treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / platform / x86 / alienware-wmi.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Alienware AlienFX control
4  *
5  * Copyright (C) 2014 Dell Inc <mario_limonciello@dell.com>
6  */
7
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10 #include <linux/acpi.h>
11 #include <linux/module.h>
12 #include <linux/platform_device.h>
13 #include <linux/dmi.h>
14 #include <linux/leds.h>
15
16 #define LEGACY_CONTROL_GUID             "A90597CE-A997-11DA-B012-B622A1EF5492"
17 #define LEGACY_POWER_CONTROL_GUID       "A80593CE-A997-11DA-B012-B622A1EF5492"
18 #define WMAX_CONTROL_GUID               "A70591CE-A997-11DA-B012-B622A1EF5492"
19
20 #define WMAX_METHOD_HDMI_SOURCE         0x1
21 #define WMAX_METHOD_HDMI_STATUS         0x2
22 #define WMAX_METHOD_BRIGHTNESS          0x3
23 #define WMAX_METHOD_ZONE_CONTROL        0x4
24 #define WMAX_METHOD_HDMI_CABLE          0x5
25 #define WMAX_METHOD_AMPLIFIER_CABLE     0x6
26 #define WMAX_METHOD_DEEP_SLEEP_CONTROL  0x0B
27 #define WMAX_METHOD_DEEP_SLEEP_STATUS   0x0C
28
29 MODULE_AUTHOR("Mario Limonciello <mario_limonciello@dell.com>");
30 MODULE_DESCRIPTION("Alienware special feature control");
31 MODULE_LICENSE("GPL");
32 MODULE_ALIAS("wmi:" LEGACY_CONTROL_GUID);
33 MODULE_ALIAS("wmi:" WMAX_CONTROL_GUID);
34
35 enum INTERFACE_FLAGS {
36         LEGACY,
37         WMAX,
38 };
39
40 enum LEGACY_CONTROL_STATES {
41         LEGACY_RUNNING = 1,
42         LEGACY_BOOTING = 0,
43         LEGACY_SUSPEND = 3,
44 };
45
46 enum WMAX_CONTROL_STATES {
47         WMAX_RUNNING = 0xFF,
48         WMAX_BOOTING = 0,
49         WMAX_SUSPEND = 3,
50 };
51
52 struct quirk_entry {
53         u8 num_zones;
54         u8 hdmi_mux;
55         u8 amplifier;
56         u8 deepslp;
57 };
58
59 static struct quirk_entry *quirks;
60
61
62 static struct quirk_entry quirk_inspiron5675 = {
63         .num_zones = 2,
64         .hdmi_mux = 0,
65         .amplifier = 0,
66         .deepslp = 0,
67 };
68
69 static struct quirk_entry quirk_unknown = {
70         .num_zones = 2,
71         .hdmi_mux = 0,
72         .amplifier = 0,
73         .deepslp = 0,
74 };
75
76 static struct quirk_entry quirk_x51_r1_r2 = {
77         .num_zones = 3,
78         .hdmi_mux = 0,
79         .amplifier = 0,
80         .deepslp = 0,
81 };
82
83 static struct quirk_entry quirk_x51_r3 = {
84         .num_zones = 4,
85         .hdmi_mux = 0,
86         .amplifier = 1,
87         .deepslp = 0,
88 };
89
90 static struct quirk_entry quirk_asm100 = {
91         .num_zones = 2,
92         .hdmi_mux = 1,
93         .amplifier = 0,
94         .deepslp = 0,
95 };
96
97 static struct quirk_entry quirk_asm200 = {
98         .num_zones = 2,
99         .hdmi_mux = 1,
100         .amplifier = 0,
101         .deepslp = 1,
102 };
103
104 static struct quirk_entry quirk_asm201 = {
105         .num_zones = 2,
106         .hdmi_mux = 1,
107         .amplifier = 1,
108         .deepslp = 1,
109 };
110
111 static int __init dmi_matched(const struct dmi_system_id *dmi)
112 {
113         quirks = dmi->driver_data;
114         return 1;
115 }
116
117 static const struct dmi_system_id alienware_quirks[] __initconst = {
118         {
119          .callback = dmi_matched,
120          .ident = "Alienware X51 R3",
121          .matches = {
122                      DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
123                      DMI_MATCH(DMI_PRODUCT_NAME, "Alienware X51 R3"),
124                      },
125          .driver_data = &quirk_x51_r3,
126          },
127         {
128          .callback = dmi_matched,
129          .ident = "Alienware X51 R2",
130          .matches = {
131                      DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
132                      DMI_MATCH(DMI_PRODUCT_NAME, "Alienware X51 R2"),
133                      },
134          .driver_data = &quirk_x51_r1_r2,
135          },
136         {
137          .callback = dmi_matched,
138          .ident = "Alienware X51 R1",
139          .matches = {
140                      DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
141                      DMI_MATCH(DMI_PRODUCT_NAME, "Alienware X51"),
142                      },
143          .driver_data = &quirk_x51_r1_r2,
144          },
145         {
146          .callback = dmi_matched,
147          .ident = "Alienware ASM100",
148          .matches = {
149                      DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
150                      DMI_MATCH(DMI_PRODUCT_NAME, "ASM100"),
151                      },
152          .driver_data = &quirk_asm100,
153          },
154         {
155          .callback = dmi_matched,
156          .ident = "Alienware ASM200",
157          .matches = {
158                      DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
159                      DMI_MATCH(DMI_PRODUCT_NAME, "ASM200"),
160                      },
161          .driver_data = &quirk_asm200,
162          },
163         {
164          .callback = dmi_matched,
165          .ident = "Alienware ASM201",
166          .matches = {
167                      DMI_MATCH(DMI_SYS_VENDOR, "Alienware"),
168                      DMI_MATCH(DMI_PRODUCT_NAME, "ASM201"),
169                      },
170          .driver_data = &quirk_asm201,
171          },
172          {
173          .callback = dmi_matched,
174          .ident = "Dell Inc. Inspiron 5675",
175          .matches = {
176                      DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
177                      DMI_MATCH(DMI_PRODUCT_NAME, "Inspiron 5675"),
178                      },
179          .driver_data = &quirk_inspiron5675,
180          },
181         {}
182 };
183
184 struct color_platform {
185         u8 blue;
186         u8 green;
187         u8 red;
188 } __packed;
189
190 struct platform_zone {
191         u8 location;
192         struct device_attribute *attr;
193         struct color_platform colors;
194 };
195
196 struct wmax_brightness_args {
197         u32 led_mask;
198         u32 percentage;
199 };
200
201 struct wmax_basic_args {
202         u8 arg;
203 };
204
205 struct legacy_led_args {
206         struct color_platform colors;
207         u8 brightness;
208         u8 state;
209 } __packed;
210
211 struct wmax_led_args {
212         u32 led_mask;
213         struct color_platform colors;
214         u8 state;
215 } __packed;
216
217 static struct platform_device *platform_device;
218 static struct device_attribute *zone_dev_attrs;
219 static struct attribute **zone_attrs;
220 static struct platform_zone *zone_data;
221
222 static struct platform_driver platform_driver = {
223         .driver = {
224                    .name = "alienware-wmi",
225                    }
226 };
227
228 static struct attribute_group zone_attribute_group = {
229         .name = "rgb_zones",
230 };
231
232 static u8 interface;
233 static u8 lighting_control_state;
234 static u8 global_brightness;
235
236 /*
237  * Helpers used for zone control
238  */
239 static int parse_rgb(const char *buf, struct platform_zone *zone)
240 {
241         long unsigned int rgb;
242         int ret;
243         union color_union {
244                 struct color_platform cp;
245                 int package;
246         } repackager;
247
248         ret = kstrtoul(buf, 16, &rgb);
249         if (ret)
250                 return ret;
251
252         /* RGB triplet notation is 24-bit hexadecimal */
253         if (rgb > 0xFFFFFF)
254                 return -EINVAL;
255
256         repackager.package = rgb & 0x0f0f0f0f;
257         pr_debug("alienware-wmi: r: %d g:%d b: %d\n",
258                  repackager.cp.red, repackager.cp.green, repackager.cp.blue);
259         zone->colors = repackager.cp;
260         return 0;
261 }
262
263 static struct platform_zone *match_zone(struct device_attribute *attr)
264 {
265         u8 zone;
266
267         for (zone = 0; zone < quirks->num_zones; zone++) {
268                 if ((struct device_attribute *)zone_data[zone].attr == attr) {
269                         pr_debug("alienware-wmi: matched zone location: %d\n",
270                                  zone_data[zone].location);
271                         return &zone_data[zone];
272                 }
273         }
274         return NULL;
275 }
276
277 /*
278  * Individual RGB zone control
279  */
280 static int alienware_update_led(struct platform_zone *zone)
281 {
282         int method_id;
283         acpi_status status;
284         char *guid;
285         struct acpi_buffer input;
286         struct legacy_led_args legacy_args;
287         struct wmax_led_args wmax_basic_args;
288         if (interface == WMAX) {
289                 wmax_basic_args.led_mask = 1 << zone->location;
290                 wmax_basic_args.colors = zone->colors;
291                 wmax_basic_args.state = lighting_control_state;
292                 guid = WMAX_CONTROL_GUID;
293                 method_id = WMAX_METHOD_ZONE_CONTROL;
294
295                 input.length = (acpi_size) sizeof(wmax_basic_args);
296                 input.pointer = &wmax_basic_args;
297         } else {
298                 legacy_args.colors = zone->colors;
299                 legacy_args.brightness = global_brightness;
300                 legacy_args.state = 0;
301                 if (lighting_control_state == LEGACY_BOOTING ||
302                     lighting_control_state == LEGACY_SUSPEND) {
303                         guid = LEGACY_POWER_CONTROL_GUID;
304                         legacy_args.state = lighting_control_state;
305                 } else
306                         guid = LEGACY_CONTROL_GUID;
307                 method_id = zone->location + 1;
308
309                 input.length = (acpi_size) sizeof(legacy_args);
310                 input.pointer = &legacy_args;
311         }
312         pr_debug("alienware-wmi: guid %s method %d\n", guid, method_id);
313
314         status = wmi_evaluate_method(guid, 0, method_id, &input, NULL);
315         if (ACPI_FAILURE(status))
316                 pr_err("alienware-wmi: zone set failure: %u\n", status);
317         return ACPI_FAILURE(status);
318 }
319
320 static ssize_t zone_show(struct device *dev, struct device_attribute *attr,
321                          char *buf)
322 {
323         struct platform_zone *target_zone;
324         target_zone = match_zone(attr);
325         if (target_zone == NULL)
326                 return sprintf(buf, "red: -1, green: -1, blue: -1\n");
327         return sprintf(buf, "red: %d, green: %d, blue: %d\n",
328                        target_zone->colors.red,
329                        target_zone->colors.green, target_zone->colors.blue);
330
331 }
332
333 static ssize_t zone_set(struct device *dev, struct device_attribute *attr,
334                         const char *buf, size_t count)
335 {
336         struct platform_zone *target_zone;
337         int ret;
338         target_zone = match_zone(attr);
339         if (target_zone == NULL) {
340                 pr_err("alienware-wmi: invalid target zone\n");
341                 return 1;
342         }
343         ret = parse_rgb(buf, target_zone);
344         if (ret)
345                 return ret;
346         ret = alienware_update_led(target_zone);
347         return ret ? ret : count;
348 }
349
350 /*
351  * LED Brightness (Global)
352  */
353 static int wmax_brightness(int brightness)
354 {
355         acpi_status status;
356         struct acpi_buffer input;
357         struct wmax_brightness_args args = {
358                 .led_mask = 0xFF,
359                 .percentage = brightness,
360         };
361         input.length = (acpi_size) sizeof(args);
362         input.pointer = &args;
363         status = wmi_evaluate_method(WMAX_CONTROL_GUID, 0,
364                                      WMAX_METHOD_BRIGHTNESS, &input, NULL);
365         if (ACPI_FAILURE(status))
366                 pr_err("alienware-wmi: brightness set failure: %u\n", status);
367         return ACPI_FAILURE(status);
368 }
369
370 static void global_led_set(struct led_classdev *led_cdev,
371                            enum led_brightness brightness)
372 {
373         int ret;
374         global_brightness = brightness;
375         if (interface == WMAX)
376                 ret = wmax_brightness(brightness);
377         else
378                 ret = alienware_update_led(&zone_data[0]);
379         if (ret)
380                 pr_err("LED brightness update failed\n");
381 }
382
383 static enum led_brightness global_led_get(struct led_classdev *led_cdev)
384 {
385         return global_brightness;
386 }
387
388 static struct led_classdev global_led = {
389         .brightness_set = global_led_set,
390         .brightness_get = global_led_get,
391         .name = "alienware::global_brightness",
392 };
393
394 /*
395  * Lighting control state device attribute (Global)
396  */
397 static ssize_t show_control_state(struct device *dev,
398                                   struct device_attribute *attr, char *buf)
399 {
400         if (lighting_control_state == LEGACY_BOOTING)
401                 return scnprintf(buf, PAGE_SIZE, "[booting] running suspend\n");
402         else if (lighting_control_state == LEGACY_SUSPEND)
403                 return scnprintf(buf, PAGE_SIZE, "booting running [suspend]\n");
404         return scnprintf(buf, PAGE_SIZE, "booting [running] suspend\n");
405 }
406
407 static ssize_t store_control_state(struct device *dev,
408                                    struct device_attribute *attr,
409                                    const char *buf, size_t count)
410 {
411         long unsigned int val;
412         if (strcmp(buf, "booting\n") == 0)
413                 val = LEGACY_BOOTING;
414         else if (strcmp(buf, "suspend\n") == 0)
415                 val = LEGACY_SUSPEND;
416         else if (interface == LEGACY)
417                 val = LEGACY_RUNNING;
418         else
419                 val = WMAX_RUNNING;
420         lighting_control_state = val;
421         pr_debug("alienware-wmi: updated control state to %d\n",
422                  lighting_control_state);
423         return count;
424 }
425
426 static DEVICE_ATTR(lighting_control_state, 0644, show_control_state,
427                    store_control_state);
428
429 static int alienware_zone_init(struct platform_device *dev)
430 {
431         u8 zone;
432         char buffer[10];
433         char *name;
434
435         if (interface == WMAX) {
436                 lighting_control_state = WMAX_RUNNING;
437         } else if (interface == LEGACY) {
438                 lighting_control_state = LEGACY_RUNNING;
439         }
440         global_led.max_brightness = 0x0F;
441         global_brightness = global_led.max_brightness;
442
443         /*
444          *      - zone_dev_attrs num_zones + 1 is for individual zones and then
445          *        null terminated
446          *      - zone_attrs num_zones + 2 is for all attrs in zone_dev_attrs +
447          *        the lighting control + null terminated
448          *      - zone_data num_zones is for the distinct zones
449          */
450         zone_dev_attrs =
451             kcalloc(quirks->num_zones + 1, sizeof(struct device_attribute),
452                     GFP_KERNEL);
453         if (!zone_dev_attrs)
454                 return -ENOMEM;
455
456         zone_attrs =
457             kcalloc(quirks->num_zones + 2, sizeof(struct attribute *),
458                     GFP_KERNEL);
459         if (!zone_attrs)
460                 return -ENOMEM;
461
462         zone_data =
463             kcalloc(quirks->num_zones, sizeof(struct platform_zone),
464                     GFP_KERNEL);
465         if (!zone_data)
466                 return -ENOMEM;
467
468         for (zone = 0; zone < quirks->num_zones; zone++) {
469                 sprintf(buffer, "zone%02hhX", zone);
470                 name = kstrdup(buffer, GFP_KERNEL);
471                 if (name == NULL)
472                         return 1;
473                 sysfs_attr_init(&zone_dev_attrs[zone].attr);
474                 zone_dev_attrs[zone].attr.name = name;
475                 zone_dev_attrs[zone].attr.mode = 0644;
476                 zone_dev_attrs[zone].show = zone_show;
477                 zone_dev_attrs[zone].store = zone_set;
478                 zone_data[zone].location = zone;
479                 zone_attrs[zone] = &zone_dev_attrs[zone].attr;
480                 zone_data[zone].attr = &zone_dev_attrs[zone];
481         }
482         zone_attrs[quirks->num_zones] = &dev_attr_lighting_control_state.attr;
483         zone_attribute_group.attrs = zone_attrs;
484
485         led_classdev_register(&dev->dev, &global_led);
486
487         return sysfs_create_group(&dev->dev.kobj, &zone_attribute_group);
488 }
489
490 static void alienware_zone_exit(struct platform_device *dev)
491 {
492         u8 zone;
493
494         sysfs_remove_group(&dev->dev.kobj, &zone_attribute_group);
495         led_classdev_unregister(&global_led);
496         if (zone_dev_attrs) {
497                 for (zone = 0; zone < quirks->num_zones; zone++)
498                         kfree(zone_dev_attrs[zone].attr.name);
499         }
500         kfree(zone_dev_attrs);
501         kfree(zone_data);
502         kfree(zone_attrs);
503 }
504
505 static acpi_status alienware_wmax_command(struct wmax_basic_args *in_args,
506                                           u32 command, int *out_data)
507 {
508         acpi_status status;
509         union acpi_object *obj;
510         struct acpi_buffer input;
511         struct acpi_buffer output;
512
513         input.length = (acpi_size) sizeof(*in_args);
514         input.pointer = in_args;
515         if (out_data) {
516                 output.length = ACPI_ALLOCATE_BUFFER;
517                 output.pointer = NULL;
518                 status = wmi_evaluate_method(WMAX_CONTROL_GUID, 0,
519                                              command, &input, &output);
520                 if (ACPI_SUCCESS(status)) {
521                         obj = (union acpi_object *)output.pointer;
522                         if (obj && obj->type == ACPI_TYPE_INTEGER)
523                                 *out_data = (u32)obj->integer.value;
524                 }
525                 kfree(output.pointer);
526         } else {
527                 status = wmi_evaluate_method(WMAX_CONTROL_GUID, 0,
528                                              command, &input, NULL);
529         }
530         return status;
531 }
532
533 /*
534  *      The HDMI mux sysfs node indicates the status of the HDMI input mux.
535  *      It can toggle between standard system GPU output and HDMI input.
536  */
537 static ssize_t show_hdmi_cable(struct device *dev,
538                                struct device_attribute *attr, char *buf)
539 {
540         acpi_status status;
541         u32 out_data;
542         struct wmax_basic_args in_args = {
543                 .arg = 0,
544         };
545         status =
546             alienware_wmax_command(&in_args, WMAX_METHOD_HDMI_CABLE,
547                                    (u32 *) &out_data);
548         if (ACPI_SUCCESS(status)) {
549                 if (out_data == 0)
550                         return scnprintf(buf, PAGE_SIZE,
551                                          "[unconnected] connected unknown\n");
552                 else if (out_data == 1)
553                         return scnprintf(buf, PAGE_SIZE,
554                                          "unconnected [connected] unknown\n");
555         }
556         pr_err("alienware-wmi: unknown HDMI cable status: %d\n", status);
557         return scnprintf(buf, PAGE_SIZE, "unconnected connected [unknown]\n");
558 }
559
560 static ssize_t show_hdmi_source(struct device *dev,
561                                 struct device_attribute *attr, char *buf)
562 {
563         acpi_status status;
564         u32 out_data;
565         struct wmax_basic_args in_args = {
566                 .arg = 0,
567         };
568         status =
569             alienware_wmax_command(&in_args, WMAX_METHOD_HDMI_STATUS,
570                                    (u32 *) &out_data);
571
572         if (ACPI_SUCCESS(status)) {
573                 if (out_data == 1)
574                         return scnprintf(buf, PAGE_SIZE,
575                                          "[input] gpu unknown\n");
576                 else if (out_data == 2)
577                         return scnprintf(buf, PAGE_SIZE,
578                                          "input [gpu] unknown\n");
579         }
580         pr_err("alienware-wmi: unknown HDMI source status: %u\n", status);
581         return scnprintf(buf, PAGE_SIZE, "input gpu [unknown]\n");
582 }
583
584 static ssize_t toggle_hdmi_source(struct device *dev,
585                                   struct device_attribute *attr,
586                                   const char *buf, size_t count)
587 {
588         acpi_status status;
589         struct wmax_basic_args args;
590         if (strcmp(buf, "gpu\n") == 0)
591                 args.arg = 1;
592         else if (strcmp(buf, "input\n") == 0)
593                 args.arg = 2;
594         else
595                 args.arg = 3;
596         pr_debug("alienware-wmi: setting hdmi to %d : %s", args.arg, buf);
597
598         status = alienware_wmax_command(&args, WMAX_METHOD_HDMI_SOURCE, NULL);
599
600         if (ACPI_FAILURE(status))
601                 pr_err("alienware-wmi: HDMI toggle failed: results: %u\n",
602                        status);
603         return count;
604 }
605
606 static DEVICE_ATTR(cable, S_IRUGO, show_hdmi_cable, NULL);
607 static DEVICE_ATTR(source, S_IRUGO | S_IWUSR, show_hdmi_source,
608                    toggle_hdmi_source);
609
610 static struct attribute *hdmi_attrs[] = {
611         &dev_attr_cable.attr,
612         &dev_attr_source.attr,
613         NULL,
614 };
615
616 static const struct attribute_group hdmi_attribute_group = {
617         .name = "hdmi",
618         .attrs = hdmi_attrs,
619 };
620
621 static void remove_hdmi(struct platform_device *dev)
622 {
623         if (quirks->hdmi_mux > 0)
624                 sysfs_remove_group(&dev->dev.kobj, &hdmi_attribute_group);
625 }
626
627 static int create_hdmi(struct platform_device *dev)
628 {
629         int ret;
630
631         ret = sysfs_create_group(&dev->dev.kobj, &hdmi_attribute_group);
632         if (ret)
633                 remove_hdmi(dev);
634         return ret;
635 }
636
637 /*
638  * Alienware GFX amplifier support
639  * - Currently supports reading cable status
640  * - Leaving expansion room to possibly support dock/undock events later
641  */
642 static ssize_t show_amplifier_status(struct device *dev,
643                                      struct device_attribute *attr, char *buf)
644 {
645         acpi_status status;
646         u32 out_data;
647         struct wmax_basic_args in_args = {
648                 .arg = 0,
649         };
650         status =
651             alienware_wmax_command(&in_args, WMAX_METHOD_AMPLIFIER_CABLE,
652                                    (u32 *) &out_data);
653         if (ACPI_SUCCESS(status)) {
654                 if (out_data == 0)
655                         return scnprintf(buf, PAGE_SIZE,
656                                          "[unconnected] connected unknown\n");
657                 else if (out_data == 1)
658                         return scnprintf(buf, PAGE_SIZE,
659                                          "unconnected [connected] unknown\n");
660         }
661         pr_err("alienware-wmi: unknown amplifier cable status: %d\n", status);
662         return scnprintf(buf, PAGE_SIZE, "unconnected connected [unknown]\n");
663 }
664
665 static DEVICE_ATTR(status, S_IRUGO, show_amplifier_status, NULL);
666
667 static struct attribute *amplifier_attrs[] = {
668         &dev_attr_status.attr,
669         NULL,
670 };
671
672 static const struct attribute_group amplifier_attribute_group = {
673         .name = "amplifier",
674         .attrs = amplifier_attrs,
675 };
676
677 static void remove_amplifier(struct platform_device *dev)
678 {
679         if (quirks->amplifier > 0)
680                 sysfs_remove_group(&dev->dev.kobj, &amplifier_attribute_group);
681 }
682
683 static int create_amplifier(struct platform_device *dev)
684 {
685         int ret;
686
687         ret = sysfs_create_group(&dev->dev.kobj, &amplifier_attribute_group);
688         if (ret)
689                 remove_amplifier(dev);
690         return ret;
691 }
692
693 /*
694  * Deep Sleep Control support
695  * - Modifies BIOS setting for deep sleep control allowing extra wakeup events
696  */
697 static ssize_t show_deepsleep_status(struct device *dev,
698                                      struct device_attribute *attr, char *buf)
699 {
700         acpi_status status;
701         u32 out_data;
702         struct wmax_basic_args in_args = {
703                 .arg = 0,
704         };
705         status = alienware_wmax_command(&in_args, WMAX_METHOD_DEEP_SLEEP_STATUS,
706                                         (u32 *) &out_data);
707         if (ACPI_SUCCESS(status)) {
708                 if (out_data == 0)
709                         return scnprintf(buf, PAGE_SIZE,
710                                          "[disabled] s5 s5_s4\n");
711                 else if (out_data == 1)
712                         return scnprintf(buf, PAGE_SIZE,
713                                          "disabled [s5] s5_s4\n");
714                 else if (out_data == 2)
715                         return scnprintf(buf, PAGE_SIZE,
716                                          "disabled s5 [s5_s4]\n");
717         }
718         pr_err("alienware-wmi: unknown deep sleep status: %d\n", status);
719         return scnprintf(buf, PAGE_SIZE, "disabled s5 s5_s4 [unknown]\n");
720 }
721
722 static ssize_t toggle_deepsleep(struct device *dev,
723                                 struct device_attribute *attr,
724                                 const char *buf, size_t count)
725 {
726         acpi_status status;
727         struct wmax_basic_args args;
728
729         if (strcmp(buf, "disabled\n") == 0)
730                 args.arg = 0;
731         else if (strcmp(buf, "s5\n") == 0)
732                 args.arg = 1;
733         else
734                 args.arg = 2;
735         pr_debug("alienware-wmi: setting deep sleep to %d : %s", args.arg, buf);
736
737         status = alienware_wmax_command(&args, WMAX_METHOD_DEEP_SLEEP_CONTROL,
738                                         NULL);
739
740         if (ACPI_FAILURE(status))
741                 pr_err("alienware-wmi: deep sleep control failed: results: %u\n",
742                         status);
743         return count;
744 }
745
746 static DEVICE_ATTR(deepsleep, S_IRUGO | S_IWUSR, show_deepsleep_status, toggle_deepsleep);
747
748 static struct attribute *deepsleep_attrs[] = {
749         &dev_attr_deepsleep.attr,
750         NULL,
751 };
752
753 static const struct attribute_group deepsleep_attribute_group = {
754         .name = "deepsleep",
755         .attrs = deepsleep_attrs,
756 };
757
758 static void remove_deepsleep(struct platform_device *dev)
759 {
760         if (quirks->deepslp > 0)
761                 sysfs_remove_group(&dev->dev.kobj, &deepsleep_attribute_group);
762 }
763
764 static int create_deepsleep(struct platform_device *dev)
765 {
766         int ret;
767
768         ret = sysfs_create_group(&dev->dev.kobj, &deepsleep_attribute_group);
769         if (ret)
770                 remove_deepsleep(dev);
771         return ret;
772 }
773
774 static int __init alienware_wmi_init(void)
775 {
776         int ret;
777
778         if (wmi_has_guid(LEGACY_CONTROL_GUID))
779                 interface = LEGACY;
780         else if (wmi_has_guid(WMAX_CONTROL_GUID))
781                 interface = WMAX;
782         else {
783                 pr_warn("alienware-wmi: No known WMI GUID found\n");
784                 return -ENODEV;
785         }
786
787         dmi_check_system(alienware_quirks);
788         if (quirks == NULL)
789                 quirks = &quirk_unknown;
790
791         ret = platform_driver_register(&platform_driver);
792         if (ret)
793                 goto fail_platform_driver;
794         platform_device = platform_device_alloc("alienware-wmi", -1);
795         if (!platform_device) {
796                 ret = -ENOMEM;
797                 goto fail_platform_device1;
798         }
799         ret = platform_device_add(platform_device);
800         if (ret)
801                 goto fail_platform_device2;
802
803         if (quirks->hdmi_mux > 0) {
804                 ret = create_hdmi(platform_device);
805                 if (ret)
806                         goto fail_prep_hdmi;
807         }
808
809         if (quirks->amplifier > 0) {
810                 ret = create_amplifier(platform_device);
811                 if (ret)
812                         goto fail_prep_amplifier;
813         }
814
815         if (quirks->deepslp > 0) {
816                 ret = create_deepsleep(platform_device);
817                 if (ret)
818                         goto fail_prep_deepsleep;
819         }
820
821         ret = alienware_zone_init(platform_device);
822         if (ret)
823                 goto fail_prep_zones;
824
825         return 0;
826
827 fail_prep_zones:
828         alienware_zone_exit(platform_device);
829 fail_prep_deepsleep:
830 fail_prep_amplifier:
831 fail_prep_hdmi:
832         platform_device_del(platform_device);
833 fail_platform_device2:
834         platform_device_put(platform_device);
835 fail_platform_device1:
836         platform_driver_unregister(&platform_driver);
837 fail_platform_driver:
838         return ret;
839 }
840
841 module_init(alienware_wmi_init);
842
843 static void __exit alienware_wmi_exit(void)
844 {
845         if (platform_device) {
846                 alienware_zone_exit(platform_device);
847                 remove_hdmi(platform_device);
848                 platform_device_unregister(platform_device);
849                 platform_driver_unregister(&platform_driver);
850         }
851 }
852
853 module_exit(alienware_wmi_exit);