aboutsummaryrefslogtreecommitdiffstats
path: root/arch/ppc/syslib/ppc_sys.c
diff options
context:
space:
mode:
Diffstat (limited to 'arch/ppc/syslib/ppc_sys.c')
-rw-r--r--arch/ppc/syslib/ppc_sys.c329
1 files changed, 0 insertions, 329 deletions
diff --git a/arch/ppc/syslib/ppc_sys.c b/arch/ppc/syslib/ppc_sys.c
deleted file mode 100644
index 837183c24dfc..000000000000
--- a/arch/ppc/syslib/ppc_sys.c
+++ /dev/null
@@ -1,329 +0,0 @@
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
19int (*ppc_sys_device_fixup) (struct platform_device * pdev);
20
21static int ppc_sys_inited;
22static int ppc_sys_func_inited;
23
24static 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
33void __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
47void __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
60static 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
68static 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
98void __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 */
106void __init
107ppc_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 */
122void *__init ppc_sys_get_pdata(enum ppc_sys_devices dev)
123{
124 return ppc_sys_platform_devices[dev].dev.platform_data;
125}
126
127void 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
146void 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 */
191void 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*/
219void 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
252void 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
265void 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
279void 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
290void 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
302static 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
329subsys_initcall(ppc_sys_init);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-28 00:40:48 -0500