Pull thinkpad into release branch

5 files changed, 854 insertions, 159 deletions

diff --git a/Documentation/thinkpad-acpi.txt b/Documentation/thinkpad-acpi.txt
index 9e6b94face4b..6711fbcf4080 100644
--- a/Documentation/thinkpad-acpi.txt
+++ b/Documentation/thinkpad-acpi.txt
@@ -1,11 +1,11 @@
                      ThinkPad ACPI Extras Driver
 
-                            Version 0.14
-                          April 21st, 2007
+                            Version 0.15
+                           July 1st, 2007
 
                Borislav Deianov <borislav@users.sf.net>
-             Henrique de Moraes Holschuh <hmh@hmh.eng.br>
-                      http://ibm-acpi.sf.net/
+             Henrique de Moraes Holschuh <hmh@hmh.eng.br>
+                      http://ibm-acpi.sf.net/
 
 
 This is a Linux driver for the IBM and Lenovo ThinkPad laptops. It
@@ -134,54 +134,68 @@ end of this document.  Changes to the sysfs interface done by the kernel
 subsystems are not documented here, nor are they tracked by this
 attribute.
 
+Changes to the thinkpad-acpi sysfs interface are only considered
+non-experimental when they are submitted to Linux mainline, at which
+point the changes in this interface are documented and interface_version
+may be updated.  If you are using any thinkpad-acpi features not yet
+sent to mainline for merging, you do so on your own risk: these features
+may disappear, or be implemented in a different and incompatible way by
+the time they are merged in Linux mainline.
+
+Changes that are backwards-compatible by nature (e.g. the addition of
+attributes that do not change the way the other attributes work) do not
+always warrant an update of interface_version.  Therefore, one must
+expect that an attribute might not be there, and deal with it properly
+(an attribute not being there *is* a valid way to make it clear that a
+feature is not available in sysfs).
+
 Hot keys
 --------
 
 procfs: /proc/acpi/ibm/hotkey
 sysfs device attribute: hotkey_*
 
-Without this driver, only the Fn-F4 key (sleep button) generates an
-ACPI event. With the driver loaded, the hotkey feature enabled and the
-mask set (see below), the various hot keys generate ACPI events in the
+In a ThinkPad, the ACPI HKEY handler is responsible for comunicating
+some important events and also keyboard hot key presses to the operating
+system.  Enabling the hotkey functionality of thinkpad-acpi signals the
+firmware that such a driver is present, and modifies how the ThinkPad
+firmware will behave in many situations.
+
+When the hotkey feature is enabled and the hot key mask is set (see
+below), the various hot keys either generate ACPI events in the
 following format:
 
         ibm/hotkey HKEY 00000080 0000xxxx
 
