]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - arch/x86/platform/olpc/olpc.c
x86/olpc: Add debugfs interface for EC commands
[~shefty/rdma-dev.git] / arch / x86 / platform / olpc / olpc.c
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 #include <linux/platform_device.h>
21 #include <linux/of.h>
22 #include <linux/syscore_ops.h>
23 #include <linux/debugfs.h>
24 #include <linux/mutex.h>
25
26 #include <asm/geode.h>
27 #include <asm/setup.h>
28 #include <asm/olpc.h>
29 #include <asm/olpc_ofw.h>
30
31 struct olpc_platform_t olpc_platform_info;
32 EXPORT_SYMBOL_GPL(olpc_platform_info);
33
34 static DEFINE_SPINLOCK(ec_lock);
35
36 /* debugfs interface to EC commands */
37 #define EC_MAX_CMD_ARGS (5 + 1) /* cmd byte + 5 args */
38 #define EC_MAX_CMD_REPLY (8)
39
40 static struct dentry *ec_debugfs_dir;
41 static DEFINE_MUTEX(ec_debugfs_cmd_lock);
42 static unsigned char ec_debugfs_resp[EC_MAX_CMD_REPLY];
43 static unsigned int ec_debugfs_resp_bytes;
44
45 /* EC event mask to be applied during suspend (defining wakeup sources). */
46 static u16 ec_wakeup_mask;
47
48 /* what the timeout *should* be (in ms) */
49 #define EC_BASE_TIMEOUT 20
50
51 /* the timeout that bugs in the EC might force us to actually use */
52 static int ec_timeout = EC_BASE_TIMEOUT;
53
54 static int __init olpc_ec_timeout_set(char *str)
55 {
56         if (get_option(&str, &ec_timeout) != 1) {
57                 ec_timeout = EC_BASE_TIMEOUT;
58                 printk(KERN_ERR "olpc-ec:  invalid argument to "
59                                 "'olpc_ec_timeout=', ignoring!\n");
60         }
61         printk(KERN_DEBUG "olpc-ec:  using %d ms delay for EC commands.\n",
62                         ec_timeout);
63         return 1;
64 }
65 __setup("olpc_ec_timeout=", olpc_ec_timeout_set);
66
67 /*
68  * These {i,o}bf_status functions return whether the buffers are full or not.
69  */
70
71 static inline unsigned int ibf_status(unsigned int port)
72 {
73         return !!(inb(port) & 0x02);
74 }
75
76 static inline unsigned int obf_status(unsigned int port)
77 {
78         return inb(port) & 0x01;
79 }
80
81 #define wait_on_ibf(p, d) __wait_on_ibf(__LINE__, (p), (d))
82 static int __wait_on_ibf(unsigned int line, unsigned int port, int desired)
83 {
84         unsigned int timeo;
85         int state = ibf_status(port);
86
87         for (timeo = ec_timeout; state != desired && timeo; timeo--) {
88                 mdelay(1);
89                 state = ibf_status(port);
90         }
91
92         if ((state == desired) && (ec_timeout > EC_BASE_TIMEOUT) &&
93                         timeo < (ec_timeout - EC_BASE_TIMEOUT)) {
94                 printk(KERN_WARNING "olpc-ec:  %d: waited %u ms for IBF!\n",
95                                 line, ec_timeout - timeo);
96         }
97
98         return !(state == desired);
99 }
100
101 #define wait_on_obf(p, d) __wait_on_obf(__LINE__, (p), (d))
102 static int __wait_on_obf(unsigned int line, unsigned int port, int desired)
103 {
104         unsigned int timeo;
105         int state = obf_status(port);
106
107         for (timeo = ec_timeout; state != desired && timeo; timeo--) {
108                 mdelay(1);
109                 state = obf_status(port);
110         }
111
112         if ((state == desired) && (ec_timeout > EC_BASE_TIMEOUT) &&
113                         timeo < (ec_timeout - EC_BASE_TIMEOUT)) {
114                 printk(KERN_WARNING "olpc-ec:  %d: waited %u ms for OBF!\n",
115                                 line, ec_timeout - timeo);
116         }
117
118         return !(state == desired);
119 }
120
121 /*
122  * This allows the kernel to run Embedded Controller commands.  The EC is
123  * documented at <http://wiki.laptop.org/go/Embedded_controller>, and the
124  * available EC commands are here:
125  * <http://wiki.laptop.org/go/Ec_specification>.  Unfortunately, while
126  * OpenFirmware's source is available, the EC's is not.
127  */
128 int olpc_ec_cmd(unsigned char cmd, unsigned char *inbuf, size_t inlen,
129                 unsigned char *outbuf,  size_t outlen)
130 {
131         unsigned long flags;
132         int ret = -EIO;
133         int i;
134         int restarts = 0;
135
136         spin_lock_irqsave(&ec_lock, flags);
137
138         /* Clear OBF */
139         for (i = 0; i < 10 && (obf_status(0x6c) == 1); i++)
140                 inb(0x68);
141         if (i == 10) {
142                 printk(KERN_ERR "olpc-ec:  timeout while attempting to "
143                                 "clear OBF flag!\n");
144                 goto err;
145         }
146
147         if (wait_on_ibf(0x6c, 0)) {
148                 printk(KERN_ERR "olpc-ec:  timeout waiting for EC to "
149                                 "quiesce!\n");
150                 goto err;
151         }
152
153 restart:
154         /*
155          * Note that if we time out during any IBF checks, that's a failure;
156          * we have to return.  There's no way for the kernel to clear that.
157          *
158          * If we time out during an OBF check, we can restart the command;
159          * reissuing it will clear the OBF flag, and we should be alright.
160          * The OBF flag will sometimes misbehave due to what we believe
161          * is a hardware quirk..
162          */
163         pr_devel("olpc-ec:  running cmd 0x%x\n", cmd);
164         outb(cmd, 0x6c);
165
166         if (wait_on_ibf(0x6c, 0)) {
167                 printk(KERN_ERR "olpc-ec:  timeout waiting for EC to read "
168                                 "command!\n");
169                 goto err;
170         }
171
172         if (inbuf && inlen) {
173                 /* write data to EC */
174                 for (i = 0; i < inlen; i++) {
175                         pr_devel("olpc-ec:  sending cmd arg 0x%x\n", inbuf[i]);
176                         outb(inbuf[i], 0x68);
177                         if (wait_on_ibf(0x6c, 0)) {
178                                 printk(KERN_ERR "olpc-ec:  timeout waiting for"
179                                                 " EC accept data!\n");
180                                 goto err;
181                         }
182                 }
183         }
184         if (outbuf && outlen) {
185                 /* read data from EC */
186                 for (i = 0; i < outlen; i++) {
187                         if (wait_on_obf(0x6c, 1)) {
188                                 printk(KERN_ERR "olpc-ec:  timeout waiting for"
189                                                 " EC to provide data!\n");
190                                 if (restarts++ < 10)
191                                         goto restart;
192                                 goto err;
193                         }
194                         outbuf[i] = inb(0x68);
195                         pr_devel("olpc-ec:  received 0x%x\n", outbuf[i]);
196                 }
197         }
198
199         ret = 0;
200 err:
201         spin_unlock_irqrestore(&ec_lock, flags);
202         return ret;
203 }
204 EXPORT_SYMBOL_GPL(olpc_ec_cmd);
205
206 void olpc_ec_wakeup_set(u16 value)
207 {
208         ec_wakeup_mask |= value;
209 }
210 EXPORT_SYMBOL_GPL(olpc_ec_wakeup_set);
211
212 void olpc_ec_wakeup_clear(u16 value)
213 {
214         ec_wakeup_mask &= ~value;
215 }
216 EXPORT_SYMBOL_GPL(olpc_ec_wakeup_clear);
217
218 /*
219  * Returns true if the compile and runtime configurations allow for EC events
220  * to wake the system.
221  */
222 bool olpc_ec_wakeup_available(void)
223 {
224         if (!machine_is_olpc())
225                 return false;
226
227         /*
228          * XO-1 EC wakeups are available when olpc-xo1-sci driver is
229          * compiled in
230          */
231 #ifdef CONFIG_OLPC_XO1_SCI
232         if (olpc_platform_info.boardrev < olpc_board_pre(0xd0)) /* XO-1 */
233                 return true;
234 #endif
235
236         /*
237          * XO-1.5 EC wakeups are available when olpc-xo15-sci driver is
238          * compiled in
239          */
240 #ifdef CONFIG_OLPC_XO15_SCI
241         if (olpc_platform_info.boardrev >= olpc_board_pre(0xd0)) /* XO-1.5 */
242                 return true;
243 #endif
244
245         return false;
246 }
247 EXPORT_SYMBOL_GPL(olpc_ec_wakeup_available);
248
249 int olpc_ec_mask_write(u16 bits)
250 {
251         if (olpc_platform_info.flags & OLPC_F_EC_WIDE_SCI) {
252                 __be16 ec_word = cpu_to_be16(bits);
253                 return olpc_ec_cmd(EC_WRITE_EXT_SCI_MASK, (void *) &ec_word, 2,
254                                    NULL, 0);
255         } else {
256                 unsigned char ec_byte = bits & 0xff;
257                 return olpc_ec_cmd(EC_WRITE_SCI_MASK, &ec_byte, 1, NULL, 0);
258         }
259 }
260 EXPORT_SYMBOL_GPL(olpc_ec_mask_write);
261
262 int olpc_ec_sci_query(u16 *sci_value)
263 {
264         int ret;
265
266         if (olpc_platform_info.flags & OLPC_F_EC_WIDE_SCI) {
267                 __be16 ec_word;
268                 ret = olpc_ec_cmd(EC_EXT_SCI_QUERY,
269                         NULL, 0, (void *) &ec_word, 2);
270                 if (ret == 0)
271                         *sci_value = be16_to_cpu(ec_word);
272         } else {
273                 unsigned char ec_byte;
274                 ret = olpc_ec_cmd(EC_SCI_QUERY, NULL, 0, &ec_byte, 1);
275                 if (ret == 0)
276                         *sci_value = ec_byte;
277         }
278
279         return ret;
280 }
281 EXPORT_SYMBOL_GPL(olpc_ec_sci_query);
282
283 static ssize_t ec_debugfs_cmd_write(struct file *file, const char __user *buf,
284                                     size_t size, loff_t *ppos)
285 {
286         int i, m;
287         unsigned char ec_cmd[EC_MAX_CMD_ARGS];
288         unsigned int ec_cmd_int[EC_MAX_CMD_ARGS];
289         char cmdbuf[64];
290         int ec_cmd_bytes;
291
292         mutex_lock(&ec_debugfs_cmd_lock);
293
294         size = simple_write_to_buffer(cmdbuf, sizeof(cmdbuf), ppos, buf, size);
295
296         m = sscanf(cmdbuf, "%x:%u %x %x %x %x %x", &ec_cmd_int[0],
297                    &ec_debugfs_resp_bytes,
298                    &ec_cmd_int[1], &ec_cmd_int[2], &ec_cmd_int[3],
299                    &ec_cmd_int[4], &ec_cmd_int[5]);
300         if (m < 2 || ec_debugfs_resp_bytes > EC_MAX_CMD_REPLY) {
301                 /* reset to prevent overflow on read */
302                 ec_debugfs_resp_bytes = 0;
303
304                 printk(KERN_DEBUG "olpc-ec: bad ec cmd:  "
305                        "cmd:response-count [arg1 [arg2 ...]]\n");
306                 size = -EINVAL;
307                 goto out;
308         }
309
310         /* convert scanf'd ints to char */
311         ec_cmd_bytes = m - 2;
312         for (i = 0; i <= ec_cmd_bytes; i++)
313                 ec_cmd[i] = ec_cmd_int[i];
314
315         printk(KERN_DEBUG "olpc-ec: debugfs cmd 0x%02x with %d args "
316                "%02x %02x %02x %02x %02x, want %d returns\n",
317                ec_cmd[0], ec_cmd_bytes, ec_cmd[1], ec_cmd[2], ec_cmd[3],
318                ec_cmd[4], ec_cmd[5], ec_debugfs_resp_bytes);
319
320         olpc_ec_cmd(ec_cmd[0], (ec_cmd_bytes == 0) ? NULL : &ec_cmd[1],
321                     ec_cmd_bytes, ec_debugfs_resp, ec_debugfs_resp_bytes);
322
323         printk(KERN_DEBUG "olpc-ec: response "
324                "%02x %02x %02x %02x %02x %02x %02x %02x (%d bytes expected)\n",
325                ec_debugfs_resp[0], ec_debugfs_resp[1], ec_debugfs_resp[2],
326                ec_debugfs_resp[3], ec_debugfs_resp[4], ec_debugfs_resp[5],
327                ec_debugfs_resp[6], ec_debugfs_resp[7], ec_debugfs_resp_bytes);
328
329 out:
330         mutex_unlock(&ec_debugfs_cmd_lock);
331         return size;
332 }
333
334 static ssize_t ec_debugfs_cmd_read(struct file *file, char __user *buf,
335                                    size_t size, loff_t *ppos)
336 {
337         unsigned int i, r;
338         char *rp;
339         char respbuf[64];
340
341         mutex_lock(&ec_debugfs_cmd_lock);
342         rp = respbuf;
343         rp += sprintf(rp, "%02x", ec_debugfs_resp[0]);
344         for (i = 1; i < ec_debugfs_resp_bytes; i++)
345                 rp += sprintf(rp, ", %02x", ec_debugfs_resp[i]);
346         mutex_unlock(&ec_debugfs_cmd_lock);
347         rp += sprintf(rp, "\n");
348
349         r = rp - respbuf;
350         return simple_read_from_buffer(buf, size, ppos, respbuf, r);
351 }
352
353 static const struct file_operations ec_debugfs_genops = {
354         .write   = ec_debugfs_cmd_write,
355         .read    = ec_debugfs_cmd_read,
356 };
357
358 static void setup_debugfs(void)
359 {
360         ec_debugfs_dir = debugfs_create_dir("olpc-ec", 0);
361         if (ec_debugfs_dir == ERR_PTR(-ENODEV))
362                 return;
363
364         debugfs_create_file("cmd", 0600, ec_debugfs_dir, NULL,
365                             &ec_debugfs_genops);
366 }
367
368 static int olpc_ec_suspend(void)
369 {
370         return olpc_ec_mask_write(ec_wakeup_mask);
371 }
372
373 static bool __init check_ofw_architecture(struct device_node *root)
374 {
375         const char *olpc_arch;
376         int propsize;
377
378         olpc_arch = of_get_property(root, "architecture", &propsize);
379         return propsize == 5 && strncmp("OLPC", olpc_arch, 5) == 0;
380 }
381
382 static u32 __init get_board_revision(struct device_node *root)
383 {
384         int propsize;
385         const __be32 *rev;
386
387         rev = of_get_property(root, "board-revision-int", &propsize);
388         if (propsize != 4)
389                 return 0;
390
391         return be32_to_cpu(*rev);
392 }
393
394 static bool __init platform_detect(void)
395 {
396         struct device_node *root = of_find_node_by_path("/");
397         bool success;
398
399         if (!root)
400                 return false;
401
402         success = check_ofw_architecture(root);
403         if (success) {
404                 olpc_platform_info.boardrev = get_board_revision(root);
405                 olpc_platform_info.flags |= OLPC_F_PRESENT;
406         }
407
408         of_node_put(root);
409         return success;
410 }
411
412 static int __init add_xo1_platform_devices(void)
413 {
414         struct platform_device *pdev;
415
416         pdev = platform_device_register_simple("xo1-rfkill", -1, NULL, 0);
417         if (IS_ERR(pdev))
418                 return PTR_ERR(pdev);
419
420         pdev = platform_device_register_simple("olpc-xo1", -1, NULL, 0);
421         if (IS_ERR(pdev))
422                 return PTR_ERR(pdev);
423
424         return 0;
425 }
426
427 static struct syscore_ops olpc_syscore_ops = {
428         .suspend = olpc_ec_suspend,
429 };
430
431 static int __init olpc_init(void)
432 {
433         int r = 0;
434
435         if (!olpc_ofw_present() || !platform_detect())
436                 return 0;
437
438         spin_lock_init(&ec_lock);
439
440         /* assume B1 and above models always have a DCON */
441         if (olpc_board_at_least(olpc_board(0xb1)))
442                 olpc_platform_info.flags |= OLPC_F_DCON;
443
444         /* get the EC revision */
445         olpc_ec_cmd(EC_FIRMWARE_REV, NULL, 0,
446                         (unsigned char *) &olpc_platform_info.ecver, 1);
447
448 #ifdef CONFIG_PCI_OLPC
449         /* If the VSA exists let it emulate PCI, if not emulate in kernel.
450          * XO-1 only. */
451         if (olpc_platform_info.boardrev < olpc_board_pre(0xd0) &&
452                         !cs5535_has_vsa2())
453                 x86_init.pci.arch_init = pci_olpc_init;
454 #endif
455         /* EC version 0x5f adds support for wide SCI mask */
456         if (olpc_platform_info.ecver >= 0x5f)
457                 olpc_platform_info.flags |= OLPC_F_EC_WIDE_SCI;
458
459         printk(KERN_INFO "OLPC board revision %s%X (EC=%x)\n",
460                         ((olpc_platform_info.boardrev & 0xf) < 8) ? "pre" : "",
461                         olpc_platform_info.boardrev >> 4,
462                         olpc_platform_info.ecver);
463
464         if (olpc_platform_info.boardrev < olpc_board_pre(0xd0)) { /* XO-1 */
465                 r = add_xo1_platform_devices();
466                 if (r)
467                         return r;
468         }
469
470         register_syscore_ops(&olpc_syscore_ops);
471         setup_debugfs();
472
473         return 0;
474 }
475
476 postcore_initcall(olpc_init);