← Back to branch summary

~hui.wang/alsa-driver/tiwai-trunk-fgit

« back to all changes in this revision

Viewing changes to usb/endpoint.c

  • Committer: Hui Wang
  • Date: 2018-06-07 01:04:04 UTC
  • Revision ID: git-v1:baf13208df10376d9e4588ad3524aeb3c9973bdf
sync the alsa hda driver from Takashi's tree

Signed-off-by: Hui Wang <hui.wang@canonical.com>

Show diffs side-by-side

added added

removed removed

Lines of Context:
usb/endpoint.c
 
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_RUNNING         1
 
37
#define EP_FLAG_STOPPING        2
 
38
 
 
39
/*
 
40
 * snd_usb_endpoint is a model that abstracts everything related to an
 
41
 * USB endpoint and its streaming.
 
42
 *
 
43
 * There are functions to activate and deactivate the streaming URBs and
 
44
 * optional callbacks to let the pcm logic handle the actual content of the
 
45
 * packets for playback and record. Thus, the bus streaming and the audio
 
46
 * handlers are fully decoupled.
 
47
 *
 
48
 * There are two different types of endpoints in audio applications.
 
49
 *
 
50
 * SND_USB_ENDPOINT_TYPE_DATA handles full audio data payload for both
 
51
 * inbound and outbound traffic.
 
52
 *
 
53
 * SND_USB_ENDPOINT_TYPE_SYNC endpoints are for inbound traffic only and
 
54
 * expect the payload to carry Q10.14 / Q16.16 formatted sync information
 
55
 * (3 or 4 bytes).
 
56
 *
 
57
 * Each endpoint has to be configured prior to being used by calling
 
58
 * snd_usb_endpoint_set_params().
 
59
 *
 
60
 * The model incorporates a reference counting, so that multiple users
 
61
 * can call snd_usb_endpoint_start() and snd_usb_endpoint_stop(), and
 
62
 * only the first user will effectively start the URBs, and only the last
 
63
 * one to stop it will tear the URBs down again.
 
64
 */
 
65
 
 
66
/*
 
67
 * convert a sampling rate into our full speed format (fs/1000 in Q16.16)
 
68
 * this will overflow at approx 524 kHz
 
69
 */
 
70
static inline unsigned get_usb_full_speed_rate(unsigned int rate)
 
71
{
 
72
        return ((rate << 13) + 62) / 125;
 
73
}
 
74
 
 
75
/*
 
76
 * convert a sampling rate into USB high speed format (fs/8000 in Q16.16)
 
77
 * this will overflow at approx 4 MHz
 
78
 */
 
79
static inline unsigned get_usb_high_speed_rate(unsigned int rate)
 
80
{
 
81
        return ((rate << 10) + 62) / 125;
 
82
}
 
83
 
 
84
/*
 
85
 * release a urb data
 
86
 */
 
87
static void release_urb_ctx(struct snd_urb_ctx *u)
 
88
{
 
89
        if (u->buffer_size)
 
90
                usb_free_coherent(u->ep->chip->dev, u->buffer_size,
 
91
                                  u->urb->transfer_buffer,
 
92
                                  u->urb->transfer_dma);
 
93
        usb_free_urb(u->urb);
 
94
        u->urb = NULL;
 
95
}
 
96
 
 
97
static const char *usb_error_string(int err)
 
98
{
 
99
        switch (err) {
 
100
        case -ENODEV:
 
101
                return "no device";
 
102
        case -ENOENT:
 
103
                return "endpoint not enabled";
 
104
        case -EPIPE:
 
105
                return "endpoint stalled";
 
106
        case -ENOSPC:
 
107
                return "not enough bandwidth";
 
108
        case -ESHUTDOWN:
 
109
                return "device disabled";
 
110
        case -EHOSTUNREACH:
 
111
                return "device suspended";
 
112
        case -EINVAL:
 
113
        case -EAGAIN:
 
114
        case -EFBIG:
 
115
        case -EMSGSIZE:
 
116
                return "internal error";
 
117
        default:
 
118
                return "unknown error";
 
119
        }
 
120
}
 
121
 
 
122
/**
 
123
 * snd_usb_endpoint_implicit_feedback_sink: Report endpoint usage type
 
124
 *
 
125
 * @ep: The snd_usb_endpoint
 
126
 *
 
127
 * Determine whether an endpoint is driven by an implicit feedback
 
128
 * data endpoint source.
 
129
 */
 
130
int snd_usb_endpoint_implicit_feedback_sink(struct snd_usb_endpoint *ep)
 
131
{
 
132
        return  ep->sync_master &&
 
133
                ep->sync_master->type == SND_USB_ENDPOINT_TYPE_DATA &&
 
134
                ep->type == SND_USB_ENDPOINT_TYPE_DATA &&
 
135
                usb_pipeout(ep->pipe);
 
136
}
 
137
 
 
138
/*
 
139
 * For streaming based on information derived from sync endpoints,
 
140
 * prepare_outbound_urb_sizes() will call next_packet_size() to
 
141
 * determine the number of samples to be sent in the next packet.
 
142
 *
 
143
 * For implicit feedback, next_packet_size() is unused.
 
144
 */
 
145
int snd_usb_endpoint_next_packet_size(struct snd_usb_endpoint *ep)
 
146
{
 
147
        unsigned long flags;
 
148
        int ret;
 
149
 
 
150
        if (ep->fill_max)
 
151
                return ep->maxframesize;
 
152
 
 
153
        spin_lock_irqsave(&ep->lock, flags);
 
154
        ep->phase = (ep->phase & 0xffff)
 
155
                + (ep->freqm << ep->datainterval);
 
156
        ret = min(ep->phase >> 16, ep->maxframesize);
 
157
        spin_unlock_irqrestore(&ep->lock, flags);
 
158
 
 
159
        return ret;
 
160
}
 
161
 
 
162
static void retire_outbound_urb(struct snd_usb_endpoint *ep,
 
163
                                struct snd_urb_ctx *urb_ctx)
 
164
{
 
165
        if (ep->retire_data_urb)
 
166
                ep->retire_data_urb(ep->data_subs, urb_ctx->urb);
 
167
}
 
168
 
 
169
static void retire_inbound_urb(struct snd_usb_endpoint *ep,
 
170
                               struct snd_urb_ctx *urb_ctx)
 
171
{
 
172
        struct urb *urb = urb_ctx->urb;
 
173
 
 
174
        if (unlikely(ep->skip_packets > 0)) {
 
175
                ep->skip_packets--;
 
176
                return;
 
177
        }
 
178
 
 
179
        if (ep->sync_slave)
 
180
                snd_usb_handle_sync_urb(ep->sync_slave, ep, urb);
 
181
 
 
182
        if (ep->retire_data_urb)
 
183
                ep->retire_data_urb(ep->data_subs, urb);
 
184
}
 
