65 files changed, 4776 insertions, 803 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 139f41f033..408b45168a 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -2,16 +2,12 @@
 # ACPI Configuration
 #
 
-menu "ACPI (Advanced Configuration and Power Interface) Support"
+menuconfig ACPI
+        bool "ACPI Support (Advanced Configuration and Power Interface) Support"
         depends on !X86_NUMAQ
         depends on !X86_VISWS
         depends on !IA64_HP_SIM
         depends on IA64 || X86
-        depends on PM
-
-config ACPI
-        bool "ACPI Support"
-        depends on IA64 || X86
         depends on PCI
         depends on PM
         select PNP
@@ -49,7 +45,6 @@ if ACPI
 config ACPI_SLEEP
         bool "Sleep States"
         depends on X86 && (!SMP || SUSPEND_SMP)
-        depends on PM
         default y
         ---help---
           This option adds support for ACPI suspend states. 
@@ -82,7 +77,6 @@ config ACPI_SLEEP_PROC_SLEEP
 
 config ACPI_PROCFS
         bool "Procfs interface (deprecated)"
-        depends on ACPI
         default y
         ---help---
           The Procfs interface for ACPI is made optional for backward compatibility.
@@ -124,7 +118,7 @@ config ACPI_BUTTON
 
 config ACPI_VIDEO
         tristate "Video"
-        depends on X86 && BACKLIGHT_CLASS_DEVICE
+        depends on X86 && BACKLIGHT_CLASS_DEVICE && VIDEO_OUTPUT_CONTROL
         help
           This driver implement the ACPI Extensions For Display Adapters
           for integrated graphics devices on motherboard, as specified in
@@ -280,6 +274,14 @@ config ACPI_DEBUG
           of verbosity. Saying Y enables these statements. This will increase
           your kernel size by around 50K.
 
+config ACPI_DEBUG_FUNC_TRACE
+        bool "Additionally enable ACPI function tracing"
+        default n
+        depends on ACPI_DEBUG
+        help
+          ACPI Debug Statements slow down ACPI processing. Function trace
+          is about half of the penalty and is rarely useful.
+
 config ACPI_EC
         bool
         default y
@@ -330,7 +332,6 @@ config ACPI_CONTAINER
 
 config ACPI_HOTPLUG_MEMORY
         tristate "Memory Hotplug"
-        depends on ACPI
         depends on MEMORY_HOTPLUG
         default n
         help
@@ -359,5 +360,3 @@ config ACPI_SBS
           to today's ACPI "Control Method" battery.
 
 endif   # ACPI
-
-endmenu
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index e64c76c8b7..cad932de38 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -43,21 +43,30 @@
 #define ACPI_BATTERY_CLASS              "battery"
 #define ACPI_BATTERY_HID                "PNP0C0A"
 #define ACPI_BATTERY_DEVICE_NAME        "Battery"
-#define ACPI_BATTERY_FILE_INFO          "info"
-#define ACPI_BATTERY_FILE_STATUS        "state"
-#define ACPI_BATTERY_FILE_ALARM         "alarm"
 #define ACPI_BATTERY_NOTIFY_STATUS      0x80
 #define ACPI_BATTERY_NOTIFY_INFO        0x81
 #define ACPI_BATTERY_UNITS_WATTS        "mW"
 #define ACPI_BATTERY_UNITS_AMPS         "mA"
 
 #define _COMPONENT              ACPI_BATTERY_COMPONENT
+
+#define ACPI_BATTERY_UPDATE_TIME        0
+
+#define ACPI_BATTERY_NONE_UPDATE        0
+#define ACPI_BATTERY_EASY_UPDATE        1
+#define ACPI_BATTERY_INIT_UPDATE        2
+
 ACPI_MODULE_NAME("battery");
 
 MODULE_AUTHOR("Paul Diefenbaugh");
 MODULE_DESCRIPTION("ACPI Battery Driver");
 MODULE_LICENSE("GPL");
 
+static unsigned int update_time = ACPI_BATTERY_UPDATE_TIME;
+
+/* 0 - every time, > 0 - by update_time */
+module_param(update_time, uint, 0644);
+
 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
 
@@ -76,7 +85,7 @@ static struct acpi_driver acpi_battery_driver = {
                 },
 };
 
-struct acpi_battery_status {
+struct acpi_battery_state {
         acpi_integer state;
         acpi_integer present_rate;
         acpi_integer remaining_capacity;
@@ -99,33 +108,111 @@ struct acpi_battery_info {
         acpi_string oem_info;
 };
 
-struct acpi_battery_flags {
-        u8 present:1;           /* Bay occupied? */
-        u8 power_unit:1;        /* 0=watts, 1=apms */
-        u8 alarm:1;             /* _BTP present? */
-        u8 reserved:5;
+enum acpi_battery_files{
+        ACPI_BATTERY_INFO = 0,
+        ACPI_BATTERY_STATE,
+        ACPI_BATTERY_ALARM,
+        ACPI_BATTERY_NUMFILES,
 };
 
-struct acpi_battery_trips {
-        unsigned long warning;
-        unsigned long low;
+struct acpi_battery_flags {
+        u8 battery_present_prev;
+        u8 alarm_present;
+        u8 init_update;
+        u8 update[ACPI_BATTERY_NUMFILES];
+        u8 power_unit;
 };
 
 struct acpi_battery {
-        struct acpi_device * device;
+        struct mutex mutex;
+        struct acpi_device *device;
         struct acpi_battery_flags flags;
-        struct acpi_battery_trips trips;
+        struct acpi_buffer bif_data;
+        struct acpi_buffer bst_data;
         unsigned long alarm;
-        struct acpi_battery_info *info;
+        unsigned long update_time[ACPI_BATTERY_NUMFILES];
 };
 
+inline int acpi_battery_present(struct acpi_battery *battery)
+{
+        return battery->device->status.battery_present;
+}
+inline char *acpi_battery_power_units(struct acpi_battery *battery)
+{
+        if (battery->flags.power_unit)
+                return ACPI_BATTERY_UNITS_AMPS;
+        else
+                return ACPI_BATTERY_UNITS_WATTS;
+}
+
+inline acpi_handle acpi_battery_handle(struct acpi_battery *battery)
+{
+        return battery->device->handle;
+}
+
 /* --------------------------------------------------------------------------
                                Battery Management
    -------------------------------------------------------------------------- */
 
-static int
-acpi_battery_get_info(struct acpi_battery *battery,
-                      struct acpi_battery_info **bif)
+static void acpi_battery_check_result(struct acpi_battery *battery, int result)
+{
+        if (!battery)
+                return;
+
+        if (result) {
+                battery->flags.init_update = 1;
+        }
+}
+
+static int acpi_battery_extract_package(struct acpi_battery *battery,
+                                        union acpi_object *package,
+                                        struct acpi_buffer *format,
+                                        struct acpi_buffer *data,
+                                        char *package_name)
+{
+        acpi_status status = AE_OK;
+        struct acpi_buffer data_null = { 0, NULL };
+
+        status = acpi_extract_package(package, format, &data_null);
+        if (status != AE_BUFFER_OVERFLOW) {
+                ACPI_EXCEPTION((AE_INFO, status, "Extracting size %s",
+                                package_name));
+                return -ENODEV;
+        }
+
+        if (data_null.length != data->length) {
+                kfree(data->pointer);
+                data->pointer = kzalloc(data_null.length, GFP_KERNEL);
+                if (!data->pointer) {
+                        ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY, "kzalloc()"));
+                        return -ENOMEM;
+                }
+                data->length = data_null.length;
+        }
+
+        status = acpi_extract_package(package, format, data);
+        if (ACPI_FAILURE(status)) {
+                ACPI_EXCEPTION((AE_INFO, status, "Extracting %s",
+                                package_name));
+                return -ENODEV;
+        }
+
+        return 0;
+}
+
+static int acpi_battery_get_status(struct acpi_battery *battery)
+{
+        int result = 0;
+
+        result = acpi_bus_get_status(battery->device);
+        if (result) {
+                ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
+                return -ENODEV;
+        }
+        return result;
+}
+
+static int acpi_battery_get_info(struct acpi_battery *battery)
 {
         int result = 0;
         acpi_status status = 0;
@@ -133,16 +220,20 @@ acpi_battery_get_info(struct acpi_battery *battery,
         struct acpi_buffer format = { sizeof(ACPI_BATTERY_FORMAT_BIF),
                 ACPI_BATTERY_FORMAT_BIF
         };
-        struct acpi_buffer data = { 0, NULL };
         union acpi_object *package = NULL;
+        struct acpi_buffer *data = NULL;
+        struct acpi_battery_info *bif = NULL;
 
+        battery->update_time[ACPI_BATTERY_INFO] = get_seconds();
 
-        if (!battery || !bif)
-                return -EINVAL;
+        if (!acpi_battery_present(battery))
+                return 0;
 
-        /* Evalute _BIF */
+        /* Evaluate _BIF */
 
-        status = acpi_evaluate_object(battery->device->handle, "_BIF", NULL, &buffer);
+        status =
+            acpi_evaluate_object(acpi_battery_handle(battery), "_BIF", NULL,
+                                 &buffer);
         if (ACPI_FAILURE(status)) {
                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));
                 return -ENODEV;
@@ -150,41 +241,29 @@ acpi_battery_get_info(struct acpi_battery *battery,
 
         package = buffer.pointer;
 
-        /* Extract Package Data */
-
-        status = acpi_extract_package(package, &format, &data);
-        if (status != AE_BUFFER_OVERFLOW) {
-                ACPI_EXCEPTION((AE_INFO, status, "Extracting _BIF"));
-                result = -ENODEV;
-                goto end;
-        }
+        data = &battery->bif_data;
 
-        data.pointer = kzalloc(data.length, GFP_KERNEL);
-        if (!data.pointer) {
-                result = -ENOMEM;
-                goto end;
-        }
+        /* Extract Package Data */
 
-        status = acpi_extract_package(package, &format, &data);
-        if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status, "Extracting _BIF"));
-                kfree(data.pointer);
-                result = -ENODEV;
+        result =
+            acpi_battery_extract_package(battery, package, &format, data,
+                                         "_BIF");
+        if (result)
                 goto end;
-        }
 
       end:
+
         kfree(buffer.pointer);
 
-        if (!result)
-                (*bif) = data.pointer;
+        if (!result) {
+                bif = data->pointer;
+                battery->flags.power_unit = bif->power_unit;
+        }
 
         return result;
 }
 
