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/ctype.h> 45 #include <linux/usb.h> 46 #include <linux/moduleparam.h> 47 #include <linux/mutex.h> 48 #include <linux/usb/audio.h> 49 #include <linux/usb/audio-v2.h> 50 #include <linux/module.h> 51 52 #include <sound/control.h> 53 #include <sound/core.h> 54 #include <sound/info.h> 55 #include <sound/pcm.h> 56 #include <sound/pcm_params.h> 57 #include <sound/initval.h> 58 59 #include "usbaudio.h" 60 #include "card.h" 61 #include "midi.h" 62 #include "mixer.h" 63 #include "proc.h" 64 #include "quirks.h" 65 #include "endpoint.h" 66 #include "helper.h" 67 #include "debug.h" 68 #include "pcm.h" 69 #include "format.h" 70 #include "power.h" 71 #include "stream.h" 72 73 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>"); 74 MODULE_DESCRIPTION("USB Audio"); 75 MODULE_LICENSE("GPL"); 76 MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}"); 77 78 79 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 80 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 81 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;/* Enable this card */ 82 /* Vendor/product IDs for this card */ 83 static int vid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; 84 static int pid[SNDRV_CARDS] = { [0 ... (SNDRV_CARDS-1)] = -1 }; 85 static int nrpacks = 8; /* max. number of packets per urb */ 86 static bool async_unlink = 1; 87 static int device_setup[SNDRV_CARDS]; /* device parameter for this card */ 88 static bool ignore_ctl_error; 89 90 module_param_array(index, int, NULL, 0444); 91 MODULE_PARM_DESC(index, "Index value for the USB audio adapter."); 92 module_param_array(id, charp, NULL, 0444); 93 MODULE_PARM_DESC(id, "ID string for the USB audio adapter."); 94 module_param_array(enable, bool, NULL, 0444); 95 MODULE_PARM_DESC(enable, "Enable USB audio adapter."); 96 module_param_array(vid, int, NULL, 0444); 97 MODULE_PARM_DESC(vid, "Vendor ID for the USB audio device."); 98 module_param_array(pid, int, NULL, 0444); 99 MODULE_PARM_DESC(pid, "Product ID for the USB audio device."); 100 module_param(nrpacks, int, 0644); 101 MODULE_PARM_DESC(nrpacks, "Max. number of packets per URB."); 102 module_param(async_unlink, bool, 0444); 103 MODULE_PARM_DESC(async_unlink, "Use async unlink mode."); 104 module_param_array(device_setup, int, NULL, 0444); 105 MODULE_PARM_DESC(device_setup, "Specific device setup (if needed)."); 106 module_param(ignore_ctl_error, bool, 0444); 107 MODULE_PARM_DESC(ignore_ctl_error, 108 "Ignore errors from USB controller for mixer interfaces."); 109 110 /* 111 * we keep the snd_usb_audio_t instances by ourselves for merging 112 * the all interfaces on the same card as one sound device. 113 */ 114 115 static DEFINE_MUTEX(register_mutex); 116 static struct snd_usb_audio *usb_chip[SNDRV_CARDS]; 117 static struct usb_driver usb_audio_driver; 118 119 /* 120 * disconnect streams 121 * called from snd_usb_audio_disconnect() 122 */ 123 static void snd_usb_stream_disconnect(struct list_head *head) 124 { 125 int idx; 126 struct snd_usb_stream *as; 127 struct snd_usb_substream *subs; 128 129 as = list_entry(head, struct snd_usb_stream, list); 130 for (idx = 0; idx < 2; idx++) { 131 subs = &as->substream[idx]; 132 if (!subs->num_formats) 133 continue; 134 subs->interface = -1; 135 subs->data_endpoint = NULL; 136 subs->sync_endpoint = NULL; 137 } 138 } 139 140 static int snd_usb_create_stream(struct snd_usb_audio *chip, int ctrlif, int interface) 141 { 142 struct usb_device *dev = chip->dev; 143 struct usb_host_interface *alts; 144 struct usb_interface_descriptor *altsd; 145 struct usb_interface *iface = usb_ifnum_to_if(dev, interface); 146 147 if (!iface) { 148 snd_printk(KERN_ERR "%d:%u:%d : does not exist\n", 149 dev->devnum, ctrlif, interface); 150 return -EINVAL; 151 } 152 153 if (usb_interface_claimed(iface)) { 154 snd_printdd(KERN_INFO "%d:%d:%d: skipping, already claimed\n", 155 dev->devnum, ctrlif, interface); 156 return -EINVAL; 157 } 158 159 alts = &iface->altsetting[0]; 160 altsd = get_iface_desc(alts); 161 if ((altsd->bInterfaceClass == USB_CLASS_AUDIO || 162 altsd->bInterfaceClass == USB_CLASS_VENDOR_SPEC) && 163 altsd->bInterfaceSubClass == USB_SUBCLASS_MIDISTREAMING) { 164 int err = snd_usbmidi_create(chip->card, iface, 165 &chip->midi_list, NULL); 166 if (err < 0) { 167 snd_printk(KERN_ERR "%d:%u:%d: cannot create sequencer device\n", 168 dev->devnum, ctrlif, interface); 169 return -EINVAL; 170 } 171 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L); 172 173 return 0; 174 } 175 176 if ((altsd->bInterfaceClass != USB_CLASS_AUDIO && 177 altsd->bInterfaceClass != USB_CLASS_VENDOR_SPEC) || 178 altsd->bInterfaceSubClass != USB_SUBCLASS_AUDIOSTREAMING) { 179 snd_printdd(KERN_ERR "%d:%u:%d: skipping non-supported interface %d\n", 180 dev->devnum, ctrlif, interface, altsd->bInterfaceClass); 181 /* skip non-supported classes */ 182 return -EINVAL; 183 } 184 185 if (snd_usb_get_speed(dev) == USB_SPEED_LOW) { 186 snd_printk(KERN_ERR "low speed audio streaming not supported\n"); 187 return -EINVAL; 188 } 189 190 if (! snd_usb_parse_audio_interface(chip, interface)) { 191 usb_set_interface(dev, interface, 0); /* reset the current interface */ 192 usb_driver_claim_interface(&usb_audio_driver, iface, (void *)-1L); 193 return -EINVAL; 194 } 195 196 return 0; 197 } 198 199 /* 200 * parse audio control descriptor and create pcm/midi streams 201 */ 202 static int snd_usb_create_streams(struct snd_usb_audio *chip, int ctrlif) 203 { 204 struct usb_device *dev = chip->dev; 205 struct usb_host_interface *host_iface; 206 struct usb_interface_descriptor *altsd; 207 void *control_header; 208 int i, protocol; 209 210 /* find audiocontrol interface */ 211 host_iface = &usb_ifnum_to_if(dev, ctrlif)->altsetting[0]; 212 control_header = snd_usb_find_csint_desc(host_iface->extra, 213 host_iface->extralen, 214 NULL, UAC_HEADER); 215 altsd = get_iface_desc(host_iface); 216 protocol = altsd->bInterfaceProtocol; 217 218 if (!control_header) { 219 snd_printk(KERN_ERR "cannot find UAC_HEADER\n"); 220 return -EINVAL; 221 } 222 223 switch (protocol) { 224 default: 225 snd_printdd(KERN_WARNING "unknown interface protocol %#02x, assuming v1\n", 226 protocol); 227 /* fall through */ 228 229 case UAC_VERSION_1: { 230 struct uac1_ac_header_descriptor *h1 = control_header; 231 232 if (!h1->bInCollection) { 233 snd_printk(KERN_INFO "skipping empty audio interface (v1)\n"); 234 return -EINVAL; 235 } 236 237 if (h1->bLength < sizeof(*h1) + h1->bInCollection) { 238 snd_printk(KERN_ERR "invalid UAC_HEADER (v1)\n"); 239 return -EINVAL; 240 } 241 242 for (i = 0; i < h1->bInCollection; i++) 243 snd_usb_create_stream(chip, ctrlif, h1->baInterfaceNr[i]); 244 245 break; 246 } 247 248 case UAC_VERSION_2: { 249 struct usb_interface_assoc_descriptor *assoc = 250 usb_ifnum_to_if(dev, ctrlif)->intf_assoc; 251 252 if (!assoc) { 253 snd_printk(KERN_ERR "Audio class v2 interfaces need an interface association\n"); 254 return -EINVAL; 255 } 256 257 for (i = 0; i < assoc->bInterfaceCount; i++) { 258 int intf = assoc->bFirstInterface + i; 259 260 if (intf != ctrlif) 261 snd_usb_create_stream(chip, ctrlif, intf); 262 } 263 264 break; 265 } 266 } 267 268 return 0; 269 } 270 271 /* 272 * free the chip instance 273 * 274 * here we have to do not much, since pcm and controls are already freed 275 * 276 */ 277 278 static int snd_usb_audio_free(struct snd_usb_audio *chip) 279 { 280 mutex_destroy(&chip->mutex); 281 kfree(chip); 282 return 0; 283 } 284 285 static int snd_usb_audio_dev_free(struct snd_device *device) 286 { 287 struct snd_usb_audio *chip = device->device_data; 288 return snd_usb_audio_free(chip); 289 } 290 291 static void remove_trailing_spaces(char *str) 292 { 293 char *p; 294 295 if (!*str) 296 return; 297 for (p = str + strlen(str) - 1; p >= str && isspace(*p); p--) 298 *p = 0; 299 } 300 301 /* 302 * create a chip instance and set its names. 303 */ 304 static int snd_usb_audio_create(struct usb_device *dev, int idx, 305 const struct snd_usb_audio_quirk *quirk, 306 struct snd_usb_audio **rchip) 307 { 308 struct snd_card *card; 309 struct snd_usb_audio *chip; 310 int err, len; 311 char component[14]; 312 static struct snd_device_ops ops = { 313 .dev_free = snd_usb_audio_dev_free, 314 }; 315 316 *rchip = NULL; 317 318 switch (snd_usb_get_speed(dev)) { 319 case USB_SPEED_LOW: 320 case USB_SPEED_FULL: 321 case USB_SPEED_HIGH: 322 case USB_SPEED_SUPER: 323 break; 324 default: 325 snd_printk(KERN_ERR "unknown device speed %d\n", snd_usb_get_speed(dev)); 326 return -ENXIO; 327 } 328 329 err = snd_card_create(index[idx], id[idx], THIS_MODULE, 0, &card); 330 if (err < 0) { 331 snd_printk(KERN_ERR "cannot create card instance %d\n", idx); 332 return err; 333 } 334 335 chip = kzalloc(sizeof(*chip), GFP_KERNEL); 336 if (! chip) { 337 snd_card_free(card); 338 return -ENOMEM; 339 } 340 341 mutex_init(&chip->mutex); 342 mutex_init(&chip->shutdown_mutex); 343 chip->index = idx; 344 chip->dev = dev; 345 chip->card = card; 346 chip->setup = device_setup[idx]; 347 chip->nrpacks = nrpacks; 348 chip->async_unlink = async_unlink; 349 chip->probing = 1; 350 351 chip->usb_id = USB_ID(le16_to_cpu(dev->descriptor.idVendor), 352 le16_to_cpu(dev->descriptor.idProduct)); 353 INIT_LIST_HEAD(&chip->pcm_list); 354 INIT_LIST_HEAD(&chip->ep_list); 355 INIT_LIST_HEAD(&chip->midi_list); 356 INIT_LIST_HEAD(&chip->mixer_list); 357 358 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) { 359 snd_usb_audio_free(chip); 360 snd_card_free(card); 361 return err; 362 } 363 364 strcpy(card->driver, "USB-Audio"); 365 sprintf(component, "USB%04x:%04x", 366 USB_ID_VENDOR(chip->usb_id), USB_ID_PRODUCT(chip->usb_id)); 367 snd_component_add(card, component); 368 369 /* retrieve the device string as shortname */ 370 if (quirk && quirk->product_name && *quirk->product_name) { 371 strlcpy(card->shortname, quirk->product_name, sizeof(card->shortname)); 372 } else { 373 if (!dev->descriptor.iProduct || 374 usb_string(dev, dev->descriptor.iProduct, 375 card->shortname, sizeof(card->shortname)) <= 0) { 376 /* no name available from anywhere, so use ID */ 377 sprintf(card->shortname, "USB Device %#04x:%#04x", 378 USB_ID_VENDOR(chip->usb_id), 379 USB_ID_PRODUCT(chip->usb_id)); 380 } 381 } 382 remove_trailing_spaces(card->shortname); 383 384 /* retrieve the vendor and device strings as longname */ 385 if (quirk && quirk->vendor_name && *quirk->vendor_name) { 386 len = strlcpy(card->longname, quirk->vendor_name, sizeof(card->longname)); 387 } else { 388 if (dev->descriptor.iManufacturer) 389 len = usb_string(dev, dev->descriptor.iManufacturer, 390 card->longname, sizeof(card->longname)); 391 else 392 len = 0; 393 /* we don't really care if there isn't any vendor string */ 394 } 395 if (len > 0) { 396 remove_trailing_spaces(card->longname); 397 if (*card->longname) 398 strlcat(card->longname, " ", sizeof(card->longname)); 399 } 400 401 strlcat(card->longname, card->shortname, sizeof(card->longname)); 402 403 len = strlcat(card->longname, " at ", sizeof(card->longname)); 404 405 if (len < sizeof(card->longname)) 406 usb_make_path(dev, card->longname + len, sizeof(card->longname) - len); 407 408 switch (snd_usb_get_speed(dev)) { 409 case USB_SPEED_LOW: 410 strlcat(card->longname, ", low speed", sizeof(card->longname)); 411 break; 412 case USB_SPEED_FULL: 413 strlcat(card->longname, ", full speed", sizeof(card->longname)); 414 break; 415 case USB_SPEED_HIGH: 416 strlcat(card->longname, ", high speed", sizeof(card->longname)); 417 break; 418 case USB_SPEED_SUPER: 419 strlcat(card->longname, ", super speed", sizeof(card->longname)); 420 break; 421 default: 422 break; 423 } 424 425 snd_usb_audio_create_proc(chip); 426 427 *rchip = chip; 428 return 0; 429 } 430 431 /* 432 * probe the active usb device 433 * 434 * note that this can be called multiple times per a device, when it 435 * includes multiple audio control interfaces. 436 * 437 * thus we check the usb device pointer and creates the card instance 438 * only at the first time. the successive calls of this function will 439 * append the pcm interface to the corresponding card. 440 */ 441 static struct snd_usb_audio * 442 snd_usb_audio_probe(struct usb_device *dev, 443 struct usb_interface *intf, 444 const struct usb_device_id *usb_id) 445 { 446 const struct snd_usb_audio_quirk *quirk = (const struct snd_usb_audio_quirk *)usb_id->driver_info; 447 int i, err; 448 struct snd_usb_audio *chip; 449 struct usb_host_interface *alts; 450 int ifnum; 451 u32 id; 452 453 alts = &intf->altsetting[0]; 454 ifnum = get_iface_desc(alts)->bInterfaceNumber; 455 id = USB_ID(le16_to_cpu(dev->descriptor.idVendor), 456 le16_to_cpu(dev->descriptor.idProduct)); 457 if (quirk && quirk->ifnum >= 0 && ifnum != quirk->ifnum) 458 goto __err_val; 459 460 if (snd_usb_apply_boot_quirk(dev, intf, quirk) < 0) 461 goto __err_val; 462 463 /* 464 * found a config. now register to ALSA 465 */ 466 467 /* check whether it's already registered */ 468 chip = NULL; 469 mutex_lock(®ister_mutex); 470 for (i = 0; i < SNDRV_CARDS; i++) { 471 if (usb_chip[i] && usb_chip[i]->dev == dev) { 472 if (usb_chip[i]->shutdown) { 473 snd_printk(KERN_ERR "USB device is in the shutdown state, cannot create a card instance\n"); 474 goto __error; 475 } 476 chip = usb_chip[i]; 477 chip->probing = 1; 478 break; 479 } 480 } 481 if (! chip) { 482 /* it's a fresh one. 483 * now look for an empty slot and create a new card instance 484 */ 485 for (i = 0; i < SNDRV_CARDS; i++) 486 if (enable[i] && ! usb_chip[i] && 487 (vid[i] == -1 || vid[i] == USB_ID_VENDOR(id)) && 488 (pid[i] == -1 || pid[i] == USB_ID_PRODUCT(id))) { 489 if (snd_usb_audio_create(dev, i, quirk, &chip) < 0) { 490 goto __error; 491 } 492 snd_card_set_dev(chip->card, &intf->dev); 493 chip->pm_intf = intf; 494 break; 495 } 496 if (!chip) { 497 printk(KERN_ERR "no available usb audio device\n"); 498 goto __error; 499 } 500 } 501 502 /* 503 * For devices with more than one control interface, we assume the 504 * first contains the audio controls. We might need a more specific 505 * check here in the future. 506 */ 507 if (!chip->ctrl_intf) 508 chip->ctrl_intf = alts; 509 510 chip->txfr_quirk = 0; 511 err = 1; /* continue */ 512 if (quirk && quirk->ifnum != QUIRK_NO_INTERFACE) { 513 /* need some special handlings */ 514 if ((err = snd_usb_create_quirk(chip, intf, &usb_audio_driver, quirk)) < 0) 515 goto __error; 516 } 517 518 if (err > 0) { 519 /* create normal USB audio interfaces */ 520 if (snd_usb_create_streams(chip, ifnum) < 0 || 521 snd_usb_create_mixer(chip, ifnum, ignore_ctl_error) < 0) { 522 goto __error; 523 } 524 } 525 526 /* we are allowed to call snd_card_register() many times */ 527 if (snd_card_register(chip->card) < 0) { 528 goto __error; 529 } 530 531 usb_chip[chip->index] = chip; 532 chip->num_interfaces++; 533 chip->probing = 0; 534 mutex_unlock(®ister_mutex); 535 return chip; 536 537 __error: 538 if (chip) { 539 if (!chip->num_interfaces) 540 snd_card_free(chip->card); 541 chip->probing = 0; 542 } 543 mutex_unlock(®ister_mutex); 544 __err_val: 545 return NULL; 546 } 547 548 /* 549 * we need to take care of counter, since disconnection can be called also 550 * many times as well as usb_audio_probe(). 551 */ 552 static void snd_usb_audio_disconnect(struct usb_device *dev, 553 struct snd_usb_audio *chip) 554 { 555 struct snd_card *card; 556 struct list_head *p, *n; 557 558 if (chip == (void *)-1L) 559 return; 560 561 card = chip->card; 562 mutex_lock(®ister_mutex); 563 mutex_lock(&chip->shutdown_mutex); 564 chip->shutdown = 1; 565 chip->num_interfaces--; 566 if (chip->num_interfaces <= 0) { 567 snd_card_disconnect(card); 568 /* release the pcm resources */ 569 list_for_each(p, &chip->pcm_list) { 570 snd_usb_stream_disconnect(p); 571 } 572 /* release the endpoint resources */ 573 list_for_each_safe(p, n, &chip->ep_list) { 574 snd_usb_endpoint_free(p); 575 } 576 /* release the midi resources */ 577 list_for_each(p, &chip->midi_list) { 578 snd_usbmidi_disconnect(p); 579 } 580 /* release mixer resources */ 581 list_for_each(p, &chip->mixer_list) { 582 snd_usb_mixer_disconnect(p); 583 } 584 usb_chip[chip->index] = NULL; 585 mutex_unlock(&chip->shutdown_mutex); 586 mutex_unlock(®ister_mutex); 587 snd_card_free_when_closed(card); 588 } else { 589 mutex_unlock(&chip->shutdown_mutex); 590 mutex_unlock(®ister_mutex); 591 } 592 } 593 594 /* 595 * new 2.5 USB kernel API 596 */ 597 static int usb_audio_probe(struct usb_interface *intf, 598 const struct usb_device_id *id) 599 { 600 struct snd_usb_audio *chip; 601 chip = snd_usb_audio_probe(interface_to_usbdev(intf), intf, id); 602 if (chip) { 603 usb_set_intfdata(intf, chip); 604 return 0; 605 } else 606 return -EIO; 607 } 608 609 static void usb_audio_disconnect(struct usb_interface *intf) 610 { 611 snd_usb_audio_disconnect(interface_to_usbdev(intf), 612 usb_get_intfdata(intf)); 613 } 614 615 #ifdef CONFIG_PM 616 617 int snd_usb_autoresume(struct snd_usb_audio *chip) 618 { 619 int err = -ENODEV; 620 621 if (!chip->shutdown && !chip->probing) 622 err = usb_autopm_get_interface(chip->pm_intf); 623 624 return err; 625 } 626 627 void snd_usb_autosuspend(struct snd_usb_audio *chip) 628 { 629 if (!chip->shutdown && !chip->probing) 630 usb_autopm_put_interface(chip->pm_intf); 631 } 632 633 static int usb_audio_suspend(struct usb_interface *intf, pm_message_t message) 634 { 635 struct snd_usb_audio *chip = usb_get_intfdata(intf); 636 struct list_head *p; 637 struct snd_usb_stream *as; 638 struct usb_mixer_interface *mixer; 639 640 if (chip == (void *)-1L) 641 return 0; 642 643 if (!PMSG_IS_AUTO(message)) { 644 snd_power_change_state(chip->card, SNDRV_CTL_POWER_D3hot); 645 if (!chip->num_suspended_intf++) { 646 list_for_each(p, &chip->pcm_list) { 647 as = list_entry(p, struct snd_usb_stream, list); 648 snd_pcm_suspend_all(as->pcm); 649 as->substream[0].need_setup_ep = 650 as->substream[1].need_setup_ep = true; 651 } 652 } 653 } else { 654 /* 655 * otherwise we keep the rest of the system in the dark 656 * to keep this transparent 657 */ 658 if (!chip->num_suspended_intf++) 659 chip->autosuspended = 1; 660 } 661 662 list_for_each_entry(mixer, &chip->mixer_list, list) 663 snd_usb_mixer_inactivate(mixer); 664 665 return 0; 666 } 667 668 static int usb_audio_resume(struct usb_interface *intf) 669 { 670 struct snd_usb_audio *chip = usb_get_intfdata(intf); 671 struct usb_mixer_interface *mixer; 672 int err = 0; 673 674 if (chip == (void *)-1L) 675 return 0; 676 if (--chip->num_suspended_intf) 677 return 0; 678 /* 679 * ALSA leaves material resumption to user space 680 * we just notify and restart the mixers 681 */ 682 list_for_each_entry(mixer, &chip->mixer_list, list) { 683 err = snd_usb_mixer_activate(mixer); 684 if (err < 0) 685 goto err_out; 686 } 687 688 if (!chip->autosuspended) 689 snd_power_change_state(chip->card, SNDRV_CTL_POWER_D0); 690 chip->autosuspended = 0; 691 692 err_out: 693 return err; 694 } 695 #else 696 #define usb_audio_suspend NULL 697 #define usb_audio_resume NULL 698 #endif /* CONFIG_PM */ 699 700 static struct usb_device_id usb_audio_ids [] = { 701 #include "quirks-table.h" 702 { .match_flags = (USB_DEVICE_ID_MATCH_INT_CLASS | USB_DEVICE_ID_MATCH_INT_SUBCLASS), 703 .bInterfaceClass = USB_CLASS_AUDIO, 704 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL }, 705 { } /* Terminating entry */ 706 }; 707 708 MODULE_DEVICE_TABLE (usb, usb_audio_ids); 709 710 /* 711 * entry point for linux usb interface 712 */ 713 714 static struct usb_driver usb_audio_driver = { 715 .name = "snd-usb-audio", 716 .probe = usb_audio_probe, 717 .disconnect = usb_audio_disconnect, 718 .suspend = usb_audio_suspend, 719 .resume = usb_audio_resume, 720 .id_table = usb_audio_ids, 721 .supports_autosuspend = 1, 722 }; 723 724 static int __init snd_usb_audio_init(void) 725 { 726 if (nrpacks < 1 || nrpacks > MAX_PACKS) { 727 printk(KERN_WARNING "invalid nrpacks value.\n"); 728 return -EINVAL; 729 } 730 return usb_register(&usb_audio_driver); 731 } 732 733 static void __exit snd_usb_audio_cleanup(void) 734 { 735 usb_deregister(&usb_audio_driver); 736 } 737 738 module_init(snd_usb_audio_init); 739 module_exit(snd_usb_audio_cleanup); 740