diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index 8834405..2505f15 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,