-static int
-acpi_battery_get_status(struct acpi_battery *battery,
-                        struct acpi_battery_status **bst)
+static int acpi_battery_get_state(struct acpi_battery *battery)
 {
         int result = 0;
         acpi_status status = 0;
@@ -192,16 +271,19 @@ acpi_battery_get_status(struct acpi_battery *battery,
         struct acpi_buffer format = { sizeof(ACPI_BATTERY_FORMAT_BST),
                 ACPI_BATTERY_FORMAT_BST
         };
-        struct acpi_buffer data = { 0, NULL };
         union acpi_object *package = NULL;
+        struct acpi_buffer *data = NULL;
 
+        battery->update_time[ACPI_BATTERY_STATE] = get_seconds();
 
-        if (!battery || !bst)
-                return -EINVAL;
+        if (!acpi_battery_present(battery))
+                return 0;
 
-        /* Evalute _BST */
+        /* Evaluate _BST */
 
-        status = acpi_evaluate_object(battery->device->handle, "_BST", NULL, &buffer);
+        status =
+            acpi_evaluate_object(acpi_battery_handle(battery), "_BST", NULL,
+                                 &buffer);
         if (ACPI_FAILURE(status)) {
                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
                 return -ENODEV;
@@ -209,55 +291,49 @@ acpi_battery_get_status(struct acpi_battery *battery,
 
         package = buffer.pointer;
 
-        /* Extract Package Data */
-
-        status = acpi_extract_package(package, &format, &data);
-        if (status != AE_BUFFER_OVERFLOW) {
-                ACPI_EXCEPTION((AE_INFO, status, "Extracting _BST"));
-                result = -ENODEV;
-                goto end;
-        }
+        data = &battery->bst_data;
 
-        data.pointer = kzalloc(data.length, GFP_KERNEL);
-        if (!data.pointer) {
-                result = -ENOMEM;
-                goto end;
-        }
+        /* Extract Package Data */
 
-        status = acpi_extract_package(package, &format, &data);
-        if (ACPI_FAILURE(status)) {
-                ACPI_EXCEPTION((AE_INFO, status, "Extracting _BST"));
-                kfree(data.pointer);
-                result = -ENODEV;
+        result =
+            acpi_battery_extract_package(battery, package, &format, data,
+                                         "_BST");
+        if (result)
                 goto end;
-        }
 
       end:
         kfree(buffer.pointer);
 
-        if (!result)
-                (*bst) = data.pointer;
-
         return result;
 }
 
-static int
-acpi_battery_set_alarm(struct acpi_battery *battery, unsigned long alarm)
+static int acpi_battery_get_alarm(struct acpi_battery *battery)
+{
+        battery->update_time[ACPI_BATTERY_ALARM] = get_seconds();
+
+        return 0;
+}
+
+static int acpi_battery_set_alarm(struct acpi_battery *battery,
+                                  unsigned long alarm)
 {
         acpi_status status = 0;
         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
         struct acpi_object_list arg_list = { 1, &arg0 };
 
+        battery->update_time[ACPI_BATTERY_ALARM] = get_seconds();
 
-        if (!battery)
-                return -EINVAL;
+        if (!acpi_battery_present(battery))
+                return -ENODEV;
 
-        if (!battery->flags.alarm)
+        if (!battery->flags.alarm_present)
                 return -ENODEV;
 
         arg0.integer.value = alarm;
 
-        status = acpi_evaluate_object(battery->device->handle, "_BTP", &arg_list, NULL);
+        status =
+            acpi_evaluate_object(acpi_battery_handle(battery), "_BTP",
+                                 &arg_list, NULL);
         if (ACPI_FAILURE(status))
                 return -ENODEV;
 
@@ -268,65 +344,114 @@ acpi_battery_set_alarm(struct acpi_battery *battery, unsigned long alarm)
         return 0;
 }
 
-static int acpi_battery_check(struct acpi_battery *battery)
+static int acpi_battery_init_alarm(struct acpi_battery *battery)
 {
         int result = 0;
         acpi_status status = AE_OK;
         acpi_handle handle = NULL;
-        struct acpi_device *device = NULL;
-        struct acpi_battery_info *bif = NULL;
+        struct acpi_battery_info *bif = battery->bif_data.pointer;
+        unsigned long alarm = battery->alarm;
 
+        /* See if alarms are supported, and if so, set default */
 
-        if (!battery)
-                return -EINVAL;
-
-        device = battery->device;
+        status = acpi_get_handle(acpi_battery_handle(battery), "_BTP", &handle);
+        if (ACPI_SUCCESS(status)) {
+                battery->flags.alarm_present = 1;
+                if (!alarm && bif) {
+                        alarm = bif->design_capacity_warning;
+                }
+                result = acpi_battery_set_alarm(battery, alarm);
+                if (result)
+                        goto end;
+        } else {
+                battery->flags.alarm_present = 0;
+        }
 
-        result = acpi_bus_get_status(device);
-        if (result)
-                return result;
+      end:
 
-        /* Insertion? */
+        return result;
+}
 
-        if (!battery->flags.present && device->status.battery_present) {
+static int acpi_battery_init_update(struct acpi_battery *battery)
+{
+        int result = 0;
 
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Battery inserted\n"));
+        result = acpi_battery_get_status(battery);
+        if (result)
+                return result;
 
-                /* Evalute _BIF to get certain static information */
+        battery->flags.battery_present_prev = acpi_battery_present(battery);
 
-                result = acpi_battery_get_info(battery, &bif);
+        if (acpi_battery_present(battery)) {
+                result = acpi_battery_get_info(battery);
+                if (result)
+                        return result;
+                result = acpi_battery_get_state(battery);
                 if (result)
                         return result;
 
-                battery->flags.power_unit = bif->power_unit;
-                battery->trips.warning = bif->design_capacity_warning;
-                battery->trips.low = bif->design_capacity_low;
-                kfree(bif);
+                acpi_battery_init_alarm(battery);
+        }
+
+        return result;
+}
 
-                /* See if alarms are supported, and if so, set default */
+static int acpi_battery_update(struct acpi_battery *battery,
+                               int update, int *update_result_ptr)
+{
+        int result = 0;
+        int update_result = ACPI_BATTERY_NONE_UPDATE;
+
+        if (!acpi_battery_present(battery)) {
+                update = 1;
+        }
 
-                status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
-                if (ACPI_SUCCESS(status)) {
-                        battery->flags.alarm = 1;
-                        acpi_battery_set_alarm(battery, battery->trips.warning);
+        if (battery->flags.init_update) {
+                result = acpi_battery_init_update(battery);
+                if (result)
+                        goto end;
+                update_result = ACPI_BATTERY_INIT_UPDATE;
+        } else if (update) {
+                result = acpi_battery_get_status(battery);
+                if (result)
+                        goto end;
+                if ((!battery->flags.battery_present_prev & acpi_battery_present(battery))
+                    || (battery->flags.battery_present_prev & !acpi_battery_present(battery))) {
+                        result = acpi_battery_init_update(battery);
+                        if (result)
+                                goto end;
+                        update_result = ACPI_BATTERY_INIT_UPDATE;
+                } else {
+                        update_result = ACPI_BATTERY_EASY_UPDATE;
                 }
         }
 
-        /* Removal? */
+      end:
 
-        else if (battery->flags.present && !device->status.battery_present) {
-                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Battery removed\n"));
-        }
+        battery->flags.init_update = (result != 0);
 
-        battery->flags.present = device->status.battery_present;
+        *update_result_ptr = update_result;
 
         return result;
 }
 
-static void acpi_battery_check_present(struct acpi_battery *battery)
+static void acpi_battery_notify_update(struct acpi_battery *battery)
 {
-        if (!battery->flags.present) {
-                acpi_battery_check(battery);
+        acpi_battery_get_status(battery);
+
+        if (battery->flags.init_update) {
+                return;
+        }
+
+        if ((!battery->flags.battery_present_prev &
+             acpi_battery_present(battery)) ||
+            (battery->flags.battery_present_prev &
+             !acpi_battery_present(battery))) {
+                battery->flags.init_update = 1;
+        } else {
+                battery->flags.update[ACPI_BATTERY_INFO] = 1;
+                battery->flags.update[ACPI_BATTERY_STATE] = 1;
+                battery->flags.update[ACPI_BATTERY_ALARM] = 1;
         }
 }
 
@@ -335,37 +460,33 @@ static void acpi_battery_check_present(struct acpi_battery *battery)
    -------------------------------------------------------------------------- */
 
 static struct proc_dir_entry *acpi_battery_dir;
-static int acpi_battery_read_info(struct seq_file *seq, void *offset)
+
+static int acpi_battery_print_info(struct seq_file *seq, int result)
 {
-        int result = 0;
         struct acpi_battery *battery = seq->private;
         struct acpi_battery_info *bif = NULL;
         char *units = "?";
 
-
-        if (!battery)
+        if (result)
                 goto end;
 
-        acpi_battery_check_present(battery);
-
-        if (battery->flags.present)
+        if (acpi_battery_present(battery))
                 seq_printf(seq, "present:                 yes\n");
         else {
                 seq_printf(seq, "present:                 no\n");
                 goto end;
         }
 
-        /* Battery Info (_BIF) */
-
-        result = acpi_battery_get_info(battery, &bif);
-        if (result || !bif) {
-                seq_printf(seq, "ERROR: Unable to read battery information\n");
+        bif = battery->bif_data.pointer;
+        if (!bif) {
+                ACPI_EXCEPTION((AE_INFO, AE_ERROR, "BIF buffer is NULL"));
+                result = -ENODEV;
                 goto end;
         }
 
-        units =
-            bif->
-            power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
+        /* Battery Units */
+
+        units = acpi_battery_power_units(battery);
 
         if (bif->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
                 seq_printf(seq, "design capacity:         unknown\n");
@@ -396,7 +517,6 @@ static int acpi_battery_read_info(struct seq_file *seq, void *offset)
         else
                 seq_printf(seq, "design voltage:          %d mV\n",
                            (u32) bif->design_voltage);
-
         seq_printf(seq, "design capacity warning: %d %sh\n",
                    (u32) bif->design_capacity_warning, units);
         seq_printf(seq, "design capacity low:     %d %sh\n",
@@ -411,50 +531,40 @@ static int acpi_battery_read_info(struct seq_file *seq, void *offset)
         seq_printf(seq, "OEM info:                %s\n", bif->oem_info);
 
       end:
-        kfree(bif);
 
-        return 0;
-}
+        if (result)
+                seq_printf(seq, "ERROR: Unable to read battery info\n");
 
-static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
-{
-        return single_open(file, acpi_battery_read_info, PDE(inode)->data);
+        return result;
 }
 
-static int acpi_battery_read_state(struct seq_file *seq, void *offset)
+static int acpi_battery_print_state(struct seq_file *seq, int result)
 {
-        int result = 0;
         struct acpi_battery *battery = seq->private;
-        struct acpi_battery_status *bst = NULL;
+        struct acpi_battery_state *bst = NULL;
         char *units = "?";
 
-
-        if (!battery)
+        if (result)
                 goto end;
 
-        acpi_battery_check_present(battery);
-
-        if (battery->flags.present)
+        if (acpi_battery_present(battery))
                 seq_printf(seq, "present:                 yes\n");
         else {
                 seq_printf(seq, "present:                 no\n");
                 goto end;
         }
 
-        /* Battery Units */
-
-        units =
-            battery->flags.
-            power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
-
-        /* Battery Status (_BST) */
-
-        result = acpi_battery_get_status(battery, &bst);
-        if (result || !bst) {
-                seq_printf(seq, "ERROR: Unable to read battery status\n");
+        bst = battery->bst_data.pointer;
+        if (!bst) {
+                ACPI_EXCEPTION((AE_INFO, AE_ERROR, "BST buffer is NULL"));
+                result = -ENODEV;
                 goto end;
         }
 
+        /* Battery Units */
+
+        units = acpi_battery_power_units(battery);
+
         if (!(bst->state & 0x04))
                 seq_printf(seq, "capacity state:          ok\n");
         else
@@ -490,48 +600,43 @@ static int acpi_battery_read_state(struct seq_file *seq, void *offset)
                            (u32) bst->present_voltage);
 
       end:
-        kfree(bst);
 
-        return 0;
-}
+        if (result) {
+                seq_printf(seq, "ERROR: Unable to read battery state\n");
+        }
 
-static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
-{
-        return single_open(file, acpi_battery_read_state, PDE(inode)->data);
+        return result;
 }
 
-static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
+static int acpi_battery_print_alarm(struct seq_file *seq, int result)
 {
         struct acpi_battery *battery = seq->private;
         char *units = "?";
 
-
-        if (!battery)
+        if (result)
                 goto end;
 
-        acpi_battery_check_present(battery);
-
-        if (!battery->flags.present) {
+        if (!acpi_battery_present(battery)) {
                 seq_printf(seq, "present:                 no\n");
                 goto end;
         }
 
         /* Battery Units */
 
-        units =
-            battery->flags.
-            power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
-
-        /* Battery Alarm */
+        units = acpi_battery_power_units(battery);
 
         seq_printf(seq, "alarm:                   ");
         if (!battery->alarm)
                 seq_printf(seq, "unsupported\n");
         else
-                seq_printf(seq, "%d %sh\n", (u32) battery->alarm, units);
+                seq_printf(seq, "%lu %sh\n", battery->alarm, units);
 
       end:
-        return 0;
+
+        if (result)
+                seq_printf(seq, "ERROR: Unable to read battery alarm\n");
+
+        return result;
 }
 
 static ssize_t
@@ -543,27 +648,113 @@ acpi_battery_write_alarm(struct file *file,
         char alarm_string[12] = { '\0' };
         struct seq_file *m = file->private_data;
         struct acpi_battery *battery = m->private;
-
+        int update_result = ACPI_BATTERY_NONE_UPDATE;
 
         if (!battery || (count > sizeof(alarm_string) - 1))
                 return -EINVAL;
 
-        acpi_battery_check_present(battery);
+        mutex_lock(&battery->mutex);
 
-        if (!battery->flags.present)
-                return -ENODEV;
+        result = acpi_battery_update(battery, 1, &update_result);
+        if (result) {
+                result = -ENODEV;
+                goto end;
+        }
+
+        if (!acpi_battery_present(battery)) {
+                result = -ENODEV;
+                goto end;
+        }
 
-        if (copy_from_user(alarm_string, buffer, count))
-                return -EFAULT;
+        if (copy_from_user(alarm_string, buffer, count)) {
+                result = -EFAULT;
+                goto end;
+        }
 
         alarm_string[count] = '\0';
 
         result = acpi_battery_set_alarm(battery,
                                         simple_strtoul(alarm_string, NULL, 0));
         if (result)
-                return result;
+                goto end;
+
+      end:
 
-        return count;
+        acpi_battery_check_result(battery, result);
+
+        if (!result)
+                result = count;
+
+        mutex_unlock(&battery->mutex);
+
+        return result;
+}
+
+typedef int(*print_func)(struct seq_file *seq, int result);
+typedef int(*get_func)(struct acpi_battery *battery);
+
+static struct acpi_read_mux {
+        print_func print;
+        get_func get;
+} acpi_read_funcs[ACPI_BATTERY_NUMFILES] = {
+        {.get = acpi_battery_get_info, .print = acpi_battery_print_info},
+        {.get = acpi_battery_get_state, .print = acpi_battery_print_state},
+        {.get = acpi_battery_get_alarm, .print = acpi_battery_print_alarm},
+};
+
+static int acpi_battery_read(int fid, struct seq_file *seq)
+{
+        struct acpi_battery *battery = seq->private;
+        int result = 0;
+        int update_result = ACPI_BATTERY_NONE_UPDATE;
+        int update = 0;
+
+        mutex_lock(&battery->mutex);
+
+        update = (get_seconds() - battery->update_time[fid] >= update_time);
+        update = (update | battery->flags.update[fid]);
+
+        result = acpi_battery_update(battery, update, &update_result);
+        if (result)
+                goto end;
+
+        if (update_result == ACPI_BATTERY_EASY_UPDATE) {
+                result = acpi_read_funcs[fid].get(battery);
+                if (result)
+                        goto end;
+        }
+
+      end:
+        result = acpi_read_funcs[fid].print(seq, result);
+        acpi_battery_check_result(battery, result);
+        battery->flags.update[fid] = result;
+        mutex_unlock(&battery->mutex);
+        return result;
+}
+
+static int acpi_battery_read_info(struct seq_file *seq, void *offset)
+{
+        return acpi_battery_read(ACPI_BATTERY_INFO, seq);
+}
+
+static int acpi_battery_read_state(struct seq_file *seq, void *offset)
+{
+        return acpi_battery_read(ACPI_BATTERY_STATE, seq);
+}
+
+static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
+{
+        return acpi_battery_read(ACPI_BATTERY_ALARM, seq);
+}
+
+static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
+{
+        return single_open(file, acpi_battery_read_info, PDE(inode)->data);
+}
+
+static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
+{
+        return single_open(file, acpi_battery_read_state, PDE(inode)->data);
 }
 
 static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
@@ -571,35 +762,51 @@ static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
         return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
 }
 
-static const struct file_operations acpi_battery_info_ops = {
+static struct battery_file {
+        struct file_operations ops;
+        mode_t mode;
+        char *name;
+} acpi_battery_file[] = {
+        {
+        .name = "info",
+        .mode = S_IRUGO,
+        .ops = {
         .open = acpi_battery_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
         .release = single_release,
         .owner = THIS_MODULE,
-};
-
-static const struct file_operations acpi_battery_state_ops = {
+        },
+        },
+        {
+        .name = "state",
+        .mode = S_IRUGO,
+        .ops = {
         .open = acpi_battery_state_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
         .release = single_release,
         .owner = THIS_MODULE,
-};
-
-static const struct file_operations acpi_battery_alarm_ops = {
+        },
+        },
+        {
+        .name = "alarm",
+        .mode = S_IFREG | S_IRUGO | S_IWUSR,
+        .ops = {
         .open = acpi_battery_alarm_open_fs,
         .read = seq_read,
         .write = acpi_battery_write_alarm,
         .llseek = seq_lseek,
         .release = single_release,
         .owner = THIS_MODULE,
+        },
+        },
 };
 
 static int acpi_battery_add_fs(struct acpi_device *device)
 {
         struct proc_dir_entry *entry = NULL;
-
+        int i;
 
         if (!acpi_device_dir(device)) {
                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
@@ -609,38 +816,16 @@ static int acpi_battery_add_fs(struct acpi_device *device)
                 acpi_device_dir(device)->owner = THIS_MODULE;
         }
 
-        /* 'info' [R] */
-        entry = create_proc_entry(ACPI_BATTERY_FILE_INFO,
-                                  S_IRUGO, acpi_device_dir(device));
-        if (!entry)
-                return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_battery_info_ops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
-
-        /* 'status' [R] */
-        entry = create_proc_entry(ACPI_BATTERY_FILE_STATUS,
-                                  S_IRUGO, acpi_device_dir(device));
-        if (!entry)
-                return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_battery_state_ops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
-
-        /* 'alarm' [R/W] */
-        entry = create_proc_entry(ACPI_BATTERY_FILE_ALARM,
-                                  S_IFREG | S_IRUGO | S_IWUSR,
-                                  acpi_device_dir(device));
-        if (!entry)
-                return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_battery_alarm_ops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
+        for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
+                entry = create_proc_entry(acpi_battery_file[i].name,
+                                  acpi_battery_file[i].mode, acpi_device_dir(device));
+                if (!entry)
+                        return -ENODEV;
+                else {
+                        entry->proc_fops = &acpi_battery_file[i].ops;
+                        entry->data = acpi_driver_data(device);
+                        entry->owner = THIS_MODULE;
+                }
         }
 
         return 0;
@@ -648,15 +833,12 @@ static int acpi_battery_add_fs(struct acpi_device *device)
 
 static int acpi_battery_remove_fs(struct acpi_device *device)
 {
-
+        int i;
         if (acpi_device_dir(device)) {
-                remove_proc_entry(ACPI_BATTERY_FILE_ALARM,
+                for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
+                        remove_proc_entry(acpi_battery_file[i].name,
                                   acpi_device_dir(device));
-                remove_proc_entry(ACPI_BATTERY_FILE_STATUS,
-                                  acpi_device_dir(device));
-                remove_proc_entry(ACPI_BATTERY_FILE_INFO,
-                                  acpi_device_dir(device));
-
+                }
                 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
                 acpi_device_dir(device) = NULL;
         }
@@ -673,7 +855,6 @@ static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
         struct acpi_battery *battery = data;
         struct acpi_device *device = NULL;
 
-
         if (!battery)
                 return;
 
@@ -684,8 +865,10 @@ static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
         case ACPI_BATTERY_NOTIFY_INFO:
         case ACPI_NOTIFY_BUS_CHECK:
         case ACPI_NOTIFY_DEVICE_CHECK:
-                acpi_battery_check(battery);
-                acpi_bus_generate_event(device, event, battery->flags.present);
+                device = battery->device;
+                acpi_battery_notify_update(battery);
+                acpi_bus_generate_event(device, event,
+                                        acpi_battery_present(battery));
                 break;
         default:
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
@@ -702,7 +885,6 @@ static int acpi_battery_add(struct acpi_device *device)
         acpi_status status = 0;
         struct acpi_battery *battery = NULL;
 
-
         if (!device)
                 return -EINVAL;
 
@@ -710,15 +892,21 @@ static int acpi_battery_add(struct acpi_device *device)
         if (!battery)
                 return -ENOMEM;
 
+        mutex_init(&battery->mutex);
+
+        mutex_lock(&battery->mutex);
+
         battery->device = device;
         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
         acpi_driver_data(device) = battery;
 
-        result = acpi_battery_check(battery);
+        result = acpi_battery_get_status(battery);
         if (result)
                 goto end;
 
+        battery->flags.init_update = 1;
+
         result = acpi_battery_add_fs(device);
         if (result)
                 goto end;
@@ -727,6 +915,7 @@ static int acpi_battery_add(struct acpi_device *device)
                                              ACPI_ALL_NOTIFY,
                                              acpi_battery_notify, battery);
         if (ACPI_FAILURE(status)) {
+                ACPI_EXCEPTION((AE_INFO, status, "Installing notify handler"));
                 result = -ENODEV;
                 goto end;
         }
@@ -736,11 +925,14 @@ static int acpi_battery_add(struct acpi_device *device)
                device->status.battery_present ? "present" : "absent");
 
       end:
+
         if (result) {
                 acpi_battery_remove_fs(device);
                 kfree(battery);
         }
 
+        mutex_unlock(&battery->mutex);
+
         return result;
 }
 
@@ -749,18 +941,27 @@ static int acpi_battery_remove(struct acpi_device *device, int type)
         acpi_status status = 0;
         struct acpi_battery *battery = NULL;
 
-
         if (!device || !acpi_driver_data(device))
                 return -EINVAL;
 
         battery = acpi_driver_data(device);
 
+        mutex_lock(&battery->mutex);
+
         status = acpi_remove_notify_handler(device->handle,
                                             ACPI_ALL_NOTIFY,
                                             acpi_battery_notify);
 
         acpi_battery_remove_fs(device);
 
+        kfree(battery->bif_data.pointer);
+
+        kfree(battery->bst_data.pointer);
+
+        mutex_unlock(&battery->mutex);
+
+        mutex_destroy(&battery->mutex);
+
         kfree(battery);
 
         return 0;
@@ -775,7 +976,10 @@ static int acpi_battery_resume(struct acpi_device *device)
                 return -EINVAL;
 
         battery = device->driver_data;
-        return acpi_battery_check(battery);
+
+        battery->flags.init_update = 1;
+
+        return 0;
 }
 
 static int __init acpi_battery_init(void)
@@ -800,7 +1004,6 @@ static int __init acpi_battery_init(void)
 
 static void __exit acpi_battery_exit(void)
 {
-
         acpi_bus_unregister_driver(&acpi_battery_driver);
 
         acpi_unlock_battery_dir(acpi_battery_dir);
diff --git a/drivers/acpi/bay.c b/drivers/acpi/bay.c
index fb3f31b5e6..56a5b3fffe 100644
--- a/drivers/acpi/bay.c
+++ b/drivers/acpi/bay.c
@@ -288,6 +288,11 @@ static int bay_add(acpi_handle handle, int id)
         new_bay->pdev = pdev;
         platform_set_drvdata(pdev, new_bay);
 
+        /*
+         * we want the bay driver to be able to send uevents
+         */
+        pdev->dev.uevent_suppress = 0;
+
         if (acpi_bay_add_fs(new_bay)) {
                 platform_device_unregister(new_bay->pdev);
                 goto bay_add_err;
@@ -328,18 +333,12 @@ static void bay_notify(acpi_handle handle, u32 event, void *data)
 {
         struct bay *bay_dev = (struct bay *)data;
         struct device *dev = &bay_dev->pdev->dev;
+        char event_string[12];
+        char *envp[] = { event_string, NULL };
 
         bay_dprintk(handle, "Bay event");
-
-        switch(event) {
-        case ACPI_NOTIFY_BUS_CHECK:
-        case ACPI_NOTIFY_DEVICE_CHECK:
-        case ACPI_NOTIFY_EJECT_REQUEST:
-                kobject_uevent(&dev->kobj, KOBJ_CHANGE);
-                break;
-        default:
-                printk(KERN_ERR PREFIX "Bay: unknown event %d\n", event);
-        }
+        sprintf(event_string, "BAY_EVENT=%d\n", event);
+        kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
 }
 
 static acpi_status
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index e5084ececb..6b2658c962 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -292,6 +292,10 @@ int acpi_bus_generate_event(struct acpi_device *device, u8 type, int data)
         if (!device)
                 return -EINVAL;
 
+        if (acpi_bus_generate_genetlink_event(device, type, data))
+                printk(KERN_WARNING PREFIX
+                        "Failed to generate an ACPI event via genetlink!\n");
+
         /* drop event on the floor if no one's listening */
         if (!event_is_open)
                 return 0;
diff --git a/drivers/acpi/dock.c b/drivers/acpi/dock.c
index 4546bf873a..6192c8be66 100644
--- a/drivers/acpi/dock.c
+++ b/drivers/acpi/dock.c
@@ -40,8 +40,15 @@ MODULE_AUTHOR("Kristen Carlson Accardi");
 MODULE_DESCRIPTION(ACPI_DOCK_DRIVER_DESCRIPTION);
 MODULE_LICENSE("GPL");
 
+static int immediate_undock = 1;
+module_param(immediate_undock, bool, 0644);
+MODULE_PARM_DESC(immediate_undock, "1 (default) will cause the driver to "
+        "undock immediately when the undock button is pressed, 0 will cause"
+        " the driver to wait for userspace to write the undock sysfs file "
+        " before undocking");
+
 static struct atomic_notifier_head dock_notifier_list;
-static struct platform_device dock_device;
+static struct platform_device *dock_device;
 static char dock_device_name[] = "dock";
 
 struct dock_station {
@@ -63,6 +70,7 @@ struct dock_dependent_device {
 };
 
 #define DOCK_DOCKING    0x00000001
+#define DOCK_UNDOCKING  0x00000002
 #define DOCK_EVENT      3
 #define UNDOCK_EVENT    2
 
@@ -327,12 +335,20 @@ static void hotplug_dock_devices(struct dock_station *ds, u32 event)
 
 static void dock_event(struct dock_station *ds, u32 event, int num)
 {
-        struct device *dev = &dock_device.dev;
+        struct device *dev = &dock_device->dev;
+        char event_string[7];
+        char *envp[] = { event_string, NULL };
+
+        if (num == UNDOCK_EVENT)
+                sprintf(event_string, "UNDOCK");
+        else
+                sprintf(event_string, "DOCK");
+
         /*
          * Indicate that the status of the dock station has
          * changed.
          */
-        kobject_uevent(&dev->kobj, KOBJ_CHANGE);
+        kobject_uevent_env(&dev->kobj, KOBJ_CHANGE, envp);
 }
 
 /**
@@ -380,12 +396,11 @@ static void handle_dock(struct dock_station *ds, int dock)
         union acpi_object arg;
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         struct acpi_buffer name_buffer = { ACPI_ALLOCATE_BUFFER, NULL };
-        union acpi_object *obj;
 
         acpi_get_name(ds->handle, ACPI_FULL_PATHNAME, &name_buffer);
-        obj = name_buffer.pointer;
 
-        printk(KERN_INFO PREFIX "%s\n", dock ? "docking" : "undocking");
+        printk(KERN_INFO PREFIX "%s - %s\n",
+                (char *)name_buffer.pointer, dock ? "docking" : "undocking");
 
         /* _DCK method has one argument */
         arg_list.count = 1;
@@ -394,7 +409,8 @@ static void handle_dock(struct dock_station *ds, int dock)
         arg.integer.value = dock;
         status = acpi_evaluate_object(ds->handle, "_DCK", &arg_list, &buffer);
         if (ACPI_FAILURE(status))
-                pr_debug("%s: failed to execute _DCK\n", obj->string.pointer);
+                printk(KERN_ERR PREFIX "%s - failed to execute _DCK\n",
+                         (char *)name_buffer.pointer);
         kfree(buffer.pointer);
         kfree(name_buffer.pointer);
 }
@@ -420,6 +436,16 @@ static inline void complete_dock(struct dock_station *ds)
         ds->last_dock_time = jiffies;
 }
 
+static inline void begin_undock(struct dock_station *ds)
+{
+        ds->flags |= DOCK_UNDOCKING;
+}
+
+static inline void complete_undock(struct dock_station *ds)
+{
+        ds->flags &= ~(DOCK_UNDOCKING);
+}
+
 /**
  * dock_in_progress - see if we are in the middle of handling a dock event
  * @ds: the dock station
@@ -550,7 +576,7 @@ static int handle_eject_request(struct dock_station *ds, u32 event)
                 printk(KERN_ERR PREFIX "Unable to undock!\n");
                 return -EBUSY;
         }
-
+        complete_undock(ds);
         return 0;
 }
 
@@ -594,7 +620,11 @@ static void dock_notify(acpi_handle handle, u32 event, void *data)
          * to the driver who wish to hotplug.
          */
         case ACPI_NOTIFY_EJECT_REQUEST:
-                handle_eject_request(ds, event);
+                begin_undock(ds);
+                if (immediate_undock)
+                        handle_eject_request(ds, event);
+                else
+                        dock_event(ds, event, UNDOCK_EVENT);
                 break;
         default:
                 printk(KERN_ERR PREFIX "Unknown dock event %d\n", event);
@@ -653,6 +683,17 @@ static ssize_t show_docked(struct device *dev,
 DEVICE_ATTR(docked, S_IRUGO, show_docked, NULL);
 
 /*
+ * show_flags - read method for flags file in sysfs
+ */
+static ssize_t show_flags(struct device *dev,
+                          struct device_attribute *attr, char *buf)
+{
+        return snprintf(buf, PAGE_SIZE, "%d\n", dock_station->flags);
+
+}
+DEVICE_ATTR(flags, S_IRUGO, show_flags, NULL);
+
+/*
  * write_undock - write method for "undock" file in sysfs
  */
 static ssize_t write_undock(struct device *dev, struct device_attribute *attr,
@@ -675,16 +716,15 @@ static ssize_t show_dock_uid(struct device *dev,
                              struct device_attribute *attr, char *buf)
 {
         unsigned long lbuf;
-        acpi_status status = acpi_evaluate_integer(dock_station->handle, "_UID", NULL, &lbuf);
-        if(ACPI_FAILURE(status)) {
+        acpi_status status = acpi_evaluate_integer(dock_station->handle,
+                                        "_UID", NULL, &lbuf);
+        if (ACPI_FAILURE(status))
             return 0;
-        }
+
         return snprintf(buf, PAGE_SIZE, "%lx\n", lbuf);
 }
 DEVICE_ATTR(uid, S_IRUGO, show_dock_uid, NULL);
 
-
-
 /**
  * dock_add - add a new dock station
  * @handle: the dock station handle
@@ -711,33 +751,53 @@ static int dock_add(acpi_handle handle)
         ATOMIC_INIT_NOTIFIER_HEAD(&dock_notifier_list);
 
         /* initialize platform device stuff */
-        dock_device.name = dock_device_name;
-        ret = platform_device_register(&dock_device);
+        dock_device =
+                platform_device_register_simple(dock_device_name, 0, NULL, 0);
+        if (IS_ERR(dock_device)) {
+                kfree(dock_station);
+                dock_station = NULL;
+                return PTR_ERR(dock_device);
+        }
+
+        /* we want the dock device to send uevents */
+        dock_device->dev.uevent_suppress = 0;
+
+        ret = device_create_file(&dock_device->dev, &dev_attr_docked);
         if (ret) {
-                printk(KERN_ERR PREFIX "Error %d registering dock device\n", ret);
+                printk("Error %d adding sysfs file\n", ret);
+                platform_device_unregister(dock_device);
                 kfree(dock_station);
+                dock_station = NULL;
                 return ret;
         }
-        ret = device_create_file(&dock_device.dev, &dev_attr_docked);
+        ret = device_create_file(&dock_device->dev, &dev_attr_undock);
         if (ret) {
                 printk("Error %d adding sysfs file\n", ret);
-                platform_device_unregister(&dock_device);
+                device_remove_file(&dock_device->dev, &dev_attr_docked);
+                platform_device_unregister(dock_device);
                 kfree(dock_station);
+                dock_station = NULL;
                 return ret;
         }
-        ret = device_create_file(&dock_device.dev, &dev_attr_undock);
+        ret = device_create_file(&dock_device->dev, &dev_attr_uid);
         if (ret) {
                 printk("Error %d adding sysfs file\n", ret);
-                device_remove_file(&dock_device.dev, &dev_attr_docked);
-                platform_device_unregister(&dock_device);
+                device_remove_file(&dock_device->dev, &dev_attr_docked);
+                device_remove_file(&dock_device->dev, &dev_attr_undock);
+                platform_device_unregister(dock_device);
                 kfree(dock_station);
+                dock_station = NULL;
                 return ret;
         }
-        ret = device_create_file(&dock_device.dev, &dev_attr_uid);
+        ret = device_create_file(&dock_device->dev, &dev_attr_flags);
         if (ret) {
                 printk("Error %d adding sysfs file\n", ret);
-                platform_device_unregister(&dock_device);
+                device_remove_file(&dock_device->dev, &dev_attr_docked);
+                device_remove_file(&dock_device->dev, &dev_attr_undock);
+                device_remove_file(&dock_device->dev, &dev_attr_uid);
+                platform_device_unregister(dock_device);
                 kfree(dock_station);
+                dock_station = NULL;
                 return ret;
         }
 
@@ -750,6 +810,7 @@ static int dock_add(acpi_handle handle)
         dd = alloc_dock_dependent_device(handle);
         if (!dd) {
                 kfree(dock_station);
+                dock_station = NULL;
                 ret = -ENOMEM;
                 goto dock_add_err_unregister;
         }
@@ -773,10 +834,13 @@ static int dock_add(acpi_handle handle)
 dock_add_err:
         kfree(dd);
 dock_add_err_unregister:
-        device_remove_file(&dock_device.dev, &dev_attr_docked);
-        device_remove_file(&dock_device.dev, &dev_attr_undock);
-        platform_device_unregister(&dock_device);
+        device_remove_file(&dock_device->dev, &dev_attr_docked);
+        device_remove_file(&dock_device->dev, &dev_attr_undock);
+        device_remove_file(&dock_device->dev, &dev_attr_uid);
+        device_remove_file(&dock_device->dev, &dev_attr_flags);
+        platform_device_unregister(dock_device);
         kfree(dock_station);
+        dock_station = NULL;
         return ret;
 }
 
@@ -804,12 +868,15 @@ static int dock_remove(void)
                 printk(KERN_ERR "Error removing notify handler\n");
 
         /* cleanup sysfs */
-        device_remove_file(&dock_device.dev, &dev_attr_docked);
-        device_remove_file(&dock_device.dev, &dev_attr_undock);
-        platform_device_unregister(&dock_device);
+        device_remove_file(&dock_device->dev, &dev_attr_docked);
+        device_remove_file(&dock_device->dev, &dev_attr_undock);
+        device_remove_file(&dock_device->dev, &dev_attr_uid);
+        device_remove_file(&dock_device->dev, &dev_attr_flags);
+        platform_device_unregister(dock_device);
 
         /* free dock station memory */
         kfree(dock_station);
+        dock_station = NULL;
         return 0;
 }
 
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 82f496c076..10e851021e 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -34,25 +34,26 @@
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/interrupt.h>
+#include <linux/list.h>
 #include <asm/io.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 #include <acpi/actypes.h>
 
-#define _COMPONENT              ACPI_EC_COMPONENT
-ACPI_MODULE_NAME("ec");
-#define ACPI_EC_COMPONENT               0x00100000
 #define ACPI_EC_CLASS                   "embedded_controller"
 #define ACPI_EC_HID                     "PNP0C09"
 #define ACPI_EC_DEVICE_NAME             "Embedded Controller"
 #define ACPI_EC_FILE_INFO               "info"
+
 #undef PREFIX
 #define PREFIX                          "ACPI: EC: "
+
 /* EC status register */
 #define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
 #define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
 #define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
 #define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
+
 /* EC commands */
 enum ec_command {
         ACPI_EC_COMMAND_READ = 0x80,
@@ -61,6 +62,7 @@ enum ec_command {
         ACPI_EC_BURST_DISABLE = 0x83,
         ACPI_EC_COMMAND_QUERY = 0x84,
 };
+
 /* EC events */
 enum ec_event {
         ACPI_EC_EVENT_OBF_1 = 1,        /* Output buffer full */
@@ -94,6 +96,16 @@ static struct acpi_driver acpi_ec_driver = {
 
 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
 /* External interfaces use first EC only, so remember */
+typedef int (*acpi_ec_query_func) (void *data);
+
+struct acpi_ec_query_handler {
+        struct list_head node;
+        acpi_ec_query_func func;
+        acpi_handle handle;
+        void *data;
+        u8 query_bit;
+};
+
 static struct acpi_ec {
         acpi_handle handle;
         unsigned long gpe;
@@ -104,6 +116,7 @@ static struct acpi_ec {
         atomic_t query_pending;
         atomic_t event_count;
         wait_queue_head_t wait;
+        struct list_head list;
 } *boot_ec, *first_ec;
 
 /* --------------------------------------------------------------------------
@@ -245,7 +258,7 @@ static int acpi_ec_transaction(struct acpi_ec *ec, u8 command,
 
         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, 0, 0);
         if (status) {
-                printk(KERN_DEBUG PREFIX
+                printk(KERN_ERR PREFIX
                        "input buffer is not empty, aborting transaction\n");
                 goto end;
         }
@@ -394,21 +407,67 @@ static int acpi_ec_query(struct acpi_ec *ec, u8 * data)
 /* --------------------------------------------------------------------------
                                 Event Management
    -------------------------------------------------------------------------- */
+int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
+                              acpi_handle handle, acpi_ec_query_func func,
+                              void *data)
+{
+        struct acpi_ec_query_handler *handler =
+            kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
+        if (!handler)
+                return -ENOMEM;
+
+        handler->query_bit = query_bit;
+        handler->handle = handle;
+        handler->func = func;
+        handler->data = data;
+        mutex_lock(&ec->lock);
+        list_add_tail(&handler->node, &ec->list);
+        mutex_unlock(&ec->lock);
+        return 0;
+}
+
+EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
+
+void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
+{
+        struct acpi_ec_query_handler *handler;
+        mutex_lock(&ec->lock);
+        list_for_each_entry(handler, &ec->list, node) {
+                if (query_bit == handler->query_bit) {
+                        list_del(&handler->node);
+                        kfree(handler);
+                        break;
+                }
+        }
+        mutex_unlock(&ec->lock);
+}
+
+EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
 
 static void acpi_ec_gpe_query(void *ec_cxt)
 {
         struct acpi_ec *ec = ec_cxt;
         u8 value = 0;
-        char object_name[8];
+        struct acpi_ec_query_handler *handler, copy;
 
         if (!ec || acpi_ec_query(ec, &value))
                 return;
-
-        snprintf(object_name, 8, "_Q%2.2X", value);
-
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s", object_name));
-
-        acpi_evaluate_object(ec->handle, object_name, NULL, NULL);
+        mutex_lock(&ec->lock);
+        list_for_each_entry(handler, &ec->list, node) {
+                if (value == handler->query_bit) {
+                        /* have custom handler for this bit */
+                        memcpy(&copy, handler, sizeof(copy));
+                        mutex_unlock(&ec->lock);
+                        if (copy.func) {
+                                copy.func(copy.data);
+                        } else if (copy.handle) {
+                                acpi_evaluate_object(copy.handle, NULL, NULL, NULL);
+                        }
+                        return;
+                }
+        }
+        mutex_unlock(&ec->lock);
+        printk(KERN_ERR PREFIX "Handler for query 0x%x is not found!\n", value);
 }
 
 static u32 acpi_ec_gpe_handler(void *data)
@@ -427,8 +486,7 @@ static u32 acpi_ec_gpe_handler(void *data)
         if ((value & ACPI_EC_FLAG_SCI) && !atomic_read(&ec->query_pending)) {
                 atomic_set(&ec->query_pending, 1);
                 status =
-                    acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query,
-                                    ec);
+                    acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query, ec);
         }
 
         return status == AE_OK ?
@@ -454,57 +512,35 @@ acpi_ec_space_setup(acpi_handle region_handle,
 }
 
 static acpi_status
-acpi_ec_space_handler(u32 function,
-                      acpi_physical_address address,
-                      u32 bit_width,
-                      acpi_integer * value,
+acpi_ec_space_handler(u32 function, acpi_physical_address address,
+                      u32 bits, acpi_integer *value,
                       void *handler_context, void *region_context)
 {
-        int result = 0;
         struct acpi_ec *ec = handler_context;
-        u64 temp = *value;
-        acpi_integer f_v = 0;
-        int i = 0;
+        int result = 0, i = 0;
+        u8 temp = 0;
 
         if ((address > 0xFF) || !value || !handler_context)
                 return AE_BAD_PARAMETER;
 
-        if (bit_width != 8 && acpi_strict) {
+        if (function != ACPI_READ && function != ACPI_WRITE)
                 return AE_BAD_PARAMETER;
-        }
-
-      next_byte:
-        switch (function) {
-        case ACPI_READ:
-                temp = 0;
-                result = acpi_ec_read(ec, (u8) address, (u8 *) & temp);
-                break;
-        case ACPI_WRITE:
-                result = acpi_ec_write(ec, (u8) address, (u8) temp);
-                break;
-        default:
-                result = -EINVAL;
-                goto out;
-                break;
-        }
 
-        bit_width -= 8;
-        if (bit_width) {
-                if (function == ACPI_READ)
-                        f_v |= temp << 8 * i;
-                if (function == ACPI_WRITE)
-                        temp >>= 8;
-                i++;
-                address++;
-                goto next_byte;
-        }
+        if (bits != 8 && acpi_strict)
+                return AE_BAD_PARAMETER;
 
-        if (function == ACPI_READ) {
-                f_v |= temp << 8 * i;
-                *value = f_v;
+        while (bits - i > 0) {
+                if (function == ACPI_READ) {
+                        result = acpi_ec_read(ec, address, &temp);
+                        (*value) |= ((acpi_integer)temp) << i;
+                } else {
+                        temp = 0xff & ((*value) >> i);
+                        result = acpi_ec_write(ec, address, temp);
+                }
+                i += 8;
+                ++address;
         }
 
-      out:
         switch (result) {
         case -EINVAL:
                 return AE_BAD_PARAMETER;
@@ -597,9 +633,6 @@ static int acpi_ec_remove_fs(struct acpi_device *device)
 static acpi_status
 ec_parse_io_ports(struct acpi_resource *resource, void *context);
 
-static acpi_status
-ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval);
-
 static struct acpi_ec *make_acpi_ec(void)
 {
         struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
@@ -610,13 +643,52 @@ static struct acpi_ec *make_acpi_ec(void)
         atomic_set(&ec->event_count, 1);
         mutex_init(&ec->lock);
         init_waitqueue_head(&ec->wait);
+        INIT_LIST_HEAD(&ec->list);
 
         return ec;
 }
 
+static acpi_status
+acpi_ec_register_query_methods(acpi_handle handle, u32 level,
+                               void *context, void **return_value)
+{
+        struct acpi_namespace_node *node = handle;
+        struct acpi_ec *ec = context;
+        int value = 0;
+        if (sscanf(node->name.ascii, "_Q%x", &value) == 1) {
+                acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
+        }
+        return AE_OK;
+}
+
+static int ec_parse_device(struct acpi_ec *ec, acpi_handle handle)
+{
+        if (ACPI_FAILURE(acpi_walk_resources(handle, METHOD_NAME__CRS,
+                                     ec_parse_io_ports, ec)))
+                return -EINVAL;
+
+        /* Get GPE bit assignment (EC events). */
+        /* TODO: Add support for _GPE returning a package */
+        if (ACPI_FAILURE(acpi_evaluate_integer(handle, "_GPE", NULL, &ec->gpe)))
+                return -EINVAL;
+
+        /* Use the global lock for all EC transactions? */
+        acpi_evaluate_integer(handle, "_GLK", NULL, &ec->global_lock);
+
+        /* Find and register all query methods */
+        acpi_walk_namespace(ACPI_TYPE_METHOD, handle, 1,
+                            acpi_ec_register_query_methods, ec, NULL);
+
+        ec->handle = handle;
+
+        printk(KERN_INFO PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx",
+                          ec->gpe, ec->command_addr, ec->data_addr);
+
+        return 0;
+}
+
 static int acpi_ec_add(struct acpi_device *device)
 {
-        acpi_status status = AE_OK;
         struct acpi_ec *ec = NULL;
 
         if (!device)
@@ -629,8 +701,7 @@ static int acpi_ec_add(struct acpi_device *device)
         if (!ec)
                 return -ENOMEM;
 
-        status = ec_parse_device(device->handle, 0, ec, NULL);
-        if (status != AE_CTRL_TERMINATE) {
+        if (ec_parse_device(ec, device->handle)) {
                 kfree(ec);
                 return -EINVAL;
         }
@@ -641,6 +712,8 @@ static int acpi_ec_add(struct acpi_device *device)
                         /* We might have incorrect info for GL at boot time */
                         mutex_lock(&boot_ec->lock);
                         boot_ec->global_lock = ec->global_lock;
+                        /* Copy handlers from new ec into boot ec */
+                        list_splice(&ec->list, &boot_ec->list);
                         mutex_unlock(&boot_ec->lock);
                         kfree(ec);
                         ec = boot_ec;
@@ -651,22 +724,24 @@ static int acpi_ec_add(struct acpi_device *device)
         acpi_driver_data(device) = ec;
 
         acpi_ec_add_fs(device);
-
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s [%s] (gpe %d) interrupt mode.",
-                          acpi_device_name(device), acpi_device_bid(device),
-                          (u32) ec->gpe));
-
         return 0;
 }
 
 static int acpi_ec_remove(struct acpi_device *device, int type)
 {
         struct acpi_ec *ec;
+        struct acpi_ec_query_handler *handler;
 
         if (!device)
                 return -EINVAL;
 
         ec = acpi_driver_data(device);
+        mutex_lock(&ec->lock);
+        list_for_each_entry(handler, &ec->list, node) {
+                list_del(&handler->node);
+                kfree(handler);
+        }
+        mutex_unlock(&ec->lock);
         acpi_ec_remove_fs(device);
         acpi_driver_data(device) = NULL;
         if (ec == first_ec)
@@ -722,15 +797,13 @@ static int ec_install_handlers(struct acpi_ec *ec)
                 return -ENODEV;
         }
 
-        /* EC is fully operational, allow queries */
-        atomic_set(&ec->query_pending, 0);
-
         return 0;
 }
 
 static int acpi_ec_start(struct acpi_device *device)
 {
         struct acpi_ec *ec;
+        int ret = 0;
 
         if (!device)
                 return -EINVAL;
@@ -740,14 +813,14 @@ static int acpi_ec_start(struct acpi_device *device)
         if (!ec)
                 return -EINVAL;
 
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02lx, ports=0x%2lx,0x%2lx",
-                          ec->gpe, ec->command_addr, ec->data_addr));
-
         /* Boot EC is already working */
-        if (ec == boot_ec)
-                return 0;
+        if (ec != boot_ec)
+                ret = ec_install_handlers(ec);
+
+        /* EC is fully operational, allow queries */
+        atomic_set(&ec->query_pending, 0);
 
-        return ec_install_handlers(ec);
+        return ret;
 }
 
 static int acpi_ec_stop(struct acpi_device *device, int type)
@@ -779,34 +852,6 @@ static int acpi_ec_stop(struct acpi_device *device, int type)
         return 0;
 }
 
-static acpi_status
-ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
-{
-        acpi_status status;
-
-        struct acpi_ec *ec = context;
-        status = acpi_walk_resources(handle, METHOD_NAME__CRS,
-                                     ec_parse_io_ports, ec);
-        if (ACPI_FAILURE(status))
-                return status;
-
-        /* Get GPE bit assignment (EC events). */
-        /* TODO: Add support for _GPE returning a package */
-        status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec->gpe);
-        if (ACPI_FAILURE(status))
-                return status;
-
-        /* Use the global lock for all EC transactions? */
-        acpi_evaluate_integer(handle, "_GLK", NULL, &ec->global_lock);
-
-        ec->handle = handle;
-
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "GPE=0x%02lx, ports=0x%2lx, 0x%2lx",
-                          ec->gpe, ec->command_addr, ec->data_addr));
-
-        return AE_CTRL_TERMINATE;
-}
-
 int __init acpi_ec_ecdt_probe(void)
 {
         int ret;
@@ -825,7 +870,7 @@ int __init acpi_ec_ecdt_probe(void)
         if (ACPI_FAILURE(status))
                 goto error;
 
-        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found ECDT"));
+        printk(KERN_INFO PREFIX "EC description table is found, configuring boot EC\n");
 
         boot_ec->command_addr = ecdt_ptr->control.address;
         boot_ec->data_addr = ecdt_ptr->data.address;
diff --git a/drivers/acpi/event.c b/drivers/acpi/event.c
index 3b23562e6f..dfa5853b17 100644
--- a/drivers/acpi/event.c
+++ b/drivers/acpi/event.c
@@ -11,6 +11,8 @@
 #include <linux/init.h>
 #include <linux/poll.h>
 #include <acpi/acpi_drivers.h>
+#include <net/netlink.h>
+#include <net/genetlink.h>
 
 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
 ACPI_MODULE_NAME("event");
@@ -48,7 +50,6 @@ acpi_system_read_event(struct file *file, char __user * buffer, size_t count,
         static int chars_remaining = 0;
         static char *ptr;
 
-
         if (!chars_remaining) {
                 memset(&event, 0, sizeof(struct acpi_bus_event));
 
@@ -106,23 +107,161 @@ static const struct file_operations acpi_system_event_ops = {
         .poll = acpi_system_poll_event,
 };
 
+#ifdef CONFIG_NET
+unsigned int acpi_event_seqnum;
+struct acpi_genl_event {
+        acpi_device_class device_class;
+        char bus_id[15];
+        u32 type;
+        u32 data;
+};
+
+/* attributes of acpi_genl_family */
+enum {
+        ACPI_GENL_ATTR_UNSPEC,
+        ACPI_GENL_ATTR_EVENT,   /* ACPI event info needed by user space */
+        __ACPI_GENL_ATTR_MAX,
+};
+#define ACPI_GENL_ATTR_MAX (__ACPI_GENL_ATTR_MAX - 1)
+
+/* commands supported by the acpi_genl_family */
+enum {
+        ACPI_GENL_CMD_UNSPEC,
+        ACPI_GENL_CMD_EVENT,    /* kernel->user notifications for ACPI events */
+        __ACPI_GENL_CMD_MAX,
+};
+#define ACPI_GENL_CMD_MAX (__ACPI_GENL_CMD_MAX - 1)
+
+#define ACPI_GENL_FAMILY_NAME           "acpi_event"
+#define ACPI_GENL_VERSION               0x01
+#define ACPI_GENL_MCAST_GROUP_NAME      "acpi_mc_group"
+
+static struct genl_family acpi_event_genl_family = {
+        .id = GENL_ID_GENERATE,
+        .name = ACPI_GENL_FAMILY_NAME,
+        .version = ACPI_GENL_VERSION,
+        .maxattr = ACPI_GENL_ATTR_MAX,
+};
+
+static struct genl_multicast_group acpi_event_mcgrp = {
+        .name = ACPI_GENL_MCAST_GROUP_NAME,
+};
+
+int acpi_bus_generate_genetlink_event(struct acpi_device *device,
+                                      u8 type, int data)
+{
+        struct sk_buff *skb;
+        struct nlattr *attr;
+        struct acpi_genl_event *event;
+        void *msg_header;
+        int size;
+        int result;
+
+        /* allocate memory */
+        size = nla_total_size(sizeof(struct acpi_genl_event)) +
+            nla_total_size(0);
+
+        skb = genlmsg_new(size, GFP_ATOMIC);
+        if (!skb)
+                return -ENOMEM;
+
+        /* add the genetlink message header */
+        msg_header = genlmsg_put(skb, 0, acpi_event_seqnum++,
+                                 &acpi_event_genl_family, 0,
+                                 ACPI_GENL_CMD_EVENT);
+        if (!msg_header) {
+                nlmsg_free(skb);
+                return -ENOMEM;
+        }
+
+        /* fill the data */
+        attr =
+            nla_reserve(skb, ACPI_GENL_ATTR_EVENT,
+                        sizeof(struct acpi_genl_event));
+        if (!attr) {
+                nlmsg_free(skb);
+                return -EINVAL;
+        }
+
+        event = nla_data(attr);
+        if (!event) {
+                nlmsg_free(skb);
+                return -EINVAL;
+        }
+
+        memset(event, 0, sizeof(struct acpi_genl_event));
+
+        strcpy(event->device_class, device->pnp.device_class);
+        strcpy(event->bus_id, device->dev.bus_id);
+        event->type = type;
+        event->data = data;
+
+        /* send multicast genetlink message */
+        result = genlmsg_end(skb, msg_header);
+        if (result < 0) {
+                nlmsg_free(skb);
+                return result;
+        }
+
+        result =
+            genlmsg_multicast(skb, 0, acpi_event_mcgrp.id, GFP_ATOMIC);
+        if (result)
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                                  "Failed to send a Genetlink message!\n"));
+        return 0;
+}
+
+static int acpi_event_genetlink_init(void)
+{
+        int result;
+
+        result = genl_register_family(&acpi_event_genl_family);
+        if (result)
+                return result;
+
+        result = genl_register_mc_group(&acpi_event_genl_family,
+                                        &acpi_event_mcgrp);
+        if (result)
+                genl_unregister_family(&acpi_event_genl_family);
+
+        return result;
+}
+
+#else
+int acpi_bus_generate_genetlink_event(struct acpi_device *device, u8 type,
+                                      int data)
+{
+        return 0;
+}
+
+static int acpi_event_genetlink_init(void)
+{
+        return -ENODEV;
+}
+#endif
+
 static int __init acpi_event_init(void)
 {
         struct proc_dir_entry *entry;
         int error = 0;
 
-
         if (acpi_disabled)
                 return 0;
 
+        /* create genetlink for acpi event */
+        error = acpi_event_genetlink_init();
+        if (error)
+                printk(KERN_WARNING PREFIX
+                       "Failed to create genetlink family for ACPI event\n");
+
         /* 'event' [R] */
         entry = create_proc_entry("event", S_IRUSR, acpi_root_dir);
         if (entry)
                 entry->proc_fops = &acpi_system_event_ops;
-        else {
-                error = -ENODEV;
-        }
-        return error;
+        else
+                return -ENODEV;
+
+        return 0;
 }
 
-subsys_initcall(acpi_event_init);
+fs_initcall(acpi_event_init);
diff --git a/drivers/acpi/events/evgpeblk.c b/drivers/acpi/events/evgpeblk.c
index 902c287b3a..361ebe6c4a 100644
--- a/drivers/acpi/events/evgpeblk.c
+++ b/drivers/acpi/events/evgpeblk.c
@@ -586,6 +586,10 @@ acpi_ev_delete_gpe_xrupt(struct acpi_gpe_xrupt_info *gpe_xrupt)
         flags = acpi_os_acquire_lock(acpi_gbl_gpe_lock);
         if (gpe_xrupt->previous) {
                 gpe_xrupt->previous->next = gpe_xrupt->next;
+        } else {
+                /* No previous, update list head */
+
+                acpi_gbl_gpe_xrupt_list_head = gpe_xrupt->next;
         }
 
         if (gpe_xrupt->next) {
diff --git a/drivers/acpi/events/evrgnini.c b/drivers/acpi/events/evrgnini.c
index 400d90fca9..23ee7bc4a7 100644
--- a/drivers/acpi/events/evrgnini.c
+++ b/drivers/acpi/events/evrgnini.c
@@ -284,6 +284,7 @@ acpi_ev_pci_config_region_setup(acpi_handle handle,
         }
 
         if (!pci_device_node) {
+                ACPI_FREE(pci_id);
                 return_ACPI_STATUS(AE_AML_OPERAND_TYPE);
         }
 
diff --git a/drivers/acpi/glue.c b/drivers/acpi/glue.c
index 41427a41f6..4893e256e3 100644
--- a/drivers/acpi/glue.c
+++ b/drivers/acpi/glue.c
@@ -16,7 +16,7 @@
 #if ACPI_GLUE_DEBUG
 #define DBG(x...) printk(PREFIX x)
 #else
-#define DBG(x...)
+#define DBG(x...) do { } while(0)
 #endif
 static LIST_HEAD(bus_type_list);
 static DECLARE_RWSEM(bus_type_sem);
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index 0c9f15c54e..ab04d848b1 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -36,13 +36,11 @@
 ACPI_MODULE_NAME("numa");
 
 static nodemask_t nodes_found_map = NODE_MASK_NONE;
-#define PXM_INVAL       -1
-#define NID_INVAL       -1
 
 /* maps to convert between proximity domain and logical node ID */
-static int pxm_to_node_map[MAX_PXM_DOMAINS]
+static int __cpuinitdata pxm_to_node_map[MAX_PXM_DOMAINS]
                                 = { [0 ... MAX_PXM_DOMAINS - 1] = NID_INVAL };
-static int node_to_pxm_map[MAX_NUMNODES]
+static int __cpuinitdata node_to_pxm_map[MAX_NUMNODES]
                                 = { [0 ... MAX_NUMNODES - 1] = PXM_INVAL };
 
 int pxm_to_node(int pxm)
@@ -59,6 +57,12 @@ int node_to_pxm(int node)
         return node_to_pxm_map[node];
 }
 
+void __acpi_map_pxm_to_node(int pxm, int node)
+{
+        pxm_to_node_map[pxm] = node;
+        node_to_pxm_map[node] = pxm;
+}
+
 int acpi_map_pxm_to_node(int pxm)
 {
         int node = pxm_to_node_map[pxm];
@@ -67,8 +71,7 @@ int acpi_map_pxm_to_node(int pxm)
                 if (nodes_weight(nodes_found_map) >= MAX_NUMNODES)
                         return NID_INVAL;
                 node = first_unset_node(nodes_found_map);
-                pxm_to_node_map[pxm] = node;
-                node_to_pxm_map[node] = pxm;
+                __acpi_map_pxm_to_node(pxm, node);
                 node_set(node, nodes_found_map);
         }
 
@@ -83,7 +86,8 @@ void __cpuinit acpi_unmap_pxm_to_node(int node)
         node_clear(node, nodes_found_map);
 }
 
-void __init acpi_table_print_srat_entry(struct acpi_subtable_header * header)
+static void __init
+acpi_table_print_srat_entry(struct acpi_subtable_header *header)
 {
 
         ACPI_FUNCTION_NAME("acpi_table_print_srat_entry");
@@ -200,7 +204,7 @@ static int __init acpi_parse_srat(struct acpi_table_header *table)
         return 0;
 }
 
-int __init
+static int __init
 acpi_table_parse_srat(enum acpi_srat_type id,
                       acpi_table_entry_handler handler, unsigned int max_entries)
 {
@@ -211,14 +215,13 @@ acpi_table_parse_srat(enum acpi_srat_type id,
 
 int __init acpi_numa_init(void)
 {
-        int result;
-
         /* SRAT: Static Resource Affinity Table */
         if (!acpi_table_parse(ACPI_SIG_SRAT, acpi_parse_srat)) {
-                result = acpi_table_parse_srat(ACPI_SRAT_TYPE_CPU_AFFINITY,
-                                               acpi_parse_processor_affinity,
-                                               NR_CPUS);
-                result = acpi_table_parse_srat(ACPI_SRAT_TYPE_MEMORY_AFFINITY, acpi_parse_memory_affinity, NR_NODE_MEMBLKS);    // IA64 specific
+                acpi_table_parse_srat(ACPI_SRAT_TYPE_CPU_AFFINITY,
+                                      acpi_parse_processor_affinity, NR_CPUS);
+                acpi_table_parse_srat(ACPI_SRAT_TYPE_MEMORY_AFFINITY,
+                                      acpi_parse_memory_affinity,
+                                      NR_NODE_MEMBLKS);
         }
 
         /* SLIT: System Locality Information Table */
diff --git a/drivers/acpi/osl.c b/drivers/acpi/osl.c
index 00d53c2fd1..12c09fafce 100644
--- a/drivers/acpi/osl.c
+++ b/drivers/acpi/osl.c
@@ -77,13 +77,7 @@ static struct workqueue_struct *kacpi_notify_wq;
 #define OSI_STRING_LENGTH_MAX 64        /* arbitrary */
 static char osi_additional_string[OSI_STRING_LENGTH_MAX];
 
-#define OSI_LINUX_ENABLED
-#ifdef  OSI_LINUX_ENABLED
-int osi_linux = 1;      /* enable _OSI(Linux) by default */
-#else
-int osi_linux;          /* disable _OSI(Linux) by default */
-#endif
-
+static int osi_linux;           /* disable _OSI(Linux) by default */
 
 #ifdef CONFIG_DMI
 static struct __initdata dmi_system_id acpi_osl_dmi_table[];
@@ -1183,17 +1177,10 @@ acpi_os_validate_interface (char *interface)
         if (!strcmp("Linux", interface)) {
                 printk(KERN_WARNING PREFIX
                         "System BIOS is requesting _OSI(Linux)\n");
-#ifdef  OSI_LINUX_ENABLED
-                printk(KERN_WARNING PREFIX
-                        "Please test with \"acpi_osi=!Linux\"\n"
-                        "Please send dmidecode "
-                        "to linux-acpi@vger.kernel.org\n");
-#else
                 printk(KERN_WARNING PREFIX
                         "If \"acpi_osi=Linux\" works better,\n"
                         "Please send dmidecode "
                         "to linux-acpi@vger.kernel.org\n");
-#endif
                 if(osi_linux)
                         return AE_OK;
         }
@@ -1227,36 +1214,14 @@ acpi_os_validate_address (
 }
 
 #ifdef CONFIG_DMI
-#ifdef  OSI_LINUX_ENABLED
-static int dmi_osi_not_linux(struct dmi_system_id *d)
-{
-        printk(KERN_NOTICE "%s detected: requires not _OSI(Linux)\n", d->ident);
-        enable_osi_linux(0);
-        return 0;
-}
-#else
 static int dmi_osi_linux(struct dmi_system_id *d)
 {
-        printk(KERN_NOTICE "%s detected: requires _OSI(Linux)\n", d->ident);
+        printk(KERN_NOTICE "%s detected: enabling _OSI(Linux)\n", d->ident);
         enable_osi_linux(1);
         return 0;
 }
-#endif
 
 static struct dmi_system_id acpi_osl_dmi_table[] __initdata = {
-#ifdef  OSI_LINUX_ENABLED
-        /*
-         * Boxes that need NOT _OSI(Linux)
-         */
-        {
-         .callback = dmi_osi_not_linux,
-         .ident = "Toshiba Satellite P100",
-         .matches = {
-                     DMI_MATCH(DMI_BOARD_VENDOR, "TOSHIBA"),
-                     DMI_MATCH(DMI_BOARD_NAME, "Satellite P100"),
-                     },
-         },
-#else
         /*
          * Boxes that need _OSI(Linux)
          */
@@ -1268,7 +1233,6 @@ static struct dmi_system_id acpi_osl_dmi_table[] __initdata = {
                      DMI_MATCH(DMI_BOARD_NAME, "MPAD-MSAE Customer Reference Boards"),
                      },
          },
-#endif
         {}
 };
 #endif /* CONFIG_DMI */
diff --git a/drivers/acpi/pci_link.c b/drivers/acpi/pci_link.c
index acc5947713..3448edd61d 100644
--- a/drivers/acpi/pci_link.c
+++ b/drivers/acpi/pci_link.c
@@ -733,7 +733,7 @@ static int acpi_pci_link_add(struct acpi_device *device)
         /* query and set link->irq.active */
         acpi_pci_link_get_current(link);
 
-        printk(PREFIX "%s [%s] (IRQs", acpi_device_name(device),
+        printk(KERN_INFO PREFIX "%s [%s] (IRQs", acpi_device_name(device),
                acpi_device_bid(device));
         for (i = 0; i < link->irq.possible_count; i++) {
                 if (link->irq.active == link->irq.possible[i]) {
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index e1ca86dfdd..81aceb5da7 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -66,6 +66,7 @@
 #define ACPI_PROCESSOR_FILE_LIMIT       "limit"
 #define ACPI_PROCESSOR_NOTIFY_PERFORMANCE 0x80
 #define ACPI_PROCESSOR_NOTIFY_POWER     0x81
+#define ACPI_PROCESSOR_NOTIFY_THROTTLING        0x82
 
 #define ACPI_PROCESSOR_LIMIT_USER       0
 #define ACPI_PROCESSOR_LIMIT_THERMAL    1
@@ -84,6 +85,8 @@ static int acpi_processor_info_open_fs(struct inode *inode, struct file *file);
 static void acpi_processor_notify(acpi_handle handle, u32 event, void *data);
 static acpi_status acpi_processor_hotadd_init(acpi_handle handle, int *p_cpu);
 static int acpi_processor_handle_eject(struct acpi_processor *pr);
+extern int acpi_processor_tstate_has_changed(struct acpi_processor *pr);
+
 
 static struct acpi_driver acpi_processor_driver = {
         .name = "processor",
@@ -696,6 +699,9 @@ static void acpi_processor_notify(acpi_handle handle, u32 event, void *data)
                 acpi_processor_cst_has_changed(pr);
                 acpi_bus_generate_event(device, event, 0);
                 break;
+        case ACPI_PROCESSOR_NOTIFY_THROTTLING:
+                acpi_processor_tstate_has_changed(pr);
+                acpi_bus_generate_event(device, event, 0);
         default:
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                                   "Unsupported event [0x%x]\n", event));
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index bb5d23be42..a898991f77 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -490,7 +490,17 @@ static void acpi_processor_idle(void)
 
         case ACPI_STATE_C3:
 
-                if (pr->flags.bm_check) {
+                /*
+                 * disable bus master
+                 * bm_check implies we need ARB_DIS
+                 * !bm_check implies we need cache flush
+                 * bm_control implies whether we can do ARB_DIS
+                 *
+                 * That leaves a case where bm_check is set and bm_control is
+                 * not set. In that case we cannot do much, we enter C3
+                 * without doing anything.
+                 */
+                if (pr->flags.bm_check && pr->flags.bm_control) {
                         if (atomic_inc_return(&c3_cpu_count) ==
                             num_online_cpus()) {
                                 /*
@@ -499,7 +509,7 @@ static void acpi_processor_idle(void)
                                  */
                                 acpi_set_register(ACPI_BITREG_ARB_DISABLE, 1);
                         }
-                } else {
+                } else if (!pr->flags.bm_check) {
                         /* SMP with no shared cache... Invalidate cache  */
                         ACPI_FLUSH_CPU_CACHE();
                 }
@@ -511,7 +521,7 @@ static void acpi_processor_idle(void)
                 acpi_cstate_enter(cx);
                 /* Get end time (ticks) */
                 t2 = inl(acpi_gbl_FADT.xpm_timer_block.address);
-                if (pr->flags.bm_check) {
+                if (pr->flags.bm_check && pr->flags.bm_control) {
                         /* Enable bus master arbitration */
                         atomic_dec(&c3_cpu_count);
                         acpi_set_register(ACPI_BITREG_ARB_DISABLE, 0);
@@ -961,9 +971,9 @@ static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
         if (pr->flags.bm_check) {
                 /* bus mastering control is necessary */
                 if (!pr->flags.bm_control) {
+                        /* In this case we enter C3 without bus mastering */
                         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                          "C3 support requires bus mastering control\n"));
-                        return;
+                                "C3 support without bus mastering control\n"));
                 }
         } else {
                 /*
diff --git a/drivers/acpi/processor_throttling.c b/drivers/acpi/processor_throttling.c
index b33486009f..3f55d1f90c 100644
--- a/drivers/acpi/processor_throttling.c
+++ b/drivers/acpi/processor_throttling.c
@@ -44,17 +44,231 @@
 #define _COMPONENT              ACPI_PROCESSOR_COMPONENT
 ACPI_MODULE_NAME("processor_throttling");
 
+static int acpi_processor_get_throttling(struct acpi_processor *pr);
+int acpi_processor_set_throttling(struct acpi_processor *pr, int state);
+
+static int acpi_processor_get_platform_limit(struct acpi_processor *pr)
+{
+        acpi_status status = 0;
+        unsigned long tpc = 0;
+
+        if (!pr)
+                return -EINVAL;
+        status = acpi_evaluate_integer(pr->handle, "_TPC", NULL, &tpc);
+        if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) {
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TPC"));
+                return -ENODEV;
+        }
+        pr->throttling_platform_limit = (int)tpc;
+        return 0;
+}
+
+int acpi_processor_tstate_has_changed(struct acpi_processor *pr)
+{
+        return acpi_processor_get_platform_limit(pr);
+}
+
+/* --------------------------------------------------------------------------
+                             _PTC, _TSS, _TSD support 
+   -------------------------------------------------------------------------- */
+static int acpi_processor_get_throttling_control(struct acpi_processor *pr)
+{
+        int result = 0;
+        acpi_status status = 0;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        union acpi_object *ptc = NULL;
+        union acpi_object obj = { 0 };
+
+        status = acpi_evaluate_object(pr->handle, "_PTC", NULL, &buffer);
+        if (ACPI_FAILURE(status)) {
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _PTC"));
+                return -ENODEV;
+        }
+
+        ptc = (union acpi_object *)buffer.pointer;
+        if (!ptc || (ptc->type != ACPI_TYPE_PACKAGE)
+            || (ptc->package.count != 2)) {
+                printk(KERN_ERR PREFIX "Invalid _PTC data\n");
+                result = -EFAULT;
+                goto end;
+        }
+
+        /*
+         * control_register
+         */
+
+        obj = ptc->package.elements[0];
+
+        if ((obj.type != ACPI_TYPE_BUFFER)
+            || (obj.buffer.length < sizeof(struct acpi_ptc_register))
+            || (obj.buffer.pointer == NULL)) {
+                printk(KERN_ERR PREFIX
+                       "Invalid _PTC data (control_register)\n");
+                result = -EFAULT;
+                goto end;
+        }
+        memcpy(&pr->throttling.control_register, obj.buffer.pointer,
+               sizeof(struct acpi_ptc_register));
+
+        /*
+         * status_register
+         */
+
+        obj = ptc->package.elements[1];
+
+        if ((obj.type != ACPI_TYPE_BUFFER)
+            || (obj.buffer.length < sizeof(struct acpi_ptc_register))
+            || (obj.buffer.pointer == NULL)) {
+                printk(KERN_ERR PREFIX "Invalid _PTC data (status_register)\n");
+                result = -EFAULT;
+                goto end;
+        }
+
+        memcpy(&pr->throttling.status_register, obj.buffer.pointer,
+               sizeof(struct acpi_ptc_register));
+
+      end:
+        kfree(buffer.pointer);
+
+        return result;
+}
+static int acpi_processor_get_throttling_states(struct acpi_processor *pr)
+{
+        int result = 0;
+        acpi_status status = AE_OK;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
+        struct acpi_buffer state = { 0, NULL };
+        union acpi_object *tss = NULL;
+        int i;
+
+        status = acpi_evaluate_object(pr->handle, "_TSS", NULL, &buffer);
+        if (ACPI_FAILURE(status)) {
+                ACPI_EXCEPTION((AE_INFO, status, "Evaluating _TSS"));
+                return -ENODEV;
+        }
+
+        tss = buffer.pointer;
+        if (!tss || (tss->type != ACPI_TYPE_PACKAGE)) {
+                printk(KERN_ERR PREFIX "Invalid _TSS data\n");
+                result = -EFAULT;
+                goto end;
+        }
+
+        ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d throttling states\n",
+                          tss->package.count));
+
+        pr->throttling.state_count = tss->package.count;
+        pr->throttling.states_tss =
+            kmalloc(sizeof(struct acpi_processor_tx_tss) * tss->package.count,
+                    GFP_KERNEL);
+        if (!pr->throttling.states_tss) {
+                result = -ENOMEM;
+                goto end;
+        }
+
+        for (i = 0; i < pr->throttling.state_count; i++) {
+
+                struct acpi_processor_tx_tss *tx =
+                    (struct acpi_processor_tx_tss *)&(pr->throttling.
+                                                      states_tss[i]);
+
+                state.length = sizeof(struct acpi_processor_tx_tss);
+                state.pointer = tx;
+
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Extracting state %d\n", i));
+
+                status = acpi_extract_package(&(tss->package.elements[i]),
+                                              &format, &state);
+                if (ACPI_FAILURE(status)) {
+                        ACPI_EXCEPTION((AE_INFO, status, "Invalid _TSS data"));
+                        result = -EFAULT;
+                        kfree(pr->throttling.states_tss);
+                        goto end;
+                }
+
+                if (!tx->freqpercentage) {
+                        printk(KERN_ERR PREFIX
+                               "Invalid _TSS data: freq is zero\n");
+                        result = -EFAULT;
+                        kfree(pr->throttling.states_tss);
+                        goto end;
+                }
+        }
+
+      end:
+        kfree(buffer.pointer);
+
+        return result;
+}
+static int acpi_processor_get_tsd(struct acpi_processor *pr)
+{
+        int result = 0;
+        acpi_status status = AE_OK;
+        struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
+        struct acpi_buffer format = { sizeof("NNNNN"), "NNNNN" };
+        struct acpi_buffer state = { 0, NULL };
+        union acpi_object *tsd = NULL;
+        struct acpi_tsd_package *pdomain;
+
+        status = acpi_evaluate_object(pr->handle, "_TSD", NULL, &buffer);
+        if (ACPI_FAILURE(status)) {
+                return -ENODEV;
+        }
+
+        tsd = buffer.pointer;
+        if (!tsd || (tsd->type != ACPI_TYPE_PACKAGE)) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _TSD data\n"));
+                result = -EFAULT;
+                goto end;
+        }
+
+        if (tsd->package.count != 1) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _TSD data\n"));
+                result = -EFAULT;
+                goto end;
+        }
+
+        pdomain = &(pr->throttling.domain_info);
+
+        state.length = sizeof(struct acpi_tsd_package);
+        state.pointer = pdomain;
+
+        status = acpi_extract_package(&(tsd->package.elements[0]),
+                                      &format, &state);
+        if (ACPI_FAILURE(status)) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Invalid _TSD data\n"));
+                result = -EFAULT;
+                goto end;
+        }
+
+        if (pdomain->num_entries != ACPI_TSD_REV0_ENTRIES) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unknown _TSD:num_entries\n"));
+                result = -EFAULT;
+                goto end;
+        }
+
+        if (pdomain->revision != ACPI_TSD_REV0_REVISION) {
+                ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Unknown _TSD:revision\n"));
+                result = -EFAULT;
+                goto end;
+        }
+
+      end:
+        kfree(buffer.pointer);
+        return result;
+}
+
 /* --------------------------------------------------------------------------
                               Throttling Control
    -------------------------------------------------------------------------- */
-static int acpi_processor_get_throttling(struct acpi_processor *pr)
+static int acpi_processor_get_throttling_fadt(struct acpi_processor *pr)
 {
         int state = 0;
         u32 value = 0;
         u32 duty_mask = 0;
         u32 duty_value = 0;
 
-
         if (!pr)
                 return -EINVAL;
 
@@ -94,13 +308,115 @@ static int acpi_processor_get_throttling(struct acpi_processor *pr)
         return 0;
 }
 
-int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
+static int acpi_read_throttling_status(struct acpi_processor_throttling
+                                       *throttling)
+{
+        int value = -1;
+        switch (throttling->status_register.space_id) {
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                acpi_os_read_port((acpi_io_address) throttling->status_register.
+                                  address, &value,
+                                  (u32) throttling->status_register.bit_width *
+                                  8);
+                break;
+        case ACPI_ADR_SPACE_FIXED_HARDWARE:
+                printk(KERN_ERR PREFIX
+                       "HARDWARE addr space,NOT supported yet\n");
+                break;
+        default:
+                printk(KERN_ERR PREFIX "Unknown addr space %d\n",
+                       (u32) (throttling->status_register.space_id));
+        }
+        return value;
+}
+
+static int acpi_write_throttling_state(struct acpi_processor_throttling
+                                       *throttling, int value)
+{
+        int ret = -1;
+
+        switch (throttling->control_register.space_id) {
+        case ACPI_ADR_SPACE_SYSTEM_IO:
+                acpi_os_write_port((acpi_io_address) throttling->
+                                   control_register.address, value,
+                                   (u32) throttling->control_register.
+                                   bit_width * 8);
+                ret = 0;
+                break;
+        case ACPI_ADR_SPACE_FIXED_HARDWARE:
+                printk(KERN_ERR PREFIX
+                       "HARDWARE addr space,NOT supported yet\n");
+                break;
+        default:
+                printk(KERN_ERR PREFIX "Unknown addr space %d\n",
+                       (u32) (throttling->control_register.space_id));
+        }
+        return ret;
+}
+
+static int acpi_get_throttling_state(struct acpi_processor *pr, int value)
+{
+        int i;
+
+        for (i = 0; i < pr->throttling.state_count; i++) {
+                struct acpi_processor_tx_tss *tx =
+                    (struct acpi_processor_tx_tss *)&(pr->throttling.
+                                                      states_tss[i]);
+                if (tx->control == value)
+                        break;
+        }
+        if (i > pr->throttling.state_count)
+                i = -1;
+        return i;
+}
+
+static int acpi_get_throttling_value(struct acpi_processor *pr, int state)
+{
+        int value = -1;
+        if (state >= 0 && state <= pr->throttling.state_count) {
+                struct acpi_processor_tx_tss *tx =
+                    (struct acpi_processor_tx_tss *)&(pr->throttling.
+                                                      states_tss[state]);
+                value = tx->control;
+        }
+        return value;
+}
+
+static int acpi_processor_get_throttling_ptc(struct acpi_processor *pr)
+{
+        int state = 0;
+        u32 value = 0;
+
+        if (!pr)
+                return -EINVAL;
+
+        if (!pr->flags.throttling)
+                return -ENODEV;
+
+        pr->throttling.state = 0;
+        local_irq_disable();
+        value = acpi_read_throttling_status(&pr->throttling);
+        if (value >= 0) {
+                state = acpi_get_throttling_state(pr, value);
+                pr->throttling.state = state;
+        }
+        local_irq_enable();
+
+        return 0;
+}
+
+static int acpi_processor_get_throttling(struct acpi_processor *pr)
+{
+        return pr->throttling.acpi_processor_get_throttling(pr);
+}
+
+static int acpi_processor_set_throttling_fadt(struct acpi_processor *pr,
+                                              int state)
 {
         u32 value = 0;
         u32 duty_mask = 0;
         u32 duty_value = 0;
 
-
         if (!pr)
                 return -EINVAL;
 
@@ -113,6 +429,8 @@ int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
         if (state == pr->throttling.state)
                 return 0;
 
+        if (state < pr->throttling_platform_limit)
+                return -EPERM;
         /*
          * Calculate the duty_value and duty_mask.
          */
@@ -165,12 +483,51 @@ int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
         return 0;
 }
 
+static int acpi_processor_set_throttling_ptc(struct acpi_processor *pr,
+                                             int state)
+{
+        u32 value = 0;
+
+        if (!pr)
+                return -EINVAL;
+
+        if ((state < 0) || (state > (pr->throttling.state_count - 1)))
+                return -EINVAL;
+
+        if (!pr->flags.throttling)
+                return -ENODEV;
+
+        if (state == pr->throttling.state)
+                return 0;
+
+        if (state < pr->throttling_platform_limit)
+                return -EPERM;
+
+        local_irq_disable();
+
+        value = acpi_get_throttling_value(pr, state);
+        if (value >= 0) {
+                acpi_write_throttling_state(&pr->throttling, value);
+                pr->throttling.state = state;
+        }
+        local_irq_enable();
+
+        return 0;
+}
+
+int acpi_processor_set_throttling(struct acpi_processor *pr, int state)
+{
+        return pr->throttling.acpi_processor_set_throttling(pr, state);
+}
+
 int acpi_processor_get_throttling_info(struct acpi_processor *pr)
 {
         int result = 0;
         int step = 0;
         int i = 0;
-
+        int no_ptc = 0;
+        int no_tss = 0;
+        int no_tsd = 0;
 
         ACPI_DEBUG_PRINT((ACPI_DB_INFO,
                           "pblk_address[0x%08x] duty_offset[%d] duty_width[%d]\n",
@@ -182,6 +539,21 @@ int acpi_processor_get_throttling_info(struct acpi_processor *pr)
                 return -EINVAL;
 
         /* TBD: Support ACPI 2.0 objects */
+        no_ptc = acpi_processor_get_throttling_control(pr);
+        no_tss = acpi_processor_get_throttling_states(pr);
+        no_tsd = acpi_processor_get_tsd(pr);
+
+        if (no_ptc || no_tss) {
+                pr->throttling.acpi_processor_get_throttling =
+                    &acpi_processor_get_throttling_fadt;
+                pr->throttling.acpi_processor_set_throttling =
+                    &acpi_processor_set_throttling_fadt;
+        } else {
+                pr->throttling.acpi_processor_get_throttling =
+                    &acpi_processor_get_throttling_ptc;
+                pr->throttling.acpi_processor_set_throttling =
+                    &acpi_processor_set_throttling_ptc;
+        }
 
         if (!pr->throttling.address) {
                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No throttling register\n"));
@@ -262,7 +634,6 @@ static int acpi_processor_throttling_seq_show(struct seq_file *seq,
         int i = 0;
         int result = 0;
 
-
         if (!pr)
                 goto end;
 
@@ -280,15 +651,25 @@ static int acpi_processor_throttling_seq_show(struct seq_file *seq,
         }
 
         seq_printf(seq, "state count:             %d\n"
-                   "active state:            T%d\n",
-                   pr->throttling.state_count, pr->throttling.state);
+                   "active state:            T%d\n"
+                   "state available: T%d to T%d\n",
+                   pr->throttling.state_count, pr->throttling.state,
+                   pr->throttling_platform_limit,
+                   pr->throttling.state_count - 1);
 
         seq_puts(seq, "states:\n");
-        for (i = 0; i < pr->throttling.state_count; i++)
-                seq_printf(seq, "   %cT%d:                  %02d%%\n",
-                           (i == pr->throttling.state ? '*' : ' '), i,
-                           (pr->throttling.states[i].performance ? pr->
-                            throttling.states[i].performance / 10 : 0));
+        if (acpi_processor_get_throttling == acpi_processor_get_throttling_fadt)
+                for (i = 0; i < pr->throttling.state_count; i++)
+                        seq_printf(seq, "   %cT%d:                  %02d%%\n",
+                                   (i == pr->throttling.state ? '*' : ' '), i,
+                                   (pr->throttling.states[i].performance ? pr->
+                                    throttling.states[i].performance / 10 : 0));
+        else
+                for (i = 0; i < pr->throttling.state_count; i++)
+                        seq_printf(seq, "   %cT%d:                  %02d%%\n",
+                                   (i == pr->throttling.state ? '*' : ' '), i,
+                                   (int)pr->throttling.states_tss[i].
+                                   freqpercentage);
 
       end:
         return 0;
@@ -301,7 +682,7 @@ static int acpi_processor_throttling_open_fs(struct inode *inode,
                            PDE(inode)->data);
 }
 
-static ssize_t acpi_processor_write_throttling(struct file * file,
+static ssize_t acpi_processor_write_throttling(struct file *file,
                                                const char __user * buffer,
                                                size_t count, loff_t * data)
 {
@@ -310,7 +691,6 @@ static ssize_t acpi_processor_write_throttling(struct file * file,
         struct acpi_processor *pr = m->private;
         char state_string[12] = { '\0' };
 
-
         if (!pr || (count > sizeof(state_string) - 1))
                 return -EINVAL;
 
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
index c1bae10683..974d00ccfe 100644
--- a/drivers/acpi/sbs.c
+++ b/drivers/acpi/sbs.c
@@ -127,7 +127,7 @@ static int acpi_sbs_resume(struct acpi_device *device);
 static struct acpi_driver acpi_sbs_driver = {
         .name = "sbs",
         .class = ACPI_SBS_CLASS,
-        .ids = ACPI_SBS_HID,
+        .ids = "ACPI0001,ACPI0005",
         .ops = {
                 .add = acpi_sbs_add,
                 .remove = acpi_sbs_remove,
@@ -176,10 +176,8 @@ struct acpi_battery {
 };
 
 struct acpi_sbs {
-        acpi_handle handle;
         int base;
         struct acpi_device *device;
-        struct acpi_ec_smbus *smbus;
         struct mutex mutex;
         int sbsm_present;
         int sbsm_batteries_supported;
@@ -511,7 +509,7 @@ static int acpi_sbsm_get_info(struct acpi_sbs *sbs)
                                 "acpi_sbs_read_word() failed"));
                 goto end;
         }
-
+        sbs->sbsm_present = 1;
         sbs->sbsm_batteries_supported = battery_system_info & 0x000f;
 
       end:
@@ -1630,13 +1628,12 @@ static int acpi_sbs_add(struct acpi_device *device)
 {
         struct acpi_sbs *sbs = NULL;
         int result = 0, remove_result = 0;
-        unsigned long sbs_obj;
         int id;
         acpi_status status = AE_OK;
         unsigned long val;
 
         status =
-            acpi_evaluate_integer(device->parent->handle, "_EC", NULL, &val);
+            acpi_evaluate_integer(device->handle, "_EC", NULL, &val);
         if (ACPI_FAILURE(status)) {
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Error obtaining _EC"));
                 return -EIO;
@@ -1653,7 +1650,7 @@ static int acpi_sbs_add(struct acpi_device *device)
 
         sbs_mutex_lock(sbs);
 
-        sbs->base = (val & 0xff00ull) >> 8;
+        sbs->base = 0xff & (val >> 8);
         sbs->device = device;
 
         strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
@@ -1665,24 +1662,10 @@ static int acpi_sbs_add(struct acpi_device *device)
                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "acpi_ac_add() failed"));
                 goto end;
         }
-        status = acpi_evaluate_integer(device->handle, "_SBS", NULL, &sbs_obj);
-        if (status) {
-                ACPI_EXCEPTION((AE_INFO, status,
-                                "acpi_evaluate_integer() failed"));
-                result = -EIO;
-                goto end;
-        }
-        if (sbs_obj > 0) {
-                result = acpi_sbsm_get_info(sbs);
-                if (result) {
-                        ACPI_EXCEPTION((AE_INFO, AE_ERROR,
-                                        "acpi_sbsm_get_info() failed"));
-                        goto end;
-                }
-                sbs->sbsm_present = 1;
-        }
 
-        if (sbs->sbsm_present == 0) {
+        acpi_sbsm_get_info(sbs);
+
+        if (!sbs->sbsm_present) {
                 result = acpi_battery_add(sbs, 0);
                 if (result) {
                         ACPI_EXCEPTION((AE_INFO, AE_ERROR,
@@ -1702,8 +1685,6 @@ static int acpi_sbs_add(struct acpi_device *device)
                 }
         }
 
-        sbs->handle = device->handle;
-
         init_timer(&sbs->update_timer);
         result = acpi_check_update_proc(sbs);
         if (result)
diff --git a/drivers/acpi/sleep/main.c b/drivers/acpi/sleep/main.c
index 42127c0d61..3279e72a94 100644
--- a/drivers/acpi/sleep/main.c
+++ b/drivers/acpi/sleep/main.c
@@ -210,11 +210,6 @@ static void acpi_hibernation_finish(void)
 
         /* reset firmware waking vector */
         acpi_set_firmware_waking_vector((acpi_physical_address) 0);
-
-        if (init_8259A_after_S1) {
-                printk("Broken toshiba laptop -> kicking interrupts\n");
-                init_8259A(0);
-        }
 }
 
 static int acpi_hibernation_pre_restore(void)
diff --git a/drivers/acpi/system.c b/drivers/acpi/system.c
index 83a8d30979..edee2806e3 100644
--- a/drivers/acpi/system.c
+++ b/drivers/acpi/system.c
@@ -39,15 +39,12 @@ ACPI_MODULE_NAME("system");
 
 #define ACPI_SYSTEM_CLASS               "system"
 #define ACPI_SYSTEM_DEVICE_NAME         "System"
-#define ACPI_SYSTEM_FILE_INFO           "info"
-#define ACPI_SYSTEM_FILE_EVENT          "event"
-#define ACPI_SYSTEM_FILE_DSDT           "dsdt"
-#define ACPI_SYSTEM_FILE_FADT           "fadt"
 
 /*
  * Make ACPICA version work as module param
  */
-static int param_get_acpica_version(char *buffer, struct kernel_param *kp) {
+static int param_get_acpica_version(char *buffer, struct kernel_param *kp)
+{
         int result;
 
         result = sprintf(buffer, "%x", ACPI_CA_VERSION);
@@ -58,9 +55,126 @@ static int param_get_acpica_version(char *buffer, struct kernel_param *kp) {
 module_param_call(acpica_version, NULL, param_get_acpica_version, NULL, 0444);
 
 /* --------------------------------------------------------------------------
+                              FS Interface (/sys)
+   -------------------------------------------------------------------------- */
+static LIST_HEAD(acpi_table_attr_list);
+static struct kobject tables_kobj;
+
+struct acpi_table_attr {
+        struct bin_attribute attr;
+        char name[8];
+        int instance;
+        struct list_head node;
+};
+
+static ssize_t acpi_table_show(struct kobject *kobj,
+                               struct bin_attribute *bin_attr, char *buf,
+                               loff_t offset, size_t count)
+{
+        struct acpi_table_attr *table_attr =
+            container_of(bin_attr, struct acpi_table_attr, attr);
+        struct acpi_table_header *table_header = NULL;
+        acpi_status status;
+        ssize_t ret_count = count;
+
+        status =
+            acpi_get_table(table_attr->name, table_attr->instance,
+                           &table_header);
+        if (ACPI_FAILURE(status))
+                return -ENODEV;
+
+        if (offset >= table_header->length) {
+                ret_count = 0;
+                goto end;
+        }
+
+        if (offset + ret_count > table_header->length)
+                ret_count = table_header->length - offset;
+
+        memcpy(buf, ((char *)table_header) + offset, ret_count);
+
+      end:
+        return ret_count;
+}
+
+static void acpi_table_attr_init(struct acpi_table_attr *table_attr,
+                                 struct acpi_table_header *table_header)
+{
+        struct acpi_table_header *header = NULL;
+        struct acpi_table_attr *attr = NULL;
+
+        memcpy(table_attr->name, table_header->signature, ACPI_NAME_SIZE);
+
+        list_for_each_entry(attr, &acpi_table_attr_list, node) {
+                if (!memcmp(table_header->signature, attr->name,
+                            ACPI_NAME_SIZE))
+                        if (table_attr->instance < attr->instance)
+                                table_attr->instance = attr->instance;
+        }
+        table_attr->instance++;
+
+        if (table_attr->instance > 1 || (table_attr->instance == 1 &&
+                                         !acpi_get_table(table_header->
+                                                         signature, 2,
+                                                         &header)))
+                sprintf(table_attr->name + 4, "%d", table_attr->instance);
+
+        table_attr->attr.size = 0;
+        table_attr->attr.read = acpi_table_show;
+        table_attr->attr.attr.name = table_attr->name;
+        table_attr->attr.attr.mode = 0444;
+        table_attr->attr.attr.owner = THIS_MODULE;
+
+        return;
+}
+
+static int acpi_system_sysfs_init(void)
+{
+        struct acpi_table_attr *table_attr;
+        struct acpi_table_header *table_header = NULL;
+        int table_index = 0;
+        int result;
+
+        tables_kobj.parent = &acpi_subsys.kobj;
+        kobject_set_name(&tables_kobj, "tables");
+        result = kobject_register(&tables_kobj);
+        if (result)
+                return result;
+
+        do {
+                result = acpi_get_table_by_index(table_index, &table_header);
+                if (!result) {
+                        table_index++;
+                        table_attr = NULL;
+                        table_attr =
+                            kzalloc(sizeof(struct acpi_table_attr), GFP_KERNEL);
+                        if (!table_attr)
+                                return -ENOMEM;
+
+                        acpi_table_attr_init(table_attr, table_header);
+                        result =
+                            sysfs_create_bin_file(&tables_kobj,
+                                                  &table_attr->attr);
+                        if (result) {
+                                kfree(table_attr);
+                                return result;
+                        } else
+                                list_add_tail(&table_attr->node,
+                                              &acpi_table_attr_list);
+                }
+        } while (!result);
+
+        return 0;
+}
+
+/* --------------------------------------------------------------------------
                               FS Interface (/proc)
    -------------------------------------------------------------------------- */
 #ifdef CONFIG_ACPI_PROCFS
+#define ACPI_SYSTEM_FILE_INFO           "info"
+#define ACPI_SYSTEM_FILE_EVENT          "event"
+#define ACPI_SYSTEM_FILE_DSDT           "dsdt"
+#define ACPI_SYSTEM_FILE_FADT           "fadt"
 
 static int acpi_system_read_info(struct seq_file *seq, void *offset)
 {
@@ -80,7 +194,6 @@ static const struct file_operations acpi_system_info_ops = {
         .llseek = seq_lseek,
         .release = single_release,
 };
-#endif
 
 static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
                                      loff_t *);
@@ -97,13 +210,11 @@ acpi_system_read_dsdt(struct file *file,
         struct acpi_table_header *dsdt = NULL;
         ssize_t res;
 
-
         status = acpi_get_table(ACPI_SIG_DSDT, 1, &dsdt);
         if (ACPI_FAILURE(status))
                 return -ENODEV;
 
-        res = simple_read_from_buffer(buffer, count, ppos,
-                                      dsdt, dsdt->length);
+        res = simple_read_from_buffer(buffer, count, ppos, dsdt, dsdt->length);
 
         return res;
 }
@@ -123,28 +234,21 @@ acpi_system_read_fadt(struct file *file,
         struct acpi_table_header *fadt = NULL;
         ssize_t res;
 
-
         status = acpi_get_table(ACPI_SIG_FADT, 1, &fadt);
         if (ACPI_FAILURE(status))
                 return -ENODEV;
 
-        res = simple_read_from_buffer(buffer, count, ppos,
-                                      fadt, fadt->length);
+        res = simple_read_from_buffer(buffer, count, ppos, fadt, fadt->length);
 
         return res;
 }
 
-static int __init acpi_system_init(void)
+static int acpi_system_procfs_init(void)
 {
         struct proc_dir_entry *entry;
         int error = 0;
         char *name;
 
-
-        if (acpi_disabled)
-                return 0;
-
-#ifdef CONFIG_ACPI_PROCFS
         /* 'info' [R] */
         name = ACPI_SYSTEM_FILE_INFO;
         entry = create_proc_entry(name, S_IRUGO, acpi_root_dir);
@@ -153,7 +257,6 @@ static int __init acpi_system_init(void)
         else {
                 entry->proc_fops = &acpi_system_info_ops;
         }
-#endif
 
         /* 'dsdt' [R] */
         name = ACPI_SYSTEM_FILE_DSDT;
@@ -177,12 +280,32 @@ static int __init acpi_system_init(void)
       Error:
         remove_proc_entry(ACPI_SYSTEM_FILE_FADT, acpi_root_dir);
         remove_proc_entry(ACPI_SYSTEM_FILE_DSDT, acpi_root_dir);
-#ifdef CONFIG_ACPI_PROCFS
         remove_proc_entry(ACPI_SYSTEM_FILE_INFO, acpi_root_dir);
-#endif
 
         error = -EFAULT;
         goto Done;
 }
+#else
+static int acpi_system_procfs_init(void)
+{
+        return 0;
+}
+#endif
+
+static int __init acpi_system_init(void)
+{
+        int result = 0;
+
+        if (acpi_disabled)
+                return 0;
+
+        result = acpi_system_procfs_init();
+        if (result)
+                return result;
+
+        result = acpi_system_sysfs_init();
+
+        return result;
+}
 
 subsys_initcall(acpi_system_init);
diff --git a/drivers/acpi/tables/tbfadt.c b/drivers/acpi/tables/tbfadt.c
index 1285e91474..002bb33003 100644
--- a/drivers/acpi/tables/tbfadt.c
+++ b/drivers/acpi/tables/tbfadt.c
@@ -211,14 +211,17 @@ void acpi_tb_parse_fadt(acpi_native_uint table_index, u8 flags)
  * DESCRIPTION: Get a local copy of the FADT and convert it to a common format.
  *              Performs validation on some important FADT fields.
  *
+ * NOTE:        We create a local copy of the FADT regardless of the version.
+ *
  ******************************************************************************/
 
 void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length)
 {
 
         /*
-         * Check if the FADT is larger than what we know about (ACPI 2.0 version).
-         * Truncate the table, but make some noise.
+         * Check if the FADT is larger than the largest table that we expect
+         * (the ACPI 2.0/3.0 version). If so, truncate the table, and issue
+         * a warning.
          */
         if (length > sizeof(struct acpi_table_fadt)) {
                 ACPI_WARNING((AE_INFO,
@@ -227,10 +230,12 @@ void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length)
                               sizeof(struct acpi_table_fadt)));
         }
 
-        /* Copy the entire FADT locally. Zero first for tb_convert_fadt */
+        /* Clear the entire local FADT */
 
         ACPI_MEMSET(&acpi_gbl_FADT, 0, sizeof(struct acpi_table_fadt));
 
+        /* Copy the original FADT, up to sizeof (struct acpi_table_fadt) */
+
         ACPI_MEMCPY(&acpi_gbl_FADT, table,
                     ACPI_MIN(length, sizeof(struct acpi_table_fadt)));
 
@@ -251,7 +256,7 @@ void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length)
  * RETURN:      None
  *
  * DESCRIPTION: Converts all versions of the FADT to a common internal format.
- *              -> Expand all 32-bit addresses to 64-bit.
+ *              Expand all 32-bit addresses to 64-bit.
  *
  * NOTE:        acpi_gbl_FADT must be of size (struct acpi_table_fadt),
  *              and must contain a copy of the actual FADT.
@@ -292,8 +297,23 @@ static void acpi_tb_convert_fadt(void)
         }
 
         /*
-         * Expand the 32-bit V1.0 addresses to the 64-bit "X" generic address
-         * structures as necessary.
+         * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which
+         * should be zero are indeed zero. This will workaround BIOSs that
+         * inadvertently place values in these fields.
+         *
+         * The ACPI 1.0 reserved fields that will be zeroed are the bytes located at
+         * offset 45, 55, 95, and the word located at offset 109, 110.
+         */
+        if (acpi_gbl_FADT.header.revision < 3) {
+                acpi_gbl_FADT.preferred_profile = 0;
+                acpi_gbl_FADT.pstate_control = 0;
+                acpi_gbl_FADT.cst_control = 0;
+                acpi_gbl_FADT.boot_flags = 0;
+        }
+
+        /*
+         * Expand the ACPI 1.0 32-bit V1.0 addresses to the ACPI 2.0 64-bit "X"
+         * generic address structures as necessary.
          */
         for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {
                 target =
@@ -349,18 +369,6 @@ static void acpi_tb_convert_fadt(void)
                     acpi_gbl_FADT.xpm1a_event_block.space_id;
 
         }
-
-        /*
-         * For ACPI 1.0 FADTs, ensure that reserved fields (which should be zero)
-         * are indeed zero. This will workaround BIOSs that inadvertently placed
-         * values in these fields.
-         */
-        if (acpi_gbl_FADT.header.revision < 3) {
-                acpi_gbl_FADT.preferred_profile = 0;
-                acpi_gbl_FADT.pstate_control = 0;
-                acpi_gbl_FADT.cst_control = 0;
-                acpi_gbl_FADT.boot_flags = 0;
-        }
 }
 
 /******************************************************************************
diff --git a/drivers/acpi/utilities/uteval.c b/drivers/acpi/utilities/uteval.c
index 8ec6f8e481..f112af433e 100644
--- a/drivers/acpi/utilities/uteval.c
+++ b/drivers/acpi/utilities/uteval.c
@@ -62,16 +62,13 @@ acpi_ut_translate_one_cid(union acpi_operand_object *obj_desc,
 static char *acpi_interfaces_supported[] = {
         /* Operating System Vendor Strings */
 
-        "Windows 2000",
-        "Windows 2001",
-        "Windows 2001 SP0",
-        "Windows 2001 SP1",
-        "Windows 2001 SP2",
-        "Windows 2001 SP3",
-        "Windows 2001 SP4",
-        "Windows 2001.1",
-        "Windows 2001.1 SP1",   /* Added 03/2006 */
-        "Windows 2006",         /* Added 03/2006 */
+        "Windows 2000",         /* Windows 2000 */
+        "Windows 2001",         /* Windows XP */
+        "Windows 2001 SP1",     /* Windows XP SP1 */
+        "Windows 2001 SP2",     /* Windows XP SP2 */
+        "Windows 2001.1",       /* Windows Server 2003 */
+        "Windows 2001.1 SP1",   /* Windows Server 2003 SP1 - Added 03/2006 */
+        "Windows 2006",         /* Windows Vista - Added 03/2006 */
 
         /* Feature Group Strings */
 
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 00d25b3472..5f014d3764 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -33,6 +33,7 @@
 #include <linux/seq_file.h>
 
 #include <linux/backlight.h>
+#include <linux/video_output.h>
 #include <asm/uaccess.h>
 
 #include <acpi/acpi_bus.h>
@@ -169,6 +170,7 @@ struct acpi_video_device {
         struct acpi_device *dev;
         struct acpi_video_device_brightness *brightness;
         struct backlight_device *backlight;
+        struct output_device *output_dev;
 };
 
 /* bus */
@@ -272,6 +274,10 @@ static int acpi_video_get_next_level(struct acpi_video_device *device,
                                      u32 level_current, u32 event);
 static void acpi_video_switch_brightness(struct acpi_video_device *device,
                                          int event);
+static int acpi_video_device_get_state(struct acpi_video_device *device,
+                            unsigned long *state);
+static int acpi_video_output_get(struct output_device *od);
+static int acpi_video_device_set_state(struct acpi_video_device *device, int state);
 
 /*backlight device sysfs support*/
 static int acpi_video_get_brightness(struct backlight_device *bd)
@@ -297,6 +303,28 @@ static struct backlight_ops acpi_backlight_ops = {
         .update_status  = acpi_video_set_brightness,
 };
 
+/*video output device sysfs support*/
+static int acpi_video_output_get(struct output_device *od)
+{
+        unsigned long state;
+        struct acpi_video_device *vd =
+                (struct acpi_video_device *)class_get_devdata(&od->class_dev);
+        acpi_video_device_get_state(vd, &state);
+        return (int)state;
+}
+
+static int acpi_video_output_set(struct output_device *od)
+{
+        unsigned long state = od->request_state;
+        struct acpi_video_device *vd=
+                (struct acpi_video_device *)class_get_devdata(&od->class_dev);
+        return acpi_video_device_set_state(vd, state);
+}
+
+static struct output_properties acpi_output_properties = {
+        .set_state = acpi_video_output_set,
+        .get_status = acpi_video_output_get,
+};
 /* --------------------------------------------------------------------------
                                Video Management
    -------------------------------------------------------------------------- */
@@ -531,7 +559,6 @@ acpi_video_bus_DOS(struct acpi_video_bus *video, int bios_flag, int lcd_flag)
 
 static void acpi_video_device_find_cap(struct acpi_video_device *device)
 {
-        acpi_integer status;
         acpi_handle h_dummy1;
         int i;
         u32 max_level = 0;
@@ -565,50 +592,55 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
                 device->cap._DSS = 1;
         }
 
-        status = acpi_video_device_lcd_query_levels(device, &obj);
-
-        if (obj && obj->type == ACPI_TYPE_PACKAGE && obj->package.count >= 2) {
-                int count = 0;
-                union acpi_object *o;
-
-                br = kzalloc(sizeof(*br), GFP_KERNEL);
-                if (!br) {
-                        printk(KERN_ERR "can't allocate memory\n");
-                } else {
-                        br->levels = kmalloc(obj->package.count *
-                                             sizeof *(br->levels), GFP_KERNEL);
-                        if (!br->levels)
-                                goto out;
-
-                        for (i = 0; i < obj->package.count; i++) {
-                                o = (union acpi_object *)&obj->package.
-                                    elements[i];
-                                if (o->type != ACPI_TYPE_INTEGER) {
-                                        printk(KERN_ERR PREFIX "Invalid data\n");
-                                        continue;
-                                }
-                                br->levels[count] = (u32) o->integer.value;
-                                if (br->levels[count] > max_level)
-                                        max_level = br->levels[count];
-                                count++;
-                        }
-                      out:
-                        if (count < 2) {
-                                kfree(br->levels);
-                                kfree(br);
+        if (ACPI_SUCCESS(acpi_video_device_lcd_query_levels(device, &obj))) {
+
+                if (obj->package.count >= 2) {
+                        int count = 0;
+                        union acpi_object *o;
+
+                        br = kzalloc(sizeof(*br), GFP_KERNEL);
+                        if (!br) {
+                                printk(KERN_ERR "can't allocate memory\n");
                         } else {
-                                br->count = count;
-                                device->brightness = br;
-                                ACPI_DEBUG_PRINT((ACPI_DB_INFO,
-                                                  "found %d brightness levels\n",
-                                                  count));
+                                br->levels = kmalloc(obj->package.count *
+                                                     sizeof *(br->levels), GFP_KERNEL);
+                                if (!br->levels)
+                                        goto out;
+
+                                for (i = 0; i < obj->package.count; i++) {
+                                        o = (union acpi_object *)&obj->package.
+                                            elements[i];
+                                        if (o->type != ACPI_TYPE_INTEGER) {
+                                                printk(KERN_ERR PREFIX "Invalid data\n");
+                                                continue;
+                                        }
+                                        br->levels[count] = (u32) o->integer.value;
+
+                                        if (br->levels[count] > max_level)
+                                                max_level = br->levels[count];
+                                        count++;
+                                }
+                              out:
+                                if (count < 2) {
+                                        kfree(br->levels);
+                                        kfree(br);
+                                } else {
+                                        br->count = count;
+                                        device->brightness = br;
+                                        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
+                                                          "found %d brightness levels\n",
+                                                          count));
+                                }
                         }
                 }
+
+        } else {
+                ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not query available LCD brightness level\n"));
         }
 
         kfree(obj);
 
-        if (device->cap._BCL && device->cap._BCM && device->cap._BQC){
+        if (device->cap._BCL && device->cap._BCM && device->cap._BQC && max_level > 0){
                 unsigned long tmp;
                 static int count = 0;
                 char *name;
@@ -626,6 +658,17 @@ static void acpi_video_device_find_cap(struct acpi_video_device *device)
 
                 kfree(name);
         }
+        if (device->cap._DCS && device->cap._DSS){
+                static int count = 0;
+                char *name;
+                name = kzalloc(MAX_NAME_LEN, GFP_KERNEL);
+                if (!name)
+                        return;
+                sprintf(name, "acpi_video%d", count++);
+                device->output_dev = video_output_register(name,
+                                NULL, device, &acpi_output_properties);
+                kfree(name);
+        }
         return;
 }
 
@@ -1669,6 +1712,7 @@ static int acpi_video_bus_put_one_device(struct acpi_video_device *device)
                                             ACPI_DEVICE_NOTIFY,
                                             acpi_video_device_notify);
         backlight_device_unregister(device->backlight);
+        video_output_unregister(device->output_dev);
         return 0;
 }
 
diff --git a/drivers/base/power/trace.c b/drivers/base/power/trace.c
index a9ab30feff..2b0c601e42 100644
--- a/drivers/base/power/trace.c
+++ b/drivers/base/power/trace.c
@@ -142,6 +142,7 @@ void set_trace_device(struct device *dev)
 {
         dev_hash_value = hash_string(DEVSEED, dev->bus_id, DEVHASH);
 }
+EXPORT_SYMBOL(set_trace_device);
 
 /*
  * We could just take the "tracedata" index into the .tracedata
@@ -162,6 +163,7 @@ void generate_resume_trace(void *tracedata, unsigned int user)
         file_hash_value = hash_string(lineno, file, FILEHASH);
         set_magic_time(user_hash_value, file_hash_value, dev_hash_value);
 }
+EXPORT_SYMBOL(generate_resume_trace);
 
 extern char __tracedata_start, __tracedata_end;
 static int show_file_hash(unsigned int value)
@@ -170,7 +172,8 @@ static int show_file_hash(unsigned int value)
         char *tracedata;
 
         match = 0;
-        for (tracedata = &__tracedata_start ; tracedata < &__tracedata_end ; tracedata += 6) {
+        for (tracedata = &__tracedata_start ; tracedata < &__tracedata_end ;
+                        tracedata += 2 + sizeof(unsigned long)) {
                 unsigned short lineno = *(unsigned short *)tracedata;
                 const char *file = *(const char **)(tracedata + 2);
                 unsigned int hash = hash_string(lineno, file, FILEHASH);
diff --git a/drivers/block/Makefile b/drivers/block/Makefile
index 819c829125..a7a099027f 100644
--- a/drivers/block/Makefile
+++ b/drivers/block/Makefile
@@ -8,6 +8,7 @@
 obj-$(CONFIG_MAC_FLOPPY)        += swim3.o
 obj-$(CONFIG_BLK_DEV_FD)        += floppy.o
 obj-$(CONFIG_AMIGA_FLOPPY)      += amiflop.o
+obj-$(CONFIG_PS3_DISK)          += ps3disk.o
 obj-$(CONFIG_ATARI_FLOPPY)      += ataflop.o
 obj-$(CONFIG_AMIGA_Z2RAM)       += z2ram.o
 obj-$(CONFIG_BLK_DEV_RAM)       += rd.o
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
new file mode 100644
index 0000000000..170fb33dba
--- /dev/null
+++ b/drivers/block/ps3disk.c
@@ -0,0 +1,630 @@
+/*
+ * PS3 Disk Storage Driver
+ *
+ * Copyright (C) 2007 Sony Computer Entertainment Inc.
+ * Copyright 2007 Sony Corp.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/ata.h>
+#include <linux/blkdev.h>
+
+#include <asm/lv1call.h>
+#include <asm/ps3stor.h>
+#include <asm/firmware.h>
+
+
+#define DEVICE_NAME             "ps3disk"
+
+#define BOUNCE_SIZE             (64*1024)
+
+#define PS3DISK_MAX_DISKS       16
+#define PS3DISK_MINORS          16
+
+
+#define PS3DISK_NAME            "ps3d%c"
+
+
+struct ps3disk_private {
+        spinlock_t lock;                /* Request queue spinlock */
+        struct request_queue *queue;
+        struct gendisk *gendisk;
+        unsigned int blocking_factor;
+        struct request *req;
+        u64 raw_capacity;
+        unsigned char model[ATA_ID_PROD_LEN+1];
+};
+
+
+#define LV1_STORAGE_SEND_ATA_COMMAND    (2)
+#define LV1_STORAGE_ATA_HDDOUT          (0x23)
+
+struct lv1_ata_cmnd_block {
+        u16     features;
+        u16     sector_count;
+        u16     LBA_low;
+        u16     LBA_mid;
+        u16     LBA_high;
+        u8      device;
+        u8      command;
+        u32     is_ext;
+        u32     proto;
+        u32     in_out;
+        u32     size;
+        u64     buffer;
+        u32     arglen;
+};
+
+enum lv1_ata_proto {
+        NON_DATA_PROTO     = 0,
+        PIO_DATA_IN_PROTO  = 1,
+        PIO_DATA_OUT_PROTO = 2,
+        DMA_PROTO = 3
+};
+
+enum lv1_ata_in_out {
+        DIR_WRITE = 0,                  /* memory -> device */
+        DIR_READ = 1                    /* device -> memory */
+};
+
+static int ps3disk_major;
+
+
+static struct block_device_operations ps3disk_fops = {
+        .owner          = THIS_MODULE,
+};
+
+
+static void ps3disk_scatter_gather(struct ps3_storage_device *dev,
+                                   struct request *req, int gather)
+{
+        unsigned int offset = 0;
+        struct bio *bio;
+        sector_t sector;
+        struct bio_vec *bvec;
+        unsigned int i = 0, j;
+        size_t size;
+        void *buf;
+
+        rq_for_each_bio(bio, req) {
+                sector = bio->bi_sector;
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u: bio %u: %u segs %u sectors from %lu\n",
+                        __func__, __LINE__, i, bio_segments(bio),
+                        bio_sectors(bio), sector);
+                bio_for_each_segment(bvec, bio, j) {
+                        size = bvec->bv_len;
+                        buf = __bio_kmap_atomic(bio, j, KM_IRQ0);
+                        if (gather)
+                                memcpy(dev->bounce_buf+offset, buf, size);
+                        else
+                                memcpy(buf, dev->bounce_buf+offset, size);
+                        offset += size;
+                        flush_kernel_dcache_page(bio_iovec_idx(bio, j)->bv_page);
+                        __bio_kunmap_atomic(bio, KM_IRQ0);
+                }
+                i++;
+        }
+}
+
+static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
+                                     struct request *req)
+{
+        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        int write = rq_data_dir(req), res;
+        const char *op = write ? "write" : "read";
+        u64 start_sector, sectors;
+        unsigned int region_id = dev->regions[dev->region_idx].id;
+
+#ifdef DEBUG
+        unsigned int n = 0;
+        struct bio *bio;
+
+        rq_for_each_bio(bio, req)
+                n++;
+        dev_dbg(&dev->sbd.core,
+                "%s:%u: %s req has %u bios for %lu sectors %lu hard sectors\n",
+                __func__, __LINE__, op, n, req->nr_sectors,
+                req->hard_nr_sectors);
+#endif
+
+        start_sector = req->sector * priv->blocking_factor;
+        sectors = req->nr_sectors * priv->blocking_factor;
+        dev_dbg(&dev->sbd.core, "%s:%u: %s %lu sectors starting at %lu\n",
+                __func__, __LINE__, op, sectors, start_sector);
+
+        if (write) {
+                ps3disk_scatter_gather(dev, req, 1);
+
+                res = lv1_storage_write(dev->sbd.dev_id, region_id,
+                                        start_sector, sectors, 0,
+                                        dev->bounce_lpar, &dev->tag);
+        } else {
+                res = lv1_storage_read(dev->sbd.dev_id, region_id,
+                                       start_sector, sectors, 0,
+                                       dev->bounce_lpar, &dev->tag);
+        }
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: %s failed %d\n", __func__,
+                        __LINE__, op, res);
+                end_request(req, 0);
+                return 0;
+        }
+
+        priv->req = req;
+        return 1;
+}
+
+static int ps3disk_submit_flush_request(struct ps3_storage_device *dev,
+                                        struct request *req)
+{
+        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        u64 res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: flush request\n", __func__, __LINE__);
+
+        res = lv1_storage_send_device_command(dev->sbd.dev_id,
+                                              LV1_STORAGE_ATA_HDDOUT, 0, 0, 0,
+                                              0, &dev->tag);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%lx\n",
+                        __func__, __LINE__, res);
+                end_request(req, 0);
+                return 0;
+        }
+
+        priv->req = req;
+        return 1;
+}
+
+static void ps3disk_do_request(struct ps3_storage_device *dev,
+                               request_queue_t *q)
+{
+        struct request *req;
+
+        dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
+
+        while ((req = elv_next_request(q))) {
+                if (blk_fs_request(req)) {
+                        if (ps3disk_submit_request_sg(dev, req))
+                                break;
+                } else if (req->cmd_type == REQ_TYPE_FLUSH) {
+                        if (ps3disk_submit_flush_request(dev, req))
+                                break;
+                } else {
+                        blk_dump_rq_flags(req, DEVICE_NAME " bad request");
+                        end_request(req, 0);
+                        continue;
+                }
+        }
+}
+
+static void ps3disk_request(request_queue_t *q)
+{
+        struct ps3_storage_device *dev = q->queuedata;
+        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+
+        if (priv->req) {
+                dev_dbg(&dev->sbd.core, "%s:%u busy\n", __func__, __LINE__);
+                return;
+        }
+
+        ps3disk_do_request(dev, q);
+}
+
+static irqreturn_t ps3disk_interrupt(int irq, void *data)
+{
+        struct ps3_storage_device *dev = data;
+        struct ps3disk_private *priv;
+        struct request *req;
+        int res, read, uptodate;
+        u64 tag, status;
+        unsigned long num_sectors;
+        const char *op;
+
+        res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
+
+        if (tag != dev->tag)
+                dev_err(&dev->sbd.core,
+                        "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                        __func__, __LINE__, tag, dev->tag);
+
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+                        __func__, __LINE__, res, status);
+                return IRQ_HANDLED;
+        }
+
+        priv = dev->sbd.core.driver_data;
+        req = priv->req;
+        if (!req) {
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u non-block layer request completed\n", __func__,
+                        __LINE__);
+                dev->lv1_status = status;
+                complete(&dev->done);
+                return IRQ_HANDLED;
+        }
+
+        if (req->cmd_type == REQ_TYPE_FLUSH) {
+                read = 0;
+                num_sectors = req->hard_cur_sectors;
+                op = "flush";
+        } else {
+                read = !rq_data_dir(req);
+                num_sectors = req->nr_sectors;
+                op = read ? "read" : "write";
+        }
+        if (status) {
+                dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__,
+                        __LINE__, op, status);
+                uptodate = 0;
+        } else {
+                dev_dbg(&dev->sbd.core, "%s:%u: %s completed\n", __func__,
+                        __LINE__, op);
+                uptodate = 1;
+                if (read)
+                        ps3disk_scatter_gather(dev, req, 0);
+        }
+
+        spin_lock(&priv->lock);
+        if (!end_that_request_first(req, uptodate, num_sectors)) {
+                add_disk_randomness(req->rq_disk);
+                blkdev_dequeue_request(req);
+                end_that_request_last(req, uptodate);
+        }
+        priv->req = NULL;
+        ps3disk_do_request(dev, priv->queue);
+        spin_unlock(&priv->lock);
+
+        return IRQ_HANDLED;
+}
+
+static int ps3disk_sync_cache(struct ps3_storage_device *dev)
+{
+        u64 res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: sync cache\n", __func__, __LINE__);
+
+        res = ps3stor_send_command(dev, LV1_STORAGE_ATA_HDDOUT, 0, 0, 0, 0);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%lx\n",
+                        __func__, __LINE__, res);
+                return -EIO;
+        }
+        return 0;
+}
+
+
+/* ATA helpers copied from drivers/ata/libata-core.c */
+
+static void swap_buf_le16(u16 *buf, unsigned int buf_words)
+{
+#ifdef __BIG_ENDIAN
+        unsigned int i;
+
+        for (i = 0; i < buf_words; i++)
+                buf[i] = le16_to_cpu(buf[i]);
+#endif /* __BIG_ENDIAN */
+}
+
+static u64 ata_id_n_sectors(const u16 *id)
+{
+        if (ata_id_has_lba(id)) {
+                if (ata_id_has_lba48(id))
+                        return ata_id_u64(id, 100);
+                else
+                        return ata_id_u32(id, 60);
+        } else {
+                if (ata_id_current_chs_valid(id))
+                        return ata_id_u32(id, 57);
+                else
+                        return id[1] * id[3] * id[6];
+        }
+}
+
+static void ata_id_string(const u16 *id, unsigned char *s, unsigned int ofs,
+                          unsigned int len)
+{
+        unsigned int c;
+
+        while (len > 0) {
+                c = id[ofs] >> 8;
+                *s = c;
+                s++;
+
+                c = id[ofs] & 0xff;
+                *s = c;
+                s++;
+
+                ofs++;
+                len -= 2;
+        }
+}
+
+static void ata_id_c_string(const u16 *id, unsigned char *s, unsigned int ofs,
+                            unsigned int len)
+{
+        unsigned char *p;
+
+        WARN_ON(!(len & 1));
+
+        ata_id_string(id, s, ofs, len - 1);
+
+        p = s + strnlen(s, len - 1);
+        while (p > s && p[-1] == ' ')
+                p--;
+        *p = '\0';
+}
+
+static int ps3disk_identify(struct ps3_storage_device *dev)
+{
+        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        struct lv1_ata_cmnd_block ata_cmnd;
+        u16 *id = dev->bounce_buf;
+        u64 res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: identify disk\n", __func__, __LINE__);
+
+        memset(&ata_cmnd, 0, sizeof(struct lv1_ata_cmnd_block));
+        ata_cmnd.command = ATA_CMD_ID_ATA;
+        ata_cmnd.sector_count = 1;
+        ata_cmnd.size = ata_cmnd.arglen = ATA_ID_WORDS * 2;
+        ata_cmnd.buffer = dev->bounce_lpar;
+        ata_cmnd.proto = PIO_DATA_IN_PROTO;
+        ata_cmnd.in_out = DIR_READ;
+
+        res = ps3stor_send_command(dev, LV1_STORAGE_SEND_ATA_COMMAND,
+                                   ps3_mm_phys_to_lpar(__pa(&ata_cmnd)),
+                                   sizeof(ata_cmnd), ata_cmnd.buffer,
+                                   ata_cmnd.arglen);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: identify disk failed 0x%lx\n",
+                        __func__, __LINE__, res);
+                return -EIO;
+        }
+
+        swap_buf_le16(id, ATA_ID_WORDS);
+
+        /* All we're interested in are raw capacity and model name */
+        priv->raw_capacity = ata_id_n_sectors(id);
+        ata_id_c_string(id, priv->model, ATA_ID_PROD, sizeof(priv->model));
+        return 0;
+}
+
+static void ps3disk_prepare_flush(request_queue_t *q, struct request *req)
+{
+        struct ps3_storage_device *dev = q->queuedata;
+
+        dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
+
+        memset(req->cmd, 0, sizeof(req->cmd));
+        req->cmd_type = REQ_TYPE_FLUSH;
+}
+
+static int ps3disk_issue_flush(request_queue_t *q, struct gendisk *gendisk,
+                               sector_t *sector)
+{
+        struct ps3_storage_device *dev = q->queuedata;
+        struct request *req;
+        int res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
+
+        req = blk_get_request(q, WRITE, __GFP_WAIT);
+        ps3disk_prepare_flush(q, req);
+        res = blk_execute_rq(q, gendisk, req, 0);
+        if (res)
+                dev_err(&dev->sbd.core, "%s:%u: flush request failed %d\n",
+                        __func__, __LINE__, res);
+        blk_put_request(req);
+        return res;
+}
+
+
+static unsigned long ps3disk_mask;
+
+static DEFINE_MUTEX(ps3disk_mask_mutex);
+
+static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+        struct ps3disk_private *priv;
+        int error;
+        unsigned int devidx;
+        struct request_queue *queue;
+        struct gendisk *gendisk;
+
+        if (dev->blk_size < 512) {
+                dev_err(&dev->sbd.core,
+                        "%s:%u: cannot handle block size %lu\n", __func__,
+                        __LINE__, dev->blk_size);
+                return -EINVAL;
+        }
+
+        BUILD_BUG_ON(PS3DISK_MAX_DISKS > BITS_PER_LONG);
+        mutex_lock(&ps3disk_mask_mutex);
+        devidx = find_first_zero_bit(&ps3disk_mask, PS3DISK_MAX_DISKS);
+        if (devidx >= PS3DISK_MAX_DISKS) {
+                dev_err(&dev->sbd.core, "%s:%u: Too many disks\n", __func__,
+                        __LINE__);
+                mutex_unlock(&ps3disk_mask_mutex);
+                return -ENOSPC;
+        }
+        __set_bit(devidx, &ps3disk_mask);
+        mutex_unlock(&ps3disk_mask_mutex);
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                error = -ENOMEM;
+                goto fail;
+        }
+
+        dev->sbd.core.driver_data = priv;
+        spin_lock_init(&priv->lock);
+
+        dev->bounce_size = BOUNCE_SIZE;
+        dev->bounce_buf = kmalloc(BOUNCE_SIZE, GFP_DMA);
+        if (!dev->bounce_buf) {
+                error = -ENOMEM;
+                goto fail_free_priv;
+        }
+
+        error = ps3stor_setup(dev, ps3disk_interrupt);
+        if (error)
+                goto fail_free_bounce;
+
+        ps3disk_identify(dev);
+
+        queue = blk_init_queue(ps3disk_request, &priv->lock);
+        if (!queue) {
+                dev_err(&dev->sbd.core, "%s:%u: blk_init_queue failed\n",
+                        __func__, __LINE__);
+                error = -ENOMEM;
+                goto fail_teardown;
+        }
+
+        priv->queue = queue;
+        queue->queuedata = dev;
+
+        blk_queue_bounce_limit(queue, BLK_BOUNCE_HIGH);
+
+        blk_queue_max_sectors(queue, dev->bounce_size >> 9);
+        blk_queue_segment_boundary(queue, -1UL);
+        blk_queue_dma_alignment(queue, dev->blk_size-1);
+        blk_queue_hardsect_size(queue, dev->blk_size);
+
+        blk_queue_issue_flush_fn(queue, ps3disk_issue_flush);
+        blk_queue_ordered(queue, QUEUE_ORDERED_DRAIN_FLUSH,
+                          ps3disk_prepare_flush);
+
+        blk_queue_max_phys_segments(queue, -1);
+        blk_queue_max_hw_segments(queue, -1);
+        blk_queue_max_segment_size(queue, dev->bounce_size);
+
+        gendisk = alloc_disk(PS3DISK_MINORS);
+        if (!gendisk) {
+                dev_err(&dev->sbd.core, "%s:%u: alloc_disk failed\n", __func__,
+                        __LINE__);
+                error = -ENOMEM;
+                goto fail_cleanup_queue;
+        }
+
+        priv->gendisk = gendisk;
+        gendisk->major = ps3disk_major;
+        gendisk->first_minor = devidx * PS3DISK_MINORS;
+        gendisk->fops = &ps3disk_fops;
+        gendisk->queue = queue;
+        gendisk->private_data = dev;
+        gendisk->driverfs_dev = &dev->sbd.core;
+        snprintf(gendisk->disk_name, sizeof(gendisk->disk_name), PS3DISK_NAME,
+                 devidx+'a');
+        priv->blocking_factor = dev->blk_size >> 9;
+        set_capacity(gendisk,
+                     dev->regions[dev->region_idx].size*priv->blocking_factor);
+
+        dev_info(&dev->sbd.core,
+                 "%s is a %s (%lu MiB total, %lu MiB for OtherOS)\n",
+                 gendisk->disk_name, priv->model, priv->raw_capacity >> 11,
+                 get_capacity(gendisk) >> 11);
+
+        add_disk(gendisk);
+        return 0;
+
+fail_cleanup_queue:
+        blk_cleanup_queue(queue);
+fail_teardown:
+        ps3stor_teardown(dev);
+fail_free_bounce:
+        kfree(dev->bounce_buf);
+fail_free_priv:
+        kfree(priv);
+        dev->sbd.core.driver_data = NULL;
+fail:
+        mutex_lock(&ps3disk_mask_mutex);
+        __clear_bit(devidx, &ps3disk_mask);
+        mutex_unlock(&ps3disk_mask_mutex);
+        return error;
+}
+
+static int ps3disk_remove(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+
+        mutex_lock(&ps3disk_mask_mutex);
+        __clear_bit(priv->gendisk->first_minor / PS3DISK_MINORS,
+                    &ps3disk_mask);
+        mutex_unlock(&ps3disk_mask_mutex);
+        del_gendisk(priv->gendisk);
+        blk_cleanup_queue(priv->queue);
+        put_disk(priv->gendisk);
+        dev_notice(&dev->sbd.core, "Synchronizing disk cache\n");
+        ps3disk_sync_cache(dev);
+        ps3stor_teardown(dev);
+        kfree(dev->bounce_buf);
+        kfree(priv);
+        dev->sbd.core.driver_data = NULL;
+        return 0;
+}
+
+static struct ps3_system_bus_driver ps3disk = {
+        .match_id       = PS3_MATCH_ID_STOR_DISK,
+        .core.name      = DEVICE_NAME,
+        .core.owner     = THIS_MODULE,
+        .probe          = ps3disk_probe,
+        .remove         = ps3disk_remove,
+        .shutdown       = ps3disk_remove,
+};
+
+
+static int __init ps3disk_init(void)
+{
+        int error;
+
+        if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
+                return -ENODEV;
+
+        error = register_blkdev(0, DEVICE_NAME);
+        if (error <= 0) {
+                printk(KERN_ERR "%s:%u: register_blkdev failed %d\n", __func__,
+                       __LINE__, error);
+                return error;
+        }
+        ps3disk_major = error;
+
+        pr_info("%s:%u: registered block device major %d\n", __func__,
+                __LINE__, ps3disk_major);
+
+        error = ps3_system_bus_driver_register(&ps3disk);
+        if (error)
+                unregister_blkdev(ps3disk_major, DEVICE_NAME);
+
+        return error;
+}
+
+static void __exit ps3disk_exit(void)
+{
+        ps3_system_bus_driver_unregister(&ps3disk);
+        unregister_blkdev(ps3disk_major, DEVICE_NAME);
+}
+
+module_init(ps3disk_init);
+module_exit(ps3disk_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("PS3 Disk Storage Driver");
+MODULE_AUTHOR("Sony Corporation");
+MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_DISK);
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 4e6f387fd1..8fecaf4010 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -107,6 +107,8 @@ obj-$(CONFIG_IPMI_HANDLER)	+= ipmi/
 obj-$(CONFIG_HANGCHECK_TIMER)   += hangcheck-timer.o
 obj-$(CONFIG_TCG_TPM)           += tpm/
 
+obj-$(CONFIG_PS3_FLASH)         += ps3flash.o
+
 # Files generated that shall be removed upon make clean
 clean-files := consolemap_deftbl.c defkeymap.c
 
diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index 7cda04b335..2d7cd486e0 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -41,7 +41,7 @@ config HW_RANDOM_AMD
 
 config HW_RANDOM_GEODE
         tristate "AMD Geode HW Random Number Generator support"
-        depends on HW_RANDOM && X86 && PCI
+        depends on HW_RANDOM && X86_32 && PCI
         default HW_RANDOM
         ---help---
           This driver provides kernel-side support for the Random Number
diff --git a/drivers/char/ps3flash.c b/drivers/char/ps3flash.c
new file mode 100644
index 0000000000..79b6f461be
--- /dev/null
+++ b/drivers/char/ps3flash.c
@@ -0,0 +1,440 @@
+/*
+ * PS3 FLASH ROM Storage Driver
+ *
+ * Copyright (C) 2007 Sony Computer Entertainment Inc.
+ * Copyright 2007 Sony Corp.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/uaccess.h>
+
+#include <asm/lv1call.h>
+#include <asm/ps3stor.h>
+
+
+#define DEVICE_NAME             "ps3flash"
+
+#define FLASH_BLOCK_SIZE        (256*1024)
+
+
+struct ps3flash_private {
+        struct mutex mutex;     /* Bounce buffer mutex */
+};
+
+static struct ps3_storage_device *ps3flash_dev;
+
+static ssize_t ps3flash_read_write_sectors(struct ps3_storage_device *dev,
+                                           u64 lpar, u64 start_sector,
+                                           u64 sectors, int write)
+{
+        u64 res = ps3stor_read_write_sectors(dev, lpar, start_sector, sectors,
+                                             write);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__,
+                        __LINE__, write ? "write" : "read", res);
+                return -EIO;
+        }
+        return sectors;
+}
+
+static ssize_t ps3flash_read_sectors(struct ps3_storage_device *dev,
+                                     u64 start_sector, u64 sectors,
+                                     unsigned int sector_offset)
+{
+        u64 max_sectors, lpar;
+
+        max_sectors = dev->bounce_size / dev->blk_size;
+        if (sectors > max_sectors) {
+                dev_dbg(&dev->sbd.core, "%s:%u Limiting sectors to %lu\n",
+                        __func__, __LINE__, max_sectors);
+                sectors = max_sectors;
+        }
+
+        lpar = dev->bounce_lpar + sector_offset * dev->blk_size;
+        return ps3flash_read_write_sectors(dev, lpar, start_sector, sectors,
+                                           0);
+}
+
+static ssize_t ps3flash_write_chunk(struct ps3_storage_device *dev,
+                                    u64 start_sector)
+{
+       u64 sectors = dev->bounce_size / dev->blk_size;
+       return ps3flash_read_write_sectors(dev, dev->bounce_lpar, start_sector,
+                                          sectors, 1);
+}
+
+static loff_t ps3flash_llseek(struct file *file, loff_t offset, int origin)
+{
+        struct ps3_storage_device *dev = ps3flash_dev;
+        loff_t res;
+
+        mutex_lock(&file->f_mapping->host->i_mutex);
+        switch (origin) {
+        case 1:
+                offset += file->f_pos;
+                break;
+        case 2:
+                offset += dev->regions[dev->region_idx].size*dev->blk_size;
+                break;
+        }
+        if (offset < 0) {
+                res = -EINVAL;
+                goto out;
+        }
+
+        file->f_pos = offset;
+        res = file->f_pos;
+
+out:
+        mutex_unlock(&file->f_mapping->host->i_mutex);
+        return res;
+}
+
+static ssize_t ps3flash_read(struct file *file, char __user *buf, size_t count,
+                             loff_t *pos)
+{
+        struct ps3_storage_device *dev = ps3flash_dev;
+        struct ps3flash_private *priv = dev->sbd.core.driver_data;
+        u64 size, start_sector, end_sector, offset;
+        ssize_t sectors_read;
+        size_t remaining, n;
+
+        dev_dbg(&dev->sbd.core,
+                "%s:%u: Reading %zu bytes at position %lld to user 0x%p\n",
+                __func__, __LINE__, count, *pos, buf);
+
+        size = dev->regions[dev->region_idx].size*dev->blk_size;
+        if (*pos >= size || !count)
+                return 0;
+
+        if (*pos + count > size) {
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u Truncating count from %zu to %llu\n", __func__,
+                        __LINE__, count, size - *pos);
+                count = size - *pos;
+        }
+
+        start_sector = *pos / dev->blk_size;
+        offset = *pos % dev->blk_size;
+        end_sector = DIV_ROUND_UP(*pos + count, dev->blk_size);
+
+        remaining = count;
+        do {
+                mutex_lock(&priv->mutex);
+
+                sectors_read = ps3flash_read_sectors(dev, start_sector,
+                                                     end_sector-start_sector,
+                                                     0);
+                if (sectors_read < 0) {
+                        mutex_unlock(&priv->mutex);
+                        goto fail;
+                }
+
+                n = min(remaining, sectors_read*dev->blk_size-offset);
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u: copy %lu bytes from 0x%p to user 0x%p\n",
+                        __func__, __LINE__, n, dev->bounce_buf+offset, buf);
+                if (copy_to_user(buf, dev->bounce_buf+offset, n)) {
+                        mutex_unlock(&priv->mutex);
+                        sectors_read = -EFAULT;
+                        goto fail;
+                }
+
+                mutex_unlock(&priv->mutex);
+
+                *pos += n;
+                buf += n;
+                remaining -= n;
+                start_sector += sectors_read;
+                offset = 0;
+        } while (remaining > 0);
+
+        return count;
+
+fail:
+        return sectors_read;
+}
+
+static ssize_t ps3flash_write(struct file *file, const char __user *buf,
+                              size_t count, loff_t *pos)
+{
+        struct ps3_storage_device *dev = ps3flash_dev;
+        struct ps3flash_private *priv = dev->sbd.core.driver_data;
+        u64 size, chunk_sectors, start_write_sector, end_write_sector,
+            end_read_sector, start_read_sector, head, tail, offset;
+        ssize_t res;
+        size_t remaining, n;
+        unsigned int sec_off;
+
+        dev_dbg(&dev->sbd.core,
+                "%s:%u: Writing %zu bytes at position %lld from user 0x%p\n",
+                __func__, __LINE__, count, *pos, buf);
+
+        size = dev->regions[dev->region_idx].size*dev->blk_size;
+        if (*pos >= size || !count)
+                return 0;
+
+        if (*pos + count > size) {
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u Truncating count from %zu to %llu\n", __func__,
+                        __LINE__, count, size - *pos);
+                count = size - *pos;
+        }
+
+        chunk_sectors = dev->bounce_size / dev->blk_size;
+
+        start_write_sector = *pos / dev->bounce_size * chunk_sectors;
+        offset = *pos % dev->bounce_size;
+        end_write_sector = DIV_ROUND_UP(*pos + count, dev->bounce_size) *
+                           chunk_sectors;
+
+        end_read_sector = DIV_ROUND_UP(*pos, dev->blk_size);
+        start_read_sector = (*pos + count) / dev->blk_size;
+
+        /*
+         * As we have to write in 256 KiB chunks, while we can read in blk_size
+         * (usually 512 bytes) chunks, we perform the following steps:
+         *   1. Read from start_write_sector to end_read_sector ("head")
+         *   2. Read from start_read_sector to end_write_sector ("tail")
+         *   3. Copy data to buffer
+         *   4. Write from start_write_sector to end_write_sector
+         * All of this is complicated by using only one 256 KiB bounce buffer.
+         */
+
+        head = end_read_sector - start_write_sector;
+        tail = end_write_sector - start_read_sector;
+
+        remaining = count;
+        do {
+                mutex_lock(&priv->mutex);
+
+                if (end_read_sector >= start_read_sector) {
+                        /* Merge head and tail */
+                        dev_dbg(&dev->sbd.core,
+                                "Merged head and tail: %lu sectors at %lu\n",
+                                chunk_sectors, start_write_sector);
+                        res = ps3flash_read_sectors(dev, start_write_sector,
+                                                    chunk_sectors, 0);
+                        if (res < 0)
+                                goto fail;
+                } else {
+                        if (head) {
+                                /* Read head */
+                                dev_dbg(&dev->sbd.core,
+                                        "head: %lu sectors at %lu\n", head,
+                                        start_write_sector);
+                                res = ps3flash_read_sectors(dev,
+                                                            start_write_sector,
+                                                            head, 0);
+                                if (res < 0)
+                                        goto fail;
+                        }
+                        if (start_read_sector <
+                            start_write_sector+chunk_sectors) {
+                                /* Read tail */
+                                dev_dbg(&dev->sbd.core,
+                                        "tail: %lu sectors at %lu\n", tail,
+                                        start_read_sector);
+                                sec_off = start_read_sector-start_write_sector;
+                                res = ps3flash_read_sectors(dev,
+                                                            start_read_sector,
+                                                            tail, sec_off);
+                                if (res < 0)
+                                        goto fail;
+                        }
+                }
+
+                n = min(remaining, dev->bounce_size-offset);
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u: copy %lu bytes from user 0x%p to 0x%p\n",
+                        __func__, __LINE__, n, buf, dev->bounce_buf+offset);
+                if (copy_from_user(dev->bounce_buf+offset, buf, n)) {
+                        res = -EFAULT;
+                        goto fail;
+                }
+
+                res = ps3flash_write_chunk(dev, start_write_sector);
+                if (res < 0)
+                        goto fail;
+
+                mutex_unlock(&priv->mutex);
+
+                *pos += n;
+                buf += n;
+                remaining -= n;
+                start_write_sector += chunk_sectors;
+                head = 0;
+                offset = 0;
+        } while (remaining > 0);
+
+        return count;
+
+fail:
+        mutex_unlock(&priv->mutex);
+        return res;
+}
+
+
+static irqreturn_t ps3flash_interrupt(int irq, void *data)
+{
+        struct ps3_storage_device *dev = data;
+        int res;
+        u64 tag, status;
+
+        res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
+
+        if (tag != dev->tag)
+                dev_err(&dev->sbd.core,
+                        "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                        __func__, __LINE__, tag, dev->tag);
+
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+                        __func__, __LINE__, res, status);
+        } else {
+                dev->lv1_status = status;
+                complete(&dev->done);
+        }
+        return IRQ_HANDLED;
+}
+
+
+static const struct file_operations ps3flash_fops = {
+        .owner  = THIS_MODULE,
+        .llseek = ps3flash_llseek,
+        .read   = ps3flash_read,
+        .write  = ps3flash_write,
+};
+
+static struct miscdevice ps3flash_misc = {
+        .minor  = MISC_DYNAMIC_MINOR,
+        .name   = DEVICE_NAME,
+        .fops   = &ps3flash_fops,
+};
+
+static int __devinit ps3flash_probe(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+        struct ps3flash_private *priv;
+        int error;
+        unsigned long tmp;
+
+        tmp = dev->regions[dev->region_idx].start*dev->blk_size;
+        if (tmp % FLASH_BLOCK_SIZE) {
+                dev_err(&dev->sbd.core,
+                        "%s:%u region start %lu is not aligned\n", __func__,
+                        __LINE__, tmp);
+                return -EINVAL;
+        }
+        tmp = dev->regions[dev->region_idx].size*dev->blk_size;
+        if (tmp % FLASH_BLOCK_SIZE) {
+                dev_err(&dev->sbd.core,
+                        "%s:%u region size %lu is not aligned\n", __func__,
+                        __LINE__, tmp);
+                return -EINVAL;
+        }
+
+        /* use static buffer, kmalloc cannot allocate 256 KiB */
+        if (!ps3flash_bounce_buffer.address)
+                return -ENODEV;
+
+        if (ps3flash_dev) {
+                dev_err(&dev->sbd.core,
+                        "Only one FLASH device is supported\n");
+                return -EBUSY;
+        }
+
+        ps3flash_dev = dev;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                error = -ENOMEM;
+                goto fail;
+        }
+
+        dev->sbd.core.driver_data = priv;
+        mutex_init(&priv->mutex);
+
+        dev->bounce_size = ps3flash_bounce_buffer.size;
+        dev->bounce_buf = ps3flash_bounce_buffer.address;
+
+        error = ps3stor_setup(dev, ps3flash_interrupt);
+        if (error)
+                goto fail_free_priv;
+
+        ps3flash_misc.parent = &dev->sbd.core;
+        error = misc_register(&ps3flash_misc);
+        if (error) {
+                dev_err(&dev->sbd.core, "%s:%u: misc_register failed %d\n",
+                        __func__, __LINE__, error);
+                goto fail_teardown;
+        }
+
+        dev_info(&dev->sbd.core, "%s:%u: registered misc device %d\n",
+                 __func__, __LINE__, ps3flash_misc.minor);
+        return 0;
+
+fail_teardown:
+        ps3stor_teardown(dev);
+fail_free_priv:
+        kfree(priv);
+        dev->sbd.core.driver_data = NULL;
+fail:
+        ps3flash_dev = NULL;
+        return error;
+}
+
+static int ps3flash_remove(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+
+        misc_deregister(&ps3flash_misc);
+        ps3stor_teardown(dev);
+        kfree(dev->sbd.core.driver_data);
+        dev->sbd.core.driver_data = NULL;
+        ps3flash_dev = NULL;
+        return 0;
+}
+
+
+static struct ps3_system_bus_driver ps3flash = {
+        .match_id       = PS3_MATCH_ID_STOR_FLASH,
+        .core.name      = DEVICE_NAME,
+        .core.owner     = THIS_MODULE,
+        .probe          = ps3flash_probe,
+        .remove         = ps3flash_remove,
+        .shutdown       = ps3flash_remove,
+};
+
+
+static int __init ps3flash_init(void)
+{
+        return ps3_system_bus_driver_register(&ps3flash);
+}
+
+static void __exit ps3flash_exit(void)
+{
+        ps3_system_bus_driver_unregister(&ps3flash);
+}
+
+module_init(ps3flash_init);
+module_exit(ps3flash_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("PS3 FLASH ROM Storage Driver");
+MODULE_AUTHOR("Sony Corporation");
+MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_FLASH);
diff --git a/drivers/char/rtc.c b/drivers/char/rtc.c
index 30c3f54c76..ec6b65ec69 100644
--- a/drivers/char/rtc.c
+++ b/drivers/char/rtc.c
@@ -82,7 +82,7 @@
 #include <asm/uaccess.h>
 #include <asm/system.h>
 