185
 
 
186
static void prepare_silent_urb(struct snd_usb_endpoint *ep,
 
187
                               struct snd_urb_ctx *ctx)
 
188
{
 
189
        struct urb *urb = ctx->urb;
 
190
        unsigned int offs = 0;
 
191
        unsigned int extra = 0;
 
192
        __le32 packet_length;
 
193
        int i;
 
194
 
 
195
        /* For tx_length_quirk, put packet length at start of packet */
 
196
        if (ep->chip->tx_length_quirk)
 
197
                extra = sizeof(packet_length);
 
198
 
 
199
        for (i = 0; i < ctx->packets; ++i) {
 
200
                unsigned int offset;
 
201
                unsigned int length;
 
202
                int counts;
 
203
 
 
204
                if (ctx->packet_size[i])
 
205
                        counts = ctx->packet_size[i];
 
206
                else
 
207
                        counts = snd_usb_endpoint_next_packet_size(ep);
 
208
 
 
209
                length = counts * ep->stride; /* number of silent bytes */
 
210
                offset = offs * ep->stride + extra * i;
 
211
                urb->iso_frame_desc[i].offset = offset;
 
212
                urb->iso_frame_desc[i].length = length + extra;
 
213
                if (extra) {
 
214
                        packet_length = cpu_to_le32(length);
 
215
                        memcpy(urb->transfer_buffer + offset,
 
216
                               &packet_length, sizeof(packet_length));
 
217
                }
 
218
                memset(urb->transfer_buffer + offset + extra,
 
219
                       ep->silence_value, length);
 
220
                offs += counts;
 
221
        }
 
222
 
 
223
        urb->number_of_packets = ctx->packets;
 
224
        urb->transfer_buffer_length = offs * ep->stride + ctx->packets * extra;
 
225
}
 
226
 
 
227
/*
 
228
 * Prepare a PLAYBACK urb for submission to the bus.
 
229
 */
 
230
static void prepare_outbound_urb(struct snd_usb_endpoint *ep,
 
231
                                 struct snd_urb_ctx *ctx)
 
232
{
 
233
        struct urb *urb = ctx->urb;
 
234
        unsigned char *cp = urb->transfer_buffer;
 
235
 
 
236
        urb->dev = ep->chip->dev; /* we need to set this at each time */
 
237
 
 
238
        switch (ep->type) {
 
239
        case SND_USB_ENDPOINT_TYPE_DATA:
 
240
                if (ep->prepare_data_urb) {
 
241
                        ep->prepare_data_urb(ep->data_subs, urb);
 
242
                } else {
 
243
                        /* no data provider, so send silence */
 
244
                        prepare_silent_urb(ep, ctx);
 
245
                }
 
246
                break;
 
247
 
 
248
        case SND_USB_ENDPOINT_TYPE_SYNC:
 
249
                if (snd_usb_get_speed(ep->chip->dev) >= USB_SPEED_HIGH) {
 
250
                        /*
 
251
                         * fill the length and offset of each urb descriptor.
 
252
                         * the fixed 12.13 frequency is passed as 16.16 through the pipe.
 
253
                         */
 
254
                        urb->iso_frame_desc[0].length = 4;
 
255
                        urb->iso_frame_desc[0].offset = 0;
 
256
                        cp[0] = ep->freqn;
 
257
                        cp[1] = ep->freqn >> 8;
 
258
                        cp[2] = ep->freqn >> 16;
 
259
                        cp[3] = ep->freqn >> 24;
 
260
                } else {
 
261
                        /*
 
262
                         * fill the length and offset of each urb descriptor.
 
263
                         * the fixed 10.14 frequency is passed through the pipe.
 
264
                         */
 
265
                        urb->iso_frame_desc[0].length = 3;
 
266
                        urb->iso_frame_desc[0].offset = 0;
 
267
                        cp[0] = ep->freqn >> 2;
 
268
                        cp[1] = ep->freqn >> 10;
 
269
                        cp[2] = ep->freqn >> 18;
 
270
                }
 
271
 
 
272
                break;
 
273
        }
 
274
}
 
275
 
 
276
/*
 
277
 * Prepare a CAPTURE or SYNC urb for submission to the bus.
 
278
 */
 
279
static inline void prepare_inbound_urb(struct snd_usb_endpoint *ep,
 
280
                                       struct snd_urb_ctx *urb_ctx)
 
281
{
 
282
        int i, offs;
 
283
        struct urb *urb = urb_ctx->urb;
 
284
 
 
285
        urb->dev = ep->chip->dev; /* we need to set this at each time */
 
286
 
 
287
        switch (ep->type) {
 
288
        case SND_USB_ENDPOINT_TYPE_DATA:
 
289
                offs = 0;
 
290
                for (i = 0; i < urb_ctx->packets; i++) {
 
291
                        urb->iso_frame_desc[i].offset = offs;
 
292
                        urb->iso_frame_desc[i].length = ep->curpacksize;
 
293
                        offs += ep->curpacksize;
 
294
                }
 
295
 
 
296
                urb->transfer_buffer_length = offs;
 
297
                urb->number_of_packets = urb_ctx->packets;
 
298
                break;
 
299
 
 
300
        case SND_USB_ENDPOINT_TYPE_SYNC:
 
301
                urb->iso_frame_desc[0].length = min(4u, ep->syncmaxsize);
 
302
                urb->iso_frame_desc[0].offset = 0;
 
303
                break;
 
304
        }
 
305
}
 
306
 
 
307
/*
 
308
 * Send output urbs that have been prepared previously. URBs are dequeued
 
309
 * from ep->ready_playback_urbs and in case there there aren't any available
 
310
 * or there are no packets that have been prepared, this function does
 
311
 * nothing.
 
312
 *
 
313
 * The reason why the functionality of sending and preparing URBs is separated
 
314
 * is that host controllers don't guarantee the order in which they return
 
315
 * inbound and outbound packets to their submitters.
 
316
 *
 
317
 * This function is only used for implicit feedback endpoints. For endpoints
 
318
 * driven by dedicated sync endpoints, URBs are immediately re-submitted
 
319
 * from their completion handler.
 
320
 */
 
321
static void queue_pending_output_urbs(struct snd_usb_endpoint *ep)
 
