?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / platform / x86 / eeepc-laptop.c
blob2cc4eff7258f5cfb151c824ac50898095de96edb
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, 0444);
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 wlan = get_acpi(eeepc, CM_ASL_WLAN);
903 set_acpi(eeepc, CM_ASL_WLAN, wlan);
904 }
905
906 return 0;
907 }
908
909 static int eeepc_hotk_restore(struct device *device)
910 {
911 struct eeepc_laptop *eeepc = dev_get_drvdata(device);
912
913 /* Refresh both wlan rfkill state and pci hotplug */
914 if (eeepc->wlan_rfkill)
915 eeepc_rfkill_hotplug(eeepc);
916
917 if (eeepc->bluetooth_rfkill)
918 rfkill_set_sw_state(eeepc->bluetooth_rfkill,
919 get_acpi(eeepc, CM_ASL_BLUETOOTH) != 1);
920 if (eeepc->wwan3g_rfkill)
921 rfkill_set_sw_state(eeepc->wwan3g_rfkill,
922 get_acpi(eeepc, CM_ASL_3G) != 1);
923 if (eeepc->wimax_rfkill)
924 rfkill_set_sw_state(eeepc->wimax_rfkill,
925 get_acpi(eeepc, 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 .owner = THIS_MODULE,
939 .pm = &eeepc_pm_ops,
940 }
941 };
942
943 /*
944 * Hwmon device
945 */
946
947 #define EEEPC_EC_SC00 0x61
948 #define EEEPC_EC_FAN_PWM (EEEPC_EC_SC00 + 2) /* Fan PWM duty cycle (%) */
949 #define EEEPC_EC_FAN_HRPM (EEEPC_EC_SC00 + 5) /* High byte, fan speed (RPM) */
950 #define EEEPC_EC_FAN_LRPM (EEEPC_EC_SC00 + 6) /* Low byte, fan speed (RPM) */
951
952 #define EEEPC_EC_SFB0 0xD0
953 #define EEEPC_EC_FAN_CTRL (EEEPC_EC_SFB0 + 3) /* Byte containing SF25 */
954
955 static int eeepc_get_fan_pwm(void)
956 {
957 u8 value = 0;
958
959 ec_read(EEEPC_EC_FAN_PWM, &value);
960 return value * 255 / 100;
961 }
962
963 static void eeepc_set_fan_pwm(int value)
964 {
965 value = SENSORS_LIMIT(value, 0, 255);
966 value = value * 100 / 255;
967 ec_write(EEEPC_EC_FAN_PWM, value);
968 }
969
970 static int eeepc_get_fan_rpm(void)
971 {
972 u8 high = 0;
973 u8 low = 0;
974
975 ec_read(EEEPC_EC_FAN_HRPM, &high);
976 ec_read(EEEPC_EC_FAN_LRPM, &low);
977 return high << 8 | low;
978 }
979
980 static int eeepc_get_fan_ctrl(void)
981 {
982 u8 value = 0;
983
984 ec_read(EEEPC_EC_FAN_CTRL, &value);
985 if (value & 0x02)
986 return 1; /* manual */
987 else
988 return 2; /* automatic */
989 }
990
991 static void eeepc_set_fan_ctrl(int manual)
992 {
993 u8 value = 0;
994
995 ec_read(EEEPC_EC_FAN_CTRL, &value);
996 if (manual == 1)
997 value |= 0x02;
998 else
999 value &= ~0x02;
1000 ec_write(EEEPC_EC_FAN_CTRL, value);
1001 }
1002
1003 static ssize_t store_sys_hwmon(void (*set)(int), const char *buf, size_t count)
1004 {
1005 int rv, value;
1006
1007 rv = parse_arg(buf, count, &value);
1008 if (rv > 0)
1009 set(value);
1010 return rv;
1011 }
1012
1013 static ssize_t show_sys_hwmon(int (*get)(void), char *buf)
1014 {
1015 return sprintf(buf, "%d\n", get());
1016 }
1017
1018 #define EEEPC_CREATE_SENSOR_ATTR(_name, _mode, _set, _get) \
1019 static ssize_t show_##_name(struct device *dev, \
1020 struct device_attribute *attr, \
1021 char *buf) \
1022 { \
1023 return show_sys_hwmon(_set, buf); \
1024 } \
1025 static ssize_t store_##_name(struct device *dev, \
1026 struct device_attribute *attr, \
1027 const char *buf, size_t count) \
1028 { \
1029 return store_sys_hwmon(_get, buf, count); \
1030 } \
1031 static SENSOR_DEVICE_ATTR(_name, _mode, show_##_name, store_##_name, 0);
1032
1033 EEEPC_CREATE_SENSOR_ATTR(fan1_input, S_IRUGO, eeepc_get_fan_rpm, NULL);
1034 EEEPC_CREATE_SENSOR_ATTR(pwm1, S_IRUGO | S_IWUSR,
1035 eeepc_get_fan_pwm, eeepc_set_fan_pwm);
1036 EEEPC_CREATE_SENSOR_ATTR(pwm1_enable, S_IRUGO | S_IWUSR,
1037 eeepc_get_fan_ctrl, eeepc_set_fan_ctrl);
1038
1039 static ssize_t
1040 show_name(struct device *dev, struct device_attribute *attr, char *buf)
1041 {
1042 return sprintf(buf, "eeepc\n");
1043 }
1044 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
1045
1046 static struct attribute *hwmon_attributes[] = {
1047 &sensor_dev_attr_pwm1.dev_attr.attr,
1048 &sensor_dev_attr_fan1_input.dev_attr.attr,
1049 &sensor_dev_attr_pwm1_enable.dev_attr.attr,
1050 &sensor_dev_attr_name.dev_attr.attr,
1051 NULL
1052 };
1053
1054 static struct attribute_group hwmon_attribute_group = {
1055 .attrs = hwmon_attributes
1056 };
1057
1058 static void eeepc_hwmon_exit(struct eeepc_laptop *eeepc)
1059 {
1060 struct device *hwmon;
1061
1062 hwmon = eeepc->hwmon_device;
1063 if (!hwmon)
1064 return;
1065 sysfs_remove_group(&hwmon->kobj,
1066 &hwmon_attribute_group);
1067 hwmon_device_unregister(hwmon);
1068 eeepc->hwmon_device = NULL;
1069 }
1070
1071 static int eeepc_hwmon_init(struct eeepc_laptop *eeepc)
1072 {
1073 struct device *hwmon;
1074 int result;
1075
1076 hwmon = hwmon_device_register(&eeepc->platform_device->dev);
1077 if (IS_ERR(hwmon)) {
1078 pr_err("Could not register eeepc hwmon device\n");
1079 eeepc->hwmon_device = NULL;
1080 return PTR_ERR(hwmon);
1081 }
1082 eeepc->hwmon_device = hwmon;
1083 result = sysfs_create_group(&hwmon->kobj,
1084 &hwmon_attribute_group);
1085 if (result)
1086 eeepc_hwmon_exit(eeepc);
1087 return result;
1088 }
1089
1090 /*
1091 * Backlight device
1092 */
1093 static int read_brightness(struct backlight_device *bd)
1094 {
1095 struct eeepc_laptop *eeepc = bl_get_data(bd);
1096
1097 return get_acpi(eeepc, CM_ASL_PANELBRIGHT);
1098 }
1099
1100 static int set_brightness(struct backlight_device *bd, int value)
1101 {
1102 struct eeepc_laptop *eeepc = bl_get_data(bd);
1103
1104 return set_acpi(eeepc, CM_ASL_PANELBRIGHT, value);
1105 }
1106
1107 static int update_bl_status(struct backlight_device *bd)
1108 {
1109 return set_brightness(bd, bd->props.brightness);
1110 }
1111
1112 static struct backlight_ops eeepcbl_ops = {
1113 .get_brightness = read_brightness,
1114 .update_status = update_bl_status,
1115 };
1116
1117 static int eeepc_backlight_notify(struct eeepc_laptop *eeepc)
1118 {
1119 struct backlight_device *bd = eeepc->backlight_device;
1120 int old = bd->props.brightness;
1121
1122 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1123
1124 return old;
1125 }
1126
1127 static int eeepc_backlight_init(struct eeepc_laptop *eeepc)
1128 {
1129 struct backlight_properties props;
1130 struct backlight_device *bd;
1131
1132 memset(&props, 0, sizeof(struct backlight_properties));
1133 props.max_brightness = 15;
1134 bd = backlight_device_register(EEEPC_LAPTOP_FILE,
1135 &eeepc->platform_device->dev, eeepc,
1136 &eeepcbl_ops, &props);
1137 if (IS_ERR(bd)) {
1138 pr_err("Could not register eeepc backlight device\n");
1139 eeepc->backlight_device = NULL;
1140 return PTR_ERR(bd);
1141 }
1142 eeepc->backlight_device = bd;
1143 bd->props.brightness = read_brightness(bd);
1144 bd->props.power = FB_BLANK_UNBLANK;
1145 backlight_update_status(bd);
1146 return 0;
1147 }
1148
1149 static void eeepc_backlight_exit(struct eeepc_laptop *eeepc)
1150 {
1151 if (eeepc->backlight_device)
1152 backlight_device_unregister(eeepc->backlight_device);
1153 eeepc->backlight_device = NULL;
1154 }
1155
1156
1157 /*
1158 * Input device (i.e. hotkeys)
1159 */
1160 static int eeepc_input_init(struct eeepc_laptop *eeepc)
1161 {
1162 struct input_dev *input;
1163 int error;
1164
1165 input = input_allocate_device();
1166 if (!input) {
1167 pr_info("Unable to allocate input device\n");
1168 return -ENOMEM;
1169 }
1170
1171 input->name = "Asus EeePC extra buttons";
1172 input->phys = EEEPC_LAPTOP_FILE "/input0";
1173 input->id.bustype = BUS_HOST;
1174 input->dev.parent = &eeepc->platform_device->dev;
1175
1176 error = sparse_keymap_setup(input, eeepc_keymap, NULL);
1177 if (error) {
1178 pr_err("Unable to setup input device keymap\n");
1179 goto err_free_dev;
1180 }
1181
1182 error = input_register_device(input);
1183 if (error) {
1184 pr_err("Unable to register input device\n");
1185 goto err_free_keymap;
1186 }
1187
1188 eeepc->inputdev = input;
1189 return 0;
1190
1191 err_free_keymap:
1192 sparse_keymap_free(input);
1193 err_free_dev:
1194 input_free_device(input);
1195 return error;
1196 }
1197
1198 static void eeepc_input_exit(struct eeepc_laptop *eeepc)
1199 {
1200 if (eeepc->inputdev) {
1201 sparse_keymap_free(eeepc->inputdev);
1202 input_unregister_device(eeepc->inputdev);
1203 }
1204 }
1205
1206 /*
1207 * ACPI driver
1208 */
1209 static void eeepc_acpi_notify(struct acpi_device *device, u32 event)
1210 {
1211 struct eeepc_laptop *eeepc = acpi_driver_data(device);
1212 u16 count;
1213
1214 if (event > ACPI_MAX_SYS_NOTIFY)
1215 return;
1216 count = eeepc->event_count[event % 128]++;
1217 acpi_bus_generate_proc_event(device, event, count);
1218 acpi_bus_generate_netlink_event(device->pnp.device_class,
1219 dev_name(&device->dev), event,
1220 count);
1221
1222 /* Brightness events are special */
1223 if (event >= NOTIFY_BRN_MIN && event <= NOTIFY_BRN_MAX) {
1224
1225 /* Ignore them completely if the acpi video driver is used */
1226 if (eeepc->backlight_device != NULL) {
1227 int old_brightness, new_brightness;
1228
1229 /* Update the backlight device. */
1230 old_brightness = eeepc_backlight_notify(eeepc);
1231
1232 /* Convert event to keypress (obsolescent hack) */
1233 new_brightness = event - NOTIFY_BRN_MIN;
1234
1235 if (new_brightness < old_brightness) {
1236 event = NOTIFY_BRN_MIN; /* brightness down */
1237 } else if (new_brightness > old_brightness) {
1238 event = NOTIFY_BRN_MAX; /* brightness up */
1239 } else {
1240 /*
1241 * no change in brightness - already at min/max,
1242 * event will be desired value (or else ignored)
1243 */
1244 }
1245 sparse_keymap_report_event(eeepc->inputdev, event,
1246 1, true);
1247 }
1248 } else {
1249 /* Everything else is a bona-fide keypress event */
1250 sparse_keymap_report_event(eeepc->inputdev, event, 1, true);
1251 }
1252 }
1253
1254 static void eeepc_dmi_check(struct eeepc_laptop *eeepc)
1255 {
1256 const char *model;
1257
1258 model = dmi_get_system_info(DMI_PRODUCT_NAME);
1259 if (!model)
1260 return;
1261
1262 /*
1263 * Blacklist for setting cpufv (cpu speed).
1264 *
1265 * EeePC 4G ("701") implements CFVS, but it is not supported
1266 * by the pre-installed OS, and the original option to change it
1267 * in the BIOS setup screen was removed in later versions.
1268 *
1269 * Judging by the lack of "Super Hybrid Engine" on Asus product pages,
1270 * this applies to all "701" models (4G/4G Surf/2G Surf).
1271 *
1272 * So Asus made a deliberate decision not to support it on this model.
1273 * We have several reports that using it can cause the system to hang
1274 *
1275 * The hang has also been reported on a "702" (Model name "8G"?).
1276 *
1277 * We avoid dmi_check_system() / dmi_match(), because they use
1278 * substring matching. We don't want to affect the "701SD"
1279 * and "701SDX" models, because they do support S.H.E.
1280 */
1281 if (strcmp(model, "701") == 0 || strcmp(model, "702") == 0) {
1282 eeepc->cpufv_disabled = true;
1283 pr_info("model %s does not officially support setting cpu "
1284 "speed\n", model);
1285 pr_info("cpufv disabled to avoid instability\n");
1286 }
1287
1288 /*
1289 * Blacklist for wlan hotplug
1290 *
1291 * Eeepc 1005HA doesn't work like others models and don't need the
1292 * hotplug code. In fact, current hotplug code seems to unplug another
1293 * device...
1294 */
1295 if (strcmp(model, "1005HA") == 0 || strcmp(model, "1201N") == 0 ||
1296 strcmp(model, "1005PE") == 0) {
1297 eeepc->hotplug_disabled = true;
1298 pr_info("wlan hotplug disabled\n");
1299 }
1300 }
1301
1302 static void cmsg_quirk(struct eeepc_laptop *eeepc, int cm, const char *name)
1303 {
1304 int dummy;
1305
1306 /* Some BIOSes do not report cm although it is avaliable.
1307 Check if cm_getv[cm] works and, if yes, assume cm should be set. */
1308 if (!(eeepc->cm_supported & (1 << cm))
1309 && !read_acpi_int(eeepc->handle, cm_getv[cm], &dummy)) {
1310 pr_info("%s (%x) not reported by BIOS,"
1311 " enabling anyway\n", name, 1 << cm);
1312 eeepc->cm_supported |= 1 << cm;
1313 }
1314 }
1315
1316 static void cmsg_quirks(struct eeepc_laptop *eeepc)
1317 {
1318 cmsg_quirk(eeepc, CM_ASL_LID, "LID");
1319 cmsg_quirk(eeepc, CM_ASL_TYPE, "TYPE");
1320 cmsg_quirk(eeepc, CM_ASL_PANELPOWER, "PANELPOWER");
1321 cmsg_quirk(eeepc, CM_ASL_TPD, "TPD");
1322 }
1323
1324 static int eeepc_acpi_init(struct eeepc_laptop *eeepc,
1325 struct acpi_device *device)
1326 {
1327 unsigned int init_flags;
1328 int result;
1329
1330 result = acpi_bus_get_status(device);
1331 if (result)
1332 return result;
1333 if (!device->status.present) {
1334 pr_err("Hotkey device not present, aborting\n");
1335 return -ENODEV;
1336 }
1337
1338 init_flags = DISABLE_ASL_WLAN | DISABLE_ASL_DISPLAYSWITCH;
1339 pr_notice("Hotkey init flags 0x%x\n", init_flags);
1340
1341 if (write_acpi_int(eeepc->handle, "INIT", init_flags)) {
1342 pr_err("Hotkey initialization failed\n");
1343 return -ENODEV;
1344 }
1345
1346 /* get control methods supported */
1347 if (read_acpi_int(eeepc->handle, "CMSG", &eeepc->cm_supported)) {
1348 pr_err("Get control methods supported failed\n");
1349 return -ENODEV;
1350 }
1351 cmsg_quirks(eeepc);
1352 pr_info("Get control methods supported: 0x%x\n", eeepc->cm_supported);
1353
1354 return 0;
1355 }
1356
1357 static void __devinit eeepc_enable_camera(struct eeepc_laptop *eeepc)
1358 {
1359 /*
1360 * If the following call to set_acpi() fails, it's because there's no
1361 * camera so we can ignore the error.
1362 */
1363 if (get_acpi(eeepc, CM_ASL_CAMERA) == 0)
1364 set_acpi(eeepc, CM_ASL_CAMERA, 1);
1365 }
1366
1367 static bool eeepc_device_present;
1368
1369 static int __devinit eeepc_acpi_add(struct acpi_device *device)
1370 {
1371 struct eeepc_laptop *eeepc;
1372 int result;
1373
1374 pr_notice(EEEPC_LAPTOP_NAME "\n");
1375 eeepc = kzalloc(sizeof(struct eeepc_laptop), GFP_KERNEL);
1376 if (!eeepc)
1377 return -ENOMEM;
1378 eeepc->handle = device->handle;
1379 strcpy(acpi_device_name(device), EEEPC_ACPI_DEVICE_NAME);
1380 strcpy(acpi_device_class(device), EEEPC_ACPI_CLASS);
1381 device->driver_data = eeepc;
1382
1383 eeepc->hotplug_disabled = hotplug_disabled;
1384
1385 eeepc_dmi_check(eeepc);
1386
1387 result = eeepc_acpi_init(eeepc, device);
1388 if (result)
1389 goto fail_platform;
1390 eeepc_enable_camera(eeepc);
1391
1392 /*
1393 * Register the platform device first. It is used as a parent for the
1394 * sub-devices below.
1395 *
1396 * Note that if there are multiple instances of this ACPI device it
1397 * will bail out, because the platform device is registered with a
1398 * fixed name. Of course it doesn't make sense to have more than one,
1399 * and machine-specific scripts find the fixed name convenient. But
1400 * It's also good for us to exclude multiple instances because both
1401 * our hwmon and our wlan rfkill subdevice use global ACPI objects
1402 * (the EC and the wlan PCI slot respectively).
1403 */
1404 result = eeepc_platform_init(eeepc);
1405 if (result)
1406 goto fail_platform;
1407
1408 if (!acpi_video_backlight_support()) {
1409 result = eeepc_backlight_init(eeepc);
1410 if (result)
1411 goto fail_backlight;
1412 } else
1413 pr_info("Backlight controlled by ACPI video driver\n");
1414
1415 result = eeepc_input_init(eeepc);
1416 if (result)
1417 goto fail_input;
1418
1419 result = eeepc_hwmon_init(eeepc);
1420 if (result)
1421 goto fail_hwmon;
1422
1423 result = eeepc_led_init(eeepc);
1424 if (result)
1425 goto fail_led;
1426
1427 result = eeepc_rfkill_init(eeepc);
1428 if (result)
1429 goto fail_rfkill;
1430
1431 eeepc_device_present = true;
1432 return 0;
1433
1434 fail_rfkill:
1435 eeepc_led_exit(eeepc);
1436 fail_led:
1437 eeepc_hwmon_exit(eeepc);
1438 fail_hwmon:
1439 eeepc_input_exit(eeepc);
1440 fail_input:
1441 eeepc_backlight_exit(eeepc);
1442 fail_backlight:
1443 eeepc_platform_exit(eeepc);
1444 fail_platform:
1445 kfree(eeepc);
1446
1447 return result;
1448 }
1449
1450 static int eeepc_acpi_remove(struct acpi_device *device, int type)
1451 {
1452 struct eeepc_laptop *eeepc = acpi_driver_data(device);
1453
1454 eeepc_backlight_exit(eeepc);
1455 eeepc_rfkill_exit(eeepc);
1456 eeepc_input_exit(eeepc);
1457 eeepc_hwmon_exit(eeepc);
1458 eeepc_led_exit(eeepc);
1459 eeepc_platform_exit(eeepc);
1460
1461 kfree(eeepc);
1462 return 0;
1463 }
1464
1465
1466 static const struct acpi_device_id eeepc_device_ids[] = {
1467 {EEEPC_ACPI_HID, 0},
1468 {"", 0},
1469 };
1470 MODULE_DEVICE_TABLE(acpi, eeepc_device_ids);
1471
1472 static struct acpi_driver eeepc_acpi_driver = {
1473 .name = EEEPC_LAPTOP_NAME,
1474 .class = EEEPC_ACPI_CLASS,
1475 .owner = THIS_MODULE,
1476 .ids = eeepc_device_ids,
1477 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1478 .ops = {
1479 .add = eeepc_acpi_add,
1480 .remove = eeepc_acpi_remove,
1481 .notify = eeepc_acpi_notify,
1482 },
1483 };
1484
1485
1486 static int __init eeepc_laptop_init(void)
1487 {
1488 int result;
1489
1490 result = platform_driver_register(&platform_driver);
1491 if (result < 0)
1492 return result;
1493
1494 result = acpi_bus_register_driver(&eeepc_acpi_driver);
1495 if (result < 0)
1496 goto fail_acpi_driver;
1497
1498 if (!eeepc_device_present) {
1499 result = -ENODEV;
1500 goto fail_no_device;
1501 }
1502
1503 return 0;
1504
1505 fail_no_device:
1506 acpi_bus_unregister_driver(&eeepc_acpi_driver);
1507 fail_acpi_driver:
1508 platform_driver_unregister(&platform_driver);
1509 return result;
1510 }
1511
1512 static void __exit eeepc_laptop_exit(void)
1513 {
1514 acpi_bus_unregister_driver(&eeepc_acpi_driver);
1515 platform_driver_unregister(&platform_driver);
1516 }
1517
1518 module_init(eeepc_laptop_init);
1519 module_exit(eeepc_laptop_exit);
Tomato firmware and modifications.