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