2 * platform.c - platform 'pseudo' bus for legacy devices
4 * Copyright (c) 2002-3 Patrick Mochel
5 * Copyright (c) 2002-3 Open Source Development Labs
7 * This file is released under the GPLv2
9 * Please see Documentation/driver-model/platform.txt for more
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 #include <linux/slab.h>
23 struct device platform_bus
= {
28 * platform_get_resource - get a resource for a device
29 * @dev: platform device
30 * @type: resource type
31 * @num: resource index
34 platform_get_resource(struct platform_device
*dev
, unsigned int type
,
39 for (i
= 0; i
< dev
->num_resources
; i
++) {
40 struct resource
*r
= &dev
->resource
[i
];
42 if ((r
->flags
& (IORESOURCE_IO
|IORESOURCE_MEM
|
43 IORESOURCE_IRQ
|IORESOURCE_DMA
))
52 * platform_get_irq - get an IRQ for a device
53 * @dev: platform device
54 * @num: IRQ number index
56 int platform_get_irq(struct platform_device
*dev
, unsigned int num
)
58 struct resource
*r
= platform_get_resource(dev
, IORESOURCE_IRQ
, num
);
60 return r
? r
->start
: 0;
64 * platform_get_resource_byname - get a resource for a device by name
65 * @dev: platform device
66 * @type: resource type
67 * @name: resource name
70 platform_get_resource_byname(struct platform_device
*dev
, unsigned int type
,
75 for (i
= 0; i
< dev
->num_resources
; i
++) {
76 struct resource
*r
= &dev
->resource
[i
];
78 if ((r
->flags
& (IORESOURCE_IO
|IORESOURCE_MEM
|
79 IORESOURCE_IRQ
|IORESOURCE_DMA
)) == type
)
80 if (!strcmp(r
->name
, name
))
87 * platform_get_irq - get an IRQ for a device
88 * @dev: platform device
91 int platform_get_irq_byname(struct platform_device
*dev
, char *name
)
93 struct resource
*r
= platform_get_resource_byname(dev
, IORESOURCE_IRQ
, name
);
95 return r
? r
->start
: 0;
99 * platform_add_devices - add a numbers of platform devices
100 * @devs: array of platform devices to add
101 * @num: number of platform devices in array
103 int platform_add_devices(struct platform_device
**devs
, int num
)
107 for (i
= 0; i
< num
; i
++) {
108 ret
= platform_device_register(devs
[i
]);
111 platform_device_unregister(devs
[i
]);
120 * platform_device_register - add a platform-level device
121 * @pdev: platform device we're adding
124 int platform_device_register(struct platform_device
* pdev
)
131 if (!pdev
->dev
.parent
)
132 pdev
->dev
.parent
= &platform_bus
;
134 pdev
->dev
.bus
= &platform_bus_type
;
137 snprintf(pdev
->dev
.bus_id
, BUS_ID_SIZE
, "%s.%u", pdev
->name
, pdev
->id
);
139 strlcpy(pdev
->dev
.bus_id
, pdev
->name
, BUS_ID_SIZE
);
141 for (i
= 0; i
< pdev
->num_resources
; i
++) {
142 struct resource
*p
, *r
= &pdev
->resource
[i
];
145 r
->name
= pdev
->dev
.bus_id
;
149 if (r
->flags
& IORESOURCE_MEM
)
151 else if (r
->flags
& IORESOURCE_IO
)
152 p
= &ioport_resource
;
155 if (p
&& request_resource(p
, r
)) {
157 "%s: failed to claim resource %d\n",
158 pdev
->dev
.bus_id
, i
);
164 pr_debug("Registering platform device '%s'. Parent at %s\n",
165 pdev
->dev
.bus_id
, pdev
->dev
.parent
->bus_id
);
167 ret
= device_register(&pdev
->dev
);
173 if (pdev
->resource
[i
].flags
& (IORESOURCE_MEM
|IORESOURCE_IO
))
174 release_resource(&pdev
->resource
[i
]);
179 * platform_device_unregister - remove a platform-level device
180 * @pdev: platform device we're removing
182 * Note that this function will also release all memory- and port-based
183 * resources owned by the device (@dev->resource).
185 void platform_device_unregister(struct platform_device
* pdev
)
190 for (i
= 0; i
< pdev
->num_resources
; i
++) {
191 struct resource
*r
= &pdev
->resource
[i
];
192 if (r
->flags
& (IORESOURCE_MEM
|IORESOURCE_IO
))
196 device_unregister(&pdev
->dev
);
200 struct platform_object
{
201 struct platform_device pdev
;
202 struct resource resources
[0];
205 static void platform_device_release_simple(struct device
*dev
)
207 struct platform_device
*pdev
= to_platform_device(dev
);
209 kfree(container_of(pdev
, struct platform_object
, pdev
));
213 * platform_device_register_simple
214 * @name: base name of the device we're adding
216 * @res: set of resources that needs to be allocated for the device
217 * @num: number of resources
219 * This function creates a simple platform device that requires minimal
220 * resource and memory management. Canned release function freeing
221 * memory allocated for the device allows drivers using such devices
222 * to be unloaded iwithout waiting for the last reference to the device
225 struct platform_device
*platform_device_register_simple(char *name
, unsigned int id
,
226 struct resource
*res
, unsigned int num
)
228 struct platform_object
*pobj
;
231 pobj
= kzalloc(sizeof(*pobj
) + sizeof(struct resource
) * num
, GFP_KERNEL
);
237 pobj
->pdev
.name
= name
;
239 pobj
->pdev
.dev
.release
= platform_device_release_simple
;
242 memcpy(pobj
->resources
, res
, sizeof(struct resource
) * num
);
243 pobj
->pdev
.resource
= pobj
->resources
;
244 pobj
->pdev
.num_resources
= num
;
247 retval
= platform_device_register(&pobj
->pdev
);
255 return ERR_PTR(retval
);
260 * platform_match - bind platform device to platform driver.
264 * Platform device IDs are assumed to be encoded like this:
265 * "<name><instance>", where <name> is a short description of the
266 * type of device, like "pci" or "floppy", and <instance> is the
267 * enumerated instance of the device, like '0' or '42'.
268 * Driver IDs are simply "<name>".
269 * So, extract the <name> from the platform_device structure,
270 * and compare it against the name of the driver. Return whether
274 static int platform_match(struct device
* dev
, struct device_driver
* drv
)
276 struct platform_device
*pdev
= container_of(dev
, struct platform_device
, dev
);
278 return (strncmp(pdev
->name
, drv
->name
, BUS_ID_SIZE
) == 0);
281 static int platform_suspend(struct device
* dev
, pm_message_t state
)
285 if (dev
->driver
&& dev
->driver
->suspend
)
286 ret
= dev
->driver
->suspend(dev
, state
);
291 static int platform_resume(struct device
* dev
)
295 if (dev
->driver
&& dev
->driver
->resume
)
296 ret
= dev
->driver
->resume(dev
);
301 struct bus_type platform_bus_type
= {
303 .match
= platform_match
,
304 .suspend
= platform_suspend
,
305 .resume
= platform_resume
,
308 int __init
platform_bus_init(void)
310 device_register(&platform_bus
);
311 return bus_register(&platform_bus_type
);
314 #ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
315 u64
dma_get_required_mask(struct device
*dev
)
317 u32 low_totalram
= ((max_pfn
- 1) << PAGE_SHIFT
);
318 u32 high_totalram
= ((max_pfn
- 1) >> (32 - PAGE_SHIFT
));
321 if (!high_totalram
) {
322 /* convert to mask just covering totalram */
323 low_totalram
= (1 << (fls(low_totalram
) - 1));
324 low_totalram
+= low_totalram
- 1;
327 high_totalram
= (1 << (fls(high_totalram
) - 1));
328 high_totalram
+= high_totalram
- 1;
329 mask
= (((u64
)high_totalram
) << 32) + 0xffffffff;
331 return mask
& *dev
->dma_mask
;
333 EXPORT_SYMBOL_GPL(dma_get_required_mask
);
336 EXPORT_SYMBOL_GPL(platform_bus
);
337 EXPORT_SYMBOL_GPL(platform_bus_type
);
338 EXPORT_SYMBOL_GPL(platform_add_devices
);
339 EXPORT_SYMBOL_GPL(platform_device_register
);
340 EXPORT_SYMBOL_GPL(platform_device_register_simple
);
341 EXPORT_SYMBOL_GPL(platform_device_unregister
);
342 EXPORT_SYMBOL_GPL(platform_get_irq
);
343 EXPORT_SYMBOL_GPL(platform_get_resource
);
344 EXPORT_SYMBOL_GPL(platform_get_irq_byname
);
345 EXPORT_SYMBOL_GPL(platform_get_resource_byname
);