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