2 * Device Modules for Nintendo Wii / Wii U HID Driver
3 * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the Free
9 * Software Foundation; either version 2 of the License, or (at your option)
15 * Nintendo devices provide different peripherals and many new devices lack
16 * initial features like the IR camera. Therefore, each peripheral device is
17 * implemented as an independent module and we probe on each device only the
18 * modules for the hardware that really is available.
20 * Module registration is sequential. Unregistration is done in reverse order.
21 * After device detection, the needed modules are loaded. Users can trigger
22 * re-detection which causes all modules to be unloaded and then reload the
23 * modules for the new detected device.
25 * wdata->input is a shared input device. It is always initialized prior to
26 * module registration. If at least one registered module is marked as
27 * WIIMOD_FLAG_INPUT, then the input device will get registered after all
28 * modules were registered.
29 * Please note that it is unregistered _before_ the "remove" callbacks are
30 * called. This guarantees that no input interaction is done, anymore. However,
31 * the wiimote core keeps a reference to the input device so it is freed only
32 * after all modules were removed. It is safe to send events to unregistered
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"
44 * The initial Wii Remote provided a bunch of buttons that are reported as
45 * part of the core protocol. Many later devices dropped these and report
46 * invalid data in the core button reports. Load this only on devices which
47 * correctly send button reports.
48 * It uses the shared input device.
51 static const __u16 wiimod_keys_map
[] = {
52 KEY_LEFT
, /* WIIPROTO_KEY_LEFT */
53 KEY_RIGHT
, /* WIIPROTO_KEY_RIGHT */
54 KEY_UP
, /* WIIPROTO_KEY_UP */
55 KEY_DOWN
, /* WIIPROTO_KEY_DOWN */
56 KEY_NEXT
, /* WIIPROTO_KEY_PLUS */
57 KEY_PREVIOUS
, /* WIIPROTO_KEY_MINUS */
58 BTN_1
, /* WIIPROTO_KEY_ONE */
59 BTN_2
, /* WIIPROTO_KEY_TWO */
60 BTN_A
, /* WIIPROTO_KEY_A */
61 BTN_B
, /* WIIPROTO_KEY_B */
62 BTN_MODE
, /* WIIPROTO_KEY_HOME */
65 static void wiimod_keys_in_keys(struct wiimote_data
*wdata
, const __u8
*keys
)
67 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_LEFT
],
69 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_RIGHT
],
71 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_DOWN
],
73 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_UP
],
75 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_PLUS
],
77 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_TWO
],
79 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_ONE
],
81 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_B
],
83 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_A
],
85 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_MINUS
],
87 input_report_key(wdata
->input
, wiimod_keys_map
[WIIPROTO_KEY_HOME
],
89 input_sync(wdata
->input
);
92 static int wiimod_keys_probe(const struct wiimod_ops
*ops
,
93 struct wiimote_data
*wdata
)
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
);
104 static const struct wiimod_ops wiimod_keys
= {
105 .flags
= WIIMOD_FLAG_INPUT
,
107 .probe
= wiimod_keys_probe
,
109 .in_keys
= wiimod_keys_in_keys
,
114 * Nearly all devices provide a rumble feature. A small motor for
115 * force-feedback effects. We provide an FF_RUMBLE memless ff device on the
116 * shared input device if this module is loaded.
117 * The rumble motor is controlled via a flag on almost every output report so
118 * the wiimote core handles the rumble flag. But if a device doesn't provide
119 * the rumble motor, this flag shouldn't be set.
122 static int wiimod_rumble_play(struct input_dev
*dev
, void *data
,
123 struct ff_effect
*eff
)
125 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
130 * The wiimote supports only a single rumble motor so if any magnitude
131 * is set to non-zero then we start the rumble motor. If both are set to
132 * zero, we stop the rumble motor.
135 if (eff
->u
.rumble
.strong_magnitude
|| eff
->u
.rumble
.weak_magnitude
)
140 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
141 wiiproto_req_rumble(wdata
, value
);
142 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
147 static int wiimod_rumble_probe(const struct wiimod_ops
*ops
,
148 struct wiimote_data
*wdata
)
150 set_bit(FF_RUMBLE
, wdata
->input
->ffbit
);
151 if (input_ff_create_memless(wdata
->input
, NULL
, wiimod_rumble_play
))
157 static void wiimod_rumble_remove(const struct wiimod_ops
*ops
,
158 struct wiimote_data
*wdata
)
162 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
163 wiiproto_req_rumble(wdata
, 0);
164 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
167 static const struct wiimod_ops wiimod_rumble
= {
168 .flags
= WIIMOD_FLAG_INPUT
,
170 .probe
= wiimod_rumble_probe
,
171 .remove
= wiimod_rumble_remove
,
176 * 1 byte of battery capacity information is sent along every protocol status
177 * report. The wiimote core caches it but we try to update it on every
178 * user-space request.
179 * This is supported by nearly every device so it's almost always enabled.
182 static enum power_supply_property wiimod_battery_props
[] = {
183 POWER_SUPPLY_PROP_CAPACITY
,
184 POWER_SUPPLY_PROP_SCOPE
,
187 static int wiimod_battery_get_property(struct power_supply
*psy
,
188 enum power_supply_property psp
,
189 union power_supply_propval
*val
)
191 struct wiimote_data
*wdata
= container_of(psy
, struct wiimote_data
,
196 if (psp
== POWER_SUPPLY_PROP_SCOPE
) {
197 val
->intval
= POWER_SUPPLY_SCOPE_DEVICE
;
199 } else if (psp
!= POWER_SUPPLY_PROP_CAPACITY
) {
203 ret
= wiimote_cmd_acquire(wdata
);
207 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
208 wiimote_cmd_set(wdata
, WIIPROTO_REQ_SREQ
, 0);
209 wiiproto_req_status(wdata
);
210 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
212 wiimote_cmd_wait(wdata
);
213 wiimote_cmd_release(wdata
);
215 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
216 state
= wdata
->state
.cmd_battery
;
217 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
219 val
->intval
= state
* 100 / 255;
223 static int wiimod_battery_probe(const struct wiimod_ops
*ops
,
224 struct wiimote_data
*wdata
)
228 wdata
->battery
.properties
= wiimod_battery_props
;
229 wdata
->battery
.num_properties
= ARRAY_SIZE(wiimod_battery_props
);
230 wdata
->battery
.get_property
= wiimod_battery_get_property
;
231 wdata
->battery
.type
= POWER_SUPPLY_TYPE_BATTERY
;
232 wdata
->battery
.use_for_apm
= 0;
233 wdata
->battery
.name
= kasprintf(GFP_KERNEL
, "wiimote_battery_%s",
235 if (!wdata
->battery
.name
)
238 ret
= power_supply_register(&wdata
->hdev
->dev
, &wdata
->battery
);
240 hid_err(wdata
->hdev
, "cannot register battery device\n");
244 power_supply_powers(&wdata
->battery
, &wdata
->hdev
->dev
);
248 kfree(wdata
->battery
.name
);
249 wdata
->battery
.name
= NULL
;
253 static void wiimod_battery_remove(const struct wiimod_ops
*ops
,
254 struct wiimote_data
*wdata
)
256 if (!wdata
->battery
.name
)
259 power_supply_unregister(&wdata
->battery
);
260 kfree(wdata
->battery
.name
);
261 wdata
->battery
.name
= NULL
;
264 static const struct wiimod_ops wiimod_battery
= {
267 .probe
= wiimod_battery_probe
,
268 .remove
= wiimod_battery_remove
,
273 * 0 to 4 player LEDs are supported by devices. The "arg" field of the
274 * wiimod_ops structure specifies which LED this module controls. This allows
275 * to register a limited number of LEDs.
276 * State is managed by wiimote core.
279 static enum led_brightness
wiimod_led_get(struct led_classdev
*led_dev
)
281 struct wiimote_data
*wdata
;
282 struct device
*dev
= led_dev
->dev
->parent
;
287 wdata
= hid_get_drvdata(container_of(dev
, struct hid_device
, dev
));
289 for (i
= 0; i
< 4; ++i
) {
290 if (wdata
->leds
[i
] == led_dev
) {
291 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
292 value
= wdata
->state
.flags
& WIIPROTO_FLAG_LED(i
+ 1);
293 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
298 return value
? LED_FULL
: LED_OFF
;
301 static void wiimod_led_set(struct led_classdev
*led_dev
,
302 enum led_brightness value
)
304 struct wiimote_data
*wdata
;
305 struct device
*dev
= led_dev
->dev
->parent
;
310 wdata
= hid_get_drvdata(container_of(dev
, struct hid_device
, dev
));
312 for (i
= 0; i
< 4; ++i
) {
313 if (wdata
->leds
[i
] == led_dev
) {
314 flag
= WIIPROTO_FLAG_LED(i
+ 1);
315 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
316 state
= wdata
->state
.flags
;
317 if (value
== LED_OFF
)
318 wiiproto_req_leds(wdata
, state
& ~flag
);
320 wiiproto_req_leds(wdata
, state
| flag
);
321 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
327 static int wiimod_led_probe(const struct wiimod_ops
*ops
,
328 struct wiimote_data
*wdata
)
330 struct device
*dev
= &wdata
->hdev
->dev
;
331 size_t namesz
= strlen(dev_name(dev
)) + 9;
332 struct led_classdev
*led
;
337 led
= kzalloc(sizeof(struct led_classdev
) + namesz
, GFP_KERNEL
);
341 name
= (void*)&led
[1];
342 snprintf(name
, namesz
, "%s:blue:p%lu", dev_name(dev
), ops
->arg
);
345 led
->max_brightness
= 1;
346 led
->brightness_get
= wiimod_led_get
;
347 led
->brightness_set
= wiimod_led_set
;
349 wdata
->leds
[ops
->arg
] = led
;
350 ret
= led_classdev_register(dev
, led
);
354 /* enable LED1 to stop initial LED-blinking */
356 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
357 wiiproto_req_leds(wdata
, WIIPROTO_FLAG_LED1
);
358 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
364 wdata
->leds
[ops
->arg
] = NULL
;
369 static void wiimod_led_remove(const struct wiimod_ops
*ops
,
370 struct wiimote_data
*wdata
)
372 if (!wdata
->leds
[ops
->arg
])
375 led_classdev_unregister(wdata
->leds
[ops
->arg
]);
376 kfree(wdata
->leds
[ops
->arg
]);
377 wdata
->leds
[ops
->arg
] = NULL
;
380 static const struct wiimod_ops wiimod_leds
[4] = {
384 .probe
= wiimod_led_probe
,
385 .remove
= wiimod_led_remove
,
390 .probe
= wiimod_led_probe
,
391 .remove
= wiimod_led_remove
,
396 .probe
= wiimod_led_probe
,
397 .remove
= wiimod_led_remove
,
402 .probe
= wiimod_led_probe
,
403 .remove
= wiimod_led_remove
,
409 * 3 axis accelerometer data is part of nearly all DRMs. If not supported by a
410 * device, it's mostly cleared to 0. This module parses this data and provides
411 * it via a separate input device.
414 static void wiimod_accel_in_accel(struct wiimote_data
*wdata
,
419 if (!(wdata
->state
.flags
& WIIPROTO_FLAG_ACCEL
))
423 * payload is: BB BB XX YY ZZ
424 * Accelerometer data is encoded into 3 10bit values. XX, YY and ZZ
425 * contain the upper 8 bits of each value. The lower 2 bits are
426 * contained in the buttons data BB BB.
427 * Bits 6 and 7 of the first buttons byte BB is the lower 2 bits of the
428 * X accel value. Bit 5 of the second buttons byte is the 2nd bit of Y
429 * accel value and bit 6 is the second bit of the Z value.
430 * The first bit of Y and Z values is not available and always set to 0.
431 * 0x200 is returned on no movement.
438 x
|= (accel
[0] >> 5) & 0x3;
439 y
|= (accel
[1] >> 4) & 0x2;
440 z
|= (accel
[1] >> 5) & 0x2;
442 input_report_abs(wdata
->accel
, ABS_RX
, x
- 0x200);
443 input_report_abs(wdata
->accel
, ABS_RY
, y
- 0x200);
444 input_report_abs(wdata
->accel
, ABS_RZ
, z
- 0x200);
445 input_sync(wdata
->accel
);
448 static int wiimod_accel_open(struct input_dev
*dev
)
450 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
453 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
454 wiiproto_req_accel(wdata
, true);
455 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
460 static void wiimod_accel_close(struct input_dev
*dev
)
462 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
465 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
466 wiiproto_req_accel(wdata
, false);
467 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
470 static int wiimod_accel_probe(const struct wiimod_ops
*ops
,
471 struct wiimote_data
*wdata
)
475 wdata
->accel
= input_allocate_device();
479 input_set_drvdata(wdata
->accel
, wdata
);
480 wdata
->accel
->open
= wiimod_accel_open
;
481 wdata
->accel
->close
= wiimod_accel_close
;
482 wdata
->accel
->dev
.parent
= &wdata
->hdev
->dev
;
483 wdata
->accel
->id
.bustype
= wdata
->hdev
->bus
;
484 wdata
->accel
->id
.vendor
= wdata
->hdev
->vendor
;
485 wdata
->accel
->id
.product
= wdata
->hdev
->product
;
486 wdata
->accel
->id
.version
= wdata
->hdev
->version
;
487 wdata
->accel
->name
= WIIMOTE_NAME
" Accelerometer";
489 set_bit(EV_ABS
, wdata
->accel
->evbit
);
490 set_bit(ABS_RX
, wdata
->accel
->absbit
);
491 set_bit(ABS_RY
, wdata
->accel
->absbit
);
492 set_bit(ABS_RZ
, wdata
->accel
->absbit
);
493 input_set_abs_params(wdata
->accel
, ABS_RX
, -500, 500, 2, 4);
494 input_set_abs_params(wdata
->accel
, ABS_RY
, -500, 500, 2, 4);
495 input_set_abs_params(wdata
->accel
, ABS_RZ
, -500, 500, 2, 4);
497 ret
= input_register_device(wdata
->accel
);
499 hid_err(wdata
->hdev
, "cannot register input device\n");
506 input_free_device(wdata
->accel
);
511 static void wiimod_accel_remove(const struct wiimod_ops
*ops
,
512 struct wiimote_data
*wdata
)
517 input_unregister_device(wdata
->accel
);
521 static const struct wiimod_ops wiimod_accel
= {
524 .probe
= wiimod_accel_probe
,
525 .remove
= wiimod_accel_remove
,
526 .in_accel
= wiimod_accel_in_accel
,
531 * Up to 4 IR sources can be tracked by a normal Wii Remote. The IR cam needs
532 * to be initialized with a fairly complex procedure and consumes a lot of
533 * power. Therefore, as long as no application uses the IR input device, it is
535 * Nearly no other device than the normal Wii Remotes supports the IR cam so
536 * you can disable this module for these devices.
539 static void wiimod_ir_in_ir(struct wiimote_data
*wdata
, const __u8
*ir
,
540 bool packed
, unsigned int id
)
546 if (!(wdata
->state
.flags
& WIIPROTO_FLAGS_IR
))
572 * Basic IR data is encoded into 3 bytes. The first two bytes are the
573 * lower 8 bit of the X/Y data, the 3rd byte contains the upper 2 bits
575 * If data is packed, then the 3rd byte is put first and slightly
576 * reordered. This allows to interleave packed and non-packed data to
577 * have two IR sets in 5 bytes instead of 6.
578 * The resulting 10bit X/Y values are passed to the ABS_HAT? input dev.
582 x
= ir
[1] | ((ir
[0] & 0x03) << 8);
583 y
= ir
[2] | ((ir
[0] & 0x0c) << 6);
585 x
= ir
[0] | ((ir
[2] & 0x30) << 4);
586 y
= ir
[1] | ((ir
[2] & 0xc0) << 2);
589 input_report_abs(wdata
->ir
, xid
, x
);
590 input_report_abs(wdata
->ir
, yid
, y
);
593 input_sync(wdata
->ir
);
596 static int wiimod_ir_change(struct wiimote_data
*wdata
, __u16 mode
)
601 static const __u8 data_enable
[] = { 0x01 };
602 static const __u8 data_sens1
[] = { 0x02, 0x00, 0x00, 0x71, 0x01,
603 0x00, 0xaa, 0x00, 0x64 };
604 static const __u8 data_sens2
[] = { 0x63, 0x03 };
605 static const __u8 data_fin
[] = { 0x08 };
607 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
609 if (mode
== (wdata
->state
.flags
& WIIPROTO_FLAGS_IR
)) {
610 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
615 wdata
->state
.flags
&= ~WIIPROTO_FLAGS_IR
;
616 wiiproto_req_ir1(wdata
, 0);
617 wiiproto_req_ir2(wdata
, 0);
618 wiiproto_req_drm(wdata
, WIIPROTO_REQ_NULL
);
619 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
623 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
625 ret
= wiimote_cmd_acquire(wdata
);
629 /* send PIXEL CLOCK ENABLE cmd first */
630 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
631 wiimote_cmd_set(wdata
, WIIPROTO_REQ_IR1
, 0);
632 wiiproto_req_ir1(wdata
, 0x06);
633 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
635 ret
= wiimote_cmd_wait(wdata
);
638 if (wdata
->state
.cmd_err
) {
643 /* enable IR LOGIC */
644 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
645 wiimote_cmd_set(wdata
, WIIPROTO_REQ_IR2
, 0);
646 wiiproto_req_ir2(wdata
, 0x06);
647 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
649 ret
= wiimote_cmd_wait(wdata
);
652 if (wdata
->state
.cmd_err
) {
657 /* enable IR cam but do not make it send data, yet */
658 ret
= wiimote_cmd_write(wdata
, 0xb00030, data_enable
,
659 sizeof(data_enable
));
663 /* write first sensitivity block */
664 ret
= wiimote_cmd_write(wdata
, 0xb00000, data_sens1
,
669 /* write second sensitivity block */
670 ret
= wiimote_cmd_write(wdata
, 0xb0001a, data_sens2
,
675 /* put IR cam into desired state */
677 case WIIPROTO_FLAG_IR_FULL
:
680 case WIIPROTO_FLAG_IR_EXT
:
683 case WIIPROTO_FLAG_IR_BASIC
:
687 ret
= wiimote_cmd_write(wdata
, 0xb00033, &format
, sizeof(format
));
691 /* make IR cam send data */
692 ret
= wiimote_cmd_write(wdata
, 0xb00030, data_fin
, sizeof(data_fin
));
696 /* request new DRM mode compatible to IR mode */
697 spin_lock_irqsave(&wdata
->state
.lock
, flags
);
698 wdata
->state
.flags
&= ~WIIPROTO_FLAGS_IR
;
699 wdata
->state
.flags
|= mode
& WIIPROTO_FLAGS_IR
;
700 wiiproto_req_drm(wdata
, WIIPROTO_REQ_NULL
);
701 spin_unlock_irqrestore(&wdata
->state
.lock
, flags
);
704 wiimote_cmd_release(wdata
);
708 static int wiimod_ir_open(struct input_dev
*dev
)
710 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
712 return wiimod_ir_change(wdata
, WIIPROTO_FLAG_IR_BASIC
);
715 static void wiimod_ir_close(struct input_dev
*dev
)
717 struct wiimote_data
*wdata
= input_get_drvdata(dev
);
719 wiimod_ir_change(wdata
, 0);
722 static int wiimod_ir_probe(const struct wiimod_ops
*ops
,
723 struct wiimote_data
*wdata
)
727 wdata
->ir
= input_allocate_device();
731 input_set_drvdata(wdata
->ir
, wdata
);
732 wdata
->ir
->open
= wiimod_ir_open
;
733 wdata
->ir
->close
= wiimod_ir_close
;
734 wdata
->ir
->dev
.parent
= &wdata
->hdev
->dev
;
735 wdata
->ir
->id
.bustype
= wdata
->hdev
->bus
;
736 wdata
->ir
->id
.vendor
= wdata
->hdev
->vendor
;
737 wdata
->ir
->id
.product
= wdata
->hdev
->product
;
738 wdata
->ir
->id
.version
= wdata
->hdev
->version
;
739 wdata
->ir
->name
= WIIMOTE_NAME
" IR";
741 set_bit(EV_ABS
, wdata
->ir
->evbit
);
742 set_bit(ABS_HAT0X
, wdata
->ir
->absbit
);
743 set_bit(ABS_HAT0Y
, wdata
->ir
->absbit
);
744 set_bit(ABS_HAT1X
, wdata
->ir
->absbit
);
745 set_bit(ABS_HAT1Y
, wdata
->ir
->absbit
);
746 set_bit(ABS_HAT2X
, wdata
->ir
->absbit
);
747 set_bit(ABS_HAT2Y
, wdata
->ir
->absbit
);
748 set_bit(ABS_HAT3X
, wdata
->ir
->absbit
);
749 set_bit(ABS_HAT3Y
, wdata
->ir
->absbit
);
750 input_set_abs_params(wdata
->ir
, ABS_HAT0X
, 0, 1023, 2, 4);
751 input_set_abs_params(wdata
->ir
, ABS_HAT0Y
, 0, 767, 2, 4);
752 input_set_abs_params(wdata
->ir
, ABS_HAT1X
, 0, 1023, 2, 4);
753 input_set_abs_params(wdata
->ir
, ABS_HAT1Y
, 0, 767, 2, 4);
754 input_set_abs_params(wdata
->ir
, ABS_HAT2X
, 0, 1023, 2, 4);
755 input_set_abs_params(wdata
->ir
, ABS_HAT2Y
, 0, 767, 2, 4);
756 input_set_abs_params(wdata
->ir
, ABS_HAT3X
, 0, 1023, 2, 4);
757 input_set_abs_params(wdata
->ir
, ABS_HAT3Y
, 0, 767, 2, 4);
759 ret
= input_register_device(wdata
->ir
);
761 hid_err(wdata
->hdev
, "cannot register input device\n");
768 input_free_device(wdata
->ir
);
773 static void wiimod_ir_remove(const struct wiimod_ops
*ops
,
774 struct wiimote_data
*wdata
)
779 input_unregister_device(wdata
->ir
);
783 static const struct wiimod_ops wiimod_ir
= {
786 .probe
= wiimod_ir_probe
,
787 .remove
= wiimod_ir_remove
,
788 .in_ir
= wiimod_ir_in_ir
,
793 const struct wiimod_ops
*wiimod_table
[WIIMOD_NUM
] = {
794 [WIIMOD_KEYS
] = &wiimod_keys
,
795 [WIIMOD_RUMBLE
] = &wiimod_rumble
,
796 [WIIMOD_BATTERY
] = &wiimod_battery
,
797 [WIIMOD_LED1
] = &wiimod_leds
[0],
798 [WIIMOD_LED2
] = &wiimod_leds
[1],
799 [WIIMOD_LED3
] = &wiimod_leds
[2],
800 [WIIMOD_LED4
] = &wiimod_leds
[3],
801 [WIIMOD_ACCEL
] = &wiimod_accel
,
802 [WIIMOD_IR
] = &wiimod_ir
,