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)
10 * Audio Class 3.0 support by Ruslan Bilovol <ruslan.bilovol@gmail.com>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29 * - the linked URBs would be preferred but not used so far because of
30 * the instability of unlinking.
31 * - type II is not supported properly. there is no device which supports
32 * this type *correctly*. SB extigy looks as if it supports, but it's
33 * indeed an AC3 stream packed in SPDIF frames (i.e. no real AC3 stream).
37 #include <linux/bitops.h>
38 #include <linux/init.h>
39 #include <linux/list.h>
40 #include <linux/slab.h>
41 #include <linux/string.h>
42 #include <linux/ctype.h>
43 #include <linux/usb.h>
44 #include <linux/moduleparam.h>
45 #include <linux/mutex.h>
46 #include <linux/usb/audio.h>
47 #include <linux/usb/audio-v2.h>
48 #include <linux/usb/audio-v3.h>
49 #include <linux/module.h>
51 #include <sound/control.h>
52 #include <sound/core.h>
53 #include <sound/info.h>
54 #include <sound/pcm.h>
55 #include <sound/pcm_params.h>
56 #include <sound/initval.h>
72 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
73 MODULE_DESCRIPTION("USB Audio");
74 MODULE_LICENSE("GPL");
75 MODULE_SUPPORTED_DEVICE("{{Generic,USB Audio}}");
78 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
; /* Index 0-MAX */
79 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
; /* ID for this card */
80 static bool enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;/* Enable this card */
81 /* Vendor/product IDs for this card */
82 static int vid
[SNDRV_CARDS
] = { [0 ... (SNDRV_CARDS
-1)] = -1 };
83 static int pid
[SNDRV_CARDS
] = { [0 ... (SNDRV_CARDS
-1)] = -1 };
84 static int device_setup
[SNDRV_CARDS
]; /* device parameter for this card */
85 static bool ignore_ctl_error
;
86 static bool autoclock
= true;
87 static char *quirk_alias
[SNDRV_CARDS
];
89 module_param_array(index
, int, NULL
, 0444);
90 MODULE_PARM_DESC(index
, "Index value for the USB audio adapter.");
91 module_param_array(id
, charp
, NULL
, 0444);
92 MODULE_PARM_DESC(id
, "ID string for the USB audio adapter.");
93 module_param_array(enable
, bool, NULL
, 0444);
94 MODULE_PARM_DESC(enable
, "Enable USB audio adapter.");
95 module_param_array(vid
, int, NULL
, 0444);
96 MODULE_PARM_DESC(vid
, "Vendor ID for the USB audio device.");
97 module_param_array(pid
, int, NULL
, 0444);
98 MODULE_PARM_DESC(pid
, "Product ID for the USB audio device.");
99 module_param_array(device_setup
, int, NULL
, 0444);
100 MODULE_PARM_DESC(device_setup
, "Specific device setup (if needed).");
101 module_param(ignore_ctl_error
, bool, 0444);
102 MODULE_PARM_DESC(ignore_ctl_error
,
103 "Ignore errors from USB controller for mixer interfaces.");
104 module_param(autoclock
, bool, 0444);
105 MODULE_PARM_DESC(autoclock
, "Enable auto-clock selection for UAC2 devices (default: yes).");
106 module_param_array(quirk_alias
, charp
, NULL
, 0444);
107 MODULE_PARM_DESC(quirk_alias
, "Quirk aliases, e.g. 0123abcd:5678beef.");
110 * we keep the snd_usb_audio_t instances by ourselves for merging
111 * the all interfaces on the same card as one sound device.
114 static DEFINE_MUTEX(register_mutex
);
115 static struct snd_usb_audio
*usb_chip
[SNDRV_CARDS
];
116 static struct usb_driver usb_audio_driver
;
120 * called from usb_audio_disconnect()
122 static void snd_usb_stream_disconnect(struct snd_usb_stream
*as
)
125 struct snd_usb_substream
*subs
;
127 for (idx
= 0; idx
< 2; idx
++) {
128 subs
= &as
->substream
[idx
];
129 if (!subs
->num_formats
)
131 subs
->interface
= -1;
132 subs
->data_endpoint
= NULL
;
133 subs
->sync_endpoint
= NULL
;
137 static int snd_usb_create_stream(struct snd_usb_audio
*chip
, int ctrlif
, int interface
)
139 struct usb_device
*dev
= chip
->dev
;
140 struct usb_host_interface
*alts
;
141 struct usb_interface_descriptor
*altsd
;
142 struct usb_interface
*iface
= usb_ifnum_to_if(dev
, interface
);
145 dev_err(&dev
->dev
, "%u:%d : does not exist\n",
150 alts
= &iface
->altsetting
[0];
151 altsd
= get_iface_desc(alts
);
154 * Android with both accessory and audio interfaces enabled gets the
155 * interface numbers wrong.
157 if ((chip
->usb_id
== USB_ID(0x18d1, 0x2d04) ||
158 chip
->usb_id
== USB_ID(0x18d1, 0x2d05)) &&
160 altsd
->bInterfaceClass
== USB_CLASS_VENDOR_SPEC
&&
161 altsd
->bInterfaceSubClass
== USB_SUBCLASS_VENDOR_SPEC
) {
163 iface
= usb_ifnum_to_if(dev
, interface
);
166 alts
= &iface
->altsetting
[0];
167 altsd
= get_iface_desc(alts
);
170 if (usb_interface_claimed(iface
)) {
171 dev_dbg(&dev
->dev
, "%d:%d: skipping, already claimed\n",
176 if ((altsd
->bInterfaceClass
== USB_CLASS_AUDIO
||
177 altsd
->bInterfaceClass
== USB_CLASS_VENDOR_SPEC
) &&
178 altsd
->bInterfaceSubClass
== USB_SUBCLASS_MIDISTREAMING
) {
179 int err
= __snd_usbmidi_create(chip
->card
, iface
,
180 &chip
->midi_list
, NULL
,
184 "%u:%d: cannot create sequencer device\n",
188 usb_driver_claim_interface(&usb_audio_driver
, iface
, (void *)-1L);
193 if ((altsd
->bInterfaceClass
!= USB_CLASS_AUDIO
&&
194 altsd
->bInterfaceClass
!= USB_CLASS_VENDOR_SPEC
) ||
195 altsd
->bInterfaceSubClass
!= USB_SUBCLASS_AUDIOSTREAMING
) {
197 "%u:%d: skipping non-supported interface %d\n",
198 ctrlif
, interface
, altsd
->bInterfaceClass
);
199 /* skip non-supported classes */
203 if (snd_usb_get_speed(dev
) == USB_SPEED_LOW
) {
204 dev_err(&dev
->dev
, "low speed audio streaming not supported\n");
208 if (! snd_usb_parse_audio_interface(chip
, interface
)) {
209 usb_set_interface(dev
, interface
, 0); /* reset the current interface */
210 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
;
228 /* find audiocontrol interface */
229 host_iface
= &usb_ifnum_to_if(dev
, ctrlif
)->altsetting
[0];
230 control_header
= snd_usb_find_csint_desc(host_iface
->extra
,
231 host_iface
->extralen
,
233 altsd
= get_iface_desc(host_iface
);
234 protocol
= altsd
->bInterfaceProtocol
;
236 if (!control_header
) {
237 dev_err(&dev
->dev
, "cannot find UAC_HEADER\n");
241 rest_bytes
= (void *)(host_iface
->extra
+ host_iface
->extralen
) -
244 /* just to be sure -- this shouldn't hit at all */
245 if (rest_bytes
<= 0) {
246 dev_err(&dev
->dev
, "invalid control header\n");
253 "unknown interface protocol %#02x, assuming v1\n",
257 case UAC_VERSION_1
: {
258 struct uac1_ac_header_descriptor
*h1
= control_header
;
260 if (rest_bytes
< sizeof(*h1
)) {
261 dev_err(&dev
->dev
, "too short v1 buffer descriptor\n");
265 if (!h1
->bInCollection
) {
266 dev_info(&dev
->dev
, "skipping empty audio interface (v1)\n");
270 if (rest_bytes
< h1
->bLength
) {
271 dev_err(&dev
->dev
, "invalid buffer length (v1)\n");
275 if (h1
->bLength
< sizeof(*h1
) + h1
->bInCollection
) {
276 dev_err(&dev
->dev
, "invalid UAC_HEADER (v1)\n");
280 for (i
= 0; i
< h1
->bInCollection
; i
++)
281 snd_usb_create_stream(chip
, ctrlif
, h1
->baInterfaceNr
[i
]);
287 case UAC_VERSION_3
: {
288 struct usb_interface_assoc_descriptor
*assoc
=
289 usb_ifnum_to_if(dev
, ctrlif
)->intf_assoc
;
293 * Firmware writers cannot count to three. So to find
294 * the IAD on the NuForce UDH-100, also check the next
297 struct usb_interface
*iface
=
298 usb_ifnum_to_if(dev
, ctrlif
+ 1);
301 iface
->intf_assoc
->bFunctionClass
== USB_CLASS_AUDIO
&&
302 iface
->intf_assoc
->bFunctionProtocol
== UAC_VERSION_2
)
303 assoc
= iface
->intf_assoc
;
307 dev_err(&dev
->dev
, "Audio class v2/v3 interfaces need an interface association\n");
311 for (i
= 0; i
< assoc
->bInterfaceCount
; i
++) {
312 int intf
= assoc
->bFirstInterface
+ i
;
315 snd_usb_create_stream(chip
, ctrlif
, intf
);
326 * free the chip instance
328 * here we have to do not much, since pcm and controls are already freed
332 static int snd_usb_audio_free(struct snd_usb_audio
*chip
)
334 struct snd_usb_endpoint
*ep
, *n
;
336 list_for_each_entry_safe(ep
, n
, &chip
->ep_list
, list
)
337 snd_usb_endpoint_free(ep
);
339 mutex_destroy(&chip
->mutex
);
340 if (!atomic_read(&chip
->shutdown
))
341 dev_set_drvdata(&chip
->dev
->dev
, NULL
);
346 static int snd_usb_audio_dev_free(struct snd_device
*device
)
348 struct snd_usb_audio
*chip
= device
->device_data
;
349 return snd_usb_audio_free(chip
);
353 * create a chip instance and set its names.
355 static int snd_usb_audio_create(struct usb_interface
*intf
,
356 struct usb_device
*dev
, int idx
,
357 const struct snd_usb_audio_quirk
*quirk
,
359 struct snd_usb_audio
**rchip
)
361 struct snd_card
*card
;
362 struct snd_usb_audio
*chip
;
365 static struct snd_device_ops ops
= {
366 .dev_free
= snd_usb_audio_dev_free
,
371 switch (snd_usb_get_speed(dev
)) {
375 case USB_SPEED_WIRELESS
:
376 case USB_SPEED_SUPER
:
377 case USB_SPEED_SUPER_PLUS
:
380 dev_err(&dev
->dev
, "unknown device speed %d\n", snd_usb_get_speed(dev
));
384 err
= snd_card_new(&intf
->dev
, index
[idx
], id
[idx
], THIS_MODULE
,
387 dev_err(&dev
->dev
, "cannot create card instance %d\n", idx
);
391 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
397 mutex_init(&chip
->mutex
);
398 init_waitqueue_head(&chip
->shutdown_wait
);
402 chip
->setup
= device_setup
[idx
];
403 chip
->autoclock
= autoclock
;
404 atomic_set(&chip
->active
, 1); /* avoid autopm during probing */
405 atomic_set(&chip
->usage_count
, 0);
406 atomic_set(&chip
->shutdown
, 0);
408 chip
->usb_id
= usb_id
;
409 INIT_LIST_HEAD(&chip
->pcm_list
);
410 INIT_LIST_HEAD(&chip
->ep_list
);
411 INIT_LIST_HEAD(&chip
->midi_list
);
412 INIT_LIST_HEAD(&chip
->mixer_list
);
414 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
)) < 0) {
415 snd_usb_audio_free(chip
);
420 strcpy(card
->driver
, "USB-Audio");
421 sprintf(component
, "USB%04x:%04x",
422 USB_ID_VENDOR(chip
->usb_id
), USB_ID_PRODUCT(chip
->usb_id
));
423 snd_component_add(card
, component
);
425 /* retrieve the device string as shortname */
426 if (quirk
&& quirk
->product_name
&& *quirk
->product_name
) {
427 strlcpy(card
->shortname
, quirk
->product_name
, sizeof(card
->shortname
));
429 if (!dev
->descriptor
.iProduct
||
430 usb_string(dev
, dev
->descriptor
.iProduct
,
431 card
->shortname
, sizeof(card
->shortname
)) <= 0) {
432 /* no name available from anywhere, so use ID */
433 sprintf(card
->shortname
, "USB Device %#04x:%#04x",
434 USB_ID_VENDOR(chip
->usb_id
),
435 USB_ID_PRODUCT(chip
->usb_id
));
438 strim(card
->shortname
);
440 /* retrieve the vendor and device strings as longname */
441 if (quirk
&& quirk
->vendor_name
&& *quirk
->vendor_name
) {
442 len
= strlcpy(card
->longname
, quirk
->vendor_name
, sizeof(card
->longname
));
444 if (dev
->descriptor
.iManufacturer
)
445 len
= usb_string(dev
, dev
->descriptor
.iManufacturer
,
446 card
->longname
, sizeof(card
->longname
));
449 /* we don't really care if there isn't any vendor string */
452 strim(card
->longname
);
454 strlcat(card
->longname
, " ", sizeof(card
->longname
));
457 strlcat(card
->longname
, card
->shortname
, sizeof(card
->longname
));
459 len
= strlcat(card
->longname
, " at ", sizeof(card
->longname
));
461 if (len
< sizeof(card
->longname
))
462 usb_make_path(dev
, card
->longname
+ len
, sizeof(card
->longname
) - len
);
464 switch (snd_usb_get_speed(dev
)) {
466 strlcat(card
->longname
, ", low speed", sizeof(card
->longname
));
469 strlcat(card
->longname
, ", full speed", sizeof(card
->longname
));
472 strlcat(card
->longname
, ", high speed", sizeof(card
->longname
));
474 case USB_SPEED_SUPER
:
475 strlcat(card
->longname
, ", super speed", sizeof(card
->longname
));
477 case USB_SPEED_SUPER_PLUS
:
478 strlcat(card
->longname
, ", super speed plus", sizeof(card
->longname
));
484 snd_usb_audio_create_proc(chip
);
490 /* look for a matching quirk alias id */
491 static bool get_alias_id(struct usb_device
*dev
, unsigned int *id
)
494 unsigned int src
, dst
;
496 for (i
= 0; i
< ARRAY_SIZE(quirk_alias
); i
++) {
497 if (!quirk_alias
[i
] ||
498 sscanf(quirk_alias
[i
], "%x:%x", &src
, &dst
) != 2 ||
502 "device (%04x:%04x): applying quirk alias %04x:%04x\n",
503 USB_ID_VENDOR(*id
), USB_ID_PRODUCT(*id
),
504 USB_ID_VENDOR(dst
), USB_ID_PRODUCT(dst
));
512 static const struct usb_device_id usb_audio_ids
[]; /* defined below */
514 /* look for the corresponding quirk */
515 static const struct snd_usb_audio_quirk
*
516 get_alias_quirk(struct usb_device
*dev
, unsigned int id
)
518 const struct usb_device_id
*p
;
520 for (p
= usb_audio_ids
; p
->match_flags
; p
++) {
521 /* FIXME: this checks only vendor:product pair in the list */
522 if ((p
->match_flags
& USB_DEVICE_ID_MATCH_DEVICE
) ==
523 USB_DEVICE_ID_MATCH_DEVICE
&&
524 p
->idVendor
== USB_ID_VENDOR(id
) &&
525 p
->idProduct
== USB_ID_PRODUCT(id
))
526 return (const struct snd_usb_audio_quirk
*)p
->driver_info
;
533 * probe the active usb device
535 * note that this can be called multiple times per a device, when it
536 * includes multiple audio control interfaces.
538 * thus we check the usb device pointer and creates the card instance
539 * only at the first time. the successive calls of this function will
540 * append the pcm interface to the corresponding card.
542 static int usb_audio_probe(struct usb_interface
*intf
,
543 const struct usb_device_id
*usb_id
)
545 struct usb_device
*dev
= interface_to_usbdev(intf
);
546 const struct snd_usb_audio_quirk
*quirk
=
547 (const struct snd_usb_audio_quirk
*)usb_id
->driver_info
;
548 struct snd_usb_audio
*chip
;
550 struct usb_host_interface
*alts
;
554 alts
= &intf
->altsetting
[0];
555 ifnum
= get_iface_desc(alts
)->bInterfaceNumber
;
556 id
= USB_ID(le16_to_cpu(dev
->descriptor
.idVendor
),
557 le16_to_cpu(dev
->descriptor
.idProduct
));
558 if (get_alias_id(dev
, &id
))
559 quirk
= get_alias_quirk(dev
, id
);
560 if (quirk
&& quirk
->ifnum
>= 0 && ifnum
!= quirk
->ifnum
)
563 err
= snd_usb_apply_boot_quirk(dev
, intf
, quirk
, id
);
568 * found a config. now register to ALSA
571 /* check whether it's already registered */
573 mutex_lock(®ister_mutex
);
574 for (i
= 0; i
< SNDRV_CARDS
; i
++) {
575 if (usb_chip
[i
] && usb_chip
[i
]->dev
== dev
) {
576 if (atomic_read(&usb_chip
[i
]->shutdown
)) {
577 dev_err(&dev
->dev
, "USB device is in the shutdown state, cannot create a card instance\n");
582 atomic_inc(&chip
->active
); /* avoid autopm */
588 * now look for an empty slot and create a new card instance
590 for (i
= 0; i
< SNDRV_CARDS
; i
++)
592 (vid
[i
] == -1 || vid
[i
] == USB_ID_VENDOR(id
)) &&
593 (pid
[i
] == -1 || pid
[i
] == USB_ID_PRODUCT(id
))) {
595 err
= snd_usb_audio_create(intf
, dev
, i
, quirk
,
599 chip
->pm_intf
= intf
;
601 } else if (vid
[i
] != -1 || pid
[i
] != -1) {
603 "device (%04x:%04x) is disabled\n",
611 dev_err(&dev
->dev
, "no available usb audio device\n");
616 dev_set_drvdata(&dev
->dev
, chip
);
619 * For devices with more than one control interface, we assume the
620 * first contains the audio controls. We might need a more specific
621 * check here in the future.
623 if (!chip
->ctrl_intf
)
624 chip
->ctrl_intf
= alts
;
626 chip
->txfr_quirk
= 0;
627 err
= 1; /* continue */
628 if (quirk
&& quirk
->ifnum
!= QUIRK_NO_INTERFACE
) {
629 /* need some special handlings */
630 err
= snd_usb_create_quirk(chip
, intf
, &usb_audio_driver
, quirk
);
636 /* create normal USB audio interfaces */
637 err
= snd_usb_create_streams(chip
, ifnum
);
640 err
= snd_usb_create_mixer(chip
, ifnum
, ignore_ctl_error
);
645 /* we are allowed to call snd_card_register() many times */
646 err
= snd_card_register(chip
->card
);
650 usb_chip
[chip
->index
] = chip
;
651 chip
->num_interfaces
++;
652 usb_set_intfdata(intf
, chip
);
653 atomic_dec(&chip
->active
);
654 mutex_unlock(®ister_mutex
);
659 if (!chip
->num_interfaces
)
660 snd_card_free(chip
->card
);
661 atomic_dec(&chip
->active
);
663 mutex_unlock(®ister_mutex
);
668 * we need to take care of counter, since disconnection can be called also
669 * many times as well as usb_audio_probe().
671 static void usb_audio_disconnect(struct usb_interface
*intf
)
673 struct snd_usb_audio
*chip
= usb_get_intfdata(intf
);
674 struct snd_card
*card
;
677 if (chip
== (void *)-1L)
682 mutex_lock(®ister_mutex
);
683 if (atomic_inc_return(&chip
->shutdown
) == 1) {
684 struct snd_usb_stream
*as
;
685 struct snd_usb_endpoint
*ep
;
686 struct usb_mixer_interface
*mixer
;
688 /* wait until all pending tasks done;
689 * they are protected by snd_usb_lock_shutdown()
691 wait_event(chip
->shutdown_wait
,
692 !atomic_read(&chip
->usage_count
));
693 snd_card_disconnect(card
);
694 /* release the pcm resources */
695 list_for_each_entry(as
, &chip
->pcm_list
, list
) {
696 snd_usb_stream_disconnect(as
);
698 /* release the endpoint resources */
699 list_for_each_entry(ep
, &chip
->ep_list
, list
) {
700 snd_usb_endpoint_release(ep
);
702 /* release the midi resources */
703 list_for_each(p
, &chip
->midi_list
) {
704 snd_usbmidi_disconnect(p
);
706 /* release mixer resources */
707 list_for_each_entry(mixer
, &chip
->mixer_list
, list
) {
708 snd_usb_mixer_disconnect(mixer
);
712 chip
->num_interfaces
--;
713 if (chip
->num_interfaces
<= 0) {
714 usb_chip
[chip
->index
] = NULL
;
715 mutex_unlock(®ister_mutex
);
716 snd_card_free_when_closed(card
);
718 mutex_unlock(®ister_mutex
);
722 /* lock the shutdown (disconnect) task and autoresume */
723 int snd_usb_lock_shutdown(struct snd_usb_audio
*chip
)
727 atomic_inc(&chip
->usage_count
);
728 if (atomic_read(&chip
->shutdown
)) {
732 err
= snd_usb_autoresume(chip
);
738 if (atomic_dec_and_test(&chip
->usage_count
))
739 wake_up(&chip
->shutdown_wait
);
743 /* autosuspend and unlock the shutdown */
744 void snd_usb_unlock_shutdown(struct snd_usb_audio
*chip
)
746 snd_usb_autosuspend(chip
);
747 if (atomic_dec_and_test(&chip
->usage_count
))
748 wake_up(&chip
->shutdown_wait
);
753 int snd_usb_autoresume(struct snd_usb_audio
*chip
)
755 if (atomic_read(&chip
->shutdown
))
757 if (atomic_inc_return(&chip
->active
) == 1)
758 return usb_autopm_get_interface(chip
->pm_intf
);
762 void snd_usb_autosuspend(struct snd_usb_audio
*chip
)
764 if (atomic_read(&chip
->shutdown
))
766 if (atomic_dec_and_test(&chip
->active
))
767 usb_autopm_put_interface(chip
->pm_intf
);
770 static int usb_audio_suspend(struct usb_interface
*intf
, pm_message_t message
)
772 struct snd_usb_audio
*chip
= usb_get_intfdata(intf
);
773 struct snd_usb_stream
*as
;
774 struct usb_mixer_interface
*mixer
;
777 if (chip
== (void *)-1L)
780 chip
->autosuspended
= !!PMSG_IS_AUTO(message
);
781 if (!chip
->autosuspended
)
782 snd_power_change_state(chip
->card
, SNDRV_CTL_POWER_D3hot
);
783 if (!chip
->num_suspended_intf
++) {
784 list_for_each_entry(as
, &chip
->pcm_list
, list
) {
785 snd_pcm_suspend_all(as
->pcm
);
786 as
->substream
[0].need_setup_ep
=
787 as
->substream
[1].need_setup_ep
= true;
789 list_for_each(p
, &chip
->midi_list
)
790 snd_usbmidi_suspend(p
);
791 list_for_each_entry(mixer
, &chip
->mixer_list
, list
)
792 snd_usb_mixer_suspend(mixer
);
798 static int __usb_audio_resume(struct usb_interface
*intf
, bool reset_resume
)
800 struct snd_usb_audio
*chip
= usb_get_intfdata(intf
);
801 struct usb_mixer_interface
*mixer
;
805 if (chip
== (void *)-1L)
807 if (--chip
->num_suspended_intf
)
810 atomic_inc(&chip
->active
); /* avoid autopm */
812 * ALSA leaves material resumption to user space
813 * we just notify and restart the mixers
815 list_for_each_entry(mixer
, &chip
->mixer_list
, list
) {
816 err
= snd_usb_mixer_resume(mixer
, reset_resume
);
821 list_for_each(p
, &chip
->midi_list
) {
822 snd_usbmidi_resume(p
);
825 if (!chip
->autosuspended
)
826 snd_power_change_state(chip
->card
, SNDRV_CTL_POWER_D0
);
827 chip
->autosuspended
= 0;
830 atomic_dec(&chip
->active
); /* allow autopm after this point */
834 static int usb_audio_resume(struct usb_interface
*intf
)
836 return __usb_audio_resume(intf
, false);
839 static int usb_audio_reset_resume(struct usb_interface
*intf
)
841 return __usb_audio_resume(intf
, true);
844 #define usb_audio_suspend NULL
845 #define usb_audio_resume NULL
846 #define usb_audio_reset_resume NULL
847 #endif /* CONFIG_PM */
849 static const struct usb_device_id usb_audio_ids
[] = {
850 #include "quirks-table.h"
851 { .match_flags
= (USB_DEVICE_ID_MATCH_INT_CLASS
| USB_DEVICE_ID_MATCH_INT_SUBCLASS
),
852 .bInterfaceClass
= USB_CLASS_AUDIO
,
853 .bInterfaceSubClass
= USB_SUBCLASS_AUDIOCONTROL
},
854 { } /* Terminating entry */
856 MODULE_DEVICE_TABLE(usb
, usb_audio_ids
);
859 * entry point for linux usb interface
862 static struct usb_driver usb_audio_driver
= {
863 .name
= "snd-usb-audio",
864 .probe
= usb_audio_probe
,
865 .disconnect
= usb_audio_disconnect
,
866 .suspend
= usb_audio_suspend
,
867 .resume
= usb_audio_resume
,
868 .reset_resume
= usb_audio_reset_resume
,
869 .id_table
= usb_audio_ids
,
870 .supports_autosuspend
= 1,
873 module_usb_driver(usb_audio_driver
);