card.c 25.3 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
D
Daniel Mack 已提交
2 3 4 5 6 7 8 9 10
/*
 *   (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)
 *
11
 *   Audio Class 3.0 support by Ruslan Bilovol <ruslan.bilovol@gmail.com>
D
Daniel Mack 已提交
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 *
 *  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>
28
#include <linux/ctype.h>
D
Daniel Mack 已提交
29 30 31 32
#include <linux/usb.h>
#include <linux/moduleparam.h>
#include <linux/mutex.h>
#include <linux/usb/audio.h>
D
Daniel Mack 已提交
33
#include <linux/usb/audio-v2.h>
34
#include <linux/usb/audio-v3.h>
35
#include <linux/module.h>
D
Daniel Mack 已提交
36

37
#include <sound/control.h>
D
Daniel Mack 已提交
38 39 40 41 42 43 44 45 46
#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"
47
#include "mixer.h"
D
Daniel Mack 已提交
48 49 50 51 52 53 54
#include "proc.h"
#include "quirks.h"
#include "endpoint.h"
#include "helper.h"
#include "debug.h"
#include "pcm.h"
#include "format.h"
55
#include "power.h"
D
Daniel Mack 已提交
56
#include "stream.h"
57
#include "media.h"
D
Daniel Mack 已提交
58 59 60 61 62 63 64 65 66

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 */
67
static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */
D
Daniel Mack 已提交
68 69 70 71
/* 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 */
72
static bool ignore_ctl_error;
73
static bool autoclock = true;
74
static char *quirk_alias[SNDRV_CARDS];
75
static char *delayed_register[SNDRV_CARDS];
D
Daniel Mack 已提交
76

77
bool snd_usb_use_vmalloc = true;
78
bool snd_usb_skip_validation;
79

D
Daniel Mack 已提交
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
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.");
95 96
module_param(autoclock, bool, 0444);
MODULE_PARM_DESC(autoclock, "Enable auto-clock selection for UAC2 devices (default: yes).");
97 98
module_param_array(quirk_alias, charp, NULL, 0444);
MODULE_PARM_DESC(quirk_alias, "Quirk aliases, e.g. 0123abcd:5678beef.");
99 100
module_param_array(delayed_register, charp, NULL, 0444);
MODULE_PARM_DESC(delayed_register, "Quirk for delayed registration, given by id:iface, e.g. 0123abcd:4.");
101 102
module_param_named(use_vmalloc, snd_usb_use_vmalloc, bool, 0444);
MODULE_PARM_DESC(use_vmalloc, "Use vmalloc for PCM intermediate buffers (default: yes).");
103 104
module_param_named(skip_validation, snd_usb_skip_validation, bool, 0444);
MODULE_PARM_DESC(skip_validation, "Skip unit descriptor validation (default: no).");
D
Daniel Mack 已提交
105 106 107 108 109 110 111 112 113 114 115 116

/*
 * 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
117
 * called from usb_audio_disconnect()
D
Daniel Mack 已提交
118
 */
119
static void snd_usb_stream_disconnect(struct snd_usb_stream *as)
D
Daniel Mack 已提交
120 121 122 123 124 125 126
{
	int idx;
	struct snd_usb_substream *subs;

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

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) {
142 143
		dev_err(&dev->dev, "%u:%d : does not exist\n",
			ctrlif, interface);
D
Daniel Mack 已提交
144 145 146
		return -EINVAL;
	}

147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166
	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);
	}

D
Daniel Mack 已提交
167
	if (usb_interface_claimed(iface)) {
168 169
		dev_dbg(&dev->dev, "%d:%d: skipping, already claimed\n",
			ctrlif, interface);
D
Daniel Mack 已提交
170 171 172 173 174 175
		return -EINVAL;
	}

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

	if (snd_usb_get_speed(dev) == USB_SPEED_LOW) {
201
		dev_err(&dev->dev, "low speed audio streaming not supported\n");
D
Daniel Mack 已提交
202 203 204
		return -EINVAL;
	}