322
{
 
323
        while (test_bit(EP_FLAG_RUNNING, &ep->flags)) {
 
324
 
 
325
                unsigned long flags;
 
326
                struct snd_usb_packet_info *uninitialized_var(packet);
 
327
                struct snd_urb_ctx *ctx = NULL;
 
328
                struct urb *urb;
 
329
                int err, i;
 
330
 
 
331
                spin_lock_irqsave(&ep->lock, flags);
 
332
                if (ep->next_packet_read_pos != ep->next_packet_write_pos) {
 
333
                        packet = ep->next_packet + ep->next_packet_read_pos;
 
334
                        ep->next_packet_read_pos++;
 
335
                        ep->next_packet_read_pos %= MAX_URBS;
 
336
 
 
337
                        /* take URB out of FIFO */
 
338
                        if (!list_empty(&ep->ready_playback_urbs))
 
339
                                ctx = list_first_entry(&ep->ready_playback_urbs,
 
340
                                               struct snd_urb_ctx, ready_list);
 
341
                }
 
342
                spin_unlock_irqrestore(&ep->lock, flags);
 
343
 
 
344
                if (ctx == NULL)
 
345
                        return;
 
346
 
 
347
                list_del_init(&ctx->ready_list);
 
348
                urb = ctx->urb;
 
349
 
 
350
                /* copy over the length information */
 
351
                for (i = 0; i < packet->packets; i++)
 
352
                        ctx->packet_size[i] = packet->packet_size[i];
 
353
 
 
354
                /* call the data handler to fill in playback data */
 
355
                prepare_outbound_urb(ep, ctx);
 
356
 
 
357
                err = usb_submit_urb(ctx->urb, GFP_ATOMIC);
 
358
                if (err < 0)
 
359
                        usb_audio_err(ep->chip,
 
360
                                "Unable to submit urb #%d: %d (urb %p)\n",
 
361
                                ctx->index, err, ctx->urb);
 
362
                else
 
363
                        set_bit(ctx->index, &ep->active_mask);
 
364
        }
 
365
}
 
366
 
 
367
/*
 
368
 * complete callback for urbs
 
369
 */
 
370
static void snd_complete_urb(struct urb *urb)
 
371
{
 
372
        struct snd_urb_ctx *ctx = urb->context;
 
373
        struct snd_usb_endpoint *ep = ctx->ep;
 
374
        struct snd_pcm_substream *substream;
 
375
        unsigned long flags;
 
376
        int err;
 
377
 
 
378
        if (unlikely(urb->status == -ENOENT ||          /* unlinked */
 
379
                     urb->status == -ENODEV ||          /* device removed */
 
380
                     urb->status == -ECONNRESET ||      /* unlinked */
 
381
                     urb->status == -ESHUTDOWN))        /* device disabled */
 
382
                goto exit_clear;
 
383
        /* device disconnected */
 
384
        if (unlikely(atomic_read(&ep->chip->shutdown)))
 
385
                goto exit_clear;
 
386
 
 
387
        if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
 
388
                goto exit_clear;
 
389
 
 
390
        if (usb_pipeout(ep->pipe)) {
 
391
                retire_outbound_urb(ep, ctx);
 
392
                /* can be stopped during retire callback */
 
393
                if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
 
394
                        goto exit_clear;
 
395
 
 
396
                if (snd_usb_endpoint_implicit_feedback_sink(ep)) {
 
397
                        spin_lock_irqsave(&ep->lock, flags);
 
398
                        list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
 
399
                        spin_unlock_irqrestore(&ep->lock, flags);
 
400
                        queue_pending_output_urbs(ep);
 
401
 
 
402
                        goto exit_clear;
 
403
                }
 
404
 
 
405
                prepare_outbound_urb(ep, ctx);
 
406
        } else {
 
407
                retire_inbound_urb(ep, ctx);
 
408
                /* can be stopped during retire callback */
 
409
                if (unlikely(!test_bit(EP_FLAG_RUNNING, &ep->flags)))
 
410
                        goto exit_clear;
 
411
 
 
412
                prepare_inbound_urb(ep, ctx);
 
413
        }
 
414
 
 
415
        err = usb_submit_urb(urb, GFP_ATOMIC);
 
416
        if (err == 0)
 
417
                return;
 
418
 
 
419
        usb_audio_err(ep->chip, "cannot submit urb (err = %d)\n", err);
 
420
        if (ep->data_subs && ep->data_subs->pcm_substream) {
 
421
                substream = ep->data_subs->pcm_substream;
 
422
                snd_pcm_stop_xrun(substream);
 
423
        }
 
424
 
 
425
exit_clear:
 
426
        clear_bit(ctx->index, &ep->active_mask);
 
427
}
 
428
 
 
429
/**
 
430
 * snd_usb_add_endpoint: Add an endpoint to an USB audio chip
 
431
 *
 
432
 * @chip: The chip
 
433
 * @alts: The USB host interface
 
434
 * @ep_num: The number of the endpoint to use
 
435
 * @direction: SNDRV_PCM_STREAM_PLAYBACK or SNDRV_PCM_STREAM_CAPTURE
 
436
 * @type: SND_USB_ENDPOINT_TYPE_DATA or SND_USB_ENDPOINT_TYPE_SYNC
 
437
 *
 
438
 * If the requested endpoint has not been added to the given chip before,
 
439
 * a new instance is created. Otherwise, a pointer to the previoulsy
 
440
 * created instance is returned. In case of any error, NULL is returned.
 
441
 *
 
442
 * New endpoints will be added to chip->ep_list and must be freed by
 
443
 * calling snd_usb_endpoint_free().
 
444
 *
 
445
 * For SND_USB_ENDPOINT_TYPE_SYNC, the caller needs to guarantee that
 
446
 * bNumEndpoints > 1 beforehand.
 
447
 */
 
448
struct snd_usb_endpoint *snd_usb_add_endpoint(struct snd_usb_audio *chip,
 
449
                                              struct usb_host_interface *alts,
 
450
                                              int ep_num, int direction, int type)
 
