card.c 22.9 KB
Newer Older
Daniel Mack's avatar
Daniel Mack committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
/*
 *   (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:
 *
 *   - 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>
41
#include <linux/ctype.h>
Daniel Mack's avatar
Daniel Mack committed
42 43 44 45
#include <linux/usb.h>
#include <linux/moduleparam.h>
#include <linux/mutex.h>
#include <linux/usb/audio.h>
46
#include <linux/usb/audio-v2.h>
47
#include <linux/module.h>
Daniel Mack's avatar
Daniel Mack committed
48

49
#include <sound/control.h>
Daniel Mack's avatar
Daniel Mack committed
50 51 52 53 54 55 56 57 58
#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"
59
#include "mixer.h"
Daniel Mack's avatar
Daniel Mack committed
60 61 62 63 64 65 66
#include "proc.h"
#include "quirks.h"
#include "endpoint.h"
#include "helper.h"
#include "debug.h"
#include "pcm.h"
#include "format.h"
67
#include "power.h"
Daniel Mack's avatar
Daniel Mack committed
68
#include "stream.h"
Daniel Mack's avatar
Daniel Mack committed
69 70 71 72 73 74 75 76 77

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 */
78
static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */
Daniel Mack's avatar
Daniel Mack committed
79 80 81 82
/* 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 device_setup[SNDRV_CARDS]; /* device parameter for this card */
83
static bool ignore_ctl_error;
84
static bool autoclock = true;
85
static char *quirk_alias[SNDRV_CARDS];
Daniel Mack's avatar
Daniel Mack committed
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

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_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.");
102 103
module_param(autoclock, bool, 0444);
MODULE_PARM_DESC(autoclock, "Enable auto-clock selection for UAC2 devices (default: yes).");
104 105
module_param_array(quirk_alias, charp, NULL, 0444);
MODULE_PARM_DESC(quirk_alias, "Quirk aliases, e.g. 0123abcd:5678beef.");
Daniel Mack's avatar
Daniel Mack committed
106 107 108 109 110 111 112 113 114 115 116 117

/*
 * 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
118
 * called from usb_audio_disconnect()
Daniel Mack's avatar
Daniel Mack committed
119
 */
120
static void snd_usb_stream_disconnect(struct snd_usb_stream *as)
Daniel Mack's avatar
Daniel Mack committed
121 122 123 124 125 126 127
{
	int idx;
	struct snd_usb_substream *subs;

	for (idx = 0; idx < 2; idx++) {
		subs = &as->substream[idx];
		if (!subs->num_formats)
128
			continue;
Daniel Mack's avatar
Daniel Mack committed
129
		subs->interface = -1;
130 131
		subs->data_endpoint = NULL;
		subs->sync_endpoint = NULL;
Daniel Mack's avatar
Daniel Mack committed
132 133 134 135 136 137 138 139 140 141 142
	}
}

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) {
143 144
		dev_err(&dev->dev, "%u:%d : does not exist\n",
			ctrlif, interface);
Daniel Mack's avatar
Daniel Mack committed
145 146 147
		return -EINVAL;
	}

148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167
	alts = &iface->altsetting[0];
	altsd = get_iface_desc(alts);

	/*
	 * Android with both accessory and audio interfaces enabled gets the
	 * interface numbers wrong.
	 */
	if ((chip->usb_id == USB_ID(0x18d1, 0x2d04) ||
	     chip->usb_id == USB_ID(0x18d1, 0x2d05)) &&
	    interface == 0 &&
	    altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC &&
	    altsd->bInterfaceSubClass == USB_SUBCLASS_VENDOR_SPEC) {
		interface = 2;
		iface = usb_ifnum_to_if(dev, interface);
		if (!iface)
			return -EINVAL;
		alts = &iface->altsetting[0];
		altsd = get_iface_desc(alts);
	}

