drivers/platform/x86/alienware-wmi.c

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