[PATCH] drivers/base/*: use kzalloc instead of kmalloc+memset
[linux-2.6.git] / drivers / base / platform.c
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 = kzalloc(sizeof(*pobj) + sizeof(struct resource) * num, GFP_KERNEL);
229         if (!pobj) {
230                 retval = -ENOMEM;
231                 goto error;
232         }
233
234         pobj->pdev.name = name;
235         pobj->pdev.id = id;
236         pobj->pdev.dev.release = platform_device_release_simple;
237
238         if (num) {
239                 memcpy(pobj->resources, res, sizeof(struct resource) * num);
240                 pobj->pdev.resource = pobj->resources;
241                 pobj->pdev.num_resources = num;
242         }
243
244         retval = platform_device_register(&pobj->pdev);
245         if (retval)
246                 goto error;
247
248         return &pobj->pdev;
249
250 error:
251         kfree(pobj);
252         return ERR_PTR(retval);
253 }
254
255
256 /**
257  *      platform_match - bind platform device to platform driver.
258  *      @dev:   device.
259  *      @drv:   driver.
260  *
261  *      Platform device IDs are assumed to be encoded like this:
262  *      "<name><instance>", where <name> is a short description of the
263  *      type of device, like "pci" or "floppy", and <instance> is the
264  *      enumerated instance of the device, like '0' or '42'.
265  *      Driver IDs are simply "<name>".
266  *      So, extract the <name> from the platform_device structure,
267  *      and compare it against the name of the driver. Return whether
268  *      they match or not.
269  */
270
271 static int platform_match(struct device * dev, struct device_driver * drv)
272 {
273         struct platform_device *pdev = container_of(dev, struct platform_device, dev);
274
275         return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
276 }
277
278 static int platform_suspend(struct device * dev, pm_message_t state)
279 {
280         int ret = 0;
281
282         if (dev->driver && dev->driver->suspend) {
283                 ret = dev->driver->suspend(dev, state, SUSPEND_DISABLE);
284                 if (ret == 0)
285                         ret = dev->driver->suspend(dev, state, SUSPEND_SAVE_STATE);
286                 if (ret == 0)
287                         ret = dev->driver->suspend(dev, state, SUSPEND_POWER_DOWN);
288         }
289         return ret;
290 }
291
292 static int platform_resume(struct device * dev)
293 {
294         int ret = 0;
295
296         if (dev->driver && dev->driver->resume) {
297                 ret = dev->driver->resume(dev, RESUME_POWER_ON);
298                 if (ret == 0)
299                         ret = dev->driver->resume(dev, RESUME_RESTORE_STATE);
300                 if (ret == 0)
301                         ret = dev->driver->resume(dev, RESUME_ENABLE);
302         }
303         return ret;
304 }
305
306 struct bus_type platform_bus_type = {
307         .name           = "platform",
308         .match          = platform_match,
309         .suspend        = platform_suspend,
310         .resume         = platform_resume,
311 };
312
313 int __init platform_bus_init(void)
314 {
315         device_register(&platform_bus);
316         return bus_register(&platform_bus_type);
317 }
318
319 #ifndef ARCH_HAS_DMA_GET_REQUIRED_MASK
320 u64 dma_get_required_mask(struct device *dev)
321 {
322         u32 low_totalram = ((max_pfn - 1) << PAGE_SHIFT);
323         u32 high_totalram = ((max_pfn - 1) >> (32 - PAGE_SHIFT));
324         u64 mask;
325
326         if (!high_totalram) {
327                 /* convert to mask just covering totalram */
328                 low_totalram = (1 << (fls(low_totalram) - 1));
329                 low_totalram += low_totalram - 1;
330                 mask = low_totalram;
331         } else {
332                 high_totalram = (1 << (fls(high_totalram) - 1));
333                 high_totalram += high_totalram - 1;
334                 mask = (((u64)high_totalram) << 32) + 0xffffffff;
335         }
336         return mask & *dev->dma_mask;
337 }
338 EXPORT_SYMBOL_GPL(dma_get_required_mask);
339 #endif
340
341 EXPORT_SYMBOL_GPL(platform_bus);
342 EXPORT_SYMBOL_GPL(platform_bus_type);
343 EXPORT_SYMBOL_GPL(platform_add_devices);
344 EXPORT_SYMBOL_GPL(platform_device_register);
345 EXPORT_SYMBOL_GPL(platform_device_register_simple);
346 EXPORT_SYMBOL_GPL(platform_device_unregister);
347 EXPORT_SYMBOL_GPL(platform_get_irq);
348 EXPORT_SYMBOL_GPL(platform_get_resource);
349 EXPORT_SYMBOL_GPL(platform_get_irq_byname);
350 EXPORT_SYMBOL_GPL(platform_get_resource_byname);