Daniel Mack's avatar
Daniel Mack committed
168
	if (usb_interface_claimed(iface)) {
169 170
		dev_dbg(&dev->dev, "%d:%d: skipping, already claimed\n",
			ctrlif, interface);
Daniel Mack's avatar
Daniel Mack committed
171 172 173 174 175 176
		return -EINVAL;
	}

	if ((altsd->bInterfaceClass == USB_CLASS_AUDIO ||
	     altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) &&
	    altsd->bInterfaceSubClass == USB_SUBCLASS_MIDISTREAMING) {
177 178 179
		int err = __snd_usbmidi_create(chip->card, iface,
					     &chip->midi_list, NULL,
					     chip->usb_id);
Daniel Mack's avatar
Daniel Mack committed
180
		if (err < 0) {
181 182 183
			dev_err(&dev->dev,
				"%u:%d: cannot create sequencer device\n",
				ctrlif, interface);
Daniel Mack's avatar
Daniel Mack committed
184 185 186 187 188 189 190 191 192 193
			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) {
194 195 196
		dev_dbg(&dev->dev,
			"%u:%d: skipping non-supported interface %d\n",
			ctrlif, interface, altsd->bInterfaceClass);
Daniel Mack's avatar
Daniel Mack committed
197 198 199 200 201
		/* skip non-supported classes */
		return -EINVAL;
	}

	if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
202
		dev_err(&dev->dev, "low speed audio streaming not supported\n");
Daniel Mack's avatar
Daniel Mack committed
203 204 205
		return -EINVAL;
	}

Daniel Mack's avatar
Daniel Mack committed
206
	if (! snd_usb_parse_audio_interface(chip, interface)) {
Daniel Mack's avatar
Daniel Mack committed
207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
		usb_set_interface(dev, interface, 0); /* reset the current interface */
		usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L);
	}

	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;
224
	int rest_bytes;
Daniel Mack's avatar
Daniel Mack committed
225 226 227 228 229 230 231 232 233 234

	/* 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) {
235
		dev_err(&dev->dev, "cannot find UAC_HEADER\n");
Daniel Mack's avatar
Daniel Mack committed
236 237 238
		return -EINVAL;
	}

239 240 241 242 243 244 245 246 247
	rest_bytes = (void *)(host_iface->extra + host_iface->extralen) -
		control_header;

	/* just to be sure -- this shouldn't hit at all */
	if (rest_bytes <= 0) {
		dev_err(&dev->dev, "invalid control header\n");
		return -EINVAL;
	}

