18 files changed, 173 insertions, 251 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/bus.c b/drivers/acpi/bus.c
index 2d1955c11833..a6dbcf4d9ef5 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -35,6 +35,7 @@
 #ifdef CONFIG_X86
 #include <asm/mpspec.h>
 #endif
+#include <linux/pci.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
 
@@ -784,6 +785,7 @@ static int __init acpi_init(void)
         result = acpi_bus_init();
 
         if (!result) {
+                pci_mmcfg_late_init();
                 if (!(pm_flags & PM_APM))
                         pm_flags |= PM_ACPI;
                 else {
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 3d9362140831..0924992187e8 100644
--- a/drivers/acpi/ec.c
+++ b/drivers/acpi/ec.c
@@ -634,16 +634,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 cf635cde836b..6cf10cbc1eee 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 f2a76acecfcd..81e4f081a4ae 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 ea5f628dcc15..386e5aa48834 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;
 }
 
@@ -612,6 +603,15 @@ static int acpi_processor_get_info(struct acpi_processor *pr, unsigned has_uid)
                 request_region(pr->throttling.address, 6, "ACPI CPU throttle");
         }
 
+        /*
+         * If ACPI describes a slot number for this CPU, we can use it
+         * ensure we get the right value in the "physical id" field
+         * of /proc/cpuinfo
+         */
+        status = acpi_evaluate_object(pr->handle, "_SUN", NULL, &buffer);
+        if (ACPI_SUCCESS(status))
+                arch_fix_phys_package_id(pr->id, object.integer.value);
+
         return 0;
 }
 
diff --git a/drivers/acpi/processor_idle.c b/drivers/acpi/processor_idle.c
index 55d69dce47c4..2dd2c1f3a01c 100644
--- a/drivers/acpi/processor_idle.c
+++ b/drivers/acpi/processor_idle.c
@@ -1286,6 +1286,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,
@@ -1833,16 +1834,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 782c2250443e..504385b1f211 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,
@@ -1437,63 +1442,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 33c502e56026..f7eb12e55602 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -190,6 +190,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,
@@ -198,6 +199,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,
@@ -207,6 +209,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,
@@ -215,6 +218,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,
@@ -223,6 +227,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,
@@ -233,6 +238,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,
@@ -242,6 +248,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,
@@ -251,6 +258,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,
@@ -260,6 +268,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,
@@ -1061,47 +1070,37 @@ static int acpi_video_device_add_fs(struct acpi_device *device)
         device_dir->owner = THIS_MODULE;
 
         /* 'info' [R] */
-        entry = create_proc_entry("info", S_IRUGO, device_dir);
+        entry = proc_create_data("info", S_IRUGO, acpi_device_dir(device),
+                        &acpi_video_device_info_fops, acpi_driver_data(device));
         if (!entry)
                 goto err_remove_dir;
 
-        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,
-                                  device_dir);
+        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)
                 goto err_remove_info;
 
-        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,
-                                  device_dir);
+        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)
                 goto err_remove_state;
 
-        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, device_dir);
+        entry = proc_create_data("EDID", S_IRUGO, acpi_device_dir(device),
+                                 &acpi_video_device_EDID_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 goto err_remove_brightness;
 
-        entry->proc_fops = &acpi_video_device_EDID_fops;
-        entry->data = acpi_driver_data(device);
-        entry->owner = THIS_MODULE;
-
-        acpi_device_dir(device) = device_dir;
         return 0;
 
  err_remove_brightness:
@@ -1347,54 +1346,44 @@ static int acpi_video_bus_add_fs(struct acpi_device *device)
         device_dir->owner = THIS_MODULE;
 
         /* 'info' [R] */
-        entry = create_proc_entry("info", S_IRUGO, device_dir);
+        entry = proc_create_data("info", S_IRUGO, acpi_device_dir(device),
+                                 &acpi_video_bus_info_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 goto err_remove_dir;
 
-        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, device_dir);
+        entry = proc_create_data("ROM", S_IRUGO, acpi_device_dir(device),
+                                 &acpi_video_bus_ROM_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 goto err_remove_info;
 
-        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, device_dir);
+        entry = proc_create_data("POST_info", S_IRUGO, acpi_device_dir(device),
+                                 &acpi_video_bus_POST_info_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 goto err_remove_rom;
 
-        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_IWUSR,
-                                  device_dir);
+        acpi_video_bus_POST_fops.write = acpi_video_bus_write_POST;
+        entry = proc_create_data("POST", S_IFREG | S_IRUGO | S_IWUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_video_bus_POST_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 goto err_remove_post_info;
 
-        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_IWUSR,
-                              device_dir);
+        acpi_video_bus_DOS_fops.write = acpi_video_bus_write_DOS;
+        entry = proc_create_data("DOS", S_IFREG | S_IRUGO | S_IWUSR,
+                                 acpi_device_dir(device),
+                                 &acpi_video_bus_DOS_fops,
+                                 acpi_driver_data(device));
         if (!entry)
                 goto err_remove_post;
 
-        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;
-
         video->dir = acpi_device_dir(device) = device_dir;
         return 0;