blob: ea995af6d049ec63b86f8fb59cf374640db9cc56 [file] [log] [blame]
Clemens Ladisch31ef9132011-03-15 07:53:21 +01001/*
2 * Audio and Music Data Transmission Protocol (IEC 61883-6) streams
3 * with Common Isochronous Packet (IEC 61883-1) headers
4 *
5 * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
6 * Licensed under the terms of the GNU General Public License, version 2.
7 */
8
9#include <linux/device.h>
10#include <linux/err.h>
11#include <linux/firewire.h>
12#include <linux/module.h>
13#include <linux/slab.h>
14#include <sound/pcm.h>
15#include "amdtp.h"
16
17#define TICKS_PER_CYCLE 3072
18#define CYCLES_PER_SECOND 8000
19#define TICKS_PER_SECOND (TICKS_PER_CYCLE * CYCLES_PER_SECOND)
20
21#define TRANSFER_DELAY_TICKS 0x2e00 /* 479.17 µs */
22
23#define TAG_CIP 1
24
25#define CIP_EOH (1u << 31)
26#define CIP_FMT_AM (0x10 << 24)
27#define AMDTP_FDF_AM824 (0 << 19)
28#define AMDTP_FDF_SFC_SHIFT 16
29
30/* TODO: make these configurable */
31#define INTERRUPT_INTERVAL 16
32#define QUEUE_LENGTH 48
33
Clemens Ladisch76fb8782012-05-13 22:03:09 +020034static void pcm_period_tasklet(unsigned long data);
35
Clemens Ladisch31ef9132011-03-15 07:53:21 +010036/**
37 * amdtp_out_stream_init - initialize an AMDTP output stream structure
38 * @s: the AMDTP output stream to initialize
39 * @unit: the target of the stream
40 * @flags: the packet transmission method to use
41 */
42int amdtp_out_stream_init(struct amdtp_out_stream *s, struct fw_unit *unit,
43 enum cip_out_flags flags)
44{
45 if (flags != CIP_NONBLOCKING)
46 return -EINVAL;
47
48 s->unit = fw_unit_get(unit);
49 s->flags = flags;
50 s->context = ERR_PTR(-1);
51 mutex_init(&s->mutex);
Clemens Ladisch76fb8782012-05-13 22:03:09 +020052 tasklet_init(&s->period_tasklet, pcm_period_tasklet, (unsigned long)s);
Clemens Ladischec00f5e2011-03-15 07:57:24 +010053 s->packet_index = 0;
Clemens Ladisch31ef9132011-03-15 07:53:21 +010054
55 return 0;
56}
57EXPORT_SYMBOL(amdtp_out_stream_init);
58
59/**
60 * amdtp_out_stream_destroy - free stream resources
61 * @s: the AMDTP output stream to destroy
62 */
63void amdtp_out_stream_destroy(struct amdtp_out_stream *s)
64{
65 WARN_ON(!IS_ERR(s->context));
66 mutex_destroy(&s->mutex);
67 fw_unit_put(s->unit);
68}
69EXPORT_SYMBOL(amdtp_out_stream_destroy);
70
71/**
72 * amdtp_out_stream_set_rate - set the sample rate
73 * @s: the AMDTP output stream to configure
74 * @rate: the sample rate
75 *
76 * The sample rate must be set before the stream is started, and must not be
77 * changed while the stream is running.
78 */
79void amdtp_out_stream_set_rate(struct amdtp_out_stream *s, unsigned int rate)
80{
81 static const struct {
82 unsigned int rate;
83 unsigned int syt_interval;
84 } rate_info[] = {
85 [CIP_SFC_32000] = { 32000, 8, },
86 [CIP_SFC_44100] = { 44100, 8, },
87 [CIP_SFC_48000] = { 48000, 8, },
88 [CIP_SFC_88200] = { 88200, 16, },
89 [CIP_SFC_96000] = { 96000, 16, },
90 [CIP_SFC_176400] = { 176400, 32, },
91 [CIP_SFC_192000] = { 192000, 32, },
92 };
93 unsigned int sfc;
94
95 if (WARN_ON(!IS_ERR(s->context)))
96 return;
97
98 for (sfc = 0; sfc < ARRAY_SIZE(rate_info); ++sfc)
99 if (rate_info[sfc].rate == rate) {
100 s->sfc = sfc;
101 s->syt_interval = rate_info[sfc].syt_interval;
102 return;
103 }
104 WARN_ON(1);
105}
106EXPORT_SYMBOL(amdtp_out_stream_set_rate);
107
108/**
109 * amdtp_out_stream_get_max_payload - get the stream's packet size
110 * @s: the AMDTP output stream
111 *
112 * This function must not be called before the stream has been configured
113 * with amdtp_out_stream_set_hw_params(), amdtp_out_stream_set_pcm(), and
114 * amdtp_out_stream_set_midi().
115 */
116unsigned int amdtp_out_stream_get_max_payload(struct amdtp_out_stream *s)
117{
118 static const unsigned int max_data_blocks[] = {
119 [CIP_SFC_32000] = 4,
120 [CIP_SFC_44100] = 6,
121 [CIP_SFC_48000] = 6,
122 [CIP_SFC_88200] = 12,
123 [CIP_SFC_96000] = 12,
124 [CIP_SFC_176400] = 23,
125 [CIP_SFC_192000] = 24,
126 };
127
128 s->data_block_quadlets = s->pcm_channels;
129 s->data_block_quadlets += DIV_ROUND_UP(s->midi_ports, 8);
130
131 return 8 + max_data_blocks[s->sfc] * 4 * s->data_block_quadlets;
132}
133EXPORT_SYMBOL(amdtp_out_stream_get_max_payload);
134
135static void amdtp_write_s16(struct amdtp_out_stream *s,
136 struct snd_pcm_substream *pcm,
137 __be32 *buffer, unsigned int frames);
138static void amdtp_write_s32(struct amdtp_out_stream *s,
139 struct snd_pcm_substream *pcm,
140 __be32 *buffer, unsigned int frames);
141
142/**
143 * amdtp_out_stream_set_pcm_format - set the PCM format
144 * @s: the AMDTP output stream to configure
145 * @format: the format of the ALSA PCM device
146 *
147 * The sample format must be set before the stream is started, and must not be
148 * changed while the stream is running.
149 */
150void amdtp_out_stream_set_pcm_format(struct amdtp_out_stream *s,
151 snd_pcm_format_t format)
152{
153 if (WARN_ON(!IS_ERR(s->context)))
154 return;
155
156 switch (format) {
157 default:
158 WARN_ON(1);
159 /* fall through */
160 case SNDRV_PCM_FORMAT_S16:
161 s->transfer_samples = amdtp_write_s16;
162 break;
163 case SNDRV_PCM_FORMAT_S32:
164 s->transfer_samples = amdtp_write_s32;
165 break;
166 }
167}
168EXPORT_SYMBOL(amdtp_out_stream_set_pcm_format);
169
Clemens Ladisch76fb8782012-05-13 22:03:09 +0200170/**
171 * amdtp_out_stream_pcm_prepare - prepare PCM device for running
172 * @s: the AMDTP output stream
173 *
174 * This function should be called from the PCM device's .prepare callback.
175 */
176void amdtp_out_stream_pcm_prepare(struct amdtp_out_stream *s)
177{
178 tasklet_kill(&s->period_tasklet);
179 s->pcm_buffer_pointer = 0;
180 s->pcm_period_pointer = 0;
Clemens Ladisch92b862c2012-05-13 19:07:22 +0200181 s->pointer_flush = true;
Clemens Ladisch76fb8782012-05-13 22:03:09 +0200182}
183EXPORT_SYMBOL(amdtp_out_stream_pcm_prepare);
184
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100185static unsigned int calculate_data_blocks(struct amdtp_out_stream *s)
186{
187 unsigned int phase, data_blocks;
188
189 if (!cip_sfc_is_base_44100(s->sfc)) {
190 /* Sample_rate / 8000 is an integer, and precomputed. */
191 data_blocks = s->data_block_state;
192 } else {
193 phase = s->data_block_state;
194
195 /*
196 * This calculates the number of data blocks per packet so that
197 * 1) the overall rate is correct and exactly synchronized to
198 * the bus clock, and
199 * 2) packets with a rounded-up number of blocks occur as early
200 * as possible in the sequence (to prevent underruns of the
201 * device's buffer).
202 */
203 if (s->sfc == CIP_SFC_44100)
204 /* 6 6 5 6 5 6 5 ... */
205 data_blocks = 5 + ((phase & 1) ^
206 (phase == 0 || phase >= 40));
207 else
208 /* 12 11 11 11 11 ... or 23 22 22 22 22 ... */
209 data_blocks = 11 * (s->sfc >> 1) + (phase == 0);
210 if (++phase >= (80 >> (s->sfc >> 1)))
211 phase = 0;
212 s->data_block_state = phase;
213 }
214
215 return data_blocks;
216}
217
218static unsigned int calculate_syt(struct amdtp_out_stream *s,
219 unsigned int cycle)
220{
221 unsigned int syt_offset, phase, index, syt;
222
223 if (s->last_syt_offset < TICKS_PER_CYCLE) {
224 if (!cip_sfc_is_base_44100(s->sfc))
225 syt_offset = s->last_syt_offset + s->syt_offset_state;
226 else {
227 /*
228 * The time, in ticks, of the n'th SYT_INTERVAL sample is:
229 * n * SYT_INTERVAL * 24576000 / sample_rate
230 * Modulo TICKS_PER_CYCLE, the difference between successive
231 * elements is about 1386.23. Rounding the results of this
232 * formula to the SYT precision results in a sequence of
233 * differences that begins with:
234 * 1386 1386 1387 1386 1386 1386 1387 1386 1386 1386 1387 ...
235 * This code generates _exactly_ the same sequence.
236 */
237 phase = s->syt_offset_state;
238 index = phase % 13;
239 syt_offset = s->last_syt_offset;
240 syt_offset += 1386 + ((index && !(index & 3)) ||
241 phase == 146);
242 if (++phase >= 147)
243 phase = 0;
244 s->syt_offset_state = phase;
245 }
246 } else
247 syt_offset = s->last_syt_offset - TICKS_PER_CYCLE;
248 s->last_syt_offset = syt_offset;
249
Clemens Ladischbe454362011-03-15 07:55:02 +0100250 if (syt_offset < TICKS_PER_CYCLE) {
251 syt_offset += TRANSFER_DELAY_TICKS - TICKS_PER_CYCLE;
252 syt = (cycle + syt_offset / TICKS_PER_CYCLE) << 12;
253 syt += syt_offset % TICKS_PER_CYCLE;
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100254
Clemens Ladischbe454362011-03-15 07:55:02 +0100255 return syt & 0xffff;
256 } else {
257 return 0xffff; /* no info */
258 }
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100259}
260
261static void amdtp_write_s32(struct amdtp_out_stream *s,
262 struct snd_pcm_substream *pcm,
263 __be32 *buffer, unsigned int frames)
264{
265 struct snd_pcm_runtime *runtime = pcm->runtime;
266 unsigned int channels, remaining_frames, frame_step, i, c;
267 const u32 *src;
268
269 channels = s->pcm_channels;
270 src = (void *)runtime->dma_area +
271 s->pcm_buffer_pointer * (runtime->frame_bits / 8);
272 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
273 frame_step = s->data_block_quadlets - channels;
274
275 for (i = 0; i < frames; ++i) {
276 for (c = 0; c < channels; ++c) {
277 *buffer = cpu_to_be32((*src >> 8) | 0x40000000);
278 src++;
279 buffer++;
280 }
281 buffer += frame_step;
282 if (--remaining_frames == 0)
283 src = (void *)runtime->dma_area;
284 }
285}
286
287static void amdtp_write_s16(struct amdtp_out_stream *s,
288 struct snd_pcm_substream *pcm,
289 __be32 *buffer, unsigned int frames)
290{
291 struct snd_pcm_runtime *runtime = pcm->runtime;
292 unsigned int channels, remaining_frames, frame_step, i, c;
293 const u16 *src;
294
295 channels = s->pcm_channels;
296 src = (void *)runtime->dma_area +
297 s->pcm_buffer_pointer * (runtime->frame_bits / 8);
298 remaining_frames = runtime->buffer_size - s->pcm_buffer_pointer;
299 frame_step = s->data_block_quadlets - channels;
300
301 for (i = 0; i < frames; ++i) {
302 for (c = 0; c < channels; ++c) {
303 *buffer = cpu_to_be32((*src << 8) | 0x40000000);
304 src++;
305 buffer++;
306 }
307 buffer += frame_step;
308 if (--remaining_frames == 0)
309 src = (void *)runtime->dma_area;
310 }
311}
312
313static void amdtp_fill_pcm_silence(struct amdtp_out_stream *s,
314 __be32 *buffer, unsigned int frames)
315{
316 unsigned int i, c;
317
318 for (i = 0; i < frames; ++i) {
319 for (c = 0; c < s->pcm_channels; ++c)
320 buffer[c] = cpu_to_be32(0x40000000);
321 buffer += s->data_block_quadlets;
322 }
323}
324
325static void amdtp_fill_midi(struct amdtp_out_stream *s,
326 __be32 *buffer, unsigned int frames)
327{
328 unsigned int i;
329
330 for (i = 0; i < frames; ++i)
331 buffer[s->pcm_channels + i * s->data_block_quadlets] =
332 cpu_to_be32(0x80000000);
333}
334
335static void queue_out_packet(struct amdtp_out_stream *s, unsigned int cycle)
336{
337 __be32 *buffer;
Clemens Ladischec00f5e2011-03-15 07:57:24 +0100338 unsigned int index, data_blocks, syt, ptr;
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100339 struct snd_pcm_substream *pcm;
340 struct fw_iso_packet packet;
341 int err;
342
Clemens Ladischec00f5e2011-03-15 07:57:24 +0100343 if (s->packet_index < 0)
344 return;
345 index = s->packet_index;
346
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100347 data_blocks = calculate_data_blocks(s);
348 syt = calculate_syt(s, cycle);
349
Clemens Ladischec00f5e2011-03-15 07:57:24 +0100350 buffer = s->buffer.packets[index].buffer;
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100351 buffer[0] = cpu_to_be32(ACCESS_ONCE(s->source_node_id_field) |
352 (s->data_block_quadlets << 16) |
353 s->data_block_counter);
354 buffer[1] = cpu_to_be32(CIP_EOH | CIP_FMT_AM | AMDTP_FDF_AM824 |
355 (s->sfc << AMDTP_FDF_SFC_SHIFT) | syt);
356 buffer += 2;
357
358 pcm = ACCESS_ONCE(s->pcm);
359 if (pcm)
360 s->transfer_samples(s, pcm, buffer, data_blocks);
361 else
362 amdtp_fill_pcm_silence(s, buffer, data_blocks);
363 if (s->midi_ports)
364 amdtp_fill_midi(s, buffer, data_blocks);
365
366 s->data_block_counter = (s->data_block_counter + data_blocks) & 0xff;
367
368 packet.payload_length = 8 + data_blocks * 4 * s->data_block_quadlets;
Clemens Ladischec00f5e2011-03-15 07:57:24 +0100369 packet.interrupt = IS_ALIGNED(index + 1, INTERRUPT_INTERVAL);
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100370 packet.skip = 0;
371 packet.tag = TAG_CIP;
372 packet.sy = 0;
373 packet.header_length = 0;
374
375 err = fw_iso_context_queue(s->context, &packet, &s->buffer.iso_buffer,
Clemens Ladischec00f5e2011-03-15 07:57:24 +0100376 s->buffer.packets[index].offset);
377 if (err < 0) {
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100378 dev_err(&s->unit->device, "queueing error: %d\n", err);
Clemens Ladischec00f5e2011-03-15 07:57:24 +0100379 s->packet_index = -1;
380 amdtp_out_stream_pcm_abort(s);
381 return;
382 }
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100383
Clemens Ladischec00f5e2011-03-15 07:57:24 +0100384 if (++index >= QUEUE_LENGTH)
385 index = 0;
386 s->packet_index = index;
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100387
388 if (pcm) {
389 ptr = s->pcm_buffer_pointer + data_blocks;
390 if (ptr >= pcm->runtime->buffer_size)
391 ptr -= pcm->runtime->buffer_size;
392 ACCESS_ONCE(s->pcm_buffer_pointer) = ptr;
393
394 s->pcm_period_pointer += data_blocks;
395 if (s->pcm_period_pointer >= pcm->runtime->period_size) {
396 s->pcm_period_pointer -= pcm->runtime->period_size;
Clemens Ladisch92b862c2012-05-13 19:07:22 +0200397 s->pointer_flush = false;
Clemens Ladisch76fb8782012-05-13 22:03:09 +0200398 tasklet_hi_schedule(&s->period_tasklet);
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100399 }
400 }
401}
402
Clemens Ladisch76fb8782012-05-13 22:03:09 +0200403static void pcm_period_tasklet(unsigned long data)
404{
405 struct amdtp_out_stream *s = (void *)data;
406 struct snd_pcm_substream *pcm = ACCESS_ONCE(s->pcm);
407
408 if (pcm)
409 snd_pcm_period_elapsed(pcm);
410}
411
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100412static void out_packet_callback(struct fw_iso_context *context, u32 cycle,
413 size_t header_length, void *header, void *data)
414{
415 struct amdtp_out_stream *s = data;
416 unsigned int i, packets = header_length / 4;
417
418 /*
419 * Compute the cycle of the last queued packet.
420 * (We need only the four lowest bits for the SYT, so we can ignore
421 * that bits 0-11 must wrap around at 3072.)
422 */
423 cycle += QUEUE_LENGTH - packets;
424
425 for (i = 0; i < packets; ++i)
426 queue_out_packet(s, ++cycle);
Clemens Ladisch13882a82011-05-02 09:33:56 +0200427 fw_iso_context_queue_flush(s->context);
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100428}
429
430static int queue_initial_skip_packets(struct amdtp_out_stream *s)
431{
432 struct fw_iso_packet skip_packet = {
433 .skip = 1,
434 };
435 unsigned int i;
436 int err;
437
438 for (i = 0; i < QUEUE_LENGTH; ++i) {
Clemens Ladischec00f5e2011-03-15 07:57:24 +0100439 skip_packet.interrupt = IS_ALIGNED(s->packet_index + 1,
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100440 INTERRUPT_INTERVAL);
441 err = fw_iso_context_queue(s->context, &skip_packet, NULL, 0);
442 if (err < 0)
443 return err;
Clemens Ladischec00f5e2011-03-15 07:57:24 +0100444 if (++s->packet_index >= QUEUE_LENGTH)
445 s->packet_index = 0;
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100446 }
447
448 return 0;
449}
450
451/**
452 * amdtp_out_stream_start - start sending packets
453 * @s: the AMDTP output stream to start
454 * @channel: the isochronous channel on the bus
455 * @speed: firewire speed code
456 *
457 * The stream cannot be started until it has been configured with
458 * amdtp_out_stream_set_hw_params(), amdtp_out_stream_set_pcm(), and
459 * amdtp_out_stream_set_midi(); and it must be started before any
460 * PCM or MIDI device can be started.
461 */
462int amdtp_out_stream_start(struct amdtp_out_stream *s, int channel, int speed)
463{
464 static const struct {
465 unsigned int data_block;
466 unsigned int syt_offset;
467 } initial_state[] = {
468 [CIP_SFC_32000] = { 4, 3072 },
469 [CIP_SFC_48000] = { 6, 1024 },
470 [CIP_SFC_96000] = { 12, 1024 },
471 [CIP_SFC_192000] = { 24, 1024 },
472 [CIP_SFC_44100] = { 0, 67 },
473 [CIP_SFC_88200] = { 0, 67 },
474 [CIP_SFC_176400] = { 0, 67 },
475 };
476 int err;
477
478 mutex_lock(&s->mutex);
479
480 if (WARN_ON(!IS_ERR(s->context) ||
481 (!s->pcm_channels && !s->midi_ports))) {
482 err = -EBADFD;
483 goto err_unlock;
484 }
485
486 s->data_block_state = initial_state[s->sfc].data_block;
487 s->syt_offset_state = initial_state[s->sfc].syt_offset;
488 s->last_syt_offset = TICKS_PER_CYCLE;
489
490 err = iso_packets_buffer_init(&s->buffer, s->unit, QUEUE_LENGTH,
491 amdtp_out_stream_get_max_payload(s),
492 DMA_TO_DEVICE);
493 if (err < 0)
494 goto err_unlock;
495
496 s->context = fw_iso_context_create(fw_parent_device(s->unit)->card,
497 FW_ISO_CONTEXT_TRANSMIT,
498 channel, speed, 0,
499 out_packet_callback, s);
500 if (IS_ERR(s->context)) {
501 err = PTR_ERR(s->context);
502 if (err == -EBUSY)
503 dev_err(&s->unit->device,
504 "no free output stream on this controller\n");
505 goto err_buffer;
506 }
507
508 amdtp_out_stream_update(s);
509
Clemens Ladischec00f5e2011-03-15 07:57:24 +0100510 s->packet_index = 0;
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100511 s->data_block_counter = 0;
512 err = queue_initial_skip_packets(s);
513 if (err < 0)
514 goto err_context;
515
516 err = fw_iso_context_start(s->context, -1, 0, 0);
517 if (err < 0)
518 goto err_context;
519
520 mutex_unlock(&s->mutex);
521
522 return 0;
523
524err_context:
525 fw_iso_context_destroy(s->context);
526 s->context = ERR_PTR(-1);
527err_buffer:
528 iso_packets_buffer_destroy(&s->buffer, s->unit);
529err_unlock:
530 mutex_unlock(&s->mutex);
531
532 return err;
533}
534EXPORT_SYMBOL(amdtp_out_stream_start);
535
536/**
Clemens Ladische9148dd2012-05-13 18:49:14 +0200537 * amdtp_out_stream_pcm_pointer - get the PCM buffer position
538 * @s: the AMDTP output stream that transports the PCM data
539 *
540 * Returns the current buffer position, in frames.
541 */
542unsigned long amdtp_out_stream_pcm_pointer(struct amdtp_out_stream *s)
543{
Clemens Ladisch92b862c2012-05-13 19:07:22 +0200544 /* this optimization is allowed to be racy */
545 if (s->pointer_flush)
546 fw_iso_context_flush_completions(s->context);
547 else
548 s->pointer_flush = true;
Clemens Ladische9148dd2012-05-13 18:49:14 +0200549
550 return ACCESS_ONCE(s->pcm_buffer_pointer);
551}
552EXPORT_SYMBOL(amdtp_out_stream_pcm_pointer);
553
554/**
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100555 * amdtp_out_stream_update - update the stream after a bus reset
556 * @s: the AMDTP output stream
557 */
558void amdtp_out_stream_update(struct amdtp_out_stream *s)
559{
560 ACCESS_ONCE(s->source_node_id_field) =
561 (fw_parent_device(s->unit)->card->node_id & 0x3f) << 24;
562}
563EXPORT_SYMBOL(amdtp_out_stream_update);
564
565/**
566 * amdtp_out_stream_stop - stop sending packets
567 * @s: the AMDTP output stream to stop
568 *
569 * All PCM and MIDI devices of the stream must be stopped before the stream
570 * itself can be stopped.
571 */
572void amdtp_out_stream_stop(struct amdtp_out_stream *s)
573{
574 mutex_lock(&s->mutex);
575
576 if (IS_ERR(s->context)) {
577 mutex_unlock(&s->mutex);
578 return;
579 }
580
Clemens Ladisch76fb8782012-05-13 22:03:09 +0200581 tasklet_kill(&s->period_tasklet);
Clemens Ladisch31ef9132011-03-15 07:53:21 +0100582 fw_iso_context_stop(s->context);
583 fw_iso_context_destroy(s->context);
584 s->context = ERR_PTR(-1);
585 iso_packets_buffer_destroy(&s->buffer, s->unit);
586
587 mutex_unlock(&s->mutex);
588}
589EXPORT_SYMBOL(amdtp_out_stream_stop);
590
591/**
592 * amdtp_out_stream_pcm_abort - abort the running PCM device
593 * @s: the AMDTP stream about to be stopped
594 *
595 * If the isochronous stream needs to be stopped asynchronously, call this
596 * function first to stop the PCM device.
597 */
598void amdtp_out_stream_pcm_abort(struct amdtp_out_stream *s)
599{
600 struct snd_pcm_substream *pcm;
601
602 pcm = ACCESS_ONCE(s->pcm);
603 if (pcm) {
604 snd_pcm_stream_lock_irq(pcm);
605 if (snd_pcm_running(pcm))
606 snd_pcm_stop(pcm, SNDRV_PCM_STATE_XRUN);
607 snd_pcm_stream_unlock_irq(pcm);
608 }
609}
610EXPORT_SYMBOL(amdtp_out_stream_pcm_abort);