blob: 8fc2dedbeb52e7e8a44a42207d43274fa0e3a36a [file] [log] [blame]
Markus Grabner705ecec2009-02-27 19:43:04 -08001/*
Markus Grabnere1a164d2010-08-23 01:08:25 +02002 * Line6 Linux USB driver - 0.9.1beta
Markus Grabner705ecec2009-02-27 19:43:04 -08003 *
Markus Grabner1027f4762010-08-12 01:35:30 +02004 * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
Markus Grabner705ecec2009-02-27 19:43:04 -08005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation, version 2.
9 *
10 */
11
Stefan Hajnoczi140e28b2011-11-23 08:20:45 +000012#include <linux/slab.h>
Markus Grabner705ecec2009-02-27 19:43:04 -080013#include <sound/core.h>
14#include <sound/pcm.h>
15#include <sound/pcm_params.h>
16
17#include "audio.h"
Markus Grabner1027f4762010-08-12 01:35:30 +020018#include "capture.h"
19#include "driver.h"
Markus Grabner705ecec2009-02-27 19:43:04 -080020#include "pcm.h"
Greg Kroah-Hartmanb702ed252009-02-27 20:45:03 -080021#include "playback.h"
Markus Grabner705ecec2009-02-27 19:43:04 -080022
Markus Grabner705ecec2009-02-27 19:43:04 -080023/*
24 Software stereo volume control.
25*/
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -080026static void change_volume(struct urb *urb_out, int volume[],
27 int bytes_per_frame)
Markus Grabner705ecec2009-02-27 19:43:04 -080028{
29 int chn = 0;
30
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -080031 if (volume[0] == 256 && volume[1] == 256)
Shawn Bohrer45af4972009-11-15 22:17:50 -060032 return; /* maximum volume - no change */
Markus Grabner705ecec2009-02-27 19:43:04 -080033
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -080034 if (bytes_per_frame == 4) {
Markus Grabner705ecec2009-02-27 19:43:04 -080035 short *p, *buf_end;
Fabian Mewesa6b46992014-03-24 23:46:31 +010036
Markus Grabner705ecec2009-02-27 19:43:04 -080037 p = (short *)urb_out->transfer_buffer;
38 buf_end = p + urb_out->transfer_buffer_length / sizeof(*p);
39
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -080040 for (; p < buf_end; ++p) {
Markus Grabner705ecec2009-02-27 19:43:04 -080041 *p = (*p * volume[chn & 1]) >> 8;
42 ++chn;
43 }
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -080044 } else if (bytes_per_frame == 6) {
Markus Grabner705ecec2009-02-27 19:43:04 -080045 unsigned char *p, *buf_end;
Jerry Snitselaarf3c52612014-04-24 00:31:48 -070046
Markus Grabner705ecec2009-02-27 19:43:04 -080047 p = (unsigned char *)urb_out->transfer_buffer;
48 buf_end = p + urb_out->transfer_buffer_length;
49
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -080050 for (; p < buf_end; p += 3) {
51 int val;
Fabian Mewesa6b46992014-03-24 23:46:31 +010052
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -080053 val = p[0] + (p[1] << 8) + ((signed char)p[2] << 16);
Markus Grabner705ecec2009-02-27 19:43:04 -080054 val = (val * volume[chn & 1]) >> 8;
55 p[0] = val;
56 p[1] = val >> 8;
57 p[2] = val >> 16;
58 ++chn;
59 }
60 }
61}
62
Markus Grabner1027f4762010-08-12 01:35:30 +020063/*
64 Create signal for impulse response test.
65*/
66static void create_impulse_test_signal(struct snd_line6_pcm *line6pcm,
67 struct urb *urb_out, int bytes_per_frame)
68{
69 int frames = urb_out->transfer_buffer_length / bytes_per_frame;
70
71 if (bytes_per_frame == 4) {
Markus Grabnere1a164d2010-08-23 01:08:25 +020072 int i;
73 short *pi = (short *)line6pcm->prev_fbuf;
74 short *po = (short *)urb_out->transfer_buffer;
75
76 for (i = 0; i < frames; ++i) {
77 po[0] = pi[0];
78 po[1] = 0;
79 pi += 2;
80 po += 2;
81 }
Markus Grabner1027f4762010-08-12 01:35:30 +020082 } else if (bytes_per_frame == 6) {
83 int i, j;
84 unsigned char *pi = line6pcm->prev_fbuf;
85 unsigned char *po = urb_out->transfer_buffer;
86
87 for (i = 0; i < frames; ++i) {
88 for (j = 0; j < bytes_per_frame / 2; ++j)
89 po[j] = pi[j];
90
91 for (; j < bytes_per_frame; ++j)
92 po[j] = 0;
93
94 pi += bytes_per_frame;
95 po += bytes_per_frame;
96 }
Markus Grabnere1a164d2010-08-23 01:08:25 +020097 }
98 if (--line6pcm->impulse_count <= 0) {
99 ((unsigned char *)(urb_out->transfer_buffer))[bytes_per_frame -
100 1] =
101 line6pcm->impulse_volume;
102 line6pcm->impulse_count = line6pcm->impulse_period;
Markus Grabner1027f4762010-08-12 01:35:30 +0200103 }
104}
105
Markus Grabner1027f4762010-08-12 01:35:30 +0200106/*
107 Add signal to buffer for software monitoring.
108*/
109static void add_monitor_signal(struct urb *urb_out, unsigned char *signal,
110 int volume, int bytes_per_frame)
111{
112 if (volume == 0)
113 return; /* zero volume - no change */
114
115 if (bytes_per_frame == 4) {
116 short *pi, *po, *buf_end;
Fabian Mewesa6b46992014-03-24 23:46:31 +0100117
Markus Grabner1027f4762010-08-12 01:35:30 +0200118 pi = (short *)signal;
119 po = (short *)urb_out->transfer_buffer;
120 buf_end = po + urb_out->transfer_buffer_length / sizeof(*po);
121
122 for (; po < buf_end; ++pi, ++po)
123 *po += (*pi * volume) >> 8;
124 }
125
126 /*
Markus Grabnere1a164d2010-08-23 01:08:25 +0200127 We don't need to handle devices with 6 bytes per frame here
128 since they all support hardware monitoring.
129 */
Markus Grabner1027f4762010-08-12 01:35:30 +0200130}
131
Markus Grabner705ecec2009-02-27 19:43:04 -0800132/*
133 Find a free URB, prepare audio data, and submit URB.
134*/
Markus Grabner1027f4762010-08-12 01:35:30 +0200135static int submit_audio_out_urb(struct snd_line6_pcm *line6pcm)
Markus Grabner705ecec2009-02-27 19:43:04 -0800136{
137 int index;
138 unsigned long flags;
139 int i, urb_size, urb_frames;
Markus Grabnere1a164d2010-08-23 01:08:25 +0200140 int ret;
Markus Grabner705ecec2009-02-27 19:43:04 -0800141 const int bytes_per_frame = line6pcm->properties->bytes_per_frame;
Shawn Bohrer45af4972009-11-15 22:17:50 -0600142 const int frame_increment =
143 line6pcm->properties->snd_line6_rates.rats[0].num_min;
144 const int frame_factor =
145 line6pcm->properties->snd_line6_rates.rats[0].den *
146 (USB_INTERVALS_PER_SECOND / LINE6_ISO_INTERVAL);
Markus Grabner705ecec2009-02-27 19:43:04 -0800147 struct urb *urb_out;
148
149 spin_lock_irqsave(&line6pcm->lock_audio_out, flags);
Shawn Bohrer45af4972009-11-15 22:17:50 -0600150 index =
151 find_first_zero_bit(&line6pcm->active_urb_out, LINE6_ISO_BUFFERS);
Markus Grabner705ecec2009-02-27 19:43:04 -0800152
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800153 if (index < 0 || index >= LINE6_ISO_BUFFERS) {
Markus Grabner705ecec2009-02-27 19:43:04 -0800154 spin_unlock_irqrestore(&line6pcm->lock_audio_out, flags);
Markus Grabner1027f4762010-08-12 01:35:30 +0200155 dev_err(line6pcm->line6->ifcdev, "no free URB found\n");
Markus Grabner705ecec2009-02-27 19:43:04 -0800156 return -EINVAL;
157 }
158
159 urb_out = line6pcm->urb_audio_out[index];
160 urb_size = 0;
161
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800162 for (i = 0; i < LINE6_ISO_PACKETS; ++i) {
Markus Grabner705ecec2009-02-27 19:43:04 -0800163 /* compute frame size for given sampling rate */
Markus Grabner1027f4762010-08-12 01:35:30 +0200164 int fsize = 0;
Shawn Bohrer45af4972009-11-15 22:17:50 -0600165 struct usb_iso_packet_descriptor *fout =
166 &urb_out->iso_frame_desc[i];
Markus Grabner1027f4762010-08-12 01:35:30 +0200167
Markus Grabner0ca54882012-01-20 00:09:09 +0100168 if (line6pcm->flags & LINE6_BITS_CAPTURE_STREAM)
Markus Grabner1027f4762010-08-12 01:35:30 +0200169 fsize = line6pcm->prev_fsize;
Markus Grabner1027f4762010-08-12 01:35:30 +0200170
171 if (fsize == 0) {
172 int n;
Fabian Mewesa6b46992014-03-24 23:46:31 +0100173
Markus Grabner1027f4762010-08-12 01:35:30 +0200174 line6pcm->count_out += frame_increment;
175 n = line6pcm->count_out / frame_factor;
176 line6pcm->count_out -= n * frame_factor;
177 fsize = n * bytes_per_frame;
178 }
179
Markus Grabner705ecec2009-02-27 19:43:04 -0800180 fout->offset = urb_size;
Markus Grabner1027f4762010-08-12 01:35:30 +0200181 fout->length = fsize;
182 urb_size += fsize;
183 }
184
185 if (urb_size == 0) {
186 /* can't determine URB size */
187 spin_unlock_irqrestore(&line6pcm->lock_audio_out, flags);
Stefan Hajnoczi6a8ec872012-11-11 13:24:43 +0100188 dev_err(line6pcm->line6->ifcdev, "driver bug: urb_size = 0\n");
Markus Grabner1027f4762010-08-12 01:35:30 +0200189 return -EINVAL;
Markus Grabner705ecec2009-02-27 19:43:04 -0800190 }
191
192 urb_frames = urb_size / bytes_per_frame;
Markus Grabner1027f4762010-08-12 01:35:30 +0200193 urb_out->transfer_buffer =
194 line6pcm->buffer_out +
Stefan Hajnoczi153e3872011-12-10 02:12:29 +0100195 index * LINE6_ISO_PACKETS * line6pcm->max_packet_size;
Markus Grabner1027f4762010-08-12 01:35:30 +0200196 urb_out->transfer_buffer_length = urb_size;
197 urb_out->context = line6pcm;
Markus Grabner705ecec2009-02-27 19:43:04 -0800198
Markus Grabner0ca54882012-01-20 00:09:09 +0100199 if (test_bit(LINE6_INDEX_PCM_ALSA_PLAYBACK_STREAM, &line6pcm->flags) &&
200 !test_bit(LINE6_INDEX_PAUSE_PLAYBACK, &line6pcm->flags)) {
Markus Grabner1027f4762010-08-12 01:35:30 +0200201 struct snd_pcm_runtime *runtime =
202 get_substream(line6pcm, SNDRV_PCM_STREAM_PLAYBACK)->runtime;
203
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800204 if (line6pcm->pos_out + urb_frames > runtime->buffer_size) {
Markus Grabner705ecec2009-02-27 19:43:04 -0800205 /*
Shawn Bohrer45af4972009-11-15 22:17:50 -0600206 The transferred area goes over buffer boundary,
207 copy the data to the temp buffer.
208 */
Markus Grabner705ecec2009-02-27 19:43:04 -0800209 int len;
Fabian Mewesa6b46992014-03-24 23:46:31 +0100210
Markus Grabner705ecec2009-02-27 19:43:04 -0800211 len = runtime->buffer_size - line6pcm->pos_out;
Markus Grabner705ecec2009-02-27 19:43:04 -0800212
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800213 if (len > 0) {
Markus Grabner1027f4762010-08-12 01:35:30 +0200214 memcpy(urb_out->transfer_buffer,
Shawn Bohrer45af4972009-11-15 22:17:50 -0600215 runtime->dma_area +
216 line6pcm->pos_out * bytes_per_frame,
217 len * bytes_per_frame);
Markus Grabner1027f4762010-08-12 01:35:30 +0200218 memcpy(urb_out->transfer_buffer +
Shawn Bohrer45af4972009-11-15 22:17:50 -0600219 len * bytes_per_frame, runtime->dma_area,
220 (urb_frames - len) * bytes_per_frame);
Markus Grabner1027f4762010-08-12 01:35:30 +0200221 } else
Stefan Hajnoczi6a8ec872012-11-11 13:24:43 +0100222 dev_err(line6pcm->line6->ifcdev, "driver bug: len = %d\n",
223 len);
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800224 } else {
Markus Grabner1027f4762010-08-12 01:35:30 +0200225 memcpy(urb_out->transfer_buffer,
226 runtime->dma_area +
227 line6pcm->pos_out * bytes_per_frame,
228 urb_out->transfer_buffer_length);
Markus Grabner705ecec2009-02-27 19:43:04 -0800229 }
Markus Grabner1027f4762010-08-12 01:35:30 +0200230
Greg Kroah-Hartman027360c2010-09-21 16:58:00 -0700231 line6pcm->pos_out += urb_frames;
232 if (line6pcm->pos_out >= runtime->buffer_size)
Markus Grabner1027f4762010-08-12 01:35:30 +0200233 line6pcm->pos_out -= runtime->buffer_size;
234 } else {
235 memset(urb_out->transfer_buffer, 0,
236 urb_out->transfer_buffer_length);
Markus Grabner705ecec2009-02-27 19:43:04 -0800237 }
238
Markus Grabner1027f4762010-08-12 01:35:30 +0200239 change_volume(urb_out, line6pcm->volume_playback, bytes_per_frame);
Markus Grabner705ecec2009-02-27 19:43:04 -0800240
Peter Huewe597a1e72010-12-07 23:38:02 +0100241 if (line6pcm->prev_fbuf != NULL) {
Markus Grabner0ca54882012-01-20 00:09:09 +0100242 if (line6pcm->flags & LINE6_BITS_PCM_IMPULSE) {
Markus Grabner1027f4762010-08-12 01:35:30 +0200243 create_impulse_test_signal(line6pcm, urb_out,
244 bytes_per_frame);
Ebru Akagunduz30bb0e72013-10-23 02:00:22 +0300245 if (line6pcm->flags &
246 LINE6_BIT_PCM_ALSA_CAPTURE_STREAM) {
Markus Grabnere1a164d2010-08-23 01:08:25 +0200247 line6_capture_copy(line6pcm,
248 urb_out->transfer_buffer,
249 urb_out->
250 transfer_buffer_length);
251 line6_capture_check_period(line6pcm,
Ebru Akagunduz30bb0e72013-10-23 02:00:22 +0300252 urb_out->transfer_buffer_length);
Markus Grabner1027f4762010-08-12 01:35:30 +0200253 }
254 } else {
Markus Grabner1027f4762010-08-12 01:35:30 +0200255 if (!
Markus Grabnere1a164d2010-08-23 01:08:25 +0200256 (line6pcm->line6->
Chris Rorvick4cb1a4a2015-01-12 12:42:45 -0800257 properties->capabilities & LINE6_CAP_HWMON)
Markus Grabner0ca54882012-01-20 00:09:09 +0100258 && (line6pcm->flags & LINE6_BITS_PLAYBACK_STREAM)
259 && (line6pcm->flags & LINE6_BITS_CAPTURE_STREAM))
Markus Grabner1027f4762010-08-12 01:35:30 +0200260 add_monitor_signal(urb_out, line6pcm->prev_fbuf,
261 line6pcm->volume_monitor,
262 bytes_per_frame);
Markus Grabner1027f4762010-08-12 01:35:30 +0200263 }
Markus Grabner1027f4762010-08-12 01:35:30 +0200264 }
Markus Grabner705ecec2009-02-27 19:43:04 -0800265
Markus Grabnere1a164d2010-08-23 01:08:25 +0200266 ret = usb_submit_urb(urb_out, GFP_ATOMIC);
267
268 if (ret == 0)
Markus Grabner705ecec2009-02-27 19:43:04 -0800269 set_bit(index, &line6pcm->active_urb_out);
270 else
Markus Grabner1027f4762010-08-12 01:35:30 +0200271 dev_err(line6pcm->line6->ifcdev,
Markus Grabnere1a164d2010-08-23 01:08:25 +0200272 "URB out #%d submission failed (%d)\n", index, ret);
Markus Grabner705ecec2009-02-27 19:43:04 -0800273
274 spin_unlock_irqrestore(&line6pcm->lock_audio_out, flags);
275 return 0;
276}
277
278/*
279 Submit all currently available playback URBs.
280*/
Markus Grabner1027f4762010-08-12 01:35:30 +0200281int line6_submit_audio_out_all_urbs(struct snd_line6_pcm *line6pcm)
Markus Grabner705ecec2009-02-27 19:43:04 -0800282{
283 int ret, i;
284
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800285 for (i = 0; i < LINE6_ISO_BUFFERS; ++i) {
Markus Grabner1027f4762010-08-12 01:35:30 +0200286 ret = submit_audio_out_urb(line6pcm);
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800287 if (ret < 0)
Markus Grabner705ecec2009-02-27 19:43:04 -0800288 return ret;
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800289 }
Markus Grabner705ecec2009-02-27 19:43:04 -0800290
291 return 0;
292}
293
294/*
295 Unlink all currently active playback URBs.
296*/
Markus Grabner1027f4762010-08-12 01:35:30 +0200297void line6_unlink_audio_out_urbs(struct snd_line6_pcm *line6pcm)
Markus Grabner705ecec2009-02-27 19:43:04 -0800298{
299 unsigned int i;
300
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800301 for (i = LINE6_ISO_BUFFERS; i--;) {
302 if (test_bit(i, &line6pcm->active_urb_out)) {
303 if (!test_and_set_bit(i, &line6pcm->unlink_urb_out)) {
Markus Grabner705ecec2009-02-27 19:43:04 -0800304 struct urb *u = line6pcm->urb_audio_out[i];
Jerry Snitselaarf3c52612014-04-24 00:31:48 -0700305
Markus Grabner705ecec2009-02-27 19:43:04 -0800306 usb_unlink_urb(u);
307 }
308 }
309 }
310}
311
312/*
Stefan Hajnoczi6a8ec872012-11-11 13:24:43 +0100313 Wait until unlinking of all currently active playback URBs has been
314 finished.
Markus Grabner705ecec2009-02-27 19:43:04 -0800315*/
Markus Grabner0ca54882012-01-20 00:09:09 +0100316void line6_wait_clear_audio_out_urbs(struct snd_line6_pcm *line6pcm)
Markus Grabner705ecec2009-02-27 19:43:04 -0800317{
318 int timeout = HZ;
319 unsigned int i;
320 int alive;
321
322 do {
323 alive = 0;
324 for (i = LINE6_ISO_BUFFERS; i--;) {
325 if (test_bit(i, &line6pcm->active_urb_out))
326 alive++;
327 }
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800328 if (!alive)
Markus Grabner705ecec2009-02-27 19:43:04 -0800329 break;
330 set_current_state(TASK_UNINTERRUPTIBLE);
331 schedule_timeout(1);
332 } while (--timeout > 0);
333 if (alive)
334 snd_printk(KERN_ERR "timeout: still %d active urbs..\n", alive);
Markus Grabner705ecec2009-02-27 19:43:04 -0800335}
336
337/*
338 Unlink all currently active playback URBs, and wait for finishing.
339*/
Markus Grabner1027f4762010-08-12 01:35:30 +0200340void line6_unlink_wait_clear_audio_out_urbs(struct snd_line6_pcm *line6pcm)
Markus Grabner705ecec2009-02-27 19:43:04 -0800341{
Markus Grabner1027f4762010-08-12 01:35:30 +0200342 line6_unlink_audio_out_urbs(line6pcm);
Markus Grabner0ca54882012-01-20 00:09:09 +0100343 line6_wait_clear_audio_out_urbs(line6pcm);
Markus Grabner6b02a17e2011-12-10 02:12:32 +0100344}
345
346void line6_free_playback_buffer(struct snd_line6_pcm *line6pcm)
347{
348 kfree(line6pcm->buffer_out);
349 line6pcm->buffer_out = NULL;
350}
351
Markus Grabner705ecec2009-02-27 19:43:04 -0800352/*
353 Callback for completed playback URB.
354*/
Greg Kroah-Hartman0c7ab152009-02-27 20:28:04 -0800355static void audio_out_callback(struct urb *urb)
Markus Grabner705ecec2009-02-27 19:43:04 -0800356{
357 int i, index, length = 0, shutdown = 0;
358 unsigned long flags;
Markus Grabnere1a164d2010-08-23 01:08:25 +0200359 struct snd_line6_pcm *line6pcm = (struct snd_line6_pcm *)urb->context;
Shawn Bohrer45af4972009-11-15 22:17:50 -0600360 struct snd_pcm_substream *substream =
Markus Grabner1027f4762010-08-12 01:35:30 +0200361 get_substream(line6pcm, SNDRV_PCM_STREAM_PLAYBACK);
362
363#if USE_CLEAR_BUFFER_WORKAROUND
364 memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
365#endif
366
367 line6pcm->last_frame_out = urb->start_frame;
Markus Grabner705ecec2009-02-27 19:43:04 -0800368
369 /* find index of URB */
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800370 for (index = LINE6_ISO_BUFFERS; index--;)
371 if (urb == line6pcm->urb_audio_out[index])
Markus Grabner705ecec2009-02-27 19:43:04 -0800372 break;
373
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800374 if (index < 0)
Shawn Bohrer45af4972009-11-15 22:17:50 -0600375 return; /* URB has been unlinked asynchronously */
Markus Grabner705ecec2009-02-27 19:43:04 -0800376
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800377 for (i = LINE6_ISO_PACKETS; i--;)
Markus Grabner705ecec2009-02-27 19:43:04 -0800378 length += urb->iso_frame_desc[i].length;
379
380 spin_lock_irqsave(&line6pcm->lock_audio_out, flags);
Markus Grabner705ecec2009-02-27 19:43:04 -0800381
Markus Grabner0ca54882012-01-20 00:09:09 +0100382 if (test_bit(LINE6_INDEX_PCM_ALSA_PLAYBACK_STREAM, &line6pcm->flags)) {
Markus Grabner1027f4762010-08-12 01:35:30 +0200383 struct snd_pcm_runtime *runtime = substream->runtime;
Jerry Snitselaarf3c52612014-04-24 00:31:48 -0700384
Markus Grabner1027f4762010-08-12 01:35:30 +0200385 line6pcm->pos_out_done +=
386 length / line6pcm->properties->bytes_per_frame;
387
388 if (line6pcm->pos_out_done >= runtime->buffer_size)
389 line6pcm->pos_out_done -= runtime->buffer_size;
390 }
Markus Grabner705ecec2009-02-27 19:43:04 -0800391
392 clear_bit(index, &line6pcm->active_urb_out);
393
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800394 for (i = LINE6_ISO_PACKETS; i--;)
Markus Grabnere1a164d2010-08-23 01:08:25 +0200395 if (urb->iso_frame_desc[i].status == -EXDEV) {
Markus Grabner705ecec2009-02-27 19:43:04 -0800396 shutdown = 1;
397 break;
398 }
399
Markus Grabner1027f4762010-08-12 01:35:30 +0200400 if (test_and_clear_bit(index, &line6pcm->unlink_urb_out))
Markus Grabner705ecec2009-02-27 19:43:04 -0800401 shutdown = 1;
402
403 spin_unlock_irqrestore(&line6pcm->lock_audio_out, flags);
404
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800405 if (!shutdown) {
Markus Grabner1027f4762010-08-12 01:35:30 +0200406 submit_audio_out_urb(line6pcm);
Markus Grabner705ecec2009-02-27 19:43:04 -0800407
Stefan Hajnoczi6a8ec872012-11-11 13:24:43 +0100408 if (test_bit(LINE6_INDEX_PCM_ALSA_PLAYBACK_STREAM,
409 &line6pcm->flags)) {
Greg Kroah-Hartman027360c2010-09-21 16:58:00 -0700410 line6pcm->bytes_out += length;
411 if (line6pcm->bytes_out >= line6pcm->period_out) {
Markus Grabner1027f4762010-08-12 01:35:30 +0200412 line6pcm->bytes_out %= line6pcm->period_out;
413 snd_pcm_period_elapsed(substream);
414 }
Markus Grabner705ecec2009-02-27 19:43:04 -0800415 }
416 }
417}
418
419/* open playback callback */
420static int snd_line6_playback_open(struct snd_pcm_substream *substream)
421{
422 int err;
423 struct snd_pcm_runtime *runtime = substream->runtime;
424 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
425
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800426 err = snd_pcm_hw_constraint_ratdens(runtime, 0, SNDRV_PCM_HW_PARAM_RATE,
Markus Grabnere1a164d2010-08-23 01:08:25 +0200427 (&line6pcm->
428 properties->snd_line6_rates));
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800429 if (err < 0)
Markus Grabner705ecec2009-02-27 19:43:04 -0800430 return err;
431
432 runtime->hw = line6pcm->properties->snd_line6_playback_hw;
433 return 0;
434}
435
436/* close playback callback */
437static int snd_line6_playback_close(struct snd_pcm_substream *substream)
438{
439 return 0;
440}
441
442/* hw_params playback callback */
Shawn Bohrer45af4972009-11-15 22:17:50 -0600443static int snd_line6_playback_hw_params(struct snd_pcm_substream *substream,
444 struct snd_pcm_hw_params *hw_params)
Markus Grabner705ecec2009-02-27 19:43:04 -0800445{
446 int ret;
447 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
448
449 /* -- Florian Demski [FD] */
450 /* don't ask me why, but this fixes the bug on my machine */
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800451 if (line6pcm == NULL) {
452 if (substream->pcm == NULL)
Markus Grabner705ecec2009-02-27 19:43:04 -0800453 return -ENOMEM;
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800454 if (substream->pcm->private_data == NULL)
Markus Grabner705ecec2009-02-27 19:43:04 -0800455 return -ENOMEM;
456 substream->private_data = substream->pcm->private_data;
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800457 line6pcm = snd_pcm_substream_chip(substream);
Markus Grabner705ecec2009-02-27 19:43:04 -0800458 }
459 /* -- [FD] end */
460
Markus Grabner0ca54882012-01-20 00:09:09 +0100461 ret = line6_pcm_acquire(line6pcm, LINE6_BIT_PCM_ALSA_PLAYBACK_BUFFER);
Stefan Hajnoczi140e28b2011-11-23 08:20:45 +0000462
Markus Grabner0ca54882012-01-20 00:09:09 +0100463 if (ret < 0)
464 return ret;
Stefan Hajnoczi140e28b2011-11-23 08:20:45 +0000465
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800466 ret = snd_pcm_lib_malloc_pages(substream,
467 params_buffer_bytes(hw_params));
Markus Grabner0ca54882012-01-20 00:09:09 +0100468 if (ret < 0) {
469 line6_pcm_release(line6pcm, LINE6_BIT_PCM_ALSA_PLAYBACK_BUFFER);
Markus Grabner705ecec2009-02-27 19:43:04 -0800470 return ret;
Markus Grabner0ca54882012-01-20 00:09:09 +0100471 }
Markus Grabner705ecec2009-02-27 19:43:04 -0800472
473 line6pcm->period_out = params_period_bytes(hw_params);
Markus Grabner705ecec2009-02-27 19:43:04 -0800474 return 0;
475}
476
477/* hw_free playback callback */
478static int snd_line6_playback_hw_free(struct snd_pcm_substream *substream)
479{
Stefan Hajnoczi140e28b2011-11-23 08:20:45 +0000480 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
Jerry Snitselaarf3c52612014-04-24 00:31:48 -0700481
Markus Grabner0ca54882012-01-20 00:09:09 +0100482 line6_pcm_release(line6pcm, LINE6_BIT_PCM_ALSA_PLAYBACK_BUFFER);
Markus Grabner705ecec2009-02-27 19:43:04 -0800483 return snd_pcm_lib_free_pages(substream);
484}
485
486/* trigger playback callback */
Markus Grabner1027f4762010-08-12 01:35:30 +0200487int snd_line6_playback_trigger(struct snd_line6_pcm *line6pcm, int cmd)
Markus Grabner705ecec2009-02-27 19:43:04 -0800488{
Markus Grabner705ecec2009-02-27 19:43:04 -0800489 int err;
Markus Grabner705ecec2009-02-27 19:43:04 -0800490
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800491 switch (cmd) {
Markus Grabner705ecec2009-02-27 19:43:04 -0800492 case SNDRV_PCM_TRIGGER_START:
Markus Grabner1027f4762010-08-12 01:35:30 +0200493 case SNDRV_PCM_TRIGGER_RESUME:
Stefan Hajnoczi6a8ec872012-11-11 13:24:43 +0100494 err = line6_pcm_acquire(line6pcm,
495 LINE6_BIT_PCM_ALSA_PLAYBACK_STREAM);
Markus Grabner705ecec2009-02-27 19:43:04 -0800496
Markus Grabner1027f4762010-08-12 01:35:30 +0200497 if (err < 0)
498 return err;
Markus Grabner705ecec2009-02-27 19:43:04 -0800499
500 break;
501
502 case SNDRV_PCM_TRIGGER_STOP:
Markus Grabner1027f4762010-08-12 01:35:30 +0200503 case SNDRV_PCM_TRIGGER_SUSPEND:
Stefan Hajnoczi6a8ec872012-11-11 13:24:43 +0100504 err = line6_pcm_release(line6pcm,
505 LINE6_BIT_PCM_ALSA_PLAYBACK_STREAM);
Markus Grabner1027f4762010-08-12 01:35:30 +0200506
507 if (err < 0)
508 return err;
Markus Grabner705ecec2009-02-27 19:43:04 -0800509
510 break;
511
512 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
Markus Grabner0ca54882012-01-20 00:09:09 +0100513 set_bit(LINE6_INDEX_PAUSE_PLAYBACK, &line6pcm->flags);
Markus Grabner705ecec2009-02-27 19:43:04 -0800514 break;
515
516 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
Markus Grabner0ca54882012-01-20 00:09:09 +0100517 clear_bit(LINE6_INDEX_PAUSE_PLAYBACK, &line6pcm->flags);
Markus Grabner705ecec2009-02-27 19:43:04 -0800518 break;
519
520 default:
521 return -EINVAL;
522 }
523
524 return 0;
525}
526
527/* playback pointer callback */
528static snd_pcm_uframes_t
529snd_line6_playback_pointer(struct snd_pcm_substream *substream)
530{
531 struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
Jerry Snitselaarf3c52612014-04-24 00:31:48 -0700532
Markus Grabner705ecec2009-02-27 19:43:04 -0800533 return line6pcm->pos_out_done;
534}
535
536/* playback operators */
537struct snd_pcm_ops snd_line6_playback_ops = {
Markus Grabnere1a164d2010-08-23 01:08:25 +0200538 .open = snd_line6_playback_open,
539 .close = snd_line6_playback_close,
540 .ioctl = snd_pcm_lib_ioctl,
541 .hw_params = snd_line6_playback_hw_params,
542 .hw_free = snd_line6_playback_hw_free,
543 .prepare = snd_line6_prepare,
544 .trigger = snd_line6_trigger,
545 .pointer = snd_line6_playback_pointer,
Markus Grabner705ecec2009-02-27 19:43:04 -0800546};
547
Markus Grabner1027f4762010-08-12 01:35:30 +0200548int line6_create_audio_out_urbs(struct snd_line6_pcm *line6pcm)
Markus Grabner705ecec2009-02-27 19:43:04 -0800549{
Chris Rorvick16d603d2015-01-12 12:42:55 -0800550 struct usb_line6 *line6 = line6pcm->line6;
Markus Grabner705ecec2009-02-27 19:43:04 -0800551 int i;
552
553 /* create audio URBs and fill in constant values: */
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800554 for (i = 0; i < LINE6_ISO_BUFFERS; ++i) {
Markus Grabner705ecec2009-02-27 19:43:04 -0800555 struct urb *urb;
556
557 /* URB for audio out: */
Shawn Bohrer45af4972009-11-15 22:17:50 -0600558 urb = line6pcm->urb_audio_out[i] =
559 usb_alloc_urb(LINE6_ISO_PACKETS, GFP_KERNEL);
Markus Grabner705ecec2009-02-27 19:43:04 -0800560
Greg Kroah-Hartman010f3782009-02-27 22:41:12 -0800561 if (urb == NULL) {
Chris Rorvick16d603d2015-01-12 12:42:55 -0800562 dev_err(line6->ifcdev, "Out of memory\n");
Markus Grabner705ecec2009-02-27 19:43:04 -0800563 return -ENOMEM;
564 }
565
Chris Rorvick16d603d2015-01-12 12:42:55 -0800566 urb->dev = line6->usbdev;
Shawn Bohrer45af4972009-11-15 22:17:50 -0600567 urb->pipe =
Chris Rorvick16d603d2015-01-12 12:42:55 -0800568 usb_sndisocpipe(line6->usbdev,
569 line6->properties->ep_audio_w &
Markus Grabnere1a164d2010-08-23 01:08:25 +0200570 USB_ENDPOINT_NUMBER_MASK);
Markus Grabner705ecec2009-02-27 19:43:04 -0800571 urb->transfer_flags = URB_ISO_ASAP;
572 urb->start_frame = -1;
573 urb->number_of_packets = LINE6_ISO_PACKETS;
574 urb->interval = LINE6_ISO_INTERVAL;
575 urb->error_count = 0;
576 urb->complete = audio_out_callback;
577 }
578
579 return 0;
580}