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-lenght 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);
330