?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dmi: clean-up dmi helper declarations
[linux-2.6/openmoko-kernel/knife-kernel.git] / drivers / misc / thinkpad_acpi.c
blob3f28f6eabdbffcca3868b0b688b4a0516da91347
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-2008 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 TPACPI_VERSION "0.20"
25 #define TPACPI_SYSFS_VERSION 0x020200
26
27 /*
28 * Changelog:
29 * 2007-10-20 changelog trimmed down
30 *
31 * 2007-03-27 0.14 renamed to thinkpad_acpi and moved to
32 * drivers/misc.
33 *
34 * 2006-11-22 0.13 new maintainer
35 * changelog now lives in git commit history, and will
36 * not be updated further in-file.
37 *
38 * 2005-03-17 0.11 support for 600e, 770x
39 * thanks to Jamie Lentin <lentinj@dial.pipex.com>
40 *
41 * 2005-01-16 0.9 use MODULE_VERSION
42 * thanks to Henrik Brix Andersen <brix@gentoo.org>
43 * fix parameter passing on module loading
44 * thanks to Rusty Russell <rusty@rustcorp.com.au>
45 * thanks to Jim Radford <radford@blackbean.org>
46 * 2004-11-08 0.8 fix init error case, don't return from a macro
47 * thanks to Chris Wright <chrisw@osdl.org>
48 */
49
50 #include <linux/kernel.h>
51 #include <linux/module.h>
52 #include <linux/init.h>
53 #include <linux/types.h>
54 #include <linux/string.h>
55 #include <linux/list.h>
56 #include <linux/mutex.h>
57 #include <linux/kthread.h>
58 #include <linux/freezer.h>
59 #include <linux/delay.h>
60
61 #include <linux/nvram.h>
62 #include <linux/proc_fs.h>
63 #include <linux/sysfs.h>
64 #include <linux/backlight.h>
65 #include <linux/fb.h>
66 #include <linux/platform_device.h>
67 #include <linux/hwmon.h>
68 #include <linux/hwmon-sysfs.h>
69 #include <linux/input.h>
70 #include <linux/leds.h>
71 #include <asm/uaccess.h>
72
73 #include <linux/dmi.h>
74 #include <linux/jiffies.h>
75 #include <linux/workqueue.h>
76
77 #include <acpi/acpi_drivers.h>
78 #include <acpi/acnamesp.h>
79
80 #include <linux/pci_ids.h>
81
82
83 /* ThinkPad CMOS commands */
84 #define TP_CMOS_VOLUME_DOWN 0
85 #define TP_CMOS_VOLUME_UP 1
86 #define TP_CMOS_VOLUME_MUTE 2
87 #define TP_CMOS_BRIGHTNESS_UP 4
88 #define TP_CMOS_BRIGHTNESS_DOWN 5
89 #define TP_CMOS_THINKLIGHT_ON 12
90 #define TP_CMOS_THINKLIGHT_OFF 13
91
92 /* NVRAM Addresses */
93 enum tp_nvram_addr {
94 TP_NVRAM_ADDR_HK2 = 0x57,
95 TP_NVRAM_ADDR_THINKLIGHT = 0x58,
96 TP_NVRAM_ADDR_VIDEO = 0x59,
97 TP_NVRAM_ADDR_BRIGHTNESS = 0x5e,
98 TP_NVRAM_ADDR_MIXER = 0x60,
99 };
100
101 /* NVRAM bit masks */
102 enum {
103 TP_NVRAM_MASK_HKT_THINKPAD = 0x08,
104 TP_NVRAM_MASK_HKT_ZOOM = 0x20,
105 TP_NVRAM_MASK_HKT_DISPLAY = 0x40,
106 TP_NVRAM_MASK_HKT_HIBERNATE = 0x80,
107 TP_NVRAM_MASK_THINKLIGHT = 0x10,
108 TP_NVRAM_MASK_HKT_DISPEXPND = 0x30,
109 TP_NVRAM_MASK_HKT_BRIGHTNESS = 0x20,
110 TP_NVRAM_MASK_LEVEL_BRIGHTNESS = 0x0f,
111 TP_NVRAM_POS_LEVEL_BRIGHTNESS = 0,
112 TP_NVRAM_MASK_MUTE = 0x40,
113 TP_NVRAM_MASK_HKT_VOLUME = 0x80,
114 TP_NVRAM_MASK_LEVEL_VOLUME = 0x0f,
115 TP_NVRAM_POS_LEVEL_VOLUME = 0,
116 };
117
118 /* ACPI HIDs */
119 #define TPACPI_ACPI_HKEY_HID "IBM0068"
120
121 /* Input IDs */
122 #define TPACPI_HKEY_INPUT_PRODUCT 0x5054 /* "TP" */
123 #define TPACPI_HKEY_INPUT_VERSION 0x4101
124
125
126 /****************************************************************************
127 * Main driver
128 */
129
130 #define TPACPI_NAME "thinkpad"
131 #define TPACPI_DESC "ThinkPad ACPI Extras"
132 #define TPACPI_FILE TPACPI_NAME "_acpi"
133 #define TPACPI_URL "http://ibm-acpi.sf.net/"
134 #define TPACPI_MAIL "ibm-acpi-devel@lists.sourceforge.net"
135
136 #define TPACPI_PROC_DIR "ibm"
137 #define TPACPI_ACPI_EVENT_PREFIX "ibm"
138 #define TPACPI_DRVR_NAME TPACPI_FILE
139 #define TPACPI_DRVR_SHORTNAME "tpacpi"
140 #define TPACPI_HWMON_DRVR_NAME TPACPI_NAME "_hwmon"
141
142 #define TPACPI_NVRAM_KTHREAD_NAME "ktpacpi_nvramd"
143 #define TPACPI_WORKQUEUE_NAME "ktpacpid"
144
145 #define TPACPI_MAX_ACPI_ARGS 3
146
147 /* Debugging */
148 #define TPACPI_LOG TPACPI_FILE ": "
149 #define TPACPI_ERR KERN_ERR TPACPI_LOG
150 #define TPACPI_NOTICE KERN_NOTICE TPACPI_LOG
151 #define TPACPI_INFO KERN_INFO TPACPI_LOG
152 #define TPACPI_DEBUG KERN_DEBUG TPACPI_LOG
153
154 #define TPACPI_DBG_ALL 0xffff
155 #define TPACPI_DBG_ALL 0xffff
156 #define TPACPI_DBG_INIT 0x0001
157 #define TPACPI_DBG_EXIT 0x0002
158 #define dbg_printk(a_dbg_level, format, arg...) \
159 do { if (dbg_level & a_dbg_level) \
160 printk(TPACPI_DEBUG "%s: " format, __func__ , ## arg); \
161 } while (0)
162 #ifdef CONFIG_THINKPAD_ACPI_DEBUG
163 #define vdbg_printk(a_dbg_level, format, arg...) \
164 dbg_printk(a_dbg_level, format, ## arg)
165 static const char *str_supported(int is_supported);
166 #else
167 #define vdbg_printk(a_dbg_level, format, arg...)
168 #endif
169
170 #define onoff(status, bit) ((status) & (1 << (bit)) ? "on" : "off")
171 #define enabled(status, bit) ((status) & (1 << (bit)) ? "enabled" : "disabled")
172 #define strlencmp(a, b) (strncmp((a), (b), strlen(b)))
173
174
175 /****************************************************************************
176 * Driver-wide structs and misc. variables
177 */
178
179 struct ibm_struct;
180
181 struct tp_acpi_drv_struct {
182 const struct acpi_device_id *hid;
183 struct acpi_driver *driver;
184
185 void (*notify) (struct ibm_struct *, u32);
186 acpi_handle *handle;
187 u32 type;
188 struct acpi_device *device;
189 };
190
191 struct ibm_struct {
192 char *name;
193
194 int (*read) (char *);
195 int (*write) (char *);
196 void (*exit) (void);
197 void (*resume) (void);
198 void (*suspend) (pm_message_t state);
199
200 struct list_head all_drivers;
201
202 struct tp_acpi_drv_struct *acpi;
203
204 struct {
205 u8 acpi_driver_registered:1;
206 u8 acpi_notify_installed:1;
207 u8 proc_created:1;
208 u8 init_called:1;
209 u8 experimental:1;
210 } flags;
211 };
212
213 struct ibm_init_struct {
214 char param[32];
215
216 int (*init) (struct ibm_init_struct *);
217 struct ibm_struct *data;
218 };
219
220 static struct {
221 #ifdef CONFIG_THINKPAD_ACPI_BAY
222 u32 bay_status:1;
223 u32 bay_eject:1;
224 u32 bay_status2:1;
225 u32 bay_eject2:1;
226 #endif
227 u32 bluetooth:1;
228 u32 hotkey:1;
229 u32 hotkey_mask:1;
230 u32 hotkey_wlsw:1;
231 u32 hotkey_tablet:1;
232 u32 light:1;
233 u32 light_status:1;
234 u32 bright_16levels:1;
235 u32 bright_acpimode:1;
236 u32 wan:1;
237 u32 fan_ctrl_status_undef:1;
238 u32 input_device_registered:1;
239 u32 platform_drv_registered:1;
240 u32 platform_drv_attrs_registered:1;
241 u32 sensors_pdrv_registered:1;
242 u32 sensors_pdrv_attrs_registered:1;
243 u32 sensors_pdev_attrs_registered:1;
244 u32 hotkey_poll_active:1;
245 } tp_features;
246
247 static struct {
248 u16 hotkey_mask_ff:1;
249 u16 bright_cmos_ec_unsync:1;
250 } tp_warned;
251
252 struct thinkpad_id_data {
253 unsigned int vendor; /* ThinkPad vendor:
254 * PCI_VENDOR_ID_IBM/PCI_VENDOR_ID_LENOVO */
255
256 char *bios_version_str; /* Something like 1ZET51WW (1.03z) */
257 char *ec_version_str; /* Something like 1ZHT51WW-1.04a */
258
259 u16 bios_model; /* Big Endian, TP-1Y = 0x5931, 0 = unknown */
260 u16 ec_model;
261
262 char *model_str; /* ThinkPad T43 */
263 char *nummodel_str; /* 9384A9C for a 9384-A9C model */
264 };
265 static struct thinkpad_id_data thinkpad_id;
266
267 static enum {
268 TPACPI_LIFE_INIT = 0,
269 TPACPI_LIFE_RUNNING,
270 TPACPI_LIFE_EXITING,
271 } tpacpi_lifecycle;
272
273 static int experimental;
274 static u32 dbg_level;
275
276 static struct workqueue_struct *tpacpi_wq;
277
278 /* Special LED class that can defer work */
279 struct tpacpi_led_classdev {
280 struct led_classdev led_classdev;
281 struct work_struct work;
282 enum led_brightness new_brightness;
283 unsigned int led;
284 };
285
286 /****************************************************************************
287 ****************************************************************************
288 *
289 * ACPI Helpers and device model
290 *
291 ****************************************************************************
292 ****************************************************************************/
293
294 /*************************************************************************
295 * ACPI basic handles
296 */
297
298 static acpi_handle root_handle;
299
300 #define TPACPI_HANDLE(object, parent, paths...) \
301 static acpi_handle object##_handle; \
302 static acpi_handle *object##_parent = &parent##_handle; \
303 static char *object##_path; \
304 static char *object##_paths[] = { paths }
305
306 TPACPI_HANDLE(ec, root, "\\_SB.PCI0.ISA.EC0", /* 240, 240x */
307 "\\_SB.PCI.ISA.EC", /* 570 */
308 "\\_SB.PCI0.ISA0.EC0", /* 600e/x, 770e, 770x */
309 "\\_SB.PCI0.ISA.EC", /* A21e, A2xm/p, T20-22, X20-21 */
310 "\\_SB.PCI0.AD4S.EC0", /* i1400, R30 */
311 "\\_SB.PCI0.ICH3.EC0", /* R31 */
312 "\\_SB.PCI0.LPC.EC", /* all others */
313 );
314
315 TPACPI_HANDLE(ecrd, ec, "ECRD"); /* 570 */
316 TPACPI_HANDLE(ecwr, ec, "ECWR"); /* 570 */
317
318 TPACPI_HANDLE(cmos, root, "\\UCMS", /* R50, R50e, R50p, R51, */
319 /* T4x, X31, X40 */
320 "\\CMOS", /* A3x, G4x, R32, T23, T30, X22-24, X30 */
321 "\\CMS", /* R40, R40e */
322 ); /* all others */
323
324 TPACPI_HANDLE(hkey, ec, "\\_SB.HKEY", /* 600e/x, 770e, 770x */
325 "^HKEY", /* R30, R31 */
326 "HKEY", /* all others */
327 ); /* 570 */
328
329 TPACPI_HANDLE(vid, root, "\\_SB.PCI.AGP.VGA", /* 570 */
330 "\\_SB.PCI0.AGP0.VID0", /* 600e/x, 770x */
331 "\\_SB.PCI0.VID0", /* 770e */
332 "\\_SB.PCI0.VID", /* A21e, G4x, R50e, X30, X40 */
333 "\\_SB.PCI0.AGP.VID", /* all others */
334 ); /* R30, R31 */
335
336
337 /*************************************************************************
338 * ACPI helpers
339 */
340
341 static int acpi_evalf(acpi_handle handle,
342 void *res, char *method, char *fmt, ...)
343 {
344 char *fmt0 = fmt;
345 struct acpi_object_list params;
346 union acpi_object in_objs[TPACPI_MAX_ACPI_ARGS];
347 struct acpi_buffer result, *resultp;
348 union acpi_object out_obj;
349 acpi_status status;
350 va_list ap;
351 char res_type;
352 int success;
353 int quiet;
354
355 if (!*fmt) {
356 printk(TPACPI_ERR "acpi_evalf() called with empty format\n");
357 return 0;
358 }
359
360 if (*fmt == 'q') {
361 quiet = 1;
362 fmt++;
363 } else
364 quiet = 0;
365
366 res_type = *(fmt++);
367
368 params.count = 0;
369 params.pointer = &in_objs[0];
370
371 va_start(ap, fmt);
372 while (*fmt) {
373 char c = *(fmt++);
374 switch (c) {
375 case 'd': /* int */
376 in_objs[params.count].integer.value = va_arg(ap, int);
377 in_objs[params.count++].type = ACPI_TYPE_INTEGER;
378 break;
379 /* add more types as needed */
380 default:
381 printk(TPACPI_ERR "acpi_evalf() called "
382 "with invalid format character '%c'\n", c);
383 return 0;
384 }
385 }
386 va_end(ap);
387
388 if (res_type != 'v') {
389 result.length = sizeof(out_obj);
390 result.pointer = &out_obj;
391 resultp = &result;
392 } else
393 resultp = NULL;
394
395 status = acpi_evaluate_object(handle, method, &params, resultp);
396
397 switch (res_type) {
398 case 'd': /* int */
399 if (res)
400 *(int *)res = out_obj.integer.value;
401 success = status == AE_OK && out_obj.type == ACPI_TYPE_INTEGER;
402 break;
403 case 'v': /* void */
404 success = status == AE_OK;
405 break;
406 /* add more types as needed */
407 default:
408 printk(TPACPI_ERR "acpi_evalf() called "
409 "with invalid format character '%c'\n", res_type);
410 return 0;
411 }
412
413 if (!success && !quiet)
414 printk(TPACPI_ERR "acpi_evalf(%s, %s, ...) failed: %d\n",
415 method, fmt0, status);
416
417 return success;
418 }
419
420 static int acpi_ec_read(int i, u8 *p)
421 {
422 int v;
423
424 if (ecrd_handle) {
425 if (!acpi_evalf(ecrd_handle, &v, NULL, "dd", i))
426 return 0;
427 *p = v;
428 } else {
429 if (ec_read(i, p) < 0)
430 return 0;
431 }
432
433 return 1;
434 }
435
436 static int acpi_ec_write(int i, u8 v)
437 {
438 if (ecwr_handle) {
439 if (!acpi_evalf(ecwr_handle, NULL, NULL, "vdd", i, v))
440 return 0;
441 } else {
442 if (ec_write(i, v) < 0)
443 return 0;
444 }
445
446 return 1;
447 }
448
449 #if defined(CONFIG_THINKPAD_ACPI_DOCK) || defined(CONFIG_THINKPAD_ACPI_BAY)
450 static int _sta(acpi_handle handle)
451 {
452 int status;
453
454 if (!handle || !acpi_evalf(handle, &status, "_STA", "d"))
455 status = 0;
456
457 return status;
458 }
459 #endif
460
461 static int issue_thinkpad_cmos_command(int cmos_cmd)
462 {
463 if (!cmos_handle)
464 return -ENXIO;
465
466 if (!acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd))
467 return -EIO;
468
469 return 0;
470 }
471
472 /*************************************************************************
473 * ACPI device model
474 */
475
476 #define TPACPI_ACPIHANDLE_INIT(object) \
477 drv_acpi_handle_init(#object, &object##_handle, *object##_parent, \
478 object##_paths, ARRAY_SIZE(object##_paths), &object##_path)
479
480 static void drv_acpi_handle_init(char *name,
481 acpi_handle *handle, acpi_handle parent,
482 char **paths, int num_paths, char **path)
483 {
484 int i;
485 acpi_status status;
486
487 vdbg_printk(TPACPI_DBG_INIT, "trying to locate ACPI handle for %s\n",
488 name);
489
490 for (i = 0; i < num_paths; i++) {
491 status = acpi_get_handle(parent, paths[i], handle);
492 if (ACPI_SUCCESS(status)) {
493 *path = paths[i];
494 dbg_printk(TPACPI_DBG_INIT,
495 "Found ACPI handle %s for %s\n",
496 *path, name);
497 return;
498 }
499 }
500
501 vdbg_printk(TPACPI_DBG_INIT, "ACPI handle for %s not found\n",
502 name);
503 *handle = NULL;
504 }
505
506 static void dispatch_acpi_notify(acpi_handle handle, u32 event, void *data)
507 {
508 struct ibm_struct *ibm = data;
509
510 if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
511 return;
512
513 if (!ibm || !ibm->acpi || !ibm->acpi->notify)
514 return;
515
516 ibm->acpi->notify(ibm, event);
517 }
518
519 static int __init setup_acpi_notify(struct ibm_struct *ibm)
520 {
521 acpi_status status;
522 int rc;
523
524 BUG_ON(!ibm->acpi);
525
526 if (!*ibm->acpi->handle)
527 return 0;
528
529 vdbg_printk(TPACPI_DBG_INIT,
530 "setting up ACPI notify for %s\n", ibm->name);
531
532 rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
533 if (rc < 0) {
534 printk(TPACPI_ERR "acpi_bus_get_device(%s) failed: %d\n",
535 ibm->name, rc);
536 return -ENODEV;
537 }
538
539 acpi_driver_data(ibm->acpi->device) = ibm;
540 sprintf(acpi_device_class(ibm->acpi->device), "%s/%s",
541 TPACPI_ACPI_EVENT_PREFIX,
542 ibm->name);
543
544 status = acpi_install_notify_handler(*ibm->acpi->handle,
545 ibm->acpi->type, dispatch_acpi_notify, ibm);
546 if (ACPI_FAILURE(status)) {
547 if (status == AE_ALREADY_EXISTS) {
548 printk(TPACPI_NOTICE
549 "another device driver is already "
550 "handling %s events\n", ibm->name);
551 } else {
552 printk(TPACPI_ERR
553 "acpi_install_notify_handler(%s) failed: %d\n",
554 ibm->name, status);
555 }
556 return -ENODEV;
557 }
558 ibm->flags.acpi_notify_installed = 1;
559 return 0;
560 }
561
562 static int __init tpacpi_device_add(struct acpi_device *device)
563 {
564 return 0;
565 }
566
567 static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
568 {
569 int rc;
570
571 dbg_printk(TPACPI_DBG_INIT,
572 "registering %s as an ACPI driver\n", ibm->name);
573
574 BUG_ON(!ibm->acpi);
575
576 ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
577 if (!ibm->acpi->driver) {
578 printk(TPACPI_ERR "kzalloc(ibm->driver) failed\n");
579 return -ENOMEM;
580 }
581
582 sprintf(ibm->acpi->driver->name, "%s_%s", TPACPI_NAME, ibm->name);
583 ibm->acpi->driver->ids = ibm->acpi->hid;
584
585 ibm->acpi->driver->ops.add = &tpacpi_device_add;
586
587 rc = acpi_bus_register_driver(ibm->acpi->driver);
588 if (rc < 0) {
589 printk(TPACPI_ERR "acpi_bus_register_driver(%s) failed: %d\n",
590 ibm->name, rc);
591 kfree(ibm->acpi->driver);
592 ibm->acpi->driver = NULL;
593 } else if (!rc)
594 ibm->flags.acpi_driver_registered = 1;
595
596 return rc;
597 }
598
599
600 /****************************************************************************
601 ****************************************************************************
602 *
603 * Procfs Helpers
604 *
605 ****************************************************************************
606 ****************************************************************************/
607
608 static int dispatch_procfs_read(char *page, char **start, off_t off,
609 int count, int *eof, void *data)
610 {
611 struct ibm_struct *ibm = data;
612 int len;
613
614 if (!ibm || !ibm->read)
615 return -EINVAL;
616
617 len = ibm->read(page);
618 if (len < 0)
619 return len;
620
621 if (len <= off + count)
622 *eof = 1;
623 *start = page + off;
624 len -= off;
625 if (len > count)
626 len = count;
627 if (len < 0)
628 len = 0;
629
630 return len;
631 }
632
633 static int dispatch_procfs_write(struct file *file,
634 const char __user *userbuf,
635 unsigned long count, void *data)
636 {
637 struct ibm_struct *ibm = data;
638 char *kernbuf;
639 int ret;
640
641 if (!ibm || !ibm->write)
642 return -EINVAL;
643
644 kernbuf = kmalloc(count + 2, GFP_KERNEL);
645 if (!kernbuf)
646 return -ENOMEM;
647
648 if (copy_from_user(kernbuf, userbuf, count)) {
649 kfree(kernbuf);
650 return -EFAULT;
651 }
652
653 kernbuf[count] = 0;
654 strcat(kernbuf, ",");
655 ret = ibm->write(kernbuf);
656 if (ret == 0)
657 ret = count;
658
659 kfree(kernbuf);
660
661 return ret;
662 }
663
664 static char *next_cmd(char **cmds)
665 {
666 char *start = *cmds;
667 char *end;
668
669 while ((end = strchr(start, ',')) && end == start)
670 start = end + 1;
671
672 if (!end)
673 return NULL;
674
675 *end = 0;
676 *cmds = end + 1;
677 return start;
678 }
679
680
681 /****************************************************************************
682 ****************************************************************************
683 *
684 * Device model: input, hwmon and platform
685 *
686 ****************************************************************************
687 ****************************************************************************/
688
689 static struct platform_device *tpacpi_pdev;
690 static struct platform_device *tpacpi_sensors_pdev;
691 static struct device *tpacpi_hwmon;
692 static struct input_dev *tpacpi_inputdev;
693 static struct mutex tpacpi_inputdev_send_mutex;
694 static LIST_HEAD(tpacpi_all_drivers);
695
696 static int tpacpi_suspend_handler(struct platform_device *pdev,
697 pm_message_t state)
698 {
699 struct ibm_struct *ibm, *itmp;
700
701 list_for_each_entry_safe(ibm, itmp,
702 &tpacpi_all_drivers,
703 all_drivers) {
704 if (ibm->suspend)
705 (ibm->suspend)(state);
706 }
707
708 return 0;
709 }
710
711 static int tpacpi_resume_handler(struct platform_device *pdev)
712 {
713 struct ibm_struct *ibm, *itmp;
714
715 list_for_each_entry_safe(ibm, itmp,
716 &tpacpi_all_drivers,
717 all_drivers) {
718 if (ibm->resume)
719 (ibm->resume)();
720 }
721
722 return 0;
723 }
724
725 static struct platform_driver tpacpi_pdriver = {
726 .driver = {
727 .name = TPACPI_DRVR_NAME,
728 .owner = THIS_MODULE,
729 },
730 .suspend = tpacpi_suspend_handler,
731 .resume = tpacpi_resume_handler,
732 };
733
734 static struct platform_driver tpacpi_hwmon_pdriver = {
735 .driver = {
736 .name = TPACPI_HWMON_DRVR_NAME,
737 .owner = THIS_MODULE,
738 },
739 };
740
741 /*************************************************************************
742 * sysfs support helpers
743 */
744
745 struct attribute_set {
746 unsigned int members, max_members;
747 struct attribute_group group;
748 };
749
750 struct attribute_set_obj {
751 struct attribute_set s;
752 struct attribute *a;
753 } __attribute__((packed));
754
755 static struct attribute_set *create_attr_set(unsigned int max_members,
756 const char *name)
757 {
758 struct attribute_set_obj *sobj;
759
760 if (max_members == 0)
761 return NULL;
762
763 /* Allocates space for implicit NULL at the end too */
764 sobj = kzalloc(sizeof(struct attribute_set_obj) +
765 max_members * sizeof(struct attribute *),
766 GFP_KERNEL);
767 if (!sobj)
768 return NULL;
769 sobj->s.max_members = max_members;
770 sobj->s.group.attrs = &sobj->a;
771 sobj->s.group.name = name;
772
773 return &sobj->s;
774 }
775
776 #define destroy_attr_set(_set) \
777 kfree(_set);
778
779 /* not multi-threaded safe, use it in a single thread per set */
780 static int add_to_attr_set(struct attribute_set *s, struct attribute *attr)
781 {
782 if (!s || !attr)
783 return -EINVAL;
784
785 if (s->members >= s->max_members)
786 return -ENOMEM;
787
788 s->group.attrs[s->members] = attr;
789 s->members++;
790
791 return 0;
792 }
793
794 static int add_many_to_attr_set(struct attribute_set *s,
795 struct attribute **attr,
796 unsigned int count)
797 {
798 int i, res;
799
800 for (i = 0; i < count; i++) {
801 res = add_to_attr_set(s, attr[i]);
802 if (res)
803 return res;
804 }
805
806 return 0;
807 }
808
809 static void delete_attr_set(struct attribute_set *s, struct kobject *kobj)
810 {
811 sysfs_remove_group(kobj, &s->group);
812 destroy_attr_set(s);
813 }
814
815 #define register_attr_set_with_sysfs(_attr_set, _kobj) \
816 sysfs_create_group(_kobj, &_attr_set->group)
817
818 static int parse_strtoul(const char *buf,
819 unsigned long max, unsigned long *value)
820 {
821 char *endp;
822
823 while (*buf && isspace(*buf))
824 buf++;
825 *value = simple_strtoul(buf, &endp, 0);
826 while (*endp && isspace(*endp))
827 endp++;
828 if (*endp || *value > max)
829 return -EINVAL;
830
831 return 0;
832 }
833
834 static int __init tpacpi_query_bcl_levels(acpi_handle handle)
835 {
836 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
837 union acpi_object *obj;
838 int rc;
839
840 if (ACPI_SUCCESS(acpi_evaluate_object(handle, NULL, NULL, &buffer))) {
841 obj = (union acpi_object *)buffer.pointer;
842 if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
843 printk(TPACPI_ERR "Unknown _BCL data, "
844 "please report this to %s\n", TPACPI_MAIL);
845 rc = 0;
846 } else {
847 rc = obj->package.count;
848 }
849 } else {
850 return 0;
851 }
852
853 kfree(buffer.pointer);
854 return rc;
855 }
856
857 static acpi_status __init tpacpi_acpi_walk_find_bcl(acpi_handle handle,
858 u32 lvl, void *context, void **rv)
859 {
860 char name[ACPI_PATH_SEGMENT_LENGTH];
861 struct acpi_buffer buffer = { sizeof(name), &name };
862
863 if (ACPI_SUCCESS(acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer)) &&
864 !strncmp("_BCL", name, sizeof(name) - 1)) {
865 BUG_ON(!rv || !*rv);
866 **(int **)rv = tpacpi_query_bcl_levels(handle);
867 return AE_CTRL_TERMINATE;
868 } else {
869 return AE_OK;
870 }
871 }
872
873 /*
874 * Returns 0 (no ACPI _BCL or _BCL invalid), or size of brightness map
875 */
876 static int __init tpacpi_check_std_acpi_brightness_support(void)
877 {
878 int status;
879 int bcl_levels = 0;
880 void *bcl_ptr = &bcl_levels;
881
882 if (!vid_handle) {
883 TPACPI_ACPIHANDLE_INIT(vid);
884 }
885 if (!vid_handle)
886 return 0;
887
888 /*
889 * Search for a _BCL method, and execute it. This is safe on all
890 * ThinkPads, and as a side-effect, _BCL will place a Lenovo Vista
891 * BIOS in ACPI backlight control mode. We do NOT have to care
892 * about calling the _BCL method in an enabled video device, any
893 * will do for our purposes.
894 */
895
896 status = acpi_walk_namespace(ACPI_TYPE_METHOD, vid_handle, 3,
897 tpacpi_acpi_walk_find_bcl, NULL,
898 &bcl_ptr);
899
900 if (ACPI_SUCCESS(status) && bcl_levels > 2) {
901 tp_features.bright_acpimode = 1;
902 return (bcl_levels - 2);
903 }
904
905 return 0;
906 }
907
908 /*************************************************************************
909 * thinkpad-acpi driver attributes
910 */
911
912 /* interface_version --------------------------------------------------- */
913 static ssize_t tpacpi_driver_interface_version_show(
914 struct device_driver *drv,
915 char *buf)
916 {
917 return snprintf(buf, PAGE_SIZE, "0x%08x\n", TPACPI_SYSFS_VERSION);
918 }
919
920 static DRIVER_ATTR(interface_version, S_IRUGO,
921 tpacpi_driver_interface_version_show, NULL);
922
923 /* debug_level --------------------------------------------------------- */
924 static ssize_t tpacpi_driver_debug_show(struct device_driver *drv,
925 char *buf)
926 {
927 return snprintf(buf, PAGE_SIZE, "0x%04x\n", dbg_level);
928 }
929
930 static ssize_t tpacpi_driver_debug_store(struct device_driver *drv,
931 const char *buf, size_t count)
932 {
933 unsigned long t;
934
935 if (parse_strtoul(buf, 0xffff, &t))
936 return -EINVAL;
937
938 dbg_level = t;
939
940 return count;
941 }
942
943 static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
944 tpacpi_driver_debug_show, tpacpi_driver_debug_store);
945
946 /* version ------------------------------------------------------------- */
947 static ssize_t tpacpi_driver_version_show(struct device_driver *drv,
948 char *buf)
949 {
950 return snprintf(buf, PAGE_SIZE, "%s v%s\n",
951 TPACPI_DESC, TPACPI_VERSION);
952 }
953
954 static DRIVER_ATTR(version, S_IRUGO,
955 tpacpi_driver_version_show, NULL);
956
957 /* --------------------------------------------------------------------- */
958
959 static struct driver_attribute *tpacpi_driver_attributes[] = {
960 &driver_attr_debug_level, &driver_attr_version,
961 &driver_attr_interface_version,
962 };
963
964 static int __init tpacpi_create_driver_attributes(struct device_driver *drv)
965 {
966 int i, res;
967
968 i = 0;
969 res = 0;
970 while (!res && i < ARRAY_SIZE(tpacpi_driver_attributes)) {
971 res = driver_create_file(drv, tpacpi_driver_attributes[i]);
972 i++;
973 }
974
975 return res;
976 }
977
978 static void tpacpi_remove_driver_attributes(struct device_driver *drv)
979 {
980 int i;
981
982 for (i = 0; i < ARRAY_SIZE(tpacpi_driver_attributes); i++)
983 driver_remove_file(drv, tpacpi_driver_attributes[i]);
984 }
985
986 /****************************************************************************
987 ****************************************************************************
988 *
989 * Subdrivers
990 *
991 ****************************************************************************
992 ****************************************************************************/
993
994 /*************************************************************************
995 * thinkpad-acpi init subdriver
996 */
997
998 static int __init thinkpad_acpi_driver_init(struct ibm_init_struct *iibm)
999 {
1000 printk(TPACPI_INFO "%s v%s\n", TPACPI_DESC, TPACPI_VERSION);
1001 printk(TPACPI_INFO "%s\n", TPACPI_URL);
1002
1003 printk(TPACPI_INFO "ThinkPad BIOS %s, EC %s\n",
1004 (thinkpad_id.bios_version_str) ?
1005 thinkpad_id.bios_version_str : "unknown",
1006 (thinkpad_id.ec_version_str) ?
1007 thinkpad_id.ec_version_str : "unknown");
1008
1009 if (thinkpad_id.vendor && thinkpad_id.model_str)
1010 printk(TPACPI_INFO "%s %s, model %s\n",
1011 (thinkpad_id.vendor == PCI_VENDOR_ID_IBM) ?
1012 "IBM" : ((thinkpad_id.vendor ==
1013 PCI_VENDOR_ID_LENOVO) ?
1014 "Lenovo" : "Unknown vendor"),
1015 thinkpad_id.model_str,
1016 (thinkpad_id.nummodel_str) ?
1017 thinkpad_id.nummodel_str : "unknown");
1018
1019 return 0;
1020 }
1021
1022 static int thinkpad_acpi_driver_read(char *p)
1023 {
1024 int len = 0;
1025
1026 len += sprintf(p + len, "driver:\t\t%s\n", TPACPI_DESC);
1027 len += sprintf(p + len, "version:\t%s\n", TPACPI_VERSION);
1028
1029 return len;
1030 }
1031
1032 static struct ibm_struct thinkpad_acpi_driver_data = {
1033 .name = "driver",
1034 .read = thinkpad_acpi_driver_read,
1035 };
1036
1037 /*************************************************************************
1038 * Hotkey subdriver
1039 */
1040
1041 enum { /* hot key scan codes (derived from ACPI DSDT) */
1042 TP_ACPI_HOTKEYSCAN_FNF1 = 0,
1043 TP_ACPI_HOTKEYSCAN_FNF2,
1044 TP_ACPI_HOTKEYSCAN_FNF3,
1045 TP_ACPI_HOTKEYSCAN_FNF4,
1046 TP_ACPI_HOTKEYSCAN_FNF5,
1047 TP_ACPI_HOTKEYSCAN_FNF6,
1048 TP_ACPI_HOTKEYSCAN_FNF7,
1049 TP_ACPI_HOTKEYSCAN_FNF8,
1050 TP_ACPI_HOTKEYSCAN_FNF9,
1051 TP_ACPI_HOTKEYSCAN_FNF10,
1052 TP_ACPI_HOTKEYSCAN_FNF11,
1053 TP_ACPI_HOTKEYSCAN_FNF12,
1054 TP_ACPI_HOTKEYSCAN_FNBACKSPACE,
1055 TP_ACPI_HOTKEYSCAN_FNINSERT,
1056 TP_ACPI_HOTKEYSCAN_FNDELETE,
1057 TP_ACPI_HOTKEYSCAN_FNHOME,
1058 TP_ACPI_HOTKEYSCAN_FNEND,
1059 TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1060 TP_ACPI_HOTKEYSCAN_FNPAGEDOWN,
1061 TP_ACPI_HOTKEYSCAN_FNSPACE,
1062 TP_ACPI_HOTKEYSCAN_VOLUMEUP,
1063 TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
1064 TP_ACPI_HOTKEYSCAN_MUTE,
1065 TP_ACPI_HOTKEYSCAN_THINKPAD,
1066 };
1067
1068 enum { /* Keys available through NVRAM polling */
1069 TPACPI_HKEY_NVRAM_KNOWN_MASK = 0x00fb88c0U,
1070 TPACPI_HKEY_NVRAM_GOOD_MASK = 0x00fb8000U,
1071 };
1072
1073 enum { /* Positions of some of the keys in hotkey masks */
1074 TP_ACPI_HKEY_DISPSWTCH_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNF7,
1075 TP_ACPI_HKEY_DISPXPAND_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNF8,
1076 TP_ACPI_HKEY_HIBERNATE_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNF12,
1077 TP_ACPI_HKEY_BRGHTUP_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNHOME,
1078 TP_ACPI_HKEY_BRGHTDWN_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNEND,
1079 TP_ACPI_HKEY_THNKLGHT_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1080 TP_ACPI_HKEY_ZOOM_MASK = 1 << TP_ACPI_HOTKEYSCAN_FNSPACE,
1081 TP_ACPI_HKEY_VOLUP_MASK = 1 << TP_ACPI_HOTKEYSCAN_VOLUMEUP,
1082 TP_ACPI_HKEY_VOLDWN_MASK = 1 << TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
1083 TP_ACPI_HKEY_MUTE_MASK = 1 << TP_ACPI_HOTKEYSCAN_MUTE,
1084 TP_ACPI_HKEY_THINKPAD_MASK = 1 << TP_ACPI_HOTKEYSCAN_THINKPAD,
1085 };
1086
1087 enum { /* NVRAM to ACPI HKEY group map */
1088 TP_NVRAM_HKEY_GROUP_HK2 = TP_ACPI_HKEY_THINKPAD_MASK |
1089 TP_ACPI_HKEY_ZOOM_MASK |
1090 TP_ACPI_HKEY_DISPSWTCH_MASK |
1091 TP_ACPI_HKEY_HIBERNATE_MASK,
1092 TP_NVRAM_HKEY_GROUP_BRIGHTNESS = TP_ACPI_HKEY_BRGHTUP_MASK |
1093 TP_ACPI_HKEY_BRGHTDWN_MASK,
1094 TP_NVRAM_HKEY_GROUP_VOLUME = TP_ACPI_HKEY_VOLUP_MASK |
1095 TP_ACPI_HKEY_VOLDWN_MASK |
1096 TP_ACPI_HKEY_MUTE_MASK,
1097 };
1098
1099 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1100 struct tp_nvram_state {
1101 u16 thinkpad_toggle:1;
1102 u16 zoom_toggle:1;
1103 u16 display_toggle:1;
1104 u16 thinklight_toggle:1;
1105 u16 hibernate_toggle:1;
1106 u16 displayexp_toggle:1;
1107 u16 display_state:1;
1108 u16 brightness_toggle:1;
1109 u16 volume_toggle:1;
1110 u16 mute:1;
1111
1112 u8 brightness_level;
1113 u8 volume_level;
1114 };
1115
1116 static struct task_struct *tpacpi_hotkey_task;
1117 static u32 hotkey_source_mask; /* bit mask 0=ACPI,1=NVRAM */
1118 static int hotkey_poll_freq = 10; /* Hz */
1119 static struct mutex hotkey_thread_mutex;
1120 static struct mutex hotkey_thread_data_mutex;
1121 static unsigned int hotkey_config_change;
1122
1123 #else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1124
1125 #define hotkey_source_mask 0U
1126
1127 #endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1128
1129 static struct mutex hotkey_mutex;
1130
1131 static enum { /* Reasons for waking up */
1132 TP_ACPI_WAKEUP_NONE = 0, /* None or unknown */
1133 TP_ACPI_WAKEUP_BAYEJ, /* Bay ejection request */
1134 TP_ACPI_WAKEUP_UNDOCK, /* Undock request */
1135 } hotkey_wakeup_reason;
1136
1137 static int hotkey_autosleep_ack;
1138
1139 static int hotkey_orig_status;
1140 static u32 hotkey_orig_mask;
1141 static u32 hotkey_all_mask;
1142 static u32 hotkey_reserved_mask;
1143 static u32 hotkey_mask;
1144
1145 static unsigned int hotkey_report_mode;
1146
1147 static u16 *hotkey_keycode_map;
1148
1149 static struct attribute_set *hotkey_dev_attributes;
1150
1151 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1152 #define HOTKEY_CONFIG_CRITICAL_START \
1153 do { \
1154 mutex_lock(&hotkey_thread_data_mutex); \
1155 hotkey_config_change++; \
1156 } while (0);
1157 #define HOTKEY_CONFIG_CRITICAL_END \
1158 mutex_unlock(&hotkey_thread_data_mutex);
1159 #else
1160 #define HOTKEY_CONFIG_CRITICAL_START
1161 #define HOTKEY_CONFIG_CRITICAL_END
1162 #endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1163
1164 /* HKEY.MHKG() return bits */
1165 #define TP_HOTKEY_TABLET_MASK (1 << 3)
1166
1167 static int hotkey_get_wlsw(int *status)
1168 {
1169 if (!acpi_evalf(hkey_handle, status, "WLSW", "d"))
1170 return -EIO;
1171 return 0;
1172 }
1173
1174 static int hotkey_get_tablet_mode(int *status)
1175 {
1176 int s;
1177
1178 if (!acpi_evalf(hkey_handle, &s, "MHKG", "d"))
1179 return -EIO;
1180
1181 *status = ((s & TP_HOTKEY_TABLET_MASK) != 0);
1182 return 0;
1183 }
1184
1185 /*
1186 * Call with hotkey_mutex held
1187 */
1188 static int hotkey_mask_get(void)
1189 {
1190 u32 m = 0;
1191
1192 if (tp_features.hotkey_mask) {
1193 if (!acpi_evalf(hkey_handle, &m, "DHKN", "d"))
1194 return -EIO;
1195 }
1196 hotkey_mask = m | (hotkey_source_mask & hotkey_mask);
1197
1198 return 0;
1199 }
1200
1201 /*
1202 * Call with hotkey_mutex held
1203 */
1204 static int hotkey_mask_set(u32 mask)
1205 {
1206 int i;
1207 int rc = 0;
1208
1209 if (tp_features.hotkey_mask) {
1210 if (!tp_warned.hotkey_mask_ff &&
1211 (mask == 0xffff || mask == 0xffffff ||
1212 mask == 0xffffffff)) {
1213 tp_warned.hotkey_mask_ff = 1;
1214 printk(TPACPI_NOTICE
1215 "setting the hotkey mask to 0x%08x is likely "
1216 "not the best way to go about it\n", mask);
1217 printk(TPACPI_NOTICE
1218 "please consider using the driver defaults, "
1219 "and refer to up-to-date thinkpad-acpi "
1220 "documentation\n");
1221 }
1222
1223 HOTKEY_CONFIG_CRITICAL_START
1224 for (i = 0; i < 32; i++) {
1225 u32 m = 1 << i;
1226 /* enable in firmware mask only keys not in NVRAM
1227 * mode, but enable the key in the cached hotkey_mask
1228 * regardless of mode, or the key will end up
1229 * disabled by hotkey_mask_get() */
1230 if (!acpi_evalf(hkey_handle,
1231 NULL, "MHKM", "vdd", i + 1,
1232 !!((mask & ~hotkey_source_mask) & m))) {
1233 rc = -EIO;
1234 break;
1235 } else {
1236 hotkey_mask = (hotkey_mask & ~m) | (mask & m);
1237 }
1238 }
1239 HOTKEY_CONFIG_CRITICAL_END
1240
1241 /* hotkey_mask_get must be called unconditionally below */
1242 if (!hotkey_mask_get() && !rc &&
1243 (hotkey_mask & ~hotkey_source_mask) !=
1244 (mask & ~hotkey_source_mask)) {
1245 printk(TPACPI_NOTICE
1246 "requested hot key mask 0x%08x, but "
1247 "firmware forced it to 0x%08x\n",
1248 mask, hotkey_mask);
1249 }
1250 } else {
1251 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1252 HOTKEY_CONFIG_CRITICAL_START
1253 hotkey_mask = mask & hotkey_source_mask;
1254 HOTKEY_CONFIG_CRITICAL_END
1255 hotkey_mask_get();
1256 if (hotkey_mask != mask) {
1257 printk(TPACPI_NOTICE
1258 "requested hot key mask 0x%08x, "
1259 "forced to 0x%08x (NVRAM poll mask is "
1260 "0x%08x): no firmware mask support\n",
1261 mask, hotkey_mask, hotkey_source_mask);
1262 }
1263 #else
1264 hotkey_mask_get();
1265 rc = -ENXIO;
1266 #endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1267 }
1268
1269 return rc;
1270 }
1271
1272 static int hotkey_status_get(int *status)
1273 {
1274 if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
1275 return -EIO;
1276
1277 return 0;
1278 }
1279
1280 static int hotkey_status_set(int status)
1281 {
1282 if (!acpi_evalf(hkey_handle, NULL, "MHKC", "vd", status))
1283 return -EIO;
1284
1285 return 0;
1286 }
1287
1288 static void tpacpi_input_send_radiosw(void)
1289 {
1290 int wlsw;
1291
1292 if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&wlsw)) {
1293 mutex_lock(&tpacpi_inputdev_send_mutex);
1294
1295 input_report_switch(tpacpi_inputdev,
1296 SW_RADIO, !!wlsw);
1297 input_sync(tpacpi_inputdev);
1298
1299 mutex_unlock(&tpacpi_inputdev_send_mutex);
1300 }
1301 }
1302
1303 static void tpacpi_input_send_tabletsw(void)
1304 {
1305 int state;
1306
1307 if (tp_features.hotkey_tablet &&
1308 !hotkey_get_tablet_mode(&state)) {
1309 mutex_lock(&tpacpi_inputdev_send_mutex);
1310
1311 input_report_switch(tpacpi_inputdev,
1312 SW_TABLET_MODE, !!state);
1313 input_sync(tpacpi_inputdev);
1314
1315 mutex_unlock(&tpacpi_inputdev_send_mutex);
1316 }
1317 }
1318
1319 static void tpacpi_input_send_key(unsigned int scancode)
1320 {
1321 unsigned int keycode;
1322
1323 keycode = hotkey_keycode_map[scancode];
1324
1325 if (keycode != KEY_RESERVED) {
1326 mutex_lock(&tpacpi_inputdev_send_mutex);
1327
1328 input_report_key(tpacpi_inputdev, keycode, 1);
1329 if (keycode == KEY_UNKNOWN)
1330 input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN,
1331 scancode);
1332 input_sync(tpacpi_inputdev);
1333
1334 input_report_key(tpacpi_inputdev, keycode, 0);
1335 if (keycode == KEY_UNKNOWN)
1336 input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN,
1337 scancode);
1338 input_sync(tpacpi_inputdev);
1339
1340 mutex_unlock(&tpacpi_inputdev_send_mutex);
1341 }
1342 }
1343
1344 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1345 static struct tp_acpi_drv_struct ibm_hotkey_acpidriver;
1346
1347 static void tpacpi_hotkey_send_key(unsigned int scancode)
1348 {
1349 tpacpi_input_send_key(scancode);
1350 if (hotkey_report_mode < 2) {
1351 acpi_bus_generate_proc_event(ibm_hotkey_acpidriver.device,
1352 0x80, 0x1001 + scancode);
1353 }
1354 }
1355
1356 static void hotkey_read_nvram(struct tp_nvram_state *n, u32 m)
1357 {
1358 u8 d;
1359
1360 if (m & TP_NVRAM_HKEY_GROUP_HK2) {
1361 d = nvram_read_byte(TP_NVRAM_ADDR_HK2);
1362 n->thinkpad_toggle = !!(d & TP_NVRAM_MASK_HKT_THINKPAD);
1363 n->zoom_toggle = !!(d & TP_NVRAM_MASK_HKT_ZOOM);
1364 n->display_toggle = !!(d & TP_NVRAM_MASK_HKT_DISPLAY);
1365 n->hibernate_toggle = !!(d & TP_NVRAM_MASK_HKT_HIBERNATE);
1366 }
1367 if (m & TP_ACPI_HKEY_THNKLGHT_MASK) {
1368 d = nvram_read_byte(TP_NVRAM_ADDR_THINKLIGHT);
1369 n->thinklight_toggle = !!(d & TP_NVRAM_MASK_THINKLIGHT);
1370 }
1371 if (m & TP_ACPI_HKEY_DISPXPAND_MASK) {
1372 d = nvram_read_byte(TP_NVRAM_ADDR_VIDEO);
1373 n->displayexp_toggle =
1374 !!(d & TP_NVRAM_MASK_HKT_DISPEXPND);
1375 }
1376 if (m & TP_NVRAM_HKEY_GROUP_BRIGHTNESS) {
1377 d = nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS);
1378 n->brightness_level = (d & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
1379 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
1380 n->brightness_toggle =
1381 !!(d & TP_NVRAM_MASK_HKT_BRIGHTNESS);
1382 }
1383 if (m & TP_NVRAM_HKEY_GROUP_VOLUME) {
1384 d = nvram_read_byte(TP_NVRAM_ADDR_MIXER);
1385 n->volume_level = (d & TP_NVRAM_MASK_LEVEL_VOLUME)
1386 >> TP_NVRAM_POS_LEVEL_VOLUME;
1387 n->mute = !!(d & TP_NVRAM_MASK_MUTE);
1388 n->volume_toggle = !!(d & TP_NVRAM_MASK_HKT_VOLUME);
1389 }
1390 }
1391
1392 #define TPACPI_COMPARE_KEY(__scancode, __member) \
1393 do { \
1394 if ((mask & (1 << __scancode)) && \
1395 oldn->__member != newn->__member) \
1396 tpacpi_hotkey_send_key(__scancode); \
1397 } while (0)
1398
1399 #define TPACPI_MAY_SEND_KEY(__scancode) \
1400 do { if (mask & (1 << __scancode)) \
1401 tpacpi_hotkey_send_key(__scancode); } while (0)
1402
1403 static void hotkey_compare_and_issue_event(struct tp_nvram_state *oldn,
1404 struct tp_nvram_state *newn,
1405 u32 mask)
1406 {
1407 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_THINKPAD, thinkpad_toggle);
1408 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNSPACE, zoom_toggle);
1409 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF7, display_toggle);
1410 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF12, hibernate_toggle);
1411
1412 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNPAGEUP, thinklight_toggle);
1413
1414 TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF8, displayexp_toggle);
1415
1416 /* handle volume */
1417 if (oldn->volume_toggle != newn->volume_toggle) {
1418 if (oldn->mute != newn->mute) {
1419 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_MUTE);
1420 }
1421 if (oldn->volume_level > newn->volume_level) {
1422 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
1423 } else if (oldn->volume_level < newn->volume_level) {
1424 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
1425 } else if (oldn->mute == newn->mute) {
1426 /* repeated key presses that didn't change state */
1427 if (newn->mute) {
1428 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_MUTE);
1429 } else if (newn->volume_level != 0) {
1430 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
1431 } else {
1432 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
1433 }
1434 }
1435 }
1436
1437 /* handle brightness */
1438 if (oldn->brightness_toggle != newn->brightness_toggle) {
1439 if (oldn->brightness_level < newn->brightness_level) {
1440 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
1441 } else if (oldn->brightness_level > newn->brightness_level) {
1442 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
1443 } else {
1444 /* repeated key presses that didn't change state */
1445 if (newn->brightness_level != 0) {
1446 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
1447 } else {
1448 TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
1449 }
1450 }
1451 }
1452 }
1453
1454 #undef TPACPI_COMPARE_KEY
1455 #undef TPACPI_MAY_SEND_KEY
1456
1457 static int hotkey_kthread(void *data)
1458 {
1459 struct tp_nvram_state s[2];
1460 u32 mask;
1461 unsigned int si, so;
1462 unsigned long t;
1463 unsigned int change_detector, must_reset;
1464
1465 mutex_lock(&hotkey_thread_mutex);
1466
1467 if (tpacpi_lifecycle == TPACPI_LIFE_EXITING)
1468 goto exit;
1469
1470 set_freezable();
1471
1472 so = 0;
1473 si = 1;
1474 t = 0;
1475
1476 /* Initial state for compares */
1477 mutex_lock(&hotkey_thread_data_mutex);
1478 change_detector = hotkey_config_change;
1479 mask = hotkey_source_mask & hotkey_mask;
1480 mutex_unlock(&hotkey_thread_data_mutex);
1481 hotkey_read_nvram(&s[so], mask);
1482
1483 while (!kthread_should_stop() && hotkey_poll_freq) {
1484 if (t == 0)
1485 t = 1000/hotkey_poll_freq;
1486 t = msleep_interruptible(t);
1487 if (unlikely(kthread_should_stop()))
1488 break;
1489 must_reset = try_to_freeze();
1490 if (t > 0 && !must_reset)
1491 continue;
1492
1493 mutex_lock(&hotkey_thread_data_mutex);
1494 if (must_reset || hotkey_config_change != change_detector) {
1495 /* forget old state on thaw or config change */
1496 si = so;
1497 t = 0;
1498 change_detector = hotkey_config_change;
1499 }
1500 mask = hotkey_source_mask & hotkey_mask;
1501 mutex_unlock(&hotkey_thread_data_mutex);
1502
1503 if (likely(mask)) {
1504 hotkey_read_nvram(&s[si], mask);
1505 if (likely(si != so)) {
1506 hotkey_compare_and_issue_event(&s[so], &s[si],
1507 mask);
1508 }
1509 }
1510
1511 so = si;
1512 si ^= 1;
1513 }
1514
1515 exit:
1516 mutex_unlock(&hotkey_thread_mutex);
1517 return 0;
1518 }
1519
1520 static void hotkey_poll_stop_sync(void)
1521 {
1522 if (tpacpi_hotkey_task) {
1523 if (frozen(tpacpi_hotkey_task) ||
1524 freezing(tpacpi_hotkey_task))
1525 thaw_process(tpacpi_hotkey_task);
1526
1527 kthread_stop(tpacpi_hotkey_task);
1528 tpacpi_hotkey_task = NULL;
1529 mutex_lock(&hotkey_thread_mutex);
1530 /* at this point, the thread did exit */
1531 mutex_unlock(&hotkey_thread_mutex);
1532 }
1533 }
1534
1535 /* call with hotkey_mutex held */
1536 static void hotkey_poll_setup(int may_warn)
1537 {
1538 if ((hotkey_source_mask & hotkey_mask) != 0 &&
1539 hotkey_poll_freq > 0 &&
1540 (tpacpi_inputdev->users > 0 || hotkey_report_mode < 2)) {
1541 if (!tpacpi_hotkey_task) {
1542 tpacpi_hotkey_task = kthread_run(hotkey_kthread,
1543 NULL, TPACPI_NVRAM_KTHREAD_NAME);
1544 if (IS_ERR(tpacpi_hotkey_task)) {
1545 tpacpi_hotkey_task = NULL;
1546 printk(TPACPI_ERR
1547 "could not create kernel thread "
1548 "for hotkey polling\n");
1549 }
1550 }
1551 } else {
1552 hotkey_poll_stop_sync();
1553 if (may_warn &&
1554 hotkey_source_mask != 0 && hotkey_poll_freq == 0) {
1555 printk(TPACPI_NOTICE
1556 "hot keys 0x%08x require polling, "
1557 "which is currently disabled\n",
1558 hotkey_source_mask);
1559 }
1560 }
1561 }
1562
1563 static void hotkey_poll_setup_safe(int may_warn)
1564 {
1565 mutex_lock(&hotkey_mutex);
1566 hotkey_poll_setup(may_warn);
1567 mutex_unlock(&hotkey_mutex);
1568 }
1569
1570 #else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1571
1572 static void hotkey_poll_setup_safe(int __unused)
1573 {
1574 }
1575
1576 #endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1577
1578 static int hotkey_inputdev_open(struct input_dev *dev)
1579 {
1580 switch (tpacpi_lifecycle) {
1581 case TPACPI_LIFE_INIT:
1582 /*
1583 * hotkey_init will call hotkey_poll_setup_safe
1584 * at the appropriate moment
1585 */
1586 return 0;
1587 case TPACPI_LIFE_EXITING:
1588 return -EBUSY;
1589 case TPACPI_LIFE_RUNNING:
1590 hotkey_poll_setup_safe(0);
1591 return 0;
1592 }
1593
1594 /* Should only happen if tpacpi_lifecycle is corrupt */
1595 BUG();
1596 return -EBUSY;
1597 }
1598
1599 static void hotkey_inputdev_close(struct input_dev *dev)
1600 {
1601 /* disable hotkey polling when possible */
1602 if (tpacpi_lifecycle == TPACPI_LIFE_RUNNING)
1603 hotkey_poll_setup_safe(0);
1604 }
1605
1606 /* sysfs hotkey enable ------------------------------------------------- */
1607 static ssize_t hotkey_enable_show(struct device *dev,
1608 struct device_attribute *attr,
1609 char *buf)
1610 {
1611 int res, status;
1612
1613 res = hotkey_status_get(&status);
1614 if (res)
1615 return res;
1616
1617 return snprintf(buf, PAGE_SIZE, "%d\n", status);
1618 }
1619
1620 static ssize_t hotkey_enable_store(struct device *dev,
1621 struct device_attribute *attr,
1622 const char *buf, size_t count)
1623 {
1624 unsigned long t;
1625 int res;
1626
1627 if (parse_strtoul(buf, 1, &t))
1628 return -EINVAL;
1629
1630 res = hotkey_status_set(t);
1631
1632 return (res) ? res : count;
1633 }
1634
1635 static struct device_attribute dev_attr_hotkey_enable =
1636 __ATTR(hotkey_enable, S_IWUSR | S_IRUGO,
1637 hotkey_enable_show, hotkey_enable_store);
1638
1639 /* sysfs hotkey mask --------------------------------------------------- */
1640 static ssize_t hotkey_mask_show(struct device *dev,
1641 struct device_attribute *attr,
1642 char *buf)
1643 {
1644 int res;
1645
1646 if (mutex_lock_interruptible(&hotkey_mutex))
1647 return -ERESTARTSYS;
1648 res = hotkey_mask_get();
1649 mutex_unlock(&hotkey_mutex);
1650
1651 return (res)?
1652 res : snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_mask);
1653 }
1654
1655 static ssize_t hotkey_mask_store(struct device *dev,
1656 struct device_attribute *attr,
1657 const char *buf, size_t count)
1658 {
1659 unsigned long t;
1660 int res;
1661
1662 if (parse_strtoul(buf, 0xffffffffUL, &t))
1663 return -EINVAL;
1664
1665 if (mutex_lock_interruptible(&hotkey_mutex))
1666 return -ERESTARTSYS;
1667
1668 res = hotkey_mask_set(t);
1669
1670 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1671 hotkey_poll_setup(1);
1672 #endif
1673
1674 mutex_unlock(&hotkey_mutex);
1675
1676 return (res) ? res : count;
1677 }
1678
1679 static struct device_attribute dev_attr_hotkey_mask =
1680 __ATTR(hotkey_mask, S_IWUSR | S_IRUGO,
1681 hotkey_mask_show, hotkey_mask_store);
1682
1683 /* sysfs hotkey bios_enabled ------------------------------------------- */
1684 static ssize_t hotkey_bios_enabled_show(struct device *dev,
1685 struct device_attribute *attr,
1686 char *buf)
1687 {
1688 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_orig_status);
1689 }
1690
1691 static struct device_attribute dev_attr_hotkey_bios_enabled =
1692 __ATTR(hotkey_bios_enabled, S_IRUGO, hotkey_bios_enabled_show, NULL);
1693
1694 /* sysfs hotkey bios_mask ---------------------------------------------- */
1695 static ssize_t hotkey_bios_mask_show(struct device *dev,
1696 struct device_attribute *attr,
1697 char *buf)
1698 {
1699 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_orig_mask);
1700 }
1701
1702 static struct device_attribute dev_attr_hotkey_bios_mask =
1703 __ATTR(hotkey_bios_mask, S_IRUGO, hotkey_bios_mask_show, NULL);
1704
1705 /* sysfs hotkey all_mask ----------------------------------------------- */
1706 static ssize_t hotkey_all_mask_show(struct device *dev,
1707 struct device_attribute *attr,
1708 char *buf)
1709 {
1710 return snprintf(buf, PAGE_SIZE, "0x%08x\n",
1711 hotkey_all_mask | hotkey_source_mask);
1712 }
1713
1714 static struct device_attribute dev_attr_hotkey_all_mask =
1715 __ATTR(hotkey_all_mask, S_IRUGO, hotkey_all_mask_show, NULL);
1716
1717 /* sysfs hotkey recommended_mask --------------------------------------- */
1718 static ssize_t hotkey_recommended_mask_show(struct device *dev,
1719 struct device_attribute *attr,
1720 char *buf)
1721 {
1722 return snprintf(buf, PAGE_SIZE, "0x%08x\n",
1723 (hotkey_all_mask | hotkey_source_mask)
1724 & ~hotkey_reserved_mask);
1725 }
1726
1727 static struct device_attribute dev_attr_hotkey_recommended_mask =
1728 __ATTR(hotkey_recommended_mask, S_IRUGO,
1729 hotkey_recommended_mask_show, NULL);
1730
1731 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1732
1733 /* sysfs hotkey hotkey_source_mask ------------------------------------- */
1734 static ssize_t hotkey_source_mask_show(struct device *dev,
1735 struct device_attribute *attr,
1736 char *buf)
1737 {
1738 return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_source_mask);
1739 }
1740
1741 static ssize_t hotkey_source_mask_store(struct device *dev,
1742 struct device_attribute *attr,
1743 const char *buf, size_t count)
1744 {
1745 unsigned long t;
1746
1747 if (parse_strtoul(buf, 0xffffffffUL, &t) ||
1748 ((t & ~TPACPI_HKEY_NVRAM_KNOWN_MASK) != 0))
1749 return -EINVAL;
1750
1751 if (mutex_lock_interruptible(&hotkey_mutex))
1752 return -ERESTARTSYS;
1753
1754 HOTKEY_CONFIG_CRITICAL_START
1755 hotkey_source_mask = t;
1756 HOTKEY_CONFIG_CRITICAL_END
1757
1758 hotkey_poll_setup(1);
1759
1760 mutex_unlock(&hotkey_mutex);
1761
1762 return count;
1763 }
1764
1765 static struct device_attribute dev_attr_hotkey_source_mask =
1766 __ATTR(hotkey_source_mask, S_IWUSR | S_IRUGO,
1767 hotkey_source_mask_show, hotkey_source_mask_store);
1768
1769 /* sysfs hotkey hotkey_poll_freq --------------------------------------- */
1770 static ssize_t hotkey_poll_freq_show(struct device *dev,
1771 struct device_attribute *attr,
1772 char *buf)
1773 {
1774 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_poll_freq);
1775 }
1776
1777 static ssize_t hotkey_poll_freq_store(struct device *dev,
1778 struct device_attribute *attr,
1779 const char *buf, size_t count)
1780 {
1781 unsigned long t;
1782
1783 if (parse_strtoul(buf, 25, &t))
1784 return -EINVAL;
1785
1786 if (mutex_lock_interruptible(&hotkey_mutex))
1787 return -ERESTARTSYS;
1788
1789 hotkey_poll_freq = t;
1790
1791 hotkey_poll_setup(1);
1792 mutex_unlock(&hotkey_mutex);
1793
1794 return count;
1795 }
1796
1797 static struct device_attribute dev_attr_hotkey_poll_freq =
1798 __ATTR(hotkey_poll_freq, S_IWUSR | S_IRUGO,
1799 hotkey_poll_freq_show, hotkey_poll_freq_store);
1800
1801 #endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1802
1803 /* sysfs hotkey radio_sw (pollable) ------------------------------------ */
1804 static ssize_t hotkey_radio_sw_show(struct device *dev,
1805 struct device_attribute *attr,
1806 char *buf)
1807 {
1808 int res, s;
1809 res = hotkey_get_wlsw(&s);
1810 if (res < 0)
1811 return res;
1812
1813 return snprintf(buf, PAGE_SIZE, "%d\n", !!s);
1814 }
1815
1816 static struct device_attribute dev_attr_hotkey_radio_sw =
1817 __ATTR(hotkey_radio_sw, S_IRUGO, hotkey_radio_sw_show, NULL);
1818
1819 static void hotkey_radio_sw_notify_change(void)
1820 {
1821 if (tp_features.hotkey_wlsw)
1822 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
1823 "hotkey_radio_sw");
1824 }
1825
1826 /* sysfs hotkey tablet mode (pollable) --------------------------------- */
1827 static ssize_t hotkey_tablet_mode_show(struct device *dev,
1828 struct device_attribute *attr,
1829 char *buf)
1830 {
1831 int res, s;
1832 res = hotkey_get_tablet_mode(&s);
1833 if (res < 0)
1834 return res;
1835
1836 return snprintf(buf, PAGE_SIZE, "%d\n", !!s);
1837 }
1838
1839 static struct device_attribute dev_attr_hotkey_tablet_mode =
1840 __ATTR(hotkey_tablet_mode, S_IRUGO, hotkey_tablet_mode_show, NULL);
1841
1842 static void hotkey_tablet_mode_notify_change(void)
1843 {
1844 if (tp_features.hotkey_tablet)
1845 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
1846 "hotkey_tablet_mode");
1847 }
1848
1849 /* sysfs hotkey report_mode -------------------------------------------- */
1850 static ssize_t hotkey_report_mode_show(struct device *dev,
1851 struct device_attribute *attr,
1852 char *buf)
1853 {
1854 return snprintf(buf, PAGE_SIZE, "%d\n",
1855 (hotkey_report_mode != 0) ? hotkey_report_mode : 1);
1856 }
1857
1858 static struct device_attribute dev_attr_hotkey_report_mode =
1859 __ATTR(hotkey_report_mode, S_IRUGO, hotkey_report_mode_show, NULL);
1860
1861 /* sysfs wakeup reason (pollable) -------------------------------------- */
1862 static ssize_t hotkey_wakeup_reason_show(struct device *dev,
1863 struct device_attribute *attr,
1864 char *buf)
1865 {
1866 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_wakeup_reason);
1867 }
1868
1869 static struct device_attribute dev_attr_hotkey_wakeup_reason =
1870 __ATTR(wakeup_reason, S_IRUGO, hotkey_wakeup_reason_show, NULL);
1871
1872 static void hotkey_wakeup_reason_notify_change(void)
1873 {
1874 if (tp_features.hotkey_mask)
1875 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
1876 "wakeup_reason");
1877 }
1878
1879 /* sysfs wakeup hotunplug_complete (pollable) -------------------------- */
1880 static ssize_t hotkey_wakeup_hotunplug_complete_show(struct device *dev,
1881 struct device_attribute *attr,
1882 char *buf)
1883 {
1884 return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_autosleep_ack);
1885 }
1886
1887 static struct device_attribute dev_attr_hotkey_wakeup_hotunplug_complete =
1888 __ATTR(wakeup_hotunplug_complete, S_IRUGO,
1889 hotkey_wakeup_hotunplug_complete_show, NULL);
1890
1891 static void hotkey_wakeup_hotunplug_complete_notify_change(void)
1892 {
1893 if (tp_features.hotkey_mask)
1894 sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
1895 "wakeup_hotunplug_complete");
1896 }
1897
1898 /* --------------------------------------------------------------------- */
1899
1900 static struct attribute *hotkey_attributes[] __initdata = {
1901 &dev_attr_hotkey_enable.attr,
1902 &dev_attr_hotkey_bios_enabled.attr,
1903 &dev_attr_hotkey_report_mode.attr,
1904 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1905 &dev_attr_hotkey_mask.attr,
1906 &dev_attr_hotkey_all_mask.attr,
1907 &dev_attr_hotkey_recommended_mask.attr,
1908 &dev_attr_hotkey_source_mask.attr,
1909 &dev_attr_hotkey_poll_freq.attr,
1910 #endif
1911 };
1912
1913 static struct attribute *hotkey_mask_attributes[] __initdata = {
1914 &dev_attr_hotkey_bios_mask.attr,
1915 #ifndef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1916 &dev_attr_hotkey_mask.attr,
1917 &dev_attr_hotkey_all_mask.attr,
1918 &dev_attr_hotkey_recommended_mask.attr,
1919 #endif
1920 &dev_attr_hotkey_wakeup_reason.attr,
1921 &dev_attr_hotkey_wakeup_hotunplug_complete.attr,
1922 };
1923
1924 static int __init hotkey_init(struct ibm_init_struct *iibm)
1925 {
1926 /* Requirements for changing the default keymaps:
1927 *
1928 * 1. Many of the keys are mapped to KEY_RESERVED for very
1929 * good reasons. Do not change them unless you have deep
1930 * knowledge on the IBM and Lenovo ThinkPad firmware for
1931 * the various ThinkPad models. The driver behaves
1932 * differently for KEY_RESERVED: such keys have their
1933 * hot key mask *unset* in mask_recommended, and also
1934 * in the initial hot key mask programmed into the
1935 * firmware at driver load time, which means the firm-
1936 * ware may react very differently if you change them to
1937 * something else;
1938 *
1939 * 2. You must be subscribed to the linux-thinkpad and
1940 * ibm-acpi-devel mailing lists, and you should read the
1941 * list archives since 2007 if you want to change the
1942 * keymaps. This requirement exists so that you will
1943 * know the past history of problems with the thinkpad-
1944 * acpi driver keymaps, and also that you will be
1945 * listening to any bug reports;
1946 *
1947 * 3. Do not send thinkpad-acpi specific patches directly to
1948 * for merging, *ever*. Send them to the linux-acpi
1949 * mailinglist for comments. Merging is to be done only
1950 * through acpi-test and the ACPI maintainer.
1951 *
1952 * If the above is too much to ask, don't change the keymap.
1953 * Ask the thinkpad-acpi maintainer to do it, instead.
1954 */
1955 static u16 ibm_keycode_map[] __initdata = {
1956 /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
1957 KEY_FN_F1, KEY_FN_F2, KEY_COFFEE, KEY_SLEEP,
1958 KEY_WLAN, KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
1959 KEY_FN_F9, KEY_FN_F10, KEY_FN_F11, KEY_SUSPEND,
1960
1961 /* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */
1962 KEY_UNKNOWN, /* 0x0C: FN+BACKSPACE */
1963 KEY_UNKNOWN, /* 0x0D: FN+INSERT */
1964 KEY_UNKNOWN, /* 0x0E: FN+DELETE */
1965
1966 /* brightness: firmware always reacts to them, unless
1967 * X.org did some tricks in the radeon BIOS scratch
1968 * registers of *some* models */
1969 KEY_RESERVED, /* 0x0F: FN+HOME (brightness up) */
1970 KEY_RESERVED, /* 0x10: FN+END (brightness down) */
1971
1972 /* Thinklight: firmware always react to it */
1973 KEY_RESERVED, /* 0x11: FN+PGUP (thinklight toggle) */
1974
1975 KEY_UNKNOWN, /* 0x12: FN+PGDOWN */
1976 KEY_ZOOM, /* 0x13: FN+SPACE (zoom) */
1977
1978 /* Volume: firmware always react to it and reprograms
1979 * the built-in *extra* mixer. Never map it to control
1980 * another mixer by default. */
1981 KEY_RESERVED, /* 0x14: VOLUME UP */
1982 KEY_RESERVED, /* 0x15: VOLUME DOWN */
1983 KEY_RESERVED, /* 0x16: MUTE */
1984
1985 KEY_VENDOR, /* 0x17: Thinkpad/AccessIBM/Lenovo */
1986
1987 /* (assignments unknown, please report if found) */
1988 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
1989 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
1990 };
1991 static u16 lenovo_keycode_map[] __initdata = {
1992 /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
1993 KEY_FN_F1, KEY_COFFEE, KEY_BATTERY, KEY_SLEEP,
1994 KEY_WLAN, KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
1995 KEY_FN_F9, KEY_FN_F10, KEY_FN_F11, KEY_SUSPEND,
1996
1997 /* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */
1998 KEY_UNKNOWN, /* 0x0C: FN+BACKSPACE */
1999 KEY_UNKNOWN, /* 0x0D: FN+INSERT */
2000 KEY_UNKNOWN, /* 0x0E: FN+DELETE */
2001
2002 /* These either have to go through ACPI video, or
2003 * act like in the IBM ThinkPads, so don't ever
2004 * enable them by default */
2005 KEY_RESERVED, /* 0x0F: FN+HOME (brightness up) */
2006 KEY_RESERVED, /* 0x10: FN+END (brightness down) */
2007
2008 KEY_RESERVED, /* 0x11: FN+PGUP (thinklight toggle) */
2009
2010 KEY_UNKNOWN, /* 0x12: FN+PGDOWN */
2011 KEY_ZOOM, /* 0x13: FN+SPACE (zoom) */
2012
2013 /* Volume: z60/z61, T60 (BIOS version?): firmware always
2014 * react to it and reprograms the built-in *extra* mixer.
2015 * Never map it to control another mixer by default.
2016 *
2017 * T60?, T61, R60?, R61: firmware and EC tries to send
2018 * these over the regular keyboard, so these are no-ops,
2019 * but there are still weird bugs re. MUTE, so do not
2020 * change unless you get test reports from all Lenovo
2021 * models. May cause the BIOS to interfere with the
2022 * HDA mixer.
2023 */
2024 KEY_RESERVED, /* 0x14: VOLUME UP */
2025 KEY_RESERVED, /* 0x15: VOLUME DOWN */
2026 KEY_RESERVED, /* 0x16: MUTE */
2027
2028 KEY_VENDOR, /* 0x17: Thinkpad/AccessIBM/Lenovo */
2029
2030 /* (assignments unknown, please report if found) */
2031 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
2032 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
2033 };
2034
2035 #define TPACPI_HOTKEY_MAP_LEN ARRAY_SIZE(ibm_keycode_map)
2036 #define TPACPI_HOTKEY_MAP_SIZE sizeof(ibm_keycode_map)
2037 #define TPACPI_HOTKEY_MAP_TYPESIZE sizeof(ibm_keycode_map[0])
2038
2039 int res, i;
2040 int status;
2041 int hkeyv;
2042
2043 vdbg_printk(TPACPI_DBG_INIT, "initializing hotkey subdriver\n");
2044
2045 BUG_ON(!tpacpi_inputdev);
2046 BUG_ON(tpacpi_inputdev->open != NULL ||
2047 tpacpi_inputdev->close != NULL);
2048
2049 TPACPI_ACPIHANDLE_INIT(hkey);
2050 mutex_init(&hotkey_mutex);
2051
2052 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2053 mutex_init(&hotkey_thread_mutex);
2054 mutex_init(&hotkey_thread_data_mutex);
2055 #endif
2056
2057 /* hotkey not supported on 570 */
2058 tp_features.hotkey = hkey_handle != NULL;
2059
2060 vdbg_printk(TPACPI_DBG_INIT, "hotkeys are %s\n",
2061 str_supported(tp_features.hotkey));
2062
2063 if (tp_features.hotkey) {
2064 hotkey_dev_attributes = create_attr_set(13, NULL);
2065 if (!hotkey_dev_attributes)
2066 return -ENOMEM;
2067 res = add_many_to_attr_set(hotkey_dev_attributes,
2068 hotkey_attributes,
2069 ARRAY_SIZE(hotkey_attributes));
2070 if (res)
2071 return res;
2072
2073 /* mask not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
2074 A30, R30, R31, T20-22, X20-21, X22-24. Detected by checking
2075 for HKEY interface version 0x100 */
2076 if (acpi_evalf(hkey_handle, &hkeyv, "MHKV", "qd")) {
2077 if ((hkeyv >> 8) != 1) {
2078 printk(TPACPI_ERR "unknown version of the "
2079 "HKEY interface: 0x%x\n", hkeyv);
2080 printk(TPACPI_ERR "please report this to %s\n",
2081 TPACPI_MAIL);
2082 } else {
2083 /*
2084 * MHKV 0x100 in A31, R40, R40e,
2085 * T4x, X31, and later
2086 */
2087 tp_features.hotkey_mask = 1;
2088 }
2089 }
2090
2091 vdbg_printk(TPACPI_DBG_INIT, "hotkey masks are %s\n",
2092 str_supported(tp_features.hotkey_mask));
2093
2094 if (tp_features.hotkey_mask) {
2095 if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
2096 "MHKA", "qd")) {
2097 printk(TPACPI_ERR
2098 "missing MHKA handler, "
2099 "please report this to %s\n",
2100 TPACPI_MAIL);
2101 /* FN+F12, FN+F4, FN+F3 */
2102 hotkey_all_mask = 0x080cU;
2103 }
2104 }
2105
2106 /* hotkey_source_mask *must* be zero for
2107 * the first hotkey_mask_get */
2108 res = hotkey_status_get(&hotkey_orig_status);
2109 if (!res && tp_features.hotkey_mask) {
2110 res = hotkey_mask_get();
2111 hotkey_orig_mask = hotkey_mask;
2112 if (!res) {
2113 res = add_many_to_attr_set(
2114 hotkey_dev_attributes,
2115 hotkey_mask_attributes,
2116 ARRAY_SIZE(hotkey_mask_attributes));
2117 }
2118 }
2119
2120 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2121 if (tp_features.hotkey_mask) {
2122 hotkey_source_mask = TPACPI_HKEY_NVRAM_GOOD_MASK
2123 & ~hotkey_all_mask;
2124 } else {
2125 hotkey_source_mask = TPACPI_HKEY_NVRAM_GOOD_MASK;
2126 }
2127
2128 vdbg_printk(TPACPI_DBG_INIT,
2129 "hotkey source mask 0x%08x, polling freq %d\n",
2130 hotkey_source_mask, hotkey_poll_freq);
2131 #endif
2132
2133 /* Not all thinkpads have a hardware radio switch */
2134 if (!res && acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
2135 tp_features.hotkey_wlsw = 1;
2136 printk(TPACPI_INFO
2137 "radio switch found; radios are %s\n",
2138 enabled(status, 0));
2139 res = add_to_attr_set(hotkey_dev_attributes,
2140 &dev_attr_hotkey_radio_sw.attr);
2141 }
2142
2143 /* For X41t, X60t, X61t Tablets... */
2144 if (!res && acpi_evalf(hkey_handle, &status, "MHKG", "qd")) {
2145 tp_features.hotkey_tablet = 1;
2146 printk(TPACPI_INFO
2147 "possible tablet mode switch found; "
2148 "ThinkPad in %s mode\n",
2149 (status & TP_HOTKEY_TABLET_MASK)?
2150 "tablet" : "laptop");
2151 res = add_to_attr_set(hotkey_dev_attributes,
2152 &dev_attr_hotkey_tablet_mode.attr);
2153 }
2154
2155 if (!res)
2156 res = register_attr_set_with_sysfs(
2157 hotkey_dev_attributes,
2158 &tpacpi_pdev->dev.kobj);
2159 if (res)
2160 return res;
2161
2162 /* Set up key map */
2163
2164 hotkey_keycode_map = kmalloc(TPACPI_HOTKEY_MAP_SIZE,
2165 GFP_KERNEL);
2166 if (!hotkey_keycode_map) {
2167 printk(TPACPI_ERR
2168 "failed to allocate memory for key map\n");
2169 return -ENOMEM;
2170 }
2171
2172 if (thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO) {
2173 dbg_printk(TPACPI_DBG_INIT,
2174 "using Lenovo default hot key map\n");
2175 memcpy(hotkey_keycode_map, &lenovo_keycode_map,
2176 TPACPI_HOTKEY_MAP_SIZE);
2177 } else {
2178 dbg_printk(TPACPI_DBG_INIT,
2179 "using IBM default hot key map\n");
2180 memcpy(hotkey_keycode_map, &ibm_keycode_map,
2181 TPACPI_HOTKEY_MAP_SIZE);
2182 }
2183
2184 set_bit(EV_KEY, tpacpi_inputdev->evbit);
2185 set_bit(EV_MSC, tpacpi_inputdev->evbit);
2186 set_bit(MSC_SCAN, tpacpi_inputdev->mscbit);
2187 tpacpi_inputdev->keycodesize = TPACPI_HOTKEY_MAP_TYPESIZE;
2188 tpacpi_inputdev->keycodemax = TPACPI_HOTKEY_MAP_LEN;
2189 tpacpi_inputdev->keycode = hotkey_keycode_map;
2190 for (i = 0; i < TPACPI_HOTKEY_MAP_LEN; i++) {
2191 if (hotkey_keycode_map[i] != KEY_RESERVED) {
2192 set_bit(hotkey_keycode_map[i],
2193 tpacpi_inputdev->keybit);
2194 } else {
2195 if (i < sizeof(hotkey_reserved_mask)*8)
2196 hotkey_reserved_mask |= 1 << i;
2197 }
2198 }
2199
2200 if (tp_features.hotkey_wlsw) {
2201 set_bit(EV_SW, tpacpi_inputdev->evbit);
2202 set_bit(SW_RADIO, tpacpi_inputdev->swbit);
2203 }
2204 if (tp_features.hotkey_tablet) {
2205 set_bit(EV_SW, tpacpi_inputdev->evbit);
2206 set_bit(SW_TABLET_MODE, tpacpi_inputdev->swbit);
2207 }
2208
2209 /* Do not issue duplicate brightness change events to
2210 * userspace */
2211 if (!tp_features.bright_acpimode)
2212 /* update bright_acpimode... */
2213 tpacpi_check_std_acpi_brightness_support();
2214
2215 if (tp_features.bright_acpimode) {
2216 printk(TPACPI_INFO
2217 "This ThinkPad has standard ACPI backlight "
2218 "brightness control, supported by the ACPI "
2219 "video driver\n");
2220 printk(TPACPI_NOTICE
2221 "Disabling thinkpad-acpi brightness events "
2222 "by default...\n");
2223
2224 /* The hotkey_reserved_mask change below is not
2225 * necessary while the keys are at KEY_RESERVED in the
2226 * default map, but better safe than sorry, leave it
2227 * here as a marker of what we have to do, especially
2228 * when we finally become able to set this at runtime
2229 * on response to X.org requests */
2230 hotkey_reserved_mask |=
2231 (1 << TP_ACPI_HOTKEYSCAN_FNHOME)
2232 | (1 << TP_ACPI_HOTKEYSCAN_FNEND);
2233 }
2234
2235 dbg_printk(TPACPI_DBG_INIT,
2236 "enabling hot key handling\n");
2237 res = hotkey_status_set(1);
2238 if (res)
2239 return res;
2240 res = hotkey_mask_set(((hotkey_all_mask | hotkey_source_mask)
2241 & ~hotkey_reserved_mask)
2242 | hotkey_orig_mask);
2243 if (res < 0 && res != -ENXIO)
2244 return res;
2245
2246 dbg_printk(TPACPI_DBG_INIT,
2247 "legacy hot key reporting over procfs %s\n",
2248 (hotkey_report_mode < 2) ?
2249 "enabled" : "disabled");
2250
2251 tpacpi_inputdev->open = &hotkey_inputdev_open;
2252 tpacpi_inputdev->close = &hotkey_inputdev_close;
2253
2254 hotkey_poll_setup_safe(1);
2255 tpacpi_input_send_radiosw();
2256 tpacpi_input_send_tabletsw();
2257 }
2258
2259 return (tp_features.hotkey)? 0 : 1;
2260 }
2261
2262 static void hotkey_exit(void)
2263 {
2264 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2265 hotkey_poll_stop_sync();
2266 #endif
2267
2268 if (tp_features.hotkey) {
2269 dbg_printk(TPACPI_DBG_EXIT,
2270 "restoring original hot key mask\n");
2271 /* no short-circuit boolean operator below! */
2272 if ((hotkey_mask_set(hotkey_orig_mask) |
2273 hotkey_status_set(hotkey_orig_status)) != 0)
2274 printk(TPACPI_ERR
2275 "failed to restore hot key mask "
2276 "to BIOS defaults\n");
2277 }
2278
2279 if (hotkey_dev_attributes) {
2280 delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
2281 hotkey_dev_attributes = NULL;
2282 }
2283 }
2284
2285 static void hotkey_notify(struct ibm_struct *ibm, u32 event)
2286 {
2287 u32 hkey;
2288 unsigned int scancode;
2289 int send_acpi_ev;
2290 int ignore_acpi_ev;
2291 int unk_ev;
2292
2293 if (event != 0x80) {
2294 printk(TPACPI_ERR
2295 "unknown HKEY notification event %d\n", event);
2296 /* forward it to userspace, maybe it knows how to handle it */
2297 acpi_bus_generate_netlink_event(
2298 ibm->acpi->device->pnp.device_class,
2299 ibm->acpi->device->dev.bus_id,
2300 event, 0);
2301 return;
2302 }
2303
2304 while (1) {
2305 if (!acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
2306 printk(TPACPI_ERR "failed to retrieve HKEY event\n");
2307 return;
2308 }
2309
2310 if (hkey == 0) {
2311 /* queue empty */
2312 return;
2313 }
2314
2315 send_acpi_ev = 1;
2316 ignore_acpi_ev = 0;
2317 unk_ev = 0;
2318
2319 switch (hkey >> 12) {
2320 case 1:
2321 /* 0x1000-0x1FFF: key presses */
2322 scancode = hkey & 0xfff;
2323 if (scancode > 0 && scancode < 0x21) {
2324 scancode--;
2325 if (!(hotkey_source_mask & (1 << scancode))) {
2326 tpacpi_input_send_key(scancode);
2327 send_acpi_ev = 0;
2328 } else {
2329 ignore_acpi_ev = 1;
2330 }
2331 } else {
2332 unk_ev = 1;
2333 }
2334 break;
2335 case 2:
2336 /* Wakeup reason */
2337 switch (hkey) {
2338 case 0x2304: /* suspend, undock */
2339 case 0x2404: /* hibernation, undock */
2340 hotkey_wakeup_reason = TP_ACPI_WAKEUP_UNDOCK;
2341 ignore_acpi_ev = 1;
2342 break;
2343 case 0x2305: /* suspend, bay eject */
2344 case 0x2405: /* hibernation, bay eject */
2345 hotkey_wakeup_reason = TP_ACPI_WAKEUP_BAYEJ;
2346 ignore_acpi_ev = 1;
2347 break;
2348 default:
2349 unk_ev = 1;
2350 }
2351 if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
2352 printk(TPACPI_INFO
2353 "woke up due to a hot-unplug "
2354 "request...\n");
2355 hotkey_wakeup_reason_notify_change();
2356 }
2357 break;
2358 case 3:
2359 /* bay-related wakeups */
2360 if (hkey == 0x3003) {
2361 hotkey_autosleep_ack = 1;
2362 printk(TPACPI_INFO
2363 "bay ejected\n");
2364 hotkey_wakeup_hotunplug_complete_notify_change();
2365 } else {
2366 unk_ev = 1;
2367 }
2368 break;
2369 case 4:
2370 /* dock-related wakeups */
2371 if (hkey == 0x4003) {
2372 hotkey_autosleep_ack = 1;
2373 printk(TPACPI_INFO
2374 "undocked\n");
2375 hotkey_wakeup_hotunplug_complete_notify_change();
2376 } else {
2377 unk_ev = 1;
2378 }
2379 break;
2380 case 5:
2381 /* 0x5000-0x5FFF: human interface helpers */
2382 switch (hkey) {
2383 case 0x5010: /* Lenovo new BIOS: brightness changed */
2384 case 0x500b: /* X61t: tablet pen inserted into bay */
2385 case 0x500c: /* X61t: tablet pen removed from bay */
2386 break;
2387 case 0x5009: /* X41t-X61t: swivel up (tablet mode) */
2388 case 0x500a: /* X41t-X61t: swivel down (normal mode) */
2389 tpacpi_input_send_tabletsw();
2390 hotkey_tablet_mode_notify_change();
2391 send_acpi_ev = 0;
2392 break;
2393 case 0x5001:
2394 case 0x5002:
2395 /* LID switch events. Do not propagate */
2396 ignore_acpi_ev = 1;
2397 break;
2398 default:
2399 unk_ev = 1;
2400 }
2401 break;
2402 case 7:
2403 /* 0x7000-0x7FFF: misc */
2404 if (tp_features.hotkey_wlsw && hkey == 0x7000) {
2405 tpacpi_input_send_radiosw();
2406 hotkey_radio_sw_notify_change();
2407 send_acpi_ev = 0;
2408 break;
2409 }
2410 /* fallthrough to default */
2411 default:
2412 unk_ev = 1;
2413 }
2414 if (unk_ev) {
2415 printk(TPACPI_NOTICE
2416 "unhandled HKEY event 0x%04x\n", hkey);
2417 }
2418
2419 /* Legacy events */
2420 if (!ignore_acpi_ev &&
2421 (send_acpi_ev || hotkey_report_mode < 2)) {
2422 acpi_bus_generate_proc_event(ibm->acpi->device,
2423 event, hkey);
2424 }
2425
2426 /* netlink events */
2427 if (!ignore_acpi_ev && send_acpi_ev) {
2428 acpi_bus_generate_netlink_event(
2429 ibm->acpi->device->pnp.device_class,
2430 ibm->acpi->device->dev.bus_id,
2431 event, hkey);
2432 }
2433 }
2434 }
2435
2436 static void hotkey_suspend(pm_message_t state)
2437 {
2438 /* Do these on suspend, we get the events on early resume! */
2439 hotkey_wakeup_reason = TP_ACPI_WAKEUP_NONE;
2440 hotkey_autosleep_ack = 0;
2441 }
2442
2443 static void hotkey_resume(void)
2444 {
2445 if (hotkey_mask_get())
2446 printk(TPACPI_ERR
2447 "error while trying to read hot key mask "
2448 "from firmware\n");
2449 tpacpi_input_send_radiosw();
2450 hotkey_radio_sw_notify_change();
2451 hotkey_tablet_mode_notify_change();
2452 hotkey_wakeup_reason_notify_change();
2453 hotkey_wakeup_hotunplug_complete_notify_change();
2454 hotkey_poll_setup_safe(0);
2455 }
2456
2457 /* procfs -------------------------------------------------------------- */
2458 static int hotkey_read(char *p)
2459 {
2460 int res, status;
2461 int len = 0;
2462
2463 if (!tp_features.hotkey) {
2464 len += sprintf(p + len, "status:\t\tnot supported\n");
2465 return len;
2466 }
2467
2468 if (mutex_lock_interruptible(&hotkey_mutex))
2469 return -ERESTARTSYS;
2470 res = hotkey_status_get(&status);
2471 if (!res)
2472 res = hotkey_mask_get();
2473 mutex_unlock(&hotkey_mutex);
2474 if (res)
2475 return res;
2476
2477 len += sprintf(p + len, "status:\t\t%s\n", enabled(status, 0));
2478 if (tp_features.hotkey_mask) {
2479 len += sprintf(p + len, "mask:\t\t0x%08x\n", hotkey_mask);
2480 len += sprintf(p + len,
2481 "commands:\tenable, disable, reset, <mask>\n");
2482 } else {
2483 len += sprintf(p + len, "mask:\t\tnot supported\n");
2484 len += sprintf(p + len, "commands:\tenable, disable, reset\n");
2485 }
2486
2487 return len;
2488 }
2489
2490 static int hotkey_write(char *buf)
2491 {
2492 int res, status;
2493 u32 mask;
2494 char *cmd;
2495
2496 if (!tp_features.hotkey)
2497 return -ENODEV;
2498
2499 if (mutex_lock_interruptible(&hotkey_mutex))
2500 return -ERESTARTSYS;
2501
2502 status = -1;
2503 mask = hotkey_mask;
2504
2505 res = 0;
2506 while ((cmd = next_cmd(&buf))) {
2507 if (strlencmp(cmd, "enable") == 0) {
2508 status = 1;
2509 } else if (strlencmp(cmd, "disable") == 0) {
2510 status = 0;
2511 } else if (strlencmp(cmd, "reset") == 0) {
2512 status = hotkey_orig_status;
2513 mask = hotkey_orig_mask;
2514 } else if (sscanf(cmd, "0x%x", &mask) == 1) {
2515 /* mask set */
2516 } else if (sscanf(cmd, "%x", &mask) == 1) {
2517 /* mask set */
2518 } else {
2519 res = -EINVAL;
2520 goto errexit;
2521 }
2522 }
2523 if (status != -1)
2524 res = hotkey_status_set(status);
2525
2526 if (!res && mask != hotkey_mask)
2527 res = hotkey_mask_set(mask);
2528
2529 errexit:
2530 mutex_unlock(&hotkey_mutex);
2531 return res;
2532 }
2533
2534 static const struct acpi_device_id ibm_htk_device_ids[] = {
2535 {TPACPI_ACPI_HKEY_HID, 0},
2536 {"", 0},
2537 };
2538
2539 static struct tp_acpi_drv_struct ibm_hotkey_acpidriver = {
2540 .hid = ibm_htk_device_ids,
2541 .notify = hotkey_notify,
2542 .handle = &hkey_handle,
2543 .type = ACPI_DEVICE_NOTIFY,
2544 };
2545
2546 static struct ibm_struct hotkey_driver_data = {
2547 .name = "hotkey",
2548 .read = hotkey_read,
2549 .write = hotkey_write,
2550 .exit = hotkey_exit,
2551 .resume = hotkey_resume,
2552 .suspend = hotkey_suspend,
2553 .acpi = &ibm_hotkey_acpidriver,
2554 };
2555
2556 /*************************************************************************
2557 * Bluetooth subdriver
2558 */
2559
2560 enum {
2561 /* ACPI GBDC/SBDC bits */
2562 TP_ACPI_BLUETOOTH_HWPRESENT = 0x01, /* Bluetooth hw available */
2563 TP_ACPI_BLUETOOTH_RADIOSSW = 0x02, /* Bluetooth radio enabled */
2564 TP_ACPI_BLUETOOTH_UNK = 0x04, /* unknown function */
2565 };
2566
2567 static int bluetooth_get_radiosw(void);
2568 static int bluetooth_set_radiosw(int radio_on);
2569
2570 /* sysfs bluetooth enable ---------------------------------------------- */
2571 static ssize_t bluetooth_enable_show(struct device *dev,
2572 struct device_attribute *attr,
2573 char *buf)
2574 {
2575 int status;
2576
2577 status = bluetooth_get_radiosw();
2578 if (status < 0)
2579 return status;
2580
2581 return snprintf(buf, PAGE_SIZE, "%d\n", status ? 1 : 0);
2582 }
2583
2584 static ssize_t bluetooth_enable_store(struct device *dev,
2585 struct device_attribute *attr,
2586 const char *buf, size_t count)
2587 {
2588 unsigned long t;
2589 int res;
2590
2591 if (parse_strtoul(buf, 1, &t))
2592 return -EINVAL;
2593
2594 res = bluetooth_set_radiosw(t);
2595
2596 return (res) ? res : count;
2597 }
2598
2599 static struct device_attribute dev_attr_bluetooth_enable =
2600 __ATTR(bluetooth_enable, S_IWUSR | S_IRUGO,
2601 bluetooth_enable_show, bluetooth_enable_store);
2602
2603 /* --------------------------------------------------------------------- */
2604
2605 static struct attribute *bluetooth_attributes[] = {
2606 &dev_attr_bluetooth_enable.attr,
2607 NULL
2608 };
2609
2610 static const struct attribute_group bluetooth_attr_group = {
2611 .attrs = bluetooth_attributes,
2612 };
2613
2614 static int __init bluetooth_init(struct ibm_init_struct *iibm)
2615 {
2616 int res;
2617 int status = 0;
2618
2619 vdbg_printk(TPACPI_DBG_INIT, "initializing bluetooth subdriver\n");
2620
2621 TPACPI_ACPIHANDLE_INIT(hkey);
2622
2623 /* bluetooth not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
2624 G4x, R30, R31, R40e, R50e, T20-22, X20-21 */
2625 tp_features.bluetooth = hkey_handle &&
2626 acpi_evalf(hkey_handle, &status, "GBDC", "qd");
2627
2628 vdbg_printk(TPACPI_DBG_INIT, "bluetooth is %s, status 0x%02x\n",
2629 str_supported(tp_features.bluetooth),
2630 status);
2631
2632 if (tp_features.bluetooth) {
2633 if (!(status & TP_ACPI_BLUETOOTH_HWPRESENT)) {
2634 /* no bluetooth hardware present in system */
2635 tp_features.bluetooth = 0;
2636 dbg_printk(TPACPI_DBG_INIT,
2637 "bluetooth hardware not installed\n");
2638 } else {
2639 res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
2640 &bluetooth_attr_group);
2641 if (res)
2642 return res;
2643 }
2644 }
2645
2646 return (tp_features.bluetooth)? 0 : 1;
2647 }
2648
2649 static void bluetooth_exit(void)
2650 {
2651 sysfs_remove_group(&tpacpi_pdev->dev.kobj,
2652 &bluetooth_attr_group);
2653 }
2654
2655 static int bluetooth_get_radiosw(void)
2656 {
2657 int status;
2658
2659 if (!tp_features.bluetooth)
2660 return -ENODEV;
2661
2662 if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
2663 return -EIO;
2664
2665 return ((status & TP_ACPI_BLUETOOTH_RADIOSSW) != 0);
2666 }
2667
2668 static int bluetooth_set_radiosw(int radio_on)
2669 {
2670 int status;
2671
2672 if (!tp_features.bluetooth)
2673 return -ENODEV;
2674
2675 if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
2676 return -EIO;
2677 if (radio_on)
2678 status |= TP_ACPI_BLUETOOTH_RADIOSSW;
2679 else
2680 status &= ~TP_ACPI_BLUETOOTH_RADIOSSW;
2681 if (!acpi_evalf(hkey_handle, NULL, "SBDC", "vd", status))
2682 return -EIO;
2683
2684 return 0;
2685 }
2686
2687 /* procfs -------------------------------------------------------------- */
2688 static int bluetooth_read(char *p)
2689 {
2690 int len = 0;
2691 int status = bluetooth_get_radiosw();
2692
2693 if (!tp_features.bluetooth)
2694 len += sprintf(p + len, "status:\t\tnot supported\n");
2695 else {
2696 len += sprintf(p + len, "status:\t\t%s\n",
2697 (status)? "enabled" : "disabled");
2698 len += sprintf(p + len, "commands:\tenable, disable\n");
2699 }
2700
2701 return len;
2702 }
2703
2704 static int bluetooth_write(char *buf)
2705 {
2706 char *cmd;
2707
2708 if (!tp_features.bluetooth)
2709 return -ENODEV;
2710
2711 while ((cmd = next_cmd(&buf))) {
2712 if (strlencmp(cmd, "enable") == 0) {
2713 bluetooth_set_radiosw(1);
2714 } else if (strlencmp(cmd, "disable") == 0) {
2715 bluetooth_set_radiosw(0);
2716 } else
2717 return -EINVAL;
2718 }
2719
2720 return 0;
2721 }
2722
2723 static struct ibm_struct bluetooth_driver_data = {
2724 .name = "bluetooth",
2725 .read = bluetooth_read,
2726 .write = bluetooth_write,
2727 .exit = bluetooth_exit,
2728 };
2729
2730 /*************************************************************************
2731 * Wan subdriver
2732 */
2733
2734 enum {
2735 /* ACPI GWAN/SWAN bits */
2736 TP_ACPI_WANCARD_HWPRESENT = 0x01, /* Wan hw available */
2737 TP_ACPI_WANCARD_RADIOSSW = 0x02, /* Wan radio enabled */
2738 TP_ACPI_WANCARD_UNK = 0x04, /* unknown function */
2739 };
2740
2741 static int wan_get_radiosw(void);
2742 static int wan_set_radiosw(int radio_on);
2743
2744 /* sysfs wan enable ---------------------------------------------------- */
2745 static ssize_t wan_enable_show(struct device *dev,
2746 struct device_attribute *attr,
2747 char *buf)
2748 {
2749 int status;
2750
2751 status = wan_get_radiosw();
2752 if (status < 0)
2753 return status;
2754
2755 return snprintf(buf, PAGE_SIZE, "%d\n", status ? 1 : 0);
2756 }
2757
2758 static ssize_t wan_enable_store(struct device *dev,
2759 struct device_attribute *attr,
2760 const char *buf, size_t count)
2761 {
2762 unsigned long t;
2763 int res;
2764
2765 if (parse_strtoul(buf, 1, &t))
2766 return -EINVAL;
2767
2768 res = wan_set_radiosw(t);
2769
2770 return (res) ? res : count;
2771 }
2772
2773 static struct device_attribute dev_attr_wan_enable =
2774 __ATTR(wwan_enable, S_IWUSR | S_IRUGO,
2775 wan_enable_show, wan_enable_store);
2776
2777 /* --------------------------------------------------------------------- */
2778
2779 static struct attribute *wan_attributes[] = {
2780 &dev_attr_wan_enable.attr,
2781 NULL
2782 };
2783
2784 static const struct attribute_group wan_attr_group = {
2785 .attrs = wan_attributes,
2786 };
2787
2788 static int __init wan_init(struct ibm_init_struct *iibm)
2789 {
2790 int res;
2791 int status = 0;
2792
2793 vdbg_printk(TPACPI_DBG_INIT, "initializing wan subdriver\n");
2794
2795 TPACPI_ACPIHANDLE_INIT(hkey);
2796
2797 tp_features.wan = hkey_handle &&
2798 acpi_evalf(hkey_handle, &status, "GWAN", "qd");
2799
2800 vdbg_printk(TPACPI_DBG_INIT, "wan is %s, status 0x%02x\n",
2801 str_supported(tp_features.wan),
2802 status);
2803
2804 if (tp_features.wan) {
2805 if (!(status & TP_ACPI_WANCARD_HWPRESENT)) {
2806 /* no wan hardware present in system */
2807 tp_features.wan = 0;
2808 dbg_printk(TPACPI_DBG_INIT,
2809 "wan hardware not installed\n");
2810 } else {
2811 res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
2812 &wan_attr_group);
2813 if (res)
2814 return res;
2815 }
2816 }
2817
2818 return (tp_features.wan)? 0 : 1;
2819 }
2820
2821 static void wan_exit(void)
2822 {
2823 sysfs_remove_group(&tpacpi_pdev->dev.kobj,
2824 &wan_attr_group);
2825 }
2826
2827 static int wan_get_radiosw(void)
2828 {
2829 int status;
2830
2831 if (!tp_features.wan)
2832 return -ENODEV;
2833
2834 if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
2835 return -EIO;
2836
2837 return ((status & TP_ACPI_WANCARD_RADIOSSW) != 0);
2838 }
2839
2840 static int wan_set_radiosw(int radio_on)
2841 {
2842 int status;
2843
2844 if (!tp_features.wan)
2845 return -ENODEV;
2846
2847 if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
2848 return -EIO;
2849 if (radio_on)
2850 status |= TP_ACPI_WANCARD_RADIOSSW;
2851 else
2852 status &= ~TP_ACPI_WANCARD_RADIOSSW;
2853 if (!acpi_evalf(hkey_handle, NULL, "SWAN", "vd", status))
2854 return -EIO;
2855
2856 return 0;
2857 }
2858
2859 /* procfs -------------------------------------------------------------- */
2860 static int wan_read(char *p)
2861 {
2862 int len = 0;
2863 int status = wan_get_radiosw();
2864
2865 if (!tp_features.wan)
2866 len += sprintf(p + len, "status:\t\tnot supported\n");
2867 else {
2868 len += sprintf(p + len, "status:\t\t%s\n",
2869 (status)? "enabled" : "disabled");
2870 len += sprintf(p + len, "commands:\tenable, disable\n");
2871 }
2872
2873 return len;
2874 }
2875
2876 static int wan_write(char *buf)
2877 {
2878 char *cmd;
2879
2880 if (!tp_features.wan)
2881 return -ENODEV;
2882
2883 while ((cmd = next_cmd(&buf))) {
2884 if (strlencmp(cmd, "enable") == 0) {
2885 wan_set_radiosw(1);
2886 } else if (strlencmp(cmd, "disable") == 0) {
2887 wan_set_radiosw(0);
2888 } else
2889 return -EINVAL;
2890 }
2891
2892 return 0;
2893 }
2894
2895 static struct ibm_struct wan_driver_data = {
2896 .name = "wan",
2897 .read = wan_read,
2898 .write = wan_write,
2899 .exit = wan_exit,
2900 .flags.experimental = 1,
2901 };
2902
2903 /*************************************************************************
2904 * Video subdriver
2905 */
2906
2907 #ifdef CONFIG_THINKPAD_ACPI_VIDEO
2908
2909 enum video_access_mode {
2910 TPACPI_VIDEO_NONE = 0,
2911 TPACPI_VIDEO_570, /* 570 */
2912 TPACPI_VIDEO_770, /* 600e/x, 770e, 770x */
2913 TPACPI_VIDEO_NEW, /* all others */
2914 };
2915
2916 enum { /* video status flags, based on VIDEO_570 */
2917 TP_ACPI_VIDEO_S_LCD = 0x01, /* LCD output enabled */
2918 TP_ACPI_VIDEO_S_CRT = 0x02, /* CRT output enabled */
2919 TP_ACPI_VIDEO_S_DVI = 0x08, /* DVI output enabled */
2920 };
2921
2922 enum { /* TPACPI_VIDEO_570 constants */
2923 TP_ACPI_VIDEO_570_PHSCMD = 0x87, /* unknown magic constant :( */
2924 TP_ACPI_VIDEO_570_PHSMASK = 0x03, /* PHS bits that map to
2925 * video_status_flags */
2926 TP_ACPI_VIDEO_570_PHS2CMD = 0x8b, /* unknown magic constant :( */
2927 TP_ACPI_VIDEO_570_PHS2SET = 0x80, /* unknown magic constant :( */
2928 };
2929
2930 static enum video_access_mode video_supported;
2931 static int video_orig_autosw;
2932
2933 static int video_autosw_get(void);
2934 static int video_autosw_set(int enable);
2935
2936 TPACPI_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID"); /* G41 */
2937
2938 static int __init video_init(struct ibm_init_struct *iibm)
2939 {
2940 int ivga;
2941
2942 vdbg_printk(TPACPI_DBG_INIT, "initializing video subdriver\n");
2943
2944 TPACPI_ACPIHANDLE_INIT(vid);
2945 TPACPI_ACPIHANDLE_INIT(vid2);
2946
2947 if (vid2_handle && acpi_evalf(NULL, &ivga, "\\IVGA", "d") && ivga)
2948 /* G41, assume IVGA doesn't change */
2949 vid_handle = vid2_handle;
2950
2951 if (!vid_handle)
2952 /* video switching not supported on R30, R31 */
2953 video_supported = TPACPI_VIDEO_NONE;
2954 else if (acpi_evalf(vid_handle, &video_orig_autosw, "SWIT", "qd"))
2955 /* 570 */
2956 video_supported = TPACPI_VIDEO_570;
2957 else if (acpi_evalf(vid_handle, &video_orig_autosw, "^VADL", "qd"))
2958 /* 600e/x, 770e, 770x */
2959 video_supported = TPACPI_VIDEO_770;
2960 else
2961 /* all others */
2962 video_supported = TPACPI_VIDEO_NEW;
2963
2964 vdbg_printk(TPACPI_DBG_INIT, "video is %s, mode %d\n",
2965 str_supported(video_supported != TPACPI_VIDEO_NONE),
2966 video_supported);
2967
2968 return (video_supported != TPACPI_VIDEO_NONE)? 0 : 1;
2969 }
2970
2971 static void video_exit(void)
2972 {
2973 dbg_printk(TPACPI_DBG_EXIT,
2974 "restoring original video autoswitch mode\n");
2975 if (video_autosw_set(video_orig_autosw))
2976 printk(TPACPI_ERR "error while trying to restore original "
2977 "video autoswitch mode\n");
2978 }
2979
2980 static int video_outputsw_get(void)
2981 {
2982 int status = 0;
2983 int i;
2984
2985 switch (video_supported) {
2986 case TPACPI_VIDEO_570:
2987 if (!acpi_evalf(NULL, &i, "\\_SB.PHS", "dd",
2988 TP_ACPI_VIDEO_570_PHSCMD))
2989 return -EIO;
2990 status = i & TP_ACPI_VIDEO_570_PHSMASK;
2991 break;
2992 case TPACPI_VIDEO_770:
2993 if (!acpi_evalf(NULL, &i, "\\VCDL", "d"))
2994 return -EIO;
2995 if (i)
2996 status |= TP_ACPI_VIDEO_S_LCD;
2997 if (!acpi_evalf(NULL, &i, "\\VCDC", "d"))
2998 return -EIO;
2999 if (i)
3000 status |= TP_ACPI_VIDEO_S_CRT;
3001 break;
3002 case TPACPI_VIDEO_NEW:
3003 if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 1) ||
3004 !acpi_evalf(NULL, &i, "\\VCDC", "d"))
3005 return -EIO;
3006 if (i)
3007 status |= TP_ACPI_VIDEO_S_CRT;
3008
3009 if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0) ||
3010 !acpi_evalf(NULL, &i, "\\VCDL", "d"))
3011 return -EIO;
3012 if (i)
3013 status |= TP_ACPI_VIDEO_S_LCD;
3014 if (!acpi_evalf(NULL, &i, "\\VCDD", "d"))
3015 return -EIO;
3016 if (i)
3017 status |= TP_ACPI_VIDEO_S_DVI;
3018 break;
3019 default:
3020 return -ENOSYS;
3021 }
3022
3023 return status;
3024 }
3025
3026 static int video_outputsw_set(int status)
3027 {
3028 int autosw;
3029 int res = 0;
3030
3031 switch (video_supported) {
3032 case TPACPI_VIDEO_570:
3033 res = acpi_evalf(NULL, NULL,
3034 "\\_SB.PHS2", "vdd",
3035 TP_ACPI_VIDEO_570_PHS2CMD,
3036 status | TP_ACPI_VIDEO_570_PHS2SET);
3037 break;
3038 case TPACPI_VIDEO_770:
3039 autosw = video_autosw_get();
3040 if (autosw < 0)
3041 return autosw;
3042
3043 res = video_autosw_set(1);
3044 if (res)
3045 return res;
3046 res = acpi_evalf(vid_handle, NULL,
3047 "ASWT", "vdd", status * 0x100, 0);
3048 if (!autosw && video_autosw_set(autosw)) {
3049 printk(TPACPI_ERR
3050 "video auto-switch left enabled due to error\n");
3051 return -EIO;
3052 }
3053 break;
3054 case TPACPI_VIDEO_NEW:
3055 res = acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0x80) &&
3056 acpi_evalf(NULL, NULL, "\\VSDS", "vdd", status, 1);
3057 break;
3058 default:
3059 return -ENOSYS;
3060 }
3061
3062 return (res)? 0 : -EIO;
3063 }
3064
3065 static int video_autosw_get(void)
3066 {
3067 int autosw = 0;
3068
3069 switch (video_supported) {
3070 case TPACPI_VIDEO_570:
3071 if (!acpi_evalf(vid_handle, &autosw, "SWIT", "d"))
3072 return -EIO;
3073 break;
3074 case TPACPI_VIDEO_770:
3075 case TPACPI_VIDEO_NEW:
3076 if (!acpi_evalf(vid_handle, &autosw, "^VDEE", "d"))
3077 return -EIO;
3078 break;
3079 default:
3080 return -ENOSYS;
3081 }
3082
3083 return autosw & 1;
3084 }
3085
3086 static int video_autosw_set(int enable)
3087 {
3088 if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", (enable)? 1 : 0))
3089 return -EIO;
3090 return 0;
3091 }
3092
3093 static int video_outputsw_cycle(void)
3094 {
3095 int autosw = video_autosw_get();
3096 int res;
3097
3098 if (autosw < 0)
3099 return autosw;
3100
3101 switch (video_supported) {
3102 case TPACPI_VIDEO_570:
3103 res = video_autosw_set(1);
3104 if (res)
3105 return res;
3106 res = acpi_evalf(ec_handle, NULL, "_Q16", "v");
3107 break;
3108 case TPACPI_VIDEO_770:
3109 case TPACPI_VIDEO_NEW:
3110 res = video_autosw_set(1);
3111 if (res)
3112 return res;
3113 res = acpi_evalf(vid_handle, NULL, "VSWT", "v");
3114 break;
3115 default:
3116 return -ENOSYS;
3117 }
3118 if (!autosw && video_autosw_set(autosw)) {
3119 printk(TPACPI_ERR
3120 "video auto-switch left enabled due to error\n");
3121 return -EIO;
3122 }
3123
3124 return (res)? 0 : -EIO;
3125 }
3126
3127 static int video_expand_toggle(void)
3128 {
3129 switch (video_supported) {
3130 case TPACPI_VIDEO_570:
3131 return acpi_evalf(ec_handle, NULL, "_Q17", "v")?
3132 0 : -EIO;
3133 case TPACPI_VIDEO_770:
3134 return acpi_evalf(vid_handle, NULL, "VEXP", "v")?
3135 0 : -EIO;
3136 case TPACPI_VIDEO_NEW:
3137 return acpi_evalf(NULL, NULL, "\\VEXP", "v")?
3138 0 : -EIO;
3139 default:
3140 return -ENOSYS;
3141 }
3142 /* not reached */
3143 }
3144
3145 static int video_read(char *p)
3146 {
3147 int status, autosw;
3148 int len = 0;
3149
3150 if (video_supported == TPACPI_VIDEO_NONE) {
3151 len += sprintf(p + len, "status:\t\tnot supported\n");
3152 return len;
3153 }
3154
3155 status = video_outputsw_get();
3156 if (status < 0)
3157 return status;
3158
3159 autosw = video_autosw_get();
3160 if (autosw < 0)
3161 return autosw;
3162
3163 len += sprintf(p + len, "status:\t\tsupported\n");
3164 len += sprintf(p + len, "lcd:\t\t%s\n", enabled(status, 0));
3165 len += sprintf(p + len, "crt:\t\t%s\n", enabled(status, 1));
3166 if (video_supported == TPACPI_VIDEO_NEW)
3167 len += sprintf(p + len, "dvi:\t\t%s\n", enabled(status, 3));
3168 len += sprintf(p + len, "auto:\t\t%s\n", enabled(autosw, 0));
3169 len += sprintf(p + len, "commands:\tlcd_enable, lcd_disable\n");
3170 len += sprintf(p + len, "commands:\tcrt_enable, crt_disable\n");
3171 if (video_supported == TPACPI_VIDEO_NEW)
3172 len += sprintf(p + len, "commands:\tdvi_enable, dvi_disable\n");
3173 len += sprintf(p + len, "commands:\tauto_enable, auto_disable\n");
3174 len += sprintf(p + len, "commands:\tvideo_switch, expand_toggle\n");
3175
3176 return len;
3177 }
3178
3179 static int video_write(char *buf)
3180 {
3181 char *cmd;
3182 int enable, disable, status;
3183 int res;
3184
3185 if (video_supported == TPACPI_VIDEO_NONE)
3186 return -ENODEV;
3187
3188 enable = 0;
3189 disable = 0;
3190
3191 while ((cmd = next_cmd(&buf))) {
3192 if (strlencmp(cmd, "lcd_enable") == 0) {
3193 enable |= TP_ACPI_VIDEO_S_LCD;
3194 } else if (strlencmp(cmd, "lcd_disable") == 0) {
3195 disable |= TP_ACPI_VIDEO_S_LCD;
3196 } else if (strlencmp(cmd, "crt_enable") == 0) {
3197 enable |= TP_ACPI_VIDEO_S_CRT;
3198 } else if (strlencmp(cmd, "crt_disable") == 0) {
3199 disable |= TP_ACPI_VIDEO_S_CRT;
3200 } else if (video_supported == TPACPI_VIDEO_NEW &&
3201 strlencmp(cmd, "dvi_enable") == 0) {
3202 enable |= TP_ACPI_VIDEO_S_DVI;
3203 } else if (video_supported == TPACPI_VIDEO_NEW &&
3204 strlencmp(cmd, "dvi_disable") == 0) {
3205 disable |= TP_ACPI_VIDEO_S_DVI;
3206 } else if (strlencmp(cmd, "auto_enable") == 0) {
3207 res = video_autosw_set(1);
3208 if (res)
3209 return res;
3210 } else if (strlencmp(cmd, "auto_disable") == 0) {
3211 res = video_autosw_set(0);
3212 if (res)
3213 return res;
3214 } else if (strlencmp(cmd, "video_switch") == 0) {
3215 res = video_outputsw_cycle();
3216 if (res)
3217 return res;
3218 } else if (strlencmp(cmd, "expand_toggle") == 0) {
3219 res = video_expand_toggle();
3220 if (res)
3221 return res;
3222 } else
3223 return -EINVAL;
3224 }
3225
3226 if (enable || disable) {
3227 status = video_outputsw_get();
3228 if (status < 0)
3229 return status;
3230 res = video_outputsw_set((status & ~disable) | enable);
3231 if (res)
3232 return res;
3233 }
3234
3235 return 0;
3236 }
3237
3238 static struct ibm_struct video_driver_data = {
3239 .name = "video",
3240 .read = video_read,
3241 .write = video_write,
3242 .exit = video_exit,
3243 };
3244
3245 #endif /* CONFIG_THINKPAD_ACPI_VIDEO */
3246
3247 /*************************************************************************
3248 * Light (thinklight) subdriver
3249 */
3250
3251 TPACPI_HANDLE(lght, root, "\\LGHT"); /* A21e, A2xm/p, T20-22, X20-21 */
3252 TPACPI_HANDLE(ledb, ec, "LEDB"); /* G4x */
3253
3254 static int light_get_status(void)
3255 {
3256 int status = 0;
3257
3258 if (tp_features.light_status) {
3259 if (!acpi_evalf(ec_handle, &status, "KBLT", "d"))
3260 return -EIO;
3261 return (!!status);
3262 }
3263
3264 return -ENXIO;
3265 }
3266
3267 static int light_set_status(int status)
3268 {
3269 int rc;
3270
3271 if (tp_features.light) {
3272 if (cmos_handle) {
3273 rc = acpi_evalf(cmos_handle, NULL, NULL, "vd",
3274 (status)?
3275 TP_CMOS_THINKLIGHT_ON :
3276 TP_CMOS_THINKLIGHT_OFF);
3277 } else {
3278 rc = acpi_evalf(lght_handle, NULL, NULL, "vd",
3279 (status)? 1 : 0);
3280 }
3281 return (rc)? 0 : -EIO;
3282 }
3283
3284 return -ENXIO;
3285 }
3286
3287 static void light_set_status_worker(struct work_struct *work)
3288 {
3289 struct tpacpi_led_classdev *data =
3290 container_of(work, struct tpacpi_led_classdev, work);
3291
3292 if (likely(tpacpi_lifecycle == TPACPI_LIFE_RUNNING))
3293 light_set_status((data->new_brightness != LED_OFF));
3294 }
3295
3296 static void light_sysfs_set(struct led_classdev *led_cdev,
3297 enum led_brightness brightness)
3298 {
3299 struct tpacpi_led_classdev *data =
3300 container_of(led_cdev,
3301 struct tpacpi_led_classdev,
3302 led_classdev);
3303 data->new_brightness = brightness;
3304 queue_work(tpacpi_wq, &data->work);
3305 }
3306
3307 static enum led_brightness light_sysfs_get(struct led_classdev *led_cdev)
3308 {
3309 return (light_get_status() == 1)? LED_FULL : LED_OFF;
3310 }
3311
3312 static struct tpacpi_led_classdev tpacpi_led_thinklight = {
3313 .led_classdev = {
3314 .name = "tpacpi::thinklight",
3315 .brightness_set = &light_sysfs_set,
3316 .brightness_get = &light_sysfs_get,
3317 }
3318 };
3319
3320 static int __init light_init(struct ibm_init_struct *iibm)
3321 {
3322 int rc = 0;
3323
3324 vdbg_printk(TPACPI_DBG_INIT, "initializing light subdriver\n");
3325
3326 TPACPI_ACPIHANDLE_INIT(ledb);
3327 TPACPI_ACPIHANDLE_INIT(lght);
3328 TPACPI_ACPIHANDLE_INIT(cmos);
3329 INIT_WORK(&tpacpi_led_thinklight.work, light_set_status_worker);
3330
3331 /* light not supported on 570, 600e/x, 770e, 770x, G4x, R30, R31 */
3332 tp_features.light = (cmos_handle || lght_handle) && !ledb_handle;
3333
3334 if (tp_features.light)
3335 /* light status not supported on
3336 570, 600e/x, 770e, 770x, G4x, R30, R31, R32, X20 */
3337 tp_features.light_status =
3338 acpi_evalf(ec_handle, NULL, "KBLT", "qv");
3339
3340 vdbg_printk(TPACPI_DBG_INIT, "light is %s\n",
3341 str_supported(tp_features.light));
3342
3343 if (tp_features.light) {
3344 rc = led_classdev_register(&tpacpi_pdev->dev,
3345 &tpacpi_led_thinklight.led_classdev);
3346 }
3347
3348 if (rc < 0) {
3349 tp_features.light = 0;
3350 tp_features.light_status = 0;
3351 } else {
3352 rc = (tp_features.light)? 0 : 1;
3353 }
3354 return rc;
3355 }
3356
3357 static void light_exit(void)
3358 {
3359 led_classdev_unregister(&tpacpi_led_thinklight.led_classdev);
3360 if (work_pending(&tpacpi_led_thinklight.work))
3361 flush_workqueue(tpacpi_wq);
3362 }
3363
3364 static int light_read(char *p)
3365 {
3366 int len = 0;
3367 int status;
3368
3369 if (!tp_features.light) {
3370 len += sprintf(p + len, "status:\t\tnot supported\n");
3371 } else if (!tp_features.light_status) {
3372 len += sprintf(p + len, "status:\t\tunknown\n");
3373 len += sprintf(p + len, "commands:\ton, off\n");
3374 } else {
3375 status = light_get_status();
3376 if (status < 0)
3377 return status;
3378 len += sprintf(p + len, "status:\t\t%s\n", onoff(status, 0));
3379 len += sprintf(p + len, "commands:\ton, off\n");
3380 }
3381
3382 return len;
3383 }
3384
3385 static int light_write(char *buf)
3386 {
3387 char *cmd;
3388 int newstatus = 0;
3389
3390 if (!tp_features.light)
3391 return -ENODEV;
3392
3393 while ((cmd = next_cmd(&buf))) {
3394 if (strlencmp(cmd, "on") == 0) {
3395 newstatus = 1;
3396 } else if (strlencmp(cmd, "off") == 0) {
3397 newstatus = 0;
3398 } else
3399 return -EINVAL;
3400 }
3401
3402 return light_set_status(newstatus);
3403 }
3404
3405 static struct ibm_struct light_driver_data = {
3406 .name = "light",
3407 .read = light_read,
3408 .write = light_write,
3409 .exit = light_exit,
3410 };
3411
3412 /*************************************************************************
3413 * Dock subdriver
3414 */
3415
3416 #ifdef CONFIG_THINKPAD_ACPI_DOCK
3417
3418 static void dock_notify(struct ibm_struct *ibm, u32 event);
3419 static int dock_read(char *p);
3420 static int dock_write(char *buf);
3421
3422 TPACPI_HANDLE(dock, root, "\\_SB.GDCK", /* X30, X31, X40 */
3423 "\\_SB.PCI0.DOCK", /* 600e/x,770e,770x,A2xm/p,T20-22,X20-21 */
3424 "\\_SB.PCI0.PCI1.DOCK", /* all others */
3425 "\\_SB.PCI.ISA.SLCE", /* 570 */
3426 ); /* A21e,G4x,R30,R31,R32,R40,R40e,R50e */
3427
3428 /* don't list other alternatives as we install a notify handler on the 570 */
3429 TPACPI_HANDLE(pci, root, "\\_SB.PCI"); /* 570 */
3430
3431 static const struct acpi_device_id ibm_pci_device_ids[] = {
3432 {PCI_ROOT_HID_STRING, 0},
3433 {"", 0},
3434 };
3435
3436 static struct tp_acpi_drv_struct ibm_dock_acpidriver[2] = {
3437 {
3438 .notify = dock_notify,
3439 .handle = &dock_handle,
3440 .type = ACPI_SYSTEM_NOTIFY,
3441 },
3442 {
3443 /* THIS ONE MUST NEVER BE USED FOR DRIVER AUTOLOADING.
3444 * We just use it to get notifications of dock hotplug
3445 * in very old thinkpads */
3446 .hid = ibm_pci_device_ids,
3447 .notify = dock_notify,
3448 .handle = &pci_handle,
3449 .type = ACPI_SYSTEM_NOTIFY,
3450 },
3451 };
3452
3453 static struct ibm_struct dock_driver_data[2] = {
3454 {
3455 .name = "dock",
3456 .read = dock_read,
3457 .write = dock_write,
3458 .acpi = &ibm_dock_acpidriver[0],
3459 },
3460 {
3461 .name = "dock",
3462 .acpi = &ibm_dock_acpidriver[1],
3463 },
3464 };
3465
3466 #define dock_docked() (_sta(dock_handle) & 1)
3467
3468 static int __init dock_init(struct ibm_init_struct *iibm)
3469 {
3470 vdbg_printk(TPACPI_DBG_INIT, "initializing dock subdriver\n");
3471
3472 TPACPI_ACPIHANDLE_INIT(dock);
3473
3474 vdbg_printk(TPACPI_DBG_INIT, "dock is %s\n",
3475 str_supported(dock_handle != NULL));
3476
3477 return (dock_handle)? 0 : 1;
3478 }
3479
3480 static int __init dock_init2(struct ibm_init_struct *iibm)
3481 {
3482 int dock2_needed;
3483
3484 vdbg_printk(TPACPI_DBG_INIT, "initializing dock subdriver part 2\n");
3485
3486 if (dock_driver_data[0].flags.acpi_driver_registered &&
3487 dock_driver_data[0].flags.acpi_notify_installed) {
3488 TPACPI_ACPIHANDLE_INIT(pci);
3489 dock2_needed = (pci_handle != NULL);
3490 vdbg_printk(TPACPI_DBG_INIT,
3491 "dock PCI handler for the TP 570 is %s\n",
3492 str_supported(dock2_needed));
3493 } else {
3494 vdbg_printk(TPACPI_DBG_INIT,
3495 "dock subdriver part 2 not required\n");
3496 dock2_needed = 0;
3497 }
3498
3499 return (dock2_needed)? 0 : 1;
3500 }
3501
3502 static void dock_notify(struct ibm_struct *ibm, u32 event)
3503 {
3504 int docked = dock_docked();
3505 int pci = ibm->acpi->hid && ibm->acpi->device &&
3506 acpi_match_device_ids(ibm->acpi->device, ibm_pci_device_ids);
3507 int data;
3508
3509 if (event == 1 && !pci) /* 570 */
3510 data = 1; /* button */
3511 else if (event == 1 && pci) /* 570 */
3512 data = 3; /* dock */
3513 else if (event == 3 && docked)
3514 data = 1; /* button */
3515 else if (event == 3 && !docked)
3516 data = 2; /* undock */
3517 else if (event == 0 && docked)
3518 data = 3; /* dock */
3519 else {
3520 printk(TPACPI_ERR "unknown dock event %d, status %d\n",
3521 event, _sta(dock_handle));
3522 data = 0; /* unknown */
3523 }
3524 acpi_bus_generate_proc_event(ibm->acpi->device, event, data);
3525 acpi_bus_generate_netlink_event(ibm->acpi->device->pnp.device_class,
3526 ibm->acpi->device->dev.bus_id,
3527 event, data);
3528 }
3529
3530 static int dock_read(char *p)
3531 {
3532 int len = 0;
3533 int docked = dock_docked();
3534
3535 if (!dock_handle)
3536 len += sprintf(p + len, "status:\t\tnot supported\n");
3537 else if (!docked)
3538 len += sprintf(p + len, "status:\t\tundocked\n");
3539 else {
3540 len += sprintf(p + len, "status:\t\tdocked\n");
3541 len += sprintf(p + len, "commands:\tdock, undock\n");
3542 }
3543
3544 return len;
3545 }
3546
3547 static int dock_write(char *buf)
3548 {
3549 char *cmd;
3550
3551 if (!dock_docked())
3552 return -ENODEV;
3553
3554 while ((cmd = next_cmd(&buf))) {
3555 if (strlencmp(cmd, "undock") == 0) {
3556 if (!acpi_evalf(dock_handle, NULL, "_DCK", "vd", 0) ||
3557 !acpi_evalf(dock_handle, NULL, "_EJ0", "vd", 1))
3558 return -EIO;
3559 } else if (strlencmp(cmd, "dock") == 0) {
3560 if (!acpi_evalf(dock_handle, NULL, "_DCK", "vd", 1))
3561 return -EIO;
3562 } else
3563 return -EINVAL;
3564 }
3565
3566 return 0;
3567 }
3568
3569 #endif /* CONFIG_THINKPAD_ACPI_DOCK */
3570
3571 /*************************************************************************
3572 * Bay subdriver
3573 */
3574
3575 #ifdef CONFIG_THINKPAD_ACPI_BAY
3576
3577 TPACPI_HANDLE(bay, root, "\\_SB.PCI.IDE.SECN.MAST", /* 570 */
3578 "\\_SB.PCI0.IDE0.IDES.IDSM", /* 600e/x, 770e, 770x */
3579 "\\_SB.PCI0.SATA.SCND.MSTR", /* T60, X60, Z60 */
3580 "\\_SB.PCI0.IDE0.SCND.MSTR", /* all others */
3581 ); /* A21e, R30, R31 */
3582 TPACPI_HANDLE(bay_ej, bay, "_EJ3", /* 600e/x, A2xm/p, A3x */
3583 "_EJ0", /* all others */
3584 ); /* 570,A21e,G4x,R30,R31,R32,R40e,R50e */
3585 TPACPI_HANDLE(bay2, root, "\\_SB.PCI0.IDE0.PRIM.SLAV", /* A3x, R32 */
3586 "\\_SB.PCI0.IDE0.IDEP.IDPS", /* 600e/x, 770e, 770x */
3587 ); /* all others */
3588 TPACPI_HANDLE(bay2_ej, bay2, "_EJ3", /* 600e/x, 770e, A3x */
3589 "_EJ0", /* 770x */
3590 ); /* all others */
3591
3592 static int __init bay_init(struct ibm_init_struct *iibm)
3593 {
3594 vdbg_printk(TPACPI_DBG_INIT, "initializing bay subdriver\n");
3595
3596 TPACPI_ACPIHANDLE_INIT(bay);
3597 if (bay_handle)
3598 TPACPI_ACPIHANDLE_INIT(bay_ej);
3599 TPACPI_ACPIHANDLE_INIT(bay2);
3600 if (bay2_handle)
3601 TPACPI_ACPIHANDLE_INIT(bay2_ej);
3602
3603 tp_features.bay_status = bay_handle &&
3604 acpi_evalf(bay_handle, NULL, "_STA", "qv");
3605 tp_features.bay_status2 = bay2_handle &&
3606 acpi_evalf(bay2_handle, NULL, "_STA", "qv");
3607
3608 tp_features.bay_eject = bay_handle && bay_ej_handle &&
3609 (strlencmp(bay_ej_path, "_EJ0") == 0 || experimental);
3610 tp_features.bay_eject2 = bay2_handle && bay2_ej_handle &&
3611 (strlencmp(bay2_ej_path, "_EJ0") == 0 || experimental);
3612
3613 vdbg_printk(TPACPI_DBG_INIT,
3614 "bay 1: status %s, eject %s; bay 2: status %s, eject %s\n",
3615 str_supported(tp_features.bay_status),
3616 str_supported(tp_features.bay_eject),
3617 str_supported(tp_features.bay_status2),
3618 str_supported(tp_features.bay_eject2));
3619
3620 return (tp_features.bay_status || tp_features.bay_eject ||
3621 tp_features.bay_status2 || tp_features.bay_eject2)? 0 : 1;
3622 }
3623
3624 static void bay_notify(struct ibm_struct *ibm, u32 event)
3625 {
3626 acpi_bus_generate_proc_event(ibm->acpi->device, event, 0);
3627 acpi_bus_generate_netlink_event(ibm->acpi->device->pnp.device_class,
3628 ibm->acpi->device->dev.bus_id,
3629 event, 0);
3630 }
3631
3632 #define bay_occupied(b) (_sta(b##_handle) & 1)
3633
3634 static int bay_read(char *p)
3635 {
3636 int len = 0;
3637 int occupied = bay_occupied(bay);
3638 int occupied2 = bay_occupied(bay2);
3639 int eject, eject2;
3640
3641 len += sprintf(p + len, "status:\t\t%s\n",
3642 tp_features.bay_status ?
3643 (occupied ? "occupied" : "unoccupied") :
3644 "not supported");
3645 if (tp_features.bay_status2)
3646 len += sprintf(p + len, "status2:\t%s\n", occupied2 ?
3647 "occupied" : "unoccupied");
3648
3649 eject = tp_features.bay_eject && occupied;
3650 eject2 = tp_features.bay_eject2 && occupied2;
3651
3652 if (eject && eject2)
3653 len += sprintf(p + len, "commands:\teject, eject2\n");
3654 else if (eject)
3655 len += sprintf(p + len, "commands:\teject\n");
3656 else if (eject2)
3657 len += sprintf(p + len, "commands:\teject2\n");
3658
3659 return len;
3660 }
3661
3662 static int bay_write(char *buf)
3663 {
3664 char *cmd;
3665
3666 if (!tp_features.bay_eject && !tp_features.bay_eject2)
3667 return -ENODEV;
3668
3669 while ((cmd = next_cmd(&buf))) {
3670 if (tp_features.bay_eject && strlencmp(cmd, "eject") == 0) {
3671 if (!acpi_evalf(bay_ej_handle, NULL, NULL, "vd", 1))
3672 return -EIO;
3673 } else if (tp_features.bay_eject2 &&
3674 strlencmp(cmd, "eject2") == 0) {
3675 if (!acpi_evalf(bay2_ej_handle, NULL, NULL, "vd", 1))
3676 return -EIO;
3677 } else
3678 return -EINVAL;
3679 }
3680
3681 return 0;
3682 }
3683
3684 static struct tp_acpi_drv_struct ibm_bay_acpidriver = {
3685 .notify = bay_notify,
3686 .handle = &bay_handle,
3687 .type = ACPI_SYSTEM_NOTIFY,
3688 };
3689
3690 static struct ibm_struct bay_driver_data = {
3691 .name = "bay",
3692 .read = bay_read,
3693 .write = bay_write,
3694 .acpi = &ibm_bay_acpidriver,
3695 };
3696
3697 #endif /* CONFIG_THINKPAD_ACPI_BAY */
3698
3699 /*************************************************************************
3700 * CMOS subdriver
3701 */
3702
3703 /* sysfs cmos_command -------------------------------------------------- */
3704 static ssize_t cmos_command_store(struct device *dev,
3705 struct device_attribute *attr,
3706 const char *buf, size_t count)
3707 {
3708 unsigned long cmos_cmd;
3709 int res;
3710
3711 if (parse_strtoul(buf, 21, &cmos_cmd))
3712 return -EINVAL;
3713
3714 res = issue_thinkpad_cmos_command(cmos_cmd);
3715 return (res)? res : count;
3716 }
3717
3718 static struct device_attribute dev_attr_cmos_command =
3719 __ATTR(cmos_command, S_IWUSR, NULL, cmos_command_store);
3720
3721 /* --------------------------------------------------------------------- */
3722
3723 static int __init cmos_init(struct ibm_init_struct *iibm)
3724 {
3725 int res;
3726
3727 vdbg_printk(TPACPI_DBG_INIT,
3728 "initializing cmos commands subdriver\n");
3729
3730 TPACPI_ACPIHANDLE_INIT(cmos);
3731
3732 vdbg_printk(TPACPI_DBG_INIT, "cmos commands are %s\n",
3733 str_supported(cmos_handle != NULL));
3734
3735 res = device_create_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
3736 if (res)
3737 return res;
3738
3739 return (cmos_handle)? 0 : 1;
3740 }
3741
3742 static void cmos_exit(void)
3743 {
3744 device_remove_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
3745 }
3746
3747 static int cmos_read(char *p)
3748 {
3749 int len = 0;
3750
3751 /* cmos not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
3752 R30, R31, T20-22, X20-21 */
3753 if (!cmos_handle)
3754 len += sprintf(p + len, "status:\t\tnot supported\n");
3755 else {
3756 len += sprintf(p + len, "status:\t\tsupported\n");
3757 len += sprintf(p + len, "commands:\t<cmd> (<cmd> is 0-21)\n");
3758 }
3759
3760 return len;
3761 }
3762
3763 static int cmos_write(char *buf)
3764 {
3765 char *cmd;
3766 int cmos_cmd, res;
3767
3768 while ((cmd = next_cmd(&buf))) {
3769 if (sscanf(cmd, "%u", &cmos_cmd) == 1 &&
3770 cmos_cmd >= 0 && cmos_cmd <= 21) {
3771 /* cmos_cmd set */
3772 } else
3773 return -EINVAL;
3774
3775 res = issue_thinkpad_cmos_command(cmos_cmd);
3776 if (res)
3777 return res;
3778 }
3779
3780 return 0;
3781 }
3782
3783 static struct ibm_struct cmos_driver_data = {
3784 .name = "cmos",
3785 .read = cmos_read,
3786 .write = cmos_write,
3787 .exit = cmos_exit,
3788 };
3789
3790 /*************************************************************************
3791 * LED subdriver
3792 */
3793
3794 enum led_access_mode {
3795 TPACPI_LED_NONE = 0,
3796 TPACPI_LED_570, /* 570 */
3797 TPACPI_LED_OLD, /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
3798 TPACPI_LED_NEW, /* all others */
3799 };
3800
3801 enum { /* For TPACPI_LED_OLD */
3802 TPACPI_LED_EC_HLCL = 0x0c, /* EC reg to get led to power on */
3803 TPACPI_LED_EC_HLBL = 0x0d, /* EC reg to blink a lit led */
3804 TPACPI_LED_EC_HLMS = 0x0e, /* EC reg to select led to command */
3805 };
3806
3807 enum led_status_t {
3808 TPACPI_LED_OFF = 0,
3809 TPACPI_LED_ON,
3810 TPACPI_LED_BLINK,
3811 };
3812
3813 static enum led_access_mode led_supported;
3814
3815 TPACPI_HANDLE(led, ec, "SLED", /* 570 */
3816 "SYSL", /* 600e/x, 770e, 770x, A21e, A2xm/p, */
3817 /* T20-22, X20-21 */
3818 "LED", /* all others */
3819 ); /* R30, R31 */
3820
3821 #define TPACPI_LED_NUMLEDS 8
3822 static struct tpacpi_led_classdev *tpacpi_leds;
3823 static enum led_status_t tpacpi_led_state_cache[TPACPI_LED_NUMLEDS];
3824 static const char const *tpacpi_led_names[TPACPI_LED_NUMLEDS] = {
3825 /* there's a limit of 19 chars + NULL before 2.6.26 */
3826 "tpacpi::power",
3827 "tpacpi:orange:batt",
3828 "tpacpi:green:batt",
3829 "tpacpi::dock_active",
3830 "tpacpi::bay_active",
3831 "tpacpi::dock_batt",
3832 "tpacpi::unknown_led",
3833 "tpacpi::standby",
3834 };
3835
3836 static int led_get_status(unsigned int led)
3837 {
3838 int status;
3839 enum led_status_t led_s;
3840
3841 switch (led_supported) {
3842 case TPACPI_LED_570:
3843 if (!acpi_evalf(ec_handle,
3844 &status, "GLED", "dd", 1 << led))
3845 return -EIO;
3846 led_s = (status == 0)?
3847 TPACPI_LED_OFF :
3848 ((status == 1)?
3849 TPACPI_LED_ON :
3850 TPACPI_LED_BLINK);
3851 tpacpi_led_state_cache[led] = led_s;
3852 return led_s;
3853 default:
3854 return -ENXIO;
3855 }
3856
3857 /* not reached */
3858 }
3859
3860 static int led_set_status(unsigned int led, enum led_status_t ledstatus)
3861 {
3862 /* off, on, blink. Index is led_status_t */
3863 static const int const led_sled_arg1[] = { 0, 1, 3 };
3864 static const int const led_exp_hlbl[] = { 0, 0, 1 }; /* led# * */
3865 static const int const led_exp_hlcl[] = { 0, 1, 1 }; /* led# * */
3866 static const int const led_led_arg1[] = { 0, 0x80, 0xc0 };
3867
3868 int rc = 0;
3869
3870 switch (led_supported) {
3871 case TPACPI_LED_570:
3872 /* 570 */
3873 led = 1 << led;
3874 if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
3875 led, led_sled_arg1[ledstatus]))
3876 rc = -EIO;
3877 break;
3878 case TPACPI_LED_OLD:
3879 /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20 */
3880 led = 1 << led;
3881 rc = ec_write(TPACPI_LED_EC_HLMS, led);
3882 if (rc >= 0)
3883 rc = ec_write(TPACPI_LED_EC_HLBL,
3884 led * led_exp_hlbl[ledstatus]);
3885 if (rc >= 0)
3886 rc = ec_write(TPACPI_LED_EC_HLCL,
3887 led * led_exp_hlcl[ledstatus]);
3888 break;
3889 case TPACPI_LED_NEW:
3890 /* all others */
3891 if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
3892 led, led_led_arg1[ledstatus]))
3893 rc = -EIO;
3894 break;
3895 default:
3896 rc = -ENXIO;
3897 }
3898
3899 if (!rc)
3900 tpacpi_led_state_cache[led] = ledstatus;
3901
3902 return rc;
3903 }
3904
3905 static void led_sysfs_set_status(unsigned int led,
3906 enum led_brightness brightness)
3907 {
3908 led_set_status(led,
3909 (brightness == LED_OFF) ?
3910 TPACPI_LED_OFF :
3911 (tpacpi_led_state_cache[led] == TPACPI_LED_BLINK) ?
3912 TPACPI_LED_BLINK : TPACPI_LED_ON);
3913 }
3914
3915 static void led_set_status_worker(struct work_struct *work)
3916 {
3917 struct tpacpi_led_classdev *data =
3918 container_of(work, struct tpacpi_led_classdev, work);
3919
3920 if (likely(tpacpi_lifecycle == TPACPI_LIFE_RUNNING))
3921 led_sysfs_set_status(data->led, data->new_brightness);
3922 }
3923
3924 static void led_sysfs_set(struct led_classdev *led_cdev,
3925 enum led_brightness brightness)
3926 {
3927 struct tpacpi_led_classdev *data = container_of(led_cdev,
3928 struct tpacpi_led_classdev, led_classdev);
3929
3930 data->new_brightness = brightness;
3931 queue_work(tpacpi_wq, &data->work);
3932 }
3933
3934 static int led_sysfs_blink_set(struct led_classdev *led_cdev,
3935 unsigned long *delay_on, unsigned long *delay_off)
3936 {
3937 struct tpacpi_led_classdev *data = container_of(led_cdev,
3938 struct tpacpi_led_classdev, led_classdev);
3939
3940 /* Can we choose the flash rate? */
3941 if (*delay_on == 0 && *delay_off == 0) {
3942 /* yes. set them to the hardware blink rate (1 Hz) */
3943 *delay_on = 500; /* ms */
3944 *delay_off = 500; /* ms */
3945 } else if ((*delay_on != 500) || (*delay_off != 500))
3946 return -EINVAL;
3947
3948 data->new_brightness = TPACPI_LED_BLINK;
3949 queue_work(tpacpi_wq, &data->work);
3950
3951 return 0;
3952 }
3953
3954 static enum led_brightness led_sysfs_get(struct led_classdev *led_cdev)
3955 {
3956 int rc;
3957
3958 struct tpacpi_led_classdev *data = container_of(led_cdev,
3959 struct tpacpi_led_classdev, led_classdev);
3960
3961 rc = led_get_status(data->led);
3962
3963 if (rc == TPACPI_LED_OFF || rc < 0)
3964 rc = LED_OFF; /* no error handling in led class :( */
3965 else
3966 rc = LED_FULL;
3967
3968 return rc;
3969 }
3970
3971 static void led_exit(void)
3972 {
3973 unsigned int i;
3974
3975 for (i = 0; i < TPACPI_LED_NUMLEDS; i++) {
3976 if (tpacpi_leds[i].led_classdev.name)
3977 led_classdev_unregister(&tpacpi_leds[i].led_classdev);
3978 }
3979
3980 kfree(tpacpi_leds);
3981 tpacpi_leds = NULL;
3982 }
3983
3984 static int __init led_init(struct ibm_init_struct *iibm)
3985 {
3986 unsigned int i;
3987 int rc;
3988
3989 vdbg_printk(TPACPI_DBG_INIT, "initializing LED subdriver\n");
3990
3991 TPACPI_ACPIHANDLE_INIT(led);
3992
3993 if (!led_handle)
3994 /* led not supported on R30, R31 */
3995 led_supported = TPACPI_LED_NONE;
3996 else if (strlencmp(led_path, "SLED") == 0)
3997 /* 570 */
3998 led_supported = TPACPI_LED_570;
3999 else if (strlencmp(led_path, "SYSL") == 0)
4000 /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
4001 led_supported = TPACPI_LED_OLD;
4002 else
4003 /* all others */
4004 led_supported = TPACPI_LED_NEW;
4005
4006 vdbg_printk(TPACPI_DBG_INIT, "LED commands are %s, mode %d\n",
4007 str_supported(led_supported), led_supported);
4008
4009 tpacpi_leds = kzalloc(sizeof(*tpacpi_leds) * TPACPI_LED_NUMLEDS,
4010 GFP_KERNEL);
4011 if (!tpacpi_leds) {
4012 printk(TPACPI_ERR "Out of memory for LED data\n");
4013 return -ENOMEM;
4014 }
4015
4016 for (i = 0; i < TPACPI_LED_NUMLEDS; i++) {
4017 tpacpi_leds[i].led = i;
4018
4019 tpacpi_leds[i].led_classdev.brightness_set = &led_sysfs_set;
4020 tpacpi_leds[i].led_classdev.blink_set = &led_sysfs_blink_set;
4021 if (led_supported == TPACPI_LED_570)
4022 tpacpi_leds[i].led_classdev.brightness_get =
4023 &led_sysfs_get;
4024
4025 tpacpi_leds[i].led_classdev.name = tpacpi_led_names[i];
4026
4027 INIT_WORK(&tpacpi_leds[i].work, led_set_status_worker);
4028
4029 rc = led_classdev_register(&tpacpi_pdev->dev,
4030 &tpacpi_leds[i].led_classdev);
4031 if (rc < 0) {
4032 tpacpi_leds[i].led_classdev.name = NULL;
4033 led_exit();
4034 return rc;
4035 }
4036 }
4037
4038 return (led_supported != TPACPI_LED_NONE)? 0 : 1;
4039 }
4040
4041 #define str_led_status(s) \
4042 ((s) == TPACPI_LED_OFF ? "off" : \
4043 ((s) == TPACPI_LED_ON ? "on" : "blinking"))
4044
4045 static int led_read(char *p)
4046 {
4047 int len = 0;
4048
4049 if (!led_supported) {
4050 len += sprintf(p + len, "status:\t\tnot supported\n");
4051 return len;
4052 }
4053 len += sprintf(p + len, "status:\t\tsupported\n");
4054
4055 if (led_supported == TPACPI_LED_570) {
4056 /* 570 */
4057 int i, status;
4058 for (i = 0; i < 8; i++) {
4059 status = led_get_status(i);
4060 if (status < 0)
4061 return -EIO;
4062 len += sprintf(p + len, "%d:\t\t%s\n",
4063 i, str_led_status(status));
4064 }
4065 }
4066
4067 len += sprintf(p + len, "commands:\t"
4068 "<led> on, <led> off, <led> blink (<led> is 0-7)\n");
4069
4070 return len;
4071 }
4072
4073 static int led_write(char *buf)
4074 {
4075 char *cmd;
4076 int led, rc;
4077 enum led_status_t s;
4078
4079 if (!led_supported)
4080 return -ENODEV;
4081
4082 while ((cmd = next_cmd(&buf))) {
4083 if (sscanf(cmd, "%d", &led) != 1 || led < 0 || led > 7)
4084 return -EINVAL;
4085
4086 if (strstr(cmd, "off")) {
4087 s = TPACPI_LED_OFF;
4088 } else if (strstr(cmd, "on")) {
4089 s = TPACPI_LED_ON;
4090 } else if (strstr(cmd, "blink")) {
4091 s = TPACPI_LED_BLINK;
4092 } else {
4093 return -EINVAL;
4094 }
4095
4096 rc = led_set_status(led, s);
4097 if (rc < 0)
4098 return rc;
4099 }
4100
4101 return 0;
4102 }
4103
4104 static struct ibm_struct led_driver_data = {
4105 .name = "led",
4106 .read = led_read,
4107 .write = led_write,
4108 .exit = led_exit,
4109 };
4110
4111 /*************************************************************************
4112 * Beep subdriver
4113 */
4114
4115 TPACPI_HANDLE(beep, ec, "BEEP"); /* all except R30, R31 */
4116
4117 static int __init beep_init(struct ibm_init_struct *iibm)
4118 {
4119 vdbg_printk(TPACPI_DBG_INIT, "initializing beep subdriver\n");
4120
4121 TPACPI_ACPIHANDLE_INIT(beep);
4122
4123 vdbg_printk(TPACPI_DBG_INIT, "beep is %s\n",
4124 str_supported(beep_handle != NULL));
4125
4126 return (beep_handle)? 0 : 1;
4127 }
4128
4129 static int beep_read(char *p)
4130 {
4131 int len = 0;
4132
4133 if (!beep_handle)
4134 len += sprintf(p + len, "status:\t\tnot supported\n");
4135 else {
4136 len += sprintf(p + len, "status:\t\tsupported\n");
4137 len += sprintf(p + len, "commands:\t<cmd> (<cmd> is 0-17)\n");
4138 }
4139
4140 return len;
4141 }
4142
4143 static int beep_write(char *buf)
4144 {
4145 char *cmd;
4146 int beep_cmd;
4147
4148 if (!beep_handle)
4149 return -ENODEV;
4150
4151 while ((cmd = next_cmd(&buf))) {
4152 if (sscanf(cmd, "%u", &beep_cmd) == 1 &&
4153 beep_cmd >= 0 && beep_cmd <= 17) {
4154 /* beep_cmd set */
4155 } else
4156 return -EINVAL;
4157 if (!acpi_evalf(beep_handle, NULL, NULL, "vdd", beep_cmd, 0))
4158 return -EIO;
4159 }
4160
4161 return 0;
4162 }
4163
4164 static struct ibm_struct beep_driver_data = {
4165 .name = "beep",
4166 .read = beep_read,
4167 .write = beep_write,
4168 };
4169
4170 /*************************************************************************
4171 * Thermal subdriver
4172 */
4173
4174 enum thermal_access_mode {
4175 TPACPI_THERMAL_NONE = 0, /* No thermal support */
4176 TPACPI_THERMAL_ACPI_TMP07, /* Use ACPI TMP0-7 */
4177 TPACPI_THERMAL_ACPI_UPDT, /* Use ACPI TMP0-7 with UPDT */
4178 TPACPI_THERMAL_TPEC_8, /* Use ACPI EC regs, 8 sensors */
4179 TPACPI_THERMAL_TPEC_16, /* Use ACPI EC regs, 16 sensors */
4180 };
4181
4182 enum { /* TPACPI_THERMAL_TPEC_* */
4183 TP_EC_THERMAL_TMP0 = 0x78, /* ACPI EC regs TMP 0..7 */
4184 TP_EC_THERMAL_TMP8 = 0xC0, /* ACPI EC regs TMP 8..15 */
4185 TP_EC_THERMAL_TMP_NA = -128, /* ACPI EC sensor not available */
4186 };
4187
4188 #define TPACPI_MAX_THERMAL_SENSORS 16 /* Max thermal sensors supported */
4189 struct ibm_thermal_sensors_struct {
4190 s32 temp[TPACPI_MAX_THERMAL_SENSORS];
4191 };
4192
4193 static enum thermal_access_mode thermal_read_mode;
4194
4195 /* idx is zero-based */
4196 static int thermal_get_sensor(int idx, s32 *value)
4197 {
4198 int t;
4199 s8 tmp;
4200 char tmpi[5];
4201
4202 t = TP_EC_THERMAL_TMP0;
4203
4204 switch (thermal_read_mode) {
4205 #if TPACPI_MAX_THERMAL_SENSORS >= 16
4206 case TPACPI_THERMAL_TPEC_16:
4207 if (idx >= 8 && idx <= 15) {
4208 t = TP_EC_THERMAL_TMP8;
4209 idx -= 8;
4210 }
4211 /* fallthrough */
4212 #endif
4213 case TPACPI_THERMAL_TPEC_8:
4214 if (idx <= 7) {
4215 if (!acpi_ec_read(t + idx, &tmp))
4216 return -EIO;
4217 *value = tmp * 1000;
4218 return 0;
4219 }
4220 break;
4221
4222 case TPACPI_THERMAL_ACPI_UPDT:
4223 if (idx <= 7) {
4224 snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
4225 if (!acpi_evalf(ec_handle, NULL, "UPDT", "v"))
4226 return -EIO;
4227 if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
4228 return -EIO;
4229 *value = (t - 2732) * 100;
4230 return 0;
4231 }
4232 break;
4233
4234 case TPACPI_THERMAL_ACPI_TMP07:
4235 if (idx <= 7) {
4236 snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
4237 if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
4238 return -EIO;
4239 if (t > 127 || t < -127)
4240 t = TP_EC_THERMAL_TMP_NA;
4241 *value = t * 1000;
4242 return 0;
4243 }
4244 break;
4245
4246 case TPACPI_THERMAL_NONE:
4247 default:
4248 return -ENOSYS;
4249 }
4250
4251 return -EINVAL;
4252 }
4253
4254 static int thermal_get_sensors(struct ibm_thermal_sensors_struct *s)
4255 {
4256 int res, i;
4257 int n;
4258
4259 n = 8;
4260 i = 0;
4261
4262 if (!s)
4263 return -EINVAL;
4264
4265 if (thermal_read_mode == TPACPI_THERMAL_TPEC_16)
4266 n = 16;
4267
4268 for (i = 0 ; i < n; i++) {
4269 res = thermal_get_sensor(i, &s->temp[i]);
4270 if (res)
4271 return res;
4272 }
4273
4274 return n;
4275 }
4276
4277 /* sysfs temp##_input -------------------------------------------------- */
4278
4279 static ssize_t thermal_temp_input_show(struct device *dev,
4280 struct device_attribute *attr,
4281 char *buf)
4282 {
4283 struct sensor_device_attribute *sensor_attr =
4284 to_sensor_dev_attr(attr);
4285 int idx = sensor_attr->index;
4286 s32 value;
4287 int res;
4288
4289 res = thermal_get_sensor(idx, &value);
4290 if (res)
4291 return res;
4292 if (value == TP_EC_THERMAL_TMP_NA * 1000)
4293 return -ENXIO;
4294
4295 return snprintf(buf, PAGE_SIZE, "%d\n", value);
4296 }
4297
4298 #define THERMAL_SENSOR_ATTR_TEMP(_idxA, _idxB) \
4299 SENSOR_ATTR(temp##_idxA##_input, S_IRUGO, \
4300 thermal_temp_input_show, NULL, _idxB)
4301
4302 static struct sensor_device_attribute sensor_dev_attr_thermal_temp_input[] = {
4303 THERMAL_SENSOR_ATTR_TEMP(1, 0),
4304 THERMAL_SENSOR_ATTR_TEMP(2, 1),
4305 THERMAL_SENSOR_ATTR_TEMP(3, 2),
4306 THERMAL_SENSOR_ATTR_TEMP(4, 3),
4307 THERMAL_SENSOR_ATTR_TEMP(5, 4),
4308 THERMAL_SENSOR_ATTR_TEMP(6, 5),
4309 THERMAL_SENSOR_ATTR_TEMP(7, 6),
4310 THERMAL_SENSOR_ATTR_TEMP(8, 7),
4311 THERMAL_SENSOR_ATTR_TEMP(9, 8),
4312 THERMAL_SENSOR_ATTR_TEMP(10, 9),
4313 THERMAL_SENSOR_ATTR_TEMP(11, 10),
4314 THERMAL_SENSOR_ATTR_TEMP(12, 11),
4315 THERMAL_SENSOR_ATTR_TEMP(13, 12),
4316 THERMAL_SENSOR_ATTR_TEMP(14, 13),
4317 THERMAL_SENSOR_ATTR_TEMP(15, 14),
4318 THERMAL_SENSOR_ATTR_TEMP(16, 15),
4319 };
4320
4321 #define THERMAL_ATTRS(X) \
4322 &sensor_dev_attr_thermal_temp_input[X].dev_attr.attr
4323
4324 static struct attribute *thermal_temp_input_attr[] = {
4325 THERMAL_ATTRS(8),
4326 THERMAL_ATTRS(9),
4327 THERMAL_ATTRS(10),
4328 THERMAL_ATTRS(11),
4329 THERMAL_ATTRS(12),
4330 THERMAL_ATTRS(13),
4331 THERMAL_ATTRS(14),
4332 THERMAL_ATTRS(15),
4333 THERMAL_ATTRS(0),
4334 THERMAL_ATTRS(1),
4335 THERMAL_ATTRS(2),
4336 THERMAL_ATTRS(3),
4337 THERMAL_ATTRS(4),
4338 THERMAL_ATTRS(5),
4339 THERMAL_ATTRS(6),
4340 THERMAL_ATTRS(7),
4341 NULL
4342 };
4343
4344 static const struct attribute_group thermal_temp_input16_group = {
4345 .attrs = thermal_temp_input_attr
4346 };
4347
4348 static const struct attribute_group thermal_temp_input8_group = {
4349 .attrs = &thermal_temp_input_attr[8]
4350 };
4351
4352 #undef THERMAL_SENSOR_ATTR_TEMP
4353 #undef THERMAL_ATTRS
4354
4355 /* --------------------------------------------------------------------- */
4356
4357 static int __init thermal_init(struct ibm_init_struct *iibm)
4358 {
4359 u8 t, ta1, ta2;
4360 int i;
4361 int acpi_tmp7;
4362 int res;
4363
4364 vdbg_printk(TPACPI_DBG_INIT, "initializing thermal subdriver\n");
4365
4366 acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
4367
4368 if (thinkpad_id.ec_model) {
4369 /*
4370 * Direct EC access mode: sensors at registers
4371 * 0x78-0x7F, 0xC0-0xC7. Registers return 0x00 for
4372 * non-implemented, thermal sensors return 0x80 when
4373 * not available
4374 */
4375
4376 ta1 = ta2 = 0;
4377 for (i = 0; i < 8; i++) {
4378 if (acpi_ec_read(TP_EC_THERMAL_TMP0 + i, &t)) {
4379 ta1 |= t;
4380 } else {
4381 ta1 = 0;
4382 break;
4383 }
4384 if (acpi_ec_read(TP_EC_THERMAL_TMP8 + i, &t)) {
4385 ta2 |= t;
4386 } else {
4387 ta1 = 0;
4388 break;
4389 }
4390 }
4391 if (ta1 == 0) {
4392 /* This is sheer paranoia, but we handle it anyway */
4393 if (acpi_tmp7) {
4394 printk(TPACPI_ERR
4395 "ThinkPad ACPI EC access misbehaving, "
4396 "falling back to ACPI TMPx access "
4397 "mode\n");
4398 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
4399 } else {
4400 printk(TPACPI_ERR
4401 "ThinkPad ACPI EC access misbehaving, "
4402 "disabling thermal sensors access\n");
4403 thermal_read_mode = TPACPI_THERMAL_NONE;
4404 }
4405 } else {
4406 thermal_read_mode =
4407 (ta2 != 0) ?
4408 TPACPI_THERMAL_TPEC_16 : TPACPI_THERMAL_TPEC_8;
4409 }
4410 } else if (acpi_tmp7) {
4411 if (acpi_evalf(ec_handle, NULL, "UPDT", "qv")) {
4412 /* 600e/x, 770e, 770x */
4413 thermal_read_mode = TPACPI_THERMAL_ACPI_UPDT;
4414 } else {
4415 /* Standard ACPI TMPx access, max 8 sensors */
4416 thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
4417 }
4418 } else {
4419 /* temperatures not supported on 570, G4x, R30, R31, R32 */
4420 thermal_read_mode = TPACPI_THERMAL_NONE;
4421 }
4422
4423 vdbg_printk(TPACPI_DBG_INIT, "thermal is %s, mode %d\n",
4424 str_supported(thermal_read_mode != TPACPI_THERMAL_NONE),
4425 thermal_read_mode);
4426
4427 switch (thermal_read_mode) {
4428 case TPACPI_THERMAL_TPEC_16:
4429 res = sysfs_create_group(&tpacpi_sensors_pdev->dev.kobj,
4430 &thermal_temp_input16_group);
4431 if (res)
4432 return res;
4433 break;
4434 case TPACPI_THERMAL_TPEC_8:
4435 case TPACPI_THERMAL_ACPI_TMP07:
4436 case TPACPI_THERMAL_ACPI_UPDT:
4437 res = sysfs_create_group(&tpacpi_sensors_pdev->dev.kobj,
4438 &thermal_temp_input8_group);
4439 if (res)
4440 return res;
4441 break;
4442 case TPACPI_THERMAL_NONE:
4443 default:
4444 return 1;
4445 }
4446
4447 return 0;
4448 }
4449
4450 static void thermal_exit(void)
4451 {
4452 switch (thermal_read_mode) {
4453 case TPACPI_THERMAL_TPEC_16:
4454 sysfs_remove_group(&tpacpi_sensors_pdev->dev.kobj,
4455 &thermal_temp_input16_group);
4456 break;
4457 case TPACPI_THERMAL_TPEC_8:
4458 case TPACPI_THERMAL_ACPI_TMP07:
4459 case TPACPI_THERMAL_ACPI_UPDT:
4460 sysfs_remove_group(&tpacpi_sensors_pdev->dev.kobj,
4461 &thermal_temp_input16_group);
4462 break;
4463 case TPACPI_THERMAL_NONE:
4464 default:
4465 break;
4466 }
4467 }
4468
4469 static int thermal_read(char *p)
4470 {
4471 int len = 0;
4472 int n, i;
4473 struct ibm_thermal_sensors_struct t;
4474
4475 n = thermal_get_sensors(&t);
4476 if (unlikely(n < 0))
4477 return n;
4478
4479 len += sprintf(p + len, "temperatures:\t");
4480
4481 if (n > 0) {
4482 for (i = 0; i < (n - 1); i++)
4483 len += sprintf(p + len, "%d ", t.temp[i] / 1000);
4484 len += sprintf(p + len, "%d\n", t.temp[i] / 1000);
4485 } else
4486 len += sprintf(p + len, "not supported\n");
4487
4488 return len;
4489 }
4490
4491 static struct ibm_struct thermal_driver_data = {
4492 .name = "thermal",
4493 .read = thermal_read,
4494 .exit = thermal_exit,
4495 };
4496
4497 /*************************************************************************
4498 * EC Dump subdriver
4499 */
4500
4501 static u8 ecdump_regs[256];
4502
4503 static int ecdump_read(char *p)
4504 {
4505 int len = 0;
4506 int i, j;
4507 u8 v;
4508
4509 len += sprintf(p + len, "EC "
4510 " +00 +01 +02 +03 +04 +05 +06 +07"
4511 " +08 +09 +0a +0b +0c +0d +0e +0f\n");
4512 for (i = 0; i < 256; i += 16) {
4513 len += sprintf(p + len, "EC 0x%02x:", i);
4514 for (j = 0; j < 16; j++) {
4515 if (!acpi_ec_read(i + j, &v))
4516 break;
4517 if (v != ecdump_regs[i + j])
4518 len += sprintf(p + len, " *%02x", v);
4519 else
4520 len += sprintf(p + len, " %02x", v);
4521 ecdump_regs[i + j] = v;
4522 }
4523 len += sprintf(p + len, "\n");
4524 if (j != 16)
4525 break;
4526 }
4527
4528 /* These are way too dangerous to advertise openly... */
4529 #if 0
4530 len += sprintf(p + len, "commands:\t0x<offset> 0x<value>"
4531 " (<offset> is 00-ff, <value> is 00-ff)\n");
4532 len += sprintf(p + len, "commands:\t0x<offset> <value> "
4533 " (<offset> is 00-ff, <value> is 0-255)\n");
4534 #endif
4535 return len;
4536 }
4537
4538 static int ecdump_write(char *buf)
4539 {
4540 char *cmd;
4541 int i, v;
4542
4543 while ((cmd = next_cmd(&buf))) {
4544 if (sscanf(cmd, "0x%x 0x%x", &i, &v) == 2) {
4545 /* i and v set */
4546 } else if (sscanf(cmd, "0x%x %u", &i, &v) == 2) {
4547 /* i and v set */
4548 } else
4549 return -EINVAL;
4550 if (i >= 0 && i < 256 && v >= 0 && v < 256) {
4551 if (!acpi_ec_write(i, v))
4552 return -EIO;
4553 } else
4554 return -EINVAL;
4555 }
4556
4557 return 0;
4558 }
4559
4560 static struct ibm_struct ecdump_driver_data = {
4561 .name = "ecdump",
4562 .read = ecdump_read,
4563 .write = ecdump_write,
4564 .flags.experimental = 1,
4565 };
4566
4567 /*************************************************************************
4568 * Backlight/brightness subdriver
4569 */
4570
4571 #define TPACPI_BACKLIGHT_DEV_NAME "thinkpad_screen"
4572
4573 enum {
4574 TP_EC_BACKLIGHT = 0x31,
4575
4576 /* TP_EC_BACKLIGHT bitmasks */
4577 TP_EC_BACKLIGHT_LVLMSK = 0x1F,
4578 TP_EC_BACKLIGHT_CMDMSK = 0xE0,
4579 TP_EC_BACKLIGHT_MAPSW = 0x20,
4580 };
4581
4582 static struct backlight_device *ibm_backlight_device;
4583 static int brightness_mode;
4584 static unsigned int brightness_enable = 2; /* 2 = auto, 0 = no, 1 = yes */
4585
4586 static struct mutex brightness_mutex;
4587
4588 /*
4589 * ThinkPads can read brightness from two places: EC 0x31, or
4590 * CMOS NVRAM byte 0x5E, bits 0-3.
4591 *
4592 * EC 0x31 has the following layout
4593 * Bit 7: unknown function
4594 * Bit 6: unknown function
4595 * Bit 5: Z: honour scale changes, NZ: ignore scale changes
4596 * Bit 4: must be set to zero to avoid problems
4597 * Bit 3-0: backlight brightness level
4598 *
4599 * brightness_get_raw returns status data in the EC 0x31 layout
4600 */
4601 static int brightness_get_raw(int *status)
4602 {
4603 u8 lec = 0, lcmos = 0, level = 0;
4604
4605 if (brightness_mode & 1) {
4606 if (!acpi_ec_read(TP_EC_BACKLIGHT, &lec))
4607 return -EIO;
4608 level = lec & TP_EC_BACKLIGHT_LVLMSK;
4609 };
4610 if (brightness_mode & 2) {
4611 lcmos = (nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS)
4612 & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
4613 >> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
4614 lcmos &= (tp_features.bright_16levels)? 0x0f : 0x07;
4615 level = lcmos;
4616 }
4617
4618 if (brightness_mode == 3) {
4619 *status = lec; /* Prefer EC, CMOS is just a backing store */
4620 lec &= TP_EC_BACKLIGHT_LVLMSK;
4621 if (lec == lcmos)
4622 tp_warned.bright_cmos_ec_unsync = 0;
4623 else {
4624 if (!tp_warned.bright_cmos_ec_unsync) {
4625 printk(TPACPI_ERR
4626 "CMOS NVRAM (%u) and EC (%u) do not "
4627 "agree on display brightness level\n",
4628 (unsigned int) lcmos,
4629 (unsigned int) lec);
4630 tp_warned.bright_cmos_ec_unsync = 1;
4631 }
4632 return -EIO;
4633 }
4634 } else {
4635 *status = level;
4636 }
4637
4638 return 0;
4639 }
4640
4641 /* May return EINTR which can always be mapped to ERESTARTSYS */
4642 static int brightness_set(int value)
4643 {
4644 int cmos_cmd, inc, i, res;
4645 int current_value;
4646 int command_bits;
4647
4648 if (value > ((tp_features.bright_16levels)? 15 : 7) ||
4649 value < 0)
4650 return -EINVAL;
4651
4652 res = mutex_lock_interruptible(&brightness_mutex);
4653 if (res < 0)
4654 return res;
4655
4656 res = brightness_get_raw(&current_value);
4657 if (res < 0)
4658 goto errout;
4659
4660 command_bits = current_value & TP_EC_BACKLIGHT_CMDMSK;
4661 current_value &= TP_EC_BACKLIGHT_LVLMSK;
4662
4663 cmos_cmd = value > current_value ?
4664 TP_CMOS_BRIGHTNESS_UP :
4665 TP_CMOS_BRIGHTNESS_DOWN;
4666 inc = (value > current_value)? 1 : -1;
4667
4668 res = 0;
4669 for (i = current_value; i != value; i += inc) {
4670 if ((brightness_mode & 2) &&
4671 issue_thinkpad_cmos_command(cmos_cmd)) {
4672 res = -EIO;
4673 goto errout;
4674 }
4675 if ((brightness_mode & 1) &&
4676 !acpi_ec_write(TP_EC_BACKLIGHT,
4677 (i + inc) | command_bits)) {
4678 res = -EIO;
4679 goto errout;;
4680 }
4681 }
4682
4683 errout:
4684 mutex_unlock(&brightness_mutex);
4685 return res;
4686 }
4687
4688 /* sysfs backlight class ----------------------------------------------- */
4689
4690 static int brightness_update_status(struct backlight_device *bd)
4691 {
4692 /* it is the backlight class's job (caller) to handle
4693 * EINTR and other errors properly */
4694 return brightness_set(
4695 (bd->props.fb_blank == FB_BLANK_UNBLANK &&
4696 bd->props.power == FB_BLANK_UNBLANK) ?
4697 bd->props.brightness : 0);
4698 }
4699
4700 static int brightness_get(struct backlight_device *bd)
4701 {
4702 int status, res;
4703
4704 res = brightness_get_raw(&status);
4705 if (res < 0)
4706 return 0; /* FIXME: teach backlight about error handling */
4707
4708 return status & TP_EC_BACKLIGHT_LVLMSK;
4709 }
4710
4711 static struct backlight_ops ibm_backlight_data = {
4712 .get_brightness = brightness_get,
4713 .update_status = brightness_update_status,
4714 };
4715
4716 /* --------------------------------------------------------------------- */
4717
4718 static int __init brightness_init(struct ibm_init_struct *iibm)
4719 {
4720 int b;
4721
4722 vdbg_printk(TPACPI_DBG_INIT, "initializing brightness subdriver\n");
4723
4724 mutex_init(&brightness_mutex);
4725
4726 /*
4727 * We always attempt to detect acpi support, so as to switch
4728 * Lenovo Vista BIOS to ACPI brightness mode even if we are not
4729 * going to publish a backlight interface
4730 */
4731 b = tpacpi_check_std_acpi_brightness_support();
4732 if (b > 0) {
4733 if (thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO) {
4734 printk(TPACPI_NOTICE
4735 "Lenovo BIOS switched to ACPI backlight "
4736 "control mode\n");
4737 }
4738 if (brightness_enable > 1) {
4739 printk(TPACPI_NOTICE
4740 "standard ACPI backlight interface "
4741 "available, not loading native one...\n");
4742 return 1;
4743 }
4744 }
4745
4746 if (!brightness_enable) {
4747 dbg_printk(TPACPI_DBG_INIT,
4748 "brightness support disabled by "
4749 "module parameter\n");
4750 return 1;
4751 }
4752
4753 if (b > 16) {
4754 printk(TPACPI_ERR
4755 "Unsupported brightness interface, "
4756 "please contact %s\n", TPACPI_MAIL);
4757 return 1;
4758 }
4759 if (b == 16)
4760 tp_features.bright_16levels = 1;
4761
4762 if (!brightness_mode) {
4763 if (thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO)
4764 brightness_mode = 2;
4765 else
4766 brightness_mode = 3;
4767
4768 dbg_printk(TPACPI_DBG_INIT, "selected brightness_mode=%d\n",
4769 brightness_mode);
4770 }
4771
4772 if (brightness_mode > 3)
4773 return -EINVAL;
4774
4775 if (brightness_get_raw(&b) < 0)
4776 return 1;
4777
4778 if (tp_features.bright_16levels)
4779 printk(TPACPI_INFO
4780 "detected a 16-level brightness capable ThinkPad\n");
4781
4782 ibm_backlight_device = backlight_device_register(
4783 TPACPI_BACKLIGHT_DEV_NAME, NULL, NULL,
4784 &ibm_backlight_data);
4785 if (IS_ERR(ibm_backlight_device)) {
4786 printk(TPACPI_ERR "Could not register backlight device\n");
4787 return PTR_ERR(ibm_backlight_device);
4788 }
4789 vdbg_printk(TPACPI_DBG_INIT, "brightness is supported\n");
4790
4791 ibm_backlight_device->props.max_brightness =
4792 (tp_features.bright_16levels)? 15 : 7;
4793 ibm_backlight_device->props.brightness = b & TP_EC_BACKLIGHT_LVLMSK;
4794 backlight_update_status(ibm_backlight_device);
4795
4796 return 0;
4797 }
4798
4799 static void brightness_exit(void)
4800 {
4801 if (ibm_backlight_device) {
4802 vdbg_printk(TPACPI_DBG_EXIT,
4803 "calling backlight_device_unregister()\n");
4804 backlight_device_unregister(ibm_backlight_device);
4805 ibm_backlight_device = NULL;
4806 }
4807 }
4808
4809 static int brightness_read(char *p)
4810 {
4811 int len = 0;
4812 int level;
4813
4814 level = brightness_get(NULL);
4815 if (level < 0) {
4816 len += sprintf(p + len, "level:\t\tunreadable\n");
4817 } else {
4818 len += sprintf(p + len, "level:\t\t%d\n", level);
4819 len += sprintf(p + len, "commands:\tup, down\n");
4820 len += sprintf(p + len, "commands:\tlevel <level>"
4821 " (<level> is 0-%d)\n",
4822 (tp_features.bright_16levels) ? 15 : 7);
4823 }
4824
4825 return len;
4826 }
4827
4828 static int brightness_write(char *buf)
4829 {
4830 int level;
4831 int rc;
4832 char *cmd;
4833 int max_level = (tp_features.bright_16levels) ? 15 : 7;
4834
4835 level = brightness_get(NULL);
4836 if (level < 0)
4837 return level;
4838
4839 while ((cmd = next_cmd(&buf))) {
4840 if (strlencmp(cmd, "up") == 0) {
4841 if (level < max_level)
4842 level++;
4843 } else if (strlencmp(cmd, "down") == 0) {
4844 if (level > 0)
4845 level--;
4846 } else if (sscanf(cmd, "level %d", &level) == 1 &&
4847 level >= 0 && level <= max_level) {
4848 /* new level set */
4849 } else
4850 return -EINVAL;
4851 }
4852
4853 /*
4854 * Now we know what the final level should be, so we try to set it.
4855 * Doing it this way makes the syscall restartable in case of EINTR
4856 */
4857 rc = brightness_set(level);
4858 return (rc == -EINTR)? ERESTARTSYS : rc;
4859 }
4860
4861 static struct ibm_struct brightness_driver_data = {
4862 .name = "brightness",
4863 .read = brightness_read,
4864 .write = brightness_write,
4865 .exit = brightness_exit,
4866 };
4867
4868 /*************************************************************************
4869 * Volume subdriver
4870 */
4871
4872 static int volume_offset = 0x30;
4873
4874 static int volume_read(char *p)
4875 {
4876 int len = 0;
4877 u8 level;
4878
4879 if (!acpi_ec_read(volume_offset, &level)) {
4880 len += sprintf(p + len, "level:\t\tunreadable\n");
4881 } else {
4882 len += sprintf(p + len, "level:\t\t%d\n", level & 0xf);
4883 len += sprintf(p + len, "mute:\t\t%s\n", onoff(level, 6));
4884 len += sprintf(p + len, "commands:\tup, down, mute\n");
4885 len += sprintf(p + len, "commands:\tlevel <level>"
4886 " (<level> is 0-15)\n");
4887 }
4888
4889 return len;
4890 }
4891
4892 static int volume_write(char *buf)
4893 {
4894 int cmos_cmd, inc, i;
4895 u8 level, mute;
4896 int new_level, new_mute;
4897 char *cmd;
4898
4899 while ((cmd = next_cmd(&buf))) {
4900 if (!acpi_ec_read(volume_offset, &level))
4901 return -EIO;
4902 new_mute = mute = level & 0x40;
4903 new_level = level = level & 0xf;
4904
4905 if (strlencmp(cmd, "up") == 0) {
4906 if (mute)
4907 new_mute = 0;
4908 else
4909 new_level = level == 15 ? 15 : level + 1;
4910 } else if (strlencmp(cmd, "down") == 0) {
4911 if (mute)
4912 new_mute = 0;
4913 else
4914 new_level = level == 0 ? 0 : level - 1;
4915 } else if (sscanf(cmd, "level %d", &new_level) == 1 &&
4916 new_level >= 0 && new_level <= 15) {
4917 /* new_level set */
4918 } else if (strlencmp(cmd, "mute") == 0) {
4919 new_mute = 0x40;
4920 } else
4921 return -EINVAL;
4922
4923 if (new_level != level) {
4924 /* mute doesn't change */
4925
4926 cmos_cmd = (new_level > level) ?
4927 TP_CMOS_VOLUME_UP : TP_CMOS_VOLUME_DOWN;
4928 inc = new_level > level ? 1 : -1;
4929
4930 if (mute && (issue_thinkpad_cmos_command(cmos_cmd) ||
4931 !acpi_ec_write(volume_offset, level)))
4932 return -EIO;
4933
4934 for (i = level; i != new_level; i += inc)
4935 if (issue_thinkpad_cmos_command(cmos_cmd) ||
4936 !acpi_ec_write(volume_offset, i + inc))
4937 return -EIO;
4938
4939 if (mute &&
4940 (issue_thinkpad_cmos_command(TP_CMOS_VOLUME_MUTE) ||
4941 !acpi_ec_write(volume_offset, new_level + mute))) {
4942 return -EIO;
4943 }
4944 }
4945
4946 if (new_mute != mute) {
4947 /* level doesn't change */
4948
4949 cmos_cmd = (new_mute) ?
4950 TP_CMOS_VOLUME_MUTE : TP_CMOS_VOLUME_UP;
4951
4952 if (issue_thinkpad_cmos_command(cmos_cmd) ||
4953 !acpi_ec_write(volume_offset, level + new_mute))
4954 return -EIO;
4955 }
4956 }
4957
4958 return 0;
4959 }
4960
4961 static struct ibm_struct volume_driver_data = {
4962 .name = "volume",
4963 .read = volume_read,
4964 .write = volume_write,
4965 };
4966
4967 /*************************************************************************
4968 * Fan subdriver
4969 */
4970
4971 /*
4972 * FAN ACCESS MODES
4973 *
4974 * TPACPI_FAN_RD_ACPI_GFAN:
4975 * ACPI GFAN method: returns fan level
4976 *
4977 * see TPACPI_FAN_WR_ACPI_SFAN
4978 * EC 0x2f (HFSP) not available if GFAN exists
4979 *
4980 * TPACPI_FAN_WR_ACPI_SFAN:
4981 * ACPI SFAN method: sets fan level, 0 (stop) to 7 (max)
4982 *
4983 * EC 0x2f (HFSP) might be available *for reading*, but do not use
4984 * it for writing.
4985 *
4986 * TPACPI_FAN_WR_TPEC:
4987 * ThinkPad EC register 0x2f (HFSP): fan control loop mode
4988 * Supported on almost all ThinkPads
4989 *
4990 * Fan speed changes of any sort (including those caused by the
4991 * disengaged mode) are usually done slowly by the firmware as the
4992 * maximum ammount of fan duty cycle change per second seems to be
4993 * limited.
4994 *
4995 * Reading is not available if GFAN exists.
4996 * Writing is not available if SFAN exists.
4997 *
4998 * Bits
4999 * 7 automatic mode engaged;
5000 * (default operation mode of the ThinkPad)
5001 * fan level is ignored in this mode.
5002 * 6 full speed mode (takes precedence over bit 7);
5003 * not available on all thinkpads. May disable
5004 * the tachometer while the fan controller ramps up
5005 * the speed (which can take up to a few *minutes*).
5006 * Speeds up fan to 100% duty-cycle, which is far above
5007 * the standard RPM levels. It is not impossible that
5008 * it could cause hardware damage.
5009 * 5-3 unused in some models. Extra bits for fan level
5010 * in others, but still useless as all values above
5011 * 7 map to the same speed as level 7 in these models.
5012 * 2-0 fan level (0..7 usually)
5013 * 0x00 = stop
5014 * 0x07 = max (set when temperatures critical)
5015 * Some ThinkPads may have other levels, see
5016 * TPACPI_FAN_WR_ACPI_FANS (X31/X40/X41)
5017 *
5018 * FIRMWARE BUG: on some models, EC 0x2f might not be initialized at
5019 * boot. Apparently the EC does not intialize it, so unless ACPI DSDT
5020 * does so, its initial value is meaningless (0x07).
5021 *
5022 * For firmware bugs, refer to:
5023 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
5024 *
5025 * ----
5026 *
5027 * ThinkPad EC register 0x84 (LSB), 0x85 (MSB):
5028 * Main fan tachometer reading (in RPM)
5029 *
5030 * This register is present on all ThinkPads with a new-style EC, and
5031 * it is known not to be present on the A21m/e, and T22, as there is
5032 * something else in offset 0x84 according to the ACPI DSDT. Other
5033 * ThinkPads from this same time period (and earlier) probably lack the
5034 * tachometer as well.
5035 *
5036 * Unfortunately a lot of ThinkPads with new-style ECs but whose firwmare
5037 * was never fixed by IBM to report the EC firmware version string
5038 * probably support the tachometer (like the early X models), so
5039 * detecting it is quite hard. We need more data to know for sure.
5040 *
5041 * FIRMWARE BUG: always read 0x84 first, otherwise incorrect readings
5042 * might result.
5043 *
5044 * FIRMWARE BUG: may go stale while the EC is switching to full speed
5045 * mode.
5046 *
5047 * For firmware bugs, refer to:
5048 * http://thinkwiki.org/wiki/Embedded_Controller_Firmware#Firmware_Issues
5049 *
5050 * TPACPI_FAN_WR_ACPI_FANS:
5051 * ThinkPad X31, X40, X41. Not available in the X60.
5052 *
5053 * FANS ACPI handle: takes three arguments: low speed, medium speed,
5054 * high speed. ACPI DSDT seems to map these three speeds to levels
5055 * as follows: STOP LOW LOW MED MED HIGH HIGH HIGH HIGH
5056 * (this map is stored on FAN0..FAN8 as "0,1,1,2,2,3,3,3,3")
5057 *
5058 * The speeds are stored on handles
5059 * (FANA:FAN9), (FANC:FANB), (FANE:FAND).
5060 *
5061 * There are three default speed sets, acessible as handles:
5062 * FS1L,FS1M,FS1H; FS2L,FS2M,FS2H; FS3L,FS3M,FS3H
5063 *
5064 * ACPI DSDT switches which set is in use depending on various
5065 * factors.
5066 *
5067 * TPACPI_FAN_WR_TPEC is also available and should be used to
5068 * command the fan. The X31/X40/X41 seems to have 8 fan levels,
5069 * but the ACPI tables just mention level 7.
5070 */
5071
5072 enum { /* Fan control constants */
5073 fan_status_offset = 0x2f, /* EC register 0x2f */
5074 fan_rpm_offset = 0x84, /* EC register 0x84: LSB, 0x85 MSB (RPM)
5075 * 0x84 must be read before 0x85 */
5076
5077 TP_EC_FAN_FULLSPEED = 0x40, /* EC fan mode: full speed */
5078 TP_EC_FAN_AUTO = 0x80, /* EC fan mode: auto fan control */
5079
5080 TPACPI_FAN_LAST_LEVEL = 0x100, /* Use cached last-seen fan level */
5081 };
5082
5083 enum fan_status_access_mode {
5084 TPACPI_FAN_NONE = 0, /* No fan status or control */
5085 TPACPI_FAN_RD_ACPI_GFAN, /* Use ACPI GFAN */
5086 TPACPI_FAN_RD_TPEC, /* Use ACPI EC regs 0x2f, 0x84-0x85 */
5087 };
5088
5089 enum fan_control_access_mode {
5090 TPACPI_FAN_WR_NONE = 0, /* No fan control */
5091 TPACPI_FAN_WR_ACPI_SFAN, /* Use ACPI SFAN */
5092 TPACPI_FAN_WR_TPEC, /* Use ACPI EC reg 0x2f */
5093 TPACPI_FAN_WR_ACPI_FANS, /* Use ACPI FANS and EC reg 0x2f */
5094 };
5095
5096 enum fan_control_commands {
5097 TPACPI_FAN_CMD_SPEED = 0x0001, /* speed command */
5098 TPACPI_FAN_CMD_LEVEL = 0x0002, /* level command */
5099 TPACPI_FAN_CMD_ENABLE = 0x0004, /* enable/disable cmd,
5100 * and also watchdog cmd */
5101 };
5102
5103 static int fan_control_allowed;
5104
5105 static enum fan_status_access_mode fan_status_access_mode;
5106 static enum fan_control_access_mode fan_control_access_mode;
5107 static enum fan_control_commands fan_control_commands;
5108
5109 static u8 fan_control_initial_status;
5110 static u8 fan_control_desired_level;
5111 static int fan_watchdog_maxinterval;
5112
5113 static struct mutex fan_mutex;
5114
5115 static void fan_watchdog_fire(struct work_struct *ignored);
5116 static DECLARE_DELAYED_WORK(fan_watchdog_task, fan_watchdog_fire);
5117
5118 TPACPI_HANDLE(fans, ec, "FANS"); /* X31, X40, X41 */
5119 TPACPI_HANDLE(gfan, ec, "GFAN", /* 570 */
5120 "\\FSPD", /* 600e/x, 770e, 770x */
5121 ); /* all others */
5122 TPACPI_HANDLE(sfan, ec, "SFAN", /* 570 */
5123 "JFNS", /* 770x-JL */
5124 ); /* all others */
5125
5126 /*
5127 * Call with fan_mutex held
5128 */
5129 static void fan_update_desired_level(u8 status)
5130 {
5131 if ((status &
5132 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) {
5133 if (status > 7)
5134 fan_control_desired_level = 7;
5135 else
5136 fan_control_desired_level = status;
5137 }
5138 }
5139
5140 static int fan_get_status(u8 *status)
5141 {
5142 u8 s;
5143
5144 /* TODO:
5145 * Add TPACPI_FAN_RD_ACPI_FANS ? */
5146
5147 switch (fan_status_access_mode) {
5148 case TPACPI_FAN_RD_ACPI_GFAN:
5149 /* 570, 600e/x, 770e, 770x */
5150
5151 if (unlikely(!acpi_evalf(gfan_handle, &s, NULL, "d")))
5152 return -EIO;
5153
5154 if (likely(status))
5155 *status = s & 0x07;
5156
5157 break;
5158
5159 case TPACPI_FAN_RD_TPEC:
5160 /* all except 570, 600e/x, 770e, 770x */
5161 if (unlikely(!acpi_ec_read(fan_status_offset, &s)))
5162 return -EIO;
5163
5164 if (likely(status))
5165 *status = s;
5166
5167 break;
5168
5169 default:
5170 return -ENXIO;
5171 }
5172
5173 return 0;
5174 }
5175
5176 static int fan_get_status_safe(u8 *status)
5177 {
5178 int rc;
5179 u8 s;
5180
5181 if (mutex_lock_interruptible(&fan_mutex))
5182 return -ERESTARTSYS;
5183 rc = fan_get_status(&s);
5184 if (!rc)
5185 fan_update_desired_level(s);
5186 mutex_unlock(&fan_mutex);
5187
5188 if (status)
5189 *status = s;
5190
5191 return rc;
5192 }
5193
5194 static int fan_get_speed(unsigned int *speed)
5195 {
5196 u8 hi, lo;
5197
5198 switch (fan_status_access_mode) {
5199 case TPACPI_FAN_RD_TPEC:
5200 /* all except 570, 600e/x, 770e, 770x */
5201 if (unlikely(!acpi_ec_read(fan_rpm_offset, &lo) ||
5202 !acpi_ec_read(fan_rpm_offset + 1, &hi)))
5203 return -EIO;
5204
5205 if (likely(speed))
5206 *speed = (hi << 8) | lo;
5207
5208 break;
5209
5210 default:
5211 return -ENXIO;
5212 }
5213
5214 return 0;
5215 }
5216
5217 static int fan_set_level(int level)
5218 {
5219 if (!fan_control_allowed)
5220 return -EPERM;
5221
5222 switch (fan_control_access_mode) {
5223 case TPACPI_FAN_WR_ACPI_SFAN:
5224 if (level >= 0 && level <= 7) {
5225 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", level))
5226 return -EIO;
5227 } else
5228 return -EINVAL;
5229 break;
5230
5231 case TPACPI_FAN_WR_ACPI_FANS:
5232 case TPACPI_FAN_WR_TPEC:
5233 if ((level != TP_EC_FAN_AUTO) &&
5234 (level != TP_EC_FAN_FULLSPEED) &&
5235 ((level < 0) || (level > 7)))
5236 return -EINVAL;
5237
5238 /* safety net should the EC not support AUTO
5239 * or FULLSPEED mode bits and just ignore them */
5240 if (level & TP_EC_FAN_FULLSPEED)
5241 level |= 7; /* safety min speed 7 */
5242 else if (level & TP_EC_FAN_AUTO)
5243 level |= 4; /* safety min speed 4 */
5244
5245 if (!acpi_ec_write(fan_status_offset, level))
5246 return -EIO;
5247 else
5248 tp_features.fan_ctrl_status_undef = 0;
5249 break;
5250
5251 default:
5252 return -ENXIO;
5253 }
5254 return 0;
5255 }
5256
5257 static int fan_set_level_safe(int level)
5258 {
5259 int rc;
5260
5261 if (!fan_control_allowed)
5262 return -EPERM;
5263
5264 if (mutex_lock_interruptible(&fan_mutex))
5265 return -ERESTARTSYS;
5266
5267 if (level == TPACPI_FAN_LAST_LEVEL)
5268 level = fan_control_desired_level;
5269
5270 rc = fan_set_level(level);
5271 if (!rc)
5272 fan_update_desired_level(level);
5273
5274 mutex_unlock(&fan_mutex);
5275 return rc;
5276 }
5277
5278 static int fan_set_enable(void)
5279 {
5280 u8 s;
5281 int rc;
5282
5283 if (!fan_control_allowed)
5284 return -EPERM;
5285
5286 if (mutex_lock_interruptible(&fan_mutex))
5287 return -ERESTARTSYS;
5288
5289 switch (fan_control_access_mode) {
5290 case TPACPI_FAN_WR_ACPI_FANS:
5291 case TPACPI_FAN_WR_TPEC:
5292 rc = fan_get_status(&s);
5293 if (rc < 0)
5294 break;
5295
5296 /* Don't go out of emergency fan mode */
5297 if (s != 7) {
5298 s &= 0x07;
5299 s |= TP_EC_FAN_AUTO | 4; /* min fan speed 4 */
5300 }
5301
5302 if (!acpi_ec_write(fan_status_offset, s))
5303 rc = -EIO;
5304 else {
5305 tp_features.fan_ctrl_status_undef = 0;
5306 rc = 0;
5307 }
5308 break;
5309
5310 case TPACPI_FAN_WR_ACPI_SFAN:
5311 rc = fan_get_status(&s);
5312 if (rc < 0)
5313 break;
5314
5315 s &= 0x07;
5316
5317 /* Set fan to at least level 4 */
5318 s |= 4;
5319
5320 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", s))
5321 rc = -EIO;
5322 else
5323 rc = 0;
5324 break;
5325
5326 default:
5327 rc = -ENXIO;
5328 }
5329
5330 mutex_unlock(&fan_mutex);
5331 return rc;
5332 }
5333
5334 static int fan_set_disable(void)
5335 {
5336 int rc;
5337
5338 if (!fan_control_allowed)
5339 return -EPERM;
5340
5341 if (mutex_lock_interruptible(&fan_mutex))
5342 return -ERESTARTSYS;
5343
5344 rc = 0;
5345 switch (fan_control_access_mode) {
5346 case TPACPI_FAN_WR_ACPI_FANS:
5347 case TPACPI_FAN_WR_TPEC:
5348 if (!acpi_ec_write(fan_status_offset, 0x00))
5349 rc = -EIO;
5350 else {
5351 fan_control_desired_level = 0;
5352 tp_features.fan_ctrl_status_undef = 0;
5353 }
5354 break;
5355
5356 case TPACPI_FAN_WR_ACPI_SFAN:
5357 if (!acpi_evalf(sfan_handle, NULL, NULL, "vd", 0x00))
5358 rc = -EIO;
5359 else
5360 fan_control_desired_level = 0;
5361 break;
5362
5363 default:
5364 rc = -ENXIO;
5365 }
5366
5367
5368 mutex_unlock(&fan_mutex);
5369 return rc;
5370 }
5371
5372 static int fan_set_speed(int speed)
5373 {
5374 int rc;
5375
5376 if (!fan_control_allowed)
5377 return -EPERM;
5378
5379 if (mutex_lock_interruptible(&fan_mutex))
5380 return -ERESTARTSYS;
5381
5382 rc = 0;
5383 switch (fan_control_access_mode) {
5384 case TPACPI_FAN_WR_ACPI_FANS:
5385 if (speed >= 0 && speed <= 65535) {
5386 if (!acpi_evalf(fans_handle, NULL, NULL, "vddd",
5387 speed, speed, speed))
5388 rc = -EIO;
5389 } else
5390 rc = -EINVAL;
5391 break;
5392
5393 default:
5394 rc = -ENXIO;
5395 }
5396
5397 mutex_unlock(&fan_mutex);
5398 return rc;
5399 }
5400
5401 static void fan_watchdog_reset(void)
5402 {
5403 static int fan_watchdog_active;
5404
5405 if (fan_control_access_mode == TPACPI_FAN_WR_NONE)
5406 return;
5407
5408 if (fan_watchdog_active)
5409 cancel_delayed_work(&fan_watchdog_task);
5410
5411 if (fan_watchdog_maxinterval > 0 &&
5412 tpacpi_lifecycle != TPACPI_LIFE_EXITING) {
5413 fan_watchdog_active = 1;
5414 if (!queue_delayed_work(tpacpi_wq, &fan_watchdog_task,
5415 msecs_to_jiffies(fan_watchdog_maxinterval
5416 * 1000))) {
5417 printk(TPACPI_ERR
5418 "failed to queue the fan watchdog, "
5419 "watchdog will not trigger\n");
5420 }
5421 } else
5422 fan_watchdog_active = 0;
5423 }
5424
5425 static void fan_watchdog_fire(struct work_struct *ignored)
5426 {
5427 int rc;
5428
5429 if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
5430 return;
5431
5432 printk(TPACPI_NOTICE "fan watchdog: enabling fan\n");
5433 rc = fan_set_enable();
5434 if (rc < 0) {
5435 printk(TPACPI_ERR "fan watchdog: error %d while enabling fan, "
5436 "will try again later...\n", -rc);
5437 /* reschedule for later */
5438 fan_watchdog_reset();
5439 }
5440 }
5441
5442 /*
5443 * SYSFS fan layout: hwmon compatible (device)
5444 *
5445 * pwm*_enable:
5446 * 0: "disengaged" mode
5447 * 1: manual mode
5448 * 2: native EC "auto" mode (recommended, hardware default)
5449 *
5450 * pwm*: set speed in manual mode, ignored otherwise.
5451 * 0 is level 0; 255 is level 7. Intermediate points done with linear
5452 * interpolation.
5453 *
5454 * fan*_input: tachometer reading, RPM
5455 *
5456 *
5457 * SYSFS fan layout: extensions
5458 *
5459 * fan_watchdog (driver):
5460 * fan watchdog interval in seconds, 0 disables (default), max 120
5461 */
5462
5463 /* sysfs fan pwm1_enable ----------------------------------------------- */
5464 static ssize_t fan_pwm1_enable_show(struct device *dev,
5465 struct device_attribute *attr,
5466 char *buf)
5467 {
5468 int res, mode;
5469 u8 status;
5470
5471 res = fan_get_status_safe(&status);
5472 if (res)
5473 return res;
5474
5475 if (unlikely(tp_features.fan_ctrl_status_undef)) {
5476 if (status != fan_control_initial_status) {
5477 tp_features.fan_ctrl_status_undef = 0;
5478 } else {
5479 /* Return most likely status. In fact, it
5480 * might be the only possible status */
5481 status = TP_EC_FAN_AUTO;
5482 }
5483 }
5484
5485 if (status & TP_EC_FAN_FULLSPEED) {
5486 mode = 0;
5487 } else if (status & TP_EC_FAN_AUTO) {
5488 mode = 2;
5489 } else
5490 mode = 1;
5491
5492 return snprintf(buf, PAGE_SIZE, "%d\n", mode);
5493 }
5494
5495 static ssize_t fan_pwm1_enable_store(struct device *dev,
5496 struct device_attribute *attr,
5497 const char *buf, size_t count)
5498 {
5499 unsigned long t;
5500 int res, level;
5501
5502 if (parse_strtoul(buf, 2, &t))
5503 return -EINVAL;
5504
5505 switch (t) {
5506 case 0:
5507 level = TP_EC_FAN_FULLSPEED;
5508 break;
5509 case 1:
5510 level = TPACPI_FAN_LAST_LEVEL;
5511 break;
5512 case 2:
5513 level = TP_EC_FAN_AUTO;
5514 break;
5515 case 3:
5516 /* reserved for software-controlled auto mode */
5517 return -ENOSYS;
5518 default:
5519 return -EINVAL;
5520 }
5521
5522 res = fan_set_level_safe(level);
5523 if (res == -ENXIO)
5524 return -EINVAL;
5525 else if (res < 0)
5526 return res;
5527
5528 fan_watchdog_reset();
5529
5530 return count;
5531 }
5532
5533 static struct device_attribute dev_attr_fan_pwm1_enable =
5534 __ATTR(pwm1_enable, S_IWUSR | S_IRUGO,
5535 fan_pwm1_enable_show, fan_pwm1_enable_store);
5536
5537 /* sysfs fan pwm1 ------------------------------------------------------ */
5538 static ssize_t fan_pwm1_show(struct device *dev,
5539 struct device_attribute *attr,
5540 char *buf)
5541 {
5542 int res;
5543 u8 status;
5544
5545 res = fan_get_status_safe(&status);
5546 if (res)
5547 return res;
5548
5549 if (unlikely(tp_features.fan_ctrl_status_undef)) {
5550 if (status != fan_control_initial_status) {
5551 tp_features.fan_ctrl_status_undef = 0;
5552 } else {
5553 status = TP_EC_FAN_AUTO;
5554 }
5555 }
5556
5557 if ((status &
5558 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) != 0)
5559 status = fan_control_desired_level;
5560
5561 if (status > 7)
5562 status = 7;
5563
5564 return snprintf(buf, PAGE_SIZE, "%u\n", (status * 255) / 7);
5565 }
5566
5567 static ssize_t fan_pwm1_store(struct device *dev,
5568 struct device_attribute *attr,
5569 const char *buf, size_t count)
5570 {
5571 unsigned long s;
5572 int rc;
5573 u8 status, newlevel;
5574
5575 if (parse_strtoul(buf, 255, &s))
5576 return -EINVAL;
5577
5578 /* scale down from 0-255 to 0-7 */
5579 newlevel = (s >> 5) & 0x07;
5580
5581 if (mutex_lock_interruptible(&fan_mutex))
5582 return -ERESTARTSYS;
5583
5584 rc = fan_get_status(&status);
5585 if (!rc && (status &
5586 (TP_EC_FAN_AUTO | TP_EC_FAN_FULLSPEED)) == 0) {
5587 rc = fan_set_level(newlevel);
5588 if (rc == -ENXIO)
5589 rc = -EINVAL;
5590 else if (!rc) {
5591 fan_update_desired_level(newlevel);
5592 fan_watchdog_reset();
5593 }
5594 }
5595
5596 mutex_unlock(&fan_mutex);
5597 return (rc)? rc : count;
5598 }
5599
5600 static struct device_attribute dev_attr_fan_pwm1 =
5601 __ATTR(pwm1, S_IWUSR | S_IRUGO,
5602 fan_pwm1_show, fan_pwm1_store);
5603
5604 /* sysfs fan fan1_input ------------------------------------------------ */
5605 static ssize_t fan_fan1_input_show(struct device *dev,
5606 struct device_attribute *attr,
5607 char *buf)
5608 {
5609 int res;
5610 unsigned int speed;
5611
5612 res = fan_get_speed(&speed);
5613 if (res < 0)
5614 return res;
5615
5616 return snprintf(buf, PAGE_SIZE, "%u\n", speed);
5617 }
5618
5619 static struct device_attribute dev_attr_fan_fan1_input =
5620 __ATTR(fan1_input, S_IRUGO,
5621 fan_fan1_input_show, NULL);
5622
5623 /* sysfs fan fan_watchdog (hwmon driver) ------------------------------- */
5624 static ssize_t fan_fan_watchdog_show(struct device_driver *drv,
5625 char *buf)
5626 {
5627 return snprintf(buf, PAGE_SIZE, "%u\n", fan_watchdog_maxinterval);
5628 }
5629
5630 static ssize_t fan_fan_watchdog_store(struct device_driver *drv,
5631 const char *buf, size_t count)
5632 {
5633 unsigned long t;
5634
5635 if (parse_strtoul(buf, 120, &t))
5636 return -EINVAL;
5637
5638 if (!fan_control_allowed)
5639 return -EPERM;
5640
5641 fan_watchdog_maxinterval = t;
5642 fan_watchdog_reset();
5643
5644 return count;
5645 }
5646
5647 static DRIVER_ATTR(fan_watchdog, S_IWUSR | S_IRUGO,
5648 fan_fan_watchdog_show, fan_fan_watchdog_store);
5649
5650 /* --------------------------------------------------------------------- */
5651 static struct attribute *fan_attributes[] = {
5652 &dev_attr_fan_pwm1_enable.attr, &dev_attr_fan_pwm1.attr,
5653 &dev_attr_fan_fan1_input.attr,
5654 NULL
5655 };
5656
5657 static const struct attribute_group fan_attr_group = {
5658 .attrs = fan_attributes,
5659 };
5660
5661 static int __init fan_init(struct ibm_init_struct *iibm)
5662 {
5663 int rc;
5664
5665 vdbg_printk(TPACPI_DBG_INIT, "initializing fan subdriver\n");
5666
5667 mutex_init(&fan_mutex);
5668 fan_status_access_mode = TPACPI_FAN_NONE;
5669 fan_control_access_mode = TPACPI_FAN_WR_NONE;
5670 fan_control_commands = 0;
5671 fan_watchdog_maxinterval = 0;
5672 tp_features.fan_ctrl_status_undef = 0;
5673 fan_control_desired_level = 7;
5674
5675 TPACPI_ACPIHANDLE_INIT(fans);
5676 TPACPI_ACPIHANDLE_INIT(gfan);
5677 TPACPI_ACPIHANDLE_INIT(sfan);
5678
5679 if (gfan_handle) {
5680 /* 570, 600e/x, 770e, 770x */
5681 fan_status_access_mode = TPACPI_FAN_RD_ACPI_GFAN;
5682 } else {
5683 /* all other ThinkPads: note that even old-style
5684 * ThinkPad ECs supports the fan control register */
5685 if (likely(acpi_ec_read(fan_status_offset,
5686 &fan_control_initial_status))) {
5687 fan_status_access_mode = TPACPI_FAN_RD_TPEC;
5688
5689 /* In some ThinkPads, neither the EC nor the ACPI
5690 * DSDT initialize the fan status, and it ends up
5691 * being set to 0x07 when it *could* be either
5692 * 0x07 or 0x80.
5693 *
5694 * Enable for TP-1Y (T43), TP-78 (R51e),
5695 * TP-76 (R52), TP-70 (T43, R52), which are known
5696 * to be buggy. */
5697 if (fan_control_initial_status == 0x07) {
5698 switch (thinkpad_id.ec_model) {
5699 case 0x5931: /* TP-1Y */
5700 case 0x3837: /* TP-78 */
5701 case 0x3637: /* TP-76 */
5702 case 0x3037: /* TP-70 */
5703 printk(TPACPI_NOTICE
5704 "fan_init: initial fan status "
5705 "is unknown, assuming it is "
5706 "in auto mode\n");
5707 tp_features.fan_ctrl_status_undef = 1;
5708 ;;
5709 }
5710 }
5711 } else {
5712 printk(TPACPI_ERR
5713 "ThinkPad ACPI EC access misbehaving, "
5714 "fan status and control unavailable\n");
5715 return 1;
5716 }
5717 }
5718
5719 if (sfan_handle) {
5720 /* 570, 770x-JL */
5721 fan_control_access_mode = TPACPI_FAN_WR_ACPI_SFAN;
5722 fan_control_commands |=
5723 TPACPI_FAN_CMD_LEVEL | TPACPI_FAN_CMD_ENABLE;
5724 } else {
5725 if (!gfan_handle) {
5726 /* gfan without sfan means no fan control */
5727 /* all other models implement TP EC 0x2f control */
5728
5729 if (fans_handle) {
5730 /* X31, X40, X41 */
5731 fan_control_access_mode =
5732 TPACPI_FAN_WR_ACPI_FANS;
5733 fan_control_commands |=
5734 TPACPI_FAN_CMD_SPEED |
5735 TPACPI_FAN_CMD_LEVEL |
5736 TPACPI_FAN_CMD_ENABLE;
5737 } else {
5738 fan_control_access_mode = TPACPI_FAN_WR_TPEC;
5739 fan_control_commands |=
5740 TPACPI_FAN_CMD_LEVEL |
5741 TPACPI_FAN_CMD_ENABLE;
5742 }
5743 }
5744 }
5745
5746 vdbg_printk(TPACPI_DBG_INIT, "fan is %s, modes %d, %d\n",
5747 str_supported(fan_status_access_mode != TPACPI_FAN_NONE ||
5748 fan_control_access_mode != TPACPI_FAN_WR_NONE),
5749 fan_status_access_mode, fan_control_access_mode);
5750
5751 /* fan control master switch */
5752 if (!fan_control_allowed) {
5753 fan_control_access_mode = TPACPI_FAN_WR_NONE;
5754 fan_control_commands = 0;
5755 dbg_printk(TPACPI_DBG_INIT,
5756 "fan control features disabled by parameter\n");
5757 }
5758
5759 /* update fan_control_desired_level */
5760 if (fan_status_access_mode != TPACPI_FAN_NONE)
5761 fan_get_status_safe(NULL);
5762
5763 if (fan_status_access_mode != TPACPI_FAN_NONE ||
5764 fan_control_access_mode != TPACPI_FAN_WR_NONE) {
5765 rc = sysfs_create_group(&tpacpi_sensors_pdev->dev.kobj,
5766 &fan_attr_group);
5767 if (!(rc < 0))
5768 rc = driver_create_file(&tpacpi_hwmon_pdriver.driver,
5769 &driver_attr_fan_watchdog);
5770 if (rc < 0)
5771 return rc;
5772 return 0;
5773 } else
5774 return 1;
5775 }
5776
5777 static void fan_exit(void)
5778 {
5779 vdbg_printk(TPACPI_DBG_EXIT,
5780 "cancelling any pending fan watchdog tasks\n");
5781
5782 /* FIXME: can we really do this unconditionally? */
5783 sysfs_remove_group(&tpacpi_sensors_pdev->dev.kobj, &fan_attr_group);
5784 driver_remove_file(&tpacpi_hwmon_pdriver.driver,
5785 &driver_attr_fan_watchdog);
5786
5787 cancel_delayed_work(&fan_watchdog_task);
5788 flush_workqueue(tpacpi_wq);
5789 }
5790
5791 static int fan_read(char *p)
5792 {
5793 int len = 0;
5794 int rc;
5795 u8 status;
5796 unsigned int speed = 0;
5797
5798 switch (fan_status_access_mode) {
5799 case TPACPI_FAN_RD_ACPI_GFAN:
5800 /* 570, 600e/x, 770e, 770x */
5801 rc = fan_get_status_safe(&status);
5802 if (rc < 0)
5803 return rc;
5804
5805 len += sprintf(p + len, "status:\t\t%s\n"
5806 "level:\t\t%d\n",
5807 (status != 0) ? "enabled" : "disabled", status);
5808 break;
5809
5810 case TPACPI_FAN_RD_TPEC:
5811 /* all except 570, 600e/x, 770e, 770x */
5812 rc = fan_get_status_safe(&status);
5813 if (rc < 0)
5814 return rc;
5815
5816 if (unlikely(tp_features.fan_ctrl_status_undef)) {
5817 if (status != fan_control_initial_status)
5818 tp_features.fan_ctrl_status_undef = 0;
5819 else
5820 /* Return most likely status. In fact, it
5821 * might be the only possible status */
5822 status = TP_EC_FAN_AUTO;
5823 }
5824
5825 len += sprintf(p + len, "status:\t\t%s\n",
5826 (status != 0) ? "enabled" : "disabled");
5827
5828 rc = fan_get_speed(&speed);
5829 if (rc < 0)
5830 return rc;
5831
5832 len += sprintf(p + len, "speed:\t\t%d\n", speed);
5833
5834 if (status & TP_EC_FAN_FULLSPEED)
5835 /* Disengaged mode takes precedence */
5836 len += sprintf(p + len, "level:\t\tdisengaged\n");
5837 else if (status & TP_EC_FAN_AUTO)
5838 len += sprintf(p + len, "level:\t\tauto\n");
5839 else
5840 len += sprintf(p + len, "level:\t\t%d\n", status);
5841 break;
5842
5843 case TPACPI_FAN_NONE:
5844 default:
5845 len += sprintf(p + len, "status:\t\tnot supported\n");
5846 }
5847
5848 if (fan_control_commands & TPACPI_FAN_CMD_LEVEL) {
5849 len += sprintf(p + len, "commands:\tlevel <level>");
5850
5851 switch (fan_control_access_mode) {
5852 case TPACPI_FAN_WR_ACPI_SFAN:
5853 len += sprintf(p + len, " (<level> is 0-7)\n");
5854 break;
5855
5856 default:
5857 len += sprintf(p + len, " (<level> is 0-7, "
5858 "auto, disengaged, full-speed)\n");
5859 break;
5860 }
5861 }
5862
5863 if (fan_control_commands & TPACPI_FAN_CMD_ENABLE)
5864 len += sprintf(p + len, "commands:\tenable, disable\n"
5865 "commands:\twatchdog <timeout> (<timeout> "
5866 "is 0 (off), 1-120 (seconds))\n");
5867
5868 if (fan_control_commands & TPACPI_FAN_CMD_SPEED)
5869 len += sprintf(p + len, "commands:\tspeed <speed>"
5870 " (<speed> is 0-65535)\n");
5871
5872 return len;
5873 }
5874
5875 static int fan_write_cmd_level(const char *cmd, int *rc)
5876 {
5877 int level;
5878
5879 if (strlencmp(cmd, "level auto") == 0)
5880 level = TP_EC_FAN_AUTO;
5881 else if ((strlencmp(cmd, "level disengaged") == 0) |
5882 (strlencmp(cmd, "level full-speed") == 0))
5883 level = TP_EC_FAN_FULLSPEED;
5884 else if (sscanf(cmd, "level %d", &level) != 1)
5885 return 0;
5886
5887 *rc = fan_set_level_safe(level);
5888 if (*rc == -ENXIO)
5889 printk(TPACPI_ERR "level command accepted for unsupported "
5890 "access mode %d", fan_control_access_mode);
5891
5892 return 1;
5893 }
5894
5895 static int fan_write_cmd_enable(const char *cmd, int *rc)
5896 {
5897 if (strlencmp(cmd, "enable") != 0)
5898 return 0;
5899
5900 *rc = fan_set_enable();
5901 if (*rc == -ENXIO)
5902 printk(TPACPI_ERR "enable command accepted for unsupported "
5903 "access mode %d", fan_control_access_mode);
5904
5905 return 1;
5906 }
5907
5908 static int fan_write_cmd_disable(const char *cmd, int *rc)
5909 {
5910 if (strlencmp(cmd, "disable") != 0)
5911 return 0;
5912
5913 *rc = fan_set_disable();
5914 if (*rc == -ENXIO)
5915 printk(TPACPI_ERR "disable command accepted for unsupported "
5916 "access mode %d", fan_control_access_mode);
5917
5918 return 1;
5919 }
5920
5921 static int fan_write_cmd_speed(const char *cmd, int *rc)
5922 {
5923 int speed;
5924
5925 /* TODO:
5926 * Support speed <low> <medium> <high> ? */
5927
5928 if (sscanf(cmd, "speed %d", &speed) != 1)
5929 return 0;
5930
5931 *rc = fan_set_speed(speed);
5932 if (*rc == -ENXIO)
5933 printk(TPACPI_ERR "speed command accepted for unsupported "
5934 "access mode %d", fan_control_access_mode);
5935
5936 return 1;
5937 }
5938
5939 static int fan_write_cmd_watchdog(const char *cmd, int *rc)
5940 {
5941 int interval;
5942
5943 if (sscanf(cmd, "watchdog %d", &interval) != 1)
5944 return 0;
5945
5946 if (interval < 0 || interval > 120)
5947 *rc = -EINVAL;
5948 else
5949 fan_watchdog_maxinterval = interval;
5950
5951 return 1;
5952 }
5953
5954 static int fan_write(char *buf)
5955 {
5956 char *cmd;
5957 int rc = 0;
5958
5959 while (!rc && (cmd = next_cmd(&buf))) {
5960 if (!((fan_control_commands & TPACPI_FAN_CMD_LEVEL) &&
5961 fan_write_cmd_level(cmd, &rc)) &&
5962 !((fan_control_commands & TPACPI_FAN_CMD_ENABLE) &&
5963 (fan_write_cmd_enable(cmd, &rc) ||
5964 fan_write_cmd_disable(cmd, &rc) ||
5965 fan_write_cmd_watchdog(cmd, &rc))) &&
5966 !((fan_control_commands & TPACPI_FAN_CMD_SPEED) &&
5967 fan_write_cmd_speed(cmd, &rc))
5968 )
5969 rc = -EINVAL;
5970 else if (!rc)
5971 fan_watchdog_reset();
5972 }
5973
5974 return rc;
5975 }
5976
5977 static struct ibm_struct fan_driver_data = {
5978 .name = "fan",
5979 .read = fan_read,
5980 .write = fan_write,
5981 .exit = fan_exit,
5982 };
5983
5984 /****************************************************************************
5985 ****************************************************************************
5986 *
5987 * Infrastructure
5988 *
5989 ****************************************************************************
5990 ****************************************************************************/
5991
5992 /* sysfs name ---------------------------------------------------------- */
5993 static ssize_t thinkpad_acpi_pdev_name_show(struct device *dev,
5994 struct device_attribute *attr,
5995 char *buf)
5996 {
5997 return snprintf(buf, PAGE_SIZE, "%s\n", TPACPI_NAME);
5998 }
5999
6000 static struct device_attribute dev_attr_thinkpad_acpi_pdev_name =
6001 __ATTR(name, S_IRUGO, thinkpad_acpi_pdev_name_show, NULL);
6002
6003 /* --------------------------------------------------------------------- */
6004
6005 /* /proc support */
6006 static struct proc_dir_entry *proc_dir;
6007
6008 /*
6009 * Module and infrastructure proble, init and exit handling
6010 */
6011
6012 static int force_load;
6013
6014 #ifdef CONFIG_THINKPAD_ACPI_DEBUG
6015 static const char * __init str_supported(int is_supported)
6016 {
6017 static char text_unsupported[] __initdata = "not supported";
6018
6019 return (is_supported)? &text_unsupported[4] : &text_unsupported[0];
6020 }
6021 #endif /* CONFIG_THINKPAD_ACPI_DEBUG */
6022
6023 static void ibm_exit(struct ibm_struct *ibm)
6024 {
6025 dbg_printk(TPACPI_DBG_EXIT, "removing %s\n", ibm->name);
6026
6027 list_del_init(&ibm->all_drivers);
6028
6029 if (ibm->flags.acpi_notify_installed) {
6030 dbg_printk(TPACPI_DBG_EXIT,
6031 "%s: acpi_remove_notify_handler\n", ibm->name);
6032 BUG_ON(!ibm->acpi);
6033 acpi_remove_notify_handler(*ibm->acpi->handle,
6034 ibm->acpi->type,
6035 dispatch_acpi_notify);
6036 ibm->flags.acpi_notify_installed = 0;
6037 ibm->flags.acpi_notify_installed = 0;
6038 }
6039
6040 if (ibm->flags.proc_created) {
6041 dbg_printk(TPACPI_DBG_EXIT,
6042 "%s: remove_proc_entry\n", ibm->name);
6043 remove_proc_entry(ibm->name, proc_dir);
6044 ibm->flags.proc_created = 0;
6045 }
6046
6047 if (ibm->flags.acpi_driver_registered) {
6048 dbg_printk(TPACPI_DBG_EXIT,
6049 "%s: acpi_bus_unregister_driver\n", ibm->name);
6050 BUG_ON(!ibm->acpi);
6051 acpi_bus_unregister_driver(ibm->acpi->driver);
6052 kfree(ibm->acpi->driver);
6053 ibm->acpi->driver = NULL;
6054 ibm->flags.acpi_driver_registered = 0;
6055 }
6056
6057 if (ibm->flags.init_called && ibm->exit) {
6058 ibm->exit();
6059 ibm->flags.init_called = 0;
6060 }
6061
6062 dbg_printk(TPACPI_DBG_INIT, "finished removing %s\n", ibm->name);
6063 }
6064
6065 static int __init ibm_init(struct ibm_init_struct *iibm)
6066 {
6067 int ret;
6068 struct ibm_struct *ibm = iibm->data;
6069 struct proc_dir_entry *entry;
6070
6071 BUG_ON(ibm == NULL);
6072
6073 INIT_LIST_HEAD(&ibm->all_drivers);
6074
6075 if (ibm->flags.experimental && !experimental)
6076 return 0;
6077
6078 dbg_printk(TPACPI_DBG_INIT,
6079 "probing for %s\n", ibm->name);
6080
6081 if (iibm->init) {
6082 ret = iibm->init(iibm);
6083 if (ret > 0)
6084 return 0; /* probe failed */
6085 if (ret)
6086 return ret;
6087
6088 ibm->flags.init_called = 1;
6089 }
6090
6091 if (ibm->acpi) {
6092 if (ibm->acpi->hid) {
6093 ret = register_tpacpi_subdriver(ibm);
6094 if (ret)
6095 goto err_out;
6096 }
6097
6098 if (ibm->acpi->notify) {
6099 ret = setup_acpi_notify(ibm);
6100 if (ret == -ENODEV) {
6101 printk(TPACPI_NOTICE "disabling subdriver %s\n",
6102 ibm->name);
6103 ret = 0;
6104 goto err_out;
6105 }
6106 if (ret < 0)
6107 goto err_out;
6108 }
6109 }
6110
6111 dbg_printk(TPACPI_DBG_INIT,
6112 "%s installed\n", ibm->name);
6113
6114 if (ibm->read) {
6115 entry = create_proc_entry(ibm->name,
6116 S_IFREG | S_IRUGO | S_IWUSR,
6117 proc_dir);
6118 if (!entry) {
6119 printk(TPACPI_ERR "unable to create proc entry %s\n",
6120 ibm->name);
6121 ret = -ENODEV;
6122 goto err_out;
6123 }
6124 entry->owner = THIS_MODULE;
6125 entry->data = ibm;
6126 entry->read_proc = &dispatch_procfs_read;
6127 if (ibm->write)
6128 entry->write_proc = &dispatch_procfs_write;
6129 ibm->flags.proc_created = 1;
6130 }
6131
6132 list_add_tail(&ibm->all_drivers, &tpacpi_all_drivers);
6133
6134 return 0;
6135
6136 err_out:
6137 dbg_printk(TPACPI_DBG_INIT,
6138 "%s: at error exit path with result %d\n",
6139 ibm->name, ret);
6140
6141 ibm_exit(ibm);
6142 return (ret < 0)? ret : 0;
6143 }
6144
6145 /* Probing */
6146
6147 static void __init get_thinkpad_model_data(struct thinkpad_id_data *tp)
6148 {
6149 const struct dmi_device *dev = NULL;
6150 char ec_fw_string[18];
6151
6152 if (!tp)
6153 return;
6154
6155 memset(tp, 0, sizeof(*tp));
6156
6157 if (dmi_name_in_vendors("IBM"))
6158 tp->vendor = PCI_VENDOR_ID_IBM;
6159 else if (dmi_name_in_vendors("LENOVO"))
6160 tp->vendor = PCI_VENDOR_ID_LENOVO;
6161 else
6162 return;
6163
6164 tp->bios_version_str = kstrdup(dmi_get_system_info(DMI_BIOS_VERSION),
6165 GFP_KERNEL);
6166 if (!tp->bios_version_str)
6167 return;
6168 tp->bios_model = tp->bios_version_str[0]
6169 | (tp->bios_version_str[1] << 8);
6170
6171 /*
6172 * ThinkPad T23 or newer, A31 or newer, R50e or newer,
6173 * X32 or newer, all Z series; Some models must have an
6174 * up-to-date BIOS or they will not be detected.
6175 *
6176 * See http://thinkwiki.org/wiki/List_of_DMI_IDs
6177 */
6178 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, NULL, dev))) {
6179 if (sscanf(dev->name,
6180 "IBM ThinkPad Embedded Controller -[%17c",
6181 ec_fw_string) == 1) {
6182 ec_fw_string[sizeof(ec_fw_string) - 1] = 0;
6183 ec_fw_string[strcspn(ec_fw_string, " ]")] = 0;
6184
6185 tp->ec_version_str = kstrdup(ec_fw_string, GFP_KERNEL);
6186 tp->ec_model = ec_fw_string[0]
6187 | (ec_fw_string[1] << 8);
6188 break;
6189 }
6190 }
6191
6192 tp->model_str = kstrdup(dmi_get_system_info(DMI_PRODUCT_VERSION),
6193 GFP_KERNEL);
6194 if (tp->model_str && strnicmp(tp->model_str, "ThinkPad", 8) != 0) {
6195 kfree(tp->model_str);
6196 tp->model_str = NULL;
6197 }
6198
6199 tp->nummodel_str = kstrdup(dmi_get_system_info(DMI_PRODUCT_NAME),
6200 GFP_KERNEL);
6201 }
6202
6203 static int __init probe_for_thinkpad(void)
6204 {
6205 int is_thinkpad;
6206
6207 if (acpi_disabled)
6208 return -ENODEV;
6209
6210 /*
6211 * Non-ancient models have better DMI tagging, but very old models
6212 * don't.
6213 */
6214 is_thinkpad = (thinkpad_id.model_str != NULL);
6215
6216 /* ec is required because many other handles are relative to it */
6217 TPACPI_ACPIHANDLE_INIT(ec);
6218 if (!ec_handle) {
6219 if (is_thinkpad)
6220 printk(TPACPI_ERR
6221 "Not yet supported ThinkPad detected!\n");
6222 return -ENODEV;
6223 }
6224
6225 /*
6226 * Risks a regression on very old machines, but reduces potential
6227 * false positives a damn great deal
6228 */
6229 if (!is_thinkpad)
6230 is_thinkpad = (thinkpad_id.vendor == PCI_VENDOR_ID_IBM);
6231
6232 if (!is_thinkpad && !force_load)
6233 return -ENODEV;
6234
6235 return 0;
6236 }
6237
6238
6239 /* Module init, exit, parameters */
6240
6241 static struct ibm_init_struct ibms_init[] __initdata = {
6242 {
6243 .init = thinkpad_acpi_driver_init,
6244 .data = &thinkpad_acpi_driver_data,
6245 },
6246 {
6247 .init = hotkey_init,
6248 .data = &hotkey_driver_data,
6249 },
6250 {
6251 .init = bluetooth_init,
6252 .data = &bluetooth_driver_data,
6253 },
6254 {
6255 .init = wan_init,
6256 .data = &wan_driver_data,
6257 },
6258 #ifdef CONFIG_THINKPAD_ACPI_VIDEO
6259 {
6260 .init = video_init,
6261 .data = &video_driver_data,
6262 },
6263 #endif
6264 {
6265 .init = light_init,
6266 .data = &light_driver_data,
6267 },
6268 #ifdef CONFIG_THINKPAD_ACPI_DOCK
6269 {
6270 .init = dock_init,
6271 .data = &dock_driver_data[0],
6272 },
6273 {
6274 .init = dock_init2,
6275 .data = &dock_driver_data[1],
6276 },
6277 #endif
6278 #ifdef CONFIG_THINKPAD_ACPI_BAY
6279 {
6280 .init = bay_init,
6281 .data = &bay_driver_data,
6282 },
6283 #endif
6284 {
6285 .init = cmos_init,
6286 .data = &cmos_driver_data,
6287 },
6288 {
6289 .init = led_init,
6290 .data = &led_driver_data,
6291 },
6292 {
6293 .init = beep_init,
6294 .data = &beep_driver_data,
6295 },
6296 {
6297 .init = thermal_init,
6298 .data = &thermal_driver_data,
6299 },
6300 {
6301 .data = &ecdump_driver_data,
6302 },
6303 {
6304 .init = brightness_init,
6305 .data = &brightness_driver_data,
6306 },
6307 {
6308 .data = &volume_driver_data,
6309 },
6310 {
6311 .init = fan_init,
6312 .data = &fan_driver_data,
6313 },
6314 };
6315
6316 static int __init set_ibm_param(const char *val, struct kernel_param *kp)
6317 {
6318 unsigned int i;
6319 struct ibm_struct *ibm;
6320
6321 if (!kp || !kp->name || !val)
6322 return -EINVAL;
6323
6324 for (i = 0; i < ARRAY_SIZE(ibms_init); i++) {
6325 ibm = ibms_init[i].data;
6326 WARN_ON(ibm == NULL);
6327
6328 if (!ibm || !ibm->name)
6329 continue;
6330
6331 if (strcmp(ibm->name, kp->name) == 0 && ibm->write) {
6332 if (strlen(val) > sizeof(ibms_init[i].param) - 2)
6333 return -ENOSPC;
6334 strcpy(ibms_init[i].param, val);
6335 strcat(ibms_init[i].param, ",");
6336 return 0;
6337 }
6338 }
6339
6340 return -EINVAL;
6341 }
6342
6343 module_param(experimental, int, 0);
6344 MODULE_PARM_DESC(experimental,
6345 "Enables experimental features when non-zero");
6346
6347 module_param_named(debug, dbg_level, uint, 0);
6348 MODULE_PARM_DESC(debug, "Sets debug level bit-mask");
6349
6350 module_param(force_load, bool, 0);
6351 MODULE_PARM_DESC(force_load,
6352 "Attempts to load the driver even on a "
6353 "mis-identified ThinkPad when true");
6354
6355 module_param_named(fan_control, fan_control_allowed, bool, 0);
6356 MODULE_PARM_DESC(fan_control,
6357 "Enables setting fan parameters features when true");
6358
6359 module_param_named(brightness_mode, brightness_mode, int, 0);
6360 MODULE_PARM_DESC(brightness_mode,
6361 "Selects brightness control strategy: "
6362 "0=auto, 1=EC, 2=CMOS, 3=both");
6363
6364 module_param(brightness_enable, uint, 0);
6365 MODULE_PARM_DESC(brightness_enable,
6366 "Enables backlight control when 1, disables when 0");
6367
6368 module_param(hotkey_report_mode, uint, 0);
6369 MODULE_PARM_DESC(hotkey_report_mode,
6370 "used for backwards compatibility with userspace, "
6371 "see documentation");
6372
6373 #define TPACPI_PARAM(feature) \
6374 module_param_call(feature, set_ibm_param, NULL, NULL, 0); \
6375 MODULE_PARM_DESC(feature, "Simulates thinkpad-acpi procfs command " \
6376 "at module load, see documentation")
6377
6378 TPACPI_PARAM(hotkey);
6379 TPACPI_PARAM(bluetooth);
6380 TPACPI_PARAM(video);
6381 TPACPI_PARAM(light);
6382 #ifdef CONFIG_THINKPAD_ACPI_DOCK
6383 TPACPI_PARAM(dock);
6384 #endif
6385 #ifdef CONFIG_THINKPAD_ACPI_BAY
6386 TPACPI_PARAM(bay);
6387 #endif /* CONFIG_THINKPAD_ACPI_BAY */
6388 TPACPI_PARAM(cmos);
6389 TPACPI_PARAM(led);
6390 TPACPI_PARAM(beep);
6391 TPACPI_PARAM(ecdump);
6392 TPACPI_PARAM(brightness);
6393 TPACPI_PARAM(volume);
6394 TPACPI_PARAM(fan);
6395
6396 static void thinkpad_acpi_module_exit(void)
6397 {
6398 struct ibm_struct *ibm, *itmp;
6399
6400 tpacpi_lifecycle = TPACPI_LIFE_EXITING;
6401
6402 list_for_each_entry_safe_reverse(ibm, itmp,
6403 &tpacpi_all_drivers,
6404 all_drivers) {
6405 ibm_exit(ibm);
6406 }
6407
6408 dbg_printk(TPACPI_DBG_INIT, "finished subdriver exit path...\n");
6409
6410 if (tpacpi_inputdev) {
6411 if (tp_features.input_device_registered)
6412 input_unregister_device(tpacpi_inputdev);
6413 else
6414 input_free_device(tpacpi_inputdev);
6415 }
6416
6417 if (tpacpi_hwmon)
6418 hwmon_device_unregister(tpacpi_hwmon);
6419
6420 if (tp_features.sensors_pdev_attrs_registered)
6421 device_remove_file(&tpacpi_sensors_pdev->dev,
6422 &dev_attr_thinkpad_acpi_pdev_name);
6423 if (tpacpi_sensors_pdev)
6424 platform_device_unregister(tpacpi_sensors_pdev);
6425 if (tpacpi_pdev)
6426 platform_device_unregister(tpacpi_pdev);
6427
6428 if (tp_features.sensors_pdrv_attrs_registered)
6429 tpacpi_remove_driver_attributes(&tpacpi_hwmon_pdriver.driver);
6430 if (tp_features.platform_drv_attrs_registered)
6431 tpacpi_remove_driver_attributes(&tpacpi_pdriver.driver);
6432
6433 if (tp_features.sensors_pdrv_registered)
6434 platform_driver_unregister(&tpacpi_hwmon_pdriver);
6435
6436 if (tp_features.platform_drv_registered)
6437 platform_driver_unregister(&tpacpi_pdriver);
6438
6439 if (proc_dir)
6440 remove_proc_entry(TPACPI_PROC_DIR, acpi_root_dir);
6441
6442 if (tpacpi_wq)
6443 destroy_workqueue(tpacpi_wq);
6444
6445 kfree(thinkpad_id.bios_version_str);
6446 kfree(thinkpad_id.ec_version_str);
6447 kfree(thinkpad_id.model_str);
6448 }
6449
6450
6451 static int __init thinkpad_acpi_module_init(void)
6452 {
6453 int ret, i;
6454
6455 tpacpi_lifecycle = TPACPI_LIFE_INIT;
6456
6457 /* Parameter checking */
6458 if (hotkey_report_mode > 2)
6459 return -EINVAL;
6460
6461 /* Driver-level probe */
6462
6463 get_thinkpad_model_data(&thinkpad_id);
6464 ret = probe_for_thinkpad();
6465 if (ret) {
6466 thinkpad_acpi_module_exit();
6467 return ret;
6468 }
6469
6470 /* Driver initialization */
6471
6472 TPACPI_ACPIHANDLE_INIT(ecrd);
6473 TPACPI_ACPIHANDLE_INIT(ecwr);
6474
6475 tpacpi_wq = create_singlethread_workqueue(TPACPI_WORKQUEUE_NAME);
6476 if (!tpacpi_wq) {
6477 thinkpad_acpi_module_exit();
6478 return -ENOMEM;
6479 }
6480
6481 proc_dir = proc_mkdir(TPACPI_PROC_DIR, acpi_root_dir);
6482 if (!proc_dir) {
6483 printk(TPACPI_ERR
6484 "unable to create proc dir " TPACPI_PROC_DIR);
6485 thinkpad_acpi_module_exit();
6486 return -ENODEV;
6487 }
6488 proc_dir->owner = THIS_MODULE;
6489
6490 ret = platform_driver_register(&tpacpi_pdriver);
6491 if (ret) {
6492 printk(TPACPI_ERR
6493 "unable to register main platform driver\n");
6494 thinkpad_acpi_module_exit();
6495 return ret;
6496 }
6497 tp_features.platform_drv_registered = 1;
6498
6499 ret = platform_driver_register(&tpacpi_hwmon_pdriver);
6500 if (ret) {
6501 printk(TPACPI_ERR
6502 "unable to register hwmon platform driver\n");
6503 thinkpad_acpi_module_exit();
6504 return ret;
6505 }
6506 tp_features.sensors_pdrv_registered = 1;
6507
6508 ret = tpacpi_create_driver_attributes(&tpacpi_pdriver.driver);
6509 if (!ret) {
6510 tp_features.platform_drv_attrs_registered = 1;
6511 ret = tpacpi_create_driver_attributes(
6512 &tpacpi_hwmon_pdriver.driver);
6513 }
6514 if (ret) {
6515 printk(TPACPI_ERR
6516 "unable to create sysfs driver attributes\n");
6517 thinkpad_acpi_module_exit();
6518 return ret;
6519 }
6520 tp_features.sensors_pdrv_attrs_registered = 1;
6521
6522
6523 /* Device initialization */
6524 tpacpi_pdev = platform_device_register_simple(TPACPI_DRVR_NAME, -1,
6525 NULL, 0);
6526 if (IS_ERR(tpacpi_pdev)) {
6527 ret = PTR_ERR(tpacpi_pdev);
6528 tpacpi_pdev = NULL;
6529 printk(TPACPI_ERR "unable to register platform device\n");
6530 thinkpad_acpi_module_exit();
6531 return ret;
6532 }
6533 tpacpi_sensors_pdev = platform_device_register_simple(
6534 TPACPI_HWMON_DRVR_NAME,
6535 -1, NULL, 0);
6536 if (IS_ERR(tpacpi_sensors_pdev)) {
6537 ret = PTR_ERR(tpacpi_sensors_pdev);
6538 tpacpi_sensors_pdev = NULL;
6539 printk(TPACPI_ERR
6540 "unable to register hwmon platform device\n");
6541 thinkpad_acpi_module_exit();
6542 return ret;
6543 }
6544 ret = device_create_file(&tpacpi_sensors_pdev->dev,
6545 &dev_attr_thinkpad_acpi_pdev_name);
6546 if (ret) {
6547 printk(TPACPI_ERR
6548 "unable to create sysfs hwmon device attributes\n");
6549 thinkpad_acpi_module_exit();
6550 return ret;
6551 }
6552 tp_features.sensors_pdev_attrs_registered = 1;
6553 tpacpi_hwmon = hwmon_device_register(&tpacpi_sensors_pdev->dev);
6554 if (IS_ERR(tpacpi_hwmon)) {
6555 ret = PTR_ERR(tpacpi_hwmon);
6556 tpacpi_hwmon = NULL;
6557 printk(TPACPI_ERR "unable to register hwmon device\n");
6558 thinkpad_acpi_module_exit();
6559 return ret;
6560 }
6561 mutex_init(&tpacpi_inputdev_send_mutex);
6562 tpacpi_inputdev = input_allocate_device();
6563 if (!tpacpi_inputdev) {
6564 printk(TPACPI_ERR "unable to allocate input device\n");
6565 thinkpad_acpi_module_exit();
6566 return -ENOMEM;
6567 } else {
6568 /* Prepare input device, but don't register */
6569 tpacpi_inputdev->name = "ThinkPad Extra Buttons";
6570 tpacpi_inputdev->phys = TPACPI_DRVR_NAME "/input0";
6571 tpacpi_inputdev->id.bustype = BUS_HOST;
6572 tpacpi_inputdev->id.vendor = (thinkpad_id.vendor) ?
6573 thinkpad_id.vendor :
6574 PCI_VENDOR_ID_IBM;
6575 tpacpi_inputdev->id.product = TPACPI_HKEY_INPUT_PRODUCT;
6576 tpacpi_inputdev->id.version = TPACPI_HKEY_INPUT_VERSION;
6577 }
6578 for (i = 0; i < ARRAY_SIZE(ibms_init); i++) {
6579 ret = ibm_init(&ibms_init[i]);
6580 if (ret >= 0 && *ibms_init[i].param)
6581 ret = ibms_init[i].data->write(ibms_init[i].param);
6582 if (ret < 0) {
6583 thinkpad_acpi_module_exit();
6584 return ret;
6585 }
6586 }
6587 ret = input_register_device(tpacpi_inputdev);
6588 if (ret < 0) {
6589 printk(TPACPI_ERR "unable to register input device\n");
6590 thinkpad_acpi_module_exit();
6591 return ret;
6592 } else {
6593 tp_features.input_device_registered = 1;
6594 }
6595
6596 tpacpi_lifecycle = TPACPI_LIFE_RUNNING;
6597 return 0;
6598 }
6599
6600 /* Please remove this in year 2009 */
6601 MODULE_ALIAS("ibm_acpi");
6602
6603 MODULE_ALIAS(TPACPI_DRVR_SHORTNAME);
6604
6605 /*
6606 * DMI matching for module autoloading
6607 *
6608 * See http://thinkwiki.org/wiki/List_of_DMI_IDs
6609 * See http://thinkwiki.org/wiki/BIOS_Upgrade_Downloads
6610 *
6611 * Only models listed in thinkwiki will be supported, so add yours
6612 * if it is not there yet.
6613 */
6614 #define IBM_BIOS_MODULE_ALIAS(__type) \
6615 MODULE_ALIAS("dmi:bvnIBM:bvr" __type "ET??WW")
6616
6617 /* Non-ancient thinkpads */
6618 MODULE_ALIAS("dmi:bvnIBM:*:svnIBM:*:pvrThinkPad*:rvnIBM:*");
6619 MODULE_ALIAS("dmi:bvnLENOVO:*:svnLENOVO:*:pvrThinkPad*:rvnLENOVO:*");
6620
6621 /* Ancient thinkpad BIOSes have to be identified by
6622 * BIOS type or model number, and there are far less
6623 * BIOS types than model numbers... */
6624 IBM_BIOS_MODULE_ALIAS("I[B,D,H,I,M,N,O,T,W,V,Y,Z]");
6625 IBM_BIOS_MODULE_ALIAS("1[0,3,6,8,A-G,I,K,M-P,S,T]");
6626 IBM_BIOS_MODULE_ALIAS("K[U,X-Z]");
6627
6628 MODULE_AUTHOR("Borislav Deianov, Henrique de Moraes Holschuh");
6629 MODULE_DESCRIPTION(TPACPI_DESC);
6630 MODULE_VERSION(TPACPI_VERSION);
6631 MODULE_LICENSE("GPL");
6632
6633 module_init(thinkpad_acpi_module_init);
6634 module_exit(thinkpad_acpi_module_exit);
Community contributions to the Openmoko Kernel