linux/drivers/hid/hid-wiimote-core.c
<<
>>
Prefs 
   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * HID driver for Nintendo Wii / Wii U peripherals
   4 * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
   5 */
   6
   7/*
   8 */
   9
  10#include <linux/completion.h>
  11#include <linux/device.h>
  12#include <linux/hid.h>
  13#include <linux/input.h>
  14#include <linux/module.h>
  15#include <linux/mutex.h>
  16#include <linux/spinlock.h>
  17#include "hid-ids.h"
  18#include "hid-wiimote.h"
  19
  20/* output queue handling */
  21
  22static int wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
  23                            size_t count)
  24{
  25        __u8 *buf;
  26        int ret;
  27
  28        if (!hdev->ll_driver->output_report)
  29                return -ENODEV;
  30
  31        buf = kmemdup(buffer, count, GFP_KERNEL);
  32        if (!buf)
  33                return -ENOMEM;
  34
  35        ret = hid_hw_output_report(hdev, buf, count);
  36
  37        kfree(buf);
  38        return ret;
  39}
  40
  41static void wiimote_queue_worker(struct work_struct *work)
  42{
  43        struct wiimote_queue *queue = container_of(work, struct wiimote_queue,
  44                                                   worker);
  45        struct wiimote_data *wdata = container_of(queue, struct wiimote_data,
  46                                                  queue);
  47        unsigned long flags;
  48        int ret;
  49
  50        spin_lock_irqsave(&wdata->queue.lock, flags);
  51
  52        while (wdata->queue.head != wdata->queue.tail) {
  53                spin_unlock_irqrestore(&wdata->queue.lock, flags);
  54                ret = wiimote_hid_send(wdata->hdev,
  55                                 wdata->queue.outq[wdata->queue.tail].data,
  56                                 wdata->queue.outq[wdata->queue.tail].size);
  57                if (ret < 0) {
  58                        spin_lock_irqsave(&wdata->state.lock, flags);
  59                        wiimote_cmd_abort(wdata);
  60                        spin_unlock_irqrestore(&wdata->state.lock, flags);
  61                }
  62                spin_lock_irqsave(&wdata->queue.lock, flags);
  63
  64                wdata->queue.tail = (wdata->queue.tail + 1) % WIIMOTE_BUFSIZE;
  65        }
  66
  67        spin_unlock_irqrestore(&wdata->queue.lock, flags);
  68}
  69
  70static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
  71                                                                size_t count)
  72{
  73        unsigned long flags;
  74        __u8 newhead;
  75
  76        if (count > HID_MAX_BUFFER_SIZE) {
  77                hid_warn(wdata->hdev, "Sending too large output report\n");
  78
  79                spin_lock_irqsave(&wdata->queue.lock, flags);
  80                goto out_error;
  81        }
  82
  83        /*
  84         * Copy new request into our output queue and check whether the
  85         * queue is full. If it is full, discard this request.
  86         * If it is empty we need to start a new worker that will
  87         * send out the buffer to the hid device.
  88         * If the queue is not empty, then there must be a worker
  89         * that is currently sending out our buffer and this worker
  90         * will reschedule itself until the queue is empty.
  91         */
  92
  93        spin_lock_irqsave(&wdata->queue.lock, flags);
  94
  95        memcpy(wdata->queue.outq[wdata->queue.head].data, buffer, count);
  96        wdata->queue.outq[wdata->queue.head].size = count;
  97        newhead = (wdata->queue.head + 1) % WIIMOTE_BUFSIZE;
  98
  99        if (wdata->queue.head == wdata->queue.tail) {
 100                wdata->queue.head = newhead;
 101                schedule_work(&wdata->queue.worker);
 102        } else if (newhead != wdata->queue.tail) {
 103                wdata->queue.head = newhead;
 104        } else {
 105                hid_warn(wdata->hdev, "Output queue is full");
 106                goto out_error;
 107        }
 108
 109        goto out_unlock;
 110
 111out_error:
 112        wiimote_cmd_abort(wdata);
 113out_unlock:
 114        spin_unlock_irqrestore(&wdata->queue.lock, flags);
 115}
 116
 117/*
 118 * This sets the rumble bit on the given output report if rumble is
 119 * currently enabled.
 120 * \cmd1 must point to the second byte in the output report => &cmd[1]
 121 * This must be called on nearly every output report before passing it
 122 * into the output queue!
 123 */
 124static inline void wiiproto_keep_rumble(struct wiimote_data *wdata, __u8 *cmd1)
 125{
 126        if (wdata->state.flags & WIIPROTO_FLAG_RUMBLE)
 127                *cmd1 |= 0x01;
 128}
 129
 130void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
 131{
 132        __u8 cmd[2];
 133
 134        rumble = !!rumble;
 135        if (rumble == !!(wdata->state.flags & WIIPROTO_FLAG_RUMBLE))
 136                return;
 137
 138        if (rumble)
 139                wdata->state.flags |= WIIPROTO_FLAG_RUMBLE;
 140        else
 141                wdata->state.flags &= ~WIIPROTO_FLAG_RUMBLE;
 142
 143        cmd[0] = WIIPROTO_REQ_RUMBLE;
 144        cmd[1] = 0;
 145
 146        wiiproto_keep_rumble(wdata, &cmd[1]);
 147        wiimote_queue(wdata, cmd, sizeof(cmd));
 148}
 149
 150void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
 151{
 152        __u8 cmd[2];
 153
 154        leds &= WIIPROTO_FLAGS_LEDS;
 155        if ((wdata->state.flags & WIIPROTO_FLAGS_LEDS) == leds)
 156                return;
 157        wdata->state.flags = (wdata->state.flags & ~WIIPROTO_FLAGS_LEDS) | leds;
 158
 159        cmd[0] = WIIPROTO_REQ_LED;
 160        cmd[1] = 0;
 161
 162        if (leds & WIIPROTO_FLAG_LED1)
 163                cmd[1] |= 0x10;
 164        if (leds & WIIPROTO_FLAG_LED2)
 165                cmd[1] |= 0x20;
 166        if (leds & WIIPROTO_FLAG_LED3)
 167                cmd[1] |= 0x40;
 168        if (leds & WIIPROTO_FLAG_LED4)
 169                cmd[1] |= 0x80;
 170
 171        wiiproto_keep_rumble(wdata, &cmd[1]);
 172        wiimote_queue(wdata, cmd, sizeof(cmd));
 173}
 174
 175/*
 176 * Check what peripherals of the wiimote are currently
 177 * active and select a proper DRM that supports all of
 178 * the requested data inputs.
 179 *
 180 * Not all combinations are actually supported. The following
 181 * combinations work only with limitations:
 182 *  - IR cam in extended or full mode disables any data transmission
 183 *    of extension controllers. There is no DRM mode that supports
 184 *    extension bytes plus extended/full IR.
 185 *  - IR cam with accelerometer and extension *_EXT8 is not supported.
 186 *    However, all extensions that need *_EXT8 are devices that don't
 187 *    support IR cameras. Hence, this shouldn't happen under normal
 188 *    operation.
 189 *  - *_EXT16 is only supported in combination with buttons and
 190 *    accelerometer. No IR or similar can be active simultaneously. As
 191 *    above, all modules that require it are mutually exclusive with
 192 *    IR/etc. so this doesn't matter.
 193 */
 194static __u8 select_drm(struct wiimote_data *wdata)
 195{
 196        __u8 ir = wdata->state.flags & WIIPROTO_FLAGS_IR;
 197        bool ext;
 198
 199        ext = (wdata->state.flags & WIIPROTO_FLAG_EXT_USED) ||
 200              (wdata->state.flags & WIIPROTO_FLAG_MP_USED);
 201
 202        /* some 3rd-party balance-boards are hard-coded to KEE, *sigh* */
 203        if (wdata->state.devtype == WIIMOTE_DEV_BALANCE_BOARD) {
 204                if (ext)
 205                        return WIIPROTO_REQ_DRM_KEE;
 206                else
 207                        return WIIPROTO_REQ_DRM_K;
 208        }
 209
 210        if (ir == WIIPROTO_FLAG_IR_BASIC) {
 211                if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) {
 212                        /* GEN10 and ealier devices bind IR formats to DRMs.
 213                         * Hence, we cannot use DRM_KAI here as it might be
 214                         * bound to IR_EXT. Use DRM_KAIE unconditionally so we
 215                         * work with all devices and our parsers can use the
 216                         * fixed formats, too. */
 217                        return WIIPROTO_REQ_DRM_KAIE;
 218                } else {
 219                        return WIIPROTO_REQ_DRM_KIE;
 220                }
 221        } else if (ir == WIIPROTO_FLAG_IR_EXT) {
 222                return WIIPROTO_REQ_DRM_KAI;
 223        } else if (ir == WIIPROTO_FLAG_IR_FULL) {
 224                return WIIPROTO_REQ_DRM_SKAI1;
 225        } else {
 226                if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) {
 227                        if (ext)
 228                                return WIIPROTO_REQ_DRM_KAE;
 229                        else
 230                                return WIIPROTO_REQ_DRM_KA;
 231                } else {
 232                        if (ext)
 233                                return WIIPROTO_REQ_DRM_KEE;
 234                        else
 235                                return WIIPROTO_REQ_DRM_K;
 236                }
 237        }
 238}
 239
 240void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
 241{
 242        __u8 cmd[3];
 243
 244        if (wdata->state.flags & WIIPROTO_FLAG_DRM_LOCKED)
 245                drm = wdata->state.drm;
 246        else if (drm == WIIPROTO_REQ_NULL)
 247                drm = select_drm(wdata);
 248
 249        cmd[0] = WIIPROTO_REQ_DRM;
 250        cmd[1] = 0;
 251        cmd[2] = drm;
 252
 253        wdata->state.drm = drm;
 254        wiiproto_keep_rumble(wdata, &cmd[1]);
 255        wiimote_queue(wdata, cmd, sizeof(cmd));
 256}
 257
 258void wiiproto_req_status(struct wiimote_data *wdata)
 259{
 260        __u8 cmd[2];
 261
 262        cmd[0] = WIIPROTO_REQ_SREQ;
 263        cmd[1] = 0;
 264
 265        wiiproto_keep_rumble(wdata, &cmd[1]);
 266        wiimote_queue(wdata, cmd, sizeof(cmd));
 267}
 268
 269void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
 270{
 271        accel = !!accel;
 272        if (accel == !!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
 273                return;
 274
 275        if (accel)
 276                wdata->state.flags |= WIIPROTO_FLAG_ACCEL;
 277        else
 278                wdata->state.flags &= ~WIIPROTO_FLAG_ACCEL;
 279
 280        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
 281}
 282
 283void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
 284{
 285        __u8 cmd[2];
 286
 287        cmd[0] = WIIPROTO_REQ_IR1;
 288        cmd[1] = flags;
 289
 290        wiiproto_keep_rumble(wdata, &cmd[1]);
 291        wiimote_queue(wdata, cmd, sizeof(cmd));
 292}
 293
 294void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
 295{
 296        __u8 cmd[2];
 297
 298        cmd[0] = WIIPROTO_REQ_IR2;
 299        cmd[1] = flags;
 300
 301        wiiproto_keep_rumble(wdata, &cmd[1]);
 302        wiimote_queue(wdata, cmd, sizeof(cmd));
 303}
 304
 305#define wiiproto_req_wreg(wdata, os, buf, sz) \
 306                        wiiproto_req_wmem((wdata), false, (os), (buf), (sz))
 307
 308#define wiiproto_req_weeprom(wdata, os, buf, sz) \
 309                        wiiproto_req_wmem((wdata), true, (os), (buf), (sz))
 310
 311static void wiiproto_req_wmem(struct wiimote_data *wdata, bool eeprom,
 312                                __u32 offset, const __u8 *buf, __u8 size)
 313{
 314        __u8 cmd[22];
 315
 316        if (size > 16 || size == 0) {
 317                hid_warn(wdata->hdev, "Invalid length %d wmem request\n", size);
 318                return;
 319        }
 320
 321        memset(cmd, 0, sizeof(cmd));
 322        cmd[0] = WIIPROTO_REQ_WMEM;
 323        cmd[2] = (offset >> 16) & 0xff;
 324        cmd[3] = (offset >> 8) & 0xff;
 325        cmd[4] = offset & 0xff;
 326        cmd[5] = size;
 327        memcpy(&cmd[6], buf, size);
 328
 329        if (!eeprom)
 330                cmd[1] |= 0x04;
 331
 332        wiiproto_keep_rumble(wdata, &cmd[1]);
 333        wiimote_queue(wdata, cmd, sizeof(cmd));
 334}
 335
 336void wiiproto_req_rmem(struct wiimote_data *wdata, bool eeprom, __u32 offset,
 337                                                                __u16 size)
 338{
 339        __u8 cmd[7];
 340
 341        if (size == 0) {
 342                hid_warn(wdata->hdev, "Invalid length %d rmem request\n", size);
 343                return;
 344        }
 345
 346        cmd[0] = WIIPROTO_REQ_RMEM;
 347        cmd[1] = 0;
 348        cmd[2] = (offset >> 16) & 0xff;
 349        cmd[3] = (offset >> 8) & 0xff;
 350        cmd[4] = offset & 0xff;
 351        cmd[5] = (size >> 8) & 0xff;
 352        cmd[6] = size & 0xff;
 353
 354        if (!eeprom)
 355                cmd[1] |= 0x04;
 356
 357        wiiproto_keep_rumble(wdata, &cmd[1]);
 358        wiimote_queue(wdata, cmd, sizeof(cmd));
 359}
 360
 361/* requries the cmd-mutex to be held */
 362int wiimote_cmd_write(struct wiimote_data *wdata, __u32 offset,
 363                                                const __u8 *wmem, __u8 size)
 364{
 365        unsigned long flags;
 366        int ret;
 367
 368        spin_lock_irqsave(&wdata->state.lock, flags);
 369        wiimote_cmd_set(wdata, WIIPROTO_REQ_WMEM, 0);
 370        wiiproto_req_wreg(wdata, offset, wmem, size);
 371        spin_unlock_irqrestore(&wdata->state.lock, flags);
 372
 373        ret = wiimote_cmd_wait(wdata);
 374        if (!ret && wdata->state.cmd_err)
 375                ret = -EIO;
 376
 377        return ret;
 378}
 379
 380/* requries the cmd-mutex to be held */
 381ssize_t wiimote_cmd_read(struct wiimote_data *wdata, __u32 offset, __u8 *rmem,
 382                                                                __u8 size)
 383{
 384        unsigned long flags;
 385        ssize_t ret;
 386
 387        spin_lock_irqsave(&wdata->state.lock, flags);
 388        wdata->state.cmd_read_size = size;
 389        wdata->state.cmd_read_buf = rmem;
 390        wiimote_cmd_set(wdata, WIIPROTO_REQ_RMEM, offset & 0xffff);
 391        wiiproto_req_rreg(wdata, offset, size);
 392        spin_unlock_irqrestore(&wdata->state.lock, flags);
 393
 394        ret = wiimote_cmd_wait(wdata);
 395
 396        spin_lock_irqsave(&wdata->state.lock, flags);
 397        wdata->state.cmd_read_buf = NULL;
 398        spin_unlock_irqrestore(&wdata->state.lock, flags);
 399
 400        if (!ret) {
 401                if (wdata->state.cmd_read_size == 0)
 402                        ret = -EIO;
 403                else
 404                        ret = wdata->state.cmd_read_size;
 405        }
 406
 407        return ret;
 408}
 409
 410/* requires the cmd-mutex to be held */
 411static int wiimote_cmd_init_ext(struct wiimote_data *wdata)
 412{
 413        __u8 wmem;
 414        int ret;
 415
 416        /* initialize extension */
 417        wmem = 0x55;
 418        ret = wiimote_cmd_write(wdata, 0xa400f0, &wmem, sizeof(wmem));
 419        if (ret)
 420                return ret;
 421
 422        /* disable default encryption */
 423        wmem = 0x0;
 424        ret = wiimote_cmd_write(wdata, 0xa400fb, &wmem, sizeof(wmem));
 425        if (ret)
 426                return ret;
 427
 428        return 0;
 429}
 430
 431/* requires the cmd-mutex to be held */
 432static __u8 wiimote_cmd_read_ext(struct wiimote_data *wdata, __u8 *rmem)
 433{
 434        int ret;
 435
 436        /* read extension ID */
 437        ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6);
 438        if (ret != 6)
 439                return WIIMOTE_EXT_NONE;
 440
 441        hid_dbg(wdata->hdev, "extension ID: %6phC\n", rmem);
 442
 443        if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff &&
 444            rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff)
 445                return WIIMOTE_EXT_NONE;
 446
 447        if (rmem[4] == 0x00 && rmem[5] == 0x00)
 448                return WIIMOTE_EXT_NUNCHUK;
 449        if (rmem[4] == 0x01 && rmem[5] == 0x01)
 450                return WIIMOTE_EXT_CLASSIC_CONTROLLER;
 451        if (rmem[4] == 0x04 && rmem[5] == 0x02)
 452                return WIIMOTE_EXT_BALANCE_BOARD;
 453        if (rmem[4] == 0x01 && rmem[5] == 0x20)
 454                return WIIMOTE_EXT_PRO_CONTROLLER;
 455        if (rmem[0] == 0x01 && rmem[1] == 0x00 &&
 456            rmem[4] == 0x01 && rmem[5] == 0x03)
 457                return WIIMOTE_EXT_DRUMS;
 458        if (rmem[0] == 0x00 && rmem[1] == 0x00 &&
 459            rmem[4] == 0x01 && rmem[5] == 0x03)
 460                return WIIMOTE_EXT_GUITAR;
 461
 462        return WIIMOTE_EXT_UNKNOWN;
 463}
 464
 465/* requires the cmd-mutex to be held */
 466static int wiimote_cmd_init_mp(struct wiimote_data *wdata)
 467{
 468        __u8 wmem;
 469        int ret;
 470
 471        /* initialize MP */
 472        wmem = 0x55;
 473        ret = wiimote_cmd_write(wdata, 0xa600f0, &wmem, sizeof(wmem));
 474        if (ret)
 475                return ret;
 476
 477        /* disable default encryption */
 478        wmem = 0x0;
 479        ret = wiimote_cmd_write(wdata, 0xa600fb, &wmem, sizeof(wmem));
 480        if (ret)
 481                return ret;
 482
 483        return 0;
 484}
 485
 486/* requires the cmd-mutex to be held */
 487static bool wiimote_cmd_map_mp(struct wiimote_data *wdata, __u8 exttype)
 488{
 489        __u8 wmem;
 490
 491        /* map MP with correct pass-through mode */
 492        switch (exttype) {
 493        case WIIMOTE_EXT_CLASSIC_CONTROLLER:
 494        case WIIMOTE_EXT_DRUMS:
 495        case WIIMOTE_EXT_GUITAR:
 496                wmem = 0x07;
 497                break;
 498        case WIIMOTE_EXT_NUNCHUK:
 499                wmem = 0x05;
 500                break;
 501        default:
 502                wmem = 0x04;
 503                break;
 504        }
 505
 506        return wiimote_cmd_write(wdata, 0xa600fe, &wmem, sizeof(wmem));
 507}
 508
 509/* requires the cmd-mutex to be held */
 510static bool wiimote_cmd_read_mp(struct wiimote_data *wdata, __u8 *rmem)
 511{
 512        int ret;
 513
 514        /* read motion plus ID */
 515        ret = wiimote_cmd_read(wdata, 0xa600fa, rmem, 6);
 516        if (ret != 6)
 517                return false;
 518
 519        hid_dbg(wdata->hdev, "motion plus ID: %6phC\n", rmem);
 520
 521        if (rmem[5] == 0x05)
 522                return true;
 523
 524        hid_info(wdata->hdev, "unknown motion plus ID: %6phC\n", rmem);
 525
 526        return false;
 527}
 528
 529/* requires the cmd-mutex to be held */
 530static __u8 wiimote_cmd_read_mp_mapped(struct wiimote_data *wdata)
 531{
 532        int ret;
 533        __u8 rmem[6];
 534
 535        /* read motion plus ID */
 536        ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6);
 537        if (ret != 6)
 538                return WIIMOTE_MP_NONE;
 539
 540        hid_dbg(wdata->hdev, "mapped motion plus ID: %6phC\n", rmem);
 541
 542        if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff &&
 543            rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff)
 544                return WIIMOTE_MP_NONE;
 545
 546        if (rmem[4] == 0x04 && rmem[5] == 0x05)
 547                return WIIMOTE_MP_SINGLE;
 548        else if (rmem[4] == 0x05 && rmem[5] == 0x05)
 549                return WIIMOTE_MP_PASSTHROUGH_NUNCHUK;
 550        else if (rmem[4] == 0x07 && rmem[5] == 0x05)
 551                return WIIMOTE_MP_PASSTHROUGH_CLASSIC;
 552
 553        return WIIMOTE_MP_UNKNOWN;
 554}
 555
 556/* device module handling */
 557
 558static const __u8 * const wiimote_devtype_mods[WIIMOTE_DEV_NUM] = {
 559        [WIIMOTE_DEV_PENDING] = (const __u8[]){
 560                WIIMOD_NULL,
 561        },
 562        [WIIMOTE_DEV_UNKNOWN] = (const __u8[]){
 563                WIIMOD_NO_MP,
 564                WIIMOD_NULL,
 565        },
 566        [WIIMOTE_DEV_GENERIC] = (const __u8[]){
 567                WIIMOD_KEYS,
 568                WIIMOD_RUMBLE,
 569                WIIMOD_BATTERY,
 570                WIIMOD_LED1,
 571                WIIMOD_LED2,
 572                WIIMOD_LED3,
 573                WIIMOD_LED4,
 574                WIIMOD_ACCEL,
 575                WIIMOD_IR,
 576                WIIMOD_NULL,
 577        },
 578        [WIIMOTE_DEV_GEN10] = (const __u8[]){
 579                WIIMOD_KEYS,
 580                WIIMOD_RUMBLE,
 581                WIIMOD_BATTERY,
 582                WIIMOD_LED1,
 583                WIIMOD_LED2,
 584                WIIMOD_LED3,
 585                WIIMOD_LED4,
 586                WIIMOD_ACCEL,
 587                WIIMOD_IR,
 588                WIIMOD_NULL,
 589        },
 590        [WIIMOTE_DEV_GEN20] = (const __u8[]){
 591                WIIMOD_KEYS,
 592                WIIMOD_RUMBLE,
 593                WIIMOD_BATTERY,
 594                WIIMOD_LED1,
 595                WIIMOD_LED2,
 596                WIIMOD_LED3,
 597                WIIMOD_LED4,
 598                WIIMOD_ACCEL,
 599                WIIMOD_IR,
 600                WIIMOD_BUILTIN_MP,
 601                WIIMOD_NULL,
 602        },
 603        [WIIMOTE_DEV_BALANCE_BOARD] = (const __u8[]) {
 604                WIIMOD_BATTERY,
 605                WIIMOD_LED1,
 606                WIIMOD_NO_MP,
 607                WIIMOD_NULL,
 608        },
 609        [WIIMOTE_DEV_PRO_CONTROLLER] = (const __u8[]) {
 610                WIIMOD_BATTERY,
 611                WIIMOD_LED1,
 612                WIIMOD_LED2,
 613                WIIMOD_LED3,
 614                WIIMOD_LED4,
 615                WIIMOD_NO_MP,
 616                WIIMOD_NULL,
 617        },
 618};
 619
 620static void wiimote_modules_load(struct wiimote_data *wdata,
 621                                 unsigned int devtype)
 622{
 623        bool need_input = false;
 624        const __u8 *mods, *iter;
 625        const struct wiimod_ops *ops;
 626        int ret;
 627
 628        mods = wiimote_devtype_mods[devtype];
 629
 630        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
 631                if (wiimod_table[*iter]->flags & WIIMOD_FLAG_INPUT) {
 632                        need_input = true;
 633                        break;
 634                }
 635        }
 636
 637        if (need_input) {
 638                wdata->input = input_allocate_device();
 639                if (!wdata->input)
 640                        return;
 641
 642                input_set_drvdata(wdata->input, wdata);
 643                wdata->input->dev.parent = &wdata->hdev->dev;
 644                wdata->input->id.bustype = wdata->hdev->bus;
 645                wdata->input->id.vendor = wdata->hdev->vendor;
 646                wdata->input->id.product = wdata->hdev->product;
 647                wdata->input->id.version = wdata->hdev->version;
 648                wdata->input->name = WIIMOTE_NAME;
 649        }
 650
 651        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
 652                ops = wiimod_table[*iter];
 653                if (!ops->probe)
 654                        continue;
 655
 656                ret = ops->probe(ops, wdata);
 657                if (ret)
 658                        goto error;
 659        }
 660
 661        if (wdata->input) {
 662                ret = input_register_device(wdata->input);
 663                if (ret)
 664                        goto error;
 665        }
 666
 667        spin_lock_irq(&wdata->state.lock);
 668        wdata->state.devtype = devtype;
 669        spin_unlock_irq(&wdata->state.lock);
 670        return;
 671
 672error:
 673        for ( ; iter-- != mods; ) {
 674                ops = wiimod_table[*iter];
 675                if (ops->remove)
 676                        ops->remove(ops, wdata);
 677        }
 678
 679        if (wdata->input) {
 680                input_free_device(wdata->input);
 681                wdata->input = NULL;
 682        }
 683}
 684
 685static void wiimote_modules_unload(struct wiimote_data *wdata)
 686{
 687        const __u8 *mods, *iter;
 688        const struct wiimod_ops *ops;
 689        unsigned long flags;
 690
 691        mods = wiimote_devtype_mods[wdata->state.devtype];
 692
 693        spin_lock_irqsave(&wdata->state.lock, flags);
 694        wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
 695        spin_unlock_irqrestore(&wdata->state.lock, flags);
 696
 697        /* find end of list */
 698        for (iter = mods; *iter != WIIMOD_NULL; ++iter)
 699                /* empty */ ;
 700
 701        if (wdata->input) {
 702                input_get_device(wdata->input);
 703                input_unregister_device(wdata->input);
 704        }
 705
 706        for ( ; iter-- != mods; ) {
 707                ops = wiimod_table[*iter];
 708                if (ops->remove)
 709                        ops->remove(ops, wdata);
 710        }
 711
 712        if (wdata->input) {
 713                input_put_device(wdata->input);
 714                wdata->input = NULL;
 715        }
 716}
 717
 718/* device extension handling */
 719
 720static void wiimote_ext_load(struct wiimote_data *wdata, unsigned int ext)
 721{
 722        unsigned long flags;
 723        const struct wiimod_ops *ops;
 724        int ret;
 725
 726        ops = wiimod_ext_table[ext];
 727
 728        if (ops->probe) {
 729                ret = ops->probe(ops, wdata);
 730                if (ret)
 731                        ext = WIIMOTE_EXT_UNKNOWN;
 732        }
 733
 734        spin_lock_irqsave(&wdata->state.lock, flags);
 735        wdata->state.exttype = ext;
 736        spin_unlock_irqrestore(&wdata->state.lock, flags);
 737}
 738
 739static void wiimote_ext_unload(struct wiimote_data *wdata)
 740{
 741        unsigned long flags;
 742        const struct wiimod_ops *ops;
 743
 744        ops = wiimod_ext_table[wdata->state.exttype];
 745
 746        spin_lock_irqsave(&wdata->state.lock, flags);
 747        wdata->state.exttype = WIIMOTE_EXT_UNKNOWN;
 748        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
 749        spin_unlock_irqrestore(&wdata->state.lock, flags);
 750
 751        if (ops->remove)
 752                ops->remove(ops, wdata);
 753}
 754
 755static void wiimote_mp_load(struct wiimote_data *wdata)
 756{
 757        unsigned long flags;
 758        const struct wiimod_ops *ops;
 759        int ret;
 760        __u8 mode = 2;
 761
 762        ops = &wiimod_mp;
 763        if (ops->probe) {
 764                ret = ops->probe(ops, wdata);
 765                if (ret)
 766                        mode = 1;
 767        }
 768
 769        spin_lock_irqsave(&wdata->state.lock, flags);
 770        wdata->state.mp = mode;
 771        spin_unlock_irqrestore(&wdata->state.lock, flags);
 772}
 773
 774static void wiimote_mp_unload(struct wiimote_data *wdata)
 775{
 776        unsigned long flags;
 777        const struct wiimod_ops *ops;
 778
 779        if (wdata->state.mp < 2)
 780                return;
 781
 782        ops = &wiimod_mp;
 783
 784        spin_lock_irqsave(&wdata->state.lock, flags);
 785        wdata->state.mp = 0;
 786        wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED;
 787        spin_unlock_irqrestore(&wdata->state.lock, flags);
 788
 789        if (ops->remove)
 790                ops->remove(ops, wdata);
 791}
 792
 793/* device (re-)initialization and detection */
 794
 795static const char *wiimote_devtype_names[WIIMOTE_DEV_NUM] = {
 796        [WIIMOTE_DEV_PENDING] = "Pending",
 797        [WIIMOTE_DEV_UNKNOWN] = "Unknown",
 798        [WIIMOTE_DEV_GENERIC] = "Generic",
 799        [WIIMOTE_DEV_GEN10] = "Nintendo Wii Remote (Gen 1)",
 800        [WIIMOTE_DEV_GEN20] = "Nintendo Wii Remote Plus (Gen 2)",
 801        [WIIMOTE_DEV_BALANCE_BOARD] = "Nintendo Wii Balance Board",
 802        [WIIMOTE_DEV_PRO_CONTROLLER] = "Nintendo Wii U Pro Controller",
 803};
 804
 805/* Try to guess the device type based on all collected information. We
 806 * first try to detect by static extension types, then VID/PID and the
 807 * device name. If we cannot detect the device, we use
 808 * WIIMOTE_DEV_GENERIC so all modules will get probed on the device. */
 809static void wiimote_init_set_type(struct wiimote_data *wdata,
 810                                  __u8 exttype)
 811{
 812        __u8 devtype = WIIMOTE_DEV_GENERIC;
 813        __u16 vendor, product;
 814        const char *name;
 815
 816        vendor = wdata->hdev->vendor;
 817        product = wdata->hdev->product;
 818        name = wdata->hdev->name;
 819
 820        if (exttype == WIIMOTE_EXT_BALANCE_BOARD) {
 821                devtype = WIIMOTE_DEV_BALANCE_BOARD;
 822                goto done;
 823        } else if (exttype == WIIMOTE_EXT_PRO_CONTROLLER) {
 824                devtype = WIIMOTE_DEV_PRO_CONTROLLER;
 825                goto done;
 826        }
 827
 828        if (!strcmp(name, "Nintendo RVL-CNT-01")) {
 829                devtype = WIIMOTE_DEV_GEN10;
 830                goto done;
 831        } else if (!strcmp(name, "Nintendo RVL-CNT-01-TR")) {
 832                devtype = WIIMOTE_DEV_GEN20;
 833                goto done;
 834        } else if (!strcmp(name, "Nintendo RVL-WBC-01")) {
 835                devtype = WIIMOTE_DEV_BALANCE_BOARD;
 836                goto done;
 837        } else if (!strcmp(name, "Nintendo RVL-CNT-01-UC")) {
 838                devtype = WIIMOTE_DEV_PRO_CONTROLLER;
 839                goto done;
 840        }
 841
 842        if (vendor == USB_VENDOR_ID_NINTENDO) {
 843                if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE) {
 844                        devtype = WIIMOTE_DEV_GEN10;
 845                        goto done;
 846                } else if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE2) {
 847                        devtype = WIIMOTE_DEV_GEN20;
 848                        goto done;
 849                }
 850        }
 851
 852done:
 853        if (devtype == WIIMOTE_DEV_GENERIC)
 854                hid_info(wdata->hdev, "cannot detect device; NAME: %s VID: %04x PID: %04x EXT: %04x\n",
 855                        name, vendor, product, exttype);
 856        else
 857                hid_info(wdata->hdev, "detected device: %s\n",
 858                         wiimote_devtype_names[devtype]);
 859
 860        wiimote_modules_load(wdata, devtype);
 861}
 862
 863static void wiimote_init_detect(struct wiimote_data *wdata)
 864{
 865        __u8 exttype = WIIMOTE_EXT_NONE, extdata[6];
 866        bool ext;
 867        int ret;
 868
 869        wiimote_cmd_acquire_noint(wdata);
 870
 871        spin_lock_irq(&wdata->state.lock);
 872        wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
 873        wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
 874        wiiproto_req_status(wdata);
 875        spin_unlock_irq(&wdata->state.lock);
 876
 877        ret = wiimote_cmd_wait_noint(wdata);
 878        if (ret)
 879                goto out_release;
 880
 881        spin_lock_irq(&wdata->state.lock);
 882        ext = wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED;
 883        spin_unlock_irq(&wdata->state.lock);
 884
 885        if (!ext)
 886                goto out_release;
 887
 888        wiimote_cmd_init_ext(wdata);
 889        exttype = wiimote_cmd_read_ext(wdata, extdata);
 890
 891out_release:
 892        wiimote_cmd_release(wdata);
 893        wiimote_init_set_type(wdata, exttype);
 894
 895        /* schedule MP timer */
 896        spin_lock_irq(&wdata->state.lock);
 897        if (!(wdata->state.flags & WIIPROTO_FLAG_BUILTIN_MP) &&
 898            !(wdata->state.flags & WIIPROTO_FLAG_NO_MP))
 899                mod_timer(&wdata->timer, jiffies + HZ * 4);
 900        spin_unlock_irq(&wdata->state.lock);
 901}
 902
 903/*
 904 * MP hotplug events are not generated by the wiimote. Therefore, we need
 905 * polling to detect it. We use a 4s interval for polling MP registers. This
 906 * seems reasonable considering applications can trigger it manually via
 907 * sysfs requests.
 908 */
 909static void wiimote_init_poll_mp(struct wiimote_data *wdata)
 910{
 911        bool mp;
 912        __u8 mpdata[6];
 913
 914        wiimote_cmd_acquire_noint(wdata);
 915        wiimote_cmd_init_mp(wdata);
 916        mp = wiimote_cmd_read_mp(wdata, mpdata);
 917        wiimote_cmd_release(wdata);
 918
 919        /* load/unload MP module if it changed */
 920        if (mp) {
 921                if (!wdata->state.mp) {
 922                        hid_info(wdata->hdev, "detected extension: Nintendo Wii Motion Plus\n");
 923                        wiimote_mp_load(wdata);
 924                }
 925        } else if (wdata->state.mp) {
 926                wiimote_mp_unload(wdata);
 927        }
 928
 929        mod_timer(&wdata->timer, jiffies + HZ * 4);
 930}
 931
 932/*
 933 * Check whether the wiimote is in the expected state. The extension registers
 934 * may change during hotplug and initialization so we might get hotplug events
 935 * that we caused by remapping some memory.
 936 * We use some heuristics here to check known states. If the wiimote is in the
 937 * expected state, we can ignore the hotplug event.
 938 *
 939 * Returns "true" if the device is in expected state, "false" if we should
 940 * redo hotplug handling and extension initialization.
 941 */
 942static bool wiimote_init_check(struct wiimote_data *wdata)
 943{
 944        __u32 flags;
 945        __u8 type, data[6];
 946        bool ret, poll_mp;
 947
 948        spin_lock_irq(&wdata->state.lock);
 949        flags = wdata->state.flags;
 950        spin_unlock_irq(&wdata->state.lock);
 951
 952        wiimote_cmd_acquire_noint(wdata);
 953
 954        /* If MP is used and active, but the extension is not, we expect:
 955         *   read_mp_mapped() == WIIMOTE_MP_SINGLE
 956         *   state.flags == !EXT_ACTIVE && !MP_PLUGGED && MP_ACTIVE
 957         * We do not check EXT_PLUGGED because it might change during
 958         * initialization of MP without extensions.
 959         *  - If MP is unplugged/replugged, read_mp_mapped() fails
 960         *  - If EXT is plugged, MP_PLUGGED will get set */
 961        if (wdata->state.exttype == WIIMOTE_EXT_NONE &&
 962            wdata->state.mp > 0 && (flags & WIIPROTO_FLAG_MP_USED)) {
 963                type = wiimote_cmd_read_mp_mapped(wdata);
 964                ret = type == WIIMOTE_MP_SINGLE;
 965
 966                spin_lock_irq(&wdata->state.lock);
 967                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
 968                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED);
 969                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
 970                spin_unlock_irq(&wdata->state.lock);
 971
 972                if (!ret)
 973                        hid_dbg(wdata->hdev, "state left: !EXT && MP\n");
 974
 975                /* while MP is mapped, we get EXT_PLUGGED events */
 976                poll_mp = false;
 977
 978                goto out_release;
 979        }
 980
 981        /* If MP is unused, but the extension port is used, we expect:
 982         *   read_ext == state.exttype
 983         *   state.flags == !MP_ACTIVE && EXT_ACTIVE
 984         * - If MP is plugged/unplugged, our timer detects it
 985         * - If EXT is unplugged/replugged, EXT_ACTIVE will become unset */
 986        if (!(flags & WIIPROTO_FLAG_MP_USED) &&
 987            wdata->state.exttype != WIIMOTE_EXT_NONE) {
 988                type = wiimote_cmd_read_ext(wdata, data);
 989                ret = type == wdata->state.exttype;
 990
 991                spin_lock_irq(&wdata->state.lock);
 992                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
 993                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
 994                spin_unlock_irq(&wdata->state.lock);
 995
 996                if (!ret)
 997                        hid_dbg(wdata->hdev, "state left: EXT && !MP\n");
 998
 999                /* poll MP for hotplug events */
1000                poll_mp = true;

1001
1002                goto out_release;
1003        }
1004
1005        /* If neither MP nor an extension are used, we expect:
1006         *   read_ext() == WIIMOTE_EXT_NONE
1007         *   state.flags == !MP_ACTIVE && !EXT_ACTIVE && !EXT_PLUGGED
1008         * No need to perform any action in this case as everything is
1009         * disabled already.
1010         * - If MP is plugged/unplugged, our timer detects it
1011         * - If EXT is plugged, EXT_PLUGGED will be set */
1012        if (!(flags & WIIPROTO_FLAG_MP_USED) &&
1013            wdata->state.exttype == WIIMOTE_EXT_NONE) {
1014                type = wiimote_cmd_read_ext(wdata, data);
1015                ret = type == wdata->state.exttype;
1016
1017                spin_lock_irq(&wdata->state.lock);
1018                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
1019                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
1020                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED);
1021                spin_unlock_irq(&wdata->state.lock);
1022
1023                if (!ret)
1024                        hid_dbg(wdata->hdev, "state left: !EXT && !MP\n");
1025
1026                /* poll MP for hotplug events */
1027                poll_mp = true;
1028
1029                goto out_release;
1030        }
1031
1032        /* The trickiest part is if both EXT and MP are active. We cannot read
1033         * the EXT ID, anymore, because MP is mapped over it. However, we use
1034         * a handy trick here:
1035         *   - EXT_ACTIVE is unset whenever !MP_PLUGGED is sent
1036         * MP_PLUGGED might be re-sent again before we are scheduled, but
1037         * EXT_ACTIVE will stay unset.
1038         * So it is enough to check for mp_mapped() and MP_ACTIVE and
1039         * EXT_ACTIVE. EXT_PLUGGED is a sanity check. */
1040        if (wdata->state.exttype != WIIMOTE_EXT_NONE &&
1041            wdata->state.mp > 0 && (flags & WIIPROTO_FLAG_MP_USED)) {
1042                type = wiimote_cmd_read_mp_mapped(wdata);
1043                ret = type != WIIMOTE_MP_NONE;
1044                ret = ret && type != WIIMOTE_MP_UNKNOWN;
1045                ret = ret && type != WIIMOTE_MP_SINGLE;
1046
1047                spin_lock_irq(&wdata->state.lock);
1048                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED);
1049                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
1050                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
1051                spin_unlock_irq(&wdata->state.lock);
1052
1053                if (!ret)
1054                        hid_dbg(wdata->hdev, "state left: EXT && MP\n");
1055
1056                /* while MP is mapped, we get EXT_PLUGGED events */
1057                poll_mp = false;
1058
1059                goto out_release;
1060        }
1061
1062        /* unknown state */
1063        ret = false;
1064
1065out_release:
1066        wiimote_cmd_release(wdata);
1067
1068        /* only poll for MP if requested and if state didn't change */
1069        if (ret && poll_mp && !(flags & WIIPROTO_FLAG_BUILTIN_MP) &&
1070            !(flags & WIIPROTO_FLAG_NO_MP))
1071                wiimote_init_poll_mp(wdata);
1072
1073        return ret;
1074}
1075
1076static const char *wiimote_exttype_names[WIIMOTE_EXT_NUM] = {
1077        [WIIMOTE_EXT_NONE] = "None",
1078        [WIIMOTE_EXT_UNKNOWN] = "Unknown",
1079        [WIIMOTE_EXT_NUNCHUK] = "Nintendo Wii Nunchuk",
1080        [WIIMOTE_EXT_CLASSIC_CONTROLLER] = "Nintendo Wii Classic Controller",
1081        [WIIMOTE_EXT_BALANCE_BOARD] = "Nintendo Wii Balance Board",
1082        [WIIMOTE_EXT_PRO_CONTROLLER] = "Nintendo Wii U Pro Controller",
1083        [WIIMOTE_EXT_DRUMS] = "Nintendo Wii Drums",
1084        [WIIMOTE_EXT_GUITAR] = "Nintendo Wii Guitar",
1085};
1086
1087/*
1088 * Handle hotplug events
1089 * If we receive an hotplug event and the device-check failed, we deinitialize
1090 * the extension ports, re-read all extension IDs and set the device into
1091 * the desired state. This involves mapping MP into the main extension
1092 * registers, setting up extension passthrough modes and initializing the
1093 * requested extensions.
1094 */
1095static void wiimote_init_hotplug(struct wiimote_data *wdata)
1096{
1097        __u8 exttype, extdata[6], mpdata[6];
1098        __u32 flags;
1099        bool mp;
1100
1101        hid_dbg(wdata->hdev, "detect extensions..\n");
1102
1103        wiimote_cmd_acquire_noint(wdata);
1104
1105        spin_lock_irq(&wdata->state.lock);
1106
1107        /* get state snapshot that we will then work on */
1108        flags = wdata->state.flags;
1109
1110        /* disable event forwarding temporarily */
1111        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE;
1112        wdata->state.flags &= ~WIIPROTO_FLAG_MP_ACTIVE;
1113
1114        spin_unlock_irq(&wdata->state.lock);
1115
1116        /* init extension and MP (deactivates current extension or MP) */
1117        wiimote_cmd_init_ext(wdata);
1118        if (flags & WIIPROTO_FLAG_NO_MP) {
1119                mp = false;
1120        } else {
1121                wiimote_cmd_init_mp(wdata);
1122                mp = wiimote_cmd_read_mp(wdata, mpdata);
1123        }
1124        exttype = wiimote_cmd_read_ext(wdata, extdata);
1125
1126        wiimote_cmd_release(wdata);
1127
1128        /* load/unload extension module if it changed */
1129        if (exttype != wdata->state.exttype) {
1130                /* unload previous extension */
1131                wiimote_ext_unload(wdata);
1132
1133                if (exttype == WIIMOTE_EXT_UNKNOWN) {
1134                        hid_info(wdata->hdev, "cannot detect extension; %6phC\n",
1135                                 extdata);
1136                } else if (exttype == WIIMOTE_EXT_NONE) {
1137                        spin_lock_irq(&wdata->state.lock);
1138                        wdata->state.exttype = WIIMOTE_EXT_NONE;
1139                        spin_unlock_irq(&wdata->state.lock);
1140                } else {
1141                        hid_info(wdata->hdev, "detected extension: %s\n",
1142                                 wiimote_exttype_names[exttype]);
1143                        /* try loading new extension */
1144                        wiimote_ext_load(wdata, exttype);
1145                }
1146        }
1147
1148        /* load/unload MP module if it changed */
1149        if (mp) {
1150                if (!wdata->state.mp) {
1151                        hid_info(wdata->hdev, "detected extension: Nintendo Wii Motion Plus\n");
1152                        wiimote_mp_load(wdata);
1153                }
1154        } else if (wdata->state.mp) {
1155                wiimote_mp_unload(wdata);
1156        }
1157
1158        /* if MP is not used, do not map or activate it */
1159        if (!(flags & WIIPROTO_FLAG_MP_USED))
1160                mp = false;
1161
1162        /* map MP into main extension registers if used */
1163        if (mp) {
1164                wiimote_cmd_acquire_noint(wdata);
1165                wiimote_cmd_map_mp(wdata, exttype);
1166                wiimote_cmd_release(wdata);
1167
1168                /* delete MP hotplug timer */
1169                del_timer_sync(&wdata->timer);
1170        } else {
1171                /* reschedule MP hotplug timer */
1172                if (!(flags & WIIPROTO_FLAG_BUILTIN_MP) &&
1173                    !(flags & WIIPROTO_FLAG_NO_MP))
1174                        mod_timer(&wdata->timer, jiffies + HZ * 4);
1175        }
1176
1177        spin_lock_irq(&wdata->state.lock);
1178
1179        /* enable data forwarding again and set expected hotplug state */
1180        if (mp) {
1181                wdata->state.flags |= WIIPROTO_FLAG_MP_ACTIVE;
1182                if (wdata->state.exttype == WIIMOTE_EXT_NONE) {
1183                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
1184                        wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED;
1185                } else {
1186                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
1187                        wdata->state.flags |= WIIPROTO_FLAG_MP_PLUGGED;
1188                        wdata->state.flags |= WIIPROTO_FLAG_EXT_ACTIVE;
1189                }
1190        } else if (wdata->state.exttype != WIIMOTE_EXT_NONE) {
1191                wdata->state.flags |= WIIPROTO_FLAG_EXT_ACTIVE;
1192        }
1193
1194        /* request status report for hotplug state updates */
1195        wiiproto_req_status(wdata);
1196
1197        spin_unlock_irq(&wdata->state.lock);
1198
1199        hid_dbg(wdata->hdev, "detected extensions: MP: %d EXT: %d\n",
1200                wdata->state.mp, wdata->state.exttype);
1201}
1202
1203static void wiimote_init_worker(struct work_struct *work)
1204{
1205        struct wiimote_data *wdata = container_of(work, struct wiimote_data,
1206                                                  init_worker);
1207        bool changed = false;
1208
1209        if (wdata->state.devtype == WIIMOTE_DEV_PENDING) {
1210                wiimote_init_detect(wdata);
1211                changed = true;
1212        }
1213
1214        if (changed || !wiimote_init_check(wdata))
1215                wiimote_init_hotplug(wdata);
1216
1217        if (changed)
1218                kobject_uevent(&wdata->hdev->dev.kobj, KOBJ_CHANGE);
1219}
1220
1221void __wiimote_schedule(struct wiimote_data *wdata)
1222{
1223        if (!(wdata->state.flags & WIIPROTO_FLAG_EXITING))
1224                schedule_work(&wdata->init_worker);
1225}
1226
1227static void wiimote_schedule(struct wiimote_data *wdata)
1228{
1229        unsigned long flags;
1230
1231        spin_lock_irqsave(&wdata->state.lock, flags);
1232        __wiimote_schedule(wdata);
1233        spin_unlock_irqrestore(&wdata->state.lock, flags);
1234}
1235
1236static void wiimote_init_timeout(struct timer_list *t)
1237{
1238        struct wiimote_data *wdata = from_timer(wdata, t, timer);
1239
1240        wiimote_schedule(wdata);
1241}
1242
1243/* protocol handlers */
1244
1245static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
1246{
1247        const __u8 *iter, *mods;
1248        const struct wiimod_ops *ops;
1249
1250        ops = wiimod_ext_table[wdata->state.exttype];
1251        if (ops->in_keys) {
1252                ops->in_keys(wdata, payload);
1253                return;
1254        }
1255
1256        mods = wiimote_devtype_mods[wdata->state.devtype];
1257        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
1258                ops = wiimod_table[*iter];
1259                if (ops->in_keys) {
1260                        ops->in_keys(wdata, payload);
1261                        break;
1262                }
1263        }
1264}
1265
1266static void handler_accel(struct wiimote_data *wdata, const __u8 *payload)
1267{
1268        const __u8 *iter, *mods;
1269        const struct wiimod_ops *ops;
1270
1271        ops = wiimod_ext_table[wdata->state.exttype];
1272        if (ops->in_accel) {
1273                ops->in_accel(wdata, payload);
1274                return;
1275        }
1276
1277        mods = wiimote_devtype_mods[wdata->state.devtype];
1278        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
1279                ops = wiimod_table[*iter];
1280                if (ops->in_accel) {
1281                        ops->in_accel(wdata, payload);
1282                        break;
1283                }
1284        }
1285}
1286
1287static bool valid_ext_handler(const struct wiimod_ops *ops, size_t len)
1288{
1289        if (!ops->in_ext)
1290                return false;
1291        if ((ops->flags & WIIMOD_FLAG_EXT8) && len < 8)
1292                return false;
1293        if ((ops->flags & WIIMOD_FLAG_EXT16) && len < 16)
1294                return false;
1295
1296        return true;
1297}
1298
1299static void handler_ext(struct wiimote_data *wdata, const __u8 *payload,
1300                        size_t len)
1301{
1302        static const __u8 invalid[21] = { 0xff, 0xff, 0xff, 0xff,
1303                                          0xff, 0xff, 0xff, 0xff,
1304                                          0xff, 0xff, 0xff, 0xff,
1305                                          0xff, 0xff, 0xff, 0xff,
1306                                          0xff, 0xff, 0xff, 0xff,
1307                                          0xff };
1308        const __u8 *iter, *mods;
1309        const struct wiimod_ops *ops;
1310        bool is_mp;
1311
1312        if (len > 21)
1313                len = 21;
1314        if (len < 6 || !memcmp(payload, invalid, len))
1315                return;
1316
1317        /* if MP is active, track MP slot hotplugging */
1318        if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
1319                /* this bit is set for invalid events (eg. during hotplug) */
1320                if (payload[5] & 0x01)
1321                        return;
1322
1323                if (payload[4] & 0x01) {
1324                        if (!(wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED)) {
1325                                hid_dbg(wdata->hdev, "MP hotplug: 1\n");
1326                                wdata->state.flags |= WIIPROTO_FLAG_MP_PLUGGED;
1327                                __wiimote_schedule(wdata);
1328                        }
1329                } else {
1330                        if (wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED) {
1331                                hid_dbg(wdata->hdev, "MP hotplug: 0\n");
1332                                wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED;
1333                                wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE;
1334                                __wiimote_schedule(wdata);
1335                        }
1336                }
1337
1338                /* detect MP data that is sent interleaved with EXT data */
1339                is_mp = payload[5] & 0x02;
1340        } else {
1341                is_mp = false;
1342        }
1343
1344        /* ignore EXT events if no extension is active */
1345        if (!(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE) && !is_mp)
1346                return;
1347
1348        /* try forwarding to extension handler, first */
1349        ops = wiimod_ext_table[wdata->state.exttype];
1350        if (is_mp && ops->in_mp) {
1351                ops->in_mp(wdata, payload);
1352                return;
1353        } else if (!is_mp && valid_ext_handler(ops, len)) {
1354                ops->in_ext(wdata, payload);
1355                return;
1356        }
1357
1358        /* try forwarding to MP handler */
1359        ops = &wiimod_mp;
1360        if (is_mp && ops->in_mp) {
1361                ops->in_mp(wdata, payload);
1362                return;
1363        } else if (!is_mp && valid_ext_handler(ops, len)) {
1364                ops->in_ext(wdata, payload);
1365                return;
1366        }
1367
1368        /* try forwarding to loaded modules */
1369        mods = wiimote_devtype_mods[wdata->state.devtype];
1370        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
1371                ops = wiimod_table[*iter];
1372                if (is_mp && ops->in_mp) {
1373                        ops->in_mp(wdata, payload);
1374                        return;
1375                } else if (!is_mp && valid_ext_handler(ops, len)) {
1376                        ops->in_ext(wdata, payload);
1377                        return;
1378                }
1379        }
1380}
1381
1382#define ir_to_input0(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 0)
1383#define ir_to_input1(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 1)
1384#define ir_to_input2(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 2)
1385#define ir_to_input3(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 3)
1386
1387static void handler_ir(struct wiimote_data *wdata, const __u8 *payload,
1388                       bool packed, unsigned int id)
1389{
1390        const __u8 *iter, *mods;
1391        const struct wiimod_ops *ops;
1392
1393        ops = wiimod_ext_table[wdata->state.exttype];
1394        if (ops->in_ir) {
1395                ops->in_ir(wdata, payload, packed, id);
1396                return;
1397        }
1398
1399        mods = wiimote_devtype_mods[wdata->state.devtype];
1400        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
1401                ops = wiimod_table[*iter];
1402                if (ops->in_ir) {
1403                        ops->in_ir(wdata, payload, packed, id);
1404                        break;
1405                }
1406        }
1407}
1408
1409/* reduced status report with "BB BB" key data only */
1410static void handler_status_K(struct wiimote_data *wdata,
1411                             const __u8 *payload)
1412{
1413        handler_keys(wdata, payload);
1414
1415        /* on status reports the drm is reset so we need to resend the drm */
1416        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1417}
1418
1419/* extended status report with "BB BB LF 00 00 VV" data */
1420static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
1421{
1422        handler_status_K(wdata, payload);
1423
1424        /* update extension status */
1425        if (payload[2] & 0x02) {
1426                if (!(wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED)) {
1427                        hid_dbg(wdata->hdev, "EXT hotplug: 1\n");
1428                        wdata->state.flags |= WIIPROTO_FLAG_EXT_PLUGGED;
1429                        __wiimote_schedule(wdata);
1430                }
1431        } else {
1432                if (wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED) {
1433                        hid_dbg(wdata->hdev, "EXT hotplug: 0\n");
1434                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
1435                        wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED;
1436                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE;
1437                        wdata->state.flags &= ~WIIPROTO_FLAG_MP_ACTIVE;
1438                        __wiimote_schedule(wdata);
1439                }
1440        }
1441
1442        wdata->state.cmd_battery = payload[5];
1443        if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0))
1444                wiimote_cmd_complete(wdata);
1445}
1446
1447/* reduced generic report with "BB BB" key data only */
1448static void handler_generic_K(struct wiimote_data *wdata, const __u8 *payload)
1449{
1450        handler_keys(wdata, payload);
1451}
1452
1453static void handler_data(struct wiimote_data *wdata, const __u8 *payload)
1454{
1455        __u16 offset = payload[3] << 8 | payload[4];
1456        __u8 size = (payload[2] >> 4) + 1;
1457        __u8 err = payload[2] & 0x0f;
1458
1459        handler_keys(wdata, payload);
1460
1461        if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_RMEM, offset)) {
1462                if (err)
1463                        size = 0;
1464                else if (size > wdata->state.cmd_read_size)
1465                        size = wdata->state.cmd_read_size;
1466
1467                wdata->state.cmd_read_size = size;
1468                if (wdata->state.cmd_read_buf)
1469                        memcpy(wdata->state.cmd_read_buf, &payload[5], size);
1470                wiimote_cmd_complete(wdata);
1471        }
1472}
1473
1474static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
1475{
1476        __u8 err = payload[3];
1477        __u8 cmd = payload[2];
1478
1479        handler_keys(wdata, payload);
1480
1481        if (wiimote_cmd_pending(wdata, cmd, 0)) {
1482                wdata->state.cmd_err = err;
1483                wiimote_cmd_complete(wdata);
1484        } else if (err) {
1485                hid_warn(wdata->hdev, "Remote error %u on req %u\n", err,
1486                                                                        cmd);
1487        }
1488}
1489
1490static void handler_drm_KA(struct wiimote_data *wdata, const __u8 *payload)
1491{
1492        handler_keys(wdata, payload);
1493        handler_accel(wdata, payload);
1494}
1495
1496static void handler_drm_KE(struct wiimote_data *wdata, const __u8 *payload)
1497{
1498        handler_keys(wdata, payload);
1499        handler_ext(wdata, &payload[2], 8);
1500}
1501
1502static void handler_drm_KAI(struct wiimote_data *wdata, const __u8 *payload)
1503{
1504        handler_keys(wdata, payload);
1505        handler_accel(wdata, payload);
1506        ir_to_input0(wdata, &payload[5], false);
1507        ir_to_input1(wdata, &payload[8], false);
1508        ir_to_input2(wdata, &payload[11], false);
1509        ir_to_input3(wdata, &payload[14], false);
1510}
1511
1512static void handler_drm_KEE(struct wiimote_data *wdata, const __u8 *payload)
1513{
1514        handler_keys(wdata, payload);
1515        handler_ext(wdata, &payload[2], 19);
1516}
1517
1518static void handler_drm_KIE(struct wiimote_data *wdata, const __u8 *payload)
1519{
1520        handler_keys(wdata, payload);
1521        ir_to_input0(wdata, &payload[2], false);
1522        ir_to_input1(wdata, &payload[4], true);
1523        ir_to_input2(wdata, &payload[7], false);
1524        ir_to_input3(wdata, &payload[9], true);
1525        handler_ext(wdata, &payload[12], 9);
1526}
1527
1528static void handler_drm_KAE(struct wiimote_data *wdata, const __u8 *payload)
1529{
1530        handler_keys(wdata, payload);
1531        handler_accel(wdata, payload);
1532        handler_ext(wdata, &payload[5], 16);
1533}
1534
1535static void handler_drm_KAIE(struct wiimote_data *wdata, const __u8 *payload)
1536{
1537        handler_keys(wdata, payload);
1538        handler_accel(wdata, payload);
1539        ir_to_input0(wdata, &payload[5], false);
1540        ir_to_input1(wdata, &payload[7], true);
1541        ir_to_input2(wdata, &payload[10], false);
1542        ir_to_input3(wdata, &payload[12], true);
1543        handler_ext(wdata, &payload[15], 6);
1544}
1545
1546static void handler_drm_E(struct wiimote_data *wdata, const __u8 *payload)
1547{
1548        handler_ext(wdata, payload, 21);
1549}
1550
1551static void handler_drm_SKAI1(struct wiimote_data *wdata, const __u8 *payload)
1552{
1553        handler_keys(wdata, payload);
1554
1555        wdata->state.accel_split[0] = payload[2];
1556        wdata->state.accel_split[1] = (payload[0] >> 1) & (0x10 | 0x20);
1557        wdata->state.accel_split[1] |= (payload[1] << 1) & (0x40 | 0x80);
1558
1559        ir_to_input0(wdata, &payload[3], false);
1560        ir_to_input1(wdata, &payload[12], false);
1561}
1562
1563static void handler_drm_SKAI2(struct wiimote_data *wdata, const __u8 *payload)
1564{
1565        __u8 buf[5];
1566
1567        handler_keys(wdata, payload);
1568
1569        wdata->state.accel_split[1] |= (payload[0] >> 5) & (0x01 | 0x02);
1570        wdata->state.accel_split[1] |= (payload[1] >> 3) & (0x04 | 0x08);
1571
1572        buf[0] = 0;
1573        buf[1] = 0;
1574        buf[2] = wdata->state.accel_split[0];
1575        buf[3] = payload[2];
1576        buf[4] = wdata->state.accel_split[1];
1577        handler_accel(wdata, buf);
1578
1579        ir_to_input2(wdata, &payload[3], false);
1580        ir_to_input3(wdata, &payload[12], false);
1581}
1582
1583struct wiiproto_handler {
1584        __u8 id;
1585        size_t size;
1586        void (*func)(struct wiimote_data *wdata, const __u8 *payload);
1587};
1588
1589static const struct wiiproto_handler handlers[] = {
1590        { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
1591        { .id = WIIPROTO_REQ_STATUS, .size = 2, .func = handler_status_K },
1592        { .id = WIIPROTO_REQ_DATA, .size = 21, .func = handler_data },
1593        { .id = WIIPROTO_REQ_DATA, .size = 2, .func = handler_generic_K },
1594        { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
1595        { .id = WIIPROTO_REQ_RETURN, .size = 2, .func = handler_generic_K },
1596        { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
1597        { .id = WIIPROTO_REQ_DRM_KA, .size = 5, .func = handler_drm_KA },
1598        { .id = WIIPROTO_REQ_DRM_KA, .size = 2, .func = handler_generic_K },
1599        { .id = WIIPROTO_REQ_DRM_KE, .size = 10, .func = handler_drm_KE },
1600        { .id = WIIPROTO_REQ_DRM_KE, .size = 2, .func = handler_generic_K },
1601        { .id = WIIPROTO_REQ_DRM_KAI, .size = 17, .func = handler_drm_KAI },
1602        { .id = WIIPROTO_REQ_DRM_KAI, .size = 2, .func = handler_generic_K },
1603        { .id = WIIPROTO_REQ_DRM_KEE, .size = 21, .func = handler_drm_KEE },
1604        { .id = WIIPROTO_REQ_DRM_KEE, .size = 2, .func = handler_generic_K },
1605        { .id = WIIPROTO_REQ_DRM_KAE, .size = 21, .func = handler_drm_KAE },
1606        { .id = WIIPROTO_REQ_DRM_KAE, .size = 2, .func = handler_generic_K },
1607        { .id = WIIPROTO_REQ_DRM_KIE, .size = 21, .func = handler_drm_KIE },
1608        { .id = WIIPROTO_REQ_DRM_KIE, .size = 2, .func = handler_generic_K },
1609        { .id = WIIPROTO_REQ_DRM_KAIE, .size = 21, .func = handler_drm_KAIE },
1610        { .id = WIIPROTO_REQ_DRM_KAIE, .size = 2, .func = handler_generic_K },
1611        { .id = WIIPROTO_REQ_DRM_E, .size = 21, .func = handler_drm_E },
1612        { .id = WIIPROTO_REQ_DRM_SKAI1, .size = 21, .func = handler_drm_SKAI1 },
1613        { .id = WIIPROTO_REQ_DRM_SKAI2, .size = 21, .func = handler_drm_SKAI2 },
1614        { .id = 0 }
1615};
1616
1617static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
1618                                                        u8 *raw_data, int size)
1619{
1620        struct wiimote_data *wdata = hid_get_drvdata(hdev);
1621        const struct wiiproto_handler *h;
1622        int i;
1623        unsigned long flags;
1624
1625        if (size < 1)
1626                return -EINVAL;
1627
1628        for (i = 0; handlers[i].id; ++i) {
1629                h = &handlers[i];
1630                if (h->id == raw_data[0] && h->size < size) {
1631                        spin_lock_irqsave(&wdata->state.lock, flags);
1632                        h->func(wdata, &raw_data[1]);
1633                        spin_unlock_irqrestore(&wdata->state.lock, flags);
1634                        break;
1635                }
1636        }
1637
1638        if (!handlers[i].id)
1639                hid_warn(hdev, "Unhandled report %hhu size %d\n", raw_data[0],
1640                                                                        size);
1641
1642        return 0;
1643}
1644
1645static ssize_t wiimote_ext_show(struct device *dev,
1646                                struct device_attribute *attr,
1647                                char *buf)
1648{
1649        struct wiimote_data *wdata = dev_to_wii(dev);
1650        __u8 type;
1651        unsigned long flags;
1652
1653        spin_lock_irqsave(&wdata->state.lock, flags);
1654        type = wdata->state.exttype;
1655        spin_unlock_irqrestore(&wdata->state.lock, flags);
1656
1657        switch (type) {
1658        case WIIMOTE_EXT_NONE:
1659                return sprintf(buf, "none\n");
1660        case WIIMOTE_EXT_NUNCHUK:
1661                return sprintf(buf, "nunchuk\n");
1662        case WIIMOTE_EXT_CLASSIC_CONTROLLER:
1663                return sprintf(buf, "classic\n");
1664        case WIIMOTE_EXT_BALANCE_BOARD:
1665                return sprintf(buf, "balanceboard\n");
1666        case WIIMOTE_EXT_PRO_CONTROLLER:
1667                return sprintf(buf, "procontroller\n");
1668        case WIIMOTE_EXT_DRUMS:
1669                return sprintf(buf, "drums\n");
1670        case WIIMOTE_EXT_GUITAR:
1671                return sprintf(buf, "guitar\n");
1672        case WIIMOTE_EXT_UNKNOWN:
1673        default:
1674                return sprintf(buf, "unknown\n");
1675        }
1676}
1677
1678static ssize_t wiimote_ext_store(struct device *dev,
1679                                 struct device_attribute *attr,
1680                                 const char *buf, size_t count)
1681{
1682        struct wiimote_data *wdata = dev_to_wii(dev);
1683
1684        if (!strcmp(buf, "scan")) {
1685                wiimote_schedule(wdata);
1686        } else {
1687                return -EINVAL;
1688        }
1689
1690        return strnlen(buf, PAGE_SIZE);
1691}
1692
1693static DEVICE_ATTR(extension, S_IRUGO | S_IWUSR | S_IWGRP, wiimote_ext_show,
1694                   wiimote_ext_store);
1695
1696static ssize_t wiimote_dev_show(struct device *dev,
1697                                struct device_attribute *attr,
1698                                char *buf)
1699{
1700        struct wiimote_data *wdata = dev_to_wii(dev);
1701        __u8 type;
1702        unsigned long flags;
1703
1704        spin_lock_irqsave(&wdata->state.lock, flags);
1705        type = wdata->state.devtype;
1706        spin_unlock_irqrestore(&wdata->state.lock, flags);
1707
1708        switch (type) {
1709        case WIIMOTE_DEV_GENERIC:
1710                return sprintf(buf, "generic\n");
1711        case WIIMOTE_DEV_GEN10:
1712                return sprintf(buf, "gen10\n");
1713        case WIIMOTE_DEV_GEN20:
1714                return sprintf(buf, "gen20\n");
1715        case WIIMOTE_DEV_BALANCE_BOARD:
1716                return sprintf(buf, "balanceboard\n");
1717        case WIIMOTE_DEV_PRO_CONTROLLER:
1718                return sprintf(buf, "procontroller\n");
1719        case WIIMOTE_DEV_PENDING:
1720                return sprintf(buf, "pending\n");
1721        case WIIMOTE_DEV_UNKNOWN:
1722        default:
1723                return sprintf(buf, "unknown\n");
1724        }
1725}
1726
1727static DEVICE_ATTR(devtype, S_IRUGO, wiimote_dev_show, NULL);
1728
1729static struct wiimote_data *wiimote_create(struct hid_device *hdev)
1730{
1731        struct wiimote_data *wdata;
1732
1733        wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
1734        if (!wdata)
1735                return NULL;
1736
1737        wdata->hdev = hdev;
1738        hid_set_drvdata(hdev, wdata);
1739
1740        spin_lock_init(&wdata->queue.lock);
1741        INIT_WORK(&wdata->queue.worker, wiimote_queue_worker);
1742
1743        spin_lock_init(&wdata->state.lock);
1744        init_completion(&wdata->state.ready);
1745        mutex_init(&wdata->state.sync);
1746        wdata->state.drm = WIIPROTO_REQ_DRM_K;
1747        wdata->state.cmd_battery = 0xff;
1748
1749        INIT_WORK(&wdata->init_worker, wiimote_init_worker);
1750        timer_setup(&wdata->timer, wiimote_init_timeout, 0);
1751
1752        return wdata;
1753}
1754
1755static void wiimote_destroy(struct wiimote_data *wdata)
1756{
1757        unsigned long flags;
1758
1759        wiidebug_deinit(wdata);
1760
1761        /* prevent init_worker from being scheduled again */
1762        spin_lock_irqsave(&wdata->state.lock, flags);
1763        wdata->state.flags |= WIIPROTO_FLAG_EXITING;
1764        spin_unlock_irqrestore(&wdata->state.lock, flags);
1765
1766        cancel_work_sync(&wdata->init_worker);
1767        del_timer_sync(&wdata->timer);
1768
1769        device_remove_file(&wdata->hdev->dev, &dev_attr_devtype);
1770        device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
1771
1772        wiimote_mp_unload(wdata);
1773        wiimote_ext_unload(wdata);
1774        wiimote_modules_unload(wdata);
1775        cancel_work_sync(&wdata->queue.worker);
1776        hid_hw_close(wdata->hdev);
1777        hid_hw_stop(wdata->hdev);
1778
1779        kfree(wdata);
1780}
1781
1782static int wiimote_hid_probe(struct hid_device *hdev,
1783                                const struct hid_device_id *id)
1784{
1785        struct wiimote_data *wdata;
1786        int ret;
1787
1788        hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
1789
1790        wdata = wiimote_create(hdev);
1791        if (!wdata) {
1792                hid_err(hdev, "Can't alloc device\n");
1793                return -ENOMEM;
1794        }
1795
1796        ret = hid_parse(hdev);
1797        if (ret) {
1798                hid_err(hdev, "HID parse failed\n");
1799                goto err;
1800        }
1801
1802        ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1803        if (ret) {
1804                hid_err(hdev, "HW start failed\n");
1805                goto err;
1806        }
1807
1808        ret = hid_hw_open(hdev);
1809        if (ret) {
1810                hid_err(hdev, "cannot start hardware I/O\n");
1811                goto err_stop;
1812        }
1813
1814        ret = device_create_file(&hdev->dev, &dev_attr_extension);
1815        if (ret) {
1816                hid_err(hdev, "cannot create sysfs attribute\n");
1817                goto err_close;
1818        }
1819
1820        ret = device_create_file(&hdev->dev, &dev_attr_devtype);
1821        if (ret) {
1822                hid_err(hdev, "cannot create sysfs attribute\n");
1823                goto err_ext;
1824        }
1825
1826        ret = wiidebug_init(wdata);
1827        if (ret)
1828                goto err_free;
1829
1830        hid_info(hdev, "New device registered\n");
1831
1832        /* schedule device detection */
1833        wiimote_schedule(wdata);
1834
1835        return 0;
1836
1837err_free:
1838        wiimote_destroy(wdata);
1839        return ret;
1840
1841err_ext:
1842        device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
1843err_close:
1844        hid_hw_close(hdev);
1845err_stop:
1846        hid_hw_stop(hdev);
1847err:
1848        input_free_device(wdata->ir);
1849        input_free_device(wdata->accel);
1850        kfree(wdata);
1851        return ret;
1852}
1853
1854static void wiimote_hid_remove(struct hid_device *hdev)
1855{
1856        struct wiimote_data *wdata = hid_get_drvdata(hdev);
1857
1858        hid_info(hdev, "Device removed\n");
1859        wiimote_destroy(wdata);
1860}
1861
1862static const struct hid_device_id wiimote_hid_devices[] = {
1863        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
1864                                USB_DEVICE_ID_NINTENDO_WIIMOTE) },
1865        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
1866                                USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
1867        { }
1868};
1869
1870bool wiimote_dpad_as_analog = false;
1871module_param_named(dpad_as_analog, wiimote_dpad_as_analog, bool, 0644);
1872MODULE_PARM_DESC(dpad_as_analog, "Use D-Pad as main analog input");
1873
1874MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
1875
1876static struct hid_driver wiimote_hid_driver = {
1877        .name = "wiimote",
1878        .id_table = wiimote_hid_devices,
1879        .probe = wiimote_hid_probe,
1880        .remove = wiimote_hid_remove,
1881        .raw_event = wiimote_hid_event,
1882};
1883module_hid_driver(wiimote_hid_driver);
1884
1885MODULE_LICENSE("GPL");
1886MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
1887MODULE_DESCRIPTION("Driver for Nintendo Wii / Wii U peripherals");
1888
Hosted by Missing Link Electronics. The original LXR software by the LXR community, this experimental version by lxr@linux.no.