1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Device Modules for Nintendo Wii / Wii U HID Driver
4  * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
5  */
6 
7 /*
8  */
9 
10 /*
11  * Wiimote Modules
12  * Nintendo devices provide different peripherals and many new devices lack
13  * initial features like the IR camera. Therefore, each peripheral device is
14  * implemented as an independent module and we probe on each device only the
15  * modules for the hardware that really is available.
16  *
17  * Module registration is sequential. Unregistration is done in reverse order.
18  * After device detection, the needed modules are loaded. Users can trigger
19  * re-detection which causes all modules to be unloaded and then reload the
20  * modules for the new detected device.
21  *
22  * wdata->input is a shared input device. It is always initialized prior to
23  * module registration. If at least one registered module is marked as
24  * WIIMOD_FLAG_INPUT, then the input device will get registered after all
25  * modules were registered.
26  * Please note that it is unregistered _before_ the "remove" callbacks are
27  * called. This guarantees that no input interaction is done, anymore. However,
28  * the wiimote core keeps a reference to the input device so it is freed only
29  * after all modules were removed. It is safe to send events to unregistered
30  * input devices.
31  */
32 
33 #include <linux/device.h>
34 #include <linux/hid.h>
35 #include <linux/input.h>
36 #include <linux/spinlock.h>
37 #include "hid-wiimote.h"
38 
39 /*
40  * Keys
41  * The initial Wii Remote provided a bunch of buttons that are reported as
42  * part of the core protocol. Many later devices dropped these and report
43  * invalid data in the core button reports. Load this only on devices which
44  * correctly send button reports.
45  * It uses the shared input device.
46  */
47 
48 static const __u16 wiimod_keys_map[] = {
49 	KEY_LEFT,	/* WIIPROTO_KEY_LEFT */
50 	KEY_RIGHT,	/* WIIPROTO_KEY_RIGHT */
51 	KEY_UP,		/* WIIPROTO_KEY_UP */
52 	KEY_DOWN,	/* WIIPROTO_KEY_DOWN */
53 	KEY_NEXT,	/* WIIPROTO_KEY_PLUS */
54 	KEY_PREVIOUS,	/* WIIPROTO_KEY_MINUS */
55 	BTN_1,		/* WIIPROTO_KEY_ONE */
56 	BTN_2,		/* WIIPROTO_KEY_TWO */
57 	BTN_A,		/* WIIPROTO_KEY_A */
58 	BTN_B,		/* WIIPROTO_KEY_B */
59 	BTN_MODE,	/* WIIPROTO_KEY_HOME */
60 };
61 
62 static void wiimod_keys_in_keys(struct wiimote_data *wdata, const __u8 *keys)
63 {
64 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_LEFT],
65 							!!(keys[0] & 0x01));
66 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_RIGHT],
67 							!!(keys[0] & 0x02));
68 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_DOWN],
69 							!!(keys[0] & 0x04));
70 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_UP],
71 							!!(keys[0] & 0x08));
72 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_PLUS],
73 							!!(keys[0] & 0x10));
74 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_TWO],
75 							!!(keys[1] & 0x01));
76 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_ONE],
77 							!!(keys[1] & 0x02));
78 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_B],
79 							!!(keys[1] & 0x04));
80 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_A],
81 							!!(keys[1] & 0x08));
82 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_MINUS],
83 							!!(keys[1] & 0x10));
84 	input_report_key(wdata->input, wiimod_keys_map[WIIPROTO_KEY_HOME],
85 							!!(keys[1] & 0x80));
86 	input_sync(wdata->input);
87 }
88 
89 static int wiimod_keys_probe(const struct wiimod_ops *ops,
90 			     struct wiimote_data *wdata)
91 {
92 	unsigned int i;
93 
94 	set_bit(EV_KEY, wdata->input->evbit);
95 	for (i = 0; i < WIIPROTO_KEY_COUNT; ++i)
96 		set_bit(wiimod_keys_map[i], wdata->input->keybit);
97 
98 	return 0;
99 }
100 
101 static const struct wiimod_ops wiimod_keys = {
102 	.flags = WIIMOD_FLAG_INPUT,
103 	.arg = 0,
104 	.probe = wiimod_keys_probe,
105 	.remove = NULL,
106 	.in_keys = wiimod_keys_in_keys,
107 };
108 
109 /*
110  * Rumble
111  * Nearly all devices provide a rumble feature. A small motor for
112  * force-feedback effects. We provide an FF_RUMBLE memless ff device on the
113  * shared input device if this module is loaded.
114  * The rumble motor is controlled via a flag on almost every output report so
115  * the wiimote core handles the rumble flag. But if a device doesn't provide
116  * the rumble motor, this flag shouldn't be set.
117  */
118 
119 /* used by wiimod_rumble and wiipro_rumble */
120 static void wiimod_rumble_worker(struct work_struct *work)
121 {
122 	struct wiimote_data *wdata = container_of(work, struct wiimote_data,
123 						  rumble_worker);
124 
125 	spin_lock_irq(&wdata->state.lock);
126 	wiiproto_req_rumble(wdata, wdata->state.cache_rumble);
127 	spin_unlock_irq(&wdata->state.lock);
128 }
129 
130 static int wiimod_rumble_play(struct input_dev *dev, void *data,
131 			      struct ff_effect *eff)
132 {
133 	struct wiimote_data *wdata = input_get_drvdata(dev);
134 	__u8 value;
135 
136 	/*
137 	 * The wiimote supports only a single rumble motor so if any magnitude
138 	 * is set to non-zero then we start the rumble motor. If both are set to
139 	 * zero, we stop the rumble motor.
140 	 */
141 
142 	if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
143 		value = 1;
144 	else
145 		value = 0;
146 
147 	/* Locking state.lock here might deadlock with input_event() calls.
148 	 * schedule_work acts as barrier. Merging multiple changes is fine. */
149 	wdata->state.cache_rumble = value;
150 	schedule_work(&wdata->rumble_worker);
151 
152 	return 0;
153 }
154 
155 static int wiimod_rumble_probe(const struct wiimod_ops *ops,
156 			       struct wiimote_data *wdata)
157 {
158 	INIT_WORK(&wdata->rumble_worker, wiimod_rumble_worker);
159 
160 	set_bit(FF_RUMBLE, wdata->input->ffbit);
161 	if (input_ff_create_memless(wdata->input, NULL, wiimod_rumble_play))
162 		return -ENOMEM;
163 
164 	return 0;
165 }
166 
167 static void wiimod_rumble_remove(const struct wiimod_ops *ops,
168 				 struct wiimote_data *wdata)
169 {
170 	unsigned long flags;
171 
172 	cancel_work_sync(&wdata->rumble_worker);
173 
174 	spin_lock_irqsave(&wdata->state.lock, flags);
175 	wiiproto_req_rumble(wdata, 0);
176 	spin_unlock_irqrestore(&wdata->state.lock, flags);
177 }
178 
179 static const struct wiimod_ops wiimod_rumble = {
180 	.flags = WIIMOD_FLAG_INPUT,
181 	.arg = 0,
182 	.probe = wiimod_rumble_probe,
183 	.remove = wiimod_rumble_remove,
184 };
185 
186 /*
187  * Battery
188  * 1 byte of battery capacity information is sent along every protocol status
189  * report. The wiimote core caches it but we try to update it on every
190  * user-space request.
191  * This is supported by nearly every device so it's almost always enabled.
192  */
193 
194 static enum power_supply_property wiimod_battery_props[] = {
195 	POWER_SUPPLY_PROP_CAPACITY,
196 	POWER_SUPPLY_PROP_SCOPE,
197 };
198 
199 static int wiimod_battery_get_property(struct power_supply *psy,
200 				       enum power_supply_property psp,
201 				       union power_supply_propval *val)
202 {
203 	struct wiimote_data *wdata = power_supply_get_drvdata(psy);
204 	int ret = 0, state;
205 	unsigned long flags;
206 
207 	if (psp == POWER_SUPPLY_PROP_SCOPE) {
208 		val->intval = POWER_SUPPLY_SCOPE_DEVICE;
209 		return 0;
210 	} else if (psp != POWER_SUPPLY_PROP_CAPACITY) {
211 		return -EINVAL;
212 	}
213 
214 	ret = wiimote_cmd_acquire(wdata);
215 	if (ret)
216 		return ret;
217 
218 	spin_lock_irqsave(&wdata->state.lock, flags);
219 	wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
220 	wiiproto_req_status(wdata);
221 	spin_unlock_irqrestore(&wdata->state.lock, flags);
222 
223 	wiimote_cmd_wait(wdata);
224 	wiimote_cmd_release(wdata);
225 
226 	spin_lock_irqsave(&wdata->state.lock, flags);
227 	state = wdata->state.cmd_battery;
228 	spin_unlock_irqrestore(&wdata->state.lock, flags);
229 
230 	val->intval = state * 100 / 255;
231 	return ret;
232 }
233 
234 static int wiimod_battery_probe(const struct wiimod_ops *ops,
235 				struct wiimote_data *wdata)
236 {
237 	struct power_supply_config psy_cfg = { .drv_data = wdata, };
238 	int ret;
239 
240 	wdata->battery_desc.properties = wiimod_battery_props;
241 	wdata->battery_desc.num_properties = ARRAY_SIZE(wiimod_battery_props);
242 	wdata->battery_desc.get_property = wiimod_battery_get_property;
243 	wdata->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY;
244 	wdata->battery_desc.use_for_apm = 0;
245 	wdata->battery_desc.name = kasprintf(GFP_KERNEL, "wiimote_battery_%s",
246 					     wdata->hdev->uniq);
247 	if (!wdata->battery_desc.name)
248 		return -ENOMEM;
249 
250 	wdata->battery = power_supply_register(&wdata->hdev->dev,
251 					       &wdata->battery_desc,
252 					       &psy_cfg);
253 	if (IS_ERR(wdata->battery)) {
254 		hid_err(wdata->hdev, "cannot register battery device\n");
255 		ret = PTR_ERR(wdata->battery);
256 		goto err_free;
257 	}
258 
259 	power_supply_powers(wdata->battery, &wdata->hdev->dev);
260 	return 0;
261 
262 err_free:
263 	kfree(wdata->battery_desc.name);
264 	wdata->battery_desc.name = NULL;
265 	return ret;
266 }
267 
268 static void wiimod_battery_remove(const struct wiimod_ops *ops,
269 				  struct wiimote_data *wdata)
270 {
271 	if (!wdata->battery_desc.name)
272 		return;
273 
274 	power_supply_unregister(wdata->battery);
275 	kfree(wdata->battery_desc.name);
276 	wdata->battery_desc.name = NULL;
277 }
278 
279 static const struct wiimod_ops wiimod_battery = {
280 	.flags = 0,
281 	.arg = 0,
282 	.probe = wiimod_battery_probe,
283 	.remove = wiimod_battery_remove,
284 };
285 
286 /*
287  * LED
288  * 0 to 4 player LEDs are supported by devices. The "arg" field of the
289  * wiimod_ops structure specifies which LED this module controls. This allows
290  * to register a limited number of LEDs.
291  * State is managed by wiimote core.
292  */
293 
294 static enum led_brightness wiimod_led_get(struct led_classdev *led_dev)
295 {
296 	struct device *dev = led_dev->dev->parent;
297 	struct wiimote_data *wdata = dev_to_wii(dev);
298 	int i;
299 	unsigned long flags;
300 	bool value = false;
301 
302 	for (i = 0; i < 4; ++i) {
303 		if (wdata->leds[i] == led_dev) {
304 			spin_lock_irqsave(&wdata->state.lock, flags);
305 			value = wdata->state.flags & WIIPROTO_FLAG_LED(i + 1);
306 			spin_unlock_irqrestore(&wdata->state.lock, flags);
307 			break;
308 		}
309 	}
310 
311 	return value ? LED_FULL : LED_OFF;
312 }
313 
314 static void wiimod_led_set(struct led_classdev *led_dev,
315 			   enum led_brightness value)
316 {
317 	struct device *dev = led_dev->dev->parent;
318 	struct wiimote_data *wdata = dev_to_wii(dev);
319 	int i;
320 	unsigned long flags;
321 	__u8 state, flag;
322 
323 	for (i = 0; i < 4; ++i) {
324 		if (wdata->leds[i] == led_dev) {
325 			flag = WIIPROTO_FLAG_LED(i + 1);
326 			spin_lock_irqsave(&wdata->state.lock, flags);
327 			state = wdata->state.flags;
328 			if (value == LED_OFF)
329 				wiiproto_req_leds(wdata, state & ~flag);
330 			else
331 				wiiproto_req_leds(wdata, state | flag);
332 			spin_unlock_irqrestore(&wdata->state.lock, flags);
333 			break;
334 		}
335 	}
336 }
337 
338 static int wiimod_led_probe(const struct wiimod_ops *ops,
339 			    struct wiimote_data *wdata)
340 {
341 	struct device *dev = &wdata->hdev->dev;
342 	size_t namesz = strlen(dev_name(dev)) + 9;
343 	struct led_classdev *led;
344 	unsigned long flags;
345 	char *name;
346 	int ret;
347 
348 	led = kzalloc(sizeof(struct led_classdev) + namesz, GFP_KERNEL);
349 	if (!led)
350 		return -ENOMEM;
351 
352 	name = (void*)&led[1];
353 	snprintf(name, namesz, "%s:blue:p%lu", dev_name(dev), ops->arg);
354 	led->name = name;
355 	led->brightness = 0;
356 	led->max_brightness = 1;
357 	led->brightness_get = wiimod_led_get;
358 	led->brightness_set = wiimod_led_set;
359 
360 	wdata->leds[ops->arg] = led;
361 	ret = led_classdev_register(dev, led);
362 	if (ret)
363 		goto err_free;
364 
365 	/* enable LED1 to stop initial LED-blinking */
366 	if (ops->arg == 0) {
367 		spin_lock_irqsave(&wdata->state.lock, flags);
368 		wiiproto_req_leds(wdata, WIIPROTO_FLAG_LED1);
369 		spin_unlock_irqrestore(&wdata->state.lock, flags);
370 	}
371 
372 	return 0;
373 
374 err_free:
375 	wdata->leds[ops->arg] = NULL;
376 	kfree(led);
377 	return ret;
378 }
379 
380 static void wiimod_led_remove(const struct wiimod_ops *ops,
381 			      struct wiimote_data *wdata)
382 {
383 	if (!wdata->leds[ops->arg])
384 		return;
385 
386 	led_classdev_unregister(wdata->leds[ops->arg]);
387 	kfree(wdata->leds[ops->arg]);
388 	wdata->leds[ops->arg] = NULL;
389 }
390 
391 static const struct wiimod_ops wiimod_leds[4] = {
392 	{
393 		.flags = 0,
394 		.arg = 0,
395 		.probe = wiimod_led_probe,
396 		.remove = wiimod_led_remove,
397 	},
398 	{
399 		.flags = 0,
400 		.arg = 1,
401 		.probe = wiimod_led_probe,
402 		.remove = wiimod_led_remove,
403 	},
404 	{
405 		.flags = 0,
406 		.arg = 2,
407 		.probe = wiimod_led_probe,
408 		.remove = wiimod_led_remove,
409 	},
410 	{
411 		.flags = 0,
412 		.arg = 3,
413 		.probe = wiimod_led_probe,
414 		.remove = wiimod_led_remove,
415 	},
416 };
417 
418 /*
419  * Accelerometer
420  * 3 axis accelerometer data is part of nearly all DRMs. If not supported by a
421  * device, it's mostly cleared to 0. This module parses this data and provides
422  * it via a separate input device.
423  */
424 
425 static void wiimod_accel_in_accel(struct wiimote_data *wdata,
426 				  const __u8 *accel)
427 {
428 	__u16 x, y, z;
429 
430 	if (!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
431 		return;
432 
433 	/*
434 	 * payload is: BB BB XX YY ZZ
435 	 * Accelerometer data is encoded into 3 10bit values. XX, YY and ZZ
436 	 * contain the upper 8 bits of each value. The lower 2 bits are
437 	 * contained in the buttons data BB BB.
438 	 * Bits 6 and 7 of the first buttons byte BB is the lower 2 bits of the
439 	 * X accel value. Bit 5 of the second buttons byte is the 2nd bit of Y
440 	 * accel value and bit 6 is the second bit of the Z value.
441 	 * The first bit of Y and Z values is not available and always set to 0.
442 	 * 0x200 is returned on no movement.
443 	 */
444 
445 	x = accel[2] << 2;
446 	y = accel[3] << 2;
447 	z = accel[4] << 2;
448 
449 	x |= (accel[0] >> 5) & 0x3;
450 	y |= (accel[1] >> 4) & 0x2;
451 	z |= (accel[1] >> 5) & 0x2;
452 
453 	input_report_abs(wdata->accel, ABS_RX, x - 0x200);
454 	input_report_abs(wdata->accel, ABS_RY, y - 0x200);
455 	input_report_abs(wdata->accel, ABS_RZ, z - 0x200);
456 	input_sync(wdata->accel);
457 }
458 
459 static int wiimod_accel_open(struct input_dev *dev)
460 {
461 	struct wiimote_data *wdata = input_get_drvdata(dev);
462 	unsigned long flags;
463 
464 	spin_lock_irqsave(&wdata->state.lock, flags);
465 	wiiproto_req_accel(wdata, true);
466 	spin_unlock_irqrestore(&wdata->state.lock, flags);
467 
468 	return 0;
469 }
470 
471 static void wiimod_accel_close(struct input_dev *dev)
472 {
473 	struct wiimote_data *wdata = input_get_drvdata(dev);
474 	unsigned long flags;
475 
476 	spin_lock_irqsave(&wdata->state.lock, flags);
477 	wiiproto_req_accel(wdata, false);
478 	spin_unlock_irqrestore(&wdata->state.lock, flags);
479 }
480 
481 static int wiimod_accel_probe(const struct wiimod_ops *ops,
482 			      struct wiimote_data *wdata)
483 {
484 	int ret;
485 
486 	wdata->accel = input_allocate_device();
487 	if (!wdata->accel)
488 		return -ENOMEM;
489 
490 	input_set_drvdata(wdata->accel, wdata);
491 	wdata->accel->open = wiimod_accel_open;
492 	wdata->accel->close = wiimod_accel_close;
493 	wdata->accel->dev.parent = &wdata->hdev->dev;
494 	wdata->accel->id.bustype = wdata->hdev->bus;
495 	wdata->accel->id.vendor = wdata->hdev->vendor;
496 	wdata->accel->id.product = wdata->hdev->product;
497 	wdata->accel->id.version = wdata->hdev->version;
498 	wdata->accel->name = WIIMOTE_NAME " Accelerometer";
499 
500 	set_bit(EV_ABS, wdata->accel->evbit);
501 	set_bit(ABS_RX, wdata->accel->absbit);
502 	set_bit(ABS_RY, wdata->accel->absbit);
503 	set_bit(ABS_RZ, wdata->accel->absbit);
504 	input_set_abs_params(wdata->accel, ABS_RX, -500, 500, 2, 4);
505 	input_set_abs_params(wdata->accel, ABS_RY, -500, 500, 2, 4);
506 	input_set_abs_params(wdata->accel, ABS_RZ, -500, 500, 2, 4);
507 
508 	ret = input_register_device(wdata->accel);
509 	if (ret) {
510 		hid_err(wdata->hdev, "cannot register input device\n");
511 		goto err_free;
512 	}
513 
514 	return 0;
515 
516 err_free:
517 	input_free_device(wdata->accel);
518 	wdata->accel = NULL;
519 	return ret;
520 }
521 
522 static void wiimod_accel_remove(const struct wiimod_ops *ops,
523 				struct wiimote_data *wdata)
524 {
525 	if (!wdata->accel)
526 		return;
527 
528 	input_unregister_device(wdata->accel);
529 	wdata->accel = NULL;
530 }
531 
532 static const struct wiimod_ops wiimod_accel = {
533 	.flags = 0,
534 	.arg = 0,
535 	.probe = wiimod_accel_probe,
536 	.remove = wiimod_accel_remove,
537 	.in_accel = wiimod_accel_in_accel,
538 };
539 
540 /*
541  * IR Cam
542  * Up to 4 IR sources can be tracked by a normal Wii Remote. The IR cam needs
543  * to be initialized with a fairly complex procedure and consumes a lot of
544  * power. Therefore, as long as no application uses the IR input device, it is
545  * kept offline.
546  * Nearly no other device than the normal Wii Remotes supports the IR cam so
547  * you can disable this module for these devices.
548  */
549 
550 static void wiimod_ir_in_ir(struct wiimote_data *wdata, const __u8 *ir,
551 			    bool packed, unsigned int id)
552 {
553 	__u16 x, y;
554 	__u8 xid, yid;
555 	bool sync = false;
556 
557 	if (!(wdata->state.flags & WIIPROTO_FLAGS_IR))
558 		return;
559 
560 	switch (id) {
561 	case 0:
562 		xid = ABS_HAT0X;
563 		yid = ABS_HAT0Y;
564 		break;
565 	case 1:
566 		xid = ABS_HAT1X;
567 		yid = ABS_HAT1Y;
568 		break;
569 	case 2:
570 		xid = ABS_HAT2X;
571 		yid = ABS_HAT2Y;
572 		break;
573 	case 3:
574 		xid = ABS_HAT3X;
575 		yid = ABS_HAT3Y;
576 		sync = true;
577 		break;
578 	default:
579 		return;
580 	}
581 
582 	/*
583 	 * Basic IR data is encoded into 3 bytes. The first two bytes are the
584 	 * lower 8 bit of the X/Y data, the 3rd byte contains the upper 2 bits
585 	 * of both.
586 	 * If data is packed, then the 3rd byte is put first and slightly
587 	 * reordered. This allows to interleave packed and non-packed data to
588 	 * have two IR sets in 5 bytes instead of 6.
589 	 * The resulting 10bit X/Y values are passed to the ABS_HAT? input dev.
590 	 */
591 
592 	if (packed) {
593 		x = ir[1] | ((ir[0] & 0x03) << 8);
594 		y = ir[2] | ((ir[0] & 0x0c) << 6);
595 	} else {
596 		x = ir[0] | ((ir[2] & 0x30) << 4);
597 		y = ir[1] | ((ir[2] & 0xc0) << 2);
598 	}
599 
600 	input_report_abs(wdata->ir, xid, x);
601 	input_report_abs(wdata->ir, yid, y);
602 
603 	if (sync)
604 		input_sync(wdata->ir);
605 }
606 
607 static int wiimod_ir_change(struct wiimote_data *wdata, __u16 mode)
608 {
609 	int ret;
610 	unsigned long flags;
611 	__u8 format = 0;
612 	static const __u8 data_enable[] = { 0x01 };
613 	static const __u8 data_sens1[] = { 0x02, 0x00, 0x00, 0x71, 0x01,
614 						0x00, 0xaa, 0x00, 0x64 };
615 	static const __u8 data_sens2[] = { 0x63, 0x03 };
616 	static const __u8 data_fin[] = { 0x08 };
617 
618 	spin_lock_irqsave(&wdata->state.lock, flags);
619 
620 	if (mode == (wdata->state.flags & WIIPROTO_FLAGS_IR)) {
621 		spin_unlock_irqrestore(&wdata->state.lock, flags);
622 		return 0;
623 	}
624 
625 	if (mode == 0) {
626 		wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
627 		wiiproto_req_ir1(wdata, 0);
628 		wiiproto_req_ir2(wdata, 0);
629 		wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
630 		spin_unlock_irqrestore(&wdata->state.lock, flags);
631 		return 0;
632 	}
633 
634 	spin_unlock_irqrestore(&wdata->state.lock, flags);
635 
636 	ret = wiimote_cmd_acquire(wdata);
637 	if (ret)
638 		return ret;
639 
640 	/* send PIXEL CLOCK ENABLE cmd first */
641 	spin_lock_irqsave(&wdata->state.lock, flags);
642 	wiimote_cmd_set(wdata, WIIPROTO_REQ_IR1, 0);
643 	wiiproto_req_ir1(wdata, 0x06);
644 	spin_unlock_irqrestore(&wdata->state.lock, flags);
645 
646 	ret = wiimote_cmd_wait(wdata);
647 	if (ret)
648 		goto unlock;
649 	if (wdata->state.cmd_err) {
650 		ret = -EIO;
651 		goto unlock;
652 	}
653 
654 	/* enable IR LOGIC */
655 	spin_lock_irqsave(&wdata->state.lock, flags);
656 	wiimote_cmd_set(wdata, WIIPROTO_REQ_IR2, 0);
657 	wiiproto_req_ir2(wdata, 0x06);
658 	spin_unlock_irqrestore(&wdata->state.lock, flags);
659 
660 	ret = wiimote_cmd_wait(wdata);
661 	if (ret)
662 		goto unlock;
663 	if (wdata->state.cmd_err) {
664 		ret = -EIO;
665 		goto unlock;
666 	}
667 
668 	/* enable IR cam but do not make it send data, yet */
669 	ret = wiimote_cmd_write(wdata, 0xb00030, data_enable,
670 							sizeof(data_enable));
671 	if (ret)
672 		goto unlock;
673 
674 	/* write first sensitivity block */
675 	ret = wiimote_cmd_write(wdata, 0xb00000, data_sens1,
676 							sizeof(data_sens1));
677 	if (ret)
678 		goto unlock;
679 
680 	/* write second sensitivity block */
681 	ret = wiimote_cmd_write(wdata, 0xb0001a, data_sens2,
682 							sizeof(data_sens2));
683 	if (ret)
684 		goto unlock;
685 
686 	/* put IR cam into desired state */
687 	switch (mode) {
688 		case WIIPROTO_FLAG_IR_FULL:
689 			format = 5;
690 			break;
691 		case WIIPROTO_FLAG_IR_EXT:
692 			format = 3;
693 			break;
694 		case WIIPROTO_FLAG_IR_BASIC:
695 			format = 1;
696 			break;
697 	}
698 	ret = wiimote_cmd_write(wdata, 0xb00033, &format, sizeof(format));
699 	if (ret)
700 		goto unlock;
701 
702 	/* make IR cam send data */
703 	ret = wiimote_cmd_write(wdata, 0xb00030, data_fin, sizeof(data_fin));
704 	if (ret)
705 		goto unlock;
706 
707 	/* request new DRM mode compatible to IR mode */
708 	spin_lock_irqsave(&wdata->state.lock, flags);
709 	wdata->state.flags &= ~WIIPROTO_FLAGS_IR;
710 	wdata->state.flags |= mode & WIIPROTO_FLAGS_IR;
711 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
712 	spin_unlock_irqrestore(&wdata->state.lock, flags);
713 
714 unlock:
715 	wiimote_cmd_release(wdata);
716 	return ret;
717 }
718 
719 static int wiimod_ir_open(struct input_dev *dev)
720 {
721 	struct wiimote_data *wdata = input_get_drvdata(dev);
722 
723 	return wiimod_ir_change(wdata, WIIPROTO_FLAG_IR_BASIC);
724 }
725 
726 static void wiimod_ir_close(struct input_dev *dev)
727 {
728 	struct wiimote_data *wdata = input_get_drvdata(dev);
729 
730 	wiimod_ir_change(wdata, 0);
731 }
732 
733 static int wiimod_ir_probe(const struct wiimod_ops *ops,
734 			   struct wiimote_data *wdata)
735 {
736 	int ret;
737 
738 	wdata->ir = input_allocate_device();
739 	if (!wdata->ir)
740 		return -ENOMEM;
741 
742 	input_set_drvdata(wdata->ir, wdata);
743 	wdata->ir->open = wiimod_ir_open;
744 	wdata->ir->close = wiimod_ir_close;
745 	wdata->ir->dev.parent = &wdata->hdev->dev;
746 	wdata->ir->id.bustype = wdata->hdev->bus;
747 	wdata->ir->id.vendor = wdata->hdev->vendor;
748 	wdata->ir->id.product = wdata->hdev->product;
749 	wdata->ir->id.version = wdata->hdev->version;
750 	wdata->ir->name = WIIMOTE_NAME " IR";
751 
752 	set_bit(EV_ABS, wdata->ir->evbit);
753 	set_bit(ABS_HAT0X, wdata->ir->absbit);
754 	set_bit(ABS_HAT0Y, wdata->ir->absbit);
755 	set_bit(ABS_HAT1X, wdata->ir->absbit);
756 	set_bit(ABS_HAT1Y, wdata->ir->absbit);
757 	set_bit(ABS_HAT2X, wdata->ir->absbit);
758 	set_bit(ABS_HAT2Y, wdata->ir->absbit);
759 	set_bit(ABS_HAT3X, wdata->ir->absbit);
760 	set_bit(ABS_HAT3Y, wdata->ir->absbit);
761 	input_set_abs_params(wdata->ir, ABS_HAT0X, 0, 1023, 2, 4);
762 	input_set_abs_params(wdata->ir, ABS_HAT0Y, 0, 767, 2, 4);
763 	input_set_abs_params(wdata->ir, ABS_HAT1X, 0, 1023, 2, 4);
764 	input_set_abs_params(wdata->ir, ABS_HAT1Y, 0, 767, 2, 4);
765 	input_set_abs_params(wdata->ir, ABS_HAT2X, 0, 1023, 2, 4);
766 	input_set_abs_params(wdata->ir, ABS_HAT2Y, 0, 767, 2, 4);
767 	input_set_abs_params(wdata->ir, ABS_HAT3X, 0, 1023, 2, 4);
768 	input_set_abs_params(wdata->ir, ABS_HAT3Y, 0, 767, 2, 4);
769 
770 	ret = input_register_device(wdata->ir);
771 	if (ret) {
772 		hid_err(wdata->hdev, "cannot register input device\n");
773 		goto err_free;
774 	}
775 
776 	return 0;
777 
778 err_free:
779 	input_free_device(wdata->ir);
780 	wdata->ir = NULL;
781 	return ret;
782 }
783 
784 static void wiimod_ir_remove(const struct wiimod_ops *ops,
785 			     struct wiimote_data *wdata)
786 {
787 	if (!wdata->ir)
788 		return;
789 
790 	input_unregister_device(wdata->ir);
791 	wdata->ir = NULL;
792 }
793 
794 static const struct wiimod_ops wiimod_ir = {
795 	.flags = 0,
796 	.arg = 0,
797 	.probe = wiimod_ir_probe,
798 	.remove = wiimod_ir_remove,
799 	.in_ir = wiimod_ir_in_ir,
800 };
801 
802 /*
803  * Nunchuk Extension
804  * The Nintendo Wii Nunchuk was the first official extension published by
805  * Nintendo. It provides two additional keys and a separate accelerometer. It
806  * can be hotplugged to standard Wii Remotes.
807  */
808 
809 enum wiimod_nunchuk_keys {
810 	WIIMOD_NUNCHUK_KEY_C,
811 	WIIMOD_NUNCHUK_KEY_Z,
812 	WIIMOD_NUNCHUK_KEY_NUM,
813 };
814 
815 static const __u16 wiimod_nunchuk_map[] = {
816 	BTN_C,		/* WIIMOD_NUNCHUK_KEY_C */
817 	BTN_Z,		/* WIIMOD_NUNCHUK_KEY_Z */
818 };
819 
820 static void wiimod_nunchuk_in_ext(struct wiimote_data *wdata, const __u8 *ext)
821 {
822 	__s16 x, y, z, bx, by;
823 
824 	/*   Byte |   8    7 |  6    5 |  4    3 |  2 |  1  |
825 	 *   -----+----------+---------+---------+----+-----+
826 	 *    1   |              Button X <7:0>             |
827 	 *    2   |              Button Y <7:0>             |
828 	 *   -----+----------+---------+---------+----+-----+
829 	 *    3   |               Speed X <9:2>             |
830 	 *    4   |               Speed Y <9:2>             |
831 	 *    5   |               Speed Z <9:2>             |
832 	 *   -----+----------+---------+---------+----+-----+
833 	 *    6   | Z <1:0>  | Y <1:0> | X <1:0> | BC | BZ  |
834 	 *   -----+----------+---------+---------+----+-----+
835 	 * Button X/Y is the analog stick. Speed X, Y and Z are the
836 	 * accelerometer data in the same format as the wiimote's accelerometer.
837 	 * The 6th byte contains the LSBs of the accelerometer data.
838 	 * BC and BZ are the C and Z buttons: 0 means pressed
839 	 *
840 	 * If reported interleaved with motionp, then the layout changes. The
841 	 * 5th and 6th byte changes to:
842 	 *   -----+-----------------------------------+-----+
843 	 *    5   |            Speed Z <9:3>          | EXT |
844 	 *   -----+--------+-----+-----+----+----+----+-----+
845 	 *    6   |Z <2:1> |Y <1>|X <1>| BC | BZ | 0  |  0  |
846 	 *   -----+--------+-----+-----+----+----+----+-----+
847 	 * All three accelerometer values lose their LSB. The other data is
848 	 * still available but slightly moved.
849 	 *
850 	 * Center data for button values is 128. Center value for accelerometer
851 	 * values it 512 / 0x200
852 	 */
853 
854 	bx = ext[0];
855 	by = ext[1];
856 	bx -= 128;
857 	by -= 128;
858 
859 	x = ext[2] << 2;
860 	y = ext[3] << 2;
861 	z = ext[4] << 2;
862 
863 	if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
864 		x |= (ext[5] >> 3) & 0x02;
865 		y |= (ext[5] >> 4) & 0x02;
866 		z &= ~0x4;
867 		z |= (ext[5] >> 5) & 0x06;
868 	} else {
869 		x |= (ext[5] >> 2) & 0x03;
870 		y |= (ext[5] >> 4) & 0x03;
871 		z |= (ext[5] >> 6) & 0x03;
872 	}
873 
874 	x -= 0x200;
875 	y -= 0x200;
876 	z -= 0x200;
877 
878 	input_report_abs(wdata->extension.input, ABS_HAT0X, bx);
879 	input_report_abs(wdata->extension.input, ABS_HAT0Y, by);
880 
881 	input_report_abs(wdata->extension.input, ABS_RX, x);
882 	input_report_abs(wdata->extension.input, ABS_RY, y);
883 	input_report_abs(wdata->extension.input, ABS_RZ, z);
884 
885 	if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
886 		input_report_key(wdata->extension.input,
887 			wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_Z],
888 			!(ext[5] & 0x04));
889 		input_report_key(wdata->extension.input,
890 			wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_C],
891 			!(ext[5] & 0x08));
892 	} else {
893 		input_report_key(wdata->extension.input,
894 			wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_Z],
895 			!(ext[5] & 0x01));
896 		input_report_key(wdata->extension.input,
897 			wiimod_nunchuk_map[WIIMOD_NUNCHUK_KEY_C],
898 			!(ext[5] & 0x02));
899 	}
900 
901 	input_sync(wdata->extension.input);
902 }
903 
904 static int wiimod_nunchuk_open(struct input_dev *dev)
905 {
906 	struct wiimote_data *wdata = input_get_drvdata(dev);
907 	unsigned long flags;
908 
909 	spin_lock_irqsave(&wdata->state.lock, flags);
910 	wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
911 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
912 	spin_unlock_irqrestore(&wdata->state.lock, flags);
913 
914 	return 0;
915 }
916 
917 static void wiimod_nunchuk_close(struct input_dev *dev)
918 {
919 	struct wiimote_data *wdata = input_get_drvdata(dev);
920 	unsigned long flags;
921 
922 	spin_lock_irqsave(&wdata->state.lock, flags);
923 	wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
924 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
925 	spin_unlock_irqrestore(&wdata->state.lock, flags);
926 }
927 
928 static int wiimod_nunchuk_probe(const struct wiimod_ops *ops,
929 				struct wiimote_data *wdata)
930 {
931 	int ret, i;
932 
933 	wdata->extension.input = input_allocate_device();
934 	if (!wdata->extension.input)
935 		return -ENOMEM;
936 
937 	input_set_drvdata(wdata->extension.input, wdata);
938 	wdata->extension.input->open = wiimod_nunchuk_open;
939 	wdata->extension.input->close = wiimod_nunchuk_close;
940 	wdata->extension.input->dev.parent = &wdata->hdev->dev;
941 	wdata->extension.input->id.bustype = wdata->hdev->bus;
942 	wdata->extension.input->id.vendor = wdata->hdev->vendor;
943 	wdata->extension.input->id.product = wdata->hdev->product;
944 	wdata->extension.input->id.version = wdata->hdev->version;
945 	wdata->extension.input->name = WIIMOTE_NAME " Nunchuk";
946 
947 	set_bit(EV_KEY, wdata->extension.input->evbit);
948 	for (i = 0; i < WIIMOD_NUNCHUK_KEY_NUM; ++i)
949 		set_bit(wiimod_nunchuk_map[i],
950 			wdata->extension.input->keybit);
951 
952 	set_bit(EV_ABS, wdata->extension.input->evbit);
953 	set_bit(ABS_HAT0X, wdata->extension.input->absbit);
954 	set_bit(ABS_HAT0Y, wdata->extension.input->absbit);
955 	input_set_abs_params(wdata->extension.input,
956 			     ABS_HAT0X, -120, 120, 2, 4);
957 	input_set_abs_params(wdata->extension.input,
958 			     ABS_HAT0Y, -120, 120, 2, 4);
959 	set_bit(ABS_RX, wdata->extension.input->absbit);
960 	set_bit(ABS_RY, wdata->extension.input->absbit);
961 	set_bit(ABS_RZ, wdata->extension.input->absbit);
962 	input_set_abs_params(wdata->extension.input,
963 			     ABS_RX, -500, 500, 2, 4);
964 	input_set_abs_params(wdata->extension.input,
965 			     ABS_RY, -500, 500, 2, 4);
966 	input_set_abs_params(wdata->extension.input,
967 			     ABS_RZ, -500, 500, 2, 4);
968 
969 	ret = input_register_device(wdata->extension.input);
970 	if (ret)
971 		goto err_free;
972 
973 	return 0;
974 
975 err_free:
976 	input_free_device(wdata->extension.input);
977 	wdata->extension.input = NULL;
978 	return ret;
979 }
980 
981 static void wiimod_nunchuk_remove(const struct wiimod_ops *ops,
982 				  struct wiimote_data *wdata)
983 {
984 	if (!wdata->extension.input)
985 		return;
986 
987 	input_unregister_device(wdata->extension.input);
988 	wdata->extension.input = NULL;
989 }
990 
991 static const struct wiimod_ops wiimod_nunchuk = {
992 	.flags = 0,
993 	.arg = 0,
994 	.probe = wiimod_nunchuk_probe,
995 	.remove = wiimod_nunchuk_remove,
996 	.in_ext = wiimod_nunchuk_in_ext,
997 };
998 
999 /*
1000  * Classic Controller
1001  * Another official extension from Nintendo. It provides a classic
1002  * gamecube-like controller that can be hotplugged on the Wii Remote.
1003  * It has several hardware buttons and switches that are all reported via
1004  * a normal extension device.
1005  */
1006 
1007 enum wiimod_classic_keys {
1008 	WIIMOD_CLASSIC_KEY_A,
1009 	WIIMOD_CLASSIC_KEY_B,
1010 	WIIMOD_CLASSIC_KEY_X,
1011 	WIIMOD_CLASSIC_KEY_Y,
1012 	WIIMOD_CLASSIC_KEY_ZL,
1013 	WIIMOD_CLASSIC_KEY_ZR,
1014 	WIIMOD_CLASSIC_KEY_PLUS,
1015 	WIIMOD_CLASSIC_KEY_MINUS,
1016 	WIIMOD_CLASSIC_KEY_HOME,
1017 	WIIMOD_CLASSIC_KEY_LEFT,
1018 	WIIMOD_CLASSIC_KEY_RIGHT,
1019 	WIIMOD_CLASSIC_KEY_UP,
1020 	WIIMOD_CLASSIC_KEY_DOWN,
1021 	WIIMOD_CLASSIC_KEY_LT,
1022 	WIIMOD_CLASSIC_KEY_RT,
1023 	WIIMOD_CLASSIC_KEY_NUM,
1024 };
1025 
1026 static const __u16 wiimod_classic_map[] = {
1027 	BTN_A,		/* WIIMOD_CLASSIC_KEY_A */
1028 	BTN_B,		/* WIIMOD_CLASSIC_KEY_B */
1029 	BTN_X,		/* WIIMOD_CLASSIC_KEY_X */
1030 	BTN_Y,		/* WIIMOD_CLASSIC_KEY_Y */
1031 	BTN_TL2,	/* WIIMOD_CLASSIC_KEY_ZL */
1032 	BTN_TR2,	/* WIIMOD_CLASSIC_KEY_ZR */
1033 	KEY_NEXT,	/* WIIMOD_CLASSIC_KEY_PLUS */
1034 	KEY_PREVIOUS,	/* WIIMOD_CLASSIC_KEY_MINUS */
1035 	BTN_MODE,	/* WIIMOD_CLASSIC_KEY_HOME */
1036 	KEY_LEFT,	/* WIIMOD_CLASSIC_KEY_LEFT */
1037 	KEY_RIGHT,	/* WIIMOD_CLASSIC_KEY_RIGHT */
1038 	KEY_UP,		/* WIIMOD_CLASSIC_KEY_UP */
1039 	KEY_DOWN,	/* WIIMOD_CLASSIC_KEY_DOWN */
1040 	BTN_TL,		/* WIIMOD_CLASSIC_KEY_LT */
1041 	BTN_TR,		/* WIIMOD_CLASSIC_KEY_RT */
1042 };
1043 
1044 static void wiimod_classic_in_ext(struct wiimote_data *wdata, const __u8 *ext)
1045 {
1046 	__s8 rx, ry, lx, ly, lt, rt;
1047 
1048 	/*   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
1049 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1050 	 *    1   | RX <5:4>  |              LX <5:0>             |
1051 	 *    2   | RX <3:2>  |              LY <5:0>             |
1052 	 *   -----+-----+-----+-----+-----------------------------+
1053 	 *    3   |RX<1>| LT <5:4>  |         RY <5:1>            |
1054 	 *   -----+-----+-----------+-----------------------------+
1055 	 *    4   |     LT <3:1>    |         RT <5:1>            |
1056 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1057 	 *    5   | BDR | BDD | BLT | B-  | BH  | B+  | BRT |  1  |
1058 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1059 	 *    6   | BZL | BB  | BY  | BA  | BX  | BZR | BDL | BDU |
1060 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1061 	 * All buttons are 0 if pressed
1062 	 * RX and RY are right analog stick
1063 	 * LX and LY are left analog stick
1064 	 * LT is left trigger, RT is right trigger
1065 	 * BLT is 0 if left trigger is fully pressed
1066 	 * BRT is 0 if right trigger is fully pressed
1067 	 * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons
1068 	 * BZL is left Z button and BZR is right Z button
1069 	 * B-, BH, B+ are +, HOME and - buttons
1070 	 * BB, BY, BA, BX are A, B, X, Y buttons
1071 	 * LSB of RX, RY, LT, and RT are not transmitted and always 0.
1072 	 *
1073 	 * With motionp enabled it changes slightly to this:
1074 	 *   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
1075 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1076 	 *    1   | RX <5:4>  |          LX <5:1>           | BDU |
1077 	 *    2   | RX <3:2>  |          LY <5:1>           | BDL |
1078 	 *   -----+-----+-----+-----+-----------------------+-----+
1079 	 *    3   |RX<1>| LT <5:4>  |         RY <5:1>            |
1080 	 *   -----+-----+-----------+-----------------------------+
1081 	 *    4   |     LT <3:1>    |         RT <5:1>            |
1082 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1083 	 *    5   | BDR | BDD | BLT | B-  | BH  | B+  | BRT | EXT |
1084 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1085 	 *    6   | BZL | BB  | BY  | BA  | BX  | BZR |  0  |  0  |
1086 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1087 	 * Only the LSBs of LX and LY are lost. BDU and BDL are moved, the rest
1088 	 * is the same as before.
1089 	 */
1090 
1091 	if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
1092 		lx = ext[0] & 0x3e;
1093 		ly = ext[1] & 0x3e;
1094 	} else {
1095 		lx = ext[0] & 0x3f;
1096 		ly = ext[1] & 0x3f;
1097 	}
1098 
1099 	rx = (ext[0] >> 3) & 0x18;
1100 	rx |= (ext[1] >> 5) & 0x06;
1101 	rx |= (ext[2] >> 7) & 0x01;
1102 	ry = ext[2] & 0x1f;
1103 
1104 	rt = ext[3] & 0x1f;
1105 	lt = (ext[2] >> 2) & 0x18;
1106 	lt |= (ext[3] >> 5) & 0x07;
1107 
1108 	rx <<= 1;
1109 	ry <<= 1;
1110 	rt <<= 1;
1111 	lt <<= 1;
1112 
1113 	input_report_abs(wdata->extension.input, ABS_HAT1X, lx - 0x20);
1114 	input_report_abs(wdata->extension.input, ABS_HAT1Y, ly - 0x20);
1115 	input_report_abs(wdata->extension.input, ABS_HAT2X, rx - 0x20);
1116 	input_report_abs(wdata->extension.input, ABS_HAT2Y, ry - 0x20);
1117 	input_report_abs(wdata->extension.input, ABS_HAT3X, rt);
1118 	input_report_abs(wdata->extension.input, ABS_HAT3Y, lt);
1119 
1120 	input_report_key(wdata->extension.input,
1121 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_RIGHT],
1122 			 !(ext[4] & 0x80));
1123 	input_report_key(wdata->extension.input,
1124 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_DOWN],
1125 			 !(ext[4] & 0x40));
1126 	input_report_key(wdata->extension.input,
1127 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LT],
1128 			 !(ext[4] & 0x20));
1129 	input_report_key(wdata->extension.input,
1130 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_MINUS],
1131 			 !(ext[4] & 0x10));
1132 	input_report_key(wdata->extension.input,
1133 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_HOME],
1134 			 !(ext[4] & 0x08));
1135 	input_report_key(wdata->extension.input,
1136 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_PLUS],
1137 			 !(ext[4] & 0x04));
1138 	input_report_key(wdata->extension.input,
1139 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_RT],
1140 			 !(ext[4] & 0x02));
1141 	input_report_key(wdata->extension.input,
1142 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_ZL],
1143 			 !(ext[5] & 0x80));
1144 	input_report_key(wdata->extension.input,
1145 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_B],
1146 			 !(ext[5] & 0x40));
1147 	input_report_key(wdata->extension.input,
1148 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_Y],
1149 			 !(ext[5] & 0x20));
1150 	input_report_key(wdata->extension.input,
1151 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_A],
1152 			 !(ext[5] & 0x10));
1153 	input_report_key(wdata->extension.input,
1154 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_X],
1155 			 !(ext[5] & 0x08));
1156 	input_report_key(wdata->extension.input,
1157 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_ZR],
1158 			 !(ext[5] & 0x04));
1159 
1160 	if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
1161 		input_report_key(wdata->extension.input,
1162 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LEFT],
1163 			 !(ext[1] & 0x01));
1164 		input_report_key(wdata->extension.input,
1165 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_UP],
1166 			 !(ext[0] & 0x01));
1167 	} else {
1168 		input_report_key(wdata->extension.input,
1169 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_LEFT],
1170 			 !(ext[5] & 0x02));
1171 		input_report_key(wdata->extension.input,
1172 			 wiimod_classic_map[WIIMOD_CLASSIC_KEY_UP],
1173 			 !(ext[5] & 0x01));
1174 	}
1175 
1176 	input_sync(wdata->extension.input);
1177 }
1178 
1179 static int wiimod_classic_open(struct input_dev *dev)
1180 {
1181 	struct wiimote_data *wdata = input_get_drvdata(dev);
1182 	unsigned long flags;
1183 
1184 	spin_lock_irqsave(&wdata->state.lock, flags);
1185 	wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
1186 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1187 	spin_unlock_irqrestore(&wdata->state.lock, flags);
1188 
1189 	return 0;
1190 }
1191 
1192 static void wiimod_classic_close(struct input_dev *dev)
1193 {
1194 	struct wiimote_data *wdata = input_get_drvdata(dev);
1195 	unsigned long flags;
1196 
1197 	spin_lock_irqsave(&wdata->state.lock, flags);
1198 	wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
1199 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1200 	spin_unlock_irqrestore(&wdata->state.lock, flags);
1201 }
1202 
1203 static int wiimod_classic_probe(const struct wiimod_ops *ops,
1204 				struct wiimote_data *wdata)
1205 {
1206 	int ret, i;
1207 
1208 	wdata->extension.input = input_allocate_device();
1209 	if (!wdata->extension.input)
1210 		return -ENOMEM;
1211 
1212 	input_set_drvdata(wdata->extension.input, wdata);
1213 	wdata->extension.input->open = wiimod_classic_open;
1214 	wdata->extension.input->close = wiimod_classic_close;
1215 	wdata->extension.input->dev.parent = &wdata->hdev->dev;
1216 	wdata->extension.input->id.bustype = wdata->hdev->bus;
1217 	wdata->extension.input->id.vendor = wdata->hdev->vendor;
1218 	wdata->extension.input->id.product = wdata->hdev->product;
1219 	wdata->extension.input->id.version = wdata->hdev->version;
1220 	wdata->extension.input->name = WIIMOTE_NAME " Classic Controller";
1221 
1222 	set_bit(EV_KEY, wdata->extension.input->evbit);
1223 	for (i = 0; i < WIIMOD_CLASSIC_KEY_NUM; ++i)
1224 		set_bit(wiimod_classic_map[i],
1225 			wdata->extension.input->keybit);
1226 
1227 	set_bit(EV_ABS, wdata->extension.input->evbit);
1228 	set_bit(ABS_HAT1X, wdata->extension.input->absbit);
1229 	set_bit(ABS_HAT1Y, wdata->extension.input->absbit);
1230 	set_bit(ABS_HAT2X, wdata->extension.input->absbit);
1231 	set_bit(ABS_HAT2Y, wdata->extension.input->absbit);
1232 	set_bit(ABS_HAT3X, wdata->extension.input->absbit);
1233 	set_bit(ABS_HAT3Y, wdata->extension.input->absbit);
1234 	input_set_abs_params(wdata->extension.input,
1235 			     ABS_HAT1X, -30, 30, 1, 1);
1236 	input_set_abs_params(wdata->extension.input,
1237 			     ABS_HAT1Y, -30, 30, 1, 1);
1238 	input_set_abs_params(wdata->extension.input,
1239 			     ABS_HAT2X, -30, 30, 1, 1);
1240 	input_set_abs_params(wdata->extension.input,
1241 			     ABS_HAT2Y, -30, 30, 1, 1);
1242 	input_set_abs_params(wdata->extension.input,
1243 			     ABS_HAT3X, -30, 30, 1, 1);
1244 	input_set_abs_params(wdata->extension.input,
1245 			     ABS_HAT3Y, -30, 30, 1, 1);
1246 
1247 	ret = input_register_device(wdata->extension.input);
1248 	if (ret)
1249 		goto err_free;
1250 
1251 	return 0;
1252 
1253 err_free:
1254 	input_free_device(wdata->extension.input);
1255 	wdata->extension.input = NULL;
1256 	return ret;
1257 }
1258 
1259 static void wiimod_classic_remove(const struct wiimod_ops *ops,
1260 				  struct wiimote_data *wdata)
1261 {
1262 	if (!wdata->extension.input)
1263 		return;
1264 
1265 	input_unregister_device(wdata->extension.input);
1266 	wdata->extension.input = NULL;
1267 }
1268 
1269 static const struct wiimod_ops wiimod_classic = {
1270 	.flags = 0,
1271 	.arg = 0,
1272 	.probe = wiimod_classic_probe,
1273 	.remove = wiimod_classic_remove,
1274 	.in_ext = wiimod_classic_in_ext,
1275 };
1276 
1277 /*
1278  * Balance Board Extension
1279  * The Nintendo Wii Balance Board provides four hardware weight sensor plus a
1280  * single push button. No other peripherals are available. However, the
1281  * balance-board data is sent via a standard Wii Remote extension. All other
1282  * data for non-present hardware is zeroed out.
1283  * Some 3rd party devices react allergic if we try to access normal Wii Remote
1284  * hardware, so this extension module should be the only module that is loaded
1285  * on balance boards.
1286  * The balance board needs 8 bytes extension data instead of basic 6 bytes so
1287  * it needs the WIIMOD_FLAG_EXT8 flag.
1288  */
1289 
1290 static void wiimod_bboard_in_keys(struct wiimote_data *wdata, const __u8 *keys)
1291 {
1292 	input_report_key(wdata->extension.input, BTN_A,
1293 			 !!(keys[1] & 0x08));
1294 	input_sync(wdata->extension.input);
1295 }
1296 
1297 static void wiimod_bboard_in_ext(struct wiimote_data *wdata,
1298 				 const __u8 *ext)
1299 {
1300 	__s32 val[4], tmp, div;
1301 	unsigned int i;
1302 	struct wiimote_state *s = &wdata->state;
1303 
1304 	/*
1305 	 * Balance board data layout:
1306 	 *
1307 	 *   Byte |  8  7  6  5  4  3  2  1  |
1308 	 *   -----+--------------------------+
1309 	 *    1   |    Top Right <15:8>      |
1310 	 *    2   |    Top Right  <7:0>      |
1311 	 *   -----+--------------------------+
1312 	 *    3   | Bottom Right <15:8>      |
1313 	 *    4   | Bottom Right  <7:0>      |
1314 	 *   -----+--------------------------+
1315 	 *    5   |     Top Left <15:8>      |
1316 	 *    6   |     Top Left  <7:0>      |
1317 	 *   -----+--------------------------+
1318 	 *    7   |  Bottom Left <15:8>      |
1319 	 *    8   |  Bottom Left  <7:0>      |
1320 	 *   -----+--------------------------+
1321 	 *
1322 	 * These values represent the weight-measurements of the Wii-balance
1323 	 * board with 16bit precision.
1324 	 *
1325 	 * The balance-board is never reported interleaved with motionp.
1326 	 */
1327 
1328 	val[0] = ext[0];
1329 	val[0] <<= 8;
1330 	val[0] |= ext[1];
1331 
1332 	val[1] = ext[2];
1333 	val[1] <<= 8;
1334 	val[1] |= ext[3];
1335 
1336 	val[2] = ext[4];
1337 	val[2] <<= 8;
1338 	val[2] |= ext[5];
1339 
1340 	val[3] = ext[6];
1341 	val[3] <<= 8;
1342 	val[3] |= ext[7];
1343 
1344 	/* apply calibration data */
1345 	for (i = 0; i < 4; i++) {
1346 		if (val[i] <= s->calib_bboard[i][0]) {
1347 			tmp = 0;
1348 		} else if (val[i] < s->calib_bboard[i][1]) {
1349 			tmp = val[i] - s->calib_bboard[i][0];
1350 			tmp *= 1700;
1351 			div = s->calib_bboard[i][1] - s->calib_bboard[i][0];
1352 			tmp /= div ? div : 1;
1353 		} else {
1354 			tmp = val[i] - s->calib_bboard[i][1];
1355 			tmp *= 1700;
1356 			div = s->calib_bboard[i][2] - s->calib_bboard[i][1];
1357 			tmp /= div ? div : 1;
1358 			tmp += 1700;
1359 		}
1360 		val[i] = tmp;
1361 	}
1362 
1363 	input_report_abs(wdata->extension.input, ABS_HAT0X, val[0]);
1364 	input_report_abs(wdata->extension.input, ABS_HAT0Y, val[1]);
1365 	input_report_abs(wdata->extension.input, ABS_HAT1X, val[2]);
1366 	input_report_abs(wdata->extension.input, ABS_HAT1Y, val[3]);
1367 	input_sync(wdata->extension.input);
1368 }
1369 
1370 static int wiimod_bboard_open(struct input_dev *dev)
1371 {
1372 	struct wiimote_data *wdata = input_get_drvdata(dev);
1373 	unsigned long flags;
1374 
1375 	spin_lock_irqsave(&wdata->state.lock, flags);
1376 	wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
1377 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1378 	spin_unlock_irqrestore(&wdata->state.lock, flags);
1379 
1380 	return 0;
1381 }
1382 
1383 static void wiimod_bboard_close(struct input_dev *dev)
1384 {
1385 	struct wiimote_data *wdata = input_get_drvdata(dev);
1386 	unsigned long flags;
1387 
1388 	spin_lock_irqsave(&wdata->state.lock, flags);
1389 	wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
1390 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1391 	spin_unlock_irqrestore(&wdata->state.lock, flags);
1392 }
1393 
1394 static ssize_t wiimod_bboard_calib_show(struct device *dev,
1395 					struct device_attribute *attr,
1396 					char *out)
1397 {
1398 	struct wiimote_data *wdata = dev_to_wii(dev);
1399 	int i, j, ret;
1400 	__u16 val;
1401 	__u8 buf[24], offs;
1402 
1403 	ret = wiimote_cmd_acquire(wdata);
1404 	if (ret)
1405 		return ret;
1406 
1407 	ret = wiimote_cmd_read(wdata, 0xa40024, buf, 12);
1408 	if (ret != 12) {
1409 		wiimote_cmd_release(wdata);
1410 		return ret < 0 ? ret : -EIO;
1411 	}
1412 	ret = wiimote_cmd_read(wdata, 0xa40024 + 12, buf + 12, 12);
1413 	if (ret != 12) {
1414 		wiimote_cmd_release(wdata);
1415 		return ret < 0 ? ret : -EIO;
1416 	}
1417 
1418 	wiimote_cmd_release(wdata);
1419 
1420 	spin_lock_irq(&wdata->state.lock);
1421 	offs = 0;
1422 	for (i = 0; i < 3; ++i) {
1423 		for (j = 0; j < 4; ++j) {
1424 			wdata->state.calib_bboard[j][i] = buf[offs];
1425 			wdata->state.calib_bboard[j][i] <<= 8;
1426 			wdata->state.calib_bboard[j][i] |= buf[offs + 1];
1427 			offs += 2;
1428 		}
1429 	}
1430 	spin_unlock_irq(&wdata->state.lock);
1431 
1432 	ret = 0;
1433 	for (i = 0; i < 3; ++i) {
1434 		for (j = 0; j < 4; ++j) {
1435 			val = wdata->state.calib_bboard[j][i];
1436 			if (i == 2 && j == 3)
1437 				ret += sprintf(&out[ret], "%04x\n", val);
1438 			else
1439 				ret += sprintf(&out[ret], "%04x:", val);
1440 		}
1441 	}
1442 
1443 	return ret;
1444 }
1445 
1446 static DEVICE_ATTR(bboard_calib, S_IRUGO, wiimod_bboard_calib_show, NULL);
1447 
1448 static int wiimod_bboard_probe(const struct wiimod_ops *ops,
1449 			       struct wiimote_data *wdata)
1450 {
1451 	int ret, i, j;
1452 	__u8 buf[24], offs;
1453 
1454 	wiimote_cmd_acquire_noint(wdata);
1455 
1456 	ret = wiimote_cmd_read(wdata, 0xa40024, buf, 12);
1457 	if (ret != 12) {
1458 		wiimote_cmd_release(wdata);
1459 		return ret < 0 ? ret : -EIO;
1460 	}
1461 	ret = wiimote_cmd_read(wdata, 0xa40024 + 12, buf + 12, 12);
1462 	if (ret != 12) {
1463 		wiimote_cmd_release(wdata);
1464 		return ret < 0 ? ret : -EIO;
1465 	}
1466 
1467 	wiimote_cmd_release(wdata);
1468 
1469 	offs = 0;
1470 	for (i = 0; i < 3; ++i) {
1471 		for (j = 0; j < 4; ++j) {
1472 			wdata->state.calib_bboard[j][i] = buf[offs];
1473 			wdata->state.calib_bboard[j][i] <<= 8;
1474 			wdata->state.calib_bboard[j][i] |= buf[offs + 1];
1475 			offs += 2;
1476 		}
1477 	}
1478 
1479 	wdata->extension.input = input_allocate_device();
1480 	if (!wdata->extension.input)
1481 		return -ENOMEM;
1482 
1483 	ret = device_create_file(&wdata->hdev->dev,
1484 				 &dev_attr_bboard_calib);
1485 	if (ret) {
1486 		hid_err(wdata->hdev, "cannot create sysfs attribute\n");
1487 		goto err_free;
1488 	}
1489 
1490 	input_set_drvdata(wdata->extension.input, wdata);
1491 	wdata->extension.input->open = wiimod_bboard_open;
1492 	wdata->extension.input->close = wiimod_bboard_close;
1493 	wdata->extension.input->dev.parent = &wdata->hdev->dev;
1494 	wdata->extension.input->id.bustype = wdata->hdev->bus;
1495 	wdata->extension.input->id.vendor = wdata->hdev->vendor;
1496 	wdata->extension.input->id.product = wdata->hdev->product;
1497 	wdata->extension.input->id.version = wdata->hdev->version;
1498 	wdata->extension.input->name = WIIMOTE_NAME " Balance Board";
1499 
1500 	set_bit(EV_KEY, wdata->extension.input->evbit);
1501 	set_bit(BTN_A, wdata->extension.input->keybit);
1502 
1503 	set_bit(EV_ABS, wdata->extension.input->evbit);
1504 	set_bit(ABS_HAT0X, wdata->extension.input->absbit);
1505 	set_bit(ABS_HAT0Y, wdata->extension.input->absbit);
1506 	set_bit(ABS_HAT1X, wdata->extension.input->absbit);
1507 	set_bit(ABS_HAT1Y, wdata->extension.input->absbit);
1508 	input_set_abs_params(wdata->extension.input,
1509 			     ABS_HAT0X, 0, 65535, 2, 4);
1510 	input_set_abs_params(wdata->extension.input,
1511 			     ABS_HAT0Y, 0, 65535, 2, 4);
1512 	input_set_abs_params(wdata->extension.input,
1513 			     ABS_HAT1X, 0, 65535, 2, 4);
1514 	input_set_abs_params(wdata->extension.input,
1515 			     ABS_HAT1Y, 0, 65535, 2, 4);
1516 
1517 	ret = input_register_device(wdata->extension.input);
1518 	if (ret)
1519 		goto err_file;
1520 
1521 	return 0;
1522 
1523 err_file:
1524 	device_remove_file(&wdata->hdev->dev,
1525 			   &dev_attr_bboard_calib);
1526 err_free:
1527 	input_free_device(wdata->extension.input);
1528 	wdata->extension.input = NULL;
1529 	return ret;
1530 }
1531 
1532 static void wiimod_bboard_remove(const struct wiimod_ops *ops,
1533 				 struct wiimote_data *wdata)
1534 {
1535 	if (!wdata->extension.input)
1536 		return;
1537 
1538 	input_unregister_device(wdata->extension.input);
1539 	wdata->extension.input = NULL;
1540 	device_remove_file(&wdata->hdev->dev,
1541 			   &dev_attr_bboard_calib);
1542 }
1543 
1544 static const struct wiimod_ops wiimod_bboard = {
1545 	.flags = WIIMOD_FLAG_EXT8,
1546 	.arg = 0,
1547 	.probe = wiimod_bboard_probe,
1548 	.remove = wiimod_bboard_remove,
1549 	.in_keys = wiimod_bboard_in_keys,
1550 	.in_ext = wiimod_bboard_in_ext,
1551 };
1552 
1553 /*
1554  * Pro Controller
1555  * Released with the Wii U was the Nintendo Wii U Pro Controller. It does not
1556  * work together with the classic Wii, but only with the new Wii U. However, it
1557  * uses the same protocol and provides a builtin "classic controller pro"
1558  * extension, few standard buttons, a rumble motor, 4 LEDs and a battery.
1559  * We provide all these via a standard extension device as the device doesn't
1560  * feature an extension port.
1561  */
1562 
1563 enum wiimod_pro_keys {
1564 	WIIMOD_PRO_KEY_A,
1565 	WIIMOD_PRO_KEY_B,
1566 	WIIMOD_PRO_KEY_X,
1567 	WIIMOD_PRO_KEY_Y,
1568 	WIIMOD_PRO_KEY_PLUS,
1569 	WIIMOD_PRO_KEY_MINUS,
1570 	WIIMOD_PRO_KEY_HOME,
1571 	WIIMOD_PRO_KEY_LEFT,
1572 	WIIMOD_PRO_KEY_RIGHT,
1573 	WIIMOD_PRO_KEY_UP,
1574 	WIIMOD_PRO_KEY_DOWN,
1575 	WIIMOD_PRO_KEY_TL,
1576 	WIIMOD_PRO_KEY_TR,
1577 	WIIMOD_PRO_KEY_ZL,
1578 	WIIMOD_PRO_KEY_ZR,
1579 	WIIMOD_PRO_KEY_THUMBL,
1580 	WIIMOD_PRO_KEY_THUMBR,
1581 	WIIMOD_PRO_KEY_NUM,
1582 };
1583 
1584 static const __u16 wiimod_pro_map[] = {
1585 	BTN_EAST,	/* WIIMOD_PRO_KEY_A */
1586 	BTN_SOUTH,	/* WIIMOD_PRO_KEY_B */
1587 	BTN_NORTH,	/* WIIMOD_PRO_KEY_X */
1588 	BTN_WEST,	/* WIIMOD_PRO_KEY_Y */
1589 	BTN_START,	/* WIIMOD_PRO_KEY_PLUS */
1590 	BTN_SELECT,	/* WIIMOD_PRO_KEY_MINUS */
1591 	BTN_MODE,	/* WIIMOD_PRO_KEY_HOME */
1592 	BTN_DPAD_LEFT,	/* WIIMOD_PRO_KEY_LEFT */
1593 	BTN_DPAD_RIGHT,	/* WIIMOD_PRO_KEY_RIGHT */
1594 	BTN_DPAD_UP,	/* WIIMOD_PRO_KEY_UP */
1595 	BTN_DPAD_DOWN,	/* WIIMOD_PRO_KEY_DOWN */
1596 	BTN_TL,		/* WIIMOD_PRO_KEY_TL */
1597 	BTN_TR,		/* WIIMOD_PRO_KEY_TR */
1598 	BTN_TL2,	/* WIIMOD_PRO_KEY_ZL */
1599 	BTN_TR2,	/* WIIMOD_PRO_KEY_ZR */
1600 	BTN_THUMBL,	/* WIIMOD_PRO_KEY_THUMBL */
1601 	BTN_THUMBR,	/* WIIMOD_PRO_KEY_THUMBR */
1602 };
1603 
1604 static void wiimod_pro_in_ext(struct wiimote_data *wdata, const __u8 *ext)
1605 {
1606 	__s16 rx, ry, lx, ly;
1607 
1608 	/*   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
1609 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1610 	 *    1   |                   LX <7:0>                    |
1611 	 *   -----+-----------------------+-----------------------+
1612 	 *    2   |  0     0     0     0  |       LX <11:8>       |
1613 	 *   -----+-----------------------+-----------------------+
1614 	 *    3   |                   RX <7:0>                    |
1615 	 *   -----+-----------------------+-----------------------+
1616 	 *    4   |  0     0     0     0  |       RX <11:8>       |
1617 	 *   -----+-----------------------+-----------------------+
1618 	 *    5   |                   LY <7:0>                    |
1619 	 *   -----+-----------------------+-----------------------+
1620 	 *    6   |  0     0     0     0  |       LY <11:8>       |
1621 	 *   -----+-----------------------+-----------------------+
1622 	 *    7   |                   RY <7:0>                    |
1623 	 *   -----+-----------------------+-----------------------+
1624 	 *    8   |  0     0     0     0  |       RY <11:8>       |
1625 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1626 	 *    9   | BDR | BDD | BLT | B-  | BH  | B+  | BRT |  1  |
1627 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1628 	 *   10   | BZL | BB  | BY  | BA  | BX  | BZR | BDL | BDU |
1629 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1630 	 *   11   |  1  |     BATTERY     | USB |CHARG|LTHUM|RTHUM|
1631 	 *   -----+-----+-----------------+-----------+-----+-----+
1632 	 * All buttons are low-active (0 if pressed)
1633 	 * RX and RY are right analog stick
1634 	 * LX and LY are left analog stick
1635 	 * BLT is left trigger, BRT is right trigger.
1636 	 * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons
1637 	 * BZL is left Z button and BZR is right Z button
1638 	 * B-, BH, B+ are +, HOME and - buttons
1639 	 * BB, BY, BA, BX are A, B, X, Y buttons
1640 	 *
1641 	 * Bits marked as 0/1 are unknown and never changed during tests.
1642 	 *
1643 	 * Not entirely verified:
1644 	 *   CHARG: 1 if uncharging, 0 if charging
1645 	 *   USB: 1 if not connected, 0 if connected
1646 	 *   BATTERY: battery capacity from 000 (empty) to 100 (full)
1647 	 */
1648 
1649 	lx = (ext[0] & 0xff) | ((ext[1] & 0x0f) << 8);
1650 	rx = (ext[2] & 0xff) | ((ext[3] & 0x0f) << 8);
1651 	ly = (ext[4] & 0xff) | ((ext[5] & 0x0f) << 8);
1652 	ry = (ext[6] & 0xff) | ((ext[7] & 0x0f) << 8);
1653 
1654 	/* zero-point offsets */
1655 	lx -= 0x800;
1656 	ly = 0x800 - ly;
1657 	rx -= 0x800;
1658 	ry = 0x800 - ry;
1659 
1660 	/* Trivial automatic calibration. We don't know any calibration data
1661 	 * in the EEPROM so we must use the first report to calibrate the
1662 	 * null-position of the analog sticks. Users can retrigger calibration
1663 	 * via sysfs, or set it explicitly. If data is off more than abs(500),
1664 	 * we skip calibration as the sticks are likely to be moved already. */
1665 	if (!(wdata->state.flags & WIIPROTO_FLAG_PRO_CALIB_DONE)) {
1666 		wdata->state.flags |= WIIPROTO_FLAG_PRO_CALIB_DONE;
1667 		if (abs(lx) < 500)
1668 			wdata->state.calib_pro_sticks[0] = -lx;
1669 		if (abs(ly) < 500)
1670 			wdata->state.calib_pro_sticks[1] = -ly;
1671 		if (abs(rx) < 500)
1672 			wdata->state.calib_pro_sticks[2] = -rx;
1673 		if (abs(ry) < 500)
1674 			wdata->state.calib_pro_sticks[3] = -ry;
1675 	}
1676 
1677 	/* apply calibration data */
1678 	lx += wdata->state.calib_pro_sticks[0];
1679 	ly += wdata->state.calib_pro_sticks[1];
1680 	rx += wdata->state.calib_pro_sticks[2];
1681 	ry += wdata->state.calib_pro_sticks[3];
1682 
1683 	input_report_abs(wdata->extension.input, ABS_X, lx);
1684 	input_report_abs(wdata->extension.input, ABS_Y, ly);
1685 	input_report_abs(wdata->extension.input, ABS_RX, rx);
1686 	input_report_abs(wdata->extension.input, ABS_RY, ry);
1687 
1688 	input_report_key(wdata->extension.input,
1689 			 wiimod_pro_map[WIIMOD_PRO_KEY_RIGHT],
1690 			 !(ext[8] & 0x80));
1691 	input_report_key(wdata->extension.input,
1692 			 wiimod_pro_map[WIIMOD_PRO_KEY_DOWN],
1693 			 !(ext[8] & 0x40));
1694 	input_report_key(wdata->extension.input,
1695 			 wiimod_pro_map[WIIMOD_PRO_KEY_TL],
1696 			 !(ext[8] & 0x20));
1697 	input_report_key(wdata->extension.input,
1698 			 wiimod_pro_map[WIIMOD_PRO_KEY_MINUS],
1699 			 !(ext[8] & 0x10));
1700 	input_report_key(wdata->extension.input,
1701 			 wiimod_pro_map[WIIMOD_PRO_KEY_HOME],
1702 			 !(ext[8] & 0x08));
1703 	input_report_key(wdata->extension.input,
1704 			 wiimod_pro_map[WIIMOD_PRO_KEY_PLUS],
1705 			 !(ext[8] & 0x04));
1706 	input_report_key(wdata->extension.input,
1707 			 wiimod_pro_map[WIIMOD_PRO_KEY_TR],
1708 			 !(ext[8] & 0x02));
1709 
1710 	input_report_key(wdata->extension.input,
1711 			 wiimod_pro_map[WIIMOD_PRO_KEY_ZL],
1712 			 !(ext[9] & 0x80));
1713 	input_report_key(wdata->extension.input,
1714 			 wiimod_pro_map[WIIMOD_PRO_KEY_B],
1715 			 !(ext[9] & 0x40));
1716 	input_report_key(wdata->extension.input,
1717 			 wiimod_pro_map[WIIMOD_PRO_KEY_Y],
1718 			 !(ext[9] & 0x20));
1719 	input_report_key(wdata->extension.input,
1720 			 wiimod_pro_map[WIIMOD_PRO_KEY_A],
1721 			 !(ext[9] & 0x10));
1722 	input_report_key(wdata->extension.input,
1723 			 wiimod_pro_map[WIIMOD_PRO_KEY_X],
1724 			 !(ext[9] & 0x08));
1725 	input_report_key(wdata->extension.input,
1726 			 wiimod_pro_map[WIIMOD_PRO_KEY_ZR],
1727 			 !(ext[9] & 0x04));
1728 	input_report_key(wdata->extension.input,
1729 			 wiimod_pro_map[WIIMOD_PRO_KEY_LEFT],
1730 			 !(ext[9] & 0x02));
1731 	input_report_key(wdata->extension.input,
1732 			 wiimod_pro_map[WIIMOD_PRO_KEY_UP],
1733 			 !(ext[9] & 0x01));
1734 
1735 	input_report_key(wdata->extension.input,
1736 			 wiimod_pro_map[WIIMOD_PRO_KEY_THUMBL],
1737 			 !(ext[10] & 0x02));
1738 	input_report_key(wdata->extension.input,
1739 			 wiimod_pro_map[WIIMOD_PRO_KEY_THUMBR],
1740 			 !(ext[10] & 0x01));
1741 
1742 	input_sync(wdata->extension.input);
1743 }
1744 
1745 static int wiimod_pro_open(struct input_dev *dev)
1746 {
1747 	struct wiimote_data *wdata = input_get_drvdata(dev);
1748 	unsigned long flags;
1749 
1750 	spin_lock_irqsave(&wdata->state.lock, flags);
1751 	wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
1752 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1753 	spin_unlock_irqrestore(&wdata->state.lock, flags);
1754 
1755 	return 0;
1756 }
1757 
1758 static void wiimod_pro_close(struct input_dev *dev)
1759 {
1760 	struct wiimote_data *wdata = input_get_drvdata(dev);
1761 	unsigned long flags;
1762 
1763 	spin_lock_irqsave(&wdata->state.lock, flags);
1764 	wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
1765 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1766 	spin_unlock_irqrestore(&wdata->state.lock, flags);
1767 }
1768 
1769 static int wiimod_pro_play(struct input_dev *dev, void *data,
1770 			   struct ff_effect *eff)
1771 {
1772 	struct wiimote_data *wdata = input_get_drvdata(dev);
1773 	__u8 value;
1774 
1775 	/*
1776 	 * The wiimote supports only a single rumble motor so if any magnitude
1777 	 * is set to non-zero then we start the rumble motor. If both are set to
1778 	 * zero, we stop the rumble motor.
1779 	 */
1780 
1781 	if (eff->u.rumble.strong_magnitude || eff->u.rumble.weak_magnitude)
1782 		value = 1;
1783 	else
1784 		value = 0;
1785 
1786 	/* Locking state.lock here might deadlock with input_event() calls.
1787 	 * schedule_work acts as barrier. Merging multiple changes is fine. */
1788 	wdata->state.cache_rumble = value;
1789 	schedule_work(&wdata->rumble_worker);
1790 
1791 	return 0;
1792 }
1793 
1794 static ssize_t wiimod_pro_calib_show(struct device *dev,
1795 				     struct device_attribute *attr,
1796 				     char *out)
1797 {
1798 	struct wiimote_data *wdata = dev_to_wii(dev);
1799 	int r;
1800 
1801 	r = 0;
1802 	r += sprintf(&out[r], "%+06hd:", wdata->state.calib_pro_sticks[0]);
1803 	r += sprintf(&out[r], "%+06hd ", wdata->state.calib_pro_sticks[1]);
1804 	r += sprintf(&out[r], "%+06hd:", wdata->state.calib_pro_sticks[2]);
1805 	r += sprintf(&out[r], "%+06hd\n", wdata->state.calib_pro_sticks[3]);
1806 
1807 	return r;
1808 }
1809 
1810 static ssize_t wiimod_pro_calib_store(struct device *dev,
1811 				      struct device_attribute *attr,
1812 				      const char *buf, size_t count)
1813 {
1814 	struct wiimote_data *wdata = dev_to_wii(dev);
1815 	int r;
1816 	s16 x1, y1, x2, y2;
1817 
1818 	if (!strncmp(buf, "scan\n", 5)) {
1819 		spin_lock_irq(&wdata->state.lock);
1820 		wdata->state.flags &= ~WIIPROTO_FLAG_PRO_CALIB_DONE;
1821 		spin_unlock_irq(&wdata->state.lock);
1822 	} else {
1823 		r = sscanf(buf, "%hd:%hd %hd:%hd", &x1, &y1, &x2, &y2);
1824 		if (r != 4)
1825 			return -EINVAL;
1826 
1827 		spin_lock_irq(&wdata->state.lock);
1828 		wdata->state.flags |= WIIPROTO_FLAG_PRO_CALIB_DONE;
1829 		spin_unlock_irq(&wdata->state.lock);
1830 
1831 		wdata->state.calib_pro_sticks[0] = x1;
1832 		wdata->state.calib_pro_sticks[1] = y1;
1833 		wdata->state.calib_pro_sticks[2] = x2;
1834 		wdata->state.calib_pro_sticks[3] = y2;
1835 	}
1836 
1837 	return strnlen(buf, PAGE_SIZE);
1838 }
1839 
1840 static DEVICE_ATTR(pro_calib, S_IRUGO|S_IWUSR|S_IWGRP, wiimod_pro_calib_show,
1841 		   wiimod_pro_calib_store);
1842 
1843 static int wiimod_pro_probe(const struct wiimod_ops *ops,
1844 			    struct wiimote_data *wdata)
1845 {
1846 	int ret, i;
1847 	unsigned long flags;
1848 
1849 	INIT_WORK(&wdata->rumble_worker, wiimod_rumble_worker);
1850 	wdata->state.calib_pro_sticks[0] = 0;
1851 	wdata->state.calib_pro_sticks[1] = 0;
1852 	wdata->state.calib_pro_sticks[2] = 0;
1853 	wdata->state.calib_pro_sticks[3] = 0;
1854 
1855 	spin_lock_irqsave(&wdata->state.lock, flags);
1856 	wdata->state.flags &= ~WIIPROTO_FLAG_PRO_CALIB_DONE;
1857 	spin_unlock_irqrestore(&wdata->state.lock, flags);
1858 
1859 	wdata->extension.input = input_allocate_device();
1860 	if (!wdata->extension.input)
1861 		return -ENOMEM;
1862 
1863 	set_bit(FF_RUMBLE, wdata->extension.input->ffbit);
1864 	input_set_drvdata(wdata->extension.input, wdata);
1865 
1866 	if (input_ff_create_memless(wdata->extension.input, NULL,
1867 				    wiimod_pro_play)) {
1868 		ret = -ENOMEM;
1869 		goto err_free;
1870 	}
1871 
1872 	ret = device_create_file(&wdata->hdev->dev,
1873 				 &dev_attr_pro_calib);
1874 	if (ret) {
1875 		hid_err(wdata->hdev, "cannot create sysfs attribute\n");
1876 		goto err_free;
1877 	}
1878 
1879 	wdata->extension.input->open = wiimod_pro_open;
1880 	wdata->extension.input->close = wiimod_pro_close;
1881 	wdata->extension.input->dev.parent = &wdata->hdev->dev;
1882 	wdata->extension.input->id.bustype = wdata->hdev->bus;
1883 	wdata->extension.input->id.vendor = wdata->hdev->vendor;
1884 	wdata->extension.input->id.product = wdata->hdev->product;
1885 	wdata->extension.input->id.version = wdata->hdev->version;
1886 	wdata->extension.input->name = WIIMOTE_NAME " Pro Controller";
1887 
1888 	set_bit(EV_KEY, wdata->extension.input->evbit);
1889 	for (i = 0; i < WIIMOD_PRO_KEY_NUM; ++i)
1890 		set_bit(wiimod_pro_map[i],
1891 			wdata->extension.input->keybit);
1892 
1893 	set_bit(EV_ABS, wdata->extension.input->evbit);
1894 	set_bit(ABS_X, wdata->extension.input->absbit);
1895 	set_bit(ABS_Y, wdata->extension.input->absbit);
1896 	set_bit(ABS_RX, wdata->extension.input->absbit);
1897 	set_bit(ABS_RY, wdata->extension.input->absbit);
1898 	input_set_abs_params(wdata->extension.input,
1899 			     ABS_X, -0x400, 0x400, 4, 100);
1900 	input_set_abs_params(wdata->extension.input,
1901 			     ABS_Y, -0x400, 0x400, 4, 100);
1902 	input_set_abs_params(wdata->extension.input,
1903 			     ABS_RX, -0x400, 0x400, 4, 100);
1904 	input_set_abs_params(wdata->extension.input,
1905 			     ABS_RY, -0x400, 0x400, 4, 100);
1906 
1907 	ret = input_register_device(wdata->extension.input);
1908 	if (ret)
1909 		goto err_file;
1910 
1911 	return 0;
1912 
1913 err_file:
1914 	device_remove_file(&wdata->hdev->dev,
1915 			   &dev_attr_pro_calib);
1916 err_free:
1917 	input_free_device(wdata->extension.input);
1918 	wdata->extension.input = NULL;
1919 	return ret;
1920 }
1921 
1922 static void wiimod_pro_remove(const struct wiimod_ops *ops,
1923 			      struct wiimote_data *wdata)
1924 {
1925 	unsigned long flags;
1926 
1927 	if (!wdata->extension.input)
1928 		return;
1929 
1930 	input_unregister_device(wdata->extension.input);
1931 	wdata->extension.input = NULL;
1932 	cancel_work_sync(&wdata->rumble_worker);
1933 	device_remove_file(&wdata->hdev->dev,
1934 			   &dev_attr_pro_calib);
1935 
1936 	spin_lock_irqsave(&wdata->state.lock, flags);
1937 	wiiproto_req_rumble(wdata, 0);
1938 	spin_unlock_irqrestore(&wdata->state.lock, flags);
1939 }
1940 
1941 static const struct wiimod_ops wiimod_pro = {
1942 	.flags = WIIMOD_FLAG_EXT16,
1943 	.arg = 0,
1944 	.probe = wiimod_pro_probe,
1945 	.remove = wiimod_pro_remove,
1946 	.in_ext = wiimod_pro_in_ext,
1947 };
1948 
1949 /*
1950  * Drums
1951  * Guitar-Hero, Rock-Band and other games came bundled with drums which can
1952  * be plugged as extension to a Wiimote. Drum-reports are still not entirely
1953  * figured out, but the most important information is known.
1954  * We create a separate device for drums and report all information via this
1955  * input device.
1956  */
1957 
1958 static inline void wiimod_drums_report_pressure(struct wiimote_data *wdata,
1959 						__u8 none, __u8 which,
1960 						__u8 pressure, __u8 onoff,
1961 						__u8 *store, __u16 code,
1962 						__u8 which_code)
1963 {
1964 	static const __u8 default_pressure = 3;
1965 
1966 	if (!none && which == which_code) {
1967 		*store = pressure;
1968 		input_report_abs(wdata->extension.input, code, *store);
1969 	} else if (onoff != !!*store) {
1970 		*store = onoff ? default_pressure : 0;
1971 		input_report_abs(wdata->extension.input, code, *store);
1972 	}
1973 }
1974 
1975 static void wiimod_drums_in_ext(struct wiimote_data *wdata, const __u8 *ext)
1976 {
1977 	__u8 pressure, which, none, hhp, sx, sy;
1978 	__u8 o, r, y, g, b, bass, bm, bp;
1979 
1980 	/*   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
1981 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1982 	 *    1   |  0  |  0  |              SX <5:0>             |
1983 	 *    2   |  0  |  0  |              SY <5:0>             |
1984 	 *   -----+-----+-----+-----------------------------+-----+
1985 	 *    3   | HPP | NON |         WHICH <5:1>         |  ?  |
1986 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1987 	 *    4   |   SOFT <7:5>    |  0  |  1  |  1  |  0  |  ?  |
1988 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1989 	 *    5   |  ?  |  1  |  1  | B-  |  1  | B+  |  1  |  ?  |
1990 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1991 	 *    6   |  O  |  R  |  Y  |  G  |  B  | BSS |  1  |  1  |
1992 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1993 	 * All buttons are 0 if pressed
1994 	 *
1995 	 * With Motion+ enabled, the following bits will get invalid:
1996 	 *   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
1997 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
1998 	 *    1   |  0  |  0  |              SX <5:1>       |XXXXX|
1999 	 *    2   |  0  |  0  |              SY <5:1>       |XXXXX|
2000 	 *   -----+-----+-----+-----------------------------+-----+
2001 	 *    3   | HPP | NON |         WHICH <5:1>         |  ?  |
2002 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2003 	 *    4   |   SOFT <7:5>    |  0  |  1  |  1  |  0  |  ?  |
2004 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2005 	 *    5   |  ?  |  1  |  1  | B-  |  1  | B+  |  1  |XXXXX|
2006 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2007 	 *    6   |  O  |  R  |  Y  |  G  |  B  | BSS |XXXXX|XXXXX|
2008 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2009 	 */
2010 
2011 	pressure = 7 - (ext[3] >> 5);
2012 	which = (ext[2] >> 1) & 0x1f;
2013 	none = !!(ext[2] & 0x40);
2014 	hhp = !(ext[2] & 0x80);
2015 	sx = ext[0] & 0x3f;
2016 	sy = ext[1] & 0x3f;
2017 	o = !(ext[5] & 0x80);
2018 	r = !(ext[5] & 0x40);
2019 	y = !(ext[5] & 0x20);
2020 	g = !(ext[5] & 0x10);
2021 	b = !(ext[5] & 0x08);
2022 	bass = !(ext[5] & 0x04);
2023 	bm = !(ext[4] & 0x10);
2024 	bp = !(ext[4] & 0x04);
2025 
2026 	if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
2027 		sx &= 0x3e;
2028 		sy &= 0x3e;
2029 	}
2030 
2031 	wiimod_drums_report_pressure(wdata, none, which, pressure,
2032 				     o, &wdata->state.pressure_drums[0],
2033 				     ABS_HAT2Y, 0x0e);
2034 	wiimod_drums_report_pressure(wdata, none, which, pressure,
2035 				     r, &wdata->state.pressure_drums[1],
2036 				     ABS_HAT0X, 0x19);
2037 	wiimod_drums_report_pressure(wdata, none, which, pressure,
2038 				     y, &wdata->state.pressure_drums[2],
2039 				     ABS_HAT2X, 0x11);
2040 	wiimod_drums_report_pressure(wdata, none, which, pressure,
2041 				     g, &wdata->state.pressure_drums[3],
2042 				     ABS_HAT1X, 0x12);
2043 	wiimod_drums_report_pressure(wdata, none, which, pressure,
2044 				     b, &wdata->state.pressure_drums[4],
2045 				     ABS_HAT0Y, 0x0f);
2046 
2047 	/* Bass shares pressure with hi-hat (set via hhp) */
2048 	wiimod_drums_report_pressure(wdata, none, hhp ? 0xff : which, pressure,
2049 				     bass, &wdata->state.pressure_drums[5],
2050 				     ABS_HAT3X, 0x1b);
2051 	/* Hi-hat has no on/off values, just pressure. Force to off/0. */
2052 	wiimod_drums_report_pressure(wdata, none, hhp ? which : 0xff, pressure,
2053 				     0, &wdata->state.pressure_drums[6],
2054 				     ABS_HAT3Y, 0x0e);
2055 
2056 	input_report_abs(wdata->extension.input, ABS_X, sx - 0x20);
2057 	input_report_abs(wdata->extension.input, ABS_Y, sy - 0x20);
2058 
2059 	input_report_key(wdata->extension.input, BTN_START, bp);
2060 	input_report_key(wdata->extension.input, BTN_SELECT, bm);
2061 
2062 	input_sync(wdata->extension.input);
2063 }
2064 
2065 static int wiimod_drums_open(struct input_dev *dev)
2066 {
2067 	struct wiimote_data *wdata = input_get_drvdata(dev);
2068 	unsigned long flags;
2069 
2070 	spin_lock_irqsave(&wdata->state.lock, flags);
2071 	wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
2072 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
2073 	spin_unlock_irqrestore(&wdata->state.lock, flags);
2074 
2075 	return 0;
2076 }
2077 
2078 static void wiimod_drums_close(struct input_dev *dev)
2079 {
2080 	struct wiimote_data *wdata = input_get_drvdata(dev);
2081 	unsigned long flags;
2082 
2083 	spin_lock_irqsave(&wdata->state.lock, flags);
2084 	wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
2085 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
2086 	spin_unlock_irqrestore(&wdata->state.lock, flags);
2087 }
2088 
2089 static int wiimod_drums_probe(const struct wiimod_ops *ops,
2090 			      struct wiimote_data *wdata)
2091 {
2092 	int ret;
2093 
2094 	wdata->extension.input = input_allocate_device();
2095 	if (!wdata->extension.input)
2096 		return -ENOMEM;
2097 
2098 	input_set_drvdata(wdata->extension.input, wdata);
2099 	wdata->extension.input->open = wiimod_drums_open;
2100 	wdata->extension.input->close = wiimod_drums_close;
2101 	wdata->extension.input->dev.parent = &wdata->hdev->dev;
2102 	wdata->extension.input->id.bustype = wdata->hdev->bus;
2103 	wdata->extension.input->id.vendor = wdata->hdev->vendor;
2104 	wdata->extension.input->id.product = wdata->hdev->product;
2105 	wdata->extension.input->id.version = wdata->hdev->version;
2106 	wdata->extension.input->name = WIIMOTE_NAME " Drums";
2107 
2108 	set_bit(EV_KEY, wdata->extension.input->evbit);
2109 	set_bit(BTN_START, wdata->extension.input->keybit);
2110 	set_bit(BTN_SELECT, wdata->extension.input->keybit);
2111 
2112 	set_bit(EV_ABS, wdata->extension.input->evbit);
2113 	set_bit(ABS_X, wdata->extension.input->absbit);
2114 	set_bit(ABS_Y, wdata->extension.input->absbit);
2115 	set_bit(ABS_HAT0X, wdata->extension.input->absbit);
2116 	set_bit(ABS_HAT0Y, wdata->extension.input->absbit);
2117 	set_bit(ABS_HAT1X, wdata->extension.input->absbit);
2118 	set_bit(ABS_HAT2X, wdata->extension.input->absbit);
2119 	set_bit(ABS_HAT2Y, wdata->extension.input->absbit);
2120 	set_bit(ABS_HAT3X, wdata->extension.input->absbit);
2121 	set_bit(ABS_HAT3Y, wdata->extension.input->absbit);
2122 	input_set_abs_params(wdata->extension.input,
2123 			     ABS_X, -32, 31, 1, 1);
2124 	input_set_abs_params(wdata->extension.input,
2125 			     ABS_Y, -32, 31, 1, 1);
2126 	input_set_abs_params(wdata->extension.input,
2127 			     ABS_HAT0X, 0, 7, 0, 0);
2128 	input_set_abs_params(wdata->extension.input,
2129 			     ABS_HAT0Y, 0, 7, 0, 0);
2130 	input_set_abs_params(wdata->extension.input,
2131 			     ABS_HAT1X, 0, 7, 0, 0);
2132 	input_set_abs_params(wdata->extension.input,
2133 			     ABS_HAT2X, 0, 7, 0, 0);
2134 	input_set_abs_params(wdata->extension.input,
2135 			     ABS_HAT2Y, 0, 7, 0, 0);
2136 	input_set_abs_params(wdata->extension.input,
2137 			     ABS_HAT3X, 0, 7, 0, 0);
2138 	input_set_abs_params(wdata->extension.input,
2139 			     ABS_HAT3Y, 0, 7, 0, 0);
2140 
2141 	ret = input_register_device(wdata->extension.input);
2142 	if (ret)
2143 		goto err_free;
2144 
2145 	return 0;
2146 
2147 err_free:
2148 	input_free_device(wdata->extension.input);
2149 	wdata->extension.input = NULL;
2150 	return ret;
2151 }
2152 
2153 static void wiimod_drums_remove(const struct wiimod_ops *ops,
2154 				struct wiimote_data *wdata)
2155 {
2156 	if (!wdata->extension.input)
2157 		return;
2158 
2159 	input_unregister_device(wdata->extension.input);
2160 	wdata->extension.input = NULL;
2161 }
2162 
2163 static const struct wiimod_ops wiimod_drums = {
2164 	.flags = 0,
2165 	.arg = 0,
2166 	.probe = wiimod_drums_probe,
2167 	.remove = wiimod_drums_remove,
2168 	.in_ext = wiimod_drums_in_ext,
2169 };
2170 
2171 /*
2172  * Guitar
2173  * Guitar-Hero, Rock-Band and other games came bundled with guitars which can
2174  * be plugged as extension to a Wiimote.
2175  * We create a separate device for guitars and report all information via this
2176  * input device.
2177  */
2178 
2179 enum wiimod_guitar_keys {
2180 	WIIMOD_GUITAR_KEY_G,
2181 	WIIMOD_GUITAR_KEY_R,
2182 	WIIMOD_GUITAR_KEY_Y,
2183 	WIIMOD_GUITAR_KEY_B,
2184 	WIIMOD_GUITAR_KEY_O,
2185 	WIIMOD_GUITAR_KEY_UP,
2186 	WIIMOD_GUITAR_KEY_DOWN,
2187 	WIIMOD_GUITAR_KEY_PLUS,
2188 	WIIMOD_GUITAR_KEY_MINUS,
2189 	WIIMOD_GUITAR_KEY_NUM,
2190 };
2191 
2192 static const __u16 wiimod_guitar_map[] = {
2193 	BTN_1,			/* WIIMOD_GUITAR_KEY_G */
2194 	BTN_2,			/* WIIMOD_GUITAR_KEY_R */
2195 	BTN_3,			/* WIIMOD_GUITAR_KEY_Y */
2196 	BTN_4,			/* WIIMOD_GUITAR_KEY_B */
2197 	BTN_5,			/* WIIMOD_GUITAR_KEY_O */
2198 	BTN_DPAD_UP,		/* WIIMOD_GUITAR_KEY_UP */
2199 	BTN_DPAD_DOWN,		/* WIIMOD_GUITAR_KEY_DOWN */
2200 	BTN_START,		/* WIIMOD_GUITAR_KEY_PLUS */
2201 	BTN_SELECT,		/* WIIMOD_GUITAR_KEY_MINUS */
2202 };
2203 
2204 static void wiimod_guitar_in_ext(struct wiimote_data *wdata, const __u8 *ext)
2205 {
2206 	__u8 sx, sy, tb, wb, bd, bm, bp, bo, br, bb, bg, by, bu;
2207 
2208 	/*   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
2209 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2210 	 *    1   |  0  |  0  |              SX <5:0>             |
2211 	 *    2   |  0  |  0  |              SY <5:0>             |
2212 	 *   -----+-----+-----+-----+-----------------------------+
2213 	 *    3   |  0  |  0  |  0  |      TB <4:0>               |
2214 	 *   -----+-----+-----+-----+-----------------------------+
2215 	 *    4   |  0  |  0  |  0  |      WB <4:0>               |
2216 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2217 	 *    5   |  1  | BD  |  1  | B-  |  1  | B+  |  1  |  1  |
2218 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2219 	 *    6   | BO  | BR  | BB  | BG  | BY  |  1  |  1  | BU  |
2220 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2221 	 * All buttons are 0 if pressed
2222 	 *
2223 	 * With Motion+ enabled, it will look like this:
2224 	 *   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
2225 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2226 	 *    1   |  0  |  0  |              SX <5:1>       | BU  |
2227 	 *    2   |  0  |  0  |              SY <5:1>       |  1  |
2228 	 *   -----+-----+-----+-----+-----------------------+-----+
2229 	 *    3   |  0  |  0  |  0  |      TB <4:0>               |
2230 	 *   -----+-----+-----+-----+-----------------------------+
2231 	 *    4   |  0  |  0  |  0  |      WB <4:0>               |
2232 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2233 	 *    5   |  1  | BD  |  1  | B-  |  1  | B+  |  1  |XXXXX|
2234 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2235 	 *    6   | BO  | BR  | BB  | BG  | BY  |  1  |XXXXX|XXXXX|
2236 	 *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
2237 	 */
2238 
2239 	sx = ext[0] & 0x3f;
2240 	sy = ext[1] & 0x3f;
2241 	tb = ext[2] & 0x1f;
2242 	wb = ext[3] & 0x1f;
2243 	bd = !(ext[4] & 0x40);
2244 	bm = !(ext[4] & 0x10);
2245 	bp = !(ext[4] & 0x04);
2246 	bo = !(ext[5] & 0x80);
2247 	br = !(ext[5] & 0x40);
2248 	bb = !(ext[5] & 0x20);
2249 	bg = !(ext[5] & 0x10);
2250 	by = !(ext[5] & 0x08);
2251 	bu = !(ext[5] & 0x01);
2252 
2253 	if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
2254 		bu = !(ext[0] & 0x01);
2255 		sx &= 0x3e;
2256 		sy &= 0x3e;
2257 	}
2258 
2259 	input_report_abs(wdata->extension.input, ABS_X, sx - 0x20);
2260 	input_report_abs(wdata->extension.input, ABS_Y, sy - 0x20);
2261 	input_report_abs(wdata->extension.input, ABS_HAT0X, tb);
2262 	input_report_abs(wdata->extension.input, ABS_HAT1X, wb - 0x10);
2263 
2264 	input_report_key(wdata->extension.input,
2265 			 wiimod_guitar_map[WIIMOD_GUITAR_KEY_G],
2266 			 bg);
2267 	input_report_key(wdata->extension.input,
2268 			 wiimod_guitar_map[WIIMOD_GUITAR_KEY_R],
2269 			 br);
2270 	input_report_key(wdata->extension.input,
2271 			 wiimod_guitar_map[WIIMOD_GUITAR_KEY_Y],
2272 			 by);
2273 	input_report_key(wdata->extension.input,
2274 			 wiimod_guitar_map[WIIMOD_GUITAR_KEY_B],
2275 			 bb);
2276 	input_report_key(wdata->extension.input,
2277 			 wiimod_guitar_map[WIIMOD_GUITAR_KEY_O],
2278 			 bo);
2279 	input_report_key(wdata->extension.input,
2280 			 wiimod_guitar_map[WIIMOD_GUITAR_KEY_UP],
2281 			 bu);
2282 	input_report_key(wdata->extension.input,
2283 			 wiimod_guitar_map[WIIMOD_GUITAR_KEY_DOWN],
2284 			 bd);
2285 	input_report_key(wdata->extension.input,
2286 			 wiimod_guitar_map[WIIMOD_GUITAR_KEY_PLUS],
2287 			 bp);
2288 	input_report_key(wdata->extension.input,
2289 			 wiimod_guitar_map[WIIMOD_GUITAR_KEY_MINUS],
2290 			 bm);
2291 
2292 	input_sync(wdata->extension.input);
2293 }
2294 
2295 static int wiimod_guitar_open(struct input_dev *dev)
2296 {
2297 	struct wiimote_data *wdata = input_get_drvdata(dev);
2298 	unsigned long flags;
2299 
2300 	spin_lock_irqsave(&wdata->state.lock, flags);
2301 	wdata->state.flags |= WIIPROTO_FLAG_EXT_USED;
2302 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
2303 	spin_unlock_irqrestore(&wdata->state.lock, flags);
2304 
2305 	return 0;
2306 }
2307 
2308 static void wiimod_guitar_close(struct input_dev *dev)
2309 {
2310 	struct wiimote_data *wdata = input_get_drvdata(dev);
2311 	unsigned long flags;
2312 
2313 	spin_lock_irqsave(&wdata->state.lock, flags);
2314 	wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
2315 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
2316 	spin_unlock_irqrestore(&wdata->state.lock, flags);
2317 }
2318 
2319 static int wiimod_guitar_probe(const struct wiimod_ops *ops,
2320 			       struct wiimote_data *wdata)
2321 {
2322 	int ret, i;
2323 
2324 	wdata->extension.input = input_allocate_device();
2325 	if (!wdata->extension.input)
2326 		return -ENOMEM;
2327 
2328 	input_set_drvdata(wdata->extension.input, wdata);
2329 	wdata->extension.input->open = wiimod_guitar_open;
2330 	wdata->extension.input->close = wiimod_guitar_close;
2331 	wdata->extension.input->dev.parent = &wdata->hdev->dev;
2332 	wdata->extension.input->id.bustype = wdata->hdev->bus;
2333 	wdata->extension.input->id.vendor = wdata->hdev->vendor;
2334 	wdata->extension.input->id.product = wdata->hdev->product;
2335 	wdata->extension.input->id.version = wdata->hdev->version;
2336 	wdata->extension.input->name = WIIMOTE_NAME " Guitar";
2337 
2338 	set_bit(EV_KEY, wdata->extension.input->evbit);
2339 	for (i = 0; i < WIIMOD_GUITAR_KEY_NUM; ++i)
2340 		set_bit(wiimod_guitar_map[i],
2341 			wdata->extension.input->keybit);
2342 
2343 	set_bit(EV_ABS, wdata->extension.input->evbit);
2344 	set_bit(ABS_X, wdata->extension.input->absbit);
2345 	set_bit(ABS_Y, wdata->extension.input->absbit);
2346 	set_bit(ABS_HAT0X, wdata->extension.input->absbit);
2347 	set_bit(ABS_HAT1X, wdata->extension.input->absbit);
2348 	input_set_abs_params(wdata->extension.input,
2349 			     ABS_X, -32, 31, 1, 1);
2350 	input_set_abs_params(wdata->extension.input,
2351 			     ABS_Y, -32, 31, 1, 1);
2352 	input_set_abs_params(wdata->extension.input,
2353 			     ABS_HAT0X, 0, 0x1f, 1, 1);
2354 	input_set_abs_params(wdata->extension.input,
2355 			     ABS_HAT1X, 0, 0x0f, 1, 1);
2356 
2357 	ret = input_register_device(wdata->extension.input);
2358 	if (ret)
2359 		goto err_free;
2360 
2361 	return 0;
2362 
2363 err_free:
2364 	input_free_device(wdata->extension.input);
2365 	wdata->extension.input = NULL;
2366 	return ret;
2367 }
2368 
2369 static void wiimod_guitar_remove(const struct wiimod_ops *ops,
2370 				 struct wiimote_data *wdata)
2371 {
2372 	if (!wdata->extension.input)
2373 		return;
2374 
2375 	input_unregister_device(wdata->extension.input);
2376 	wdata->extension.input = NULL;
2377 }
2378 
2379 static const struct wiimod_ops wiimod_guitar = {
2380 	.flags = 0,
2381 	.arg = 0,
2382 	.probe = wiimod_guitar_probe,
2383 	.remove = wiimod_guitar_remove,
2384 	.in_ext = wiimod_guitar_in_ext,
2385 };
2386 
2387 /*
2388  * Builtin Motion Plus
2389  * This module simply sets the WIIPROTO_FLAG_BUILTIN_MP protocol flag which
2390  * disables polling for Motion-Plus. This should be set only for devices which
2391  * don't allow MP hotplugging.
2392  */
2393 
2394 static int wiimod_builtin_mp_probe(const struct wiimod_ops *ops,
2395 				   struct wiimote_data *wdata)
2396 {
2397 	unsigned long flags;
2398 
2399 	spin_lock_irqsave(&wdata->state.lock, flags);
2400 	wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP;
2401 	spin_unlock_irqrestore(&wdata->state.lock, flags);
2402 
2403 	return 0;
2404 }
2405 
2406 static void wiimod_builtin_mp_remove(const struct wiimod_ops *ops,
2407 				     struct wiimote_data *wdata)
2408 {
2409 	unsigned long flags;
2410 
2411 	spin_lock_irqsave(&wdata->state.lock, flags);
2412 	wdata->state.flags |= WIIPROTO_FLAG_BUILTIN_MP;
2413 	spin_unlock_irqrestore(&wdata->state.lock, flags);
2414 }
2415 
2416 static const struct wiimod_ops wiimod_builtin_mp = {
2417 	.flags = 0,
2418 	.arg = 0,
2419 	.probe = wiimod_builtin_mp_probe,
2420 	.remove = wiimod_builtin_mp_remove,
2421 };
2422 
2423 /*
2424  * No Motion Plus
2425  * This module simply sets the WIIPROTO_FLAG_NO_MP protocol flag which
2426  * disables motion-plus. This is needed for devices that advertise this but we
2427  * don't know how to use it (or whether it is actually present).
2428  */
2429 
2430 static int wiimod_no_mp_probe(const struct wiimod_ops *ops,
2431 			      struct wiimote_data *wdata)
2432 {
2433 	unsigned long flags;
2434 
2435 	spin_lock_irqsave(&wdata->state.lock, flags);
2436 	wdata->state.flags |= WIIPROTO_FLAG_NO_MP;
2437 	spin_unlock_irqrestore(&wdata->state.lock, flags);
2438 
2439 	return 0;
2440 }
2441 
2442 static void wiimod_no_mp_remove(const struct wiimod_ops *ops,
2443 				struct wiimote_data *wdata)
2444 {
2445 	unsigned long flags;
2446 
2447 	spin_lock_irqsave(&wdata->state.lock, flags);
2448 	wdata->state.flags |= WIIPROTO_FLAG_NO_MP;
2449 	spin_unlock_irqrestore(&wdata->state.lock, flags);
2450 }
2451 
2452 static const struct wiimod_ops wiimod_no_mp = {
2453 	.flags = 0,
2454 	.arg = 0,
2455 	.probe = wiimod_no_mp_probe,
2456 	.remove = wiimod_no_mp_remove,
2457 };
2458 
2459 /*
2460  * Motion Plus
2461  * The Motion Plus extension provides rotation sensors (gyro) as a small
2462  * extension device for Wii Remotes. Many devices have them built-in so
2463  * you cannot see them from the outside.
2464  * Motion Plus extensions are special because they are on a separate extension
2465  * port and allow other extensions to be used simultaneously. This is all
2466  * handled by the Wiimote Core so we don't have to deal with it.
2467  */
2468 
2469 static void wiimod_mp_in_mp(struct wiimote_data *wdata, const __u8 *ext)
2470 {
2471 	__s32 x, y, z;
2472 
2473 	/*        |   8    7    6    5    4    3 |  2  |  1  |
2474 	 *   -----+------------------------------+-----+-----+
2475 	 *    1   |               Yaw Speed <7:0>            |
2476 	 *    2   |              Roll Speed <7:0>            |
2477 	 *    3   |             Pitch Speed <7:0>            |
2478 	 *   -----+------------------------------+-----+-----+
2479 	 *    4   |       Yaw Speed <13:8>       | Yaw |Pitch|
2480 	 *   -----+------------------------------+-----+-----+
2481 	 *    5   |      Roll Speed <13:8>       |Roll | Ext |
2482 	 *   -----+------------------------------+-----+-----+
2483 	 *    6   |     Pitch Speed <13:8>       |  1  |  0  |
2484 	 *   -----+------------------------------+-----+-----+
2485 	 * The single bits Yaw, Roll, Pitch in the lower right corner specify
2486 	 * whether the wiimote is rotating fast (0) or slow (1). Speed for slow
2487 	 * roation is 8192/440 units / deg/s and for fast rotation 8192/2000
2488 	 * units / deg/s. To get a linear scale for fast rotation we multiply
2489 	 * by 2000/440 = ~4.5454 and scale both fast and slow by 9 to match the
2490 	 * previous scale reported by this driver.
2491 	 * This leaves a linear scale with 8192*9/440 (~167.564) units / deg/s.
2492 	 * If the wiimote is not rotating the sensor reports 2^13 = 8192.
2493 	 * Ext specifies whether an extension is connected to the motionp.
2494 	 * which is parsed by wiimote-core.
2495 	 */
2496 
2497 	x = ext[0];
2498 	y = ext[1];
2499 	z = ext[2];
2500 
2501 	x |= (((__u16)ext[3]) << 6) & 0xff00;
2502 	y |= (((__u16)ext[4]) << 6) & 0xff00;
2503 	z |= (((__u16)ext[5]) << 6) & 0xff00;
2504 
2505 	x -= 8192;
2506 	y -= 8192;
2507 	z -= 8192;
2508 
2509 	if (!(ext[3] & 0x02))
2510 		x = (x * 2000 * 9) / 440;
2511 	else
2512 		x *= 9;
2513 	if (!(ext[4] & 0x02))
2514 		y = (y * 2000 * 9) / 440;
2515 	else
2516 		y *= 9;
2517 	if (!(ext[3] & 0x01))
2518 		z = (z * 2000 * 9) / 440;
2519 	else
2520 		z *= 9;
2521 
2522 	input_report_abs(wdata->mp, ABS_RX, x);
2523 	input_report_abs(wdata->mp, ABS_RY, y);
2524 	input_report_abs(wdata->mp, ABS_RZ, z);
2525 	input_sync(wdata->mp);
2526 }
2527 
2528 static int wiimod_mp_open(struct input_dev *dev)
2529 {
2530 	struct wiimote_data *wdata = input_get_drvdata(dev);
2531 	unsigned long flags;
2532 
2533 	spin_lock_irqsave(&wdata->state.lock, flags);
2534 	wdata->state.flags |= WIIPROTO_FLAG_MP_USED;
2535 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
2536 	__wiimote_schedule(wdata);
2537 	spin_unlock_irqrestore(&wdata->state.lock, flags);
2538 
2539 	return 0;
2540 }
2541 
2542 static void wiimod_mp_close(struct input_dev *dev)
2543 {
2544 	struct wiimote_data *wdata = input_get_drvdata(dev);
2545 	unsigned long flags;
2546 
2547 	spin_lock_irqsave(&wdata->state.lock, flags);
2548 	wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED;
2549 	wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
2550 	__wiimote_schedule(wdata);
2551 	spin_unlock_irqrestore(&wdata->state.lock, flags);
2552 }
2553 
2554 static int wiimod_mp_probe(const struct wiimod_ops *ops,
2555 			   struct wiimote_data *wdata)
2556 {
2557 	int ret;
2558 
2559 	wdata->mp = input_allocate_device();
2560 	if (!wdata->mp)
2561 		return -ENOMEM;
2562 
2563 	input_set_drvdata(wdata->mp, wdata);
2564 	wdata->mp->open = wiimod_mp_open;
2565 	wdata->mp->close = wiimod_mp_close;
2566 	wdata->mp->dev.parent = &wdata->hdev->dev;
2567 	wdata->mp->id.bustype = wdata->hdev->bus;
2568 	wdata->mp->id.vendor = wdata->hdev->vendor;
2569 	wdata->mp->id.product = wdata->hdev->product;
2570 	wdata->mp->id.version = wdata->hdev->version;
2571 	wdata->mp->name = WIIMOTE_NAME " Motion Plus";
2572 
2573 	set_bit(EV_ABS, wdata->mp->evbit);
2574 	set_bit(ABS_RX, wdata->mp->absbit);
2575 	set_bit(ABS_RY, wdata->mp->absbit);
2576 	set_bit(ABS_RZ, wdata->mp->absbit);
2577 	input_set_abs_params(wdata->mp,
2578 			     ABS_RX, -16000, 16000, 4, 8);
2579 	input_set_abs_params(wdata->mp,
2580 			     ABS_RY, -16000, 16000, 4, 8);
2581 	input_set_abs_params(wdata->mp,
2582 			     ABS_RZ, -16000, 16000, 4, 8);
2583 
2584 	ret = input_register_device(wdata->mp);
2585 	if (ret)
2586 		goto err_free;
2587 
2588 	return 0;
2589 
2590 err_free:
2591 	input_free_device(wdata->mp);
2592 	wdata->mp = NULL;
2593 	return ret;
2594 }
2595 
2596 static void wiimod_mp_remove(const struct wiimod_ops *ops,
2597 			     struct wiimote_data *wdata)
2598 {
2599 	if (!wdata->mp)
2600 		return;
2601 
2602 	input_unregister_device(wdata->mp);
2603 	wdata->mp = NULL;
2604 }
2605 
2606 const struct wiimod_ops wiimod_mp = {
2607 	.flags = 0,
2608 	.arg = 0,
2609 	.probe = wiimod_mp_probe,
2610 	.remove = wiimod_mp_remove,
2611 	.in_mp = wiimod_mp_in_mp,
2612 };
2613 
2614 /* module table */
2615 
2616 static const struct wiimod_ops wiimod_dummy;
2617 
2618 const struct wiimod_ops *wiimod_table[WIIMOD_NUM] = {
2619 	[WIIMOD_KEYS] = &wiimod_keys,
2620 	[WIIMOD_RUMBLE] = &wiimod_rumble,
2621 	[WIIMOD_BATTERY] = &wiimod_battery,
2622 	[WIIMOD_LED1] = &wiimod_leds[0],
2623 	[WIIMOD_LED2] = &wiimod_leds[1],
2624 	[WIIMOD_LED3] = &wiimod_leds[2],
2625 	[WIIMOD_LED4] = &wiimod_leds[3],
2626 	[WIIMOD_ACCEL] = &wiimod_accel,
2627 	[WIIMOD_IR] = &wiimod_ir,
2628 	[WIIMOD_BUILTIN_MP] = &wiimod_builtin_mp,
2629 	[WIIMOD_NO_MP] = &wiimod_no_mp,
2630 };
2631 
2632 const struct wiimod_ops *wiimod_ext_table[WIIMOTE_EXT_NUM] = {
2633 	[WIIMOTE_EXT_NONE] = &wiimod_dummy,
2634 	[WIIMOTE_EXT_UNKNOWN] = &wiimod_dummy,
2635 	[WIIMOTE_EXT_NUNCHUK] = &wiimod_nunchuk,
2636 	[WIIMOTE_EXT_CLASSIC_CONTROLLER] = &wiimod_classic,
2637 	[WIIMOTE_EXT_BALANCE_BOARD] = &wiimod_bboard,
2638 	[WIIMOTE_EXT_PRO_CONTROLLER] = &wiimod_pro,
2639 	[WIIMOTE_EXT_DRUMS] = &wiimod_drums,
2640 	[WIIMOTE_EXT_GUITAR] = &wiimod_guitar,
2641 };
2642