Guest User

Untitled

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