[net-next-2.6.git] / sound / usb / card.c

/*
 *   (Tentative) USB Audio Driver for ALSA
 *
 *   Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
 *
 *   Many codes borrowed from audio.c by
 *	    Alan Cox (alan@lxorguk.ukuu.org.uk)
 *	    Thomas Sailer (sailer@ife.ee.ethz.ch)
 *
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 *
 *  NOTES:
 *
 *   - async unlink should be used for avoiding the sleep inside lock.
 *     2.4.22 usb-uhci seems buggy for async unlinking and results in
 *     oops.  in such a cse, pass async_unlink=0 option.
 *   - the linked URBs would be preferred but not used so far because of
 *     the instability of unlinking.
 *   - type II is not supported properly.  there is no device which supports
 *     this type *correctly*.  SB extigy looks as if it supports, but it's
 *     indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream).
 */


#include <linux/bitops.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/usb.h>
#include <linux/moduleparam.h>
#include <linux/mutex.h>
#include <linux/usb/audio.h>
#include <linux/usb/audio-v2.h>

#include <sound/core.h>
#include <sound/info.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/initval.h>

#include "usbaudio.h"
#include "card.h"
#include "midi.h"
#include "mixer.h"
#include "proc.h"
#include "quirks.h"
#include "endpoint.h"
#include "helper.h"
#include "debug.h"
#include "pcm.h"
#include "urb.h"
#include "format.h"

MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
MODULE_DESCRIPTION("USB Audio");
MODULE_LICENSE("GPL");
MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}");


static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;	/* Index 0-MAX */
static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;	/* ID for this card */
static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */
/* Vendor/product IDs for this card */
static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 };
static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 };
static int nrpacks = 8;		/* max. number of packets per urb */
static int async_unlink = 1;
static int device_setup[SNDRV_CARDS]; /* device parameter for this card */
static int ignore_ctl_error;

module_param_array(index, int, NULL, 0444);
MODULE_PARM_DESC(index, "Index value for the USB audio adapter.");
module_param_array(id, charp, NULL, 0444);
MODULE_PARM_DESC(id, "ID string for the USB audio adapter.");
module_param_array(enable, bool, NULL, 0444);
MODULE_PARM_DESC(enable, "Enable USB audio adapter.");
module_param_array(vid, int, NULL, 0444);
MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device.");
module_param_array(pid, int, NULL, 0444);
MODULE_PARM_DESC(pid, "Product ID for the USB audio device.");
module_param(nrpacks, int, 0644);
MODULE_PARM_DESC(nrpacks, "Max. number of packets per URB.");
module_param(async_unlink, bool, 0444);
MODULE_PARM_DESC(async_unlink, "Use async unlink mode.");
module_param_array(device_setup, int, NULL, 0444);
MODULE_PARM_DESC(device_setup, "Specific device setup (if needed).");
module_param(ignore_ctl_error, bool, 0444);
MODULE_PARM_DESC(ignore_ctl_error,
		 "Ignore errors from USB controller for mixer interfaces.");

/*
 * we keep the snd_usb_audio_t instances by ourselves for merging
 * the all interfaces on the same card as one sound device.
 */

static DEFINE_MUTEX(register_mutex);
static struct snd_usb_audio *usb_chip[SNDRV_CARDS];
static struct usb_driver usb_audio_driver;

/*
 * disconnect streams
 * called from snd_usb_audio_disconnect()
 */
static void snd_usb_stream_disconnect(struct list_head *head)
{
	int idx;
	struct snd_usb_stream *as;
	struct snd_usb_substream *subs;

	as = list_entry(head, struct snd_usb_stream, list);
	for (idx = 0; idx < 2; idx++) {
		subs = &as->substream[idx];
		if (!subs->num_formats)
			continue;
		snd_usb_release_substream_urbs(subs, 1);
		subs->interface = -1;
	}
}

static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int interface)
{
	struct usb_device *dev = chip->dev;
	struct usb_host_interface *alts;
	struct usb_interface_descriptor *altsd;
	struct usb_interface *iface = usb_ifnum_to_if(dev, interface);

	if (!iface) {
		snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
			   dev->devnum, ctrlif, interface);
		return -EINVAL;
	}

	if (usb_interface_claimed(iface)) {
		snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n",
						dev->devnum, ctrlif, interface);
		return -EINVAL;
	}

	alts = &iface->altsetting[0];
	altsd = get_iface_desc(alts);
	if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
	     altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
	    altsd->bInterfaceSubClass == USB_SUBCLASS_MIDISTREAMING) {
		int err = snd_usbmidi_create(chip->card, iface,
					     &chip->midi_list, NULL);
		if (err < 0) {
			snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n",
						dev->devnum, ctrlif, interface);
			return -EINVAL;
		}
		usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);

		return 0;
	}

	if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
	     altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) ||
	    altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING) {
		snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n",
					dev->devnum, ctrlif, interface, altsd->bInterfaceClass);
		/* skip non-supported classes */
		return -EINVAL;
	}

	if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
		snd_printk(KERN_ERR "low speed audio streaming not supported\n");
		return -EINVAL;
	}

	if (! snd_usb_parse_audio_endpoints(chip, interface)) {
		usb_set_interface(dev, interface, 0); /* reset the current interface */
		usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
		return -EINVAL;
	}

	return 0;
}

