1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Copyright (C) 2007, 2008 Karsten Wiese <fzu@wemgehoertderstaat.de>
4 */
5
6 #include <linux/slab.h>
7 #include <linux/usb.h>
8 #include <linux/usb/audio.h>
9 #include <linux/module.h>
10 #include <sound/core.h>
11 #include <sound/hwdep.h>
12 #include <sound/pcm.h>
13 #include <sound/initval.h>
14 #define MODNAME "US122L"
15 #include "usb_stream.c"
16 #include "../usbaudio.h"
17 #include "../midi.h"
18 #include "us122l.h"
19
20 MODULE_AUTHOR("Karsten Wiese <fzu@wemgehoertderstaat.de>");
21 MODULE_DESCRIPTION("TASCAM "NAME_ALLCAPS" Version 0.5");
22 MODULE_LICENSE("GPL");
23
24 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-max */
25 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* Id for this card */
26 /* Enable this card */
27 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
28
29 module_param_array(index, int, NULL, 0444);
30 MODULE_PARM_DESC(index, "Index value for "NAME_ALLCAPS".");
31 module_param_array(id, charp, NULL, 0444);
32 MODULE_PARM_DESC(id, "ID string for "NAME_ALLCAPS".");
33 module_param_array(enable, bool, NULL, 0444);
34 MODULE_PARM_DESC(enable, "Enable "NAME_ALLCAPS".");
35
36 /* driver_info flags */
37 #define US122L_FLAG_US144 BIT(0)
38
39 static int snd_us122l_card_used[SNDRV_CARDS];
40
us122l_create_usbmidi(struct snd_card * card)41 static int us122l_create_usbmidi(struct snd_card *card)
42 {
43 static const struct snd_usb_midi_endpoint_info quirk_data = {
44 .out_ep = 4,
45 .in_ep = 3,
46 .out_cables = 0x001,
47 .in_cables = 0x001
48 };
49 static const struct snd_usb_audio_quirk quirk = {
50 .vendor_name = "US122L",
51 .product_name = NAME_ALLCAPS,
52 .ifnum = 1,
53 .type = QUIRK_MIDI_US122L,
54 .data = &quirk_data
55 };
56 struct usb_device *dev = US122L(card)->dev;
57 struct usb_interface *iface = usb_ifnum_to_if(dev, 1);
58
59 return snd_usbmidi_create(card, iface,
60 &US122L(card)->midi_list, &quirk);
61 }
62
us144_create_usbmidi(struct snd_card * card)63 static int us144_create_usbmidi(struct snd_card *card)
64 {
65 static const struct snd_usb_midi_endpoint_info quirk_data = {
66 .out_ep = 4,
67 .in_ep = 3,
68 .out_cables = 0x001,
69 .in_cables = 0x001
70 };
71 static const struct snd_usb_audio_quirk quirk = {
72 .vendor_name = "US144",
73 .product_name = NAME_ALLCAPS,
74 .ifnum = 0,
75 .type = QUIRK_MIDI_US122L,
76 .data = &quirk_data
77 };
78 struct usb_device *dev = US122L(card)->dev;
79 struct usb_interface *iface = usb_ifnum_to_if(dev, 0);
80
81 return snd_usbmidi_create(card, iface,
82 &US122L(card)->midi_list, &quirk);
83 }
84
pt_info_set(struct usb_device * dev,u8 v)85 static void pt_info_set(struct usb_device *dev, u8 v)
86 {
87 usb_control_msg_send(dev, 0, 'I',
88 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
89 v, 0, NULL, 0, 1000, GFP_NOIO);
90 }
91
usb_stream_hwdep_vm_fault(struct vm_fault * vmf)92 static vm_fault_t usb_stream_hwdep_vm_fault(struct vm_fault *vmf)
93 {
94 unsigned long offset;
95 struct page *page;
96 void *vaddr;
97 struct us122l *us122l = vmf->vma->vm_private_data;
98 struct usb_stream *s;
99
100 mutex_lock(&us122l->mutex);
101 s = us122l->sk.s;
102 if (!s)
103 goto unlock;
104
105 offset = vmf->pgoff << PAGE_SHIFT;
106 if (offset < PAGE_ALIGN(s->read_size)) {
107 vaddr = (char *)s + offset;
108 } else {
109 offset -= PAGE_ALIGN(s->read_size);
110 if (offset >= PAGE_ALIGN(s->write_size))
111 goto unlock;
112
113 vaddr = us122l->sk.write_page + offset;
114 }
115 page = virt_to_page(vaddr);
116
117 get_page(page);
118 mutex_unlock(&us122l->mutex);
119
120 vmf->page = page;
121
122 return 0;
123 unlock:
124 mutex_unlock(&us122l->mutex);
125 return VM_FAULT_SIGBUS;
126 }
127
128
129 static const struct vm_operations_struct usb_stream_hwdep_vm_ops = {
130 .fault = usb_stream_hwdep_vm_fault,
131 };
132
usb_stream_hwdep_open(struct snd_hwdep * hw,struct file * file)133 static int usb_stream_hwdep_open(struct snd_hwdep *hw, struct file *file)
134 {
135 struct us122l *us122l = hw->private_data;
136 struct usb_interface *iface;
137
138 if (hw->used >= 2)
139 return -EBUSY;
140
141 if (!us122l->first)
142 us122l->first = file;
143
144 if (us122l->is_us144) {
145 iface = usb_ifnum_to_if(us122l->dev, 0);
146 usb_autopm_get_interface(iface);
147 }
148 iface = usb_ifnum_to_if(us122l->dev, 1);
149 usb_autopm_get_interface(iface);
150 return 0;
151 }
152
usb_stream_hwdep_release(struct snd_hwdep * hw,struct file * file)153 static int usb_stream_hwdep_release(struct snd_hwdep *hw, struct file *file)
154 {
155 struct us122l *us122l = hw->private_data;
156 struct usb_interface *iface;
157
158 if (us122l->is_us144) {
159 iface = usb_ifnum_to_if(us122l->dev, 0);
160 usb_autopm_put_interface(iface);
161 }
162 iface = usb_ifnum_to_if(us122l->dev, 1);
163 usb_autopm_put_interface(iface);
164 if (us122l->first == file)
165 us122l->first = NULL;
166 mutex_lock(&us122l->mutex);
167 if (us122l->master == file)
168 us122l->master = us122l->slave;
169
170 us122l->slave = NULL;
171 mutex_unlock(&us122l->mutex);
172 return 0;
173 }
174
usb_stream_hwdep_mmap(struct snd_hwdep * hw,struct file * filp,struct vm_area_struct * area)175 static int usb_stream_hwdep_mmap(struct snd_hwdep *hw,
176 struct file *filp, struct vm_area_struct *area)
177 {
178 unsigned long size = area->vm_end - area->vm_start;
179 struct us122l *us122l = hw->private_data;
180 unsigned long offset;
181 struct usb_stream *s;
182 int err = 0;
183 bool read;
184
185 offset = area->vm_pgoff << PAGE_SHIFT;
186 mutex_lock(&us122l->mutex);
187 s = us122l->sk.s;
188 read = offset < s->read_size;
189 if (read && area->vm_flags & VM_WRITE) {
190 err = -EPERM;
191 goto out;
192 }
193 /* if userspace tries to mmap beyond end of our buffer, fail */
194 if (size > PAGE_ALIGN(read ? s->read_size : s->write_size)) {
195 dev_warn(hw->card->dev, "%s: size %lu > %u\n", __func__,
196 size, read ? s->read_size : s->write_size);
197 err = -EINVAL;
198 goto out;
199 }
200
201 area->vm_ops = &usb_stream_hwdep_vm_ops;
202 vm_flags_set(area, VM_DONTDUMP);
203 if (!read)
204 vm_flags_set(area, VM_DONTEXPAND);
205 area->vm_private_data = us122l;
206 out:
207 mutex_unlock(&us122l->mutex);
208 return err;
209 }
210
usb_stream_hwdep_poll(struct snd_hwdep * hw,struct file * file,poll_table * wait)211 static __poll_t usb_stream_hwdep_poll(struct snd_hwdep *hw,
212 struct file *file, poll_table *wait)
213 {
214 struct us122l *us122l = hw->private_data;
215 unsigned int *polled;
216 __poll_t mask;
217
218 poll_wait(file, &us122l->sk.sleep, wait);
219
220 mask = EPOLLIN | EPOLLOUT | EPOLLWRNORM | EPOLLERR;
221 if (mutex_trylock(&us122l->mutex)) {
222 struct usb_stream *s = us122l->sk.s;
223
224 if (s && s->state == usb_stream_ready) {
225 if (us122l->first == file)
226 polled = &s->periods_polled;
227 else
228 polled = &us122l->second_periods_polled;
229 if (*polled != s->periods_done) {
230 *polled = s->periods_done;
231 mask = EPOLLIN | EPOLLOUT | EPOLLWRNORM;
232 } else {
233 mask = 0;
234 }
235 }
236 mutex_unlock(&us122l->mutex);
237 }
238 return mask;
239 }
240
us122l_stop(struct us122l * us122l)241 static void us122l_stop(struct us122l *us122l)
242 {
243 struct list_head *p;
244
245 list_for_each(p, &us122l->midi_list)
246 snd_usbmidi_input_stop(p);
247
248 usb_stream_stop(&us122l->sk);
249 usb_stream_free(&us122l->sk);
250 }
251
us122l_set_sample_rate(struct usb_device * dev,int rate)252 static int us122l_set_sample_rate(struct usb_device *dev, int rate)
253 {
254 unsigned int ep = 0x81;
255 unsigned char data[3];
256 int err;
257
258 data[0] = rate;
259 data[1] = rate >> 8;
260 data[2] = rate >> 16;
261 err = usb_control_msg_send(dev, 0, UAC_SET_CUR,
262 USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
263 UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3,
264 1000, GFP_NOIO);
265 if (err)
266 dev_err(&dev->dev, "%d: cannot set freq %d to ep 0x%x\n",
267 dev->devnum, rate, ep);
268 return err;
269 }
270
us122l_start(struct us122l * us122l,unsigned int rate,unsigned int period_frames)271 static bool us122l_start(struct us122l *us122l,
272 unsigned int rate, unsigned int period_frames)
273 {
274 struct list_head *p;
275 int err;
276 unsigned int use_packsize = 0;
277 bool success = false;
278
279 if (us122l->dev->speed == USB_SPEED_HIGH) {
280 /* The us-122l's descriptor defaults to iso max_packsize 78,
281 which isn't needed for samplerates <= 48000.
282 Lets save some memory:
283 */
284 switch (rate) {
285 case 44100:
286 use_packsize = 36;
287 break;
288 case 48000:
289 use_packsize = 42;
290 break;
291 case 88200:
292 use_packsize = 72;
293 break;
294 }
295 }
296 if (!usb_stream_new(&us122l->sk, us122l->dev, 1, 2,
297 rate, use_packsize, period_frames, 6))
298 goto out;
299
300 err = us122l_set_sample_rate(us122l->dev, rate);
301 if (err < 0) {
302 us122l_stop(us122l);
303 dev_err(&us122l->dev->dev, "us122l_set_sample_rate error\n");
304 goto out;
305 }
306 err = usb_stream_start(&us122l->sk);
307 if (err < 0) {
308 us122l_stop(us122l);
309 dev_err(&us122l->dev->dev, "%s error %i\n", __func__, err);
310 goto out;
311 }
312 list_for_each(p, &us122l->midi_list)
313 snd_usbmidi_input_start(p);
314 success = true;
315 out:
316 return success;
317 }
318
usb_stream_hwdep_ioctl(struct snd_hwdep * hw,struct file * file,unsigned int cmd,unsigned long arg)319 static int usb_stream_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
320 unsigned int cmd, unsigned long arg)
321 {
322 struct usb_stream_config cfg;
323 struct us122l *us122l = hw->private_data;
324 struct usb_stream *s;
325 unsigned int min_period_frames;
326 int err = 0;
327 bool high_speed;
328
329 if (cmd != SNDRV_USB_STREAM_IOCTL_SET_PARAMS)
330 return -ENOTTY;
331
332 if (copy_from_user(&cfg, (void __user *)arg, sizeof(cfg)))
333 return -EFAULT;
334
335 if (cfg.version != USB_STREAM_INTERFACE_VERSION)
336 return -ENXIO;
337
338 high_speed = us122l->dev->speed == USB_SPEED_HIGH;
339 if ((cfg.sample_rate != 44100 && cfg.sample_rate != 48000 &&
340 (!high_speed ||
341 (cfg.sample_rate != 88200 && cfg.sample_rate != 96000))) ||
342 cfg.frame_size != 6 ||
343 cfg.period_frames > 0x3000)
344 return -EINVAL;
345
346 switch (cfg.sample_rate) {
347 case 44100:
348 min_period_frames = 48;
349 break;
350 case 48000:
351 min_period_frames = 52;
352 break;
353 default:
354 min_period_frames = 104;
355 break;
356 }
357 if (!high_speed)
358 min_period_frames <<= 1;
359 if (cfg.period_frames < min_period_frames)
360 return -EINVAL;
361
362 snd_power_wait(hw->card);
363
364 mutex_lock(&us122l->mutex);
365 s = us122l->sk.s;
366 if (!us122l->master) {
367 us122l->master = file;
368 } else if (us122l->master != file) {
369 if (!s || memcmp(&cfg, &s->cfg, sizeof(cfg))) {
370 err = -EIO;
371 goto unlock;
372 }
373 us122l->slave = file;
374 }
375 if (!s || memcmp(&cfg, &s->cfg, sizeof(cfg)) ||
376 s->state == usb_stream_xrun) {
377 us122l_stop(us122l);
378 if (!us122l_start(us122l, cfg.sample_rate, cfg.period_frames))
379 err = -EIO;
380 else
381 err = 1;
382 }
383 unlock:
384 mutex_unlock(&us122l->mutex);
385 wake_up_all(&us122l->sk.sleep);
386 return err;
387 }
388
389 #define SND_USB_STREAM_ID "USB STREAM"
usb_stream_hwdep_new(struct snd_card * card)390 static int usb_stream_hwdep_new(struct snd_card *card)
391 {
392 int err;
393 struct snd_hwdep *hw;
394 struct usb_device *dev = US122L(card)->dev;
395
396 err = snd_hwdep_new(card, SND_USB_STREAM_ID, 0, &hw);
397 if (err < 0)
398 return err;
399
400 hw->iface = SNDRV_HWDEP_IFACE_USB_STREAM;
401 hw->private_data = US122L(card);
402 hw->ops.open = usb_stream_hwdep_open;
403 hw->ops.release = usb_stream_hwdep_release;
404 hw->ops.ioctl = usb_stream_hwdep_ioctl;
405 hw->ops.ioctl_compat = usb_stream_hwdep_ioctl;
406 hw->ops.mmap = usb_stream_hwdep_mmap;
407 hw->ops.poll = usb_stream_hwdep_poll;
408
409 sprintf(hw->name, "/dev/bus/usb/%03d/%03d/hwdeppcm",
410 dev->bus->busnum, dev->devnum);
411 return 0;
412 }
413
us122l_create_card(struct snd_card * card)414 static bool us122l_create_card(struct snd_card *card)
415 {
416 int err;
417 struct us122l *us122l = US122L(card);
418
419 if (us122l->is_us144) {
420 err = usb_set_interface(us122l->dev, 0, 1);
421 if (err) {
422 dev_err(card->dev, "usb_set_interface error\n");
423 return false;
424 }
425 }
426 err = usb_set_interface(us122l->dev, 1, 1);
427 if (err) {
428 dev_err(card->dev, "usb_set_interface error\n");
429 return false;
430 }
431
432 pt_info_set(us122l->dev, 0x11);
433 pt_info_set(us122l->dev, 0x10);
434
435 if (!us122l_start(us122l, 44100, 256))
436 return false;
437
438 if (us122l->is_us144)
439 err = us144_create_usbmidi(card);
440 else
441 err = us122l_create_usbmidi(card);
442 if (err < 0) {
443 dev_err(card->dev, "us122l_create_usbmidi error %i\n", err);
444 goto stop;
445 }
446 err = usb_stream_hwdep_new(card);
447 if (err < 0) {
448 /* release the midi resources */
449 struct list_head *p;
450
451 list_for_each(p, &us122l->midi_list)
452 snd_usbmidi_disconnect(p);
453
454 goto stop;
455 }
456 return true;
457
458 stop:
459 us122l_stop(us122l);
460 return false;
461 }
462
snd_us122l_free(struct snd_card * card)463 static void snd_us122l_free(struct snd_card *card)
464 {
465 struct us122l *us122l = US122L(card);
466 int index = us122l->card_index;
467
468 if (index >= 0 && index < SNDRV_CARDS)
469 snd_us122l_card_used[index] = 0;
470 }
471
usx2y_create_card(struct usb_device * device,struct usb_interface * intf,struct snd_card ** cardp,unsigned long flags)472 static int usx2y_create_card(struct usb_device *device,
473 struct usb_interface *intf,
474 struct snd_card **cardp,
475 unsigned long flags)
476 {
477 int dev;
478 struct snd_card *card;
479 int err;
480
481 for (dev = 0; dev < SNDRV_CARDS; ++dev)
482 if (enable[dev] && !snd_us122l_card_used[dev])
483 break;
484 if (dev >= SNDRV_CARDS)
485 return -ENODEV;
486 err = snd_card_new(&intf->dev, index[dev], id[dev], THIS_MODULE,
487 sizeof(struct us122l), &card);
488 if (err < 0)
489 return err;
490 snd_us122l_card_used[US122L(card)->card_index = dev] = 1;
491 card->private_free = snd_us122l_free;
492 US122L(card)->dev = device;
493 mutex_init(&US122L(card)->mutex);
494 US122L(card)->sk.dev = device;
495 init_waitqueue_head(&US122L(card)->sk.sleep);
496 US122L(card)->is_us144 = flags & US122L_FLAG_US144;
497 INIT_LIST_HEAD(&US122L(card)->midi_list);
498 strcpy(card->driver, "USB "NAME_ALLCAPS"");
499 sprintf(card->shortname, "TASCAM "NAME_ALLCAPS"");
500 sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)",
501 card->shortname,
502 le16_to_cpu(device->descriptor.idVendor),
503 le16_to_cpu(device->descriptor.idProduct),
504 0,
505 US122L(card)->dev->bus->busnum,
506 US122L(card)->dev->devnum
507 );
508 *cardp = card;
509 return 0;
510 }
511
us122l_usb_probe(struct usb_interface * intf,const struct usb_device_id * device_id,struct snd_card ** cardp)512 static int us122l_usb_probe(struct usb_interface *intf,
513 const struct usb_device_id *device_id,
514 struct snd_card **cardp)
515 {
516 struct usb_device *device = interface_to_usbdev(intf);
517 struct snd_card *card;
518 int err;
519
520 err = usx2y_create_card(device, intf, &card, device_id->driver_info);
521 if (err < 0)
522 return err;
523
524 if (!us122l_create_card(card)) {
525 snd_card_free(card);
526 return -EINVAL;
527 }
528
529 err = snd_card_register(card);
530 if (err < 0) {
531 snd_card_free(card);
532 return err;
533 }
534
535 usb_get_intf(usb_ifnum_to_if(device, 0));
536 usb_get_dev(device);
537 *cardp = card;
538 return 0;
539 }
540
snd_us122l_probe(struct usb_interface * intf,const struct usb_device_id * id)541 static int snd_us122l_probe(struct usb_interface *intf,
542 const struct usb_device_id *id)
543 {
544 struct usb_device *device = interface_to_usbdev(intf);
545 struct snd_card *card;
546 int err;
547
548 if (id->driver_info & US122L_FLAG_US144 &&
549 device->speed == USB_SPEED_HIGH) {
550 dev_err(&device->dev, "disable ehci-hcd to run US-144\n");
551 return -ENODEV;
552 }
553
554 if (intf->cur_altsetting->desc.bInterfaceNumber != 1)
555 return 0;
556
557 err = us122l_usb_probe(usb_get_intf(intf), id, &card);
558 if (err < 0) {
559 usb_put_intf(intf);
560 return err;
561 }
562
563 usb_set_intfdata(intf, card);
564 return 0;
565 }
566
snd_us122l_disconnect(struct usb_interface * intf)567 static void snd_us122l_disconnect(struct usb_interface *intf)
568 {
569 struct snd_card *card;
570 struct us122l *us122l;
571 struct list_head *p;
572
573 card = usb_get_intfdata(intf);
574 if (!card)
575 return;
576
577 snd_card_disconnect(card);
578
579 us122l = US122L(card);
580 mutex_lock(&us122l->mutex);
581 us122l_stop(us122l);
582 mutex_unlock(&us122l->mutex);
583
584 /* release the midi resources */
585 list_for_each(p, &us122l->midi_list) {
586 snd_usbmidi_disconnect(p);
587 }
588
589 usb_put_intf(usb_ifnum_to_if(us122l->dev, 0));
590 usb_put_intf(usb_ifnum_to_if(us122l->dev, 1));
591 usb_put_dev(us122l->dev);
592
593 snd_card_free_when_closed(card);
594 }
595
snd_us122l_suspend(struct usb_interface * intf,pm_message_t message)596 static int snd_us122l_suspend(struct usb_interface *intf, pm_message_t message)
597 {
598 struct snd_card *card;
599 struct us122l *us122l;
600 struct list_head *p;
601
602 card = usb_get_intfdata(intf);
603 if (!card)
604 return 0;
605 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
606
607 us122l = US122L(card);
608 if (!us122l)
609 return 0;
610
611 list_for_each(p, &us122l->midi_list)
612 snd_usbmidi_input_stop(p);
613
614 mutex_lock(&us122l->mutex);
615 usb_stream_stop(&us122l->sk);
616 mutex_unlock(&us122l->mutex);
617
618 return 0;
619 }
620
snd_us122l_resume(struct usb_interface * intf)621 static int snd_us122l_resume(struct usb_interface *intf)
622 {
623 struct snd_card *card;
624 struct us122l *us122l;
625 struct list_head *p;
626 int err;
627
628 card = usb_get_intfdata(intf);
629 if (!card)
630 return 0;
631
632 us122l = US122L(card);
633 if (!us122l)
634 return 0;
635
636 mutex_lock(&us122l->mutex);
637 /* needed, doesn't restart without: */
638 if (us122l->is_us144) {
639 err = usb_set_interface(us122l->dev, 0, 1);
640 if (err) {
641 dev_err(&us122l->dev->dev, "usb_set_interface error\n");
642 goto unlock;
643 }
644 }
645 err = usb_set_interface(us122l->dev, 1, 1);
646 if (err) {
647 dev_err(&us122l->dev->dev, "usb_set_interface error\n");
648 goto unlock;
649 }
650
651 pt_info_set(us122l->dev, 0x11);
652 pt_info_set(us122l->dev, 0x10);
653
654 err = us122l_set_sample_rate(us122l->dev,
655 us122l->sk.s->cfg.sample_rate);
656 if (err < 0) {
657 dev_err(&us122l->dev->dev, "us122l_set_sample_rate error\n");
658 goto unlock;
659 }
660 err = usb_stream_start(&us122l->sk);
661 if (err)
662 goto unlock;
663
664 list_for_each(p, &us122l->midi_list)
665 snd_usbmidi_input_start(p);
666 unlock:
667 mutex_unlock(&us122l->mutex);
668 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
669 return err;
670 }
671
672 static const struct usb_device_id snd_us122l_usb_id_table[] = {
673 {
674 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
675 .idVendor = 0x0644,
676 .idProduct = USB_ID_US122L
677 },
678 { /* US-144 only works at USB1.1! Disable module ehci-hcd. */
679 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
680 .idVendor = 0x0644,
681 .idProduct = USB_ID_US144,
682 .driver_info = US122L_FLAG_US144
683 },
684 {
685 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
686 .idVendor = 0x0644,
687 .idProduct = USB_ID_US122MKII
688 },
689 {
690 .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
691 .idVendor = 0x0644,
692 .idProduct = USB_ID_US144MKII,
693 .driver_info = US122L_FLAG_US144
694 },
695 { /* terminator */ }
696 };
697 MODULE_DEVICE_TABLE(usb, snd_us122l_usb_id_table);
698
699 static struct usb_driver snd_us122l_usb_driver = {
700 .name = "snd-usb-us122l",
701 .probe = snd_us122l_probe,
702 .disconnect = snd_us122l_disconnect,
703 .suspend = snd_us122l_suspend,
704 .resume = snd_us122l_resume,
705 .reset_resume = snd_us122l_resume,
706 .id_table = snd_us122l_usb_id_table,
707 .supports_autosuspend = 1
708 };
709
710 module_usb_driver(snd_us122l_usb_driver);
711