451
{
 
452
        struct snd_usb_endpoint *ep;
 
453
        int is_playback = direction == SNDRV_PCM_STREAM_PLAYBACK;
 
454
 
 
455
        if (WARN_ON(!alts))
 
456
                return NULL;
 
457
 
 
458
        mutex_lock(&chip->mutex);
 
459
 
 
460
        list_for_each_entry(ep, &chip->ep_list, list) {
 
461
                if (ep->ep_num == ep_num &&
 
462
                    ep->iface == alts->desc.bInterfaceNumber &&
 
463
                    ep->altsetting == alts->desc.bAlternateSetting) {
 
464
                        usb_audio_dbg(ep->chip,
 
465
                                      "Re-using EP %x in iface %d,%d @%p\n",
 
466
                                        ep_num, ep->iface, ep->altsetting, ep);
 
467
                        goto __exit_unlock;
 
468
                }
 
469
        }
 
470
 
 
471
        usb_audio_dbg(chip, "Creating new %s %s endpoint #%x\n",
 
472
                    is_playback ? "playback" : "capture",
 
473
                    type == SND_USB_ENDPOINT_TYPE_DATA ? "data" : "sync",
 
474
                    ep_num);
 
475
 
 
476
        ep = kzalloc(sizeof(*ep), GFP_KERNEL);
 
477
        if (!ep)
 
478
                goto __exit_unlock;
 
479
 
 
480
        ep->chip = chip;
 
481
        spin_lock_init(&ep->lock);
 
482
        ep->type = type;
 
483
        ep->ep_num = ep_num;
 
484
        ep->iface = alts->desc.bInterfaceNumber;
 
485
        ep->altsetting = alts->desc.bAlternateSetting;
 
486
        INIT_LIST_HEAD(&ep->ready_playback_urbs);
 
487
        ep_num &= USB_ENDPOINT_NUMBER_MASK;
 
488
 
 
489
        if (is_playback)
 
490
                ep->pipe = usb_sndisocpipe(chip->dev, ep_num);
 
491
        else
 
492
                ep->pipe = usb_rcvisocpipe(chip->dev, ep_num);
 
493
 
 
494
        if (type == SND_USB_ENDPOINT_TYPE_SYNC) {
 
495
                if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE &&
 
496
                    get_endpoint(alts, 1)->bRefresh >= 1 &&
 
497
                    get_endpoint(alts, 1)->bRefresh <= 9)
 
498
                        ep->syncinterval = get_endpoint(alts, 1)->bRefresh;
 
499
                else if (snd_usb_get_speed(chip->dev) == USB_SPEED_FULL)
 
500
                        ep->syncinterval = 1;
 
501
                else if (get_endpoint(alts, 1)->bInterval >= 1 &&
 
502
                         get_endpoint(alts, 1)->bInterval <= 16)
 
503
                        ep->syncinterval = get_endpoint(alts, 1)->bInterval - 1;
 
504
                else
 
505
                        ep->syncinterval = 3;
 
506
 
 
507
                ep->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize);
 
508
        }
 
509
 
 
510
        list_add_tail(&ep->list, &chip->ep_list);
 
511
 
 
512
__exit_unlock:
 
513
        mutex_unlock(&chip->mutex);
 
514
 
 
515
        return ep;
 
516
}
 
517
 
 
518
/*
 
519
 *  wait until all urbs are processed.
 
520
 */
 
521
static int wait_clear_urbs(struct snd_usb_endpoint *ep)
 
522
{
 
523
        unsigned long end_time = jiffies + msecs_to_jiffies(1000);
 
524
        int alive;
 
525
 
 
526
        do {
 
527
                alive = bitmap_weight(&ep->active_mask, ep->nurbs);
 
528
                if (!alive)
 
529
                        break;
 
530
 
 
531
                schedule_timeout_uninterruptible(1);
 
532
        } while (time_before(jiffies, end_time));
 
533
 
 
534
        if (alive)
 
535
                usb_audio_err(ep->chip,
 
536
                        "timeout: still %d active urbs on EP #%x\n",
 
537
                        alive, ep->ep_num);
 
538
        clear_bit(EP_FLAG_STOPPING, &ep->flags);
 
539
 
 
540
        ep->data_subs = NULL;
 
541
        ep->sync_slave = NULL;
 
542
        ep->retire_data_urb = NULL;
 
543
        ep->prepare_data_urb = NULL;
 
544
 
 
545
        return 0;
 
546
}
 
547
 
 
548
/* sync the pending stop operation;
 
549
 * this function itself doesn't trigger the stop operation
 
550
 */
 
551
void snd_usb_endpoint_sync_pending_stop(struct snd_usb_endpoint *ep)
 
552
{
 
553
        if (ep && test_bit(EP_FLAG_STOPPING, &ep->flags))
 
554
                wait_clear_urbs(ep);
 
555
}
 
556
 
 
557
/*
 
558
 * unlink active urbs.
 
559
 */
 
560
static int deactivate_urbs(struct snd_usb_endpoint *ep, bool force)
 
561
{
 
562
        unsigned int i;
 
563
 
 
564
        if (!force && atomic_read(&ep->chip->shutdown)) /* to be sure... */
 
565
                return -EBADFD;
 
566
 
 
567
        clear_bit(EP_FLAG_RUNNING, &ep->flags);
 
568
 
 
569
        INIT_LIST_HEAD(&ep->ready_playback_urbs);
 
570
        ep->next_packet_read_pos = 0;
 
571
        ep->next_packet_write_pos = 0;
 
572
 
 
573
        for (i = 0; i < ep->nurbs; i++) {
 
574
                if (test_bit(i, &ep->active_mask)) {
 
575
                        if (!test_and_set_bit(i, &ep->unlink_mask)) {
 
576
                                struct urb *u = ep->urb[i].urb;
 
577
                                usb_unlink_urb(u);
 
578
                        }
 
579
                }
 
580
        }
 
581
 
 
582
        return 0;
 
583
}
 
584
 
 
585
/*
 
586
 * release an endpoint's urbs
 
587
 */
 
588
static void release_urbs(struct snd_usb_endpoint *ep, int force)
 
589
{
 
590
        int i;
 
591
 
 
592
        /* route incoming urbs to nirvana */
 
593
        ep->retire_data_urb = NULL;
 
594
        ep->prepare_data_urb = NULL;
 
595
 
 
596
        /* stop urbs */
 
597
        deactivate_urbs(ep, force);
 
598
        wait_clear_urbs(ep);
 
599
 
 
600
        for (i = 0; i < ep->nurbs; i++)
 
601
                release_urb_ctx(&ep->urb[i]);
 
602
 
 
603
        if (ep->syncbuf)
 
604
                usb_free_coherent(ep->chip->dev, SYNC_URBS * 4,
 
605
                                  ep->syncbuf, ep->sync_dma);
 
606
 
 
607
        ep->syncbuf = NULL;
 
608
        ep->nurbs = 0;
 
609
}
 
610
 
 
611
/*
 
612
 * configure a data endpoint
 
613
 */
 
614
static int data_ep_set_params(struct snd_usb_endpoint *ep,
 
615
                              snd_pcm_format_t pcm_format,
 
616
                              unsigned int channels,
 
617
                              unsigned int period_bytes,
 
618
                              unsigned int frames_per_period,
 
619
                              unsigned int periods_per_buffer,
 
620
                              struct audioformat *fmt,
 
621
                              struct snd_usb_endpoint *sync_ep)
 
