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/module.h>
21 #include <linux/moduleparam.h>
22 #include <linux/input.h>
23 #include <linux/usb.h>
24 #include <linux/usb/input.h>
25 #include <linux/spinlock.h>
26 #include <sound/driver.h>
27 #include <sound/core.h>
28 #include <sound/rawmidi.h>
29 #include <sound/pcm.h>
30 #include "caiaq-device.h"
31 #include "caiaq-input.h"
33 #ifdef CONFIG_SND_USB_CAIAQ_INPUT
35 static unsigned short keycode_ak1[] = { KEY_C, KEY_B, KEY_A };
36 static unsigned short keycode_rk2[] = { KEY_1, KEY_2, KEY_3, KEY_4,
37 KEY_5, KEY_6, KEY_7 };
38 static unsigned short keycode_rk3[] = { KEY_1, KEY_2, KEY_3, KEY_4,
39 KEY_5, KEY_6, KEY_7, KEY_5, KEY_6 };
41 static unsigned short keycode_kore[] = {
42 KEY_FN_F1, /* "menu" */
43 KEY_FN_F7, /* "lcd backlight */
44 KEY_FN_F2, /* "control" */
45 KEY_FN_F3, /* "enter" */
46 KEY_FN_F4, /* "view" */
47 KEY_FN_F5, /* "esc" */
48 KEY_FN_F6, /* "sound" */
49 KEY_FN_F8, /* array spacer, never triggered. */
54 KEY_SOUND, /* "listen" */
58 BTN_4, /* 8 softkeys */
66 KEY_BRL_DOT4, /* touch sensitive knobs */
76 #define DEG90 (range / 2)
77 #define DEG180 (range)
78 #define DEG270 (DEG90 + DEG180)
79 #define DEG360 (DEG180 * 2)
80 #define HIGH_PEAK (268)
83 /* some of these devices have endless rotation potentiometers
84 * built in which use two tapers, 90 degrees phase shifted.
85 * this algorithm decodes them to one single value, ranging
87 static unsigned int decode_erp(unsigned char a, unsigned char b)
89 int weight_a, weight_b;
92 int range = HIGH_PEAK - LOW_PEAK;
93 int mid_value = (HIGH_PEAK + LOW_PEAK) / 2;
95 weight_b = abs(mid_value - a) - (range / 2 - 100) / 2;
103 weight_a = 100 - weight_b;
106 /* 0..90 and 270..360 degrees */
107 pos_b = b - LOW_PEAK + DEG270;
111 /* 90..270 degrees */
112 pos_b = HIGH_PEAK - b + DEG90;
117 pos_a = a - LOW_PEAK;
119 /* 180..360 degrees */
120 pos_a = HIGH_PEAK - a + DEG180;
122 /* interpolate both slider values, depending on weight factors */
124 ret = pos_a * weight_a + pos_b * weight_b;
126 /* normalize to 0..999 */
147 static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev *dev,
148 const unsigned char *buf,
151 struct input_dev *input_dev = dev->input_dev;
153 switch (dev->chip.usb_id) {
154 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2):
155 input_report_abs(input_dev, ABS_X, (buf[4] << 8) | buf[5]);
156 input_report_abs(input_dev, ABS_Y, (buf[0] << 8) | buf[1]);
157 input_report_abs(input_dev, ABS_Z, (buf[2] << 8) | buf[3]);
158 input_sync(input_dev);
160 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
161 input_report_abs(input_dev, ABS_X, (buf[0] << 8) | buf[1]);
162 input_report_abs(input_dev, ABS_Y, (buf[2] << 8) | buf[3]);
163 input_report_abs(input_dev, ABS_Z, (buf[4] << 8) | buf[5]);
164 input_sync(input_dev);
166 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
167 input_report_abs(input_dev, ABS_X, (buf[0] << 8) | buf[1]);
168 input_report_abs(input_dev, ABS_Y, (buf[2] << 8) | buf[3]);
169 input_report_abs(input_dev, ABS_Z, (buf[4] << 8) | buf[5]);
170 input_sync(input_dev);
175 static void snd_caiaq_input_read_erp(struct snd_usb_caiaqdev *dev,
176 const char *buf, unsigned int len)
178 struct input_dev *input_dev = dev->input_dev;
181 switch (dev->chip.usb_id) {
182 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
183 i = decode_erp(buf[0], buf[1]);
184 input_report_abs(input_dev, ABS_X, i);
185 input_sync(input_dev);
187 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
188 i = decode_erp(buf[7], buf[5]);
189 input_report_abs(input_dev, ABS_HAT0X, i);
190 i = decode_erp(buf[12], buf[14]);
191 input_report_abs(input_dev, ABS_HAT0Y, i);
192 i = decode_erp(buf[15], buf[13]);
193 input_report_abs(input_dev, ABS_HAT1X, i);
194 i = decode_erp(buf[0], buf[2]);
195 input_report_abs(input_dev, ABS_HAT1Y, i);
196 i = decode_erp(buf[3], buf[1]);
197 input_report_abs(input_dev, ABS_HAT2X, i);
198 i = decode_erp(buf[8], buf[10]);
199 input_report_abs(input_dev, ABS_HAT2Y, i);
200 i = decode_erp(buf[11], buf[9]);
201 input_report_abs(input_dev, ABS_HAT3X, i);
202 i = decode_erp(buf[4], buf[6]);
203 input_report_abs(input_dev, ABS_HAT3Y, i);
204 input_sync(input_dev);
209 static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev *dev,
210 char *buf, unsigned int len)
212 struct input_dev *input_dev = dev->input_dev;
213 unsigned short *keycode = input_dev->keycode;
219 if (input_dev->id.product == USB_PID_RIGKONTROL2)
220 for (i = 0; i < len; i++)
223 for (i = 0; i < input_dev->keycodemax && i < len * 8; i++)
224 input_report_key(input_dev, keycode[i],
225 buf[i / 8] & (1 << (i % 8)));
227 if (dev->chip.usb_id ==
228 USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER))
229 input_report_abs(dev->input_dev, ABS_MISC, 255 - buf[4]);
231 input_sync(input_dev);
234 void snd_usb_caiaq_input_dispatch(struct snd_usb_caiaqdev *dev,
238 if (!dev->input_dev || len < 1)
242 case EP1_CMD_READ_ANALOG:
243 snd_caiaq_input_read_analog(dev, buf + 1, len - 1);
245 case EP1_CMD_READ_ERP:
246 snd_caiaq_input_read_erp(dev, buf + 1, len - 1);
248 case EP1_CMD_READ_IO:
249 snd_caiaq_input_read_io(dev, buf + 1, len - 1);
254 int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *dev)
256 struct usb_device *usb_dev = dev->chip.dev;
257 struct input_dev *input;
260 input = input_allocate_device();
264 usb_make_path(usb_dev, dev->phys, sizeof(dev->phys));
265 strlcat(dev->phys, "/input0", sizeof(dev->phys));
267 input->name = dev->product_name;
268 input->phys = dev->phys;
269 usb_to_input_id(usb_dev, &input->id);
270 input->dev.parent = &usb_dev->dev;
272 switch (dev->chip.usb_id) {
273 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2):
274 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
275 input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
277 BUILD_BUG_ON(sizeof(dev->keycode) < sizeof(keycode_rk2));
278 memcpy(dev->keycode, keycode_rk2, sizeof(keycode_rk2));
279 input->keycodemax = ARRAY_SIZE(keycode_rk2);
280 input_set_abs_params(input, ABS_X, 0, 4096, 0, 10);
281 input_set_abs_params(input, ABS_Y, 0, 4096, 0, 10);
282 input_set_abs_params(input, ABS_Z, 0, 4096, 0, 10);
283 snd_usb_caiaq_set_auto_msg(dev, 1, 10, 0);
285 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3):
286 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
287 input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
289 BUILD_BUG_ON(sizeof(dev->keycode) < sizeof(keycode_rk3));
290 memcpy(dev->keycode, keycode_rk3, sizeof(keycode_rk3));
291 input->keycodemax = ARRAY_SIZE(keycode_rk3);
292 input_set_abs_params(input, ABS_X, 0, 1024, 0, 10);
293 input_set_abs_params(input, ABS_Y, 0, 1024, 0, 10);
294 input_set_abs_params(input, ABS_Z, 0, 1024, 0, 10);
295 snd_usb_caiaq_set_auto_msg(dev, 1, 10, 0);
297 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1):
298 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
299 input->absbit[0] = BIT_MASK(ABS_X);
300 BUILD_BUG_ON(sizeof(dev->keycode) < sizeof(keycode_ak1));
301 memcpy(dev->keycode, keycode_ak1, sizeof(keycode_ak1));
302 input->keycodemax = ARRAY_SIZE(keycode_ak1);
303 input_set_abs_params(input, ABS_X, 0, 999, 0, 10);
304 snd_usb_caiaq_set_auto_msg(dev, 1, 0, 5);
306 case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER):
307 input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
308 input->absbit[0] = BIT_MASK(ABS_HAT0X) | BIT_MASK(ABS_HAT0Y) |
309 BIT_MASK(ABS_HAT1X) | BIT_MASK(ABS_HAT1Y) |
310 BIT_MASK(ABS_HAT2X) | BIT_MASK(ABS_HAT2Y) |
311 BIT_MASK(ABS_HAT3X) | BIT_MASK(ABS_HAT3Y) |
312 BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) |
314 input->absbit[BIT_WORD(ABS_MISC)] |= BIT_MASK(ABS_MISC);
315 BUILD_BUG_ON(sizeof(dev->keycode) < sizeof(keycode_kore));
316 memcpy(dev->keycode, keycode_kore, sizeof(keycode_kore));
317 input->keycodemax = ARRAY_SIZE(keycode_kore);
318 input_set_abs_params(input, ABS_HAT0X, 0, 999, 0, 10);
319 input_set_abs_params(input, ABS_HAT0Y, 0, 999, 0, 10);
320 input_set_abs_params(input, ABS_HAT1X, 0, 999, 0, 10);
321 input_set_abs_params(input, ABS_HAT1Y, 0, 999, 0, 10);
322 input_set_abs_params(input, ABS_HAT2X, 0, 999, 0, 10);
323 input_set_abs_params(input, ABS_HAT2Y, 0, 999, 0, 10);
324 input_set_abs_params(input, ABS_HAT3X, 0, 999, 0, 10);
325 input_set_abs_params(input, ABS_HAT3Y, 0, 999, 0, 10);
326 input_set_abs_params(input, ABS_X, 0, 4096, 0, 10);
327 input_set_abs_params(input, ABS_Y, 0, 4096, 0, 10);
328 input_set_abs_params(input, ABS_Z, 0, 4096, 0, 10);
329 input_set_abs_params(input, ABS_MISC, 0, 255, 0, 1);
330 snd_usb_caiaq_set_auto_msg(dev, 1, 10, 5);
333 /* no input methods supported on this device */
334 input_free_device(input);
338 input->keycode = dev->keycode;
339 input->keycodesize = sizeof(unsigned short);
340 for (i = 0; i < input->keycodemax; i++)
341 __set_bit(dev->keycode[i], input->keybit);
343 ret = input_register_device(input);
345 input_free_device(input);
349 dev->input_dev = input;
353 void snd_usb_caiaq_input_free(struct snd_usb_caiaqdev *dev)
355 if (!dev || !dev->input_dev)
358 input_unregister_device(dev->input_dev);
359 dev->input_dev = NULL;
362 #endif /* CONFIG_SND_USB_CAIAQ_INPUT */