/*
 * parse audio control descriptor and create pcm/midi streams
 */
static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
{
	struct usb_device *dev = chip->dev;
	struct usb_host_interface *host_iface;
	struct usb_interface_descriptor *altsd;
	void *control_header;
	int i, protocol;

	/* find audiocontrol interface */
	host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
	control_header = snd_usb_find_csint_desc(host_iface->extra,
						 host_iface->extralen,
						 NULL, UAC_HEADER);
	altsd = get_iface_desc(host_iface);
	protocol = altsd->bInterfaceProtocol;

	if (!control_header) {
		snd_printk(KERN_ERR "cannot find UAC_HEADER\n");
		return -EINVAL;
	}

	switch (protocol) {
	default:
		snd_printdd(KERN_WARNING "unknown interface protocol %#02x, assuming v1\n",
			    protocol);
		/* fall through */

	case UAC_VERSION_1: {
		struct uac1_ac_header_descriptor *h1 = control_header;

		if (!h1->bInCollection) {
			snd_printk(KERN_INFO "skipping empty audio interface (v1)\n");
			return -EINVAL;
		}

		if (h1->bLength < sizeof(*h1) + h1->bInCollection) {
			snd_printk(KERN_ERR "invalid UAC_HEADER (v1)\n");
			return -EINVAL;
		}

		for (i = 0; i < h1->bInCollection; i++)
			snd_usb_create_stream(chip, ctrlif, h1->baInterfaceNr[i]);

		break;
	}

	case UAC_VERSION_2: {
		struct usb_interface_assoc_descriptor *assoc =
			usb_ifnum_to_if(dev, ctrlif)->intf_assoc;

		if (!assoc) {
			snd_printk(KERN_ERR "Audio class v2 interfaces need an interface association\n");
			return -EINVAL;
		}

		for (i = 0; i < assoc->bInterfaceCount; i++) {
			int intf = assoc->bFirstInterface + i;

			if (intf != ctrlif)
				snd_usb_create_stream(chip, ctrlif, intf);
		}

		break;
	}
	}

	return 0;
}

/*
 * free the chip instance
 *
 * here we have to do not much, since pcm and controls are already freed
 *
 */

static int snd_usb_audio_free(struct snd_usb_audio *chip)
{
	kfree(chip);
	return 0;
}

static int snd_usb_audio_dev_free(struct snd_device *device)
{
	struct snd_usb_audio *chip = device->device_data;
	return snd_usb_audio_free(chip);
}


/*
 * create a chip instance and set its names.
 */
static int snd_usb_audio_create(struct usb_device *dev, int idx,
				const struct snd_usb_audio_quirk *quirk,
				struct snd_usb_audio **rchip)
{
	struct snd_card *card;
	struct snd_usb_audio *chip;
	int err, len;
	char component[14];
	static struct snd_device_ops ops = {
		.dev_free =	snd_usb_audio_dev_free,
	};

	*rchip = NULL;

	switch (snd_usb_get_speed(dev)) {
	case USB_SPEED_LOW:
	case USB_SPEED_FULL:
	case USB_SPEED_HIGH:
	case USB_SPEED_SUPER:
		break;
	default:
		snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
		return -ENXIO;
	}

	err = snd_card_create(index[idx], id[idx], THIS_MODULE, 0, &card);
	if (err < 0) {
		snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
		return err;
	}

	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
	if (! chip) {
		snd_card_free(card);
		return -ENOMEM;
	}

	chip->index = idx;
	chip->dev = dev;
	chip->card = card;
	chip->setup = device_setup[idx];
	chip->nrpacks = nrpacks;
	chip->async_unlink = async_unlink;

	chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
			      le16_to_cpu(dev->descriptor.idProduct));
	INIT_LIST_HEAD(&chip->pcm_list);
	INIT_LIST_HEAD(&chip->midi_list);
	INIT_LIST_HEAD(&chip->mixer_list);

	if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
		snd_usb_audio_free(chip);
		snd_card_free(card);
		return err;
	}

	strcpy(card->driver, "USB-Audio");
	sprintf(component, "USB%04x:%04x",
		USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id));
	snd_component_add(card, component);

	/* retrieve the device string as shortname */
	if (quirk && quirk->product_name) {
		strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname));
	} else {
		if (!dev->descriptor.iProduct ||
		    usb_string(dev, dev->descriptor.iProduct,
		    card->shortname, sizeof(card->shortname)) <= 0) {
			/* no name available from anywhere, so use ID */
			sprintf(card->shortname, "USB Device %#04x:%#04x",
				USB_ID_VENDOR(chip->usb_id),
				USB_ID_PRODUCT(chip->usb_id));
		}
	}

	/* retrieve the vendor and device strings as longname */
	if (quirk && quirk->vendor_name) {
		len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
	} else {
		if (dev->descriptor.iManufacturer)
			len = usb_string(dev, dev->descriptor.iManufacturer,
					 card->longname, sizeof(card->longname));
		else
			len = 0;
		/* we don't really care if there isn't any vendor string */
	}
	if (len > 0)
		strlcat(card->longname, " ", sizeof(card->longname));

	strlcat(card->longname, card->shortname, sizeof(card->longname));

	len = strlcat(card->longname, " at ", sizeof(card->longname));

	if (len < sizeof(card->longname))
		usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);

	switch (snd_usb_get_speed(dev)) {
	case USB_SPEED_LOW:
		strlcat(card->longname, ", low speed", sizeof(card->longname));
		break;
	case USB_SPEED_FULL:
		strlcat(card->longname, ", full speed", sizeof(card->longname));
		break;
	case USB_SPEED_HIGH:
		strlcat(card->longname, ", high speed", sizeof(card->longname));
		break;
	case USB_SPEED_SUPER:
		strlcat(card->longname, ", super speed", sizeof(card->longname));
		break;
	default:
		break;
	}

	snd_usb_audio_create_proc(chip);

	*rchip = chip;
	return 0;
}