D
Daniel Mack 已提交
205
	if (! snd_usb_parse_audio_interface(chip, interface)) {
D
Daniel Mack 已提交
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
		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;
	int i, protocol;

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

	switch (protocol) {
229
	default:
230 231 232
		dev_warn(&dev->dev,
			 "unknown interface protocol %#02x, assuming v1\n",
			 protocol);
233 234
		/* fall through */

D
Daniel Mack 已提交
235
	case UAC_VERSION_1: {
236 237 238 239 240 241
		struct uac1_ac_header_descriptor *h1;
		int rest_bytes;

		h1 = snd_usb_find_csint_desc(host_iface->extra,
							 host_iface->extralen,
							 NULL, UAC_HEADER);
242
		if (!h1 || h1->bLength < sizeof(*h1)) {
243 244 245 246 247 248 249 250 251 252 253 254
			dev_err(&dev->dev, "cannot find UAC_HEADER\n");
			return -EINVAL;
		}

		rest_bytes = (void *)(host_iface->extra +
				host_iface->extralen) - (void *)h1;

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

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

D
Daniel Mack 已提交
261
		if (!h1->bInCollection) {
262
			dev_info(&dev->dev, "skipping empty audio interface (v1)\n");
D
Daniel Mack 已提交
263 264 265
			return -EINVAL;
		}

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

D
Daniel Mack 已提交
271
		if (h1->bLength < sizeof(*h1) + h1->bInCollection) {
272
			dev_err(&dev->dev, "invalid UAC_HEADER (v1)\n");
D
Daniel Mack 已提交
273 274 275 276 277 278 279 280 281
			return -EINVAL;
		}

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

		break;
	}

282 283
	case UAC_VERSION_2:
	case UAC_VERSION_3: {
D
Daniel Mack 已提交
284 285 286
		struct usb_interface_assoc_descriptor *assoc =
			usb_ifnum_to_if(dev, ctrlif)->intf_assoc;

287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
		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;
		}

D
Daniel Mack 已提交
302
		if (!assoc) {
303
			dev_err(&dev->dev, "Audio class v2/v3 interfaces need an interface association\n");
D
Daniel Mack 已提交
304 305 306
			return -EINVAL;
		}

307 308 309 310 311 312 313 314 315 316 317 318 319 320
		if (protocol == UAC_VERSION_3) {
			int badd = assoc->bFunctionSubClass;

			if (badd != UAC3_FUNCTION_SUBCLASS_FULL_ADC_3_0 &&
			    (badd < UAC3_FUNCTION_SUBCLASS_GENERIC_IO ||
			     badd > UAC3_FUNCTION_SUBCLASS_SPEAKERPHONE)) {
				dev_err(&dev->dev,
					"Unsupported UAC3 BADD profile\n");
				return -EINVAL;
			}

			chip->badd_profile = badd;
		}

D
Daniel Mack 已提交
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341
		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
 *
 */

342
static void snd_usb_audio_free(struct snd_card *card)
D
Daniel Mack 已提交
343
{
344
	struct snd_usb_audio *chip = card->private_data;
345
	struct snd_usb_endpoint *ep, *n;
346

347 348
	list_for_each_entry_safe(ep, n, &chip->ep_list, list)
		snd_usb_endpoint_free(ep);
349

350
	mutex_destroy(&chip->mutex);
351 352
	if (!atomic_read(&chip->shutdown))
		dev_set_drvdata(&chip->dev->dev, NULL);
D
Daniel Mack 已提交
353 354
}

355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
static void usb_audio_make_shortname(struct usb_device *dev,
				     struct snd_usb_audio *chip,
				     const struct snd_usb_audio_quirk *quirk)
{
	struct snd_card *card = chip->card;

	if (quirk && quirk->product_name && *quirk->product_name) {
		strlcpy(card->shortname, quirk->product_name,
			sizeof(card->shortname));
		return;
	}

	/* retrieve the device string as shortname */
	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));
	}

	strim(card->shortname);
}

