drivers/hid/hid-wiimote-ext.c

   1 /*
   2  * HID driver for Nintendo Wiimote extension devices
   3  * Copyright (c) 2011 David Herrmann
   4  */
   5
   6 /*
   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)
  10  * any later version.
  11  */
  12
  13 #include <linux/atomic.h>
  14 #include <linux/module.h>
  15 #include <linux/spinlock.h>
  16 #include <linux/workqueue.h>
  17 #include "hid-wiimote.h"
  18
  19 struct wiimote_ext {
  20         struct wiimote_data *wdata;
  21         struct work_struct worker;
  22         struct input_dev *input;
  23         struct input_dev *mp_input;
  24
  25         atomic_t opened;
  26         atomic_t mp_opened;
  27         bool plugged;
  28         bool mp_plugged;
  29         bool motionp;
  30         __u8 ext_type;
  31         __u16 calib[4][3];
  32 };
  33
  34 enum wiiext_type {
  35         WIIEXT_NONE,            /* placeholder */
  36         WIIEXT_CLASSIC,         /* Nintendo classic controller */
  37         WIIEXT_NUNCHUCK,        /* Nintendo nunchuck controller */
  38         WIIEXT_BALANCE_BOARD,   /* Nintendo balance board controller */
  39 };
  40
  41 enum wiiext_keys {
  42         WIIEXT_KEY_C,
  43         WIIEXT_KEY_Z,
  44         WIIEXT_KEY_A,
  45         WIIEXT_KEY_B,
  46         WIIEXT_KEY_X,
  47         WIIEXT_KEY_Y,
  48         WIIEXT_KEY_ZL,
  49         WIIEXT_KEY_ZR,
  50         WIIEXT_KEY_PLUS,
  51         WIIEXT_KEY_MINUS,
  52         WIIEXT_KEY_HOME,
  53         WIIEXT_KEY_LEFT,
  54         WIIEXT_KEY_RIGHT,
  55         WIIEXT_KEY_UP,
  56         WIIEXT_KEY_DOWN,
  57         WIIEXT_KEY_LT,
  58         WIIEXT_KEY_RT,
  59         WIIEXT_KEY_COUNT
  60 };
  61
  62 static __u16 wiiext_keymap[] = {
  63         BTN_C,          /* WIIEXT_KEY_C */
  64         BTN_Z,          /* WIIEXT_KEY_Z */
  65         BTN_A,          /* WIIEXT_KEY_A */
  66         BTN_B,          /* WIIEXT_KEY_B */
  67         BTN_X,          /* WIIEXT_KEY_X */
  68         BTN_Y,          /* WIIEXT_KEY_Y */
  69         BTN_TL2,        /* WIIEXT_KEY_ZL */
  70         BTN_TR2,        /* WIIEXT_KEY_ZR */
  71         KEY_NEXT,       /* WIIEXT_KEY_PLUS */
  72         KEY_PREVIOUS,   /* WIIEXT_KEY_MINUS */
  73         BTN_MODE,       /* WIIEXT_KEY_HOME */
  74         KEY_LEFT,       /* WIIEXT_KEY_LEFT */
  75         KEY_RIGHT,      /* WIIEXT_KEY_RIGHT */
  76         KEY_UP,         /* WIIEXT_KEY_UP */
  77         KEY_DOWN,       /* WIIEXT_KEY_DOWN */
  78         BTN_TL,         /* WIIEXT_KEY_LT */
  79         BTN_TR,         /* WIIEXT_KEY_RT */
  80 };
  81
  82 /* disable all extensions */
  83 static void ext_disable(struct wiimote_ext *ext)
  84 {
  85         unsigned long flags;
  86         __u8 wmem = 0x55;
  87
  88         if (!wiimote_cmd_acquire(ext->wdata)) {
  89                 wiimote_cmd_write(ext->wdata, 0xa400f0, &wmem, sizeof(wmem));
  90                 wiimote_cmd_release(ext->wdata);
  91         }
  92
  93         spin_lock_irqsave(&ext->wdata->state.lock, flags);
  94         ext->motionp = false;
  95         ext->ext_type = WIIEXT_NONE;
  96         wiiproto_req_drm(ext->wdata, WIIPROTO_REQ_NULL);
  97         spin_unlock_irqrestore(&ext->wdata->state.lock, flags);
  98 }
  99
 100 static bool motionp_read(struct wiimote_ext *ext)
 101 {
 102         __u8 rmem[2], wmem;
 103         ssize_t ret;
 104         bool avail = false;
 105
 106         if (!atomic_read(&ext->mp_opened))
 107                 return false;
 108
 109         if (wiimote_cmd_acquire(ext->wdata))
 110                 return false;
 111
 112         /* initialize motion plus */
 113         wmem = 0x55;
 114         ret = wiimote_cmd_write(ext->wdata, 0xa600f0, &wmem, sizeof(wmem));
 115         if (ret)
 116                 goto error;
 117
 118         /* read motion plus ID */
 119         ret = wiimote_cmd_read(ext->wdata, 0xa600fe, rmem, 2);
 120         if (ret == 2 || rmem[1] == 0x5)
 121                 avail = true;
 122
 123 error:
 124         wiimote_cmd_release(ext->wdata);
 125         return avail;
 126 }
 127
 128 static __u8 ext_read(struct wiimote_ext *ext)
 129 {
 130         ssize_t ret;
 131         __u8 buf[24], i, j, offs = 0;
 132         __u8 rmem[2], wmem;
 133         __u8 type = WIIEXT_NONE;
 134
 135         if (!ext->plugged || !atomic_read(&ext->opened))
 136                 return WIIEXT_NONE;
 137
 138         if (wiimote_cmd_acquire(ext->wdata))
 139                 return WIIEXT_NONE;
 140
 141         /* initialize extension */
 142         wmem = 0x55;
 143         ret = wiimote_cmd_write(ext->wdata, 0xa400f0, &wmem, sizeof(wmem));
 144         if (!ret) {
 145                 /* disable encryption */
 146                 wmem = 0x0;
 147                 wiimote_cmd_write(ext->wdata, 0xa400fb, &wmem, sizeof(wmem));
 148         }
 149
 150         /* read extension ID */
 151         ret = wiimote_cmd_read(ext->wdata, 0xa400fe, rmem, 2);
 152         if (ret == 2) {
 153                 if (rmem[0] == 0 && rmem[1] == 0)
 154                         type = WIIEXT_NUNCHUCK;
 155                 else if (rmem[0] == 0x01 && rmem[1] == 0x01)
 156                         type = WIIEXT_CLASSIC;
 157                 else if (rmem[0] == 0x04 && rmem[1] == 0x02)
 158                         type = WIIEXT_BALANCE_BOARD;
 159         }
 160
 161         /* get balance board calibration data */
 162         if (type == WIIEXT_BALANCE_BOARD) {
 163                 ret = wiimote_cmd_read(ext->wdata, 0xa40024, buf, 12);
 164                 ret += wiimote_cmd_read(ext->wdata, 0xa40024 + 12,
 165                                         buf + 12, 12);
 166
 167                 if (ret != 24) {
 168                         type = WIIEXT_NONE;
 169                 } else {
 170                         for (i = 0; i < 3; i++) {
 171                                 for (j = 0; j < 4; j++) {
 172                                         ext->calib[j][i] = buf[offs];
 173                                         ext->calib[j][i] <<= 8;
 174                                         ext->calib[j][i] |= buf[offs + 1];
 175                                         offs += 2;
 176                                 }
 177                         }
 178                 }
 179         }
 180
 181         wiimote_cmd_release(ext->wdata);
 182
 183         return type;
 184 }
 185
 186 static void ext_enable(struct wiimote_ext *ext, bool motionp, __u8 ext_type)
 187 {
 188         unsigned long flags;
 189         __u8 wmem;
 190         int ret;
 191
 192         if (motionp) {
 193                 if (wiimote_cmd_acquire(ext->wdata))
 194                         return;
 195
 196                 if (ext_type == WIIEXT_CLASSIC)
 197                         wmem = 0x07;
 198                 else if (ext_type == WIIEXT_NUNCHUCK)
 199                         wmem = 0x05;
 200                 else
 201                         wmem = 0x04;
 202
 203                 ret = wiimote_cmd_write(ext->wdata, 0xa600fe, &wmem, sizeof(wmem));
 204                 wiimote_cmd_release(ext->wdata);
 205                 if (ret)
 206                         return;
 207         }
 208
 209         spin_lock_irqsave(&ext->wdata->state.lock, flags);
 210         ext->motionp = motionp;
 211         ext->ext_type = ext_type;
 212         wiiproto_req_drm(ext->wdata, WIIPROTO_REQ_NULL);
 213         spin_unlock_irqrestore(&ext->wdata->state.lock, flags);
 214 }
 215
 216 static void wiiext_worker(struct work_struct *work)
 217 {
 218         struct wiimote_ext *ext = container_of(work, struct wiimote_ext,
 219                                                                         worker);
 220         bool motionp;
 221         __u8 ext_type;
 222
 223         ext_disable(ext);
 224         motionp = motionp_read(ext);
 225         ext_type = ext_read(ext);
 226         ext_enable(ext, motionp, ext_type);
 227 }
 228
 229 /* schedule work only once, otherwise mark for reschedule */
 230 static void wiiext_schedule(struct wiimote_ext *ext)
 231 {
 232         schedule_work(&ext->worker);
 233 }
 234
 235 /*
 236  * Reacts on extension port events
 237  * Whenever the driver gets an event from the wiimote that an extension has been
 238  * plugged or unplugged, this funtion shall be called. It checks what extensions
 239  * are connected and initializes and activates them.
 240  * This can be called in atomic context. The initialization is done in a
 241  * separate worker thread. The state.lock spinlock must be held by the caller.
 242  */
 243 void wiiext_event(struct wiimote_data *wdata, bool plugged)
 244 {
 245         if (!wdata->ext)
 246                 return;
 247
 248         if (wdata->ext->plugged == plugged)
 249                 return;
 250
 251         wdata->ext->plugged = plugged;
 252
 253         if (!plugged)
 254                 wdata->ext->mp_plugged = false;
 255
 256         /*
 257          * We need to call wiiext_schedule(wdata->ext) here, however, the
 258          * extension initialization logic is not fully understood and so
 259          * automatic initialization is not supported, yet.
 260          */
 261 }
 262
 263 /*
 264  * Returns true if the current DRM mode should contain extension data and false
 265  * if there is no interest in extension data.
 266  * All supported extensions send 6 byte extension data so any DRM that contains
 267  * extension bytes is fine.
 268  * The caller must hold the state.lock spinlock.
 269  */
 270 bool wiiext_active(struct wiimote_data *wdata)
 271 {
 272         if (!wdata->ext)
 273                 return false;
 274
 275         return wdata->ext->motionp || wdata->ext->ext_type;
 276 }
 277
 278 static void handler_motionp(struct wiimote_ext *ext, const __u8 *payload)
 279 {
 280         __s32 x, y, z;
 281         bool plugged;
 282
 283         /*        |   8    7    6    5    4    3 |  2  |  1  |
 284          *   -----+------------------------------+-----+-----+
 285          *    1   |               Yaw Speed <7:0>            |
 286          *    2   |              Roll Speed <7:0>            |
 287          *    3   |             Pitch Speed <7:0>            |
 288          *   -----+------------------------------+-----+-----+
 289          *    4   |       Yaw Speed <13:8>       | Yaw |Pitch|
 290          *   -----+------------------------------+-----+-----+
 291          *    5   |      Roll Speed <13:8>       |Roll | Ext |
 292          *   -----+------------------------------+-----+-----+
 293          *    6   |     Pitch Speed <13:8>       |  1  |  0  |
 294          *   -----+------------------------------+-----+-----+
 295          * The single bits Yaw, Roll, Pitch in the lower right corner specify
 296          * whether the wiimote is rotating fast (0) or slow (1). Speed for slow
 297          * roation is 440 deg/s and for fast rotation 2000 deg/s. To get a
 298          * linear scale we multiply by 2000/440 = ~4.5454 which is 18 for fast
 299          * and 9 for slow.
 300          * If the wiimote is not rotating the sensor reports 2^13 = 8192.
 301          * Ext specifies whether an extension is connected to the motionp.
 302          */
 303
 304         x = payload[0];
 305         y = payload[1];
 306         z = payload[2];
 307
 308         x |= (((__u16)payload[3]) << 6) & 0xff00;
 309         y |= (((__u16)payload[4]) << 6) & 0xff00;
 310         z |= (((__u16)payload[5]) << 6) & 0xff00;
 311
 312         x -= 8192;
 313         y -= 8192;
 314         z -= 8192;
 315
 316         if (!(payload[3] & 0x02))
 317                 x *= 18;
 318         else
 319                 x *= 9;
 320         if (!(payload[4] & 0x02))
 321                 y *= 18;
 322         else
 323                 y *= 9;
 324         if (!(payload[3] & 0x01))
 325                 z *= 18;
 326         else
 327                 z *= 9;
 328
 329         input_report_abs(ext->mp_input, ABS_RX, x);
 330         input_report_abs(ext->mp_input, ABS_RY, y);
 331         input_report_abs(ext->mp_input, ABS_RZ, z);
 332         input_sync(ext->mp_input);
 333
 334         plugged = payload[5] & 0x01;
 335         if (plugged != ext->mp_plugged)
 336                 ext->mp_plugged = plugged;
 337 }
 338
 339 static void handler_nunchuck(struct wiimote_ext *ext, const __u8 *payload)
 340 {
 341         __s16 x, y, z, bx, by;
 342
 343         /*   Byte |   8    7 |  6    5 |  4    3 |  2 |  1  |
 344          *   -----+----------+---------+---------+----+-----+
 345          *    1   |              Button X <7:0>             |
 346          *    2   |              Button Y <7:0>             |
 347          *   -----+----------+---------+---------+----+-----+
 348          *    3   |               Speed X <9:2>             |
 349          *    4   |               Speed Y <9:2>             |
 350          *    5   |               Speed Z <9:2>             |
 351          *   -----+----------+---------+---------+----+-----+
 352          *    6   | Z <1:0>  | Y <1:0> | X <1:0> | BC | BZ  |
 353          *   -----+----------+---------+---------+----+-----+
 354          * Button X/Y is the analog stick. Speed X, Y and Z are the
 355          * accelerometer data in the same format as the wiimote's accelerometer.
 356          * The 6th byte contains the LSBs of the accelerometer data.
 357          * BC and BZ are the C and Z buttons: 0 means pressed
 358          *
 359          * If reported interleaved with motionp, then the layout changes. The
 360          * 5th and 6th byte changes to:
 361          *   -----+-----------------------------------+-----+
 362          *    5   |            Speed Z <9:3>          | EXT |
 363          *   -----+--------+-----+-----+----+----+----+-----+
 364          *    6   |Z <2:1> |Y <1>|X <1>| BC | BZ | 0  |  0  |
 365          *   -----+--------+-----+-----+----+----+----+-----+
 366          * All three accelerometer values lose their LSB. The other data is
 367          * still available but slightly moved.
 368          *
 369          * Center data for button values is 128. Center value for accelerometer
 370          * values it 512 / 0x200
 371          */
 372
 373         bx = payload[0];
 374         by = payload[1];
 375         bx -= 128;
 376         by -= 128;
 377
 378         x = payload[2] << 2;
 379         y = payload[3] << 2;
 380         z = payload[4] << 2;
 381
 382         if (ext->motionp) {
 383                 x |= (payload[5] >> 3) & 0x02;
 384                 y |= (payload[5] >> 4) & 0x02;
 385                 z &= ~0x4;
 386                 z |= (payload[5] >> 5) & 0x06;
 387         } else {
 388                 x |= (payload[5] >> 2) & 0x03;
 389                 y |= (payload[5] >> 4) & 0x03;
 390                 z |= (payload[5] >> 6) & 0x03;
 391         }
 392
 393         x -= 0x200;
 394         y -= 0x200;
 395         z -= 0x200;
 396
 397         input_report_abs(ext->input, ABS_HAT0X, bx);
 398         input_report_abs(ext->input, ABS_HAT0Y, by);
 399
 400         input_report_abs(ext->input, ABS_RX, x);
 401         input_report_abs(ext->input, ABS_RY, y);
 402         input_report_abs(ext->input, ABS_RZ, z);
 403
 404         if (ext->motionp) {
 405                 input_report_key(ext->input,
 406                         wiiext_keymap[WIIEXT_KEY_Z], !!(payload[5] & 0x04));
 407                 input_report_key(ext->input,
 408                         wiiext_keymap[WIIEXT_KEY_C], !!(payload[5] & 0x08));
 409         } else {
 410                 input_report_key(ext->input,
 411                         wiiext_keymap[WIIEXT_KEY_Z], !!(payload[5] & 0x01));
 412                 input_report_key(ext->input,
 413                         wiiext_keymap[WIIEXT_KEY_C], !!(payload[5] & 0x02));
 414         }
 415
 416         input_sync(ext->input);
 417 }
 418
 419 static void handler_classic(struct wiimote_ext *ext, const __u8 *payload)
 420 {
 421         __s8 rx, ry, lx, ly, lt, rt;
 422
 423         /*   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
 424          *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
 425          *    1   | RX <5:4>  |              LX <5:0>             |
 426          *    2   | RX <3:2>  |              LY <5:0>             |
 427          *   -----+-----+-----+-----+-----------------------------+
 428          *    3   |RX<1>| LT <5:4>  |         RY <5:1>            |
 429          *   -----+-----+-----------+-----------------------------+
 430          *    4   |     LT <3:1>    |         RT <5:1>            |
 431          *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
 432          *    5   | BDR | BDD | BLT | B-  | BH  | B+  | BRT |  1  |
 433          *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
 434          *    6   | BZL | BB  | BY  | BA  | BX  | BZR | BDL | BDU |
 435          *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
 436          * All buttons are 0 if pressed
 437          * RX and RY are right analog stick
 438          * LX and LY are left analog stick
 439          * LT is left trigger, RT is right trigger
 440          * BLT is 0 if left trigger is fully pressed
 441          * BRT is 0 if right trigger is fully pressed
 442          * BDR, BDD, BDL, BDU form the D-Pad with right, down, left, up buttons
 443          * BZL is left Z button and BZR is right Z button
 444          * B-, BH, B+ are +, HOME and - buttons
 445          * BB, BY, BA, BX are A, B, X, Y buttons
 446          * LSB of RX, RY, LT, and RT are not transmitted and always 0.
 447          *
 448          * With motionp enabled it changes slightly to this:
 449          *   Byte |  8  |  7  |  6  |  5  |  4  |  3  |  2  |  1  |
 450          *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
 451          *    1   | RX <4:3>  |          LX <5:1>           | BDU |
 452          *    2   | RX <2:1>  |          LY <5:1>           | BDL |
 453          *   -----+-----+-----+-----+-----------------------+-----+
 454          *    3   |RX<0>| LT <4:3>  |         RY <4:0>            |
 455          *   -----+-----+-----------+-----------------------------+
 456          *    4   |     LT <2:0>    |         RT <4:0>            |
 457          *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
 458          *    5   | BDR | BDD | BLT | B-  | BH  | B+  | BRT | EXT |
 459          *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
 460          *    6   | BZL | BB  | BY  | BA  | BX  | BZR |  0  |  0  |
 461          *   -----+-----+-----+-----+-----+-----+-----+-----+-----+
 462          * Only the LSBs of LX and LY are lost. BDU and BDL are moved, the rest
 463          * is the same as before.
 464          */
 465
 466         if (ext->motionp) {
 467                 lx = payload[0] & 0x3e;
 468                 ly = payload[0] & 0x3e;
 469         } else {
 470                 lx = payload[0] & 0x3f;
 471                 ly = payload[0] & 0x3f;
 472         }
 473
 474         rx = (payload[0] >> 3) & 0x14;
 475         rx |= (payload[1] >> 5) & 0x06;
 476         rx |= (payload[2] >> 7) & 0x01;
 477         ry = payload[2] & 0x1f;
 478
 479         rt = payload[3] & 0x1f;
 480         lt = (payload[2] >> 2) & 0x18;
 481         lt |= (payload[3] >> 5) & 0x07;
 482
 483         rx <<= 1;
 484         ry <<= 1;
 485         rt <<= 1;
 486         lt <<= 1;
 487
 488         input_report_abs(ext->input, ABS_HAT1X, lx - 0x20);
 489         input_report_abs(ext->input, ABS_HAT1Y, ly - 0x20);
 490         input_report_abs(ext->input, ABS_HAT2X, rx - 0x20);
 491         input_report_abs(ext->input, ABS_HAT2Y, ry - 0x20);
 492         input_report_abs(ext->input, ABS_HAT3X, rt - 0x20);
 493         input_report_abs(ext->input, ABS_HAT3Y, lt - 0x20);
 494
 495         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_RIGHT],
 496                                                         !!(payload[4] & 0x80));
 497         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_DOWN],
 498                                                         !!(payload[4] & 0x40));
 499         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LT],
 500                                                         !!(payload[4] & 0x20));
 501         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_MINUS],
 502                                                         !!(payload[4] & 0x10));
 503         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_HOME],
 504                                                         !!(payload[4] & 0x08));
 505         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_PLUS],
 506                                                         !!(payload[4] & 0x04));
 507         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_RT],
 508                                                         !!(payload[4] & 0x02));
 509         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_ZL],
 510                                                         !!(payload[5] & 0x80));
 511         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_B],
 512                                                         !!(payload[5] & 0x40));
 513         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_Y],
 514                                                         !!(payload[5] & 0x20));
 515         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_A],
 516                                                         !!(payload[5] & 0x10));
 517         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_X],
 518                                                         !!(payload[5] & 0x08));
 519         input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_ZR],
 520                                                         !!(payload[5] & 0x04));
 521
 522         if (ext->motionp) {
 523                 input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_UP],
 524                                                         !!(payload[0] & 0x01));
 525                 input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LEFT],
 526                                                         !!(payload[1] & 0x01));
 527         } else {
 528                 input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_UP],
 529                                                         !!(payload[5] & 0x01));
 530                 input_report_key(ext->input, wiiext_keymap[WIIEXT_KEY_LEFT],
 531                                                         !!(payload[5] & 0x02));
 532         }
 533
 534         input_sync(ext->input);
 535 }
 536
 537 static void handler_balance_board(struct wiimote_ext *ext, const __u8 *payload)
 538 {
 539         __s32 val[4], tmp;
 540         unsigned int i;
 541
 542         /*   Byte |  8  7  6  5  4  3  2  1  |
 543          *   -----+--------------------------+
 544          *    1   |    Top Right <15:8>      |
 545          *    2   |    Top Right  <7:0>      |
 546          *   -----+--------------------------+
 547          *    3   | Bottom Right <15:8>      |
 548          *    4   | Bottom Right  <7:0>      |
 549          *   -----+--------------------------+
 550          *    5   |     Top Left <15:8>      |
 551          *    6   |     Top Left  <7:0>      |
 552          *   -----+--------------------------+
 553          *    7   |  Bottom Left <15:8>      |
 554          *    8   |  Bottom Left  <7:0>      |
 555          *   -----+--------------------------+
 556          *
 557          * These values represent the weight-measurements of the Wii-balance
 558          * board with 16bit precision.
 559          *
 560          * The balance-board is never reported interleaved with motionp.
 561          */
 562
 563         val[0] = payload[0];
 564         val[0] <<= 8;
 565         val[0] |= payload[1];
 566
 567         val[1] = payload[2];
 568         val[1] <<= 8;
 569         val[1] |= payload[3];
 570
 571         val[2] = payload[4];
 572         val[2] <<= 8;
 573         val[2] |= payload[5];
 574
 575         val[3] = payload[6];
 576         val[3] <<= 8;
 577         val[3] |= payload[7];
 578
 579         /* apply calibration data */
 580         for (i = 0; i < 4; i++) {
 581                 if (val[i] < ext->calib[i][1]) {
 582                         tmp = val[i] - ext->calib[i][0];
 583                         tmp *= 1700;
 584                         tmp /= ext->calib[i][1] - ext->calib[i][0];
 585                 } else {
 586                         tmp = val[i] - ext->calib[i][1];
 587                         tmp *= 1700;
 588                         tmp /= ext->calib[i][2] - ext->calib[i][1];
 589                         tmp += 1700;
 590                 }
 591                 val[i] = tmp;
 592         }
 593
 594         input_report_abs(ext->input, ABS_HAT0X, val[0]);
 595         input_report_abs(ext->input, ABS_HAT0Y, val[1]);
 596         input_report_abs(ext->input, ABS_HAT1X, val[2]);
 597         input_report_abs(ext->input, ABS_HAT1Y, val[3]);
 598
 599         input_sync(ext->input);
 600 }
 601
 602 /* call this with state.lock spinlock held */
 603 void wiiext_handle(struct wiimote_data *wdata, const __u8 *payload)
 604 {
 605         struct wiimote_ext *ext = wdata->ext;
 606
 607         if (!ext)
 608                 return;
 609
 610         if (ext->motionp && (payload[5] & 0x02)) {
 611                 handler_motionp(ext, payload);
 612         } else if (ext->ext_type == WIIEXT_NUNCHUCK) {
 613                 handler_nunchuck(ext, payload);
 614         } else if (ext->ext_type == WIIEXT_CLASSIC) {
 615                 handler_classic(ext, payload);
 616         } else if (ext->ext_type == WIIEXT_BALANCE_BOARD) {
 617                 handler_balance_board(ext, payload);
 618         }
 619 }
 620
 621 static ssize_t wiiext_show(struct device *dev, struct device_attribute *attr,
 622                                                                 char *buf)
 623 {
 624         struct wiimote_data *wdata = dev_to_wii(dev);
 625         __u8 type = WIIEXT_NONE;
 626         bool motionp = false;
 627         unsigned long flags;
 628
 629         spin_lock_irqsave(&wdata->state.lock, flags);
 630         if (wdata->ext) {
 631                 motionp = wdata->ext->motionp;
 632                 type = wdata->ext->ext_type;
 633         }
 634         spin_unlock_irqrestore(&wdata->state.lock, flags);
 635
 636         if (type == WIIEXT_NUNCHUCK) {
 637                 if (motionp)
 638                         return sprintf(buf, "motionp+nunchuck\n");
 639                 else
 640                         return sprintf(buf, "nunchuck\n");
 641         } else if (type == WIIEXT_CLASSIC) {
 642                 if (motionp)
 643                         return sprintf(buf, "motionp+classic\n");
 644                 else
 645                         return sprintf(buf, "classic\n");
 646         } else if (type == WIIEXT_BALANCE_BOARD) {
 647                 if (motionp)
 648                         return sprintf(buf, "motionp+balanceboard\n");
 649                 else
 650                         return sprintf(buf, "balanceboard\n");
 651         } else {
 652                 if (motionp)
 653                         return sprintf(buf, "motionp\n");
 654                 else
 655                         return sprintf(buf, "none\n");
 656         }
 657 }
 658
 659 static DEVICE_ATTR(extension, S_IRUGO, wiiext_show, NULL);
 660
 661 static int wiiext_input_open(struct input_dev *dev)
 662 {
 663         struct wiimote_ext *ext = input_get_drvdata(dev);
 664         int ret;
 665
 666         ret = hid_hw_open(ext->wdata->hdev);
 667         if (ret)
 668                 return ret;
 669
 670         atomic_inc(&ext->opened);
 671         wiiext_schedule(ext);
 672
 673         return 0;
 674 }
 675
 676 static void wiiext_input_close(struct input_dev *dev)
 677 {
 678         struct wiimote_ext *ext = input_get_drvdata(dev);
 679
 680         atomic_dec(&ext->opened);
 681         wiiext_schedule(ext);
 682         hid_hw_close(ext->wdata->hdev);
 683 }
 684
 685 static int wiiext_mp_open(struct input_dev *dev)
 686 {
 687         struct wiimote_ext *ext = input_get_drvdata(dev);
 688         int ret;
 689
 690         ret = hid_hw_open(ext->wdata->hdev);
 691         if (ret)
 692                 return ret;
 693
 694         atomic_inc(&ext->mp_opened);
 695         wiiext_schedule(ext);
 696
 697         return 0;
 698 }
 699
 700 static void wiiext_mp_close(struct input_dev *dev)
 701 {
 702         struct wiimote_ext *ext = input_get_drvdata(dev);
 703
 704         atomic_dec(&ext->mp_opened);
 705         wiiext_schedule(ext);
 706         hid_hw_close(ext->wdata->hdev);
 707 }
 708
 709 /* Initializes the extension driver of a wiimote */
 710 int wiiext_init(struct wiimote_data *wdata)
 711 {
 712         struct wiimote_ext *ext;
 713         unsigned long flags;
 714         int ret, i;
 715
 716         ext = kzalloc(sizeof(*ext), GFP_KERNEL);
 717         if (!ext)
 718                 return -ENOMEM;
 719
 720         ext->wdata = wdata;
 721         INIT_WORK(&ext->worker, wiiext_worker);
 722
 723         ext->input = input_allocate_device();
 724         if (!ext->input) {
 725                 ret = -ENOMEM;
 726                 goto err_input;
 727         }
 728
 729         input_set_drvdata(ext->input, ext);
 730         ext->input->open = wiiext_input_open;
 731         ext->input->close = wiiext_input_close;
 732         ext->input->dev.parent = &wdata->hdev->dev;
 733         ext->input->id.bustype = wdata->hdev->bus;
 734         ext->input->id.vendor = wdata->hdev->vendor;
 735         ext->input->id.product = wdata->hdev->product;
 736         ext->input->id.version = wdata->hdev->version;
 737         ext->input->name = WIIMOTE_NAME " Extension";
 738
 739         set_bit(EV_KEY, ext->input->evbit);
 740         for (i = 0; i < WIIEXT_KEY_COUNT; ++i)
 741                 set_bit(wiiext_keymap[i], ext->input->keybit);
 742
 743         set_bit(EV_ABS, ext->input->evbit);
 744         set_bit(ABS_HAT0X, ext->input->absbit);
 745         set_bit(ABS_HAT0Y, ext->input->absbit);
 746         set_bit(ABS_HAT1X, ext->input->absbit);
 747         set_bit(ABS_HAT1Y, ext->input->absbit);
 748         set_bit(ABS_HAT2X, ext->input->absbit);
 749         set_bit(ABS_HAT2Y, ext->input->absbit);
 750         set_bit(ABS_HAT3X, ext->input->absbit);
 751         set_bit(ABS_HAT3Y, ext->input->absbit);
 752         input_set_abs_params(ext->input, ABS_HAT0X, -120, 120, 2, 4);
 753         input_set_abs_params(ext->input, ABS_HAT0Y, -120, 120, 2, 4);
 754         input_set_abs_params(ext->input, ABS_HAT1X, -30, 30, 1, 1);
 755         input_set_abs_params(ext->input, ABS_HAT1Y, -30, 30, 1, 1);
 756         input_set_abs_params(ext->input, ABS_HAT2X, -30, 30, 1, 1);
 757         input_set_abs_params(ext->input, ABS_HAT2Y, -30, 30, 1, 1);
 758         input_set_abs_params(ext->input, ABS_HAT3X, -30, 30, 1, 1);
 759         input_set_abs_params(ext->input, ABS_HAT3Y, -30, 30, 1, 1);
 760         set_bit(ABS_RX, ext->input->absbit);
 761         set_bit(ABS_RY, ext->input->absbit);
 762         set_bit(ABS_RZ, ext->input->absbit);
 763         input_set_abs_params(ext->input, ABS_RX, -500, 500, 2, 4);
 764         input_set_abs_params(ext->input, ABS_RY, -500, 500, 2, 4);
 765         input_set_abs_params(ext->input, ABS_RZ, -500, 500, 2, 4);
 766
 767         ret = input_register_device(ext->input);
 768         if (ret) {
 769                 input_free_device(ext->input);
 770                 goto err_input;
 771         }
 772
 773         ext->mp_input = input_allocate_device();
 774         if (!ext->mp_input) {
 775                 ret = -ENOMEM;
 776                 goto err_mp;
 777         }
 778
 779         input_set_drvdata(ext->mp_input, ext);
 780         ext->mp_input->open = wiiext_mp_open;
 781         ext->mp_input->close = wiiext_mp_close;
 782         ext->mp_input->dev.parent = &wdata->hdev->dev;
 783         ext->mp_input->id.bustype = wdata->hdev->bus;
 784         ext->mp_input->id.vendor = wdata->hdev->vendor;
 785         ext->mp_input->id.product = wdata->hdev->product;
 786         ext->mp_input->id.version = wdata->hdev->version;
 787         ext->mp_input->name = WIIMOTE_NAME " Motion+";
 788
 789         set_bit(EV_ABS, ext->mp_input->evbit);
 790         set_bit(ABS_RX, ext->mp_input->absbit);
 791         set_bit(ABS_RY, ext->mp_input->absbit);
 792         set_bit(ABS_RZ, ext->mp_input->absbit);
 793         input_set_abs_params(ext->mp_input, ABS_RX, -160000, 160000, 4, 8);
 794         input_set_abs_params(ext->mp_input, ABS_RY, -160000, 160000, 4, 8);
 795         input_set_abs_params(ext->mp_input, ABS_RZ, -160000, 160000, 4, 8);
 796
 797         ret = input_register_device(ext->mp_input);
 798         if (ret) {
 799                 input_free_device(ext->mp_input);
 800                 goto err_mp;
 801         }
 802
 803         ret = device_create_file(&wdata->hdev->dev, &dev_attr_extension);
 804         if (ret)
 805                 goto err_dev;
 806
 807         spin_lock_irqsave(&wdata->state.lock, flags);
 808         wdata->ext = ext;
 809         spin_unlock_irqrestore(&wdata->state.lock, flags);
 810
 811         return 0;
 812
 813 err_dev:
 814         input_unregister_device(ext->mp_input);
 815 err_mp:
 816         input_unregister_device(ext->input);
 817 err_input:
 818         kfree(ext);
 819         return ret;
 820 }
 821
 822 /* Deinitializes the extension driver of a wiimote */
 823 void wiiext_deinit(struct wiimote_data *wdata)
 824 {
 825         struct wiimote_ext *ext = wdata->ext;
 826         unsigned long flags;
 827
 828         if (!ext)
 829                 return;
 830
 831         /*
 832          * We first unset wdata->ext to avoid further input from the wiimote
 833          * core. The worker thread does not access this pointer so it is not
 834          * affected by this.
 835          * We kill the worker after this so it does not get respawned during
 836          * deinitialization.
 837          */
 838
 839         spin_lock_irqsave(&wdata->state.lock, flags);
 840         wdata->ext = NULL;
 841         spin_unlock_irqrestore(&wdata->state.lock, flags);
 842
 843         device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
 844         input_unregister_device(ext->mp_input);
 845         input_unregister_device(ext->input);
 846
 847         cancel_work_sync(&ext->worker);
 848         kfree(ext);
 849 }