/*
 * probe the active usb device
 *
 * note that this can be called multiple times per a device, when it
 * includes multiple audio control interfaces.
 *
 * thus we check the usb device pointer and creates the card instance
 * only at the first time.  the successive calls of this function will
 * append the pcm interface to the corresponding card.
 */
static void *snd_usb_audio_probe(struct usb_device *dev,
				 struct usb_interface *intf,
				 const struct usb_device_id *usb_id)
{
	const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info;
	int i, err;
	struct snd_usb_audio *chip;
	struct usb_host_interface *alts;
	int ifnum;
	u32 id;

	alts = &intf->altsetting[0];
	ifnum = get_iface_desc(alts)->bInterfaceNumber;
	id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
		    le16_to_cpu(dev->descriptor.idProduct));
	if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
		goto __err_val;

	if (snd_usb_apply_boot_quirk(dev, intf, quirk) < 0)
		goto __err_val;

	/*
	 * found a config.  now register to ALSA
	 */

	/* check whether it's already registered */
	chip = NULL;
	mutex_lock(&register_mutex);
	for (i = 0; i < SNDRV_CARDS; i++) {
		if (usb_chip[i] && usb_chip[i]->dev == dev) {
			if (usb_chip[i]->shutdown) {
				snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n");
				goto __error;
			}
			chip = usb_chip[i];
			break;
		}
	}
	if (! chip) {
		/* it's a fresh one.
		 * now look for an empty slot and create a new card instance
		 */
		for (i = 0; i < SNDRV_CARDS; i++)
			if (enable[i] && ! usb_chip[i] &&
			    (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) &&
			    (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) {
				if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) {
					goto __error;
				}
				snd_card_set_dev(chip->card, &intf->dev);
				break;
			}
		if (!chip) {
			printk(KERN_ERR "no available usb audio device\n");
			goto __error;
		}
	}

	chip->txfr_quirk = 0;
	err = 1; /* continue */
	if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
		/* need some special handlings */
		if ((err = snd_usb_create_quirk(chip, intf, &usb_audio_driver, quirk)) < 0)
			goto __error;
	}

	/*
	 * For devices with more than one control interface, we assume the
	 * first contains the audio controls. We might need a more specific
	 * check here in the future.
	 */
	if (!chip->ctrl_intf)
		chip->ctrl_intf = alts;

	if (err > 0) {
		/* create normal USB audio interfaces */
		if (snd_usb_create_streams(chip, ifnum) < 0 ||
		    snd_usb_create_mixer(chip, ifnum, ignore_ctl_error) < 0) {
			goto __error;
		}
	}

	/* we are allowed to call snd_card_register() many times */
	if (snd_card_register(chip->card) < 0) {
		goto __error;
	}

	usb_chip[chip->index] = chip;
	chip->num_interfaces++;
	mutex_unlock(&register_mutex);
	return chip;

 __error:
	if (chip && !chip->num_interfaces)
		snd_card_free(chip->card);
	mutex_unlock(&register_mutex);
 __err_val:
	return NULL;
}

/*
 * we need to take care of counter, since disconnection can be called also
 * many times as well as usb_audio_probe().
 */
static void snd_usb_audio_disconnect(struct usb_device *dev, void *ptr)
{
	struct snd_usb_audio *chip;
	struct snd_card *card;
	struct list_head *p;

	if (ptr == (void *)-1L)
		return;

	chip = ptr;
	card = chip->card;
	mutex_lock(&register_mutex);
	chip->shutdown = 1;
	chip->num_interfaces--;
	if (chip->num_interfaces <= 0) {
		snd_card_disconnect(card);
		/* release the pcm resources */
		list_for_each(p, &chip->pcm_list) {
			snd_usb_stream_disconnect(p);
		}
		/* release the midi resources */
		list_for_each(p, &chip->midi_list) {
			snd_usbmidi_disconnect(p);
		}
		/* release mixer resources */
		list_for_each(p, &chip->mixer_list) {
			snd_usb_mixer_disconnect(p);
		}
		usb_chip[chip->index] = NULL;
		mutex_unlock(&register_mutex);
		snd_card_free_when_closed(card);
	} else {
		mutex_unlock(&register_mutex);
	}
}