static void usb_audio_make_longname(struct usb_device *dev,
				    struct snd_usb_audio *chip,
				    const struct snd_usb_audio_quirk *quirk)
{
	struct snd_card *card = chip->card;
	int len;

	/* shortcut - if any pre-defined string is given, use it */
	if (quirk && quirk->profile_name && *quirk->profile_name) {
		strlcpy(card->longname, quirk->profile_name,
			sizeof(card->longname));
		return;
	}

	if (quirk && quirk->vendor_name && *quirk->vendor_name) {
		len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname));
	} else {
		/* retrieve the vendor and device strings as longname */
		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) {
		strim(card->longname);
		if (*card->longname)
			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;
	case USB_SPEED_SUPER_PLUS:
		strlcat(card->longname, ", super speed plus", sizeof(card->longname));
		break;
	default:
		break;
	}
}

D
Daniel Mack 已提交
439 440 441
/*
 * create a chip instance and set its names.
 */
442 443
static int snd_usb_audio_create(struct usb_interface *intf,
				struct usb_device *dev, int idx,
D
Daniel Mack 已提交
444
				const struct snd_usb_audio_quirk *quirk,
445
				unsigned int usb_id,
D
Daniel Mack 已提交
446 447 448 449
				struct snd_usb_audio **rchip)
{
	struct snd_card *card;
	struct snd_usb_audio *chip;
450
	int err;
D
Daniel Mack 已提交
451 452 453 454
	char component[14];

	*rchip = NULL;

455 456 457 458
	switch (snd_usb_get_speed(dev)) {
	case USB_SPEED_LOW:
	case USB_SPEED_FULL:
	case USB_SPEED_HIGH:
459
	case USB_SPEED_WIRELESS:
460
	case USB_SPEED_SUPER:
461
	case USB_SPEED_SUPER_PLUS:
462 463
		break;
	default:
464
		dev_err(&dev->dev, "unknown device speed %d\n", snd_usb_get_speed(dev));
D
Daniel Mack 已提交
465 466 467
		return -ENXIO;
	}

468
	err = snd_card_new(&intf->dev, index[idx], id[idx], THIS_MODULE,
469
			   sizeof(*chip), &card);
D
Daniel Mack 已提交
470
	if (err < 0) {
471
		dev_err(&dev->dev, "cannot create card instance %d\n", idx);
D
Daniel Mack 已提交
472 473 474
		return err;
	}

475
	chip = card->private_data;
476
	mutex_init(&chip->mutex);
477
	init_waitqueue_head(&chip->shutdown_wait);
D
Daniel Mack 已提交
478 479 480 481
	chip->index = idx;
	chip->dev = dev;
	chip->card = card;
	chip->setup = device_setup[idx];
482
	chip->autoclock = autoclock;
483
	atomic_set(&chip->active, 1); /* avoid autopm during probing */
484 485
	atomic_set(&chip->usage_count, 0);
	atomic_set(&chip->shutdown, 0);
D
Daniel Mack 已提交
486

487
	chip->usb_id = usb_id;
D
Daniel Mack 已提交
488
	INIT_LIST_HEAD(&chip->pcm_list);
489
	INIT_LIST_HEAD(&chip->ep_list);
D
Daniel Mack 已提交
490 491 492
	INIT_LIST_HEAD(&chip->midi_list);
	INIT_LIST_HEAD(&chip->mixer_list);

493
	card->private_free = snd_usb_audio_free;
D
Daniel Mack 已提交
494 495 496 497 498 499

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

500 501
	usb_audio_make_shortname(dev, chip, quirk);
	usb_audio_make_longname(dev, chip, quirk);
D
Daniel Mack 已提交
502 503 504 505 506 507 508

	snd_usb_audio_create_proc(chip);

	*rchip = chip;
	return 0;
}

509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
/* 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;
}

531 532 533 534 535 536 537 538 539 540 541 542 543 544 545
static bool check_delayed_register_option(struct snd_usb_audio *chip, int iface)
{
	int i;
	unsigned int id, inum;

	for (i = 0; i < ARRAY_SIZE(delayed_register); i++) {
		if (delayed_register[i] &&
		    sscanf(delayed_register[i], "%x:%x", &id, &inum) == 2 &&
		    id == chip->usb_id)
			return inum != iface;
	}

	return false;
}

546
static const struct usb_device_id usb_audio_ids[]; /* defined below */
547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565