622
{
 
623
        unsigned int maxsize, minsize, packs_per_ms, max_packs_per_urb;
 
624
        unsigned int max_packs_per_period, urbs_per_period, urb_packs;
 
625
        unsigned int max_urbs, i;
 
626
        int frame_bits = snd_pcm_format_physical_width(pcm_format) * channels;
 
627
        int tx_length_quirk = (ep->chip->tx_length_quirk &&
 
628
                               usb_pipeout(ep->pipe));
 
629
 
 
630
        if (pcm_format == SNDRV_PCM_FORMAT_DSD_U16_LE && fmt->dsd_dop) {
 
631
                /*
 
632
                 * When operating in DSD DOP mode, the size of a sample frame
 
633
                 * in hardware differs from the actual physical format width
 
634
                 * because we need to make room for the DOP markers.
 
635
                 */
 
636
                frame_bits += channels << 3;
 
637
        }
 
638
 
 
639
        ep->datainterval = fmt->datainterval;
 
640
        ep->stride = frame_bits >> 3;
 
641
 
 
642
        switch (pcm_format) {
 
643
        case SNDRV_PCM_FORMAT_U8:
 
644
                ep->silence_value = 0x80;
 
645
                break;
 
646
        case SNDRV_PCM_FORMAT_DSD_U8:
 
647
        case SNDRV_PCM_FORMAT_DSD_U16_LE:
 
648
        case SNDRV_PCM_FORMAT_DSD_U32_LE:
 
649
        case SNDRV_PCM_FORMAT_DSD_U16_BE:
 
650
        case SNDRV_PCM_FORMAT_DSD_U32_BE:
 
651
                ep->silence_value = 0x69;
 
652
                break;
 
653
        default:
 
654
                ep->silence_value = 0;
 
655
        }
 
656
 
 
657
        /* assume max. frequency is 50% higher than nominal */
 
658
        ep->freqmax = ep->freqn + (ep->freqn >> 1);
 
659
        /* Round up freqmax to nearest integer in order to calculate maximum
 
660
         * packet size, which must represent a whole number of frames.
 
661
         * This is accomplished by adding 0x0.ffff before converting the
 
662
         * Q16.16 format into integer.
 
663
         * In order to accurately calculate the maximum packet size when
 
664
         * the data interval is more than 1 (i.e. ep->datainterval > 0),
 
665
         * multiply by the data interval prior to rounding. For instance,
 
666
         * a freqmax of 41 kHz will result in a max packet size of 6 (5.125)
 
667
         * frames with a data interval of 1, but 11 (10.25) frames with a
 
668
         * data interval of 2.
 
669
         * (ep->freqmax << ep->datainterval overflows at 8.192 MHz for the
 
670
         * maximum datainterval value of 3, at USB full speed, higher for
 
671
         * USB high speed, noting that ep->freqmax is in units of
 
672
         * frames per packet in Q16.16 format.)
 
673
         */
 
674
        maxsize = (((ep->freqmax << ep->datainterval) + 0xffff) >> 16) *
 
675
                         (frame_bits >> 3);
 
676
        if (tx_length_quirk)
 
677
                maxsize += sizeof(__le32); /* Space for length descriptor */
 
678
        /* but wMaxPacketSize might reduce this */
 
679
        if (ep->maxpacksize && ep->maxpacksize < maxsize) {
 
680
                /* whatever fits into a max. size packet */
 
681
                unsigned int data_maxsize = maxsize = ep->maxpacksize;
 
682
 
 
683
                if (tx_length_quirk)
 
684
                        /* Need to remove the length descriptor to calc freq */
 
685
                        data_maxsize -= sizeof(__le32);
 
686
                ep->freqmax = (data_maxsize / (frame_bits >> 3))
 
687
                                << (16 - ep->datainterval);
 
688
        }
 
689
 
 
690
        if (ep->fill_max)
 
691
                ep->curpacksize = ep->maxpacksize;
 
692
        else
 
693
                ep->curpacksize = maxsize;
 
694
 
 
695
        if (snd_usb_get_speed(ep->chip->dev) != USB_SPEED_FULL) {
 
696
                packs_per_ms = 8 >> ep->datainterval;
 
697
                max_packs_per_urb = MAX_PACKS_HS;
 
698
        } else {
 
699
                packs_per_ms = 1;
 
700
                max_packs_per_urb = MAX_PACKS;
 
701
        }
 
702
        if (sync_ep && !snd_usb_endpoint_implicit_feedback_sink(ep))
 
703
                max_packs_per_urb = min(max_packs_per_urb,
 
704
                                        1U << sync_ep->syncinterval);
 
705
        max_packs_per_urb = max(1u, max_packs_per_urb >> ep->datainterval);
 
706
 
 
707
        /*
 
708
         * Capture endpoints need to use small URBs because there's no way
 
709
         * to tell in advance where the next period will end, and we don't
 
710
         * want the next URB to complete much after the period ends.
 
711
         *
 
712
         * Playback endpoints with implicit sync much use the same parameters
 
713
         * as their corresponding capture endpoint.
 
714
         */
 
715
        if (usb_pipein(ep->pipe) ||
 
716
                        snd_usb_endpoint_implicit_feedback_sink(ep)) {
 
717
 
 
718
                urb_packs = packs_per_ms;
 
719
                /*
 
720
                 * Wireless devices can poll at a max rate of once per 4ms.
 
721
                 * For dataintervals less than 5, increase the packet count to
 
722
                 * allow the host controller to use bursting to fill in the
 
723
                 * gaps.
 
724
                 */
 
725
                if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_WIRELESS) {
 
726
                        int interval = ep->datainterval;
 
727
                        while (interval < 5) {
 
728
                                urb_packs <<= 1;
 
729
                                ++interval;
 
730
                        }
 
731
                }
 
732
                /* make capture URBs <= 1 ms and smaller than a period */
 
733
                urb_packs = min(max_packs_per_urb, urb_packs);
 
734
                while (urb_packs > 1 && urb_packs * maxsize >= period_bytes)
 
735
                        urb_packs >>= 1;
 
736
                ep->nurbs = MAX_URBS;
 
737
 
 
738
        /*
 
739
         * Playback endpoints without implicit sync are adjusted so that
 
740
         * a period fits as evenly as possible in the smallest number of
 
741
         * URBs.  The total number of URBs is adjusted to the size of the
 
742
         * ALSA buffer, subject to the MAX_URBS and MAX_QUEUE limits.
 
743
         */
 
744
        } else {
 
745
                /* determine how small a packet can be */
 
746
                minsize = (ep->freqn >> (16 - ep->datainterval)) *
 
747
                                (frame_bits >> 3);
 
748
                /* with sync from device, assume it can be 12% lower */
 
749
                if (sync_ep)
 
750
                        minsize -= minsize >> 3;
 
751
                minsize = max(minsize, 1u);
 
752
 
 
753
                /* how many packets will contain an entire ALSA period? */
 
754
                max_packs_per_period = DIV_ROUND_UP(period_bytes, minsize);
 
755
 
 
756
                /* how many URBs will contain a period? */
 
757
                urbs_per_period = DIV_ROUND_UP(max_packs_per_period,
 
758
                                max_packs_per_urb);
 
759
                /* how many packets are needed in each URB? */
 
760
                urb_packs = DIV_ROUND_UP(max_packs_per_period, urbs_per_period);
 
761
 
 
762
                /* limit the number of frames in a single URB */
 
763
                ep->max_urb_frames = DIV_ROUND_UP(frames_per_period,
 
764
                                        urbs_per_period);
 
765
 
 
766
                /* try to use enough URBs to contain an entire ALSA buffer */
 
767
                max_urbs = min((unsigned) MAX_URBS,
 
768
                                MAX_QUEUE * packs_per_ms / urb_packs);
 
769
                ep->nurbs = min(max_urbs, urbs_per_period * periods_per_buffer);
 
770
        }
 
