?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/amd-iommu: Add per IOMMU reference counting
[linux/fpc-iii.git] / drivers / platform / x86 / eeepc-laptop.c
blob4226e535273874fb06aea0344c4c8ce00a8b957c
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 __devinit 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 if (get_acpi(CM_ASL_CAMERA) == 0)
360 set_acpi(CM_ASL_CAMERA, 1);
361 }
362
363 /*
364 * Sys helpers
365 */
366 static int parse_arg(const char *buf, unsigned long count, int *val)
367 {
368 if (!count)
369 return 0;
370 if (sscanf(buf, "%i", val) != 1)
371 return -EINVAL;
372 return count;
373 }
374
375 static ssize_t store_sys_acpi(int cm, const char *buf, size_t count)
376 {
377 int rv, value;
378
379 rv = parse_arg(buf, count, &value);
380 if (rv > 0)
381 value = set_acpi(cm, value);
382 if (value < 0)
383 return value;
384 return rv;
385 }
386
387 static ssize_t show_sys_acpi(int cm, char *buf)
388 {
389 int value = get_acpi(cm);
390
391 if (value < 0)
392 return value;
393 return sprintf(buf, "%d\n", value);
394 }
395
396 #define EEEPC_CREATE_DEVICE_ATTR(_name, _cm) \
397 static ssize_t show_##_name(struct device *dev, \
398 struct device_attribute *attr, \
399 char *buf) \
400 { \
401 return show_sys_acpi(_cm, buf); \
402 } \
403 static ssize_t store_##_name(struct device *dev, \
404 struct device_attribute *attr, \
405 const char *buf, size_t count) \
406 { \
407 return store_sys_acpi(_cm, buf, count); \
408 } \
409 static struct device_attribute dev_attr_##_name = { \
410 .attr = { \
411 .name = __stringify(_name), \
412 .mode = 0644 }, \
413 .show = show_##_name, \
414 .store = store_##_name, \
415 }
416
417 EEEPC_CREATE_DEVICE_ATTR(camera, CM_ASL_CAMERA);
418 EEEPC_CREATE_DEVICE_ATTR(cardr, CM_ASL_CARDREADER);
419 EEEPC_CREATE_DEVICE_ATTR(disp, CM_ASL_DISPLAYSWITCH);
420
421 struct eeepc_cpufv {
422 int num;
423 int cur;
424 };
425
426 static int get_cpufv(struct eeepc_cpufv *c)
427 {
428 c->cur = get_acpi(CM_ASL_CPUFV);
429 c->num = (c->cur >> 8) & 0xff;
430 c->cur &= 0xff;
431 if (c->cur < 0 || c->num <= 0 || c->num > 12)
432 return -ENODEV;
433 return 0;
434 }
435
436 static ssize_t show_available_cpufv(struct device *dev,
437 struct device_attribute *attr,
438 char *buf)
439 {
440 struct eeepc_cpufv c;
441 int i;
442 ssize_t len = 0;
443
444 if (get_cpufv(&c))
445 return -ENODEV;
446 for (i = 0; i < c.num; i++)
447 len += sprintf(buf + len, "%d ", i);
448 len += sprintf(buf + len, "\n");
449 return len;
450 }
451
452 static ssize_t show_cpufv(struct device *dev,
453 struct device_attribute *attr,
454 char *buf)
455 {
456 struct eeepc_cpufv c;
457
458 if (get_cpufv(&c))
459 return -ENODEV;
460 return sprintf(buf, "%#x\n", (c.num << 8) | c.cur);
461 }
462
463 static ssize_t store_cpufv(struct device *dev,
464 struct device_attribute *attr,
465 const char *buf, size_t count)
466 {
467 struct eeepc_cpufv c;
468 int rv, value;
469
470 if (get_cpufv(&c))
471 return -ENODEV;
472 rv = parse_arg(buf, count, &value);
473 if (rv < 0)
474 return rv;
475 if (!rv || value < 0 || value >= c.num)
476 return -EINVAL;
477 set_acpi(CM_ASL_CPUFV, value);
478 return rv;
479 }
480
481 static struct device_attribute dev_attr_cpufv = {
482 .attr = {
483 .name = "cpufv",
484 .mode = 0644 },
485 .show = show_cpufv,
486 .store = store_cpufv
487 };
488
489 static struct device_attribute dev_attr_available_cpufv = {
490 .attr = {
491 .name = "available_cpufv",
492 .mode = 0444 },
493 .show = show_available_cpufv
494 };
495
496 static struct attribute *platform_attributes[] = {
497 &dev_attr_camera.attr,
498 &dev_attr_cardr.attr,
499 &dev_attr_disp.attr,
500 &dev_attr_cpufv.attr,
501 &dev_attr_available_cpufv.attr,
502 NULL
503 };
504
505 static struct attribute_group platform_attribute_group = {
506 .attrs = platform_attributes
507 };
508
509 /*
510 * Hotkey functions
511 */
512 static struct key_entry *eepc_get_entry_by_scancode(int code)
513 {
514 struct key_entry *key;
515
516 for (key = eeepc_keymap; key->type != KE_END; key++)
517 if (code == key->code)
518 return key;
519
520 return NULL;
521 }
522
523 static struct key_entry *eepc_get_entry_by_keycode(int code)
524 {
525 struct key_entry *key;
526
527 for (key = eeepc_keymap; key->type != KE_END; key++)
528 if (code == key->keycode && key->type == KE_KEY)
529 return key;
530
531 return NULL;
532 }
533
534 static int eeepc_getkeycode(struct input_dev *dev, int scancode, int *keycode)
535 {
536 struct key_entry *key = eepc_get_entry_by_scancode(scancode);
537
538 if (key && key->type == KE_KEY) {
539 *keycode = key->keycode;
540 return 0;
541 }
542
543 return -EINVAL;
544 }
545
546 static int eeepc_setkeycode(struct input_dev *dev, int scancode, int keycode)
547 {
548 struct key_entry *key;
549 int old_keycode;
550
551 if (keycode < 0 || keycode > KEY_MAX)
552 return -EINVAL;
553
554 key = eepc_get_entry_by_scancode(scancode);
555 if (key && key->type == KE_KEY) {
556 old_keycode = key->keycode;
557 key->keycode = keycode;
558 set_bit(keycode, dev->keybit);
559 if (!eepc_get_entry_by_keycode(old_keycode))
560 clear_bit(old_keycode, dev->keybit);
561 return 0;
562 }
563
564 return -EINVAL;
565 }
566
567 static void cmsg_quirk(int cm, const char *name)
568 {
569 int dummy;
570
571 /* Some BIOSes do not report cm although it is avaliable.
572 Check if cm_getv[cm] works and, if yes, assume cm should be set. */
573 if (!(ehotk->cm_supported & (1 << cm))
574 && !read_acpi_int(ehotk->handle, cm_getv[cm], &dummy)) {
575 pr_info("%s (%x) not reported by BIOS,"
576 " enabling anyway\n", name, 1 << cm);
577 ehotk->cm_supported |= 1 << cm;
578 }
579 }
580
581 static void cmsg_quirks(void)
582 {
583 cmsg_quirk(CM_ASL_LID, "LID");
584 cmsg_quirk(CM_ASL_TYPE, "TYPE");
585 cmsg_quirk(CM_ASL_PANELPOWER, "PANELPOWER");
586 cmsg_quirk(CM_ASL_TPD, "TPD");
587 }
588
589 static int eeepc_hotk_check(void)
590 {
591 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
592 int result;
593
594 result = acpi_bus_get_status(ehotk->device);
595 if (result)
596 return result;
597 if (ehotk->device->status.present) {
598 if (write_acpi_int(ehotk->handle, "INIT", ehotk->init_flag,
599 &buffer)) {
600 pr_err("Hotkey initialization failed\n");
601 return -ENODEV;
602 } else {
603 pr_notice("Hotkey init flags 0x%x\n", ehotk->init_flag);
604 }
605 /* get control methods supported */
606 if (read_acpi_int(ehotk->handle, "CMSG"
607 , &ehotk->cm_supported)) {
608 pr_err("Get control methods supported failed\n");
609 return -ENODEV;
610 } else {
611 cmsg_quirks();
612 pr_info("Get control methods supported: 0x%x\n",
613 ehotk->cm_supported);
614 }
615 } else {
616 pr_err("Hotkey device not present, aborting\n");
617 return -EINVAL;
618 }
619 return 0;
620 }
621
622 static int notify_brn(void)
623 {
624 /* returns the *previous* brightness, or -1 */
625 struct backlight_device *bd = eeepc_backlight_device;
626 if (bd) {
627 int old = bd->props.brightness;
628 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
629 return old;
630 }
631 return -1;
632 }
633
634 static int eeepc_get_adapter_status(struct hotplug_slot *hotplug_slot,
635 u8 *value)
636 {
637 int val = get_acpi(CM_ASL_WLAN);
638
639 if (val == 1 || val == 0)
640 *value = val;
641 else
642 return -EINVAL;
643
644 return 0;
645 }
646
647 static void eeepc_rfkill_hotplug(void)
648 {
649 struct pci_dev *dev;
650 struct pci_bus *bus;
651 bool blocked = eeepc_wlan_rfkill_blocked();
652
653 if (ehotk->wlan_rfkill)
654 rfkill_set_sw_state(ehotk->wlan_rfkill, blocked);
655
656 mutex_lock(&ehotk->hotplug_lock);
657
658 if (ehotk->hotplug_slot) {
659 bus = pci_find_bus(0, 1);
660 if (!bus) {
661 pr_warning("Unable to find PCI bus 1?\n");
662 goto out_unlock;
663 }
664
665 if (!blocked) {
666 dev = pci_get_slot(bus, 0);
667 if (dev) {
668 /* Device already present */
669 pci_dev_put(dev);
670 goto out_unlock;
671 }
672 dev = pci_scan_single_device(bus, 0);
673 if (dev) {
674 pci_bus_assign_resources(bus);
675 if (pci_bus_add_device(dev))
676 pr_err("Unable to hotplug wifi\n");
677 }
678 } else {
679 dev = pci_get_slot(bus, 0);
680 if (dev) {
681 pci_remove_bus_device(dev);
682 pci_dev_put(dev);
683 }
684 }
685 }
686
687 out_unlock:
688 mutex_unlock(&ehotk->hotplug_lock);
689 }
690
691 static void eeepc_rfkill_notify(acpi_handle handle, u32 event, void *data)
692 {
693 if (event != ACPI_NOTIFY_BUS_CHECK)
694 return;
695
696 eeepc_rfkill_hotplug();
697 }
698
699 static void eeepc_hotk_notify(struct acpi_device *device, u32 event)
700 {
701 static struct key_entry *key;
702 u16 count;
703 int brn = -ENODEV;
704
705 if (!ehotk)
706 return;
707 if (event > ACPI_MAX_SYS_NOTIFY)
708 return;
709 if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX)
710 brn = notify_brn();
711 count = ehotk->event_count[event % 128]++;
712 acpi_bus_generate_proc_event(ehotk->device, event, count);
713 acpi_bus_generate_netlink_event(ehotk->device->pnp.device_class,
714 dev_name(&ehotk->device->dev), event,
715 count);
716 if (ehotk->inputdev) {
717 if (brn != -ENODEV) {
718 /* brightness-change events need special
719 * handling for conversion to key events
720 */
721 if (brn < 0)
722 brn = event;
723 else
724 brn += NOTIFY_BRN_MIN;
725 if (event < brn)
726 event = NOTIFY_BRN_MIN; /* brightness down */
727 else if (event > brn)
728 event = NOTIFY_BRN_MIN + 2; /* ... up */
729 else
730 event = NOTIFY_BRN_MIN + 1; /* ... unchanged */
731 }
732 key = eepc_get_entry_by_scancode(event);
733 if (key) {
734 switch (key->type) {
735 case KE_KEY:
736 input_report_key(ehotk->inputdev, key->keycode,
737 1);
738 input_sync(ehotk->inputdev);
739 input_report_key(ehotk->inputdev, key->keycode,
740 0);
741 input_sync(ehotk->inputdev);
742 break;
743 }
744 }
745 }
746 }
747
748 static int eeepc_register_rfkill_notifier(char *node)
749 {
750 acpi_status status = AE_OK;
751 acpi_handle handle;
752
753 status = acpi_get_handle(NULL, node, &handle);
754
755 if (ACPI_SUCCESS(status)) {
756 status = acpi_install_notify_handler(handle,
757 ACPI_SYSTEM_NOTIFY,
758 eeepc_rfkill_notify,
759 NULL);
760 if (ACPI_FAILURE(status))
761 pr_warning("Failed to register notify on %s\n", node);
762 } else
763 return -ENODEV;
764
765 return 0;
766 }
767
768 static void eeepc_unregister_rfkill_notifier(char *node)
769 {
770 acpi_status status = AE_OK;
771 acpi_handle handle;
772
773 status = acpi_get_handle(NULL, node, &handle);
774
775 if (ACPI_SUCCESS(status)) {
776 status = acpi_remove_notify_handler(handle,
777 ACPI_SYSTEM_NOTIFY,
778 eeepc_rfkill_notify);
779 if (ACPI_FAILURE(status))
780 pr_err("Error removing rfkill notify handler %s\n",
781 node);
782 }
783 }
784
785 static void eeepc_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
786 {
787 kfree(hotplug_slot->info);
788 kfree(hotplug_slot);
789 }
790
791 static int eeepc_setup_pci_hotplug(void)
792 {
793 int ret = -ENOMEM;
794 struct pci_bus *bus = pci_find_bus(0, 1);
795
796 if (!bus) {
797 pr_err("Unable to find wifi PCI bus\n");
798 return -ENODEV;
799 }
800
801 ehotk->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
802 if (!ehotk->hotplug_slot)
803 goto error_slot;
804
805 ehotk->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
806 GFP_KERNEL);
807 if (!ehotk->hotplug_slot->info)
808 goto error_info;
809
810 ehotk->hotplug_slot->private = ehotk;
811 ehotk->hotplug_slot->release = &eeepc_cleanup_pci_hotplug;
812 ehotk->hotplug_slot->ops = &eeepc_hotplug_slot_ops;
813 eeepc_get_adapter_status(ehotk->hotplug_slot,
814 &ehotk->hotplug_slot->info->adapter_status);
815
816 ret = pci_hp_register(ehotk->hotplug_slot, bus, 0, "eeepc-wifi");
817 if (ret) {
818 pr_err("Unable to register hotplug slot - %d\n", ret);
819 goto error_register;
820 }
821
822 return 0;
823
824 error_register:
825 kfree(ehotk->hotplug_slot->info);
826 error_info:
827 kfree(ehotk->hotplug_slot);
828 ehotk->hotplug_slot = NULL;
829 error_slot:
830 return ret;
831 }
832
833 static int eeepc_hotk_thaw(struct device *device)
834 {
835 if (ehotk->wlan_rfkill) {
836 bool wlan;
837
838 /*
839 * Work around bios bug - acpi _PTS turns off the wireless led
840 * during suspend. Normally it restores it on resume, but
841 * we should kick it ourselves in case hibernation is aborted.
842 */
843 wlan = get_acpi(CM_ASL_WLAN);
844 set_acpi(CM_ASL_WLAN, wlan);
845 }
846
847 return 0;
848 }
849
850 static int eeepc_hotk_restore(struct device *device)
851 {
852 /* Refresh both wlan rfkill state and pci hotplug */
853 if (ehotk->wlan_rfkill)
854 eeepc_rfkill_hotplug();
855
856 if (ehotk->bluetooth_rfkill)
857 rfkill_set_sw_state(ehotk->bluetooth_rfkill,
858 get_acpi(CM_ASL_BLUETOOTH) != 1);
859 if (ehotk->wwan3g_rfkill)
860 rfkill_set_sw_state(ehotk->wwan3g_rfkill,
861 get_acpi(CM_ASL_3G) != 1);
862 if (ehotk->wimax_rfkill)
863 rfkill_set_sw_state(ehotk->wimax_rfkill,
864 get_acpi(CM_ASL_WIMAX) != 1);
865
866 return 0;
867 }
868
869 /*
870 * Hwmon
871 */
872 static int eeepc_get_fan_pwm(void)
873 {
874 int value = 0;
875
876 read_acpi_int(NULL, EEEPC_EC_FAN_PWM, &value);
877 value = value * 255 / 100;
878 return (value);
879 }
880
881 static void eeepc_set_fan_pwm(int value)
882 {
883 value = SENSORS_LIMIT(value, 0, 255);
884 value = value * 100 / 255;
885 ec_write(EEEPC_EC_SC02, value);
886 }
887
888 static int eeepc_get_fan_rpm(void)
889 {
890 int high = 0;
891 int low = 0;
892
893 read_acpi_int(NULL, EEEPC_EC_FAN_HRPM, &high);
894 read_acpi_int(NULL, EEEPC_EC_FAN_LRPM, &low);
895 return (high << 8 | low);
896 }
897
898 static int eeepc_get_fan_ctrl(void)
899 {
900 int value = 0;
901
902 read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
903 return ((value & 0x02 ? 1 : 0));
904 }
905
906 static void eeepc_set_fan_ctrl(int manual)
907 {
908 int value = 0;
909
910 read_acpi_int(NULL, EEEPC_EC_FAN_CTRL, &value);
911 if (manual)
912 value |= 0x02;
913 else
914 value &= ~0x02;
915 ec_write(EEEPC_EC_SFB3, value);
916 }
917
918 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
919 {
920 int rv, value;
921
922 rv = parse_arg(buf, count, &value);
923 if (rv > 0)
924 set(value);
925 return rv;
926 }
927
928 static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
929 {
930 return sprintf(buf, "%d\n", get());
931 }
932
933 #define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get) \
934 static ssize_t show_##_name(struct device *dev, \
935 struct device_attribute *attr, \
936 char *buf) \
937 { \
938 return show_sys_hwmon(_set, buf); \
939 } \
940 static ssize_t store_##_name(struct device *dev, \
941 struct device_attribute *attr, \
942 const char *buf, size_t count) \
943 { \
944 return store_sys_hwmon(_get, buf, count); \
945 } \
946 static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0);
947
948 EEEPC_CREATE_SENSOR_ATTR(fan1_input, S_IRUGO, eeepc_get_fan_rpm, NULL);
949 EEEPC_CREATE_SENSOR_ATTR(pwm1, S_IRUGO | S_IWUSR,
950 eeepc_get_fan_pwm, eeepc_set_fan_pwm);
951 EEEPC_CREATE_SENSOR_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
952 eeepc_get_fan_ctrl, eeepc_set_fan_ctrl);
953
954 static ssize_t
955 show_name(struct device *dev, struct device_attribute *attr, char *buf)
956 {
957 return sprintf(buf, "eeepc\n");
958 }
959 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
960
961 static struct attribute *hwmon_attributes[] = {
962 &sensor_dev_attr_pwm1.dev_attr.attr,
963 &sensor_dev_attr_fan1_input.dev_attr.attr,
964 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
965 &sensor_dev_attr_name.dev_attr.attr,
966 NULL
967 };
968
969 static struct attribute_group hwmon_attribute_group = {
970 .attrs = hwmon_attributes
971 };
972
973 /*
974 * exit/init
975 */
976 static void eeepc_backlight_exit(void)
977 {
978 if (eeepc_backlight_device)
979 backlight_device_unregister(eeepc_backlight_device);
980 eeepc_backlight_device = NULL;
981 }
982
983 static void eeepc_rfkill_exit(void)
984 {
985 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P5");
986 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P6");
987 eeepc_unregister_rfkill_notifier("\\_SB.PCI0.P0P7");
988 if (ehotk->wlan_rfkill) {
989 rfkill_unregister(ehotk->wlan_rfkill);
990 rfkill_destroy(ehotk->wlan_rfkill);
991 ehotk->wlan_rfkill = NULL;
992 }
993 /*
994 * Refresh pci hotplug in case the rfkill state was changed after
995 * eeepc_unregister_rfkill_notifier()
996 */
997 eeepc_rfkill_hotplug();
998 if (ehotk->hotplug_slot)
999 pci_hp_deregister(ehotk->hotplug_slot);
1000
1001 if (ehotk->bluetooth_rfkill) {
1002 rfkill_unregister(ehotk->bluetooth_rfkill);
1003 rfkill_destroy(ehotk->bluetooth_rfkill);
1004 ehotk->bluetooth_rfkill = NULL;
1005 }
1006 if (ehotk->wwan3g_rfkill) {
1007 rfkill_unregister(ehotk->wwan3g_rfkill);
1008 rfkill_destroy(ehotk->wwan3g_rfkill);
1009 ehotk->wwan3g_rfkill = NULL;
1010 }
1011 if (ehotk->wimax_rfkill) {
1012 rfkill_unregister(ehotk->wimax_rfkill);
1013 rfkill_destroy(ehotk->wimax_rfkill);
1014 ehotk->wimax_rfkill = NULL;
1015 }
1016 }
1017
1018 static void eeepc_input_exit(void)
1019 {
1020 if (ehotk->inputdev)
1021 input_unregister_device(ehotk->inputdev);
1022 }
1023
1024 static void eeepc_hwmon_exit(void)
1025 {
1026 struct device *hwmon;
1027
1028 hwmon = eeepc_hwmon_device;
1029 if (!hwmon)
1030 return ;
1031 sysfs_remove_group(&hwmon->kobj,
1032 &hwmon_attribute_group);
1033 hwmon_device_unregister(hwmon);
1034 eeepc_hwmon_device = NULL;
1035 }
1036
1037 static int eeepc_new_rfkill(struct rfkill **rfkill,
1038 const char *name, struct device *dev,
1039 enum rfkill_type type, int cm)
1040 {
1041 int result;
1042
1043 result = get_acpi(cm);
1044 if (result < 0)
1045 return result;
1046
1047 *rfkill = rfkill_alloc(name, dev, type,
1048 &eeepc_rfkill_ops, (void *)(unsigned long)cm);
1049
1050 if (!*rfkill)
1051 return -EINVAL;
1052
1053 rfkill_init_sw_state(*rfkill, get_acpi(cm) != 1);
1054 result = rfkill_register(*rfkill);
1055 if (result) {
1056 rfkill_destroy(*rfkill);
1057 *rfkill = NULL;
1058 return result;
1059 }
1060 return 0;
1061 }
1062
1063
1064 static int eeepc_rfkill_init(struct device *dev)
1065 {
1066 int result = 0;
1067
1068 mutex_init(&ehotk->hotplug_lock);
1069
1070 result = eeepc_new_rfkill(&ehotk->wlan_rfkill,
1071 "eeepc-wlan", dev,
1072 RFKILL_TYPE_WLAN, CM_ASL_WLAN);
1073
1074 if (result && result != -ENODEV)
1075 goto exit;
1076
1077 result = eeepc_new_rfkill(&ehotk->bluetooth_rfkill,
1078 "eeepc-bluetooth", dev,
1079 RFKILL_TYPE_BLUETOOTH, CM_ASL_BLUETOOTH);
1080
1081 if (result && result != -ENODEV)
1082 goto exit;
1083
1084 result = eeepc_new_rfkill(&ehotk->wwan3g_rfkill,
1085 "eeepc-wwan3g", dev,
1086 RFKILL_TYPE_WWAN, CM_ASL_3G);
1087
1088 if (result && result != -ENODEV)
1089 goto exit;
1090
1091 result = eeepc_new_rfkill(&ehotk->wimax_rfkill,
1092 "eeepc-wimax", dev,
1093 RFKILL_TYPE_WIMAX, CM_ASL_WIMAX);
1094
1095 if (result && result != -ENODEV)
1096 goto exit;
1097
1098 result = eeepc_setup_pci_hotplug();
1099 /*
1100 * If we get -EBUSY then something else is handling the PCI hotplug -
1101 * don't fail in this case
1102 */
1103 if (result == -EBUSY)
1104 result = 0;
1105
1106 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P5");
1107 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P6");
1108 eeepc_register_rfkill_notifier("\\_SB.PCI0.P0P7");
1109 /*
1110 * Refresh pci hotplug in case the rfkill state was changed during
1111 * setup.
1112 */
1113 eeepc_rfkill_hotplug();
1114
1115 exit:
1116 if (result && result != -ENODEV)
1117 eeepc_rfkill_exit();
1118 return result;
1119 }
1120
1121 static int eeepc_backlight_init(struct device *dev)
1122 {
1123 struct backlight_device *bd;
1124
1125 bd = backlight_device_register(EEEPC_HOTK_FILE, dev,
1126 NULL, &eeepcbl_ops);
1127 if (IS_ERR(bd)) {
1128 pr_err("Could not register eeepc backlight device\n");
1129 eeepc_backlight_device = NULL;
1130 return PTR_ERR(bd);
1131 }
1132 eeepc_backlight_device = bd;
1133 bd->props.max_brightness = 15;
1134 bd->props.brightness = read_brightness(NULL);
1135 bd->props.power = FB_BLANK_UNBLANK;
1136 backlight_update_status(bd);
1137 return 0;
1138 }
1139
1140 static int eeepc_hwmon_init(struct device *dev)
1141 {
1142 struct device *hwmon;
1143 int result;
1144
1145 hwmon = hwmon_device_register(dev);
1146 if (IS_ERR(hwmon)) {
1147 pr_err("Could not register eeepc hwmon device\n");
1148 eeepc_hwmon_device = NULL;
1149 return PTR_ERR(hwmon);
1150 }
1151 eeepc_hwmon_device = hwmon;
1152 result = sysfs_create_group(&hwmon->kobj,
1153 &hwmon_attribute_group);
1154 if (result)
1155 eeepc_hwmon_exit();
1156 return result;
1157 }
1158
1159 static int eeepc_input_init(struct device *dev)
1160 {
1161 const struct key_entry *key;
1162 int result;
1163
1164 ehotk->inputdev = input_allocate_device();
1165 if (!ehotk->inputdev) {
1166 pr_info("Unable to allocate input device\n");
1167 return -ENOMEM;
1168 }
1169 ehotk->inputdev->name = "Asus EeePC extra buttons";
1170 ehotk->inputdev->dev.parent = dev;
1171 ehotk->inputdev->phys = EEEPC_HOTK_FILE "/input0";
1172 ehotk->inputdev->id.bustype = BUS_HOST;
1173 ehotk->inputdev->getkeycode = eeepc_getkeycode;
1174 ehotk->inputdev->setkeycode = eeepc_setkeycode;
1175
1176 for (key = eeepc_keymap; key->type != KE_END; key++) {
1177 switch (key->type) {
1178 case KE_KEY:
1179 set_bit(EV_KEY, ehotk->inputdev->evbit);
1180 set_bit(key->keycode, ehotk->inputdev->keybit);
1181 break;
1182 }
1183 }
1184 result = input_register_device(ehotk->inputdev);
1185 if (result) {
1186 pr_info("Unable to register input device\n");
1187 input_free_device(ehotk->inputdev);
1188 return result;
1189 }
1190 return 0;
1191 }
1192
1193 static int __devinit eeepc_hotk_add(struct acpi_device *device)
1194 {
1195 struct device *dev;
1196 int result;
1197
1198 if (!device)
1199 return -EINVAL;
1200 pr_notice(EEEPC_HOTK_NAME "\n");
1201 ehotk = kzalloc(sizeof(struct eeepc_hotk), GFP_KERNEL);
1202 if (!ehotk)
1203 return -ENOMEM;
1204 ehotk->init_flag = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
1205 ehotk->handle = device->handle;
1206 strcpy(acpi_device_name(device), EEEPC_HOTK_DEVICE_NAME);
1207 strcpy(acpi_device_class(device), EEEPC_HOTK_CLASS);
1208 device->driver_data = ehotk;
1209 ehotk->device = device;
1210
1211 result = eeepc_hotk_check();
1212 if (result)
1213 goto fail_platform_driver;
1214 eeepc_enable_camera();
1215
1216 /* Register platform stuff */
1217 result = platform_driver_register(&platform_driver);
1218 if (result)
1219 goto fail_platform_driver;
1220 platform_device = platform_device_alloc(EEEPC_HOTK_FILE, -1);
1221 if (!platform_device) {
1222 result = -ENOMEM;
1223 goto fail_platform_device1;
1224 }
1225 result = platform_device_add(platform_device);
1226 if (result)
1227 goto fail_platform_device2;
1228 result = sysfs_create_group(&platform_device->dev.kobj,
1229 &platform_attribute_group);
1230 if (result)
1231 goto fail_sysfs;
1232
1233 dev = &platform_device->dev;
1234
1235 if (!acpi_video_backlight_support()) {
1236 result = eeepc_backlight_init(dev);
1237 if (result)
1238 goto fail_backlight;
1239 } else
1240 pr_info("Backlight controlled by ACPI video "
1241 "driver\n");
1242
1243 result = eeepc_input_init(dev);
1244 if (result)
1245 goto fail_input;
1246
1247 result = eeepc_hwmon_init(dev);
1248 if (result)
1249 goto fail_hwmon;
1250
1251 result = eeepc_rfkill_init(dev);
1252 if (result)
1253 goto fail_rfkill;
1254
1255 return 0;
1256
1257 fail_rfkill:
1258 eeepc_hwmon_exit();
1259 fail_hwmon:
1260 eeepc_input_exit();
1261 fail_input:
1262 eeepc_backlight_exit();
1263 fail_backlight:
1264 sysfs_remove_group(&platform_device->dev.kobj,
1265 &platform_attribute_group);
1266 fail_sysfs:
1267 platform_device_del(platform_device);
1268 fail_platform_device2:
1269 platform_device_put(platform_device);
1270 fail_platform_device1:
1271 platform_driver_unregister(&platform_driver);
1272 fail_platform_driver:
1273 kfree(ehotk);
1274
1275 return result;
1276 }
1277
1278 static int eeepc_hotk_remove(struct acpi_device *device, int type)
1279 {
1280 if (!device || !acpi_driver_data(device))
1281 return -EINVAL;
1282
1283 eeepc_backlight_exit();
1284 eeepc_rfkill_exit();
1285 eeepc_input_exit();
1286 eeepc_hwmon_exit();
1287 sysfs_remove_group(&platform_device->dev.kobj,
1288 &platform_attribute_group);
1289 platform_device_unregister(platform_device);
1290 platform_driver_unregister(&platform_driver);
1291
1292 kfree(ehotk);
1293 return 0;
1294 }
1295
1296 static int __init eeepc_laptop_init(void)
1297 {
1298 int result;
1299
1300 if (acpi_disabled)
1301 return -ENODEV;
1302 result = acpi_bus_register_driver(&eeepc_hotk_driver);
1303 if (result < 0)
1304 return result;
1305 if (!ehotk) {
1306 acpi_bus_unregister_driver(&eeepc_hotk_driver);
1307 return -ENODEV;
1308 }
1309 return 0;
1310 }
1311
1312 static void __exit eeepc_laptop_exit(void)
1313 {
1314 acpi_bus_unregister_driver(&eeepc_hotk_driver);
1315 }
1316
1317 module_init(eeepc_laptop_init);
1318 module_exit(eeepc_laptop_exit);
Linux with added FPC-III support