?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ACPI: thinkpad-acpi: register input device
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / misc / thinkpad_acpi.c
blob28a56e1ebae1119c30c0ee4944620b0ecebcbef3
1 /*
2 * thinkpad_acpi.c - 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.14"
25 #define TPACPI_SYSFS_VERSION 0x000200
26
27 /*
28 * Changelog:
29 * 2007-03-27 0.14 renamed to thinkpad_acpi and moved to
30 * drivers/misc.
31 *
32 * 2006-11-22 0.13 new maintainer
33 * changelog now lives in git commit history, and will
34 * not be updated further in-file.
35 *
36 * 2005-08-17 0.12 fix compilation on 2.6.13-rc kernels
37 * 2005-03-17 0.11 support for 600e, 770x
38 * thanks to Jamie Lentin <lentinj@dial.pipex.com>
39 * support for 770e, G41
40 * G40 and G41 don't have a thinklight
41 * temperatures no longer experimental
42 * experimental brightness control
43 * experimental volume control
44 * experimental fan enable/disable
45 * 2005-01-16 0.10 fix module loading on R30, R31
46 * 2005-01-16 0.9 support for 570, R30, R31
47 * ultrabay support on A22p, A3x
48 * limit arg for cmos, led, beep, drop experimental status
49 * more capable led control on A21e, A22p, T20-22, X20
50 * experimental temperatures and fan speed
51 * experimental embedded controller register dump
52 * mark more functions as __init, drop incorrect __exit
53 * use MODULE_VERSION
54 * thanks to Henrik Brix Andersen <brix@gentoo.org>
55 * fix parameter passing on module loading
56 * thanks to Rusty Russell <rusty@rustcorp.com.au>
57 * thanks to Jim Radford <radford@blackbean.org>
58 * 2004-11-08 0.8 fix init error case, don't return from a macro
59 * thanks to Chris Wright <chrisw@osdl.org>
60 * 2004-10-23 0.7 fix module loading on A21e, A22p, T20, T21, X20
61 * fix led control on A21e
62 * 2004-10-19 0.6 use acpi_bus_register_driver() to claim HKEY device
63 * 2004-10-18 0.5 thinklight support on A21e, G40, R32, T20, T21, X20
64 * proc file format changed
65 * video_switch command
66 * experimental cmos control
67 * experimental led control
68 * experimental acpi sounds
69 * 2004-09-16 0.4 support for module parameters
70 * hotkey mask can be prefixed by 0x
71 * video output switching
72 * video expansion control
73 * ultrabay eject support
74 * removed lcd brightness/on/off control, didn't work
75 * 2004-08-17 0.3 support for R40
76 * lcd off, brightness control
77 * thinklight on/off
78 * 2004-08-14 0.2 support for T series, X20
79 * bluetooth enable/disable
80 * hotkey events disabled by default
81 * removed fan control, currently useless
82 * 2004-08-09 0.1 initial release, support for X series
83 */
84
85 #include "thinkpad_acpi.h"
86
87 MODULE_AUTHOR("Borislav Deianov, Henrique de Moraes Holschuh");
88 MODULE_DESCRIPTION(IBM_DESC);
89 MODULE_VERSION(IBM_VERSION);
90 MODULE_LICENSE("GPL");
91
92 /* Please remove this in year 2009 */
93 MODULE_ALIAS("ibm_acpi");
94
95 /*
96 * DMI matching for module autoloading
97 *
98 * See http://thinkwiki.org/wiki/List_of_DMI_IDs
99 * See http://thinkwiki.org/wiki/BIOS_Upgrade_Downloads
100 *
101 * Only models listed in thinkwiki will be supported, so add yours
102 * if it is not there yet.
103 */
104 #define IBM_BIOS_MODULE_ALIAS(__type) \
105 MODULE_ALIAS("dmi:bvnIBM:bvr" __type "ET??WW")
106
107 /* Non-ancient thinkpads */
108 MODULE_ALIAS("dmi:bvnIBM:*:svnIBM:*:pvrThinkPad*:rvnIBM:*");
109 MODULE_ALIAS("dmi:bvnLENOVO:*:svnLENOVO:*:pvrThinkPad*:rvnLENOVO:*");
110
111 /* Ancient thinkpad BIOSes have to be identified by
112 * BIOS type or model number, and there are far less
113 * BIOS types than model numbers... */
114 IBM_BIOS_MODULE_ALIAS("I[B,D,H,I,M,N,O,T,W,V,Y,Z]");
115 IBM_BIOS_MODULE_ALIAS("1[0,3,6,8,A-G,I,K,M-P,S,T]");
116 IBM_BIOS_MODULE_ALIAS("K[U,X-Z]");
117
118 #define __unused __attribute__ ((unused))
119
120 /****************************************************************************
121 ****************************************************************************
122 *
123 * ACPI Helpers and device model
124 *
125 ****************************************************************************
126 ****************************************************************************/
127
128 /*************************************************************************
129 * ACPI basic handles
130 */
131
132 static acpi_handle root_handle;
133
134 #define IBM_HANDLE(object, parent, paths...) \
135 static acpi_handle object##_handle; \
136 static acpi_handle *object##_parent = &parent##_handle; \
137 static char *object##_path; \
138 static char *object##_paths[] = { paths }
139
140 IBM_HANDLE(ec, root, "\\_SB.PCI0.ISA.EC0", /* 240, 240x */
141 "\\_SB.PCI.ISA.EC", /* 570 */
142 "\\_SB.PCI0.ISA0.EC0", /* 600e/x, 770e, 770x */
143 "\\_SB.PCI0.ISA.EC", /* A21e, A2xm/p, T20-22, X20-21 */
144 "\\_SB.PCI0.AD4S.EC0", /* i1400, R30 */
145 "\\_SB.PCI0.ICH3.EC0", /* R31 */
146 "\\_SB.PCI0.LPC.EC", /* all others */
147 );
148
149 IBM_HANDLE(ecrd, ec, "ECRD"); /* 570 */
150 IBM_HANDLE(ecwr, ec, "ECWR"); /* 570 */
151
152
153 /*************************************************************************
154 * Misc ACPI handles
155 */
156
157 IBM_HANDLE(cmos, root, "\\UCMS", /* R50, R50e, R50p, R51, T4x, X31, X40 */
158 "\\CMOS", /* A3x, G4x, R32, T23, T30, X22-24, X30 */
159 "\\CMS", /* R40, R40e */
160 ); /* all others */
161
162 IBM_HANDLE(hkey, ec, "\\_SB.HKEY", /* 600e/x, 770e, 770x */
163 "^HKEY", /* R30, R31 */
164 "HKEY", /* all others */
165 ); /* 570 */
166
167
168 /*************************************************************************
169 * ACPI helpers
170 */
171
172 static int acpi_evalf(acpi_handle handle,
173 void *res, char *method, char *fmt, ...)
174 {
175 char *fmt0 = fmt;
176 struct acpi_object_list params;
177 union acpi_object in_objs[IBM_MAX_ACPI_ARGS];
178 struct acpi_buffer result, *resultp;
179 union acpi_object out_obj;
180 acpi_status status;
181 va_list ap;
182 char res_type;
183 int success;
184 int quiet;
185
186 if (!*fmt) {
187 printk(IBM_ERR "acpi_evalf() called with empty format\n");
188 return 0;
189 }
190
191 if (*fmt == 'q') {
192 quiet = 1;
193 fmt++;
194 } else
195 quiet = 0;
196
197 res_type = *(fmt++);
198
199 params.count = 0;
200 params.pointer = &in_objs[0];
201
202 va_start(ap, fmt);
203 while (*fmt) {
204 char c = *(fmt++);
205 switch (c) {
206 case 'd': /* int */
207 in_objs[params.count].integer.value = va_arg(ap, int);
208 in_objs[params.count++].type = ACPI_TYPE_INTEGER;
209 break;
210 /* add more types as needed */
211 default:
212 printk(IBM_ERR "acpi_evalf() called "
213 "with invalid format character '%c'\n", c);
214 return 0;
215 }
216 }
217 va_end(ap);
218
219 if (res_type != 'v') {
220 result.length = sizeof(out_obj);
221 result.pointer = &out_obj;
222 resultp = &result;
223 } else
224 resultp = NULL;
225
226 status = acpi_evaluate_object(handle, method, &params, resultp);
227
228 switch (res_type) {
229 case 'd': /* int */
230 if (res)
231 *(int *)res = out_obj.integer.value;
232 success = status == AE_OK && out_obj.type == ACPI_TYPE_INTEGER;
233 break;
234 case 'v': /* void */
235 success = status == AE_OK;
236 break;
237 /* add more types as needed */
238 default:
239 printk(IBM_ERR "acpi_evalf() called "
240 "with invalid format character '%c'\n", res_type);
241 return 0;
242 }
243
244 if (!success && !quiet)
245 printk(IBM_ERR "acpi_evalf(%s, %s, ...) failed: %d\n",
246 method, fmt0, status);
247
248 return success;
249 }
250
251 static void __unused acpi_print_int(acpi_handle handle, char *method)
252 {
253 int i;
254
255 if (acpi_evalf(handle, &i, method, "d"))
256 printk(IBM_INFO "%s = 0x%x\n", method, i);
257 else
258 printk(IBM_ERR "error calling %s\n", method);
259 }
260
261 static int acpi_ec_read(int i, u8 * p)
262 {
263 int v;
264
265 if (ecrd_handle) {
266 if (!acpi_evalf(ecrd_handle, &v, NULL, "dd", i))
267 return 0;
268 *p = v;
269 } else {
270 if (ec_read(i, p) < 0)
271 return 0;
272 }
273
274 return 1;
275 }
276
277 static int acpi_ec_write(int i, u8 v)
278 {
279 if (ecwr_handle) {
280 if (!acpi_evalf(ecwr_handle, NULL, NULL, "vdd", i, v))
281 return 0;
282 } else {
283 if (ec_write(i, v) < 0)
284 return 0;
285 }
286
287 return 1;
288 }
289
290 static int _sta(acpi_handle handle)
291 {
292 int status;
293
294 if (!handle || !acpi_evalf(handle, &status, "_STA", "d"))
295 status = 0;
296
297 return status;
298 }
299
300 static int issue_thinkpad_cmos_command(int cmos_cmd)
301 {
302 if (!cmos_handle)
303 return -ENXIO;
304
305 if (!acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd))
306 return -EIO;
307
308 return 0;
309 }
310
311 /*************************************************************************
312 * ACPI device model
313 */
314
315 static void drv_acpi_handle_init(char *name,
316 acpi_handle *handle, acpi_handle parent,
317 char **paths, int num_paths, char **path)
318 {
319 int i;
320 acpi_status status;
321
322 vdbg_printk(TPACPI_DBG_INIT, "trying to locate ACPI handle for %s\n",
323 name);
324
325 for (i = 0; i < num_paths; i++) {
326 status = acpi_get_handle(parent, paths[i], handle);
327 if (ACPI_SUCCESS(status)) {
328 *path = paths[i];
329 dbg_printk(TPACPI_DBG_INIT,
330 "Found ACPI handle %s for %s\n",
331 *path, name);
332 return;
333 }
334 }
335
336 vdbg_printk(TPACPI_DBG_INIT, "ACPI handle for %s not found\n",
337 name);
338 *handle = NULL;
339 }
340
341 static void dispatch_acpi_notify(acpi_handle handle, u32 event, void *data)
342 {
343 struct ibm_struct *ibm = data;
344
345 if (!ibm || !ibm->acpi || !ibm->acpi->notify)
346 return;
347
348 ibm->acpi->notify(ibm, event);
349 }
350
351 static int __init setup_acpi_notify(struct ibm_struct *ibm)
352 {
353 acpi_status status;
354 int rc;
355
356 BUG_ON(!ibm->acpi);
357
358 if (!*ibm->acpi->handle)
359 return 0;
360
361 vdbg_printk(TPACPI_DBG_INIT,
362 "setting up ACPI notify for %s\n", ibm->name);
363
364 rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
365 if (rc < 0) {
366 printk(IBM_ERR "acpi_bus_get_device(%s) failed: %d\n",
367 ibm->name, rc);
368 return -ENODEV;
369 }
370
371 acpi_driver_data(ibm->acpi->device) = ibm;
372 sprintf(acpi_device_class(ibm->acpi->device), "%s/%s",
373 IBM_ACPI_EVENT_PREFIX,
374 ibm->name);
375
376 status = acpi_install_notify_handler(*ibm->acpi->handle,
377 ibm->acpi->type, dispatch_acpi_notify, ibm);
378 if (ACPI_FAILURE(status)) {
379 if (status == AE_ALREADY_EXISTS) {
380 printk(IBM_NOTICE "another device driver is already handling %s events\n",
381 ibm->name);
382 } else {
383 printk(IBM_ERR "acpi_install_notify_handler(%s) failed: %d\n",
384 ibm->name, status);
385 }
386 return -ENODEV;
387 }
388 ibm->flags.acpi_notify_installed = 1;
389 return 0;
390 }
391
392 static int __init tpacpi_device_add(struct acpi_device *device)
393 {
394 return 0;
395 }
396
397 static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
398 {
399 int rc;
400
401 dbg_printk(TPACPI_DBG_INIT,
402 "registering %s as an ACPI driver\n", ibm->name);
403
404 BUG_ON(!ibm->acpi);
405
406 ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
407 if (!ibm->acpi->driver) {
408 printk(IBM_ERR "kzalloc(ibm->driver) failed\n");
409 return -ENOMEM;
410 }
411
412 sprintf(ibm->acpi->driver->name, "%s_%s", IBM_NAME, ibm->name);
413 ibm->acpi->driver->ids = ibm->acpi->hid;
414 ibm->acpi->driver->ops.add = &tpacpi_device_add;
415
416 rc = acpi_bus_register_driver(ibm->acpi->driver);
417 if (rc < 0) {
418 printk(IBM_ERR "acpi_bus_register_driver(%s) failed: %d\n",
419 ibm->acpi->hid, rc);
420 kfree(ibm->acpi->driver);
421 ibm->acpi->driver = NULL;
422 } else if (!rc)
423 ibm->flags.acpi_driver_registered = 1;
424
425 return rc;
426 }
427
428
429 /****************************************************************************
430 ****************************************************************************
431 *
432 * Procfs Helpers
433 *
434 ****************************************************************************
435 ****************************************************************************/
436
437 static int dispatch_procfs_read(char *page, char **start, off_t off,
438 int count, int *eof, void *data)
439 {
440 struct ibm_struct *ibm = data;
441 int len;
442
443 if (!ibm || !ibm->read)
444 return -EINVAL;
445
446 len = ibm->read(page);
447 if (len < 0)
448 return len;
449
450 if (len <= off + count)
451 *eof = 1;
452 *start = page + off;
453 len -= off;
454 if (len > count)
455 len = count;
456 if (len < 0)
457 len = 0;
458
459 return len;
460 }
461
462 static int dispatch_procfs_write(struct file *file,
463 const char __user * userbuf,
464 unsigned long count, void *data)
465 {
466 struct ibm_struct *ibm = data;
467 char *kernbuf;
468 int ret;
469
470 if (!ibm || !ibm->write)
471 return -EINVAL;
472
473 kernbuf = kmalloc(count + 2, GFP_KERNEL);
474 if (!kernbuf)
475 return -ENOMEM;
476
477 if (copy_from_user(kernbuf, userbuf, count)) {
478 kfree(kernbuf);
479 return -EFAULT;
480 }
481
482 kernbuf[count] = 0;
483 strcat(kernbuf, ",");
484 ret = ibm->write(kernbuf);
485 if (ret == 0)
486 ret = count;
487
488 kfree(kernbuf);
489
490 return ret;
491 }
492
493 static char *next_cmd(char **cmds)
494 {
495 char *start = *cmds;
496 char *end;
497
498 while ((end = strchr(start, ',')) && end == start)
499 start = end + 1;
500
501 if (!end)
502 return NULL;
503
504 *end = 0;
505 *cmds = end + 1;
506 return start;
507 }
508
509
510 /****************************************************************************
511 ****************************************************************************
512 *
513 * Device model: input, hwmon and platform
514 *
515 ****************************************************************************
516 ****************************************************************************/
517
518 static struct platform_device *tpacpi_pdev;
519 static struct class_device *tpacpi_hwmon;
520 static struct input_dev *tpacpi_inputdev;
521
522 static struct platform_driver tpacpi_pdriver = {
523 .driver = {
524 .name = IBM_DRVR_NAME,
525 .owner = THIS_MODULE,
526 },
527 };
528
529
530 /*************************************************************************
531 * thinkpad-acpi driver attributes
532 */
533
534 /* interface_version --------------------------------------------------- */
535 static ssize_t tpacpi_driver_interface_version_show(
536 struct device_driver *drv,
537 char *buf)
538 {
539 return snprintf(buf, PAGE_SIZE, "0x%08x\n", TPACPI_SYSFS_VERSION);
540 }
541
542 static DRIVER_ATTR(interface_version, S_IRUGO,
543 tpacpi_driver_interface_version_show, NULL);
544
545 /* debug_level --------------------------------------------------------- */
546 static ssize_t tpacpi_driver_debug_show(struct device_driver *drv,
547 char *buf)
548 {
549 return snprintf(buf, PAGE_SIZE, "0x%04x\n", dbg_level);
550 }
551
552 static ssize_t tpacpi_driver_debug_store(struct device_driver *drv,
553 const char *buf, size_t count)
554 {
555 unsigned long t;
556
557 if (parse_strtoul(buf, 0xffff, &t))
558 return -EINVAL;
559
560 dbg_level = t;
561
562 return count;
563 }
564
565 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
566 tpacpi_driver_debug_show, tpacpi_driver_debug_store);
567
568 /* version ------------------------------------------------------------- */
569 static ssize_t tpacpi_driver_version_show(struct device_driver *drv,
570 char *buf)
571 {
572 return snprintf(buf, PAGE_SIZE, "%s v%s\n", IBM_DESC, IBM_VERSION);
573 }
574
575 static DRIVER_ATTR(version, S_IRUGO,
576 tpacpi_driver_version_show, NULL);
577
578 /* --------------------------------------------------------------------- */
579
580 static struct driver_attribute* tpacpi_driver_attributes[] = {
581 &driver_attr_debug_level, &driver_attr_version,
582 &driver_attr_interface_version,
583 };
584
585 static int __init tpacpi_create_driver_attributes(struct device_driver *drv)
586 {
587 int i, res;
588
589 i = 0;
590 res = 0;
591 while (!res && i < ARRAY_SIZE(tpacpi_driver_attributes)) {
592 res = driver_create_file(drv, tpacpi_driver_attributes[i]);
593 i++;
594 }
595
596 return res;
597 }
598
599 static void tpacpi_remove_driver_attributes(struct device_driver *drv)
600 {
601 int i;
602
603 for(i = 0; i < ARRAY_SIZE(tpacpi_driver_attributes); i++)
604 driver_remove_file(drv, tpacpi_driver_attributes[i]);
605 }
606
607 /*************************************************************************
608 * sysfs support helpers
609 */
610
611 struct attribute_set_obj {
612 struct attribute_set s;
613 struct attribute *a;
614 } __attribute__((packed));
615
616 static struct attribute_set *create_attr_set(unsigned int max_members,
617 const char* name)
618 {
619 struct attribute_set_obj *sobj;
620
621 if (max_members == 0)
622 return NULL;
623
624 /* Allocates space for implicit NULL at the end too */
625 sobj = kzalloc(sizeof(struct attribute_set_obj) +
626 max_members * sizeof(struct attribute *),
627 GFP_KERNEL);
628 if (!sobj)
629 return NULL;
630 sobj->s.max_members = max_members;
631 sobj->s.group.attrs = &sobj->a;
632 sobj->s.group.name = name;
633
634 return &sobj->s;
635 }
636
637 /* not multi-threaded safe, use it in a single thread per set */
638 static int add_to_attr_set(struct attribute_set* s, struct attribute *attr)
639 {
640 if (!s || !attr)
641 return -EINVAL;
642
643 if (s->members >= s->max_members)
644 return -ENOMEM;
645
646 s->group.attrs[s->members] = attr;
647 s->members++;
648
649 return 0;
650 }
651
652 static int add_many_to_attr_set(struct attribute_set* s,
653 struct attribute **attr,
654 unsigned int count)
655 {
656 int i, res;
657
658 for (i = 0; i < count; i++) {
659 res = add_to_attr_set(s, attr[i]);
660 if (res)
661 return res;
662 }
663
664 return 0;
665 }
666
667 static void delete_attr_set(struct attribute_set* s, struct kobject *kobj)
668 {
669 sysfs_remove_group(kobj, &s->group);
670 destroy_attr_set(s);
671 }
672
673 static int parse_strtoul(const char *buf,
674 unsigned long max, unsigned long *value)
675 {
676 char *endp;
677
678 *value = simple_strtoul(buf, &endp, 0);
679 while (*endp && isspace(*endp))
680 endp++;
681 if (*endp || *value > max)
682 return -EINVAL;
683
684 return 0;
685 }
686
687 /****************************************************************************
688 ****************************************************************************
689 *
690 * Subdrivers
691 *
692 ****************************************************************************
693 ****************************************************************************/
694
695 /*************************************************************************
696 * thinkpad-acpi init subdriver
697 */
698
699 static int __init thinkpad_acpi_driver_init(struct ibm_init_struct *iibm)
700 {
701 printk(IBM_INFO "%s v%s\n", IBM_DESC, IBM_VERSION);
702 printk(IBM_INFO "%s\n", IBM_URL);
703
704 if (ibm_thinkpad_ec_found)
705 printk(IBM_INFO "ThinkPad EC firmware %s\n",
706 ibm_thinkpad_ec_found);
707
708 return 0;
709 }
710
711 static int thinkpad_acpi_driver_read(char *p)
712 {
713 int len = 0;
714
715 len += sprintf(p + len, "driver:\t\t%s\n", IBM_DESC);
716 len += sprintf(p + len, "version:\t%s\n", IBM_VERSION);
717
718 return len;
719 }
720
721 static struct ibm_struct thinkpad_acpi_driver_data = {
722 .name = "driver",
723 .read = thinkpad_acpi_driver_read,
724 };
725
726 /*************************************************************************
727 * Hotkey subdriver
728 */
729
730 static int hotkey_orig_status;
731 static u32 hotkey_orig_mask;
732 static u32 hotkey_all_mask;
733 static u32 hotkey_reserved_mask = 0x00778000;
734
735 static struct attribute_set *hotkey_dev_attributes;
736
737 static int hotkey_get_wlsw(int *status)
738 {
739 if (!acpi_evalf(hkey_handle, status, "WLSW", "d"))
740 return -EIO;
741 return 0;
742 }
743
744 /* sysfs hotkey enable ------------------------------------------------- */
745 static ssize_t hotkey_enable_show(struct device *dev,
746 struct device_attribute *attr,
747 char *buf)
748 {
749 int res, status;
750 u32 mask;
751
752 res = hotkey_get(&status, &mask);
753 if (res)
754 return res;
755
756 return snprintf(buf, PAGE_SIZE, "%d\n", status);
757 }
758
759 static ssize_t hotkey_enable_store(struct device *dev,
760 struct device_attribute *attr,
761 const char *buf, size_t count)
762 {
763 unsigned long t;
764 int res, status;
765 u32 mask;
766
767 if (parse_strtoul(buf, 1, &t))
768 return -EINVAL;
769
770 res = hotkey_get(&status, &mask);
771 if (!res)
772 res = hotkey_set(t, mask);
773
774 return (res) ? res : count;
775 }
776
777 static struct device_attribute dev_attr_hotkey_enable =
778 __ATTR(hotkey_enable, S_IWUSR | S_IRUGO,
779 hotkey_enable_show, hotkey_enable_store);
780
781 /* sysfs hotkey mask --------------------------------------------------- */
782 static ssize_t hotkey_mask_show(struct device *dev,
783 struct device_attribute *attr,
784 char *buf)
785 {
786 int res, status;
787 u32 mask;
788
789 res = hotkey_get(&status, &mask);
790 if (res)
791 return res;
792
793 return snprintf(buf, PAGE_SIZE, "0x%08x\n", mask);
794 }
795
796 static ssize_t hotkey_mask_store(struct device *dev,
797 struct device_attribute *attr,
798 const char *buf, size_t count)
799 {
800 unsigned long t;
801 int res, status;
802 u32 mask;
803
804 if (parse_strtoul(buf, 0xffffffffUL, &t))
805 return -EINVAL;
806
807 res = hotkey_get(&status, &mask);
808 if (!res)
809 hotkey_set(status, t);
810
811 return (res) ? res : count;
812 }
813
814 static struct device_attribute dev_attr_hotkey_mask =
815 __ATTR(hotkey_mask, S_IWUSR | S_IRUGO,
816 hotkey_mask_show, hotkey_mask_store);
817
818 /* sysfs hotkey bios_enabled ------------------------------------------- */
819 static ssize_t hotkey_bios_enabled_show(struct device *dev,
820 struct device_attribute *attr,
821 char *buf)
822 {
823 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_orig_status);
824 }
825
826 static struct device_attribute dev_attr_hotkey_bios_enabled =
827 __ATTR(hotkey_bios_enabled, S_IRUGO, hotkey_bios_enabled_show, NULL);
828
829 /* sysfs hotkey bios_mask ---------------------------------------------- */
830 static ssize_t hotkey_bios_mask_show(struct device *dev,
831 struct device_attribute *attr,
832 char *buf)
833 {
834 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_orig_mask);
835 }
836
837 static struct device_attribute dev_attr_hotkey_bios_mask =
838 __ATTR(hotkey_bios_mask, S_IRUGO, hotkey_bios_mask_show, NULL);
839
840 /* sysfs hotkey all_mask ----------------------------------------------- */
841 static ssize_t hotkey_all_mask_show(struct device *dev,
842 struct device_attribute *attr,
843 char *buf)
844 {
845 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_all_mask);
846 }
847
848 static struct device_attribute dev_attr_hotkey_all_mask =
849 __ATTR(hotkey_all_mask, S_IRUGO, hotkey_all_mask_show, NULL);
850
851 /* sysfs hotkey recommended_mask --------------------------------------- */
852 static ssize_t hotkey_recommended_mask_show(struct device *dev,
853 struct device_attribute *attr,
854 char *buf)
855 {
856 return snprintf(buf, PAGE_SIZE, "0x%08x\n",
857 hotkey_all_mask & ~hotkey_reserved_mask);
858 }
859
860 static struct device_attribute dev_attr_hotkey_recommended_mask =
861 __ATTR(hotkey_recommended_mask, S_IRUGO,
862 hotkey_recommended_mask_show, NULL);
863
864 /* sysfs hotkey radio_sw ----------------------------------------------- */
865 static ssize_t hotkey_radio_sw_show(struct device *dev,
866 struct device_attribute *attr,
867 char *buf)
868 {
869 int res, s;
870 res = hotkey_get_wlsw(&s);
871 if (res < 0)
872 return res;
873
874 return snprintf(buf, PAGE_SIZE, "%d\n", !!s);
875 }
876
877 static struct device_attribute dev_attr_hotkey_radio_sw =
878 __ATTR(hotkey_radio_sw, S_IRUGO, hotkey_radio_sw_show, NULL);
879
880 /* --------------------------------------------------------------------- */
881
882 static struct attribute *hotkey_mask_attributes[] = {
883 &dev_attr_hotkey_mask.attr,
884 &dev_attr_hotkey_bios_enabled.attr,
885 &dev_attr_hotkey_bios_mask.attr,
886 &dev_attr_hotkey_all_mask.attr,
887 &dev_attr_hotkey_recommended_mask.attr,
888 };
889
890 static int __init hotkey_init(struct ibm_init_struct *iibm)
891 {
892 int res;
893 int status;
894
895 vdbg_printk(TPACPI_DBG_INIT, "initializing hotkey subdriver\n");
896
897 IBM_ACPIHANDLE_INIT(hkey);
898 mutex_init(&hotkey_mutex);
899
900 /* hotkey not supported on 570 */
901 tp_features.hotkey = hkey_handle != NULL;
902
903 vdbg_printk(TPACPI_DBG_INIT, "hotkeys are %s\n",
904 str_supported(tp_features.hotkey));
905
906 if (tp_features.hotkey) {
907 hotkey_dev_attributes = create_attr_set(7, NULL);
908 if (!hotkey_dev_attributes)
909 return -ENOMEM;
910 res = add_to_attr_set(hotkey_dev_attributes,
911 &dev_attr_hotkey_enable.attr);
912 if (res)
913 return res;
914
915 /* mask not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
916 A30, R30, R31, T20-22, X20-21, X22-24 */
917 tp_features.hotkey_mask =
918 acpi_evalf(hkey_handle, NULL, "DHKN", "qv");
919
920 vdbg_printk(TPACPI_DBG_INIT, "hotkey masks are %s\n",
921 str_supported(tp_features.hotkey_mask));
922
923 if (tp_features.hotkey_mask) {
924 /* MHKA available in A31, R40, R40e, T4x, X31, and later */
925 if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
926 "MHKA", "qd"))
927 hotkey_all_mask = 0x080cU; /* FN+F12, FN+F4, FN+F3 */
928 }
929
930 res = hotkey_get(&hotkey_orig_status, &hotkey_orig_mask);
931 if (!res && tp_features.hotkey_mask) {
932 res = add_many_to_attr_set(hotkey_dev_attributes,
933 hotkey_mask_attributes,
934 ARRAY_SIZE(hotkey_mask_attributes));
935 }
936
937 /* Not all thinkpads have a hardware radio switch */
938 if (!res && acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
939 tp_features.hotkey_wlsw = 1;
940 printk(IBM_INFO
941 "radio switch found; radios are %s\n",
942 enabled(status, 0));
943 res = add_to_attr_set(hotkey_dev_attributes,
944 &dev_attr_hotkey_radio_sw.attr);
945 }
946
947 if (!res)
948 res = register_attr_set_with_sysfs(
949 hotkey_dev_attributes,
950 &tpacpi_pdev->dev.kobj);
951 if (res)
952 return res;
953 }
954
955 return (tp_features.hotkey)? 0 : 1;
956 }
957
958 static void hotkey_exit(void)
959 {
960 int res;
961
962 if (tp_features.hotkey) {
963 dbg_printk(TPACPI_DBG_EXIT, "restoring original hotkey mask\n");
964 res = hotkey_set(hotkey_orig_status, hotkey_orig_mask);
965 if (res)
966 printk(IBM_ERR "failed to restore hotkey to BIOS defaults\n");
967 }
968
969 if (hotkey_dev_attributes) {
970 delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
971 hotkey_dev_attributes = NULL;
972 }
973 }
974
975 static void hotkey_notify(struct ibm_struct *ibm, u32 event)
976 {
977 int hkey;
978
979 if (event == 0x80 && acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
980 acpi_bus_generate_event(ibm->acpi->device, event, hkey);
981 } else {
982 printk(IBM_ERR "unknown hotkey notification event %d\n", event);
983 acpi_bus_generate_event(ibm->acpi->device, event, 0);
984 }
985 }
986
987 /*
988 * Call with hotkey_mutex held
989 */
990 static int hotkey_get(int *status, u32 *mask)
991 {
992 if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
993 return -EIO;
994
995 if (tp_features.hotkey_mask)
996 if (!acpi_evalf(hkey_handle, mask, "DHKN", "d"))
997 return -EIO;
998
999 return 0;
1000 }
1001
1002 /*
1003 * Call with hotkey_mutex held
1004 */
1005 static int hotkey_set(int status, u32 mask)
1006 {
1007 int i;
1008
1009 if (!acpi_evalf(hkey_handle, NULL, "MHKC", "vd", status))
1010 return -EIO;
1011
1012 if (tp_features.hotkey_mask)
1013 for (i = 0; i < 32; i++) {
1014 int bit = ((1 << i) & mask) != 0;
1015 if (!acpi_evalf(hkey_handle,
1016 NULL, "MHKM", "vdd", i + 1, bit))
1017 return -EIO;
1018 }
1019
1020 return 0;
1021 }
1022
1023 /* procfs -------------------------------------------------------------- */
1024 static int hotkey_read(char *p)
1025 {
1026 int res, status;
1027 u32 mask;
1028 int len = 0;
1029
1030 if (!tp_features.hotkey) {
1031 len += sprintf(p + len, "status:\t\tnot supported\n");
1032 return len;
1033 }
1034
1035 res = mutex_lock_interruptible(&hotkey_mutex);
1036 if (res < 0)
1037 return res;
1038 res = hotkey_get(&status, &mask);
1039 mutex_unlock(&hotkey_mutex);
1040 if (res)
1041 return res;
1042
1043 len += sprintf(p + len, "status:\t\t%s\n", enabled(status, 0));
1044 if (tp_features.hotkey_mask) {
1045 len += sprintf(p + len, "mask:\t\t0x%08x\n", mask);
1046 len += sprintf(p + len,
1047 "commands:\tenable, disable, reset, <mask>\n");
1048 } else {
1049 len += sprintf(p + len, "mask:\t\tnot supported\n");
1050 len += sprintf(p + len, "commands:\tenable, disable, reset\n");
1051 }
1052
1053 return len;
1054 }
1055
1056 static int hotkey_write(char *buf)
1057 {
1058 int res, status;
1059 u32 mask;
1060 char *cmd;
1061 int do_cmd = 0;
1062
1063 if (!tp_features.hotkey)
1064 return -ENODEV;
1065
1066 res = mutex_lock_interruptible(&hotkey_mutex);
1067 if (res < 0)
1068 return res;
1069
1070 res = hotkey_get(&status, &mask);
1071 if (res)
1072 goto errexit;
1073
1074 res = 0;
1075 while ((cmd = next_cmd(&buf))) {
1076 if (strlencmp(cmd, "enable") == 0) {
1077 status = 1;
1078 } else if (strlencmp(cmd, "disable") == 0) {
1079 status = 0;
1080 } else if (strlencmp(cmd, "reset") == 0) {
1081 status = hotkey_orig_status;
1082 mask = hotkey_orig_mask;
1083 } else if (sscanf(cmd, "0x%x", &mask) == 1) {
1084 /* mask set */
1085 } else if (sscanf(cmd, "%x", &mask) == 1) {
1086 /* mask set */
1087 } else {
1088 res = -EINVAL;
1089 goto errexit;
1090 }
1091 do_cmd = 1;
1092 }
1093
1094 if (do_cmd)
1095 res = hotkey_set(status, mask);
1096
1097 errexit:
1098 mutex_unlock(&hotkey_mutex);
1099 return res;
1100 }
1101
1102 static struct tp_acpi_drv_struct ibm_hotkey_acpidriver = {
1103 .hid = IBM_HKEY_HID,
1104 .notify = hotkey_notify,
1105 .handle = &hkey_handle,
1106 .type = ACPI_DEVICE_NOTIFY,
1107 };
1108
1109 static struct ibm_struct hotkey_driver_data = {
1110 .name = "hotkey",
1111 .read = hotkey_read,
1112 .write = hotkey_write,
1113 .exit = hotkey_exit,
1114 .acpi = &ibm_hotkey_acpidriver,
1115 };
1116
1117 /*************************************************************************
1118 * Bluetooth subdriver
1119 */
1120
1121 /* sysfs bluetooth enable ---------------------------------------------- */
1122 static ssize_t bluetooth_enable_show(struct device *dev,
1123 struct device_attribute *attr,
1124 char *buf)
1125 {
1126 int status;
1127
1128 status = bluetooth_get_radiosw();
1129 if (status < 0)
1130 return status;
1131
1132 return snprintf(buf, PAGE_SIZE, "%d\n", status ? 1 : 0);
1133 }
1134
1135 static ssize_t bluetooth_enable_store(struct device *dev,
1136 struct device_attribute *attr,
1137 const char *buf, size_t count)
1138 {
1139 unsigned long t;
1140 int res;
1141
1142 if (parse_strtoul(buf, 1, &t))
1143 return -EINVAL;
1144
1145 res = bluetooth_set_radiosw(t);
1146
1147 return (res) ? res : count;
1148 }
1149
1150 static struct device_attribute dev_attr_bluetooth_enable =
1151 __ATTR(bluetooth_enable, S_IWUSR | S_IRUGO,
1152 bluetooth_enable_show, bluetooth_enable_store);
1153
1154 /* --------------------------------------------------------------------- */
1155
1156 static struct attribute *bluetooth_attributes[] = {
1157 &dev_attr_bluetooth_enable.attr,
1158 NULL
1159 };
1160
1161 static const struct attribute_group bluetooth_attr_group = {
1162 .attrs = bluetooth_attributes,
1163 };
1164
1165 static int __init bluetooth_init(struct ibm_init_struct *iibm)
1166 {
1167 int res;
1168 int status = 0;
1169
1170 vdbg_printk(TPACPI_DBG_INIT, "initializing bluetooth subdriver\n");
1171
1172 IBM_ACPIHANDLE_INIT(hkey);
1173
1174 /* bluetooth not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
1175 G4x, R30, R31, R40e, R50e, T20-22, X20-21 */
1176 tp_features.bluetooth = hkey_handle &&
1177 acpi_evalf(hkey_handle, &status, "GBDC", "qd");
1178
1179 vdbg_printk(TPACPI_DBG_INIT, "bluetooth is %s, status 0x%02x\n",
1180 str_supported(tp_features.bluetooth),
1181 status);
1182
1183 if (tp_features.bluetooth) {
1184 if (!(status & TP_ACPI_BLUETOOTH_HWPRESENT)) {
1185 /* no bluetooth hardware present in system */
1186 tp_features.bluetooth = 0;
1187 dbg_printk(TPACPI_DBG_INIT,
1188 "bluetooth hardware not installed\n");
1189 } else {
1190 res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
1191 &bluetooth_attr_group);
1192 if (res)
1193 return res;
1194 }
1195 }
1196
1197 return (tp_features.bluetooth)? 0 : 1;
1198 }
1199
1200 static void bluetooth_exit(void)
1201 {
1202 sysfs_remove_group(&tpacpi_pdev->dev.kobj,
1203 &bluetooth_attr_group);
1204 }
1205
1206 static int bluetooth_get_radiosw(void)
1207 {
1208 int status;
1209
1210 if (!tp_features.bluetooth)
1211 return -ENODEV;
1212
1213 if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
1214 return -EIO;
1215
1216 return ((status & TP_ACPI_BLUETOOTH_RADIOSSW) != 0);
1217 }
1218
1219 static int bluetooth_set_radiosw(int radio_on)
1220 {
1221 int status;
1222
1223 if (!tp_features.bluetooth)
1224 return -ENODEV;
1225
1226 if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
1227 return -EIO;
1228 if (radio_on)
1229 status |= TP_ACPI_BLUETOOTH_RADIOSSW;
1230 else
1231 status &= ~TP_ACPI_BLUETOOTH_RADIOSSW;
1232 if (!acpi_evalf(hkey_handle, NULL, "SBDC", "vd", status))
1233 return -EIO;
1234
1235 return 0;
1236 }
1237
1238 /* procfs -------------------------------------------------------------- */
1239 static int bluetooth_read(char *p)
1240 {
1241 int len = 0;
1242 int status = bluetooth_get_radiosw();
1243
1244 if (!tp_features.bluetooth)
1245 len += sprintf(p + len, "status:\t\tnot supported\n");
1246 else {
1247 len += sprintf(p + len, "status:\t\t%s\n",
1248 (status)? "enabled" : "disabled");
1249 len += sprintf(p + len, "commands:\tenable, disable\n");
1250 }
1251
1252 return len;
1253 }
1254
1255 static int bluetooth_write(char *buf)
1256 {
1257 char *cmd;
1258
1259 if (!tp_features.bluetooth)
1260 return -ENODEV;
1261
1262 while ((cmd = next_cmd(&buf))) {
1263 if (strlencmp(cmd, "enable") == 0) {
1264 bluetooth_set_radiosw(1);
1265 } else if (strlencmp(cmd, "disable") == 0) {
1266 bluetooth_set_radiosw(0);
1267 } else
1268 return -EINVAL;
1269 }
1270
1271 return 0;
1272 }
1273
1274 static struct ibm_struct bluetooth_driver_data = {
1275 .name = "bluetooth",
1276 .read = bluetooth_read,
1277 .write = bluetooth_write,
1278 .exit = bluetooth_exit,
1279 };
1280
1281 /*************************************************************************
1282 * Wan subdriver
1283 */
1284
1285 /* sysfs wan enable ---------------------------------------------------- */
1286 static ssize_t wan_enable_show(struct device *dev,
1287 struct device_attribute *attr,
1288 char *buf)
1289 {
1290 int status;
1291
1292 status = wan_get_radiosw();
1293 if (status < 0)
1294 return status;
1295
1296 return snprintf(buf, PAGE_SIZE, "%d\n", status ? 1 : 0);
1297 }
1298
1299 static ssize_t wan_enable_store(struct device *dev,
1300 struct device_attribute *attr,
1301 const char *buf, size_t count)
1302 {
1303 unsigned long t;
1304 int res;
1305
1306 if (parse_strtoul(buf, 1, &t))
1307 return -EINVAL;
1308
1309 res = wan_set_radiosw(t);
1310
1311 return (res) ? res : count;
1312 }
1313
1314 static struct device_attribute dev_attr_wan_enable =
1315 __ATTR(wwan_enable, S_IWUSR | S_IRUGO,
1316 wan_enable_show, wan_enable_store);
1317
1318 /* --------------------------------------------------------------------- */
1319
1320 static struct attribute *wan_attributes[] = {
1321 &dev_attr_wan_enable.attr,
1322 NULL
1323 };
1324
1325 static const struct attribute_group wan_attr_group = {
1326 .attrs = wan_attributes,
1327 };
1328
1329 static int __init wan_init(struct ibm_init_struct *iibm)
1330 {
1331 int res;
1332 int status = 0;
1333
1334 vdbg_printk(TPACPI_DBG_INIT, "initializing wan subdriver\n");
1335
1336 IBM_ACPIHANDLE_INIT(hkey);
1337
1338 tp_features.wan = hkey_handle &&
1339 acpi_evalf(hkey_handle, &status, "GWAN", "qd");
1340
1341 vdbg_printk(TPACPI_DBG_INIT, "wan is %s, status 0x%02x\n",
1342 str_supported(tp_features.wan),
1343 status);
1344
1345 if (tp_features.wan) {
1346 if (!(status & TP_ACPI_WANCARD_HWPRESENT)) {
1347 /* no wan hardware present in system */
1348 tp_features.wan = 0;
1349 dbg_printk(TPACPI_DBG_INIT,
1350 "wan hardware not installed\n");
1351 } else {
1352 res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
1353 &wan_attr_group);
1354 if (res)
1355 return res;
1356 }
1357 }
1358
1359 return (tp_features.wan)? 0 : 1;
1360 }
1361
1362 static void wan_exit(void)
1363 {
1364 sysfs_remove_group(&tpacpi_pdev->dev.kobj,
1365 &wan_attr_group);
1366 }
1367
1368 static int wan_get_radiosw(void)
1369 {
1370 int status;
1371
1372 if (!tp_features.wan)
1373 return -ENODEV;
1374
1375 if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
1376 return -EIO;
1377
1378 return ((status & TP_ACPI_WANCARD_RADIOSSW) != 0);
1379 }
1380
1381 static int wan_set_radiosw(int radio_on)
1382 {
1383 int status;
1384
1385 if (!tp_features.wan)
1386 return -ENODEV;
1387
1388 if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
1389 return -EIO;
1390 if (radio_on)
1391 status |= TP_ACPI_WANCARD_RADIOSSW;
1392 else
1393 status &= ~TP_ACPI_WANCARD_RADIOSSW;
1394 if (!acpi_evalf(hkey_handle, NULL, "SWAN", "vd", status))
1395 return -EIO;
1396
1397 return 0;
1398 }
1399
1400 /* procfs -------------------------------------------------------------- */
1401 static int wan_read(char *p)
1402 {
1403 int len = 0;
1404 int status = wan_get_radiosw();
1405
1406 if (!tp_features.wan)
1407 len += sprintf(p + len, "status:\t\tnot supported\n");
1408 else {
1409 len += sprintf(p + len, "status:\t\t%s\n",
1410 (status)? "enabled" : "disabled");
1411 len += sprintf(p + len, "commands:\tenable, disable\n");
1412 }
1413
1414 return len;
1415 }
1416
1417 static int wan_write(char *buf)
1418 {
1419 char *cmd;
1420
1421 if (!tp_features.wan)
1422 return -ENODEV;
1423
1424 while ((cmd = next_cmd(&buf))) {
1425 if (strlencmp(cmd, "enable") == 0) {
1426 wan_set_radiosw(1);
1427 } else if (strlencmp(cmd, "disable") == 0) {
1428 wan_set_radiosw(0);
1429 } else
1430 return -EINVAL;
1431 }
1432
1433 return 0;
1434 }
1435
1436 static struct ibm_struct wan_driver_data = {
1437 .name = "wan",
1438 .read = wan_read,
1439 .write = wan_write,
1440 .exit = wan_exit,
1441 .flags.experimental = 1,
1442 };
1443
1444 /*************************************************************************
1445 * Video subdriver
1446 */
1447
1448 static enum video_access_mode video_supported;
1449 static int video_orig_autosw;
1450
1451 IBM_HANDLE(vid, root, "\\_SB.PCI.AGP.VGA", /* 570 */
1452 "\\_SB.PCI0.AGP0.VID0", /* 600e/x, 770x */
1453 "\\_SB.PCI0.VID0", /* 770e */
1454 "\\_SB.PCI0.VID", /* A21e, G4x, R50e, X30, X40 */
1455 "\\_SB.PCI0.AGP.VID", /* all others */
1456 ); /* R30, R31 */
1457
1458 IBM_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID"); /* G41 */
1459
1460 static int __init video_init(struct ibm_init_struct *iibm)
1461 {
1462 int ivga;
1463
1464 vdbg_printk(TPACPI_DBG_INIT, "initializing video subdriver\n");
1465
1466 IBM_ACPIHANDLE_INIT(vid);
1467 IBM_ACPIHANDLE_INIT(vid2);
1468
1469 if (vid2_handle && acpi_evalf(NULL, &ivga, "\\IVGA", "d") && ivga)
1470 /* G41, assume IVGA doesn't change */
1471 vid_handle = vid2_handle;
1472
1473 if (!vid_handle)
1474 /* video switching not supported on R30, R31 */
1475 video_supported = TPACPI_VIDEO_NONE;
1476 else if (acpi_evalf(vid_handle, &video_orig_autosw, "SWIT", "qd"))
1477 /* 570 */
1478 video_supported = TPACPI_VIDEO_570;
1479 else if (acpi_evalf(vid_handle, &video_orig_autosw, "^VADL", "qd"))
1480 /* 600e/x, 770e, 770x */
1481 video_supported = TPACPI_VIDEO_770;
1482 else
1483 /* all others */
1484 video_supported = TPACPI_VIDEO_NEW;
1485
1486 vdbg_printk(TPACPI_DBG_INIT, "video is %s, mode %d\n",
1487 str_supported(video_supported != TPACPI_VIDEO_NONE),
1488 video_supported);
1489
1490 return (video_supported != TPACPI_VIDEO_NONE)? 0 : 1;
1491 }
1492
1493 static void video_exit(void)
1494 {
1495 dbg_printk(TPACPI_DBG_EXIT,
1496 "restoring original video autoswitch mode\n");
1497 if (video_autosw_set(video_orig_autosw))
1498 printk(IBM_ERR "error while trying to restore original "
1499 "video autoswitch mode\n");
1500 }
1501
1502 static int video_outputsw_get(void)
1503 {
1504 int status = 0;
1505 int i;
1506
1507 switch (video_supported) {
1508 case TPACPI_VIDEO_570:
1509 if (!acpi_evalf(NULL, &i, "\\_SB.PHS", "dd",
1510 TP_ACPI_VIDEO_570_PHSCMD))
1511 return -EIO;
1512 status = i & TP_ACPI_VIDEO_570_PHSMASK;
1513 break;
1514 case TPACPI_VIDEO_770:
1515 if (!acpi_evalf(NULL, &i, "\\VCDL", "d"))
1516 return -EIO;
1517 if (i)
1518 status |= TP_ACPI_VIDEO_S_LCD;
1519 if (!acpi_evalf(NULL, &i, "\\VCDC", "d"))
1520 return -EIO;
1521 if (i)
1522 status |= TP_ACPI_VIDEO_S_CRT;
1523 break;
1524 case TPACPI_VIDEO_NEW:
1525 if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 1) ||
1526 !acpi_evalf(NULL, &i, "\\VCDC", "d"))
1527 return -EIO;
1528 if (i)
1529 status |= TP_ACPI_VIDEO_S_CRT;
1530
1531 if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0) ||
1532 !acpi_evalf(NULL, &i, "\\VCDL", "d"))
1533 return -EIO;
1534 if (i)
1535 status |= TP_ACPI_VIDEO_S_LCD;
1536 if (!acpi_evalf(NULL, &i, "\\VCDD", "d"))
1537 return -EIO;
1538 if (i)
1539 status |= TP_ACPI_VIDEO_S_DVI;
1540 break;
1541 default:
1542 return -ENOSYS;
1543 }
1544
1545 return status;
1546 }
1547
1548 static int video_outputsw_set(int status)
1549 {
1550 int autosw;
1551 int res = 0;
1552
1553 switch (video_supported) {
1554 case TPACPI_VIDEO_570:
1555 res = acpi_evalf(NULL, NULL,
1556 "\\_SB.PHS2", "vdd",
1557 TP_ACPI_VIDEO_570_PHS2CMD,
1558 status | TP_ACPI_VIDEO_570_PHS2SET);
1559 break;
1560 case TPACPI_VIDEO_770:
1561 autosw = video_autosw_get();
1562 if (autosw < 0)
1563 return autosw;
1564
1565 res = video_autosw_set(1);
1566 if (res)
1567 return res;
1568 res = acpi_evalf(vid_handle, NULL,
1569 "ASWT", "vdd", status * 0x100, 0);
1570 if (!autosw && video_autosw_set(autosw)) {
1571 printk(IBM_ERR "video auto-switch left enabled due to error\n");
1572 return -EIO;
1573 }
1574 break;
1575 case TPACPI_VIDEO_NEW:
1576 res = acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0x80) &&
1577 acpi_evalf(NULL, NULL, "\\VSDS", "vdd", status, 1);
1578 break;
1579 default:
1580 return -ENOSYS;
1581 }
1582
1583 return (res)? 0 : -EIO;
1584 }
1585
1586 static int video_autosw_get(void)
1587 {
1588 int autosw = 0;
1589
1590 switch (video_supported) {
1591 case TPACPI_VIDEO_570:
1592 if (!acpi_evalf(vid_handle, &autosw, "SWIT", "d"))
1593 return -EIO;
1594 break;
1595 case TPACPI_VIDEO_770:
1596 case TPACPI_VIDEO_NEW:
1597 if (!acpi_evalf(vid_handle, &autosw, "^VDEE", "d"))
1598 return -EIO;
1599 break;
1600 default:
1601 return -ENOSYS;
1602 }
1603
1604 return autosw & 1;
1605 }
1606
1607 static int video_autosw_set(int enable)
1608 {
1609 if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", (enable)? 1 : 0))
1610 return -EIO;
1611 return 0;
1612 }
1613
1614 static int video_outputsw_cycle(void)
1615 {
1616 int autosw = video_autosw_get();
1617 int res;
1618
1619 if (autosw < 0)
1620 return autosw;
1621
1622 switch (video_supported) {
1623 case TPACPI_VIDEO_570:
1624 res = video_autosw_set(1);
1625 if (res)
1626 return res;
1627 res = acpi_evalf(ec_handle, NULL, "_Q16", "v");
1628 break;
1629 case TPACPI_VIDEO_770:
1630 case TPACPI_VIDEO_NEW:
1631 res = video_autosw_set(1);
1632 if (res)
1633 return res;
1634 res = acpi_evalf(vid_handle, NULL, "VSWT", "v");
1635 break;
1636 default:
1637 return -ENOSYS;
1638 }
1639 if (!autosw && video_autosw_set(autosw)) {
1640 printk(IBM_ERR "video auto-switch left enabled due to error\n");
1641 return -EIO;
1642 }
1643
1644 return (res)? 0 : -EIO;
1645 }
1646
1647 static int video_expand_toggle(void)
1648 {
1649 switch (video_supported) {
1650 case TPACPI_VIDEO_570:
1651 return acpi_evalf(ec_handle, NULL, "_Q17", "v")?
1652 0 : -EIO;
1653 case TPACPI_VIDEO_770:
1654 return acpi_evalf(vid_handle, NULL, "VEXP", "v")?
1655 0 : -EIO;
1656 case TPACPI_VIDEO_NEW:
1657 return acpi_evalf(NULL, NULL, "\\VEXP", "v")?
1658 0 : -EIO;
1659 default:
1660 return -ENOSYS;
1661 }
1662 /* not reached */
1663 }
1664
1665 static int video_read(char *p)
1666 {
1667 int status, autosw;
1668 int len = 0;
1669
1670 if (video_supported == TPACPI_VIDEO_NONE) {
1671 len += sprintf(p + len, "status:\t\tnot supported\n");
1672 return len;
1673 }
1674
1675 status = video_outputsw_get();
1676 if (status < 0)
1677 return status;
1678
1679 autosw = video_autosw_get();
1680 if (autosw < 0)
1681 return autosw;
1682
1683 len += sprintf(p + len, "status:\t\tsupported\n");
1684 len += sprintf(p + len, "lcd:\t\t%s\n", enabled(status, 0));
1685 len += sprintf(p + len, "crt:\t\t%s\n", enabled(status, 1));
1686 if (video_supported == TPACPI_VIDEO_NEW)
1687 len += sprintf(p + len, "dvi:\t\t%s\n", enabled(status, 3));
1688 len += sprintf(p + len, "auto:\t\t%s\n", enabled(autosw, 0));
1689 len += sprintf(p + len, "commands:\tlcd_enable, lcd_disable\n");
1690 len += sprintf(p + len, "commands:\tcrt_enable, crt_disable\n");
1691 if (video_supported == TPACPI_VIDEO_NEW)
1692 len += sprintf(p + len, "commands:\tdvi_enable, dvi_disable\n");
1693 len += sprintf(p + len, "commands:\tauto_enable, auto_disable\n");
1694 len += sprintf(p + len, "commands:\tvideo_switch, expand_toggle\n");
1695
1696 return len;
1697 }
1698
1699 static int video_write(char *buf)
1700 {
1701 char *cmd;
1702 int enable, disable, status;
1703 int res;
1704
1705 if (video_supported == TPACPI_VIDEO_NONE)
1706 return -ENODEV;
1707
1708 enable = 0;
1709 disable = 0;
1710
1711 while ((cmd = next_cmd(&buf))) {
1712 if (strlencmp(cmd, "lcd_enable") == 0) {
1713 enable |= TP_ACPI_VIDEO_S_LCD;
1714 } else if (strlencmp(cmd, "lcd_disable") == 0) {
1715 disable |= TP_ACPI_VIDEO_S_LCD;
1716 } else if (strlencmp(cmd, "crt_enable") == 0) {
1717 enable |= TP_ACPI_VIDEO_S_CRT;
1718 } else if (strlencmp(cmd, "crt_disable") == 0) {
1719 disable |= TP_ACPI_VIDEO_S_CRT;
1720 } else if (video_supported == TPACPI_VIDEO_NEW &&
1721 strlencmp(cmd, "dvi_enable") == 0) {
1722 enable |= TP_ACPI_VIDEO_S_DVI;
1723 } else if (video_supported == TPACPI_VIDEO_NEW &&
1724 strlencmp(cmd, "dvi_disable") == 0) {
1725 disable |= TP_ACPI_VIDEO_S_DVI;
1726 } else if (strlencmp(cmd, "auto_enable") == 0) {
1727 res = video_autosw_set(1);
1728 if (res)
1729 return res;
1730 } else if (strlencmp(cmd, "auto_disable") == 0) {
1731 res = video_autosw_set(0);
1732 if (res)
1733 return res;
1734 } else if (strlencmp(cmd, "video_switch") == 0) {
1735 res = video_outputsw_cycle();
1736 if (res)
1737 return res;
1738 } else if (strlencmp(cmd, "expand_toggle") == 0) {
1739 res = video_expand_toggle();
1740 if (res)
1741 return res;
1742 } else
1743 return -EINVAL;
1744 }
1745
1746 if (enable || disable) {
1747 status = video_outputsw_get();
1748 if (status < 0)
1749 return status;
1750 res = video_outputsw_set((status & ~disable) | enable);
1751 if (res)
1752 return res;
1753 }
1754
1755 return 0;
1756 }
1757
1758 static struct ibm_struct video_driver_data = {
1759 .name = "video",
1760 .read = video_read,
1761 .write = video_write,
1762 .exit = video_exit,
1763 };
1764
1765 /*************************************************************************
1766 * Light (thinklight) subdriver
1767 */
1768
1769 IBM_HANDLE(lght, root, "\\LGHT"); /* A21e, A2xm/p, T20-22, X20-21 */
1770 IBM_HANDLE(ledb, ec, "LEDB"); /* G4x */
1771
1772 static int __init light_init(struct ibm_init_struct *iibm)
1773 {
1774 vdbg_printk(TPACPI_DBG_INIT, "initializing light subdriver\n");
1775
1776 IBM_ACPIHANDLE_INIT(ledb);
1777 IBM_ACPIHANDLE_INIT(lght);
1778 IBM_ACPIHANDLE_INIT(cmos);
1779
1780 /* light not supported on 570, 600e/x, 770e, 770x, G4x, R30, R31 */
1781 tp_features.light = (cmos_handle || lght_handle) && !ledb_handle;
1782
1783 if (tp_features.light)
1784 /* light status not supported on
1785 570, 600e/x, 770e, 770x, G4x, R30, R31, R32, X20 */
1786 tp_features.light_status =
1787 acpi_evalf(ec_handle, NULL, "KBLT", "qv");
1788
1789 vdbg_printk(TPACPI_DBG_INIT, "light is %s\n",
1790 str_supported(tp_features.light));
1791
1792 return (tp_features.light)? 0 : 1;
1793 }
1794
1795 static int light_read(char *p)
1796 {
1797 int len = 0;
1798 int status = 0;
1799
1800 if (!tp_features.light) {
1801 len += sprintf(p + len, "status:\t\tnot supported\n");
1802 } else if (!tp_features.light_status) {
1803 len += sprintf(p + len, "status:\t\tunknown\n");
1804 len += sprintf(p + len, "commands:\ton, off\n");
1805 } else {
1806 if (!acpi_evalf(ec_handle, &status, "KBLT", "d"))
1807 return -EIO;
1808 len += sprintf(p + len, "status:\t\t%s\n", onoff(status, 0));
1809 len += sprintf(p + len, "commands:\ton, off\n");
1810 }
1811
1812 return len;
1813 }
1814
1815 static int light_write(char *buf)
1816 {
1817 int cmos_cmd, lght_cmd;
1818 char *cmd;
1819 int success;
1820
1821 if (!tp_features.light)
1822 return -ENODEV;
1823
1824 while ((cmd = next_cmd(&buf))) {
1825 if (strlencmp(cmd, "on") == 0) {
1826 cmos_cmd = 0x0c;
1827 lght_cmd = 1;
1828 } else if (strlencmp(cmd, "off") == 0) {
1829 cmos_cmd = 0x0d;
1830 lght_cmd = 0;
1831 } else
1832 return -EINVAL;
1833
1834 success = cmos_handle ?
1835 acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd) :
1836 acpi_evalf(lght_handle, NULL, NULL, "vd", lght_cmd);
1837 if (!success)
1838 return -EIO;
1839 }
1840
1841 return 0;
1842 }
1843
1844 static struct ibm_struct light_driver_data = {
1845 .name = "light",
1846 .read = light_read,
1847 .write = light_write,
1848 };
1849
1850 /*************************************************************************
1851 * Dock subdriver
1852 */
1853
1854 #ifdef CONFIG_THINKPAD_ACPI_DOCK
1855
1856 IBM_HANDLE(dock, root, "\\_SB.GDCK", /* X30, X31, X40 */
1857 "\\_SB.PCI0.DOCK", /* 600e/x,770e,770x,A2xm/p,T20-22,X20-21 */
1858 "\\_SB.PCI0.PCI1.DOCK", /* all others */
1859 "\\_SB.PCI.ISA.SLCE", /* 570 */
1860 ); /* A21e,G4x,R30,R31,R32,R40,R40e,R50e */
1861
1862 /* don't list other alternatives as we install a notify handler on the 570 */
1863 IBM_HANDLE(pci, root, "\\_SB.PCI"); /* 570 */
1864
1865 static struct tp_acpi_drv_struct ibm_dock_acpidriver[2] = {
1866 {
1867 .notify = dock_notify,
1868 .handle = &dock_handle,
1869 .type = ACPI_SYSTEM_NOTIFY,
1870 },
1871 {
1872 .hid = IBM_PCI_HID,
1873 .notify = dock_notify,
1874 .handle = &pci_handle,
1875 .type = ACPI_SYSTEM_NOTIFY,
1876 },
1877 };
1878
1879 static struct ibm_struct dock_driver_data[2] = {
1880 {
1881 .name = "dock",
1882 .read = dock_read,
1883 .write = dock_write,
1884 .acpi = &ibm_dock_acpidriver[0],
1885 },
1886 {
1887 .name = "dock",
1888 .acpi = &ibm_dock_acpidriver[1],
1889 },
1890 };
1891
1892 #define dock_docked() (_sta(dock_handle) & 1)
1893
1894 static int __init dock_init(struct ibm_init_struct *iibm)
1895 {
1896 vdbg_printk(TPACPI_DBG_INIT, "initializing dock subdriver\n");
1897
1898 IBM_ACPIHANDLE_INIT(dock);
1899
1900 vdbg_printk(TPACPI_DBG_INIT, "dock is %s\n",
1901 str_supported(dock_handle != NULL));
1902
1903 return (dock_handle)? 0 : 1;
1904 }
1905
1906 static int __init dock_init2(struct ibm_init_struct *iibm)
1907 {
1908 int dock2_needed;
1909
1910 vdbg_printk(TPACPI_DBG_INIT, "initializing dock subdriver part 2\n");
1911
1912 if (dock_driver_data[0].flags.acpi_driver_registered &&
1913 dock_driver_data[0].flags.acpi_notify_installed) {
1914 IBM_ACPIHANDLE_INIT(pci);
1915 dock2_needed = (pci_handle != NULL);
1916 vdbg_printk(TPACPI_DBG_INIT,
1917 "dock PCI handler for the TP 570 is %s\n",
1918 str_supported(dock2_needed));
1919 } else {
1920 vdbg_printk(TPACPI_DBG_INIT,
1921 "dock subdriver part 2 not required\n");
1922 dock2_needed = 0;
1923 }
1924
1925 return (dock2_needed)? 0 : 1;
1926 }
1927
1928 static void dock_notify(struct ibm_struct *ibm, u32 event)
1929 {
1930 int docked = dock_docked();
1931 int pci = ibm->acpi->hid && strstr(ibm->acpi->hid, IBM_PCI_HID);
1932
1933 if (event == 1 && !pci) /* 570 */
1934 acpi_bus_generate_event(ibm->acpi->device, event, 1); /* button */
1935 else if (event == 1 && pci) /* 570 */
1936 acpi_bus_generate_event(ibm->acpi->device, event, 3); /* dock */
1937 else if (event == 3 && docked)
1938 acpi_bus_generate_event(ibm->acpi->device, event, 1); /* button */
1939 else if (event == 3 && !docked)
1940 acpi_bus_generate_event(ibm->acpi->device, event, 2); /* undock */
1941 else if (event == 0 && docked)
1942 acpi_bus_generate_event(ibm->acpi->device, event, 3); /* dock */
1943 else {
1944 printk(IBM_ERR "unknown dock event %d, status %d\n",
1945 event, _sta(dock_handle));
1946 acpi_bus_generate_event(ibm->acpi->device, event, 0); /* unknown */
1947 }
1948 }
1949
1950 static int dock_read(char *p)
1951 {
1952 int len = 0;
1953 int docked = dock_docked();
1954
1955 if (!dock_handle)
1956 len += sprintf(p + len, "status:\t\tnot supported\n");
1957 else if (!docked)
1958 len += sprintf(p + len, "status:\t\tundocked\n");
1959 else {
1960 len += sprintf(p + len, "status:\t\tdocked\n");
1961 len += sprintf(p + len, "commands:\tdock, undock\n");
1962 }
1963
1964 return len;
1965 }
1966
1967 static int dock_write(char *buf)
1968 {
1969 char *cmd;
1970
1971 if (!dock_docked())
1972 return -ENODEV;
1973
1974 while ((cmd = next_cmd(&buf))) {
1975 if (strlencmp(cmd, "undock") == 0) {
1976 if (!acpi_evalf(dock_handle, NULL, "_DCK", "vd", 0) ||
1977 !acpi_evalf(dock_handle, NULL, "_EJ0", "vd", 1))
1978 return -EIO;
1979 } else if (strlencmp(cmd, "dock") == 0) {
1980 if (!acpi_evalf(dock_handle, NULL, "_DCK", "vd", 1))
1981 return -EIO;
1982 } else
1983 return -EINVAL;
1984 }
1985
1986 return 0;
1987 }
1988
1989 #endif /* CONFIG_THINKPAD_ACPI_DOCK */
1990
1991 /*************************************************************************
1992 * Bay subdriver
1993 */
1994
1995 #ifdef CONFIG_THINKPAD_ACPI_BAY
1996 IBM_HANDLE(bay, root, "\\_SB.PCI.IDE.SECN.MAST", /* 570 */
1997 "\\_SB.PCI0.IDE0.IDES.IDSM", /* 600e/x, 770e, 770x */
1998 "\\_SB.PCI0.SATA.SCND.MSTR", /* T60, X60, Z60 */
1999 "\\_SB.PCI0.IDE0.SCND.MSTR", /* all others */
2000 ); /* A21e, R30, R31 */
2001 IBM_HANDLE(bay_ej, bay, "_EJ3", /* 600e/x, A2xm/p, A3x */
2002 "_EJ0", /* all others */
2003 ); /* 570,A21e,G4x,R30,R31,R32,R40e,R50e */
2004 IBM_HANDLE(bay2, root, "\\_SB.PCI0.IDE0.PRIM.SLAV", /* A3x, R32 */
2005 "\\_SB.PCI0.IDE0.IDEP.IDPS", /* 600e/x, 770e, 770x */
2006 ); /* all others */
2007 IBM_HANDLE(bay2_ej, bay2, "_EJ3", /* 600e/x, 770e, A3x */
2008 "_EJ0", /* 770x */
2009 ); /* all others */
2010
2011 static int __init bay_init(struct ibm_init_struct *iibm)
2012 {
2013 vdbg_printk(TPACPI_DBG_INIT, "initializing bay subdriver\n");
2014
2015 IBM_ACPIHANDLE_INIT(bay);
2016 if (bay_handle)
2017 IBM_ACPIHANDLE_INIT(bay_ej);
2018 IBM_ACPIHANDLE_INIT(bay2);
2019 if (bay2_handle)
2020 IBM_ACPIHANDLE_INIT(bay2_ej);
2021
2022 tp_features.bay_status = bay_handle &&
2023 acpi_evalf(bay_handle, NULL, "_STA", "qv");
2024 tp_features.bay_status2 = bay2_handle &&
2025 acpi_evalf(bay2_handle, NULL, "_STA", "qv");
2026
2027 tp_features.bay_eject = bay_handle && bay_ej_handle &&
2028 (strlencmp(bay_ej_path, "_EJ0") == 0 || experimental);
2029 tp_features.bay_eject2 = bay2_handle && bay2_ej_handle &&
2030 (strlencmp(bay2_ej_path, "_EJ0") == 0 || experimental);
2031
2032 vdbg_printk(TPACPI_DBG_INIT,
2033 "bay 1: status %s, eject %s; bay 2: status %s, eject %s\n",
2034 str_supported(tp_features.bay_status),
2035 str_supported(tp_features.bay_eject),
2036 str_supported(tp_features.bay_status2),
2037 str_supported(tp_features.bay_eject2));
2038
2039 return (tp_features.bay_status || tp_features.bay_eject ||
2040 tp_features.bay_status2 || tp_features.bay_eject2)? 0 : 1;
2041 }
2042
2043 static void bay_notify(struct ibm_struct *ibm, u32 event)
2044 {
2045 acpi_bus_generate_event(ibm->acpi->device, event, 0);
2046 }
2047
2048 #define bay_occupied(b) (_sta(b##_handle) & 1)
2049
2050 static int bay_read(char *p)
2051 {
2052 int len = 0;
2053 int occupied = bay_occupied(bay);
2054 int occupied2 = bay_occupied(bay2);
2055 int eject, eject2;
2056
2057 len += sprintf(p + len, "status:\t\t%s\n",
2058 tp_features.bay_status ?
2059 (occupied ? "occupied" : "unoccupied") :
2060 "not supported");
2061 if (tp_features.bay_status2)
2062 len += sprintf(p + len, "status2:\t%s\n", occupied2 ?
2063 "occupied" : "unoccupied");
2064
2065 eject = tp_features.bay_eject && occupied;
2066 eject2 = tp_features.bay_eject2 && occupied2;
2067
2068 if (eject && eject2)
2069 len += sprintf(p + len, "commands:\teject, eject2\n");
2070 else if (eject)
2071 len += sprintf(p + len, "commands:\teject\n");
2072 else if (eject2)
2073 len += sprintf(p + len, "commands:\teject2\n");
2074
2075 return len;
2076 }
2077
2078 static int bay_write(char *buf)
2079 {
2080 char *cmd;
2081
2082 if (!tp_features.bay_eject && !tp_features.bay_eject2)
2083 return -ENODEV;
2084
2085 while ((cmd = next_cmd(&buf))) {
2086 if (tp_features.bay_eject && strlencmp(cmd, "eject") == 0) {
2087 if (!acpi_evalf(bay_ej_handle, NULL, NULL, "vd", 1))
2088 return -EIO;
2089 } else if (tp_features.bay_eject2 &&
2090 strlencmp(cmd, "eject2") == 0) {
2091 if (!acpi_evalf(bay2_ej_handle, NULL, NULL, "vd", 1))
2092 return -EIO;
2093 } else
2094 return -EINVAL;
2095 }
2096
2097 return 0;
2098 }
2099
2100 static struct tp_acpi_drv_struct ibm_bay_acpidriver = {
2101 .notify = bay_notify,
2102 .handle = &bay_handle,
2103 .type = ACPI_SYSTEM_NOTIFY,
2104 };
2105
2106 static struct ibm_struct bay_driver_data = {
2107 .name = "bay",
2108 .read = bay_read,
2109 .write = bay_write,
2110 .acpi = &ibm_bay_acpidriver,
2111 };
2112
2113 #endif /* CONFIG_THINKPAD_ACPI_BAY */
2114
2115 /*************************************************************************
2116 * CMOS subdriver
2117 */
2118
2119 /* sysfs cmos_command -------------------------------------------------- */
2120 static ssize_t cmos_command_store(struct device *dev,
2121 struct device_attribute *attr,
2122 const char *buf, size_t count)
2123 {
2124 unsigned long cmos_cmd;
2125 int res;
2126
2127 if (parse_strtoul(buf, 21, &cmos_cmd))
2128 return -EINVAL;
2129
2130 res = issue_thinkpad_cmos_command(cmos_cmd);
2131 return (res)? res : count;
2132 }
2133
2134 static struct device_attribute dev_attr_cmos_command =
2135 __ATTR(cmos_command, S_IWUSR, NULL, cmos_command_store);
2136
2137 /* --------------------------------------------------------------------- */
2138
2139 static int __init cmos_init(struct ibm_init_struct *iibm)
2140 {
2141 int res;
2142
2143 vdbg_printk(TPACPI_DBG_INIT,
2144 "initializing cmos commands subdriver\n");
2145
2146 IBM_ACPIHANDLE_INIT(cmos);
2147
2148 vdbg_printk(TPACPI_DBG_INIT, "cmos commands are %s\n",
2149 str_supported(cmos_handle != NULL));
2150
2151 res = device_create_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
2152 if (res)
2153 return res;
2154
2155 return (cmos_handle)? 0 : 1;
2156 }
2157
2158 static void cmos_exit(void)
2159 {
2160 device_remove_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
2161 }
2162
2163 static int cmos_read(char *p)
2164 {
2165 int len = 0;
2166
2167 /* cmos not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
2168 R30, R31, T20-22, X20-21 */
2169 if (!cmos_handle)
2170 len += sprintf(p + len, "status:\t\tnot supported\n");
2171 else {
2172 len += sprintf(p + len, "status:\t\tsupported\n");
2173 len += sprintf(p + len, "commands:\t<cmd> (<cmd> is 0-21)\n");
2174 }
2175
2176 return len;
2177 }
2178
2179 static int cmos_write(char *buf)
2180 {
2181 char *cmd;
2182 int cmos_cmd, res;
2183
2184 while ((cmd = next_cmd(&buf))) {
2185 if (sscanf(cmd, "%u", &cmos_cmd) == 1 &&
2186 cmos_cmd >= 0 && cmos_cmd <= 21) {
2187 /* cmos_cmd set */
2188 } else
2189 return -EINVAL;
2190
2191 res = issue_thinkpad_cmos_command(cmos_cmd);
2192 if (res)
2193 return res;
2194 }
2195
2196 return 0;
2197 }
2198
2199 static struct ibm_struct cmos_driver_data = {
2200 .name = "cmos",
2201 .read = cmos_read,
2202 .write = cmos_write,
2203 .exit = cmos_exit,
2204 };
2205
2206 /*************************************************************************
2207 * LED subdriver
2208 */
2209
2210 static enum led_access_mode led_supported;
2211
2212 IBM_HANDLE(led, ec, "SLED", /* 570 */
2213 "SYSL", /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
2214 "LED", /* all others */
2215 ); /* R30, R31 */
2216
2217 static int __init led_init(struct ibm_init_struct *iibm)
2218 {
2219 vdbg_printk(TPACPI_DBG_INIT, "initializing LED subdriver\n");
2220
2221 IBM_ACPIHANDLE_INIT(led);
2222
2223 if (!led_handle)
2224 /* led not supported on R30, R31 */
2225 led_supported = TPACPI_LED_NONE;
2226 else if (strlencmp(led_path, "SLED") == 0)
2227 /* 570 */
2228 led_supported = TPACPI_LED_570;
2229 else if (strlencmp(led_path, "SYSL") == 0)
2230 /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
2231 led_supported = TPACPI_LED_OLD;
2232 else
2233 /* all others */
2234 led_supported = TPACPI_LED_NEW;
2235
2236 vdbg_printk(TPACPI_DBG_INIT, "LED commands are %s, mode %d\n",
2237 str_supported(led_supported), led_supported);
2238
2239 return (led_supported != TPACPI_LED_NONE)? 0 : 1;
2240 }
2241
2242 #define led_status(s) ((s) == 0 ? "off" : ((s) == 1 ? "on" : "blinking"))
2243
2244 static int led_read(char *p)
2245 {
2246 int len = 0;
2247
2248 if (!led_supported) {
2249 len += sprintf(p + len, "status:\t\tnot supported\n");
2250 return len;
2251 }
2252 len += sprintf(p + len, "status:\t\tsupported\n");
2253
2254 if (led_supported == TPACPI_LED_570) {
2255 /* 570 */
2256 int i, status;
2257 for (i = 0; i < 8; i++) {
2258 if (!acpi_evalf(ec_handle,
2259 &status, "GLED", "dd", 1 << i))
2260 return -EIO;
2261 len += sprintf(p + len, "%d:\t\t%s\n",
2262 i, led_status(status));
2263 }
2264 }
2265
2266 len += sprintf(p + len, "commands:\t"
2267 "<led> on, <led> off, <led> blink (<led> is 0-7)\n");
2268
2269 return len;
2270 }
2271
2272 /* off, on, blink */
2273 static const int led_sled_arg1[] = { 0, 1, 3 };
2274 static const int led_exp_hlbl[] = { 0, 0, 1 }; /* led# * */
2275 static const int led_exp_hlcl[] = { 0, 1, 1 }; /* led# * */
2276 static const int led_led_arg1[] = { 0, 0x80, 0xc0 };
2277
2278 static int led_write(char *buf)
2279 {
2280 char *cmd;
2281 int led, ind, ret;
2282
2283 if (!led_supported)
2284 return -ENODEV;
2285
2286 while ((cmd = next_cmd(&buf))) {
2287 if (sscanf(cmd, "%d", &led) != 1 || led < 0 || led > 7)
2288 return -EINVAL;
2289
2290 if (strstr(cmd, "off")) {
2291 ind = 0;
2292 } else if (strstr(cmd, "on")) {
2293 ind = 1;
2294 } else if (strstr(cmd, "blink")) {
2295 ind = 2;
2296 } else
2297 return -EINVAL;
2298
2299 if (led_supported == TPACPI_LED_570) {
2300 /* 570 */
2301 led = 1 << led;
2302 if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
2303 led, led_sled_arg1[ind]))
2304 return -EIO;
2305 } else if (led_supported == TPACPI_LED_OLD) {
2306 /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20 */
2307 led = 1 << led;
2308 ret = ec_write(TPACPI_LED_EC_HLMS, led);
2309 if (ret >= 0)
2310 ret =
2311 ec_write(TPACPI_LED_EC_HLBL,
2312 led * led_exp_hlbl[ind]);
2313 if (ret >= 0)
2314 ret =
2315 ec_write(TPACPI_LED_EC_HLCL,
2316 led * led_exp_hlcl[ind]);
2317 if (ret < 0)
2318 return ret;
2319 } else {
2320 /* all others */
2321 if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
2322 led, led_led_arg1[ind]))
2323 return -EIO;
2324 }
2325 }
2326
2327 return 0;
2328 }
2329
2330 static struct ibm_struct led_driver_data = {
2331 .name = "led",
2332 .read = led_read,
2333 .write = led_write,
2334 };
2335
2336 /*************************************************************************
2337 * Beep subdriver
2338 */
2339
2340 IBM_HANDLE(beep, ec, "BEEP"); /* all except R30, R31 */
2341
2342 static int __init beep_init(struct ibm_init_struct *iibm)
2343 {
2344 vdbg_printk(TPACPI_DBG_INIT, "initializing beep subdriver\n");
2345
2346 IBM_ACPIHANDLE_INIT(beep);
2347
2348 vdbg_printk(TPACPI_DBG_INIT, "beep is %s\n",
2349 str_supported(beep_handle != NULL));
2350
2351 return (beep_handle)? 0 : 1;
2352 }
2353
2354 static int beep_read(char *p)
2355 {
2356 int len = 0;
2357
2358 if (!beep_handle)
2359 len += sprintf(p + len, "status:\t\tnot supported\n");
2360 else {
2361 len += sprintf(p + len, "status:\t\tsupported\n");
2362 len += sprintf(p + len, "commands:\t<cmd> (<cmd> is 0-17)\n");
2363 }
2364
2365 return len;
2366 }
2367
2368 static int beep_write(char *buf)
2369 {
2370 char *cmd;
2371 int beep_cmd;
2372
2373 if (!beep_handle)
2374 return -ENODEV;
2375
2376 while ((cmd = next_cmd(&buf))) {
2377 if (sscanf(cmd, "%u", &beep_cmd) == 1 &&
2378 beep_cmd >= 0 && beep_cmd <= 17) {
2379 /* beep_cmd set */
2380 } else
2381 return -EINVAL;
2382 if (!acpi_evalf(beep_handle, NULL, NULL, "vdd", beep_cmd, 0))
2383 return -EIO;
2384 }
2385
2386 return 0;
2387 }
2388
2389 static struct ibm_struct beep_driver_data = {
2390 .name = "beep",
2391 .read = beep_read,
2392 .write = beep_write,
2393 };
2394
2395 /*************************************************************************
2396 * Thermal subdriver
2397 */
2398
2399 static enum thermal_access_mode thermal_read_mode;
2400
2401 /* sysfs temp##_input -------------------------------------------------- */
2402
2403 static ssize_t thermal_temp_input_show(struct device *dev,
2404 struct device_attribute *attr,
2405 char *buf)
2406 {
2407 struct sensor_device_attribute *sensor_attr =
2408 to_sensor_dev_attr(attr);
2409 int idx = sensor_attr->index;
2410 s32 value;
2411 int res;
2412
2413 res = thermal_get_sensor(idx, &value);
2414 if (res)
2415 return res;
2416 if (value == TP_EC_THERMAL_TMP_NA * 1000)
2417 return -ENXIO;
2418
2419 return snprintf(buf, PAGE_SIZE, "%d\n", value);
2420 }
2421
2422 #define THERMAL_SENSOR_ATTR_TEMP(_idxA, _idxB) \
2423 SENSOR_ATTR(temp##_idxA##_input, S_IRUGO, thermal_temp_input_show, NULL, _idxB)
2424
2425 static struct sensor_device_attribute sensor_dev_attr_thermal_temp_input[] = {
2426 THERMAL_SENSOR_ATTR_TEMP(1, 0),
2427 THERMAL_SENSOR_ATTR_TEMP(2, 1),
2428 THERMAL_SENSOR_ATTR_TEMP(3, 2),
2429 THERMAL_SENSOR_ATTR_TEMP(4, 3),
2430 THERMAL_SENSOR_ATTR_TEMP(5, 4),
2431 THERMAL_SENSOR_ATTR_TEMP(6, 5),
2432 THERMAL_SENSOR_ATTR_TEMP(7, 6),
2433 THERMAL_SENSOR_ATTR_TEMP(8, 7),
2434 THERMAL_SENSOR_ATTR_TEMP(9, 8),
2435 THERMAL_SENSOR_ATTR_TEMP(10, 9),
2436 THERMAL_SENSOR_ATTR_TEMP(11, 10),
2437 THERMAL_SENSOR_ATTR_TEMP(12, 11),
2438 THERMAL_SENSOR_ATTR_TEMP(13, 12),
2439 THERMAL_SENSOR_ATTR_TEMP(14, 13),
2440 THERMAL_SENSOR_ATTR_TEMP(15, 14),
2441 THERMAL_SENSOR_ATTR_TEMP(16, 15),
2442 };
2443
2444 #define THERMAL_ATTRS(X) \
2445 &sensor_dev_attr_thermal_temp_input[X].dev_attr.attr
2446
2447 static struct attribute *thermal_temp_input_attr[] = {
2448 THERMAL_ATTRS(8),
2449 THERMAL_ATTRS(9),
2450 THERMAL_ATTRS(10),
2451 THERMAL_ATTRS(11),
2452 THERMAL_ATTRS(12),
2453 THERMAL_ATTRS(13),
2454 THERMAL_ATTRS(14),
2455 THERMAL_ATTRS(15),
2456 THERMAL_ATTRS(0),
2457 THERMAL_ATTRS(1),
2458 THERMAL_ATTRS(2),
2459 THERMAL_ATTRS(3),
2460 THERMAL_ATTRS(4),
2461 THERMAL_ATTRS(5),
2462 THERMAL_ATTRS(6),
2463 THERMAL_ATTRS(7),
2464 NULL
2465 };
2466
2467 static const struct attribute_group thermal_temp_input16_group = {
2468 .attrs = thermal_temp_input_attr
2469 };
2470
2471 static const struct attribute_group thermal_temp_input8_group = {
2472 .attrs = &thermal_temp_input_attr[8]
2473 };
2474
2475 #undef THERMAL_SENSOR_ATTR_TEMP
2476 #undef THERMAL_ATTRS
2477
2478 /* --------------------------------------------------------------------- */
2479
2480 static int __init thermal_init(struct ibm_init_struct *iibm)
2481 {
2482 u8 t, ta1, ta2;
2483 int i;
2484 int acpi_tmp7;
2485 int res;
2486
2487 vdbg_printk(TPACPI_DBG_INIT, "initializing thermal subdriver\n");
2488
2489 acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
2490
2491 if (ibm_thinkpad_ec_found && experimental) {
2492 /*
2493 * Direct EC access mode: sensors at registers
2494 * 0x78-0x7F, 0xC0-0xC7. Registers return 0x00 for
2495 * non-implemented, thermal sensors return 0x80 when
2496 * not available
2497 */
2498
2499 ta1 = ta2 = 0;
2500 for (i = 0; i < 8; i++) {
2501 if (acpi_ec_read(TP_EC_THERMAL_TMP0 + i, &t)) {
2502 ta1 |= t;
2503 } else {
2504 ta1 = 0;
2505 break;
2506 }
2507 if (acpi_ec_read(TP_EC_THERMAL_TMP8 + i, &t)) {
2508 ta2 |= t;
2509 } else {
2510 ta1 = 0;
2511 break;
2512 }
2513 }
2514 if (ta1 == 0) {
2515 /* This is sheer paranoia, but we handle it anyway */
2516 if (acpi_tmp7) {
2517 printk(IBM_ERR
2518 "ThinkPad ACPI EC access misbehaving, "
2519 "falling back to ACPI TMPx access mode\n");
2520 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
2521 } else {
2522 printk(IBM_ERR
2523 "ThinkPad ACPI EC access misbehaving, "
2524 "disabling thermal sensors access\n");
2525 thermal_read_mode = TPACPI_THERMAL_NONE;
2526 }
2527 } else {
2528 thermal_read_mode =
2529 (ta2 != 0) ?
2530 TPACPI_THERMAL_TPEC_16 : TPACPI_THERMAL_TPEC_8;
2531 }
2532 } else if (acpi_tmp7) {
2533 if (acpi_evalf(ec_handle, NULL, "UPDT", "qv")) {
2534 /* 600e/x, 770e, 770x */
2535 thermal_read_mode = TPACPI_THERMAL_ACPI_UPDT;
2536 } else {
2537 /* Standard ACPI TMPx access, max 8 sensors */
2538 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
2539 }
2540 } else {
2541 /* temperatures not supported on 570, G4x, R30, R31, R32 */
2542 thermal_read_mode = TPACPI_THERMAL_NONE;
2543 }
2544
2545 vdbg_printk(TPACPI_DBG_INIT, "thermal is %s, mode %d\n",
2546 str_supported(thermal_read_mode != TPACPI_THERMAL_NONE),
2547 thermal_read_mode);
2548
2549 switch(thermal_read_mode) {
2550 case TPACPI_THERMAL_TPEC_16:
2551 res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
2552 &thermal_temp_input16_group);
2553 if (res)
2554 return res;
2555 break;
2556 case TPACPI_THERMAL_TPEC_8:
2557 case TPACPI_THERMAL_ACPI_TMP07:
2558 case TPACPI_THERMAL_ACPI_UPDT:
2559 res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
2560 &thermal_temp_input8_group);
2561 if (res)
2562 return res;
2563 break;
2564 case TPACPI_THERMAL_NONE:
2565 default:
2566 return 1;
2567 }
2568
2569 return 0;
2570 }
2571
2572 static void thermal_exit(void)
2573 {
2574 switch(thermal_read_mode) {
2575 case TPACPI_THERMAL_TPEC_16:
2576 sysfs_remove_group(&tpacpi_pdev->dev.kobj,
2577 &thermal_temp_input16_group);
2578 break;
2579 case TPACPI_THERMAL_TPEC_8:
2580 case TPACPI_THERMAL_ACPI_TMP07:
2581 case TPACPI_THERMAL_ACPI_UPDT:
2582 sysfs_remove_group(&tpacpi_pdev->dev.kobj,
2583 &thermal_temp_input16_group);
2584 break;
2585 case TPACPI_THERMAL_NONE:
2586 default:
2587 break;
2588 }
2589 }
2590
2591 /* idx is zero-based */
2592 static int thermal_get_sensor(int idx, s32 *value)
2593 {
2594 int t;
2595 s8 tmp;
2596 char tmpi[5];
2597
2598 t = TP_EC_THERMAL_TMP0;
2599
2600 switch (thermal_read_mode) {
2601 #if TPACPI_MAX_THERMAL_SENSORS >= 16
2602 case TPACPI_THERMAL_TPEC_16:
2603 if (idx >= 8 && idx <= 15) {
2604 t = TP_EC_THERMAL_TMP8;
2605 idx -= 8;
2606 }
2607 /* fallthrough */
2608 #endif
2609 case TPACPI_THERMAL_TPEC_8:
2610 if (idx <= 7) {
2611 if (!acpi_ec_read(t + idx, &tmp))
2612 return -EIO;
2613 *value = tmp * 1000;
2614 return 0;
2615 }
2616 break;
2617
2618 case TPACPI_THERMAL_ACPI_UPDT:
2619 if (idx <= 7) {
2620 snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
2621 if (!acpi_evalf(ec_handle, NULL, "UPDT", "v"))
2622 return -EIO;
2623 if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
2624 return -EIO;
2625 *value = (t - 2732) * 100;
2626 return 0;
2627 }
2628 break;
2629
2630 case TPACPI_THERMAL_ACPI_TMP07:
2631 if (idx <= 7) {
2632 snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
2633 if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
2634 return -EIO;
2635 *value = t * 1000;
2636 return 0;
2637 }
2638 break;
2639
2640 case TPACPI_THERMAL_NONE:
2641 default:
2642 return -ENOSYS;
2643 }
2644
2645 return -EINVAL;
2646 }
2647
2648 static int thermal_get_sensors(struct ibm_thermal_sensors_struct *s)
2649 {
2650 int res, i;
2651 int n;
2652
2653 n = 8;
2654 i = 0;
2655
2656 if (!s)
2657 return -EINVAL;
2658
2659 if (thermal_read_mode == TPACPI_THERMAL_TPEC_16)
2660 n = 16;
2661
2662 for(i = 0 ; i < n; i++) {
2663 res = thermal_get_sensor(i, &s->temp[i]);
2664 if (res)
2665 return res;
2666 }
2667
2668 return n;
2669 }
2670
2671 static int thermal_read(char *p)
2672 {
2673 int len = 0;
2674 int n, i;
2675 struct ibm_thermal_sensors_struct t;
2676
2677 n = thermal_get_sensors(&t);
2678 if (unlikely(n < 0))
2679 return n;
2680
2681 len += sprintf(p + len, "temperatures:\t");
2682
2683 if (n > 0) {
2684 for (i = 0; i < (n - 1); i++)
2685 len += sprintf(p + len, "%d ", t.temp[i] / 1000);
2686 len += sprintf(p + len, "%d\n", t.temp[i] / 1000);
2687 } else
2688 len += sprintf(p + len, "not supported\n");
2689
2690 return len;
2691 }
2692
2693 static struct ibm_struct thermal_driver_data = {
2694 .name = "thermal",
2695 .read = thermal_read,
2696 .exit = thermal_exit,
2697 };
2698
2699 /*************************************************************************
2700 * EC Dump subdriver
2701 */
2702
2703 static u8 ecdump_regs[256];
2704
2705 static int ecdump_read(char *p)
2706 {
2707 int len = 0;
2708 int i, j;
2709 u8 v;
2710
2711 len += sprintf(p + len, "EC "
2712 " +00 +01 +02 +03 +04 +05 +06 +07"
2713 " +08 +09 +0a +0b +0c +0d +0e +0f\n");
2714 for (i = 0; i < 256; i += 16) {
2715 len += sprintf(p + len, "EC 0x%02x:", i);
2716 for (j = 0; j < 16; j++) {
2717 if (!acpi_ec_read(i + j, &v))
2718 break;
2719 if (v != ecdump_regs[i + j])
2720 len += sprintf(p + len, " *%02x", v);
2721 else
2722 len += sprintf(p + len, " %02x", v);
2723 ecdump_regs[i + j] = v;
2724 }
2725 len += sprintf(p + len, "\n");
2726 if (j != 16)
2727 break;
2728 }
2729
2730 /* These are way too dangerous to advertise openly... */
2731 #if 0
2732 len += sprintf(p + len, "commands:\t0x<offset> 0x<value>"
2733 " (<offset> is 00-ff, <value> is 00-ff)\n");
2734 len += sprintf(p + len, "commands:\t0x<offset> <value> "
2735 " (<offset> is 00-ff, <value> is 0-255)\n");
2736 #endif
2737 return len;
2738 }
2739
2740 static int ecdump_write(char *buf)
2741 {
2742 char *cmd;
2743 int i, v;
2744
2745 while ((cmd = next_cmd(&buf))) {
2746 if (sscanf(cmd, "0x%x 0x%x", &i, &v) == 2) {
2747 /* i and v set */
2748 } else if (sscanf(cmd, "0x%x %u", &i, &v) == 2) {
2749 /* i and v set */
2750 } else
2751 return -EINVAL;
2752 if (i >= 0 && i < 256 && v >= 0 && v < 256) {
2753 if (!acpi_ec_write(i, v))
2754 return -EIO;
2755 } else
2756 return -EINVAL;
2757 }
2758
2759 return 0;
2760 }
2761
2762 static struct ibm_struct ecdump_driver_data = {
2763 .name = "ecdump",
2764 .read = ecdump_read,
2765 .write = ecdump_write,
2766 .flags.experimental = 1,
2767 };
2768
2769 /*************************************************************************
2770 * Backlight/brightness subdriver
2771 */
2772
2773 static struct backlight_device *ibm_backlight_device;
2774
2775 static struct backlight_properties ibm_backlight_data = {
2776 .owner = THIS_MODULE,
2777 .get_brightness = brightness_get,
2778 .update_status = brightness_update_status,
2779 .max_brightness = 7,
2780 };
2781
2782 static int __init brightness_init(struct ibm_init_struct *iibm)
2783 {
2784 int b;
2785
2786 vdbg_printk(TPACPI_DBG_INIT, "initializing brightness subdriver\n");
2787
2788 b = brightness_get(NULL);
2789 if (b < 0)
2790 return b;
2791
2792 ibm_backlight_device = backlight_device_register(
2793 TPACPI_BACKLIGHT_DEV_NAME, NULL, NULL,
2794 &ibm_backlight_data);
2795 if (IS_ERR(ibm_backlight_device)) {
2796 printk(IBM_ERR "Could not register backlight device\n");
2797 return PTR_ERR(ibm_backlight_device);
2798 }
2799 vdbg_printk(TPACPI_DBG_INIT, "brightness is supported\n");
2800
2801 ibm_backlight_device->props->brightness = b;
2802 brightness_update_status(ibm_backlight_device);
2803
2804 return 0;
2805 }
2806
2807 static void brightness_exit(void)
2808 {
2809 if (ibm_backlight_device) {
2810 vdbg_printk(TPACPI_DBG_EXIT,
2811 "calling backlight_device_unregister()\n");
2812 backlight_device_unregister(ibm_backlight_device);
2813 ibm_backlight_device = NULL;
2814 }
2815 }
2816
2817 static int brightness_update_status(struct backlight_device *bd)
2818 {
2819 return brightness_set(
2820 (bd->props->fb_blank == FB_BLANK_UNBLANK &&
2821 bd->props->power == FB_BLANK_UNBLANK) ?
2822 bd->props->brightness : 0);
2823 }
2824
2825 static int brightness_get(struct backlight_device *bd)
2826 {
2827 u8 level;
2828 if (!acpi_ec_read(brightness_offset, &level))
2829 return -EIO;
2830
2831 level &= 0x7;
2832
2833 return level;
2834 }
2835
2836 static int brightness_set(int value)
2837 {
2838 int cmos_cmd, inc, i;
2839 int current_value = brightness_get(NULL);
2840
2841 value &= 7;
2842
2843 cmos_cmd = value > current_value ? TP_CMOS_BRIGHTNESS_UP : TP_CMOS_BRIGHTNESS_DOWN;
2844 inc = value > current_value ? 1 : -1;
2845 for (i = current_value; i != value; i += inc) {
2846 if (issue_thinkpad_cmos_command(cmos_cmd))
2847 return -EIO;
2848 if (!acpi_ec_write(brightness_offset, i + inc))
2849 return -EIO;
2850 }
2851
2852 return 0;
2853 }
2854
2855 static int brightness_read(char *p)
2856 {
2857 int len = 0;
2858 int level;
2859
2860 if ((level = brightness_get(NULL)) < 0) {
2861 len += sprintf(p + len, "level:\t\tunreadable\n");
2862 } else {
2863 len += sprintf(p + len, "level:\t\t%d\n", level & 0x7);
2864 len += sprintf(p + len, "commands:\tup, down\n");
2865 len += sprintf(p + len, "commands:\tlevel <level>"
2866 " (<level> is 0-7)\n");
2867 }
2868
2869 return len;
2870 }
2871
2872 static int brightness_write(char *buf)
2873 {
2874 int level;
2875 int new_level;
2876 char *cmd;
2877
2878 while ((cmd = next_cmd(&buf))) {
2879 if ((level = brightness_get(NULL)) < 0)
2880 return level;
2881 level &= 7;
2882
2883 if (strlencmp(cmd, "up") == 0) {
2884 new_level = level == 7 ? 7 : level + 1;
2885 } else if (strlencmp(cmd, "down") == 0) {
2886 new_level = level == 0 ? 0 : level - 1;
2887 } else if (sscanf(cmd, "level %d", &new_level) == 1 &&
2888 new_level >= 0 && new_level <= 7) {
2889 /* new_level set */
2890 } else
2891 return -EINVAL;
2892
2893 brightness_set(new_level);
2894 }
2895
2896 return 0;
2897 }
2898
2899 static struct ibm_struct brightness_driver_data = {
2900 .name = "brightness",
2901 .read = brightness_read,
2902 .write = brightness_write,
2903 .exit = brightness_exit,
2904 };
2905
2906 /*************************************************************************
2907 * Volume subdriver
2908 */
2909
2910 static int volume_read(char *p)
2911 {
2912 int len = 0;
2913 u8 level;
2914
2915 if (!acpi_ec_read(volume_offset, &level)) {
2916 len += sprintf(p + len, "level:\t\tunreadable\n");
2917 } else {
2918 len += sprintf(p + len, "level:\t\t%d\n", level & 0xf);
2919 len += sprintf(p + len, "mute:\t\t%s\n", onoff(level, 6));
2920 len += sprintf(p + len, "commands:\tup, down, mute\n");
2921 len += sprintf(p + len, "commands:\tlevel <level>"
2922 " (<level> is 0-15)\n");
2923 }
2924
2925 return len;
2926 }
2927
2928 static int volume_write(char *buf)
2929 {
2930 int cmos_cmd, inc, i;
2931 u8 level, mute;
2932 int new_level, new_mute;
2933 char *cmd;
2934
2935 while ((cmd = next_cmd(&buf))) {
2936 if (!acpi_ec_read(volume_offset, &level))
2937 return -EIO;
2938 new_mute = mute = level & 0x40;
2939 new_level = level = level & 0xf;
2940
2941 if (strlencmp(cmd, "up") == 0) {
2942 if (mute)
2943 new_mute = 0;
2944 else
2945 new_level = level == 15 ? 15 : level + 1;
2946 } else if (strlencmp(cmd, "down") == 0) {
2947 if (mute)
2948 new_mute = 0;
2949 else
2950 new_level = level == 0 ? 0 : level - 1;
2951 } else if (sscanf(cmd, "level %d", &new_level) == 1 &&
2952 new_level >= 0 && new_level <= 15) {
2953 /* new_level set */
2954 } else if (strlencmp(cmd, "mute") == 0) {
2955 new_mute = 0x40;
2956 } else
2957 return -EINVAL;
2958
2959 if (new_level != level) { /* mute doesn't change */
2960 cmos_cmd = new_level > level ? TP_CMOS_VOLUME_UP : TP_CMOS_VOLUME_DOWN;
2961 inc = new_level > level ? 1 : -1;
2962
2963 if (mute && (issue_thinkpad_cmos_command(cmos_cmd) ||
2964 !acpi_ec_write(volume_offset, level)))
2965 return -EIO;
2966
2967 for (i = level; i != new_level; i += inc)
2968 if (issue_thinkpad_cmos_command(cmos_cmd) ||
2969 !acpi_ec_write(volume_offset, i + inc))
2970 return -EIO;
2971
2972 if (mute && (issue_thinkpad_cmos_command(TP_CMOS_VOLUME_MUTE) ||
2973 !acpi_ec_write(volume_offset,
2974 new_level + mute)))
2975 return -EIO;
2976 }
2977
2978 if (new_mute != mute) { /* level doesn't change */
2979 cmos_cmd = new_mute ? TP_CMOS_VOLUME_MUTE : TP_CMOS_VOLUME_UP;
2980
2981 if (issue_thinkpad_cmos_command(cmos_cmd) ||
2982 !acpi_ec_write(volume_offset, level + new_mute))
2983 return -EIO;
2984 }
2985 }
2986
2987 return 0;
2988 }
2989
2990 static struct ibm_struct volume_driver_data = {
2991 .name = "volume",
2992 .read = volume_read,
2993 .write = volume_write,
2994 };
2995
2996 /*************************************************************************
2997 * Fan subdriver
2998 */
2999
3000 /*
3001 * FAN ACCESS MODES
3002 *
3003 * TPACPI_FAN_RD_ACPI_GFAN:
3004 * ACPI GFAN method: returns fan level
3005 *
3006 * see TPACPI_FAN_WR_ACPI_SFAN
3007 * EC 0x2f (HFSP) not available if GFAN exists
3008 *
3009 * TPACPI_FAN_WR_ACPI_SFAN:
3010 * ACPI SFAN method: sets fan level, 0 (stop) to 7 (max)
3011 *
3012 * EC 0x2f (HFSP) might be available *for reading*, but do not use
3013 * it for writing.
3014 *
3015 * TPACPI_FAN_WR_TPEC:
3016 * ThinkPad EC register 0x2f (HFSP): fan control loop mode
3017 * Supported on almost all ThinkPads
3018 *
3019 * Fan speed changes of any sort (including those caused by the
3020 * disengaged mode) are usually done slowly by the firmware as the
3021 * maximum ammount of fan duty cycle change per second seems to be
3022 * limited.
3023 *
3024 * Reading is not available if GFAN exists.
3025 * Writing is not available if SFAN exists.
3026 *
3027 * Bits
3028 * 7 automatic mode engaged;
3029 * (default operation mode of the ThinkPad)
3030 * fan level is ignored in this mode.
3031 * 6 full speed mode (takes precedence over bit 7);
3032 * not available on all thinkpads. May disable
3033 * the tachometer while the fan controller ramps up
3034 * the speed (which can take up to a few *minutes*).
3035 * Speeds up fan to 100% duty-cycle, which is far above
3036 * the standard RPM levels. It is not impossible that
3037 * it could cause hardware damage.
3038 * 5-3 unused in some models. Extra bits for fan level
3039 * in others, but still useless as all values above
3040 * 7 map to the same speed as level 7 in these models.
3041 * 2-0 fan level (0..7 usually)
3042 * 0x00 = stop
3043 * 0x07 = max (set when temperatures critical)
3044 * Some ThinkPads may have other levels, see
3045 * TPACPI_FAN_WR_ACPI_FANS (X31/X40/X41)
3046 *
3047 * FIRMWARE BUG: on some models, EC 0x2f might not be initialized at
3048 * boot. Apparently the EC does not intialize it, so unless ACPI DSDT
3049 * does so, its initial value is meaningless (0x07).
3050 *
3051 * For firmware bugs, refer to:
3052 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
3053 *
3054 * ----
3055 *
3056 * ThinkPad EC register 0x84 (LSB), 0x85 (MSB):
3057 * Main fan tachometer reading (in RPM)
3058 *
3059 * This register is present on all ThinkPads with a new-style EC, and
3060 * it is known not to be present on the A21m/e, and T22, as there is
3061 * something else in offset 0x84 according to the ACPI DSDT. Other
3062 * ThinkPads from this same time period (and earlier) probably lack the
3063 * tachometer as well.
3064 *
3065 * Unfortunately a lot of ThinkPads with new-style ECs but whose firwmare
3066 * was never fixed by IBM to report the EC firmware version string
3067 * probably support the tachometer (like the early X models), so
3068 * detecting it is quite hard. We need more data to know for sure.
3069 *
3070 * FIRMWARE BUG: always read 0x84 first, otherwise incorrect readings
3071 * might result.
3072 *
3073 * FIRMWARE BUG: may go stale while the EC is switching to full speed
3074 * mode.
3075 *
3076 * For firmware bugs, refer to:
3077 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
3078 *
3079 * TPACPI_FAN_WR_ACPI_FANS:
3080 * ThinkPad X31, X40, X41. Not available in the X60.
3081 *
3082 * FANS ACPI handle: takes three arguments: low speed, medium speed,
3083 * high speed. ACPI DSDT seems to map these three speeds to levels
3084 * as follows: STOP LOW LOW MED MED HIGH HIGH HIGH HIGH
3085 * (this map is stored on FAN0..FAN8 as "0,1,1,2,2,3,3,3,3")
3086 *
3087 * The speeds are stored on handles
3088 * (FANA:FAN9), (FANC:FANB), (FANE:FAND).
3089 *
3090 * There are three default speed sets, acessible as handles:
3091 * FS1L,FS1M,FS1H; FS2L,FS2M,FS2H; FS3L,FS3M,FS3H
3092 *
3093 * ACPI DSDT switches which set is in use depending on various
3094 * factors.
3095 *
3096 * TPACPI_FAN_WR_TPEC is also available and should be used to
3097 * command the fan. The X31/X40/X41 seems to have 8 fan levels,
3098 * but the ACPI tables just mention level 7.
3099 */
3100
3101 static enum fan_status_access_mode fan_status_access_mode;
3102 static enum fan_control_access_mode fan_control_access_mode;
3103 static enum fan_control_commands fan_control_commands;
3104
3105 static u8 fan_control_initial_status;
3106 static u8 fan_control_desired_level;
3107
3108 static void fan_watchdog_fire(struct work_struct *ignored);
3109 static int fan_watchdog_maxinterval;
3110 static DECLARE_DELAYED_WORK(fan_watchdog_task, fan_watchdog_fire);
3111
3112 IBM_HANDLE(fans, ec, "FANS"); /* X31, X40, X41 */
3113 IBM_HANDLE(gfan, ec, "GFAN", /* 570 */
3114 "\\FSPD", /* 600e/x, 770e, 770x */
3115 ); /* all others */
3116 IBM_HANDLE(sfan, ec, "SFAN", /* 570 */
3117 "JFNS", /* 770x-JL */
3118 ); /* all others */
3119
3120 /*
3121 * SYSFS fan layout: hwmon compatible (device)
3122 *
3123 * pwm*_enable:
3124 * 0: "disengaged" mode
3125 * 1: manual mode
3126 * 2: native EC "auto" mode (recommended, hardware default)
3127 *
3128 * pwm*: set speed in manual mode, ignored otherwise.
3129 * 0 is level 0; 255 is level 7. Intermediate points done with linear
3130 * interpolation.
3131 *
3132 * fan*_input: tachometer reading, RPM
3133 *
3134 *
3135 * SYSFS fan layout: extensions
3136 *
3137 * fan_watchdog (driver):
3138 * fan watchdog interval in seconds, 0 disables (default), max 120
3139 */
3140
3141 /* sysfs fan pwm1_enable ----------------------------------------------- */
3142 static ssize_t fan_pwm1_enable_show(struct device *dev,
3143 struct device_attribute *attr,
3144 char *buf)
3145 {
3146 int res, mode;
3147 u8 status;
3148
3149 res = fan_get_status_safe(&status);
3150 if (res)
3151 return res;
3152
3153 if (unlikely(tp_features.fan_ctrl_status_undef)) {
3154 if (status != fan_control_initial_status) {
3155 tp_features.fan_ctrl_status_undef = 0;
3156 } else {
3157 /* Return most likely status. In fact, it
3158 * might be the only possible status */
3159 status = TP_EC_FAN_AUTO;
3160 }
3161 }
3162
3163 if (status & TP_EC_FAN_FULLSPEED) {
3164 mode = 0;
3165 } else if (status & TP_EC_FAN_AUTO) {
3166 mode = 2;
3167 } else
3168 mode = 1;
3169
3170 return snprintf(buf, PAGE_SIZE, "%d\n", mode);
3171 }
3172
3173 static ssize_t fan_pwm1_enable_store(struct device *dev,
3174 struct device_attribute *attr,
3175 const char *buf, size_t count)
3176 {
3177 unsigned long t;
3178 int res, level;
3179
3180 if (parse_strtoul(buf, 2, &t))
3181 return -EINVAL;
3182
3183 switch (t) {
3184 case 0:
3185 level = TP_EC_FAN_FULLSPEED;
3186 break;
3187 case 1:
3188 level = TPACPI_FAN_LAST_LEVEL;
3189 break;
3190 case 2:
3191 level = TP_EC_FAN_AUTO;
3192 break;
3193 case 3:
3194 /* reserved for software-controlled auto mode */
3195 return -ENOSYS;
3196 default:
3197 return -EINVAL;
3198 }
3199
3200 res = fan_set_level_safe(level);
3201 if (res == -ENXIO)
3202 return -EINVAL;
3203 else if (res < 0)
3204 return res;
3205
3206 fan_watchdog_reset();
3207
3208 return count;
3209 }
3210
3211 static struct device_attribute dev_attr_fan_pwm1_enable =
3212 __ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
3213 fan_pwm1_enable_show, fan_pwm1_enable_store);
3214
3215 /* sysfs fan pwm1 ------------------------------------------------------ */
3216 static ssize_t fan_pwm1_show(struct device *dev,
3217 struct device_attribute *attr,
3218 char *buf)
3219 {
3220 int res;
3221 u8 status;
3222
3223 res = fan_get_status_safe(&status);
3224 if (res)
3225 return res;
3226
3227 if (unlikely(tp_features.fan_ctrl_status_undef)) {
3228 if (status != fan_control_initial_status) {
3229 tp_features.fan_ctrl_status_undef = 0;
3230 } else {
3231 status = TP_EC_FAN_AUTO;
3232 }
3233 }
3234
3235 if ((status &
3236 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) != 0)
3237 status = fan_control_desired_level;
3238
3239 if (status > 7)
3240 status = 7;
3241
3242 return snprintf(buf, PAGE_SIZE, "%u\n", (status * 255) / 7);
3243 }
3244
3245 static ssize_t fan_pwm1_store(struct device *dev,
3246 struct device_attribute *attr,
3247 const char *buf, size_t count)
3248 {
3249 unsigned long s;
3250 int rc;
3251 u8 status, newlevel;
3252
3253 if (parse_strtoul(buf, 255, &s))
3254 return -EINVAL;
3255
3256 /* scale down from 0-255 to 0-7 */
3257 newlevel = (s >> 5) & 0x07;
3258
3259 rc = mutex_lock_interruptible(&fan_mutex);
3260 if (rc < 0)
3261 return rc;
3262
3263 rc = fan_get_status(&status);
3264 if (!rc && (status &
3265 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) {
3266 rc = fan_set_level(newlevel);
3267 if (rc == -ENXIO)
3268 rc = -EINVAL;
3269 else if (!rc) {
3270 fan_update_desired_level(newlevel);
3271 fan_watchdog_reset();
3272 }
3273 }
3274
3275 mutex_unlock(&fan_mutex);
3276 return (rc)? rc : count;
3277 }
3278
3279 static struct device_attribute dev_attr_fan_pwm1 =
3280 __ATTR(pwm1, S_IWUSR | S_IRUGO,
3281 fan_pwm1_show, fan_pwm1_store);
3282
3283 /* sysfs fan fan1_input ------------------------------------------------ */
3284 static ssize_t fan_fan1_input_show(struct device *dev,
3285 struct device_attribute *attr,
3286 char *buf)
3287 {
3288 int res;
3289 unsigned int speed;
3290
3291 res = fan_get_speed(&speed);
3292 if (res < 0)
3293 return res;
3294
3295 return snprintf(buf, PAGE_SIZE, "%u\n", speed);
3296 }
3297
3298 static struct device_attribute dev_attr_fan_fan1_input =
3299 __ATTR(fan1_input, S_IRUGO,
3300 fan_fan1_input_show, NULL);
3301
3302 /* sysfs fan fan_watchdog (driver) ------------------------------------- */
3303 static ssize_t fan_fan_watchdog_show(struct device_driver *drv,
3304 char *buf)
3305 {
3306 return snprintf(buf, PAGE_SIZE, "%u\n", fan_watchdog_maxinterval);
3307 }
3308
3309 static ssize_t fan_fan_watchdog_store(struct device_driver *drv,
3310 const char *buf, size_t count)
3311 {
3312 unsigned long t;
3313
3314 if (parse_strtoul(buf, 120, &t))
3315 return -EINVAL;
3316
3317 if (!fan_control_allowed)
3318 return -EPERM;
3319
3320 fan_watchdog_maxinterval = t;
3321 fan_watchdog_reset();
3322
3323 return count;
3324 }
3325
3326 static DRIVER_ATTR(fan_watchdog, S_IWUSR | S_IRUGO,
3327 fan_fan_watchdog_show, fan_fan_watchdog_store);
3328
3329 /* --------------------------------------------------------------------- */
3330 static struct attribute *fan_attributes[] = {
3331 &dev_attr_fan_pwm1_enable.attr, &dev_attr_fan_pwm1.attr,
3332 &dev_attr_fan_fan1_input.attr,
3333 NULL
3334 };
3335
3336 static const struct attribute_group fan_attr_group = {
3337 .attrs = fan_attributes,
3338 };
3339
3340 static int __init fan_init(struct ibm_init_struct *iibm)
3341 {
3342 int rc;
3343
3344 vdbg_printk(TPACPI_DBG_INIT, "initializing fan subdriver\n");
3345
3346 mutex_init(&fan_mutex);
3347 fan_status_access_mode = TPACPI_FAN_NONE;
3348 fan_control_access_mode = TPACPI_FAN_WR_NONE;
3349 fan_control_commands = 0;
3350 fan_watchdog_maxinterval = 0;
3351 tp_features.fan_ctrl_status_undef = 0;
3352 fan_control_desired_level = 7;
3353
3354 IBM_ACPIHANDLE_INIT(fans);
3355 IBM_ACPIHANDLE_INIT(gfan);
3356 IBM_ACPIHANDLE_INIT(sfan);
3357
3358 if (gfan_handle) {
3359 /* 570, 600e/x, 770e, 770x */
3360 fan_status_access_mode = TPACPI_FAN_RD_ACPI_GFAN;
3361 } else {
3362 /* all other ThinkPads: note that even old-style
3363 * ThinkPad ECs supports the fan control register */
3364 if (likely(acpi_ec_read(fan_status_offset,
3365 &fan_control_initial_status))) {
3366 fan_status_access_mode = TPACPI_FAN_RD_TPEC;
3367
3368 /* In some ThinkPads, neither the EC nor the ACPI
3369 * DSDT initialize the fan status, and it ends up
3370 * being set to 0x07 when it *could* be either
3371 * 0x07 or 0x80.
3372 *
3373 * Enable for TP-1Y (T43), TP-78 (R51e),
3374 * TP-76 (R52), TP-70 (T43, R52), which are known
3375 * to be buggy. */
3376 if (fan_control_initial_status == 0x07 &&
3377 ibm_thinkpad_ec_found &&
3378 ((ibm_thinkpad_ec_found[0] == '1' &&
3379 ibm_thinkpad_ec_found[1] == 'Y') ||
3380 (ibm_thinkpad_ec_found[0] == '7' &&
3381 (ibm_thinkpad_ec_found[1] == '6' ||
3382 ibm_thinkpad_ec_found[1] == '8' ||
3383 ibm_thinkpad_ec_found[1] == '0'))
3384 )) {
3385 printk(IBM_NOTICE
3386 "fan_init: initial fan status is "
3387 "unknown, assuming it is in auto "
3388 "mode\n");
3389 tp_features.fan_ctrl_status_undef = 1;
3390 }
3391 } else {
3392 printk(IBM_ERR
3393 "ThinkPad ACPI EC access misbehaving, "
3394 "fan status and control unavailable\n");
3395 return 1;
3396 }
3397 }
3398
3399 if (sfan_handle) {
3400 /* 570, 770x-JL */
3401 fan_control_access_mode = TPACPI_FAN_WR_ACPI_SFAN;
3402 fan_control_commands |=
3403 TPACPI_FAN_CMD_LEVEL | TPACPI_FAN_CMD_ENABLE;
3404 } else {
3405 if (!gfan_handle) {
3406 /* gfan without sfan means no fan control */
3407 /* all other models implement TP EC 0x2f control */
3408
3409 if (fans_handle) {
3410 /* X31, X40, X41 */
3411 fan_control_access_mode =
3412 TPACPI_FAN_WR_ACPI_FANS;
3413 fan_control_commands |=
3414 TPACPI_FAN_CMD_SPEED |
3415 TPACPI_FAN_CMD_LEVEL |
3416 TPACPI_FAN_CMD_ENABLE;
3417 } else {
3418 fan_control_access_mode = TPACPI_FAN_WR_TPEC;
3419 fan_control_commands |=
3420 TPACPI_FAN_CMD_LEVEL |
3421 TPACPI_FAN_CMD_ENABLE;
3422 }
3423 }
3424 }
3425
3426 vdbg_printk(TPACPI_DBG_INIT, "fan is %s, modes %d, %d\n",
3427 str_supported(fan_status_access_mode != TPACPI_FAN_NONE ||
3428 fan_control_access_mode != TPACPI_FAN_WR_NONE),
3429 fan_status_access_mode, fan_control_access_mode);
3430
3431 /* fan control master switch */
3432 if (!fan_control_allowed) {
3433 fan_control_access_mode = TPACPI_FAN_WR_NONE;
3434 fan_control_commands = 0;
3435 dbg_printk(TPACPI_DBG_INIT,
3436 "fan control features disabled by parameter\n");
3437 }
3438
3439 /* update fan_control_desired_level */
3440 if (fan_status_access_mode != TPACPI_FAN_NONE)
3441 fan_get_status_safe(NULL);
3442
3443 if (fan_status_access_mode != TPACPI_FAN_NONE ||
3444 fan_control_access_mode != TPACPI_FAN_WR_NONE) {
3445 rc = sysfs_create_group(&tpacpi_pdev->dev.kobj,
3446 &fan_attr_group);
3447 if (!(rc < 0))
3448 rc = driver_create_file(&tpacpi_pdriver.driver,
3449 &driver_attr_fan_watchdog);
3450 if (rc < 0)
3451 return rc;
3452 return 0;
3453 } else
3454 return 1;
3455 }
3456
3457 /*
3458 * Call with fan_mutex held
3459 */
3460 static void fan_update_desired_level(u8 status)
3461 {
3462 if ((status &
3463 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) {
3464 if (status > 7)
3465 fan_control_desired_level = 7;
3466 else
3467 fan_control_desired_level = status;
3468 }
3469 }
3470
3471 static int fan_get_status(u8 *status)
3472 {
3473 u8 s;
3474
3475 /* TODO:
3476 * Add TPACPI_FAN_RD_ACPI_FANS ? */
3477
3478 switch (fan_status_access_mode) {
3479 case TPACPI_FAN_RD_ACPI_GFAN:
3480 /* 570, 600e/x, 770e, 770x */
3481
3482 if (unlikely(!acpi_evalf(gfan_handle, &s, NULL, "d")))
3483 return -EIO;
3484
3485 if (likely(status))
3486 *status = s & 0x07;
3487
3488 break;
3489
3490 case TPACPI_FAN_RD_TPEC:
3491 /* all except 570, 600e/x, 770e, 770x */
3492 if (unlikely(!acpi_ec_read(fan_status_offset, &s)))
3493 return -EIO;
3494
3495 if (likely(status))
3496 *status = s;
3497
3498 break;
3499
3500 default:
3501 return -ENXIO;
3502 }
3503
3504 return 0;
3505 }
3506
3507 static int fan_get_status_safe(u8 *status)
3508 {
3509 int rc;
3510 u8 s;
3511
3512 rc = mutex_lock_interruptible(&fan_mutex);
3513 if (rc < 0)
3514 return rc;
3515 rc = fan_get_status(&s);
3516 if (!rc)
3517 fan_update_desired_level(s);
3518 mutex_unlock(&fan_mutex);
3519
3520 if (status)
3521 *status = s;
3522
3523 return rc;
3524 }
3525
3526 static void fan_exit(void)
3527 {
3528 vdbg_printk(TPACPI_DBG_EXIT, "cancelling any pending fan watchdog tasks\n");
3529
3530 /* FIXME: can we really do this unconditionally? */
3531 sysfs_remove_group(&tpacpi_pdev->dev.kobj, &fan_attr_group);
3532 driver_remove_file(&tpacpi_pdriver.driver, &driver_attr_fan_watchdog);
3533
3534 cancel_delayed_work(&fan_watchdog_task);
3535 flush_scheduled_work();
3536 }
3537
3538 static int fan_get_speed(unsigned int *speed)
3539 {
3540 u8 hi, lo;
3541
3542 switch (fan_status_access_mode) {
3543 case TPACPI_FAN_RD_TPEC:
3544 /* all except 570, 600e/x, 770e, 770x */
3545 if (unlikely(!acpi_ec_read(fan_rpm_offset, &lo) ||
3546 !acpi_ec_read(fan_rpm_offset + 1, &hi)))
3547 return -EIO;
3548
3549 if (likely(speed))
3550 *speed = (hi << 8) | lo;
3551
3552 break;
3553
3554 default:
3555 return -ENXIO;
3556 }
3557
3558 return 0;
3559 }
3560
3561 static void fan_watchdog_fire(struct work_struct *ignored)
3562 {
3563 int rc;
3564
3565 printk(IBM_NOTICE "fan watchdog: enabling fan\n");
3566 rc = fan_set_enable();
3567 if (rc < 0) {
3568 printk(IBM_ERR "fan watchdog: error %d while enabling fan, "
3569 "will try again later...\n", -rc);
3570 /* reschedule for later */
3571 fan_watchdog_reset();
3572 }
3573 }
3574
3575 static void fan_watchdog_reset(void)
3576 {
3577 static int fan_watchdog_active;
3578
3579 if (fan_control_access_mode == TPACPI_FAN_WR_NONE)
3580 return;
3581
3582 if (fan_watchdog_active)
3583 cancel_delayed_work(&fan_watchdog_task);
3584
3585 if (fan_watchdog_maxinterval > 0) {
3586 fan_watchdog_active = 1;
3587 if (!schedule_delayed_work(&fan_watchdog_task,
3588 msecs_to_jiffies(fan_watchdog_maxinterval
3589 * 1000))) {
3590 printk(IBM_ERR "failed to schedule the fan watchdog, "
3591 "watchdog will not trigger\n");
3592 }
3593 } else
3594 fan_watchdog_active = 0;
3595 }
3596
3597 static int fan_set_level(int level)
3598 {
3599 if (!fan_control_allowed)
3600 return -EPERM;
3601
3602 switch (fan_control_access_mode) {
3603 case TPACPI_FAN_WR_ACPI_SFAN:
3604 if (level >= 0 && level <= 7) {
3605 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", level))
3606 return -EIO;
3607 } else
3608 return -EINVAL;
3609 break;
3610
3611 case TPACPI_FAN_WR_ACPI_FANS:
3612 case TPACPI_FAN_WR_TPEC:
3613 if ((level != TP_EC_FAN_AUTO) &&
3614 (level != TP_EC_FAN_FULLSPEED) &&
3615 ((level < 0) || (level > 7)))
3616 return -EINVAL;
3617
3618 /* safety net should the EC not support AUTO
3619 * or FULLSPEED mode bits and just ignore them */
3620 if (level & TP_EC_FAN_FULLSPEED)
3621 level |= 7; /* safety min speed 7 */
3622 else if (level & TP_EC_FAN_FULLSPEED)
3623 level |= 4; /* safety min speed 4 */
3624
3625 if (!acpi_ec_write(fan_status_offset, level))
3626 return -EIO;
3627 else
3628 tp_features.fan_ctrl_status_undef = 0;
3629 break;
3630
3631 default:
3632 return -ENXIO;
3633 }
3634 return 0;
3635 }
3636
3637 static int fan_set_level_safe(int level)
3638 {
3639 int rc;
3640
3641 if (!fan_control_allowed)
3642 return -EPERM;
3643
3644 rc = mutex_lock_interruptible(&fan_mutex);
3645 if (rc < 0)
3646 return rc;
3647
3648 if (level == TPACPI_FAN_LAST_LEVEL)
3649 level = fan_control_desired_level;
3650
3651 rc = fan_set_level(level);
3652 if (!rc)
3653 fan_update_desired_level(level);
3654
3655 mutex_unlock(&fan_mutex);
3656 return rc;
3657 }
3658
3659 static int fan_set_enable(void)
3660 {
3661 u8 s;
3662 int rc;
3663
3664 if (!fan_control_allowed)
3665 return -EPERM;
3666
3667 rc = mutex_lock_interruptible(&fan_mutex);
3668 if (rc < 0)
3669 return rc;
3670
3671 switch (fan_control_access_mode) {
3672 case TPACPI_FAN_WR_ACPI_FANS:
3673 case TPACPI_FAN_WR_TPEC:
3674 rc = fan_get_status(&s);
3675 if (rc < 0)
3676 break;
3677
3678 /* Don't go out of emergency fan mode */
3679 if (s != 7) {
3680 s &= 0x07;
3681 s |= TP_EC_FAN_AUTO | 4; /* min fan speed 4 */
3682 }
3683
3684 if (!acpi_ec_write(fan_status_offset, s))
3685 rc = -EIO;
3686 else {
3687 tp_features.fan_ctrl_status_undef = 0;
3688 rc = 0;
3689 }
3690 break;
3691
3692 case TPACPI_FAN_WR_ACPI_SFAN:
3693 rc = fan_get_status(&s);
3694 if (rc < 0)
3695 break;
3696
3697 s &= 0x07;
3698
3699 /* Set fan to at least level 4 */
3700 s |= 4;
3701
3702 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", s))
3703 rc= -EIO;
3704 else
3705 rc = 0;
3706 break;
3707
3708 default:
3709 rc = -ENXIO;
3710 }
3711
3712 mutex_unlock(&fan_mutex);
3713 return rc;
3714 }
3715
3716 static int fan_set_disable(void)
3717 {
3718 int rc;
3719
3720 if (!fan_control_allowed)
3721 return -EPERM;
3722
3723 rc = mutex_lock_interruptible(&fan_mutex);
3724 if (rc < 0)
3725 return rc;
3726
3727 rc = 0;
3728 switch (fan_control_access_mode) {
3729 case TPACPI_FAN_WR_ACPI_FANS:
3730 case TPACPI_FAN_WR_TPEC:
3731 if (!acpi_ec_write(fan_status_offset, 0x00))
3732 rc = -EIO;
3733 else {
3734 fan_control_desired_level = 0;
3735 tp_features.fan_ctrl_status_undef = 0;
3736 }
3737 break;
3738
3739 case TPACPI_FAN_WR_ACPI_SFAN:
3740 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", 0x00))
3741 rc = -EIO;
3742 else
3743 fan_control_desired_level = 0;
3744 break;
3745
3746 default:
3747 rc = -ENXIO;
3748 }
3749
3750
3751 mutex_unlock(&fan_mutex);
3752 return rc;
3753 }
3754
3755 static int fan_set_speed(int speed)
3756 {
3757 int rc;
3758
3759 if (!fan_control_allowed)
3760 return -EPERM;
3761
3762 rc = mutex_lock_interruptible(&fan_mutex);
3763 if (rc < 0)
3764 return rc;
3765
3766 rc = 0;
3767 switch (fan_control_access_mode) {
3768 case TPACPI_FAN_WR_ACPI_FANS:
3769 if (speed >= 0 && speed <= 65535) {
3770 if (!acpi_evalf(fans_handle, NULL, NULL, "vddd",
3771 speed, speed, speed))
3772 rc = -EIO;
3773 } else
3774 rc = -EINVAL;
3775 break;
3776
3777 default:
3778 rc = -ENXIO;
3779 }
3780
3781 mutex_unlock(&fan_mutex);
3782 return rc;
3783 }
3784
3785 static int fan_read(char *p)
3786 {
3787 int len = 0;
3788 int rc;
3789 u8 status;
3790 unsigned int speed = 0;
3791
3792 switch (fan_status_access_mode) {
3793 case TPACPI_FAN_RD_ACPI_GFAN:
3794 /* 570, 600e/x, 770e, 770x */
3795 if ((rc = fan_get_status_safe(&status)) < 0)
3796 return rc;
3797
3798 len += sprintf(p + len, "status:\t\t%s\n"
3799 "level:\t\t%d\n",
3800 (status != 0) ? "enabled" : "disabled", status);
3801 break;
3802
3803 case TPACPI_FAN_RD_TPEC:
3804 /* all except 570, 600e/x, 770e, 770x */
3805 if ((rc = fan_get_status_safe(&status)) < 0)
3806 return rc;
3807
3808 if (unlikely(tp_features.fan_ctrl_status_undef)) {
3809 if (status != fan_control_initial_status)
3810 tp_features.fan_ctrl_status_undef = 0;
3811 else
3812 /* Return most likely status. In fact, it
3813 * might be the only possible status */
3814 status = TP_EC_FAN_AUTO;
3815 }
3816
3817 len += sprintf(p + len, "status:\t\t%s\n",
3818 (status != 0) ? "enabled" : "disabled");
3819
3820 if ((rc = fan_get_speed(&speed)) < 0)
3821 return rc;
3822
3823 len += sprintf(p + len, "speed:\t\t%d\n", speed);
3824
3825 if (status & TP_EC_FAN_FULLSPEED)
3826 /* Disengaged mode takes precedence */
3827 len += sprintf(p + len, "level:\t\tdisengaged\n");
3828 else if (status & TP_EC_FAN_AUTO)
3829 len += sprintf(p + len, "level:\t\tauto\n");
3830 else
3831 len += sprintf(p + len, "level:\t\t%d\n", status);
3832 break;
3833
3834 case TPACPI_FAN_NONE:
3835 default:
3836 len += sprintf(p + len, "status:\t\tnot supported\n");
3837 }
3838
3839 if (fan_control_commands & TPACPI_FAN_CMD_LEVEL) {
3840 len += sprintf(p + len, "commands:\tlevel <level>");
3841
3842 switch (fan_control_access_mode) {
3843 case TPACPI_FAN_WR_ACPI_SFAN:
3844 len += sprintf(p + len, " (<level> is 0-7)\n");
3845 break;
3846
3847 default:
3848 len += sprintf(p + len, " (<level> is 0-7, "
3849 "auto, disengaged, full-speed)\n");
3850 break;
3851 }
3852 }
3853
3854 if (fan_control_commands & TPACPI_FAN_CMD_ENABLE)
3855 len += sprintf(p + len, "commands:\tenable, disable\n"
3856 "commands:\twatchdog <timeout> (<timeout> is 0 (off), "
3857 "1-120 (seconds))\n");
3858
3859 if (fan_control_commands & TPACPI_FAN_CMD_SPEED)
3860 len += sprintf(p + len, "commands:\tspeed <speed>"
3861 " (<speed> is 0-65535)\n");
3862
3863 return len;
3864 }
3865
3866 static int fan_write_cmd_level(const char *cmd, int *rc)
3867 {
3868 int level;
3869
3870 if (strlencmp(cmd, "level auto") == 0)
3871 level = TP_EC_FAN_AUTO;
3872 else if ((strlencmp(cmd, "level disengaged") == 0) |
3873 (strlencmp(cmd, "level full-speed") == 0))
3874 level = TP_EC_FAN_FULLSPEED;
3875 else if (sscanf(cmd, "level %d", &level) != 1)
3876 return 0;
3877
3878 if ((*rc = fan_set_level_safe(level)) == -ENXIO)
3879 printk(IBM_ERR "level command accepted for unsupported "
3880 "access mode %d", fan_control_access_mode);
3881
3882 return 1;
3883 }
3884
3885 static int fan_write_cmd_enable(const char *cmd, int *rc)
3886 {
3887 if (strlencmp(cmd, "enable") != 0)
3888 return 0;
3889
3890 if ((*rc = fan_set_enable()) == -ENXIO)
3891 printk(IBM_ERR "enable command accepted for unsupported "
3892 "access mode %d", fan_control_access_mode);
3893
3894 return 1;
3895 }
3896
3897 static int fan_write_cmd_disable(const char *cmd, int *rc)
3898 {
3899 if (strlencmp(cmd, "disable") != 0)
3900 return 0;
3901
3902 if ((*rc = fan_set_disable()) == -ENXIO)
3903 printk(IBM_ERR "disable command accepted for unsupported "
3904 "access mode %d", fan_control_access_mode);
3905
3906 return 1;
3907 }
3908
3909 static int fan_write_cmd_speed(const char *cmd, int *rc)
3910 {
3911 int speed;
3912
3913 /* TODO:
3914 * Support speed <low> <medium> <high> ? */
3915
3916 if (sscanf(cmd, "speed %d", &speed) != 1)
3917 return 0;
3918
3919 if ((*rc = fan_set_speed(speed)) == -ENXIO)
3920 printk(IBM_ERR "speed command accepted for unsupported "
3921 "access mode %d", fan_control_access_mode);
3922
3923 return 1;
3924 }
3925
3926 static int fan_write_cmd_watchdog(const char *cmd, int *rc)
3927 {
3928 int interval;
3929
3930 if (sscanf(cmd, "watchdog %d", &interval) != 1)
3931 return 0;
3932
3933 if (interval < 0 || interval > 120)
3934 *rc = -EINVAL;
3935 else
3936 fan_watchdog_maxinterval = interval;
3937
3938 return 1;
3939 }
3940
3941 static int fan_write(char *buf)
3942 {
3943 char *cmd;
3944 int rc = 0;
3945
3946 while (!rc && (cmd = next_cmd(&buf))) {
3947 if (!((fan_control_commands & TPACPI_FAN_CMD_LEVEL) &&
3948 fan_write_cmd_level(cmd, &rc)) &&
3949 !((fan_control_commands & TPACPI_FAN_CMD_ENABLE) &&
3950 (fan_write_cmd_enable(cmd, &rc) ||
3951 fan_write_cmd_disable(cmd, &rc) ||
3952 fan_write_cmd_watchdog(cmd, &rc))) &&
3953 !((fan_control_commands & TPACPI_FAN_CMD_SPEED) &&
3954 fan_write_cmd_speed(cmd, &rc))
3955 )
3956 rc = -EINVAL;
3957 else if (!rc)
3958 fan_watchdog_reset();
3959 }
3960
3961 return rc;
3962 }
3963
3964 static struct ibm_struct fan_driver_data = {
3965 .name = "fan",
3966 .read = fan_read,
3967 .write = fan_write,
3968 .exit = fan_exit,
3969 };
3970
3971 /****************************************************************************
3972 ****************************************************************************
3973 *
3974 * Infrastructure
3975 *
3976 ****************************************************************************
3977 ****************************************************************************/
3978
3979 /* /proc support */
3980 static struct proc_dir_entry *proc_dir;
3981
3982 /* Subdriver registry */
3983 static LIST_HEAD(tpacpi_all_drivers);
3984
3985
3986 /*
3987 * Module and infrastructure proble, init and exit handling
3988 */
3989
3990 #ifdef CONFIG_THINKPAD_ACPI_DEBUG
3991 static const char * __init str_supported(int is_supported)
3992 {
3993 static char text_unsupported[] __initdata = "not supported";
3994
3995 return (is_supported)? &text_unsupported[4] : &text_unsupported[0];
3996 }
3997 #endif /* CONFIG_THINKPAD_ACPI_DEBUG */
3998
3999 static int __init ibm_init(struct ibm_init_struct *iibm)
4000 {
4001 int ret;
4002 struct ibm_struct *ibm = iibm->data;
4003 struct proc_dir_entry *entry;
4004
4005 BUG_ON(ibm == NULL);
4006
4007 INIT_LIST_HEAD(&ibm->all_drivers);
4008
4009 if (ibm->flags.experimental && !experimental)
4010 return 0;
4011
4012 dbg_printk(TPACPI_DBG_INIT,
4013 "probing for %s\n", ibm->name);
4014
4015 if (iibm->init) {
4016 ret = iibm->init(iibm);
4017 if (ret > 0)
4018 return 0; /* probe failed */
4019 if (ret)
4020 return ret;
4021
4022 ibm->flags.init_called = 1;
4023 }
4024
4025 if (ibm->acpi) {
4026 if (ibm->acpi->hid) {
4027 ret = register_tpacpi_subdriver(ibm);
4028 if (ret)
4029 goto err_out;
4030 }
4031
4032 if (ibm->acpi->notify) {
4033 ret = setup_acpi_notify(ibm);
4034 if (ret == -ENODEV) {
4035 printk(IBM_NOTICE "disabling subdriver %s\n",
4036 ibm->name);
4037 ret = 0;
4038 goto err_out;
4039 }
4040 if (ret < 0)
4041 goto err_out;
4042 }
4043 }
4044
4045 dbg_printk(TPACPI_DBG_INIT,
4046 "%s installed\n", ibm->name);
4047
4048 if (ibm->read) {
4049 entry = create_proc_entry(ibm->name,
4050 S_IFREG | S_IRUGO | S_IWUSR,
4051 proc_dir);
4052 if (!entry) {
4053 printk(IBM_ERR "unable to create proc entry %s\n",
4054 ibm->name);
4055 ret = -ENODEV;
4056 goto err_out;
4057 }
4058 entry->owner = THIS_MODULE;
4059 entry->data = ibm;
4060 entry->read_proc = &dispatch_procfs_read;
4061 if (ibm->write)
4062 entry->write_proc = &dispatch_procfs_write;
4063 ibm->flags.proc_created = 1;
4064 }
4065
4066 list_add_tail(&ibm->all_drivers, &tpacpi_all_drivers);
4067
4068 return 0;
4069
4070 err_out:
4071 dbg_printk(TPACPI_DBG_INIT,
4072 "%s: at error exit path with result %d\n",
4073 ibm->name, ret);
4074
4075 ibm_exit(ibm);
4076 return (ret < 0)? ret : 0;
4077 }
4078
4079 static void ibm_exit(struct ibm_struct *ibm)
4080 {
4081 dbg_printk(TPACPI_DBG_EXIT, "removing %s\n", ibm->name);
4082
4083 list_del_init(&ibm->all_drivers);
4084
4085 if (ibm->flags.acpi_notify_installed) {
4086 dbg_printk(TPACPI_DBG_EXIT,
4087 "%s: acpi_remove_notify_handler\n", ibm->name);
4088 BUG_ON(!ibm->acpi);
4089 acpi_remove_notify_handler(*ibm->acpi->handle,
4090 ibm->acpi->type,
4091 dispatch_acpi_notify);
4092 ibm->flags.acpi_notify_installed = 0;
4093 ibm->flags.acpi_notify_installed = 0;
4094 }
4095
4096 if (ibm->flags.proc_created) {
4097 dbg_printk(TPACPI_DBG_EXIT,
4098 "%s: remove_proc_entry\n", ibm->name);
4099 remove_proc_entry(ibm->name, proc_dir);
4100 ibm->flags.proc_created = 0;
4101 }
4102
4103 if (ibm->flags.acpi_driver_registered) {
4104 dbg_printk(TPACPI_DBG_EXIT,
4105 "%s: acpi_bus_unregister_driver\n", ibm->name);
4106 BUG_ON(!ibm->acpi);
4107 acpi_bus_unregister_driver(ibm->acpi->driver);
4108 kfree(ibm->acpi->driver);
4109 ibm->acpi->driver = NULL;
4110 ibm->flags.acpi_driver_registered = 0;
4111 }
4112
4113 if (ibm->flags.init_called && ibm->exit) {
4114 ibm->exit();
4115 ibm->flags.init_called = 0;
4116 }
4117
4118 dbg_printk(TPACPI_DBG_INIT, "finished removing %s\n", ibm->name);
4119 }
4120
4121 /* Probing */
4122
4123 static char *ibm_thinkpad_ec_found;
4124
4125 static char* __init check_dmi_for_ec(void)
4126 {
4127 struct dmi_device *dev = NULL;
4128 char ec_fw_string[18];
4129
4130 /*
4131 * ThinkPad T23 or newer, A31 or newer, R50e or newer,
4132 * X32 or newer, all Z series; Some models must have an
4133 * up-to-date BIOS or they will not be detected.
4134 *
4135 * See http://thinkwiki.org/wiki/List_of_DMI_IDs
4136 */
4137 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
4138 if (sscanf(dev->name,
4139 "IBM ThinkPad Embedded Controller -[%17c",
4140 ec_fw_string) == 1) {
4141 ec_fw_string[sizeof(ec_fw_string) - 1] = 0;
4142 ec_fw_string[strcspn(ec_fw_string, " ]")] = 0;
4143 return kstrdup(ec_fw_string, GFP_KERNEL);
4144 }
4145 }
4146 return NULL;
4147 }
4148
4149 static int __init probe_for_thinkpad(void)
4150 {
4151 int is_thinkpad;
4152
4153 if (acpi_disabled)
4154 return -ENODEV;
4155
4156 /*
4157 * Non-ancient models have better DMI tagging, but very old models
4158 * don't.
4159 */
4160 is_thinkpad = dmi_name_in_vendors("ThinkPad");
4161
4162 /* ec is required because many other handles are relative to it */
4163 IBM_ACPIHANDLE_INIT(ec);
4164 if (!ec_handle) {
4165 if (is_thinkpad)
4166 printk(IBM_ERR
4167 "Not yet supported ThinkPad detected!\n");
4168 return -ENODEV;
4169 }
4170
4171 /*
4172 * Risks a regression on very old machines, but reduces potential
4173 * false positives a damn great deal
4174 */
4175 if (!is_thinkpad)
4176 is_thinkpad = dmi_name_in_vendors("IBM");
4177
4178 if (!is_thinkpad && !force_load)
4179 return -ENODEV;
4180
4181 return 0;
4182 }
4183
4184
4185 /* Module init, exit, parameters */
4186
4187 static struct ibm_init_struct ibms_init[] __initdata = {
4188 {
4189 .init = thinkpad_acpi_driver_init,
4190 .data = &thinkpad_acpi_driver_data,
4191 },
4192 {
4193 .init = hotkey_init,
4194 .data = &hotkey_driver_data,
4195 },
4196 {
4197 .init = bluetooth_init,
4198 .data = &bluetooth_driver_data,
4199 },
4200 {
4201 .init = wan_init,
4202 .data = &wan_driver_data,
4203 },
4204 {
4205 .init = video_init,
4206 .data = &video_driver_data,
4207 },
4208 {
4209 .init = light_init,
4210 .data = &light_driver_data,
4211 },
4212 #ifdef CONFIG_THINKPAD_ACPI_DOCK
4213 {
4214 .init = dock_init,
4215 .data = &dock_driver_data[0],
4216 },
4217 {
4218 .init = dock_init2,
4219 .data = &dock_driver_data[1],
4220 },
4221 #endif
4222 #ifdef CONFIG_THINKPAD_ACPI_BAY
4223 {
4224 .init = bay_init,
4225 .data = &bay_driver_data,
4226 },
4227 #endif
4228 {
4229 .init = cmos_init,
4230 .data = &cmos_driver_data,
4231 },
4232 {
4233 .init = led_init,
4234 .data = &led_driver_data,
4235 },
4236 {
4237 .init = beep_init,
4238 .data = &beep_driver_data,
4239 },
4240 {
4241 .init = thermal_init,
4242 .data = &thermal_driver_data,
4243 },
4244 {
4245 .data = &ecdump_driver_data,
4246 },
4247 {
4248 .init = brightness_init,
4249 .data = &brightness_driver_data,
4250 },
4251 {
4252 .data = &volume_driver_data,
4253 },
4254 {
4255 .init = fan_init,
4256 .data = &fan_driver_data,
4257 },
4258 };
4259
4260 static int __init set_ibm_param(const char *val, struct kernel_param *kp)
4261 {
4262 unsigned int i;
4263 struct ibm_struct *ibm;
4264
4265 for (i = 0; i < ARRAY_SIZE(ibms_init); i++) {
4266 ibm = ibms_init[i].data;
4267 BUG_ON(ibm == NULL);
4268
4269 if (strcmp(ibm->name, kp->name) == 0 && ibm->write) {
4270 if (strlen(val) > sizeof(ibms_init[i].param) - 2)
4271 return -ENOSPC;
4272 strcpy(ibms_init[i].param, val);
4273 strcat(ibms_init[i].param, ",");
4274 return 0;
4275 }
4276 }
4277
4278 return -EINVAL;
4279 }
4280
4281 static int experimental;
4282 module_param(experimental, int, 0);
4283
4284 static u32 dbg_level;
4285 module_param_named(debug, dbg_level, uint, 0);
4286
4287 static int force_load;
4288 module_param(force_load, int, 0);
4289
4290 static int fan_control_allowed;
4291 module_param_named(fan_control, fan_control_allowed, int, 0);
4292
4293 #define IBM_PARAM(feature) \
4294 module_param_call(feature, set_ibm_param, NULL, NULL, 0)
4295
4296 IBM_PARAM(hotkey);
4297 IBM_PARAM(bluetooth);
4298 IBM_PARAM(video);
4299 IBM_PARAM(light);
4300 #ifdef CONFIG_THINKPAD_ACPI_DOCK
4301 IBM_PARAM(dock);
4302 #endif
4303 #ifdef CONFIG_THINKPAD_ACPI_BAY
4304 IBM_PARAM(bay);
4305 #endif /* CONFIG_THINKPAD_ACPI_BAY */
4306 IBM_PARAM(cmos);
4307 IBM_PARAM(led);
4308 IBM_PARAM(beep);
4309 IBM_PARAM(ecdump);
4310 IBM_PARAM(brightness);
4311 IBM_PARAM(volume);
4312 IBM_PARAM(fan);
4313
4314 static int __init thinkpad_acpi_module_init(void)
4315 {
4316 int ret, i;
4317
4318 /* Driver-level probe */
4319 ret = probe_for_thinkpad();
4320 if (ret)
4321 return ret;
4322
4323 /* Driver initialization */
4324 ibm_thinkpad_ec_found = check_dmi_for_ec();
4325 IBM_ACPIHANDLE_INIT(ecrd);
4326 IBM_ACPIHANDLE_INIT(ecwr);
4327
4328 proc_dir = proc_mkdir(IBM_PROC_DIR, acpi_root_dir);
4329 if (!proc_dir) {
4330 printk(IBM_ERR "unable to create proc dir " IBM_PROC_DIR);
4331 thinkpad_acpi_module_exit();
4332 return -ENODEV;
4333 }
4334 proc_dir->owner = THIS_MODULE;
4335
4336 ret = platform_driver_register(&tpacpi_pdriver);
4337 if (ret) {
4338 printk(IBM_ERR "unable to register platform driver\n");
4339 thinkpad_acpi_module_exit();
4340 return ret;
4341 }
4342 ret = tpacpi_create_driver_attributes(&tpacpi_pdriver.driver);
4343 if (ret) {
4344 printk(IBM_ERR "unable to create sysfs driver attributes\n");
4345 thinkpad_acpi_module_exit();
4346 return ret;
4347 }
4348
4349
4350 /* Device initialization */
4351 tpacpi_pdev = platform_device_register_simple(IBM_DRVR_NAME, -1,
4352 NULL, 0);
4353 if (IS_ERR(tpacpi_pdev)) {
4354 ret = PTR_ERR(tpacpi_pdev);
4355 tpacpi_pdev = NULL;
4356 printk(IBM_ERR "unable to register platform device\n");
4357 thinkpad_acpi_module_exit();
4358 return ret;
4359 }
4360 tpacpi_hwmon = hwmon_device_register(&tpacpi_pdev->dev);
4361 if (IS_ERR(tpacpi_hwmon)) {
4362 ret = PTR_ERR(tpacpi_hwmon);
4363 tpacpi_hwmon = NULL;
4364 printk(IBM_ERR "unable to register hwmon device\n");
4365 thinkpad_acpi_module_exit();
4366 return ret;
4367 }
4368 tpacpi_inputdev = input_allocate_device();
4369 if (!tpacpi_inputdev) {
4370 printk(IBM_ERR "unable to allocate input device\n");
4371 thinkpad_acpi_module_exit();
4372 return -ENOMEM;
4373 } else {
4374 /* Prepare input device, but don't register */
4375 tpacpi_inputdev->name = "ThinkPad Extra Buttons";
4376 tpacpi_inputdev->phys = IBM_DRVR_NAME "/input0";
4377 tpacpi_inputdev->id.bustype = BUS_HOST;
4378 tpacpi_inputdev->id.vendor = TPACPI_HKEY_INPUT_VENDOR;
4379 tpacpi_inputdev->id.product = TPACPI_HKEY_INPUT_PRODUCT;
4380 tpacpi_inputdev->id.version = TPACPI_HKEY_INPUT_VERSION;
4381 }
4382 for (i = 0; i < ARRAY_SIZE(ibms_init); i++) {
4383 ret = ibm_init(&ibms_init[i]);
4384 if (ret >= 0 && *ibms_init[i].param)
4385 ret = ibms_init[i].data->write(ibms_init[i].param);
4386 if (ret < 0) {
4387 thinkpad_acpi_module_exit();
4388 return ret;
4389 }
4390 }
4391 ret = input_register_device(tpacpi_inputdev);
4392 if (ret < 0) {
4393 printk(IBM_ERR "unable to register input device\n");
4394 thinkpad_acpi_module_exit();
4395 return ret;
4396 } else {
4397 tp_features.input_device_registered = 1;
4398 }
4399
4400 return 0;
4401 }
4402
4403 static void thinkpad_acpi_module_exit(void)
4404 {
4405 struct ibm_struct *ibm, *itmp;
4406
4407 list_for_each_entry_safe_reverse(ibm, itmp,
4408 &tpacpi_all_drivers,
4409 all_drivers) {
4410 ibm_exit(ibm);
4411 }
4412
4413 dbg_printk(TPACPI_DBG_INIT, "finished subdriver exit path...\n");
4414
4415 if (tpacpi_inputdev) {
4416 if (tp_features.input_device_registered)
4417 input_unregister_device(tpacpi_inputdev);
4418 else
4419 input_free_device(tpacpi_inputdev);
4420 }
4421
4422 if (tpacpi_hwmon)
4423 hwmon_device_unregister(tpacpi_hwmon);
4424
4425 if (tpacpi_pdev)
4426 platform_device_unregister(tpacpi_pdev);
4427
4428 tpacpi_remove_driver_attributes(&tpacpi_pdriver.driver);
4429 platform_driver_unregister(&tpacpi_pdriver);
4430
4431 if (proc_dir)
4432 remove_proc_entry(IBM_PROC_DIR, acpi_root_dir);
4433
4434 kfree(ibm_thinkpad_ec_found);
4435 }
4436
4437 module_init(thinkpad_acpi_module_init);
4438 module_exit(thinkpad_acpi_module_exit);
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree