183 files changed, 3195 insertions, 2837 deletions

diff --git a/drivers/acpi/ac.c b/drivers/acpi/ac.c
index 43a95e5640de..5b73f6a2cd86 100644
--- a/drivers/acpi/ac.c
+++ b/drivers/acpi/ac.c
@@ -92,6 +92,7 @@ struct acpi_ac {
 
 #ifdef CONFIG_ACPI_PROCFS_POWER
 static const struct file_operations acpi_ac_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_ac_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -195,16 +196,11 @@ static int acpi_ac_add_fs(struct acpi_device *device)
         }
 
         /* 'state' [R] */
-        entry = create_proc_entry(ACPI_AC_FILE_STATE,
-                                  S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data(ACPI_AC_FILE_STATE,
+                                 S_IRUGO, acpi_device_dir(device),
+                                 &acpi_ac_fops, acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_ac_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
-
         return 0;
 }
 
diff --git a/drivers/acpi/battery.c b/drivers/acpi/battery.c
index d5729d5dc190..b1c723f9f58d 100644
--- a/drivers/acpi/battery.c
+++ b/drivers/acpi/battery.c
@@ -741,15 +741,13 @@ static int acpi_battery_add_fs(struct acpi_device *device)
         }
 
         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));
+                entry = proc_create_data(acpi_battery_file[i].name,
+                                         acpi_battery_file[i].mode,
+                                         acpi_device_dir(device),
+                                         &acpi_battery_file[i].ops,
+                                         acpi_driver_data(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;
 }
diff --git a/drivers/acpi/button.c b/drivers/acpi/button.c
index 6c5da83cdb68..1dfec413588c 100644
--- a/drivers/acpi/button.c
+++ b/drivers/acpi/button.c
@@ -102,6 +102,7 @@ struct acpi_button {
 };
 
 static const struct file_operations acpi_button_info_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_button_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -109,6 +110,7 @@ static const struct file_operations acpi_button_info_fops = {
 };
 
 static const struct file_operations acpi_button_state_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_button_state_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -207,27 +209,21 @@ static int acpi_button_add_fs(struct acpi_device *device)
         acpi_device_dir(device)->owner = THIS_MODULE;
 
         /* 'info' [R] */
-        entry = create_proc_entry(ACPI_BUTTON_FILE_INFO,
-                                  S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data(ACPI_BUTTON_FILE_INFO,
+                                 S_IRUGO, acpi_device_dir(device),
+                                 &acpi_button_info_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_button_info_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* show lid state [R] */
         if (button->type == ACPI_BUTTON_TYPE_LID) {
-                entry = create_proc_entry(ACPI_BUTTON_FILE_STATE,
-                                          S_IRUGO, acpi_device_dir(device));
+                entry = proc_create_data(ACPI_BUTTON_FILE_STATE,
+                                         S_IRUGO, acpi_device_dir(device),
+                                         &acpi_button_state_fops,
+                                         acpi_driver_data(device));
                 if (!entry)
                         return -ENODEV;
-                else {
-                        entry->proc_fops = &acpi_button_state_fops;
-                        entry->data = acpi_driver_data(device);
-                        entry->owner = THIS_MODULE;
-                }
         }
 
         return 0;
diff --git a/drivers/acpi/ec.c b/drivers/acpi/ec.c
index 7222a18a0319..e3f04b272f3f 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -669,16 +669,11 @@ static int acpi_ec_add_fs(struct acpi_device *device)
                         return -ENODEV;
         }
 
-        entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
-                                  acpi_device_dir(device));
+        entry = proc_create_data(ACPI_EC_FILE_INFO, S_IRUGO,
+                                 acpi_device_dir(device),
+                                 &acpi_ec_info_ops, acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_ec_info_ops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
-
         return 0;
 }
 
diff --git a/drivers/acpi/event.c b/drivers/acpi/event.c
index abec1ca94cf4..0c24bd4d6562 100644
--- a/drivers/acpi/event.c
+++ b/drivers/acpi/event.c
@@ -102,6 +102,7 @@ static unsigned int acpi_system_poll_event(struct file *file, poll_table * wait)
 }
 
 static const struct file_operations acpi_system_event_ops = {
+        .owner = THIS_MODULE,
         .open = acpi_system_open_event,
         .read = acpi_system_read_event,
         .release = acpi_system_close_event,
@@ -294,10 +295,9 @@ static int __init acpi_event_init(void)
 
 #ifdef CONFIG_ACPI_PROC_EVENT
         /* 'event' [R] */
-        entry = create_proc_entry("event", S_IRUSR, acpi_root_dir);
-        if (entry)
-                entry->proc_fops = &acpi_system_event_ops;
-        else
+        entry = proc_create("event", S_IRUSR, acpi_root_dir,
+                            &acpi_system_event_ops);
+        if (!entry)
                 return -ENODEV;
 #endif
 
diff --git a/drivers/acpi/fan.c b/drivers/acpi/fan.c
index c8e3cba423ef..194077ab9b85 100644
--- a/drivers/acpi/fan.c
+++ b/drivers/acpi/fan.c
@@ -192,17 +192,13 @@ static int acpi_fan_add_fs(struct acpi_device *device)
         }
 
         /* 'status' [R/W] */
-        entry = create_proc_entry(ACPI_FAN_FILE_STATE,
-                                  S_IFREG | S_IRUGO | S_IWUSR,
-                                  acpi_device_dir(device));
+        entry = proc_create_data(ACPI_FAN_FILE_STATE,
+                                 S_IFREG | S_IRUGO | S_IWUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_fan_state_ops,
+                                 device);
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_fan_state_ops;
-                entry->data = device;
-                entry->owner = THIS_MODULE;
-        }
-
         return 0;
 }
 
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index 76bf6d90c700..21fc8bf0d31f 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -93,6 +93,7 @@ struct acpi_power_resource {
 static struct list_head acpi_power_resource_list;
 
 static const struct file_operations acpi_power_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_power_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -543,15 +544,11 @@ static int acpi_power_add_fs(struct acpi_device *device)
         }
 
         /* 'status' [R] */
-        entry = create_proc_entry(ACPI_POWER_FILE_STATUS,
-                                  S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data(ACPI_POWER_FILE_STATUS,
+                                 S_IRUGO, acpi_device_dir(device),
+                                 &acpi_power_fops, acpi_driver_data(device));
         if (!entry)
                 return -EIO;
-        else {
-                entry->proc_fops = &acpi_power_fops;
-                entry->data = acpi_driver_data(device);
-        }
-
         return 0;
 }
 
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index a825b431b64f..dd28c912e84f 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -112,6 +112,7 @@ static struct acpi_driver acpi_processor_driver = {
 #define UNINSTALL_NOTIFY_HANDLER        2
 
 static const struct file_operations acpi_processor_info_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_processor_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -326,40 +327,30 @@ static int acpi_processor_add_fs(struct acpi_device *device)
         acpi_device_dir(device)->owner = THIS_MODULE;
 
         /* 'info' [R] */
-        entry = create_proc_entry(ACPI_PROCESSOR_FILE_INFO,
-                                  S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data(ACPI_PROCESSOR_FILE_INFO,
+                                 S_IRUGO, acpi_device_dir(device),
+                                 &acpi_processor_info_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -EIO;
-        else {
-                entry->proc_fops = &acpi_processor_info_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'throttling' [R/W] */
-        entry = create_proc_entry(ACPI_PROCESSOR_FILE_THROTTLING,
-                                  S_IFREG | S_IRUGO | S_IWUSR,
-                                  acpi_device_dir(device));
+        entry = proc_create_data(ACPI_PROCESSOR_FILE_THROTTLING,
+                                 S_IFREG | S_IRUGO | S_IWUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_processor_throttling_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -EIO;
-        else {
-                entry->proc_fops = &acpi_processor_throttling_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'limit' [R/W] */
-        entry = create_proc_entry(ACPI_PROCESSOR_FILE_LIMIT,
-                                  S_IFREG | S_IRUGO | S_IWUSR,
-                                  acpi_device_dir(device));
+        entry = proc_create_data(ACPI_PROCESSOR_FILE_LIMIT,
+                                 S_IFREG | S_IRUGO | S_IWUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_processor_limit_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -EIO;
-        else {
-                entry->proc_fops = &acpi_processor_limit_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
-
         return 0;
 }
 
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 0d90ff5fd117..789d4947ed31 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -1282,6 +1282,7 @@ static int acpi_processor_power_open_fs(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations acpi_processor_power_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_processor_power_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -1822,16 +1823,12 @@ int __cpuinit acpi_processor_power_init(struct acpi_processor *pr,
         }
 
         /* 'power' [R] */
-        entry = create_proc_entry(ACPI_PROCESSOR_FILE_POWER,
-                                  S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data(ACPI_PROCESSOR_FILE_POWER,
+                                 S_IRUGO, acpi_device_dir(device),
+                                 &acpi_processor_power_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -EIO;
-        else {
-                entry->proc_fops = &acpi_processor_power_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
-
         return 0;
 }
 
diff --git a/drivers/acpi/processor_perflib.c b/drivers/acpi/processor_perflib.c
index b477a4be8a69..d80b2d1441af 100644
--- a/drivers/acpi/processor_perflib.c
+++ b/drivers/acpi/processor_perflib.c
@@ -411,6 +411,7 @@ EXPORT_SYMBOL(acpi_processor_notify_smm);
 
 static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file);
 static struct file_operations acpi_processor_perf_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_processor_perf_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -456,7 +457,6 @@ static int acpi_processor_perf_open_fs(struct inode *inode, struct file *file)
 
 static void acpi_cpufreq_add_file(struct acpi_processor *pr)
 {
-        struct proc_dir_entry *entry = NULL;
         struct acpi_device *device = NULL;
 
 
@@ -464,14 +464,9 @@ static void acpi_cpufreq_add_file(struct acpi_processor *pr)
                 return;
 
         /* add file 'performance' [R/W] */
-        entry = create_proc_entry(ACPI_PROCESSOR_FILE_PERFORMANCE,
-                                  S_IFREG | S_IRUGO,
-                                  acpi_device_dir(device));
-        if (entry){
-                entry->proc_fops = &acpi_processor_perf_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
+        proc_create_data(ACPI_PROCESSOR_FILE_PERFORMANCE, S_IFREG | S_IRUGO,
+                         acpi_device_dir(device),
+                         &acpi_processor_perf_fops, acpi_driver_data(device));
         return;
 }
 
diff --git a/drivers/acpi/processor_thermal.c b/drivers/acpi/processor_thermal.c
index 649ae99b9216..ef34b18f95ca 100644
--- a/drivers/acpi/processor_thermal.c
+++ b/drivers/acpi/processor_thermal.c
@@ -509,6 +509,7 @@ static ssize_t acpi_processor_write_limit(struct file * file,
 }
 
 struct file_operations acpi_processor_limit_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_processor_limit_open_fs,
         .read = seq_read,
         .write = acpi_processor_write_limit,
diff --git a/drivers/acpi/processor_throttling.c b/drivers/acpi/processor_throttling.c
index 0bba3a914e86..bb06738860c4 100644
--- a/drivers/acpi/processor_throttling.c
+++ b/drivers/acpi/processor_throttling.c
@@ -1252,6 +1252,7 @@ static ssize_t acpi_processor_write_throttling(struct file *file,
 }
 
 struct file_operations acpi_processor_throttling_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_processor_throttling_open_fs,
         .read = seq_read,
         .write = acpi_processor_write_throttling,
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c
index 585ae3c9c8ea..10a36512647c 100644
--- a/drivers/acpi/sbs.c
+++ b/drivers/acpi/sbs.c
@@ -483,8 +483,6 @@ acpi_sbs_add_fs(struct proc_dir_entry **dir,
                 struct file_operations *state_fops,
                 struct file_operations *alarm_fops, void *data)
 {
-        struct proc_dir_entry *entry = NULL;
-
         if (!*dir) {
                 *dir = proc_mkdir(dir_name, parent_dir);
                 if (!*dir) {
@@ -494,34 +492,19 @@ acpi_sbs_add_fs(struct proc_dir_entry **dir,
         }
 
         /* 'info' [R] */
-        if (info_fops) {
-                entry = create_proc_entry(ACPI_SBS_FILE_INFO, S_IRUGO, *dir);
-                if (entry) {
-                        entry->proc_fops = info_fops;
-                        entry->data = data;
-                        entry->owner = THIS_MODULE;
-                }
-        }
+        if (info_fops)
+                proc_create_data(ACPI_SBS_FILE_INFO, S_IRUGO, *dir,
+                                 info_fops, data);
 
         /* 'state' [R] */
-        if (state_fops) {
-                entry = create_proc_entry(ACPI_SBS_FILE_STATE, S_IRUGO, *dir);
-                if (entry) {
-                        entry->proc_fops = state_fops;
-                        entry->data = data;
-                        entry->owner = THIS_MODULE;
-                }
-        }
+        if (state_fops)
+                proc_create_data(ACPI_SBS_FILE_STATE, S_IRUGO, *dir,
+                                 state_fops, data);
 
         /* 'alarm' [R/W] */
-        if (alarm_fops) {
-                entry = create_proc_entry(ACPI_SBS_FILE_ALARM, S_IRUGO, *dir);
-                if (entry) {
-                        entry->proc_fops = alarm_fops;
-                        entry->data = data;
-                        entry->owner = THIS_MODULE;
-                }
-        }
+        if (alarm_fops)
+                proc_create_data(ACPI_SBS_FILE_ALARM, S_IRUGO, *dir,
+                                 alarm_fops, data);
         return 0;
 }
 
diff --git a/drivers/acpi/sleep/proc.c b/drivers/acpi/sleep/proc.c
index f8df5217d477..8a5fe8710513 100644
--- a/drivers/acpi/sleep/proc.c
+++ b/drivers/acpi/sleep/proc.c
@@ -440,6 +440,7 @@ acpi_system_wakeup_device_open_fs(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations acpi_system_wakeup_device_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_system_wakeup_device_open_fs,
         .read = seq_read,
         .write = acpi_system_write_wakeup_device,
@@ -449,6 +450,7 @@ static const struct file_operations acpi_system_wakeup_device_fops = {
 
 #ifdef  CONFIG_ACPI_PROCFS
 static const struct file_operations acpi_system_sleep_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_system_sleep_open_fs,
         .read = seq_read,
         .write = acpi_system_write_sleep,
@@ -459,6 +461,7 @@ static const struct file_operations acpi_system_sleep_fops = {
 
 #ifdef  HAVE_ACPI_LEGACY_ALARM
 static const struct file_operations acpi_system_alarm_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_system_alarm_open_fs,
         .read = seq_read,
         .write = acpi_system_write_alarm,
@@ -477,37 +480,26 @@ static u32 rtc_handler(void *context)
 
 static int __init acpi_sleep_proc_init(void)
 {
-        struct proc_dir_entry *entry = NULL;
-
         if (acpi_disabled)
                 return 0;
 
 #ifdef  CONFIG_ACPI_PROCFS
         /* 'sleep' [R/W] */
-        entry =
-            create_proc_entry("sleep", S_IFREG | S_IRUGO | S_IWUSR,
-                              acpi_root_dir);
-        if (entry)
-                entry->proc_fops = &acpi_system_sleep_fops;
+        proc_create("sleep", S_IFREG | S_IRUGO | S_IWUSR,
+                    acpi_root_dir, &acpi_system_sleep_fops);
 #endif                          /* CONFIG_ACPI_PROCFS */
 
 #ifdef  HAVE_ACPI_LEGACY_ALARM
         /* 'alarm' [R/W] */
-        entry =
-            create_proc_entry("alarm", S_IFREG | S_IRUGO | S_IWUSR,
-                              acpi_root_dir);
-        if (entry)
-                entry->proc_fops = &acpi_system_alarm_fops;
+        proc_create("alarm", S_IFREG | S_IRUGO | S_IWUSR,
+                    acpi_root_dir, &acpi_system_alarm_fops);
 
         acpi_install_fixed_event_handler(ACPI_EVENT_RTC, rtc_handler, NULL);
 #endif                          /* HAVE_ACPI_LEGACY_ALARM */
 
         /* 'wakeup device' [R/W] */
-        entry =
-            create_proc_entry("wakeup", S_IFREG | S_IRUGO | S_IWUSR,
-                              acpi_root_dir);
-        if (entry)
-                entry->proc_fops = &acpi_system_wakeup_device_fops;
+        proc_create("wakeup", S_IFREG | S_IRUGO | S_IWUSR,
+                    acpi_root_dir, &acpi_system_wakeup_device_fops);
 
         return 0;
 }
diff --git a/drivers/acpi/system.c b/drivers/acpi/system.c
index 4749f379a915..769f24855eb6 100644
--- a/drivers/acpi/system.c
+++ b/drivers/acpi/system.c
@@ -396,6 +396,7 @@ static int acpi_system_info_open_fs(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations acpi_system_info_ops = {
+        .owner = THIS_MODULE,
         .open = acpi_system_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -406,6 +407,7 @@ static ssize_t acpi_system_read_dsdt(struct file *, char __user *, size_t,
                                      loff_t *);
 
 static const struct file_operations acpi_system_dsdt_ops = {
+        .owner = THIS_MODULE,
         .read = acpi_system_read_dsdt,
 };
 
@@ -430,6 +432,7 @@ static ssize_t acpi_system_read_fadt(struct file *, char __user *, size_t,
                                      loff_t *);
 
 static const struct file_operations acpi_system_fadt_ops = {
+        .owner = THIS_MODULE,
         .read = acpi_system_read_fadt,
 };
 
@@ -454,31 +457,23 @@ static int acpi_system_procfs_init(void)
 {
         struct proc_dir_entry *entry;
         int error = 0;
-        char *name;
 
         /* 'info' [R] */
-        name = ACPI_SYSTEM_FILE_INFO;
-        entry = create_proc_entry(name, S_IRUGO, acpi_root_dir);
+        entry = proc_create(ACPI_SYSTEM_FILE_INFO, S_IRUGO, acpi_root_dir,
+                            &acpi_system_info_ops);
         if (!entry)
                 goto Error;
-        else {
-                entry->proc_fops = &acpi_system_info_ops;
-        }
 
         /* 'dsdt' [R] */
-        name = ACPI_SYSTEM_FILE_DSDT;
-        entry = create_proc_entry(name, S_IRUSR, acpi_root_dir);
-        if (entry)
-                entry->proc_fops = &acpi_system_dsdt_ops;
-        else
+        entry = proc_create(ACPI_SYSTEM_FILE_DSDT, S_IRUSR, acpi_root_dir,
+                            &acpi_system_dsdt_ops);
+        if (!entry)
                 goto Error;
 
         /* 'fadt' [R] */
-        name = ACPI_SYSTEM_FILE_FADT;
-        entry = create_proc_entry(name, S_IRUSR, acpi_root_dir);
-        if (entry)
-                entry->proc_fops = &acpi_system_fadt_ops;
-        else
+        entry = proc_create(ACPI_SYSTEM_FILE_FADT, S_IRUSR, acpi_root_dir,
+                            &acpi_system_fadt_ops);
+        if (!entry)
                 goto Error;
 
       Done:
diff --git a/drivers/acpi/thermal.c b/drivers/acpi/thermal.c
index 766bd25d3376..0815ac3ae3d6 100644
--- a/drivers/acpi/thermal.c
+++ b/drivers/acpi/thermal.c
@@ -198,6 +198,7 @@ struct acpi_thermal {
 };
 
 static const struct file_operations acpi_thermal_state_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_thermal_state_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -205,6 +206,7 @@ static const struct file_operations acpi_thermal_state_fops = {
 };
 
 static const struct file_operations acpi_thermal_temp_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_thermal_temp_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -212,6 +214,7 @@ static const struct file_operations acpi_thermal_temp_fops = {
 };
 
 static const struct file_operations acpi_thermal_trip_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_thermal_trip_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -219,6 +222,7 @@ static const struct file_operations acpi_thermal_trip_fops = {
 };
 
 static const struct file_operations acpi_thermal_cooling_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_thermal_cooling_open_fs,
         .read = seq_read,
         .write = acpi_thermal_write_cooling_mode,
@@ -227,6 +231,7 @@ static const struct file_operations acpi_thermal_cooling_fops = {
 };
 
 static const struct file_operations acpi_thermal_polling_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_thermal_polling_open_fs,
         .read = seq_read,
         .write = acpi_thermal_write_polling,
@@ -1419,63 +1424,47 @@ static int acpi_thermal_add_fs(struct acpi_device *device)
         }
 
         /* 'state' [R] */
-        entry = create_proc_entry(ACPI_THERMAL_FILE_STATE,
-                                  S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data(ACPI_THERMAL_FILE_STATE,
+                                 S_IRUGO, acpi_device_dir(device),
+                                 &acpi_thermal_state_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_thermal_state_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'temperature' [R] */
-        entry = create_proc_entry(ACPI_THERMAL_FILE_TEMPERATURE,
-                                  S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data(ACPI_THERMAL_FILE_TEMPERATURE,
+                                 S_IRUGO, acpi_device_dir(device),
+                                 &acpi_thermal_temp_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_thermal_temp_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'trip_points' [R] */
-        entry = create_proc_entry(ACPI_THERMAL_FILE_TRIP_POINTS,
-                                  S_IRUGO,
-                                  acpi_device_dir(device));
+        entry = proc_create_data(ACPI_THERMAL_FILE_TRIP_POINTS,
+                                 S_IRUGO,
+                                 acpi_device_dir(device),
+                                 &acpi_thermal_trip_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_thermal_trip_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'cooling_mode' [R/W] */
-        entry = create_proc_entry(ACPI_THERMAL_FILE_COOLING_MODE,
-                                  S_IFREG | S_IRUGO | S_IWUSR,
-                                  acpi_device_dir(device));
+        entry = proc_create_data(ACPI_THERMAL_FILE_COOLING_MODE,
+                                 S_IFREG | S_IRUGO | S_IWUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_thermal_cooling_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_thermal_cooling_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'polling_frequency' [R/W] */
-        entry = create_proc_entry(ACPI_THERMAL_FILE_POLLING_FREQ,
-                                  S_IFREG | S_IRUGO | S_IWUSR,
-                                  acpi_device_dir(device));
+        entry = proc_create_data(ACPI_THERMAL_FILE_POLLING_FREQ,
+                                 S_IFREG | S_IRUGO | S_IWUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_thermal_polling_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_thermal_polling_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
-
         return 0;
 }
 
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 980a74188781..43b228314a86 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -192,6 +192,7 @@ struct acpi_video_device {
 /* bus */
 static int acpi_video_bus_info_open_fs(struct inode *inode, struct file *file);
 static struct file_operations acpi_video_bus_info_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_video_bus_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -200,6 +201,7 @@ static struct file_operations acpi_video_bus_info_fops = {
 
 static int acpi_video_bus_ROM_open_fs(struct inode *inode, struct file *file);
 static struct file_operations acpi_video_bus_ROM_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_video_bus_ROM_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -209,6 +211,7 @@ static struct file_operations acpi_video_bus_ROM_fops = {
 static int acpi_video_bus_POST_info_open_fs(struct inode *inode,
                                             struct file *file);
 static struct file_operations acpi_video_bus_POST_info_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_video_bus_POST_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -217,6 +220,7 @@ static struct file_operations acpi_video_bus_POST_info_fops = {
 
 static int acpi_video_bus_POST_open_fs(struct inode *inode, struct file *file);
 static struct file_operations acpi_video_bus_POST_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_video_bus_POST_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -225,6 +229,7 @@ static struct file_operations acpi_video_bus_POST_fops = {
 
 static int acpi_video_bus_DOS_open_fs(struct inode *inode, struct file *file);
 static struct file_operations acpi_video_bus_DOS_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_video_bus_DOS_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -235,6 +240,7 @@ static struct file_operations acpi_video_bus_DOS_fops = {
 static int acpi_video_device_info_open_fs(struct inode *inode,
                                           struct file *file);
 static struct file_operations acpi_video_device_info_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_video_device_info_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -244,6 +250,7 @@ static struct file_operations acpi_video_device_info_fops = {
 static int acpi_video_device_state_open_fs(struct inode *inode,
                                            struct file *file);
 static struct file_operations acpi_video_device_state_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_video_device_state_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -253,6 +260,7 @@ static struct file_operations acpi_video_device_state_fops = {
 static int acpi_video_device_brightness_open_fs(struct inode *inode,
                                                 struct file *file);
 static struct file_operations acpi_video_device_brightness_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_video_device_brightness_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -262,6 +270,7 @@ static struct file_operations acpi_video_device_brightness_fops = {
 static int acpi_video_device_EDID_open_fs(struct inode *inode,
                                           struct file *file);
 static struct file_operations acpi_video_device_EDID_fops = {
+        .owner = THIS_MODULE,
         .open = acpi_video_device_EDID_open_fs,
         .read = seq_read,
         .llseek = seq_lseek,
@@ -1070,51 +1079,36 @@ static int acpi_video_device_add_fs(struct acpi_device *device)
         }
 
         /* 'info' [R] */
-        entry = create_proc_entry("info", S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data("info", S_IRUGO, acpi_device_dir(device),
+                        &acpi_video_device_info_fops, acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_video_device_info_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'state' [R/W] */
-        entry =
-            create_proc_entry("state", S_IFREG | S_IRUGO | S_IWUSR,
-                              acpi_device_dir(device));
+        acpi_video_device_state_fops.write = acpi_video_device_write_state;
+        entry = proc_create_data("state", S_IFREG | S_IRUGO | S_IWUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_video_device_state_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                acpi_video_device_state_fops.write = acpi_video_device_write_state;
-                entry->proc_fops = &acpi_video_device_state_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'brightness' [R/W] */
-        entry =
-            create_proc_entry("brightness", S_IFREG | S_IRUGO | S_IWUSR,
-                              acpi_device_dir(device));
+        acpi_video_device_brightness_fops.write =
+                acpi_video_device_write_brightness;
+        entry = proc_create_data("brightness", S_IFREG | S_IRUGO | S_IWUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_video_device_brightness_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                acpi_video_device_brightness_fops.write = acpi_video_device_write_brightness;
-                entry->proc_fops = &acpi_video_device_brightness_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'EDID' [R] */
-        entry = create_proc_entry("EDID", S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data("EDID", S_IRUGO, acpi_device_dir(device),
+                                 &acpi_video_device_EDID_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_video_device_EDID_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
-
         return 0;
 }
 
@@ -1353,61 +1347,43 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
         }
 
         /* 'info' [R] */
-        entry = create_proc_entry("info", S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data("info", S_IRUGO, acpi_device_dir(device),
+                                 &acpi_video_bus_info_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_video_bus_info_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'ROM' [R] */
-        entry = create_proc_entry("ROM", S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data("ROM", S_IRUGO, acpi_device_dir(device),
+                                 &acpi_video_bus_ROM_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_video_bus_ROM_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'POST_info' [R] */
-        entry =
-            create_proc_entry("POST_info", S_IRUGO, acpi_device_dir(device));
+        entry = proc_create_data("POST_info", S_IRUGO, acpi_device_dir(device),
+                                 &acpi_video_bus_POST_info_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                entry->proc_fops = &acpi_video_bus_POST_info_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'POST' [R/W] */
-        entry =
-            create_proc_entry("POST", S_IFREG | S_IRUGO | S_IRUSR,
-                              acpi_device_dir(device));
+        acpi_video_bus_POST_fops.write = acpi_video_bus_write_POST;
+        entry = proc_create_data("POST", S_IFREG | S_IRUGO | S_IRUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_video_bus_POST_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                acpi_video_bus_POST_fops.write = acpi_video_bus_write_POST;
-                entry->proc_fops = &acpi_video_bus_POST_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         /* 'DOS' [R/W] */
-        entry =
-            create_proc_entry("DOS", S_IFREG | S_IRUGO | S_IRUSR,
-                              acpi_device_dir(device));
+        acpi_video_bus_DOS_fops.write = acpi_video_bus_write_DOS;
+        entry = proc_create_data("DOS", S_IFREG | S_IRUGO | S_IRUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_video_bus_DOS_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 return -ENODEV;
-        else {
-                acpi_video_bus_DOS_fops.write = acpi_video_bus_write_DOS;
-                entry->proc_fops = &acpi_video_bus_DOS_fops;
-                entry->data = acpi_driver_data(device);
-                entry->owner = THIS_MODULE;
-        }
 
         return 0;
 }
diff --git a/drivers/base/firmware_class.c b/drivers/base/firmware_class.c
index 1fef7df8c9d6..9fd4a8534146 100644
--- a/drivers/base/firmware_class.c
+++ b/drivers/base/firmware_class.c
@@ -396,6 +396,8 @@ _request_firmware(const struct firmware **firmware_p, const char *name,
         if (!firmware_p)
                 return -EINVAL;
 
+        printk(KERN_INFO "firmware: requesting %s\n", name);
+
         *firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
         if (!firmware) {
                 printk(KERN_ERR "%s: kmalloc(struct firmware) failed\n",
diff --git a/drivers/block/aoe/aoe.h b/drivers/block/aoe/aoe.h
index 280e71ee744c..5b4c6e649c11 100644
--- a/drivers/block/aoe/aoe.h
+++ b/drivers/block/aoe/aoe.h
@@ -195,7 +195,6 @@ void aoedev_exit(void);
 struct aoedev *aoedev_by_aoeaddr(int maj, int min);
 struct aoedev *aoedev_by_sysminor_m(ulong sysminor);
 void aoedev_downdev(struct aoedev *d);
-int aoedev_isbusy(struct aoedev *d);
 int aoedev_flush(const char __user *str, size_t size);
 
 int aoenet_init(void);
diff --git a/drivers/block/aoe/aoecmd.c b/drivers/block/aoe/aoecmd.c
index d00293ba3b45..8fc429cf82b6 100644
--- a/drivers/block/aoe/aoecmd.c
+++ b/drivers/block/aoe/aoecmd.c
@@ -668,16 +668,16 @@ ataid_complete(struct aoedev *d, struct aoetgt *t, unsigned char *id)
         u16 n;
 
         /* word 83: command set supported */
-        n = le16_to_cpu(get_unaligned((__le16 *) &id[83<<1]));
+        n = get_unaligned_le16(&id[83 << 1]);
 
         /* word 86: command set/feature enabled */
-        n |= le16_to_cpu(get_unaligned((__le16 *) &id[86<<1]));
+        n |= get_unaligned_le16(&id[86 << 1]);
 
         if (n & (1<<10)) {      /* bit 10: LBA 48 */
                 d->flags |= DEVFL_EXT;
 
                 /* word 100: number lba48 sectors */
-                ssize = le64_to_cpu(get_unaligned((__le64 *) &id[100<<1]));
+                ssize = get_unaligned_le64(&id[100 << 1]);
 
                 /* set as in ide-disk.c:init_idedisk_capacity */
                 d->geo.cylinders = ssize;
@@ -688,12 +688,12 @@ ataid_complete(struct aoedev *d, struct aoetgt *t, unsigned char *id)
                 d->flags &= ~DEVFL_EXT;
 
                 /* number lba28 sectors */
-                ssize = le32_to_cpu(get_unaligned((__le32 *) &id[60<<1]));
+                ssize = get_unaligned_le32(&id[60 << 1]);
 
                 /* NOTE: obsolete in ATA 6 */
-                d->geo.cylinders = le16_to_cpu(get_unaligned((__le16 *) &id[54<<1]));
-                d->geo.heads = le16_to_cpu(get_unaligned((__le16 *) &id[55<<1]));
-                d->geo.sectors = le16_to_cpu(get_unaligned((__le16 *) &id[56<<1]));
+                d->geo.cylinders = get_unaligned_le16(&id[54 << 1]);
+                d->geo.heads = get_unaligned_le16(&id[55 << 1]);
+                d->geo.sectors = get_unaligned_le16(&id[56 << 1]);
         }
 
         if (d->ssize != ssize)
@@ -779,7 +779,7 @@ aoecmd_ata_rsp(struct sk_buff *skb)
         u16 aoemajor;
 
         hin = (struct aoe_hdr *) skb_mac_header(skb);
-        aoemajor = be16_to_cpu(get_unaligned(&hin->major));
+        aoemajor = get_unaligned_be16(&hin->major);
         d = aoedev_by_aoeaddr(aoemajor, hin->minor);
         if (d == NULL) {
                 snprintf(ebuf, sizeof ebuf, "aoecmd_ata_rsp: ata response "
@@ -791,7 +791,7 @@ aoecmd_ata_rsp(struct sk_buff *skb)
 
         spin_lock_irqsave(&d->lock, flags);
 
-        n = be32_to_cpu(get_unaligned(&hin->tag));
+        n = get_unaligned_be32(&hin->tag);
         t = gettgt(d, hin->src);
         if (t == NULL) {
                 printk(KERN_INFO "aoe: can't find target e%ld.%d:%012llx\n",
@@ -806,9 +806,9 @@ aoecmd_ata_rsp(struct sk_buff *skb)
                 snprintf(ebuf, sizeof ebuf,
                         "%15s e%d.%d    tag=%08x@%08lx\n",
                         "unexpected rsp",
-                        be16_to_cpu(get_unaligned(&hin->major)),
+                        get_unaligned_be16(&hin->major),
                         hin->minor,
-                        be32_to_cpu(get_unaligned(&hin->tag)),
+                        get_unaligned_be32(&hin->tag),
                         jiffies);
                 aoechr_error(ebuf);
                 return;
@@ -873,7 +873,7 @@ aoecmd_ata_rsp(struct sk_buff *skb)
                         printk(KERN_INFO
                                 "aoe: unrecognized ata command %2.2Xh for %d.%d\n",
                                 ahout->cmdstat,
-                                be16_to_cpu(get_unaligned(&hin->major)),
+                                get_unaligned_be16(&hin->major),
                                 hin->minor);
                 }
         }
diff --git a/drivers/block/aoe/aoedev.c b/drivers/block/aoe/aoedev.c
index f9a1cd9edb77..a1d813ab0d6b 100644
--- a/drivers/block/aoe/aoedev.c
+++ b/drivers/block/aoe/aoedev.c
@@ -18,24 +18,6 @@ static void skbpoolfree(struct aoedev *d);
 static struct aoedev *devlist;
 static DEFINE_SPINLOCK(devlist_lock);
 
-int
-aoedev_isbusy(struct aoedev *d)
-{
-        struct aoetgt **t, **te;
-        struct frame *f, *e;
-
-        t = d->targets;
-        te = t + NTARGETS;
-        for (; t < te && *t; t++) {
-                f = (*t)->frames;
-                e = f + (*t)->nframes;
-                for (; f < e; f++)
-                        if (f->tag != FREETAG)
-                                return 1;
-        }
-        return 0;
-}
-
 struct aoedev *
 aoedev_by_aoeaddr(int maj, int min)
 {
diff --git a/drivers/block/aoe/aoenet.c b/drivers/block/aoe/aoenet.c
index 18d243c73eee..d625169c8e48 100644
--- a/drivers/block/aoe/aoenet.c
+++ b/drivers/block/aoe/aoenet.c
@@ -128,7 +128,7 @@ aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt,
         skb_push(skb, ETH_HLEN);        /* (1) */
 
         h = (struct aoe_hdr *) skb_mac_header(skb);
-        n = be32_to_cpu(get_unaligned(&h->tag));
+        n = get_unaligned_be32(&h->tag);
         if ((h->verfl & AOEFL_RSP) == 0 || (n & 1<<31))
                 goto exit;
 
@@ -140,7 +140,7 @@ aoenet_rcv(struct sk_buff *skb, struct net_device *ifp, struct packet_type *pt,
                         printk(KERN_ERR
                                 "%s%d.%d@%s; ecode=%d '%s'\n",
                                 "aoe: error packet from ",
-                                be16_to_cpu(get_unaligned(&h->major)),
+                                get_unaligned_be16(&h->major),
                                 h->minor, skb->dev->name,
                                 h->err, aoe_errlist[n]);
                 goto exit;
diff --git a/drivers/block/cciss.c b/drivers/block/cciss.c
index cf6083a1f928..e539be5750dc 100644
--- a/drivers/block/cciss.c
+++ b/drivers/block/cciss.c
@@ -425,7 +425,7 @@ static void __devinit cciss_procinit(int i)
         struct proc_dir_entry *pde;
 
         if (proc_cciss == NULL)
-                proc_cciss = proc_mkdir("cciss", proc_root_driver);
+                proc_cciss = proc_mkdir("driver/cciss", NULL);
         if (!proc_cciss)
                 return;
         pde = proc_create(hba[i]->devname, S_IWUSR | S_IRUSR | S_IRGRP |
@@ -3700,7 +3700,7 @@ static void __exit cciss_cleanup(void)
                         cciss_remove_one(hba[i]->pdev);
                 }
         }
-        remove_proc_entry("cciss", proc_root_driver);
+        remove_proc_entry("driver/cciss", NULL);
 }
 
 static void fail_all_cmds(unsigned long ctlr)
diff --git a/drivers/block/cpqarray.c b/drivers/block/cpqarray.c
index 69199185ff4b..09c14341e6e3 100644
--- a/drivers/block/cpqarray.c
+++ b/drivers/block/cpqarray.c
@@ -214,7 +214,7 @@ static struct proc_dir_entry *proc_array;
 static void __init ida_procinit(int i)
 {
         if (proc_array == NULL) {
-                proc_array = proc_mkdir("cpqarray", proc_root_driver);
+                proc_array = proc_mkdir("driver/cpqarray", NULL);
                 if (!proc_array) return;
         }
 
@@ -1796,7 +1796,7 @@ static void __exit cpqarray_exit(void)
                 }
         }
 
-        remove_proc_entry("cpqarray", proc_root_driver);
+        remove_proc_entry("driver/cpqarray", NULL);
 }
 
 module_init(cpqarray_init)
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 7652e87d60c5..395f8ea7981c 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4526,14 +4526,15 @@ static void __init parse_floppy_cfg_string(char *cfg)
         }
 }
 
-int __init init_module(void)
+static int __init floppy_module_init(void)
 {
         if (floppy)
                 parse_floppy_cfg_string(floppy);
         return floppy_init();
 }
+module_init(floppy_module_init);
 
-void cleanup_module(void)
+static void __exit floppy_module_exit(void)
 {
         int drive;
 
@@ -4562,6 +4563,7 @@ void cleanup_module(void)
         /* eject disk, if any */
         fd_eject(0);
 }
+module_exit(floppy_module_exit);
 
 module_param(floppy, charp, 0);
 module_param(FLOPPY_IRQ, int, 0);
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index f75bda16a1fc..ad98dda6037d 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -29,6 +29,7 @@
 #include <linux/kernel.h>
 #include <net/sock.h>
 #include <linux/net.h>
+#include <linux/kthread.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -55,6 +56,7 @@ static unsigned int debugflags;
 
 static unsigned int nbds_max = 16;
 static struct nbd_device *nbd_dev;
+static int max_part;
 
 /*
  * Use just one lock (or at most 1 per NIC). Two arguments for this:
@@ -337,7 +339,7 @@ static struct request *nbd_read_stat(struct nbd_device *lo)
         }
 
         req = nbd_find_request(lo, *(struct request **)reply.handle);
-        if (unlikely(IS_ERR(req))) {
+        if (IS_ERR(req)) {
                 result = PTR_ERR(req);
                 if (result != -ENOENT)
                         goto harderror;
@@ -441,6 +443,85 @@ static void nbd_clear_que(struct nbd_device *lo)
 }
 
 
+static void nbd_handle_req(struct nbd_device *lo, struct request *req)
+{
+        if (!blk_fs_request(req))
+                goto error_out;
+
+        nbd_cmd(req) = NBD_CMD_READ;
+        if (rq_data_dir(req) == WRITE) {
+                nbd_cmd(req) = NBD_CMD_WRITE;
+                if (lo->flags & NBD_READ_ONLY) {
+                        printk(KERN_ERR "%s: Write on read-only\n",
+                                        lo->disk->disk_name);
+                        goto error_out;
+                }
+        }
+
+        req->errors = 0;
+
+        mutex_lock(&lo->tx_lock);
+        if (unlikely(!lo->sock)) {
+                mutex_unlock(&lo->tx_lock);
+                printk(KERN_ERR "%s: Attempted send on closed socket\n",
+                       lo->disk->disk_name);
+                req->errors++;
+                nbd_end_request(req);
+                return;
+        }
+
+        lo->active_req = req;
+
+        if (nbd_send_req(lo, req) != 0) {
+                printk(KERN_ERR "%s: Request send failed\n",
+                                lo->disk->disk_name);
+                req->errors++;
+                nbd_end_request(req);
+        } else {
+                spin_lock(&lo->queue_lock);
+                list_add(&req->queuelist, &lo->queue_head);
+                spin_unlock(&lo->queue_lock);
+        }
+
+        lo->active_req = NULL;
+        mutex_unlock(&lo->tx_lock);
+        wake_up_all(&lo->active_wq);
+
+        return;
+
+error_out:
+        req->errors++;
+        nbd_end_request(req);
+}
+
+static int nbd_thread(void *data)
+{
+        struct nbd_device *lo = data;
+        struct request *req;
+
+        set_user_nice(current, -20);
+        while (!kthread_should_stop() || !list_empty(&lo->waiting_queue)) {
+                /* wait for something to do */
+                wait_event_interruptible(lo->waiting_wq,
+                                         kthread_should_stop() ||
+                                         !list_empty(&lo->waiting_queue));
+
+                /* extract request */
+                if (list_empty(&lo->waiting_queue))
+                        continue;
+
+                spin_lock_irq(&lo->queue_lock);
+                req = list_entry(lo->waiting_queue.next, struct request,
+                                 queuelist);
+                list_del_init(&req->queuelist);
+                spin_unlock_irq(&lo->queue_lock);
+
+                /* handle request */
+                nbd_handle_req(lo, req);
+        }
+        return 0;
+}
+
 /*
  * We always wait for result of write, for now. It would be nice to make it optional
  * in future
@@ -456,65 +537,23 @@ static void do_nbd_request(struct request_queue * q)
                 struct nbd_device *lo;
 
                 blkdev_dequeue_request(req);
+
+                spin_unlock_irq(q->queue_lock);
+
                 dprintk(DBG_BLKDEV, "%s: request %p: dequeued (flags=%x)\n",
                                 req->rq_disk->disk_name, req, req->cmd_type);
 
-                if (!blk_fs_request(req))
-                        goto error_out;
-
                 lo = req->rq_disk->private_data;
 
                 BUG_ON(lo->magic != LO_MAGIC);
 
-                nbd_cmd(req) = NBD_CMD_READ;
-                if (rq_data_dir(req) == WRITE) {
-                        nbd_cmd(req) = NBD_CMD_WRITE;
-                        if (lo->flags & NBD_READ_ONLY) {
-                                printk(KERN_ERR "%s: Write on read-only\n",
-                                                lo->disk->disk_name);
-                                goto error_out;
-                        }
-                }
-
-                req->errors = 0;
-                spin_unlock_irq(q->queue_lock);
-
-                mutex_lock(&lo->tx_lock);
-                if (unlikely(!lo->sock)) {
-                        mutex_unlock(&lo->tx_lock);
-                        printk(KERN_ERR "%s: Attempted send on closed socket\n",
-                               lo->disk->disk_name);
-                        req->errors++;
-                        nbd_end_request(req);
-                        spin_lock_irq(q->queue_lock);
-                        continue;
-                }
-
-                lo->active_req = req;
+                spin_lock_irq(&lo->queue_lock);
+                list_add_tail(&req->queuelist, &lo->waiting_queue);
+                spin_unlock_irq(&lo->queue_lock);
 
-                if (nbd_send_req(lo, req) != 0) {
-                        printk(KERN_ERR "%s: Request send failed\n",
-                                        lo->disk->disk_name);
-                        req->errors++;
-                        nbd_end_request(req);
-                } else {
-                        spin_lock(&lo->queue_lock);
-                        list_add(&req->queuelist, &lo->queue_head);
-                        spin_unlock(&lo->queue_lock);
-                }
-
-                lo->active_req = NULL;
-                mutex_unlock(&lo->tx_lock);
-                wake_up_all(&lo->active_wq);
+                wake_up(&lo->waiting_wq);
 
                 spin_lock_irq(q->queue_lock);
-                continue;
-
-error_out:
-                req->errors++;
-                spin_unlock(q->queue_lock);
-                nbd_end_request(req);
-                spin_lock(q->queue_lock);
         }
 }
 
@@ -524,6 +563,7 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
         struct nbd_device *lo = inode->i_bdev->bd_disk->private_data;
         int error;
         struct request sreq ;
+        struct task_struct *thread;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
@@ -572,10 +612,13 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                 error = -EINVAL;
                 file = fget(arg);
                 if (file) {
+                        struct block_device *bdev = inode->i_bdev;
                         inode = file->f_path.dentry->d_inode;
                         if (S_ISSOCK(inode->i_mode)) {
                                 lo->file = file;
                                 lo->sock = SOCKET_I(inode);
+                                if (max_part > 0)
+                                        bdev->bd_invalidated = 1;
                                 error = 0;
                         } else {
                                 fput(file);
@@ -607,7 +650,12 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
         case NBD_DO_IT:
                 if (!lo->file)
                         return -EINVAL;
+                thread = kthread_create(nbd_thread, lo, lo->disk->disk_name);
+                if (IS_ERR(thread))
+                        return PTR_ERR(thread);
+                wake_up_process(thread);
                 error = nbd_do_it(lo);
+                kthread_stop(thread);
                 if (error)
                         return error;
                 sock_shutdown(lo, 1);
@@ -620,6 +668,8 @@ static int nbd_ioctl(struct inode *inode, struct file *file,
                 lo->bytesize = 0;
                 inode->i_bdev->bd_inode->i_size = 0;
                 set_capacity(lo->disk, 0);
+                if (max_part > 0)
+                        ioctl_by_bdev(inode->i_bdev, BLKRRPART, 0);
                 return lo->harderror;
         case NBD_CLEAR_QUE:
                 /*
@@ -653,6 +703,7 @@ static int __init nbd_init(void)
 {
         int err = -ENOMEM;
         int i;
+        int part_shift;
 
         BUILD_BUG_ON(sizeof(struct nbd_request) != 28);
 
@@ -660,8 +711,17 @@ static int __init nbd_init(void)
         if (!nbd_dev)
                 return -ENOMEM;
 
+        if (max_part < 0) {
+                printk(KERN_CRIT "nbd: max_part must be >= 0\n");
+                return -EINVAL;
+        }
+
+        part_shift = 0;
+        if (max_part > 0)
+                part_shift = fls(max_part);
+
         for (i = 0; i < nbds_max; i++) {
-                struct gendisk *disk = alloc_disk(1);
+                struct gendisk *disk = alloc_disk(1 << part_shift);
                 elevator_t *old_e;
                 if (!disk)
                         goto out;
@@ -696,17 +756,18 @@ static int __init nbd_init(void)
                 nbd_dev[i].file = NULL;
                 nbd_dev[i].magic = LO_MAGIC;
                 nbd_dev[i].flags = 0;
+                INIT_LIST_HEAD(&nbd_dev[i].waiting_queue);
                 spin_lock_init(&nbd_dev[i].queue_lock);
                 INIT_LIST_HEAD(&nbd_dev[i].queue_head);
                 mutex_init(&nbd_dev[i].tx_lock);
                 init_waitqueue_head(&nbd_dev[i].active_wq);
+                init_waitqueue_head(&nbd_dev[i].waiting_wq);
                 nbd_dev[i].blksize = 1024;
                 nbd_dev[i].bytesize = 0;
                 disk->major = NBD_MAJOR;
-                disk->first_minor = i;
+                disk->first_minor = i << part_shift;
                 disk->fops = &nbd_fops;
                 disk->private_data = &nbd_dev[i];
-                disk->flags |= GENHD_FL_SUPPRESS_PARTITION_INFO;
                 sprintf(disk->disk_name, "nbd%d", i);
                 set_capacity(disk, 0);
                 add_disk(disk);
@@ -744,7 +805,9 @@ MODULE_DESCRIPTION("Network Block Device");
 MODULE_LICENSE("GPL");
 
 module_param(nbds_max, int, 0444);
-MODULE_PARM_DESC(nbds_max, "How many network block devices to initialize.");
+MODULE_PARM_DESC(nbds_max, "number of network block devices to initialize (default: 16)");
+module_param(max_part, int, 0444);
+MODULE_PARM_DESC(max_part, "number of partitions per device (default: 0)");
 #ifndef NDEBUG
 module_param(debugflags, int, 0644);
 MODULE_PARM_DESC(debugflags, "flags for controlling debug output");
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 3b806c9fb005..3ba1df93e9e3 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -2742,7 +2742,6 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
         int i;
         int ret = 0;
         char b[BDEVNAME_SIZE];
-        struct proc_dir_entry *proc;
         struct block_device *bdev;
 
         if (pd->pkt_dev == dev) {
@@ -2786,11 +2785,7 @@ static int pkt_new_dev(struct pktcdvd_device *pd, dev_t dev)
                 goto out_mem;
         }
 
-        proc = create_proc_entry(pd->name, 0, pkt_proc);
-        if (proc) {
-                proc->data = pd;
-                proc->proc_fops = &pkt_proc_fops;
-        }
+        proc_create_data(pd->name, 0, pkt_proc, &pkt_proc_fops, pd);
         DPRINTK(DRIVER_NAME": writer %s mapped to %s\n", pd->name, bdevname(bdev, b));
         return 0;
 
@@ -3099,7 +3094,7 @@ static int __init pkt_init(void)
                 goto out_misc;
         }
 
-        pkt_proc = proc_mkdir(DRIVER_NAME, proc_root_driver);
+        pkt_proc = proc_mkdir("driver/"DRIVER_NAME, NULL);
 
         return 0;
 
@@ -3115,7 +3110,7 @@ out2:
 
 static void __exit pkt_exit(void)
 {
-        remove_proc_entry(DRIVER_NAME, proc_root_driver);
+        remove_proc_entry("driver/"DRIVER_NAME, NULL);
         misc_deregister(&pkt_misc);
 
         pkt_debugfs_cleanup();
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index d771da816d95..f2fff5799ddf 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -137,7 +137,7 @@ static void blkif_restart_queue_callback(void *arg)
         schedule_work(&info->work);
 }
 
-int blkif_getgeo(struct block_device *bd, struct hd_geometry *hg)
+static int blkif_getgeo(struct block_device *bd, struct hd_geometry *hg)
 {
         /* We don't have real geometry info, but let's at least return
            values consistent with the size of the device */
diff --git a/drivers/cdrom/viocd.c b/drivers/cdrom/viocd.c
index b74b6c2768a8..5245a4a0ba74 100644
--- a/drivers/cdrom/viocd.c
+++ b/drivers/cdrom/viocd.c
@@ -144,6 +144,7 @@ static int proc_viocd_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations proc_viocd_operations = {
+        .owner          = THIS_MODULE,
         .open           = proc_viocd_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -679,7 +680,6 @@ static struct vio_driver viocd_driver = {
 
 static int __init viocd_init(void)
 {
-        struct proc_dir_entry *e;
         int ret = 0;
 
         if (!firmware_has_feature(FW_FEATURE_ISERIES))
@@ -719,12 +719,8 @@ static int __init viocd_init(void)
         if (ret)
                 goto out_free_info;
 
-        e = create_proc_entry("iSeries/viocd", S_IFREG|S_IRUGO, NULL);
-        if (e) {
-                e->owner = THIS_MODULE;
-                e->proc_fops = &proc_viocd_operations;
-        }
-
+        proc_create("iSeries/viocd", S_IFREG|S_IRUGO, NULL,
+                    &proc_viocd_operations);
         return 0;
 
 out_free_info:
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index 929d4fa73fd9..5dce3877eee5 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -80,6 +80,15 @@ config VT_HW_CONSOLE_BINDING
          information. For framebuffer console users, please refer to
          <file:Documentation/fb/fbcon.txt>.
 
+config DEVKMEM
+        bool "/dev/kmem virtual device support"
+        default y
+        help
+          Say Y here if you want to support the /dev/kmem device. The
+          /dev/kmem device is rarely used, but can be used for certain
+          kind of kernel debugging operations.
+          When in doubt, say "N".
+
 config SERIAL_NONSTANDARD
         bool "Non-standard serial port support"
         depends on HAS_IOMEM
diff --git a/drivers/char/apm-emulation.c b/drivers/char/apm-emulation.c
index 17d54315e146..cdd876dbb2b0 100644
--- a/drivers/char/apm-emulation.c
+++ b/drivers/char/apm-emulation.c
@@ -14,6 +14,7 @@
 #include <linux/poll.h>
 #include <linux/slab.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/miscdevice.h>
 #include <linux/apm_bios.h>
 #include <linux/capability.h>
@@ -493,11 +494,10 @@ static struct miscdevice apm_device = {
  *      -1: Unknown
  *   8) min = minutes; sec = seconds
  */
-static int apm_get_info(char *buf, char **start, off_t fpos, int length)
+static int proc_apm_show(struct seq_file *m, void *v)
 {
         struct apm_power_info info;
         char *units;
-        int ret;
 
         info.ac_line_status = 0xff;
         info.battery_status = 0xff;
@@ -515,14 +515,27 @@ static int apm_get_info(char *buf, char **start, off_t fpos, int length)
         case 1:         units = "sec";  break;
         }
 
-        ret = sprintf(buf, "%s 1.2 0x%02x 0x%02x 0x%02x 0x%02x %d%% %d %s\n",
+        seq_printf(m, "%s 1.2 0x%02x 0x%02x 0x%02x 0x%02x %d%% %d %s\n",
                      driver_version, APM_32_BIT_SUPPORT,
                      info.ac_line_status, info.battery_status,
                      info.battery_flag, info.battery_life,
                      info.time, units);
 
-        return ret;
+        return 0;
 }
+
+static int proc_apm_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, proc_apm_show, NULL);
+}
+
+static const struct file_operations apm_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = proc_apm_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
 #endif
 
 static int kapmd(void *arg)
@@ -593,7 +606,7 @@ static int __init apm_init(void)
         wake_up_process(kapmd_tsk);
 
 #ifdef CONFIG_PROC_FS
-        create_proc_info_entry("apm", 0, NULL, apm_get_info);
+        proc_create("apm", 0, NULL, &apm_proc_fops);
 #endif
 
         ret = misc_register(&apm_device);
diff --git a/drivers/char/i8k.c b/drivers/char/i8k.c
index 8609b8236c67..f49037b744f9 100644
--- a/drivers/char/i8k.c
+++ b/drivers/char/i8k.c
@@ -82,6 +82,7 @@ static int i8k_ioctl(struct inode *, struct file *, unsigned int,
                      unsigned long);
 
 static const struct file_operations i8k_fops = {
+        .owner          = THIS_MODULE,
         .open           = i8k_open_fs,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -554,13 +555,10 @@ static int __init i8k_init(void)
                 return -ENODEV;
 
         /* Register the proc entry */
-        proc_i8k = create_proc_entry("i8k", 0, NULL);
+        proc_i8k = proc_create("i8k", 0, NULL, &i8k_fops);
         if (!proc_i8k)
                 return -ENOENT;
 
-        proc_i8k->proc_fops = &i8k_fops;
-        proc_i8k->owner = THIS_MODULE;
-
         printk(KERN_INFO
                "Dell laptop SMM driver v%s Massimo Dal Zotto (dz@debian.org)\n",
                I8K_VERSION);
diff --git a/drivers/char/ip2/ip2main.c b/drivers/char/ip2/ip2main.c
index b1d6cad84282..0a61856c631f 100644
--- a/drivers/char/ip2/ip2main.c
+++ b/drivers/char/ip2/ip2main.c
@@ -133,8 +133,9 @@
  *****************/
 
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 
-static int ip2_read_procmem(char *, char **, off_t, int);
+static const struct file_operations ip2mem_proc_fops;
 static int ip2_read_proc(char *, char **, off_t, int, int *, void * );
 
 /********************/
@@ -423,7 +424,7 @@ cleanup_module(void)
         }
         put_tty_driver(ip2_tty_driver);
         unregister_chrdev(IP2_IPL_MAJOR, pcIpl);
-        remove_proc_entry("ip2mem", &proc_root);
+        remove_proc_entry("ip2mem", NULL);
 
         // free memory
         for (i = 0; i < IP2_MAX_BOARDS; i++) {
@@ -695,7 +696,7 @@ ip2_loadmain(int *iop, int *irqp, unsigned char *firmware, int firmsize)
                 }
         }
         /* Register the read_procmem thing */
-        if (!create_proc_info_entry("ip2mem",0,&proc_root,ip2_read_procmem)) {
+        if (!proc_create("ip2mem",0,NULL,&ip2mem_proc_fops)) {
                 printk(KERN_ERR "IP2: failed to register read_procmem\n");
         } else {
 
@@ -2967,65 +2968,61 @@ ip2_ipl_open( struct inode *pInode, struct file *pFile )
         }
         return 0;
 }
-/******************************************************************************/
-/* Function:   ip2_read_procmem                                               */
-/* Parameters:                                                                */
-/*                                                                            */
-/* Returns: Length of output                                                  */
-/*                                                                            */
-/* Description:                                                               */
-/*   Supplies some driver operating parameters                                */
-/*      Not real useful unless your debugging the fifo                                                    */
-/*                                                                            */
-/******************************************************************************/
-
-#define LIMIT  (PAGE_SIZE - 120)
 
 static int
-ip2_read_procmem(char *buf, char **start, off_t offset, int len)
+proc_ip2mem_show(struct seq_file *m, void *v)
 {
         i2eBordStrPtr  pB;
         i2ChanStrPtr  pCh;
         PTTY tty;
         int i;
 
-        len = 0;
-
 #define FMTLINE "%3d: 0x%08x 0x%08x 0%011o 0%011o\n"
 #define FMTLIN2 "     0x%04x 0x%04x tx flow 0x%x\n"
 #define FMTLIN3 "     0x%04x 0x%04x rc flow\n"
 
-        len += sprintf(buf+len,"\n");
+        seq_printf(m,"\n");
 
         for( i = 0; i < IP2_MAX_BOARDS; ++i ) {
                 pB = i2BoardPtrTable[i];
                 if ( pB ) {
-                        len += sprintf(buf+len,"board %d:\n",i);
-                        len += sprintf(buf+len,"\tFifo rem: %d mty: %x outM %x\n",
+                        seq_printf(m,"board %d:\n",i);
+                        seq_printf(m,"\tFifo rem: %d mty: %x outM %x\n",
                                 pB->i2eFifoRemains,pB->i2eWaitingForEmptyFifo,pB->i2eOutMailWaiting);
                 }
         }
 
-        len += sprintf(buf+len,"#: tty flags, port flags,     cflags,     iflags\n");
+        seq_printf(m,"#: tty flags, port flags,     cflags,     iflags\n");
         for (i=0; i < IP2_MAX_PORTS; i++) {
-                if (len > LIMIT)
-                        break;
                 pCh = DevTable[i];
                 if (pCh) {
                         tty = pCh->pTTY;
                         if (tty && tty->count) {
-                                len += sprintf(buf+len,FMTLINE,i,(int)tty->flags,pCh->flags,
+                                seq_printf(m,FMTLINE,i,(int)tty->flags,pCh->flags,
                                                                         tty->termios->c_cflag,tty->termios->c_iflag);
 
-                                len += sprintf(buf+len,FMTLIN2,
+                                seq_printf(m,FMTLIN2,
                                                 pCh->outfl.asof,pCh->outfl.room,pCh->channelNeeds);
-                                len += sprintf(buf+len,FMTLIN3,pCh->infl.asof,pCh->infl.room);
+                                seq_printf(m,FMTLIN3,pCh->infl.asof,pCh->infl.room);
                         }
                 }
         }
-        return len;
+        return 0;
+}
+
+static int proc_ip2mem_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, proc_ip2mem_show, NULL);
 }
 
+static const struct file_operations ip2mem_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = proc_ip2mem_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 /*
  * This is the handler for /proc/tty/driver/ip2
  *
diff --git a/drivers/char/ipmi/Makefile b/drivers/char/ipmi/Makefile
index 553f0a408eda..eb8a1a8c188e 100644
--- a/drivers/char/ipmi/Makefile
+++ b/drivers/char/ipmi/Makefile
@@ -9,7 +9,3 @@ obj-$(CONFIG_IPMI_DEVICE_INTERFACE) += ipmi_devintf.o
 obj-$(CONFIG_IPMI_SI) += ipmi_si.o
 obj-$(CONFIG_IPMI_WATCHDOG) += ipmi_watchdog.o
 obj-$(CONFIG_IPMI_POWEROFF) += ipmi_poweroff.o
-
-ipmi_si.o:      $(ipmi_si-objs)
-        $(LD) -r -o $@ $(ipmi_si-objs)
-
diff --git a/drivers/char/ipmi/ipmi_bt_sm.c b/drivers/char/ipmi/ipmi_bt_sm.c
index e736119b6497..7b98c067190a 100644
--- a/drivers/char/ipmi/ipmi_bt_sm.c
+++ b/drivers/char/ipmi/ipmi_bt_sm.c
@@ -37,26 +37,32 @@
 #define BT_DEBUG_ENABLE 1       /* Generic messages */
 #define BT_DEBUG_MSG    2       /* Prints all request/response buffers */
 #define BT_DEBUG_STATES 4       /* Verbose look at state changes */
-/* BT_DEBUG_OFF must be zero to correspond to the default uninitialized
-   value */
+/*
+ * BT_DEBUG_OFF must be zero to correspond to the default uninitialized
+ * value
+ */
 
 static int bt_debug; /* 0 == BT_DEBUG_OFF */
 
 module_param(bt_debug, int, 0644);
 MODULE_PARM_DESC(bt_debug, "debug bitmask, 1=enable, 2=messages, 4=states");
 
-/* Typical "Get BT Capabilities" values are 2-3 retries, 5-10 seconds,
-   and 64 byte buffers.  However, one HP implementation wants 255 bytes of
-   buffer (with a documented message of 160 bytes) so go for the max.
-   Since the Open IPMI architecture is single-message oriented at this
-   stage, the queue depth of BT is of no concern. */
+/*
+ * Typical "Get BT Capabilities" values are 2-3 retries, 5-10 seconds,
+ * and 64 byte buffers.  However, one HP implementation wants 255 bytes of
+ * buffer (with a documented message of 160 bytes) so go for the max.
+ * Since the Open IPMI architecture is single-message oriented at this
+ * stage, the queue depth of BT is of no concern.
+ */
 
 #define BT_NORMAL_TIMEOUT       5       /* seconds */
 #define BT_NORMAL_RETRY_LIMIT   2
 #define BT_RESET_DELAY          6       /* seconds after warm reset */
 
-/* States are written in chronological order and usually cover
-   multiple rows of the state table discussion in the IPMI spec. */
+/*
+ * States are written in chronological order and usually cover
+ * multiple rows of the state table discussion in the IPMI spec.
+ */
 
 enum bt_states {
         BT_STATE_IDLE = 0,      /* Order is critical in this list */
@@ -76,10 +82,12 @@ enum bt_states {
         BT_STATE_LONG_BUSY      /* BT doesn't get hosed :-) */
 };
 
-/* Macros seen at the end of state "case" blocks.  They help with legibility
-   and debugging. */
+/*
+ * Macros seen at the end of state "case" blocks.  They help with legibility
+ * and debugging.
+ */
 
-#define BT_STATE_CHANGE(X,Y) { bt->state = X; return Y; }
+#define BT_STATE_CHANGE(X, Y) { bt->state = X; return Y; }
 
 #define BT_SI_SM_RETURN(Y)   { last_printed = BT_STATE_PRINTME; return Y; }
 
@@ -110,11 +118,13 @@ struct si_sm_data {
 #define BT_H_BUSY       0x40
 #define BT_B_BUSY       0x80
 
-/* Some bits are toggled on each write: write once to set it, once
-   more to clear it; writing a zero does nothing.  To absolutely
-   clear it, check its state and write if set.  This avoids the "get
-   current then use as mask" scheme to modify one bit.  Note that the
-   variable "bt" is hardcoded into these macros. */
+/*
+ * Some bits are toggled on each write: write once to set it, once
+ * more to clear it; writing a zero does nothing.  To absolutely
+ * clear it, check its state and write if set.  This avoids the "get
+ * current then use as mask" scheme to modify one bit.  Note that the
+ * variable "bt" is hardcoded into these macros.
+ */
 
 #define BT_STATUS       bt->io->inputb(bt->io, 0)
 #define BT_CONTROL(x)   bt->io->outputb(bt->io, 0, x)
@@ -125,8 +135,10 @@ struct si_sm_data {
 #define BT_INTMASK_R    bt->io->inputb(bt->io, 2)
 #define BT_INTMASK_W(x) bt->io->outputb(bt->io, 2, x)
 
-/* Convenience routines for debugging.  These are not multi-open safe!
-   Note the macros have hardcoded variables in them. */
+/*
+ * Convenience routines for debugging.  These are not multi-open safe!
+ * Note the macros have hardcoded variables in them.
+ */
 
 static char *state2txt(unsigned char state)
 {
@@ -182,7 +194,8 @@ static char *status2txt(unsigned char status)
 static unsigned int bt_init_data(struct si_sm_data *bt, struct si_sm_io *io)
 {
         memset(bt, 0, sizeof(struct si_sm_data));
-        if (bt->io != io) {             /* external: one-time only things */
+        if (bt->io != io) {
+                /* external: one-time only things */
                 bt->io = io;
                 bt->seq = 0;
         }
@@ -229,7 +242,7 @@ static int bt_start_transaction(struct si_sm_data *bt,
                 printk(KERN_WARNING "BT: +++++++++++++++++ New command\n");
                 printk(KERN_WARNING "BT: NetFn/LUN CMD [%d data]:", size - 2);
                 for (i = 0; i < size; i ++)
-                        printk (" %02x", data[i]);
+                        printk(" %02x", data[i]);
                 printk("\n");
         }
         bt->write_data[0] = size + 1;   /* all data plus seq byte */
@@ -246,8 +259,10 @@ static int bt_start_transaction(struct si_sm_data *bt,
         return 0;
 }
 
-/* After the upper state machine has been told SI_SM_TRANSACTION_COMPLETE
-   it calls this.  Strip out the length and seq bytes. */
+/*
+ * After the upper state machine has been told SI_SM_TRANSACTION_COMPLETE
+ * it calls this.  Strip out the length and seq bytes.
+ */
 
 static int bt_get_result(struct si_sm_data *bt,
                          unsigned char *data,
@@ -269,10 +284,10 @@ static int bt_get_result(struct si_sm_data *bt,
                 memcpy(data + 2, bt->read_data + 4, msg_len - 2);
 
         if (bt_debug & BT_DEBUG_MSG) {
-                printk (KERN_WARNING "BT: result %d bytes:", msg_len);
+                printk(KERN_WARNING "BT: result %d bytes:", msg_len);
                 for (i = 0; i < msg_len; i++)
                         printk(" %02x", data[i]);
-                printk ("\n");
+                printk("\n");
         }
         return msg_len;
 }
@@ -292,8 +307,10 @@ static void reset_flags(struct si_sm_data *bt)
         BT_INTMASK_W(BT_BMC_HWRST);
 }
 
-/* Get rid of an unwanted/stale response.  This should only be needed for
-   BMCs that support multiple outstanding requests. */
+/*
+ * Get rid of an unwanted/stale response.  This should only be needed for
+ * BMCs that support multiple outstanding requests.
+ */
 
 static void drain_BMC2HOST(struct si_sm_data *bt)
 {
@@ -326,8 +343,8 @@ static inline void write_all_bytes(struct si_sm_data *bt)
                 printk(KERN_WARNING "BT: write %d bytes seq=0x%02X",
                         bt->write_count, bt->seq);
                 for (i = 0; i < bt->write_count; i++)
-                        printk (" %02x", bt->write_data[i]);
-                printk ("\n");
+                        printk(" %02x", bt->write_data[i]);
+                printk("\n");
         }
         for (i = 0; i < bt->write_count; i++)
                 HOST2BMC(bt->write_data[i]);
@@ -337,8 +354,10 @@ static inline int read_all_bytes(struct si_sm_data *bt)
 {
         unsigned char i;
 
-        /* length is "framing info", minimum = 4: NetFn, Seq, Cmd, cCode.
-           Keep layout of first four bytes aligned with write_data[] */
+        /*
+         * length is "framing info", minimum = 4: NetFn, Seq, Cmd, cCode.
+         * Keep layout of first four bytes aligned with write_data[]
+         */
 
         bt->read_data[0] = BMC2HOST;
         bt->read_count = bt->read_data[0];
@@ -362,8 +381,8 @@ static inline int read_all_bytes(struct si_sm_data *bt)
                 if (max > 16)
                         max = 16;
                 for (i = 0; i < max; i++)
-                        printk (" %02x", bt->read_data[i]);
-                printk ("%s\n", bt->read_count == max ? "" : " ...");
+                        printk(KERN_CONT " %02x", bt->read_data[i]);
+                printk(KERN_CONT "%s\n", bt->read_count == max ? "" : " ...");
         }
 
         /* per the spec, the (NetFn[1], Seq[2], Cmd[3]) tuples must match */
@@ -402,8 +421,10 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
         printk(KERN_WARNING "IPMI BT: %s in %s %s ",    /* open-ended line */
                 reason, STATE2TXT, STATUS2TXT);
 
-        /* Per the IPMI spec, retries are based on the sequence number
-           known only to this module, so manage a restart here. */
+        /*
+         * Per the IPMI spec, retries are based on the sequence number
+         * known only to this module, so manage a restart here.
+         */
         (bt->error_retries)++;
         if (bt->error_retries < bt->BT_CAP_retries) {
                 printk("%d retries left\n",
@@ -412,8 +433,8 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
                 return SI_SM_CALL_WITHOUT_DELAY;
         }
 
-        printk("failed %d retries, sending error response\n",
-                bt->BT_CAP_retries);
+        printk(KERN_WARNING "failed %d retries, sending error response\n",
+               bt->BT_CAP_retries);
         if (!bt->nonzero_status)
                 printk(KERN_ERR "IPMI BT: stuck, try power cycle\n");
 
@@ -424,8 +445,10 @@ static enum si_sm_result error_recovery(struct si_sm_data *bt,
                 return SI_SM_CALL_WITHOUT_DELAY;
         }
 
-        /* Concoct a useful error message, set up the next state, and
-           be done with this sequence. */
+        /*
+         * Concoct a useful error message, set up the next state, and
+         * be done with this sequence.
+         */
 
         bt->state = BT_STATE_IDLE;
         switch (cCode) {
@@ -461,10 +484,12 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                 last_printed = bt->state;
         }
 
-        /* Commands that time out may still (eventually) provide a response.
-           This stale response will get in the way of a new response so remove
-           it if possible (hopefully during IDLE).  Even if it comes up later
-           it will be rejected by its (now-forgotten) seq number. */
+        /*
+         * Commands that time out may still (eventually) provide a response.
+         * This stale response will get in the way of a new response so remove
+         * it if possible (hopefully during IDLE).  Even if it comes up later
+         * it will be rejected by its (now-forgotten) seq number.
+         */
 
         if ((bt->state < BT_STATE_WRITE_BYTES) && (status & BT_B2H_ATN)) {
                 drain_BMC2HOST(bt);
@@ -472,7 +497,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
         }
 
         if ((bt->state != BT_STATE_IDLE) &&
-            (bt->state <  BT_STATE_PRINTME)) {          /* check timeout */
+            (bt->state <  BT_STATE_PRINTME)) {
+                /* check timeout */
                 bt->timeout -= time;
                 if ((bt->timeout < 0) && (bt->state < BT_STATE_RESET1))
                         return error_recovery(bt,
@@ -482,8 +508,10 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
 
         switch (bt->state) {
 
-        /* Idle state first checks for asynchronous messages from another
-           channel, then does some opportunistic housekeeping. */
+        /*
+         * Idle state first checks for asynchronous messages from another
+         * channel, then does some opportunistic housekeeping.
+         */
 
         case BT_STATE_IDLE:
                 if (status & BT_SMS_ATN) {
@@ -531,16 +559,19 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                         BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
                 BT_CONTROL(BT_H_BUSY);          /* set */
 
-                /* Uncached, ordered writes should just proceeed serially but
-                   some BMCs don't clear B2H_ATN with one hit.  Fast-path a
-                   workaround without too much penalty to the general case. */
+                /*
+                 * Uncached, ordered writes should just proceeed serially but
+                 * some BMCs don't clear B2H_ATN with one hit.  Fast-path a
+                 * workaround without too much penalty to the general case.
+                 */
 
                 BT_CONTROL(BT_B2H_ATN);         /* clear it to ACK the BMC */
                 BT_STATE_CHANGE(BT_STATE_CLEAR_B2H,
                                 SI_SM_CALL_WITHOUT_DELAY);
 
         case BT_STATE_CLEAR_B2H:
-                if (status & BT_B2H_ATN) {      /* keep hitting it */
+                if (status & BT_B2H_ATN) {
+                        /* keep hitting it */
                         BT_CONTROL(BT_B2H_ATN);
                         BT_SI_SM_RETURN(SI_SM_CALL_WITH_DELAY);
                 }
@@ -548,7 +579,8 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                                 SI_SM_CALL_WITHOUT_DELAY);
 
         case BT_STATE_READ_BYTES:
-                if (!(status & BT_H_BUSY))      /* check in case of retry */
+                if (!(status & BT_H_BUSY))
+                        /* check in case of retry */
                         BT_CONTROL(BT_H_BUSY);
                 BT_CONTROL(BT_CLR_RD_PTR);      /* start of BMC2HOST buffer */
                 i = read_all_bytes(bt);         /* true == packet seq match */
@@ -599,8 +631,10 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
                 BT_STATE_CHANGE(BT_STATE_XACTION_START,
                                 SI_SM_CALL_WITH_DELAY);
 
-        /* Get BT Capabilities, using timing of upper level state machine.
-           Set outreqs to prevent infinite loop on timeout. */
+        /*
+         * Get BT Capabilities, using timing of upper level state machine.
+         * Set outreqs to prevent infinite loop on timeout.
+         */
         case BT_STATE_CAPABILITIES_BEGIN:
                 bt->BT_CAP_outreqs = 1;
                 {
@@ -638,10 +672,12 @@ static enum si_sm_result bt_event(struct si_sm_data *bt, long time)
 
 static int bt_detect(struct si_sm_data *bt)
 {
-        /* It's impossible for the BT status and interrupt registers to be
-           all 1's, (assuming a properly functioning, self-initialized BMC)
-           but that's what you get from reading a bogus address, so we
-           test that first.  The calling routine uses negative logic. */
+        /*
+         * It's impossible for the BT status and interrupt registers to be
+         * all 1's, (assuming a properly functioning, self-initialized BMC)
+         * but that's what you get from reading a bogus address, so we
+         * test that first.  The calling routine uses negative logic.
+         */
 
         if ((BT_STATUS == 0xFF) && (BT_INTMASK_R == 0xFF))
                 return 1;
@@ -658,8 +694,7 @@ static int bt_size(void)
         return sizeof(struct si_sm_data);
 }
 
-struct si_sm_handlers bt_smi_handlers =
-{
+struct si_sm_handlers bt_smi_handlers = {
         .init_data              = bt_init_data,
         .start_transaction      = bt_start_transaction,
         .get_result             = bt_get_result,
diff --git a/drivers/char/ipmi/ipmi_kcs_sm.c b/drivers/char/ipmi/ipmi_kcs_sm.c
index c1b8228cb7b6..80704875794c 100644
--- a/drivers/char/ipmi/ipmi_kcs_sm.c
+++ b/drivers/char/ipmi/ipmi_kcs_sm.c
@@ -60,37 +60,58 @@ MODULE_PARM_DESC(kcs_debug, "debug bitmask, 1=enable, 2=messages, 4=states");
 
 /* The states the KCS driver may be in. */
 enum kcs_states {
-        KCS_IDLE,               /* The KCS interface is currently
-                                   doing nothing. */
-        KCS_START_OP,           /* We are starting an operation.  The
-                                   data is in the output buffer, but
-                                   nothing has been done to the
-                                   interface yet.  This was added to
-                                   the state machine in the spec to
-                                   wait for the initial IBF. */
-        KCS_WAIT_WRITE_START,   /* We have written a write cmd to the
-                                   interface. */
-        KCS_WAIT_WRITE,         /* We are writing bytes to the
-                                   interface. */
-        KCS_WAIT_WRITE_END,     /* We have written the write end cmd
-                                   to the interface, and still need to
-                                   write the last byte. */
-        KCS_WAIT_READ,          /* We are waiting to read data from
-                                   the interface. */
-        KCS_ERROR0,             /* State to transition to the error
-                                   handler, this was added to the
-                                   state machine in the spec to be
-                                   sure IBF was there. */
-        KCS_ERROR1,             /* First stage error handler, wait for
-                                   the interface to respond. */
-        KCS_ERROR2,             /* The abort cmd has been written,
-                                   wait for the interface to
-                                   respond. */
-        KCS_ERROR3,             /* We wrote some data to the
-                                   interface, wait for it to switch to
-                                   read mode. */
-        KCS_HOSED               /* The hardware failed to follow the
-                                   state machine. */
+        /* The KCS interface is currently doing nothing. */
+        KCS_IDLE,
+
+        /*
+         * We are starting an operation.  The data is in the output
+         * buffer, but nothing has been done to the interface yet.  This
+         * was added to the state machine in the spec to wait for the
+         * initial IBF.
+         */
+        KCS_START_OP,
+
+        /* We have written a write cmd to the interface. */
+        KCS_WAIT_WRITE_START,
+
+        /* We are writing bytes to the interface. */
+        KCS_WAIT_WRITE,
+
+        /*
+         * We have written the write end cmd to the interface, and
+         * still need to write the last byte.
+         */
+        KCS_WAIT_WRITE_END,
+
+        /* We are waiting to read data from the interface. */
+        KCS_WAIT_READ,
+
+        /*
+         * State to transition to the error handler, this was added to
+         * the state machine in the spec to be sure IBF was there.
+         */
+        KCS_ERROR0,
+
+        /*
+         * First stage error handler, wait for the interface to
+         * respond.
+         */
+        KCS_ERROR1,
+
+        /*
+         * The abort cmd has been written, wait for the interface to
+         * respond.
+         */
+        KCS_ERROR2,
+
+        /*
+         * We wrote some data to the interface, wait for it to switch
+         * to read mode.
+         */
+        KCS_ERROR3,
+
+        /* The hardware failed to follow the state machine. */
+        KCS_HOSED
 };
 
 #define MAX_KCS_READ_SIZE IPMI_MAX_MSG_LENGTH
@@ -102,8 +123,7 @@ enum kcs_states {
 #define MAX_ERROR_RETRIES 10
 #define ERROR0_OBF_WAIT_JIFFIES (2*HZ)
 
-struct si_sm_data
-{
+struct si_sm_data {
         enum kcs_states  state;
         struct si_sm_io *io;
         unsigned char    write_data[MAX_KCS_WRITE_SIZE];
@@ -187,7 +207,8 @@ static inline void start_error_recovery(struct si_sm_data *kcs, char *reason)
         (kcs->error_retries)++;
         if (kcs->error_retries > MAX_ERROR_RETRIES) {
                 if (kcs_debug & KCS_DEBUG_ENABLE)
-                        printk(KERN_DEBUG "ipmi_kcs_sm: kcs hosed: %s\n", reason);
+                        printk(KERN_DEBUG "ipmi_kcs_sm: kcs hosed: %s\n",
+                               reason);
                 kcs->state = KCS_HOSED;
         } else {
                 kcs->error0_timeout = jiffies + ERROR0_OBF_WAIT_JIFFIES;
@@ -271,10 +292,9 @@ static int start_kcs_transaction(struct si_sm_data *kcs, unsigned char *data,
 
         if (kcs_debug & KCS_DEBUG_MSG) {
                 printk(KERN_DEBUG "start_kcs_transaction -");
-                for (i = 0; i < size; i ++) {
+                for (i = 0; i < size; i++)
                         printk(" %02x", (unsigned char) (data [i]));
-                }
-                printk ("\n");
+                printk("\n");
         }
         kcs->error_retries = 0;
         memcpy(kcs->write_data, data, size);
@@ -305,9 +325,11 @@ static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
                 kcs->read_pos = 3;
         }
         if (kcs->truncated) {
-                /* Report a truncated error.  We might overwrite
-                   another error, but that's too bad, the user needs
-                   to know it was truncated. */
+                /*
+                 * Report a truncated error.  We might overwrite
+                 * another error, but that's too bad, the user needs
+                 * to know it was truncated.
+                 */
                 data[2] = IPMI_ERR_MSG_TRUNCATED;
                 kcs->truncated = 0;
         }
@@ -315,9 +337,11 @@ static int get_kcs_result(struct si_sm_data *kcs, unsigned char *data,
         return kcs->read_pos;
 }
 
-/* This implements the state machine defined in the IPMI manual, see
-   that for details on how this works.  Divide that flowchart into
-   sections delimited by "Wait for IBF" and this will become clear. */
+/*
+ * This implements the state machine defined in the IPMI manual, see
+ * that for details on how this works.  Divide that flowchart into
+ * sections delimited by "Wait for IBF" and this will become clear.
+ */
 static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
 {
         unsigned char status;
@@ -388,11 +412,12 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                         write_next_byte(kcs);
                 }
                 break;
-                
+
         case KCS_WAIT_WRITE_END:
                 if (state != KCS_WRITE_STATE) {
                         start_error_recovery(kcs,
-                                             "Not in write state for write end");
+                                             "Not in write state"
+                                             " for write end");
                         break;
                 }
                 clear_obf(kcs, status);
@@ -413,13 +438,15 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                                 return SI_SM_CALL_WITH_DELAY;
                         read_next_byte(kcs);
                 } else {
-                        /* We don't implement this exactly like the state
-                           machine in the spec.  Some broken hardware
-                           does not write the final dummy byte to the
-                           read register.  Thus obf will never go high
-                           here.  We just go straight to idle, and we
-                           handle clearing out obf in idle state if it
-                           happens to come in. */
+                        /*
+                         * We don't implement this exactly like the state
+                         * machine in the spec.  Some broken hardware
+                         * does not write the final dummy byte to the
+                         * read register.  Thus obf will never go high
+                         * here.  We just go straight to idle, and we
+                         * handle clearing out obf in idle state if it
+                         * happens to come in.
+                         */
                         clear_obf(kcs, status);
                         kcs->orig_write_count = 0;
                         kcs->state = KCS_IDLE;
@@ -430,7 +457,8 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
         case KCS_ERROR0:
                 clear_obf(kcs, status);
                 status = read_status(kcs);
-                if  (GET_STATUS_OBF(status)) /* controller isn't responding */
+                if (GET_STATUS_OBF(status))
+                        /* controller isn't responding */
                         if (time_before(jiffies, kcs->error0_timeout))
                                 return SI_SM_CALL_WITH_TICK_DELAY;
                 write_cmd(kcs, KCS_GET_STATUS_ABORT);
@@ -442,7 +470,7 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                 write_data(kcs, 0);
                 kcs->state = KCS_ERROR2;
                 break;
-                
+
         case KCS_ERROR2:
                 if (state != KCS_READ_STATE) {
                         start_error_recovery(kcs,
@@ -456,7 +484,7 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                 write_data(kcs, KCS_READ_BYTE);
                 kcs->state = KCS_ERROR3;
                 break;
-                
+
         case KCS_ERROR3:
                 if (state != KCS_IDLE_STATE) {
                         start_error_recovery(kcs,
@@ -475,7 +503,7 @@ static enum si_sm_result kcs_event(struct si_sm_data *kcs, long time)
                         return SI_SM_TRANSACTION_COMPLETE;
                 }
                 break;
-                        
+
         case KCS_HOSED:
                 break;
         }
@@ -495,10 +523,12 @@ static int kcs_size(void)
 
 static int kcs_detect(struct si_sm_data *kcs)
 {
-        /* It's impossible for the KCS status register to be all 1's,
-           (assuming a properly functioning, self-initialized BMC)
-           but that's what you get from reading a bogus address, so we
-           test that first. */
+        /*
+         * It's impossible for the KCS status register to be all 1's,
+         * (assuming a properly functioning, self-initialized BMC)
+         * but that's what you get from reading a bogus address, so we
+         * test that first.
+         */
         if (read_status(kcs) == 0xff)
                 return 1;
 
@@ -509,8 +539,7 @@ static void kcs_cleanup(struct si_sm_data *kcs)
 {
 }
 
-struct si_sm_handlers kcs_smi_handlers =
-{
+struct si_sm_handlers kcs_smi_handlers = {
         .init_data         = init_kcs_data,
         .start_transaction = start_kcs_transaction,
         .get_result        = get_kcs_result,
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index 32b2b22996dc..8a59aaa21be5 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -47,7 +47,7 @@
 
 #define PFX "IPMI message handler: "
 
-#define IPMI_DRIVER_VERSION "39.1"
+#define IPMI_DRIVER_VERSION "39.2"
 
 static struct ipmi_recv_msg *ipmi_alloc_recv_msg(void);
 static int ipmi_init_msghandler(void);
@@ -63,16 +63,16 @@ static struct proc_dir_entry *proc_ipmi_root;
 
 #define MAX_EVENTS_IN_QUEUE     25
 
-/* Don't let a message sit in a queue forever, always time it with at lest
-   the max message timer.  This is in milliseconds. */
+/*
+ * Don't let a message sit in a queue forever, always time it with at lest
+ * the max message timer.  This is in milliseconds.
+ */
 #define MAX_MSG_TIMEOUT         60000
 
-
 /*
  * The main "user" data structure.
  */
-struct ipmi_user
-{
+struct ipmi_user {
         struct list_head link;
 
         /* Set to "0" when the user is destroyed. */
@@ -91,8 +91,7 @@ struct ipmi_user
         int gets_events;
 };
 
-struct cmd_rcvr
-{
+struct cmd_rcvr {
         struct list_head link;
 
         ipmi_user_t   user;
@@ -106,12 +105,12 @@ struct cmd_rcvr
          * or change any data until the RCU period completes.  So we
          * use this next variable during mass deletion so we can have
          * a list and don't have to wait and restart the search on
-         * every individual deletion of a command. */
+         * every individual deletion of a command.
+         */
         struct cmd_rcvr *next;
 };
 
-struct seq_table
-{
+struct seq_table {
         unsigned int         inuse : 1;
         unsigned int         broadcast : 1;
 
@@ -119,53 +118,60 @@ struct seq_table
         unsigned long        orig_timeout;
         unsigned int         retries_left;
 
-        /* To verify on an incoming send message response that this is
-           the message that the response is for, we keep a sequence id
-           and increment it every time we send a message. */
+        /*
+         * To verify on an incoming send message response that this is
+         * the message that the response is for, we keep a sequence id
+         * and increment it every time we send a message.
+         */
         long                 seqid;
 
-        /* This is held so we can properly respond to the message on a
-           timeout, and it is used to hold the temporary data for
-           retransmission, too. */
+        /*
+         * This is held so we can properly respond to the message on a
+         * timeout, and it is used to hold the temporary data for
+         * retransmission, too.
+         */
         struct ipmi_recv_msg *recv_msg;
 };
 
-/* Store the information in a msgid (long) to allow us to find a
-   sequence table entry from the msgid. */
+/*
+ * Store the information in a msgid (long) to allow us to find a
+ * sequence table entry from the msgid.
+ */
 #define STORE_SEQ_IN_MSGID(seq, seqid) (((seq&0xff)<<26) | (seqid&0x3ffffff))
 
 #define GET_SEQ_FROM_MSGID(msgid, seq, seqid) \
         do {                                                            \
                 seq = ((msgid >> 26) & 0x3f);                           \
                 seqid = (msgid & 0x3fffff);                             \
-        } while (0)
+        } while (0)
 
 #define NEXT_SEQID(seqid) (((seqid) + 1) & 0x3fffff)
 
-struct ipmi_channel
-{
+struct ipmi_channel {
         unsigned char medium;
         unsigned char protocol;
 
-        /* My slave address.  This is initialized to IPMI_BMC_SLAVE_ADDR,
-           but may be changed by the user. */
+        /*
+         * My slave address.  This is initialized to IPMI_BMC_SLAVE_ADDR,
+         * but may be changed by the user.
+         */
         unsigned char address;
 
-        /* My LUN.  This should generally stay the SMS LUN, but just in
-           case... */
+        /*
+         * My LUN.  This should generally stay the SMS LUN, but just in
+         * case...
+         */
         unsigned char lun;
 };
 
 #ifdef CONFIG_PROC_FS
-struct ipmi_proc_entry
-{
+struct ipmi_proc_entry {
         char                   *name;
         struct ipmi_proc_entry *next;
 };
 #endif
 
-struct bmc_device
-{
+struct bmc_device {
         struct platform_device *dev;
         struct ipmi_device_id  id;
         unsigned char          guid[16];
@@ -186,10 +192,108 @@ struct bmc_device
         struct device_attribute aux_firmware_rev_attr;
 };
 
+/*
+ * Various statistics for IPMI, these index stats[] in the ipmi_smi
+ * structure.
+ */
+enum ipmi_stat_indexes {
+        /* Commands we got from the user that were invalid. */
+        IPMI_STAT_sent_invalid_commands = 0,
+
+        /* Commands we sent to the MC. */
+        IPMI_STAT_sent_local_commands,
+
+        /* Responses from the MC that were delivered to a user. */
+        IPMI_STAT_handled_local_responses,
+
+        /* Responses from the MC that were not delivered to a user. */
+        IPMI_STAT_unhandled_local_responses,
+
+        /* Commands we sent out to the IPMB bus. */
+        IPMI_STAT_sent_ipmb_commands,
+
+        /* Commands sent on the IPMB that had errors on the SEND CMD */
+        IPMI_STAT_sent_ipmb_command_errs,
+
+        /* Each retransmit increments this count. */
+        IPMI_STAT_retransmitted_ipmb_commands,
+
+        /*
+         * When a message times out (runs out of retransmits) this is
+         * incremented.
+         */
+        IPMI_STAT_timed_out_ipmb_commands,
+
+        /*
+         * This is like above, but for broadcasts.  Broadcasts are
+         * *not* included in the above count (they are expected to
+         * time out).
+         */
+        IPMI_STAT_timed_out_ipmb_broadcasts,
+
+        /* Responses I have sent to the IPMB bus. */
+        IPMI_STAT_sent_ipmb_responses,
+
+        /* The response was delivered to the user. */
+        IPMI_STAT_handled_ipmb_responses,
+
+        /* The response had invalid data in it. */
+        IPMI_STAT_invalid_ipmb_responses,
+
+        /* The response didn't have anyone waiting for it. */
+        IPMI_STAT_unhandled_ipmb_responses,
+
+        /* Commands we sent out to the IPMB bus. */
+        IPMI_STAT_sent_lan_commands,
+
+        /* Commands sent on the IPMB that had errors on the SEND CMD */
+        IPMI_STAT_sent_lan_command_errs,
+
+        /* Each retransmit increments this count. */
+        IPMI_STAT_retransmitted_lan_commands,
+
+        /*
+         * When a message times out (runs out of retransmits) this is
+         * incremented.
+         */
+        IPMI_STAT_timed_out_lan_commands,
+
+        /* Responses I have sent to the IPMB bus. */
+        IPMI_STAT_sent_lan_responses,
+
+        /* The response was delivered to the user. */
+        IPMI_STAT_handled_lan_responses,
+
+        /* The response had invalid data in it. */
+        IPMI_STAT_invalid_lan_responses,
+
+        /* The response didn't have anyone waiting for it. */
+        IPMI_STAT_unhandled_lan_responses,
+
+        /* The command was delivered to the user. */
+        IPMI_STAT_handled_commands,
+
+        /* The command had invalid data in it. */
+        IPMI_STAT_invalid_commands,
+
+        /* The command didn't have anyone waiting for it. */
+        IPMI_STAT_unhandled_commands,
+
+        /* Invalid data in an event. */
+        IPMI_STAT_invalid_events,
+
+        /* Events that were received with the proper format. */
+        IPMI_STAT_events,
+
+
+        /* This *must* remain last, add new values above this. */
+        IPMI_NUM_STATS
+};
+
+
 #define IPMI_IPMB_NUM_SEQ       64
 #define IPMI_MAX_CHANNELS       16
-struct ipmi_smi
-{
+struct ipmi_smi {
         /* What interface number are we? */
         int intf_num;
 
@@ -198,8 +302,10 @@ struct ipmi_smi
         /* Used for a list of interfaces. */
         struct list_head link;
 
-        /* The list of upper layers that are using me.  seq_lock
-         * protects this. */
+        /*
+         * The list of upper layers that are using me.  seq_lock
+         * protects this.
+         */
         struct list_head users;
 
         /* Information to supply to users. */
@@ -213,10 +319,12 @@ struct ipmi_smi
         char *my_dev_name;
         char *sysfs_name;
 
-        /* This is the lower-layer's sender routine.  Note that you
+        /*
+         * This is the lower-layer's sender routine.  Note that you
          * must either be holding the ipmi_interfaces_mutex or be in
          * an umpreemptible region to use this.  You must fetch the
-         * value into a local variable and make sure it is not NULL. */
+         * value into a local variable and make sure it is not NULL.
+         */
         struct ipmi_smi_handlers *handlers;
         void                     *send_info;
 
@@ -229,34 +337,45 @@ struct ipmi_smi
         /* Driver-model device for the system interface. */
         struct device          *si_dev;
 
-        /* A table of sequence numbers for this interface.  We use the
-           sequence numbers for IPMB messages that go out of the
-           interface to match them up with their responses.  A routine
-           is called periodically to time the items in this list. */
+        /*
+         * A table of sequence numbers for this interface.  We use the
+         * sequence numbers for IPMB messages that go out of the
+         * interface to match them up with their responses.  A routine
+         * is called periodically to time the items in this list.
+         */
         spinlock_t       seq_lock;
         struct seq_table seq_table[IPMI_IPMB_NUM_SEQ];
         int curr_seq;
 
-        /* Messages that were delayed for some reason (out of memory,
-           for instance), will go in here to be processed later in a
-           periodic timer interrupt. */
+        /*
+         * Messages that were delayed for some reason (out of memory,
+         * for instance), will go in here to be processed later in a
+         * periodic timer interrupt.
+         */
         spinlock_t       waiting_msgs_lock;
         struct list_head waiting_msgs;
 
-        /* The list of command receivers that are registered for commands
-           on this interface. */
+        /*
+         * The list of command receivers that are registered for commands
+         * on this interface.
+         */
         struct mutex     cmd_rcvrs_mutex;
         struct list_head cmd_rcvrs;
 
-        /* Events that were queues because no one was there to receive
-           them. */
+        /*
+         * Events that were queues because no one was there to receive
+         * them.
+         */
         spinlock_t       events_lock; /* For dealing with event stuff. */
         struct list_head waiting_events;
         unsigned int     waiting_events_count; /* How many events in queue? */
-        int              delivering_events;
+        char             delivering_events;
+        char             event_msg_printed;
 
-        /* The event receiver for my BMC, only really used at panic
-           shutdown as a place to store this. */
+        /*
+         * The event receiver for my BMC, only really used at panic
+         * shutdown as a place to store this.
+         */
         unsigned char event_receiver;
         unsigned char event_receiver_lun;
         unsigned char local_sel_device;
@@ -268,14 +387,18 @@ struct ipmi_smi
         int auto_maintenance_timeout;
         spinlock_t maintenance_mode_lock; /* Used in a timer... */
 
-        /* A cheap hack, if this is non-null and a message to an
-           interface comes in with a NULL user, call this routine with
-           it.  Note that the message will still be freed by the
-           caller.  This only works on the system interface. */
+        /*
+         * A cheap hack, if this is non-null and a message to an
+         * interface comes in with a NULL user, call this routine with
+         * it.  Note that the message will still be freed by the
+         * caller.  This only works on the system interface.
+         */
         void (*null_user_handler)(ipmi_smi_t intf, struct ipmi_recv_msg *msg);
 
-        /* When we are scanning the channels for an SMI, this will
-           tell which channel we are scanning. */
+        /*
+         * When we are scanning the channels for an SMI, this will
+         * tell which channel we are scanning.
+         */
         int curr_channel;
 
         /* Channel information */
@@ -285,74 +408,14 @@ struct ipmi_smi
         struct proc_dir_entry *proc_dir;
         char                  proc_dir_name[10];
 
-        spinlock_t   counter_lock; /* For making counters atomic. */
-
-        /* Commands we got that were invalid. */
-        unsigned int sent_invalid_commands;
-
-        /* Commands we sent to the MC. */
-        unsigned int sent_local_commands;
-        /* Responses from the MC that were delivered to a user. */
-        unsigned int handled_local_responses;
-        /* Responses from the MC that were not delivered to a user. */
-        unsigned int unhandled_local_responses;
-
-        /* Commands we sent out to the IPMB bus. */
-        unsigned int sent_ipmb_commands;
-        /* Commands sent on the IPMB that had errors on the SEND CMD */
-        unsigned int sent_ipmb_command_errs;
-        /* Each retransmit increments this count. */
-        unsigned int retransmitted_ipmb_commands;
-        /* When a message times out (runs out of retransmits) this is
-           incremented. */
-        unsigned int timed_out_ipmb_commands;
-
-        /* This is like above, but for broadcasts.  Broadcasts are
-           *not* included in the above count (they are expected to
-           time out). */
-        unsigned int timed_out_ipmb_broadcasts;
+        atomic_t stats[IPMI_NUM_STATS];
 
-        /* Responses I have sent to the IPMB bus. */
-        unsigned int sent_ipmb_responses;
-
-        /* The response was delivered to the user. */
-        unsigned int handled_ipmb_responses;
-        /* The response had invalid data in it. */
-        unsigned int invalid_ipmb_responses;
-        /* The response didn't have anyone waiting for it. */
-        unsigned int unhandled_ipmb_responses;
-
-        /* Commands we sent out to the IPMB bus. */
-        unsigned int sent_lan_commands;
-        /* Commands sent on the IPMB that had errors on the SEND CMD */
-        unsigned int sent_lan_command_errs;
-        /* Each retransmit increments this count. */
-        unsigned int retransmitted_lan_commands;
-        /* When a message times out (runs out of retransmits) this is
-           incremented. */
-        unsigned int timed_out_lan_commands;
-
-        /* Responses I have sent to the IPMB bus. */
-        unsigned int sent_lan_responses;
-
-        /* The response was delivered to the user. */
-        unsigned int handled_lan_responses;
-        /* The response had invalid data in it. */
-        unsigned int invalid_lan_responses;
-        /* The response didn't have anyone waiting for it. */
-        unsigned int unhandled_lan_responses;
-
-        /* The command was delivered to the user. */
-        unsigned int handled_commands;
-        /* The command had invalid data in it. */
-        unsigned int invalid_commands;
-        /* The command didn't have anyone waiting for it. */
-        unsigned int unhandled_commands;
-
-        /* Invalid data in an event. */
-        unsigned int invalid_events;
-        /* Events that were received with the proper format. */
-        unsigned int events;
+        /*
+         * run_to_completion duplicate of smb_info, smi_info
+         * and ipmi_serial_info structures. Used to decrease numbers of
+         * parameters passed by "low" level IPMI code.
+         */
+        int run_to_completion;
 };
 #define to_si_intf_from_dev(device) container_of(device, struct ipmi_smi, dev)
 
@@ -368,12 +431,19 @@ static DEFINE_MUTEX(ipmidriver_mutex);
 static LIST_HEAD(ipmi_interfaces);
 static DEFINE_MUTEX(ipmi_interfaces_mutex);
 
-/* List of watchers that want to know when smi's are added and
-   deleted. */
+/*
+ * List of watchers that want to know when smi's are added and deleted.
+ */
 static LIST_HEAD(smi_watchers);
 static DEFINE_MUTEX(smi_watchers_mutex);
 
 
+#define ipmi_inc_stat(intf, stat) \
+        atomic_inc(&(intf)->stats[IPMI_STAT_ ## stat])
+#define ipmi_get_stat(intf, stat) \
+        ((unsigned int) atomic_read(&(intf)->stats[IPMI_STAT_ ## stat]))
+
+
 static void free_recv_msg_list(struct list_head *q)
 {
         struct ipmi_recv_msg *msg, *msg2;
@@ -417,10 +487,8 @@ static void clean_up_interface_data(ipmi_smi_t intf)
 
         for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) {
                 if ((intf->seq_table[i].inuse)
-                    && (intf->seq_table[i].recv_msg))
-                {
+                                        && (intf->seq_table[i].recv_msg))
                         ipmi_free_recv_msg(intf->seq_table[i].recv_msg);
-                }
         }
 }
 
@@ -487,6 +555,7 @@ int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher)
         }
         return -ENOMEM;
 }
+EXPORT_SYMBOL(ipmi_smi_watcher_register);
 
 int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher)
 {
@@ -495,6 +564,7 @@ int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher)
         mutex_unlock(&smi_watchers_mutex);
         return 0;
 }
+EXPORT_SYMBOL(ipmi_smi_watcher_unregister);
 
 /*
  * Must be called with smi_watchers_mutex held.
@@ -530,8 +600,7 @@ ipmi_addr_equal(struct ipmi_addr *addr1, struct ipmi_addr *addr2)
         }
 
         if ((addr1->addr_type == IPMI_IPMB_ADDR_TYPE)
-            || (addr1->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
-        {
+            || (addr1->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) {
                 struct ipmi_ipmb_addr *ipmb_addr1
                     = (struct ipmi_ipmb_addr *) addr1;
                 struct ipmi_ipmb_addr *ipmb_addr2
@@ -559,9 +628,8 @@ ipmi_addr_equal(struct ipmi_addr *addr1, struct ipmi_addr *addr2)
 
 int ipmi_validate_addr(struct ipmi_addr *addr, int len)
 {
-        if (len < sizeof(struct ipmi_system_interface_addr)) {
+        if (len < sizeof(struct ipmi_system_interface_addr))
                 return -EINVAL;
-        }
 
         if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) {
                 if (addr->channel != IPMI_BMC_CHANNEL)
@@ -575,23 +643,21 @@ int ipmi_validate_addr(struct ipmi_addr *addr, int len)
                 return -EINVAL;
 
         if ((addr->addr_type == IPMI_IPMB_ADDR_TYPE)
-            || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
-        {
-                if (len < sizeof(struct ipmi_ipmb_addr)) {
+            || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) {
+                if (len < sizeof(struct ipmi_ipmb_addr))
                         return -EINVAL;
-                }
                 return 0;
         }
 
         if (addr->addr_type == IPMI_LAN_ADDR_TYPE) {
-                if (len < sizeof(struct ipmi_lan_addr)) {
+                if (len < sizeof(struct ipmi_lan_addr))
                         return -EINVAL;
-                }
                 return 0;
         }
 
         return -EINVAL;
 }
+EXPORT_SYMBOL(ipmi_validate_addr);
 
 unsigned int ipmi_addr_length(int addr_type)
 {
@@ -599,34 +665,28 @@ unsigned int ipmi_addr_length(int addr_type)
                 return sizeof(struct ipmi_system_interface_addr);
 
         if ((addr_type == IPMI_IPMB_ADDR_TYPE)
-            || (addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
-        {
+                        || (addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
                 return sizeof(struct ipmi_ipmb_addr);
-        }
 
         if (addr_type == IPMI_LAN_ADDR_TYPE)
                 return sizeof(struct ipmi_lan_addr);
 
         return 0;
 }
+EXPORT_SYMBOL(ipmi_addr_length);
 
 static void deliver_response(struct ipmi_recv_msg *msg)
 {
         if (!msg->user) {
                 ipmi_smi_t    intf = msg->user_msg_data;
-                unsigned long flags;
 
                 /* Special handling for NULL users. */
                 if (intf->null_user_handler) {
                         intf->null_user_handler(intf, msg);
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->handled_local_responses++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        ipmi_inc_stat(intf, handled_local_responses);
                 } else {
                         /* No handler, so give up. */
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->unhandled_local_responses++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        ipmi_inc_stat(intf, unhandled_local_responses);
                 }
                 ipmi_free_recv_msg(msg);
         } else {
@@ -646,9 +706,11 @@ deliver_err_response(struct ipmi_recv_msg *msg, int err)
         deliver_response(msg);
 }
 
-/* Find the next sequence number not being used and add the given
-   message with the given timeout to the sequence table.  This must be
-   called with the interface's seq_lock held. */
+/*
+ * Find the next sequence number not being used and add the given
+ * message with the given timeout to the sequence table.  This must be
+ * called with the interface's seq_lock held.
+ */
 static int intf_next_seq(ipmi_smi_t           intf,
                          struct ipmi_recv_msg *recv_msg,
                          unsigned long        timeout,
@@ -660,10 +722,8 @@ static int intf_next_seq(ipmi_smi_t           intf,
         int          rv = 0;
         unsigned int i;
 
-        for (i = intf->curr_seq;
-             (i+1)%IPMI_IPMB_NUM_SEQ != intf->curr_seq;
-             i = (i+1)%IPMI_IPMB_NUM_SEQ)
-        {
+        for (i = intf->curr_seq; (i+1)%IPMI_IPMB_NUM_SEQ != intf->curr_seq;
+                                        i = (i+1)%IPMI_IPMB_NUM_SEQ) {
                 if (!intf->seq_table[i].inuse)
                         break;
         }
@@ -671,8 +731,10 @@ static int intf_next_seq(ipmi_smi_t           intf,
         if (!intf->seq_table[i].inuse) {
                 intf->seq_table[i].recv_msg = recv_msg;
 
-                /* Start with the maximum timeout, when the send response
-                   comes in we will start the real timer. */
+                /*
+                 * Start with the maximum timeout, when the send response
+                 * comes in we will start the real timer.
+                 */
                 intf->seq_table[i].timeout = MAX_MSG_TIMEOUT;
                 intf->seq_table[i].orig_timeout = timeout;
                 intf->seq_table[i].retries_left = retries;
@@ -685,15 +747,17 @@ static int intf_next_seq(ipmi_smi_t           intf,
         } else {
                 rv = -EAGAIN;
         }
-        
+
         return rv;
 }
 
-/* Return the receive message for the given sequence number and
-   release the sequence number so it can be reused.  Some other data
-   is passed in to be sure the message matches up correctly (to help
-   guard against message coming in after their timeout and the
-   sequence number being reused). */
+/*
+ * Return the receive message for the given sequence number and
+ * release the sequence number so it can be reused.  Some other data
+ * is passed in to be sure the message matches up correctly (to help
+ * guard against message coming in after their timeout and the
+ * sequence number being reused).
+ */
 static int intf_find_seq(ipmi_smi_t           intf,
                          unsigned char        seq,
                          short                channel,
@@ -712,11 +776,9 @@ static int intf_find_seq(ipmi_smi_t           intf,
         if (intf->seq_table[seq].inuse) {
                 struct ipmi_recv_msg *msg = intf->seq_table[seq].recv_msg;
 
-                if ((msg->addr.channel == channel)
-                    && (msg->msg.cmd == cmd)
-                    && (msg->msg.netfn == netfn)
-                    && (ipmi_addr_equal(addr, &(msg->addr))))
-                {
+                if ((msg->addr.channel == channel) && (msg->msg.cmd == cmd)
+                                && (msg->msg.netfn == netfn)
+                                && (ipmi_addr_equal(addr, &(msg->addr)))) {
                         *recv_msg = msg;
                         intf->seq_table[seq].inuse = 0;
                         rv = 0;
@@ -741,11 +803,12 @@ static int intf_start_seq_timer(ipmi_smi_t intf,
         GET_SEQ_FROM_MSGID(msgid, seq, seqid);
 
         spin_lock_irqsave(&(intf->seq_lock), flags);
-        /* We do this verification because the user can be deleted
-           while a message is outstanding. */
+        /*
+         * We do this verification because the user can be deleted
+         * while a message is outstanding.
+         */
         if ((intf->seq_table[seq].inuse)
-            && (intf->seq_table[seq].seqid == seqid))
-        {
+                                && (intf->seq_table[seq].seqid == seqid)) {
                 struct seq_table *ent = &(intf->seq_table[seq]);
                 ent->timeout = ent->orig_timeout;
                 rv = 0;
@@ -770,11 +833,12 @@ static int intf_err_seq(ipmi_smi_t   intf,
         GET_SEQ_FROM_MSGID(msgid, seq, seqid);
 
         spin_lock_irqsave(&(intf->seq_lock), flags);
-        /* We do this verification because the user can be deleted
-           while a message is outstanding. */
+        /*
+         * We do this verification because the user can be deleted
+         * while a message is outstanding.
+         */
         if ((intf->seq_table[seq].inuse)
-            && (intf->seq_table[seq].seqid == seqid))
-        {
+                                && (intf->seq_table[seq].seqid == seqid)) {
                 struct seq_table *ent = &(intf->seq_table[seq]);
 
                 ent->inuse = 0;
@@ -800,24 +864,30 @@ int ipmi_create_user(unsigned int          if_num,
         int           rv = 0;
         ipmi_smi_t    intf;
 
-        /* There is no module usecount here, because it's not
-           required.  Since this can only be used by and called from
-           other modules, they will implicitly use this module, and
-           thus this can't be removed unless the other modules are
-           removed. */
+        /*
+         * There is no module usecount here, because it's not
+         * required.  Since this can only be used by and called from
+         * other modules, they will implicitly use this module, and
+         * thus this can't be removed unless the other modules are
+         * removed.
+         */
 
         if (handler == NULL)
                 return -EINVAL;
 
-        /* Make sure the driver is actually initialized, this handles
-           problems with initialization order. */
+        /*
+         * Make sure the driver is actually initialized, this handles
+         * problems with initialization order.
+         */
         if (!initialized) {
                 rv = ipmi_init_msghandler();
                 if (rv)
                         return rv;
 
-                /* The init code doesn't return an error if it was turned
-                   off, but it won't initialize.  Check that. */
+                /*
+                 * The init code doesn't return an error if it was turned
+                 * off, but it won't initialize.  Check that.
+                 */
                 if (!initialized)
                         return -ENODEV;
         }
@@ -858,8 +928,10 @@ int ipmi_create_user(unsigned int          if_num,
                 }
         }
 
-        /* Hold the lock so intf->handlers is guaranteed to be good
-         * until now */
+        /*
+         * Hold the lock so intf->handlers is guaranteed to be good
+         * until now
+         */
         mutex_unlock(&ipmi_interfaces_mutex);
 
         new_user->valid = 1;
@@ -876,6 +948,7 @@ out_kfree:
         kfree(new_user);
         return rv;
 }
+EXPORT_SYMBOL(ipmi_create_user);
 
 static void free_user(struct kref *ref)
 {
@@ -899,8 +972,7 @@ int ipmi_destroy_user(ipmi_user_t user)
 
         for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++) {
                 if (intf->seq_table[i].inuse
-                    && (intf->seq_table[i].recv_msg->user == user))
-                {
+                    && (intf->seq_table[i].recv_msg->user == user)) {
                         intf->seq_table[i].inuse = 0;
                         ipmi_free_recv_msg(intf->seq_table[i].recv_msg);
                 }
@@ -943,6 +1015,7 @@ int ipmi_destroy_user(ipmi_user_t user)
 
         return 0;
 }
+EXPORT_SYMBOL(ipmi_destroy_user);
 
 void ipmi_get_version(ipmi_user_t   user,
                       unsigned char *major,
@@ -951,6 +1024,7 @@ void ipmi_get_version(ipmi_user_t   user,
         *major = user->intf->ipmi_version_major;
         *minor = user->intf->ipmi_version_minor;
 }
+EXPORT_SYMBOL(ipmi_get_version);
 
 int ipmi_set_my_address(ipmi_user_t   user,
                         unsigned int  channel,
@@ -961,6 +1035,7 @@ int ipmi_set_my_address(ipmi_user_t   user,
         user->intf->channels[channel].address = address;
         return 0;
 }
+EXPORT_SYMBOL(ipmi_set_my_address);
 
 int ipmi_get_my_address(ipmi_user_t   user,
                         unsigned int  channel,
@@ -971,6 +1046,7 @@ int ipmi_get_my_address(ipmi_user_t   user,
         *address = user->intf->channels[channel].address;
         return 0;
 }
+EXPORT_SYMBOL(ipmi_get_my_address);
 
 int ipmi_set_my_LUN(ipmi_user_t   user,
                     unsigned int  channel,
@@ -981,6 +1057,7 @@ int ipmi_set_my_LUN(ipmi_user_t   user,
         user->intf->channels[channel].lun = LUN & 0x3;
         return 0;
 }
+EXPORT_SYMBOL(ipmi_set_my_LUN);
 
 int ipmi_get_my_LUN(ipmi_user_t   user,
                     unsigned int  channel,
@@ -991,6 +1068,7 @@ int ipmi_get_my_LUN(ipmi_user_t   user,
         *address = user->intf->channels[channel].lun;
         return 0;
 }
+EXPORT_SYMBOL(ipmi_get_my_LUN);
 
 int ipmi_get_maintenance_mode(ipmi_user_t user)
 {
@@ -1075,6 +1153,11 @@ int ipmi_set_gets_events(ipmi_user_t user, int val)
                 list_for_each_entry_safe(msg, msg2, &intf->waiting_events, link)
                         list_move_tail(&msg->link, &msgs);
                 intf->waiting_events_count = 0;
+                if (intf->event_msg_printed) {
+                        printk(KERN_WARNING PFX "Event queue no longer"
+                               " full\n");
+                        intf->event_msg_printed = 0;
+                }
 
                 intf->delivering_events = 1;
                 spin_unlock_irqrestore(&intf->events_lock, flags);
@@ -1094,6 +1177,7 @@ int ipmi_set_gets_events(ipmi_user_t user, int val)
 
         return 0;
 }
+EXPORT_SYMBOL(ipmi_set_gets_events);
 
 static struct cmd_rcvr *find_cmd_rcvr(ipmi_smi_t    intf,
                                       unsigned char netfn,
@@ -1159,6 +1243,7 @@ int ipmi_register_for_cmd(ipmi_user_t   user,
 
         return rv;
 }
+EXPORT_SYMBOL(ipmi_register_for_cmd);
 
 int ipmi_unregister_for_cmd(ipmi_user_t   user,
                             unsigned char netfn,
@@ -1196,19 +1281,13 @@ int ipmi_unregister_for_cmd(ipmi_user_t   user,
         }
         return rv;
 }
-
-void ipmi_user_set_run_to_completion(ipmi_user_t user, int val)
-{
-        ipmi_smi_t intf = user->intf;
-        if (intf->handlers)
-                intf->handlers->set_run_to_completion(intf->send_info, val);
-}
+EXPORT_SYMBOL(ipmi_unregister_for_cmd);
 
 static unsigned char
 ipmb_checksum(unsigned char *data, int size)
 {
         unsigned char csum = 0;
-        
+
         for (; size > 0; size--, data++)
                 csum += *data;
 
@@ -1250,8 +1329,10 @@ static inline void format_ipmb_msg(struct ipmi_smi_msg   *smi_msg,
                 = ipmb_checksum(&(smi_msg->data[i+6]),
                                 smi_msg->data_size-6);
 
-        /* Add on the checksum size and the offset from the
-           broadcast. */
+        /*
+         * Add on the checksum size and the offset from the
+         * broadcast.
+         */
         smi_msg->data_size += 1 + i;
 
         smi_msg->msgid = msgid;
@@ -1287,17 +1368,21 @@ static inline void format_lan_msg(struct ipmi_smi_msg   *smi_msg,
                 = ipmb_checksum(&(smi_msg->data[7]),
                                 smi_msg->data_size-7);
 
-        /* Add on the checksum size and the offset from the
-           broadcast. */
+        /*
+         * Add on the checksum size and the offset from the
+         * broadcast.
+         */
         smi_msg->data_size += 1;
 
         smi_msg->msgid = msgid;
 }
 
-/* Separate from ipmi_request so that the user does not have to be
-   supplied in certain circumstances (mainly at panic time).  If
-   messages are supplied, they will be freed, even if an error
-   occurs. */
+/*
+ * Separate from ipmi_request so that the user does not have to be
+ * supplied in certain circumstances (mainly at panic time).  If
+ * messages are supplied, they will be freed, even if an error
+ * occurs.
+ */
 static int i_ipmi_request(ipmi_user_t          user,
                           ipmi_smi_t           intf,
                           struct ipmi_addr     *addr,
@@ -1319,19 +1404,18 @@ static int i_ipmi_request(ipmi_user_t          user,
         struct ipmi_smi_handlers *handlers;
 
 
-        if (supplied_recv) {
+        if (supplied_recv)
                 recv_msg = supplied_recv;
-        } else {
+        else {
                 recv_msg = ipmi_alloc_recv_msg();
-                if (recv_msg == NULL) {
+                if (recv_msg == NULL)
                         return -ENOMEM;
-                }
         }
         recv_msg->user_msg_data = user_msg_data;
 
-        if (supplied_smi) {
+        if (supplied_smi)
                 smi_msg = (struct ipmi_smi_msg *) supplied_smi;
-        } else {
+        else {
                 smi_msg = ipmi_alloc_smi_msg();
                 if (smi_msg == NULL) {
                         ipmi_free_recv_msg(recv_msg);
@@ -1350,8 +1434,10 @@ static int i_ipmi_request(ipmi_user_t          user,
         if (user)
                 kref_get(&user->refcount);
         recv_msg->msgid = msgid;
-        /* Store the message to send in the receive message so timeout
-           responses can get the proper response data. */
+        /*
+         * Store the message to send in the receive message so timeout
+         * responses can get the proper response data.
+         */
         recv_msg->msg = *msg;
 
         if (addr->addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE) {
@@ -1365,9 +1451,7 @@ static int i_ipmi_request(ipmi_user_t          user,
 
                 smi_addr = (struct ipmi_system_interface_addr *) addr;
                 if (smi_addr->lun > 3) {
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EINVAL;
                         goto out_err;
                 }
@@ -1377,13 +1461,12 @@ static int i_ipmi_request(ipmi_user_t          user,
                 if ((msg->netfn == IPMI_NETFN_APP_REQUEST)
                     && ((msg->cmd == IPMI_SEND_MSG_CMD)
                         || (msg->cmd == IPMI_GET_MSG_CMD)
-                        || (msg->cmd == IPMI_READ_EVENT_MSG_BUFFER_CMD)))
-                {
-                        /* We don't let the user do these, since we manage
-                           the sequence numbers. */
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        || (msg->cmd == IPMI_READ_EVENT_MSG_BUFFER_CMD))) {
+                        /*
+                         * We don't let the user do these, since we manage
+                         * the sequence numbers.
+                         */
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EINVAL;
                         goto out_err;
                 }
@@ -1391,14 +1474,12 @@ static int i_ipmi_request(ipmi_user_t          user,
                 if (((msg->netfn == IPMI_NETFN_APP_REQUEST)
                       && ((msg->cmd == IPMI_COLD_RESET_CMD)
                           || (msg->cmd == IPMI_WARM_RESET_CMD)))
-                     || (msg->netfn == IPMI_NETFN_FIRMWARE_REQUEST))
-                {
+                     || (msg->netfn == IPMI_NETFN_FIRMWARE_REQUEST)) {
                         spin_lock_irqsave(&intf->maintenance_mode_lock, flags);
                         intf->auto_maintenance_timeout
                                 = IPMI_MAINTENANCE_MODE_TIMEOUT;
                         if (!intf->maintenance_mode
-                            && !intf->maintenance_mode_enable)
-                        {
+                            && !intf->maintenance_mode_enable) {
                                 intf->maintenance_mode_enable = 1;
                                 maintenance_mode_update(intf);
                         }
@@ -1407,9 +1488,7 @@ static int i_ipmi_request(ipmi_user_t          user,
                 }
 
                 if ((msg->data_len + 2) > IPMI_MAX_MSG_LENGTH) {
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EMSGSIZE;
                         goto out_err;
                 }
@@ -1421,31 +1500,23 @@ static int i_ipmi_request(ipmi_user_t          user,
                 if (msg->data_len > 0)
                         memcpy(&(smi_msg->data[2]), msg->data, msg->data_len);
                 smi_msg->data_size = msg->data_len + 2;
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->sent_local_commands++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, sent_local_commands);
         } else if ((addr->addr_type == IPMI_IPMB_ADDR_TYPE)
-                   || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE))
-        {
+                   || (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE)) {
                 struct ipmi_ipmb_addr *ipmb_addr;
                 unsigned char         ipmb_seq;
                 long                  seqid;
                 int                   broadcast = 0;
 
                 if (addr->channel >= IPMI_MAX_CHANNELS) {
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EINVAL;
                         goto out_err;
                 }
 
                 if (intf->channels[addr->channel].medium
-                    != IPMI_CHANNEL_MEDIUM_IPMB)
-                {
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                                        != IPMI_CHANNEL_MEDIUM_IPMB) {
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EINVAL;
                         goto out_err;
                 }
@@ -1457,9 +1528,11 @@ static int i_ipmi_request(ipmi_user_t          user,
                         retries = 4;
                 }
                 if (addr->addr_type == IPMI_IPMB_BROADCAST_ADDR_TYPE) {
-                    /* Broadcasts add a zero at the beginning of the
-                       message, but otherwise is the same as an IPMB
-                       address. */
+                    /*
+                     * Broadcasts add a zero at the beginning of the
+                     * message, but otherwise is the same as an IPMB
+                     * address.
+                     */
                     addr->addr_type = IPMI_IPMB_ADDR_TYPE;
                     broadcast = 1;
                 }
@@ -1469,21 +1542,19 @@ static int i_ipmi_request(ipmi_user_t          user,
                 if (retry_time_ms == 0)
                     retry_time_ms = 1000;
 
-                /* 9 for the header and 1 for the checksum, plus
-                   possibly one for the broadcast. */
+                /*
+                 * 9 for the header and 1 for the checksum, plus
+                 * possibly one for the broadcast.
+                 */
                 if ((msg->data_len + 10 + broadcast) > IPMI_MAX_MSG_LENGTH) {
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EMSGSIZE;
                         goto out_err;
                 }
 
                 ipmb_addr = (struct ipmi_ipmb_addr *) addr;
                 if (ipmb_addr->lun > 3) {
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EINVAL;
                         goto out_err;
                 }
@@ -1491,29 +1562,31 @@ static int i_ipmi_request(ipmi_user_t          user,
                 memcpy(&recv_msg->addr, ipmb_addr, sizeof(*ipmb_addr));
 
                 if (recv_msg->msg.netfn & 0x1) {
-                        /* It's a response, so use the user's sequence
-                           from msgid. */
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_ipmb_responses++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        /*
+                         * It's a response, so use the user's sequence
+                         * from msgid.
+                         */
+                        ipmi_inc_stat(intf, sent_ipmb_responses);
                         format_ipmb_msg(smi_msg, msg, ipmb_addr, msgid,
                                         msgid, broadcast,
                                         source_address, source_lun);
 
-                        /* Save the receive message so we can use it
-                           to deliver the response. */
+                        /*
+                         * Save the receive message so we can use it
+                         * to deliver the response.
+                         */
                         smi_msg->user_data = recv_msg;
                 } else {
                         /* It's a command, so get a sequence for it. */
 
                         spin_lock_irqsave(&(intf->seq_lock), flags);
 
-                        spin_lock(&intf->counter_lock);
-                        intf->sent_ipmb_commands++;
-                        spin_unlock(&intf->counter_lock);
+                        ipmi_inc_stat(intf, sent_ipmb_commands);
 
-                        /* Create a sequence number with a 1 second
-                           timeout and 4 retries. */
+                        /*
+                         * Create a sequence number with a 1 second
+                         * timeout and 4 retries.
+                         */
                         rv = intf_next_seq(intf,
                                            recv_msg,
                                            retry_time_ms,
@@ -1522,34 +1595,42 @@ static int i_ipmi_request(ipmi_user_t          user,
                                            &ipmb_seq,
                                            &seqid);
                         if (rv) {
-                                /* We have used up all the sequence numbers,
-                                   probably, so abort. */
+                                /*
+                                 * We have used up all the sequence numbers,
+                                 * probably, so abort.
+                                 */
                                 spin_unlock_irqrestore(&(intf->seq_lock),
                                                        flags);
                                 goto out_err;
                         }
 
-                        /* Store the sequence number in the message,
-                           so that when the send message response
-                           comes back we can start the timer. */
+                        /*
+                         * Store the sequence number in the message,
+                         * so that when the send message response
+                         * comes back we can start the timer.
+                         */
                         format_ipmb_msg(smi_msg, msg, ipmb_addr,
                                         STORE_SEQ_IN_MSGID(ipmb_seq, seqid),
                                         ipmb_seq, broadcast,
                                         source_address, source_lun);
 
-                        /* Copy the message into the recv message data, so we
-                           can retransmit it later if necessary. */
+                        /*
+                         * Copy the message into the recv message data, so we
+                         * can retransmit it later if necessary.
+                         */
                         memcpy(recv_msg->msg_data, smi_msg->data,
                                smi_msg->data_size);
                         recv_msg->msg.data = recv_msg->msg_data;
                         recv_msg->msg.data_len = smi_msg->data_size;
 
-                        /* We don't unlock until here, because we need
-                           to copy the completed message into the
-                           recv_msg before we release the lock.
-                           Otherwise, race conditions may bite us.  I
-                           know that's pretty paranoid, but I prefer
-                           to be correct. */
+                        /*
+                         * We don't unlock until here, because we need
+                         * to copy the completed message into the
+                         * recv_msg before we release the lock.
+                         * Otherwise, race conditions may bite us.  I
+                         * know that's pretty paranoid, but I prefer
+                         * to be correct.
+                         */
                         spin_unlock_irqrestore(&(intf->seq_lock), flags);
                 }
         } else if (addr->addr_type == IPMI_LAN_ADDR_TYPE) {
@@ -1558,21 +1639,16 @@ static int i_ipmi_request(ipmi_user_t          user,
                 long                  seqid;
 
                 if (addr->channel >= IPMI_MAX_CHANNELS) {
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EINVAL;
                         goto out_err;
                 }
 
                 if ((intf->channels[addr->channel].medium
-                    != IPMI_CHANNEL_MEDIUM_8023LAN)
+                                != IPMI_CHANNEL_MEDIUM_8023LAN)
                     && (intf->channels[addr->channel].medium
-                        != IPMI_CHANNEL_MEDIUM_ASYNC))
-                {
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                                != IPMI_CHANNEL_MEDIUM_ASYNC)) {
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EINVAL;
                         goto out_err;
                 }
@@ -1585,18 +1661,14 @@ static int i_ipmi_request(ipmi_user_t          user,
 
                 /* 11 for the header and 1 for the checksum. */
                 if ((msg->data_len + 12) > IPMI_MAX_MSG_LENGTH) {
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EMSGSIZE;
                         goto out_err;
                 }
 
                 lan_addr = (struct ipmi_lan_addr *) addr;
                 if (lan_addr->lun > 3) {
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_invalid_commands++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        ipmi_inc_stat(intf, sent_invalid_commands);
                         rv = -EINVAL;
                         goto out_err;
                 }
@@ -1604,28 +1676,30 @@ static int i_ipmi_request(ipmi_user_t          user,
                 memcpy(&recv_msg->addr, lan_addr, sizeof(*lan_addr));
 
                 if (recv_msg->msg.netfn & 0x1) {
-                        /* It's a response, so use the user's sequence
-                           from msgid. */
-                        spin_lock_irqsave(&intf->counter_lock, flags);
-                        intf->sent_lan_responses++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                        /*
+                         * It's a response, so use the user's sequence
+                         * from msgid.
+                         */
+                        ipmi_inc_stat(intf, sent_lan_responses);
                         format_lan_msg(smi_msg, msg, lan_addr, msgid,
                                        msgid, source_lun);
 
-                        /* Save the receive message so we can use it
-                           to deliver the response. */
+                        /*
+                         * Save the receive message so we can use it
+                         * to deliver the response.
+                         */
                         smi_msg->user_data = recv_msg;
                 } else {
                         /* It's a command, so get a sequence for it. */
 
                         spin_lock_irqsave(&(intf->seq_lock), flags);
 
-                        spin_lock(&intf->counter_lock);
-                        intf->sent_lan_commands++;
-                        spin_unlock(&intf->counter_lock);
+                        ipmi_inc_stat(intf, sent_lan_commands);
 
-                        /* Create a sequence number with a 1 second
-                           timeout and 4 retries. */
+                        /*
+                         * Create a sequence number with a 1 second
+                         * timeout and 4 retries.
+                         */
                         rv = intf_next_seq(intf,
                                            recv_msg,
                                            retry_time_ms,
@@ -1634,40 +1708,46 @@ static int i_ipmi_request(ipmi_user_t          user,
                                            &ipmb_seq,
                                            &seqid);
                         if (rv) {
-                                /* We have used up all the sequence numbers,
-                                   probably, so abort. */
+                                /*
+                                 * We have used up all the sequence numbers,
+                                 * probably, so abort.
+                                 */
                                 spin_unlock_irqrestore(&(intf->seq_lock),
                                                        flags);
                                 goto out_err;
                         }
 
-                        /* Store the sequence number in the message,
-                           so that when the send message response
-                           comes back we can start the timer. */
+                        /*
+                         * Store the sequence number in the message,
+                         * so that when the send message response
+                         * comes back we can start the timer.
+                         */
                         format_lan_msg(smi_msg, msg, lan_addr,
                                        STORE_SEQ_IN_MSGID(ipmb_seq, seqid),
                                        ipmb_seq, source_lun);
 
-                        /* Copy the message into the recv message data, so we
-                           can retransmit it later if necessary. */
+                        /*
+                         * Copy the message into the recv message data, so we
+                         * can retransmit it later if necessary.
+                         */
                         memcpy(recv_msg->msg_data, smi_msg->data,
                                smi_msg->data_size);
                         recv_msg->msg.data = recv_msg->msg_data;
                         recv_msg->msg.data_len = smi_msg->data_size;
 
-                        /* We don't unlock until here, because we need
-                           to copy the completed message into the
-                           recv_msg before we release the lock.
-                           Otherwise, race conditions may bite us.  I
-                           know that's pretty paranoid, but I prefer
-                           to be correct. */
+                        /*
+                         * We don't unlock until here, because we need
+                         * to copy the completed message into the
+                         * recv_msg before we release the lock.
+                         * Otherwise, race conditions may bite us.  I
+                         * know that's pretty paranoid, but I prefer
+                         * to be correct.
+                         */
                         spin_unlock_irqrestore(&(intf->seq_lock), flags);
                 }
         } else {
             /* Unknown address type. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->sent_invalid_commands++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, sent_invalid_commands);
                 rv = -EINVAL;
                 goto out_err;
         }
@@ -1735,6 +1815,7 @@ int ipmi_request_settime(ipmi_user_t      user,
                               retries,
                               retry_time_ms);
 }
+EXPORT_SYMBOL(ipmi_request_settime);
 
 int ipmi_request_supply_msgs(ipmi_user_t          user,
                              struct ipmi_addr     *addr,
@@ -1766,6 +1847,7 @@ int ipmi_request_supply_msgs(ipmi_user_t          user,
                               lun,
                               -1, 0);
 }
+EXPORT_SYMBOL(ipmi_request_supply_msgs);
 
 #ifdef CONFIG_PROC_FS
 static int ipmb_file_read_proc(char *page, char **start, off_t off,
@@ -1790,7 +1872,7 @@ static int version_file_read_proc(char *page, char **start, off_t off,
         char       *out = (char *) page;
         ipmi_smi_t intf = data;
 
-        return sprintf(out, "%d.%d\n",
+        return sprintf(out, "%u.%u\n",
                        ipmi_version_major(&intf->bmc->id),
                        ipmi_version_minor(&intf->bmc->id));
 }
@@ -1801,65 +1883,65 @@ static int stat_file_read_proc(char *page, char **start, off_t off,
         char       *out = (char *) page;
         ipmi_smi_t intf = data;
 
-        out += sprintf(out, "sent_invalid_commands:       %d\n",
-                       intf->sent_invalid_commands);
-        out += sprintf(out, "sent_local_commands:         %d\n",
-                       intf->sent_local_commands);
-        out += sprintf(out, "handled_local_responses:     %d\n",
-                       intf->handled_local_responses);
-        out += sprintf(out, "unhandled_local_responses:   %d\n",
-                       intf->unhandled_local_responses);
-        out += sprintf(out, "sent_ipmb_commands:          %d\n",
-                       intf->sent_ipmb_commands);
-        out += sprintf(out, "sent_ipmb_command_errs:      %d\n",
-                       intf->sent_ipmb_command_errs);
-        out += sprintf(out, "retransmitted_ipmb_commands: %d\n",
-                       intf->retransmitted_ipmb_commands);
-        out += sprintf(out, "timed_out_ipmb_commands:     %d\n",
-                       intf->timed_out_ipmb_commands);
-        out += sprintf(out, "timed_out_ipmb_broadcasts:   %d\n",
-                       intf->timed_out_ipmb_broadcasts);
-        out += sprintf(out, "sent_ipmb_responses:         %d\n",
-                       intf->sent_ipmb_responses);
-        out += sprintf(out, "handled_ipmb_responses:      %d\n",
-                       intf->handled_ipmb_responses);
-        out += sprintf(out, "invalid_ipmb_responses:      %d\n",
-                       intf->invalid_ipmb_responses);
-        out += sprintf(out, "unhandled_ipmb_responses:    %d\n",
-                       intf->unhandled_ipmb_responses);
-        out += sprintf(out, "sent_lan_commands:           %d\n",
-                       intf->sent_lan_commands);
-        out += sprintf(out, "sent_lan_command_errs:       %d\n",
-                       intf->sent_lan_command_errs);
-        out += sprintf(out, "retransmitted_lan_commands:  %d\n",
-                       intf->retransmitted_lan_commands);
-        out += sprintf(out, "timed_out_lan_commands:      %d\n",
-                       intf->timed_out_lan_commands);
-        out += sprintf(out, "sent_lan_responses:          %d\n",
-                       intf->sent_lan_responses);
-        out += sprintf(out, "handled_lan_responses:       %d\n",
-                       intf->handled_lan_responses);
-        out += sprintf(out, "invalid_lan_responses:       %d\n",
-                       intf->invalid_lan_responses);
-        out += sprintf(out, "unhandled_lan_responses:     %d\n",
-                       intf->unhandled_lan_responses);
-        out += sprintf(out, "handled_commands:            %d\n",
-                       intf->handled_commands);
-        out += sprintf(out, "invalid_commands:            %d\n",
-                       intf->invalid_commands);
-        out += sprintf(out, "unhandled_commands:          %d\n",
-                       intf->unhandled_commands);
-        out += sprintf(out, "invalid_events:              %d\n",
-                       intf->invalid_events);
-        out += sprintf(out, "events:                      %d\n",
-                       intf->events);
+        out += sprintf(out, "sent_invalid_commands:       %u\n",
+                       ipmi_get_stat(intf, sent_invalid_commands));
+        out += sprintf(out, "sent_local_commands:         %u\n",
+                       ipmi_get_stat(intf, sent_local_commands));
+        out += sprintf(out, "handled_local_responses:     %u\n",
+                       ipmi_get_stat(intf, handled_local_responses));
+        out += sprintf(out, "unhandled_local_responses:   %u\n",
+                       ipmi_get_stat(intf, unhandled_local_responses));
+        out += sprintf(out, "sent_ipmb_commands:          %u\n",
+                       ipmi_get_stat(intf, sent_ipmb_commands));
+        out += sprintf(out, "sent_ipmb_command_errs:      %u\n",
+                       ipmi_get_stat(intf, sent_ipmb_command_errs));
+        out += sprintf(out, "retransmitted_ipmb_commands: %u\n",
+                       ipmi_get_stat(intf, retransmitted_ipmb_commands));
+        out += sprintf(out, "timed_out_ipmb_commands:     %u\n",
+                       ipmi_get_stat(intf, timed_out_ipmb_commands));
+        out += sprintf(out, "timed_out_ipmb_broadcasts:   %u\n",
+                       ipmi_get_stat(intf, timed_out_ipmb_broadcasts));
+        out += sprintf(out, "sent_ipmb_responses:         %u\n",
+                       ipmi_get_stat(intf, sent_ipmb_responses));
+        out += sprintf(out, "handled_ipmb_responses:      %u\n",
+                       ipmi_get_stat(intf, handled_ipmb_responses));
+        out += sprintf(out, "invalid_ipmb_responses:      %u\n",
+                       ipmi_get_stat(intf, invalid_ipmb_responses));
+        out += sprintf(out, "unhandled_ipmb_responses:    %u\n",
+                       ipmi_get_stat(intf, unhandled_ipmb_responses));
+        out += sprintf(out, "sent_lan_commands:           %u\n",
+                       ipmi_get_stat(intf, sent_lan_commands));
+        out += sprintf(out, "sent_lan_command_errs:       %u\n",
+                       ipmi_get_stat(intf, sent_lan_command_errs));
+        out += sprintf(out, "retransmitted_lan_commands:  %u\n",
+                       ipmi_get_stat(intf, retransmitted_lan_commands));
+        out += sprintf(out, "timed_out_lan_commands:      %u\n",
+                       ipmi_get_stat(intf, timed_out_lan_commands));
+        out += sprintf(out, "sent_lan_responses:          %u\n",
+                       ipmi_get_stat(intf, sent_lan_responses));
+        out += sprintf(out, "handled_lan_responses:       %u\n",
+                       ipmi_get_stat(intf, handled_lan_responses));
+        out += sprintf(out, "invalid_lan_responses:       %u\n",
+                       ipmi_get_stat(intf, invalid_lan_responses));
+        out += sprintf(out, "unhandled_lan_responses:     %u\n",
+                       ipmi_get_stat(intf, unhandled_lan_responses));
+        out += sprintf(out, "handled_commands:            %u\n",
+                       ipmi_get_stat(intf, handled_commands));
+        out += sprintf(out, "invalid_commands:            %u\n",
+                       ipmi_get_stat(intf, invalid_commands));
+        out += sprintf(out, "unhandled_commands:          %u\n",
+                       ipmi_get_stat(intf, unhandled_commands));
+        out += sprintf(out, "invalid_events:              %u\n",
+                       ipmi_get_stat(intf, invalid_events));
+        out += sprintf(out, "events:                      %u\n",
+                       ipmi_get_stat(intf, events));
 
         return (out - ((char *) page));
 }
 #endif /* CONFIG_PROC_FS */
 
 int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
-                            read_proc_t *read_proc, write_proc_t *write_proc,
+                            read_proc_t *read_proc,
                             void *data, struct module *owner)
 {
         int                    rv = 0;
@@ -1886,7 +1968,6 @@ int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
         } else {
                 file->data = data;
                 file->read_proc = read_proc;
-                file->write_proc = write_proc;
                 file->owner = owner;
 
                 mutex_lock(&smi->proc_entry_lock);
@@ -1899,6 +1980,7 @@ int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
 
         return rv;
 }
+EXPORT_SYMBOL(ipmi_smi_add_proc_entry);
 
 static int add_proc_entries(ipmi_smi_t smi, int num)
 {
@@ -1909,23 +1991,22 @@ static int add_proc_entries(ipmi_smi_t smi, int num)
         smi->proc_dir = proc_mkdir(smi->proc_dir_name, proc_ipmi_root);
         if (!smi->proc_dir)
                 rv = -ENOMEM;
-        else {
+        else
                 smi->proc_dir->owner = THIS_MODULE;
-        }
 
         if (rv == 0)
                 rv = ipmi_smi_add_proc_entry(smi, "stats",
-                                             stat_file_read_proc, NULL,
+                                             stat_file_read_proc,
                                              smi, THIS_MODULE);
 
         if (rv == 0)
                 rv = ipmi_smi_add_proc_entry(smi, "ipmb",
-                                             ipmb_file_read_proc, NULL,
+                                             ipmb_file_read_proc,
                                              smi, THIS_MODULE);
 
         if (rv == 0)
                 rv = ipmi_smi_add_proc_entry(smi, "version",
-                                             version_file_read_proc, NULL,
+                                             version_file_read_proc,
                                              smi, THIS_MODULE);
 #endif /* CONFIG_PROC_FS */
 
@@ -2210,37 +2291,47 @@ static int create_files(struct bmc_device *bmc)
 
         err = device_create_file(&bmc->dev->dev,
                            &bmc->device_id_attr);
-        if (err) goto out;
+        if (err)
+                goto out;
         err = device_create_file(&bmc->dev->dev,
                            &bmc->provides_dev_sdrs_attr);
-        if (err) goto out_devid;
+        if (err)
+                goto out_devid;
         err = device_create_file(&bmc->dev->dev,
                            &bmc->revision_attr);
-        if (err) goto out_sdrs;
+        if (err)
+                goto out_sdrs;
         err = device_create_file(&bmc->dev->dev,
                            &bmc->firmware_rev_attr);
-        if (err) goto out_rev;
+        if (err)
+                goto out_rev;
         err = device_create_file(&bmc->dev->dev,
                            &bmc->version_attr);
-        if (err) goto out_firm;
+        if (err)
+                goto out_firm;
         err = device_create_file(&bmc->dev->dev,
                            &bmc->add_dev_support_attr);
-        if (err) goto out_version;
+        if (err)
+                goto out_version;
         err = device_create_file(&bmc->dev->dev,
                            &bmc->manufacturer_id_attr);
-        if (err) goto out_add_dev;
+        if (err)
+                goto out_add_dev;
         err = device_create_file(&bmc->dev->dev,
                            &bmc->product_id_attr);
-        if (err) goto out_manu;
+        if (err)
+                goto out_manu;
         if (bmc->id.aux_firmware_revision_set) {
                 err = device_create_file(&bmc->dev->dev,
                                    &bmc->aux_firmware_rev_attr);
-                if (err) goto out_prod_id;
+                if (err)
+                        goto out_prod_id;
         }
         if (bmc->guid_set) {
                 err = device_create_file(&bmc->dev->dev,
                                    &bmc->guid_attr);
-                if (err) goto out_aux_firm;
+                if (err)
+                        goto out_aux_firm;
         }
 
         return 0;
@@ -2368,8 +2459,10 @@ static int ipmi_bmc_register(ipmi_smi_t intf, int ifnum,
                                "ipmi_msghandler:"
                                " Unable to register bmc device: %d\n",
                                rv);
-                        /* Don't go to out_err, you can only do that if
-                           the device is registered already. */
+                        /*
+                         * Don't go to out_err, you can only do that if
+                         * the device is registered already.
+                         */
                         return rv;
                 }
 
@@ -2560,17 +2653,18 @@ channel_handler(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
 
         if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
             && (msg->msg.netfn == IPMI_NETFN_APP_RESPONSE)
-            && (msg->msg.cmd == IPMI_GET_CHANNEL_INFO_CMD))
-        {
+            && (msg->msg.cmd == IPMI_GET_CHANNEL_INFO_CMD)) {
                 /* It's the one we want */
                 if (msg->msg.data[0] != 0) {
                         /* Got an error from the channel, just go on. */
 
                         if (msg->msg.data[0] == IPMI_INVALID_COMMAND_ERR) {
-                                /* If the MC does not support this
-                                   command, that is legal.  We just
-                                   assume it has one IPMB at channel
-                                   zero. */
+                                /*
+                                 * If the MC does not support this
+                                 * command, that is legal.  We just
+                                 * assume it has one IPMB at channel
+                                 * zero.
+                                 */
                                 intf->channels[0].medium
                                         = IPMI_CHANNEL_MEDIUM_IPMB;
                                 intf->channels[0].protocol
@@ -2591,7 +2685,7 @@ channel_handler(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
                 intf->channels[chan].medium = msg->msg.data[2] & 0x7f;
                 intf->channels[chan].protocol = msg->msg.data[3] & 0x1f;
 
-        next_channel:
+ next_channel:
                 intf->curr_channel++;
                 if (intf->curr_channel >= IPMI_MAX_CHANNELS)
                         wake_up(&intf->waitq);
@@ -2619,6 +2713,7 @@ void ipmi_poll_interface(ipmi_user_t user)
         if (intf->handlers->poll)
                 intf->handlers->poll(intf->send_info);
 }
+EXPORT_SYMBOL(ipmi_poll_interface);
 
 int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
                       void                     *send_info,
@@ -2633,14 +2728,18 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
         ipmi_smi_t       tintf;
         struct list_head *link;
 
-        /* Make sure the driver is actually initialized, this handles
-           problems with initialization order. */
+        /*
+         * Make sure the driver is actually initialized, this handles
+         * problems with initialization order.
+         */
         if (!initialized) {
                 rv = ipmi_init_msghandler();
                 if (rv)
                         return rv;
-                /* The init code doesn't return an error if it was turned
-                   off, but it won't initialize.  Check that. */
+                /*
+                 * The init code doesn't return an error if it was turned
+                 * off, but it won't initialize.  Check that.
+                 */
                 if (!initialized)
                         return -ENODEV;
         }
@@ -2688,8 +2787,9 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
         spin_lock_init(&intf->maintenance_mode_lock);
         INIT_LIST_HEAD(&intf->cmd_rcvrs);
         init_waitqueue_head(&intf->waitq);
+        for (i = 0; i < IPMI_NUM_STATS; i++)
+                atomic_set(&intf->stats[i], 0);
 
-        spin_lock_init(&intf->counter_lock);
         intf->proc_dir = NULL;
 
         mutex_lock(&smi_watchers_mutex);
@@ -2717,11 +2817,12 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
         get_guid(intf);
 
         if ((intf->ipmi_version_major > 1)
-            || ((intf->ipmi_version_major == 1)
-                && (intf->ipmi_version_minor >= 5)))
-        {
-                /* Start scanning the channels to see what is
-                   available. */
+                        || ((intf->ipmi_version_major == 1)
+                            && (intf->ipmi_version_minor >= 5))) {
+                /*
+                 * Start scanning the channels to see what is
+                 * available.
+                 */
                 intf->null_user_handler = channel_handler;
                 intf->curr_channel = 0;
                 rv = send_channel_info_cmd(intf, 0);
@@ -2769,6 +2870,7 @@ int ipmi_register_smi(struct ipmi_smi_handlers *handlers,
 
         return rv;
 }
+EXPORT_SYMBOL(ipmi_register_smi);
 
 static void cleanup_smi_msgs(ipmi_smi_t intf)
 {
@@ -2803,8 +2905,10 @@ int ipmi_unregister_smi(ipmi_smi_t intf)
 
         remove_proc_entries(intf);
 
-        /* Call all the watcher interfaces to tell them that
-           an interface is gone. */
+        /*
+         * Call all the watcher interfaces to tell them that
+         * an interface is gone.
+         */
         list_for_each_entry(w, &smi_watchers, link)
                 w->smi_gone(intf_num);
         mutex_unlock(&smi_watchers_mutex);
@@ -2812,22 +2916,21 @@ int ipmi_unregister_smi(ipmi_smi_t intf)
         kref_put(&intf->refcount, intf_free);
         return 0;
 }
+EXPORT_SYMBOL(ipmi_unregister_smi);
 
 static int handle_ipmb_get_msg_rsp(ipmi_smi_t          intf,
                                    struct ipmi_smi_msg *msg)
 {
         struct ipmi_ipmb_addr ipmb_addr;
         struct ipmi_recv_msg  *recv_msg;
-        unsigned long         flags;
 
-        
-        /* This is 11, not 10, because the response must contain a
-         * completion code. */
+        /*
+         * This is 11, not 10, because the response must contain a
+         * completion code.
+         */
         if (msg->rsp_size < 11) {
                 /* Message not big enough, just ignore it. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->invalid_ipmb_responses++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, invalid_ipmb_responses);
                 return 0;
         }
 
@@ -2841,37 +2944,38 @@ static int handle_ipmb_get_msg_rsp(ipmi_smi_t          intf,
         ipmb_addr.channel = msg->rsp[3] & 0x0f;
         ipmb_addr.lun = msg->rsp[7] & 3;
 
-        /* It's a response from a remote entity.  Look up the sequence
-           number and handle the response. */
+        /*
+         * It's a response from a remote entity.  Look up the sequence
+         * number and handle the response.
+         */
         if (intf_find_seq(intf,
                           msg->rsp[7] >> 2,
                           msg->rsp[3] & 0x0f,
                           msg->rsp[8],
                           (msg->rsp[4] >> 2) & (~1),
                           (struct ipmi_addr *) &(ipmb_addr),
-                          &recv_msg))
-        {
-                /* We were unable to find the sequence number,
-                   so just nuke the message. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->unhandled_ipmb_responses++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                          &recv_msg)) {
+                /*
+                 * We were unable to find the sequence number,
+                 * so just nuke the message.
+                 */
+                ipmi_inc_stat(intf, unhandled_ipmb_responses);
                 return 0;
         }
 
         memcpy(recv_msg->msg_data,
                &(msg->rsp[9]),
                msg->rsp_size - 9);
-        /* THe other fields matched, so no need to set them, except
-           for netfn, which needs to be the response that was
-           returned, not the request value. */
+        /*
+         * The other fields matched, so no need to set them, except
+         * for netfn, which needs to be the response that was
+         * returned, not the request value.
+         */
         recv_msg->msg.netfn = msg->rsp[4] >> 2;
         recv_msg->msg.data = recv_msg->msg_data;
         recv_msg->msg.data_len = msg->rsp_size - 10;
         recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
-        spin_lock_irqsave(&intf->counter_lock, flags);
-        intf->handled_ipmb_responses++;
-        spin_unlock_irqrestore(&intf->counter_lock, flags);
+        ipmi_inc_stat(intf, handled_ipmb_responses);
         deliver_response(recv_msg);
 
         return 0;
@@ -2888,14 +2992,11 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
         ipmi_user_t              user = NULL;
         struct ipmi_ipmb_addr    *ipmb_addr;
         struct ipmi_recv_msg     *recv_msg;
-        unsigned long            flags;
         struct ipmi_smi_handlers *handlers;
 
         if (msg->rsp_size < 10) {
                 /* Message not big enough, just ignore it. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->invalid_commands++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, invalid_commands);
                 return 0;
         }
 
@@ -2919,19 +3020,17 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
 
         if (user == NULL) {
                 /* We didn't find a user, deliver an error response. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->unhandled_commands++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, unhandled_commands);
 
                 msg->data[0] = (IPMI_NETFN_APP_REQUEST << 2);
                 msg->data[1] = IPMI_SEND_MSG_CMD;
                 msg->data[2] = msg->rsp[3];
                 msg->data[3] = msg->rsp[6];
-                msg->data[4] = ((netfn + 1) << 2) | (msg->rsp[7] & 0x3);
+                msg->data[4] = ((netfn + 1) << 2) | (msg->rsp[7] & 0x3);
                 msg->data[5] = ipmb_checksum(&(msg->data[3]), 2);
                 msg->data[6] = intf->channels[msg->rsp[3] & 0xf].address;
-                /* rqseq/lun */
-                msg->data[7] = (msg->rsp[7] & 0xfc) | (msg->rsp[4] & 0x3);
+                /* rqseq/lun */
+                msg->data[7] = (msg->rsp[7] & 0xfc) | (msg->rsp[4] & 0x3);
                 msg->data[8] = msg->rsp[8]; /* cmd */
                 msg->data[9] = IPMI_INVALID_CMD_COMPLETION_CODE;
                 msg->data[10] = ipmb_checksum(&(msg->data[6]), 4);
@@ -2950,23 +3049,25 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
                 handlers = intf->handlers;
                 if (handlers) {
                         handlers->sender(intf->send_info, msg, 0);
-                        /* We used the message, so return the value
-                           that causes it to not be freed or
-                           queued. */
+                        /*
+                         * We used the message, so return the value
+                         * that causes it to not be freed or
+                         * queued.
+                         */
                         rv = -1;
                 }
                 rcu_read_unlock();
         } else {
                 /* Deliver the message to the user. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->handled_commands++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, handled_commands);
 
                 recv_msg = ipmi_alloc_recv_msg();
                 if (!recv_msg) {
-                        /* We couldn't allocate memory for the
-                           message, so requeue it for handling
-                           later. */
+                        /*
+                         * We couldn't allocate memory for the
+                         * message, so requeue it for handling
+                         * later.
+                         */
                         rv = 1;
                         kref_put(&user->refcount, free_user);
                 } else {
@@ -2977,8 +3078,10 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
                         ipmb_addr->lun = msg->rsp[7] & 3;
                         ipmb_addr->channel = msg->rsp[3] & 0xf;
 
-                        /* Extract the rest of the message information
-                           from the IPMB header.*/
+                        /*
+                         * Extract the rest of the message information
+                         * from the IPMB header.
+                         */
                         recv_msg->user = user;
                         recv_msg->recv_type = IPMI_CMD_RECV_TYPE;
                         recv_msg->msgid = msg->rsp[7] >> 2;
@@ -2986,8 +3089,10 @@ static int handle_ipmb_get_msg_cmd(ipmi_smi_t          intf,
                         recv_msg->msg.cmd = msg->rsp[8];
                         recv_msg->msg.data = recv_msg->msg_data;
 
-                        /* We chop off 10, not 9 bytes because the checksum
-                           at the end also needs to be removed. */
+                        /*
+                         * We chop off 10, not 9 bytes because the checksum
+                         * at the end also needs to be removed.
+                         */
                         recv_msg->msg.data_len = msg->rsp_size - 10;
                         memcpy(recv_msg->msg_data,
                                &(msg->rsp[9]),
@@ -3004,16 +3109,15 @@ static int handle_lan_get_msg_rsp(ipmi_smi_t          intf,
 {
         struct ipmi_lan_addr  lan_addr;
         struct ipmi_recv_msg  *recv_msg;
-        unsigned long         flags;
 
 
-        /* This is 13, not 12, because the response must contain a
-         * completion code. */
+        /*
+         * This is 13, not 12, because the response must contain a
+         * completion code.
+         */
         if (msg->rsp_size < 13) {
                 /* Message not big enough, just ignore it. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->invalid_lan_responses++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, invalid_lan_responses);
                 return 0;
         }
 
@@ -3030,37 +3134,38 @@ static int handle_lan_get_msg_rsp(ipmi_smi_t          intf,
         lan_addr.privilege = msg->rsp[3] >> 4;
         lan_addr.lun = msg->rsp[9] & 3;
 
-        /* It's a response from a remote entity.  Look up the sequence
-           number and handle the response. */
+        /*
+         * It's a response from a remote entity.  Look up the sequence
+         * number and handle the response.
+         */
         if (intf_find_seq(intf,
                           msg->rsp[9] >> 2,
                           msg->rsp[3] & 0x0f,
                           msg->rsp[10],
                           (msg->rsp[6] >> 2) & (~1),
                           (struct ipmi_addr *) &(lan_addr),
-                          &recv_msg))
-        {
-                /* We were unable to find the sequence number,
-                   so just nuke the message. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->unhandled_lan_responses++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                          &recv_msg)) {
+                /*
+                 * We were unable to find the sequence number,
+                 * so just nuke the message.
+                 */
+                ipmi_inc_stat(intf, unhandled_lan_responses);
                 return 0;
         }
 
         memcpy(recv_msg->msg_data,
                &(msg->rsp[11]),
                msg->rsp_size - 11);
-        /* The other fields matched, so no need to set them, except
-           for netfn, which needs to be the response that was
-           returned, not the request value. */
+        /*
+         * The other fields matched, so no need to set them, except
+         * for netfn, which needs to be the response that was
+         * returned, not the request value.
+         */
         recv_msg->msg.netfn = msg->rsp[6] >> 2;
         recv_msg->msg.data = recv_msg->msg_data;
         recv_msg->msg.data_len = msg->rsp_size - 12;
         recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
-        spin_lock_irqsave(&intf->counter_lock, flags);
-        intf->handled_lan_responses++;
-        spin_unlock_irqrestore(&intf->counter_lock, flags);
+        ipmi_inc_stat(intf, handled_lan_responses);
         deliver_response(recv_msg);
 
         return 0;
@@ -3077,13 +3182,10 @@ static int handle_lan_get_msg_cmd(ipmi_smi_t          intf,
         ipmi_user_t              user = NULL;
         struct ipmi_lan_addr     *lan_addr;
         struct ipmi_recv_msg     *recv_msg;
-        unsigned long            flags;
 
         if (msg->rsp_size < 12) {
                 /* Message not big enough, just ignore it. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->invalid_commands++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, invalid_commands);
                 return 0;
         }
 
@@ -3107,23 +3209,23 @@ static int handle_lan_get_msg_cmd(ipmi_smi_t          intf,
 
         if (user == NULL) {
                 /* We didn't find a user, just give up. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->unhandled_commands++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, unhandled_commands);
 
-                rv = 0; /* Don't do anything with these messages, just
-                           allow them to be freed. */
+                /*
+                 * Don't do anything with these messages, just allow
+                 * them to be freed.
+                 */
+                rv = 0;
         } else {
                 /* Deliver the message to the user. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->handled_commands++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, handled_commands);
 
                 recv_msg = ipmi_alloc_recv_msg();
                 if (!recv_msg) {
-                        /* We couldn't allocate memory for the
-                           message, so requeue it for handling
-                           later. */
+                        /*
+                         * We couldn't allocate memory for the
+                         * message, so requeue it for handling later.
+                         */
                         rv = 1;
                         kref_put(&user->refcount, free_user);
                 } else {
@@ -3137,8 +3239,10 @@ static int handle_lan_get_msg_cmd(ipmi_smi_t          intf,
                         lan_addr->channel = msg->rsp[3] & 0xf;
                         lan_addr->privilege = msg->rsp[3] >> 4;
 
-                        /* Extract the rest of the message information
-                           from the IPMB header.*/
+                        /*
+                         * Extract the rest of the message information
+                         * from the IPMB header.
+                         */
                         recv_msg->user = user;
                         recv_msg->recv_type = IPMI_CMD_RECV_TYPE;
                         recv_msg->msgid = msg->rsp[9] >> 2;
@@ -3146,8 +3250,10 @@ static int handle_lan_get_msg_cmd(ipmi_smi_t          intf,
                         recv_msg->msg.cmd = msg->rsp[10];
                         recv_msg->msg.data = recv_msg->msg_data;
 
-                        /* We chop off 12, not 11 bytes because the checksum
-                           at the end also needs to be removed. */
+                        /*
+                         * We chop off 12, not 11 bytes because the checksum
+                         * at the end also needs to be removed.
+                         */
                         recv_msg->msg.data_len = msg->rsp_size - 12;
                         memcpy(recv_msg->msg_data,
                                &(msg->rsp[11]),
@@ -3163,7 +3269,7 @@ static void copy_event_into_recv_msg(struct ipmi_recv_msg *recv_msg,
                                      struct ipmi_smi_msg  *msg)
 {
         struct ipmi_system_interface_addr *smi_addr;
-        
+
         recv_msg->msgid = 0;
         smi_addr = (struct ipmi_system_interface_addr *) &(recv_msg->addr);
         smi_addr->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
@@ -3189,9 +3295,7 @@ static int handle_read_event_rsp(ipmi_smi_t          intf,
 
         if (msg->rsp_size < 19) {
                 /* Message is too small to be an IPMB event. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->invalid_events++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, invalid_events);
                 return 0;
         }
 
@@ -3204,12 +3308,12 @@ static int handle_read_event_rsp(ipmi_smi_t          intf,
 
         spin_lock_irqsave(&intf->events_lock, flags);
 
-        spin_lock(&intf->counter_lock);
-        intf->events++;
-        spin_unlock(&intf->counter_lock);
+        ipmi_inc_stat(intf, events);
 
-        /* Allocate and fill in one message for every user that is getting
-           events. */
+        /*
+         * Allocate and fill in one message for every user that is
+         * getting events.
+         */
         rcu_read_lock();
         list_for_each_entry_rcu(user, &intf->users, link) {
                 if (!user->gets_events)
@@ -3223,9 +3327,11 @@ static int handle_read_event_rsp(ipmi_smi_t          intf,
                                 list_del(&recv_msg->link);
                                 ipmi_free_recv_msg(recv_msg);
                         }
-                        /* We couldn't allocate memory for the
-                           message, so requeue it for handling
-                           later. */
+                        /*
+                         * We couldn't allocate memory for the
+                         * message, so requeue it for handling
+                         * later.
+                         */
                         rv = 1;
                         goto out;
                 }
@@ -3246,13 +3352,17 @@ static int handle_read_event_rsp(ipmi_smi_t          intf,
                         deliver_response(recv_msg);
                 }
         } else if (intf->waiting_events_count < MAX_EVENTS_IN_QUEUE) {
-                /* No one to receive the message, put it in queue if there's
-                   not already too many things in the queue. */
+                /*
+                 * No one to receive the message, put it in queue if there's
+                 * not already too many things in the queue.
+                 */
                 recv_msg = ipmi_alloc_recv_msg();
                 if (!recv_msg) {
-                        /* We couldn't allocate memory for the
-                           message, so requeue it for handling
-                           later. */
+                        /*
+                         * We couldn't allocate memory for the
+                         * message, so requeue it for handling
+                         * later.
+                         */
                         rv = 1;
                         goto out;
                 }
@@ -3260,11 +3370,14 @@ static int handle_read_event_rsp(ipmi_smi_t          intf,
                 copy_event_into_recv_msg(recv_msg, msg);
                 list_add_tail(&(recv_msg->link), &(intf->waiting_events));
                 intf->waiting_events_count++;
-        } else {
-                /* There's too many things in the queue, discard this
-                   message. */
-                printk(KERN_WARNING PFX "Event queue full, discarding an"
-                       " incoming event\n");
+        } else if (!intf->event_msg_printed) {
+                /*
+                 * There's too many things in the queue, discard this
+                 * message.
+                 */
+                printk(KERN_WARNING PFX "Event queue full, discarding"
+                       " incoming events\n");
+                intf->event_msg_printed = 1;
         }
 
  out:
@@ -3277,16 +3390,15 @@ static int handle_bmc_rsp(ipmi_smi_t          intf,
                           struct ipmi_smi_msg *msg)
 {
         struct ipmi_recv_msg *recv_msg;
-        unsigned long        flags;
         struct ipmi_user     *user;
 
         recv_msg = (struct ipmi_recv_msg *) msg->user_data;
-        if (recv_msg == NULL)
-        {
-                printk(KERN_WARNING"IPMI message received with no owner. This\n"
-                        "could be because of a malformed message, or\n"
-                        "because of a hardware error.  Contact your\n"
-                        "hardware vender for assistance\n");
+        if (recv_msg == NULL) {
+                printk(KERN_WARNING
+                       "IPMI message received with no owner. This\n"
+                       "could be because of a malformed message, or\n"
+                       "because of a hardware error.  Contact your\n"
+                       "hardware vender for assistance\n");
                 return 0;
         }
 
@@ -3294,16 +3406,12 @@ static int handle_bmc_rsp(ipmi_smi_t          intf,
         /* Make sure the user still exists. */
         if (user && !user->valid) {
                 /* The user for the message went away, so give up. */
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->unhandled_local_responses++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, unhandled_local_responses);
                 ipmi_free_recv_msg(recv_msg);
         } else {
                 struct ipmi_system_interface_addr *smi_addr;
 
-                spin_lock_irqsave(&intf->counter_lock, flags);
-                intf->handled_local_responses++;
-                spin_unlock_irqrestore(&intf->counter_lock, flags);
+                ipmi_inc_stat(intf, handled_local_responses);
                 recv_msg->recv_type = IPMI_RESPONSE_RECV_TYPE;
                 recv_msg->msgid = msg->msgid;
                 smi_addr = ((struct ipmi_system_interface_addr *)
@@ -3324,9 +3432,11 @@ static int handle_bmc_rsp(ipmi_smi_t          intf,
         return 0;
 }
 
-/* Handle a new message.  Return 1 if the message should be requeued,
-   0 if the message should be freed, or -1 if the message should not
-   be freed or requeued. */
+/*
+ * Handle a new message.  Return 1 if the message should be requeued,
+ * 0 if the message should be freed, or -1 if the message should not
+ * be freed or requeued.
+ */
 static int handle_new_recv_msg(ipmi_smi_t          intf,
                                struct ipmi_smi_msg *msg)
 {
@@ -3351,10 +3461,12 @@ static int handle_new_recv_msg(ipmi_smi_t          intf,
                 msg->rsp[1] = msg->data[1];
                 msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
                 msg->rsp_size = 3;
-        } else if (((msg->rsp[0] >> 2) != ((msg->data[0] >> 2) | 1))/* Netfn */
-                   || (msg->rsp[1] != msg->data[1]))              /* Command */
-        {
-                /* The response is not even marginally correct. */
+        } else if (((msg->rsp[0] >> 2) != ((msg->data[0] >> 2) | 1))
+                   || (msg->rsp[1] != msg->data[1])) {
+                /*
+                 * The NetFN and Command in the response is not even
+                 * marginally correct.
+                 */
                 printk(KERN_WARNING PFX "BMC returned incorrect response,"
                        " expected netfn %x cmd %x, got netfn %x cmd %x\n",
                        (msg->data[0] >> 2) | 1, msg->data[1],
@@ -3369,10 +3481,11 @@ static int handle_new_recv_msg(ipmi_smi_t          intf,
 
         if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
             && (msg->rsp[1] == IPMI_SEND_MSG_CMD)
-            && (msg->user_data != NULL))
-        {
-                /* It's a response to a response we sent.  For this we
-                   deliver a send message response to the user. */
+            && (msg->user_data != NULL)) {
+                /*
+                 * It's a response to a response we sent.  For this we
+                 * deliver a send message response to the user.
+                 */
                 struct ipmi_recv_msg     *recv_msg = msg->user_data;
 
                 requeue = 0;
@@ -3398,8 +3511,7 @@ static int handle_new_recv_msg(ipmi_smi_t          intf,
                 recv_msg->msg_data[0] = msg->rsp[2];
                 deliver_response(recv_msg);
         } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
-                   && (msg->rsp[1] == IPMI_GET_MSG_CMD))
-        {
+                   && (msg->rsp[1] == IPMI_GET_MSG_CMD)) {
                 /* It's from the receive queue. */
                 chan = msg->rsp[3] & 0xf;
                 if (chan >= IPMI_MAX_CHANNELS) {
@@ -3411,12 +3523,16 @@ static int handle_new_recv_msg(ipmi_smi_t          intf,
                 switch (intf->channels[chan].medium) {
                 case IPMI_CHANNEL_MEDIUM_IPMB:
                         if (msg->rsp[4] & 0x04) {
-                                /* It's a response, so find the
-                                   requesting message and send it up. */
+                                /*
+                                 * It's a response, so find the
+                                 * requesting message and send it up.
+                                 */
                                 requeue = handle_ipmb_get_msg_rsp(intf, msg);
                         } else {
-                                /* It's a command to the SMS from some other
-                                   entity.  Handle that. */
+                                /*
+                                 * It's a command to the SMS from some other
+                                 * entity.  Handle that.
+                                 */
                                 requeue = handle_ipmb_get_msg_cmd(intf, msg);
                         }
                         break;
@@ -3424,25 +3540,30 @@ static int handle_new_recv_msg(ipmi_smi_t          intf,
                 case IPMI_CHANNEL_MEDIUM_8023LAN:
                 case IPMI_CHANNEL_MEDIUM_ASYNC:
                         if (msg->rsp[6] & 0x04) {
-                                /* It's a response, so find the
-                                   requesting message and send it up. */
+                                /*
+                                 * It's a response, so find the
+                                 * requesting message and send it up.
+                                 */
                                 requeue = handle_lan_get_msg_rsp(intf, msg);
                         } else {
-                                /* It's a command to the SMS from some other
-                                   entity.  Handle that. */
+                                /*
+                                 * It's a command to the SMS from some other
+                                 * entity.  Handle that.
+                                 */
                                 requeue = handle_lan_get_msg_cmd(intf, msg);
                         }
                         break;
 
                 default:
-                        /* We don't handle the channel type, so just
-                         * free the message. */
+                        /*
+                         * We don't handle the channel type, so just
+                         * free the message.
+                         */
                         requeue = 0;
                 }
 
         } else if ((msg->rsp[0] == ((IPMI_NETFN_APP_REQUEST|1) << 2))
-                   && (msg->rsp[1] == IPMI_READ_EVENT_MSG_BUFFER_CMD))
-        {
+                   && (msg->rsp[1] == IPMI_READ_EVENT_MSG_BUFFER_CMD)) {
                 /* It's an asyncronous event. */
                 requeue = handle_read_event_rsp(intf, msg);
         } else {
@@ -3458,71 +3579,82 @@ static int handle_new_recv_msg(ipmi_smi_t          intf,
 void ipmi_smi_msg_received(ipmi_smi_t          intf,
                            struct ipmi_smi_msg *msg)
 {
-        unsigned long flags;
+        unsigned long flags = 0; /* keep us warning-free. */
         int           rv;
+        int           run_to_completion;
 
 
         if ((msg->data_size >= 2)
             && (msg->data[0] == (IPMI_NETFN_APP_REQUEST << 2))
             && (msg->data[1] == IPMI_SEND_MSG_CMD)
-            && (msg->user_data == NULL))
-        {
-                /* This is the local response to a command send, start
-                   the timer for these.  The user_data will not be
-                   NULL if this is a response send, and we will let
-                   response sends just go through. */
-
-                /* Check for errors, if we get certain errors (ones
-                   that mean basically we can try again later), we
-                   ignore them and start the timer.  Otherwise we
-                   report the error immediately. */
+            && (msg->user_data == NULL)) {
+                /*
+                 * This is the local response to a command send, start
+                 * the timer for these.  The user_data will not be
+                 * NULL if this is a response send, and we will let
+                 * response sends just go through.
+                 */
+
+                /*
+                 * Check for errors, if we get certain errors (ones
+                 * that mean basically we can try again later), we
+                 * ignore them and start the timer.  Otherwise we
+                 * report the error immediately.
+                 */
                 if ((msg->rsp_size >= 3) && (msg->rsp[2] != 0)
                     && (msg->rsp[2] != IPMI_NODE_BUSY_ERR)
                     && (msg->rsp[2] != IPMI_LOST_ARBITRATION_ERR)
                     && (msg->rsp[2] != IPMI_BUS_ERR)
-                    && (msg->rsp[2] != IPMI_NAK_ON_WRITE_ERR))
-                {
+                    && (msg->rsp[2] != IPMI_NAK_ON_WRITE_ERR)) {
                         int chan = msg->rsp[3] & 0xf;
 
                         /* Got an error sending the message, handle it. */
-                        spin_lock_irqsave(&intf->counter_lock, flags);
                         if (chan >= IPMI_MAX_CHANNELS)
                                 ; /* This shouldn't happen */
                         else if ((intf->channels[chan].medium
                                   == IPMI_CHANNEL_MEDIUM_8023LAN)
                                  || (intf->channels[chan].medium
                                      == IPMI_CHANNEL_MEDIUM_ASYNC))
-                                intf->sent_lan_command_errs++;
+                                ipmi_inc_stat(intf, sent_lan_command_errs);
                         else
-                                intf->sent_ipmb_command_errs++;
-                        spin_unlock_irqrestore(&intf->counter_lock, flags);
+                                ipmi_inc_stat(intf, sent_ipmb_command_errs);
                         intf_err_seq(intf, msg->msgid, msg->rsp[2]);
-                } else {
+                } else
                         /* The message was sent, start the timer. */
                         intf_start_seq_timer(intf, msg->msgid);
-                }
 
                 ipmi_free_smi_msg(msg);
                 goto out;
         }
 
-        /* To preserve message order, if the list is not empty, we
-           tack this message onto the end of the list. */
-        spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
+        /*
+         * To preserve message order, if the list is not empty, we
+         * tack this message onto the end of the list.
+         */
+        run_to_completion = intf->run_to_completion;
+        if (!run_to_completion)
+                spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
         if (!list_empty(&intf->waiting_msgs)) {
                 list_add_tail(&msg->link, &intf->waiting_msgs);
-                spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
+                if (!run_to_completion)
+                        spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
                 goto out;
         }
-        spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
-                
+        if (!run_to_completion)
+                spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
+
         rv = handle_new_recv_msg(intf, msg);
         if (rv > 0) {
-                /* Could not handle the message now, just add it to a
-                   list to handle later. */
-                spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
+                /*
+                 * Could not handle the message now, just add it to a
+                 * list to handle later.
+                 */
+                run_to_completion = intf->run_to_completion;
+                if (!run_to_completion)
+                        spin_lock_irqsave(&intf->waiting_msgs_lock, flags);
                 list_add_tail(&msg->link, &intf->waiting_msgs);
-                spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
+                if (!run_to_completion)
+                        spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
         } else if (rv == 0) {
                 ipmi_free_smi_msg(msg);
         }
@@ -3530,6 +3662,7 @@ void ipmi_smi_msg_received(ipmi_smi_t          intf,
  out:
         return;
 }
+EXPORT_SYMBOL(ipmi_smi_msg_received);
 
 void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf)
 {
@@ -3544,7 +3677,7 @@ void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf)
         }
         rcu_read_unlock();
 }
-
+EXPORT_SYMBOL(ipmi_smi_watchdog_pretimeout);
 
 static struct ipmi_smi_msg *
 smi_from_recv_msg(ipmi_smi_t intf, struct ipmi_recv_msg *recv_msg,
@@ -3552,14 +3685,16 @@ smi_from_recv_msg(ipmi_smi_t intf, struct ipmi_recv_msg *recv_msg,
 {
         struct ipmi_smi_msg *smi_msg = ipmi_alloc_smi_msg();
         if (!smi_msg)
-                /* If we can't allocate the message, then just return, we
-                   get 4 retries, so this should be ok. */
+                /*
+                 * If we can't allocate the message, then just return, we
+                 * get 4 retries, so this should be ok.
+                 */
                 return NULL;
 
         memcpy(smi_msg->data, recv_msg->msg.data, recv_msg->msg.data_len);
         smi_msg->data_size = recv_msg->msg.data_len;
         smi_msg->msgid = STORE_SEQ_IN_MSGID(seq, seqid);
-                
+
 #ifdef DEBUG_MSGING
         {
                 int m;
@@ -3594,28 +3729,26 @@ static void check_msg_timeout(ipmi_smi_t intf, struct seq_table *ent,
                 ent->inuse = 0;
                 msg = ent->recv_msg;
                 list_add_tail(&msg->link, timeouts);
-                spin_lock(&intf->counter_lock);
                 if (ent->broadcast)
-                        intf->timed_out_ipmb_broadcasts++;
+                        ipmi_inc_stat(intf, timed_out_ipmb_broadcasts);
                 else if (ent->recv_msg->addr.addr_type == IPMI_LAN_ADDR_TYPE)
-                        intf->timed_out_lan_commands++;
+                        ipmi_inc_stat(intf, timed_out_lan_commands);
                 else
-                        intf->timed_out_ipmb_commands++;
-                spin_unlock(&intf->counter_lock);
+                        ipmi_inc_stat(intf, timed_out_ipmb_commands);
         } else {
                 struct ipmi_smi_msg *smi_msg;
                 /* More retries, send again. */
 
-                /* Start with the max timer, set to normal
-                   timer after the message is sent. */
+                /*
+                 * Start with the max timer, set to normal timer after
+                 * the message is sent.
+                 */
                 ent->timeout = MAX_MSG_TIMEOUT;
                 ent->retries_left--;
-                spin_lock(&intf->counter_lock);
                 if (ent->recv_msg->addr.addr_type == IPMI_LAN_ADDR_TYPE)
-                        intf->retransmitted_lan_commands++;
+                        ipmi_inc_stat(intf, retransmitted_lan_commands);
                 else
-                        intf->retransmitted_ipmb_commands++;
-                spin_unlock(&intf->counter_lock);
+                        ipmi_inc_stat(intf, retransmitted_ipmb_commands);
 
                 smi_msg = smi_from_recv_msg(intf, ent->recv_msg, slot,
                                             ent->seqid);
@@ -3624,11 +3757,13 @@ static void check_msg_timeout(ipmi_smi_t intf, struct seq_table *ent,
 
                 spin_unlock_irqrestore(&intf->seq_lock, *flags);
 
-                /* Send the new message.  We send with a zero
-                 * priority.  It timed out, I doubt time is
-                 * that critical now, and high priority
-                 * messages are really only for messages to the
-                 * local MC, which don't get resent. */
+                /*
+                 * Send the new message.  We send with a zero
+                 * priority.  It timed out, I doubt time is that
+                 * critical now, and high priority messages are really
+                 * only for messages to the local MC, which don't get
+                 * resent.
+                 */
                 handlers = intf->handlers;
                 if (handlers)
                         intf->handlers->sender(intf->send_info,
@@ -3659,16 +3794,20 @@ static void ipmi_timeout_handler(long timeout_period)
                                 list_del(&smi_msg->link);
                                 ipmi_free_smi_msg(smi_msg);
                         } else {
-                                /* To preserve message order, quit if we
-                                   can't handle a message. */
+                                /*
+                                 * To preserve message order, quit if we
+                                 * can't handle a message.
+                                 */
                                 break;
                         }
                 }
                 spin_unlock_irqrestore(&intf->waiting_msgs_lock, flags);
 
-                /* Go through the seq table and find any messages that
-                   have timed out, putting them in the timeouts
-                   list. */
+                /*
+                 * Go through the seq table and find any messages that
+                 * have timed out, putting them in the timeouts
+                 * list.
+                 */
                 INIT_LIST_HEAD(&timeouts);
                 spin_lock_irqsave(&intf->seq_lock, flags);
                 for (i = 0; i < IPMI_IPMB_NUM_SEQ; i++)
@@ -3694,8 +3833,7 @@ static void ipmi_timeout_handler(long timeout_period)
                                 intf->auto_maintenance_timeout
                                         -= timeout_period;
                                 if (!intf->maintenance_mode
-                                    && (intf->auto_maintenance_timeout <= 0))
-                                {
+                                    && (intf->auto_maintenance_timeout <= 0)) {
                                         intf->maintenance_mode_enable = 0;
                                         maintenance_mode_update(intf);
                                 }
@@ -3713,8 +3851,10 @@ static void ipmi_request_event(void)
         struct ipmi_smi_handlers *handlers;
 
         rcu_read_lock();
-        /* Called from the timer, no need to check if handlers is
-         * valid. */
+        /*
+         * Called from the timer, no need to check if handlers is
+         * valid.
+         */
         list_for_each_entry_rcu(intf, &ipmi_interfaces, link) {
                 /* No event requests when in maintenance mode. */
                 if (intf->maintenance_mode_enable)
@@ -3735,10 +3875,12 @@ static struct timer_list ipmi_timer;
 /* How many jiffies does it take to get to the timeout time. */
 #define IPMI_TIMEOUT_JIFFIES    ((IPMI_TIMEOUT_TIME * HZ) / 1000)
 
-/* Request events from the queue every second (this is the number of
-   IPMI_TIMEOUT_TIMES between event requests).  Hopefully, in the
-   future, IPMI will add a way to know immediately if an event is in
-   the queue and this silliness can go away. */
+/*
+ * Request events from the queue every second (this is the number of
+ * IPMI_TIMEOUT_TIMES between event requests).  Hopefully, in the
+ * future, IPMI will add a way to know immediately if an event is in
+ * the queue and this silliness can go away.
+ */
 #define IPMI_REQUEST_EV_TIME    (1000 / (IPMI_TIMEOUT_TIME))
 
 static atomic_t stop_operation;
@@ -3782,6 +3924,7 @@ struct ipmi_smi_msg *ipmi_alloc_smi_msg(void)
         }
         return rv;
 }
+EXPORT_SYMBOL(ipmi_alloc_smi_msg);
 
 static void free_recv_msg(struct ipmi_recv_msg *msg)
 {
@@ -3789,7 +3932,7 @@ static void free_recv_msg(struct ipmi_recv_msg *msg)
         kfree(msg);
 }
 
-struct ipmi_recv_msg *ipmi_alloc_recv_msg(void)
+static struct ipmi_recv_msg *ipmi_alloc_recv_msg(void)
 {
         struct ipmi_recv_msg *rv;
 
@@ -3808,6 +3951,7 @@ void ipmi_free_recv_msg(struct ipmi_recv_msg *msg)
                 kref_put(&msg->user->refcount, free_user);
         msg->done(msg);
 }
+EXPORT_SYMBOL(ipmi_free_recv_msg);
 
 #ifdef CONFIG_IPMI_PANIC_EVENT
 
@@ -3825,8 +3969,7 @@ static void event_receiver_fetcher(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
         if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
             && (msg->msg.netfn == IPMI_NETFN_SENSOR_EVENT_RESPONSE)
             && (msg->msg.cmd == IPMI_GET_EVENT_RECEIVER_CMD)
-            && (msg->msg.data[0] == IPMI_CC_NO_ERROR))
-        {
+            && (msg->msg.data[0] == IPMI_CC_NO_ERROR)) {
                 /* A get event receiver command, save it. */
                 intf->event_receiver = msg->msg.data[1];
                 intf->event_receiver_lun = msg->msg.data[2] & 0x3;
@@ -3838,10 +3981,11 @@ static void device_id_fetcher(ipmi_smi_t intf, struct ipmi_recv_msg *msg)
         if ((msg->addr.addr_type == IPMI_SYSTEM_INTERFACE_ADDR_TYPE)
             && (msg->msg.netfn == IPMI_NETFN_APP_RESPONSE)
             && (msg->msg.cmd == IPMI_GET_DEVICE_ID_CMD)
-            && (msg->msg.data[0] == IPMI_CC_NO_ERROR))
-        {
-                /* A get device id command, save if we are an event
-                   receiver or generator. */
+            && (msg->msg.data[0] == IPMI_CC_NO_ERROR)) {
+                /*
+                 * A get device id command, save if we are an event
+                 * receiver or generator.
+                 */
                 intf->local_sel_device = (msg->msg.data[6] >> 2) & 1;
                 intf->local_event_generator = (msg->msg.data[6] >> 5) & 1;
         }
@@ -3874,8 +4018,10 @@ static void send_panic_events(char *str)
         data[4] = 0x6f; /* Sensor specific, IPMI table 36-1 */
         data[5] = 0xa1; /* Runtime stop OEM bytes 2 & 3. */
 
-        /* Put a few breadcrumbs in.  Hopefully later we can add more things
-           to make the panic events more useful. */
+        /*
+         * Put a few breadcrumbs in.  Hopefully later we can add more things
+         * to make the panic events more useful.
+         */
         if (str) {
                 data[3] = str[0];
                 data[6] = str[1];
@@ -3891,6 +4037,7 @@ static void send_panic_events(char *str)
                         /* Interface is not ready. */
                         continue;
 
+                intf->run_to_completion = 1;
                 /* Send the event announcing the panic. */
                 intf->handlers->set_run_to_completion(intf->send_info, 1);
                 i_ipmi_request(NULL,
@@ -3908,9 +4055,11 @@ static void send_panic_events(char *str)
         }
 
 #ifdef CONFIG_IPMI_PANIC_STRING
-        /* On every interface, dump a bunch of OEM event holding the
-           string. */
-        if (!str) 
+        /*
+         * On every interface, dump a bunch of OEM event holding the
+         * string.
+         */
+        if (!str)
                 return;
 
         /* For every registered interface, send the event. */
@@ -3931,11 +4080,13 @@ static void send_panic_events(char *str)
                  */
                 smp_rmb();
 
-                /* First job here is to figure out where to send the
-                   OEM events.  There's no way in IPMI to send OEM
-                   events using an event send command, so we have to
-                   find the SEL to put them in and stick them in
-                   there. */
+                /*
+                 * First job here is to figure out where to send the
+                 * OEM events.  There's no way in IPMI to send OEM
+                 * events using an event send command, so we have to
+                 * find the SEL to put them in and stick them in
+                 * there.
+                 */
 
                 /* Get capabilities from the get device id. */
                 intf->local_sel_device = 0;
@@ -3983,24 +4134,29 @@ static void send_panic_events(char *str)
                 }
                 intf->null_user_handler = NULL;
 
-                /* Validate the event receiver.  The low bit must not
-                   be 1 (it must be a valid IPMB address), it cannot
-                   be zero, and it must not be my address. */
-                if (((intf->event_receiver & 1) == 0)
+                /*
+                 * Validate the event receiver.  The low bit must not
+                 * be 1 (it must be a valid IPMB address), it cannot
+                 * be zero, and it must not be my address.
+                 */
+                if (((intf->event_receiver & 1) == 0)
                     && (intf->event_receiver != 0)
-                    && (intf->event_receiver != intf->channels[0].address))
-                {
-                        /* The event receiver is valid, send an IPMB
-                           message. */
+                    && (intf->event_receiver != intf->channels[0].address)) {
+                        /*
+                         * The event receiver is valid, send an IPMB
+                         * message.
+                         */
                         ipmb = (struct ipmi_ipmb_addr *) &addr;
                         ipmb->addr_type = IPMI_IPMB_ADDR_TYPE;
                         ipmb->channel = 0; /* FIXME - is this right? */
                         ipmb->lun = intf->event_receiver_lun;
                         ipmb->slave_addr = intf->event_receiver;
                 } else if (intf->local_sel_device) {
-                        /* The event receiver was not valid (or was
-                           me), but I am an SEL device, just dump it
-                           in my SEL. */
+                        /*
+                         * The event receiver was not valid (or was
+                         * me), but I am an SEL device, just dump it
+                         * in my SEL.
+                         */
                         si = (struct ipmi_system_interface_addr *) &addr;
                         si->addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
                         si->channel = IPMI_BMC_CHANNEL;
@@ -4008,7 +4164,6 @@ static void send_panic_events(char *str)
                 } else
                         continue; /* No where to send the event. */
 
-                
                 msg.netfn = IPMI_NETFN_STORAGE_REQUEST; /* Storage. */
                 msg.cmd = IPMI_ADD_SEL_ENTRY_CMD;
                 msg.data = data;
@@ -4025,8 +4180,10 @@ static void send_panic_events(char *str)
                         data[2] = 0xf0; /* OEM event without timestamp. */
                         data[3] = intf->channels[0].address;
                         data[4] = j++; /* sequence # */
-                        /* Always give 11 bytes, so strncpy will fill
-                           it with zeroes for me. */
+                        /*
+                         * Always give 11 bytes, so strncpy will fill
+                         * it with zeroes for me.
+                         */
                         strncpy(data+5, p, 11);
                         p += size;
 
@@ -4043,7 +4200,7 @@ static void send_panic_events(char *str)
                                        intf->channels[0].lun,
                                        0, 1); /* no retry, and no wait. */
                 }
-        }       
+        }
 #endif /* CONFIG_IPMI_PANIC_STRING */
 }
 #endif /* CONFIG_IPMI_PANIC_EVENT */
@@ -4052,7 +4209,7 @@ static int has_panicked;
 
 static int panic_event(struct notifier_block *this,
                        unsigned long         event,
-                       void                  *ptr)
+                       void                  *ptr)
 {
         ipmi_smi_t intf;
 
@@ -4066,6 +4223,7 @@ static int panic_event(struct notifier_block *this,
                         /* Interface is not ready. */
                         continue;
 
+                intf->run_to_completion = 1;
                 intf->handlers->set_run_to_completion(intf->send_info, 1);
         }
 
@@ -4133,11 +4291,16 @@ static __exit void cleanup_ipmi(void)
 
         atomic_notifier_chain_unregister(&panic_notifier_list, &panic_block);
 
-        /* This can't be called if any interfaces exist, so no worry about
-           shutting down the interfaces. */
+        /*
+         * This can't be called if any interfaces exist, so no worry
+         * about shutting down the interfaces.
+         */
 
-        /* Tell the timer to stop, then wait for it to stop.  This avoids
-           problems with race conditions removing the timer here. */
+        /*
+         * Tell the timer to stop, then wait for it to stop.  This
+         * avoids problems with race conditions removing the timer
+         * here.
+         */
         atomic_inc(&stop_operation);
         del_timer_sync(&ipmi_timer);
 
@@ -4164,31 +4327,6 @@ module_exit(cleanup_ipmi);
 module_init(ipmi_init_msghandler_mod);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
-MODULE_DESCRIPTION("Incoming and outgoing message routing for an IPMI interface.");
+MODULE_DESCRIPTION("Incoming and outgoing message routing for an IPMI"
+                   " interface.");
 MODULE_VERSION(IPMI_DRIVER_VERSION);
-
-EXPORT_SYMBOL(ipmi_create_user);
-EXPORT_SYMBOL(ipmi_destroy_user);
-EXPORT_SYMBOL(ipmi_get_version);
-EXPORT_SYMBOL(ipmi_request_settime);
-EXPORT_SYMBOL(ipmi_request_supply_msgs);
-EXPORT_SYMBOL(ipmi_poll_interface);
-EXPORT_SYMBOL(ipmi_register_smi);
-EXPORT_SYMBOL(ipmi_unregister_smi);
-EXPORT_SYMBOL(ipmi_register_for_cmd);
-EXPORT_SYMBOL(ipmi_unregister_for_cmd);
-EXPORT_SYMBOL(ipmi_smi_msg_received);
-EXPORT_SYMBOL(ipmi_smi_watchdog_pretimeout);
-EXPORT_SYMBOL(ipmi_alloc_smi_msg);
-EXPORT_SYMBOL(ipmi_addr_length);
-EXPORT_SYMBOL(ipmi_validate_addr);
-EXPORT_SYMBOL(ipmi_set_gets_events);
-EXPORT_SYMBOL(ipmi_smi_watcher_register);
-EXPORT_SYMBOL(ipmi_smi_watcher_unregister);
-EXPORT_SYMBOL(ipmi_set_my_address);
-EXPORT_SYMBOL(ipmi_get_my_address);
-EXPORT_SYMBOL(ipmi_set_my_LUN);
-EXPORT_SYMBOL(ipmi_get_my_LUN);
-EXPORT_SYMBOL(ipmi_smi_add_proc_entry);
-EXPORT_SYMBOL(ipmi_user_set_run_to_completion);
-EXPORT_SYMBOL(ipmi_free_recv_msg);
diff --git a/drivers/char/ipmi/ipmi_poweroff.c b/drivers/char/ipmi/ipmi_poweroff.c
index b86186de7f07..a261bd735dfb 100644
--- a/drivers/char/ipmi/ipmi_poweroff.c
+++ b/drivers/char/ipmi/ipmi_poweroff.c
@@ -87,7 +87,10 @@ MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
 
 /* parameter definition to allow user to flag power cycle */
 module_param(poweroff_powercycle, int, 0644);
-MODULE_PARM_DESC(poweroff_powercycle, " Set to non-zero to enable power cycle instead of power down. Power cycle is contingent on hardware support, otherwise it defaults back to power down.");
+MODULE_PARM_DESC(poweroff_powercycle,
+                 " Set to non-zero to enable power cycle instead of power"
+                 " down. Power cycle is contingent on hardware support,"
+                 " otherwise it defaults back to power down.");
 
 /* Stuff from the get device id command. */
 static unsigned int mfg_id;
@@ -95,22 +98,25 @@ static unsigned int prod_id;
 static unsigned char capabilities;
 static unsigned char ipmi_version;
 
-/* We use our own messages for this operation, we don't let the system
-   allocate them, since we may be in a panic situation.  The whole
-   thing is single-threaded, anyway, so multiple messages are not
-   required. */
+/*
+ * We use our own messages for this operation, we don't let the system
+ * allocate them, since we may be in a panic situation.  The whole
+ * thing is single-threaded, anyway, so multiple messages are not
+ * required.
+ */
+static atomic_t dummy_count = ATOMIC_INIT(0);
 static void dummy_smi_free(struct ipmi_smi_msg *msg)
 {
+        atomic_dec(&dummy_count);
 }
 static void dummy_recv_free(struct ipmi_recv_msg *msg)
 {
+        atomic_dec(&dummy_count);
 }
-static struct ipmi_smi_msg halt_smi_msg =
-{
+static struct ipmi_smi_msg halt_smi_msg = {
         .done = dummy_smi_free
 };
-static struct ipmi_recv_msg halt_recv_msg =
-{
+static struct ipmi_recv_msg halt_recv_msg = {
         .done = dummy_recv_free
 };
 
@@ -127,8 +133,7 @@ static void receive_handler(struct ipmi_recv_msg *recv_msg, void *handler_data)
                 complete(comp);
 }
 
-static struct ipmi_user_hndl ipmi_poweroff_handler =
-{
+static struct ipmi_user_hndl ipmi_poweroff_handler = {
         .ipmi_recv_hndl = receive_handler
 };
 
@@ -152,17 +157,28 @@ static int ipmi_request_wait_for_response(ipmi_user_t            user,
         return halt_recv_msg.msg.data[0];
 }
 
-/* We are in run-to-completion mode, no completion is desired. */
+/* Wait for message to complete, spinning. */
 static int ipmi_request_in_rc_mode(ipmi_user_t            user,
                                    struct ipmi_addr       *addr,
                                    struct kernel_ipmi_msg *send_msg)
 {
         int rv;
 
+        atomic_set(&dummy_count, 2);
         rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, NULL,
                                       &halt_smi_msg, &halt_recv_msg, 0);
-        if (rv)
+        if (rv) {
+                atomic_set(&dummy_count, 0);
                 return rv;
+        }
+
+        /*
+         * Spin until our message is done.
+         */
+        while (atomic_read(&dummy_count) > 0) {
+                ipmi_poll_interface(user);
+                cpu_relax();
+        }
 
         return halt_recv_msg.msg.data[0];
 }
@@ -184,47 +200,47 @@ static int ipmi_request_in_rc_mode(ipmi_user_t            user,
 
 static void (*atca_oem_poweroff_hook)(ipmi_user_t user);
 
-static void pps_poweroff_atca (ipmi_user_t user)
+static void pps_poweroff_atca(ipmi_user_t user)
 {
-        struct ipmi_system_interface_addr smi_addr;
-        struct kernel_ipmi_msg            send_msg;
-        int                               rv;
-        /*
-         * Configure IPMI address for local access
-         */
-        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
-        smi_addr.channel = IPMI_BMC_CHANNEL;
-        smi_addr.lun = 0;
-
-        printk(KERN_INFO PFX "PPS powerdown hook used");
-
-        send_msg.netfn = IPMI_NETFN_OEM;
-        send_msg.cmd = IPMI_ATCA_PPS_GRACEFUL_RESTART;
-        send_msg.data = IPMI_ATCA_PPS_IANA;
-        send_msg.data_len = 3;
-        rv = ipmi_request_in_rc_mode(user,
-                                  (struct ipmi_addr *) &smi_addr,
-                                   &send_msg);
-        if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
-                printk(KERN_ERR PFX "Unable to send ATCA ,"
-                       " IPMI error 0x%x\n", rv);
-        }
+        struct ipmi_system_interface_addr smi_addr;
+        struct kernel_ipmi_msg            send_msg;
+        int                               rv;
+        /*
+         * Configure IPMI address for local access
+         */
+        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
+        smi_addr.channel = IPMI_BMC_CHANNEL;
+        smi_addr.lun = 0;
+
+        printk(KERN_INFO PFX "PPS powerdown hook used");
+
+        send_msg.netfn = IPMI_NETFN_OEM;
+        send_msg.cmd = IPMI_ATCA_PPS_GRACEFUL_RESTART;
+        send_msg.data = IPMI_ATCA_PPS_IANA;
+        send_msg.data_len = 3;
+        rv = ipmi_request_in_rc_mode(user,
+                                     (struct ipmi_addr *) &smi_addr,
+                                     &send_msg);
+        if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
+                printk(KERN_ERR PFX "Unable to send ATCA ,"
+                       " IPMI error 0x%x\n", rv);
+        }
         return;
 }
 
-static int ipmi_atca_detect (ipmi_user_t user)
+static int ipmi_atca_detect(ipmi_user_t user)
 {
         struct ipmi_system_interface_addr smi_addr;
         struct kernel_ipmi_msg            send_msg;
         int                               rv;
         unsigned char                     data[1];
 
-        /*
-         * Configure IPMI address for local access
-         */
-        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
-        smi_addr.channel = IPMI_BMC_CHANNEL;
-        smi_addr.lun = 0;
+        /*
+         * Configure IPMI address for local access
+         */
+        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
+        smi_addr.channel = IPMI_BMC_CHANNEL;
+        smi_addr.lun = 0;
 
         /*
          * Use get address info to check and see if we are ATCA
@@ -238,28 +254,30 @@ static int ipmi_atca_detect (ipmi_user_t user)
                                             (struct ipmi_addr *) &smi_addr,
                                             &send_msg);
 
-        printk(KERN_INFO PFX "ATCA Detect mfg 0x%X prod 0x%X\n", mfg_id, prod_id);
-        if((mfg_id == IPMI_MOTOROLA_MANUFACTURER_ID)
-            && (prod_id == IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID)) {
-                printk(KERN_INFO PFX "Installing Pigeon Point Systems Poweroff Hook\n");
+        printk(KERN_INFO PFX "ATCA Detect mfg 0x%X prod 0x%X\n",
+               mfg_id, prod_id);
+        if ((mfg_id == IPMI_MOTOROLA_MANUFACTURER_ID)
+            && (prod_id == IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID)) {
+                printk(KERN_INFO PFX
+                       "Installing Pigeon Point Systems Poweroff Hook\n");
                 atca_oem_poweroff_hook = pps_poweroff_atca;
         }
         return !rv;
 }
 
-static void ipmi_poweroff_atca (ipmi_user_t user)
+static void ipmi_poweroff_atca(ipmi_user_t user)
 {
         struct ipmi_system_interface_addr smi_addr;
         struct kernel_ipmi_msg            send_msg;
         int                               rv;
         unsigned char                     data[4];
 
-        /*
-         * Configure IPMI address for local access
-         */
-        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
-        smi_addr.channel = IPMI_BMC_CHANNEL;
-        smi_addr.lun = 0;
+        /*
+         * Configure IPMI address for local access
+         */
+        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
+        smi_addr.channel = IPMI_BMC_CHANNEL;
+        smi_addr.lun = 0;
 
         printk(KERN_INFO PFX "Powering down via ATCA power command\n");
 
@@ -273,23 +291,24 @@ static void ipmi_poweroff_atca (ipmi_user_t user)
         data[2] = 0; /* Power Level */
         data[3] = 0; /* Don't change saved presets */
         send_msg.data = data;
-        send_msg.data_len = sizeof (data);
+        send_msg.data_len = sizeof(data);
         rv = ipmi_request_in_rc_mode(user,
                                      (struct ipmi_addr *) &smi_addr,
                                      &send_msg);
-        /** At this point, the system may be shutting down, and most
-         ** serial drivers (if used) will have interrupts turned off
-         ** it may be better to ignore IPMI_UNKNOWN_ERR_COMPLETION_CODE
-         ** return code
-         **/
-        if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
+        /*
+         * At this point, the system may be shutting down, and most
+         * serial drivers (if used) will have interrupts turned off
+         * it may be better to ignore IPMI_UNKNOWN_ERR_COMPLETION_CODE
+         * return code
+         */
+        if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
                 printk(KERN_ERR PFX "Unable to send ATCA powerdown message,"
                        " IPMI error 0x%x\n", rv);
                 goto out;
         }
 
-        if(atca_oem_poweroff_hook)
-                return atca_oem_poweroff_hook(user);
+        if (atca_oem_poweroff_hook)
+                atca_oem_poweroff_hook(user);
  out:
         return;
 }
@@ -310,13 +329,13 @@ static void ipmi_poweroff_atca (ipmi_user_t user)
 #define IPMI_CPI1_PRODUCT_ID            0x000157
 #define IPMI_CPI1_MANUFACTURER_ID       0x0108
 
-static int ipmi_cpi1_detect (ipmi_user_t user)
+static int ipmi_cpi1_detect(ipmi_user_t user)
 {
         return ((mfg_id == IPMI_CPI1_MANUFACTURER_ID)
                 && (prod_id == IPMI_CPI1_PRODUCT_ID));
 }
 
-static void ipmi_poweroff_cpi1 (ipmi_user_t user)
+static void ipmi_poweroff_cpi1(ipmi_user_t user)
 {
         struct ipmi_system_interface_addr smi_addr;
         struct ipmi_ipmb_addr             ipmb_addr;
@@ -328,12 +347,12 @@ static void ipmi_poweroff_cpi1 (ipmi_user_t user)
         unsigned char                     aer_addr;
         unsigned char                     aer_lun;
 
-        /*
-         * Configure IPMI address for local access
-         */
-        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
-        smi_addr.channel = IPMI_BMC_CHANNEL;
-        smi_addr.lun = 0;
+        /*
+         * Configure IPMI address for local access
+         */
+        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
+        smi_addr.channel = IPMI_BMC_CHANNEL;
+        smi_addr.lun = 0;
 
         printk(KERN_INFO PFX "Powering down via CPI1 power command\n");
 
@@ -425,7 +444,7 @@ static void ipmi_poweroff_cpi1 (ipmi_user_t user)
  */
 
 #define DELL_IANA_MFR_ID {0xA2, 0x02, 0x00}
-static int ipmi_dell_chassis_detect (ipmi_user_t user)
+static int ipmi_dell_chassis_detect(ipmi_user_t user)
 {
         const char ipmi_version_major = ipmi_version & 0xF;
         const char ipmi_version_minor = (ipmi_version >> 4) & 0xF;
@@ -444,25 +463,25 @@ static int ipmi_dell_chassis_detect (ipmi_user_t user)
 #define IPMI_NETFN_CHASSIS_REQUEST      0
 #define IPMI_CHASSIS_CONTROL_CMD        0x02
 
-static int ipmi_chassis_detect (ipmi_user_t user)
+static int ipmi_chassis_detect(ipmi_user_t user)
 {
         /* Chassis support, use it. */
         return (capabilities & 0x80);
 }
 
-static void ipmi_poweroff_chassis (ipmi_user_t user)
+static void ipmi_poweroff_chassis(ipmi_user_t user)
 {
         struct ipmi_system_interface_addr smi_addr;
         struct kernel_ipmi_msg            send_msg;
         int                               rv;
         unsigned char                     data[1];
 
-        /*
-         * Configure IPMI address for local access
-         */
-        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
-        smi_addr.channel = IPMI_BMC_CHANNEL;
-        smi_addr.lun = 0;
+        /*
+         * Configure IPMI address for local access
+         */
+        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
+        smi_addr.channel = IPMI_BMC_CHANNEL;
+        smi_addr.lun = 0;
 
  powercyclefailed:
         printk(KERN_INFO PFX "Powering %s via IPMI chassis control command\n",
@@ -525,15 +544,13 @@ static struct poweroff_function poweroff_functions[] = {
 
 
 /* Called on a powerdown request. */
-static void ipmi_poweroff_function (void)
+static void ipmi_poweroff_function(void)
 {
         if (!ready)
                 return;
 
         /* Use run-to-completion mode, since interrupts may be off. */
-        ipmi_user_set_run_to_completion(ipmi_user, 1);
         specific_poweroff_func(ipmi_user);
-        ipmi_user_set_run_to_completion(ipmi_user, 0);
 }
 
 /* Wait for an IPMI interface to be installed, the first one installed
@@ -561,13 +578,13 @@ static void ipmi_po_new_smi(int if_num, struct device *device)
 
         ipmi_ifnum = if_num;
 
-        /*
-         * Do a get device ide and store some results, since this is
+        /*
+         * Do a get device ide and store some results, since this is
          * used by several functions.
-         */
-        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
-        smi_addr.channel = IPMI_BMC_CHANNEL;
-        smi_addr.lun = 0;
+         */
+        smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
+        smi_addr.channel = IPMI_BMC_CHANNEL;
+        smi_addr.lun = 0;
 
         send_msg.netfn = IPMI_NETFN_APP_REQUEST;
         send_msg.cmd = IPMI_GET_DEVICE_ID_CMD;
@@ -632,8 +649,7 @@ static void ipmi_po_smi_gone(int if_num)
         pm_power_off = old_poweroff_func;
 }
 
-static struct ipmi_smi_watcher smi_watcher =
-{
+static struct ipmi_smi_watcher smi_watcher = {
         .owner    = THIS_MODULE,
         .new_smi  = ipmi_po_new_smi,
         .smi_gone = ipmi_po_smi_gone
@@ -675,12 +691,12 @@ static struct ctl_table_header *ipmi_table_header;
 /*
  * Startup and shutdown functions.
  */
-static int ipmi_poweroff_init (void)
+static int ipmi_poweroff_init(void)
 {
         int rv;
 
-        printk (KERN_INFO "Copyright (C) 2004 MontaVista Software -"
-                " IPMI Powerdown via sys_reboot.\n");
+        printk(KERN_INFO "Copyright (C) 2004 MontaVista Software -"
+               " IPMI Powerdown via sys_reboot.\n");
 
         if (poweroff_powercycle)
                 printk(KERN_INFO PFX "Power cycle is enabled.\n");
diff --git a/drivers/char/ipmi/ipmi_si_intf.c b/drivers/char/ipmi/ipmi_si_intf.c
index 4f560d0bb808..5a5455585c1d 100644
--- a/drivers/char/ipmi/ipmi_si_intf.c
+++ b/drivers/char/ipmi/ipmi_si_intf.c
@@ -80,7 +80,7 @@
 #define SI_USEC_PER_JIFFY       (1000000/HZ)
 #define SI_TIMEOUT_JIFFIES      (SI_TIMEOUT_TIME_USEC/SI_USEC_PER_JIFFY)
 #define SI_SHORT_TIMEOUT_USEC  250 /* .25ms when the SM request a
-                                       short timeout */
+                                      short timeout */
 
 /* Bit for BMC global enables. */
 #define IPMI_BMC_RCV_MSG_INTR     0x01
@@ -114,14 +114,61 @@ static char *si_to_str[] = { "kcs", "smic", "bt" };
 
 #define DEVICE_NAME "ipmi_si"
 
-static struct device_driver ipmi_driver =
-{
+static struct device_driver ipmi_driver = {
         .name = DEVICE_NAME,
         .bus = &platform_bus_type
 };
 
-struct smi_info
-{
+
+/*
+ * Indexes into stats[] in smi_info below.
+ */
+enum si_stat_indexes {
+        /*
+         * Number of times the driver requested a timer while an operation
+         * was in progress.
+         */
+        SI_STAT_short_timeouts = 0,
+
+        /*
+         * Number of times the driver requested a timer while nothing was in
+         * progress.
+         */
+        SI_STAT_long_timeouts,
+
+        /* Number of times the interface was idle while being polled. */
+        SI_STAT_idles,
+
+        /* Number of interrupts the driver handled. */
+        SI_STAT_interrupts,
+
+        /* Number of time the driver got an ATTN from the hardware. */
+        SI_STAT_attentions,
+
+        /* Number of times the driver requested flags from the hardware. */
+        SI_STAT_flag_fetches,
+
+        /* Number of times the hardware didn't follow the state machine. */
+        SI_STAT_hosed_count,
+
+        /* Number of completed messages. */
+        SI_STAT_complete_transactions,
+
+        /* Number of IPMI events received from the hardware. */
+        SI_STAT_events,
+
+        /* Number of watchdog pretimeouts. */
+        SI_STAT_watchdog_pretimeouts,
+
+        /* Number of asyncronous messages received. */
+        SI_STAT_incoming_messages,
+
+
+        /* This *must* remain last, add new values above this. */
+        SI_NUM_STATS
+};
+
+struct smi_info {
         int                    intf_num;
         ipmi_smi_t             intf;
         struct si_sm_data      *si_sm;
@@ -134,8 +181,10 @@ struct smi_info
         struct ipmi_smi_msg    *curr_msg;
         enum si_intf_state     si_state;
 
-        /* Used to handle the various types of I/O that can occur with
-           IPMI */
+        /*
+         * Used to handle the various types of I/O that can occur with
+         * IPMI
+         */
         struct si_sm_io io;
         int (*io_setup)(struct smi_info *info);
         void (*io_cleanup)(struct smi_info *info);
@@ -146,15 +195,18 @@ struct smi_info
         void (*addr_source_cleanup)(struct smi_info *info);
         void *addr_source_data;
 
-        /* Per-OEM handler, called from handle_flags().
-           Returns 1 when handle_flags() needs to be re-run
-           or 0 indicating it set si_state itself.
-        */
+        /*
+         * Per-OEM handler, called from handle_flags().  Returns 1
+         * when handle_flags() needs to be re-run or 0 indicating it
+         * set si_state itself.
+         */
         int (*oem_data_avail_handler)(struct smi_info *smi_info);
 
-        /* Flags from the last GET_MSG_FLAGS command, used when an ATTN
-           is set to hold the flags until we are done handling everything
-           from the flags. */
+        /*
+         * Flags from the last GET_MSG_FLAGS command, used when an ATTN
+         * is set to hold the flags until we are done handling everything
+         * from the flags.
+         */
 #define RECEIVE_MSG_AVAIL       0x01
 #define EVENT_MSG_BUFFER_FULL   0x02
 #define WDT_PRE_TIMEOUT_INT     0x08
@@ -162,25 +214,31 @@ struct smi_info
 #define OEM1_DATA_AVAIL     0x40
 #define OEM2_DATA_AVAIL     0x80
 #define OEM_DATA_AVAIL      (OEM0_DATA_AVAIL | \
-                             OEM1_DATA_AVAIL | \
-                             OEM2_DATA_AVAIL)
+                             OEM1_DATA_AVAIL | \
+                             OEM2_DATA_AVAIL)
         unsigned char       msg_flags;
 
-        /* If set to true, this will request events the next time the
-           state machine is idle. */
+        /*
+         * If set to true, this will request events the next time the
+         * state machine is idle.
+         */
         atomic_t            req_events;
 
-        /* If true, run the state machine to completion on every send
-           call.  Generally used after a panic to make sure stuff goes
-           out. */
+        /*
+         * If true, run the state machine to completion on every send
+         * call.  Generally used after a panic to make sure stuff goes
+         * out.
+         */
         int                 run_to_completion;
 
         /* The I/O port of an SI interface. */
         int                 port;
 
-        /* The space between start addresses of the two ports.  For
-           instance, if the first port is 0xca2 and the spacing is 4, then
-           the second port is 0xca6. */
+        /*
+         * The space between start addresses of the two ports.  For
+         * instance, if the first port is 0xca2 and the spacing is 4, then
+         * the second port is 0xca6.
+         */
         unsigned int        spacing;
 
         /* zero if no irq; */
@@ -195,10 +253,12 @@ struct smi_info
         /* Used to gracefully stop the timer without race conditions. */
         atomic_t            stop_operation;
 
-        /* The driver will disable interrupts when it gets into a
-           situation where it cannot handle messages due to lack of
-           memory.  Once that situation clears up, it will re-enable
-           interrupts. */
+        /*
+         * The driver will disable interrupts when it gets into a
+         * situation where it cannot handle messages due to lack of
+         * memory.  Once that situation clears up, it will re-enable
+         * interrupts.
+         */
         int interrupt_disabled;
 
         /* From the get device id response... */
@@ -208,33 +268,28 @@ struct smi_info
         struct device *dev;
         struct platform_device *pdev;
 
-         /* True if we allocated the device, false if it came from
-          * someplace else (like PCI). */
+        /*
+         * True if we allocated the device, false if it came from
+         * someplace else (like PCI).
+         */
         int dev_registered;
 
         /* Slave address, could be reported from DMI. */
         unsigned char slave_addr;
 
         /* Counters and things for the proc filesystem. */
-        spinlock_t count_lock;
-        unsigned long short_timeouts;
-        unsigned long long_timeouts;
-        unsigned long timeout_restarts;
-        unsigned long idles;
-        unsigned long interrupts;
-        unsigned long attentions;
-        unsigned long flag_fetches;
-        unsigned long hosed_count;
-        unsigned long complete_transactions;
-        unsigned long events;
-        unsigned long watchdog_pretimeouts;
-        unsigned long incoming_messages;
-
-        struct task_struct *thread;
+        atomic_t stats[SI_NUM_STATS];
+
+        struct task_struct *thread;
 
         struct list_head link;
 };
 
+#define smi_inc_stat(smi, stat) \
+        atomic_inc(&(smi)->stats[SI_STAT_ ## stat])
+#define smi_get_stat(smi, stat) \
+        ((unsigned int) atomic_read(&(smi)->stats[SI_STAT_ ## stat]))
+
 #define SI_MAX_PARMS 4
 
 static int force_kipmid[SI_MAX_PARMS];
@@ -246,7 +301,7 @@ static int try_smi_init(struct smi_info *smi);
 static void cleanup_one_si(struct smi_info *to_clean);
 
 static ATOMIC_NOTIFIER_HEAD(xaction_notifier_list);
-static int register_xaction_notifier(struct notifier_block * nb)
+static int register_xaction_notifier(struct notifier_block *nb)
 {
         return atomic_notifier_chain_register(&xaction_notifier_list, nb);
 }
@@ -255,7 +310,7 @@ static void deliver_recv_msg(struct smi_info *smi_info,
                              struct ipmi_smi_msg *msg)
 {
         /* Deliver the message to the upper layer with the lock
-           released. */
+           released. */
         spin_unlock(&(smi_info->si_lock));
         ipmi_smi_msg_received(smi_info->intf, msg);
         spin_lock(&(smi_info->si_lock));
@@ -287,9 +342,12 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
         struct timeval t;
 #endif
 
-        /* No need to save flags, we aleady have interrupts off and we
-           already hold the SMI lock. */
-        spin_lock(&(smi_info->msg_lock));
+        /*
+         * No need to save flags, we aleady have interrupts off and we
+         * already hold the SMI lock.
+         */
+        if (!smi_info->run_to_completion)
+                spin_lock(&(smi_info->msg_lock));
 
         /* Pick the high priority queue first. */
         if (!list_empty(&(smi_info->hp_xmit_msgs))) {
@@ -310,7 +368,7 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
                                                 link);
 #ifdef DEBUG_TIMING
                 do_gettimeofday(&t);
-                printk("**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
+                printk(KERN_DEBUG "**Start2: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
                 err = atomic_notifier_call_chain(&xaction_notifier_list,
                                 0, smi_info);
@@ -322,14 +380,14 @@ static enum si_sm_result start_next_msg(struct smi_info *smi_info)
                         smi_info->si_sm,
                         smi_info->curr_msg->data,
                         smi_info->curr_msg->data_size);
-                if (err) {
+                if (err)
                         return_hosed_msg(smi_info, err);
-                }
 
                 rv = SI_SM_CALL_WITHOUT_DELAY;
         }
-        out:
-        spin_unlock(&(smi_info->msg_lock));
+ out:
+        if (!smi_info->run_to_completion)
+                spin_unlock(&(smi_info->msg_lock));
 
         return rv;
 }
@@ -338,8 +396,10 @@ static void start_enable_irq(struct smi_info *smi_info)
 {
         unsigned char msg[2];
 
-        /* If we are enabling interrupts, we have to tell the
-           BMC to use them. */
+        /*
+         * If we are enabling interrupts, we have to tell the
+         * BMC to use them.
+         */
         msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
         msg[1] = IPMI_GET_BMC_GLOBAL_ENABLES_CMD;
 
@@ -371,10 +431,12 @@ static void start_clear_flags(struct smi_info *smi_info)
         smi_info->si_state = SI_CLEARING_FLAGS;
 }
 
-/* When we have a situtaion where we run out of memory and cannot
-   allocate messages, we just leave them in the BMC and run the system
-   polled until we can allocate some memory.  Once we have some
-   memory, we will re-enable the interrupt. */
+/*
+ * When we have a situtaion where we run out of memory and cannot
+ * allocate messages, we just leave them in the BMC and run the system
+ * polled until we can allocate some memory.  Once we have some
+ * memory, we will re-enable the interrupt.
+ */
 static inline void disable_si_irq(struct smi_info *smi_info)
 {
         if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
@@ -396,9 +458,7 @@ static void handle_flags(struct smi_info *smi_info)
  retry:
         if (smi_info->msg_flags & WDT_PRE_TIMEOUT_INT) {
                 /* Watchdog pre-timeout */
-                spin_lock(&smi_info->count_lock);
-                smi_info->watchdog_pretimeouts++;
-                spin_unlock(&smi_info->count_lock);
+                smi_inc_stat(smi_info, watchdog_pretimeouts);
 
                 start_clear_flags(smi_info);
                 smi_info->msg_flags &= ~WDT_PRE_TIMEOUT_INT;
@@ -444,12 +504,11 @@ static void handle_flags(struct smi_info *smi_info)
                         smi_info->curr_msg->data_size);
                 smi_info->si_state = SI_GETTING_EVENTS;
         } else if (smi_info->msg_flags & OEM_DATA_AVAIL &&
-                   smi_info->oem_data_avail_handler) {
+                   smi_info->oem_data_avail_handler) {
                 if (smi_info->oem_data_avail_handler(smi_info))
                         goto retry;
-        } else {
+        } else
                 smi_info->si_state = SI_NORMAL;
-        }
 }
 
 static void handle_transaction_done(struct smi_info *smi_info)
@@ -459,7 +518,7 @@ static void handle_transaction_done(struct smi_info *smi_info)
         struct timeval t;
 
         do_gettimeofday(&t);
-        printk("**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
+        printk(KERN_DEBUG "**Done: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
         switch (smi_info->si_state) {
         case SI_NORMAL:
@@ -472,9 +531,11 @@ static void handle_transaction_done(struct smi_info *smi_info)
                                 smi_info->curr_msg->rsp,
                                 IPMI_MAX_MSG_LENGTH);
 
-                /* Do this here becase deliver_recv_msg() releases the
-                   lock, and a new message can be put in during the
-                   time the lock is released. */
+                /*
+                 * Do this here becase deliver_recv_msg() releases the
+                 * lock, and a new message can be put in during the
+                 * time the lock is released.
+                 */
                 msg = smi_info->curr_msg;
                 smi_info->curr_msg = NULL;
                 deliver_recv_msg(smi_info, msg);
@@ -488,12 +549,13 @@ static void handle_transaction_done(struct smi_info *smi_info)
                 /* We got the flags from the SMI, now handle them. */
                 len = smi_info->handlers->get_result(smi_info->si_sm, msg, 4);
                 if (msg[2] != 0) {
-                        /* Error fetching flags, just give up for
-                           now. */
+                        /* Error fetching flags, just give up for now. */
                         smi_info->si_state = SI_NORMAL;
                 } else if (len < 4) {
-                        /* Hmm, no flags.  That's technically illegal, but
-                           don't use uninitialized data. */
+                        /*
+                         * Hmm, no flags.  That's technically illegal, but
+                         * don't use uninitialized data.
+                         */
                         smi_info->si_state = SI_NORMAL;
                 } else {
                         smi_info->msg_flags = msg[3];
@@ -530,9 +592,11 @@ static void handle_transaction_done(struct smi_info *smi_info)
                                 smi_info->curr_msg->rsp,
                                 IPMI_MAX_MSG_LENGTH);
 
-                /* Do this here becase deliver_recv_msg() releases the
-                   lock, and a new message can be put in during the
-                   time the lock is released. */
+                /*
+                 * Do this here becase deliver_recv_msg() releases the
+                 * lock, and a new message can be put in during the
+                 * time the lock is released.
+                 */
                 msg = smi_info->curr_msg;
                 smi_info->curr_msg = NULL;
                 if (msg->rsp[2] != 0) {
@@ -543,14 +607,14 @@ static void handle_transaction_done(struct smi_info *smi_info)
                         smi_info->msg_flags &= ~EVENT_MSG_BUFFER_FULL;
                         handle_flags(smi_info);
                 } else {
-                        spin_lock(&smi_info->count_lock);
-                        smi_info->events++;
-                        spin_unlock(&smi_info->count_lock);
-
-                        /* Do this before we deliver the message
-                           because delivering the message releases the
-                           lock and something else can mess with the
-                           state. */
+                        smi_inc_stat(smi_info, events);
+
+                        /*
+                         * Do this before we deliver the message
+                         * because delivering the message releases the
+                         * lock and something else can mess with the
+                         * state.
+                         */
                         handle_flags(smi_info);
 
                         deliver_recv_msg(smi_info, msg);
@@ -566,9 +630,11 @@ static void handle_transaction_done(struct smi_info *smi_info)
                                 smi_info->curr_msg->rsp,
                                 IPMI_MAX_MSG_LENGTH);
 
-                /* Do this here becase deliver_recv_msg() releases the
-                   lock, and a new message can be put in during the
-                   time the lock is released. */
+                /*
+                 * Do this here becase deliver_recv_msg() releases the
+                 * lock, and a new message can be put in during the
+                 * time the lock is released.
+                 */
                 msg = smi_info->curr_msg;
                 smi_info->curr_msg = NULL;
                 if (msg->rsp[2] != 0) {
@@ -579,14 +645,14 @@ static void handle_transaction_done(struct smi_info *smi_info)
                         smi_info->msg_flags &= ~RECEIVE_MSG_AVAIL;
                         handle_flags(smi_info);
                 } else {
-                        spin_lock(&smi_info->count_lock);
-                        smi_info->incoming_messages++;
-                        spin_unlock(&smi_info->count_lock);
-
-                        /* Do this before we deliver the message
-                           because delivering the message releases the
-                           lock and something else can mess with the
-                           state. */
+                        smi_inc_stat(smi_info, incoming_messages);
+
+                        /*
+                         * Do this before we deliver the message
+                         * because delivering the message releases the
+                         * lock and something else can mess with the
+                         * state.
+                         */
                         handle_flags(smi_info);
 
                         deliver_recv_msg(smi_info, msg);
@@ -674,69 +740,70 @@ static void handle_transaction_done(struct smi_info *smi_info)
         }
 }
 
-/* Called on timeouts and events.  Timeouts should pass the elapsed
-   time, interrupts should pass in zero.  Must be called with
-   si_lock held and interrupts disabled. */
+/*
+ * Called on timeouts and events.  Timeouts should pass the elapsed
+ * time, interrupts should pass in zero.  Must be called with
+ * si_lock held and interrupts disabled.
+ */
 static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
                                            int time)
 {
         enum si_sm_result si_sm_result;
 
  restart:
-        /* There used to be a loop here that waited a little while
-           (around 25us) before giving up.  That turned out to be
-           pointless, the minimum delays I was seeing were in the 300us
-           range, which is far too long to wait in an interrupt.  So
-           we just run until the state machine tells us something
-           happened or it needs a delay. */
+        /*
+         * There used to be a loop here that waited a little while
+         * (around 25us) before giving up.  That turned out to be
+         * pointless, the minimum delays I was seeing were in the 300us
+         * range, which is far too long to wait in an interrupt.  So
+         * we just run until the state machine tells us something
+         * happened or it needs a delay.
+         */
         si_sm_result = smi_info->handlers->event(smi_info->si_sm, time);
         time = 0;
         while (si_sm_result == SI_SM_CALL_WITHOUT_DELAY)
-        {
                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
-        }
 
-        if (si_sm_result == SI_SM_TRANSACTION_COMPLETE)
-        {
-                spin_lock(&smi_info->count_lock);
-                smi_info->complete_transactions++;
-                spin_unlock(&smi_info->count_lock);
+        if (si_sm_result == SI_SM_TRANSACTION_COMPLETE) {
+                smi_inc_stat(smi_info, complete_transactions);
 
                 handle_transaction_done(smi_info);
                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
-        }
-        else if (si_sm_result == SI_SM_HOSED)
-        {
-                spin_lock(&smi_info->count_lock);
-                smi_info->hosed_count++;
-                spin_unlock(&smi_info->count_lock);
+        } else if (si_sm_result == SI_SM_HOSED) {
+                smi_inc_stat(smi_info, hosed_count);
 
-                /* Do the before return_hosed_msg, because that
-                   releases the lock. */
+                /*
+                 * Do the before return_hosed_msg, because that
+                 * releases the lock.
+                 */
                 smi_info->si_state = SI_NORMAL;
                 if (smi_info->curr_msg != NULL) {
-                        /* If we were handling a user message, format
-                           a response to send to the upper layer to
-                           tell it about the error. */
+                        /*
+                         * If we were handling a user message, format
+                         * a response to send to the upper layer to
+                         * tell it about the error.
+                         */
                         return_hosed_msg(smi_info, IPMI_ERR_UNSPECIFIED);
                 }
                 si_sm_result = smi_info->handlers->event(smi_info->si_sm, 0);
         }
 
-        /* We prefer handling attn over new messages. */
-        if (si_sm_result == SI_SM_ATTN)
-        {
+        /*
+         * We prefer handling attn over new messages.  But don't do
+         * this if there is not yet an upper layer to handle anything.
+         */
+        if (likely(smi_info->intf) && si_sm_result == SI_SM_ATTN) {
                 unsigned char msg[2];
 
-                spin_lock(&smi_info->count_lock);
-                smi_info->attentions++;
-                spin_unlock(&smi_info->count_lock);
+                smi_inc_stat(smi_info, attentions);
 
-                /* Got a attn, send down a get message flags to see
-                   what's causing it.  It would be better to handle
-                   this in the upper layer, but due to the way
-                   interrupts work with the SMI, that's not really
-                   possible. */
+                /*
+                 * Got a attn, send down a get message flags to see
+                 * what's causing it.  It would be better to handle
+                 * this in the upper layer, but due to the way
+                 * interrupts work with the SMI, that's not really
+                 * possible.
+                 */
                 msg[0] = (IPMI_NETFN_APP_REQUEST << 2);
                 msg[1] = IPMI_GET_MSG_FLAGS_CMD;
 
@@ -748,20 +815,19 @@ static enum si_sm_result smi_event_handler(struct smi_info *smi_info,
 
         /* If we are currently idle, try to start the next message. */
         if (si_sm_result == SI_SM_IDLE) {
-                spin_lock(&smi_info->count_lock);
-                smi_info->idles++;
-                spin_unlock(&smi_info->count_lock);
+                smi_inc_stat(smi_info, idles);
 
                 si_sm_result = start_next_msg(smi_info);
                 if (si_sm_result != SI_SM_IDLE)
                         goto restart;
-        }
+        }
 
         if ((si_sm_result == SI_SM_IDLE)
-            && (atomic_read(&smi_info->req_events)))
-        {
-                /* We are idle and the upper layer requested that I fetch
-                   events, so do so. */
+            && (atomic_read(&smi_info->req_events))) {
+                /*
+                 * We are idle and the upper layer requested that I fetch
+                 * events, so do so.
+                 */
                 atomic_set(&smi_info->req_events, 0);
 
                 smi_info->curr_msg = ipmi_alloc_smi_msg();
@@ -803,56 +869,50 @@ static void sender(void                *send_info,
                 return;
         }
 
-        spin_lock_irqsave(&(smi_info->msg_lock), flags);
 #ifdef DEBUG_TIMING
         do_gettimeofday(&t);
         printk("**Enqueue: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
 
         if (smi_info->run_to_completion) {
-                /* If we are running to completion, then throw it in
-                   the list and run transactions until everything is
-                   clear.  Priority doesn't matter here. */
+                /*
+                 * If we are running to completion, then throw it in
+                 * the list and run transactions until everything is
+                 * clear.  Priority doesn't matter here.
+                 */
+
+                /*
+                 * Run to completion means we are single-threaded, no
+                 * need for locks.
+                 */
                 list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
 
-                /* We have to release the msg lock and claim the smi
-                   lock in this case, because of race conditions. */
-                spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
-
-                spin_lock_irqsave(&(smi_info->si_lock), flags);
                 result = smi_event_handler(smi_info, 0);
                 while (result != SI_SM_IDLE) {
                         udelay(SI_SHORT_TIMEOUT_USEC);
                         result = smi_event_handler(smi_info,
                                                    SI_SHORT_TIMEOUT_USEC);
                 }
-                spin_unlock_irqrestore(&(smi_info->si_lock), flags);
                 return;
-        } else {
-                if (priority > 0) {
-                        list_add_tail(&(msg->link), &(smi_info->hp_xmit_msgs));
-                } else {
-                        list_add_tail(&(msg->link), &(smi_info->xmit_msgs));
-                }
         }
-        spin_unlock_irqrestore(&(smi_info->msg_lock), flags);
 
-        spin_lock_irqsave(&(smi_info->si_lock), flags);
-        if ((smi_info->si_state == SI_NORMAL)
-            && (smi_info->curr_msg == NULL))
-        {
+        spin_lock_irqsave(&smi_info->msg_lock, flags);
+        if (priority > 0)
+                list_add_tail(&msg->link, &smi_info->hp_xmit_msgs);
+        else
+                list_add_tail(&msg->link, &smi_info->xmit_msgs);
+        spin_unlock_irqrestore(&smi_info->msg_lock, flags);
+
+        spin_lock_irqsave(&smi_info->si_lock, flags);
+        if (smi_info->si_state == SI_NORMAL && smi_info->curr_msg == NULL)
                 start_next_msg(smi_info);
-        }
-        spin_unlock_irqrestore(&(smi_info->si_lock), flags);
+        spin_unlock_irqrestore(&smi_info->si_lock, flags);
 }
 
 static void set_run_to_completion(void *send_info, int i_run_to_completion)
 {
         struct smi_info   *smi_info = send_info;
         enum si_sm_result result;
-        unsigned long     flags;
-
-        spin_lock_irqsave(&(smi_info->si_lock), flags);
 
         smi_info->run_to_completion = i_run_to_completion;
         if (i_run_to_completion) {
@@ -863,8 +923,6 @@ static void set_run_to_completion(void *send_info, int i_run_to_completion)
                                                    SI_SHORT_TIMEOUT_USEC);
                 }
         }
-
-        spin_unlock_irqrestore(&(smi_info->si_lock), flags);
 }
 
 static int ipmi_thread(void *data)
@@ -878,9 +936,8 @@ static int ipmi_thread(void *data)
                 spin_lock_irqsave(&(smi_info->si_lock), flags);
                 smi_result = smi_event_handler(smi_info, 0);
                 spin_unlock_irqrestore(&(smi_info->si_lock), flags);
-                if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
-                        /* do nothing */
-                }
+                if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
+                        ; /* do nothing */
                 else if (smi_result == SI_SM_CALL_WITH_DELAY)
                         schedule();
                 else
@@ -931,7 +988,7 @@ static void smi_timeout(unsigned long data)
         spin_lock_irqsave(&(smi_info->si_lock), flags);
 #ifdef DEBUG_TIMING
         do_gettimeofday(&t);
-        printk("**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
+        printk(KERN_DEBUG "**Timer: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
         jiffies_now = jiffies;
         time_diff = (((long)jiffies_now - (long)smi_info->last_timeout_jiffies)
@@ -945,23 +1002,19 @@ static void smi_timeout(unsigned long data)
         if ((smi_info->irq) && (!smi_info->interrupt_disabled)) {
                 /* Running with interrupts, only do long timeouts. */
                 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
-                spin_lock_irqsave(&smi_info->count_lock, flags);
-                smi_info->long_timeouts++;
-                spin_unlock_irqrestore(&smi_info->count_lock, flags);
+                smi_inc_stat(smi_info, long_timeouts);
                 goto do_add_timer;
         }
 
-        /* If the state machine asks for a short delay, then shorten
-           the timer timeout. */
+        /*
+         * If the state machine asks for a short delay, then shorten
+         * the timer timeout.
+         */
         if (smi_result == SI_SM_CALL_WITH_DELAY) {
-                spin_lock_irqsave(&smi_info->count_lock, flags);
-                smi_info->short_timeouts++;
-                spin_unlock_irqrestore(&smi_info->count_lock, flags);
+                smi_inc_stat(smi_info, short_timeouts);
                 smi_info->si_timer.expires = jiffies + 1;
         } else {
-                spin_lock_irqsave(&smi_info->count_lock, flags);
-                smi_info->long_timeouts++;
-                spin_unlock_irqrestore(&smi_info->count_lock, flags);
+                smi_inc_stat(smi_info, long_timeouts);
                 smi_info->si_timer.expires = jiffies + SI_TIMEOUT_JIFFIES;
         }
 
@@ -979,13 +1032,11 @@ static irqreturn_t si_irq_handler(int irq, void *data)
 
         spin_lock_irqsave(&(smi_info->si_lock), flags);
 
-        spin_lock(&smi_info->count_lock);
-        smi_info->interrupts++;
-        spin_unlock(&smi_info->count_lock);
+        smi_inc_stat(smi_info, interrupts);
 
 #ifdef DEBUG_TIMING
         do_gettimeofday(&t);
-        printk("**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
+        printk(KERN_DEBUG "**Interrupt: %d.%9.9d\n", t.tv_sec, t.tv_usec);
 #endif
         smi_event_handler(smi_info, 0);
         spin_unlock_irqrestore(&(smi_info->si_lock), flags);
@@ -1028,7 +1079,7 @@ static int smi_start_processing(void       *send_info,
          * The BT interface is efficient enough to not need a thread,
          * and there is no need for a thread if we have interrupts.
          */
-        else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
+        else if ((new_smi->si_type != SI_BT) && (!new_smi->irq))
                 enable = 1;
 
         if (enable) {
@@ -1054,8 +1105,7 @@ static void set_maintenance_mode(void *send_info, int enable)
                 atomic_set(&smi_info->req_events, 0);
 }
 
-static struct ipmi_smi_handlers handlers =
-{
+static struct ipmi_smi_handlers handlers = {
         .owner                  = THIS_MODULE,
         .start_processing       = smi_start_processing,
         .sender                 = sender,
@@ -1065,8 +1115,10 @@ static struct ipmi_smi_handlers handlers =
         .poll                   = poll,
 };
 
-/* There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
-   a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS */
+/*
+ * There can be 4 IO ports passed in (with or without IRQs), 4 addresses,
+ * a default IO port, and 1 ACPI/SPMI address.  That sets SI_MAX_DRIVERS.
+ */
 
 static LIST_HEAD(smi_infos);
 static DEFINE_MUTEX(smi_infos_lock);
@@ -1257,10 +1309,9 @@ static void port_cleanup(struct smi_info *info)
         int          idx;
 
         if (addr) {
-                for (idx = 0; idx < info->io_size; idx++) {
+                for (idx = 0; idx < info->io_size; idx++)
                         release_region(addr + idx * info->io.regspacing,
                                        info->io.regsize);
-                }
         }
 }
 
@@ -1274,8 +1325,10 @@ static int port_setup(struct smi_info *info)
 
         info->io_cleanup = port_cleanup;
 
-        /* Figure out the actual inb/inw/inl/etc routine to use based
-           upon the register size. */
+        /*
+         * Figure out the actual inb/inw/inl/etc routine to use based
+         * upon the register size.
+         */
         switch (info->io.regsize) {
         case 1:
                 info->io.inputb = port_inb;
@@ -1290,17 +1343,18 @@ static int port_setup(struct smi_info *info)
                 info->io.outputb = port_outl;
                 break;
         default:
-                printk("ipmi_si: Invalid register size: %d\n",
+                printk(KERN_WARNING "ipmi_si: Invalid register size: %d\n",
                        info->io.regsize);
                 return -EINVAL;
         }
 
-        /* Some BIOSes reserve disjoint I/O regions in their ACPI
+        /*
+         * Some BIOSes reserve disjoint I/O regions in their ACPI
          * tables.  This causes problems when trying to register the
          * entire I/O region.  Therefore we must register each I/O
          * port separately.
          */
-        for (idx = 0; idx < info->io_size; idx++) {
+        for (idx = 0; idx < info->io_size; idx++) {
                 if (request_region(addr + idx * info->io.regspacing,
                                    info->io.regsize, DEVICE_NAME) == NULL) {
                         /* Undo allocations */
@@ -1388,8 +1442,10 @@ static int mem_setup(struct smi_info *info)
 
         info->io_cleanup = mem_cleanup;
 
-        /* Figure out the actual readb/readw/readl/etc routine to use based
-           upon the register size. */
+        /*
+         * Figure out the actual readb/readw/readl/etc routine to use based
+         * upon the register size.
+         */
         switch (info->io.regsize) {
         case 1:
                 info->io.inputb = intf_mem_inb;
@@ -1410,16 +1466,18 @@ static int mem_setup(struct smi_info *info)
                 break;
 #endif
         default:
-                printk("ipmi_si: Invalid register size: %d\n",
+                printk(KERN_WARNING "ipmi_si: Invalid register size: %d\n",
                        info->io.regsize);
                 return -EINVAL;
         }
 
-        /* Calculate the total amount of memory to claim.  This is an
+        /*
+         * Calculate the total amount of memory to claim.  This is an
          * unusual looking calculation, but it avoids claiming any
          * more memory than it has to.  It will claim everything
          * between the first address to the end of the last full
-         * register. */
+         * register.
+         */
         mapsize = ((info->io_size * info->io.regspacing)
                    - (info->io.regspacing - info->io.regsize));
 
@@ -1749,9 +1807,11 @@ static __devinit void hardcode_find_bmc(void)
 
 #include <linux/acpi.h>
 
-/* Once we get an ACPI failure, we don't try any more, because we go
-   through the tables sequentially.  Once we don't find a table, there
-   are no more. */
+/*
+ * Once we get an ACPI failure, we don't try any more, because we go
+ * through the tables sequentially.  Once we don't find a table, there
+ * are no more.
+ */
 static int acpi_failure;
 
 /* For GPE-type interrupts. */
@@ -1765,9 +1825,7 @@ static u32 ipmi_acpi_gpe(void *context)
 
         spin_lock_irqsave(&(smi_info->si_lock), flags);
 
-        spin_lock(&smi_info->count_lock);
-        smi_info->interrupts++;
-        spin_unlock(&smi_info->count_lock);
+        smi_inc_stat(smi_info, interrupts);
 
 #ifdef DEBUG_TIMING
         do_gettimeofday(&t);
@@ -1816,7 +1874,8 @@ static int acpi_gpe_irq_setup(struct smi_info *info)
 
 /*
  * Defined at
- * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/Docs/TechPapers/IA64/hpspmi.pdf
+ * http://h21007.www2.hp.com/dspp/files/unprotected/devresource/
+ * Docs/TechPapers/IA64/hpspmi.pdf
  */
 struct SPMITable {
         s8      Signature[4];
@@ -1838,14 +1897,18 @@ struct SPMITable {
          */
         u8      InterruptType;
 
-        /* If bit 0 of InterruptType is set, then this is the SCI
-           interrupt in the GPEx_STS register. */
+        /*
+         * If bit 0 of InterruptType is set, then this is the SCI
+         * interrupt in the GPEx_STS register.
+         */
         u8      GPE;
 
         s16     Reserved;
 
-        /* If bit 1 of InterruptType is set, then this is the I/O
-           APIC/SAPIC interrupt. */
+        /*
+         * If bit 1 of InterruptType is set, then this is the I/O
+         * APIC/SAPIC interrupt.
+         */
         u32     GlobalSystemInterrupt;
 
         /* The actual register address. */
@@ -1863,7 +1926,7 @@ static __devinit int try_init_acpi(struct SPMITable *spmi)
 
         if (spmi->IPMIlegacy != 1) {
             printk(KERN_INFO "IPMI: Bad SPMI legacy %d\n", spmi->IPMIlegacy);
-            return -ENODEV;
+            return -ENODEV;
         }
 
         if (spmi->addr.space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
@@ -1880,8 +1943,7 @@ static __devinit int try_init_acpi(struct SPMITable *spmi)
         info->addr_source = "ACPI";
 
         /* Figure out the interface type. */
-        switch (spmi->InterfaceType)
-        {
+        switch (spmi->InterfaceType) {
         case 1: /* KCS */
                 info->si_type = SI_KCS;
                 break;
@@ -1929,7 +1991,8 @@ static __devinit int try_init_acpi(struct SPMITable *spmi)
                 info->io.addr_type = IPMI_IO_ADDR_SPACE;
         } else {
                 kfree(info);
-                printk("ipmi_si: Unknown ACPI I/O Address type\n");
+                printk(KERN_WARNING
+                       "ipmi_si: Unknown ACPI I/O Address type\n");
                 return -EIO;
         }
         info->io.addr_data = spmi->addr.address;
@@ -1963,8 +2026,7 @@ static __devinit void acpi_find_bmc(void)
 #endif
 
 #ifdef CONFIG_DMI
-struct dmi_ipmi_data
-{
+struct dmi_ipmi_data {
         u8              type;
         u8              addr_space;
         unsigned long   base_addr;
@@ -1989,11 +2051,10 @@ static int __devinit decode_dmi(const struct dmi_header *dm,
                         /* I/O */
                         base_addr &= 0xFFFE;
                         dmi->addr_space = IPMI_IO_ADDR_SPACE;
-                }
-                else {
+                } else
                         /* Memory */
                         dmi->addr_space = IPMI_MEM_ADDR_SPACE;
-                }
+
                 /* If bit 4 of byte 0x10 is set, then the lsb for the address
                    is odd. */
                 dmi->base_addr = base_addr | ((data[0x10] & 0x10) >> 4);
@@ -2002,7 +2063,7 @@ static int __devinit decode_dmi(const struct dmi_header *dm,
 
                 /* The top two bits of byte 0x10 hold the register spacing. */
                 reg_spacing = (data[0x10] & 0xC0) >> 6;
-                switch(reg_spacing){
+                switch (reg_spacing) {
                 case 0x00: /* Byte boundaries */
                     dmi->offset = 1;
                     break;
@@ -2018,12 +2079,14 @@ static int __devinit decode_dmi(const struct dmi_header *dm,
                 }
         } else {
                 /* Old DMI spec. */
-                /* Note that technically, the lower bit of the base
+                /*
+                 * Note that technically, the lower bit of the base
                  * address should be 1 if the address is I/O and 0 if
                  * the address is in memory.  So many systems get that
                  * wrong (and all that I have seen are I/O) so we just
                  * ignore that bit and assume I/O.  Systems that use
-                 * memory should use the newer spec, anyway. */
+                 * memory should use the newer spec, anyway.
+                 */
                 dmi->base_addr = base_addr & 0xfffe;
                 dmi->addr_space = IPMI_IO_ADDR_SPACE;
                 dmi->offset = 1;
@@ -2230,13 +2293,13 @@ static struct pci_device_id ipmi_pci_devices[] = {
 MODULE_DEVICE_TABLE(pci, ipmi_pci_devices);
 
 static struct pci_driver ipmi_pci_driver = {
-        .name =         DEVICE_NAME,
-        .id_table =     ipmi_pci_devices,
-        .probe =        ipmi_pci_probe,
-        .remove =       __devexit_p(ipmi_pci_remove),
+        .name =         DEVICE_NAME,
+        .id_table =     ipmi_pci_devices,
+        .probe =        ipmi_pci_probe,
+        .remove =       __devexit_p(ipmi_pci_remove),
 #ifdef CONFIG_PM
-        .suspend =      ipmi_pci_suspend,
-        .resume =       ipmi_pci_resume,
+        .suspend =      ipmi_pci_suspend,
+        .resume =       ipmi_pci_resume,
 #endif
 };
 #endif /* CONFIG_PCI */
@@ -2306,7 +2369,7 @@ static int __devinit ipmi_of_probe(struct of_device *dev,
                 info->io.addr_data, info->io.regsize, info->io.regspacing,
                 info->irq);
 
-        dev->dev.driver_data = (void*) info;
+        dev->dev.driver_data = (void *) info;
 
         return try_smi_init(info);
 }
@@ -2319,14 +2382,16 @@ static int __devexit ipmi_of_remove(struct of_device *dev)
 
 static struct of_device_id ipmi_match[] =
 {
-        { .type = "ipmi", .compatible = "ipmi-kcs",  .data = (void *)(unsigned long) SI_KCS },
-        { .type = "ipmi", .compatible = "ipmi-smic", .data = (void *)(unsigned long) SI_SMIC },
-        { .type = "ipmi", .compatible = "ipmi-bt",   .data = (void *)(unsigned long) SI_BT },
+        { .type = "ipmi", .compatible = "ipmi-kcs",
+          .data = (void *)(unsigned long) SI_KCS },
+        { .type = "ipmi", .compatible = "ipmi-smic",
+          .data = (void *)(unsigned long) SI_SMIC },
+        { .type = "ipmi", .compatible = "ipmi-bt",
+          .data = (void *)(unsigned long) SI_BT },
         {},
 };
 
-static struct of_platform_driver ipmi_of_platform_driver =
-{
+static struct of_platform_driver ipmi_of_platform_driver = {
         .name           = "ipmi",
         .match_table    = ipmi_match,
         .probe          = ipmi_of_probe,
@@ -2347,32 +2412,32 @@ static int try_get_dev_id(struct smi_info *smi_info)
         if (!resp)
                 return -ENOMEM;
 
-        /* Do a Get Device ID command, since it comes back with some
-           useful info. */
+        /*
+         * Do a Get Device ID command, since it comes back with some
+         * useful info.
+         */
         msg[0] = IPMI_NETFN_APP_REQUEST << 2;
         msg[1] = IPMI_GET_DEVICE_ID_CMD;
         smi_info->handlers->start_transaction(smi_info->si_sm, msg, 2);
 
         smi_result = smi_info->handlers->event(smi_info->si_sm, 0);
-        for (;;)
-        {
+        for (;;) {
                 if (smi_result == SI_SM_CALL_WITH_DELAY ||
                     smi_result == SI_SM_CALL_WITH_TICK_DELAY) {
                         schedule_timeout_uninterruptible(1);
                         smi_result = smi_info->handlers->event(
                                 smi_info->si_sm, 100);
-                }
-                else if (smi_result == SI_SM_CALL_WITHOUT_DELAY)
-                {
+                } else if (smi_result == SI_SM_CALL_WITHOUT_DELAY) {
                         smi_result = smi_info->handlers->event(
                                 smi_info->si_sm, 0);
-                }
-                else
+                } else
                         break;
         }
         if (smi_result == SI_SM_HOSED) {
-                /* We couldn't get the state machine to run, so whatever's at
-                   the port is probably not an IPMI SMI interface. */
+                /*
+                 * We couldn't get the state machine to run, so whatever's at
+                 * the port is probably not an IPMI SMI interface.
+                 */
                 rv = -ENODEV;
                 goto out;
         }
@@ -2405,30 +2470,28 @@ static int stat_file_read_proc(char *page, char **start, off_t off,
 
         out += sprintf(out, "interrupts_enabled:    %d\n",
                        smi->irq && !smi->interrupt_disabled);
-        out += sprintf(out, "short_timeouts:        %ld\n",
-                       smi->short_timeouts);
-        out += sprintf(out, "long_timeouts:         %ld\n",
-                       smi->long_timeouts);
-        out += sprintf(out, "timeout_restarts:      %ld\n",
-                       smi->timeout_restarts);
-        out += sprintf(out, "idles:                 %ld\n",
-                       smi->idles);
-        out += sprintf(out, "interrupts:            %ld\n",
-                       smi->interrupts);
-        out += sprintf(out, "attentions:            %ld\n",
-                       smi->attentions);
-        out += sprintf(out, "flag_fetches:          %ld\n",
-                       smi->flag_fetches);
-        out += sprintf(out, "hosed_count:           %ld\n",
-                       smi->hosed_count);
-        out += sprintf(out, "complete_transactions: %ld\n",
-                       smi->complete_transactions);
-        out += sprintf(out, "events:                %ld\n",
-                       smi->events);
-        out += sprintf(out, "watchdog_pretimeouts:  %ld\n",
-                       smi->watchdog_pretimeouts);
-        out += sprintf(out, "incoming_messages:     %ld\n",
-                       smi->incoming_messages);
+        out += sprintf(out, "short_timeouts:        %u\n",
+                       smi_get_stat(smi, short_timeouts));
+        out += sprintf(out, "long_timeouts:         %u\n",
+                       smi_get_stat(smi, long_timeouts));
+        out += sprintf(out, "idles:                 %u\n",
+                       smi_get_stat(smi, idles));
+        out += sprintf(out, "interrupts:            %u\n",
+                       smi_get_stat(smi, interrupts));
+        out += sprintf(out, "attentions:            %u\n",
+                       smi_get_stat(smi, attentions));
+        out += sprintf(out, "flag_fetches:          %u\n",
+                       smi_get_stat(smi, flag_fetches));
+        out += sprintf(out, "hosed_count:           %u\n",
+                       smi_get_stat(smi, hosed_count));
+        out += sprintf(out, "complete_transactions: %u\n",
+                       smi_get_stat(smi, complete_transactions));
+        out += sprintf(out, "events:                %u\n",
+                       smi_get_stat(smi, events));
+        out += sprintf(out, "watchdog_pretimeouts:  %u\n",
+                       smi_get_stat(smi, watchdog_pretimeouts));
+        out += sprintf(out, "incoming_messages:     %u\n",
+                       smi_get_stat(smi, incoming_messages));
 
         return out - page;
 }
@@ -2460,7 +2523,7 @@ static int param_read_proc(char *page, char **start, off_t off,
 static int oem_data_avail_to_receive_msg_avail(struct smi_info *smi_info)
 {
         smi_info->msg_flags = ((smi_info->msg_flags & ~OEM_DATA_AVAIL) |
-                                RECEIVE_MSG_AVAIL);
+                               RECEIVE_MSG_AVAIL);
         return 1;
 }
 
@@ -2502,10 +2565,9 @@ static void setup_dell_poweredge_oem_data_handler(struct smi_info *smi_info)
                     id->ipmi_version   == DELL_POWEREDGE_8G_BMC_IPMI_VERSION) {
                         smi_info->oem_data_avail_handler =
                                 oem_data_avail_to_receive_msg_avail;
-                }
-                else if (ipmi_version_major(id) < 1 ||
-                         (ipmi_version_major(id) == 1 &&
-                          ipmi_version_minor(id) < 5)) {
+                } else if (ipmi_version_major(id) < 1 ||
+                           (ipmi_version_major(id) == 1 &&
+                            ipmi_version_minor(id) < 5)) {
                         smi_info->oem_data_avail_handler =
                                 oem_data_avail_to_receive_msg_avail;
                 }
@@ -2597,8 +2659,10 @@ static void setup_xaction_handlers(struct smi_info *smi_info)
 static inline void wait_for_timer_and_thread(struct smi_info *smi_info)
 {
         if (smi_info->intf) {
-                /* The timer and thread are only running if the
-                   interface has been started up and registered. */
+                /*
+                 * The timer and thread are only running if the
+                 * interface has been started up and registered.
+                 */
                 if (smi_info->thread != NULL)
                         kthread_stop(smi_info->thread);
                 del_timer_sync(&smi_info->si_timer);
@@ -2676,6 +2740,7 @@ static int is_new_interface(struct smi_info *info)
 static int try_smi_init(struct smi_info *new_smi)
 {
         int rv;
+        int i;
 
         if (new_smi->addr_source) {
                 printk(KERN_INFO "ipmi_si: Trying %s-specified %s state"
@@ -2722,7 +2787,7 @@ static int try_smi_init(struct smi_info *new_smi)
         /* Allocate the state machine's data and initialize it. */
         new_smi->si_sm = kmalloc(new_smi->handlers->size(), GFP_KERNEL);
         if (!new_smi->si_sm) {
-                printk(" Could not allocate state machine memory\n");
+                printk(KERN_ERR "Could not allocate state machine memory\n");
                 rv = -ENOMEM;
                 goto out_err;
         }
@@ -2732,13 +2797,12 @@ static int try_smi_init(struct smi_info *new_smi)
         /* Now that we know the I/O size, we can set up the I/O. */
         rv = new_smi->io_setup(new_smi);
         if (rv) {
-                printk(" Could not set up I/O space\n");
+                printk(KERN_ERR "Could not set up I/O space\n");
                 goto out_err;
         }
 
         spin_lock_init(&(new_smi->si_lock));
         spin_lock_init(&(new_smi->msg_lock));
-        spin_lock_init(&(new_smi->count_lock));
 
         /* Do low-level detection first. */
         if (new_smi->handlers->detect(new_smi->si_sm)) {
@@ -2749,8 +2813,10 @@ static int try_smi_init(struct smi_info *new_smi)
                 goto out_err;
         }
 
-        /* Attempt a get device id command.  If it fails, we probably
-           don't have a BMC here. */
+        /*
+         * Attempt a get device id command.  If it fails, we probably
+         * don't have a BMC here.
+         */
         rv = try_get_dev_id(new_smi);
         if (rv) {
                 if (new_smi->addr_source)
@@ -2767,22 +2833,28 @@ static int try_smi_init(struct smi_info *new_smi)
         new_smi->curr_msg = NULL;
         atomic_set(&new_smi->req_events, 0);
         new_smi->run_to_completion = 0;
+        for (i = 0; i < SI_NUM_STATS; i++)
+                atomic_set(&new_smi->stats[i], 0);
 
         new_smi->interrupt_disabled = 0;
         atomic_set(&new_smi->stop_operation, 0);
         new_smi->intf_num = smi_num;
         smi_num++;
 
-        /* Start clearing the flags before we enable interrupts or the
-           timer to avoid racing with the timer. */
+        /*
+         * Start clearing the flags before we enable interrupts or the
+         * timer to avoid racing with the timer.
+         */
         start_clear_flags(new_smi);
         /* IRQ is defined to be set when non-zero. */
         if (new_smi->irq)
                 new_smi->si_state = SI_CLEARING_FLAGS_THEN_SET_IRQ;
 
         if (!new_smi->dev) {
-                /* If we don't already have a device from something
-                 * else (like PCI), then register a new one. */
+                /*
+                 * If we don't already have a device from something
+                 * else (like PCI), then register a new one.
+                 */
                 new_smi->pdev = platform_device_alloc("ipmi_si",
                                                       new_smi->intf_num);
                 if (rv) {
@@ -2820,7 +2892,7 @@ static int try_smi_init(struct smi_info *new_smi)
         }
 
         rv = ipmi_smi_add_proc_entry(new_smi->intf, "type",
-                                     type_file_read_proc, NULL,
+                                     type_file_read_proc,
                                      new_smi, THIS_MODULE);
         if (rv) {
                 printk(KERN_ERR
@@ -2830,7 +2902,7 @@ static int try_smi_init(struct smi_info *new_smi)
         }
 
         rv = ipmi_smi_add_proc_entry(new_smi->intf, "si_stats",
-                                     stat_file_read_proc, NULL,
+                                     stat_file_read_proc,
                                      new_smi, THIS_MODULE);
         if (rv) {
                 printk(KERN_ERR
@@ -2840,7 +2912,7 @@ static int try_smi_init(struct smi_info *new_smi)
         }
 
         rv = ipmi_smi_add_proc_entry(new_smi->intf, "params",
-                                     param_read_proc, NULL,
+                                     param_read_proc,
                                      new_smi, THIS_MODULE);
         if (rv) {
                 printk(KERN_ERR
@@ -2853,7 +2925,8 @@ static int try_smi_init(struct smi_info *new_smi)
 
         mutex_unlock(&smi_infos_lock);
 
-        printk(KERN_INFO "IPMI %s interface initialized\n",si_to_str[new_smi->si_type]);
+        printk(KERN_INFO "IPMI %s interface initialized\n",
+               si_to_str[new_smi->si_type]);
 
         return 0;
 
@@ -2868,9 +2941,11 @@ static int try_smi_init(struct smi_info *new_smi)
         if (new_smi->irq_cleanup)
                 new_smi->irq_cleanup(new_smi);
 
-        /* Wait until we know that we are out of any interrupt
-           handlers might have been running before we freed the
-           interrupt. */
+        /*
+         * Wait until we know that we are out of any interrupt
+         * handlers might have been running before we freed the
+         * interrupt.
+         */
         synchronize_sched();
 
         if (new_smi->si_sm) {
@@ -2942,11 +3017,10 @@ static __devinit int init_ipmi_si(void)
 
 #ifdef CONFIG_PCI
         rv = pci_register_driver(&ipmi_pci_driver);
-        if (rv){
+        if (rv)
                 printk(KERN_ERR
                        "init_ipmi_si: Unable to register PCI driver: %d\n",
                        rv);
-        }
 #endif
 
 #ifdef CONFIG_PPC_OF
@@ -2975,7 +3049,8 @@ static __devinit int init_ipmi_si(void)
                 of_unregister_platform_driver(&ipmi_of_platform_driver);
 #endif
                 driver_unregister(&ipmi_driver);
-                printk("ipmi_si: Unable to find any System Interface(s)\n");
+                printk(KERN_WARNING
+                       "ipmi_si: Unable to find any System Interface(s)\n");
                 return -ENODEV;
         } else {
                 mutex_unlock(&smi_infos_lock);
@@ -2997,13 +3072,17 @@ static void cleanup_one_si(struct smi_info *to_clean)
         /* Tell the driver that we are shutting down. */
         atomic_inc(&to_clean->stop_operation);
 
-        /* Make sure the timer and thread are stopped and will not run
-           again. */
+        /*
+         * Make sure the timer and thread are stopped and will not run
+         * again.
+         */
         wait_for_timer_and_thread(to_clean);
 
-        /* Timeouts are stopped, now make sure the interrupts are off
-           for the device.  A little tricky with locks to make sure
-           there are no races. */
+        /*
+         * Timeouts are stopped, now make sure the interrupts are off
+         * for the device.  A little tricky with locks to make sure
+         * there are no races.
+         */
         spin_lock_irqsave(&to_clean->si_lock, flags);
         while (to_clean->curr_msg || (to_clean->si_state != SI_NORMAL)) {
                 spin_unlock_irqrestore(&to_clean->si_lock, flags);
@@ -3074,4 +3153,5 @@ module_exit(cleanup_ipmi_si);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
-MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT system interfaces.");
+MODULE_DESCRIPTION("Interface to the IPMI driver for the KCS, SMIC, and BT"
+                   " system interfaces.");
diff --git a/drivers/char/ipmi/ipmi_si_sm.h b/drivers/char/ipmi/ipmi_si_sm.h
index 4b731b24dc16..df89f73475fb 100644
--- a/drivers/char/ipmi/ipmi_si_sm.h
+++ b/drivers/char/ipmi/ipmi_si_sm.h
@@ -34,22 +34,27 @@
  *  675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-/* This is defined by the state machines themselves, it is an opaque
-   data type for them to use. */
+/*
+ * This is defined by the state machines themselves, it is an opaque
+ * data type for them to use.
+ */
 struct si_sm_data;
 
-/* The structure for doing I/O in the state machine.  The state
-   machine doesn't have the actual I/O routines, they are done through
-   this interface. */
-struct si_sm_io
-{
+/*
+ * The structure for doing I/O in the state machine.  The state
+ * machine doesn't have the actual I/O routines, they are done through
+ * this interface.
+ */
+struct si_sm_io {
         unsigned char (*inputb)(struct si_sm_io *io, unsigned int offset);
         void (*outputb)(struct si_sm_io *io,
                         unsigned int  offset,
                         unsigned char b);
 
-        /* Generic info used by the actual handling routines, the
-           state machine shouldn't touch these. */
+        /*
+         * Generic info used by the actual handling routines, the
+         * state machine shouldn't touch these.
+         */
         void __iomem *addr;
         int  regspacing;
         int  regsize;
@@ -59,53 +64,67 @@ struct si_sm_io
 };
 
 /* Results of SMI events. */
-enum si_sm_result
-{
+enum si_sm_result {
         SI_SM_CALL_WITHOUT_DELAY, /* Call the driver again immediately */
         SI_SM_CALL_WITH_DELAY,  /* Delay some before calling again. */
-        SI_SM_CALL_WITH_TICK_DELAY,     /* Delay at least 1 tick before calling again. */
+        SI_SM_CALL_WITH_TICK_DELAY,/* Delay >=1 tick before calling again. */
         SI_SM_TRANSACTION_COMPLETE, /* A transaction is finished. */
         SI_SM_IDLE,             /* The SM is in idle state. */
         SI_SM_HOSED,            /* The hardware violated the state machine. */
-        SI_SM_ATTN              /* The hardware is asserting attn and the
-                                   state machine is idle. */
+
+        /*
+         * The hardware is asserting attn and the state machine is
+         * idle.
+         */
+        SI_SM_ATTN
 };
 
 /* Handlers for the SMI state machine. */
-struct si_sm_handlers
-{
-        /* Put the version number of the state machine here so the
-           upper layer can print it. */
+struct si_sm_handlers {
+        /*
+         * Put the version number of the state machine here so the
+         * upper layer can print it.
+         */
         char *version;
 
-        /* Initialize the data and return the amount of I/O space to
-           reserve for the space. */
+        /*
+         * Initialize the data and return the amount of I/O space to
+         * reserve for the space.
+         */
         unsigned int (*init_data)(struct si_sm_data *smi,
                                   struct si_sm_io   *io);
 
-        /* Start a new transaction in the state machine.  This will
-           return -2 if the state machine is not idle, -1 if the size
-           is invalid (to large or too small), or 0 if the transaction
-           is successfully completed. */
+        /*
+         * Start a new transaction in the state machine.  This will
+         * return -2 if the state machine is not idle, -1 if the size
+         * is invalid (to large or too small), or 0 if the transaction
+         * is successfully completed.
+         */
         int (*start_transaction)(struct si_sm_data *smi,
                                  unsigned char *data, unsigned int size);
 
-        /* Return the results after the transaction.  This will return
-           -1 if the buffer is too small, zero if no transaction is
-           present, or the actual length of the result data. */
+        /*
+         * Return the results after the transaction.  This will return
+         * -1 if the buffer is too small, zero if no transaction is
+         * present, or the actual length of the result data.
+         */
         int (*get_result)(struct si_sm_data *smi,
                           unsigned char *data, unsigned int length);
 
-        /* Call this periodically (for a polled interface) or upon
-           receiving an interrupt (for a interrupt-driven interface).
-           If interrupt driven, you should probably poll this
-           periodically when not in idle state.  This should be called
-           with the time that passed since the last call, if it is
-           significant.  Time is in microseconds. */
+        /*
+         * Call this periodically (for a polled interface) or upon
+         * receiving an interrupt (for a interrupt-driven interface).
+         * If interrupt driven, you should probably poll this
+         * periodically when not in idle state.  This should be called
+         * with the time that passed since the last call, if it is
+         * significant.  Time is in microseconds.
+         */
         enum si_sm_result (*event)(struct si_sm_data *smi, long time);
 
-        /* Attempt to detect an SMI.  Returns 0 on success or nonzero
-           on failure. */
+        /*
+         * Attempt to detect an SMI.  Returns 0 on success or nonzero
+         * on failure.
+         */
         int (*detect)(struct si_sm_data *smi);
 
         /* The interface is shutting down, so clean it up. */
diff --git a/drivers/char/ipmi/ipmi_smic_sm.c b/drivers/char/ipmi/ipmi_smic_sm.c
index e64ea7d25d24..faed92971907 100644
--- a/drivers/char/ipmi/ipmi_smic_sm.c
+++ b/drivers/char/ipmi/ipmi_smic_sm.c
@@ -85,6 +85,7 @@ enum smic_states {
 /* SMIC Flags Register Bits */
 #define SMIC_RX_DATA_READY      0x80
 #define SMIC_TX_DATA_READY      0x40
+
 /*
  * SMIC_SMI and SMIC_EVM_DATA_AVAIL are only used by
  * a few systems, and then only by Systems Management
@@ -104,23 +105,22 @@ enum smic_states {
 #define EC_ILLEGAL_COMMAND      0x04
 #define EC_BUFFER_FULL          0x05
 
-struct si_sm_data
-{
+struct si_sm_data {
         enum smic_states state;
         struct si_sm_io *io;
-        unsigned char    write_data[MAX_SMIC_WRITE_SIZE];
-        int              write_pos;
-        int              write_count;
-        int              orig_write_count;
-        unsigned char    read_data[MAX_SMIC_READ_SIZE];
-        int              read_pos;
-        int              truncated;
-        unsigned int     error_retries;
-        long             smic_timeout;
+        unsigned char    write_data[MAX_SMIC_WRITE_SIZE];
+        int              write_pos;
+        int              write_count;
+        int              orig_write_count;
+        unsigned char    read_data[MAX_SMIC_READ_SIZE];
+        int              read_pos;
+        int              truncated;
+        unsigned int     error_retries;
+        long             smic_timeout;
 };
 
-static unsigned int init_smic_data (struct si_sm_data *smic,
-                                    struct si_sm_io *io)
+static unsigned int init_smic_data(struct si_sm_data *smic,
+                                   struct si_sm_io *io)
 {
         smic->state = SMIC_IDLE;
         smic->io = io;
@@ -150,11 +150,10 @@ static int start_smic_transaction(struct si_sm_data *smic,
                 return IPMI_NOT_IN_MY_STATE_ERR;
 
         if (smic_debug & SMIC_DEBUG_MSG) {
-                printk(KERN_INFO "start_smic_transaction -");
-                for (i = 0; i < size; i ++) {
-                        printk (" %02x", (unsigned char) (data [i]));
-                }
-                printk ("\n");
+                printk(KERN_DEBUG "start_smic_transaction -");
+                for (i = 0; i < size; i++)
+                        printk(" %02x", (unsigned char) data[i]);
+                printk("\n");
         }
         smic->error_retries = 0;
         memcpy(smic->write_data, data, size);
@@ -173,11 +172,10 @@ static int smic_get_result(struct si_sm_data *smic,
         int i;
 
         if (smic_debug & SMIC_DEBUG_MSG) {
-                printk (KERN_INFO "smic_get result -");
-                for (i = 0; i < smic->read_pos; i ++) {
-                        printk (" %02x", (smic->read_data [i]));
-                }
-                printk ("\n");
+                printk(KERN_DEBUG "smic_get result -");
+                for (i = 0; i < smic->read_pos; i++)
+                        printk(" %02x", smic->read_data[i]);
+                printk("\n");
         }
         if (length < smic->read_pos) {
                 smic->read_pos = length;
@@ -223,8 +221,8 @@ static inline void write_smic_control(struct si_sm_data *smic,
         smic->io->outputb(smic->io, 1, control);
 }
 
-static inline void write_si_sm_data (struct si_sm_data *smic,
-                                   unsigned char   data)
+static inline void write_si_sm_data(struct si_sm_data *smic,
+                                    unsigned char   data)
 {
         smic->io->outputb(smic->io, 0, data);
 }
@@ -233,10 +231,9 @@ static inline void start_error_recovery(struct si_sm_data *smic, char *reason)
 {
         (smic->error_retries)++;
         if (smic->error_retries > SMIC_MAX_ERROR_RETRIES) {
-                if (smic_debug & SMIC_DEBUG_ENABLE) {
+                if (smic_debug & SMIC_DEBUG_ENABLE)
                         printk(KERN_WARNING
                                "ipmi_smic_drv: smic hosed: %s\n", reason);
-                }
                 smic->state = SMIC_HOSED;
         } else {
                 smic->write_count = smic->orig_write_count;
@@ -254,14 +251,14 @@ static inline void write_next_byte(struct si_sm_data *smic)
         (smic->write_count)--;
 }
 
-static inline void read_next_byte (struct si_sm_data *smic)
+static inline void read_next_byte(struct si_sm_data *smic)
 {
         if (smic->read_pos >= MAX_SMIC_READ_SIZE) {
-                read_smic_data (smic);
+                read_smic_data(smic);
                 smic->truncated = 1;
         } else {
                 smic->read_data[smic->read_pos] = read_smic_data(smic);
-                (smic->read_pos)++;
+                smic->read_pos++;
         }
 }
 
@@ -336,7 +333,7 @@ static inline void read_next_byte (struct si_sm_data *smic)
         SMIC_SC_SMS_RD_END      0xC6
 */
 
-static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
+static enum si_sm_result smic_event(struct si_sm_data *smic, long time)
 {
         unsigned char status;
         unsigned char flags;
@@ -347,13 +344,15 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
                 return SI_SM_HOSED;
         }
         if (smic->state != SMIC_IDLE) {
-                if (smic_debug & SMIC_DEBUG_STATES) {
-                        printk(KERN_INFO
+                if (smic_debug & SMIC_DEBUG_STATES)
+                        printk(KERN_DEBUG
                                "smic_event - smic->smic_timeout = %ld,"
                                " time = %ld\n",
                                smic->smic_timeout, time);
-                }
-/* FIXME: smic_event is sometimes called with time > SMIC_RETRY_TIMEOUT */
+                /*
+                 * FIXME: smic_event is sometimes called with time >
+                 * SMIC_RETRY_TIMEOUT
+                 */
                 if (time < SMIC_RETRY_TIMEOUT) {
                         smic->smic_timeout -= time;
                         if (smic->smic_timeout < 0) {
@@ -366,9 +365,9 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
         if (flags & SMIC_FLAG_BSY)
                 return SI_SM_CALL_WITH_DELAY;
 
-        status = read_smic_status (smic);
+        status = read_smic_status(smic);
         if (smic_debug & SMIC_DEBUG_STATES)
-                printk(KERN_INFO
+                printk(KERN_DEBUG
                        "smic_event - state = %d, flags = 0x%02x,"
                        " status = 0x%02x\n",
                        smic->state, flags, status);
@@ -377,9 +376,7 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
         case SMIC_IDLE:
                 /* in IDLE we check for available messages */
                 if (flags & SMIC_SMS_DATA_AVAIL)
-                {
                         return SI_SM_ATTN;
-                }
                 return SI_SM_IDLE;
 
         case SMIC_START_OP:
@@ -391,7 +388,7 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
 
         case SMIC_OP_OK:
                 if (status != SMIC_SC_SMS_READY) {
-                                /* this should not happen */
+                        /* this should not happen */
                         start_error_recovery(smic,
                                              "state = SMIC_OP_OK,"
                                              " status != SMIC_SC_SMS_READY");
@@ -411,8 +408,10 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
                                              "status != SMIC_SC_SMS_WR_START");
                         return SI_SM_CALL_WITH_DELAY;
                 }
-                /* we must not issue WR_(NEXT|END) unless
-                   TX_DATA_READY is set */
+                /*
+                 * we must not issue WR_(NEXT|END) unless
+                 * TX_DATA_READY is set
+                 * */
                 if (flags & SMIC_TX_DATA_READY) {
                         if (smic->write_count == 1) {
                                 /* last byte */
@@ -424,10 +423,8 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
                         }
                         write_next_byte(smic);
                         write_smic_flags(smic, flags | SMIC_FLAG_BSY);
-                }
-                else {
+                } else
                         return SI_SM_CALL_WITH_DELAY;
-                }
                 break;
 
         case SMIC_WRITE_NEXT:
@@ -442,52 +439,48 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
                         if (smic->write_count == 1) {
                                 write_smic_control(smic, SMIC_CC_SMS_WR_END);
                                 smic->state = SMIC_WRITE_END;
-                        }
-                        else {
+                        } else {
                                 write_smic_control(smic, SMIC_CC_SMS_WR_NEXT);
                                 smic->state = SMIC_WRITE_NEXT;
                         }
                         write_next_byte(smic);
                         write_smic_flags(smic, flags | SMIC_FLAG_BSY);
-                }
-                else {
+                } else
                         return SI_SM_CALL_WITH_DELAY;
-                }
                 break;
 
         case SMIC_WRITE_END:
                 if (status != SMIC_SC_SMS_WR_END) {
-                        start_error_recovery (smic,
-                                              "state = SMIC_WRITE_END, "
-                                              "status != SMIC_SC_SMS_WR_END");
+                        start_error_recovery(smic,
+                                             "state = SMIC_WRITE_END, "
+                                             "status != SMIC_SC_SMS_WR_END");
                         return SI_SM_CALL_WITH_DELAY;
                 }
                 /* data register holds an error code */
                 data = read_smic_data(smic);
                 if (data != 0) {
-                        if (smic_debug & SMIC_DEBUG_ENABLE) {
-                                printk(KERN_INFO
+                        if (smic_debug & SMIC_DEBUG_ENABLE)
+                                printk(KERN_DEBUG
                                        "SMIC_WRITE_END: data = %02x\n", data);
-                        }
                         start_error_recovery(smic,
                                              "state = SMIC_WRITE_END, "
                                              "data != SUCCESS");
                         return SI_SM_CALL_WITH_DELAY;
-                } else {
+                } else
                         smic->state = SMIC_WRITE2READ;
-                }
                 break;
 
         case SMIC_WRITE2READ:
-                /* we must wait for RX_DATA_READY to be set before we
-                   can continue */
+                /*
+                 * we must wait for RX_DATA_READY to be set before we
+                 * can continue
+                 */
                 if (flags & SMIC_RX_DATA_READY) {
                         write_smic_control(smic, SMIC_CC_SMS_RD_START);
                         write_smic_flags(smic, flags | SMIC_FLAG_BSY);
                         smic->state = SMIC_READ_START;
-                } else {
+                } else
                         return SI_SM_CALL_WITH_DELAY;
-                }
                 break;
 
         case SMIC_READ_START:
@@ -502,15 +495,16 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
                         write_smic_control(smic, SMIC_CC_SMS_RD_NEXT);
                         write_smic_flags(smic, flags | SMIC_FLAG_BSY);
                         smic->state = SMIC_READ_NEXT;
-                } else {
+                } else
                         return SI_SM_CALL_WITH_DELAY;
-                }
                 break;
 
         case SMIC_READ_NEXT:
                 switch (status) {
-                /* smic tells us that this is the last byte to be read
-                   --> clean up */
+                /*
+                 * smic tells us that this is the last byte to be read
+                 * --> clean up
+                 */
                 case SMIC_SC_SMS_RD_END:
                         read_next_byte(smic);
                         write_smic_control(smic, SMIC_CC_SMS_RD_END);
@@ -523,9 +517,8 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
                                 write_smic_control(smic, SMIC_CC_SMS_RD_NEXT);
                                 write_smic_flags(smic, flags | SMIC_FLAG_BSY);
                                 smic->state = SMIC_READ_NEXT;
-                        } else {
+                        } else
                                 return SI_SM_CALL_WITH_DELAY;
-                        }
                         break;
                 default:
                         start_error_recovery(
@@ -546,10 +539,9 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
                 data = read_smic_data(smic);
                 /* data register holds an error code */
                 if (data != 0) {
-                        if (smic_debug & SMIC_DEBUG_ENABLE) {
-                                printk(KERN_INFO
+                        if (smic_debug & SMIC_DEBUG_ENABLE)
+                                printk(KERN_DEBUG
                                        "SMIC_READ_END: data = %02x\n", data);
-                        }
                         start_error_recovery(smic,
                                              "state = SMIC_READ_END, "
                                              "data != SUCCESS");
@@ -565,7 +557,7 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
 
         default:
                 if (smic_debug & SMIC_DEBUG_ENABLE) {
-                        printk(KERN_WARNING "smic->state = %d\n", smic->state);
+                        printk(KERN_DEBUG "smic->state = %d\n", smic->state);
                         start_error_recovery(smic, "state = UNKNOWN");
                         return SI_SM_CALL_WITH_DELAY;
                 }
@@ -576,10 +568,12 @@ static enum si_sm_result smic_event (struct si_sm_data *smic, long time)
 
 static int smic_detect(struct si_sm_data *smic)
 {
-        /* It's impossible for the SMIC fnags register to be all 1's,
-           (assuming a properly functioning, self-initialized BMC)
-           but that's what you get from reading a bogus address, so we
-           test that first. */
+        /*
+         * It's impossible for the SMIC fnags register to be all 1's,
+         * (assuming a properly functioning, self-initialized BMC)
+         * but that's what you get from reading a bogus address, so we
+         * test that first.
+         */
         if (read_smic_flags(smic) == 0xff)
                 return 1;
 
@@ -595,8 +589,7 @@ static int smic_size(void)
         return sizeof(struct si_sm_data);
 }
 
-struct si_sm_handlers smic_smi_handlers =
-{
+struct si_sm_handlers smic_smi_handlers = {
         .init_data         = init_smic_data,
         .start_transaction = start_smic_transaction,
         .get_result        = smic_get_result,
diff --git a/drivers/char/ipmi/ipmi_watchdog.c b/drivers/char/ipmi/ipmi_watchdog.c
index 8f45ca9235ad..1b9a87047817 100644
--- a/drivers/char/ipmi/ipmi_watchdog.c
+++ b/drivers/char/ipmi/ipmi_watchdog.c
@@ -54,13 +54,15 @@
 #include <asm/atomic.h>
 
 #ifdef CONFIG_X86
-/* This is ugly, but I've determined that x86 is the only architecture
-   that can reasonably support the IPMI NMI watchdog timeout at this
-   time.  If another architecture adds this capability somehow, it
-   will have to be a somewhat different mechanism and I have no idea
-   how it will work.  So in the unlikely event that another
-   architecture supports this, we can figure out a good generic
-   mechanism for it at that time. */
+/*
+ * This is ugly, but I've determined that x86 is the only architecture
+ * that can reasonably support the IPMI NMI watchdog timeout at this
+ * time.  If another architecture adds this capability somehow, it
+ * will have to be a somewhat different mechanism and I have no idea
+ * how it will work.  So in the unlikely event that another
+ * architecture supports this, we can figure out a good generic
+ * mechanism for it at that time.
+ */
 #include <asm/kdebug.h>
 #define HAVE_DIE_NMI
 #endif
@@ -95,9 +97,8 @@
 /* Operations that can be performed on a pretimout. */
 #define WDOG_PREOP_NONE         0
 #define WDOG_PREOP_PANIC        1
-#define WDOG_PREOP_GIVE_DATA    2 /* Cause data to be available to
-                                     read.  Doesn't work in NMI
-                                     mode. */
+/* Cause data to be available to read.  Doesn't work in NMI mode. */
+#define WDOG_PREOP_GIVE_DATA    2
 
 /* Actions to perform on a full timeout. */
 #define WDOG_SET_TIMEOUT_ACT(byte, use) \
@@ -108,8 +109,10 @@
 #define WDOG_TIMEOUT_POWER_DOWN         2
 #define WDOG_TIMEOUT_POWER_CYCLE        3
 
-/* Byte 3 of the get command, byte 4 of the get response is the
-   pre-timeout in seconds. */
+/*
+ * Byte 3 of the get command, byte 4 of the get response is the
+ * pre-timeout in seconds.
+ */
 
 /* Bits for setting byte 4 of the set command, byte 5 of the get response. */
 #define WDOG_EXPIRE_CLEAR_BIOS_FRB2     (1 << 1)
@@ -118,11 +121,13 @@
 #define WDOG_EXPIRE_CLEAR_SMS_OS        (1 << 4)
 #define WDOG_EXPIRE_CLEAR_OEM           (1 << 5)
 
-/* Setting/getting the watchdog timer value.  This is for bytes 5 and
-   6 (the timeout time) of the set command, and bytes 6 and 7 (the
-   timeout time) and 8 and 9 (the current countdown value) of the
-   response.  The timeout value is given in seconds (in the command it
-   is 100ms intervals). */
+/*
+ * Setting/getting the watchdog timer value.  This is for bytes 5 and
+ * 6 (the timeout time) of the set command, and bytes 6 and 7 (the
+ * timeout time) and 8 and 9 (the current countdown value) of the
+ * response.  The timeout value is given in seconds (in the command it
+ * is 100ms intervals).
+ */
 #define WDOG_SET_TIMEOUT(byte1, byte2, val) \
         (byte1) = (((val) * 10) & 0xff), (byte2) = (((val) * 10) >> 8)
 #define WDOG_GET_TIMEOUT(byte1, byte2) \
@@ -184,8 +189,10 @@ static int ipmi_set_timeout(int do_heartbeat);
 static void ipmi_register_watchdog(int ipmi_intf);
 static void ipmi_unregister_watchdog(int ipmi_intf);
 
-/* If true, the driver will start running as soon as it is configured
-   and ready. */
+/*
+ * If true, the driver will start running as soon as it is configured
+ * and ready.
+ */
 static int start_now;
 
 static int set_param_int(const char *val, struct kernel_param *kp)
@@ -309,10 +316,12 @@ static int ipmi_ignore_heartbeat;
 /* Is someone using the watchdog?  Only one user is allowed. */
 static unsigned long ipmi_wdog_open;
 
-/* If set to 1, the heartbeat command will set the state to reset and
-   start the timer.  The timer doesn't normally run when the driver is
-   first opened until the heartbeat is set the first time, this
-   variable is used to accomplish this. */
+/*
+ * If set to 1, the heartbeat command will set the state to reset and
+ * start the timer.  The timer doesn't normally run when the driver is
+ * first opened until the heartbeat is set the first time, this
+ * variable is used to accomplish this.
+ */
 static int ipmi_start_timer_on_heartbeat;
 
 /* IPMI version of the BMC. */
@@ -329,10 +338,12 @@ static int nmi_handler_registered;
 
 static int ipmi_heartbeat(void);
 
-/* We use a mutex to make sure that only one thing can send a set
-   timeout at one time, because we only have one copy of the data.
-   The mutex is claimed when the set_timeout is sent and freed
-   when both messages are free. */
+/*
+ * We use a mutex to make sure that only one thing can send a set
+ * timeout at one time, because we only have one copy of the data.
+ * The mutex is claimed when the set_timeout is sent and freed
+ * when both messages are free.
+ */
 static atomic_t set_timeout_tofree = ATOMIC_INIT(0);
 static DEFINE_MUTEX(set_timeout_lock);
 static DECLARE_COMPLETION(set_timeout_wait);
@@ -346,15 +357,13 @@ static void set_timeout_free_recv(struct ipmi_recv_msg *msg)
     if (atomic_dec_and_test(&set_timeout_tofree))
             complete(&set_timeout_wait);
 }
-static struct ipmi_smi_msg set_timeout_smi_msg =
-{
+static struct ipmi_smi_msg set_timeout_smi_msg = {
         .done = set_timeout_free_smi
 };
-static struct ipmi_recv_msg set_timeout_recv_msg =
-{
+static struct ipmi_recv_msg set_timeout_recv_msg = {
         .done = set_timeout_free_recv
 };
- 
+
 static int i_ipmi_set_timeout(struct ipmi_smi_msg  *smi_msg,
                               struct ipmi_recv_msg *recv_msg,
                               int                  *send_heartbeat_now)
@@ -373,13 +382,14 @@ static int i_ipmi_set_timeout(struct ipmi_smi_msg  *smi_msg,
         WDOG_SET_TIMER_USE(data[0], WDOG_TIMER_USE_SMS_OS);
 
         if ((ipmi_version_major > 1)
-            || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5)))
-        {
+            || ((ipmi_version_major == 1) && (ipmi_version_minor >= 5))) {
                 /* This is an IPMI 1.5-only feature. */
                 data[0] |= WDOG_DONT_STOP_ON_SET;
         } else if (ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
-                /* In ipmi 1.0, setting the timer stops the watchdog, we
-                   need to start it back up again. */
+                /*
+                 * In ipmi 1.0, setting the timer stops the watchdog, we
+                 * need to start it back up again.
+                 */
                 hbnow = 1;
         }
 
@@ -465,12 +475,10 @@ static void panic_recv_free(struct ipmi_recv_msg *msg)
         atomic_dec(&panic_done_count);
 }
 
-static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg =
-{
+static struct ipmi_smi_msg panic_halt_heartbeat_smi_msg = {
         .done = panic_smi_free
 };
-static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg =
-{
+static struct ipmi_recv_msg panic_halt_heartbeat_recv_msg = {
         .done = panic_recv_free
 };
 
@@ -480,8 +488,10 @@ static void panic_halt_ipmi_heartbeat(void)
         struct ipmi_system_interface_addr addr;
         int rv;
 
-        /* Don't reset the timer if we have the timer turned off, that
-           re-enables the watchdog. */
+        /*
+         * Don't reset the timer if we have the timer turned off, that
+         * re-enables the watchdog.
+         */
         if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
                 return;
 
@@ -505,19 +515,19 @@ static void panic_halt_ipmi_heartbeat(void)
                 atomic_add(2, &panic_done_count);
 }
 
-static struct ipmi_smi_msg panic_halt_smi_msg =
-{
+static struct ipmi_smi_msg panic_halt_smi_msg = {
         .done = panic_smi_free
 };
-static struct ipmi_recv_msg panic_halt_recv_msg =
-{
+static struct ipmi_recv_msg panic_halt_recv_msg = {
         .done = panic_recv_free
 };
 
-/* Special call, doesn't claim any locks.  This is only to be called
-   at panic or halt time, in run-to-completion mode, when the caller
-   is the only CPU and the only thing that will be going is these IPMI
-   calls. */
+/*
+ * Special call, doesn't claim any locks.  This is only to be called
+ * at panic or halt time, in run-to-completion mode, when the caller
+ * is the only CPU and the only thing that will be going is these IPMI
+ * calls.
+ */
 static void panic_halt_ipmi_set_timeout(void)
 {
         int send_heartbeat_now;
@@ -540,10 +550,12 @@ static void panic_halt_ipmi_set_timeout(void)
                 ipmi_poll_interface(watchdog_user);
 }
 
-/* We use a semaphore to make sure that only one thing can send a
-   heartbeat at one time, because we only have one copy of the data.
-   The semaphore is claimed when the set_timeout is sent and freed
-   when both messages are free. */
+/*
+ * We use a mutex to make sure that only one thing can send a
+ * heartbeat at one time, because we only have one copy of the data.
+ * The semaphore is claimed when the set_timeout is sent and freed
+ * when both messages are free.
+ */
 static atomic_t heartbeat_tofree = ATOMIC_INIT(0);
 static DEFINE_MUTEX(heartbeat_lock);
 static DECLARE_COMPLETION(heartbeat_wait);
@@ -557,15 +569,13 @@ static void heartbeat_free_recv(struct ipmi_recv_msg *msg)
     if (atomic_dec_and_test(&heartbeat_tofree))
             complete(&heartbeat_wait);
 }
-static struct ipmi_smi_msg heartbeat_smi_msg =
-{
+static struct ipmi_smi_msg heartbeat_smi_msg = {
         .done = heartbeat_free_smi
 };
-static struct ipmi_recv_msg heartbeat_recv_msg =
-{
+static struct ipmi_recv_msg heartbeat_recv_msg = {
         .done = heartbeat_free_recv
 };
- 
+
 static int ipmi_heartbeat(void)
 {
         struct kernel_ipmi_msg            msg;
@@ -580,10 +590,12 @@ static int ipmi_heartbeat(void)
                 ipmi_watchdog_state = action_val;
                 return ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
         } else if (pretimeout_since_last_heartbeat) {
-                /* A pretimeout occurred, make sure we set the timeout.
-                   We don't want to set the action, though, we want to
-                   leave that alone (thus it can't be combined with the
-                   above operation. */
+                /*
+                 * A pretimeout occurred, make sure we set the timeout.
+                 * We don't want to set the action, though, we want to
+                 * leave that alone (thus it can't be combined with the
+                 * above operation.
+                 */
                 return ipmi_set_timeout(IPMI_SET_TIMEOUT_HB_IF_NECESSARY);
         }
 
@@ -591,8 +603,10 @@ static int ipmi_heartbeat(void)
 
         atomic_set(&heartbeat_tofree, 2);
 
-        /* Don't reset the timer if we have the timer turned off, that
-           re-enables the watchdog. */
+        /*
+         * Don't reset the timer if we have the timer turned off, that
+         * re-enables the watchdog.
+         */
         if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE) {
                 mutex_unlock(&heartbeat_lock);
                 return 0;
@@ -625,10 +639,12 @@ static int ipmi_heartbeat(void)
         wait_for_completion(&heartbeat_wait);
 
         if (heartbeat_recv_msg.msg.data[0] != 0) {
-            /* Got an error in the heartbeat response.  It was already
-               reported in ipmi_wdog_msg_handler, but we should return
-               an error here. */
-            rv = -EINVAL;
+                /*
+                 * Got an error in the heartbeat response.  It was already
+                 * reported in ipmi_wdog_msg_handler, but we should return
+                 * an error here.
+                 */
+                rv = -EINVAL;
         }
 
         mutex_unlock(&heartbeat_lock);
@@ -636,8 +652,7 @@ static int ipmi_heartbeat(void)
         return rv;
 }
 
-static struct watchdog_info ident =
-{
+static struct watchdog_info ident = {
         .options        = 0,    /* WDIOF_SETTIMEOUT, */
         .firmware_version = 1,
         .identity       = "IPMI"
@@ -650,7 +665,7 @@ static int ipmi_ioctl(struct inode *inode, struct file *file,
         int i;
         int val;
 
-        switch(cmd) {
+        switch (cmd) {
         case WDIOC_GETSUPPORT:
                 i = copy_to_user(argp, &ident, sizeof(ident));
                 return i ? -EFAULT : 0;
@@ -690,15 +705,13 @@ static int ipmi_ioctl(struct inode *inode, struct file *file,
                 i = copy_from_user(&val, argp, sizeof(int));
                 if (i)
                         return -EFAULT;
-                if (val & WDIOS_DISABLECARD)
-                {
+                if (val & WDIOS_DISABLECARD) {
                         ipmi_watchdog_state = WDOG_TIMEOUT_NONE;
                         ipmi_set_timeout(IPMI_SET_TIMEOUT_NO_HB);
                         ipmi_start_timer_on_heartbeat = 0;
                 }
 
-                if (val & WDIOS_ENABLECARD)
-                {
+                if (val & WDIOS_ENABLECARD) {
                         ipmi_watchdog_state = action_val;
                         ipmi_set_timeout(IPMI_SET_TIMEOUT_FORCE_HB);
                 }
@@ -724,13 +737,13 @@ static ssize_t ipmi_write(struct file *file,
         int rv;
 
         if (len) {
-                if (!nowayout) {
-                        size_t i;
+                if (!nowayout) {
+                        size_t i;
 
                         /* In case it was set long ago */
                         expect_close = 0;
 
-                        for (i = 0; i != len; i++) {
+                        for (i = 0; i != len; i++) {
                                 char c;
 
                                 if (get_user(c, buf + i))
@@ -758,15 +771,17 @@ static ssize_t ipmi_read(struct file *file,
         if (count <= 0)
                 return 0;
 
-        /* Reading returns if the pretimeout has gone off, and it only does
-           it once per pretimeout. */
+        /*
+         * Reading returns if the pretimeout has gone off, and it only does
+         * it once per pretimeout.
+         */
         spin_lock(&ipmi_read_lock);
         if (!data_to_read) {
                 if (file->f_flags & O_NONBLOCK) {
                         rv = -EAGAIN;
                         goto out;
                 }
-                
+
                 init_waitqueue_entry(&wait, current);
                 add_wait_queue(&read_q, &wait);
                 while (!data_to_read) {
@@ -776,7 +791,7 @@ static ssize_t ipmi_read(struct file *file,
                         spin_lock(&ipmi_read_lock);
                 }
                 remove_wait_queue(&read_q, &wait);
-            
+
                 if (signal_pending(current)) {
                         rv = -ERESTARTSYS;
                         goto out;
@@ -799,25 +814,27 @@ static ssize_t ipmi_read(struct file *file,
 
 static int ipmi_open(struct inode *ino, struct file *filep)
 {
-        switch (iminor(ino)) {
-        case WATCHDOG_MINOR:
+        switch (iminor(ino)) {
+        case WATCHDOG_MINOR:
                 if (test_and_set_bit(0, &ipmi_wdog_open))
-                        return -EBUSY;
+                        return -EBUSY;
 
-                /* Don't start the timer now, let it start on the
-                   first heartbeat. */
+                /*
+                 * Don't start the timer now, let it start on the
+                 * first heartbeat.
+                 */
                 ipmi_start_timer_on_heartbeat = 1;
                 return nonseekable_open(ino, filep);
 
         default:
                 return (-ENODEV);
-        }
+        }
 }
 
 static unsigned int ipmi_poll(struct file *file, poll_table *wait)
 {
         unsigned int mask = 0;
-        
+
         poll_wait(file, &read_q, wait);
 
         spin_lock(&ipmi_read_lock);
@@ -851,7 +868,7 @@ static int ipmi_close(struct inode *ino, struct file *filep)
                 clear_bit(0, &ipmi_wdog_open);
         }
 
-        ipmi_fasync (-1, filep, 0);
+        ipmi_fasync(-1, filep, 0);
         expect_close = 0;
 
         return 0;
@@ -882,7 +899,7 @@ static void ipmi_wdog_msg_handler(struct ipmi_recv_msg *msg,
                        msg->msg.data[0],
                        msg->msg.cmd);
         }
-        
+
         ipmi_free_recv_msg(msg);
 }
 
@@ -902,14 +919,14 @@ static void ipmi_wdog_pretimeout_handler(void *handler_data)
                 }
         }
 
-        /* On some machines, the heartbeat will give
-           an error and not work unless we re-enable
-           the timer.   So do so. */
+        /*
+         * On some machines, the heartbeat will give an error and not
+         * work unless we re-enable the timer.  So do so.
+         */
         pretimeout_since_last_heartbeat = 1;
 }
 
-static struct ipmi_user_hndl ipmi_hndlrs =
-{
+static struct ipmi_user_hndl ipmi_hndlrs = {
         .ipmi_recv_hndl           = ipmi_wdog_msg_handler,
         .ipmi_watchdog_pretimeout = ipmi_wdog_pretimeout_handler
 };
@@ -949,8 +966,10 @@ static void ipmi_register_watchdog(int ipmi_intf)
                 int old_timeout = timeout;
                 int old_preop_val = preop_val;
 
-                /* Set the pretimeout to go off in a second and give
-                   ourselves plenty of time to stop the timer. */
+                /*
+                 * Set the pretimeout to go off in a second and give
+                 * ourselves plenty of time to stop the timer.
+                 */
                 ipmi_watchdog_state = WDOG_TIMEOUT_RESET;
                 preop_val = WDOG_PREOP_NONE; /* Make sure nothing happens */
                 pretimeout = 99;
@@ -974,7 +993,7 @@ static void ipmi_register_watchdog(int ipmi_intf)
                                " occur.  The NMI pretimeout will"
                                " likely not work\n");
                 }
-        out_restore:
+ out_restore:
                 testing_nmi = 0;
                 preop_val = old_preop_val;
                 pretimeout = old_pretimeout;
@@ -1009,9 +1028,11 @@ static void ipmi_unregister_watchdog(int ipmi_intf)
         /* Make sure no one can call us any more. */
         misc_deregister(&ipmi_wdog_miscdev);
 
-        /* Wait to make sure the message makes it out.  The lower layer has
-           pointers to our buffers, we want to make sure they are done before
-           we release our memory. */
+        /*
+         * Wait to make sure the message makes it out.  The lower layer has
+         * pointers to our buffers, we want to make sure they are done before
+         * we release our memory.
+         */
         while (atomic_read(&set_timeout_tofree))
                 schedule_timeout_uninterruptible(1);
 
@@ -1052,15 +1073,17 @@ ipmi_nmi(struct notifier_block *self, unsigned long val, void *data)
                 return NOTIFY_STOP;
         }
 
-        /* If we are not expecting a timeout, ignore it. */
+        /* If we are not expecting a timeout, ignore it. */
         if (ipmi_watchdog_state == WDOG_TIMEOUT_NONE)
                 return NOTIFY_OK;
 
         if (preaction_val != WDOG_PRETIMEOUT_NMI)
                 return NOTIFY_OK;
 
-        /* If no one else handled the NMI, we assume it was the IPMI
-           watchdog. */
+        /*
+         * If no one else handled the NMI, we assume it was the IPMI
+         * watchdog.
+         */
         if (preop_val == WDOG_PREOP_PANIC) {
                 /* On some machines, the heartbeat will give
                    an error and not work unless we re-enable
@@ -1082,7 +1105,7 @@ static int wdog_reboot_handler(struct notifier_block *this,
                                unsigned long         code,
                                void                  *unused)
 {
-        static int reboot_event_handled = 0;
+        static int reboot_event_handled;
 
         if ((watchdog_user) && (!reboot_event_handled)) {
                 /* Make sure we only do this once. */
@@ -1115,7 +1138,7 @@ static int wdog_panic_handler(struct notifier_block *this,
                               unsigned long         event,
                               void                  *unused)
 {
-        static int panic_event_handled = 0;
+        static int panic_event_handled;
 
         /* On a panic, if we have a panic timeout, make sure to extend
            the watchdog timer to a reasonable value to complete the
@@ -1125,7 +1148,7 @@ static int wdog_panic_handler(struct notifier_block *this,
             ipmi_watchdog_state != WDOG_TIMEOUT_NONE) {
                 /* Make sure we do this only once. */
                 panic_event_handled = 1;
-            
+
                 timeout = 255;
                 pretimeout = 0;
                 panic_halt_ipmi_set_timeout();
@@ -1151,8 +1174,7 @@ static void ipmi_smi_gone(int if_num)
         ipmi_unregister_watchdog(if_num);
 }
 
-static struct ipmi_smi_watcher smi_watcher =
-{
+static struct ipmi_smi_watcher smi_watcher = {
         .owner    = THIS_MODULE,
         .new_smi  = ipmi_new_smi,
         .smi_gone = ipmi_smi_gone
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index e83623ead441..934ffafedaea 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -364,6 +364,7 @@ static int mmap_mem(struct file * file, struct vm_area_struct * vma)
         return 0;
 }
 
+#ifdef CONFIG_DEVKMEM
 static int mmap_kmem(struct file * file, struct vm_area_struct * vma)
 {
         unsigned long pfn;
@@ -384,6 +385,7 @@ static int mmap_kmem(struct file * file, struct vm_area_struct * vma)
         vma->vm_pgoff = pfn;
         return mmap_mem(file, vma);
 }
+#endif
 
 #ifdef CONFIG_CRASH_DUMP
 /*
@@ -422,6 +424,7 @@ static ssize_t read_oldmem(struct file *file, char __user *buf,
 extern long vread(char *buf, char *addr, unsigned long count);
 extern long vwrite(char *buf, char *addr, unsigned long count);
 
+#ifdef CONFIG_DEVKMEM
 /*
  * This function reads the *virtual* memory as seen by the kernel.
  */
@@ -626,6 +629,7 @@ static ssize_t write_kmem(struct file * file, const char __user * buf,
         *ppos = p;
         return virtr + wrote;
 }
+#endif
 
 #ifdef CONFIG_DEVPORT
 static ssize_t read_port(struct file * file, char __user * buf,
@@ -803,6 +807,7 @@ static const struct file_operations mem_fops = {
         .get_unmapped_area = get_unmapped_area_mem,
 };
 
+#ifdef CONFIG_DEVKMEM
 static const struct file_operations kmem_fops = {
         .llseek         = memory_lseek,
         .read           = read_kmem,
@@ -811,6 +816,7 @@ static const struct file_operations kmem_fops = {
         .open           = open_kmem,
         .get_unmapped_area = get_unmapped_area_mem,
 };
+#endif
 
 static const struct file_operations null_fops = {
         .llseek         = null_lseek,
@@ -889,11 +895,13 @@ static int memory_open(struct inode * inode, struct file * filp)
                         filp->f_mapping->backing_dev_info =
                                 &directly_mappable_cdev_bdi;
                         break;
+#ifdef CONFIG_DEVKMEM
                 case 2:
                         filp->f_op = &kmem_fops;
                         filp->f_mapping->backing_dev_info =
                                 &directly_mappable_cdev_bdi;
                         break;
+#endif
                 case 3:
                         filp->f_op = &null_fops;
                         break;
@@ -942,7 +950,9 @@ static const struct {
         const struct file_operations    *fops;
 } devlist[] = { /* list of minor devices */
         {1, "mem",     S_IRUSR | S_IWUSR | S_IRGRP, &mem_fops},
+#ifdef CONFIG_DEVKMEM
         {2, "kmem",    S_IRUSR | S_IWUSR | S_IRGRP, &kmem_fops},
+#endif
         {3, "null",    S_IRUGO | S_IWUGO,           &null_fops},
 #ifdef CONFIG_DEVPORT
         {4, "port",    S_IRUSR | S_IWUSR | S_IRGRP, &port_fops},
diff --git a/drivers/char/misc.c b/drivers/char/misc.c
index 4d058dadbfcc..eaace0db0ff4 100644
--- a/drivers/char/misc.c
+++ b/drivers/char/misc.c
@@ -263,23 +263,26 @@ EXPORT_SYMBOL(misc_deregister);
 
 static int __init misc_init(void)
 {
-#ifdef CONFIG_PROC_FS
-        struct proc_dir_entry *ent;
+        int err;
 
-        ent = create_proc_entry("misc", 0, NULL);
-        if (ent)
-                ent->proc_fops = &misc_proc_fops;
+#ifdef CONFIG_PROC_FS
+        proc_create("misc", 0, NULL, &misc_proc_fops);
 #endif
         misc_class = class_create(THIS_MODULE, "misc");
+        err = PTR_ERR(misc_class);
         if (IS_ERR(misc_class))
-                return PTR_ERR(misc_class);
+                goto fail_remove;
 
-        if (register_chrdev(MISC_MAJOR,"misc",&misc_fops)) {
-                printk("unable to get major %d for misc devices\n",
-                       MISC_MAJOR);
-                class_destroy(misc_class);
-                return -EIO;
-        }
+        err = -EIO;
+        if (register_chrdev(MISC_MAJOR,"misc",&misc_fops))
+                goto fail_printk;
         return 0;
+
+fail_printk:
+        printk("unable to get major %d for misc devices\n", MISC_MAJOR);
+        class_destroy(misc_class);
+fail_remove:
+        remove_proc_entry("misc", NULL);
+        return err;
 }
 subsys_initcall(misc_init);
diff --git a/drivers/char/pcmcia/ipwireless/hardware.c b/drivers/char/pcmcia/ipwireless/hardware.c
index 1f978ff87fa8..fa9d3c945f31 100644
--- a/drivers/char/pcmcia/ipwireless/hardware.c
+++ b/drivers/char/pcmcia/ipwireless/hardware.c
@@ -354,32 +354,6 @@ struct ipw_rx_packet {
         unsigned int channel_idx;
 };
 
-#ifdef IPWIRELESS_STATE_DEBUG
-int ipwireless_dump_hardware_state(char *p, size_t limit,
-                                   struct ipw_hardware *hw)
-{
-        return snprintf(p, limit,
-                        "debug: initializing=%d\n"
-                        "debug: tx_ready=%d\n"
-                        "debug: tx_queued=%d\n"
-                        "debug: rx_ready=%d\n"
-                        "debug: rx_bytes_queued=%d\n"
-                        "debug: blocking_rx=%d\n"
-                        "debug: removed=%d\n"
-                        "debug: hardware.shutting_down=%d\n"
-                        "debug: to_setup=%d\n",
-                        hw->initializing,
-                        hw->tx_ready,
-                        hw->tx_queued,
-                        hw->rx_ready,
-                        hw->rx_bytes_queued,
-                        hw->blocking_rx,
-                        hw->removed,
-                        hw->shutting_down,
-                        hw->to_setup);
-}
-#endif
-
 static char *data_type(const unsigned char *buf, unsigned length)
 {
         struct nl_packet_header *hdr = (struct nl_packet_header *) buf;
diff --git a/drivers/char/pcmcia/ipwireless/hardware.h b/drivers/char/pcmcia/ipwireless/hardware.h
index c83190ffb0e7..19ce5eb266b1 100644
--- a/drivers/char/pcmcia/ipwireless/hardware.h
+++ b/drivers/char/pcmcia/ipwireless/hardware.h
@@ -58,7 +58,5 @@ void ipwireless_init_hardware_v1(struct ipw_hardware *hw,
                                  void *reboot_cb_data);
 void ipwireless_init_hardware_v2_v3(struct ipw_hardware *hw);
 void ipwireless_sleep(unsigned int tenths);
-int ipwireless_dump_hardware_state(char *p, size_t limit,
-                                   struct ipw_hardware *hw);
 
 #endif
diff --git a/drivers/char/pcmcia/ipwireless/network.c b/drivers/char/pcmcia/ipwireless/network.c
index d793e68b3e0d..fe914d34f7f6 100644
--- a/drivers/char/pcmcia/ipwireless/network.c
+++ b/drivers/char/pcmcia/ipwireless/network.c
@@ -63,21 +63,6 @@ struct ipw_network {
         struct work_struct work_go_offline;
 };
 
-
-#ifdef IPWIRELESS_STATE_DEBUG
-int ipwireless_dump_network_state(char *p, size_t limit,
-                                  struct ipw_network *network)
-{
-        return snprintf(p, limit,
-                        "debug: ppp_blocked=%d\n"
-                        "debug: outgoing_packets_queued=%d\n"
-                        "debug: network.shutting_down=%d\n",
-                        network->ppp_blocked,
-                        network->outgoing_packets_queued,
-                        network->shutting_down);
-}
-#endif
-
 static void notify_packet_sent(void *callback_data, unsigned int packet_length)
 {
         struct ipw_network *network = callback_data;
diff --git a/drivers/char/pcmcia/ipwireless/network.h b/drivers/char/pcmcia/ipwireless/network.h
index b0e1e952fd14..ccacd26fc7ef 100644
--- a/drivers/char/pcmcia/ipwireless/network.h
+++ b/drivers/char/pcmcia/ipwireless/network.h
@@ -49,7 +49,4 @@ void ipwireless_ppp_close(struct ipw_network *net);
 int ipwireless_ppp_channel_index(struct ipw_network *net);
 int ipwireless_ppp_unit_number(struct ipw_network *net);
 
-int ipwireless_dump_network_state(char *p, size_t limit,
-                                  struct ipw_network *net);
-
 #endif
diff --git a/drivers/char/random.c b/drivers/char/random.c
index f43c89f7c449..0cf98bd4f2d2 100644
--- a/drivers/char/random.c
+++ b/drivers/char/random.c
@@ -272,7 +272,7 @@ static int random_write_wakeup_thresh = 128;
 
 static int trickle_thresh __read_mostly = INPUT_POOL_WORDS * 28;
 
-static DEFINE_PER_CPU(int, trickle_count) = 0;
+static DEFINE_PER_CPU(int, trickle_count);
 
 /*
  * A pool of size .poolwords is stirred with a primitive polynomial
@@ -370,17 +370,19 @@ static struct poolinfo {
  */
 static DECLARE_WAIT_QUEUE_HEAD(random_read_wait);
 static DECLARE_WAIT_QUEUE_HEAD(random_write_wait);
+static struct fasync_struct *fasync;
 
 #if 0
-static int debug = 0;
+static int debug;
 module_param(debug, bool, 0644);
-#define DEBUG_ENT(fmt, arg...) do { if (debug) \
-        printk(KERN_DEBUG "random %04d %04d %04d: " \
-        fmt,\
-        input_pool.entropy_count,\
-        blocking_pool.entropy_count,\
-        nonblocking_pool.entropy_count,\
-        ## arg); } while (0)
+#define DEBUG_ENT(fmt, arg...) do { \
+        if (debug) \
+                printk(KERN_DEBUG "random %04d %04d %04d: " \
+                fmt,\
+                input_pool.entropy_count,\
+                blocking_pool.entropy_count,\
+                nonblocking_pool.entropy_count,\
+                ## arg); } while (0)
 #else
 #define DEBUG_ENT(fmt, arg...) do {} while (0)
 #endif
@@ -394,7 +396,7 @@ module_param(debug, bool, 0644);
 
 struct entropy_store;
 struct entropy_store {
-        /* mostly-read data: */
+        /* read-only data: */
         struct poolinfo *poolinfo;
         __u32 *pool;
         const char *name;
@@ -402,7 +404,7 @@ struct entropy_store {
         struct entropy_store *pull;
 
         /* read-write data: */
-        spinlock_t lock ____cacheline_aligned_in_smp;
+        spinlock_t lock;
         unsigned add_ptr;
         int entropy_count;
         int input_rotate;
@@ -438,25 +440,26 @@ static struct entropy_store nonblocking_pool = {
 };
 
 /*
- * This function adds a byte into the entropy "pool".  It does not
+ * This function adds bytes into the entropy "pool".  It does not
  * update the entropy estimate.  The caller should call
- * credit_entropy_store if this is appropriate.
+ * credit_entropy_bits if this is appropriate.
  *
  * The pool is stirred with a primitive polynomial of the appropriate
  * degree, and then twisted.  We twist by three bits at a time because
  * it's cheap to do so and helps slightly in the expected case where
  * the entropy is concentrated in the low-order bits.
  */
-static void __add_entropy_words(struct entropy_store *r, const __u32 *in,
-                                int nwords, __u32 out[16])
+static void mix_pool_bytes_extract(struct entropy_store *r, const void *in,
+                                   int nbytes, __u8 out[64])
 {
         static __u32 const twist_table[8] = {
                 0x00000000, 0x3b6e20c8, 0x76dc4190, 0x4db26158,
                 0xedb88320, 0xd6d6a3e8, 0x9b64c2b0, 0xa00ae278 };
-        unsigned long i, add_ptr, tap1, tap2, tap3, tap4, tap5;
-        int new_rotate, input_rotate;
+        unsigned long i, j, tap1, tap2, tap3, tap4, tap5;
+        int input_rotate;
         int wordmask = r->poolinfo->poolwords - 1;
-        __u32 w, next_w;
+        const char *bytes = in;
+        __u32 w;
         unsigned long flags;
 
         /* Taps are constant, so we can load them without holding r->lock.  */
@@ -465,78 +468,76 @@ static void __add_entropy_words(struct entropy_store *r, const __u32 *in,
         tap3 = r->poolinfo->tap3;
         tap4 = r->poolinfo->tap4;
         tap5 = r->poolinfo->tap5;
-        next_w = *in++;
 
         spin_lock_irqsave(&r->lock, flags);
-        prefetch_range(r->pool, wordmask);
         input_rotate = r->input_rotate;
-        add_ptr = r->add_ptr;
+        i = r->add_ptr;
 
-        while (nwords--) {
-                w = rol32(next_w, input_rotate);
-                if (nwords > 0)
-                        next_w = *in++;
-                i = add_ptr = (add_ptr - 1) & wordmask;
-                /*
-                 * Normally, we add 7 bits of rotation to the pool.
-                 * At the beginning of the pool, add an extra 7 bits
-                 * rotation, so that successive passes spread the
-                 * input bits across the pool evenly.
-                 */
-                new_rotate = input_rotate + 14;
-                if (i)
-                        new_rotate = input_rotate + 7;
-                input_rotate = new_rotate & 31;
+        /* mix one byte at a time to simplify size handling and churn faster */
+        while (nbytes--) {
+                w = rol32(*bytes++, input_rotate & 31);
+                i = (i - 1) & wordmask;
 
                 /* XOR in the various taps */
+                w ^= r->pool[i];
                 w ^= r->pool[(i + tap1) & wordmask];
                 w ^= r->pool[(i + tap2) & wordmask];
                 w ^= r->pool[(i + tap3) & wordmask];
                 w ^= r->pool[(i + tap4) & wordmask];
                 w ^= r->pool[(i + tap5) & wordmask];
-                w ^= r->pool[i];
+
+                /* Mix the result back in with a twist */
                 r->pool[i] = (w >> 3) ^ twist_table[w & 7];
+
+                /*
+                 * Normally, we add 7 bits of rotation to the pool.
+                 * At the beginning of the pool, add an extra 7 bits
+                 * rotation, so that successive passes spread the
+                 * input bits across the pool evenly.
+                 */
+                input_rotate += i ? 7 : 14;
         }
 
         r->input_rotate = input_rotate;
-        r->add_ptr = add_ptr;
+        r->add_ptr = i;
 
-        if (out) {
-                for (i = 0; i < 16; i++) {
-                        out[i] = r->pool[add_ptr];
-                        add_ptr = (add_ptr - 1) & wordmask;
-                }
-        }
+        if (out)
+                for (j = 0; j < 16; j++)
+                        ((__u32 *)out)[j] = r->pool[(i - j) & wordmask];
 
         spin_unlock_irqrestore(&r->lock, flags);
 }
 
-static inline void add_entropy_words(struct entropy_store *r, const __u32 *in,
-                                     int nwords)
+static void mix_pool_bytes(struct entropy_store *r, const void *in, int bytes)
 {
-        __add_entropy_words(r, in, nwords, NULL);
+       mix_pool_bytes_extract(r, in, bytes, NULL);
 }
 
 /*
  * Credit (or debit) the entropy store with n bits of entropy
  */
-static void credit_entropy_store(struct entropy_store *r, int nbits)
+static void credit_entropy_bits(struct entropy_store *r, int nbits)
 {
         unsigned long flags;
 
+        if (!nbits)
+                return;
+
         spin_lock_irqsave(&r->lock, flags);
 
-        if (r->entropy_count + nbits < 0) {
-                DEBUG_ENT("negative entropy/overflow (%d+%d)\n",
-                          r->entropy_count, nbits);
+        DEBUG_ENT("added %d entropy credits to %s\n", nbits, r->name);
+        r->entropy_count += nbits;
+        if (r->entropy_count < 0) {
+                DEBUG_ENT("negative entropy/overflow\n");
                 r->entropy_count = 0;
-        } else if (r->entropy_count + nbits > r->poolinfo->POOLBITS) {
+        } else if (r->entropy_count > r->poolinfo->POOLBITS)
                 r->entropy_count = r->poolinfo->POOLBITS;
-        } else {
-                r->entropy_count += nbits;
-                if (nbits)
-                        DEBUG_ENT("added %d entropy credits to %s\n",
-                                  nbits, r->name);
+
+        /* should we wake readers? */
+        if (r == &input_pool &&
+            r->entropy_count >= random_read_wakeup_thresh) {
+                wake_up_interruptible(&random_read_wait);
+                kill_fasync(&fasync, SIGIO, POLL_IN);
         }
 
         spin_unlock_irqrestore(&r->lock, flags);
@@ -551,7 +552,7 @@ static void credit_entropy_store(struct entropy_store *r, int nbits)
 /* There is one of these per entropy source */
 struct timer_rand_state {
         cycles_t last_time;
-        long last_delta,last_delta2;
+        long last_delta, last_delta2;
         unsigned dont_count_entropy:1;
 };
 
@@ -586,7 +587,7 @@ static void add_timer_randomness(struct timer_rand_state *state, unsigned num)
         sample.jiffies = jiffies;
         sample.cycles = get_cycles();
         sample.num = num;
-        add_entropy_words(&input_pool, (u32 *)&sample, sizeof(sample)/4);
+        mix_pool_bytes(&input_pool, &sample, sizeof(sample));
 
         /*
          * Calculate number of bits of randomness we probably added.
@@ -620,13 +621,9 @@ static void add_timer_randomness(struct timer_rand_state *state, unsigned num)
                  * Round down by 1 bit on general principles,
                  * and limit entropy entimate to 12 bits.
                  */
-                credit_entropy_store(&input_pool,
-                                     min_t(int, fls(delta>>1), 11));
+                credit_entropy_bits(&input_pool,
+                                    min_t(int, fls(delta>>1), 11));
         }
-
-        if(input_pool.entropy_count >= random_read_wakeup_thresh)
-                wake_up_interruptible(&random_read_wait);
-
 out:
         preempt_enable();
 }
@@ -677,7 +674,7 @@ void add_disk_randomness(struct gendisk *disk)
  *
  *********************************************************************/
 
-static ssize_t extract_entropy(struct entropy_store *r, void * buf,
+static ssize_t extract_entropy(struct entropy_store *r, void *buf,
                                size_t nbytes, int min, int rsvd);
 
 /*
@@ -704,10 +701,10 @@ static void xfer_secondary_pool(struct entropy_store *r, size_t nbytes)
                           "(%d of %d requested)\n",
                           r->name, bytes * 8, nbytes * 8, r->entropy_count);
 
-                bytes=extract_entropy(r->pull, tmp, bytes,
-                                      random_read_wakeup_thresh / 8, rsvd);
-                add_entropy_words(r, tmp, (bytes + 3) / 4);
-                credit_entropy_store(r, bytes*8);
+                bytes = extract_entropy(r->pull, tmp, bytes,
+                                        random_read_wakeup_thresh / 8, rsvd);
+                mix_pool_bytes(r, tmp, bytes);
+                credit_entropy_bits(r, bytes*8);
         }
 }
 
@@ -744,13 +741,15 @@ static size_t account(struct entropy_store *r, size_t nbytes, int min,
                 if (r->limit && nbytes + reserved >= r->entropy_count / 8)
                         nbytes = r->entropy_count/8 - reserved;
 
-                if(r->entropy_count / 8 >= nbytes + reserved)
+                if (r->entropy_count / 8 >= nbytes + reserved)
                         r->entropy_count -= nbytes*8;
                 else
                         r->entropy_count = reserved;
 
-                if (r->entropy_count < random_write_wakeup_thresh)
+                if (r->entropy_count < random_write_wakeup_thresh) {
                         wake_up_interruptible(&random_write_wait);
+                        kill_fasync(&fasync, SIGIO, POLL_OUT);
+                }
         }
 
         DEBUG_ENT("debiting %d entropy credits from %s%s\n",
@@ -764,45 +763,46 @@ static size_t account(struct entropy_store *r, size_t nbytes, int min,
 static void extract_buf(struct entropy_store *r, __u8 *out)
 {
         int i;
-        __u32 data[16], buf[5 + SHA_WORKSPACE_WORDS];
+        __u32 hash[5], workspace[SHA_WORKSPACE_WORDS];
+        __u8 extract[64];
+
+        /* Generate a hash across the pool, 16 words (512 bits) at a time */
+        sha_init(hash);
+        for (i = 0; i < r->poolinfo->poolwords; i += 16)
+                sha_transform(hash, (__u8 *)(r->pool + i), workspace);
 
-        sha_init(buf);
         /*
-         * As we hash the pool, we mix intermediate values of
-         * the hash back into the pool.  This eliminates
-         * backtracking attacks (where the attacker knows
-         * the state of the pool plus the current outputs, and
-         * attempts to find previous ouputs), unless the hash
-         * function can be inverted.
+         * We mix the hash back into the pool to prevent backtracking
+         * attacks (where the attacker knows the state of the pool
+         * plus the current outputs, and attempts to find previous
+         * ouputs), unless the hash function can be inverted. By
+         * mixing at least a SHA1 worth of hash data back, we make
+         * brute-forcing the feedback as hard as brute-forcing the
+         * hash.
          */
-        for (i = 0; i < r->poolinfo->poolwords; i += 16) {
-                /* hash blocks of 16 words = 512 bits */
-                sha_transform(buf, (__u8 *)(r->pool + i), buf + 5);
-                /* feed back portion of the resulting hash */
-                add_entropy_words(r, &buf[i % 5], 1);
-        }
+        mix_pool_bytes_extract(r, hash, sizeof(hash), extract);
 
         /*
-         * To avoid duplicates, we atomically extract a
-         * portion of the pool while mixing, and hash one
-         * final time.
+         * To avoid duplicates, we atomically extract a portion of the
+         * pool while mixing, and hash one final time.
          */
-        __add_entropy_words(r, &buf[i % 5], 1, data);
-        sha_transform(buf, (__u8 *)data, buf + 5);
+        sha_transform(hash, extract, workspace);
+        memset(extract, 0, sizeof(extract));
+        memset(workspace, 0, sizeof(workspace));
 
         /*
-         * In case the hash function has some recognizable
-         * output pattern, we fold it in half.
+         * In case the hash function has some recognizable output
+         * pattern, we fold it in half. Thus, we always feed back
+         * twice as much data as we output.
          */
-
-        buf[0] ^= buf[3];
-        buf[1] ^= buf[4];
-        buf[2] ^= rol32(buf[2], 16);
-        memcpy(out, buf, EXTRACT_SIZE);
-        memset(buf, 0, sizeof(buf));
+        hash[0] ^= hash[3];
+        hash[1] ^= hash[4];
+        hash[2] ^= rol32(hash[2], 16);
+        memcpy(out, hash, EXTRACT_SIZE);
+        memset(hash, 0, sizeof(hash));
 }
 
-static ssize_t extract_entropy(struct entropy_store *r, void * buf,
+static ssize_t extract_entropy(struct entropy_store *r, void *buf,
                                size_t nbytes, int min, int reserved)
 {
         ssize_t ret = 0, i;
@@ -872,7 +872,6 @@ void get_random_bytes(void *buf, int nbytes)
 {
         extract_entropy(&nonblocking_pool, buf, nbytes, 0, 0);
 }
-
 EXPORT_SYMBOL(get_random_bytes);
 
 /*
@@ -894,12 +893,11 @@ static void init_std_data(struct entropy_store *r)
         spin_unlock_irqrestore(&r->lock, flags);
 
         now = ktime_get_real();
-        add_entropy_words(r, (__u32 *)&now, sizeof(now)/4);
-        add_entropy_words(r, (__u32 *)utsname(),
-                          sizeof(*(utsname()))/4);
+        mix_pool_bytes(r, &now, sizeof(now));
+        mix_pool_bytes(r, utsname(), sizeof(*(utsname())));
 }
 
-static int __init rand_initialize(void)
+static int rand_initialize(void)
 {
         init_std_data(&input_pool);
         init_std_data(&blocking_pool);
@@ -940,7 +938,7 @@ void rand_initialize_disk(struct gendisk *disk)
 #endif
 
 static ssize_t
-random_read(struct file * file, char __user * buf, size_t nbytes, loff_t *ppos)
+random_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
 {
         ssize_t n, retval = 0, count = 0;
 
@@ -1002,8 +1000,7 @@ random_read(struct file * file, char __user * buf, size_t nbytes, loff_t *ppos)
 }
 
 static ssize_t
-urandom_read(struct file * file, char __user * buf,
-                      size_t nbytes, loff_t *ppos)
+urandom_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos)
 {
         return extract_entropy_user(&nonblocking_pool, buf, nbytes);
 }
@@ -1038,16 +1035,15 @@ write_pool(struct entropy_store *r, const char __user *buffer, size_t count)
                 count -= bytes;
                 p += bytes;
 
-                add_entropy_words(r, buf, (bytes + 3) / 4);
+                mix_pool_bytes(r, buf, bytes);
                 cond_resched();
         }
 
         return 0;
 }
 
-static ssize_t
-random_write(struct file * file, const char __user * buffer,
-             size_t count, loff_t *ppos)
+static ssize_t random_write(struct file *file, const char __user *buffer,
+                            size_t count, loff_t *ppos)
 {
         size_t ret;
         struct inode *inode = file->f_path.dentry->d_inode;
@@ -1064,9 +1060,7 @@ random_write(struct file * file, const char __user * buffer,
         return (ssize_t)count;
 }
 
-static int
-random_ioctl(struct inode * inode, struct file * file,
-             unsigned int cmd, unsigned long arg)
+static long random_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
 {
         int size, ent_count;
         int __user *p = (int __user *)arg;
@@ -1074,8 +1068,8 @@ random_ioctl(struct inode * inode, struct file * file,
 
         switch (cmd) {
         case RNDGETENTCNT:
-                ent_count = input_pool.entropy_count;
-                if (put_user(ent_count, p))
+                /* inherently racy, no point locking */
+                if (put_user(input_pool.entropy_count, p))
                         return -EFAULT;
                 return 0;
         case RNDADDTOENTCNT:
@@ -1083,13 +1077,7 @@ random_ioctl(struct inode * inode, struct file * file,
                         return -EPERM;
                 if (get_user(ent_count, p))
                         return -EFAULT;
-                credit_entropy_store(&input_pool, ent_count);
-                /*
-                 * Wake up waiting processes if we have enough
-                 * entropy.
-                 */
-                if (input_pool.entropy_count >= random_read_wakeup_thresh)
-                        wake_up_interruptible(&random_read_wait);
+                credit_entropy_bits(&input_pool, ent_count);
                 return 0;
         case RNDADDENTROPY:
                 if (!capable(CAP_SYS_ADMIN))
@@ -1104,39 +1092,45 @@ random_ioctl(struct inode * inode, struct file * file,
                                     size);
                 if (retval < 0)
                         return retval;
-                credit_entropy_store(&input_pool, ent_count);
-                /*
-                 * Wake up waiting processes if we have enough
-                 * entropy.
-                 */
-                if (input_pool.entropy_count >= random_read_wakeup_thresh)
-                        wake_up_interruptible(&random_read_wait);
+                credit_entropy_bits(&input_pool, ent_count);
                 return 0;
         case RNDZAPENTCNT:
         case RNDCLEARPOOL:
                 /* Clear the entropy pool counters. */
                 if (!capable(CAP_SYS_ADMIN))
                         return -EPERM;
-                init_std_data(&input_pool);
-                init_std_data(&blocking_pool);
-                init_std_data(&nonblocking_pool);
+                rand_initialize();
                 return 0;
         default:
                 return -EINVAL;
         }
 }
 
+static int random_fasync(int fd, struct file *filp, int on)
+{
+        return fasync_helper(fd, filp, on, &fasync);
+}
+
+static int random_release(struct inode *inode, struct file *filp)
+{
+        return fasync_helper(-1, filp, 0, &fasync);
+}
+
 const struct file_operations random_fops = {
         .read  = random_read,
         .write = random_write,
         .poll  = random_poll,
-        .ioctl = random_ioctl,
+        .unlocked_ioctl = random_ioctl,
+        .fasync = random_fasync,
+        .release = random_release,
 };
 
 const struct file_operations urandom_fops = {
         .read  = urandom_read,
         .write = random_write,
-        .ioctl = random_ioctl,
+        .unlocked_ioctl = random_ioctl,
+        .fasync = random_fasync,
+        .release = random_release,
 };
 
 /***************************************************************
@@ -1157,7 +1151,6 @@ void generate_random_uuid(unsigned char uuid_out[16])
         /* Set the UUID variant to DCE */
         uuid_out[8] = (uuid_out[8] & 0x3F) | 0x80;
 }
-
 EXPORT_SYMBOL(generate_random_uuid);
 
 /********************************************************************
@@ -1339,7 +1332,7 @@ ctl_table random_table[] = {
 
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 
-static __u32 twothirdsMD4Transform (__u32 const buf[4], __u32 const in[12])
+static __u32 twothirdsMD4Transform(__u32 const buf[4], __u32 const in[12])
 {
         __u32 a = buf[0], b = buf[1], c = buf[2], d = buf[3];
 
@@ -1487,8 +1480,8 @@ __u32 secure_tcpv6_sequence_number(__be32 *saddr, __be32 *daddr,
          */
 
         memcpy(hash, saddr, 16);
-        hash[4]=((__force u16)sport << 16) + (__force u16)dport;
-        memcpy(&hash[5],keyptr->secret,sizeof(__u32) * 7);
+        hash[4] = ((__force u16)sport << 16) + (__force u16)dport;
+        memcpy(&hash[5], keyptr->secret, sizeof(__u32) * 7);
 
         seq = twothirdsMD4Transform((const __u32 *)daddr, hash) & HASH_MASK;
         seq += keyptr->count;
@@ -1538,10 +1531,10 @@ __u32 secure_tcp_sequence_number(__be32 saddr, __be32 daddr,
          *  Note that the words are placed into the starting vector, which is
          *  then mixed with a partial MD4 over random data.
          */
-        hash[0]=(__force u32)saddr;
-        hash[1]=(__force u32)daddr;
-        hash[2]=((__force u16)sport << 16) + (__force u16)dport;
-        hash[3]=keyptr->secret[11];
+        hash[0] = (__force u32)saddr;
+        hash[1] = (__force u32)daddr;
+        hash[2] = ((__force u16)sport << 16) + (__force u16)dport;
+        hash[3] = keyptr->secret[11];
 
         seq = half_md4_transform(hash, keyptr->secret) & HASH_MASK;
         seq += keyptr->count;
@@ -1556,10 +1549,7 @@ __u32 secure_tcp_sequence_number(__be32 saddr, __be32 daddr,
          *      Choosing a clock of 64 ns period is OK. (period of 274 s)
          */
         seq += ktime_to_ns(ktime_get_real()) >> 6;
-#if 0
-        printk("init_seq(%lx, %lx, %d, %d) = %d\n",
-               saddr, daddr, sport, dport, seq);
-#endif
+
         return seq;
 }
 
@@ -1582,14 +1572,15 @@ u32 secure_ipv4_port_ephemeral(__be32 saddr, __be32 daddr, __be16 dport)
 }
 
 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
-u32 secure_ipv6_port_ephemeral(const __be32 *saddr, const __be32 *daddr, __be16 dport)
+u32 secure_ipv6_port_ephemeral(const __be32 *saddr, const __be32 *daddr,
+                               __be16 dport)
 {
         struct keydata *keyptr = get_keyptr();
         u32 hash[12];
 
         memcpy(hash, saddr, 16);
         hash[4] = (__force u32)dport;
-        memcpy(&hash[5],keyptr->secret,sizeof(__u32) * 7);
+        memcpy(&hash[5], keyptr->secret, sizeof(__u32) * 7);
 
         return twothirdsMD4Transform((const __u32 *)daddr, hash);
 }
@@ -1617,13 +1608,9 @@ u64 secure_dccp_sequence_number(__be32 saddr, __be32 daddr,
 
         seq += ktime_to_ns(ktime_get_real());
         seq &= (1ull << 48) - 1;
-#if 0
-        printk("dccp init_seq(%lx, %lx, %d, %d) = %d\n",
-               saddr, daddr, sport, dport, seq);
-#endif
+
         return seq;
 }
-
 EXPORT_SYMBOL(secure_dccp_sequence_number);
 #endif
 
diff --git a/drivers/char/rocket_int.h b/drivers/char/rocket_int.h
index b01d38125a8f..143cc432fdb2 100644
--- a/drivers/char/rocket_int.h
+++ b/drivers/char/rocket_int.h
@@ -55,7 +55,7 @@ static inline void sOutW(unsigned short port, unsigned short value)
 
 static inline void out32(unsigned short port, Byte_t *p)
 {
-        u32 value = le32_to_cpu(get_unaligned((__le32 *)p));
+        u32 value = get_unaligned_le32(p);
 #ifdef ROCKET_DEBUG_IO
         printk(KERN_DEBUG "out32(%x, %lx)...\n", port, value);
 #endif
diff --git a/drivers/char/rtc.c b/drivers/char/rtc.c
index e2ec2ee4cf79..5f80a9dff573 100644
--- a/drivers/char/rtc.c
+++ b/drivers/char/rtc.c
@@ -1069,10 +1069,8 @@ no_irq:
         }
 
 #ifdef CONFIG_PROC_FS
-        ent = create_proc_entry("driver/rtc", 0, NULL);
-        if (ent)
-                ent->proc_fops = &rtc_proc_fops;
-        else
+        ent = proc_create("driver/rtc", 0, NULL, &rtc_proc_fops);
+        if (!ent)
                 printk(KERN_WARNING "rtc: Failed to register with procfs.\n");
 #endif
 
diff --git a/drivers/char/snsc_event.c b/drivers/char/snsc_event.c
index 1b75b0b7d542..31a7765eaf73 100644
--- a/drivers/char/snsc_event.c
+++ b/drivers/char/snsc_event.c
@@ -63,16 +63,13 @@ static int
 scdrv_parse_event(char *event, int *src, int *code, int *esp_code, char *desc)
 {
         char *desc_end;
-        __be32 from_buf;
 
         /* record event source address */
-        from_buf = get_unaligned((__be32 *)event);
-        *src = be32_to_cpup(&from_buf);
+        *src = get_unaligned_be32(event);
         event += 4;                     /* move on to event code */
 
         /* record the system controller's event code */
-        from_buf = get_unaligned((__be32 *)event);
-        *code = be32_to_cpup(&from_buf);
+        *code = get_unaligned_be32(event);
         event += 4;                     /* move on to event arguments */
 
         /* how many arguments are in the packet? */
@@ -86,8 +83,7 @@ scdrv_parse_event(char *event, int *src, int *code, int *esp_code, char *desc)
                 /* not an integer argument, so give up */
                 return -1;
         }
-        from_buf = get_unaligned((__be32 *)event);
-        *esp_code = be32_to_cpup(&from_buf);
+        *esp_code = get_unaligned_be32(event);
         event += 4;
 
         /* parse out the event description */
diff --git a/drivers/char/sysrq.c b/drivers/char/sysrq.c
index 1ade193c9128..9e9bad8bdcf4 100644
--- a/drivers/char/sysrq.c
+++ b/drivers/char/sysrq.c
@@ -196,6 +196,48 @@ static struct sysrq_key_op sysrq_showlocks_op = {
 #define sysrq_showlocks_op (*(struct sysrq_key_op *)0)
 #endif
 
+#ifdef CONFIG_SMP
+static DEFINE_SPINLOCK(show_lock);
+
+static void showacpu(void *dummy)
+{
+        unsigned long flags;
+
+        /* Idle CPUs have no interesting backtrace. */
+        if (idle_cpu(smp_processor_id()))
+                return;
+
+        spin_lock_irqsave(&show_lock, flags);
+        printk(KERN_INFO "CPU%d:\n", smp_processor_id());
+        show_stack(NULL, NULL);
+        spin_unlock_irqrestore(&show_lock, flags);
+}
+
+static void sysrq_showregs_othercpus(struct work_struct *dummy)
+{
+        smp_call_function(showacpu, NULL, 0, 0);
+}
+
+static DECLARE_WORK(sysrq_showallcpus, sysrq_showregs_othercpus);
+
+static void sysrq_handle_showallcpus(int key, struct tty_struct *tty)
+{
+        struct pt_regs *regs = get_irq_regs();
+        if (regs) {
+                printk(KERN_INFO "CPU%d:\n", smp_processor_id());
+                show_regs(regs);
+        }
+        schedule_work(&sysrq_showallcpus);
+}
+
+static struct sysrq_key_op sysrq_showallcpus_op = {
+        .handler        = sysrq_handle_showallcpus,
+        .help_msg       = "aLlcpus",
+        .action_msg     = "Show backtrace of all active CPUs",
+        .enable_mask    = SYSRQ_ENABLE_DUMP,
+};
+#endif
+
 static void sysrq_handle_showregs(int key, struct tty_struct *tty)
 {
         struct pt_regs *regs = get_irq_regs();
@@ -340,7 +382,11 @@ static struct sysrq_key_op *sysrq_key_table[36] = {
         &sysrq_kill_op,                 /* i */
         NULL,                           /* j */
         &sysrq_SAK_op,                  /* k */
+#ifdef CONFIG_SMP
+        &sysrq_showallcpus_op,          /* l */
+#else
         NULL,                           /* l */
+#endif
         &sysrq_showmem_op,              /* m */
         &sysrq_unrt_op,                 /* n */
         /* o: This will often be registered as 'Off' at init time */
diff --git a/drivers/char/toshiba.c b/drivers/char/toshiba.c
index ce5ebe3b168f..64f1ceed0b2c 100644
--- a/drivers/char/toshiba.c
+++ b/drivers/char/toshiba.c
@@ -520,12 +520,11 @@ static int __init toshiba_init(void)
         {
                 struct proc_dir_entry *pde;
 
-                pde = create_proc_entry("toshiba", 0, NULL);
+                pde = proc_create("toshiba", 0, NULL, &proc_toshiba_fops);
                 if (!pde) {
                         misc_deregister(&tosh_device);
                         return -ENOMEM;
                 }
-                pde->proc_fops = &proc_toshiba_fops;
         }
 #endif
 
diff --git a/drivers/char/tpm/Kconfig b/drivers/char/tpm/Kconfig
index 8f3f7620f95a..3738cfa209ff 100644
--- a/drivers/char/tpm/Kconfig
+++ b/drivers/char/tpm/Kconfig
@@ -23,7 +23,7 @@ if TCG_TPM
 
 config TCG_TIS
         tristate "TPM Interface Specification 1.2 Interface"
-        depends on PNPACPI
+        depends on PNP
         ---help---
           If you have a TPM security chip that is compliant with the
           TCG TIS 1.2 TPM specification say Yes and it will be accessible
@@ -32,7 +32,6 @@ config TCG_TIS
 
 config TCG_NSC
         tristate "National Semiconductor TPM Interface"
-        depends on PNPACPI
         ---help---
           If you have a TPM security chip from National Semiconductor 
           say Yes and it will be accessible from within Linux.  To 
@@ -48,7 +47,7 @@ config TCG_ATMEL
 
 config TCG_INFINEON
         tristate "Infineon Technologies TPM Interface"
-        depends on PNPACPI
+        depends on PNP
         ---help---
           If you have a TPM security chip from Infineon Technologies
           (either SLD 9630 TT 1.1 or SLB 9635 TT 1.2) say Yes and it
diff --git a/drivers/char/tpm/tpm_nsc.c b/drivers/char/tpm/tpm_nsc.c
index 6313326bc41f..ab18c1e7b115 100644
--- a/drivers/char/tpm/tpm_nsc.c
+++ b/drivers/char/tpm/tpm_nsc.c
@@ -264,7 +264,7 @@ static const struct tpm_vendor_specific tpm_nsc = {
 
 static struct platform_device *pdev = NULL;
 
-static void __devexit tpm_nsc_remove(struct device *dev)
+static void tpm_nsc_remove(struct device *dev)
 {
         struct tpm_chip *chip = dev_get_drvdata(dev);
         if ( chip ) {
diff --git a/drivers/char/viotape.c b/drivers/char/viotape.c
index db7a731e2362..58aad63831f4 100644
--- a/drivers/char/viotape.c
+++ b/drivers/char/viotape.c
@@ -249,6 +249,7 @@ static int proc_viotape_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations proc_viotape_operations = {
+        .owner          = THIS_MODULE,
         .open           = proc_viotape_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -915,7 +916,6 @@ static struct vio_driver viotape_driver = {
 int __init viotap_init(void)
 {
         int ret;
-        struct proc_dir_entry *e;
 
         if (!firmware_has_feature(FW_FEATURE_ISERIES))
                 return -ENODEV;
@@ -968,11 +968,8 @@ int __init viotap_init(void)
         if (ret)
                 goto unreg_class;
 
-        e = create_proc_entry("iSeries/viotape", S_IFREG|S_IRUGO, NULL);
-        if (e) {
-                e->owner = THIS_MODULE;
-                e->proc_fops = &proc_viotape_operations;
-        }
+        proc_create("iSeries/viotape", S_IFREG|S_IRUGO, NULL,
+                    &proc_viotape_operations);
 
         return 0;
 
diff --git a/drivers/char/vt.c b/drivers/char/vt.c
index df4c3ead9e2b..1c2660477135 100644
--- a/drivers/char/vt.c
+++ b/drivers/char/vt.c
@@ -301,7 +301,7 @@ static void scrup(struct vc_data *vc, unsigned int t, unsigned int b, int nr)
         d = (unsigned short *)(vc->vc_origin + vc->vc_size_row * t);
         s = (unsigned short *)(vc->vc_origin + vc->vc_size_row * (t + nr));
         scr_memmovew(d, s, (b - t - nr) * vc->vc_size_row);
-        scr_memsetw(d + (b - t - nr) * vc->vc_cols, vc->vc_video_erase_char,
+        scr_memsetw(d + (b - t - nr) * vc->vc_cols, vc->vc_scrl_erase_char,
                     vc->vc_size_row * nr);
 }
 
@@ -319,7 +319,7 @@ static void scrdown(struct vc_data *vc, unsigned int t, unsigned int b, int nr)
         s = (unsigned short *)(vc->vc_origin + vc->vc_size_row * t);
         step = vc->vc_cols * nr;
         scr_memmovew(s + step, s, (b - t - nr) * vc->vc_size_row);
-        scr_memsetw(s, vc->vc_video_erase_char, 2 * step);
+        scr_memsetw(s, vc->vc_scrl_erase_char, 2 * step);
 }
 
 static void do_update_region(struct vc_data *vc, unsigned long start, int count)
@@ -400,7 +400,7 @@ static u8 build_attr(struct vc_data *vc, u8 _color, u8 _intensity, u8 _blink,
  *  Bit 7   : blink
  */
         {
-        u8 a = vc->vc_color;
+        u8 a = _color;
         if (!vc->vc_can_do_color)
                 return _intensity |
                        (_italic ? 2 : 0) |
@@ -434,6 +434,7 @@ static void update_attr(struct vc_data *vc)
                       vc->vc_blink, vc->vc_underline,
                       vc->vc_reverse ^ vc->vc_decscnm, vc->vc_italic);
         vc->vc_video_erase_char = (build_attr(vc, vc->vc_color, 1, vc->vc_blink, 0, vc->vc_decscnm, 0) << 8) | ' ';
+        vc->vc_scrl_erase_char = (build_attr(vc, vc->vc_def_color, 1, false, false, false, false) << 8) | ' ';
 }
 
 /* Note: inverting the screen twice should revert to the original state */
diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig
index 2b382990fe58..6e6c3c4aea6b 100644
--- a/drivers/edac/Kconfig
+++ b/drivers/edac/Kconfig
@@ -67,7 +67,7 @@ config EDAC_E7XXX
           E7205, E7500, E7501 and E7505 server chipsets.
 
 config EDAC_E752X
-        tristate "Intel e752x (e7520, e7525, e7320)"
+        tristate "Intel e752x (e7520, e7525, e7320) and 3100"
         depends on EDAC_MM_EDAC && PCI && X86 && HOTPLUG
         help
           Support for error detection and correction on the Intel
diff --git a/drivers/edac/amd76x_edac.c b/drivers/edac/amd76x_edac.c
index f22075410591..2b95f1a3edfc 100644
--- a/drivers/edac/amd76x_edac.c
+++ b/drivers/edac/amd76x_edac.c
@@ -17,6 +17,7 @@
 #include <linux/pci.h>
 #include <linux/pci_ids.h>
 #include <linux/slab.h>
+#include <linux/edac.h>
 #include "edac_core.h"
 
 #define AMD76X_REVISION " Ver: 2.0.2 "  __DATE__
@@ -344,6 +345,9 @@ static struct pci_driver amd76x_driver = {
 
 static int __init amd76x_init(void)
 {
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         return pci_register_driver(&amd76x_driver);
 }
 
@@ -358,3 +362,6 @@ module_exit(amd76x_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Linux Networx (http://lnxi.com) Thayne Harbaugh");
 MODULE_DESCRIPTION("MC support for AMD 76x memory controllers");
+
+module_param(edac_op_state, int, 0444);
+MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
diff --git a/drivers/edac/e752x_edac.c b/drivers/edac/e752x_edac.c
index 6eb434749cd5..c94a0eb492cb 100644
--- a/drivers/edac/e752x_edac.c
+++ b/drivers/edac/e752x_edac.c
@@ -29,6 +29,7 @@
 #define EDAC_MOD_STR    "e752x_edac"
 
 static int force_function_unhide;
+static int sysbus_parity = -1;
 
 static struct edac_pci_ctl_info *e752x_pci;
 
@@ -62,6 +63,14 @@ static struct edac_pci_ctl_info *e752x_pci;
 #define PCI_DEVICE_ID_INTEL_7320_1_ERR  0x3593
 #endif                          /* PCI_DEVICE_ID_INTEL_7320_1_ERR */
 
+#ifndef PCI_DEVICE_ID_INTEL_3100_0
+#define PCI_DEVICE_ID_INTEL_3100_0      0x35B0
+#endif                          /* PCI_DEVICE_ID_INTEL_3100_0 */
+
+#ifndef PCI_DEVICE_ID_INTEL_3100_1_ERR
+#define PCI_DEVICE_ID_INTEL_3100_1_ERR  0x35B1
+#endif                          /* PCI_DEVICE_ID_INTEL_3100_1_ERR */
+
 #define E752X_NR_CSROWS         8       /* number of csrows */
 
 /* E752X register addresses - device 0 function 0 */
@@ -152,6 +161,12 @@ static struct edac_pci_ctl_info *e752x_pci;
                                         /*     error syndrome register (16b) */
 #define E752X_DEVPRES1          0xF4    /* Device Present 1 register (8b) */
 
+/* 3100 IMCH specific register addresses - device 0 function 1 */
+#define I3100_NSI_FERR          0x48    /* NSI first error reg (32b) */
+#define I3100_NSI_NERR          0x4C    /* NSI next error reg (32b) */
+#define I3100_NSI_SMICMD        0x54    /* NSI SMI command register (32b) */
+#define I3100_NSI_EMASK         0x90    /* NSI error mask register (32b) */
+
 /* ICH5R register addresses - device 30 function 0 */
 #define ICH5R_PCI_STAT          0x06    /* PCI status register (16b) */
 #define ICH5R_PCI_2ND_STAT      0x1E    /* PCI status secondary reg (16b) */
@@ -160,7 +175,8 @@ static struct edac_pci_ctl_info *e752x_pci;
 enum e752x_chips {
         E7520 = 0,
         E7525 = 1,
-        E7320 = 2
+        E7320 = 2,
+        I3100 = 3
 };
 
 struct e752x_pvt {
@@ -185,8 +201,10 @@ struct e752x_dev_info {
 struct e752x_error_info {
         u32 ferr_global;
         u32 nerr_global;
-        u8 hi_ferr;
-        u8 hi_nerr;
+        u32 nsi_ferr;   /* 3100 only */
+        u32 nsi_nerr;   /* 3100 only */
+        u8 hi_ferr;     /* all but 3100 */
+        u8 hi_nerr;     /* all but 3100 */
         u16 sysbus_ferr;
         u16 sysbus_nerr;
         u8 buf_ferr;
@@ -215,6 +233,10 @@ static const struct e752x_dev_info e752x_devs[] = {
                 .err_dev = PCI_DEVICE_ID_INTEL_7320_1_ERR,
                 .ctl_dev = PCI_DEVICE_ID_INTEL_7320_0,
                 .ctl_name = "E7320"},
+        [I3100] = {
+                .err_dev = PCI_DEVICE_ID_INTEL_3100_1_ERR,
+                .ctl_dev = PCI_DEVICE_ID_INTEL_3100_0,
+                .ctl_name = "3100"},
 };
 
 static unsigned long ctl_page_to_phys(struct mem_ctl_info *mci,
@@ -402,7 +424,7 @@ static inline void process_threshold_ce(struct mem_ctl_info *mci, u16 error,
 static char *global_message[11] = {
         "PCI Express C1", "PCI Express C", "PCI Express B1",
         "PCI Express B", "PCI Express A1", "PCI Express A",
-        "DMA Controler", "HUB Interface", "System Bus",
+        "DMA Controler", "HUB or NS Interface", "System Bus",
         "DRAM Controler", "Internal Buffer"
 };
 
@@ -455,6 +477,63 @@ static inline void hub_error(int fatal, u8 errors, int *error_found,
                 do_hub_error(fatal, errors);
 }
 
+#define NSI_FATAL_MASK          0x0c080081
+#define NSI_NON_FATAL_MASK      0x23a0ba64
+#define NSI_ERR_MASK            (NSI_FATAL_MASK | NSI_NON_FATAL_MASK)
+
+static char *nsi_message[30] = {
+        "NSI Link Down",        /* NSI_FERR/NSI_NERR bit 0, fatal error */
+        "",                                             /* reserved */
+        "NSI Parity Error",                             /* bit 2, non-fatal */
+        "",                                             /* reserved */
+        "",                                             /* reserved */
+        "Correctable Error Message",                    /* bit 5, non-fatal */
+        "Non-Fatal Error Message",                      /* bit 6, non-fatal */
+        "Fatal Error Message",                          /* bit 7, fatal */
+        "",                                             /* reserved */
+        "Receiver Error",                               /* bit 9, non-fatal */
+        "",                                             /* reserved */
+        "Bad TLP",                                      /* bit 11, non-fatal */
+        "Bad DLLP",                                     /* bit 12, non-fatal */
+        "REPLAY_NUM Rollover",                          /* bit 13, non-fatal */
+        "",                                             /* reserved */
+        "Replay Timer Timeout",                         /* bit 15, non-fatal */
+        "",                                             /* reserved */
+        "",                                             /* reserved */
+        "",                                             /* reserved */
+        "Data Link Protocol Error",                     /* bit 19, fatal */
+        "",                                             /* reserved */
+        "Poisoned TLP",                                 /* bit 21, non-fatal */
+        "",                                             /* reserved */
+        "Completion Timeout",                           /* bit 23, non-fatal */
+        "Completer Abort",                              /* bit 24, non-fatal */
+        "Unexpected Completion",                        /* bit 25, non-fatal */
+        "Receiver Overflow",                            /* bit 26, fatal */
+        "Malformed TLP",                                /* bit 27, fatal */
+        "",                                             /* reserved */
+        "Unsupported Request"                           /* bit 29, non-fatal */
+};
+
+static void do_nsi_error(int fatal, u32 errors)
+{
+        int i;
+
+        for (i = 0; i < 30; i++) {
+                if (errors & (1 << i))
+                        printk(KERN_WARNING "%sError %s\n",
+                               fatal_message[fatal], nsi_message[i]);
+        }
+}
+
+static inline void nsi_error(int fatal, u32 errors, int *error_found,
+                int handle_error)
+{
+        *error_found = 1;
+
+        if (handle_error)
+                do_nsi_error(fatal, errors);
+}
+
 static char *membuf_message[4] = {
         "Internal PMWB to DRAM parity",
         "Internal PMWB to System Bus Parity",
@@ -546,6 +625,31 @@ static void e752x_check_hub_interface(struct e752x_error_info *info,
         }
 }
 
+static void e752x_check_ns_interface(struct e752x_error_info *info,
+                                int *error_found, int handle_error)
+{
+        u32 stat32;
+
+        stat32 = info->nsi_ferr;
+        if (stat32 & NSI_ERR_MASK) { /* Error, so process */
+                if (stat32 & NSI_FATAL_MASK)    /* check for fatal errors */
+                        nsi_error(1, stat32 & NSI_FATAL_MASK, error_found,
+                                  handle_error);
+                if (stat32 & NSI_NON_FATAL_MASK) /* check for non-fatal ones */
+                        nsi_error(0, stat32 & NSI_NON_FATAL_MASK, error_found,
+                                  handle_error);
+        }
+        stat32 = info->nsi_nerr;
+        if (stat32 & NSI_ERR_MASK) {
+                if (stat32 & NSI_FATAL_MASK)
+                        nsi_error(1, stat32 & NSI_FATAL_MASK, error_found,
+                                  handle_error);
+                if (stat32 & NSI_NON_FATAL_MASK)
+                        nsi_error(0, stat32 & NSI_NON_FATAL_MASK, error_found,
+                                  handle_error);
+        }
+}
+
 static void e752x_check_sysbus(struct e752x_error_info *info,
                         int *error_found, int handle_error)
 {
@@ -653,7 +757,15 @@ static void e752x_get_error_info(struct mem_ctl_info *mci,
         pci_read_config_dword(dev, E752X_FERR_GLOBAL, &info->ferr_global);
 
         if (info->ferr_global) {
-                pci_read_config_byte(dev, E752X_HI_FERR, &info->hi_ferr);
+                if (pvt->dev_info->err_dev == PCI_DEVICE_ID_INTEL_3100_1_ERR) {
+                        pci_read_config_dword(dev, I3100_NSI_FERR,
+                                             &info->nsi_ferr);
+                        info->hi_ferr = 0;
+                } else {
+                        pci_read_config_byte(dev, E752X_HI_FERR,
+                                             &info->hi_ferr);
+                        info->nsi_ferr = 0;
+                }
                 pci_read_config_word(dev, E752X_SYSBUS_FERR,
                                 &info->sysbus_ferr);
                 pci_read_config_byte(dev, E752X_BUF_FERR, &info->buf_ferr);
@@ -669,10 +781,15 @@ static void e752x_get_error_info(struct mem_ctl_info *mci,
                 pci_read_config_dword(dev, E752X_DRAM_RETR_ADD,
                                 &info->dram_retr_add);
 
+                /* ignore the reserved bits just in case */
                 if (info->hi_ferr & 0x7f)
                         pci_write_config_byte(dev, E752X_HI_FERR,
                                         info->hi_ferr);
 
+                if (info->nsi_ferr & NSI_ERR_MASK)
+                        pci_write_config_dword(dev, I3100_NSI_FERR,
+                                        info->nsi_ferr);
+
                 if (info->sysbus_ferr)
                         pci_write_config_word(dev, E752X_SYSBUS_FERR,
                                         info->sysbus_ferr);
@@ -692,7 +809,15 @@ static void e752x_get_error_info(struct mem_ctl_info *mci,
         pci_read_config_dword(dev, E752X_NERR_GLOBAL, &info->nerr_global);
 
         if (info->nerr_global) {
-                pci_read_config_byte(dev, E752X_HI_NERR, &info->hi_nerr);
+                if (pvt->dev_info->err_dev == PCI_DEVICE_ID_INTEL_3100_1_ERR) {
+                        pci_read_config_dword(dev, I3100_NSI_NERR,
+                                             &info->nsi_nerr);
+                        info->hi_nerr = 0;
+                } else {
+                        pci_read_config_byte(dev, E752X_HI_NERR,
+                                             &info->hi_nerr);
+                        info->nsi_nerr = 0;
+                }
                 pci_read_config_word(dev, E752X_SYSBUS_NERR,
                                 &info->sysbus_nerr);
                 pci_read_config_byte(dev, E752X_BUF_NERR, &info->buf_nerr);
@@ -706,6 +831,10 @@ static void e752x_get_error_info(struct mem_ctl_info *mci,
                         pci_write_config_byte(dev, E752X_HI_NERR,
                                         info->hi_nerr);
 
+                if (info->nsi_nerr & NSI_ERR_MASK)
+                        pci_write_config_dword(dev, I3100_NSI_NERR,
+                                        info->nsi_nerr);
+
                 if (info->sysbus_nerr)
                         pci_write_config_word(dev, E752X_SYSBUS_NERR,
                                         info->sysbus_nerr);
@@ -750,6 +879,7 @@ static int e752x_process_error_info(struct mem_ctl_info *mci,
                 global_error(0, stat32, &error_found, handle_errors);
 
         e752x_check_hub_interface(info, &error_found, handle_errors);
+        e752x_check_ns_interface(info, &error_found, handle_errors);
         e752x_check_sysbus(info, &error_found, handle_errors);
         e752x_check_membuf(info, &error_found, handle_errors);
         e752x_check_dram(mci, info, &error_found, handle_errors);
@@ -920,15 +1050,53 @@ fail:
         return 1;
 }
 
+/* Setup system bus parity mask register.
+ * Sysbus parity supported on:
+ *   e7320/e7520/e7525 + Xeon
+ *   i3100 + Xeon/Celeron
+ * Sysbus parity not supported on:
+ *   i3100 + Pentium M/Celeron M/Core Duo/Core2 Duo
+ */
+static void e752x_init_sysbus_parity_mask(struct e752x_pvt *pvt)
+{
+        char *cpu_id = cpu_data(0).x86_model_id;
+        struct pci_dev *dev = pvt->dev_d0f1;
+        int enable = 1;
+
+        /* Allow module paramter override, else see if CPU supports parity */
+        if (sysbus_parity != -1) {
+                enable = sysbus_parity;
+        } else if (cpu_id[0] &&
+                   ((strstr(cpu_id, "Pentium") && strstr(cpu_id, " M ")) ||
+                    (strstr(cpu_id, "Celeron") && strstr(cpu_id, " M ")) ||
+                    (strstr(cpu_id, "Core") && strstr(cpu_id, "Duo")))) {
+                e752x_printk(KERN_INFO, "System Bus Parity not "
+                             "supported by CPU, disabling\n");
+                enable = 0;
+        }
+
+        if (enable)
+                pci_write_config_word(dev, E752X_SYSBUS_ERRMASK, 0x0000);
+        else
+                pci_write_config_word(dev, E752X_SYSBUS_ERRMASK, 0x0309);
+}
+
 static void e752x_init_error_reporting_regs(struct e752x_pvt *pvt)
 {
         struct pci_dev *dev;
 
         dev = pvt->dev_d0f1;
         /* Turn off error disable & SMI in case the BIOS turned it on */
-        pci_write_config_byte(dev, E752X_HI_ERRMASK, 0x00);
-        pci_write_config_byte(dev, E752X_HI_SMICMD, 0x00);
-        pci_write_config_word(dev, E752X_SYSBUS_ERRMASK, 0x00);
+        if (pvt->dev_info->err_dev == PCI_DEVICE_ID_INTEL_3100_1_ERR) {
+                pci_write_config_dword(dev, I3100_NSI_EMASK, 0);
+                pci_write_config_dword(dev, I3100_NSI_SMICMD, 0);
+        } else {
+                pci_write_config_byte(dev, E752X_HI_ERRMASK, 0x00);
+                pci_write_config_byte(dev, E752X_HI_SMICMD, 0x00);
+        }
+
+        e752x_init_sysbus_parity_mask(pvt);
+
         pci_write_config_word(dev, E752X_SYSBUS_SMICMD, 0x00);
         pci_write_config_byte(dev, E752X_BUF_ERRMASK, 0x00);
         pci_write_config_byte(dev, E752X_BUF_SMICMD, 0x00);
@@ -949,16 +1117,6 @@ static int e752x_probe1(struct pci_dev *pdev, int dev_idx)
         debugf0("%s(): mci\n", __func__);
         debugf0("Starting Probe1\n");
 
-        /* make sure error reporting method is sane */
-        switch (edac_op_state) {
-        case EDAC_OPSTATE_POLL:
-        case EDAC_OPSTATE_NMI:
-                break;
-        default:
-                edac_op_state = EDAC_OPSTATE_POLL;
-                break;
-        }
-
         /* check to see if device 0 function 1 is enabled; if it isn't, we
          * assume the BIOS has reserved it for a reason and is expecting
          * exclusive access, we take care not to violate that assumption and
@@ -985,8 +1143,9 @@ static int e752x_probe1(struct pci_dev *pdev, int dev_idx)
 
         debugf3("%s(): init mci\n", __func__);
         mci->mtype_cap = MEM_FLAG_RDDR;
-        mci->edac_ctl_cap = EDAC_FLAG_NONE | EDAC_FLAG_SECDED |
-                EDAC_FLAG_S4ECD4ED;
+        /* 3100 IMCH supports SECDEC only */
+        mci->edac_ctl_cap = (dev_idx == I3100) ? EDAC_FLAG_SECDED :
+                (EDAC_FLAG_NONE | EDAC_FLAG_SECDED | EDAC_FLAG_S4ECD4ED);
         /* FIXME - what if different memory types are in different csrows? */
         mci->mod_name = EDAC_MOD_STR;
         mci->mod_ver = E752X_REVISION;
@@ -1018,7 +1177,10 @@ static int e752x_probe1(struct pci_dev *pdev, int dev_idx)
         e752x_init_csrows(mci, pdev, ddrcsr);
         e752x_init_mem_map_table(pdev, pvt);
 
-        mci->edac_cap |= EDAC_FLAG_NONE;
+        if (dev_idx == I3100)
+                mci->edac_cap = EDAC_FLAG_SECDED; /* the only mode supported */
+        else
+                mci->edac_cap |= EDAC_FLAG_NONE;
         debugf3("%s(): tolm, remapbase, remaplimit\n", __func__);
 
         /* load the top of low memory, remap base, and remap limit vars */
@@ -1110,6 +1272,9 @@ static const struct pci_device_id e752x_pci_tbl[] __devinitdata = {
          PCI_VEND_DEV(INTEL, 7320_0), PCI_ANY_ID, PCI_ANY_ID, 0, 0,
          E7320},
         {
+         PCI_VEND_DEV(INTEL, 3100_0), PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+         I3100},
+        {
          0,
          }                      /* 0 terminated list. */
 };
@@ -1128,6 +1293,10 @@ static int __init e752x_init(void)
         int pci_rc;
 
         debugf3("%s()\n", __func__);
+
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         pci_rc = pci_register_driver(&e752x_driver);
         return (pci_rc < 0) ? pci_rc : 0;
 }
@@ -1143,10 +1312,15 @@ module_exit(e752x_exit);
 
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Linux Networx (http://lnxi.com) Tom Zimmerman\n");
-MODULE_DESCRIPTION("MC support for Intel e752x memory controllers");
+MODULE_DESCRIPTION("MC support for Intel e752x/3100 memory controllers");
 
 module_param(force_function_unhide, int, 0444);
 MODULE_PARM_DESC(force_function_unhide, "if BIOS sets Dev0:Fun1 up as hidden:"
                  " 1=force unhide and hope BIOS doesn't fight driver for Dev0:Fun1 access");
+
 module_param(edac_op_state, int, 0444);
 MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
+
+module_param(sysbus_parity, int, 0444);
+MODULE_PARM_DESC(sysbus_parity, "0=disable system bus parity checking,"
+                " 1=enable system bus parity checking, default=auto-detect");
diff --git a/drivers/edac/e7xxx_edac.c b/drivers/edac/e7xxx_edac.c
index 96ecc4926641..c7d11cc4e21a 100644
--- a/drivers/edac/e7xxx_edac.c
+++ b/drivers/edac/e7xxx_edac.c
@@ -414,16 +414,6 @@ static int e7xxx_probe1(struct pci_dev *pdev, int dev_idx)
 
         debugf0("%s(): mci\n", __func__);
 
-        /* make sure error reporting method is sane */
-        switch (edac_op_state) {
-        case EDAC_OPSTATE_POLL:
-        case EDAC_OPSTATE_NMI:
-                break;
-        default:
-                edac_op_state = EDAC_OPSTATE_POLL;
-                break;
-        }
-
         pci_read_config_dword(pdev, E7XXX_DRC, &drc);
 
         drc_chan = dual_channel_active(drc, dev_idx);
@@ -565,6 +555,9 @@ static struct pci_driver e7xxx_driver = {
 
 static int __init e7xxx_init(void)
 {
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         return pci_register_driver(&e7xxx_driver);
 }
 
diff --git a/drivers/edac/edac_device.c b/drivers/edac/edac_device.c
index b9552bc03dea..63372fa7ecfe 100644
--- a/drivers/edac/edac_device.c
+++ b/drivers/edac/edac_device.c
@@ -36,7 +36,7 @@
  * is protected by the 'device_ctls_mutex' lock
  */
 static DEFINE_MUTEX(device_ctls_mutex);
-static struct list_head edac_device_list = LIST_HEAD_INIT(edac_device_list);
+static LIST_HEAD(edac_device_list);
 
 #ifdef CONFIG_EDAC_DEBUG
 static void edac_device_dump_device(struct edac_device_ctl_info *edac_dev)
@@ -375,37 +375,6 @@ static void del_edac_device_from_global_list(struct edac_device_ctl_info
         wait_for_completion(&edac_device->removal_complete);
 }
 
-/**
- * edac_device_find
- *      Search for a edac_device_ctl_info structure whose index is 'idx'.
- *
- * If found, return a pointer to the structure.
- * Else return NULL.
- *
- * Caller must hold device_ctls_mutex.
- */
-struct edac_device_ctl_info *edac_device_find(int idx)
-{
-        struct list_head *item;
-        struct edac_device_ctl_info *edac_dev;
-
-        /* Iterate over list, looking for exact match of ID */
-        list_for_each(item, &edac_device_list) {
-                edac_dev = list_entry(item, struct edac_device_ctl_info, link);
-
-                if (edac_dev->dev_idx >= idx) {
-                        if (edac_dev->dev_idx == idx)
-                                return edac_dev;
-
-                        /* not on list, so terminate early */
-                        break;
-                }
-        }
-
-        return NULL;
-}
-EXPORT_SYMBOL_GPL(edac_device_find);
-
 /*
  * edac_device_workq_function
  *      performs the operation scheduled by a workq request
diff --git a/drivers/edac/edac_mc.c b/drivers/edac/edac_mc.c
index 063a1bffe38b..a4cf1645f588 100644
--- a/drivers/edac/edac_mc.c
+++ b/drivers/edac/edac_mc.c
@@ -36,7 +36,7 @@
 
 /* lock to memory controller's control array */
 static DEFINE_MUTEX(mem_ctls_mutex);
-static struct list_head mc_devices = LIST_HEAD_INIT(mc_devices);
+static LIST_HEAD(mc_devices);
 
 #ifdef CONFIG_EDAC_DEBUG
 
@@ -886,24 +886,3 @@ void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
         mci->csrows[csrow].channels[channel].ce_count++;
 }
 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);
-
-/*
- * Iterate over all MC instances and check for ECC, et al, errors
- */
-void edac_check_mc_devices(void)
-{
-        struct list_head *item;
-        struct mem_ctl_info *mci;
-
-        debugf3("%s()\n", __func__);
-        mutex_lock(&mem_ctls_mutex);
-
-        list_for_each(item, &mc_devices) {
-                mci = list_entry(item, struct mem_ctl_info, link);
-
-                if (mci->edac_check != NULL)
-                        mci->edac_check(mci);
-        }
-
-        mutex_unlock(&mem_ctls_mutex);
-}
diff --git a/drivers/edac/edac_module.h b/drivers/edac/edac_module.h
index cbc419c8ebc1..233d4798c3aa 100644
--- a/drivers/edac/edac_module.h
+++ b/drivers/edac/edac_module.h
@@ -27,7 +27,6 @@ extern int edac_mc_register_sysfs_main_kobj(struct mem_ctl_info *mci);
 extern void edac_mc_unregister_sysfs_main_kobj(struct mem_ctl_info *mci);
 extern int edac_create_sysfs_mci_device(struct mem_ctl_info *mci);
 extern void edac_remove_sysfs_mci_device(struct mem_ctl_info *mci);
-extern void edac_check_mc_devices(void);
 extern int edac_get_log_ue(void);
 extern int edac_get_log_ce(void);
 extern int edac_get_panic_on_ue(void);
diff --git a/drivers/edac/edac_pci.c b/drivers/edac/edac_pci.c
index 32be43576a8e..9b24340b52e1 100644
--- a/drivers/edac/edac_pci.c
+++ b/drivers/edac/edac_pci.c
@@ -29,7 +29,7 @@
 #include "edac_module.h"
 
 static DEFINE_MUTEX(edac_pci_ctls_mutex);
-static struct list_head edac_pci_list = LIST_HEAD_INIT(edac_pci_list);
+static LIST_HEAD(edac_pci_list);
 
 /*
  * edac_pci_alloc_ctl_info
@@ -189,6 +189,9 @@ static void del_edac_pci_from_global_list(struct edac_pci_ctl_info *pci)
         wait_for_completion(&pci->complete);
 }
 
+#if 0
+/* Older code, but might use in the future */
+
 /*
  * edac_pci_find()
  *      Search for an edac_pci_ctl_info structure whose index is 'idx'
@@ -219,6 +222,7 @@ struct edac_pci_ctl_info *edac_pci_find(int idx)
         return NULL;
 }
 EXPORT_SYMBOL_GPL(edac_pci_find);
+#endif
 
 /*
  * edac_pci_workq_function()
@@ -422,7 +426,7 @@ EXPORT_SYMBOL_GPL(edac_pci_del_device);
  *
  *      a Generic parity check API
  */
-void edac_pci_generic_check(struct edac_pci_ctl_info *pci)
+static void edac_pci_generic_check(struct edac_pci_ctl_info *pci)
 {
         debugf4("%s()\n", __func__);
         edac_pci_do_parity_check();
diff --git a/drivers/edac/edac_pci_sysfs.c b/drivers/edac/edac_pci_sysfs.c
index 71c3195d3704..2c1fa1bb6df2 100644
--- a/drivers/edac/edac_pci_sysfs.c
+++ b/drivers/edac/edac_pci_sysfs.c
@@ -37,17 +37,17 @@ int edac_pci_get_check_errors(void)
         return check_pci_errors;
 }
 
-int edac_pci_get_log_pe(void)
+static int edac_pci_get_log_pe(void)
 {
         return edac_pci_log_pe;
 }
 
-int edac_pci_get_log_npe(void)
+static int edac_pci_get_log_npe(void)
 {
         return edac_pci_log_npe;
 }
 
-int edac_pci_get_panic_on_pe(void)
+static int edac_pci_get_panic_on_pe(void)
 {
         return edac_pci_panic_on_pe;
 }
@@ -197,7 +197,8 @@ error_out:
  *
  *      unregister the kobj for the EDAC PCI instance
  */
-void edac_pci_unregister_sysfs_instance_kobj(struct edac_pci_ctl_info *pci)
+static void edac_pci_unregister_sysfs_instance_kobj(
+                        struct edac_pci_ctl_info *pci)
 {
         debugf0("%s()\n", __func__);
 
@@ -337,7 +338,7 @@ static struct kobj_type ktype_edac_pci_main_kobj = {
  *      setup the sysfs for EDAC PCI attributes
  *      assumes edac_class has already been initialized
  */
-int edac_pci_main_kobj_setup(void)
+static int edac_pci_main_kobj_setup(void)
 {
         int err;
         struct sysdev_class *edac_class;
diff --git a/drivers/edac/i3000_edac.c b/drivers/edac/i3000_edac.c
index 5d4292811c14..6c9a0f2a593c 100644
--- a/drivers/edac/i3000_edac.c
+++ b/drivers/edac/i3000_edac.c
@@ -326,15 +326,6 @@ static int i3000_probe1(struct pci_dev *pdev, int dev_idx)
                 return -ENODEV;
         }
 
-        switch (edac_op_state) {
-        case EDAC_OPSTATE_POLL:
-        case EDAC_OPSTATE_NMI:
-                break;
-        default:
-                edac_op_state = EDAC_OPSTATE_POLL;
-                break;
-        }
-
         c0dra[0] = readb(window + I3000_C0DRA + 0);     /* ranks 0,1 */
         c0dra[1] = readb(window + I3000_C0DRA + 1);     /* ranks 2,3 */
         c1dra[0] = readb(window + I3000_C1DRA + 0);     /* ranks 0,1 */
@@ -503,6 +494,10 @@ static int __init i3000_init(void)
         int pci_rc;
 
         debugf3("MC: %s()\n", __func__);
+
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         pci_rc = pci_register_driver(&i3000_driver);
         if (pci_rc < 0)
                 goto fail0;
diff --git a/drivers/edac/i5000_edac.c b/drivers/edac/i5000_edac.c
index 5a852017c17a..4a16b5b61cfb 100644
--- a/drivers/edac/i5000_edac.c
+++ b/drivers/edac/i5000_edac.c
@@ -1286,16 +1286,6 @@ static int i5000_probe1(struct pci_dev *pdev, int dev_idx)
         if (PCI_FUNC(pdev->devfn) != 0)
                 return -ENODEV;
 
-        /* make sure error reporting method is sane */
-        switch (edac_op_state) {
-        case EDAC_OPSTATE_POLL:
-        case EDAC_OPSTATE_NMI:
-                break;
-        default:
-                edac_op_state = EDAC_OPSTATE_POLL;
-                break;
-        }
-
         /* Ask the devices for the number of CSROWS and CHANNELS so
          * that we can calculate the memory resources, etc
          *
@@ -1478,6 +1468,9 @@ static int __init i5000_init(void)
 
         debugf2("MC: " __FILE__ ": %s()\n", __func__);
 
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         pci_rc = pci_register_driver(&i5000_driver);
 
         return (pci_rc < 0) ? pci_rc : 0;
@@ -1501,5 +1494,6 @@ MODULE_AUTHOR
     ("Linux Networx (http://lnxi.com) Doug Thompson <norsk5@xmission.com>");
 MODULE_DESCRIPTION("MC Driver for Intel I5000 memory controllers - "
                 I5000_REVISION);
+
 module_param(edac_op_state, int, 0444);
 MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
diff --git a/drivers/edac/i82443bxgx_edac.c b/drivers/edac/i82443bxgx_edac.c
index 83bfe37c4bbb..c5305e3ee434 100644
--- a/drivers/edac/i82443bxgx_edac.c
+++ b/drivers/edac/i82443bxgx_edac.c
@@ -29,6 +29,7 @@
 
 #include <linux/slab.h>
 
+#include <linux/edac.h>
 #include "edac_core.h"
 
 #define I82443_REVISION "0.1"
@@ -386,6 +387,9 @@ static struct pci_driver i82443bxgx_edacmc_driver = {
 
 static int __init i82443bxgx_edacmc_init(void)
 {
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         return pci_register_driver(&i82443bxgx_edacmc_driver);
 }
 
@@ -400,3 +404,6 @@ module_exit(i82443bxgx_edacmc_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Tim Small <tim@buttersideup.com> - WPAD");
 MODULE_DESCRIPTION("EDAC MC support for Intel 82443BX/GX memory controllers");
+
+module_param(edac_op_state, int, 0444);
+MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
diff --git a/drivers/edac/i82860_edac.c b/drivers/edac/i82860_edac.c
index f5ecd2c4d813..c0088ba9672b 100644
--- a/drivers/edac/i82860_edac.c
+++ b/drivers/edac/i82860_edac.c
@@ -14,6 +14,7 @@
 #include <linux/pci.h>
 #include <linux/pci_ids.h>
 #include <linux/slab.h>
+#include <linux/edac.h>
 #include "edac_core.h"
 
 #define  I82860_REVISION " Ver: 2.0.2 " __DATE__
@@ -294,6 +295,9 @@ static int __init i82860_init(void)
 
         debugf3("%s()\n", __func__);
 
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         if ((pci_rc = pci_register_driver(&i82860_driver)) < 0)
                 goto fail0;
 
@@ -345,3 +349,6 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com) "
                 "Ben Woodard <woodard@redhat.com>");
 MODULE_DESCRIPTION("ECC support for Intel 82860 memory hub controllers");
+
+module_param(edac_op_state, int, 0444);
+MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
diff --git a/drivers/edac/i82875p_edac.c b/drivers/edac/i82875p_edac.c
index 031abadc439a..e43bdc43a1bf 100644
--- a/drivers/edac/i82875p_edac.c
+++ b/drivers/edac/i82875p_edac.c
@@ -18,6 +18,7 @@
 #include <linux/pci.h>
 #include <linux/pci_ids.h>
 #include <linux/slab.h>
+#include <linux/edac.h>
 #include "edac_core.h"
 
 #define I82875P_REVISION        " Ver: 2.0.2 " __DATE__
@@ -393,6 +394,7 @@ static int i82875p_probe1(struct pci_dev *pdev, int dev_idx)
         struct i82875p_error_info discard;
 
         debugf0("%s()\n", __func__);
+
         ovrfl_pdev = pci_get_device(PCI_VEND_DEV(INTEL, 82875_6), NULL);
 
         if (i82875p_setup_overfl_dev(pdev, &ovrfl_pdev, &ovrfl_window))
@@ -532,6 +534,10 @@ static int __init i82875p_init(void)
         int pci_rc;
 
         debugf3("%s()\n", __func__);
+
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         pci_rc = pci_register_driver(&i82875p_driver);
 
         if (pci_rc < 0)
@@ -586,3 +592,6 @@ module_exit(i82875p_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Linux Networx (http://lnxi.com) Thayne Harbaugh");
 MODULE_DESCRIPTION("MC support for Intel 82875 memory hub controllers");
+
+module_param(edac_op_state, int, 0444);
+MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
diff --git a/drivers/edac/i82975x_edac.c b/drivers/edac/i82975x_edac.c
index 0ee888456932..2eed3ea2cf62 100644
--- a/drivers/edac/i82975x_edac.c
+++ b/drivers/edac/i82975x_edac.c
@@ -14,7 +14,7 @@
 #include <linux/pci.h>
 #include <linux/pci_ids.h>
 #include <linux/slab.h>
-
+#include <linux/edac.h>
 #include "edac_core.h"
 
 #define I82975X_REVISION        " Ver: 1.0.0 " __DATE__
@@ -611,6 +611,9 @@ static int __init i82975x_init(void)
 
         debugf3("%s()\n", __func__);
 
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         pci_rc = pci_register_driver(&i82975x_driver);
         if (pci_rc < 0)
                 goto fail0;
@@ -664,3 +667,6 @@ module_exit(i82975x_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Arvind R. <arvind@acarlab.com>");
 MODULE_DESCRIPTION("MC support for Intel 82975 memory hub controllers");
+
+module_param(edac_op_state, int, 0444);
+MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
diff --git a/drivers/edac/pasemi_edac.c b/drivers/edac/pasemi_edac.c
index 90320917be28..3fd65a563848 100644
--- a/drivers/edac/pasemi_edac.c
+++ b/drivers/edac/pasemi_edac.c
@@ -284,6 +284,9 @@ static struct pci_driver pasemi_edac_driver = {
 
 static int __init pasemi_edac_init(void)
 {
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         return pci_register_driver(&pasemi_edac_driver);
 }
 
@@ -298,3 +301,6 @@ module_exit(pasemi_edac_exit);
 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Egor Martovetsky <egor@pasemi.com>");
 MODULE_DESCRIPTION("MC support for PA Semi PWRficient memory controller");
+module_param(edac_op_state, int, 0444);
+MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
+
diff --git a/drivers/edac/r82600_edac.c b/drivers/edac/r82600_edac.c
index e25f712f2dc3..9900675e9598 100644
--- a/drivers/edac/r82600_edac.c
+++ b/drivers/edac/r82600_edac.c
@@ -20,6 +20,7 @@
 #include <linux/pci.h>
 #include <linux/pci_ids.h>
 #include <linux/slab.h>
+#include <linux/edac.h>
 #include "edac_core.h"
 
 #define R82600_REVISION " Ver: 2.0.2 " __DATE__
@@ -393,6 +394,9 @@ static struct pci_driver r82600_driver = {
 
 static int __init r82600_init(void)
 {
+       /* Ensure that the OPSTATE is set correctly for POLL or NMI */
+       opstate_init();
+
         return pci_register_driver(&r82600_driver);
 }
 
@@ -412,3 +416,6 @@ MODULE_DESCRIPTION("MC support for Radisys 82600 memory controllers");
 module_param(disable_hardware_scrub, bool, 0644);
 MODULE_PARM_DESC(disable_hardware_scrub,
                  "If set, disable the chipset's automatic scrub for CEs");
+
+module_param(edac_op_state, int, 0444);
+MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 40ffd767647d..dc2cec6127d1 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -17,6 +17,15 @@ config EDD
           obscure configurations. Most disk controller BIOS vendors do
           not yet implement this feature.
 
+config EDD_OFF
+        bool "Sets default behavior for EDD detection to off"
+        depends on EDD
+        default n
+        help
+          Say Y if you want EDD disabled by default, even though it is compiled into the
+          kernel. Say N if you want EDD enabled by default. EDD can be dynamically set
+          using the kernel parameter 'edd={on|skipmbr|off}'.
+
 config EFI_VARS
         tristate "EFI Variable Support via sysfs"
         depends on EFI
diff --git a/drivers/firmware/dcdbas.c b/drivers/firmware/dcdbas.c
index f235940719e7..25918f7dfd0f 100644
--- a/drivers/firmware/dcdbas.c
+++ b/drivers/firmware/dcdbas.c
@@ -63,7 +63,7 @@ static void smi_data_buf_free(void)
                 return;
 
         dev_dbg(&dcdbas_pdev->dev, "%s: phys: %x size: %lu\n",
-                __FUNCTION__, smi_data_buf_phys_addr, smi_data_buf_size);
+                __func__, smi_data_buf_phys_addr, smi_data_buf_size);
 
         dma_free_coherent(&dcdbas_pdev->dev, smi_data_buf_size, smi_data_buf,
                           smi_data_buf_handle);
@@ -92,7 +92,7 @@ static int smi_data_buf_realloc(unsigned long size)
         if (!buf) {
                 dev_dbg(&dcdbas_pdev->dev,
                         "%s: failed to allocate memory size %lu\n",
-                        __FUNCTION__, size);
+                        __func__, size);
                 return -ENOMEM;
         }
         /* memory zeroed by dma_alloc_coherent */
@@ -110,7 +110,7 @@ static int smi_data_buf_realloc(unsigned long size)
         smi_data_buf_size = size;
 
         dev_dbg(&dcdbas_pdev->dev, "%s: phys: %x size: %lu\n",
-                __FUNCTION__, smi_data_buf_phys_addr, smi_data_buf_size);
+                __func__, smi_data_buf_phys_addr, smi_data_buf_size);
 
         return 0;
 }
@@ -258,7 +258,7 @@ static int smi_request(struct smi_cmd *smi_cmd)
 
         if (smi_cmd->magic != SMI_CMD_MAGIC) {
                 dev_info(&dcdbas_pdev->dev, "%s: invalid magic value\n",
-                         __FUNCTION__);
+                         __func__);
                 return -EBADR;
         }
 
@@ -267,7 +267,7 @@ static int smi_request(struct smi_cmd *smi_cmd)
         set_cpus_allowed_ptr(current, &cpumask_of_cpu(0));
         if (smp_processor_id() != 0) {
                 dev_dbg(&dcdbas_pdev->dev, "%s: failed to get CPU 0\n",
-                        __FUNCTION__);
+                        __func__);
                 ret = -EBUSY;
                 goto out;
         }
@@ -428,7 +428,7 @@ static int host_control_smi(void)
 
         default:
                 dev_dbg(&dcdbas_pdev->dev, "%s: invalid SMI type %u\n",
-                        __FUNCTION__, host_control_smi_type);
+                        __func__, host_control_smi_type);
                 return -ENOSYS;
         }
 
@@ -456,13 +456,13 @@ static void dcdbas_host_control(void)
         host_control_action = HC_ACTION_NONE;
 
         if (!smi_data_buf) {
-                dev_dbg(&dcdbas_pdev->dev, "%s: no SMI buffer\n", __FUNCTION__);
+                dev_dbg(&dcdbas_pdev->dev, "%s: no SMI buffer\n", __func__);
                 return;
         }
 
         if (smi_data_buf_size < sizeof(struct apm_cmd)) {
                 dev_dbg(&dcdbas_pdev->dev, "%s: SMI buffer too small\n",
-                        __FUNCTION__);
+                        __func__);
                 return;
         }
 
diff --git a/drivers/firmware/dell_rbu.c b/drivers/firmware/dell_rbu.c
index 477a3d0e3caf..6a8b1e037e07 100644
--- a/drivers/firmware/dell_rbu.c
+++ b/drivers/firmware/dell_rbu.c
@@ -123,7 +123,7 @@ static int create_packet(void *data, size_t length)
         if (!newpacket) {
                 printk(KERN_WARNING
                         "dell_rbu:%s: failed to allocate new "
-                        "packet\n", __FUNCTION__);
+                        "packet\n", __func__);
                 retval = -ENOMEM;
                 spin_lock(&rbu_data.lock);
                 goto out_noalloc;
@@ -152,7 +152,7 @@ static int create_packet(void *data, size_t length)
                 printk(KERN_WARNING
                         "dell_rbu:%s: failed to allocate "
                         "invalid_addr_packet_array \n",
-                        __FUNCTION__);
+                        __func__);
                 retval = -ENOMEM;
                 spin_lock(&rbu_data.lock);
                 goto out_alloc_packet;
@@ -164,7 +164,7 @@ static int create_packet(void *data, size_t length)
                 if (!packet_data_temp_buf) {
                         printk(KERN_WARNING
                                 "dell_rbu:%s: failed to allocate new "
-                                "packet\n", __FUNCTION__);
+                                "packet\n", __func__);
                         retval = -ENOMEM;
                         spin_lock(&rbu_data.lock);
                         goto out_alloc_packet_array;
@@ -416,7 +416,7 @@ static int img_update_realloc(unsigned long size)
                  */
                 if ((size != 0) && (rbu_data.image_update_buffer == NULL)) {
                         printk(KERN_ERR "dell_rbu:%s: corruption "
-                                "check failed\n", __FUNCTION__);
+                                "check failed\n", __func__);
                         return -EINVAL;
                 }
                 /*
@@ -642,7 +642,7 @@ static ssize_t write_rbu_image_type(struct kobject *kobj,
                         if (req_firm_rc) {
                                 printk(KERN_ERR
                                         "dell_rbu:%s request_firmware_nowait"
-                                        " failed %d\n", __FUNCTION__, rc);
+                                        " failed %d\n", __func__, rc);
                                 rc = -EIO;
                         } else
                                 rbu_data.entry_created = 1;
@@ -718,7 +718,7 @@ static int __init dcdrbu_init(void)
         if (IS_ERR(rbu_device)) {
                 printk(KERN_ERR
                         "dell_rbu:%s:platform_device_register_simple "
-                        "failed\n", __FUNCTION__);
+                        "failed\n", __func__);
                 return PTR_ERR(rbu_device);
         }
 
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index e03c67dd3e63..f43d6d3cf2fa 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -606,7 +606,7 @@ static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
                 case 2:
                         if ((end - start) < 2)
                                 return NULL;
-                        item->data.u16 = le16_to_cpu(get_unaligned((__le16*)start));
+                        item->data.u16 = get_unaligned_le16(start);
                         start = (__u8 *)((__le16 *)start + 1);
                         return start;
 
@@ -614,7 +614,7 @@ static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
                         item->size++;
                         if ((end - start) < 4)
                                 return NULL;
-                        item->data.u32 = le32_to_cpu(get_unaligned((__le32*)start));
+                        item->data.u32 = get_unaligned_le32(start);
                         start = (__u8 *)((__le32 *)start + 1);
                         return start;
         }
@@ -765,7 +765,7 @@ static __inline__ __u32 extract(__u8 *report, unsigned offset, unsigned n)
 
         report += offset >> 3;  /* adjust byte index */
         offset &= 7;            /* now only need bit offset into one byte */
-        x = le64_to_cpu(get_unaligned((__le64 *) report));
+        x = get_unaligned_le64(report);
         x = (x >> offset) & ((1ULL << n) - 1);  /* extract bit field */
         return (u32) x;
 }
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c
index 7b2f3815a838..8d6ad812a014 100644
--- a/drivers/ide/ide-proc.c
+++ b/drivers/ide/ide-proc.c
@@ -822,6 +822,7 @@ static int ide_drivers_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations ide_drivers_operations = {
+        .owner          = THIS_MODULE,
         .open           = ide_drivers_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -830,16 +831,12 @@ static const struct file_operations ide_drivers_operations = {
 
 void proc_ide_create(void)
 {
-        struct proc_dir_entry *entry;
-
         proc_ide_root = proc_mkdir("ide", NULL);
 
         if (!proc_ide_root)
                 return;
 
-        entry = create_proc_entry("drivers", 0, proc_ide_root);
-        if (entry)
-                entry->proc_fops = &ide_drivers_operations;
+        proc_create("drivers", 0, proc_ide_root, &ide_drivers_operations);
 }
 
 void proc_ide_destroy(void)
diff --git a/drivers/infiniband/core/umem.c b/drivers/infiniband/core/umem.c
index 4e3128ff73c1..fe78f7d25099 100644
--- a/drivers/infiniband/core/umem.c
+++ b/drivers/infiniband/core/umem.c
@@ -38,6 +38,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/sched.h>
 #include <linux/hugetlb.h>
+#include <linux/dma-attrs.h>
 
 #include "uverbs.h"
 
@@ -72,9 +73,10 @@ static void __ib_umem_release(struct ib_device *dev, struct ib_umem *umem, int d
  * @addr: userspace virtual address to start at
  * @size: length of region to pin
  * @access: IB_ACCESS_xxx flags for memory being pinned
+ * @dmasync: flush in-flight DMA when the memory region is written
  */
 struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr,
-                            size_t size, int access)
+                            size_t size, int access, int dmasync)
 {
         struct ib_umem *umem;
         struct page **page_list;
@@ -87,6 +89,10 @@ struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr,
         int ret;
         int off;
         int i;
+        DEFINE_DMA_ATTRS(attrs);
+
+        if (dmasync)
+                dma_set_attr(DMA_ATTR_WRITE_BARRIER, &attrs);
 
         if (!can_do_mlock())
                 return ERR_PTR(-EPERM);
@@ -174,10 +180,11 @@ struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr,
                                 sg_set_page(&chunk->page_list[i], page_list[i + off], PAGE_SIZE, 0);
                         }
 
-                        chunk->nmap = ib_dma_map_sg(context->device,
-                                                    &chunk->page_list[0],
-                                                    chunk->nents,
-                                                    DMA_BIDIRECTIONAL);
+                        chunk->nmap = ib_dma_map_sg_attrs(context->device,
+                                                          &chunk->page_list[0],
+                                                          chunk->nents,
+                                                          DMA_BIDIRECTIONAL,
+                                                          &attrs);
                         if (chunk->nmap <= 0) {
                                 for (i = 0; i < chunk->nents; ++i)
                                         put_page(sg_page(&chunk->page_list[i]));
diff --git a/drivers/infiniband/hw/amso1100/c2_provider.c b/drivers/infiniband/hw/amso1100/c2_provider.c
index 6af2c0f79a67..2acf9b62cf99 100644
--- a/drivers/infiniband/hw/amso1100/c2_provider.c
+++ b/drivers/infiniband/hw/amso1100/c2_provider.c
@@ -452,7 +452,7 @@ static struct ib_mr *c2_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
                 return ERR_PTR(-ENOMEM);
         c2mr->pd = c2pd;
 
-        c2mr->umem = ib_umem_get(pd->uobject->context, start, length, acc);
+        c2mr->umem = ib_umem_get(pd->uobject->context, start, length, acc, 0);
         if (IS_ERR(c2mr->umem)) {
                 err = PTR_ERR(c2mr->umem);
                 kfree(c2mr);
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.c b/drivers/infiniband/hw/cxgb3/iwch_provider.c
index ab4695c1dd56..e343e9e64844 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.c
@@ -602,7 +602,7 @@ static struct ib_mr *iwch_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         if (!mhp)
                 return ERR_PTR(-ENOMEM);
 
-        mhp->umem = ib_umem_get(pd->uobject->context, start, length, acc);
+        mhp->umem = ib_umem_get(pd->uobject->context, start, length, acc, 0);
         if (IS_ERR(mhp->umem)) {
                 err = PTR_ERR(mhp->umem);
                 kfree(mhp);
diff --git a/drivers/infiniband/hw/ehca/ehca_mrmw.c b/drivers/infiniband/hw/ehca/ehca_mrmw.c
index 46ae4eb2c4e1..f974367cad40 100644
--- a/drivers/infiniband/hw/ehca/ehca_mrmw.c
+++ b/drivers/infiniband/hw/ehca/ehca_mrmw.c
@@ -323,7 +323,7 @@ struct ib_mr *ehca_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         }
 
         e_mr->umem = ib_umem_get(pd->uobject->context, start, length,
-                                 mr_access_flags);
+                                 mr_access_flags, 0);
         if (IS_ERR(e_mr->umem)) {
                 ib_mr = (void *)e_mr->umem;
                 goto reg_user_mr_exit1;
diff --git a/drivers/infiniband/hw/ipath/ipath_mr.c b/drivers/infiniband/hw/ipath/ipath_mr.c
index db4ba92f79fc..9d343b7c2f3b 100644
--- a/drivers/infiniband/hw/ipath/ipath_mr.c
+++ b/drivers/infiniband/hw/ipath/ipath_mr.c
@@ -195,7 +195,8 @@ struct ib_mr *ipath_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
                 goto bail;
         }
 
-        umem = ib_umem_get(pd->uobject->context, start, length, mr_access_flags);
+        umem = ib_umem_get(pd->uobject->context, start, length,
+                           mr_access_flags, 0);
         if (IS_ERR(umem))
                 return (void *) umem;
 
diff --git a/drivers/infiniband/hw/mlx4/cq.c b/drivers/infiniband/hw/mlx4/cq.c
index 5e570bb0bb6f..e3dddfc687f9 100644
--- a/drivers/infiniband/hw/mlx4/cq.c
+++ b/drivers/infiniband/hw/mlx4/cq.c
@@ -137,7 +137,7 @@ static int mlx4_ib_get_cq_umem(struct mlx4_ib_dev *dev, struct ib_ucontext *cont
         int err;
 
         *umem = ib_umem_get(context, buf_addr, cqe * sizeof (struct mlx4_cqe),
-                            IB_ACCESS_LOCAL_WRITE);
+                            IB_ACCESS_LOCAL_WRITE, 1);
         if (IS_ERR(*umem))
                 return PTR_ERR(*umem);
 
diff --git a/drivers/infiniband/hw/mlx4/doorbell.c b/drivers/infiniband/hw/mlx4/doorbell.c
index 8e342cc9baec..8aee4233b388 100644
--- a/drivers/infiniband/hw/mlx4/doorbell.c
+++ b/drivers/infiniband/hw/mlx4/doorbell.c
@@ -63,7 +63,7 @@ int mlx4_ib_db_map_user(struct mlx4_ib_ucontext *context, unsigned long virt,
         page->user_virt = (virt & PAGE_MASK);
         page->refcnt    = 0;
         page->umem      = ib_umem_get(&context->ibucontext, virt & PAGE_MASK,
-                                      PAGE_SIZE, 0);
+                                      PAGE_SIZE, 0, 0);
         if (IS_ERR(page->umem)) {
                 err = PTR_ERR(page->umem);
                 kfree(page);
diff --git a/drivers/infiniband/hw/mlx4/mr.c b/drivers/infiniband/hw/mlx4/mr.c
index fe2c2e94a5f8..68e92485fc76 100644
--- a/drivers/infiniband/hw/mlx4/mr.c
+++ b/drivers/infiniband/hw/mlx4/mr.c
@@ -132,7 +132,8 @@ struct ib_mr *mlx4_ib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         if (!mr)
                 return ERR_PTR(-ENOMEM);
 
-        mr->umem = ib_umem_get(pd->uobject->context, start, length, access_flags);
+        mr->umem = ib_umem_get(pd->uobject->context, start, length,
+                               access_flags, 0);
         if (IS_ERR(mr->umem)) {
                 err = PTR_ERR(mr->umem);
                 goto err_free;
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index 80ea8b9e7761..8e02ecfec188 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -482,7 +482,7 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
                         goto err;
 
                 qp->umem = ib_umem_get(pd->uobject->context, ucmd.buf_addr,
-                                       qp->buf_size, 0);
+                                       qp->buf_size, 0, 0);
                 if (IS_ERR(qp->umem)) {
                         err = PTR_ERR(qp->umem);
                         goto err;
diff --git a/drivers/infiniband/hw/mlx4/srq.c b/drivers/infiniband/hw/mlx4/srq.c
index 204619702f9d..12d6bc6f8007 100644
--- a/drivers/infiniband/hw/mlx4/srq.c
+++ b/drivers/infiniband/hw/mlx4/srq.c
@@ -109,7 +109,7 @@ struct ib_srq *mlx4_ib_create_srq(struct ib_pd *pd,
                 }
 
                 srq->umem = ib_umem_get(pd->uobject->context, ucmd.buf_addr,
-                                        buf_size, 0);
+                                        buf_size, 0, 0);
                 if (IS_ERR(srq->umem)) {
                         err = PTR_ERR(srq->umem);
                         goto err_srq;
diff --git a/drivers/infiniband/hw/mthca/mthca_provider.c b/drivers/infiniband/hw/mthca/mthca_provider.c
index 696e1f302332..2a9f460cf061 100644
--- a/drivers/infiniband/hw/mthca/mthca_provider.c
+++ b/drivers/infiniband/hw/mthca/mthca_provider.c
@@ -1006,17 +1006,23 @@ static struct ib_mr *mthca_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         struct mthca_dev *dev = to_mdev(pd->device);
         struct ib_umem_chunk *chunk;
         struct mthca_mr *mr;
+        struct mthca_reg_mr ucmd;
         u64 *pages;
         int shift, n, len;
         int i, j, k;
         int err = 0;
         int write_mtt_size;
 
+        if (ib_copy_from_udata(&ucmd, udata, sizeof ucmd))
+                return ERR_PTR(-EFAULT);
+
         mr = kmalloc(sizeof *mr, GFP_KERNEL);
         if (!mr)
                 return ERR_PTR(-ENOMEM);
 
-        mr->umem = ib_umem_get(pd->uobject->context, start, length, acc);
+        mr->umem = ib_umem_get(pd->uobject->context, start, length, acc,
+                               ucmd.mr_attrs & MTHCA_MR_DMASYNC);
+
         if (IS_ERR(mr->umem)) {
                 err = PTR_ERR(mr->umem);
                 goto err;
diff --git a/drivers/infiniband/hw/mthca/mthca_user.h b/drivers/infiniband/hw/mthca/mthca_user.h
index 02cc0a766f3a..f8cb3b664d37 100644
--- a/drivers/infiniband/hw/mthca/mthca_user.h
+++ b/drivers/infiniband/hw/mthca/mthca_user.h
@@ -41,7 +41,7 @@
  * Increment this value if any changes that break userspace ABI
  * compatibility are made.
  */
-#define MTHCA_UVERBS_ABI_VERSION        1
+#define MTHCA_UVERBS_ABI_VERSION        2
 
 /*
  * Make sure that all structs defined in this file remain laid out so
@@ -61,6 +61,14 @@ struct mthca_alloc_pd_resp {
         __u32 reserved;
 };
 
+struct mthca_reg_mr {
+        __u32 mr_attrs;
+#define MTHCA_MR_DMASYNC 0x1
+/* mark the memory region with a DMA attribute that causes
+ * in-flight DMA to be flushed when the region is written to */
+        __u32 reserved;
+};
+
 struct mthca_create_cq {
         __u32 lkey;
         __u32 pdn;
diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c
index ee74f7c7a6da..9ae397a0ff7e 100644
--- a/drivers/infiniband/hw/nes/nes_verbs.c
+++ b/drivers/infiniband/hw/nes/nes_verbs.c
@@ -2377,7 +2377,7 @@ static struct ib_mr *nes_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         u8 single_page = 1;
         u8 stag_key;
 
-        region = ib_umem_get(pd->uobject->context, start, length, acc);
+        region = ib_umem_get(pd->uobject->context, start, length, acc, 0);
         if (IS_ERR(region)) {
                 return (struct ib_mr *)region;
         }
diff --git a/drivers/input/input.c b/drivers/input/input.c
index f02c242c3114..27006fc18305 100644
--- a/drivers/input/input.c
+++ b/drivers/input/input.c
@@ -898,30 +898,26 @@ static int __init input_proc_init(void)
 {
         struct proc_dir_entry *entry;
 
-        proc_bus_input_dir = proc_mkdir("input", proc_bus);
+        proc_bus_input_dir = proc_mkdir("bus/input", NULL);
         if (!proc_bus_input_dir)
                 return -ENOMEM;
 
         proc_bus_input_dir->owner = THIS_MODULE;
 
-        entry = create_proc_entry("devices", 0, proc_bus_input_dir);
+        entry = proc_create("devices", 0, proc_bus_input_dir,
+                            &input_devices_fileops);
         if (!entry)
                 goto fail1;
 
-        entry->owner = THIS_MODULE;
-        entry->proc_fops = &input_devices_fileops;
-
-        entry = create_proc_entry("handlers", 0, proc_bus_input_dir);
+        entry = proc_create("handlers", 0, proc_bus_input_dir,
+                            &input_handlers_fileops);
         if (!entry)
                 goto fail2;
 
-        entry->owner = THIS_MODULE;
-        entry->proc_fops = &input_handlers_fileops;
-
         return 0;
 
  fail2: remove_proc_entry("devices", proc_bus_input_dir);
- fail1: remove_proc_entry("input", proc_bus);
+ fail1: remove_proc_entry("bus/input", NULL);
         return -ENOMEM;
 }
 
@@ -929,7 +925,7 @@ static void input_proc_exit(void)
 {
         remove_proc_entry("devices", proc_bus_input_dir);
         remove_proc_entry("handlers", proc_bus_input_dir);
-        remove_proc_entry("input", proc_bus);
+        remove_proc_entry("bus/input", NULL);
 }
 
 #else /* !CONFIG_PROC_FS */
diff --git a/drivers/input/tablet/aiptek.c b/drivers/input/tablet/aiptek.c
index 1d759f6f8076..55c1134d6137 100644
--- a/drivers/input/tablet/aiptek.c
+++ b/drivers/input/tablet/aiptek.c
@@ -528,9 +528,9 @@ static void aiptek_irq(struct urb *urb)
                             (aiptek->curSetting.pointerMode)) {
                                 aiptek->diagnostic = AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED;
                 } else {
-                        x = le16_to_cpu(get_unaligned((__le16 *) (data + 1)));
-                        y = le16_to_cpu(get_unaligned((__le16 *) (data + 3)));
-                        z = le16_to_cpu(get_unaligned((__le16 *) (data + 6)));
+                        x = get_unaligned_le16(data + 1);
+                        y = get_unaligned_le16(data + 3);
+                        z = get_unaligned_le16(data + 6);
 
                         dv = (data[5] & 0x01) != 0 ? 1 : 0;
                         p = (data[5] & 0x02) != 0 ? 1 : 0;
@@ -613,8 +613,8 @@ static void aiptek_irq(struct urb *urb)
                         (aiptek->curSetting.pointerMode)) {
                         aiptek->diagnostic = AIPTEK_DIAGNOSTIC_TOOL_DISALLOWED;
                 } else {
-                        x = le16_to_cpu(get_unaligned((__le16 *) (data + 1)));
-                        y = le16_to_cpu(get_unaligned((__le16 *) (data + 3)));
+                        x = get_unaligned_le16(data + 1);
+                        y = get_unaligned_le16(data + 3);
 
                         jitterable = data[5] & 0x1c;
 
@@ -679,7 +679,7 @@ static void aiptek_irq(struct urb *urb)
                 pck = (data[1] & aiptek->curSetting.stylusButtonUpper) != 0 ? 1 : 0;
 
                 macro = dv && p && tip && !(data[3] & 1) ? (data[3] >> 1) : -1;
-                z = le16_to_cpu(get_unaligned((__le16 *) (data + 4)));
+                z = get_unaligned_le16(data + 4);
 
                 if (dv) {
                         /* If the selected tool changed, reset the old
@@ -757,7 +757,7 @@ static void aiptek_irq(struct urb *urb)
          * hat switches (which just so happen to be the macroKeys.)
          */
         else if (data[0] == 6) {
-                macro = le16_to_cpu(get_unaligned((__le16 *) (data + 1)));
+                macro = get_unaligned_le16(data + 1);
                 if (macro > 0) {
                         input_report_key(inputdev, macroKeyEvents[macro - 1],
                                          0);
@@ -952,7 +952,7 @@ aiptek_query(struct aiptek *aiptek, unsigned char command, unsigned char data)
                     buf[0], buf[1], buf[2]);
                 ret = -EIO;
         } else {
-                ret = le16_to_cpu(get_unaligned((__le16 *) (buf + 1)));
+                ret = get_unaligned_le16(buf + 1);
         }
         kfree(buf);
         return ret;
diff --git a/drivers/input/tablet/gtco.c b/drivers/input/tablet/gtco.c
index f66ca215cdec..c5a8661a1baa 100644
--- a/drivers/input/tablet/gtco.c
+++ b/drivers/input/tablet/gtco.c
@@ -245,11 +245,11 @@ static void parse_hid_report_descriptor(struct gtco *device, char * report,
                         data = report[i];
                         break;
                 case 2:
-                        data16 = le16_to_cpu(get_unaligned((__le16 *)&report[i]));
+                        data16 = get_unaligned_le16(&report[i]);
                         break;
                 case 3:
                         size = 4;
-                        data32 = le32_to_cpu(get_unaligned((__le32 *)&report[i]));
+                        data32 = get_unaligned_le32(&report[i]);
                         break;
                 }
 
@@ -695,10 +695,10 @@ static void gtco_urb_callback(struct urb *urbinfo)
                         /*  Fall thru */
                 case 1:
                         /* All reports have X and Y coords in the same place */
-                        val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[1]));
+                        val = get_unaligned_le16(&device->buffer[1]);
                         input_report_abs(inputdev, ABS_X, val);
 
-                        val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[3]));
+                        val = get_unaligned_le16(&device->buffer[3]);
                         input_report_abs(inputdev, ABS_Y, val);
 
                         /* Ditto for proximity bit */
@@ -762,7 +762,7 @@ static void gtco_urb_callback(struct urb *urbinfo)
                                 le_buffer[1]  = (u8)(device->buffer[4] >> 1);
                                 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
 
-                                val = le16_to_cpu(get_unaligned((__le16 *)le_buffer));
+                                val = get_unaligned_le16(le_buffer);
                                 input_report_abs(inputdev, ABS_Y, val);
 
                                 /*
@@ -772,10 +772,10 @@ static void gtco_urb_callback(struct urb *urbinfo)
                                 buttonbyte = device->buffer[5] >> 1;
                         } else {
 
-                                val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[1]));
+                                val = get_unaligned_le16(&device->buffer[1]);
                                 input_report_abs(inputdev, ABS_X, val);
 
-                                val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[3]));
+                                val = get_unaligned_le16(&device->buffer[3]);
                                 input_report_abs(inputdev, ABS_Y, val);
 
                                 buttonbyte = device->buffer[5];
diff --git a/drivers/input/tablet/kbtab.c b/drivers/input/tablet/kbtab.c
index 1182fc133167..f23f5a97fb38 100644
--- a/drivers/input/tablet/kbtab.c
+++ b/drivers/input/tablet/kbtab.c
@@ -63,8 +63,8 @@ static void kbtab_irq(struct urb *urb)
                 goto exit;
         }
 
-        kbtab->x = le16_to_cpu(get_unaligned((__le16 *) &data[1]));
-        kbtab->y = le16_to_cpu(get_unaligned((__le16 *) &data[3]));
+        kbtab->x = get_unaligned_le16(&data[1]);
+        kbtab->y = get_unaligned_le16(&data[3]);
 
         kbtab->pressure = (data[5]);
 
diff --git a/drivers/isdn/capi/kcapi_proc.c b/drivers/isdn/capi/kcapi_proc.c
index 845a797b0030..c29208bd7521 100644
--- a/drivers/isdn/capi/kcapi_proc.c
+++ b/drivers/isdn/capi/kcapi_proc.c
@@ -114,6 +114,7 @@ static int seq_contrstats_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations proc_controller_ops = {
+        .owner          = THIS_MODULE,
         .open           = seq_controller_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -121,6 +122,7 @@ static const struct file_operations proc_controller_ops = {
 };
 
 static const struct file_operations proc_contrstats_ops = {
+        .owner          = THIS_MODULE,
         .open           = seq_contrstats_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -219,6 +221,7 @@ seq_applstats_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations proc_applications_ops = {
+        .owner          = THIS_MODULE,
         .open           = seq_applications_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -226,21 +229,13 @@ static const struct file_operations proc_applications_ops = {
 };
 
 static const struct file_operations proc_applstats_ops = {
+        .owner          = THIS_MODULE,
         .open           = seq_applstats_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
         .release        = seq_release,
 };
 
-static void
-create_seq_entry(char *name, mode_t mode, const struct file_operations *f)
-{
-        struct proc_dir_entry *entry;
-        entry = create_proc_entry(name, mode, NULL);
-        if (entry)
-                entry->proc_fops = f;
-}
-
 // ---------------------------------------------------------------------------
 
 static void *capi_driver_start(struct seq_file *seq, loff_t *pos)
@@ -283,6 +278,7 @@ seq_capi_driver_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations proc_driver_ops = {
+        .owner          = THIS_MODULE,
         .open           = seq_capi_driver_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -296,11 +292,11 @@ kcapi_proc_init(void)
 {
         proc_mkdir("capi",             NULL);
         proc_mkdir("capi/controllers", NULL);
-        create_seq_entry("capi/controller",   0, &proc_controller_ops);
-        create_seq_entry("capi/contrstats",   0, &proc_contrstats_ops);
-        create_seq_entry("capi/applications", 0, &proc_applications_ops);
-        create_seq_entry("capi/applstats",    0, &proc_applstats_ops);
-        create_seq_entry("capi/driver",       0, &proc_driver_ops);
+        proc_create("capi/controller",   0, NULL, &proc_controller_ops);
+        proc_create("capi/contrstats",   0, NULL, &proc_contrstats_ops);
+        proc_create("capi/applications", 0, NULL, &proc_applications_ops);
+        proc_create("capi/applstats",    0, NULL, &proc_applstats_ops);
+        proc_create("capi/driver",       0, NULL, &proc_driver_ops);
 }
 
 void __exit
diff --git a/drivers/isdn/divert/divert_procfs.c b/drivers/isdn/divert/divert_procfs.c
index 4fd4c46892e3..8b256a617c8a 100644
--- a/drivers/isdn/divert/divert_procfs.c
+++ b/drivers/isdn/divert/divert_procfs.c
@@ -288,13 +288,12 @@ divert_dev_init(void)
         isdn_proc_entry = proc_mkdir("isdn", init_net.proc_net);
         if (!isdn_proc_entry)
                 return (-1);
-        isdn_divert_entry = create_proc_entry("divert", S_IFREG | S_IRUGO, isdn_proc_entry);
+        isdn_divert_entry = proc_create("divert", S_IFREG | S_IRUGO,
+                                        isdn_proc_entry, &isdn_fops);
         if (!isdn_divert_entry) {
                 remove_proc_entry("isdn", init_net.proc_net);
                 return (-1);
         }
-        isdn_divert_entry->proc_fops = &isdn_fops; 
-        isdn_divert_entry->owner = THIS_MODULE; 
 #endif  /* CONFIG_PROC_FS */
 
         return (0);
diff --git a/drivers/isdn/hardware/eicon/divasproc.c b/drivers/isdn/hardware/eicon/divasproc.c
index 0632a2606998..fae895828a17 100644
--- a/drivers/isdn/hardware/eicon/divasproc.c
+++ b/drivers/isdn/hardware/eicon/divasproc.c
@@ -125,15 +125,11 @@ static const struct file_operations divas_fops = {
 
 int create_divas_proc(void)
 {
-        divas_proc_entry = create_proc_entry(divas_proc_name,
-                                             S_IFREG | S_IRUGO,
-                                             proc_net_eicon);
+        proc_create(divas_proc_name, S_IFREG | S_IRUGO, proc_net_eicon,
+                    &divas_fops);
         if (!divas_proc_entry)
                 return (0);
 
-        divas_proc_entry->proc_fops = &divas_fops;
-        divas_proc_entry->owner = THIS_MODULE;
-
         return (1);
 }
 
diff --git a/drivers/isdn/hysdn/hysdn_procconf.c b/drivers/isdn/hysdn/hysdn_procconf.c
index 27d890b48f88..877be9922c3d 100644
--- a/drivers/isdn/hysdn/hysdn_procconf.c
+++ b/drivers/isdn/hysdn/hysdn_procconf.c
@@ -370,6 +370,7 @@ hysdn_conf_close(struct inode *ino, struct file *filep)
 /******************************************************/
 static const struct file_operations conf_fops =
 {
+        .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .read           = hysdn_conf_read,
         .write          = hysdn_conf_write,
@@ -402,11 +403,9 @@ hysdn_procconf_init(void)
         while (card) {
 
                 sprintf(conf_name, "%s%d", PROC_CONF_BASENAME, card->myid);
-                if ((card->procconf = (void *) create_proc_entry(conf_name,
-                                             S_IFREG | S_IRUGO | S_IWUSR,
-                                            hysdn_proc_entry)) != NULL) {
-                        ((struct proc_dir_entry *) card->procconf)->proc_fops = &conf_fops;
-                        ((struct proc_dir_entry *) card->procconf)->owner = THIS_MODULE;
+                if ((card->procconf = (void *) proc_create(conf_name,
+                                                S_IFREG | S_IRUGO | S_IWUSR,
+                                                hysdn_proc_entry)) != NULL) {
                         hysdn_proclog_init(card);       /* init the log file entry */
                 }
                 card = card->next;      /* next entry */
diff --git a/drivers/isdn/hysdn/hysdn_proclog.c b/drivers/isdn/hysdn/hysdn_proclog.c
index 27b3991fb0ec..8991d2c8ee4a 100644
--- a/drivers/isdn/hysdn/hysdn_proclog.c
+++ b/drivers/isdn/hysdn/hysdn_proclog.c
@@ -380,6 +380,7 @@ hysdn_log_poll(struct file *file, poll_table * wait)
 /**************************************************/
 static const struct file_operations log_fops =
 {
+        .owner          = THIS_MODULE,
         .llseek         = no_llseek,
         .read           = hysdn_log_read,
         .write          = hysdn_log_write,
@@ -402,10 +403,9 @@ hysdn_proclog_init(hysdn_card * card)
 
         if ((pd = kzalloc(sizeof(struct procdata), GFP_KERNEL)) != NULL) {
                 sprintf(pd->log_name, "%s%d", PROC_LOG_BASENAME, card->myid);
-                if ((pd->log = create_proc_entry(pd->log_name, S_IFREG | S_IRUGO | S_IWUSR, hysdn_proc_entry)) != NULL) {
-                        pd->log->proc_fops = &log_fops; 
-                        pd->log->owner = THIS_MODULE;
-                }
+                pd->log = proc_create(pd->log_name,
+                                S_IFREG | S_IRUGO | S_IWUSR, hysdn_proc_entry,
+                                &log_fops);
 
                 init_waitqueue_head(&(pd->rd_queue));
 
diff --git a/drivers/leds/led-class.c b/drivers/leds/led-class.c
index ac05a928f764..b3c54be74556 100644
--- a/drivers/leds/led-class.c
+++ b/drivers/leds/led-class.c
@@ -105,7 +105,7 @@ int led_classdev_register(struct device *parent, struct led_classdev *led_cdev)
 
         led_cdev->dev = device_create(leds_class, parent, 0, "%s",
                                             led_cdev->name);
-        if (unlikely(IS_ERR(led_cdev->dev)))
+        if (IS_ERR(led_cdev->dev))
                 return PTR_ERR(led_cdev->dev);
 
         dev_set_drvdata(led_cdev->dev, led_cdev);
diff --git a/drivers/mca/mca-legacy.c b/drivers/mca/mca-legacy.c
index 0c7bfa74c8ef..494f0c2001f5 100644
--- a/drivers/mca/mca-legacy.c
+++ b/drivers/mca/mca-legacy.c
@@ -282,24 +282,6 @@ void mca_set_adapter_name(int slot, char* name)
 EXPORT_SYMBOL(mca_set_adapter_name);
 
 /**
- *      mca_is_adapter_used - check if claimed by driver
- *      @slot:  slot to check
- *
- *      Returns 1 if the slot has been claimed by a driver
- */
-
-int mca_is_adapter_used(int slot)
-{
-        struct mca_device *mca_dev = mca_find_device_by_slot(slot);
-
-        if(!mca_dev)
-                return 0;
-
-        return mca_device_claimed(mca_dev);
-}
-EXPORT_SYMBOL(mca_is_adapter_used);
-
-/**
  *      mca_mark_as_used - claim an MCA device
  *      @slot:  slot to claim
  *      FIXME:  should we make this threadsafe
diff --git a/drivers/mca/mca-proc.c b/drivers/mca/mca-proc.c
index 33d5e0820cc5..81ea0d377bf4 100644
--- a/drivers/mca/mca-proc.c
+++ b/drivers/mca/mca-proc.c
@@ -183,7 +183,7 @@ void __init mca_do_proc_init(void)
         struct proc_dir_entry* node = NULL;
         struct mca_device *mca_dev;
 
-        proc_mca = proc_mkdir("mca", &proc_root);
+        proc_mca = proc_mkdir("mca", NULL);
         create_proc_read_entry("pos",0,proc_mca,get_mca_info,NULL);
         create_proc_read_entry("machine",0,proc_mca,get_mca_machine_info,NULL);
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index acd716b657b8..bb3e4b1cb773 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -5948,13 +5948,9 @@ static struct notifier_block md_notifier = {
 
 static void md_geninit(void)
 {
-        struct proc_dir_entry *p;
-
         dprintk("md: sizeof(mdp_super_t) = %d\n", (int)sizeof(mdp_super_t));
 
-        p = create_proc_entry("mdstat", S_IRUGO, NULL);
-        if (p)
-                p->proc_fops = &md_seq_fops;
+        proc_create("mdstat", S_IRUGO, NULL, &md_seq_fops);
 }
 
 static int __init md_init(void)
diff --git a/drivers/media/video/zoran_procfs.c b/drivers/media/video/zoran_procfs.c
index 328ed6e7ac6a..870bc5a70e3f 100644
--- a/drivers/media/video/zoran_procfs.c
+++ b/drivers/media/video/zoran_procfs.c
@@ -180,6 +180,7 @@ static ssize_t zoran_write(struct file *file, const char __user *buffer,
 }
 
 static const struct file_operations zoran_operations = {
+        .owner          = THIS_MODULE,
         .open           = zoran_open,
         .read           = seq_read,
         .write          = zoran_write,
@@ -195,10 +196,8 @@ zoran_proc_init (struct zoran *zr)
         char name[8];
 
         snprintf(name, 7, "zoran%d", zr->id);
-        if ((zr->zoran_proc = create_proc_entry(name, 0, NULL))) {
-                zr->zoran_proc->data = zr;
-                zr->zoran_proc->owner = THIS_MODULE;
-                zr->zoran_proc->proc_fops = &zoran_operations;
+        zr->zoran_proc = proc_create_data(name, 0, NULL, &zoran_operations, zr);
+        if (zr->zoran_proc != NULL) {
                 dprintk(2,
                         KERN_INFO
                         "%s: procfs entry /proc/%s allocated. data=%p\n",
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index a95314897402..81483de8c0fd 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -371,7 +371,7 @@ static int i2o_block_prep_req_fn(struct request_queue *q, struct request *req)
         /* connect the i2o_block_request to the request */
         if (!req->special) {
                 ireq = i2o_block_request_alloc();
-                if (unlikely(IS_ERR(ireq))) {
+                if (IS_ERR(ireq)) {
                         osm_debug("unable to allocate i2o_block_request!\n");
                         return BLKPREP_DEFER;
                 }
diff --git a/drivers/message/i2o/i2o_proc.c b/drivers/message/i2o/i2o_proc.c
index 6fdd072201f9..54a3016ff45d 100644
--- a/drivers/message/i2o/i2o_proc.c
+++ b/drivers/message/i2o/i2o_proc.c
@@ -1893,13 +1893,11 @@ static int i2o_proc_create_entries(struct proc_dir_entry *dir,
         struct proc_dir_entry *tmp;
 
         while (i2o_pe->name) {
-                tmp = create_proc_entry(i2o_pe->name, i2o_pe->mode, dir);
+                tmp = proc_create_data(i2o_pe->name, i2o_pe->mode, dir,
+                                       i2o_pe->fops, data);
                 if (!tmp)
                         return -1;
 
-                tmp->data = data;
-                tmp->proc_fops = i2o_pe->fops;
-
                 i2o_pe++;
         }
 
diff --git a/drivers/misc/hdpuftrs/hdpu_cpustate.c b/drivers/misc/hdpuftrs/hdpu_cpustate.c
index 302e92418bbe..ff51ab67231c 100644
--- a/drivers/misc/hdpuftrs/hdpu_cpustate.c
+++ b/drivers/misc/hdpuftrs/hdpu_cpustate.c
@@ -210,13 +210,10 @@ static int hdpu_cpustate_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        proc_de = create_proc_entry("sky_cpustate", 0666, &proc_root);
+        proc_de = proc_create("sky_cpustate", 0666, NULL, &proc_cpustate);
         if (!proc_de) {
                 printk(KERN_WARNING "sky_cpustate: "
                        "Unable to create proc entry\n");
-        } else {
-                proc_de->proc_fops = &proc_cpustate;
-                proc_de->owner = THIS_MODULE;
         }
 
         printk(KERN_INFO "Sky CPU State Driver v" SKY_CPUSTATE_VERSION "\n");
diff --git a/drivers/misc/hdpuftrs/hdpu_nexus.c b/drivers/misc/hdpuftrs/hdpu_nexus.c
index 2fa36f7a6eb3..08e26beefe64 100644
--- a/drivers/misc/hdpuftrs/hdpu_nexus.c
+++ b/drivers/misc/hdpuftrs/hdpu_nexus.c
@@ -102,22 +102,17 @@ static int hdpu_nexus_probe(struct platform_device *pdev)
                 printk(KERN_ERR "sky_nexus: Could not map slot id\n");
         }
 
-        hdpu_slot_id = create_proc_entry("sky_slot_id", 0666, &proc_root);
+        hdpu_slot_id = proc_create("sky_slot_id", 0666, NULL, &proc_slot_id);
         if (!hdpu_slot_id) {
                 printk(KERN_WARNING "sky_nexus: "
                        "Unable to create proc dir entry: sky_slot_id\n");
-        } else {
-                hdpu_slot_id->proc_fops = &proc_slot_id;
-                hdpu_slot_id->owner = THIS_MODULE;
         }
 
-        hdpu_chassis_id = create_proc_entry("sky_chassis_id", 0666, &proc_root);
-        if (!hdpu_chassis_id) {
+        hdpu_chassis_id = proc_create("sky_chassis_id", 0666, NULL,
+                                      &proc_chassis_id);
+        if (!hdpu_chassis_id)
                 printk(KERN_WARNING "sky_nexus: "
                        "Unable to create proc dir entry: sky_chassis_id\n");
-        } else {
-                hdpu_chassis_id->proc_fops = &proc_chassis_id;
-                hdpu_chassis_id->owner = THIS_MODULE;
         }
 
         return 0;
@@ -128,8 +123,8 @@ static int hdpu_nexus_remove(struct platform_device *pdev)
         slot_id = -1;
         chassis_id = -1;
 
-        remove_proc_entry("sky_slot_id", &proc_root);
-        remove_proc_entry("sky_chassis_id", &proc_root);
+        remove_proc_entry("sky_slot_id", NULL);
+        remove_proc_entry("sky_chassis_id", NULL);
 
         hdpu_slot_id = 0;
         hdpu_chassis_id = 0;
diff --git a/drivers/misc/ibmasm/command.c b/drivers/misc/ibmasm/command.c
index 1a0e7978226a..276d3fb68094 100644
--- a/drivers/misc/ibmasm/command.c
+++ b/drivers/misc/ibmasm/command.c
@@ -96,7 +96,7 @@ static inline void do_exec_command(struct service_processor *sp)
 {
         char tsbuf[32];
 
-        dbg("%s:%d at %s\n", __FUNCTION__, __LINE__, get_timestamp(tsbuf));
+        dbg("%s:%d at %s\n", __func__, __LINE__, get_timestamp(tsbuf));
 
         if (ibmasm_send_i2o_message(sp)) {
                 sp->current_command->status = IBMASM_CMD_FAILED;
@@ -119,7 +119,7 @@ void ibmasm_exec_command(struct service_processor *sp, struct command *cmd)
         unsigned long flags;
         char tsbuf[32];
 
-        dbg("%s:%d at %s\n", __FUNCTION__, __LINE__, get_timestamp(tsbuf));
+        dbg("%s:%d at %s\n", __func__, __LINE__, get_timestamp(tsbuf));
 
         spin_lock_irqsave(&sp->lock, flags);
 
@@ -139,7 +139,7 @@ static void exec_next_command(struct service_processor *sp)
         unsigned long flags;
         char tsbuf[32];
 
-        dbg("%s:%d at %s\n", __FUNCTION__, __LINE__, get_timestamp(tsbuf));
+        dbg("%s:%d at %s\n", __func__, __LINE__, get_timestamp(tsbuf));
 
         spin_lock_irqsave(&sp->lock, flags);
         sp->current_command = dequeue_command(sp);
diff --git a/drivers/misc/ibmasm/heartbeat.c b/drivers/misc/ibmasm/heartbeat.c
index 3036e785b3e4..1bc4306572a4 100644
--- a/drivers/misc/ibmasm/heartbeat.c
+++ b/drivers/misc/ibmasm/heartbeat.c
@@ -75,9 +75,9 @@ void ibmasm_heartbeat_exit(struct service_processor *sp)
 {
         char tsbuf[32];
 
-        dbg("%s:%d at %s\n", __FUNCTION__, __LINE__, get_timestamp(tsbuf));
+        dbg("%s:%d at %s\n", __func__, __LINE__, get_timestamp(tsbuf));
         ibmasm_wait_for_response(sp->heartbeat, IBMASM_CMD_TIMEOUT_NORMAL);
-        dbg("%s:%d at %s\n", __FUNCTION__, __LINE__, get_timestamp(tsbuf));
+        dbg("%s:%d at %s\n", __func__, __LINE__, get_timestamp(tsbuf));
         suspend_heartbeats = 1;
         command_put(sp->heartbeat);
 }
@@ -88,7 +88,7 @@ void ibmasm_receive_heartbeat(struct service_processor *sp,  void *message, size
         struct dot_command_header *header = (struct dot_command_header *)cmd->buffer;
         char tsbuf[32];
 
-        dbg("%s:%d at %s\n", __FUNCTION__, __LINE__, get_timestamp(tsbuf));
+        dbg("%s:%d at %s\n", __func__, __LINE__, get_timestamp(tsbuf));
         if (suspend_heartbeats)
                 return;
 
diff --git a/drivers/misc/intel_menlow.c b/drivers/misc/intel_menlow.c
index 0c0bb3093e07..80a136352408 100644
--- a/drivers/misc/intel_menlow.c
+++ b/drivers/misc/intel_menlow.c
@@ -175,19 +175,17 @@ static int intel_menlow_memory_add(struct acpi_device *device)
                 goto end;
         }
 
-        if (cdev) {
-                acpi_driver_data(device) = cdev;
-                result = sysfs_create_link(&device->dev.kobj,
-                                        &cdev->device.kobj, "thermal_cooling");
-                if (result)
-                        goto unregister;
-
-                result = sysfs_create_link(&cdev->device.kobj,
-                                        &device->dev.kobj, "device");
-                if (result) {
-                        sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
-                        goto unregister;
-                }
+        acpi_driver_data(device) = cdev;
+        result = sysfs_create_link(&device->dev.kobj,
+                                &cdev->device.kobj, "thermal_cooling");
+        if (result)
+                goto unregister;
+
+        result = sysfs_create_link(&cdev->device.kobj,
+                                &device->dev.kobj, "device");
+        if (result) {
+                sysfs_remove_link(&device->dev.kobj, "thermal_cooling");
+                goto unregister;
         }
 
  end:
diff --git a/drivers/misc/ioc4.c b/drivers/misc/ioc4.c
index 05172d2613d6..6f76573e7c8a 100644
--- a/drivers/misc/ioc4.c
+++ b/drivers/misc/ioc4.c
@@ -75,7 +75,7 @@ ioc4_register_submodule(struct ioc4_submodule *is)
                         printk(KERN_WARNING
                                "%s: IOC4 submodule %s probe failed "
                                "for pci_dev %s",
-                               __FUNCTION__, module_name(is->is_owner),
+                               __func__, module_name(is->is_owner),
                                pci_name(idd->idd_pdev));
                 }
         }
@@ -102,7 +102,7 @@ ioc4_unregister_submodule(struct ioc4_submodule *is)
                         printk(KERN_WARNING
                                "%s: IOC4 submodule %s remove failed "
                                "for pci_dev %s.\n",
-                               __FUNCTION__, module_name(is->is_owner),
+                               __func__, module_name(is->is_owner),
                                pci_name(idd->idd_pdev));
                 }
         }
@@ -282,7 +282,7 @@ ioc4_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
         if ((ret = pci_enable_device(pdev))) {
                 printk(KERN_WARNING
                        "%s: Failed to enable IOC4 device for pci_dev %s.\n",
-                       __FUNCTION__, pci_name(pdev));
+                       __func__, pci_name(pdev));
                 goto out;
         }
         pci_set_master(pdev);
@@ -292,7 +292,7 @@ ioc4_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
         if (!idd) {
                 printk(KERN_WARNING
                        "%s: Failed to allocate IOC4 data for pci_dev %s.\n",
-                       __FUNCTION__, pci_name(pdev));
+                       __func__, pci_name(pdev));
                 ret = -ENODEV;
                 goto out_idd;
         }
@@ -307,7 +307,7 @@ ioc4_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
                 printk(KERN_WARNING
                        "%s: Unable to find IOC4 misc resource "
                        "for pci_dev %s.\n",
-                       __FUNCTION__, pci_name(idd->idd_pdev));
+                       __func__, pci_name(idd->idd_pdev));
                 ret = -ENODEV;
                 goto out_pci;
         }
@@ -316,7 +316,7 @@ ioc4_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
                 printk(KERN_WARNING
                        "%s: Unable to request IOC4 misc region "
                        "for pci_dev %s.\n",
-                       __FUNCTION__, pci_name(idd->idd_pdev));
+                       __func__, pci_name(idd->idd_pdev));
                 ret = -ENODEV;
                 goto out_pci;
         }
@@ -326,7 +326,7 @@ ioc4_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
                 printk(KERN_WARNING
                        "%s: Unable to remap IOC4 misc region "
                        "for pci_dev %s.\n",
-                       __FUNCTION__, pci_name(idd->idd_pdev));
+                       __func__, pci_name(idd->idd_pdev));
                 ret = -ENODEV;
                 goto out_misc_region;
         }
@@ -372,7 +372,7 @@ ioc4_probe(struct pci_dev *pdev, const struct pci_device_id *pci_id)
                         printk(KERN_WARNING
                                "%s: IOC4 submodule 0x%s probe failed "
                                "for pci_dev %s.\n",
-                               __FUNCTION__, module_name(is->is_owner),
+                               __func__, module_name(is->is_owner),
                                pci_name(idd->idd_pdev));
                 }
         }
@@ -406,7 +406,7 @@ ioc4_remove(struct pci_dev *pdev)
                         printk(KERN_WARNING
                                "%s: IOC4 submodule 0x%s remove failed "
                                "for pci_dev %s.\n",
-                               __FUNCTION__, module_name(is->is_owner),
+                               __func__, module_name(is->is_owner),
                                pci_name(idd->idd_pdev));
                 }
         }
@@ -418,7 +418,7 @@ ioc4_remove(struct pci_dev *pdev)
                 printk(KERN_WARNING
                        "%s: Unable to get IOC4 misc mapping for pci_dev %s. "
                        "Device removal may be incomplete.\n",
-                       __FUNCTION__, pci_name(idd->idd_pdev));
+                       __func__, pci_name(idd->idd_pdev));
         }
         release_mem_region(idd->idd_bar0, sizeof(struct ioc4_misc_regs));
 
diff --git a/drivers/misc/phantom.c b/drivers/misc/phantom.c
index 7fa61e907e1c..71d1c84e2fa8 100644
--- a/drivers/misc/phantom.c
+++ b/drivers/misc/phantom.c
@@ -12,6 +12,7 @@
  *  or alternatively, you might use OpenHaptics provided by Sensable.
  */
 
+#include <linux/compat.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/device.h>
@@ -91,11 +92,8 @@ static long phantom_ioctl(struct file *file, unsigned int cmd,
         unsigned long flags;
         unsigned int i;
 
-        if (_IOC_TYPE(cmd) != PH_IOC_MAGIC ||
-                        _IOC_NR(cmd) > PH_IOC_MAXNR)
-                return -ENOTTY;
-
         switch (cmd) {
+        case PHN_SETREG:
         case PHN_SET_REG:
                 if (copy_from_user(&r, argp, sizeof(r)))
                         return -EFAULT;
@@ -126,6 +124,7 @@ static long phantom_ioctl(struct file *file, unsigned int cmd,
                         phantom_status(dev, dev->status & ~PHB_RUNNING);
                 spin_unlock_irqrestore(&dev->regs_lock, flags);
                 break;
+        case PHN_SETREGS:
         case PHN_SET_REGS:
                 if (copy_from_user(&rs, argp, sizeof(rs)))
                         return -EFAULT;
@@ -143,6 +142,7 @@ static long phantom_ioctl(struct file *file, unsigned int cmd,
                 }
                 spin_unlock_irqrestore(&dev->regs_lock, flags);
                 break;
+        case PHN_GETREG:
         case PHN_GET_REG:
                 if (copy_from_user(&r, argp, sizeof(r)))
                         return -EFAULT;
@@ -155,6 +155,7 @@ static long phantom_ioctl(struct file *file, unsigned int cmd,
                 if (copy_to_user(argp, &r, sizeof(r)))
                         return -EFAULT;
                 break;
+        case PHN_GETREGS:
         case PHN_GET_REGS: {
                 u32 m;
 
@@ -168,6 +169,7 @@ static long phantom_ioctl(struct file *file, unsigned int cmd,
                 for (i = 0; i < m; i++)
                         if (rs.mask & BIT(i))
                                 rs.values[i] = ioread32(dev->iaddr + i);
+                atomic_set(&dev->counter, 0);
                 spin_unlock_irqrestore(&dev->regs_lock, flags);
 
                 if (copy_to_user(argp, &rs, sizeof(rs)))
@@ -191,6 +193,20 @@ static long phantom_ioctl(struct file *file, unsigned int cmd,
         return 0;
 }
 
+#ifdef CONFIG_COMPAT
+static long phantom_compat_ioctl(struct file *filp, unsigned int cmd,
+                unsigned long arg)
+{
+        if (_IOC_NR(cmd) <= 3 && _IOC_SIZE(cmd) == sizeof(compat_uptr_t)) {
+                cmd &= ~(_IOC_SIZEMASK << _IOC_SIZESHIFT);
+                cmd |= sizeof(void *) << _IOC_SIZESHIFT;
+        }
+        return phantom_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
+}
+#else
+#define phantom_compat_ioctl NULL
+#endif
+
 static int phantom_open(struct inode *inode, struct file *file)
 {
         struct phantom_device *dev = container_of(inode->i_cdev,
@@ -239,11 +255,12 @@ static unsigned int phantom_poll(struct file *file, poll_table *wait)
 
         pr_debug("phantom_poll: %d\n", atomic_read(&dev->counter));
         poll_wait(file, &dev->wait, wait);
-        if (atomic_read(&dev->counter)) {
+
+        if (!(dev->status & PHB_RUNNING))
+                mask = POLLERR;
+        else if (atomic_read(&dev->counter))
                 mask = POLLIN | POLLRDNORM;
-                atomic_dec(&dev->counter);
-        } else if ((dev->status & PHB_RUNNING) == 0)
-                mask = POLLIN | POLLRDNORM | POLLERR;
+
         pr_debug("phantom_poll end: %x/%d\n", mask, atomic_read(&dev->counter));
 
         return mask;
@@ -253,6 +270,7 @@ static struct file_operations phantom_file_ops = {
         .open = phantom_open,
         .release = phantom_release,
         .unlocked_ioctl = phantom_ioctl,
+        .compat_ioctl = phantom_compat_ioctl,
         .poll = phantom_poll,
 };
 
diff --git a/drivers/misc/sony-laptop.c b/drivers/misc/sony-laptop.c
index 02ff3d19b1cc..00e48e2a9c11 100644
--- a/drivers/misc/sony-laptop.c
+++ b/drivers/misc/sony-laptop.c
@@ -961,7 +961,7 @@ static int sony_nc_resume(struct acpi_device *device)
                 ret = acpi_callsetfunc(sony_nc_acpi_handle, *item->acpiset,
                                        item->value, NULL);
                 if (ret < 0) {
-                        printk("%s: %d\n", __FUNCTION__, ret);
+                        printk("%s: %d\n", __func__, ret);
                         break;
                 }
         }
@@ -1453,7 +1453,7 @@ static struct sonypi_eventtypes type4_events[] = {
                 udelay(1);                                              \
         if (!n)                                                         \
                 dprintk("command failed at %s : %s (line %d)\n",        \
-                                __FILE__, __FUNCTION__, __LINE__);      \
+                                __FILE__, __func__, __LINE__);  \
 }
 
 static u8 sony_pic_call1(u8 dev)
diff --git a/drivers/mmc/host/mmc_spi.c b/drivers/mmc/host/mmc_spi.c
index 365024b83d3d..35508584ac2a 100644
--- a/drivers/mmc/host/mmc_spi.c
+++ b/drivers/mmc/host/mmc_spi.c
@@ -340,7 +340,7 @@ checkstatus:
 
         /* SPI R3, R4, or R7 == R1 + 4 bytes */
         case MMC_RSP_SPI_R3:
-                cmd->resp[1] = be32_to_cpu(get_unaligned((u32 *)cp));
+                cmd->resp[1] = get_unaligned_be32(cp);
                 break;
 
         /* SPI R1 == just one status byte */
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 6e91b4b7aabb..6425603bc379 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -3282,17 +3282,14 @@ static int bond_create_proc_entry(struct bonding *bond)
         struct net_device *bond_dev = bond->dev;
 
         if (bond_proc_dir) {
-                bond->proc_entry = create_proc_entry(bond_dev->name,
-                                                     S_IRUGO,
-                                                     bond_proc_dir);
+                bond->proc_entry = proc_create_data(bond_dev->name,
+                                                    S_IRUGO, bond_proc_dir,
+                                                    &bond_info_fops, bond);
                 if (bond->proc_entry == NULL) {
                         printk(KERN_WARNING DRV_NAME
                                ": Warning: Cannot create /proc/net/%s/%s\n",
                                DRV_NAME, bond_dev->name);
                 } else {
-                        bond->proc_entry->data = bond;
-                        bond->proc_entry->proc_fops = &bond_info_fops;
-                        bond->proc_entry->owner = THIS_MODULE;
                         memcpy(bond->proc_file_name, bond_dev->name, IFNAMSIZ);
                 }
         }
diff --git a/drivers/net/e100.c b/drivers/net/e100.c
index 2d139ec79777..f3cba5e24ec5 100644
--- a/drivers/net/e100.c
+++ b/drivers/net/e100.c
@@ -1802,7 +1802,7 @@ static int e100_rx_alloc_skb(struct nic *nic, struct rx *rx)
          * it is protected by the before last buffer's el bit being set */
         if (rx->prev->skb) {
                 struct rfd *prev_rfd = (struct rfd *)rx->prev->skb->data;
-                put_unaligned(cpu_to_le32(rx->dma_addr), &prev_rfd->link);
+                put_unaligned_le32(rx->dma_addr, &prev_rfd->link);
         }
 
         return 0;
diff --git a/drivers/net/hamachi.c b/drivers/net/hamachi.c
index b53f6b6491b3..e5c2380f50ca 100644
--- a/drivers/net/hamachi.c
+++ b/drivers/net/hamachi.c
@@ -1508,7 +1508,7 @@ static int hamachi_rx(struct net_device *dev)
                                             hmp->rx_buf_sz,
                                             PCI_DMA_FROMDEVICE);
                 buf_addr = (u8 *) hmp->rx_skbuff[entry]->data;
-                frame_status = le32_to_cpu(get_unaligned((__le32*)&(buf_addr[data_size - 12])));
+                frame_status = get_unaligned_le32(&(buf_addr[data_size - 12]));
                 if (hamachi_debug > 4)
                         printk(KERN_DEBUG "  hamachi_rx() status was %8.8x.\n",
                                 frame_status);
diff --git a/drivers/net/ibmveth.c b/drivers/net/ibmveth.c
index ce4fc2ec2fe4..00527805e4f1 100644
--- a/drivers/net/ibmveth.c
+++ b/drivers/net/ibmveth.c
@@ -1302,13 +1302,10 @@ static void ibmveth_proc_register_adapter(struct ibmveth_adapter *adapter)
         if (ibmveth_proc_dir) {
                 char u_addr[10];
                 sprintf(u_addr, "%x", adapter->vdev->unit_address);
-                entry = create_proc_entry(u_addr, S_IFREG, ibmveth_proc_dir);
-                if (!entry) {
+                entry = proc_create_data(u_addr, S_IFREG, ibmveth_proc_dir,
+                                         &ibmveth_proc_fops, adapter);
+                if (!entry)
                         ibmveth_error_printk("Cannot create adapter proc entry");
-                } else {
-                        entry->data = (void *) adapter;
-                        entry->proc_fops = &ibmveth_proc_fops;
-                }
         }
         return;
 }
diff --git a/drivers/net/irda/mcs7780.c b/drivers/net/irda/mcs7780.c
index 93916cf33f29..ad92d3ff1c40 100644
--- a/drivers/net/irda/mcs7780.c
+++ b/drivers/net/irda/mcs7780.c
@@ -464,7 +464,7 @@ static void mcs_unwrap_fir(struct mcs_cb *mcs, __u8 *buf, int len)
         }
 
         fcs = ~(crc32_le(~0, buf, new_len));
-        if(fcs != le32_to_cpu(get_unaligned((__le32 *)(buf+new_len)))) {
+        if(fcs != get_unaligned_le32(buf + new_len)) {
                 IRDA_ERROR("crc error calc 0x%x len %d\n", fcs, new_len);
                 mcs->stats.rx_errors++;
                 mcs->stats.rx_crc_errors++;
diff --git a/drivers/net/irda/stir4200.c b/drivers/net/irda/stir4200.c
index e59c485bc497..051963782749 100644
--- a/drivers/net/irda/stir4200.c
+++ b/drivers/net/irda/stir4200.c
@@ -329,7 +329,7 @@ static void fir_eof(struct stir_cb *stir)
         }
 
         fcs = ~(crc32_le(~0, rx_buff->data, len));
-        if (fcs != le32_to_cpu(get_unaligned((__le32 *)(rx_buff->data+len)))) {
+        if (fcs != get_unaligned_le32(rx_buff->data + len)) {
                 pr_debug("crc error calc 0x%x len %d\n", fcs, len);
                 stir->stats.rx_errors++;
                 stir->stats.rx_crc_errors++;
diff --git a/drivers/net/irda/vlsi_ir.c b/drivers/net/irda/vlsi_ir.c
index acd082a96a4f..d15e00b8591e 100644
--- a/drivers/net/irda/vlsi_ir.c
+++ b/drivers/net/irda/vlsi_ir.c
@@ -1674,13 +1674,12 @@ vlsi_irda_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         if (vlsi_proc_root != NULL) {
                 struct proc_dir_entry *ent;
 
-                ent = create_proc_entry(ndev->name, S_IFREG|S_IRUGO, vlsi_proc_root);
+                ent = proc_create_data(ndev->name, S_IFREG|S_IRUGO,
+                                       vlsi_proc_root, VLSI_PROC_FOPS, ndev);
                 if (!ent) {
                         IRDA_WARNING("%s: failed to create proc entry\n",
                                      __FUNCTION__);
                 } else {
-                        ent->data = ndev;
-                        ent->proc_fops = VLSI_PROC_FOPS;
                         ent->size = 0;
                 }
                 idev->proc_entry = ent;
diff --git a/drivers/net/myri10ge/myri10ge.c b/drivers/net/myri10ge/myri10ge.c
index cead81e80f0c..ef63c8d2bd7e 100644
--- a/drivers/net/myri10ge/myri10ge.c
+++ b/drivers/net/myri10ge/myri10ge.c
@@ -2437,7 +2437,7 @@ static int myri10ge_sw_tso(struct sk_buff *skb, struct net_device *dev)
         int status;
 
         segs = skb_gso_segment(skb, dev->features & ~NETIF_F_TSO6);
-        if (unlikely(IS_ERR(segs)))
+        if (IS_ERR(segs))
                 goto drop;
 
         while (segs) {
diff --git a/drivers/net/pppoe.c b/drivers/net/pppoe.c
index 4fad4ddb3504..58a26a47af29 100644
--- a/drivers/net/pppoe.c
+++ b/drivers/net/pppoe.c
@@ -1052,11 +1052,9 @@ static int __init pppoe_proc_init(void)
 {
         struct proc_dir_entry *p;
 
-        p = create_proc_entry("pppoe", S_IRUGO, init_net.proc_net);
+        p = proc_net_fops_create(&init_net, "pppoe", S_IRUGO, &pppoe_seq_fops);
         if (!p)
                 return -ENOMEM;
-
-        p->proc_fops = &pppoe_seq_fops;
         return 0;
 }
 #else /* CONFIG_PROC_FS */
diff --git a/drivers/net/pppol2tp.c b/drivers/net/pppol2tp.c
index 3d10ca050b79..244d7830c92a 100644
--- a/drivers/net/pppol2tp.c
+++ b/drivers/net/pppol2tp.c
@@ -2469,12 +2469,12 @@ static int __init pppol2tp_init(void)
                 goto out_unregister_pppol2tp_proto;
 
 #ifdef CONFIG_PROC_FS
-        pppol2tp_proc = create_proc_entry("pppol2tp", 0, init_net.proc_net);
+        pppol2tp_proc = proc_net_fops_create(&init_net, "pppol2tp", 0,
+                                             &pppol2tp_proc_fops);
         if (!pppol2tp_proc) {
                 err = -ENOMEM;
                 goto out_unregister_pppox_proto;
         }
-        pppol2tp_proc->proc_fops = &pppol2tp_proc_fops;
 #endif /* CONFIG_PROC_FS */
         printk(KERN_INFO "PPPoL2TP kernel driver, %s\n",
                PPPOL2TP_DRV_VERSION);
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index e3f74c9f78bd..b66c75e3b8a1 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -4361,7 +4361,7 @@ static int tg3_tso_bug(struct tg3 *tp, struct sk_buff *skb)
         }
 
         segs = skb_gso_segment(skb, tp->dev->features & ~NETIF_F_TSO);
-        if (unlikely(IS_ERR(segs)))
+        if (IS_ERR(segs))
                 goto tg3_tso_bug_end;
 
         do {
diff --git a/drivers/net/tulip/de4x5.c b/drivers/net/tulip/de4x5.c
index 6c6fc325c8f9..bc30c6e8fea2 100644
--- a/drivers/net/tulip/de4x5.c
+++ b/drivers/net/tulip/de4x5.c
@@ -482,7 +482,6 @@
 static char version[] __devinitdata = "de4x5.c:V0.546 2001/02/22 davies@maniac.ultranet.com\n";
 
 #define c_char const char
-#define TWIDDLE(a) (u_short)le16_to_cpu(get_unaligned((__le16 *)(a)))
 
 /*
 ** MII Information
@@ -4405,7 +4404,7 @@ srom_infoleaf_info(struct net_device *dev)
         }
     }
 
-    lp->infoleaf_offset = TWIDDLE(p+1);
+        lp->infoleaf_offset = get_unaligned_le16(p + 1);
 
     return 0;
 }
@@ -4476,7 +4475,7 @@ srom_exec(struct net_device *dev, u_char *p)
 
     while (count--) {
         gep_wr(((lp->chipset==DC21140) && (lp->ibn!=5) ?
-                                                   *p++ : TWIDDLE(w++)), dev);
+                                                   *p++ : get_unaligned_le16(w++)), dev);
         mdelay(2);                          /* 2ms per action */
     }
 
@@ -4711,10 +4710,10 @@ type1_infoblock(struct net_device *dev, u_char count, u_char *p)
         lp->active = *p++;
         lp->phy[lp->active].gep = (*p ? p : NULL); p += (*p + 1);
         lp->phy[lp->active].rst = (*p ? p : NULL); p += (*p + 1);
-        lp->phy[lp->active].mc  = TWIDDLE(p); p += 2;
-        lp->phy[lp->active].ana = TWIDDLE(p); p += 2;
-        lp->phy[lp->active].fdx = TWIDDLE(p); p += 2;
-        lp->phy[lp->active].ttm = TWIDDLE(p);
+        lp->phy[lp->active].mc  = get_unaligned_le16(p); p += 2;
+        lp->phy[lp->active].ana = get_unaligned_le16(p); p += 2;
+        lp->phy[lp->active].fdx = get_unaligned_le16(p); p += 2;
+        lp->phy[lp->active].ttm = get_unaligned_le16(p);
         return 0;
     } else if ((lp->media == INIT) && (lp->timeout < 0)) {
         lp->ibn = 1;
@@ -4751,16 +4750,16 @@ type2_infoblock(struct net_device *dev, u_char count, u_char *p)
         lp->infoblock_media = (*p) & MEDIA_CODE;
 
         if ((*p++) & EXT_FIELD) {
-            lp->cache.csr13 = TWIDDLE(p); p += 2;
-            lp->cache.csr14 = TWIDDLE(p); p += 2;
-            lp->cache.csr15 = TWIDDLE(p); p += 2;
+            lp->cache.csr13 = get_unaligned_le16(p); p += 2;
+            lp->cache.csr14 = get_unaligned_le16(p); p += 2;
+            lp->cache.csr15 = get_unaligned_le16(p); p += 2;
         } else {
             lp->cache.csr13 = CSR13;
             lp->cache.csr14 = CSR14;
             lp->cache.csr15 = CSR15;
         }
-        lp->cache.gepc = ((s32)(TWIDDLE(p)) << 16); p += 2;
-        lp->cache.gep  = ((s32)(TWIDDLE(p)) << 16);
+        lp->cache.gepc = ((s32)(get_unaligned_le16(p)) << 16); p += 2;
+        lp->cache.gep  = ((s32)(get_unaligned_le16(p)) << 16);
         lp->infoblock_csr6 = OMR_SIA;
         lp->useMII = false;
 
@@ -4792,10 +4791,10 @@ type3_infoblock(struct net_device *dev, u_char count, u_char *p)
         if (MOTO_SROM_BUG) lp->active = 0;
         lp->phy[lp->active].gep = (*p ? p : NULL); p += (2 * (*p) + 1);
         lp->phy[lp->active].rst = (*p ? p : NULL); p += (2 * (*p) + 1);
-        lp->phy[lp->active].mc  = TWIDDLE(p); p += 2;
-        lp->phy[lp->active].ana = TWIDDLE(p); p += 2;
-        lp->phy[lp->active].fdx = TWIDDLE(p); p += 2;
-        lp->phy[lp->active].ttm = TWIDDLE(p); p += 2;
+        lp->phy[lp->active].mc  = get_unaligned_le16(p); p += 2;
+        lp->phy[lp->active].ana = get_unaligned_le16(p); p += 2;
+        lp->phy[lp->active].fdx = get_unaligned_le16(p); p += 2;
+        lp->phy[lp->active].ttm = get_unaligned_le16(p); p += 2;
         lp->phy[lp->active].mci = *p;
         return 0;
     } else if ((lp->media == INIT) && (lp->timeout < 0)) {
@@ -4835,8 +4834,8 @@ type4_infoblock(struct net_device *dev, u_char count, u_char *p)
         lp->cache.csr13 = CSR13;              /* Hard coded defaults */
         lp->cache.csr14 = CSR14;
         lp->cache.csr15 = CSR15;
-        lp->cache.gepc = ((s32)(TWIDDLE(p)) << 16); p += 2;
-        lp->cache.gep  = ((s32)(TWIDDLE(p)) << 16); p += 2;
+        lp->cache.gepc = ((s32)(get_unaligned_le16(p)) << 16); p += 2;
+        lp->cache.gep  = ((s32)(get_unaligned_le16(p)) << 16); p += 2;
         csr6 = *p++;
         flags = *p++;
 
diff --git a/drivers/net/tulip/de4x5.h b/drivers/net/tulip/de4x5.h
index 9fb8d7f07994..f5f33b3eb067 100644
--- a/drivers/net/tulip/de4x5.h
+++ b/drivers/net/tulip/de4x5.h
@@ -1017,4 +1017,4 @@ struct de4x5_ioctl {
 #define DE4X5_SET_OMR           0x0d /* Set the OMR Register contents */
 #define DE4X5_GET_REG           0x0e /* Get the DE4X5 Registers */
 
-#define MOTO_SROM_BUG    ((lp->active == 8) && (((le32_to_cpu(get_unaligned(((__le32 *)dev->dev_addr))))&0x00ffffff)==0x3e0008))
+#define MOTO_SROM_BUG    (lp->active == 8 && (get_unaligned_le32(dev->dev_addr) & 0x00ffffff) == 0x3e0008)
diff --git a/drivers/net/tulip/tulip.h b/drivers/net/tulip/tulip.h
index 908422f2f320..92c68a22f16b 100644
--- a/drivers/net/tulip/tulip.h
+++ b/drivers/net/tulip/tulip.h
@@ -25,6 +25,7 @@
 #include <linux/pci.h>
 #include <asm/io.h>
 #include <asm/irq.h>
+#include <asm/unaligned.h>
 
 
 
@@ -304,11 +305,7 @@ enum t21143_csr6_bits {
 
 #define RUN_AT(x) (jiffies + (x))
 
-#if defined(__i386__)                   /* AKA get_unaligned() */
-#define get_u16(ptr) (*(u16 *)(ptr))
-#else
-#define get_u16(ptr) (((u8*)(ptr))[0] + (((u8*)(ptr))[1]<<8))
-#endif
+#define get_u16(ptr) get_unaligned_le16((ptr))
 
 struct medialeaf {
         u8 type;
diff --git a/drivers/net/tulip/tulip_core.c b/drivers/net/tulip/tulip_core.c
index fa1c1c329a2d..f9d13fa05d64 100644
--- a/drivers/net/tulip/tulip_core.c
+++ b/drivers/net/tulip/tulip_core.c
@@ -327,8 +327,8 @@ static void tulip_up(struct net_device *dev)
         tp->dirty_rx = tp->dirty_tx = 0;
 
         if (tp->flags & MC_HASH_ONLY) {
-                u32 addr_low = le32_to_cpu(get_unaligned((__le32 *)dev->dev_addr));
-                u32 addr_high = le16_to_cpu(get_unaligned((__le16 *)(dev->dev_addr+4)));
+                u32 addr_low = get_unaligned_le32(dev->dev_addr);
+                u32 addr_high = get_unaligned_le16(dev->dev_addr + 4);
                 if (tp->chip_id == AX88140) {
                         iowrite32(0, ioaddr + CSR13);
                         iowrite32(addr_low,  ioaddr + CSR14);
@@ -1437,13 +1437,13 @@ static int __devinit tulip_init_one (struct pci_dev *pdev,
                         do
                                 value = ioread32(ioaddr + CSR9);
                         while (value < 0  && --boguscnt > 0);
-                        put_unaligned(cpu_to_le16(value), ((__le16*)dev->dev_addr) + i);
+                        put_unaligned_le16(value, ((__le16 *)dev->dev_addr) + i);
                         sum += value & 0xffff;
                 }
         } else if (chip_idx == COMET) {
                 /* No need to read the EEPROM. */
-                put_unaligned(cpu_to_le32(ioread32(ioaddr + 0xA4)), (__le32 *)dev->dev_addr);
-                put_unaligned(cpu_to_le16(ioread32(ioaddr + 0xA8)), (__le16 *)(dev->dev_addr + 4));
+                put_unaligned_le32(ioread32(ioaddr + 0xA4), dev->dev_addr);
+                put_unaligned_le16(ioread32(ioaddr + 0xA8), dev->dev_addr + 4);
                 for (i = 0; i < 6; i ++)
                         sum += dev->dev_addr[i];
         } else {
diff --git a/drivers/net/wireless/airo.c b/drivers/net/wireless/airo.c
index 932d6b1c9d0b..45f47c1c0a35 100644
--- a/drivers/net/wireless/airo.c
+++ b/drivers/net/wireless/airo.c
@@ -3657,7 +3657,7 @@ void mpi_receive_802_11 (struct airo_info *ai)
         ptr += hdrlen;
         if (hdrlen == 24)
                 ptr += 6;
-        gap = le16_to_cpu(get_unaligned((__le16 *)ptr));
+        gap = get_unaligned_le16(ptr);
         ptr += sizeof(__le16);
         if (gap) {
                 if (gap <= 8)
@@ -4347,24 +4347,28 @@ static int proc_config_open( struct inode *inode, struct file *file );
 static int proc_wepkey_open( struct inode *inode, struct file *file );
 
 static const struct file_operations proc_statsdelta_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .open           = proc_statsdelta_open,
         .release        = proc_close
 };
 
 static const struct file_operations proc_stats_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .open           = proc_stats_open,
         .release        = proc_close
 };
 
 static const struct file_operations proc_status_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .open           = proc_status_open,
         .release        = proc_close
 };
 
 static const struct file_operations proc_SSID_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .write          = proc_write,
         .open           = proc_SSID_open,
@@ -4372,6 +4376,7 @@ static const struct file_operations proc_SSID_ops = {
 };
 
 static const struct file_operations proc_BSSList_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .write          = proc_write,
         .open           = proc_BSSList_open,
@@ -4379,6 +4384,7 @@ static const struct file_operations proc_BSSList_ops = {
 };
 
 static const struct file_operations proc_APList_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .write          = proc_write,
         .open           = proc_APList_open,
@@ -4386,6 +4392,7 @@ static const struct file_operations proc_APList_ops = {
 };
 
 static const struct file_operations proc_config_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .write          = proc_write,
         .open           = proc_config_open,
@@ -4393,6 +4400,7 @@ static const struct file_operations proc_config_ops = {
 };
 
 static const struct file_operations proc_wepkey_ops = {
+        .owner          = THIS_MODULE,
         .read           = proc_read,
         .write          = proc_write,
         .open           = proc_wepkey_open,
@@ -4411,10 +4419,6 @@ struct proc_data {
         void (*on_close) (struct inode *, struct file *);
 };
 
-#ifndef SETPROC_OPS
-#define SETPROC_OPS(entry, ops) (entry)->proc_fops = &(ops)
-#endif
-
 static int setup_proc_entry( struct net_device *dev,
                              struct airo_info *apriv ) {
         struct proc_dir_entry *entry;
@@ -4430,100 +4434,76 @@ static int setup_proc_entry( struct net_device *dev,
         apriv->proc_entry->owner = THIS_MODULE;
 
         /* Setup the StatsDelta */
-        entry = create_proc_entry("StatsDelta",
-                                  S_IFREG | (S_IRUGO&proc_perm),
-                                  apriv->proc_entry);
+        entry = proc_create_data("StatsDelta",
+                                 S_IFREG | (S_IRUGO&proc_perm),
+                                 apriv->proc_entry, &proc_statsdelta_ops, dev);
         if (!entry)
                 goto fail_stats_delta;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_statsdelta_ops);
 
         /* Setup the Stats */
-        entry = create_proc_entry("Stats",
-                                  S_IFREG | (S_IRUGO&proc_perm),
-                                  apriv->proc_entry);
+        entry = proc_create_data("Stats",
+                                 S_IFREG | (S_IRUGO&proc_perm),
+                                 apriv->proc_entry, &proc_stats_ops, dev);
         if (!entry)
                 goto fail_stats;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_stats_ops);
 
         /* Setup the Status */
-        entry = create_proc_entry("Status",
-                                  S_IFREG | (S_IRUGO&proc_perm),
-                                  apriv->proc_entry);
+        entry = proc_create_data("Status",
+                                 S_IFREG | (S_IRUGO&proc_perm),
+                                 apriv->proc_entry, &proc_status_ops, dev);
         if (!entry)
                 goto fail_status;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_status_ops);
 
         /* Setup the Config */
-        entry = create_proc_entry("Config",
-                                  S_IFREG | proc_perm,
-                                  apriv->proc_entry);
+        entry = proc_create_data("Config",
+                                 S_IFREG | proc_perm,
+                                 apriv->proc_entry, &proc_config_ops, dev);
         if (!entry)
                 goto fail_config;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_config_ops);
 
         /* Setup the SSID */
-        entry = create_proc_entry("SSID",
-                                  S_IFREG | proc_perm,
-                                  apriv->proc_entry);
+        entry = proc_create_data("SSID",
+                                 S_IFREG | proc_perm,
+                                 apriv->proc_entry, &proc_SSID_ops, dev);
         if (!entry)
                 goto fail_ssid;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_SSID_ops);
 
         /* Setup the APList */
-        entry = create_proc_entry("APList",
-                                  S_IFREG | proc_perm,
-                                  apriv->proc_entry);
+        entry = proc_create_data("APList",
+                                 S_IFREG | proc_perm,
+                                 apriv->proc_entry, &proc_APList_ops, dev);
         if (!entry)
                 goto fail_aplist;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_APList_ops);
 
         /* Setup the BSSList */
-        entry = create_proc_entry("BSSList",
-                                  S_IFREG | proc_perm,
-                                  apriv->proc_entry);
+        entry = proc_create_data("BSSList",
+                                 S_IFREG | proc_perm,
+                                 apriv->proc_entry, &proc_BSSList_ops, dev);
         if (!entry)
                 goto fail_bsslist;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_BSSList_ops);
 
         /* Setup the WepKey */
-        entry = create_proc_entry("WepKey",
-                                  S_IFREG | proc_perm,
-                                  apriv->proc_entry);
+        entry = proc_create_data("WepKey",
+                                 S_IFREG | proc_perm,
+                                 apriv->proc_entry, &proc_wepkey_ops, dev);
         if (!entry)
                 goto fail_wepkey;
         entry->uid = proc_uid;
         entry->gid = proc_gid;
-        entry->data = dev;
-        entry->owner = THIS_MODULE;
-        SETPROC_OPS(entry, proc_wepkey_ops);
 
         return 0;
 
@@ -5625,9 +5605,9 @@ static int __init airo_init_module( void )
         int have_isa_dev = 0;
 #endif
 
-        airo_entry = create_proc_entry("aironet",
+        airo_entry = create_proc_entry("driver/aironet",
                                        S_IFDIR | airo_perm,
-                                       proc_root_driver);
+                                       NULL);
 
         if (airo_entry) {
                 airo_entry->uid = proc_uid;
@@ -5651,7 +5631,7 @@ static int __init airo_init_module( void )
         airo_print_info("", "Finished probing for PCI adapters");
 
         if (i) {
-                remove_proc_entry("aironet", proc_root_driver);
+                remove_proc_entry("driver/aironet", NULL);
                 return i;
         }
 #endif
@@ -5673,7 +5653,7 @@ static void __exit airo_cleanup_module( void )
 #ifdef CONFIG_PCI
         pci_unregister_driver(&airo_driver);
 #endif
-        remove_proc_entry("aironet", proc_root_driver);
+        remove_proc_entry("driver/aironet", NULL);
 }
 
 /*
diff --git a/drivers/net/wireless/ath5k/base.c b/drivers/net/wireless/ath5k/base.c
index e18305b781c9..4e5c8fc35200 100644
--- a/drivers/net/wireless/ath5k/base.c
+++ b/drivers/net/wireless/ath5k/base.c
@@ -58,10 +58,6 @@
 #include "reg.h"
 #include "debug.h"
 
-/* unaligned little endian access */
-#define LE_READ_2(_p) (le16_to_cpu(get_unaligned((__le16 *)(_p))))
-#define LE_READ_4(_p) (le32_to_cpu(get_unaligned((__le32 *)(_p))))
-
 enum {
         ATH_LED_TX,
         ATH_LED_RX,
@@ -2909,9 +2905,9 @@ static void ath5k_configure_filter(struct ieee80211_hw *hw,
                         if (!mclist)
                                 break;
                         /* calculate XOR of eight 6-bit values */
-                        val = LE_READ_4(mclist->dmi_addr + 0);
+                        val = get_unaligned_le32(mclist->dmi_addr + 0);
                         pos = (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
-                        val = LE_READ_4(mclist->dmi_addr + 3);
+                        val = get_unaligned_le32(mclist->dmi_addr + 3);
                         pos ^= (val >> 18) ^ (val >> 12) ^ (val >> 6) ^ val;
                         pos &= 0x3f;
                         mfilt[pos / 32] |= (1 << (pos % 32));
diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index 4bf8a99099fe..8c24cd72aaca 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -2171,7 +2171,7 @@ static int b43_write_initvals(struct b43_wldev *dev,
                                 goto err_format;
                         array_size -= sizeof(iv->data.d32);
 
-                        value = be32_to_cpu(get_unaligned(&iv->data.d32));
+                        value = get_unaligned_be32(&iv->data.d32);
                         b43_write32(dev, offset, value);
 
                         iv = (const struct b43_iv *)((const uint8_t *)iv +
diff --git a/drivers/net/wireless/b43legacy/main.c b/drivers/net/wireless/b43legacy/main.c
index ef829ee8ffd4..14a5eea2573e 100644
--- a/drivers/net/wireless/b43legacy/main.c
+++ b/drivers/net/wireless/b43legacy/main.c
@@ -1720,7 +1720,7 @@ static int b43legacy_write_initvals(struct b43legacy_wldev *dev,
                                 goto err_format;
                         array_size -= sizeof(iv->data.d32);
 
-                        value = be32_to_cpu(get_unaligned(&iv->data.d32));
+                        value = get_unaligned_be32(&iv->data.d32);
                         b43legacy_write32(dev, offset, value);
 
                         iv = (const struct b43legacy_iv *)((const uint8_t *)iv +
diff --git a/drivers/net/wireless/iwlwifi/iwl-3945.c b/drivers/net/wireless/iwlwifi/iwl-3945.c
index 598e4eef4f40..d3406830c8e3 100644
--- a/drivers/net/wireless/iwlwifi/iwl-3945.c
+++ b/drivers/net/wireless/iwlwifi/iwl-3945.c
@@ -554,40 +554,36 @@ static void iwl3945_add_radiotap(struct iwl3945_priv *priv,
         iwl3945_rt->rt_hdr.it_pad = 0;
 
         /* total header + data */
-        put_unaligned(cpu_to_le16(sizeof(*iwl3945_rt)),
-                      &iwl3945_rt->rt_hdr.it_len);
+        put_unaligned_le16(sizeof(*iwl3945_rt), &iwl3945_rt->rt_hdr.it_len);
 
         /* Indicate all the fields we add to the radiotap header */
-        put_unaligned(cpu_to_le32((1 << IEEE80211_RADIOTAP_TSFT) |
-                                  (1 << IEEE80211_RADIOTAP_FLAGS) |
-                                  (1 << IEEE80211_RADIOTAP_RATE) |
-                                  (1 << IEEE80211_RADIOTAP_CHANNEL) |
-                                  (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
-                                  (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
-                                  (1 << IEEE80211_RADIOTAP_ANTENNA)),
-                      &iwl3945_rt->rt_hdr.it_present);
+        put_unaligned_le32((1 << IEEE80211_RADIOTAP_TSFT) |
+                           (1 << IEEE80211_RADIOTAP_FLAGS) |
+                           (1 << IEEE80211_RADIOTAP_RATE) |
+                           (1 << IEEE80211_RADIOTAP_CHANNEL) |
+                           (1 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL) |
+                           (1 << IEEE80211_RADIOTAP_DBM_ANTNOISE) |
+                           (1 << IEEE80211_RADIOTAP_ANTENNA),
+                        &iwl3945_rt->rt_hdr.it_present);
 
         /* Zero the flags, we'll add to them as we go */
         iwl3945_rt->rt_flags = 0;
 
-        put_unaligned(cpu_to_le64(tsf), &iwl3945_rt->rt_tsf);
+        put_unaligned_le64(tsf, &iwl3945_rt->rt_tsf);
 
         iwl3945_rt->rt_dbmsignal = signal;
         iwl3945_rt->rt_dbmnoise = noise;
 
         /* Convert the channel frequency and set the flags */
-        put_unaligned(cpu_to_le16(stats->freq), &iwl3945_rt->rt_channelMHz);
+        put_unaligned_le16(stats->freq, &iwl3945_rt->rt_channelMHz);
         if (!(phy_flags_hw & RX_RES_PHY_FLAGS_BAND_24_MSK))
-                put_unaligned(cpu_to_le16(IEEE80211_CHAN_OFDM |
-                                          IEEE80211_CHAN_5GHZ),
+                put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ,
                               &iwl3945_rt->rt_chbitmask);
         else if (phy_flags_hw & RX_RES_PHY_FLAGS_MOD_CCK_MSK)
-                put_unaligned(cpu_to_le16(IEEE80211_CHAN_CCK |
-                                          IEEE80211_CHAN_2GHZ),
+                put_unaligned_le16(IEEE80211_CHAN_CCK | IEEE80211_CHAN_2GHZ,
                               &iwl3945_rt->rt_chbitmask);
         else    /* 802.11g */
-                put_unaligned(cpu_to_le16(IEEE80211_CHAN_OFDM |
-                                          IEEE80211_CHAN_2GHZ),
+                put_unaligned_le16(IEEE80211_CHAN_OFDM | IEEE80211_CHAN_2GHZ,
                               &iwl3945_rt->rt_chbitmask);
 
         if (rate == -1)
diff --git a/drivers/net/wireless/libertas/scan.c b/drivers/net/wireless/libertas/scan.c
index e72c97a0d6c1..1a409fcc80d3 100644
--- a/drivers/net/wireless/libertas/scan.c
+++ b/drivers/net/wireless/libertas/scan.c
@@ -522,7 +522,7 @@ static int lbs_process_bss(struct bss_descriptor *bss,
 
         if (*bytesleft >= sizeof(beaconsize)) {
                 /* Extract & convert beacon size from the command buffer */
-                beaconsize = le16_to_cpu(get_unaligned((__le16 *)*pbeaconinfo));
+                beaconsize = get_unaligned_le16(*pbeaconinfo);
                 *bytesleft -= sizeof(beaconsize);
                 *pbeaconinfo += sizeof(beaconsize);
         }
diff --git a/drivers/net/wireless/zd1211rw/zd_usb.c b/drivers/net/wireless/zd1211rw/zd_usb.c
index e34675c2f8fc..5316074f39f0 100644
--- a/drivers/net/wireless/zd1211rw/zd_usb.c
+++ b/drivers/net/wireless/zd1211rw/zd_usb.c
@@ -545,11 +545,11 @@ static void handle_rx_packet(struct zd_usb *usb, const u8 *buffer,
          * be padded. Unaligned access might also happen if the length_info
          * structure is not present.
          */
-        if (get_unaligned(&length_info->tag) == cpu_to_le16(RX_LENGTH_INFO_TAG))
+        if (get_unaligned_le16(&length_info->tag) == RX_LENGTH_INFO_TAG)
         {
                 unsigned int l, k, n;
                 for (i = 0, l = 0;; i++) {
-                        k = le16_to_cpu(get_unaligned(&length_info->length[i]));
+                        k = get_unaligned_le16(&length_info->length[i]);
                         if (k == 0)
                                 return;
                         n = l+k;
diff --git a/drivers/net/yellowfin.c b/drivers/net/yellowfin.c
index 24640726f8bb..57e1f495b9fc 100644
--- a/drivers/net/yellowfin.c
+++ b/drivers/net/yellowfin.c
@@ -1062,7 +1062,7 @@ static int yellowfin_rx(struct net_device *dev)
                 buf_addr = rx_skb->data;
                 data_size = (le32_to_cpu(desc->dbdma_cmd) -
                         le32_to_cpu(desc->result_status)) & 0xffff;
-                frame_status = le16_to_cpu(get_unaligned((__le16*)&(buf_addr[data_size - 2])));
+                frame_status = get_unaligned_le16(&(buf_addr[data_size - 2]));
                 if (yellowfin_debug > 4)
                         printk(KERN_DEBUG "  yellowfin_rx() status was %4.4x.\n",
                                    frame_status);
diff --git a/drivers/nubus/proc.c b/drivers/nubus/proc.c
index e07492be1f4a..208dd12825bc 100644
--- a/drivers/nubus/proc.c
+++ b/drivers/nubus/proc.c
@@ -21,6 +21,7 @@
 #include <linux/kernel.h>
 #include <linux/nubus.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/init.h>
 #include <linux/module.h>
 
@@ -28,38 +29,36 @@
 #include <asm/byteorder.h>
 
 static int
-get_nubus_dev_info(char *buf, char **start, off_t pos, int count)
+nubus_devices_proc_show(struct seq_file *m, void *v)
 {
         struct nubus_dev *dev = nubus_devices;
-        off_t at = 0;
-        int len, cnt;
 
-        cnt = 0;
-        while (dev && count > cnt) {
-                len = sprintf(buf, "%x\t%04x %04x %04x %04x",
+        while (dev) {
+                seq_printf(m, "%x\t%04x %04x %04x %04x",
                               dev->board->slot,
                               dev->category,
                               dev->type,
                               dev->dr_sw,
                               dev->dr_hw);
-                len += sprintf(buf+len,
-                               "\t%08lx",
-                               dev->board->slot_addr);
-                buf[len++] = '\n';
-                at += len;
-                if (at >= pos) {
-                        if (!*start) {
-                                *start = buf + (pos - (at - len));
-                                cnt = at - pos;
-                        } else
-                                cnt += len;
-                        buf += len;
-                }
+                seq_printf(m, "\t%08lx\n", dev->board->slot_addr);
                 dev = dev->next;
         }
-        return (count > cnt) ? cnt : count;
+        return 0;
+}
+
+static int nubus_devices_proc_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, nubus_devices_proc_show, NULL);
 }
 
+static const struct file_operations nubus_devices_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = nubus_devices_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 static struct proc_dir_entry *proc_bus_nubus_dir;
 
 static void nubus_proc_subdir(struct nubus_dev* dev,
@@ -171,8 +170,7 @@ void __init nubus_proc_init(void)
 {
         if (!MACH_IS_MAC)
                 return;
-        proc_bus_nubus_dir = proc_mkdir("nubus", proc_bus);
-        create_proc_info_entry("devices", 0, proc_bus_nubus_dir,
-                                get_nubus_dev_info);
+        proc_bus_nubus_dir = proc_mkdir("bus/nubus", NULL);
+        proc_create("devices", 0, proc_bus_nubus_dir, &nubus_devices_proc_fops);
         proc_bus_nubus_add_devices();
 }
diff --git a/drivers/parisc/ccio-dma.c b/drivers/parisc/ccio-dma.c
index 62db3c3fe4dc..07d2a8d4498f 100644
--- a/drivers/parisc/ccio-dma.c
+++ b/drivers/parisc/ccio-dma.c
@@ -1551,8 +1551,7 @@ static int __init ccio_probe(struct parisc_device *dev)
 {
         int i;
         struct ioc *ioc, **ioc_p = &ioc_list;
-        struct proc_dir_entry *info_entry, *bitmap_entry;
-        
+
         ioc = kzalloc(sizeof(struct ioc), GFP_KERNEL);
         if (ioc == NULL) {
                 printk(KERN_ERR MODULE_NAME ": memory allocation failure\n");
@@ -1580,13 +1579,10 @@ static int __init ccio_probe(struct parisc_device *dev)
         HBA_DATA(dev->dev.platform_data)->iommu = ioc;
         
         if (ioc_count == 0) {
-                info_entry = create_proc_entry(MODULE_NAME, 0, proc_runway_root);
-                if (info_entry)
-                        info_entry->proc_fops = &ccio_proc_info_fops;
-
-                bitmap_entry = create_proc_entry(MODULE_NAME"-bitmap", 0, proc_runway_root);
-                if (bitmap_entry)
-                        bitmap_entry->proc_fops = &ccio_proc_bitmap_fops;
+                proc_create(MODULE_NAME, 0, proc_runway_root,
+                            &ccio_proc_info_fops);
+                proc_create(MODULE_NAME"-bitmap", 0, proc_runway_root,
+                            &ccio_proc_bitmap_fops);
         }
 
         ioc_count++;
diff --git a/drivers/parisc/sba_iommu.c b/drivers/parisc/sba_iommu.c
index 8c4d2c13d5f2..afc849bd3f58 100644
--- a/drivers/parisc/sba_iommu.c
+++ b/drivers/parisc/sba_iommu.c
@@ -1895,7 +1895,9 @@ sba_driver_callback(struct parisc_device *dev)
         int i;
         char *version;
         void __iomem *sba_addr = ioremap_nocache(dev->hpa.start, SBA_FUNC_SIZE);
-        struct proc_dir_entry *info_entry, *bitmap_entry, *root;
+#ifdef CONFIG_PROC_FS
+        struct proc_dir_entry *root;
+#endif
 
         sba_dump_ranges(sba_addr);
 
@@ -1973,14 +1975,8 @@ sba_driver_callback(struct parisc_device *dev)
                 break;
         }
 
-        info_entry = create_proc_entry("sba_iommu", 0, root);
-        bitmap_entry = create_proc_entry("sba_iommu-bitmap", 0, root);
-
-        if (info_entry)
-                info_entry->proc_fops = &sba_proc_fops;
-
-        if (bitmap_entry)
-                bitmap_entry->proc_fops = &sba_proc_bitmap_fops;
+        proc_create("sba_iommu", 0, root, &sba_proc_fops);
+        proc_create("sba_iommu-bitmap", 0, root, &sba_proc_bitmap_fops);
 #endif
 
         parisc_vmerge_boundary = IOVP_SIZE;
diff --git a/drivers/parport/parport_pc.c b/drivers/parport/parport_pc.c
index a85808938205..e71092e80288 100644
--- a/drivers/parport/parport_pc.c
+++ b/drivers/parport/parport_pc.c
@@ -3082,6 +3082,7 @@ static struct pci_driver parport_pc_pci_driver;
 static int __init parport_pc_init_superio(int autoirq, int autodma) {return 0;}
 #endif /* CONFIG_PCI */
 
+#ifdef CONFIG_PNP
 
 static const struct pnp_device_id parport_pc_pnp_tbl[] = {
         /* Standard LPT Printer Port */
@@ -3148,6 +3149,9 @@ static struct pnp_driver parport_pc_pnp_driver = {
         .remove         = parport_pc_pnp_remove,
 };
 
+#else
+static struct pnp_driver parport_pc_pnp_driver;
+#endif /* CONFIG_PNP */
 
 static int __devinit parport_pc_platform_probe(struct platform_device *pdev)
 {
diff --git a/drivers/pci/proc.c b/drivers/pci/proc.c
index ef18fcd641e2..963a97642ae9 100644
--- a/drivers/pci/proc.c
+++ b/drivers/pci/proc.c
@@ -293,6 +293,7 @@ static int proc_bus_pci_release(struct inode *inode, struct file *file)
 #endif /* HAVE_PCI_MMAP */
 
 static const struct file_operations proc_bus_pci_operations = {
+        .owner          = THIS_MODULE,
         .llseek         = proc_bus_pci_lseek,
         .read           = proc_bus_pci_read,
         .write          = proc_bus_pci_write,
@@ -406,11 +407,10 @@ int pci_proc_attach_device(struct pci_dev *dev)
         }
 
         sprintf(name, "%02x.%x", PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn));
-        e = create_proc_entry(name, S_IFREG | S_IRUGO | S_IWUSR, bus->procdir);
+        e = proc_create_data(name, S_IFREG | S_IRUGO | S_IWUSR, bus->procdir,
+                             &proc_bus_pci_operations, dev);
         if (!e)
                 return -ENOMEM;
-        e->proc_fops = &proc_bus_pci_operations;
-        e->data = dev;
         e->size = dev->cfg_size;
         dev->procent = e;
 
@@ -462,6 +462,7 @@ static int proc_bus_pci_dev_open(struct inode *inode, struct file *file)
         return seq_open(file, &proc_bus_pci_devices_op);
 }
 static const struct file_operations proc_bus_pci_dev_operations = {
+        .owner          = THIS_MODULE,
         .open           = proc_bus_pci_dev_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -470,12 +471,10 @@ static const struct file_operations proc_bus_pci_dev_operations = {
 
 static int __init pci_proc_init(void)
 {
-        struct proc_dir_entry *entry;
         struct pci_dev *dev = NULL;
-        proc_bus_pci_dir = proc_mkdir("pci", proc_bus);
-        entry = create_proc_entry("devices", 0, proc_bus_pci_dir);
-        if (entry)
-                entry->proc_fops = &proc_bus_pci_dev_operations;
+        proc_bus_pci_dir = proc_mkdir("bus/pci", NULL);
+        proc_create("devices", 0, proc_bus_pci_dir,
+                    &proc_bus_pci_dev_operations);
         proc_initialized = 1;
         while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
                 pci_proc_attach_device(dev);
diff --git a/drivers/pcmcia/cistpl.c b/drivers/pcmcia/cistpl.c
index 06a85d7d5aa2..36379535f9da 100644
--- a/drivers/pcmcia/cistpl.c
+++ b/drivers/pcmcia/cistpl.c
@@ -402,15 +402,6 @@ EXPORT_SYMBOL(pcmcia_replace_cis);
     
 ======================================================================*/
 
-static inline u16 cis_get_u16(void *ptr)
-{
-        return le16_to_cpu(get_unaligned((__le16 *) ptr));
-}
-static inline u32 cis_get_u32(void *ptr)
-{
-        return le32_to_cpu(get_unaligned((__le32 *) ptr));
-}
-
 typedef struct tuple_flags {
     u_int               link_space:4;
     u_int               has_link:1;
@@ -471,7 +462,7 @@ static int follow_link(struct pcmcia_socket *s, tuple_t *tuple)
         /* Get indirect link from the MFC tuple */
         read_cis_cache(s, LINK_SPACE(tuple->Flags),
                        tuple->LinkOffset, 5, link);
-        ofs = cis_get_u32(link + 1);
+        ofs = get_unaligned_le32(link + 1);
         SPACE(tuple->Flags) = (link[0] == CISTPL_MFC_ATTR);
         /* Move to the next indirect link */
         tuple->LinkOffset += 5;
@@ -679,8 +670,8 @@ static int parse_checksum(tuple_t *tuple, cistpl_checksum_t *csum)
     if (tuple->TupleDataLen < 5)
         return CS_BAD_TUPLE;
     p = (u_char *) tuple->TupleData;
-    csum->addr = tuple->CISOffset + cis_get_u16(p) - 2;
-    csum->len = cis_get_u16(p + 2);
+    csum->addr = tuple->CISOffset + get_unaligned_le16(p) - 2;
+    csum->len = get_unaligned_le16(p + 2);
     csum->sum = *(p + 4);
     return CS_SUCCESS;
 }
@@ -691,7 +682,7 @@ static int parse_longlink(tuple_t *tuple, cistpl_longlink_t *link)
 {
     if (tuple->TupleDataLen < 4)
         return CS_BAD_TUPLE;
-    link->addr = cis_get_u32(tuple->TupleData);
+    link->addr = get_unaligned_le32(tuple->TupleData);
     return CS_SUCCESS;
 }
 
@@ -710,7 +701,7 @@ static int parse_longlink_mfc(tuple_t *tuple,
         return CS_BAD_TUPLE;
     for (i = 0; i < link->nfn; i++) {
         link->fn[i].space = *p; p++;
-        link->fn[i].addr = cis_get_u32(p);
+        link->fn[i].addr = get_unaligned_le32(p);
         p += 4;
     }
     return CS_SUCCESS;
@@ -800,8 +791,8 @@ static int parse_manfid(tuple_t *tuple, cistpl_manfid_t *m)
 {
     if (tuple->TupleDataLen < 4)
         return CS_BAD_TUPLE;
-    m->manf = cis_get_u16(tuple->TupleData);
-    m->card = cis_get_u16(tuple->TupleData + 2);
+    m->manf = get_unaligned_le16(tuple->TupleData);
+    m->card = get_unaligned_le16(tuple->TupleData + 2);
     return CS_SUCCESS;
 }
 
@@ -1100,7 +1091,7 @@ static int parse_cftable_entry(tuple_t *tuple,
         break;
     case 0x20:
         entry->mem.nwin = 1;
-        entry->mem.win[0].len = cis_get_u16(p) << 8;
+        entry->mem.win[0].len = get_unaligned_le16(p) << 8;
         entry->mem.win[0].card_addr = 0;
         entry->mem.win[0].host_addr = 0;
         p += 2;
@@ -1108,8 +1099,8 @@ static int parse_cftable_entry(tuple_t *tuple,
         break;
     case 0x40:
         entry->mem.nwin = 1;
-        entry->mem.win[0].len = cis_get_u16(p) << 8;
-        entry->mem.win[0].card_addr = cis_get_u16(p + 2) << 8;
+        entry->mem.win[0].len = get_unaligned_le16(p) << 8;
+        entry->mem.win[0].card_addr = get_unaligned_le16(p + 2) << 8;
         entry->mem.win[0].host_addr = 0;
         p += 4;
         if (p > q) return CS_BAD_TUPLE;
@@ -1146,7 +1137,7 @@ static int parse_bar(tuple_t *tuple, cistpl_bar_t *bar)
     p = (u_char *)tuple->TupleData;
     bar->attr = *p;
     p += 2;
-    bar->size = cis_get_u32(p);
+    bar->size = get_unaligned_le32(p);
     return CS_SUCCESS;
 }
 
@@ -1159,7 +1150,7 @@ static int parse_config_cb(tuple_t *tuple, cistpl_config_t *config)
         return CS_BAD_TUPLE;
     config->last_idx = *(++p);
     p++;
-    config->base = cis_get_u32(p);
+    config->base = get_unaligned_le32(p);
     config->subtuples = tuple->TupleDataLen - 6;
     return CS_SUCCESS;
 }
@@ -1275,7 +1266,7 @@ static int parse_vers_2(tuple_t *tuple, cistpl_vers_2_t *v2)
 
     v2->vers = p[0];
     v2->comply = p[1];
-    v2->dindex = cis_get_u16(p +2 );
+    v2->dindex = get_unaligned_le16(p +2 );
     v2->vspec8 = p[6];
     v2->vspec9 = p[7];
     v2->nhdr = p[8];
@@ -1316,8 +1307,8 @@ static int parse_format(tuple_t *tuple, cistpl_format_t *fmt)
 
     fmt->type = p[0];
     fmt->edc = p[1];
-    fmt->offset = cis_get_u32(p + 2);
-    fmt->length = cis_get_u32(p + 6);
+    fmt->offset = get_unaligned_le32(p + 2);
+    fmt->length = get_unaligned_le32(p + 6);
 
     return CS_SUCCESS;
 }
diff --git a/drivers/pnp/isapnp/proc.c b/drivers/pnp/isapnp/proc.c
index 2b8266c3d40f..3f94edab25fa 100644
--- a/drivers/pnp/isapnp/proc.c
+++ b/drivers/pnp/isapnp/proc.c
@@ -85,6 +85,7 @@ static ssize_t isapnp_proc_bus_read(struct file *file, char __user * buf,
 }
 
 static const struct file_operations isapnp_proc_bus_file_operations = {
+        .owner  = THIS_MODULE,
         .llseek = isapnp_proc_bus_lseek,
         .read = isapnp_proc_bus_read,
 };
@@ -102,12 +103,10 @@ static int isapnp_proc_attach_device(struct pnp_dev *dev)
                         return -ENOMEM;
         }
         sprintf(name, "%02x", dev->number);
-        e = dev->procent = create_proc_entry(name, S_IFREG | S_IRUGO, de);
+        e = dev->procent = proc_create_data(name, S_IFREG | S_IRUGO, de,
+                        &isapnp_proc_bus_file_operations, dev);
         if (!e)
                 return -ENOMEM;
-        e->proc_fops = &isapnp_proc_bus_file_operations;
-        e->owner = THIS_MODULE;
-        e->data = dev;
         e->size = 256;
         return 0;
 }
@@ -116,7 +115,7 @@ int __init isapnp_proc_init(void)
 {
         struct pnp_dev *dev;
 
-        isapnp_proc_bus_dir = proc_mkdir("isapnp", proc_bus);
+        isapnp_proc_bus_dir = proc_mkdir("bus/isapnp", NULL);
         protocol_for_each_dev(&isapnp_protocol, dev) {
                 isapnp_proc_attach_device(dev);
         }
diff --git a/drivers/pnp/pnpbios/proc.c b/drivers/pnp/pnpbios/proc.c
index bb19bc957bad..46d506f66259 100644
--- a/drivers/pnp/pnpbios/proc.c
+++ b/drivers/pnp/pnpbios/proc.c
@@ -256,7 +256,7 @@ int pnpbios_interface_attach_device(struct pnp_bios_node *node)
  */
 int __init pnpbios_proc_init(void)
 {
-        proc_pnp = proc_mkdir("pnp", proc_bus);
+        proc_pnp = proc_mkdir("bus/pnp", NULL);
         if (!proc_pnp)
                 return -EIO;
         proc_pnp_boot = proc_mkdir("boot", proc_pnp);
@@ -294,5 +294,5 @@ void __exit pnpbios_proc_exit(void)
         remove_proc_entry("configuration_info", proc_pnp);
         remove_proc_entry("devices", proc_pnp);
         remove_proc_entry("boot", proc_pnp);
-        remove_proc_entry("pnp", proc_bus);
+        remove_proc_entry("bus/pnp", NULL);
 }
diff --git a/drivers/power/ds2760_battery.c b/drivers/power/ds2760_battery.c
index bdb9b7285b3d..71be36f18709 100644
--- a/drivers/power/ds2760_battery.c
+++ b/drivers/power/ds2760_battery.c
@@ -262,7 +262,7 @@ static void ds2760_battery_work(struct work_struct *work)
                 struct ds2760_device_info, monitor_work.work);
         const int interval = HZ * 60;
 
-        dev_dbg(di->dev, "%s\n", __FUNCTION__);
+        dev_dbg(di->dev, "%s\n", __func__);
 
         ds2760_battery_update_status(di);
         queue_delayed_work(di->monitor_wqueue, &di->monitor_work, interval);
@@ -275,7 +275,7 @@ static void ds2760_battery_external_power_changed(struct power_supply *psy)
 {
         struct ds2760_device_info *di = to_ds2760_device_info(psy);
 
-        dev_dbg(di->dev, "%s\n", __FUNCTION__);
+        dev_dbg(di->dev, "%s\n", __func__);
 
         cancel_delayed_work(&di->monitor_work);
         queue_delayed_work(di->monitor_wqueue, &di->monitor_work, HZ/10);
diff --git a/drivers/power/olpc_battery.c b/drivers/power/olpc_battery.c
index af7a231092a4..ab1e8289f07f 100644
--- a/drivers/power/olpc_battery.c
+++ b/drivers/power/olpc_battery.c
@@ -315,7 +315,6 @@ static int __init olpc_bat_init(void)
         if (ret)
                 goto battery_failed;
 
-        olpc_register_battery_callback(&olpc_battery_trigger_uevent);
         goto success;
 
 battery_failed:
@@ -328,7 +327,6 @@ success:
 
 static void __exit olpc_bat_exit(void)
 {
-        olpc_deregister_battery_callback();
         power_supply_unregister(&olpc_bat);
         power_supply_unregister(&olpc_ac);
         platform_device_unregister(bat_pdev);
diff --git a/drivers/power/power_supply_core.c b/drivers/power/power_supply_core.c
index 03d6a38464ef..138dd76ee347 100644
--- a/drivers/power/power_supply_core.c
+++ b/drivers/power/power_supply_core.c
@@ -39,7 +39,7 @@ static void power_supply_changed_work(struct work_struct *work)
         struct power_supply *psy = container_of(work, struct power_supply,
                                                 changed_work);
 
-        dev_dbg(psy->dev, "%s\n", __FUNCTION__);
+        dev_dbg(psy->dev, "%s\n", __func__);
 
         class_for_each_device(power_supply_class, psy,
                               __power_supply_changed_work);
@@ -51,7 +51,7 @@ static void power_supply_changed_work(struct work_struct *work)
 
 void power_supply_changed(struct power_supply *psy)
 {
-        dev_dbg(psy->dev, "%s\n", __FUNCTION__);
+        dev_dbg(psy->dev, "%s\n", __func__);
 
         schedule_work(&psy->changed_work);
 }
@@ -82,7 +82,7 @@ int power_supply_am_i_supplied(struct power_supply *psy)
         error = class_for_each_device(power_supply_class, psy,
                                       __power_supply_am_i_supplied);
 
-        dev_dbg(psy->dev, "%s %d\n", __FUNCTION__, error);
+        dev_dbg(psy->dev, "%s %d\n", __func__, error);
 
         return error;
 }
diff --git a/drivers/power/power_supply_leds.c b/drivers/power/power_supply_leds.c
index fa3034f85c38..2dece40c544f 100644
--- a/drivers/power/power_supply_leds.c
+++ b/drivers/power/power_supply_leds.c
@@ -24,7 +24,7 @@ static void power_supply_update_bat_leds(struct power_supply *psy)
         if (psy->get_property(psy, POWER_SUPPLY_PROP_STATUS, &status))
                 return;
 
-        dev_dbg(psy->dev, "%s %d\n", __FUNCTION__, status.intval);
+        dev_dbg(psy->dev, "%s %d\n", __func__, status.intval);
 
         switch (status.intval) {
         case POWER_SUPPLY_STATUS_FULL:
@@ -101,7 +101,7 @@ static void power_supply_update_gen_leds(struct power_supply *psy)
         if (psy->get_property(psy, POWER_SUPPLY_PROP_ONLINE, &online))
                 return;
 
-        dev_dbg(psy->dev, "%s %d\n", __FUNCTION__, online.intval);
+        dev_dbg(psy->dev, "%s %d\n", __func__, online.intval);
 
         if (online.intval)
                 led_trigger_event(psy->online_trig, LED_FULL);
diff --git a/drivers/rtc/rtc-bfin.c b/drivers/rtc/rtc-bfin.c
index 4f28045d9ef2..8624f55d0560 100644
--- a/drivers/rtc/rtc-bfin.c
+++ b/drivers/rtc/rtc-bfin.c
@@ -419,7 +419,7 @@ static int __devinit bfin_rtc_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         rtc->rtc_dev = rtc_device_register(pdev->name, &pdev->dev, &bfin_rtc_ops, THIS_MODULE);
-        if (unlikely(IS_ERR(rtc))) {
+        if (IS_ERR(rtc)) {
                 ret = PTR_ERR(rtc->rtc_dev);
                 goto err;
         }
diff --git a/drivers/rtc/rtc-proc.c b/drivers/rtc/rtc-proc.c
index 8d300e6d0d9e..0c6257a034ff 100644
--- a/drivers/rtc/rtc-proc.c
+++ b/drivers/rtc/rtc-proc.c
@@ -108,12 +108,10 @@ void rtc_proc_add_device(struct rtc_device *rtc)
         if (rtc->id == 0) {
                 struct proc_dir_entry *ent;
 
-                ent = create_proc_entry("driver/rtc", 0, NULL);
-                if (ent) {
-                        ent->proc_fops = &rtc_proc_fops;
+                ent = proc_create_data("driver/rtc", 0, NULL,
+                                       &rtc_proc_fops, rtc);
+                if (ent)
                         ent->owner = rtc->owner;
-                        ent->data = rtc;
-                }
         }
 }
 
diff --git a/drivers/s390/block/dasd_proc.c b/drivers/s390/block/dasd_proc.c
index 556063e8f7a9..03c0e40a92ff 100644
--- a/drivers/s390/block/dasd_proc.c
+++ b/drivers/s390/block/dasd_proc.c
@@ -157,6 +157,7 @@ static int dasd_devices_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations dasd_devices_file_ops = {
+        .owner          = THIS_MODULE,
         .open           = dasd_devices_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -311,17 +312,16 @@ out_error:
 int
 dasd_proc_init(void)
 {
-        dasd_proc_root_entry = proc_mkdir("dasd", &proc_root);
+        dasd_proc_root_entry = proc_mkdir("dasd", NULL);
         if (!dasd_proc_root_entry)
                 goto out_nodasd;
         dasd_proc_root_entry->owner = THIS_MODULE;
-        dasd_devices_entry = create_proc_entry("devices",
-                                               S_IFREG | S_IRUGO | S_IWUSR,
-                                               dasd_proc_root_entry);
+        dasd_devices_entry = proc_create("devices",
+                                         S_IFREG | S_IRUGO | S_IWUSR,
+                                         dasd_proc_root_entry,
+                                         &dasd_devices_file_ops);
         if (!dasd_devices_entry)
                 goto out_nodevices;
-        dasd_devices_entry->proc_fops = &dasd_devices_file_ops;
-        dasd_devices_entry->owner = THIS_MODULE;
         dasd_statistics_entry = create_proc_entry("statistics",
                                                   S_IFREG | S_IRUGO | S_IWUSR,
                                                   dasd_proc_root_entry);
@@ -335,7 +335,7 @@ dasd_proc_init(void)
  out_nostatistics:
         remove_proc_entry("devices", dasd_proc_root_entry);
  out_nodevices:
-        remove_proc_entry("dasd", &proc_root);
+        remove_proc_entry("dasd", NULL);
  out_nodasd:
         return -ENOENT;
 }
@@ -345,5 +345,5 @@ dasd_proc_exit(void)
 {
         remove_proc_entry("devices", dasd_proc_root_entry);
         remove_proc_entry("statistics", dasd_proc_root_entry);
-        remove_proc_entry("dasd", &proc_root);
+        remove_proc_entry("dasd", NULL);
 }
diff --git a/drivers/s390/char/tape_proc.c b/drivers/s390/char/tape_proc.c
index c9b96d51b28f..e7c888c14e71 100644
--- a/drivers/s390/char/tape_proc.c
+++ b/drivers/s390/char/tape_proc.c
@@ -111,6 +111,7 @@ static int tape_proc_open(struct inode *inode, struct file *file)
 
 static const struct file_operations tape_proc_ops =
 {
+        .owner          = THIS_MODULE,
         .open           = tape_proc_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -124,14 +125,12 @@ void
 tape_proc_init(void)
 {
         tape_proc_devices =
-                create_proc_entry ("tapedevices", S_IFREG | S_IRUGO | S_IWUSR,
-                                   &proc_root);
+                proc_create("tapedevices", S_IFREG | S_IRUGO | S_IWUSR, NULL,
+                            &tape_proc_ops);
         if (tape_proc_devices == NULL) {
                 PRINT_WARN("tape: Cannot register procfs entry tapedevices\n");
                 return;
         }
-        tape_proc_devices->proc_fops = &tape_proc_ops;
-        tape_proc_devices->owner = THIS_MODULE;
 }
 
 /*
@@ -141,5 +140,5 @@ void
 tape_proc_cleanup(void)
 {
         if (tape_proc_devices != NULL)
-                remove_proc_entry ("tapedevices", &proc_root);
+                remove_proc_entry ("tapedevices", NULL);
 }
diff --git a/drivers/s390/cio/blacklist.c b/drivers/s390/cio/blacklist.c
index e8597ec92247..40ef948fcb3a 100644
--- a/drivers/s390/cio/blacklist.c
+++ b/drivers/s390/cio/blacklist.c
@@ -374,13 +374,10 @@ cio_ignore_proc_init (void)
 {
         struct proc_dir_entry *entry;
 
-        entry = create_proc_entry ("cio_ignore", S_IFREG | S_IRUGO | S_IWUSR,
-                                   &proc_root);
+        entry = proc_create("cio_ignore", S_IFREG | S_IRUGO | S_IWUSR, NULL,
+                            &cio_ignore_proc_fops);
         if (!entry)
                 return -ENOENT;
-
-        entry->proc_fops = &cio_ignore_proc_fops;
-
         return 0;
 }
 
diff --git a/drivers/s390/cio/qdio.c b/drivers/s390/cio/qdio.c
index 10aa1e780801..43876e287370 100644
--- a/drivers/s390/cio/qdio.c
+++ b/drivers/s390/cio/qdio.c
@@ -3632,7 +3632,7 @@ qdio_add_procfs_entry(void)
 {
         proc_perf_file_registration=0;
         qdio_perf_proc_file=create_proc_entry(QDIO_PERF,
-                                              S_IFREG|0444,&proc_root);
+                                              S_IFREG|0444,NULL);
         if (qdio_perf_proc_file) {
                 qdio_perf_proc_file->read_proc=&qdio_perf_procfile_read;
         } else proc_perf_file_registration=-1;
@@ -3647,7 +3647,7 @@ static void
 qdio_remove_procfs_entry(void)
 {
         if (!proc_perf_file_registration) /* means if it went ok earlier */
-                remove_proc_entry(QDIO_PERF,&proc_root);
+                remove_proc_entry(QDIO_PERF,NULL);
 }
 
 /**
diff --git a/drivers/scsi/megaraid.c b/drivers/scsi/megaraid.c
index b135a1ed4b2c..18551aaf5e09 100644
--- a/drivers/scsi/megaraid.c
+++ b/drivers/scsi/megaraid.c
@@ -4996,7 +4996,7 @@ static int __init megaraid_init(void)
                 max_mbox_busy_wait = MBOX_BUSY_WAIT;
 
 #ifdef CONFIG_PROC_FS
-        mega_proc_dir_entry = proc_mkdir("megaraid", &proc_root);
+        mega_proc_dir_entry = proc_mkdir("megaraid", NULL);
         if (!mega_proc_dir_entry) {
                 printk(KERN_WARNING
                                 "megaraid: failed to create megaraid root\n");
@@ -5005,7 +5005,7 @@ static int __init megaraid_init(void)
         error = pci_register_driver(&megaraid_pci_driver);
         if (error) {
 #ifdef CONFIG_PROC_FS
-                remove_proc_entry("megaraid", &proc_root);
+                remove_proc_entry("megaraid", NULL);
 #endif
                 return error;
         }
@@ -5035,7 +5035,7 @@ static void __exit megaraid_exit(void)
         pci_unregister_driver(&megaraid_pci_driver);
 
 #ifdef CONFIG_PROC_FS
-        remove_proc_entry("megaraid", &proc_root);
+        remove_proc_entry("megaraid", NULL);
 #endif
 }
 
diff --git a/drivers/scsi/scsi_devinfo.c b/drivers/scsi/scsi_devinfo.c
index b8de041bc0ae..a235802f2981 100644
--- a/drivers/scsi/scsi_devinfo.c
+++ b/drivers/scsi/scsi_devinfo.c
@@ -449,37 +449,40 @@ int scsi_get_device_flags(struct scsi_device *sdev,
 }
 
 #ifdef CONFIG_SCSI_PROC_FS
-/* 
- * proc_scsi_dev_info_read: dump the scsi_dev_info_list via
- * /proc/scsi/device_info
- */
-static int proc_scsi_devinfo_read(char *buffer, char **start,
-                                  off_t offset, int length)
+static int devinfo_seq_show(struct seq_file *m, void *v)
 {
-        struct scsi_dev_info_list *devinfo;
-        int size, len = 0;
-        off_t begin = 0;
-        off_t pos = 0;
+        struct scsi_dev_info_list *devinfo =
+                list_entry(v, struct scsi_dev_info_list, dev_info_list);
 
-        list_for_each_entry(devinfo, &scsi_dev_info_list, dev_info_list) {
-                size = sprintf(buffer + len, "'%.8s' '%.16s' 0x%x\n",
+        seq_printf(m, "'%.8s' '%.16s' 0x%x\n",
                         devinfo->vendor, devinfo->model, devinfo->flags);
-                len += size;
-                pos = begin + len;
-                if (pos < offset) {
-                        len = 0;
-                        begin = pos;
-                }
-                if (pos > offset + length)
-                        goto stop_output;
-        }
+        return 0;
+}
+
+static void * devinfo_seq_start(struct seq_file *m, loff_t *pos)
+{
+        return seq_list_start(&scsi_dev_info_list, *pos);
+}
 
-stop_output:
-        *start = buffer + (offset - begin);     /* Start of wanted data */
-        len -= (offset - begin);        /* Start slop */
-        if (len > length)
-                len = length;   /* Ending slop */
-        return (len);
+static void * devinfo_seq_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        return seq_list_next(v, &scsi_dev_info_list, pos);
+}
+
+static void devinfo_seq_stop(struct seq_file *m, void *v)
+{
+}
+
+static const struct seq_operations scsi_devinfo_seq_ops = {
+        .start  = devinfo_seq_start,
+        .next   = devinfo_seq_next,
+        .stop   = devinfo_seq_stop,
+        .show   = devinfo_seq_show,
+};
+
+static int proc_scsi_devinfo_open(struct inode *inode, struct file *file)
+{
+        return seq_open(file, &scsi_devinfo_seq_ops);
 }
 
 /* 
@@ -489,11 +492,12 @@ stop_output:
  * integer value of flag to the scsi device info list.
  * To use, echo "vendor:model:flag" > /proc/scsi/device_info
  */
-static int proc_scsi_devinfo_write(struct file *file, const char __user *buf,
-                                   unsigned long length, void *data)
+static ssize_t proc_scsi_devinfo_write(struct file *file,
+                                       const char __user *buf,
+                                       size_t length, loff_t *ppos)
 {
         char *buffer;
-        int err = length;
+        ssize_t err = length;
 
         if (!buf || length>PAGE_SIZE)
                 return -EINVAL;
@@ -517,6 +521,15 @@ out:
         free_page((unsigned long)buffer);
         return err;
 }
+
+static const struct file_operations scsi_devinfo_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = proc_scsi_devinfo_open,
+        .read           = seq_read,
+        .write          = proc_scsi_devinfo_write,
+        .llseek         = seq_lseek,
+        .release        = seq_release,
+};
 #endif /* CONFIG_SCSI_PROC_FS */
 
 module_param_string(dev_flags, scsi_dev_flags, sizeof(scsi_dev_flags), 0);
@@ -577,15 +590,13 @@ int __init scsi_init_devinfo(void)
         }
 
 #ifdef CONFIG_SCSI_PROC_FS
-        p = create_proc_entry("scsi/device_info", 0, NULL);
+        p = proc_create("scsi/device_info", 0, NULL, &scsi_devinfo_proc_fops);
         if (!p) {
                 error = -ENOMEM;
                 goto out;
         }
 
         p->owner = THIS_MODULE;
-        p->get_info = proc_scsi_devinfo_read;
-        p->write_proc = proc_scsi_devinfo_write;
 #endif /* CONFIG_SCSI_PROC_FS */
 
  out:
diff --git a/drivers/scsi/scsi_proc.c b/drivers/scsi/scsi_proc.c
index 3a1c99d5c775..e4a0d2f9b357 100644
--- a/drivers/scsi/scsi_proc.c
+++ b/drivers/scsi/scsi_proc.c
@@ -413,6 +413,7 @@ static int proc_scsi_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations proc_scsi_operations = {
+        .owner          = THIS_MODULE,
         .open           = proc_scsi_open,
         .read           = seq_read,
         .write          = proc_scsi_write,
@@ -431,10 +432,9 @@ int __init scsi_init_procfs(void)
         if (!proc_scsi)
                 goto err1;
 
-        pde = create_proc_entry("scsi/scsi", 0, NULL);
+        pde = proc_create("scsi/scsi", 0, NULL, &proc_scsi_operations);
         if (!pde)
                 goto err2;
-        pde->proc_fops = &proc_scsi_operations;
 
         return 0;
 
diff --git a/drivers/scsi/scsi_scan.c b/drivers/scsi/scsi_scan.c
index fcd7455ffc39..a00eee6f7be9 100644
--- a/drivers/scsi/scsi_scan.c
+++ b/drivers/scsi/scsi_scan.c
@@ -1828,7 +1828,7 @@ void scsi_scan_host(struct Scsi_Host *shost)
         }
 
         p = kthread_run(do_scan_async, data, "scsi_scan_%d", shost->host_no);
-        if (unlikely(IS_ERR(p)))
+        if (IS_ERR(p))
                 do_scan_async(data);
 }
 EXPORT_SYMBOL(scsi_scan_host);
diff --git a/drivers/scsi/sg.c b/drivers/scsi/sg.c
index 2029422bc04d..c9d7f721b9e2 100644
--- a/drivers/scsi/sg.c
+++ b/drivers/scsi/sg.c
@@ -2667,7 +2667,6 @@ sg_proc_init(void)
 {
         int k, mask;
         int num_leaves = ARRAY_SIZE(sg_proc_leaf_arr);
-        struct proc_dir_entry *pdep;
         struct sg_proc_leaf * leaf;
 
         sg_proc_sgp = proc_mkdir(sg_proc_sg_dirname, NULL);
@@ -2676,13 +2675,10 @@ sg_proc_init(void)
         for (k = 0; k < num_leaves; ++k) {
                 leaf = &sg_proc_leaf_arr[k];
                 mask = leaf->fops->write ? S_IRUGO | S_IWUSR : S_IRUGO;
-                pdep = create_proc_entry(leaf->name, mask, sg_proc_sgp);
-                if (pdep) {
-                        leaf->fops->owner = THIS_MODULE,
-                        leaf->fops->read = seq_read,
-                        leaf->fops->llseek = seq_lseek,
-                        pdep->proc_fops = leaf->fops;
-                }
+                leaf->fops->owner = THIS_MODULE;
+                leaf->fops->read = seq_read;
+                leaf->fops->llseek = seq_lseek;
+                proc_create(leaf->name, mask, sg_proc_sgp, leaf->fops);
         }
         return 0;
 }
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index 4220f22b6660..5f71ff3aee35 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -305,8 +305,6 @@ enum {
  */
 
 #define FW_GET_BYTE(p)  *((__u8 *) (p))
-#define FW_GET_WORD(p)  le16_to_cpu(get_unaligned((__le16 *) (p)))
-#define FW_GET_LONG(p)  le32_to_cpu(get_unaligned((__le32 *) (p)))
 
 #define FW_DIR "ueagle-atm/"
 #define NB_MODEM 4
@@ -621,7 +619,7 @@ static void uea_upload_pre_firmware(const struct firmware *fw_entry, void *conte
         if (size < 4)
                 goto err_fw_corrupted;
 
-        crc = FW_GET_LONG(pfw);
+        crc = get_unaligned_le32(pfw);
         pfw += 4;
         size -= 4;
         if (crc32_be(0, pfw, size) != crc)
@@ -640,7 +638,7 @@ static void uea_upload_pre_firmware(const struct firmware *fw_entry, void *conte
 
         while (size > 3) {
                 u8 len = FW_GET_BYTE(pfw);
-                u16 add = FW_GET_WORD(pfw + 1);
+                u16 add = get_unaligned_le16(pfw + 1);
 
                 size -= len + 3;
                 if (size < 0)
@@ -738,7 +736,7 @@ static int check_dsp_e1(u8 *dsp, unsigned int len)
 
         for (i = 0; i < pagecount; i++) {
 
-                pageoffset = FW_GET_LONG(dsp + p);
+                pageoffset = get_unaligned_le32(dsp + p);
                 p += 4;
 
                 if (pageoffset == 0)
@@ -759,7 +757,7 @@ static int check_dsp_e1(u8 *dsp, unsigned int len)
                                 return 1;
 
                         pp += 2;        /* skip blockaddr */
-                        blocksize = FW_GET_WORD(dsp + pp);
+                        blocksize = get_unaligned_le16(dsp + pp);
                         pp += 2;
 
                         /* enough space for block data? */
@@ -928,7 +926,7 @@ static void uea_load_page_e1(struct work_struct *work)
                 goto bad1;
 
         p += 4 * pageno;
-        pageoffset = FW_GET_LONG(p);
+        pageoffset = get_unaligned_le32(p);
 
         if (pageoffset == 0)
                 goto bad1;
@@ -945,10 +943,10 @@ static void uea_load_page_e1(struct work_struct *work)
         bi.wOvlOffset = cpu_to_le16(ovl | 0x8000);
 
         for (i = 0; i < blockcount; i++) {
-                blockaddr = FW_GET_WORD(p);
+                blockaddr = get_unaligned_le16(p);
                 p += 2;
 
-                blocksize = FW_GET_WORD(p);
+                blocksize = get_unaligned_le16(p);
                 p += 2;
 
                 bi.wSize = cpu_to_le16(blocksize);
@@ -1152,9 +1150,9 @@ static int uea_cmv_e1(struct uea_softc *sc,
         cmv.bDirection = E1_HOSTTOMODEM;
         cmv.bFunction = function;
         cmv.wIndex = cpu_to_le16(sc->cmv_dsc.e1.idx);
-        put_unaligned(cpu_to_le32(address), &cmv.dwSymbolicAddress);
+        put_unaligned_le32(address, &cmv.dwSymbolicAddress);
         cmv.wOffsetAddress = cpu_to_le16(offset);
-        put_unaligned(cpu_to_le32(data >> 16 | data << 16), &cmv.dwData);
+        put_unaligned_le32(data >> 16 | data << 16, &cmv.dwData);
 
         ret = uea_request(sc, UEA_E1_SET_BLOCK, UEA_MPTX_START, sizeof(cmv), &cmv);
         if (ret < 0)
@@ -1646,7 +1644,7 @@ static int request_cmvs(struct uea_softc *sc,
         if (size < 5)
                 goto err_fw_corrupted;
 
-        crc = FW_GET_LONG(data);
+        crc = get_unaligned_le32(data);
         data += 4;
         size -= 4;
         if (crc32_be(0, data, size) != crc)
@@ -1696,9 +1694,9 @@ static int uea_send_cmvs_e1(struct uea_softc *sc)
                         "please update your firmware\n");
 
                 for (i = 0; i < len; i++) {
-                        ret = uea_write_cmv_e1(sc, FW_GET_LONG(&cmvs_v1[i].address),
-                                                FW_GET_WORD(&cmvs_v1[i].offset),
-                                                FW_GET_LONG(&cmvs_v1[i].data));
+                        ret = uea_write_cmv_e1(sc, get_unaligned_le32(&cmvs_v1[i].address),
+                                                get_unaligned_le16(&cmvs_v1[i].offset),
+                                                get_unaligned_le32(&cmvs_v1[i].data));
                         if (ret < 0)
                                 goto out;
                 }
@@ -1706,9 +1704,9 @@ static int uea_send_cmvs_e1(struct uea_softc *sc)
                 struct uea_cmvs_v2 *cmvs_v2 = cmvs_ptr;
 
                 for (i = 0; i < len; i++) {
-                        ret = uea_write_cmv_e1(sc, FW_GET_LONG(&cmvs_v2[i].address),
-                                                (u16) FW_GET_LONG(&cmvs_v2[i].offset),
-                                                FW_GET_LONG(&cmvs_v2[i].data));
+                        ret = uea_write_cmv_e1(sc, get_unaligned_le32(&cmvs_v2[i].address),
+                                                (u16) get_unaligned_le32(&cmvs_v2[i].offset),
+                                                get_unaligned_le32(&cmvs_v2[i].data));
                         if (ret < 0)
                                 goto out;
                 }
@@ -1759,10 +1757,10 @@ static int uea_send_cmvs_e4(struct uea_softc *sc)
 
                 for (i = 0; i < len; i++) {
                         ret = uea_write_cmv_e4(sc, 1,
-                                                FW_GET_LONG(&cmvs_v2[i].group),
-                                                FW_GET_LONG(&cmvs_v2[i].address),
-                                                FW_GET_LONG(&cmvs_v2[i].offset),
-                                                FW_GET_LONG(&cmvs_v2[i].data));
+                                                get_unaligned_le32(&cmvs_v2[i].group),
+                                                get_unaligned_le32(&cmvs_v2[i].address),
+                                                get_unaligned_le32(&cmvs_v2[i].offset),
+                                                get_unaligned_le32(&cmvs_v2[i].data));
                         if (ret < 0)
                                 goto out;
                 }
@@ -1964,7 +1962,7 @@ static void uea_dispatch_cmv_e1(struct uea_softc *sc, struct intr_pkt *intr)
                 if (UEA_CHIP_VERSION(sc) == ADI930
                                 && cmv->bFunction ==  E1_MAKEFUNCTION(2, 2)) {
                         cmv->wIndex = cpu_to_le16(dsc->idx);
-                        put_unaligned(cpu_to_le32(dsc->address), &cmv->dwSymbolicAddress);
+                        put_unaligned_le32(dsc->address, &cmv->dwSymbolicAddress);
                         cmv->wOffsetAddress = cpu_to_le16(dsc->offset);
                 } else
                         goto bad2;
@@ -1978,11 +1976,11 @@ static void uea_dispatch_cmv_e1(struct uea_softc *sc, struct intr_pkt *intr)
 
         /* in case of MEMACCESS */
         if (le16_to_cpu(cmv->wIndex) != dsc->idx ||
-            le32_to_cpu(get_unaligned(&cmv->dwSymbolicAddress)) != dsc->address ||
+            get_unaligned_le32(&cmv->dwSymbolicAddress) != dsc->address ||
             le16_to_cpu(cmv->wOffsetAddress) != dsc->offset)
                 goto bad2;
 
-        sc->data = le32_to_cpu(get_unaligned(&cmv->dwData));
+        sc->data = get_unaligned_le32(&cmv->dwData);
         sc->data = sc->data << 16 | sc->data >> 16;
 
         wake_up_cmv_ack(sc);
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 7b572e75e73c..cefe7f2c6f75 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -280,7 +280,7 @@ static void acm_ctrl_irq(struct urb *urb)
 
                 case USB_CDC_NOTIFY_SERIAL_STATE:
 
-                        newctrl = le16_to_cpu(get_unaligned((__le16 *) data));
+                        newctrl = get_unaligned_le16(data);
 
                         if (acm->tty && !acm->clocal && (acm->ctrlin & ~newctrl & ACM_CTRL_DCD)) {
                                 dbg("calling hangup");
diff --git a/drivers/usb/core/inode.c b/drivers/usb/core/inode.c
index 8607846e3c3f..1d253dd4ea81 100644
--- a/drivers/usb/core/inode.c
+++ b/drivers/usb/core/inode.c
@@ -773,7 +773,7 @@ int __init usbfs_init(void)
         usb_register_notify(&usbfs_nb);
 
         /* create mount point for usbfs */
-        usbdir = proc_mkdir("usb", proc_bus);
+        usbdir = proc_mkdir("bus/usb", NULL);
 
         return 0;
 }
@@ -783,6 +783,6 @@ void usbfs_cleanup(void)
         usb_unregister_notify(&usbfs_nb);
         unregister_filesystem(&usb_fs_type);
         if (usbdir)
-                remove_proc_entry("usb", proc_bus);
+                remove_proc_entry("bus/usb", NULL);
 }
 
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 9b913afb2e6d..274c60a970cd 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -231,6 +231,7 @@ static int proc_udc_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations proc_ops = {
+        .owner          = THIS_MODULE,
         .open           = proc_udc_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -239,15 +240,7 @@ static const struct file_operations proc_ops = {
 
 static void create_debug_file(struct at91_udc *udc)
 {
-        struct proc_dir_entry *pde;
-
-        pde = create_proc_entry (debug_filename, 0, NULL);
-        udc->pde = pde;
-        if (pde == NULL)
-                return;
-
-        pde->proc_fops = &proc_ops;
-        pde->data = udc;
+        udc->pde = proc_create_data(debug_filename, 0, NULL, &proc_ops, udc);
 }
 
 static void remove_debug_file(struct at91_udc *udc)
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 64a592cbbe7b..be6613afedbf 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -127,7 +127,7 @@ goku_ep_enable(struct usb_ep *_ep, const struct usb_endpoint_descriptor *desc)
 
         /* enabling the no-toggle interrupt mode would need an api hook */
         mode = 0;
-        max = le16_to_cpu(get_unaligned(&desc->wMaxPacketSize));
+        max = get_unaligned_le16(&desc->wMaxPacketSize);
         switch (max) {
         case 64:        mode++;
         case 32:        mode++;
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index 95f7662376f1..881d74c3d964 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -2504,6 +2504,7 @@ static int proc_udc_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations proc_ops = {
+        .owner          = THIS_MODULE,
         .open           = proc_udc_open,
         .read           = seq_read,
         .llseek         = seq_lseek,
@@ -2512,11 +2513,7 @@ static const struct file_operations proc_ops = {
 
 static void create_proc_file(void)
 {
-        struct proc_dir_entry *pde;
-
-        pde = create_proc_entry (proc_filename, 0, NULL);
-        if (pde)
-                pde->proc_fops = &proc_ops;
+        proc_create(proc_filename, 0, NULL, &proc_ops);
 }
 
 static void remove_proc_file(void)
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index bd58dd504f6f..d0677f5d3cd5 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -183,14 +183,10 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                 DBG("query OID %08x value, len %d:\n", OID, buf_len);
                 for (i = 0; i < buf_len; i += 16) {
                         DBG("%03d: %08x %08x %08x %08x\n", i,
-                                le32_to_cpu(get_unaligned((__le32 *)
-                                        &buf[i])),
-                                le32_to_cpu(get_unaligned((__le32 *)
-                                        &buf[i + 4])),
-                                le32_to_cpu(get_unaligned((__le32 *)
-                                        &buf[i + 8])),
-                                le32_to_cpu(get_unaligned((__le32 *)
-                                        &buf[i + 12])));
+                                get_unaligned_le32(&buf[i]),
+                                get_unaligned_le32(&buf[i + 4]),
+                                get_unaligned_le32(&buf[i + 8]),
+                                get_unaligned_le32(&buf[i + 12]));
                 }
         }
 
@@ -666,7 +662,7 @@ gen_ndis_query_resp (int configNr, u32 OID, u8 *buf, unsigned buf_len,
                 break;
         case OID_PNP_QUERY_POWER:
                 DBG("%s: OID_PNP_QUERY_POWER D%d\n", __func__,
-                                le32_to_cpu(get_unaligned((__le32 *)buf)) - 1);
+                                get_unaligned_le32(buf) - 1);
                 /* only suspend is a real power state, and
                  * it can't be entered by OID_PNP_SET_POWER...
                  */
@@ -705,14 +701,10 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
                 DBG("set OID %08x value, len %d:\n", OID, buf_len);
                 for (i = 0; i < buf_len; i += 16) {
                         DBG("%03d: %08x %08x %08x %08x\n", i,
-                                le32_to_cpu(get_unaligned((__le32 *)
-                                        &buf[i])),
-                                le32_to_cpu(get_unaligned((__le32 *)
-                                        &buf[i + 4])),
-                                le32_to_cpu(get_unaligned((__le32 *)
-                                        &buf[i + 8])),
-                                le32_to_cpu(get_unaligned((__le32 *)
-                                        &buf[i + 12])));
+                                get_unaligned_le32(&buf[i]),
+                                get_unaligned_le32(&buf[i + 4]),
+                                get_unaligned_le32(&buf[i + 8]),
+                                get_unaligned_le32(&buf[i + 12]));
                 }
         }
 
@@ -726,8 +718,7 @@ static int gen_ndis_set_resp (u8 configNr, u32 OID, u8 *buf, u32 buf_len,
                  *      PROMISCUOUS, DIRECTED,
                  *      MULTICAST, ALL_MULTICAST, BROADCAST
                  */
-                *params->filter = (u16) le32_to_cpu(get_unaligned(
-                                (__le32 *)buf));
+                *params->filter = (u16)get_unaligned_le32(buf);
                 DBG("%s: OID_GEN_CURRENT_PACKET_FILTER %08x\n",
                         __func__, *params->filter);
 
@@ -777,7 +768,7 @@ update_linkstate:
                  * resuming, Windows forces a reset, and then SET_POWER D0.
                  * FIXME ... then things go batty; Windows wedges itself.
                  */
-                i = le32_to_cpu(get_unaligned((__le32 *)buf));
+                i = get_unaligned_le32(buf);
                 DBG("%s: OID_PNP_SET_POWER D%d\n", __func__, i - 1);
                 switch (i) {
                 case NdisDeviceStateD0:
@@ -1064,8 +1055,8 @@ int rndis_msg_parser (u8 configNr, u8 *buf)
                 return -ENOMEM;
 
         tmp = (__le32 *) buf;
-        MsgType   = le32_to_cpu(get_unaligned(tmp++));
-        MsgLength = le32_to_cpu(get_unaligned(tmp++));
+        MsgType   = get_unaligned_le32(tmp++);
+        MsgLength = get_unaligned_le32(tmp++);
 
         if (configNr >= RNDIS_MAX_CONFIGS)
                 return -ENOTSUPP;
@@ -1296,10 +1287,9 @@ int rndis_rm_hdr(struct sk_buff *skb)
         tmp++;
 
         /* DataOffset, DataLength */
-        if (!skb_pull(skb, le32_to_cpu(get_unaligned(tmp++))
-                        + 8 /* offset of DataOffset */))
+        if (!skb_pull(skb, get_unaligned_le32(tmp++) + 8))
                 return -EOVERFLOW;
-        skb_trim(skb, le32_to_cpu(get_unaligned(tmp++)));
+        skb_trim(skb, get_unaligned_le32(tmp++));
 
         return 0;
 }
diff --git a/drivers/usb/gadget/usbstring.c b/drivers/usb/gadget/usbstring.c
index 878e428a0ec1..4154be375c7a 100644
--- a/drivers/usb/gadget/usbstring.c
+++ b/drivers/usb/gadget/usbstring.c
@@ -74,7 +74,7 @@ static int utf8_to_utf16le(const char *s, __le16 *cp, unsigned len)
                                 goto fail;
                 } else
                         uchar = c;
-                put_unaligned (cpu_to_le16 (uchar), cp++);
+                put_unaligned_le16(uchar, cp++);
                 count++;
                 len--;
         }
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index f13d1029aeb2..382587c4457c 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -770,7 +770,7 @@ static int ehci_hub_control (
         if (status & ~0xffff)   /* only if wPortChange is interesting */
 #endif
                 dbg_port (ehci, "GetStatus", wIndex + 1, temp);
-                put_unaligned(cpu_to_le32 (status), (__le32 *) buf);
+                put_unaligned_le32(status, buf);
                 break;
         case SetHubFeature:
                 switch (wValue) {
diff --git a/drivers/usb/host/ohci-hub.c b/drivers/usb/host/ohci-hub.c
index 5be3bb3e6a9d..17dc2eccda83 100644
--- a/drivers/usb/host/ohci-hub.c
+++ b/drivers/usb/host/ohci-hub.c
@@ -736,14 +736,14 @@ static int ohci_hub_control (
                 break;
         case GetHubStatus:
                 temp = roothub_status (ohci) & ~(RH_HS_CRWE | RH_HS_DRWE);
-                put_unaligned(cpu_to_le32 (temp), (__le32 *) buf);
+                put_unaligned_le32(temp, buf);
                 break;
         case GetPortStatus:
                 if (!wIndex || wIndex > ports)
                         goto error;
                 wIndex--;
                 temp = roothub_portstatus (ohci, wIndex);
-                put_unaligned(cpu_to_le32 (temp), (__le32 *) buf);
+                put_unaligned_le32(temp, buf);
 
 #ifndef OHCI_VERBOSE_DEBUG
         if (*(u16*)(buf+2))     /* only if wPortChange is interesting */
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 3fd7a0c12078..426575247b23 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -1506,15 +1506,7 @@ static const char proc_filename[] = "driver/sl811h";
 
 static void create_debug_file(struct sl811 *sl811)
 {
-        struct proc_dir_entry *pde;
-
-        pde = create_proc_entry(proc_filename, 0, NULL);
-        if (pde == NULL)
-                return;
-
-        pde->proc_fops = &proc_ops;
-        pde->data = sl811;
-        sl811->pde = pde;
+        sl811->pde = proc_create_data(proc_filename, 0, NULL, &proc_ops, sl811);
 }
 
 static void remove_debug_file(struct sl811 *sl811)
diff --git a/drivers/video/clps711xfb.c b/drivers/video/clps711xfb.c
index 17b5267f44d7..9f8a389dc7ae 100644
--- a/drivers/video/clps711xfb.c
+++ b/drivers/video/clps711xfb.c
@@ -381,7 +381,7 @@ int __init clps711xfb_init(void)
 
         /* Register the /proc entries. */
         clps7111fb_backlight_proc_entry = create_proc_entry("backlight", 0444,
-                &proc_root);
+                NULL);
         if (clps7111fb_backlight_proc_entry == NULL) {
                 printk("Couldn't create the /proc entry for the backlight.\n");
                 return -EINVAL;
diff --git a/drivers/video/console/fbcon.c b/drivers/video/console/fbcon.c
index 8eda7b60df8f..ad31983b43eb 100644
--- a/drivers/video/console/fbcon.c
+++ b/drivers/video/console/fbcon.c
@@ -1881,7 +1881,7 @@ static int fbcon_scroll(struct vc_data *vc, int t, int b, int dir,
                         scr_memsetw((unsigned short *) (vc->vc_origin +
                                                         vc->vc_size_row *
                                                         (b - count)),
-                                    vc->vc_video_erase_char,
+                                    vc->vc_scrl_erase_char,
                                     vc->vc_size_row * count);
                         return 1;
                         break;
@@ -1953,7 +1953,7 @@ static int fbcon_scroll(struct vc_data *vc, int t, int b, int dir,
                         scr_memsetw((unsigned short *) (vc->vc_origin +
                                                         vc->vc_size_row *
                                                         (b - count)),
-                                    vc->vc_video_erase_char,
+                                    vc->vc_scrl_erase_char,
                                     vc->vc_size_row * count);
                         return 1;
                 }
@@ -1972,7 +1972,7 @@ static int fbcon_scroll(struct vc_data *vc, int t, int b, int dir,
                         scr_memsetw((unsigned short *) (vc->vc_origin +
                                                         vc->vc_size_row *
                                                         t),
-                                    vc->vc_video_erase_char,
+                                    vc->vc_scrl_erase_char,
                                     vc->vc_size_row * count);
                         return 1;
                         break;
@@ -2042,7 +2042,7 @@ static int fbcon_scroll(struct vc_data *vc, int t, int b, int dir,
                         scr_memsetw((unsigned short *) (vc->vc_origin +
                                                         vc->vc_size_row *
                                                         t),
-                                    vc->vc_video_erase_char,
+                                    vc->vc_scrl_erase_char,
                                     vc->vc_size_row * count);
                         return 1;
                 }
diff --git a/drivers/video/console/mdacon.c b/drivers/video/console/mdacon.c
index bd8d995fe25d..38a296bbdfc9 100644
--- a/drivers/video/console/mdacon.c
+++ b/drivers/video/console/mdacon.c
@@ -531,7 +531,7 @@ static void mdacon_cursor(struct vc_data *c, int mode)
 
 static int mdacon_scroll(struct vc_data *c, int t, int b, int dir, int lines)
 {
-        u16 eattr = mda_convert_attr(c->vc_video_erase_char);
+        u16 eattr = mda_convert_attr(c->vc_scrl_erase_char);
 
         if (!lines)
                 return 0;
diff --git a/drivers/video/console/sticon.c b/drivers/video/console/sticon.c
index 67a682d6cc7b..a11cc2fdd4cd 100644
--- a/drivers/video/console/sticon.c
+++ b/drivers/video/console/sticon.c
@@ -170,12 +170,12 @@ static int sticon_scroll(struct vc_data *conp, int t, int b, int dir, int count)
     switch (dir) {
     case SM_UP:
         sti_bmove(sti, t + count, 0, t, 0, b - t - count, conp->vc_cols);
-        sti_clear(sti, b - count, 0, count, conp->vc_cols, conp->vc_video_erase_char);
+        sti_clear(sti, b - count, 0, count, conp->vc_cols, conp->vc_scrl_erase_char);
         break;
 
     case SM_DOWN:
         sti_bmove(sti, t, 0, t + count, 0, b - t - count, conp->vc_cols);
-        sti_clear(sti, t, 0, count, conp->vc_cols, conp->vc_video_erase_char);
+        sti_clear(sti, t, 0, count, conp->vc_cols, conp->vc_scrl_erase_char);
         break;
     }
 
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index 6df29a62d720..bd1f57b259d9 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -1350,7 +1350,7 @@ static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
                 } else
                         c->vc_origin += delta;
                 scr_memsetw((u16 *) (c->vc_origin + c->vc_screenbuf_size -
-                                     delta), c->vc_video_erase_char,
+                                     delta), c->vc_scrl_erase_char,
                             delta);
         } else {
                 if (oldo - delta < vga_vram_base) {
@@ -1363,7 +1363,7 @@ static int vgacon_scroll(struct vc_data *c, int t, int b, int dir,
                 } else
                         c->vc_origin -= delta;
                 c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
-                scr_memsetw((u16 *) (c->vc_origin), c->vc_video_erase_char,
+                scr_memsetw((u16 *) (c->vc_origin), c->vc_scrl_erase_char,
                             delta);
         }
         c->vc_scr_end = c->vc_origin + c->vc_screenbuf_size;
diff --git a/drivers/video/matrox/matroxfb_misc.c b/drivers/video/matrox/matroxfb_misc.c
index aaa3e538e5da..5b5f072fc1a8 100644
--- a/drivers/video/matrox/matroxfb_misc.c
+++ b/drivers/video/matrox/matroxfb_misc.c
@@ -522,8 +522,6 @@ static void parse_bios(unsigned char __iomem* vbios, struct matrox_bios* bd) {
 #endif
 }
 
-#define get_u16(x) (le16_to_cpu(get_unaligned((__u16*)(x))))
-#define get_u32(x) (le32_to_cpu(get_unaligned((__u32*)(x))))
 static int parse_pins1(WPMINFO const struct matrox_bios* bd) {
         unsigned int maxdac;
 
@@ -532,11 +530,12 @@ static int parse_pins1(WPMINFO const struct matrox_bios* bd) {
                 case 1:         maxdac = 220000; break;
                 default:        maxdac = 240000; break;
         }
-        if (get_u16(bd->pins + 24)) {
-                maxdac = get_u16(bd->pins + 24) * 10;
+        if (get_unaligned_le16(bd->pins + 24)) {
+                maxdac = get_unaligned_le16(bd->pins + 24) * 10;
         }
         MINFO->limits.pixel.vcomax = maxdac;
-        MINFO->values.pll.system = get_u16(bd->pins + 28) ? get_u16(bd->pins + 28) * 10 : 50000;
+        MINFO->values.pll.system = get_unaligned_le16(bd->pins + 28) ?
+                get_unaligned_le16(bd->pins + 28) * 10 : 50000;
         /* ignore 4MB, 8MB, module clocks */
         MINFO->features.pll.ref_freq = 14318;
         MINFO->values.reg.mctlwtst      = 0x00030101;
@@ -575,7 +574,8 @@ static void default_pins2(WPMINFO2) {
 static int parse_pins3(WPMINFO const struct matrox_bios* bd) {
         MINFO->limits.pixel.vcomax      =
         MINFO->limits.system.vcomax     = (bd->pins[36] == 0xFF) ? 230000                       : ((bd->pins[36] + 100) * 1000);
-        MINFO->values.reg.mctlwtst      = get_u32(bd->pins + 48) == 0xFFFFFFFF ? 0x01250A21     : get_u32(bd->pins + 48);
+        MINFO->values.reg.mctlwtst      = get_unaligned_le32(bd->pins + 48) == 0xFFFFFFFF ?
+                0x01250A21 : get_unaligned_le32(bd->pins + 48);
         /* memory config */
         MINFO->values.reg.memrdbk       = ((bd->pins[57] << 21) & 0x1E000000) |
                                           ((bd->pins[57] << 22) & 0x00C00000) |
@@ -601,7 +601,7 @@ static void default_pins3(WPMINFO2) {
 static int parse_pins4(WPMINFO const struct matrox_bios* bd) {
         MINFO->limits.pixel.vcomax      = (bd->pins[ 39] == 0xFF) ? 230000                      : bd->pins[ 39] * 4000;
         MINFO->limits.system.vcomax     = (bd->pins[ 38] == 0xFF) ? MINFO->limits.pixel.vcomax  : bd->pins[ 38] * 4000;
-        MINFO->values.reg.mctlwtst      = get_u32(bd->pins + 71);
+        MINFO->values.reg.mctlwtst      = get_unaligned_le32(bd->pins + 71);
         MINFO->values.reg.memrdbk       = ((bd->pins[87] << 21) & 0x1E000000) |
                                           ((bd->pins[87] << 22) & 0x00C00000) |
                                           ((bd->pins[86] <<  1) & 0x000001E0) |
@@ -609,7 +609,7 @@ static int parse_pins4(WPMINFO const struct matrox_bios* bd) {
         MINFO->values.reg.opt           = ((bd->pins[53] << 15) & 0x00400000) |
                                           ((bd->pins[53] << 22) & 0x10000000) |
                                           ((bd->pins[53] <<  7) & 0x00001C00);
-        MINFO->values.reg.opt3          = get_u32(bd->pins + 67);
+        MINFO->values.reg.opt3          = get_unaligned_le32(bd->pins + 67);
         MINFO->values.pll.system        = (bd->pins[ 65] == 0xFF) ? 200000                      : bd->pins[ 65] * 4000;
         MINFO->features.pll.ref_freq    = (bd->pins[ 92] & 0x01) ? 14318 : 27000;
         return 0;
@@ -640,12 +640,12 @@ static int parse_pins5(WPMINFO const struct matrox_bios* bd) {
         MINFO->limits.video.vcomin      = (bd->pins[122] == 0xFF) ? MINFO->limits.system.vcomin : bd->pins[122] * mult;
         MINFO->values.pll.system        =
         MINFO->values.pll.video         = (bd->pins[ 92] == 0xFF) ? 284000                      : bd->pins[ 92] * 4000;
-        MINFO->values.reg.opt           = get_u32(bd->pins+ 48);
-        MINFO->values.reg.opt2          = get_u32(bd->pins+ 52);
-        MINFO->values.reg.opt3          = get_u32(bd->pins+ 94);
-        MINFO->values.reg.mctlwtst      = get_u32(bd->pins+ 98);
-        MINFO->values.reg.memmisc       = get_u32(bd->pins+102);
-        MINFO->values.reg.memrdbk       = get_u32(bd->pins+106);
+        MINFO->values.reg.opt           = get_unaligned_le32(bd->pins + 48);
+        MINFO->values.reg.opt2          = get_unaligned_le32(bd->pins + 52);
+        MINFO->values.reg.opt3          = get_unaligned_le32(bd->pins + 94);
+        MINFO->values.reg.mctlwtst      = get_unaligned_le32(bd->pins + 98);
+        MINFO->values.reg.memmisc       = get_unaligned_le32(bd->pins + 102);
+        MINFO->values.reg.memrdbk       = get_unaligned_le32(bd->pins + 106);
         MINFO->features.pll.ref_freq    = (bd->pins[110] & 0x01) ? 14318 : 27000;
         MINFO->values.memory.ddr        = (bd->pins[114] & 0x60) == 0x20;
         MINFO->values.memory.dll        = (bd->pins[115] & 0x02) != 0;
diff --git a/drivers/video/metronomefb.c b/drivers/video/metronomefb.c
index 249791286367..cc4c038a1b3f 100644
--- a/drivers/video/metronomefb.c
+++ b/drivers/video/metronomefb.c
@@ -206,8 +206,7 @@ static int load_waveform(u8 *mem, size_t size, u8 *metromem, int m, int t,
         }
 
         /* check waveform mode table address checksum */
-        wmta = le32_to_cpu(get_unaligned((__le32 *) wfm_hdr->wmta));
-        wmta &= 0x00FFFFFF;
+        wmta = get_unaligned_le32(wfm_hdr->wmta) & 0x00FFFFFF;
         cksum_idx = wmta + m*4 + 3;
         if (cksum_idx > size)
                 return -EINVAL;
@@ -219,8 +218,7 @@ static int load_waveform(u8 *mem, size_t size, u8 *metromem, int m, int t,
         }
 
         /* check waveform temperature table address checksum */
-        tta = le32_to_cpu(get_unaligned((int *) (mem + wmta + m*4)));
-        tta &= 0x00FFFFFF;
+        tta = get_unaligned_le32(mem + wmta + m * 4) & 0x00FFFFFF;
         cksum_idx = tta + trn*4 + 3;
         if (cksum_idx > size)
                 return -EINVAL;
@@ -233,8 +231,7 @@ static int load_waveform(u8 *mem, size_t size, u8 *metromem, int m, int t,
 
         /* here we do the real work of putting the waveform into the
         metromem buffer. this does runlength decoding of the waveform */
-        wfm_idx = le32_to_cpu(get_unaligned((__le32 *) (mem + tta + trn*4)));
-        wfm_idx &= 0x00FFFFFF;
+        wfm_idx = get_unaligned_le32(mem + tta + trn * 4) & 0x00FFFFFF;
         owfm_idx = wfm_idx;
         if (wfm_idx > size)
                 return -EINVAL;
diff --git a/drivers/zorro/proc.c b/drivers/zorro/proc.c
index 2ce4cebc31d9..099b6fb5b5cb 100644
--- a/drivers/zorro/proc.c
+++ b/drivers/zorro/proc.c
@@ -13,6 +13,7 @@
 #include <linux/types.h>
 #include <linux/zorro.h>
 #include <linux/proc_fs.h>
+#include <linux/seq_file.h>
 #include <linux/init.h>
 #include <linux/smp_lock.h>
 #include <asm/uaccess.h>
@@ -76,36 +77,58 @@ proc_bus_zorro_read(struct file *file, char __user *buf, size_t nbytes, loff_t *
 }
 
 static const struct file_operations proc_bus_zorro_operations = {
+        .owner          = THIS_MODULE,
         .llseek         = proc_bus_zorro_lseek,
         .read           = proc_bus_zorro_read,
 };
 
-static int
-get_zorro_dev_info(char *buf, char **start, off_t pos, int count)
+static void * zorro_seq_start(struct seq_file *m, loff_t *pos)
 {
-        u_int slot;
-        off_t at = 0;
-        int len, cnt;
-
-        for (slot = cnt = 0; slot < zorro_num_autocon && count > cnt; slot++) {
-                struct zorro_dev *z = &zorro_autocon[slot];
-                len = sprintf(buf, "%02x\t%08x\t%08lx\t%08lx\t%02x\n", slot,
-                              z->id, (unsigned long)zorro_resource_start(z),
-                              (unsigned long)zorro_resource_len(z),
-                              z->rom.er_Type);
-                at += len;
-                if (at >= pos) {
-                        if (!*start) {
-                                *start = buf + (pos - (at - len));
-                                cnt = at - pos;
-                        } else
-                                cnt += len;
-                        buf += len;
-                }
-        }
-        return (count > cnt) ? cnt : count;
+        return (*pos < zorro_num_autocon) ? pos : NULL;
+}
+
+static void * zorro_seq_next(struct seq_file *m, void *v, loff_t *pos)
+{
+        (*pos)++;
+        return (*pos < zorro_num_autocon) ? pos : NULL;
+}
+
+static void zorro_seq_stop(struct seq_file *m, void *v)
+{
+}
+
+static int zorro_seq_show(struct seq_file *m, void *v)
+{
+        u_int slot = *(loff_t *)v;
+        struct zorro_dev *z = &zorro_autocon[slot];
+
+        seq_printf(m, "%02x\t%08x\t%08lx\t%08lx\t%02x\n", slot, z->id,
+                   (unsigned long)zorro_resource_start(z),
+                   (unsigned long)zorro_resource_len(z),
+                   z->rom.er_Type);
+        return 0;
+}
+
+static const struct seq_operations zorro_devices_seq_ops = {
+        .start = zorro_seq_start,
+        .next  = zorro_seq_next,
+        .stop  = zorro_seq_stop,
+        .show  = zorro_seq_show,
+};
+
+static int zorro_devices_proc_open(struct inode *inode, struct file *file)
+{
+        return seq_open(file, &zorro_devices_seq_ops);
 }
 
+static const struct file_operations zorro_devices_proc_fops = {
+        .owner          = THIS_MODULE,
+        .open           = zorro_devices_proc_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = seq_release,
+};
+
 static struct proc_dir_entry *proc_bus_zorro_dir;
 
 static int __init zorro_proc_attach_device(u_int slot)
@@ -114,11 +137,11 @@ static int __init zorro_proc_attach_device(u_int slot)
         char name[4];
 
         sprintf(name, "%02x", slot);
-        entry = create_proc_entry(name, 0, proc_bus_zorro_dir);
+        entry = proc_create_data(name, 0, proc_bus_zorro_dir,
+                                 &proc_bus_zorro_operations,
+                                 &zorro_autocon[slot]);
         if (!entry)
                 return -ENOMEM;
-        entry->proc_fops = &proc_bus_zorro_operations;
-        entry->data = &zorro_autocon[slot];
         entry->size = sizeof(struct zorro_dev);
         return 0;
 }
@@ -128,9 +151,9 @@ static int __init zorro_proc_init(void)
         u_int slot;
 
         if (MACH_IS_AMIGA && AMIGAHW_PRESENT(ZORRO)) {
-                proc_bus_zorro_dir = proc_mkdir("zorro", proc_bus);
-                create_proc_info_entry("devices", 0, proc_bus_zorro_dir,
-                                       get_zorro_dev_info);
+                proc_bus_zorro_dir = proc_mkdir("bus/zorro", NULL);
+                proc_create("devices", 0, proc_bus_zorro_dir,
+                            &zorro_devices_proc_fops);
                 for (slot = 0; slot < zorro_num_autocon; slot++)
                         zorro_proc_attach_device(slot);
         }