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