xref: /linux/sound/usb/usx2y/us122l.c (revision 3fd6c59042dbba50391e30862beac979491145fe)
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