771
 
 
772
        /* allocate and initialize data urbs */
 
773
        for (i = 0; i < ep->nurbs; i++) {
 
774
                struct snd_urb_ctx *u = &ep->urb[i];
 
775
                u->index = i;
 
776
                u->ep = ep;
 
777
                u->packets = urb_packs;
 
778
                u->buffer_size = maxsize * u->packets;
 
779
 
 
780
                if (fmt->fmt_type == UAC_FORMAT_TYPE_II)
 
781
                        u->packets++; /* for transfer delimiter */
 
782
                u->urb = usb_alloc_urb(u->packets, GFP_KERNEL);
 
783
                if (!u->urb)
 
784
                        goto out_of_memory;
 
785
 
 
786
                u->urb->transfer_buffer =
 
787
                        usb_alloc_coherent(ep->chip->dev, u->buffer_size,
 
788
                                           GFP_KERNEL, &u->urb->transfer_dma);
 
789
                if (!u->urb->transfer_buffer)
 
790
                        goto out_of_memory;
 
791
                u->urb->pipe = ep->pipe;
 
792
                u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 
793
                u->urb->interval = 1 << ep->datainterval;
 
794
                u->urb->context = u;
 
795
                u->urb->complete = snd_complete_urb;
 
796
                INIT_LIST_HEAD(&u->ready_list);
 
797
        }
 
798
 
 
799
        return 0;
 
800
 
 
801
out_of_memory:
 
802
        release_urbs(ep, 0);
 
803
        return -ENOMEM;
 
804
}
 
805
 
 
806
/*
 
807
 * configure a sync endpoint
 
808
 */
 
809
static int sync_ep_set_params(struct snd_usb_endpoint *ep)
 
810
{
 
811
        int i;
 
812
 
 
813
        ep->syncbuf = usb_alloc_coherent(ep->chip->dev, SYNC_URBS * 4,
 
814
                                         GFP_KERNEL, &ep->sync_dma);
 
815
        if (!ep->syncbuf)
 
816
                return -ENOMEM;
 
817
 
 
818
        for (i = 0; i < SYNC_URBS; i++) {
 
819
                struct snd_urb_ctx *u = &ep->urb[i];
 
820
                u->index = i;
 
821
                u->ep = ep;
 
822
                u->packets = 1;
 
823
                u->urb = usb_alloc_urb(1, GFP_KERNEL);
 
824
                if (!u->urb)
 
825
                        goto out_of_memory;
 
826
                u->urb->transfer_buffer = ep->syncbuf + i * 4;
 
827
                u->urb->transfer_dma = ep->sync_dma + i * 4;
 
828
                u->urb->transfer_buffer_length = 4;
 
829
                u->urb->pipe = ep->pipe;
 
830
                u->urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
 
831
                u->urb->number_of_packets = 1;
 
832
                u->urb->interval = 1 << ep->syncinterval;
 
833
                u->urb->context = u;
 
834
                u->urb->complete = snd_complete_urb;
 
835
        }
 
836
 
 
837
        ep->nurbs = SYNC_URBS;
 
838
 
 
839
        return 0;
 
840
 
 
841
out_of_memory:
 
842
        release_urbs(ep, 0);
 
843
        return -ENOMEM;
 
844
}
 
845
 
 
846
/**
 
847
 * snd_usb_endpoint_set_params: configure an snd_usb_endpoint
 
848
 *
 
849
 * @ep: the snd_usb_endpoint to configure
 
850
 * @pcm_format: the audio fomat.
 
851
 * @channels: the number of audio channels.
 
852
 * @period_bytes: the number of bytes in one alsa period.
 
853
 * @period_frames: the number of frames in one alsa period.
 
854
 * @buffer_periods: the number of periods in one alsa buffer.
 
855
 * @rate: the frame rate.
 
856
 * @fmt: the USB audio format information
 
857
 * @sync_ep: the sync endpoint to use, if any
 
858
 *
 
859
 * Determine the number of URBs to be used on this endpoint.
 
860
 * An endpoint must be configured before it can be started.
 
861
 * An endpoint that is already running can not be reconfigured.
 
862
 */
 
863
int snd_usb_endpoint_set_params(struct snd_usb_endpoint *ep,
 
864
                                snd_pcm_format_t pcm_format,
 
865
                                unsigned int channels,
 
866
                                unsigned int period_bytes,
 
867
                                unsigned int period_frames,
 
868
                                unsigned int buffer_periods,
 
869
                                unsigned int rate,
 
870
                                struct audioformat *fmt,
 
871
                                struct snd_usb_endpoint *sync_ep)
 
872
{
 
873
        int err;
 
874
 
 
875
        if (ep->use_count != 0) {
 
876
                usb_audio_warn(ep->chip,
 
877
                         "Unable to change format on ep #%x: already in use\n",
 
878
                         ep->ep_num);
 
879
                return -EBUSY;
 
880
        }
 
881
 
 
882
        /* release old buffers, if any */
 
883
        release_urbs(ep, 0);
 
884
 
 
885
        ep->datainterval = fmt->datainterval;
 
886
        ep->maxpacksize = fmt->maxpacksize;
 
887
        ep->fill_max = !!(fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX);
 
888
 
 
889
        if (snd_usb_get_speed(ep->chip->dev) == USB_SPEED_FULL)
 
890
                ep->freqn = get_usb_full_speed_rate(rate);
 
891
        else
 
892
                ep->freqn = get_usb_high_speed_rate(rate);
 
893
 
 
894
        /* calculate the frequency in 16.16 format */
 
895
        ep->freqm = ep->freqn;
 
896
        ep->freqshift = INT_MIN;
 
897
 
 
898
        ep->phase = 0;
 
899
 
 
900
        switch (ep->type) {
 
901
        case  SND_USB_ENDPOINT_TYPE_DATA:
 
902
                err = data_ep_set_params(ep, pcm_format, channels,
 
903
                                         period_bytes, period_frames,
 
904
                                         buffer_periods, fmt, sync_ep);
 
905
                break;
 
906
        case  SND_USB_ENDPOINT_TYPE_SYNC:
 
907
                err = sync_ep_set_params(ep);
 
908
                break;
 
909
        default:
 
910
                err = -EINVAL;
 
911
        }
 
912
 
 
913
        usb_audio_dbg(ep->chip,
 
914
                "Setting params for ep #%x (type %d, %d urbs), ret=%d\n",
 
915
                ep->ep_num, ep->type, ep->nurbs, err);
 
916
 
 
917
        return err;
 
918
}
 
