Root/
1 | /* |
2 | * This program is free software; you can redistribute it and/or modify |
3 | * it under the terms of the GNU General Public License as published by |
4 | * the Free Software Foundation; either version 2 of the License, or |
5 | * (at your option) any later version. |
6 | * |
7 | * This program is distributed in the hope that it will be useful, |
8 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
9 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
10 | * GNU General Public License for more details. |
11 | * |
12 | * You should have received a copy of the GNU General Public License |
13 | * along with this program; if not, write to the Free Software |
14 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
15 | */ |
16 | |
17 | #include <linux/init.h> |
18 | #include <linux/slab.h> |
19 | #include <linux/usb.h> |
20 | #include <linux/usb/audio.h> |
21 | #include <linux/usb/audio-v2.h> |
22 | |
23 | #include <sound/core.h> |
24 | #include <sound/pcm.h> |
25 | #include <sound/pcm_params.h> |
26 | |
27 | #include "usbaudio.h" |
28 | #include "card.h" |
29 | #include "quirks.h" |
30 | #include "debug.h" |
31 | #include "urb.h" |
32 | #include "helper.h" |
33 | #include "pcm.h" |
34 | #include "clock.h" |
35 | #include "power.h" |
36 | |
37 | /* |
38 | * return the current pcm pointer. just based on the hwptr_done value. |
39 | */ |
40 | static snd_pcm_uframes_t snd_usb_pcm_pointer(struct snd_pcm_substream *substream) |
41 | { |
42 | struct snd_usb_substream *subs; |
43 | unsigned int hwptr_done; |
44 | |
45 | subs = (struct snd_usb_substream *)substream->runtime->private_data; |
46 | spin_lock(&subs->lock); |
47 | hwptr_done = subs->hwptr_done; |
48 | spin_unlock(&subs->lock); |
49 | return hwptr_done / (substream->runtime->frame_bits >> 3); |
50 | } |
51 | |
52 | /* |
53 | * find a matching audio format |
54 | */ |
55 | static struct audioformat *find_format(struct snd_usb_substream *subs, unsigned int format, |
56 | unsigned int rate, unsigned int channels) |
57 | { |
58 | struct list_head *p; |
59 | struct audioformat *found = NULL; |
60 | int cur_attr = 0, attr; |
61 | |
62 | list_for_each(p, &subs->fmt_list) { |
63 | struct audioformat *fp; |
64 | fp = list_entry(p, struct audioformat, list); |
65 | if (!(fp->formats & (1uLL << format))) |
66 | continue; |
67 | if (fp->channels != channels) |
68 | continue; |
69 | if (rate < fp->rate_min || rate > fp->rate_max) |
70 | continue; |
71 | if (! (fp->rates & SNDRV_PCM_RATE_CONTINUOUS)) { |
72 | unsigned int i; |
73 | for (i = 0; i < fp->nr_rates; i++) |
74 | if (fp->rate_table[i] == rate) |
75 | break; |
76 | if (i >= fp->nr_rates) |
77 | continue; |
78 | } |
79 | attr = fp->ep_attr & USB_ENDPOINT_SYNCTYPE; |
80 | if (! found) { |
81 | found = fp; |
82 | cur_attr = attr; |
83 | continue; |
84 | } |
85 | /* avoid async out and adaptive in if the other method |
86 | * supports the same format. |
87 | * this is a workaround for the case like |
88 | * M-audio audiophile USB. |
89 | */ |
90 | if (attr != cur_attr) { |
91 | if ((attr == USB_ENDPOINT_SYNC_ASYNC && |
92 | subs->direction == SNDRV_PCM_STREAM_PLAYBACK) || |
93 | (attr == USB_ENDPOINT_SYNC_ADAPTIVE && |
94 | subs->direction == SNDRV_PCM_STREAM_CAPTURE)) |
95 | continue; |
96 | if ((cur_attr == USB_ENDPOINT_SYNC_ASYNC && |
97 | subs->direction == SNDRV_PCM_STREAM_PLAYBACK) || |
98 | (cur_attr == USB_ENDPOINT_SYNC_ADAPTIVE && |
99 | subs->direction == SNDRV_PCM_STREAM_CAPTURE)) { |
100 | found = fp; |
101 | cur_attr = attr; |
102 | continue; |
103 | } |
104 | } |
105 | /* find the format with the largest max. packet size */ |
106 | if (fp->maxpacksize > found->maxpacksize) { |
107 | found = fp; |
108 | cur_attr = attr; |
109 | } |
110 | } |
111 | return found; |
112 | } |
113 | |
114 | static int init_pitch_v1(struct snd_usb_audio *chip, int iface, |
115 | struct usb_host_interface *alts, |
116 | struct audioformat *fmt) |
117 | { |
118 | struct usb_device *dev = chip->dev; |
119 | unsigned int ep; |
120 | unsigned char data[1]; |
121 | int err; |
122 | |
123 | ep = get_endpoint(alts, 0)->bEndpointAddress; |
124 | |
125 | data[0] = 1; |
126 | if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR, |
127 | USB_TYPE_CLASS|USB_RECIP_ENDPOINT|USB_DIR_OUT, |
128 | UAC_EP_CS_ATTR_PITCH_CONTROL << 8, ep, |
129 | data, sizeof(data), 1000)) < 0) { |
130 | snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH\n", |
131 | dev->devnum, iface, ep); |
132 | return err; |
133 | } |
134 | |
135 | return 0; |
136 | } |
137 | |
138 | static int init_pitch_v2(struct snd_usb_audio *chip, int iface, |
139 | struct usb_host_interface *alts, |
140 | struct audioformat *fmt) |
141 | { |
142 | struct usb_device *dev = chip->dev; |
143 | unsigned char data[1]; |
144 | unsigned int ep; |
145 | int err; |
146 | |
147 | ep = get_endpoint(alts, 0)->bEndpointAddress; |
148 | |
149 | data[0] = 1; |
150 | if ((err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR, |
151 | USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT, |
152 | UAC2_EP_CS_PITCH << 8, 0, |
153 | data, sizeof(data), 1000)) < 0) { |
154 | snd_printk(KERN_ERR "%d:%d:%d: cannot set enable PITCH (v2)\n", |
155 | dev->devnum, iface, fmt->altsetting); |
156 | return err; |
157 | } |
158 | |
159 | return 0; |
160 | } |
161 | |
162 | /* |
163 | * initialize the pitch control and sample rate |
164 | */ |
165 | int snd_usb_init_pitch(struct snd_usb_audio *chip, int iface, |
166 | struct usb_host_interface *alts, |
167 | struct audioformat *fmt) |
168 | { |
169 | struct usb_interface_descriptor *altsd = get_iface_desc(alts); |
170 | |
171 | /* if endpoint doesn't have pitch control, bail out */ |
172 | if (!(fmt->attributes & UAC_EP_CS_ATTR_PITCH_CONTROL)) |
173 | return 0; |
174 | |
175 | switch (altsd->bInterfaceProtocol) { |
176 | case UAC_VERSION_1: |
177 | default: |
178 | return init_pitch_v1(chip, iface, alts, fmt); |
179 | |
180 | case UAC_VERSION_2: |
181 | return init_pitch_v2(chip, iface, alts, fmt); |
182 | } |
183 | } |
184 | |
185 | /* |
186 | * find a matching format and set up the interface |
187 | */ |
188 | static int set_format(struct snd_usb_substream *subs, struct audioformat *fmt) |
189 | { |
190 | struct usb_device *dev = subs->dev; |
191 | struct usb_host_interface *alts; |
192 | struct usb_interface_descriptor *altsd; |
193 | struct usb_interface *iface; |
194 | unsigned int ep, attr; |
195 | int is_playback = subs->direction == SNDRV_PCM_STREAM_PLAYBACK; |
196 | int err; |
197 | |
198 | iface = usb_ifnum_to_if(dev, fmt->iface); |
199 | if (WARN_ON(!iface)) |
200 | return -EINVAL; |
201 | alts = &iface->altsetting[fmt->altset_idx]; |
202 | altsd = get_iface_desc(alts); |
203 | if (WARN_ON(altsd->bAlternateSetting != fmt->altsetting)) |
204 | return -EINVAL; |
205 | |
206 | if (fmt == subs->cur_audiofmt) |
207 | return 0; |
208 | |
209 | /* close the old interface */ |
210 | if (subs->interface >= 0 && subs->interface != fmt->iface) { |
211 | if (usb_set_interface(subs->dev, subs->interface, 0) < 0) { |
212 | snd_printk(KERN_ERR "%d:%d:%d: return to setting 0 failed\n", |
213 | dev->devnum, fmt->iface, fmt->altsetting); |
214 | return -EIO; |
215 | } |
216 | subs->interface = -1; |
217 | subs->altset_idx = 0; |
218 | } |
219 | |
220 | /* set interface */ |
221 | if (subs->interface != fmt->iface || subs->altset_idx != fmt->altset_idx) { |
222 | if (usb_set_interface(dev, fmt->iface, fmt->altsetting) < 0) { |
223 | snd_printk(KERN_ERR "%d:%d:%d: usb_set_interface failed\n", |
224 | dev->devnum, fmt->iface, fmt->altsetting); |
225 | return -EIO; |
226 | } |
227 | snd_printdd(KERN_INFO "setting usb interface %d:%d\n", fmt->iface, fmt->altsetting); |
228 | subs->interface = fmt->iface; |
229 | subs->altset_idx = fmt->altset_idx; |
230 | } |
231 | |
232 | /* create a data pipe */ |
233 | ep = fmt->endpoint & USB_ENDPOINT_NUMBER_MASK; |
234 | if (is_playback) |
235 | subs->datapipe = usb_sndisocpipe(dev, ep); |
236 | else |
237 | subs->datapipe = usb_rcvisocpipe(dev, ep); |
238 | subs->datainterval = fmt->datainterval; |
239 | subs->syncpipe = subs->syncinterval = 0; |
240 | subs->maxpacksize = fmt->maxpacksize; |
241 | subs->syncmaxsize = 0; |
242 | subs->fill_max = 0; |
243 | |
244 | /* we need a sync pipe in async OUT or adaptive IN mode */ |
245 | /* check the number of EP, since some devices have broken |
246 | * descriptors which fool us. if it has only one EP, |
247 | * assume it as adaptive-out or sync-in. |
248 | */ |
249 | attr = fmt->ep_attr & USB_ENDPOINT_SYNCTYPE; |
250 | if (((is_playback && attr == USB_ENDPOINT_SYNC_ASYNC) || |
251 | (! is_playback && attr == USB_ENDPOINT_SYNC_ADAPTIVE)) && |
252 | altsd->bNumEndpoints >= 2) { |
253 | /* check sync-pipe endpoint */ |
254 | /* ... and check descriptor size before accessing bSynchAddress |
255 | because there is a version of the SB Audigy 2 NX firmware lacking |
256 | the audio fields in the endpoint descriptors */ |
257 | if ((get_endpoint(alts, 1)->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) != 0x01 || |
258 | (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && |
259 | get_endpoint(alts, 1)->bSynchAddress != 0)) { |
260 | snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n", |
261 | dev->devnum, fmt->iface, fmt->altsetting); |
262 | return -EINVAL; |
263 | } |
264 | ep = get_endpoint(alts, 1)->bEndpointAddress; |
265 | if (get_endpoint(alts, 0)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && |
266 | (( is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress | USB_DIR_IN)) || |
267 | (!is_playback && ep != (unsigned int)(get_endpoint(alts, 0)->bSynchAddress & ~USB_DIR_IN)))) { |
268 | snd_printk(KERN_ERR "%d:%d:%d : invalid synch pipe\n", |
269 | dev->devnum, fmt->iface, fmt->altsetting); |
270 | return -EINVAL; |
271 | } |
272 | ep &= USB_ENDPOINT_NUMBER_MASK; |
273 | if (is_playback) |
274 | subs->syncpipe = usb_rcvisocpipe(dev, ep); |
275 | else |
276 | subs->syncpipe = usb_sndisocpipe(dev, ep); |
277 | if (get_endpoint(alts, 1)->bLength >= USB_DT_ENDPOINT_AUDIO_SIZE && |
278 | get_endpoint(alts, 1)->bRefresh >= 1 && |
279 | get_endpoint(alts, 1)->bRefresh <= 9) |
280 | subs->syncinterval = get_endpoint(alts, 1)->bRefresh; |
281 | else if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) |
282 | subs->syncinterval = 1; |
283 | else if (get_endpoint(alts, 1)->bInterval >= 1 && |
284 | get_endpoint(alts, 1)->bInterval <= 16) |
285 | subs->syncinterval = get_endpoint(alts, 1)->bInterval - 1; |
286 | else |
287 | subs->syncinterval = 3; |
288 | subs->syncmaxsize = le16_to_cpu(get_endpoint(alts, 1)->wMaxPacketSize); |
289 | } |
290 | |
291 | /* always fill max packet size */ |
292 | if (fmt->attributes & UAC_EP_CS_ATTR_FILL_MAX) |
293 | subs->fill_max = 1; |
294 | |
295 | if ((err = snd_usb_init_pitch(subs->stream->chip, subs->interface, alts, fmt)) < 0) |
296 | return err; |
297 | |
298 | subs->cur_audiofmt = fmt; |
299 | |
300 | snd_usb_set_format_quirk(subs, fmt); |
301 | |
302 | #if 0 |
303 | printk(KERN_DEBUG |
304 | "setting done: format = %d, rate = %d..%d, channels = %d\n", |
305 | fmt->format, fmt->rate_min, fmt->rate_max, fmt->channels); |
306 | printk(KERN_DEBUG |
307 | " datapipe = 0x%0x, syncpipe = 0x%0x\n", |
308 | subs->datapipe, subs->syncpipe); |
309 | #endif |
310 | |
311 | return 0; |
312 | } |
313 | |
314 | /* |
315 | * hw_params callback |
316 | * |
317 | * allocate a buffer and set the given audio format. |
318 | * |
319 | * so far we use a physically linear buffer although packetize transfer |
320 | * doesn't need a continuous area. |
321 | * if sg buffer is supported on the later version of alsa, we'll follow |
322 | * that. |
323 | */ |
324 | static int snd_usb_hw_params(struct snd_pcm_substream *substream, |
325 | struct snd_pcm_hw_params *hw_params) |
326 | { |
327 | struct snd_usb_substream *subs = substream->runtime->private_data; |
328 | struct audioformat *fmt; |
329 | unsigned int channels, rate, format; |
330 | int ret, changed; |
331 | |
332 | ret = snd_pcm_lib_alloc_vmalloc_buffer(substream, |
333 | params_buffer_bytes(hw_params)); |
334 | if (ret < 0) |
335 | return ret; |
336 | |
337 | format = params_format(hw_params); |
338 | rate = params_rate(hw_params); |
339 | channels = params_channels(hw_params); |
340 | fmt = find_format(subs, format, rate, channels); |
341 | if (!fmt) { |
342 | snd_printd(KERN_DEBUG "cannot set format: format = %#x, rate = %d, channels = %d\n", |
343 | format, rate, channels); |
344 | return -EINVAL; |
345 | } |
346 | |
347 | changed = subs->cur_audiofmt != fmt || |
348 | subs->period_bytes != params_period_bytes(hw_params) || |
349 | subs->cur_rate != rate; |
350 | if ((ret = set_format(subs, fmt)) < 0) |
351 | return ret; |
352 | |
353 | if (subs->cur_rate != rate) { |
354 | struct usb_host_interface *alts; |
355 | struct usb_interface *iface; |
356 | iface = usb_ifnum_to_if(subs->dev, fmt->iface); |
357 | alts = &iface->altsetting[fmt->altset_idx]; |
358 | ret = snd_usb_init_sample_rate(subs->stream->chip, subs->interface, alts, fmt, rate); |
359 | if (ret < 0) |
360 | return ret; |
361 | subs->cur_rate = rate; |
362 | } |
363 | |
364 | if (changed) { |
365 | mutex_lock(&subs->stream->chip->shutdown_mutex); |
366 | /* format changed */ |
367 | snd_usb_release_substream_urbs(subs, 0); |
368 | /* influenced: period_bytes, channels, rate, format, */ |
369 | ret = snd_usb_init_substream_urbs(subs, params_period_bytes(hw_params), |
370 | params_rate(hw_params), |
371 | snd_pcm_format_physical_width(params_format(hw_params)) * |
372 | params_channels(hw_params)); |
373 | mutex_unlock(&subs->stream->chip->shutdown_mutex); |
374 | } |
375 | |
376 | return ret; |
377 | } |
378 | |
379 | /* |
380 | * hw_free callback |
381 | * |
382 | * reset the audio format and release the buffer |
383 | */ |
384 | static int snd_usb_hw_free(struct snd_pcm_substream *substream) |
385 | { |
386 | struct snd_usb_substream *subs = substream->runtime->private_data; |
387 | |
388 | subs->cur_audiofmt = NULL; |
389 | subs->cur_rate = 0; |
390 | subs->period_bytes = 0; |
391 | mutex_lock(&subs->stream->chip->shutdown_mutex); |
392 | snd_usb_release_substream_urbs(subs, 0); |
393 | mutex_unlock(&subs->stream->chip->shutdown_mutex); |
394 | return snd_pcm_lib_free_vmalloc_buffer(substream); |
395 | } |
396 | |
397 | /* |
398 | * prepare callback |
399 | * |
400 | * only a few subtle things... |
401 | */ |
402 | static int snd_usb_pcm_prepare(struct snd_pcm_substream *substream) |
403 | { |
404 | struct snd_pcm_runtime *runtime = substream->runtime; |
405 | struct snd_usb_substream *subs = runtime->private_data; |
406 | |
407 | if (! subs->cur_audiofmt) { |
408 | snd_printk(KERN_ERR "usbaudio: no format is specified!\n"); |
409 | return -ENXIO; |
410 | } |
411 | |
412 | /* some unit conversions in runtime */ |
413 | subs->maxframesize = bytes_to_frames(runtime, subs->maxpacksize); |
414 | subs->curframesize = bytes_to_frames(runtime, subs->curpacksize); |
415 | |
416 | /* reset the pointer */ |
417 | subs->hwptr_done = 0; |
418 | subs->transfer_done = 0; |
419 | subs->phase = 0; |
420 | runtime->delay = 0; |
421 | |
422 | return snd_usb_substream_prepare(subs, runtime); |
423 | } |
424 | |
425 | static struct snd_pcm_hardware snd_usb_hardware = |
426 | { |
427 | .info = SNDRV_PCM_INFO_MMAP | |
428 | SNDRV_PCM_INFO_MMAP_VALID | |
429 | SNDRV_PCM_INFO_BATCH | |
430 | SNDRV_PCM_INFO_INTERLEAVED | |
431 | SNDRV_PCM_INFO_BLOCK_TRANSFER | |
432 | SNDRV_PCM_INFO_PAUSE, |
433 | .buffer_bytes_max = 1024 * 1024, |
434 | .period_bytes_min = 64, |
435 | .period_bytes_max = 512 * 1024, |
436 | .periods_min = 2, |
437 | .periods_max = 1024, |
438 | }; |
439 | |
440 | static int hw_check_valid_format(struct snd_usb_substream *subs, |
441 | struct snd_pcm_hw_params *params, |
442 | struct audioformat *fp) |
443 | { |
444 | struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); |
445 | struct snd_interval *ct = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); |
446 | struct snd_mask *fmts = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); |
447 | struct snd_interval *pt = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME); |
448 | struct snd_mask check_fmts; |
449 | unsigned int ptime; |
450 | |
451 | /* check the format */ |
452 | snd_mask_none(&check_fmts); |
453 | check_fmts.bits[0] = (u32)fp->formats; |
454 | check_fmts.bits[1] = (u32)(fp->formats >> 32); |
455 | snd_mask_intersect(&check_fmts, fmts); |
456 | if (snd_mask_empty(&check_fmts)) { |
457 | hwc_debug(" > check: no supported format %d\n", fp->format); |
458 | return 0; |
459 | } |
460 | /* check the channels */ |
461 | if (fp->channels < ct->min || fp->channels > ct->max) { |
462 | hwc_debug(" > check: no valid channels %d (%d/%d)\n", fp->channels, ct->min, ct->max); |
463 | return 0; |
464 | } |
465 | /* check the rate is within the range */ |
466 | if (fp->rate_min > it->max || (fp->rate_min == it->max && it->openmax)) { |
467 | hwc_debug(" > check: rate_min %d > max %d\n", fp->rate_min, it->max); |
468 | return 0; |
469 | } |
470 | if (fp->rate_max < it->min || (fp->rate_max == it->min && it->openmin)) { |
471 | hwc_debug(" > check: rate_max %d < min %d\n", fp->rate_max, it->min); |
472 | return 0; |
473 | } |
474 | /* check whether the period time is >= the data packet interval */ |
475 | if (snd_usb_get_speed(subs->dev) != USB_SPEED_FULL) { |
476 | ptime = 125 * (1 << fp->datainterval); |
477 | if (ptime > pt->max || (ptime == pt->max && pt->openmax)) { |
478 | hwc_debug(" > check: ptime %u > max %u\n", ptime, pt->max); |
479 | return 0; |
480 | } |
481 | } |
482 | return 1; |
483 | } |
484 | |
485 | static int hw_rule_rate(struct snd_pcm_hw_params *params, |
486 | struct snd_pcm_hw_rule *rule) |
487 | { |
488 | struct snd_usb_substream *subs = rule->private; |
489 | struct list_head *p; |
490 | struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); |
491 | unsigned int rmin, rmax; |
492 | int changed; |
493 | |
494 | hwc_debug("hw_rule_rate: (%d,%d)\n", it->min, it->max); |
495 | changed = 0; |
496 | rmin = rmax = 0; |
497 | list_for_each(p, &subs->fmt_list) { |
498 | struct audioformat *fp; |
499 | fp = list_entry(p, struct audioformat, list); |
500 | if (!hw_check_valid_format(subs, params, fp)) |
501 | continue; |
502 | if (changed++) { |
503 | if (rmin > fp->rate_min) |
504 | rmin = fp->rate_min; |
505 | if (rmax < fp->rate_max) |
506 | rmax = fp->rate_max; |
507 | } else { |
508 | rmin = fp->rate_min; |
509 | rmax = fp->rate_max; |
510 | } |
511 | } |
512 | |
513 | if (!changed) { |
514 | hwc_debug(" --> get empty\n"); |
515 | it->empty = 1; |
516 | return -EINVAL; |
517 | } |
518 | |
519 | changed = 0; |
520 | if (it->min < rmin) { |
521 | it->min = rmin; |
522 | it->openmin = 0; |
523 | changed = 1; |
524 | } |
525 | if (it->max > rmax) { |
526 | it->max = rmax; |
527 | it->openmax = 0; |
528 | changed = 1; |
529 | } |
530 | if (snd_interval_checkempty(it)) { |
531 | it->empty = 1; |
532 | return -EINVAL; |
533 | } |
534 | hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed); |
535 | return changed; |
536 | } |
537 | |
538 | |
539 | static int hw_rule_channels(struct snd_pcm_hw_params *params, |
540 | struct snd_pcm_hw_rule *rule) |
541 | { |
542 | struct snd_usb_substream *subs = rule->private; |
543 | struct list_head *p; |
544 | struct snd_interval *it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); |
545 | unsigned int rmin, rmax; |
546 | int changed; |
547 | |
548 | hwc_debug("hw_rule_channels: (%d,%d)\n", it->min, it->max); |
549 | changed = 0; |
550 | rmin = rmax = 0; |
551 | list_for_each(p, &subs->fmt_list) { |
552 | struct audioformat *fp; |
553 | fp = list_entry(p, struct audioformat, list); |
554 | if (!hw_check_valid_format(subs, params, fp)) |
555 | continue; |
556 | if (changed++) { |
557 | if (rmin > fp->channels) |
558 | rmin = fp->channels; |
559 | if (rmax < fp->channels) |
560 | rmax = fp->channels; |
561 | } else { |
562 | rmin = fp->channels; |
563 | rmax = fp->channels; |
564 | } |
565 | } |
566 | |
567 | if (!changed) { |
568 | hwc_debug(" --> get empty\n"); |
569 | it->empty = 1; |
570 | return -EINVAL; |
571 | } |
572 | |
573 | changed = 0; |
574 | if (it->min < rmin) { |
575 | it->min = rmin; |
576 | it->openmin = 0; |
577 | changed = 1; |
578 | } |
579 | if (it->max > rmax) { |
580 | it->max = rmax; |
581 | it->openmax = 0; |
582 | changed = 1; |
583 | } |
584 | if (snd_interval_checkempty(it)) { |
585 | it->empty = 1; |
586 | return -EINVAL; |
587 | } |
588 | hwc_debug(" --> (%d, %d) (changed = %d)\n", it->min, it->max, changed); |
589 | return changed; |
590 | } |
591 | |
592 | static int hw_rule_format(struct snd_pcm_hw_params *params, |
593 | struct snd_pcm_hw_rule *rule) |
594 | { |
595 | struct snd_usb_substream *subs = rule->private; |
596 | struct list_head *p; |
597 | struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); |
598 | u64 fbits; |
599 | u32 oldbits[2]; |
600 | int changed; |
601 | |
602 | hwc_debug("hw_rule_format: %x:%x\n", fmt->bits[0], fmt->bits[1]); |
603 | fbits = 0; |
604 | list_for_each(p, &subs->fmt_list) { |
605 | struct audioformat *fp; |
606 | fp = list_entry(p, struct audioformat, list); |
607 | if (!hw_check_valid_format(subs, params, fp)) |
608 | continue; |
609 | fbits |= fp->formats; |
610 | } |
611 | |
612 | oldbits[0] = fmt->bits[0]; |
613 | oldbits[1] = fmt->bits[1]; |
614 | fmt->bits[0] &= (u32)fbits; |
615 | fmt->bits[1] &= (u32)(fbits >> 32); |
616 | if (!fmt->bits[0] && !fmt->bits[1]) { |
617 | hwc_debug(" --> get empty\n"); |
618 | return -EINVAL; |
619 | } |
620 | changed = (oldbits[0] != fmt->bits[0] || oldbits[1] != fmt->bits[1]); |
621 | hwc_debug(" --> %x:%x (changed = %d)\n", fmt->bits[0], fmt->bits[1], changed); |
622 | return changed; |
623 | } |
624 | |
625 | static int hw_rule_period_time(struct snd_pcm_hw_params *params, |
626 | struct snd_pcm_hw_rule *rule) |
627 | { |
628 | struct snd_usb_substream *subs = rule->private; |
629 | struct audioformat *fp; |
630 | struct snd_interval *it; |
631 | unsigned char min_datainterval; |
632 | unsigned int pmin; |
633 | int changed; |
634 | |
635 | it = hw_param_interval(params, SNDRV_PCM_HW_PARAM_PERIOD_TIME); |
636 | hwc_debug("hw_rule_period_time: (%u,%u)\n", it->min, it->max); |
637 | min_datainterval = 0xff; |
638 | list_for_each_entry(fp, &subs->fmt_list, list) { |
639 | if (!hw_check_valid_format(subs, params, fp)) |
640 | continue; |
641 | min_datainterval = min(min_datainterval, fp->datainterval); |
642 | } |
643 | if (min_datainterval == 0xff) { |
644 | hwc_debug(" --> get empty\n"); |
645 | it->empty = 1; |
646 | return -EINVAL; |
647 | } |
648 | pmin = 125 * (1 << min_datainterval); |
649 | changed = 0; |
650 | if (it->min < pmin) { |
651 | it->min = pmin; |
652 | it->openmin = 0; |
653 | changed = 1; |
654 | } |
655 | if (snd_interval_checkempty(it)) { |
656 | it->empty = 1; |
657 | return -EINVAL; |
658 | } |
659 | hwc_debug(" --> (%u,%u) (changed = %d)\n", it->min, it->max, changed); |
660 | return changed; |
661 | } |
662 | |
663 | /* |
664 | * If the device supports unusual bit rates, does the request meet these? |
665 | */ |
666 | static int snd_usb_pcm_check_knot(struct snd_pcm_runtime *runtime, |
667 | struct snd_usb_substream *subs) |
668 | { |
669 | struct audioformat *fp; |
670 | int count = 0, needs_knot = 0; |
671 | int err; |
672 | |
673 | list_for_each_entry(fp, &subs->fmt_list, list) { |
674 | if (fp->rates & SNDRV_PCM_RATE_CONTINUOUS) |
675 | return 0; |
676 | count += fp->nr_rates; |
677 | if (fp->rates & SNDRV_PCM_RATE_KNOT) |
678 | needs_knot = 1; |
679 | } |
680 | if (!needs_knot) |
681 | return 0; |
682 | |
683 | subs->rate_list.list = kmalloc(sizeof(int) * count, GFP_KERNEL); |
684 | if (!subs->rate_list.list) |
685 | return -ENOMEM; |
686 | subs->rate_list.count = count; |
687 | subs->rate_list.mask = 0; |
688 | count = 0; |
689 | list_for_each_entry(fp, &subs->fmt_list, list) { |
690 | int i; |
691 | for (i = 0; i < fp->nr_rates; i++) |
692 | subs->rate_list.list[count++] = fp->rate_table[i]; |
693 | } |
694 | err = snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, |
695 | &subs->rate_list); |
696 | if (err < 0) |
697 | return err; |
698 | |
699 | return 0; |
700 | } |
701 | |
702 | |
703 | /* |
704 | * set up the runtime hardware information. |
705 | */ |
706 | |
707 | static int setup_hw_info(struct snd_pcm_runtime *runtime, struct snd_usb_substream *subs) |
708 | { |
709 | struct list_head *p; |
710 | unsigned int pt, ptmin; |
711 | int param_period_time_if_needed; |
712 | int err; |
713 | |
714 | runtime->hw.formats = subs->formats; |
715 | |
716 | runtime->hw.rate_min = 0x7fffffff; |
717 | runtime->hw.rate_max = 0; |
718 | runtime->hw.channels_min = 256; |
719 | runtime->hw.channels_max = 0; |
720 | runtime->hw.rates = 0; |
721 | ptmin = UINT_MAX; |
722 | /* check min/max rates and channels */ |
723 | list_for_each(p, &subs->fmt_list) { |
724 | struct audioformat *fp; |
725 | fp = list_entry(p, struct audioformat, list); |
726 | runtime->hw.rates |= fp->rates; |
727 | if (runtime->hw.rate_min > fp->rate_min) |
728 | runtime->hw.rate_min = fp->rate_min; |
729 | if (runtime->hw.rate_max < fp->rate_max) |
730 | runtime->hw.rate_max = fp->rate_max; |
731 | if (runtime->hw.channels_min > fp->channels) |
732 | runtime->hw.channels_min = fp->channels; |
733 | if (runtime->hw.channels_max < fp->channels) |
734 | runtime->hw.channels_max = fp->channels; |
735 | if (fp->fmt_type == UAC_FORMAT_TYPE_II && fp->frame_size > 0) { |
736 | /* FIXME: there might be more than one audio formats... */ |
737 | runtime->hw.period_bytes_min = runtime->hw.period_bytes_max = |
738 | fp->frame_size; |
739 | } |
740 | pt = 125 * (1 << fp->datainterval); |
741 | ptmin = min(ptmin, pt); |
742 | } |
743 | err = snd_usb_autoresume(subs->stream->chip); |
744 | if (err < 0) |
745 | return err; |
746 | |
747 | param_period_time_if_needed = SNDRV_PCM_HW_PARAM_PERIOD_TIME; |
748 | if (snd_usb_get_speed(subs->dev) == USB_SPEED_FULL) |
749 | /* full speed devices have fixed data packet interval */ |
750 | ptmin = 1000; |
751 | if (ptmin == 1000) |
752 | /* if period time doesn't go below 1 ms, no rules needed */ |
753 | param_period_time_if_needed = -1; |
754 | snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, |
755 | ptmin, UINT_MAX); |
756 | |
757 | if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, |
758 | hw_rule_rate, subs, |
759 | SNDRV_PCM_HW_PARAM_FORMAT, |
760 | SNDRV_PCM_HW_PARAM_CHANNELS, |
761 | param_period_time_if_needed, |
762 | -1)) < 0) |
763 | goto rep_err; |
764 | if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, |
765 | hw_rule_channels, subs, |
766 | SNDRV_PCM_HW_PARAM_FORMAT, |
767 | SNDRV_PCM_HW_PARAM_RATE, |
768 | param_period_time_if_needed, |
769 | -1)) < 0) |
770 | goto rep_err; |
771 | if ((err = snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT, |
772 | hw_rule_format, subs, |
773 | SNDRV_PCM_HW_PARAM_RATE, |
774 | SNDRV_PCM_HW_PARAM_CHANNELS, |
775 | param_period_time_if_needed, |
776 | -1)) < 0) |
777 | goto rep_err; |
778 | if (param_period_time_if_needed >= 0) { |
779 | err = snd_pcm_hw_rule_add(runtime, 0, |
780 | SNDRV_PCM_HW_PARAM_PERIOD_TIME, |
781 | hw_rule_period_time, subs, |
782 | SNDRV_PCM_HW_PARAM_FORMAT, |
783 | SNDRV_PCM_HW_PARAM_CHANNELS, |
784 | SNDRV_PCM_HW_PARAM_RATE, |
785 | -1); |
786 | if (err < 0) |
787 | goto rep_err; |
788 | } |
789 | if ((err = snd_usb_pcm_check_knot(runtime, subs)) < 0) |
790 | goto rep_err; |
791 | return 0; |
792 | |
793 | rep_err: |
794 | snd_usb_autosuspend(subs->stream->chip); |
795 | return err; |
796 | } |
797 | |
798 | static int snd_usb_pcm_open(struct snd_pcm_substream *substream, int direction) |
799 | { |
800 | struct snd_usb_stream *as = snd_pcm_substream_chip(substream); |
801 | struct snd_pcm_runtime *runtime = substream->runtime; |
802 | struct snd_usb_substream *subs = &as->substream[direction]; |
803 | |
804 | subs->interface = -1; |
805 | subs->altset_idx = 0; |
806 | runtime->hw = snd_usb_hardware; |
807 | runtime->private_data = subs; |
808 | subs->pcm_substream = substream; |
809 | /* runtime PM is also done there */ |
810 | return setup_hw_info(runtime, subs); |
811 | } |
812 | |
813 | static int snd_usb_pcm_close(struct snd_pcm_substream *substream, int direction) |
814 | { |
815 | struct snd_usb_stream *as = snd_pcm_substream_chip(substream); |
816 | struct snd_usb_substream *subs = &as->substream[direction]; |
817 | |
818 | if (!as->chip->shutdown && subs->interface >= 0) { |
819 | usb_set_interface(subs->dev, subs->interface, 0); |
820 | subs->interface = -1; |
821 | } |
822 | subs->pcm_substream = NULL; |
823 | snd_usb_autosuspend(subs->stream->chip); |
824 | return 0; |
825 | } |
826 | |
827 | static int snd_usb_playback_open(struct snd_pcm_substream *substream) |
828 | { |
829 | return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_PLAYBACK); |
830 | } |
831 | |
832 | static int snd_usb_playback_close(struct snd_pcm_substream *substream) |
833 | { |
834 | return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_PLAYBACK); |
835 | } |
836 | |
837 | static int snd_usb_capture_open(struct snd_pcm_substream *substream) |
838 | { |
839 | return snd_usb_pcm_open(substream, SNDRV_PCM_STREAM_CAPTURE); |
840 | } |
841 | |
842 | static int snd_usb_capture_close(struct snd_pcm_substream *substream) |
843 | { |
844 | return snd_usb_pcm_close(substream, SNDRV_PCM_STREAM_CAPTURE); |
845 | } |
846 | |
847 | static struct snd_pcm_ops snd_usb_playback_ops = { |
848 | .open = snd_usb_playback_open, |
849 | .close = snd_usb_playback_close, |
850 | .ioctl = snd_pcm_lib_ioctl, |
851 | .hw_params = snd_usb_hw_params, |
852 | .hw_free = snd_usb_hw_free, |
853 | .prepare = snd_usb_pcm_prepare, |
854 | .trigger = snd_usb_substream_playback_trigger, |
855 | .pointer = snd_usb_pcm_pointer, |
856 | .page = snd_pcm_lib_get_vmalloc_page, |
857 | .mmap = snd_pcm_lib_mmap_vmalloc, |
858 | }; |
859 | |
860 | static struct snd_pcm_ops snd_usb_capture_ops = { |
861 | .open = snd_usb_capture_open, |
862 | .close = snd_usb_capture_close, |
863 | .ioctl = snd_pcm_lib_ioctl, |
864 | .hw_params = snd_usb_hw_params, |
865 | .hw_free = snd_usb_hw_free, |
866 | .prepare = snd_usb_pcm_prepare, |
867 | .trigger = snd_usb_substream_capture_trigger, |
868 | .pointer = snd_usb_pcm_pointer, |
869 | .page = snd_pcm_lib_get_vmalloc_page, |
870 | .mmap = snd_pcm_lib_mmap_vmalloc, |
871 | }; |
872 | |
873 | void snd_usb_set_pcm_ops(struct snd_pcm *pcm, int stream) |
874 | { |
875 | snd_pcm_set_ops(pcm, stream, |
876 | stream == SNDRV_PCM_STREAM_PLAYBACK ? |
877 | &snd_usb_playback_ops : &snd_usb_capture_ops); |
878 | } |
879 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9