powerpc/40x: Update Kilauea dts to support NAND, RTC and HWMON
[linux-2.6.git] / arch / powerpc / boot / planetcore.c
1 /*
2  * PlanetCore configuration data support functions
3  *
4  * Author: Scott Wood <scottwood@freescale.com>
5  *
6  * Copyright (c) 2007 Freescale Semiconductor, Inc.
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License version 2 as published
10  * by the Free Software Foundation.
11  */
12
13 #include "stdio.h"
14 #include "stdlib.h"
15 #include "ops.h"
16 #include "planetcore.h"
17 #include "io.h"
18
19 /* PlanetCore passes information to the OS in the form of
20  * a table of key=value strings, separated by newlines.
21  *
22  * The list is terminated by an empty string (i.e. two
23  * consecutive newlines).
24  *
25  * To make it easier to parse, we first convert all the
26  * newlines into null bytes.
27  */
28
29 void planetcore_prepare_table(char *table)
30 {
31         do {
32                 if (*table == '\n')
33                         *table = 0;
34
35                 table++;
36         } while (*(table - 1) || *table != '\n');
37
38         *table = 0;
39 }
40
41 const char *planetcore_get_key(const char *table, const char *key)
42 {
43         int keylen = strlen(key);
44
45         do {
46                 if (!strncmp(table, key, keylen) && table[keylen] == '=')
47                         return table + keylen + 1;
48
49                 table += strlen(table) + 1;
50         } while (strlen(table) != 0);
51
52         return NULL;
53 }
54
55 int planetcore_get_decimal(const char *table, const char *key, u64 *val)
56 {
57         const char *str = planetcore_get_key(table, key);
58         if (!str)
59                 return 0;
60
61         *val = strtoull(str, NULL, 10);
62         return 1;
63 }
64
65 int planetcore_get_hex(const char *table, const char *key, u64 *val)
66 {
67         const char *str = planetcore_get_key(table, key);
68         if (!str)
69                 return 0;
70
71         *val = strtoull(str, NULL, 16);
72         return 1;
73 }
74
75 static u64 mac_table[4] = {
76         0x000000000000,
77         0x000000800000,
78         0x000000400000,
79         0x000000c00000,
80 };
81
82 void planetcore_set_mac_addrs(const char *table)
83 {
84         u8 addr[4][6];
85         u64 int_addr;
86         u32 i;
87         int j;
88
89         if (!planetcore_get_hex(table, PLANETCORE_KEY_MAC_ADDR, &int_addr))
90                 return;
91
92         for (i = 0; i < 4; i++) {
93                 u64 this_dev_addr = (int_addr & ~0x000000c00000) |
94                                     mac_table[i];
95
96                 for (j = 5; j >= 0; j--) {
97                         addr[i][j] = this_dev_addr & 0xff;
98                         this_dev_addr >>= 8;
99                 }
100
101                 dt_fixup_mac_address(i, addr[i]);
102         }
103 }
104
105 static char prop_buf[MAX_PROP_LEN];
106
107 void planetcore_set_stdout_path(const char *table)
108 {
109         char *path;
110         const char *label;
111         void *node, *chosen;
112
113         label = planetcore_get_key(table, PLANETCORE_KEY_SERIAL_PORT);
114         if (!label)
115                 return;
116
117         node = find_node_by_prop_value_str(NULL, "linux,planetcore-label",
118                                            label);
119         if (!node)
120                 return;
121
122         path = get_path(node, prop_buf, MAX_PROP_LEN);
123         if (!path)
124                 return;
125
126         chosen = finddevice("/chosen");
127         if (!chosen)
128                 chosen = create_node(NULL, "chosen");
129         if (!chosen)
130                 return;
131
132         setprop_str(chosen, "linux,stdout-path", path);
133 }
134
135 void planetcore_set_serial_speed(const char *table)
136 {
137         void *chosen, *stdout;
138         u64 baud;
139         u32 baud32;
140         int len;
141
142         chosen = finddevice("/chosen");
143         if (!chosen)
144                 return;
145
146         len = getprop(chosen, "linux,stdout-path", prop_buf, MAX_PROP_LEN);
147         if (len <= 0)
148                 return;
149
150         stdout = finddevice(prop_buf);
151         if (!stdout) {
152                 printf("planetcore_set_serial_speed: "
153                        "Bad /chosen/linux,stdout-path.\r\n");
154
155                 return;
156         }
157
158         if (!planetcore_get_decimal(table, PLANETCORE_KEY_SERIAL_BAUD,
159                                     &baud)) {
160                 printf("planetcore_set_serial_speed: No SB tag.\r\n");
161                 return;
162         }
163
164         baud32 = baud;
165         setprop(stdout, "current-speed", &baud32, 4);
166 }