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