aboutsummaryrefslogtreecommitdiffstats
path: root/arch/x86/kernel/olpc.c
diff options
context:
space:
mode:
authorGlenn Elliott <gelliott@cs.unc.edu>2012-03-04 19:47:13 -0500
committerGlenn Elliott <gelliott@cs.unc.edu>2012-03-04 19:47:13 -0500
commitc71c03bda1e86c9d5198c5d83f712e695c4f2a1e (patch)
treeecb166cb3e2b7e2adb3b5e292245fefd23381ac8 /arch/x86/kernel/olpc.c
parentea53c912f8a86a8567697115b6a0d8152beee5c8 (diff)
parent6a00f206debf8a5c8899055726ad127dbeeed098 (diff)
Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp
Conflicts: litmus/sched_cedf.c
Diffstat (limited to 'arch/x86/kernel/olpc.c')
-rw-r--r--arch/x86/kernel/olpc.c260
1 files changed, 0 insertions, 260 deletions
diff --git a/arch/x86/kernel/olpc.c b/arch/x86/kernel/olpc.c
deleted file mode 100644
index 0e0cdde519be..000000000000
--- a/arch/x86/kernel/olpc.c
+++ /dev/null
@@ -1,260 +0,0 @@
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>
20
21#include <asm/geode.h>
22#include <asm/setup.h>
23#include <asm/olpc.h>
24#include <asm/olpc_ofw.h>
25
26struct olpc_platform_t olpc_platform_info;
27EXPORT_SYMBOL_GPL(olpc_platform_info);
28
29static 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 */
35static int ec_timeout = EC_BASE_TIMEOUT;
36
37static 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
54static inline unsigned int ibf_status(unsigned int port)
55{
56 return !!(inb(port) & 0x02);
57}
58
59static 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))
65static 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))
85static 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 */
111int 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
135restart:
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 */
145 pr_devel("olpc-ec: running cmd 0x%x\n", cmd);
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 }
162 pr_devel("olpc-ec: sending cmd arg 0x%x\n", inbuf[i]);
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);
175 pr_devel("olpc-ec: received 0x%x\n", outbuf[i]);
176 }
177 }
178
179 ret = 0;
180err:
181 spin_unlock_irqrestore(&ec_lock, flags);
182 return ret;
183}
184EXPORT_SYMBOL_GPL(olpc_ec_cmd);
185
186#ifdef CONFIG_OLPC_OPENFIRMWARE
187static void __init platform_detect(void)
188{
189 size_t propsize;
190 __be32 rev;
191 const void *args[] = { NULL, "board-revision-int", &rev, (void *)4 };
192 void *res[] = { &propsize };
193
194 if (olpc_ofw("getprop", args, res) || propsize != 4) {
195 printk(KERN_ERR "ofw: getprop call failed!\n");
196 rev = cpu_to_be32(0);
197 }
198 olpc_platform_info.boardrev = be32_to_cpu(rev);
199}
200#else
201static void __init platform_detect(void)
202{
203 /* stopgap until OFW support is added to the kernel */
204 olpc_platform_info.boardrev = olpc_board(0xc2);
205}
206#endif
207
208static int __init olpc_init(void)
209{
210 unsigned char *romsig;
211
212 /* The ioremap check is dangerous; limit what we run it on */
213 if (!is_geode() || cs5535_has_vsa2())
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
244#ifdef CONFIG_PCI_OLPC
245 /* If the VSA exists let it emulate PCI, if not emulate in kernel */
246 if (!cs5535_has_vsa2())
247 x86_init.pci.arch_init = pci_olpc_init;
248#endif
249
250 printk(KERN_INFO "OLPC board revision %s%X (EC=%x)\n",
251 ((olpc_platform_info.boardrev & 0xf) < 8) ? "pre" : "",
252 olpc_platform_info.boardrev >> 4,
253 olpc_platform_info.ecver);
254
255unmap:
256 iounmap(romsig);
257 return 0;
258}
259
260postcore_initcall(olpc_init);
generated by cgit v1.2.2 (git 2.25.0) at 2026-03-05 08:13:45 -0500