Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *   Copyright (c) 2006,2007 Daniel Mack, Tim Ruetz
0004 */
0005 
0006 #include <linux/device.h>
0007 #include <linux/gfp.h>
0008 #include <linux/init.h>
0009 #include <linux/usb.h>
0010 #include <linux/usb/input.h>
0011 #include <sound/core.h>
0012 #include <sound/pcm.h>
0013 
0014 #include "device.h"
0015 #include "input.h"
0016 
0017 static const unsigned short keycode_ak1[] =  { KEY_C, KEY_B, KEY_A };
0018 static const unsigned short keycode_rk2[] =  { KEY_1, KEY_2, KEY_3, KEY_4,
0019                      KEY_5, KEY_6, KEY_7 };
0020 static const unsigned short keycode_rk3[] =  { KEY_1, KEY_2, KEY_3, KEY_4,
0021                      KEY_5, KEY_6, KEY_7, KEY_8, KEY_9 };
0022 
0023 static const unsigned short keycode_kore[] = {
0024     KEY_FN_F1,      /* "menu"               */
0025     KEY_FN_F7,      /* "lcd backlight       */
0026     KEY_FN_F2,      /* "control"            */
0027     KEY_FN_F3,      /* "enter"              */
0028     KEY_FN_F4,      /* "view"               */
0029     KEY_FN_F5,      /* "esc"                */
0030     KEY_FN_F6,      /* "sound"              */
0031     KEY_FN_F8,      /* array spacer, never triggered. */
0032     KEY_RIGHT,
0033     KEY_DOWN,
0034     KEY_UP,
0035     KEY_LEFT,
0036     KEY_SOUND,      /* "listen"             */
0037     KEY_RECORD,
0038     KEY_PLAYPAUSE,
0039     KEY_STOP,
0040     BTN_4,          /* 8 softkeys */
0041     BTN_3,
0042     BTN_2,
0043     BTN_1,
0044     BTN_8,
0045     BTN_7,
0046     BTN_6,
0047     BTN_5,
0048     KEY_BRL_DOT4,   /* touch sensitive knobs */
0049     KEY_BRL_DOT3,
0050     KEY_BRL_DOT2,
0051     KEY_BRL_DOT1,
0052     KEY_BRL_DOT8,
0053     KEY_BRL_DOT7,
0054     KEY_BRL_DOT6,
0055     KEY_BRL_DOT5
0056 };
0057 
0058 #define MASCHINE_BUTTONS   (42)
0059 #define MASCHINE_BUTTON(X) ((X) + BTN_MISC)
0060 #define MASCHINE_PADS      (16)
0061 #define MASCHINE_PAD(X)    ((X) + ABS_PRESSURE)
0062 
0063 static const unsigned short keycode_maschine[] = {
0064     MASCHINE_BUTTON(40), /* mute       */
0065     MASCHINE_BUTTON(39), /* solo       */
0066     MASCHINE_BUTTON(38), /* select     */
0067     MASCHINE_BUTTON(37), /* duplicate  */
0068     MASCHINE_BUTTON(36), /* navigate   */
0069     MASCHINE_BUTTON(35), /* pad mode   */
0070     MASCHINE_BUTTON(34), /* pattern    */
0071     MASCHINE_BUTTON(33), /* scene      */
0072     KEY_RESERVED, /* spacer */
0073 
0074     MASCHINE_BUTTON(30), /* rec        */
0075     MASCHINE_BUTTON(31), /* erase      */
0076     MASCHINE_BUTTON(32), /* shift      */
0077     MASCHINE_BUTTON(28), /* grid       */
0078     MASCHINE_BUTTON(27), /* >          */
0079     MASCHINE_BUTTON(26), /* <          */
0080     MASCHINE_BUTTON(25), /* restart    */
0081 
0082     MASCHINE_BUTTON(21), /* E          */
0083     MASCHINE_BUTTON(22), /* F          */
0084     MASCHINE_BUTTON(23), /* G          */
0085     MASCHINE_BUTTON(24), /* H          */
0086     MASCHINE_BUTTON(20), /* D          */
0087     MASCHINE_BUTTON(19), /* C          */
0088     MASCHINE_BUTTON(18), /* B          */
0089     MASCHINE_BUTTON(17), /* A          */
0090 
0091     MASCHINE_BUTTON(0),  /* control    */
0092     MASCHINE_BUTTON(2),  /* browse     */
0093     MASCHINE_BUTTON(4),  /* <          */
0094     MASCHINE_BUTTON(6),  /* snap       */
0095     MASCHINE_BUTTON(7),  /* autowrite  */
0096     MASCHINE_BUTTON(5),  /* >          */
0097     MASCHINE_BUTTON(3),  /* sampling   */
0098     MASCHINE_BUTTON(1),  /* step       */
0099 
0100     MASCHINE_BUTTON(15), /* 8 softkeys */
0101     MASCHINE_BUTTON(14),
0102     MASCHINE_BUTTON(13),
0103     MASCHINE_BUTTON(12),
0104     MASCHINE_BUTTON(11),
0105     MASCHINE_BUTTON(10),
0106     MASCHINE_BUTTON(9),
0107     MASCHINE_BUTTON(8),
0108 
0109     MASCHINE_BUTTON(16), /* note repeat */
0110     MASCHINE_BUTTON(29)  /* play        */
0111 };
0112 
0113 #define KONTROLX1_INPUTS    (40)
0114 #define KONTROLS4_BUTTONS   (12 * 8)
0115 #define KONTROLS4_AXIS      (46)
0116 
0117 #define KONTROLS4_BUTTON(X) ((X) + BTN_MISC)
0118 #define KONTROLS4_ABS(X)    ((X) + ABS_HAT0X)
0119 
0120 #define DEG90       (range / 2)
0121 #define DEG180      (range)
0122 #define DEG270      (DEG90 + DEG180)
0123 #define DEG360      (DEG180 * 2)
0124 #define HIGH_PEAK   (268)
0125 #define LOW_PEAK    (-7)
0126 
0127 /* some of these devices have endless rotation potentiometers
0128  * built in which use two tapers, 90 degrees phase shifted.
0129  * this algorithm decodes them to one single value, ranging
0130  * from 0 to 999 */
0131 static unsigned int decode_erp(unsigned char a, unsigned char b)
0132 {
0133     int weight_a, weight_b;
0134     int pos_a, pos_b;
0135     int ret;
0136     int range = HIGH_PEAK - LOW_PEAK;
0137     int mid_value = (HIGH_PEAK + LOW_PEAK) / 2;
0138 
0139     weight_b = abs(mid_value - a) - (range / 2 - 100) / 2;
0140 
0141     if (weight_b < 0)
0142         weight_b = 0;
0143 
0144     if (weight_b > 100)
0145         weight_b = 100;
0146 
0147     weight_a = 100 - weight_b;
0148 
0149     if (a < mid_value) {
0150         /* 0..90 and 270..360 degrees */
0151         pos_b = b - LOW_PEAK + DEG270;
0152         if (pos_b >= DEG360)
0153             pos_b -= DEG360;
0154     } else
0155         /* 90..270 degrees */
0156         pos_b = HIGH_PEAK - b + DEG90;
0157 
0158 
0159     if (b > mid_value)
0160         /* 0..180 degrees */
0161         pos_a = a - LOW_PEAK;
0162     else
0163         /* 180..360 degrees */
0164         pos_a = HIGH_PEAK - a + DEG180;
0165 
0166     /* interpolate both slider values, depending on weight factors */
0167     /* 0..99 x DEG360 */
0168     ret = pos_a * weight_a + pos_b * weight_b;
0169 
0170     /* normalize to 0..999 */
0171     ret *= 10;
0172     ret /= DEG360;
0173 
0174     if (ret < 0)
0175         ret += 1000;
0176 
0177     if (ret >= 1000)
0178         ret -= 1000;
0179 
0180     return ret;
0181 }
0182 
0183 #undef DEG90
0184 #undef DEG180
0185 #undef DEG270
0186 #undef DEG360
0187 #undef HIGH_PEAK
0188 #undef LOW_PEAK
0189 
0190 static inline void snd_caiaq_input_report_abs(struct snd_usb_caiaqdev *cdev,
0191                           int axis, const unsigned char *buf,
0192                           int offset)
0193 {
0194     input_report_abs(cdev->input_dev, axis,
0195              (buf[offset * 2] << 8) | buf[offset * 2 + 1]);
0196 }
0197 
0198 static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev *cdev,
0199                     const unsigned char *buf,
0200                     unsigned int len)
0201 {
0202     struct input_dev *input_dev = cdev->input_dev;
0203 
0204     switch (cdev->chip.usb_id) {
0205     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2):
0206         snd_caiaq_input_report_abs(cdev, ABS_X, buf, 2);
0207         snd_caiaq_input_report_abs(cdev, ABS_Y, buf, 0);
0208         snd_caiaq_input_report_abs(cdev, ABS_Z, buf, 1);
0209         break;
0210     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
0211     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
0212     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
0213         snd_caiaq_input_report_abs(cdev, ABS_X, buf, 0);
0214         snd_caiaq_input_report_abs(cdev, ABS_Y, buf, 1);
0215         snd_caiaq_input_report_abs(cdev, ABS_Z, buf, 2);
0216         break;
0217     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
0218         snd_caiaq_input_report_abs(cdev, ABS_HAT0X, buf, 4);
0219         snd_caiaq_input_report_abs(cdev, ABS_HAT0Y, buf, 2);
0220         snd_caiaq_input_report_abs(cdev, ABS_HAT1X, buf, 6);
0221         snd_caiaq_input_report_abs(cdev, ABS_HAT1Y, buf, 1);
0222         snd_caiaq_input_report_abs(cdev, ABS_HAT2X, buf, 7);
0223         snd_caiaq_input_report_abs(cdev, ABS_HAT2Y, buf, 0);
0224         snd_caiaq_input_report_abs(cdev, ABS_HAT3X, buf, 5);
0225         snd_caiaq_input_report_abs(cdev, ABS_HAT3Y, buf, 3);
0226         break;
0227     }
0228 
0229     input_sync(input_dev);
0230 }
0231 
0232 static void snd_caiaq_input_read_erp(struct snd_usb_caiaqdev *cdev,
0233                      const char *buf, unsigned int len)
0234 {
0235     struct input_dev *input_dev = cdev->input_dev;
0236     int i;
0237 
0238     switch (cdev->chip.usb_id) {
0239     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
0240         i = decode_erp(buf[0], buf[1]);
0241         input_report_abs(input_dev, ABS_X, i);
0242         input_sync(input_dev);
0243         break;
0244     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
0245     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
0246         i = decode_erp(buf[7], buf[5]);
0247         input_report_abs(input_dev, ABS_HAT0X, i);
0248         i = decode_erp(buf[12], buf[14]);
0249         input_report_abs(input_dev, ABS_HAT0Y, i);
0250         i = decode_erp(buf[15], buf[13]);
0251         input_report_abs(input_dev, ABS_HAT1X, i);
0252         i = decode_erp(buf[0], buf[2]);
0253         input_report_abs(input_dev, ABS_HAT1Y, i);
0254         i = decode_erp(buf[3], buf[1]);
0255         input_report_abs(input_dev, ABS_HAT2X, i);
0256         i = decode_erp(buf[8], buf[10]);
0257         input_report_abs(input_dev, ABS_HAT2Y, i);
0258         i = decode_erp(buf[11], buf[9]);
0259         input_report_abs(input_dev, ABS_HAT3X, i);
0260         i = decode_erp(buf[4], buf[6]);
0261         input_report_abs(input_dev, ABS_HAT3Y, i);
0262         input_sync(input_dev);
0263         break;
0264 
0265     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER):
0266         /* 4 under the left screen */
0267         input_report_abs(input_dev, ABS_HAT0X, decode_erp(buf[21], buf[20]));
0268         input_report_abs(input_dev, ABS_HAT0Y, decode_erp(buf[15], buf[14]));
0269         input_report_abs(input_dev, ABS_HAT1X, decode_erp(buf[9],  buf[8]));
0270         input_report_abs(input_dev, ABS_HAT1Y, decode_erp(buf[3],  buf[2]));
0271 
0272         /* 4 under the right screen */
0273         input_report_abs(input_dev, ABS_HAT2X, decode_erp(buf[19], buf[18]));
0274         input_report_abs(input_dev, ABS_HAT2Y, decode_erp(buf[13], buf[12]));
0275         input_report_abs(input_dev, ABS_HAT3X, decode_erp(buf[7],  buf[6]));
0276         input_report_abs(input_dev, ABS_HAT3Y, decode_erp(buf[1],  buf[0]));
0277 
0278         /* volume */
0279         input_report_abs(input_dev, ABS_RX, decode_erp(buf[17], buf[16]));
0280         /* tempo */
0281         input_report_abs(input_dev, ABS_RY, decode_erp(buf[11], buf[10]));
0282         /* swing */
0283         input_report_abs(input_dev, ABS_RZ, decode_erp(buf[5],  buf[4]));
0284 
0285         input_sync(input_dev);
0286         break;
0287     }
0288 }
0289 
0290 static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev *cdev,
0291                     unsigned char *buf, unsigned int len)
0292 {
0293     struct input_dev *input_dev = cdev->input_dev;
0294     unsigned short *keycode = input_dev->keycode;
0295     int i;
0296 
0297     if (!keycode)
0298         return;
0299 
0300     if (input_dev->id.product == USB_PID_RIGKONTROL2)
0301         for (i = 0; i < len; i++)
0302             buf[i] = ~buf[i];
0303 
0304     for (i = 0; i < input_dev->keycodemax && i < len * 8; i++)
0305         input_report_key(input_dev, keycode[i],
0306                  buf[i / 8] & (1 << (i % 8)));
0307 
0308     switch (cdev->chip.usb_id) {
0309     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
0310     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
0311         input_report_abs(cdev->input_dev, ABS_MISC, 255 - buf[4]);
0312         break;
0313     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
0314         /* rotary encoders */
0315         input_report_abs(cdev->input_dev, ABS_X, buf[5] & 0xf);
0316         input_report_abs(cdev->input_dev, ABS_Y, buf[5] >> 4);
0317         input_report_abs(cdev->input_dev, ABS_Z, buf[6] & 0xf);
0318         input_report_abs(cdev->input_dev, ABS_MISC, buf[6] >> 4);
0319         break;
0320     }
0321 
0322     input_sync(input_dev);
0323 }
0324 
0325 #define TKS4_MSGBLOCK_SIZE  16
0326 
0327 static void snd_usb_caiaq_tks4_dispatch(struct snd_usb_caiaqdev *cdev,
0328                     const unsigned char *buf,
0329                     unsigned int len)
0330 {
0331     struct device *dev = caiaqdev_to_dev(cdev);
0332 
0333     while (len) {
0334         unsigned int i, block_id = (buf[0] << 8) | buf[1];
0335 
0336         switch (block_id) {
0337         case 0:
0338             /* buttons */
0339             for (i = 0; i < KONTROLS4_BUTTONS; i++)
0340                 input_report_key(cdev->input_dev, KONTROLS4_BUTTON(i),
0341                          (buf[4 + (i / 8)] >> (i % 8)) & 1);
0342             break;
0343 
0344         case 1:
0345             /* left wheel */
0346             input_report_abs(cdev->input_dev, KONTROLS4_ABS(36), buf[9] | ((buf[8] & 0x3) << 8));
0347             /* right wheel */
0348             input_report_abs(cdev->input_dev, KONTROLS4_ABS(37), buf[13] | ((buf[12] & 0x3) << 8));
0349 
0350             /* rotary encoders */
0351             input_report_abs(cdev->input_dev, KONTROLS4_ABS(38), buf[3] & 0xf);
0352             input_report_abs(cdev->input_dev, KONTROLS4_ABS(39), buf[4] >> 4);
0353             input_report_abs(cdev->input_dev, KONTROLS4_ABS(40), buf[4] & 0xf);
0354             input_report_abs(cdev->input_dev, KONTROLS4_ABS(41), buf[5] >> 4);
0355             input_report_abs(cdev->input_dev, KONTROLS4_ABS(42), buf[5] & 0xf);
0356             input_report_abs(cdev->input_dev, KONTROLS4_ABS(43), buf[6] >> 4);
0357             input_report_abs(cdev->input_dev, KONTROLS4_ABS(44), buf[6] & 0xf);
0358             input_report_abs(cdev->input_dev, KONTROLS4_ABS(45), buf[7] >> 4);
0359             input_report_abs(cdev->input_dev, KONTROLS4_ABS(46), buf[7] & 0xf);
0360 
0361             break;
0362         case 2:
0363             /* Volume Fader Channel D */
0364             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(0), buf, 1);
0365             /* Volume Fader Channel B */
0366             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(1), buf, 2);
0367             /* Volume Fader Channel A */
0368             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(2), buf, 3);
0369             /* Volume Fader Channel C */
0370             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(3), buf, 4);
0371             /* Loop Volume */
0372             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(4), buf, 6);
0373             /* Crossfader */
0374             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(7), buf, 7);
0375 
0376             break;
0377 
0378         case 3:
0379             /* Tempo Fader R */
0380             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(6), buf, 3);
0381             /* Tempo Fader L */
0382             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(5), buf, 4);
0383             /* Mic Volume */
0384             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(8), buf, 6);
0385             /* Cue Mix */
0386             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(9), buf, 7);
0387 
0388             break;
0389 
0390         case 4:
0391             /* Wheel distance sensor L */
0392             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(10), buf, 1);
0393             /* Wheel distance sensor R */
0394             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(11), buf, 2);
0395             /* Channel D EQ - Filter */
0396             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(12), buf, 3);
0397             /* Channel D EQ - Low */
0398             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(13), buf, 4);
0399             /* Channel D EQ - Mid */
0400             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(14), buf, 5);
0401             /* Channel D EQ - Hi */
0402             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(15), buf, 6);
0403             /* FX2 - dry/wet */
0404             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(16), buf, 7);
0405 
0406             break;
0407 
0408         case 5:
0409             /* FX2 - 1 */
0410             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(17), buf, 1);
0411             /* FX2 - 2 */
0412             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(18), buf, 2);
0413             /* FX2 - 3 */
0414             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(19), buf, 3);
0415             /* Channel B EQ - Filter */
0416             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(20), buf, 4);
0417             /* Channel B EQ - Low */
0418             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(21), buf, 5);
0419             /* Channel B EQ - Mid */
0420             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(22), buf, 6);
0421             /* Channel B EQ - Hi */
0422             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(23), buf, 7);
0423 
0424             break;
0425 
0426         case 6:
0427             /* Channel A EQ - Filter */
0428             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(24), buf, 1);
0429             /* Channel A EQ - Low */
0430             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(25), buf, 2);
0431             /* Channel A EQ - Mid */
0432             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(26), buf, 3);
0433             /* Channel A EQ - Hi */
0434             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(27), buf, 4);
0435             /* Channel C EQ - Filter */
0436             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(28), buf, 5);
0437             /* Channel C EQ - Low */
0438             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(29), buf, 6);
0439             /* Channel C EQ - Mid */
0440             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(30), buf, 7);
0441 
0442             break;
0443 
0444         case 7:
0445             /* Channel C EQ - Hi */
0446             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(31), buf, 1);
0447             /* FX1 - wet/dry */
0448             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(32), buf, 2);
0449             /* FX1 - 1 */
0450             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(33), buf, 3);
0451             /* FX1 - 2 */
0452             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(34), buf, 4);
0453             /* FX1 - 3 */
0454             snd_caiaq_input_report_abs(cdev, KONTROLS4_ABS(35), buf, 5);
0455 
0456             break;
0457 
0458         default:
0459             dev_dbg(dev, "%s(): bogus block (id %d)\n",
0460                 __func__, block_id);
0461             return;
0462         }
0463 
0464         len -= TKS4_MSGBLOCK_SIZE;
0465         buf += TKS4_MSGBLOCK_SIZE;
0466     }
0467 
0468     input_sync(cdev->input_dev);
0469 }
0470 
0471 #define MASCHINE_MSGBLOCK_SIZE 2
0472 
0473 static void snd_usb_caiaq_maschine_dispatch(struct snd_usb_caiaqdev *cdev,
0474                     const unsigned char *buf,
0475                     unsigned int len)
0476 {
0477     unsigned int i, pad_id;
0478     __le16 *pressure = (__le16 *) buf;
0479 
0480     for (i = 0; i < MASCHINE_PADS; i++) {
0481         pad_id = le16_to_cpu(*pressure) >> 12;
0482         input_report_abs(cdev->input_dev, MASCHINE_PAD(pad_id),
0483                  le16_to_cpu(*pressure) & 0xfff);
0484         pressure++;
0485     }
0486 
0487     input_sync(cdev->input_dev);
0488 }
0489 
0490 static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb)
0491 {
0492     struct snd_usb_caiaqdev *cdev = urb->context;
0493     unsigned char *buf = urb->transfer_buffer;
0494     struct device *dev = &urb->dev->dev;
0495     int ret;
0496 
0497     if (urb->status || !cdev || urb != cdev->ep4_in_urb)
0498         return;
0499 
0500     switch (cdev->chip.usb_id) {
0501     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
0502         if (urb->actual_length < 24)
0503             goto requeue;
0504 
0505         if (buf[0] & 0x3)
0506             snd_caiaq_input_read_io(cdev, buf + 1, 7);
0507 
0508         if (buf[0] & 0x4)
0509             snd_caiaq_input_read_analog(cdev, buf + 8, 16);
0510 
0511         break;
0512 
0513     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
0514         snd_usb_caiaq_tks4_dispatch(cdev, buf, urb->actual_length);
0515         break;
0516 
0517     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER):
0518         if (urb->actual_length < (MASCHINE_PADS * MASCHINE_MSGBLOCK_SIZE))
0519             goto requeue;
0520 
0521         snd_usb_caiaq_maschine_dispatch(cdev, buf, urb->actual_length);
0522         break;
0523     }
0524 
0525 requeue:
0526     cdev->ep4_in_urb->actual_length = 0;
0527     ret = usb_submit_urb(cdev->ep4_in_urb, GFP_ATOMIC);
0528     if (ret < 0)
0529         dev_err(dev, "unable to submit urb. OOM!?\n");
0530 }
0531 
0532 static int snd_usb_caiaq_input_open(struct input_dev *idev)
0533 {
0534     struct snd_usb_caiaqdev *cdev = input_get_drvdata(idev);
0535 
0536     if (!cdev)
0537         return -EINVAL;
0538 
0539     switch (cdev->chip.usb_id) {
0540     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
0541     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
0542     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER):
0543         if (usb_submit_urb(cdev->ep4_in_urb, GFP_KERNEL) != 0)
0544             return -EIO;
0545         break;
0546     }
0547 
0548     return 0;
0549 }
0550 
0551 static void snd_usb_caiaq_input_close(struct input_dev *idev)
0552 {
0553     struct snd_usb_caiaqdev *cdev = input_get_drvdata(idev);
0554 
0555     if (!cdev)
0556         return;
0557 
0558     switch (cdev->chip.usb_id) {
0559     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
0560     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
0561     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER):
0562         usb_kill_urb(cdev->ep4_in_urb);
0563         break;
0564     }
0565 }
0566 
0567 void snd_usb_caiaq_input_dispatch(struct snd_usb_caiaqdev *cdev,
0568                   char *buf,
0569                   unsigned int len)
0570 {
0571     if (!cdev->input_dev || len < 1)
0572         return;
0573 
0574     switch (buf[0]) {
0575     case EP1_CMD_READ_ANALOG:
0576         snd_caiaq_input_read_analog(cdev, buf + 1, len - 1);
0577         break;
0578     case EP1_CMD_READ_ERP:
0579         snd_caiaq_input_read_erp(cdev, buf + 1, len - 1);
0580         break;
0581     case EP1_CMD_READ_IO:
0582         snd_caiaq_input_read_io(cdev, buf + 1, len - 1);
0583         break;
0584     }
0585 }
0586 
0587 int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *cdev)
0588 {
0589     struct usb_device *usb_dev = cdev->chip.dev;
0590     struct input_dev *input;
0591     int i, ret = 0;
0592 
0593     input = input_allocate_device();
0594     if (!input)
0595         return -ENOMEM;
0596 
0597     usb_make_path(usb_dev, cdev->phys, sizeof(cdev->phys));
0598     strlcat(cdev->phys, "/input0", sizeof(cdev->phys));
0599 
0600     input->name = cdev->product_name;
0601     input->phys = cdev->phys;
0602     usb_to_input_id(usb_dev, &input->id);
0603     input->dev.parent = &usb_dev->dev;
0604 
0605     input_set_drvdata(input, cdev);
0606 
0607     switch (cdev->chip.usb_id) {
0608     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2):
0609         input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
0610         input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
0611             BIT_MASK(ABS_Z);
0612         BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_rk2));
0613         memcpy(cdev->keycode, keycode_rk2, sizeof(keycode_rk2));
0614         input->keycodemax = ARRAY_SIZE(keycode_rk2);
0615         input_set_abs_params(input, ABS_X, 0, 4096, 0, 10);
0616         input_set_abs_params(input, ABS_Y, 0, 4096, 0, 10);
0617         input_set_abs_params(input, ABS_Z, 0, 4096, 0, 10);
0618         snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 0);
0619         break;
0620     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
0621         input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
0622         input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
0623             BIT_MASK(ABS_Z);
0624         BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_rk3));
0625         memcpy(cdev->keycode, keycode_rk3, sizeof(keycode_rk3));
0626         input->keycodemax = ARRAY_SIZE(keycode_rk3);
0627         input_set_abs_params(input, ABS_X, 0, 1024, 0, 10);
0628         input_set_abs_params(input, ABS_Y, 0, 1024, 0, 10);
0629         input_set_abs_params(input, ABS_Z, 0, 1024, 0, 10);
0630         snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 0);
0631         break;
0632     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
0633         input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
0634         input->absbit[0] = BIT_MASK(ABS_X);
0635         BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_ak1));
0636         memcpy(cdev->keycode, keycode_ak1, sizeof(keycode_ak1));
0637         input->keycodemax = ARRAY_SIZE(keycode_ak1);
0638         input_set_abs_params(input, ABS_X, 0, 999, 0, 10);
0639         snd_usb_caiaq_set_auto_msg(cdev, 1, 0, 5);
0640         break;
0641     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
0642     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2):
0643         input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
0644         input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) |
0645                    BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) |
0646                    BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) |
0647                    BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) |
0648                    BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
0649                    BIT_MASK(ABS_Z);
0650         input->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
0651         BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_kore));
0652         memcpy(cdev->keycode, keycode_kore, sizeof(keycode_kore));
0653         input->keycodemax = ARRAY_SIZE(keycode_kore);
0654         input_set_abs_params(input, ABS_HAT0X, 0, 999, 0, 10);
0655         input_set_abs_params(input, ABS_HAT0Y, 0, 999, 0, 10);
0656         input_set_abs_params(input, ABS_HAT1X, 0, 999, 0, 10);
0657         input_set_abs_params(input, ABS_HAT1Y, 0, 999, 0, 10);
0658         input_set_abs_params(input, ABS_HAT2X, 0, 999, 0, 10);
0659         input_set_abs_params(input, ABS_HAT2Y, 0, 999, 0, 10);
0660         input_set_abs_params(input, ABS_HAT3X, 0, 999, 0, 10);
0661         input_set_abs_params(input, ABS_HAT3Y, 0, 999, 0, 10);
0662         input_set_abs_params(input, ABS_X, 0, 4096, 0, 10);
0663         input_set_abs_params(input, ABS_Y, 0, 4096, 0, 10);
0664         input_set_abs_params(input, ABS_Z, 0, 4096, 0, 10);
0665         input_set_abs_params(input, ABS_MISC, 0, 255, 0, 1);
0666         snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5);
0667         break;
0668     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1):
0669         input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
0670         input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) |
0671                    BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) |
0672                    BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) |
0673                    BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) |
0674                    BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
0675                    BIT_MASK(ABS_Z);
0676         input->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
0677         BUILD_BUG_ON(sizeof(cdev->keycode) < KONTROLX1_INPUTS);
0678         for (i = 0; i < KONTROLX1_INPUTS; i++)
0679             cdev->keycode[i] = BTN_MISC + i;
0680         input->keycodemax = KONTROLX1_INPUTS;
0681 
0682         /* analog potentiometers */
0683         input_set_abs_params(input, ABS_HAT0X, 0, 4096, 0, 10);
0684         input_set_abs_params(input, ABS_HAT0Y, 0, 4096, 0, 10);
0685         input_set_abs_params(input, ABS_HAT1X, 0, 4096, 0, 10);
0686         input_set_abs_params(input, ABS_HAT1Y, 0, 4096, 0, 10);
0687         input_set_abs_params(input, ABS_HAT2X, 0, 4096, 0, 10);
0688         input_set_abs_params(input, ABS_HAT2Y, 0, 4096, 0, 10);
0689         input_set_abs_params(input, ABS_HAT3X, 0, 4096, 0, 10);
0690         input_set_abs_params(input, ABS_HAT3Y, 0, 4096, 0, 10);
0691 
0692         /* rotary encoders */
0693         input_set_abs_params(input, ABS_X, 0, 0xf, 0, 1);
0694         input_set_abs_params(input, ABS_Y, 0, 0xf, 0, 1);
0695         input_set_abs_params(input, ABS_Z, 0, 0xf, 0, 1);
0696         input_set_abs_params(input, ABS_MISC, 0, 0xf, 0, 1);
0697 
0698         cdev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL);
0699         if (!cdev->ep4_in_urb) {
0700             ret = -ENOMEM;
0701             goto exit_free_idev;
0702         }
0703 
0704         usb_fill_bulk_urb(cdev->ep4_in_urb, usb_dev,
0705                   usb_rcvbulkpipe(usb_dev, 0x4),
0706                   cdev->ep4_in_buf, EP4_BUFSIZE,
0707                   snd_usb_caiaq_ep4_reply_dispatch, cdev);
0708         ret = usb_urb_ep_type_check(cdev->ep4_in_urb);
0709         if (ret < 0)
0710             goto exit_free_idev;
0711 
0712         snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5);
0713 
0714         break;
0715 
0716     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLS4):
0717         input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
0718         BUILD_BUG_ON(sizeof(cdev->keycode) < KONTROLS4_BUTTONS);
0719         for (i = 0; i < KONTROLS4_BUTTONS; i++)
0720             cdev->keycode[i] = KONTROLS4_BUTTON(i);
0721         input->keycodemax = KONTROLS4_BUTTONS;
0722 
0723         for (i = 0; i < KONTROLS4_AXIS; i++) {
0724             int axis = KONTROLS4_ABS(i);
0725             input->absbit[BIT_WORD(axis)] |= BIT_MASK(axis);
0726         }
0727 
0728         /* 36 analog potentiometers and faders */
0729         for (i = 0; i < 36; i++)
0730             input_set_abs_params(input, KONTROLS4_ABS(i), 0, 0xfff, 0, 10);
0731 
0732         /* 2 encoder wheels */
0733         input_set_abs_params(input, KONTROLS4_ABS(36), 0, 0x3ff, 0, 1);
0734         input_set_abs_params(input, KONTROLS4_ABS(37), 0, 0x3ff, 0, 1);
0735 
0736         /* 9 rotary encoders */
0737         for (i = 0; i < 9; i++)
0738             input_set_abs_params(input, KONTROLS4_ABS(38+i), 0, 0xf, 0, 1);
0739 
0740         cdev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL);
0741         if (!cdev->ep4_in_urb) {
0742             ret = -ENOMEM;
0743             goto exit_free_idev;
0744         }
0745 
0746         usb_fill_bulk_urb(cdev->ep4_in_urb, usb_dev,
0747                   usb_rcvbulkpipe(usb_dev, 0x4),
0748                   cdev->ep4_in_buf, EP4_BUFSIZE,
0749                   snd_usb_caiaq_ep4_reply_dispatch, cdev);
0750         ret = usb_urb_ep_type_check(cdev->ep4_in_urb);
0751         if (ret < 0)
0752             goto exit_free_idev;
0753 
0754         snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5);
0755 
0756         break;
0757 
0758     case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_MASCHINECONTROLLER):
0759         input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
0760         input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) |
0761             BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) |
0762             BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) |
0763             BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) |
0764             BIT_MASK(ABS_RX) | BIT_MASK(ABS_RY) |
0765             BIT_MASK(ABS_RZ);
0766 
0767         BUILD_BUG_ON(sizeof(cdev->keycode) < sizeof(keycode_maschine));
0768         memcpy(cdev->keycode, keycode_maschine, sizeof(keycode_maschine));
0769         input->keycodemax = ARRAY_SIZE(keycode_maschine);
0770 
0771         for (i = 0; i < MASCHINE_PADS; i++) {
0772             input->absbit[0] |= MASCHINE_PAD(i);
0773             input_set_abs_params(input, MASCHINE_PAD(i), 0, 0xfff, 5, 10);
0774         }
0775 
0776         input_set_abs_params(input, ABS_HAT0X, 0, 999, 0, 10);
0777         input_set_abs_params(input, ABS_HAT0Y, 0, 999, 0, 10);
0778         input_set_abs_params(input, ABS_HAT1X, 0, 999, 0, 10);
0779         input_set_abs_params(input, ABS_HAT1Y, 0, 999, 0, 10);
0780         input_set_abs_params(input, ABS_HAT2X, 0, 999, 0, 10);
0781         input_set_abs_params(input, ABS_HAT2Y, 0, 999, 0, 10);
0782         input_set_abs_params(input, ABS_HAT3X, 0, 999, 0, 10);
0783         input_set_abs_params(input, ABS_HAT3Y, 0, 999, 0, 10);
0784         input_set_abs_params(input, ABS_RX, 0, 999, 0, 10);
0785         input_set_abs_params(input, ABS_RY, 0, 999, 0, 10);
0786         input_set_abs_params(input, ABS_RZ, 0, 999, 0, 10);
0787 
0788         cdev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL);
0789         if (!cdev->ep4_in_urb) {
0790             ret = -ENOMEM;
0791             goto exit_free_idev;
0792         }
0793 
0794         usb_fill_bulk_urb(cdev->ep4_in_urb, usb_dev,
0795                   usb_rcvbulkpipe(usb_dev, 0x4),
0796                   cdev->ep4_in_buf, EP4_BUFSIZE,
0797                   snd_usb_caiaq_ep4_reply_dispatch, cdev);
0798         ret = usb_urb_ep_type_check(cdev->ep4_in_urb);
0799         if (ret < 0)
0800             goto exit_free_idev;
0801 
0802         snd_usb_caiaq_set_auto_msg(cdev, 1, 10, 5);
0803         break;
0804 
0805     default:
0806         /* no input methods supported on this device */
0807         goto exit_free_idev;
0808     }
0809 
0810     input->open = snd_usb_caiaq_input_open;
0811     input->close = snd_usb_caiaq_input_close;
0812     input->keycode = cdev->keycode;
0813     input->keycodesize = sizeof(unsigned short);
0814     for (i = 0; i < input->keycodemax; i++)
0815         __set_bit(cdev->keycode[i], input->keybit);
0816 
0817     cdev->input_dev = input;
0818 
0819     ret = input_register_device(input);
0820     if (ret < 0)
0821         goto exit_free_idev;
0822 
0823     return 0;
0824 
0825 exit_free_idev:
0826     input_free_device(input);
0827     cdev->input_dev = NULL;
0828     return ret;
0829 }
0830 
0831 void snd_usb_caiaq_input_free(struct snd_usb_caiaqdev *cdev)
0832 {
0833     if (!cdev || !cdev->input_dev)
0834         return;
0835 
0836     usb_kill_urb(cdev->ep4_in_urb);
0837     usb_free_urb(cdev->ep4_in_urb);
0838     cdev->ep4_in_urb = NULL;
0839 
0840     input_unregister_device(cdev->input_dev);
0841     cdev->input_dev = NULL;
0842 }
[ 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!