1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#include <linux/device.h>
37#include <linux/hid.h>
38#include <linux/input.h>
39#include <linux/spinlock.h>
40#include "hid-wiimote.h"
41
42
43
44
45
46
47
48
49
50
51static const __u16 wiimod_keys_map[] = {
52 KEY_LEFT,
53 KEY_RIGHT,
54 KEY_UP,
55 KEY_DOWN,
56 KEY_NEXT,
57 KEY_PREVIOUS,
58 BTN_1,
59 BTN_2,
60 BTN_A,
61 BTN_B,
62 BTN_MODE,
63};
64
65static void wiimod_keys_in_keys(struct wiimote_data *wdata, const __u8 *keys)
66{
67 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_LEFT],
68 !!(keys[0] & 0x01));
69 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_RIGHT],
70 !!(keys[0] & 0x02));
71 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_DOWN],
72 !!(keys[0] & 0x04));
73 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_UP],
74 !!(keys[0] & 0x08));
75 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_PLUS],
76 !!(keys[0] & 0x10));
77 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_TWO],
78 !!(keys[1] & 0x01));
79 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_ONE],
80 !!(keys[1] & 0x02));
81 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_B],
82 !!(keys[1] & 0x04));
83 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_A],
84 !!(keys[1] & 0x08));
85 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_MINUS],
86 !!(keys[1] & 0x10));
87 input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_HOME],
88 !!(keys[1] & 0x80));
89 input_sync(wdata->input);
90}
91
92static int wiimod_keys_probe(const struct wiimod_ops *ops,
93 struct wiimote_data *wdata)
94{
95 unsigned int i;
96
97 set_bit(EV_KEY, wdata->input->evbit);
98 for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
99 set_bit(wiimod_keys_map[i], wdata->input->keybit);
100
101 return 0;
102}
103
104static const struct wiimod_ops wiimod_keys = {
105 .flags = WIIMOD_FLAG_INPUT,
106 .arg = 0,
107 .probe = wiimod_keys_probe,
108 .remove = NULL,
109 .in_keys = wiimod_keys_in_keys,
110};
111
112
113
114
115
116
117
118
119
120
121
122
123static void wiimod_rumble_worker(struct work_struct *work)
124{
125 struct wiimote_data *wdata = container_of(work, struct wiimote_data,
126 rumble_worker);
127
128 spin_lock_irq(&wdata->state.lock);
129 wiiproto_req_rumble(wdata, wdata->state.cache_rumble);
130 spin_unlock_irq(&wdata->state.lock);
131}
132
133static int wiimod_rumble_play(struct input_dev *dev, void *data,
134 struct ff_effect *eff)
135{
136 struct wiimote_data *wdata = input_get_drvdata(dev);
137 __u8 value;
138
139
140
141
142
143
144
145 if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
146 value = 1;
147 else
148 value = 0;
149
150
151
152 wdata->state.cache_rumble = value;
153 schedule_work(&wdata->rumble_worker);
154
155 return 0;
156}
157
158static int wiimod_rumble_probe(const struct wiimod_ops *ops,
159 struct wiimote_data *wdata)
160{
161 INIT_WORK(&wdata->rumble_worker, wiimod_rumble_worker);
162
163 set_bit(FF_RUMBLE, wdata->input->ffbit);
164 if (input_ff_create_memless(wdata->input, NULL, wiimod_rumble_play))
165 return -ENOMEM;
166
167 return 0;
168}
169
170static void wiimod_rumble_remove(const struct wiimod_ops *ops,
171 struct wiimote_data *wdata)
172{
173 unsigned long flags;
174
175 cancel_work_sync(&wdata->rumble_worker);
176
177 spin_lock_irqsave(&wdata->state.lock, flags);
178 wiiproto_req_rumble(wdata, 0);
179 spin_unlock_irqrestore(&wdata->state.lock, flags);
180}
181
182static const struct wiimod_ops wiimod_rumble = {
183 .flags = WIIMOD_FLAG_INPUT,
184 .arg = 0,
185 .probe = wiimod_rumble_probe,
186 .remove = wiimod_rumble_remove,
187};
188
189
190
191
192
193
194
195
196
197static enum power_supply_property wiimod_battery_props[] = {
198 POWER_SUPPLY_PROP_CAPACITY,
199 POWER_SUPPLY_PROP_SCOPE,
200};
201
202static int wiimod_battery_get_property(struct power_supply *psy,
203 enum power_supply_property psp,
204 union power_supply_propval *val)
205{
206 struct wiimote_data *wdata = power_supply_get_drvdata(psy);
207 int ret = 0, state;
208 unsigned long flags;
209
210 if (psp == POWER_SUPPLY_PROP_SCOPE) {
211 val->intval = POWER_SUPPLY_SCOPE_DEVICE;
212 return 0;
213 } else if (psp != POWER_SUPPLY_PROP_CAPACITY) {
214 return -EINVAL;
215 }
216
217 ret = wiimote_cmd_acquire(wdata);
218 if (ret)
219 return ret;
220
221 spin_lock_irqsave(&wdata->state.lock, flags);
222 wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
223 wiiproto_req_status(wdata);
224 spin_unlock_irqrestore(&wdata->state.lock, flags);
225
226 wiimote_cmd_wait(wdata);
227 wiimote_cmd_release(wdata);
228
229 spin_lock_irqsave(&wdata->state.lock, flags);
230 state = wdata->state.cmd_battery;
231 spin_unlock_irqrestore(&wdata->state.lock, flags);
232
233 val->intval = state * 100 / 255;
234 return ret;
235}
236
237static int wiimod_battery_probe(const struct wiimod_ops *ops,
238 struct wiimote_data *wdata)
239{
240 struct power_supply_config psy_cfg = { .drv_data = wdata, };
241 int ret;
242
243 wdata->battery_desc.properties = wiimod_battery_props;
244 wdata->battery_desc.num_properties = ARRAY_SIZE(wiimod_battery_props);
245 wdata->battery_desc.get_property = wiimod_battery_get_property;
246 wdata->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
247 wdata->battery_desc.use_for_apm = 0;
248 wdata->battery_desc.name = kasprintf(GFP_KERNEL, "wiimote_battery_%s",
249 wdata->hdev->uniq);
250 if (!wdata->battery_desc.name)
251 return -ENOMEM;
252
253 wdata->battery = power_supply_register(&wdata->hdev->dev,
254 &wdata->battery_desc,
255 &psy_cfg);
256 if (IS_ERR(wdata->battery)) {
257 hid_err(wdata->hdev, "cannot register battery device\n");
258 ret = PTR_ERR(wdata->battery);
259 goto err_free;
260 }
261
262 power_supply_powers(wdata->battery, &wdata->hdev->dev);
263 return 0;
264
265err_free:
266 kfree(wdata->battery_desc.name);
267 wdata->battery_desc.name = NULL;
268 return ret;
269}
270
271static void wiimod_battery_remove(const struct wiimod_ops *ops,
272 struct wiimote_data *wdata)
273{
274 if (!wdata->battery_desc.name)
275 return;
276
277 power_supply_unregister(wdata->battery);
278 kfree(wdata->battery_desc.name);
279 wdata->battery_desc.name = NULL;
280}
281
282static const struct wiimod_ops wiimod_battery = {
283 .flags = 0,
284 .arg = 0,
285 .probe = wiimod_battery_probe,
286 .remove = wiimod_battery_remove,
287};
288
289
290
291
292
293
294
295
296
297static enum led_brightness wiimod_led_get(struct led_classdev *led_dev)
298{
299 struct device *dev = led_dev->dev->parent;
300 struct wiimote_data *wdata = dev_to_wii(dev);
301 int i;
302 unsigned long flags;
303 bool value = false;
304
305 for (i = 0; i < 4; ++i) {
306 if (wdata->leds[i] == led_dev) {
307 spin_lock_irqsave(&wdata->state.lock, flags);
308 value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
309 spin_unlock_irqrestore(&wdata->state.lock, flags);
310 break;
311 }
312 }
313
314 return value ? LED_FULL : LED_OFF;
315}
316
317static void wiimod_led_set(struct led_classdev *led_dev,
318 enum led_brightness value)
319{
320 struct device *dev = led_dev->dev->parent;
321 struct wiimote_data *wdata = dev_to_wii(dev);
322 int i;
323 unsigned long flags;
324 __u8 state, flag;
325
326 for (i = 0; i < 4; ++i) {
327 if (wdata->leds[i] == led_dev) {
328 flag = WIIPROTO_FLAG_LED(i + 1);
329 spin_lock_irqsave(&wdata->state.lock, flags);
330 state = wdata->state.flags;
331 if (value == LED_OFF)
332 wiiproto_req_leds(wdata, state & ~flag);
333 else
334 wiiproto_req_leds(wdata, state | flag);
335 spin_unlock_irqrestore(&wdata->state.lock, flags);
336 break;
337 }
338 }
339}
340
341static int wiimod_led_probe(const struct wiimod_ops *ops,
342 struct wiimote_data *wdata)
343{
344 struct device *dev = &wdata->hdev->dev;
345 size_t namesz = strlen(dev_name(dev)) + 9;
346 struct led_classdev *led;
347 unsigned long flags;
348 char *name;
349 int ret;
350
351 led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
352 if (!led)
353 return -ENOMEM;
354
355 name = (void*)&led[1];
356 snprintf(name, namesz, "%s:blue:p%lu", dev_name(dev), ops->arg);
357 led->name = name;
358 led->brightness = 0;
359 led->max_brightness = 1;
360 led->brightness_get = wiimod_led_get;
361 led->brightness_set = wiimod_led_set;
362
363 wdata->leds[ops->arg] = led;
364 ret = led_classdev_register(dev, led);
365 if (ret)
366 goto err_free;
367
368
369 if (ops->arg == 0) {
370 spin_lock_irqsave(&wdata->state.lock, flags);
371 wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
372 spin_unlock_irqrestore(&wdata->state.lock, flags);
373 }
374
375 return 0;
376
377err_free:
378 wdata->leds[ops->arg] = NULL;
379 kfree(led);
380 return ret;
381}
382
383static void wiimod_led_remove(const struct wiimod_ops *ops,
384 struct wiimote_data *wdata)
385{
386 if (!wdata->leds[ops->arg])
387 return;
388
389 led_classdev_unregister(wdata->leds[ops->arg]);
390 kfree(wdata->leds[ops->arg]);
391 wdata->leds[ops->arg] = NULL;
392}
393
394static const struct wiimod_ops wiimod_leds[4] = {
395 {
396 .flags = 0,
397 .arg = 0,
398 .probe = wiimod_led_probe,
399 .remove = wiimod_led_remove,
400 },
401 {
402 .flags = 0,
403 .arg = 1,
404 .probe = wiimod_led_probe,
405 .remove = wiimod_led_remove,
406 },
407 {
408 .flags = 0,
409 .arg = 2,
410 .probe = wiimod_led_probe,
411 .remove = wiimod_led_remove,
412 },
413 {
414 .flags = 0,
415 .arg = 3,
416 .probe = wiimod_led_probe,
417 .remove = wiimod_led_remove,
418 },
419};
420
421
422
423
424
425
426
427
428static void wiimod_accel_in_accel(struct wiimote_data *wdata,
429 const __u8 *accel)
430{
431 __u16 x, y, z;
432
433 if (!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
434 return;
435
436
437
438
439
440
441
442
443
444
445
446
447
448 x = accel[2] << 2;
449 y = accel[3] << 2;
450 z = accel[4] << 2;
451
452 x |= (accel[0] >> 5) & 0x3;
453 y |= (accel[1] >> 4) & 0x2;
454 z |= (accel[1] >> 5) & 0x2;
455
456 input_report_abs(wdata->accel, ABS_RX, x - 0x200);
457 input_report_abs(wdata->accel, ABS_RY, y - 0x200);
458 input_report_abs(wdata->accel, ABS_RZ, z - 0x200);
459 input_sync(wdata->accel);
460}
461
462static int wiimod_accel_open(struct input_dev *dev)
463{
464 struct wiimote_data *wdata = input_get_drvdata(dev);
465 unsigned long flags;
466
467 spin_lock_irqsave(&wdata->state.lock, flags);
468 wiiproto_req_accel(wdata, true);
469 spin_unlock_irqrestore(&wdata->state.lock, flags);
470
471 return 0;
472}
473
474static void wiimod_accel_close(struct input_dev *dev)
475{
476 struct wiimote_data *wdata = input_get_drvdata(dev);
477 unsigned long flags;
478
479 spin_lock_irqsave(&wdata->state.lock, flags);
480 wiiproto_req_accel(wdata, false);
481 spin_unlock_irqrestore(&wdata->state.lock, flags);
482}
483
484static int wiimod_accel_probe(const struct wiimod_ops *ops,
485 struct wiimote_data *wdata)
486{
487 int ret;
488
489 wdata->accel = input_allocate_device();
490 if (!wdata->accel)
491 return -ENOMEM;
492
493 input_set_drvdata(wdata->accel, wdata);
494 wdata->accel->open = wiimod_accel_open;
495 wdata->accel->close = wiimod_accel_close;
496 wdata->accel->dev.parent = &wdata->hdev->dev;
497 wdata->accel->id.bustype = wdata->hdev->bus;
498 wdata->accel->id.vendor = wdata->hdev->vendor;
499 wdata->accel->id.product = wdata->hdev->product;
500 wdata->accel->id.version = wdata->hdev->version;
501 wdata->accel->name = WIIMOTE_NAME " Accelerometer";
502
503 set_bit(EV_ABS, wdata->accel->evbit);
504 set_bit(ABS_RX, wdata->accel->absbit);
505 set_bit(ABS_RY, wdata->accel->absbit);
506 set_bit(ABS_RZ, wdata->accel->absbit);
507 input_set_abs_params(wdata->accel, ABS_RX, -500, 500, 2, 4);
508 input_set_abs_params(wdata->accel, ABS_RY, -500, 500, 2, 4);
509 input_set_abs_params(wdata->accel, ABS_RZ, -500, 500, 2, 4);
510
511 ret = input_register_device(wdata->accel);
512 if (ret) {
513 hid_err(wdata->hdev, "cannot register input device\n");
514 goto err_free;
515 }
516
517 return 0;
518
519err_free:
520 input_free_device(wdata->accel);
521 wdata->accel = NULL;
522 return ret;
523}
524
525static void wiimod_accel_remove(const struct wiimod_ops *ops,
526 struct wiimote_data *wdata)
527{
528 if (!wdata->accel)
529 return;
530
531 input_unregister_device(wdata->accel);
532 wdata->accel = NULL;
533}
534
535static const struct wiimod_ops wiimod_accel = {
536 .flags = 0,
537 .arg = 0,
538 .probe = wiimod_accel_probe,
539 .remove = wiimod_accel_remove,
540 .in_accel = wiimod_accel_in_accel,
541};
542
543
544
545
546
547
548
549
550
551
552
553static void wiimod_ir_in_ir(struct wiimote_data *wdata, const __u8 *ir,
554 bool packed, unsigned int id)
555{
556 __u16 x, y;
557 __u8 xid, yid;
558 bool sync = false;
559
560 if (!(wdata->state.flags & WIIPROTO_FLAGS_IR))
561 return;
562
563 switch (id) {
564 case 0:
565 xid = ABS_HAT0X;
566 yid = ABS_HAT0Y;
567 break;
568 case 1:
569 xid = ABS_HAT1X;
570 yid = ABS_HAT1Y;
571 break;
572 case 2:
573 xid = ABS_HAT2X;
574 yid = ABS_HAT2Y;
575 break;
576 case 3:
577 xid = ABS_HAT3X;
578 yid = ABS_HAT3Y;
579 sync = true;
580 break;
581 default:
582 return;
583 }
584
585
586
587
588
589
590
591
592
593
594
595 if (packed) {
596 x = ir[1] | ((ir[0] & 0x03) << 8);
597 y = ir[2] | ((ir[0] & 0x0c) << 6);
598 } else {
599 x = ir[0] | ((ir[2] & 0x30) << 4);
600 y = ir[1] | ((ir[2] & 0xc0) << 2);
601 }
602
603 input_report_abs(wdata->ir, xid, x);
604 input_report_abs(wdata->ir, yid, y);
605
606 if (sync)
607 input_sync(wdata->ir);
608}
609
610static int wiimod_ir_change(struct wiimote_data *wdata, __u16 mode)
611{
612 int ret;
613 unsigned long flags;
614 __u8 format = 0;
615 static const __u8 data_enable[] = { 0x01 };
616 static const __u8 data_sens1[] = { 0x02, 0x00, 0x00, 0x71, 0x01,
617 0x00, 0xaa, 0x00, 0x64 };
618 static const __u8 data_sens2[] = { 0x63, 0x03 };
619 static const __u8 data_fin[] = { 0x08 };
620
621 spin_lock_irqsave(&wdata->state.lock, flags);
622
623 if (mode == (wdata->state.flags & WIIPROTO_FLAGS_IR)) {
624 spin_unlock_irqrestore(&wdata->state.lock, flags);
625 return 0;
626 }
627
628 if (mode == 0) {
629 wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
630 wiiproto_req_ir1(wdata, 0);
631 wiiproto_req_ir2(wdata, 0);
632 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
633 spin_unlock_irqrestore(&wdata->state.lock, flags);
634 return 0;
635 }
636
637 spin_unlock_irqrestore(&wdata->state.lock, flags);
638
639 ret = wiimote_cmd_acquire(wdata);
640 if (ret)
641 return ret;
642
643
644 spin_lock_irqsave(&wdata->state.lock, flags);
645 wiimote_cmd_set(wdata, WIIPROTO_REQ_IR1, 0);
646 wiiproto_req_ir1(wdata, 0x06);
647 spin_unlock_irqrestore(&wdata->state.lock, flags);
648
649 ret = wiimote_cmd_wait(wdata);
650 if (ret)
651 goto unlock;
652 if (wdata->state.cmd_err) {
653 ret = -EIO;
654 goto unlock;
655 }
656
657
658 spin_lock_irqsave(&wdata->state.lock, flags);
659 wiimote_cmd_set(wdata, WIIPROTO_REQ_IR2, 0);
660 wiiproto_req_ir2(wdata, 0x06);
661 spin_unlock_irqrestore(&wdata->state.lock, flags);
662
663 ret = wiimote_cmd_wait(wdata);
664 if (ret)
665 goto unlock;
666 if (wdata->state.cmd_err) {
667 ret = -EIO;
668 goto unlock;
669 }
670
671
672 ret = wiimote_cmd_write(wdata, 0xb00030, data_enable,
673 sizeof(data_enable));
674 if (ret)
675 goto unlock;
676
677
678 ret = wiimote_cmd_write(wdata, 0xb00000, data_sens1,
679 sizeof(data_sens1));
680 if (ret)
681 goto unlock;
682
683
684 ret = wiimote_cmd_write(wdata, 0xb0001a, data_sens2,
685 sizeof(data_sens2));
686 if (ret)
687 goto unlock;
688
689
690 switch (mode) {
691 case WIIPROTO_FLAG_IR_FULL:
692 format = 5;
693 break;
694 case WIIPROTO_FLAG_IR_EXT:
695 format = 3;
696 break;
697 case WIIPROTO_FLAG_IR_BASIC:
698 format = 1;
699 break;
700 }
701 ret = wiimote_cmd_write(wdata, 0xb00033, &format, sizeof(format));
702 if (ret)
703 goto unlock;
704
705
706 ret = wiimote_cmd_write(wdata, 0xb00030, data_fin, sizeof(data_fin));
707 if (ret)
708 goto unlock;
709
710
711 spin_lock_irqsave(&wdata->state.lock, flags);
712 wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
713 wdata->state.flags |= mode & WIIPROTO_FLAGS_IR;
714 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
715 spin_unlock_irqrestore(&wdata->state.lock, flags);
716
717unlock:
718 wiimote_cmd_release(wdata);
719 return ret;
720}
721
722static int wiimod_ir_open(struct input_dev *dev)
723{
724 struct wiimote_data *wdata = input_get_drvdata(dev);
725
726 return wiimod_ir_change(wdata, WIIPROTO_FLAG_IR_BASIC);
727}
728
729static void wiimod_ir_close(struct input_dev *dev)
730{
731 struct wiimote_data *wdata = input_get_drvdata(dev);
732
733 wiimod_ir_change(wdata, 0);
734}
735
736static int wiimod_ir_probe(const struct wiimod_ops *ops,
737 struct wiimote_data *wdata)
738{
739 int ret;
740
741 wdata->ir = input_allocate_device();
742 if (!wdata->ir)
743 return -ENOMEM;
744
745 input_set_drvdata(wdata->ir, wdata);
746 wdata->ir->open = wiimod_ir_open;
747 wdata->ir->close = wiimod_ir_close;
748 wdata->ir->dev.parent = &wdata->hdev->dev;
749 wdata->ir->id.bustype = wdata->hdev->bus;
750 wdata->ir->id.vendor = wdata->hdev->vendor;
751 wdata->ir->id.product = wdata->hdev->product;
752 wdata->ir->id.version = wdata->hdev->version;
753 wdata->ir->name = WIIMOTE_NAME " IR";
754
755 set_bit(EV_ABS, wdata->ir->evbit);
756 set_bit(ABS_HAT0X, wdata->ir->absbit);
757 set_bit(ABS_HAT0Y, wdata->ir->absbit);
758 set_bit(ABS_HAT1X, wdata->ir->absbit);
759 set_bit(ABS_HAT1Y, wdata->ir->absbit);
760 set_bit(ABS_HAT2X, wdata->ir->absbit);
761 set_bit(ABS_HAT2Y, wdata->ir->absbit);
762 set_bit(ABS_HAT3X, wdata->ir->absbit);
763 set_bit(ABS_HAT3Y, wdata->ir->absbit);
764 input_set_abs_params(wdata->ir, ABS_HAT0X, 0, 1023, 2, 4);
765 input_set_abs_params(wdata->ir, ABS_HAT0Y, 0, 767, 2, 4);
766 input_set_abs_params(wdata->ir, ABS_HAT1X, 0, 1023, 2, 4);
767 input_set_abs_params(wdata->ir, ABS_HAT1Y, 0, 767, 2, 4);
768 input_set_abs_params(wdata->ir, ABS_HAT2X, 0, 1023, 2, 4);
769 input_set_abs_params(wdata->ir, ABS_HAT2Y, 0, 767, 2, 4);
770 input_set_abs_params(wdata->ir, ABS_HAT3X, 0, 1023, 2, 4);
771 input_set_abs_params(wdata->ir, ABS_HAT3Y, 0, 767, 2, 4);
772
773 ret = input_register_device(wdata->ir);
774 if (ret) {
775 hid_err(wdata->hdev, "cannot register input device\n");
776 goto err_free;
777 }
778
779 return 0;
780
781err_free:
782 input_free_device(wdata->ir);
783 wdata->ir = NULL;
784 return ret;
785}
786
787static void wiimod_ir_remove(const struct wiimod_ops *ops,
788 struct wiimote_data *wdata)
789{
790 if (!wdata->ir)
791 return;
792
793 input_unregister_device(wdata->ir);
794 wdata->ir = NULL;
795}
796
797static const struct wiimod_ops wiimod_ir = {
798 .flags = 0,
799 .arg = 0,
800 .probe = wiimod_ir_probe,
801 .remove = wiimod_ir_remove,
802 .in_ir = wiimod_ir_in_ir,
803};
804
805
806
807
808
809
810
811
812enum wiimod_nunchuk_keys {
813 WIIMOD_NUNCHUK_KEY_C,
814 WIIMOD_NUNCHUK_KEY_Z,
815 WIIMOD_NUNCHUK_KEY_NUM,
816};
817
818static const __u16 wiimod_nunchuk_map[] = {
819 BTN_C,
820 BTN_Z,
821};
822
823static void wiimod_nunchuk_in_ext(struct wiimote_data *wdata, const __u8 *ext)
824{
825 __s16 x, y, z, bx, by;
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857 bx = ext[0];
858 by = ext[1];
859 bx -= 128;
860 by -= 128;
861
862 x = ext[2] << 2;
863 y = ext[3] << 2;
864 z = ext[4] << 2;
865
866 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
867 x |= (ext[5] >> 3) & 0x02;
868 y |= (ext[5] >> 4) & 0x02;
869 z &= ~0x4;
870 z |= (ext[5] >> 5) & 0x06;
871 } else {
872 x |= (ext[5] >> 2) & 0x03;
873 y |= (ext[5] >> 4) & 0x03;
874 z |= (ext[5] >> 6) & 0x03;
875 }
876
877 x -= 0x200;
878 y -= 0x200;
879 z -= 0x200;
880
881 input_report_abs(wdata->extension.input, ABS_HAT0X, bx);
882 input_report_abs(wdata->extension.input, ABS_HAT0Y, by);
883
884 input_report_abs(wdata->extension.input, ABS_RX, x);
885 input_report_abs(wdata->extension.input, ABS_RY, y);
886 input_report_abs(wdata->extension.input, ABS_RZ, z);
887
888 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
889 input_report_key(wdata->extension.input,
890 wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_Z],
891 !(ext[5] & 0x04));
892 input_report_key(wdata->extension.input,
893 wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_C],
894 !(ext[5] & 0x08));
895 } else {
896 input_report_key(wdata->extension.input,
897 wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_Z],
898 !(ext[5] & 0x01));
899 input_report_key(wdata->extension.input,
900 wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_C],
901 !(ext[5] & 0x02));
902 }
903
904 input_sync(wdata->extension.input);
905}
906
907static int wiimod_nunchuk_open(struct input_dev *dev)
908{
909 struct wiimote_data *wdata = input_get_drvdata(dev);
910 unsigned long flags;
911
912 spin_lock_irqsave(&wdata->state.lock, flags);
913 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
914 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
915 spin_unlock_irqrestore(&wdata->state.lock, flags);
916
917 return 0;
918}
919
920static void wiimod_nunchuk_close(struct input_dev *dev)
921{
922 struct wiimote_data *wdata = input_get_drvdata(dev);
923 unsigned long flags;
924
925 spin_lock_irqsave(&wdata->state.lock, flags);
926 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
927 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
928 spin_unlock_irqrestore(&wdata->state.lock, flags);
929}
930
931static int wiimod_nunchuk_probe(const struct wiimod_ops *ops,
932 struct wiimote_data *wdata)
933{
934 int ret, i;
935
936 wdata->extension.input = input_allocate_device();
937 if (!wdata->extension.input)
938 return -ENOMEM;
939
940 input_set_drvdata(wdata->extension.input, wdata);
941 wdata->extension.input->open = wiimod_nunchuk_open;
942 wdata->extension.input->close = wiimod_nunchuk_close;
943 wdata->extension.input->dev.parent = &wdata->hdev->dev;
944 wdata->extension.input->id.bustype = wdata->hdev->bus;
945 wdata->extension.input->id.vendor = wdata->hdev->vendor;
946 wdata->extension.input->id.product = wdata->hdev->product;
947 wdata->extension.input->id.version = wdata->hdev->version;
948 wdata->extension.input->name = WIIMOTE_NAME " Nunchuk";
949
950 set_bit(EV_KEY, wdata->extension.input->evbit);
951 for (i = 0; i < WIIMOD_NUNCHUK_KEY_NUM; ++i)
952 set_bit(wiimod_nunchuk_map[i],
953 wdata->extension.input->keybit);
954
955 set_bit(EV_ABS, wdata->extension.input->evbit);
956 set_bit(ABS_HAT0X, wdata->extension.input->absbit);
957 set_bit(ABS_HAT0Y, wdata->extension.input->absbit);
958 input_set_abs_params(wdata->extension.input,
959 ABS_HAT0X, -120, 120, 2, 4);
960 input_set_abs_params(wdata->extension.input,
961 ABS_HAT0Y, -120, 120, 2, 4);
962 set_bit(ABS_RX, wdata->extension.input->absbit);
963 set_bit(ABS_RY, wdata->extension.input->absbit);
964 set_bit(ABS_RZ, wdata->extension.input->absbit);
965 input_set_abs_params(wdata->extension.input,
966 ABS_RX, -500, 500, 2, 4);
967 input_set_abs_params(wdata->extension.input,
968 ABS_RY, -500, 500, 2, 4);
969 input_set_abs_params(wdata->extension.input,
970 ABS_RZ, -500, 500, 2, 4);
971
972 ret = input_register_device(wdata->extension.input);
973 if (ret)
974 goto err_free;
975
976 return 0;
977
978err_free:
979 input_free_device(wdata->extension.input);
980 wdata->extension.input = NULL;
981 return ret;
982}
983
984static void wiimod_nunchuk_remove(const struct wiimod_ops *ops,
985 struct wiimote_data *wdata)
986{
987 if (!wdata->extension.input)
988 return;
989
990 input_unregister_device(wdata->extension.input);
991 wdata->extension.input = NULL;
992}
993
994static const struct wiimod_ops wiimod_nunchuk = {
995 .flags = 0,
996 .arg = 0,
997 .probe = wiimod_nunchuk_probe,
998 .remove = wiimod_nunchuk_remove,
999 .in_ext = wiimod_nunchuk_in_ext,
1000};
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010enum wiimod_classic_keys {
1011 WIIMOD_CLASSIC_KEY_A,
1012 WIIMOD_CLASSIC_KEY_B,
1013 WIIMOD_CLASSIC_KEY_X,
1014 WIIMOD_CLASSIC_KEY_Y,
1015 WIIMOD_CLASSIC_KEY_ZL,
1016 WIIMOD_CLASSIC_KEY_ZR,
1017 WIIMOD_CLASSIC_KEY_PLUS,
1018 WIIMOD_CLASSIC_KEY_MINUS,
1019 WIIMOD_CLASSIC_KEY_HOME,
1020 WIIMOD_CLASSIC_KEY_LEFT,
1021 WIIMOD_CLASSIC_KEY_RIGHT,
1022 WIIMOD_CLASSIC_KEY_UP,
1023 WIIMOD_CLASSIC_KEY_DOWN,
1024 WIIMOD_CLASSIC_KEY_LT,
1025 WIIMOD_CLASSIC_KEY_RT,
1026 WIIMOD_CLASSIC_KEY_NUM,
1027};
1028
1029static const __u16 wiimod_classic_map[] = {
1030 BTN_A,
1031 BTN_B,
1032 BTN_X,
1033 BTN_Y,
1034 BTN_TL2,
1035 BTN_TR2,
1036 KEY_NEXT,
1037 KEY_PREVIOUS,
1038 BTN_MODE,
1039 KEY_LEFT,
1040 KEY_RIGHT,
1041 KEY_UP,
1042 KEY_DOWN,
1043 BTN_TL,
1044 BTN_TR,
1045};
1046
1047static void wiimod_classic_in_ext(struct wiimote_data *wdata, const __u8 *ext)
1048{
1049 __s8 rx, ry, lx, ly, lt, rt;
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
1095 lx = ext[0] & 0x3e;
1096 ly = ext[1] & 0x3e;
1097 } else {
1098 lx = ext[0] & 0x3f;
1099 ly = ext[1] & 0x3f;
1100 }
1101
1102 rx = (ext[0] >> 3) & 0x18;
1103 rx |= (ext[1] >> 5) & 0x06;
1104 rx |= (ext[2] >> 7) & 0x01;
1105 ry = ext[2] & 0x1f;
1106
1107 rt = ext[3] & 0x1f;
1108 lt = (ext[2] >> 2) & 0x18;
1109 lt |= (ext[3] >> 5) & 0x07;
1110
1111 rx <<= 1;
1112 ry <<= 1;
1113 rt <<= 1;
1114 lt <<= 1;
1115
1116 input_report_abs(wdata->extension.input, ABS_HAT1X, lx - 0x20);
1117 input_report_abs(wdata->extension.input, ABS_HAT1Y, ly - 0x20);
1118 input_report_abs(wdata->extension.input, ABS_HAT2X, rx - 0x20);
1119 input_report_abs(wdata->extension.input, ABS_HAT2Y, ry - 0x20);
1120 input_report_abs(wdata->extension.input, ABS_HAT3X, rt);
1121 input_report_abs(wdata->extension.input, ABS_HAT3Y, lt);
1122
1123 input_report_key(wdata->extension.input,
1124 wiimod_classic_map[WIIMOD_CLASSIC_KEY_RIGHT],
1125 !(ext[4] & 0x80));
1126 input_report_key(wdata->extension.input,
1127 wiimod_classic_map[WIIMOD_CLASSIC_KEY_DOWN],
1128 !(ext[4] & 0x40));
1129 input_report_key(wdata->extension.input,
1130 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LT],
1131 !(ext[4] & 0x20));
1132 input_report_key(wdata->extension.input,
1133 wiimod_classic_map[WIIMOD_CLASSIC_KEY_MINUS],
1134 !(ext[4] & 0x10));
1135 input_report_key(wdata->extension.input,
1136 wiimod_classic_map[WIIMOD_CLASSIC_KEY_HOME],
1137 !(ext[4] & 0x08));
1138 input_report_key(wdata->extension.input,
1139 wiimod_classic_map[WIIMOD_CLASSIC_KEY_PLUS],
1140 !(ext[4] & 0x04));
1141 input_report_key(wdata->extension.input,
1142 wiimod_classic_map[WIIMOD_CLASSIC_KEY_RT],
1143 !(ext[4] & 0x02));
1144 input_report_key(wdata->extension.input,
1145 wiimod_classic_map[WIIMOD_CLASSIC_KEY_ZL],
1146 !(ext[5] & 0x80));
1147 input_report_key(wdata->extension.input,
1148 wiimod_classic_map[WIIMOD_CLASSIC_KEY_B],
1149 !(ext[5] & 0x40));
1150 input_report_key(wdata->extension.input,
1151 wiimod_classic_map[WIIMOD_CLASSIC_KEY_Y],
1152 !(ext[5] & 0x20));
1153 input_report_key(wdata->extension.input,
1154 wiimod_classic_map[WIIMOD_CLASSIC_KEY_A],
1155 !(ext[5] & 0x10));
1156 input_report_key(wdata->extension.input,
1157 wiimod_classic_map[WIIMOD_CLASSIC_KEY_X],
1158 !(ext[5] & 0x08));
1159 input_report_key(wdata->extension.input,
1160 wiimod_classic_map[WIIMOD_CLASSIC_KEY_ZR],
1161 !(ext[5] & 0x04));
1162
1163 if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
1164 input_report_key(wdata->extension.input,
1165 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LEFT],
1166 !(ext[1] & 0x01));
1167 input_report_key(wdata->extension.input,
1168 wiimod_classic_map[WIIMOD_CLASSIC_KEY_UP],
1169 !(ext[0] & 0x01));
1170 } else {
1171 input_report_key(wdata->extension.input,
1172 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LEFT],
1173 !(ext[5] & 0x02));
1174 input_report_key(wdata->extension.input,
1175 wiimod_classic_map[WIIMOD_CLASSIC_KEY_UP],
1176 !(ext[5] & 0x01));
1177 }
1178
1179 input_sync(wdata->extension.input);
1180}
1181
1182static int wiimod_classic_open(struct input_dev *dev)
1183{
1184 struct wiimote_data *wdata = input_get_drvdata(dev);
1185 unsigned long flags;
1186
1187 spin_lock_irqsave(&wdata->state.lock, flags);
1188 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
1189 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1190 spin_unlock_irqrestore(&wdata->state.lock, flags);
1191
1192 return 0;
1193}
1194
1195static void wiimod_classic_close(struct input_dev *dev)
1196{
1197 struct wiimote_data *wdata = input_get_drvdata(dev);
1198 unsigned long flags;
1199
1200 spin_lock_irqsave(&wdata->state.lock, flags);
1201 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
1202 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1203 spin_unlock_irqrestore(&wdata->state.lock, flags);
1204}
1205
1206static int wiimod_classic_probe(const struct wiimod_ops *ops,
1207 struct wiimote_data *wdata)
1208{
1209 int ret, i;
1210
1211 wdata->extension.input = input_allocate_device();
1212 if (!wdata->extension.input)
1213 return -ENOMEM;
1214
1215 input_set_drvdata(wdata->extension.input, wdata);
1216 wdata->extension.input->open = wiimod_classic_open;
1217 wdata->extension.input->close = wiimod_classic_close;
1218 wdata->extension.input->dev.parent = &wdata->hdev->dev;
1219 wdata->extension.input->id.bustype = wdata->hdev->bus;
1220 wdata->extension.input->id.vendor = wdata->hdev->vendor;
1221 wdata->extension.input->id.product = wdata->hdev->product;
1222 wdata->extension.input->id.version = wdata->hdev->version;
1223 wdata->extension.input->name = WIIMOTE_NAME " Classic Controller";
1224
1225 set_bit(EV_KEY, wdata->extension.input->evbit);
1226 for (i = 0; i < WIIMOD_CLASSIC_KEY_NUM; ++i)
1227 set_bit(wiimod_classic_map[i],
1228 wdata->extension.input->keybit);
1229
1230 set_bit(EV_ABS, wdata->extension.input->evbit);
1231 set_bit(ABS_HAT1X, wdata->extension.input->absbit);
1232 set_bit(ABS_HAT1Y, wdata->extension.input->absbit);
1233 set_bit(ABS_HAT2X, wdata->extension.input->absbit);
1234 set_bit(ABS_HAT2Y, wdata->extension.input->absbit);
1235 set_bit(ABS_HAT3X, wdata->extension.input->absbit);
1236 set_bit(ABS_HAT3Y, wdata->extension.input->absbit);
1237 input_set_abs_params(wdata->extension.input,
1238 ABS_HAT1X, -30, 30, 1, 1);
1239 input_set_abs_params(wdata->extension.input,
1240 ABS_HAT1Y, -30, 30, 1, 1);
1241 input_set_abs_params(wdata->extension.input,
1242 ABS_HAT2X, -30, 30, 1, 1);
1243 input_set_abs_params(wdata->extension.input,
1244 ABS_HAT2Y, -30, 30, 1, 1);
1245 input_set_abs_params(wdata->extension.input,
1246 ABS_HAT3X, -30, 30, 1, 1);
1247 input_set_abs_params(wdata->extension.input,
1248 ABS_HAT3Y, -30, 30, 1, 1);
1249
1250 ret = input_register_device(wdata->extension.input);
1251 if (ret)
1252 goto err_free;
1253
1254 return 0;
1255
1256err_free:
1257 input_free_device(wdata->extension.input);
1258 wdata->extension.input = NULL;
1259 return ret;
1260}
1261
1262static void wiimod_classic_remove(const struct wiimod_ops *ops,
1263 struct wiimote_data *wdata)
1264{
1265 if (!wdata->extension.input)
1266 return;
1267
1268 input_unregister_device(wdata->extension.input);
1269 wdata->extension.input = NULL;
1270}
1271
1272static const struct wiimod_ops wiimod_classic = {
1273 .flags = 0,
1274 .arg = 0,
1275 .probe = wiimod_classic_probe,
1276 .remove = wiimod_classic_remove,
1277 .in_ext = wiimod_classic_in_ext,
1278};
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293static void wiimod_bboard_in_keys(struct wiimote_data *wdata, const __u8 *keys)
1294{
1295 input_report_key(wdata->extension.input, BTN_A,
1296 !!(keys[1] & 0x08));
1297 input_sync(wdata->extension.input);
1298}
1299
1300static void wiimod_bboard_in_ext(struct wiimote_data *wdata,
1301 const __u8 *ext)
1302{
1303 __s32 val[4], tmp, div;
1304 unsigned int i;
1305 struct wiimote_state *s = &wdata->state;
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331 val[0] = ext[0];
1332 val[0] <<= 8;
1333 val[0] |= ext[1];
1334
1335 val[1] = ext[2];
1336 val[1] <<= 8;
1337 val[1] |= ext[3];
1338
1339 val[2] = ext[4];
1340 val[2] <<= 8;
1341 val[2] |= ext[5];
1342
1343 val[3] = ext[6];
1344 val[3] <<= 8;
1345 val[3] |= ext[7];
1346
1347
1348 for (i = 0; i < 4; i++) {
1349 if (val[i] <= s->calib_bboard[i][0]) {
1350 tmp = 0;
1351 } else if (val[i] < s->calib_bboard[i][1]) {
1352 tmp = val[i] - s->calib_bboard[i][0];
1353 tmp *= 1700;
1354 div = s->calib_bboard[i][1] - s->calib_bboard[i][0];
1355 tmp /= div ? div : 1;
1356 } else {
1357 tmp = val[i] - s->calib_bboard[i][1];
1358 tmp *= 1700;
1359 div = s->calib_bboard[i][2] - s->calib_bboard[i][1];
1360 tmp /= div ? div : 1;
1361 tmp += 1700;
1362 }
1363 val[i] = tmp;
1364 }
1365
1366 input_report_abs(wdata->extension.input, ABS_HAT0X, val[0]);
1367 input_report_abs(wdata->extension.input, ABS_HAT0Y, val[1]);
1368 input_report_abs(wdata->extension.input, ABS_HAT1X, val[2]);
1369 input_report_abs(wdata->extension.input, ABS_HAT1Y, val[3]);
1370 input_sync(wdata->extension.input);
1371}
1372
1373static int wiimod_bboard_open(struct input_dev *dev)
1374{
1375 struct wiimote_data *wdata = input_get_drvdata(dev);
1376 unsigned long flags;
1377
1378 spin_lock_irqsave(&wdata->state.lock, flags);
1379 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
1380 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1381 spin_unlock_irqrestore(&wdata->state.lock, flags);
1382
1383 return 0;
1384}
1385
1386static void wiimod_bboard_close(struct input_dev *dev)
1387{
1388 struct wiimote_data *wdata = input_get_drvdata(dev);
1389 unsigned long flags;
1390
1391 spin_lock_irqsave(&wdata->state.lock, flags);
1392 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
1393 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1394 spin_unlock_irqrestore(&wdata->state.lock, flags);
1395}
1396
1397static ssize_t wiimod_bboard_calib_show(struct device *dev,
1398 struct device_attribute *attr,
1399 char *out)
1400{
1401 struct wiimote_data *wdata = dev_to_wii(dev);
1402 int i, j, ret;
1403 __u16 val;
1404 __u8 buf[24], offs;
1405
1406 ret = wiimote_cmd_acquire(wdata);
1407 if (ret)
1408 return ret;
1409
1410 ret = wiimote_cmd_read(wdata, 0xa40024, buf, 12);
1411 if (ret != 12) {
1412 wiimote_cmd_release(wdata);
1413 return ret < 0 ? ret : -EIO;
1414 }
1415 ret = wiimote_cmd_read(wdata, 0xa40024 + 12, buf + 12, 12);
1416 if (ret != 12) {
1417 wiimote_cmd_release(wdata);
1418 return ret < 0 ? ret : -EIO;
1419 }
1420
1421 wiimote_cmd_release(wdata);
1422
1423 spin_lock_irq(&wdata->state.lock);
1424 offs = 0;
1425 for (i = 0; i < 3; ++i) {
1426 for (j = 0; j < 4; ++j) {
1427 wdata->state.calib_bboard[j][i] = buf[offs];
1428 wdata->state.calib_bboard[j][i] <<= 8;
1429 wdata->state.calib_bboard[j][i] |= buf[offs + 1];
1430 offs += 2;
1431 }
1432 }
1433 spin_unlock_irq(&wdata->state.lock);
1434
1435 ret = 0;
1436 for (i = 0; i < 3; ++i) {
1437 for (j = 0; j < 4; ++j) {
1438 val = wdata->state.calib_bboard[j][i];
1439 if (i == 2 && j == 3)
1440 ret += sprintf(&out[ret], "%04x\n", val);
1441 else
1442 ret += sprintf(&out[ret], "%04x:", val);
1443 }
1444 }
1445
1446 return ret;
1447}
1448
1449static DEVICE_ATTR(bboard_calib, S_IRUGO, wiimod_bboard_calib_show, NULL);
1450
1451static int wiimod_bboard_probe(const struct wiimod_ops *ops,
1452 struct wiimote_data *wdata)
1453{
1454 int ret, i, j;
1455 __u8 buf[24], offs;
1456
1457 wiimote_cmd_acquire_noint(wdata);
1458
1459 ret = wiimote_cmd_read(wdata, 0xa40024, buf, 12);
1460 if (ret != 12) {
1461 wiimote_cmd_release(wdata);
1462 return ret < 0 ? ret : -EIO;
1463 }
1464 ret = wiimote_cmd_read(wdata, 0xa40024 + 12, buf + 12, 12);
1465 if (ret != 12) {
1466 wiimote_cmd_release(wdata);
1467 return ret < 0 ? ret : -EIO;
1468 }
1469
1470 wiimote_cmd_release(wdata);
1471
1472 offs = 0;
1473 for (i = 0; i < 3; ++i) {
1474 for (j = 0; j < 4; ++j) {
1475 wdata->state.calib_bboard[j][i] = buf[offs];
1476 wdata->state.calib_bboard[j][i] <<= 8;
1477 wdata->state.calib_bboard[j][i] |= buf[offs + 1];
1478 offs += 2;
1479 }
1480 }
1481
1482 wdata->extension.input = input_allocate_device();
1483 if (!wdata->extension.input)
1484 return -ENOMEM;
1485
1486 ret = device_create_file(&wdata->hdev->dev,
1487 &dev_attr_bboard_calib);
1488 if (ret) {
1489 hid_err(wdata->hdev, "cannot create sysfs attribute\n");
1490 goto err_free;
1491 }
1492
1493 input_set_drvdata(wdata->extension.input, wdata);
1494 wdata->extension.input->open = wiimod_bboard_open;
1495 wdata->extension.input->close = wiimod_bboard_close;
1496 wdata->extension.input->dev.parent = &wdata->hdev->dev;
1497 wdata->extension.input->id.bustype = wdata->hdev->bus;
1498 wdata->extension.input->id.vendor = wdata->hdev->vendor;
1499 wdata->extension.input->id.product = wdata->hdev->product;
1500 wdata->extension.input->id.version = wdata->hdev->version;
1501 wdata->extension.input->name = WIIMOTE_NAME " Balance Board";
1502
1503 set_bit(EV_KEY, wdata->extension.input->evbit);
1504 set_bit(BTN_A, wdata->extension.input->keybit);
1505
1506 set_bit(EV_ABS, wdata->extension.input->evbit);
1507 set_bit(ABS_HAT0X, wdata->extension.input->absbit);
1508 set_bit(ABS_HAT0Y, wdata->extension.input->absbit);
1509 set_bit(ABS_HAT1X, wdata->extension.input->absbit);
1510 set_bit(ABS_HAT1Y, wdata->extension.input->absbit);
1511 input_set_abs_params(wdata->extension.input,
1512 ABS_HAT0X, 0, 65535, 2, 4);
1513 input_set_abs_params(wdata->extension.input,
1514 ABS_HAT0Y, 0, 65535, 2, 4);
1515 input_set_abs_params(wdata->extension.input,
1516 ABS_HAT1X, 0, 65535, 2, 4);
1517 input_set_abs_params(wdata->extension.input,
1518 ABS_HAT1Y, 0, 65535, 2, 4);
1519
1520 ret = input_register_device(wdata->extension.input);
1521 if (ret)
1522 goto err_file;
1523
1524 return 0;
1525
1526err_file:
1527 device_remove_file(&wdata->hdev->dev,
1528 &dev_attr_bboard_calib);
1529err_free:
1530 input_free_device(wdata->extension.input);
1531 wdata->extension.input = NULL;
1532 return ret;
1533}
1534
1535static void wiimod_bboard_remove(const struct wiimod_ops *ops,
1536 struct wiimote_data *wdata)
1537{
1538 if (!wdata->extension.input)
1539 return;
1540
1541 input_unregister_device(wdata->extension.input);
1542 wdata->extension.input = NULL;
1543 device_remove_file(&wdata->hdev->dev,
1544 &dev_attr_bboard_calib);
1545}
1546
1547static const struct wiimod_ops wiimod_bboard = {
1548 .flags = WIIMOD_FLAG_EXT8,
1549 .arg = 0,
1550 .probe = wiimod_bboard_probe,
1551 .remove = wiimod_bboard_remove,
1552 .in_keys = wiimod_bboard_in_keys,
1553 .in_ext = wiimod_bboard_in_ext,
1554};
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566enum wiimod_pro_keys {
1567 WIIMOD_PRO_KEY_A,
1568 WIIMOD_PRO_KEY_B,
1569 WIIMOD_PRO_KEY_X,
1570 WIIMOD_PRO_KEY_Y,
1571 WIIMOD_PRO_KEY_PLUS,
1572 WIIMOD_PRO_KEY_MINUS,
1573 WIIMOD_PRO_KEY_HOME,
1574 WIIMOD_PRO_KEY_LEFT,
1575 WIIMOD_PRO_KEY_RIGHT,
1576 WIIMOD_PRO_KEY_UP,
1577 WIIMOD_PRO_KEY_DOWN,
1578 WIIMOD_PRO_KEY_TL,
1579 WIIMOD_PRO_KEY_TR,
1580 WIIMOD_PRO_KEY_ZL,
1581 WIIMOD_PRO_KEY_ZR,
1582 WIIMOD_PRO_KEY_THUMBL,
1583 WIIMOD_PRO_KEY_THUMBR,
1584 WIIMOD_PRO_KEY_NUM,
1585};
1586
1587static const __u16 wiimod_pro_map[] = {
1588 BTN_EAST,
1589 BTN_SOUTH,
1590 BTN_NORTH,
1591 BTN_WEST,
1592 BTN_START,
1593 BTN_SELECT,
1594 BTN_MODE,
1595 BTN_DPAD_LEFT,
1596 BTN_DPAD_RIGHT,
1597 BTN_DPAD_UP,
1598 BTN_DPAD_DOWN,
1599 BTN_TL,
1600 BTN_TR,
1601 BTN_TL2,
1602 BTN_TR2,
1603 BTN_THUMBL,
1604 BTN_THUMBR,
1605};
1606
1607static void wiimod_pro_in_ext(struct wiimote_data *wdata, const __u8 *ext)
1608{
1609 __s16 rx, ry, lx, ly;
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652 lx = (ext[0] & 0xff) | ((ext[1] & 0x0f) << 8);
1653 rx = (ext[2] & 0xff) | ((ext[3] & 0x0f) << 8);
1654 ly = (ext[4] & 0xff) | ((ext[5] & 0x0f) << 8);
1655 ry = (ext[6] & 0xff) | ((ext[7] & 0x0f) << 8);
1656
1657
1658 lx -= 0x800;
1659 ly = 0x800 - ly;
1660 rx -= 0x800;
1661 ry = 0x800 - ry;
1662
1663
1664
1665
1666
1667
1668 if (!(wdata->state.flags & WIIPROTO_FLAG_PRO_CALIB_DONE)) {
1669 wdata->state.flags |= WIIPROTO_FLAG_PRO_CALIB_DONE;
1670 if (abs(lx) < 500)
1671 wdata->state.calib_pro_sticks[0] = -lx;
1672 if (abs(ly) < 500)
1673 wdata->state.calib_pro_sticks[1] = -ly;
1674 if (abs(rx) < 500)
1675 wdata->state.calib_pro_sticks[2] = -rx;
1676 if (abs(ry) < 500)
1677 wdata->state.calib_pro_sticks[3] = -ry;
1678 }
1679
1680
1681 lx += wdata->state.calib_pro_sticks[0];
1682 ly += wdata->state.calib_pro_sticks[1];
1683 rx += wdata->state.calib_pro_sticks[2];
1684 ry += wdata->state.calib_pro_sticks[3];
1685
1686 input_report_abs(wdata->extension.input, ABS_X, lx);
1687 input_report_abs(wdata->extension.input, ABS_Y, ly);
1688 input_report_abs(wdata->extension.input, ABS_RX, rx);
1689 input_report_abs(wdata->extension.input, ABS_RY, ry);
1690
1691 input_report_key(wdata->extension.input,
1692 wiimod_pro_map[WIIMOD_PRO_KEY_RIGHT],
1693 !(ext[8] & 0x80));
1694 input_report_key(wdata->extension.input,
1695 wiimod_pro_map[WIIMOD_PRO_KEY_DOWN],
1696 !(ext[8] & 0x40));
1697 input_report_key(wdata->extension.input,
1698 wiimod_pro_map[WIIMOD_PRO_KEY_TL],
1699 !(ext[8] & 0x20));
1700 input_report_key(wdata->extension.input,
1701 wiimod_pro_map[WIIMOD_PRO_KEY_MINUS],
1702 !(ext[8] & 0x10));
1703 input_report_key(wdata->extension.input,
1704 wiimod_pro_map[WIIMOD_PRO_KEY_HOME],
1705 !(ext[8] & 0x08));
1706 input_report_key(wdata->extension.input,
1707 wiimod_pro_map[WIIMOD_PRO_KEY_PLUS],
1708 !(ext[8] & 0x04));
1709 input_report_key(wdata->extension.input,
1710 wiimod_pro_map[WIIMOD_PRO_KEY_TR],
1711 !(ext[8] & 0x02));
1712
1713 input_report_key(wdata->extension.input,
1714 wiimod_pro_map[WIIMOD_PRO_KEY_ZL],
1715 !(ext[9] & 0x80));
1716 input_report_key(wdata->extension.input,
1717 wiimod_pro_map[WIIMOD_PRO_KEY_B],
1718 !(ext[9] & 0x40));
1719 input_report_key(wdata->extension.input,
1720 wiimod_pro_map[WIIMOD_PRO_KEY_Y],
1721 !(ext[9] & 0x20));
1722 input_report_key(wdata->extension.input,
1723 wiimod_pro_map[WIIMOD_PRO_KEY_A],
1724 !(ext[9] & 0x10));
1725 input_report_key(wdata->extension.input,
1726 wiimod_pro_map[WIIMOD_PRO_KEY_X],
1727 !(ext[9] & 0x08));
1728 input_report_key(wdata->extension.input,
1729 wiimod_pro_map[WIIMOD_PRO_KEY_ZR],
1730 !(ext[9] & 0x04));
1731 input_report_key(wdata->extension.input,
1732 wiimod_pro_map[WIIMOD_PRO_KEY_LEFT],
1733 !(ext[9] & 0x02));
1734 input_report_key(wdata->extension.input,
1735 wiimod_pro_map[WIIMOD_PRO_KEY_UP],
1736 !(ext[9] & 0x01));
1737
1738 input_report_key(wdata->extension.input,
1739 wiimod_pro_map[WIIMOD_PRO_KEY_THUMBL],
1740 !(ext[10] & 0x02));
1741 input_report_key(wdata->extension.input,
1742 wiimod_pro_map[WIIMOD_PRO_KEY_THUMBR],
1743 !(ext[10] & 0x01));
1744
1745 input_sync(wdata->extension.input);
1746}
1747
1748static int wiimod_pro_open(struct input_dev *dev)
1749{
1750 struct wiimote_data *wdata = input_get_drvdata(dev);
1751 unsigned long flags;
1752
1753 spin_lock_irqsave(&wdata->state.lock, flags);
1754 wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
1755 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1756 spin_unlock_irqrestore(&wdata->state.lock, flags);
1757
1758 return 0;
1759}
1760
1761static void wiimod_pro_close(struct input_dev *dev)
1762{
1763 struct wiimote_data *wdata = input_get_drvdata(dev);
1764 unsigned long flags;
1765
1766 spin_lock_irqsave(&wdata->state.lock, flags);
1767 wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
1768 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1769 spin_unlock_irqrestore(&wdata->state.lock, flags);
1770}
1771
1772static int wiimod_pro_play(struct input_dev *dev, void *data,
1773 struct ff_effect *eff)
1774{
1775 struct wiimote_data *wdata = input_get_drvdata(dev);
1776 __u8 value;
1777
1778
1779
1780
1781
1782
1783
1784 if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
1785 value = 1;
1786 else
1787 value = 0;
1788
1789
1790
1791 wdata->state.cache_rumble = value;
1792 schedule_work(&wdata->rumble_worker);
1793
1794 return 0;
1795}
1796
1797static ssize_t wiimod_pro_calib_show(struct device *dev,
1798 struct device_attribute *attr,
1799 char *out)
1800{
1801 struct wiimote_data *wdata = dev_to_wii(dev);
1802 int r;
1803
1804 r = 0;
1805 r += sprintf(&out[r], "%+06hd:", wdata->state.calib_pro_sticks[0]);
1806 r += sprintf(&out[r], "%+06hd ", wdata->state.calib_pro_sticks[1]);
1807 r += sprintf(&out[r], "%+06hd:", wdata->state.calib_pro_sticks[2]);
1808 r += sprintf(&out[r], "%+06hd\n", wdata->state.calib_pro_sticks[3]);
1809
1810 return r;
1811}
1812
1813static ssize_t wiimod_pro_calib_store(struct device *dev,
1814 struct device_attribute *attr,
1815 const char *buf, size_t count)
1816{
1817 struct wiimote_data *wdata = dev_to_wii(dev);
1818 int r;
1819 s16 x1, y1, x2, y2;
1820
1821 if (!strncmp(buf, "scan\n", 5)) {
1822 spin_lock_irq(&wdata->state.lock);
1823 wdata->state.flags &= ~WIIPROTO_FLAG_PRO_CALIB_DONE;
1824 spin_unlock_irq(&wdata->state.lock);
1825 } else {
1826 r = sscanf(buf, "%hd:%hd %hd:%hd", &x1, &y1, &x2, &y2);
1827 if (r != 4)
1828 return -EINVAL;
1829
1830 spin_lock_irq(&wdata->state.lock);
1831 wdata->state.flags |= WIIPROTO_FLAG_PRO_CALIB_DONE;
1832 spin_unlock_irq(&wdata->state.lock);
1833
1834 wdata->state.calib_pro_sticks[0] = x1;
1835 wdata->state.calib_pro_sticks[1] = y1;
1836 wdata->state.calib_pro_sticks[2] = x2;
1837 wdata->state.calib_pro_sticks[3] = y2;
1838 }
1839
1840 return strnlen(buf, PAGE_SIZE);
1841}
1842
1843static DEVICE_ATTR(pro_calib, S_IRUGO|S_IWUSR|S_IWGRP, wiimod_pro_calib_show,
1844 wiimod_pro_calib_store);
1845
1846static int wiimod_pro_probe(const struct wiimod_ops *ops,
1847 struct wiimote_data *wdata)
1848{
1849 int ret, i;
1850 unsigned long flags;
1851
1852 INIT_WORK(&wdata->rumble_worker, wiimod_rumble_worker);
1853 wdata->state.calib_pro_sticks[0] = 0;
1854 wdata->state.calib_pro_sticks[1] = 0;
1855 wdata->state.calib_pro_sticks[2] = 0;
1856 wdata->state.calib_pro_sticks[3] = 0;
1857
1858 spin_lock_irqsave(&wdata->state.lock, flags);
1859 wdata->state.flags &= ~WIIPROTO_FLAG_PRO_CALIB_DONE;
1860 spin_unlock_irqrestore(&wdata->state.lock, flags);
1861
1862 wdata->extension.input = input_allocate_device();
1863 if (!wdata->extension.input)
1864 return -ENOMEM;
1865
1866 set_bit(FF_RUMBLE, wdata->extension.input->ffbit);
1867 input_set_drvdata(wdata->extension.input, wdata);
1868
1869 if (input_ff_create_memless(wdata->extension.input, NULL,
1870 wiimod_pro_play)) {
1871 ret = -ENOMEM;
1872 goto err_free;
1873 }
1874
1875 ret = device_create_file(&wdata->hdev->dev,
1876 &dev_attr_pro_calib);
1877 if (ret) {
1878 hid_err(wdata->hdev, "cannot create sysfs attribute\n");
1879 goto err_free;
1880 }
1881
1882 wdata->extension.input->open = wiimod_pro_open;
1883 wdata->extension.input->close = wiimod_pro_close;
1884 wdata->extension.input->dev.parent = &wdata->hdev->dev;
1885 wdata->extension.input->id.bustype = wdata->hdev->bus;
1886 wdata->extension.input->id.vendor = wdata->hdev->vendor;
1887 wdata->extension.input->id.product = wdata->hdev->product;
1888 wdata->extension.input->id.version = wdata->hdev->version;
1889 wdata->extension.input->name = WIIMOTE_NAME " Pro Controller";
1890
1891 set_bit(EV_KEY, wdata->extension.input->evbit);
1892 for (i = 0; i < WIIMOD_PRO_KEY_NUM; ++i)
1893 set_bit(wiimod_pro_map[i],
1894 wdata->extension.input->keybit);
1895
1896 set_bit(EV_ABS, wdata->extension.input->evbit);
1897 set_bit(ABS_X, wdata->extension.input->absbit);
1898 set_bit(ABS_Y, wdata->extension.input->absbit);
1899 set_bit(ABS_RX, wdata->extension.input->absbit);
1900 set_bit(ABS_RY, wdata->extension.input->absbit);
1901 input_set_abs_params(wdata->extension.input,
1902 ABS_X, -0x400, 0x400, 4, 100);
1903 input_set_abs_params(wdata->extension.input,
1904 ABS_Y, -0x400, 0x400, 4, 100);
1905 input_set_abs_params(wdata->extension.input,
1906 ABS_RX, -0x400, 0x400, 4, 100);
1907 input_set_abs_params(wdata->extension.input,
1908 ABS_RY, -0x400, 0x400, 4, 100);
1909
1910 ret = input_register_device(wdata->extension.input);
1911 if (ret)
1912 goto err_file;
1913
1914 return 0;
1915
1916err_file:
1917 device_remove_file(&wdata->hdev->dev,
1918 &dev_attr_pro_calib);
1919err_free:
1920 input_free_device(wdata->extension.input);
1921 wdata->extension.input = NULL;
1922 return ret;
1923}
1924
1925static void wiimod_pro_remove(const struct wiimod_ops *ops,
1926 struct wiimote_data *wdata)
1927{
1928 unsigned long flags;
1929
1930 if (!wdata->extension.input)
1931 return;
1932
1933 input_unregister_device(wdata->extension.input);
1934 wdata->extension.input = NULL;
1935 cancel_work_sync(&wdata->rumble_worker);
1936 device_remove_file(&wdata->hdev->dev,
1937 &dev_attr_pro_calib);
1938
1939 spin_lock_irqsave(&wdata->state.lock, flags);
1940 wiiproto_req_rumble(wdata, 0);
1941 spin_unlock_irqrestore(&wdata->state.lock, flags);
1942}
1943
1944static const struct wiimod_ops wiimod_pro = {
1945 .flags = WIIMOD_FLAG_EXT16,
1946 .arg = 0,
1947 .probe = wiimod_pro_probe,
1948 .remove = wiimod_pro_remove,
1949 .in_ext = wiimod_pro_in_ext,
1950};
1951
1952
1953
1954
1955
1956
1957
1958
1959static int wiimod_builtin_mp_probe(const struct wiimod_ops *ops,
1960 struct wiimote_data *wdata)
1961{
1962 unsigned long flags;
1963
1964 spin_lock_irqsave(&wdata->state.lock, flags);
1965 wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP;
1966 spin_unlock_irqrestore(&wdata->state.lock, flags);
1967
1968 return 0;
1969}
1970
1971static void wiimod_builtin_mp_remove(const struct wiimod_ops *ops,
1972 struct wiimote_data *wdata)
1973{
1974 unsigned long flags;
1975
1976 spin_lock_irqsave(&wdata->state.lock, flags);
1977 wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP;
1978 spin_unlock_irqrestore(&wdata->state.lock, flags);
1979}
1980
1981static const struct wiimod_ops wiimod_builtin_mp = {
1982 .flags = 0,
1983 .arg = 0,
1984 .probe = wiimod_builtin_mp_probe,
1985 .remove = wiimod_builtin_mp_remove,
1986};
1987
1988
1989
1990
1991
1992
1993
1994
1995static int wiimod_no_mp_probe(const struct wiimod_ops *ops,
1996 struct wiimote_data *wdata)
1997{
1998 unsigned long flags;
1999
2000 spin_lock_irqsave(&wdata->state.lock, flags);
2001 wdata->state.flags |= WIIPROTO_FLAG_NO_MP;
2002 spin_unlock_irqrestore(&wdata->state.lock, flags);
2003
2004 return 0;
2005}
2006
2007static void wiimod_no_mp_remove(const struct wiimod_ops *ops,
2008 struct wiimote_data *wdata)
2009{
2010 unsigned long flags;
2011
2012 spin_lock_irqsave(&wdata->state.lock, flags);
2013 wdata->state.flags |= WIIPROTO_FLAG_NO_MP;
2014 spin_unlock_irqrestore(&wdata->state.lock, flags);
2015}
2016
2017static const struct wiimod_ops wiimod_no_mp = {
2018 .flags = 0,
2019 .arg = 0,
2020 .probe = wiimod_no_mp_probe,
2021 .remove = wiimod_no_mp_remove,
2022};
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034static void wiimod_mp_in_mp(struct wiimote_data *wdata, const __u8 *ext)
2035{
2036 __s32 x, y, z;
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062 x = ext[0];
2063 y = ext[1];
2064 z = ext[2];
2065
2066 x |= (((__u16)ext[3]) << 6) & 0xff00;
2067 y |= (((__u16)ext[4]) << 6) & 0xff00;
2068 z |= (((__u16)ext[5]) << 6) & 0xff00;
2069
2070 x -= 8192;
2071 y -= 8192;
2072 z -= 8192;
2073
2074 if (!(ext[3] & 0x02))
2075 x = (x * 2000 * 9) / 440;
2076 else
2077 x *= 9;
2078 if (!(ext[4] & 0x02))
2079 y = (y * 2000 * 9) / 440;
2080 else
2081 y *= 9;
2082 if (!(ext[3] & 0x01))
2083 z = (z * 2000 * 9) / 440;
2084 else
2085 z *= 9;
2086
2087 input_report_abs(wdata->mp, ABS_RX, x);
2088 input_report_abs(wdata->mp, ABS_RY, y);
2089 input_report_abs(wdata->mp, ABS_RZ, z);
2090 input_sync(wdata->mp);
2091}
2092
2093static int wiimod_mp_open(struct input_dev *dev)
2094{
2095 struct wiimote_data *wdata = input_get_drvdata(dev);
2096 unsigned long flags;
2097
2098 spin_lock_irqsave(&wdata->state.lock, flags);
2099 wdata->state.flags |= WIIPROTO_FLAG_MP_USED;
2100 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
2101 __wiimote_schedule(wdata);
2102 spin_unlock_irqrestore(&wdata->state.lock, flags);
2103
2104 return 0;
2105}
2106
2107static void wiimod_mp_close(struct input_dev *dev)
2108{
2109 struct wiimote_data *wdata = input_get_drvdata(dev);
2110 unsigned long flags;
2111
2112 spin_lock_irqsave(&wdata->state.lock, flags);
2113 wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED;
2114 wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
2115 __wiimote_schedule(wdata);
2116 spin_unlock_irqrestore(&wdata->state.lock, flags);
2117}
2118
2119static int wiimod_mp_probe(const struct wiimod_ops *ops,
2120 struct wiimote_data *wdata)
2121{
2122 int ret;
2123
2124 wdata->mp = input_allocate_device();
2125 if (!wdata->mp)
2126 return -ENOMEM;
2127
2128 input_set_drvdata(wdata->mp, wdata);
2129 wdata->mp->open = wiimod_mp_open;
2130 wdata->mp->close = wiimod_mp_close;
2131 wdata->mp->dev.parent = &wdata->hdev->dev;
2132 wdata->mp->id.bustype = wdata->hdev->bus;
2133 wdata->mp->id.vendor = wdata->hdev->vendor;
2134 wdata->mp->id.product = wdata->hdev->product;
2135 wdata->mp->id.version = wdata->hdev->version;
2136 wdata->mp->name = WIIMOTE_NAME " Motion Plus";
2137
2138 set_bit(EV_ABS, wdata->mp->evbit);
2139 set_bit(ABS_RX, wdata->mp->absbit);
2140 set_bit(ABS_RY, wdata->mp->absbit);
2141 set_bit(ABS_RZ, wdata->mp->absbit);
2142 input_set_abs_params(wdata->mp,
2143 ABS_RX, -16000, 16000, 4, 8);
2144 input_set_abs_params(wdata->mp,
2145 ABS_RY, -16000, 16000, 4, 8);
2146 input_set_abs_params(wdata->mp,
2147 ABS_RZ, -16000, 16000, 4, 8);
2148
2149 ret = input_register_device(wdata->mp);
2150 if (ret)
2151 goto err_free;
2152
2153 return 0;
2154
2155err_free:
2156 input_free_device(wdata->mp);
2157 wdata->mp = NULL;
2158 return ret;
2159}
2160
2161static void wiimod_mp_remove(const struct wiimod_ops *ops,
2162 struct wiimote_data *wdata)
2163{
2164 if (!wdata->mp)
2165 return;
2166
2167 input_unregister_device(wdata->mp);
2168 wdata->mp = NULL;
2169}
2170
2171const struct wiimod_ops wiimod_mp = {
2172 .flags = 0,
2173 .arg = 0,
2174 .probe = wiimod_mp_probe,
2175 .remove = wiimod_mp_remove,
2176 .in_mp = wiimod_mp_in_mp,
2177};
2178
2179
2180
2181static const struct wiimod_ops wiimod_dummy;
2182
2183const struct wiimod_ops *wiimod_table[WIIMOD_NUM] = {
2184 [WIIMOD_KEYS] = &wiimod_keys,
2185 [WIIMOD_RUMBLE] = &wiimod_rumble,
2186 [WIIMOD_BATTERY] = &wiimod_battery,
2187 [WIIMOD_LED1] = &wiimod_leds[0],
2188 [WIIMOD_LED2] = &wiimod_leds[1],
2189 [WIIMOD_LED3] = &wiimod_leds[2],
2190 [WIIMOD_LED4] = &wiimod_leds[3],
2191 [WIIMOD_ACCEL] = &wiimod_accel,
2192 [WIIMOD_IR] = &wiimod_ir,
2193 [WIIMOD_BUILTIN_MP] = &wiimod_builtin_mp,
2194 [WIIMOD_NO_MP] = &wiimod_no_mp,
2195};
2196
2197const struct wiimod_ops *wiimod_ext_table[WIIMOTE_EXT_NUM] = {
2198 [WIIMOTE_EXT_NONE] = &wiimod_dummy,
2199 [WIIMOTE_EXT_UNKNOWN] = &wiimod_dummy,
2200 [WIIMOTE_EXT_NUNCHUK] = &wiimod_nunchuk,
2201 [WIIMOTE_EXT_CLASSIC_CONTROLLER] = &wiimod_classic,
2202 [WIIMOTE_EXT_BALANCE_BOARD] = &wiimod_bboard,
2203 [WIIMOTE_EXT_PRO_CONTROLLER] = &wiimod_pro,
2204};
2205