2 * (Tentative) USB Audio Driver for ALSA
4 * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>
6 * Many codes borrowed from audio.c by
7 * Alan Cox (alan@lxorguk.ukuu.org.uk)
8 * Thomas Sailer (sailer@ife.ee.ethz.ch)
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.
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.
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
28 * - the linked URBs would be preferred but not used so far because of
29 * the instability of unlinking.
30 * - type II is not supported properly. there is no device which supports
31 * this type *correctly*. SB extigy looks as if it supports, but it's
32 * indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream).
36 #include <linux/bitops.h>
37 #include <linux/init.h>
38 #include <linux/list.h>
39 #include <linux/slab.h>
40 #include <linux/string.h>
41 #include <linux/ctype.h>
42 #include <linux/usb.h>
43 #include <linux/moduleparam.h>
44 #include <linux/mutex.h>
45 #include <linux/usb/audio.h>
46 #include <linux/usb/audio-v2.h>
47 #include <linux/module.h>
49 #include <sound/control.h>
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>
71 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
72 MODULE_DESCRIPTION("USB Audio");
73 MODULE_LICENSE("GPL");
74 MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}");
77 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
78 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
79 static bool enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;/* Enable this card */
80 /* Vendor/product IDs for this card */
81 static int vid
[SNDRV_CARDS
] = { [0 ... (SNDRV_CARDS
-1)] = -1 };
82 static int pid
[SNDRV_CARDS
] = { [0 ... (SNDRV_CARDS
-1)] = -1 };
83 static int device_setup
[SNDRV_CARDS
]; /* device parameter for this card */
84 static bool ignore_ctl_error
;
85 static bool autoclock
= true;
86 static char *quirk_alias
[SNDRV_CARDS
];
88 module_param_array(index
, int, NULL
, 0444);
89 MODULE_PARM_DESC(index
, "Index value for the USB audio adapter.");
90 module_param_array(id
, charp
, NULL
, 0444);
91 MODULE_PARM_DESC(id
, "ID string for the USB audio adapter.");
92 module_param_array(enable
, bool, NULL
, 0444);
93 MODULE_PARM_DESC(enable
, "Enable USB audio adapter.");
94 module_param_array(vid
, int, NULL
, 0444);
95 MODULE_PARM_DESC(vid
, "Vendor ID for the USB audio device.");
96 module_param_array(pid
, int, NULL
, 0444);
97 MODULE_PARM_DESC(pid
, "Product ID for the USB audio device.");
98 module_param_array(device_setup
, int, NULL
, 0444);
99 MODULE_PARM_DESC(device_setup
, "Specific device setup (if needed).");
100 module_param(ignore_ctl_error
, bool, 0444);
101 MODULE_PARM_DESC(ignore_ctl_error
,
102 "Ignore errors from USB controller for mixer interfaces.");
103 module_param(autoclock
, bool, 0444);
104 MODULE_PARM_DESC(autoclock
, "Enable auto-clock selection for UAC2 devices (default: yes).");
105 module_param_array(quirk_alias
, charp
, NULL
, 0444);
106 MODULE_PARM_DESC(quirk_alias
, "Quirk aliases, e.g. 0123abcd:5678beef.");
109 * we keep the snd_usb_audio_t instances by ourselves for merging
110 * the all interfaces on the same card as one sound device.
113 static DEFINE_MUTEX(register_mutex
);
114 static struct snd_usb_audio
*usb_chip
[SNDRV_CARDS
];
115 static struct usb_driver usb_audio_driver
;
119 * called from usb_audio_disconnect()
121 static void snd_usb_stream_disconnect(struct snd_usb_stream
*as
)
124 struct snd_usb_substream
*subs
;
126 for (idx
= 0; idx
< 2; idx
++) {
127 subs
= &as
->substream
[idx
];
128 if (!subs
->num_formats
)
130 subs
->interface
= -1;
131 subs
->data_endpoint
= NULL
;
132 subs
->sync_endpoint
= NULL
;
136 static int snd_usb_create_stream(struct snd_usb_audio
*chip
, int ctrlif
, int interface
)
138 struct usb_device
*dev
= chip
->dev
;
139 struct usb_host_interface
*alts
;
140 struct usb_interface_descriptor
*altsd
;
141 struct usb_interface
*iface
= usb_ifnum_to_if(dev
, interface
);
144 dev_err(&dev
->dev
, "%u:%d : does not exist\n",
149 alts
= &iface
->altsetting
[0];
150 altsd
= get_iface_desc(alts
);
153 * Android with both accessory and audio interfaces enabled gets the
154 * interface numbers wrong.
156 if ((chip
->usb_id
== USB_ID(0x18d1, 0x2d04) ||
157 chip
->usb_id
== USB_ID(0x18d1, 0x2d05)) &&
159 altsd
->bInterfaceClass
== USB_CLASS_VENDOR_SPEC
&&
160 altsd
->bInterfaceSubClass
== USB_SUBCLASS_VENDOR_SPEC
) {
162 iface
= usb_ifnum_to_if(dev
, interface
);
165 alts
= &iface
->altsetting
[0];
166 altsd
= get_iface_desc(alts
);
169 if (usb_interface_claimed(iface
)) {
170 dev_dbg(&dev
->dev
, "%d:%d: skipping, already claimed\n",
175 if ((altsd
->bInterfaceClass
== USB_CLASS_AUDIO
||
176 altsd
->bInterfaceClass
== USB_CLASS_VENDOR_SPEC
) &&
177 altsd
->bInterfaceSubClass
== USB_SUBCLASS_MIDISTREAMING
) {
178 int err
= __snd_usbmidi_create(chip
->card
, iface
,
179 &chip
->midi_list
, NULL
,
183 "%u:%d: cannot create sequencer device\n",
187 usb_driver_claim_interface(&usb_audio_driver
, iface
, (void *)-1L);
192 if ((altsd
->bInterfaceClass
!= USB_CLASS_AUDIO
&&
193 altsd
->bInterfaceClass
!= USB_CLASS_VENDOR_SPEC
) ||
194 altsd
->bInterfaceSubClass
!= USB_SUBCLASS_AUDIOSTREAMING
) {
196 "%u:%d: skipping non-supported interface %d\n",
197 ctrlif
, interface
, altsd
->bInterfaceClass
);
198 /* skip non-supported classes */
202 if (snd_usb_get_speed(dev
) == USB_SPEED_LOW
) {
203 dev_err(&dev
->dev
, "low speed audio streaming not supported\n");
207 if (! snd_usb_parse_audio_interface(chip
, interface
)) {
208 usb_set_interface(dev
, interface
, 0); /* reset the current interface */
209 usb_driver_claim_interface(&usb_audio_driver
, iface
, (void *)-1L);
217 * parse audio control descriptor and create pcm/midi streams
219 static int snd_usb_create_streams(struct snd_usb_audio
*chip
, int ctrlif
)
221 struct usb_device
*dev
= chip
->dev
;
222 struct usb_host_interface
*host_iface
;
223 struct usb_interface_descriptor
*altsd
;
224 void *control_header
;
227 /* find audiocontrol interface */
228 host_iface
= &usb_ifnum_to_if(dev
, ctrlif
)->altsetting
[0];
229 control_header
= snd_usb_find_csint_desc(host_iface
->extra
,
230 host_iface
->extralen
,
232 altsd
= get_iface_desc(host_iface
);
233 protocol
= altsd
->bInterfaceProtocol
;
235 if (!control_header
) {
236 dev_err(&dev
->dev
, "cannot find UAC_HEADER\n");
243 "unknown interface protocol %#02x, assuming v1\n",
247 case UAC_VERSION_1
: {
248 struct uac1_ac_header_descriptor
*h1
= control_header
;
250 if (!h1
->bInCollection
) {
251 dev_info(&dev
->dev
, "skipping empty audio interface (v1)\n");
255 if (h1
->bLength
< sizeof(*h1
) + h1
->bInCollection
) {
256 dev_err(&dev
->dev
, "invalid UAC_HEADER (v1)\n");
260 for (i
= 0; i
< h1
->bInCollection
; i
++)
261 snd_usb_create_stream(chip
, ctrlif
, h1
->baInterfaceNr
[i
]);
266 case UAC_VERSION_2
: {
267 struct usb_interface_assoc_descriptor
*assoc
=
268 usb_ifnum_to_if(dev
, ctrlif
)->intf_assoc
;
272 * Firmware writers cannot count to three. So to find
273 * the IAD on the NuForce UDH-100, also check the next
276 struct usb_interface
*iface
=
277 usb_ifnum_to_if(dev
, ctrlif
+ 1);
280 iface
->intf_assoc
->bFunctionClass
== USB_CLASS_AUDIO
&&
281 iface
->intf_assoc
->bFunctionProtocol
== UAC_VERSION_2
)
282 assoc
= iface
->intf_assoc
;
286 dev_err(&dev
->dev
, "Audio class v2 interfaces need an interface association\n");
290 for (i
= 0; i
< assoc
->bInterfaceCount
; i
++) {
291 int intf
= assoc
->bFirstInterface
+ i
;
294 snd_usb_create_stream(chip
, ctrlif
, intf
);
305 * free the chip instance
307 * here we have to do not much, since pcm and controls are already freed
311 static int snd_usb_audio_free(struct snd_usb_audio
*chip
)
313 struct snd_usb_endpoint
*ep
, *n
;
315 list_for_each_entry_safe(ep
, n
, &chip
->ep_list
, list
)
316 snd_usb_endpoint_free(ep
);
318 mutex_destroy(&chip
->mutex
);
319 dev_set_drvdata(&chip
->dev
->dev
, NULL
);
324 static int snd_usb_audio_dev_free(struct snd_device
*device
)
326 struct snd_usb_audio
*chip
= device
->device_data
;
327 return snd_usb_audio_free(chip
);
331 * create a chip instance and set its names.
333 static int snd_usb_audio_create(struct usb_interface
*intf
,
334 struct usb_device
*dev
, int idx
,
335 const struct snd_usb_audio_quirk
*quirk
,
336 struct snd_usb_audio
**rchip
)
338 struct snd_card
*card
;
339 struct snd_usb_audio
*chip
;
342 static struct snd_device_ops ops
= {
343 .dev_free
= snd_usb_audio_dev_free
,
348 switch (snd_usb_get_speed(dev
)) {
352 case USB_SPEED_WIRELESS
:
353 case USB_SPEED_SUPER
:
356 dev_err(&dev
->dev
, "unknown device speed %d\n", snd_usb_get_speed(dev
));
360 err
= snd_card_new(&intf
->dev
, index
[idx
], id
[idx
], THIS_MODULE
,
363 dev_err(&dev
->dev
, "cannot create card instance %d\n", idx
);
367 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
373 mutex_init(&chip
->mutex
);
374 init_waitqueue_head(&chip
->shutdown_wait
);
378 chip
->setup
= device_setup
[idx
];
379 chip
->autoclock
= autoclock
;
380 atomic_set(&chip
->active
, 1); /* avoid autopm during probing */
381 atomic_set(&chip
->usage_count
, 0);
382 atomic_set(&chip
->shutdown
, 0);
384 chip
->usb_id
= USB_ID(le16_to_cpu(dev
->descriptor
.idVendor
),
385 le16_to_cpu(dev
->descriptor
.idProduct
));
386 INIT_LIST_HEAD(&chip
->pcm_list
);
387 INIT_LIST_HEAD(&chip
->ep_list
);
388 INIT_LIST_HEAD(&chip
->midi_list
);
389 INIT_LIST_HEAD(&chip
->mixer_list
);
391 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
)) < 0) {
392 snd_usb_audio_free(chip
);
397 strcpy(card
->driver
, "USB-Audio");
398 sprintf(component
, "USB%04x:%04x",
399 USB_ID_VENDOR(chip
->usb_id
), USB_ID_PRODUCT(chip
->usb_id
));
400 snd_component_add(card
, component
);
402 /* retrieve the device string as shortname */
403 if (quirk
&& quirk
->product_name
&& *quirk
->product_name
) {
404 strlcpy(card
->shortname
, quirk
->product_name
, sizeof(card
->shortname
));
406 if (!dev
->descriptor
.iProduct
||
407 usb_string(dev
, dev
->descriptor
.iProduct
,
408 card
->shortname
, sizeof(card
->shortname
)) <= 0) {
409 /* no name available from anywhere, so use ID */
410 sprintf(card
->shortname
, "USB Device %#04x:%#04x",
411 USB_ID_VENDOR(chip
->usb_id
),
412 USB_ID_PRODUCT(chip
->usb_id
));
415 strim(card
->shortname
);
417 /* retrieve the vendor and device strings as longname */
418 if (quirk
&& quirk
->vendor_name
&& *quirk
->vendor_name
) {
419 len
= strlcpy(card
->longname
, quirk
->vendor_name
, sizeof(card
->longname
));
421 if (dev
->descriptor
.iManufacturer
)
422 len
= usb_string(dev
, dev
->descriptor
.iManufacturer
,
423 card
->longname
, sizeof(card
->longname
));
426 /* we don't really care if there isn't any vendor string */
429 strim(card
->longname
);
431 strlcat(card
->longname
, " ", sizeof(card
->longname
));
434 strlcat(card
->longname
, card
->shortname
, sizeof(card
->longname
));
436 len
= strlcat(card
->longname
, " at ", sizeof(card
->longname
));
438 if (len
< sizeof(card
->longname
))
439 usb_make_path(dev
, card
->longname
+ len
, sizeof(card
->longname
) - len
);
441 switch (snd_usb_get_speed(dev
)) {
443 strlcat(card
->longname
, ", low speed", sizeof(card
->longname
));
446 strlcat(card
->longname
, ", full speed", sizeof(card
->longname
));
449 strlcat(card
->longname
, ", high speed", sizeof(card
->longname
));
451 case USB_SPEED_SUPER
:
452 strlcat(card
->longname
, ", super speed", sizeof(card
->longname
));
458 snd_usb_audio_create_proc(chip
);
464 /* look for a matching quirk alias id */
465 static bool get_alias_id(struct usb_device
*dev
, unsigned int *id
)
468 unsigned int src
, dst
;
470 for (i
= 0; i
< ARRAY_SIZE(quirk_alias
); i
++) {
471 if (!quirk_alias
[i
] ||
472 sscanf(quirk_alias
[i
], "%x:%x", &src
, &dst
) != 2 ||
476 "device (%04x:%04x): applying quirk alias %04x:%04x\n",
477 USB_ID_VENDOR(*id
), USB_ID_PRODUCT(*id
),
478 USB_ID_VENDOR(dst
), USB_ID_PRODUCT(dst
));
486 static struct usb_device_id usb_audio_ids
[]; /* defined below */
488 /* look for the corresponding quirk */
489 static const struct snd_usb_audio_quirk
*
490 get_alias_quirk(struct usb_device
*dev
, unsigned int id
)
492 const struct usb_device_id
*p
;
494 for (p
= usb_audio_ids
; p
->match_flags
; p
++) {
495 /* FIXME: this checks only vendor:product pair in the list */
496 if ((p
->match_flags
& USB_DEVICE_ID_MATCH_DEVICE
) ==
497 USB_DEVICE_ID_MATCH_DEVICE
&&
498 p
->idVendor
== USB_ID_VENDOR(id
) &&
499 p
->idProduct
== USB_ID_PRODUCT(id
))
500 return (const struct snd_usb_audio_quirk
*)p
->driver_info
;
507 * probe the active usb device
509 * note that this can be called multiple times per a device, when it
510 * includes multiple audio control interfaces.
512 * thus we check the usb device pointer and creates the card instance
513 * only at the first time. the successive calls of this function will
514 * append the pcm interface to the corresponding card.
516 static int usb_audio_probe(struct usb_interface
*intf
,
517 const struct usb_device_id
*usb_id
)
519 struct usb_device
*dev
= interface_to_usbdev(intf
);
520 const struct snd_usb_audio_quirk
*quirk
=
521 (const struct snd_usb_audio_quirk
*)usb_id
->driver_info
;
522 struct snd_usb_audio
*chip
;
524 struct usb_host_interface
*alts
;
528 alts
= &intf
->altsetting
[0];
529 ifnum
= get_iface_desc(alts
)->bInterfaceNumber
;
530 id
= USB_ID(le16_to_cpu(dev
->descriptor
.idVendor
),
531 le16_to_cpu(dev
->descriptor
.idProduct
));
532 if (get_alias_id(dev
, &id
))
533 quirk
= get_alias_quirk(dev
, id
);
534 if (quirk
&& quirk
->ifnum
>= 0 && ifnum
!= quirk
->ifnum
)
537 err
= snd_usb_apply_boot_quirk(dev
, intf
, quirk
, id
);
542 * found a config. now register to ALSA
545 /* check whether it's already registered */
547 mutex_lock(®ister_mutex
);
548 for (i
= 0; i
< SNDRV_CARDS
; i
++) {
549 if (usb_chip
[i
] && usb_chip
[i
]->dev
== dev
) {
550 if (atomic_read(&usb_chip
[i
]->shutdown
)) {
551 dev_err(&dev
->dev
, "USB device is in the shutdown state, cannot create a card instance\n");
556 dev_set_drvdata(&dev
->dev
, chip
);
557 atomic_inc(&chip
->active
); /* avoid autopm */
563 * now look for an empty slot and create a new card instance
565 for (i
= 0; i
< SNDRV_CARDS
; i
++)
566 if (enable
[i
] && ! usb_chip
[i
] &&
567 (vid
[i
] == -1 || vid
[i
] == USB_ID_VENDOR(id
)) &&
568 (pid
[i
] == -1 || pid
[i
] == USB_ID_PRODUCT(id
))) {
569 err
= snd_usb_audio_create(intf
, dev
, i
, quirk
,
573 chip
->pm_intf
= intf
;
577 dev_err(&dev
->dev
, "no available usb audio device\n");
584 * For devices with more than one control interface, we assume the
585 * first contains the audio controls. We might need a more specific
586 * check here in the future.
588 if (!chip
->ctrl_intf
)
589 chip
->ctrl_intf
= alts
;
591 chip
->txfr_quirk
= 0;
592 err
= 1; /* continue */
593 if (quirk
&& quirk
->ifnum
!= QUIRK_NO_INTERFACE
) {
594 /* need some special handlings */
595 err
= snd_usb_create_quirk(chip
, intf
, &usb_audio_driver
, quirk
);
601 /* create normal USB audio interfaces */
602 err
= snd_usb_create_streams(chip
, ifnum
);
605 err
= snd_usb_create_mixer(chip
, ifnum
, ignore_ctl_error
);
610 /* we are allowed to call snd_card_register() many times */
611 err
= snd_card_register(chip
->card
);
615 if (quirk
->media_device
) {
616 /* don't want to fail when media_snd_device_create() fails */
617 media_snd_device_create(chip
, intf
);
620 usb_chip
[chip
->index
] = chip
;
621 chip
->num_interfaces
++;
622 usb_set_intfdata(intf
, chip
);
623 atomic_dec(&chip
->active
);
624 mutex_unlock(®ister_mutex
);
629 if (!chip
->num_interfaces
)
630 snd_card_free(chip
->card
);
631 atomic_dec(&chip
->active
);
633 mutex_unlock(®ister_mutex
);
638 * we need to take care of counter, since disconnection can be called also
639 * many times as well as usb_audio_probe().
641 static void usb_audio_disconnect(struct usb_interface
*intf
)
643 struct snd_usb_audio
*chip
= usb_get_intfdata(intf
);
644 struct snd_card
*card
;
647 if (chip
== (void *)-1L)
652 mutex_lock(®ister_mutex
);
653 if (atomic_inc_return(&chip
->shutdown
) == 1) {
654 struct snd_usb_stream
*as
;
655 struct snd_usb_endpoint
*ep
;
656 struct usb_mixer_interface
*mixer
;
658 /* wait until all pending tasks done;
659 * they are protected by snd_usb_lock_shutdown()
661 wait_event(chip
->shutdown_wait
,
662 !atomic_read(&chip
->usage_count
));
663 snd_card_disconnect(card
);
664 /* release the pcm resources */
665 list_for_each_entry(as
, &chip
->pcm_list
, list
) {
666 snd_usb_stream_disconnect(as
);
668 /* release the endpoint resources */
669 list_for_each_entry(ep
, &chip
->ep_list
, list
) {
670 snd_usb_endpoint_release(ep
);
672 /* release the midi resources */
673 list_for_each(p
, &chip
->midi_list
) {
674 snd_usbmidi_disconnect(p
);
677 * Nice to check quirk && quirk->media_device
678 * need some special handlings. Doesn't look like
679 * we have access to quirk here
682 media_snd_device_delete(chip
);
684 /* release mixer resources */
685 list_for_each_entry(mixer
, &chip
->mixer_list
, list
) {
686 snd_usb_mixer_disconnect(mixer
);
690 chip
->num_interfaces
--;
691 if (chip
->num_interfaces
<= 0) {
692 usb_chip
[chip
->index
] = NULL
;
693 mutex_unlock(®ister_mutex
);
694 snd_card_free_when_closed(card
);
696 mutex_unlock(®ister_mutex
);
700 /* lock the shutdown (disconnect) task and autoresume */
701 int snd_usb_lock_shutdown(struct snd_usb_audio
*chip
)
705 atomic_inc(&chip
->usage_count
);
706 if (atomic_read(&chip
->shutdown
)) {
710 err
= snd_usb_autoresume(chip
);
716 if (atomic_dec_and_test(&chip
->usage_count
))
717 wake_up(&chip
->shutdown_wait
);
721 /* autosuspend and unlock the shutdown */
722 void snd_usb_unlock_shutdown(struct snd_usb_audio
*chip
)
724 snd_usb_autosuspend(chip
);
725 if (atomic_dec_and_test(&chip
->usage_count
))
726 wake_up(&chip
->shutdown_wait
);
731 int snd_usb_autoresume(struct snd_usb_audio
*chip
)
733 if (atomic_read(&chip
->shutdown
))
735 if (atomic_inc_return(&chip
->active
) == 1)
736 return usb_autopm_get_interface(chip
->pm_intf
);
740 void snd_usb_autosuspend(struct snd_usb_audio
*chip
)
742 if (atomic_read(&chip
->shutdown
))
744 if (atomic_dec_and_test(&chip
->active
))
745 usb_autopm_put_interface(chip
->pm_intf
);
748 static int usb_audio_suspend(struct usb_interface
*intf
, pm_message_t message
)
750 struct snd_usb_audio
*chip
= usb_get_intfdata(intf
);
751 struct snd_usb_stream
*as
;
752 struct usb_mixer_interface
*mixer
;
755 if (chip
== (void *)-1L)
758 chip
->autosuspended
= !!PMSG_IS_AUTO(message
);
759 if (!chip
->autosuspended
)
760 snd_power_change_state(chip
->card
, SNDRV_CTL_POWER_D3hot
);
761 if (!chip
->num_suspended_intf
++) {
762 list_for_each_entry(as
, &chip
->pcm_list
, list
) {
763 snd_pcm_suspend_all(as
->pcm
);
764 as
->substream
[0].need_setup_ep
=
765 as
->substream
[1].need_setup_ep
= true;
767 list_for_each(p
, &chip
->midi_list
)
768 snd_usbmidi_suspend(p
);
769 list_for_each_entry(mixer
, &chip
->mixer_list
, list
)
770 snd_usb_mixer_suspend(mixer
);
776 static int __usb_audio_resume(struct usb_interface
*intf
, bool reset_resume
)
778 struct snd_usb_audio
*chip
= usb_get_intfdata(intf
);
779 struct usb_mixer_interface
*mixer
;
783 if (chip
== (void *)-1L)
785 if (--chip
->num_suspended_intf
)
788 atomic_inc(&chip
->active
); /* avoid autopm */
790 * ALSA leaves material resumption to user space
791 * we just notify and restart the mixers
793 list_for_each_entry(mixer
, &chip
->mixer_list
, list
) {
794 err
= snd_usb_mixer_resume(mixer
, reset_resume
);
799 list_for_each(p
, &chip
->midi_list
) {
800 snd_usbmidi_resume(p
);
803 if (!chip
->autosuspended
)
804 snd_power_change_state(chip
->card
, SNDRV_CTL_POWER_D0
);
805 chip
->autosuspended
= 0;
808 atomic_dec(&chip
->active
); /* allow autopm after this point */
812 static int usb_audio_resume(struct usb_interface
*intf
)
814 return __usb_audio_resume(intf
, false);
817 static int usb_audio_reset_resume(struct usb_interface
*intf
)
819 return __usb_audio_resume(intf
, true);
822 #define usb_audio_suspend NULL
823 #define usb_audio_resume NULL
824 #define usb_audio_reset_resume NULL
825 #endif /* CONFIG_PM */
827 static struct usb_device_id usb_audio_ids
[] = {
828 #include "quirks-table.h"
829 { .match_flags
= (USB_DEVICE_ID_MATCH_INT_CLASS
| USB_DEVICE_ID_MATCH_INT_SUBCLASS
),
830 .bInterfaceClass
= USB_CLASS_AUDIO
,
831 .bInterfaceSubClass
= USB_SUBCLASS_AUDIOCONTROL
},
832 { } /* Terminating entry */
834 MODULE_DEVICE_TABLE(usb
, usb_audio_ids
);
837 * entry point for linux usb interface
840 static struct usb_driver usb_audio_driver
= {
841 .name
= "snd-usb-audio",
842 .probe
= usb_audio_probe
,
843 .disconnect
= usb_audio_disconnect
,
844 .suspend
= usb_audio_suspend
,
845 .resume
= usb_audio_resume
,
846 .reset_resume
= usb_audio_reset_resume
,
847 .id_table
= usb_audio_ids
,
848 .supports_autosuspend
= 1,
851 module_usb_driver(usb_audio_driver
);