linux/drivers/misc/thinkpad_acpi.c
<<
>>
Prefs
   1/*
   2 *  thinkpad_acpi.c - ThinkPad ACPI Extras
   3 *
   4 *
   5 *  Copyright (C) 2004-2005 Borislav Deianov <borislav@users.sf.net>
   6 *  Copyright (C) 2006-2008 Henrique de Moraes Holschuh <hmh@hmh.eng.br>
   7 *
   8 *  This program is free software; you can redistribute it and/or modify
   9 *  it under the terms of the GNU General Public License as published by
  10 *  the Free Software Foundation; either version 2 of the License, or
  11 *  (at your option) any later version.
  12 *
  13 *  This program is distributed in the hope that it will be useful,
  14 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 *  GNU General Public License for more details.
  17 *
  18 *  You should have received a copy of the GNU General Public License
  19 *  along with this program; if not, write to the Free Software
  20 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21 *  02110-1301, USA.
  22 */
  23
  24#define TPACPI_VERSION "0.21"
  25#define TPACPI_SYSFS_VERSION 0x020200
  26
  27/*
  28 *  Changelog:
  29 *  2007-10-20          changelog trimmed down
  30 *
  31 *  2007-03-27  0.14    renamed to thinkpad_acpi and moved to
  32 *                      drivers/misc.
  33 *
  34 *  2006-11-22  0.13    new maintainer
  35 *                      changelog now lives in git commit history, and will
  36 *                      not be updated further in-file.
  37 *
  38 *  2005-03-17  0.11    support for 600e, 770x
  39 *                          thanks to Jamie Lentin <lentinj@dial.pipex.com>
  40 *
  41 *  2005-01-16  0.9     use MODULE_VERSION
  42 *                          thanks to Henrik Brix Andersen <brix@gentoo.org>
  43 *                      fix parameter passing on module loading
  44 *                          thanks to Rusty Russell <rusty@rustcorp.com.au>
  45 *                          thanks to Jim Radford <radford@blackbean.org>
  46 *  2004-11-08  0.8     fix init error case, don't return from a macro
  47 *                          thanks to Chris Wright <chrisw@osdl.org>
  48 */
  49
  50#include <linux/kernel.h>
  51#include <linux/module.h>
  52#include <linux/init.h>
  53#include <linux/types.h>
  54#include <linux/string.h>
  55#include <linux/list.h>
  56#include <linux/mutex.h>
  57#include <linux/kthread.h>
  58#include <linux/freezer.h>
  59#include <linux/delay.h>
  60
  61#include <linux/nvram.h>
  62#include <linux/proc_fs.h>
  63#include <linux/sysfs.h>
  64#include <linux/backlight.h>
  65#include <linux/fb.h>
  66#include <linux/platform_device.h>
  67#include <linux/hwmon.h>
  68#include <linux/hwmon-sysfs.h>
  69#include <linux/input.h>
  70#include <linux/leds.h>
  71#include <linux/rfkill.h>
  72#include <asm/uaccess.h>
  73
  74#include <linux/dmi.h>
  75#include <linux/jiffies.h>
  76#include <linux/workqueue.h>
  77
  78#include <acpi/acpi_drivers.h>
  79#include <acpi/acnamesp.h>
  80
  81#include <linux/pci_ids.h>
  82
  83
  84/* ThinkPad CMOS commands */
  85#define TP_CMOS_VOLUME_DOWN     0
  86#define TP_CMOS_VOLUME_UP       1
  87#define TP_CMOS_VOLUME_MUTE     2
  88#define TP_CMOS_BRIGHTNESS_UP   4
  89#define TP_CMOS_BRIGHTNESS_DOWN 5
  90#define TP_CMOS_THINKLIGHT_ON   12
  91#define TP_CMOS_THINKLIGHT_OFF  13
  92
  93/* NVRAM Addresses */
  94enum tp_nvram_addr {
  95        TP_NVRAM_ADDR_HK2               = 0x57,
  96        TP_NVRAM_ADDR_THINKLIGHT        = 0x58,
  97        TP_NVRAM_ADDR_VIDEO             = 0x59,
  98        TP_NVRAM_ADDR_BRIGHTNESS        = 0x5e,
  99        TP_NVRAM_ADDR_MIXER             = 0x60,
 100};
 101
 102/* NVRAM bit masks */
 103enum {
 104        TP_NVRAM_MASK_HKT_THINKPAD      = 0x08,
 105        TP_NVRAM_MASK_HKT_ZOOM          = 0x20,
 106        TP_NVRAM_MASK_HKT_DISPLAY       = 0x40,
 107        TP_NVRAM_MASK_HKT_HIBERNATE     = 0x80,
 108        TP_NVRAM_MASK_THINKLIGHT        = 0x10,
 109        TP_NVRAM_MASK_HKT_DISPEXPND     = 0x30,
 110        TP_NVRAM_MASK_HKT_BRIGHTNESS    = 0x20,
 111        TP_NVRAM_MASK_LEVEL_BRIGHTNESS  = 0x0f,
 112        TP_NVRAM_POS_LEVEL_BRIGHTNESS   = 0,
 113        TP_NVRAM_MASK_MUTE              = 0x40,
 114        TP_NVRAM_MASK_HKT_VOLUME        = 0x80,
 115        TP_NVRAM_MASK_LEVEL_VOLUME      = 0x0f,
 116        TP_NVRAM_POS_LEVEL_VOLUME       = 0,
 117};
 118
 119/* ACPI HIDs */
 120#define TPACPI_ACPI_HKEY_HID            "IBM0068"
 121
 122/* Input IDs */
 123#define TPACPI_HKEY_INPUT_PRODUCT       0x5054 /* "TP" */
 124#define TPACPI_HKEY_INPUT_VERSION       0x4101
 125
 126
 127/****************************************************************************
 128 * Main driver
 129 */
 130
 131#define TPACPI_NAME "thinkpad"
 132#define TPACPI_DESC "ThinkPad ACPI Extras"
 133#define TPACPI_FILE TPACPI_NAME "_acpi"
 134#define TPACPI_URL "http://ibm-acpi.sf.net/"
 135#define TPACPI_MAIL "ibm-acpi-devel@lists.sourceforge.net"
 136
 137#define TPACPI_PROC_DIR "ibm"
 138#define TPACPI_ACPI_EVENT_PREFIX "ibm"
 139#define TPACPI_DRVR_NAME TPACPI_FILE
 140#define TPACPI_DRVR_SHORTNAME "tpacpi"
 141#define TPACPI_HWMON_DRVR_NAME TPACPI_NAME "_hwmon"
 142
 143#define TPACPI_NVRAM_KTHREAD_NAME "ktpacpi_nvramd"
 144#define TPACPI_WORKQUEUE_NAME "ktpacpid"
 145
 146#define TPACPI_MAX_ACPI_ARGS 3
 147
 148/* rfkill switches */
 149enum {
 150        TPACPI_RFK_BLUETOOTH_SW_ID = 0,
 151        TPACPI_RFK_WWAN_SW_ID,
 152};
 153
 154/* Debugging */
 155#define TPACPI_LOG TPACPI_FILE ": "
 156#define TPACPI_ERR         KERN_ERR    TPACPI_LOG
 157#define TPACPI_NOTICE KERN_NOTICE TPACPI_LOG
 158#define TPACPI_INFO   KERN_INFO   TPACPI_LOG
 159#define TPACPI_DEBUG  KERN_DEBUG  TPACPI_LOG
 160
 161#define TPACPI_DBG_ALL          0xffff
 162#define TPACPI_DBG_INIT         0x0001
 163#define TPACPI_DBG_EXIT         0x0002
 164#define dbg_printk(a_dbg_level, format, arg...) \
 165        do { if (dbg_level & a_dbg_level) \
 166                printk(TPACPI_DEBUG "%s: " format, __func__ , ## arg); \
 167        } while (0)
 168#ifdef CONFIG_THINKPAD_ACPI_DEBUG
 169#define vdbg_printk(a_dbg_level, format, arg...) \
 170        dbg_printk(a_dbg_level, format, ## arg)
 171static const char *str_supported(int is_supported);
 172#else
 173#define vdbg_printk(a_dbg_level, format, arg...)
 174#endif
 175
 176#define onoff(status, bit) ((status) & (1 << (bit)) ? "on" : "off")
 177#define enabled(status, bit) ((status) & (1 << (bit)) ? "enabled" : "disabled")
 178#define strlencmp(a, b) (strncmp((a), (b), strlen(b)))
 179
 180
 181/****************************************************************************
 182 * Driver-wide structs and misc. variables
 183 */
 184
 185struct ibm_struct;
 186
 187struct tp_acpi_drv_struct {
 188        const struct acpi_device_id *hid;
 189        struct acpi_driver *driver;
 190
 191        void (*notify) (struct ibm_struct *, u32);
 192        acpi_handle *handle;
 193        u32 type;
 194        struct acpi_device *device;
 195};
 196
 197struct ibm_struct {
 198        char *name;
 199
 200        int (*read) (char *);
 201        int (*write) (char *);
 202        void (*exit) (void);
 203        void (*resume) (void);
 204        void (*suspend) (pm_message_t state);
 205
 206        struct list_head all_drivers;
 207
 208        struct tp_acpi_drv_struct *acpi;
 209
 210        struct {
 211                u8 acpi_driver_registered:1;
 212                u8 acpi_notify_installed:1;
 213                u8 proc_created:1;
 214                u8 init_called:1;
 215                u8 experimental:1;
 216        } flags;
 217};
 218
 219struct ibm_init_struct {
 220        char param[32];
 221
 222        int (*init) (struct ibm_init_struct *);
 223        struct ibm_struct *data;
 224};
 225
 226static struct {
 227#ifdef CONFIG_THINKPAD_ACPI_BAY
 228        u32 bay_status:1;
 229        u32 bay_eject:1;
 230        u32 bay_status2:1;
 231        u32 bay_eject2:1;
 232#endif
 233        u32 bluetooth:1;
 234        u32 hotkey:1;
 235        u32 hotkey_mask:1;
 236        u32 hotkey_wlsw:1;
 237        u32 hotkey_tablet:1;
 238        u32 light:1;
 239        u32 light_status:1;
 240        u32 bright_16levels:1;
 241        u32 bright_acpimode:1;
 242        u32 wan:1;
 243        u32 fan_ctrl_status_undef:1;
 244        u32 input_device_registered:1;
 245        u32 platform_drv_registered:1;
 246        u32 platform_drv_attrs_registered:1;
 247        u32 sensors_pdrv_registered:1;
 248        u32 sensors_pdrv_attrs_registered:1;
 249        u32 sensors_pdev_attrs_registered:1;
 250        u32 hotkey_poll_active:1;
 251} tp_features;
 252
 253static struct {
 254        u16 hotkey_mask_ff:1;
 255        u16 bright_cmos_ec_unsync:1;
 256} tp_warned;
 257
 258struct thinkpad_id_data {
 259        unsigned int vendor;    /* ThinkPad vendor:
 260                                 * PCI_VENDOR_ID_IBM/PCI_VENDOR_ID_LENOVO */
 261
 262        char *bios_version_str; /* Something like 1ZET51WW (1.03z) */
 263        char *ec_version_str;   /* Something like 1ZHT51WW-1.04a */
 264
 265        u16 bios_model;         /* Big Endian, TP-1Y = 0x5931, 0 = unknown */
 266        u16 ec_model;
 267
 268        char *model_str;        /* ThinkPad T43 */
 269        char *nummodel_str;     /* 9384A9C for a 9384-A9C model */
 270};
 271static struct thinkpad_id_data thinkpad_id;
 272
 273static enum {
 274        TPACPI_LIFE_INIT = 0,
 275        TPACPI_LIFE_RUNNING,
 276        TPACPI_LIFE_EXITING,
 277} tpacpi_lifecycle;
 278
 279static int experimental;
 280static u32 dbg_level;
 281
 282static struct workqueue_struct *tpacpi_wq;
 283
 284/* Special LED class that can defer work */
 285struct tpacpi_led_classdev {
 286        struct led_classdev led_classdev;
 287        struct work_struct work;
 288        enum led_brightness new_brightness;
 289        unsigned int led;
 290};
 291
 292/****************************************************************************
 293 ****************************************************************************
 294 *
 295 * ACPI Helpers and device model
 296 *
 297 ****************************************************************************
 298 ****************************************************************************/
 299
 300/*************************************************************************
 301 * ACPI basic handles
 302 */
 303
 304static acpi_handle root_handle;
 305
 306#define TPACPI_HANDLE(object, parent, paths...)                 \
 307        static acpi_handle  object##_handle;                    \
 308        static acpi_handle *object##_parent = &parent##_handle; \
 309        static char        *object##_path;                      \
 310        static char        *object##_paths[] = { paths }
 311
 312TPACPI_HANDLE(ec, root, "\\_SB.PCI0.ISA.EC0",   /* 240, 240x */
 313           "\\_SB.PCI.ISA.EC",  /* 570 */
 314           "\\_SB.PCI0.ISA0.EC0",       /* 600e/x, 770e, 770x */
 315           "\\_SB.PCI0.ISA.EC", /* A21e, A2xm/p, T20-22, X20-21 */
 316           "\\_SB.PCI0.AD4S.EC0",       /* i1400, R30 */
 317           "\\_SB.PCI0.ICH3.EC0",       /* R31 */
 318           "\\_SB.PCI0.LPC.EC", /* all others */
 319           );
 320
 321TPACPI_HANDLE(ecrd, ec, "ECRD");        /* 570 */
 322TPACPI_HANDLE(ecwr, ec, "ECWR");        /* 570 */
 323
 324TPACPI_HANDLE(cmos, root, "\\UCMS",     /* R50, R50e, R50p, R51, */
 325                                        /* T4x, X31, X40 */
 326           "\\CMOS",            /* A3x, G4x, R32, T23, T30, X22-24, X30 */
 327           "\\CMS",             /* R40, R40e */
 328           );                   /* all others */
 329
 330TPACPI_HANDLE(hkey, ec, "\\_SB.HKEY",   /* 600e/x, 770e, 770x */
 331           "^HKEY",             /* R30, R31 */
 332           "HKEY",              /* all others */
 333           );                   /* 570 */
 334
 335TPACPI_HANDLE(vid, root, "\\_SB.PCI.AGP.VGA",   /* 570 */
 336           "\\_SB.PCI0.AGP0.VID0",      /* 600e/x, 770x */
 337           "\\_SB.PCI0.VID0",   /* 770e */
 338           "\\_SB.PCI0.VID",    /* A21e, G4x, R50e, X30, X40 */
 339           "\\_SB.PCI0.AGP.VID",        /* all others */
 340           );                           /* R30, R31 */
 341
 342
 343/*************************************************************************
 344 * ACPI helpers
 345 */
 346
 347static int acpi_evalf(acpi_handle handle,
 348                      void *res, char *method, char *fmt, ...)
 349{
 350        char *fmt0 = fmt;
 351        struct acpi_object_list params;
 352        union acpi_object in_objs[TPACPI_MAX_ACPI_ARGS];
 353        struct acpi_buffer result, *resultp;
 354        union acpi_object out_obj;
 355        acpi_status status;
 356        va_list ap;
 357        char res_type;
 358        int success;
 359        int quiet;
 360
 361        if (!*fmt) {
 362                printk(TPACPI_ERR "acpi_evalf() called with empty format\n");
 363                return 0;
 364        }
 365
 366        if (*fmt == 'q') {
 367                quiet = 1;
 368                fmt++;
 369        } else
 370                quiet = 0;
 371
 372        res_type = *(fmt++);
 373
 374        params.count = 0;
 375        params.pointer = &in_objs[0];
 376
 377        va_start(ap, fmt);
 378        while (*fmt) {
 379                char c = *(fmt++);
 380                switch (c) {
 381                case 'd':       /* int */
 382                        in_objs[params.count].integer.value = va_arg(ap, int);
 383                        in_objs[params.count++].type = ACPI_TYPE_INTEGER;
 384                        break;
 385                        /* add more types as needed */
 386                default:
 387                        printk(TPACPI_ERR "acpi_evalf() called "
 388                               "with invalid format character '%c'\n", c);
 389                        return 0;
 390                }
 391        }
 392        va_end(ap);
 393
 394        if (res_type != 'v') {
 395                result.length = sizeof(out_obj);
 396                result.pointer = &out_obj;
 397                resultp = &result;
 398        } else
 399                resultp = NULL;
 400
 401        status = acpi_evaluate_object(handle, method, &params, resultp);
 402
 403        switch (res_type) {
 404        case 'd':               /* int */
 405                if (res)
 406                        *(int *)res = out_obj.integer.value;
 407                success = status == AE_OK && out_obj.type == ACPI_TYPE_INTEGER;
 408                break;
 409        case 'v':               /* void */
 410                success = status == AE_OK;
 411                break;
 412                /* add more types as needed */
 413        default:
 414                printk(TPACPI_ERR "acpi_evalf() called "
 415                       "with invalid format character '%c'\n", res_type);
 416                return 0;
 417        }
 418
 419        if (!success && !quiet)
 420                printk(TPACPI_ERR "acpi_evalf(%s, %s, ...) failed: %d\n",
 421                       method, fmt0, status);
 422
 423        return success;
 424}
 425
 426static int acpi_ec_read(int i, u8 *p)
 427{
 428        int v;
 429
 430        if (ecrd_handle) {
 431                if (!acpi_evalf(ecrd_handle, &v, NULL, "dd", i))
 432                        return 0;
 433                *p = v;
 434        } else {
 435                if (ec_read(i, p) < 0)
 436                        return 0;
 437        }
 438
 439        return 1;
 440}
 441
 442static int acpi_ec_write(int i, u8 v)
 443{
 444        if (ecwr_handle) {
 445                if (!acpi_evalf(ecwr_handle, NULL, NULL, "vdd", i, v))
 446                        return 0;
 447        } else {
 448                if (ec_write(i, v) < 0)
 449                        return 0;
 450        }
 451
 452        return 1;
 453}
 454
 455#if defined(CONFIG_THINKPAD_ACPI_DOCK) || defined(CONFIG_THINKPAD_ACPI_BAY)
 456static int _sta(acpi_handle handle)
 457{
 458        int status;
 459
 460        if (!handle || !acpi_evalf(handle, &status, "_STA", "d"))
 461                status = 0;
 462
 463        return status;
 464}
 465#endif
 466
 467static int issue_thinkpad_cmos_command(int cmos_cmd)
 468{
 469        if (!cmos_handle)
 470                return -ENXIO;
 471
 472        if (!acpi_evalf(cmos_handle, NULL, NULL, "vd", cmos_cmd))
 473                return -EIO;
 474
 475        return 0;
 476}
 477
 478/*************************************************************************
 479 * ACPI device model
 480 */
 481
 482#define TPACPI_ACPIHANDLE_INIT(object) \
 483        drv_acpi_handle_init(#object, &object##_handle, *object##_parent, \
 484                object##_paths, ARRAY_SIZE(object##_paths), &object##_path)
 485
 486static void drv_acpi_handle_init(char *name,
 487                           acpi_handle *handle, acpi_handle parent,
 488                           char **paths, int num_paths, char **path)
 489{
 490        int i;
 491        acpi_status status;
 492
 493        vdbg_printk(TPACPI_DBG_INIT, "trying to locate ACPI handle for %s\n",
 494                name);
 495
 496        for (i = 0; i < num_paths; i++) {
 497                status = acpi_get_handle(parent, paths[i], handle);
 498                if (ACPI_SUCCESS(status)) {
 499                        *path = paths[i];
 500                        dbg_printk(TPACPI_DBG_INIT,
 501                                   "Found ACPI handle %s for %s\n",
 502                                   *path, name);
 503                        return;
 504                }
 505        }
 506
 507        vdbg_printk(TPACPI_DBG_INIT, "ACPI handle for %s not found\n",
 508                    name);
 509        *handle = NULL;
 510}
 511
 512static void dispatch_acpi_notify(acpi_handle handle, u32 event, void *data)
 513{
 514        struct ibm_struct *ibm = data;
 515
 516        if (tpacpi_lifecycle != TPACPI_LIFE_RUNNING)
 517                return;
 518
 519        if (!ibm || !ibm->acpi || !ibm->acpi->notify)
 520                return;
 521
 522        ibm->acpi->notify(ibm, event);
 523}
 524
 525static int __init setup_acpi_notify(struct ibm_struct *ibm)
 526{
 527        acpi_status status;
 528        int rc;
 529
 530        BUG_ON(!ibm->acpi);
 531
 532        if (!*ibm->acpi->handle)
 533                return 0;
 534
 535        vdbg_printk(TPACPI_DBG_INIT,
 536                "setting up ACPI notify for %s\n", ibm->name);
 537
 538        rc = acpi_bus_get_device(*ibm->acpi->handle, &ibm->acpi->device);
 539        if (rc < 0) {
 540                printk(TPACPI_ERR "acpi_bus_get_device(%s) failed: %d\n",
 541                        ibm->name, rc);
 542                return -ENODEV;
 543        }
 544
 545        ibm->acpi->device->driver_data = ibm;
 546        sprintf(acpi_device_class(ibm->acpi->device), "%s/%s",
 547                TPACPI_ACPI_EVENT_PREFIX,
 548                ibm->name);
 549
 550        status = acpi_install_notify_handler(*ibm->acpi->handle,
 551                        ibm->acpi->type, dispatch_acpi_notify, ibm);
 552        if (ACPI_FAILURE(status)) {
 553                if (status == AE_ALREADY_EXISTS) {
 554                        printk(TPACPI_NOTICE
 555                               "another device driver is already "
 556                               "handling %s events\n", ibm->name);
 557                } else {
 558                        printk(TPACPI_ERR
 559                               "acpi_install_notify_handler(%s) failed: %d\n",
 560                               ibm->name, status);
 561                }
 562                return -ENODEV;
 563        }
 564        ibm->flags.acpi_notify_installed = 1;
 565        return 0;
 566}
 567
 568static int __init tpacpi_device_add(struct acpi_device *device)
 569{
 570        return 0;
 571}
 572
 573static int __init register_tpacpi_subdriver(struct ibm_struct *ibm)
 574{
 575        int rc;
 576
 577        dbg_printk(TPACPI_DBG_INIT,
 578                "registering %s as an ACPI driver\n", ibm->name);
 579
 580        BUG_ON(!ibm->acpi);
 581
 582        ibm->acpi->driver = kzalloc(sizeof(struct acpi_driver), GFP_KERNEL);
 583        if (!ibm->acpi->driver) {
 584                printk(TPACPI_ERR
 585                       "failed to allocate memory for ibm->acpi->driver\n");
 586                return -ENOMEM;
 587        }
 588
 589        sprintf(ibm->acpi->driver->name, "%s_%s", TPACPI_NAME, ibm->name);
 590        ibm->acpi->driver->ids = ibm->acpi->hid;
 591
 592        ibm->acpi->driver->ops.add = &tpacpi_device_add;
 593
 594        rc = acpi_bus_register_driver(ibm->acpi->driver);
 595        if (rc < 0) {
 596                printk(TPACPI_ERR "acpi_bus_register_driver(%s) failed: %d\n",
 597                       ibm->name, rc);
 598                kfree(ibm->acpi->driver);
 599                ibm->acpi->driver = NULL;
 600        } else if (!rc)
 601                ibm->flags.acpi_driver_registered = 1;
 602
 603        return rc;
 604}
 605
 606
 607/****************************************************************************
 608 ****************************************************************************
 609 *
 610 * Procfs Helpers
 611 *
 612 ****************************************************************************
 613 ****************************************************************************/
 614
 615static int dispatch_procfs_read(char *page, char **start, off_t off,
 616                        int count, int *eof, void *data)
 617{
 618        struct ibm_struct *ibm = data;
 619        int len;
 620
 621        if (!ibm || !ibm->read)
 622                return -EINVAL;
 623
 624        len = ibm->read(page);
 625        if (len < 0)
 626                return len;
 627
 628        if (len <= off + count)
 629                *eof = 1;
 630        *start = page + off;
 631        len -= off;
 632        if (len > count)
 633                len = count;
 634        if (len < 0)
 635                len = 0;
 636
 637        return len;
 638}
 639
 640static int dispatch_procfs_write(struct file *file,
 641                        const char __user *userbuf,
 642                        unsigned long count, void *data)
 643{
 644        struct ibm_struct *ibm = data;
 645        char *kernbuf;
 646        int ret;
 647
 648        if (!ibm || !ibm->write)
 649                return -EINVAL;
 650
 651        kernbuf = kmalloc(count + 2, GFP_KERNEL);
 652        if (!kernbuf)
 653                return -ENOMEM;
 654
 655        if (copy_from_user(kernbuf, userbuf, count)) {
 656                kfree(kernbuf);
 657                return -EFAULT;
 658        }
 659
 660        kernbuf[count] = 0;
 661        strcat(kernbuf, ",");
 662        ret = ibm->write(kernbuf);
 663        if (ret == 0)
 664                ret = count;
 665
 666        kfree(kernbuf);
 667
 668        return ret;
 669}
 670
 671static char *next_cmd(char **cmds)
 672{
 673        char *start = *cmds;
 674        char *end;
 675
 676        while ((end = strchr(start, ',')) && end == start)
 677                start = end + 1;
 678
 679        if (!end)
 680                return NULL;
 681
 682        *end = 0;
 683        *cmds = end + 1;
 684        return start;
 685}
 686
 687
 688/****************************************************************************
 689 ****************************************************************************
 690 *
 691 * Device model: input, hwmon and platform
 692 *
 693 ****************************************************************************
 694 ****************************************************************************/
 695
 696static struct platform_device *tpacpi_pdev;
 697static struct platform_device *tpacpi_sensors_pdev;
 698static struct device *tpacpi_hwmon;
 699static struct input_dev *tpacpi_inputdev;
 700static struct mutex tpacpi_inputdev_send_mutex;
 701static LIST_HEAD(tpacpi_all_drivers);
 702
 703static int tpacpi_suspend_handler(struct platform_device *pdev,
 704                                  pm_message_t state)
 705{
 706        struct ibm_struct *ibm, *itmp;
 707
 708        list_for_each_entry_safe(ibm, itmp,
 709                                 &tpacpi_all_drivers,
 710                                 all_drivers) {
 711                if (ibm->suspend)
 712                        (ibm->suspend)(state);
 713        }
 714
 715        return 0;
 716}
 717
 718static int tpacpi_resume_handler(struct platform_device *pdev)
 719{
 720        struct ibm_struct *ibm, *itmp;
 721
 722        list_for_each_entry_safe(ibm, itmp,
 723                                 &tpacpi_all_drivers,
 724                                 all_drivers) {
 725                if (ibm->resume)
 726                        (ibm->resume)();
 727        }
 728
 729        return 0;
 730}
 731
 732static struct platform_driver tpacpi_pdriver = {
 733        .driver = {
 734                .name = TPACPI_DRVR_NAME,
 735                .owner = THIS_MODULE,
 736        },
 737        .suspend = tpacpi_suspend_handler,
 738        .resume = tpacpi_resume_handler,
 739};
 740
 741static struct platform_driver tpacpi_hwmon_pdriver = {
 742        .driver = {
 743                .name = TPACPI_HWMON_DRVR_NAME,
 744                .owner = THIS_MODULE,
 745        },
 746};
 747
 748/*************************************************************************
 749 * sysfs support helpers
 750 */
 751
 752struct attribute_set {
 753        unsigned int members, max_members;
 754        struct attribute_group group;
 755};
 756
 757struct attribute_set_obj {
 758        struct attribute_set s;
 759        struct attribute *a;
 760} __attribute__((packed));
 761
 762static struct attribute_set *create_attr_set(unsigned int max_members,
 763                                                const char *name)
 764{
 765        struct attribute_set_obj *sobj;
 766
 767        if (max_members == 0)
 768                return NULL;
 769
 770        /* Allocates space for implicit NULL at the end too */
 771        sobj = kzalloc(sizeof(struct attribute_set_obj) +
 772                    max_members * sizeof(struct attribute *),
 773                    GFP_KERNEL);
 774        if (!sobj)
 775                return NULL;
 776        sobj->s.max_members = max_members;
 777        sobj->s.group.attrs = &sobj->a;
 778        sobj->s.group.name = name;
 779
 780        return &sobj->s;
 781}
 782
 783#define destroy_attr_set(_set) \
 784        kfree(_set);
 785
 786/* not multi-threaded safe, use it in a single thread per set */
 787static int add_to_attr_set(struct attribute_set *s, struct attribute *attr)
 788{
 789        if (!s || !attr)
 790                return -EINVAL;
 791
 792        if (s->members >= s->max_members)
 793                return -ENOMEM;
 794
 795        s->group.attrs[s->members] = attr;
 796        s->members++;
 797
 798        return 0;
 799}
 800
 801static int add_many_to_attr_set(struct attribute_set *s,
 802                        struct attribute **attr,
 803                        unsigned int count)
 804{
 805        int i, res;
 806
 807        for (i = 0; i < count; i++) {
 808                res = add_to_attr_set(s, attr[i]);
 809                if (res)
 810                        return res;
 811        }
 812
 813        return 0;
 814}
 815
 816static void delete_attr_set(struct attribute_set *s, struct kobject *kobj)
 817{
 818        sysfs_remove_group(kobj, &s->group);
 819        destroy_attr_set(s);
 820}
 821
 822#define register_attr_set_with_sysfs(_attr_set, _kobj) \
 823        sysfs_create_group(_kobj, &_attr_set->group)
 824
 825static int parse_strtoul(const char *buf,
 826                unsigned long max, unsigned long *value)
 827{
 828        char *endp;
 829
 830        while (*buf && isspace(*buf))
 831                buf++;
 832        *value = simple_strtoul(buf, &endp, 0);
 833        while (*endp && isspace(*endp))
 834                endp++;
 835        if (*endp || *value > max)
 836                return -EINVAL;
 837
 838        return 0;
 839}
 840
 841static void tpacpi_disable_brightness_delay(void)
 842{
 843        if (acpi_evalf(hkey_handle, NULL, "PWMS", "qvd", 0))
 844                printk(TPACPI_NOTICE
 845                        "ACPI backlight control delay disabled\n");
 846}
 847
 848static int __init tpacpi_query_bcl_levels(acpi_handle handle)
 849{
 850        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 851        union acpi_object *obj;
 852        int rc;
 853
 854        if (ACPI_SUCCESS(acpi_evaluate_object(handle, NULL, NULL, &buffer))) {
 855                obj = (union acpi_object *)buffer.pointer;
 856                if (!obj || (obj->type != ACPI_TYPE_PACKAGE)) {
 857                        printk(TPACPI_ERR "Unknown _BCL data, "
 858                               "please report this to %s\n", TPACPI_MAIL);
 859                        rc = 0;
 860                } else {
 861                        rc = obj->package.count;
 862                }
 863        } else {
 864                return 0;
 865        }
 866
 867        kfree(buffer.pointer);
 868        return rc;
 869}
 870
 871static acpi_status __init tpacpi_acpi_walk_find_bcl(acpi_handle handle,
 872                                        u32 lvl, void *context, void **rv)
 873{
 874        char name[ACPI_PATH_SEGMENT_LENGTH];
 875        struct acpi_buffer buffer = { sizeof(name), &name };
 876
 877        if (ACPI_SUCCESS(acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer)) &&
 878            !strncmp("_BCL", name, sizeof(name) - 1)) {
 879                BUG_ON(!rv || !*rv);
 880                **(int **)rv = tpacpi_query_bcl_levels(handle);
 881                return AE_CTRL_TERMINATE;
 882        } else {
 883                return AE_OK;
 884        }
 885}
 886
 887/*
 888 * Returns 0 (no ACPI _BCL or _BCL invalid), or size of brightness map
 889 */
 890static int __init tpacpi_check_std_acpi_brightness_support(void)
 891{
 892        int status;
 893        int bcl_levels = 0;
 894        void *bcl_ptr = &bcl_levels;
 895
 896        if (!vid_handle) {
 897                TPACPI_ACPIHANDLE_INIT(vid);
 898        }
 899        if (!vid_handle)
 900                return 0;
 901
 902        /*
 903         * Search for a _BCL method, and execute it.  This is safe on all
 904         * ThinkPads, and as a side-effect, _BCL will place a Lenovo Vista
 905         * BIOS in ACPI backlight control mode.  We do NOT have to care
 906         * about calling the _BCL method in an enabled video device, any
 907         * will do for our purposes.
 908         */
 909
 910        status = acpi_walk_namespace(ACPI_TYPE_METHOD, vid_handle, 3,
 911                                     tpacpi_acpi_walk_find_bcl, NULL,
 912                                     &bcl_ptr);
 913
 914        if (ACPI_SUCCESS(status) && bcl_levels > 2) {
 915                tp_features.bright_acpimode = 1;
 916                return (bcl_levels - 2);
 917        }
 918
 919        return 0;
 920}
 921
 922static int __init tpacpi_new_rfkill(const unsigned int id,
 923                        struct rfkill **rfk,
 924                        const enum rfkill_type rfktype,
 925                        const char *name,
 926                        int (*toggle_radio)(void *, enum rfkill_state),
 927                        int (*get_state)(void *, enum rfkill_state *))
 928{
 929        int res;
 930        enum rfkill_state initial_state;
 931
 932        *rfk = rfkill_allocate(&tpacpi_pdev->dev, rfktype);
 933        if (!*rfk) {
 934                printk(TPACPI_ERR
 935                        "failed to allocate memory for rfkill class\n");
 936                return -ENOMEM;
 937        }
 938
 939        (*rfk)->name = name;
 940        (*rfk)->get_state = get_state;
 941        (*rfk)->toggle_radio = toggle_radio;
 942
 943        if (!get_state(NULL, &initial_state))
 944                (*rfk)->state = initial_state;
 945
 946        res = rfkill_register(*rfk);
 947        if (res < 0) {
 948                printk(TPACPI_ERR
 949                        "failed to register %s rfkill switch: %d\n",
 950                        name, res);
 951                rfkill_free(*rfk);
 952                *rfk = NULL;
 953                return res;
 954        }
 955
 956        return 0;
 957}
 958
 959/*************************************************************************
 960 * thinkpad-acpi driver attributes
 961 */
 962
 963/* interface_version --------------------------------------------------- */
 964static ssize_t tpacpi_driver_interface_version_show(
 965                                struct device_driver *drv,
 966                                char *buf)
 967{
 968        return snprintf(buf, PAGE_SIZE, "0x%08x\n", TPACPI_SYSFS_VERSION);
 969}
 970
 971static DRIVER_ATTR(interface_version, S_IRUGO,
 972                tpacpi_driver_interface_version_show, NULL);
 973
 974/* debug_level --------------------------------------------------------- */
 975static ssize_t tpacpi_driver_debug_show(struct device_driver *drv,
 976                                                char *buf)
 977{
 978        return snprintf(buf, PAGE_SIZE, "0x%04x\n", dbg_level);
 979}
 980
 981static ssize_t tpacpi_driver_debug_store(struct device_driver *drv,
 982                                                const char *buf, size_t count)
 983{
 984        unsigned long t;
 985
 986        if (parse_strtoul(buf, 0xffff, &t))
 987                return -EINVAL;
 988
 989        dbg_level = t;
 990
 991        return count;
 992}
 993
 994static DRIVER_ATTR(debug_level, S_IWUSR | S_IRUGO,
 995                tpacpi_driver_debug_show, tpacpi_driver_debug_store);
 996
 997/* version ------------------------------------------------------------- */
 998static ssize_t tpacpi_driver_version_show(struct device_driver *drv,
 999                                                char *buf)
1000{
1001        return snprintf(buf, PAGE_SIZE, "%s v%s\n",
1002                        TPACPI_DESC, TPACPI_VERSION);
1003}
1004
1005static DRIVER_ATTR(version, S_IRUGO,
1006                tpacpi_driver_version_show, NULL);
1007
1008/* --------------------------------------------------------------------- */
1009
1010static struct driver_attribute *tpacpi_driver_attributes[] = {
1011        &driver_attr_debug_level, &driver_attr_version,
1012        &driver_attr_interface_version,
1013};
1014
1015static int __init tpacpi_create_driver_attributes(struct device_driver *drv)
1016{
1017        int i, res;
1018
1019        i = 0;
1020        res = 0;
1021        while (!res && i < ARRAY_SIZE(tpacpi_driver_attributes)) {
1022                res = driver_create_file(drv, tpacpi_driver_attributes[i]);
1023                i++;
1024        }
1025
1026        return res;
1027}
1028
1029static void tpacpi_remove_driver_attributes(struct device_driver *drv)
1030{
1031        int i;
1032
1033        for (i = 0; i < ARRAY_SIZE(tpacpi_driver_attributes); i++)
1034                driver_remove_file(drv, tpacpi_driver_attributes[i]);
1035}
1036
1037/****************************************************************************
1038 ****************************************************************************
1039 *
1040 * Subdrivers
1041 *
1042 ****************************************************************************
1043 ****************************************************************************/
1044
1045/*************************************************************************
1046 * thinkpad-acpi init subdriver
1047 */
1048
1049static int __init thinkpad_acpi_driver_init(struct ibm_init_struct *iibm)
1050{
1051        printk(TPACPI_INFO "%s v%s\n", TPACPI_DESC, TPACPI_VERSION);
1052        printk(TPACPI_INFO "%s\n", TPACPI_URL);
1053
1054        printk(TPACPI_INFO "ThinkPad BIOS %s, EC %s\n",
1055                (thinkpad_id.bios_version_str) ?
1056                        thinkpad_id.bios_version_str : "unknown",
1057                (thinkpad_id.ec_version_str) ?
1058                        thinkpad_id.ec_version_str : "unknown");
1059
1060        if (thinkpad_id.vendor && thinkpad_id.model_str)
1061                printk(TPACPI_INFO "%s %s, model %s\n",
1062                        (thinkpad_id.vendor == PCI_VENDOR_ID_IBM) ?
1063                                "IBM" : ((thinkpad_id.vendor ==
1064                                                PCI_VENDOR_ID_LENOVO) ?
1065                                        "Lenovo" : "Unknown vendor"),
1066                        thinkpad_id.model_str,
1067                        (thinkpad_id.nummodel_str) ?
1068                                thinkpad_id.nummodel_str : "unknown");
1069
1070        return 0;
1071}
1072
1073static int thinkpad_acpi_driver_read(char *p)
1074{
1075        int len = 0;
1076
1077        len += sprintf(p + len, "driver:\t\t%s\n", TPACPI_DESC);
1078        len += sprintf(p + len, "version:\t%s\n", TPACPI_VERSION);
1079
1080        return len;
1081}
1082
1083static struct ibm_struct thinkpad_acpi_driver_data = {
1084        .name = "driver",
1085        .read = thinkpad_acpi_driver_read,
1086};
1087
1088/*************************************************************************
1089 * Hotkey subdriver
1090 */
1091
1092enum {  /* hot key scan codes (derived from ACPI DSDT) */
1093        TP_ACPI_HOTKEYSCAN_FNF1         = 0,
1094        TP_ACPI_HOTKEYSCAN_FNF2,
1095        TP_ACPI_HOTKEYSCAN_FNF3,
1096        TP_ACPI_HOTKEYSCAN_FNF4,
1097        TP_ACPI_HOTKEYSCAN_FNF5,
1098        TP_ACPI_HOTKEYSCAN_FNF6,
1099        TP_ACPI_HOTKEYSCAN_FNF7,
1100        TP_ACPI_HOTKEYSCAN_FNF8,
1101        TP_ACPI_HOTKEYSCAN_FNF9,
1102        TP_ACPI_HOTKEYSCAN_FNF10,
1103        TP_ACPI_HOTKEYSCAN_FNF11,
1104        TP_ACPI_HOTKEYSCAN_FNF12,
1105        TP_ACPI_HOTKEYSCAN_FNBACKSPACE,
1106        TP_ACPI_HOTKEYSCAN_FNINSERT,
1107        TP_ACPI_HOTKEYSCAN_FNDELETE,
1108        TP_ACPI_HOTKEYSCAN_FNHOME,
1109        TP_ACPI_HOTKEYSCAN_FNEND,
1110        TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1111        TP_ACPI_HOTKEYSCAN_FNPAGEDOWN,
1112        TP_ACPI_HOTKEYSCAN_FNSPACE,
1113        TP_ACPI_HOTKEYSCAN_VOLUMEUP,
1114        TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
1115        TP_ACPI_HOTKEYSCAN_MUTE,
1116        TP_ACPI_HOTKEYSCAN_THINKPAD,
1117};
1118
1119enum {  /* Keys available through NVRAM polling */
1120        TPACPI_HKEY_NVRAM_KNOWN_MASK = 0x00fb88c0U,
1121        TPACPI_HKEY_NVRAM_GOOD_MASK  = 0x00fb8000U,
1122};
1123
1124enum {  /* Positions of some of the keys in hotkey masks */
1125        TP_ACPI_HKEY_DISPSWTCH_MASK     = 1 << TP_ACPI_HOTKEYSCAN_FNF7,
1126        TP_ACPI_HKEY_DISPXPAND_MASK     = 1 << TP_ACPI_HOTKEYSCAN_FNF8,
1127        TP_ACPI_HKEY_HIBERNATE_MASK     = 1 << TP_ACPI_HOTKEYSCAN_FNF12,
1128        TP_ACPI_HKEY_BRGHTUP_MASK       = 1 << TP_ACPI_HOTKEYSCAN_FNHOME,
1129        TP_ACPI_HKEY_BRGHTDWN_MASK      = 1 << TP_ACPI_HOTKEYSCAN_FNEND,
1130        TP_ACPI_HKEY_THNKLGHT_MASK      = 1 << TP_ACPI_HOTKEYSCAN_FNPAGEUP,
1131        TP_ACPI_HKEY_ZOOM_MASK          = 1 << TP_ACPI_HOTKEYSCAN_FNSPACE,
1132        TP_ACPI_HKEY_VOLUP_MASK         = 1 << TP_ACPI_HOTKEYSCAN_VOLUMEUP,
1133        TP_ACPI_HKEY_VOLDWN_MASK        = 1 << TP_ACPI_HOTKEYSCAN_VOLUMEDOWN,
1134        TP_ACPI_HKEY_MUTE_MASK          = 1 << TP_ACPI_HOTKEYSCAN_MUTE,
1135        TP_ACPI_HKEY_THINKPAD_MASK      = 1 << TP_ACPI_HOTKEYSCAN_THINKPAD,
1136};
1137
1138enum {  /* NVRAM to ACPI HKEY group map */
1139        TP_NVRAM_HKEY_GROUP_HK2         = TP_ACPI_HKEY_THINKPAD_MASK |
1140                                          TP_ACPI_HKEY_ZOOM_MASK |
1141                                          TP_ACPI_HKEY_DISPSWTCH_MASK |
1142                                          TP_ACPI_HKEY_HIBERNATE_MASK,
1143        TP_NVRAM_HKEY_GROUP_BRIGHTNESS  = TP_ACPI_HKEY_BRGHTUP_MASK |
1144                                          TP_ACPI_HKEY_BRGHTDWN_MASK,
1145        TP_NVRAM_HKEY_GROUP_VOLUME      = TP_ACPI_HKEY_VOLUP_MASK |
1146                                          TP_ACPI_HKEY_VOLDWN_MASK |
1147                                          TP_ACPI_HKEY_MUTE_MASK,
1148};
1149
1150#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1151struct tp_nvram_state {
1152       u16 thinkpad_toggle:1;
1153       u16 zoom_toggle:1;
1154       u16 display_toggle:1;
1155       u16 thinklight_toggle:1;
1156       u16 hibernate_toggle:1;
1157       u16 displayexp_toggle:1;
1158       u16 display_state:1;
1159       u16 brightness_toggle:1;
1160       u16 volume_toggle:1;
1161       u16 mute:1;
1162
1163       u8 brightness_level;
1164       u8 volume_level;
1165};
1166
1167static struct task_struct *tpacpi_hotkey_task;
1168static u32 hotkey_source_mask;          /* bit mask 0=ACPI,1=NVRAM */
1169static int hotkey_poll_freq = 10;       /* Hz */
1170static struct mutex hotkey_thread_mutex;
1171static struct mutex hotkey_thread_data_mutex;
1172static unsigned int hotkey_config_change;
1173
1174#else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1175
1176#define hotkey_source_mask 0U
1177
1178#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1179
1180static struct mutex hotkey_mutex;
1181
1182static enum {   /* Reasons for waking up */
1183        TP_ACPI_WAKEUP_NONE = 0,        /* None or unknown */
1184        TP_ACPI_WAKEUP_BAYEJ,           /* Bay ejection request */
1185        TP_ACPI_WAKEUP_UNDOCK,          /* Undock request */
1186} hotkey_wakeup_reason;
1187
1188static int hotkey_autosleep_ack;
1189
1190static int hotkey_orig_status;
1191static u32 hotkey_orig_mask;
1192static u32 hotkey_all_mask;
1193static u32 hotkey_reserved_mask;
1194static u32 hotkey_mask;
1195
1196static unsigned int hotkey_report_mode;
1197
1198static u16 *hotkey_keycode_map;
1199
1200static struct attribute_set *hotkey_dev_attributes;
1201
1202#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1203#define HOTKEY_CONFIG_CRITICAL_START \
1204        do { \
1205                mutex_lock(&hotkey_thread_data_mutex); \
1206                hotkey_config_change++; \
1207        } while (0);
1208#define HOTKEY_CONFIG_CRITICAL_END \
1209        mutex_unlock(&hotkey_thread_data_mutex);
1210#else
1211#define HOTKEY_CONFIG_CRITICAL_START
1212#define HOTKEY_CONFIG_CRITICAL_END
1213#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1214
1215/* HKEY.MHKG() return bits */
1216#define TP_HOTKEY_TABLET_MASK (1 << 3)
1217
1218static int hotkey_get_wlsw(int *status)
1219{
1220        if (!acpi_evalf(hkey_handle, status, "WLSW", "d"))
1221                return -EIO;
1222        return 0;
1223}
1224
1225static int hotkey_get_tablet_mode(int *status)
1226{
1227        int s;
1228
1229        if (!acpi_evalf(hkey_handle, &s, "MHKG", "d"))
1230                return -EIO;
1231
1232        *status = ((s & TP_HOTKEY_TABLET_MASK) != 0);
1233        return 0;
1234}
1235
1236/*
1237 * Call with hotkey_mutex held
1238 */
1239static int hotkey_mask_get(void)
1240{
1241        u32 m = 0;
1242
1243        if (tp_features.hotkey_mask) {
1244                if (!acpi_evalf(hkey_handle, &m, "DHKN", "d"))
1245                        return -EIO;
1246        }
1247        hotkey_mask = m | (hotkey_source_mask & hotkey_mask);
1248
1249        return 0;
1250}
1251
1252/*
1253 * Call with hotkey_mutex held
1254 */
1255static int hotkey_mask_set(u32 mask)
1256{
1257        int i;
1258        int rc = 0;
1259
1260        if (tp_features.hotkey_mask) {
1261                if (!tp_warned.hotkey_mask_ff &&
1262                    (mask == 0xffff || mask == 0xffffff ||
1263                     mask == 0xffffffff)) {
1264                        tp_warned.hotkey_mask_ff = 1;
1265                        printk(TPACPI_NOTICE
1266                               "setting the hotkey mask to 0x%08x is likely "
1267                               "not the best way to go about it\n", mask);
1268                        printk(TPACPI_NOTICE
1269                               "please consider using the driver defaults, "
1270                               "and refer to up-to-date thinkpad-acpi "
1271                               "documentation\n");
1272                }
1273
1274                HOTKEY_CONFIG_CRITICAL_START
1275                for (i = 0; i < 32; i++) {
1276                        u32 m = 1 << i;
1277                        /* enable in firmware mask only keys not in NVRAM
1278                         * mode, but enable the key in the cached hotkey_mask
1279                         * regardless of mode, or the key will end up
1280                         * disabled by hotkey_mask_get() */
1281                        if (!acpi_evalf(hkey_handle,
1282                                        NULL, "MHKM", "vdd", i + 1,
1283                                        !!((mask & ~hotkey_source_mask) & m))) {
1284                                rc = -EIO;
1285                                break;
1286                        } else {
1287                                hotkey_mask = (hotkey_mask & ~m) | (mask & m);
1288                        }
1289                }
1290                HOTKEY_CONFIG_CRITICAL_END
1291
1292                /* hotkey_mask_get must be called unconditionally below */
1293                if (!hotkey_mask_get() && !rc &&
1294                    (hotkey_mask & ~hotkey_source_mask) !=
1295                     (mask & ~hotkey_source_mask)) {
1296                        printk(TPACPI_NOTICE
1297                               "requested hot key mask 0x%08x, but "
1298                               "firmware forced it to 0x%08x\n",
1299                               mask, hotkey_mask);
1300                }
1301        } else {
1302#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1303                HOTKEY_CONFIG_CRITICAL_START
1304                hotkey_mask = mask & hotkey_source_mask;
1305                HOTKEY_CONFIG_CRITICAL_END
1306                hotkey_mask_get();
1307                if (hotkey_mask != mask) {
1308                        printk(TPACPI_NOTICE
1309                               "requested hot key mask 0x%08x, "
1310                               "forced to 0x%08x (NVRAM poll mask is "
1311                               "0x%08x): no firmware mask support\n",
1312                               mask, hotkey_mask, hotkey_source_mask);
1313                }
1314#else
1315                hotkey_mask_get();
1316                rc = -ENXIO;
1317#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1318        }
1319
1320        return rc;
1321}
1322
1323static int hotkey_status_get(int *status)
1324{
1325        if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
1326                return -EIO;
1327
1328        return 0;
1329}
1330
1331static int hotkey_status_set(int status)
1332{
1333        if (!acpi_evalf(hkey_handle, NULL, "MHKC", "vd", status))
1334                return -EIO;
1335
1336        return 0;
1337}
1338
1339static void tpacpi_input_send_tabletsw(void)
1340{
1341        int state;
1342
1343        if (tp_features.hotkey_tablet &&
1344            !hotkey_get_tablet_mode(&state)) {
1345                mutex_lock(&tpacpi_inputdev_send_mutex);
1346
1347                input_report_switch(tpacpi_inputdev,
1348                                    SW_TABLET_MODE, !!state);
1349                input_sync(tpacpi_inputdev);
1350
1351                mutex_unlock(&tpacpi_inputdev_send_mutex);
1352        }
1353}
1354
1355static void tpacpi_input_send_key(unsigned int scancode)
1356{
1357        unsigned int keycode;
1358
1359        keycode = hotkey_keycode_map[scancode];
1360
1361        if (keycode != KEY_RESERVED) {
1362                mutex_lock(&tpacpi_inputdev_send_mutex);
1363
1364                input_report_key(tpacpi_inputdev, keycode, 1);
1365                if (keycode == KEY_UNKNOWN)
1366                        input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN,
1367                                    scancode);
1368                input_sync(tpacpi_inputdev);
1369
1370                input_report_key(tpacpi_inputdev, keycode, 0);
1371                if (keycode == KEY_UNKNOWN)
1372                        input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN,
1373                                    scancode);
1374                input_sync(tpacpi_inputdev);
1375
1376                mutex_unlock(&tpacpi_inputdev_send_mutex);
1377        }
1378}
1379
1380#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1381static struct tp_acpi_drv_struct ibm_hotkey_acpidriver;
1382
1383static void tpacpi_hotkey_send_key(unsigned int scancode)
1384{
1385        tpacpi_input_send_key(scancode);
1386        if (hotkey_report_mode < 2) {
1387                acpi_bus_generate_proc_event(ibm_hotkey_acpidriver.device,
1388                                                0x80, 0x1001 + scancode);
1389        }
1390}
1391
1392static void hotkey_read_nvram(struct tp_nvram_state *n, u32 m)
1393{
1394        u8 d;
1395
1396        if (m & TP_NVRAM_HKEY_GROUP_HK2) {
1397                d = nvram_read_byte(TP_NVRAM_ADDR_HK2);
1398                n->thinkpad_toggle = !!(d & TP_NVRAM_MASK_HKT_THINKPAD);
1399                n->zoom_toggle = !!(d & TP_NVRAM_MASK_HKT_ZOOM);
1400                n->display_toggle = !!(d & TP_NVRAM_MASK_HKT_DISPLAY);
1401                n->hibernate_toggle = !!(d & TP_NVRAM_MASK_HKT_HIBERNATE);
1402        }
1403        if (m & TP_ACPI_HKEY_THNKLGHT_MASK) {
1404                d = nvram_read_byte(TP_NVRAM_ADDR_THINKLIGHT);
1405                n->thinklight_toggle = !!(d & TP_NVRAM_MASK_THINKLIGHT);
1406        }
1407        if (m & TP_ACPI_HKEY_DISPXPAND_MASK) {
1408                d = nvram_read_byte(TP_NVRAM_ADDR_VIDEO);
1409                n->displayexp_toggle =
1410                                !!(d & TP_NVRAM_MASK_HKT_DISPEXPND);
1411        }
1412        if (m & TP_NVRAM_HKEY_GROUP_BRIGHTNESS) {
1413                d = nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS);
1414                n->brightness_level = (d & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
1415                                >> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
1416                n->brightness_toggle =
1417                                !!(d & TP_NVRAM_MASK_HKT_BRIGHTNESS);
1418        }
1419        if (m & TP_NVRAM_HKEY_GROUP_VOLUME) {
1420                d = nvram_read_byte(TP_NVRAM_ADDR_MIXER);
1421                n->volume_level = (d & TP_NVRAM_MASK_LEVEL_VOLUME)
1422                                >> TP_NVRAM_POS_LEVEL_VOLUME;
1423                n->mute = !!(d & TP_NVRAM_MASK_MUTE);
1424                n->volume_toggle = !!(d & TP_NVRAM_MASK_HKT_VOLUME);
1425        }
1426}
1427
1428#define TPACPI_COMPARE_KEY(__scancode, __member) \
1429        do { \
1430                if ((mask & (1 << __scancode)) && \
1431                    oldn->__member != newn->__member) \
1432                tpacpi_hotkey_send_key(__scancode); \
1433        } while (0)
1434
1435#define TPACPI_MAY_SEND_KEY(__scancode) \
1436        do { if (mask & (1 << __scancode)) \
1437                tpacpi_hotkey_send_key(__scancode); } while (0)
1438
1439static void hotkey_compare_and_issue_event(struct tp_nvram_state *oldn,
1440                                           struct tp_nvram_state *newn,
1441                                           u32 mask)
1442{
1443        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_THINKPAD, thinkpad_toggle);
1444        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNSPACE, zoom_toggle);
1445        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF7, display_toggle);
1446        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF12, hibernate_toggle);
1447
1448        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNPAGEUP, thinklight_toggle);
1449
1450        TPACPI_COMPARE_KEY(TP_ACPI_HOTKEYSCAN_FNF8, displayexp_toggle);
1451
1452        /* handle volume */
1453        if (oldn->volume_toggle != newn->volume_toggle) {
1454                if (oldn->mute != newn->mute) {
1455                        TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_MUTE);
1456                }
1457                if (oldn->volume_level > newn->volume_level) {
1458                        TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
1459                } else if (oldn->volume_level < newn->volume_level) {
1460                        TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
1461                } else if (oldn->mute == newn->mute) {
1462                        /* repeated key presses that didn't change state */
1463                        if (newn->mute) {
1464                                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_MUTE);
1465                        } else if (newn->volume_level != 0) {
1466                                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEUP);
1467                        } else {
1468                                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_VOLUMEDOWN);
1469                        }
1470                }
1471        }
1472
1473        /* handle brightness */
1474        if (oldn->brightness_toggle != newn->brightness_toggle) {
1475                if (oldn->brightness_level < newn->brightness_level) {
1476                        TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
1477                } else if (oldn->brightness_level > newn->brightness_level) {
1478                        TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
1479                } else {
1480                        /* repeated key presses that didn't change state */
1481                        if (newn->brightness_level != 0) {
1482                                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNHOME);
1483                        } else {
1484                                TPACPI_MAY_SEND_KEY(TP_ACPI_HOTKEYSCAN_FNEND);
1485                        }
1486                }
1487        }
1488}
1489
1490#undef TPACPI_COMPARE_KEY
1491#undef TPACPI_MAY_SEND_KEY
1492
1493static int hotkey_kthread(void *data)
1494{
1495        struct tp_nvram_state s[2];
1496        u32 mask;
1497        unsigned int si, so;
1498        unsigned long t;
1499        unsigned int change_detector, must_reset;
1500
1501        mutex_lock(&hotkey_thread_mutex);
1502
1503        if (tpacpi_lifecycle == TPACPI_LIFE_EXITING)
1504                goto exit;
1505
1506        set_freezable();
1507
1508        so = 0;
1509        si = 1;
1510        t = 0;
1511
1512        /* Initial state for compares */
1513        mutex_lock(&hotkey_thread_data_mutex);
1514        change_detector = hotkey_config_change;
1515        mask = hotkey_source_mask & hotkey_mask;
1516        mutex_unlock(&hotkey_thread_data_mutex);
1517        hotkey_read_nvram(&s[so], mask);
1518
1519        while (!kthread_should_stop() && hotkey_poll_freq) {
1520                if (t == 0)
1521                        t = 1000/hotkey_poll_freq;
1522                t = msleep_interruptible(t);
1523                if (unlikely(kthread_should_stop()))
1524                        break;
1525                must_reset = try_to_freeze();
1526                if (t > 0 && !must_reset)
1527                        continue;
1528
1529                mutex_lock(&hotkey_thread_data_mutex);
1530                if (must_reset || hotkey_config_change != change_detector) {
1531                        /* forget old state on thaw or config change */
1532                        si = so;
1533                        t = 0;
1534                        change_detector = hotkey_config_change;
1535                }
1536                mask = hotkey_source_mask & hotkey_mask;
1537                mutex_unlock(&hotkey_thread_data_mutex);
1538
1539                if (likely(mask)) {
1540                        hotkey_read_nvram(&s[si], mask);
1541                        if (likely(si != so)) {
1542                                hotkey_compare_and_issue_event(&s[so], &s[si],
1543                                                                mask);
1544                        }
1545                }
1546
1547                so = si;
1548                si ^= 1;
1549        }
1550
1551exit:
1552        mutex_unlock(&hotkey_thread_mutex);
1553        return 0;
1554}
1555
1556static void hotkey_poll_stop_sync(void)
1557{
1558        if (tpacpi_hotkey_task) {
1559                if (frozen(tpacpi_hotkey_task) ||
1560                    freezing(tpacpi_hotkey_task))
1561                        thaw_process(tpacpi_hotkey_task);
1562
1563                kthread_stop(tpacpi_hotkey_task);
1564                tpacpi_hotkey_task = NULL;
1565                mutex_lock(&hotkey_thread_mutex);
1566                /* at this point, the thread did exit */
1567                mutex_unlock(&hotkey_thread_mutex);
1568        }
1569}
1570
1571/* call with hotkey_mutex held */
1572static void hotkey_poll_setup(int may_warn)
1573{
1574        if ((hotkey_source_mask & hotkey_mask) != 0 &&
1575            hotkey_poll_freq > 0 &&
1576            (tpacpi_inputdev->users > 0 || hotkey_report_mode < 2)) {
1577                if (!tpacpi_hotkey_task) {
1578                        tpacpi_hotkey_task = kthread_run(hotkey_kthread,
1579                                        NULL, TPACPI_NVRAM_KTHREAD_NAME);
1580                        if (IS_ERR(tpacpi_hotkey_task)) {
1581                                tpacpi_hotkey_task = NULL;
1582                                printk(TPACPI_ERR
1583                                       "could not create kernel thread "
1584                                       "for hotkey polling\n");
1585                        }
1586                }
1587        } else {
1588                hotkey_poll_stop_sync();
1589                if (may_warn &&
1590                    hotkey_source_mask != 0 && hotkey_poll_freq == 0) {
1591                        printk(TPACPI_NOTICE
1592                                "hot keys 0x%08x require polling, "
1593                                "which is currently disabled\n",
1594                                hotkey_source_mask);
1595                }
1596        }
1597}
1598
1599static void hotkey_poll_setup_safe(int may_warn)
1600{
1601        mutex_lock(&hotkey_mutex);
1602        hotkey_poll_setup(may_warn);
1603        mutex_unlock(&hotkey_mutex);
1604}
1605
1606#else /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1607
1608static void hotkey_poll_setup_safe(int __unused)
1609{
1610}
1611
1612#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1613
1614static int hotkey_inputdev_open(struct input_dev *dev)
1615{
1616        switch (tpacpi_lifecycle) {
1617        case TPACPI_LIFE_INIT:
1618                /*
1619                 * hotkey_init will call hotkey_poll_setup_safe
1620                 * at the appropriate moment
1621                 */
1622                return 0;
1623        case TPACPI_LIFE_EXITING:
1624                return -EBUSY;
1625        case TPACPI_LIFE_RUNNING:
1626                hotkey_poll_setup_safe(0);
1627                return 0;
1628        }
1629
1630        /* Should only happen if tpacpi_lifecycle is corrupt */
1631        BUG();
1632        return -EBUSY;
1633}
1634
1635static void hotkey_inputdev_close(struct input_dev *dev)
1636{
1637        /* disable hotkey polling when possible */
1638        if (tpacpi_lifecycle == TPACPI_LIFE_RUNNING)
1639                hotkey_poll_setup_safe(0);
1640}
1641
1642/* sysfs hotkey enable ------------------------------------------------- */
1643static ssize_t hotkey_enable_show(struct device *dev,
1644                           struct device_attribute *attr,
1645                           char *buf)
1646{
1647        int res, status;
1648
1649        res = hotkey_status_get(&status);
1650        if (res)
1651                return res;
1652
1653        return snprintf(buf, PAGE_SIZE, "%d\n", status);
1654}
1655
1656static ssize_t hotkey_enable_store(struct device *dev,
1657                            struct device_attribute *attr,
1658                            const char *buf, size_t count)
1659{
1660        unsigned long t;
1661        int res;
1662
1663        if (parse_strtoul(buf, 1, &t))
1664                return -EINVAL;
1665
1666        res = hotkey_status_set(t);
1667
1668        return (res) ? res : count;
1669}
1670
1671static struct device_attribute dev_attr_hotkey_enable =
1672        __ATTR(hotkey_enable, S_IWUSR | S_IRUGO,
1673                hotkey_enable_show, hotkey_enable_store);
1674
1675/* sysfs hotkey mask --------------------------------------------------- */
1676static ssize_t hotkey_mask_show(struct device *dev,
1677                           struct device_attribute *attr,
1678                           char *buf)
1679{
1680        int res;
1681
1682        if (mutex_lock_interruptible(&hotkey_mutex))
1683                return -ERESTARTSYS;
1684        res = hotkey_mask_get();
1685        mutex_unlock(&hotkey_mutex);
1686
1687        return (res)?
1688                res : snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_mask);
1689}
1690
1691static ssize_t hotkey_mask_store(struct device *dev,
1692                            struct device_attribute *attr,
1693                            const char *buf, size_t count)
1694{
1695        unsigned long t;
1696        int res;
1697
1698        if (parse_strtoul(buf, 0xffffffffUL, &t))
1699                return -EINVAL;
1700
1701        if (mutex_lock_interruptible(&hotkey_mutex))
1702                return -ERESTARTSYS;
1703
1704        res = hotkey_mask_set(t);
1705
1706#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1707        hotkey_poll_setup(1);
1708#endif
1709
1710        mutex_unlock(&hotkey_mutex);
1711
1712        return (res) ? res : count;
1713}
1714
1715static struct device_attribute dev_attr_hotkey_mask =
1716        __ATTR(hotkey_mask, S_IWUSR | S_IRUGO,
1717                hotkey_mask_show, hotkey_mask_store);
1718
1719/* sysfs hotkey bios_enabled ------------------------------------------- */
1720static ssize_t hotkey_bios_enabled_show(struct device *dev,
1721                           struct device_attribute *attr,
1722                           char *buf)
1723{
1724        return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_orig_status);
1725}
1726
1727static struct device_attribute dev_attr_hotkey_bios_enabled =
1728        __ATTR(hotkey_bios_enabled, S_IRUGO, hotkey_bios_enabled_show, NULL);
1729
1730/* sysfs hotkey bios_mask ---------------------------------------------- */
1731static ssize_t hotkey_bios_mask_show(struct device *dev,
1732                           struct device_attribute *attr,
1733                           char *buf)
1734{
1735        return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_orig_mask);
1736}
1737
1738static struct device_attribute dev_attr_hotkey_bios_mask =
1739        __ATTR(hotkey_bios_mask, S_IRUGO, hotkey_bios_mask_show, NULL);
1740
1741/* sysfs hotkey all_mask ----------------------------------------------- */
1742static ssize_t hotkey_all_mask_show(struct device *dev,
1743                           struct device_attribute *attr,
1744                           char *buf)
1745{
1746        return snprintf(buf, PAGE_SIZE, "0x%08x\n",
1747                                hotkey_all_mask | hotkey_source_mask);
1748}
1749
1750static struct device_attribute dev_attr_hotkey_all_mask =
1751        __ATTR(hotkey_all_mask, S_IRUGO, hotkey_all_mask_show, NULL);
1752
1753/* sysfs hotkey recommended_mask --------------------------------------- */
1754static ssize_t hotkey_recommended_mask_show(struct device *dev,
1755                                            struct device_attribute *attr,
1756                                            char *buf)
1757{
1758        return snprintf(buf, PAGE_SIZE, "0x%08x\n",
1759                        (hotkey_all_mask | hotkey_source_mask)
1760                        & ~hotkey_reserved_mask);
1761}
1762
1763static struct device_attribute dev_attr_hotkey_recommended_mask =
1764        __ATTR(hotkey_recommended_mask, S_IRUGO,
1765                hotkey_recommended_mask_show, NULL);
1766
1767#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1768
1769/* sysfs hotkey hotkey_source_mask ------------------------------------- */
1770static ssize_t hotkey_source_mask_show(struct device *dev,
1771                           struct device_attribute *attr,
1772                           char *buf)
1773{
1774        return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_source_mask);
1775}
1776
1777static ssize_t hotkey_source_mask_store(struct device *dev,
1778                            struct device_attribute *attr,
1779                            const char *buf, size_t count)
1780{
1781        unsigned long t;
1782
1783        if (parse_strtoul(buf, 0xffffffffUL, &t) ||
1784                ((t & ~TPACPI_HKEY_NVRAM_KNOWN_MASK) != 0))
1785                return -EINVAL;
1786
1787        if (mutex_lock_interruptible(&hotkey_mutex))
1788                return -ERESTARTSYS;
1789
1790        HOTKEY_CONFIG_CRITICAL_START
1791        hotkey_source_mask = t;
1792        HOTKEY_CONFIG_CRITICAL_END
1793
1794        hotkey_poll_setup(1);
1795
1796        mutex_unlock(&hotkey_mutex);
1797
1798        return count;
1799}
1800
1801static struct device_attribute dev_attr_hotkey_source_mask =
1802        __ATTR(hotkey_source_mask, S_IWUSR | S_IRUGO,
1803                hotkey_source_mask_show, hotkey_source_mask_store);
1804
1805/* sysfs hotkey hotkey_poll_freq --------------------------------------- */
1806static ssize_t hotkey_poll_freq_show(struct device *dev,
1807                           struct device_attribute *attr,
1808                           char *buf)
1809{
1810        return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_poll_freq);
1811}
1812
1813static ssize_t hotkey_poll_freq_store(struct device *dev,
1814                            struct device_attribute *attr,
1815                            const char *buf, size_t count)
1816{
1817        unsigned long t;
1818
1819        if (parse_strtoul(buf, 25, &t))
1820                return -EINVAL;
1821
1822        if (mutex_lock_interruptible(&hotkey_mutex))
1823                return -ERESTARTSYS;
1824
1825        hotkey_poll_freq = t;
1826
1827        hotkey_poll_setup(1);
1828        mutex_unlock(&hotkey_mutex);
1829
1830        return count;
1831}
1832
1833static struct device_attribute dev_attr_hotkey_poll_freq =
1834        __ATTR(hotkey_poll_freq, S_IWUSR | S_IRUGO,
1835                hotkey_poll_freq_show, hotkey_poll_freq_store);
1836
1837#endif /* CONFIG_THINKPAD_ACPI_HOTKEY_POLL */
1838
1839/* sysfs hotkey radio_sw (pollable) ------------------------------------ */
1840static ssize_t hotkey_radio_sw_show(struct device *dev,
1841                           struct device_attribute *attr,
1842                           char *buf)
1843{
1844        int res, s;
1845        res = hotkey_get_wlsw(&s);
1846        if (res < 0)
1847                return res;
1848
1849        return snprintf(buf, PAGE_SIZE, "%d\n", !!s);
1850}
1851
1852static struct device_attribute dev_attr_hotkey_radio_sw =
1853        __ATTR(hotkey_radio_sw, S_IRUGO, hotkey_radio_sw_show, NULL);
1854
1855static void hotkey_radio_sw_notify_change(void)
1856{
1857        if (tp_features.hotkey_wlsw)
1858                sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
1859                             "hotkey_radio_sw");
1860}
1861
1862/* sysfs hotkey tablet mode (pollable) --------------------------------- */
1863static ssize_t hotkey_tablet_mode_show(struct device *dev,
1864                           struct device_attribute *attr,
1865                           char *buf)
1866{
1867        int res, s;
1868        res = hotkey_get_tablet_mode(&s);
1869        if (res < 0)
1870                return res;
1871
1872        return snprintf(buf, PAGE_SIZE, "%d\n", !!s);
1873}
1874
1875static struct device_attribute dev_attr_hotkey_tablet_mode =
1876        __ATTR(hotkey_tablet_mode, S_IRUGO, hotkey_tablet_mode_show, NULL);
1877
1878static void hotkey_tablet_mode_notify_change(void)
1879{
1880        if (tp_features.hotkey_tablet)
1881                sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
1882                             "hotkey_tablet_mode");
1883}
1884
1885/* sysfs hotkey report_mode -------------------------------------------- */
1886static ssize_t hotkey_report_mode_show(struct device *dev,
1887                           struct device_attribute *attr,
1888                           char *buf)
1889{
1890        return snprintf(buf, PAGE_SIZE, "%d\n",
1891                (hotkey_report_mode != 0) ? hotkey_report_mode : 1);
1892}
1893
1894static struct device_attribute dev_attr_hotkey_report_mode =
1895        __ATTR(hotkey_report_mode, S_IRUGO, hotkey_report_mode_show, NULL);
1896
1897/* sysfs wakeup reason (pollable) -------------------------------------- */
1898static ssize_t hotkey_wakeup_reason_show(struct device *dev,
1899                           struct device_attribute *attr,
1900                           char *buf)
1901{
1902        return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_wakeup_reason);
1903}
1904
1905static struct device_attribute dev_attr_hotkey_wakeup_reason =
1906        __ATTR(wakeup_reason, S_IRUGO, hotkey_wakeup_reason_show, NULL);
1907
1908static void hotkey_wakeup_reason_notify_change(void)
1909{
1910        if (tp_features.hotkey_mask)
1911                sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
1912                             "wakeup_reason");
1913}
1914
1915/* sysfs wakeup hotunplug_complete (pollable) -------------------------- */
1916static ssize_t hotkey_wakeup_hotunplug_complete_show(struct device *dev,
1917                           struct device_attribute *attr,
1918                           char *buf)
1919{
1920        return snprintf(buf, PAGE_SIZE, "%d\n", hotkey_autosleep_ack);
1921}
1922
1923static struct device_attribute dev_attr_hotkey_wakeup_hotunplug_complete =
1924        __ATTR(wakeup_hotunplug_complete, S_IRUGO,
1925               hotkey_wakeup_hotunplug_complete_show, NULL);
1926
1927static void hotkey_wakeup_hotunplug_complete_notify_change(void)
1928{
1929        if (tp_features.hotkey_mask)
1930                sysfs_notify(&tpacpi_pdev->dev.kobj, NULL,
1931                             "wakeup_hotunplug_complete");
1932}
1933
1934/* --------------------------------------------------------------------- */
1935
1936static struct attribute *hotkey_attributes[] __initdata = {
1937        &dev_attr_hotkey_enable.attr,
1938        &dev_attr_hotkey_bios_enabled.attr,
1939        &dev_attr_hotkey_report_mode.attr,
1940#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1941        &dev_attr_hotkey_mask.attr,
1942        &dev_attr_hotkey_all_mask.attr,
1943        &dev_attr_hotkey_recommended_mask.attr,
1944        &dev_attr_hotkey_source_mask.attr,
1945        &dev_attr_hotkey_poll_freq.attr,
1946#endif
1947};
1948
1949static struct attribute *hotkey_mask_attributes[] __initdata = {
1950        &dev_attr_hotkey_bios_mask.attr,
1951#ifndef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1952        &dev_attr_hotkey_mask.attr,
1953        &dev_attr_hotkey_all_mask.attr,
1954        &dev_attr_hotkey_recommended_mask.attr,
1955#endif
1956        &dev_attr_hotkey_wakeup_reason.attr,
1957        &dev_attr_hotkey_wakeup_hotunplug_complete.attr,
1958};
1959
1960static void bluetooth_update_rfk(void);
1961static void wan_update_rfk(void);
1962static void tpacpi_send_radiosw_update(void)
1963{
1964        int wlsw;
1965
1966        /* Sync these BEFORE sending any rfkill events */
1967        if (tp_features.bluetooth)
1968                bluetooth_update_rfk();
1969        if (tp_features.wan)
1970                wan_update_rfk();
1971
1972        if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&wlsw)) {
1973                mutex_lock(&tpacpi_inputdev_send_mutex);
1974
1975                input_report_switch(tpacpi_inputdev,
1976                                    SW_RFKILL_ALL, !!wlsw);
1977                input_sync(tpacpi_inputdev);
1978
1979                mutex_unlock(&tpacpi_inputdev_send_mutex);
1980        }
1981        hotkey_radio_sw_notify_change();
1982}
1983
1984static void hotkey_exit(void)
1985{
1986#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
1987        hotkey_poll_stop_sync();
1988#endif
1989
1990        if (hotkey_dev_attributes)
1991                delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
1992
1993        kfree(hotkey_keycode_map);
1994
1995        if (tp_features.hotkey) {
1996                dbg_printk(TPACPI_DBG_EXIT,
1997                           "restoring original hot key mask\n");
1998                /* no short-circuit boolean operator below! */
1999                if ((hotkey_mask_set(hotkey_orig_mask) |
2000                     hotkey_status_set(hotkey_orig_status)) != 0)
2001                        printk(TPACPI_ERR
2002                               "failed to restore hot key mask "
2003                               "to BIOS defaults\n");
2004        }
2005}
2006
2007static int __init hotkey_init(struct ibm_init_struct *iibm)
2008{
2009        /* Requirements for changing the default keymaps:
2010         *
2011         * 1. Many of the keys are mapped to KEY_RESERVED for very
2012         *    good reasons.  Do not change them unless you have deep
2013         *    knowledge on the IBM and Lenovo ThinkPad firmware for
2014         *    the various ThinkPad models.  The driver behaves
2015         *    differently for KEY_RESERVED: such keys have their
2016         *    hot key mask *unset* in mask_recommended, and also
2017         *    in the initial hot key mask programmed into the
2018         *    firmware at driver load time, which means the firm-
2019         *    ware may react very differently if you change them to
2020         *    something else;
2021         *
2022         * 2. You must be subscribed to the linux-thinkpad and
2023         *    ibm-acpi-devel mailing lists, and you should read the
2024         *    list archives since 2007 if you want to change the
2025         *    keymaps.  This requirement exists so that you will
2026         *    know the past history of problems with the thinkpad-
2027         *    acpi driver keymaps, and also that you will be
2028         *    listening to any bug reports;
2029         *
2030         * 3. Do not send thinkpad-acpi specific patches directly to
2031         *    for merging, *ever*.  Send them to the linux-acpi
2032         *    mailinglist for comments.  Merging is to be done only
2033         *    through acpi-test and the ACPI maintainer.
2034         *
2035         * If the above is too much to ask, don't change the keymap.
2036         * Ask the thinkpad-acpi maintainer to do it, instead.
2037         */
2038        static u16 ibm_keycode_map[] __initdata = {
2039                /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
2040                KEY_FN_F1,      KEY_FN_F2,      KEY_COFFEE,     KEY_SLEEP,
2041                KEY_WLAN,       KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
2042                KEY_FN_F9,      KEY_FN_F10,     KEY_FN_F11,     KEY_SUSPEND,
2043
2044                /* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */
2045                KEY_UNKNOWN,    /* 0x0C: FN+BACKSPACE */
2046                KEY_UNKNOWN,    /* 0x0D: FN+INSERT */
2047                KEY_UNKNOWN,    /* 0x0E: FN+DELETE */
2048
2049                /* brightness: firmware always reacts to them, unless
2050                 * X.org did some tricks in the radeon BIOS scratch
2051                 * registers of *some* models */
2052                KEY_RESERVED,   /* 0x0F: FN+HOME (brightness up) */
2053                KEY_RESERVED,   /* 0x10: FN+END (brightness down) */
2054
2055                /* Thinklight: firmware always react to it */
2056                KEY_RESERVED,   /* 0x11: FN+PGUP (thinklight toggle) */
2057
2058                KEY_UNKNOWN,    /* 0x12: FN+PGDOWN */
2059                KEY_ZOOM,       /* 0x13: FN+SPACE (zoom) */
2060
2061                /* Volume: firmware always react to it and reprograms
2062                 * the built-in *extra* mixer.  Never map it to control
2063                 * another mixer by default. */
2064                KEY_RESERVED,   /* 0x14: VOLUME UP */
2065                KEY_RESERVED,   /* 0x15: VOLUME DOWN */
2066                KEY_RESERVED,   /* 0x16: MUTE */
2067
2068                KEY_VENDOR,     /* 0x17: Thinkpad/AccessIBM/Lenovo */
2069
2070                /* (assignments unknown, please report if found) */
2071                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
2072                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
2073        };
2074        static u16 lenovo_keycode_map[] __initdata = {
2075                /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
2076                KEY_FN_F1,      KEY_COFFEE,     KEY_BATTERY,    KEY_SLEEP,
2077                KEY_WLAN,       KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
2078                KEY_FN_F9,      KEY_FN_F10,     KEY_FN_F11,     KEY_SUSPEND,
2079
2080                /* Scan codes 0x0C to 0x1F: Other ACPI HKEY hot keys */
2081                KEY_UNKNOWN,    /* 0x0C: FN+BACKSPACE */
2082                KEY_UNKNOWN,    /* 0x0D: FN+INSERT */
2083                KEY_UNKNOWN,    /* 0x0E: FN+DELETE */
2084
2085                /* These either have to go through ACPI video, or
2086                 * act like in the IBM ThinkPads, so don't ever
2087                 * enable them by default */
2088                KEY_RESERVED,   /* 0x0F: FN+HOME (brightness up) */
2089                KEY_RESERVED,   /* 0x10: FN+END (brightness down) */
2090
2091                KEY_RESERVED,   /* 0x11: FN+PGUP (thinklight toggle) */
2092
2093                KEY_UNKNOWN,    /* 0x12: FN+PGDOWN */
2094                KEY_ZOOM,       /* 0x13: FN+SPACE (zoom) */
2095
2096                /* Volume: z60/z61, T60 (BIOS version?): firmware always
2097                 * react to it and reprograms the built-in *extra* mixer.
2098                 * Never map it to control another mixer by default.
2099                 *
2100                 * T60?, T61, R60?, R61: firmware and EC tries to send
2101                 * these over the regular keyboard, so these are no-ops,
2102                 * but there are still weird bugs re. MUTE, so do not
2103                 * change unless you get test reports from all Lenovo
2104                 * models.  May cause the BIOS to interfere with the
2105                 * HDA mixer.
2106                 */
2107                KEY_RESERVED,   /* 0x14: VOLUME UP */
2108                KEY_RESERVED,   /* 0x15: VOLUME DOWN */
2109                KEY_RESERVED,   /* 0x16: MUTE */
2110
2111                KEY_VENDOR,     /* 0x17: Thinkpad/AccessIBM/Lenovo */
2112
2113                /* (assignments unknown, please report if found) */
2114                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
2115                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
2116        };
2117
2118#define TPACPI_HOTKEY_MAP_LEN           ARRAY_SIZE(ibm_keycode_map)
2119#define TPACPI_HOTKEY_MAP_SIZE          sizeof(ibm_keycode_map)
2120#define TPACPI_HOTKEY_MAP_TYPESIZE      sizeof(ibm_keycode_map[0])
2121
2122        int res, i;
2123        int status;
2124        int hkeyv;
2125
2126        vdbg_printk(TPACPI_DBG_INIT, "initializing hotkey subdriver\n");
2127
2128        BUG_ON(!tpacpi_inputdev);
2129        BUG_ON(tpacpi_inputdev->open != NULL ||
2130               tpacpi_inputdev->close != NULL);
2131
2132        TPACPI_ACPIHANDLE_INIT(hkey);
2133        mutex_init(&hotkey_mutex);
2134
2135#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2136        mutex_init(&hotkey_thread_mutex);
2137        mutex_init(&hotkey_thread_data_mutex);
2138#endif
2139
2140        /* hotkey not supported on 570 */
2141        tp_features.hotkey = hkey_handle != NULL;
2142
2143        vdbg_printk(TPACPI_DBG_INIT, "hotkeys are %s\n",
2144                str_supported(tp_features.hotkey));
2145
2146        if (!tp_features.hotkey)
2147                return 1;
2148
2149        tpacpi_disable_brightness_delay();
2150
2151        hotkey_dev_attributes = create_attr_set(13, NULL);
2152        if (!hotkey_dev_attributes)
2153                return -ENOMEM;
2154        res = add_many_to_attr_set(hotkey_dev_attributes,
2155                        hotkey_attributes,
2156                        ARRAY_SIZE(hotkey_attributes));
2157        if (res)
2158                goto err_exit;
2159
2160        /* mask not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
2161           A30, R30, R31, T20-22, X20-21, X22-24.  Detected by checking
2162           for HKEY interface version 0x100 */
2163        if (acpi_evalf(hkey_handle, &hkeyv, "MHKV", "qd")) {
2164                if ((hkeyv >> 8) != 1) {
2165                        printk(TPACPI_ERR "unknown version of the "
2166                               "HKEY interface: 0x%x\n", hkeyv);
2167                        printk(TPACPI_ERR "please report this to %s\n",
2168                               TPACPI_MAIL);
2169                } else {
2170                        /*
2171                         * MHKV 0x100 in A31, R40, R40e,
2172                         * T4x, X31, and later
2173                         */
2174                        tp_features.hotkey_mask = 1;
2175                }
2176        }
2177
2178        vdbg_printk(TPACPI_DBG_INIT, "hotkey masks are %s\n",
2179                str_supported(tp_features.hotkey_mask));
2180
2181        if (tp_features.hotkey_mask) {
2182                if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
2183                                "MHKA", "qd")) {
2184                        printk(TPACPI_ERR
2185                               "missing MHKA handler, "
2186                               "please report this to %s\n",
2187                               TPACPI_MAIL);
2188                        /* FN+F12, FN+F4, FN+F3 */
2189                        hotkey_all_mask = 0x080cU;
2190                }
2191        }
2192
2193        /* hotkey_source_mask *must* be zero for
2194         * the first hotkey_mask_get */
2195        res = hotkey_status_get(&hotkey_orig_status);
2196        if (res)
2197                goto err_exit;
2198
2199        if (tp_features.hotkey_mask) {
2200                res = hotkey_mask_get();
2201                if (res)
2202                        goto err_exit;
2203
2204                hotkey_orig_mask = hotkey_mask;
2205                res = add_many_to_attr_set(
2206                                hotkey_dev_attributes,
2207                                hotkey_mask_attributes,
2208                                ARRAY_SIZE(hotkey_mask_attributes));
2209                if (res)
2210                        goto err_exit;
2211        }
2212
2213#ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
2214        if (tp_features.hotkey_mask) {
2215                hotkey_source_mask = TPACPI_HKEY_NVRAM_GOOD_MASK
2216                                        & ~hotkey_all_mask;
2217        } else {
2218                hotkey_source_mask = TPACPI_HKEY_NVRAM_GOOD_MASK;
2219        }
2220
2221        vdbg_printk(TPACPI_DBG_INIT,
2222                    "hotkey source mask 0x%08x, polling freq %d\n",
2223                    hotkey_source_mask, hotkey_poll_freq);
2224#endif
2225
2226        /* Not all thinkpads have a hardware radio switch */
2227        if (acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
2228                tp_features.hotkey_wlsw = 1;
2229                printk(TPACPI_INFO
2230                        "radio switch found; radios are %s\n",
2231                        enabled(status, 0));
2232        }
2233        if (tp_features.hotkey_wlsw)
2234                res = add_to_attr_set(hotkey_dev_attributes,
2235                                &dev_attr_hotkey_radio_sw.attr);
2236
2237        /* For X41t, X60t, X61t Tablets... */
2238        if (!res && acpi_evalf(hkey_handle, &status, "MHKG", "qd")) {
2239                tp_features.hotkey_tablet = 1;
2240                printk(TPACPI_INFO
2241                        "possible tablet mode switch found; "
2242                        "ThinkPad in %s mode\n",
2243                        (status & TP_HOTKEY_TABLET_MASK)?
2244                                "tablet" : "laptop");
2245                res = add_to_attr_set(hotkey_dev_attributes,
2246                                &dev_attr_hotkey_tablet_mode.attr);
2247        }
2248
2249        if (!res)
2250                res = register_attr_set_with_sysfs(
2251                                hotkey_dev_attributes,
2252                                &tpacpi_pdev->dev.kobj);
2253        if (res)
2254                goto err_exit;
2255
2256        /* Set up key map */
2257
2258        hotkey_keycode_map = kmalloc(TPACPI_HOTKEY_MAP_SIZE,
2259                                        GFP_KERNEL);
2260        if (!hotkey_keycode_map) {
2261                printk(TPACPI_ERR
2262                        "failed to allocate memory for key map\n");
2263                res = -ENOMEM;
2264                goto err_exit;
2265        }
2266
2267        if (thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO) {
2268                dbg_printk(TPACPI_DBG_INIT,
2269                           "using Lenovo default hot key map\n");
2270                memcpy(hotkey_keycode_map, &lenovo_keycode_map,
2271                        TPACPI_HOTKEY_MAP_SIZE);
2272        } else {
2273                dbg_printk(TPACPI_DBG_INIT,
2274                           "using IBM default hot key map\n");
2275                memcpy(hotkey_keycode_map, &ibm_keycode_map,
2276                        TPACPI_HOTKEY_MAP_SIZE);
2277        }
2278
2279        set_bit(EV_KEY, tpacpi_inputdev->evbit);
2280        set_bit(EV_MSC, tpacpi_inputdev->evbit);
2281        set_bit(MSC_SCAN, tpacpi_inputdev->mscbit);
2282        tpacpi_inputdev->keycodesize = TPACPI_HOTKEY_MAP_TYPESIZE;
2283        tpacpi_inputdev->keycodemax = TPACPI_HOTKEY_MAP_LEN;
2284        tpacpi_inputdev->keycode = hotkey_keycode_map;
2285        for (i = 0; i < TPACPI_HOTKEY_MAP_LEN; i++) {
2286                if (hotkey_keycode_map[i] != KEY_RESERVED) {
2287                        set_bit(hotkey_keycode_map[i],
2288                                tpacpi_inputdev->keybit);
2289                } else {
2290                        if (i < sizeof(hotkey_reserved_mask)*8)
2291                                hotkey_reserved_mask |= 1 << i;
2292                }
2293        }
2294
2295        if (tp_features.hotkey_wlsw) {
2296                set_bit(EV_SW, tpacpi_inputdev->evbit);
2297                set_bit(SW_RFKILL_ALL, tpacpi_inputdev->swbit);
2298        }
2299        if (tp_features.hotkey_tablet) {
2300                set_bit(EV_SW, tpacpi_inputdev->evbit);
2301                set_bit(SW_TABLET_MODE, tpacpi_inputdev->swbit);
2302        }
2303
2304        /* Do not issue duplicate brightness change events to
2305         * userspace */
2306        if (!tp_features.bright_acpimode)
2307                /* update bright_acpimode... */
2308                tpacpi_check_std_acpi_brightness_support();
2309
2310        if (tp_features.bright_acpimode) {
2311                printk(TPACPI_INFO
2312                       "This ThinkPad has standard ACPI backlight "
2313                       "brightness control, supported by the ACPI "
2314                       "video driver\n");
2315                printk(TPACPI_NOTICE
2316                       "Disabling thinkpad-acpi brightness events "
2317                       "by default...\n");
2318
2319                /* The hotkey_reserved_mask change below is not
2320                 * necessary while the keys are at KEY_RESERVED in the
2321                 * default map, but better safe than sorry, leave it
2322                 * here as a marker of what we have to do, especially
2323                 * when we finally become able to set this at runtime
2324                 * on response to X.org requests */
2325                hotkey_reserved_mask |=
2326                        (1 << TP_ACPI_HOTKEYSCAN_FNHOME)
2327                        | (1 << TP_ACPI_HOTKEYSCAN_FNEND);
2328        }
2329
2330        dbg_printk(TPACPI_DBG_INIT, "enabling hot key handling\n");
2331        res = hotkey_status_set(1);
2332        if (res) {
2333                hotkey_exit();
2334                return res;
2335        }
2336        res = hotkey_mask_set(((hotkey_all_mask | hotkey_source_mask)
2337                                & ~hotkey_reserved_mask)
2338                                | hotkey_orig_mask);
2339        if (res < 0 && res != -ENXIO) {
2340                hotkey_exit();
2341                return res;
2342        }
2343
2344        dbg_printk(TPACPI_DBG_INIT,
2345                        "legacy hot key reporting over procfs %s\n",
2346                        (hotkey_report_mode < 2) ?
2347                                "enabled" : "disabled");
2348
2349        tpacpi_inputdev->open = &hotkey_inputdev_open;
2350        tpacpi_inputdev->close = &hotkey_inputdev_close;
2351
2352        hotkey_poll_setup_safe(1);
2353        tpacpi_send_radiosw_update();
2354        tpacpi_input_send_tabletsw();
2355
2356        return 0;
2357
2358err_exit:
2359        delete_attr_set(hotkey_dev_attributes, &tpacpi_pdev->dev.kobj);
2360        hotkey_dev_attributes = NULL;
2361
2362        return (res < 0)? res : 1;
2363}
2364
2365static void hotkey_notify(struct ibm_struct *ibm, u32 event)
2366{
2367        u32 hkey;
2368        unsigned int scancode;
2369        int send_acpi_ev;
2370        int ignore_acpi_ev;
2371        int unk_ev;
2372
2373        if (event != 0x80) {
2374                printk(TPACPI_ERR
2375                       "unknown HKEY notification event %d\n", event);
2376                /* forward it to userspace, maybe it knows how to handle it */
2377                acpi_bus_generate_netlink_event(
2378                                        ibm->acpi->device->pnp.device_class,
2379                                        ibm->acpi->device->dev.bus_id,
2380                                        event, 0);
2381                return;
2382        }
2383
2384        while (1) {
2385                if (!acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
2386                        printk(TPACPI_ERR "failed to retrieve HKEY event\n");
2387                        return;
2388                }
2389
2390                if (hkey == 0) {
2391                        /* queue empty */
2392                        return;
2393                }
2394
2395                send_acpi_ev = 1;
2396                ignore_acpi_ev = 0;
2397                unk_ev = 0;
2398
2399                switch (hkey >> 12) {
2400                case 1:
2401                        /* 0x1000-0x1FFF: key presses */
2402                        scancode = hkey & 0xfff;
2403                        if (scancode > 0 && scancode < 0x21) {
2404                                scancode--;
2405                                if (!(hotkey_source_mask & (1 << scancode))) {
2406                                        tpacpi_input_send_key(scancode);
2407                                        send_acpi_ev = 0;
2408                                } else {
2409                                        ignore_acpi_ev = 1;
2410                                }
2411                        } else {
2412                                unk_ev = 1;
2413                        }
2414                        break;
2415                case 2:
2416                        /* Wakeup reason */
2417                        switch (hkey) {
2418                        case 0x2304: /* suspend, undock */
2419                        case 0x2404: /* hibernation, undock */
2420                                hotkey_wakeup_reason = TP_ACPI_WAKEUP_UNDOCK;
2421                                ignore_acpi_ev = 1;
2422                                break;
2423                        case 0x2305: /* suspend, bay eject */
2424                        case 0x2405: /* hibernation, bay eject */
2425                                hotkey_wakeup_reason = TP_ACPI_WAKEUP_BAYEJ;
2426                                ignore_acpi_ev = 1;
2427                                break;
2428                        default:
2429                                unk_ev = 1;
2430                        }
2431                        if (hotkey_wakeup_reason != TP_ACPI_WAKEUP_NONE) {
2432                                printk(TPACPI_INFO
2433                                       "woke up due to a hot-unplug "
2434                                       "request...\n");
2435                                hotkey_wakeup_reason_notify_change();
2436                        }
2437                        break;
2438                case 3:
2439                        /* bay-related wakeups */
2440                        if (hkey == 0x3003) {
2441                                hotkey_autosleep_ack = 1;
2442                                printk(TPACPI_INFO
2443                                       "bay ejected\n");
2444                                hotkey_wakeup_hotunplug_complete_notify_change();
2445                        } else {
2446                                unk_ev = 1;
2447                        }
2448                        break;
2449                case 4:
2450                        /* dock-related wakeups */
2451                        if (hkey == 0x4003) {
2452                                hotkey_autosleep_ack = 1;
2453                                printk(TPACPI_INFO
2454                                       "undocked\n");
2455                                hotkey_wakeup_hotunplug_complete_notify_change();
2456                        } else {
2457                                unk_ev = 1;
2458                        }
2459                        break;
2460                case 5:
2461                        /* 0x5000-0x5FFF: human interface helpers */
2462                        switch (hkey) {
2463                        case 0x5010: /* Lenovo new BIOS: brightness changed */
2464                        case 0x500b: /* X61t: tablet pen inserted into bay */
2465                        case 0x500c: /* X61t: tablet pen removed from bay */
2466                                break;
2467                        case 0x5009: /* X41t-X61t: swivel up (tablet mode) */
2468                        case 0x500a: /* X41t-X61t: swivel down (normal mode) */
2469                                tpacpi_input_send_tabletsw();
2470                                hotkey_tablet_mode_notify_change();
2471                                send_acpi_ev = 0;
2472                                break;
2473                        case 0x5001:
2474                        case 0x5002:
2475                                /* LID switch events.  Do not propagate */
2476                                ignore_acpi_ev = 1;
2477                                break;
2478                        default:
2479                                unk_ev = 1;
2480                        }
2481                        break;
2482                case 7:
2483                        /* 0x7000-0x7FFF: misc */
2484                        if (tp_features.hotkey_wlsw && hkey == 0x7000) {
2485                                tpacpi_send_radiosw_update();
2486                                send_acpi_ev = 0;
2487                                break;
2488                        }
2489                        /* fallthrough to default */
2490                default:
2491                        unk_ev = 1;
2492                }
2493                if (unk_ev) {
2494                        printk(TPACPI_NOTICE
2495                               "unhandled HKEY event 0x%04x\n", hkey);
2496                }
2497
2498                /* Legacy events */
2499                if (!ignore_acpi_ev &&
2500                    (send_acpi_ev || hotkey_report_mode < 2)) {
2501                        acpi_bus_generate_proc_event(ibm->acpi->device,
2502                                                     event, hkey);
2503                }
2504
2505                /* netlink events */
2506                if (!ignore_acpi_ev && send_acpi_ev) {
2507                        acpi_bus_generate_netlink_event(
2508                                        ibm->acpi->device->pnp.device_class,
2509                                        ibm->acpi->device->dev.bus_id,
2510                                        event, hkey);
2511                }
2512        }
2513}
2514
2515static void hotkey_suspend(pm_message_t state)
2516{
2517        /* Do these on suspend, we get the events on early resume! */
2518        hotkey_wakeup_reason = TP_ACPI_WAKEUP_NONE;
2519        hotkey_autosleep_ack = 0;
2520}
2521
2522static void hotkey_resume(void)
2523{
2524        tpacpi_disable_brightness_delay();
2525
2526        if (hotkey_mask_get())
2527                printk(TPACPI_ERR
2528                       "error while trying to read hot key mask "
2529                       "from firmware\n");
2530        tpacpi_send_radiosw_update();
2531        hotkey_tablet_mode_notify_change();
2532        hotkey_wakeup_reason_notify_change();
2533        hotkey_wakeup_hotunplug_complete_notify_change();
2534        hotkey_poll_setup_safe(0);
2535}
2536
2537/* procfs -------------------------------------------------------------- */
2538static int hotkey_read(char *p)
2539{
2540        int res, status;
2541        int len = 0;
2542
2543        if (!tp_features.hotkey) {
2544                len += sprintf(p + len, "status:\t\tnot supported\n");
2545                return len;
2546        }
2547
2548        if (mutex_lock_interruptible(&hotkey_mutex))
2549                return -ERESTARTSYS;
2550        res = hotkey_status_get(&status);
2551        if (!res)
2552                res = hotkey_mask_get();
2553        mutex_unlock(&hotkey_mutex);
2554        if (res)
2555                return res;
2556
2557        len += sprintf(p + len, "status:\t\t%s\n", enabled(status, 0));
2558        if (tp_features.hotkey_mask) {
2559                len += sprintf(p + len, "mask:\t\t0x%08x\n", hotkey_mask);
2560                len += sprintf(p + len,
2561                               "commands:\tenable, disable, reset, <mask>\n");
2562        } else {
2563                len += sprintf(p + len, "mask:\t\tnot supported\n");
2564                len += sprintf(p + len, "commands:\tenable, disable, reset\n");
2565        }
2566
2567        return len;
2568}
2569
2570static int hotkey_write(char *buf)
2571{
2572        int res, status;
2573        u32 mask;
2574        char *cmd;
2575
2576        if (!tp_features.hotkey)
2577                return -ENODEV;
2578
2579        if (mutex_lock_interruptible(&hotkey_mutex))
2580                return -ERESTARTSYS;
2581
2582        status = -1;
2583        mask = hotkey_mask;
2584
2585        res = 0;
2586        while ((cmd = next_cmd(&buf))) {
2587                if (strlencmp(cmd, "enable") == 0) {
2588                        status = 1;
2589                } else if (strlencmp(cmd, "disable") == 0) {
2590                        status = 0;
2591                } else if (strlencmp(cmd, "reset") == 0) {
2592                        status = hotkey_orig_status;
2593                        mask = hotkey_orig_mask;
2594                } else if (sscanf(cmd, "0x%x", &mask) == 1) {
2595                        /* mask set */
2596                } else if (sscanf(cmd, "%x", &mask) == 1) {
2597                        /* mask set */
2598                } else {
2599                        res = -EINVAL;
2600                        goto errexit;
2601                }
2602        }
2603        if (status != -1)
2604                res = hotkey_status_set(status);
2605
2606        if (!res && mask != hotkey_mask)
2607                res = hotkey_mask_set(mask);
2608
2609errexit:
2610        mutex_unlock(&hotkey_mutex);
2611        return res;
2612}
2613
2614static const struct acpi_device_id ibm_htk_device_ids[] = {
2615        {TPACPI_ACPI_HKEY_HID, 0},
2616        {"", 0},
2617};
2618
2619static struct tp_acpi_drv_struct ibm_hotkey_acpidriver = {
2620        .hid = ibm_htk_device_ids,
2621        .notify = hotkey_notify,
2622        .handle = &hkey_handle,
2623        .type = ACPI_DEVICE_NOTIFY,
2624};
2625
2626static struct ibm_struct hotkey_driver_data = {
2627        .name = "hotkey",
2628        .read = hotkey_read,
2629        .write = hotkey_write,
2630        .exit = hotkey_exit,
2631        .resume = hotkey_resume,
2632        .suspend = hotkey_suspend,
2633        .acpi = &ibm_hotkey_acpidriver,
2634};
2635
2636/*************************************************************************
2637 * Bluetooth subdriver
2638 */
2639
2640enum {
2641        /* ACPI GBDC/SBDC bits */
2642        TP_ACPI_BLUETOOTH_HWPRESENT     = 0x01, /* Bluetooth hw available */
2643        TP_ACPI_BLUETOOTH_RADIOSSW      = 0x02, /* Bluetooth radio enabled */
2644        TP_ACPI_BLUETOOTH_UNK           = 0x04, /* unknown function */
2645};
2646
2647static struct rfkill *tpacpi_bluetooth_rfkill;
2648
2649static int bluetooth_get_radiosw(void)
2650{
2651        int status;
2652
2653        if (!tp_features.bluetooth)
2654                return -ENODEV;
2655
2656        /* WLSW overrides bluetooth in firmware/hardware, reflect that */
2657        if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status)
2658                return RFKILL_STATE_HARD_BLOCKED;
2659
2660        if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
2661                return -EIO;
2662
2663        return ((status & TP_ACPI_BLUETOOTH_RADIOSSW) != 0) ?
2664                RFKILL_STATE_UNBLOCKED : RFKILL_STATE_SOFT_BLOCKED;
2665}
2666
2667static void bluetooth_update_rfk(void)
2668{
2669        int status;
2670
2671        if (!tpacpi_bluetooth_rfkill)
2672                return;
2673
2674        status = bluetooth_get_radiosw();
2675        if (status < 0)
2676                return;
2677        rfkill_force_state(tpacpi_bluetooth_rfkill, status);
2678}
2679
2680static int bluetooth_set_radiosw(int radio_on, int update_rfk)
2681{
2682        int status;
2683
2684        if (!tp_features.bluetooth)
2685                return -ENODEV;
2686
2687        /* WLSW overrides bluetooth in firmware/hardware, but there is no
2688         * reason to risk weird behaviour. */
2689        if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status
2690            && radio_on)
2691                return -EPERM;
2692
2693        if (!acpi_evalf(hkey_handle, &status, "GBDC", "d"))
2694                return -EIO;
2695        if (radio_on)
2696                status |= TP_ACPI_BLUETOOTH_RADIOSSW;
2697        else
2698                status &= ~TP_ACPI_BLUETOOTH_RADIOSSW;
2699        if (!acpi_evalf(hkey_handle, NULL, "SBDC", "vd", status))
2700                return -EIO;
2701
2702        if (update_rfk)
2703                bluetooth_update_rfk();
2704
2705        return 0;
2706}
2707
2708/* sysfs bluetooth enable ---------------------------------------------- */
2709static ssize_t bluetooth_enable_show(struct device *dev,
2710                           struct device_attribute *attr,
2711                           char *buf)
2712{
2713        int status;
2714
2715        status = bluetooth_get_radiosw();
2716        if (status < 0)
2717                return status;
2718
2719        return snprintf(buf, PAGE_SIZE, "%d\n",
2720                        (status == RFKILL_STATE_UNBLOCKED) ? 1 : 0);
2721}
2722
2723static ssize_t bluetooth_enable_store(struct device *dev,
2724                            struct device_attribute *attr,
2725                            const char *buf, size_t count)
2726{
2727        unsigned long t;
2728        int res;
2729
2730        if (parse_strtoul(buf, 1, &t))
2731                return -EINVAL;
2732
2733        res = bluetooth_set_radiosw(t, 1);
2734
2735        return (res) ? res : count;
2736}
2737
2738static struct device_attribute dev_attr_bluetooth_enable =
2739        __ATTR(bluetooth_enable, S_IWUSR | S_IRUGO,
2740                bluetooth_enable_show, bluetooth_enable_store);
2741
2742/* --------------------------------------------------------------------- */
2743
2744static struct attribute *bluetooth_attributes[] = {
2745        &dev_attr_bluetooth_enable.attr,
2746        NULL
2747};
2748
2749static const struct attribute_group bluetooth_attr_group = {
2750        .attrs = bluetooth_attributes,
2751};
2752
2753static int tpacpi_bluetooth_rfk_get(void *data, enum rfkill_state *state)
2754{
2755        int bts = bluetooth_get_radiosw();
2756
2757        if (bts < 0)
2758                return bts;
2759
2760        *state = bts;
2761        return 0;
2762}
2763
2764static int tpacpi_bluetooth_rfk_set(void *data, enum rfkill_state state)
2765{
2766        return bluetooth_set_radiosw((state == RFKILL_STATE_UNBLOCKED), 0);
2767}
2768
2769static void bluetooth_exit(void)
2770{
2771        if (tpacpi_bluetooth_rfkill)
2772                rfkill_unregister(tpacpi_bluetooth_rfkill);
2773
2774        sysfs_remove_group(&tpacpi_pdev->dev.kobj,
2775                        &bluetooth_attr_group);
2776}
2777
2778static int __init bluetooth_init(struct ibm_init_struct *iibm)
2779{
2780        int res;
2781        int status = 0;
2782
2783        vdbg_printk(TPACPI_DBG_INIT, "initializing bluetooth subdriver\n");
2784
2785        TPACPI_ACPIHANDLE_INIT(hkey);
2786
2787        /* bluetooth not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
2788           G4x, R30, R31, R40e, R50e, T20-22, X20-21 */
2789        tp_features.bluetooth = hkey_handle &&
2790            acpi_evalf(hkey_handle, &status, "GBDC", "qd");
2791
2792        vdbg_printk(TPACPI_DBG_INIT, "bluetooth is %s, status 0x%02x\n",
2793                str_supported(tp_features.bluetooth),
2794                status);
2795
2796        if (tp_features.bluetooth &&
2797            !(status & TP_ACPI_BLUETOOTH_HWPRESENT)) {
2798                /* no bluetooth hardware present in system */
2799                tp_features.bluetooth = 0;
2800                dbg_printk(TPACPI_DBG_INIT,
2801                           "bluetooth hardware not installed\n");
2802        }
2803
2804        if (!tp_features.bluetooth)
2805                return 1;
2806
2807        res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
2808                                &bluetooth_attr_group);
2809        if (res)
2810                return res;
2811
2812        res = tpacpi_new_rfkill(TPACPI_RFK_BLUETOOTH_SW_ID,
2813                                &tpacpi_bluetooth_rfkill,
2814                                RFKILL_TYPE_BLUETOOTH,
2815                                "tpacpi_bluetooth_sw",
2816                                tpacpi_bluetooth_rfk_set,
2817                                tpacpi_bluetooth_rfk_get);
2818        if (res) {
2819                bluetooth_exit();
2820                return res;
2821        }
2822
2823        return 0;
2824}
2825
2826/* procfs -------------------------------------------------------------- */
2827static int bluetooth_read(char *p)
2828{
2829        int len = 0;
2830        int status = bluetooth_get_radiosw();
2831
2832        if (!tp_features.bluetooth)
2833                len += sprintf(p + len, "status:\t\tnot supported\n");
2834        else {
2835                len += sprintf(p + len, "status:\t\t%s\n",
2836                                (status == RFKILL_STATE_UNBLOCKED) ?
2837                                        "enabled" : "disabled");
2838                len += sprintf(p + len, "commands:\tenable, disable\n");
2839        }
2840
2841        return len;
2842}
2843
2844static int bluetooth_write(char *buf)
2845{
2846        char *cmd;
2847
2848        if (!tp_features.bluetooth)
2849                return -ENODEV;
2850
2851        while ((cmd = next_cmd(&buf))) {
2852                if (strlencmp(cmd, "enable") == 0) {
2853                        bluetooth_set_radiosw(1, 1);
2854                } else if (strlencmp(cmd, "disable") == 0) {
2855                        bluetooth_set_radiosw(0, 1);
2856                } else
2857                        return -EINVAL;
2858        }
2859
2860        return 0;
2861}
2862
2863static struct ibm_struct bluetooth_driver_data = {
2864        .name = "bluetooth",
2865        .read = bluetooth_read,
2866        .write = bluetooth_write,
2867        .exit = bluetooth_exit,
2868};
2869
2870/*************************************************************************
2871 * Wan subdriver
2872 */
2873
2874enum {
2875        /* ACPI GWAN/SWAN bits */
2876        TP_ACPI_WANCARD_HWPRESENT       = 0x01, /* Wan hw available */
2877        TP_ACPI_WANCARD_RADIOSSW        = 0x02, /* Wan radio enabled */
2878        TP_ACPI_WANCARD_UNK             = 0x04, /* unknown function */
2879};
2880
2881static struct rfkill *tpacpi_wan_rfkill;
2882
2883static int wan_get_radiosw(void)
2884{
2885        int status;
2886
2887        if (!tp_features.wan)
2888                return -ENODEV;
2889
2890        /* WLSW overrides WWAN in firmware/hardware, reflect that */
2891        if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status)
2892                return RFKILL_STATE_HARD_BLOCKED;
2893
2894        if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
2895                return -EIO;
2896
2897        return ((status & TP_ACPI_WANCARD_RADIOSSW) != 0) ?
2898                RFKILL_STATE_UNBLOCKED : RFKILL_STATE_SOFT_BLOCKED;
2899}
2900
2901static void wan_update_rfk(void)
2902{
2903        int status;
2904
2905        if (!tpacpi_wan_rfkill)
2906                return;
2907
2908        status = wan_get_radiosw();
2909        if (status < 0)
2910                return;
2911        rfkill_force_state(tpacpi_wan_rfkill, status);
2912}
2913
2914static int wan_set_radiosw(int radio_on, int update_rfk)
2915{
2916        int status;
2917
2918        if (!tp_features.wan)
2919                return -ENODEV;
2920
2921        /* WLSW overrides bluetooth in firmware/hardware, but there is no
2922         * reason to risk weird behaviour. */
2923        if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&status) && !status
2924            && radio_on)
2925                return -EPERM;
2926
2927        if (!acpi_evalf(hkey_handle, &status, "GWAN", "d"))
2928                return -EIO;
2929        if (radio_on)
2930                status |= TP_ACPI_WANCARD_RADIOSSW;
2931        else
2932                status &= ~TP_ACPI_WANCARD_RADIOSSW;
2933        if (!acpi_evalf(hkey_handle, NULL, "SWAN", "vd", status))
2934                return -EIO;
2935
2936        if (update_rfk)
2937                wan_update_rfk();
2938
2939        return 0;
2940}
2941
2942/* sysfs wan enable ---------------------------------------------------- */
2943static ssize_t wan_enable_show(struct device *dev,
2944                           struct device_attribute *attr,
2945                           char *buf)
2946{
2947        int status;
2948
2949        status = wan_get_radiosw();
2950        if (status < 0)
2951                return status;
2952
2953        return snprintf(buf, PAGE_SIZE, "%d\n",
2954                        (status == RFKILL_STATE_UNBLOCKED) ? 1 : 0);
2955}
2956
2957static ssize_t wan_enable_store(struct device *dev,
2958                            struct device_attribute *attr,
2959                            const char *buf, size_t count)
2960{
2961        unsigned long t;
2962        int res;
2963
2964        if (parse_strtoul(buf, 1, &t))
2965                return -EINVAL;
2966
2967        res = wan_set_radiosw(t, 1);
2968
2969        return (res) ? res : count;
2970}
2971
2972static struct device_attribute dev_attr_wan_enable =
2973        __ATTR(wwan_enable, S_IWUSR | S_IRUGO,
2974                wan_enable_show, wan_enable_store);
2975
2976/* --------------------------------------------------------------------- */
2977
2978static struct attribute *wan_attributes[] = {
2979        &dev_attr_wan_enable.attr,
2980        NULL
2981};
2982
2983static const struct attribute_group wan_attr_group = {
2984        .attrs = wan_attributes,
2985};
2986
2987static int tpacpi_wan_rfk_get(void *data, enum rfkill_state *state)
2988{
2989        int wans = wan_get_radiosw();
2990
2991        if (wans < 0)
2992                return wans;
2993
2994        *state = wans;
2995        return 0;
2996}
2997
2998static int tpacpi_wan_rfk_set(void *data, enum rfkill_state state)
2999{
3000        return wan_set_radiosw((state == RFKILL_STATE_UNBLOCKED), 0);
3001}
3002
3003static void wan_exit(void)
3004{
3005        if (tpacpi_wan_rfkill)
3006                rfkill_unregister(tpacpi_wan_rfkill);
3007
3008        sysfs_remove_group(&tpacpi_pdev->dev.kobj,
3009                &wan_attr_group);
3010}
3011
3012static int __init wan_init(struct ibm_init_struct *iibm)
3013{
3014        int res;
3015        int status = 0;
3016
3017        vdbg_printk(TPACPI_DBG_INIT, "initializing wan subdriver\n");
3018
3019        TPACPI_ACPIHANDLE_INIT(hkey);
3020
3021        tp_features.wan = hkey_handle &&
3022            acpi_evalf(hkey_handle, &status, "GWAN", "qd");
3023
3024        vdbg_printk(TPACPI_DBG_INIT, "wan is %s, status 0x%02x\n",
3025                str_supported(tp_features.wan),
3026                status);
3027
3028        if (tp_features.wan &&
3029            !(status & TP_ACPI_WANCARD_HWPRESENT)) {
3030                /* no wan hardware present in system */
3031                tp_features.wan = 0;
3032                dbg_printk(TPACPI_DBG_INIT,
3033                           "wan hardware not installed\n");
3034        }
3035
3036        if (!tp_features.wan)
3037                return 1;
3038
3039        res = sysfs_create_group(&tpacpi_pdev->dev.kobj,
3040                                &wan_attr_group);
3041        if (res)
3042                return res;
3043
3044        res = tpacpi_new_rfkill(TPACPI_RFK_WWAN_SW_ID,
3045                                &tpacpi_wan_rfkill,
3046                                RFKILL_TYPE_WWAN,
3047                                "tpacpi_wwan_sw",
3048                                tpacpi_wan_rfk_set,
3049                                tpacpi_wan_rfk_get);
3050        if (res) {
3051                wan_exit();
3052                return res;
3053        }
3054
3055        return 0;
3056}
3057
3058/* procfs -------------------------------------------------------------- */
3059static int wan_read(char *p)
3060{
3061        int len = 0;
3062        int status = wan_get_radiosw();
3063
3064        if (!tp_features.wan)
3065                len += sprintf(p + len, "status:\t\tnot supported\n");
3066        else {
3067                len += sprintf(p + len, "status:\t\t%s\n",
3068                                (status == RFKILL_STATE_UNBLOCKED) ?
3069                                        "enabled" : "disabled");
3070                len += sprintf(p + len, "commands:\tenable, disable\n");
3071        }
3072
3073        return len;
3074}
3075
3076static int wan_write(char *buf)
3077{
3078        char *cmd;
3079
3080        if (!tp_features.wan)
3081                return -ENODEV;
3082
3083        while ((cmd = next_cmd(&buf))) {
3084                if (strlencmp(cmd, "enable") == 0) {
3085                        wan_set_radiosw(1, 1);
3086                } else if (strlencmp(cmd, "disable") == 0) {
3087                        wan_set_radiosw(0, 1);
3088                } else
3089                        return -EINVAL;
3090        }
3091
3092        return 0;
3093}
3094
3095static struct ibm_struct wan_driver_data = {
3096        .name = "wan",
3097        .read = wan_read,
3098        .write = wan_write,
3099        .exit = wan_exit,
3100};
3101
3102/*************************************************************************
3103 * Video subdriver
3104 */
3105
3106#ifdef CONFIG_THINKPAD_ACPI_VIDEO
3107
3108enum video_access_mode {
3109        TPACPI_VIDEO_NONE = 0,
3110        TPACPI_VIDEO_570,       /* 570 */
3111        TPACPI_VIDEO_770,       /* 600e/x, 770e, 770x */
3112        TPACPI_VIDEO_NEW,       /* all others */
3113};
3114
3115enum {  /* video status flags, based on VIDEO_570 */
3116        TP_ACPI_VIDEO_S_LCD = 0x01,     /* LCD output enabled */
3117        TP_ACPI_VIDEO_S_CRT = 0x02,     /* CRT output enabled */
3118        TP_ACPI_VIDEO_S_DVI = 0x08,     /* DVI output enabled */
3119};
3120
3121enum {  /* TPACPI_VIDEO_570 constants */
3122        TP_ACPI_VIDEO_570_PHSCMD = 0x87,        /* unknown magic constant :( */
3123        TP_ACPI_VIDEO_570_PHSMASK = 0x03,       /* PHS bits that map to
3124                                                 * video_status_flags */
3125        TP_ACPI_VIDEO_570_PHS2CMD = 0x8b,       /* unknown magic constant :( */
3126        TP_ACPI_VIDEO_570_PHS2SET = 0x80,       /* unknown magic constant :( */
3127};
3128
3129static enum video_access_mode video_supported;
3130static int video_orig_autosw;
3131
3132static int video_autosw_get(void);
3133static int video_autosw_set(int enable);
3134
3135TPACPI_HANDLE(vid2, root, "\\_SB.PCI0.AGPB.VID");       /* G41 */
3136
3137static int __init video_init(struct ibm_init_struct *iibm)
3138{
3139        int ivga;
3140
3141        vdbg_printk(TPACPI_DBG_INIT, "initializing video subdriver\n");
3142
3143        TPACPI_ACPIHANDLE_INIT(vid);
3144        TPACPI_ACPIHANDLE_INIT(vid2);
3145
3146        if (vid2_handle && acpi_evalf(NULL, &ivga, "\\IVGA", "d") && ivga)
3147                /* G41, assume IVGA doesn't change */
3148                vid_handle = vid2_handle;
3149
3150        if (!vid_handle)
3151                /* video switching not supported on R30, R31 */
3152                video_supported = TPACPI_VIDEO_NONE;
3153        else if (acpi_evalf(vid_handle, &video_orig_autosw, "SWIT", "qd"))
3154                /* 570 */
3155                video_supported = TPACPI_VIDEO_570;
3156        else if (acpi_evalf(vid_handle, &video_orig_autosw, "^VADL", "qd"))
3157                /* 600e/x, 770e, 770x */
3158                video_supported = TPACPI_VIDEO_770;
3159        else
3160                /* all others */
3161                video_supported = TPACPI_VIDEO_NEW;
3162
3163        vdbg_printk(TPACPI_DBG_INIT, "video is %s, mode %d\n",
3164                str_supported(video_supported != TPACPI_VIDEO_NONE),
3165                video_supported);
3166
3167        return (video_supported != TPACPI_VIDEO_NONE)? 0 : 1;
3168}
3169
3170static void video_exit(void)
3171{
3172        dbg_printk(TPACPI_DBG_EXIT,
3173                   "restoring original video autoswitch mode\n");
3174        if (video_autosw_set(video_orig_autosw))
3175                printk(TPACPI_ERR "error while trying to restore original "
3176                        "video autoswitch mode\n");
3177}
3178
3179static int video_outputsw_get(void)
3180{
3181        int status = 0;
3182        int i;
3183
3184        switch (video_supported) {
3185        case TPACPI_VIDEO_570:
3186                if (!acpi_evalf(NULL, &i, "\\_SB.PHS", "dd",
3187                                 TP_ACPI_VIDEO_570_PHSCMD))
3188                        return -EIO;
3189                status = i & TP_ACPI_VIDEO_570_PHSMASK;
3190                break;
3191        case TPACPI_VIDEO_770:
3192                if (!acpi_evalf(NULL, &i, "\\VCDL", "d"))
3193                        return -EIO;
3194                if (i)
3195                        status |= TP_ACPI_VIDEO_S_LCD;
3196                if (!acpi_evalf(NULL, &i, "\\VCDC", "d"))
3197                        return -EIO;
3198                if (i)
3199                        status |= TP_ACPI_VIDEO_S_CRT;
3200                break;
3201        case TPACPI_VIDEO_NEW:
3202                if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 1) ||
3203                    !acpi_evalf(NULL, &i, "\\VCDC", "d"))
3204                        return -EIO;
3205                if (i)
3206                        status |= TP_ACPI_VIDEO_S_CRT;
3207
3208                if (!acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0) ||
3209                    !acpi_evalf(NULL, &i, "\\VCDL", "d"))
3210                        return -EIO;
3211                if (i)
3212                        status |= TP_ACPI_VIDEO_S_LCD;
3213                if (!acpi_evalf(NULL, &i, "\\VCDD", "d"))
3214                        return -EIO;
3215                if (i)
3216                        status |= TP_ACPI_VIDEO_S_DVI;
3217                break;
3218        default:
3219                return -ENOSYS;
3220        }
3221
3222        return status;
3223}
3224
3225static int video_outputsw_set(int status)
3226{
3227        int autosw;
3228        int res = 0;
3229
3230        switch (video_supported) {
3231        case TPACPI_VIDEO_570:
3232                res = acpi_evalf(NULL, NULL,
3233                                 "\\_SB.PHS2", "vdd",
3234                                 TP_ACPI_VIDEO_570_PHS2CMD,
3235                                 status | TP_ACPI_VIDEO_570_PHS2SET);
3236                break;
3237        case TPACPI_VIDEO_770:
3238                autosw = video_autosw_get();
3239                if (autosw < 0)
3240                        return autosw;
3241
3242                res = video_autosw_set(1);
3243                if (res)
3244                        return res;
3245                res = acpi_evalf(vid_handle, NULL,
3246                                 "ASWT", "vdd", status * 0x100, 0);
3247                if (!autosw && video_autosw_set(autosw)) {
3248                        printk(TPACPI_ERR
3249                               "video auto-switch left enabled due to error\n");
3250                        return -EIO;
3251                }
3252                break;
3253        case TPACPI_VIDEO_NEW:
3254                res = acpi_evalf(NULL, NULL, "\\VUPS", "vd", 0x80) &&
3255                      acpi_evalf(NULL, NULL, "\\VSDS", "vdd", status, 1);
3256                break;
3257        default:
3258                return -ENOSYS;
3259        }
3260
3261        return (res)? 0 : -EIO;
3262}
3263
3264static int video_autosw_get(void)
3265{
3266        int autosw = 0;
3267
3268        switch (video_supported) {
3269        case TPACPI_VIDEO_570:
3270                if (!acpi_evalf(vid_handle, &autosw, "SWIT", "d"))
3271                        return -EIO;
3272                break;
3273        case TPACPI_VIDEO_770:
3274        case TPACPI_VIDEO_NEW:
3275                if (!acpi_evalf(vid_handle, &autosw, "^VDEE", "d"))
3276                        return -EIO;
3277                break;
3278        default:
3279                return -ENOSYS;
3280        }
3281
3282        return autosw & 1;
3283}
3284
3285static int video_autosw_set(int enable)
3286{
3287        if (!acpi_evalf(vid_handle, NULL, "_DOS", "vd", (enable)? 1 : 0))
3288                return -EIO;
3289        return 0;
3290}
3291
3292static int video_outputsw_cycle(void)
3293{
3294        int autosw = video_autosw_get();
3295        int res;
3296
3297        if (autosw < 0)
3298                return autosw;
3299
3300        switch (video_supported) {
3301        case TPACPI_VIDEO_570:
3302                res = video_autosw_set(1);
3303                if (res)
3304                        return res;
3305                res = acpi_evalf(ec_handle, NULL, "_Q16", "v");
3306                break;
3307        case TPACPI_VIDEO_770:
3308        case TPACPI_VIDEO_NEW:
3309                res = video_autosw_set(1);
3310                if (res)
3311                        return res;
3312                res = acpi_evalf(vid_handle, NULL, "VSWT", "v");
3313                break;
3314        default:
3315                return -ENOSYS;
3316        }
3317        if (!autosw && video_autosw_set(autosw)) {
3318                printk(TPACPI_ERR
3319                       "video auto-switch left enabled due to error\n");
3320                return -EIO;
3321        }
3322
3323        return (res)? 0 : -EIO;
3324}
3325
3326static int video_expand_toggle(void)
3327{
3328        switch (video_supported) {
3329        case TPACPI_VIDEO_570:
3330                return acpi_evalf(ec_handle, NULL, "_Q17", "v")?
3331                        0 : -EIO;
3332        case TPACPI_VIDEO_770:
3333                return acpi_evalf(vid_handle, NULL, "VEXP", "v")?
3334                        0 : -EIO;
3335        case TPACPI_VIDEO_NEW:
3336                return acpi_evalf(NULL, NULL, "\\VEXP", "v")?
3337                        0 : -EIO;
3338        default:
3339                return -ENOSYS;
3340        }
3341        /* not reached */
3342}
3343
3344static int video_read(char *p)
3345{
3346        int status, autosw;
3347        int len = 0;
3348
3349        if (video_supported == TPACPI_VIDEO_NONE) {
3350                len += sprintf(p + len, "status:\t\tnot supported\n");
3351                return len;
3352        }
3353
3354        status = video_outputsw_get();
3355        if (status < 0)
3356                return status;
3357
3358        autosw = video_autosw_get();
3359        if (autosw < 0)
3360                return autosw;
3361
3362        len += sprintf(p + len, "status:\t\tsupported\n");
3363        len += sprintf(p + len, "lcd:\t\t%s\n", enabled(status, 0));
3364        len += sprintf(p + len, "crt:\t\t%s\n", enabled(status, 1));
3365        if (video_supported == TPACPI_VIDEO_NEW)
3366                len += sprintf(p + len, "dvi:\t\t%s\n", enabled(status, 3));
3367        len += sprintf(p + len, "auto:\t\t%s\n", enabled(autosw, 0));
3368        len += sprintf(p + len, "commands:\tlcd_enable, lcd_disable\n");
3369        len += sprintf(p + len, "commands:\tcrt_enable, crt_disable\n");
3370        if (video_supported == TPACPI_VIDEO_NEW)
3371                len += sprintf(p + len, "commands:\tdvi_enable, dvi_disable\n");
3372        len += sprintf(p + len, "commands:\tauto_enable, auto_disable\n");
3373        len += sprintf(p + len, "commands:\tvideo_switch, expand_toggle\n");
3374
3375        return len;
3376}
3377
3378static int video_write(char *buf)
3379{
3380        char *cmd;
3381        int enable, disable, status;
3382        int res;
3383
3384        if (video_supported == TPACPI_VIDEO_NONE)
3385                return -ENODEV;
3386
3387        enable = 0;
3388        disable = 0;
3389
3390        while ((cmd = next_cmd(&buf))) {
3391                if (strlencmp(cmd, "lcd_enable") == 0) {
3392                        enable |= TP_ACPI_VIDEO_S_LCD;
3393                } else if (strlencmp(cmd, "lcd_disable") == 0) {
3394                        disable |= TP_ACPI_VIDEO_S_LCD;
3395                } else if (strlencmp(cmd, "crt_enable") == 0) {
3396                        enable |= TP_ACPI_VIDEO_S_CRT;
3397                } else if (strlencmp(cmd, "crt_disable") == 0) {
3398                        disable |= TP_ACPI_VIDEO_S_CRT;
3399                } else if (video_supported == TPACPI_VIDEO_NEW &&
3400                           strlencmp(cmd, "dvi_enable") == 0) {
3401                        enable |= TP_ACPI_VIDEO_S_DVI;
3402                } else if (video_supported == TPACPI_VIDEO_NEW &&
3403                           strlencmp(cmd, "dvi_disable") == 0) {
3404                        disable |= TP_ACPI_VIDEO_S_DVI;
3405                } else if (strlencmp(cmd, "auto_enable") == 0) {
3406                        res = video_autosw_set(1);
3407                        if (res)
3408                                return res;
3409                } else if (strlencmp(cmd, "auto_disable") == 0) {
3410                        res = video_autosw_set(0);
3411                        if (res)
3412                                return res;
3413                } else if (strlencmp(cmd, "video_switch") == 0) {
3414                        res = video_outputsw_cycle();
3415                        if (res)
3416                                return res;
3417                } else if (strlencmp(cmd, "expand_toggle") == 0) {
3418                        res = video_expand_toggle();
3419                        if (res)
3420                                return res;
3421                } else
3422                        return -EINVAL;
3423        }
3424
3425        if (enable || disable) {
3426                status = video_outputsw_get();
3427                if (status < 0)
3428                        return status;
3429                res = video_outputsw_set((status & ~disable) | enable);
3430                if (res)
3431                        return res;
3432        }
3433
3434        return 0;
3435}
3436
3437static struct ibm_struct video_driver_data = {
3438        .name = "video",
3439        .read = video_read,
3440        .write = video_write,
3441        .exit = video_exit,
3442};
3443
3444#endif /* CONFIG_THINKPAD_ACPI_VIDEO */
3445
3446/*************************************************************************
3447 * Light (thinklight) subdriver
3448 */
3449
3450TPACPI_HANDLE(lght, root, "\\LGHT");    /* A21e, A2xm/p, T20-22, X20-21 */
3451TPACPI_HANDLE(ledb, ec, "LEDB");                /* G4x */
3452
3453static int light_get_status(void)
3454{
3455        int status = 0;
3456
3457        if (tp_features.light_status) {
3458                if (!acpi_evalf(ec_handle, &status, "KBLT", "d"))
3459                        return -EIO;
3460                return (!!status);
3461        }
3462
3463        return -ENXIO;
3464}
3465
3466static int light_set_status(int status)
3467{
3468        int rc;
3469
3470        if (tp_features.light) {
3471                if (cmos_handle) {
3472                        rc = acpi_evalf(cmos_handle, NULL, NULL, "vd",
3473                                        (status)?
3474                                                TP_CMOS_THINKLIGHT_ON :
3475                                                TP_CMOS_THINKLIGHT_OFF);
3476                } else {
3477                        rc = acpi_evalf(lght_handle, NULL, NULL, "vd",
3478                                        (status)? 1 : 0);
3479                }
3480                return (rc)? 0 : -EIO;
3481        }
3482
3483        return -ENXIO;
3484}
3485
3486static void light_set_status_worker(struct work_struct *work)
3487{
3488        struct tpacpi_led_classdev *data =
3489                        container_of(work, struct tpacpi_led_classdev, work);
3490
3491        if (likely(tpacpi_lifecycle == TPACPI_LIFE_RUNNING))
3492                light_set_status((data->new_brightness != LED_OFF));
3493}
3494
3495static void light_sysfs_set(struct led_classdev *led_cdev,
3496                        enum led_brightness brightness)
3497{
3498        struct tpacpi_led_classdev *data =
3499                container_of(led_cdev,
3500                             struct tpacpi_led_classdev,
3501                             led_classdev);
3502        data->new_brightness = brightness;
3503        queue_work(tpacpi_wq, &data->work);
3504}
3505
3506static enum led_brightness light_sysfs_get(struct led_classdev *led_cdev)
3507{
3508        return (light_get_status() == 1)? LED_FULL : LED_OFF;
3509}
3510
3511static struct tpacpi_led_classdev tpacpi_led_thinklight = {
3512        .led_classdev = {
3513                .name           = "tpacpi::thinklight",
3514                .brightness_set = &light_sysfs_set,
3515                .brightness_get = &light_sysfs_get,
3516        }
3517};
3518
3519static int __init light_init(struct ibm_init_struct *iibm)
3520{
3521        int rc;
3522
3523        vdbg_printk(TPACPI_DBG_INIT, "initializing light subdriver\n");
3524
3525        TPACPI_ACPIHANDLE_INIT(ledb);
3526        TPACPI_ACPIHANDLE_INIT(lght);
3527        TPACPI_ACPIHANDLE_INIT(cmos);
3528        INIT_WORK(&tpacpi_led_thinklight.work, light_set_status_worker);
3529
3530        /* light not supported on 570, 600e/x, 770e, 770x, G4x, R30, R31 */
3531        tp_features.light = (cmos_handle || lght_handle) && !ledb_handle;
3532
3533        if (tp_features.light)
3534                /* light status not supported on
3535                   570, 600e/x, 770e, 770x, G4x, R30, R31, R32, X20 */
3536                tp_features.light_status =
3537                        acpi_evalf(ec_handle, NULL, "KBLT", "qv");
3538
3539        vdbg_printk(TPACPI_DBG_INIT, "light is %s, light status is %s\n",
3540                str_supported(tp_features.light),
3541                str_supported(tp_features.light_status));
3542
3543        if (!tp_features.light)
3544                return 1;
3545
3546        rc = led_classdev_register(&tpacpi_pdev->dev,
3547                                   &tpacpi_led_thinklight.led_classdev);
3548
3549        if (rc < 0) {
3550                tp_features.light = 0;
3551                tp_features.light_status = 0;
3552        } else  {
3553                rc = 0;
3554        }
3555
3556        return rc;
3557}
3558
3559static void light_exit(void)
3560{
3561        led_classdev_unregister(&tpacpi_led_thinklight.led_classdev);
3562        if (work_pending(&tpacpi_led_thinklight.work))
3563                flush_workqueue(tpacpi_wq);
3564}
3565
3566static int light_read(char *p)
3567{
3568        int len = 0;
3569        int status;
3570
3571        if (!tp_features.light) {
3572                len += sprintf(p + len, "status:\t\tnot supported\n");
3573        } else if (!tp_features.light_status) {
3574                len += sprintf(p + len, "status:\t\tunknown\n");
3575                len += sprintf(p + len, "commands:\ton, off\n");
3576        } else {
3577                status = light_get_status();
3578                if (status < 0)
3579                        return status;
3580                len += sprintf(p + len, "status:\t\t%s\n", onoff(status, 0));
3581                len += sprintf(p + len, "commands:\ton, off\n");
3582        }
3583
3584        return len;
3585}
3586
3587static int light_write(char *buf)
3588{
3589        char *cmd;
3590        int newstatus = 0;
3591
3592        if (!tp_features.light)
3593                return -ENODEV;
3594
3595        while ((cmd = next_cmd(&buf))) {
3596                if (strlencmp(cmd, "on") == 0) {
3597                        newstatus = 1;
3598                } else if (strlencmp(cmd, "off") == 0) {
3599                        newstatus = 0;
3600                } else
3601                        return -EINVAL;
3602        }
3603
3604        return light_set_status(newstatus);
3605}
3606
3607static struct ibm_struct light_driver_data = {
3608        .name = "light",
3609        .read = light_read,
3610        .write = light_write,
3611        .exit = light_exit,
3612};
3613
3614/*************************************************************************
3615 * Dock subdriver
3616 */
3617
3618#ifdef CONFIG_THINKPAD_ACPI_DOCK
3619
3620static void dock_notify(struct ibm_struct *ibm, u32 event);
3621static int dock_read(char *p);
3622static int dock_write(char *buf);
3623
3624TPACPI_HANDLE(dock, root, "\\_SB.GDCK", /* X30, X31, X40 */
3625           "\\_SB.PCI0.DOCK",   /* 600e/x,770e,770x,A2xm/p,T20-22,X20-21 */
3626           "\\_SB.PCI0.PCI1.DOCK",      /* all others */
3627           "\\_SB.PCI.ISA.SLCE",        /* 570 */
3628    );                          /* A21e,G4x,R30,R31,R32,R40,R40e,R50e */
3629
3630/* don't list other alternatives as we install a notify handler on the 570 */
3631TPACPI_HANDLE(pci, root, "\\_SB.PCI");  /* 570 */
3632
3633static const struct acpi_device_id ibm_pci_device_ids[] = {
3634        {PCI_ROOT_HID_STRING, 0},
3635        {"", 0},
3636};
3637
3638static struct tp_acpi_drv_struct ibm_dock_acpidriver[2] = {
3639        {
3640         .notify = dock_notify,
3641         .handle = &dock_handle,
3642         .type = ACPI_SYSTEM_NOTIFY,
3643        },
3644        {
3645        /* THIS ONE MUST NEVER BE USED FOR DRIVER AUTOLOADING.
3646         * We just use it to get notifications of dock hotplug
3647         * in very old thinkpads */
3648         .hid = ibm_pci_device_ids,
3649         .notify = dock_notify,
3650         .handle = &pci_handle,
3651         .type = ACPI_SYSTEM_NOTIFY,
3652        },
3653};
3654
3655static struct ibm_struct dock_driver_data[2] = {
3656        {
3657         .name = "dock",
3658         .read = dock_read,
3659         .write = dock_write,
3660         .acpi = &ibm_dock_acpidriver[0],
3661        },
3662        {
3663         .name = "dock",
3664         .acpi = &ibm_dock_acpidriver[1],
3665        },
3666};
3667
3668#define dock_docked() (_sta(dock_handle) & 1)
3669
3670static int __init dock_init(struct ibm_init_struct *iibm)
3671{
3672        vdbg_printk(TPACPI_DBG_INIT, "initializing dock subdriver\n");
3673
3674        TPACPI_ACPIHANDLE_INIT(dock);
3675
3676        vdbg_printk(TPACPI_DBG_INIT, "dock is %s\n",
3677                str_supported(dock_handle != NULL));
3678
3679        return (dock_handle)? 0 : 1;
3680}
3681
3682static int __init dock_init2(struct ibm_init_struct *iibm)
3683{
3684        int dock2_needed;
3685
3686        vdbg_printk(TPACPI_DBG_INIT, "initializing dock subdriver part 2\n");
3687
3688        if (dock_driver_data[0].flags.acpi_driver_registered &&
3689            dock_driver_data[0].flags.acpi_notify_installed) {
3690                TPACPI_ACPIHANDLE_INIT(pci);
3691                dock2_needed = (pci_handle != NULL);
3692                vdbg_printk(TPACPI_DBG_INIT,
3693                            "dock PCI handler for the TP 570 is %s\n",
3694                            str_supported(dock2_needed));
3695        } else {
3696                vdbg_printk(TPACPI_DBG_INIT,
3697                "dock subdriver part 2 not required\n");
3698                dock2_needed = 0;
3699        }
3700
3701        return (dock2_needed)? 0 : 1;
3702}
3703
3704static void dock_notify(struct ibm_struct *ibm, u32 event)
3705{
3706        int docked = dock_docked();
3707        int pci = ibm->acpi->hid && ibm->acpi->device &&
3708                acpi_match_device_ids(ibm->acpi->device, ibm_pci_device_ids);
3709        int data;
3710
3711        if (event == 1 && !pci) /* 570 */
3712                data = 1;       /* button */
3713        else if (event == 1 && pci)     /* 570 */
3714                data = 3;       /* dock */
3715        else if (event == 3 && docked)
3716                data = 1;       /* button */
3717        else if (event == 3 && !docked)
3718                data = 2;       /* undock */
3719        else if (event == 0 && docked)
3720                data = 3;       /* dock */
3721        else {
3722                printk(TPACPI_ERR "unknown dock event %d, status %d\n",
3723                       event, _sta(dock_handle));
3724                data = 0;       /* unknown */
3725        }
3726        acpi_bus_generate_proc_event(ibm->acpi->device, event, data);
3727        acpi_bus_generate_netlink_event(ibm->acpi->device->pnp.device_class,
3728                                          ibm->acpi->device->dev.bus_id,
3729                                          event, data);
3730}
3731
3732static int dock_read(char *p)
3733{
3734        int len = 0;
3735        int docked = dock_docked();
3736
3737        if (!dock_handle)
3738                len += sprintf(p + len, "status:\t\tnot supported\n");
3739        else if (!docked)
3740                len += sprintf(p + len, "status:\t\tundocked\n");
3741        else {
3742                len += sprintf(p + len, "status:\t\tdocked\n");
3743                len += sprintf(p + len, "commands:\tdock, undock\n");
3744        }
3745
3746        return len;
3747}
3748
3749static int dock_write(char *buf)
3750{
3751        char *cmd;
3752
3753        if (!dock_docked())
3754                return -ENODEV;
3755
3756        while ((cmd = next_cmd(&buf))) {
3757                if (strlencmp(cmd, "undock") == 0) {
3758                        if (!acpi_evalf(dock_handle, NULL, "_DCK", "vd", 0) ||
3759                            !acpi_evalf(dock_handle, NULL, "_EJ0", "vd", 1))
3760                                return -EIO;
3761                } else if (strlencmp(cmd, "dock") == 0) {
3762                        if (!acpi_evalf(dock_handle, NULL, "_DCK", "vd", 1))
3763                                return -EIO;
3764                } else
3765                        return -EINVAL;
3766        }
3767
3768        return 0;
3769}
3770
3771#endif /* CONFIG_THINKPAD_ACPI_DOCK */
3772
3773/*************************************************************************
3774 * Bay subdriver
3775 */
3776
3777#ifdef CONFIG_THINKPAD_ACPI_BAY
3778
3779TPACPI_HANDLE(bay, root, "\\_SB.PCI.IDE.SECN.MAST",     /* 570 */
3780           "\\_SB.PCI0.IDE0.IDES.IDSM", /* 600e/x, 770e, 770x */
3781           "\\_SB.PCI0.SATA.SCND.MSTR", /* T60, X60, Z60 */
3782           "\\_SB.PCI0.IDE0.SCND.MSTR", /* all others */
3783           );                           /* A21e, R30, R31 */
3784TPACPI_HANDLE(bay_ej, bay, "_EJ3",      /* 600e/x, A2xm/p, A3x */
3785           "_EJ0",              /* all others */
3786           );                   /* 570,A21e,G4x,R30,R31,R32,R40e,R50e */
3787TPACPI_HANDLE(bay2, root, "\\_SB.PCI0.IDE0.PRIM.SLAV",  /* A3x, R32 */
3788           "\\_SB.PCI0.IDE0.IDEP.IDPS", /* 600e/x, 770e, 770x */
3789           );                           /* all others */
3790TPACPI_HANDLE(bay2_ej, bay2, "_EJ3",    /* 600e/x, 770e, A3x */
3791           "_EJ0",                      /* 770x */
3792           );                           /* all others */
3793
3794static int __init bay_init(struct ibm_init_struct *iibm)
3795{
3796        vdbg_printk(TPACPI_DBG_INIT, "initializing bay subdriver\n");
3797
3798        TPACPI_ACPIHANDLE_INIT(bay);
3799        if (bay_handle)
3800                TPACPI_ACPIHANDLE_INIT(bay_ej);
3801        TPACPI_ACPIHANDLE_INIT(bay2);
3802        if (bay2_handle)
3803                TPACPI_ACPIHANDLE_INIT(bay2_ej);
3804
3805        tp_features.bay_status = bay_handle &&
3806                acpi_evalf(bay_handle, NULL, "_STA", "qv");
3807        tp_features.bay_status2 = bay2_handle &&
3808                acpi_evalf(bay2_handle, NULL, "_STA", "qv");
3809
3810        tp_features.bay_eject = bay_handle && bay_ej_handle &&
3811                (strlencmp(bay_ej_path, "_EJ0") == 0 || experimental);
3812        tp_features.bay_eject2 = bay2_handle && bay2_ej_handle &&
3813                (strlencmp(bay2_ej_path, "_EJ0") == 0 || experimental);
3814
3815        vdbg_printk(TPACPI_DBG_INIT,
3816                "bay 1: status %s, eject %s; bay 2: status %s, eject %s\n",
3817                str_supported(tp_features.bay_status),
3818                str_supported(tp_features.bay_eject),
3819                str_supported(tp_features.bay_status2),
3820                str_supported(tp_features.bay_eject2));
3821
3822        return (tp_features.bay_status || tp_features.bay_eject ||
3823                tp_features.bay_status2 || tp_features.bay_eject2)? 0 : 1;
3824}
3825
3826static void bay_notify(struct ibm_struct *ibm, u32 event)
3827{
3828        acpi_bus_generate_proc_event(ibm->acpi->device, event, 0);
3829        acpi_bus_generate_netlink_event(ibm->acpi->device->pnp.device_class,
3830                                          ibm->acpi->device->dev.bus_id,
3831                                          event, 0);
3832}
3833
3834#define bay_occupied(b) (_sta(b##_handle) & 1)
3835
3836static int bay_read(char *p)
3837{
3838        int len = 0;
3839        int occupied = bay_occupied(bay);
3840        int occupied2 = bay_occupied(bay2);
3841        int eject, eject2;
3842
3843        len += sprintf(p + len, "status:\t\t%s\n",
3844                tp_features.bay_status ?
3845                        (occupied ? "occupied" : "unoccupied") :
3846                                "not supported");
3847        if (tp_features.bay_status2)
3848                len += sprintf(p + len, "status2:\t%s\n", occupied2 ?
3849                               "occupied" : "unoccupied");
3850
3851        eject = tp_features.bay_eject && occupied;
3852        eject2 = tp_features.bay_eject2 && occupied2;
3853
3854        if (eject && eject2)
3855                len += sprintf(p + len, "commands:\teject, eject2\n");
3856        else if (eject)
3857                len += sprintf(p + len, "commands:\teject\n");
3858        else if (eject2)
3859                len += sprintf(p + len, "commands:\teject2\n");
3860
3861        return len;
3862}
3863
3864static int bay_write(char *buf)
3865{
3866        char *cmd;
3867
3868        if (!tp_features.bay_eject && !tp_features.bay_eject2)
3869                return -ENODEV;
3870
3871        while ((cmd = next_cmd(&buf))) {
3872                if (tp_features.bay_eject && strlencmp(cmd, "eject") == 0) {
3873                        if (!acpi_evalf(bay_ej_handle, NULL, NULL, "vd", 1))
3874                                return -EIO;
3875                } else if (tp_features.bay_eject2 &&
3876                           strlencmp(cmd, "eject2") == 0) {
3877                        if (!acpi_evalf(bay2_ej_handle, NULL, NULL, "vd", 1))
3878                                return -EIO;
3879                } else
3880                        return -EINVAL;
3881        }
3882
3883        return 0;
3884}
3885
3886static struct tp_acpi_drv_struct ibm_bay_acpidriver = {
3887        .notify = bay_notify,
3888        .handle = &bay_handle,
3889        .type = ACPI_SYSTEM_NOTIFY,
3890};
3891
3892static struct ibm_struct bay_driver_data = {
3893        .name = "bay",
3894        .read = bay_read,
3895        .write = bay_write,
3896        .acpi = &ibm_bay_acpidriver,
3897};
3898
3899#endif /* CONFIG_THINKPAD_ACPI_BAY */
3900
3901/*************************************************************************
3902 * CMOS subdriver
3903 */
3904
3905/* sysfs cmos_command -------------------------------------------------- */
3906static ssize_t cmos_command_store(struct device *dev,
3907                            struct device_attribute *attr,
3908                            const char *buf, size_t count)
3909{
3910        unsigned long cmos_cmd;
3911        int res;
3912
3913        if (parse_strtoul(buf, 21, &cmos_cmd))
3914                return -EINVAL;
3915
3916        res = issue_thinkpad_cmos_command(cmos_cmd);
3917        return (res)? res : count;
3918}
3919
3920static struct device_attribute dev_attr_cmos_command =
3921        __ATTR(cmos_command, S_IWUSR, NULL, cmos_command_store);
3922
3923/* --------------------------------------------------------------------- */
3924
3925static int __init cmos_init(struct ibm_init_struct *iibm)
3926{
3927        int res;
3928
3929        vdbg_printk(TPACPI_DBG_INIT,
3930                "initializing cmos commands subdriver\n");
3931
3932        TPACPI_ACPIHANDLE_INIT(cmos);
3933
3934        vdbg_printk(TPACPI_DBG_INIT, "cmos commands are %s\n",
3935                str_supported(cmos_handle != NULL));
3936
3937        res = device_create_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
3938        if (res)
3939                return res;
3940
3941        return (cmos_handle)? 0 : 1;
3942}
3943
3944static void cmos_exit(void)
3945{
3946        device_remove_file(&tpacpi_pdev->dev, &dev_attr_cmos_command);
3947}
3948
3949static int cmos_read(char *p)
3950{
3951        int len = 0;
3952
3953        /* cmos not supported on 570, 600e/x, 770e, 770x, A21e, A2xm/p,
3954           R30, R31, T20-22, X20-21 */
3955        if (!cmos_handle)
3956                len += sprintf(p + len, "status:\t\tnot supported\n");
3957        else {
3958                len += sprintf(p + len, "status:\t\tsupported\n");
3959                len += sprintf(p + len, "commands:\t<cmd> (<cmd> is 0-21)\n");
3960        }
3961
3962        return len;
3963}
3964
3965static int cmos_write(char *buf)
3966{
3967        char *cmd;
3968        int cmos_cmd, res;
3969
3970        while ((cmd = next_cmd(&buf))) {
3971                if (sscanf(cmd, "%u", &cmos_cmd) == 1 &&
3972                    cmos_cmd >= 0 && cmos_cmd <= 21) {
3973                        /* cmos_cmd set */
3974                } else
3975                        return -EINVAL;
3976
3977                res = issue_thinkpad_cmos_command(cmos_cmd);
3978                if (res)
3979                        return res;
3980        }
3981
3982        return 0;
3983}
3984
3985static struct ibm_struct cmos_driver_data = {
3986        .name = "cmos",
3987        .read = cmos_read,
3988        .write = cmos_write,
3989        .exit = cmos_exit,
3990};
3991
3992/*************************************************************************
3993 * LED subdriver
3994 */
3995
3996enum led_access_mode {
3997        TPACPI_LED_NONE = 0,
3998        TPACPI_LED_570, /* 570 */
3999        TPACPI_LED_OLD, /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
4000        TPACPI_LED_NEW, /* all others */
4001};
4002
4003enum {  /* For TPACPI_LED_OLD */
4004        TPACPI_LED_EC_HLCL = 0x0c,      /* EC reg to get led to power on */
4005        TPACPI_LED_EC_HLBL = 0x0d,      /* EC reg to blink a lit led */
4006        TPACPI_LED_EC_HLMS = 0x0e,      /* EC reg to select led to command */
4007};
4008
4009enum led_status_t {
4010        TPACPI_LED_OFF = 0,
4011        TPACPI_LED_ON,
4012        TPACPI_LED_BLINK,
4013};
4014
4015static enum led_access_mode led_supported;
4016
4017TPACPI_HANDLE(led, ec, "SLED",  /* 570 */
4018           "SYSL",              /* 600e/x, 770e, 770x, A21e, A2xm/p, */
4019                                /* T20-22, X20-21 */
4020           "LED",               /* all others */
4021           );                   /* R30, R31 */
4022
4023#define TPACPI_LED_NUMLEDS 8
4024static struct tpacpi_led_classdev *tpacpi_leds;
4025static enum led_status_t tpacpi_led_state_cache[TPACPI_LED_NUMLEDS];
4026static const char * const tpacpi_led_names[TPACPI_LED_NUMLEDS] = {
4027        /* there's a limit of 19 chars + NULL before 2.6.26 */
4028        "tpacpi::power",
4029        "tpacpi:orange:batt",
4030        "tpacpi:green:batt",
4031        "tpacpi::dock_active",
4032        "tpacpi::bay_active",
4033        "tpacpi::dock_batt",
4034        "tpacpi::unknown_led",
4035        "tpacpi::standby",
4036};
4037
4038static int led_get_status(const unsigned int led)
4039{
4040        int status;
4041        enum led_status_t led_s;
4042
4043        switch (led_supported) {
4044        case TPACPI_LED_570:
4045                if (!acpi_evalf(ec_handle,
4046                                &status, "GLED", "dd", 1 << led))
4047                        return -EIO;
4048                led_s = (status == 0)?
4049                                TPACPI_LED_OFF :
4050                                ((status == 1)?
4051                                        TPACPI_LED_ON :
4052                                        TPACPI_LED_BLINK);
4053                tpacpi_led_state_cache[led] = led_s;
4054                return led_s;
4055        default:
4056                return -ENXIO;
4057        }
4058
4059        /* not reached */
4060}
4061
4062static int led_set_status(const unsigned int led,
4063                          const enum led_status_t ledstatus)
4064{
4065        /* off, on, blink. Index is led_status_t */
4066        static const unsigned int led_sled_arg1[] = { 0, 1, 3 };
4067        static const unsigned int led_led_arg1[] = { 0, 0x80, 0xc0 };
4068
4069        int rc = 0;
4070
4071        switch (led_supported) {
4072        case TPACPI_LED_570:
4073                /* 570 */
4074                if (led > 7)
4075                        return -EINVAL;
4076                if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
4077                                (1 << led), led_sled_arg1[ledstatus]))
4078                        rc = -EIO;
4079                break;
4080        case TPACPI_LED_OLD:
4081                /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20 */
4082                if (led > 7)
4083                        return -EINVAL;
4084                rc = ec_write(TPACPI_LED_EC_HLMS, (1 << led));
4085                if (rc >= 0)
4086                        rc = ec_write(TPACPI_LED_EC_HLBL,
4087                                      (ledstatus == TPACPI_LED_BLINK) << led);
4088                if (rc >= 0)
4089                        rc = ec_write(TPACPI_LED_EC_HLCL,
4090                                      (ledstatus != TPACPI_LED_OFF) << led);
4091                break;
4092        case TPACPI_LED_NEW:
4093                /* all others */
4094                if (!acpi_evalf(led_handle, NULL, NULL, "vdd",
4095                                led, led_led_arg1[ledstatus]))
4096                        rc = -EIO;
4097                break;
4098        default:
4099                rc = -ENXIO;
4100        }
4101
4102        if (!rc)
4103                tpacpi_led_state_cache[led] = ledstatus;
4104
4105        return rc;
4106}
4107
4108static void led_sysfs_set_status(unsigned int led,
4109                                 enum led_brightness brightness)
4110{
4111        led_set_status(led,
4112                        (brightness == LED_OFF) ?
4113                        TPACPI_LED_OFF :
4114                        (tpacpi_led_state_cache[led] == TPACPI_LED_BLINK) ?
4115                                TPACPI_LED_BLINK : TPACPI_LED_ON);
4116}
4117
4118static void led_set_status_worker(struct work_struct *work)
4119{
4120        struct tpacpi_led_classdev *data =
4121                container_of(work, struct tpacpi_led_classdev, work);
4122
4123        if (likely(tpacpi_lifecycle == TPACPI_LIFE_RUNNING))
4124                led_sysfs_set_status(data->led, data->new_brightness);
4125}
4126
4127static void led_sysfs_set(struct led_classdev *led_cdev,
4128                        enum led_brightness brightness)
4129{
4130        struct tpacpi_led_classdev *data = container_of(led_cdev,
4131                             struct tpacpi_led_classdev, led_classdev);
4132
4133        data->new_brightness = brightness;
4134        queue_work(tpacpi_wq, &data->work);
4135}
4136
4137static int led_sysfs_blink_set(struct led_classdev *led_cdev,
4138                        unsigned long *delay_on, unsigned long *delay_off)
4139{
4140        struct tpacpi_led_classdev *data = container_of(led_cdev,
4141                             struct tpacpi_led_classdev, led_classdev);
4142
4143        /* Can we choose the flash rate? */
4144        if (*delay_on == 0 && *delay_off == 0) {
4145                /* yes. set them to the hardware blink rate (1 Hz) */
4146                *delay_on = 500; /* ms */
4147                *delay_off = 500; /* ms */
4148        } else if ((*delay_on != 500) || (*delay_off != 500))
4149                return -EINVAL;
4150
4151        data->new_brightness = TPACPI_LED_BLINK;
4152        queue_work(tpacpi_wq, &data->work);
4153
4154        return 0;
4155}
4156
4157static enum led_brightness led_sysfs_get(struct led_classdev *led_cdev)
4158{
4159        int rc;
4160
4161        struct tpacpi_led_classdev *data = container_of(led_cdev,
4162                             struct tpacpi_led_classdev, led_classdev);
4163
4164        rc = led_get_status(data->led);
4165
4166        if (rc == TPACPI_LED_OFF || rc < 0)
4167                rc = LED_OFF;   /* no error handling in led class :( */
4168        else
4169                rc = LED_FULL;
4170
4171        return rc;
4172}
4173
4174static void led_exit(void)
4175{
4176        unsigned int i;
4177
4178        for (i = 0; i < TPACPI_LED_NUMLEDS; i++) {
4179                if (tpacpi_leds[i].led_classdev.name)
4180                        led_classdev_unregister(&tpacpi_leds[i].led_classdev);
4181        }
4182
4183        kfree(tpacpi_leds);
4184}
4185
4186static int __init led_init(struct ibm_init_struct *iibm)
4187{
4188        unsigned int i;
4189        int rc;
4190
4191        vdbg_printk(TPACPI_DBG_INIT, "initializing LED subdriver\n");
4192
4193        TPACPI_ACPIHANDLE_INIT(led);
4194
4195        if (!led_handle)
4196                /* led not supported on R30, R31 */
4197                led_supported = TPACPI_LED_NONE;
4198        else if (strlencmp(led_path, "SLED") == 0)
4199                /* 570 */
4200                led_supported = TPACPI_LED_570;
4201        else if (strlencmp(led_path, "SYSL") == 0)
4202                /* 600e/x, 770e, 770x, A21e, A2xm/p, T20-22, X20-21 */
4203                led_supported = TPACPI_LED_OLD;
4204        else
4205                /* all others */
4206                led_supported = TPACPI_LED_NEW;
4207
4208        vdbg_printk(TPACPI_DBG_INIT, "LED commands are %s, mode %d\n",
4209                str_supported(led_supported), led_supported);
4210
4211        tpacpi_leds = kzalloc(sizeof(*tpacpi_leds) * TPACPI_LED_NUMLEDS,
4212                              GFP_KERNEL);
4213        if (!tpacpi_leds) {
4214                printk(TPACPI_ERR "Out of memory for LED data\n");
4215                return -ENOMEM;
4216        }
4217
4218        for (i = 0; i < TPACPI_LED_NUMLEDS; i++) {
4219                tpacpi_leds[i].led = i;
4220
4221                tpacpi_leds[i].led_classdev.brightness_set = &led_sysfs_set;
4222                tpacpi_leds[i].led_classdev.blink_set = &led_sysfs_blink_set;
4223                if (led_supported == TPACPI_LED_570)
4224                        tpacpi_leds[i].led_classdev.brightness_get =
4225                                                        &led_sysfs_get;
4226
4227                tpacpi_leds[i].led_classdev.name = tpacpi_led_names[i];
4228
4229                INIT_WORK(&tpacpi_leds[i].work, led_set_status_worker);
4230
4231                rc = led_classdev_register(&tpacpi_pdev->dev,
4232                                           &tpacpi_leds[i].led_classdev);
4233                if (rc < 0) {
4234                        tpacpi_leds[i].led_classdev.name = NULL;
4235                        led_exit();
4236                        return rc;
4237                }
4238        }
4239
4240        return (led_supported != TPACPI_LED_NONE)? 0 : 1;
4241}
4242
4243#define str_led_status(s) \
4244        ((s) == TPACPI_LED_OFF ? "off" : \
4245                ((s) == TPACPI_LED_ON ? "on" : "blinking"))
4246
4247static int led_read(char *p)
4248{
4249        int len = 0;
4250
4251        if (!led_supported) {
4252                len += sprintf(p + len, "status:\t\tnot supported\n");
4253                return len;
4254        }
4255        len += sprintf(p + len, "status:\t\tsupported\n");
4256
4257        if (led_supported == TPACPI_LED_570) {
4258                /* 570 */
4259                int i, status;
4260                for (i = 0; i < 8; i++) {
4261                        status = led_get_status(i);
4262                        if (status < 0)
4263                                return -EIO;
4264                        len += sprintf(p + len, "%d:\t\t%s\n",
4265                                       i, str_led_status(status));
4266                }
4267        }
4268
4269        len += sprintf(p + len, "commands:\t"
4270                       "<led> on, <led> off, <led> blink (<led> is 0-7)\n");
4271
4272        return len;
4273}
4274
4275static int led_write(char *buf)
4276{
4277        char *cmd;
4278        int led, rc;
4279        enum led_status_t s;
4280
4281        if (!led_supported)
4282                return -ENODEV;
4283
4284        while ((cmd = next_cmd(&buf))) {
4285                if (sscanf(cmd, "%d", &led) != 1 || led < 0 || led > 7)
4286                        return -EINVAL;
4287
4288                if (strstr(cmd, "off")) {
4289                        s = TPACPI_LED_OFF;
4290                } else if (strstr(cmd, "on")) {
4291                        s = TPACPI_LED_ON;
4292                } else if (strstr(cmd, "blink")) {
4293                        s = TPACPI_LED_BLINK;
4294                } else {
4295                        return -EINVAL;
4296                }
4297
4298                rc = led_set_status(led, s);
4299                if (rc < 0)
4300                        return rc;
4301        }
4302
4303        return 0;
4304}
4305
4306static struct ibm_struct led_driver_data = {
4307        .name = "led",
4308        .read = led_read,
4309        .write = led_write,
4310        .exit = led_exit,
4311};
4312
4313/*************************************************************************
4314 * Beep subdriver
4315 */
4316
4317TPACPI_HANDLE(beep, ec, "BEEP");        /* all except R30, R31 */
4318
4319static int __init beep_init(struct ibm_init_struct *iibm)
4320{
4321        vdbg_printk(TPACPI_DBG_INIT, "initializing beep subdriver\n");
4322
4323        TPACPI_ACPIHANDLE_INIT(beep);
4324
4325        vdbg_printk(TPACPI_DBG_INIT, "beep is %s\n",
4326                str_supported(beep_handle != NULL));
4327
4328        return (beep_handle)? 0 : 1;
4329}
4330
4331static int beep_read(char *p)
4332{
4333        int len = 0;
4334
4335        if (!beep_handle)
4336                len += sprintf(p + len, "status:\t\tnot supported\n");
4337        else {
4338                len += sprintf(p + len, "status:\t\tsupported\n");
4339                len += sprintf(p + len, "commands:\t<cmd> (<cmd> is 0-17)\n");
4340        }
4341
4342        return len;
4343}
4344
4345static int beep_write(char *buf)
4346{
4347        char *cmd;
4348        int beep_cmd;
4349
4350        if (!beep_handle)
4351                return -ENODEV;
4352
4353        while ((cmd = next_cmd(&buf))) {
4354                if (sscanf(cmd, "%u", &beep_cmd) == 1 &&
4355                    beep_cmd >= 0 && beep_cmd <= 17) {
4356                        /* beep_cmd set */
4357                } else
4358                        return -EINVAL;
4359                if (!acpi_evalf(beep_handle, NULL, NULL, "vdd", beep_cmd, 0))
4360                        return -EIO;
4361        }
4362
4363        return 0;
4364}
4365
4366static struct ibm_struct beep_driver_data = {
4367        .name = "beep",
4368        .read = beep_read,
4369        .write = beep_write,
4370};
4371
4372/*************************************************************************
4373 * Thermal subdriver
4374 */
4375
4376enum thermal_access_mode {
4377        TPACPI_THERMAL_NONE = 0,        /* No thermal support */
4378        TPACPI_THERMAL_ACPI_TMP07,      /* Use ACPI TMP0-7 */
4379        TPACPI_THERMAL_ACPI_UPDT,       /* Use ACPI TMP0-7 with UPDT */
4380        TPACPI_THERMAL_TPEC_8,          /* Use ACPI EC regs, 8 sensors */
4381        TPACPI_THERMAL_TPEC_16,         /* Use ACPI EC regs, 16 sensors */
4382};
4383
4384enum { /* TPACPI_THERMAL_TPEC_* */
4385        TP_EC_THERMAL_TMP0 = 0x78,      /* ACPI EC regs TMP 0..7 */
4386        TP_EC_THERMAL_TMP8 = 0xC0,      /* ACPI EC regs TMP 8..15 */
4387        TP_EC_THERMAL_TMP_NA = -128,    /* ACPI EC sensor not available */
4388};
4389
4390#define TPACPI_MAX_THERMAL_SENSORS 16   /* Max thermal sensors supported */
4391struct ibm_thermal_sensors_struct {
4392        s32 temp[TPACPI_MAX_THERMAL_SENSORS];
4393};
4394
4395static enum thermal_access_mode thermal_read_mode;
4396
4397/* idx is zero-based */
4398static int thermal_get_sensor(int idx, s32 *value)
4399{
4400        int t;
4401        s8 tmp;
4402        char tmpi[5];
4403
4404        t = TP_EC_THERMAL_TMP0;
4405
4406        switch (thermal_read_mode) {
4407#if TPACPI_MAX_THERMAL_SENSORS >= 16
4408        case TPACPI_THERMAL_TPEC_16:
4409                if (idx >= 8 && idx <= 15) {
4410                        t = TP_EC_THERMAL_TMP8;
4411                        idx -= 8;
4412                }
4413                /* fallthrough */
4414#endif
4415        case TPACPI_THERMAL_TPEC_8:
4416                if (idx <= 7) {
4417                        if (!acpi_ec_read(t + idx, &tmp))
4418                                return -EIO;
4419                        *value = tmp * 1000;
4420                        return 0;
4421                }
4422                break;
4423
4424        case TPACPI_THERMAL_ACPI_UPDT:
4425                if (idx <= 7) {
4426                        snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
4427                        if (!acpi_evalf(ec_handle, NULL, "UPDT", "v"))
4428                                return -EIO;
4429                        if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
4430                                return -EIO;
4431                        *value = (t - 2732) * 100;
4432                        return 0;
4433                }
4434                break;
4435
4436        case TPACPI_THERMAL_ACPI_TMP07:
4437                if (idx <= 7) {
4438                        snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
4439                        if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
4440                                return -EIO;
4441                        if (t > 127 || t < -127)
4442                                t = TP_EC_THERMAL_TMP_NA;
4443                        *value = t * 1000;
4444                        return 0;
4445                }
4446                break;
4447
4448        case TPACPI_THERMAL_NONE:
4449        default:
4450                return -ENOSYS;
4451        }
4452
4453        return -EINVAL;
4454}
4455
4456static int thermal_get_sensors(struct ibm_thermal_sensors_struct *s)
4457{
4458        int res, i;
4459        int n;
4460
4461        n = 8;
4462        i = 0;
4463
4464        if (!s)
4465                return -EINVAL;
4466
4467        if (thermal_read_mode == TPACPI_THERMAL_TPEC_16)
4468                n = 16;
4469
4470        for (i = 0 ; i < n; i++) {
4471                res = thermal_get_sensor(i, &s->temp[i]);
4472                if (res)
4473                        return res;
4474        }
4475
4476        return n;
4477}
4478
4479/* sysfs temp##_input -------------------------------------------------- */
4480
4481static ssize_t thermal_temp_input_show(struct device *dev,
4482                           struct device_attribute *attr,
4483                           char *buf)
4484{
4485        struct sensor_device_attribute *sensor_attr =
4486                                        to_sensor_dev_attr(attr);
4487        int idx = sensor_attr->index;
4488        s32 value;
4489        int res;
4490
4491        res = thermal_get_sensor(idx, &value);
4492        if (res)
4493                return res;
4494        if (value == TP_EC_THERMAL_TMP_NA * 1000)
4495                return -ENXIO;
4496
4497        return snprintf(buf, PAGE_SIZE, "%d\n", value);
4498}
4499
4500#define THERMAL_SENSOR_ATTR_TEMP(_idxA, _idxB) \
4501         SENSOR_ATTR(temp##_idxA##_input, S_IRUGO, \
4502                     thermal_temp_input_show, NULL, _idxB)
4503
4504static struct sensor_device_attribute sensor_dev_attr_thermal_temp_input[] = {
4505        THERMAL_SENSOR_ATTR_TEMP(1, 0),
4506        THERMAL_SENSOR_ATTR_TEMP(2, 1),
4507        THERMAL_SENSOR_ATTR_TEMP(3, 2),
4508        THERMAL_SENSOR_ATTR_TEMP(4, 3),
4509        THERMAL_SENSOR_ATTR_TEMP(5, 4),
4510        THERMAL_SENSOR_ATTR_TEMP(6, 5),
4511        THERMAL_SENSOR_ATTR_TEMP(7, 6),
4512        THERMAL_SENSOR_ATTR_TEMP(8, 7),
4513        THERMAL_SENSOR_ATTR_TEMP(9, 8),
4514        THERMAL_SENSOR_ATTR_TEMP(10, 9),
4515        THERMAL_SENSOR_ATTR_TEMP(11, 10),
4516        THERMAL_SENSOR_ATTR_TEMP(12, 11),
4517        THERMAL_SENSOR_ATTR_TEMP(13, 12),
4518        THERMAL_SENSOR_ATTR_TEMP(14, 13),
4519        THERMAL_SENSOR_ATTR_TEMP(15, 14),
4520        THERMAL_SENSOR_ATTR_TEMP(16, 15),
4521};
4522
4523#define THERMAL_ATTRS(X) \
4524        &sensor_dev_attr_thermal_temp_input[X].dev_attr.attr
4525
4526static struct attribute *thermal_temp_input_attr[] = {
4527        THERMAL_ATTRS(8),
4528        THERMAL_ATTRS(9),
4529        THERMAL_ATTRS(10),
4530        THERMAL_ATTRS(11),
4531        THERMAL_ATTRS(12),
4532        THERMAL_ATTRS(13),
4533        THERMAL_ATTRS(14),
4534        THERMAL_ATTRS(15),
4535        THERMAL_ATTRS(0),
4536        THERMAL_ATTRS(1),
4537        THERMAL_ATTRS(2),
4538        THERMAL_ATTRS(3),
4539        THERMAL_ATTRS(4),
4540        THERMAL_ATTRS(5),
4541        THERMAL_ATTRS(6),
4542        THERMAL_ATTRS(7),
4543        NULL
4544};
4545
4546static const struct attribute_group thermal_temp_input16_group = {
4547        .attrs = thermal_temp_input_attr
4548};
4549
4550static const struct attribute_group thermal_temp_input8_group = {
4551        .attrs = &thermal_temp_input_attr[8]
4552};
4553
4554#undef THERMAL_SENSOR_ATTR_TEMP
4555#undef THERMAL_ATTRS
4556
4557/* --------------------------------------------------------------------- */
4558
4559static int __init thermal_init(struct ibm_init_struct *iibm)
4560{
4561        u8 t, ta1, ta2;
4562        int i;
4563        int acpi_tmp7;
4564        int res;
4565
4566        vdbg_printk(TPACPI_DBG_INIT, "initializing thermal subdriver\n");
4567
4568        acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
4569
4570        if (thinkpad_id.ec_model) {
4571                /*
4572                 * Direct EC access mode: sensors at registers
4573                 * 0x78-0x7F, 0xC0-0xC7.  Registers return 0x00 for
4574                 * non-implemented, thermal sensors return 0x80 when
4575                 * not available
4576                 */
4577
4578                ta1 = ta2 = 0;
4579                for (i = 0; i < 8; i++) {
4580                        if (acpi_ec_read(TP_EC_THERMAL_TMP0 + i, &t)) {
4581                                ta1 |= t;
4582                        } else {
4583                                ta1 = 0;
4584                                break;
4585                        }
4586                        if (acpi_ec_read(TP_EC_THERMAL_TMP8 + i, &t)) {
4587                                ta2 |= t;
4588                        } else {
4589                                ta1 = 0;
4590                                break;
4591                        }
4592                }
4593                if (ta1 == 0) {
4594                        /* This is sheer paranoia, but we handle it anyway */
4595                        if (acpi_tmp7) {
4596                                printk(TPACPI_ERR
4597                                       "ThinkPad ACPI EC access misbehaving, "
4598                                       "falling back to ACPI TMPx access "
4599                                       "mode\n");
4600                                thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
4601                        } else {
4602                                printk(TPACPI_ERR
4603                                       "ThinkPad ACPI EC access misbehaving, "
4604                                       "disabling thermal sensors access\n");
4605                                thermal_read_mode = TPACPI_THERMAL_NONE;
4606                        }
4607                } else {
4608                        thermal_read_mode =
4609                            (ta2 != 0) ?
4610                            TPACPI_THERMAL_TPEC_16 : TPACPI_THERMAL_TPEC_8;
4611                }
4612        } else if (acpi_tmp7) {
4613                if (acpi_evalf(ec_handle, NULL, "UPDT", "qv")) {
4614                        /* 600e/x, 770e, 770x */
4615                        thermal_read_mode = TPACPI_THERMAL_ACPI_UPDT;
4616                } else {
4617                        /* Standard ACPI TMPx access, max 8 sensors */
4618                        thermal_read_mode = TPACPI_THERMAL_ACPI_TMP07;
4619                }
4620        } else {
4621                /* temperatures not supported on 570, G4x, R30, R31, R32 */
4622                thermal_read_mode = TPACPI_THERMAL_NONE;
4623        }
4624
4625        vdbg_printk(TPACPI_DBG_INIT, "thermal is %s, mode %d\n",
4626                str_supported(thermal_read_mode != TPACPI_THERMAL_NONE),
4627                thermal_read_mode);
4628
4629        switch (thermal_read_mode) {
4630        case TPACPI_THERMAL_TPEC_16:
4631                res = sysfs_create_group(&tpacpi_sensors_pdev->dev.kobj,
4632                                &thermal_temp_input16_group);
4633                if (res)
4634                        return res;
4635                break;
4636        case TPACPI_THERMAL_TPEC_8:
4637        case TPACPI_THERMAL_ACPI_TMP07:
4638        case TPACPI_THERMAL_ACPI_UPDT:
4639                res = sysfs_create_group(&tpacpi_sensors_pdev->dev.kobj,
4640                                &thermal_temp_input8_group);
4641                if (res)
4642                        return res;
4643                break;
4644        case TPACPI_THERMAL_NONE:
4645        default:
4646                return 1;
4647        }
4648
4649        return 0;
4650}
4651
4652static void thermal_exit(void)
4653{
4654        switch (thermal_read_mode) {
4655        case TPACPI_THERMAL_TPEC_16:
4656                sysfs_remove_group(&tpacpi_sensors_pdev->dev.kobj,
4657                                   &thermal_temp_input16_group);
4658                break;
4659        case TPACPI_THERMAL_TPEC_8:
4660        case TPACPI_THERMAL_ACPI_TMP07:
4661        case TPACPI_THERMAL_ACPI_UPDT:
4662                sysfs_remove_group(&tpacpi_sensors_pdev->dev.kobj,
4663                                   &thermal_temp_input16_group);
4664                break;
4665        case TPACPI_THERMAL_NONE:
4666        default:
4667                break;
4668        }
4669}
4670
4671static int thermal_read(char *p)
4672{
4673        int len = 0;
4674        int n, i;
4675        struct ibm_thermal_sensors_struct t;
4676
4677        n = thermal_get_sensors(&t);
4678        if (unlikely(n < 0))
4679                return n;
4680
4681        len += sprintf(p + len, "temperatures:\t");
4682
4683        if (n > 0) {
4684                for (i = 0; i < (n - 1); i++)
4685                        len += sprintf(p + len, "%d ", t.temp[i] / 1000);
4686                len += sprintf(p + len, "%d\n", t.temp[i] / 1000);
4687        } else
4688                len += sprintf(p + len, "not supported\n");
4689
4690        return len;
4691}
4692
4693static struct ibm_struct thermal_driver_data = {
4694        .name = "thermal",
4695        .read = thermal_read,
4696        .exit = thermal_exit,
4697};
4698
4699/*************************************************************************
4700 * EC Dump subdriver
4701 */
4702
4703static u8 ecdump_regs[256];
4704
4705static int ecdump_read(char *p)
4706{
4707        int len = 0;
4708        int i, j;
4709        u8 v;
4710