1/*
2 * Line6 Linux USB driver - 0.9.1beta
3 *
4 * Copyright (C) 2004-2010 Markus Grabner (grabner@icg.tugraz.at)
5 *
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
12#include <linux/slab.h>
13#include <sound/core.h>
14#include <sound/control.h>
15#include <sound/pcm.h>
16#include <sound/pcm_params.h>
17
18#include "audio.h"
19#include "capture.h"
20#include "driver.h"
21#include "playback.h"
22#include "pod.h"
23
24#ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE
25
26static struct snd_line6_pcm *dev2pcm(struct device *dev)
27{
28	struct usb_interface *interface = to_usb_interface(dev);
29	struct usb_line6 *line6 = usb_get_intfdata(interface);
30	struct snd_line6_pcm *line6pcm = line6->line6pcm;
31	return line6pcm;
32}
33
34/*
35	"read" request on "impulse_volume" special file.
36*/
37static ssize_t pcm_get_impulse_volume(struct device *dev,
38				      struct device_attribute *attr, char *buf)
39{
40	return sprintf(buf, "%d\n", dev2pcm(dev)->impulse_volume);
41}
42
43/*
44	"write" request on "impulse_volume" special file.
45*/
46static ssize_t pcm_set_impulse_volume(struct device *dev,
47				      struct device_attribute *attr,
48				      const char *buf, size_t count)
49{
50	struct snd_line6_pcm *line6pcm = dev2pcm(dev);
51	int value = simple_strtoul(buf, NULL, 10);
52	line6pcm->impulse_volume = value;
53
54	if (value > 0)
55		line6_pcm_acquire(line6pcm, LINE6_BITS_PCM_IMPULSE);
56	else
57		line6_pcm_release(line6pcm, LINE6_BITS_PCM_IMPULSE);
58
59	return count;
60}
61
62/*
63	"read" request on "impulse_period" special file.
64*/
65static ssize_t pcm_get_impulse_period(struct device *dev,
66				      struct device_attribute *attr, char *buf)
67{
68	return sprintf(buf, "%d\n", dev2pcm(dev)->impulse_period);
69}
70
71/*
72	"write" request on "impulse_period" special file.
73*/
74static ssize_t pcm_set_impulse_period(struct device *dev,
75				      struct device_attribute *attr,
76				      const char *buf, size_t count)
77{
78	dev2pcm(dev)->impulse_period = simple_strtoul(buf, NULL, 10);
79	return count;
80}
81
82static DEVICE_ATTR(impulse_volume, S_IWUSR | S_IRUGO, pcm_get_impulse_volume,
83		   pcm_set_impulse_volume);
84static DEVICE_ATTR(impulse_period, S_IWUSR | S_IRUGO, pcm_get_impulse_period,
85		   pcm_set_impulse_period);
86
87#endif
88
89static bool test_flags(unsigned long flags0, unsigned long flags1,
90		       unsigned long mask)
91{
92	return ((flags0 & mask) == 0) && ((flags1 & mask) != 0);
93}
94
95int line6_pcm_acquire(struct snd_line6_pcm *line6pcm, int channels)
96{
97	unsigned long flags_old =
98	    __sync_fetch_and_or(&line6pcm->flags, channels);
99	unsigned long flags_new = flags_old | channels;
100	unsigned long flags_final = flags_old;
101	int err = 0;
102
103	line6pcm->prev_fbuf = NULL;
104
105	if (test_flags(flags_old, flags_new, LINE6_BITS_CAPTURE_BUFFER)) {
106		/* We may be invoked multiple times in a row so allocate once only */
107		if (!line6pcm->buffer_in) {
108			line6pcm->buffer_in =
109				kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS *
110					line6pcm->max_packet_size, GFP_KERNEL);
111
112			if (!line6pcm->buffer_in) {
113				dev_err(line6pcm->line6->ifcdev,
114					"cannot malloc capture buffer\n");
115				err = -ENOMEM;
116				goto pcm_acquire_error;
117			}
118
119			flags_final |= channels & LINE6_BITS_CAPTURE_BUFFER;
120		}
121	}
122
123	if (test_flags(flags_old, flags_new, LINE6_BITS_CAPTURE_STREAM)) {
124		/*
125		   Waiting for completion of active URBs in the stop handler is
126		   a bug, we therefore report an error if capturing is restarted
127		   too soon.
128		 */
129		if (line6pcm->active_urb_in | line6pcm->unlink_urb_in) {
130			dev_err(line6pcm->line6->ifcdev, "Device not yet ready\n");
131			return -EBUSY;
132		}
133
134		line6pcm->count_in = 0;
135		line6pcm->prev_fsize = 0;
136		err = line6_submit_audio_in_all_urbs(line6pcm);
137
138		if (err < 0)
139			goto pcm_acquire_error;
140
141		flags_final |= channels & LINE6_BITS_CAPTURE_STREAM;
142	}
143
144	if (test_flags(flags_old, flags_new, LINE6_BITS_PLAYBACK_BUFFER)) {
145		/* We may be invoked multiple times in a row so allocate once only */
146		if (!line6pcm->buffer_out) {
147			line6pcm->buffer_out =
148				kmalloc(LINE6_ISO_BUFFERS * LINE6_ISO_PACKETS *
149					line6pcm->max_packet_size, GFP_KERNEL);
150
151			if (!line6pcm->buffer_out) {
152				dev_err(line6pcm->line6->ifcdev,
153					"cannot malloc playback buffer\n");
154				err = -ENOMEM;
155				goto pcm_acquire_error;
156			}
157
158			flags_final |= channels & LINE6_BITS_PLAYBACK_BUFFER;
159		}
160	}
161
162	if (test_flags(flags_old, flags_new, LINE6_BITS_PLAYBACK_STREAM)) {
163		/*
164		  See comment above regarding PCM restart.
165		*/
166		if (line6pcm->active_urb_out | line6pcm->unlink_urb_out) {
167			dev_err(line6pcm->line6->ifcdev, "Device not yet ready\n");
168			return -EBUSY;
169		}
170
171		line6pcm->count_out = 0;
172		err = line6_submit_audio_out_all_urbs(line6pcm);
173
174		if (err < 0)
175			goto pcm_acquire_error;
176
177		flags_final |= channels & LINE6_BITS_PLAYBACK_STREAM;
178	}
179
180	return 0;
181
182pcm_acquire_error:
183	/*
184	   If not all requested resources/streams could be obtained, release
185	   those which were successfully obtained (if any).
186	*/
187	line6_pcm_release(line6pcm, flags_final & channels);
188	return err;
189}
190
191int line6_pcm_release(struct snd_line6_pcm *line6pcm, int channels)
192{
193	unsigned long flags_old =
194	    __sync_fetch_and_and(&line6pcm->flags, ~channels);
195	unsigned long flags_new = flags_old & ~channels;
196
197	if (test_flags(flags_new, flags_old, LINE6_BITS_CAPTURE_STREAM))
198		line6_unlink_audio_in_urbs(line6pcm);
199
200	if (test_flags(flags_new, flags_old, LINE6_BITS_CAPTURE_BUFFER)) {
201		line6_wait_clear_audio_in_urbs(line6pcm);
202		line6_free_capture_buffer(line6pcm);
203	}
204
205	if (test_flags(flags_new, flags_old, LINE6_BITS_PLAYBACK_STREAM))
206		line6_unlink_audio_out_urbs(line6pcm);
207
208	if (test_flags(flags_new, flags_old, LINE6_BITS_PLAYBACK_BUFFER)) {
209		line6_wait_clear_audio_out_urbs(line6pcm);
210		line6_free_playback_buffer(line6pcm);
211	}
212
213	return 0;
214}
215
216/* trigger callback */
217int snd_line6_trigger(struct snd_pcm_substream *substream, int cmd)
218{
219	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
220	struct snd_pcm_substream *s;
221	int err;
222	unsigned long flags;
223
224	spin_lock_irqsave(&line6pcm->lock_trigger, flags);
225	clear_bit(LINE6_INDEX_PREPARED, &line6pcm->flags);
226
227	snd_pcm_group_for_each_entry(s, substream) {
228		switch (s->stream) {
229		case SNDRV_PCM_STREAM_PLAYBACK:
230			err = snd_line6_playback_trigger(line6pcm, cmd);
231
232			if (err < 0) {
233				spin_unlock_irqrestore(&line6pcm->lock_trigger,
234						       flags);
235				return err;
236			}
237
238			break;
239
240		case SNDRV_PCM_STREAM_CAPTURE:
241			err = snd_line6_capture_trigger(line6pcm, cmd);
242
243			if (err < 0) {
244				spin_unlock_irqrestore(&line6pcm->lock_trigger,
245						       flags);
246				return err;
247			}
248
249			break;
250
251		default:
252			dev_err(line6pcm->line6->ifcdev,
253				"Unknown stream direction %d\n", s->stream);
254		}
255	}
256
257	spin_unlock_irqrestore(&line6pcm->lock_trigger, flags);
258	return 0;
259}
260
261/* control info callback */
262static int snd_line6_control_playback_info(struct snd_kcontrol *kcontrol,
263					   struct snd_ctl_elem_info *uinfo)
264{
265	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
266	uinfo->count = 2;
267	uinfo->value.integer.min = 0;
268	uinfo->value.integer.max = 256;
269	return 0;
270}
271
272/* control get callback */
273static int snd_line6_control_playback_get(struct snd_kcontrol *kcontrol,
274					  struct snd_ctl_elem_value *ucontrol)
275{
276	int i;
277	struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
278
279	for (i = 2; i--;)
280		ucontrol->value.integer.value[i] = line6pcm->volume_playback[i];
281
282	return 0;
283}
284
285/* control put callback */
286static int snd_line6_control_playback_put(struct snd_kcontrol *kcontrol,
287					  struct snd_ctl_elem_value *ucontrol)
288{
289	int i, changed = 0;
290	struct snd_line6_pcm *line6pcm = snd_kcontrol_chip(kcontrol);
291
292	for (i = 2; i--;)
293		if (line6pcm->volume_playback[i] !=
294		    ucontrol->value.integer.value[i]) {
295			line6pcm->volume_playback[i] =
296			    ucontrol->value.integer.value[i];
297			changed = 1;
298		}
299
300	return changed;
301}
302
303/* control definition */
304static struct snd_kcontrol_new line6_control_playback = {
305	.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
306	.name = "PCM Playback Volume",
307	.index = 0,
308	.access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
309	.info = snd_line6_control_playback_info,
310	.get = snd_line6_control_playback_get,
311	.put = snd_line6_control_playback_put
312};
313
314/*
315	Cleanup the PCM device.
316*/
317static void line6_cleanup_pcm(struct snd_pcm *pcm)
318{
319	int i;
320	struct snd_line6_pcm *line6pcm = snd_pcm_chip(pcm);
321
322#ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE
323	device_remove_file(line6pcm->line6->ifcdev, &dev_attr_impulse_volume);
324	device_remove_file(line6pcm->line6->ifcdev, &dev_attr_impulse_period);
325#endif
326
327	for (i = LINE6_ISO_BUFFERS; i--;) {
328		if (line6pcm->urb_audio_out[i]) {
329			usb_kill_urb(line6pcm->urb_audio_out[i]);
330			usb_free_urb(line6pcm->urb_audio_out[i]);
331		}
332		if (line6pcm->urb_audio_in[i]) {
333			usb_kill_urb(line6pcm->urb_audio_in[i]);
334			usb_free_urb(line6pcm->urb_audio_in[i]);
335		}
336	}
337}
338
339/* create a PCM device */
340static int snd_line6_new_pcm(struct snd_line6_pcm *line6pcm)
341{
342	struct snd_pcm *pcm;
343	int err;
344
345	err = snd_pcm_new(line6pcm->line6->card,
346			  (char *)line6pcm->line6->properties->name,
347			  0, 1, 1, &pcm);
348	if (err < 0)
349		return err;
350
351	pcm->private_data = line6pcm;
352	pcm->private_free = line6_cleanup_pcm;
353	line6pcm->pcm = pcm;
354	strcpy(pcm->name, line6pcm->line6->properties->name);
355
356	/* set operators */
357	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
358			&snd_line6_playback_ops);
359	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_line6_capture_ops);
360
361	/* pre-allocation of buffers */
362	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
363					      snd_dma_continuous_data
364					      (GFP_KERNEL), 64 * 1024,
365					      128 * 1024);
366
367	return 0;
368}
369
370/* PCM device destructor */
371static int snd_line6_pcm_free(struct snd_device *device)
372{
373	return 0;
374}
375
376/*
377	Stop substream if still running.
378*/
379static void pcm_disconnect_substream(struct snd_pcm_substream *substream)
380{
381	if (substream->runtime && snd_pcm_running(substream))
382		snd_pcm_stop(substream, SNDRV_PCM_STATE_DISCONNECTED);
383}
384
385/*
386	Stop PCM stream.
387*/
388void line6_pcm_disconnect(struct snd_line6_pcm *line6pcm)
389{
390	pcm_disconnect_substream(get_substream
391				 (line6pcm, SNDRV_PCM_STREAM_CAPTURE));
392	pcm_disconnect_substream(get_substream
393				 (line6pcm, SNDRV_PCM_STREAM_PLAYBACK));
394	line6_unlink_wait_clear_audio_out_urbs(line6pcm);
395	line6_unlink_wait_clear_audio_in_urbs(line6pcm);
396}
397
398/*
399	Create and register the PCM device and mixer entries.
400	Create URBs for playback and capture.
401*/
402int line6_init_pcm(struct usb_line6 *line6,
403		   struct line6_pcm_properties *properties)
404{
405	static struct snd_device_ops pcm_ops = {
406		.dev_free = snd_line6_pcm_free,
407	};
408
409	int err;
410	int ep_read = 0, ep_write = 0;
411	struct snd_line6_pcm *line6pcm;
412
413	if (!(line6->properties->capabilities & LINE6_BIT_PCM))
414		return 0;	/* skip PCM initialization and report success */
415
416	/* initialize PCM subsystem based on product id: */
417	switch (line6->product) {
418	case LINE6_DEVID_BASSPODXT:
419	case LINE6_DEVID_BASSPODXTLIVE:
420	case LINE6_DEVID_BASSPODXTPRO:
421	case LINE6_DEVID_PODXT:
422	case LINE6_DEVID_PODXTLIVE:
423	case LINE6_DEVID_PODXTPRO:
424	case LINE6_DEVID_PODHD300:
425		ep_read = 0x82;
426		ep_write = 0x01;
427		break;
428
429	case LINE6_DEVID_PODHD500:
430	case LINE6_DEVID_PODX3:
431	case LINE6_DEVID_PODX3LIVE:
432		ep_read = 0x86;
433		ep_write = 0x02;
434		break;
435
436	case LINE6_DEVID_POCKETPOD:
437		ep_read = 0x82;
438		ep_write = 0x02;
439		break;
440
441	case LINE6_DEVID_GUITARPORT:
442	case LINE6_DEVID_PODSTUDIO_GX:
443	case LINE6_DEVID_PODSTUDIO_UX1:
444	case LINE6_DEVID_PODSTUDIO_UX2:
445	case LINE6_DEVID_TONEPORT_GX:
446	case LINE6_DEVID_TONEPORT_UX1:
447	case LINE6_DEVID_TONEPORT_UX2:
448		ep_read = 0x82;
449		ep_write = 0x01;
450		break;
451
452		/* this is for interface_number == 1:
453		   case LINE6_DEVID_TONEPORT_UX2:
454		   case LINE6_DEVID_PODSTUDIO_UX2:
455		   ep_read  = 0x87;
456		   ep_write = 0x00;
457		   break;
458		 */
459
460	default:
461		MISSING_CASE;
462	}
463
464	line6pcm = kzalloc(sizeof(struct snd_line6_pcm), GFP_KERNEL);
465
466	if (line6pcm == NULL)
467		return -ENOMEM;
468
469	line6pcm->volume_playback[0] = line6pcm->volume_playback[1] = 255;
470	line6pcm->volume_monitor = 255;
471	line6pcm->line6 = line6;
472	line6pcm->ep_audio_read = ep_read;
473	line6pcm->ep_audio_write = ep_write;
474
475	/* Read and write buffers are sized identically, so choose minimum */
476	line6pcm->max_packet_size = min(
477			usb_maxpacket(line6->usbdev,
478				usb_rcvisocpipe(line6->usbdev, ep_read), 0),
479			usb_maxpacket(line6->usbdev,
480				usb_sndisocpipe(line6->usbdev, ep_write), 1));
481
482	line6pcm->properties = properties;
483	line6->line6pcm = line6pcm;
484
485	/* PCM device: */
486	err = snd_device_new(line6->card, SNDRV_DEV_PCM, line6, &pcm_ops);
487	if (err < 0)
488		return err;
489
490	snd_card_set_dev(line6->card, line6->ifcdev);
491
492	err = snd_line6_new_pcm(line6pcm);
493	if (err < 0)
494		return err;
495
496	spin_lock_init(&line6pcm->lock_audio_out);
497	spin_lock_init(&line6pcm->lock_audio_in);
498	spin_lock_init(&line6pcm->lock_trigger);
499
500	err = line6_create_audio_out_urbs(line6pcm);
501	if (err < 0)
502		return err;
503
504	err = line6_create_audio_in_urbs(line6pcm);
505	if (err < 0)
506		return err;
507
508	/* mixer: */
509	err =
510	    snd_ctl_add(line6->card,
511			snd_ctl_new1(&line6_control_playback, line6pcm));
512	if (err < 0)
513		return err;
514
515#ifdef CONFIG_LINE6_USB_IMPULSE_RESPONSE
516	/* impulse response test: */
517	err = device_create_file(line6->ifcdev, &dev_attr_impulse_volume);
518	if (err < 0)
519		return err;
520
521	err = device_create_file(line6->ifcdev, &dev_attr_impulse_period);
522	if (err < 0)
523		return err;
524
525	line6pcm->impulse_period = LINE6_IMPULSE_DEFAULT_PERIOD;
526#endif
527
528	return 0;
529}
530
531/* prepare pcm callback */
532int snd_line6_prepare(struct snd_pcm_substream *substream)
533{
534	struct snd_line6_pcm *line6pcm = snd_pcm_substream_chip(substream);
535
536	switch (substream->stream) {
537	case SNDRV_PCM_STREAM_PLAYBACK:
538		if ((line6pcm->flags & LINE6_BITS_PLAYBACK_STREAM) == 0)
539			line6_unlink_wait_clear_audio_out_urbs(line6pcm);
540
541		break;
542
543	case SNDRV_PCM_STREAM_CAPTURE:
544		if ((line6pcm->flags & LINE6_BITS_CAPTURE_STREAM) == 0)
545			line6_unlink_wait_clear_audio_in_urbs(line6pcm);
546
547		break;
548
549	default:
550		MISSING_CASE;
551	}
552
553	if (!test_and_set_bit(LINE6_INDEX_PREPARED, &line6pcm->flags)) {
554		line6pcm->count_out = 0;
555		line6pcm->pos_out = 0;
556		line6pcm->pos_out_done = 0;
557		line6pcm->bytes_out = 0;
558		line6pcm->count_in = 0;
559		line6pcm->pos_in_done = 0;
560		line6pcm->bytes_in = 0;
561	}
562
563	return 0;
564}
565