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 .bus_id = "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 = kmalloc(sizeof(struct superhyway_device), GFP_KERNEL); 60 if (!dev) 61 return -ENOMEM; 62 63 memset(dev, 0, sizeof(struct superhyway_device)); 64 } 65 66 dev->bus = bus; 67 superhyway_read_vcr(dev, base, &dev->vcr); 68 69 if (!dev->resource) { 70 dev->resource = kmalloc(sizeof(struct resource), GFP_KERNEL); 71 if (!dev->resource) { 72 kfree(dev); 73 return -ENOMEM; 74 } 75 76 dev->resource->name = dev->name; 77 dev->resource->start = base; 78 dev->resource->end = dev->resource->start + 0x01000000; 79 } 80 81 dev->dev.parent = &superhyway_bus_device; 82 dev->dev.bus = &superhyway_bus_type; 83 dev->dev.release = superhyway_device_release; 84 dev->id.id = dev->vcr.mod_id; 85 86 sprintf(dev->name, "SuperHyway device %04x", dev->id.id); 87 sprintf(dev->dev.bus_id, "%02x", superhyway_devices); 88 89 superhyway_devices++; 90 91 return device_register(&dev->dev); 92 } 93 94 int superhyway_add_devices(struct superhyway_bus *bus, 95 struct superhyway_device **devices, 96 int nr_devices) 97 { 98 int i, ret = 0; 99 100 for (i = 0; i < nr_devices; i++) { 101 struct superhyway_device *dev = devices[i]; 102 ret |= superhyway_add_device(dev->resource[0].start, dev, bus); 103 } 104 105 return ret; 106 } 107 108 static int __init superhyway_init(void) 109 { 110 struct superhyway_bus *bus; 111 int ret = 0; 112 113 device_register(&superhyway_bus_device); 114 115 for (bus = superhyway_channels; bus->ops; bus++) 116 ret |= superhyway_scan_bus(bus); 117 118 return ret; 119 } 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 int 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 && shyway_drv->remove) { 159 shyway_drv->remove(shyway_dev); 160 return 0; 161 } 162 163 return -ENODEV; 164 } 165 166 /** 167 * superhyway_register_driver - Register a new SuperHyway driver 168 * @drv: SuperHyway driver to register. 169 * 170 * This registers the passed in @drv. Any devices matching the id table will 171 * automatically be populated and handed off to the driver's specified probe 172 * routine. 173 */ 174 int superhyway_register_driver(struct superhyway_driver *drv) 175 { 176 drv->drv.name = drv->name; 177 drv->drv.bus = &superhyway_bus_type; 178 drv->drv.probe = superhyway_device_probe; 179 drv->drv.remove = superhyway_device_remove; 180 181 return driver_register(&drv->drv); 182 } 183 184 /** 185 * superhyway_unregister_driver - Unregister a SuperHyway driver 186 * @drv: SuperHyway driver to unregister. 187 * 188 * This cleans up after superhyway_register_driver(), and should be invoked in 189 * the exit path of any module drivers. 190 */ 191 void superhyway_unregister_driver(struct superhyway_driver *drv) 192 { 193 driver_unregister(&drv->drv); 194 } 195 196 static int superhyway_bus_match(struct device *dev, struct device_driver *drv) 197 { 198 struct superhyway_device *shyway_dev = to_superhyway_device(dev); 199 struct superhyway_driver *shyway_drv = to_superhyway_driver(drv); 200 const struct superhyway_device_id *ids = shyway_drv->id_table; 201 202 if (!ids) 203 return -EINVAL; 204 if (superhyway_match_id(ids, shyway_dev)) 205 return 1; 206 207 return -ENODEV; 208 } 209 210 struct bus_type superhyway_bus_type = { 211 .name = "superhyway", 212 .match = superhyway_bus_match, 213 #ifdef CONFIG_SYSFS 214 .dev_attrs = superhyway_dev_attrs, 215 #endif 216 }; 217 218 static int __init superhyway_bus_init(void) 219 { 220 return bus_register(&superhyway_bus_type); 221 } 222 223 static void __exit superhyway_bus_exit(void) 224 { 225 device_unregister(&superhyway_bus_device); 226 bus_unregister(&superhyway_bus_type); 227 } 228 229 core_initcall(superhyway_bus_init); 230 module_exit(superhyway_bus_exit); 231 232 EXPORT_SYMBOL(superhyway_bus_type); 233 EXPORT_SYMBOL(superhyway_add_device); 234 EXPORT_SYMBOL(superhyway_add_devices); 235 EXPORT_SYMBOL(superhyway_register_driver); 236 EXPORT_SYMBOL(superhyway_unregister_driver); 237 238 MODULE_LICENSE("GPL"); 239