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