drivers/sh/superhyway/superhyway.c

   1 /*
   2  * drivers/sh/superhyway/superhyway.c
   3  *
   4  * SuperHyway Bus Driver
   5  *
   6  * Copyright (C) 2004, 2005  Paul Mundt <lethal@linux-sh.org>
   7  *
   8  * This file is subject to the terms and conditions of the GNU General Public
   9  * License.  See the file "COPYING" in the main directory of this archive
  10  * for more details.
  11  */
  12 #include <linux/kernel.h>
  13 #include <linux/device.h>
  14 #include <linux/init.h>
  15 #include <linux/module.h>
  16 #include <linux/types.h>
  17 #include <linux/list.h>
  18 #include <linux/superhyway.h>
  19 #include <linux/string.h>
  20 #include <linux/slab.h>
  21
  22 static int superhyway_devices;
  23
  24 static struct device superhyway_bus_device = {
  25         .init_name = "superhyway",
  26 };
  27
  28 static void superhyway_device_release(struct device *dev)
  29 {
  30         struct superhyway_device *sdev = to_superhyway_device(dev);
  31
  32         kfree(sdev->resource);
  33         kfree(sdev);
  34 }
  35
  36 /**
  37  * superhyway_add_device - Add a SuperHyway module
  38  * @base: Physical address where module is mapped.
  39  * @sdev: SuperHyway device to add, or NULL to allocate a new one.
  40  * @bus: Bus where SuperHyway module resides.
  41  *
  42  * This is responsible for adding a new SuperHyway module. This sets up a new
  43  * struct superhyway_device for the module being added if @sdev == NULL.
  44  *
  45  * Devices are initially added in the order that they are scanned (from the
  46  * top-down of the memory map), and are assigned an ID based on the order that
  47  * they are added. Any manual addition of a module will thus get the ID after
  48  * the devices already discovered regardless of where it resides in memory.
  49  *
  50  * Further work can and should be done in superhyway_scan_bus(), to be sure
  51  * that any new modules are properly discovered and subsequently registered.
  52  */
  53 int superhyway_add_device(unsigned long base, struct superhyway_device *sdev,
  54                           struct superhyway_bus *bus)
  55 {
  56         struct superhyway_device *dev = sdev;
  57
  58         if (!dev) {
  59                 dev = kzalloc(sizeof(struct superhyway_device), GFP_KERNEL);
  60                 if (!dev)
  61                         return -ENOMEM;
  62
  63         }
  64
  65         dev->bus = bus;
  66         superhyway_read_vcr(dev, base, &dev->vcr);
  67
  68         if (!dev->resource) {
  69                 dev->resource = kzalloc(sizeof(struct resource), GFP_KERNEL);
  70                 if (!dev->resource) {
  71                         kfree(dev);
  72                         return -ENOMEM;
  73                 }
  74
  75                 dev->resource->name     = dev->name;
  76                 dev->resource->start    = base;
  77                 dev->resource->end      = dev->resource->start + 0x01000000;
  78         }
  79
  80         dev->dev.parent         = &superhyway_bus_device;
  81         dev->dev.bus            = &superhyway_bus_type;
  82         dev->dev.release        = superhyway_device_release;
  83         dev->id.id              = dev->vcr.mod_id;
  84
  85         sprintf(dev->name, "SuperHyway device %04x", dev->id.id);
  86         dev_set_name(&dev->dev, "%02x", superhyway_devices);
  87
  88         superhyway_devices++;
  89
  90         return device_register(&dev->dev);
  91 }
  92
  93 int superhyway_add_devices(struct superhyway_bus *bus,
  94                            struct superhyway_device **devices,
  95                            int nr_devices)
  96 {
  97         int i, ret = 0;
  98
  99         for (i = 0; i < nr_devices; i++) {
 100                 struct superhyway_device *dev = devices[i];
 101                 ret |= superhyway_add_device(dev->resource[0].start, dev, bus);
 102         }
 103
 104         return ret;
 105 }
 106
 107 static int __init superhyway_init(void)
 108 {
 109         struct superhyway_bus *bus;
 110         int ret;
 111
 112         ret = device_register(&superhyway_bus_device);
 113         if (unlikely(ret))
 114                 return ret;
 115
 116         for (bus = superhyway_channels; bus->ops; bus++)
 117                 ret |= superhyway_scan_bus(bus);
 118
 119         return ret;
 120 }
 121 postcore_initcall(superhyway_init);
 122
 123 static const struct superhyway_device_id *
 124 superhyway_match_id(const struct superhyway_device_id *ids,
 125                     struct superhyway_device *dev)
 126 {
 127         while (ids->id) {
 128                 if (ids->id == dev->id.id)
 129                         return ids;
 130
 131                 ids++;
 132         }
 133
 134         return NULL;
 135 }
 136
 137 static int superhyway_device_probe(struct device *dev)
 138 {
 139         struct superhyway_device *shyway_dev = to_superhyway_device(dev);
 140         struct superhyway_driver *shyway_drv = to_superhyway_driver(dev->driver);
 141
 142         if (shyway_drv && shyway_drv->probe) {
 143                 const struct superhyway_device_id *id;
 144
 145                 id = superhyway_match_id(shyway_drv->id_table, shyway_dev);
 146                 if (id)
 147                         return shyway_drv->probe(shyway_dev, id);
 148         }
 149
 150         return -ENODEV;
 151 }
 152
 153 static void superhyway_device_remove(struct device *dev)
 154 {
 155         struct superhyway_device *shyway_dev = to_superhyway_device(dev);
 156         struct superhyway_driver *shyway_drv = to_superhyway_driver(dev->driver);
 157
 158         if (shyway_drv->remove)
 159                 shyway_drv->remove(shyway_dev);
 160 }
 161
 162 /**
 163  * superhyway_register_driver - Register a new SuperHyway driver
 164  * @drv: SuperHyway driver to register.
 165  *
 166  * This registers the passed in @drv. Any devices matching the id table will
 167  * automatically be populated and handed off to the driver's specified probe
 168  * routine.
 169  */
 170 int superhyway_register_driver(struct superhyway_driver *drv)
 171 {
 172         drv->drv.name   = drv->name;
 173         drv->drv.bus    = &superhyway_bus_type;
 174
 175         return driver_register(&drv->drv);
 176 }
 177
 178 /**
 179  * superhyway_unregister_driver - Unregister a SuperHyway driver
 180  * @drv: SuperHyway driver to unregister.
 181  *
 182  * This cleans up after superhyway_register_driver(), and should be invoked in
 183  * the exit path of any module drivers.
 184  */
 185 void superhyway_unregister_driver(struct superhyway_driver *drv)
 186 {
 187         driver_unregister(&drv->drv);
 188 }
 189
 190 static int superhyway_bus_match(struct device *dev, struct device_driver *drv)
 191 {
 192         struct superhyway_device *shyway_dev = to_superhyway_device(dev);
 193         struct superhyway_driver *shyway_drv = to_superhyway_driver(drv);
 194         const struct superhyway_device_id *ids = shyway_drv->id_table;
 195
 196         if (!ids)
 197                 return -EINVAL;
 198         if (superhyway_match_id(ids, shyway_dev))
 199                 return 1;
 200
 201         return -ENODEV;
 202 }
 203
 204 struct bus_type superhyway_bus_type = {
 205         .name           = "superhyway",
 206         .match          = superhyway_bus_match,
 207 #ifdef CONFIG_SYSFS
 208         .dev_groups     = superhyway_dev_groups,
 209 #endif
 210         .probe          = superhyway_device_probe,
 211         .remove         = superhyway_device_remove,
 212 };
 213
 214 static int __init superhyway_bus_init(void)
 215 {
 216         return bus_register(&superhyway_bus_type);
 217 }
 218
 219 static void __exit superhyway_bus_exit(void)
 220 {
 221         device_unregister(&superhyway_bus_device);
 222         bus_unregister(&superhyway_bus_type);
 223 }
 224
 225 core_initcall(superhyway_bus_init);
 226 module_exit(superhyway_bus_exit);
 227
 228 EXPORT_SYMBOL(superhyway_bus_type);
 229 EXPORT_SYMBOL(superhyway_add_device);
 230 EXPORT_SYMBOL(superhyway_add_devices);
 231 EXPORT_SYMBOL(superhyway_register_driver);
 232 EXPORT_SYMBOL(superhyway_unregister_driver);
 233
 234 MODULE_LICENSE("GPL");