Daniel Mack's avatar
Daniel Mack committed
248
	switch (protocol) {
249
	default:
250 251 252
		dev_warn(&dev->dev,
			 "unknown interface protocol %#02x, assuming v1\n",
			 protocol);
253 254
		/* fall through */

Daniel Mack's avatar
Daniel Mack committed
255
	case UAC_VERSION_1: {
256
		struct uac1_ac_header_descriptor *h1 = control_header;
Daniel Mack's avatar
Daniel Mack committed
257

258 259 260 261 262
		if (rest_bytes < sizeof(*h1)) {
			dev_err(&dev->dev, "too short v1 buffer descriptor\n");
			return -EINVAL;
		}

Daniel Mack's avatar
Daniel Mack committed
263
		if (!h1->bInCollection) {
264
			dev_info(&dev->dev, "skipping empty audio interface (v1)\n");
Daniel Mack's avatar
Daniel Mack committed
265 266 267
			return -EINVAL;
		}

268 269 270 271 272
		if (rest_bytes < h1->bLength) {
			dev_err(&dev->dev, "invalid buffer length (v1)\n");
			return -EINVAL;
		}

Daniel Mack's avatar
Daniel Mack committed
273
		if (h1->bLength < sizeof(*h1) + h1->bInCollection) {
274
			dev_err(&dev->dev, "invalid UAC_HEADER (v1)\n");
Daniel Mack's avatar
Daniel Mack committed
275 276 277 278 279 280 281 282 283 284 285 286 287
			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;

288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
		if (!assoc) {
			/*
			 * Firmware writers cannot count to three.  So to find
			 * the IAD on the NuForce UDH-100, also check the next
			 * interface.
			 */
			struct usb_interface *iface =
				usb_ifnum_to_if(dev, ctrlif + 1);
			if (iface &&
			    iface->intf_assoc &&
			    iface->intf_assoc->bFunctionClass == USB_CLASS_AUDIO &&
			    iface->intf_assoc->bFunctionProtocol == UAC_VERSION_2)
				assoc = iface->intf_assoc;
		}

Daniel Mack's avatar
Daniel Mack committed
303
		if (!assoc) {
304
			dev_err(&dev->dev, "Audio class v2 interfaces need an interface association\n");
Daniel Mack's avatar
Daniel Mack committed
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
			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)
{
331
	struct snd_usb_endpoint *ep, *n;
332

333 334
	list_for_each_entry_safe(ep, n, &chip->ep_list, list)
		snd_usb_endpoint_free(ep);
335

336
	mutex_destroy(&chip->mutex);
337 338
	if (!atomic_read(&chip->shutdown))
		dev_set_drvdata(&chip->dev->dev, NULL);
Daniel Mack's avatar
Daniel Mack committed
339 340 341 342 343 344 345 346 347 348 349 350 351
	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.
 */
352 353
static int snd_usb_audio_create(struct usb_interface *intf,
				struct usb_device *dev, int idx,
Daniel Mack's avatar
Daniel Mack committed
354
				const struct snd_usb_audio_quirk *quirk,
355
				unsigned int usb_id,
Daniel Mack's avatar
Daniel Mack committed
356 357 358 359 360 361 362 363 364 365 366 367
				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;

368 369 370 371
	switch (snd_usb_get_speed(dev)) {
	case USB_SPEED_LOW:
	case USB_SPEED_FULL:
	case USB_SPEED_HIGH:
372
	case USB_SPEED_WIRELESS:
373
	case USB_SPEED_SUPER:
374
	case USB_SPEED_SUPER_PLUS:
375 376
		break;
	default:
377
		dev_err(&dev->dev, "unknown device speed %d\n", snd_usb_get_speed(dev));
Daniel Mack's avatar
Daniel Mack committed
378 379 380
		return -ENXIO;
	}

381 382
	err = snd_card_new(&intf->dev, index[idx], id[idx], THIS_MODULE,
			   0, &card);
Daniel Mack's avatar
Daniel Mack committed
383
	if (err < 0) {
384
		dev_err(&dev->dev, "cannot create card instance %d\n", idx);
Daniel Mack's avatar
Daniel Mack committed
385 386 387 388 389 390 391 392 393
		return err;
	}

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

394
	mutex_init(&chip->mutex);
395
	init_waitqueue_head(&chip->shutdown_wait);
Daniel Mack's avatar
Daniel Mack committed
396 397 398 399
	chip->index = idx;
	chip->dev = dev;
	chip->card = card;
	chip->setup = device_setup[idx];
400
	chip->autoclock = autoclock;
401
	atomic_set(&chip->active, 1); /* avoid autopm during probing */
402 403
	atomic_set(&chip->usage_count, 0);
	atomic_set(&chip->shutdown, 0);
Daniel Mack's avatar
Daniel Mack committed
404

405
	chip->usb_id = usb_id;
Daniel Mack's avatar
Daniel Mack committed
406
	INIT_LIST_HEAD(&chip->pcm_list);
407
	INIT_LIST_HEAD(&chip->ep_list);
Daniel Mack's avatar
Daniel Mack committed
408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
	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 */
423
	if (quirk && quirk->product_name && *quirk->product_name) {
Daniel Mack's avatar
Daniel Mack committed
424 425 426 427 428 429 430 431 432 433 434
		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));
		}
	}
435
	strim(card->shortname);
Daniel Mack's avatar
Daniel Mack committed
436 437

	/* retrieve the vendor and device strings as longname */
438
	if (quirk && quirk->vendor_name && *quirk->vendor_name) {
Daniel Mack's avatar
Daniel Mack committed
439 440 441 442 443 444 445 446 447
		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 */
	}
448
	if (len > 0) {
449
		strim(card->longname);
450 451 452
		if (*card->longname)
			strlcat(card->longname, " ", sizeof(card->longname));
	}
Daniel Mack's avatar
Daniel Mack committed
453 454 455 456 457 458 459 460

	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);

461 462 463 464 465 466 467 468 469 470 471 472 473
	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;
474 475 476
	case USB_SPEED_SUPER_PLUS:
		strlcat(card->longname, ", super speed plus", sizeof(card->longname));
		break;
477 478 479
	default:
		break;
	}
Daniel Mack's avatar
Daniel Mack committed
480 481 482 483 484 485 486

	snd_usb_audio_create_proc(chip);

	*rchip = chip;
	return 0;
}

487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508
/* look for a matching quirk alias id */
static bool get_alias_id(struct usb_device *dev, unsigned int *id)
{
	int i;
	unsigned int src, dst;

	for (i = 0; i < ARRAY_SIZE(quirk_alias); i++) {
		if (!quirk_alias[i] ||
		    sscanf(quirk_alias[i], "%x:%x", &src, &dst) != 2 ||
		    src != *id)
			continue;
		dev_info(&dev->dev,
			 "device (%04x:%04x): applying quirk alias %04x:%04x\n",
			 USB_ID_VENDOR(*id), USB_ID_PRODUCT(*id),
			 USB_ID_VENDOR(dst), USB_ID_PRODUCT(dst));
		*id = dst;
		return true;
	}

	return false;
}