919
 
 
920
/**
 
921
 * snd_usb_endpoint_start: start an snd_usb_endpoint
 
922
 *
 
923
 * @ep: the endpoint to start
 
924
 *
 
925
 * A call to this function will increment the use count of the endpoint.
 
926
 * In case it is not already running, the URBs for this endpoint will be
 
927
 * submitted. Otherwise, this function does nothing.
 
928
 *
 
929
 * Must be balanced to calls of snd_usb_endpoint_stop().
 
930
 *
 
931
 * Returns an error if the URB submission failed, 0 in all other cases.
 
932
 */
 
933
int snd_usb_endpoint_start(struct snd_usb_endpoint *ep)
 
934
{
 
935
        int err;
 
936
        unsigned int i;
 
937
 
 
938
        if (atomic_read(&ep->chip->shutdown))
 
939
                return -EBADFD;
 
940
 
 
941
        /* already running? */
 
942
        if (++ep->use_count != 1)
 
943
                return 0;
 
944
 
 
945
        /* just to be sure */
 
946
        deactivate_urbs(ep, false);
 
947
 
 
948
        ep->active_mask = 0;
 
949
        ep->unlink_mask = 0;
 
950
        ep->phase = 0;
 
951
 
 
952
        snd_usb_endpoint_start_quirk(ep);
 
953
 
 
954
        /*
 
955
         * If this endpoint has a data endpoint as implicit feedback source,
 
956
         * don't start the urbs here. Instead, mark them all as available,
 
957
         * wait for the record urbs to return and queue the playback urbs
 
958
         * from that context.
 
959
         */
 
960
 
 
961
        set_bit(EP_FLAG_RUNNING, &ep->flags);
 
962
 
 
963
        if (snd_usb_endpoint_implicit_feedback_sink(ep)) {
 
964
                for (i = 0; i < ep->nurbs; i++) {
 
965
                        struct snd_urb_ctx *ctx = ep->urb + i;
 
966
                        list_add_tail(&ctx->ready_list, &ep->ready_playback_urbs);
 
967
                }
 
968
 
 
969
                return 0;
 
970
        }
 
971
 
 
972
        for (i = 0; i < ep->nurbs; i++) {
 
973
                struct urb *urb = ep->urb[i].urb;
 
974
 
 
975
                if (snd_BUG_ON(!urb))
 
976
                        goto __error;
 
977
 
 
978
                if (usb_pipeout(ep->pipe)) {
 
979
                        prepare_outbound_urb(ep, urb->context);
 
980
                } else {
 
981
                        prepare_inbound_urb(ep, urb->context);
 
982
                }
 
983
 
 
984
                err = usb_submit_urb(urb, GFP_ATOMIC);
 
985
                if (err < 0) {
 
986
                        usb_audio_err(ep->chip,
 
987
                                "cannot submit urb %d, error %d: %s\n",
 
988
                                i, err, usb_error_string(err));
 
989
                        goto __error;
 
990
                }
 
991
                set_bit(i, &ep->active_mask);
 
992
        }
 
993
 
 
994
        return 0;
 
995
 
 
996
__error:
 
997
        clear_bit(EP_FLAG_RUNNING, &ep->flags);
 
998
        ep->use_count--;
 
999
        deactivate_urbs(ep, false);
 
1000
        return -EPIPE;
 
1001
}
 
1002
 
 
1003
/**
 
1004
 * snd_usb_endpoint_stop: stop an snd_usb_endpoint
 
1005
 *
 
1006
 * @ep: the endpoint to stop (may be NULL)
 
1007
 *
 
1008
 * A call to this function will decrement the use count of the endpoint.
 
1009
 * In case the last user has requested the endpoint stop, the URBs will
 
1010
 * actually be deactivated.
 
1011
 *
 
1012
 * Must be balanced to calls of snd_usb_endpoint_start().
 
1013
 *
 
1014
 * The caller needs to synchronize the pending stop operation via
 
1015
 * snd_usb_endpoint_sync_pending_stop().
 
1016
 */
 
1017
void snd_usb_endpoint_stop(struct snd_usb_endpoint *ep)
 
1018
{
 
1019
        if (!ep)
 
1020
                return;
 
1021
 
 
1022
        if (snd_BUG_ON(ep->use_count == 0))
 
1023
                return;
 
1024
 
 
1025
        if (--ep->use_count == 0) {
 
1026
                deactivate_urbs(ep, false);
 
1027
                set_bit(EP_FLAG_STOPPING, &ep->flags);
 
1028
        }
 
1029
}
 
1030
 
 
1031
/**
 
1032
 * snd_usb_endpoint_deactivate: deactivate an snd_usb_endpoint
 
1033
 *
 
1034
 * @ep: the endpoint to deactivate
 
1035
 *
 
1036
 * If the endpoint is not currently in use, this functions will
 
1037
 * deactivate its associated URBs.
 
1038
 *
 
1039
 * In case of any active users, this functions does nothing.
 
1040
 */
 
1041
void snd_usb_endpoint_deactivate(struct snd_usb_endpoint *ep)
 
1042
{
 
1043
        if (!ep)
 
1044
                return;
 
1045
 
 
1046
        if (ep->use_count != 0)
 
1047
                return;
 
1048
 
 
1049
        deactivate_urbs(ep, true);
 
1050
        wait_clear_urbs(ep);
 
1051
}
 
1052
 
 
1053
/**
 
1054
 * snd_usb_endpoint_release: Tear down an snd_usb_endpoint
 
1055
 *
 
1056
 * @ep: the endpoint to release
 
1057
 *
 
1058
 * This function does not care for the endpoint's use count but will tear
 
1059
 * down all the streaming URBs immediately.
 
1060
 */
 
1061
void snd_usb_endpoint_release(struct snd_usb_endpoint *ep)
 
1062
{
 
1063
        release_urbs(ep, 1);
 
1064
}
 
1065
 
 
1066
/**
 
1067
 * snd_usb_endpoint_free: Free the resources of an snd_usb_endpoint
 
1068
 *
 
1069
 * @ep: the endpoint to free
 
1070
 *
 
1071
 * This free all resources of the given ep.
 
1072
 */
 
1073
void snd_usb_endpoint_free(struct snd_usb_endpoint *ep)
 
1074
{
 
1075
        kfree(ep);
 
1076
}
 
1077
 
 
1078
/**
 
1079
 * snd_usb_handle_sync_urb: parse an USB sync packet
 
1080
 *
 
1081
 * @ep: the endpoint to handle the packet
 
1082
 * @sender: the sending endpoint
 
1083
 * @urb: the received packet
 
1084
 *
 
1085
 * This function is called from the context of an endpoint that received
 
1086
 * the packet and is used to let another endpoint object handle the payload.
 
1087
 */
 
