blob: 3a5f4c991797a02eb0de0ecaac726076d88281f9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
20struct 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 */
30struct resource *
31platform_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 */
53int 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 */
66struct resource *
67platform_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 */
88int 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 */
100int 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
Martin Waitz67be2dd2005-05-01 08:59:26 -0700118 * @pdev: platform device we're adding
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 *
120 */
121int 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
Martin Waitz67be2dd2005-05-01 08:59:26 -0700177 * @pdev: platform device we're removing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 *
179 * Note that this function will also release all memory- and port-based
180 * resources owned by the device (@dev->resource).
181 */
182void 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
197struct platform_object {
198 struct platform_device pdev;
199 struct resource resources[0];
200};
201
202static 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 */
222struct 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
251error:
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
272static 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
279static 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
293static 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
307struct bus_type platform_bus_type = {
308 .name = "platform",
309 .match = platform_match,
310 .suspend = platform_suspend,
311 .resume = platform_resume,
312};
313
314int __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
321u64 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}
339EXPORT_SYMBOL_GPL(dma_get_required_mask);
340#endif
341
342EXPORT_SYMBOL_GPL(platform_bus);
343EXPORT_SYMBOL_GPL(platform_bus_type);
Robert Schwebel46ea0d62005-04-18 21:57:32 -0700344EXPORT_SYMBOL_GPL(platform_add_devices);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345EXPORT_SYMBOL_GPL(platform_device_register);
346EXPORT_SYMBOL_GPL(platform_device_register_simple);
347EXPORT_SYMBOL_GPL(platform_device_unregister);
348EXPORT_SYMBOL_GPL(platform_get_irq);
349EXPORT_SYMBOL_GPL(platform_get_resource);
350EXPORT_SYMBOL_GPL(platform_get_irq_byname);
351EXPORT_SYMBOL_GPL(platform_get_resource_byname);