-#if defined(__i386__)
+#ifdef CONFIG_X86
 #include <asm/hpet.h>
 #endif
 
diff --git a/drivers/clocksource/acpi_pm.c b/drivers/clocksource/acpi_pm.c
index e783dbf0f1..7b46faf223 100644
--- a/drivers/clocksource/acpi_pm.c
+++ b/drivers/clocksource/acpi_pm.c
@@ -71,7 +71,7 @@ static struct clocksource clocksource_acpi_pm = {
         .rating         = 200,
         .read           = acpi_pm_read,
         .mask           = (cycle_t)ACPI_PM_MASK,
-        .mult           = 0, /*to be caluclated*/
+        .mult           = 0, /*to be calculated*/
         .shift          = 22,
         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 
diff --git a/drivers/input/misc/pcspkr.c b/drivers/input/misc/pcspkr.c
index 31989dcd92..906bf5e8de 100644
--- a/drivers/input/misc/pcspkr.c
+++ b/drivers/input/misc/pcspkr.c
@@ -24,7 +24,12 @@ MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("PC Speaker beeper driver");
 MODULE_LICENSE("GPL");
 
-static DEFINE_SPINLOCK(i8253_beep_lock);
+#ifdef CONFIG_X86
+/* Use the global PIT lock ! */
+#include <asm/i8253.h>
+#else
+static DEFINE_SPINLOCK(i8253_lock);
+#endif
 
 static int pcspkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 {
@@ -43,7 +48,7 @@ static int pcspkr_event(struct input_dev *dev, unsigned int type, unsigned int c
         if (value > 20 && value < 32767)
                 count = PIT_TICK_RATE / value;
 
-        spin_lock_irqsave(&i8253_beep_lock, flags);
+        spin_lock_irqsave(&i8253_lock, flags);
 
         if (count) {
                 /* enable counter 2 */
@@ -58,7 +63,7 @@ static int pcspkr_event(struct input_dev *dev, unsigned int type, unsigned int c
                 outb(inb_p(0x61) & 0xFC, 0x61);
         }
 
-        spin_unlock_irqrestore(&i8253_beep_lock, flags);
+        spin_unlock_irqrestore(&i8253_lock, flags);
 
         return 0;
 }
diff --git a/drivers/isdn/Kconfig b/drivers/isdn/Kconfig
index cf906c8cee..66f946aa30 100644
--- a/drivers/isdn/Kconfig
+++ b/drivers/isdn/Kconfig
@@ -21,9 +21,7 @@ menuconfig ISDN
 
 if ISDN
 
-menu "Old ISDN4Linux"
-
-config ISDN_I4L
+menuconfig ISDN_I4L
         tristate "Old ISDN4Linux (deprecated)"
         ---help---
           This driver allows you to use an ISDN adapter for networking
@@ -45,12 +43,8 @@ if ISDN_I4L
 source "drivers/isdn/i4l/Kconfig"
 endif
 
-endmenu
-
-comment "CAPI subsystem"
-
-config ISDN_CAPI
-        tristate "CAPI2.0 support"
+menuconfig ISDN_CAPI
+        tristate "CAPI 2.0 subsystem"
         help
           This provides the CAPI (Common ISDN Application Programming
           Interface, a standard making it easy for programs to access ISDN
diff --git a/drivers/isdn/act2000/Kconfig b/drivers/isdn/act2000/Kconfig
index 78e6ad8d57..3fc1a5434e 100644
--- a/drivers/isdn/act2000/Kconfig
+++ b/drivers/isdn/act2000/Kconfig
@@ -3,7 +3,7 @@
 #
 config ISDN_DRV_ACT2000
         tristate "IBM Active 2000 support"
-        depends on ISDN_I4L && ISA
+        depends on ISA
         help
           Say Y here if you have an IBM Active 2000 ISDN card. In order to use
           this card, additional firmware is necessary, which has to be loaded
diff --git a/drivers/isdn/gigaset/Kconfig b/drivers/isdn/gigaset/Kconfig
index bcbb6502a7..0017e50c69 100644
--- a/drivers/isdn/gigaset/Kconfig
+++ b/drivers/isdn/gigaset/Kconfig
@@ -1,9 +1,5 @@
-menu "Siemens Gigaset"
-        depends on ISDN_I4L
-
-config ISDN_DRV_GIGASET
+menuconfig ISDN_DRV_GIGASET
         tristate "Siemens Gigaset support (isdn)"
-        depends on ISDN_I4L
         select CRC_CCITT
         select BITREVERSE
         help
@@ -55,6 +51,4 @@ config GIGASET_UNDOCREQ
           features like configuration mode of M105, say yes. If you
           care about your device, say no.
 
-endif
-
-endmenu
+endif # ISDN_DRV_GIGASET != n
diff --git a/drivers/isdn/hisax/Kconfig b/drivers/isdn/hisax/Kconfig
index 12d91fb9f8..a3b945ac32 100644
--- a/drivers/isdn/hisax/Kconfig
+++ b/drivers/isdn/hisax/Kconfig
@@ -1,6 +1,5 @@
 
 menu "Passive cards"
-        depends on ISDN_I4L
 
 config ISDN_DRV_HISAX
         tristate "HiSax SiemensChipSet driver support"
diff --git a/drivers/isdn/i4l/Kconfig b/drivers/isdn/i4l/Kconfig
index e91c187992..36778b270c 100644
--- a/drivers/isdn/i4l/Kconfig
+++ b/drivers/isdn/i4l/Kconfig
@@ -99,7 +99,6 @@ config ISDN_DRV_LOOP
 
 config ISDN_DIVERSION
         tristate "Support isdn diversion services"
-        depends on ISDN_I4L
         help
           This option allows you to use some supplementary diversion
           services in conjunction with the HiSax driver on an EURO/DSS1
@@ -119,13 +118,11 @@ config ISDN_DIVERSION
 endmenu
 
 comment "ISDN4Linux hardware drivers"
-        depends on ISDN_I4L
 
 source "drivers/isdn/hisax/Kconfig"
 
 
 menu "Active cards"
-        depends on ISDN_I4L!=n
 
 source "drivers/isdn/icn/Kconfig"
 
diff --git a/drivers/isdn/icn/Kconfig b/drivers/isdn/icn/Kconfig
index fcb99f5f0b..89d15eed76 100644
--- a/drivers/isdn/icn/Kconfig
+++ b/drivers/isdn/icn/Kconfig
@@ -3,7 +3,7 @@
 #
 config ISDN_DRV_ICN
         tristate "ICN 2B and 4B support"
-        depends on ISDN_I4L && ISA
+        depends on ISA
         help
           This enables support for two kinds of ISDN-cards made by a German
           company called ICN.  2B is the standard version for a single ISDN
diff --git a/drivers/isdn/pcbit/Kconfig b/drivers/isdn/pcbit/Kconfig
index 0933881ab0..ffba6eca12 100644
--- a/drivers/isdn/pcbit/Kconfig
+++ b/drivers/isdn/pcbit/Kconfig
@@ -3,7 +3,7 @@
 #
 config ISDN_DRV_PCBIT
         tristate "PCBIT-D support"
-        depends on ISDN_I4L && ISA && (BROKEN || X86)
+        depends on ISA && (BROKEN || X86)
         help
           This enables support for the PCBIT ISDN-card.  This card is
           manufactured in Portugal by Octal.  For running this card,
diff --git a/drivers/isdn/sc/Kconfig b/drivers/isdn/sc/Kconfig
index 5346e33d81..e6510ca7bf 100644
--- a/drivers/isdn/sc/Kconfig
+++ b/drivers/isdn/sc/Kconfig
@@ -3,7 +3,7 @@
 #
 config ISDN_DRV_SC
         tristate "Spellcaster support"
-        depends on ISDN_I4L && ISA
+        depends on ISA
         help
           This enables support for the Spellcaster BRI ISDN boards.  This
           driver currently builds only in a modularized version.
diff --git a/drivers/kvm/Kconfig b/drivers/kvm/Kconfig
index 2f661e5f0d..6cecc396e0 100644
--- a/drivers/kvm/Kconfig
+++ b/drivers/kvm/Kconfig
@@ -11,6 +11,7 @@ if VIRTUALIZATION
 config KVM
         tristate "Kernel-based Virtual Machine (KVM) support"
         depends on X86 && EXPERIMENTAL
+        select ANON_INODES
         ---help---
           Support hosting fully virtualized guest machines using hardware
           virtualization extensions.  You will need a fairly recent
diff --git a/drivers/lguest/lguest.c b/drivers/lguest/lguest.c
index 434fea1e82..18dade06d4 100644
--- a/drivers/lguest/lguest.c
+++ b/drivers/lguest/lguest.c
@@ -398,6 +398,8 @@ static void lguest_clockevent_set_mode(enum clock_event_mode mode,
                 break;
         case CLOCK_EVT_MODE_PERIODIC:
                 BUG();
+        case CLOCK_EVT_MODE_RESUME:
+                break;
         }
 }
 
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index ba952a0325..bdc52d6922 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -920,6 +920,8 @@ static void crypt_dtr(struct dm_target *ti)
 {
         struct crypt_config *cc = (struct crypt_config *) ti->private;
 
+        flush_workqueue(_kcryptd_workqueue);
+
         bioset_free(cc->bs);
         mempool_destroy(cc->page_pool);
         mempool_destroy(cc->io_pool);
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 1d516f24ba..aaaa61ea42 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/sony-laptop.c b/drivers/misc/sony-laptop.c
index 9623eaf4f8..303e48ca0e 100644
--- a/drivers/misc/sony-laptop.c
+++ b/drivers/misc/sony-laptop.c
@@ -142,43 +142,124 @@ struct sony_laptop_keypress {
         int key;
 };
 
-/* Correspondance table between sonypi events and input layer events */
-static struct {
-        int sonypiev;
-        int inputev;
-} sony_laptop_inputkeys[] = {
-        { SONYPI_EVENT_CAPTURE_PRESSED,         KEY_CAMERA },
-        { SONYPI_EVENT_FNKEY_ONLY,              KEY_FN },
-        { SONYPI_EVENT_FNKEY_ESC,               KEY_FN_ESC },
-        { SONYPI_EVENT_FNKEY_F1,                KEY_FN_F1 },
-        { SONYPI_EVENT_FNKEY_F2,                KEY_FN_F2 },
-        { SONYPI_EVENT_FNKEY_F3,                KEY_FN_F3 },
-        { SONYPI_EVENT_FNKEY_F4,                KEY_FN_F4 },
-        { SONYPI_EVENT_FNKEY_F5,                KEY_FN_F5 },
-        { SONYPI_EVENT_FNKEY_F6,                KEY_FN_F6 },
-        { SONYPI_EVENT_FNKEY_F7,                KEY_FN_F7 },
-        { SONYPI_EVENT_FNKEY_F8,                KEY_FN_F8 },
-        { SONYPI_EVENT_FNKEY_F9,                KEY_FN_F9 },
-        { SONYPI_EVENT_FNKEY_F10,               KEY_FN_F10 },
-        { SONYPI_EVENT_FNKEY_F11,               KEY_FN_F11 },
-        { SONYPI_EVENT_FNKEY_F12,               KEY_FN_F12 },
-        { SONYPI_EVENT_FNKEY_1,                 KEY_FN_1 },
-        { SONYPI_EVENT_FNKEY_2,                 KEY_FN_2 },
-        { SONYPI_EVENT_FNKEY_D,                 KEY_FN_D },
-        { SONYPI_EVENT_FNKEY_E,                 KEY_FN_E },
-        { SONYPI_EVENT_FNKEY_F,                 KEY_FN_F },
-        { SONYPI_EVENT_FNKEY_S,                 KEY_FN_S },
-        { SONYPI_EVENT_FNKEY_B,                 KEY_FN_B },
-        { SONYPI_EVENT_BLUETOOTH_PRESSED,       KEY_BLUE },
-        { SONYPI_EVENT_BLUETOOTH_ON,            KEY_BLUE },
-        { SONYPI_EVENT_PKEY_P1,                 KEY_PROG1 },
-        { SONYPI_EVENT_PKEY_P2,                 KEY_PROG2 },
-        { SONYPI_EVENT_PKEY_P3,                 KEY_PROG3 },
-        { SONYPI_EVENT_BACK_PRESSED,            KEY_BACK },
-        { SONYPI_EVENT_HELP_PRESSED,            KEY_HELP },
-        { SONYPI_EVENT_ZOOM_PRESSED,            KEY_ZOOM },
-        { SONYPI_EVENT_THUMBPHRASE_PRESSED,     BTN_THUMB },
-        { 0, 0 },
+/* Correspondance table between sonypi events
+ * and input layer indexes in the keymap
+ */
+static int sony_laptop_input_index[] = {
+        -1,     /* no event */
+        -1,     /* SONYPI_EVENT_JOGDIAL_DOWN */
+        -1,     /* SONYPI_EVENT_JOGDIAL_UP */
+        -1,     /* SONYPI_EVENT_JOGDIAL_DOWN_PRESSED */
+        -1,     /* SONYPI_EVENT_JOGDIAL_UP_PRESSED */
+        -1,     /* SONYPI_EVENT_JOGDIAL_PRESSED */
+        -1,     /* SONYPI_EVENT_JOGDIAL_RELEASED */
+         0,     /* SONYPI_EVENT_CAPTURE_PRESSED */
+         1,     /* SONYPI_EVENT_CAPTURE_RELEASED */
+         2,     /* SONYPI_EVENT_CAPTURE_PARTIALPRESSED */
+         3,     /* SONYPI_EVENT_CAPTURE_PARTIALRELEASED */
+         4,     /* SONYPI_EVENT_FNKEY_ESC */
+         5,     /* SONYPI_EVENT_FNKEY_F1 */
+         6,     /* SONYPI_EVENT_FNKEY_F2 */
+         7,     /* SONYPI_EVENT_FNKEY_F3 */
+         8,     /* SONYPI_EVENT_FNKEY_F4 */
+         9,     /* SONYPI_EVENT_FNKEY_F5 */
+        10,     /* SONYPI_EVENT_FNKEY_F6 */
+        11,     /* SONYPI_EVENT_FNKEY_F7 */
+        12,     /* SONYPI_EVENT_FNKEY_F8 */
+        13,     /* SONYPI_EVENT_FNKEY_F9 */
+        14,     /* SONYPI_EVENT_FNKEY_F10 */
+        15,     /* SONYPI_EVENT_FNKEY_F11 */
+        16,     /* SONYPI_EVENT_FNKEY_F12 */
+        17,     /* SONYPI_EVENT_FNKEY_1 */
+        18,     /* SONYPI_EVENT_FNKEY_2 */
+        19,     /* SONYPI_EVENT_FNKEY_D */
+        20,     /* SONYPI_EVENT_FNKEY_E */
+        21,     /* SONYPI_EVENT_FNKEY_F */
+        22,     /* SONYPI_EVENT_FNKEY_S */
+        23,     /* SONYPI_EVENT_FNKEY_B */
+        24,     /* SONYPI_EVENT_BLUETOOTH_PRESSED */
+        25,     /* SONYPI_EVENT_PKEY_P1 */
+        26,     /* SONYPI_EVENT_PKEY_P2 */
+        27,     /* SONYPI_EVENT_PKEY_P3 */
+        28,     /* SONYPI_EVENT_BACK_PRESSED */
+        -1,     /* SONYPI_EVENT_LID_CLOSED */
+        -1,     /* SONYPI_EVENT_LID_OPENED */
+        29,     /* SONYPI_EVENT_BLUETOOTH_ON */
+        30,     /* SONYPI_EVENT_BLUETOOTH_OFF */
+        31,     /* SONYPI_EVENT_HELP_PRESSED */
+        32,     /* SONYPI_EVENT_FNKEY_ONLY */
+        33,     /* SONYPI_EVENT_JOGDIAL_FAST_DOWN */
+        34,     /* SONYPI_EVENT_JOGDIAL_FAST_UP */
+        35,     /* SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED */
+        36,     /* SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED */
+        37,     /* SONYPI_EVENT_JOGDIAL_VFAST_DOWN */
+        38,     /* SONYPI_EVENT_JOGDIAL_VFAST_UP */
+        39,     /* SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED */
+        40,     /* SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED */
+        41,     /* SONYPI_EVENT_ZOOM_PRESSED */
+        42,     /* SONYPI_EVENT_THUMBPHRASE_PRESSED */
+        43,     /* SONYPI_EVENT_MEYE_FACE */
+        44,     /* SONYPI_EVENT_MEYE_OPPOSITE */
+        45,     /* SONYPI_EVENT_MEMORYSTICK_INSERT */
+        46,     /* SONYPI_EVENT_MEMORYSTICK_EJECT */
+        -1,     /* SONYPI_EVENT_ANYBUTTON_RELEASED */
+        -1,     /* SONYPI_EVENT_BATTERY_INSERT */
+        -1,     /* SONYPI_EVENT_BATTERY_REMOVE */
+        -1,     /* SONYPI_EVENT_FNKEY_RELEASED */
+        47,     /* SONYPI_EVENT_WIRELESS_ON */
+        48,     /* SONYPI_EVENT_WIRELESS_OFF */
+};
+
+static int sony_laptop_input_keycode_map[] = {
+        KEY_CAMERA,     /*  0 SONYPI_EVENT_CAPTURE_PRESSED */
+        KEY_RESERVED,   /*  1 SONYPI_EVENT_CAPTURE_RELEASED */
+        KEY_RESERVED,   /*  2 SONYPI_EVENT_CAPTURE_PARTIALPRESSED */
+        KEY_RESERVED,   /*  3 SONYPI_EVENT_CAPTURE_PARTIALRELEASED */
+        KEY_FN_ESC,     /*  4 SONYPI_EVENT_FNKEY_ESC */
+        KEY_FN_F1,      /*  5 SONYPI_EVENT_FNKEY_F1 */
+        KEY_FN_F2,      /*  6 SONYPI_EVENT_FNKEY_F2 */
+        KEY_FN_F3,      /*  7 SONYPI_EVENT_FNKEY_F3 */
+        KEY_FN_F4,      /*  8 SONYPI_EVENT_FNKEY_F4 */
+        KEY_FN_F5,      /*  9 SONYPI_EVENT_FNKEY_F5 */
+        KEY_FN_F6,      /* 10 SONYPI_EVENT_FNKEY_F6 */
+        KEY_FN_F7,      /* 11 SONYPI_EVENT_FNKEY_F7 */
+        KEY_FN_F8,      /* 12 SONYPI_EVENT_FNKEY_F8 */
+        KEY_FN_F9,      /* 13 SONYPI_EVENT_FNKEY_F9 */
+        KEY_FN_F10,     /* 14 SONYPI_EVENT_FNKEY_F10 */
+        KEY_FN_F11,     /* 15 SONYPI_EVENT_FNKEY_F11 */
+        KEY_FN_F12,     /* 16 SONYPI_EVENT_FNKEY_F12 */
+        KEY_FN_F1,      /* 17 SONYPI_EVENT_FNKEY_1 */
+        KEY_FN_F2,      /* 18 SONYPI_EVENT_FNKEY_2 */
+        KEY_FN_D,       /* 19 SONYPI_EVENT_FNKEY_D */
+        KEY_FN_E,       /* 20 SONYPI_EVENT_FNKEY_E */
+        KEY_FN_F,       /* 21 SONYPI_EVENT_FNKEY_F */
+        KEY_FN_S,       /* 22 SONYPI_EVENT_FNKEY_S */
+        KEY_FN_B,       /* 23 SONYPI_EVENT_FNKEY_B */
+        KEY_BLUETOOTH,  /* 24 SONYPI_EVENT_BLUETOOTH_PRESSED */
+        KEY_PROG1,      /* 25 SONYPI_EVENT_PKEY_P1 */
+        KEY_PROG2,      /* 26 SONYPI_EVENT_PKEY_P2 */
+        KEY_PROG3,      /* 27 SONYPI_EVENT_PKEY_P3 */
+        KEY_BACK,       /* 28 SONYPI_EVENT_BACK_PRESSED */
+        KEY_BLUETOOTH,  /* 29 SONYPI_EVENT_BLUETOOTH_ON */
+        KEY_BLUETOOTH,  /* 30 SONYPI_EVENT_BLUETOOTH_OFF */
+        KEY_HELP,       /* 31 SONYPI_EVENT_HELP_PRESSED */
+        KEY_FN,         /* 32 SONYPI_EVENT_FNKEY_ONLY */
+        KEY_RESERVED,   /* 33 SONYPI_EVENT_JOGDIAL_FAST_DOWN */
+        KEY_RESERVED,   /* 34 SONYPI_EVENT_JOGDIAL_FAST_UP */
+        KEY_RESERVED,   /* 35 SONYPI_EVENT_JOGDIAL_FAST_DOWN_PRESSED */
+        KEY_RESERVED,   /* 36 SONYPI_EVENT_JOGDIAL_FAST_UP_PRESSED */
+        KEY_RESERVED,   /* 37 SONYPI_EVENT_JOGDIAL_VFAST_DOWN */
+        KEY_RESERVED,   /* 38 SONYPI_EVENT_JOGDIAL_VFAST_UP */
+        KEY_RESERVED,   /* 39 SONYPI_EVENT_JOGDIAL_VFAST_DOWN_PRESSED */
+        KEY_RESERVED,   /* 40 SONYPI_EVENT_JOGDIAL_VFAST_UP_PRESSED */
+        KEY_ZOOM,       /* 41 SONYPI_EVENT_ZOOM_PRESSED */
+        BTN_THUMB,      /* 42 SONYPI_EVENT_THUMBPHRASE_PRESSED */
+        KEY_RESERVED,   /* 43 SONYPI_EVENT_MEYE_FACE */
+        KEY_RESERVED,   /* 44 SONYPI_EVENT_MEYE_OPPOSITE */
+        KEY_RESERVED,   /* 45 SONYPI_EVENT_MEMORYSTICK_INSERT */
+        KEY_RESERVED,   /* 46 SONYPI_EVENT_MEMORYSTICK_EJECT */
+        KEY_WLAN,       /* 47 SONYPI_EVENT_WIRELESS_ON */
+        KEY_WLAN,       /* 48 SONYPI_EVENT_WIRELESS_OFF */
 };
 
 /* release buttons after a short delay if pressed */
@@ -202,7 +283,6 @@ static void sony_laptop_report_input_event(u8 event)
         struct input_dev *jog_dev = sony_laptop_input.jog_dev;
         struct input_dev *key_dev = sony_laptop_input.key_dev;
         struct sony_laptop_keypress kp = { NULL };
-        int i;
 
         if (event == SONYPI_EVENT_FNKEY_RELEASED) {
                 /* Nothing, not all VAIOs generate this event */
@@ -231,17 +311,22 @@ static void sony_laptop_report_input_event(u8 event)
                 break;
 
         default:
-                for (i = 0; sony_laptop_inputkeys[i].sonypiev; i++)
-                        if (event == sony_laptop_inputkeys[i].sonypiev) {
+                if (event > ARRAY_SIZE (sony_laptop_input_keycode_map)) {
+                        dprintk("sony_laptop_report_input_event, event not known: %d\n", event);
+                        break;
+                }
+                if (sony_laptop_input_index[event] != -1) {
+                        kp.key = sony_laptop_input_keycode_map[sony_laptop_input_index[event]];
+                        if (kp.key != KEY_UNKNOWN)
                                 kp.dev = key_dev;
-                                kp.key = sony_laptop_inputkeys[i].inputev;
-                                break;
-                        }
+                }
                 break;
         }
 
         if (kp.dev) {
                 input_report_key(kp.dev, kp.key, 1);
+                /* we emit the scancode so we can always remap the key */
+                input_event(kp.dev, EV_MSC, MSC_SCAN, event);
                 input_sync(kp.dev);
                 kfifo_put(sony_laptop_input.fifo,
                           (unsigned char *)&kp, sizeof(kp));
@@ -296,11 +381,18 @@ static int sony_laptop_setup_input(void)
         key_dev->id.vendor = PCI_VENDOR_ID_SONY;
 
         /* Initialize the Input Drivers: special keys */
-        key_dev->evbit[0] = BIT(EV_KEY);
-        for (i = 0; sony_laptop_inputkeys[i].sonypiev; i++)
-                if (sony_laptop_inputkeys[i].inputev)
-                        set_bit(sony_laptop_inputkeys[i].inputev,
-                                        key_dev->keybit);
+        set_bit(EV_KEY, key_dev->evbit);
+        set_bit(EV_MSC, key_dev->evbit);
+        set_bit(MSC_SCAN, key_dev->mscbit);
+        key_dev->keycodesize = sizeof(sony_laptop_input_keycode_map[0]);
+        key_dev->keycodemax = ARRAY_SIZE(sony_laptop_input_keycode_map);
+        key_dev->keycode = &sony_laptop_input_keycode_map;
+        for (i = 0; i < ARRAY_SIZE(sony_laptop_input_keycode_map); i++) {
+                if (sony_laptop_input_keycode_map[i] != KEY_RESERVED) {
+                        set_bit(sony_laptop_input_keycode_map[i],
+                                key_dev->keybit);
+                }
+        }
 
         error = input_register_device(key_dev);
         if (error)
@@ -487,6 +579,14 @@ SNC_HANDLE_NAMES(audiopower_set, "AZPW");
 SNC_HANDLE_NAMES(lanpower_get, "GLNP");
 SNC_HANDLE_NAMES(lanpower_set, "LNPW");
 
+SNC_HANDLE_NAMES(lidstate_get, "GLID");
+
+SNC_HANDLE_NAMES(indicatorlamp_get, "GILS");
+SNC_HANDLE_NAMES(indicatorlamp_set, "SILS");
+
+SNC_HANDLE_NAMES(gainbass_get, "GMGB");
+SNC_HANDLE_NAMES(gainbass_set, "CMGB");
+
 SNC_HANDLE_NAMES(PID_get, "GPID");
 
 SNC_HANDLE_NAMES(CTR_get, "GCTR");
@@ -507,6 +607,12 @@ static struct sony_nc_value sony_nc_values[] = {
                         boolean_validate, 0),
         SNC_HANDLE(lanpower, snc_lanpower_get, snc_lanpower_set,
                         boolean_validate, 1),
+        SNC_HANDLE(lidstate, snc_lidstate_get, NULL,
+                        boolean_validate, 0),
+        SNC_HANDLE(indicatorlamp, snc_indicatorlamp_get, snc_indicatorlamp_set,
+                        boolean_validate, 0),
+        SNC_HANDLE(gainbass, snc_gainbass_get, snc_gainbass_set,
+                        boolean_validate, 0),
         /* unknown methods */
         SNC_HANDLE(PID, snc_PID_get, NULL, NULL, 1),
         SNC_HANDLE(CTR, snc_CTR_get, snc_CTR_set, NULL, 1),
@@ -689,13 +795,116 @@ static struct backlight_ops sony_backlight_ops = {
 };
 
 /*
+ * New SNC-only Vaios event mapping to driver known keys
+ */
+struct sony_nc_event {
+        u8      data;
+        u8      event;
+};
+
+static struct sony_nc_event *sony_nc_events;
+
+/* Vaio C* --maybe also FE*, N* and AR* ?-- special init sequence
+ * for Fn keys
+ */
+static int sony_nc_C_enable(struct dmi_system_id *id)
+{
+        int result = 0;
+
+        printk(KERN_NOTICE DRV_PFX "detected %s\n", id->ident);
+
+        sony_nc_events = id->driver_data;
+
+        if (acpi_callsetfunc(sony_nc_acpi_handle, "SN02", 0x4, &result) < 0
+                        || acpi_callsetfunc(sony_nc_acpi_handle, "SN07", 0x2, &result) < 0
+                        || acpi_callsetfunc(sony_nc_acpi_handle, "SN02", 0x10, &result) < 0
+                        || acpi_callsetfunc(sony_nc_acpi_handle, "SN07", 0x0, &result) < 0
+                        || acpi_callsetfunc(sony_nc_acpi_handle, "SN03", 0x2, &result) < 0
+                        || acpi_callsetfunc(sony_nc_acpi_handle, "SN07", 0x101, &result) < 0) {
+                printk(KERN_WARNING DRV_PFX "failed to initialize SNC, some "
+                                "functionalities may be missing\n");
+                return 1;
+        }
+        return 0;
+}
+
+static struct sony_nc_event sony_C_events[] = {
+        { 0x81, SONYPI_EVENT_FNKEY_F1 },
+        { 0x01, SONYPI_EVENT_FNKEY_RELEASED },
+        { 0x85, SONYPI_EVENT_FNKEY_F5 },
+        { 0x05, SONYPI_EVENT_FNKEY_RELEASED },
+        { 0x86, SONYPI_EVENT_FNKEY_F6 },
+        { 0x06, SONYPI_EVENT_FNKEY_RELEASED },
+        { 0x87, SONYPI_EVENT_FNKEY_F7 },
+        { 0x07, SONYPI_EVENT_FNKEY_RELEASED },
+        { 0x8A, SONYPI_EVENT_FNKEY_F10 },
+        { 0x0A, SONYPI_EVENT_FNKEY_RELEASED },
+        { 0x8C, SONYPI_EVENT_FNKEY_F12 },
+        { 0x0C, SONYPI_EVENT_FNKEY_RELEASED },
+        { 0, 0 },
+};
+
+/* SNC-only model map */
+struct dmi_system_id sony_nc_ids[] = {
+                {
+                        .ident = "Sony Vaio FE Series",
+                        .callback = sony_nc_C_enable,
+                        .driver_data = sony_C_events,
+                        .matches = {
+                                DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
+                                DMI_MATCH(DMI_PRODUCT_NAME, "VGN-FE"),
+                        },
+                },
+                {
+                        .ident = "Sony Vaio C Series",
+                        .callback = sony_nc_C_enable,
+                        .driver_data = sony_C_events,
+                        .matches = {
+                                DMI_MATCH(DMI_SYS_VENDOR, "Sony Corporation"),
+                                DMI_MATCH(DMI_PRODUCT_NAME, "VGN-C"),
+                        },
+                },
+                { }
+};
+
+/*
  * ACPI callbacks
  */
 static void sony_acpi_notify(acpi_handle handle, u32 event, void *data)
 {
-        dprintk("sony_acpi_notify, event: %d\n", event);
-        sony_laptop_report_input_event(event);
-        acpi_bus_generate_event(sony_nc_acpi_device, 1, event);
+        struct sony_nc_event *evmap;
+        u32 ev = event;
+        int result;
+
+        if (ev == 0x92) {
+                /* read the key pressed from EC.GECR
+                 * A call to SN07 with 0x0202 will do it as well respecting
+                 * the current protocol on different OSes
+                 *
+                 * Note: the path for GECR may be
+                 *   \_SB.PCI0.LPCB.EC (C, FE, AR, N and friends)
+                 *   \_SB.PCI0.PIB.EC0 (VGN-FR notifications are sent directly, no GECR)
+                 *
+                 * TODO: we may want to do the same for the older GHKE -need
+                 *       dmi list- so this snippet may become one more callback.
+                 */
+                if (acpi_callsetfunc(handle, "SN07", 0x0202, &result) < 0)
+                        dprintk("sony_acpi_notify, unable to decode event 0x%.2x\n", ev);
+                else
+                        ev = result & 0xFF;
+        }
+
+        if (sony_nc_events)
+                for (evmap = sony_nc_events; evmap->event; evmap++) {
+                        if (evmap->data == ev) {
+                                ev = evmap->event;
+                                break;
+                        }
+                }
+
+        dprintk("sony_acpi_notify, event: 0x%.2x\n", ev);
+        sony_laptop_report_input_event(ev);
+        acpi_bus_generate_event(sony_nc_acpi_device, 1, ev);
 }
 
 static acpi_status sony_walk_callback(acpi_handle handle, u32 level,
@@ -732,6 +941,10 @@ static int sony_nc_resume(struct acpi_device *device)
                         break;
                 }
         }
+
+        /* re-initialize models with specific requirements */
+        dmi_check_system(sony_nc_ids);
+
         return 0;
 }
 
@@ -750,6 +963,15 @@ static int sony_nc_add(struct acpi_device *device)
 
         sony_nc_acpi_handle = device->handle;
 
+        /* read device status */
+        result = acpi_bus_get_status(device);
+        /* bail IFF the above call was successful and the device is not present */
+        if (!result && !device->status.present) {
+                dprintk("Device not present\n");
+                result = -ENODEV;
+                goto outwalk;
+        }
+
         if (debug) {
                 status = acpi_walk_namespace(ACPI_TYPE_METHOD, sony_nc_acpi_handle,
                                              1, sony_walk_callback, NULL, NULL);
@@ -760,6 +982,15 @@ static int sony_nc_add(struct acpi_device *device)
                 }
         }
 
+        /* try to _INI the device if such method exists (ACPI spec 3.0-6.5.1
+         * should be respected as we already checked for the device presence above */
+        if (ACPI_SUCCESS(acpi_get_handle(sony_nc_acpi_handle, METHOD_NAME__INI, &handle))) {
+                dprintk("Invoking _INI\n");
+                if (ACPI_FAILURE(acpi_evaluate_object(sony_nc_acpi_handle, METHOD_NAME__INI,
+                                                NULL, NULL)))
+                        dprintk("_INI Method failed\n");
+        }
+
         /* setup input devices and helper fifo */
         result = sony_laptop_setup_input();
         if (result) {
@@ -772,7 +1003,7 @@ static int sony_nc_add(struct acpi_device *device)
                                              ACPI_DEVICE_NOTIFY,
                                              sony_acpi_notify, NULL);
         if (ACPI_FAILURE(status)) {
-                printk(KERN_WARNING DRV_PFX "unable to install notify handler\n");
+                printk(KERN_WARNING DRV_PFX "unable to install notify handler (%u)\n", status);
                 result = -ENODEV;
                 goto outinput;
         }
@@ -795,6 +1026,9 @@ static int sony_nc_add(struct acpi_device *device)
 
         }
 
+        /* initialize models with specific requirements */
+        dmi_check_system(sony_nc_ids);
+
         result = sony_pf_add();
         if (result)
                 goto outbacklight;
@@ -908,7 +1142,9 @@ static struct acpi_driver sony_nc_driver = {
 #define SONYPI_DEVICE_TYPE2     0x00000002
 #define SONYPI_DEVICE_TYPE3     0x00000004
 
-#define SONY_PIC_EV_MASK        0xff
+#define SONYPI_TYPE1_OFFSET     0x04
+#define SONYPI_TYPE2_OFFSET     0x12
+#define SONYPI_TYPE3_OFFSET     0x12
 
 struct sony_pic_ioport {
         struct acpi_resource_io io;
@@ -922,6 +1158,7 @@ struct sony_pic_irq {
 
 struct sony_pic_dev {
         int                     model;
+        u16                     evport_offset;
         u8                      camera_power;
         u8                      bluetooth_power;
         u8                      wwan_power;
@@ -1999,20 +2236,17 @@ end:
 static irqreturn_t sony_pic_irq(int irq, void *dev_id)
 {
         int i, j;
-        u32 port_val = 0;
         u8 ev = 0;
         u8 data_mask = 0;
         u8 device_event = 0;
 
         struct sony_pic_dev *dev = (struct sony_pic_dev *) dev_id;
 
-        acpi_os_read_port(dev->cur_ioport->io.minimum, &port_val,
-                        dev->cur_ioport->io.address_length);
-        ev = port_val & SONY_PIC_EV_MASK;
-        data_mask = 0xff & (port_val >> (dev->cur_ioport->io.address_length - 8));
+        ev = inb_p(dev->cur_ioport->io.minimum);
+        data_mask = inb_p(dev->cur_ioport->io.minimum + dev->evport_offset);
 
-        dprintk("event (0x%.8x [%.2x] [%.2x]) at port 0x%.4x\n",
-                        port_val, ev, data_mask, dev->cur_ioport->io.minimum);
+        dprintk("event ([%.2x] [%.2x]) at port 0x%.4x(+0x%.2x)\n",
+                        ev, data_mask, dev->cur_ioport->io.minimum, dev->evport_offset);
 
         if (ev == 0x00 || ev == 0xff)
                 return IRQ_HANDLED;
@@ -2103,6 +2337,20 @@ static int sony_pic_add(struct acpi_device *device)
         spic_dev.model = sony_pic_detect_device_type();
         mutex_init(&spic_dev.lock);
 
+        /* model specific characteristics */
+        switch(spic_dev.model) {
+                case SONYPI_DEVICE_TYPE1:
+                        spic_dev.evport_offset = SONYPI_TYPE1_OFFSET;
+                        break;
+                case SONYPI_DEVICE_TYPE3:
+                        spic_dev.evport_offset = SONYPI_TYPE3_OFFSET;
+                        break;
+                case SONYPI_DEVICE_TYPE2:
+                default:
+                        spic_dev.evport_offset = SONYPI_TYPE2_OFFSET;
+                        break;
+        }
+
         /* read _PRS resources */
         result = sony_pic_possible_resources(device);
         if (result) {
diff --git a/drivers/misc/thinkpad_acpi.c b/drivers/misc/thinkpad_acpi.c
index 95c0b96e83..f15a58f740 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 72d62f2dab..b7a4a888cc 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/drivers/net/Kconfig b/drivers/net/Kconfig
index 3073f67958..f8a602caab 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -5,6 +5,7 @@
 
 menuconfig NETDEVICES
         default y if UML
+        depends on NET
         bool "Network device support"
         ---help---
           You can say N here if you don't intend to connect your Linux box to
diff --git a/drivers/net/irda/Kconfig b/drivers/net/irda/Kconfig
index 829da9a1d1..2098d0af8f 100644
--- a/drivers/net/irda/Kconfig
+++ b/drivers/net/irda/Kconfig
@@ -155,6 +155,15 @@ config KINGSUN_DONGLE
           To compile it as a module, choose M here: the module will be called
           kingsun-sir.
 
+config EP7211_DONGLE
+        tristate "EP7211 I/R support"
+        depends on IRTTY_SIR && ARCH_EP7211 && IRDA && EXPERIMENTAL
+        help
+          Say Y here if you want to build support for the Cirrus logic
+          EP7211 chipset's infrared module.
+
+
+
 comment "Old SIR device drivers"
 
 config IRPORT_SIR
@@ -355,7 +364,7 @@ config WINBOND_FIR
 
 config TOSHIBA_FIR
         tristate "Toshiba Type-O IR Port"
-        depends on IRDA && PCI && !64BIT
+        depends on IRDA && PCI && !64BIT && VIRT_TO_BUS
         help
           Say Y here if you want to build support for the Toshiba Type-O IR
           and Donau oboe chipsets. These chipsets are used by the Toshiba
diff --git a/drivers/net/irda/Makefile b/drivers/net/irda/Makefile
index 233a2f9237..2808ef5c7b 100644
--- a/drivers/net/irda/Makefile
+++ b/drivers/net/irda/Makefile
@@ -45,6 +45,7 @@ obj-$(CONFIG_MCP2120_DONGLE)	+= mcp2120-sir.o
 obj-$(CONFIG_ACT200L_DONGLE)    += act200l-sir.o
 obj-$(CONFIG_MA600_DONGLE)      += ma600-sir.o
 obj-$(CONFIG_TOIM3232_DONGLE)   += toim3232-sir.o
+obj-$(CONFIG_EP7211_DONGLE)     += ep7211-sir.o
 obj-$(CONFIG_KINGSUN_DONGLE)    += kingsun-sir.o
 
 # The SIR helper module
diff --git a/drivers/net/irda/ep7211-sir.c b/drivers/net/irda/ep7211-sir.c
new file mode 100644
index 0000000000..831572429b
--- /dev/null
+++ b/drivers/net/irda/ep7211-sir.c
@@ -0,0 +1,89 @@
+/*
+ * IR port driver for the Cirrus Logic EP7211 processor.
+ *
+ * Copyright 2001, Blue Mug Inc.  All rights reserved.
+ * Copyright 2007, Samuel Ortiz <samuel@sortiz.org>
+ */
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/tty.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+
+#include <net/irda/irda.h>
+#include <net/irda/irda_device.h>
+
+#include <asm/io.h>
+#include <asm/hardware.h>
+
+#include "sir-dev.h"
+
+#define MIN_DELAY 25      /* 15 us, but wait a little more to be sure */
+#define MAX_DELAY 10000   /* 1 ms */
+
+static int ep7211_open(struct sir_dev *dev);
+static int ep7211_close(struct sir_dev *dev);
+static int ep7211_change_speed(struct sir_dev *dev, unsigned speed);
+static int ep7211_reset(struct sir_dev *dev);
+
+static struct dongle_driver ep7211 = {
+        .owner          = THIS_MODULE,
+        .driver_name    = "EP7211 IR driver",
+        .type           = IRDA_EP7211_DONGLE,
+        .open           = ep7211_open,
+        .close          = ep7211_close,
+        .reset          = ep7211_reset,
+        .set_speed      = ep7211_change_speed,
+};
+
+static int __init ep7211_sir_init(void)
+{
+        return irda_register_dongle(&ep7211);
+}
+
+static void __exit ep7211_sir_cleanup(void)
+{
+        irda_unregister_dongle(&ep7211);
+}
+
+static int ep7211_open(struct sir_dev *dev)
+{
+        unsigned int syscon;
+
+        /* Turn on the SIR encoder. */
+        syscon = clps_readl(SYSCON1);
+        syscon |= SYSCON1_SIREN;
+        clps_writel(syscon, SYSCON1);
+
+        return 0;
+}
+
+static int ep7211_close(struct sir_dev *dev)
+{
+        unsigned int syscon;
+
+        /* Turn off the SIR encoder. */
+        syscon = clps_readl(SYSCON1);
+        syscon &= ~SYSCON1_SIREN;
+        clps_writel(syscon, SYSCON1);
+
+        return 0;
+}
+
+static int ep7211_change_speed(struct sir_dev *dev, unsigned speed)
+{
+        return 0;
+}
+
+static int ep7211_reset(struct sir_dev *dev)
+{
+        return 0;
+}
+
+MODULE_AUTHOR("Samuel Ortiz <samuel@sortiz.org>");
+MODULE_DESCRIPTION("EP7211 IR dongle driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("irda-dongle-13"); /* IRDA_EP7211_DONGLE */
+
+module_init(ep7211_sir_init);
+module_exit(ep7211_sir_cleanup);
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 35f34665e3..9d8d40d5c8 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -38,6 +38,9 @@ config RTC_HCTOSYS_DEVICE
           clock, usually rtc0.  Initialization is done when the system
           starts up, and when it resumes from a low power state.
 
+          The driver for this RTC device must be loaded before late_initcall
+          functions run, so it must usually be statically linked.
+
           This clock should be battery-backed, so that it reads the correct
           time when the system boots from a power-off state.  Otherwise, your
           system will need an external clock source (like an NTP server).
@@ -305,6 +308,16 @@ config RTC_DRV_DS1553
           This driver can also be built as a module. If so, the module
           will be called rtc-ds1553.
 
+config RTC_DRV_STK17TA8
+        tristate "Simtek STK17TA8"
+        depends on RTC_CLASS
+        help
+          If you say yes here you get support for the
+          Simtek STK17TA8 timekeeping chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-stk17ta8.
+
 config RTC_DRV_DS1742
         tristate "Dallas DS1742/1743"
         depends on RTC_CLASS
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 3109af9a16..7ede9e7253 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -32,6 +32,7 @@ obj-$(CONFIG_RTC_DRV_RS5C348)	+= rtc-rs5c348.o
 obj-$(CONFIG_RTC_DRV_M41T80)    += rtc-m41t80.o
 obj-$(CONFIG_RTC_DRV_M48T86)    += rtc-m48t86.o
 obj-$(CONFIG_RTC_DRV_DS1553)    += rtc-ds1553.o
+obj-$(CONFIG_RTC_DRV_STK17TA8)  += rtc-stk17ta8.o
 obj-$(CONFIG_RTC_DRV_RS5C313)   += rtc-rs5c313.o
 obj-$(CONFIG_RTC_DRV_EP93XX)    += rtc-ep93xx.o
 obj-$(CONFIG_RTC_DRV_SA1100)    += rtc-sa1100.o
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index f98a83a11a..46da571493 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -407,7 +407,7 @@ static __init int ds1553_init(void)
 
 static __exit void ds1553_exit(void)
 {
-        return platform_driver_unregister(&ds1553_rtc_driver);
+        platform_driver_unregister(&ds1553_rtc_driver);
 }
 
 module_init(ds1553_init);
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index d1778ae8bc..b2e5481ba3 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -263,7 +263,7 @@ static __init int ds1742_init(void)
 
 static __exit void ds1742_exit(void)
 {
-        return platform_driver_unregister(&ds1742_rtc_driver);
+        platform_driver_unregister(&ds1742_rtc_driver);
 }
 
 module_init(ds1742_init);
diff --git a/drivers/rtc/rtc-max6900.c b/drivers/rtc/rtc-max6900.c
index eee4ee5bb7..a1cd448639 100644
--- a/drivers/rtc/rtc-max6900.c
+++ b/drivers/rtc/rtc-max6900.c
@@ -31,17 +31,24 @@
 #define MAX6900_REG_DW                  5       /* day of week   1-7  */
 #define MAX6900_REG_YR                  6       /* year         00-99 */
 #define MAX6900_REG_CT                  7       /* control */
-#define MAX6900_REG_LEN                 8
+                                                /* register 8 is undocumented */
+#define MAX6900_REG_CENTURY             9       /* century */
+#define MAX6900_REG_LEN                 10
+
+#define MAX6900_BURST_LEN               8       /* can burst r/w first 8 regs */
 
 #define MAX6900_REG_CT_WP               (1 << 7)        /* Write Protect */
 
+
 /*
  * register read/write commands
  */
 #define MAX6900_REG_CONTROL_WRITE       0x8e
-#define MAX6900_REG_BURST_READ          0xbf
-#define MAX6900_REG_BURST_WRITE         0xbe
+#define MAX6900_REG_CENTURY_WRITE       0x92
+#define MAX6900_REG_CENTURY_READ        0x93
 #define MAX6900_REG_RESERVED_READ       0x96
+#define MAX6900_REG_BURST_WRITE         0xbe
+#define MAX6900_REG_BURST_READ          0xbf
 
 #define MAX6900_IDLE_TIME_AFTER_WRITE   3       /* specification says 2.5 mS */
 
@@ -58,19 +65,32 @@ static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind);
 
 static int max6900_i2c_read_regs(struct i2c_client *client, u8 *buf)
 {
-        u8 reg_addr[1] = { MAX6900_REG_BURST_READ };
-        struct i2c_msg msgs[2] = {
+        u8 reg_burst_read[1] = { MAX6900_REG_BURST_READ };
+        u8 reg_century_read[1] = { MAX6900_REG_CENTURY_READ };
+        struct i2c_msg msgs[4] = {
                 {
                         .addr   = client->addr,
                         .flags  = 0, /* write */
-                        .len    = sizeof(reg_addr),
-                        .buf    = reg_addr
+                        .len    = sizeof(reg_burst_read),
+                        .buf    = reg_burst_read
                 },
                 {
                         .addr   = client->addr,
                         .flags  = I2C_M_RD,
-                        .len    = MAX6900_REG_LEN,
+                        .len    = MAX6900_BURST_LEN,
                         .buf    = buf
+                },
+                {
+                        .addr   = client->addr,
+                        .flags  = 0, /* write */
+                        .len    = sizeof(reg_century_read),
+                        .buf    = reg_century_read
+                },
+                {
+                        .addr   = client->addr,
+                        .flags  = I2C_M_RD,
+                        .len    = sizeof(buf[MAX6900_REG_CENTURY]),
+                        .buf    = &buf[MAX6900_REG_CENTURY]
                 }
         };
         int rc;
@@ -86,33 +106,58 @@ static int max6900_i2c_read_regs(struct i2c_client *client, u8 *buf)
 
 static int max6900_i2c_write_regs(struct i2c_client *client, u8 const *buf)
 {
-        u8 i2c_buf[MAX6900_REG_LEN + 1] = { MAX6900_REG_BURST_WRITE };
-        struct i2c_msg msgs[1] = {
+        u8 i2c_century_buf[1 + 1] = { MAX6900_REG_CENTURY_WRITE };
+        struct i2c_msg century_msgs[1] = {
                 {
                         .addr   = client->addr,
                         .flags  = 0, /* write */
-                        .len    = MAX6900_REG_LEN + 1,
-                        .buf    = i2c_buf
+                        .len    = sizeof(i2c_century_buf),
+                        .buf    = i2c_century_buf
+                }
+        };
+        u8 i2c_burst_buf[MAX6900_BURST_LEN + 1] = { MAX6900_REG_BURST_WRITE };
+        struct i2c_msg burst_msgs[1] = {
+                {
+                        .addr   = client->addr,
+                        .flags  = 0, /* write */
+                        .len    = sizeof(i2c_burst_buf),
+                        .buf    = i2c_burst_buf
                 }
         };
         int rc;
 
-        memcpy(&i2c_buf[1], buf, MAX6900_REG_LEN);
+        /*
+         * We have to make separate calls to i2c_transfer because of
+         * the need to delay after each write to the chip.  Also,
+         * we write the century byte first, since we set the write-protect
+         * bit as part of the burst write.
+         */
+        i2c_century_buf[1] = buf[MAX6900_REG_CENTURY];
+        rc = i2c_transfer(client->adapter, century_msgs,
+                          ARRAY_SIZE(century_msgs));
+        if (rc != ARRAY_SIZE(century_msgs))
+                goto write_failed;
+        msleep(MAX6900_IDLE_TIME_AFTER_WRITE);
 
-        rc = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-        if (rc != ARRAY_SIZE(msgs)) {
-                dev_err(&client->dev, "%s: register write failed\n",
-                        __FUNCTION__);
-                return -EIO;
-        }
+        memcpy(&i2c_burst_buf[1], buf, MAX6900_BURST_LEN);
+
+        rc = i2c_transfer(client->adapter, burst_msgs, ARRAY_SIZE(burst_msgs));
+        if (rc != ARRAY_SIZE(burst_msgs))
+                goto write_failed;
         msleep(MAX6900_IDLE_TIME_AFTER_WRITE);
+
         return 0;
+
+write_failed:
+        dev_err(&client->dev, "%s: register write failed\n",
+                __FUNCTION__);
+        return -EIO;
 }
 
 static int max6900_i2c_validate_client(struct i2c_client *client)
 {
         u8 regs[MAX6900_REG_LEN];
-        u8 zero_mask[MAX6900_REG_LEN] = {
+        u8 zero_mask[] = {
                 0x80,   /* seconds */
                 0x80,   /* minutes */
                 0x40,   /* hours */
@@ -134,7 +179,7 @@ static int max6900_i2c_validate_client(struct i2c_client *client)
         if (rc < 0)
                 return rc;
 
-        for (i = 0; i < MAX6900_REG_LEN; ++i) {
+        for (i = 0; i < ARRAY_SIZE(zero_mask); ++i) {
                 if (regs[i] & zero_mask[i])
                         return -ENODEV;
         }
@@ -156,7 +201,8 @@ static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
         tm->tm_hour = BCD2BIN(regs[MAX6900_REG_HR] & 0x3f);
         tm->tm_mday = BCD2BIN(regs[MAX6900_REG_DT]);
         tm->tm_mon = BCD2BIN(regs[MAX6900_REG_MO]) - 1;
-        tm->tm_year = BCD2BIN(regs[MAX6900_REG_YR]) + 100;
+        tm->tm_year = BCD2BIN(regs[MAX6900_REG_YR]) +
+                      BCD2BIN(regs[MAX6900_REG_CENTURY]) * 100 - 1900;
         tm->tm_wday = BCD2BIN(regs[MAX6900_REG_DW]);
 
         return 0;
@@ -189,9 +235,11 @@ static int max6900_i2c_set_time(struct i2c_client *client,
         regs[MAX6900_REG_HR] = BIN2BCD(tm->tm_hour);
         regs[MAX6900_REG_DT] = BIN2BCD(tm->tm_mday);
         regs[MAX6900_REG_MO] = BIN2BCD(tm->tm_mon + 1);
-        regs[MAX6900_REG_YR] = BIN2BCD(tm->tm_year - 100);
         regs[MAX6900_REG_DW] = BIN2BCD(tm->tm_wday);
-        regs[MAX6900_REG_CT] = MAX6900_REG_CT_WP;       /* set write protect */
+        regs[MAX6900_REG_YR] = BIN2BCD(tm->tm_year % 100);
+        regs[MAX6900_REG_CENTURY] = BIN2BCD((tm->tm_year + 1900) / 100);
+        /* set write protect */
+        regs[MAX6900_REG_CT] = MAX6900_REG_CT_WP;
 
         rc = max6900_i2c_write_regs(client, regs);
         if (rc < 0)
diff --git a/drivers/rtc/rtc-stk17ta8.c b/drivers/rtc/rtc-stk17ta8.c
new file mode 100644
index 0000000000..f10d3facec
--- /dev/null
+++ b/drivers/rtc/rtc-stk17ta8.c
@@ -0,0 +1,420 @@
+/*
+ * A RTC driver for the Simtek STK17TA8
+ *
+ * By Thomas Hommel <thomas.hommel@gefanuc.com>
+ *
+ * Based on the DS1553 driver from
+ * Atsushi Nemoto <anemo@mba.ocn.ne.jp>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/bcd.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/jiffies.h>
+#include <linux/interrupt.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+
+#define DRV_VERSION "0.1"
+
+#define RTC_REG_SIZE            0x20000
+#define RTC_OFFSET              0x1fff0
+
+#define RTC_FLAGS               (RTC_OFFSET + 0)
+#define RTC_CENTURY             (RTC_OFFSET + 1)
+#define RTC_SECONDS_ALARM       (RTC_OFFSET + 2)
+#define RTC_MINUTES_ALARM       (RTC_OFFSET + 3)
+#define RTC_HOURS_ALARM         (RTC_OFFSET + 4)
+#define RTC_DATE_ALARM          (RTC_OFFSET + 5)
+#define RTC_INTERRUPTS          (RTC_OFFSET + 6)
+#define RTC_WATCHDOG            (RTC_OFFSET + 7)
+#define RTC_CALIBRATION         (RTC_OFFSET + 8)
+#define RTC_SECONDS             (RTC_OFFSET + 9)
+#define RTC_MINUTES             (RTC_OFFSET + 10)
+#define RTC_HOURS               (RTC_OFFSET + 11)
+#define RTC_DAY                 (RTC_OFFSET + 12)
+#define RTC_DATE                (RTC_OFFSET + 13)
+#define RTC_MONTH               (RTC_OFFSET + 14)
+#define RTC_YEAR                (RTC_OFFSET + 15)
+
+#define RTC_SECONDS_MASK        0x7f
+#define RTC_DAY_MASK            0x07
+#define RTC_CAL_MASK            0x3f
+
+/* Bits in the Calibration register */
+#define RTC_STOP                0x80
+
+/* Bits in the Flags register */
+#define RTC_FLAGS_AF            0x40
+#define RTC_FLAGS_PF            0x20
+#define RTC_WRITE               0x02
+#define RTC_READ                0x01
+
+/* Bits in the Interrupts register */
+#define RTC_INTS_AIE            0x40
+
+struct rtc_plat_data {
+        struct rtc_device *rtc;
+        void __iomem *ioaddr;
+        unsigned long baseaddr;
+        unsigned long last_jiffies;
+        int irq;
+        unsigned int irqen;
+        int alrm_sec;
+        int alrm_min;
+        int alrm_hour;
+        int alrm_mday;
+};
+
+static int stk17ta8_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        u8 flags;
+
+        flags = readb(pdata->ioaddr + RTC_FLAGS);
+        writeb(flags | RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
+
+        writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
+        writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
+        writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
+        writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
+        writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
+        writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
+        writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
+        writeb(BIN2BCD((tm->tm_year + 1900) / 100), ioaddr + RTC_CENTURY);
+
+        writeb(flags & ~RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
+        return 0;
+}
+
+static int stk17ta8_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        unsigned int year, month, day, hour, minute, second, week;
+        unsigned int century;
+        u8 flags;
+
+        /* give enough time to update RTC in case of continuous read */
+        if (pdata->last_jiffies == jiffies)
+                msleep(1);
+        pdata->last_jiffies = jiffies;
+
+        flags = readb(pdata->ioaddr + RTC_FLAGS);
+        writeb(flags | RTC_READ, ioaddr + RTC_FLAGS);
+        second = readb(ioaddr + RTC_SECONDS) & RTC_SECONDS_MASK;
+        minute = readb(ioaddr + RTC_MINUTES);
+        hour = readb(ioaddr + RTC_HOURS);
+        day = readb(ioaddr + RTC_DATE);
+        week = readb(ioaddr + RTC_DAY) & RTC_DAY_MASK;
+        month = readb(ioaddr + RTC_MONTH);
+        year = readb(ioaddr + RTC_YEAR);
+        century = readb(ioaddr + RTC_CENTURY);
+        writeb(flags & ~RTC_READ, ioaddr + RTC_FLAGS);
+        tm->tm_sec = BCD2BIN(second);
+        tm->tm_min = BCD2BIN(minute);
+        tm->tm_hour = BCD2BIN(hour);
+        tm->tm_mday = BCD2BIN(day);
+        tm->tm_wday = BCD2BIN(week);
+        tm->tm_mon = BCD2BIN(month) - 1;
+        /* year is 1900 + tm->tm_year */
+        tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
+
+        if (rtc_valid_tm(tm) < 0) {
+                dev_err(dev, "retrieved date/time is not valid.\n");
+                rtc_time_to_tm(0, tm);
+        }
+        return 0;
+}
+
+static void stk17ta8_rtc_update_alarm(struct rtc_plat_data *pdata)
+{
+        void __iomem *ioaddr = pdata->ioaddr;
+        unsigned long irqflags;
+        u8 flags;
+
+        spin_lock_irqsave(&pdata->rtc->irq_lock, irqflags);
+
+        flags = readb(ioaddr + RTC_FLAGS);
+        writeb(flags | RTC_WRITE, ioaddr + RTC_FLAGS);
+
+        writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_mday),
+               ioaddr + RTC_DATE_ALARM);
+        writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_hour),
+               ioaddr + RTC_HOURS_ALARM);
+        writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_min),
+               ioaddr + RTC_MINUTES_ALARM);
+        writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_sec),
+               ioaddr + RTC_SECONDS_ALARM);
+        writeb(pdata->irqen ? RTC_INTS_AIE : 0, ioaddr + RTC_INTERRUPTS);
+        readb(ioaddr + RTC_FLAGS);      /* clear interrupts */
+        writeb(flags & ~RTC_WRITE, ioaddr + RTC_FLAGS);
+        spin_unlock_irqrestore(&pdata->rtc->irq_lock, irqflags);
+}
+
+static int stk17ta8_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq < 0)
+                return -EINVAL;
+        pdata->alrm_mday = alrm->time.tm_mday;
+        pdata->alrm_hour = alrm->time.tm_hour;
+        pdata->alrm_min = alrm->time.tm_min;
+        pdata->alrm_sec = alrm->time.tm_sec;
+        if (alrm->enabled)
+                pdata->irqen |= RTC_AF;
+        stk17ta8_rtc_update_alarm(pdata);
+        return 0;
+}
+
+static int stk17ta8_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq < 0)
+                return -EINVAL;
+        alrm->time.tm_mday = pdata->alrm_mday < 0 ? 0 : pdata->alrm_mday;
+        alrm->time.tm_hour = pdata->alrm_hour < 0 ? 0 : pdata->alrm_hour;
+        alrm->time.tm_min = pdata->alrm_min < 0 ? 0 : pdata->alrm_min;
+        alrm->time.tm_sec = pdata->alrm_sec < 0 ? 0 : pdata->alrm_sec;
+        alrm->enabled = (pdata->irqen & RTC_AF) ? 1 : 0;
+        return 0;
+}
+
+static irqreturn_t stk17ta8_rtc_interrupt(int irq, void *dev_id)
+{
+        struct platform_device *pdev = dev_id;
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        unsigned long events = RTC_IRQF;
+
+        /* read and clear interrupt */
+        if (!(readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF))
+                return IRQ_NONE;
+        if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
+                events |= RTC_UF;
+        else
+                events |= RTC_AF;
+        rtc_update_irq(pdata->rtc, 1, events);
+        return IRQ_HANDLED;
+}
+
+static void stk17ta8_rtc_release(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq >= 0) {
+                pdata->irqen = 0;
+                stk17ta8_rtc_update_alarm(pdata);
+        }
+}
+
+static int stk17ta8_rtc_ioctl(struct device *dev, unsigned int cmd,
+                            unsigned long arg)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq < 0)
+                return -ENOIOCTLCMD; /* fall back into rtc-dev's emulation */
+        switch (cmd) {
+        case RTC_AIE_OFF:
+                pdata->irqen &= ~RTC_AF;
+                stk17ta8_rtc_update_alarm(pdata);
+                break;
+        case RTC_AIE_ON:
+                pdata->irqen |= RTC_AF;
+                stk17ta8_rtc_update_alarm(pdata);
+                break;
+        default:
+                return -ENOIOCTLCMD;
+        }
+        return 0;
+}
+
+static const struct rtc_class_ops stk17ta8_rtc_ops = {
+        .read_time      = stk17ta8_rtc_read_time,
+        .set_time       = stk17ta8_rtc_set_time,
+        .read_alarm     = stk17ta8_rtc_read_alarm,
+        .set_alarm      = stk17ta8_rtc_set_alarm,
+        .release        = stk17ta8_rtc_release,
+        .ioctl          = stk17ta8_rtc_ioctl,
+};
+
+static ssize_t stk17ta8_nvram_read(struct kobject *kobj, char *buf,
+                                 loff_t pos, size_t size)
+{
+        struct platform_device *pdev =
+                to_platform_device(container_of(kobj, struct device, kobj));
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        ssize_t count;
+
+        for (count = 0; size > 0 && pos < RTC_OFFSET; count++, size--)
+                *buf++ = readb(ioaddr + pos++);
+        return count;
+}
+
+static ssize_t stk17ta8_nvram_write(struct kobject *kobj, char *buf,
+                                  loff_t pos, size_t size)
+{
+        struct platform_device *pdev =
+                to_platform_device(container_of(kobj, struct device, kobj));
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        ssize_t count;
+
+        for (count = 0; size > 0 && pos < RTC_OFFSET; count++, size--)
+                writeb(*buf++, ioaddr + pos++);
+        return count;
+}
+
+static struct bin_attribute stk17ta8_nvram_attr = {
+        .attr = {
+                .name = "nvram",
+                .mode = S_IRUGO | S_IWUGO,
+                .owner = THIS_MODULE,
+        },
+        .size = RTC_OFFSET,
+        .read = stk17ta8_nvram_read,
+        .write = stk17ta8_nvram_write,
+};
+
+static int __init stk17ta8_rtc_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+        struct resource *res;
+        unsigned int cal;
+        unsigned int flags;
+        struct rtc_plat_data *pdata;
+        void __iomem *ioaddr = NULL;
+        int ret = 0;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+        pdata->irq = -1;
+        if (!request_mem_region(res->start, RTC_REG_SIZE, pdev->name)) {
+                ret = -EBUSY;
+                goto out;
+        }
+        pdata->baseaddr = res->start;
+        ioaddr = ioremap(pdata->baseaddr, RTC_REG_SIZE);
+        if (!ioaddr) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        pdata->ioaddr = ioaddr;
+        pdata->irq = platform_get_irq(pdev, 0);
+
+        /* turn RTC on if it was not on */
+        cal = readb(ioaddr + RTC_CALIBRATION);
+        if (cal & RTC_STOP) {
+                cal &= RTC_CAL_MASK;
+                flags = readb(ioaddr + RTC_FLAGS);
+                writeb(flags | RTC_WRITE, ioaddr + RTC_FLAGS);
+                writeb(cal, ioaddr + RTC_CALIBRATION);
+                writeb(flags & ~RTC_WRITE, ioaddr + RTC_FLAGS);
+        }
+        if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_PF)
+                dev_warn(&pdev->dev, "voltage-low detected.\n");
+
+        if (pdata->irq >= 0) {
+                writeb(0, ioaddr + RTC_INTERRUPTS);
+                if (request_irq(pdata->irq, stk17ta8_rtc_interrupt,
+                                IRQF_DISABLED | IRQF_SHARED,
+                                pdev->name, pdev) < 0) {
+                        dev_warn(&pdev->dev, "interrupt not available.\n");
+                        pdata->irq = -1;
+                }
+        }
+
+        rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                  &stk17ta8_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                goto out;
+        }
+        pdata->rtc = rtc;
+        pdata->last_jiffies = jiffies;
+        platform_set_drvdata(pdev, pdata);
+        ret = sysfs_create_bin_file(&pdev->dev.kobj, &stk17ta8_nvram_attr);
+        if (ret)
+                goto out;
+        return 0;
+ out:
+        if (pdata->rtc)
+                rtc_device_unregister(pdata->rtc);
+        if (pdata->irq >= 0)
+                free_irq(pdata->irq, pdev);
+        if (ioaddr)
+                iounmap(ioaddr);
+        if (pdata->baseaddr)
+                release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
+        kfree(pdata);
+        return ret;
+}
+
+static int __devexit stk17ta8_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        sysfs_remove_bin_file(&pdev->dev.kobj, &stk17ta8_nvram_attr);
+        rtc_device_unregister(pdata->rtc);
+        if (pdata->irq >= 0) {
+                writeb(0, pdata->ioaddr + RTC_INTERRUPTS);
+                free_irq(pdata->irq, pdev);
+        }
+        iounmap(pdata->ioaddr);
+        release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
+        kfree(pdata);
+        return 0;
+}
+
+static struct platform_driver stk17ta8_rtc_driver = {
+        .probe          = stk17ta8_rtc_probe,
+        .remove         = __devexit_p(stk17ta8_rtc_remove),
+        .driver         = {
+                .name   = "stk17ta8",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static __init int stk17ta8_init(void)
+{
+        return platform_driver_register(&stk17ta8_rtc_driver);
+}
+
+static __exit void stk17ta8_exit(void)
+{
+        return platform_driver_unregister(&stk17ta8_rtc_driver);
+}
+
+module_init(stk17ta8_init);
+module_exit(stk17ta8_exit);
+
+MODULE_AUTHOR("Thomas Hommel <thomas.hommel@gefanuc.com>");
+MODULE_DESCRIPTION("Simtek STK17TA8 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 0f86895571..86a7ba7bad 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -132,6 +132,7 @@ obj-$(CONFIG_SCSI_IBMVSCSI)	+= ibmvscsi/
 obj-$(CONFIG_SCSI_IBMVSCSIS)    += ibmvscsi/
 obj-$(CONFIG_SCSI_HPTIOP)       += hptiop.o
 obj-$(CONFIG_SCSI_STEX)         += stex.o
+obj-$(CONFIG_PS3_ROM)           += ps3rom.o
 
 obj-$(CONFIG_ARM)               += arm/
 
diff --git a/drivers/scsi/ps3rom.c b/drivers/scsi/ps3rom.c
new file mode 100644
index 0000000000..b50f1e14f2
--- /dev/null
+++ b/drivers/scsi/ps3rom.c
@@ -0,0 +1,533 @@
+/*
+ * PS3 BD/DVD/CD-ROM Storage Driver
+ *
+ * Copyright (C) 2007 Sony Computer Entertainment Inc.
+ * Copyright 2007 Sony Corp.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/cdrom.h>
+#include <linux/highmem.h>
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_dbg.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+
+#include <asm/lv1call.h>
+#include <asm/ps3stor.h>
+
+
+#define DEVICE_NAME                     "ps3rom"
+
+#define BOUNCE_SIZE                     (64*1024)
+
+#define PS3ROM_MAX_SECTORS              (BOUNCE_SIZE / CD_FRAMESIZE)
+
+
+struct ps3rom_private {
+        struct ps3_storage_device *dev;
+        struct scsi_cmnd *curr_cmd;
+};
+
+
+#define LV1_STORAGE_SEND_ATAPI_COMMAND  (1)
+
+struct lv1_atapi_cmnd_block {
+        u8      pkt[32];        /* packet command block           */
+        u32     pktlen;         /* should be 12 for ATAPI 8020    */
+        u32     blocks;
+        u32     block_size;
+        u32     proto;          /* transfer mode                  */
+        u32     in_out;         /* transfer direction             */
+        u64     buffer;         /* parameter except command block */
+        u32     arglen;         /* length above                   */
+};
+
+enum lv1_atapi_proto {
+        NON_DATA_PROTO     = 0,
+        PIO_DATA_IN_PROTO  = 1,
+        PIO_DATA_OUT_PROTO = 2,
+        DMA_PROTO = 3
+};
+
+enum lv1_atapi_in_out {
+        DIR_WRITE = 0,          /* memory -> device */
+        DIR_READ = 1            /* device -> memory */
+};
+
+
+static int ps3rom_slave_configure(struct scsi_device *scsi_dev)
+{
+        struct ps3rom_private *priv = shost_priv(scsi_dev->host);
+        struct ps3_storage_device *dev = priv->dev;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: id %u, lun %u, channel %u\n", __func__,
+                __LINE__, scsi_dev->id, scsi_dev->lun, scsi_dev->channel);
+
+        /*
+         * ATAPI SFF8020 devices use MODE_SENSE_10,
+         * so we can prohibit MODE_SENSE_6
+         */
+        scsi_dev->use_10_for_ms = 1;
+
+        /* we don't support {READ,WRITE}_6 */
+        scsi_dev->use_10_for_rw = 1;
+
+        return 0;
+}
+
+/*
+ * copy data from device into scatter/gather buffer
+ */
+static int fill_from_dev_buffer(struct scsi_cmnd *cmd, const void *buf)
+{
+        int k, req_len, act_len, len, active;
+        void *kaddr;
+        struct scatterlist *sgpnt;
+        unsigned int buflen;
+
+        buflen = cmd->request_bufflen;
+        if (!buflen)
+                return 0;
+
+        if (!cmd->request_buffer)
+                return -1;
+
+        sgpnt = cmd->request_buffer;
+        active = 1;
+        for (k = 0, req_len = 0, act_len = 0; k < cmd->use_sg; ++k, ++sgpnt) {
+                if (active) {
+                        kaddr = kmap_atomic(sgpnt->page, KM_IRQ0);
+                        len = sgpnt->length;
+                        if ((req_len + len) > buflen) {
+                                active = 0;
+                                len = buflen - req_len;
+                        }
+                        memcpy(kaddr + sgpnt->offset, buf + req_len, len);
+                        flush_kernel_dcache_page(sgpnt->page);
+                        kunmap_atomic(kaddr, KM_IRQ0);
+                        act_len += len;
+                }
+                req_len += sgpnt->length;
+        }
+        cmd->resid = req_len - act_len;
+        return 0;
+}
+
+/*
+ * copy data from scatter/gather into device's buffer
+ */
+static int fetch_to_dev_buffer(struct scsi_cmnd *cmd, void *buf)
+{
+        int k, req_len, len, fin;
+        void *kaddr;
+        struct scatterlist *sgpnt;
+        unsigned int buflen;
+
+        buflen = cmd->request_bufflen;
+        if (!buflen)
+                return 0;
+
+        if (!cmd->request_buffer)
+                return -1;
+
+        sgpnt = cmd->request_buffer;
+        for (k = 0, req_len = 0, fin = 0; k < cmd->use_sg; ++k, ++sgpnt) {
+                kaddr = kmap_atomic(sgpnt->page, KM_IRQ0);
+                len = sgpnt->length;
+                if ((req_len + len) > buflen) {
+                        len = buflen - req_len;
+                        fin = 1;
+                }
+                memcpy(buf + req_len, kaddr + sgpnt->offset, len);
+                kunmap_atomic(kaddr, KM_IRQ0);
+                if (fin)
+                        return req_len + len;
+                req_len += sgpnt->length;
+        }
+        return req_len;
+}
+
+static int ps3rom_atapi_request(struct ps3_storage_device *dev,
+                                struct scsi_cmnd *cmd)
+{
+        struct lv1_atapi_cmnd_block atapi_cmnd;
+        unsigned char opcode = cmd->cmnd[0];
+        int res;
+        u64 lpar;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: send ATAPI command 0x%02x\n", __func__,
+                __LINE__, opcode);
+
+        memset(&atapi_cmnd, 0, sizeof(struct lv1_atapi_cmnd_block));
+        memcpy(&atapi_cmnd.pkt, cmd->cmnd, 12);
+        atapi_cmnd.pktlen = 12;
+        atapi_cmnd.block_size = 1; /* transfer size is block_size * blocks */
+        atapi_cmnd.blocks = atapi_cmnd.arglen = cmd->request_bufflen;
+        atapi_cmnd.buffer = dev->bounce_lpar;
+
+        switch (cmd->sc_data_direction) {
+        case DMA_FROM_DEVICE:
+                if (cmd->request_bufflen >= CD_FRAMESIZE)
+                        atapi_cmnd.proto = DMA_PROTO;
+                else
+                        atapi_cmnd.proto = PIO_DATA_IN_PROTO;
+                atapi_cmnd.in_out = DIR_READ;
+                break;
+
+        case DMA_TO_DEVICE:
+                if (cmd->request_bufflen >= CD_FRAMESIZE)
+                        atapi_cmnd.proto = DMA_PROTO;
+                else
+                        atapi_cmnd.proto = PIO_DATA_OUT_PROTO;
+                atapi_cmnd.in_out = DIR_WRITE;
+                res = fetch_to_dev_buffer(cmd, dev->bounce_buf);
+                if (res < 0)
+                        return DID_ERROR << 16;
+                break;
+
+        default:
+                atapi_cmnd.proto = NON_DATA_PROTO;
+                break;
+        }
+
+        lpar = ps3_mm_phys_to_lpar(__pa(&atapi_cmnd));
+        res = lv1_storage_send_device_command(dev->sbd.dev_id,
+                                              LV1_STORAGE_SEND_ATAPI_COMMAND,
+                                              lpar, sizeof(atapi_cmnd),
+                                              atapi_cmnd.buffer,
+                                              atapi_cmnd.arglen, &dev->tag);
+        if (res == LV1_DENIED_BY_POLICY) {
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u: ATAPI command 0x%02x denied by policy\n",
+                        __func__, __LINE__, opcode);
+                return DID_ERROR << 16;
+        }
+
+        if (res) {
+                dev_err(&dev->sbd.core,
+                        "%s:%u: ATAPI command 0x%02x failed %d\n", __func__,
+                        __LINE__, opcode, res);
+                return DID_ERROR << 16;
+        }
+
+        return 0;
+}
+
+static inline unsigned int srb10_lba(const struct scsi_cmnd *cmd)
+{
+        return cmd->cmnd[2] << 24 | cmd->cmnd[3] << 16 | cmd->cmnd[4] << 8 |
+               cmd->cmnd[5];
+}
+
+static inline unsigned int srb10_len(const struct scsi_cmnd *cmd)
+{
+        return cmd->cmnd[7] << 8 | cmd->cmnd[8];
+}
+
+static int ps3rom_read_request(struct ps3_storage_device *dev,
+                               struct scsi_cmnd *cmd, u32 start_sector,
+                               u32 sectors)
+{
+        int res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: read %u sectors starting at %u\n",
+                __func__, __LINE__, sectors, start_sector);
+
+        res = lv1_storage_read(dev->sbd.dev_id,
+                               dev->regions[dev->region_idx].id, start_sector,
+                               sectors, 0, dev->bounce_lpar, &dev->tag);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: read failed %d\n", __func__,
+                        __LINE__, res);
+                return DID_ERROR << 16;
+        }
+
+        return 0;
+}
+
+static int ps3rom_write_request(struct ps3_storage_device *dev,
+                                struct scsi_cmnd *cmd, u32 start_sector,
+                                u32 sectors)
+{
+        int res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: write %u sectors starting at %u\n",
+                __func__, __LINE__, sectors, start_sector);
+
+        res = fetch_to_dev_buffer(cmd, dev->bounce_buf);
+        if (res < 0)
+                return DID_ERROR << 16;
+
+        res = lv1_storage_write(dev->sbd.dev_id,
+                                dev->regions[dev->region_idx].id, start_sector,
+                                sectors, 0, dev->bounce_lpar, &dev->tag);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: write failed %d\n", __func__,
+                        __LINE__, res);
+                return DID_ERROR << 16;
+        }
+
+        return 0;
+}
+
+static int ps3rom_queuecommand(struct scsi_cmnd *cmd,
+                               void (*done)(struct scsi_cmnd *))
+{
+        struct ps3rom_private *priv = shost_priv(cmd->device->host);
+        struct ps3_storage_device *dev = priv->dev;
+        unsigned char opcode;
+        int res;
+
+#ifdef DEBUG
+        scsi_print_command(cmd);
+#endif
+
+        priv->curr_cmd = cmd;
+        cmd->scsi_done = done;
+
+        opcode = cmd->cmnd[0];
+        /*
+         * While we can submit READ/WRITE SCSI commands as ATAPI commands,
+         * it's recommended for various reasons (performance, error handling,
+         * ...) to use lv1_storage_{read,write}() instead
+         */
+        switch (opcode) {
+        case READ_10:
+                res = ps3rom_read_request(dev, cmd, srb10_lba(cmd),
+                                          srb10_len(cmd));
+                break;
+
+        case WRITE_10:
+                res = ps3rom_write_request(dev, cmd, srb10_lba(cmd),
+                                           srb10_len(cmd));
+                break;
+
+        default:
+                res = ps3rom_atapi_request(dev, cmd);
+                break;
+        }
+
+        if (res) {
+                memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
+                cmd->result = res;
+                cmd->sense_buffer[0] = 0x70;
+                cmd->sense_buffer[2] = ILLEGAL_REQUEST;
+                priv->curr_cmd = NULL;
+                cmd->scsi_done(cmd);
+        }
+
+        return 0;
+}
+
+static int decode_lv1_status(u64 status, unsigned char *sense_key,
+                             unsigned char *asc, unsigned char *ascq)
+{
+        if (((status >> 24) & 0xff) != SAM_STAT_CHECK_CONDITION)
+                return -1;
+
+        *sense_key = (status >> 16) & 0xff;
+        *asc       = (status >>  8) & 0xff;
+        *ascq      =  status        & 0xff;
+        return 0;
+}
+
+static irqreturn_t ps3rom_interrupt(int irq, void *data)
+{
+        struct ps3_storage_device *dev = data;
+        struct Scsi_Host *host;
+        struct ps3rom_private *priv;
+        struct scsi_cmnd *cmd;
+        int res;
+        u64 tag, status;
+        unsigned char sense_key, asc, ascq;
+
+        res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
+        /*
+         * status = -1 may mean that ATAPI transport completed OK, but
+         * ATAPI command itself resulted CHECK CONDITION
+         * so, upper layer should issue REQUEST_SENSE to check the sense data
+         */
+
+        if (tag != dev->tag)
+                dev_err(&dev->sbd.core,
+                        "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                        __func__, __LINE__, tag, dev->tag);
+
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+                        __func__, __LINE__, res, status);
+                return IRQ_HANDLED;
+        }
+
+        host = dev->sbd.core.driver_data;
+        priv = shost_priv(host);
+        cmd = priv->curr_cmd;
+
+        if (!status) {
+                /* OK, completed */
+                if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
+                        res = fill_from_dev_buffer(cmd, dev->bounce_buf);
+                        if (res) {
+                                cmd->result = DID_ERROR << 16;
+                                goto done;
+                        }
+                }
+                cmd->result = DID_OK << 16;
+                goto done;
+        }
+
+        if (cmd->cmnd[0] == REQUEST_SENSE) {
+                /* SCSI spec says request sense should never get error */
+                dev_err(&dev->sbd.core, "%s:%u: end error without autosense\n",
+                        __func__, __LINE__);
+                cmd->result = DID_ERROR << 16 | SAM_STAT_CHECK_CONDITION;
+                goto done;
+        }
+
+        if (decode_lv1_status(status, &sense_key, &asc, &ascq)) {
+                cmd->result = DID_ERROR << 16;
+                goto done;
+        }
+
+        cmd->sense_buffer[0]  = 0x70;
+        cmd->sense_buffer[2]  = sense_key;
+        cmd->sense_buffer[7]  = 16 - 6;
+        cmd->sense_buffer[12] = asc;
+        cmd->sense_buffer[13] = ascq;
+        cmd->result = SAM_STAT_CHECK_CONDITION;
+
+done:
+        priv->curr_cmd = NULL;
+        cmd->scsi_done(cmd);
+        return IRQ_HANDLED;
+}
+
+static struct scsi_host_template ps3rom_host_template = {
+        .name =                 DEVICE_NAME,
+        .slave_configure =      ps3rom_slave_configure,
+        .queuecommand =         ps3rom_queuecommand,
+        .can_queue =            1,
+        .this_id =              7,
+        .sg_tablesize =         SG_ALL,
+        .cmd_per_lun =          1,
+        .emulated =             1,              /* only sg driver uses this */
+        .max_sectors =          PS3ROM_MAX_SECTORS,
+        .use_clustering =       ENABLE_CLUSTERING,
+        .module =               THIS_MODULE,
+};
+
+
+static int __devinit ps3rom_probe(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+        int error;
+        struct Scsi_Host *host;
+        struct ps3rom_private *priv;
+
+        if (dev->blk_size != CD_FRAMESIZE) {
+                dev_err(&dev->sbd.core,
+                        "%s:%u: cannot handle block size %lu\n", __func__,
+                        __LINE__, dev->blk_size);
+                return -EINVAL;
+        }
+
+        dev->bounce_size = BOUNCE_SIZE;
+        dev->bounce_buf = kmalloc(BOUNCE_SIZE, GFP_DMA);
+        if (!dev->bounce_buf)
+                return -ENOMEM;
+
+        error = ps3stor_setup(dev, ps3rom_interrupt);
+        if (error)
+                goto fail_free_bounce;
+
+        host = scsi_host_alloc(&ps3rom_host_template,
+                               sizeof(struct ps3rom_private));
+        if (!host) {
+                dev_err(&dev->sbd.core, "%s:%u: scsi_host_alloc failed\n",
+                        __func__, __LINE__);
+                goto fail_teardown;
+        }
+
+        priv = shost_priv(host);
+        dev->sbd.core.driver_data = host;
+        priv->dev = dev;
+
+        /* One device/LUN per SCSI bus */
+        host->max_id = 1;
+        host->max_lun = 1;
+
+        error = scsi_add_host(host, &dev->sbd.core);
+        if (error) {
+                dev_err(&dev->sbd.core, "%s:%u: scsi_host_alloc failed %d\n",
+                        __func__, __LINE__, error);
+                error = -ENODEV;
+                goto fail_host_put;
+        }
+
+        scsi_scan_host(host);
+        return 0;
+
+fail_host_put:
+        scsi_host_put(host);
+        dev->sbd.core.driver_data = NULL;
+fail_teardown:
+        ps3stor_teardown(dev);
+fail_free_bounce:
+        kfree(dev->bounce_buf);
+        return error;
+}
+
+static int ps3rom_remove(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+        struct Scsi_Host *host = dev->sbd.core.driver_data;
+
+        scsi_remove_host(host);
+        ps3stor_teardown(dev);
+        scsi_host_put(host);
+        dev->sbd.core.driver_data = NULL;
+        kfree(dev->bounce_buf);
+        return 0;
+}
+
+static struct ps3_system_bus_driver ps3rom = {
+        .match_id       = PS3_MATCH_ID_STOR_ROM,
+        .core.name      = DEVICE_NAME,
+        .core.owner     = THIS_MODULE,
+        .probe          = ps3rom_probe,
+        .remove         = ps3rom_remove
+};
+
+
+static int __init ps3rom_init(void)
+{
+        return ps3_system_bus_driver_register(&ps3rom);
+}
+
+static void __exit ps3rom_exit(void)
+{
+        ps3_system_bus_driver_unregister(&ps3rom);
+}
+
+module_init(ps3rom_init);
+module_exit(ps3rom_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("PS3 BD/DVD/CD-ROM Storage Driver");
+MODULE_AUTHOR("Sony Corporation");
+MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_ROM);
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 018884d7a5..b05de30b5d 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -303,8 +303,7 @@ spi_register_board_info(struct spi_board_info const *info, unsigned n)
  * creates board info from kernel command lines
  */
 
