xref: /openbmc/linux/sound/usb/6fire/pcm.c (revision 614b9feb)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Linux driver for TerraTec DMX 6Fire USB
4  *
5  * PCM driver
6  *
7  * Author:	Torsten Schenk <torsten.schenk@zoho.com>
8  * Created:	Jan 01, 2011
9  * Copyright:	(C) Torsten Schenk
10  */
11 
12 #include "pcm.h"
13 #include "chip.h"
14 #include "comm.h"
15 #include "control.h"
16 
17 enum {
18 	OUT_N_CHANNELS = 6, IN_N_CHANNELS = 4
19 };
20 
21 /* keep next two synced with
22  * FW_EP_W_MAX_PACKET_SIZE[] and RATES_MAX_PACKET_SIZE
23  * and CONTROL_RATE_XXX in control.h */
24 static const int rates_in_packet_size[] = { 228, 228, 420, 420, 404, 404 };
25 static const int rates_out_packet_size[] = { 228, 228, 420, 420, 604, 604 };
26 static const int rates[] = { 44100, 48000, 88200, 96000, 176400, 192000 };
27 static const int rates_alsaid[] = {
28 	SNDRV_PCM_RATE_44100, SNDRV_PCM_RATE_48000,
29 	SNDRV_PCM_RATE_88200, SNDRV_PCM_RATE_96000,
30 	SNDRV_PCM_RATE_176400, SNDRV_PCM_RATE_192000 };
31 
32 enum { /* settings for pcm */
33 	OUT_EP = 6, IN_EP = 2, MAX_BUFSIZE = 128 * 1024
34 };
35 
36 enum { /* pcm streaming states */
37 	STREAM_DISABLED, /* no pcm streaming */
38 	STREAM_STARTING, /* pcm streaming requested, waiting to become ready */
39 	STREAM_RUNNING, /* pcm streaming running */
40 	STREAM_STOPPING
41 };
42 
43 static const struct snd_pcm_hardware pcm_hw = {
44 	.info = SNDRV_PCM_INFO_MMAP |
45 		SNDRV_PCM_INFO_INTERLEAVED |
46 		SNDRV_PCM_INFO_BLOCK_TRANSFER |
47 		SNDRV_PCM_INFO_MMAP_VALID |
48 		SNDRV_PCM_INFO_BATCH,
49 
50 	.formats = SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE,
51 
52 	.rates = SNDRV_PCM_RATE_44100 |
53 		SNDRV_PCM_RATE_48000 |
54 		SNDRV_PCM_RATE_88200 |
55 		SNDRV_PCM_RATE_96000 |
56 		SNDRV_PCM_RATE_176400 |
57 		SNDRV_PCM_RATE_192000,
58 
59 	.rate_min = 44100,
60 	.rate_max = 192000,
61 	.channels_min = 1,
62 	.channels_max = 0, /* set in pcm_open, depending on capture/playback */
63 	.buffer_bytes_max = MAX_BUFSIZE,
64 	.period_bytes_min = PCM_N_PACKETS_PER_URB * (PCM_MAX_PACKET_SIZE - 4),
65 	.period_bytes_max = MAX_BUFSIZE,
66 	.periods_min = 2,
67 	.periods_max = 1024
68 };
69 
usb6fire_pcm_set_rate(struct pcm_runtime * rt)70 static int usb6fire_pcm_set_rate(struct pcm_runtime *rt)
71 {
72 	int ret;
73 	struct control_runtime *ctrl_rt = rt->chip->control;
74 
75 	ctrl_rt->usb_streaming = false;
76 	ret = ctrl_rt->update_streaming(ctrl_rt);
77 	if (ret < 0) {
78 		dev_err(&rt->chip->dev->dev,
79 			"error stopping streaming while setting samplerate %d.\n",
80 			rates[rt->rate]);
81 		return ret;
82 	}
83 
84 	ret = ctrl_rt->set_rate(ctrl_rt, rt->rate);
85 	if (ret < 0) {
86 		dev_err(&rt->chip->dev->dev,
87 			"error setting samplerate %d.\n",
88 			rates[rt->rate]);
89 		return ret;
90 	}
91 
92 	ret = ctrl_rt->set_channels(ctrl_rt, OUT_N_CHANNELS, IN_N_CHANNELS,
93 			false, false);
94 	if (ret < 0) {
95 		dev_err(&rt->chip->dev->dev,
96 			"error initializing channels while setting samplerate %d.\n",
97 			rates[rt->rate]);
98 		return ret;
99 	}
100 
101 	ctrl_rt->usb_streaming = true;
102 	ret = ctrl_rt->update_streaming(ctrl_rt);
103 	if (ret < 0) {
104 		dev_err(&rt->chip->dev->dev,
105 			"error starting streaming while setting samplerate %d.\n",
106 			rates[rt->rate]);
107 		return ret;
108 	}
109 
110 	rt->in_n_analog = IN_N_CHANNELS;
111 	rt->out_n_analog = OUT_N_CHANNELS;
112 	rt->in_packet_size = rates_in_packet_size[rt->rate];
113 	rt->out_packet_size = rates_out_packet_size[rt->rate];
114 	return 0;
115 }
116 
usb6fire_pcm_get_substream(struct snd_pcm_substream * alsa_sub)117 static struct pcm_substream *usb6fire_pcm_get_substream(
118 		struct snd_pcm_substream *alsa_sub)
119 {
120 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
121 
122 	if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK)
123 		return &rt->playback;
124 	else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE)
125 		return &rt->capture;
126 	dev_err(&rt->chip->dev->dev, "error getting pcm substream slot.\n");
127 	return NULL;
128 }
129 
130 /* call with stream_mutex locked */
usb6fire_pcm_stream_stop(struct pcm_runtime * rt)131 static void usb6fire_pcm_stream_stop(struct pcm_runtime *rt)
132 {
133 	int i;
134 	struct control_runtime *ctrl_rt = rt->chip->control;
135 
136 	if (rt->stream_state != STREAM_DISABLED) {
137 
138 		rt->stream_state = STREAM_STOPPING;
139 
140 		for (i = 0; i < PCM_N_URBS; i++) {
141 			usb_kill_urb(&rt->in_urbs[i].instance);
142 			usb_kill_urb(&rt->out_urbs[i].instance);
143 		}
144 		ctrl_rt->usb_streaming = false;
145 		ctrl_rt->update_streaming(ctrl_rt);
146 		rt->stream_state = STREAM_DISABLED;
147 	}
148 }
149 
150 /* call with stream_mutex locked */
usb6fire_pcm_stream_start(struct pcm_runtime * rt)151 static int usb6fire_pcm_stream_start(struct pcm_runtime *rt)
152 {
153 	int ret;
154 	int i;
155 	int k;
156 	struct usb_iso_packet_descriptor *packet;
157 
158 	if (rt->stream_state == STREAM_DISABLED) {
159 		/* submit our in urbs */
160 		rt->stream_wait_cond = false;
161 		rt->stream_state = STREAM_STARTING;
162 		for (i = 0; i < PCM_N_URBS; i++) {
163 			for (k = 0; k < PCM_N_PACKETS_PER_URB; k++) {
164 				packet = &rt->in_urbs[i].packets[k];
165 				packet->offset = k * rt->in_packet_size;
166 				packet->length = rt->in_packet_size;
167 				packet->actual_length = 0;
168 				packet->status = 0;
169 			}
170 			ret = usb_submit_urb(&rt->in_urbs[i].instance,
171 					GFP_ATOMIC);
172 			if (ret) {
173 				usb6fire_pcm_stream_stop(rt);
174 				return ret;
175 			}
176 		}
177 
178 		/* wait for first out urb to return (sent in urb handler) */
179 		wait_event_timeout(rt->stream_wait_queue, rt->stream_wait_cond,
180 				HZ);
181 		if (rt->stream_wait_cond)
182 			rt->stream_state = STREAM_RUNNING;
183 		else {
184 			usb6fire_pcm_stream_stop(rt);
185 			return -EIO;
186 		}
187 	}
188 	return 0;
189 }
190 
191 /* call with substream locked */
usb6fire_pcm_capture(struct pcm_substream * sub,struct pcm_urb * urb)192 static void usb6fire_pcm_capture(struct pcm_substream *sub, struct pcm_urb *urb)
193 {
194 	int i;
195 	int frame;
196 	int frame_count;
197 	unsigned int total_length = 0;
198 	struct pcm_runtime *rt = snd_pcm_substream_chip(sub->instance);
199 	struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
200 	u32 *src = NULL;
201 	u32 *dest = (u32 *) (alsa_rt->dma_area + sub->dma_off
202 			* (alsa_rt->frame_bits >> 3));
203 	u32 *dest_end = (u32 *) (alsa_rt->dma_area + alsa_rt->buffer_size
204 			* (alsa_rt->frame_bits >> 3));
205 	int bytes_per_frame = alsa_rt->channels << 2;
206 
207 	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
208 		/* at least 4 header bytes for valid packet.
209 		 * after that: 32 bits per sample for analog channels */
210 		if (urb->packets[i].actual_length > 4)
211 			frame_count = (urb->packets[i].actual_length - 4)
212 					/ (rt->in_n_analog << 2);
213 		else
214 			frame_count = 0;
215 
216 		if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
217 			src = (u32 *) (urb->buffer + total_length);
218 		else if (alsa_rt->format == SNDRV_PCM_FORMAT_S32_LE)
219 			src = (u32 *) (urb->buffer - 1 + total_length);
220 		else
221 			return;
222 		src++; /* skip leading 4 bytes of every packet */
223 		total_length += urb->packets[i].length;
224 		for (frame = 0; frame < frame_count; frame++) {
225 			memcpy(dest, src, bytes_per_frame);
226 			dest += alsa_rt->channels;
227 			src += rt->in_n_analog;
228 			sub->dma_off++;
229 			sub->period_off++;
230 			if (dest == dest_end) {
231 				sub->dma_off = 0;
232 				dest = (u32 *) alsa_rt->dma_area;
233 			}
234 		}
235 	}
236 }
237 
238 /* call with substream locked */
usb6fire_pcm_playback(struct pcm_substream * sub,struct pcm_urb * urb)239 static void usb6fire_pcm_playback(struct pcm_substream *sub,
240 		struct pcm_urb *urb)
241 {
242 	int i;
243 	int frame;
244 	int frame_count;
245 	struct pcm_runtime *rt = snd_pcm_substream_chip(sub->instance);
246 	struct snd_pcm_runtime *alsa_rt = sub->instance->runtime;
247 	u32 *src = (u32 *) (alsa_rt->dma_area + sub->dma_off
248 			* (alsa_rt->frame_bits >> 3));
249 	u32 *src_end = (u32 *) (alsa_rt->dma_area + alsa_rt->buffer_size
250 			* (alsa_rt->frame_bits >> 3));
251 	u32 *dest;
252 	int bytes_per_frame = alsa_rt->channels << 2;
253 
254 	if (alsa_rt->format == SNDRV_PCM_FORMAT_S32_LE)
255 		dest = (u32 *) (urb->buffer - 1);
256 	else if (alsa_rt->format == SNDRV_PCM_FORMAT_S24_LE)
257 		dest = (u32 *) (urb->buffer);
258 	else {
259 		dev_err(&rt->chip->dev->dev, "Unknown sample format.");
260 		return;
261 	}
262 
263 	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
264 		/* at least 4 header bytes for valid packet.
265 		 * after that: 32 bits per sample for analog channels */
266 		if (urb->packets[i].length > 4)
267 			frame_count = (urb->packets[i].length - 4)
268 					/ (rt->out_n_analog << 2);
269 		else
270 			frame_count = 0;
271 		dest++; /* skip leading 4 bytes of every frame */
272 		for (frame = 0; frame < frame_count; frame++) {
273 			memcpy(dest, src, bytes_per_frame);
274 			src += alsa_rt->channels;
275 			dest += rt->out_n_analog;
276 			sub->dma_off++;
277 			sub->period_off++;
278 			if (src == src_end) {
279 				src = (u32 *) alsa_rt->dma_area;
280 				sub->dma_off = 0;
281 			}
282 		}
283 	}
284 }
285 
usb6fire_pcm_in_urb_handler(struct urb * usb_urb)286 static void usb6fire_pcm_in_urb_handler(struct urb *usb_urb)
287 {
288 	struct pcm_urb *in_urb = usb_urb->context;
289 	struct pcm_urb *out_urb = in_urb->peer;
290 	struct pcm_runtime *rt = in_urb->chip->pcm;
291 	struct pcm_substream *sub;
292 	unsigned long flags;
293 	int total_length = 0;
294 	int frame_count;
295 	int frame;
296 	int channel;
297 	int i;
298 	u8 *dest;
299 
300 	if (usb_urb->status || rt->panic || rt->stream_state == STREAM_STOPPING)
301 		return;
302 	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++)
303 		if (in_urb->packets[i].status) {
304 			rt->panic = true;
305 			return;
306 		}
307 
308 	if (rt->stream_state == STREAM_DISABLED) {
309 		dev_err(&rt->chip->dev->dev,
310 			"internal error: stream disabled in in-urb handler.\n");
311 		return;
312 	}
313 
314 	/* receive our capture data */
315 	sub = &rt->capture;
316 	spin_lock_irqsave(&sub->lock, flags);
317 	if (sub->active) {
318 		usb6fire_pcm_capture(sub, in_urb);
319 		if (sub->period_off >= sub->instance->runtime->period_size) {
320 			sub->period_off %= sub->instance->runtime->period_size;
321 			spin_unlock_irqrestore(&sub->lock, flags);
322 			snd_pcm_period_elapsed(sub->instance);
323 		} else
324 			spin_unlock_irqrestore(&sub->lock, flags);
325 	} else
326 		spin_unlock_irqrestore(&sub->lock, flags);
327 
328 	/* setup out urb structure */
329 	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++) {
330 		out_urb->packets[i].offset = total_length;
331 		out_urb->packets[i].length = (in_urb->packets[i].actual_length
332 				- 4) / (rt->in_n_analog << 2)
333 				* (rt->out_n_analog << 2) + 4;
334 		out_urb->packets[i].status = 0;
335 		total_length += out_urb->packets[i].length;
336 	}
337 	memset(out_urb->buffer, 0, total_length);
338 
339 	/* now send our playback data (if a free out urb was found) */
340 	sub = &rt->playback;
341 	spin_lock_irqsave(&sub->lock, flags);
342 	if (sub->active) {
343 		usb6fire_pcm_playback(sub, out_urb);
344 		if (sub->period_off >= sub->instance->runtime->period_size) {
345 			sub->period_off %= sub->instance->runtime->period_size;
346 			spin_unlock_irqrestore(&sub->lock, flags);
347 			snd_pcm_period_elapsed(sub->instance);
348 		} else
349 			spin_unlock_irqrestore(&sub->lock, flags);
350 	} else
351 		spin_unlock_irqrestore(&sub->lock, flags);
352 
353 	/* setup the 4th byte of each sample (0x40 for analog channels) */
354 	dest = out_urb->buffer;
355 	for (i = 0; i < PCM_N_PACKETS_PER_URB; i++)
356 		if (out_urb->packets[i].length >= 4) {
357 			frame_count = (out_urb->packets[i].length - 4)
358 					/ (rt->out_n_analog << 2);
359 			*(dest++) = 0xaa;
360 			*(dest++) = 0xaa;
361 			*(dest++) = frame_count;
362 			*(dest++) = 0x00;
363 			for (frame = 0; frame < frame_count; frame++)
364 				for (channel = 0;
365 						channel < rt->out_n_analog;
366 						channel++) {
367 					dest += 3; /* skip sample data */
368 					*(dest++) = 0x40;
369 				}
370 		}
371 	usb_submit_urb(&out_urb->instance, GFP_ATOMIC);
372 	usb_submit_urb(&in_urb->instance, GFP_ATOMIC);
373 }
374 
usb6fire_pcm_out_urb_handler(struct urb * usb_urb)375 static void usb6fire_pcm_out_urb_handler(struct urb *usb_urb)
376 {
377 	struct pcm_urb *urb = usb_urb->context;
378 	struct pcm_runtime *rt = urb->chip->pcm;
379 
380 	if (rt->stream_state == STREAM_STARTING) {
381 		rt->stream_wait_cond = true;
382 		wake_up(&rt->stream_wait_queue);
383 	}
384 }
385 
usb6fire_pcm_open(struct snd_pcm_substream * alsa_sub)386 static int usb6fire_pcm_open(struct snd_pcm_substream *alsa_sub)
387 {
388 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
389 	struct pcm_substream *sub = NULL;
390 	struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
391 
392 	if (rt->panic)
393 		return -EPIPE;
394 
395 	mutex_lock(&rt->stream_mutex);
396 	alsa_rt->hw = pcm_hw;
397 
398 	if (alsa_sub->stream == SNDRV_PCM_STREAM_PLAYBACK) {
399 		if (rt->rate < ARRAY_SIZE(rates))
400 			alsa_rt->hw.rates = rates_alsaid[rt->rate];
401 		alsa_rt->hw.channels_max = OUT_N_CHANNELS;
402 		sub = &rt->playback;
403 	} else if (alsa_sub->stream == SNDRV_PCM_STREAM_CAPTURE) {
404 		if (rt->rate < ARRAY_SIZE(rates))
405 			alsa_rt->hw.rates = rates_alsaid[rt->rate];
406 		alsa_rt->hw.channels_max = IN_N_CHANNELS;
407 		sub = &rt->capture;
408 	}
409 
410 	if (!sub) {
411 		mutex_unlock(&rt->stream_mutex);
412 		dev_err(&rt->chip->dev->dev, "invalid stream type.\n");
413 		return -EINVAL;
414 	}
415 
416 	sub->instance = alsa_sub;
417 	sub->active = false;
418 	mutex_unlock(&rt->stream_mutex);
419 	return 0;
420 }
421 
usb6fire_pcm_close(struct snd_pcm_substream * alsa_sub)422 static int usb6fire_pcm_close(struct snd_pcm_substream *alsa_sub)
423 {
424 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
425 	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
426 	unsigned long flags;
427 
428 	if (rt->panic)
429 		return 0;
430 
431 	mutex_lock(&rt->stream_mutex);
432 	if (sub) {
433 		/* deactivate substream */
434 		spin_lock_irqsave(&sub->lock, flags);
435 		sub->instance = NULL;
436 		sub->active = false;
437 		spin_unlock_irqrestore(&sub->lock, flags);
438 
439 		/* all substreams closed? if so, stop streaming */
440 		if (!rt->playback.instance && !rt->capture.instance) {
441 			usb6fire_pcm_stream_stop(rt);
442 			rt->rate = ARRAY_SIZE(rates);
443 		}
444 	}
445 	mutex_unlock(&rt->stream_mutex);
446 	return 0;
447 }
448 
usb6fire_pcm_prepare(struct snd_pcm_substream * alsa_sub)449 static int usb6fire_pcm_prepare(struct snd_pcm_substream *alsa_sub)
450 {
451 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
452 	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
453 	struct snd_pcm_runtime *alsa_rt = alsa_sub->runtime;
454 	int ret;
455 
456 	if (rt->panic)
457 		return -EPIPE;
458 	if (!sub)
459 		return -ENODEV;
460 
461 	mutex_lock(&rt->stream_mutex);
462 	sub->dma_off = 0;
463 	sub->period_off = 0;
464 
465 	if (rt->stream_state == STREAM_DISABLED) {
466 		for (rt->rate = 0; rt->rate < ARRAY_SIZE(rates); rt->rate++)
467 			if (alsa_rt->rate == rates[rt->rate])
468 				break;
469 		if (rt->rate == ARRAY_SIZE(rates)) {
470 			mutex_unlock(&rt->stream_mutex);
471 			dev_err(&rt->chip->dev->dev,
472 				"invalid rate %d in prepare.\n",
473 				alsa_rt->rate);
474 			return -EINVAL;
475 		}
476 
477 		ret = usb6fire_pcm_set_rate(rt);
478 		if (ret) {
479 			mutex_unlock(&rt->stream_mutex);
480 			return ret;
481 		}
482 		ret = usb6fire_pcm_stream_start(rt);
483 		if (ret) {
484 			mutex_unlock(&rt->stream_mutex);
485 			dev_err(&rt->chip->dev->dev,
486 				"could not start pcm stream.\n");
487 			return ret;
488 		}
489 	}
490 	mutex_unlock(&rt->stream_mutex);
491 	return 0;
492 }
493 
usb6fire_pcm_trigger(struct snd_pcm_substream * alsa_sub,int cmd)494 static int usb6fire_pcm_trigger(struct snd_pcm_substream *alsa_sub, int cmd)
495 {
496 	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
497 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
498 	unsigned long flags;
499 
500 	if (rt->panic)
501 		return -EPIPE;
502 	if (!sub)
503 		return -ENODEV;
504 
505 	switch (cmd) {
506 	case SNDRV_PCM_TRIGGER_START:
507 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
508 		spin_lock_irqsave(&sub->lock, flags);
509 		sub->active = true;
510 		spin_unlock_irqrestore(&sub->lock, flags);
511 		return 0;
512 
513 	case SNDRV_PCM_TRIGGER_STOP:
514 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
515 		spin_lock_irqsave(&sub->lock, flags);
516 		sub->active = false;
517 		spin_unlock_irqrestore(&sub->lock, flags);
518 		return 0;
519 
520 	default:
521 		return -EINVAL;
522 	}
523 }
524 
usb6fire_pcm_pointer(struct snd_pcm_substream * alsa_sub)525 static snd_pcm_uframes_t usb6fire_pcm_pointer(
526 		struct snd_pcm_substream *alsa_sub)
527 {
528 	struct pcm_substream *sub = usb6fire_pcm_get_substream(alsa_sub);
529 	struct pcm_runtime *rt = snd_pcm_substream_chip(alsa_sub);
530 	unsigned long flags;
531 	snd_pcm_uframes_t ret;
532 
533 	if (rt->panic || !sub)
534 		return SNDRV_PCM_POS_XRUN;
535 
536 	spin_lock_irqsave(&sub->lock, flags);
537 	ret = sub->dma_off;
538 	spin_unlock_irqrestore(&sub->lock, flags);
539 	return ret;
540 }
541 
542 static const struct snd_pcm_ops pcm_ops = {
543 	.open = usb6fire_pcm_open,
544 	.close = usb6fire_pcm_close,
545 	.prepare = usb6fire_pcm_prepare,
546 	.trigger = usb6fire_pcm_trigger,
547 	.pointer = usb6fire_pcm_pointer,
548 };
549 
usb6fire_pcm_init_urb(struct pcm_urb * urb,struct sfire_chip * chip,bool in,int ep,void (* handler)(struct urb *))550 static void usb6fire_pcm_init_urb(struct pcm_urb *urb,
551 				  struct sfire_chip *chip, bool in, int ep,
552 				  void (*handler)(struct urb *))
553 {
554 	urb->chip = chip;
555 	usb_init_urb(&urb->instance);
556 	urb->instance.transfer_buffer = urb->buffer;
557 	urb->instance.transfer_buffer_length =
558 			PCM_N_PACKETS_PER_URB * PCM_MAX_PACKET_SIZE;
559 	urb->instance.dev = chip->dev;
560 	urb->instance.pipe = in ? usb_rcvisocpipe(chip->dev, ep)
561 			: usb_sndisocpipe(chip->dev, ep);
562 	urb->instance.interval = 1;
563 	urb->instance.complete = handler;
564 	urb->instance.context = urb;
565 	urb->instance.number_of_packets = PCM_N_PACKETS_PER_URB;
566 }
567 
usb6fire_pcm_buffers_init(struct pcm_runtime * rt)568 static int usb6fire_pcm_buffers_init(struct pcm_runtime *rt)
569 {
570 	int i;
571 
572 	for (i = 0; i < PCM_N_URBS; i++) {
573 		rt->out_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE,
574 						 PCM_N_PACKETS_PER_URB,
575 						 GFP_KERNEL);
576 		if (!rt->out_urbs[i].buffer)
577 			return -ENOMEM;
578 		rt->in_urbs[i].buffer = kcalloc(PCM_MAX_PACKET_SIZE,
579 						PCM_N_PACKETS_PER_URB,
580 						GFP_KERNEL);
581 		if (!rt->in_urbs[i].buffer)
582 			return -ENOMEM;
583 	}
584 	return 0;
585 }
586 
usb6fire_pcm_buffers_destroy(struct pcm_runtime * rt)587 static void usb6fire_pcm_buffers_destroy(struct pcm_runtime *rt)
588 {
589 	int i;
590 
591 	for (i = 0; i < PCM_N_URBS; i++) {
592 		kfree(rt->out_urbs[i].buffer);
593 		kfree(rt->in_urbs[i].buffer);
594 	}
595 }
596 
usb6fire_pcm_init(struct sfire_chip * chip)597 int usb6fire_pcm_init(struct sfire_chip *chip)
598 {
599 	int i;
600 	int ret;
601 	struct snd_pcm *pcm;
602 	struct pcm_runtime *rt =
603 			kzalloc(sizeof(struct pcm_runtime), GFP_KERNEL);
604 
605 	if (!rt)
606 		return -ENOMEM;
607 
608 	ret = usb6fire_pcm_buffers_init(rt);
609 	if (ret) {
610 		usb6fire_pcm_buffers_destroy(rt);
611 		kfree(rt);
612 		return ret;
613 	}
614 
615 	rt->chip = chip;
616 	rt->stream_state = STREAM_DISABLED;
617 	rt->rate = ARRAY_SIZE(rates);
618 	init_waitqueue_head(&rt->stream_wait_queue);
619 	mutex_init(&rt->stream_mutex);
620 
621 	spin_lock_init(&rt->playback.lock);
622 	spin_lock_init(&rt->capture.lock);
623 
624 	for (i = 0; i < PCM_N_URBS; i++) {
625 		usb6fire_pcm_init_urb(&rt->in_urbs[i], chip, true, IN_EP,
626 				usb6fire_pcm_in_urb_handler);
627 		usb6fire_pcm_init_urb(&rt->out_urbs[i], chip, false, OUT_EP,
628 				usb6fire_pcm_out_urb_handler);
629 
630 		rt->in_urbs[i].peer = &rt->out_urbs[i];
631 		rt->out_urbs[i].peer = &rt->in_urbs[i];
632 	}
633 
634 	ret = snd_pcm_new(chip->card, "DMX6FireUSB", 0, 1, 1, &pcm);
635 	if (ret < 0) {
636 		usb6fire_pcm_buffers_destroy(rt);
637 		kfree(rt);
638 		dev_err(&chip->dev->dev, "cannot create pcm instance.\n");
639 		return ret;
640 	}
641 
642 	pcm->private_data = rt;
643 	strcpy(pcm->name, "DMX 6Fire USB");
644 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &pcm_ops);
645 	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &pcm_ops);
646 	snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
647 
648 	rt->instance = pcm;
649 
650 	chip->pcm = rt;
651 	return 0;
652 }
653 
usb6fire_pcm_abort(struct sfire_chip * chip)654 void usb6fire_pcm_abort(struct sfire_chip *chip)
655 {
656 	struct pcm_runtime *rt = chip->pcm;
657 	int i;
658 
659 	if (rt) {
660 		rt->panic = true;
661 
662 		if (rt->playback.instance)
663 			snd_pcm_stop_xrun(rt->playback.instance);
664 
665 		if (rt->capture.instance)
666 			snd_pcm_stop_xrun(rt->capture.instance);
667 
668 		for (i = 0; i < PCM_N_URBS; i++) {
669 			usb_poison_urb(&rt->in_urbs[i].instance);
670 			usb_poison_urb(&rt->out_urbs[i].instance);
671 		}
672 
673 	}
674 }
675 
usb6fire_pcm_destroy(struct sfire_chip * chip)676 void usb6fire_pcm_destroy(struct sfire_chip *chip)
677 {
678 	struct pcm_runtime *rt = chip->pcm;
679 
680 	usb6fire_pcm_buffers_destroy(rt);
681 	kfree(rt);
682 	chip->pcm = NULL;
683 }
684