asus-laptop: revise names

asus-laptop now does a lot more than just hotkeys.  Replace the "hotk"
names used throughout the driver with some slightly more appropriate
names.  The actual strings used in kernel messages and sysfs are left
unchanged.

Signed-off-by: Corentin Chary <corentincj@iksaif.net>

1 files changed, 111 insertions, 110 deletions

diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index 8834405be1fd..2505f15cbe6b 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -52,11 +52,11 @@
 
 #define ASUS_LAPTOP_VERSION     "0.42"
 
-#define ASUS_HOTK_NAME          "Asus Laptop Support"
-#define ASUS_HOTK_CLASS         "hotkey"
-#define ASUS_HOTK_DEVICE_NAME   "Hotkey"
-#define ASUS_HOTK_FILE          KBUILD_MODNAME
-#define ASUS_HOTK_PREFIX        "\\_SB.ATKD."
+#define ASUS_LAPTOP_NAME        "Asus Laptop Support"
+#define ASUS_LAPTOP_CLASS       "hotkey"
+#define ASUS_LAPTOP_DEVICE_NAME "Hotkey"
+#define ASUS_LAPTOP_FILE        KBUILD_MODNAME
+#define ASUS_LAPTOP_PREFIX      "\\_SB.ATKD."
 
 
 /*
@@ -89,7 +89,7 @@
 #define KEY_ON          0x200   /* Keyboard backlight */
 
 MODULE_AUTHOR("Julien Lerouge, Karol Kozimor, Corentin Chary");
-MODULE_DESCRIPTION(ASUS_HOTK_NAME);
+MODULE_DESCRIPTION(ASUS_LAPTOP_NAME);
 MODULE_LICENSE("GPL");
 
 /*
@@ -124,27 +124,27 @@ MODULE_PARM_DESC(bluetooth_status, "Set the wireless status on boot "
         static char *object##_paths[] = { paths }
 
 /* LED */
-ASUS_HANDLE(mled_set, ASUS_HOTK_PREFIX "MLED");
-ASUS_HANDLE(tled_set, ASUS_HOTK_PREFIX "TLED");
-ASUS_HANDLE(rled_set, ASUS_HOTK_PREFIX "RLED"); /* W1JC */
-ASUS_HANDLE(pled_set, ASUS_HOTK_PREFIX "PLED"); /* A7J */
-ASUS_HANDLE(gled_set, ASUS_HOTK_PREFIX "GLED"); /* G1, G2 (probably) */
+ASUS_HANDLE(mled_set, ASUS_LAPTOP_PREFIX "MLED");
+ASUS_HANDLE(tled_set, ASUS_LAPTOP_PREFIX "TLED");
+ASUS_HANDLE(rled_set, ASUS_LAPTOP_PREFIX "RLED");       /* W1JC */
+ASUS_HANDLE(pled_set, ASUS_LAPTOP_PREFIX "PLED");       /* A7J */
+ASUS_HANDLE(gled_set, ASUS_LAPTOP_PREFIX "GLED");       /* G1, G2 (probably) */
 
 /* LEDD */
-ASUS_HANDLE(ledd_set, ASUS_HOTK_PREFIX "SLCM");
+ASUS_HANDLE(ledd_set, ASUS_LAPTOP_PREFIX "SLCM");
 
 /*
  * Bluetooth and WLAN
  * WLED and BLED are not handled like other XLED, because in some dsdt
  * they also control the WLAN/Bluetooth device.
  */
-ASUS_HANDLE(wl_switch, ASUS_HOTK_PREFIX "WLED");
-ASUS_HANDLE(bt_switch, ASUS_HOTK_PREFIX "BLED");
-ASUS_HANDLE(wireless_status, ASUS_HOTK_PREFIX "RSTS");  /* All new models */
+ASUS_HANDLE(wl_switch, ASUS_LAPTOP_PREFIX "WLED");
+ASUS_HANDLE(bt_switch, ASUS_LAPTOP_PREFIX "BLED");
+ASUS_HANDLE(wireless_status, ASUS_LAPTOP_PREFIX "RSTS");        /* All new models */
 
 /* Brightness */
