us122l.c 17 KB

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