2 * Copyright (c) 2006,2007 Daniel Mack, Tim Ruetz
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #include <linux/init.h>
20 #include <linux/usb.h>
21 #include <linux/usb/input.h>
22 #include <sound/core.h>
23 #include <sound/pcm.h>
28 static unsigned short keycode_ak1
[] = { KEY_C
, KEY_B
, KEY_A
};
29 static unsigned short keycode_rk2
[] = { KEY_1
, KEY_2
, KEY_3
, KEY_4
,
30 KEY_5
, KEY_6
, KEY_7
};
31 static unsigned short keycode_rk3
[] = { KEY_1
, KEY_2
, KEY_3
, KEY_4
,
32 KEY_5
, KEY_6
, KEY_7
, KEY_5
, KEY_6
};
34 static unsigned short keycode_kore
[] = {
35 KEY_FN_F1
, /* "menu" */
36 KEY_FN_F7
, /* "lcd backlight */
37 KEY_FN_F2
, /* "control" */
38 KEY_FN_F3
, /* "enter" */
39 KEY_FN_F4
, /* "view" */
40 KEY_FN_F5
, /* "esc" */
41 KEY_FN_F6
, /* "sound" */
42 KEY_FN_F8
, /* array spacer, never triggered. */
47 KEY_SOUND
, /* "listen" */
51 BTN_4
, /* 8 softkeys */
59 KEY_BRL_DOT4
, /* touch sensitive knobs */
69 #define KONTROLX1_INPUTS 40
71 #define DEG90 (range / 2)
72 #define DEG180 (range)
73 #define DEG270 (DEG90 + DEG180)
74 #define DEG360 (DEG180 * 2)
75 #define HIGH_PEAK (268)
78 /* some of these devices have endless rotation potentiometers
79 * built in which use two tapers, 90 degrees phase shifted.
80 * this algorithm decodes them to one single value, ranging
82 static unsigned int decode_erp(unsigned char a
, unsigned char b
)
84 int weight_a
, weight_b
;
87 int range
= HIGH_PEAK
- LOW_PEAK
;
88 int mid_value
= (HIGH_PEAK
+ LOW_PEAK
) / 2;
90 weight_b
= abs(mid_value
- a
) - (range
/ 2 - 100) / 2;
98 weight_a
= 100 - weight_b
;
101 /* 0..90 and 270..360 degrees */
102 pos_b
= b
- LOW_PEAK
+ DEG270
;
106 /* 90..270 degrees */
107 pos_b
= HIGH_PEAK
- b
+ DEG90
;
112 pos_a
= a
- LOW_PEAK
;
114 /* 180..360 degrees */
115 pos_a
= HIGH_PEAK
- a
+ DEG180
;
117 /* interpolate both slider values, depending on weight factors */
119 ret
= pos_a
* weight_a
+ pos_b
* weight_b
;
121 /* normalize to 0..999 */
142 static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev
*dev
,
143 const unsigned char *buf
,
146 struct input_dev
*input_dev
= dev
->input_dev
;
148 switch (dev
->chip
.usb_id
) {
149 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_RIGKONTROL2
):
150 input_report_abs(input_dev
, ABS_X
, (buf
[4] << 8) | buf
[5]);
151 input_report_abs(input_dev
, ABS_Y
, (buf
[0] << 8) | buf
[1]);
152 input_report_abs(input_dev
, ABS_Z
, (buf
[2] << 8) | buf
[3]);
153 input_sync(input_dev
);
155 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_RIGKONTROL3
):
156 input_report_abs(input_dev
, ABS_X
, (buf
[0] << 8) | buf
[1]);
157 input_report_abs(input_dev
, ABS_Y
, (buf
[2] << 8) | buf
[3]);
158 input_report_abs(input_dev
, ABS_Z
, (buf
[4] << 8) | buf
[5]);
159 input_sync(input_dev
);
161 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_KORECONTROLLER
):
162 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_KORECONTROLLER2
):
163 input_report_abs(input_dev
, ABS_X
, (buf
[0] << 8) | buf
[1]);
164 input_report_abs(input_dev
, ABS_Y
, (buf
[2] << 8) | buf
[3]);
165 input_report_abs(input_dev
, ABS_Z
, (buf
[4] << 8) | buf
[5]);
166 input_sync(input_dev
);
168 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_TRAKTORKONTROLX1
):
169 input_report_abs(input_dev
, ABS_HAT0X
, (buf
[8] << 8) | buf
[9]);
170 input_report_abs(input_dev
, ABS_HAT0Y
, (buf
[4] << 8) | buf
[5]);
171 input_report_abs(input_dev
, ABS_HAT1X
, (buf
[12] << 8) | buf
[13]);
172 input_report_abs(input_dev
, ABS_HAT1Y
, (buf
[2] << 8) | buf
[3]);
173 input_report_abs(input_dev
, ABS_HAT2X
, (buf
[15] << 8) | buf
[15]);
174 input_report_abs(input_dev
, ABS_HAT2Y
, (buf
[0] << 8) | buf
[1]);
175 input_report_abs(input_dev
, ABS_HAT3X
, (buf
[10] << 8) | buf
[11]);
176 input_report_abs(input_dev
, ABS_HAT3Y
, (buf
[6] << 8) | buf
[7]);
177 input_sync(input_dev
);
182 static void snd_caiaq_input_read_erp(struct snd_usb_caiaqdev
*dev
,
183 const char *buf
, unsigned int len
)
185 struct input_dev
*input_dev
= dev
->input_dev
;
188 switch (dev
->chip
.usb_id
) {
189 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_AK1
):
190 i
= decode_erp(buf
[0], buf
[1]);
191 input_report_abs(input_dev
, ABS_X
, i
);
192 input_sync(input_dev
);
194 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_KORECONTROLLER
):
195 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_KORECONTROLLER2
):
196 i
= decode_erp(buf
[7], buf
[5]);
197 input_report_abs(input_dev
, ABS_HAT0X
, i
);
198 i
= decode_erp(buf
[12], buf
[14]);
199 input_report_abs(input_dev
, ABS_HAT0Y
, i
);
200 i
= decode_erp(buf
[15], buf
[13]);
201 input_report_abs(input_dev
, ABS_HAT1X
, i
);
202 i
= decode_erp(buf
[0], buf
[2]);
203 input_report_abs(input_dev
, ABS_HAT1Y
, i
);
204 i
= decode_erp(buf
[3], buf
[1]);
205 input_report_abs(input_dev
, ABS_HAT2X
, i
);
206 i
= decode_erp(buf
[8], buf
[10]);
207 input_report_abs(input_dev
, ABS_HAT2Y
, i
);
208 i
= decode_erp(buf
[11], buf
[9]);
209 input_report_abs(input_dev
, ABS_HAT3X
, i
);
210 i
= decode_erp(buf
[4], buf
[6]);
211 input_report_abs(input_dev
, ABS_HAT3Y
, i
);
212 input_sync(input_dev
);
217 static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev
*dev
,
218 unsigned char *buf
, unsigned int len
)
220 struct input_dev
*input_dev
= dev
->input_dev
;
221 unsigned short *keycode
= input_dev
->keycode
;
227 if (input_dev
->id
.product
== USB_PID_RIGKONTROL2
)
228 for (i
= 0; i
< len
; i
++)
231 for (i
= 0; i
< input_dev
->keycodemax
&& i
< len
* 8; i
++)
232 input_report_key(input_dev
, keycode
[i
],
233 buf
[i
/ 8] & (1 << (i
% 8)));
235 switch (dev
->chip
.usb_id
) {
236 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_KORECONTROLLER
):
237 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_KORECONTROLLER2
):
238 input_report_abs(dev
->input_dev
, ABS_MISC
, 255 - buf
[4]);
240 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_TRAKTORKONTROLX1
):
241 /* rotary encoders */
242 input_report_abs(dev
->input_dev
, ABS_X
, buf
[5] & 0xf);
243 input_report_abs(dev
->input_dev
, ABS_Y
, buf
[5] >> 4);
244 input_report_abs(dev
->input_dev
, ABS_Z
, buf
[6] & 0xf);
245 input_report_abs(dev
->input_dev
, ABS_MISC
, buf
[6] >> 4);
249 input_sync(input_dev
);
252 static void snd_usb_caiaq_ep4_reply_dispatch(struct urb
*urb
)
254 struct snd_usb_caiaqdev
*dev
= urb
->context
;
255 unsigned char *buf
= urb
->transfer_buffer
;
258 if (urb
->status
|| !dev
|| urb
!= dev
->ep4_in_urb
)
261 if (urb
->actual_length
< 24)
264 switch (dev
->chip
.usb_id
) {
265 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_TRAKTORKONTROLX1
):
267 snd_caiaq_input_read_io(dev
, buf
+ 1, 7);
270 snd_caiaq_input_read_analog(dev
, buf
+ 8, 16);
276 dev
->ep4_in_urb
->actual_length
= 0;
277 ret
= usb_submit_urb(dev
->ep4_in_urb
, GFP_ATOMIC
);
279 log("unable to submit urb. OOM!?\n");
282 static int snd_usb_caiaq_input_open(struct input_dev
*idev
)
284 struct snd_usb_caiaqdev
*dev
= input_get_drvdata(idev
);
289 switch (dev
->chip
.usb_id
) {
290 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_TRAKTORKONTROLX1
):
291 if (usb_submit_urb(dev
->ep4_in_urb
, GFP_KERNEL
) != 0)
299 static void snd_usb_caiaq_input_close(struct input_dev
*idev
)
301 struct snd_usb_caiaqdev
*dev
= input_get_drvdata(idev
);
306 switch (dev
->chip
.usb_id
) {
307 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_TRAKTORKONTROLX1
):
308 usb_kill_urb(dev
->ep4_in_urb
);
313 void snd_usb_caiaq_input_dispatch(struct snd_usb_caiaqdev
*dev
,
317 if (!dev
->input_dev
|| len
< 1)
321 case EP1_CMD_READ_ANALOG
:
322 snd_caiaq_input_read_analog(dev
, buf
+ 1, len
- 1);
324 case EP1_CMD_READ_ERP
:
325 snd_caiaq_input_read_erp(dev
, buf
+ 1, len
- 1);
327 case EP1_CMD_READ_IO
:
328 snd_caiaq_input_read_io(dev
, buf
+ 1, len
- 1);
333 int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev
*dev
)
335 struct usb_device
*usb_dev
= dev
->chip
.dev
;
336 struct input_dev
*input
;
339 input
= input_allocate_device();
343 usb_make_path(usb_dev
, dev
->phys
, sizeof(dev
->phys
));
344 strlcat(dev
->phys
, "/input0", sizeof(dev
->phys
));
346 input
->name
= dev
->product_name
;
347 input
->phys
= dev
->phys
;
348 usb_to_input_id(usb_dev
, &input
->id
);
349 input
->dev
.parent
= &usb_dev
->dev
;
351 input_set_drvdata(input
, dev
);
353 switch (dev
->chip
.usb_id
) {
354 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_RIGKONTROL2
):
355 input
->evbit
[0] = BIT_MASK(EV_KEY
) | BIT_MASK(EV_ABS
);
356 input
->absbit
[0] = BIT_MASK(ABS_X
) | BIT_MASK(ABS_Y
) |
358 BUILD_BUG_ON(sizeof(dev
->keycode
) < sizeof(keycode_rk2
));
359 memcpy(dev
->keycode
, keycode_rk2
, sizeof(keycode_rk2
));
360 input
->keycodemax
= ARRAY_SIZE(keycode_rk2
);
361 input_set_abs_params(input
, ABS_X
, 0, 4096, 0, 10);
362 input_set_abs_params(input
, ABS_Y
, 0, 4096, 0, 10);
363 input_set_abs_params(input
, ABS_Z
, 0, 4096, 0, 10);
364 snd_usb_caiaq_set_auto_msg(dev
, 1, 10, 0);
366 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_RIGKONTROL3
):
367 input
->evbit
[0] = BIT_MASK(EV_KEY
) | BIT_MASK(EV_ABS
);
368 input
->absbit
[0] = BIT_MASK(ABS_X
) | BIT_MASK(ABS_Y
) |
370 BUILD_BUG_ON(sizeof(dev
->keycode
) < sizeof(keycode_rk3
));
371 memcpy(dev
->keycode
, keycode_rk3
, sizeof(keycode_rk3
));
372 input
->keycodemax
= ARRAY_SIZE(keycode_rk3
);
373 input_set_abs_params(input
, ABS_X
, 0, 1024, 0, 10);
374 input_set_abs_params(input
, ABS_Y
, 0, 1024, 0, 10);
375 input_set_abs_params(input
, ABS_Z
, 0, 1024, 0, 10);
376 snd_usb_caiaq_set_auto_msg(dev
, 1, 10, 0);
378 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_AK1
):
379 input
->evbit
[0] = BIT_MASK(EV_KEY
) | BIT_MASK(EV_ABS
);
380 input
->absbit
[0] = BIT_MASK(ABS_X
);
381 BUILD_BUG_ON(sizeof(dev
->keycode
) < sizeof(keycode_ak1
));
382 memcpy(dev
->keycode
, keycode_ak1
, sizeof(keycode_ak1
));
383 input
->keycodemax
= ARRAY_SIZE(keycode_ak1
);
384 input_set_abs_params(input
, ABS_X
, 0, 999, 0, 10);
385 snd_usb_caiaq_set_auto_msg(dev
, 1, 0, 5);
387 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_KORECONTROLLER
):
388 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_KORECONTROLLER2
):
389 input
->evbit
[0] = BIT_MASK(EV_KEY
) | BIT_MASK(EV_ABS
);
390 input
->absbit
[0] = BIT_MASK(ABS_HAT0X
) | BIT_MASK(ABS_HAT0Y
) |
391 BIT_MASK(ABS_HAT1X
) | BIT_MASK(ABS_HAT1Y
) |
392 BIT_MASK(ABS_HAT2X
) | BIT_MASK(ABS_HAT2Y
) |
393 BIT_MASK(ABS_HAT3X
) | BIT_MASK(ABS_HAT3Y
) |
394 BIT_MASK(ABS_X
) | BIT_MASK(ABS_Y
) |
396 input
->absbit
[BIT_WORD(ABS_MISC
)] |= BIT_MASK(ABS_MISC
);
397 BUILD_BUG_ON(sizeof(dev
->keycode
) < sizeof(keycode_kore
));
398 memcpy(dev
->keycode
, keycode_kore
, sizeof(keycode_kore
));
399 input
->keycodemax
= ARRAY_SIZE(keycode_kore
);
400 input_set_abs_params(input
, ABS_HAT0X
, 0, 999, 0, 10);
401 input_set_abs_params(input
, ABS_HAT0Y
, 0, 999, 0, 10);
402 input_set_abs_params(input
, ABS_HAT1X
, 0, 999, 0, 10);
403 input_set_abs_params(input
, ABS_HAT1Y
, 0, 999, 0, 10);
404 input_set_abs_params(input
, ABS_HAT2X
, 0, 999, 0, 10);
405 input_set_abs_params(input
, ABS_HAT2Y
, 0, 999, 0, 10);
406 input_set_abs_params(input
, ABS_HAT3X
, 0, 999, 0, 10);
407 input_set_abs_params(input
, ABS_HAT3Y
, 0, 999, 0, 10);
408 input_set_abs_params(input
, ABS_X
, 0, 4096, 0, 10);
409 input_set_abs_params(input
, ABS_Y
, 0, 4096, 0, 10);
410 input_set_abs_params(input
, ABS_Z
, 0, 4096, 0, 10);
411 input_set_abs_params(input
, ABS_MISC
, 0, 255, 0, 1);
412 snd_usb_caiaq_set_auto_msg(dev
, 1, 10, 5);
414 case USB_ID(USB_VID_NATIVEINSTRUMENTS
, USB_PID_TRAKTORKONTROLX1
):
415 input
->evbit
[0] = BIT_MASK(EV_KEY
) | BIT_MASK(EV_ABS
);
416 input
->absbit
[0] = BIT_MASK(ABS_HAT0X
) | BIT_MASK(ABS_HAT0Y
) |
417 BIT_MASK(ABS_HAT1X
) | BIT_MASK(ABS_HAT1Y
) |
418 BIT_MASK(ABS_HAT2X
) | BIT_MASK(ABS_HAT2Y
) |
419 BIT_MASK(ABS_HAT3X
) | BIT_MASK(ABS_HAT3Y
) |
420 BIT_MASK(ABS_X
) | BIT_MASK(ABS_Y
) |
422 input
->absbit
[BIT_WORD(ABS_MISC
)] |= BIT_MASK(ABS_MISC
);
423 BUILD_BUG_ON(sizeof(dev
->keycode
) < KONTROLX1_INPUTS
);
424 for (i
= 0; i
< KONTROLX1_INPUTS
; i
++)
425 dev
->keycode
[i
] = BTN_MISC
+ i
;
426 input
->keycodemax
= KONTROLX1_INPUTS
;
428 /* analog potentiometers */
429 input_set_abs_params(input
, ABS_HAT0X
, 0, 4096, 0, 10);
430 input_set_abs_params(input
, ABS_HAT0Y
, 0, 4096, 0, 10);
431 input_set_abs_params(input
, ABS_HAT1X
, 0, 4096, 0, 10);
432 input_set_abs_params(input
, ABS_HAT1Y
, 0, 4096, 0, 10);
433 input_set_abs_params(input
, ABS_HAT2X
, 0, 4096, 0, 10);
434 input_set_abs_params(input
, ABS_HAT2Y
, 0, 4096, 0, 10);
435 input_set_abs_params(input
, ABS_HAT3X
, 0, 4096, 0, 10);
436 input_set_abs_params(input
, ABS_HAT3Y
, 0, 4096, 0, 10);
438 /* rotary encoders */
439 input_set_abs_params(input
, ABS_X
, 0, 0xf, 0, 1);
440 input_set_abs_params(input
, ABS_Y
, 0, 0xf, 0, 1);
441 input_set_abs_params(input
, ABS_Z
, 0, 0xf, 0, 1);
442 input_set_abs_params(input
, ABS_MISC
, 0, 0xf, 0, 1);
444 dev
->ep4_in_urb
= usb_alloc_urb(0, GFP_KERNEL
);
445 if (!dev
->ep4_in_urb
) {
450 usb_fill_bulk_urb(dev
->ep4_in_urb
, usb_dev
,
451 usb_rcvbulkpipe(usb_dev
, 0x4),
452 dev
->ep4_in_buf
, EP4_BUFSIZE
,
453 snd_usb_caiaq_ep4_reply_dispatch
, dev
);
455 snd_usb_caiaq_set_auto_msg(dev
, 1, 10, 5);
459 /* no input methods supported on this device */
463 input
->open
= snd_usb_caiaq_input_open
;
464 input
->close
= snd_usb_caiaq_input_close
;
465 input
->keycode
= dev
->keycode
;
466 input
->keycodesize
= sizeof(unsigned short);
467 for (i
= 0; i
< input
->keycodemax
; i
++)
468 __set_bit(dev
->keycode
[i
], input
->keybit
);
470 ret
= input_register_device(input
);
474 dev
->input_dev
= input
;
478 input_free_device(input
);
482 void snd_usb_caiaq_input_free(struct snd_usb_caiaqdev
*dev
)
484 if (!dev
|| !dev
->input_dev
)
487 usb_kill_urb(dev
->ep4_in_urb
);
488 usb_free_urb(dev
->ep4_in_urb
);
489 dev
->ep4_in_urb
= NULL
;
491 input_unregister_device(dev
->input_dev
);
492 dev
->input_dev
= NULL
;