From: Vikas Gupta Date: Wed, 7 Oct 2020 17:18:53 +0000 (+0530) Subject: crypto/bcmfs: introduce BCMFS driver X-Git-Url: http://git.droids-corp.org/?a=commitdiff_plain;h=c8e79da7c676;p=dpdk.git crypto/bcmfs: introduce BCMFS driver Add Broadcom FlexSparc(FS) device creation driver which registers to a vdev and create a device. Add APIs for logs, supportive documentation and maintainers file. Signed-off-by: Vikas Gupta Signed-off-by: Raveendra Padasalagi Reviewed-by: Ajit Khaparde Acked-by: Akhil Goyal --- diff --git a/MAINTAINERS b/MAINTAINERS index 3b96e8e686..9d4b0ae184 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -967,6 +967,13 @@ F: drivers/crypto/armv8/ F: doc/guides/cryptodevs/armv8.rst F: doc/guides/cryptodevs/features/armv8.ini +Broadcom FlexSparc +M: Ajit Khaparde +M: Raveendra Padasalagi +M: Vikas Gupta +F: drivers/crypto/bcmfs/ +F: doc/guides/cryptodevs/bcmfs.rst + Cavium OCTEON TX crypto M: Anoob Joseph F: drivers/common/cpt/ diff --git a/doc/guides/cryptodevs/bcmfs.rst b/doc/guides/cryptodevs/bcmfs.rst new file mode 100644 index 0000000000..0ed1a062b3 --- /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 x86 platform. + +.. code-block:: console + + cd + meson --cross-file config/arm/arm64_stingray_linux_gcc + cd + ninja + +Initialization +-------------- +The supported platform 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 d1e37583fb..5f1a01c9bc 100644 --- a/doc/guides/rel_notes/release_20_11.rst +++ b/doc/guides/rel_notes/release_20_11.rst @@ -159,6 +159,11 @@ New Features * Added support for SNOW3G-UEA2/UIA2 algorithms. * Added support for KASUMI-F8/F9 algorithms. +* **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. + * **Updated Marvell NITROX symmetric crypto PMD.** * Added AES-GCM support. diff --git a/drivers/crypto/bcmfs/bcmfs_device.c b/drivers/crypto/bcmfs/bcmfs_device.c new file mode 100644 index 0000000000..f1050ff112 --- /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 = BCMFS_SYM_FS4_VERSION + }, + { + .name = "fs5", + .suffix = "mbox", + .type = BCMFS_SYM_FS5, + .offset = 0, + .version = BCMFS_SYM_FS5_VERSION + }, + { + /* 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..1a4d0cf365 --- /dev/null +++ b/drivers/crypto/bcmfs/bcmfs_device.h @@ -0,0 +1,43 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(C) 2020 Broadcom. + * All rights reserved. + */ + +#ifndef _BCMFS_DEVICE_H_ +#define _BCMFS_DEVICE_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" + +#define BCMFS_SYM_FS4_VERSION 0x76303031 +#define BCMFS_SYM_FS5_VERSION 0x76303032 + +/* 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_DEVICE_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..4a76d1d52d --- /dev/null +++ b/drivers/crypto/bcmfs/rte_pmd_bcmfs_version.map @@ -0,0 +1,3 @@ +DPDK_21 { + 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',