API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 22nd, 2020
756
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 51.76 KB | None | 0 0
raw download clone embed print report
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. */
  4.  
  5. #include <linux/init.h>
  6. #include <linux/slab.h>
  7. #include <linux/bitrev.h>
  8. #include <linux/ratelimit.h>
  9. #include <linux/usb.h>
  10. #include <linux/usb/audio.h>
  11. #include <linux/usb/audio-v2.h>
  12.  
  13. #include <sound/core.h>
  14. #include <sound/pcm.h>
  15. #include <sound/pcm_params.h>
  16.  
  17. #include "usbaudio.h"
  18. #include "card.h"
  19. #include "quirks.h"
  20. #include "debug.h"
  21. #include "endpoint.h"
  22. #include "helper.h"
  23. #include "pcm.h"
  24. #include "clock.h"
  25. #include "power.h"
  26. #include "media.h"
  27.  
  28. #define SUBSTREAM_FLAG_DATA_EP_STARTED 0
  29. #define SUBSTREAM_FLAG_SYNC_EP_STARTED 1
  30.  
  31. /* return the estimated delay based on USB frame counters */
  32. snd_pcm_uframes_t snd_usb_pcm_delay(struct snd_usb_substream *subs,
  33. unsigned int rate)
  34. {
  35. int current_frame_number;
  36. int frame_diff;
  37. int est_delay;
  38.  
  39. if (!subs->last_delay)
  40. return 0; /* short path */
  41.  
  42. current_frame_number = usb_get_current_frame_number(subs->dev);
  43. /*
  44. * HCD implementations use different widths, use lower 8 bits.
  45. * The delay will be managed up to 256ms, which is more than
  46. * enough
  47. */
  48. frame_diff = (current_frame_number - subs->last_frame_number) & 0xff;
  49.  
  50. /* Approximation based on number of samples per USB frame (ms),
  51. some truncation for 44.1 but the estimate is good enough */
  52. est_delay = frame_diff * rate / 1000;
  53. if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK)
  54. est_delay = subs->last_delay - est_delay;
  55. else
  56. est_delay = subs->last_delay + est_delay;
  57.  
  58. if (est_delay < 0)
  59. est_delay = 0;
  60. return est_delay;
  61. }
  62.  
  63. /*
  64. * return the current pcm pointer. just based on the hwptr_done value.
  65. */
  66. static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream)
  67. {
  68. struct snd_usb_substream *subs = substream->runtime->private_data;
  69. unsigned int hwptr_done;
  70.  
  71. if (atomic_read(&subs->stream->chip->shutdown))
  72. return SNDRV_PCM_POS_XRUN;
  73. spin_lock(&subs->lock);
  74. hwptr_done = subs->hwptr_done;
  75. substream->runtime->delay = snd_usb_pcm_delay(subs,
  76. substream->runtime->rate);
  77. spin_unlock(&subs->lock);
  78. return hwptr_done / (substream->runtime->frame_bits >> 3);
  79. }
  80.  
  81. /*
  82. * find a matching audio format
  83. */
  84. static struct audioformat *find_format(struct snd_usb_substream *subs)
  85. {
  86. struct audioformat *fp;
  87. struct audioformat *found = NULL;
  88. int cur_attr = 0, attr;
  89.  
  90. list_for_each_entry(fp, &subs->fmt_list, list) {
  91. if (!(fp->formats & pcm_format_to_bits(subs->pcm_format)))
  92. continue;
  93. if (fp->channels != subs->channels)
  94. continue;
  95. if (subs->cur_rate < fp->rate_min ||
  96. subs->cur_rate > fp->rate_max)
  97. continue;
  98. if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) {
  99. unsigned int i;
  100. for (i = 0; i < fp->nr_rates; i++)
  101. if (fp->rate_table[i] == subs->cur_rate)
  102. break;
  103. if (i >= fp->nr_rates)
  104. continue;
  105. }
  106. attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE;
  107. if (! found) {
  108. found = fp;
  109. cur_attr = attr;
  110. continue;
  111. }
  112. /* avoid async out and adaptive in if the other method
  113. * supports the same format.
  114. * this is a workaround for the case like
  115. * M-audio audiophile USB.
  116. */
  117. if (attr != cur_attr) {
  118. if ((attr == USB_ENDPOINT_SYNC_ASYNC &&
  119. subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
  120. (attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
  121. subs->direction == SNDRV_PCM_STREAM_CAPTURE))
  122. continue;
  123. if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC &&
  124. subs->direction == SNDRV_PCM_STREAM_PLAYBACK) ||
  125. (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE &&
  126. subs->direction == SNDRV_PCM_STREAM_CAPTURE)) {
  127. found = fp;
  128. cur_attr = attr;
  129. continue;
  130. }
  131. }
  132. /* find the format with the largest max. packet size */
  133. if (fp->maxpacksize > found->maxpacksize) {
  134. found = fp;
  135. cur_attr = attr;
  136. }
  137. }
  138. return found;
  139. }
  140.  
  141. static int init_pitch_v1(struct snd_usb_audio *chip, int iface,
  142. struct usb_host_interface *alts,
  143. struct audioformat *fmt)
  144. {
  145. struct usb_device *dev = chip->dev;
  146. unsigned int ep;
  147. unsigned char data[1];
  148. int err;
  149.  
  150. if (get_iface_desc(alts)->bNumEndpoints < 1)
  151. return -EINVAL;
  152. ep = get_endpoint(alts, 0)->bEndpointAddress;
  153.  
  154. data[0] = 1;
  155. err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR,
  156. USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT,
  157. UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep,
  158. data, sizeof(data));
  159. if (err < 0) {
  160. usb_audio_err(chip, "%d:%d: cannot set enable PITCH\n",
  161. iface, ep);
  162. return err;
  163. }
  164.  
  165. return 0;
  166. }
  167.  
  168. static int init_pitch_v2(struct snd_usb_audio *chip, int iface,
  169. struct usb_host_interface *alts,
  170. struct audioformat *fmt)
  171. {
  172. struct usb_device *dev = chip->dev;
  173. unsigned char data[1];
  174. int err;
  175.  
  176. data[0] = 1;
  177. err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR,
  178. USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
  179. UAC2_EP_CS_PITCH << 8, 0,
  180. data, sizeof(data));
  181. if (err < 0) {
  182. usb_audio_err(chip, "%d:%d: cannot set enable PITCH (v2)\n",
  183. iface, fmt->altsetting);
  184. return err;
  185. }
  186.  
  187. return 0;
  188. }
  189.  
  190. /*
  191. * initialize the pitch control and sample rate
  192. */
  193. int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface,
  194. struct usb_host_interface *alts,
  195. struct audioformat *fmt)
  196. {
  197. /* if endpoint doesn't have pitch control, bail out */
  198. if (!(fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL))
  199. return 0;
  200.  
  201. switch (fmt->protocol) {
  202. case UAC_VERSION_1:
  203. default:
  204. return init_pitch_v1(chip, iface, alts, fmt);
  205.  
  206. case UAC_VERSION_2:
  207. return init_pitch_v2(chip, iface, alts, fmt);
  208. }
  209. }
  210.  
  211. static int start_endpoints(struct snd_usb_substream *subs)
  212. {
  213. int err;
  214.  
  215. if (!subs->data_endpoint)
  216. return -EINVAL;
  217.  
  218. if (!test_and_set_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags)) {
  219. struct snd_usb_endpoint *ep = subs->data_endpoint;
  220.  
  221. dev_dbg(&subs->dev->dev, "Starting data EP @%p\n", ep);
  222.  
  223. ep->data_subs = subs;
  224. err = snd_usb_endpoint_start(ep);
  225. if (err < 0) {
  226. clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags);
  227. return err;
  228. }
  229. }
  230.  
  231. if (subs->sync_endpoint &&
  232. !test_and_set_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags)) {
  233. struct snd_usb_endpoint *ep = subs->sync_endpoint;
  234.  
  235. if (subs->data_endpoint->iface != subs->sync_endpoint->iface ||
  236. subs->data_endpoint->altsetting != subs->sync_endpoint->altsetting) {
  237. err = usb_set_interface(subs->dev,
  238. subs->sync_endpoint->iface,
  239. subs->sync_endpoint->altsetting);
  240. if (err < 0) {
  241. clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags);
  242. dev_err(&subs->dev->dev,
  243. "%d:%d: cannot set interface (%d)\n",
  244. subs->sync_endpoint->iface,
  245. subs->sync_endpoint->altsetting, err);
  246. return -EIO;
  247. }
  248. }
  249.  
  250. dev_dbg(&subs->dev->dev, "Starting sync EP @%p\n", ep);
  251.  
  252. ep->sync_slave = subs->data_endpoint;
  253. err = snd_usb_endpoint_start(ep);
  254. if (err < 0) {
  255. clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags);
  256. return err;
  257. }
  258. }
  259.  
  260. return 0;
  261. }
  262.  
  263. static void stop_endpoints(struct snd_usb_substream *subs, bool wait)
  264. {
  265. if (test_and_clear_bit(SUBSTREAM_FLAG_SYNC_EP_STARTED, &subs->flags))
  266. snd_usb_endpoint_stop(subs->sync_endpoint);
  267.  
  268. if (test_and_clear_bit(SUBSTREAM_FLAG_DATA_EP_STARTED, &subs->flags))
  269. snd_usb_endpoint_stop(subs->data_endpoint);
  270.  
  271. if (wait) {
  272. snd_usb_endpoint_sync_pending_stop(subs->sync_endpoint);
  273. snd_usb_endpoint_sync_pending_stop(subs->data_endpoint);
  274. }
  275. }
  276.  
  277. static int search_roland_implicit_fb(struct usb_device *dev, int ifnum,
  278. unsigned int altsetting,
  279. struct usb_host_interface **alts,
  280. unsigned int *ep)
  281. {
  282. struct usb_interface *iface;
  283. struct usb_interface_descriptor *altsd;
  284. struct usb_endpoint_descriptor *epd;
  285.  
  286. iface = usb_ifnum_to_if(dev, ifnum);
  287. if (!iface || iface->num_altsetting < altsetting + 1)
  288. return -ENOENT;
  289. *alts = &iface->altsetting[altsetting];
  290. altsd = get_iface_desc(*alts);
  291. if (altsd->bAlternateSetting != altsetting ||
  292. altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC ||
  293. (altsd->bInterfaceSubClass != 2 &&
  294. altsd->bInterfaceProtocol != 2 ) ||
  295. altsd->bNumEndpoints < 1)
  296. return -ENOENT;
  297. epd = get_endpoint(*alts, 0);
  298. if (!usb_endpoint_is_isoc_in(epd) ||
  299. (epd->bmAttributes & USB_ENDPOINT_USAGE_MASK) !=
  300. USB_ENDPOINT_USAGE_IMPLICIT_FB)
  301. return -ENOENT;
  302. *ep = epd->bEndpointAddress;
  303. return 0;
  304. }
  305.  
  306. /* Setup an implicit feedback endpoint from a quirk. Returns 0 if no quirk
  307. * applies. Returns 1 if a quirk was found.
  308. */
  309. static int set_sync_ep_implicit_fb_quirk(struct snd_usb_substream *subs,
  310. struct usb_device *dev,
  311. struct usb_interface_descriptor *altsd,
  312. unsigned int attr)
  313. {
  314. struct usb_host_interface *alts;
  315. struct usb_interface *iface;
  316. unsigned int ep;
  317. unsigned int ifnum;
  318.  
  319. /* Implicit feedback sync EPs consumers are always playback EPs */
  320. if (subs->direction != SNDRV_PCM_STREAM_PLAYBACK)
  321. return 0;
  322.  
  323. switch (subs->stream->chip->usb_id) {
  324. case USB_ID(0x0763, 0x2030): /* M-Audio Fast Track C400 */
  325. case USB_ID(0x0763, 0x2031): /* M-Audio Fast Track C600 */
  326. ep = 0x81;
  327. ifnum = 3;
  328. goto add_sync_ep_from_ifnum;
  329. case USB_ID(0x0763, 0x2080): /* M-Audio FastTrack Ultra */
  330. case USB_ID(0x0763, 0x2081):
  331. ep = 0x81;
  332. ifnum = 2;
  333. goto add_sync_ep_from_ifnum;
  334. case USB_ID(0x2466, 0x8003): /* Fractal Audio Axe-Fx II */
  335. ep = 0x86;
  336. ifnum = 2;
  337. goto add_sync_ep_from_ifnum;
  338. case USB_ID(0x2466, 0x8010): /* Fractal Audio Axe-Fx III */
  339. ep = 0x81;
  340. ifnum = 2;
  341. goto add_sync_ep_from_ifnum;
  342. case USB_ID(0x1397, 0x0001): /* Behringer UFX1604 */
  343. case USB_ID(0x1397, 0x0002): /* Behringer UFX1204 */
  344. ep = 0x81;
  345. ifnum = 1;
  346. goto add_sync_ep_from_ifnum;
  347. case USB_ID(0x07fd, 0x0004): /* MOTU MicroBook II */
  348. ep = 0x84;
  349. ifnum = 0;
  350. goto add_sync_ep_from_ifnum;
  351. case USB_ID(0x1235, 0x8215): /* Focusrite Scarlett 18i20 3rd Gen */
  352. ep = 0x81;
  353. ifnum = 2;
  354. goto add_sync_ep_from_ifnum;
  355. }
  356.  
  357. if (attr == USB_ENDPOINT_SYNC_ASYNC &&
  358. altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC &&
  359. altsd->bInterfaceProtocol == 2 &&
  360. altsd->bNumEndpoints == 1 &&
  361. USB_ID_VENDOR(subs->stream->chip->usb_id) == 0x0582 /* Roland */ &&
  362. search_roland_implicit_fb(dev, altsd->bInterfaceNumber + 1,
  363. altsd->bAlternateSetting,
  364. &alts, &ep) >= 0) {
  365. goto add_sync_ep;
  366. }
  367.  
  368. /* No quirk */
  369. return 0;
  370.  
  371. add_sync_ep_from_ifnum:
  372. iface = usb_ifnum_to_if(dev, ifnum);
  373.  
  374. if (!iface || iface->num_altsetting == 0)
  375. return -EINVAL;
  376.  
  377. alts = &iface->altsetting[1];
  378.  
  379. add_sync_ep:
  380. subs->sync_endpoint = snd_usb_add_endpoint(subs->stream->chip,
  381. alts, ep, !subs->direction,
  382. SND_USB_ENDPOINT_TYPE_DATA);
  383. if (!subs->sync_endpoint)
  384. return -EINVAL;
  385.  
  386. subs->data_endpoint->sync_master = subs->sync_endpoint;
  387.  
  388. return 1;
  389. }
  390.  
  391. static int set_sync_endpoint(struct snd_usb_substream *subs,
  392. struct audioformat *fmt,
  393. struct usb_device *dev,
  394. struct usb_host_interface *alts,
  395. struct usb_interface_descriptor *altsd)
  396. {
  397. int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK;
  398. unsigned int ep, attr;
  399. bool implicit_fb;
  400. int err;
  401.  
  402. /* we need a sync pipe in async OUT or adaptive IN mode */
  403. /* check the number of EP, since some devices have broken
  404. * descriptors which fool us. if it has only one EP,
  405. * assume it as adaptive-out or sync-in.
  406. */
  407. attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE;
  408.  
  409. if ((is_playback && (attr != USB_ENDPOINT_SYNC_ASYNC)) ||
  410. (!is_playback && (attr != USB_ENDPOINT_SYNC_ADAPTIVE))) {
  411.  
  412. /*
  413. * In these modes the notion of sync_endpoint is irrelevant.
  414. * Reset pointers to avoid using stale data from previously
  415. * used settings, e.g. when configuration and endpoints were
  416. * changed
  417. */
  418.  
  419. subs->sync_endpoint = NULL;
  420. subs->data_endpoint->sync_master = NULL;
  421. }
  422.  
  423. err = set_sync_ep_implicit_fb_quirk(subs, dev, altsd, attr);
  424. if (err < 0)
  425. return err;
  426.  
  427. /* endpoint set by quirk */
  428. if (err > 0)
  429. return 0;
  430.  
  431. if (altsd->bNumEndpoints < 2)
  432. return 0;
  433.  
  434. if ((is_playback && (attr == USB_ENDPOINT_SYNC_SYNC ||
  435. attr == USB_ENDPOINT_SYNC_ADAPTIVE)) ||
  436. (!is_playback && attr != USB_ENDPOINT_SYNC_ADAPTIVE))
  437. return 0;
  438.  
  439. /*
  440. * In case of illegal SYNC_NONE for OUT endpoint, we keep going to see
  441. * if we don't find a sync endpoint, as on M-Audio Transit. In case of
  442. * error fall back to SYNC mode and don't create sync endpoint
  443. */
  444.  
  445. /* check sync-pipe endpoint */
  446. /* ... and check descriptor size before accessing bSynchAddress
  447. because there is a version of the SB Audigy 2 NX firmware lacking
  448. the audio fields in the endpoint descriptors */
  449. if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != USB_ENDPOINT_XFER_ISOC ||
  450. (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
  451. get_endpoint(alts, 1)->bSynchAddress != 0)) {
  452. dev_err(&dev->dev,
  453. "%d:%d : invalid sync pipe. bmAttributes %02x, bLength %d, bSynchAddress %02x\n",
  454. fmt->iface, fmt->altsetting,
  455. get_endpoint(alts, 1)->bmAttributes,
  456. get_endpoint(alts, 1)->bLength,
  457. get_endpoint(alts, 1)->bSynchAddress);
  458. if (is_playback && attr == USB_ENDPOINT_SYNC_NONE)
  459. return 0;
  460. return -EINVAL;
  461. }
  462. ep = get_endpoint(alts, 1)->bEndpointAddress;
  463. if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
  464. get_endpoint(alts, 0)->bSynchAddress != 0 &&
  465. ((is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) ||
  466. (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) {
  467. dev_err(&dev->dev,
  468. "%d:%d : invalid sync pipe. is_playback %d, ep %02x, bSynchAddress %02x\n",
  469. fmt->iface, fmt->altsetting,
  470. is_playback, ep, get_endpoint(alts, 0)->bSynchAddress);
  471. if (is_playback && attr == USB_ENDPOINT_SYNC_NONE)
  472. return 0;
  473. return -EINVAL;
  474. }
  475.  
  476. implicit_fb = (get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_USAGE_MASK)
  477. == USB_ENDPOINT_USAGE_IMPLICIT_FB;
  478.  
  479. subs->sync_endpoint = snd_usb_add_endpoint(subs->stream->chip,
  480. alts, ep, !subs->direction,
  481. implicit_fb ?
  482. SND_USB_ENDPOINT_TYPE_DATA :
  483. SND_USB_ENDPOINT_TYPE_SYNC);
  484. if (!subs->sync_endpoint) {
  485. if (is_playback && attr == USB_ENDPOINT_SYNC_NONE)
  486. return 0;
  487. return -EINVAL;
  488. }
  489.  
  490. subs->data_endpoint->sync_master = subs->sync_endpoint;
  491.  
  492. return 0;
  493. }
  494.  
  495. /*
  496. * find a matching format and set up the interface
  497. */
  498. static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt)
  499. {
  500. struct usb_device *dev = subs->dev;
  501. struct usb_host_interface *alts;
  502. struct usb_interface_descriptor *altsd;
  503. struct usb_interface *iface;
  504. int err;
  505.  
  506. iface = usb_ifnum_to_if(dev, fmt->iface);
  507. if (WARN_ON(!iface))
  508. return -EINVAL;
  509. alts = usb_altnum_to_altsetting(iface, fmt->altsetting);
  510. altsd = get_iface_desc(alts);
  511. if (WARN_ON(altsd->bAlternateSetting != fmt->altsetting))
  512. return -EINVAL;
  513.  
  514. if (fmt == subs->cur_audiofmt)
  515. return 0;
  516.  
  517. /* close the old interface */
  518. if (subs->interface >= 0 && subs->interface != fmt->iface) {
  519. if (!subs->stream->chip->keep_iface) {
  520. err = usb_set_interface(subs->dev, subs->interface, 0);
  521. if (err < 0) {
  522. dev_err(&dev->dev,
  523. "%d:%d: return to setting 0 failed (%d)\n",
  524. fmt->iface, fmt->altsetting, err);
  525. return -EIO;
  526. }
  527. }
  528. subs->interface = -1;
  529. subs->altset_idx = 0;
  530. }
  531.  
  532. /* set interface */
  533. if (iface->cur_altsetting != alts) {
  534. err = snd_usb_select_mode_quirk(subs, fmt);
  535. if (err < 0)
  536. return -EIO;
  537.  
  538. err = usb_set_interface(dev, fmt->iface, fmt->altsetting);
  539. if (err < 0) {
  540. dev_err(&dev->dev,
  541. "%d:%d: usb_set_interface failed (%d)\n",
  542. fmt->iface, fmt->altsetting, err);
  543. return -EIO;
  544. }
  545. dev_dbg(&dev->dev, "setting usb interface %d:%d\n",
  546. fmt->iface, fmt->altsetting);
  547. snd_usb_set_interface_quirk(dev);
  548. }
  549.  
  550. subs->interface = fmt->iface;
  551. subs->altset_idx = fmt->altset_idx;
  552. subs->data_endpoint = snd_usb_add_endpoint(subs->stream->chip,
  553. alts, fmt->endpoint, subs->direction,
  554. SND_USB_ENDPOINT_TYPE_DATA);
  555.  
  556. if (!subs->data_endpoint)
  557. return -EINVAL;
  558.  
  559. err = set_sync_endpoint(subs, fmt, dev, alts, altsd);
  560. if (err < 0)
  561. return err;
  562.  
  563. err = snd_usb_init_pitch(subs->stream->chip, fmt->iface, alts, fmt);
  564. if (err < 0)
  565. return err;
  566.  
  567. subs->cur_audiofmt = fmt;
  568.  
  569. snd_usb_set_format_quirk(subs, fmt);
  570.  
  571. return 0;
  572. }
  573.  
  574. /*
  575. * Return the score of matching two audioformats.
  576. * Veto the audioformat if:
  577. * - It has no channels for some reason.
  578. * - Requested PCM format is not supported.
  579. * - Requested sample rate is not supported.
  580. */
  581. static int match_endpoint_audioformats(struct snd_usb_substream *subs,
  582. struct audioformat *fp,
  583. struct audioformat *match, int rate,
  584. snd_pcm_format_t pcm_format)
  585. {
  586. int i;
  587. int score = 0;
  588.  
  589. if (fp->channels < 1) {
  590. dev_dbg(&subs->dev->dev,
  591. "%s: (fmt @%p) no channels\n", __func__, fp);
  592. return 0;
  593. }
  594.  
  595. if (!(fp->formats & pcm_format_to_bits(pcm_format))) {
  596. dev_dbg(&subs->dev->dev,
  597. "%s: (fmt @%p) no match for format %d\n", __func__,
  598. fp, pcm_format);
  599. return 0;
  600. }
  601.  
  602. for (i = 0; i < fp->nr_rates; i++) {
  603. if (fp->rate_table[i] == rate) {
  604. score++;
  605. break;
  606. }
  607. }
  608. if (!score) {
  609. dev_dbg(&subs->dev->dev,
  610. "%s: (fmt @%p) no match for rate %d\n", __func__,
  611. fp, rate);
  612. return 0;
  613. }
  614.  
  615. if (fp->channels == match->channels)
  616. score++;
  617.  
  618. dev_dbg(&subs->dev->dev,
  619. "%s: (fmt @%p) score %d\n", __func__, fp, score);
  620.  
  621. return score;
  622. }
  623.  
  624. /*
  625. * Configure the sync ep using the rate and pcm format of the data ep.
  626. */
  627. static int configure_sync_endpoint(struct snd_usb_substream *subs)
  628. {
  629. int ret;
  630. struct audioformat *fp;
  631. struct audioformat *sync_fp = NULL;
  632. int cur_score = 0;
  633. int sync_period_bytes = subs->period_bytes;
  634. struct snd_usb_substream *sync_subs =
  635. &subs->stream->substream[subs->direction ^ 1];
  636.  
  637. if (subs->sync_endpoint->type != SND_USB_ENDPOINT_TYPE_DATA ||
  638. !subs->stream)
  639. return snd_usb_endpoint_set_params(subs->sync_endpoint,
  640. subs->pcm_format,
  641. subs->channels,
  642. subs->period_bytes,
  643. 0, 0,
  644. subs->cur_rate,
  645. subs->cur_audiofmt,
  646. NULL);
  647.  
  648. /* Try to find the best matching audioformat. */
  649. list_for_each_entry(fp, &sync_subs->fmt_list, list) {
  650. int score = match_endpoint_audioformats(subs,
  651. fp, subs->cur_audiofmt,
  652. subs->cur_rate, subs->pcm_format);
  653.  
  654. if (score > cur_score) {
  655. sync_fp = fp;
  656. cur_score = score;
  657. }
  658. }
  659.  
  660. if (unlikely(sync_fp == NULL)) {
  661. dev_err(&subs->dev->dev,
  662. "%s: no valid audioformat for sync ep %x found\n",
  663. __func__, sync_subs->ep_num);
  664. return -EINVAL;
  665. }
  666.  
  667. /*
  668. * Recalculate the period bytes if channel number differ between
  669. * data and sync ep audioformat.
  670. */
  671. if (sync_fp->channels != subs->channels) {
  672. sync_period_bytes = (subs->period_bytes / subs->channels) *
  673. sync_fp->channels;
  674. dev_dbg(&subs->dev->dev,
  675. "%s: adjusted sync ep period bytes (%d -> %d)\n",
  676. __func__, subs->period_bytes, sync_period_bytes);
  677. }
  678.  
  679. ret = snd_usb_endpoint_set_params(subs->sync_endpoint,
  680. subs->pcm_format,
  681. sync_fp->channels,
  682. sync_period_bytes,
  683. 0, 0,
  684. subs->cur_rate,
  685. sync_fp,
  686. NULL);
  687.  
  688. return ret;
  689. }
  690.  
  691. /*
  692. * configure endpoint params
  693. *
  694. * called during initial setup and upon resume
  695. */
  696. static int configure_endpoint(struct snd_usb_substream *subs)
  697. {
  698. int ret;
  699.  
  700. /* format changed */
  701. stop_endpoints(subs, true);
  702. ret = snd_usb_endpoint_set_params(subs->data_endpoint,
  703. subs->pcm_format,
  704. subs->channels,
  705. subs->period_bytes,
  706. subs->period_frames,
  707. subs->buffer_periods,
  708. subs->cur_rate,
  709. subs->cur_audiofmt,
  710. subs->sync_endpoint);
  711. if (ret < 0)
  712. return ret;
  713.  
  714. if (subs->sync_endpoint)
  715. ret = configure_sync_endpoint(subs);
  716.  
  717. return ret;
  718. }
  719.  
  720. static int snd_usb_pcm_change_state(struct snd_usb_substream *subs, int state)
  721. {
  722. int ret;
  723.  
  724. if (!subs->str_pd)
  725. return 0;
  726.  
  727. ret = snd_usb_power_domain_set(subs->stream->chip, subs->str_pd, state);
  728. if (ret < 0) {
  729. dev_err(&subs->dev->dev,
  730. "Cannot change Power Domain ID: %d to state: %d. Err: %d\n",
  731. subs->str_pd->pd_id, state, ret);
  732. return ret;
  733. }
  734.  
  735. return 0;
  736. }
  737.  
  738. int snd_usb_pcm_suspend(struct snd_usb_stream *as)
  739. {
  740. int ret;
  741.  
  742. ret = snd_usb_pcm_change_state(&as->substream[0], UAC3_PD_STATE_D2);
  743. if (ret < 0)
  744. return ret;
  745.  
  746. ret = snd_usb_pcm_change_state(&as->substream[1], UAC3_PD_STATE_D2);
  747. if (ret < 0)
  748. return ret;
  749.  
  750. return 0;
  751. }
  752.  
  753. int snd_usb_pcm_resume(struct snd_usb_stream *as)
  754. {
  755. int ret;
  756.  
  757. ret = snd_usb_pcm_change_state(&as->substream[0], UAC3_PD_STATE_D1);
  758. if (ret < 0)
  759. return ret;
  760.  
  761. ret = snd_usb_pcm_change_state(&as->substream[1], UAC3_PD_STATE_D1);
  762. if (ret < 0)
  763. return ret;
  764.  
  765. return 0;
  766. }
  767.  
  768. /*
  769. * hw_params callback
  770. *
  771. * allocate a buffer and set the given audio format.
  772. *
  773. * so far we use a physically linear buffer although packetize transfer
  774. * doesn't need a continuous area.
  775. * if sg buffer is supported on the later version of alsa, we'll follow
  776. * that.
  777. */
  778. static int snd_usb_hw_params(struct snd_pcm_substream *substream,
  779. struct snd_pcm_hw_params *hw_params)
  780. {
  781. struct snd_usb_substream *subs = substream->runtime->private_data;
  782. struct audioformat *fmt;
  783. int ret;
  784.  
  785. ret = snd_media_start_pipeline(subs);
  786. if (ret)
  787. return ret;
  788.  
  789. if (snd_usb_use_vmalloc)
  790. ret = snd_pcm_lib_alloc_vmalloc_buffer(substream,
  791. params_buffer_bytes(hw_params));
  792. else
  793. ret = snd_pcm_lib_malloc_pages(substream,
  794. params_buffer_bytes(hw_params));
  795. if (ret < 0)
  796. goto stop_pipeline;
  797.  
  798. subs->pcm_format = params_format(hw_params);
  799. subs->period_bytes = params_period_bytes(hw_params);
  800. subs->period_frames = params_period_size(hw_params);
  801. subs->buffer_periods = params_periods(hw_params);
  802. subs->channels = params_channels(hw_params);
  803. subs->cur_rate = params_rate(hw_params);
  804.  
  805. fmt = find_format(subs);
  806. if (!fmt) {
  807. dev_dbg(&subs->dev->dev,
  808. "cannot set format: format = %#x, rate = %d, channels = %d\n",
  809. subs->pcm_format, subs->cur_rate, subs->channels);
  810. ret = -EINVAL;
  811. goto stop_pipeline;
  812. }
  813.  
  814. ret = snd_usb_lock_shutdown(subs->stream->chip);
  815. if (ret < 0)
  816. goto stop_pipeline;
  817.  
  818. ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D0);
  819. if (ret < 0)
  820. goto unlock;
  821.  
  822. ret = set_format(subs, fmt);
  823. if (ret < 0)
  824. goto unlock;
  825.  
  826. subs->interface = fmt->iface;
  827. subs->altset_idx = fmt->altset_idx;
  828. subs->need_setup_ep = true;
  829.  
  830. unlock:
  831. snd_usb_unlock_shutdown(subs->stream->chip);
  832. if (ret < 0)
  833. goto stop_pipeline;
  834. return ret;
  835.  
  836. stop_pipeline:
  837. snd_media_stop_pipeline(subs);
  838. return ret;
  839. }
  840.  
  841. /*
  842. * hw_free callback
  843. *
  844. * reset the audio format and release the buffer
  845. */
  846. static int snd_usb_hw_free(struct snd_pcm_substream *substream)
  847. {
  848. struct snd_usb_substream *subs = substream->runtime->private_data;
  849.  
  850. snd_media_stop_pipeline(subs);
  851. subs->cur_audiofmt = NULL;
  852. subs->cur_rate = 0;
  853. subs->period_bytes = 0;
  854. if (!snd_usb_lock_shutdown(subs->stream->chip)) {
  855. stop_endpoints(subs, true);
  856. snd_usb_endpoint_deactivate(subs->sync_endpoint);
  857. snd_usb_endpoint_deactivate(subs->data_endpoint);
  858. snd_usb_unlock_shutdown(subs->stream->chip);
  859. }
  860.  
  861. if (snd_usb_use_vmalloc)
  862. return snd_pcm_lib_free_vmalloc_buffer(substream);
  863. else
  864. return snd_pcm_lib_free_pages(substream);
  865. }
  866.  
  867. /*
  868. * prepare callback
  869. *
  870. * only a few subtle things...
  871. */
  872. static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream)
  873. {
  874. struct snd_pcm_runtime *runtime = substream->runtime;
  875. struct snd_usb_substream *subs = runtime->private_data;
  876. struct usb_host_interface *alts;
  877. struct usb_interface *iface;
  878. int ret;
  879.  
  880. if (! subs->cur_audiofmt) {
  881. dev_err(&subs->dev->dev, "no format is specified!\n");
  882. return -ENXIO;
  883. }
  884.  
  885. ret = snd_usb_lock_shutdown(subs->stream->chip);
  886. if (ret < 0)
  887. return ret;
  888. if (snd_BUG_ON(!subs->data_endpoint)) {
  889. ret = -EIO;
  890. goto unlock;
  891. }
  892.  
  893. snd_usb_endpoint_sync_pending_stop(subs->sync_endpoint);
  894. snd_usb_endpoint_sync_pending_stop(subs->data_endpoint);
  895.  
  896. ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D0);
  897. if (ret < 0)
  898. goto unlock;
  899.  
  900. ret = set_format(subs, subs->cur_audiofmt);
  901. if (ret < 0)
  902. goto unlock;
  903.  
  904. if (subs->need_setup_ep) {
  905.  
  906. iface = usb_ifnum_to_if(subs->dev, subs->cur_audiofmt->iface);
  907. alts = &iface->altsetting[subs->cur_audiofmt->altset_idx];
  908. ret = snd_usb_init_sample_rate(subs->stream->chip,
  909. subs->cur_audiofmt->iface,
  910. alts,
  911. subs->cur_audiofmt,
  912. subs->cur_rate);
  913. if (ret < 0)
  914. goto unlock;
  915.  
  916. ret = configure_endpoint(subs);
  917. if (ret < 0)
  918. goto unlock;
  919. subs->need_setup_ep = false;
  920. }
  921.  
  922. /* some unit conversions in runtime */
  923. subs->data_endpoint->maxframesize =
  924. bytes_to_frames(runtime, subs->data_endpoint->maxpacksize);
  925. subs->data_endpoint->curframesize =
  926. bytes_to_frames(runtime, subs->data_endpoint->curpacksize);
  927.  
  928. /* reset the pointer */
  929. subs->hwptr_done = 0;
  930. subs->transfer_done = 0;
  931. subs->last_delay = 0;
  932. subs->last_frame_number = 0;
  933. runtime->delay = 0;
  934.  
  935. /* for playback, submit the URBs now; otherwise, the first hwptr_done
  936. * updates for all URBs would happen at the same time when starting */
  937. if (subs->direction == SNDRV_PCM_STREAM_PLAYBACK)
  938. ret = start_endpoints(subs);
  939.  
  940. unlock:
  941. snd_usb_unlock_shutdown(subs->stream->chip);
  942. return ret;
  943. }
  944.  
  945. static const struct snd_pcm_hardware snd_usb_hardware =
  946. {
  947. .info = SNDRV_PCM_INFO_MMAP |
  948. SNDRV_PCM_INFO_MMAP_VALID |
  949. SNDRV_PCM_INFO_BATCH |
  950. SNDRV_PCM_INFO_INTERLEAVED |
  951. SNDRV_PCM_INFO_BLOCK_TRANSFER |
  952. SNDRV_PCM_INFO_PAUSE,
  953. .buffer_bytes_max = 1024 * 1024,
  954. .period_bytes_min = 64,
  955. .period_bytes_max = 512 * 1024,
  956. .periods_min = 2,
  957. .periods_max = 1024,
  958. };
  959.  
  960. static int hw_check_valid_format(struct snd_usb_substream *subs,
  961. struct snd_pcm_hw_params *params,
  962. struct audioformat *fp)
  963. {
  964. struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
  965. struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
  966. struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
  967. struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
  968. struct snd_mask check_fmts;
  969. unsigned int ptime;
  970.  
  971. /* check the format */
  972. snd_mask_none(&check_fmts);
  973. check_fmts.bits[0] = (u32)fp->formats;
  974. check_fmts.bits[1] = (u32)(fp->formats >> 32);
  975. snd_mask_intersect(&check_fmts, fmts);
  976. if (snd_mask_empty(&check_fmts)) {
  977. hwc_debug(" > check: no supported format %d\n", fp->format);
  978. return 0;
  979. }
  980. /* check the channels */
  981. if (fp->channels < ct->min || fp->channels > ct->max) {
  982. hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max);
  983. return 0;
  984. }
  985. /* check the rate is within the range */
  986. if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) {
  987. hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max);
  988. return 0;
  989. }
  990. if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) {
  991. hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min);
  992. return 0;
  993. }
  994. /* check whether the period time is >= the data packet interval */
  995. if (subs->speed != USB_SPEED_FULL) {
  996. ptime = 125 * (1 << fp->datainterval);
  997. if (ptime > pt->max || (ptime == pt->max && pt->openmax)) {
  998. hwc_debug(" > check: ptime %u > max %u\n", ptime, pt->max);
  999. return 0;
  1000. }
  1001. }
  1002. return 1;
  1003. }
  1004.  
  1005. static int hw_rule_rate(struct snd_pcm_hw_params *params,
  1006. struct snd_pcm_hw_rule *rule)
  1007. {
  1008. struct snd_usb_substream *subs = rule->private;
  1009. struct audioformat *fp;
  1010. struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
  1011. unsigned int rmin, rmax;
  1012. int changed;
  1013.  
  1014. hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max);
  1015. changed = 0;
  1016. rmin = rmax = 0;
  1017. list_for_each_entry(fp, &subs->fmt_list, list) {
  1018. if (!hw_check_valid_format(subs, params, fp))
  1019. continue;
  1020. if (changed++) {
  1021. if (rmin > fp->rate_min)
  1022. rmin = fp->rate_min;
  1023. if (rmax < fp->rate_max)
  1024. rmax = fp->rate_max;
  1025. } else {
  1026. rmin = fp->rate_min;
  1027. rmax = fp->rate_max;
  1028. }
  1029. }
  1030.  
  1031. if (!changed) {
  1032. hwc_debug(" --> get empty\n");
  1033. it->empty = 1;
  1034. return -EINVAL;
  1035. }
  1036.  
  1037. changed = 0;
  1038. if (it->min < rmin) {
  1039. it->min = rmin;
  1040. it->openmin = 0;
  1041. changed = 1;
  1042. }
  1043. if (it->max > rmax) {
  1044. it->max = rmax;
  1045. it->openmax = 0;
  1046. changed = 1;
  1047. }
  1048. if (snd_interval_checkempty(it)) {
  1049. it->empty = 1;
  1050. return -EINVAL;
  1051. }
  1052. hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
  1053. return changed;
  1054. }
  1055.  
  1056.  
  1057. static int hw_rule_channels(struct snd_pcm_hw_params *params,
  1058. struct snd_pcm_hw_rule *rule)
  1059. {
  1060. struct snd_usb_substream *subs = rule->private;
  1061. struct audioformat *fp;
  1062. struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
  1063. unsigned int rmin, rmax;
  1064. int changed;
  1065.  
  1066. hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max);
  1067. changed = 0;
  1068. rmin = rmax = 0;
  1069. list_for_each_entry(fp, &subs->fmt_list, list) {
  1070. if (!hw_check_valid_format(subs, params, fp))
  1071. continue;
  1072. if (changed++) {
  1073. if (rmin > fp->channels)
  1074. rmin = fp->channels;
  1075. if (rmax < fp->channels)
  1076. rmax = fp->channels;
  1077. } else {
  1078. rmin = fp->channels;
  1079. rmax = fp->channels;
  1080. }
  1081. }
  1082.  
  1083. if (!changed) {
  1084. hwc_debug(" --> get empty\n");
  1085. it->empty = 1;
  1086. return -EINVAL;
  1087. }
  1088.  
  1089. changed = 0;
  1090. if (it->min < rmin) {
  1091. it->min = rmin;
  1092. it->openmin = 0;
  1093. changed = 1;
  1094. }
  1095. if (it->max > rmax) {
  1096. it->max = rmax;
  1097. it->openmax = 0;
  1098. changed = 1;
  1099. }
  1100. if (snd_interval_checkempty(it)) {
  1101. it->empty = 1;
  1102. return -EINVAL;
  1103. }
  1104. hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed);
  1105. return changed;
  1106. }
  1107.  
  1108. static int hw_rule_format(struct snd_pcm_hw_params *params,
  1109. struct snd_pcm_hw_rule *rule)
  1110. {
  1111. struct snd_usb_substream *subs = rule->private;
  1112. struct audioformat *fp;
  1113. struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
  1114. u64 fbits;
  1115. u32 oldbits[2];
  1116. int changed;
  1117.  
  1118. hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]);
  1119. fbits = 0;
  1120. list_for_each_entry(fp, &subs->fmt_list, list) {
  1121. if (!hw_check_valid_format(subs, params, fp))
  1122. continue;
  1123. fbits |= fp->formats;
  1124. }
  1125.  
  1126. oldbits[0] = fmt->bits[0];
  1127. oldbits[1] = fmt->bits[1];
  1128. fmt->bits[0] &= (u32)fbits;
  1129. fmt->bits[1] &= (u32)(fbits >> 32);
  1130. if (!fmt->bits[0] && !fmt->bits[1]) {
  1131. hwc_debug(" --> get empty\n");
  1132. return -EINVAL;
  1133. }
  1134. changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]);
  1135. hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed);
  1136. return changed;
  1137. }
  1138.  
  1139. static int hw_rule_period_time(struct snd_pcm_hw_params *params,
  1140. struct snd_pcm_hw_rule *rule)
  1141. {
  1142. struct snd_usb_substream *subs = rule->private;
  1143. struct audioformat *fp;
  1144. struct snd_interval *it;
  1145. unsigned char min_datainterval;
  1146. unsigned int pmin;
  1147. int changed;
  1148.  
  1149. it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME);
  1150. hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max);
  1151. min_datainterval = 0xff;
  1152. list_for_each_entry(fp, &subs->fmt_list, list) {
  1153. if (!hw_check_valid_format(subs, params, fp))
  1154. continue;
  1155. min_datainterval = min(min_datainterval, fp->datainterval);
  1156. }
  1157. if (min_datainterval == 0xff) {
  1158. hwc_debug(" --> get empty\n");
  1159. it->empty = 1;
  1160. return -EINVAL;
  1161. }
  1162. pmin = 125 * (1 << min_datainterval);
  1163. changed = 0;
  1164. if (it->min < pmin) {
  1165. it->min = pmin;
  1166. it->openmin = 0;
  1167. changed = 1;
  1168. }
  1169. if (snd_interval_checkempty(it)) {
  1170. it->empty = 1;
  1171. return -EINVAL;
  1172. }
  1173. hwc_debug(" --> (%u,%u) (changed = %d)\n", it->min, it->max, changed);
  1174. return changed;
  1175. }
  1176.  
  1177. /*
  1178. * If the device supports unusual bit rates, does the request meet these?
  1179. */
  1180. static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime,
  1181. struct snd_usb_substream *subs)
  1182. {
  1183. struct audioformat *fp;
  1184. int *rate_list;
  1185. int count = 0, needs_knot = 0;
  1186. int err;
  1187.  
  1188. kfree(subs->rate_list.list);
  1189. subs->rate_list.list = NULL;
  1190.  
  1191. list_for_each_entry(fp, &subs->fmt_list, list) {
  1192. if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)
  1193. return 0;
  1194. count += fp->nr_rates;
  1195. if (fp->rates & SNDRV_PCM_RATE_KNOT)
  1196. needs_knot = 1;
  1197. }
  1198. if (!needs_knot)
  1199. return 0;
  1200.  
  1201. subs->rate_list.list = rate_list =
  1202. kmalloc_array(count, sizeof(int), GFP_KERNEL);
  1203. if (!subs->rate_list.list)
  1204. return -ENOMEM;
  1205. subs->rate_list.count = count;
  1206. subs->rate_list.mask = 0;
  1207. count = 0;
  1208. list_for_each_entry(fp, &subs->fmt_list, list) {
  1209. int i;
  1210. for (i = 0; i < fp->nr_rates; i++)
  1211. rate_list[count++] = fp->rate_table[i];
  1212. }
  1213. err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
  1214. &subs->rate_list);
  1215. if (err < 0)
  1216. return err;
  1217.  
  1218. return 0;
  1219. }
  1220.  
  1221.  
  1222. /*
  1223. * set up the runtime hardware information.
  1224. */
  1225.  
  1226. static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs)
  1227. {
  1228. struct audioformat *fp;
  1229. unsigned int pt, ptmin;
  1230. int param_period_time_if_needed;
  1231. int err;
  1232.  
  1233. runtime->hw.formats = subs->formats;
  1234.  
  1235. runtime->hw.rate_min = 0x7fffffff;
  1236. runtime->hw.rate_max = 0;
  1237. runtime->hw.channels_min = 256;
  1238. runtime->hw.channels_max = 0;
  1239. runtime->hw.rates = 0;
  1240. ptmin = UINT_MAX;
  1241. /* check min/max rates and channels */
  1242. list_for_each_entry(fp, &subs->fmt_list, list) {
  1243. runtime->hw.rates |= fp->rates;
  1244. if (runtime->hw.rate_min > fp->rate_min)
  1245. runtime->hw.rate_min = fp->rate_min;
  1246. if (runtime->hw.rate_max < fp->rate_max)
  1247. runtime->hw.rate_max = fp->rate_max;
  1248. if (runtime->hw.channels_min > fp->channels)
  1249. runtime->hw.channels_min = fp->channels;
  1250. if (runtime->hw.channels_max < fp->channels)
  1251. runtime->hw.channels_max = fp->channels;
  1252. if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) {
  1253. /* FIXME: there might be more than one audio formats... */
  1254. runtime->hw.period_bytes_min = runtime->hw.period_bytes_max =
  1255. fp->frame_size;
  1256. }
  1257. pt = 125 * (1 << fp->datainterval);
  1258. ptmin = min(ptmin, pt);
  1259. }
  1260.  
  1261. param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME;
  1262. if (subs->speed == USB_SPEED_FULL)
  1263. /* full speed devices have fixed data packet interval */
  1264. ptmin = 1000;
  1265. if (ptmin == 1000)
  1266. /* if period time doesn't go below 1 ms, no rules needed */
  1267. param_period_time_if_needed = -1;
  1268.  
  1269. err = snd_pcm_hw_constraint_minmax(runtime,
  1270. SNDRV_PCM_HW_PARAM_PERIOD_TIME,
  1271. ptmin, UINT_MAX);
  1272. if (err < 0)
  1273. return err;
  1274.  
  1275. err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
  1276. hw_rule_rate, subs,
  1277. SNDRV_PCM_HW_PARAM_FORMAT,
  1278. SNDRV_PCM_HW_PARAM_CHANNELS,
  1279. param_period_time_if_needed,
  1280. -1);
  1281. if (err < 0)
  1282. return err;
  1283. err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS,
  1284. hw_rule_channels, subs,
  1285. SNDRV_PCM_HW_PARAM_FORMAT,
  1286. SNDRV_PCM_HW_PARAM_RATE,
  1287. param_period_time_if_needed,
  1288. -1);
  1289. if (err < 0)
  1290. return err;
  1291. err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT,
  1292. hw_rule_format, subs,
  1293. SNDRV_PCM_HW_PARAM_RATE,
  1294. SNDRV_PCM_HW_PARAM_CHANNELS,
  1295. param_period_time_if_needed,
  1296. -1);
  1297. if (err < 0)
  1298. return err;
  1299. if (param_period_time_if_needed >= 0) {
  1300. err = snd_pcm_hw_rule_add(runtime, 0,
  1301. SNDRV_PCM_HW_PARAM_PERIOD_TIME,
  1302. hw_rule_period_time, subs,
  1303. SNDRV_PCM_HW_PARAM_FORMAT,
  1304. SNDRV_PCM_HW_PARAM_CHANNELS,
  1305. SNDRV_PCM_HW_PARAM_RATE,
  1306. -1);
  1307. if (err < 0)
  1308. return err;
  1309. }
  1310. err = snd_usb_pcm_check_knot(runtime, subs);
  1311. if (err < 0)
  1312. return err;
  1313.  
  1314. return snd_usb_autoresume(subs->stream->chip);
  1315. }
  1316.  
  1317. static int snd_usb_pcm_open(struct snd_pcm_substream *substream)
  1318. {
  1319. int direction = substream->stream;
  1320. struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
  1321. struct snd_pcm_runtime *runtime = substream->runtime;
  1322. struct snd_usb_substream *subs = &as->substream[direction];
  1323. int ret;
  1324.  
  1325. subs->interface = -1;
  1326. subs->altset_idx = 0;
  1327. runtime->hw = snd_usb_hardware;
  1328. runtime->private_data = subs;
  1329. subs->pcm_substream = substream;
  1330. /* runtime PM is also done there */
  1331.  
  1332. /* initialize DSD/DOP context */
  1333. subs->dsd_dop.byte_idx = 0;
  1334. subs->dsd_dop.channel = 0;
  1335. subs->dsd_dop.marker = 1;
  1336.  
  1337. ret = setup_hw_info(runtime, subs);
  1338. if (ret == 0) {
  1339. ret = snd_media_stream_init(subs, as->pcm, direction);
  1340. if (ret)
  1341. snd_usb_autosuspend(subs->stream->chip);
  1342. }
  1343. return ret;
  1344. }
  1345.  
  1346. static int snd_usb_pcm_close(struct snd_pcm_substream *substream)
  1347. {
  1348. int direction = substream->stream;
  1349. struct snd_usb_stream *as = snd_pcm_substream_chip(substream);
  1350. struct snd_usb_substream *subs = &as->substream[direction];
  1351. int ret;
  1352.  
  1353. stop_endpoints(subs, true);
  1354. snd_media_stop_pipeline(subs);
  1355.  
  1356. if (!as->chip->keep_iface &&
  1357. subs->interface >= 0 &&
  1358. !snd_usb_lock_shutdown(subs->stream->chip)) {
  1359. usb_set_interface(subs->dev, subs->interface, 0);
  1360. subs->interface = -1;
  1361. ret = snd_usb_pcm_change_state(subs, UAC3_PD_STATE_D1);
  1362. snd_usb_unlock_shutdown(subs->stream->chip);
  1363. if (ret < 0)
  1364. return ret;
  1365. }
  1366.  
  1367. subs->pcm_substream = NULL;
  1368. snd_usb_autosuspend(subs->stream->chip);
  1369.  
  1370. return 0;
  1371. }
  1372.  
  1373. /* Since a URB can handle only a single linear buffer, we must use double
  1374. * buffering when the data to be transferred overflows the buffer boundary.
  1375. * To avoid inconsistencies when updating hwptr_done, we use double buffering
  1376. * for all URBs.
  1377. */
  1378. static void retire_capture_urb(struct snd_usb_substream *subs,
  1379. struct urb *urb)
  1380. {
  1381. struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
  1382. unsigned int stride, frames, bytes, oldptr;
  1383. int i, period_elapsed = 0;
  1384. unsigned long flags;
  1385. unsigned char *cp;
  1386. int current_frame_number;
  1387.  
  1388. /* read frame number here, update pointer in critical section */
  1389. current_frame_number = usb_get_current_frame_number(subs->dev);
  1390.  
  1391. stride = runtime->frame_bits >> 3;
  1392.  
  1393. for (i = 0; i < urb->number_of_packets; i++) {
  1394. cp = (unsigned char *)urb->transfer_buffer + urb->iso_frame_desc[i].offset + subs->pkt_offset_adj;
  1395. if (urb->iso_frame_desc[i].status && printk_ratelimit()) {
  1396. dev_dbg(&subs->dev->dev, "frame %d active: %d\n",
  1397. i, urb->iso_frame_desc[i].status);
  1398. // continue;
  1399. }
  1400. bytes = urb->iso_frame_desc[i].actual_length;
  1401. frames = bytes / stride;
  1402. if (!subs->txfr_quirk)
  1403. bytes = frames * stride;
  1404. if (bytes % (runtime->sample_bits >> 3) != 0) {
  1405. int oldbytes = bytes;
  1406. bytes = frames * stride;
  1407. dev_warn_ratelimited(&subs->dev->dev,
  1408. "Corrected urb data len. %d->%d\n",
  1409. oldbytes, bytes);
  1410. }
  1411. /* update the current pointer */
  1412. spin_lock_irqsave(&subs->lock, flags);
  1413. oldptr = subs->hwptr_done;
  1414. subs->hwptr_done += bytes;
  1415. if (subs->hwptr_done >= runtime->buffer_size * stride)
  1416. subs->hwptr_done -= runtime->buffer_size * stride;
  1417. frames = (bytes + (oldptr % stride)) / stride;
  1418. subs->transfer_done += frames;
  1419. if (subs->transfer_done >= runtime->period_size) {
  1420. subs->transfer_done -= runtime->period_size;
  1421. period_elapsed = 1;
  1422. }
  1423. /* capture delay is by construction limited to one URB,
  1424. * reset delays here
  1425. */
  1426. runtime->delay = subs->last_delay = 0;
  1427.  
  1428. /* realign last_frame_number */
  1429. subs->last_frame_number = current_frame_number;
  1430. subs->last_frame_number &= 0xFF; /* keep 8 LSBs */
  1431.  
  1432. spin_unlock_irqrestore(&subs->lock, flags);
  1433. /* copy a data chunk */
  1434. if (oldptr + bytes > runtime->buffer_size * stride) {
  1435. unsigned int bytes1 =
  1436. runtime->buffer_size * stride - oldptr;
  1437. memcpy(runtime->dma_area + oldptr, cp, bytes1);
  1438. memcpy(runtime->dma_area, cp + bytes1, bytes - bytes1);
  1439. } else {
  1440. memcpy(runtime->dma_area + oldptr, cp, bytes);
  1441. }
  1442. }
  1443.  
  1444. if (period_elapsed)
  1445. snd_pcm_period_elapsed(subs->pcm_substream);
  1446. }
  1447.  
  1448. static inline void fill_playback_urb_dsd_dop(struct snd_usb_substream *subs,
  1449. struct urb *urb, unsigned int bytes)
  1450. {
  1451. struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
  1452. unsigned int stride = runtime->frame_bits >> 3;
  1453. unsigned int dst_idx = 0;
  1454. unsigned int src_idx = subs->hwptr_done;
  1455. unsigned int wrap = runtime->buffer_size * stride;
  1456. u8 *dst = urb->transfer_buffer;
  1457. u8 *src = runtime->dma_area;
  1458. u8 marker[] = { 0x05, 0xfa };
  1459.  
  1460. /*
  1461. * The DSP DOP format defines a way to transport DSD samples over
  1462. * normal PCM data endpoints. It requires stuffing of marker bytes
  1463. * (0x05 and 0xfa, alternating per sample frame), and then expects
  1464. * 2 additional bytes of actual payload. The whole frame is stored
  1465. * LSB.
  1466. *
  1467. * Hence, for a stereo transport, the buffer layout looks like this,
  1468. * where L refers to left channel samples and R to right.
  1469. *
  1470. * L1 L2 0x05 R1 R2 0x05 L3 L4 0xfa R3 R4 0xfa
  1471. * L5 L6 0x05 R5 R6 0x05 L7 L8 0xfa R7 R8 0xfa
  1472. * .....
  1473. *
  1474. */
  1475.  
  1476. while (bytes--) {
  1477. if (++subs->dsd_dop.byte_idx == 3) {
  1478. /* frame boundary? */
  1479. dst[dst_idx++] = marker[subs->dsd_dop.marker];
  1480. src_idx += 2;
  1481. subs->dsd_dop.byte_idx = 0;
  1482.  
  1483. if (++subs->dsd_dop.channel % runtime->channels == 0) {
  1484. /* alternate the marker */
  1485. subs->dsd_dop.marker++;
  1486. subs->dsd_dop.marker %= ARRAY_SIZE(marker);
  1487. subs->dsd_dop.channel = 0;
  1488. }
  1489. } else {
  1490. /* stuff the DSD payload */
  1491. int idx = (src_idx + subs->dsd_dop.byte_idx - 1) % wrap;
  1492.  
  1493. if (subs->cur_audiofmt->dsd_bitrev)
  1494. dst[dst_idx++] = bitrev8(src[idx]);
  1495. else
  1496. dst[dst_idx++] = src[idx];
  1497.  
  1498. subs->hwptr_done++;
  1499. }
  1500. }
  1501. if (subs->hwptr_done >= runtime->buffer_size * stride)
  1502. subs->hwptr_done -= runtime->buffer_size * stride;
  1503. }
  1504.  
  1505. static void copy_to_urb(struct snd_usb_substream *subs, struct urb *urb,
  1506. int offset, int stride, unsigned int bytes)
  1507. {
  1508. struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
  1509.  
  1510. if (subs->hwptr_done + bytes > runtime->buffer_size * stride) {
  1511. /* err, the transferred area goes over buffer boundary. */
  1512. unsigned int bytes1 =
  1513. runtime->buffer_size * stride - subs->hwptr_done;
  1514. memcpy(urb->transfer_buffer + offset,
  1515. runtime->dma_area + subs->hwptr_done, bytes1);
  1516. memcpy(urb->transfer_buffer + offset + bytes1,
  1517. runtime->dma_area, bytes - bytes1);
  1518. } else {
  1519. memcpy(urb->transfer_buffer + offset,
  1520. runtime->dma_area + subs->hwptr_done, bytes);
  1521. }
  1522. subs->hwptr_done += bytes;
  1523. if (subs->hwptr_done >= runtime->buffer_size * stride)
  1524. subs->hwptr_done -= runtime->buffer_size * stride;
  1525. }
  1526.  
  1527. static unsigned int copy_to_urb_quirk(struct snd_usb_substream *subs,
  1528. struct urb *urb, int stride,
  1529. unsigned int bytes)
  1530. {
  1531. __le32 packet_length;
  1532. int i;
  1533.  
  1534. /* Put __le32 length descriptor at start of each packet. */
  1535. for (i = 0; i < urb->number_of_packets; i++) {
  1536. unsigned int length = urb->iso_frame_desc[i].length;
  1537. unsigned int offset = urb->iso_frame_desc[i].offset;
  1538.  
  1539. packet_length = cpu_to_le32(length);
  1540. offset += i * sizeof(packet_length);
  1541. urb->iso_frame_desc[i].offset = offset;
  1542. urb->iso_frame_desc[i].length += sizeof(packet_length);
  1543. memcpy(urb->transfer_buffer + offset,
  1544. &packet_length, sizeof(packet_length));
  1545. copy_to_urb(subs, urb, offset + sizeof(packet_length),
  1546. stride, length);
  1547. }
  1548. /* Adjust transfer size accordingly. */
  1549. bytes += urb->number_of_packets * sizeof(packet_length);
  1550. return bytes;
  1551. }
  1552.  
  1553. static void prepare_playback_urb(struct snd_usb_substream *subs,
  1554. struct urb *urb)
  1555. {
  1556. struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
  1557. struct snd_usb_endpoint *ep = subs->data_endpoint;
  1558. struct snd_urb_ctx *ctx = urb->context;
  1559. unsigned int counts, frames, bytes;
  1560. int i, stride, period_elapsed = 0;
  1561. unsigned long flags;
  1562.  
  1563. stride = runtime->frame_bits >> 3;
  1564.  
  1565. frames = 0;
  1566. urb->number_of_packets = 0;
  1567. spin_lock_irqsave(&subs->lock, flags);
  1568. subs->frame_limit += ep->max_urb_frames;
  1569. for (i = 0; i < ctx->packets; i++) {
  1570. if (ctx->packet_size[i])
  1571. counts = ctx->packet_size[i];
  1572. else
  1573. counts = snd_usb_endpoint_next_packet_size(ep);
  1574.  
  1575. /* set up descriptor */
  1576. urb->iso_frame_desc[i].offset = frames * ep->stride;
  1577. urb->iso_frame_desc[i].length = counts * ep->stride;
  1578. frames += counts;
  1579. urb->number_of_packets++;
  1580. subs->transfer_done += counts;
  1581. if (subs->transfer_done >= runtime->period_size) {
  1582. subs->transfer_done -= runtime->period_size;
  1583. subs->frame_limit = 0;
  1584. period_elapsed = 1;
  1585. if (subs->fmt_type == UAC_FORMAT_TYPE_II) {
  1586. if (subs->transfer_done > 0) {
  1587. /* FIXME: fill-max mode is not
  1588. * supported yet */
  1589. frames -= subs->transfer_done;
  1590. counts -= subs->transfer_done;
  1591. urb->iso_frame_desc[i].length =
  1592. counts * ep->stride;
  1593. subs->transfer_done = 0;
  1594. }
  1595. i++;
  1596. if (i < ctx->packets) {
  1597. /* add a transfer delimiter */
  1598. urb->iso_frame_desc[i].offset =
  1599. frames * ep->stride;
  1600. urb->iso_frame_desc[i].length = 0;
  1601. urb->number_of_packets++;
  1602. }
  1603. break;
  1604. }
  1605. }
  1606. /* finish at the period boundary or after enough frames */
  1607. if ((period_elapsed ||
  1608. subs->transfer_done >= subs->frame_limit) &&
  1609. !snd_usb_endpoint_implicit_feedback_sink(ep))
  1610. break;
  1611. }
  1612. bytes = frames * ep->stride;
  1613.  
  1614. if (unlikely(subs->pcm_format == SNDRV_PCM_FORMAT_DSD_U16_LE &&
  1615. subs->cur_audiofmt->dsd_dop)) {
  1616. fill_playback_urb_dsd_dop(subs, urb, bytes);
  1617. } else if (unlikely(subs->pcm_format == SNDRV_PCM_FORMAT_DSD_U8 &&
  1618. subs->cur_audiofmt->dsd_bitrev)) {
  1619. /* bit-reverse the bytes */
  1620. u8 *buf = urb->transfer_buffer;
  1621. for (i = 0; i < bytes; i++) {
  1622. int idx = (subs->hwptr_done + i)
  1623. % (runtime->buffer_size * stride);
  1624. buf[i] = bitrev8(runtime->dma_area[idx]);
  1625. }
  1626.  
  1627. subs->hwptr_done += bytes;
  1628. if (subs->hwptr_done >= runtime->buffer_size * stride)
  1629. subs->hwptr_done -= runtime->buffer_size * stride;
  1630. } else {
  1631. /* usual PCM */
  1632. if (!subs->tx_length_quirk)
  1633. copy_to_urb(subs, urb, 0, stride, bytes);
  1634. else
  1635. bytes = copy_to_urb_quirk(subs, urb, stride, bytes);
  1636. /* bytes is now amount of outgoing data */
  1637. }
  1638.  
  1639. /* update delay with exact number of samples queued */
  1640. runtime->delay = subs->last_delay;
  1641. runtime->delay += frames;
  1642. subs->last_delay = runtime->delay;
  1643.  
  1644. /* realign last_frame_number */
  1645. subs->last_frame_number = usb_get_current_frame_number(subs->dev);
  1646. subs->last_frame_number &= 0xFF; /* keep 8 LSBs */
  1647.  
  1648. if (subs->trigger_tstamp_pending_update) {
  1649. /* this is the first actual URB submitted,
  1650. * update trigger timestamp to reflect actual start time
  1651. */
  1652. snd_pcm_gettime(runtime, &runtime->trigger_tstamp);
  1653. subs->trigger_tstamp_pending_update = false;
  1654. }
  1655.  
  1656. spin_unlock_irqrestore(&subs->lock, flags);
  1657. urb->transfer_buffer_length = bytes;
  1658. if (period_elapsed)
  1659. snd_pcm_period_elapsed(subs->pcm_substream);
  1660. }
  1661.  
  1662. /*
  1663. * process after playback data complete
  1664. * - decrease the delay count again
  1665. */
  1666. static void retire_playback_urb(struct snd_usb_substream *subs,
  1667. struct urb *urb)
  1668. {
  1669. unsigned long flags;
  1670. struct snd_pcm_runtime *runtime = subs->pcm_substream->runtime;
  1671. struct snd_usb_endpoint *ep = subs->data_endpoint;
  1672. int processed = urb->transfer_buffer_length / ep->stride;
  1673. int est_delay;
  1674.  
  1675. /* ignore the delay accounting when procssed=0 is given, i.e.
  1676. * silent payloads are procssed before handling the actual data
  1677. */
  1678. if (!processed)
  1679. return;
  1680.  
  1681. spin_lock_irqsave(&subs->lock, flags);
  1682. if (!subs->last_delay)
  1683. goto out; /* short path */
  1684.  
  1685. est_delay = snd_usb_pcm_delay(subs, runtime->rate);
  1686. /* update delay with exact number of samples played */
  1687. if (processed > subs->last_delay)
  1688. subs->last_delay = 0;
  1689. else
  1690. subs->last_delay -= processed;
  1691. runtime->delay = subs->last_delay;
  1692.  
  1693. /*
  1694. * Report when delay estimate is off by more than 2ms.
  1695. * The error should be lower than 2ms since the estimate relies
  1696. * on two reads of a counter updated every ms.
  1697. */
  1698. if (abs(est_delay - subs->last_delay) * 1000 > runtime->rate * 2)
  1699. dev_dbg_ratelimited(&subs->dev->dev,
  1700. "delay: estimated %d, actual %d\n",
  1701. est_delay, subs->last_delay);
  1702.  
  1703. if (!subs->running) {
  1704. /* update last_frame_number for delay counting here since
  1705. * prepare_playback_urb won't be called during pause
  1706. */
  1707. subs->last_frame_number =
  1708. usb_get_current_frame_number(subs->dev) & 0xff;
  1709. }
  1710.  
  1711. out:
  1712. spin_unlock_irqrestore(&subs->lock, flags);
  1713. }
  1714.  
  1715. static int snd_usb_substream_playback_trigger(struct snd_pcm_substream *substream,
  1716. int cmd)
  1717. {
  1718. struct snd_usb_substream *subs = substream->runtime->private_data;
  1719.  
  1720. switch (cmd) {
  1721. case SNDRV_PCM_TRIGGER_START:
  1722. subs->trigger_tstamp_pending_update = true;
  1723. /* fall through */
  1724. case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  1725. subs->data_endpoint->prepare_data_urb = prepare_playback_urb;
  1726. subs->data_endpoint->retire_data_urb = retire_playback_urb;
  1727. subs->running = 1;
  1728. return 0;
  1729. case SNDRV_PCM_TRIGGER_STOP:
  1730. stop_endpoints(subs, false);
  1731. subs->running = 0;
  1732. return 0;
  1733. case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
  1734. subs->data_endpoint->prepare_data_urb = NULL;
  1735. /* keep retire_data_urb for delay calculation */
  1736. subs->data_endpoint->retire_data_urb = retire_playback_urb;
  1737. subs->running = 0;
  1738. return 0;
  1739. }
  1740.  
  1741. return -EINVAL;
  1742. }
  1743.  
  1744. static int snd_usb_substream_capture_trigger(struct snd_pcm_substream *substream,
  1745. int cmd)
  1746. {
  1747. int err;
  1748. struct snd_usb_substream *subs = substream->runtime->private_data;
  1749.  
  1750. switch (cmd) {
  1751. case SNDRV_PCM_TRIGGER_START:
  1752. err = start_endpoints(subs);
  1753. if (err < 0)
  1754. return err;
  1755.  
  1756. subs->data_endpoint->retire_data_urb = retire_capture_urb;
  1757. subs->running = 1;
  1758. return 0;
  1759. case SNDRV_PCM_TRIGGER_STOP:
  1760. stop_endpoints(subs, false);
  1761. subs->running = 0;
  1762. return 0;
  1763. case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
  1764. subs->data_endpoint->retire_data_urb = NULL;
  1765. subs->running = 0;
  1766. return 0;
  1767. case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  1768. subs->data_endpoint->retire_data_urb = retire_capture_urb;
  1769. subs->running = 1;
  1770. return 0;
  1771. }
  1772.  
  1773. return -EINVAL;
  1774. }
  1775.  
  1776. static const struct snd_pcm_ops snd_usb_playback_ops = {
  1777. .open = snd_usb_pcm_open,
  1778. .close = snd_usb_pcm_close,
  1779. .ioctl = snd_pcm_lib_ioctl,
  1780. .hw_params = snd_usb_hw_params,
  1781. .hw_free = snd_usb_hw_free,
  1782. .prepare = snd_usb_pcm_prepare,
  1783. .trigger = snd_usb_substream_playback_trigger,
  1784. .pointer = snd_usb_pcm_pointer,
  1785. .page = snd_pcm_lib_get_vmalloc_page,
  1786. };
  1787.  
  1788. static const struct snd_pcm_ops snd_usb_capture_ops = {
  1789. .open = snd_usb_pcm_open,
  1790. .close = snd_usb_pcm_close,
  1791. .ioctl = snd_pcm_lib_ioctl,
  1792. .hw_params = snd_usb_hw_params,
  1793. .hw_free = snd_usb_hw_free,
  1794. .prepare = snd_usb_pcm_prepare,
  1795. .trigger = snd_usb_substream_capture_trigger,
  1796. .pointer = snd_usb_pcm_pointer,
  1797. .page = snd_pcm_lib_get_vmalloc_page,
  1798. };
  1799.  
  1800. static const struct snd_pcm_ops snd_usb_playback_dev_ops = {
  1801. .open = snd_usb_pcm_open,
  1802. .close = snd_usb_pcm_close,
  1803. .ioctl = snd_pcm_lib_ioctl,
  1804. .hw_params = snd_usb_hw_params,
  1805. .hw_free = snd_usb_hw_free,
  1806. .prepare = snd_usb_pcm_prepare,
  1807. .trigger = snd_usb_substream_playback_trigger,
  1808. .pointer = snd_usb_pcm_pointer,
  1809. .page = snd_pcm_sgbuf_ops_page,
  1810. };
  1811.  
  1812. static const struct snd_pcm_ops snd_usb_capture_dev_ops = {
  1813. .open = snd_usb_pcm_open,
  1814. .close = snd_usb_pcm_close,
  1815. .ioctl = snd_pcm_lib_ioctl,
  1816. .hw_params = snd_usb_hw_params,
  1817. .hw_free = snd_usb_hw_free,
  1818. .prepare = snd_usb_pcm_prepare,
  1819. .trigger = snd_usb_substream_capture_trigger,
  1820. .pointer = snd_usb_pcm_pointer,
  1821. .page = snd_pcm_sgbuf_ops_page,
  1822. };
  1823.  
  1824. void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream)
  1825. {
  1826. const struct snd_pcm_ops *ops;
  1827.  
  1828. if (snd_usb_use_vmalloc)
  1829. ops = stream == SNDRV_PCM_STREAM_PLAYBACK ?
  1830. &snd_usb_playback_ops : &snd_usb_capture_ops;
  1831. else
  1832. ops = stream == SNDRV_PCM_STREAM_PLAYBACK ?
  1833. &snd_usb_playback_dev_ops : &snd_usb_capture_dev_ops;
  1834. snd_pcm_set_ops(pcm, stream, ops);
  1835. }
  1836.  
  1837. void snd_usb_preallocate_buffer(struct snd_usb_substream *subs)
  1838. {
  1839. struct snd_pcm *pcm = subs->stream->pcm;
  1840. struct snd_pcm_substream *s = pcm->streams[subs->direction].substream;
  1841. struct device *dev = subs->dev->bus->controller;
  1842.  
  1843. if (!snd_usb_use_vmalloc)
  1844. snd_pcm_lib_preallocate_pages(s, SNDRV_DMA_TYPE_DEV_SG,
  1845. dev, 64*1024, 512*1024);
  1846. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!