/*
 * new 2.5 USB kernel API
 */
static int usb_audio_probe(struct usb_interface *intf,
			   const struct usb_device_id *id)
{
	void *chip;
	chip = snd_usb_audio_probe(interface_to_usbdev(intf), intf, id);
	if (chip) {
		usb_set_intfdata(intf, chip);
		return 0;
	} else
		return -EIO;
}

static void usb_audio_disconnect(struct usb_interface *intf)
{
	snd_usb_audio_disconnect(interface_to_usbdev(intf),
				 usb_get_intfdata(intf));
}

#ifdef CONFIG_PM
static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct snd_usb_audio *chip = usb_get_intfdata(intf);
	struct list_head *p;
	struct snd_usb_stream *as;

	if (chip == (void *)-1L)
		return 0;

	snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
	if (!chip->num_suspended_intf++) {
		list_for_each(p, &chip->pcm_list) {
			as = list_entry(p, struct snd_usb_stream, list);
			snd_pcm_suspend_all(as->pcm);
		}
	}

	return 0;
}

static int usb_audio_resume(struct usb_interface *intf)
{
	struct snd_usb_audio *chip = usb_get_intfdata(intf);

	if (chip == (void *)-1L)
		return 0;
	if (--chip->num_suspended_intf)
		return 0;
	/*
	 * ALSA leaves material resumption to user space
	 * we just notify
	 */

	snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);

	return 0;
}
#else
#define usb_audio_suspend	NULL
#define usb_audio_resume	NULL
#endif		/* CONFIG_PM */

static struct usb_device_id usb_audio_ids [] = {
#include "quirks-table.h"
    { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS),
      .bInterfaceClass = USB_CLASS_AUDIO,
      .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL },
    { }						/* Terminating entry */
};

MODULE_DEVICE_TABLE (usb, usb_audio_ids);

/*
 * entry point for linux usb interface
 */

static struct usb_driver usb_audio_driver = {
	.name =		"snd-usb-audio",
	.probe =	usb_audio_probe,
	.disconnect =	usb_audio_disconnect,
	.suspend =	usb_audio_suspend,
	.resume =	usb_audio_resume,
	.id_table =	usb_audio_ids,
};

static int __init snd_usb_audio_init(void)
{
	if (nrpacks < 1 || nrpacks > MAX_PACKS) {
		printk(KERN_WARNING "invalid nrpacks value.\n");
		return -EINVAL;
	}
	return usb_register(&usb_audio_driver);
}

static void __exit snd_usb_audio_cleanup(void)
{
	usb_deregister(&usb_audio_driver);
}

module_init(snd_usb_audio_init);
module_exit(snd_usb_audio_cleanup);
Commit	Line	Data
e5779998 DM	1	/*
	2	* (Tentative) USB Audio Driver for ALSA
	3	*
	4	* Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
	5	*
	6	* Many codes borrowed from audio.c by
	7	* Alan Cox (alan@lxorguk.ukuu.org.uk)
	8	* Thomas Sailer (sailer@ife.ee.ethz.ch)
	9	*
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to the Free Software
	23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	24	*
	25	*
	26	* NOTES:
	27	*
	28	* - async unlink should be used for avoiding the sleep inside lock.
	29	* 2.4.22 usb-uhci seems buggy for async unlinking and results in
	30	* oops. in such a cse, pass async_unlink=0 option.
	31	* - the linked URBs would be preferred but not used so far because of
	32	* the instability of unlinking.
	33	* - type II is not supported properly. there is no device which supports
	34	* this type correctly. SB extigy looks as if it supports, but it's
	35	* indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream).
	36	*/
	37
	38
	39	#include <linux/bitops.h>
	40	#include <linux/init.h>
	41	#include <linux/list.h>
	42	#include <linux/slab.h>
	43	#include <linux/string.h>
	44	#include <linux/usb.h>
	45	#include <linux/moduleparam.h>
	46	#include <linux/mutex.h>
	47	#include <linux/usb/audio.h>
7e847894	48	#include <linux/usb/audio-v2.h>
e5779998 DM	49
	50	#include <sound/core.h>
	51	#include <sound/info.h>
	52	#include <sound/pcm.h>
	53	#include <sound/pcm_params.h>
	54	#include <sound/initval.h>
	55
	56	#include "usbaudio.h"
	57	#include "card.h"
	58	#include "midi.h"
