From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from EUR01-HE1-obe.outbound.protection.outlook.com (mail-he1eur01on0051.outbound.protection.outlook.com [104.47.0.51]) by dpdk.org (Postfix) with ESMTP id ECAEC44C7 for ; Thu, 3 May 2018 17:52:43 +0200 (CEST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector1; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=cEBW/vtPqloUpDNWPw9uw0aJWzZeAHAGi40qzPOwQzU=; b=DLEezPUYCKb03sHmJgyTdbiXRHHnu/usemjMuTMnkJkRbjxni5+fXf+qqQD9kmnPoCap6V8DytL7a2PPQSXDa+D9WylylwZPpMKeh754DiXoSUrSGEU4ICG/ZesTiVqh+Q/4YK0kzV7o1sAZFo27t9pd8K3AAo6UnVxEQdBvsJc= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=nipun.gupta@nxp.com; Received: from b27504-OptiPlex-790.ap.freescale.net (14.142.187.166) by VI1PR0401MB2429.eurprd04.prod.outlook.com (2603:10a6:800:2a::22) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.20.715.24; Thu, 3 May 2018 15:52:41 +0000 From: Nipun Gupta To: thomas@monjalon.net, hemant.agrawal@nxp.com, shreyansh.jain@nxp.com Cc: dev@dpdk.org, Nipun Gupta Date: Thu, 3 May 2018 21:22:00 +0530 Message-Id: <1525362722-32726-7-git-send-email-nipun.gupta@nxp.com> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1525362722-32726-1-git-send-email-nipun.gupta@nxp.com> References: <1525280972-27736-1-git-send-email-nipun.gupta@nxp.com> <1525362722-32726-1-git-send-email-nipun.gupta@nxp.com> MIME-Version: 1.0 Content-Type: text/plain X-Originating-IP: [14.142.187.166] X-ClientProxiedBy: MA1PR0101CA0046.INDPRD01.PROD.OUTLOOK.COM (2603:1096:a00:22::32) To VI1PR0401MB2429.eurprd04.prod.outlook.com (2603:10a6:800:2a::22) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(7020095)(4652020)(48565401081)(5600026)(4534165)(7168020)(4627221)(201703031133081)(201702281549075)(2017052603328)(7153060)(7193020); SRVR:VI1PR0401MB2429; X-Microsoft-Exchange-Diagnostics: 1; VI1PR0401MB2429; 3:vU4eKOXZ60x1/QIPSJmSGmeFDMujdpFelGPvPO6xvHXb1fHMWs95NoJvW3Fve6M5v7dJ9x2vV0tpac4pGerYJ0ipyFq5mH851PkiAfWgKnuW/SMttnhuEbBRFbhYZE0Z2lFVIbM7vuofJbUautlMCNqzXlj4DfR/1ngXPqVicqrJ2kjY/VCvMy6mKEdWmTHpuneWtTRUVPhLWxorUN0LzYdLEvxZ1bv1/4Y9zA1gTBKSF18XogpmO4bw8NSNQ9DN; 25:EqnHVH1UgJxISb0h5LUdCTAlrRBvUoyZmeJ/0oiHcHnL6DoLcf3HOk6PNNZhUO0ofWrF9hvv756VS9INQOqSIYjs7X7qR8P4sbSQtv6eaJWqb77D+P5Gd/UtxWDTTnSmv5CZZuVSzVfwB/2ydmR0tWOihLtRB+/nLr+KDnVpyg7JC3he4Pn3bUSoQ5/godKprPr1wURhARiB1A5rPdeuJJeF2vjp2MXWhXZXfYJe1TbeS7qEjC8MTRbsqVErnY6aIpXOx+Ps3WOUv8T6Ou+G2uUHtJnmMHLOs023sU4ZNEkETwmIQDjWElkXOPJ6UD67qFAv4d2ZJanPJePqTJC2wQ==; 31:40GqlNaXGtCU/38Mtsbks7GUhUmm8oehzh7MLNkUp6pRSgQQbuqQEzXQSUCT/NP0NZVu9XiK3SB7MiOLJ9Vpe5CiyQ4hOsgaXMtV4MqUL6ayYNnBIreceQUzjO8t70vzqweYUc3/nF4znwS7zmyaboHvyq1rcKLFsHhi73KNLkqK22JZ8RW0BQCdS3oFIRsf9hFVofKHLF4S8brKO3RKrOhUMSA7wXG0J0lYbciAN2g= X-MS-TrafficTypeDiagnostic: VI1PR0401MB2429: X-Microsoft-Exchange-Diagnostics: 1; VI1PR0401MB2429; 20:XarCKqSO6nI8Od0NCpEMnLCWNEz822JeNtKnqW4l7PP8DHuTDdP8S6zAYUtGL/KAS+wB6+5htB19n9hpsb6ER656vrUOleSrnSascq/FvHYWmhaiOdOeqM49hHIXoGF2OFTN11AAmddJXV2pGY+UAKgT4vzGlzSzkCKeOdEmU6W0fr3qRM36X+Ey3Ku9mj0smIdXsjNNMMue86ikRJSC6PNqQd71YT77ftSmkiciJIe+0WoYqtGOMvSsWfFQWO20yNw+oGa8XtWYMBYnyCKCikcVGPiqKKfSxAxnw8qKwRJbUpRQoCzW7NLHCLLl1oyRyIEzddo1r4DP3Ejl/HoGgqFk8HDCq//1KB/BVQshdo4MYDQtvzv+17oU23sJKe8H4anSf73kos2EUHcMxg4cVfBry56dyzMsIyDekzHGSSyCcgracbNNoxK2sb+3LbOdy4umbrMaNjFfTbwAmYtNJBMQYUNjsncd3ZLerVr0UjMO641mOFHj8EXQqr4NXdwB; 4:vlUnIEabwFd364EZ1R07bVyVjuHnzH+3K62EX78yqYKOd1Wzp6bo+0rfh6raD5LgRzgWt5b4Nx95eBpwA6PP5kH8Teozv8biVn1KLcQm+r1v2fQoGuhVDNPiaKO1VVQNEtmOykibfVs8Vrp9d+LDsRz4txvdrVhJeO5MgfkwqqHpi+Aa/8DvvqkCwhvWD+sEpVIC5++P8H6W3riJrcaCACgZQYkarvm43rdKaChxFmdtt2D0X8+xm+dlKFbn+Fy+H+KA5zQGQGUQUeC4ipKDDsb27RguVRq58DTkCniIwtJj6prExgp5ygPL9RXmjsls X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(185117386973197); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(8211001083)(6040522)(2401047)(5005006)(8121501046)(10201501046)(93006095)(93001095)(3231254)(944501410)(52105095)(3002001)(6055026)(6041310)(20161123558120)(20161123562045)(20161123564045)(20161123560045)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(6072148)(201708071742011); SRVR:VI1PR0401MB2429; BCL:0; PCL:0; RULEID:; SRVR:VI1PR0401MB2429; X-Forefront-PRVS: 066153096A X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(376002)(366004)(396003)(39380400002)(346002)(39860400002)(199004)(189003)(6666003)(50466002)(6636002)(4326008)(68736007)(6512007)(5009440100003)(25786009)(97736004)(551934003)(6486002)(36756003)(106356001)(105586002)(2906002)(81166006)(6506007)(316002)(386003)(52116002)(59450400001)(66066001)(47776003)(86362001)(478600001)(446003)(305945005)(7736002)(48376002)(16586007)(76176011)(51416003)(55236004)(6116002)(486006)(186003)(476003)(16526019)(2616005)(11346002)(956004)(81156014)(3846002)(26005)(5660300001)(44832011)(50226002)(53936002)(8676002)(8936002)(110426005); DIR:OUT; SFP:1101; SCL:1; SRVR:VI1PR0401MB2429; H:b27504-OptiPlex-790.ap.freescale.net; FPR:; SPF:None; LANG:en; PTR:InfoNoRecords; A:1; MX:1; Received-SPF: None (protection.outlook.com: nxp.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; VI1PR0401MB2429; 23:M8ZmyvadMqKtZ3C42PkyYzasT6pgbGtucK44sa3?= =?us-ascii?Q?SQRPsM2WZcG/1UxzERPeWynEiY77AwzMtV6cw6gv9IqvM+H4sgLVZCGcsh40?= =?us-ascii?Q?+KFxMQMXAxanDrcer0zNr3bB5RB32vYuN3Lkt5JlCleQajrvV+MuKtioP5lR?= =?us-ascii?Q?unGU6fLPbH+kTPoQ3ac7psXM4/aTDC544AFcaaKfTDAreUz+hDkkLVdgyQiF?= =?us-ascii?Q?8oeG/fKcpAvN+AS29eHb7k5LjNrEXrDiBIKdgTOmuDuqo01CRxFmBbjzSPSc?= =?us-ascii?Q?WskfhVhAfMe0hEgAx/zt890MF7olmbeNKGzb+qfqqex3+E0rp9C4pmC/dt1a?= =?us-ascii?Q?9a+AaTCNrAziwaRPpneDqHh/S2SQQnX+HmqIx6tKBL8BhVle34DDCm2J7ZMS?= =?us-ascii?Q?G8jPJiZ9h7PM4mZu60eS5CliNCnK/3YP9Talh04Skz2XLyI/Lxn9vtcR7/Bv?= =?us-ascii?Q?x5xBYsASVFAKwZ+L9eiUXMYG2JW8ktlQJh2Ax8p3Lc8VfdtAzbs0ZsMdnole?= =?us-ascii?Q?m937g6JiFIeIMYsabicsfMELCCda7usiUoEB+zIXPfg1alI0+SxuAWOKwg64?= =?us-ascii?Q?ZUkXueBrhbbwqyQq3TuvLHWaiqyXjutv7ky3wmFgbegMfOyyZzH6rl0NJAo3?= =?us-ascii?Q?trXaUfnpU5q10DWBZUtVsWVMGGjlms3V+B1MmgtOvuM/NbdiHfvu0zMN0jJo?= =?us-ascii?Q?QaVt2MIPdDAGFhg/CETNw/ykYPIfVXBiUZ1PcobpkO9eNfR0aR6/AYCYjJem?= =?us-ascii?Q?eZnILqnPlZdGIcRkRfXU9F53QEWXQn+JHl4//ias4wHQav+TGj4t71tSV0yY?= =?us-ascii?Q?c2fUGKEboRSnlraeBsjF5kd5X/z9vROrog5jWI4tQ0udOOE1He2bAfI9BX+m?= =?us-ascii?Q?6+ZwIsmr4lBhGQ9MaTEvFdeNpw+vBTXamriziCXjviNVlVv5fLBX0uT3c0Fb?= =?us-ascii?Q?USTvwb14g+j8V4qY7nvYd6QBnLaNDoTpCF0cwtL9i2T2gyc/jCmlpLQ1iAmP?= =?us-ascii?Q?UpXzwaPR+3hVfjuMQxpQS6qNrghWXSexnaVb0a3ztM5cD83ksDA/eN003IHC?= =?us-ascii?Q?L3VtgMVTi+3rgk/cA8Ar2V6oqcELzUo9RWP/c9MvMgv4VKLUfRPAsaI6W+NI?= =?us-ascii?Q?9PhJh6Y7oPlNCc/7I2Ns29E1XRch/gfRRdoYmoSEYp/fk4ime9r5dwOio1Tu?= =?us-ascii?Q?OmTKiR8QBzEzUXo2Gs8F7VZMLMOd03r4C3d9PeCIU6yJZsrX6hWCoq4l1cfB?= =?us-ascii?Q?mAP0xNn7aO+dPHyJgB7NStkWFVJChMW9HYQ9+nwVk0N6jPJ/2XdyV8cYoA6Z?= =?us-ascii?Q?7clBxAwV4YFKiBlhck4w4xJ2fsr3ws4cL9xFPvpzSeNfK?= X-Microsoft-Antispam-Message-Info: LsGbdOGVcJFtA0F+15EDtPe4Nkf5XZMqnApI8ZYf7DxNTyDbbsKwBGvyvmWTt9n2mcJ87bUwTB0jq8R7LueSpRtbunC3iQvPlRNgKJR8tCTVNxF+YkiKbcEoWFKs3kjBvpnLOHdOUIQCyMOlbcHwyR5WF9jCB6o6BRqi5iZ8uX2favAyOjW8Hj2dns5dOJx3 X-Microsoft-Exchange-Diagnostics: 1; VI1PR0401MB2429; 6:BFgH7BxAREoQtxPreIkROKTTaS/6xx7hiTVcoh8mogibj/3v8t99I2YkouT1Lh1P9rVjsQyRe8W/ciXKaSSb66PLs+Ti9evj9CSrPYIwgWuL5msyBJveFuw/Xv/N0P/jZZ03I942/880SEotvyuO1QaB2jE0k3emRsS9uxtJ6RPupMfIZnW3FPRxWefRYSYaZYtMw9QR5DlaW715CYkE8kiTZjIWK0jOhvElgAhbsTVg2cUj89i98y0WzSN4sS3C1O8t7tUqVPlVjbsBQPGedqhPoAPgQ9ZjD5AN1tRaXnkDdLmhc+1Pyp7t0zfsNo2qA/M4Jp1EQTqlBirH/L+kXGD07+RJ6COyccXdfOEiEZL3CtctkLgNBv1p9b4YwtsUtHEjx/r63RPIdqHz/KxngZ6uz5cYPok5BoQPNsvOQmBJAUpXip2dvJL1pV1Wh1uMvkOvex0/xWLd3b7aMD/G8g==; 5:FPHjrPXWUbPPIU3MPehpZgBj9REQ2lysMaYYEfwN63GRisEGw4J4dkQOIrInrHufFnEVvaksyHoIPxjItCOXy+9n+Wwz2Yj6PGpo2H4rHmMwzes2BC8xw20lTvc4HwFzQ1XZ07muyU4/y3K17yURzvMXLPrKOTvfmeEieXnn7M8=; 24:zpjPFA2/oDEYmeEK226jaRq7fnoqgWjc8OOS7J2L9l8zJDjU+VmoaWP/ZVC83OTudvrfboO+INOFjHXwDZokzQFfJEz43bej19K261Gc3MI= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; VI1PR0401MB2429; 7:TN++nYE77scy5iBbjVzuWUDJPA7cHEfgOSByoGaxPePHdHItifznjV1QeQsSw2OVjj/Y0Be4k9xsLBRa1db8UInDw3O/cSRQehkrAIVRMyOk5QcVeFMOARw1H9/MnDsx2wjhtWyHk5CcAl+cgYLKDiAjbwGqbgLPGP3z9BJ3U7Ydz68xQfgLTioN0z2rMAh1JeAVLnsZR9gzDuECmS62XYjlvTSnjjGpLtRbomQU1q00oMrPFY3UtJH8FcUoNSWy X-MS-Office365-Filtering-Correlation-Id: d2213480-d730-4626-92ab-08d5b10de7d7 X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 03 May 2018 15:52:41.1244 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: d2213480-d730-4626-92ab-08d5b10de7d7 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-Transport-CrossTenantHeadersStamped: VI1PR0401MB2429 Subject: [dpdk-dev] [PATCH v7 6/8] raw/dpaa2_qdma: support configuration APIs X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 03 May 2018 15:52:44 -0000 Signed-off-by: Nipun Gupta Acked-by: Shreyansh Jain --- doc/api/doxy-api-index.md | 1 + doc/api/doxy-api.conf | 1 + drivers/raw/dpaa2_qdma/Makefile | 2 + drivers/raw/dpaa2_qdma/dpaa2_qdma.c | 375 +++++++++++++++++++++ drivers/raw/dpaa2_qdma/dpaa2_qdma.h | 63 ++++ drivers/raw/dpaa2_qdma/meson.build | 2 + drivers/raw/dpaa2_qdma/rte_pmd_dpaa2_qdma.h | 216 ++++++++++++ .../raw/dpaa2_qdma/rte_pmd_dpaa2_qdma_version.map | 12 + 8 files changed, 672 insertions(+) create mode 100644 drivers/raw/dpaa2_qdma/rte_pmd_dpaa2_qdma.h diff --git a/doc/api/doxy-api-index.md b/doc/api/doxy-api-index.md index 26ce7b4..437d903 100644 --- a/doc/api/doxy-api-index.md +++ b/doc/api/doxy-api-index.md @@ -38,6 +38,7 @@ The public API headers are grouped by topics: [i40e] (@ref rte_pmd_i40e.h), [bnxt] (@ref rte_pmd_bnxt.h), [dpaa] (@ref rte_pmd_dpaa.h), + [dpaa2_qdma] (@ref rte_pmd_dpaa2_qdma.h), [crypto_scheduler] (@ref rte_cryptodev_scheduler.h) - **memory**: diff --git a/doc/api/doxy-api.conf b/doc/api/doxy-api.conf index 5686cbb..88bee03 100644 --- a/doc/api/doxy-api.conf +++ b/doc/api/doxy-api.conf @@ -37,6 +37,7 @@ INPUT = doc/api/doxy-api-index.md \ drivers/net/i40e \ drivers/net/ixgbe \ drivers/net/softnic \ + drivers/raw/dpaa2_qdma \ lib/librte_eal/common/include \ lib/librte_eal/common/include/generic \ lib/librte_acl \ diff --git a/drivers/raw/dpaa2_qdma/Makefile b/drivers/raw/dpaa2_qdma/Makefile index 68c785a..d88809e 100644 --- a/drivers/raw/dpaa2_qdma/Makefile +++ b/drivers/raw/dpaa2_qdma/Makefile @@ -32,4 +32,6 @@ LIBABIVER := 1 # SRCS-$(CONFIG_RTE_LIBRTE_PMD_DPAA2_QDMA_RAWDEV) += dpaa2_qdma.c +SYMLINK-$(CONFIG_RTE_LIBRTE_PMD_DPAA2_QDMA_RAWDEV)-include += rte_pmd_dpaa2_qdma.h + include $(RTE_SDK)/mk/rte.lib.mk diff --git a/drivers/raw/dpaa2_qdma/dpaa2_qdma.c b/drivers/raw/dpaa2_qdma/dpaa2_qdma.c index 9288350..b38a282 100644 --- a/drivers/raw/dpaa2_qdma/dpaa2_qdma.c +++ b/drivers/raw/dpaa2_qdma/dpaa2_qdma.c @@ -20,6 +20,7 @@ #include "dpaa2_qdma.h" #include "dpaa2_qdma_logs.h" +#include "rte_pmd_dpaa2_qdma.h" /* Dynamic log type identifier */ int dpaa2_qdma_logtype; @@ -32,6 +33,380 @@ static struct qdma_hw_queue_list qdma_queue_list = TAILQ_HEAD_INITIALIZER(qdma_queue_list); +/* QDMA Virtual Queues */ +struct qdma_virt_queue *qdma_vqs; + +/* QDMA per core data */ +struct qdma_per_core_info qdma_core_info[RTE_MAX_LCORE]; + +static struct qdma_hw_queue * +alloc_hw_queue(uint32_t lcore_id) +{ + struct qdma_hw_queue *queue = NULL; + + DPAA2_QDMA_FUNC_TRACE(); + + /* Get a free queue from the list */ + TAILQ_FOREACH(queue, &qdma_queue_list, next) { + if (queue->num_users == 0) { + queue->lcore_id = lcore_id; + queue->num_users++; + break; + } + } + + return queue; +} + +static void +free_hw_queue(struct qdma_hw_queue *queue) +{ + DPAA2_QDMA_FUNC_TRACE(); + + queue->num_users--; +} + + +static struct qdma_hw_queue * +get_hw_queue(uint32_t lcore_id) +{ + struct qdma_per_core_info *core_info; + struct qdma_hw_queue *queue, *temp; + uint32_t least_num_users; + int num_hw_queues, i; + + DPAA2_QDMA_FUNC_TRACE(); + + core_info = &qdma_core_info[lcore_id]; + num_hw_queues = core_info->num_hw_queues; + + /* + * Allocate a HW queue if there are less queues + * than maximum per core queues configured + */ + if (num_hw_queues < qdma_dev.max_hw_queues_per_core) { + queue = alloc_hw_queue(lcore_id); + if (queue) { + core_info->hw_queues[num_hw_queues] = queue; + core_info->num_hw_queues++; + return queue; + } + } + + queue = core_info->hw_queues[0]; + /* In case there is no queue associated with the core return NULL */ + if (!queue) + return NULL; + + /* Fetch the least loaded H/W queue */ + least_num_users = core_info->hw_queues[0]->num_users; + for (i = 0; i < num_hw_queues; i++) { + temp = core_info->hw_queues[i]; + if (temp->num_users < least_num_users) + queue = temp; + } + + if (queue) + queue->num_users++; + + return queue; +} + +static void +put_hw_queue(struct qdma_hw_queue *queue) +{ + struct qdma_per_core_info *core_info; + int lcore_id, num_hw_queues, i; + + DPAA2_QDMA_FUNC_TRACE(); + + /* + * If this is the last user of the queue free it. + * Also remove it from QDMA core info. + */ + if (queue->num_users == 1) { + free_hw_queue(queue); + + /* Remove the physical queue from core info */ + lcore_id = queue->lcore_id; + core_info = &qdma_core_info[lcore_id]; + num_hw_queues = core_info->num_hw_queues; + for (i = 0; i < num_hw_queues; i++) { + if (queue == core_info->hw_queues[i]) + break; + } + for (; i < num_hw_queues - 1; i++) + core_info->hw_queues[i] = core_info->hw_queues[i + 1]; + core_info->hw_queues[i] = NULL; + } else { + queue->num_users--; + } +} + +int __rte_experimental +rte_qdma_init(void) +{ + DPAA2_QDMA_FUNC_TRACE(); + + rte_spinlock_init(&qdma_dev.lock); + + return 0; +} + +void __rte_experimental +rte_qdma_attr_get(struct rte_qdma_attr *qdma_attr) +{ + DPAA2_QDMA_FUNC_TRACE(); + + qdma_attr->num_hw_queues = qdma_dev.num_hw_queues; +} + +int __rte_experimental +rte_qdma_reset(void) +{ + struct qdma_hw_queue *queue; + int i; + + DPAA2_QDMA_FUNC_TRACE(); + + /* In case QDMA device is not in stopped state, return -EBUSY */ + if (qdma_dev.state == 1) { + DPAA2_QDMA_ERR( + "Device is in running state. Stop before reset."); + return -EBUSY; + } + + /* In case there are pending jobs on any VQ, return -EBUSY */ + for (i = 0; i < qdma_dev.max_vqs; i++) { + if (qdma_vqs[i].in_use && (qdma_vqs[i].num_enqueues != + qdma_vqs[i].num_dequeues)) + DPAA2_QDMA_ERR("Jobs are still pending on VQ: %d", i); + return -EBUSY; + } + + /* Reset HW queues */ + TAILQ_FOREACH(queue, &qdma_queue_list, next) + queue->num_users = 0; + + /* Reset and free virtual queues */ + for (i = 0; i < qdma_dev.max_vqs; i++) { + if (qdma_vqs[i].status_ring) + rte_ring_free(qdma_vqs[i].status_ring); + } + if (qdma_vqs) + rte_free(qdma_vqs); + qdma_vqs = NULL; + + /* Reset per core info */ + memset(&qdma_core_info, 0, + sizeof(struct qdma_per_core_info) * RTE_MAX_LCORE); + + /* Free the FLE pool */ + if (qdma_dev.fle_pool) + rte_mempool_free(qdma_dev.fle_pool); + + /* Reset QDMA device structure */ + qdma_dev.mode = RTE_QDMA_MODE_HW; + qdma_dev.max_hw_queues_per_core = 0; + qdma_dev.fle_pool = NULL; + qdma_dev.fle_pool_count = 0; + qdma_dev.max_vqs = 0; + + return 0; +} + +int __rte_experimental +rte_qdma_configure(struct rte_qdma_config *qdma_config) +{ + int ret; + + DPAA2_QDMA_FUNC_TRACE(); + + /* In case QDMA device is not in stopped state, return -EBUSY */ + if (qdma_dev.state == 1) { + DPAA2_QDMA_ERR( + "Device is in running state. Stop before config."); + return -1; + } + + /* Reset the QDMA device */ + ret = rte_qdma_reset(); + if (ret) { + DPAA2_QDMA_ERR("Resetting QDMA failed"); + return ret; + } + + /* Set mode */ + qdma_dev.mode = qdma_config->mode; + + /* Set max HW queue per core */ + if (qdma_config->max_hw_queues_per_core > MAX_HW_QUEUE_PER_CORE) { + DPAA2_QDMA_ERR("H/W queues per core is more than: %d", + MAX_HW_QUEUE_PER_CORE); + return -EINVAL; + } + qdma_dev.max_hw_queues_per_core = + qdma_config->max_hw_queues_per_core; + + /* Allocate Virtual Queues */ + qdma_vqs = rte_malloc("qdma_virtual_queues", + (sizeof(struct qdma_virt_queue) * qdma_config->max_vqs), + RTE_CACHE_LINE_SIZE); + if (!qdma_vqs) { + DPAA2_QDMA_ERR("qdma_virtual_queues allocation failed"); + return -ENOMEM; + } + qdma_dev.max_vqs = qdma_config->max_vqs; + + /* Allocate FLE pool */ + qdma_dev.fle_pool = rte_mempool_create("qdma_fle_pool", + qdma_config->fle_pool_count, QDMA_FLE_POOL_SIZE, + QDMA_FLE_CACHE_SIZE(qdma_config->fle_pool_count), 0, + NULL, NULL, NULL, NULL, SOCKET_ID_ANY, 0); + if (!qdma_dev.fle_pool) { + DPAA2_QDMA_ERR("qdma_fle_pool create failed"); + rte_free(qdma_vqs); + qdma_vqs = NULL; + return -ENOMEM; + } + qdma_dev.fle_pool_count = qdma_config->fle_pool_count; + + return 0; +} + +int __rte_experimental +rte_qdma_start(void) +{ + DPAA2_QDMA_FUNC_TRACE(); + + qdma_dev.state = 1; + + return 0; +} + +int __rte_experimental +rte_qdma_vq_create(uint32_t lcore_id, uint32_t flags) +{ + char ring_name[32]; + int i; + + DPAA2_QDMA_FUNC_TRACE(); + + rte_spinlock_lock(&qdma_dev.lock); + + /* Get a free Virtual Queue */ + for (i = 0; i < qdma_dev.max_vqs; i++) { + if (qdma_vqs[i].in_use == 0) + break; + } + + /* Return in case no VQ is free */ + if (i == qdma_dev.max_vqs) { + rte_spinlock_unlock(&qdma_dev.lock); + return -ENODEV; + } + + if (qdma_dev.mode == RTE_QDMA_MODE_HW || + (flags & RTE_QDMA_VQ_EXCLUSIVE_PQ)) { + /* Allocate HW queue for a VQ */ + qdma_vqs[i].hw_queue = alloc_hw_queue(lcore_id); + qdma_vqs[i].exclusive_hw_queue = 1; + } else { + /* Allocate a Ring for Virutal Queue in VQ mode */ + sprintf(ring_name, "status ring %d", i); + qdma_vqs[i].status_ring = rte_ring_create(ring_name, + qdma_dev.fle_pool_count, rte_socket_id(), 0); + if (!qdma_vqs[i].status_ring) { + DPAA2_QDMA_ERR("Status ring creation failed for vq"); + rte_spinlock_unlock(&qdma_dev.lock); + return rte_errno; + } + + /* Get a HW queue (shared) for a VQ */ + qdma_vqs[i].hw_queue = get_hw_queue(lcore_id); + qdma_vqs[i].exclusive_hw_queue = 0; + } + + if (qdma_vqs[i].hw_queue == NULL) { + DPAA2_QDMA_ERR("No H/W queue available for VQ"); + if (qdma_vqs[i].status_ring) + rte_ring_free(qdma_vqs[i].status_ring); + qdma_vqs[i].status_ring = NULL; + rte_spinlock_unlock(&qdma_dev.lock); + return -ENODEV; + } + + qdma_vqs[i].in_use = 1; + qdma_vqs[i].lcore_id = lcore_id; + + rte_spinlock_unlock(&qdma_dev.lock); + + return i; +} + +void __rte_experimental +rte_qdma_vq_stats(uint16_t vq_id, + struct rte_qdma_vq_stats *vq_status) +{ + struct qdma_virt_queue *qdma_vq = &qdma_vqs[vq_id]; + + DPAA2_QDMA_FUNC_TRACE(); + + if (qdma_vq->in_use) { + vq_status->exclusive_hw_queue = qdma_vq->exclusive_hw_queue; + vq_status->lcore_id = qdma_vq->lcore_id; + vq_status->num_enqueues = qdma_vq->num_enqueues; + vq_status->num_dequeues = qdma_vq->num_dequeues; + vq_status->num_pending_jobs = vq_status->num_enqueues - + vq_status->num_dequeues; + } +} + +int __rte_experimental +rte_qdma_vq_destroy(uint16_t vq_id) +{ + struct qdma_virt_queue *qdma_vq = &qdma_vqs[vq_id]; + + DPAA2_QDMA_FUNC_TRACE(); + + /* In case there are pending jobs on any VQ, return -EBUSY */ + if (qdma_vq->num_enqueues != qdma_vq->num_dequeues) + return -EBUSY; + + rte_spinlock_lock(&qdma_dev.lock); + + if (qdma_vq->exclusive_hw_queue) + free_hw_queue(qdma_vq->hw_queue); + else { + if (qdma_vqs->status_ring) + rte_ring_free(qdma_vqs->status_ring); + + put_hw_queue(qdma_vq->hw_queue); + } + + memset(qdma_vq, 0, sizeof(struct qdma_virt_queue)); + + rte_spinlock_lock(&qdma_dev.lock); + + return 0; +} + +void __rte_experimental +rte_qdma_stop(void) +{ + DPAA2_QDMA_FUNC_TRACE(); + + qdma_dev.state = 0; +} + +void __rte_experimental +rte_qdma_destroy(void) +{ + DPAA2_QDMA_FUNC_TRACE(); + + rte_qdma_reset(); +} + static const struct rte_rawdev_ops dpaa2_qdma_ops; static int diff --git a/drivers/raw/dpaa2_qdma/dpaa2_qdma.h b/drivers/raw/dpaa2_qdma/dpaa2_qdma.h index 8b3b1b9..fe1da41 100644 --- a/drivers/raw/dpaa2_qdma/dpaa2_qdma.h +++ b/drivers/raw/dpaa2_qdma/dpaa2_qdma.h @@ -5,6 +5,22 @@ #ifndef __DPAA2_QDMA_H__ #define __DPAA2_QDMA_H__ +struct qdma_sdd; +struct qdma_io_meta; + +#define DPAA2_QDMA_MAX_FLE 3 +#define DPAA2_QDMA_MAX_SDD 2 + +/** FLE pool size: 3 Frame list + 2 source/destination descriptor */ +#define QDMA_FLE_POOL_SIZE (sizeof(struct qdma_io_meta) + \ + sizeof(struct qbman_fle) * DPAA2_QDMA_MAX_FLE + \ + sizeof(struct qdma_sdd) * DPAA2_QDMA_MAX_SDD) +/** FLE pool cache size */ +#define QDMA_FLE_CACHE_SIZE(_num) (_num/(RTE_MAX_LCORE * 2)) + +/** Maximum possible H/W Queues on each core */ +#define MAX_HW_QUEUE_PER_CORE 64 + /** * Represents a QDMA device. * A single QDMA device exists which is combination of multiple DPDMAI rawdev's. @@ -45,6 +61,53 @@ struct qdma_hw_queue { uint32_t num_users; }; +/** Represents a QDMA virtual queue */ +struct qdma_virt_queue { + /** Status ring of the virtual queue */ + struct rte_ring *status_ring; + /** Associated hw queue */ + struct qdma_hw_queue *hw_queue; + /** Associated lcore id */ + uint32_t lcore_id; + /** States if this vq is in use or not */ + uint8_t in_use; + /** States if this vq has exclusively associated hw queue */ + uint8_t exclusive_hw_queue; + /* Total number of enqueues on this VQ */ + uint64_t num_enqueues; + /* Total number of dequeues from this VQ */ + uint64_t num_dequeues; +}; + +/** Represents a QDMA per core hw queues allocation in virtual mode */ +struct qdma_per_core_info { + /** list for allocated hw queues */ + struct qdma_hw_queue *hw_queues[MAX_HW_QUEUE_PER_CORE]; + /* Number of hw queues allocated for this core */ + uint16_t num_hw_queues; +}; + +/** Metadata which is stored with each operation */ +struct qdma_io_meta { + /** + * Context which is stored in the FLE pool (just before the FLE). + * QDMA job is stored as a this context as a part of metadata. + */ + uint64_t cnxt; + /** VQ ID is stored as a part of metadata of the enqueue command */ + uint64_t id; +}; + +/** Source/Destination Descriptor */ +struct qdma_sdd { + uint32_t rsv; + /** Stride configuration */ + uint32_t stride; + /** Route-by-port command */ + uint32_t rbpcmd; + uint32_t cmd; +} __attribute__((__packed__)); + /** Represents a DPDMAI raw device */ struct dpaa2_dpdmai_dev { /** Pointer to Next device instance */ diff --git a/drivers/raw/dpaa2_qdma/meson.build b/drivers/raw/dpaa2_qdma/meson.build index b747500..a2eb1d2 100644 --- a/drivers/raw/dpaa2_qdma/meson.build +++ b/drivers/raw/dpaa2_qdma/meson.build @@ -5,3 +5,5 @@ deps += ['rawdev', 'mempool_dpaa2', 'ring'] sources = files('dpaa2_qdma.c') allow_experimental_apis = true + +install_headers('rte_pmd_dpaa2_qdma.h') diff --git a/drivers/raw/dpaa2_qdma/rte_pmd_dpaa2_qdma.h b/drivers/raw/dpaa2_qdma/rte_pmd_dpaa2_qdma.h new file mode 100644 index 0000000..29a1e4b --- /dev/null +++ b/drivers/raw/dpaa2_qdma/rte_pmd_dpaa2_qdma.h @@ -0,0 +1,216 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright 2018 NXP + */ + +#ifndef __RTE_PMD_DPAA2_QDMA_H__ +#define __RTE_PMD_DPAA2_QDMA_H__ + +/** + * @file + * + * NXP dpaa2 QDMA specific structures. + * + */ + +/** Determines the mode of operation */ +enum { + /** + * Allocate a H/W queue per VQ i.e. Exclusive hardware queue for a VQ. + * This mode will have best performance. + */ + RTE_QDMA_MODE_HW, + /** + * A VQ shall not have an exclusive associated H/W queue. + * Rather a H/W Queue will be shared by multiple Virtual Queues. + * This mode will have intermediate data structures to support + * multi VQ to PQ mappings thus having some performance implications. + * Note: Even in this mode there is an option to allocate a H/W + * queue for a VQ. Please see 'RTE_QDMA_VQ_EXCLUSIVE_PQ' flag. + */ + RTE_QDMA_MODE_VIRTUAL +}; + +/** + * If user has configued a Virtual Queue mode, but for some particular VQ + * user needs an exclusive H/W queue associated (for better performance + * on that particular VQ), then user can pass this flag while creating the + * Virtual Queue. A H/W queue will be allocated corresponding to + * VQ which uses this flag. + */ +#define RTE_QDMA_VQ_EXCLUSIVE_PQ (1ULL) + +/** States if the source addresses is physical. */ +#define RTE_QDMA_JOB_SRC_PHY (1ULL) + +/** States if the destination addresses is physical. */ +#define RTE_QDMA_JOB_DEST_PHY (1ULL << 1) + +/** Provides QDMA device attributes */ +struct rte_qdma_attr { + /** total number of hw QDMA queues present */ + uint16_t num_hw_queues; +}; + +/** QDMA device configuration structure */ +struct rte_qdma_config { + /** Number of maximum hw queues to allocate per core. */ + uint16_t max_hw_queues_per_core; + /** Maximum number of VQ's to be used. */ + uint16_t max_vqs; + /** mode of operation - physical(h/w) or virtual */ + uint8_t mode; + /** + * User provides this as input to the driver as a size of the FLE pool. + * FLE's (and corresponding source/destination descriptors) are + * allocated by the driver at enqueue time to store src/dest and + * other data and are freed at the dequeue time. This determines the + * maximum number of inflight jobs on the QDMA device. This should + * be power of 2. + */ + int fle_pool_count; +}; + +/** Provides QDMA device statistics */ +struct rte_qdma_vq_stats { + /** States if this vq has exclusively associated hw queue */ + uint8_t exclusive_hw_queue; + /** Associated lcore id */ + uint32_t lcore_id; + /* Total number of enqueues on this VQ */ + uint64_t num_enqueues; + /* Total number of dequeues from this VQ */ + uint64_t num_dequeues; + /* total number of pending jobs in this VQ */ + uint64_t num_pending_jobs; +}; + +/** Determines a QDMA job */ +struct rte_qdma_job { + /** Source Address from where DMA is (to be) performed */ + uint64_t src; + /** Destination Address where DMA is (to be) done */ + uint64_t dest; + /** Length of the DMA operation in bytes. */ + uint32_t len; + /** See RTE_QDMA_JOB_ flags */ + uint32_t flags; + /** + * User can specify a context which will be maintained + * on the dequeue operation. + */ + uint64_t cnxt; + /** + * Status of the transaction. + * This is filled in the dequeue operation by the driver. + */ + uint8_t status; +}; + +/** + * Initialize the QDMA device. + * + * @returns + * - 0: Success. + * - <0: Error code. + */ +int __rte_experimental +rte_qdma_init(void); + +/** + * Get the QDMA attributes. + * + * @param qdma_attr + * QDMA attributes providing total number of hw queues etc. + */ +void __rte_experimental +rte_qdma_attr_get(struct rte_qdma_attr *qdma_attr); + +/** + * Reset the QDMA device. This API will completely reset the QDMA + * device, bringing it to original state as if only rte_qdma_init() API + * has been called. + * + * @returns + * - 0: Success. + * - <0: Error code. + */ +int __rte_experimental +rte_qdma_reset(void); + +/** + * Configure the QDMA device. + * + * @returns + * - 0: Success. + * - <0: Error code. + */ +int __rte_experimental +rte_qdma_configure(struct rte_qdma_config *qdma_config); + +/** + * Start the QDMA device. + * + * @returns + * - 0: Success. + * - <0: Error code. + */ +int __rte_experimental +rte_qdma_start(void); + +/** + * Create a Virtual Queue on a particular lcore id. + * This API can be called from any thread/core. User can create/destroy + * VQ's at runtime. + * + * @param lcore_id + * LCORE ID on which this particular queue would be associated with. + * @param flags + * RTE_QDMA_VQ_ flags. See macro definitions. + * + * @returns + * - >= 0: Virtual queue ID. + * - <0: Error code. + */ +int __rte_experimental +rte_qdma_vq_create(uint32_t lcore_id, uint32_t flags); + +/** + * Get a Virtual Queue statistics. + * + * @param vq_id + * Virtual Queue ID. + * @param vq_stats + * VQ statistics structure which will be filled in by the driver. + */ +void __rte_experimental +rte_qdma_vq_stats(uint16_t vq_id, + struct rte_qdma_vq_stats *vq_stats); + +/** + * Destroy the Virtual Queue specified by vq_id. + * This API can be called from any thread/core. User can create/destroy + * VQ's at runtime. + * + * @param vq_id + * Virtual Queue ID which needs to be deinialized. + * + * @returns + * - 0: Success. + * - <0: Error code. + */ +int __rte_experimental +rte_qdma_vq_destroy(uint16_t vq_id); + +/** + * Stop QDMA device. + */ +void __rte_experimental +rte_qdma_stop(void); + +/** + * Destroy the QDMA device. + */ +void __rte_experimental +rte_qdma_destroy(void); + +#endif /* __RTE_PMD_DPAA2_QDMA_H__*/ diff --git a/drivers/raw/dpaa2_qdma/rte_pmd_dpaa2_qdma_version.map b/drivers/raw/dpaa2_qdma/rte_pmd_dpaa2_qdma_version.map index 33d2379..7335c35 100644 --- a/drivers/raw/dpaa2_qdma/rte_pmd_dpaa2_qdma_version.map +++ b/drivers/raw/dpaa2_qdma/rte_pmd_dpaa2_qdma_version.map @@ -1,4 +1,16 @@ EXPERIMENTAL { + global: + + rte_qdma_attr_get; + rte_qdma_configure; + rte_qdma_destroy; + rte_qdma_init; + rte_qdma_reset; + rte_qdma_start; + rte_qdma_stop; + rte_qdma_vq_create; + rte_qdma_vq_destroy; + rte_qdma_vq_stats; local: *; }; -- 1.9.1