1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/init.h>
21#include <linux/module.h>
22#include <linux/slab.h>
23#include <linux/workqueue.h>
24#include <acpi/acpi_drivers.h>
25#include <linux/backlight.h>
26#include <linux/input.h>
27#include <linux/rfkill.h>
28
29MODULE_LICENSE("GPL");
30
31
32struct cmpc_accel {
33 int sensitivity;
34 int g_select;
35 int inputdev_state;
36};
37
38#define CMPC_ACCEL_DEV_STATE_CLOSED 0
39#define CMPC_ACCEL_DEV_STATE_OPEN 1
40
41#define CMPC_ACCEL_SENSITIVITY_DEFAULT 5
42#define CMPC_ACCEL_G_SELECT_DEFAULT 0
43
44#define CMPC_ACCEL_HID "ACCE0000"
45#define CMPC_ACCEL_HID_V4 "ACCE0001"
46#define CMPC_TABLET_HID "TBLT0000"
47#define CMPC_IPML_HID "IPML200"
48#define CMPC_KEYS_HID "FNBT0000"
49
50
51
52
53
54typedef void (*input_device_init)(struct input_dev *dev);
55
56static int cmpc_add_acpi_notify_device(struct acpi_device *acpi, char *name,
57 input_device_init idev_init)
58{
59 struct input_dev *inputdev;
60 int error;
61
62 inputdev = input_allocate_device();
63 if (!inputdev)
64 return -ENOMEM;
65 inputdev->name = name;
66 inputdev->dev.parent = &acpi->dev;
67 idev_init(inputdev);
68 error = input_register_device(inputdev);
69 if (error) {
70 input_free_device(inputdev);
71 return error;
72 }
73 dev_set_drvdata(&acpi->dev, inputdev);
74 return 0;
75}
76
77static int cmpc_remove_acpi_notify_device(struct acpi_device *acpi)
78{
79 struct input_dev *inputdev = dev_get_drvdata(&acpi->dev);
80 input_unregister_device(inputdev);
81 return 0;
82}
83
84
85
86
87static acpi_status cmpc_start_accel_v4(acpi_handle handle)
88{
89 union acpi_object param[4];
90 struct acpi_object_list input;
91 acpi_status status;
92
93 param[0].type = ACPI_TYPE_INTEGER;
94 param[0].integer.value = 0x3;
95 param[1].type = ACPI_TYPE_INTEGER;
96 param[1].integer.value = 0;
97 param[2].type = ACPI_TYPE_INTEGER;
98 param[2].integer.value = 0;
99 param[3].type = ACPI_TYPE_INTEGER;
100 param[3].integer.value = 0;
101 input.count = 4;
102 input.pointer = param;
103 status = acpi_evaluate_object(handle, "ACMD", &input, NULL);
104 return status;
105}
106
107static acpi_status cmpc_stop_accel_v4(acpi_handle handle)
108{
109 union acpi_object param[4];
110 struct acpi_object_list input;
111 acpi_status status;
112
113 param[0].type = ACPI_TYPE_INTEGER;
114 param[0].integer.value = 0x4;
115 param[1].type = ACPI_TYPE_INTEGER;
116 param[1].integer.value = 0;
117 param[2].type = ACPI_TYPE_INTEGER;
118 param[2].integer.value = 0;
119 param[3].type = ACPI_TYPE_INTEGER;
120 param[3].integer.value = 0;
121 input.count = 4;
122 input.pointer = param;
123 status = acpi_evaluate_object(handle, "ACMD", &input, NULL);
124 return status;
125}
126
127static acpi_status cmpc_accel_set_sensitivity_v4(acpi_handle handle, int val)
128{
129 union acpi_object param[4];
130 struct acpi_object_list input;
131
132 param[0].type = ACPI_TYPE_INTEGER;
133 param[0].integer.value = 0x02;
134 param[1].type = ACPI_TYPE_INTEGER;
135 param[1].integer.value = val;
136 param[2].type = ACPI_TYPE_INTEGER;
137 param[2].integer.value = 0;
138 param[3].type = ACPI_TYPE_INTEGER;
139 param[3].integer.value = 0;
140 input.count = 4;
141 input.pointer = param;
142 return acpi_evaluate_object(handle, "ACMD", &input, NULL);
143}
144
145static acpi_status cmpc_accel_set_g_select_v4(acpi_handle handle, int val)
146{
147 union acpi_object param[4];
148 struct acpi_object_list input;
149
150 param[0].type = ACPI_TYPE_INTEGER;
151 param[0].integer.value = 0x05;
152 param[1].type = ACPI_TYPE_INTEGER;
153 param[1].integer.value = val;
154 param[2].type = ACPI_TYPE_INTEGER;
155 param[2].integer.value = 0;
156 param[3].type = ACPI_TYPE_INTEGER;
157 param[3].integer.value = 0;
158 input.count = 4;
159 input.pointer = param;
160 return acpi_evaluate_object(handle, "ACMD", &input, NULL);
161}
162
163static acpi_status cmpc_get_accel_v4(acpi_handle handle,
164 int16_t *x,
165 int16_t *y,
166 int16_t *z)
167{
168 union acpi_object param[4];
169 struct acpi_object_list input;
170 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
171 int16_t *locs;
172 acpi_status status;
173
174 param[0].type = ACPI_TYPE_INTEGER;
175 param[0].integer.value = 0x01;
176 param[1].type = ACPI_TYPE_INTEGER;
177 param[1].integer.value = 0;
178 param[2].type = ACPI_TYPE_INTEGER;
179 param[2].integer.value = 0;
180 param[3].type = ACPI_TYPE_INTEGER;
181 param[3].integer.value = 0;
182 input.count = 4;
183 input.pointer = param;
184 status = acpi_evaluate_object(handle, "ACMD", &input, &output);
185 if (ACPI_SUCCESS(status)) {
186 union acpi_object *obj;
187 obj = output.pointer;
188 locs = (int16_t *) obj->buffer.pointer;
189 *x = locs[0];
190 *y = locs[1];
191 *z = locs[2];
192 kfree(output.pointer);
193 }
194 return status;
195}
196
197static void cmpc_accel_handler_v4(struct acpi_device *dev, u32 event)
198{
199 if (event == 0x81) {
200 int16_t x, y, z;
201 acpi_status status;
202
203 status = cmpc_get_accel_v4(dev->handle, &x, &y, &z);
204 if (ACPI_SUCCESS(status)) {
205 struct input_dev *inputdev = dev_get_drvdata(&dev->dev);
206
207 input_report_abs(inputdev, ABS_X, x);
208 input_report_abs(inputdev, ABS_Y, y);
209 input_report_abs(inputdev, ABS_Z, z);
210 input_sync(inputdev);
211 }
212 }
213}
214
215static ssize_t cmpc_accel_sensitivity_show_v4(struct device *dev,
216 struct device_attribute *attr,
217 char *buf)
218{
219 struct acpi_device *acpi;
220 struct input_dev *inputdev;
221 struct cmpc_accel *accel;
222
223 acpi = to_acpi_device(dev);
224 inputdev = dev_get_drvdata(&acpi->dev);
225 accel = dev_get_drvdata(&inputdev->dev);
226
227 return sprintf(buf, "%d\n", accel->sensitivity);
228}
229
230static ssize_t cmpc_accel_sensitivity_store_v4(struct device *dev,
231 struct device_attribute *attr,
232 const char *buf, size_t count)
233{
234 struct acpi_device *acpi;
235 struct input_dev *inputdev;
236 struct cmpc_accel *accel;
237 unsigned long sensitivity;
238 int r;
239
240 acpi = to_acpi_device(dev);
241 inputdev = dev_get_drvdata(&acpi->dev);
242 accel = dev_get_drvdata(&inputdev->dev);
243
244 r = kstrtoul(buf, 0, &sensitivity);
245 if (r)
246 return r;
247
248
249 if (sensitivity < 1 || sensitivity > 127)
250 return -EINVAL;
251
252 accel->sensitivity = sensitivity;
253 cmpc_accel_set_sensitivity_v4(acpi->handle, sensitivity);
254
255 return strnlen(buf, count);
256}
257
258static struct device_attribute cmpc_accel_sensitivity_attr_v4 = {
259 .attr = { .name = "sensitivity", .mode = 0660 },
260 .show = cmpc_accel_sensitivity_show_v4,
261 .store = cmpc_accel_sensitivity_store_v4
262};
263
264static ssize_t cmpc_accel_g_select_show_v4(struct device *dev,
265 struct device_attribute *attr,
266 char *buf)
267{
268 struct acpi_device *acpi;
269 struct input_dev *inputdev;
270 struct cmpc_accel *accel;
271
272 acpi = to_acpi_device(dev);
273 inputdev = dev_get_drvdata(&acpi->dev);
274 accel = dev_get_drvdata(&inputdev->dev);
275
276 return sprintf(buf, "%d\n", accel->g_select);
277}
278
279static ssize_t cmpc_accel_g_select_store_v4(struct device *dev,
280 struct device_attribute *attr,
281 const char *buf, size_t count)
282{
283 struct acpi_device *acpi;
284 struct input_dev *inputdev;
285 struct cmpc_accel *accel;
286 unsigned long g_select;
287 int r;
288
289 acpi = to_acpi_device(dev);
290 inputdev = dev_get_drvdata(&acpi->dev);
291 accel = dev_get_drvdata(&inputdev->dev);
292
293 r = kstrtoul(buf, 0, &g_select);
294 if (r)
295 return r;
296
297
298 if (g_select != 0 && g_select != 1)
299 return -EINVAL;
300
301 accel->g_select = g_select;
302 cmpc_accel_set_g_select_v4(acpi->handle, g_select);
303
304 return strnlen(buf, count);
305}
306
307static struct device_attribute cmpc_accel_g_select_attr_v4 = {
308 .attr = { .name = "g_select", .mode = 0660 },
309 .show = cmpc_accel_g_select_show_v4,
310 .store = cmpc_accel_g_select_store_v4
311};
312
313static int cmpc_accel_open_v4(struct input_dev *input)
314{
315 struct acpi_device *acpi;
316 struct cmpc_accel *accel;
317
318 acpi = to_acpi_device(input->dev.parent);
319 accel = dev_get_drvdata(&input->dev);
320
321 cmpc_accel_set_sensitivity_v4(acpi->handle, accel->sensitivity);
322 cmpc_accel_set_g_select_v4(acpi->handle, accel->g_select);
323
324 if (ACPI_SUCCESS(cmpc_start_accel_v4(acpi->handle))) {
325 accel->inputdev_state = CMPC_ACCEL_DEV_STATE_OPEN;
326 return 0;
327 }
328 return -EIO;
329}
330
331static void cmpc_accel_close_v4(struct input_dev *input)
332{
333 struct acpi_device *acpi;
334 struct cmpc_accel *accel;
335
336 acpi = to_acpi_device(input->dev.parent);
337 accel = dev_get_drvdata(&input->dev);
338
339 cmpc_stop_accel_v4(acpi->handle);
340 accel->inputdev_state = CMPC_ACCEL_DEV_STATE_CLOSED;
341}
342
343static void cmpc_accel_idev_init_v4(struct input_dev *inputdev)
344{
345 set_bit(EV_ABS, inputdev->evbit);
346 input_set_abs_params(inputdev, ABS_X, -255, 255, 16, 0);
347 input_set_abs_params(inputdev, ABS_Y, -255, 255, 16, 0);
348 input_set_abs_params(inputdev, ABS_Z, -255, 255, 16, 0);
349 inputdev->open = cmpc_accel_open_v4;
350 inputdev->close = cmpc_accel_close_v4;
351}
352
353#ifdef CONFIG_PM_SLEEP
354static int cmpc_accel_suspend_v4(struct device *dev)
355{
356 struct input_dev *inputdev;
357 struct cmpc_accel *accel;
358
359 inputdev = dev_get_drvdata(dev);
360 accel = dev_get_drvdata(&inputdev->dev);
361
362 if (accel->inputdev_state == CMPC_ACCEL_DEV_STATE_OPEN)
363 return cmpc_stop_accel_v4(to_acpi_device(dev)->handle);
364
365 return 0;
366}
367
368static int cmpc_accel_resume_v4(struct device *dev)
369{
370 struct input_dev *inputdev;
371 struct cmpc_accel *accel;
372
373 inputdev = dev_get_drvdata(dev);
374 accel = dev_get_drvdata(&inputdev->dev);
375
376 if (accel->inputdev_state == CMPC_ACCEL_DEV_STATE_OPEN) {
377 cmpc_accel_set_sensitivity_v4(to_acpi_device(dev)->handle,
378 accel->sensitivity);
379 cmpc_accel_set_g_select_v4(to_acpi_device(dev)->handle,
380 accel->g_select);
381
382 if (ACPI_FAILURE(cmpc_start_accel_v4(to_acpi_device(dev)->handle)))
383 return -EIO;
384 }
385
386 return 0;
387}
388#endif
389
390static int cmpc_accel_add_v4(struct acpi_device *acpi)
391{
392 int error;
393 struct input_dev *inputdev;
394 struct cmpc_accel *accel;
395
396 accel = kmalloc(sizeof(*accel), GFP_KERNEL);
397 if (!accel)
398 return -ENOMEM;
399
400 accel->inputdev_state = CMPC_ACCEL_DEV_STATE_CLOSED;
401
402 accel->sensitivity = CMPC_ACCEL_SENSITIVITY_DEFAULT;
403 cmpc_accel_set_sensitivity_v4(acpi->handle, accel->sensitivity);
404
405 error = device_create_file(&acpi->dev, &cmpc_accel_sensitivity_attr_v4);
406 if (error)
407 goto failed_sensitivity;
408
409 accel->g_select = CMPC_ACCEL_G_SELECT_DEFAULT;
410 cmpc_accel_set_g_select_v4(acpi->handle, accel->g_select);
411
412 error = device_create_file(&acpi->dev, &cmpc_accel_g_select_attr_v4);
413 if (error)
414 goto failed_g_select;
415
416 error = cmpc_add_acpi_notify_device(acpi, "cmpc_accel_v4",
417 cmpc_accel_idev_init_v4);
418 if (error)
419 goto failed_input;
420
421 inputdev = dev_get_drvdata(&acpi->dev);
422 dev_set_drvdata(&inputdev->dev, accel);
423
424 return 0;
425
426failed_input:
427 device_remove_file(&acpi->dev, &cmpc_accel_g_select_attr_v4);
428failed_g_select:
429 device_remove_file(&acpi->dev, &cmpc_accel_sensitivity_attr_v4);
430failed_sensitivity:
431 kfree(accel);
432 return error;
433}
434
435static int cmpc_accel_remove_v4(struct acpi_device *acpi)
436{
437 struct input_dev *inputdev;
438 struct cmpc_accel *accel;
439
440 inputdev = dev_get_drvdata(&acpi->dev);
441 accel = dev_get_drvdata(&inputdev->dev);
442
443 device_remove_file(&acpi->dev, &cmpc_accel_sensitivity_attr_v4);
444 device_remove_file(&acpi->dev, &cmpc_accel_g_select_attr_v4);
445 return cmpc_remove_acpi_notify_device(acpi);
446}
447
448static SIMPLE_DEV_PM_OPS(cmpc_accel_pm, cmpc_accel_suspend_v4,
449 cmpc_accel_resume_v4);
450
451static const struct acpi_device_id cmpc_accel_device_ids_v4[] = {
452 {CMPC_ACCEL_HID_V4, 0},
453 {"", 0}
454};
455
456static struct acpi_driver cmpc_accel_acpi_driver_v4 = {
457 .owner = THIS_MODULE,
458 .name = "cmpc_accel_v4",
459 .class = "cmpc_accel_v4",
460 .ids = cmpc_accel_device_ids_v4,
461 .ops = {
462 .add = cmpc_accel_add_v4,
463 .remove = cmpc_accel_remove_v4,
464 .notify = cmpc_accel_handler_v4,
465 },
466 .drv.pm = &cmpc_accel_pm,
467};
468
469
470
471
472
473static acpi_status cmpc_start_accel(acpi_handle handle)
474{
475 union acpi_object param[2];
476 struct acpi_object_list input;
477 acpi_status status;
478
479 param[0].type = ACPI_TYPE_INTEGER;
480 param[0].integer.value = 0x3;
481 param[1].type = ACPI_TYPE_INTEGER;
482 input.count = 2;
483 input.pointer = param;
484 status = acpi_evaluate_object(handle, "ACMD", &input, NULL);
485 return status;
486}
487
488static acpi_status cmpc_stop_accel(acpi_handle handle)
489{
490 union acpi_object param[2];
491 struct acpi_object_list input;
492 acpi_status status;
493
494 param[0].type = ACPI_TYPE_INTEGER;
495 param[0].integer.value = 0x4;
496 param[1].type = ACPI_TYPE_INTEGER;
497 input.count = 2;
498 input.pointer = param;
499 status = acpi_evaluate_object(handle, "ACMD", &input, NULL);
500 return status;
501}
502
503static acpi_status cmpc_accel_set_sensitivity(acpi_handle handle, int val)
504{
505 union acpi_object param[2];
506 struct acpi_object_list input;
507
508 param[0].type = ACPI_TYPE_INTEGER;
509 param[0].integer.value = 0x02;
510 param[1].type = ACPI_TYPE_INTEGER;
511 param[1].integer.value = val;
512 input.count = 2;
513 input.pointer = param;
514 return acpi_evaluate_object(handle, "ACMD", &input, NULL);
515}
516
517static acpi_status cmpc_get_accel(acpi_handle handle,
518 unsigned char *x,
519 unsigned char *y,
520 unsigned char *z)
521{
522 union acpi_object param[2];
523 struct acpi_object_list input;
524 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, 0 };
525 unsigned char *locs;
526 acpi_status status;
527
528 param[0].type = ACPI_TYPE_INTEGER;
529 param[0].integer.value = 0x01;
530 param[1].type = ACPI_TYPE_INTEGER;
531 input.count = 2;
532 input.pointer = param;
533 status = acpi_evaluate_object(handle, "ACMD", &input, &output);
534 if (ACPI_SUCCESS(status)) {
535 union acpi_object *obj;
536 obj = output.pointer;
537 locs = obj->buffer.pointer;
538 *x = locs[0];
539 *y = locs[1];
540 *z = locs[2];
541 kfree(output.pointer);
542 }
543 return status;
544}
545
546static void cmpc_accel_handler(struct acpi_device *dev, u32 event)
547{
548 if (event == 0x81) {
549 unsigned char x, y, z;
550 acpi_status status;
551
552 status = cmpc_get_accel(dev->handle, &x, &y, &z);
553 if (ACPI_SUCCESS(status)) {
554 struct input_dev *inputdev = dev_get_drvdata(&dev->dev);
555
556 input_report_abs(inputdev, ABS_X, x);
557 input_report_abs(inputdev, ABS_Y, y);
558 input_report_abs(inputdev, ABS_Z, z);
559 input_sync(inputdev);
560 }
561 }
562}
563
564static ssize_t cmpc_accel_sensitivity_show(struct device *dev,
565 struct device_attribute *attr,
566 char *buf)
567{
568 struct acpi_device *acpi;
569 struct input_dev *inputdev;
570 struct cmpc_accel *accel;
571
572 acpi = to_acpi_device(dev);
573 inputdev = dev_get_drvdata(&acpi->dev);
574 accel = dev_get_drvdata(&inputdev->dev);
575
576 return sprintf(buf, "%d\n", accel->sensitivity);
577}
578
579static ssize_t cmpc_accel_sensitivity_store(struct device *dev,
580 struct device_attribute *attr,
581 const char *buf, size_t count)
582{
583 struct acpi_device *acpi;
584 struct input_dev *inputdev;
585 struct cmpc_accel *accel;
586 unsigned long sensitivity;
587 int r;
588
589 acpi = to_acpi_device(dev);
590 inputdev = dev_get_drvdata(&acpi->dev);
591 accel = dev_get_drvdata(&inputdev->dev);
592
593 r = kstrtoul(buf, 0, &sensitivity);
594 if (r)
595 return r;
596
597 accel->sensitivity = sensitivity;
598 cmpc_accel_set_sensitivity(acpi->handle, sensitivity);
599
600 return strnlen(buf, count);
601}
602
603static struct device_attribute cmpc_accel_sensitivity_attr = {
604 .attr = { .name = "sensitivity", .mode = 0660 },
605 .show = cmpc_accel_sensitivity_show,
606 .store = cmpc_accel_sensitivity_store
607};
608
609static int cmpc_accel_open(struct input_dev *input)
610{
611 struct acpi_device *acpi;
612
613 acpi = to_acpi_device(input->dev.parent);
614 if (ACPI_SUCCESS(cmpc_start_accel(acpi->handle)))
615 return 0;
616 return -EIO;
617}
618
619static void cmpc_accel_close(struct input_dev *input)
620{
621 struct acpi_device *acpi;
622
623 acpi = to_acpi_device(input->dev.parent);
624 cmpc_stop_accel(acpi->handle);
625}
626
627static void cmpc_accel_idev_init(struct input_dev *inputdev)
628{
629 set_bit(EV_ABS, inputdev->evbit);
630 input_set_abs_params(inputdev, ABS_X, 0, 255, 8, 0);
631 input_set_abs_params(inputdev, ABS_Y, 0, 255, 8, 0);
632 input_set_abs_params(inputdev, ABS_Z, 0, 255, 8, 0);
633 inputdev->open = cmpc_accel_open;
634 inputdev->close = cmpc_accel_close;
635}
636
637static int cmpc_accel_add(struct acpi_device *acpi)
638{
639 int error;
640 struct input_dev *inputdev;
641 struct cmpc_accel *accel;
642
643 accel = kmalloc(sizeof(*accel), GFP_KERNEL);
644 if (!accel)
645 return -ENOMEM;
646
647 accel->sensitivity = CMPC_ACCEL_SENSITIVITY_DEFAULT;
648 cmpc_accel_set_sensitivity(acpi->handle, accel->sensitivity);
649
650 error = device_create_file(&acpi->dev, &cmpc_accel_sensitivity_attr);
651 if (error)
652 goto failed_file;
653
654 error = cmpc_add_acpi_notify_device(acpi, "cmpc_accel",
655 cmpc_accel_idev_init);
656 if (error)
657 goto failed_input;
658
659 inputdev = dev_get_drvdata(&acpi->dev);
660 dev_set_drvdata(&inputdev->dev, accel);
661
662 return 0;
663
664failed_input:
665 device_remove_file(&acpi->dev, &cmpc_accel_sensitivity_attr);
666failed_file:
667 kfree(accel);
668 return error;
669}
670
671static int cmpc_accel_remove(struct acpi_device *acpi)
672{
673 struct input_dev *inputdev;
674 struct cmpc_accel *accel;
675
676 inputdev = dev_get_drvdata(&acpi->dev);
677 accel = dev_get_drvdata(&inputdev->dev);
678
679 device_remove_file(&acpi->dev, &cmpc_accel_sensitivity_attr);
680 return cmpc_remove_acpi_notify_device(acpi);
681}
682
683static const struct acpi_device_id cmpc_accel_device_ids[] = {
684 {CMPC_ACCEL_HID, 0},
685 {"", 0}
686};
687
688static struct acpi_driver cmpc_accel_acpi_driver = {
689 .owner = THIS_MODULE,
690 .name = "cmpc_accel",
691 .class = "cmpc_accel",
692 .ids = cmpc_accel_device_ids,
693 .ops = {
694 .add = cmpc_accel_add,
695 .remove = cmpc_accel_remove,
696 .notify = cmpc_accel_handler,
697 }
698};
699
700
701
702
703
704static acpi_status cmpc_get_tablet(acpi_handle handle,
705 unsigned long long *value)
706{
707 union acpi_object param;
708 struct acpi_object_list input;
709 unsigned long long output;
710 acpi_status status;
711
712 param.type = ACPI_TYPE_INTEGER;
713 param.integer.value = 0x01;
714 input.count = 1;
715 input.pointer = ¶m;
716 status = acpi_evaluate_integer(handle, "TCMD", &input, &output);
717 if (ACPI_SUCCESS(status))
718 *value = output;
719 return status;
720}
721
722static void cmpc_tablet_handler(struct acpi_device *dev, u32 event)
723{
724 unsigned long long val = 0;
725 struct input_dev *inputdev = dev_get_drvdata(&dev->dev);
726
727 if (event == 0x81) {
728 if (ACPI_SUCCESS(cmpc_get_tablet(dev->handle, &val))) {
729 input_report_switch(inputdev, SW_TABLET_MODE, !val);
730 input_sync(inputdev);
731 }
732 }
733}
734
735static void cmpc_tablet_idev_init(struct input_dev *inputdev)
736{
737 unsigned long long val = 0;
738 struct acpi_device *acpi;
739
740 set_bit(EV_SW, inputdev->evbit);
741 set_bit(SW_TABLET_MODE, inputdev->swbit);
742
743 acpi = to_acpi_device(inputdev->dev.parent);
744 if (ACPI_SUCCESS(cmpc_get_tablet(acpi->handle, &val))) {
745 input_report_switch(inputdev, SW_TABLET_MODE, !val);
746 input_sync(inputdev);
747 }
748}
749
750static int cmpc_tablet_add(struct acpi_device *acpi)
751{
752 return cmpc_add_acpi_notify_device(acpi, "cmpc_tablet",
753 cmpc_tablet_idev_init);
754}
755
756static int cmpc_tablet_remove(struct acpi_device *acpi)
757{
758 return cmpc_remove_acpi_notify_device(acpi);
759}
760
761#ifdef CONFIG_PM_SLEEP
762static int cmpc_tablet_resume(struct device *dev)
763{
764 struct input_dev *inputdev = dev_get_drvdata(dev);
765
766 unsigned long long val = 0;
767 if (ACPI_SUCCESS(cmpc_get_tablet(to_acpi_device(dev)->handle, &val))) {
768 input_report_switch(inputdev, SW_TABLET_MODE, !val);
769 input_sync(inputdev);
770 }
771 return 0;
772}
773#endif
774
775static SIMPLE_DEV_PM_OPS(cmpc_tablet_pm, NULL, cmpc_tablet_resume);
776
777static const struct acpi_device_id cmpc_tablet_device_ids[] = {
778 {CMPC_TABLET_HID, 0},
779 {"", 0}
780};
781
782static struct acpi_driver cmpc_tablet_acpi_driver = {
783 .owner = THIS_MODULE,
784 .name = "cmpc_tablet",
785 .class = "cmpc_tablet",
786 .ids = cmpc_tablet_device_ids,
787 .ops = {
788 .add = cmpc_tablet_add,
789 .remove = cmpc_tablet_remove,
790 .notify = cmpc_tablet_handler,
791 },
792 .drv.pm = &cmpc_tablet_pm,
793};
794
795
796
797
798
799
800static acpi_status cmpc_get_brightness(acpi_handle handle,
801 unsigned long long *value)
802{
803 union acpi_object param;
804 struct acpi_object_list input;
805 unsigned long long output;
806 acpi_status status;
807
808 param.type = ACPI_TYPE_INTEGER;
809 param.integer.value = 0xC0;
810 input.count = 1;
811 input.pointer = ¶m;
812 status = acpi_evaluate_integer(handle, "GRDI", &input, &output);
813 if (ACPI_SUCCESS(status))
814 *value = output;
815 return status;
816}
817
818static acpi_status cmpc_set_brightness(acpi_handle handle,
819 unsigned long long value)
820{
821 union acpi_object param[2];
822 struct acpi_object_list input;
823 acpi_status status;
824 unsigned long long output;
825
826 param[0].type = ACPI_TYPE_INTEGER;
827 param[0].integer.value = 0xC0;
828 param[1].type = ACPI_TYPE_INTEGER;
829 param[1].integer.value = value;
830 input.count = 2;
831 input.pointer = param;
832 status = acpi_evaluate_integer(handle, "GWRI", &input, &output);
833 return status;
834}
835
836static int cmpc_bl_get_brightness(struct backlight_device *bd)
837{
838 acpi_status status;
839 acpi_handle handle;
840 unsigned long long brightness;
841
842 handle = bl_get_data(bd);
843 status = cmpc_get_brightness(handle, &brightness);
844 if (ACPI_SUCCESS(status))
845 return brightness;
846 else
847 return -1;
848}
849
850static int cmpc_bl_update_status(struct backlight_device *bd)
851{
852 acpi_status status;
853 acpi_handle handle;
854
855 handle = bl_get_data(bd);
856 status = cmpc_set_brightness(handle, bd->props.brightness);
857 if (ACPI_SUCCESS(status))
858 return 0;
859 else
860 return -1;
861}
862
863static const struct backlight_ops cmpc_bl_ops = {
864 .get_brightness = cmpc_bl_get_brightness,
865 .update_status = cmpc_bl_update_status
866};
867
868
869
870
871
872static acpi_status cmpc_get_rfkill_wlan(acpi_handle handle,
873 unsigned long long *value)
874{
875 union acpi_object param;
876 struct acpi_object_list input;
877 unsigned long long output;
878 acpi_status status;
879
880 param.type = ACPI_TYPE_INTEGER;
881 param.integer.value = 0xC1;
882 input.count = 1;
883 input.pointer = ¶m;
884 status = acpi_evaluate_integer(handle, "GRDI", &input, &output);
885 if (ACPI_SUCCESS(status))
886 *value = output;
887 return status;
888}
889
890static acpi_status cmpc_set_rfkill_wlan(acpi_handle handle,
891 unsigned long long value)
892{
893 union acpi_object param[2];
894 struct acpi_object_list input;
895 acpi_status status;
896 unsigned long long output;
897
898 param[0].type = ACPI_TYPE_INTEGER;
899 param[0].integer.value = 0xC1;
900 param[1].type = ACPI_TYPE_INTEGER;
901 param[1].integer.value = value;
902 input.count = 2;
903 input.pointer = param;
904 status = acpi_evaluate_integer(handle, "GWRI", &input, &output);
905 return status;
906}
907
908static void cmpc_rfkill_query(struct rfkill *rfkill, void *data)
909{
910 acpi_status status;
911 acpi_handle handle;
912 unsigned long long state;
913 bool blocked;
914
915 handle = data;
916 status = cmpc_get_rfkill_wlan(handle, &state);
917 if (ACPI_SUCCESS(status)) {
918 blocked = state & 1 ? false : true;
919 rfkill_set_sw_state(rfkill, blocked);
920 }
921}
922
923static int cmpc_rfkill_block(void *data, bool blocked)
924{
925 acpi_status status;
926 acpi_handle handle;
927 unsigned long long state;
928 bool is_blocked;
929
930 handle = data;
931 status = cmpc_get_rfkill_wlan(handle, &state);
932 if (ACPI_FAILURE(status))
933 return -ENODEV;
934
935 is_blocked = state & 1 ? false : true;
936 if (is_blocked != blocked) {
937 state = blocked ? 0 : 1;
938 status = cmpc_set_rfkill_wlan(handle, state);
939 if (ACPI_FAILURE(status))
940 return -ENODEV;
941 }
942 return 0;
943}
944
945static const struct rfkill_ops cmpc_rfkill_ops = {
946 .query = cmpc_rfkill_query,
947 .set_block = cmpc_rfkill_block,
948};
949
950
951
952
953
954struct ipml200_dev {
955 struct backlight_device *bd;
956 struct rfkill *rf;
957};
958
959static int cmpc_ipml_add(struct acpi_device *acpi)
960{
961 int retval;
962 struct ipml200_dev *ipml;
963 struct backlight_properties props;
964
965 ipml = kmalloc(sizeof(*ipml), GFP_KERNEL);
966 if (ipml == NULL)
967 return -ENOMEM;
968
969 memset(&props, 0, sizeof(struct backlight_properties));
970 props.type = BACKLIGHT_PLATFORM;
971 props.max_brightness = 7;
972 ipml->bd = backlight_device_register("cmpc_bl", &acpi->dev,
973 acpi->handle, &cmpc_bl_ops,
974 &props);
975 if (IS_ERR(ipml->bd)) {
976 retval = PTR_ERR(ipml->bd);
977 goto out_bd;
978 }
979
980 ipml->rf = rfkill_alloc("cmpc_rfkill", &acpi->dev, RFKILL_TYPE_WLAN,
981 &cmpc_rfkill_ops, acpi->handle);
982
983
984
985
986
987 if (ipml->rf) {
988 retval = rfkill_register(ipml->rf);
989 if (retval) {
990 rfkill_destroy(ipml->rf);
991 ipml->rf = NULL;
992 }
993 }
994
995 dev_set_drvdata(&acpi->dev, ipml);
996 return 0;
997
998out_bd:
999 kfree(ipml);
1000 return retval;
1001}
1002
1003static int cmpc_ipml_remove(struct acpi_device *acpi)
1004{
1005 struct ipml200_dev *ipml;
1006
1007 ipml = dev_get_drvdata(&acpi->dev);
1008
1009 backlight_device_unregister(ipml->bd);
1010
1011 if (ipml->rf) {
1012 rfkill_unregister(ipml->rf);
1013 rfkill_destroy(ipml->rf);
1014 }
1015
1016 kfree(ipml);
1017
1018 return 0;
1019}
1020
1021static const struct acpi_device_id cmpc_ipml_device_ids[] = {
1022 {CMPC_IPML_HID, 0},
1023 {"", 0}
1024};
1025
1026static struct acpi_driver cmpc_ipml_acpi_driver = {
1027 .owner = THIS_MODULE,
1028 .name = "cmpc",
1029 .class = "cmpc",
1030 .ids = cmpc_ipml_device_ids,
1031 .ops = {
1032 .add = cmpc_ipml_add,
1033 .remove = cmpc_ipml_remove
1034 }
1035};
1036
1037
1038
1039
1040
1041static int cmpc_keys_codes[] = {
1042 KEY_UNKNOWN,
1043 KEY_WLAN,
1044 KEY_SWITCHVIDEOMODE,
1045 KEY_BRIGHTNESSDOWN,
1046 KEY_BRIGHTNESSUP,
1047 KEY_VENDOR,
1048 KEY_UNKNOWN,
1049 KEY_CAMERA,
1050 KEY_BACK,
1051 KEY_FORWARD,
1052 KEY_MAX
1053};
1054
1055static void cmpc_keys_handler(struct acpi_device *dev, u32 event)
1056{
1057 struct input_dev *inputdev;
1058 int code = KEY_MAX;
1059
1060 if ((event & 0x0F) < ARRAY_SIZE(cmpc_keys_codes))
1061 code = cmpc_keys_codes[event & 0x0F];
1062 inputdev = dev_get_drvdata(&dev->dev);
1063 input_report_key(inputdev, code, !(event & 0x10));
1064 input_sync(inputdev);
1065}
1066
1067static void cmpc_keys_idev_init(struct input_dev *inputdev)
1068{
1069 int i;
1070
1071 set_bit(EV_KEY, inputdev->evbit);
1072 for (i = 0; cmpc_keys_codes[i] != KEY_MAX; i++)
1073 set_bit(cmpc_keys_codes[i], inputdev->keybit);
1074}
1075
1076static int cmpc_keys_add(struct acpi_device *acpi)
1077{
1078 return cmpc_add_acpi_notify_device(acpi, "cmpc_keys",
1079 cmpc_keys_idev_init);
1080}
1081
1082static int cmpc_keys_remove(struct acpi_device *acpi)
1083{
1084 return cmpc_remove_acpi_notify_device(acpi);
1085}
1086
1087static const struct acpi_device_id cmpc_keys_device_ids[] = {
1088 {CMPC_KEYS_HID, 0},
1089 {"", 0}
1090};
1091
1092static struct acpi_driver cmpc_keys_acpi_driver = {
1093 .owner = THIS_MODULE,
1094 .name = "cmpc_keys",
1095 .class = "cmpc_keys",
1096 .ids = cmpc_keys_device_ids,
1097 .ops = {
1098 .add = cmpc_keys_add,
1099 .remove = cmpc_keys_remove,
1100 .notify = cmpc_keys_handler,
1101 }
1102};
1103
1104
1105
1106
1107
1108
1109static int cmpc_init(void)
1110{
1111 int r;
1112
1113 r = acpi_bus_register_driver(&cmpc_keys_acpi_driver);
1114 if (r)
1115 goto failed_keys;
1116
1117 r = acpi_bus_register_driver(&cmpc_ipml_acpi_driver);
1118 if (r)
1119 goto failed_bl;
1120
1121 r = acpi_bus_register_driver(&cmpc_tablet_acpi_driver);
1122 if (r)
1123 goto failed_tablet;
1124
1125 r = acpi_bus_register_driver(&cmpc_accel_acpi_driver);
1126 if (r)
1127 goto failed_accel;
1128
1129 r = acpi_bus_register_driver(&cmpc_accel_acpi_driver_v4);
1130 if (r)
1131 goto failed_accel_v4;
1132
1133 return r;
1134
1135failed_accel_v4:
1136 acpi_bus_unregister_driver(&cmpc_accel_acpi_driver);
1137
1138failed_accel:
1139 acpi_bus_unregister_driver(&cmpc_tablet_acpi_driver);
1140
1141failed_tablet:
1142 acpi_bus_unregister_driver(&cmpc_ipml_acpi_driver);
1143
1144failed_bl:
1145 acpi_bus_unregister_driver(&cmpc_keys_acpi_driver);
1146
1147failed_keys:
1148 return r;
1149}
1150
1151static void cmpc_exit(void)
1152{
1153 acpi_bus_unregister_driver(&cmpc_accel_acpi_driver_v4);
1154 acpi_bus_unregister_driver(&cmpc_accel_acpi_driver);
1155 acpi_bus_unregister_driver(&cmpc_tablet_acpi_driver);
1156 acpi_bus_unregister_driver(&cmpc_ipml_acpi_driver);
1157 acpi_bus_unregister_driver(&cmpc_keys_acpi_driver);
1158}
1159
1160module_init(cmpc_init);
1161module_exit(cmpc_exit);
1162
1163static const struct acpi_device_id cmpc_device_ids[] = {
1164 {CMPC_ACCEL_HID, 0},
1165 {CMPC_ACCEL_HID_V4, 0},
1166 {CMPC_TABLET_HID, 0},
1167 {CMPC_IPML_HID, 0},
1168 {CMPC_KEYS_HID, 0},
1169 {"", 0}
1170};
1171
1172MODULE_DEVICE_TABLE(acpi, cmpc_device_ids);
1173
