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