519 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * MEN Chameleon Bus.4 *5 * Copyright (C) 2013 MEN Mikroelektronik GmbH (www.men.de)6 * Author: Johannes Thumshirn <johannes.thumshirn@men.de>7 */8#include <linux/kernel.h>9#include <linux/module.h>10#include <linux/slab.h>11#include <linux/types.h>12#include <linux/idr.h>13#include <linux/mcb.h>14 15static DEFINE_IDA(mcb_ida);16 17static const struct mcb_device_id *mcb_match_id(const struct mcb_device_id *ids,18 struct mcb_device *dev)19{20 if (ids) {21 while (ids->device) {22 if (ids->device == dev->id)23 return ids;24 ids++;25 }26 }27 28 return NULL;29}30 31static int mcb_match(struct device *dev, const struct device_driver *drv)32{33 const struct mcb_driver *mdrv = to_mcb_driver(drv);34 struct mcb_device *mdev = to_mcb_device(dev);35 const struct mcb_device_id *found_id;36 37 found_id = mcb_match_id(mdrv->id_table, mdev);38 if (found_id)39 return 1;40 41 return 0;42}43 44static int mcb_uevent(const struct device *dev, struct kobj_uevent_env *env)45{46 const struct mcb_device *mdev = to_mcb_device(dev);47 int ret;48 49 ret = add_uevent_var(env, "MODALIAS=mcb:16z%03d", mdev->id);50 if (ret)51 return -ENOMEM;52 53 return 0;54}55 56static int mcb_probe(struct device *dev)57{58 struct mcb_driver *mdrv = to_mcb_driver(dev->driver);59 struct mcb_device *mdev = to_mcb_device(dev);60 const struct mcb_device_id *found_id;61 struct module *carrier_mod;62 int ret;63 64 found_id = mcb_match_id(mdrv->id_table, mdev);65 if (!found_id)66 return -ENODEV;67 68 carrier_mod = mdev->dev.parent->driver->owner;69 if (!try_module_get(carrier_mod))70 return -EINVAL;71 72 get_device(dev);73 ret = mdrv->probe(mdev, found_id);74 if (ret) {75 module_put(carrier_mod);76 put_device(dev);77 }78 79 return ret;80}81 82static void mcb_remove(struct device *dev)83{84 struct mcb_driver *mdrv = to_mcb_driver(dev->driver);85 struct mcb_device *mdev = to_mcb_device(dev);86 struct module *carrier_mod;87 88 mdrv->remove(mdev);89 90 carrier_mod = mdev->dev.parent->driver->owner;91 module_put(carrier_mod);92 93 put_device(&mdev->dev);94}95 96static void mcb_shutdown(struct device *dev)97{98 struct mcb_driver *mdrv = to_mcb_driver(dev->driver);99 struct mcb_device *mdev = to_mcb_device(dev);100 101 if (mdrv && mdrv->shutdown)102 mdrv->shutdown(mdev);103}104 105static ssize_t revision_show(struct device *dev, struct device_attribute *attr,106 char *buf)107{108 struct mcb_bus *bus = to_mcb_bus(dev);109 110 return scnprintf(buf, PAGE_SIZE, "%d\n", bus->revision);111}112static DEVICE_ATTR_RO(revision);113 114static ssize_t model_show(struct device *dev, struct device_attribute *attr,115 char *buf)116{117 struct mcb_bus *bus = to_mcb_bus(dev);118 119 return scnprintf(buf, PAGE_SIZE, "%c\n", bus->model);120}121static DEVICE_ATTR_RO(model);122 123static ssize_t minor_show(struct device *dev, struct device_attribute *attr,124 char *buf)125{126 struct mcb_bus *bus = to_mcb_bus(dev);127 128 return scnprintf(buf, PAGE_SIZE, "%d\n", bus->minor);129}130static DEVICE_ATTR_RO(minor);131 132static ssize_t name_show(struct device *dev, struct device_attribute *attr,133 char *buf)134{135 struct mcb_bus *bus = to_mcb_bus(dev);136 137 return scnprintf(buf, PAGE_SIZE, "%s\n", bus->name);138}139static DEVICE_ATTR_RO(name);140 141static struct attribute *mcb_bus_attrs[] = {142 &dev_attr_revision.attr,143 &dev_attr_model.attr,144 &dev_attr_minor.attr,145 &dev_attr_name.attr,146 NULL,147};148 149static const struct attribute_group mcb_carrier_group = {150 .attrs = mcb_bus_attrs,151};152 153static const struct attribute_group *mcb_carrier_groups[] = {154 &mcb_carrier_group,155 NULL,156};157 158 159static const struct bus_type mcb_bus_type = {160 .name = "mcb",161 .match = mcb_match,162 .uevent = mcb_uevent,163 .probe = mcb_probe,164 .remove = mcb_remove,165 .shutdown = mcb_shutdown,166};167 168static const struct device_type mcb_carrier_device_type = {169 .name = "mcb-carrier",170 .groups = mcb_carrier_groups,171};172 173/**174 * __mcb_register_driver() - Register a @mcb_driver at the system175 * @drv: The @mcb_driver176 * @owner: The @mcb_driver's module177 * @mod_name: The name of the @mcb_driver's module178 *179 * Register a @mcb_driver at the system. Perform some sanity checks, if180 * the .probe and .remove methods are provided by the driver.181 */182int __mcb_register_driver(struct mcb_driver *drv, struct module *owner,183 const char *mod_name)184{185 if (!drv->probe || !drv->remove)186 return -EINVAL;187 188 drv->driver.owner = owner;189 drv->driver.bus = &mcb_bus_type;190 drv->driver.mod_name = mod_name;191 192 return driver_register(&drv->driver);193}194EXPORT_SYMBOL_NS_GPL(__mcb_register_driver, MCB);195 196/**197 * mcb_unregister_driver() - Unregister a @mcb_driver from the system198 * @drv: The @mcb_driver199 *200 * Unregister a @mcb_driver from the system.201 */202void mcb_unregister_driver(struct mcb_driver *drv)203{204 driver_unregister(&drv->driver);205}206EXPORT_SYMBOL_NS_GPL(mcb_unregister_driver, MCB);207 208static void mcb_release_dev(struct device *dev)209{210 struct mcb_device *mdev = to_mcb_device(dev);211 212 mcb_bus_put(mdev->bus);213 kfree(mdev);214}215 216/**217 * mcb_device_register() - Register a mcb_device218 * @bus: The @mcb_bus of the device219 * @dev: The @mcb_device220 *221 * Register a specific @mcb_device at a @mcb_bus and the system itself.222 */223int mcb_device_register(struct mcb_bus *bus, struct mcb_device *dev)224{225 int ret;226 int device_id;227 228 device_initialize(&dev->dev);229 mcb_bus_get(bus);230 dev->dev.bus = &mcb_bus_type;231 dev->dev.parent = bus->dev.parent;232 dev->dev.release = mcb_release_dev;233 dev->dma_dev = bus->carrier;234 235 device_id = dev->id;236 dev_set_name(&dev->dev, "mcb%d-16z%03d-%d:%d:%d",237 bus->bus_nr, device_id, dev->inst, dev->group, dev->var);238 239 ret = device_add(&dev->dev);240 if (ret < 0) {241 pr_err("Failed registering device 16z%03d on bus mcb%d (%d)\n",242 device_id, bus->bus_nr, ret);243 goto out;244 }245 246 return 0;247 248out:249 put_device(&dev->dev);250 251 return ret;252}253EXPORT_SYMBOL_NS_GPL(mcb_device_register, MCB);254 255static void mcb_free_bus(struct device *dev)256{257 struct mcb_bus *bus = to_mcb_bus(dev);258 259 put_device(bus->carrier);260 ida_free(&mcb_ida, bus->bus_nr);261 kfree(bus);262}263 264/**265 * mcb_alloc_bus() - Allocate a new @mcb_bus266 * @carrier: generic &struct device for the carrier device267 *268 * Allocate a new @mcb_bus.269 */270struct mcb_bus *mcb_alloc_bus(struct device *carrier)271{272 struct mcb_bus *bus;273 int bus_nr;274 int rc;275 276 bus = kzalloc(sizeof(struct mcb_bus), GFP_KERNEL);277 if (!bus)278 return ERR_PTR(-ENOMEM);279 280 bus_nr = ida_alloc(&mcb_ida, GFP_KERNEL);281 if (bus_nr < 0) {282 kfree(bus);283 return ERR_PTR(bus_nr);284 }285 286 bus->bus_nr = bus_nr;287 bus->carrier = get_device(carrier);288 289 device_initialize(&bus->dev);290 bus->dev.parent = carrier;291 bus->dev.bus = &mcb_bus_type;292 bus->dev.type = &mcb_carrier_device_type;293 bus->dev.release = mcb_free_bus;294 295 dev_set_name(&bus->dev, "mcb:%d", bus_nr);296 rc = device_add(&bus->dev);297 if (rc)298 goto err_put;299 300 return bus;301 302err_put:303 put_device(&bus->dev);304 return ERR_PTR(rc);305}306EXPORT_SYMBOL_NS_GPL(mcb_alloc_bus, MCB);307 308static int __mcb_devices_unregister(struct device *dev, void *data)309{310 device_unregister(dev);311 return 0;312}313 314static void mcb_devices_unregister(struct mcb_bus *bus)315{316 bus_for_each_dev(bus->dev.bus, NULL, NULL, __mcb_devices_unregister);317}318/**319 * mcb_release_bus() - Free a @mcb_bus320 * @bus: The @mcb_bus to release321 *322 * Release an allocated @mcb_bus from the system.323 */324void mcb_release_bus(struct mcb_bus *bus)325{326 mcb_devices_unregister(bus);327}328EXPORT_SYMBOL_NS_GPL(mcb_release_bus, MCB);329 330/**331 * mcb_bus_get() - Increment refcnt332 * @bus: The @mcb_bus333 *334 * Get a @mcb_bus' ref335 */336struct mcb_bus *mcb_bus_get(struct mcb_bus *bus)337{338 if (bus)339 get_device(&bus->dev);340 341 return bus;342}343EXPORT_SYMBOL_NS_GPL(mcb_bus_get, MCB);344 345/**346 * mcb_bus_put() - Decrement refcnt347 * @bus: The @mcb_bus348 *349 * Release a @mcb_bus' ref350 */351void mcb_bus_put(struct mcb_bus *bus)352{353 if (bus)354 put_device(&bus->dev);355}356EXPORT_SYMBOL_NS_GPL(mcb_bus_put, MCB);357 358/**359 * mcb_alloc_dev() - Allocate a device360 * @bus: The @mcb_bus the device is part of361 *362 * Allocate a @mcb_device and add bus.363 */364struct mcb_device *mcb_alloc_dev(struct mcb_bus *bus)365{366 struct mcb_device *dev;367 368 dev = kzalloc(sizeof(struct mcb_device), GFP_KERNEL);369 if (!dev)370 return NULL;371 372 dev->bus = bus;373 374 return dev;375}376EXPORT_SYMBOL_NS_GPL(mcb_alloc_dev, MCB);377 378/**379 * mcb_free_dev() - Free @mcb_device380 * @dev: The device to free381 *382 * Free a @mcb_device383 */384void mcb_free_dev(struct mcb_device *dev)385{386 kfree(dev);387}388EXPORT_SYMBOL_NS_GPL(mcb_free_dev, MCB);389 390static int __mcb_bus_add_devices(struct device *dev, void *data)391{392 int retval;393 394 retval = device_attach(dev);395 if (retval < 0) {396 dev_err(dev, "Error adding device (%d)\n", retval);397 return retval;398 }399 400 return 0;401}402 403/**404 * mcb_bus_add_devices() - Add devices in the bus' internal device list405 * @bus: The @mcb_bus we add the devices406 *407 * Add devices in the bus' internal device list to the system.408 */409void mcb_bus_add_devices(const struct mcb_bus *bus)410{411 bus_for_each_dev(bus->dev.bus, NULL, NULL, __mcb_bus_add_devices);412}413EXPORT_SYMBOL_NS_GPL(mcb_bus_add_devices, MCB);414 415/**416 * mcb_get_resource() - get a resource for a mcb device417 * @dev: the mcb device418 * @type: the type of resource419 */420struct resource *mcb_get_resource(struct mcb_device *dev, unsigned int type)421{422 if (type == IORESOURCE_MEM)423 return &dev->mem;424 else if (type == IORESOURCE_IRQ)425 return &dev->irq;426 else427 return NULL;428}429EXPORT_SYMBOL_NS_GPL(mcb_get_resource, MCB);430 431/**432 * mcb_request_mem() - Request memory433 * @dev: The @mcb_device the memory is for434 * @name: The name for the memory reference.435 *436 * Request memory for a @mcb_device. If @name is NULL the driver name will437 * be used.438 */439struct resource *mcb_request_mem(struct mcb_device *dev, const char *name)440{441 struct resource *mem;442 u32 size;443 444 if (!name)445 name = dev->dev.driver->name;446 447 size = resource_size(&dev->mem);448 449 mem = request_mem_region(dev->mem.start, size, name);450 if (!mem)451 return ERR_PTR(-EBUSY);452 453 return mem;454}455EXPORT_SYMBOL_NS_GPL(mcb_request_mem, MCB);456 457/**458 * mcb_release_mem() - Release memory requested by device459 * @mem: The memory resource to be released460 *461 * Release memory that was prior requested via @mcb_request_mem().462 */463void mcb_release_mem(struct resource *mem)464{465 u32 size;466 467 size = resource_size(mem);468 release_mem_region(mem->start, size);469}470EXPORT_SYMBOL_NS_GPL(mcb_release_mem, MCB);471 472static int __mcb_get_irq(struct mcb_device *dev)473{474 struct resource *irq;475 476 irq = mcb_get_resource(dev, IORESOURCE_IRQ);477 478 return irq->start;479}480 481/**482 * mcb_get_irq() - Get device's IRQ number483 * @dev: The @mcb_device the IRQ is for484 *485 * Get the IRQ number of a given @mcb_device.486 */487int mcb_get_irq(struct mcb_device *dev)488{489 struct mcb_bus *bus = dev->bus;490 491 if (bus->get_irq)492 return bus->get_irq(dev);493 494 return __mcb_get_irq(dev);495}496EXPORT_SYMBOL_NS_GPL(mcb_get_irq, MCB);497 498static int mcb_init(void)499{500 return bus_register(&mcb_bus_type);501}502 503static void mcb_exit(void)504{505 ida_destroy(&mcb_ida);506 bus_unregister(&mcb_bus_type);507}508 509/* mcb must be initialized after PCI but before the chameleon drivers.510 * That means we must use some initcall between subsys_initcall and511 * device_initcall.512 */513fs_initcall(mcb_init);514module_exit(mcb_exit);515 516MODULE_DESCRIPTION("MEN Chameleon Bus Driver");517MODULE_AUTHOR("Johannes Thumshirn <johannes.thumshirn@men.de>");518MODULE_LICENSE("GPL v2");519