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                 goto out;
 946         }
 947
 948         /* No SPLV method if we are here, act as appropriate */
 949         value -= read_brightness(NULL);
 950         while (value != 0) {
 951                 status = acpi_evaluate_object(NULL, (value > 0) ?
 952                                               hotk->methods->brightness_up :
 953                                               hotk->methods->brightness_down,
 954                                               NULL, NULL);
 955                 (value > 0) ? value-- : value++;
 956                 if (ACPI_FAILURE(status))
 957                         printk(KERN_WARNING
 958                                "Asus ACPI: Error changing brightness\n");
 959                         ret = -EIO;
 960         }
 961 out:
 962         return ret;
 963 }
 964
 965 static int set_brightness_status(struct backlight_device *bd)
 966 {
 967         return set_brightness(bd->props.brightness);
 968 }
 969
 970 static int brn_proc_show(struct seq_file *m, void *v)
 971 {
 972         seq_printf(m, "%d\n", read_brightness(NULL));
 973         return 0;
 974 }
 975
 976 static int brn_proc_open(struct inode *inode, struct file *file)
 977 {
 978         return single_open(file, brn_proc_show, NULL);
 979 }
 980
 981 static ssize_t brn_proc_write(struct file *file, const char __user *buffer,
 982                size_t count, loff_t *pos)
 983 {
 984         int rv, value;
 985
 986         rv = parse_arg(buffer, count, &value);
 987         if (rv > 0) {
 988                 value = (0 < value) ? ((15 < value) ? 15 : value) : 0;
 989                 /* 0 <= value <= 15 */
 990                 set_brightness(value);
 991         }
 992         return rv;
 993 }
 994
 995 static const struct file_operations brn_proc_fops = {
 996         .owner          = THIS_MODULE,
 997         .open           = brn_proc_open,
 998         .read           = seq_read,
 999         .llseek         = seq_lseek,
1000         .release        = single_release,
1001         .write          = brn_proc_write,
1002 };
1003
1004 static void set_display(int value)
1005 {
1006         /* no sanity check needed for now */
1007         if (!write_acpi_int(hotk->handle, hotk->methods->display_set,
1008                             value, NULL))
1009                 printk(KERN_WARNING "Asus ACPI: Error setting display\n");
1010         return;
1011 }
1012
1013 /*
1014  * Now, *this* one could be more user-friendly, but so far, no-one has
1015  * complained. The significance of bits is the same as in proc_write_disp()
1016  */
1017 static int disp_proc_show(struct seq_file *m, void *v)
1018 {
1019         int value = 0;
1020
1021         if (!read_acpi_int(hotk->handle, hotk->methods->display_get, &value))
1022                 printk(KERN_WARNING
1023                        "Asus ACPI: Error reading display status\n");
1024         value &= 0x07;  /* needed for some models, shouldn't hurt others */
1025         seq_printf(m, "%d\n", value);
1026         return 0;
1027 }
1028
1029 static int disp_proc_open(struct inode *inode, struct file *file)
1030 {
1031         return single_open(file, disp_proc_show, NULL);
1032 }
1033
1034 /*
1035  * Experimental support for display switching. As of now: 1 should activate
1036  * the LCD output, 2 should do for CRT, and 4 for TV-Out. Any combination
1037  * (bitwise) of these will suffice. I never actually tested 3 displays hooked
1038  * up simultaneously, so be warned. See the acpi4asus README for more info.
1039  */
1040 static ssize_t disp_proc_write(struct file *file, const char __user *buffer,
1041                 size_t count, loff_t *pos)
1042 {
1043         int rv, value;
1044
1045         rv = parse_arg(buffer, count, &value);
1046         if (rv > 0)
1047                 set_display(value);
1048         return rv;
1049 }
1050
1051 static const struct file_operations disp_proc_fops = {
1052         .owner          = THIS_MODULE,
1053         .open           = disp_proc_open,
1054         .read           = seq_read,
1055         .llseek         = seq_lseek,
1056         .release        = single_release,
1057         .write          = disp_proc_write,
1058 };
1059
1060 static int
1061 asus_proc_add(char *name, const struct file_operations *proc_fops, mode_t mode,
1062                      struct acpi_device *device)
1063 {
1064         struct proc_dir_entry *proc;
1065
1066         proc = proc_create_data(name, mode, acpi_device_dir(device),
1067                                 proc_fops, acpi_driver_data(device));
1068         if (!proc) {
1069                 printk(KERN_WARNING "  Unable to create %s fs entry\n", name);
1070                 return -1;
1071         }
1072         proc->uid = asus_uid;
1073         proc->gid = asus_gid;
1074         return 0;
1075 }
1076
1077 static int asus_hotk_add_fs(struct acpi_device *device)
1078 {
1079         struct proc_dir_entry *proc;
1080         mode_t mode;
1081
1082         /*
1083          * If parameter uid or gid is not changed, keep the default setting for
1084          * our proc entries (-rw-rw-rw-) else, it means we care about security,
1085          * and then set to -rw-rw----
1086          */
1087
1088         if ((asus_uid == 0) && (asus_gid == 0)) {
1089                 mode = S_IFREG | S_IRUGO | S_IWUGO;
1090         } else {
1091                 mode = S_IFREG | S_IRUSR | S_IRGRP | S_IWUSR | S_IWGRP;
1092                 printk(KERN_WARNING "  asus_uid and asus_gid parameters are "
1093                        "deprecated, use chown and chmod instead!\n");
1094         }
1095
1096         acpi_device_dir(device) = asus_proc_dir;
1097         if (!acpi_device_dir(device))
1098                 return -ENODEV;
1099
1100         proc = proc_create(PROC_INFO, mode, acpi_device_dir(device),
1101                            &asus_info_proc_fops);
1102         if (proc) {
1103                 proc->uid = asus_uid;
1104                 proc->gid = asus_gid;
1105         } else {
1106                 printk(KERN_WARNING "  Unable to create " PROC_INFO
1107                        " fs entry\n");
1108         }
1109
1110         if (hotk->methods->mt_wled) {
1111                 asus_proc_add(PROC_WLED, &wled_proc_fops, mode, device);
1112         }
1113
1114         if (hotk->methods->mt_ledd) {
1115                 asus_proc_add(PROC_LEDD, &ledd_proc_fops, mode, device);
1116         }
1117
1118         if (hotk->methods->mt_mled) {
1119                 asus_proc_add(PROC_MLED, &mled_proc_fops, mode, device);
1120         }
1121
1122         if (hotk->methods->mt_tled) {
1123                 asus_proc_add(PROC_TLED, &tled_proc_fops, mode, device);
1124         }
1125
1126         if (hotk->methods->mt_bt_switch) {
1127                 asus_proc_add(PROC_BT, &bluetooth_proc_fops, mode, device);
1128         }
1129
1130         /*
1131          * We need both read node and write method as LCD switch is also
1132          * accessible from the keyboard
1133          */
1134         if (hotk->methods->mt_lcd_switch && hotk->methods->lcd_status) {
1135                 asus_proc_add(PROC_LCD, &lcd_proc_fops, mode, device);
1136         }
1137
1138         if ((hotk->methods->brightness_up && hotk->methods->brightness_down) ||
1139             (hotk->methods->brightness_get && hotk->methods->brightness_set)) {
1140                 asus_proc_add(PROC_BRN, &brn_proc_fops, mode, device);
1141         }
1142
1143         if (hotk->methods->display_set) {
1144                 asus_proc_add(PROC_DISP, &disp_proc_fops, mode, device);
1145         }
1146
1147         return 0;
1148 }
1149
1150 static int asus_hotk_remove_fs(struct acpi_device *device)
1151 {
1152         if (acpi_device_dir(device)) {
1153                 remove_proc_entry(PROC_INFO, acpi_device_dir(device));
1154                 if (hotk->methods->mt_wled)
1155                         remove_proc_entry(PROC_WLED, acpi_device_dir(device));
1156                 if (hotk->methods->mt_mled)
1157                         remove_proc_entry(PROC_MLED, acpi_device_dir(device));
1158                 if (hotk->methods->mt_tled)
1159                         remove_proc_entry(PROC_TLED, acpi_device_dir(device));
1160                 if (hotk->methods->mt_ledd)
1161                         remove_proc_entry(PROC_LEDD, acpi_device_dir(device));
1162                 if (hotk->methods->mt_bt_switch)
1163                         remove_proc_entry(PROC_BT, acpi_device_dir(device));
1164                 if (hotk->methods->mt_lcd_switch && hotk->methods->lcd_status)
1165                         remove_proc_entry(PROC_LCD, acpi_device_dir(device));
1166                 if ((hotk->methods->brightness_up
1167                      && hotk->methods->brightness_down)
1168                     || (hotk->methods->brightness_get
1169                         && hotk->methods->brightness_set))
1170                         remove_proc_entry(PROC_BRN, acpi_device_dir(device));
1171                 if (hotk->methods->display_set)
1172                         remove_proc_entry(PROC_DISP, acpi_device_dir(device));
1173         }
1174         return 0;
1175 }
1176
1177 static void asus_hotk_notify(struct acpi_device *device, u32 event)
1178 {
1179         /* TODO Find a better way to handle events count. */
1180         if (!hotk)
1181                 return;
1182
1183         /*
1184          * The BIOS *should* be sending us device events, but apparently
1185          * Asus uses system events instead, so just ignore any device
1186          * events we get.
1187          */
1188         if (event > ACPI_MAX_SYS_NOTIFY)
1189                 return;
1190
1191         if ((event & ~((u32) BR_UP)) < 16)
1192                 hotk->brightness = (event & ~((u32) BR_UP));
1193         else if ((event & ~((u32) BR_DOWN)) < 16)
1194                 hotk->brightness = (event & ~((u32) BR_DOWN));
1195
1196         acpi_bus_generate_proc_event(hotk->device, event,
1197                                 hotk->event_count[event % 128]++);
1198
1199         return;
1200 }
1201
1202 /*
1203  * Match the model string to the list of supported models. Return END_MODEL if
1204  * no match or model is NULL.
1205  */
1206 static int asus_model_match(char *model)
1207 {
1208         if (model == NULL)
1209                 return END_MODEL;
1210
1211         if (strncmp(model, "L3D", 3) == 0)
1212                 return L3D;
1213         else if (strncmp(model, "L2E", 3) == 0 ||
1214                  strncmp(model, "L3H", 3) == 0 || strncmp(model, "L5D", 3) == 0)
1215                 return L3H;
1216         else if (strncmp(model, "L3", 2) == 0 || strncmp(model, "L2B", 3) == 0)
1217                 return L3C;
1218         else if (strncmp(model, "L8L", 3) == 0)
1219                 return L8L;
1220         else if (strncmp(model, "L4R", 3) == 0)
1221                 return L4R;
1222         else if (strncmp(model, "M6N", 3) == 0 || strncmp(model, "W3N", 3) == 0)
1223                 return M6N;
1224         else if (strncmp(model, "M6R", 3) == 0 || strncmp(model, "A3G", 3) == 0)
1225                 return M6R;
1226         else if (strncmp(model, "M2N", 3) == 0 ||
1227                  strncmp(model, "M3N", 3) == 0 ||
1228                  strncmp(model, "M5N", 3) == 0 ||
1229                  strncmp(model, "S1N", 3) == 0 ||
1230                  strncmp(model, "S5N", 3) == 0)
1231                 return xxN;
1232         else if (strncmp(model, "M1", 2) == 0)
1233                 return M1A;
1234         else if (strncmp(model, "M2", 2) == 0 || strncmp(model, "L4E", 3) == 0)
1235                 return M2E;
1236         else if (strncmp(model, "L2", 2) == 0)
1237                 return L2D;
1238         else if (strncmp(model, "L8", 2) == 0)
1239                 return S1x;
1240         else if (strncmp(model, "D1", 2) == 0)
1241                 return D1x;
1242         else if (strncmp(model, "A1", 2) == 0)
1243                 return A1x;
1244         else if (strncmp(model, "A2", 2) == 0)
1245                 return A2x;
1246         else if (strncmp(model, "J1", 2) == 0)
1247                 return S2x;
1248         else if (strncmp(model, "L5", 2) == 0)
1249                 return L5x;
1250         else if (strncmp(model, "A4G", 3) == 0)
1251                 return A4G;
1252         else if (strncmp(model, "W1N", 3) == 0)
1253                 return W1N;
1254         else if (strncmp(model, "W3V", 3) == 0)
1255                 return W3V;
1256         else if (strncmp(model, "W5A", 3) == 0)
1257                 return W5A;
1258         else if (strncmp(model, "R1F", 3) == 0)
1259                 return R1F;
1260         else if (strncmp(model, "A4S", 3) == 0)
1261                 return A4S;
1262         else if (strncmp(model, "F3Sa", 4) == 0)
1263                 return F3Sa;
1264         else
1265                 return END_MODEL;
1266 }
1267
1268 /*
1269  * This function is used to initialize the hotk with right values. In this
1270  * method, we can make all the detection we want, and modify the hotk struct
1271  */
1272 static int asus_hotk_get_info(void)
1273 {
1274         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1275         union acpi_object *model = NULL;
1276         int bsts_result;
1277         char *string = NULL;
1278         acpi_status status;
1279
1280         /*
1281          * Get DSDT headers early enough to allow for differentiating between
1282          * models, but late enough to allow acpi_bus_register_driver() to fail
1283          * before doing anything ACPI-specific. Should we encounter a machine,
1284          * which needs special handling (i.e. its hotkey device has a different
1285          * HID), this bit will be moved. A global variable asus_info contains
1286          * the DSDT header.
1287          */
1288         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus_info);
1289         if (ACPI_FAILURE(status))
1290                 printk(KERN_WARNING "  Couldn't get the DSDT table header\n");
1291
1292         /* We have to write 0 on init this far for all ASUS models */
1293         if (!write_acpi_int(hotk->handle, "INIT", 0, &buffer)) {
1294                 printk(KERN_ERR "  Hotkey initialization failed\n");
1295                 return -ENODEV;
1296         }
1297
1298         /* This needs to be called for some laptops to init properly */
1299         if (!read_acpi_int(hotk->handle, "BSTS", &bsts_result))
1300                 printk(KERN_WARNING "  Error calling BSTS\n");
1301         else if (bsts_result)
1302                 printk(KERN_NOTICE "  BSTS called, 0x%02x returned\n",
1303                        bsts_result);
1304
1305         /*
1306          * Try to match the object returned by INIT to the specific model.
1307          * Handle every possible object (or the lack of thereof) the DSDT
1308          * writers might throw at us. When in trouble, we pass NULL to
1309          * asus_model_match() and try something completely different.
1310          */
1311         if (buffer.pointer) {
1312                 model = buffer.pointer;
1313                 switch (model->type) {
1314                 case ACPI_TYPE_STRING:
1315                         string = model->string.pointer;
1316                         break;
1317                 case ACPI_TYPE_BUFFER:
1318                         string = model->buffer.pointer;
1319                         break;
1320                 default:
1321                         kfree(model);
1322                         model = NULL;
1323                         break;
1324                 }
1325         }
1326         hotk->model = asus_model_match(string);
1327         if (hotk->model == END_MODEL) { /* match failed */
1328                 if (asus_info &&
1329                     strncmp(asus_info->oem_table_id, "ODEM", 4) == 0) {
1330                         hotk->model = P30;
1331                         printk(KERN_NOTICE
1332                                "  Samsung P30 detected, supported\n");
1333                 } else {
1334                         hotk->model = M2E;
1335                         printk(KERN_NOTICE "  unsupported model %s, trying "
1336                                "default values\n", string);
1337                         printk(KERN_NOTICE
1338                                "  send /proc/acpi/dsdt to the developers\n");
1339                         kfree(model);
1340                         return -ENODEV;
1341                 }
1342                 hotk->methods = &model_conf[hotk->model];
1343                 return AE_OK;
1344         }
1345         hotk->methods = &model_conf[hotk->model];
1346         printk(KERN_NOTICE "  %s model detected, supported\n", string);
1347
1348         /* Sort of per-model blacklist */
1349         if (strncmp(string, "L2B", 3) == 0)
1350                 hotk->methods->lcd_status = NULL;
1351         /* L2B is similar enough to L3C to use its settings, with this only
1352            exception */
1353         else if (strncmp(string, "A3G", 3) == 0)
1354                 hotk->methods->lcd_status = "\\BLFG";
1355         /* A3G is like M6R */
1356         else if (strncmp(string, "S5N", 3) == 0 ||
1357                  strncmp(string, "M5N", 3) == 0 ||
1358                  strncmp(string, "W3N", 3) == 0)
1359                 hotk->methods->mt_mled = NULL;
1360         /* S5N, M5N and W3N have no MLED */
1361         else if (strncmp(string, "L5D", 3) == 0)
1362                 hotk->methods->mt_wled = NULL;
1363         /* L5D's WLED is not controlled by ACPI */
1364         else if (strncmp(string, "M2N", 3) == 0 ||
1365                  strncmp(string, "W3V", 3) == 0 ||
1366                  strncmp(string, "S1N", 3) == 0)
1367                 hotk->methods->mt_wled = "WLED";
1368         /* M2N, S1N and W3V have a usable WLED */
1369         else if (asus_info) {
1370                 if (strncmp(asus_info->oem_table_id, "L1", 2) == 0)
1371                         hotk->methods->mled_status = NULL;
1372                 /* S1300A reports L84F, but L1400B too, account for that */
1373         }
1374
1375         kfree(model);
1376
1377         return AE_OK;
1378 }
1379
1380 static int asus_hotk_check(void)
1381 {
1382         int result = 0;
1383
1384         result = acpi_bus_get_status(hotk->device);
1385         if (result)
1386                 return result;
1387
1388         if (hotk->device->status.present) {
1389                 result = asus_hotk_get_info();
1390         } else {
1391                 printk(KERN_ERR "  Hotkey device not present, aborting\n");
1392                 return -EINVAL;
1393         }
1394
1395         return result;
1396 }
1397
1398 static int asus_hotk_found;
1399
1400 static int asus_hotk_add(struct acpi_device *device)
1401 {
1402         acpi_status status = AE_OK;
1403         int result;
1404
1405         printk(KERN_NOTICE "Asus Laptop ACPI Extras version %s\n",
1406                ASUS_ACPI_VERSION);
1407
1408         hotk = kzalloc(sizeof(struct asus_hotk), GFP_KERNEL);
1409         if (!hotk)
1410                 return -ENOMEM;
1411
1412         hotk->handle = device->handle;
1413         strcpy(acpi_device_name(device), ACPI_HOTK_DEVICE_NAME);
1414         strcpy(acpi_device_class(device), ACPI_HOTK_CLASS);
1415         device->driver_data = hotk;
1416         hotk->device = device;
1417
1418         result = asus_hotk_check();
1419         if (result)
1420                 goto end;
1421
1422         result = asus_hotk_add_fs(device);
1423         if (result)
1424                 goto end;
1425
1426         /* For laptops without GPLV: init the hotk->brightness value */
1427         if ((!hotk->methods->brightness_get)
1428             && (!hotk->methods->brightness_status)
1429             && (hotk->methods->brightness_up && hotk->methods->brightness_down)) {
1430                 status =
1431                     acpi_evaluate_object(NULL, hotk->methods->brightness_down,
1432                                          NULL, NULL);
1433                 if (ACPI_FAILURE(status))
1434                         printk(KERN_WARNING "  Error changing brightness\n");
1435                 else {
1436                         status =
1437                             acpi_evaluate_object(NULL,
1438                                                  hotk->methods->brightness_up,
1439                                                  NULL, NULL);
1440                         if (ACPI_FAILURE(status))
1441                                 printk(KERN_WARNING "  Strange, error changing"
1442                                        " brightness\n");
1443                 }
1444         }
1445
1446         asus_hotk_found = 1;
1447
1448         /* LED display is off by default */
1449         hotk->ledd_status = 0xFFF;
1450
1451 end:
1452         if (result)
1453                 kfree(hotk);
1454
1455         return result;
1456 }
1457
1458 static int asus_hotk_remove(struct acpi_device *device, int type)
1459 {
1460         asus_hotk_remove_fs(device);
1461
1462         kfree(hotk);
1463
1464         return 0;
1465 }
1466
1467 static struct backlight_ops asus_backlight_data = {
1468         .get_brightness = read_brightness,
1469         .update_status  = set_brightness_status,
1470 };
1471
1472 static void asus_acpi_exit(void)
1473 {
1474         if (asus_backlight_device)
1475                 backlight_device_unregister(asus_backlight_device);
1476
1477         acpi_bus_unregister_driver(&asus_hotk_driver);
1478         remove_proc_entry(PROC_ASUS, acpi_root_dir);
1479
1480         return;
1481 }
1482
1483 static int __init asus_acpi_init(void)
1484 {
1485         struct backlight_properties props;
1486         int result;
1487
1488         result = acpi_bus_register_driver(&asus_hotk_driver);
1489         if (result < 0)
1490                 return result;
1491
1492         asus_proc_dir = proc_mkdir(PROC_ASUS, acpi_root_dir);
1493         if (!asus_proc_dir) {
1494                 printk(KERN_ERR "Asus ACPI: Unable to create /proc entry\n");
1495                 acpi_bus_unregister_driver(&asus_hotk_driver);
1496                 return -ENODEV;
1497         }
1498
1499         /*
1500          * This is a bit of a kludge.  We only want this module loaded
1501          * for ASUS systems, but there's currently no way to probe the
1502          * ACPI namespace for ASUS HIDs.  So we just return failure if
1503          * we didn't find one, which will cause the module to be
1504          * unloaded.
1505          */
1506         if (!asus_hotk_found) {
1507                 acpi_bus_unregister_driver(&asus_hotk_driver);
1508                 remove_proc_entry(PROC_ASUS, acpi_root_dir);
1509                 return -ENODEV;
1510         }
1511
1512         memset(&props, 0, sizeof(struct backlight_properties));
1513         props.max_brightness = 15;
1514         asus_backlight_device = backlight_device_register("asus", NULL, NULL,
1515                                                           &asus_backlight_data,
1516                                                           &props);
1517         if (IS_ERR(asus_backlight_device)) {
1518                 printk(KERN_ERR "Could not register asus backlight device\n");
1519                 asus_backlight_device = NULL;
1520                 asus_acpi_exit();
1521                 return -ENODEV;
1522         }
1523
1524         return 0;
1525 }
1526
1527 module_init(asus_acpi_init);
1528 module_exit(asus_acpi_exit);