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
5 * Copyright (C) 2004-2005 Borislav Deianov <borislav@users.sf.net>
6 * Copyright (C) 2006-2007 Henrique de Moraes Holschuh <hmh@hmh.eng.br>
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.
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.
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.
24 #define IBM_VERSION "0.13"
27 * Changelog:
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.
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
82 #include "thinkpad_acpi.h"
84 MODULE_AUTHOR("Borislav Deianov, Henrique de Moraes Holschuh");
85 MODULE_DESCRIPTION(IBM_DESC);
86 MODULE_VERSION(IBM_VERSION);
87 MODULE_LICENSE("GPL");
89 #define __unused __attribute__ ((unused))
91 /****************************************************************************
92 ****************************************************************************
94 * ACPI Helpers and device model
96 ****************************************************************************
97 ****************************************************************************/
99 /*************************************************************************
100 * ACPI basic handles
103 static acpi_handle root_handle = NULL;
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 }
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 */
120 IBM_HANDLE(ecrd, ec, "ECRD"); /* 570 */
121 IBM_HANDLE(ecwr, ec, "ECWR"); /* 570 */
124 /*************************************************************************
125 * Misc ACPI handles
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 */
133 IBM_HANDLE(hkey, ec, "\\_SB.HKEY", /* 600e/x, 770e, 770x */
134 "^HKEY", /* R30, R31 */
135 "HKEY", /* all others */
136 ); /* 570 */
139 /*************************************************************************
140 * ACPI helpers
143 static int acpi_evalf(acpi_handle handle,
144 void *res, char *method, char *fmt, ...)
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;
157 if (!*fmt) {
158 printk(IBM_ERR "acpi_evalf() called with empty format\n");
159 return 0;
162 if (*fmt == 'q') {
163 quiet = 1;
164 fmt++;
165 } else
166 quiet = 0;
168 res_type = *(fmt++);
170 params.count = 0;
171 params.pointer = &in_objs[0];
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;
188 va_end(ap);
190 if (res_type != 'v') {
191 result.length = sizeof(out_obj);
192 result.pointer = &out_obj;
193 resultp = &result;
194 } else
195 resultp = NULL;
197 status = acpi_evaluate_object(handle, method, &params, resultp);
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;
215 if (!success && !quiet)
216 printk(IBM_ERR "acpi_evalf(%s, %s, ...) failed: %d\n",
217 method, fmt0, status);
219 return success;
222 static void __unused acpi_print_int(acpi_handle handle, char *method)
224 int i;
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);
232 static int acpi_ec_read(int i, u8 * p)
234 int v;
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;
245 return 1;
248 static int acpi_ec_write(int i, u8 v)
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;
258 return 1;
261 static int _sta(acpi_handle handle)
263 int status;
265 if (!handle || !acpi_evalf(handle, &status, "_STA", "d"))
266 status = 0;
268 return status;
271 /*************************************************************************
272 * ACPI device model
275 static void __init ibm_handle_init(char *name,
276 acpi_handle * handle, acpi_handle parent,
277 char **paths, int num_paths, char **path)
279 int i;
280 acpi_status status;
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;
290 *handle = NULL;
293 static void dispatch_notify(acpi_handle handle, u32 event, void *data)
295 struct ibm_struct *ibm = data;
297 if (!ibm || !ibm->notify)
298 return;
300 ibm->notify(ibm, event);
303 static int __init setup_notify(struct ibm_struct *ibm)
305 acpi_status status;
306 int ret;
308 if (!*ibm->handle)
309 return 0;
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;
317 acpi_driver_data(ibm->device) = ibm;
318 sprintf(acpi_device_class(ibm->device), "%s/%s", IBM_NAME, ibm->name);
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);
330 return -ENODEV;
332 ibm->notify_installed = 1;
333 return 0;
336 static int __init ibm_device_add(struct acpi_device *device)
338 return 0;
341 static int __init register_ibmacpi_subdriver(struct ibm_struct *ibm)
343 int ret;
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;
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;
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);
362 return ret;
366 /****************************************************************************
367 ****************************************************************************
369 * Procfs Helpers
371 ****************************************************************************
372 ****************************************************************************/
374 static int dispatch_read(char *page, char **start, off_t off, int count,
375 int *eof, void *data)
377 struct ibm_struct *ibm = data;
378 int len;
380 if (!ibm || !ibm->read)
381 return -EINVAL;
383 len = ibm->read(page);
384 if (len < 0)
385 return len;
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;
396 return len;
399 static int dispatch_write(struct file *file, const char __user * userbuf,
400 unsigned long count, void *data)
402 struct ibm_struct *ibm = data;
403 char *kernbuf;
404 int ret;
406 if (!ibm || !ibm->write)
407 return -EINVAL;
409 kernbuf = kmalloc(count + 2, GFP_KERNEL);
410 if (!kernbuf)
411 return -ENOMEM;
413 if (copy_from_user(kernbuf, userbuf, count)) {
414 kfree(kernbuf);
415 return -EFAULT;
418 kernbuf[count] = 0;
419 strcat(kernbuf, ",");
420 ret = ibm->write(kernbuf);
421 if (ret == 0)
422 ret = count;
424 kfree(kernbuf);
426 return ret;
429 static char *next_cmd(char **cmds)
431 char *start = *cmds;
432 char *end;
434 while ((end = strchr(start, ',')) && end == start)
435 start = end + 1;
437 if (!end)
438 return NULL;
440 *end = 0;
441 *cmds = end + 1;
442 return start;
446 /****************************************************************************
447 ****************************************************************************
449 * Subdrivers
451 ****************************************************************************
452 ****************************************************************************/
454 /*************************************************************************
455 * ibm-acpi init subdriver
458 static int ibm_acpi_driver_init(void)
460 printk(IBM_INFO "%s v%s\n", IBM_DESC, IBM_VERSION);
461 printk(IBM_INFO "%s\n", IBM_URL);
463 if (ibm_thinkpad_ec_found)
464 printk(IBM_INFO "ThinkPad EC firmware %s\n",
465 ibm_thinkpad_ec_found);
467 return 0;
470 static int ibm_acpi_driver_read(char *p)
472 int len = 0;
474 len += sprintf(p + len, "driver:\t\t%s\n", IBM_DESC);
475 len += sprintf(p + len, "version:\t%s\n", IBM_VERSION);
477 return len;
480 /*************************************************************************
481 * Hotkey subdriver
484 static int hotkey_supported;
485 static int hotkey_mask_supported;
486 static int hotkey_orig_status;
487 static int hotkey_orig_mask;
489 static int hotkey_init(void)
491 /* hotkey not supported on 570 */
492 hotkey_supported = hkey_handle != NULL;
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");
500 if (!hotkey_get(&hotkey_orig_status, &hotkey_orig_mask))
501 return -ENODEV;
504 return 0;
507 static void hotkey_exit(void)
509 if (hotkey_supported)
510 hotkey_set(hotkey_orig_status, hotkey_orig_mask);
513 static void hotkey_notify(struct ibm_struct *ibm, u32 event)
515 int hkey;
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);
525 static int hotkey_get(int *status, int *mask)
527 if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
528 return 0;
530 if (hotkey_mask_supported)
531 if (!acpi_evalf(hkey_handle, mask, "DHKN", "d"))
532 return 0;
534 return 1;
537 static int hotkey_set(int status, int mask)
539 int i;
541 if (!acpi_evalf(hkey_handle, NULL, "MHKC", "vd", status))
542 return 0;
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;
552 return 1;
555 static int hotkey_read(char *p)
557 int status, mask;
558 int len = 0;
560 if (!hotkey_supported) {
561 len += sprintf(p + len, "status:\t\tnot supported\n");
562 return len;
565 if (!hotkey_get(&status, &mask))
566 return -EIO;
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");
578 return len;
581 static int hotkey_write(char *buf)
583 int status, mask;
584 char *cmd;
585 int do_cmd = 0;
587 if (!hotkey_supported)
588 return -ENODEV;
590 if (!hotkey_get(&status, &mask))
591 return -EIO;
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;
610 if (do_cmd && !hotkey_set(status, mask))
611 return -EIO;
613 return 0;
616 /*************************************************************************
617 * Bluetooth subdriver
620 static int bluetooth_supported;
622 static int bluetooth_init(void)
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");
629 return 0;
632 static int bluetooth_status(void)
634 int status;
636 if (!bluetooth_supported ||
637 !acpi_evalf(hkey_handle, &status, "GBDC", "d"))
638 status = 0;
640 return status;
643 static int bluetooth_read(char *p)
645 int len = 0;
646 int status = bluetooth_status();
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");
657 return len;
660 static int bluetooth_write(char *buf)
662 int status = bluetooth_status();
663 char *cmd;
664 int do_cmd = 0;
666 if (!bluetooth_supported)
667 return -ENODEV;
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;
679 if (do_cmd && !acpi_evalf(hkey_handle, NULL, "SBDC", "vd", status))
680 return -EIO;
682 return 0;
685 /*************************************************************************
686 * Wan subdriver
689 static int wan_supported;
691 static int wan_init(void)
693 wan_supported = hkey_handle &&
694 acpi_evalf(hkey_handle, NULL, "GWAN", "qv");
696 return 0;
699 static int wan_status(void)
701 int status;
703 if (!wan_supported || !acpi_evalf(hkey_handle, &status, "GWAN", "d"))
704 status = 0;
706 return status;
709 static int wan_read(char *p)
711 int len = 0;
712 int status = wan_status();
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");
723 return len;
726 static int wan_write(char *buf)
728 int status = wan_status();
729 char *cmd;
730 int do_cmd = 0;
732 if (!wan_supported)
733 return -ENODEV;
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;
745 if (do_cmd && !acpi_evalf(hkey_handle, NULL, "SWAN", "vd", status))
746 return -EIO;
748 return 0;
751 /*************************************************************************
752 * Video subdriver
755 static enum video_access_mode video_supported;
756 static int video_orig_autosw;
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 */
765 IBM_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID"); /* G41 */
767 static int video_init(void)
769 int ivga;
771 if (vid2_handle && acpi_evalf(NULL, &ivga, "\\IVGA", "d") && ivga)
772 /* G41, assume IVGA doesn't change */
773 vid_handle = vid2_handle;
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;
788 return 0;
791 static void video_exit(void)
793 acpi_evalf(vid_handle, NULL, "_DOS", "vd", video_orig_autosw);
796 static int video_status(void)
798 int status = 0;
799 int i;
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;
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;
821 return status;
824 static int video_autosw(void)
826 int autosw = 0;
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");
834 return autosw & 1;
837 static int video_switch(void)
839 int autosw = video_autosw();
840 int ret;
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);
849 return ret;
852 static int video_expand(void)
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");
862 static int video_switch2(int status)
864 int ret;
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;
874 ret = acpi_evalf(vid_handle, NULL,
875 "ASWT", "vdd", status * 0x100, 0);
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);
883 return ret;
886 static int video_read(char *p)
888 int status = video_status();
889 int autosw = video_autosw();
890 int len = 0;
892 if (!video_supported) {
893 len += sprintf(p + len, "status:\t\tnot supported\n");
894 return len;
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");
910 return len;
913 static int video_write(char *buf)
915 char *cmd;
916 int enable, disable, status;
918 if (!video_supported)
919 return -ENODEV;
921 enable = disable = 0;
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;
954 if (enable || disable) {
955 status = (video_status() & 0x0f & ~disable) | enable;
956 if (!video_switch2(status))
957 return -EIO;
960 return 0;
963 /*************************************************************************
964 * Light (thinklight) subdriver
967 static int light_supported;
968 static int light_status_supported;
970 IBM_HANDLE(lght, root, "\\LGHT"); /* A21e, A2xm/p, T20-22, X20-21 */
971 IBM_HANDLE(ledb, ec, "LEDB"); /* G4x */
973 static int light_init(void)
975 /* light not supported on 570, 600e/x, 770e, 770x, G4x, R30, R31 */
976 light_supported = (cmos_handle || lght_handle) && !ledb_handle;
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");
984 return 0;
987 static int light_read(char *p)
989 int len = 0;
990 int status = 0;
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");
1004 return len;
1007 static int light_write(char *buf)
1009 int cmos_cmd, lght_cmd;
1010 char *cmd;
1011 int success;
1013 if (!light_supported)
1014 return -ENODEV;
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;
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;
1033 return 0;
1036 /*************************************************************************
1037 * Dock subdriver
1040 /* don't list other alternatives as we install a notify handler on the 570 */
1041 IBM_HANDLE(pci, root, "\\_SB.PCI"); /* 570 */
1043 #ifdef CONFIG_THINKPAD_ACPI_DOCK
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 */
1051 #define dock_docked() (_sta(dock_handle) & 1)
1053 static void dock_notify(struct ibm_struct *ibm, u32 event)
1055 int docked = dock_docked();
1056 int pci = ibm->hid && strstr(ibm->hid, IBM_PCI_HID);
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 */
1075 static int dock_read(char *p)
1077 int len = 0;
1078 int docked = dock_docked();
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");
1089 return len;
1092 static int dock_write(char *buf)
1094 char *cmd;
1096 if (!dock_docked())
1097 return -ENODEV;
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;
1111 return 0;
1114 #endif /* CONFIG_THINKPAD_ACPI_DOCK */
1116 /*************************************************************************
1117 * Bay subdriver
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;
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 */
1141 static int bay_init(void)
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");
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);
1153 return 0;
1156 static void bay_notify(struct ibm_struct *ibm, u32 event)
1158 acpi_bus_generate_event(ibm->device, event, 0);
1161 #define bay_occupied(b) (_sta(b##_handle) & 1)
1163 static int bay_read(char *p)
1165 int len = 0;
1166 int occupied = bay_occupied(bay);
1167 int occupied2 = bay_occupied(bay2);
1168 int eject, eject2;
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");
1177 eject = bay_eject_supported && occupied;
1178 eject2 = bay_eject2_supported && occupied2;
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");
1187 return len;
1190 static int bay_write(char *buf)
1192 char *cmd;
1194 if (!bay_eject_supported && !bay_eject2_supported)
1195 return -ENODEV;
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;
1209 return 0;
1211 #endif /* CONFIG_THINKPAD_ACPI_BAY */
1213 /*************************************************************************
1214 * CMOS subdriver
1217 static int cmos_eval(int cmos_cmd)
1219 if (cmos_handle)
1220 return acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd);
1221 else
1222 return 1;
1225 static int cmos_read(char *p)
1227 int len = 0;
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");
1238 return len;
1241 static int cmos_write(char *buf)
1243 char *cmd;
1244 int cmos_cmd;
1246 if (!cmos_handle)
1247 return -EINVAL;
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;
1256 if (!cmos_eval(cmos_cmd))
1257 return -EIO;
1260 return 0;
1264 /*************************************************************************
1265 * LED subdriver
1268 static enum led_access_mode led_supported;
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 */
1275 static int led_init(void)
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;
1290 return 0;
1293 #define led_status(s) ((s) == 0 ? "off" : ((s) == 1 ? "on" : "blinking"))
1295 static int led_read(char *p)
1297 int len = 0;
1299 if (!led_supported) {
1300 len += sprintf(p + len, "status:\t\tnot supported\n");
1301 return len;
1303 len += sprintf(p + len, "status:\t\tsupported\n");
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));
1317 len += sprintf(p + len, "commands:\t"
1318 "<led> on, <led> off, <led> blink (<led> is 0-7)\n");
1320 return len;
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 };
1329 static int led_write(char *buf)
1331 char *cmd;
1332 int led, ind, ret;
1334 if (!led_supported)
1335 return -ENODEV;
1337 while ((cmd = next_cmd(&buf))) {
1338 if (sscanf(cmd, "%d", &led) != 1 || led < 0 || led > 7)
1339 return -EINVAL;
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;
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;
1378 return 0;
1381 /*************************************************************************
1382 * Beep subdriver
1385 IBM_HANDLE(beep, ec, "BEEP"); /* all except R30, R31 */
1387 static int beep_read(char *p)
1389 int len = 0;
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");
1398 return len;
1401 static int beep_write(char *buf)
1403 char *cmd;
1404 int beep_cmd;
1406 if (!beep_handle)
1407 return -ENODEV;
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;
1419 return 0;
1422 /*************************************************************************
1423 * Thermal subdriver
1426 static enum thermal_access_mode thermal_read_mode;
1428 static int thermal_init(void)
1430 u8 t, ta1, ta2;
1431 int i;
1432 int acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
1434 if (ibm_thinkpad_ec_found && experimental) {
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
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;
1450 if (likely(acpi_ec_read(0xC0 + i, &t))) {
1451 ta2 |= t;
1452 } else {
1453 ta1 = 0;
1454 break;
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;
1470 } else {
1471 thermal_read_mode =
1472 (ta2 != 0) ?
1473 IBMACPI_THERMAL_TPEC_16 : IBMACPI_THERMAL_TPEC_8;
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;
1483 } else {
1484 /* temperatures not supported on 570, G4x, R30, R31, R32 */
1485 thermal_read_mode = IBMACPI_THERMAL_NONE;
1488 return 0;
1491 static int thermal_get_sensors(struct ibm_thermal_sensors_struct *s)
1493 int i, t;
1494 s8 tmp;
1495 char tmpi[] = "TMPi";
1497 if (!s)
1498 return -EINVAL;
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;
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;
1516 return (thermal_read_mode == IBMACPI_THERMAL_TPEC_16) ? 16 : 8;
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;
1527 return 8;
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;
1536 return 8;
1538 case IBMACPI_THERMAL_NONE:
1539 default:
1540 return 0;
1544 static int thermal_read(char *p)
1546 int len = 0;
1547 int n, i;
1548 struct ibm_thermal_sensors_struct t;
1550 n = thermal_get_sensors(&t);
1551 if (unlikely(n < 0))
1552 return n;
1554 len += sprintf(p + len, "temperatures:\t");
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");
1563 return len;
1566 /*************************************************************************
1567 * EC Dump subdriver
1570 static u8 ecdump_regs[256];
1572 static int ecdump_read(char *p)
1574 int len = 0;
1575 int i, j;
1576 u8 v;
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;
1592 len += sprintf(p + len, "\n");
1593 if (j != 16)
1594 break;
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;
1607 static int ecdump_write(char *buf)
1609 char *cmd;
1610 int i, v;
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;
1626 return 0;
1629 /*************************************************************************
1630 * Backlight/brightness subdriver
1633 static struct backlight_device *ibm_backlight_device = NULL;
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,
1642 static int brightness_init(void)
1644 int b;
1646 b = brightness_get(NULL);
1647 if (b < 0)
1648 return b;
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);
1657 ibm_backlight_device->props->brightness = b;
1658 brightness_update_status(ibm_backlight_device);
1660 return 0;
1663 static void brightness_exit(void)
1665 if (ibm_backlight_device) {
1666 backlight_device_unregister(ibm_backlight_device);
1667 ibm_backlight_device = NULL;
1671 static int brightness_update_status(struct backlight_device *bd)
1673 return brightness_set(
1674 (bd->props->fb_blank == FB_BLANK_UNBLANK &&
1675 bd->props->power == FB_BLANK_UNBLANK) ?
1676 bd->props->brightness : 0);
1679 static int brightness_get(struct backlight_device *bd)
1681 u8 level;
1682 if (!acpi_ec_read(brightness_offset, &level))
1683 return -EIO;
1685 level &= 0x7;
1687 return level;
1690 static int brightness_set(int value)
1692 int cmos_cmd, inc, i;
1693 int current_value = brightness_get(NULL);
1695 value &= 7;
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;
1706 return 0;
1709 static int brightness_read(char *p)
1711 int len = 0;
1712 int level;
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");
1723 return len;
1726 static int brightness_write(char *buf)
1728 int level;
1729 int new_level;
1730 char *cmd;
1732 while ((cmd = next_cmd(&buf))) {
1733 if ((level = brightness_get(NULL)) < 0)
1734 return level;
1735 level &= 7;
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;
1747 brightness_set(new_level);
1750 return 0;
1753 /*************************************************************************
1754 * Volume subdriver
1757 static int volume_read(char *p)
1759 int len = 0;
1760 u8 level;
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");
1772 return len;
1775 static int volume_write(char *buf)
1777 int cmos_cmd, inc, i;
1778 u8 level, mute;
1779 int new_level, new_mute;
1780 char *cmd;
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;
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;
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;
1810 if (mute && (!cmos_eval(cmos_cmd) ||
1811 !acpi_ec_write(volume_offset, level)))
1812 return -EIO;
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;
1819 if (mute && (!cmos_eval(TP_CMOS_VOLUME_MUTE) ||
1820 !acpi_ec_write(volume_offset,
1821 new_level + mute)))
1822 return -EIO;
1825 if (new_mute != mute) { /* level doesn't change */
1826 cmos_cmd = new_mute ? TP_CMOS_VOLUME_MUTE : TP_CMOS_VOLUME_UP;
1828 if (!cmos_eval(cmos_cmd) ||
1829 !acpi_ec_write(volume_offset, level + new_mute))
1830 return -EIO;
1834 return 0;
1838 /*************************************************************************
1839 * Fan subdriver
1843 * FAN ACCESS MODES
1845 * IBMACPI_FAN_RD_ACPI_GFAN:
1846 * ACPI GFAN method: returns fan level
1848 * see IBMACPI_FAN_WR_ACPI_SFAN
1849 * EC 0x2f not available if GFAN exists
1851 * IBMACPI_FAN_WR_ACPI_SFAN:
1852 * ACPI SFAN method: sets fan level, 0 (stop) to 7 (max)
1854 * EC 0x2f might be available *for reading*, but never for writing.
1856 * IBMACPI_FAN_WR_TPEC:
1857 * ThinkPad EC register 0x2f (HFSP): fan control loop mode Supported
1858 * on almost all ThinkPads
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.
1865 * Reading is not available if GFAN exists.
1866 * Writing is not available if SFAN exists.
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)
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).
1891 * For firmware bugs, refer to:
1892 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
1894 * ----
1896 * ThinkPad EC register 0x84 (LSB), 0x85 (MSB):
1897 * Main fan tachometer reading (in RPM)
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.
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.
1910 * FIRMWARE BUG: always read 0x84 first, otherwise incorrect readings
1911 * might result.
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.
1917 * For firmware bugs, refer to:
1918 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
1920 * IBMACPI_FAN_WR_ACPI_FANS:
1921 * ThinkPad X31, X40, X41. Not available in the X60.
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")
1928 * The speeds are stored on handles
1929 * (FANA:FAN9), (FANC:FANB), (FANE:FAND).
1931 * There are three default speed sets, acessible as handles:
1932 * FS1L,FS1M,FS1H; FS2L,FS2M,FS2H; FS3L,FS3M,FS3H
1934 * ACPI DSDT switches which set is in use depending on various
1935 * factors.
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.
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;
1946 static int fan_control_status_known;
1947 static u8 fan_control_initial_status;
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);
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 */
1961 static int fan_init(void)
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;
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;
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.
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;
2002 } else {
2003 printk(IBM_ERR
2004 "ThinkPad ACPI EC access misbehaving, "
2005 "fan status and control unavailable\n");
2006 return 0;
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 */
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;
2037 return 0;
2040 static int fan_get_status(u8 *status)
2042 u8 s;
2044 /* TODO:
2045 * Add IBMACPI_FAN_RD_ACPI_FANS ? */
2047 switch (fan_status_access_mode) {
2048 case IBMACPI_FAN_RD_ACPI_GFAN:
2049 /* 570, 600e/x, 770e, 770x */
2051 if (unlikely(!acpi_evalf(gfan_handle, &s, NULL, "d")))
2052 return -EIO;
2054 if (likely(status))
2055 *status = s & 0x07;
2057 break;
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;
2064 if (likely(status))
2065 *status = s;
2067 break;
2069 default:
2070 return -ENXIO;
2073 return 0;
2076 static void fan_exit(void)
2078 cancel_delayed_work(&fan_watchdog_task);
2079 flush_scheduled_work();
2082 static int fan_get_speed(unsigned int *speed)
2084 u8 hi, lo;
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;
2093 if (likely(speed))
2094 *speed = (hi << 8) | lo;
2096 break;
2098 default:
2099 return -ENXIO;
2102 return 0;
2105 static void fan_watchdog_fire(struct work_struct *ignored)
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();
2115 static void fan_watchdog_reset(void)
2117 static int fan_watchdog_active = 0;
2119 if (fan_watchdog_active)
2120 cancel_delayed_work(&fan_watchdog_task);
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");
2130 } else
2131 fan_watchdog_active = 0;
2134 static int fan_set_level(int level)
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;
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;
2152 if (!acpi_ec_write(fan_status_offset, level))
2153 return -EIO;
2154 else
2155 fan_control_status_known = 1;
2156 break;
2158 default:
2159 return -ENXIO;
2161 return 0;
2164 static int fan_set_enable(void)
2166 u8 s;
2167 int rc;
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;
2175 /* Don't go out of emergency fan mode */
2176 if (s != 7)
2177 s = IBMACPI_FAN_EC_AUTO;
2179 if (!acpi_ec_write(fan_status_offset, s))
2180 return -EIO;
2181 else
2182 fan_control_status_known = 1;
2183 break;
2185 case IBMACPI_FAN_WR_ACPI_SFAN:
2186 if ((rc = fan_get_status(&s)) < 0)
2187 return rc;
2189 s &= 0x07;
2191 /* Set fan to at least level 4 */
2192 if (s < 4)
2193 s = 4;
2195 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", s))
2196 return -EIO;
2197 break;
2199 default:
2200 return -ENXIO;
2202 return 0;
2205 static int fan_set_disable(void)
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;
2216 case IBMACPI_FAN_WR_ACPI_SFAN:
2217 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", 0x00))
2218 return -EIO;
2219 break;
2221 default:
2222 return -ENXIO;
2224 return 0;
2227 static int fan_set_speed(int speed)
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;
2239 default:
2240 return -ENXIO;
2242 return 0;
2245 static int fan_read(char *p)
2247 int len = 0;
2248 int rc;
2249 u8 status;
2250 unsigned int speed = 0;
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;
2258 len += sprintf(p + len, "status:\t\t%s\n"
2259 "level:\t\t%d\n",
2260 (status != 0) ? "enabled" : "disabled", status);
2261 break;
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;
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;
2277 len += sprintf(p + len, "status:\t\t%s\n",
2278 (status != 0) ? "enabled" : "disabled");
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;
2286 len += sprintf(p + len, "speed:\t\t%d\n", speed);
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;
2297 case IBMACPI_FAN_NONE:
2298 default:
2299 len += sprintf(p + len, "status:\t\tnot supported\n");
2302 if (fan_control_commands & IBMACPI_FAN_CMD_LEVEL) {
2303 len += sprintf(p + len, "commands:\tlevel <level>");
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;
2310 default:
2311 len += sprintf(p + len, " (<level> is 0-7, "
2312 "auto, disengaged)\n");
2313 break;
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");
2322 if (fan_control_commands & IBMACPI_FAN_CMD_SPEED)
2323 len += sprintf(p + len, "commands:\tspeed <speed>"
2324 " (<speed> is 0-65535)\n");
2326 return len;
2329 static int fan_write_cmd_level(const char *cmd, int *rc)
2331 int level;
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;
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);
2344 return 1;
2347 static int fan_write_cmd_enable(const char *cmd, int *rc)
2349 if (strlencmp(cmd, "enable") != 0)
2350 return 0;
2352 if ((*rc = fan_set_enable()) == -ENXIO)
2353 printk(IBM_ERR "enable command accepted for unsupported "
2354 "access mode %d", fan_control_access_mode);
2356 return 1;
2359 static int fan_write_cmd_disable(const char *cmd, int *rc)
2361 if (strlencmp(cmd, "disable") != 0)
2362 return 0;
2364 if ((*rc = fan_set_disable()) == -ENXIO)
2365 printk(IBM_ERR "disable command accepted for unsupported "
2366 "access mode %d", fan_control_access_mode);
2368 return 1;
2371 static int fan_write_cmd_speed(const char *cmd, int *rc)
2373 int speed;
2375 /* TODO:
2376 * Support speed <low> <medium> <high> ? */
2378 if (sscanf(cmd, "speed %d", &speed) != 1)
2379 return 0;
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);
2385 return 1;
2388 static int fan_write_cmd_watchdog(const char *cmd, int *rc)
2390 int interval;
2392 if (sscanf(cmd, "watchdog %d", &interval) != 1)
2393 return 0;
2395 if (interval < 0 || interval > 120)
2396 *rc = -EINVAL;
2397 else
2398 fan_watchdog_maxinterval = interval;
2400 return 1;
2403 static int fan_write(char *buf)
2405 char *cmd;
2406 int rc = 0;
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))
2418 rc = -EINVAL;
2419 else if (!rc)
2420 fan_watchdog_reset();
2423 return rc;
2426 /****************************************************************************
2427 ****************************************************************************
2429 * Infrastructure
2431 ****************************************************************************
2432 ****************************************************************************/
2434 /* /proc support */
2435 static struct proc_dir_entry *proc_dir = NULL;
2437 /* Subdriver registry */
2438 static struct ibm_struct ibms[] = {
2440 .name = "driver",
2441 .init = ibm_acpi_driver_init,
2442 .read = ibm_acpi_driver_read,
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,
2456 .name = "bluetooth",
2457 .init = bluetooth_init,
2458 .read = bluetooth_read,
2459 .write = bluetooth_write,
2462 .name = "wan",
2463 .init = wan_init,
2464 .read = wan_read,
2465 .write = wan_write,
2466 .experimental = 1,
2469 .name = "video",
2470 .init = video_init,
2471 .read = video_read,
2472 .write = video_write,
2473 .exit = video_exit,
2476 .name = "light",
2477 .init = light_init,
2478 .read = light_read,
2479 .write = light_write,
2481 #ifdef CONFIG_THINKPAD_ACPI_DOCK
2483 .name = "dock",
2484 .read = dock_read,
2485 .write = dock_write,
2486 .notify = dock_notify,
2487 .handle = &dock_handle,
2488 .type = ACPI_SYSTEM_NOTIFY,
2491 .name = "dock",
2492 .hid = IBM_PCI_HID,
2493 .notify = dock_notify,
2494 .handle = &pci_handle,
2495 .type = ACPI_SYSTEM_NOTIFY,
2497 #endif
2498 #ifdef CONFIG_THINKPAD_ACPI_BAY
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,
2508 #endif /* CONFIG_THINKPAD_ACPI_BAY */
2510 .name = "cmos",
2511 .read = cmos_read,
2512 .write = cmos_write,
2515 .name = "led",
2516 .init = led_init,
2517 .read = led_read,
2518 .write = led_write,
2521 .name = "beep",
2522 .read = beep_read,
2523 .write = beep_write,
2526 .name = "thermal",
2527 .init = thermal_init,
2528 .read = thermal_read,
2531 .name = "ecdump",
2532 .read = ecdump_read,
2533 .write = ecdump_write,
2534 .experimental = 1,
2537 .name = "brightness",
2538 .read = brightness_read,
2539 .write = brightness_write,
2540 .init = brightness_init,
2541 .exit = brightness_exit,
2544 .name = "volume",
2545 .read = volume_read,
2546 .write = volume_write,
2549 .name = "fan",
2550 .read = fan_read,
2551 .write = fan_write,
2552 .init = fan_init,
2553 .exit = fan_exit,
2554 .experimental = 1,
2559 * Module and infrastructure proble, init and exit handling
2562 static int __init ibm_init(struct ibm_struct *ibm)
2564 int ret;
2565 struct proc_dir_entry *entry;
2567 if (ibm->experimental && !experimental)
2568 return 0;
2570 if (ibm->hid) {
2571 ret = register_ibmacpi_subdriver(ibm);
2572 if (ret < 0)
2573 return ret;
2574 ibm->driver_registered = 1;
2577 if (ibm->init) {
2578 ret = ibm->init();
2579 if (ret != 0)
2580 return ret;
2581 ibm->init_called = 1;
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;
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;
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;
2609 if (ret < 0)
2610 return ret;
2613 return 0;
2616 static void ibm_exit(struct ibm_struct *ibm)
2618 if (ibm->notify_installed)
2619 acpi_remove_notify_handler(*ibm->handle, ibm->type,
2620 dispatch_notify);
2622 if (ibm->proc_created)
2623 remove_proc_entry(ibm->name, proc_dir);
2625 if (ibm->init_called && ibm->exit)
2626 ibm->exit();
2628 if (ibm->driver_registered) {
2629 acpi_bus_unregister_driver(ibm->driver);
2630 kfree(ibm->driver);
2634 /* Probing */
2636 static char *ibm_thinkpad_ec_found = NULL;
2638 static char* __init check_dmi_for_ec(void)
2640 struct dmi_device *dev = NULL;
2641 char ec_fw_string[18];
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.
2648 * See http://thinkwiki.org/wiki/List_of_DMI_IDs
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);
2659 return NULL;
2662 /* Module init, exit, parameters */
2664 static int __init set_ibm_param(const char *val, struct kernel_param *kp)
2666 unsigned int i;
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;
2677 return -EINVAL;
2680 static int experimental;
2681 module_param(experimental, int, 0);
2683 #define IBM_PARAM(feature) \
2684 module_param_call(feature, set_ibm_param, NULL, NULL, 0)
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);
2704 static int __init acpi_ibm_init(void)
2706 int ret, i;
2708 if (acpi_disabled)
2709 return -ENODEV;
2711 if (!acpi_specific_hotkey_enabled) {
2712 printk(IBM_ERR "using generic hotkey driver\n");
2713 return -ENODEV;
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;
2723 /* Models with newer firmware report the EC in DMI */
2724 ibm_thinkpad_ec_found = check_dmi_for_ec();
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);
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;
2759 proc_dir->owner = THIS_MODULE;
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;
2771 return 0;
2774 static void acpi_ibm_exit(void)
2776 int i;
2778 for (i = ARRAY_SIZE(ibms) - 1; i >= 0; i--)
2779 ibm_exit(&ibms[i]);
2781 if (proc_dir)
2782 remove_proc_entry(IBM_DIR, acpi_root_dir);
2784 if (ibm_thinkpad_ec_found)
2785 kfree(ibm_thinkpad_ec_found);
2788 module_init(acpi_ibm_init);
2789 module_exit(acpi_ibm_exit);