]>
Commit | Line | Data |
---|---|---|
3ef0e1f8 AS |
1 | /* |
2 | * Support for the OLPC DCON and OLPC EC access | |
3 | * | |
4 | * Copyright © 2006 Advanced Micro Devices, Inc. | |
5 | * Copyright © 2007-2008 Andres Salomon <dilinger@debian.org> | |
6 | * | |
7 | * This program is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published by | |
9 | * the Free Software Foundation; either version 2 of the License, or | |
10 | * (at your option) any later version. | |
11 | */ | |
12 | ||
13 | #include <linux/kernel.h> | |
14 | #include <linux/init.h> | |
15 | #include <linux/module.h> | |
16 | #include <linux/delay.h> | |
17 | #include <linux/spinlock.h> | |
18 | #include <linux/io.h> | |
19 | #include <linux/string.h> | |
d5d0e88c | 20 | |
3ef0e1f8 | 21 | #include <asm/geode.h> |
d5d0e88c | 22 | #include <asm/setup.h> |
3ef0e1f8 | 23 | #include <asm/olpc.h> |
fd699c76 | 24 | #include <asm/olpc_ofw.h> |
3ef0e1f8 AS |
25 | |
26 | struct olpc_platform_t olpc_platform_info; | |
27 | EXPORT_SYMBOL_GPL(olpc_platform_info); | |
28 | ||
29 | static DEFINE_SPINLOCK(ec_lock); | |
30 | ||
31 | /* what the timeout *should* be (in ms) */ | |
32 | #define EC_BASE_TIMEOUT 20 | |
33 | ||
34 | /* the timeout that bugs in the EC might force us to actually use */ | |
35 | static int ec_timeout = EC_BASE_TIMEOUT; | |
36 | ||
37 | static int __init olpc_ec_timeout_set(char *str) | |
38 | { | |
39 | if (get_option(&str, &ec_timeout) != 1) { | |
40 | ec_timeout = EC_BASE_TIMEOUT; | |
41 | printk(KERN_ERR "olpc-ec: invalid argument to " | |
42 | "'olpc_ec_timeout=', ignoring!\n"); | |
43 | } | |
44 | printk(KERN_DEBUG "olpc-ec: using %d ms delay for EC commands.\n", | |
45 | ec_timeout); | |
46 | return 1; | |
47 | } | |
48 | __setup("olpc_ec_timeout=", olpc_ec_timeout_set); | |
49 | ||
50 | /* | |
51 | * These {i,o}bf_status functions return whether the buffers are full or not. | |
52 | */ | |
53 | ||
54 | static inline unsigned int ibf_status(unsigned int port) | |
55 | { | |
56 | return !!(inb(port) & 0x02); | |
57 | } | |
58 | ||
59 | static inline unsigned int obf_status(unsigned int port) | |
60 | { | |
61 | return inb(port) & 0x01; | |
62 | } | |
63 | ||
64 | #define wait_on_ibf(p, d) __wait_on_ibf(__LINE__, (p), (d)) | |
65 | static int __wait_on_ibf(unsigned int line, unsigned int port, int desired) | |
66 | { | |
67 | unsigned int timeo; | |
68 | int state = ibf_status(port); | |
69 | ||
70 | for (timeo = ec_timeout; state != desired && timeo; timeo--) { | |
71 | mdelay(1); | |
72 | state = ibf_status(port); | |
73 | } | |
74 | ||
75 | if ((state == desired) && (ec_timeout > EC_BASE_TIMEOUT) && | |
76 | timeo < (ec_timeout - EC_BASE_TIMEOUT)) { | |
77 | printk(KERN_WARNING "olpc-ec: %d: waited %u ms for IBF!\n", | |
78 | line, ec_timeout - timeo); | |
79 | } | |
80 | ||
81 | return !(state == desired); | |
82 | } | |
83 | ||
84 | #define wait_on_obf(p, d) __wait_on_obf(__LINE__, (p), (d)) | |
85 | static int __wait_on_obf(unsigned int line, unsigned int port, int desired) | |
86 | { | |
87 | unsigned int timeo; | |
88 | int state = obf_status(port); | |
89 | ||
90 | for (timeo = ec_timeout; state != desired && timeo; timeo--) { | |
91 | mdelay(1); | |
92 | state = obf_status(port); | |
93 | } | |
94 | ||
95 | if ((state == desired) && (ec_timeout > EC_BASE_TIMEOUT) && | |
96 | timeo < (ec_timeout - EC_BASE_TIMEOUT)) { | |
97 | printk(KERN_WARNING "olpc-ec: %d: waited %u ms for OBF!\n", | |
98 | line, ec_timeout - timeo); | |
99 | } | |
100 | ||
101 | return !(state == desired); | |
102 | } | |
103 | ||
104 | /* | |
105 | * This allows the kernel to run Embedded Controller commands. The EC is | |
106 | * documented at <http://wiki.laptop.org/go/Embedded_controller>, and the | |
107 | * available EC commands are here: | |
108 | * <http://wiki.laptop.org/go/Ec_specification>. Unfortunately, while | |
109 | * OpenFirmware's source is available, the EC's is not. | |
110 | */ | |
111 | int olpc_ec_cmd(unsigned char cmd, unsigned char *inbuf, size_t inlen, | |
112 | unsigned char *outbuf, size_t outlen) | |
113 | { | |
114 | unsigned long flags; | |
115 | int ret = -EIO; | |
116 | int i; | |
117 | ||
118 | spin_lock_irqsave(&ec_lock, flags); | |
119 | ||
120 | /* Clear OBF */ | |
121 | for (i = 0; i < 10 && (obf_status(0x6c) == 1); i++) | |
122 | inb(0x68); | |
123 | if (i == 10) { | |
124 | printk(KERN_ERR "olpc-ec: timeout while attempting to " | |
125 | "clear OBF flag!\n"); | |
126 | goto err; | |
127 | } | |
128 | ||
129 | if (wait_on_ibf(0x6c, 0)) { | |
130 | printk(KERN_ERR "olpc-ec: timeout waiting for EC to " | |
131 | "quiesce!\n"); | |
132 | goto err; | |
133 | } | |
134 | ||
135 | restart: | |
136 | /* | |
137 | * Note that if we time out during any IBF checks, that's a failure; | |
138 | * we have to return. There's no way for the kernel to clear that. | |
139 | * | |
140 | * If we time out during an OBF check, we can restart the command; | |
141 | * reissuing it will clear the OBF flag, and we should be alright. | |
142 | * The OBF flag will sometimes misbehave due to what we believe | |
143 | * is a hardware quirk.. | |
144 | */ | |
25971865 | 145 | pr_devel("olpc-ec: running cmd 0x%x\n", cmd); |
3ef0e1f8 AS |
146 | outb(cmd, 0x6c); |
147 | ||
148 | if (wait_on_ibf(0x6c, 0)) { | |
149 | printk(KERN_ERR "olpc-ec: timeout waiting for EC to read " | |
150 | "command!\n"); | |
151 | goto err; | |
152 | } | |
153 | ||
154 | if (inbuf && inlen) { | |
155 | /* write data to EC */ | |
156 | for (i = 0; i < inlen; i++) { | |
157 | if (wait_on_ibf(0x6c, 0)) { | |
158 | printk(KERN_ERR "olpc-ec: timeout waiting for" | |
159 | " EC accept data!\n"); | |
160 | goto err; | |
161 | } | |
25971865 | 162 | pr_devel("olpc-ec: sending cmd arg 0x%x\n", inbuf[i]); |
3ef0e1f8 AS |
163 | outb(inbuf[i], 0x68); |
164 | } | |
165 | } | |
166 | if (outbuf && outlen) { | |
167 | /* read data from EC */ | |
168 | for (i = 0; i < outlen; i++) { | |
169 | if (wait_on_obf(0x6c, 1)) { | |
170 | printk(KERN_ERR "olpc-ec: timeout waiting for" | |
171 | " EC to provide data!\n"); | |
172 | goto restart; | |
173 | } | |
174 | outbuf[i] = inb(0x68); | |
25971865 | 175 | pr_devel("olpc-ec: received 0x%x\n", outbuf[i]); |
3ef0e1f8 AS |
176 | } |
177 | } | |
178 | ||
179 | ret = 0; | |
180 | err: | |
181 | spin_unlock_irqrestore(&ec_lock, flags); | |
182 | return ret; | |
183 | } | |
184 | EXPORT_SYMBOL_GPL(olpc_ec_cmd); | |
185 | ||
fd699c76 | 186 | #ifdef CONFIG_OLPC_OPENFIRMWARE |
3ef0e1f8 AS |
187 | static void __init platform_detect(void) |
188 | { | |
189 | size_t propsize; | |
e51a1ac2 | 190 | __be32 rev; |
54e5bc02 | 191 | const void *args[] = { NULL, "board-revision-int", &rev, (void *)4 }; |
fd699c76 | 192 | void *res[] = { &propsize }; |
3ef0e1f8 | 193 | |
fd699c76 | 194 | if (olpc_ofw("getprop", args, res) || propsize != 4) { |
3ef0e1f8 | 195 | printk(KERN_ERR "ofw: getprop call failed!\n"); |
e51a1ac2 | 196 | rev = cpu_to_be32(0); |
3ef0e1f8 AS |
197 | } |
198 | olpc_platform_info.boardrev = be32_to_cpu(rev); | |
199 | } | |
200 | #else | |
201 | static void __init platform_detect(void) | |
202 | { | |
203 | /* stopgap until OFW support is added to the kernel */ | |
e49590b6 | 204 | olpc_platform_info.boardrev = olpc_board(0xc2); |
3ef0e1f8 AS |
205 | } |
206 | #endif | |
207 | ||
208 | static int __init olpc_init(void) | |
209 | { | |
210 | unsigned char *romsig; | |
211 | ||
212 | /* The ioremap check is dangerous; limit what we run it on */ | |
f060f270 | 213 | if (!is_geode() || cs5535_has_vsa2()) |
3ef0e1f8 AS |
214 | return 0; |
215 | ||
216 | spin_lock_init(&ec_lock); | |
217 | ||
218 | romsig = ioremap(0xffffffc0, 16); | |
219 | if (!romsig) | |
220 | return 0; | |
221 | ||
222 | if (strncmp(romsig, "CL1 Q", 7)) | |
223 | goto unmap; | |
224 | if (strncmp(romsig+6, romsig+13, 3)) { | |
225 | printk(KERN_INFO "OLPC BIOS signature looks invalid. " | |
226 | "Assuming not OLPC\n"); | |
227 | goto unmap; | |
228 | } | |
229 | ||
230 | printk(KERN_INFO "OLPC board with OpenFirmware %.16s\n", romsig); | |
231 | olpc_platform_info.flags |= OLPC_F_PRESENT; | |
232 | ||
233 | /* get the platform revision */ | |
234 | platform_detect(); | |
235 | ||
236 | /* assume B1 and above models always have a DCON */ | |
237 | if (olpc_board_at_least(olpc_board(0xb1))) | |
238 | olpc_platform_info.flags |= OLPC_F_DCON; | |
239 | ||
240 | /* get the EC revision */ | |
241 | olpc_ec_cmd(EC_FIRMWARE_REV, NULL, 0, | |
242 | (unsigned char *) &olpc_platform_info.ecver, 1); | |
243 | ||
d5d0e88c | 244 | #ifdef CONFIG_PCI_OLPC |
76fb6570 DD |
245 | /* If the VSA exists let it emulate PCI, if not emulate in kernel. |
246 | * XO-1 only. */ | |
247 | if (olpc_platform_info.boardrev < olpc_board_pre(0xd0) && | |
248 | !cs5535_has_vsa2()) | |
d5d0e88c TG |
249 | x86_init.pci.arch_init = pci_olpc_init; |
250 | #endif | |
3ef0e1f8 AS |
251 | |
252 | printk(KERN_INFO "OLPC board revision %s%X (EC=%x)\n", | |
253 | ((olpc_platform_info.boardrev & 0xf) < 8) ? "pre" : "", | |
254 | olpc_platform_info.boardrev >> 4, | |
255 | olpc_platform_info.ecver); | |
256 | ||
257 | unmap: | |
258 | iounmap(romsig); | |
259 | return 0; | |
260 | } | |
261 | ||
262 | postcore_initcall(olpc_init); |