509
static const struct usb_device_id usb_audio_ids[]; /* defined below */
510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528

/* look for the corresponding quirk */
static const struct snd_usb_audio_quirk *
get_alias_quirk(struct usb_device *dev, unsigned int id)
{
	const struct usb_device_id *p;

	for (p = usb_audio_ids; p->match_flags; p++) {
		/* FIXME: this checks only vendor:product pair in the list */
		if ((p->match_flags & USB_DEVICE_ID_MATCH_DEVICE) ==
		    USB_DEVICE_ID_MATCH_DEVICE &&
		    p->idVendor == USB_ID_VENDOR(id) &&
		    p->idProduct == USB_ID_PRODUCT(id))
			return (const struct snd_usb_audio_quirk *)p->driver_info;
	}

	return NULL;
}

Daniel Mack's avatar
Daniel Mack committed
529 530 531 532 533 534 535 536 537 538
/*
 * 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.
 */
539 540
static int usb_audio_probe(struct usb_interface *intf,
			   const struct usb_device_id *usb_id)
Daniel Mack's avatar
Daniel Mack committed
541
{
542 543 544
	struct usb_device *dev = interface_to_usbdev(intf);
	const struct snd_usb_audio_quirk *quirk =
		(const struct snd_usb_audio_quirk *)usb_id->driver_info;
Daniel Mack's avatar
Daniel Mack committed
545
	struct snd_usb_audio *chip;
546
	int i, err;
Daniel Mack's avatar
Daniel Mack committed
547 548 549 550 551 552 553 554
	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));
555 556
	if (get_alias_id(dev, &id))
		quirk = get_alias_quirk(dev, id);
Daniel Mack's avatar
Daniel Mack committed
557
	if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
558
		return -ENXIO;
Daniel Mack's avatar
Daniel Mack committed
559

560
	err = snd_usb_apply_boot_quirk(dev, intf, quirk, id);
561 562
	if (err < 0)
		return err;
Daniel Mack's avatar
Daniel Mack committed
563 564 565 566 567 568 569 570 571 572

	/*
	 * 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) {
573
			if (atomic_read(&usb_chip[i]->shutdown)) {
574
				dev_err(&dev->dev, "USB device is in the shutdown state, cannot create a card instance\n");
575
				err = -EIO;
Daniel Mack's avatar
Daniel Mack committed
576 577 578
				goto __error;
			}
			chip = usb_chip[i];
579
			atomic_inc(&chip->active); /* avoid autopm */
Daniel Mack's avatar
Daniel Mack committed
580 581 582 583 584 585 586 587 588 589 590
			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))) {
591
				err = snd_usb_audio_create(intf, dev, i, quirk,
592
							   id, &chip);
593
				if (err < 0)
Daniel Mack's avatar
Daniel Mack committed
594
					goto __error;
595
				chip->pm_intf = intf;
Daniel Mack's avatar
Daniel Mack committed
596 597 598
				break;
			}
		if (!chip) {
599
			dev_err(&dev->dev, "no available usb audio device\n");
600
			err = -ENODEV;
Daniel Mack's avatar
Daniel Mack committed
601 602 603
			goto __error;
		}
	}
604
	dev_set_drvdata(&dev->dev, chip);
Daniel Mack's avatar
Daniel Mack committed
605

606 607 608 609 610 611 612
	/*
	 * 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;
613

614 615 616 617
	chip->txfr_quirk = 0;
	err = 1; /* continue */
	if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
		/* need some special handlings */
618 619
		err = snd_usb_create_quirk(chip, intf, &usb_audio_driver, quirk);
		if (err < 0)
620 621 622
			goto __error;
	}

Daniel Mack's avatar
Daniel Mack committed
623 624
	if (err > 0) {
		/* create normal USB audio interfaces */
625 626 627 628 629
		err = snd_usb_create_streams(chip, ifnum);
		if (err < 0)
			goto __error;
		err = snd_usb_create_mixer(chip, ifnum, ignore_ctl_error);
		if (err < 0)
Daniel Mack's avatar
Daniel Mack committed
630 631 632 633
			goto __error;
	}

	/* we are allowed to call snd_card_register() many times */
