Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
endpoint.c
Go to the documentation of this file.
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 
18 #include <linux/gfp.h>
19 #include <linux/init.h>
20 #include <linux/ratelimit.h>
21 #include <linux/usb.h>
22 #include <linux/usb/audio.h>
23 #include <linux/slab.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 "helper.h"
31 #include "card.h"
32 #include "endpoint.h"
33 #include "pcm.h"
34 #include "quirks.h"
35 
36 #define EP_FLAG_ACTIVATED 0
37 #define EP_FLAG_RUNNING 1
38 #define EP_FLAG_STOPPING 2
39 
40 /*
41  * snd_usb_endpoint is a model that abstracts everything related to an
42  * USB endpoint and its streaming.
43  *
44  * There are functions to activate and deactivate the streaming URBs and
45  * optional callbacks to let the pcm logic handle the actual content of the
46  * packets for playback and record. Thus, the bus streaming and the audio
47  * handlers are fully decoupled.
48  *
49  * There are two different types of endpoints in audio applications.
50  *
51  * SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both
52  * inbound and outbound traffic.
53  *
54  * SND_USB_ENDPOINT_TYPE_SYNC endpoints are for inbound traffic only and
55  * expect the payload to carry Q10.14 / Q16.16 formatted sync information
56  * (3 or 4 bytes).
57  *
58  * Each endpoint has to be configured prior to being used by calling
59  * snd_usb_endpoint_set_params().
60  *
61  * The model incorporates a reference counting, so that multiple users
62  * can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and
63  * only the first user will effectively start the URBs, and only the last
64  * one to stop it will tear the URBs down again.
65  */
66 
67 /*
68  * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
69  * this will overflow at approx 524 kHz
70  */
71 static inline unsigned get_usb_full_speed_rate(unsigned int rate)
72 {
73  return ((rate << 13) + 62) / 125;
74 }
75 
76 /*
77  * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
78  * this will overflow at approx 4 MHz
79  */
80 static inline unsigned get_usb_high_speed_rate(unsigned int rate)
81 {
82  return ((rate << 10) + 62) / 125;
83 }
84 
85 /*
86  * release a urb data
87  */
88 static void release_urb_ctx(struct snd_urb_ctx *u)
89 {
90  if (u->buffer_size)
91  usb_free_coherent(u->ep->chip->dev, u->buffer_size,
92  u->urb->transfer_buffer,
93  u->urb->transfer_dma);
94  usb_free_urb(u->urb);
95  u->urb = NULL;
96 }
97 
98 static const char *usb_error_string(int err)
99 {
100  switch (err) {
101  case -ENODEV:
102  return "no device";
103  case -ENOENT:
104  return "endpoint not enabled";
105  case -EPIPE:
106  return "endpoint stalled";
107  case -ENOSPC:
108  return "not enough bandwidth";
109  case -ESHUTDOWN:
110  return "device disabled";
111  case -EHOSTUNREACH:
112  return "device suspended";
113  case -EINVAL:
114  case -EAGAIN:
115  case -EFBIG:
116  case -EMSGSIZE:
117  return "internal error";
118  default:
119  return "unknown error";
120  }
121 }
122 
132 {
133  return ep->sync_master &&
136  usb_pipeout(ep->pipe);
137 }
138 
139 /*
140  * For streaming based on information derived from sync endpoints,
141  * prepare_outbound_urb_sizes() will call next_packet_size() to
142  * determine the number of samples to be sent in the next packet.
143  *
144  * For implicit feedback, next_packet_size() is unused.
145  */
147 {
148  unsigned long flags;
149  int ret;
150 
151  if (ep->fill_max)
152  return ep->maxframesize;
153 
154  spin_lock_irqsave(&ep->lock, flags);
155  ep->phase = (ep->phase & 0xffff)
156  + (ep->freqm << ep->datainterval);
157  ret = min(ep->phase >> 16, ep->maxframesize);
158  spin_unlock_irqrestore(&ep->lock, flags);
159 
160  return ret;
161 }
162 
163 static void retire_outbound_urb(struct snd_usb_endpoint *ep,
164  struct snd_urb_ctx *urb_ctx)
165 {
166  if (ep->retire_data_urb)
167  ep->retire_data_urb(ep->data_subs, urb_ctx->urb);
168 }
169 
170 static void retire_inbound_urb(struct snd_usb_endpoint *ep,
171  struct snd_urb_ctx *urb_ctx)
172 {
173  struct urb *urb = urb_ctx->urb;
174 
175  if (unlikely(ep->skip_packets > 0)) {
176  ep->skip_packets--;
177  return;
178  }
179 
180  if (ep->sync_slave)
181  snd_usb_handle_sync_urb(ep->sync_slave, ep, urb);
182 
183  if (ep->retire_data_urb)
184  ep->retire_data_urb(ep->data_subs, urb);
185 }
186 
187 /*
188  * Prepare a PLAYBACK urb for submission to the bus.
189  */
190 static void prepare_outbound_urb(struct snd_usb_endpoint *ep,
191  struct snd_urb_ctx *ctx)
192 {
193  int i;
194  struct urb *urb = ctx->urb;
195  unsigned char *cp = urb->transfer_buffer;
196 
197  urb->dev = ep->chip->dev; /* we need to set this at each time */
198 
199  switch (ep->type) {
201  if (ep->prepare_data_urb) {
202  ep->prepare_data_urb(ep->data_subs, urb);
203  } else {
204  /* no data provider, so send silence */
205  unsigned int offs = 0;
206  for (i = 0; i < ctx->packets; ++i) {
207  int counts;
208 
209  if (ctx->packet_size[i])
210  counts = ctx->packet_size[i];
211  else
213 
214  urb->iso_frame_desc[i].offset = offs * ep->stride;
215  urb->iso_frame_desc[i].length = counts * ep->stride;
216  offs += counts;
217  }
218 
219  urb->number_of_packets = ctx->packets;
220  urb->transfer_buffer_length = offs * ep->stride;
221  memset(urb->transfer_buffer, ep->silence_value,
222  offs * ep->stride);
223  }
224  break;
225 
227  if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) {
228  /*
229  * fill the length and offset of each urb descriptor.
230  * the fixed 12.13 frequency is passed as 16.16 through the pipe.
231  */
232  urb->iso_frame_desc[0].length = 4;
233  urb->iso_frame_desc[0].offset = 0;
234  cp[0] = ep->freqn;
235  cp[1] = ep->freqn >> 8;
236  cp[2] = ep->freqn >> 16;
237  cp[3] = ep->freqn >> 24;
238  } else {
239  /*
240  * fill the length and offset of each urb descriptor.
241  * the fixed 10.14 frequency is passed through the pipe.
242  */
243  urb->iso_frame_desc[0].length = 3;
244  urb->iso_frame_desc[0].offset = 0;
245  cp[0] = ep->freqn >> 2;
246  cp[1] = ep->freqn >> 10;
247  cp[2] = ep->freqn >> 18;
248  }
249 
250  break;
251  }
252 }
253 
254 /*
255  * Prepare a CAPTURE or SYNC urb for submission to the bus.
256  */
257 static inline void prepare_inbound_urb(struct snd_usb_endpoint *ep,
258  struct snd_urb_ctx *urb_ctx)
259 {
260  int i, offs;
261  struct urb *urb = urb_ctx->urb;
262 
263  urb->dev = ep->chip->dev; /* we need to set this at each time */
264 
265  switch (ep->type) {
267  offs = 0;
268  for (i = 0; i < urb_ctx->packets; i++) {
269  urb->iso_frame_desc[i].offset = offs;
270  urb->iso_frame_desc[i].length = ep->curpacksize;
271  offs += ep->curpacksize;
272  }
273 
274  urb->transfer_buffer_length = offs;
275  urb->number_of_packets = urb_ctx->packets;
276  break;
277 
279  urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize);
280  urb->iso_frame_desc[0].offset = 0;
281  break;
282  }
283 }
284 
285 /*
286  * Send output urbs that have been prepared previously. URBs are dequeued
287  * from ep->ready_playback_urbs and in case there there aren't any available
288  * or there are no packets that have been prepared, this function does
289  * nothing.
290  *
291  * The reason why the functionality of sending and preparing URBs is separated
292  * is that host controllers don't guarantee the order in which they return
293  * inbound and outbound packets to their submitters.
294  *
295  * This function is only used for implicit feedback endpoints. For endpoints
296  * driven by dedicated sync endpoints, URBs are immediately re-submitted
297  * from their completion handler.
298  */
299 static void queue_pending_output_urbs(struct snd_usb_endpoint *ep)
300 {
301  while (test_bit(EP_FLAG_RUNNING, &ep->flags)) {
302 
303  unsigned long flags;
304  struct snd_usb_packet_info *uninitialized_var(packet);
305  struct snd_urb_ctx *ctx = NULL;
306  struct urb *urb;
307  int err, i;
308 
309  spin_lock_irqsave(&ep->lock, flags);
312  ep->next_packet_read_pos++;
314 
315  /* take URB out of FIFO */
316  if (!list_empty(&ep->ready_playback_urbs))
318  struct snd_urb_ctx, ready_list);
319  }
320  spin_unlock_irqrestore(&ep->lock, flags);
321 
322  if (ctx == NULL)
323  return;
324 
325  list_del_init(&ctx->ready_list);
326  urb = ctx->urb;
327 
328  /* copy over the length information */
329  for (i = 0; i < packet->packets; i++)
330  ctx->packet_size[i] = packet->packet_size[i];
331 
332  /* call the data handler to fill in playback data */
333  prepare_outbound_urb(ep, ctx);
334 
335  err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
336  if (err < 0)
337  snd_printk(KERN_ERR "Unable to submit urb #%d: %d (urb %p)\n",
338  ctx->index, err, ctx->urb);
339  else
340  set_bit(ctx->index, &ep->active_mask);
341  }
342 }
343 
344 /*
345  * complete callback for urbs
346  */
347 static void snd_complete_urb(struct urb *urb)
348 {
349  struct snd_urb_ctx *ctx = urb->context;
350  struct snd_usb_endpoint *ep = ctx->ep;
351  int err;
352 
353  if (unlikely(urb->status == -ENOENT || /* unlinked */
354  urb->status == -ENODEV || /* device removed */
355  urb->status == -ECONNRESET || /* unlinked */
356  urb->status == -ESHUTDOWN || /* device disabled */
357  ep->chip->shutdown)) /* device disconnected */
358  goto exit_clear;
359 
360  if (usb_pipeout(ep->pipe)) {
361  retire_outbound_urb(ep, ctx);
362  /* can be stopped during retire callback */
363  if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
364  goto exit_clear;
365 
367  unsigned long flags;
368 
369  spin_lock_irqsave(&ep->lock, flags);
371  spin_unlock_irqrestore(&ep->lock, flags);
372  queue_pending_output_urbs(ep);
373 
374  goto exit_clear;
375  }
376 
377  prepare_outbound_urb(ep, ctx);
378  } else {
379  retire_inbound_urb(ep, ctx);
380  /* can be stopped during retire callback */
381  if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
382  goto exit_clear;
383 
384  prepare_inbound_urb(ep, ctx);
385  }
386 
387  err = usb_submit_urb(urb, GFP_ATOMIC);
388  if (err == 0)
389  return;
390 
391  snd_printk(KERN_ERR "cannot submit urb (err = %d)\n", err);
392  //snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
393 
394 exit_clear:
395  clear_bit(ctx->index, &ep->active_mask);
396 }
397 
415  struct usb_host_interface *alts,
416  int ep_num, int direction, int type)
417 {
418  struct list_head *p;
419  struct snd_usb_endpoint *ep;
420  int is_playback = direction == SNDRV_PCM_STREAM_PLAYBACK;
421 
422  mutex_lock(&chip->mutex);
423 
424  list_for_each(p, &chip->ep_list) {
425  ep = list_entry(p, struct snd_usb_endpoint, list);
426  if (ep->ep_num == ep_num &&
427  ep->iface == alts->desc.bInterfaceNumber &&
428  ep->alt_idx == alts->desc.bAlternateSetting) {
429  snd_printdd(KERN_DEBUG "Re-using EP %x in iface %d,%d @%p\n",
430  ep_num, ep->iface, ep->alt_idx, ep);
431  goto __exit_unlock;
432  }
433  }
434 
435  snd_printdd(KERN_DEBUG "Creating new %s %s endpoint #%x\n",
436  is_playback ? "playback" : "capture",
437  type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync",
438  ep_num);
439 
440  ep = kzalloc(sizeof(*ep), GFP_KERNEL);
441  if (!ep)
442  goto __exit_unlock;
443 
444  ep->chip = chip;
445  spin_lock_init(&ep->lock);
446  ep->type = type;
447  ep->ep_num = ep_num;
448  ep->iface = alts->desc.bInterfaceNumber;
449  ep->alt_idx = alts->desc.bAlternateSetting;
450  INIT_LIST_HEAD(&ep->ready_playback_urbs);
451  ep_num &= USB_ENDPOINT_NUMBER_MASK;
452 
453  if (is_playback)
454  ep->pipe = usb_sndisocpipe(chip->dev, ep_num);
455  else
456  ep->pipe = usb_rcvisocpipe(chip->dev, ep_num);
457 
458  if (type == SND_USB_ENDPOINT_TYPE_SYNC) {
460  get_endpoint(alts, 1)->bRefresh >= 1 &&
461  get_endpoint(alts, 1)->bRefresh <= 9)
462  ep->syncinterval = get_endpoint(alts, 1)->bRefresh;
463  else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL)
464  ep->syncinterval = 1;
465  else if (get_endpoint(alts, 1)->bInterval >= 1 &&
466  get_endpoint(alts, 1)->bInterval <= 16)
467  ep->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
468  else
469  ep->syncinterval = 3;
470 
472  }
473 
474  list_add_tail(&ep->list, &chip->ep_list);
475 
476 __exit_unlock:
477  mutex_unlock(&chip->mutex);
478 
479  return ep;
480 }
481 
482 /*
483  * wait until all urbs are processed.
484  */
485 static int wait_clear_urbs(struct snd_usb_endpoint *ep)
486 {
487  unsigned long end_time = jiffies + msecs_to_jiffies(1000);
488  unsigned int i;
489  int alive;
490 
491  do {
492  alive = 0;
493  for (i = 0; i < ep->nurbs; i++)
494  if (test_bit(i, &ep->active_mask))
495  alive++;
496 
497  if (!alive)
498  break;
499 
501  } while (time_before(jiffies, end_time));
502 
503  if (alive)
504  snd_printk(KERN_ERR "timeout: still %d active urbs on EP #%x\n",
505  alive, ep->ep_num);
507 
508  return 0;
509 }
510 
511 /* sync the pending stop operation;
512  * this function itself doesn't trigger the stop operation
513  */
515 {
516  if (ep && test_bit(EP_FLAG_STOPPING, &ep->flags))
517  wait_clear_urbs(ep);
518 }
519 
520 /*
521  * unlink active urbs.
522  */
523 static int deactivate_urbs(struct snd_usb_endpoint *ep, int force, int can_sleep)
524 {
525  unsigned int i;
526  int async;
527 
528  if (!force && ep->chip->shutdown) /* to be sure... */
529  return -EBADFD;
530 
531  async = !can_sleep && ep->chip->async_unlink;
532 
534 
535  INIT_LIST_HEAD(&ep->ready_playback_urbs);
536  ep->next_packet_read_pos = 0;
537  ep->next_packet_write_pos = 0;
538 
539  if (!async && in_interrupt())
540  return 0;
541 
542  for (i = 0; i < ep->nurbs; i++) {
543  if (test_bit(i, &ep->active_mask)) {
544  if (!test_and_set_bit(i, &ep->unlink_mask)) {
545  struct urb *u = ep->urb[i].urb;
546  if (async)
547  usb_unlink_urb(u);
548  else
549  usb_kill_urb(u);
550  }
551  }
552  }
553 
554  return 0;
555 }
556 
557 /*
558  * release an endpoint's urbs
559  */
560 static void release_urbs(struct snd_usb_endpoint *ep, int force)
561 {
562  int i;
563 
564  /* route incoming urbs to nirvana */
565  ep->retire_data_urb = NULL;
566  ep->prepare_data_urb = NULL;
567 
568  /* stop urbs */
569  deactivate_urbs(ep, force, 1);
570  wait_clear_urbs(ep);
571 
572  for (i = 0; i < ep->nurbs; i++)
573  release_urb_ctx(&ep->urb[i]);
574 
575  if (ep->syncbuf)
576  usb_free_coherent(ep->chip->dev, SYNC_URBS * 4,
577  ep->syncbuf, ep->sync_dma);
578 
579  ep->syncbuf = NULL;
580  ep->nurbs = 0;
581 }
582 
583 /*
584  * configure a data endpoint
585  */
586 static int data_ep_set_params(struct snd_usb_endpoint *ep,
587  snd_pcm_format_t pcm_format,
588  unsigned int channels,
589  unsigned int period_bytes,
590  struct audioformat *fmt,
591  struct snd_usb_endpoint *sync_ep)
592 {
593  unsigned int maxsize, i, urb_packs, total_packs, packs_per_ms;
594  int is_playback = usb_pipeout(ep->pipe);
595  int frame_bits = snd_pcm_format_physical_width(pcm_format) * channels;
596 
597  ep->datainterval = fmt->datainterval;
598  ep->stride = frame_bits >> 3;
599  ep->silence_value = pcm_format == SNDRV_PCM_FORMAT_U8 ? 0x80 : 0;
600 
601  /* calculate max. frequency */
602  if (ep->maxpacksize) {
603  /* whatever fits into a max. size packet */
604  maxsize = ep->maxpacksize;
605  ep->freqmax = (maxsize / (frame_bits >> 3))
606  << (16 - ep->datainterval);
607  } else {
608  /* no max. packet size: just take 25% higher than nominal */
609  ep->freqmax = ep->freqn + (ep->freqn >> 2);
610  maxsize = ((ep->freqmax + 0xffff) * (frame_bits >> 3))
611  >> (16 - ep->datainterval);
612  }
613 
614  if (ep->fill_max)
615  ep->curpacksize = ep->maxpacksize;
616  else
617  ep->curpacksize = maxsize;
618 
619  if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL)
620  packs_per_ms = 8 >> ep->datainterval;
621  else
622  packs_per_ms = 1;
623 
624  if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) {
625  urb_packs = max(ep->chip->nrpacks, 1);
626  urb_packs = min(urb_packs, (unsigned int) MAX_PACKS);
627  } else {
628  urb_packs = 1;
629  }
630 
631  urb_packs *= packs_per_ms;
632 
633  if (sync_ep && !snd_usb_endpoint_implict_feedback_sink(ep))
634  urb_packs = min(urb_packs, 1U << sync_ep->syncinterval);
635 
636  /* decide how many packets to be used */
637  if (is_playback && !snd_usb_endpoint_implict_feedback_sink(ep)) {
638  unsigned int minsize, maxpacks;
639  /* determine how small a packet can be */
640  minsize = (ep->freqn >> (16 - ep->datainterval))
641  * (frame_bits >> 3);
642  /* with sync from device, assume it can be 12% lower */
643  if (sync_ep)
644  minsize -= minsize >> 3;
645  minsize = max(minsize, 1u);
646  total_packs = (period_bytes + minsize - 1) / minsize;
647  /* we need at least two URBs for queueing */
648  if (total_packs < 2) {
649  total_packs = 2;
650  } else {
651  /* and we don't want too long a queue either */
652  maxpacks = max(MAX_QUEUE * packs_per_ms, urb_packs * 2);
653  total_packs = min(total_packs, maxpacks);
654  }
655  } else {
656  while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
657  urb_packs >>= 1;
658  total_packs = MAX_URBS * urb_packs;
659  }
660 
661  ep->nurbs = (total_packs + urb_packs - 1) / urb_packs;
662  if (ep->nurbs > MAX_URBS) {
663  /* too much... */
664  ep->nurbs = MAX_URBS;
665  total_packs = MAX_URBS * urb_packs;
666  } else if (ep->nurbs < 2) {
667  /* too little - we need at least two packets
668  * to ensure contiguous playback/capture
669  */
670  ep->nurbs = 2;
671  }
672 
673  /* allocate and initialize data urbs */
674  for (i = 0; i < ep->nurbs; i++) {
675  struct snd_urb_ctx *u = &ep->urb[i];
676  u->index = i;
677  u->ep = ep;
678  u->packets = (i + 1) * total_packs / ep->nurbs
679  - i * total_packs / ep->nurbs;
680  u->buffer_size = maxsize * u->packets;
681 
682  if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
683  u->packets++; /* for transfer delimiter */
685  if (!u->urb)
686  goto out_of_memory;
687 
688  u->urb->transfer_buffer =
689  usb_alloc_coherent(ep->chip->dev, u->buffer_size,
690  GFP_KERNEL, &u->urb->transfer_dma);
691  if (!u->urb->transfer_buffer)
692  goto out_of_memory;
693  u->urb->pipe = ep->pipe;
694  u->urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
695  u->urb->interval = 1 << ep->datainterval;
696  u->urb->context = u;
697  u->urb->complete = snd_complete_urb;
698  INIT_LIST_HEAD(&u->ready_list);
699  }
700 
701  return 0;
702 
704  release_urbs(ep, 0);
705  return -ENOMEM;
706 }
707 
708 /*
709  * configure a sync endpoint
710  */
711 static int sync_ep_set_params(struct snd_usb_endpoint *ep,
712  struct audioformat *fmt)
713 {
714  int i;
715 
716  ep->syncbuf = usb_alloc_coherent(ep->chip->dev, SYNC_URBS * 4,
717  GFP_KERNEL, &ep->sync_dma);
718  if (!ep->syncbuf)
719  return -ENOMEM;
720 
721  for (i = 0; i < SYNC_URBS; i++) {
722  struct snd_urb_ctx *u = &ep->urb[i];
723  u->index = i;
724  u->ep = ep;
725  u->packets = 1;
726  u->urb = usb_alloc_urb(1, GFP_KERNEL);
727  if (!u->urb)
728  goto out_of_memory;
729  u->urb->transfer_buffer = ep->syncbuf + i * 4;
730  u->urb->transfer_dma = ep->sync_dma + i * 4;
731  u->urb->transfer_buffer_length = 4;
732  u->urb->pipe = ep->pipe;
733  u->urb->transfer_flags = URB_ISO_ASAP |
734  URB_NO_TRANSFER_DMA_MAP;
735  u->urb->number_of_packets = 1;
736  u->urb->interval = 1 << ep->syncinterval;
737  u->urb->context = u;
738  u->urb->complete = snd_complete_urb;
739  }
740 
741  ep->nurbs = SYNC_URBS;
742 
743  return 0;
744 
746  release_urbs(ep, 0);
747  return -ENOMEM;
748 }
749 
766  snd_pcm_format_t pcm_format,
767  unsigned int channels,
768  unsigned int period_bytes,
769  unsigned int rate,
770  struct audioformat *fmt,
771  struct snd_usb_endpoint *sync_ep)
772 {
773  int err;
774 
775  if (ep->use_count != 0) {
776  snd_printk(KERN_WARNING "Unable to change format on ep #%x: already in use\n",
777  ep->ep_num);
778  return -EBUSY;
779  }
780 
781  /* release old buffers, if any */
782  release_urbs(ep, 0);
783 
784  ep->datainterval = fmt->datainterval;
785  ep->maxpacksize = fmt->maxpacksize;
787 
788  if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_FULL)
789  ep->freqn = get_usb_full_speed_rate(rate);
790  else
791  ep->freqn = get_usb_high_speed_rate(rate);
792 
793  /* calculate the frequency in 16.16 format */
794  ep->freqm = ep->freqn;
795  ep->freqshift = INT_MIN;
796 
797  ep->phase = 0;
798 
799  switch (ep->type) {
801  err = data_ep_set_params(ep, pcm_format, channels,
802  period_bytes, fmt, sync_ep);
803  break;
805  err = sync_ep_set_params(ep, fmt);
806  break;
807  default:
808  err = -EINVAL;
809  }
810 
811  snd_printdd(KERN_DEBUG "Setting params for ep #%x (type %d, %d urbs), ret=%d\n",
812  ep->ep_num, ep->type, ep->nurbs, err);
813 
814  return err;
815 }
816 
832 int snd_usb_endpoint_start(struct snd_usb_endpoint *ep, int can_sleep)
833 {
834  int err;
835  unsigned int i;
836 
837  if (ep->chip->shutdown)
838  return -EBADFD;
839 
840  /* already running? */
841  if (++ep->use_count != 1)
842  return 0;
843 
844  /* just to be sure */
845  deactivate_urbs(ep, 0, can_sleep);
846  if (can_sleep)
847  wait_clear_urbs(ep);
848 
849  ep->active_mask = 0;
850  ep->unlink_mask = 0;
851  ep->phase = 0;
852 
854 
855  /*
856  * If this endpoint has a data endpoint as implicit feedback source,
857  * don't start the urbs here. Instead, mark them all as available,
858  * wait for the record urbs to return and queue the playback urbs
859  * from that context.
860  */
861 
863 
865  for (i = 0; i < ep->nurbs; i++) {
866  struct snd_urb_ctx *ctx = ep->urb + i;
868  }
869 
870  return 0;
871  }
872 
873  for (i = 0; i < ep->nurbs; i++) {
874  struct urb *urb = ep->urb[i].urb;
875 
876  if (snd_BUG_ON(!urb))
877  goto __error;
878 
879  if (usb_pipeout(ep->pipe)) {
880  prepare_outbound_urb(ep, urb->context);
881  } else {
882  prepare_inbound_urb(ep, urb->context);
883  }
884 
885  err = usb_submit_urb(urb, GFP_ATOMIC);
886  if (err < 0) {
887  snd_printk(KERN_ERR "cannot submit urb %d, error %d: %s\n",
888  i, err, usb_error_string(err));
889  goto __error;
890  }
891  set_bit(i, &ep->active_mask);
892  }
893 
894  return 0;
895 
896 __error:
898  ep->use_count--;
899  deactivate_urbs(ep, 0, 0);
900  return -EPIPE;
901 }
902 
915  int force, int can_sleep, int wait)
916 {
917  if (!ep)
918  return;
919 
920  if (snd_BUG_ON(ep->use_count == 0))
921  return;
922 
923  if (--ep->use_count == 0) {
924  deactivate_urbs(ep, force, can_sleep);
925  ep->data_subs = NULL;
926  ep->sync_slave = NULL;
927  ep->retire_data_urb = NULL;
928  ep->prepare_data_urb = NULL;
929 
930  if (wait)
931  wait_clear_urbs(ep);
932  else
934  }
935 }
936 
951 {
952  if (!ep)
953  return -EINVAL;
954 
955  deactivate_urbs(ep, 1, 1);
956  wait_clear_urbs(ep);
957 
958  if (ep->use_count != 0)
959  return 0;
960 
962 
963  return 0;
964 }
965 
975 {
976  struct snd_usb_endpoint *ep;
977 
978  ep = list_entry(head, struct snd_usb_endpoint, list);
979  release_urbs(ep, 1);
980  kfree(ep);
981 }
982 
994  struct snd_usb_endpoint *sender,
995  const struct urb *urb)
996 {
997  int shift;
998  unsigned int f;
999  unsigned long flags;
1000 
1001  snd_BUG_ON(ep == sender);
1002 
1003  /*
1004  * In case the endpoint is operating in implicit feedback mode, prepare
1005  * a new outbound URB that has the same layout as the received packet
1006  * and add it to the list of pending urbs. queue_pending_output_urbs()
1007  * will take care of them later.
1008  */
1010  ep->use_count != 0) {
1011 
1012  /* implicit feedback case */
1013  int i, bytes = 0;
1014  struct snd_urb_ctx *in_ctx;
1015  struct snd_usb_packet_info *out_packet;
1016 
1017  in_ctx = urb->context;
1018 
1019  /* Count overall packet size */
1020  for (i = 0; i < in_ctx->packets; i++)
1021  if (urb->iso_frame_desc[i].status == 0)
1022  bytes += urb->iso_frame_desc[i].actual_length;
1023 
1024  /*
1025  * skip empty packets. At least M-Audio's Fast Track Ultra stops
1026  * streaming once it received a 0-byte OUT URB
1027  */
1028  if (bytes == 0)
1029  return;
1030 
1031  spin_lock_irqsave(&ep->lock, flags);
1032  out_packet = ep->next_packet + ep->next_packet_write_pos;
1033 
1034  /*
1035  * Iterate through the inbound packet and prepare the lengths
1036  * for the output packet. The OUT packet we are about to send
1037  * will have the same amount of payload bytes than the IN
1038  * packet we just received.
1039  */
1040 
1041  out_packet->packets = in_ctx->packets;
1042  for (i = 0; i < in_ctx->packets; i++) {
1043  if (urb->iso_frame_desc[i].status == 0)
1044  out_packet->packet_size[i] =
1045  urb->iso_frame_desc[i].actual_length / ep->stride;
1046  else
1047  out_packet->packet_size[i] = 0;
1048  }
1049 
1050  ep->next_packet_write_pos++;
1052  spin_unlock_irqrestore(&ep->lock, flags);
1053  queue_pending_output_urbs(ep);
1054 
1055  return;
1056  }
1057 
1058  /*
1059  * process after playback sync complete
1060  *
1061  * Full speed devices report feedback values in 10.14 format as samples
1062  * per frame, high speed devices in 16.16 format as samples per
1063  * microframe.
1064  *
1065  * Because the Audio Class 1 spec was written before USB 2.0, many high
1066  * speed devices use a wrong interpretation, some others use an
1067  * entirely different format.
1068  *
1069  * Therefore, we cannot predict what format any particular device uses
1070  * and must detect it automatically.
1071  */
1072 
1073  if (urb->iso_frame_desc[0].status != 0 ||
1074  urb->iso_frame_desc[0].actual_length < 3)
1075  return;
1076 
1077  f = le32_to_cpup(urb->transfer_buffer);
1078  if (urb->iso_frame_desc[0].actual_length == 3)
1079  f &= 0x00ffffff;
1080  else
1081  f &= 0x0fffffff;
1082 
1083  if (f == 0)
1084  return;
1085 
1086  if (unlikely(ep->freqshift == INT_MIN)) {
1087  /*
1088  * The first time we see a feedback value, determine its format
1089  * by shifting it left or right until it matches the nominal
1090  * frequency value. This assumes that the feedback does not
1091  * differ from the nominal value more than +50% or -25%.
1092  */
1093  shift = 0;
1094  while (f < ep->freqn - ep->freqn / 4) {
1095  f <<= 1;
1096  shift++;
1097  }
1098  while (f > ep->freqn + ep->freqn / 2) {
1099  f >>= 1;
1100  shift--;
1101  }
1102  ep->freqshift = shift;
1103  } else if (ep->freqshift >= 0)
1104  f <<= ep->freqshift;
1105  else
1106  f >>= -ep->freqshift;
1107 
1108  if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) {
1109  /*
1110  * If the frequency looks valid, set it.
1111  * This value is referred to in prepare_playback_urb().
1112  */
1113  spin_lock_irqsave(&ep->lock, flags);
1114  ep->freqm = f;
1115  spin_unlock_irqrestore(&ep->lock, flags);
1116  } else {
1117  /*
1118  * Out of range; maybe the shift value is wrong.
1119  * Reset it so that we autodetect again the next time.
1120  */
1121  ep->freqshift = INT_MIN;
1122  }
1123 }
1124