f0b5e634	59	#include "mixer.h"
e5779998 DM	60	#include "proc.h"
	61	#include "quirks.h"
	62	#include "endpoint.h"
	63	#include "helper.h"
	64	#include "debug.h"
	65	#include "pcm.h"
	66	#include "urb.h"
	67	#include "format.h"
	68
	69	MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
	70	MODULE_DESCRIPTION("USB Audio");
	71	MODULE_LICENSE("GPL");
	72	MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}");
	73
	74
	75	static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
	76	static char id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; / ID for this card */
	77	static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */
	78	/* Vendor/product IDs for this card */
	79	static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 };
	80	static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 };
	81	static int nrpacks = 8; /* max. number of packets per urb */
	82	static int async_unlink = 1;
	83	static int device_setup[SNDRV_CARDS]; /* device parameter for this card */
	84	static int ignore_ctl_error;
	85
	86	module_param_array(index, int, NULL, 0444);
	87	MODULE_PARM_DESC(index, "Index value for the USB audio adapter.");
	88	module_param_array(id, charp, NULL, 0444);
	89	MODULE_PARM_DESC(id, "ID string for the USB audio adapter.");
	90	module_param_array(enable, bool, NULL, 0444);
	91	MODULE_PARM_DESC(enable, "Enable USB audio adapter.");
	92	module_param_array(vid, int, NULL, 0444);
	93	MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device.");
	94	module_param_array(pid, int, NULL, 0444);
	95	MODULE_PARM_DESC(pid, "Product ID for the USB audio device.");
	96	module_param(nrpacks, int, 0644);
	97	MODULE_PARM_DESC(nrpacks, "Max. number of packets per URB.");
	98	module_param(async_unlink, bool, 0444);
	99	MODULE_PARM_DESC(async_unlink, "Use async unlink mode.");
	100	module_param_array(device_setup, int, NULL, 0444);
	101	MODULE_PARM_DESC(device_setup, "Specific device setup (if needed).");
	102	module_param(ignore_ctl_error, bool, 0444);
	103	MODULE_PARM_DESC(ignore_ctl_error,
	104	"Ignore errors from USB controller for mixer interfaces.");
	105
	106	/*
	107	* we keep the snd_usb_audio_t instances by ourselves for merging
	108	* the all interfaces on the same card as one sound device.
	109	*/
	110
	111	static DEFINE_MUTEX(register_mutex);
	112	static struct snd_usb_audio *usb_chip[SNDRV_CARDS];
	113	static struct usb_driver usb_audio_driver;
	114
	115	/*
	116	* disconnect streams
	117	* called from snd_usb_audio_disconnect()
	118	*/
	119	static void snd_usb_stream_disconnect(struct list_head *head)
	120	{
	121	int idx;
	122	struct snd_usb_stream *as;
	123	struct snd_usb_substream *subs;
124
125	as = list_entry(head, struct snd_usb_stream, list);
126	for (idx = 0; idx < 2; idx++) {
127	subs = &as->substream[idx];
128	if (!subs->num_formats)
76195fb0	129	continue;
e5779998 DM	130	snd_usb_release_substream_urbs(subs, 1);
	131	subs->interface = -1;
	132	}
	133	}
	134
	135	static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int interface)
	136	{
	137	struct usb_device *dev = chip->dev;
	138	struct usb_host_interface *alts;
	139	struct usb_interface_descriptor *altsd;
	140	struct usb_interface *iface = usb_ifnum_to_if(dev, interface);
	141
	142	if (!iface) {
	143	snd_printk(KERN_ERR "%d:%u:%d : does not exist\n",
	144	dev->devnum, ctrlif, interface);
	145	return -EINVAL;
	146	}
	147
	148	if (usb_interface_claimed(iface)) {
	149	snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n",
	150	dev->devnum, ctrlif, interface);
	151	return -EINVAL;
	152	}
	153
	154	alts = &iface->altsetting[0];
	155	altsd = get_iface_desc(alts);
	156	if ((altsd->bInterfaceClass == USB_CLASS_AUDIO \|\|
	157	altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
	158	altsd->bInterfaceSubClass == USB_SUBCLASS_MIDISTREAMING) {
	159	int err = snd_usbmidi_create(chip->card, iface,
	160	&chip->midi_list, NULL);
	161	if (err < 0) {
	162	snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n",
	163	dev->devnum, ctrlif, interface);
	164	return -EINVAL;
	165	}
	166	usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
	167
	168	return 0;
	169	}
	170
	171	if ((altsd->bInterfaceClass != USB_CLASS_AUDIO &&
	172	altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) \|\|
	173	altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING) {
	174	snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n",
	175	dev->devnum, ctrlif, interface, altsd->bInterfaceClass);
	176	/* skip non-supported classes */
	177	return -EINVAL;
	178	}
	179
	180	if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
	181	snd_printk(KERN_ERR "low speed audio streaming not supported\n");
	182	return -EINVAL;
	183	}
	184
	185	if (! snd_usb_parse_audio_endpoints(chip, interface)) {
	186	usb_set_interface(dev, interface, 0); /* reset the current interface */
	187	usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
	188	return -EINVAL;
	189	}
	190
	191	return 0;
	192	}
	193
194	/*
195	* parse audio control descriptor and create pcm/midi streams
196	*/
197	static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif)
198	{
199	struct usb_device *dev = chip->dev;
200	struct usb_host_interface *host_iface;
201	struct usb_interface_descriptor *altsd;
202	void *control_header;
203	int i, protocol;
204
205	/* find audiocontrol interface */
206	host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0];
207	control_header = snd_usb_find_csint_desc(host_iface->extra,
208	host_iface->extralen,
209	NULL, UAC_HEADER);
210	altsd = get_iface_desc(host_iface);
211	protocol = altsd->bInterfaceProtocol;
212
213	if (!control_header) {
214	snd_printk(KERN_ERR "cannot find UAC_HEADER\n");
215	return -EINVAL;
216	}
217
218	switch (protocol) {
a2acad82 CL	219	default:
	220	snd_printdd(KERN_WARNING "unknown interface protocol %#02x, assuming v1\n",
	221	protocol);
	222	/* fall through */
	223
e5779998	224	case UAC_VERSION_1: {
69da9bcb	225	struct uac1_ac_header_descriptor *h1 = control_header;
e5779998 DM	226
	227	if (!h1->bInCollection) {
	228	snd_printk(KERN_INFO "skipping empty audio interface (v1)\n");
	229	return -EINVAL;
	230	}
	231
	232	if (h1->bLength < sizeof(*h1) + h1->bInCollection) {
	233	snd_printk(KERN_ERR "invalid UAC_HEADER (v1)\n");
	234	return -EINVAL;
	235	}
	236
	237	for (i = 0; i < h1->bInCollection; i++)
	238	snd_usb_create_stream(chip, ctrlif, h1->baInterfaceNr[i]);
	239
	240	break;
	241	}
	242
	243	case UAC_VERSION_2: {
e5779998 DM	244	struct usb_interface_assoc_descriptor *assoc =
	245	usb_ifnum_to_if(dev, ctrlif)->intf_assoc;
	246
	247	if (!assoc) {
	248	snd_printk(KERN_ERR "Audio class v2 interfaces need an interface association\n");
	249	return -EINVAL;
	250	}
	251
e5779998 DM	252	for (i = 0; i < assoc->bInterfaceCount; i++) {
	253	int intf = assoc->bFirstInterface + i;
	254
	255	if (intf != ctrlif)
	256	snd_usb_create_stream(chip, ctrlif, intf);
	257	}
	258
	259	break;
	260	}
e5779998 DM	261	}
	262
	263	return 0;
	264	}
	265
	266	/*
	267	* free the chip instance
	268	*
	269	* here we have to do not much, since pcm and controls are already freed
	270	*
	271	*/
	272
	273	static int snd_usb_audio_free(struct snd_usb_audio *chip)
	274	{
	275	kfree(chip);
	276	return 0;
	277	}
	278
	279	static int snd_usb_audio_dev_free(struct snd_device *device)
	280	{
	281	struct snd_usb_audio *chip = device->device_data;
	282	return snd_usb_audio_free(chip);
	283	}
	284
	285
	286	/*
	287	* create a chip instance and set its names.
	288	*/
	289	static int snd_usb_audio_create(struct usb_device *dev, int idx,
	290	const struct snd_usb_audio_quirk *quirk,
	291	struct snd_usb_audio **rchip)
	292	{
	293	struct snd_card *card;
	294	struct snd_usb_audio *chip;
	295	int err, len;
	296	char component[14];
	297	static struct snd_device_ops ops = {
	298	.dev_free = snd_usb_audio_dev_free,
	299	};
	300
	301	*rchip = NULL;
	302
4f4e8f69 PZ	303	switch (snd_usb_get_speed(dev)) {
	304	case USB_SPEED_LOW:
	305	case USB_SPEED_FULL:
	306	case USB_SPEED_HIGH:
	307	case USB_SPEED_SUPER:
	308	break;
	309	default:
e5779998 DM	310	snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev));
	311	return -ENXIO;
	312	}
	313
	314	err = snd_card_create(index[idx], id[idx], THIS_MODULE, 0, &card);
	315	if (err < 0) {
	316	snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
	317	return err;
	318	}
	319
	320	chip = kzalloc(sizeof(*chip), GFP_KERNEL);
	321	if (! chip) {
	322	snd_card_free(card);
	323	return -ENOMEM;
	324	}
	325
	326	chip->index = idx;
	327	chip->dev = dev;
	328	chip->card = card;
	329	chip->setup = device_setup[idx];
	330	chip->nrpacks = nrpacks;
	331	chip->async_unlink = async_unlink;
	332
	333	chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
	334	le16_to_cpu(dev->descriptor.idProduct));
	335	INIT_LIST_HEAD(&chip->pcm_list);
	336	INIT_LIST_HEAD(&chip->midi_list);
	337	INIT_LIST_HEAD(&chip->mixer_list);
	338
	339	if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
	340	snd_usb_audio_free(chip);
	341	snd_card_free(card);
	342	return err;
	343	}
	344
	345	strcpy(card->driver, "USB-Audio");
	346	sprintf(component, "USB%04x:%04x",
	347	USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id));
	348	snd_component_add(card, component);
	349
	350	/* retrieve the device string as shortname */
	351	if (quirk && quirk->product_name) {
	352	strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname));
	353	} else {
	354	if (!dev->descriptor.iProduct \|\|
	355	usb_string(dev, dev->descriptor.iProduct,
	356	card->shortname, sizeof(card->shortname)) <= 0) {
	357	/* no name available from anywhere, so use ID */
	358	sprintf(card->shortname, "USB Device %#04x:%#04x",
	359	USB_ID_VENDOR(chip->usb_id),
	360	USB_ID_PRODUCT(chip->usb_id));
	361	}
	362	}
	363
	364	/* retrieve the vendor and device strings as longname */
	365	if (quirk && quirk->vendor_name) {
	366	len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
	367	} else {
	368	if (dev->descriptor.iManufacturer)
	369	len = usb_string(dev, dev->descriptor.iManufacturer,
	370	card->longname, sizeof(card->longname));
	371	else
	372	len = 0;
	373	/* we don't really care if there isn't any vendor string */
374	}
375	if (len > 0)
376	strlcat(card->longname, " ", sizeof(card->longname));
377
378	strlcat(card->longname, card->shortname, sizeof(card->longname));
379
380	len = strlcat(card->longname, " at ", sizeof(card->longname));
381
382	if (len < sizeof(card->longname))
383	usb_make_path(dev, card->longname + len, sizeof(card->longname) - len);
384
4f4e8f69 PZ	385	switch (snd_usb_get_speed(dev)) {
	386	case USB_SPEED_LOW:
	387	strlcat(card->longname, ", low speed", sizeof(card->longname));
	388	break;
	389	case USB_SPEED_FULL:
	390	strlcat(card->longname, ", full speed", sizeof(card->longname));
	391	break;
	392	case USB_SPEED_HIGH:
	393	strlcat(card->longname, ", high speed", sizeof(card->longname));
	394	break;
	395	case USB_SPEED_SUPER:
	396	strlcat(card->longname, ", super speed", sizeof(card->longname));
	397	break;
	398	default:
	399	break;
	400	}
e5779998 DM	401
	402	snd_usb_audio_create_proc(chip);
	403
	404	*rchip = chip;
	405	return 0;
	406	}
	407
	408	/*
	409	* probe the active usb device
	410	*
	411	* note that this can be called multiple times per a device, when it
	412	* includes multiple audio control interfaces.
	413	*
	414	* thus we check the usb device pointer and creates the card instance
	415	* only at the first time. the successive calls of this function will
	416	* append the pcm interface to the corresponding card.
	417	*/
	418	static void snd_usb_audio_probe(struct usb_device dev,
	419	struct usb_interface *intf,
	420	const struct usb_device_id *usb_id)
	421	{
	422	const struct snd_usb_audio_quirk quirk = (const struct snd_usb_audio_quirk )usb_id->driver_info;
	423	int i, err;
	424	struct snd_usb_audio *chip;
	425	struct usb_host_interface *alts;
	426	int ifnum;
	427	u32 id;
	428
	429	alts = &intf->altsetting[0];
	430	ifnum = get_iface_desc(alts)->bInterfaceNumber;
	431	id = USB_ID(le16_to_cpu(dev->descriptor.idVendor),
	432	le16_to_cpu(dev->descriptor.idProduct));
	433	if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
	434	goto __err_val;
	435
	436	if (snd_usb_apply_boot_quirk(dev, intf, quirk) < 0)
	437	goto __err_val;
	438
	439	/*
	440	* found a config. now register to ALSA
	441	*/
	442
	443	/* check whether it's already registered */
	444	chip = NULL;
	445	mutex_lock(&register_mutex);
	446	for (i = 0; i < SNDRV_CARDS; i++) {
	447	if (usb_chip[i] && usb_chip[i]->dev == dev) {
	448	if (usb_chip[i]->shutdown) {
	449	snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n");
	450	goto __error;
	451	}
	452	chip = usb_chip[i];
	453	break;
	454	}
	455	}
	456	if (! chip) {
	457	/* it's a fresh one.
	458	* now look for an empty slot and create a new card instance
	459	*/
	460	for (i = 0; i < SNDRV_CARDS; i++)
	461	if (enable[i] && ! usb_chip[i] &&
	462	(vid[i] == -1 \|\| vid[i] == USB_ID_VENDOR(id)) &&
	463	(pid[i] == -1 \|\| pid[i] == USB_ID_PRODUCT(id))) {
	464	if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) {
465	goto __error;
466	}
467	snd_card_set_dev(chip->card, &intf->dev);
468	break;
469	}
470	if (!chip) {
471	printk(KERN_ERR "no available usb audio device\n");
472	goto __error;
473	}
474	}
475
476	chip->txfr_quirk = 0;
477	err = 1; /* continue */
478	if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
479	/* need some special handlings */
480	if ((err = snd_usb_create_quirk(chip, intf, &usb_audio_driver, quirk)) < 0)
481	goto __error;
482	}
483
7b6717e1 DM	484	/*
	485	* For devices with more than one control interface, we assume the
	486	* first contains the audio controls. We might need a more specific
	487	* check here in the future.
	488	*/
	489	if (!chip->ctrl_intf)
	490	chip->ctrl_intf = alts;
