?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI: thinkpad-acpi: cleanup Kconfig for thinkpad-acpi
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / misc / thinkpad_acpi.c
blob6ad601b61bf33a791f0f579d0481d340c068c619
1 /*
2 * ibm_acpi.c - IBM ThinkPad ACPI Extras
3 *
4 *
5 * Copyright (C) 2004-2005 Borislav Deianov <borislav@users.sf.net>
6 * Copyright (C) 2006-2007 Henrique de Moraes Holschuh <hmh@hmh.eng.br>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 * 02110-1301, USA.
22 */
23
24 #define IBM_VERSION "0.13"
25
26 /*
27 * Changelog:
28 *
29 * 2006-11-22 0.13 new maintainer
30 * changelog now lives in git commit history, and will
31 * not be updated further in-file.
32 *
33 * 2005-08-17 0.12 fix compilation on 2.6.13-rc kernels
34 * 2005-03-17 0.11 support for 600e, 770x
35 * thanks to Jamie Lentin <lentinj@dial.pipex.com>
36 * support for 770e, G41
37 * G40 and G41 don't have a thinklight
38 * temperatures no longer experimental
39 * experimental brightness control
40 * experimental volume control
41 * experimental fan enable/disable
42 * 2005-01-16 0.10 fix module loading on R30, R31
43 * 2005-01-16 0.9 support for 570, R30, R31
44 * ultrabay support on A22p, A3x
45 * limit arg for cmos, led, beep, drop experimental status
46 * more capable led control on A21e, A22p, T20-22, X20
47 * experimental temperatures and fan speed
48 * experimental embedded controller register dump
49 * mark more functions as __init, drop incorrect __exit
50 * use MODULE_VERSION
51 * thanks to Henrik Brix Andersen <brix@gentoo.org>
52 * fix parameter passing on module loading
53 * thanks to Rusty Russell <rusty@rustcorp.com.au>
54 * thanks to Jim Radford <radford@blackbean.org>
55 * 2004-11-08 0.8 fix init error case, don't return from a macro
56 * thanks to Chris Wright <chrisw@osdl.org>
57 * 2004-10-23 0.7 fix module loading on A21e, A22p, T20, T21, X20
58 * fix led control on A21e
59 * 2004-10-19 0.6 use acpi_bus_register_driver() to claim HKEY device
60 * 2004-10-18 0.5 thinklight support on A21e, G40, R32, T20, T21, X20
61 * proc file format changed
62 * video_switch command
63 * experimental cmos control
64 * experimental led control
65 * experimental acpi sounds
66 * 2004-09-16 0.4 support for module parameters
67 * hotkey mask can be prefixed by 0x
68 * video output switching
69 * video expansion control
70 * ultrabay eject support
71 * removed lcd brightness/on/off control, didn't work
72 * 2004-08-17 0.3 support for R40
73 * lcd off, brightness control
74 * thinklight on/off
75 * 2004-08-14 0.2 support for T series, X20
76 * bluetooth enable/disable
77 * hotkey events disabled by default
78 * removed fan control, currently useless
79 * 2004-08-09 0.1 initial release, support for X series
80 */
81
82 #include "thinkpad_acpi.h"
83
84 MODULE_AUTHOR("Borislav Deianov, Henrique de Moraes Holschuh");
85 MODULE_DESCRIPTION(IBM_DESC);
86 MODULE_VERSION(IBM_VERSION);
87 MODULE_LICENSE("GPL");
88
89 #define __unused __attribute__ ((unused))
90
91 /****************************************************************************
92 ****************************************************************************
93 *
94 * ACPI Helpers and device model
95 *
96 ****************************************************************************
97 ****************************************************************************/
98
99 /*************************************************************************
100 * ACPI basic handles
101 */
102
103 static acpi_handle root_handle = NULL;
104
105 #define IBM_HANDLE(object, parent, paths...) \
106 static acpi_handle object##_handle; \
107 static acpi_handle *object##_parent = &parent##_handle; \
108 static char *object##_path; \
109 static char *object##_paths[] = { paths }
110
111 IBM_HANDLE(ec, root, "\\_SB.PCI0.ISA.EC0", /* 240, 240x */
112 "\\_SB.PCI.ISA.EC", /* 570 */
113 "\\_SB.PCI0.ISA0.EC0", /* 600e/x, 770e, 770x */
114 "\\_SB.PCI0.ISA.EC", /* A21e, A2xm/p, T20-22, X20-21 */
115 "\\_SB.PCI0.AD4S.EC0", /* i1400, R30 */
116 "\\_SB.PCI0.ICH3.EC0", /* R31 */
117 "\\_SB.PCI0.LPC.EC", /* all others */
118 );
119
120 IBM_HANDLE(ecrd, ec, "ECRD"); /* 570 */
121 IBM_HANDLE(ecwr, ec, "ECWR"); /* 570 */
122
123
124 /*************************************************************************
125 * Misc ACPI handles
126 */
127
128 IBM_HANDLE(cmos, root, "\\UCMS", /* R50, R50e, R50p, R51, T4x, X31, X40 */
129 "\\CMOS", /* A3x, G4x, R32, T23, T30, X22-24, X30 */
130 "\\CMS", /* R40, R40e */
131 ); /* all others */
132
133 IBM_HANDLE(hkey, ec, "\\_SB.HKEY", /* 600e/x, 770e, 770x */
134 "^HKEY", /* R30, R31 */
135 "HKEY", /* all others */
136 ); /* 570 */
137
138
139 /*************************************************************************
140 * ACPI helpers
141 */
142
143 static int acpi_evalf(acpi_handle handle,
144 void *res, char *method, char *fmt, ...)
145 {
146 char *fmt0 = fmt;
147 struct acpi_object_list params;
148 union acpi_object in_objs[IBM_MAX_ACPI_ARGS];
149 struct acpi_buffer result, *resultp;
150 union acpi_object out_obj;
151 acpi_status status;
152 va_list ap;
153 char res_type;
154 int success;
155 int quiet;
156
157 if (!*fmt) {
158 printk(IBM_ERR "acpi_evalf() called with empty format\n");
159 return 0;
160 }
161
162 if (*fmt == 'q') {
163 quiet = 1;
164 fmt++;
165 } else
166 quiet = 0;
167
168 res_type = *(fmt++);
169
170 params.count = 0;
171 params.pointer = &in_objs[0];
172
173 va_start(ap, fmt);
174 while (*fmt) {
175 char c = *(fmt++);
176 switch (c) {
177 case 'd': /* int */
178 in_objs[params.count].integer.value = va_arg(ap, int);
179 in_objs[params.count++].type = ACPI_TYPE_INTEGER;
180 break;
181 /* add more types as needed */
182 default:
183 printk(IBM_ERR "acpi_evalf() called "
184 "with invalid format character '%c'\n", c);
185 return 0;
186 }
187 }
188 va_end(ap);
189
190 if (res_type != 'v') {
191 result.length = sizeof(out_obj);
192 result.pointer = &out_obj;
193 resultp = &result;
194 } else
195 resultp = NULL;
196
197 status = acpi_evaluate_object(handle, method, &params, resultp);
198
199 switch (res_type) {
200 case 'd': /* int */
201 if (res)
202 *(int *)res = out_obj.integer.value;
203 success = status == AE_OK && out_obj.type == ACPI_TYPE_INTEGER;
204 break;
205 case 'v': /* void */
206 success = status == AE_OK;
207 break;
208 /* add more types as needed */
209 default:
210 printk(IBM_ERR "acpi_evalf() called "
211 "with invalid format character '%c'\n", res_type);
212 return 0;
213 }
214
215 if (!success && !quiet)
216 printk(IBM_ERR "acpi_evalf(%s, %s, ...) failed: %d\n",
217 method, fmt0, status);
218
219 return success;
220 }
221
222 static void __unused acpi_print_int(acpi_handle handle, char *method)
223 {
224 int i;
225
226 if (acpi_evalf(handle, &i, method, "d"))
227 printk(IBM_INFO "%s = 0x%x\n", method, i);
228 else
229 printk(IBM_ERR "error calling %s\n", method);
230 }
231
232 static int acpi_ec_read(int i, u8 * p)
233 {
234 int v;
235
236 if (ecrd_handle) {
237 if (!acpi_evalf(ecrd_handle, &v, NULL, "dd", i))
238 return 0;
239 *p = v;
240 } else {
241 if (ec_read(i, p) < 0)
242 return 0;
243 }
244
245 return 1;
246 }
247
248 static int acpi_ec_write(int i, u8 v)
249 {
250 if (ecwr_handle) {
251 if (!acpi_evalf(ecwr_handle, NULL, NULL, "vdd", i, v))
252 return 0;
253 } else {
254 if (ec_write(i, v) < 0)
255 return 0;
256 }
257
258 return 1;
259 }
260
261 static int _sta(acpi_handle handle)
262 {
263 int status;
264
265 if (!handle || !acpi_evalf(handle, &status, "_STA", "d"))
266 status = 0;
267
268 return status;
269 }
270
271 /*************************************************************************
272 * ACPI device model
273 */
274
275 static void __init ibm_handle_init(char *name,
276 acpi_handle * handle, acpi_handle parent,
277 char **paths, int num_paths, char **path)
278 {
279 int i;
280 acpi_status status;
281
282 for (i = 0; i < num_paths; i++) {
283 status = acpi_get_handle(parent, paths[i], handle);
284 if (ACPI_SUCCESS(status)) {
285 *path = paths[i];
286 return;
287 }
288 }
289
290 *handle = NULL;
291 }
292
293 static void dispatch_notify(acpi_handle handle, u32 event, void *data)
294 {
295 struct ibm_struct *ibm = data;
296
297 if (!ibm || !ibm->notify)
298 return;
299
300 ibm->notify(ibm, event);
301 }
302
303 static int __init setup_notify(struct ibm_struct *ibm)
304 {
305 acpi_status status;
306 int ret;
307
308 if (!*ibm->handle)
309 return 0;
310
311 ret = acpi_bus_get_device(*ibm->handle, &ibm->device);
312 if (ret < 0) {
313 printk(IBM_ERR "%s device not present\n", ibm->name);
314 return -ENODEV;
315 }
316
317 acpi_driver_data(ibm->device) = ibm;
318 sprintf(acpi_device_class(ibm->device), "%s/%s", IBM_NAME, ibm->name);
319
320 status = acpi_install_notify_handler(*ibm->handle, ibm->type,
321 dispatch_notify, ibm);
322 if (ACPI_FAILURE(status)) {
323 if (status == AE_ALREADY_EXISTS) {
324 printk(IBM_NOTICE "another device driver is already handling %s events\n",
325 ibm->name);
326 } else {
327 printk(IBM_ERR "acpi_install_notify_handler(%s) failed: %d\n",
328 ibm->name, status);
329 }
330 return -ENODEV;
331 }
332 ibm->notify_installed = 1;
333 return 0;
334 }
335
336 static int __init ibm_device_add(struct acpi_device *device)
337 {
338 return 0;
339 }
340
341 static int __init register_ibmacpi_subdriver(struct ibm_struct *ibm)
342 {
343 int ret;
344
345 ibm->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
346 if (!ibm->driver) {
347 printk(IBM_ERR "kmalloc(ibm->driver) failed\n");
348 return -1;
349 }
350
351 sprintf(ibm->driver->name, "%s_%s", IBM_NAME, ibm->name);
352 ibm->driver->ids = ibm->hid;
353 ibm->driver->ops.add = &ibm_device_add;
354
355 ret = acpi_bus_register_driver(ibm->driver);
356 if (ret < 0) {
357 printk(IBM_ERR "acpi_bus_register_driver(%s) failed: %d\n",
358 ibm->hid, ret);
359 kfree(ibm->driver);
360 }
361
362 return ret;
363 }
364
365
366 /****************************************************************************
367 ****************************************************************************
368 *
369 * Procfs Helpers
370 *
371 ****************************************************************************
372 ****************************************************************************/
373
374 static int dispatch_read(char *page, char **start, off_t off, int count,
375 int *eof, void *data)
376 {
377 struct ibm_struct *ibm = data;
378 int len;
379
380 if (!ibm || !ibm->read)
381 return -EINVAL;
382
383 len = ibm->read(page);
384 if (len < 0)
385 return len;
386
387 if (len <= off + count)
388 *eof = 1;
389 *start = page + off;
390 len -= off;
391 if (len > count)
392 len = count;
393 if (len < 0)
394 len = 0;
395
396 return len;
397 }
398
399 static int dispatch_write(struct file *file, const char __user * userbuf,
400 unsigned long count, void *data)
401 {
402 struct ibm_struct *ibm = data;
403 char *kernbuf;
404 int ret;
405
406 if (!ibm || !ibm->write)
407 return -EINVAL;
408
409 kernbuf = kmalloc(count + 2, GFP_KERNEL);
410 if (!kernbuf)
411 return -ENOMEM;
412
413 if (copy_from_user(kernbuf, userbuf, count)) {
414 kfree(kernbuf);
415 return -EFAULT;
416 }
417
418 kernbuf[count] = 0;
419 strcat(kernbuf, ",");
420 ret = ibm->write(kernbuf);
421 if (ret == 0)
422 ret = count;
423
424 kfree(kernbuf);
425
426 return ret;
427 }
428
429 static char *next_cmd(char **cmds)
430 {
431 char *start = *cmds;
432 char *end;
433
434 while ((end = strchr(start, ',')) && end == start)
435 start = end + 1;
436
437 if (!end)
438 return NULL;
439
440 *end = 0;
441 *cmds = end + 1;
442 return start;
443 }
444
445
446 /****************************************************************************
447 ****************************************************************************
448 *
449 * Subdrivers
450 *
451 ****************************************************************************
452 ****************************************************************************/
453
454 /*************************************************************************
455 * ibm-acpi init subdriver
456 */
457
458 static int ibm_acpi_driver_init(void)
459 {
460 printk(IBM_INFO "%s v%s\n", IBM_DESC, IBM_VERSION);
461 printk(IBM_INFO "%s\n", IBM_URL);
462
463 if (ibm_thinkpad_ec_found)
464 printk(IBM_INFO "ThinkPad EC firmware %s\n",
465 ibm_thinkpad_ec_found);
466
467 return 0;
468 }
469
470 static int ibm_acpi_driver_read(char *p)
471 {
472 int len = 0;
473
474 len += sprintf(p + len, "driver:\t\t%s\n", IBM_DESC);
475 len += sprintf(p + len, "version:\t%s\n", IBM_VERSION);
476
477 return len;
478 }
479
480 /*************************************************************************
481 * Hotkey subdriver
482 */
483
484 static int hotkey_supported;
485 static int hotkey_mask_supported;
486 static int hotkey_orig_status;
487 static int hotkey_orig_mask;
488
489 static int hotkey_init(void)
490 {
491 /* hotkey not supported on 570 */
492 hotkey_supported = hkey_handle != NULL;
493
494 if (hotkey_supported) {
495 /* mask not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
496 A30, R30, R31, T20-22, X20-21, X22-24 */
497 hotkey_mask_supported =
498 acpi_evalf(hkey_handle, NULL, "DHKN", "qv");
499
500 if (!hotkey_get(&hotkey_orig_status, &hotkey_orig_mask))
501 return -ENODEV;
502 }
503
504 return 0;
505 }
506
507 static void hotkey_exit(void)
508 {
509 if (hotkey_supported)
510 hotkey_set(hotkey_orig_status, hotkey_orig_mask);
511 }
512
513 static void hotkey_notify(struct ibm_struct *ibm, u32 event)
514 {
515 int hkey;
516
517 if (acpi_evalf(hkey_handle, &hkey, "MHKP", "d"))
518 acpi_bus_generate_event(ibm->device, event, hkey);
519 else {
520 printk(IBM_ERR "unknown hotkey event %d\n", event);
521 acpi_bus_generate_event(ibm->device, event, 0);
522 }
523 }
524
525 static int hotkey_get(int *status, int *mask)
526 {
527 if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
528 return 0;
529
530 if (hotkey_mask_supported)
531 if (!acpi_evalf(hkey_handle, mask, "DHKN", "d"))
532 return 0;
533
534 return 1;
535 }
536
537 static int hotkey_set(int status, int mask)
538 {
539 int i;
540
541 if (!acpi_evalf(hkey_handle, NULL, "MHKC", "vd", status))
542 return 0;
543
544 if (hotkey_mask_supported)
545 for (i = 0; i < 32; i++) {
546 int bit = ((1 << i) & mask) != 0;
547 if (!acpi_evalf(hkey_handle,
548 NULL, "MHKM", "vdd", i + 1, bit))
549 return 0;
550 }
551
552 return 1;
553 }
554
555 static int hotkey_read(char *p)
556 {
557 int status, mask;
558 int len = 0;
559
560 if (!hotkey_supported) {
561 len += sprintf(p + len, "status:\t\tnot supported\n");
562 return len;
563 }
564
565 if (!hotkey_get(&status, &mask))
566 return -EIO;
567
568 len += sprintf(p + len, "status:\t\t%s\n", enabled(status, 0));
569 if (hotkey_mask_supported) {
570 len += sprintf(p + len, "mask:\t\t0x%04x\n", mask);
571 len += sprintf(p + len,
572 "commands:\tenable, disable, reset, <mask>\n");
573 } else {
574 len += sprintf(p + len, "mask:\t\tnot supported\n");
575 len += sprintf(p + len, "commands:\tenable, disable, reset\n");
576 }
577
578 return len;
579 }
580
581 static int hotkey_write(char *buf)
582 {
583 int status, mask;
584 char *cmd;
585 int do_cmd = 0;
586
587 if (!hotkey_supported)
588 return -ENODEV;
589
590 if (!hotkey_get(&status, &mask))
591 return -EIO;
592
593 while ((cmd = next_cmd(&buf))) {
594 if (strlencmp(cmd, "enable") == 0) {
595 status = 1;
596 } else if (strlencmp(cmd, "disable") == 0) {
597 status = 0;
598 } else if (strlencmp(cmd, "reset") == 0) {
599 status = hotkey_orig_status;
600 mask = hotkey_orig_mask;
601 } else if (sscanf(cmd, "0x%x", &mask) == 1) {
602 /* mask set */
603 } else if (sscanf(cmd, "%x", &mask) == 1) {
604 /* mask set */
605 } else
606 return -EINVAL;
607 do_cmd = 1;
608 }
609
610 if (do_cmd && !hotkey_set(status, mask))
611 return -EIO;
612
613 return 0;
614 }
615
616 /*************************************************************************
617 * Bluetooth subdriver
618 */
619
620 static int bluetooth_supported;
621
622 static int bluetooth_init(void)
623 {
624 /* bluetooth not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
625 G4x, R30, R31, R40e, R50e, T20-22, X20-21 */
626 bluetooth_supported = hkey_handle &&
627 acpi_evalf(hkey_handle, NULL, "GBDC", "qv");
628
629 return 0;
630 }
631
632 static int bluetooth_status(void)
633 {
634 int status;
635
636 if (!bluetooth_supported ||
637 !acpi_evalf(hkey_handle, &status, "GBDC", "d"))
638 status = 0;
639
640 return status;
641 }
642
643 static int bluetooth_read(char *p)
644 {
645 int len = 0;
646 int status = bluetooth_status();
647
648 if (!bluetooth_supported)
649 len += sprintf(p + len, "status:\t\tnot supported\n");
650 else if (!(status & 1))
651 len += sprintf(p + len, "status:\t\tnot installed\n");
652 else {
653 len += sprintf(p + len, "status:\t\t%s\n", enabled(status, 1));
654 len += sprintf(p + len, "commands:\tenable, disable\n");
655 }
656
657 return len;
658 }
659
660 static int bluetooth_write(char *buf)
661 {
662 int status = bluetooth_status();
663 char *cmd;
664 int do_cmd = 0;
665
666 if (!bluetooth_supported)
667 return -ENODEV;
668
669 while ((cmd = next_cmd(&buf))) {
670 if (strlencmp(cmd, "enable") == 0) {
671 status |= 2;
672 } else if (strlencmp(cmd, "disable") == 0) {
673 status &= ~2;
674 } else
675 return -EINVAL;
676 do_cmd = 1;
677 }
678
679 if (do_cmd && !acpi_evalf(hkey_handle, NULL, "SBDC", "vd", status))
680 return -EIO;
681
682 return 0;
683 }
684
685 /*************************************************************************
686 * Wan subdriver
687 */
688
689 static int wan_supported;
690
691 static int wan_init(void)
692 {
693 wan_supported = hkey_handle &&
694 acpi_evalf(hkey_handle, NULL, "GWAN", "qv");
695
696 return 0;
697 }
698
699 static int wan_status(void)
700 {
701 int status;
702
703 if (!wan_supported || !acpi_evalf(hkey_handle, &status, "GWAN", "d"))
704 status = 0;
705
706 return status;
707 }
708
709 static int wan_read(char *p)
710 {
711 int len = 0;
712 int status = wan_status();
713
714 if (!wan_supported)
715 len += sprintf(p + len, "status:\t\tnot supported\n");
716 else if (!(status & 1))
717 len += sprintf(p + len, "status:\t\tnot installed\n");
718 else {
719 len += sprintf(p + len, "status:\t\t%s\n", enabled(status, 1));
720 len += sprintf(p + len, "commands:\tenable, disable\n");
721 }
722
723 return len;
724 }
725
726 static int wan_write(char *buf)
727 {
728 int status = wan_status();
729 char *cmd;
730 int do_cmd = 0;
731
732 if (!wan_supported)
733 return -ENODEV;
734
735 while ((cmd = next_cmd(&buf))) {
736 if (strlencmp(cmd, "enable") == 0) {
737 status |= 2;
738 } else if (strlencmp(cmd, "disable") == 0) {
739 status &= ~2;
740 } else
741 return -EINVAL;
742 do_cmd = 1;
743 }
744
745 if (do_cmd && !acpi_evalf(hkey_handle, NULL, "SWAN", "vd", status))
746 return -EIO;
747
748 return 0;
749 }
750
751 /*************************************************************************
752 * Video subdriver
753 */
754
755 static enum video_access_mode video_supported;
756 static int video_orig_autosw;
757
758 IBM_HANDLE(vid, root, "\\_SB.PCI.AGP.VGA", /* 570 */
759 "\\_SB.PCI0.AGP0.VID0", /* 600e/x, 770x */
760 "\\_SB.PCI0.VID0", /* 770e */
761 "\\_SB.PCI0.VID", /* A21e, G4x, R50e, X30, X40 */
762 "\\_SB.PCI0.AGP.VID", /* all others */
763 ); /* R30, R31 */
764
765 IBM_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID"); /* G41 */
766
767 static int video_init(void)
768 {
769 int ivga;
770
771 if (vid2_handle && acpi_evalf(NULL, &ivga, "\\IVGA", "d") && ivga)
772 /* G41, assume IVGA doesn't change */
773 vid_handle = vid2_handle;
774
775 if (!vid_handle)
776 /* video switching not supported on R30, R31 */
777 video_supported = IBMACPI_VIDEO_NONE;
778 else if (acpi_evalf(vid_handle, &video_orig_autosw, "SWIT", "qd"))
779 /* 570 */
780 video_supported = IBMACPI_VIDEO_570;
781 else if (acpi_evalf(vid_handle, &video_orig_autosw, "^VADL", "qd"))
782 /* 600e/x, 770e, 770x */
783 video_supported = IBMACPI_VIDEO_770;
784 else
785 /* all others */
786 video_supported = IBMACPI_VIDEO_NEW;
787
788 return 0;
789 }
790
791 static void video_exit(void)
792 {
793 acpi_evalf(vid_handle, NULL, "_DOS", "vd", video_orig_autosw);
794 }
795
796 static int video_status(void)
797 {
798 int status = 0;
799 int i;
800
801 if (video_supported == IBMACPI_VIDEO_570) {
802 if (acpi_evalf(NULL, &i, "\\_SB.PHS", "dd", 0x87))
803 status = i & 3;
804 } else if (video_supported == IBMACPI_VIDEO_770) {
805 if (acpi_evalf(NULL, &i, "\\VCDL", "d"))
806 status |= 0x01 * i;
807 if (acpi_evalf(NULL, &i, "\\VCDC", "d"))
808 status |= 0x02 * i;
809 } else if (video_supported == IBMACPI_VIDEO_NEW) {
810 acpi_evalf(NULL, NULL, "\\VUPS", "vd", 1);
811 if (acpi_evalf(NULL, &i, "\\VCDC", "d"))
812 status |= 0x02 * i;
813
814 acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0);
815 if (acpi_evalf(NULL, &i, "\\VCDL", "d"))
816 status |= 0x01 * i;
817 if (acpi_evalf(NULL, &i, "\\VCDD", "d"))
818 status |= 0x08 * i;
819 }
820
821 return status;
822 }
823
824 static int video_autosw(void)
825 {
826 int autosw = 0;
827
828 if (video_supported == IBMACPI_VIDEO_570)
829 acpi_evalf(vid_handle, &autosw, "SWIT", "d");
830 else if (video_supported == IBMACPI_VIDEO_770 ||
831 video_supported == IBMACPI_VIDEO_NEW)
832 acpi_evalf(vid_handle, &autosw, "^VDEE", "d");
833
834 return autosw & 1;
835 }
836
837 static int video_switch(void)
838 {
839 int autosw = video_autosw();
840 int ret;
841
842 if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", 1))
843 return -EIO;
844 ret = video_supported == IBMACPI_VIDEO_570 ?
845 acpi_evalf(ec_handle, NULL, "_Q16", "v") :
846 acpi_evalf(vid_handle, NULL, "VSWT", "v");
847 acpi_evalf(vid_handle, NULL, "_DOS", "vd", autosw);
848
849 return ret;
850 }
851
852 static int video_expand(void)
853 {
854 if (video_supported == IBMACPI_VIDEO_570)
855 return acpi_evalf(ec_handle, NULL, "_Q17", "v");
856 else if (video_supported == IBMACPI_VIDEO_770)
857 return acpi_evalf(vid_handle, NULL, "VEXP", "v");
858 else
859 return acpi_evalf(NULL, NULL, "\\VEXP", "v");
860 }
861
862 static int video_switch2(int status)
863 {
864 int ret;
865
866 if (video_supported == IBMACPI_VIDEO_570) {
867 ret = acpi_evalf(NULL, NULL,
868 "\\_SB.PHS2", "vdd", 0x8b, status | 0x80);
869 } else if (video_supported == IBMACPI_VIDEO_770) {
870 int autosw = video_autosw();
871 if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", 1))
872 return -EIO;
873
874 ret = acpi_evalf(vid_handle, NULL,
875 "ASWT", "vdd", status * 0x100, 0);
876
877 acpi_evalf(vid_handle, NULL, "_DOS", "vd", autosw);
878 } else {
879 ret = acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0x80) &&
880 acpi_evalf(NULL, NULL, "\\VSDS", "vdd", status, 1);
881 }
882
883 return ret;
884 }
885
886 static int video_read(char *p)
887 {
888 int status = video_status();
889 int autosw = video_autosw();
890 int len = 0;
891
892 if (!video_supported) {
893 len += sprintf(p + len, "status:\t\tnot supported\n");
894 return len;
895 }
896
897 len += sprintf(p + len, "status:\t\tsupported\n");
898 len += sprintf(p + len, "lcd:\t\t%s\n", enabled(status, 0));
899 len += sprintf(p + len, "crt:\t\t%s\n", enabled(status, 1));
900 if (video_supported == IBMACPI_VIDEO_NEW)
901 len += sprintf(p + len, "dvi:\t\t%s\n", enabled(status, 3));
902 len += sprintf(p + len, "auto:\t\t%s\n", enabled(autosw, 0));
903 len += sprintf(p + len, "commands:\tlcd_enable, lcd_disable\n");
904 len += sprintf(p + len, "commands:\tcrt_enable, crt_disable\n");
905 if (video_supported == IBMACPI_VIDEO_NEW)
906 len += sprintf(p + len, "commands:\tdvi_enable, dvi_disable\n");
907 len += sprintf(p + len, "commands:\tauto_enable, auto_disable\n");
908 len += sprintf(p + len, "commands:\tvideo_switch, expand_toggle\n");
909
910 return len;
911 }
912
913 static int video_write(char *buf)
914 {
915 char *cmd;
916 int enable, disable, status;
917
918 if (!video_supported)
919 return -ENODEV;
920
921 enable = disable = 0;
922
923 while ((cmd = next_cmd(&buf))) {
924 if (strlencmp(cmd, "lcd_enable") == 0) {
925 enable |= 0x01;
926 } else if (strlencmp(cmd, "lcd_disable") == 0) {
927 disable |= 0x01;
928 } else if (strlencmp(cmd, "crt_enable") == 0) {
929 enable |= 0x02;
930 } else if (strlencmp(cmd, "crt_disable") == 0) {
931 disable |= 0x02;
932 } else if (video_supported == IBMACPI_VIDEO_NEW &&
933 strlencmp(cmd, "dvi_enable") == 0) {
934 enable |= 0x08;
935 } else if (video_supported == IBMACPI_VIDEO_NEW &&
936 strlencmp(cmd, "dvi_disable") == 0) {
937 disable |= 0x08;
938 } else if (strlencmp(cmd, "auto_enable") == 0) {
939 if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", 1))
940 return -EIO;
941 } else if (strlencmp(cmd, "auto_disable") == 0) {
942 if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", 0))
943 return -EIO;
944 } else if (strlencmp(cmd, "video_switch") == 0) {
945 if (!video_switch())
946 return -EIO;
947 } else if (strlencmp(cmd, "expand_toggle") == 0) {
948 if (!video_expand())
949 return -EIO;
950 } else
951 return -EINVAL;
952 }
953
954 if (enable || disable) {
955 status = (video_status() & 0x0f & ~disable) | enable;
956 if (!video_switch2(status))
957 return -EIO;
958 }
959
960 return 0;
961 }
962
963 /*************************************************************************
964 * Light (thinklight) subdriver
965 */
966
967 static int light_supported;
968 static int light_status_supported;
969
970 IBM_HANDLE(lght, root, "\\LGHT"); /* A21e, A2xm/p, T20-22, X20-21 */
971 IBM_HANDLE(ledb, ec, "LEDB"); /* G4x */
972
973 static int light_init(void)
974 {
975 /* light not supported on 570, 600e/x, 770e, 770x, G4x, R30, R31 */
976 light_supported = (cmos_handle || lght_handle) && !ledb_handle;
977
978 if (light_supported)
979 /* light status not supported on
980 570, 600e/x, 770e, 770x, G4x, R30, R31, R32, X20 */
981 light_status_supported = acpi_evalf(ec_handle, NULL,
982 "KBLT", "qv");
983
984 return 0;
985 }
986
987 static int light_read(char *p)
988 {
989 int len = 0;
990 int status = 0;
991
992 if (!light_supported) {
993 len += sprintf(p + len, "status:\t\tnot supported\n");
994 } else if (!light_status_supported) {
995 len += sprintf(p + len, "status:\t\tunknown\n");
996 len += sprintf(p + len, "commands:\ton, off\n");
997 } else {
998 if (!acpi_evalf(ec_handle, &status, "KBLT", "d"))
999 return -EIO;
1000 len += sprintf(p + len, "status:\t\t%s\n", onoff(status, 0));
1001 len += sprintf(p + len, "commands:\ton, off\n");
1002 }
1003
1004 return len;
1005 }
1006
1007 static int light_write(char *buf)
1008 {
1009 int cmos_cmd, lght_cmd;
1010 char *cmd;
1011 int success;
1012
1013 if (!light_supported)
1014 return -ENODEV;
1015
1016 while ((cmd = next_cmd(&buf))) {
1017 if (strlencmp(cmd, "on") == 0) {
1018 cmos_cmd = 0x0c;
1019 lght_cmd = 1;
1020 } else if (strlencmp(cmd, "off") == 0) {
1021 cmos_cmd = 0x0d;
1022 lght_cmd = 0;
1023 } else
1024 return -EINVAL;
1025
1026 success = cmos_handle ?
1027 acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd) :
1028 acpi_evalf(lght_handle, NULL, NULL, "vd", lght_cmd);
1029 if (!success)
1030 return -EIO;
1031 }
1032
1033 return 0;
1034 }
1035
1036 /*************************************************************************
1037 * Dock subdriver
1038 */
1039
1040 /* don't list other alternatives as we install a notify handler on the 570 */
1041 IBM_HANDLE(pci, root, "\\_SB.PCI"); /* 570 */
1042
1043 #ifdef CONFIG_THINKPAD_ACPI_DOCK
1044
1045 IBM_HANDLE(dock, root, "\\_SB.GDCK", /* X30, X31, X40 */
1046 "\\_SB.PCI0.DOCK", /* 600e/x,770e,770x,A2xm/p,T20-22,X20-21 */
1047 "\\_SB.PCI0.PCI1.DOCK", /* all others */
1048 "\\_SB.PCI.ISA.SLCE", /* 570 */
1049 ); /* A21e,G4x,R30,R31,R32,R40,R40e,R50e */
1050
1051 #define dock_docked() (_sta(dock_handle) & 1)
1052
1053 static void dock_notify(struct ibm_struct *ibm, u32 event)
1054 {
1055 int docked = dock_docked();
1056 int pci = ibm->hid && strstr(ibm->hid, IBM_PCI_HID);
1057
1058 if (event == 1 && !pci) /* 570 */
1059 acpi_bus_generate_event(ibm->device, event, 1); /* button */
1060 else if (event == 1 && pci) /* 570 */
1061 acpi_bus_generate_event(ibm->device, event, 3); /* dock */
1062 else if (event == 3 && docked)
1063 acpi_bus_generate_event(ibm->device, event, 1); /* button */
1064 else if (event == 3 && !docked)
1065 acpi_bus_generate_event(ibm->device, event, 2); /* undock */
1066 else if (event == 0 && docked)
1067 acpi_bus_generate_event(ibm->device, event, 3); /* dock */
1068 else {
1069 printk(IBM_ERR "unknown dock event %d, status %d\n",
1070 event, _sta(dock_handle));
1071 acpi_bus_generate_event(ibm->device, event, 0); /* unknown */
1072 }
1073 }
1074
1075 static int dock_read(char *p)
1076 {
1077 int len = 0;
1078 int docked = dock_docked();
1079
1080 if (!dock_handle)
1081 len += sprintf(p + len, "status:\t\tnot supported\n");
1082 else if (!docked)
1083 len += sprintf(p + len, "status:\t\tundocked\n");
1084 else {
1085 len += sprintf(p + len, "status:\t\tdocked\n");
1086 len += sprintf(p + len, "commands:\tdock, undock\n");
1087 }
1088
1089 return len;
1090 }
1091
1092 static int dock_write(char *buf)
1093 {
1094 char *cmd;
1095
1096 if (!dock_docked())
1097 return -ENODEV;
1098
1099 while ((cmd = next_cmd(&buf))) {
1100 if (strlencmp(cmd, "undock") == 0) {
1101 if (!acpi_evalf(dock_handle, NULL, "_DCK", "vd", 0) ||
1102 !acpi_evalf(dock_handle, NULL, "_EJ0", "vd", 1))
1103 return -EIO;
1104 } else if (strlencmp(cmd, "dock") == 0) {
1105 if (!acpi_evalf(dock_handle, NULL, "_DCK", "vd", 1))
1106 return -EIO;
1107 } else
1108 return -EINVAL;
1109 }
1110
1111 return 0;
1112 }
1113
1114 #endif /* CONFIG_THINKPAD_ACPI_DOCK */
1115
1116 /*************************************************************************
1117 * Bay subdriver
1118 */
1119
1120 #ifdef CONFIG_THINKPAD_ACPI_BAY
1121 static int bay_status_supported;
1122 static int bay_status2_supported;
1123 static int bay_eject_supported;
1124 static int bay_eject2_supported;
1125
1126 IBM_HANDLE(bay, root, "\\_SB.PCI.IDE.SECN.MAST", /* 570 */
1127 "\\_SB.PCI0.IDE0.IDES.IDSM", /* 600e/x, 770e, 770x */
1128 "\\_SB.PCI0.SATA.SCND.MSTR", /* T60, X60, Z60 */
1129 "\\_SB.PCI0.IDE0.SCND.MSTR", /* all others */
1130 ); /* A21e, R30, R31 */
1131 IBM_HANDLE(bay_ej, bay, "_EJ3", /* 600e/x, A2xm/p, A3x */
1132 "_EJ0", /* all others */
1133 ); /* 570,A21e,G4x,R30,R31,R32,R40e,R50e */
1134 IBM_HANDLE(bay2, root, "\\_SB.PCI0.IDE0.PRIM.SLAV", /* A3x, R32 */
1135 "\\_SB.PCI0.IDE0.IDEP.IDPS", /* 600e/x, 770e, 770x */
1136 ); /* all others */
1137 IBM_HANDLE(bay2_ej, bay2, "_EJ3", /* 600e/x, 770e, A3x */
1138 "_EJ0", /* 770x */
1139 ); /* all others */
1140
1141 static int bay_init(void)
1142 {
1143 bay_status_supported = bay_handle &&
1144 acpi_evalf(bay_handle, NULL, "_STA", "qv");
1145 bay_status2_supported = bay2_handle &&
1146 acpi_evalf(bay2_handle, NULL, "_STA", "qv");
1147
1148 bay_eject_supported = bay_handle && bay_ej_handle &&
1149 (strlencmp(bay_ej_path, "_EJ0") == 0 || experimental);
1150 bay_eject2_supported = bay2_handle && bay2_ej_handle &&
1151 (strlencmp(bay2_ej_path, "_EJ0") == 0 || experimental);
1152
1153 return 0;
1154 }
1155
1156 static void bay_notify(struct ibm_struct *ibm, u32 event)
1157 {
1158 acpi_bus_generate_event(ibm->device, event, 0);
1159 }
1160
1161 #define bay_occupied(b) (_sta(b##_handle) & 1)
1162
1163 static int bay_read(char *p)
1164 {
1165 int len = 0;
1166 int occupied = bay_occupied(bay);
1167 int occupied2 = bay_occupied(bay2);
1168 int eject, eject2;
1169
1170 len += sprintf(p + len, "status:\t\t%s\n", bay_status_supported ?
1171 (occupied ? "occupied" : "unoccupied") :
1172 "not supported");
1173 if (bay_status2_supported)
1174 len += sprintf(p + len, "status2:\t%s\n", occupied2 ?
1175 "occupied" : "unoccupied");
1176
1177 eject = bay_eject_supported && occupied;
1178 eject2 = bay_eject2_supported && occupied2;
1179
1180 if (eject && eject2)
1181 len += sprintf(p + len, "commands:\teject, eject2\n");
1182 else if (eject)
1183 len += sprintf(p + len, "commands:\teject\n");
1184 else if (eject2)
1185 len += sprintf(p + len, "commands:\teject2\n");
1186
1187 return len;
1188 }
1189
1190 static int bay_write(char *buf)
1191 {
1192 char *cmd;
1193
1194 if (!bay_eject_supported && !bay_eject2_supported)
1195 return -ENODEV;
1196
1197 while ((cmd = next_cmd(&buf))) {
1198 if (bay_eject_supported && strlencmp(cmd, "eject") == 0) {
1199 if (!acpi_evalf(bay_ej_handle, NULL, NULL, "vd", 1))
1200 return -EIO;
1201 } else if (bay_eject2_supported &&
1202 strlencmp(cmd, "eject2") == 0) {
1203 if (!acpi_evalf(bay2_ej_handle, NULL, NULL, "vd", 1))
1204 return -EIO;
1205 } else
1206 return -EINVAL;
1207 }
1208
1209 return 0;
1210 }
1211 #endif /* CONFIG_THINKPAD_ACPI_BAY */
1212
1213 /*************************************************************************
1214 * CMOS subdriver
1215 */
1216
1217 static int cmos_eval(int cmos_cmd)
1218 {
1219 if (cmos_handle)
1220 return acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd);
1221 else
1222 return 1;
1223 }
1224
1225 static int cmos_read(char *p)
1226 {
1227 int len = 0;
1228
1229 /* cmos not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
1230 R30, R31, T20-22, X20-21 */
1231 if (!cmos_handle)
1232 len += sprintf(p + len, "status:\t\tnot supported\n");
1233 else {
1234 len += sprintf(p + len, "status:\t\tsupported\n");
1235 len += sprintf(p + len, "commands:\t<cmd> (<cmd> is 0-21)\n");
1236 }
1237
1238 return len;
1239 }
1240
1241 static int cmos_write(char *buf)
1242 {
1243 char *cmd;
1244 int cmos_cmd;
1245
1246 if (!cmos_handle)
1247 return -EINVAL;
1248
1249 while ((cmd = next_cmd(&buf))) {
1250 if (sscanf(cmd, "%u", &cmos_cmd) == 1 &&
1251 cmos_cmd >= 0 && cmos_cmd <= 21) {
1252 /* cmos_cmd set */
1253 } else
1254 return -EINVAL;
1255
1256 if (!cmos_eval(cmos_cmd))
1257 return -EIO;
1258 }
1259
1260 return 0;
1261 }
1262
1263
1264 /*************************************************************************
1265 * LED subdriver
1266 */
1267
1268 static enum led_access_mode led_supported;
1269
1270 IBM_HANDLE(led, ec, "SLED", /* 570 */
1271 "SYSL", /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
1272 "LED", /* all others */
1273 ); /* R30, R31 */
1274
1275 static int led_init(void)
1276 {
1277 if (!led_handle)
1278 /* led not supported on R30, R31 */
1279 led_supported = IBMACPI_LED_NONE;
1280 else if (strlencmp(led_path, "SLED") == 0)
1281 /* 570 */
1282 led_supported = IBMACPI_LED_570;
1283 else if (strlencmp(led_path, "SYSL") == 0)
1284 /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
1285 led_supported = IBMACPI_LED_OLD;
1286 else
1287 /* all others */
1288 led_supported = IBMACPI_LED_NEW;
1289
1290 return 0;
1291 }
1292
1293 #define led_status(s) ((s) == 0 ? "off" : ((s) == 1 ? "on" : "blinking"))
1294
1295 static int led_read(char *p)
1296 {
1297 int len = 0;
1298
1299 if (!led_supported) {
1300 len += sprintf(p + len, "status:\t\tnot supported\n");
1301 return len;
1302 }
1303 len += sprintf(p + len, "status:\t\tsupported\n");
1304
1305 if (led_supported == IBMACPI_LED_570) {
1306 /* 570 */
1307 int i, status;
1308 for (i = 0; i < 8; i++) {
1309 if (!acpi_evalf(ec_handle,
1310 &status, "GLED", "dd", 1 << i))
1311 return -EIO;
1312 len += sprintf(p + len, "%d:\t\t%s\n",
1313 i, led_status(status));
1314 }
1315 }
1316
1317 len += sprintf(p + len, "commands:\t"
1318 "<led> on, <led> off, <led> blink (<led> is 0-7)\n");
1319
1320 return len;
1321 }
1322
1323 /* off, on, blink */
1324 static const int led_sled_arg1[] = { 0, 1, 3 };
1325 static const int led_exp_hlbl[] = { 0, 0, 1 }; /* led# * */
1326 static const int led_exp_hlcl[] = { 0, 1, 1 }; /* led# * */
1327 static const int led_led_arg1[] = { 0, 0x80, 0xc0 };
1328
1329 static int led_write(char *buf)
1330 {
1331 char *cmd;
1332 int led, ind, ret;
1333
1334 if (!led_supported)
1335 return -ENODEV;
1336
1337 while ((cmd = next_cmd(&buf))) {
1338 if (sscanf(cmd, "%d", &led) != 1 || led < 0 || led > 7)
1339 return -EINVAL;
1340
1341 if (strstr(cmd, "off")) {
1342 ind = 0;
1343 } else if (strstr(cmd, "on")) {
1344 ind = 1;
1345 } else if (strstr(cmd, "blink")) {
1346 ind = 2;
1347 } else
1348 return -EINVAL;
1349
1350 if (led_supported == IBMACPI_LED_570) {
1351 /* 570 */
1352 led = 1 << led;
1353 if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
1354 led, led_sled_arg1[ind]))
1355 return -EIO;
1356 } else if (led_supported == IBMACPI_LED_OLD) {
1357 /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20 */
1358 led = 1 << led;
1359 ret = ec_write(IBMACPI_LED_EC_HLMS, led);
1360 if (ret >= 0)
1361 ret =
1362 ec_write(IBMACPI_LED_EC_HLBL,
1363 led * led_exp_hlbl[ind]);
1364 if (ret >= 0)
1365 ret =
1366 ec_write(IBMACPI_LED_EC_HLCL,
1367 led * led_exp_hlcl[ind]);
1368 if (ret < 0)
1369 return ret;
1370 } else {
1371 /* all others */
1372 if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
1373 led, led_led_arg1[ind]))
1374 return -EIO;
1375 }
1376 }
1377
1378 return 0;
1379 }
1380
1381 /*************************************************************************
1382 * Beep subdriver
1383 */
1384
1385 IBM_HANDLE(beep, ec, "BEEP"); /* all except R30, R31 */
1386
1387 static int beep_read(char *p)
1388 {
1389 int len = 0;
1390
1391 if (!beep_handle)
1392 len += sprintf(p + len, "status:\t\tnot supported\n");
1393 else {
1394 len += sprintf(p + len, "status:\t\tsupported\n");
1395 len += sprintf(p + len, "commands:\t<cmd> (<cmd> is 0-17)\n");
1396 }
1397
1398 return len;
1399 }
1400
1401 static int beep_write(char *buf)
1402 {
1403 char *cmd;
1404 int beep_cmd;
1405
1406 if (!beep_handle)
1407 return -ENODEV;
1408
1409 while ((cmd = next_cmd(&buf))) {
1410 if (sscanf(cmd, "%u", &beep_cmd) == 1 &&
1411 beep_cmd >= 0 && beep_cmd <= 17) {
1412 /* beep_cmd set */
1413 } else
1414 return -EINVAL;
1415 if (!acpi_evalf(beep_handle, NULL, NULL, "vdd", beep_cmd, 0))
1416 return -EIO;
1417 }
1418
1419 return 0;
1420 }
1421
1422 /*************************************************************************
1423 * Thermal subdriver
1424 */
1425
1426 static enum thermal_access_mode thermal_read_mode;
1427
1428 static int thermal_init(void)
1429 {
1430 u8 t, ta1, ta2;
1431 int i;
1432 int acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
1433
1434 if (ibm_thinkpad_ec_found && experimental) {
1435 /*
1436 * Direct EC access mode: sensors at registers
1437 * 0x78-0x7F, 0xC0-0xC7. Registers return 0x00 for
1438 * non-implemented, thermal sensors return 0x80 when
1439 * not available
1440 */
1441
1442 ta1 = ta2 = 0;
1443 for (i = 0; i < 8; i++) {
1444 if (likely(acpi_ec_read(0x78 + i, &t))) {
1445 ta1 |= t;
1446 } else {
1447 ta1 = 0;
1448 break;
1449 }
1450 if (likely(acpi_ec_read(0xC0 + i, &t))) {
1451 ta2 |= t;
1452 } else {
1453 ta1 = 0;
1454 break;
1455 }
1456 }
1457 if (ta1 == 0) {
1458 /* This is sheer paranoia, but we handle it anyway */
1459 if (acpi_tmp7) {
1460 printk(IBM_ERR
1461 "ThinkPad ACPI EC access misbehaving, "
1462 "falling back to ACPI TMPx access mode\n");
1463 thermal_read_mode = IBMACPI_THERMAL_ACPI_TMP07;
1464 } else {
1465 printk(IBM_ERR
1466 "ThinkPad ACPI EC access misbehaving, "
1467 "disabling thermal sensors access\n");
1468 thermal_read_mode = IBMACPI_THERMAL_NONE;
1469 }
1470 } else {
1471 thermal_read_mode =
1472 (ta2 != 0) ?
1473 IBMACPI_THERMAL_TPEC_16 : IBMACPI_THERMAL_TPEC_8;
1474 }
1475 } else if (acpi_tmp7) {
1476 if (acpi_evalf(ec_handle, NULL, "UPDT", "qv")) {
1477 /* 600e/x, 770e, 770x */
1478 thermal_read_mode = IBMACPI_THERMAL_ACPI_UPDT;
1479 } else {
1480 /* Standard ACPI TMPx access, max 8 sensors */
1481 thermal_read_mode = IBMACPI_THERMAL_ACPI_TMP07;
1482 }
1483 } else {
1484 /* temperatures not supported on 570, G4x, R30, R31, R32 */
1485 thermal_read_mode = IBMACPI_THERMAL_NONE;
1486 }
1487
1488 return 0;
1489 }
1490
1491 static int thermal_get_sensors(struct ibm_thermal_sensors_struct *s)
1492 {
1493 int i, t;
1494 s8 tmp;
1495 char tmpi[] = "TMPi";
1496
1497 if (!s)
1498 return -EINVAL;
1499
1500 switch (thermal_read_mode) {
1501 #if IBMACPI_MAX_THERMAL_SENSORS >= 16
1502 case IBMACPI_THERMAL_TPEC_16:
1503 for (i = 0; i < 8; i++) {
1504 if (!acpi_ec_read(0xC0 + i, &tmp))
1505 return -EIO;
1506 s->temp[i + 8] = tmp * 1000;
1507 }
1508 /* fallthrough */
1509 #endif
1510 case IBMACPI_THERMAL_TPEC_8:
1511 for (i = 0; i < 8; i++) {
1512 if (!acpi_ec_read(0x78 + i, &tmp))
1513 return -EIO;
1514 s->temp[i] = tmp * 1000;
1515 }
1516 return (thermal_read_mode == IBMACPI_THERMAL_TPEC_16) ? 16 : 8;
1517
1518 case IBMACPI_THERMAL_ACPI_UPDT:
1519 if (!acpi_evalf(ec_handle, NULL, "UPDT", "v"))
1520 return -EIO;
1521 for (i = 0; i < 8; i++) {
1522 tmpi[3] = '0' + i;
1523 if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
1524 return -EIO;
1525 s->temp[i] = (t - 2732) * 100;
1526 }
1527 return 8;
1528
1529 case IBMACPI_THERMAL_ACPI_TMP07:
1530 for (i = 0; i < 8; i++) {
1531 tmpi[3] = '0' + i;
1532 if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
1533 return -EIO;
1534 s->temp[i] = t * 1000;
1535 }
1536 return 8;
1537
1538 case IBMACPI_THERMAL_NONE:
1539 default:
1540 return 0;
1541 }
1542 }
1543
1544 static int thermal_read(char *p)
1545 {
1546 int len = 0;
1547 int n, i;
1548 struct ibm_thermal_sensors_struct t;
1549
1550 n = thermal_get_sensors(&t);
1551 if (unlikely(n < 0))
1552 return n;
1553
1554 len += sprintf(p + len, "temperatures:\t");
1555
1556 if (n > 0) {
1557 for (i = 0; i < (n - 1); i++)
1558 len += sprintf(p + len, "%d ", t.temp[i] / 1000);
1559 len += sprintf(p + len, "%d\n", t.temp[i] / 1000);
1560 } else
1561 len += sprintf(p + len, "not supported\n");
1562
1563 return len;
1564 }
1565
1566 /*************************************************************************
1567 * EC Dump subdriver
1568 */
1569
1570 static u8 ecdump_regs[256];
1571
1572 static int ecdump_read(char *p)
1573 {
1574 int len = 0;
1575 int i, j;
1576 u8 v;
1577
1578 len += sprintf(p + len, "EC "
1579 " +00 +01 +02 +03 +04 +05 +06 +07"
1580 " +08 +09 +0a +0b +0c +0d +0e +0f\n");
1581 for (i = 0; i < 256; i += 16) {
1582 len += sprintf(p + len, "EC 0x%02x:", i);
1583 for (j = 0; j < 16; j++) {
1584 if (!acpi_ec_read(i + j, &v))
1585 break;
1586 if (v != ecdump_regs[i + j])
1587 len += sprintf(p + len, " *%02x", v);
1588 else
1589 len += sprintf(p + len, " %02x", v);
1590 ecdump_regs[i + j] = v;
1591 }
1592 len += sprintf(p + len, "\n");
1593 if (j != 16)
1594 break;
1595 }
1596
1597 /* These are way too dangerous to advertise openly... */
1598 #if 0
1599 len += sprintf(p + len, "commands:\t0x<offset> 0x<value>"
1600 " (<offset> is 00-ff, <value> is 00-ff)\n");
1601 len += sprintf(p + len, "commands:\t0x<offset> <value> "
1602 " (<offset> is 00-ff, <value> is 0-255)\n");
1603 #endif
1604 return len;
1605 }
1606
1607 static int ecdump_write(char *buf)
1608 {
1609 char *cmd;
1610 int i, v;
1611
1612 while ((cmd = next_cmd(&buf))) {
1613 if (sscanf(cmd, "0x%x 0x%x", &i, &v) == 2) {
1614 /* i and v set */
1615 } else if (sscanf(cmd, "0x%x %u", &i, &v) == 2) {
1616 /* i and v set */
1617 } else
1618 return -EINVAL;
1619 if (i >= 0 && i < 256 && v >= 0 && v < 256) {
1620 if (!acpi_ec_write(i, v))
1621 return -EIO;
1622 } else
1623 return -EINVAL;
1624 }
1625
1626 return 0;
1627 }
1628
1629 /*************************************************************************
1630 * Backlight/brightness subdriver
1631 */
1632
1633 static struct backlight_device *ibm_backlight_device = NULL;
1634
1635 static struct backlight_properties ibm_backlight_data = {
1636 .owner = THIS_MODULE,
1637 .get_brightness = brightness_get,
1638 .update_status = brightness_update_status,
1639 .max_brightness = 7,
1640 };
1641
1642 static int brightness_init(void)
1643 {
1644 int b;
1645
1646 b = brightness_get(NULL);
1647 if (b < 0)
1648 return b;
1649
1650 ibm_backlight_device = backlight_device_register("ibm", NULL, NULL,
1651 &ibm_backlight_data);
1652 if (IS_ERR(ibm_backlight_device)) {
1653 printk(IBM_ERR "Could not register backlight device\n");
1654 return PTR_ERR(ibm_backlight_device);
1655 }
1656
1657 ibm_backlight_device->props->brightness = b;
1658 brightness_update_status(ibm_backlight_device);
1659
1660 return 0;
1661 }
1662
1663 static void brightness_exit(void)
1664 {
1665 if (ibm_backlight_device) {
1666 backlight_device_unregister(ibm_backlight_device);
1667 ibm_backlight_device = NULL;
1668 }
1669 }
1670
1671 static int brightness_update_status(struct backlight_device *bd)
1672 {
1673 return brightness_set(
1674 (bd->props->fb_blank == FB_BLANK_UNBLANK &&
1675 bd->props->power == FB_BLANK_UNBLANK) ?
1676 bd->props->brightness : 0);
1677 }
1678
1679 static int brightness_get(struct backlight_device *bd)
1680 {
1681 u8 level;
1682 if (!acpi_ec_read(brightness_offset, &level))
1683 return -EIO;
1684
1685 level &= 0x7;
1686
1687 return level;
1688 }
1689
1690 static int brightness_set(int value)
1691 {
1692 int cmos_cmd, inc, i;
1693 int current_value = brightness_get(NULL);
1694
1695 value &= 7;
1696
1697 cmos_cmd = value > current_value ? TP_CMOS_BRIGHTNESS_UP : TP_CMOS_BRIGHTNESS_DOWN;
1698 inc = value > current_value ? 1 : -1;
1699 for (i = current_value; i != value; i += inc) {
1700 if (!cmos_eval(cmos_cmd))
1701 return -EIO;
1702 if (!acpi_ec_write(brightness_offset, i + inc))
1703 return -EIO;
1704 }
1705
1706 return 0;
1707 }
1708
1709 static int brightness_read(char *p)
1710 {
1711 int len = 0;
1712 int level;
1713
1714 if ((level = brightness_get(NULL)) < 0) {
1715 len += sprintf(p + len, "level:\t\tunreadable\n");
1716 } else {
1717 len += sprintf(p + len, "level:\t\t%d\n", level & 0x7);
1718 len += sprintf(p + len, "commands:\tup, down\n");
1719 len += sprintf(p + len, "commands:\tlevel <level>"
1720 " (<level> is 0-7)\n");
1721 }
1722
1723 return len;
1724 }
1725
1726 static int brightness_write(char *buf)
1727 {
1728 int level;
1729 int new_level;
1730 char *cmd;
1731
1732 while ((cmd = next_cmd(&buf))) {
1733 if ((level = brightness_get(NULL)) < 0)
1734 return level;
1735 level &= 7;
1736
1737 if (strlencmp(cmd, "up") == 0) {
1738 new_level = level == 7 ? 7 : level + 1;
1739 } else if (strlencmp(cmd, "down") == 0) {
1740 new_level = level == 0 ? 0 : level - 1;
1741 } else if (sscanf(cmd, "level %d", &new_level) == 1 &&
1742 new_level >= 0 && new_level <= 7) {
1743 /* new_level set */
1744 } else
1745 return -EINVAL;
1746
1747 brightness_set(new_level);
1748 }
1749
1750 return 0;
1751 }
1752
1753 /*************************************************************************
1754 * Volume subdriver
1755 */
1756
1757 static int volume_read(char *p)
1758 {
1759 int len = 0;
1760 u8 level;
1761
1762 if (!acpi_ec_read(volume_offset, &level)) {
1763 len += sprintf(p + len, "level:\t\tunreadable\n");
1764 } else {
1765 len += sprintf(p + len, "level:\t\t%d\n", level & 0xf);
1766 len += sprintf(p + len, "mute:\t\t%s\n", onoff(level, 6));
1767 len += sprintf(p + len, "commands:\tup, down, mute\n");
1768 len += sprintf(p + len, "commands:\tlevel <level>"
1769 " (<level> is 0-15)\n");
1770 }
1771
1772 return len;
1773 }
1774
1775 static int volume_write(char *buf)
1776 {
1777 int cmos_cmd, inc, i;
1778 u8 level, mute;
1779 int new_level, new_mute;
1780 char *cmd;
1781
1782 while ((cmd = next_cmd(&buf))) {
1783 if (!acpi_ec_read(volume_offset, &level))
1784 return -EIO;
1785 new_mute = mute = level & 0x40;
1786 new_level = level = level & 0xf;
1787
1788 if (strlencmp(cmd, "up") == 0) {
1789 if (mute)
1790 new_mute = 0;
1791 else
1792 new_level = level == 15 ? 15 : level + 1;
1793 } else if (strlencmp(cmd, "down") == 0) {
1794 if (mute)
1795 new_mute = 0;
1796 else
1797 new_level = level == 0 ? 0 : level - 1;
1798 } else if (sscanf(cmd, "level %d", &new_level) == 1 &&
1799 new_level >= 0 && new_level <= 15) {
1800 /* new_level set */
1801 } else if (strlencmp(cmd, "mute") == 0) {
1802 new_mute = 0x40;
1803 } else
1804 return -EINVAL;
1805
1806 if (new_level != level) { /* mute doesn't change */
1807 cmos_cmd = new_level > level ? TP_CMOS_VOLUME_UP : TP_CMOS_VOLUME_DOWN;
1808 inc = new_level > level ? 1 : -1;
1809
1810 if (mute && (!cmos_eval(cmos_cmd) ||
1811 !acpi_ec_write(volume_offset, level)))
1812 return -EIO;
1813
1814 for (i = level; i != new_level; i += inc)
1815 if (!cmos_eval(cmos_cmd) ||
1816 !acpi_ec_write(volume_offset, i + inc))
1817 return -EIO;
1818
1819 if (mute && (!cmos_eval(TP_CMOS_VOLUME_MUTE) ||
1820 !acpi_ec_write(volume_offset,
1821 new_level + mute)))
1822 return -EIO;
1823 }
1824
1825 if (new_mute != mute) { /* level doesn't change */
1826 cmos_cmd = new_mute ? TP_CMOS_VOLUME_MUTE : TP_CMOS_VOLUME_UP;
1827
1828 if (!cmos_eval(cmos_cmd) ||
1829 !acpi_ec_write(volume_offset, level + new_mute))
1830 return -EIO;
1831 }
1832 }
1833
1834 return 0;
1835 }
1836
1837
1838 /*************************************************************************
1839 * Fan subdriver
1840 */
1841
1842 /*
1843 * FAN ACCESS MODES
1844 *
1845 * IBMACPI_FAN_RD_ACPI_GFAN:
1846 * ACPI GFAN method: returns fan level
1847 *
1848 * see IBMACPI_FAN_WR_ACPI_SFAN
1849 * EC 0x2f not available if GFAN exists
1850 *
1851 * IBMACPI_FAN_WR_ACPI_SFAN:
1852 * ACPI SFAN method: sets fan level, 0 (stop) to 7 (max)
1853 *
1854 * EC 0x2f might be available *for reading*, but never for writing.
1855 *
1856 * IBMACPI_FAN_WR_TPEC:
1857 * ThinkPad EC register 0x2f (HFSP): fan control loop mode Supported
1858 * on almost all ThinkPads
1859 *
1860 * Fan speed changes of any sort (including those caused by the
1861 * disengaged mode) are usually done slowly by the firmware as the
1862 * maximum ammount of fan duty cycle change per second seems to be
1863 * limited.
1864 *
1865 * Reading is not available if GFAN exists.
1866 * Writing is not available if SFAN exists.
1867 *
1868 * Bits
1869 * 7 automatic mode engaged;
1870 * (default operation mode of the ThinkPad)
1871 * fan level is ignored in this mode.
1872 * 6 disengage mode (takes precedence over bit 7);
1873 * not available on all thinkpads. May disable
1874 * the tachometer, and speeds up fan to 100% duty-cycle,
1875 * which speeds it up far above the standard RPM
1876 * levels. It is not impossible that it could cause
1877 * hardware damage.
1878 * 5-3 unused in some models. Extra bits for fan level
1879 * in others, but still useless as all values above
1880 * 7 map to the same speed as level 7 in these models.
1881 * 2-0 fan level (0..7 usually)
1882 * 0x00 = stop
1883 * 0x07 = max (set when temperatures critical)
1884 * Some ThinkPads may have other levels, see
1885 * IBMACPI_FAN_WR_ACPI_FANS (X31/X40/X41)
1886 *
1887 * FIRMWARE BUG: on some models, EC 0x2f might not be initialized at
1888 * boot. Apparently the EC does not intialize it, so unless ACPI DSDT
1889 * does so, its initial value is meaningless (0x07).
1890 *
1891 * For firmware bugs, refer to:
1892 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
1893 *
1894 * ----
1895 *
1896 * ThinkPad EC register 0x84 (LSB), 0x85 (MSB):
1897 * Main fan tachometer reading (in RPM)
1898 *
1899 * This register is present on all ThinkPads with a new-style EC, and
1900 * it is known not to be present on the A21m/e, and T22, as there is
1901 * something else in offset 0x84 according to the ACPI DSDT. Other
1902 * ThinkPads from this same time period (and earlier) probably lack the
1903 * tachometer as well.
1904 *
1905 * Unfortunately a lot of ThinkPads with new-style ECs but whose firwmare
1906 * was never fixed by IBM to report the EC firmware version string
1907 * probably support the tachometer (like the early X models), so
1908 * detecting it is quite hard. We need more data to know for sure.
1909 *
1910 * FIRMWARE BUG: always read 0x84 first, otherwise incorrect readings
1911 * might result.
1912 *
1913 * FIRMWARE BUG: when EC 0x2f bit 6 is set (disengaged mode), this
1914 * register is not invalidated in ThinkPads that disable tachometer
1915 * readings. Thus, the tachometer readings go stale.
1916 *
1917 * For firmware bugs, refer to:
1918 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
1919 *
1920 * IBMACPI_FAN_WR_ACPI_FANS:
1921 * ThinkPad X31, X40, X41. Not available in the X60.
1922 *
1923 * FANS ACPI handle: takes three arguments: low speed, medium speed,
1924 * high speed. ACPI DSDT seems to map these three speeds to levels
1925 * as follows: STOP LOW LOW MED MED HIGH HIGH HIGH HIGH
1926 * (this map is stored on FAN0..FAN8 as "0,1,1,2,2,3,3,3,3")
1927 *
1928 * The speeds are stored on handles
1929 * (FANA:FAN9), (FANC:FANB), (FANE:FAND).
1930 *
1931 * There are three default speed sets, acessible as handles:
1932 * FS1L,FS1M,FS1H; FS2L,FS2M,FS2H; FS3L,FS3M,FS3H
1933 *
1934 * ACPI DSDT switches which set is in use depending on various
1935 * factors.
1936 *
1937 * IBMACPI_FAN_WR_TPEC is also available and should be used to
1938 * command the fan. The X31/X40/X41 seems to have 8 fan levels,
1939 * but the ACPI tables just mention level 7.
1940 */
1941
1942 static enum fan_status_access_mode fan_status_access_mode;
1943 static enum fan_control_access_mode fan_control_access_mode;
1944 static enum fan_control_commands fan_control_commands;
1945
1946 static int fan_control_status_known;
1947 static u8 fan_control_initial_status;
1948
1949 static void fan_watchdog_fire(struct work_struct *ignored);
1950 static int fan_watchdog_maxinterval;
1951 static DECLARE_DELAYED_WORK(fan_watchdog_task, fan_watchdog_fire);
1952
1953 IBM_HANDLE(fans, ec, "FANS"); /* X31, X40, X41 */
1954 IBM_HANDLE(gfan, ec, "GFAN", /* 570 */
1955 "\\FSPD", /* 600e/x, 770e, 770x */
1956 ); /* all others */
1957 IBM_HANDLE(sfan, ec, "SFAN", /* 570 */
1958 "JFNS", /* 770x-JL */
1959 ); /* all others */
1960
1961 static int fan_init(void)
1962 {
1963 fan_status_access_mode = IBMACPI_FAN_NONE;
1964 fan_control_access_mode = IBMACPI_FAN_WR_NONE;
1965 fan_control_commands = 0;
1966 fan_control_status_known = 1;
1967 fan_watchdog_maxinterval = 0;
1968
1969 if (gfan_handle) {
1970 /* 570, 600e/x, 770e, 770x */
1971 fan_status_access_mode = IBMACPI_FAN_RD_ACPI_GFAN;
1972 } else {
1973 /* all other ThinkPads: note that even old-style
1974 * ThinkPad ECs supports the fan control register */
1975 if (likely(acpi_ec_read(fan_status_offset,
1976 &fan_control_initial_status))) {
1977 fan_status_access_mode = IBMACPI_FAN_RD_TPEC;
1978
1979 /* In some ThinkPads, neither the EC nor the ACPI
1980 * DSDT initialize the fan status, and it ends up
1981 * being set to 0x07 when it *could* be either
1982 * 0x07 or 0x80.
1983 *
1984 * Enable for TP-1Y (T43), TP-78 (R51e),
1985 * TP-76 (R52), TP-70 (T43, R52), which are known
1986 * to be buggy. */
1987 if (fan_control_initial_status == 0x07 &&
1988 ibm_thinkpad_ec_found &&
1989 ((ibm_thinkpad_ec_found[0] == '1' &&
1990 ibm_thinkpad_ec_found[1] == 'Y') ||
1991 (ibm_thinkpad_ec_found[0] == '7' &&
1992 (ibm_thinkpad_ec_found[1] == '6' ||
1993 ibm_thinkpad_ec_found[1] == '8' ||
1994 ibm_thinkpad_ec_found[1] == '0'))
1995 )) {
1996 printk(IBM_NOTICE
1997 "fan_init: initial fan status is "
1998 "unknown, assuming it is in auto "
1999 "mode\n");
2000 fan_control_status_known = 0;
2001 }
2002 } else {
2003 printk(IBM_ERR
2004 "ThinkPad ACPI EC access misbehaving, "
2005 "fan status and control unavailable\n");
2006 return 0;
2007 }
2008 }
2009
2010 if (sfan_handle) {
2011 /* 570, 770x-JL */
2012 fan_control_access_mode = IBMACPI_FAN_WR_ACPI_SFAN;
2013 fan_control_commands |=
2014 IBMACPI_FAN_CMD_LEVEL | IBMACPI_FAN_CMD_ENABLE;
2015 } else {
2016 if (!gfan_handle) {
2017 /* gfan without sfan means no fan control */
2018 /* all other models implement TP EC 0x2f control */
2019
2020 if (fans_handle) {
2021 /* X31, X40, X41 */
2022 fan_control_access_mode =
2023 IBMACPI_FAN_WR_ACPI_FANS;
2024 fan_control_commands |=
2025 IBMACPI_FAN_CMD_SPEED |
2026 IBMACPI_FAN_CMD_LEVEL |
2027 IBMACPI_FAN_CMD_ENABLE;
2028 } else {
2029 fan_control_access_mode = IBMACPI_FAN_WR_TPEC;
2030 fan_control_commands |=
2031 IBMACPI_FAN_CMD_LEVEL |
2032 IBMACPI_FAN_CMD_ENABLE;
2033 }
2034 }
2035 }
2036
2037 return 0;
2038 }
2039
2040 static int fan_get_status(u8 *status)
2041 {
2042 u8 s;
2043
2044 /* TODO:
2045 * Add IBMACPI_FAN_RD_ACPI_FANS ? */
2046
2047 switch (fan_status_access_mode) {
2048 case IBMACPI_FAN_RD_ACPI_GFAN:
2049 /* 570, 600e/x, 770e, 770x */
2050
2051 if (unlikely(!acpi_evalf(gfan_handle, &s, NULL, "d")))
2052 return -EIO;
2053
2054 if (likely(status))
2055 *status = s & 0x07;
2056
2057 break;
2058
2059 case IBMACPI_FAN_RD_TPEC:
2060 /* all except 570, 600e/x, 770e, 770x */
2061 if (unlikely(!acpi_ec_read(fan_status_offset, &s)))
2062 return -EIO;
2063
2064 if (likely(status))
2065 *status = s;
2066
2067 break;
2068
2069 default:
2070 return -ENXIO;
2071 }
2072
2073 return 0;
2074 }
2075
2076 static void fan_exit(void)
2077 {
2078 cancel_delayed_work(&fan_watchdog_task);
2079 flush_scheduled_work();
2080 }
2081
2082 static int fan_get_speed(unsigned int *speed)
2083 {
2084 u8 hi, lo;
2085
2086 switch (fan_status_access_mode) {
2087 case IBMACPI_FAN_RD_TPEC:
2088 /* all except 570, 600e/x, 770e, 770x */
2089 if (unlikely(!acpi_ec_read(fan_rpm_offset, &lo) ||
2090 !acpi_ec_read(fan_rpm_offset + 1, &hi)))
2091 return -EIO;
2092
2093 if (likely(speed))
2094 *speed = (hi << 8) | lo;
2095
2096 break;
2097
2098 default:
2099 return -ENXIO;
2100 }
2101
2102 return 0;
2103 }
2104
2105 static void fan_watchdog_fire(struct work_struct *ignored)
2106 {
2107 printk(IBM_NOTICE "fan watchdog: enabling fan\n");
2108 if (fan_set_enable()) {
2109 printk(IBM_ERR "fan watchdog: error while enabling fan\n");
2110 /* reschedule for later */
2111 fan_watchdog_reset();
2112 }
2113 }
2114
2115 static void fan_watchdog_reset(void)
2116 {
2117 static int fan_watchdog_active = 0;
2118
2119 if (fan_watchdog_active)
2120 cancel_delayed_work(&fan_watchdog_task);
2121
2122 if (fan_watchdog_maxinterval > 0) {
2123 fan_watchdog_active = 1;
2124 if (!schedule_delayed_work(&fan_watchdog_task,
2125 msecs_to_jiffies(fan_watchdog_maxinterval
2126 * 1000))) {
2127 printk(IBM_ERR "failed to schedule the fan watchdog, "
2128 "watchdog will not trigger\n");
2129 }
2130 } else
2131 fan_watchdog_active = 0;
2132 }
2133
2134 static int fan_set_level(int level)
2135 {
2136 switch (fan_control_access_mode) {
2137 case IBMACPI_FAN_WR_ACPI_SFAN:
2138 if (level >= 0 && level <= 7) {
2139 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", level))
2140 return -EIO;
2141 } else
2142 return -EINVAL;
2143 break;
2144
2145 case IBMACPI_FAN_WR_ACPI_FANS:
2146 case IBMACPI_FAN_WR_TPEC:
2147 if ((level != IBMACPI_FAN_EC_AUTO) &&
2148 (level != IBMACPI_FAN_EC_DISENGAGED) &&
2149 ((level < 0) || (level > 7)))
2150 return -EINVAL;
2151
2152 if (!acpi_ec_write(fan_status_offset, level))
2153 return -EIO;
2154 else
2155 fan_control_status_known = 1;
2156 break;
2157
2158 default:
2159 return -ENXIO;
2160 }
2161 return 0;
2162 }
2163
2164 static int fan_set_enable(void)
2165 {
2166 u8 s;
2167 int rc;
2168
2169 switch (fan_control_access_mode) {
2170 case IBMACPI_FAN_WR_ACPI_FANS:
2171 case IBMACPI_FAN_WR_TPEC:
2172 if ((rc = fan_get_status(&s)) < 0)
2173 return rc;
2174
2175 /* Don't go out of emergency fan mode */
2176 if (s != 7)
2177 s = IBMACPI_FAN_EC_AUTO;
2178
2179 if (!acpi_ec_write(fan_status_offset, s))
2180 return -EIO;
2181 else
2182 fan_control_status_known = 1;
2183 break;
2184
2185 case IBMACPI_FAN_WR_ACPI_SFAN:
2186 if ((rc = fan_get_status(&s)) < 0)
2187 return rc;
2188
2189 s &= 0x07;
2190
2191 /* Set fan to at least level 4 */
2192 if (s < 4)
2193 s = 4;
2194
2195 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", s))
2196 return -EIO;
2197 break;
2198
2199 default:
2200 return -ENXIO;
2201 }
2202 return 0;
2203 }
2204
2205 static int fan_set_disable(void)
2206 {
2207 switch (fan_control_access_mode) {
2208 case IBMACPI_FAN_WR_ACPI_FANS:
2209 case IBMACPI_FAN_WR_TPEC:
2210 if (!acpi_ec_write(fan_status_offset, 0x00))
2211 return -EIO;
2212 else
2213 fan_control_status_known = 1;
2214 break;
2215
2216 case IBMACPI_FAN_WR_ACPI_SFAN:
2217 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", 0x00))
2218 return -EIO;
2219 break;
2220
2221 default:
2222 return -ENXIO;
2223 }
2224 return 0;
2225 }
2226
2227 static int fan_set_speed(int speed)
2228 {
2229 switch (fan_control_access_mode) {
2230 case IBMACPI_FAN_WR_ACPI_FANS:
2231 if (speed >= 0 && speed <= 65535) {
2232 if (!acpi_evalf(fans_handle, NULL, NULL, "vddd",
2233 speed, speed, speed))
2234 return -EIO;
2235 } else
2236 return -EINVAL;
2237 break;
2238
2239 default:
2240 return -ENXIO;
2241 }
2242 return 0;
2243 }
2244
2245 static int fan_read(char *p)
2246 {
2247 int len = 0;
2248 int rc;
2249 u8 status;
2250 unsigned int speed = 0;
2251
2252 switch (fan_status_access_mode) {
2253 case IBMACPI_FAN_RD_ACPI_GFAN:
2254 /* 570, 600e/x, 770e, 770x */
2255 if ((rc = fan_get_status(&status)) < 0)
2256 return rc;
2257
2258 len += sprintf(p + len, "status:\t\t%s\n"
2259 "level:\t\t%d\n",
2260 (status != 0) ? "enabled" : "disabled", status);
2261 break;
2262
2263 case IBMACPI_FAN_RD_TPEC:
2264 /* all except 570, 600e/x, 770e, 770x */
2265 if ((rc = fan_get_status(&status)) < 0)
2266 return rc;
2267
2268 if (unlikely(!fan_control_status_known)) {
2269 if (status != fan_control_initial_status)
2270 fan_control_status_known = 1;
2271 else
2272 /* Return most likely status. In fact, it
2273 * might be the only possible status */
2274 status = IBMACPI_FAN_EC_AUTO;
2275 }
2276
2277 len += sprintf(p + len, "status:\t\t%s\n",
2278 (status != 0) ? "enabled" : "disabled");
2279
2280 /* No ThinkPad boots on disengaged mode, we can safely
2281 * assume the tachometer is online if fan control status
2282 * was unknown */
2283 if ((rc = fan_get_speed(&speed)) < 0)
2284 return rc;
2285
2286 len += sprintf(p + len, "speed:\t\t%d\n", speed);
2287
2288 if (status & IBMACPI_FAN_EC_DISENGAGED)
2289 /* Disengaged mode takes precedence */
2290 len += sprintf(p + len, "level:\t\tdisengaged\n");
2291 else if (status & IBMACPI_FAN_EC_AUTO)
2292 len += sprintf(p + len, "level:\t\tauto\n");
2293 else
2294 len += sprintf(p + len, "level:\t\t%d\n", status);
2295 break;
2296
2297 case IBMACPI_FAN_NONE:
2298 default:
2299 len += sprintf(p + len, "status:\t\tnot supported\n");
2300 }
2301
2302 if (fan_control_commands & IBMACPI_FAN_CMD_LEVEL) {
2303 len += sprintf(p + len, "commands:\tlevel <level>");
2304
2305 switch (fan_control_access_mode) {
2306 case IBMACPI_FAN_WR_ACPI_SFAN:
2307 len += sprintf(p + len, " (<level> is 0-7)\n");
2308 break;
2309
2310 default:
2311 len += sprintf(p + len, " (<level> is 0-7, "
2312 "auto, disengaged)\n");
2313 break;
2314 }
2315 }
2316
2317 if (fan_control_commands & IBMACPI_FAN_CMD_ENABLE)
2318 len += sprintf(p + len, "commands:\tenable, disable\n"
2319 "commands:\twatchdog <timeout> (<timeout> is 0 (off), "
2320 "1-120 (seconds))\n");
2321
2322 if (fan_control_commands & IBMACPI_FAN_CMD_SPEED)
2323 len += sprintf(p + len, "commands:\tspeed <speed>"
2324 " (<speed> is 0-65535)\n");
2325
2326 return len;
2327 }
2328
2329 static int fan_write_cmd_level(const char *cmd, int *rc)
2330 {
2331 int level;
2332
2333 if (strlencmp(cmd, "level auto") == 0)
2334 level = IBMACPI_FAN_EC_AUTO;
2335 else if (strlencmp(cmd, "level disengaged") == 0)
2336 level = IBMACPI_FAN_EC_DISENGAGED;
2337 else if (sscanf(cmd, "level %d", &level) != 1)
2338 return 0;
2339
2340 if ((*rc = fan_set_level(level)) == -ENXIO)
2341 printk(IBM_ERR "level command accepted for unsupported "
2342 "access mode %d", fan_control_access_mode);
2343
2344 return 1;
2345 }
2346
2347 static int fan_write_cmd_enable(const char *cmd, int *rc)
2348 {
2349 if (strlencmp(cmd, "enable") != 0)
2350 return 0;
2351
2352 if ((*rc = fan_set_enable()) == -ENXIO)
2353 printk(IBM_ERR "enable command accepted for unsupported "
2354 "access mode %d", fan_control_access_mode);
2355
2356 return 1;
2357 }
2358
2359 static int fan_write_cmd_disable(const char *cmd, int *rc)
2360 {
2361 if (strlencmp(cmd, "disable") != 0)
2362 return 0;
2363
2364 if ((*rc = fan_set_disable()) == -ENXIO)
2365 printk(IBM_ERR "disable command accepted for unsupported "
2366 "access mode %d", fan_control_access_mode);
2367
2368 return 1;
2369 }
2370
2371 static int fan_write_cmd_speed(const char *cmd, int *rc)
2372 {
2373 int speed;
2374
2375 /* TODO:
2376 * Support speed <low> <medium> <high> ? */
2377
2378 if (sscanf(cmd, "speed %d", &speed) != 1)
2379 return 0;
2380
2381 if ((*rc = fan_set_speed(speed)) == -ENXIO)
2382 printk(IBM_ERR "speed command accepted for unsupported "
2383 "access mode %d", fan_control_access_mode);
2384
2385 return 1;
2386 }
2387
2388 static int fan_write_cmd_watchdog(const char *cmd, int *rc)
2389 {
2390 int interval;
2391
2392 if (sscanf(cmd, "watchdog %d", &interval) != 1)
2393 return 0;
2394
2395 if (interval < 0 || interval > 120)
2396 *rc = -EINVAL;
2397 else
2398 fan_watchdog_maxinterval = interval;
2399
2400 return 1;
2401 }
2402
2403 static int fan_write(char *buf)
2404 {
2405 char *cmd;
2406 int rc = 0;
2407
2408 while (!rc && (cmd = next_cmd(&buf))) {
2409 if (!((fan_control_commands & IBMACPI_FAN_CMD_LEVEL) &&
2410 fan_write_cmd_level(cmd, &rc)) &&
2411 !((fan_control_commands & IBMACPI_FAN_CMD_ENABLE) &&
2412 (fan_write_cmd_enable(cmd, &rc) ||
2413 fan_write_cmd_disable(cmd, &rc) ||
2414 fan_write_cmd_watchdog(cmd, &rc))) &&
2415 !((fan_control_commands & IBMACPI_FAN_CMD_SPEED) &&
2416 fan_write_cmd_speed(cmd, &rc))
2417 )
2418 rc = -EINVAL;
2419 else if (!rc)
2420 fan_watchdog_reset();
2421 }
2422
2423 return rc;
2424 }
2425
2426 /****************************************************************************
2427 ****************************************************************************
2428 *
2429 * Infrastructure
2430 *
2431 ****************************************************************************
2432 ****************************************************************************/
2433
2434 /* /proc support */
2435 static struct proc_dir_entry *proc_dir = NULL;
2436
2437 /* Subdriver registry */
2438 static struct ibm_struct ibms[] = {
2439 {
2440 .name = "driver",
2441 .init = ibm_acpi_driver_init,
2442 .read = ibm_acpi_driver_read,
2443 },
2444 {
2445 .name = "hotkey",
2446 .hid = IBM_HKEY_HID,
2447 .init = hotkey_init,
2448 .read = hotkey_read,
2449 .write = hotkey_write,
2450 .exit = hotkey_exit,
2451 .notify = hotkey_notify,
2452 .handle = &hkey_handle,
2453 .type = ACPI_DEVICE_NOTIFY,
2454 },
2455 {
2456 .name = "bluetooth",
2457 .init = bluetooth_init,
2458 .read = bluetooth_read,
2459 .write = bluetooth_write,
2460 },
2461 {
2462 .name = "wan",
2463 .init = wan_init,
2464 .read = wan_read,
2465 .write = wan_write,
2466 .experimental = 1,
2467 },
2468 {
2469 .name = "video",
2470 .init = video_init,
2471 .read = video_read,
2472 .write = video_write,
2473 .exit = video_exit,
2474 },
2475 {
2476 .name = "light",
2477 .init = light_init,
2478 .read = light_read,
2479 .write = light_write,
2480 },
2481 #ifdef CONFIG_THINKPAD_ACPI_DOCK
2482 {
2483 .name = "dock",
2484 .read = dock_read,
2485 .write = dock_write,
2486 .notify = dock_notify,
2487 .handle = &dock_handle,
2488 .type = ACPI_SYSTEM_NOTIFY,
2489 },
2490 {
2491 .name = "dock",
2492 .hid = IBM_PCI_HID,
2493 .notify = dock_notify,
2494 .handle = &pci_handle,
2495 .type = ACPI_SYSTEM_NOTIFY,
2496 },
2497 #endif
2498 #ifdef CONFIG_THINKPAD_ACPI_BAY
2499 {
2500 .name = "bay",
2501 .init = bay_init,
2502 .read = bay_read,
2503 .write = bay_write,
2504 .notify = bay_notify,
2505 .handle = &bay_handle,
2506 .type = ACPI_SYSTEM_NOTIFY,
2507 },
2508 #endif /* CONFIG_THINKPAD_ACPI_BAY */
2509 {
2510 .name = "cmos",
2511 .read = cmos_read,
2512 .write = cmos_write,
2513 },
2514 {
2515 .name = "led",
2516 .init = led_init,
2517 .read = led_read,
2518 .write = led_write,
2519 },
2520 {
2521 .name = "beep",
2522 .read = beep_read,
2523 .write = beep_write,
2524 },
2525 {
2526 .name = "thermal",
2527 .init = thermal_init,
2528 .read = thermal_read,
2529 },
2530 {
2531 .name = "ecdump",
2532 .read = ecdump_read,
2533 .write = ecdump_write,
2534 .experimental = 1,
2535 },
2536 {
2537 .name = "brightness",
2538 .read = brightness_read,
2539 .write = brightness_write,
2540 .init = brightness_init,
2541 .exit = brightness_exit,
2542 },
2543 {
2544 .name = "volume",
2545 .read = volume_read,
2546 .write = volume_write,
2547 },
2548 {
2549 .name = "fan",
2550 .read = fan_read,
2551 .write = fan_write,
2552 .init = fan_init,
2553 .exit = fan_exit,
2554 .experimental = 1,
2555 },
2556 };
2557
2558 /*
2559 * Module and infrastructure proble, init and exit handling
2560 */
2561
2562 static int __init ibm_init(struct ibm_struct *ibm)
2563 {
2564 int ret;
2565 struct proc_dir_entry *entry;
2566
2567 if (ibm->experimental && !experimental)
2568 return 0;
2569
2570 if (ibm->hid) {
2571 ret = register_ibmacpi_subdriver(ibm);
2572 if (ret < 0)
2573 return ret;
2574 ibm->driver_registered = 1;
2575 }
2576
2577 if (ibm->init) {
2578 ret = ibm->init();
2579 if (ret != 0)
2580 return ret;
2581 ibm->init_called = 1;
2582 }
2583
2584 if (ibm->read) {
2585 entry = create_proc_entry(ibm->name,
2586 S_IFREG | S_IRUGO | S_IWUSR,
2587 proc_dir);
2588 if (!entry) {
2589 printk(IBM_ERR "unable to create proc entry %s\n",
2590 ibm->name);
2591 return -ENODEV;
2592 }
2593 entry->owner = THIS_MODULE;
2594 entry->data = ibm;
2595 entry->read_proc = &dispatch_read;
2596 if (ibm->write)
2597 entry->write_proc = &dispatch_write;
2598 ibm->proc_created = 1;
2599 }
2600
2601 if (ibm->notify) {
2602 ret = setup_notify(ibm);
2603 if (ret == -ENODEV) {
2604 printk(IBM_NOTICE "disabling subdriver %s\n",
2605 ibm->name);
2606 ibm_exit(ibm);
2607 return 0;
2608 }
2609 if (ret < 0)
2610 return ret;
2611 }
2612
2613 return 0;
2614 }
2615
2616 static void ibm_exit(struct ibm_struct *ibm)
2617 {
2618 if (ibm->notify_installed)
2619 acpi_remove_notify_handler(*ibm->handle, ibm->type,
2620 dispatch_notify);
2621
2622 if (ibm->proc_created)
2623 remove_proc_entry(ibm->name, proc_dir);
2624
2625 if (ibm->init_called && ibm->exit)
2626 ibm->exit();
2627
2628 if (ibm->driver_registered) {
2629 acpi_bus_unregister_driver(ibm->driver);
2630 kfree(ibm->driver);
2631 }
2632 }
2633
2634 /* Probing */
2635
2636 static char *ibm_thinkpad_ec_found = NULL;
2637
2638 static char* __init check_dmi_for_ec(void)
2639 {
2640 struct dmi_device *dev = NULL;
2641 char ec_fw_string[18];
2642
2643 /*
2644 * ThinkPad T23 or newer, A31 or newer, R50e or newer,
2645 * X32 or newer, all Z series; Some models must have an
2646 * up-to-date BIOS or they will not be detected.
2647 *
2648 * See http://thinkwiki.org/wiki/List_of_DMI_IDs
2649 */
2650 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
2651 if (sscanf(dev->name,
2652 "IBM ThinkPad Embedded Controller -[%17c",
2653 ec_fw_string) == 1) {
2654 ec_fw_string[sizeof(ec_fw_string) - 1] = 0;
2655 ec_fw_string[strcspn(ec_fw_string, " ]")] = 0;
2656 return kstrdup(ec_fw_string, GFP_KERNEL);
2657 }
2658 }
2659 return NULL;
2660 }
2661
2662 /* Module init, exit, parameters */
2663
2664 static int __init set_ibm_param(const char *val, struct kernel_param *kp)
2665 {
2666 unsigned int i;
2667
2668 for (i = 0; i < ARRAY_SIZE(ibms); i++)
2669 if (strcmp(ibms[i].name, kp->name) == 0 && ibms[i].write) {
2670 if (strlen(val) > sizeof(ibms[i].param) - 2)
2671 return -ENOSPC;
2672 strcpy(ibms[i].param, val);
2673 strcat(ibms[i].param, ",");
2674 return 0;
2675 }
2676
2677 return -EINVAL;
2678 }
2679
2680 static int experimental;
2681 module_param(experimental, int, 0);
2682
2683 #define IBM_PARAM(feature) \
2684 module_param_call(feature, set_ibm_param, NULL, NULL, 0)
2685
2686 IBM_PARAM(hotkey);
2687 IBM_PARAM(bluetooth);
2688 IBM_PARAM(video);
2689 IBM_PARAM(light);
2690 #ifdef CONFIG_THINKPAD_ACPI_DOCK
2691 IBM_PARAM(dock);
2692 #endif
2693 #ifdef CONFIG_THINKPAD_ACPI_BAY
2694 IBM_PARAM(bay);
2695 #endif /* CONFIG_THINKPAD_ACPI_BAY */
2696 IBM_PARAM(cmos);
2697 IBM_PARAM(led);
2698 IBM_PARAM(beep);
2699 IBM_PARAM(ecdump);
2700 IBM_PARAM(brightness);
2701 IBM_PARAM(volume);
2702 IBM_PARAM(fan);
2703
2704 static int __init acpi_ibm_init(void)
2705 {
2706 int ret, i;
2707
2708 if (acpi_disabled)
2709 return -ENODEV;
2710
2711 if (!acpi_specific_hotkey_enabled) {
2712 printk(IBM_ERR "using generic hotkey driver\n");
2713 return -ENODEV;
2714 }
2715
2716 /* ec is required because many other handles are relative to it */
2717 IBM_HANDLE_INIT(ec);
2718 if (!ec_handle) {
2719 printk(IBM_ERR "ec object not found\n");
2720 return -ENODEV;
2721 }
2722
2723 /* Models with newer firmware report the EC in DMI */
2724 ibm_thinkpad_ec_found = check_dmi_for_ec();
2725
2726 /* these handles are not required */
2727 IBM_HANDLE_INIT(vid);
2728 IBM_HANDLE_INIT(vid2);
2729 IBM_HANDLE_INIT(ledb);
2730 IBM_HANDLE_INIT(led);
2731 IBM_HANDLE_INIT(hkey);
2732 IBM_HANDLE_INIT(lght);
2733 IBM_HANDLE_INIT(cmos);
2734 #ifdef CONFIG_THINKPAD_ACPI_DOCK
2735 IBM_HANDLE_INIT(dock);
2736 #endif
2737 IBM_HANDLE_INIT(pci);
2738 #ifdef CONFIG_THINKPAD_ACPI_BAY
2739 IBM_HANDLE_INIT(bay);
2740 if (bay_handle)
2741 IBM_HANDLE_INIT(bay_ej);
2742 IBM_HANDLE_INIT(bay2);
2743 if (bay2_handle)
2744 IBM_HANDLE_INIT(bay2_ej);
2745 #endif /* CONFIG_THINKPAD_ACPI_BAY */
2746 IBM_HANDLE_INIT(beep);
2747 IBM_HANDLE_INIT(ecrd);
2748 IBM_HANDLE_INIT(ecwr);
2749 IBM_HANDLE_INIT(fans);
2750 IBM_HANDLE_INIT(gfan);
2751 IBM_HANDLE_INIT(sfan);
2752
2753 proc_dir = proc_mkdir(IBM_DIR, acpi_root_dir);
2754 if (!proc_dir) {
2755 printk(IBM_ERR "unable to create proc dir %s", IBM_DIR);
2756 acpi_ibm_exit();
2757 return -ENODEV;
2758 }
2759 proc_dir->owner = THIS_MODULE;
2760
2761 for (i = 0; i < ARRAY_SIZE(ibms); i++) {
2762 ret = ibm_init(&ibms[i]);
2763 if (ret >= 0 && *ibms[i].param)
2764 ret = ibms[i].write(ibms[i].param);
2765 if (ret < 0) {
2766 acpi_ibm_exit();
2767 return ret;
2768 }
2769 }
2770
2771 return 0;
2772 }
2773
2774 static void acpi_ibm_exit(void)
2775 {
2776 int i;
2777
2778 for (i = ARRAY_SIZE(ibms) - 1; i >= 0; i--)
2779 ibm_exit(&ibms[i]);
2780
2781 if (proc_dir)
2782 remove_proc_entry(IBM_DIR, acpi_root_dir);
2783
2784 if (ibm_thinkpad_ec_found)
2785 kfree(ibm_thinkpad_ec_found);
2786 }
2787
2788 module_init(acpi_ibm_init);
2789 module_exit(acpi_ibm_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree