1 files changed, 61 insertions, 45 deletions

diff --git a/sound/usb/endpoint.c b/sound/usb/endpoint.c
index 93e970f2b3c0..21dc6422d747 100644
--- a/sound/usb/endpoint.c
+++ b/sound/usb/endpoint.c
@@ -574,11 +574,14 @@ static int data_ep_set_params(struct snd_usb_endpoint *ep,
                               snd_pcm_format_t pcm_format,
                               unsigned int channels,
                               unsigned int period_bytes,
+                              unsigned int frames_per_period,
+                              unsigned int periods_per_buffer,
                               struct audioformat *fmt,
                               struct snd_usb_endpoint *sync_ep)
 {
-        unsigned int maxsize, i, urb_packs, total_packs, packs_per_ms;
-        int is_playback = usb_pipeout(ep->pipe);
+        unsigned int maxsize, minsize, packs_per_ms, max_packs_per_urb;
+        unsigned int max_packs_per_period, urbs_per_period, urb_packs;
+        unsigned int max_urbs, i;
         int frame_bits = snd_pcm_format_physical_width(pcm_format) * channels;
 
         if (pcm_format == SNDRV_PCM_FORMAT_DSD_U16_LE && fmt->dsd_dop) {
@@ -611,58 +614,67 @@ static int data_ep_set_params(struct snd_usb_endpoint *ep,
         else
                 ep->curpacksize = maxsize;
 
-        if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL)
+        if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL) {
                 packs_per_ms = 8 >> ep->datainterval;
-        else
-                packs_per_ms = 1;
-
-        if (is_playback && !snd_usb_endpoint_implicit_feedback_sink(ep)) {
-                urb_packs = max(ep->chip->nrpacks, 1);
-                urb_packs = min(urb_packs, (unsigned int) MAX_PACKS);
+                max_packs_per_urb = MAX_PACKS_HS;
         } else {
-                urb_packs = 1;
+                packs_per_ms = 1;
+                max_packs_per_urb = MAX_PACKS;
         }
+        if (sync_ep && !snd_usb_endpoint_implicit_feedback_sink(ep))
+                max_packs_per_urb = min(max_packs_per_urb,
+                                        1U << sync_ep->syncinterval);
+        max_packs_per_urb = max(1u, max_packs_per_urb >> ep->datainterval);
 
-        urb_packs *= packs_per_ms;
+        /*
+         * Capture endpoints need to use small URBs because there's no way
+         * to tell in advance where the next period will end, and we don't
+         * want the next URB to complete much after the period ends.
+         *
+         * Playback endpoints with implicit sync much use the same parameters
+         * as their corresponding capture endpoint.
+         */
+        if (usb_pipein(ep->pipe) ||
+                        snd_usb_endpoint_implicit_feedback_sink(ep)) {
 
-        if (sync_ep && !snd_usb_endpoint_implicit_feedback_sink(ep))
-                urb_packs = min(urb_packs, 1U << sync_ep->syncinterval);
+                /* make capture URBs <= 1 ms and smaller than a period */
+                urb_packs = min(max_packs_per_urb, packs_per_ms);
+                while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
+                        urb_packs >>= 1;
+                ep->nurbs = MAX_URBS;
 
-        /* decide how many packets to be used */
-        if (is_playback && !snd_usb_endpoint_implicit_feedback_sink(ep)) {
-                unsigned int minsize, maxpacks;
+        /*
+         * Playback endpoints without implicit sync are adjusted so that
+         * a period fits as evenly as possible in the smallest number of
+         * URBs.  The total number of URBs is adjusted to the size of the
+         * ALSA buffer, subject to the MAX_URBS and MAX_QUEUE limits.
+         */
+        } else {
                 /* determine how small a packet can be */
-                minsize = (ep->freqn >> (16 - ep->datainterval))
-                          * (frame_bits >> 3);
+                minsize = (ep->freqn >> (16 - ep->datainterval)) *
+                                (frame_bits >> 3);
                 /* with sync from device, assume it can be 12% lower */
                 if (sync_ep)
                         minsize -= minsize >> 3;
                 minsize = max(minsize, 1u);
-                total_packs = (period_bytes + minsize - 1) / minsize;
-                /* we need at least two URBs for queueing */
-                if (total_packs < 2) {
-                        total_packs = 2;
-                } else {
-                        /* and we don't want too long a queue either */
-                        maxpacks = max(MAX_QUEUE * packs_per_ms, urb_packs * 2);
-                        total_packs = min(total_packs, maxpacks);
-                }
-        } else {
-                while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
-                        urb_packs >>= 1;
-                total_packs = MAX_URBS * urb_packs;
-        }
 
-        ep->nurbs = (total_packs + urb_packs - 1) / urb_packs;
-        if (ep->nurbs > MAX_URBS) {
-                /* too much... */
-                ep->nurbs = MAX_URBS;
-                total_packs = MAX_URBS * urb_packs;
-        } else if (ep->nurbs < 2) {
-                /* too little - we need at least two packets
-                 * to ensure contiguous playback/capture
-                 */
-                ep->nurbs = 2;
+                /* how many packets will contain an entire ALSA period? */
+                max_packs_per_period = DIV_ROUND_UP(period_bytes, minsize);
+
+                /* how many URBs will contain a period? */
+                urbs_per_period = DIV_ROUND_UP(max_packs_per_period,
+                                max_packs_per_urb);
+                /* how many packets are needed in each URB? */
+                urb_packs = DIV_ROUND_UP(max_packs_per_period, urbs_per_period);
+
+                /* limit the number of frames in a single URB */
+                ep->max_urb_frames = DIV_ROUND_UP(frames_per_period,
+                                        urbs_per_period);
+
+                /* try to use enough URBs to contain an entire ALSA buffer */
+                max_urbs = min((unsigned) MAX_URBS,
+                                MAX_QUEUE * packs_per_ms / urb_packs);
+                ep->nurbs = min(max_urbs, urbs_per_period * periods_per_buffer);
         }
 
         /* allocate and initialize data urbs */
@@ -670,8 +682,7 @@ static int data_ep_set_params(struct snd_usb_endpoint *ep,
                 struct snd_urb_ctx *u = &ep->urb[i];
                 u->index = i;
                 u->ep = ep;
-                u->packets = (i + 1) * total_packs / ep->nurbs
-                        - i * total_packs / ep->nurbs;
+                u->packets = urb_packs;
                 u->buffer_size = maxsize * u->packets;
 
                 if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
@@ -748,6 +759,8 @@ out_of_memory:
  * @pcm_format: the audio fomat.
  * @channels: the number of audio channels.
  * @period_bytes: the number of bytes in one alsa period.
+ * @period_frames: the number of frames in one alsa period.
+ * @buffer_periods: the number of periods in one alsa buffer.
  * @rate: the frame rate.
  * @fmt: the USB audio format information
  * @sync_ep: the sync endpoint to use, if any
@@ -760,6 +773,8 @@ int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
                                 snd_pcm_format_t pcm_format,
                                 unsigned int channels,
                                 unsigned int period_bytes,
+                                unsigned int period_frames,
+                                unsigned int buffer_periods,
                                 unsigned int rate,
                                 struct audioformat *fmt,
                                 struct snd_usb_endpoint *sync_ep)
@@ -793,7 +808,8 @@ int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
         switch (ep->type) {
         case  SND_USB_ENDPOINT_TYPE_DATA:
                 err = data_ep_set_params(ep, pcm_format, channels,
-                                         period_bytes, fmt, sync_ep);
+                                         period_bytes, period_frames,
+                                         buffer_periods, fmt, sync_ep);
                 break;
         case  SND_USB_ENDPOINT_TYPE_SYNC:
                 err = sync_ep_set_params(ep, fmt);