-ASUS_HANDLE(brightness_set, ASUS_HOTK_PREFIX "SPLV");
-ASUS_HANDLE(brightness_get, ASUS_HOTK_PREFIX "GPLV");
+ASUS_HANDLE(brightness_set, ASUS_LAPTOP_PREFIX "SPLV");
+ASUS_HANDLE(brightness_get, ASUS_LAPTOP_PREFIX "GPLV");
 
 /* Backlight */
 ASUS_HANDLE(lcd_switch, "\\_SB.PCI0.SBRG.EC0._Q10",     /* All new models */
@@ -157,7 +157,7 @@ ASUS_HANDLE(lcd_switch, "\\_SB.PCI0.SBRG.EC0._Q10",	/* All new models */
             "\\Q10");           /* A2x, L2D, L3D, M2E */
 
 /* Display */
-ASUS_HANDLE(display_set, ASUS_HOTK_PREFIX "SDSP");
+ASUS_HANDLE(display_set, ASUS_LAPTOP_PREFIX "SDSP");
 ASUS_HANDLE(display_get,
             /* A6B, A6K A6R A7D F3JM L4R M6R A3G M6A M6V VX-1 V6J V6V W3Z */
             "\\_SB.PCI0.P0P1.VGA.GETD",
@@ -182,24 +182,24 @@ ASUS_HANDLE(display_get,
             /* A3F A6F A3N A3L M6N W3N W6A */
             "\\SSTE");
 
-ASUS_HANDLE(ls_switch, ASUS_HOTK_PREFIX "ALSC"); /* Z71A Z71V */
-ASUS_HANDLE(ls_level, ASUS_HOTK_PREFIX "ALSL");  /* Z71A Z71V */
+ASUS_HANDLE(ls_switch, ASUS_LAPTOP_PREFIX "ALSC"); /* Z71A Z71V */
+ASUS_HANDLE(ls_level, ASUS_LAPTOP_PREFIX "ALSL");        /* Z71A Z71V */
 
 /* GPS */
 /* R2H use different handle for GPS on/off */
-ASUS_HANDLE(gps_on, ASUS_HOTK_PREFIX "SDON");   /* R2H */
-ASUS_HANDLE(gps_off, ASUS_HOTK_PREFIX "SDOF");  /* R2H */
-ASUS_HANDLE(gps_status, ASUS_HOTK_PREFIX "GPST");
+ASUS_HANDLE(gps_on, ASUS_LAPTOP_PREFIX "SDON"); /* R2H */
+ASUS_HANDLE(gps_off, ASUS_LAPTOP_PREFIX "SDOF");        /* R2H */
+ASUS_HANDLE(gps_status, ASUS_LAPTOP_PREFIX "GPST");
 
 /* Keyboard light */
-ASUS_HANDLE(kled_set, ASUS_HOTK_PREFIX "SLKB");
-ASUS_HANDLE(kled_get, ASUS_HOTK_PREFIX "GLKB");
+ASUS_HANDLE(kled_set, ASUS_LAPTOP_PREFIX "SLKB");
+ASUS_HANDLE(kled_get, ASUS_LAPTOP_PREFIX "GLKB");
 
 /*
  * This is the main structure, we can use it to store anything interesting
  * about the hotk device
  */
-struct asus_hotk {
+struct asus_laptop {
         char *name;             /* laptop name */
 
         struct platform_device *platform_device;
@@ -216,13 +216,13 @@ struct asus_hotk {
 
 /*
  * This header is made available to allow proper configuration given model,
- * revision number , ... this info cannot go in struct asus_hotk because it is
+ * revision number , ... this info cannot go in struct asus_laptop because it is
  * available before the hotk
  */
 static struct acpi_table_header *asus_info;
 
 /* The actual device the driver binds to */
-static struct asus_hotk *hotk;
+static struct asus_laptop *asus;
 
 /* The backlight device /sys/class/backlight */
 static struct backlight_device *asus_backlight_device;
@@ -353,7 +353,7 @@ static int read_wireless_status(int mask)
         acpi_status rv = AE_OK;
 
         if (!wireless_status_handle)
-                return (hotk->status & mask) ? 1 : 0;
+                return (asus->status & mask) ? 1 : 0;
 
         rv = acpi_evaluate_integer(wireless_status_handle, NULL, NULL, &status);
         if (ACPI_FAILURE(rv))
@@ -361,7 +361,7 @@ static int read_wireless_status(int mask)
         else
                 return (status & mask) ? 1 : 0;
 
-        return (hotk->status & mask) ? 1 : 0;
+        return (asus->status & mask) ? 1 : 0;
 }
 
 static int read_gps_status(void)
@@ -375,7 +375,7 @@ static int read_gps_status(void)
         else
                 return status ? 1 : 0;
 
-        return (hotk->status & GPS_ON) ? 1 : 0;
+        return (asus->status & GPS_ON) ? 1 : 0;
 }
 
 /* Generic LED functions */
@@ -387,12 +387,12 @@ static int read_status(int mask)
         else if (mask == GPS_ON)
                 return read_gps_status();
 
-        return (hotk->status & mask) ? 1 : 0;
+        return (asus->status & mask) ? 1 : 0;
 }
 
 static void write_status(acpi_handle handle, int out, int mask)
 {
-        hotk->status = (out) ? (hotk->status | mask) : (hotk->status & ~mask);
+        asus->status = (out) ? (asus->status | mask) : (asus->status & ~mask);
 
         switch (mask) {
         case MLED_ON:
@@ -586,15 +586,15 @@ static ssize_t show_infos(struct device *dev,
          * to 1
          */
 
-        len += sprintf(page, ASUS_HOTK_NAME " " ASUS_LAPTOP_VERSION "\n");
-        len += sprintf(page + len, "Model reference    : %s\n", hotk->name);
+        len += sprintf(page, ASUS_LAPTOP_NAME " " ASUS_LAPTOP_VERSION "\n");
+        len += sprintf(page + len, "Model reference    : %s\n", asus->name);
         /*
          * The SFUN method probably allows the original driver to get the list
          * of features supported by a given model. For now, 0x0100 or 0x0800
          * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
          * The significance of others is yet to be found.
          */
-        rv = acpi_evaluate_integer(hotk->handle, "SFUN", NULL, &temp);
+        rv = acpi_evaluate_integer(asus->handle, "SFUN", NULL, &temp);
         if (!ACPI_FAILURE(rv))
                 len += sprintf(page + len, "SFUN value         : %#x\n",
                                (uint) temp);
@@ -604,7 +604,7 @@ static ssize_t show_infos(struct device *dev,
          * The significance of others is yet to be found.
          * If we don't find the method, we assume the device are present.
          */
-        rv = acpi_evaluate_integer(hotk->handle, "HRWS", NULL, &temp);
+        rv = acpi_evaluate_integer(asus->handle, "HRWS", NULL, &temp);
         if (!ACPI_FAILURE(rv))
                 len += sprintf(page + len, "HRWS value         : %#x\n",
                                (uint) temp);
@@ -615,7 +615,7 @@ static ssize_t show_infos(struct device *dev,
          * Note: since not all the laptops provide this method, errors are
          * silently ignored.
          */
-        rv = acpi_evaluate_integer(hotk->handle, "ASYM", NULL, &temp);
+        rv = acpi_evaluate_integer(asus->handle, "ASYM", NULL, &temp);
         if (!ACPI_FAILURE(rv))
                 len += sprintf(page + len, "ASYM value         : %#x\n",
                                (uint) temp);
@@ -673,7 +673,7 @@ static ssize_t store_status(const char *buf, size_t count,
 static ssize_t show_ledd(struct device *dev,
                          struct device_attribute *attr, char *buf)
 {
-        return sprintf(buf, "0x%08x\n", hotk->ledd_status);
+        return sprintf(buf, "0x%08x\n", asus->ledd_status);
 }
 
 static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
@@ -686,7 +686,7 @@ static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
                 if (write_acpi_int(ledd_set_handle, NULL, value))
                         pr_warning("LED display write failed\n");
                 else
-                        hotk->ledd_status = (u32) value;
+                        asus->ledd_status = (u32) value;
         }
         return rv;
 }
@@ -789,13 +789,13 @@ static void set_light_sens_switch(int value)
 {
         if (write_acpi_int(ls_switch_handle, NULL, value))
                 pr_warning("Error setting light sensor switch\n");
-        hotk->light_switch = value;
+        asus->light_switch = value;
 }
 
 static ssize_t show_lssw(struct device *dev,
                          struct device_attribute *attr, char *buf)
 {
-        return sprintf(buf, "%d\n", hotk->light_switch);
+        return sprintf(buf, "%d\n", asus->light_switch);
 }
 
 static ssize_t store_lssw(struct device *dev, struct device_attribute *attr,
@@ -814,13 +814,13 @@ static void set_light_sens_level(int value)
 {
         if (write_acpi_int(ls_level_handle, NULL, value))
                 pr_warning("Error setting light sensor level\n");
-        hotk->light_level = value;
+        asus->light_level = value;
 }
 
 static ssize_t show_lslvl(struct device *dev,
                           struct device_attribute *attr, char *buf)
 {
-        return sprintf(buf, "%d\n", hotk->light_level);
+        return sprintf(buf, "%d\n", asus->light_level);
 }
 
 static ssize_t store_lslvl(struct device *dev, struct device_attribute *attr,
@@ -929,23 +929,23 @@ static void asus_acpi_notify(struct acpi_device *device, u32 event)
         }
 
         /* TODO Find a better way to handle events count. */
-        count = hotk->event_count[event % 128]++;
-        acpi_bus_generate_proc_event(hotk->device, event, count);
-        acpi_bus_generate_netlink_event(hotk->device->pnp.device_class,
-                                        dev_name(&hotk->device->dev), event,
+        count = asus->event_count[event % 128]++;
+        acpi_bus_generate_proc_event(asus->device, event, count);
+        acpi_bus_generate_netlink_event(asus->device->pnp.device_class,
+                                        dev_name(&asus->device->dev), event,
                                         count);
 
-        if (hotk->inputdev) {
+        if (asus->inputdev) {
                 key = asus_get_entry_by_scancode(event);
                 if (!key)
                         return ;
 
                 switch (key->type) {
                 case KE_KEY:
-                        input_report_key(hotk->inputdev, key->keycode, 1);
-                        input_sync(hotk->inputdev);
-                        input_report_key(hotk->inputdev, key->keycode, 0);
-                        input_sync(hotk->inputdev);
+                        input_report_key(asus->inputdev, key->keycode, 1);
+                        input_sync(asus->inputdev);
+                        input_report_key(asus->inputdev, key->keycode, 0);
+                        input_sync(asus->inputdev);
                         break;
                 }
         }
@@ -996,42 +996,42 @@ static int asus_platform_init(void)
 {
         int result;
 
-        hotk->platform_device = platform_device_alloc(ASUS_HOTK_FILE, -1);
-        if (!hotk->platform_device)
+        asus->platform_device = platform_device_alloc(ASUS_LAPTOP_FILE, -1);
+        if (!asus->platform_device)
                 return -ENOMEM;
 
-        result = platform_device_add(hotk->platform_device);
+        result = platform_device_add(asus->platform_device);
         if (result)
                 goto fail_platform_device;
 
-        result = sysfs_create_group(&hotk->platform_device->dev.kobj,
+        result = sysfs_create_group(&asus->platform_device->dev.kobj,
                                     &platform_attribute_group);
         if (result)
                 goto fail_sysfs;
         return 0;
 
 fail_sysfs:
-        platform_device_del(hotk->platform_device);
+        platform_device_del(asus->platform_device);
 fail_platform_device:
-        platform_device_put(hotk->platform_device);
+        platform_device_put(asus->platform_device);
         return result;
 }
 
 static void asus_platform_exit(void)
 {
-        sysfs_remove_group(&hotk->platform_device->dev.kobj,
+        sysfs_remove_group(&asus->platform_device->dev.kobj,
                            &platform_attribute_group);
-        platform_device_unregister(hotk->platform_device);
+        platform_device_unregister(asus->platform_device);
 }
 
 static struct platform_driver platform_driver = {
         .driver = {
-                   .name = ASUS_HOTK_FILE,
+                   .name = ASUS_LAPTOP_FILE,
                    .owner = THIS_MODULE,
                    }
 };
 
-static void asus_hotk_add_fs(void)
+static void asus_laptop_add_fs(void)
 {
         ASUS_SET_DEVICE_ATTR(infos, 0444, show_infos, NULL);
 
@@ -1080,10 +1080,11 @@ static int asus_handle_init(char *name, acpi_handle * handle,
                          ARRAY_SIZE(object##_paths))
 
 /*
- * This function is used to initialize the hotk with right values. In this
- * method, we can make all the detection we want, and modify the hotk struct
+ * This function is used to initialize the context with right values. In this
+ * method, we can make all the detection we want, and modify the asus_laptop
+ * struct
  */
-static int asus_hotk_get_info(void)
+static int asus_laptop_get_info(void)
 {
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *model = NULL;
@@ -1104,14 +1105,14 @@ static int asus_hotk_get_info(void)
                 pr_warning("Couldn't get the DSDT table header\n");
 
         /* We have to write 0 on init this far for all ASUS models */
-        if (write_acpi_int_ret(hotk->handle, "INIT", 0, &buffer)) {
+        if (write_acpi_int_ret(asus->handle, "INIT", 0, &buffer)) {
                 pr_err("Hotkey initialization failed\n");
                 return -ENODEV;
         }
 
         /* This needs to be called for some laptops to init properly */
         status =
-            acpi_evaluate_integer(hotk->handle, "BSTS", NULL, &bsts_result);
+            acpi_evaluate_integer(asus->handle, "BSTS", NULL, &bsts_result);
         if (ACPI_FAILURE(status))
                 pr_warning("Error calling BSTS\n");
         else if (bsts_result)
@@ -1119,7 +1120,7 @@ static int asus_hotk_get_info(void)
                        (uint) bsts_result);
 
         /* This too ... */
-        write_acpi_int(hotk->handle, "CWAP", wapf);
+        write_acpi_int(asus->handle, "CWAP", wapf);
 
         /*
          * Try to match the object returned by INIT to the specific model.
@@ -1141,8 +1142,8 @@ static int asus_hotk_get_info(void)
                         break;
                 }
         }
-        hotk->name = kstrdup(string, GFP_KERNEL);
-        if (!hotk->name)
+        asus->name = kstrdup(string, GFP_KERNEL);
+        if (!asus->name)
                 return -ENOMEM;
 
         if (*string)
@@ -1166,7 +1167,7 @@ static int asus_hotk_get_info(void)
          * If we don't find the method, we assume the device are present.
          */
         status =
-            acpi_evaluate_integer(hotk->handle, "HRWS", NULL, &hwrs_result);
+            acpi_evaluate_integer(asus->handle, "HRWS", NULL, &hwrs_result);
         if (ACPI_FAILURE(status))
                 hwrs_result = WL_HWRS | BT_HWRS;
 
@@ -1206,30 +1207,30 @@ static int asus_input_init(struct device *dev)
         const struct key_entry *key;
         int result;
 
-        hotk->inputdev = input_allocate_device();
-        if (!hotk->inputdev) {
+        asus->inputdev = input_allocate_device();
+        if (!asus->inputdev) {
                 pr_info("Unable to allocate input device\n");
                 return 0;
         }
-        hotk->inputdev->name = "Asus Laptop extra buttons";
-        hotk->inputdev->dev.parent = dev;
-        hotk->inputdev->phys = ASUS_HOTK_FILE "/input0";
-        hotk->inputdev->id.bustype = BUS_HOST;
-        hotk->inputdev->getkeycode = asus_getkeycode;
-        hotk->inputdev->setkeycode = asus_setkeycode;
+        asus->inputdev->name = "Asus Laptop extra buttons";
+        asus->inputdev->dev.parent = dev;
+        asus->inputdev->phys = ASUS_LAPTOP_FILE "/input0";
+        asus->inputdev->id.bustype = BUS_HOST;
+        asus->inputdev->getkeycode = asus_getkeycode;
+        asus->inputdev->setkeycode = asus_setkeycode;
 
         for (key = asus_keymap; key->type != KE_END; key++) {
                 switch (key->type) {
                 case KE_KEY:
-                        set_bit(EV_KEY, hotk->inputdev->evbit);
-                        set_bit(key->keycode, hotk->inputdev->keybit);
+                        set_bit(EV_KEY, asus->inputdev->evbit);
+                        set_bit(key->keycode, asus->inputdev->keybit);
                         break;
                 }
         }
-        result = input_register_device(hotk->inputdev);
+        result = input_register_device(asus->inputdev);
         if (result) {
                 pr_info("Unable to register input device\n");
-                input_free_device(hotk->inputdev);
+                input_free_device(asus->inputdev);
         }
         return result;
 }
@@ -1257,8 +1258,8 @@ static void asus_led_exit(void)
 
 static void asus_input_exit(void)
 {
-        if (hotk->inputdev)
-                input_unregister_device(hotk->inputdev);
+        if (asus->inputdev)
+                input_unregister_device(asus->inputdev);
 }
 
 static int asus_backlight_init(struct device *dev)
@@ -1266,7 +1267,7 @@ static int asus_backlight_init(struct device *dev)
         struct backlight_device *bd;
 
         if (brightness_set_handle && lcd_switch_handle) {
-                bd = backlight_device_register(ASUS_HOTK_FILE, dev,
+                bd = backlight_device_register(ASUS_LAPTOP_FILE, dev,
                                                NULL, &asusbl_ops);
                 if (IS_ERR(bd)) {
                         pr_err("Could not register asus backlight device\n");
@@ -1354,19 +1355,19 @@ static int __devinit asus_acpi_init(struct acpi_device *device)
 {
         int result = 0;
 
-        result = acpi_bus_get_status(hotk->device);
+        result = acpi_bus_get_status(asus->device);
         if (result)
                 return result;
-        if (!hotk->device->status.present) {
+        if (!asus->device->status.present) {
                 pr_err("Hotkey device not present, aborting\n");
                 return -ENODEV;
         }
 
-        result = asus_hotk_get_info();
+        result = asus_laptop_get_info();
         if (result)
                 return result;
 
-        asus_hotk_add_fs();
+        asus_laptop_add_fs();
 
         /* WLED and BLED are on by default */
         write_status(bt_switch_handle, 1, BT_ON);
@@ -1384,17 +1385,17 @@ static int __devinit asus_acpi_init(struct acpi_device *device)
                 set_kled_lvl(1);
 
         /* LED display is off by default */
-        hotk->ledd_status = 0xFFF;
+        asus->ledd_status = 0xFFF;
 
         /* Set initial values of light sensor and level */
         hotk->light_switch = 0; /* Default to light sensor disabled */
         hotk->light_level = 5;  /* level 5 for sensor sensitivity */
 
         if (ls_switch_handle)
-                set_light_sens_switch(hotk->light_switch);
+                set_light_sens_switch(asus->light_switch);
 
         if (ls_level_handle)
-                set_light_sens_level(hotk->light_level);
+                set_light_sens_level(asus->light_level);
 
         /* GPS is on by default */
         write_status(NULL, 1, GPS_ON);
@@ -1407,14 +1408,14 @@ static int __devinit asus_acpi_add(struct acpi_device *device)
 
         pr_notice("Asus Laptop Support version %s\n",
                   ASUS_LAPTOP_VERSION);
-        hotk = kzalloc(sizeof(struct asus_hotk), GFP_KERNEL);
-        if (!hotk)
+        asus = kzalloc(sizeof(struct asus_laptop), GFP_KERNEL);
+        if (!asus)
                 return -ENOMEM;
-        hotk->handle = device->handle;
-        strcpy(acpi_device_name(device), ASUS_HOTK_DEVICE_NAME);
-        strcpy(acpi_device_class(device), ASUS_HOTK_CLASS);
-        device->driver_data = hotk;
-        hotk->device = device;
+        asus->handle = device->handle;
+        strcpy(acpi_device_name(device), ASUS_LAPTOP_DEVICE_NAME);
+        strcpy(acpi_device_class(device), ASUS_LAPTOP_CLASS);
+        device->driver_data = asus;
+        asus->device = device;
 
         result = asus_acpi_init(device);
         if (result)
@@ -1429,17 +1430,17 @@ static int __devinit asus_acpi_add(struct acpi_device *device)
                 goto fail_platform;
 
         if (!acpi_video_backlight_support()) {
-                result = asus_backlight_init(&hotk->platform_device->dev);
+                result = asus_backlight_init(&asus->platform_device->dev);
                 if (result)
                         goto fail_backlight;
         } else
                 pr_info("Backlight controlled by ACPI video driver\n");
 
-        result = asus_input_init(&hotk->platform_device->dev);
+        result = asus_input_init(&asus->platform_device->dev);
         if (result)
                 goto fail_input;
 
-        result = asus_led_init(&hotk->platform_device->dev);
+        result = asus_led_init(&asus->platform_device->dev);
         if (result)
                 goto fail_led;
 
@@ -1453,8 +1454,8 @@ fail_input:
 fail_backlight:
         asus_platform_exit();
 fail_platform:
-        kfree(hotk->name);
-        kfree(hotk);
+        kfree(asus->name);
+        kfree(asus);
 
         return result;
 }
@@ -1466,8 +1467,8 @@ static int asus_acpi_remove(struct acpi_device *device, int type)
         asus_input_exit();
         asus_platform_exit();
 
-        kfree(hotk->name);
-        kfree(hotk);
+        kfree(asus->name);
+        kfree(asus);
         return 0;
 }
 
@@ -1479,8 +1480,8 @@ static const struct acpi_device_id asus_device_ids[] = {
 MODULE_DEVICE_TABLE(acpi, asus_device_ids);
 
 static struct acpi_driver asus_acpi_driver = {
-        .name = ASUS_HOTK_NAME,
-        .class = ASUS_HOTK_CLASS,
+        .name = ASUS_LAPTOP_NAME,
+        .class = ASUS_LAPTOP_CLASS,
         .owner = THIS_MODULE,
         .ids = asus_device_ids,
         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,