linux/drivers/hid/hid-wiimote-core.c
<<
>>
Prefs
   1/*
   2 * HID driver for Nintendo Wii / Wii U peripherals
   3 * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
   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/completion.h>
  14#include <linux/device.h>
  15#include <linux/hid.h>
  16#include <linux/input.h>
  17#include <linux/module.h>
  18#include <linux/mutex.h>
  19#include <linux/spinlock.h>
  20#include "hid-ids.h"
  21#include "hid-wiimote.h"
  22
  23/* output queue handling */
  24
  25static int wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
  26                            size_t count)
  27{
  28        __u8 *buf;
  29        int ret;
  30
  31        if (!hdev->hid_output_raw_report)
  32                return -ENODEV;
  33
  34        buf = kmemdup(buffer, count, GFP_KERNEL);
  35        if (!buf)
  36                return -ENOMEM;
  37
  38        ret = hdev->hid_output_raw_report(hdev, buf, count, HID_OUTPUT_REPORT);
  39
  40        kfree(buf);
  41        return ret;
  42}
  43
  44static void wiimote_queue_worker(struct work_struct *work)
  45{
  46        struct wiimote_queue *queue = container_of(work, struct wiimote_queue,
  47                                                   worker);
  48        struct wiimote_data *wdata = container_of(queue, struct wiimote_data,
  49                                                  queue);
  50        unsigned long flags;
  51        int ret;
  52
  53        spin_lock_irqsave(&wdata->queue.lock, flags);
  54
  55        while (wdata->queue.head != wdata->queue.tail) {
  56                spin_unlock_irqrestore(&wdata->queue.lock, flags);
  57                ret = wiimote_hid_send(wdata->hdev,
  58                                 wdata->queue.outq[wdata->queue.tail].data,
  59                                 wdata->queue.outq[wdata->queue.tail].size);
  60                if (ret < 0) {
  61                        spin_lock_irqsave(&wdata->state.lock, flags);
  62                        wiimote_cmd_abort(wdata);
  63                        spin_unlock_irqrestore(&wdata->state.lock, flags);
  64                }
  65                spin_lock_irqsave(&wdata->queue.lock, flags);
  66
  67                wdata->queue.tail = (wdata->queue.tail + 1) % WIIMOTE_BUFSIZE;
  68        }
  69
  70        spin_unlock_irqrestore(&wdata->queue.lock, flags);
  71}
  72
  73static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
  74                                                                size_t count)
  75{
  76        unsigned long flags;
  77        __u8 newhead;
  78
  79        if (count > HID_MAX_BUFFER_SIZE) {
  80                hid_warn(wdata->hdev, "Sending too large output report\n");
  81
  82                spin_lock_irqsave(&wdata->queue.lock, flags);
  83                goto out_error;
  84        }
  85
  86        /*
  87         * Copy new request into our output queue and check whether the
  88         * queue is full. If it is full, discard this request.
  89         * If it is empty we need to start a new worker that will
  90         * send out the buffer to the hid device.
  91         * If the queue is not empty, then there must be a worker
  92         * that is currently sending out our buffer and this worker
  93         * will reschedule itself until the queue is empty.
  94         */
  95
  96        spin_lock_irqsave(&wdata->queue.lock, flags);
  97
  98        memcpy(wdata->queue.outq[wdata->queue.head].data, buffer, count);
  99        wdata->queue.outq[wdata->queue.head].size = count;
 100        newhead = (wdata->queue.head + 1) % WIIMOTE_BUFSIZE;
 101
 102        if (wdata->queue.head == wdata->queue.tail) {
 103                wdata->queue.head = newhead;
 104                schedule_work(&wdata->queue.worker);
 105        } else if (newhead != wdata->queue.tail) {
 106                wdata->queue.head = newhead;
 107        } else {
 108                hid_warn(wdata->hdev, "Output queue is full");
 109                goto out_error;
 110        }
 111
 112        goto out_unlock;
 113
 114out_error:
 115        wiimote_cmd_abort(wdata);
 116out_unlock:
 117        spin_unlock_irqrestore(&wdata->queue.lock, flags);
 118}
 119
 120/*
 121 * This sets the rumble bit on the given output report if rumble is
 122 * currently enabled.
 123 * \cmd1 must point to the second byte in the output report => &cmd[1]
 124 * This must be called on nearly every output report before passing it
 125 * into the output queue!
 126 */
 127static inline void wiiproto_keep_rumble(struct wiimote_data *wdata, __u8 *cmd1)
 128{
 129        if (wdata->state.flags & WIIPROTO_FLAG_RUMBLE)
 130                *cmd1 |= 0x01;
 131}
 132
 133void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
 134{
 135        __u8 cmd[2];
 136
 137        rumble = !!rumble;
 138        if (rumble == !!(wdata->state.flags & WIIPROTO_FLAG_RUMBLE))
 139                return;
 140
 141        if (rumble)
 142                wdata->state.flags |= WIIPROTO_FLAG_RUMBLE;
 143        else
 144                wdata->state.flags &= ~WIIPROTO_FLAG_RUMBLE;
 145
 146        cmd[0] = WIIPROTO_REQ_RUMBLE;
 147        cmd[1] = 0;
 148
 149        wiiproto_keep_rumble(wdata, &cmd[1]);
 150        wiimote_queue(wdata, cmd, sizeof(cmd));
 151}
 152
 153void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
 154{
 155        __u8 cmd[2];
 156
 157        leds &= WIIPROTO_FLAGS_LEDS;
 158        if ((wdata->state.flags & WIIPROTO_FLAGS_LEDS) == leds)
 159                return;
 160        wdata->state.flags = (wdata->state.flags & ~WIIPROTO_FLAGS_LEDS) | leds;
 161
 162        cmd[0] = WIIPROTO_REQ_LED;
 163        cmd[1] = 0;
 164
 165        if (leds & WIIPROTO_FLAG_LED1)
 166                cmd[1] |= 0x10;
 167        if (leds & WIIPROTO_FLAG_LED2)
 168                cmd[1] |= 0x20;
 169        if (leds & WIIPROTO_FLAG_LED3)
 170                cmd[1] |= 0x40;
 171        if (leds & WIIPROTO_FLAG_LED4)
 172                cmd[1] |= 0x80;
 173
 174        wiiproto_keep_rumble(wdata, &cmd[1]);
 175        wiimote_queue(wdata, cmd, sizeof(cmd));
 176}
 177
 178/*
 179 * Check what peripherals of the wiimote are currently
 180 * active and select a proper DRM that supports all of
 181 * the requested data inputs.
 182 *
 183 * Not all combinations are actually supported. The following
 184 * combinations work only with limitations:
 185 *  - IR cam in extended or full mode disables any data transmission
 186 *    of extension controllers. There is no DRM mode that supports
 187 *    extension bytes plus extended/full IR.
 188 *  - IR cam with accelerometer and extension *_EXT8 is not supported.
 189 *    However, all extensions that need *_EXT8 are devices that don't
 190 *    support IR cameras. Hence, this shouldn't happen under normal
 191 *    operation.
 192 *  - *_EXT16 is only supported in combination with buttons and
 193 *    accelerometer. No IR or similar can be active simultaneously. As
 194 *    above, all modules that require it are mutually exclusive with
 195 *    IR/etc. so this doesn't matter.
 196 */
 197static __u8 select_drm(struct wiimote_data *wdata)
 198{
 199        __u8 ir = wdata->state.flags & WIIPROTO_FLAGS_IR;
 200        bool ext;
 201
 202        ext = (wdata->state.flags & WIIPROTO_FLAG_EXT_USED) ||
 203              (wdata->state.flags & WIIPROTO_FLAG_MP_USED);
 204
 205        /* some 3rd-party balance-boards are hard-coded to KEE, *sigh* */
 206        if (wdata->state.devtype == WIIMOTE_DEV_BALANCE_BOARD) {
 207                if (ext)
 208                        return WIIPROTO_REQ_DRM_KEE;
 209                else
 210                        return WIIPROTO_REQ_DRM_K;
 211        }
 212
 213        if (ir == WIIPROTO_FLAG_IR_BASIC) {
 214                if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) {
 215                        /* GEN10 and ealier devices bind IR formats to DRMs.
 216                         * Hence, we cannot use DRM_KAI here as it might be
 217                         * bound to IR_EXT. Use DRM_KAIE unconditionally so we
 218                         * work with all devices and our parsers can use the
 219                         * fixed formats, too. */
 220                        return WIIPROTO_REQ_DRM_KAIE;
 221                } else {
 222                        return WIIPROTO_REQ_DRM_KIE;
 223                }
 224        } else if (ir == WIIPROTO_FLAG_IR_EXT) {
 225                return WIIPROTO_REQ_DRM_KAI;
 226        } else if (ir == WIIPROTO_FLAG_IR_FULL) {
 227                return WIIPROTO_REQ_DRM_SKAI1;
 228        } else {
 229                if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) {
 230                        if (ext)
 231                                return WIIPROTO_REQ_DRM_KAE;
 232                        else
 233                                return WIIPROTO_REQ_DRM_KA;
 234                } else {
 235                        if (ext)
 236                                return WIIPROTO_REQ_DRM_KEE;
 237                        else
 238                                return WIIPROTO_REQ_DRM_K;
 239                }
 240        }
 241}
 242
 243void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
 244{
 245        __u8 cmd[3];
 246
 247        if (wdata->state.flags & WIIPROTO_FLAG_DRM_LOCKED)
 248                drm = wdata->state.drm;
 249        else if (drm == WIIPROTO_REQ_NULL)
 250                drm = select_drm(wdata);
 251
 252        cmd[0] = WIIPROTO_REQ_DRM;
 253        cmd[1] = 0;
 254        cmd[2] = drm;
 255
 256        wdata->state.drm = drm;
 257        wiiproto_keep_rumble(wdata, &cmd[1]);
 258        wiimote_queue(wdata, cmd, sizeof(cmd));
 259}
 260
 261void wiiproto_req_status(struct wiimote_data *wdata)
 262{
 263        __u8 cmd[2];
 264
 265        cmd[0] = WIIPROTO_REQ_SREQ;
 266        cmd[1] = 0;
 267
 268        wiiproto_keep_rumble(wdata, &cmd[1]);
 269        wiimote_queue(wdata, cmd, sizeof(cmd));
 270}
 271
 272void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
 273{
 274        accel = !!accel;
 275        if (accel == !!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
 276                return;
 277
 278        if (accel)
 279                wdata->state.flags |= WIIPROTO_FLAG_ACCEL;
 280        else
 281                wdata->state.flags &= ~WIIPROTO_FLAG_ACCEL;
 282
 283        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
 284}
 285
 286void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
 287{
 288        __u8 cmd[2];
 289
 290        cmd[0] = WIIPROTO_REQ_IR1;
 291        cmd[1] = flags;
 292
 293        wiiproto_keep_rumble(wdata, &cmd[1]);
 294        wiimote_queue(wdata, cmd, sizeof(cmd));
 295}
 296
 297void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
 298{
 299        __u8 cmd[2];
 300
 301        cmd[0] = WIIPROTO_REQ_IR2;
 302        cmd[1] = flags;
 303
 304        wiiproto_keep_rumble(wdata, &cmd[1]);
 305        wiimote_queue(wdata, cmd, sizeof(cmd));
 306}
 307
 308#define wiiproto_req_wreg(wdata, os, buf, sz) \
 309                        wiiproto_req_wmem((wdata), false, (os), (buf), (sz))
 310
 311#define wiiproto_req_weeprom(wdata, os, buf, sz) \
 312                        wiiproto_req_wmem((wdata), true, (os), (buf), (sz))
 313
 314static void wiiproto_req_wmem(struct wiimote_data *wdata, bool eeprom,
 315                                __u32 offset, const __u8 *buf, __u8 size)
 316{
 317        __u8 cmd[22];
 318
 319        if (size > 16 || size == 0) {
 320                hid_warn(wdata->hdev, "Invalid length %d wmem request\n", size);
 321                return;
 322        }
 323
 324        memset(cmd, 0, sizeof(cmd));
 325        cmd[0] = WIIPROTO_REQ_WMEM;
 326        cmd[2] = (offset >> 16) & 0xff;
 327        cmd[3] = (offset >> 8) & 0xff;
 328        cmd[4] = offset & 0xff;
 329        cmd[5] = size;
 330        memcpy(&cmd[6], buf, size);
 331
 332        if (!eeprom)
 333                cmd[1] |= 0x04;
 334
 335        wiiproto_keep_rumble(wdata, &cmd[1]);
 336        wiimote_queue(wdata, cmd, sizeof(cmd));
 337}
 338
 339void wiiproto_req_rmem(struct wiimote_data *wdata, bool eeprom, __u32 offset,
 340                                                                __u16 size)
 341{
 342        __u8 cmd[7];
 343
 344        if (size == 0) {
 345                hid_warn(wdata->hdev, "Invalid length %d rmem request\n", size);
 346                return;
 347        }
 348
 349        cmd[0] = WIIPROTO_REQ_RMEM;
 350        cmd[1] = 0;
 351        cmd[2] = (offset >> 16) & 0xff;
 352        cmd[3] = (offset >> 8) & 0xff;
 353        cmd[4] = offset & 0xff;
 354        cmd[5] = (size >> 8) & 0xff;
 355        cmd[6] = size & 0xff;
 356
 357        if (!eeprom)
 358                cmd[1] |= 0x04;
 359
 360        wiiproto_keep_rumble(wdata, &cmd[1]);
 361        wiimote_queue(wdata, cmd, sizeof(cmd));
 362}
 363
 364/* requries the cmd-mutex to be held */
 365int wiimote_cmd_write(struct wiimote_data *wdata, __u32 offset,
 366                                                const __u8 *wmem, __u8 size)
 367{
 368        unsigned long flags;
 369        int ret;
 370
 371        spin_lock_irqsave(&wdata->state.lock, flags);
 372        wiimote_cmd_set(wdata, WIIPROTO_REQ_WMEM, 0);
 373        wiiproto_req_wreg(wdata, offset, wmem, size);
 374        spin_unlock_irqrestore(&wdata->state.lock, flags);
 375
 376        ret = wiimote_cmd_wait(wdata);
 377        if (!ret && wdata->state.cmd_err)
 378                ret = -EIO;
 379
 380        return ret;
 381}
 382
 383/* requries the cmd-mutex to be held */
 384ssize_t wiimote_cmd_read(struct wiimote_data *wdata, __u32 offset, __u8 *rmem,
 385                                                                __u8 size)
 386{
 387        unsigned long flags;
 388        ssize_t ret;
 389
 390        spin_lock_irqsave(&wdata->state.lock, flags);
 391        wdata->state.cmd_read_size = size;
 392        wdata->state.cmd_read_buf = rmem;
 393        wiimote_cmd_set(wdata, WIIPROTO_REQ_RMEM, offset & 0xffff);
 394        wiiproto_req_rreg(wdata, offset, size);
 395        spin_unlock_irqrestore(&wdata->state.lock, flags);
 396
 397        ret = wiimote_cmd_wait(wdata);
 398
 399        spin_lock_irqsave(&wdata->state.lock, flags);
 400        wdata->state.cmd_read_buf = NULL;
 401        spin_unlock_irqrestore(&wdata->state.lock, flags);
 402
 403        if (!ret) {
 404                if (wdata->state.cmd_read_size == 0)
 405                        ret = -EIO;
 406                else
 407                        ret = wdata->state.cmd_read_size;
 408        }
 409
 410        return ret;
 411}
 412
 413/* requires the cmd-mutex to be held */
 414static int wiimote_cmd_init_ext(struct wiimote_data *wdata)
 415{
 416        __u8 wmem;
 417        int ret;
 418
 419        /* initialize extension */
 420        wmem = 0x55;
 421        ret = wiimote_cmd_write(wdata, 0xa400f0, &wmem, sizeof(wmem));
 422        if (ret)
 423                return ret;
 424
 425        /* disable default encryption */
 426        wmem = 0x0;
 427        ret = wiimote_cmd_write(wdata, 0xa400fb, &wmem, sizeof(wmem));
 428        if (ret)
 429                return ret;
 430
 431        return 0;
 432}
 433
 434/* requires the cmd-mutex to be held */
 435static __u8 wiimote_cmd_read_ext(struct wiimote_data *wdata, __u8 *rmem)
 436{
 437        int ret;
 438
 439        /* read extension ID */
 440        ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6);
 441        if (ret != 6)
 442                return WIIMOTE_EXT_NONE;
 443
 444        hid_dbg(wdata->hdev, "extension ID: %6phC\n", rmem);
 445
 446        if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff &&
 447            rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff)
 448                return WIIMOTE_EXT_NONE;
 449
 450        if (rmem[4] == 0x00 && rmem[5] == 0x00)
 451                return WIIMOTE_EXT_NUNCHUK;
 452        if (rmem[4] == 0x01 && rmem[5] == 0x01)
 453                return WIIMOTE_EXT_CLASSIC_CONTROLLER;
 454        if (rmem[4] == 0x04 && rmem[5] == 0x02)
 455                return WIIMOTE_EXT_BALANCE_BOARD;
 456        if (rmem[4] == 0x01 && rmem[5] == 0x20)
 457                return WIIMOTE_EXT_PRO_CONTROLLER;
 458
 459        return WIIMOTE_EXT_UNKNOWN;
 460}
 461
 462/* requires the cmd-mutex to be held */
 463static int wiimote_cmd_init_mp(struct wiimote_data *wdata)
 464{
 465        __u8 wmem;
 466        int ret;
 467
 468        /* initialize MP */
 469        wmem = 0x55;
 470        ret = wiimote_cmd_write(wdata, 0xa600f0, &wmem, sizeof(wmem));
 471        if (ret)
 472                return ret;
 473
 474        /* disable default encryption */
 475        wmem = 0x0;
 476        ret = wiimote_cmd_write(wdata, 0xa600fb, &wmem, sizeof(wmem));
 477        if (ret)
 478                return ret;
 479
 480        return 0;
 481}
 482
 483/* requires the cmd-mutex to be held */
 484static bool wiimote_cmd_map_mp(struct wiimote_data *wdata, __u8 exttype)
 485{
 486        __u8 wmem;
 487
 488        /* map MP with correct pass-through mode */
 489        switch (exttype) {
 490        case WIIMOTE_EXT_CLASSIC_CONTROLLER:
 491                wmem = 0x07;
 492                break;
 493        case WIIMOTE_EXT_NUNCHUK:
 494                wmem = 0x05;
 495                break;
 496        default:
 497                wmem = 0x04;
 498                break;
 499        }
 500
 501        return wiimote_cmd_write(wdata, 0xa600fe, &wmem, sizeof(wmem));
 502}
 503
 504/* requires the cmd-mutex to be held */
 505static bool wiimote_cmd_read_mp(struct wiimote_data *wdata, __u8 *rmem)
 506{
 507        int ret;
 508
 509        /* read motion plus ID */
 510        ret = wiimote_cmd_read(wdata, 0xa600fa, rmem, 6);
 511        if (ret != 6)
 512                return false;
 513
 514        hid_dbg(wdata->hdev, "motion plus ID: %6phC\n", rmem);
 515
 516        if (rmem[5] == 0x05)
 517                return true;
 518
 519        hid_info(wdata->hdev, "unknown motion plus ID: %6phC\n", rmem);
 520
 521        return false;
 522}
 523
 524/* requires the cmd-mutex to be held */
 525static __u8 wiimote_cmd_read_mp_mapped(struct wiimote_data *wdata)
 526{
 527        int ret;
 528        __u8 rmem[6];
 529
 530        /* read motion plus ID */
 531        ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6);
 532        if (ret != 6)
 533                return WIIMOTE_MP_NONE;
 534
 535        hid_dbg(wdata->hdev, "mapped motion plus ID: %6phC\n", rmem);
 536
 537        if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff &&
 538            rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff)
 539                return WIIMOTE_MP_NONE;
 540
 541        if (rmem[4] == 0x04 && rmem[5] == 0x05)
 542                return WIIMOTE_MP_SINGLE;
 543        else if (rmem[4] == 0x05 && rmem[5] == 0x05)
 544                return WIIMOTE_MP_PASSTHROUGH_NUNCHUK;
 545        else if (rmem[4] == 0x07 && rmem[5] == 0x05)
 546                return WIIMOTE_MP_PASSTHROUGH_CLASSIC;
 547
 548        return WIIMOTE_MP_UNKNOWN;
 549}
 550
 551/* device module handling */
 552
 553static const __u8 * const wiimote_devtype_mods[WIIMOTE_DEV_NUM] = {
 554        [WIIMOTE_DEV_PENDING] = (const __u8[]){
 555                WIIMOD_NULL,
 556        },
 557        [WIIMOTE_DEV_UNKNOWN] = (const __u8[]){
 558                WIIMOD_NO_MP,
 559                WIIMOD_NULL,
 560        },
 561        [WIIMOTE_DEV_GENERIC] = (const __u8[]){
 562                WIIMOD_KEYS,
 563                WIIMOD_RUMBLE,
 564                WIIMOD_BATTERY,
 565                WIIMOD_LED1,
 566                WIIMOD_LED2,
 567                WIIMOD_LED3,
 568                WIIMOD_LED4,
 569                WIIMOD_ACCEL,
 570                WIIMOD_IR,
 571                WIIMOD_NULL,
 572        },
 573        [WIIMOTE_DEV_GEN10] = (const __u8[]){
 574                WIIMOD_KEYS,
 575                WIIMOD_RUMBLE,
 576                WIIMOD_BATTERY,
 577                WIIMOD_LED1,
 578                WIIMOD_LED2,
 579                WIIMOD_LED3,
 580                WIIMOD_LED4,
 581                WIIMOD_ACCEL,
 582                WIIMOD_IR,
 583                WIIMOD_NULL,
 584        },
 585        [WIIMOTE_DEV_GEN20] = (const __u8[]){
 586                WIIMOD_KEYS,
 587                WIIMOD_RUMBLE,
 588                WIIMOD_BATTERY,
 589                WIIMOD_LED1,
 590                WIIMOD_LED2,
 591                WIIMOD_LED3,
 592                WIIMOD_LED4,
 593                WIIMOD_ACCEL,
 594                WIIMOD_IR,
 595                WIIMOD_BUILTIN_MP,
 596                WIIMOD_NULL,
 597        },
 598        [WIIMOTE_DEV_BALANCE_BOARD] = (const __u8[]) {
 599                WIIMOD_BATTERY,
 600                WIIMOD_LED1,
 601                WIIMOD_NO_MP,
 602                WIIMOD_NULL,
 603        },
 604        [WIIMOTE_DEV_PRO_CONTROLLER] = (const __u8[]) {
 605                WIIMOD_BATTERY,
 606                WIIMOD_LED1,
 607                WIIMOD_LED2,
 608                WIIMOD_LED3,
 609                WIIMOD_LED4,
 610                WIIMOD_NO_MP,
 611                WIIMOD_NULL,
 612        },
 613};
 614
 615static void wiimote_modules_load(struct wiimote_data *wdata,
 616                                 unsigned int devtype)
 617{
 618        bool need_input = false;
 619        const __u8 *mods, *iter;
 620        const struct wiimod_ops *ops;
 621        int ret;
 622
 623        mods = wiimote_devtype_mods[devtype];
 624
 625        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
 626                if (wiimod_table[*iter]->flags & WIIMOD_FLAG_INPUT) {
 627                        need_input = true;
 628                        break;
 629                }
 630        }
 631
 632        if (need_input) {
 633                wdata->input = input_allocate_device();
 634                if (!wdata->input)
 635                        return;
 636
 637                input_set_drvdata(wdata->input, wdata);
 638                wdata->input->dev.parent = &wdata->hdev->dev;
 639                wdata->input->id.bustype = wdata->hdev->bus;
 640                wdata->input->id.vendor = wdata->hdev->vendor;
 641                wdata->input->id.product = wdata->hdev->product;
 642                wdata->input->id.version = wdata->hdev->version;
 643                wdata->input->name = WIIMOTE_NAME;
 644        }
 645
 646        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
 647                ops = wiimod_table[*iter];
 648                if (!ops->probe)
 649                        continue;
 650
 651                ret = ops->probe(ops, wdata);
 652                if (ret)
 653                        goto error;
 654        }
 655
 656        if (wdata->input) {
 657                ret = input_register_device(wdata->input);
 658                if (ret)
 659                        goto error;
 660        }
 661
 662        spin_lock_irq(&wdata->state.lock);
 663        wdata->state.devtype = devtype;
 664        spin_unlock_irq(&wdata->state.lock);
 665        return;
 666
 667error:
 668        for ( ; iter-- != mods; ) {
 669                ops = wiimod_table[*iter];
 670                if (ops->remove)
 671                        ops->remove(ops, wdata);
 672        }
 673
 674        if (wdata->input) {
 675                input_free_device(wdata->input);
 676                wdata->input = NULL;
 677        }
 678}
 679
 680static void wiimote_modules_unload(struct wiimote_data *wdata)
 681{
 682        const __u8 *mods, *iter;
 683        const struct wiimod_ops *ops;
 684        unsigned long flags;
 685
 686        mods = wiimote_devtype_mods[wdata->state.devtype];
 687
 688        spin_lock_irqsave(&wdata->state.lock, flags);
 689        wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
 690        spin_unlock_irqrestore(&wdata->state.lock, flags);
 691
 692        /* find end of list */
 693        for (iter = mods; *iter != WIIMOD_NULL; ++iter)
 694                /* empty */ ;
 695
 696        if (wdata->input) {
 697                input_get_device(wdata->input);
 698                input_unregister_device(wdata->input);
 699        }
 700
 701        for ( ; iter-- != mods; ) {
 702                ops = wiimod_table[*iter];
 703                if (ops->remove)
 704                        ops->remove(ops, wdata);
 705        }
 706
 707        if (wdata->input) {
 708                input_put_device(wdata->input);
 709                wdata->input = NULL;
 710        }
 711}
 712
 713/* device extension handling */
 714
 715static void wiimote_ext_load(struct wiimote_data *wdata, unsigned int ext)
 716{
 717        unsigned long flags;
 718        const struct wiimod_ops *ops;
 719        int ret;
 720
 721        ops = wiimod_ext_table[ext];
 722
 723        if (ops->probe) {
 724                ret = ops->probe(ops, wdata);
 725                if (ret)
 726                        ext = WIIMOTE_EXT_UNKNOWN;
 727        }
 728
 729        spin_lock_irqsave(&wdata->state.lock, flags);
 730        wdata->state.exttype = ext;
 731        spin_unlock_irqrestore(&wdata->state.lock, flags);
 732}
 733
 734static void wiimote_ext_unload(struct wiimote_data *wdata)
 735{
 736        unsigned long flags;
 737        const struct wiimod_ops *ops;
 738
 739        ops = wiimod_ext_table[wdata->state.exttype];
 740
 741        spin_lock_irqsave(&wdata->state.lock, flags);
 742        wdata->state.exttype = WIIMOTE_EXT_UNKNOWN;
 743        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
 744        spin_unlock_irqrestore(&wdata->state.lock, flags);
 745
 746        if (ops->remove)
 747                ops->remove(ops, wdata);
 748}
 749
 750static void wiimote_mp_load(struct wiimote_data *wdata)
 751{
 752        unsigned long flags;
 753        const struct wiimod_ops *ops;
 754        int ret;
 755        __u8 mode = 2;
 756
 757        ops = &wiimod_mp;
 758        if (ops->probe) {
 759                ret = ops->probe(ops, wdata);
 760                if (ret)
 761                        mode = 1;
 762        }
 763
 764        spin_lock_irqsave(&wdata->state.lock, flags);
 765        wdata->state.mp = mode;
 766        spin_unlock_irqrestore(&wdata->state.lock, flags);
 767}
 768
 769static void wiimote_mp_unload(struct wiimote_data *wdata)
 770{
 771        unsigned long flags;
 772        const struct wiimod_ops *ops;
 773
 774        if (wdata->state.mp < 2)
 775                return;
 776
 777        ops = &wiimod_mp;
 778
 779        spin_lock_irqsave(&wdata->state.lock, flags);
 780        wdata->state.mp = 0;
 781        wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED;
 782        spin_unlock_irqrestore(&wdata->state.lock, flags);
 783
 784        if (ops->remove)
 785                ops->remove(ops, wdata);
 786}
 787
 788/* device (re-)initialization and detection */
 789
 790static const char *wiimote_devtype_names[WIIMOTE_DEV_NUM] = {
 791        [WIIMOTE_DEV_PENDING] = "Pending",
 792        [WIIMOTE_DEV_UNKNOWN] = "Unknown",
 793        [WIIMOTE_DEV_GENERIC] = "Generic",
 794        [WIIMOTE_DEV_GEN10] = "Nintendo Wii Remote (Gen 1)",
 795        [WIIMOTE_DEV_GEN20] = "Nintendo Wii Remote Plus (Gen 2)",
 796        [WIIMOTE_DEV_BALANCE_BOARD] = "Nintendo Wii Balance Board",
 797        [WIIMOTE_DEV_PRO_CONTROLLER] = "Nintendo Wii U Pro Controller",
 798};
 799
 800/* Try to guess the device type based on all collected information. We
 801 * first try to detect by static extension types, then VID/PID and the
 802 * device name. If we cannot detect the device, we use
 803 * WIIMOTE_DEV_GENERIC so all modules will get probed on the device. */
 804static void wiimote_init_set_type(struct wiimote_data *wdata,
 805                                  __u8 exttype)
 806{
 807        __u8 devtype = WIIMOTE_DEV_GENERIC;
 808        __u16 vendor, product;
 809        const char *name;
 810
 811        vendor = wdata->hdev->vendor;
 812        product = wdata->hdev->product;
 813        name = wdata->hdev->name;
 814
 815        if (exttype == WIIMOTE_EXT_BALANCE_BOARD) {
 816                devtype = WIIMOTE_DEV_BALANCE_BOARD;
 817                goto done;
 818        } else if (exttype == WIIMOTE_EXT_PRO_CONTROLLER) {
 819                devtype = WIIMOTE_DEV_PRO_CONTROLLER;
 820                goto done;
 821        }
 822
 823        if (!strcmp(name, "Nintendo RVL-CNT-01")) {
 824                devtype = WIIMOTE_DEV_GEN10;
 825                goto done;
 826        } else if (!strcmp(name, "Nintendo RVL-CNT-01-TR")) {
 827                devtype = WIIMOTE_DEV_GEN20;
 828                goto done;
 829        } else if (!strcmp(name, "Nintendo RVL-WBC-01")) {
 830                devtype = WIIMOTE_DEV_BALANCE_BOARD;
 831                goto done;
 832        } else if (!strcmp(name, "Nintendo RVL-CNT-01-UC")) {
 833                devtype = WIIMOTE_DEV_PRO_CONTROLLER;
 834                goto done;
 835        }
 836
 837        if (vendor == USB_VENDOR_ID_NINTENDO) {
 838                if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE) {
 839                        devtype = WIIMOTE_DEV_GEN10;
 840                        goto done;
 841                } else if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE2) {
 842                        devtype = WIIMOTE_DEV_GEN20;
 843                        goto done;
 844                }
 845        }
 846
 847done:
 848        if (devtype == WIIMOTE_DEV_GENERIC)
 849                hid_info(wdata->hdev, "cannot detect device; NAME: %s VID: %04x PID: %04x EXT: %04x\n",
 850                        name, vendor, product, exttype);
 851        else
 852                hid_info(wdata->hdev, "detected device: %s\n",
 853                         wiimote_devtype_names[devtype]);
 854
 855        wiimote_modules_load(wdata, devtype);
 856}
 857
 858static void wiimote_init_detect(struct wiimote_data *wdata)
 859{
 860        __u8 exttype = WIIMOTE_EXT_NONE, extdata[6];
 861        bool ext;
 862        int ret;
 863
 864        wiimote_cmd_acquire_noint(wdata);
 865
 866        spin_lock_irq(&wdata->state.lock);
 867        wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
 868        wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
 869        wiiproto_req_status(wdata);
 870        spin_unlock_irq(&wdata->state.lock);
 871
 872        ret = wiimote_cmd_wait_noint(wdata);
 873        if (ret)
 874                goto out_release;
 875
 876        spin_lock_irq(&wdata->state.lock);
 877        ext = wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED;
 878        spin_unlock_irq(&wdata->state.lock);
 879
 880        if (!ext)
 881                goto out_release;
 882
 883        wiimote_cmd_init_ext(wdata);
 884        exttype = wiimote_cmd_read_ext(wdata, extdata);
 885
 886out_release:
 887        wiimote_cmd_release(wdata);
 888        wiimote_init_set_type(wdata, exttype);
 889
 890        /* schedule MP timer */
 891        spin_lock_irq(&wdata->state.lock);
 892        if (!(wdata->state.flags & WIIPROTO_FLAG_BUILTIN_MP) &&
 893            !(wdata->state.flags & WIIPROTO_FLAG_NO_MP))
 894                mod_timer(&wdata->timer, jiffies + HZ * 4);
 895        spin_unlock_irq(&wdata->state.lock);
 896}
 897
 898/*
 899 * MP hotplug events are not generated by the wiimote. Therefore, we need
 900 * polling to detect it. We use a 4s interval for polling MP registers. This
 901 * seems reasonable considering applications can trigger it manually via
 902 * sysfs requests.
 903 */
 904static void wiimote_init_poll_mp(struct wiimote_data *wdata)
 905{
 906        bool mp;
 907        __u8 mpdata[6];
 908
 909        wiimote_cmd_acquire_noint(wdata);
 910        wiimote_cmd_init_mp(wdata);
 911        mp = wiimote_cmd_read_mp(wdata, mpdata);
 912        wiimote_cmd_release(wdata);
 913
 914        /* load/unload MP module if it changed */
 915        if (mp) {
 916                if (!wdata->state.mp) {
 917                        hid_info(wdata->hdev, "detected extension: Nintendo Wii Motion Plus\n");
 918                        wiimote_mp_load(wdata);
 919                }
 920        } else if (wdata->state.mp) {
 921                wiimote_mp_unload(wdata);
 922        }
 923
 924        mod_timer(&wdata->timer, jiffies + HZ * 4);
 925}
 926
 927/*
 928 * Check whether the wiimote is in the expected state. The extension registers
 929 * may change during hotplug and initialization so we might get hotplug events
 930 * that we caused by remapping some memory.
 931 * We use some heuristics here to check known states. If the wiimote is in the
 932 * expected state, we can ignore the hotplug event.
 933 *
 934 * Returns "true" if the device is in expected state, "false" if we should
 935 * redo hotplug handling and extension initialization.
 936 */
 937static bool wiimote_init_check(struct wiimote_data *wdata)
 938{
 939        __u32 flags;
 940        __u8 type, data[6];
 941        bool ret, poll_mp;
 942
 943        spin_lock_irq(&wdata->state.lock);
 944        flags = wdata->state.flags;
 945        spin_unlock_irq(&wdata->state.lock);
 946
 947        wiimote_cmd_acquire_noint(wdata);
 948
 949        /* If MP is used and active, but the extension is not, we expect:
 950         *   read_mp_mapped() == WIIMOTE_MP_SINGLE
 951         *   state.flags == !EXT_ACTIVE && !MP_PLUGGED && MP_ACTIVE
 952         * We do not check EXT_PLUGGED because it might change during
 953         * initialization of MP without extensions.
 954         *  - If MP is unplugged/replugged, read_mp_mapped() fails
 955         *  - If EXT is plugged, MP_PLUGGED will get set */
 956        if (wdata->state.exttype == WIIMOTE_EXT_NONE &&
 957            wdata->state.mp > 0 && (flags & WIIPROTO_FLAG_MP_USED)) {
 958                type = wiimote_cmd_read_mp_mapped(wdata);
 959                ret = type == WIIMOTE_MP_SINGLE;
 960
 961                spin_lock_irq(&wdata->state.lock);
 962                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
 963                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED);
 964                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
 965                spin_unlock_irq(&wdata->state.lock);
 966
 967                if (!ret)
 968                        hid_dbg(wdata->hdev, "state left: !EXT && MP\n");
 969
 970                /* while MP is mapped, we get EXT_PLUGGED events */
 971                poll_mp = false;
 972
 973                goto out_release;
 974        }
 975
 976        /* If MP is unused, but the extension port is used, we expect:
 977         *   read_ext == state.exttype
 978         *   state.flags == !MP_ACTIVE && EXT_ACTIVE
 979         * - If MP is plugged/unplugged, our timer detects it
 980         * - If EXT is unplugged/replugged, EXT_ACTIVE will become unset */
 981        if (!(flags & WIIPROTO_FLAG_MP_USED) &&
 982            wdata->state.exttype != WIIMOTE_EXT_NONE) {
 983                type = wiimote_cmd_read_ext(wdata, data);
 984                ret = type == wdata->state.exttype;
 985
 986                spin_lock_irq(&wdata->state.lock);
 987                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
 988                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
 989                spin_unlock_irq(&wdata->state.lock);
 990
 991                if (!ret)
 992                        hid_dbg(wdata->hdev, "state left: EXT && !MP\n");
 993
 994                /* poll MP for hotplug events */
 995                poll_mp = true;
 996
 997                goto out_release;
 998        }
 999
