?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
code style scripts/checkpatch.pl (linux-3.9-rc1) formatting
[linux-2.6.32.60-moxart.git] / drivers / platform / x86 / eeepc-laptop.c
blobc533b1c6556c9565fa50ca84e7942af6439ac794
1 /*
2 * eepc-laptop.c - Asus Eee PC extras
3 *
4 * Based on asus_acpi.c as patched for the Eee PC by Asus:
5 * ftp://ftp.asus.com/pub/ASUS/EeePC/701/ASUS_ACPI_071126.rar
6 * Based on eee.c from eeepc-linux
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 */
18
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/init.h>
24 #include <linux/types.h>
25 #include <linux/platform_device.h>
26 #include <linux/backlight.h>
27 #include <linux/fb.h>
28 #include <linux/hwmon.h>
29 #include <linux/hwmon-sysfs.h>
30 #include <acpi/acpi_drivers.h>
31 #include <acpi/acpi_bus.h>
32 #include <linux/uaccess.h>
33 #include <linux/input.h>
34 #include <linux/rfkill.h>
35 #include <linux/pci.h>
36 #include <linux/pci_hotplug.h>
37 #include <linux/dmi.h>
38
39 #define EEEPC_LAPTOP_VERSION "0.1"
40
41 #define EEEPC_HOTK_NAME "Eee PC Hotkey Driver"
42 #define EEEPC_HOTK_FILE "eeepc"
43 #define EEEPC_HOTK_CLASS "hotkey"
44 #define EEEPC_HOTK_DEVICE_NAME "Hotkey"
45 #define EEEPC_HOTK_HID "ASUS010"
46
47
48 /*
49 * Definitions for Asus EeePC
50 */
51 #define NOTIFY_WLAN_ON 0x10
52 #define NOTIFY_BRN_MIN 0x20
53 #define NOTIFY_BRN_MAX 0x2f
54
55 enum {
56 DISABLE_ASL_WLAN = 0x0001,
57 DISABLE_ASL_BLUETOOTH = 0x0002,
58 DISABLE_ASL_IRDA = 0x0004,
59 DISABLE_ASL_CAMERA = 0x0008,
60 DISABLE_ASL_TV = 0x0010,
61 DISABLE_ASL_GPS = 0x0020,
62 DISABLE_ASL_DISPLAYSWITCH = 0x0040,
63 DISABLE_ASL_MODEM = 0x0080,
64 DISABLE_ASL_CARDREADER = 0x0100,
65 DISABLE_ASL_3G = 0x0200,
66 DISABLE_ASL_WIMAX = 0x0400,
67 DISABLE_ASL_HWCF = 0x0800
68 };
69
70 enum {
71 CM_ASL_WLAN = 0,
72 CM_ASL_BLUETOOTH,
73 CM_ASL_IRDA,
74 CM_ASL_1394,
75 CM_ASL_CAMERA,
76 CM_ASL_TV,
77 CM_ASL_GPS,
78 CM_ASL_DVDROM,
79 CM_ASL_DISPLAYSWITCH,
80 CM_ASL_PANELBRIGHT,
81 CM_ASL_BIOSFLASH,
82 CM_ASL_ACPIFLASH,
83 CM_ASL_CPUFV,
84 CM_ASL_CPUTEMPERATURE,
85 CM_ASL_FANCPU,
86 CM_ASL_FANCHASSIS,
87 CM_ASL_USBPORT1,
88 CM_ASL_USBPORT2,
89 CM_ASL_USBPORT3,
90 CM_ASL_MODEM,
91 CM_ASL_CARDREADER,
92 CM_ASL_3G,
93 CM_ASL_WIMAX,
94 CM_ASL_HWCF,
95 CM_ASL_LID,
96 CM_ASL_TYPE,
97 CM_ASL_PANELPOWER, /*P901*/
98 CM_ASL_TPD
99 };
100
101 static const char *cm_getv[] = {
102 "WLDG", "BTHG", NULL, NULL,
103 "CAMG", NULL, NULL, NULL,
104 NULL, "PBLG", NULL, NULL,
105 "CFVG", NULL, NULL, NULL,
106 "USBG", NULL, NULL, "MODG",
107 "CRDG", "M3GG", "WIMG", "HWCF",
108 "LIDG", "TYPE", "PBPG", "TPDG"
109 };
110
111 static const char *cm_setv[] = {
112 "WLDS", "BTHS", NULL, NULL,
113 "CAMS", NULL, NULL, NULL,
114 "SDSP", "PBLS", "HDPS", NULL,
115 "CFVS", NULL, NULL, NULL,
116 "USBG", NULL, NULL, "MODS",
117 "CRDS", "M3GS", "WIMS", NULL,
118 NULL, NULL, "PBPS", "TPDS"
119 };
120
121 #define EEEPC_EC "\\_SB.PCI0.SBRG.EC0."
122
123 #define EEEPC_EC_FAN_PWM EEEPC_EC "SC02" /* Fan PWM duty cycle (%) */
124 #define EEEPC_EC_SC02 0x63
125 #define EEEPC_EC_FAN_HRPM EEEPC_EC "SC05" /* High byte, fan speed (RPM) */
126 #define EEEPC_EC_FAN_LRPM EEEPC_EC "SC06" /* Low byte, fan speed (RPM) */
127 #define EEEPC_EC_FAN_CTRL EEEPC_EC "SFB3" /* Byte containing SF25 */
128 #define EEEPC_EC_SFB3 0xD3
129
130 /*
131 * This is the main structure, we can use it to store useful information
132 * about the hotk device
133 */
134 struct eeepc_hotk {
135 struct acpi_device *device; /* the device we are in */
136 acpi_handle handle; /* the handle of the hotk device */
137 u32 cm_supported; /* the control methods supported
138 by this BIOS */
139 bool cpufv_disabled;
140 bool hotplug_disabled;
141 uint init_flag; /* Init flags */
142 u16 event_count[128]; /* count for each event */
143 struct input_dev *inputdev;
144 u16 *keycode_map;
145 struct rfkill *wlan_rfkill;
146 struct rfkill *bluetooth_rfkill;
147 struct rfkill *wwan3g_rfkill;
148 struct rfkill *wimax_rfkill;
149 struct hotplug_slot *hotplug_slot;
150 struct mutex hotplug_lock;
151 };
152
153 /* The actual device the driver binds to */
154 static struct eeepc_hotk *ehotk;
155
156 /* Platform device/driver */
157 static int eeepc_hotk_thaw(struct device *device);
158 static int eeepc_hotk_restore(struct device *device);
159
160 static struct dev_pm_ops eeepc_pm_ops = {
161 .thaw = eeepc_hotk_thaw,
162 .restore = eeepc_hotk_restore,
163 };
164
165 static struct platform_driver platform_driver = {
166 .driver = {
167 .name = EEEPC_HOTK_FILE,
168 .owner = THIS_MODULE,
169 .pm = &eeepc_pm_ops,
170 }
171 };
172
173 static struct platform_device *platform_device;
174
175 struct key_entry {
176 char type;
177 u8 code;
178 u16 keycode;
179 };
180
181 enum { KE_KEY, KE_END };
182
183 static struct key_entry eeepc_keymap[] = {
184 /* Sleep already handled via generic ACPI code */
185 {KE_KEY, 0x10, KEY_WLAN },
186 {KE_KEY, 0x11, KEY_WLAN },
187 {KE_KEY, 0x12, KEY_PROG1 },
188 {KE_KEY, 0x13, KEY_MUTE },
189 {KE_KEY, 0x14, KEY_VOLUMEDOWN },
190 {KE_KEY, 0x15, KEY_VOLUMEUP },
191 {KE_KEY, 0x1a, KEY_COFFEE },
192 {KE_KEY, 0x1b, KEY_ZOOM },
193 {KE_KEY, 0x1c, KEY_PROG2 },
194 {KE_KEY, 0x1d, KEY_PROG3 },
195 {KE_KEY, NOTIFY_BRN_MIN, KEY_BRIGHTNESSDOWN },
196 {KE_KEY, NOTIFY_BRN_MIN + 2, KEY_BRIGHTNESSUP },
197 {KE_KEY, 0x30, KEY_SWITCHVIDEOMODE },
198 {KE_KEY, 0x31, KEY_SWITCHVIDEOMODE },
199 {KE_KEY, 0x32, KEY_SWITCHVIDEOMODE },
200 {KE_END, 0},
201 };
202
203 /*
204 * The hotkey driver declaration
205 */
206 static int eeepc_hotk_add(struct acpi_device *device);
207 static int eeepc_hotk_remove(struct acpi_device *device, int type);
208 static void eeepc_hotk_notify(struct acpi_device *device, u32 event);
209
210 static const struct acpi_device_id eeepc_device_ids[] = {
211 {EEEPC_HOTK_HID, 0},
212 {"", 0},
213 };
214 MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
215
216 static struct acpi_driver eeepc_hotk_driver = {
217 .name = EEEPC_HOTK_NAME,
218 .class = EEEPC_HOTK_CLASS,
219 .ids = eeepc_device_ids,
220 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
221 .ops = {
222 .add = eeepc_hotk_add,
223 .remove = eeepc_hotk_remove,
224 .notify = eeepc_hotk_notify,
225 },
226 };
227
228 /* PCI hotplug ops */
229 static int eeepc_get_adapter_status(struct hotplug_slot *slot, u8 *value);
230
231 static struct hotplug_slot_ops eeepc_hotplug_slot_ops = {
232 .owner = THIS_MODULE,
233 .get_adapter_status = eeepc_get_adapter_status,
234 .get_power_status = eeepc_get_adapter_status,
235 };
236
237 /* The backlight device /sys/class/backlight */
238 static struct backlight_device *eeepc_backlight_device;
239
240 /* The hwmon device */
241 static struct device *eeepc_hwmon_device;
242
243 /*
244 * The backlight class declaration
245 */
246 static int read_brightness(struct backlight_device *bd);
247 static int update_bl_status(struct backlight_device *bd);
248 static struct backlight_ops eeepcbl_ops = {
249 .get_brightness = read_brightness,
250 .update_status = update_bl_status,
251 };
252
253 MODULE_AUTHOR("Corentin Chary, Eric Cooper");
254 MODULE_DESCRIPTION(EEEPC_HOTK_NAME);
255 MODULE_LICENSE("GPL");
256
257 static bool hotplug_disabled;
258
259 module_param(hotplug_disabled, bool, 0644);
260 MODULE_PARM_DESC(hotplug_disabled,
261 "Disable hotplug for wireless device. "
262 "If your laptop need that, please report to "
263 "acpi4asus-user@lists.sourceforge.net.");
264
265 /*
266 * ACPI Helpers
267 */
268 static int write_acpi_int(acpi_handle handle, const char *method, int val,
269 struct acpi_buffer *output)
270 {
271 struct acpi_object_list params;
272 union acpi_object in_obj;
273 acpi_status status;
274
275 params.count = 1;
276 params.pointer = &in_obj;
277 in_obj.type = ACPI_TYPE_INTEGER;
278 in_obj.integer.value = val;
279
280 status = acpi_evaluate_object(handle, (char *)method, &params, output);
281 return (status == AE_OK ? 0 : -1);
282 }
283
284 static int read_acpi_int(acpi_handle handle, const char *method, int *val)
285 {
286 acpi_status status;
287 unsigned long long result;
288
289 status = acpi_evaluate_integer(handle, (char *)method, NULL, &result);
290 if (ACPI_FAILURE(status)) {
291 *val = -1;
292 return -1;
293 } else {
294 *val = result;
295 return 0;
296 }
297 }
298
299 static int set_acpi(int cm, int value)
300 {
301 if (ehotk->cm_supported & (0x1 << cm)) {
302 const char *method = cm_setv[cm];
303 if (method == NULL)
304 return -ENODEV;
305 if (write_acpi_int(ehotk->handle, method, value, NULL))
306 pr_warning("Error writing %s\n", method);
307 }
308 return 0;
309 }
310
311 static int get_acpi(int cm)
312 {
313 int value = -ENODEV;
314 if ((ehotk->cm_supported & (0x1 << cm))) {
315 const char *method = cm_getv[cm];
316 if (method == NULL)
317 return -ENODEV;
318 if (read_acpi_int(ehotk->handle, method, &value))
319 pr_warning("Error reading %s\n", method);
320 }
321 return value;
322 }
323
324 /*
325 * Backlight
326 */
327 static int read_brightness(struct backlight_device *bd)
328 {
329 return get_acpi(CM_ASL_PANELBRIGHT);
330 }
331
332 static int set_brightness(struct backlight_device *bd, int value)
333 {
334 value = max(0, min(15, value));
335 return set_acpi(CM_ASL_PANELBRIGHT, value);
336 }
337
338 static int update_bl_status(struct backlight_device *bd)
339 {
340 return set_brightness(bd, bd->props.brightness);
341 }
342
343 /*
344 * Rfkill helpers
345 */
346
347 static bool eeepc_wlan_rfkill_blocked(void)
348 {
349 if (get_acpi(CM_ASL_WLAN) == 1)
350 return false;
351 return true;
352 }
353
354 static int eeepc_rfkill_set(void *data, bool blocked)
355 {
356 unsigned long asl = (unsigned long)data;
357 return set_acpi(asl, !blocked);
358 }
359
360 static const struct rfkill_ops eeepc_rfkill_ops = {
361 .set_block = eeepc_rfkill_set,
362 };
363
364 static void __devinit eeepc_enable_camera(void)
365 {
366 /*
367 * If the following call to set_acpi() fails, it's because there's no
368 * camera so we can ignore the error.
369 */
370 if (get_acpi(CM_ASL_CAMERA) == 0)
371 set_acpi(CM_ASL_CAMERA, 1);
372 }
373
374 /*
375 * Sys helpers
376 */
377 static int parse_arg(const char *buf, unsigned long count, int *val)
378 {
379 if (!count)
380 return 0;
381 if (sscanf(buf, "%i", val) != 1)
382 return -EINVAL;
383 return count;
384 }
385
386 static ssize_t store_sys_acpi(int cm, const char *buf, size_t count)
387 {
388 int rv, value;
389
390 rv = parse_arg(buf, count, &value);
391 if (rv > 0)
392 value = set_acpi(cm, value);
393 if (value < 0)
394 return value;
395 return rv;
396 }
397
398 static ssize_t show_sys_acpi(int cm, char *buf)
399 {
400 int value = get_acpi(cm);
401
402 if (value < 0)
403 return value;
404 return sprintf(buf, "%d\n", value);
405 }
406
407 #define EEEPC_CREATE_DEVICE_ATTR(_name, _cm) \
408 static ssize_t show_##_name(struct device *dev, \
409 struct device_attribute *attr, \
410 char *buf) \
411 { \
412 return show_sys_acpi(_cm, buf); \
413 } \
414 static ssize_t store_##_name(struct device *dev, \
415 struct device_attribute *attr, \
416 const char *buf, size_t count) \
417 { \
418 return store_sys_acpi(_cm, buf, count); \
419 } \
420 static struct device_attribute dev_attr_##_name = { \
421 .attr = { \
422 .name = __stringify(_name), \
423 .mode = 0644 }, \
424 .show = show_##_name, \
425 .store = store_##_name, \
426 }
427
428 EEEPC_CREATE_DEVICE_ATTR(camera, CM_ASL_CAMERA);
429 EEEPC_CREATE_DEVICE_ATTR(cardr, CM_ASL_CARDREADER);
430 EEEPC_CREATE_DEVICE_ATTR(disp, CM_ASL_DISPLAYSWITCH);
431
432 struct eeepc_cpufv {
433 int num;
434 int cur;
435 };
436
437 static int get_cpufv(struct eeepc_cpufv *c)
438 {
439 c->cur = get_acpi(CM_ASL_CPUFV);
440 c->num = (c->cur >> 8) & 0xff;
441 c->cur &= 0xff;
442 if (c->cur < 0 || c->num <= 0 || c->num > 12)
443 return -ENODEV;
444 return 0;
445 }
446
447 static ssize_t show_available_cpufv(struct device *dev,
448 struct device_attribute *attr,
449 char *buf)
450 {
451 struct eeepc_cpufv c;
452 int i;
453 ssize_t len = 0;
454
455 if (get_cpufv(&c))
456 return -ENODEV;
457 for (i = 0; i < c.num; i++)
458 len += sprintf(buf + len, "%d ", i);
459 len += sprintf(buf + len, "\n");
460 return len;
461 }
462
463 static ssize_t show_cpufv(struct device *dev,
464 struct device_attribute *attr,
465 char *buf)
466 {
467 struct eeepc_cpufv c;
468
469 if (get_cpufv(&c))
470 return -ENODEV;
471 return sprintf(buf, "%#x\n", (c.num << 8) | c.cur);
472 }
473
474 static ssize_t store_cpufv(struct device *dev,
475 struct device_attribute *attr,
476 const char *buf, size_t count)
477 {
478 struct eeepc_cpufv c;
479 int rv, value;
480
481 if (ehotk->cpufv_disabled)
482 return -EPERM;
483 if (get_cpufv(&c))
484 return -ENODEV;
485 rv = parse_arg(buf, count, &value);
486 if (rv < 0)
487 return rv;
488 if (!rv || value < 0 || value >= c.num)
489 return -EINVAL;
490 set_acpi(CM_ASL_CPUFV, value);
491 return rv;
492 }
493
494 static ssize_t show_cpufv_disabled(struct device *dev,
495 struct device_attribute *attr,
496 char *buf)
497 {
498 return sprintf(buf, "%d\n", ehotk->cpufv_disabled);
499 }
500
501 static ssize_t store_cpufv_disabled(struct device *dev,
502 struct device_attribute *attr,
503 const char *buf, size_t count)
504 {
505 int rv, value;
506
507 rv = parse_arg(buf, count, &value);
508 if (rv < 0)
509 return rv;
510
511 switch (value) {
512 case 0:
513 if (ehotk->cpufv_disabled)
514 pr_warning("cpufv enabled (not officially supported "
515 "on this model)\n");
516 ehotk->cpufv_disabled = false;
517 return rv;
518 case 1:
519 return -EPERM;
520 default:
521 return -EINVAL;
522 }
523 }
524
525
526 static struct device_attribute dev_attr_cpufv = {
527 .attr = {
528 .name = "cpufv",
529 .mode = 0644 },
530 .show = show_cpufv,
531 .store = store_cpufv
532 };
533
534 static struct device_attribute dev_attr_available_cpufv = {
535 .attr = {
536 .name = "available_cpufv",
537 .mode = 0444 },
538 .show = show_available_cpufv
539 };
540
541 static struct device_attribute dev_attr_cpufv_disabled = {
542 .attr = {
543 .name = "cpufv_disabled",
544 .mode = 0644 },
545 .show = show_cpufv_disabled,
546 .store = store_cpufv_disabled
547 };
548
549
550 static struct attribute *platform_attributes[] = {
551 &dev_attr_camera.attr,
552 &dev_attr_cardr.attr,
553 &dev_attr_disp.attr,
554 &dev_attr_cpufv.attr,
555 &dev_attr_available_cpufv.attr,
556 &dev_attr_cpufv_disabled.attr,
557 NULL
558 };
559
560 static struct attribute_group platform_attribute_group = {
561 .attrs = platform_attributes
562 };
563
564 /*
565 * Hotkey functions
566 */
567 static struct key_entry *eepc_get_entry_by_scancode(int code)
568 {
569 struct key_entry *key;
570
571 for (key = eeepc_keymap; key->type != KE_END; key++)
572 if (code == key->code)
573 return key;
574
575 return NULL;
576 }
577
578 static struct key_entry *eepc_get_entry_by_keycode(int code)
579 {
580 struct key_entry *key;
581
582 for (key = eeepc_keymap; key->type != KE_END; key++)
583 if (code == key->keycode && key->type == KE_KEY)
584 return key;
585
586 return NULL;
587 }
588
589 static int eeepc_getkeycode(struct input_dev *dev, int scancode, int *keycode)
590 {
591 struct key_entry *key = eepc_get_entry_by_scancode(scancode);
592
593 if (key && key->type == KE_KEY) {
594 *keycode = key->keycode;
595 return 0;
596 }
597
598 return -EINVAL;
599 }
600
601 static int eeepc_setkeycode(struct input_dev *dev, int scancode, int keycode)
602 {
603 struct key_entry *key;
604 int old_keycode;
605
606 if (keycode < 0 || keycode > KEY_MAX)
607 return -EINVAL;
608
609 key = eepc_get_entry_by_scancode(scancode);
610 if (key && key->type == KE_KEY) {
611 old_keycode = key->keycode;
612 key->keycode = keycode;
613 set_bit(keycode, dev->keybit);
614 if (!eepc_get_entry_by_keycode(old_keycode))
615 clear_bit(old_keycode, dev->keybit);
616 return 0;
617 }
618
619 return -EINVAL;
620 }
621
622 static void eeepc_dmi_check(void)
623 {
624 const char *model;
625
626 model = dmi_get_system_info(DMI_PRODUCT_NAME);
627 if (!model)
628 return;
629
630 /*
631 * Blacklist for setting cpufv (cpu speed).
632 *
633 * EeePC 4G ("701") implements CFVS, but it is not supported
634 * by the pre-installed OS, and the original option to change it
635 * in the BIOS setup screen was removed in later versions.
636 *
637 * Judging by the lack of "Super Hybrid Engine" on Asus product pages,
638 * this applies to all "701" models (4G/4G Surf/2G Surf).
639 *
640 * So Asus made a deliberate decision not to support it on this model.
641 * We have several reports that using it can cause the system to hang
642 *
643 * The hang has also been reported on a "702" (Model name "8G"?).
644 *
645 * We avoid dmi_check_system() / dmi_match(), because they use
646 * substring matching. We don't want to affect the "701SD"
647 * and "701SDX" models, because they do support S.H.E.
648 */
649 if (strcmp(model, "701") == 0 || strcmp(model, "702") == 0) {
650 ehotk->cpufv_disabled = true;
651 pr_info("model %s does not officially support setting cpu "
652 "speed\n", model);
653 pr_info("cpufv disabled to avoid instability\n");
654 }
655
656 /*
657 * Blacklist for wlan hotplug
658 *
659 * Eeepc 1005HA doesn't work like others models and don't need the
660 * hotplug code. In fact, current hotplug code seems to unplug another
661 * device...
662 */
663 if (strcmp(model, "1005HA") == 0 || strcmp(model, "1201N") == 0 ||
664 strcmp(model, "1005PE") == 0) {
665 ehotk->hotplug_disabled = true;
666 pr_info("wlan hotplug disabled\n");
667 }
668 }
669
670 static void cmsg_quirk(int cm, const char *name)
671 {
672 int dummy;
673
674 /* Some BIOSes do not report cm although it is avaliable.
675 Check if cm_getv[cm] works and, if yes, assume cm should be set. */
676 if (!(ehotk->cm_supported & (1 << cm))
677 && !read_acpi_int(ehotk->handle, cm_getv[cm], &dummy)) {
678 pr_info("%s (%x) not reported by BIOS,"
679 " enabling anyway\n", name, 1 << cm);
680 ehotk->cm_supported |= 1 << cm;
681 }
682 }
683
684 static void cmsg_quirks(void)
685 {
686 cmsg_quirk(CM_ASL_LID, "LID");
687 cmsg_quirk(CM_ASL_TYPE, "TYPE");
688 cmsg_quirk(CM_ASL_PANELPOWER, "PANELPOWER");
689 cmsg_quirk(CM_ASL_TPD, "TPD");
690 }
691
692 static int eeepc_hotk_check(void)
693 {
694 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
695 int result;
696
697 result = acpi_bus_get_status(ehotk->device);
698 if (result)
699 return result;
700 if (ehotk->device->status.present) {
701 if (write_acpi_int(ehotk->handle, "INIT", ehotk->init_flag,
702 &buffer)) {
703 pr_err("Hotkey initialization failed\n");
704 return -ENODEV;
705 } else {
706 pr_notice("Hotkey init flags 0x%x\n", ehotk->init_flag);
707 }
708 /* get control methods supported */
709 if (read_acpi_int(ehotk->handle, "CMSG"
710 , &ehotk->cm_supported)) {
711 pr_err("Get control methods supported failed\n");
712 return -ENODEV;
713 } else {
714 cmsg_quirks();
715 pr_info("Get control methods supported: 0x%x\n",
716 ehotk->cm_supported);
717 }
718 } else {
719 pr_err("Hotkey device not present, aborting\n");
720 return -EINVAL;
721 }
722 return 0;
723 }
724
725 static int notify_brn(void)
726 {
727 /* returns the *previous* brightness, or -1 */
728 struct backlight_device *bd = eeepc_backlight_device;
729 if (bd) {
730 int old = bd->props.brightness;
731 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
732 return old;
733 }
734 return -1;
735 }
736
737 static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
738 u8 *value)
739 {
740 int val = get_acpi(CM_ASL_WLAN);
741
742 if (val == 1 || val == 0)
743 *value = val;
744 else
745 return -EINVAL;
746
747 return 0;
748 }
749
750 static void eeepc_rfkill_hotplug(void)
751 {
752 struct pci_dev *dev;
753 struct pci_bus *bus;
754 bool blocked = eeepc_wlan_rfkill_blocked();
755 bool absent;
756 u32 l;
757
758 if (ehotk->wlan_rfkill)
759 rfkill_set_sw_state(ehotk->wlan_rfkill, blocked);
760
761 mutex_lock(&ehotk->hotplug_lock);
762
763 if (ehotk->hotplug_slot) {
764 bus = pci_find_bus(0, 1);
765 if (!bus) {
766 pr_warning("Unable to find PCI bus 1?\n");
767 goto out_unlock;
768 }
769
770 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
771 pr_err("Unable to read PCI config space?\n");
772 goto out_unlock;
773 }
774 absent = (l == 0xffffffff);
775
776 if (blocked != absent) {
777 pr_warning("BIOS says wireless lan is %s, "
778 "but the pci device is %s\n",
779 blocked ? "blocked" : "unblocked",
780 absent ? "absent" : "present");
781 pr_warning("skipped wireless hotplug as probably "
782 "inappropriate for this model\n");
783 goto out_unlock;
784 }
785
786 if (!blocked) {
787 dev = pci_get_slot(bus, 0);
788 if (dev) {
789 /* Device already present */
790 pci_dev_put(dev);
791 goto out_unlock;
792 }
793 dev = pci_scan_single_device(bus, 0);
794 if (dev) {
795 pci_bus_assign_resources(bus);
796 if (pci_bus_add_device(dev))
797 pr_err("Unable to hotplug wifi\n");
798 }
799 } else {
800 dev = pci_get_slot(bus, 0);
801 if (dev) {
802 pci_remove_bus_device(dev);
803 pci_dev_put(dev);
804 }
805 }
806 }
807
808 out_unlock:
809 mutex_unlock(&ehotk->hotplug_lock);
810 }
811
812 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
813 {
814 if (event != ACPI_NOTIFY_BUS_CHECK)
815 return;
816
817 eeepc_rfkill_hotplug();
818 }
819
820 static void eeepc_hotk_notify(struct acpi_device *device, u32 event)
821 {
822 static struct key_entry *key;
823 u16 count;
824 int brn = -ENODEV;
825
826 if (!ehotk)
827 return;
828 if (event > ACPI_MAX_SYS_NOTIFY)
829 return;
830 if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX)
831 brn = notify_brn();
832 count = ehotk->event_count[event % 128]++;
833 acpi_bus_generate_proc_event(ehotk->device, event, count);
834 acpi_bus_generate_netlink_event(ehotk->device->pnp.device_class,
835 dev_name(&ehotk->device->dev), event,
836 count);
837 if (ehotk->inputdev) {
838 if (brn != -ENODEV) {
839 /* brightness-change events need special
840 * handling for conversion to key events
841 */
842 if (brn < 0)
843 brn = event;
844 else
845 brn += NOTIFY_BRN_MIN;
846 if (event < brn)
847 event = NOTIFY_BRN_MIN; /* brightness down */
848 else if (event > brn)
849 event = NOTIFY_BRN_MIN + 2; /* ... up */
850 else
851 event = NOTIFY_BRN_MIN + 1; /* ... unchanged */
852 }
853 key = eepc_get_entry_by_scancode(event);
854 if (key) {
855 switch (key->type) {
856 case KE_KEY:
857 input_report_key(ehotk->inputdev, key->keycode,
858 1);
859 input_sync(ehotk->inputdev);
860 input_report_key(ehotk->inputdev, key->keycode,
861 0);
862 input_sync(ehotk->inputdev);
863 break;
864 }
865 }
866 }
867 }
868
869 static int eeepc_register_rfkill_notifier(char *node)
870 {
871 acpi_status status = AE_OK;
872 acpi_handle handle;
873
874 status = acpi_get_handle(NULL, node, &handle);
875
876 if (ACPI_SUCCESS(status)) {
877 status = acpi_install_notify_handler(handle,
878 ACPI_SYSTEM_NOTIFY,
879 eeepc_rfkill_notify,
880 NULL);
881 if (ACPI_FAILURE(status))
882 pr_warning("Failed to register notify on %s\n", node);
883 } else
884 return -ENODEV;
885
886 return 0;
887 }
888
889 static void eeepc_unregister_rfkill_notifier(char *node)
890 {
891 acpi_status status = AE_OK;
892 acpi_handle handle;
893
894 status = acpi_get_handle(NULL, node, &handle);
895
896 if (ACPI_SUCCESS(status)) {
897 status = acpi_remove_notify_handler(handle,
898 ACPI_SYSTEM_NOTIFY,
899 eeepc_rfkill_notify);
900 if (ACPI_FAILURE(status))
901 pr_err("Error removing rfkill notify handler %s\n",
902 node);
903 }
904 }
905
906 static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
907 {
908 kfree(hotplug_slot->info);
909 kfree(hotplug_slot);
910 }
911
912 static int eeepc_setup_pci_hotplug(void)
913 {
914 int ret = -ENOMEM;
915 struct pci_bus *bus = pci_find_bus(0, 1);
916
917 if (!bus) {
918 pr_err("Unable to find wifi PCI bus\n");
919 return -ENODEV;
920 }
921
922 ehotk->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
923 if (!ehotk->hotplug_slot)
924 goto error_slot;
925
926 ehotk->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
927 GFP_KERNEL);
928 if (!ehotk->hotplug_slot->info)
929 goto error_info;
930
931 ehotk->hotplug_slot->private = ehotk;
932 ehotk->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
933 ehotk->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
934 eeepc_get_adapter_status(ehotk->hotplug_slot,
935 &ehotk->hotplug_slot->info->adapter_status);
936
937 ret = pci_hp_register(ehotk->hotplug_slot, bus, 0, "eeepc-wifi");
938 if (ret) {
939 pr_err("Unable to register hotplug slot - %d\n", ret);
940 goto error_register;
941 }
942
943 return 0;
944
945 error_register:
946 kfree(ehotk->hotplug_slot->info);
947 error_info:
948 kfree(ehotk->hotplug_slot);
949 ehotk->hotplug_slot = NULL;
950 error_slot:
951 return ret;
952 }
953
954 static int eeepc_hotk_thaw(struct device *device)
955 {
956 if (ehotk->wlan_rfkill) {
957 bool wlan;
958
959 /*
960 * Work around bios bug - acpi _PTS turns off the wireless led
961 * during suspend. Normally it restores it on resume, but
962 * we should kick it ourselves in case hibernation is aborted.
963 */
964 wlan = get_acpi(CM_ASL_WLAN);
965 set_acpi(CM_ASL_WLAN, wlan);
966 }
967
968 return 0;
969 }
970
971 static int eeepc_hotk_restore(struct device *device)
972 {
973 /* Refresh both wlan rfkill state and pci hotplug */
974 if (ehotk->wlan_rfkill)
975 eeepc_rfkill_hotplug();
976
977 if (ehotk->bluetooth_rfkill)
978 rfkill_set_sw_state(ehotk->bluetooth_rfkill,
979 get_acpi(CM_ASL_BLUETOOTH) != 1);
980 if (ehotk->wwan3g_rfkill)
981 rfkill_set_sw_state(ehotk->wwan3g_rfkill,
982 get_acpi(CM_ASL_3G) != 1);
983 if (ehotk->wimax_rfkill)
984 rfkill_set_sw_state(ehotk->wimax_rfkill,
985 get_acpi(CM_ASL_WIMAX) != 1);
986
987 return 0;
988 }
989
990 /*
991 * Hwmon
992 */
993 static int eeepc_get_fan_pwm(void)
994 {
995 int value = 0;
996
997 read_acpi_int(NULL, EEEPC_EC_FAN_PWM, &value);
998 value = value * 255 / 100;
999 return (value);
1000 }
1001
1002 static void eeepc_set_fan_pwm(int value)
1003 {
1004 value = SENSORS_LIMIT(value, 0, 255);
1005 value = value * 100 / 255;
1006 ec_write(EEEPC_EC_SC02, value);
1007 }
1008
1009 static int eeepc_get_fan_rpm(void)
1010 {
1011 int high = 0;
1012 int low = 0;
1013
1014 read_acpi_int(NULL, EEEPC_EC_FAN_HRPM, &high);
1015 read_acpi_int(NULL, EEEPC_EC_FAN_LRPM, &low);
1016 return (high << 8 | low);
1017 }
1018
1019 static int eeepc_get_fan_ctrl(void)
1020 {
1021 int value = 0;
1022
1023 read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
1024 return ((value & 0x02 ? 1 : 0));
1025 }
1026
1027 static void eeepc_set_fan_ctrl(int manual)
1028 {
1029 int value = 0;
1030
1031 read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
1032 if (manual)
1033 value |= 0x02;
1034 else
1035 value &= ~0x02;
1036 ec_write(EEEPC_EC_SFB3, value);
1037 }
1038
1039 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
1040 {
1041 int rv, value;
1042
1043 rv = parse_arg(buf, count, &value);
1044 if (rv > 0)
1045 set(value);
1046 return rv;
1047 }
1048
1049 static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
1050 {
1051 return sprintf(buf, "%d\n", get());
1052 }
1053
1054 #define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get) \
1055 static ssize_t show_##_name(struct device *dev, \
1056 struct device_attribute *attr, \
1057 char *buf) \
1058 { \
1059 return show_sys_hwmon(_set, buf); \
1060 } \
1061 static ssize_t store_##_name(struct device *dev, \
1062 struct device_attribute *attr, \
1063 const char *buf, size_t count) \
1064 { \
1065 return store_sys_hwmon(_get, buf, count); \
1066 } \
1067 static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0);
1068
1069 EEEPC_CREATE_SENSOR_ATTR(fan1_input, S_IRUGO, eeepc_get_fan_rpm, NULL);
1070 EEEPC_CREATE_SENSOR_ATTR(pwm1, S_IRUGO | S_IWUSR,
1071 eeepc_get_fan_pwm, eeepc_set_fan_pwm);
1072 EEEPC_CREATE_SENSOR_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
1073 eeepc_get_fan_ctrl, eeepc_set_fan_ctrl);
1074
1075 static ssize_t
1076 show_name(struct device *dev, struct device_attribute *attr, char *buf)
1077 {
1078 return sprintf(buf, "eeepc\n");
1079 }
1080 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
1081
1082 static struct attribute *hwmon_attributes[] = {
1083 &sensor_dev_attr_pwm1.dev_attr.attr,
1084 &sensor_dev_attr_fan1_input.dev_attr.attr,
1085 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1086 &sensor_dev_attr_name.dev_attr.attr,
1087 NULL
1088 };
1089
1090 static struct attribute_group hwmon_attribute_group = {
1091 .attrs = hwmon_attributes
1092 };
1093
1094 /*
1095 * exit/init
1096 */
1097 static void eeepc_backlight_exit(void)
1098 {
1099 if (eeepc_backlight_device)
1100 backlight_device_unregister(eeepc_backlight_device);
1101 eeepc_backlight_device = NULL;
1102 }
1103
1104 static void eeepc_rfkill_exit(void)
1105 {
1106 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P5");
1107 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
1108 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
1109 if (ehotk->wlan_rfkill) {
1110 rfkill_unregister(ehotk->wlan_rfkill);
1111 rfkill_destroy(ehotk->wlan_rfkill);
1112 ehotk->wlan_rfkill = NULL;
1113 }
1114 /*
1115 * Refresh pci hotplug in case the rfkill state was changed after
1116 * eeepc_unregister_rfkill_notifier()
1117 */
1118 eeepc_rfkill_hotplug();
1119 if (ehotk->hotplug_slot)
1120 pci_hp_deregister(ehotk->hotplug_slot);
1121
1122 if (ehotk->bluetooth_rfkill) {
1123 rfkill_unregister(ehotk->bluetooth_rfkill);
1124 rfkill_destroy(ehotk->bluetooth_rfkill);
1125 ehotk->bluetooth_rfkill = NULL;
1126 }
1127 if (ehotk->wwan3g_rfkill) {
1128 rfkill_unregister(ehotk->wwan3g_rfkill);
1129 rfkill_destroy(ehotk->wwan3g_rfkill);
1130 ehotk->wwan3g_rfkill = NULL;
1131 }
1132 if (ehotk->wimax_rfkill) {
1133 rfkill_unregister(ehotk->wimax_rfkill);
1134 rfkill_destroy(ehotk->wimax_rfkill);
1135 ehotk->wimax_rfkill = NULL;
1136 }
1137 }
1138
1139 static void eeepc_input_exit(void)
1140 {
1141 if (ehotk->inputdev)
1142 input_unregister_device(ehotk->inputdev);
1143 }
1144
1145 static void eeepc_hwmon_exit(void)
1146 {
1147 struct device *hwmon;
1148
1149 hwmon = eeepc_hwmon_device;
1150 if (!hwmon)
1151 return ;
1152 sysfs_remove_group(&hwmon->kobj,
1153 &hwmon_attribute_group);
1154 hwmon_device_unregister(hwmon);
1155 eeepc_hwmon_device = NULL;
1156 }
1157
1158 static int eeepc_new_rfkill(struct rfkill **rfkill,
1159 const char *name, struct device *dev,
1160 enum rfkill_type type, int cm)
1161 {
1162 int result;
1163
1164 result = get_acpi(cm);
1165 if (result < 0)
1166 return result;
1167
1168 *rfkill = rfkill_alloc(name, dev, type,
1169 &eeepc_rfkill_ops, (void *)(unsigned long)cm);
1170
1171 if (!*rfkill)
1172 return -EINVAL;
1173
1174 rfkill_init_sw_state(*rfkill, get_acpi(cm) != 1);
1175 result = rfkill_register(*rfkill);
1176 if (result) {
1177 rfkill_destroy(*rfkill);
1178 *rfkill = NULL;
1179 return result;
1180 }
1181 return 0;
1182 }
1183
1184
1185 static int eeepc_rfkill_init(struct device *dev)
1186 {
1187 int result = 0;
1188
1189 mutex_init(&ehotk->hotplug_lock);
1190
1191 result = eeepc_new_rfkill(&ehotk->wlan_rfkill,
1192 "eeepc-wlan", dev,
1193 RFKILL_TYPE_WLAN, CM_ASL_WLAN);
1194
1195 if (result && result != -ENODEV)
1196 goto exit;
1197
1198 result = eeepc_new_rfkill(&ehotk->bluetooth_rfkill,
1199 "eeepc-bluetooth", dev,
1200 RFKILL_TYPE_BLUETOOTH, CM_ASL_BLUETOOTH);
1201
1202 if (result && result != -ENODEV)
1203 goto exit;
1204
1205 result = eeepc_new_rfkill(&ehotk->wwan3g_rfkill,
1206 "eeepc-wwan3g", dev,
1207 RFKILL_TYPE_WWAN, CM_ASL_3G);
1208
1209 if (result && result != -ENODEV)
1210 goto exit;
1211
1212 result = eeepc_new_rfkill(&ehotk->wimax_rfkill,
1213 "eeepc-wimax", dev,
1214 RFKILL_TYPE_WIMAX, CM_ASL_WIMAX);
1215
1216 if (result && result != -ENODEV)
1217 goto exit;
1218
1219 if (ehotk->hotplug_disabled)
1220 return 0;
1221
1222 result = eeepc_setup_pci_hotplug();
1223 /*
1224 * If we get -EBUSY then something else is handling the PCI hotplug -
1225 * don't fail in this case
1226 */
1227 if (result == -EBUSY)
1228 result = 0;
1229
1230 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P5");
1231 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
1232 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
1233 /*
1234 * Refresh pci hotplug in case the rfkill state was changed during
1235 * setup.
1236 */
1237 eeepc_rfkill_hotplug();
1238
1239 exit:
1240 if (result && result != -ENODEV)
1241 eeepc_rfkill_exit();
1242 return result;
1243 }
1244
1245 static int eeepc_backlight_init(struct device *dev)
1246 {
1247 struct backlight_device *bd;
1248
1249 bd = backlight_device_register(EEEPC_HOTK_FILE, dev,
1250 NULL, &eeepcbl_ops);
1251 if (IS_ERR(bd)) {
1252 pr_err("Could not register eeepc backlight device\n");
1253 eeepc_backlight_device = NULL;
1254 return PTR_ERR(bd);
1255 }
1256 eeepc_backlight_device = bd;
1257 bd->props.max_brightness = 15;
1258 bd->props.brightness = read_brightness(NULL);
1259 bd->props.power = FB_BLANK_UNBLANK;
1260 backlight_update_status(bd);
1261 return 0;
1262 }
1263
1264 static int eeepc_hwmon_init(struct device *dev)
1265 {
1266 struct device *hwmon;
1267 int result;
1268
1269 hwmon = hwmon_device_register(dev);
1270 if (IS_ERR(hwmon)) {
1271 pr_err("Could not register eeepc hwmon device\n");
1272 eeepc_hwmon_device = NULL;
1273 return PTR_ERR(hwmon);
1274 }
1275 eeepc_hwmon_device = hwmon;
1276 result = sysfs_create_group(&hwmon->kobj,
1277 &hwmon_attribute_group);
1278 if (result)
1279 eeepc_hwmon_exit();
1280 return result;
1281 }
1282
1283 static int eeepc_input_init(struct device *dev)
1284 {
1285 const struct key_entry *key;
1286 int result;
1287
1288 ehotk->inputdev = input_allocate_device();
1289 if (!ehotk->inputdev) {
1290 pr_info("Unable to allocate input device\n");
1291 return -ENOMEM;
1292 }
1293 ehotk->inputdev->name = "Asus EeePC extra buttons";
1294 ehotk->inputdev->dev.parent = dev;
1295 ehotk->inputdev->phys = EEEPC_HOTK_FILE "/input0";
1296 ehotk->inputdev->id.bustype = BUS_HOST;
1297 ehotk->inputdev->getkeycode = eeepc_getkeycode;
1298 ehotk->inputdev->setkeycode = eeepc_setkeycode;
1299
1300 for (key = eeepc_keymap; key->type != KE_END; key++) {
1301 switch (key->type) {
1302 case KE_KEY:
1303 set_bit(EV_KEY, ehotk->inputdev->evbit);
1304 set_bit(key->keycode, ehotk->inputdev->keybit);
1305 break;
1306 }
1307 }
1308 result = input_register_device(ehotk->inputdev);
1309 if (result) {
1310 pr_info("Unable to register input device\n");
1311 input_free_device(ehotk->inputdev);
1312 return result;
1313 }
1314 return 0;
1315 }
1316
1317 static int __devinit eeepc_hotk_add(struct acpi_device *device)
1318 {
1319 struct device *dev;
1320 int result;
1321
1322 if (!device)
1323 return -EINVAL;
1324 pr_notice(EEEPC_HOTK_NAME "\n");
1325 ehotk = kzalloc(sizeof(struct eeepc_hotk), GFP_KERNEL);
1326 if (!ehotk)
1327 return -ENOMEM;
1328 ehotk->init_flag = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
1329 ehotk->handle = device->handle;
1330 strcpy(acpi_device_name(device), EEEPC_HOTK_DEVICE_NAME);
1331 strcpy(acpi_device_class(device), EEEPC_HOTK_CLASS);
1332 device->driver_data = ehotk;
1333 ehotk->device = device;
1334
1335 ehotk->hotplug_disabled = hotplug_disabled;
1336
1337 eeepc_dmi_check();
1338
1339 result = eeepc_hotk_check();
1340 if (result)
1341 goto fail_platform_driver;
1342 eeepc_enable_camera();
1343
1344 /* Register platform stuff */
1345 result = platform_driver_register(&platform_driver);
1346 if (result)
1347 goto fail_platform_driver;
1348 platform_device = platform_device_alloc(EEEPC_HOTK_FILE, -1);
1349 if (!platform_device) {
1350 result = -ENOMEM;
1351 goto fail_platform_device1;
1352 }
1353 result = platform_device_add(platform_device);
1354 if (result)
1355 goto fail_platform_device2;
1356 result = sysfs_create_group(&platform_device->dev.kobj,
1357 &platform_attribute_group);
1358 if (result)
1359 goto fail_sysfs;
1360
1361 dev = &platform_device->dev;
1362
1363 if (!acpi_video_backlight_support()) {
1364 result = eeepc_backlight_init(dev);
1365 if (result)
1366 goto fail_backlight;
1367 } else
1368 pr_info("Backlight controlled by ACPI video "
1369 "driver\n");
1370
1371 result = eeepc_input_init(dev);
1372 if (result)
1373 goto fail_input;
1374
1375 result = eeepc_hwmon_init(dev);
1376 if (result)
1377 goto fail_hwmon;
1378
1379 result = eeepc_rfkill_init(dev);
1380 if (result)
1381 goto fail_rfkill;
1382
1383 return 0;
1384
1385 fail_rfkill:
1386 eeepc_hwmon_exit();
1387 fail_hwmon:
1388 eeepc_input_exit();
1389 fail_input:
1390 eeepc_backlight_exit();
1391 fail_backlight:
1392 sysfs_remove_group(&platform_device->dev.kobj,
1393 &platform_attribute_group);
1394 fail_sysfs:
1395 platform_device_del(platform_device);
1396 fail_platform_device2:
1397 platform_device_put(platform_device);
1398 fail_platform_device1:
1399 platform_driver_unregister(&platform_driver);
1400 fail_platform_driver:
1401 kfree(ehotk);
1402
1403 return result;
1404 }
1405
1406 static int eeepc_hotk_remove(struct acpi_device *device, int type)
1407 {
1408 if (!device || !acpi_driver_data(device))
1409 return -EINVAL;
1410
1411 eeepc_backlight_exit();
1412 eeepc_rfkill_exit();
1413 eeepc_input_exit();
1414 eeepc_hwmon_exit();
1415 sysfs_remove_group(&platform_device->dev.kobj,
1416 &platform_attribute_group);
1417 platform_device_unregister(platform_device);
1418 platform_driver_unregister(&platform_driver);
1419
1420 kfree(ehotk);
1421 return 0;
1422 }
1423
1424 static int __init eeepc_laptop_init(void)
1425 {
1426 int result;
1427
1428 if (acpi_disabled)
1429 return -ENODEV;
1430 result = acpi_bus_register_driver(&eeepc_hotk_driver);
1431 if (result < 0)
1432 return result;
1433 if (!ehotk) {
1434 acpi_bus_unregister_driver(&eeepc_hotk_driver);
1435 return -ENODEV;
1436 }
1437 return 0;
1438 }
1439
1440 static void __exit eeepc_laptop_exit(void)
1441 {
1442 acpi_bus_unregister_driver(&eeepc_hotk_driver);
1443 }
1444
1445 module_init(eeepc_laptop_init);
1446 module_exit(eeepc_laptop_exit);
Linux ARM platform port for MOXA ART SoC