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