79f920fb	491
e5779998 DM	492	if (err > 0) {
	493	/* create normal USB audio interfaces */
	494	if (snd_usb_create_streams(chip, ifnum) < 0 \|\|
	495	snd_usb_create_mixer(chip, ifnum, ignore_ctl_error) < 0) {
	496	goto __error;
	497	}
	498	}
	499
	500	/* we are allowed to call snd_card_register() many times */
	501	if (snd_card_register(chip->card) < 0) {
	502	goto __error;
	503	}
	504
	505	usb_chip[chip->index] = chip;
	506	chip->num_interfaces++;
	507	mutex_unlock(&register_mutex);
	508	return chip;
	509
	510	__error:
	511	if (chip && !chip->num_interfaces)
	512	snd_card_free(chip->card);
	513	mutex_unlock(&register_mutex);
	514	__err_val:
	515	return NULL;
	516	}
	517
	518	/*
	519	* we need to take care of counter, since disconnection can be called also
	520	* many times as well as usb_audio_probe().
	521	*/
	522	static void snd_usb_audio_disconnect(struct usb_device dev, void ptr)
	523	{
	524	struct snd_usb_audio *chip;
	525	struct snd_card *card;
	526	struct list_head *p;
	527
	528	if (ptr == (void *)-1L)
	529	return;
	530
	531	chip = ptr;
	532	card = chip->card;
	533	mutex_lock(&register_mutex);
	534	chip->shutdown = 1;
	535	chip->num_interfaces--;
	536	if (chip->num_interfaces <= 0) {
	537	snd_card_disconnect(card);
	538	/* release the pcm resources */
	539	list_for_each(p, &chip->pcm_list) {
	540	snd_usb_stream_disconnect(p);
	541	}
	542	/* release the midi resources */
	543	list_for_each(p, &chip->midi_list) {
	544	snd_usbmidi_disconnect(p);
	545	}
	546	/* release mixer resources */
	547	list_for_each(p, &chip->mixer_list) {
	548	snd_usb_mixer_disconnect(p);
	549	}
	550	usb_chip[chip->index] = NULL;
	551	mutex_unlock(&register_mutex);
	552	snd_card_free_when_closed(card);
	553	} else {
	554	mutex_unlock(&register_mutex);
	555	}
556	}
557
558	/*
559	* new 2.5 USB kernel API
560	*/
561	static int usb_audio_probe(struct usb_interface *intf,
562	const struct usb_device_id *id)
563	{
564	void *chip;
565	chip = snd_usb_audio_probe(interface_to_usbdev(intf), intf, id);
566	if (chip) {
567	usb_set_intfdata(intf, chip);
568	return 0;
569	} else
570	return -EIO;
571	}
572
573	static void usb_audio_disconnect(struct usb_interface *intf)
574	{
575	snd_usb_audio_disconnect(interface_to_usbdev(intf),
576	usb_get_intfdata(intf));
577	}
578
579	#ifdef CONFIG_PM
580	static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message)
581	{
582	struct snd_usb_audio *chip = usb_get_intfdata(intf);
583	struct list_head *p;
584	struct snd_usb_stream *as;
585
586	if (chip == (void *)-1L)
587	return 0;
588
589	snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
590	if (!chip->num_suspended_intf++) {
591	list_for_each(p, &chip->pcm_list) {
592	as = list_entry(p, struct snd_usb_stream, list);
593	snd_pcm_suspend_all(as->pcm);
594	}
595	}
596
597	return 0;
598	}
599
600	static int usb_audio_resume(struct usb_interface *intf)
601	{
602	struct snd_usb_audio *chip = usb_get_intfdata(intf);
603
604	if (chip == (void *)-1L)
605	return 0;
606	if (--chip->num_suspended_intf)
607	return 0;
608	/*
609	* ALSA leaves material resumption to user space
610	* we just notify
611	*/
612
613	snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
614
615	return 0;
616	}
6407d474 RD	617	#else
	618	#define usb_audio_suspend NULL
	619	#define usb_audio_resume NULL
e5779998 DM	620	#endif /* CONFIG_PM */
	621
	622	static struct usb_device_id usb_audio_ids [] = {
	623	#include "quirks-table.h"
	624	{ .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS \| USB_DEVICE_ID_MATCH_INT_SUBCLASS),
	625	.bInterfaceClass = USB_CLASS_AUDIO,
	626	.bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL },
	627	{ } /* Terminating entry */
	628	};
	629
	630	MODULE_DEVICE_TABLE (usb, usb_audio_ids);
	631
	632	/*
	633	* entry point for linux usb interface
	634	*/
	635
	636	static struct usb_driver usb_audio_driver = {
	637	.name = "snd-usb-audio",
	638	.probe = usb_audio_probe,
	639	.disconnect = usb_audio_disconnect,
	640	.suspend = usb_audio_suspend,
	641	.resume = usb_audio_resume,
	642	.id_table = usb_audio_ids,
	643	};
	644
	645	static int __init snd_usb_audio_init(void)
	646	{
	647	if (nrpacks < 1 \|\| nrpacks > MAX_PACKS) {
	648	printk(KERN_WARNING "invalid nrpacks value.\n");
	649	return -EINVAL;
	650	}
	651	return usb_register(&usb_audio_driver);
	652	}
	653
	654	static void __exit snd_usb_audio_cleanup(void)
	655	{
	656	usb_deregister(&usb_audio_driver);
	657	}
	658
	659	module_init(snd_usb_audio_init);
	660	module_exit(snd_usb_audio_cleanup);