634 635
	err = snd_card_register(chip->card);
	if (err < 0)
Daniel Mack's avatar
Daniel Mack committed
636 637 638 639
		goto __error;

	usb_chip[chip->index] = chip;
	chip->num_interfaces++;
640
	usb_set_intfdata(intf, chip);
641
	atomic_dec(&chip->active);
Daniel Mack's avatar
Daniel Mack committed
642
	mutex_unlock(&register_mutex);
643
	return 0;
Daniel Mack's avatar
Daniel Mack committed
644 645

 __error:
646 647 648
	if (chip) {
		if (!chip->num_interfaces)
			snd_card_free(chip->card);
649
		atomic_dec(&chip->active);
650
	}
Daniel Mack's avatar
Daniel Mack committed
651
	mutex_unlock(&register_mutex);
652
	return err;
Daniel Mack's avatar
Daniel Mack committed
653 654 655 656 657 658
}

/*
 * we need to take care of counter, since disconnection can be called also
 * many times as well as usb_audio_probe().
 */
659
static void usb_audio_disconnect(struct usb_interface *intf)
Daniel Mack's avatar
Daniel Mack committed
660
{
661
	struct snd_usb_audio *chip = usb_get_intfdata(intf);
Daniel Mack's avatar
Daniel Mack committed
662
	struct snd_card *card;
663
	struct list_head *p;
Daniel Mack's avatar
Daniel Mack committed
664

665
	if (chip == (void *)-1L)
Daniel Mack's avatar
Daniel Mack committed
666 667 668
		return;

	card = chip->card;
669 670

	mutex_lock(&register_mutex);
671
	if (atomic_inc_return(&chip->shutdown) == 1) {
672
		struct snd_usb_stream *as;
673
		struct snd_usb_endpoint *ep;
674
		struct usb_mixer_interface *mixer;
675

676 677 678 679 680
		/* wait until all pending tasks done;
		 * they are protected by snd_usb_lock_shutdown()
		 */
		wait_event(chip->shutdown_wait,
			   !atomic_read(&chip->usage_count));
Daniel Mack's avatar
Daniel Mack committed
681 682
		snd_card_disconnect(card);
		/* release the pcm resources */
683 684
		list_for_each_entry(as, &chip->pcm_list, list) {
			snd_usb_stream_disconnect(as);
Daniel Mack's avatar
Daniel Mack committed
685
		}
686
		/* release the endpoint resources */
687 688
		list_for_each_entry(ep, &chip->ep_list, list) {
			snd_usb_endpoint_release(ep);
689
		}
Daniel Mack's avatar
Daniel Mack committed
690 691 692 693 694
		/* release the midi resources */
		list_for_each(p, &chip->midi_list) {
			snd_usbmidi_disconnect(p);
		}
		/* release mixer resources */
695 696
		list_for_each_entry(mixer, &chip->mixer_list, list) {
			snd_usb_mixer_disconnect(mixer);
Daniel Mack's avatar
Daniel Mack committed
697
		}
698 699 700 701
	}

	chip->num_interfaces--;
	if (chip->num_interfaces <= 0) {
Daniel Mack's avatar
Daniel Mack committed
702 703 704 705 706 707 708 709
		usb_chip[chip->index] = NULL;
		mutex_unlock(&register_mutex);
		snd_card_free_when_closed(card);
	} else {
		mutex_unlock(&register_mutex);
	}
}

710 711
/* lock the shutdown (disconnect) task and autoresume */
int snd_usb_lock_shutdown(struct snd_usb_audio *chip)
712
{
713
	int err;
714

715 716 717 718 719 720 721 722 723
	atomic_inc(&chip->usage_count);
	if (atomic_read(&chip->shutdown)) {
		err = -EIO;
		goto error;
	}
	err = snd_usb_autoresume(chip);
	if (err < 0)
		goto error;
	return 0;
724

725 726 727
 error:
	if (atomic_dec_and_test(&chip->usage_count))
		wake_up(&chip->shutdown_wait);
728 729 730
	return err;
}

731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749
/* autosuspend and unlock the shutdown */
void snd_usb_unlock_shutdown(struct snd_usb_audio *chip)
{
	snd_usb_autosuspend(chip);
	if (atomic_dec_and_test(&chip->usage_count))
		wake_up(&chip->shutdown_wait);
}

#ifdef CONFIG_PM

