?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[POWERPC] FSL: enet device tree cleanups
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / arch / powerpc / sysdev / fsl_soc.c
blob4baad80ab7316da61053dc7a3dd1a568497dcddd
1 /*
2 * FSL SoC setup code
3 *
4 * Maintained by Kumar Gala (see MAINTAINERS for contact information)
5 *
6 * 2006 (c) MontaVista Software, Inc.
7 * 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/stddef.h>
16 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/errno.h>
19 #include <linux/major.h>
20 #include <linux/delay.h>
21 #include <linux/irq.h>
22 #include <linux/module.h>
23 #include <linux/device.h>
24 #include <linux/platform_device.h>
25 #include <linux/of_platform.h>
26 #include <linux/phy.h>
27 #include <linux/spi/spi.h>
28 #include <linux/fsl_devices.h>
29 #include <linux/fs_enet_pd.h>
30 #include <linux/fs_uart_pd.h>
31
32 #include <asm/system.h>
33 #include <asm/atomic.h>
34 #include <asm/io.h>
35 #include <asm/irq.h>
36 #include <asm/time.h>
37 #include <asm/prom.h>
38 #include <sysdev/fsl_soc.h>
39 #include <mm/mmu_decl.h>
40 #include <asm/cpm2.h>
41
42 extern void init_fcc_ioports(struct fs_platform_info*);
43 extern void init_fec_ioports(struct fs_platform_info*);
44 extern void init_smc_ioports(struct fs_uart_platform_info*);
45 static phys_addr_t immrbase = -1;
46
47 phys_addr_t get_immrbase(void)
48 {
49 struct device_node *soc;
50
51 if (immrbase != -1)
52 return immrbase;
53
54 soc = of_find_node_by_type(NULL, "soc");
55 if (soc) {
56 int size;
57 const void *prop = of_get_property(soc, "reg", &size);
58
59 if (prop)
60 immrbase = of_translate_address(soc, prop);
61 of_node_put(soc);
62 }
63
64 return immrbase;
65 }
66
67 EXPORT_SYMBOL(get_immrbase);
68
69 #if defined(CONFIG_CPM2) || defined(CONFIG_8xx)
70
71 static u32 brgfreq = -1;
72
73 u32 get_brgfreq(void)
74 {
75 struct device_node *node;
76 const unsigned int *prop;
77 int size;
78
79 if (brgfreq != -1)
80 return brgfreq;
81
82 node = of_find_compatible_node(NULL, NULL, "fsl,cpm-brg");
83 if (node) {
84 prop = of_get_property(node, "clock-frequency", &size);
85 if (prop && size == 4)
86 brgfreq = *prop;
87
88 of_node_put(node);
89 return brgfreq;
90 }
91
92 /* Legacy device binding -- will go away when no users are left. */
93 node = of_find_node_by_type(NULL, "cpm");
94 if (node) {
95 prop = of_get_property(node, "brg-frequency", &size);
96 if (prop && size == 4)
97 brgfreq = *prop;
98
99 of_node_put(node);
100 }
101
102 return brgfreq;
103 }
104
105 EXPORT_SYMBOL(get_brgfreq);
106
107 static u32 fs_baudrate = -1;
108
109 u32 get_baudrate(void)
110 {
111 struct device_node *node;
112
113 if (fs_baudrate != -1)
114 return fs_baudrate;
115
116 node = of_find_node_by_type(NULL, "serial");
117 if (node) {
118 int size;
119 const unsigned int *prop = of_get_property(node,
120 "current-speed", &size);
121
122 if (prop)
123 fs_baudrate = *prop;
124 of_node_put(node);
125 }
126
127 return fs_baudrate;
128 }
129
130 EXPORT_SYMBOL(get_baudrate);
131 #endif /* CONFIG_CPM2 */
132
133 static int __init gfar_mdio_of_init(void)
134 {
135 struct device_node *np = NULL;
136 struct platform_device *mdio_dev;
137 struct resource res;
138 int ret;
139
140 np = of_find_compatible_node(np, NULL, "fsl,gianfar-mdio");
141
142 /* try the deprecated version */
143 if (!np)
144 np = of_find_compatible_node(np, "mdio", "gianfar");
145
146 if (np) {
147 int k;
148 struct device_node *child = NULL;
149 struct gianfar_mdio_data mdio_data;
150
151 memset(&res, 0, sizeof(res));
152 memset(&mdio_data, 0, sizeof(mdio_data));
153
154 ret = of_address_to_resource(np, 0, &res);
155 if (ret)
156 goto err;
157
158 mdio_dev =
159 platform_device_register_simple("fsl-gianfar_mdio",
160 res.start, &res, 1);
161 if (IS_ERR(mdio_dev)) {
162 ret = PTR_ERR(mdio_dev);
163 goto err;
164 }
165
166 for (k = 0; k < 32; k++)
167 mdio_data.irq[k] = PHY_POLL;
168
169 while ((child = of_get_next_child(np, child)) != NULL) {
170 int irq = irq_of_parse_and_map(child, 0);
171 if (irq != NO_IRQ) {
172 const u32 *id = of_get_property(child,
173 "reg", NULL);
174 mdio_data.irq[*id] = irq;
175 }
176 }
177
178 ret =
179 platform_device_add_data(mdio_dev, &mdio_data,
180 sizeof(struct gianfar_mdio_data));
181 if (ret)
182 goto unreg;
183 }
184
185 of_node_put(np);
186 return 0;
187
188 unreg:
189 platform_device_unregister(mdio_dev);
190 err:
191 of_node_put(np);
192 return ret;
193 }
194
195 arch_initcall(gfar_mdio_of_init);
196
197 static const char *gfar_tx_intr = "tx";
198 static const char *gfar_rx_intr = "rx";
199 static const char *gfar_err_intr = "error";
200
201
202 static int __init gfar_of_init(void)
203 {
204 struct device_node *np;
205 unsigned int i;
206 struct platform_device *gfar_dev;
207 struct resource res;
208 int ret;
209
210 for (np = NULL, i = 0;
211 (np = of_find_compatible_node(np, "network", "gianfar")) != NULL;
212 i++) {
213 struct resource r[4];
214 struct device_node *phy, *mdio;
215 struct gianfar_platform_data gfar_data;
216 const unsigned int *id;
217 const char *model;
218 const char *ctype;
219 const void *mac_addr;
220 const phandle *ph;
221 int n_res = 2;
222
223 memset(r, 0, sizeof(r));
224 memset(&gfar_data, 0, sizeof(gfar_data));
225
226 ret = of_address_to_resource(np, 0, &r[0]);
227 if (ret)
228 goto err;
229
230 of_irq_to_resource(np, 0, &r[1]);
231
232 model = of_get_property(np, "model", NULL);
233
234 /* If we aren't the FEC we have multiple interrupts */
235 if (model && strcasecmp(model, "FEC")) {
236 r[1].name = gfar_tx_intr;
237
238 r[2].name = gfar_rx_intr;
239 of_irq_to_resource(np, 1, &r[2]);
240
241 r[3].name = gfar_err_intr;
242 of_irq_to_resource(np, 2, &r[3]);
243
244 n_res += 2;
245 }
246
247 gfar_dev =
248 platform_device_register_simple("fsl-gianfar", i, &r[0],
249 n_res);
250
251 if (IS_ERR(gfar_dev)) {
252 ret = PTR_ERR(gfar_dev);
253 goto err;
254 }
255
256 mac_addr = of_get_mac_address(np);
257 if (mac_addr)
258 memcpy(gfar_data.mac_addr, mac_addr, 6);
259
260 if (model && !strcasecmp(model, "TSEC"))
261 gfar_data.device_flags =
262 FSL_GIANFAR_DEV_HAS_GIGABIT |
263 FSL_GIANFAR_DEV_HAS_COALESCE |
264 FSL_GIANFAR_DEV_HAS_RMON |
265 FSL_GIANFAR_DEV_HAS_MULTI_INTR;
266 if (model && !strcasecmp(model, "eTSEC"))
267 gfar_data.device_flags =
268 FSL_GIANFAR_DEV_HAS_GIGABIT |
269 FSL_GIANFAR_DEV_HAS_COALESCE |
270 FSL_GIANFAR_DEV_HAS_RMON |
271 FSL_GIANFAR_DEV_HAS_MULTI_INTR |
272 FSL_GIANFAR_DEV_HAS_CSUM |
273 FSL_GIANFAR_DEV_HAS_VLAN |
274 FSL_GIANFAR_DEV_HAS_EXTENDED_HASH;
275
276 ctype = of_get_property(np, "phy-connection-type", NULL);
277
278 /* We only care about rgmii-id. The rest are autodetected */
279 if (ctype && !strcmp(ctype, "rgmii-id"))
280 gfar_data.interface = PHY_INTERFACE_MODE_RGMII_ID;
281 else
282 gfar_data.interface = PHY_INTERFACE_MODE_MII;
283
284 ph = of_get_property(np, "phy-handle", NULL);
285 phy = of_find_node_by_phandle(*ph);
286
287 if (phy == NULL) {
288 ret = -ENODEV;
289 goto unreg;
290 }
291
292 mdio = of_get_parent(phy);
293
294 id = of_get_property(phy, "reg", NULL);
295 ret = of_address_to_resource(mdio, 0, &res);
296 if (ret) {
297 of_node_put(phy);
298 of_node_put(mdio);
299 goto unreg;
300 }
301
302 gfar_data.phy_id = *id;
303 gfar_data.bus_id = res.start;
304
305 of_node_put(phy);
306 of_node_put(mdio);
307
308 ret =
309 platform_device_add_data(gfar_dev, &gfar_data,
310 sizeof(struct
311 gianfar_platform_data));
312 if (ret)
313 goto unreg;
314 }
315
316 return 0;
317
318 unreg:
319 platform_device_unregister(gfar_dev);
320 err:
321 return ret;
322 }
323
324 arch_initcall(gfar_of_init);
325
326 #ifdef CONFIG_I2C_BOARDINFO
327 #include <linux/i2c.h>
328 struct i2c_driver_device {
329 char *of_device;
330 char *i2c_driver;
331 char *i2c_type;
332 };
333
334 static struct i2c_driver_device i2c_devices[] __initdata = {
335 {"ricoh,rs5c372a", "rtc-rs5c372", "rs5c372a",},
336 {"ricoh,rs5c372b", "rtc-rs5c372", "rs5c372b",},
337 {"ricoh,rv5c386", "rtc-rs5c372", "rv5c386",},
338 {"ricoh,rv5c387a", "rtc-rs5c372", "rv5c387a",},
339 {"dallas,ds1307", "rtc-ds1307", "ds1307",},
340 {"dallas,ds1337", "rtc-ds1307", "ds1337",},
341 {"dallas,ds1338", "rtc-ds1307", "ds1338",},
342 {"dallas,ds1339", "rtc-ds1307", "ds1339",},
343 {"dallas,ds1340", "rtc-ds1307", "ds1340",},
344 {"stm,m41t00", "rtc-ds1307", "m41t00"},
345 {"dallas,ds1374", "rtc-ds1374", "rtc-ds1374",},
346 };
347
348 static int __init of_find_i2c_driver(struct device_node *node,
349 struct i2c_board_info *info)
350 {
351 int i;
352
353 for (i = 0; i < ARRAY_SIZE(i2c_devices); i++) {
354 if (!of_device_is_compatible(node, i2c_devices[i].of_device))
355 continue;
356 if (strlcpy(info->driver_name, i2c_devices[i].i2c_driver,
357 KOBJ_NAME_LEN) >= KOBJ_NAME_LEN ||
358 strlcpy(info->type, i2c_devices[i].i2c_type,
359 I2C_NAME_SIZE) >= I2C_NAME_SIZE)
360 return -ENOMEM;
361 return 0;
362 }
363 return -ENODEV;
364 }
365
366 static void __init of_register_i2c_devices(struct device_node *adap_node,
367 int bus_num)
368 {
369 struct device_node *node = NULL;
370
371 while ((node = of_get_next_child(adap_node, node))) {
372 struct i2c_board_info info = {};
373 const u32 *addr;
374 int len;
375
376 addr = of_get_property(node, "reg", &len);
377 if (!addr || len < sizeof(int) || *addr > (1 << 10) - 1) {
378 printk(KERN_WARNING "fsl_soc.c: invalid i2c device entry\n");
379 continue;
380 }
381
382 info.irq = irq_of_parse_and_map(node, 0);
383 if (info.irq == NO_IRQ)
384 info.irq = -1;
385
386 if (of_find_i2c_driver(node, &info) < 0)
387 continue;
388
389 info.addr = *addr;
390
391 i2c_register_board_info(bus_num, &info, 1);
392 }
393 }
394
395 static int __init fsl_i2c_of_init(void)
396 {
397 struct device_node *np;
398 unsigned int i = 0;
399 struct platform_device *i2c_dev;
400 int ret;
401
402 for_each_compatible_node(np, NULL, "fsl-i2c") {
403 struct resource r[2];
404 struct fsl_i2c_platform_data i2c_data;
405 const unsigned char *flags = NULL;
406
407 memset(&r, 0, sizeof(r));
408 memset(&i2c_data, 0, sizeof(i2c_data));
409
410 ret = of_address_to_resource(np, 0, &r[0]);
411 if (ret)
412 goto err;
413
414 of_irq_to_resource(np, 0, &r[1]);
415
416 i2c_dev = platform_device_register_simple("fsl-i2c", i, r, 2);
417 if (IS_ERR(i2c_dev)) {
418 ret = PTR_ERR(i2c_dev);
419 goto err;
420 }
421
422 i2c_data.device_flags = 0;
423 flags = of_get_property(np, "dfsrr", NULL);
424 if (flags)
425 i2c_data.device_flags |= FSL_I2C_DEV_SEPARATE_DFSRR;
426
427 flags = of_get_property(np, "fsl5200-clocking", NULL);
428 if (flags)
429 i2c_data.device_flags |= FSL_I2C_DEV_CLOCK_5200;
430
431 ret =
432 platform_device_add_data(i2c_dev, &i2c_data,
433 sizeof(struct
434 fsl_i2c_platform_data));
435 if (ret)
436 goto unreg;
437
438 of_register_i2c_devices(np, i++);
439 }
440
441 return 0;
442
443 unreg:
444 platform_device_unregister(i2c_dev);
445 err:
446 return ret;
447 }
448
449 arch_initcall(fsl_i2c_of_init);
450 #endif
451
452 #ifdef CONFIG_PPC_83xx
453 static int __init mpc83xx_wdt_init(void)
454 {
455 struct resource r;
456 struct device_node *soc, *np;
457 struct platform_device *dev;
458 const unsigned int *freq;
459 int ret;
460
461 np = of_find_compatible_node(NULL, "watchdog", "mpc83xx_wdt");
462
463 if (!np) {
464 ret = -ENODEV;
465 goto nodev;
466 }
467
468 soc = of_find_node_by_type(NULL, "soc");
469
470 if (!soc) {
471 ret = -ENODEV;
472 goto nosoc;
473 }
474
475 freq = of_get_property(soc, "bus-frequency", NULL);
476 if (!freq) {
477 ret = -ENODEV;
478 goto err;
479 }
480
481 memset(&r, 0, sizeof(r));
482
483 ret = of_address_to_resource(np, 0, &r);
484 if (ret)
485 goto err;
486
487 dev = platform_device_register_simple("mpc83xx_wdt", 0, &r, 1);
488 if (IS_ERR(dev)) {
489 ret = PTR_ERR(dev);
490 goto err;
491 }
492
493 ret = platform_device_add_data(dev, freq, sizeof(int));
494 if (ret)
495 goto unreg;
496
497 of_node_put(soc);
498 of_node_put(np);
499
500 return 0;
501
502 unreg:
503 platform_device_unregister(dev);
504 err:
505 of_node_put(soc);
506 nosoc:
507 of_node_put(np);
508 nodev:
509 return ret;
510 }
511
512 arch_initcall(mpc83xx_wdt_init);
513 #endif
514
515 static enum fsl_usb2_phy_modes determine_usb_phy(const char *phy_type)
516 {
517 if (!phy_type)
518 return FSL_USB2_PHY_NONE;
519 if (!strcasecmp(phy_type, "ulpi"))
520 return FSL_USB2_PHY_ULPI;
521 if (!strcasecmp(phy_type, "utmi"))
522 return FSL_USB2_PHY_UTMI;
523 if (!strcasecmp(phy_type, "utmi_wide"))
524 return FSL_USB2_PHY_UTMI_WIDE;
525 if (!strcasecmp(phy_type, "serial"))
526 return FSL_USB2_PHY_SERIAL;
527
528 return FSL_USB2_PHY_NONE;
529 }
530
531 static int __init fsl_usb_of_init(void)
532 {
533 struct device_node *np;
534 unsigned int i;
535 struct platform_device *usb_dev_mph = NULL, *usb_dev_dr_host = NULL,
536 *usb_dev_dr_client = NULL;
537 int ret;
538
539 for (np = NULL, i = 0;
540 (np = of_find_compatible_node(np, "usb", "fsl-usb2-mph")) != NULL;
541 i++) {
542 struct resource r[2];
543 struct fsl_usb2_platform_data usb_data;
544 const unsigned char *prop = NULL;
545
546 memset(&r, 0, sizeof(r));
547 memset(&usb_data, 0, sizeof(usb_data));
548
549 ret = of_address_to_resource(np, 0, &r[0]);
550 if (ret)
551 goto err;
552
553 of_irq_to_resource(np, 0, &r[1]);
554
555 usb_dev_mph =
556 platform_device_register_simple("fsl-ehci", i, r, 2);
557 if (IS_ERR(usb_dev_mph)) {
558 ret = PTR_ERR(usb_dev_mph);
559 goto err;
560 }
561
562 usb_dev_mph->dev.coherent_dma_mask = 0xffffffffUL;
563 usb_dev_mph->dev.dma_mask = &usb_dev_mph->dev.coherent_dma_mask;
564
565 usb_data.operating_mode = FSL_USB2_MPH_HOST;
566
567 prop = of_get_property(np, "port0", NULL);
568 if (prop)
569 usb_data.port_enables |= FSL_USB2_PORT0_ENABLED;
570
571 prop = of_get_property(np, "port1", NULL);
572 if (prop)
573 usb_data.port_enables |= FSL_USB2_PORT1_ENABLED;
574
575 prop = of_get_property(np, "phy_type", NULL);
576 usb_data.phy_mode = determine_usb_phy(prop);
577
578 ret =
579 platform_device_add_data(usb_dev_mph, &usb_data,
580 sizeof(struct
581 fsl_usb2_platform_data));
582 if (ret)
583 goto unreg_mph;
584 }
585
586 for (np = NULL;
587 (np = of_find_compatible_node(np, "usb", "fsl-usb2-dr")) != NULL;
588 i++) {
589 struct resource r[2];
590 struct fsl_usb2_platform_data usb_data;
591 const unsigned char *prop = NULL;
592
593 memset(&r, 0, sizeof(r));
594 memset(&usb_data, 0, sizeof(usb_data));
595
596 ret = of_address_to_resource(np, 0, &r[0]);
597 if (ret)
598 goto unreg_mph;
599
600 of_irq_to_resource(np, 0, &r[1]);
601
602 prop = of_get_property(np, "dr_mode", NULL);
603
604 if (!prop || !strcmp(prop, "host")) {
605 usb_data.operating_mode = FSL_USB2_DR_HOST;
606 usb_dev_dr_host = platform_device_register_simple(
607 "fsl-ehci", i, r, 2);
608 if (IS_ERR(usb_dev_dr_host)) {
609 ret = PTR_ERR(usb_dev_dr_host);
610 goto err;
611 }
612 } else if (prop && !strcmp(prop, "peripheral")) {
613 usb_data.operating_mode = FSL_USB2_DR_DEVICE;
614 usb_dev_dr_client = platform_device_register_simple(
615 "fsl-usb2-udc", i, r, 2);
616 if (IS_ERR(usb_dev_dr_client)) {
617 ret = PTR_ERR(usb_dev_dr_client);
618 goto err;
619 }
620 } else if (prop && !strcmp(prop, "otg")) {
621 usb_data.operating_mode = FSL_USB2_DR_OTG;
622 usb_dev_dr_host = platform_device_register_simple(
623 "fsl-ehci", i, r, 2);
624 if (IS_ERR(usb_dev_dr_host)) {
625 ret = PTR_ERR(usb_dev_dr_host);
626 goto err;
627 }
628 usb_dev_dr_client = platform_device_register_simple(
629 "fsl-usb2-udc", i, r, 2);
630 if (IS_ERR(usb_dev_dr_client)) {
631 ret = PTR_ERR(usb_dev_dr_client);
632 goto err;
633 }
634 } else {
635 ret = -EINVAL;
636 goto err;
637 }
638
639 prop = of_get_property(np, "phy_type", NULL);
640 usb_data.phy_mode = determine_usb_phy(prop);
641
642 if (usb_dev_dr_host) {
643 usb_dev_dr_host->dev.coherent_dma_mask = 0xffffffffUL;
644 usb_dev_dr_host->dev.dma_mask = &usb_dev_dr_host->
645 dev.coherent_dma_mask;
646 if ((ret = platform_device_add_data(usb_dev_dr_host,
647 &usb_data, sizeof(struct
648 fsl_usb2_platform_data))))
649 goto unreg_dr;
650 }
651 if (usb_dev_dr_client) {
652 usb_dev_dr_client->dev.coherent_dma_mask = 0xffffffffUL;
653 usb_dev_dr_client->dev.dma_mask = &usb_dev_dr_client->
654 dev.coherent_dma_mask;
655 if ((ret = platform_device_add_data(usb_dev_dr_client,
656 &usb_data, sizeof(struct
657 fsl_usb2_platform_data))))
658 goto unreg_dr;
659 }
660 }
661 return 0;
662
663 unreg_dr:
664 if (usb_dev_dr_host)
665 platform_device_unregister(usb_dev_dr_host);
666 if (usb_dev_dr_client)
667 platform_device_unregister(usb_dev_dr_client);
668 unreg_mph:
669 if (usb_dev_mph)
670 platform_device_unregister(usb_dev_mph);
671 err:
672 return ret;
673 }
674
675 arch_initcall(fsl_usb_of_init);
676
677 #ifndef CONFIG_PPC_CPM_NEW_BINDING
678 #ifdef CONFIG_CPM2
679
680 extern void init_scc_ioports(struct fs_uart_platform_info*);
681
682 static const char fcc_regs[] = "fcc_regs";
683 static const char fcc_regs_c[] = "fcc_regs_c";
684 static const char fcc_pram[] = "fcc_pram";
685 static char bus_id[9][BUS_ID_SIZE];
686
687 static int __init fs_enet_of_init(void)
688 {
689 struct device_node *np;
690 unsigned int i;
691 struct platform_device *fs_enet_dev;
692 struct resource res;
693 int ret;
694
695 for (np = NULL, i = 0;
696 (np = of_find_compatible_node(np, "network", "fs_enet")) != NULL;
697 i++) {
698 struct resource r[4];
699 struct device_node *phy, *mdio;
700 struct fs_platform_info fs_enet_data;
701 const unsigned int *id, *phy_addr, *phy_irq;
702 const void *mac_addr;
703 const phandle *ph;
704 const char *model;
705
706 memset(r, 0, sizeof(r));
707 memset(&fs_enet_data, 0, sizeof(fs_enet_data));
708
709 ret = of_address_to_resource(np, 0, &r[0]);
710 if (ret)
711 goto err;
712 r[0].name = fcc_regs;
713
714 ret = of_address_to_resource(np, 1, &r[1]);
715 if (ret)
716 goto err;
717 r[1].name = fcc_pram;
718
719 ret = of_address_to_resource(np, 2, &r[2]);
720 if (ret)
721 goto err;
722 r[2].name = fcc_regs_c;
723 fs_enet_data.fcc_regs_c = r[2].start;
724
725 of_irq_to_resource(np, 0, &r[3]);
726
727 fs_enet_dev =
728 platform_device_register_simple("fsl-cpm-fcc", i, &r[0], 4);
729
730 if (IS_ERR(fs_enet_dev)) {
731 ret = PTR_ERR(fs_enet_dev);
732 goto err;
733 }
734
735 model = of_get_property(np, "model", NULL);
736 if (model == NULL) {
737 ret = -ENODEV;
738 goto unreg;
739 }
740
741 mac_addr = of_get_mac_address(np);
742 if (mac_addr)
743 memcpy(fs_enet_data.macaddr, mac_addr, 6);
744
745 ph = of_get_property(np, "phy-handle", NULL);
746 phy = of_find_node_by_phandle(*ph);
747
748 if (phy == NULL) {
749 ret = -ENODEV;
750 goto unreg;
751 }
752
753 phy_addr = of_get_property(phy, "reg", NULL);
754 fs_enet_data.phy_addr = *phy_addr;
755
756 phy_irq = of_get_property(phy, "interrupts", NULL);
757
758 id = of_get_property(np, "device-id", NULL);
759 fs_enet_data.fs_no = *id;
760 strcpy(fs_enet_data.fs_type, model);
761
762 mdio = of_get_parent(phy);
763 ret = of_address_to_resource(mdio, 0, &res);
764 if (ret) {
765 of_node_put(phy);
766 of_node_put(mdio);
767 goto unreg;
768 }
769
770 fs_enet_data.clk_rx = *((u32 *)of_get_property(np,
771 "rx-clock", NULL));
772 fs_enet_data.clk_tx = *((u32 *)of_get_property(np,
773 "tx-clock", NULL));
774
775 if (strstr(model, "FCC")) {
776 int fcc_index = *id - 1;
777 const unsigned char *mdio_bb_prop;
778
779 fs_enet_data.dpram_offset = (u32)cpm_dpram_addr(0);
780 fs_enet_data.rx_ring = 32;
781 fs_enet_data.tx_ring = 32;
782 fs_enet_data.rx_copybreak = 240;
783 fs_enet_data.use_napi = 0;
784 fs_enet_data.napi_weight = 17;
785 fs_enet_data.mem_offset = FCC_MEM_OFFSET(fcc_index);
786 fs_enet_data.cp_page = CPM_CR_FCC_PAGE(fcc_index);
787 fs_enet_data.cp_block = CPM_CR_FCC_SBLOCK(fcc_index);
788
789 snprintf((char*)&bus_id[(*id)], BUS_ID_SIZE, "%x:%02x",
790 (u32)res.start, fs_enet_data.phy_addr);
791 fs_enet_data.bus_id = (char*)&bus_id[(*id)];
792 fs_enet_data.init_ioports = init_fcc_ioports;
793
794 mdio_bb_prop = of_get_property(phy, "bitbang", NULL);
795 if (mdio_bb_prop) {
796 struct platform_device *fs_enet_mdio_bb_dev;
797 struct fs_mii_bb_platform_info fs_enet_mdio_bb_data;
798
799 fs_enet_mdio_bb_dev =
800 platform_device_register_simple("fsl-bb-mdio",
801 i, NULL, 0);
802 memset(&fs_enet_mdio_bb_data, 0,
803 sizeof(struct fs_mii_bb_platform_info));
804 fs_enet_mdio_bb_data.mdio_dat.bit =
805 mdio_bb_prop[0];
806 fs_enet_mdio_bb_data.mdio_dir.bit =
807 mdio_bb_prop[1];
808 fs_enet_mdio_bb_data.mdc_dat.bit =
809 mdio_bb_prop[2];
810 fs_enet_mdio_bb_data.mdio_port =
811 mdio_bb_prop[3];
812 fs_enet_mdio_bb_data.mdc_port =
813 mdio_bb_prop[4];
814 fs_enet_mdio_bb_data.delay =
815 mdio_bb_prop[5];
816
817 fs_enet_mdio_bb_data.irq[0] = phy_irq[0];
818 fs_enet_mdio_bb_data.irq[1] = -1;
819 fs_enet_mdio_bb_data.irq[2] = -1;
820 fs_enet_mdio_bb_data.irq[3] = phy_irq[0];
821 fs_enet_mdio_bb_data.irq[31] = -1;
822
823 fs_enet_mdio_bb_data.mdio_dat.offset =
824 (u32)&cpm2_immr->im_ioport.iop_pdatc;
825 fs_enet_mdio_bb_data.mdio_dir.offset =
826 (u32)&cpm2_immr->im_ioport.iop_pdirc;
827 fs_enet_mdio_bb_data.mdc_dat.offset =
828 (u32)&cpm2_immr->im_ioport.iop_pdatc;
829
830 ret = platform_device_add_data(
831 fs_enet_mdio_bb_dev,
832 &fs_enet_mdio_bb_data,
833 sizeof(struct fs_mii_bb_platform_info));
834 if (ret)
835 goto unreg;
836 }
837
838 of_node_put(phy);
839 of_node_put(mdio);
840
841 ret = platform_device_add_data(fs_enet_dev, &fs_enet_data,
842 sizeof(struct
843 fs_platform_info));
844 if (ret)
845 goto unreg;
846 }
847 }
848 return 0;
849
850 unreg:
851 platform_device_unregister(fs_enet_dev);
852 err:
853 return ret;
854 }
855
856 arch_initcall(fs_enet_of_init);
857
858 static const char scc_regs[] = "regs";
859 static const char scc_pram[] = "pram";
860
861 static int __init cpm_uart_of_init(void)
862 {
863 struct device_node *np;
864 unsigned int i;
865 struct platform_device *cpm_uart_dev;
866 int ret;
867
868 for (np = NULL, i = 0;
869 (np = of_find_compatible_node(np, "serial", "cpm_uart")) != NULL;
870 i++) {
871 struct resource r[3];
872 struct fs_uart_platform_info cpm_uart_data;
873 const int *id;
874 const char *model;
875
876 memset(r, 0, sizeof(r));
877 memset(&cpm_uart_data, 0, sizeof(cpm_uart_data));
878
879 ret = of_address_to_resource(np, 0, &r[0]);
880 if (ret)
881 goto err;
882
883 r[0].name = scc_regs;
884
885 ret = of_address_to_resource(np, 1, &r[1]);
886 if (ret)
887 goto err;
888 r[1].name = scc_pram;
889
890 of_irq_to_resource(np, 0, &r[2]);
891
892 cpm_uart_dev =
893 platform_device_register_simple("fsl-cpm-scc:uart", i, &r[0], 3);
894
895 if (IS_ERR(cpm_uart_dev)) {
896 ret = PTR_ERR(cpm_uart_dev);
897 goto err;
898 }
899
900 id = of_get_property(np, "device-id", NULL);
901 cpm_uart_data.fs_no = *id;
902
903 model = of_get_property(np, "model", NULL);
904 strcpy(cpm_uart_data.fs_type, model);
905
906 cpm_uart_data.uart_clk = ppc_proc_freq;
907
908 cpm_uart_data.tx_num_fifo = 4;
909 cpm_uart_data.tx_buf_size = 32;
910 cpm_uart_data.rx_num_fifo = 4;
911 cpm_uart_data.rx_buf_size = 32;
912 cpm_uart_data.clk_rx = *((u32 *)of_get_property(np,
913 "rx-clock", NULL));
914 cpm_uart_data.clk_tx = *((u32 *)of_get_property(np,
915 "tx-clock", NULL));
916
917 ret =
918 platform_device_add_data(cpm_uart_dev, &cpm_uart_data,
919 sizeof(struct
920 fs_uart_platform_info));
921 if (ret)
922 goto unreg;
923 }
924
925 return 0;
926
927 unreg:
928 platform_device_unregister(cpm_uart_dev);
929 err:
930 return ret;
931 }
932
933 arch_initcall(cpm_uart_of_init);
934 #endif /* CONFIG_CPM2 */
935
936 #ifdef CONFIG_8xx
937
938 extern void init_scc_ioports(struct fs_platform_info*);
939 extern int platform_device_skip(const char *model, int id);
940
941 static int __init fs_enet_mdio_of_init(void)
942 {
943 struct device_node *np;
944 unsigned int i;
945 struct platform_device *mdio_dev;
946 struct resource res;
947 int ret;
948
949 for (np = NULL, i = 0;
950 (np = of_find_compatible_node(np, "mdio", "fs_enet")) != NULL;
951 i++) {
952 struct fs_mii_fec_platform_info mdio_data;
953
954 memset(&res, 0, sizeof(res));
955 memset(&mdio_data, 0, sizeof(mdio_data));
956
957 ret = of_address_to_resource(np, 0, &res);
958 if (ret)
959 goto err;
960
961 mdio_dev =
962 platform_device_register_simple("fsl-cpm-fec-mdio",
963 res.start, &res, 1);
964 if (IS_ERR(mdio_dev)) {
965 ret = PTR_ERR(mdio_dev);
966 goto err;
967 }
968
969 mdio_data.mii_speed = ((((ppc_proc_freq + 4999999) / 2500000) / 2) & 0x3F) << 1;
970
971 ret =
972 platform_device_add_data(mdio_dev, &mdio_data,
973 sizeof(struct fs_mii_fec_platform_info));
974 if (ret)
975 goto unreg;
976 }
977 return 0;
978
979 unreg:
980 platform_device_unregister(mdio_dev);
981 err:
982 return ret;
983 }
984
985 arch_initcall(fs_enet_mdio_of_init);
986
987 static const char *enet_regs = "regs";
988 static const char *enet_pram = "pram";
989 static const char *enet_irq = "interrupt";
990 static char bus_id[9][BUS_ID_SIZE];
991
992 static int __init fs_enet_of_init(void)
993 {
994 struct device_node *np;
995 unsigned int i;
996 struct platform_device *fs_enet_dev = NULL;
997 struct resource res;
998 int ret;
999
1000 for (np = NULL, i = 0;
1001 (np = of_find_compatible_node(np, "network", "fs_enet")) != NULL;
1002 i++) {
1003 struct resource r[4];
1004 struct device_node *phy = NULL, *mdio = NULL;
1005 struct fs_platform_info fs_enet_data;
1006 const unsigned int *id;
1007 const unsigned int *phy_addr;
1008 const void *mac_addr;
1009 const phandle *ph;
1010 const char *model;
1011
1012 memset(r, 0, sizeof(r));
1013 memset(&fs_enet_data, 0, sizeof(fs_enet_data));
1014
1015 model = of_get_property(np, "model", NULL);
1016 if (model == NULL) {
1017 ret = -ENODEV;
1018 goto unreg;
1019 }
1020
1021 id = of_get_property(np, "device-id", NULL);
1022 fs_enet_data.fs_no = *id;
1023
1024 if (platform_device_skip(model, *id))
1025 continue;
1026
1027 ret = of_address_to_resource(np, 0, &r[0]);
1028 if (ret)
1029 goto err;
1030 r[0].name = enet_regs;
1031
1032 mac_addr = of_get_mac_address(np);
1033 if (mac_addr)
1034 memcpy(fs_enet_data.macaddr, mac_addr, 6);
1035
1036 ph = of_get_property(np, "phy-handle", NULL);
1037 if (ph != NULL)
1038 phy = of_find_node_by_phandle(*ph);
1039
1040 if (phy != NULL) {
1041 phy_addr = of_get_property(phy, "reg", NULL);
1042 fs_enet_data.phy_addr = *phy_addr;
1043 fs_enet_data.has_phy = 1;
1044
1045 mdio = of_get_parent(phy);
1046 ret = of_address_to_resource(mdio, 0, &res);
1047 if (ret) {
1048 of_node_put(phy);
1049 of_node_put(mdio);
1050 goto unreg;
1051 }
1052 }
1053
1054 model = of_get_property(np, "model", NULL);
1055 strcpy(fs_enet_data.fs_type, model);
1056
1057 if (strstr(model, "FEC")) {
1058 r[1].start = r[1].end = irq_of_parse_and_map(np, 0);
1059 r[1].flags = IORESOURCE_IRQ;
1060 r[1].name = enet_irq;
1061
1062 fs_enet_dev =
1063 platform_device_register_simple("fsl-cpm-fec", i, &r[0], 2);
1064
1065 if (IS_ERR(fs_enet_dev)) {
1066 ret = PTR_ERR(fs_enet_dev);
1067 goto err;
1068 }
1069
1070 fs_enet_data.rx_ring = 128;
1071 fs_enet_data.tx_ring = 16;
1072 fs_enet_data.rx_copybreak = 240;
1073 fs_enet_data.use_napi = 1;
1074 fs_enet_data.napi_weight = 17;
1075
1076 snprintf((char*)&bus_id[i], BUS_ID_SIZE, "%x:%02x",
1077 (u32)res.start, fs_enet_data.phy_addr);
1078 fs_enet_data.bus_id = (char*)&bus_id[i];
1079 fs_enet_data.init_ioports = init_fec_ioports;
1080 }
1081 if (strstr(model, "SCC")) {
1082 ret = of_address_to_resource(np, 1, &r[1]);
1083 if (ret)
1084 goto err;
1085 r[1].name = enet_pram;
1086
1087 r[2].start = r[2].end = irq_of_parse_and_map(np, 0);
1088 r[2].flags = IORESOURCE_IRQ;
1089 r[2].name = enet_irq;
1090
1091 fs_enet_dev =
1092 platform_device_register_simple("fsl-cpm-scc", i, &r[0], 3);
1093
1094 if (IS_ERR(fs_enet_dev)) {
1095 ret = PTR_ERR(fs_enet_dev);
1096 goto err;
1097 }
1098
1099 fs_enet_data.rx_ring = 64;
1100 fs_enet_data.tx_ring = 8;
1101 fs_enet_data.rx_copybreak = 240;
1102 fs_enet_data.use_napi = 1;
1103 fs_enet_data.napi_weight = 17;
1104
1105 snprintf((char*)&bus_id[i], BUS_ID_SIZE, "%s", "fixed@10:1");
1106 fs_enet_data.bus_id = (char*)&bus_id[i];
1107 fs_enet_data.init_ioports = init_scc_ioports;
1108 }
1109
1110 of_node_put(phy);
1111 of_node_put(mdio);
1112
1113 ret = platform_device_add_data(fs_enet_dev, &fs_enet_data,
1114 sizeof(struct
1115 fs_platform_info));
1116 if (ret)
1117 goto unreg;
1118 }
1119 return 0;
1120
1121 unreg:
1122 platform_device_unregister(fs_enet_dev);
1123 err:
1124 return ret;
1125 }
1126
1127 arch_initcall(fs_enet_of_init);
1128
1129 static int __init fsl_pcmcia_of_init(void)
1130 {
1131 struct device_node *np = NULL;
1132 /*
1133 * Register all the devices which type is "pcmcia"
1134 */
1135 while ((np = of_find_compatible_node(np,
1136 "pcmcia", "fsl,pq-pcmcia")) != NULL)
1137 of_platform_device_create(np, "m8xx-pcmcia", NULL);
1138 return 0;
1139 }
1140
1141 arch_initcall(fsl_pcmcia_of_init);
1142
1143 static const char *smc_regs = "regs";
1144 static const char *smc_pram = "pram";
1145
1146 static int __init cpm_smc_uart_of_init(void)
1147 {
1148 struct device_node *np;
1149 unsigned int i;
1150 struct platform_device *cpm_uart_dev;
1151 int ret;
1152
1153 for (np = NULL, i = 0;
1154 (np = of_find_compatible_node(np, "serial", "cpm_uart")) != NULL;
1155 i++) {
1156 struct resource r[3];
1157 struct fs_uart_platform_info cpm_uart_data;
1158 const int *id;
1159 const char *model;
1160
1161 memset(r, 0, sizeof(r));
1162 memset(&cpm_uart_data, 0, sizeof(cpm_uart_data));
1163
1164 ret = of_address_to_resource(np, 0, &r[0]);
1165 if (ret)
1166 goto err;
1167
1168 r[0].name = smc_regs;
1169
1170 ret = of_address_to_resource(np, 1, &r[1]);
1171 if (ret)
1172 goto err;
1173 r[1].name = smc_pram;
1174
1175 r[2].start = r[2].end = irq_of_parse_and_map(np, 0);
1176 r[2].flags = IORESOURCE_IRQ;
1177
1178 cpm_uart_dev =
1179 platform_device_register_simple("fsl-cpm-smc:uart", i, &r[0], 3);
1180
1181 if (IS_ERR(cpm_uart_dev)) {
1182 ret = PTR_ERR(cpm_uart_dev);
1183 goto err;
1184 }
1185
1186 model = of_get_property(np, "model", NULL);
1187 strcpy(cpm_uart_data.fs_type, model);
1188
1189 id = of_get_property(np, "device-id", NULL);
1190 cpm_uart_data.fs_no = *id;
1191 cpm_uart_data.uart_clk = ppc_proc_freq;
1192
1193 cpm_uart_data.tx_num_fifo = 4;
1194 cpm_uart_data.tx_buf_size = 32;
1195 cpm_uart_data.rx_num_fifo = 4;
1196 cpm_uart_data.rx_buf_size = 32;
1197
1198 ret =
1199 platform_device_add_data(cpm_uart_dev, &cpm_uart_data,
1200 sizeof(struct
1201 fs_uart_platform_info));
1202 if (ret)
1203 goto unreg;
1204 }
1205
1206 return 0;
1207
1208 unreg:
1209 platform_device_unregister(cpm_uart_dev);
1210 err:
1211 return ret;
1212 }
1213
1214 arch_initcall(cpm_smc_uart_of_init);
1215
1216 #endif /* CONFIG_8xx */
1217 #endif /* CONFIG_PPC_CPM_NEW_BINDING */
1218
1219 int __init fsl_spi_init(struct spi_board_info *board_infos,
1220 unsigned int num_board_infos,
1221 void (*activate_cs)(u8 cs, u8 polarity),
1222 void (*deactivate_cs)(u8 cs, u8 polarity))
1223 {
1224 struct device_node *np;
1225 unsigned int i;
1226 const u32 *sysclk;
1227
1228 /* SPI controller is either clocked from QE or SoC clock */
1229 np = of_find_node_by_type(NULL, "qe");
1230 if (!np)
1231 np = of_find_node_by_type(NULL, "soc");
1232
1233 if (!np)
1234 return -ENODEV;
1235
1236 sysclk = of_get_property(np, "bus-frequency", NULL);
1237 if (!sysclk)
1238 return -ENODEV;
1239
1240 for (np = NULL, i = 1;
1241 (np = of_find_compatible_node(np, "spi", "fsl_spi")) != NULL;
1242 i++) {
1243 int ret = 0;
1244 unsigned int j;
1245 const void *prop;
1246 struct resource res[2];
1247 struct platform_device *pdev;
1248 struct fsl_spi_platform_data pdata = {
1249 .activate_cs = activate_cs,
1250 .deactivate_cs = deactivate_cs,
1251 };
1252
1253 memset(res, 0, sizeof(res));
1254
1255 pdata.sysclk = *sysclk;
1256
1257 prop = of_get_property(np, "reg", NULL);
1258 if (!prop)
1259 goto err;
1260 pdata.bus_num = *(u32 *)prop;
1261
1262 prop = of_get_property(np, "mode", NULL);
1263 if (prop && !strcmp(prop, "cpu-qe"))
1264 pdata.qe_mode = 1;
1265
1266 for (j = 0; j < num_board_infos; j++) {
1267 if (board_infos[j].bus_num == pdata.bus_num)
1268 pdata.max_chipselect++;
1269 }
1270
1271 if (!pdata.max_chipselect)
1272 goto err;
1273
1274 ret = of_address_to_resource(np, 0, &res[0]);
1275 if (ret)
1276 goto err;
1277
1278 ret = of_irq_to_resource(np, 0, &res[1]);
1279 if (ret == NO_IRQ)
1280 goto err;
1281
1282 pdev = platform_device_alloc("mpc83xx_spi", i);
1283 if (!pdev)
1284 goto err;
1285
1286 ret = platform_device_add_data(pdev, &pdata, sizeof(pdata));
1287 if (ret)
1288 goto unreg;
1289
1290 ret = platform_device_add_resources(pdev, res,
1291 ARRAY_SIZE(res));
1292 if (ret)
1293 goto unreg;
1294
1295 ret = platform_device_register(pdev);
1296 if (ret)
1297 goto unreg;
1298
1299 continue;
1300 unreg:
1301 platform_device_del(pdev);
1302 err:
1303 continue;
1304 }
1305
1306 return spi_register_board_info(board_infos, num_board_infos);
1307 }
1308
1309 #if defined(CONFIG_PPC_85xx) || defined(CONFIG_PPC_86xx)
1310 static __be32 __iomem *rstcr;
1311
1312 static int __init setup_rstcr(void)
1313 {
1314 struct device_node *np;
1315 np = of_find_node_by_name(NULL, "global-utilities");
1316 if ((np && of_get_property(np, "fsl,has-rstcr", NULL))) {
1317 const u32 *prop = of_get_property(np, "reg", NULL);
1318 if (prop) {
1319 /* map reset control register
1320 * 0xE00B0 is offset of reset control register
1321 */
1322 rstcr = ioremap(get_immrbase() + *prop + 0xB0, 0xff);
1323 if (!rstcr)
1324 printk (KERN_EMERG "Error: reset control "
1325 "register not mapped!\n");
1326 }
1327 } else
1328 printk (KERN_INFO "rstcr compatible register does not exist!\n");
1329 if (np)
1330 of_node_put(np);
1331 return 0;
1332 }
1333
1334 arch_initcall(setup_rstcr);
1335
1336 void fsl_rstcr_restart(char *cmd)
1337 {
1338 local_irq_disable();
1339 if (rstcr)
1340 /* set reset control register */
1341 out_be32(rstcr, 0x2); /* HRESET_REQ */
1342
1343 while (1) ;
1344 }
1345 #endif
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree