/* SPDX-License-Identifier: BSD-3-Clause
*
- * Copyright 2016,2018 NXP
+ * Copyright 2016,2018-2019 NXP
*
*/
#include <rte_log.h>
#include <rte_bus.h>
-#include <rte_eal_memconfig.h>
#include <rte_malloc.h>
#include <rte_devargs.h>
#include <rte_memcpy.h>
uint32_t
rte_fslmc_get_device_count(enum rte_dpaa2_dev_type device_type)
{
- if (device_type > DPAA2_DEVTYPE_MAX)
+ if (device_type >= DPAA2_DEVTYPE_MAX)
return 0;
return rte_fslmc_bus.device_count[device_type];
}
dump_device_list(void)
{
struct rte_dpaa2_device *dev;
- uint32_t global_log_level;
- int local_log_level;
/* Only if the log level has been set to Debugging, print list */
- global_log_level = rte_log_get_global_level();
- local_log_level = rte_log_get_level(dpaa2_logtype_bus);
- if (global_log_level == RTE_LOG_DEBUG ||
- local_log_level == RTE_LOG_DEBUG) {
+ if (rte_log_can_log(dpaa2_logtype_bus, RTE_LOG_DEBUG)) {
DPAA2_BUS_LOG(DEBUG, "List of devices scanned on bus:");
TAILQ_FOREACH(dev, &rte_fslmc_bus.device_list, next) {
DPAA2_BUS_LOG(DEBUG, "\t\t%s", dev->device.name);
scan_one_fslmc_device(char *dev_name)
{
char *dup_dev_name, *t_ptr;
- struct rte_dpaa2_device *dev;
+ struct rte_dpaa2_device *dev = NULL;
+ int ret = -1;
if (!dev_name)
- return -1;
+ return ret;
/* Ignore the Container name itself */
if (!strncmp("dprc", dev_name, 4))
/* Parse the device name and ID */
t_ptr = strtok(dup_dev_name, ".");
if (!t_ptr) {
- DPAA2_BUS_ERR("Incorrect device name observed");
+ DPAA2_BUS_ERR("Invalid device found: (%s)", dup_dev_name);
+ ret = -EINVAL;
goto cleanup;
}
if (!strncmp("dpni", t_ptr, 4))
dev->dev_type = DPAA2_QDMA;
else if (!strncmp("dpdmux", t_ptr, 6))
dev->dev_type = DPAA2_MUX;
+ else if (!strncmp("dprtc", t_ptr, 5))
+ dev->dev_type = DPAA2_DPRTC;
else
dev->dev_type = DPAA2_UNKNOWN;
- /* Update the device found into the device_count table */
- rte_fslmc_bus.device_count[dev->dev_type]++;
-
t_ptr = strtok(NULL, ".");
if (!t_ptr) {
- DPAA2_BUS_ERR("Incorrect device string observed (null)");
+ DPAA2_BUS_ERR("Skipping invalid device (%s)", dup_dev_name);
+ ret = 0;
goto cleanup;
}
dev->device.name = strdup(dev_name);
if (!dev->device.name) {
DPAA2_BUS_ERR("Unable to clone device name. Out of memory");
+ ret = -ENOMEM;
goto cleanup;
}
dev->device.devargs = fslmc_devargs_lookup(dev);
+ /* Update the device found into the device_count table */
+ rte_fslmc_bus.device_count[dev->dev_type]++;
+
/* Add device in the fslmc device list */
insert_in_device_list(dev);
free(dup_dev_name);
if (dev)
free(dev);
- return -1;
+ return ret;
}
static int
{
uint16_t dev_id;
char *t_ptr;
+ const char *sep;
+ uint8_t sep_exists = 0;
+ int ret = -1;
+
+ DPAA2_BUS_DEBUG("Parsing dev=(%s)", name);
- /* 'name' is expected to contain name of device, for example, dpio.1,
- * dpni.2, etc.
+ /* There are multiple ways this can be called, with bus:dev, name=dev
+ * or just dev. In all cases, the 'addr' is actually a string.
*/
- if (strncmp("dpni", name, 4) &&
- strncmp("dpseci", name, 6) &&
- strncmp("dpcon", name, 5) &&
- strncmp("dpbp", name, 4) &&
- strncmp("dpio", name, 4) &&
- strncmp("dpci", name, 4) &&
- strncmp("dpmcp", name, 5) &&
- strncmp("dpdmai", name, 6) &&
- strncmp("dpdmux", name, 6)) {
- DPAA2_BUS_DEBUG("Unknown or unsupported device (%s)", name);
+ sep = strchr(name, ':');
+ if (!sep) {
+ /* check for '=' */
+ sep = strchr(name, '=');
+ if (!sep)
+ sep_exists = 0;
+ else
+ sep_exists = 1;
+ } else
+ sep_exists = 1;
+
+ /* Check if starting part if either of 'fslmc:' or 'name=', separator
+ * exists.
+ */
+ if (sep_exists) {
+ /* If either of "fslmc" or "name" are starting part */
+ if (!strncmp(name, RTE_STR(FSLMC_BUS_NAME),
+ strlen(RTE_STR(FSLMC_BUS_NAME))) ||
+ (!strncmp(name, "name", strlen("name")))) {
+ goto jump_out;
+ } else {
+ DPAA2_BUS_DEBUG("Invalid device for matching (%s).",
+ name);
+ ret = -EINVAL;
+ goto err_out;
+ }
+ } else
+ sep = name;
+
+jump_out:
+ /* Validate device name */
+ if (strncmp("dpni", sep, 4) &&
+ strncmp("dpseci", sep, 6) &&
+ strncmp("dpcon", sep, 5) &&
+ strncmp("dpbp", sep, 4) &&
+ strncmp("dpio", sep, 4) &&
+ strncmp("dpci", sep, 4) &&
+ strncmp("dpmcp", sep, 5) &&
+ strncmp("dpdmai", sep, 6) &&
+ strncmp("dpdmux", sep, 6)) {
+ DPAA2_BUS_DEBUG("Unknown or unsupported device (%s)", sep);
+ ret = -EINVAL;
goto err_out;
}
- t_ptr = strchr(name, '.');
+ t_ptr = strchr(sep, '.');
if (!t_ptr || sscanf(t_ptr + 1, "%hu", &dev_id) != 1) {
- DPAA2_BUS_ERR("Missing device id in device name (%s)", name);
+ DPAA2_BUS_ERR("Missing device id in device name (%s)", sep);
+ ret = -EINVAL;
goto err_out;
}
if (addr)
- strcpy(addr, name);
+ strcpy(addr, sep);
- return 0;
+ ret = 0;
err_out:
- return -EINVAL;
+ return ret;
}
static int
goto scan_fail;
/* Scan devices on the group */
- snprintf(fslmc_dirpath, sizeof(fslmc_dirpath), "%s/%d/devices",
- VFIO_IOMMU_GROUP_PATH, groupid);
+ sprintf(fslmc_dirpath, "%s/%s", SYSFS_FSL_MC_DEVICES, fslmc_container);
dir = opendir(fslmc_dirpath);
if (!dir) {
DPAA2_BUS_ERR("Unable to open VFIO group directory");
}
while ((entry = readdir(dir)) != NULL) {
- if (entry->d_name[0] == '.' || entry->d_type != DT_LNK)
+ if (entry->d_name[0] == '.' || entry->d_type != DT_DIR)
continue;
ret = scan_one_fslmc_device(entry->d_name);
/* Remove all devices in the list */
cleanup_fslmc_device_list();
scan_fail:
- DPAA2_BUS_DEBUG("FSLMC Bus Not Available. Skipping");
+ DPAA2_BUS_DEBUG("FSLMC Bus Not Available. Skipping (%d)", ret);
/* Irrespective of failure, scan only return success */
return 0;
}
/* Map existing segments as well as, in case of hotpluggable memory,
* install callback handler.
*/
- ret = rte_fslmc_vfio_dmamap();
- if (ret) {
- DPAA2_BUS_ERR("Unable to DMA map existing VAs: (%d)", ret);
- /* Not continuing ahead */
- DPAA2_BUS_ERR("FSLMC VFIO Mapping failed");
- return 0;
+ if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
+ ret = rte_fslmc_vfio_dmamap();
+ if (ret) {
+ DPAA2_BUS_ERR("Unable to DMA map existing VAs: (%d)",
+ ret);
+ /* Not continuing ahead */
+ DPAA2_BUS_ERR("FSLMC VFIO Mapping failed");
+ return 0;
+ }
}
ret = fslmc_vfio_process_group();
*
* Error is ignored as relevant logs are handled within dpaax and
* handling for unavailable dpaax table too is transparent to caller.
+ *
+ * And, the IOVA table is only applicable in case of PA mode.
*/
- dpaax_iova_table_populate();
+ if (rte_eal_iova_mode() == RTE_IOVA_PA)
+ dpaax_iova_table_populate();
TAILQ_FOREACH(dev, &rte_fslmc_bus.device_list, next) {
TAILQ_FOREACH(drv, &rte_fslmc_bus.driver_list, next) {
const struct rte_dpaa2_device *dstart;
struct rte_dpaa2_device *dev;
+ DPAA2_BUS_DEBUG("Finding a device named %s\n", (const char *)data);
+
+ /* find_device is always called with an opaque object which should be
+ * passed along to the 'cmp' function iterating over all device obj
+ * on the bus.
+ */
+
if (start != NULL) {
dstart = RTE_DEV_TO_FSLMC_CONST(start);
dev = TAILQ_NEXT(dstart, next);
dev = TAILQ_FIRST(&rte_fslmc_bus.device_list);
}
while (dev != NULL) {
- if (cmp(&dev->device, data) == 0)
+ if (cmp(&dev->device, data) == 0) {
+ DPAA2_BUS_DEBUG("Found device (%s)\n",
+ dev->device.name);
return &dev->device;
+ }
dev = TAILQ_NEXT(dev, next);
}
/* Cleanup the PA->VA Translation table; From whereever this function
* is called from.
*/
- dpaax_iova_table_depopulate();
+ if (rte_eal_iova_mode() == RTE_IOVA_PA)
+ dpaax_iova_table_depopulate();
TAILQ_REMOVE(&fslmc_bus->driver_list, driver, next);
/* Update Bus references */
return RTE_IOVA_PA;
}
+static int
+fslmc_bus_plug(struct rte_device *dev __rte_unused)
+{
+ /* No operation is performed while plugging the device */
+ return 0;
+}
+
+static int
+fslmc_bus_unplug(struct rte_device *dev __rte_unused)
+{
+ /* No operation is performed while unplugging the device */
+ return 0;
+}
+
+static void *
+fslmc_bus_dev_iterate(const void *start, const char *str,
+ const struct rte_dev_iterator *it __rte_unused)
+{
+ const struct rte_dpaa2_device *dstart;
+ struct rte_dpaa2_device *dev;
+ char *dup, *dev_name = NULL;
+
+ /* Expectation is that device would be name=device_name */
+ if (strncmp(str, "name=", 5) != 0) {
+ DPAA2_BUS_DEBUG("Invalid device string (%s)\n", str);
+ return NULL;
+ }
+
+ /* Now that name=device_name format is available, split */
+ dup = strdup(str);
+ dev_name = dup + strlen("name=");
+
+ if (start != NULL) {
+ dstart = RTE_DEV_TO_FSLMC_CONST(start);
+ dev = TAILQ_NEXT(dstart, next);
+ } else {
+ dev = TAILQ_FIRST(&rte_fslmc_bus.device_list);
+ }
+
+ while (dev != NULL) {
+ if (strcmp(dev->device.name, dev_name) == 0) {
+ free(dup);
+ return &dev->device;
+ }
+ dev = TAILQ_NEXT(dev, next);
+ }
+
+ free(dup);
+ return NULL;
+}
+
struct rte_fslmc_bus rte_fslmc_bus = {
.bus = {
.scan = rte_fslmc_scan,
.parse = rte_fslmc_parse,
.find_device = rte_fslmc_find_device,
.get_iommu_class = rte_dpaa2_get_iommu_class,
+ .plug = fslmc_bus_plug,
+ .unplug = fslmc_bus_unplug,
+ .dev_iterate = fslmc_bus_dev_iterate,
},
.device_list = TAILQ_HEAD_INITIALIZER(rte_fslmc_bus.device_list),
.driver_list = TAILQ_HEAD_INITIALIZER(rte_fslmc_bus.driver_list),
projects / ceph.git / blobdiff