2 * Clock domain and sample rate management functions
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 #include <linux/bitops.h>
21 #include <linux/init.h>
22 #include <linux/string.h>
23 #include <linux/usb.h>
24 #include <linux/usb/audio.h>
25 #include <linux/usb/audio-v2.h>
27 #include <sound/core.h>
28 #include <sound/info.h>
29 #include <sound/pcm.h>
36 static struct uac_clock_source_descriptor
*
37 snd_usb_find_clock_source(struct usb_host_interface
*ctrl_iface
,
40 struct uac_clock_source_descriptor
*cs
= NULL
;
42 while ((cs
= snd_usb_find_csint_desc(ctrl_iface
->extra
,
44 cs
, UAC2_CLOCK_SOURCE
))) {
45 if (cs
->bClockID
== clock_id
)
52 static struct uac_clock_selector_descriptor
*
53 snd_usb_find_clock_selector(struct usb_host_interface
*ctrl_iface
,
56 struct uac_clock_selector_descriptor
*cs
= NULL
;
58 while ((cs
= snd_usb_find_csint_desc(ctrl_iface
->extra
,
60 cs
, UAC2_CLOCK_SELECTOR
))) {
61 if (cs
->bClockID
== clock_id
)
68 static struct uac_clock_multiplier_descriptor
*
69 snd_usb_find_clock_multiplier(struct usb_host_interface
*ctrl_iface
,
72 struct uac_clock_multiplier_descriptor
*cs
= NULL
;
74 while ((cs
= snd_usb_find_csint_desc(ctrl_iface
->extra
,
76 cs
, UAC2_CLOCK_MULTIPLIER
))) {
77 if (cs
->bClockID
== clock_id
)
84 static int uac_clock_selector_get_val(struct snd_usb_audio
*chip
, int selector_id
)
89 ret
= snd_usb_ctl_msg(chip
->dev
, usb_rcvctrlpipe(chip
->dev
, 0),
91 USB_RECIP_INTERFACE
| USB_TYPE_CLASS
| USB_DIR_IN
,
92 UAC2_CX_CLOCK_SELECTOR
<< 8,
93 snd_usb_ctrl_intf(chip
) | (selector_id
<< 8),
94 &buf
, sizeof(buf
), 1000);
102 static bool uac_clock_source_is_valid(struct snd_usb_audio
*chip
, int source_id
)
106 struct usb_device
*dev
= chip
->dev
;
108 err
= snd_usb_ctl_msg(dev
, usb_rcvctrlpipe(dev
, 0), UAC2_CS_CUR
,
109 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
| USB_DIR_IN
,
110 UAC2_CS_CONTROL_CLOCK_VALID
<< 8,
111 snd_usb_ctrl_intf(chip
) | (source_id
<< 8),
112 &data
, sizeof(data
), 1000);
115 snd_printk(KERN_WARNING
"%s(): cannot get clock validity for id %d\n",
116 __func__
, source_id
);
123 static int __uac_clock_find_source(struct snd_usb_audio
*chip
,
124 int entity_id
, unsigned long *visited
)
126 struct uac_clock_source_descriptor
*source
;
127 struct uac_clock_selector_descriptor
*selector
;
128 struct uac_clock_multiplier_descriptor
*multiplier
;
132 if (test_and_set_bit(entity_id
, visited
)) {
133 snd_printk(KERN_WARNING
134 "%s(): recursive clock topology detected, id %d.\n",
135 __func__
, entity_id
);
139 /* first, see if the ID we're looking for is a clock source already */
140 source
= snd_usb_find_clock_source(chip
->ctrl_intf
, entity_id
);
142 return source
->bClockID
;
144 selector
= snd_usb_find_clock_selector(chip
->ctrl_intf
, entity_id
);
148 /* the entity ID we are looking for is a selector.
149 * find out what it currently selects */
150 ret
= uac_clock_selector_get_val(chip
, selector
->bClockID
);
154 /* Selector values are one-based */
156 if (ret
> selector
->bNrInPins
|| ret
< 1) {
158 "%s(): selector reported illegal value, id %d, ret %d\n",
159 __func__
, selector
->bClockID
, ret
);
164 return __uac_clock_find_source(chip
, selector
->baCSourceID
[ret
-1],
168 multiplier
= snd_usb_find_clock_multiplier(chip
->ctrl_intf
, entity_id
);
170 return __uac_clock_find_source(chip
, multiplier
->bCSourceID
,
177 * For all kinds of sample rate settings and other device queries,
178 * the clock source (end-leaf) must be used. However, clock selectors,
179 * clock multipliers and sample rate converters may be specified as
180 * clock source input to terminal. This functions walks the clock path
181 * to its end and tries to find the source.
183 * The 'visited' bitfield is used internally to detect recursive loops.
185 * Returns the clock source UnitID (>=0) on success, or an error.
187 int snd_usb_clock_find_source(struct snd_usb_audio
*chip
, int entity_id
)
189 DECLARE_BITMAP(visited
, 256);
190 memset(visited
, 0, sizeof(visited
));
191 return __uac_clock_find_source(chip
, entity_id
, visited
);
194 static int set_sample_rate_v1(struct snd_usb_audio
*chip
, int iface
,
195 struct usb_host_interface
*alts
,
196 struct audioformat
*fmt
, int rate
)
198 struct usb_device
*dev
= chip
->dev
;
200 unsigned char data
[3];
203 ep
= get_endpoint(alts
, 0)->bEndpointAddress
;
205 /* if endpoint doesn't have sampling rate control, bail out */
206 if (!(fmt
->attributes
& UAC_EP_CS_ATTR_SAMPLE_RATE
))
211 data
[2] = rate
>> 16;
212 if ((err
= snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0), UAC_SET_CUR
,
213 USB_TYPE_CLASS
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
214 UAC_EP_CS_ATTR_SAMPLE_RATE
<< 8, ep
,
215 data
, sizeof(data
), 1000)) < 0) {
216 snd_printk(KERN_ERR
"%d:%d:%d: cannot set freq %d to ep %#x\n",
217 dev
->devnum
, iface
, fmt
->altsetting
, rate
, ep
);
221 if ((err
= snd_usb_ctl_msg(dev
, usb_rcvctrlpipe(dev
, 0), UAC_GET_CUR
,
222 USB_TYPE_CLASS
| USB_RECIP_ENDPOINT
| USB_DIR_IN
,
223 UAC_EP_CS_ATTR_SAMPLE_RATE
<< 8, ep
,
224 data
, sizeof(data
), 1000)) < 0) {
225 snd_printk(KERN_WARNING
"%d:%d:%d: cannot get freq at ep %#x\n",
226 dev
->devnum
, iface
, fmt
->altsetting
, ep
);
227 return 0; /* some devices don't support reading */
230 crate
= data
[0] | (data
[1] << 8) | (data
[2] << 16);
232 snd_printd(KERN_WARNING
"current rate %d is different from the runtime rate %d\n", crate
, rate
);
233 // runtime->rate = crate;
239 static int set_sample_rate_v2(struct snd_usb_audio
*chip
, int iface
,
240 struct usb_host_interface
*alts
,
241 struct audioformat
*fmt
, int rate
)
243 struct usb_device
*dev
= chip
->dev
;
244 unsigned char data
[4];
246 int clock
= snd_usb_clock_find_source(chip
, fmt
->clock
);
251 if (!uac_clock_source_is_valid(chip
, clock
)) {
252 /* TODO: should we try to find valid clock setups by ourself? */
253 snd_printk(KERN_ERR
"%d:%d:%d: clock source %d is not valid, cannot use\n",
254 dev
->devnum
, iface
, fmt
->altsetting
, clock
);
260 data
[2] = rate
>> 16;
261 data
[3] = rate
>> 24;
262 if ((err
= snd_usb_ctl_msg(dev
, usb_sndctrlpipe(dev
, 0), UAC2_CS_CUR
,
263 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
| USB_DIR_OUT
,
264 UAC2_CS_CONTROL_SAM_FREQ
<< 8,
265 snd_usb_ctrl_intf(chip
) | (clock
<< 8),
266 data
, sizeof(data
), 1000)) < 0) {
267 snd_printk(KERN_ERR
"%d:%d:%d: cannot set freq %d (v2)\n",
268 dev
->devnum
, iface
, fmt
->altsetting
, rate
);
272 if ((err
= snd_usb_ctl_msg(dev
, usb_rcvctrlpipe(dev
, 0), UAC2_CS_CUR
,
273 USB_TYPE_CLASS
| USB_RECIP_INTERFACE
| USB_DIR_IN
,
274 UAC2_CS_CONTROL_SAM_FREQ
<< 8,
275 snd_usb_ctrl_intf(chip
) | (clock
<< 8),
276 data
, sizeof(data
), 1000)) < 0) {
277 snd_printk(KERN_WARNING
"%d:%d:%d: cannot get freq (v2)\n",
278 dev
->devnum
, iface
, fmt
->altsetting
);
282 crate
= data
[0] | (data
[1] << 8) | (data
[2] << 16) | (data
[3] << 24);
284 snd_printd(KERN_WARNING
"current rate %d is different from the runtime rate %d\n", crate
, rate
);
289 int snd_usb_init_sample_rate(struct snd_usb_audio
*chip
, int iface
,
290 struct usb_host_interface
*alts
,
291 struct audioformat
*fmt
, int rate
)
293 struct usb_interface_descriptor
*altsd
= get_iface_desc(alts
);
295 switch (altsd
->bInterfaceProtocol
) {
298 return set_sample_rate_v1(chip
, iface
, alts
, fmt
, rate
);
301 return set_sample_rate_v2(chip
, iface
, alts
, fmt
, rate
);