1000        /* If neither MP nor an extension are used, we expect:
1001         *   read_ext() == WIIMOTE_EXT_NONE
1002         *   state.flags == !MP_ACTIVE && !EXT_ACTIVE && !EXT_PLUGGED
1003         * No need to perform any action in this case as everything is
1004         * disabled already.
1005         * - If MP is plugged/unplugged, our timer detects it
1006         * - If EXT is plugged, EXT_PLUGGED will be set */
1007        if (!(flags & WIIPROTO_FLAG_MP_USED) &&
1008            wdata->state.exttype == WIIMOTE_EXT_NONE) {
1009                type = wiimote_cmd_read_ext(wdata, data);
1010                ret = type == wdata->state.exttype;
1011
1012                spin_lock_irq(&wdata->state.lock);
1013                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
1014                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
1015                ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED);
1016                spin_unlock_irq(&wdata->state.lock);
1017
1018                if (!ret)
1019                        hid_dbg(wdata->hdev, "state left: !EXT && !MP\n");
1020
1021                /* poll MP for hotplug events */
1022                poll_mp = true;
1023
1024                goto out_release;
1025        }
1026
1027        /* The trickiest part is if both EXT and MP are active. We cannot read
1028         * the EXT ID, anymore, because MP is mapped over it. However, we use
1029         * a handy trick here:
1030         *   - EXT_ACTIVE is unset whenever !MP_PLUGGED is sent
1031         * MP_PLUGGED might be re-sent again before we are scheduled, but
1032         * EXT_ACTIVE will stay unset.
1033         * So it is enough to check for mp_mapped() and MP_ACTIVE and
1034         * EXT_ACTIVE. EXT_PLUGGED is a sanity check. */
1035        if (wdata->state.exttype != WIIMOTE_EXT_NONE &&
1036            wdata->state.mp > 0 && (flags & WIIPROTO_FLAG_MP_USED)) {
1037                type = wiimote_cmd_read_mp_mapped(wdata);
1038                ret = type != WIIMOTE_MP_NONE;
1039                ret = ret && type != WIIMOTE_MP_UNKNOWN;
1040                ret = ret && type != WIIMOTE_MP_SINGLE;
1041
1042                spin_lock_irq(&wdata->state.lock);
1043                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED);
1044                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
1045                ret = ret && (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
1046                spin_unlock_irq(&wdata->state.lock);
1047
1048                if (!ret)
1049                        hid_dbg(wdata->hdev, "state left: EXT && MP\n");
1050
1051                /* while MP is mapped, we get EXT_PLUGGED events */
1052                poll_mp = false;
1053
1054                goto out_release;
1055        }
1056
1057        /* unknown state */
1058        ret = false;
1059
1060out_release:
1061        wiimote_cmd_release(wdata);
1062
1063        /* only poll for MP if requested and if state didn't change */
1064        if (ret && poll_mp && !(flags & WIIPROTO_FLAG_BUILTIN_MP) &&
1065            !(flags & WIIPROTO_FLAG_NO_MP))
1066                wiimote_init_poll_mp(wdata);
1067
1068        return ret;
1069}
1070
1071static const char *wiimote_exttype_names[WIIMOTE_EXT_NUM] = {
1072        [WIIMOTE_EXT_NONE] = "None",
1073        [WIIMOTE_EXT_UNKNOWN] = "Unknown",
1074        [WIIMOTE_EXT_NUNCHUK] = "Nintendo Wii Nunchuk",
1075        [WIIMOTE_EXT_CLASSIC_CONTROLLER] = "Nintendo Wii Classic Controller",
1076        [WIIMOTE_EXT_BALANCE_BOARD] = "Nintendo Wii Balance Board",
1077        [WIIMOTE_EXT_PRO_CONTROLLER] = "Nintendo Wii U Pro Controller",
1078};
1079
1080/*
1081 * Handle hotplug events
1082 * If we receive an hotplug event and the device-check failed, we deinitialize
1083 * the extension ports, re-read all extension IDs and set the device into
1084 * the desired state. This involves mapping MP into the main extension
1085 * registers, setting up extension passthrough modes and initializing the
1086 * requested extensions.
1087 */
1088static void wiimote_init_hotplug(struct wiimote_data *wdata)
1089{
1090        __u8 exttype, extdata[6], mpdata[6];
1091        __u32 flags;
1092        bool mp;
1093
1094        hid_dbg(wdata->hdev, "detect extensions..\n");
1095
1096        wiimote_cmd_acquire_noint(wdata);
1097
1098        spin_lock_irq(&wdata->state.lock);
1099
1100        /* get state snapshot that we will then work on */
1101        flags = wdata->state.flags;
1102
1103        /* disable event forwarding temporarily */
1104        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE;
1105        wdata->state.flags &= ~WIIPROTO_FLAG_MP_ACTIVE;
1106
1107        spin_unlock_irq(&wdata->state.lock);
1108
1109        /* init extension and MP (deactivates current extension or MP) */
1110        wiimote_cmd_init_ext(wdata);
1111        if (flags & WIIPROTO_FLAG_NO_MP) {
1112                mp = false;
1113        } else {
1114                wiimote_cmd_init_mp(wdata);
1115                mp = wiimote_cmd_read_mp(wdata, mpdata);
1116        }
1117        exttype = wiimote_cmd_read_ext(wdata, extdata);
1118
1119        wiimote_cmd_release(wdata);
1120
1121        /* load/unload extension module if it changed */
1122        if (exttype != wdata->state.exttype) {
1123                /* unload previous extension */
1124                wiimote_ext_unload(wdata);
1125
1126                if (exttype == WIIMOTE_EXT_UNKNOWN) {
1127                        hid_info(wdata->hdev, "cannot detect extension; %6phC\n",
1128                                 extdata);
1129                } else if (exttype == WIIMOTE_EXT_NONE) {
1130                        spin_lock_irq(&wdata->state.lock);
1131                        wdata->state.exttype = WIIMOTE_EXT_NONE;
1132                        spin_unlock_irq(&wdata->state.lock);
1133                } else {
1134                        hid_info(wdata->hdev, "detected extension: %s\n",
1135                                 wiimote_exttype_names[exttype]);
1136                        /* try loading new extension */
1137                        wiimote_ext_load(wdata, exttype);
1138                }
1139        }
1140
1141        /* load/unload MP module if it changed */
1142        if (mp) {
1143                if (!wdata->state.mp) {
1144                        hid_info(wdata->hdev, "detected extension: Nintendo Wii Motion Plus\n");
1145                        wiimote_mp_load(wdata);
1146                }
1147        } else if (wdata->state.mp) {
1148                wiimote_mp_unload(wdata);
1149        }
1150
1151        /* if MP is not used, do not map or activate it */
1152        if (!(flags & WIIPROTO_FLAG_MP_USED))
1153                mp = false;
1154
1155        /* map MP into main extension registers if used */
1156        if (mp) {
1157                wiimote_cmd_acquire_noint(wdata);
1158                wiimote_cmd_map_mp(wdata, exttype);
1159                wiimote_cmd_release(wdata);
1160
1161                /* delete MP hotplug timer */
1162                del_timer_sync(&wdata->timer);
1163        } else {
1164                /* reschedule MP hotplug timer */
1165                if (!(flags & WIIPROTO_FLAG_BUILTIN_MP) &&
1166                    !(flags & WIIPROTO_FLAG_NO_MP))
1167                        mod_timer(&wdata->timer, jiffies + HZ * 4);
1168        }
1169
1170        spin_lock_irq(&wdata->state.lock);
1171
1172        /* enable data forwarding again and set expected hotplug state */
1173        if (mp) {
1174                wdata->state.flags |= WIIPROTO_FLAG_MP_ACTIVE;
1175                if (wdata->state.exttype == WIIMOTE_EXT_NONE) {
1176                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
1177                        wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED;
1178                } else {
1179                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
1180                        wdata->state.flags |= WIIPROTO_FLAG_MP_PLUGGED;
1181                        wdata->state.flags |= WIIPROTO_FLAG_EXT_ACTIVE;
1182                }
1183        } else if (wdata->state.exttype != WIIMOTE_EXT_NONE) {
1184                wdata->state.flags |= WIIPROTO_FLAG_EXT_ACTIVE;
1185        }
1186
1187        /* request status report for hotplug state updates */
1188        wiiproto_req_status(wdata);
1189
1190        spin_unlock_irq(&wdata->state.lock);
1191
1192        hid_dbg(wdata->hdev, "detected extensions: MP: %d EXT: %d\n",
1193                wdata->state.mp, wdata->state.exttype);
1194}
1195
1196static void wiimote_init_worker(struct work_struct *work)
1197{
1198        struct wiimote_data *wdata = container_of(work, struct wiimote_data,
1199                                                  init_worker);
1200        bool changed = false;
1201
1202        if (wdata->state.devtype == WIIMOTE_DEV_PENDING) {
1203                wiimote_init_detect(wdata);
1204                changed = true;
1205        }
1206
1207        if (changed || !wiimote_init_check(wdata))
1208                wiimote_init_hotplug(wdata);
1209
1210        if (changed)
1211                kobject_uevent(&wdata->hdev->dev.kobj, KOBJ_CHANGE);
1212}
1213
1214void __wiimote_schedule(struct wiimote_data *wdata)
1215{
1216        if (!(wdata->state.flags & WIIPROTO_FLAG_EXITING))
1217                schedule_work(&wdata->init_worker);
1218}
1219
1220static void wiimote_schedule(struct wiimote_data *wdata)
1221{
1222        unsigned long flags;
1223
1224        spin_lock_irqsave(&wdata->state.lock, flags);
1225        __wiimote_schedule(wdata);
1226        spin_unlock_irqrestore(&wdata->state.lock, flags);
1227}
1228
1229static void wiimote_init_timeout(unsigned long arg)
1230{
1231        struct wiimote_data *wdata = (void*)arg;
1232
1233        wiimote_schedule(wdata);
1234}
1235
1236/* protocol handlers */
1237
1238static void handler_keys(struct wiimote_data *wdata, const __u8 *payload)
1239{
1240        const __u8 *iter, *mods;
1241        const struct wiimod_ops *ops;
1242
1243        ops = wiimod_ext_table[wdata->state.exttype];
1244        if (ops->in_keys) {
1245                ops->in_keys(wdata, payload);
1246                return;
1247        }
1248
1249        mods = wiimote_devtype_mods[wdata->state.devtype];
1250        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
1251                ops = wiimod_table[*iter];
1252                if (ops->in_keys) {
1253                        ops->in_keys(wdata, payload);
1254                        break;
1255                }
1256        }
1257}
1258
1259static void handler_accel(struct wiimote_data *wdata, const __u8 *payload)
1260{
1261        const __u8 *iter, *mods;
1262        const struct wiimod_ops *ops;
1263
1264        ops = wiimod_ext_table[wdata->state.exttype];
1265        if (ops->in_accel) {
1266                ops->in_accel(wdata, payload);
1267                return;
1268        }
1269
1270        mods = wiimote_devtype_mods[wdata->state.devtype];
1271        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
1272                ops = wiimod_table[*iter];
1273                if (ops->in_accel) {
1274                        ops->in_accel(wdata, payload);
1275                        break;
1276                }
1277        }
1278}
1279
1280static bool valid_ext_handler(const struct wiimod_ops *ops, size_t len)
1281{
1282        if (!ops->in_ext)
1283                return false;
1284        if ((ops->flags & WIIMOD_FLAG_EXT8) && len < 8)
1285                return false;
1286        if ((ops->flags & WIIMOD_FLAG_EXT16) && len < 16)
1287                return false;
1288
1289        return true;
1290}
1291
1292static void handler_ext(struct wiimote_data *wdata, const __u8 *payload,
1293                        size_t len)
1294{
1295        static const __u8 invalid[21] = { 0xff, 0xff, 0xff, 0xff,
1296                                          0xff, 0xff, 0xff, 0xff,
1297                                          0xff, 0xff, 0xff, 0xff,
1298                                          0xff, 0xff, 0xff, 0xff,
1299                                          0xff, 0xff, 0xff, 0xff,
1300                                          0xff };
1301        const __u8 *iter, *mods;
1302        const struct wiimod_ops *ops;
1303        bool is_mp;
1304
1305        if (len > 21)
1306                len = 21;
1307        if (len < 6 || !memcmp(payload, invalid, len))
1308                return;
1309
1310        /* if MP is active, track MP slot hotplugging */
1311        if (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE) {
1312                /* this bit is set for invalid events (eg. during hotplug) */
1313                if (payload[5] & 0x01)
1314                        return;
1315
1316                if (payload[4] & 0x01) {
1317                        if (!(wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED)) {
1318                                hid_dbg(wdata->hdev, "MP hotplug: 1\n");
1319                                wdata->state.flags |= WIIPROTO_FLAG_MP_PLUGGED;
1320                                __wiimote_schedule(wdata);
1321                        }
1322                } else {
1323                        if (wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED) {
1324                                hid_dbg(wdata->hdev, "MP hotplug: 0\n");
1325                                wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED;
1326                                wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE;
1327                                __wiimote_schedule(wdata);
1328                        }
1329                }
1330
1331                /* detect MP data that is sent interleaved with EXT data */
1332                is_mp = payload[5] & 0x02;
1333        } else {
1334                is_mp = false;
1335        }
1336
1337        /* ignore EXT events if no extension is active */
1338        if (!(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE) && !is_mp)
1339                return;
1340
1341        /* try forwarding to extension handler, first */
1342        ops = wiimod_ext_table[wdata->state.exttype];
1343        if (is_mp && ops->in_mp) {
1344                ops->in_mp(wdata, payload);
1345                return;
1346        } else if (!is_mp && valid_ext_handler(ops, len)) {
1347                ops->in_ext(wdata, payload);
1348                return;
1349        }
1350
1351        /* try forwarding to MP handler */
1352        ops = &wiimod_mp;
1353        if (is_mp && ops->in_mp) {
1354                ops->in_mp(wdata, payload);
1355                return;
1356        } else if (!is_mp && valid_ext_handler(ops, len)) {
1357                ops->in_ext(wdata, payload);
1358                return;
1359        }
1360
1361        /* try forwarding to loaded modules */
1362        mods = wiimote_devtype_mods[wdata->state.devtype];
1363        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
1364                ops = wiimod_table[*iter];
1365                if (is_mp && ops->in_mp) {
1366                        ops->in_mp(wdata, payload);
1367                        return;
1368                } else if (!is_mp && valid_ext_handler(ops, len)) {
1369                        ops->in_ext(wdata, payload);
1370                        return;
1371                }
1372        }
1373}
1374
1375#define ir_to_input0(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 0)
1376#define ir_to_input1(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 1)
1377#define ir_to_input2(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 2)
1378#define ir_to_input3(wdata, ir, packed) handler_ir((wdata), (ir), (packed), 3)
1379
1380static void handler_ir(struct wiimote_data *wdata, const __u8 *payload,
1381                       bool packed, unsigned int id)
1382{
1383        const __u8 *iter, *mods;
1384        const struct wiimod_ops *ops;
1385
1386        ops = wiimod_ext_table[wdata->state.exttype];
1387        if (ops->in_ir) {
1388                ops->in_ir(wdata, payload, packed, id);
1389                return;
1390        }
1391
1392        mods = wiimote_devtype_mods[wdata->state.devtype];
1393        for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
1394                ops = wiimod_table[*iter];
1395                if (ops->in_ir) {
1396                        ops->in_ir(wdata, payload, packed, id);
1397                        break;
1398                }
1399        }
1400}
1401
1402/* reduced status report with "BB BB" key data only */
1403static void handler_status_K(struct wiimote_data *wdata,
1404                             const __u8 *payload)
1405{
1406        handler_keys(wdata, payload);
1407
1408        /* on status reports the drm is reset so we need to resend the drm */
1409        wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
1410}
1411
1412/* extended status report with "BB BB LF 00 00 VV" data */
1413static void handler_status(struct wiimote_data *wdata, const __u8 *payload)
1414{
1415        handler_status_K(wdata, payload);
1416
1417        /* update extension status */
1418        if (payload[2] & 0x02) {
1419                if (!(wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED)) {
1420                        hid_dbg(wdata->hdev, "EXT hotplug: 1\n");
1421                        wdata->state.flags |= WIIPROTO_FLAG_EXT_PLUGGED;
1422                        __wiimote_schedule(wdata);
1423                }
1424        } else {
1425                if (wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED) {
1426                        hid_dbg(wdata->hdev, "EXT hotplug: 0\n");
1427                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_PLUGGED;
1428                        wdata->state.flags &= ~WIIPROTO_FLAG_MP_PLUGGED;
1429                        wdata->state.flags &= ~WIIPROTO_FLAG_EXT_ACTIVE;
1430                        wdata->state.flags &= ~WIIPROTO_FLAG_MP_ACTIVE;
1431                        __wiimote_schedule(wdata);
1432                }
1433        }
1434
1435        wdata->state.cmd_battery = payload[5];
1436        if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_SREQ, 0))
1437                wiimote_cmd_complete(wdata);
1438}
1439
1440/* reduced generic report with "BB BB" key data only */
1441static void handler_generic_K(struct wiimote_data *wdata, const __u8 *payload)
1442{
1443        handler_keys(wdata, payload);
1444}
1445
1446static void handler_data(struct wiimote_data *wdata, const __u8 *payload)
1447{
1448        __u16 offset = payload[3] << 8 | payload[4];
1449        __u8 size = (payload[2] >> 4) + 1;
1450        __u8 err = payload[2] & 0x0f;
1451
1452        handler_keys(wdata, payload);
1453
1454        if (wiimote_cmd_pending(wdata, WIIPROTO_REQ_RMEM, offset)) {
1455                if (err)
1456                        size = 0;
1457                else if (size > wdata->state.cmd_read_size)
1458                        size = wdata->state.cmd_read_size;
1459
1460                wdata->state.cmd_read_size = size;
1461                if (wdata->state.cmd_read_buf)
1462                        memcpy(wdata->state.cmd_read_buf, &payload[5], size);
1463                wiimote_cmd_complete(wdata);
1464        }
1465}
1466
1467static void handler_return(struct wiimote_data *wdata, const __u8 *payload)
1468{
1469        __u8 err = payload[3];
1470        __u8 cmd = payload[2];
1471
1472        handler_keys(wdata, payload);
1473
1474        if (wiimote_cmd_pending(wdata, cmd, 0)) {
1475                wdata->state.cmd_err = err;
1476                wiimote_cmd_complete(wdata);
1477        } else if (err) {
1478                hid_warn(wdata->hdev, "Remote error %hhu on req %hhu\n", err,
1479                                                                        cmd);
1480        }
1481}
1482
1483static void handler_drm_KA(struct wiimote_data *wdata, const __u8 *payload)
1484{
1485        handler_keys(wdata, payload);
1486        handler_accel(wdata, payload);
1487}
1488
1489static void handler_drm_KE(struct wiimote_data *wdata, const __u8 *payload)
1490{
1491        handler_keys(wdata, payload);
1492        handler_ext(wdata, &payload[2], 8);
1493}
1494
1495static void handler_drm_KAI(struct wiimote_data *wdata, const __u8 *payload)
1496{
1497        handler_keys(wdata, payload);
1498        handler_accel(wdata, payload);
1499        ir_to_input0(wdata, &payload[5], false);
1500        ir_to_input1(wdata, &payload[8], false);
1501        ir_to_input2(wdata, &payload[11], false);
1502        ir_to_input3(wdata, &payload[14], false);
1503}
1504
1505static void handler_drm_KEE(struct wiimote_data *wdata, const __u8 *payload)
1506{
1507        handler_keys(wdata, payload);
1508        handler_ext(wdata, &payload[2], 19);
1509}
1510
1511static void handler_drm_KIE(struct wiimote_data *wdata, const __u8 *payload)
1512{
1513        handler_keys(wdata, payload);
1514        ir_to_input0(wdata, &payload[2], false);
1515        ir_to_input1(wdata, &payload[4], true);
1516        ir_to_input2(wdata, &payload[7], false);
1517        ir_to_input3(wdata, &payload[9], true);
1518        handler_ext(wdata, &payload[12], 9);
1519}
1520
1521static void handler_drm_KAE(struct wiimote_data *wdata, const __u8 *payload)
1522{
1523        handler_keys(wdata, payload);
1524        handler_accel(wdata, payload);
1525        handler_ext(wdata, &payload[5], 16);
1526}
1527
1528static void handler_drm_KAIE(struct wiimote_data *wdata, const __u8 *payload)
1529{
1530        handler_keys(wdata, payload);
1531        handler_accel(wdata, payload);
1532        ir_to_input0(wdata, &payload[5], false);
1533        ir_to_input1(wdata, &payload[7], true);
1534        ir_to_input2(wdata, &payload[10], false);
1535        ir_to_input3(wdata, &payload[12], true);
1536        handler_ext(wdata, &payload[15], 6);
1537}
1538
1539static void handler_drm_E(struct wiimote_data *wdata, const __u8 *payload)
1540{
1541        handler_ext(wdata, payload, 21);
1542}
1543
1544static void handler_drm_SKAI1(struct wiimote_data *wdata, const __u8 *payload)
1545{
1546        handler_keys(wdata, payload);
1547
1548        wdata->state.accel_split[0] = payload[2];
1549        wdata->state.accel_split[1] = (payload[0] >> 1) & (0x10 | 0x20);
1550        wdata->state.accel_split[1] |= (payload[1] << 1) & (0x40 | 0x80);
1551
1552        ir_to_input0(wdata, &payload[3], false);
1553        ir_to_input1(wdata, &payload[12], false);
1554}
1555
1556static void handler_drm_SKAI2(struct wiimote_data *wdata, const __u8 *payload)
1557{
1558        __u8 buf[5];
1559
1560        handler_keys(wdata, payload);
1561
1562        wdata->state.accel_split[1] |= (payload[0] >> 5) & (0x01 | 0x02);
1563        wdata->state.accel_split[1] |= (payload[1] >> 3) & (0x04 | 0x08);
1564
1565        buf[0] = 0;
1566        buf[1] = 0;
1567        buf[2] = wdata->state.accel_split[0];
1568        buf[3] = payload[2];
1569        buf[4] = wdata->state.accel_split[1];
1570        handler_accel(wdata, buf);
1571
1572        ir_to_input2(wdata, &payload[3], false);
1573        ir_to_input3(wdata, &payload[12], false);
1574}
1575
1576struct wiiproto_handler {
1577        __u8 id;
1578        size_t size;
1579        void (*func)(struct wiimote_data *wdata, const __u8 *payload);
1580};
1581
1582static struct wiiproto_handler handlers[] = {
1583        { .id = WIIPROTO_REQ_STATUS, .size = 6, .func = handler_status },
1584        { .id = WIIPROTO_REQ_STATUS, .size = 2, .func = handler_status_K },
1585        { .id = WIIPROTO_REQ_DATA, .size = 21, .func = handler_data },
1586        { .id = WIIPROTO_REQ_DATA, .size = 2, .func = handler_generic_K },
1587        { .id = WIIPROTO_REQ_RETURN, .size = 4, .func = handler_return },
1588        { .id = WIIPROTO_REQ_RETURN, .size = 2, .func = handler_generic_K },
1589        { .id = WIIPROTO_REQ_DRM_K, .size = 2, .func = handler_keys },
1590        { .id = WIIPROTO_REQ_DRM_KA, .size = 5, .func = handler_drm_KA },
1591        { .id = WIIPROTO_REQ_DRM_KA, .size = 2, .func = handler_generic_K },
1592        { .id = WIIPROTO_REQ_DRM_KE, .size = 10, .func = handler_drm_KE },
1593        { .id = WIIPROTO_REQ_DRM_KE, .size = 2, .func = handler_generic_K },
1594        { .id = WIIPROTO_REQ_DRM_KAI, .size = 17, .func = handler_drm_KAI },
1595        { .id = WIIPROTO_REQ_DRM_KAI, .size = 2, .func = handler_generic_K },
1596        { .id = WIIPROTO_REQ_DRM_KEE, .size = 21, .func = handler_drm_KEE },
1597        { .id = WIIPROTO_REQ_DRM_KEE, .size = 2, .func = handler_generic_K },
1598        { .id = WIIPROTO_REQ_DRM_KAE, .size = 21, .func = handler_drm_KAE },
1599        { .id = WIIPROTO_REQ_DRM_KAE, .size = 2, .func = handler_generic_K },
1600        { .id = WIIPROTO_REQ_DRM_KIE, .size = 21, .func = handler_drm_KIE },
1601        { .id = WIIPROTO_REQ_DRM_KIE, .size = 2, .func = handler_generic_K },
1602        { .id = WIIPROTO_REQ_DRM_KAIE, .size = 21, .func = handler_drm_KAIE },
1603        { .id = WIIPROTO_REQ_DRM_KAIE, .size = 2, .func = handler_generic_K },
1604        { .id = WIIPROTO_REQ_DRM_E, .size = 21, .func = handler_drm_E },
1605        { .id = WIIPROTO_REQ_DRM_SKAI1, .size = 21, .func = handler_drm_SKAI1 },
1606        { .id = WIIPROTO_REQ_DRM_SKAI2, .size = 21, .func = handler_drm_SKAI2 },
1607        { .id = 0 }
1608};
1609
1610static int wiimote_hid_event(struct hid_device *hdev, struct hid_report *report,
1611                                                        u8 *raw_data, int size)
1612{
1613        struct wiimote_data *wdata = hid_get_drvdata(hdev);
1614        struct wiiproto_handler *h;
1615        int i;
1616        unsigned long flags;
1617
1618        if (size < 1)
1619                return -EINVAL;
1620
1621        spin_lock_irqsave(&wdata->state.lock, flags);
1622
1623        for (i = 0; handlers[i].id; ++i) {
1624                h = &handlers[i];
1625                if (h->id == raw_data[0] && h->size < size) {
1626                        h->func(wdata, &raw_data[1]);
1627                        break;
1628                }
1629        }
1630
1631        if (!handlers[i].id)
1632                hid_warn(hdev, "Unhandled report %hhu size %d\n", raw_data[0],
1633                                                                        size);
1634
1635        spin_unlock_irqrestore(&wdata->state.lock, flags);
1636
1637        return 0;
1638}
1639
1640static ssize_t wiimote_ext_show(struct device *dev,
1641                                struct device_attribute *attr,
1642                                char *buf)
1643{
1644        struct wiimote_data *wdata = dev_to_wii(dev);
1645        __u8 type;
1646        unsigned long flags;
1647
1648        spin_lock_irqsave(&wdata->state.lock, flags);
1649        type = wdata->state.exttype;
1650        spin_unlock_irqrestore(&wdata->state.lock, flags);
1651
1652        switch (type) {
1653        case WIIMOTE_EXT_NONE:
1654                return sprintf(buf, "none\n");
1655        case WIIMOTE_EXT_NUNCHUK:
1656                return sprintf(buf, "nunchuk\n");
1657        case WIIMOTE_EXT_CLASSIC_CONTROLLER:
1658                return sprintf(buf, "classic\n");
1659        case WIIMOTE_EXT_BALANCE_BOARD:
1660                return sprintf(buf, "balanceboard\n");
1661        case WIIMOTE_EXT_PRO_CONTROLLER:
1662                return sprintf(buf, "procontroller\n");
1663        case WIIMOTE_EXT_UNKNOWN:
1664                /* fallthrough */
1665        default:
1666                return sprintf(buf, "unknown\n");
1667        }
1668}
1669
1670static ssize_t wiimote_ext_store(struct device *dev,
1671                                 struct device_attribute *attr,
1672                                 const char *buf, size_t count)
1673{
1674        struct wiimote_data *wdata = dev_to_wii(dev);
1675
1676        if (!strcmp(buf, "scan")) {
1677                wiimote_schedule(wdata);
1678        } else {
1679                return -EINVAL;
1680        }
1681
1682        return strnlen(buf, PAGE_SIZE);
1683}
1684
1685static DEVICE_ATTR(extension, S_IRUGO | S_IWUSR | S_IWGRP, wiimote_ext_show,
1686                   wiimote_ext_store);
1687
1688static ssize_t wiimote_dev_show(struct device *dev,
1689                                struct device_attribute *attr,
1690                                char *buf)
1691{
1692        struct wiimote_data *wdata = dev_to_wii(dev);
1693        __u8 type;
1694        unsigned long flags;
1695
1696        spin_lock_irqsave(&wdata->state.lock, flags);
1697        type = wdata->state.devtype;
1698        spin_unlock_irqrestore(&wdata->state.lock, flags);
1699
1700        switch (type) {
1701        case WIIMOTE_DEV_GENERIC:
1702                return sprintf(buf, "generic\n");
1703        case WIIMOTE_DEV_GEN10:
1704                return sprintf(buf, "gen10\n");
1705        case WIIMOTE_DEV_GEN20:
1706                return sprintf(buf, "gen20\n");
1707        case WIIMOTE_DEV_BALANCE_BOARD:
1708                return sprintf(buf, "balanceboard\n");
1709        case WIIMOTE_DEV_PRO_CONTROLLER:
1710                return sprintf(buf, "procontroller\n");
1711        case WIIMOTE_DEV_PENDING:
1712                return sprintf(buf, "pending\n");
1713        case WIIMOTE_DEV_UNKNOWN:
1714                /* fallthrough */
1715        default:
1716                return sprintf(buf, "unknown\n");
1717        }
1718}
1719
1720static DEVICE_ATTR(devtype, S_IRUGO, wiimote_dev_show, NULL);
1721
1722static struct wiimote_data *wiimote_create(struct hid_device *hdev)
1723{
1724        struct wiimote_data *wdata;
1725
1726        wdata = kzalloc(sizeof(*wdata), GFP_KERNEL);
1727        if (!wdata)
1728                return NULL;
1729
1730        wdata->hdev = hdev;
1731        hid_set_drvdata(hdev, wdata);
1732
1733        spin_lock_init(&wdata->queue.lock);
1734        INIT_WORK(&wdata->queue.worker, wiimote_queue_worker);
1735
1736        spin_lock_init(&wdata->state.lock);
1737        init_completion(&wdata->state.ready);
1738        mutex_init(&wdata->state.sync);
1739        wdata->state.drm = WIIPROTO_REQ_DRM_K;
1740        wdata->state.cmd_battery = 0xff;
1741
1742        INIT_WORK(&wdata->init_worker, wiimote_init_worker);
1743        setup_timer(&wdata->timer, wiimote_init_timeout, (long)wdata);
1744
1745        return wdata;
1746}
1747
1748static void wiimote_destroy(struct wiimote_data *wdata)
1749{
1750        unsigned long flags;
1751
1752        wiidebug_deinit(wdata);
1753
1754        /* prevent init_worker from being scheduled again */
1755        spin_lock_irqsave(&wdata->state.lock, flags);
1756        wdata->state.flags |= WIIPROTO_FLAG_EXITING;
1757        spin_unlock_irqrestore(&wdata->state.lock, flags);
1758
1759        cancel_work_sync(&wdata->init_worker);
1760        del_timer_sync(&wdata->timer);
1761
1762        device_remove_file(&wdata->hdev->dev, &dev_attr_devtype);
1763        device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
1764
1765        wiimote_mp_unload(wdata);
1766        wiimote_ext_unload(wdata);
1767        wiimote_modules_unload(wdata);
1768        cancel_work_sync(&wdata->queue.worker);
1769        hid_hw_close(wdata->hdev);
1770        hid_hw_stop(wdata->hdev);
1771
1772        kfree(wdata);
1773}
1774
1775static int wiimote_hid_probe(struct hid_device *hdev,
1776                                const struct hid_device_id *id)
1777{
1778        struct wiimote_data *wdata;
1779        int ret;
1780
1781        hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
1782
1783        wdata = wiimote_create(hdev);
1784        if (!wdata) {
1785                hid_err(hdev, "Can't alloc device\n");
1786                return -ENOMEM;
1787        }
1788
1789        ret = hid_parse(hdev);
1790        if (ret) {
1791                hid_err(hdev, "HID parse failed\n");
1792                goto err;
1793        }
1794
1795        ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW);
1796        if (ret) {
1797                hid_err(hdev, "HW start failed\n");
1798                goto err;
1799        }
1800
1801        ret = hid_hw_open(hdev);
1802        if (ret) {
1803                hid_err(hdev, "cannot start hardware I/O\n");
1804                goto err_stop;
1805        }
1806
1807        ret = device_create_file(&hdev->dev, &dev_attr_extension);
1808        if (ret) {
1809                hid_err(hdev, "cannot create sysfs attribute\n");
1810                goto err_close;
1811        }
1812
1813        ret = device_create_file(&hdev->dev, &dev_attr_devtype);
1814        if (ret) {
1815                hid_err(hdev, "cannot create sysfs attribute\n");
1816                goto err_ext;
1817        }
1818
1819        ret = wiidebug_init(wdata);
1820        if (ret)
1821                goto err_free;
1822
1823        hid_info(hdev, "New device registered\n");
1824
1825        /* schedule device detection */
1826        wiimote_schedule(wdata);
1827
1828        return 0;
1829
1830err_free:
1831        wiimote_destroy(wdata);
1832        return ret;
1833
1834err_ext:
1835        device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
1836err_close:
1837        hid_hw_close(hdev);
1838err_stop:
1839        hid_hw_stop(hdev);
1840err:
1841        input_free_device(wdata->ir);
1842        input_free_device(wdata->accel);
1843        kfree(wdata);
1844        return ret;
1845}
1846
1847static void wiimote_hid_remove(struct hid_device *hdev)
1848{
1849        struct wiimote_data *wdata = hid_get_drvdata(hdev);
1850
1851        hid_info(hdev, "Device removed\n");
1852        wiimote_destroy(wdata);
1853}
1854
1855static const struct hid_device_id wiimote_hid_devices[] = {
1856        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
1857                                USB_DEVICE_ID_NINTENDO_WIIMOTE) },
1858        { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_NINTENDO,
1859                                USB_DEVICE_ID_NINTENDO_WIIMOTE2) },
1860        { }
1861};
1862MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
1863
1864static struct hid_driver wiimote_hid_driver = {
1865        .name = "wiimote",
1866        .id_table = wiimote_hid_devices,
1867        .probe = wiimote_hid_probe,
1868        .remove = wiimote_hid_remove,
1869        .raw_event = wiimote_hid_event,
1870};
1871module_hid_driver(wiimote_hid_driver);
1872
1873MODULE_LICENSE("GPL");
1874MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
1875MODULE_DESCRIPTION("Driver for Nintendo Wii / Wii U peripherals");
1876
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.