1088
void snd_usb_handle_sync_urb(struct snd_usb_endpoint *ep,
 
1089
                             struct snd_usb_endpoint *sender,
 
1090
                             const struct urb *urb)
 
1091
{
 
1092
        int shift;
 
1093
        unsigned int f;
 
1094
        unsigned long flags;
 
1095
 
 
1096
        snd_BUG_ON(ep == sender);
 
1097
 
 
1098
        /*
 
1099
         * In case the endpoint is operating in implicit feedback mode, prepare
 
1100
         * a new outbound URB that has the same layout as the received packet
 
1101
         * and add it to the list of pending urbs. queue_pending_output_urbs()
 
1102
         * will take care of them later.
 
1103
         */
 
1104
        if (snd_usb_endpoint_implicit_feedback_sink(ep) &&
 
1105
            ep->use_count != 0) {
 
1106
 
 
1107
                /* implicit feedback case */
 
1108
                int i, bytes = 0;
 
1109
                struct snd_urb_ctx *in_ctx;
 
1110
                struct snd_usb_packet_info *out_packet;
 
1111
 
 
1112
                in_ctx = urb->context;
 
1113
 
 
1114
                /* Count overall packet size */
 
1115
                for (i = 0; i < in_ctx->packets; i++)
 
1116
                        if (urb->iso_frame_desc[i].status == 0)
 
1117
                                bytes += urb->iso_frame_desc[i].actual_length;
 
1118
 
 
1119
                /*
 
1120
                 * skip empty packets. At least M-Audio's Fast Track Ultra stops
 
1121
                 * streaming once it received a 0-byte OUT URB
 
1122
                 */
 
1123
                if (bytes == 0)
 
1124
                        return;
 
1125
 
 
1126
                spin_lock_irqsave(&ep->lock, flags);
 
1127
                out_packet = ep->next_packet + ep->next_packet_write_pos;
 
1128
 
 
1129
                /*
 
1130
                 * Iterate through the inbound packet and prepare the lengths
 
1131
                 * for the output packet. The OUT packet we are about to send
 
1132
                 * will have the same amount of payload bytes per stride as the
 
1133
                 * IN packet we just received. Since the actual size is scaled
 
1134
                 * by the stride, use the sender stride to calculate the length
 
1135
                 * in case the number of channels differ between the implicitly
 
1136
                 * fed-back endpoint and the synchronizing endpoint.
 
1137
                 */
 
1138
 
 
1139
                out_packet->packets = in_ctx->packets;
 
1140
                for (i = 0; i < in_ctx->packets; i++) {
 
1141
                        if (urb->iso_frame_desc[i].status == 0)
 
1142
                                out_packet->packet_size[i] =
 
1143
                                        urb->iso_frame_desc[i].actual_length / sender->stride;
 
1144
                        else
 
1145
                                out_packet->packet_size[i] = 0;
 
1146
                }
 
1147
 
 
1148
                ep->next_packet_write_pos++;
 
1149
                ep->next_packet_write_pos %= MAX_URBS;
 
1150
                spin_unlock_irqrestore(&ep->lock, flags);
 
1151
                queue_pending_output_urbs(ep);
 
1152
 
 
1153
                return;
 
1154
        }
 
1155
 
 
1156
        /*
 
1157
         * process after playback sync complete
 
1158
         *
 
1159
         * Full speed devices report feedback values in 10.14 format as samples
 
1160
         * per frame, high speed devices in 16.16 format as samples per
 
1161
         * microframe.
 
1162
         *
 
1163
         * Because the Audio Class 1 spec was written before USB 2.0, many high
 
1164
         * speed devices use a wrong interpretation, some others use an
 
1165
         * entirely different format.
 
1166
         *
 
1167
         * Therefore, we cannot predict what format any particular device uses
 
1168
         * and must detect it automatically.
 
1169
         */
 
1170
 
 
1171
        if (urb->iso_frame_desc[0].status != 0 ||
 
1172
            urb->iso_frame_desc[0].actual_length < 3)
 
1173
                return;
 
1174
 
 
1175
        f = le32_to_cpup(urb->transfer_buffer);
 
1176
        if (urb->iso_frame_desc[0].actual_length == 3)
 
1177
                f &= 0x00ffffff;
 
1178
        else
 
1179
                f &= 0x0fffffff;
 
1180
 
 
1181
        if (f == 0)
 
1182
                return;
 
1183
 
 
1184
        if (unlikely(sender->tenor_fb_quirk)) {
 
1185
                /*
 
1186
                 * Devices based on Tenor 8802 chipsets (TEAC UD-H01
 
1187
                 * and others) sometimes change the feedback value
 
1188
                 * by +/- 0x1.0000.
 
1189
                 */
 
1190
                if (f < ep->freqn - 0x8000)
 
1191
                        f += 0xf000;
 
1192
                else if (f > ep->freqn + 0x8000)
 
1193
                        f -= 0xf000;
 
1194
        } else if (unlikely(ep->freqshift == INT_MIN)) {
 
1195
                /*
 
1196
                 * The first time we see a feedback value, determine its format
 
1197
                 * by shifting it left or right until it matches the nominal
 
1198
                 * frequency value.  This assumes that the feedback does not
 
1199
                 * differ from the nominal value more than +50% or -25%.
 
1200
                 */
 
1201
                shift = 0;
 
1202
                while (f < ep->freqn - ep->freqn / 4) {
 
1203
                        f <<= 1;
 
1204
                        shift++;
 
1205
                }
 
1206
                while (f > ep->freqn + ep->freqn / 2) {
 
1207
                        f >>= 1;
 
1208
                        shift--;
 
1209
                }
 
1210
                ep->freqshift = shift;
 
1211
        } else if (ep->freqshift >= 0)
 
1212
                f <<= ep->freqshift;
 
1213
        else
 
1214
                f >>= -ep->freqshift;
 
1215
 
 
1216
        if (likely(f >= ep->freqn - ep->freqn / 8 && f <= ep->freqmax)) {
 
1217
                /*
 
1218
                 * If the frequency looks valid, set it.
 
1219
                 * This value is referred to in prepare_playback_urb().
 
1220
                 */
 
1221
                spin_lock_irqsave(&ep->lock, flags);
 
1222
                ep->freqm = f;
 
1223
                spin_unlock_irqrestore(&ep->lock, flags);
 
1224
        } else {
 
1225
                /*
 
1226
                 * Out of range; maybe the shift value is wrong.
 
1227
                 * Reset it so that we autodetect again the next time.
 
1228
                 */
 
1229
                ep->freqshift = INT_MIN;
 
1230
        }
 
1231
}
 
1232