1 /* 2 * platform.c - platform 'pseudo' bus for legacy devices 3 * 4 * Copyright (c) 2002-3 Patrick Mochel 5 * Copyright (c) 2002-3 Open Source Development Labs 6 * 7 * This file is released under the GPLv2 8 * 9 * Please see Documentation/driver-model/platform.txt for more 10 * information. 11 */ 12 13 #include <linux/device.h> 14 #include <linux/module.h> 15 #include <linux/init.h> 16 #include <linux/dma-mapping.h> 17 #include <linux/bootmem.h> 18 #include <linux/err.h> 19 20 struct device platform_bus = { 21 .bus_id = "platform", 22 }; 23 24 /** 25 * platform_get_resource - get a resource for a device 26 * @dev: platform device 27 * @type: resource type 28 * @num: resource index 29 */ 30 struct resource * 31 platform_get_resource(struct platform_device *dev, unsigned int type, 32 unsigned int num) 33 { 34 int i; 35 36 for (i = 0; i < dev->num_resources; i++) { 37 struct resource *r = &dev->resource[i]; 38 39 if ((r->flags & (IORESOURCE_IO|IORESOURCE_MEM| 40 IORESOURCE_IRQ|IORESOURCE_DMA)) 41 == type) 42 if (num-- == 0) 43 return r; 44 } 45 return NULL; 46 } 47 48 /** 49 * platform_get_irq - get an IRQ for a device 50 * @dev: platform device 51 * @num: IRQ number index 52 */ 53 int platform_get_irq(struct platform_device *dev, unsigned int num) 54 { 55 struct resource *r = platform_get_resource(dev, IORESOURCE_IRQ, num); 56 57 return r ? r->start : 0; 58 } 59 60 /** 61 * platform_get_resource_byname - get a resource for a device by name 62 * @dev: platform device 63 * @type: resource type 64 * @name: resource name 65 */ 66 struct resource * 67 platform_get_resource_byname(struct platform_device *dev, unsigned int type, 68 char *name) 69 { 70 int i; 71 72 for (i = 0; i < dev->num_resources; i++) { 73 struct resource *r = &dev->resource[i]; 74 75 if ((r->flags & (IORESOURCE_IO|IORESOURCE_MEM| 76 IORESOURCE_IRQ|IORESOURCE_DMA)) == type) 77 if (!strcmp(r->name, name)) 78 return r; 79 } 80 return NULL; 81 } 82 83 /** 84 * platform_get_irq - get an IRQ for a device 85 * @dev: platform device 86 * @name: IRQ name 87 */ 88 int platform_get_irq_byname(struct platform_device *dev, char *name) 89 { 90 struct resource *r = platform_get_resource_byname(dev, IORESOURCE_IRQ, name); 91 92 return r ? r->start : 0; 93 } 94 95 /** 96 * platform_add_devices - add a numbers of platform devices 97 * @devs: array of platform devices to add 98 * @num: number of platform devices in array 99 */ 100 int platform_add_devices(struct platform_device **devs, int num) 101 { 102 int i, ret = 0; 103 104 for (i = 0; i < num; i++) { 105 ret = platform_device_register(devs[i]); 106 if (ret) { 107 while (--i >= 0) 108 platform_device_unregister(devs[i]); 109 break; 110 } 111 } 112 113 return ret; 114 } 115 116 /** 117 * platform_device_register - add a platform-level device 118 * @pdev: platform device we're adding 119 * 120 */ 121 int platform_device_register(struct platform_device * pdev) 122 { 123 int i, ret = 0; 124 125 if (!pdev) 126 return -EINVAL; 127 128 if (!pdev->dev.parent) 129 pdev->dev.parent = &platform_bus; 130 131 pdev->dev.bus = &platform_bus_type; 132 133 if (pdev->id != -1) 134 snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%u", pdev->name, pdev->id); 135 else 136 strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE); 137 138 for (i = 0; i < pdev->num_resources; i++) { 139 struct resource *p, *r = &pdev->resource[i]; 140 141 if (r->name == NULL) 142 r->name = pdev->dev.bus_id; 143 144 p = r->parent; 145 if (!p) { 146 if (r->flags & IORESOURCE_MEM) 147 p = &iomem_resource; 148 else if (r->flags & IORESOURCE_IO) 149 p = &ioport_resource; 150 } 151 152 if (p && request_resource(p, r)) { 153 printk(KERN_ERR 154 "%s: failed to claim resource %d\n", 155 pdev->dev.bus_id, i); 156 ret = -EBUSY; 157 goto failed; 158 } 159 } 160 161 pr_debug("Registering platform device '%s'. Parent at %s\n", 162 pdev->dev.bus_id, pdev->dev.parent->bus_id); 163 164 ret = device_register(&pdev->dev); 165 if (ret == 0) 166 return ret; 167 168 failed: 169 while (--i >= 0) 170 if (pdev->resource[i].flags & (IORESOURCE_MEM|IORESOURCE_IO)) 171 release_resource(&pdev->resource[i]); 172 return ret; 173 } 174 175 /** 176 * platform_device_unregister - remove a platform-level device 177 * @pdev: platform device we're removing 178 * 179 * Note that this function will also release all memory- and port-based 180 * resources owned by the device (@dev->resource). 181 */ 182 void platform_device_unregister(struct platform_device * pdev) 183 { 184 int i; 185 186 if (pdev) { 187 for (i = 0; i < pdev->num_resources; i++) { 188 struct resource *r = &pdev->resource[i]; 189 if (r->flags & (IORESOURCE_MEM|IORESOURCE_IO)) 190 release_resource(r); 191 } 192 193 device_unregister(&pdev->dev); 194 } 195 } 196 197 struct platform_object { 198 struct platform_device pdev; 199 struct resource resources[0]; 200 }; 201 202 static void platform_device_release_simple(struct device *dev) 203 { 204 struct platform_device *pdev = to_platform_device(dev); 205 206 kfree(container_of(pdev, struct platform_object, pdev)); 207 } 208 209 /** 210 * platform_device_register_simple 211 * @name: base name of the device we're adding 212 * @id: instance id 213 * @res: set of resources that needs to be allocated for the device 214 * @num: number of resources 215 * 216 * This function creates a simple platform device that requires minimal 217 * resource and memory management. Canned release function freeing 218 * memory allocated for the device allows drivers using such devices 219 * to be unloaded iwithout waiting for the last reference to the device 220 * to be dropped. 221 */ 222 struct platform_device *platform_device_register_simple(char *name, unsigned int id, 223 struct resource *res, unsigned int num) 224 { 225 struct platform_object *pobj; 226 int retval; 227 228 pobj = kmalloc(sizeof(struct platform_object) + sizeof(struct resource) * num, GFP_KERNEL); 229 if (!pobj) { 230 retval = -ENOMEM; 231 goto error; 232 } 233 234 memset(pobj, 0, sizeof(*pobj)); 235 pobj->pdev.name = name; 236 pobj->pdev.id = id; 237 pobj->pdev.dev.release = platform_device_release_simple; 238 239 if (num) { 240 memcpy(pobj->resources, res, sizeof(struct resource) * num); 241 pobj->pdev.resource = pobj->resources; 242 pobj->pdev.num_resources = num; 243 } 244 245 retval = platform_device_register(&pobj->pdev); 246 if (retval) 247 goto error; 248 249 return &pobj->pdev; 250 251 error: 252 kfree(pobj); 253 return ERR_PTR(retval); 254 } 255 256 257 /** 258 * platform_match - bind platform device to platform driver. 259 * @dev: device. 260 * @drv: driver. 261 * 262 * Platform device IDs are assumed to be encoded like this: 263 * "<name><instance>", where <name> is a short description of the 264 * type of device, like "pci" or "floppy", and <instance> is the 265 * enumerated instance of the device, like '0' or '42'. 266 * Driver IDs are simply "<name>". 267 * So, extract the <name> from the platform_device structure, 268 * and compare it against the name of the driver. Return whether 269 * they match or not. 270 */ 271 272 static int platform_match(struct device * dev, struct device_driver * drv) 273 { 274 struct platform_device *pdev = container_of(dev, struct platform_device, dev); 275 276 return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0); 277 } 278 279 static int platform_suspend(struct device * dev, pm_message_t state) 280 { 281 int ret = 0; 282 283 if (dev->driver && dev->driver->suspend) { 284 ret = dev->driver->suspend(dev, state, SUSPEND_DISABLE); 285 if (ret == 0) 286 ret = dev->driver->suspend(dev, state, SUSPEND_SAVE_STATE); 287 if (ret == 0) 288 ret = dev->driver->suspend(dev, state, SUSPEND_POWER_DOWN); 289 } 290 return ret; 291 } 292 293 static int platform_resume(struct device * dev) 294 { 295 int ret = 0; 296 297 if (dev->driver && dev->driver->resume) { 298 ret = dev->driver->resume(dev, RESUME_POWER_ON); 299 if (ret == 0) 300 ret = dev->driver->resume(dev, RESUME_RESTORE_STATE); 301 if (ret == 0) 302 ret = dev->driver->resume(dev, RESUME_ENABLE); 303 } 304 return ret; 305 } 306 307 struct bus_type platform_bus_type = { 308 .name = "platform", 309 .match = platform_match, 310 .suspend = platform_suspend, 311 .resume = platform_resume, 312 }; 313 314 int __init platform_bus_init(void) 315 { 316 device_register(&platform_bus); 317 return bus_register(&platform_bus_type); 318 } 319 320 #ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK 321 u64 dma_get_required_mask(struct device *dev) 322 { 323 u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT); 324 u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT)); 325 u64 mask; 326 327 if (!high_totalram) { 328 /* convert to mask just covering totalram */ 329 low_totalram = (1 << (fls(low_totalram) - 1)); 330 low_totalram += low_totalram - 1; 331 mask = low_totalram; 332 } else { 333 high_totalram = (1 << (fls(high_totalram) - 1)); 334 high_totalram += high_totalram - 1; 335 mask = (((u64)high_totalram) << 32) + 0xffffffff; 336 } 337 return mask & *dev->dma_mask; 338 } 339 EXPORT_SYMBOL_GPL(dma_get_required_mask); 340 #endif 341 342 EXPORT_SYMBOL_GPL(platform_bus); 343 EXPORT_SYMBOL_GPL(platform_bus_type); 344 EXPORT_SYMBOL_GPL(platform_add_devices); 345 EXPORT_SYMBOL_GPL(platform_device_register); 346 EXPORT_SYMBOL_GPL(platform_device_register_simple); 347 EXPORT_SYMBOL_GPL(platform_device_unregister); 348 EXPORT_SYMBOL_GPL(platform_get_irq); 349 EXPORT_SYMBOL_GPL(platform_get_resource); 350 EXPORT_SYMBOL_GPL(platform_get_irq_byname); 351 EXPORT_SYMBOL_GPL(platform_get_resource_byname); 352