int snd_usb_autoresume(struct snd_usb_audio *chip)
{
	if (atomic_read(&chip->shutdown))
		return -EIO;
	if (atomic_inc_return(&chip->active) == 1)
		return usb_autopm_get_interface(chip->pm_intf);
	return 0;
}

750 751
void snd_usb_autosuspend(struct snd_usb_audio *chip)
{
752 753
	if (atomic_read(&chip->shutdown))
		return;
754
	if (atomic_dec_and_test(&chip->active))
755 756 757
		usb_autopm_put_interface(chip->pm_intf);
}

Daniel Mack's avatar
Daniel Mack committed
758 759 760 761
static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message)
{
	struct snd_usb_audio *chip = usb_get_intfdata(intf);
	struct snd_usb_stream *as;
762
	struct usb_mixer_interface *mixer;
763
	struct list_head *p;
Daniel Mack's avatar
Daniel Mack committed
764 765 766 767

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

768 769
	chip->autosuspended = !!PMSG_IS_AUTO(message);
	if (!chip->autosuspended)
770
		snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
771 772 773 774 775
	if (!chip->num_suspended_intf++) {
		list_for_each_entry(as, &chip->pcm_list, list) {
			snd_pcm_suspend_all(as->pcm);
			as->substream[0].need_setup_ep =
				as->substream[1].need_setup_ep = true;
776
		}
777 778
		list_for_each(p, &chip->midi_list)
			snd_usbmidi_suspend(p);
779 780
		list_for_each_entry(mixer, &chip->mixer_list, list)
			snd_usb_mixer_suspend(mixer);
781
	}
782

Daniel Mack's avatar
Daniel Mack committed
783 784 785
	return 0;
}

786
static int __usb_audio_resume(struct usb_interface *intf, bool reset_resume)
Daniel Mack's avatar
Daniel Mack committed
787 788
{
	struct snd_usb_audio *chip = usb_get_intfdata(intf);
789
	struct usb_mixer_interface *mixer;
790
	struct list_head *p;
791
	int err = 0;
Daniel Mack's avatar
Daniel Mack committed
792 793 794 795 796

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

798
	atomic_inc(&chip->active); /* avoid autopm */
Daniel Mack's avatar
Daniel Mack committed
799 800
	/*
	 * ALSA leaves material resumption to user space
801
	 * we just notify and restart the mixers
Daniel Mack's avatar
Daniel Mack committed
802
	 */
803
	list_for_each_entry(mixer, &chip->mixer_list, list) {
804
		err = snd_usb_mixer_resume(mixer, reset_resume);
805 806 807
		if (err < 0)
			goto err_out;
	}
Daniel Mack's avatar
Daniel Mack committed
808

809 810 811 812
	list_for_each(p, &chip->midi_list) {
		snd_usbmidi_resume(p);
	}

813 814 815
	if (!chip->autosuspended)
		snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
	chip->autosuspended = 0;
Daniel Mack's avatar
Daniel Mack committed
816

817
err_out:
818
	atomic_dec(&chip->active); /* allow autopm after this point */
819
	return err;
Daniel Mack's avatar
Daniel Mack committed
820
}
821 822 823 824 825 826 827 828 829 830

static int usb_audio_resume(struct usb_interface *intf)
{
	return __usb_audio_resume(intf, false);
}

static int usb_audio_reset_resume(struct usb_interface *intf)
{
	return __usb_audio_resume(intf, true);
}
831 832 833
#else
#define usb_audio_suspend	NULL
#define usb_audio_resume	NULL
834
#define usb_audio_reset_resume	NULL
Daniel Mack's avatar
Daniel Mack committed
835 836
#endif		/* CONFIG_PM */

837
static const struct usb_device_id usb_audio_ids [] = {
Daniel Mack's avatar
Daniel Mack committed
838 839 840 841 842 843
#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 */
};
844
MODULE_DEVICE_TABLE(usb, usb_audio_ids);
Daniel Mack's avatar
Daniel Mack committed
845 846 847 848 849 850 851 852 853 854 855

/*
 * 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,
856
	.reset_resume =	usb_audio_reset_resume,
Daniel Mack's avatar
Daniel Mack committed
857
	.id_table =	usb_audio_ids,
858
	.supports_autosuspend = 1,
Daniel Mack's avatar
Daniel Mack committed
859 860
};

861
module_usb_driver(usb_audio_driver);