Commit | Line | Data |
---|---|---|
523f1dce DM |
1 | /* |
2 | * Copyright (c) 2006,2007 Daniel Mack, Tim Ruetz | |
3 | * | |
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. | |
8 | * | |
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. | |
13 | * | |
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 | |
17 | */ | |
18 | ||
19 | #include <linux/init.h> | |
523f1dce | 20 | #include <linux/usb.h> |
b18b493f | 21 | #include <linux/usb/input.h> |
6da7a2aa | 22 | #include <sound/core.h> |
523f1dce | 23 | #include <sound/pcm.h> |
936e7d03 DM |
24 | |
25 | #include "device.h" | |
26 | #include "input.h" | |
523f1dce | 27 | |
b18b493f DT |
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 }; | |
523f1dce | 33 | |
8e3cd08e DM |
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. */ | |
43 | KEY_RIGHT, | |
44 | KEY_DOWN, | |
45 | KEY_UP, | |
46 | KEY_LEFT, | |
47 | KEY_SOUND, /* "listen" */ | |
48 | KEY_RECORD, | |
49 | KEY_PLAYPAUSE, | |
50 | KEY_STOP, | |
51 | BTN_4, /* 8 softkeys */ | |
52 | BTN_3, | |
53 | BTN_2, | |
54 | BTN_1, | |
55 | BTN_8, | |
56 | BTN_7, | |
57 | BTN_6, | |
58 | BTN_5, | |
59 | KEY_BRL_DOT4, /* touch sensitive knobs */ | |
60 | KEY_BRL_DOT3, | |
61 | KEY_BRL_DOT2, | |
62 | KEY_BRL_DOT1, | |
63 | KEY_BRL_DOT8, | |
64 | KEY_BRL_DOT7, | |
65 | KEY_BRL_DOT6, | |
66 | KEY_BRL_DOT5 | |
67 | }; | |
68 | ||
6da7a2aa DM |
69 | #define KONTROLX1_INPUTS 40 |
70 | ||
b18b493f DT |
71 | #define DEG90 (range / 2) |
72 | #define DEG180 (range) | |
73 | #define DEG270 (DEG90 + DEG180) | |
74 | #define DEG360 (DEG180 * 2) | |
75 | #define HIGH_PEAK (268) | |
76 | #define LOW_PEAK (-7) | |
523f1dce DM |
77 | |
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 | |
81 | * from 0 to 999 */ | |
82 | static unsigned int decode_erp(unsigned char a, unsigned char b) | |
83 | { | |
84 | int weight_a, weight_b; | |
85 | int pos_a, pos_b; | |
86 | int ret; | |
87 | int range = HIGH_PEAK - LOW_PEAK; | |
88 | int mid_value = (HIGH_PEAK + LOW_PEAK) / 2; | |
89 | ||
b18b493f DT |
90 | weight_b = abs(mid_value - a) - (range / 2 - 100) / 2; |
91 | ||
523f1dce DM |
92 | if (weight_b < 0) |
93 | weight_b = 0; | |
94 | ||
95 | if (weight_b > 100) | |
96 | weight_b = 100; | |
97 | ||
98 | weight_a = 100 - weight_b; | |
99 | ||
100 | if (a < mid_value) { | |
101 | /* 0..90 and 270..360 degrees */ | |
102 | pos_b = b - LOW_PEAK + DEG270; | |
103 | if (pos_b >= DEG360) | |
104 | pos_b -= DEG360; | |
105 | } else | |
106 | /* 90..270 degrees */ | |
107 | pos_b = HIGH_PEAK - b + DEG90; | |
108 | ||
109 | ||
110 | if (b > mid_value) | |
111 | /* 0..180 degrees */ | |
112 | pos_a = a - LOW_PEAK; | |
113 | else | |
114 | /* 180..360 degrees */ | |
115 | pos_a = HIGH_PEAK - a + DEG180; | |
116 | ||
117 | /* interpolate both slider values, depending on weight factors */ | |
118 | /* 0..99 x DEG360 */ | |
119 | ret = pos_a * weight_a + pos_b * weight_b; | |
120 | ||
121 | /* normalize to 0..999 */ | |
122 | ret *= 10; | |
123 | ret /= DEG360; | |
124 | ||
125 | if (ret < 0) | |
126 | ret += 1000; | |
b18b493f | 127 | |
523f1dce DM |
128 | if (ret >= 1000) |
129 | ret -= 1000; | |
130 | ||
131 | return ret; | |
132 | } | |
133 | ||
134 | #undef DEG90 | |
135 | #undef DEG180 | |
136 | #undef DEG270 | |
137 | #undef DEG360 | |
138 | #undef HIGH_PEAK | |
139 | #undef LOW_PEAK | |
140 | ||
141 | ||
b18b493f | 142 | static void snd_caiaq_input_read_analog(struct snd_usb_caiaqdev *dev, |
ad1e34b5 DM |
143 | const unsigned char *buf, |
144 | unsigned int len) | |
523f1dce | 145 | { |
b18b493f DT |
146 | struct input_dev *input_dev = dev->input_dev; |
147 | ||
8e3cd08e DM |
148 | switch (dev->chip.usb_id) { |
149 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2): | |
b18b493f DT |
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); | |
523f1dce | 154 | break; |
8e3cd08e DM |
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); | |
160 | break; | |
161 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER): | |
7829d0ec | 162 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2): |
b18b493f DT |
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); | |
ad1e34b5 | 167 | break; |
6da7a2aa DM |
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); | |
178 | break; | |
523f1dce DM |
179 | } |
180 | } | |
181 | ||
b18b493f | 182 | static void snd_caiaq_input_read_erp(struct snd_usb_caiaqdev *dev, |
523f1dce DM |
183 | const char *buf, unsigned int len) |
184 | { | |
b18b493f | 185 | struct input_dev *input_dev = dev->input_dev; |
523f1dce DM |
186 | int i; |
187 | ||
8e3cd08e DM |
188 | switch (dev->chip.usb_id) { |
189 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1): | |
523f1dce | 190 | i = decode_erp(buf[0], buf[1]); |
b18b493f DT |
191 | input_report_abs(input_dev, ABS_X, i); |
192 | input_sync(input_dev); | |
523f1dce | 193 | break; |
8e3cd08e | 194 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER): |
7829d0ec | 195 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2): |
8e3cd08e DM |
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); | |
213 | break; | |
523f1dce DM |
214 | } |
215 | } | |
216 | ||
b18b493f | 217 | static void snd_caiaq_input_read_io(struct snd_usb_caiaqdev *dev, |
6da7a2aa | 218 | unsigned char *buf, unsigned int len) |
523f1dce | 219 | { |
b18b493f DT |
220 | struct input_dev *input_dev = dev->input_dev; |
221 | unsigned short *keycode = input_dev->keycode; | |
523f1dce | 222 | int i; |
523f1dce DM |
223 | |
224 | if (!keycode) | |
225 | return; | |
226 | ||
b18b493f DT |
227 | if (input_dev->id.product == USB_PID_RIGKONTROL2) |
228 | for (i = 0; i < len; i++) | |
523f1dce DM |
229 | buf[i] = ~buf[i]; |
230 | ||
8e3cd08e | 231 | for (i = 0; i < input_dev->keycodemax && i < len * 8; i++) |
b18b493f DT |
232 | input_report_key(input_dev, keycode[i], |
233 | buf[i / 8] & (1 << (i % 8))); | |
523f1dce | 234 | |
6da7a2aa DM |
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): | |
8e3cd08e | 238 | input_report_abs(dev->input_dev, ABS_MISC, 255 - buf[4]); |
6da7a2aa DM |
239 | break; |
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); | |
246 | break; | |
247 | } | |
8e3cd08e | 248 | |
b18b493f | 249 | input_sync(input_dev); |
523f1dce DM |
250 | } |
251 | ||
6da7a2aa DM |
252 | static void snd_usb_caiaq_ep4_reply_dispatch(struct urb *urb) |
253 | { | |
254 | struct snd_usb_caiaqdev *dev = urb->context; | |
255 | unsigned char *buf = urb->transfer_buffer; | |
256 | int ret; | |
257 | ||
258 | if (urb->status || !dev || urb != dev->ep4_in_urb) | |
259 | return; | |
260 | ||
261 | if (urb->actual_length < 24) | |
262 | goto requeue; | |
263 | ||
264 | switch (dev->chip.usb_id) { | |
265 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): | |
266 | if (buf[0] & 0x3) | |
267 | snd_caiaq_input_read_io(dev, buf + 1, 7); | |
268 | ||
269 | if (buf[0] & 0x4) | |
270 | snd_caiaq_input_read_analog(dev, buf + 8, 16); | |
271 | ||
272 | break; | |
273 | } | |
274 | ||
275 | requeue: | |
276 | dev->ep4_in_urb->actual_length = 0; | |
277 | ret = usb_submit_urb(dev->ep4_in_urb, GFP_ATOMIC); | |
278 | if (ret < 0) | |
279 | log("unable to submit urb. OOM!?\n"); | |
280 | } | |
281 | ||
282 | static int snd_usb_caiaq_input_open(struct input_dev *idev) | |
283 | { | |
284 | struct snd_usb_caiaqdev *dev = input_get_drvdata(idev); | |
285 | ||
286 | if (!dev) | |
287 | return -EINVAL; | |
288 | ||
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) | |
292 | return -EIO; | |
293 | break; | |
294 | } | |
295 | ||
296 | return 0; | |
297 | } | |
298 | ||
299 | static void snd_usb_caiaq_input_close(struct input_dev *idev) | |
300 | { | |
301 | struct snd_usb_caiaqdev *dev = input_get_drvdata(idev); | |
302 | ||
303 | if (!dev) | |
304 | return; | |
305 | ||
306 | switch (dev->chip.usb_id) { | |
307 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_TRAKTORKONTROLX1): | |
308 | usb_kill_urb(dev->ep4_in_urb); | |
309 | break; | |
310 | } | |
311 | } | |
312 | ||
b18b493f DT |
313 | void snd_usb_caiaq_input_dispatch(struct snd_usb_caiaqdev *dev, |
314 | char *buf, | |
523f1dce DM |
315 | unsigned int len) |
316 | { | |
b18b493f | 317 | if (!dev->input_dev || len < 1) |
523f1dce DM |
318 | return; |
319 | ||
320 | switch (buf[0]) { | |
321 | case EP1_CMD_READ_ANALOG: | |
b18b493f | 322 | snd_caiaq_input_read_analog(dev, buf + 1, len - 1); |
523f1dce DM |
323 | break; |
324 | case EP1_CMD_READ_ERP: | |
b18b493f | 325 | snd_caiaq_input_read_erp(dev, buf + 1, len - 1); |
523f1dce DM |
326 | break; |
327 | case EP1_CMD_READ_IO: | |
b18b493f | 328 | snd_caiaq_input_read_io(dev, buf + 1, len - 1); |
523f1dce DM |
329 | break; |
330 | } | |
331 | } | |
332 | ||
333 | int snd_usb_caiaq_input_init(struct snd_usb_caiaqdev *dev) | |
334 | { | |
335 | struct usb_device *usb_dev = dev->chip.dev; | |
336 | struct input_dev *input; | |
6da7a2aa | 337 | int i, ret = 0; |
523f1dce DM |
338 | |
339 | input = input_allocate_device(); | |
340 | if (!input) | |
341 | return -ENOMEM; | |
342 | ||
b18b493f DT |
343 | usb_make_path(usb_dev, dev->phys, sizeof(dev->phys)); |
344 | strlcat(dev->phys, "/input0", sizeof(dev->phys)); | |
345 | ||
523f1dce | 346 | input->name = dev->product_name; |
b18b493f DT |
347 | input->phys = dev->phys; |
348 | usb_to_input_id(usb_dev, &input->id); | |
349 | input->dev.parent = &usb_dev->dev; | |
523f1dce | 350 | |
6da7a2aa DM |
351 | input_set_drvdata(input, dev); |
352 | ||
353 | switch (dev->chip.usb_id) { | |
523f1dce | 354 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL2): |
7b19ada2 JS |
355 | input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); |
356 | input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) | | |
357 | BIT_MASK(ABS_Z); | |
b18b493f DT |
358 | BUILD_BUG_ON(sizeof(dev->keycode) < sizeof(keycode_rk2)); |
359 | memcpy(dev->keycode, keycode_rk2, sizeof(keycode_rk2)); | |
523f1dce | 360 | input->keycodemax = ARRAY_SIZE(keycode_rk2); |
523f1dce DM |
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); | |
365 | break; | |
ad1e34b5 | 366 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_RIGKONTROL3): |
8e3cd08e DM |
367 | input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); |
368 | input->absbit[0] = BIT_MASK(ABS_X) | BIT_MASK(ABS_Y) | | |
369 | BIT_MASK(ABS_Z); | |
b18b493f DT |
370 | BUILD_BUG_ON(sizeof(dev->keycode) < sizeof(keycode_rk3)); |
371 | memcpy(dev->keycode, keycode_rk3, sizeof(keycode_rk3)); | |
ad1e34b5 | 372 | input->keycodemax = ARRAY_SIZE(keycode_rk3); |
ad1e34b5 DM |
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); | |
377 | break; | |
523f1dce | 378 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_AK1): |
7b19ada2 JS |
379 | input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); |
380 | input->absbit[0] = BIT_MASK(ABS_X); | |
b18b493f DT |
381 | BUILD_BUG_ON(sizeof(dev->keycode) < sizeof(keycode_ak1)); |
382 | memcpy(dev->keycode, keycode_ak1, sizeof(keycode_ak1)); | |
523f1dce | 383 | input->keycodemax = ARRAY_SIZE(keycode_ak1); |
523f1dce DM |
384 | input_set_abs_params(input, ABS_X, 0, 999, 0, 10); |
385 | snd_usb_caiaq_set_auto_msg(dev, 1, 0, 5); | |
386 | break; | |
8e3cd08e | 387 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER): |
7829d0ec | 388 | case USB_ID(USB_VID_NATIVEINSTRUMENTS, USB_PID_KORECONTROLLER2): |
8e3cd08e DM |
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) | | |
395 | BIT_MASK(ABS_Z); | |
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); | |
6da7a2aa DM |
413 | break; |
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) | | |
421 | BIT_MASK(ABS_Z); | |
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; | |
427 | ||
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); | |
437 | ||
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); | |
443 | ||
444 | dev->ep4_in_urb = usb_alloc_urb(0, GFP_KERNEL); | |
445 | if (!dev->ep4_in_urb) { | |
446 | ret = -ENOMEM; | |
447 | goto exit_free_idev; | |
448 | } | |
449 | ||
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); | |
454 | ||
455 | snd_usb_caiaq_set_auto_msg(dev, 1, 10, 5); | |
456 | ||
8e3cd08e | 457 | break; |
523f1dce DM |
458 | default: |
459 | /* no input methods supported on this device */ | |
6da7a2aa | 460 | goto exit_free_idev; |
523f1dce DM |
461 | } |
462 | ||
6da7a2aa DM |
463 | input->open = snd_usb_caiaq_input_open; |
464 | input->close = snd_usb_caiaq_input_close; | |
b18b493f DT |
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); | |
469 | ||
523f1dce | 470 | ret = input_register_device(input); |
6da7a2aa DM |
471 | if (ret < 0) |
472 | goto exit_free_idev; | |
523f1dce DM |
473 | |
474 | dev->input_dev = input; | |
475 | return 0; | |
6da7a2aa DM |
476 | |
477 | exit_free_idev: | |
478 | input_free_device(input); | |
479 | return ret; | |
523f1dce DM |
480 | } |
481 | ||
482 | void snd_usb_caiaq_input_free(struct snd_usb_caiaqdev *dev) | |
483 | { | |
484 | if (!dev || !dev->input_dev) | |
485 | return; | |
486 | ||
6da7a2aa DM |
487 | usb_kill_urb(dev->ep4_in_urb); |
488 | usb_free_urb(dev->ep4_in_urb); | |
489 | dev->ep4_in_urb = NULL; | |
490 | ||
523f1dce | 491 | input_unregister_device(dev->input_dev); |
523f1dce DM |
492 | dev->input_dev = NULL; |
493 | } | |
494 |