-The last four digits vary depending on the key combination pressed.
-All labeled Fn-Fx key combinations generate distinct events. In
-addition, the lid microswitch and some docking station buttons may
-also generate such events.
-
-The bit mask allows some control over which hot keys generate ACPI
-events. Not all bits in the mask can be modified. Not all bits that
-can be modified do anything. Not all hot keys can be individually
-controlled by the mask. Most recent ThinkPad models honor the
-following bits (assuming the hot keys feature has been enabled):
-
-        key     bit     behavior when set       behavior when unset
-
-        Fn-F3                   always generates ACPI event
-        Fn-F4                   always generates ACPI event
-        Fn-F5   0010    generate ACPI event     enable/disable Bluetooth
-        Fn-F7   0040    generate ACPI event     switch LCD and external display
-        Fn-F8   0080    generate ACPI event     expand screen or none
-        Fn-F9   0100    generate ACPI event     none
-        Fn-F12                  always generates ACPI event
-
-Some models do not support all of the above. For example, the T30 does
-not support Fn-F5 and Fn-F9. Other models do not support the mask at
-all. On those models, hot keys cannot be controlled individually.
-
-Note that enabling ACPI events for some keys prevents their default
-behavior. For example, if events for Fn-F5 are enabled, that key will
-no longer enable/disable Bluetooth by itself. This can still be done
-from an acpid handler for the ibm/hotkey event.
-
-Note also that not all Fn key combinations are supported through
-ACPI. For example, on the X40, the brightness, volume and "Access IBM"
-buttons do not generate ACPI events even with this driver. They *can*
-be used through the "ThinkPad Buttons" utility, see
-http://www.nongnu.org/tpb/
+or events over the input layer.  The input layer support accepts the
+standard IOCTLs to remap the keycodes assigned to each hotkey.
+
+When the input device is open, the driver will suppress any ACPI hot key
+events that get translated into a meaningful input layer event, in order
+to avoid sending duplicate events to userspace.  Hot keys that are
+mapped to KEY_RESERVED in the keymap are not translated, and will always
+generate an ACPI ibm/hotkey HKEY event, and no input layer events.
+
+The hot key bit mask allows some control over which hot keys generate
+events.  If a key is "masked" (bit set to 0 in the mask), the firmware
+will handle it.  If it is "unmasked", it signals the firmware that
+thinkpad-acpi would prefer to handle it, if the firmware would be so
+kind to allow it (and it often doesn't!).
+
+Not all bits in the mask can be modified.  Not all bits that can be
+modified do anything.  Not all hot keys can be individually controlled
+by the mask.  Some models do not support the mask at all, and in those
+models, hot keys cannot be controlled individually.  The behaviour of
+the mask is, therefore, higly dependent on the ThinkPad model.
+
+Note that unmasking some keys prevents their default behavior.  For
+example, if Fn+F5 is unmasked, that key will no longer enable/disable
+Bluetooth by itself.
+
+Note also that not all Fn key combinations are supported through ACPI.
+For example, on the X40, the brightness, volume and "Access IBM" buttons
+do not generate ACPI events even with this driver.  They *can* be used
+through the "ThinkPad Buttons" utility, see http://www.nongnu.org/tpb/
 
 procfs notes:
 
@@ -189,9 +203,9 @@ The following commands can be written to the /proc/acpi/ibm/hotkey file:
 
         echo enable > /proc/acpi/ibm/hotkey -- enable the hot keys feature
         echo disable > /proc/acpi/ibm/hotkey -- disable the hot keys feature
-        echo 0xffff > /proc/acpi/ibm/hotkey -- enable all possible hot keys
-        echo 0x0000 > /proc/acpi/ibm/hotkey -- disable all possible hot keys
-        ... any other 4-hex-digit mask ...
+        echo 0xffffffff > /proc/acpi/ibm/hotkey -- enable all hot keys
+        echo 0 > /proc/acpi/ibm/hotkey -- disable all possible hot keys
+        ... any other 8-hex-digit mask ...
         echo reset > /proc/acpi/ibm/hotkey -- restore the original mask
 
 sysfs notes:
@@ -202,7 +216,7 @@ sysfs notes:
                 key feature status will be restored to this value.
 
                 0: hot keys were disabled
-                1: hot keys were enabled
+                1: hot keys were enabled (unusual)
 
         hotkey_bios_mask:
                 Returns the hot keys mask when thinkpad-acpi was loaded.
@@ -217,9 +231,182 @@ sysfs notes:
                 1: enables the hot keys feature / feature enabled
 
         hotkey_mask:
-                bit mask to enable ACPI event generation for each hot
-                key (see above).  Returns the current status of the hot
-                keys mask, and allows one to modify it.
+                bit mask to enable driver-handling and ACPI event
+                generation for each hot key (see above).  Returns the
+                current status of the hot keys mask, and allows one to
+                modify it.
+
+        hotkey_all_mask:
+                bit mask that should enable event reporting for all
+                supported hot keys, when echoed to hotkey_mask above.
+                Unless you know which events need to be handled
+                passively (because the firmware *will* handle them
+                anyway), do *not* use hotkey_all_mask.  Use
+                hotkey_recommended_mask, instead. You have been warned.
+
+        hotkey_recommended_mask:
+                bit mask that should enable event reporting for all
+                supported hot keys, except those which are always
+                handled by the firmware anyway.  Echo it to
+                hotkey_mask above, to use.
+
+        hotkey_radio_sw:
+                if the ThinkPad has a hardware radio switch, this
+                attribute will read 0 if the switch is in the "radios
+                disabled" postition, and 1 if the switch is in the
+                "radios enabled" position.
+
+input layer notes:
+
+A Hot key is mapped to a single input layer EV_KEY event, possibly
+followed by an EV_MSC MSC_SCAN event that shall contain that key's scan
+code.  An EV_SYN event will always be generated to mark the end of the
+event block.
+
+Do not use the EV_MSC MSC_SCAN events to process keys.  They are to be
+used as a helper to remap keys, only.  They are particularly useful when
+remapping KEY_UNKNOWN keys.
+
+The events are available in an input device, with the following id:
+
+        Bus:            BUS_HOST
+        vendor:         0x1014 (PCI_VENDOR_ID_IBM)  or
+                        0x17aa (PCI_VENDOR_ID_LENOVO)
+        product:        0x5054 ("TP")
+        version:        0x4101
+
+The version will have its LSB incremented if the keymap changes in a
+backwards-compatible way.  The MSB shall always be 0x41 for this input
+device.  If the MSB is not 0x41, do not use the device as described in
+this section, as it is either something else (e.g. another input device
+exported by a thinkpad driver, such as HDAPS) or its functionality has
+been changed in a non-backwards compatible way.
+
+Adding other event types for other functionalities shall be considered a
+backwards-compatible change for this input device.
+
+Thinkpad-acpi Hot Key event map (version 0x4101):
+
+ACPI    Scan
+event   code    Key             Notes
+
+0x1001  0x00    FN+F1           -
+0x1002  0x01    FN+F2           IBM: battery (rare)
+                                Lenovo: Screen lock
+
+0x1003  0x02    FN+F3           Many IBM models always report
+                                this hot key, even with hot keys
+                                disabled or with Fn+F3 masked
+                                off
+                                IBM: screen lock
+                                Lenovo: battery
+
+0x1004  0x03    FN+F4           Sleep button (ACPI sleep button
+                                semanthics, i.e. sleep-to-RAM).
+                                It is always generate some kind
+                                of event, either the hot key
+                                event or a ACPI sleep button
+                                event. The firmware may
+                                refuse to generate further FN+F4
+                                key presses until a S3 or S4 ACPI
+                                sleep cycle is performed or some
+                                time passes.
+
+0x1005  0x04    FN+F5           Radio.  Enables/disables
+                                the internal BlueTooth hardware
+                                and W-WAN card if left in control
+                                of the firmware.  Does not affect
+                                the WLAN card.
+                                Should be used to turn on/off all
+                                radios (bluetooth+W-WAN+WLAN),
+                                really.
+
+0x1006  0x05    FN+F6           -
+
+0x1007  0x06    FN+F7           Video output cycle.
+                                Do you feel lucky today?
+
+0x1008  0x07    FN+F8           IBM: toggle screen expand
+                                Lenovo: configure ultranav
+
+0x1009  0x08    FN+F9           -
+        ..      ..              ..
+0x100B  0x0A    FN+F11          -
+
+0x100C  0x0B    FN+F12          Sleep to disk.  You are always
+                                supposed to handle it yourself,
+                                either through the ACPI event,
+                                or through a hotkey event.
+                                The firmware may refuse to
+                                generate further FN+F4 key
+                                press events until a S3 or S4
+                                ACPI sleep cycle is performed,
+                                or some time passes.
+
+0x100D  0x0C    FN+BACKSPACE    -
+0x100E  0x0D    FN+INSERT       -
+0x100F  0x0E    FN+DELETE       -
+
+0x1010  0x0F    FN+HOME         Brightness up.  This key is
+                                always handled by the firmware
+                                in IBM ThinkPads, even when
+                                unmasked.  Just leave it alone.
+                                For Lenovo ThinkPads with a new
+                                BIOS, it has to be handled either
+                                by the ACPI OSI, or by userspace.
+0x1011  0x10    FN+END          Brightness down.  See brightness
+                                up for details.
+
+0x1012  0x11    FN+PGUP         Thinklight toggle.  This key is
+                                always handled by the firmware,
+                                even when unmasked.
+
+0x1013  0x12    FN+PGDOWN       -
+
+0x1014  0x13    FN+SPACE        Zoom key
+
+0x1015  0x14    VOLUME UP       Internal mixer volume up. This
+                                key is always handled by the
+                                firmware, even when unmasked.
+                                NOTE: Lenovo seems to be changing
+                                this.
+0x1016  0x15    VOLUME DOWN     Internal mixer volume up. This
+                                key is always handled by the
+                                firmware, even when unmasked.
+                                NOTE: Lenovo seems to be changing
+                                this.
+0x1017  0x16    MUTE            Mute internal mixer. This
+                                key is always handled by the
+                                firmware, even when unmasked.
+
+0x1018  0x17    THINKPAD        Thinkpad/Access IBM/Lenovo key
+
+0x1019  0x18    unknown
+..      ..      ..
+0x1020  0x1F    unknown
+
+The ThinkPad firmware does not allow one to differentiate when most hot
+keys are pressed or released (either that, or we don't know how to, yet).
+For these keys, the driver generates a set of events for a key press and
+immediately issues the same set of events for a key release.  It is
+unknown by the driver if the ThinkPad firmware triggered these events on
+hot key press or release, but the firmware will do it for either one, not
+both.
+
+If a key is mapped to KEY_RESERVED, it generates no input events at all,
+and it may generate a legacy thinkpad-acpi ACPI hotkey event.
+
+If a key is mapped to KEY_UNKNOWN, it generates an input event that
+includes an scan code, and it may also generate a legacy thinkpad-acpi
+ACPI hotkey event.
+
+If a key is mapped to anything else, it will only generate legacy
+thinkpad-acpi ACPI hotkey events if nobody has opened the input device.
+
+Non hot-key ACPI HKEY event map:
+0x5001          Lid closed
+0x5002          Lid opened
+0x7000          Radio Switch may have changed state
 
 
 Bluetooth
@@ -437,27 +624,34 @@ CMOS control
 procfs: /proc/acpi/ibm/cmos
 sysfs device attribute: cmos_command
 
-This feature is used internally by the ACPI firmware to control the
-ThinkLight on most newer ThinkPad models. It may also control LCD
-brightness, sounds volume and more, but only on some models.
+This feature is mostly used internally by the ACPI firmware to keep the legacy
+CMOS NVRAM bits in sync with the current machine state, and to record this
+state so that the ThinkPad will retain such settings across reboots.
+
+Some of these commands actually perform actions in some ThinkPad models, but
+this is expected to disappear more and more in newer models.  As an example, in
+a T43 and in a X40, commands 12 and 13 still control the ThinkLight state for
+real, but commands 0 to 2 don't control the mixer anymore (they have been
+phased out) and just update the NVRAM.
 
 The range of valid cmos command numbers is 0 to 21, but not all have an
 effect and the behavior varies from model to model.  Here is the behavior
 on the X40 (tpb is the ThinkPad Buttons utility):
 
-        0 - no effect but tpb reports "Volume down"
-        1 - no effect but tpb reports "Volume up"
-        2 - no effect but tpb reports "Mute on"
-        3 - simulate pressing the "Access IBM" button
-        4 - LCD brightness up
-        5 - LCD brightness down
-        11 - toggle screen expansion
-        12 - ThinkLight on
-        13 - ThinkLight off
-        14 - no effect but tpb reports ThinkLight status change
+        0 - Related to "Volume down" key press
+        1 - Related to "Volume up" key press
+        2 - Related to "Mute on" key press
+        3 - Related to "Access IBM" key press
+        4 - Related to "LCD brightness up" key pess
+        5 - Related to "LCD brightness down" key press
+        11 - Related to "toggle screen expansion" key press/function
+        12 - Related to "ThinkLight on"
+        13 - Related to "ThinkLight off"
+        14 - Related to "ThinkLight" key press (toggle thinklight)
 
 The cmos command interface is prone to firmware split-brain problems, as
-in newer ThinkPads it is just a compatibility layer.
+in newer ThinkPads it is just a compatibility layer.  Do not use it, it is
+exported just as a debug tool.
 
 LED control -- /proc/acpi/ibm/led
 ---------------------------------
@@ -516,23 +710,15 @@ Temperature sensors
 procfs: /proc/acpi/ibm/thermal
 sysfs device attributes: (hwmon) temp*_input
 
-Most ThinkPads include six or more separate temperature sensors but
-only expose the CPU temperature through the standard ACPI methods.
-This feature shows readings from up to eight different sensors on older
-ThinkPads, and it has experimental support for up to sixteen different
-sensors on newer ThinkPads.
-
-EXPERIMENTAL: The 16-sensors feature is marked EXPERIMENTAL because the
-implementation directly accesses hardware registers and may not work as
-expected. USE WITH CAUTION! To use this feature, you need to supply the
-experimental=1 parameter when loading the module.  When EXPERIMENTAL
-mode is enabled, reading the first 8 sensors on newer ThinkPads will
-also use an new experimental thermal sensor access mode.
+Most ThinkPads include six or more separate temperature sensors but only
+expose the CPU temperature through the standard ACPI methods.  This
+feature shows readings from up to eight different sensors on older
+ThinkPads, and up to sixteen different sensors on newer ThinkPads.
 
 For example, on the X40, a typical output may be:
 temperatures:   42 42 45 41 36 -128 33 -128
 
-EXPERIMENTAL: On the T43/p, a typical output may be:
+On the T43/p, a typical output may be:
 temperatures:   48 48 36 52 38 -128 31 -128 48 52 48 -128 -128 -128 -128 -128
 
 The mapping of thermal sensors to physical locations varies depending on
@@ -562,7 +748,8 @@ http://thinkwiki.org/wiki/Thermal_Sensors#ThinkPad_T43.2C_T43p
 2:  System board, left side (near PCMCIA slot), reported as HDAPS temp
 3:  PCMCIA slot
 9:  MCH (northbridge) to DRAM Bus
-10: ICH (southbridge), under Mini-PCI card, under touchpad
+10: Clock-generator, mini-pci card and ICH (southbridge), under Mini-PCI
+    card, under touchpad
 11: Power regulator, underside of system board, below F2 key
 
 The A31 has a very atypical layout for the thermal sensors
@@ -681,6 +868,12 @@ cannot be controlled.
 The backlight control has eight levels, ranging from 0 to 7.  Some of the
 levels may not be distinct.
 
+There are two interfaces to the firmware for brightness control, EC and CMOS.
+To select which one should be used, use the brightness_mode module parameter:
+brightness_mode=1 selects EC mode, brightness_mode=2 selects CMOS mode,
+brightness_mode=3 selects both EC and CMOS.  The driver tries to autodetect
+which interface to use.
+
 Procfs notes:
 
         The available commands are:
@@ -976,3 +1169,9 @@ Sysfs interface changelog:
 
 0x000100:       Initial sysfs support, as a single platform driver and
                 device.
+0x000200:       Hot key support for 32 hot keys, and radio slider switch
+                support.
+0x010000:       Hot keys are now handled by default over the input
+                layer, the radio switch generates input event EV_RADIO,
+                and the driver enables hot key handling by default in
+                the firmware.
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 1d516f24ba53..aaaa61ea4217 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -150,6 +150,7 @@ config THINKPAD_ACPI
         depends on X86 && ACPI
         select BACKLIGHT_CLASS_DEVICE
         select HWMON
+        select NVRAM
         ---help---
           This is a driver for the IBM and Lenovo ThinkPad laptops. It adds
           support for Fn-Fx key combinations, Bluetooth control, video
@@ -196,4 +197,17 @@ config THINKPAD_ACPI_BAY
 
           If you are not sure, say Y here.
 
+config THINKPAD_ACPI_INPUT_ENABLED
+        bool "Enable input layer support by default"
+        depends on THINKPAD_ACPI
+        default y
+        ---help---
+          Enables hot key handling over the input layer by default.  If unset,
+          the driver does not enable any hot key handling by default, and also
+          starts up with a mostly empty keymap.
+
+          If you are not sure, say Y here.  Say N to retain the deprecated
+          behavior of ibm-acpi, and thinkpad-acpi for kernels up to 2.6.21.
+
+
 endif # MISC_DEVICES
diff --git a/drivers/misc/thinkpad_acpi.c b/drivers/misc/thinkpad_acpi.c
index 95c0b96e83f2..f15a58f7403f 100644
--- a/drivers/misc/thinkpad_acpi.c
+++ b/drivers/misc/thinkpad_acpi.c
@@ -21,8 +21,8 @@
  *  02110-1301, USA.
  */
 
-#define IBM_VERSION "0.14"
-#define TPACPI_SYSFS_VERSION 0x000100
+#define IBM_VERSION "0.15"
+#define TPACPI_SYSFS_VERSION 0x010000
 
 /*
  *  Changelog:
@@ -92,6 +92,29 @@ MODULE_LICENSE("GPL");
 /* Please remove this in year 2009 */
 MODULE_ALIAS("ibm_acpi");
 
+/*
+ * DMI matching for module autoloading
+ *
+ * See http://thinkwiki.org/wiki/List_of_DMI_IDs
+ * See http://thinkwiki.org/wiki/BIOS_Upgrade_Downloads
+ *
+ * Only models listed in thinkwiki will be supported, so add yours
+ * if it is not there yet.
+ */
+#define IBM_BIOS_MODULE_ALIAS(__type) \
+        MODULE_ALIAS("dmi:bvnIBM:bvr" __type "ET??WW")
+
+/* Non-ancient thinkpads */
+MODULE_ALIAS("dmi:bvnIBM:*:svnIBM:*:pvrThinkPad*:rvnIBM:*");
+MODULE_ALIAS("dmi:bvnLENOVO:*:svnLENOVO:*:pvrThinkPad*:rvnLENOVO:*");
+
+/* Ancient thinkpad BIOSes have to be identified by
+ * BIOS type or model number, and there are far less
+ * BIOS types than model numbers... */
+IBM_BIOS_MODULE_ALIAS("I[B,D,H,I,M,N,O,T,W,V,Y,Z]");
+IBM_BIOS_MODULE_ALIAS("1[0,3,6,8,A-G,I,K,M-P,S,T]");
+IBM_BIOS_MODULE_ALIAS("K[U,X-Z]");
+
 #define __unused __attribute__ ((unused))
 
 /****************************************************************************
@@ -106,7 +129,7 @@ MODULE_ALIAS("ibm_acpi");
  * ACPI basic handles
  */
 
-static acpi_handle root_handle = NULL;
+static acpi_handle root_handle;
 
 #define IBM_HANDLE(object, parent, paths...)                    \
         static acpi_handle  object##_handle;                    \
@@ -487,19 +510,36 @@ static char *next_cmd(char **cmds)
 /****************************************************************************
  ****************************************************************************
  *
- * Device model: hwmon and platform
+ * Device model: input, hwmon and platform
  *
  ****************************************************************************
  ****************************************************************************/
 
-static struct platform_device *tpacpi_pdev = NULL;
-static struct class_device *tpacpi_hwmon = NULL;
+static struct platform_device *tpacpi_pdev;
+static struct class_device *tpacpi_hwmon;
+static struct input_dev *tpacpi_inputdev;
+
+
+static int tpacpi_resume_handler(struct platform_device *pdev)
+{
+        struct ibm_struct *ibm, *itmp;
+
+        list_for_each_entry_safe(ibm, itmp,
+                                 &tpacpi_all_drivers,
+                                 all_drivers) {
+                if (ibm->resume)
+                        (ibm->resume)();
+        }
+
+        return 0;
+}
 
 static struct platform_driver tpacpi_pdriver = {
         .driver = {
                 .name = IBM_DRVR_NAME,
                 .owner = THIS_MODULE,
         },
+        .resume = tpacpi_resume_handler,
 };
 
 
@@ -677,9 +717,19 @@ static int __init thinkpad_acpi_driver_init(struct ibm_init_struct *iibm)
         printk(IBM_INFO "%s v%s\n", IBM_DESC, IBM_VERSION);
         printk(IBM_INFO "%s\n", IBM_URL);
 
-        if (ibm_thinkpad_ec_found)
-                printk(IBM_INFO "ThinkPad EC firmware %s\n",
-                       ibm_thinkpad_ec_found);
+        printk(IBM_INFO "ThinkPad BIOS %s, EC %s\n",
+                (thinkpad_id.bios_version_str) ?
+                        thinkpad_id.bios_version_str : "unknown",
+                (thinkpad_id.ec_version_str) ?
+                        thinkpad_id.ec_version_str : "unknown");
+
+        if (thinkpad_id.vendor && thinkpad_id.model_str)
+                printk(IBM_INFO "%s %s\n",
+                        (thinkpad_id.vendor == PCI_VENDOR_ID_IBM) ?
+                                "IBM" : ((thinkpad_id.vendor ==
+                                                PCI_VENDOR_ID_LENOVO) ?
+                                        "Lenovo" : "Unknown vendor"),
+                        thinkpad_id.model_str);
 
         return 0;
 }
