SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/misc/thinkpad_acpi.c

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