drivers/staging/ipack/ipack.c

   1 /*
   2  * Industry-pack bus support functions.
   3  *
   4  * (C) 2011 Samuel Iglesias Gonsalvez <[email protected]>, CERN
   5  * (C) 2012 Samuel Iglesias Gonsalvez <[email protected]>, Igalia
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; version 2 of the License.
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/slab.h>
  14 #include <linux/idr.h>
  15 #include "ipack.h"
  16
  17 #define to_ipack_dev(device) container_of(device, struct ipack_device, dev)
  18 #define to_ipack_driver(drv) container_of(drv, struct ipack_driver, driver)
  19
  20 static DEFINE_IDA(ipack_ida);
  21
  22 static void ipack_device_release(struct device *dev)
  23 {
  24         struct ipack_device *device = to_ipack_dev(dev);
  25         kfree(device);
  26 }
  27
  28 static int ipack_bus_match(struct device *device, struct device_driver *driver)
  29 {
  30         int ret;
  31         struct ipack_device *dev = to_ipack_dev(device);
  32         struct ipack_driver *drv = to_ipack_driver(driver);
  33
  34         if ((!drv->ops) || (!drv->ops->match))
  35                 return -EINVAL;
  36
  37         ret = drv->ops->match(dev);
  38         if (ret)
  39                 dev->driver = drv;
  40
  41         return ret;
  42 }
  43
  44 static int ipack_bus_probe(struct device *device)
  45 {
  46         struct ipack_device *dev = to_ipack_dev(device);
  47
  48         if (!dev->driver->ops->probe)
  49                 return -EINVAL;
  50
  51         return dev->driver->ops->probe(dev);
  52 }
  53
  54 static int ipack_bus_remove(struct device *device)
  55 {
  56         struct ipack_device *dev = to_ipack_dev(device);
  57
  58         if (!dev->driver->ops->remove)
  59                 return -EINVAL;
  60
  61         dev->driver->ops->remove(dev);
  62         return 0;
  63 }
  64
  65 static struct bus_type ipack_bus_type = {
  66         .name  = "ipack",
  67         .probe = ipack_bus_probe,
  68         .match = ipack_bus_match,
  69         .remove = ipack_bus_remove,
  70 };
  71
  72 struct ipack_bus_device *ipack_bus_register(struct device *parent, int slots,
  73                                             struct ipack_bus_ops *ops)
  74 {
  75         int bus_nr;
  76         struct ipack_bus_device *bus;
  77
  78         bus = kzalloc(sizeof(struct ipack_bus_device), GFP_KERNEL);
  79         if (!bus)
  80                 return NULL;
  81
  82         bus_nr = ida_simple_get(&ipack_ida, 0, 0, GFP_KERNEL);
  83         if (bus_nr < 0) {
  84                 kfree(bus);
  85                 return NULL;
  86         }
  87
  88         bus->bus_nr = bus_nr;
  89         bus->parent = parent;
  90         bus->slots = slots;
  91         bus->ops = ops;
  92         return bus;
  93 }
  94 EXPORT_SYMBOL_GPL(ipack_bus_register);
  95
  96 int ipack_bus_unregister(struct ipack_bus_device *bus)
  97 {
  98         ida_simple_remove(&ipack_ida, bus->bus_nr);
  99         kfree(bus);
 100         return 0;
 101 }
 102 EXPORT_SYMBOL_GPL(ipack_bus_unregister);
 103
 104 int ipack_driver_register(struct ipack_driver *edrv, struct module *owner,
 105                           char *name)
 106 {
 107         edrv->driver.owner = owner;
 108         edrv->driver.name = name;
 109         edrv->driver.bus = &ipack_bus_type;
 110         return driver_register(&edrv->driver);
 111 }
 112 EXPORT_SYMBOL_GPL(ipack_driver_register);
 113
 114 void ipack_driver_unregister(struct ipack_driver *edrv)
 115 {
 116         driver_unregister(&edrv->driver);
 117 }
 118 EXPORT_SYMBOL_GPL(ipack_driver_unregister);
 119
 120 struct ipack_device *ipack_device_register(struct ipack_bus_device *bus,
 121                                            int slot, int irqv)
 122 {
 123         int ret;
 124         struct ipack_device *dev;
 125
 126         dev = kzalloc(sizeof(struct ipack_device), GFP_KERNEL);
 127         if (!dev)
 128                 return NULL;
 129
 130         dev->dev.bus = &ipack_bus_type;
 131         dev->dev.release = ipack_device_release;
 132         dev->dev.parent = bus->parent;
 133         dev->slot = slot;
 134         dev->bus_nr = bus->bus_nr;
 135         dev->irq = irqv;
 136         dev->bus = bus;
 137         dev_set_name(&dev->dev,
 138                      "ipack-dev.%u.%u", dev->bus_nr, dev->slot);
 139
 140         ret = device_register(&dev->dev);
 141         if (ret < 0) {
 142                 kfree(dev);
 143                 return NULL;
 144         }
 145
 146         return dev;
 147 }
 148 EXPORT_SYMBOL_GPL(ipack_device_register);
 149
 150 void ipack_device_unregister(struct ipack_device *dev)
 151 {
 152         device_unregister(&dev->dev);
 153 }
 154 EXPORT_SYMBOL_GPL(ipack_device_unregister);
 155
 156 static int __init ipack_init(void)
 157 {
 158         ida_init(&ipack_ida);
 159         return bus_register(&ipack_bus_type);
 160 }
 161
 162 static void __exit ipack_exit(void)
 163 {
 164         bus_unregister(&ipack_bus_type);
 165         ida_destroy(&ipack_ida);
 166 }
 167
 168 module_init(ipack_init);
 169 module_exit(ipack_exit);
 170
 171 MODULE_AUTHOR("Samuel Iglesias Gonsalvez <[email protected]>");
 172 MODULE_LICENSE("GPL");
 173 MODULE_DESCRIPTION("Industry-pack bus core");