Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * HID driver for Nintendo Wii / Wii U peripherals
0004  * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@gmail.com>
0005  */
0006 
0007 /*
0008  */
0009 
0010 #include <linux/completion.h>
0011 #include <linux/device.h>
0012 #include <linux/hid.h>
0013 #include <linux/input.h>
0014 #include <linux/module.h>
0015 #include <linux/mutex.h>
0016 #include <linux/spinlock.h>
0017 #include "hid-ids.h"
0018 #include "hid-wiimote.h"
0019 
0020 /* output queue handling */
0021 
0022 static int wiimote_hid_send(struct hid_device *hdev, __u8 *buffer,
0023                 size_t count)
0024 {
0025     __u8 *buf;
0026     int ret;
0027 
0028     if (!hdev->ll_driver->output_report)
0029         return -ENODEV;
0030 
0031     buf = kmemdup(buffer, count, GFP_KERNEL);
0032     if (!buf)
0033         return -ENOMEM;
0034 
0035     ret = hid_hw_output_report(hdev, buf, count);
0036 
0037     kfree(buf);
0038     return ret;
0039 }
0040 
0041 static void wiimote_queue_worker(struct work_struct *work)
0042 {
0043     struct wiimote_queue *queue = container_of(work, struct wiimote_queue,
0044                            worker);
0045     struct wiimote_data *wdata = container_of(queue, struct wiimote_data,
0046                           queue);
0047     unsigned long flags;
0048     int ret;
0049 
0050     spin_lock_irqsave(&wdata->queue.lock, flags);
0051 
0052     while (wdata->queue.head != wdata->queue.tail) {
0053         spin_unlock_irqrestore(&wdata->queue.lock, flags);
0054         ret = wiimote_hid_send(wdata->hdev,
0055                  wdata->queue.outq[wdata->queue.tail].data,
0056                  wdata->queue.outq[wdata->queue.tail].size);
0057         if (ret < 0) {
0058             spin_lock_irqsave(&wdata->state.lock, flags);
0059             wiimote_cmd_abort(wdata);
0060             spin_unlock_irqrestore(&wdata->state.lock, flags);
0061         }
0062         spin_lock_irqsave(&wdata->queue.lock, flags);
0063 
0064         wdata->queue.tail = (wdata->queue.tail + 1) % WIIMOTE_BUFSIZE;
0065     }
0066 
0067     spin_unlock_irqrestore(&wdata->queue.lock, flags);
0068 }
0069 
0070 static void wiimote_queue(struct wiimote_data *wdata, const __u8 *buffer,
0071                                 size_t count)
0072 {
0073     unsigned long flags;
0074     __u8 newhead;
0075 
0076     if (count > HID_MAX_BUFFER_SIZE) {
0077         hid_warn(wdata->hdev, "Sending too large output report\n");
0078 
0079         spin_lock_irqsave(&wdata->queue.lock, flags);
0080         goto out_error;
0081     }
0082 
0083     /*
0084      * Copy new request into our output queue and check whether the
0085      * queue is full. If it is full, discard this request.
0086      * If it is empty we need to start a new worker that will
0087      * send out the buffer to the hid device.
0088      * If the queue is not empty, then there must be a worker
0089      * that is currently sending out our buffer and this worker
0090      * will reschedule itself until the queue is empty.
0091      */
0092 
0093     spin_lock_irqsave(&wdata->queue.lock, flags);
0094 
0095     memcpy(wdata->queue.outq[wdata->queue.head].data, buffer, count);
0096     wdata->queue.outq[wdata->queue.head].size = count;
0097     newhead = (wdata->queue.head + 1) % WIIMOTE_BUFSIZE;
0098 
0099     if (wdata->queue.head == wdata->queue.tail) {
0100         wdata->queue.head = newhead;
0101         schedule_work(&wdata->queue.worker);
0102     } else if (newhead != wdata->queue.tail) {
0103         wdata->queue.head = newhead;
0104     } else {
0105         hid_warn(wdata->hdev, "Output queue is full");
0106         goto out_error;
0107     }
0108 
0109     goto out_unlock;
0110 
0111 out_error:
0112     wiimote_cmd_abort(wdata);
0113 out_unlock:
0114     spin_unlock_irqrestore(&wdata->queue.lock, flags);
0115 }
0116 
0117 /*
0118  * This sets the rumble bit on the given output report if rumble is
0119  * currently enabled.
0120  * \cmd1 must point to the second byte in the output report => &cmd[1]
0121  * This must be called on nearly every output report before passing it
0122  * into the output queue!
0123  */
0124 static inline void wiiproto_keep_rumble(struct wiimote_data *wdata, __u8 *cmd1)
0125 {
0126     if (wdata->state.flags & WIIPROTO_FLAG_RUMBLE)
0127         *cmd1 |= 0x01;
0128 }
0129 
0130 void wiiproto_req_rumble(struct wiimote_data *wdata, __u8 rumble)
0131 {
0132     __u8 cmd[2];
0133 
0134     rumble = !!rumble;
0135     if (rumble == !!(wdata->state.flags & WIIPROTO_FLAG_RUMBLE))
0136         return;
0137 
0138     if (rumble)
0139         wdata->state.flags |= WIIPROTO_FLAG_RUMBLE;
0140     else
0141         wdata->state.flags &= ~WIIPROTO_FLAG_RUMBLE;
0142 
0143     cmd[0] = WIIPROTO_REQ_RUMBLE;
0144     cmd[1] = 0;
0145 
0146     wiiproto_keep_rumble(wdata, &cmd[1]);
0147     wiimote_queue(wdata, cmd, sizeof(cmd));
0148 }
0149 
0150 void wiiproto_req_leds(struct wiimote_data *wdata, int leds)
0151 {
0152     __u8 cmd[2];
0153 
0154     leds &= WIIPROTO_FLAGS_LEDS;
0155     if ((wdata->state.flags & WIIPROTO_FLAGS_LEDS) == leds)
0156         return;
0157     wdata->state.flags = (wdata->state.flags & ~WIIPROTO_FLAGS_LEDS) | leds;
0158 
0159     cmd[0] = WIIPROTO_REQ_LED;
0160     cmd[1] = 0;
0161 
0162     if (leds & WIIPROTO_FLAG_LED1)
0163         cmd[1] |= 0x10;
0164     if (leds & WIIPROTO_FLAG_LED2)
0165         cmd[1] |= 0x20;
0166     if (leds & WIIPROTO_FLAG_LED3)
0167         cmd[1] |= 0x40;
0168     if (leds & WIIPROTO_FLAG_LED4)
0169         cmd[1] |= 0x80;
0170 
0171     wiiproto_keep_rumble(wdata, &cmd[1]);
0172     wiimote_queue(wdata, cmd, sizeof(cmd));
0173 }
0174 
0175 /*
0176  * Check what peripherals of the wiimote are currently
0177  * active and select a proper DRM that supports all of
0178  * the requested data inputs.
0179  *
0180  * Not all combinations are actually supported. The following
0181  * combinations work only with limitations:
0182  *  - IR cam in extended or full mode disables any data transmission
0183  *    of extension controllers. There is no DRM mode that supports
0184  *    extension bytes plus extended/full IR.
0185  *  - IR cam with accelerometer and extension *_EXT8 is not supported.
0186  *    However, all extensions that need *_EXT8 are devices that don't
0187  *    support IR cameras. Hence, this shouldn't happen under normal
0188  *    operation.
0189  *  - *_EXT16 is only supported in combination with buttons and
0190  *    accelerometer. No IR or similar can be active simultaneously. As
0191  *    above, all modules that require it are mutually exclusive with
0192  *    IR/etc. so this doesn't matter.
0193  */
0194 static __u8 select_drm(struct wiimote_data *wdata)
0195 {
0196     __u8 ir = wdata->state.flags & WIIPROTO_FLAGS_IR;
0197     bool ext;
0198 
0199     ext = (wdata->state.flags & WIIPROTO_FLAG_EXT_USED) ||
0200           (wdata->state.flags & WIIPROTO_FLAG_MP_USED);
0201 
0202     /* some 3rd-party balance-boards are hard-coded to KEE, *sigh* */
0203     if (wdata->state.devtype == WIIMOTE_DEV_BALANCE_BOARD) {
0204         if (ext)
0205             return WIIPROTO_REQ_DRM_KEE;
0206         else
0207             return WIIPROTO_REQ_DRM_K;
0208     }
0209 
0210     if (ir == WIIPROTO_FLAG_IR_BASIC) {
0211         if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) {
0212             /* GEN10 and ealier devices bind IR formats to DRMs.
0213              * Hence, we cannot use DRM_KAI here as it might be
0214              * bound to IR_EXT. Use DRM_KAIE unconditionally so we
0215              * work with all devices and our parsers can use the
0216              * fixed formats, too. */
0217             return WIIPROTO_REQ_DRM_KAIE;
0218         } else {
0219             return WIIPROTO_REQ_DRM_KIE;
0220         }
0221     } else if (ir == WIIPROTO_FLAG_IR_EXT) {
0222         return WIIPROTO_REQ_DRM_KAI;
0223     } else if (ir == WIIPROTO_FLAG_IR_FULL) {
0224         return WIIPROTO_REQ_DRM_SKAI1;
0225     } else {
0226         if (wdata->state.flags & WIIPROTO_FLAG_ACCEL) {
0227             if (ext)
0228                 return WIIPROTO_REQ_DRM_KAE;
0229             else
0230                 return WIIPROTO_REQ_DRM_KA;
0231         } else {
0232             if (ext)
0233                 return WIIPROTO_REQ_DRM_KEE;
0234             else
0235                 return WIIPROTO_REQ_DRM_K;
0236         }
0237     }
0238 }
0239 
0240 void wiiproto_req_drm(struct wiimote_data *wdata, __u8 drm)
0241 {
0242     __u8 cmd[3];
0243 
0244     if (wdata->state.flags & WIIPROTO_FLAG_DRM_LOCKED)
0245         drm = wdata->state.drm;
0246     else if (drm == WIIPROTO_REQ_NULL)
0247         drm = select_drm(wdata);
0248 
0249     cmd[0] = WIIPROTO_REQ_DRM;
0250     cmd[1] = 0;
0251     cmd[2] = drm;
0252 
0253     wdata->state.drm = drm;
0254     wiiproto_keep_rumble(wdata, &cmd[1]);
0255     wiimote_queue(wdata, cmd, sizeof(cmd));
0256 }
0257 
0258 void wiiproto_req_status(struct wiimote_data *wdata)
0259 {
0260     __u8 cmd[2];
0261 
0262     cmd[0] = WIIPROTO_REQ_SREQ;
0263     cmd[1] = 0;
0264 
0265     wiiproto_keep_rumble(wdata, &cmd[1]);
0266     wiimote_queue(wdata, cmd, sizeof(cmd));
0267 }
0268 
0269 void wiiproto_req_accel(struct wiimote_data *wdata, __u8 accel)
0270 {
0271     accel = !!accel;
0272     if (accel == !!(wdata->state.flags & WIIPROTO_FLAG_ACCEL))
0273         return;
0274 
0275     if (accel)
0276         wdata->state.flags |= WIIPROTO_FLAG_ACCEL;
0277     else
0278         wdata->state.flags &= ~WIIPROTO_FLAG_ACCEL;
0279 
0280     wiiproto_req_drm(wdata, WIIPROTO_REQ_NULL);
0281 }
0282 
0283 void wiiproto_req_ir1(struct wiimote_data *wdata, __u8 flags)
0284 {
0285     __u8 cmd[2];
0286 
0287     cmd[0] = WIIPROTO_REQ_IR1;
0288     cmd[1] = flags;
0289 
0290     wiiproto_keep_rumble(wdata, &cmd[1]);
0291     wiimote_queue(wdata, cmd, sizeof(cmd));
0292 }
0293 
0294 void wiiproto_req_ir2(struct wiimote_data *wdata, __u8 flags)
0295 {
0296     __u8 cmd[2];
0297 
0298     cmd[0] = WIIPROTO_REQ_IR2;
0299     cmd[1] = flags;
0300 
0301     wiiproto_keep_rumble(wdata, &cmd[1]);
0302     wiimote_queue(wdata, cmd, sizeof(cmd));
0303 }
0304 
0305 #define wiiproto_req_wreg(wdata, os, buf, sz) \
0306             wiiproto_req_wmem((wdata), false, (os), (buf), (sz))
0307 
0308 #define wiiproto_req_weeprom(wdata, os, buf, sz) \
0309             wiiproto_req_wmem((wdata), true, (os), (buf), (sz))
0310 
0311 static void wiiproto_req_wmem(struct wiimote_data *wdata, bool eeprom,
0312                 __u32 offset, const __u8 *buf, __u8 size)
0313 {
0314     __u8 cmd[22];
0315 
0316     if (size > 16 || size == 0) {
0317         hid_warn(wdata->hdev, "Invalid length %d wmem request\n", size);
0318         return;
0319     }
0320 
0321     memset(cmd, 0, sizeof(cmd));
0322     cmd[0] = WIIPROTO_REQ_WMEM;
0323     cmd[2] = (offset >> 16) & 0xff;
0324     cmd[3] = (offset >> 8) & 0xff;
0325     cmd[4] = offset & 0xff;
0326     cmd[5] = size;
0327     memcpy(&cmd[6], buf, size);
0328 
0329     if (!eeprom)
0330         cmd[1] |= 0x04;
0331 
0332     wiiproto_keep_rumble(wdata, &cmd[1]);
0333     wiimote_queue(wdata, cmd, sizeof(cmd));
0334 }
0335 
0336 void wiiproto_req_rmem(struct wiimote_data *wdata, bool eeprom, __u32 offset,
0337                                 __u16 size)
0338 {
0339     __u8 cmd[7];
0340 
0341     if (size == 0) {
0342         hid_warn(wdata->hdev, "Invalid length %d rmem request\n", size);
0343         return;
0344     }
0345 
0346     cmd[0] = WIIPROTO_REQ_RMEM;
0347     cmd[1] = 0;
0348     cmd[2] = (offset >> 16) & 0xff;
0349     cmd[3] = (offset >> 8) & 0xff;
0350     cmd[4] = offset & 0xff;
0351     cmd[5] = (size >> 8) & 0xff;
0352     cmd[6] = size & 0xff;
0353 
0354     if (!eeprom)
0355         cmd[1] |= 0x04;
0356 
0357     wiiproto_keep_rumble(wdata, &cmd[1]);
0358     wiimote_queue(wdata, cmd, sizeof(cmd));
0359 }
0360 
0361 /* requries the cmd-mutex to be held */
0362 int wiimote_cmd_write(struct wiimote_data *wdata, __u32 offset,
0363                         const __u8 *wmem, __u8 size)
0364 {
0365     unsigned long flags;
0366     int ret;
0367 
0368     spin_lock_irqsave(&wdata->state.lock, flags);
0369     wiimote_cmd_set(wdata, WIIPROTO_REQ_WMEM, 0);
0370     wiiproto_req_wreg(wdata, offset, wmem, size);
0371     spin_unlock_irqrestore(&wdata->state.lock, flags);
0372 
0373     ret = wiimote_cmd_wait(wdata);
0374     if (!ret && wdata->state.cmd_err)
0375         ret = -EIO;
0376 
0377     return ret;
0378 }
0379 
0380 /* requries the cmd-mutex to be held */
0381 ssize_t wiimote_cmd_read(struct wiimote_data *wdata, __u32 offset, __u8 *rmem,
0382                                 __u8 size)
0383 {
0384     unsigned long flags;
0385     ssize_t ret;
0386 
0387     spin_lock_irqsave(&wdata->state.lock, flags);
0388     wdata->state.cmd_read_size = size;
0389     wdata->state.cmd_read_buf = rmem;
0390     wiimote_cmd_set(wdata, WIIPROTO_REQ_RMEM, offset & 0xffff);
0391     wiiproto_req_rreg(wdata, offset, size);
0392     spin_unlock_irqrestore(&wdata->state.lock, flags);
0393 
0394     ret = wiimote_cmd_wait(wdata);
0395 
0396     spin_lock_irqsave(&wdata->state.lock, flags);
0397     wdata->state.cmd_read_buf = NULL;
0398     spin_unlock_irqrestore(&wdata->state.lock, flags);
0399 
0400     if (!ret) {
0401         if (wdata->state.cmd_read_size == 0)
0402             ret = -EIO;
0403         else
0404             ret = wdata->state.cmd_read_size;
0405     }
0406 
0407     return ret;
0408 }
0409 
0410 /* requires the cmd-mutex to be held */
0411 static int wiimote_cmd_init_ext(struct wiimote_data *wdata)
0412 {
0413     __u8 wmem;
0414     int ret;
0415 
0416     /* initialize extension */
0417     wmem = 0x55;
0418     ret = wiimote_cmd_write(wdata, 0xa400f0, &wmem, sizeof(wmem));
0419     if (ret)
0420         return ret;
0421 
0422     /* disable default encryption */
0423     wmem = 0x0;
0424     ret = wiimote_cmd_write(wdata, 0xa400fb, &wmem, sizeof(wmem));
0425     if (ret)
0426         return ret;
0427 
0428     return 0;
0429 }
0430 
0431 /* requires the cmd-mutex to be held */
0432 static __u8 wiimote_cmd_read_ext(struct wiimote_data *wdata, __u8 *rmem)
0433 {
0434     int ret;
0435 
0436     /* read extension ID */
0437     ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6);
0438     if (ret != 6)
0439         return WIIMOTE_EXT_NONE;
0440 
0441     hid_dbg(wdata->hdev, "extension ID: %6phC\n", rmem);
0442 
0443     if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff &&
0444         rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff)
0445         return WIIMOTE_EXT_NONE;
0446 
0447     if (rmem[4] == 0x00 && rmem[5] == 0x00)
0448         return WIIMOTE_EXT_NUNCHUK;
0449     if (rmem[4] == 0x01 && rmem[5] == 0x01)
0450         return WIIMOTE_EXT_CLASSIC_CONTROLLER;
0451     if (rmem[4] == 0x04 && rmem[5] == 0x02)
0452         return WIIMOTE_EXT_BALANCE_BOARD;
0453     if (rmem[4] == 0x01 && rmem[5] == 0x20)
0454         return WIIMOTE_EXT_PRO_CONTROLLER;
0455     if (rmem[0] == 0x01 && rmem[1] == 0x00 &&
0456         rmem[4] == 0x01 && rmem[5] == 0x03)
0457         return WIIMOTE_EXT_DRUMS;
0458     if (rmem[0] == 0x00 && rmem[1] == 0x00 &&
0459         rmem[4] == 0x01 && rmem[5] == 0x03)
0460         return WIIMOTE_EXT_GUITAR;
0461 
0462     return WIIMOTE_EXT_UNKNOWN;
0463 }
0464 
0465 /* requires the cmd-mutex to be held */
0466 static int wiimote_cmd_init_mp(struct wiimote_data *wdata)
0467 {
0468     __u8 wmem;
0469     int ret;
0470 
0471     /* initialize MP */
0472     wmem = 0x55;
0473     ret = wiimote_cmd_write(wdata, 0xa600f0, &wmem, sizeof(wmem));
0474     if (ret)
0475         return ret;
0476 
0477     /* disable default encryption */
0478     wmem = 0x0;
0479     ret = wiimote_cmd_write(wdata, 0xa600fb, &wmem, sizeof(wmem));
0480     if (ret)
0481         return ret;
0482 
0483     return 0;
0484 }
0485 
0486 /* requires the cmd-mutex to be held */
0487 static bool wiimote_cmd_map_mp(struct wiimote_data *wdata, __u8 exttype)
0488 {
0489     __u8 wmem;
0490 
0491     /* map MP with correct pass-through mode */
0492     switch (exttype) {
0493     case WIIMOTE_EXT_CLASSIC_CONTROLLER:
0494     case WIIMOTE_EXT_DRUMS:
0495     case WIIMOTE_EXT_GUITAR:
0496         wmem = 0x07;
0497         break;
0498     case WIIMOTE_EXT_NUNCHUK:
0499         wmem = 0x05;
0500         break;
0501     default:
0502         wmem = 0x04;
0503         break;
0504     }
0505 
0506     return wiimote_cmd_write(wdata, 0xa600fe, &wmem, sizeof(wmem));
0507 }
0508 
0509 /* requires the cmd-mutex to be held */
0510 static bool wiimote_cmd_read_mp(struct wiimote_data *wdata, __u8 *rmem)
0511 {
0512     int ret;
0513 
0514     /* read motion plus ID */
0515     ret = wiimote_cmd_read(wdata, 0xa600fa, rmem, 6);
0516     if (ret != 6)
0517         return false;
0518 
0519     hid_dbg(wdata->hdev, "motion plus ID: %6phC\n", rmem);
0520 
0521     if (rmem[5] == 0x05)
0522         return true;
0523 
0524     hid_info(wdata->hdev, "unknown motion plus ID: %6phC\n", rmem);
0525 
0526     return false;
0527 }
0528 
0529 /* requires the cmd-mutex to be held */
0530 static __u8 wiimote_cmd_read_mp_mapped(struct wiimote_data *wdata)
0531 {
0532     int ret;
0533     __u8 rmem[6];
0534 
0535     /* read motion plus ID */
0536     ret = wiimote_cmd_read(wdata, 0xa400fa, rmem, 6);
0537     if (ret != 6)
0538         return WIIMOTE_MP_NONE;
0539 
0540     hid_dbg(wdata->hdev, "mapped motion plus ID: %6phC\n", rmem);
0541 
0542     if (rmem[0] == 0xff && rmem[1] == 0xff && rmem[2] == 0xff &&
0543         rmem[3] == 0xff && rmem[4] == 0xff && rmem[5] == 0xff)
0544         return WIIMOTE_MP_NONE;
0545 
0546     if (rmem[4] == 0x04 && rmem[5] == 0x05)
0547         return WIIMOTE_MP_SINGLE;
0548     else if (rmem[4] == 0x05 && rmem[5] == 0x05)
0549         return WIIMOTE_MP_PASSTHROUGH_NUNCHUK;
0550     else if (rmem[4] == 0x07 && rmem[5] == 0x05)
0551         return WIIMOTE_MP_PASSTHROUGH_CLASSIC;
0552 
0553     return WIIMOTE_MP_UNKNOWN;
0554 }
0555 
0556 /* device module handling */
0557 
0558 static const __u8 * const wiimote_devtype_mods[WIIMOTE_DEV_NUM] = {
0559     [WIIMOTE_DEV_PENDING] = (const __u8[]){
0560         WIIMOD_NULL,
0561     },
0562     [WIIMOTE_DEV_UNKNOWN] = (const __u8[]){
0563         WIIMOD_NO_MP,
0564         WIIMOD_NULL,
0565     },
0566     [WIIMOTE_DEV_GENERIC] = (const __u8[]){
0567         WIIMOD_KEYS,
0568         WIIMOD_RUMBLE,
0569         WIIMOD_BATTERY,
0570         WIIMOD_LED1,
0571         WIIMOD_LED2,
0572         WIIMOD_LED3,
0573         WIIMOD_LED4,
0574         WIIMOD_ACCEL,
0575         WIIMOD_IR,
0576         WIIMOD_NULL,
0577     },
0578     [WIIMOTE_DEV_GEN10] = (const __u8[]){
0579         WIIMOD_KEYS,
0580         WIIMOD_RUMBLE,
0581         WIIMOD_BATTERY,
0582         WIIMOD_LED1,
0583         WIIMOD_LED2,
0584         WIIMOD_LED3,
0585         WIIMOD_LED4,
0586         WIIMOD_ACCEL,
0587         WIIMOD_IR,
0588         WIIMOD_NULL,
0589     },
0590     [WIIMOTE_DEV_GEN20] = (const __u8[]){
0591         WIIMOD_KEYS,
0592         WIIMOD_RUMBLE,
0593         WIIMOD_BATTERY,
0594         WIIMOD_LED1,
0595         WIIMOD_LED2,
0596         WIIMOD_LED3,
0597         WIIMOD_LED4,
0598         WIIMOD_ACCEL,
0599         WIIMOD_IR,
0600         WIIMOD_BUILTIN_MP,
0601         WIIMOD_NULL,
0602     },
0603     [WIIMOTE_DEV_BALANCE_BOARD] = (const __u8[]) {
0604         WIIMOD_BATTERY,
0605         WIIMOD_LED1,
0606         WIIMOD_NO_MP,
0607         WIIMOD_NULL,
0608     },
0609     [WIIMOTE_DEV_PRO_CONTROLLER] = (const __u8[]) {
0610         WIIMOD_BATTERY,
0611         WIIMOD_LED1,
0612         WIIMOD_LED2,
0613         WIIMOD_LED3,
0614         WIIMOD_LED4,
0615         WIIMOD_NO_MP,
0616         WIIMOD_NULL,
0617     },
0618 };
0619 
0620 static void wiimote_modules_load(struct wiimote_data *wdata,
0621                  unsigned int devtype)
0622 {
0623     bool need_input = false;
0624     const __u8 *mods, *iter;
0625     const struct wiimod_ops *ops;
0626     int ret;
0627 
0628     mods = wiimote_devtype_mods[devtype];
0629 
0630     for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
0631         if (wiimod_table[*iter]->flags & WIIMOD_FLAG_INPUT) {
0632             need_input = true;
0633             break;
0634         }
0635     }
0636 
0637     if (need_input) {
0638         wdata->input = input_allocate_device();
0639         if (!wdata->input)
0640             return;
0641 
0642         input_set_drvdata(wdata->input, wdata);
0643         wdata->input->dev.parent = &wdata->hdev->dev;
0644         wdata->input->id.bustype = wdata->hdev->bus;
0645         wdata->input->id.vendor = wdata->hdev->vendor;
0646         wdata->input->id.product = wdata->hdev->product;
0647         wdata->input->id.version = wdata->hdev->version;
0648         wdata->input->name = WIIMOTE_NAME;
0649     }
0650 
0651     for (iter = mods; *iter != WIIMOD_NULL; ++iter) {
0652         ops = wiimod_table[*iter];
0653         if (!ops->probe)
0654             continue;
0655 
0656         ret = ops->probe(ops, wdata);
0657         if (ret)
0658             goto error;
0659     }
0660 
0661     if (wdata->input) {
0662         ret = input_register_device(wdata->input);
0663         if (ret)
0664             goto error;
0665     }
0666 
0667     spin_lock_irq(&wdata->state.lock);
0668     wdata->state.devtype = devtype;
0669     spin_unlock_irq(&wdata->state.lock);
0670     return;
0671 
0672 error:
0673     for ( ; iter-- != mods; ) {
0674         ops = wiimod_table[*iter];
0675         if (ops->remove)
0676             ops->remove(ops, wdata);
0677     }
0678 
0679     if (wdata->input) {
0680         input_free_device(wdata->input);
0681         wdata->input = NULL;
0682     }
0683 }
0684 
0685 static void wiimote_modules_unload(struct wiimote_data *wdata)
0686 {
0687     const __u8 *mods, *iter;
0688     const struct wiimod_ops *ops;
0689     unsigned long flags;
0690 
0691     mods = wiimote_devtype_mods[wdata->state.devtype];
0692 
0693     spin_lock_irqsave(&wdata->state.lock, flags);
0694     wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
0695     spin_unlock_irqrestore(&wdata->state.lock, flags);
0696 
0697     /* find end of list */
0698     for (iter = mods; *iter != WIIMOD_NULL; ++iter)
0699         /* empty */ ;
0700 
0701     if (wdata->input) {
0702         input_get_device(wdata->input);
0703         input_unregister_device(wdata->input);
0704     }
0705 
0706     for ( ; iter-- != mods; ) {
0707         ops = wiimod_table[*iter];
0708         if (ops->remove)
0709             ops->remove(ops, wdata);
0710     }
0711 
0712     if (wdata->input) {
0713         input_put_device(wdata->input);
0714         wdata->input = NULL;
0715     }
0716 }
0717 
0718 /* device extension handling */
0719 
0720 static void wiimote_ext_load(struct wiimote_data *wdata, unsigned int ext)
0721 {
0722     unsigned long flags;
0723     const struct wiimod_ops *ops;
0724     int ret;
0725 
0726     ops = wiimod_ext_table[ext];
0727 
0728     if (ops->probe) {
0729         ret = ops->probe(ops, wdata);
0730         if (ret)
0731             ext = WIIMOTE_EXT_UNKNOWN;
0732     }
0733 
0734     spin_lock_irqsave(&wdata->state.lock, flags);
0735     wdata->state.exttype = ext;
0736     spin_unlock_irqrestore(&wdata->state.lock, flags);
0737 }
0738 
0739 static void wiimote_ext_unload(struct wiimote_data *wdata)
0740 {
0741     unsigned long flags;
0742     const struct wiimod_ops *ops;
0743 
0744     ops = wiimod_ext_table[wdata->state.exttype];
0745 
0746     spin_lock_irqsave(&wdata->state.lock, flags);
0747     wdata->state.exttype = WIIMOTE_EXT_UNKNOWN;
0748     wdata->state.flags &= ~WIIPROTO_FLAG_EXT_USED;
0749     spin_unlock_irqrestore(&wdata->state.lock, flags);
0750 
0751     if (ops->remove)
0752         ops->remove(ops, wdata);
0753 }
0754 
0755 static void wiimote_mp_load(struct wiimote_data *wdata)
0756 {
0757     unsigned long flags;
0758     const struct wiimod_ops *ops;
0759     int ret;
0760     __u8 mode = 2;
0761 
0762     ops = &wiimod_mp;
0763     if (ops->probe) {
0764         ret = ops->probe(ops, wdata);
0765         if (ret)
0766             mode = 1;
0767     }
0768 
0769     spin_lock_irqsave(&wdata->state.lock, flags);
0770     wdata->state.mp = mode;
0771     spin_unlock_irqrestore(&wdata->state.lock, flags);
0772 }
0773 
0774 static void wiimote_mp_unload(struct wiimote_data *wdata)
0775 {
0776     unsigned long flags;
0777     const struct wiimod_ops *ops;
0778 
0779     if (wdata->state.mp < 2)
0780         return;
0781 
0782     ops = &wiimod_mp;
0783 
0784     spin_lock_irqsave(&wdata->state.lock, flags);
0785     wdata->state.mp = 0;
0786     wdata->state.flags &= ~WIIPROTO_FLAG_MP_USED;
0787     spin_unlock_irqrestore(&wdata->state.lock, flags);
0788 
0789     if (ops->remove)
0790         ops->remove(ops, wdata);
0791 }
0792 
0793 /* device (re-)initialization and detection */
0794 
0795 static const char *wiimote_devtype_names[WIIMOTE_DEV_NUM] = {
0796     [WIIMOTE_DEV_PENDING] = "Pending",
0797     [WIIMOTE_DEV_UNKNOWN] = "Unknown",
0798     [WIIMOTE_DEV_GENERIC] = "Generic",
0799     [WIIMOTE_DEV_GEN10] = "Nintendo Wii Remote (Gen 1)",
0800     [WIIMOTE_DEV_GEN20] = "Nintendo Wii Remote Plus (Gen 2)",
0801     [WIIMOTE_DEV_BALANCE_BOARD] = "Nintendo Wii Balance Board",
0802     [WIIMOTE_DEV_PRO_CONTROLLER] = "Nintendo Wii U Pro Controller",
0803 };
0804 
0805 /* Try to guess the device type based on all collected information. We
0806  * first try to detect by static extension types, then VID/PID and the
0807  * device name. If we cannot detect the device, we use
0808  * WIIMOTE_DEV_GENERIC so all modules will get probed on the device. */
0809 static void wiimote_init_set_type(struct wiimote_data *wdata,
0810                   __u8 exttype)
0811 {
0812     __u8 devtype = WIIMOTE_DEV_GENERIC;
0813     __u16 vendor, product;
0814     const char *name;
0815 
0816     vendor = wdata->hdev->vendor;
0817     product = wdata->hdev->product;
0818     name = wdata->hdev->name;
0819 
0820     if (exttype == WIIMOTE_EXT_BALANCE_BOARD) {
0821         devtype = WIIMOTE_DEV_BALANCE_BOARD;
0822         goto done;
0823     } else if (exttype == WIIMOTE_EXT_PRO_CONTROLLER) {
0824         devtype = WIIMOTE_DEV_PRO_CONTROLLER;
0825         goto done;
0826     }
0827 
0828     if (!strcmp(name, "Nintendo RVL-CNT-01")) {
0829         devtype = WIIMOTE_DEV_GEN10;
0830         goto done;
0831     } else if (!strcmp(name, "Nintendo RVL-CNT-01-TR")) {
0832         devtype = WIIMOTE_DEV_GEN20;
0833         goto done;
0834     } else if (!strcmp(name, "Nintendo RVL-WBC-01")) {
0835         devtype = WIIMOTE_DEV_BALANCE_BOARD;
0836         goto done;
0837     } else if (!strcmp(name, "Nintendo RVL-CNT-01-UC")) {
0838         devtype = WIIMOTE_DEV_PRO_CONTROLLER;
0839         goto done;
0840     }
0841 
0842     if (vendor == USB_VENDOR_ID_NINTENDO) {
0843         if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE) {
0844             devtype = WIIMOTE_DEV_GEN10;
0845             goto done;
0846         } else if (product == USB_DEVICE_ID_NINTENDO_WIIMOTE2) {
0847             devtype = WIIMOTE_DEV_GEN20;
0848             goto done;
0849         }
0850     }
0851 
0852 done:
0853     if (devtype == WIIMOTE_DEV_GENERIC)
0854         hid_info(wdata->hdev, "cannot detect device; NAME: %s VID: %04x PID: %04x EXT: %04x\n",
0855             name, vendor, product, exttype);
0856     else
0857         hid_info(wdata->hdev, "detected device: %s\n",
0858              wiimote_devtype_names[devtype]);
0859 
0860     wiimote_modules_load(wdata, devtype);
0861 }
0862 
0863 static void wiimote_init_detect(struct wiimote_data *wdata)
0864 {
0865     __u8 exttype = WIIMOTE_EXT_NONE, extdata[6];
0866     bool ext;
0867     int ret;
0868 
0869     wiimote_cmd_acquire_noint(wdata);
0870 
0871     spin_lock_irq(&wdata->state.lock);
0872     wdata->state.devtype = WIIMOTE_DEV_UNKNOWN;
0873     wiimote_cmd_set(wdata, WIIPROTO_REQ_SREQ, 0);
0874     wiiproto_req_status(wdata);
0875     spin_unlock_irq(&wdata->state.lock);
0876 
0877     ret = wiimote_cmd_wait_noint(wdata);
0878     if (ret)
0879         goto out_release;
0880 
0881     spin_lock_irq(&wdata->state.lock);
0882     ext = wdata->state.flags & WIIPROTO_FLAG_EXT_PLUGGED;
0883     spin_unlock_irq(&wdata->state.lock);
0884 
0885     if (!ext)
0886         goto out_release;
0887 
0888     wiimote_cmd_init_ext(wdata);
0889     exttype = wiimote_cmd_read_ext(wdata, extdata);
0890 
0891 out_release:
0892     wiimote_cmd_release(wdata);
0893     wiimote_init_set_type(wdata, exttype);
0894 
0895     /* schedule MP timer */
0896     spin_lock_irq(&wdata->state.lock);
0897     if (!(wdata->state.flags & WIIPROTO_FLAG_BUILTIN_MP) &&
0898         !(wdata->state.flags & WIIPROTO_FLAG_NO_MP))
0899         mod_timer(&wdata->timer, jiffies + HZ * 4);
0900     spin_unlock_irq(&wdata->state.lock);
0901 }
0902 
0903 /*
0904  * MP hotplug events are not generated by the wiimote. Therefore, we need
0905  * polling to detect it. We use a 4s interval for polling MP registers. This
0906  * seems reasonable considering applications can trigger it manually via
0907  * sysfs requests.
0908  */
0909 static void wiimote_init_poll_mp(struct wiimote_data *wdata)
0910 {
0911     bool mp;
0912     __u8 mpdata[6];
0913 
0914     wiimote_cmd_acquire_noint(wdata);
0915     wiimote_cmd_init_mp(wdata);
0916     mp = wiimote_cmd_read_mp(wdata, mpdata);
0917     wiimote_cmd_release(wdata);
0918 
0919     /* load/unload MP module if it changed */
0920     if (mp) {
0921         if (!wdata->state.mp) {
0922             hid_info(wdata->hdev, "detected extension: Nintendo Wii Motion Plus\n");
0923             wiimote_mp_load(wdata);
0924         }
0925     } else if (wdata->state.mp) {
0926         wiimote_mp_unload(wdata);
0927     }
0928 
0929     mod_timer(&wdata->timer, jiffies + HZ * 4);
0930 }
0931 
0932 /*
0933  * Check whether the wiimote is in the expected state. The extension registers
0934  * may change during hotplug and initialization so we might get hotplug events
0935  * that we caused by remapping some memory.
0936  * We use some heuristics here to check known states. If the wiimote is in the
0937  * expected state, we can ignore the hotplug event.
0938  *
0939  * Returns "true" if the device is in expected state, "false" if we should
0940  * redo hotplug handling and extension initialization.
0941  */
0942 static bool wiimote_init_check(struct wiimote_data *wdata)
0943 {
0944     __u32 flags;
0945     __u8 type, data[6];
0946     bool ret, poll_mp;
0947 
0948     spin_lock_irq(&wdata->state.lock);
0949     flags = wdata->state.flags;
0950     spin_unlock_irq(&wdata->state.lock);
0951 
0952     wiimote_cmd_acquire_noint(wdata);
0953 
0954     /* If MP is used and active, but the extension is not, we expect:
0955      *   read_mp_mapped() == WIIMOTE_MP_SINGLE
0956      *   state.flags == !EXT_ACTIVE && !MP_PLUGGED && MP_ACTIVE
0957      * We do not check EXT_PLUGGED because it might change during
0958      * initialization of MP without extensions.
0959      *  - If MP is unplugged/replugged, read_mp_mapped() fails
0960      *  - If EXT is plugged, MP_PLUGGED will get set */
0961     if (wdata->state.exttype == WIIMOTE_EXT_NONE &&
0962         wdata->state.mp > 0 && (flags & WIIPROTO_FLAG_MP_USED)) {
0963         type = wiimote_cmd_read_mp_mapped(wdata);
0964         ret = type == WIIMOTE_MP_SINGLE;
0965 
0966         spin_lock_irq(&wdata->state.lock);
0967         ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
0968         ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_PLUGGED);
0969         ret = ret && (wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
0970         spin_unlock_irq(&wdata->state.lock);
0971 
0972         if (!ret)
0973             hid_dbg(wdata->hdev, "state left: !EXT && MP\n");
0974 
0975         /* while MP is mapped, we get EXT_PLUGGED events */
0976         poll_mp = false;
0977 
0978         goto out_release;
0979     }
0980 
0981     /* If MP is unused, but the extension port is used, we expect:
0982      *   read_ext == state.exttype
0983      *   state.flags == !MP_ACTIVE && EXT_ACTIVE
0984      * - If MP is plugged/unplugged, our timer detects it
0985      * - If EXT is unplugged/replugged, EXT_ACTIVE will become unset */
0986     if (!(flags & WIIPROTO_FLAG_MP_USED) &&
0987         wdata->state.exttype != WIIMOTE_EXT_NONE) {
0988         type = wiimote_cmd_read_ext(wdata, data);
0989         ret = type == wdata->state.exttype;
0990 
0991         spin_lock_irq(&wdata->state.lock);
0992         ret = ret && !(wdata->state.flags & WIIPROTO_FLAG_MP_ACTIVE);
0993         ret = ret && (wdata->state.flags & WIIPROTO_FLAG_EXT_ACTIVE);
0994         spin_unlock_irq(&wdata->state.lock);
0995 
0996         if (!ret)
0997             hid_dbg(wdata->hdev, "state left: EXT && !MP\n");
0998 
0999         /* 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 
1065 out_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 
1076 static 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  */
1095 static 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 
1203 static 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 
1221 void __wiimote_schedule(struct wiimote_data *wdata)
1222 {
1223     if (!(wdata->state.flags & WIIPROTO_FLAG_EXITING))
1224         schedule_work(&wdata->init_worker);
1225 }
1226 
1227 static 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 
1236 static 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 
1245 static 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 
1266 static 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 
1287 static 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 
1299 static 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 
1387 static 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 */
1410 static 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 */
1420 static 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 */
1448 static void handler_generic_K(struct wiimote_data *wdata, const __u8 *payload)
1449 {
1450     handler_keys(wdata, payload);
1451 }
1452 
1453 static 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 
1474 static 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 
1490 static void handler_drm_KA(struct wiimote_data *wdata, const __u8 *payload)
1491 {
1492     handler_keys(wdata, payload);
1493     handler_accel(wdata, payload);
1494 }
1495 
1496 static 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 
1502 static 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 
1512 static 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 
1518 static 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 
1528 static 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 
1535 static 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 
1546 static void handler_drm_E(struct wiimote_data *wdata, const __u8 *payload)
1547 {
1548     handler_ext(wdata, payload, 21);
1549 }
1550 
1551 static 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 
1563 static 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 
1583 struct wiiproto_handler {
1584     __u8 id;
1585     size_t size;
1586     void (*func)(struct wiimote_data *wdata, const __u8 *payload);
1587 };
1588 
1589 static 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 
1617 static 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 
1645 static 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 
1678 static 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 
1693 static DEVICE_ATTR(extension, S_IRUGO | S_IWUSR | S_IWGRP, wiimote_ext_show,
1694            wiimote_ext_store);
1695 
1696 static 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 
1727 static DEVICE_ATTR(devtype, S_IRUGO, wiimote_dev_show, NULL);
1728 
1729 static 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 
1755 static 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 
1782 static 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 
1837 err_free:
1838     wiimote_destroy(wdata);
1839     return ret;
1840 
1841 err_ext:
1842     device_remove_file(&wdata->hdev->dev, &dev_attr_extension);
1843 err_close:
1844     hid_hw_close(hdev);
1845 err_stop:
1846     hid_hw_stop(hdev);
1847 err:
1848     input_free_device(wdata->ir);
1849     input_free_device(wdata->accel);
1850     kfree(wdata);
1851     return ret;
1852 }
1853 
1854 static 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 
1862 static 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 
1870 bool wiimote_dpad_as_analog = false;
1871 module_param_named(dpad_as_analog, wiimote_dpad_as_analog, bool, 0644);
1872 MODULE_PARM_DESC(dpad_as_analog, "Use D-Pad as main analog input");
1873 
1874 MODULE_DEVICE_TABLE(hid, wiimote_hid_devices);
1875 
1876 static 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 };
1883 module_hid_driver(wiimote_hid_driver);
1884 
1885 MODULE_LICENSE("GPL");
1886 MODULE_AUTHOR("David Herrmann <dh.herrmann@gmail.com>");
1887 MODULE_DESCRIPTION("Driver for Nintendo Wii / Wii U peripherals");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!