LXR linux/sound/usb/caiaq/input.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *   Copyright (c) 2006,2007 Daniel Mack, Tim Ruetz
   4*/
   5
   6#include <linux/device.h>
   7#include <linux/gfp.h>
   8#include <linux/init.h>
   9#include <linux/usb.h>
  10#include <linux/usb/input.h>
  11#include <sound/core.h>
  12#include <sound/pcm.h>
  13
  14#include "device.h"
  15#include "input.h"
  16
  17static const unsigned short keycode_ak1[] =  { KEY_C, KEY_B, KEY_A };
  18static const unsigned short keycode_rk2[] =  { KEY_1, KEY_2, KEY_3, KEY_4,
  19                                         KEY_5, KEY_6, KEY_7 };
  20static const unsigned short keycode_rk3[] =  { KEY_1, KEY_2, KEY_3, KEY_4,
  21                                         KEY_5, KEY_6, KEY_7, KEY_8, KEY_9 };
  22
  23static const unsigned short keycode_kore[] = {
  24        KEY_FN_F1,      /* "menu"               */
  25        KEY_FN_F7,      /* "lcd backlight       */
  26        KEY_FN_F2,      /* "control"            */
  27        KEY_FN_F3,      /* "enter"              */
  28        KEY_FN_F4,      /* "view"               */
  29        KEY_FN_F5,      /* "esc"                */
  30        KEY_FN_F6,      /* "sound"              */
  31        KEY_FN_F8,      /* array spacer, never triggered. */
  32        KEY_RIGHT,
  33        KEY_DOWN,
  34        KEY_UP,
  35        KEY_LEFT,
  36        KEY_SOUND,      /* "listen"             */
  37        KEY_RECORD,
  38        KEY_PLAYPAUSE,
  39        KEY_STOP,
  40        BTN_4,          /* 8 softkeys */
  41        BTN_3,
  42        BTN_2,
  43        BTN_1,
  44        BTN_8,
  45        BTN_7,
  46        BTN_6,
  47        BTN_5,
  48        KEY_BRL_DOT4,   /* touch sensitive knobs */
  49        KEY_BRL_DOT3,
  50        KEY_BRL_DOT2,
  51        KEY_BRL_DOT1,
  52        KEY_BRL_DOT8,
  53        KEY_BRL_DOT7,
  54        KEY_BRL_DOT6,
  55        KEY_BRL_DOT5
  56};
  57
  58#define MASCHINE_BUTTONS   (42)
  59#define MASCHINE_BUTTON(X) ((X) + BTN_MISC)
  60#define MASCHINE_PADS      (16)
  61#define MASCHINE_PAD(X)    ((X) + ABS_PRESSURE)
  62
  63static const unsigned short keycode_maschine[] = {
  64        MASCHINE_BUTTON(40), /* mute       */
  65        MASCHINE_BUTTON(39), /* solo       */
  66        MASCHINE_BUTTON(38), /* select     */
  67        MASCHINE_BUTTON(37), /* duplicate  */
  68        MASCHINE_BUTTON(36), /* navigate   */
  69        MASCHINE_BUTTON(35), /* pad mode   */
  70        MASCHINE_BUTTON(34), /* pattern    */
  71        MASCHINE_BUTTON(33), /* scene      */
  72        KEY_RESERVED, /* spacer */
  73
  74        MASCHINE_BUTTON(30), /* rec        */
  75        MASCHINE_BUTTON(31), /* erase      */
  76        MASCHINE_BUTTON(32), /* shift      */
  77        MASCHINE_BUTTON(28), /* grid       */
  78        MASCHINE_BUTTON(27), /* >          */
  79        MASCHINE_BUTTON(26), /* <          */
  80        MASCHINE_BUTTON(25), /* restart    */
  81
  82        MASCHINE_BUTTON(21), /* E          */
  83        MASCHINE_BUTTON(22), /* F          */
  84        MASCHINE_BUTTON(23), /* G          */
  85        MASCHINE_BUTTON(24), /* H          */
  86        MASCHINE_BUTTON(20), /* D          */
  87        MASCHINE_BUTTON(19), /* C          */
  88        MASCHINE_BUTTON(18), /* B          */
  89        MASCHINE_BUTTON(17), /* A          */
  90
  91        MASCHINE_BUTTON(0),  /* control    */
  92        MASCHINE_BUTTON(2),  /* browse     */
  93        MASCHINE_BUTTON(4),  /* <          */
  94        MASCHINE_BUTTON(6),  /* snap       */
  95        MASCHINE_BUTTON(7),  /* autowrite  */
  96        MASCHINE_BUTTON(5),  /* >          */
  97        MASCHINE_BUTTON(3),  /* sampling   */
  98        MASCHINE_BUTTON(1),  /* step       */
  99
 100        MASCHINE_BUTTON(15), /* 8 softkeys */
 101        MASCHINE_BUTTON(14),
 102        MASCHINE_BUTTON(13),
 103        MASCHINE_BUTTON(12),
 104        MASCHINE_BUTTON(11),
 105        MASCHINE_BUTTON(10),
 106        MASCHINE_BUTTON(9),
 107        MASCHINE_BUTTON(8),
 108
 109        MASCHINE_BUTTON(16), /* note repeat */
 110        MASCHINE_BUTTON(29)  /* play        */
 111};
 112
 113#define KONTROLX1_INPUTS        (40)
 114#define KONTROLS4_BUTTONS       (12 * 8)
 115#define KONTROLS4_AXIS          (46)
 116
 117#define KONTROLS4_BUTTON(X)     ((X) + BTN_MISC)
 118#define KONTROLS4_ABS(X)        ((X) + ABS_HAT0X)
 119
 120#define DEG90           (range / 2)
 121#define DEG180          (range)
 122#define DEG270          (DEG90 + DEG180)
 123#define DEG360          (DEG180 * 2)
 124#define HIGH_PEAK       (268)
 125#define LOW_PEAK        (-7)
 126
 127/* some of these devices have endless rotation potentiometers
 128 * built in which use two tapers, 90 degrees phase shifted.
 129 * this algorithm decodes them to one single value, ranging
 130 * from 0 to 999 */
 131static unsigned int decode_erp(unsigned char a, unsigned char b)
 132{
 133        int weight_a, weight_b;
 134        int pos_a, pos_b;
 135        int ret;
 136        int range = HIGH_PEAK - LOW_PEAK;
 137        int mid_value = (HIGH_PEAK + LOW_PEAK) / 2;
 138
 139        weight_b = abs(mid_value - a) - (range / 2 - 100) / 2;
 140
 141        if (weight_b < 0)
 142                weight_b = 0;
 143
 144        if (weight_b > 100)
 145                weight_b = 100;
 146
 147        weight_a = 100 - weight_b;
 148
 149        if (a < mid_value) {
 150                /* 0..90 and 270..360 degrees */
 151                pos_b = b - LOW_PEAK + DEG270;
 152                if (pos_b >= DEG360)
 153                        pos_b -= DEG360;
 154        } else
 155                /* 90..270 degrees */
 156                pos_b = HIGH_PEAK - b + DEG90;
 157
 158
 159        if (b > mid_value)
 160                /* 0..180 degrees */
 161                pos_a = a - LOW_PEAK;
 162        else
 163                /* 180..360 degrees */
 164                pos_a = HIGH_PEAK - a + DEG180;
 165
 166        /* interpolate both slider values, depending on weight factors */
 167        /* 0..99 x DEG360 */
 168        ret = pos_a * weight_a + pos_b * weight_b;
 169
 170        /* normalize to 0..999 */
 171        ret *= 10;
 172        ret /= DEG360;
 173
 174        if (ret < 0)
 175                ret += 1000;
 176
 177        if (ret >= 1000)
 178                ret -= 1000;
 179
 180        return ret;
 181}
 182
 183#undef DEG90
 184#undef DEG180
 185#undef DEG270
 186#undef DEG360
 187#undef HIGH_PEAK
 188#undef LOW_PEAK
 189
 190static inline void snd_caiaq_input_report_abs(struct snd_usb_caiaqdev *cdev,
 191                                              int axis, const unsigned char *buf,
 192                                              int offset)
 193{
 194        input_report_abs(cdev->input_dev, axis,
 195                         (buf[offset * 2] << 8) | buf[offset * 2 + 1]);
 196}
 197
 198static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev *cdev,
 199                                        const unsigned char *buf,
 200                                        unsigned int len)
 201{
 202        struct input_dev *input_dev = cdev->input_dev;
 203
 204        switch (cdev->chip.usb_id) {
 205        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2):
 206                snd_caiaq_input_report_abs(cdev, ABS_X, buf, 2);
 207                snd_caiaq_input_report_abs(cdev, ABS_Y, buf, 0);
 208                snd_caiaq_input_report_abs(cdev, ABS_Z, buf, 1);
 209                break;
 210        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
 211        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
 212        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
 213                snd_caiaq_input_report_abs(cdev, ABS_X, buf, 0);
 214                snd_caiaq_input_report_abs(cdev, ABS_Y, buf, 1);
 215                snd_caiaq_input_report_abs(cdev, ABS_Z, buf, 2);
 216                break;
 217        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
 218                snd_caiaq_input_report_abs(cdev, ABS_HAT0X, buf, 4);
 219                snd_caiaq_input_report_abs(cdev, ABS_HAT0Y, buf, 2);
 220                snd_caiaq_input_report_abs(cdev, ABS_HAT1X, buf, 6);
 221                snd_caiaq_input_report_abs(cdev, ABS_HAT1Y, buf, 1);
 222                snd_caiaq_input_report_abs(cdev, ABS_HAT2X, buf, 7);
 223                snd_caiaq_input_report_abs(cdev, ABS_HAT2Y, buf, 0);
 224                snd_caiaq_input_report_abs(cdev, ABS_HAT3X, buf, 5);
 225                snd_caiaq_input_report_abs(cdev, ABS_HAT3Y, buf, 3);
 226                break;
 227        }
 228
 229        input_sync(input_dev);
 230}
 231
 232static void snd_caiaq_input_read_erp(struct snd_usb_caiaqdev *cdev,
 233                                     const char *buf, unsigned int len)
 234{
 235        struct input_dev *input_dev = cdev->input_dev;
 236        int i;
 237
 238        switch (cdev->chip.usb_id) {
 239        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
 240                i = decode_erp(buf[0], buf[1]);
 241                input_report_abs(input_dev, ABS_X, i);
 242                input_sync(input_dev);
 243                break;
 244        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
 245        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
 246                i = decode_erp(buf[7], buf[5]);
 247                input_report_abs(input_dev, ABS_HAT0X, i);
 248                i = decode_erp(buf[12], buf[14]);
 249                input_report_abs(input_dev, ABS_HAT0Y, i);
 250                i = decode_erp(buf[15], buf[13]);
 251                input_report_abs(input_dev, ABS_HAT1X, i);
 252                i = decode_erp(buf[0], buf[2]);
 253                input_report_abs(input_dev, ABS_HAT1Y, i);
 254                i = decode_erp(buf[3], buf[1]);
 255                input_report_abs(input_dev, ABS_HAT2X, i);
 256                i = decode_erp(buf[8], buf[10]);
 257                input_report_abs(input_dev, ABS_HAT2Y, i);
 258                i = decode_erp(buf[11], buf[9]);
 259                input_report_abs(input_dev, ABS_HAT3X, i);
 260                i = decode_erp(buf[4], buf[6]);
 261                input_report_abs(input_dev, ABS_HAT3Y, i);
 262                input_sync(input_dev);
 263                break;
 264
 265        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER):
 266                /* 4 under the left screen */
 267                input_report_abs(input_dev, ABS_HAT0X, decode_erp(buf[21], buf[20]));
 268                input_report_abs(input_dev, ABS_HAT0Y, decode_erp(buf[15], buf[14]));
 269                input_report_abs(input_dev, ABS_HAT1X, decode_erp(buf[9],  buf[8]));
 270                input_report_abs(input_dev, ABS_HAT1Y, decode_erp(buf[3],  buf[2]));
 271
 272                /* 4 under the right screen */
 273                input_report_abs(input_dev, ABS_HAT2X, decode_erp(buf[19], buf[18]));
 274                input_report_abs(input_dev, ABS_HAT2Y, decode_erp(buf[13], buf[12]));
 275                input_report_abs(input_dev, ABS_HAT3X, decode_erp(buf[7],  buf[6]));
 276                input_report_abs(input_dev, ABS_HAT3Y, decode_erp(buf[1],  buf[0]));
 277
 278                /* volume */
 279                input_report_abs(input_dev, ABS_RX, decode_erp(buf[17], buf[16]));
 280                /* tempo */
 281                input_report_abs(input_dev, ABS_RY, decode_erp(buf[11], buf[10]));
 282                /* swing */
 283                input_report_abs(input_dev, ABS_RZ, decode_erp(buf[5],  buf[4]));
 284
 285                input_sync(input_dev);
 286                break;
 287        }
 288}
 289
 290static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev *cdev,
 291                                    unsigned char *buf, unsigned int len)
 292{
 293        struct input_dev *input_dev = cdev->input_dev;
 294        unsigned short *keycode = input_dev->keycode;
 295        int i;
 296
 297        if (!keycode)
 298                return;
 299
 300        if (input_dev->id.product == USB_PID_RIGKONTROL2)
 301                for (i = 0; i < len; i++)
 302                        buf[i] = ~buf[i];
 303
 304        for (i = 0; i < input_dev->keycodemax && i < len * 8; i++)
 305                input_report_key(input_dev, keycode[i],
 306                                 buf[i / 8] & (1 << (i % 8)));
 307
 308        switch (cdev->chip.usb_id) {
 309        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
 310        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
 311                input_report_abs(cdev->input_dev, ABS_MISC, 255 - buf[4]);
 312                break;
 313        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
 314                /* rotary encoders */
 315                input_report_abs(cdev->input_dev, ABS_X, buf[5] & 0xf);
 316                input_report_abs(cdev->input_dev, ABS_Y, buf[5] >> 4);
 317                input_report_abs(cdev->input_dev, ABS_Z, buf[6] & 0xf);
 318                input_report_abs(cdev->input_dev, ABS_MISC, buf[6] >> 4);
 319                break;
 320        }
 321
 322        input_sync(input_dev);
 323}
 324
 325#define TKS4_MSGBLOCK_SIZE      16
 326
 327static void snd_usb_caiaq_tks4_dispatch(struct snd_usb_caiaqdev *cdev,
 328                                        const unsigned char *buf,
 329                                        unsigned int len)
 330{
 331        struct device *dev = caiaqdev_to_dev(cdev);
 332
 333        while (len) {
 334                unsigned int i, block_id = (buf[0] << 8) | buf[1];
 335
 336                switch (block_id) {
 337                case 0:
 338                        /* buttons */
 339                        for (i = 0; i < KONTROLS4_BUTTONS; i++)
 340                                input_report_key(cdev->input_dev, KONTROLS4_BUTTON(i),
 341                                                 (buf[4 + (i / 8)] >> (i % 8)) & 1);
 342                        break;
 343
 344                case 1:
 345                        /* left wheel */
 346                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(36), buf[9] | ((buf[8] & 0x3) << 8));
 347                        /* right wheel */
 348                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(37), buf[13] | ((buf[12] & 0x3) << 8));
 349
 350                        /* rotary encoders */
 351                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(38), buf[3] & 0xf);
 352                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(39), buf[4] >> 4);
 353                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(40), buf[4] & 0xf);
 354                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(41), buf[5] >> 4);
 355                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(42), buf[5] & 0xf);
 356                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(43), buf[6] >> 4);
 357                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(44), buf[6] & 0xf);
 358                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(45), buf[7] >> 4);
 359                        input_report_abs(cdev->input_dev, KONTROLS4_ABS(46), buf[7] & 0xf);
 360
 361                        break;
 362                case 2:
 363                        /* Volume Fader Channel D */
 364                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(0), buf, 1);
 365                        /* Volume Fader Channel B */
 366                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(1), buf, 2);
 367                        /* Volume Fader Channel A */
 368                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(2), buf, 3);
 369                        /* Volume Fader Channel C */
 370                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(3), buf, 4);
 371                        /* Loop Volume */
 372                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(4), buf, 6);
 373                        /* Crossfader */
 374                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(7), buf, 7);
 375
 376                        break;
 377
 378                case 3:
 379                        /* Tempo Fader R */
 380                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(6), buf, 3);
 381                        /* Tempo Fader L */
 382                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(5), buf, 4);
 383                        /* Mic Volume */
 384                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(8), buf, 6);
 385                        /* Cue Mix */
 386                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(9), buf, 7);
 387
 388                        break;
 389
 390                case 4:
 391                        /* Wheel distance sensor L */
 392                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(10), buf, 1);
 393                        /* Wheel distance sensor R */
 394                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(11), buf, 2);
 395                        /* Channel D EQ - Filter */
 396                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(12), buf, 3);
 397                        /* Channel D EQ - Low */
 398                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(13), buf, 4);
 399                        /* Channel D EQ - Mid */
 400                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(14), buf, 5);
 401                        /* Channel D EQ - Hi */
 402                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(15), buf, 6);
 403                        /* FX2 - dry/wet */
 404                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(16), buf, 7);
 405
 406                        break;
 407
 408                case 5:
 409                        /* FX2 - 1 */
 410                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(17), buf, 1);
 411                        /* FX2 - 2 */
 412                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(18), buf, 2);
 413                        /* FX2 - 3 */
 414                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(19), buf, 3);
 415                        /* Channel B EQ - Filter */
 416                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(20), buf, 4);
 417                        /* Channel B EQ - Low */
 418                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(21), buf, 5);
 419                        /* Channel B EQ - Mid */
 420                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(22), buf, 6);
 421                        /* Channel B EQ - Hi */
 422                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(23), buf, 7);
 423
 424                        break;
 425
 426                case 6:
 427                        /* Channel A EQ - Filter */
 428                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(24), buf, 1);
 429                        /* Channel A EQ - Low */
 430                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(25), buf, 2);
 431                        /* Channel A EQ - Mid */
 432                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(26), buf, 3);
 433                        /* Channel A EQ - Hi */
 434                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(27), buf, 4);
 435                        /* Channel C EQ - Filter */
 436                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(28), buf, 5);
 437                        /* Channel C EQ - Low */
 438                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(29), buf, 6);
 439                        /* Channel C EQ - Mid */
 440                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(30), buf, 7);
 441
 442                        break;
 443
 444                case 7:
 445                        /* Channel C EQ - Hi */
 446                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(31), buf, 1);
 447                        /* FX1 - wet/dry */
 448                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(32), buf, 2);
 449                        /* FX1 - 1 */
 450                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(33), buf, 3);
 451                        /* FX1 - 2 */
 452                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(34), buf, 4);
 453                        /* FX1 - 3 */
 454                        snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(35), buf, 5);
 455
 456                        break;
 457
 458                default:
 459                        dev_dbg(dev, "%s(): bogus block (id %d)\n",
 460                                __func__, block_id);
 461                        return;
 462                }
 463
 464                len -= TKS4_MSGBLOCK_SIZE;
 465                buf += TKS4_MSGBLOCK_SIZE;
 466        }
 467
 468        input_sync(cdev->input_dev);
 469}
 470
 471#define MASCHINE_MSGBLOCK_SIZE 2
 472
 473static void snd_usb_caiaq_maschine_dispatch(struct snd_usb_caiaqdev *cdev,
 474                                        const unsigned char *buf,
 475                                        unsigned int len)
 476{
 477        unsigned int i, pad_id;
 478        __le16 *pressure = (__le16 *) buf;
 479
 480        for (i = 0; i < MASCHINE_PADS; i++) {
 481                pad_id = le16_to_cpu(*pressure) >> 12;
 482                input_report_abs(cdev->input_dev, MASCHINE_PAD(pad_id),
 483                                 le16_to_cpu(*pressure) & 0xfff);
 484                pressure++;
 485        }
 486
 487        input_sync(cdev->input_dev);
 488}
 489
 490static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb)
 491{
 492        struct snd_usb_caiaqdev *cdev = urb->context;
 493        unsigned char *buf = urb->transfer_buffer;
 494        struct device *dev = &urb->dev->dev;
 495        int ret;
 496
 497        if (urb->status || !cdev || urb != cdev->ep4_in_urb)
 498                return;
 499
 500        switch (cdev->chip.usb_id) {
 501        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
 502                if (urb->actual_length < 24)
 503                        goto requeue;
 504
 505                if (buf[0] & 0x3)
 506                        snd_caiaq_input_read_io(cdev, buf + 1, 7);
 507
 508                if (buf[0] & 0x4)
 509                        snd_caiaq_input_read_analog(cdev, buf + 8, 16);
 510
 511                break;
 512
 513        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
 514                snd_usb_caiaq_tks4_dispatch(cdev, buf, urb->actual_length);
 515                break;
 516
 517        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER):
 518                if (urb->actual_length < (MASCHINE_PADS * MASCHINE_MSGBLOCK_SIZE))
 519                        goto requeue;
 520
 521                snd_usb_caiaq_maschine_dispatch(cdev, buf, urb->actual_length);
 522                break;
 523        }
 524
 525requeue:
 526        cdev->ep4_in_urb->actual_length = 0;
 527        ret = usb_submit_urb(cdev->ep4_in_urb, GFP_ATOMIC);
 528        if (ret < 0)
 529                dev_err(dev, "unable to submit urb. OOM!?\n");
 530}
 531
 532static int snd_usb_caiaq_input_open(struct input_dev *idev)
 533{
 534        struct snd_usb_caiaqdev *cdev = input_get_drvdata(idev);
 535
 536        if (!cdev)
 537                return -EINVAL;
 538
 539        switch (cdev->chip.usb_id) {
 540        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
 541        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
 542        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER):
 543                if (usb_submit_urb(cdev->ep4_in_urb, GFP_KERNEL) != 0)
 544                        return -EIO;
 545                break;
 546        }
 547
 548        return 0;
 549}
 550
 551static void snd_usb_caiaq_input_close(struct input_dev *idev)
 552{
 553        struct snd_usb_caiaqdev *cdev = input_get_drvdata(idev);
 554
 555        if (!cdev)
 556                return;
 557
 558        switch (cdev->chip.usb_id) {
 559        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
 560        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
 561        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER):
 562                usb_kill_urb(cdev->ep4_in_urb);
 563                break;
 564        }
 565}
 566
 567void snd_usb_caiaq_input_dispatch(struct snd_usb_caiaqdev *cdev,
 568                                  char *buf,
 569                                  unsigned int len)
 570{
 571        if (!cdev->input_dev || len < 1)
 572                return;
 573
 574        switch (buf[0]) {
 575        case EP1_CMD_READ_ANALOG:
 576                snd_caiaq_input_read_analog(cdev, buf + 1, len - 1);
 577                break;
 578        case EP1_CMD_READ_ERP:
 579                snd_caiaq_input_read_erp(cdev, buf + 1, len - 1);
 580                break;
 581        case EP1_CMD_READ_IO:
 582                snd_caiaq_input_read_io(cdev, buf + 1, len - 1);
 583                break;
 584        }
 585}
 586
 587int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *cdev)
 588{
 589        struct usb_device *usb_dev = cdev->chip.dev;
 590        struct input_dev *input;
 591        int i, ret = 0;
 592
 593        input = input_allocate_device();
 594        if (!input)
 595                return -ENOMEM;
 596
 597        usb_make_path(usb_dev, cdev->phys, sizeof(cdev->phys));
 598        strlcat(cdev->phys, "/input0", sizeof(cdev->phys));
 599
 600        input->name = cdev->product_name;
 601        input->phys = cdev->phys;
 602        usb_to_input_id(usb_dev, &input->id);
 603        input->dev.parent = &usb_dev->dev;
 604
 605        input_set_drvdata(input, cdev);
 606
 607        switch (cdev->chip.usb_id) {
 608        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2):
 609                input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 610                input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
 611                        BIT_MASK(ABS_Z);
 612                BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_rk2));
 613                memcpy(cdev->keycode, keycode_rk2, sizeof(keycode_rk2));
 614                input->keycodemax = ARRAY_SIZE(keycode_rk2);
 615                input_set_abs_params(input, ABS_X, 0, 4096, 0, 10);
 616                input_set_abs_params(input, ABS_Y, 0, 4096, 0, 10);
 617                input_set_abs_params(input, ABS_Z, 0, 4096, 0, 10);
 618                snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 0);
 619                break;
 620        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
 621                input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 622                input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
 623                        BIT_MASK(ABS_Z);
 624                BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_rk3));
 625                memcpy(cdev->keycode, keycode_rk3, sizeof(keycode_rk3));
 626                input->keycodemax = ARRAY_SIZE(keycode_rk3);
 627                input_set_abs_params(input, ABS_X, 0, 1024, 0, 10);
 628                input_set_abs_params(input, ABS_Y, 0, 1024, 0, 10);
 629                input_set_abs_params(input, ABS_Z, 0, 1024, 0, 10);
 630                snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 0);
 631                break;
 632        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
 633                input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 634                input->absbit[0] = BIT_MASK(ABS_X);
 635                BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_ak1));
 636                memcpy(cdev->keycode, keycode_ak1, sizeof(keycode_ak1));
 637                input->keycodemax = ARRAY_SIZE(keycode_ak1);
 638                input_set_abs_params(input, ABS_X, 0, 999, 0, 10);
 639                snd_usb_caiaq_set_auto_msg(cdev, 1, 0, 5);
 640                break;
 641        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
 642        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
 643                input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 644                input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) |
 645                                   BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) |
 646                                   BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) |
 647                                   BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) |
 648                                   BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
 649                                   BIT_MASK(ABS_Z);
 650                input->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
 651                BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_kore));
 652                memcpy(cdev->keycode, keycode_kore, sizeof(keycode_kore));
 653                input->keycodemax = ARRAY_SIZE(keycode_kore);
 654                input_set_abs_params(input, ABS_HAT0X, 0, 999, 0, 10);
 655                input_set_abs_params(input, ABS_HAT0Y, 0, 999, 0, 10);
 656                input_set_abs_params(input, ABS_HAT1X, 0, 999, 0, 10);
 657                input_set_abs_params(input, ABS_HAT1Y, 0, 999, 0, 10);
 658                input_set_abs_params(input, ABS_HAT2X, 0, 999, 0, 10);
 659                input_set_abs_params(input, ABS_HAT2Y, 0, 999, 0, 10);
 660                input_set_abs_params(input, ABS_HAT3X, 0, 999, 0, 10);
 661                input_set_abs_params(input, ABS_HAT3Y, 0, 999, 0, 10);
 662                input_set_abs_params(input, ABS_X, 0, 4096, 0, 10);
 663                input_set_abs_params(input, ABS_Y, 0, 4096, 0, 10);
 664                input_set_abs_params(input, ABS_Z, 0, 4096, 0, 10);
 665                input_set_abs_params(input, ABS_MISC, 0, 255, 0, 1);
 666                snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5);
 667                break;
 668        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
 669                input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 670                input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) |
 671                                   BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) |
 672                                   BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) |
 673                                   BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) |
 674                                   BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
 675                                   BIT_MASK(ABS_Z);
 676                input->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
 677                BUILD_BUG_ON(sizeof(cdev->keycode) < KONTROLX1_INPUTS);
 678                for (i = 0; i < KONTROLX1_INPUTS; i++)
 679                        cdev->keycode[i] = BTN_MISC + i;
 680                input->keycodemax = KONTROLX1_INPUTS;
 681
 682                /* analog potentiometers */
 683                input_set_abs_params(input, ABS_HAT0X, 0, 4096, 0, 10);
 684                input_set_abs_params(input, ABS_HAT0Y, 0, 4096, 0, 10);
 685                input_set_abs_params(input, ABS_HAT1X, 0, 4096, 0, 10);
 686                input_set_abs_params(input, ABS_HAT1Y, 0, 4096, 0, 10);
 687                input_set_abs_params(input, ABS_HAT2X, 0, 4096, 0, 10);
 688                input_set_abs_params(input, ABS_HAT2Y, 0, 4096, 0, 10);
 689                input_set_abs_params(input, ABS_HAT3X, 0, 4096, 0, 10);
 690                input_set_abs_params(input, ABS_HAT3Y, 0, 4096, 0, 10);
 691
 692                /* rotary encoders */
 693                input_set_abs_params(input, ABS_X, 0, 0xf, 0, 1);
 694                input_set_abs_params(input, ABS_Y, 0, 0xf, 0, 1);
 695                input_set_abs_params(input, ABS_Z, 0, 0xf, 0, 1);
 696                input_set_abs_params(input, ABS_MISC, 0, 0xf, 0, 1);
 697
 698                cdev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 699                if (!cdev->ep4_in_urb) {
 700                        ret = -ENOMEM;
 701                        goto exit_free_idev;
 702                }
 703
 704                usb_fill_bulk_urb(cdev->ep4_in_urb, usb_dev,
 705                                  usb_rcvbulkpipe(usb_dev, 0x4),
 706                                  cdev->ep4_in_buf, EP4_BUFSIZE,
 707                                  snd_usb_caiaq_ep4_reply_dispatch, cdev);
 708                ret = usb_urb_ep_type_check(cdev->ep4_in_urb);
 709                if (ret < 0)
 710                        goto exit_free_idev;
 711
 712                snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5);
 713
 714                break;
 715
 716        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
 717                input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 718                BUILD_BUG_ON(sizeof(cdev->keycode) < KONTROLS4_BUTTONS);
 719                for (i = 0; i < KONTROLS4_BUTTONS; i++)
 720                        cdev->keycode[i] = KONTROLS4_BUTTON(i);
 721                input->keycodemax = KONTROLS4_BUTTONS;
 722
 723                for (i = 0; i < KONTROLS4_AXIS; i++) {
 724                        int axis = KONTROLS4_ABS(i);
 725                        input->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
 726                }
 727
 728                /* 36 analog potentiometers and faders */
 729                for (i = 0; i < 36; i++)
 730                        input_set_abs_params(input, KONTROLS4_ABS(i), 0, 0xfff, 0, 10);
 731
 732                /* 2 encoder wheels */
 733                input_set_abs_params(input, KONTROLS4_ABS(36), 0, 0x3ff, 0, 1);
 734                input_set_abs_params(input, KONTROLS4_ABS(37), 0, 0x3ff, 0, 1);
 735
 736                /* 9 rotary encoders */
 737                for (i = 0; i < 9; i++)
 738                        input_set_abs_params(input, KONTROLS4_ABS(38+i), 0, 0xf, 0, 1);
 739
 740                cdev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 741                if (!cdev->ep4_in_urb) {
 742                        ret = -ENOMEM;
 743                        goto exit_free_idev;
 744                }
 745
 746                usb_fill_bulk_urb(cdev->ep4_in_urb, usb_dev,
 747                                  usb_rcvbulkpipe(usb_dev, 0x4),
 748                                  cdev->ep4_in_buf, EP4_BUFSIZE,
 749                                  snd_usb_caiaq_ep4_reply_dispatch, cdev);
 750                ret = usb_urb_ep_type_check(cdev->ep4_in_urb);
 751                if (ret < 0)
 752                        goto exit_free_idev;
 753
 754                snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5);
 755
 756                break;
 757
 758        case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER):
 759                input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 760                input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) |
 761                        BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) |
 762                        BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) |
 763                        BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) |
 764                        BIT_MASK(ABS_RX) | BIT_MASK(ABS_RY) |
 765                        BIT_MASK(ABS_RZ);
 766
 767                BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_maschine));
 768                memcpy(cdev->keycode, keycode_maschine, sizeof(keycode_maschine));
 769                input->keycodemax = ARRAY_SIZE(keycode_maschine);
 770
 771                for (i = 0; i < MASCHINE_PADS; i++) {
 772                        input->absbit[0] |= MASCHINE_PAD(i);
 773                        input_set_abs_params(input, MASCHINE_PAD(i), 0, 0xfff, 5, 10);
 774                }
 775
 776                input_set_abs_params(input, ABS_HAT0X, 0, 999, 0, 10);
 777                input_set_abs_params(input, ABS_HAT0Y, 0, 999, 0, 10);
 778                input_set_abs_params(input, ABS_HAT1X, 0, 999, 0, 10);
 779                input_set_abs_params(input, ABS_HAT1Y, 0, 999, 0, 10);
 780                input_set_abs_params(input, ABS_HAT2X, 0, 999, 0, 10);
 781                input_set_abs_params(input, ABS_HAT2Y, 0, 999, 0, 10);
 782                input_set_abs_params(input, ABS_HAT3X, 0, 999, 0, 10);
 783                input_set_abs_params(input, ABS_HAT3Y, 0, 999, 0, 10);
 784                input_set_abs_params(input, ABS_RX, 0, 999, 0, 10);
 785                input_set_abs_params(input, ABS_RY, 0, 999, 0, 10);
 786                input_set_abs_params(input, ABS_RZ, 0, 999, 0, 10);
 787
 788                cdev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 789                if (!cdev->ep4_in_urb) {
 790                        ret = -ENOMEM;
 791                        goto exit_free_idev;
 792                }
 793
 794                usb_fill_bulk_urb(cdev->ep4_in_urb, usb_dev,
 795                                  usb_rcvbulkpipe(usb_dev, 0x4),
 796                                  cdev->ep4_in_buf, EP4_BUFSIZE,
 797                                  snd_usb_caiaq_ep4_reply_dispatch, cdev);
 798                ret = usb_urb_ep_type_check(cdev->ep4_in_urb);
 799                if (ret < 0)
 800                        goto exit_free_idev;
 801
 802                snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5);
 803                break;
 804
 805        default:
 806                /* no input methods supported on this device */
 807                goto exit_free_idev;
 808        }
 809
 810        input->open = snd_usb_caiaq_input_open;
 811        input->close = snd_usb_caiaq_input_close;
 812        input->keycode = cdev->keycode;
 813        input->keycodesize = sizeof(unsigned short);
 814        for (i = 0; i < input->keycodemax; i++)
 815                __set_bit(cdev->keycode[i], input->keybit);
 816
 817        cdev->input_dev = input;
 818
 819        ret = input_register_device(input);
 820        if (ret < 0)
 821                goto exit_free_idev;
 822
 823        return 0;
 824
 825exit_free_idev:
 826        input_free_device(input);
 827        cdev->input_dev = NULL;
 828        return ret;
 829}
 830
 831void snd_usb_caiaq_input_free(struct snd_usb_caiaqdev *cdev)
 832{
 833        if (!cdev || !cdev->input_dev)
 834                return;
 835
 836        usb_kill_urb(cdev->ep4_in_urb);
 837        usb_free_urb(cdev->ep4_in_urb);
 838        cdev->ep4_in_urb = NULL;
 839
 840        input_unregister_device(cdev->input_dev);
 841        cdev->input_dev = NULL;
 842}
 843