/* 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;
}

D
Daniel Mack 已提交
566 567 568 569 570 571 572 573 574 575
/*
 * 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.
 */
576 577
static int usb_audio_probe(struct usb_interface *intf,
			   const struct usb_device_id *usb_id)
D
Daniel Mack 已提交
578
{
579 580 581
	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;
D
Daniel Mack 已提交
582
	struct snd_usb_audio *chip;
583
	int i, err;
D
Daniel Mack 已提交
584 585 586 587 588 589 590 591
	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));
592 593
	if (get_alias_id(dev, &id))
		quirk = get_alias_quirk(dev, id);
D
Daniel Mack 已提交
594
	if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum)
595
		return -ENXIO;
D
Daniel Mack 已提交
596

597
	err = snd_usb_apply_boot_quirk(dev, intf, quirk, id);
598 599
	if (err < 0)
		return err;
D
Daniel Mack 已提交
600 601 602 603 604 605 606 607 608 609

	/*
	 * 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) {
610
			if (atomic_read(&usb_chip[i]->shutdown)) {
611
				dev_err(&dev->dev, "USB device is in the shutdown state, cannot create a card instance\n");
612
				err = -EIO;
D
Daniel Mack 已提交
613 614 615
				goto __error;
			}
			chip = usb_chip[i];
616
			atomic_inc(&chip->active); /* avoid autopm */
D
Daniel Mack 已提交
617 618 619 620
			break;
		}
	}
	if (! chip) {
621 622
		err = snd_usb_apply_boot_quirk_once(dev, intf, quirk, id);
		if (err < 0)
623
			goto __error;
624

D
Daniel Mack 已提交
625 626 627 628
		/* it's a fresh one.
		 * now look for an empty slot and create a new card instance
		 */
		for (i = 0; i < SNDRV_CARDS; i++)
629
			if (!usb_chip[i] &&
D
Daniel Mack 已提交
630 631
			    (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) &&
			    (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) {
632 633 634 635 636 637 638 639 640 641 642 643 644
				if (enable[i]) {
					err = snd_usb_audio_create(intf, dev, i, quirk,
								   id, &chip);
					if (err < 0)
						goto __error;
					chip->pm_intf = intf;
					break;
				} else if (vid[i] != -1 || pid[i] != -1) {
					dev_info(&dev->dev,
						 "device (%04x:%04x) is disabled\n",
						 USB_ID_VENDOR(id),
						 USB_ID_PRODUCT(id));
					err = -ENOENT;
D
Daniel Mack 已提交
645
					goto __error;
646
				}
D
Daniel Mack 已提交
647 648
			}
		if (!chip) {
649
			dev_err(&dev->dev, "no available usb audio device\n");
650
			err = -ENODEV;
D
Daniel Mack 已提交
651 652 653
			goto __error;
		}
	}
654
	dev_set_drvdata(&dev->dev, chip);
D
Daniel Mack 已提交
655

656 657 658 659 660 661 662
	/*
	 * 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;
663

664 665 666 667
	chip->txfr_quirk = 0;
	err = 1; /* continue */
	if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) {
		/* need some special handlings */
668 669
		err = snd_usb_create_quirk(chip, intf, &usb_audio_driver, quirk);
		if (err < 0)
670 671 672
			goto __error;
	}

D
Daniel Mack 已提交
673 674
	if (err > 0) {
		/* create normal USB audio interfaces */
675 676 677 678 679
		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)
D
Daniel Mack 已提交
680 681 682
			goto __error;
	}

683 684 685 686 687 688 689
	if (chip->need_delayed_register) {
		dev_info(&dev->dev,
			 "Found post-registration device assignment: %08x:%02x\n",
			 chip->usb_id, ifnum);
		chip->need_delayed_register = false; /* clear again */
	}

690 691 692
	/* we are allowed to call snd_card_register() many times, but first
	 * check to see if a device needs to skip it or do anything special
	 */
