drivers/platform/x86/asus_acpi.c

   1 /*
   2  *  asus_acpi.c - Asus Laptop ACPI Extras
   3  *
   4  *
   5  *  Copyright (C) 2002-2005 Julien Lerouge, 2003-2006 Karol Kozimor
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (at your option) any later version.
  11  *
  12  *  This program is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *  GNU General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with this program; if not, write to the Free Software
  19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  *
  22  *  The development page for this driver is located at
  23  *  http://sourceforge.net/projects/acpi4asus/
  24  *
  25  *  Credits:
  26  *  Pontus Fuchs   - Helper functions, cleanup
  27  *  Johann Wiesner - Small compile fixes
  28  *  John Belmonte  - ACPI code for Toshiba laptop was a good starting point.
  29  *  �ic Burghard  - LED display support for W1N
  30  *
  31  */
  32
  33 #include <linux/kernel.h>
  34 #include <linux/module.h>
  35 #include <linux/slab.h>
  36 #include <linux/init.h>
  37 #include <linux/types.h>
  38 #include <linux/proc_fs.h>
  39 #include <linux/seq_file.h>
  40 #include <linux/backlight.h>
  41 #include <acpi/acpi_drivers.h>
  42 #include <acpi/acpi_bus.h>
  43 #include <asm/uaccess.h>
  44
  45 #define ASUS_ACPI_VERSION "0.30"
  46
  47 #define PROC_ASUS       "asus"  /* The directory */
  48 #define PROC_MLED       "mled"
  49 #define PROC_WLED       "wled"
  50 #define PROC_TLED       "tled"
  51 #define PROC_BT         "bluetooth"
  52 #define PROC_LEDD       "ledd"
  53 #define PROC_INFO       "info"
  54 #define PROC_LCD        "lcd"
  55 #define PROC_BRN        "brn"
  56 #define PROC_DISP       "disp"
  57
  58 #define ACPI_HOTK_NAME          "Asus Laptop ACPI Extras Driver"
  59 #define ACPI_HOTK_CLASS         "hotkey"
  60 #define ACPI_HOTK_DEVICE_NAME   "Hotkey"
  61
  62 /*
  63  * Some events we use, same for all Asus
  64  */
  65 #define BR_UP       0x10
  66 #define BR_DOWN     0x20
  67
  68 /*
  69  * Flags for hotk status
  70  */
  71 #define MLED_ON     0x01        /* Mail LED */
  72 #define WLED_ON     0x02        /* Wireless LED */
  73 #define TLED_ON     0x04        /* Touchpad LED */
  74 #define BT_ON       0x08        /* Internal Bluetooth */
  75
  76 MODULE_AUTHOR("Julien Lerouge, Karol Kozimor");
  77 MODULE_DESCRIPTION(ACPI_HOTK_NAME);
  78 MODULE_LICENSE("GPL");
  79
  80 static uid_t asus_uid;
  81 static gid_t asus_gid;
  82 module_param(asus_uid, uint, 0);
  83 MODULE_PARM_DESC(asus_uid, "UID for entries in /proc/acpi/asus");
  84 module_param(asus_gid, uint, 0);
  85 MODULE_PARM_DESC(asus_gid, "GID for entries in /proc/acpi/asus");
  86
  87 /* For each model, all features implemented,
  88  * those marked with R are relative to HOTK, A for absolute */
  89 struct model_data {
  90         char *name;             /* name of the laptop________________A */
  91         char *mt_mled;          /* method to handle mled_____________R */
  92         char *mled_status;      /* node to handle mled reading_______A */
  93         char *mt_wled;          /* method to handle wled_____________R */
  94         char *wled_status;      /* node to handle wled reading_______A */
  95         char *mt_tled;          /* method to handle tled_____________R */
  96         char *tled_status;      /* node to handle tled reading_______A */
  97         char *mt_ledd;          /* method to handle LED display______R */
  98         char *mt_bt_switch;     /* method to switch Bluetooth on/off_R */
  99         char *bt_status;        /* no model currently supports this__? */
 100         char *mt_lcd_switch;    /* method to turn LCD on/off_________A */
 101         char *lcd_status;       /* node to read LCD panel state______A */
 102         char *brightness_up;    /* method to set brightness up_______A */
 103         char *brightness_down;  /* method to set brightness down ____A */
 104         char *brightness_set;   /* method to set absolute brightness_R */
 105         char *brightness_get;   /* method to get absolute brightness_R */
 106         char *brightness_status;/* node to get brightness____________A */
 107         char *display_set;      /* method to set video output________R */
 108         char *display_get;      /* method to get video output________R */
 109 };
 110
 111 /*
 112  * This is the main structure, we can use it to store anything interesting
 113  * about the hotk device
 114  */
 115 struct asus_hotk {
 116         struct acpi_device *device;     /* the device we are in */
 117         acpi_handle handle;             /* the handle of the hotk device */
 118         char status;                    /* status of the hotk, for LEDs */
 119         u32 ledd_status;                /* status of the LED display */
 120         struct model_data *methods;     /* methods available on the laptop */
 121         u8 brightness;                  /* brightness level */
 122         enum {
 123                 A1x = 0,        /* A1340D, A1300F */
 124                 A2x,            /* A2500H */
 125                 A4G,            /* A4700G */
 126                 D1x,            /* D1 */
 127                 L2D,            /* L2000D */
 128                 L3C,            /* L3800C */
 129                 L3D,            /* L3400D */
 130                 L3H,            /* L3H, L2000E, L5D */
 131                 L4R,            /* L4500R */
 132                 L5x,            /* L5800C */
 133                 L8L,            /* L8400L */
 134                 M1A,            /* M1300A */
 135                 M2E,            /* M2400E, L4400L */
 136                 M6N,            /* M6800N, W3400N */
 137                 M6R,            /* M6700R, A3000G */
 138                 P30,            /* Samsung P30 */
 139                 S1x,            /* S1300A, but also L1400B and M2400A (L84F) */
 140                 S2x,            /* S200 (J1 reported), Victor MP-XP7210 */
 141                 W1N,            /* W1000N */
 142                 W5A,            /* W5A */
 143                 W3V,            /* W3030V */
 144                 xxN,            /* M2400N, M3700N, M5200N, M6800N,
 145                                                          S1300N, S5200N*/
 146                 A4S,            /* Z81sp */
 147                 F3Sa,           /* (Centrino) */
 148                 R1F,
 149                 END_MODEL
 150         } model;                /* Models currently supported */
 151         u16 event_count[128];   /* Count for each event TODO make this better */
 152 };
 153
 154 /* Here we go */
 155 #define A1x_PREFIX "\\_SB.PCI0.ISA.EC0."
 156 #define L3C_PREFIX "\\_SB.PCI0.PX40.ECD0."
 157 #define M1A_PREFIX "\\_SB.PCI0.PX40.EC0."
 158 #define P30_PREFIX "\\_SB.PCI0.LPCB.EC0."
 159 #define S1x_PREFIX "\\_SB.PCI0.PX40."
 160 #define S2x_PREFIX A1x_PREFIX
 161 #define xxN_PREFIX "\\_SB.PCI0.SBRG.EC0."
 162
 163 static struct model_data model_conf[END_MODEL] = {
 164         /*
 165          * TODO I have seen a SWBX and AIBX method on some models, like L1400B,
 166          * it seems to be a kind of switch, but what for ?
 167          */
 168
 169         {
 170          .name = "A1x",
 171          .mt_mled = "MLED",
 172          .mled_status = "\\MAIL",
 173          .mt_lcd_switch = A1x_PREFIX "_Q10",
 174          .lcd_status = "\\BKLI",
 175          .brightness_up = A1x_PREFIX "_Q0E",
 176          .brightness_down = A1x_PREFIX "_Q0F"},
 177
 178         {
 179          .name = "A2x",
 180          .mt_mled = "MLED",
 181          .mt_wled = "WLED",
 182          .wled_status = "\\SG66",
 183          .mt_lcd_switch = "\\Q10",
 184          .lcd_status = "\\BAOF",
 185          .brightness_set = "SPLV",
 186          .brightness_get = "GPLV",
 187          .display_set = "SDSP",
 188          .display_get = "\\INFB"},
 189
 190         {
 191          .name = "A4G",
 192          .mt_mled = "MLED",
 193 /* WLED present, but not controlled by ACPI */
 194          .mt_lcd_switch = xxN_PREFIX "_Q10",
 195          .brightness_set = "SPLV",
 196          .brightness_get = "GPLV",
 197          .display_set = "SDSP",
 198          .display_get = "\\ADVG"},
 199
 200         {
 201          .name = "D1x",
 202          .mt_mled = "MLED",
 203          .mt_lcd_switch = "\\Q0D",
 204          .lcd_status = "\\GP11",
 205          .brightness_up = "\\Q0C",
 206          .brightness_down = "\\Q0B",
 207          .brightness_status = "\\BLVL",
 208          .display_set = "SDSP",
 209          .display_get = "\\INFB"},
 210
 211         {
 212          .name = "L2D",
 213          .mt_mled = "MLED",
 214          .mled_status = "\\SGP6",
 215          .mt_wled = "WLED",
 216          .wled_status = "\\RCP3",
 217          .mt_lcd_switch = "\\Q10",
 218          .lcd_status = "\\SGP0",
 219          .brightness_up = "\\Q0E",
 220          .brightness_down = "\\Q0F",
 221          .display_set = "SDSP",
 222          .display_get = "\\INFB"},
 223
 224         {
 225          .name = "L3C",
 226          .mt_mled = "MLED",
 227          .mt_wled = "WLED",
 228          .mt_lcd_switch = L3C_PREFIX "_Q10",
 229          .lcd_status = "\\GL32",
 230          .brightness_set = "SPLV",
 231          .brightness_get = "GPLV",
 232          .display_set = "SDSP",
 233          .display_get = "\\_SB.PCI0.PCI1.VGAC.NMAP"},
 234
 235         {
 236          .name = "L3D",
 237          .mt_mled = "MLED",
 238          .mled_status = "\\MALD",
 239          .mt_wled = "WLED",
 240          .mt_lcd_switch = "\\Q10",
 241          .lcd_status = "\\BKLG",
 242          .brightness_set = "SPLV",
 243          .brightness_get = "GPLV",
 244          .display_set = "SDSP",
 245          .display_get = "\\INFB"},
 246
 247         {
 248          .name = "L3H",
 249          .mt_mled = "MLED",
 250          .mt_wled = "WLED",
 251          .mt_lcd_switch = "EHK",
 252          .lcd_status = "\\_SB.PCI0.PM.PBC",
 253          .brightness_set = "SPLV",
 254          .brightness_get = "GPLV",
 255          .display_set = "SDSP",
 256          .display_get = "\\INFB"},
 257
 258         {
 259          .name = "L4R",
 260          .mt_mled = "MLED",
 261          .mt_wled = "WLED",
 262          .wled_status = "\\_SB.PCI0.SBRG.SG13",
 263          .mt_lcd_switch = xxN_PREFIX "_Q10",
 264          .lcd_status = "\\_SB.PCI0.SBSM.SEO4",
 265          .brightness_set = "SPLV",
 266          .brightness_get = "GPLV",
 267          .display_set = "SDSP",
 268          .display_get = "\\_SB.PCI0.P0P1.VGA.GETD"},
 269
 270         {
 271          .name = "L5x",
 272          .mt_mled = "MLED",
 273 /* WLED present, but not controlled by ACPI */
 274          .mt_tled = "TLED",
 275          .mt_lcd_switch = "\\Q0D",
 276          .lcd_status = "\\BAOF",
 277          .brightness_set = "SPLV",
 278          .brightness_get = "GPLV",
 279          .display_set = "SDSP",
 280          .display_get = "\\INFB"},
 281
 282         {
 283          .name = "L8L"
 284 /* No features, but at least support the hotkeys */
 285          },
 286
 287         {
 288          .name = "M1A",
 289          .mt_mled = "MLED",
 290          .mt_lcd_switch = M1A_PREFIX "Q10",
 291          .lcd_status = "\\PNOF",
 292          .brightness_up = M1A_PREFIX "Q0E",
 293          .brightness_down = M1A_PREFIX "Q0F",
 294          .brightness_status = "\\BRIT",
 295          .display_set = "SDSP",
 296          .display_get = "\\INFB"},
 297
 298         {
 299          .name = "M2E",
 300          .mt_mled = "MLED",
 301          .mt_wled = "WLED",
 302          .mt_lcd_switch = "\\Q10",
 303          .lcd_status = "\\GP06",
 304          .brightness_set = "SPLV",
 305          .brightness_get = "GPLV",
 306          .display_set = "SDSP",
 307          .display_get = "\\INFB"},
 308
 309         {
 310          .name = "M6N",
 311          .mt_mled = "MLED",
 312          .mt_wled = "WLED",
 313          .wled_status = "\\_SB.PCI0.SBRG.SG13",
 314          .mt_lcd_switch = xxN_PREFIX "_Q10",
 315          .lcd_status = "\\_SB.BKLT",
 316          .brightness_set = "SPLV",
 317          .brightness_get = "GPLV",
 318          .display_set = "SDSP",
 319          .display_get = "\\SSTE"},
 320
 321         {
 322          .name = "M6R",
 323          .mt_mled = "MLED",
 324          .mt_wled = "WLED",
 325          .mt_lcd_switch = xxN_PREFIX "_Q10",
 326          .lcd_status = "\\_SB.PCI0.SBSM.SEO4",
 327          .brightness_set = "SPLV",
 328          .brightness_get = "GPLV",
 329          .display_set = "SDSP",
 330          .display_get = "\\_SB.PCI0.P0P1.VGA.GETD"},
 331
 332         {
 333          .name = "P30",
 334          .mt_wled = "WLED",
 335          .mt_lcd_switch = P30_PREFIX "_Q0E",
 336          .lcd_status = "\\BKLT",
 337          .brightness_up = P30_PREFIX "_Q68",
 338          .brightness_down = P30_PREFIX "_Q69",
 339          .brightness_get = "GPLV",
 340          .display_set = "SDSP",
 341          .display_get = "\\DNXT"},
 342
 343         {
 344          .name = "S1x",
 345          .mt_mled = "MLED",
 346          .mled_status = "\\EMLE",
 347          .mt_wled = "WLED",
 348          .mt_lcd_switch = S1x_PREFIX "Q10",
 349          .lcd_status = "\\PNOF",
 350          .brightness_set = "SPLV",
 351          .brightness_get = "GPLV"},
 352
 353         {
 354          .name = "S2x",
 355          .mt_mled = "MLED",
 356          .mled_status = "\\MAIL",
 357          .mt_lcd_switch = S2x_PREFIX "_Q10",
 358          .lcd_status = "\\BKLI",
 359          .brightness_up = S2x_PREFIX "_Q0B",
 360          .brightness_down = S2x_PREFIX "_Q0A"},
 361
 362         {
 363          .name = "W1N",
 364          .mt_mled = "MLED",
 365          .mt_wled = "WLED",
 366          .mt_ledd = "SLCM",
 367          .mt_lcd_switch = xxN_PREFIX "_Q10",
 368          .lcd_status = "\\BKLT",
 369          .brightness_set = "SPLV",
 370          .brightness_get = "GPLV",
 371          .display_set = "SDSP",
 372          .display_get = "\\ADVG"},
 373
 374         {
 375          .name = "W5A",
 376          .mt_bt_switch = "BLED",
 377          .mt_wled = "WLED",
 378          .mt_lcd_switch = xxN_PREFIX "_Q10",
 379          .brightness_set = "SPLV",
 380          .brightness_get = "GPLV",
 381          .display_set = "SDSP",
 382          .display_get = "\\ADVG"},
 383
 384         {
 385          .name = "W3V",
 386          .mt_mled = "MLED",
 387          .mt_wled = "WLED",
 388          .mt_lcd_switch = xxN_PREFIX "_Q10",
 389          .lcd_status = "\\BKLT",
 390          .brightness_set = "SPLV",
 391          .brightness_get = "GPLV",
 392          .display_set = "SDSP",
 393          .display_get = "\\INFB"},
 394
 395        {
 396          .name = "xxN",
 397          .mt_mled = "MLED",
 398 /* WLED present, but not controlled by ACPI */
 399          .mt_lcd_switch = xxN_PREFIX "_Q10",
 400          .lcd_status = "\\BKLT",
 401          .brightness_set = "SPLV",
 402          .brightness_get = "GPLV",
 403          .display_set = "SDSP",
 404         .display_get = "\\ADVG"},
 405
 406         {
 407                 .name              = "A4S",
 408                 .brightness_set    = "SPLV",
 409                 .brightness_get    = "GPLV",
 410                 .mt_bt_switch      = "BLED",
 411                 .mt_wled           = "WLED"
 412         },
 413
 414         {
 415                 .name           = "F3Sa",
 416                 .mt_bt_switch   = "BLED",
 417                 .mt_wled        = "WLED",
 418                 .mt_mled        = "MLED",
 419                 .brightness_get = "GPLV",
 420                 .brightness_set = "SPLV",
 421                 .mt_lcd_switch  = "\\_SB.PCI0.SBRG.EC0._Q10",
 422                 .lcd_status     = "\\_SB.PCI0.SBRG.EC0.RPIN",
 423                 .display_get    = "\\ADVG",
 424                 .display_set    = "SDSP",
 425         },
 426         {
 427                 .name = "R1F",
 428                 .mt_bt_switch = "BLED",
 429                 .mt_mled = "MLED",
 430                 .mt_wled = "WLED",
 431                 .mt_lcd_switch = "\\Q10",
 432                 .lcd_status = "\\GP06",
 433                 .brightness_set = "SPLV",
 434                 .brightness_get = "GPLV",
 435                 .display_set = "SDSP",
 436                 .display_get = "\\INFB"
 437         }
 438 };
 439
 440 /* procdir we use */
 441 static struct proc_dir_entry *asus_proc_dir;
 442
 443 static struct backlight_device *asus_backlight_device;
 444
 445 /*
 446  * This header is made available to allow proper configuration given model,
 447  * revision number , ... this info cannot go in struct asus_hotk because it is
 448  * available before the hotk
 449  */
 450 static struct acpi_table_header *asus_info;
 451
 452 /* The actual device the driver binds to */
 453 static struct asus_hotk *hotk;
 454
 455 /*
 456  * The hotkey driver and autoloading declaration
 457  */
 458 static int asus_hotk_add(struct acpi_device *device);
 459 static int asus_hotk_remove(struct acpi_device *device, int type);
 460 static void asus_hotk_notify(struct acpi_device *device, u32 event);
 461
 462 static const struct acpi_device_id asus_device_ids[] = {
 463         {"ATK0100", 0},
 464         {"", 0},
 465 };
 466 MODULE_DEVICE_TABLE(acpi, asus_device_ids);
 467
 468 static struct acpi_driver asus_hotk_driver = {
 469         .name = "asus_acpi",
 470         .class = ACPI_HOTK_CLASS,
 471         .owner = THIS_MODULE,
 472         .ids = asus_device_ids,
 473         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
 474         .ops = {
 475                 .add = asus_hotk_add,
 476                 .remove = asus_hotk_remove,
 477                 .notify = asus_hotk_notify,
 478                 },
 479 };
 480
 481 /*
 482  * This function evaluates an ACPI method, given an int as parameter, the
 483  * method is searched within the scope of the handle, can be NULL. The output
 484  * of the method is written is output, which can also be NULL
 485  *
 486  * returns 1 if write is successful, 0 else.
 487  */
 488 static int write_acpi_int(acpi_handle handle, const char *method, int val,
 489                           struct acpi_buffer *output)
 490 {
 491         struct acpi_object_list params; /* list of input parameters (int) */
 492         union acpi_object in_obj;       /* the only param we use */
 493         acpi_status status;
 494
 495         params.count = 1;
 496         params.pointer = &in_obj;
 497         in_obj.type = ACPI_TYPE_INTEGER;
 498         in_obj.integer.value = val;
 499
 500         status = acpi_evaluate_object(handle, (char *)method, &params, output);
 501         return (status == AE_OK);
 502 }
 503
 504 static int read_acpi_int(acpi_handle handle, const char *method, int *val)
 505 {
 506         struct acpi_buffer output;
 507         union acpi_object out_obj;
 508         acpi_status status;
 509
 510         output.length = sizeof(out_obj);
 511         output.pointer = &out_obj;
 512
 513         status = acpi_evaluate_object(handle, (char *)method, NULL, &output);
 514         *val = out_obj.integer.value;
 515         return (status == AE_OK) && (out_obj.type == ACPI_TYPE_INTEGER);
 516 }
 517
 518 static int asus_info_proc_show(struct seq_file *m, void *v)
 519 {
 520         int temp;
 521
 522         seq_printf(m, ACPI_HOTK_NAME " " ASUS_ACPI_VERSION "\n");
 523         seq_printf(m, "Model reference    : %s\n", hotk->methods->name);
 524         /*
 525          * The SFUN method probably allows the original driver to get the list
 526          * of features supported by a given model. For now, 0x0100 or 0x0800
 527          * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
 528          * The significance of others is yet to be found.
 529          */
 530         if (read_acpi_int(hotk->handle, "SFUN", &temp))
 531                 seq_printf(m, "SFUN value         : 0x%04x\n", temp);
 532         /*
 533          * Another value for userspace: the ASYM method returns 0x02 for
 534          * battery low and 0x04 for battery critical, its readings tend to be
 535          * more accurate than those provided by _BST.
 536          * Note: since not all the laptops provide this method, errors are
 537          * silently ignored.
 538          */
 539         if (read_acpi_int(hotk->handle, "ASYM", &temp))
 540                 seq_printf(m, "ASYM value         : 0x%04x\n", temp);
 541         if (asus_info) {
 542                 seq_printf(m, "DSDT length        : %d\n", asus_info->length);
 543                 seq_printf(m, "DSDT checksum      : %d\n", asus_info->checksum);
 544                 seq_printf(m, "DSDT revision      : %d\n", asus_info->revision);
 545                 seq_printf(m, "OEM id             : %.*s\n", ACPI_OEM_ID_SIZE, asus_info->oem_id);
 546                 seq_printf(m, "OEM table id       : %.*s\n", ACPI_OEM_TABLE_ID_SIZE, asus_info->oem_table_id);
 547                 seq_printf(m, "OEM revision       : 0x%x\n", asus_info->oem_revision);
 548                 seq_printf(m, "ASL comp vendor id : %.*s\n", ACPI_NAME_SIZE, asus_info->asl_compiler_id);
 549                 seq_printf(m, "ASL comp revision  : 0x%x\n", asus_info->asl_compiler_revision);
 550         }
 551
 552         return 0;
 553 }
 554
 555 static int asus_info_proc_open(struct inode *inode, struct file *file)
 556 {
 557         return single_open(file, asus_info_proc_show, NULL);
 558 }
 559
 560 static const struct file_operations asus_info_proc_fops = {
 561         .owner          = THIS_MODULE,
 562         .open           = asus_info_proc_open,
 563         .read           = seq_read,
 564         .llseek         = seq_lseek,
 565         .release        = single_release,
 566 };
 567
 568 /*
 569  * /proc handlers
 570  * We write our info in page, we begin at offset off and cannot write more
 571  * than count bytes. We set eof to 1 if we handle those 2 values. We return the
 572  * number of bytes written in page
 573  */
 574
 575 /* Generic LED functions */
 576 static int read_led(const char *ledname, int ledmask)
 577 {
 578         if (ledname) {
 579                 int led_status;
 580
 581                 if (read_acpi_int(NULL, ledname, &led_status))
 582                         return led_status;
 583                 else
 584                         printk(KERN_WARNING "Asus ACPI: Error reading LED "
 585                                "status\n");
 586         }
 587         return (hotk->status & ledmask) ? 1 : 0;
 588 }
 589
 590 static int parse_arg(const char __user *buf, unsigned long count, int *val)
 591 {
 592         char s[32];
 593         if (!count)
 594                 return 0;
 595         if (count > 31)
 596                 return -EINVAL;
 597         if (copy_from_user(s, buf, count))
 598                 return -EFAULT;
 599         s[count] = 0;
 600         if (sscanf(s, "%i", val) != 1)
 601                 return -EINVAL;
 602         return count;
 603 }
 604
 605 /* FIXME: kill extraneous args so it can be called independently */
 606 static int
 607 write_led(const char __user *buffer, unsigned long count,
 608           char *ledname, int ledmask, int invert)
 609 {
 610         int rv, value;
 611         int led_out = 0;
 612
 613         rv = parse_arg(buffer, count, &value);
 614         if (rv > 0)
 615                 led_out = value ? 1 : 0;
 616
 617         hotk->status =
 618             (led_out) ? (hotk->status | ledmask) : (hotk->status & ~ledmask);
 619
 620         if (invert)             /* invert target value */
 621                 led_out = !led_out;
 622
 623         if (!write_acpi_int(hotk->handle, ledname, led_out, NULL))
 624                 printk(KERN_WARNING "Asus ACPI: LED (%s) write failed\n",
 625                        ledname);
 626
 627         return rv;
 628 }
 629
 630 /*
 631  * Proc handlers for MLED
 632  */
 633 static int mled_proc_show(struct seq_file *m, void *v)
 634 {
 635         seq_printf(m, "%d\n", read_led(hotk->methods->mled_status, MLED_ON));
 636         return 0;
 637 }
 638
 639 static int mled_proc_open(struct inode *inode, struct file *file)
 640 {
 641         return single_open(file, mled_proc_show, NULL);
 642 }
 643
 644 static ssize_t mled_proc_write(struct file *file, const char __user *buffer,
 645                 size_t count, loff_t *pos)
 646 {
 647         return write_led(buffer, count, hotk->methods->mt_mled, MLED_ON, 1);
 648 }
 649
 650 static const struct file_operations mled_proc_fops = {
 651         .owner          = THIS_MODULE,
 652         .open           = mled_proc_open,
 653         .read           = seq_read,
 654         .llseek         = seq_lseek,
 655         .release        = single_release,
 656         .write          = mled_proc_write,
 657 };
 658
 659 /*
 660  * Proc handlers for LED display
 661  */
 662 static int ledd_proc_show(struct seq_file *m, void *v)
 663 {
 664         seq_printf(m, "0x%08x\n", hotk->ledd_status);
 665         return 0;
 666 }
 667
 668 static int ledd_proc_open(struct inode *inode, struct file *file)
 669 {
 670         return single_open(file, ledd_proc_show, NULL);
 671 }
 672
 673 static ssize_t ledd_proc_write(struct file *file, const char __user *buffer,
 674                 size_t count, loff_t *pos)
 675 {
 676         int rv, value;
 677
 678         rv = parse_arg(buffer, count, &value);
 679         if (rv > 0) {
 680                 if (!write_acpi_int
 681                     (hotk->handle, hotk->methods->mt_ledd, value, NULL))
 682                         printk(KERN_WARNING
 683                                "Asus ACPI: LED display write failed\n");
 684                 else
 685                         hotk->ledd_status = (u32) value;
 686         }
 687         return rv;
 688 }
 689
 690 static const struct file_operations ledd_proc_fops = {
 691         .owner          = THIS_MODULE,
 692         .open           = ledd_proc_open,
 693         .read           = seq_read,
 694         .llseek         = seq_lseek,
 695         .release        = single_release,
 696         .write          = ledd_proc_write,
 697 };
 698
 699 /*
 700  * Proc handlers for WLED
 701  */
 702 static int wled_proc_show(struct seq_file *m, void *v)
 703 {
 704         seq_printf(m, "%d\n", read_led(hotk->methods->wled_status, WLED_ON));
 705         return 0;
 706 }
 707
 708 static int wled_proc_open(struct inode *inode, struct file *file)
 709 {
 710         return single_open(file, wled_proc_show, NULL);
 711 }
 712
 713 static ssize_t wled_proc_write(struct file *file, const char __user *buffer,
 714                 size_t count, loff_t *pos)
 715 {
 716         return write_led(buffer, count, hotk->methods->mt_wled, WLED_ON, 0);
 717 }
 718
 719 static const struct file_operations wled_proc_fops = {
 720         .owner          = THIS_MODULE,
 721         .open           = wled_proc_open,
 722         .read           = seq_read,
 723         .llseek         = seq_lseek,
 724         .release        = single_release,
 725         .write          = wled_proc_write,
 726 };
 727
 728 /*
 729  * Proc handlers for Bluetooth
 730  */
 731 static int bluetooth_proc_show(struct seq_file *m, void *v)
 732 {
 733         seq_printf(m, "%d\n", read_led(hotk->methods->bt_status, BT_ON));
 734         return 0;
 735 }
 736
 737 static int bluetooth_proc_open(struct inode *inode, struct file *file)
 738 {
 739         return single_open(file, bluetooth_proc_show, NULL);
 740 }
 741
 742 static ssize_t bluetooth_proc_write(struct file *file,
 743                 const char __user *buffer, size_t count, loff_t *pos)
 744 {
 745         /* Note: mt_bt_switch controls both internal Bluetooth adapter's
 746            presence and its LED */
 747         return write_led(buffer, count, hotk->methods->mt_bt_switch, BT_ON, 0);
 748 }
 749
 750 static const struct file_operations bluetooth_proc_fops = {
 751         .owner          = THIS_MODULE,
 752         .open           = bluetooth_proc_open,
 753         .read           = seq_read,
 754         .llseek         = seq_lseek,
 755         .release        = single_release,
 756         .write          = bluetooth_proc_write,
 757 };
 758
 759 /*
 760  * Proc handlers for TLED
 761  */
 762 static int tled_proc_show(struct seq_file *m, void *v)
 763 {
 764         seq_printf(m, "%d\n", read_led(hotk->methods->tled_status, TLED_ON));
 765         return 0;
 766 }
 767
 768 static int tled_proc_open(struct inode *inode, struct file *file)
 769 {
 770         return single_open(file, tled_proc_show, NULL);
 771 }
 772
 773 static ssize_t tled_proc_write(struct file *file, const char __user *buffer,
 774                 size_t count, loff_t *pos)
 775 {
 776         return write_led(buffer, count, hotk->methods->mt_tled, TLED_ON, 0);
 777 }
 778
 779 static const struct file_operations tled_proc_fops = {
 780         .owner          = THIS_MODULE,
 781         .open           = tled_proc_open,
 782         .read           = seq_read,
 783         .llseek         = seq_lseek,
 784         .release        = single_release,
 785         .write          = tled_proc_write,
 786 };
 787
 788 static int get_lcd_state(void)
 789 {
 790         int lcd = 0;
 791
 792         if (hotk->model == L3H) {
 793                 /* L3H and the like have to be handled differently */
 794                 acpi_status status = 0;
 795                 struct acpi_object_list input;
 796                 union acpi_object mt_params[2];
 797                 struct acpi_buffer output;
 798                 union acpi_object out_obj;
 799
 800                 input.count = 2;
 801                 input.pointer = mt_params;
 802                 /* Note: the following values are partly guessed up, but
 803                    otherwise they seem to work */
 804                 mt_params[0].type = ACPI_TYPE_INTEGER;
 805                 mt_params[0].integer.value = 0x02;
 806                 mt_params[1].type = ACPI_TYPE_INTEGER;
 807                 mt_params[1].integer.value = 0x02;
 808
 809                 output.length = sizeof(out_obj);
 810                 output.pointer = &out_obj;
 811
 812                 status =
 813                     acpi_evaluate_object(NULL, hotk->methods->lcd_status,
 814                                          &input, &output);
 815                 if (status != AE_OK)
 816                         return -1;
 817                 if (out_obj.type == ACPI_TYPE_INTEGER)
 818                         /* That's what the AML code does */
 819                         lcd = out_obj.integer.value >> 8;
 820         } else if (hotk->model == F3Sa) {
 821                 unsigned long long tmp;
 822                 union acpi_object param;
 823                 struct acpi_object_list input;
 824                 acpi_status status;
 825
 826                 /* Read pin 11 */
 827                 param.type = ACPI_TYPE_INTEGER;
 828                 param.integer.value = 0x11;
 829                 input.count = 1;
 830                 input.pointer = &param;
 831
 832                 status = acpi_evaluate_integer(NULL, hotk->methods->lcd_status,
 833                                                 &input, &tmp);
 834                 if (status != AE_OK)
 835                         return -1;
 836
 837                 lcd = tmp;
 838         } else {
 839                 /* We don't have to check anything if we are here */
 840                 if (!read_acpi_int(NULL, hotk->methods->lcd_status, &lcd))
 841                         printk(KERN_WARNING
 842                                "Asus ACPI: Error reading LCD status\n");
 843
 844                 if (hotk->model == L2D)
 845                         lcd = ~lcd;
 846         }
 847
 848         return (lcd & 1);
 849 }
 850
 851 static int set_lcd_state(int value)
 852 {
 853         int lcd = 0;
 854         acpi_status status = 0;
 855
 856         lcd = value ? 1 : 0;
 857         if (lcd != get_lcd_state()) {
 858                 /* switch */
 859                 if (hotk->model != L3H) {
 860                         status =
 861                             acpi_evaluate_object(NULL,
 862                                                  hotk->methods->mt_lcd_switch,
 863                                                  NULL, NULL);
 864                 } else {
 865                         /* L3H and the like must be handled differently */
 866                         if (!write_acpi_int
 867                             (hotk->handle, hotk->methods->mt_lcd_switch, 0x07,
 868                              NULL))
 869                                 status = AE_ERROR;
 870                         /* L3H's AML executes EHK (0x07) upon Fn+F7 keypress,
 871                            the exact behaviour is simulated here */
 872                 }
 873                 if (ACPI_FAILURE(status))
 874                         printk(KERN_WARNING "Asus ACPI: Error switching LCD\n");
 875         }
 876         return 0;
 877
 878 }
 879
 880 static int lcd_proc_show(struct seq_file *m, void *v)
 881 {
 882         seq_printf(m, "%d\n", get_lcd_state());
 883         return 0;
 884 }
 885
 886 static int lcd_proc_open(struct inode *inode, struct file *file)
 887 {
 888         return single_open(file, lcd_proc_show, NULL);
 889 }
 890
 891 static ssize_t lcd_proc_write(struct file *file, const char __user *buffer,
 892                size_t count, loff_t *pos)
 893 {
 894         int rv, value;
 895
 896         rv = parse_arg(buffer, count, &value);
 897         if (rv > 0)
 898                 set_lcd_state(value);
 899         return rv;
 900 }
 901
 902 static const struct file_operations lcd_proc_fops = {
 903         .owner          = THIS_MODULE,
 904         .open           = lcd_proc_open,
 905         .read           = seq_read,
 906         .llseek         = seq_lseek,
 907         .release        = single_release,
 908         .write          = lcd_proc_write,
 909 };
 910
 911 static int read_brightness(struct backlight_device *bd)
 912 {
 913         int value;
 914
 915         if (hotk->methods->brightness_get) {    /* SPLV/GPLV laptop */
 916                 if (!read_acpi_int(hotk->handle, hotk->methods->brightness_get,
 917                                    &value))
 918                         printk(KERN_WARNING
 919                                "Asus ACPI: Error reading brightness\n");
 920         } else if (hotk->methods->brightness_status) {  /* For D1 for example */
 921                 if (!read_acpi_int(NULL, hotk->methods->brightness_status,
 922                                    &value))
 923                         printk(KERN_WARNING
 924                                "Asus ACPI: Error reading brightness\n");
 925         } else                  /* No GPLV method */
 926                 value = hotk->brightness;
 927         return value;
 928 }
 929
 930 /*
 931  * Change the brightness level
 932  */
 933 static int set_brightness(int value)
 934 {
 935         acpi_status status = 0;
 936         int ret = 0;
 937
 938         /* SPLV laptop */
 939         if (hotk->methods->brightness_set) {
 940                 if (!write_acpi_int(hotk->handle, hotk->methods->brightness_set,
 941                                     value, NULL)) {
 942                         printk(KERN_WARNING
 943                                "Asus ACPI: Error changing brightness\n");
 944                         ret = -EIO;
 945                 }
 946                 goto out;
 947         }
 948
 949         /* No SPLV method if we are here, act as appropriate */
 950         value -= read_brightness(NULL);
 951         while (value != 0) {
 952                 status = acpi_evaluate_object(NULL, (value > 0) ?
 953                                               hotk->methods->brightness_up :
 954                                               hotk->methods->brightness_down,
 955                                               NULL, NULL);
 956                 (value > 0) ? value-- : value++;
 957                 if (ACPI_FAILURE(status)) {
 958                         printk(KERN_WARNING
 959                                "Asus ACPI: Error changing brightness\n");
 960                         ret = -EIO;
 961                 }
 962         }
 963 out:
 964         return ret;
 965 }
 966
 967 static int set_brightness_status(struct backlight_device *bd)
 968 {
 969         return set_brightness(bd->props.brightness);
 970 }
 971
 972 static int brn_proc_show(struct seq_file *m, void *v)
 973 {
 974         seq_printf(m, "%d\n", read_brightness(NULL));
 975         return 0;
 976 }
 977
 978 static int brn_proc_open(struct inode *inode, struct file *file)
 979 {
 980         return single_open(file, brn_proc_show, NULL);
 981 }
 982
 983 static ssize_t brn_proc_write(struct file *file, const char __user *buffer,
 984                size_t count, loff_t *pos)
 985 {
 986         int rv, value;
 987
 988         rv = parse_arg(buffer, count, &value);
 989         if (rv > 0) {
 990                 value = (0 < value) ? ((15 < value) ? 15 : value) : 0;
 991                 /* 0 <= value <= 15 */
 992                 set_brightness(value);
 993         }
 994         return rv;
 995 }
 996
 997 static const struct file_operations brn_proc_fops = {
 998         .owner          = THIS_MODULE,
 999         .open           = brn_proc_open,
1000         .read           = seq_read,
1001         .llseek         = seq_lseek,
1002         .release        = single_release,
1003         .write          = brn_proc_write,
1004 };
1005
1006 static void set_display(int value)
1007 {
1008         /* no sanity check needed for now */
1009         if (!write_acpi_int(hotk->handle, hotk->methods->display_set,
1010                             value, NULL))
1011                 printk(KERN_WARNING "Asus ACPI: Error setting display\n");
1012         return;
1013 }
1014
1015 /*
1016  * Now, *this* one could be more user-friendly, but so far, no-one has
1017  * complained. The significance of bits is the same as in proc_write_disp()
1018  */
1019 static int disp_proc_show(struct seq_file *m, void *v)
1020 {
1021         int value = 0;
1022
1023         if (!read_acpi_int(hotk->handle, hotk->methods->display_get, &value))
1024                 printk(KERN_WARNING
1025                        "Asus ACPI: Error reading display status\n");
1026         value &= 0x07;  /* needed for some models, shouldn't hurt others */
1027         seq_printf(m, "%d\n", value);
1028         return 0;
1029 }
1030
1031 static int disp_proc_open(struct inode *inode, struct file *file)
1032 {
1033         return single_open(file, disp_proc_show, NULL);
1034 }
1035
1036 /*
1037  * Experimental support for display switching. As of now: 1 should activate
1038  * the LCD output, 2 should do for CRT, and 4 for TV-Out. Any combination
1039  * (bitwise) of these will suffice. I never actually tested 3 displays hooked
1040  * up simultaneously, so be warned. See the acpi4asus README for more info.
1041  */
1042 static ssize_t disp_proc_write(struct file *file, const char __user *buffer,
1043                 size_t count, loff_t *pos)
1044 {
1045         int rv, value;
1046
1047         rv = parse_arg(buffer, count, &value);
1048         if (rv > 0)
1049                 set_display(value);
1050         return rv;
1051 }
1052
1053 static const struct file_operations disp_proc_fops = {
1054         .owner          = THIS_MODULE,
1055         .open           = disp_proc_open,
1056         .read           = seq_read,
1057         .llseek         = seq_lseek,
1058         .release        = single_release,
1059         .write          = disp_proc_write,
1060 };
1061
1062 static int
1063 asus_proc_add(char *name, const struct file_operations *proc_fops, mode_t mode,
1064                      struct acpi_device *device)
1065 {
1066         struct proc_dir_entry *proc;
1067
1068         proc = proc_create_data(name, mode, acpi_device_dir(device),
1069                                 proc_fops, acpi_driver_data(device));
1070         if (!proc) {
1071                 printk(KERN_WARNING "  Unable to create %s fs entry\n", name);
1072                 return -1;
1073         }
1074         proc->uid = asus_uid;
1075         proc->gid = asus_gid;
1076         return 0;
1077 }
1078
1079 static int asus_hotk_add_fs(struct acpi_device *device)
1080 {
1081         struct proc_dir_entry *proc;
1082         mode_t mode;
1083
1084         if ((asus_uid == 0) && (asus_gid == 0)) {
1085                 mode = S_IFREG | S_IRUGO | S_IWUSR | S_IWGRP;
1086         } else {
1087                 mode = S_IFREG | S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP;
1088                 printk(KERN_WARNING "  asus_uid and asus_gid parameters are "
1089                        "deprecated, use chown and chmod instead!\n");
1090         }
1091
1092         acpi_device_dir(device) = asus_proc_dir;
1093         if (!acpi_device_dir(device))
1094                 return -ENODEV;
1095
1096         proc = proc_create(PROC_INFO, mode, acpi_device_dir(device),
1097                            &asus_info_proc_fops);
1098         if (proc) {
1099                 proc->uid = asus_uid;
1100                 proc->gid = asus_gid;
1101         } else {
1102                 printk(KERN_WARNING "  Unable to create " PROC_INFO
1103                        " fs entry\n");
1104         }
1105
1106         if (hotk->methods->mt_wled) {
1107                 asus_proc_add(PROC_WLED, &wled_proc_fops, mode, device);
1108         }
1109
1110         if (hotk->methods->mt_ledd) {
1111                 asus_proc_add(PROC_LEDD, &ledd_proc_fops, mode, device);
1112         }
1113
1114         if (hotk->methods->mt_mled) {
1115                 asus_proc_add(PROC_MLED, &mled_proc_fops, mode, device);
1116         }
1117
1118         if (hotk->methods->mt_tled) {
1119                 asus_proc_add(PROC_TLED, &tled_proc_fops, mode, device);
1120         }
1121
1122         if (hotk->methods->mt_bt_switch) {
1123                 asus_proc_add(PROC_BT, &bluetooth_proc_fops, mode, device);
1124         }
1125
1126         /*
1127          * We need both read node and write method as LCD switch is also
1128          * accessible from the keyboard
1129          */
1130         if (hotk->methods->mt_lcd_switch && hotk->methods->lcd_status) {
1131                 asus_proc_add(PROC_LCD, &lcd_proc_fops, mode, device);
1132         }
1133
1134         if ((hotk->methods->brightness_up && hotk->methods->brightness_down) ||
1135             (hotk->methods->brightness_get && hotk->methods->brightness_set)) {
1136                 asus_proc_add(PROC_BRN, &brn_proc_fops, mode, device);
1137         }
1138
1139         if (hotk->methods->display_set) {
1140                 asus_proc_add(PROC_DISP, &disp_proc_fops, mode, device);
1141         }
1142
1143         return 0;
1144 }
1145
1146 static int asus_hotk_remove_fs(struct acpi_device *device)
1147 {
1148         if (acpi_device_dir(device)) {
1149                 remove_proc_entry(PROC_INFO, acpi_device_dir(device));
1150                 if (hotk->methods->mt_wled)
1151                         remove_proc_entry(PROC_WLED, acpi_device_dir(device));
1152                 if (hotk->methods->mt_mled)
1153                         remove_proc_entry(PROC_MLED, acpi_device_dir(device));
1154                 if (hotk->methods->mt_tled)
1155                         remove_proc_entry(PROC_TLED, acpi_device_dir(device));
1156                 if (hotk->methods->mt_ledd)
1157                         remove_proc_entry(PROC_LEDD, acpi_device_dir(device));
1158                 if (hotk->methods->mt_bt_switch)
1159                         remove_proc_entry(PROC_BT, acpi_device_dir(device));
1160                 if (hotk->methods->mt_lcd_switch && hotk->methods->lcd_status)
1161                         remove_proc_entry(PROC_LCD, acpi_device_dir(device));
1162                 if ((hotk->methods->brightness_up
1163                      && hotk->methods->brightness_down)
1164                     || (hotk->methods->brightness_get
1165                         && hotk->methods->brightness_set))
1166                         remove_proc_entry(PROC_BRN, acpi_device_dir(device));
1167                 if (hotk->methods->display_set)
1168                         remove_proc_entry(PROC_DISP, acpi_device_dir(device));
1169         }
1170         return 0;
1171 }
1172
1173 static void asus_hotk_notify(struct acpi_device *device, u32 event)
1174 {
1175         /* TODO Find a better way to handle events count. */
1176         if (!hotk)
1177                 return;
1178
1179         /*
1180          * The BIOS *should* be sending us device events, but apparently
1181          * Asus uses system events instead, so just ignore any device
1182          * events we get.
1183          */
1184         if (event > ACPI_MAX_SYS_NOTIFY)
1185                 return;
1186
1187         if ((event & ~((u32) BR_UP)) < 16)
1188                 hotk->brightness = (event & ~((u32) BR_UP));
1189         else if ((event & ~((u32) BR_DOWN)) < 16)
1190                 hotk->brightness = (event & ~((u32) BR_DOWN));
1191
1192         acpi_bus_generate_proc_event(hotk->device, event,
1193                                 hotk->event_count[event % 128]++);
1194
1195         return;
1196 }
1197
1198 /*
1199  * Match the model string to the list of supported models. Return END_MODEL if
1200  * no match or model is NULL.
1201  */
1202 static int asus_model_match(char *model)
1203 {
1204         if (model == NULL)
1205                 return END_MODEL;
1206
1207         if (strncmp(model, "L3D", 3) == 0)
1208                 return L3D;
1209         else if (strncmp(model, "L2E", 3) == 0 ||
1210                  strncmp(model, "L3H", 3) == 0 || strncmp(model, "L5D", 3) == 0)
1211                 return L3H;
1212         else if (strncmp(model, "L3", 2) == 0 || strncmp(model, "L2B", 3) == 0)
1213                 return L3C;
1214         else if (strncmp(model, "L8L", 3) == 0)
1215                 return L8L;
1216         else if (strncmp(model, "L4R", 3) == 0)
1217                 return L4R;
1218         else if (strncmp(model, "M6N", 3) == 0 || strncmp(model, "W3N", 3) == 0)
1219                 return M6N;
1220         else if (strncmp(model, "M6R", 3) == 0 || strncmp(model, "A3G", 3) == 0)
1221                 return M6R;
1222         else if (strncmp(model, "M2N", 3) == 0 ||
1223                  strncmp(model, "M3N", 3) == 0 ||
1224                  strncmp(model, "M5N", 3) == 0 ||
1225                  strncmp(model, "S1N", 3) == 0 ||
1226                  strncmp(model, "S5N", 3) == 0)
1227                 return xxN;
1228         else if (strncmp(model, "M1", 2) == 0)
1229                 return M1A;
1230         else if (strncmp(model, "M2", 2) == 0 || strncmp(model, "L4E", 3) == 0)
1231                 return M2E;
1232         else if (strncmp(model, "L2", 2) == 0)
1233                 return L2D;
1234         else if (strncmp(model, "L8", 2) == 0)
1235                 return S1x;
1236         else if (strncmp(model, "D1", 2) == 0)
1237                 return D1x;
1238         else if (strncmp(model, "A1", 2) == 0)
1239                 return A1x;
1240         else if (strncmp(model, "A2", 2) == 0)
1241                 return A2x;
1242         else if (strncmp(model, "J1", 2) == 0)
1243                 return S2x;
1244         else if (strncmp(model, "L5", 2) == 0)
1245                 return L5x;
1246         else if (strncmp(model, "A4G", 3) == 0)
1247                 return A4G;
1248         else if (strncmp(model, "W1N", 3) == 0)
1249                 return W1N;
1250         else if (strncmp(model, "W3V", 3) == 0)
1251                 return W3V;
1252         else if (strncmp(model, "W5A", 3) == 0)
1253                 return W5A;
1254         else if (strncmp(model, "R1F", 3) == 0)
1255                 return R1F;
1256         else if (strncmp(model, "A4S", 3) == 0)
1257                 return A4S;
1258         else if (strncmp(model, "F3Sa", 4) == 0)
1259                 return F3Sa;
1260         else
1261                 return END_MODEL;
1262 }
1263
1264 /*
1265  * This function is used to initialize the hotk with right values. In this
1266  * method, we can make all the detection we want, and modify the hotk struct
1267  */
1268 static int asus_hotk_get_info(void)
1269 {
1270         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1271         union acpi_object *model = NULL;
1272         int bsts_result;
1273         char *string = NULL;
1274         acpi_status status;
1275
1276         /*
1277          * Get DSDT headers early enough to allow for differentiating between
1278          * models, but late enough to allow acpi_bus_register_driver() to fail
1279          * before doing anything ACPI-specific. Should we encounter a machine,
1280          * which needs special handling (i.e. its hotkey device has a different
1281          * HID), this bit will be moved. A global variable asus_info contains
1282          * the DSDT header.
1283          */
1284         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus_info);
1285         if (ACPI_FAILURE(status))
1286                 printk(KERN_WARNING "  Couldn't get the DSDT table header\n");
1287
1288         /* We have to write 0 on init this far for all ASUS models */
1289         if (!write_acpi_int(hotk->handle, "INIT", 0, &buffer)) {
1290                 printk(KERN_ERR "  Hotkey initialization failed\n");
1291                 return -ENODEV;
1292         }
1293
1294         /* This needs to be called for some laptops to init properly */
1295         if (!read_acpi_int(hotk->handle, "BSTS", &bsts_result))
1296                 printk(KERN_WARNING "  Error calling BSTS\n");
1297         else if (bsts_result)
1298                 printk(KERN_NOTICE "  BSTS called, 0x%02x returned\n",
1299                        bsts_result);
1300
1301         /*
1302          * Try to match the object returned by INIT to the specific model.
1303          * Handle every possible object (or the lack of thereof) the DSDT
1304          * writers might throw at us. When in trouble, we pass NULL to
1305          * asus_model_match() and try something completely different.
1306          */
1307         if (buffer.pointer) {
1308                 model = buffer.pointer;
1309                 switch (model->type) {
1310                 case ACPI_TYPE_STRING:
1311                         string = model->string.pointer;
1312                         break;
1313                 case ACPI_TYPE_BUFFER:
1314                         string = model->buffer.pointer;
1315                         break;
1316                 default:
1317                         kfree(model);
1318                         model = NULL;
1319                         break;
1320                 }
1321         }
1322         hotk->model = asus_model_match(string);
1323         if (hotk->model == END_MODEL) { /* match failed */
1324                 if (asus_info &&
1325                     strncmp(asus_info->oem_table_id, "ODEM", 4) == 0) {
1326                         hotk->model = P30;
1327                         printk(KERN_NOTICE
1328                                "  Samsung P30 detected, supported\n");
1329                         hotk->methods = &model_conf[hotk->model];
1330                         kfree(model);
1331                         return 0;
1332                 } else {
1333                         hotk->model = M2E;
1334                         printk(KERN_NOTICE "  unsupported model %s, trying "
1335                                "default values\n", string);
1336                         printk(KERN_NOTICE
1337                                "  send /proc/acpi/dsdt to the developers\n");
1338                         kfree(model);
1339                         return -ENODEV;
1340                 }
1341         }
1342         hotk->methods = &model_conf[hotk->model];
1343         printk(KERN_NOTICE "  %s model detected, supported\n", string);
1344
1345         /* Sort of per-model blacklist */
1346         if (strncmp(string, "L2B", 3) == 0)
1347                 hotk->methods->lcd_status = NULL;
1348         /* L2B is similar enough to L3C to use its settings, with this only
1349            exception */
1350         else if (strncmp(string, "A3G", 3) == 0)
1351                 hotk->methods->lcd_status = "\\BLFG";
1352         /* A3G is like M6R */
1353         else if (strncmp(string, "S5N", 3) == 0 ||
1354                  strncmp(string, "M5N", 3) == 0 ||
1355                  strncmp(string, "W3N", 3) == 0)
1356                 hotk->methods->mt_mled = NULL;
1357         /* S5N, M5N and W3N have no MLED */
1358         else if (strncmp(string, "L5D", 3) == 0)
1359                 hotk->methods->mt_wled = NULL;
1360         /* L5D's WLED is not controlled by ACPI */
1361         else if (strncmp(string, "M2N", 3) == 0 ||
1362                  strncmp(string, "W3V", 3) == 0 ||
1363                  strncmp(string, "S1N", 3) == 0)
1364                 hotk->methods->mt_wled = "WLED";
1365         /* M2N, S1N and W3V have a usable WLED */
1366         else if (asus_info) {
1367                 if (strncmp(asus_info->oem_table_id, "L1", 2) == 0)
1368                         hotk->methods->mled_status = NULL;
1369                 /* S1300A reports L84F, but L1400B too, account for that */
1370         }
1371
1372         kfree(model);
1373
1374         return 0;
1375 }
1376
1377 static int asus_hotk_check(void)
1378 {
1379         int result = 0;
1380
1381         result = acpi_bus_get_status(hotk->device);
1382         if (result)
1383                 return result;
1384
1385         if (hotk->device->status.present) {
1386                 result = asus_hotk_get_info();
1387         } else {
1388                 printk(KERN_ERR "  Hotkey device not present, aborting\n");
1389                 return -EINVAL;
1390         }
1391
1392         return result;
1393 }
1394
1395 static int asus_hotk_found;
1396
1397 static int asus_hotk_add(struct acpi_device *device)
1398 {
1399         acpi_status status = AE_OK;
1400         int result;
1401
1402         printk(KERN_NOTICE "Asus Laptop ACPI Extras version %s\n",
1403                ASUS_ACPI_VERSION);
1404
1405         hotk = kzalloc(sizeof(struct asus_hotk), GFP_KERNEL);
1406         if (!hotk)
1407                 return -ENOMEM;
1408
1409         hotk->handle = device->handle;
1410         strcpy(acpi_device_name(device), ACPI_HOTK_DEVICE_NAME);
1411         strcpy(acpi_device_class(device), ACPI_HOTK_CLASS);
1412         device->driver_data = hotk;
1413         hotk->device = device;
1414
1415         result = asus_hotk_check();
1416         if (result)
1417                 goto end;
1418
1419         result = asus_hotk_add_fs(device);
1420         if (result)
1421                 goto end;
1422
1423         /* For laptops without GPLV: init the hotk->brightness value */
1424         if ((!hotk->methods->brightness_get)
1425             && (!hotk->methods->brightness_status)
1426             && (hotk->methods->brightness_up && hotk->methods->brightness_down)) {
1427                 status =
1428                     acpi_evaluate_object(NULL, hotk->methods->brightness_down,
1429                                          NULL, NULL);
1430                 if (ACPI_FAILURE(status))
1431                         printk(KERN_WARNING "  Error changing brightness\n");
1432                 else {
1433                         status =
1434                             acpi_evaluate_object(NULL,
1435                                                  hotk->methods->brightness_up,
1436                                                  NULL, NULL);
1437                         if (ACPI_FAILURE(status))
1438                                 printk(KERN_WARNING "  Strange, error changing"
1439                                        " brightness\n");
1440                 }
1441         }
1442
1443         asus_hotk_found = 1;
1444
1445         /* LED display is off by default */
1446         hotk->ledd_status = 0xFFF;
1447
1448 end:
1449         if (result)
1450                 kfree(hotk);
1451
1452         return result;
1453 }
1454
1455 static int asus_hotk_remove(struct acpi_device *device, int type)
1456 {
1457         asus_hotk_remove_fs(device);
1458
1459         kfree(hotk);
1460
1461         return 0;
1462 }
1463
1464 static const struct backlight_ops asus_backlight_data = {
1465         .get_brightness = read_brightness,
1466         .update_status  = set_brightness_status,
1467 };
1468
1469 static void asus_acpi_exit(void)
1470 {
1471         if (asus_backlight_device)
1472                 backlight_device_unregister(asus_backlight_device);
1473
1474         acpi_bus_unregister_driver(&asus_hotk_driver);
1475         remove_proc_entry(PROC_ASUS, acpi_root_dir);
1476
1477         return;
1478 }
1479
1480 static int __init asus_acpi_init(void)
1481 {
1482         struct backlight_properties props;
1483         int result;
1484
1485         result = acpi_bus_register_driver(&asus_hotk_driver);
1486         if (result < 0)
1487                 return result;
1488
1489         asus_proc_dir = proc_mkdir(PROC_ASUS, acpi_root_dir);
1490         if (!asus_proc_dir) {
1491                 printk(KERN_ERR "Asus ACPI: Unable to create /proc entry\n");
1492                 acpi_bus_unregister_driver(&asus_hotk_driver);
1493                 return -ENODEV;
1494         }
1495
1496         /*
1497          * This is a bit of a kludge.  We only want this module loaded
1498          * for ASUS systems, but there's currently no way to probe the
1499          * ACPI namespace for ASUS HIDs.  So we just return failure if
1500          * we didn't find one, which will cause the module to be
1501          * unloaded.
1502          */
1503         if (!asus_hotk_found) {
1504                 acpi_bus_unregister_driver(&asus_hotk_driver);
1505                 remove_proc_entry(PROC_ASUS, acpi_root_dir);
1506                 return -ENODEV;
1507         }
1508
1509         memset(&props, 0, sizeof(struct backlight_properties));
1510         props.max_brightness = 15;
1511         asus_backlight_device = backlight_device_register("asus", NULL, NULL,
1512                                                           &asus_backlight_data,
1513                                                           &props);
1514         if (IS_ERR(asus_backlight_device)) {
1515                 printk(KERN_ERR "Could not register asus backlight device\n");
1516                 asus_backlight_device = NULL;
1517                 asus_acpi_exit();
1518                 return -ENODEV;
1519         }
1520
1521         return 0;
1522 }
1523
1524 module_init(asus_acpi_init);
1525 module_exit(asus_acpi_exit);