-static void __init_or_module
-scan_boardinfo(struct spi_master *master)
+static void scan_boardinfo(struct spi_master *master)
 {
         struct boardinfo        *bi;
         struct device           *dev = master->cdev.dev;
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 0c5644bb59..564cc9b518 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -12,6 +12,13 @@ config VGASTATE
        tristate
        default n
 
+config VIDEO_OUTPUT_CONTROL
+        tristate "Lowlevel video output switch controls"
+        default m
+        help
+          This framework adds support for low-level control of the video 
+          output switch.
+
 config FB
         tristate "Support for frame buffer devices"
         ---help---
@@ -849,6 +856,16 @@ config FB_INTSRAM
           Say Y if you want to map Frame Buffer in internal SRAM. Say N if you want
           to let frame buffer in external SDRAM.
 
+config FB_ATMEL_STN
+        bool "Use a STN display with AT91/AT32 LCD Controller"
+        depends on FB_ATMEL && MACH_AT91SAM9261EK
+        default n
+        help
+          Say Y if you want to connect a STN LCD display to the AT91/AT32 LCD
+          Controller. Say N if you want to connect a TFT.
+
+          If unsure, say N.
+
 config FB_NVIDIA
         tristate "nVidia Framebuffer Support"
         depends on FB && PCI
@@ -1796,13 +1813,14 @@ config FB_PS3
         select FB_SYS_COPYAREA
         select FB_SYS_IMAGEBLIT
         select FB_SYS_FOPS
+        select VT_HW_CONSOLE_BINDING if FRAMEBUFFER_CONSOLE
         ---help---
           Include support for the virtual frame buffer in the PS3 platform.
 
 config FB_PS3_DEFAULT_SIZE_M
         int "PS3 default frame buffer size (in MiB)"
         depends on FB_PS3
-        default 18
+        default 9
         ---help---
           This is the default size (in MiB) of the virtual frame buffer in
           the PS3.
diff --git a/drivers/video/Makefile b/drivers/video/Makefile
index a562f9d69d..518933d490 100644
--- a/drivers/video/Makefile
+++ b/drivers/video/Makefile
@@ -123,3 +123,6 @@ obj-$(CONFIG_FB_OF)               += offb.o
 
 # the test framebuffer is last
 obj-$(CONFIG_FB_VIRTUAL)          += vfb.o
+
+#video output switch sysfs driver
+obj-$(CONFIG_VIDEO_OUTPUT_CONTROL) += output.o
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index e1d5bd0c98..235b618b41 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -79,6 +79,29 @@ static struct fb_fix_screeninfo atmel_lcdfb_fix __initdata = {
         .accel          = FB_ACCEL_NONE,
 };
 
+static unsigned long compute_hozval(unsigned long xres, unsigned long lcdcon2)
+{
+        unsigned long value;
+
+        if (!(cpu_is_at91sam9261() || cpu_is_at32ap7000()))
+                return xres;
+
+        value = xres;
+        if ((lcdcon2 & ATMEL_LCDC_DISTYPE) != ATMEL_LCDC_DISTYPE_TFT) {
+                /* STN display */
+                if ((lcdcon2 & ATMEL_LCDC_DISTYPE) == ATMEL_LCDC_DISTYPE_STNCOLOR) {
+                        value *= 3;
+                }
+                if ( (lcdcon2 & ATMEL_LCDC_IFWIDTH) == ATMEL_LCDC_IFWIDTH_4
+                   || ( (lcdcon2 & ATMEL_LCDC_IFWIDTH) == ATMEL_LCDC_IFWIDTH_8
+                      && (lcdcon2 & ATMEL_LCDC_SCANMOD) == ATMEL_LCDC_SCANMOD_DUAL ))
+                        value = DIV_ROUND_UP(value, 4);
+                else
+                        value = DIV_ROUND_UP(value, 8);
+        }
+
+        return value;
+}
 
 static void atmel_lcdfb_update_dma(struct fb_info *info,
                                struct fb_var_screeninfo *var)
@@ -181,6 +204,7 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
         var->xoffset = var->yoffset = 0;
 
         switch (var->bits_per_pixel) {
+        case 1:
         case 2:
         case 4:
         case 8:
@@ -195,8 +219,11 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
                 var->blue.offset = 10;
                 var->red.length = var->green.length = var->blue.length = 5;
                 break;
-        case 24:
         case 32:
+                var->transp.offset = 24;
+                var->transp.length = 8;
+                /* fall through */
+        case 24:
                 var->red.offset = 0;
                 var->green.offset = 8;
                 var->blue.offset = 16;
@@ -228,8 +255,10 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
 static int atmel_lcdfb_set_par(struct fb_info *info)
 {
         struct atmel_lcdfb_info *sinfo = info->par;
+        unsigned long hozval_linesz;
         unsigned long value;
         unsigned long clk_value_khz;
+        unsigned long bits_per_line;
 
         dev_dbg(info->device, "%s:\n", __func__);
         dev_dbg(info->device, "  * resolution: %ux%u (%ux%u virtual)\n",
@@ -241,12 +270,15 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
 
         lcdc_writel(sinfo, ATMEL_LCDC_DMACON, 0);
 
-        if (info->var.bits_per_pixel <= 8)
+        if (info->var.bits_per_pixel == 1)
+                info->fix.visual = FB_VISUAL_MONO01;
+        else if (info->var.bits_per_pixel <= 8)
                 info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
         else
                 info->fix.visual = FB_VISUAL_TRUECOLOR;
 
-        info->fix.line_length = info->var.xres_virtual * (info->var.bits_per_pixel / 8);
+        bits_per_line = info->var.xres_virtual * info->var.bits_per_pixel;
+        info->fix.line_length = DIV_ROUND_UP(bits_per_line, 8);
 
         /* Re-initialize the DMA engine... */
         dev_dbg(info->device, "  * update DMA engine\n");
@@ -262,18 +294,21 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
         /* Set pixel clock */
         clk_value_khz = clk_get_rate(sinfo->lcdc_clk) / 1000;
 
-        value = clk_value_khz / PICOS2KHZ(info->var.pixclock);
-
-        if (clk_value_khz % PICOS2KHZ(info->var.pixclock))
-                value++;
+        value = DIV_ROUND_UP(clk_value_khz, PICOS2KHZ(info->var.pixclock));
 
         value = (value / 2) - 1;
+        dev_dbg(info->device, "  * programming CLKVAL = 0x%08lx\n", value);
 
         if (value <= 0) {
                 dev_notice(info->device, "Bypassing pixel clock divider\n");
                 lcdc_writel(sinfo, ATMEL_LCDC_LCDCON1, ATMEL_LCDC_BYPASS);
-        } else
+        } else {
                 lcdc_writel(sinfo, ATMEL_LCDC_LCDCON1, value << ATMEL_LCDC_CLKVAL_OFFSET);
+                info->var.pixclock = KHZ2PICOS(clk_value_khz / (2 * (value + 1)));
+                dev_dbg(info->device, "  updated pixclk:     %lu KHz\n",
+                                        PICOS2KHZ(info->var.pixclock));
+        }
+
 
         /* Initialize control register 2 */
         value = sinfo->default_lcdcon2;
@@ -311,9 +346,14 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
         dev_dbg(info->device, "  * LCDTIM2 = %08lx\n", value);
         lcdc_writel(sinfo, ATMEL_LCDC_TIM2, value);
 
+        /* Horizontal value (aka line size) */
+        hozval_linesz = compute_hozval(info->var.xres,
+                                        lcdc_readl(sinfo, ATMEL_LCDC_LCDCON2));
+
         /* Display size */
-        value = (info->var.xres - 1) << ATMEL_LCDC_HOZVAL_OFFSET;
+        value = (hozval_linesz - 1) << ATMEL_LCDC_HOZVAL_OFFSET;
         value |= info->var.yres - 1;
+        dev_dbg(info->device, "  * LCDFRMCFG = %08lx\n", value);
         lcdc_writel(sinfo, ATMEL_LCDC_LCDFRMCFG, value);
 
         /* FIFO Threshold: Use formula from data sheet */
@@ -421,6 +461,15 @@ static int atmel_lcdfb_setcolreg(unsigned int regno, unsigned int red,
                         ret = 0;
                 }
                 break;
+
+        case FB_VISUAL_MONO01:
+                if (regno < 2) {
+                        val = (regno == 0) ? 0x00 : 0x1F;
+                        lcdc_writel(sinfo, ATMEL_LCDC_LUT(regno), val);
+                        ret = 0;
+                }
+                break;
+
         }
 
         return ret;
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index f46fe95f69..d18b73aafa 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -187,7 +187,11 @@ static void vgacon_scrollback_init(int pitch)
         }
 }
 
-static void vgacon_scrollback_startup(void)
+/*
+ * Called only duing init so call of alloc_bootmen is ok.
+ * Marked __init_refok to silence modpost.
+ */
+static void __init_refok vgacon_scrollback_startup(void)
 {
         vgacon_scrollback = alloc_bootmem(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
                                           * 1024);
diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c
index 3972aa8cf8..646ec823c1 100644
--- a/drivers/video/ps3fb.c
+++ b/drivers/video/ps3fb.c
@@ -1067,7 +1067,7 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
         info->fix.smem_len = ps3fb_videomemory.size - offset;
         info->pseudo_palette = info->par;
         info->par = NULL;
-        info->flags = FBINFO_FLAG_DEFAULT;
+        info->flags = FBINFO_DEFAULT | FBINFO_READS_FAST;
 
         retval = fb_alloc_cmap(&info->cmap, 256, 0);
         if (retval < 0)
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index 0fe547842c..41381e6183 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -2146,7 +2146,7 @@ static void __devexit rivafb_remove(struct pci_dev *pd)
  * ------------------------------------------------------------------------- */
 
 #ifndef MODULE
-static int __init rivafb_setup(char *options)
+static int __devinit rivafb_setup(char *options)
 {
         char *this_opt;