From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 1D8A2A04B1; Mon, 5 Oct 2020 18:28:09 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 841581BA57; Mon, 5 Oct 2020 18:27:21 +0200 (CEST) Received: from mail-pj1-f66.google.com (mail-pj1-f66.google.com [209.85.216.66]) by dpdk.org (Postfix) with ESMTP id 0CF391B81B for ; Mon, 5 Oct 2020 18:27:19 +0200 (CEST) Received: by mail-pj1-f66.google.com with SMTP id t7so68906pjd.3 for ; Mon, 05 Oct 2020 09:27:18 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=broadcom.com; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=wZyZJzJM9no2dhBqBudDg7OJkRyJBk28T4wh6gIij+U=; b=WmEZylH4lz+B5SRBTZlQVxhr9GpnXObp0j4IrXYFvimzivglY0oL6GD2dWaYhEt9C5 W8iHCByzCsUv3Ns+TVY+y8lmXJfyRhY72ukkW50RNVrueV5n5QX4Snap2b7WZBXDUNx7 BlNm7bcR0hrQHuqba+HUXu61VTYNLJYeOEsUc= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=wZyZJzJM9no2dhBqBudDg7OJkRyJBk28T4wh6gIij+U=; b=EmZ5xQWFjLIdS0NXFDph3bq0gCY19ozC8xuwDUFT1tC/gcyuonJCkbA4Ym06aXIRvW rm7xncblsw+2emyUie08YUR0WZoLjd8waPUmOXGuha/Wr5NaghFLhxNKU3N0PE8Wxb0x UBsfMMi2cYwNHkuF1QxQHujMGKHLeb0yHiPRGNZeDAspFNM3aIKHKVF9bfv7qHkzTxem pG/NNsM5pLwluyQuvAkVYpZaP7A30ZCCnMR70r486XOMpE4Zg2/RD+JoDfO07g4cC6oK +qe/hzQuEWxeb+36wHm9QeoLJqim3mN7JOStfR7LBbxDC1PT2iGUQxB1dE6cQylJYE2O 6Ltw== X-Gm-Message-State: AOAM5331CVQSv9RYSsDl1FigT5iOf2D7NrOm5gtEKO0QwGJ+OwkS8VCh 12fH/aXNaKTpq4UkuN9NrfWHKtCOK6cm4GTy2b9XmR0yWdfOevZ/133G5v51hXDQU4stWsoYBYP ZRBpCM2rD5E4v+mRNgrd9OJ+MPfTam3thODjCM+XNGlNCpHkLd80UUGqLdh/C X-Google-Smtp-Source: ABdhPJzBt9NnlvipSwa/IahG+AWZdGa7DKaB8IDFhXZAnfsfeHCqt0/3vWs0TfkEauu/aIhwD9F+ng== X-Received: by 2002:a17:90b:224a:: with SMTP id hk10mr234854pjb.4.1601915233589; Mon, 05 Oct 2020 09:27:13 -0700 (PDT) Received: from rahul_yocto_ubuntu18.ibn.broadcom.net ([192.19.234.250]) by smtp.gmail.com with ESMTPSA id d129sm378061pfc.161.2020.10.05.09.27.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 05 Oct 2020 09:27:13 -0700 (PDT) From: Vikas Gupta To: dev@dpdk.org, akhil.goyal@nxp.com Cc: vikram.prakash@broadcom.com, Vikas Gupta , Raveendra Padasalagi Date: Mon, 5 Oct 2020 21:56:51 +0530 Message-Id: <20201005162658.12416-2-vikas.gupta@broadcom.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20201005162658.12416-1-vikas.gupta@broadcom.com> References: <20200813172344.3228-1-vikas.gupta@broadcom.com> <20201005162658.12416-1-vikas.gupta@broadcom.com> Content-Type: text/plain X-Content-Filtered-By: Mailman/MimeDel 2.1.15 Subject: [dpdk-dev] [PATCH v3 1/8] crypto/bcmfs: add BCMFS driver 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: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Add Broadcom FlexSparc(FS) device creation driver which registers to a vdev and create a device. Add APIs for logs, supportive documention and maintainers file. Signed-off-by: Vikas Gupta Signed-off-by: Raveendra Padasalagi Reviewed-by: Ajit Khaparde --- MAINTAINERS | 7 + doc/guides/cryptodevs/bcmfs.rst | 51 ++++ doc/guides/cryptodevs/index.rst | 1 + doc/guides/rel_notes/release_20_11.rst | 5 + drivers/crypto/bcmfs/bcmfs_device.c | 257 ++++++++++++++++++ drivers/crypto/bcmfs/bcmfs_device.h | 40 +++ drivers/crypto/bcmfs/bcmfs_logs.c | 38 +++ drivers/crypto/bcmfs/bcmfs_logs.h | 34 +++ drivers/crypto/bcmfs/meson.build | 10 + .../crypto/bcmfs/rte_pmd_bcmfs_version.map | 3 + drivers/crypto/meson.build | 1 + 11 files changed, 447 insertions(+) create mode 100644 doc/guides/cryptodevs/bcmfs.rst create mode 100644 drivers/crypto/bcmfs/bcmfs_device.c create mode 100644 drivers/crypto/bcmfs/bcmfs_device.h create mode 100644 drivers/crypto/bcmfs/bcmfs_logs.c create mode 100644 drivers/crypto/bcmfs/bcmfs_logs.h create mode 100644 drivers/crypto/bcmfs/meson.build create mode 100644 drivers/crypto/bcmfs/rte_pmd_bcmfs_version.map diff --git a/MAINTAINERS b/MAINTAINERS index c0abbe0fc8..ab849ac1d1 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1081,6 +1081,13 @@ F: drivers/crypto/zuc/ F: doc/guides/cryptodevs/zuc.rst F: doc/guides/cryptodevs/features/zuc.ini +Broadcom FlexSparc +M: Vikas Gupta +M: Raveendra Padasalagi +M: Ajit Khaparde +F: drivers/crypto/bcmfs/ +F: doc/guides/cryptodevs/bcmfs.rst +F: doc/guides/cryptodevs/features/bcmfs.ini Compression Drivers ------------------- diff --git a/doc/guides/cryptodevs/bcmfs.rst b/doc/guides/cryptodevs/bcmfs.rst new file mode 100644 index 0000000000..dc21bf60cc --- /dev/null +++ b/doc/guides/cryptodevs/bcmfs.rst @@ -0,0 +1,51 @@ +.. SPDX-License-Identifier: BSD-3-Clause + Copyright(C) 2020 Broadcom + +Broadcom FlexSparc Crypto Poll Mode Driver +========================================== + +The FlexSparc crypto poll mode driver (BCMFS PMD) provides support for offloading +cryptographic operations to the Broadcom SoCs having FlexSparc4/FlexSparc5 unit. +Detailed information about SoCs can be found at `Broadcom Official Website +`__. + +Supported Broadcom SoCs +----------------------- + +* Stingray +* Stingray2 + +Installation +------------ +Information about kernel, rootfs and toolchain can be found at +`Broadcom Official Website `__. + + .. Note:: + To execute BCMFS PMD, it must be compiled with VFIO_PRESENT flag on the + compiling platform and same gets enabled in rte_vfio.h. + +The BCMFS crypto PMD may be compiled natively on a Stingray/Stingray2 platform or +cross-compiled on an x86 platform. For example, below commands can be executed +for cross compiling on on x86 platform. + +.. code-block:: console + + cd + meson --cross-file config/arm/arm64_stingray_linux_gcc + cd + ninja + +Initialization +-------------- +The supported platfom devices should be present in the +*/sys/bus/platform/devices/fs/* path on the booted kernel. +To get BCMFS PMD executing, device node must be owned by VFIO platform module only. +For example, below commands can be run to get hold of a device node by VFIO. + +.. code-block:: console + + SETUP_SYSFS_DEV_NAME=67000000.crypto_mbox + io_device_name="vfio-platform" + echo $io_device_name > /sys/bus/platform/devices/${SETUP_SYSFS_DEV_NAME}/driver_override + echo ${SETUP_SYSFS_DEV_NAME} > /sys/bus/platform/drivers_probe diff --git a/doc/guides/cryptodevs/index.rst b/doc/guides/cryptodevs/index.rst index a67ed5a282..279f56a002 100644 --- a/doc/guides/cryptodevs/index.rst +++ b/doc/guides/cryptodevs/index.rst @@ -13,6 +13,7 @@ Crypto Device Drivers aesni_mb aesni_gcm armv8 + bcmfs caam_jr ccp dpaa2_sec diff --git a/doc/guides/rel_notes/release_20_11.rst b/doc/guides/rel_notes/release_20_11.rst index 73ac08fb0e..8643330321 100644 --- a/doc/guides/rel_notes/release_20_11.rst +++ b/doc/guides/rel_notes/release_20_11.rst @@ -185,3 +185,8 @@ Tested Platforms This section is a comment. Do not overwrite or remove it. Also, make sure to start the actual text at the margin. ======================================================= + +* **Added Broadcom BCMFS symmetric crypto PMD.** + + Added a symmetric crypto PMD for Broadcom FlexSparc crypto units. + See :doc:`../cryptodevs/bcmfs` guide for more details on this new PMD. diff --git a/drivers/crypto/bcmfs/bcmfs_device.c b/drivers/crypto/bcmfs/bcmfs_device.c new file mode 100644 index 0000000000..c9865ee6a5 --- /dev/null +++ b/drivers/crypto/bcmfs/bcmfs_device.c @@ -0,0 +1,257 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(C) 2020 Broadcom. + * All rights reserved. + */ + +#include +#include +#include + +#include +#include + +#include "bcmfs_device.h" +#include "bcmfs_logs.h" + +struct bcmfs_device_attr { + const char name[BCMFS_MAX_PATH_LEN]; + const char suffix[BCMFS_DEV_NAME_LEN]; + const enum bcmfs_device_type type; + const uint32_t offset; + const uint32_t version; +}; + +/* BCMFS supported devices */ +static struct bcmfs_device_attr dev_table[] = { + { + .name = "fs4", + .suffix = "crypto_mbox", + .type = BCMFS_SYM_FS4, + .offset = 0, + .version = 0x76303031 + }, + { + .name = "fs5", + .suffix = "mbox", + .type = BCMFS_SYM_FS5, + .offset = 0, + .version = 0x76303032 + }, + { + /* sentinel */ + } +}; + +TAILQ_HEAD(fsdev_list, bcmfs_device); +static struct fsdev_list fsdev_list = TAILQ_HEAD_INITIALIZER(fsdev_list); + +static struct bcmfs_device * +fsdev_allocate_one_dev(struct rte_vdev_device *vdev, + char *dirpath, + char *devname, + enum bcmfs_device_type dev_type __rte_unused) +{ + struct bcmfs_device *fsdev; + + fsdev = rte_calloc(__func__, 1, sizeof(*fsdev), 0); + if (!fsdev) + return NULL; + + if (strlen(dirpath) > sizeof(fsdev->dirname)) { + BCMFS_LOG(ERR, "dir path name is too long"); + goto cleanup; + } + + if (strlen(devname) > sizeof(fsdev->name)) { + BCMFS_LOG(ERR, "devname is too long"); + goto cleanup; + } + + strcpy(fsdev->dirname, dirpath); + strcpy(fsdev->name, devname); + + fsdev->vdev = vdev; + + TAILQ_INSERT_TAIL(&fsdev_list, fsdev, next); + + return fsdev; + +cleanup: + free(fsdev); + + return NULL; +} + +static struct bcmfs_device * +find_fsdev(struct rte_vdev_device *vdev) +{ + struct bcmfs_device *fsdev; + + TAILQ_FOREACH(fsdev, &fsdev_list, next) + if (fsdev->vdev == vdev) + return fsdev; + + return NULL; +} + +static void +fsdev_release(struct bcmfs_device *fsdev) +{ + if (fsdev == NULL) + return; + + TAILQ_REMOVE(&fsdev_list, fsdev, next); + free(fsdev); +} + +static int +cmprator(const void *a, const void *b) +{ + return (*(const unsigned int *)a - *(const unsigned int *)b); +} + +static int +fsdev_find_all_devs(const char *path, const char *search, + uint32_t *devs) +{ + DIR *dir; + struct dirent *entry; + int count = 0; + char addr[BCMFS_MAX_NODES][BCMFS_MAX_PATH_LEN]; + int i; + + dir = opendir(path); + if (dir == NULL) { + BCMFS_LOG(ERR, "Unable to open directory"); + return 0; + } + + while ((entry = readdir(dir)) != NULL) { + if (strstr(entry->d_name, search)) { + strlcpy(addr[count], entry->d_name, + BCMFS_MAX_PATH_LEN); + count++; + } + } + + closedir(dir); + + for (i = 0 ; i < count; i++) + devs[i] = (uint32_t)strtoul(addr[i], NULL, 16); + /* sort the devices based on IO addresses */ + qsort(devs, count, sizeof(uint32_t), cmprator); + + return count; +} + +static bool +fsdev_find_sub_dir(char *path, const char *search, char *output) +{ + DIR *dir; + struct dirent *entry; + + dir = opendir(path); + if (dir == NULL) { + BCMFS_LOG(ERR, "Unable to open directory"); + return -ENODEV; + } + + while ((entry = readdir(dir)) != NULL) { + if (!strcmp(entry->d_name, search)) { + strlcpy(output, entry->d_name, BCMFS_MAX_PATH_LEN); + closedir(dir); + return true; + } + } + + closedir(dir); + + return false; +} + + +static int +bcmfs_vdev_probe(struct rte_vdev_device *vdev) +{ + struct bcmfs_device *fsdev; + char top_dirpath[BCMFS_MAX_PATH_LEN]; + char sub_dirpath[BCMFS_MAX_PATH_LEN]; + char out_dirpath[BCMFS_MAX_PATH_LEN]; + char out_dirname[BCMFS_MAX_PATH_LEN]; + uint32_t fsdev_dev[BCMFS_MAX_NODES]; + enum bcmfs_device_type dtype; + int i = 0; + int dev_idx; + int count = 0; + bool found = false; + + sprintf(top_dirpath, "%s", SYSFS_BCM_PLTFORM_DEVICES); + while (strlen(dev_table[i].name)) { + found = fsdev_find_sub_dir(top_dirpath, + dev_table[i].name, + sub_dirpath); + if (found) + break; + i++; + } + if (!found) { + BCMFS_LOG(ERR, "No supported bcmfs dev found"); + return -ENODEV; + } + + dev_idx = i; + dtype = dev_table[i].type; + + snprintf(out_dirpath, sizeof(out_dirpath), "%s/%s", + top_dirpath, sub_dirpath); + count = fsdev_find_all_devs(out_dirpath, + dev_table[dev_idx].suffix, + fsdev_dev); + if (!count) { + BCMFS_LOG(ERR, "No supported bcmfs dev found"); + return -ENODEV; + } + + i = 0; + while (count) { + /* format the device name present in the patch */ + snprintf(out_dirname, sizeof(out_dirname), "%x.%s", + fsdev_dev[i], dev_table[dev_idx].suffix); + fsdev = fsdev_allocate_one_dev(vdev, out_dirpath, + out_dirname, dtype); + if (!fsdev) { + count--; + i++; + continue; + } + break; + } + if (fsdev == NULL) { + BCMFS_LOG(ERR, "All supported devs busy"); + return -ENODEV; + } + + return 0; +} + +static int +bcmfs_vdev_remove(struct rte_vdev_device *vdev) +{ + struct bcmfs_device *fsdev; + + fsdev = find_fsdev(vdev); + if (fsdev == NULL) + return -ENODEV; + + fsdev_release(fsdev); + return 0; +} + +/* Register with vdev */ +static struct rte_vdev_driver rte_bcmfs_pmd = { + .probe = bcmfs_vdev_probe, + .remove = bcmfs_vdev_remove +}; + +RTE_PMD_REGISTER_VDEV(bcmfs_pmd, + rte_bcmfs_pmd); diff --git a/drivers/crypto/bcmfs/bcmfs_device.h b/drivers/crypto/bcmfs/bcmfs_device.h new file mode 100644 index 0000000000..cc64a8df2c --- /dev/null +++ b/drivers/crypto/bcmfs/bcmfs_device.h @@ -0,0 +1,40 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(C) 2020 Broadcom. + * All rights reserved. + */ + +#ifndef _BCMFS_DEV_H_ +#define _BCMFS_DEV_H_ + +#include + +#include + +#include "bcmfs_logs.h" + +/* max number of dev nodes */ +#define BCMFS_MAX_NODES 4 +#define BCMFS_MAX_PATH_LEN 512 +#define BCMFS_DEV_NAME_LEN 64 + +/* Path for BCM-Platform device directory */ +#define SYSFS_BCM_PLTFORM_DEVICES "/sys/bus/platform/devices" + +/* Supported devices */ +enum bcmfs_device_type { + BCMFS_SYM_FS4, + BCMFS_SYM_FS5, + BCMFS_UNKNOWN +}; + +struct bcmfs_device { + TAILQ_ENTRY(bcmfs_device) next; + /* Directory path for vfio */ + char dirname[BCMFS_MAX_PATH_LEN]; + /* BCMFS device name */ + char name[BCMFS_DEV_NAME_LEN]; + /* Parent vdev */ + struct rte_vdev_device *vdev; +}; + +#endif /* _BCMFS_DEV_H_ */ diff --git a/drivers/crypto/bcmfs/bcmfs_logs.c b/drivers/crypto/bcmfs/bcmfs_logs.c new file mode 100644 index 0000000000..86f4ff3b53 --- /dev/null +++ b/drivers/crypto/bcmfs/bcmfs_logs.c @@ -0,0 +1,38 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Broadcom + * All rights reserved. + */ + +#include +#include + +#include "bcmfs_logs.h" + +int bcmfs_conf_logtype; +int bcmfs_dp_logtype; + +int +bcmfs_hexdump_log(uint32_t level, uint32_t logtype, const char *title, + const void *buf, unsigned int len) +{ + if (level > rte_log_get_global_level()) + return 0; + if (level > (uint32_t)(rte_log_get_level(logtype))) + return 0; + + rte_hexdump(rte_log_get_stream(), title, buf, len); + return 0; +} + +RTE_INIT(bcmfs_device_init_log) +{ + /* Configuration and general logs */ + bcmfs_conf_logtype = rte_log_register("pmd.bcmfs_config"); + if (bcmfs_conf_logtype >= 0) + rte_log_set_level(bcmfs_conf_logtype, RTE_LOG_NOTICE); + + /* data-path logs */ + bcmfs_dp_logtype = rte_log_register("pmd.bcmfs_fp"); + if (bcmfs_dp_logtype >= 0) + rte_log_set_level(bcmfs_dp_logtype, RTE_LOG_NOTICE); +} diff --git a/drivers/crypto/bcmfs/bcmfs_logs.h b/drivers/crypto/bcmfs/bcmfs_logs.h new file mode 100644 index 0000000000..c03a49b75c --- /dev/null +++ b/drivers/crypto/bcmfs/bcmfs_logs.h @@ -0,0 +1,34 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Broadcom + * All rights reserved. + */ + +#ifndef _BCMFS_LOGS_H_ +#define _BCMFS_LOGS_H_ + +#include + +extern int bcmfs_conf_logtype; +extern int bcmfs_dp_logtype; + +#define BCMFS_LOG(level, fmt, args...) \ + rte_log(RTE_LOG_ ## level, bcmfs_conf_logtype, \ + "%s(): " fmt "\n", __func__, ## args) + +#define BCMFS_DP_LOG(level, fmt, args...) \ + rte_log(RTE_LOG_ ## level, bcmfs_dp_logtype, \ + "%s(): " fmt "\n", __func__, ## args) + +#define BCMFS_DP_HEXDUMP_LOG(level, title, buf, len) \ + bcmfs_hexdump_log(RTE_LOG_ ## level, bcmfs_dp_logtype, title, buf, len) + +/** + * bcmfs_hexdump_log Dump out memory in a special hex dump format. + * + * The message will be sent to the stream used by the rte_log infrastructure. + */ +int +bcmfs_hexdump_log(uint32_t level, uint32_t logtype, const char *heading, + const void *buf, unsigned int len); + +#endif /* _BCMFS_LOGS_H_ */ diff --git a/drivers/crypto/bcmfs/meson.build b/drivers/crypto/bcmfs/meson.build new file mode 100644 index 0000000000..a4bdd8ee5d --- /dev/null +++ b/drivers/crypto/bcmfs/meson.build @@ -0,0 +1,10 @@ +# SPDX-License-Identifier: BSD-3-Clause +# Copyright(C) 2020 Broadcom +# All rights reserved. +# + +deps += ['eal', 'bus_vdev'] +sources = files( + 'bcmfs_logs.c', + 'bcmfs_device.c' + ) diff --git a/drivers/crypto/bcmfs/rte_pmd_bcmfs_version.map b/drivers/crypto/bcmfs/rte_pmd_bcmfs_version.map new file mode 100644 index 0000000000..299ae632da --- /dev/null +++ b/drivers/crypto/bcmfs/rte_pmd_bcmfs_version.map @@ -0,0 +1,3 @@ +DPDK_21.0 { + local: *; +}; diff --git a/drivers/crypto/meson.build b/drivers/crypto/meson.build index a2423507ad..93c2968acb 100644 --- a/drivers/crypto/meson.build +++ b/drivers/crypto/meson.build @@ -8,6 +8,7 @@ endif drivers = ['aesni_gcm', 'aesni_mb', 'armv8', + 'bcmfs', 'caam_jr', 'ccp', 'dpaa_sec', -- 2.17.1