693 694
	if (!snd_usb_registration_quirk(chip, ifnum) &&
	    !check_delayed_register_option(chip, ifnum)) {
695 696 697 698
		err = snd_card_register(chip->card);
		if (err < 0)
			goto __error;
	}
D
Daniel Mack 已提交
699

700 701 702 703 704
	if (quirk && quirk->shares_media_device) {
		/* don't want to fail when snd_media_device_create() fails */
		snd_media_device_create(chip, intf);
	}

D
Daniel Mack 已提交
705 706
	usb_chip[chip->index] = chip;
	chip->num_interfaces++;
707
	usb_set_intfdata(intf, chip);
708
	atomic_dec(&chip->active);
D
Daniel Mack 已提交
709
	mutex_unlock(&register_mutex);
710
	return 0;
D
Daniel Mack 已提交
711 712

 __error:
713
	if (chip) {
714 715 716 717
		/* chip->active is inside the chip->card object,
		 * decrement before memory is possibly returned.
		 */
		atomic_dec(&chip->active);
718 719 720
		if (!chip->num_interfaces)
			snd_card_free(chip->card);
	}
D
Daniel Mack 已提交
721
	mutex_unlock(&register_mutex);
722
	return err;
D
Daniel Mack 已提交
723 724 725 726 727 728
}

/*
 * we need to take care of counter, since disconnection can be called also
 * many times as well as usb_audio_probe().
 */
729
static void usb_audio_disconnect(struct usb_interface *intf)
D
Daniel Mack 已提交
730
{
731
	struct snd_usb_audio *chip = usb_get_intfdata(intf);
D
Daniel Mack 已提交
732
	struct snd_card *card;
733
	struct list_head *p;
D
Daniel Mack 已提交
734

735
	if (chip == (void *)-1L)
D
Daniel Mack 已提交
736 737 738
		return;

	card = chip->card;
739 740

	mutex_lock(&register_mutex);
741
	if (atomic_inc_return(&chip->shutdown) == 1) {
742
		struct snd_usb_stream *as;
743
		struct snd_usb_endpoint *ep;
744
		struct usb_mixer_interface *mixer;
745

746 747 748 749 750
		/* wait until all pending tasks done;
		 * they are protected by snd_usb_lock_shutdown()
		 */
		wait_event(chip->shutdown_wait,
			   !atomic_read(&chip->usage_count));
D
Daniel Mack 已提交
751 752
		snd_card_disconnect(card);
		/* release the pcm resources */
753 754
		list_for_each_entry(as, &chip->pcm_list, list) {
			snd_usb_stream_disconnect(as);
D
Daniel Mack 已提交
755
		}
756
		/* release the endpoint resources */
757 758
		list_for_each_entry(ep, &chip->ep_list, list) {
			snd_usb_endpoint_release(ep);
759
		}
D
Daniel Mack 已提交
760 761 762 763
		/* release the midi resources */
		list_for_each(p, &chip->midi_list) {
			snd_usbmidi_disconnect(p);
		}
764 765 766 767 768 769 770 771
		/*
		 * Nice to check quirk && quirk->shares_media_device and
		 * then call the snd_media_device_delete(). Don't have
		 * access to the quirk here. snd_media_device_delete()
		 * accesses mixer_list
		 */
		snd_media_device_delete(chip);

D
Daniel Mack 已提交
772
		/* release mixer resources */
773 774
		list_for_each_entry(mixer, &chip->mixer_list, list) {
			snd_usb_mixer_disconnect(mixer);
D
Daniel Mack 已提交
775
		}
776 777 778 779
	}

	chip->num_interfaces--;
	if (chip->num_interfaces <= 0) {
D
Daniel Mack 已提交
780 781 782 783 784 785 786 787
		usb_chip[chip->index] = NULL;
		mutex_unlock(&register_mutex);
		snd_card_free_when_closed(card);
	} else {
		mutex_unlock(&register_mutex);
	}
}

788 789
/* lock the shutdown (disconnect) task and autoresume */
int snd_usb_lock_shutdown(struct snd_usb_audio *chip)
790
{
791
	int err;
792

793 794 795 796 797 798 799 800 801
	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;
802

803 804 805
 error:
	if (atomic_dec_and_test(&chip->usage_count))
		wake_up(&chip->shutdown_wait);
806 807 808
	return err;
}