@@ -704,16 +754,28 @@ static struct ibm_struct thinkpad_acpi_driver_data = {
  */
 
 static int hotkey_orig_status;
-static int hotkey_orig_mask;
+static u32 hotkey_orig_mask;
+static u32 hotkey_all_mask;
+static u32 hotkey_reserved_mask;
+
+static u16 *hotkey_keycode_map;
 
-static struct attribute_set *hotkey_dev_attributes = NULL;
+static struct attribute_set *hotkey_dev_attributes;
+
+static int hotkey_get_wlsw(int *status)
+{
+        if (!acpi_evalf(hkey_handle, status, "WLSW", "d"))
+                return -EIO;
+        return 0;
+}
 
 /* sysfs hotkey enable ------------------------------------------------- */
 static ssize_t hotkey_enable_show(struct device *dev,
                            struct device_attribute *attr,
                            char *buf)
 {
-        int res, status, mask;
+        int res, status;
+        u32 mask;
 
         res = hotkey_get(&status, &mask);
         if (res)
@@ -727,7 +789,8 @@ static ssize_t hotkey_enable_store(struct device *dev,
                             const char *buf, size_t count)
 {
         unsigned long t;
-        int res, status, mask;
+        int res, status;
+        u32 mask;
 
         if (parse_strtoul(buf, 1, &t))
                 return -EINVAL;
@@ -748,13 +811,14 @@ static ssize_t hotkey_mask_show(struct device *dev,
                            struct device_attribute *attr,
                            char *buf)
 {
-        int res, status, mask;
+        int res, status;
+        u32 mask;
 
         res = hotkey_get(&status, &mask);
         if (res)
                 return res;
 
-        return snprintf(buf, PAGE_SIZE, "0x%04x\n", mask);
+        return snprintf(buf, PAGE_SIZE, "0x%08x\n", mask);
 }
 
 static ssize_t hotkey_mask_store(struct device *dev,
@@ -762,9 +826,10 @@ static ssize_t hotkey_mask_store(struct device *dev,
                             const char *buf, size_t count)
 {
         unsigned long t;
-        int res, status, mask;
+        int res, status;
+        u32 mask;
 
-        if (parse_strtoul(buf, 0xffff, &t))
+        if (parse_strtoul(buf, 0xffffffffUL, &t))
                 return -EINVAL;
 
         res = hotkey_get(&status, &mask);
@@ -794,26 +859,123 @@ static ssize_t hotkey_bios_mask_show(struct device *dev,
                            struct device_attribute *attr,
                            char *buf)
 {
-        return snprintf(buf, PAGE_SIZE, "0x%04x\n", hotkey_orig_mask);
+        return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_orig_mask);
 }
 
 static struct device_attribute dev_attr_hotkey_bios_mask =
         __ATTR(hotkey_bios_mask, S_IRUGO, hotkey_bios_mask_show, NULL);
 
+/* sysfs hotkey all_mask ----------------------------------------------- */
+static ssize_t hotkey_all_mask_show(struct device *dev,
+                           struct device_attribute *attr,
+                           char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "0x%08x\n", hotkey_all_mask);
+}
+
+static struct device_attribute dev_attr_hotkey_all_mask =
+        __ATTR(hotkey_all_mask, S_IRUGO, hotkey_all_mask_show, NULL);
+
+/* sysfs hotkey recommended_mask --------------------------------------- */
+static ssize_t hotkey_recommended_mask_show(struct device *dev,
+                                            struct device_attribute *attr,
+                                            char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "0x%08x\n",
+                        hotkey_all_mask & ~hotkey_reserved_mask);
+}
+
+static struct device_attribute dev_attr_hotkey_recommended_mask =
+        __ATTR(hotkey_recommended_mask, S_IRUGO,
+                hotkey_recommended_mask_show, NULL);
+
+/* sysfs hotkey radio_sw ----------------------------------------------- */
+static ssize_t hotkey_radio_sw_show(struct device *dev,
+                           struct device_attribute *attr,
+                           char *buf)
+{
+        int res, s;
+        res = hotkey_get_wlsw(&s);
+        if (res < 0)
+                return res;
+
+        return snprintf(buf, PAGE_SIZE, "%d\n", !!s);
+}
+
+static struct device_attribute dev_attr_hotkey_radio_sw =
+        __ATTR(hotkey_radio_sw, S_IRUGO, hotkey_radio_sw_show, NULL);
+
 /* --------------------------------------------------------------------- */
 
 static struct attribute *hotkey_mask_attributes[] = {
         &dev_attr_hotkey_mask.attr,
         &dev_attr_hotkey_bios_enabled.attr,
         &dev_attr_hotkey_bios_mask.attr,
+        &dev_attr_hotkey_all_mask.attr,
+        &dev_attr_hotkey_recommended_mask.attr,
 };
 
 static int __init hotkey_init(struct ibm_init_struct *iibm)
 {
-        int res;
+
+        static u16 ibm_keycode_map[] __initdata = {
+                /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
+                KEY_FN_F1,      KEY_FN_F2,      KEY_COFFEE,     KEY_SLEEP,
+                KEY_WLAN,       KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
+                KEY_FN_F9,      KEY_FN_F10,     KEY_FN_F11,     KEY_SUSPEND,
+                /* Scan codes 0x0C to 0x0F: Other ACPI HKEY hot keys */
+                KEY_UNKNOWN,    /* 0x0C: FN+BACKSPACE */
+                KEY_UNKNOWN,    /* 0x0D: FN+INSERT */
+                KEY_UNKNOWN,    /* 0x0E: FN+DELETE */
+                KEY_RESERVED,   /* 0x0F: FN+HOME (brightness up) */
+                /* Scan codes 0x10 to 0x1F: Extended ACPI HKEY hot keys */
+                KEY_RESERVED,   /* 0x10: FN+END (brightness down) */
+                KEY_RESERVED,   /* 0x11: FN+PGUP (thinklight toggle) */
+                KEY_UNKNOWN,    /* 0x12: FN+PGDOWN */
+                KEY_ZOOM,       /* 0x13: FN+SPACE (zoom) */
+                KEY_RESERVED,   /* 0x14: VOLUME UP */
+                KEY_RESERVED,   /* 0x15: VOLUME DOWN */
+                KEY_RESERVED,   /* 0x16: MUTE */
+                KEY_VENDOR,     /* 0x17: Thinkpad/AccessIBM/Lenovo */
+                /* (assignments unknown, please report if found) */
+                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
+                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
+        };
+        static u16 lenovo_keycode_map[] __initdata = {
+                /* Scan Codes 0x00 to 0x0B: ACPI HKEY FN+F1..F12 */
+                KEY_FN_F1,      KEY_COFFEE,     KEY_BATTERY,    KEY_SLEEP,
+                KEY_WLAN,       KEY_FN_F6, KEY_SWITCHVIDEOMODE, KEY_FN_F8,
+                KEY_FN_F9,      KEY_FN_F10,     KEY_FN_F11,     KEY_SUSPEND,
+                /* Scan codes 0x0C to 0x0F: Other ACPI HKEY hot keys */
+                KEY_UNKNOWN,    /* 0x0C: FN+BACKSPACE */
+                KEY_UNKNOWN,    /* 0x0D: FN+INSERT */
+                KEY_UNKNOWN,    /* 0x0E: FN+DELETE */
+                KEY_BRIGHTNESSUP,       /* 0x0F: FN+HOME (brightness up) */
+                /* Scan codes 0x10 to 0x1F: Extended ACPI HKEY hot keys */
+                KEY_BRIGHTNESSDOWN,     /* 0x10: FN+END (brightness down) */
+                KEY_RESERVED,   /* 0x11: FN+PGUP (thinklight toggle) */
+                KEY_UNKNOWN,    /* 0x12: FN+PGDOWN */
+                KEY_ZOOM,       /* 0x13: FN+SPACE (zoom) */
+                KEY_RESERVED,   /* 0x14: VOLUME UP */
+                KEY_RESERVED,   /* 0x15: VOLUME DOWN */
+                KEY_RESERVED,   /* 0x16: MUTE */
+                KEY_VENDOR,     /* 0x17: Thinkpad/AccessIBM/Lenovo */
+                /* (assignments unknown, please report if found) */
+                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
+                KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
+        };
+
+#define TPACPI_HOTKEY_MAP_LEN           ARRAY_SIZE(ibm_keycode_map)
+#define TPACPI_HOTKEY_MAP_SIZE          sizeof(ibm_keycode_map)
+#define TPACPI_HOTKEY_MAP_TYPESIZE      sizeof(ibm_keycode_map[0])
+
+        int res, i;
+        int status;
 
         vdbg_printk(TPACPI_DBG_INIT, "initializing hotkey subdriver\n");
 
+        BUG_ON(!tpacpi_inputdev);
+
         IBM_ACPIHANDLE_INIT(hkey);
         mutex_init(&hotkey_mutex);
 
@@ -824,7 +986,7 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                 str_supported(tp_features.hotkey));
 
         if (tp_features.hotkey) {
-                hotkey_dev_attributes = create_attr_set(4, NULL);
+                hotkey_dev_attributes = create_attr_set(7, NULL);
                 if (!hotkey_dev_attributes)
                         return -ENOMEM;
                 res = add_to_attr_set(hotkey_dev_attributes,
@@ -840,19 +1002,92 @@ static int __init hotkey_init(struct ibm_init_struct *iibm)
                 vdbg_printk(TPACPI_DBG_INIT, "hotkey masks are %s\n",
                         str_supported(tp_features.hotkey_mask));
 
+                if (tp_features.hotkey_mask) {
+                        /* MHKA available in A31, R40, R40e, T4x, X31, and later */
+                        if (!acpi_evalf(hkey_handle, &hotkey_all_mask,
+                                        "MHKA", "qd"))
+                                hotkey_all_mask = 0x080cU; /* FN+F12, FN+F4, FN+F3 */
+                }
+
                 res = hotkey_get(&hotkey_orig_status, &hotkey_orig_mask);
                 if (!res && tp_features.hotkey_mask) {
                         res = add_many_to_attr_set(hotkey_dev_attributes,
                                 hotkey_mask_attributes,
                                 ARRAY_SIZE(hotkey_mask_attributes));
                 }
+
+                /* Not all thinkpads have a hardware radio switch */
+                if (!res && acpi_evalf(hkey_handle, &status, "WLSW", "qd")) {
+                        tp_features.hotkey_wlsw = 1;
+                        printk(IBM_INFO
+                                "radio switch found; radios are %s\n",
+                                enabled(status, 0));
+                        res = add_to_attr_set(hotkey_dev_attributes,
+                                        &dev_attr_hotkey_radio_sw.attr);
+                }
+
                 if (!res)
                         res = register_attr_set_with_sysfs(
                                         hotkey_dev_attributes,
                                         &tpacpi_pdev->dev.kobj);
+                if (res)
+                        return res;
+
+                /* Set up key map */
+
+                hotkey_keycode_map = kmalloc(TPACPI_HOTKEY_MAP_SIZE,
+                                                GFP_KERNEL);
+                if (!hotkey_keycode_map) {
+                        printk(IBM_ERR "failed to allocate memory for key map\n");
+                        return -ENOMEM;
+                }
+
+                if (thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO) {
+                        dbg_printk(TPACPI_DBG_INIT,
+                                   "using Lenovo default hot key map\n");
+                        memcpy(hotkey_keycode_map, &lenovo_keycode_map,
+                                TPACPI_HOTKEY_MAP_SIZE);
+                } else {
+                        dbg_printk(TPACPI_DBG_INIT,
+                                   "using IBM default hot key map\n");
+                        memcpy(hotkey_keycode_map, &ibm_keycode_map,
+                                TPACPI_HOTKEY_MAP_SIZE);
+                }
 
+#ifndef CONFIG_THINKPAD_ACPI_INPUT_ENABLED
+                for (i = 0; i < 12; i++)
+                        hotkey_keycode_map[i] = KEY_UNKNOWN;
+#endif /* ! CONFIG_THINKPAD_ACPI_INPUT_ENABLED */
+
+                set_bit(EV_KEY, tpacpi_inputdev->evbit);
+                set_bit(EV_MSC, tpacpi_inputdev->evbit);
+                set_bit(MSC_SCAN, tpacpi_inputdev->mscbit);
+                tpacpi_inputdev->keycodesize = TPACPI_HOTKEY_MAP_TYPESIZE;
+                tpacpi_inputdev->keycodemax = TPACPI_HOTKEY_MAP_LEN;
+                tpacpi_inputdev->keycode = hotkey_keycode_map;
+                for (i = 0; i < TPACPI_HOTKEY_MAP_LEN; i++) {
+                        if (hotkey_keycode_map[i] != KEY_RESERVED) {
+                                set_bit(hotkey_keycode_map[i],
+                                        tpacpi_inputdev->keybit);
+                        } else {
+                                if (i < sizeof(hotkey_reserved_mask)*8)
+                                        hotkey_reserved_mask |= 1 << i;
+                        }
+                }
+
+                if (tp_features.hotkey_wlsw) {
+                        set_bit(EV_SW, tpacpi_inputdev->evbit);
+                        set_bit(SW_RADIO, tpacpi_inputdev->swbit);
+                }
+
+#ifdef CONFIG_THINKPAD_ACPI_INPUT_ENABLED
+                dbg_printk(TPACPI_DBG_INIT,
+                                "enabling hot key handling\n");
+                res = hotkey_set(1, (hotkey_all_mask & ~hotkey_reserved_mask)
+                                        | hotkey_orig_mask);
                 if (res)
                         return res;
+#endif /* CONFIG_THINKPAD_ACPI_INPUT_ENABLED */
         }
 
         return (tp_features.hotkey)? 0 : 1;
@@ -875,22 +1110,101 @@ static void hotkey_exit(void)
         }
 }
 
+static void tpacpi_input_send_key(unsigned int scancode,
+                                  unsigned int keycode)
+{
+        if (keycode != KEY_RESERVED) {
+                input_report_key(tpacpi_inputdev, keycode, 1);
+                if (keycode == KEY_UNKNOWN)
+                        input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN,
+                                    scancode);
+                input_sync(tpacpi_inputdev);
+
+                input_report_key(tpacpi_inputdev, keycode, 0);
+                if (keycode == KEY_UNKNOWN)
+                        input_event(tpacpi_inputdev, EV_MSC, MSC_SCAN,
+                                    scancode);
+                input_sync(tpacpi_inputdev);
+        }
+}
+
+static void tpacpi_input_send_radiosw(void)
+{
+        int wlsw;
+
+        if (tp_features.hotkey_wlsw && !hotkey_get_wlsw(&wlsw))
+                input_report_switch(tpacpi_inputdev,
+                                    SW_RADIO, !!wlsw);
+}
+
 static void hotkey_notify(struct ibm_struct *ibm, u32 event)
 {
-        int hkey;
+        u32 hkey;
+        unsigned int keycode, scancode;
+        int sendacpi = 1;
+
+        if (event == 0x80 && acpi_evalf(hkey_handle, &hkey, "MHKP", "d")) {
+                if (tpacpi_inputdev->users > 0) {
+                        switch (hkey >> 12) {
+                        case 1:
+                                /* 0x1000-0x1FFF: key presses */
+                                scancode = hkey & 0xfff;
+                                if (scancode > 0 && scancode < 0x21) {
+                                        scancode--;
+                                        keycode = hotkey_keycode_map[scancode];
+                                        tpacpi_input_send_key(scancode, keycode);
+                                        sendacpi = (keycode == KEY_RESERVED
+                                                || keycode == KEY_UNKNOWN);
+                                } else {
+                                        printk(IBM_ERR
+                                               "hotkey 0x%04x out of range for keyboard map\n",
+                                               hkey);
+                                }
+                                break;
+                        case 5:
+                                /* 0x5000-0x5FFF: LID */
+                                /* we don't handle it through this path, just
+                                 * eat up known LID events */
+                                if (hkey != 0x5001 && hkey != 0x5002) {
+                                        printk(IBM_ERR
+                                                "unknown LID-related hotkey event: 0x%04x\n",
+                                                hkey);
+                                }
+                                break;
+                        case 7:
+                                /* 0x7000-0x7FFF: misc */
+                                if (tp_features.hotkey_wlsw && hkey == 0x7000) {
+                                                tpacpi_input_send_radiosw();
+                                                sendacpi = 0;
+                                        break;
+                                }
+                                /* fallthrough to default */
+                        default:
+                                /* case 2: dock-related */
+                                /*      0x2305 - T43 waking up due to bay lever eject while aslept */
+                                /* case 3: ultra-bay related. maybe bay in dock? */
+                                /*      0x3003 - T43 after wake up by bay lever eject (0x2305) */
+                                printk(IBM_NOTICE "unhandled hotkey event 0x%04x\n", hkey);
+                        }
+                }
 
-        if (acpi_evalf(hkey_handle, &hkey, "MHKP", "d"))
-                acpi_bus_generate_event(ibm->acpi->device, event, hkey);
-        else {
-                printk(IBM_ERR "unknown hotkey event %d\n", event);
+                if (sendacpi)
+                        acpi_bus_generate_event(ibm->acpi->device, event, hkey);
+        } else {
+                printk(IBM_ERR "unknown hotkey notification event %d\n", event);
                 acpi_bus_generate_event(ibm->acpi->device, event, 0);
         }
 }
 
+static void hotkey_resume(void)
+{
+        tpacpi_input_send_radiosw();
+}
+
 /*
  * Call with hotkey_mutex held
  */
-static int hotkey_get(int *status, int *mask)
+static int hotkey_get(int *status, u32 *mask)
 {
         if (!acpi_evalf(hkey_handle, status, "DHKC", "d"))
                 return -EIO;
@@ -905,7 +1219,7 @@ static int hotkey_get(int *status, int *mask)
 /*
  * Call with hotkey_mutex held
  */
-static int hotkey_set(int status, int mask)
+static int hotkey_set(int status, u32 mask)
 {
         int i;
 
@@ -926,7 +1240,8 @@ static int hotkey_set(int status, int mask)
 /* procfs -------------------------------------------------------------- */
 static int hotkey_read(char *p)
 {
-        int res, status, mask;
+        int res, status;
+        u32 mask;
         int len = 0;
 
         if (!tp_features.hotkey) {
@@ -944,7 +1259,7 @@ static int hotkey_read(char *p)
 
         len += sprintf(p + len, "status:\t\t%s\n", enabled(status, 0));
         if (tp_features.hotkey_mask) {
-                len += sprintf(p + len, "mask:\t\t0x%04x\n", mask);
+                len += sprintf(p + len, "mask:\t\t0x%08x\n", mask);
                 len += sprintf(p + len,
                                "commands:\tenable, disable, reset, <mask>\n");
         } else {
@@ -957,7 +1272,8 @@ static int hotkey_read(char *p)
 
 static int hotkey_write(char *buf)
 {
-        int res, status, mask;
+        int res, status;
+        u32 mask;
         char *cmd;
         int do_cmd = 0;
 
@@ -1012,6 +1328,7 @@ static struct ibm_struct hotkey_driver_data = {
         .read = hotkey_read,
         .write = hotkey_write,
         .exit = hotkey_exit,
+        .resume = hotkey_resume,
         .acpi = &ibm_hotkey_acpidriver,
 };
 
@@ -1770,7 +2087,10 @@ static struct tp_acpi_drv_struct ibm_dock_acpidriver[2] = {
          .type = ACPI_SYSTEM_NOTIFY,
         },
         {
-         .hid = IBM_PCI_HID,
+        /* THIS ONE MUST NEVER BE USED FOR DRIVER AUTOLOADING.
+         * We just use it to get notifications of dock hotplug
+         * in very old thinkpads */
+         .hid = PCI_ROOT_HID_STRING,
          .notify = dock_notify,
          .handle = &pci_handle,
          .type = ACPI_SYSTEM_NOTIFY,
@@ -1829,7 +2149,7 @@ static int __init dock_init2(struct ibm_init_struct *iibm)
 static void dock_notify(struct ibm_struct *ibm, u32 event)
 {
         int docked = dock_docked();
-        int pci = ibm->acpi->hid && strstr(ibm->acpi->hid, IBM_PCI_HID);
+        int pci = ibm->acpi->hid && strstr(ibm->acpi->hid, PCI_ROOT_HID_STRING);
 
         if (event == 1 && !pci) /* 570 */
                 acpi_bus_generate_event(ibm->acpi->device, event, 1);   /* button */
@@ -2389,7 +2709,7 @@ static int __init thermal_init(struct ibm_init_struct *iibm)
 
         acpi_tmp7 = acpi_evalf(ec_handle, NULL, "TMP7", "qv");
 
-        if (ibm_thinkpad_ec_found && experimental) {
+        if (thinkpad_id.ec_model) {
                 /*
                  * Direct EC access mode: sensors at registers
                  * 0x78-0x7F, 0xC0-0xC7.  Registers return 0x00 for
@@ -2533,6 +2853,8 @@ static int thermal_get_sensor(int idx, s32 *value)
                         snprintf(tmpi, sizeof(tmpi), "TMP%c", '0' + idx);
                         if (!acpi_evalf(ec_handle, &t, tmpi, "d"))
                                 return -EIO;
+                        if (t > 127 || t < -127)
+                                t = TP_EC_THERMAL_TMP_NA;
                         *value = t * 1000;
                         return 0;
                 }
@@ -2671,22 +2993,39 @@ static struct ibm_struct ecdump_driver_data = {
  * Backlight/brightness subdriver
  */
 
-static struct backlight_device *ibm_backlight_device = NULL;
+static struct backlight_device *ibm_backlight_device;
 
 static struct backlight_ops ibm_backlight_data = {
         .get_brightness = brightness_get,
         .update_status  = brightness_update_status,
 };
 
+static struct mutex brightness_mutex;
+
 static int __init brightness_init(struct ibm_init_struct *iibm)
 {
         int b;
 
         vdbg_printk(TPACPI_DBG_INIT, "initializing brightness subdriver\n");
 
+        mutex_init(&brightness_mutex);
+
+        if (!brightness_mode) {
+                if (thinkpad_id.vendor == PCI_VENDOR_ID_LENOVO)
+                        brightness_mode = 2;
+                else
+                        brightness_mode = 3;
+
+                dbg_printk(TPACPI_DBG_INIT, "selected brightness_mode=%d\n",
+                        brightness_mode);
+        }
+
+        if (brightness_mode > 3)
+                return -EINVAL;
+
         b = brightness_get(NULL);
         if (b < 0)
-                return b;
+                return 1;
 
         ibm_backlight_device = backlight_device_register(
                                         TPACPI_BACKLIGHT_DEV_NAME, NULL, NULL,
@@ -2722,34 +3061,79 @@ static int brightness_update_status(struct backlight_device *bd)
                                 bd->props.brightness : 0);
 }
 
+/*
+ * ThinkPads can read brightness from two places: EC 0x31, or
+ * CMOS NVRAM byte 0x5E, bits 0-3.
+ */
 static int brightness_get(struct backlight_device *bd)
 {
-        u8 level;
-        if (!acpi_ec_read(brightness_offset, &level))
-                return -EIO;
+        u8 lec = 0, lcmos = 0, level = 0;
 
-        level &= 0x7;
+        if (brightness_mode & 1) {
+                if (!acpi_ec_read(brightness_offset, &lec))
+                        return -EIO;
+                lec &= 7;
+                level = lec;
+        };
+        if (brightness_mode & 2) {
+                lcmos = (nvram_read_byte(TP_NVRAM_ADDR_BRIGHTNESS)
+                         & TP_NVRAM_MASK_LEVEL_BRIGHTNESS)
+                        >> TP_NVRAM_POS_LEVEL_BRIGHTNESS;
+                level = lcmos;
+        }
+
+        if (brightness_mode == 3 && lec != lcmos) {
+                printk(IBM_ERR
+                        "CMOS NVRAM (%u) and EC (%u) do not agree "
+                        "on display brightness level\n",
+                        (unsigned int) lcmos,
+                        (unsigned int) lec);
+                return -EIO;
+        }
 
         return level;
 }
 
 static int brightness_set(int value)
 {
-        int cmos_cmd, inc, i;
-        int current_value = brightness_get(NULL);
+        int cmos_cmd, inc, i, res;
+        int current_value;
+
+        if (value > 7)
+                return -EINVAL;
 
-        value &= 7;
+        res = mutex_lock_interruptible(&brightness_mutex);
+        if (res < 0)
+                return res;
+
+        current_value = brightness_get(NULL);
+        if (current_value < 0) {
+                res = current_value;
+                goto errout;
+        }
 
-        cmos_cmd = value > current_value ? TP_CMOS_BRIGHTNESS_UP : TP_CMOS_BRIGHTNESS_DOWN;
+        cmos_cmd = value > current_value ?
+                        TP_CMOS_BRIGHTNESS_UP :
+                        TP_CMOS_BRIGHTNESS_DOWN;
         inc = value > current_value ? 1 : -1;
+
+        res = 0;
         for (i = current_value; i != value; i += inc) {
-                if (issue_thinkpad_cmos_command(cmos_cmd))
-                        return -EIO;
-                if (!acpi_ec_write(brightness_offset, i + inc))
-                        return -EIO;
+                if ((brightness_mode & 2) &&
+                    issue_thinkpad_cmos_command(cmos_cmd)) {
+                        res = -EIO;
+                        goto errout;
+                }
+                if ((brightness_mode & 1) &&
+                    !acpi_ec_write(brightness_offset, i + inc)) {
+                        res = -EIO;
+                        goto errout;;
+                }
         }
 
-        return 0;
+errout:
+        mutex_unlock(&brightness_mutex);
+        return res;
 }
 
 static int brightness_read(char *p)
@@ -3273,20 +3657,19 @@ static int __init fan_init(struct ibm_init_struct *iibm)
                          * Enable for TP-1Y (T43), TP-78 (R51e),
                          * TP-76 (R52), TP-70 (T43, R52), which are known
                          * to be buggy. */
-                        if (fan_control_initial_status == 0x07 &&
-                            ibm_thinkpad_ec_found &&
-                            ((ibm_thinkpad_ec_found[0] == '1' &&
-                              ibm_thinkpad_ec_found[1] == 'Y') ||
-                             (ibm_thinkpad_ec_found[0] == '7' &&
-                              (ibm_thinkpad_ec_found[1] == '6' ||
-                               ibm_thinkpad_ec_found[1] == '8' ||
-                               ibm_thinkpad_ec_found[1] == '0'))
-                            )) {
-                                printk(IBM_NOTICE
-                                       "fan_init: initial fan status is "
-                                       "unknown, assuming it is in auto "
-                                       "mode\n");
-                                tp_features.fan_ctrl_status_undef = 1;
+                        if (fan_control_initial_status == 0x07) {
+                                switch (thinkpad_id.ec_model) {
+                                case 0x5931: /* TP-1Y */
+                                case 0x3837: /* TP-78 */
+                                case 0x3637: /* TP-76 */
+                                case 0x3037: /* TP-70 */
+                                        printk(IBM_NOTICE
+                                               "fan_init: initial fan status is "
+                                               "unknown, assuming it is in auto "
+                                               "mode\n");
+                                        tp_features.fan_ctrl_status_undef = 1;
+                                        ;;
+                                }
                         }
                 } else {
                         printk(IBM_ERR
@@ -3474,7 +3857,7 @@ static void fan_watchdog_fire(struct work_struct *ignored)
 
 static void fan_watchdog_reset(void)
 {
-        static int fan_watchdog_active = 0;
+        static int fan_watchdog_active;
 
         if (fan_control_access_mode == TPACPI_FAN_WR_NONE)
                 return;
@@ -3877,7 +4260,7 @@ static struct ibm_struct fan_driver_data = {
  ****************************************************************************/
 
 /* /proc support */
-static struct proc_dir_entry *proc_dir = NULL;
+static struct proc_dir_entry *proc_dir;
 
 /* Subdriver registry */
 static LIST_HEAD(tpacpi_all_drivers);
@@ -4020,13 +4403,30 @@ static void ibm_exit(struct ibm_struct *ibm)
 
 /* Probing */
 
-static char *ibm_thinkpad_ec_found = NULL;
-
-static char* __init check_dmi_for_ec(void)
+static void __init get_thinkpad_model_data(struct thinkpad_id_data *tp)
 {
         struct dmi_device *dev = NULL;
         char ec_fw_string[18];
 
+        if (!tp)
+                return;
+
+        memset(tp, 0, sizeof(*tp));
+
+        if (dmi_name_in_vendors("IBM"))
+                tp->vendor = PCI_VENDOR_ID_IBM;
+        else if (dmi_name_in_vendors("LENOVO"))
+                tp->vendor = PCI_VENDOR_ID_LENOVO;
+        else
+                return;
+
+        tp->bios_version_str = kstrdup(dmi_get_system_info(DMI_BIOS_VERSION),
+                                        GFP_KERNEL);
+        if (!tp->bios_version_str)
+                return;
+        tp->bios_model = tp->bios_version_str[0]
+                         | (tp->bios_version_str[1] << 8);
+
         /*
          * ThinkPad T23 or newer, A31 or newer, R50e or newer,
          * X32 or newer, all Z series;  Some models must have an
@@ -4040,10 +4440,20 @@ static char* __init check_dmi_for_ec(void)
                            ec_fw_string) == 1) {
                         ec_fw_string[sizeof(ec_fw_string) - 1] = 0;
                         ec_fw_string[strcspn(ec_fw_string, " ]")] = 0;
-                        return kstrdup(ec_fw_string, GFP_KERNEL);
+
+                        tp->ec_version_str = kstrdup(ec_fw_string, GFP_KERNEL);
+                        tp->ec_model = ec_fw_string[0]
+                                        | (ec_fw_string[1] << 8);
+                        break;
                 }
         }
-        return NULL;
+
+        tp->model_str = kstrdup(dmi_get_system_info(DMI_PRODUCT_VERSION),
+                                        GFP_KERNEL);
+        if (strnicmp(tp->model_str, "ThinkPad", 8) != 0) {
+                kfree(tp->model_str);
+                tp->model_str = NULL;
+        }
 }
 
 static int __init probe_for_thinkpad(void)
@@ -4057,7 +4467,7 @@ static int __init probe_for_thinkpad(void)
          * Non-ancient models have better DMI tagging, but very old models
          * don't.
          */
-        is_thinkpad = dmi_name_in_vendors("ThinkPad");
+        is_thinkpad = (thinkpad_id.model_str != NULL);
 
         /* ec is required because many other handles are relative to it */
         IBM_ACPIHANDLE_INIT(ec);
@@ -4073,7 +4483,7 @@ static int __init probe_for_thinkpad(void)
          * false positives a damn great deal
          */
         if (!is_thinkpad)
-                is_thinkpad = dmi_name_in_vendors("IBM");
+                is_thinkpad = (thinkpad_id.vendor == PCI_VENDOR_ID_IBM);
 
         if (!is_thinkpad && !force_load)
                 return -ENODEV;
@@ -4185,10 +4595,13 @@ static u32 dbg_level;
 module_param_named(debug, dbg_level, uint, 0);
 
 static int force_load;
-module_param(force_load, int, 0);
+module_param(force_load, bool, 0);
 
 static int fan_control_allowed;
-module_param_named(fan_control, fan_control_allowed, int, 0);
+module_param_named(fan_control, fan_control_allowed, bool, 0);
+
+static int brightness_mode;
+module_param_named(brightness_mode, brightness_mode, int, 0);
 
 #define IBM_PARAM(feature) \
         module_param_call(feature, set_ibm_param, NULL, NULL, 0)
@@ -4216,12 +4629,16 @@ static int __init thinkpad_acpi_module_init(void)
         int ret, i;
 
         /* Driver-level probe */
+
+        get_thinkpad_model_data(&thinkpad_id);
         ret = probe_for_thinkpad();
-        if (ret)
+        if (ret) {
+                thinkpad_acpi_module_exit();
                 return ret;
+        }
 
         /* Driver initialization */
-        ibm_thinkpad_ec_found = check_dmi_for_ec();
+
         IBM_ACPIHANDLE_INIT(ecrd);
         IBM_ACPIHANDLE_INIT(ecwr);
 
@@ -4265,6 +4682,22 @@ static int __init thinkpad_acpi_module_init(void)
                 thinkpad_acpi_module_exit();
                 return ret;
         }
+        tpacpi_inputdev = input_allocate_device();
+        if (!tpacpi_inputdev) {
+                printk(IBM_ERR "unable to allocate input device\n");
+                thinkpad_acpi_module_exit();
+                return -ENOMEM;
+        } else {
+                /* Prepare input device, but don't register */
+                tpacpi_inputdev->name = "ThinkPad Extra Buttons";
+                tpacpi_inputdev->phys = IBM_DRVR_NAME "/input0";
+                tpacpi_inputdev->id.bustype = BUS_HOST;
+                tpacpi_inputdev->id.vendor = (thinkpad_id.vendor) ?
+                                                thinkpad_id.vendor :
+                                                PCI_VENDOR_ID_IBM;
+                tpacpi_inputdev->id.product = TPACPI_HKEY_INPUT_PRODUCT;
+                tpacpi_inputdev->id.version = TPACPI_HKEY_INPUT_VERSION;
+        }
         for (i = 0; i < ARRAY_SIZE(ibms_init); i++) {
                 ret = ibm_init(&ibms_init[i]);
                 if (ret >= 0 && *ibms_init[i].param)
@@ -4274,6 +4707,14 @@ static int __init thinkpad_acpi_module_init(void)
                         return ret;
                 }
         }
+        ret = input_register_device(tpacpi_inputdev);
+        if (ret < 0) {
+                printk(IBM_ERR "unable to register input device\n");
+                thinkpad_acpi_module_exit();
+                return ret;
+        } else {
+                tp_features.input_device_registered = 1;
+        }
 
         return 0;
 }
@@ -4290,6 +4731,13 @@ static void thinkpad_acpi_module_exit(void)
 
         dbg_printk(TPACPI_DBG_INIT, "finished subdriver exit path...\n");
 
+        if (tpacpi_inputdev) {
+                if (tp_features.input_device_registered)
+                        input_unregister_device(tpacpi_inputdev);
+                else
+                        input_free_device(tpacpi_inputdev);
+        }
+
         if (tpacpi_hwmon)
                 hwmon_device_unregister(tpacpi_hwmon);
 
@@ -4302,7 +4750,9 @@ static void thinkpad_acpi_module_exit(void)
         if (proc_dir)
                 remove_proc_entry(IBM_PROC_DIR, acpi_root_dir);
 
-        kfree(ibm_thinkpad_ec_found);
+        kfree(thinkpad_id.bios_version_str);
+        kfree(thinkpad_id.ec_version_str);
+        kfree(thinkpad_id.model_str);
 }
 
 module_init(thinkpad_acpi_module_init);
diff --git a/drivers/misc/thinkpad_acpi.h b/drivers/misc/thinkpad_acpi.h
index 72d62f2dabb9..b7a4a888cc8b 100644
--- a/drivers/misc/thinkpad_acpi.h
+++ b/drivers/misc/thinkpad_acpi.h
@@ -32,6 +32,7 @@
 #include <linux/list.h>
 #include <linux/mutex.h>
 
+#include <linux/nvram.h>
 #include <linux/proc_fs.h>
 #include <linux/sysfs.h>
 #include <linux/backlight.h>
@@ -39,6 +40,7 @@
 #include <linux/platform_device.h>
 #include <linux/hwmon.h>
 #include <linux/hwmon-sysfs.h>
+#include <linux/input.h>
 #include <asm/uaccess.h>
 
 #include <linux/dmi.h>
@@ -48,6 +50,7 @@
 #include <acpi/acpi_drivers.h>
 #include <acpi/acnamesp.h>
 
+#include <linux/pci_ids.h>
 
 /****************************************************************************
  * Main driver
@@ -78,6 +81,11 @@
 #define TP_CMOS_BRIGHTNESS_UP   4
 #define TP_CMOS_BRIGHTNESS_DOWN 5
 
+/* ThinkPad CMOS NVRAM constants */
+#define TP_NVRAM_ADDR_BRIGHTNESS       0x5e
+#define TP_NVRAM_MASK_LEVEL_BRIGHTNESS 0x07
+#define TP_NVRAM_POS_LEVEL_BRIGHTNESS 0
+
 #define onoff(status,bit) ((status) & (1 << (bit)) ? "on" : "off")
 #define enabled(status,bit) ((status) & (1 << (bit)) ? "enabled" : "disabled")
 #define strlencmp(a,b) (strncmp((a), (b), strlen(b)))
@@ -98,9 +106,13 @@ static const char *str_supported(int is_supported);
 #define vdbg_printk(a_dbg_level, format, arg...)
 #endif
 
+/* Input IDs */
+#define TPACPI_HKEY_INPUT_VENDOR        PCI_VENDOR_ID_IBM
+#define TPACPI_HKEY_INPUT_PRODUCT       0x5054 /* "TP" */
+#define TPACPI_HKEY_INPUT_VERSION       0x4101
+
 /* ACPI HIDs */
 #define IBM_HKEY_HID    "IBM0068"
-#define IBM_PCI_HID     "PNP0A03"
 
 /* ACPI helpers */
 static int __must_check acpi_evalf(acpi_handle handle,
@@ -161,6 +173,7 @@ static int parse_strtoul(const char *buf, unsigned long max,
 static struct platform_device *tpacpi_pdev;
 static struct class_device *tpacpi_hwmon;
 static struct platform_driver tpacpi_pdriver;
+static struct input_dev *tpacpi_inputdev;
 static int tpacpi_create_driver_attributes(struct device_driver *drv);
 static void tpacpi_remove_driver_attributes(struct device_driver *drv);
 
@@ -168,9 +181,7 @@ static void tpacpi_remove_driver_attributes(struct device_driver *drv);
 static int experimental;
 static u32 dbg_level;
 static int force_load;
-static char *ibm_thinkpad_ec_found;
 
-static char* check_dmi_for_ec(void);
 static int thinkpad_acpi_module_init(void);
 static void thinkpad_acpi_module_exit(void);
 
@@ -197,6 +208,7 @@ struct ibm_struct {
         int (*read) (char *);
         int (*write) (char *);
         void (*exit) (void);
+        void (*resume) (void);
 
         struct list_head all_drivers;
 
@@ -228,12 +240,29 @@ static struct {
         u16 bluetooth:1;
         u16 hotkey:1;
         u16 hotkey_mask:1;
+        u16 hotkey_wlsw:1;
         u16 light:1;
         u16 light_status:1;
         u16 wan:1;
         u16 fan_ctrl_status_undef:1;
+        u16 input_device_registered:1;
 } tp_features;
 
+struct thinkpad_id_data {
+        unsigned int vendor;    /* ThinkPad vendor:
+                                 * PCI_VENDOR_ID_IBM/PCI_VENDOR_ID_LENOVO */
+
+        char *bios_version_str; /* Something like 1ZET51WW (1.03z) */
+        char *ec_version_str;   /* Something like 1ZHT51WW-1.04a */
+
+        u16 bios_model;         /* Big Endian, TP-1Y = 0x5931, 0 = unknown */
+        u16 ec_model;
+
+        char *model_str;
+};
+
+static struct thinkpad_id_data thinkpad_id;
+
 static struct list_head tpacpi_all_drivers;
 
 static struct ibm_init_struct ibms_init[];
@@ -300,6 +329,7 @@ static int bluetooth_write(char *buf);
 
 static struct backlight_device *ibm_backlight_device;
 static int brightness_offset = 0x31;
+static int brightness_mode;
 
 static int brightness_init(struct ibm_init_struct *iibm);
 static void brightness_exit(void);
@@ -415,14 +445,14 @@ static int fan_write_cmd_watchdog(const char *cmd, int *rc);
  */
 
 static int hotkey_orig_status;
-static int hotkey_orig_mask;
+static u32 hotkey_orig_mask;
 
 static struct mutex hotkey_mutex;
 
 static int hotkey_init(struct ibm_init_struct *iibm);
 static void hotkey_exit(void);
-static int hotkey_get(int *status, int *mask);
-static int hotkey_set(int status, int mask);
+static int hotkey_get(int *status, u32 *mask);
+static int hotkey_set(int status, u32 mask);
 static void hotkey_notify(struct ibm_struct *ibm, u32 event);
 static int hotkey_read(char *p);
 static int hotkey_write(char *buf);
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index b15c6498fe67..ced4d3f76104 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2040,6 +2040,8 @@
 #define PCI_DEVICE_ID_ALTIMA_AC9100     0x03ea
 #define PCI_DEVICE_ID_ALTIMA_AC1003     0x03eb
 
+#define PCI_VENDOR_ID_LENOVO            0x17aa
+
 #define PCI_VENDOR_ID_ARECA             0x17d3
 #define PCI_DEVICE_ID_ARECA_1110        0x1110
 #define PCI_DEVICE_ID_ARECA_1120        0x1120