Merge branches 'release', 'acpi_pm_device_sleep_state' and 'battery' into release
[linux-2.6] / arch / ppc / syslib / ppc_sys.c
1 /*
2  * PPC System library functions
3  *
4  * Maintainer: Kumar Gala <galak@kernel.crashing.org>
5  *
6  * Copyright 2005 Freescale Semiconductor Inc.
7  * Copyright 2005 MontaVista, Inc. by Vitaly Bordug <vbordug@ru.mvista.com>
8  *
9  * This program is free software; you can redistribute  it and/or modify it
10  * under  the terms of  the GNU General  Public License as published by the
11  * Free Software Foundation;  either version 2 of the  License, or (at your
12  * option) any later version.
13  */
14
15 #include <linux/string.h>
16 #include <linux/bootmem.h>
17 #include <asm/ppc_sys.h>
18
19 int (*ppc_sys_device_fixup) (struct platform_device * pdev);
20
21 static int ppc_sys_inited;
22 static int ppc_sys_func_inited;
23
24 static const char *ppc_sys_func_names[] = {
25         [PPC_SYS_FUNC_DUMMY] = "dummy",
26         [PPC_SYS_FUNC_ETH] = "eth",
27         [PPC_SYS_FUNC_UART] = "uart",
28         [PPC_SYS_FUNC_HLDC] = "hldc",
29         [PPC_SYS_FUNC_USB] = "usb",
30         [PPC_SYS_FUNC_IRDA] = "irda",
31 };
32
33 void __init identify_ppc_sys_by_id(u32 id)
34 {
35         unsigned int i = 0;
36         while (1) {
37                 if ((ppc_sys_specs[i].mask & id) == ppc_sys_specs[i].value)
38                         break;
39                 i++;
40         }
41
42         cur_ppc_sys_spec = &ppc_sys_specs[i];
43
44         return;
45 }
46
47 void __init identify_ppc_sys_by_name(char *name)
48 {
49         unsigned int i = 0;
50         while (ppc_sys_specs[i].ppc_sys_name[0]) {
51                 if (!strcmp(ppc_sys_specs[i].ppc_sys_name, name))
52                         break;
53                 i++;
54         }
55         cur_ppc_sys_spec = &ppc_sys_specs[i];
56
57         return;
58 }
59
60 static int __init count_sys_specs(void)
61 {
62         int i = 0;
63         while (ppc_sys_specs[i].ppc_sys_name[0])
64                 i++;
65         return i;
66 }
67
68 static int __init find_chip_by_name_and_id(char *name, u32 id)
69 {
70         int ret = -1;
71         unsigned int i = 0;
72         unsigned int j = 0;
73         unsigned int dups = 0;
74
75         unsigned char matched[count_sys_specs()];
76
77         while (ppc_sys_specs[i].ppc_sys_name[0]) {
78                 if (!strcmp(ppc_sys_specs[i].ppc_sys_name, name))
79                         matched[j++] = i;
80                 i++;
81         }
82
83         ret = i;
84
85         if (j != 0) {
86                 for (i = 0; i < j; i++) {
87                         if ((ppc_sys_specs[matched[i]].mask & id) ==
88                             ppc_sys_specs[matched[i]].value) {
89                                 ret = matched[i];
90                                 dups++;
91                         }
92                 }
93                 ret = (dups == 1) ? ret : (-1 * dups);
94         }
95         return ret;
96 }
97
98 void __init identify_ppc_sys_by_name_and_id(char *name, u32 id)
99 {
100         int i = find_chip_by_name_and_id(name, id);
101         BUG_ON(i < 0);
102         cur_ppc_sys_spec = &ppc_sys_specs[i];
103 }
104
105 /* Update all memory resources by paddr, call before platform_device_register */
106 void __init
107 ppc_sys_fixup_mem_resource(struct platform_device *pdev, phys_addr_t paddr)
108 {
109         int i;
110         for (i = 0; i < pdev->num_resources; i++) {
111                 struct resource *r = &pdev->resource[i];
112                 if (((r->flags & IORESOURCE_MEM) == IORESOURCE_MEM) && 
113                         ((r->flags & PPC_SYS_IORESOURCE_FIXUPPED) != PPC_SYS_IORESOURCE_FIXUPPED)) {
114                         r->start += paddr;
115                         r->end += paddr;
116                         r->flags |= PPC_SYS_IORESOURCE_FIXUPPED;
117                 }
118         }
119 }
120
121 /* Get platform_data pointer out of platform device, call before platform_device_register */
122 void *__init ppc_sys_get_pdata(enum ppc_sys_devices dev)
123 {
124         return ppc_sys_platform_devices[dev].dev.platform_data;
125 }
126
127 void ppc_sys_device_remove(enum ppc_sys_devices dev)
128 {
129         unsigned int i;
130
131         if (ppc_sys_inited) {
132                 platform_device_unregister(&ppc_sys_platform_devices[dev]);
133         } else {
134                 if (cur_ppc_sys_spec == NULL)
135                         return;
136                 for (i = 0; i < cur_ppc_sys_spec->num_devices; i++)
137                         if (cur_ppc_sys_spec->device_list[i] == dev)
138                                 cur_ppc_sys_spec->device_list[i] = -1;
139         }
140 }
141
142 /* Platform-notify mapping
143  * Helper function for BSP code to assign board-specific platfom-divice bits
144  */
145
146 void platform_notify_map(const struct platform_notify_dev_map *map,
147                          struct device *dev)
148 {
149         struct platform_device *pdev;
150         int len, idx;
151         const char *s;
152
153         /* do nothing if no device or no bus_id */
154         if (!dev || !dev->bus_id)
155                 return;
156
157         /* call per device map */
158         while (map->bus_id != NULL) {
159                 idx = -1;
160                 s = strrchr(dev->bus_id, '.');
161                 if (s != NULL) {
162                         idx = (int)simple_strtol(s + 1, NULL, 10);
163                         len = s - dev->bus_id;
164                 } else {
165                         s = dev->bus_id;
166                         len = strlen(dev->bus_id);
167                 }
168
169                 if (!strncmp(dev->bus_id, map->bus_id, len)) {
170                         pdev = container_of(dev, struct platform_device, dev);
171                         map->rtn(pdev, idx);
172                 }
173                 map++;
174         }
175 }
176
177 /*
178    Function assignment stuff.
179  Intended to work as follows:
180  the device name defined in foo_devices.c will be concatenated with :"func",
181  where func is string map of respective function from platfom_device_func enum
182
183  The PPC_SYS_FUNC_DUMMY function is intended to remove all assignments, making the device to appear
184  in platform bus with unmodified name.
185  */
186
187 /*
188    Here we'll replace .name pointers with fixed-length strings
189    Hereby, this should be called *before* any func stuff triggeded.
190  */
191 void ppc_sys_device_initfunc(void)
192 {
193         int i;
194         const char *name;
195         static char new_names[NUM_PPC_SYS_DEVS][BUS_ID_SIZE];
196         enum ppc_sys_devices cur_dev;
197
198         /* If inited yet, do nothing */
199         if (ppc_sys_func_inited)
200                 return;
201
202         for (i = 0; i < cur_ppc_sys_spec->num_devices; i++) {
203                 if ((cur_dev = cur_ppc_sys_spec->device_list[i]) < 0)
204                         continue;
205
206                 if (ppc_sys_platform_devices[cur_dev].name) {
207                         /*backup name */
208                         name = ppc_sys_platform_devices[cur_dev].name;
209                         strlcpy(new_names[i], name, BUS_ID_SIZE);
210                         ppc_sys_platform_devices[cur_dev].name = new_names[i];
211                 }
212         }
213
214         ppc_sys_func_inited = 1;
215 }
216
217 /*The "engine" of the func stuff. Here we either concat specified function string description
218  to the name, or remove it if PPC_SYS_FUNC_DUMMY parameter is passed here*/
219 void ppc_sys_device_setfunc(enum ppc_sys_devices dev,
220                             enum platform_device_func func)
221 {
222         char *s;
223         char *name = (char *)ppc_sys_platform_devices[dev].name;
224         char tmp[BUS_ID_SIZE];
225
226         if (!ppc_sys_func_inited) {
227                 printk(KERN_ERR "Unable to alter function - not inited!\n");
228                 return;
229         }
230
231         if (ppc_sys_inited) {
232                 platform_device_unregister(&ppc_sys_platform_devices[dev]);
233         }
234
235         if ((s = (char *)strchr(name, ':')) != NULL) {  /* reassign */
236                 /* Either change the name after ':' or remove func modifications */
237                 if (func != PPC_SYS_FUNC_DUMMY)
238                         strlcpy(s + 1, ppc_sys_func_names[func], BUS_ID_SIZE);
239                 else
240                         *s = 0;
241         } else if (func != PPC_SYS_FUNC_DUMMY) {
242                 /* do assignment if it is not just "clear"  request */
243                 sprintf(tmp, "%s:%s", name, ppc_sys_func_names[func]);
244                 strlcpy(name, tmp, BUS_ID_SIZE);
245         }
246
247         if (ppc_sys_inited) {
248                 platform_device_register(&ppc_sys_platform_devices[dev]);
249         }
250 }
251
252 void ppc_sys_device_disable(enum ppc_sys_devices dev)
253 {
254         BUG_ON(cur_ppc_sys_spec == NULL);
255
256         /*Check if it is enabled*/
257         if(!(cur_ppc_sys_spec->config[dev] & PPC_SYS_CONFIG_DISABLED)) {
258                 if (ppc_sys_inited) {
259                         platform_device_unregister(&ppc_sys_platform_devices[dev]);
260                 }
261                 cur_ppc_sys_spec->config[dev] |= PPC_SYS_CONFIG_DISABLED;
262         }
263 }
264
265 void ppc_sys_device_enable(enum ppc_sys_devices dev)
266 {
267         BUG_ON(cur_ppc_sys_spec == NULL);
268
269         /*Check if it is disabled*/
270         if(cur_ppc_sys_spec->config[dev] & PPC_SYS_CONFIG_DISABLED) {
271                 if (ppc_sys_inited) {
272                         platform_device_register(&ppc_sys_platform_devices[dev]);
273                 }
274                 cur_ppc_sys_spec->config[dev] &= ~PPC_SYS_CONFIG_DISABLED;
275         }
276
277 }
278
279 void ppc_sys_device_enable_all(void)
280 {
281         enum ppc_sys_devices cur_dev;
282         int i;
283
284         for (i = 0; i < cur_ppc_sys_spec->num_devices; i++) {
285                 cur_dev = cur_ppc_sys_spec->device_list[i];
286                 ppc_sys_device_enable(cur_dev);
287         }
288 }
289
290 void ppc_sys_device_disable_all(void)
291 {
292         enum ppc_sys_devices cur_dev;
293         int i;
294
295         for (i = 0; i < cur_ppc_sys_spec->num_devices; i++) {
296                 cur_dev = cur_ppc_sys_spec->device_list[i];
297                 ppc_sys_device_disable(cur_dev);
298         }
299 }
300
301
302 static int __init ppc_sys_init(void)
303 {
304         unsigned int i, dev_id, ret = 0;
305
306         BUG_ON(cur_ppc_sys_spec == NULL);
307
308         for (i = 0; i < cur_ppc_sys_spec->num_devices; i++) {
309                 dev_id = cur_ppc_sys_spec->device_list[i];
310                 if ((dev_id != -1) &&
311                 !(cur_ppc_sys_spec->config[dev_id] & PPC_SYS_CONFIG_DISABLED)) {
312                         if (ppc_sys_device_fixup != NULL)
313                                 ppc_sys_device_fixup(&ppc_sys_platform_devices
314                                                      [dev_id]);
315                         if (platform_device_register
316                             (&ppc_sys_platform_devices[dev_id])) {
317                                 ret = 1;
318                                 printk(KERN_ERR
319                                        "unable to register device %d\n",
320                                        dev_id);
321                         }
322                 }
323         }
324
325         ppc_sys_inited = 1;
326         return ret;
327 }
328
329 subsys_initcall(ppc_sys_init);