From 2c3c1048746a4622d8c89a29670120dc8fab93c4 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:49:45 +0200 Subject: Adding upstream version 6.1.76. Signed-off-by: Daniel Baumann --- drivers/mcb/Kconfig | 41 ++++ drivers/mcb/Makefile | 9 + drivers/mcb/mcb-core.c | 517 +++++++++++++++++++++++++++++++++++++++++++++ drivers/mcb/mcb-internal.h | 128 +++++++++++ drivers/mcb/mcb-lpc.c | 189 +++++++++++++++++ drivers/mcb/mcb-parse.c | 259 +++++++++++++++++++++++ drivers/mcb/mcb-pci.c | 157 ++++++++++++++ 7 files changed, 1300 insertions(+) create mode 100644 drivers/mcb/Kconfig create mode 100644 drivers/mcb/Makefile create mode 100644 drivers/mcb/mcb-core.c create mode 100644 drivers/mcb/mcb-internal.h create mode 100644 drivers/mcb/mcb-lpc.c create mode 100644 drivers/mcb/mcb-parse.c create mode 100644 drivers/mcb/mcb-pci.c (limited to 'drivers/mcb') diff --git a/drivers/mcb/Kconfig b/drivers/mcb/Kconfig new file mode 100644 index 000000000..0a883486f --- /dev/null +++ b/drivers/mcb/Kconfig @@ -0,0 +1,41 @@ +# SPDX-License-Identifier: GPL-2.0-only +# +# MEN Chameleon Bus (MCB) support +# + +menuconfig MCB + tristate "MCB support" + default n + depends on HAS_IOMEM + help + + The MCB (MEN Chameleon Bus) is a Bus specific to MEN Mikroelektronik + FPGA based devices. It is used to identify MCB based IP-Cores within + an FPGA and provide the necessary framework for instantiating drivers + for these devices. + + If build as a module, the module is called mcb.ko + +if MCB +config MCB_PCI + tristate "PCI based MCB carrier" + default n + depends on PCI + help + + This is a MCB carrier on a PCI device. Both PCI attached on-board + FPGAs as well as CompactPCI attached MCB FPGAs are supported with + this driver. + + If build as a module, the module is called mcb-pci.ko + +config MCB_LPC + tristate "LPC (non PCI) based MCB carrier" + default n + help + + This is a MCB carrier on a LPC or non PCI device. + + If build as a module, the module is called mcb-lpc.ko + +endif # MCB diff --git a/drivers/mcb/Makefile b/drivers/mcb/Makefile new file mode 100644 index 000000000..77073c592 --- /dev/null +++ b/drivers/mcb/Makefile @@ -0,0 +1,9 @@ +# SPDX-License-Identifier: GPL-2.0 + +obj-$(CONFIG_MCB) += mcb.o + +mcb-y += mcb-core.o +mcb-y += mcb-parse.o + +obj-$(CONFIG_MCB_PCI) += mcb-pci.o +obj-$(CONFIG_MCB_LPC) += mcb-lpc.o diff --git a/drivers/mcb/mcb-core.c b/drivers/mcb/mcb-core.c new file mode 100644 index 000000000..a6b4ccc31 --- /dev/null +++ b/drivers/mcb/mcb-core.c @@ -0,0 +1,517 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * MEN Chameleon Bus. + * + * Copyright (C) 2013 MEN Mikroelektronik GmbH (www.men.de) + * Author: Johannes Thumshirn + */ +#include +#include +#include +#include +#include +#include + +static DEFINE_IDA(mcb_ida); + +static const struct mcb_device_id *mcb_match_id(const struct mcb_device_id *ids, + struct mcb_device *dev) +{ + if (ids) { + while (ids->device) { + if (ids->device == dev->id) + return ids; + ids++; + } + } + + return NULL; +} + +static int mcb_match(struct device *dev, struct device_driver *drv) +{ + struct mcb_driver *mdrv = to_mcb_driver(drv); + struct mcb_device *mdev = to_mcb_device(dev); + const struct mcb_device_id *found_id; + + found_id = mcb_match_id(mdrv->id_table, mdev); + if (found_id) + return 1; + + return 0; +} + +static int mcb_uevent(struct device *dev, struct kobj_uevent_env *env) +{ + struct mcb_device *mdev = to_mcb_device(dev); + int ret; + + ret = add_uevent_var(env, "MODALIAS=mcb:16z%03d", mdev->id); + if (ret) + return -ENOMEM; + + return 0; +} + +static int mcb_probe(struct device *dev) +{ + struct mcb_driver *mdrv = to_mcb_driver(dev->driver); + struct mcb_device *mdev = to_mcb_device(dev); + const struct mcb_device_id *found_id; + struct module *carrier_mod; + int ret; + + found_id = mcb_match_id(mdrv->id_table, mdev); + if (!found_id) + return -ENODEV; + + carrier_mod = mdev->dev.parent->driver->owner; + if (!try_module_get(carrier_mod)) + return -EINVAL; + + get_device(dev); + ret = mdrv->probe(mdev, found_id); + if (ret) { + module_put(carrier_mod); + put_device(dev); + } + + return ret; +} + +static void mcb_remove(struct device *dev) +{ + struct mcb_driver *mdrv = to_mcb_driver(dev->driver); + struct mcb_device *mdev = to_mcb_device(dev); + struct module *carrier_mod; + + mdrv->remove(mdev); + + carrier_mod = mdev->dev.parent->driver->owner; + module_put(carrier_mod); + + put_device(&mdev->dev); +} + +static void mcb_shutdown(struct device *dev) +{ + struct mcb_driver *mdrv = to_mcb_driver(dev->driver); + struct mcb_device *mdev = to_mcb_device(dev); + + if (mdrv && mdrv->shutdown) + mdrv->shutdown(mdev); +} + +static ssize_t revision_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct mcb_bus *bus = to_mcb_bus(dev); + + return scnprintf(buf, PAGE_SIZE, "%d\n", bus->revision); +} +static DEVICE_ATTR_RO(revision); + +static ssize_t model_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct mcb_bus *bus = to_mcb_bus(dev); + + return scnprintf(buf, PAGE_SIZE, "%c\n", bus->model); +} +static DEVICE_ATTR_RO(model); + +static ssize_t minor_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct mcb_bus *bus = to_mcb_bus(dev); + + return scnprintf(buf, PAGE_SIZE, "%d\n", bus->minor); +} +static DEVICE_ATTR_RO(minor); + +static ssize_t name_show(struct device *dev, struct device_attribute *attr, + char *buf) +{ + struct mcb_bus *bus = to_mcb_bus(dev); + + return scnprintf(buf, PAGE_SIZE, "%s\n", bus->name); +} +static DEVICE_ATTR_RO(name); + +static struct attribute *mcb_bus_attrs[] = { + &dev_attr_revision.attr, + &dev_attr_model.attr, + &dev_attr_minor.attr, + &dev_attr_name.attr, + NULL, +}; + +static const struct attribute_group mcb_carrier_group = { + .attrs = mcb_bus_attrs, +}; + +static const struct attribute_group *mcb_carrier_groups[] = { + &mcb_carrier_group, + NULL, +}; + + +static struct bus_type mcb_bus_type = { + .name = "mcb", + .match = mcb_match, + .uevent = mcb_uevent, + .probe = mcb_probe, + .remove = mcb_remove, + .shutdown = mcb_shutdown, +}; + +static struct device_type mcb_carrier_device_type = { + .name = "mcb-carrier", + .groups = mcb_carrier_groups, +}; + +/** + * __mcb_register_driver() - Register a @mcb_driver at the system + * @drv: The @mcb_driver + * @owner: The @mcb_driver's module + * @mod_name: The name of the @mcb_driver's module + * + * Register a @mcb_driver at the system. Perform some sanity checks, if + * the .probe and .remove methods are provided by the driver. + */ +int __mcb_register_driver(struct mcb_driver *drv, struct module *owner, + const char *mod_name) +{ + if (!drv->probe || !drv->remove) + return -EINVAL; + + drv->driver.owner = owner; + drv->driver.bus = &mcb_bus_type; + drv->driver.mod_name = mod_name; + + return driver_register(&drv->driver); +} +EXPORT_SYMBOL_NS_GPL(__mcb_register_driver, MCB); + +/** + * mcb_unregister_driver() - Unregister a @mcb_driver from the system + * @drv: The @mcb_driver + * + * Unregister a @mcb_driver from the system. + */ +void mcb_unregister_driver(struct mcb_driver *drv) +{ + driver_unregister(&drv->driver); +} +EXPORT_SYMBOL_NS_GPL(mcb_unregister_driver, MCB); + +static void mcb_release_dev(struct device *dev) +{ + struct mcb_device *mdev = to_mcb_device(dev); + + mcb_bus_put(mdev->bus); + kfree(mdev); +} + +/** + * mcb_device_register() - Register a mcb_device + * @bus: The @mcb_bus of the device + * @dev: The @mcb_device + * + * Register a specific @mcb_device at a @mcb_bus and the system itself. + */ +int mcb_device_register(struct mcb_bus *bus, struct mcb_device *dev) +{ + int ret; + int device_id; + + device_initialize(&dev->dev); + mcb_bus_get(bus); + dev->dev.bus = &mcb_bus_type; + dev->dev.parent = bus->dev.parent; + dev->dev.release = mcb_release_dev; + dev->dma_dev = bus->carrier; + + device_id = dev->id; + dev_set_name(&dev->dev, "mcb%d-16z%03d-%d:%d:%d", + bus->bus_nr, device_id, dev->inst, dev->group, dev->var); + + ret = device_add(&dev->dev); + if (ret < 0) { + pr_err("Failed registering device 16z%03d on bus mcb%d (%d)\n", + device_id, bus->bus_nr, ret); + goto out; + } + + return 0; + +out: + put_device(&dev->dev); + + return ret; +} +EXPORT_SYMBOL_NS_GPL(mcb_device_register, MCB); + +static void mcb_free_bus(struct device *dev) +{ + struct mcb_bus *bus = to_mcb_bus(dev); + + put_device(bus->carrier); + ida_free(&mcb_ida, bus->bus_nr); + kfree(bus); +} + +/** + * mcb_alloc_bus() - Allocate a new @mcb_bus + * + * Allocate a new @mcb_bus. + */ +struct mcb_bus *mcb_alloc_bus(struct device *carrier) +{ + struct mcb_bus *bus; + int bus_nr; + int rc; + + bus = kzalloc(sizeof(struct mcb_bus), GFP_KERNEL); + if (!bus) + return ERR_PTR(-ENOMEM); + + bus_nr = ida_alloc(&mcb_ida, GFP_KERNEL); + if (bus_nr < 0) { + kfree(bus); + return ERR_PTR(bus_nr); + } + + bus->bus_nr = bus_nr; + bus->carrier = get_device(carrier); + + device_initialize(&bus->dev); + bus->dev.parent = carrier; + bus->dev.bus = &mcb_bus_type; + bus->dev.type = &mcb_carrier_device_type; + bus->dev.release = &mcb_free_bus; + + dev_set_name(&bus->dev, "mcb:%d", bus_nr); + rc = device_add(&bus->dev); + if (rc) + goto err_put; + + return bus; + +err_put: + put_device(&bus->dev); + return ERR_PTR(rc); +} +EXPORT_SYMBOL_NS_GPL(mcb_alloc_bus, MCB); + +static int __mcb_devices_unregister(struct device *dev, void *data) +{ + device_unregister(dev); + return 0; +} + +static void mcb_devices_unregister(struct mcb_bus *bus) +{ + bus_for_each_dev(&mcb_bus_type, NULL, NULL, __mcb_devices_unregister); +} +/** + * mcb_release_bus() - Free a @mcb_bus + * @bus: The @mcb_bus to release + * + * Release an allocated @mcb_bus from the system. + */ +void mcb_release_bus(struct mcb_bus *bus) +{ + mcb_devices_unregister(bus); +} +EXPORT_SYMBOL_NS_GPL(mcb_release_bus, MCB); + +/** + * mcb_bus_put() - Increment refcnt + * @bus: The @mcb_bus + * + * Get a @mcb_bus' ref + */ +struct mcb_bus *mcb_bus_get(struct mcb_bus *bus) +{ + if (bus) + get_device(&bus->dev); + + return bus; +} +EXPORT_SYMBOL_NS_GPL(mcb_bus_get, MCB); + +/** + * mcb_bus_put() - Decrement refcnt + * @bus: The @mcb_bus + * + * Release a @mcb_bus' ref + */ +void mcb_bus_put(struct mcb_bus *bus) +{ + if (bus) + put_device(&bus->dev); +} +EXPORT_SYMBOL_NS_GPL(mcb_bus_put, MCB); + +/** + * mcb_alloc_dev() - Allocate a device + * @bus: The @mcb_bus the device is part of + * + * Allocate a @mcb_device and add bus. + */ +struct mcb_device *mcb_alloc_dev(struct mcb_bus *bus) +{ + struct mcb_device *dev; + + dev = kzalloc(sizeof(struct mcb_device), GFP_KERNEL); + if (!dev) + return NULL; + + dev->bus = bus; + + return dev; +} +EXPORT_SYMBOL_NS_GPL(mcb_alloc_dev, MCB); + +/** + * mcb_free_dev() - Free @mcb_device + * @dev: The device to free + * + * Free a @mcb_device + */ +void mcb_free_dev(struct mcb_device *dev) +{ + kfree(dev); +} +EXPORT_SYMBOL_NS_GPL(mcb_free_dev, MCB); + +static int __mcb_bus_add_devices(struct device *dev, void *data) +{ + int retval; + + retval = device_attach(dev); + if (retval < 0) { + dev_err(dev, "Error adding device (%d)\n", retval); + return retval; + } + + return 0; +} + +/** + * mcb_bus_add_devices() - Add devices in the bus' internal device list + * @bus: The @mcb_bus we add the devices + * + * Add devices in the bus' internal device list to the system. + */ +void mcb_bus_add_devices(const struct mcb_bus *bus) +{ + bus_for_each_dev(&mcb_bus_type, NULL, NULL, __mcb_bus_add_devices); +} +EXPORT_SYMBOL_NS_GPL(mcb_bus_add_devices, MCB); + +/** + * mcb_get_resource() - get a resource for a mcb device + * @dev: the mcb device + * @type: the type of resource + */ +struct resource *mcb_get_resource(struct mcb_device *dev, unsigned int type) +{ + if (type == IORESOURCE_MEM) + return &dev->mem; + else if (type == IORESOURCE_IRQ) + return &dev->irq; + else + return NULL; +} +EXPORT_SYMBOL_NS_GPL(mcb_get_resource, MCB); + +/** + * mcb_request_mem() - Request memory + * @dev: The @mcb_device the memory is for + * @name: The name for the memory reference. + * + * Request memory for a @mcb_device. If @name is NULL the driver name will + * be used. + */ +struct resource *mcb_request_mem(struct mcb_device *dev, const char *name) +{ + struct resource *mem; + u32 size; + + if (!name) + name = dev->dev.driver->name; + + size = resource_size(&dev->mem); + + mem = request_mem_region(dev->mem.start, size, name); + if (!mem) + return ERR_PTR(-EBUSY); + + return mem; +} +EXPORT_SYMBOL_NS_GPL(mcb_request_mem, MCB); + +/** + * mcb_release_mem() - Release memory requested by device + * @dev: The @mcb_device that requested the memory + * + * Release memory that was prior requested via @mcb_request_mem(). + */ +void mcb_release_mem(struct resource *mem) +{ + u32 size; + + size = resource_size(mem); + release_mem_region(mem->start, size); +} +EXPORT_SYMBOL_NS_GPL(mcb_release_mem, MCB); + +static int __mcb_get_irq(struct mcb_device *dev) +{ + struct resource *irq; + + irq = mcb_get_resource(dev, IORESOURCE_IRQ); + + return irq->start; +} + +/** + * mcb_get_irq() - Get device's IRQ number + * @dev: The @mcb_device the IRQ is for + * + * Get the IRQ number of a given @mcb_device. + */ +int mcb_get_irq(struct mcb_device *dev) +{ + struct mcb_bus *bus = dev->bus; + + if (bus->get_irq) + return bus->get_irq(dev); + + return __mcb_get_irq(dev); +} +EXPORT_SYMBOL_NS_GPL(mcb_get_irq, MCB); + +static int mcb_init(void) +{ + return bus_register(&mcb_bus_type); +} + +static void mcb_exit(void) +{ + ida_destroy(&mcb_ida); + bus_unregister(&mcb_bus_type); +} + +/* mcb must be initialized after PCI but before the chameleon drivers. + * That means we must use some initcall between subsys_initcall and + * device_initcall. + */ +fs_initcall(mcb_init); +module_exit(mcb_exit); + +MODULE_DESCRIPTION("MEN Chameleon Bus Driver"); +MODULE_AUTHOR("Johannes Thumshirn "); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/mcb/mcb-internal.h b/drivers/mcb/mcb-internal.h new file mode 100644 index 000000000..3602cb3b2 --- /dev/null +++ b/drivers/mcb/mcb-internal.h @@ -0,0 +1,128 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __MCB_INTERNAL +#define __MCB_INTERNAL + +#include + +#define PCI_VENDOR_ID_MEN 0x1a88 +#define PCI_DEVICE_ID_MEN_CHAMELEON 0x4d45 +#define CHAMELEONV2_MAGIC 0xabce +#define CHAM_HEADER_SIZE 0x200 + +enum chameleon_descriptor_type { + CHAMELEON_DTYPE_GENERAL = 0x0, + CHAMELEON_DTYPE_BRIDGE = 0x1, + CHAMELEON_DTYPE_CPU = 0x2, + CHAMELEON_DTYPE_BAR = 0x3, + CHAMELEON_DTYPE_END = 0xf, +}; + +enum chameleon_bus_type { + CHAMELEON_BUS_WISHBONE, + CHAMELEON_BUS_AVALON, + CHAMELEON_BUS_LPC, + CHAMELEON_BUS_ISA, +}; + +/** + * struct chameleon_fpga_header + * + * @revision: Revison of Chameleon table in FPGA + * @model: Chameleon table model ASCII char + * @minor: Revision minor + * @bus_type: Bus type (usually %CHAMELEON_BUS_WISHBONE) + * @magic: Chameleon header magic number (0xabce for version 2) + * @reserved: Reserved + * @filename: Filename of FPGA bitstream + */ +struct chameleon_fpga_header { + u8 revision; + char model; + u8 minor; + u8 bus_type; + u16 magic; + u16 reserved; + /* This one has no '\0' at the end!!! */ + char filename[CHAMELEON_FILENAME_LEN]; +} __packed; +#define HEADER_MAGIC_OFFSET 0x4 + +/** + * struct chameleon_gdd - Chameleon General Device Descriptor + * + * @irq: the position in the FPGA's IRQ controller vector + * @rev: the revision of the variant's implementation + * @var: the variant of the IP core + * @dev: the device the IP core is + * @dtype: device descriptor type + * @bar: BAR offset that must be added to module offset + * @inst: the instance number of the device, 0 is first instance + * @group: the group the device belongs to (0 = no group) + * @reserved: reserved + * @offset: beginning of the address window of desired module + * @size: size of the module's address window + */ +struct chameleon_gdd { + __le32 reg1; + __le32 reg2; + __le32 offset; + __le32 size; + +} __packed; + +/* GDD Register 1 fields */ +#define GDD_IRQ(x) ((x) & 0x1f) +#define GDD_REV(x) (((x) >> 5) & 0x3f) +#define GDD_VAR(x) (((x) >> 11) & 0x3f) +#define GDD_DEV(x) (((x) >> 18) & 0x3ff) +#define GDD_DTY(x) (((x) >> 28) & 0xf) + +/* GDD Register 2 fields */ +#define GDD_BAR(x) ((x) & 0x7) +#define GDD_INS(x) (((x) >> 3) & 0x3f) +#define GDD_GRP(x) (((x) >> 9) & 0x3f) + +/** + * struct chameleon_bdd - Chameleon Bridge Device Descriptor + * + * @irq: the position in the FPGA's IRQ controller vector + * @rev: the revision of the variant's implementation + * @var: the variant of the IP core + * @dev: the device the IP core is + * @dtype: device descriptor type + * @bar: BAR offset that must be added to module offset + * @inst: the instance number of the device, 0 is first instance + * @dbar: destination bar from the bus _behind_ the bridge + * @chamoff: offset within the BAR of the source bus + * @offset: + * @size: + */ +struct chameleon_bdd { + unsigned int irq:6; + unsigned int rev:6; + unsigned int var:6; + unsigned int dev:10; + unsigned int dtype:4; + unsigned int bar:3; + unsigned int inst:6; + unsigned int dbar:3; + unsigned int group:6; + unsigned int reserved:14; + u32 chamoff; + u32 offset; + u32 size; +} __packed; + +struct chameleon_bar { + u32 addr; + u32 size; +}; + +#define BAR_CNT(x) ((x) & 0x07) +#define CHAMELEON_BAR_MAX 6 +#define BAR_DESC_SIZE(x) ((x) * sizeof(struct chameleon_bar) + sizeof(__le32)) + +int chameleon_parse_cells(struct mcb_bus *bus, phys_addr_t mapbase, + void __iomem *base); + +#endif diff --git a/drivers/mcb/mcb-lpc.c b/drivers/mcb/mcb-lpc.c new file mode 100644 index 000000000..a851e0236 --- /dev/null +++ b/drivers/mcb/mcb-lpc.c @@ -0,0 +1,189 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * MEN Chameleon Bus. + * + * Copyright (C) 2014 MEN Mikroelektronik GmbH (www.men.de) + * Author: Andreas Werner + */ + +#include +#include +#include +#include +#include +#include "mcb-internal.h" + +struct priv { + struct mcb_bus *bus; + struct resource *mem; + void __iomem *base; +}; + +static int mcb_lpc_probe(struct platform_device *pdev) +{ + struct resource *res; + struct priv *priv; + int ret = 0, table_size; + + priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + priv->mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); + if (!priv->mem) { + dev_err(&pdev->dev, "No Memory resource\n"); + return -ENODEV; + } + + res = devm_request_mem_region(&pdev->dev, priv->mem->start, + resource_size(priv->mem), + KBUILD_MODNAME); + if (!res) { + dev_err(&pdev->dev, "Failed to request IO memory\n"); + return -EBUSY; + } + + priv->base = devm_ioremap(&pdev->dev, priv->mem->start, + resource_size(priv->mem)); + if (!priv->base) { + dev_err(&pdev->dev, "Cannot ioremap\n"); + return -ENOMEM; + } + + platform_set_drvdata(pdev, priv); + + priv->bus = mcb_alloc_bus(&pdev->dev); + if (IS_ERR(priv->bus)) + return PTR_ERR(priv->bus); + + ret = chameleon_parse_cells(priv->bus, priv->mem->start, priv->base); + if (ret < 0) { + goto out_mcb_bus; + } + + table_size = ret; + + if (table_size < CHAM_HEADER_SIZE) { + /* Release the previous resources */ + devm_iounmap(&pdev->dev, priv->base); + devm_release_mem_region(&pdev->dev, priv->mem->start, resource_size(priv->mem)); + + /* Then, allocate it again with the actual chameleon table size */ + res = devm_request_mem_region(&pdev->dev, priv->mem->start, + table_size, + KBUILD_MODNAME); + if (!res) { + dev_err(&pdev->dev, "Failed to request PCI memory\n"); + ret = -EBUSY; + goto out_mcb_bus; + } + + priv->base = devm_ioremap(&pdev->dev, priv->mem->start, table_size); + if (!priv->base) { + dev_err(&pdev->dev, "Cannot ioremap\n"); + ret = -ENOMEM; + goto out_mcb_bus; + } + + platform_set_drvdata(pdev, priv); + } + + mcb_bus_add_devices(priv->bus); + + return 0; + +out_mcb_bus: + mcb_release_bus(priv->bus); + return ret; +} + +static int mcb_lpc_remove(struct platform_device *pdev) +{ + struct priv *priv = platform_get_drvdata(pdev); + + mcb_release_bus(priv->bus); + + return 0; +} + +static struct platform_device *mcb_lpc_pdev; + +static int mcb_lpc_create_platform_device(const struct dmi_system_id *id) +{ + struct resource *res = id->driver_data; + int ret; + + mcb_lpc_pdev = platform_device_alloc("mcb-lpc", -1); + if (!mcb_lpc_pdev) + return -ENOMEM; + + ret = platform_device_add_resources(mcb_lpc_pdev, res, 1); + if (ret) + goto out_put; + + ret = platform_device_add(mcb_lpc_pdev); + if (ret) + goto out_put; + + return 0; + +out_put: + platform_device_put(mcb_lpc_pdev); + return ret; +} + +static struct resource sc24_fpga_resource = DEFINE_RES_MEM(0xe000e000, CHAM_HEADER_SIZE); +static struct resource sc31_fpga_resource = DEFINE_RES_MEM(0xf000e000, CHAM_HEADER_SIZE); + +static struct platform_driver mcb_lpc_driver = { + .driver = { + .name = "mcb-lpc", + }, + .probe = mcb_lpc_probe, + .remove = mcb_lpc_remove, +}; + +static const struct dmi_system_id mcb_lpc_dmi_table[] = { + { + .ident = "SC24", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "MEN"), + DMI_MATCH(DMI_PRODUCT_VERSION, "14SC24"), + }, + .driver_data = (void *)&sc24_fpga_resource, + .callback = mcb_lpc_create_platform_device, + }, + { + .ident = "SC31", + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "MEN"), + DMI_MATCH(DMI_PRODUCT_VERSION, "14SC31"), + }, + .driver_data = (void *)&sc31_fpga_resource, + .callback = mcb_lpc_create_platform_device, + }, + {} +}; +MODULE_DEVICE_TABLE(dmi, mcb_lpc_dmi_table); + +static int __init mcb_lpc_init(void) +{ + if (!dmi_check_system(mcb_lpc_dmi_table)) + return -ENODEV; + + return platform_driver_register(&mcb_lpc_driver); +} + +static void __exit mcb_lpc_exit(void) +{ + platform_device_unregister(mcb_lpc_pdev); + platform_driver_unregister(&mcb_lpc_driver); +} + +module_init(mcb_lpc_init); +module_exit(mcb_lpc_exit); + +MODULE_AUTHOR("Andreas Werner "); +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("MCB over LPC support"); +MODULE_IMPORT_NS(MCB); diff --git a/drivers/mcb/mcb-parse.c b/drivers/mcb/mcb-parse.c new file mode 100644 index 000000000..1ae37e693 --- /dev/null +++ b/drivers/mcb/mcb-parse.c @@ -0,0 +1,259 @@ +// SPDX-License-Identifier: GPL-2.0-only +#include +#include +#include +#include +#include +#include + +#include "mcb-internal.h" + +struct mcb_parse_priv { + phys_addr_t mapbase; + void __iomem *base; +}; + +#define for_each_chameleon_cell(dtype, p) \ + for ((dtype) = get_next_dtype((p)); \ + (dtype) != CHAMELEON_DTYPE_END; \ + (dtype) = get_next_dtype((p))) + +static inline uint32_t get_next_dtype(void __iomem *p) +{ + uint32_t dtype; + + dtype = readl(p); + return dtype >> 28; +} + +static int chameleon_parse_bdd(struct mcb_bus *bus, + struct chameleon_bar *cb, + void __iomem *base) +{ + return 0; +} + +static int chameleon_parse_gdd(struct mcb_bus *bus, + struct chameleon_bar *cb, + void __iomem *base, int bar_count) +{ + struct chameleon_gdd __iomem *gdd = + (struct chameleon_gdd __iomem *) base; + struct mcb_device *mdev; + u32 dev_mapbase; + u32 offset; + u32 size; + int ret; + __le32 reg1; + __le32 reg2; + + mdev = mcb_alloc_dev(bus); + if (!mdev) + return -ENOMEM; + + reg1 = readl(&gdd->reg1); + reg2 = readl(&gdd->reg2); + offset = readl(&gdd->offset); + size = readl(&gdd->size); + + mdev->id = GDD_DEV(reg1); + mdev->rev = GDD_REV(reg1); + mdev->var = GDD_VAR(reg1); + mdev->bar = GDD_BAR(reg2); + mdev->group = GDD_GRP(reg2); + mdev->inst = GDD_INS(reg2); + + /* + * If the BAR is missing, dev_mapbase is zero, or if the + * device is IO mapped we just print a warning and go on with the + * next device, instead of completely stop the gdd parser + */ + if (mdev->bar > bar_count - 1) { + pr_info("No BAR for 16z%03d\n", mdev->id); + ret = 0; + goto err; + } + + dev_mapbase = cb[mdev->bar].addr; + if (!dev_mapbase) { + pr_info("BAR not assigned for 16z%03d\n", mdev->id); + ret = 0; + goto err; + } + + if (dev_mapbase & 0x01) { + pr_info("IO mapped Device (16z%03d) not yet supported\n", + mdev->id); + ret = 0; + goto err; + } + + pr_debug("Found a 16z%03d\n", mdev->id); + + mdev->irq.start = GDD_IRQ(reg1); + mdev->irq.end = GDD_IRQ(reg1); + mdev->irq.flags = IORESOURCE_IRQ; + + mdev->mem.start = dev_mapbase + offset; + + mdev->mem.end = mdev->mem.start + size - 1; + mdev->mem.flags = IORESOURCE_MEM; + + ret = mcb_device_register(bus, mdev); + if (ret < 0) + goto err; + + return 0; + +err: + mcb_free_dev(mdev); + + return ret; +} + +static void chameleon_parse_bar(void __iomem *base, + struct chameleon_bar *cb, int bar_count) +{ + char __iomem *p = base; + int i; + + /* skip reg1 */ + p += sizeof(__le32); + + for (i = 0; i < bar_count; i++) { + cb[i].addr = readl(p); + cb[i].size = readl(p + 4); + + p += sizeof(struct chameleon_bar); + } +} + +static int chameleon_get_bar(void __iomem **base, phys_addr_t mapbase, + struct chameleon_bar **cb) +{ + struct chameleon_bar *c; + int bar_count; + __le32 reg; + u32 dtype; + + /* + * For those devices which are not connected + * to the PCI Bus (e.g. LPC) there is a bar + * descriptor located directly after the + * chameleon header. This header is comparable + * to a PCI header. + */ + dtype = get_next_dtype(*base); + if (dtype == CHAMELEON_DTYPE_BAR) { + reg = readl(*base); + + bar_count = BAR_CNT(reg); + if (bar_count <= 0 || bar_count > CHAMELEON_BAR_MAX) + return -ENODEV; + + c = kcalloc(bar_count, sizeof(struct chameleon_bar), + GFP_KERNEL); + if (!c) + return -ENOMEM; + + chameleon_parse_bar(*base, c, bar_count); + *base += BAR_DESC_SIZE(bar_count); + } else { + c = kzalloc(sizeof(struct chameleon_bar), GFP_KERNEL); + if (!c) + return -ENOMEM; + + bar_count = 1; + c->addr = mapbase; + } + + *cb = c; + + return bar_count; +} + +int chameleon_parse_cells(struct mcb_bus *bus, phys_addr_t mapbase, + void __iomem *base) +{ + struct chameleon_fpga_header *header; + struct chameleon_bar *cb; + void __iomem *p = base; + int num_cells = 0; + uint32_t dtype; + int bar_count; + int ret; + u32 hsize; + u32 table_size; + + hsize = sizeof(struct chameleon_fpga_header); + + header = kzalloc(hsize, GFP_KERNEL); + if (!header) + return -ENOMEM; + + /* Extract header information */ + memcpy_fromio(header, p, hsize); + /* We only support chameleon v2 at the moment */ + header->magic = le16_to_cpu(header->magic); + if (header->magic != CHAMELEONV2_MAGIC) { + pr_err("Unsupported chameleon version 0x%x\n", + header->magic); + ret = -ENODEV; + goto free_header; + } + p += hsize; + + bus->revision = header->revision; + bus->model = header->model; + bus->minor = header->minor; + snprintf(bus->name, CHAMELEON_FILENAME_LEN + 1, "%s", + header->filename); + + bar_count = chameleon_get_bar(&p, mapbase, &cb); + if (bar_count < 0) { + ret = bar_count; + goto free_header; + } + + for_each_chameleon_cell(dtype, p) { + switch (dtype) { + case CHAMELEON_DTYPE_GENERAL: + ret = chameleon_parse_gdd(bus, cb, p, bar_count); + if (ret < 0) + goto free_bar; + p += sizeof(struct chameleon_gdd); + break; + case CHAMELEON_DTYPE_BRIDGE: + chameleon_parse_bdd(bus, cb, p); + p += sizeof(struct chameleon_bdd); + break; + case CHAMELEON_DTYPE_END: + break; + default: + pr_err("Invalid chameleon descriptor type 0x%x\n", + dtype); + ret = -EINVAL; + goto free_bar; + } + num_cells++; + } + + if (num_cells == 0) { + ret = -EINVAL; + goto free_bar; + } + + table_size = p - base; + pr_debug("%d cell(s) found. Chameleon table size: 0x%04x bytes\n", num_cells, table_size); + kfree(cb); + kfree(header); + return table_size; + +free_bar: + kfree(cb); +free_header: + kfree(header); + + return ret; +} +EXPORT_SYMBOL_NS_GPL(chameleon_parse_cells, MCB); diff --git a/drivers/mcb/mcb-pci.c b/drivers/mcb/mcb-pci.c new file mode 100644 index 000000000..53d9202ff --- /dev/null +++ b/drivers/mcb/mcb-pci.c @@ -0,0 +1,157 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * MEN Chameleon Bus. + * + * Copyright (C) 2014 MEN Mikroelektronik GmbH (www.men.de) + * Author: Johannes Thumshirn + */ + +#include +#include +#include + +#include "mcb-internal.h" + +struct priv { + struct mcb_bus *bus; + phys_addr_t mapbase; + void __iomem *base; +}; + +static int mcb_pci_get_irq(struct mcb_device *mdev) +{ + struct mcb_bus *mbus = mdev->bus; + struct device *dev = mbus->carrier; + struct pci_dev *pdev = to_pci_dev(dev); + + return pdev->irq; +} + +static int mcb_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) +{ + struct resource *res; + struct priv *priv; + int ret, table_size; + unsigned long flags; + + priv = devm_kzalloc(&pdev->dev, sizeof(struct priv), GFP_KERNEL); + if (!priv) + return -ENOMEM; + + ret = pci_enable_device(pdev); + if (ret) { + dev_err(&pdev->dev, "Failed to enable PCI device\n"); + return -ENODEV; + } + pci_set_master(pdev); + + priv->mapbase = pci_resource_start(pdev, 0); + if (!priv->mapbase) { + dev_err(&pdev->dev, "No PCI resource\n"); + ret = -ENODEV; + goto out_disable; + } + + res = devm_request_mem_region(&pdev->dev, priv->mapbase, + CHAM_HEADER_SIZE, + KBUILD_MODNAME); + if (!res) { + dev_err(&pdev->dev, "Failed to request PCI memory\n"); + ret = -EBUSY; + goto out_disable; + } + + priv->base = devm_ioremap(&pdev->dev, priv->mapbase, CHAM_HEADER_SIZE); + if (!priv->base) { + dev_err(&pdev->dev, "Cannot ioremap\n"); + ret = -ENOMEM; + goto out_disable; + } + + flags = pci_resource_flags(pdev, 0); + if (flags & IORESOURCE_IO) { + ret = -ENOTSUPP; + dev_err(&pdev->dev, + "IO mapped PCI devices are not supported\n"); + goto out_disable; + } + + pci_set_drvdata(pdev, priv); + + priv->bus = mcb_alloc_bus(&pdev->dev); + if (IS_ERR(priv->bus)) { + ret = PTR_ERR(priv->bus); + goto out_disable; + } + + priv->bus->get_irq = mcb_pci_get_irq; + + ret = chameleon_parse_cells(priv->bus, priv->mapbase, priv->base); + if (ret < 0) + goto out_mcb_bus; + + table_size = ret; + + if (table_size < CHAM_HEADER_SIZE) { + /* Release the previous resources */ + devm_iounmap(&pdev->dev, priv->base); + devm_release_mem_region(&pdev->dev, priv->mapbase, CHAM_HEADER_SIZE); + + /* Then, allocate it again with the actual chameleon table size */ + res = devm_request_mem_region(&pdev->dev, priv->mapbase, + table_size, + KBUILD_MODNAME); + if (!res) { + dev_err(&pdev->dev, "Failed to request PCI memory\n"); + ret = -EBUSY; + goto out_mcb_bus; + } + + priv->base = devm_ioremap(&pdev->dev, priv->mapbase, table_size); + if (!priv->base) { + dev_err(&pdev->dev, "Cannot ioremap\n"); + ret = -ENOMEM; + goto out_mcb_bus; + } + } + + mcb_bus_add_devices(priv->bus); + + return 0; + +out_mcb_bus: + mcb_release_bus(priv->bus); +out_disable: + pci_disable_device(pdev); + return ret; +} + +static void mcb_pci_remove(struct pci_dev *pdev) +{ + struct priv *priv = pci_get_drvdata(pdev); + + mcb_release_bus(priv->bus); + + pci_disable_device(pdev); +} + +static const struct pci_device_id mcb_pci_tbl[] = { + { PCI_DEVICE(PCI_VENDOR_ID_MEN, PCI_DEVICE_ID_MEN_CHAMELEON) }, + { PCI_DEVICE(PCI_VENDOR_ID_ALTERA, PCI_DEVICE_ID_MEN_CHAMELEON) }, + { 0 }, +}; +MODULE_DEVICE_TABLE(pci, mcb_pci_tbl); + +static struct pci_driver mcb_pci_driver = { + .name = "mcb-pci", + .id_table = mcb_pci_tbl, + .probe = mcb_pci_probe, + .remove = mcb_pci_remove, +}; + +module_pci_driver(mcb_pci_driver); + +MODULE_AUTHOR("Johannes Thumshirn "); +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("MCB over PCI support"); +MODULE_IMPORT_NS(MCB); -- cgit v1.2.3