809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827
/* 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;
}

828 829
void snd_usb_autosuspend(struct snd_usb_audio *chip)
{
830 831
	if (atomic_read(&chip->shutdown))
		return;
832
	if (atomic_dec_and_test(&chip->active))
833 834 835
		usb_autopm_put_interface(chip->pm_intf);
}

D
Daniel Mack 已提交
836 837 838 839
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;
840
	struct usb_mixer_interface *mixer;
841
	struct list_head *p;
D
Daniel Mack 已提交
842 843 844 845

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

846 847
	if (!chip->num_suspended_intf++) {
		list_for_each_entry(as, &chip->pcm_list, list) {
848
			snd_usb_pcm_suspend(as);
849 850
			as->substream[0].need_setup_ep =
				as->substream[1].need_setup_ep = true;
851
		}
852 853
		list_for_each(p, &chip->midi_list)
			snd_usbmidi_suspend(p);
854 855
		list_for_each_entry(mixer, &chip->mixer_list, list)
			snd_usb_mixer_suspend(mixer);
856
	}
857

858 859 860 861 862
	if (!PMSG_IS_AUTO(message) && !chip->system_suspend) {
		snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot);
		chip->system_suspend = chip->num_suspended_intf;
	}

D
Daniel Mack 已提交
863 864 865
	return 0;
}

866
static int __usb_audio_resume(struct usb_interface *intf, bool reset_resume)
D
Daniel Mack 已提交
867 868
{
	struct snd_usb_audio *chip = usb_get_intfdata(intf);
869
	struct snd_usb_stream *as;
870
	struct usb_mixer_interface *mixer;
871
	struct list_head *p;
872
	int err = 0;
D
Daniel Mack 已提交
873 874 875

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

877
	atomic_inc(&chip->active); /* avoid autopm */
878 879
	if (chip->num_suspended_intf > 1)
		goto out;
880 881 882 883 884 885 886

	list_for_each_entry(as, &chip->pcm_list, list) {
		err = snd_usb_pcm_resume(as);
		if (err < 0)
			goto err_out;
	}

D
Daniel Mack 已提交
887 888
	/*
	 * ALSA leaves material resumption to user space
889
	 * we just notify and restart the mixers
D
Daniel Mack 已提交
890
	 */
891
	list_for_each_entry(mixer, &chip->mixer_list, list) {
892
		err = snd_usb_mixer_resume(mixer, reset_resume);
893 894 895
		if (err < 0)
			goto err_out;
	}
D
Daniel Mack 已提交
896

897 898 899 900
	list_for_each(p, &chip->midi_list) {
		snd_usbmidi_resume(p);
	}

901 902
 out:
	if (chip->num_suspended_intf == chip->system_suspend) {
903
		snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0);
904 905 906
		chip->system_suspend = 0;
	}
	chip->num_suspended_intf--;
D
Daniel Mack 已提交
907

908
err_out:
909
	atomic_dec(&chip->active); /* allow autopm after this point */
910
	return err;
D
Daniel Mack 已提交
911
}
912 913 914 915 916 917 918 919 920 921

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);
}
922 923 924
#else
#define usb_audio_suspend	NULL
#define usb_audio_resume	NULL
925
#define usb_audio_reset_resume	NULL
D
Daniel Mack 已提交
926 927
#endif		/* CONFIG_PM */

928
static const struct usb_device_id usb_audio_ids [] = {
D
Daniel Mack 已提交
929 930 931 932 933 934
#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 */
};
935
MODULE_DEVICE_TABLE(usb, usb_audio_ids);
D
Daniel Mack 已提交
936 937 938 939 940 941 942 943 944 945 946

/*
 * 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,
947
	.reset_resume =	usb_audio_reset_resume,
D
Daniel Mack 已提交
948
	.id_table =	usb_audio_ids,
949
	.supports_autosuspend = 1,
D
Daniel Mack 已提交
950 951
};

952
module_usb_driver(usb_audio_driver);