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