sound/usb/caiaq/input.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
decode_erp
snd_caiaq_input_report_abs
snd_caiaq_input_read_analog
snd_caiaq_input_read_erp
snd_caiaq_input_read_io
snd_usb_caiaq_tks4_dispatch
snd_usb_caiaq_maschine_dispatch
snd_usb_caiaq_ep4_reply_dispatch
snd_usb_caiaq_input_open
snd_usb_caiaq_input_close
snd_usb_caiaq_input_dispatch
snd_usb_caiaq_input_init
snd_usb_caiaq_input_free
   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 
  17 static unsigned short keycode_ak1[] =  { KEY_C, KEY_B, KEY_A };
  18 static unsigned short keycode_rk2[] =  { KEY_1, KEY_2, KEY_3, KEY_4,
  19                                          KEY_5, KEY_6, KEY_7 };
  20 static unsigned short keycode_rk3[] =  { KEY_1, KEY_2, KEY_3, KEY_4,
  21                                          KEY_5, KEY_6, KEY_7, KEY_8, KEY_9 };
  22 
  23 static 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 
  63 static 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 */
 131 static 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 
 190 static 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 
 198 static 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 
 232 static 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 
 290 static 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 
 327 static 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 
 473 static 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 
 490 static 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 
 525 requeue:
 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 
 532 static 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 
 551 static 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 
 567 void 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 
 587 int 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 
 825 exit_free_idev:
 826         input_free_device(input);
 827         cdev->input_dev = NULL;
 828         return ret;
 829 }
 830 
 831 void 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 }
/* [<][>][^][v][top][bottom][index][help] */
root/sound/usb/caiaq/input.c

DEFINITIONS
