1 /* 2 * Edirol UA-101/UA-1000 driver 3 * Copyright (c) Clemens Ladisch <clemens@ladisch.de> 4 * 5 * This driver is free software: you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License, version 2. 7 * 8 * This driver is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this driver. If not, see <http://www.gnu.org/licenses/>. 15 */ 16 17 #include <linux/init.h> 18 #include <linux/module.h> 19 #include <linux/slab.h> 20 #include <linux/usb.h> 21 #include <linux/usb/audio.h> 22 #include <sound/core.h> 23 #include <sound/initval.h> 24 #include <sound/pcm.h> 25 #include <sound/pcm_params.h> 26 #include "../usbaudio.h" 27 #include "../midi.h" 28 29 MODULE_DESCRIPTION("Edirol UA-101/1000 driver"); 30 MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); 31 MODULE_LICENSE("GPL v2"); 32 MODULE_SUPPORTED_DEVICE("{{Edirol,UA-101},{Edirol,UA-1000}}"); 33 34 /* 35 * Should not be lower than the minimum scheduling delay of the host 36 * controller. Some Intel controllers need more than one frame; as long as 37 * that driver doesn't tell us about this, use 1.5 frames just to be sure. 38 */ 39 #define MIN_QUEUE_LENGTH 12 40 /* Somewhat random. */ 41 #define MAX_QUEUE_LENGTH 30 42 /* 43 * This magic value optimizes memory usage efficiency for the UA-101's packet 44 * sizes at all sample rates, taking into account the stupid cache pool sizes 45 * that usb_alloc_coherent() uses. 46 */ 47 #define DEFAULT_QUEUE_LENGTH 21 48 49 #define MAX_PACKET_SIZE 672 /* hardware specific */ 50 #define MAX_MEMORY_BUFFERS DIV_ROUND_UP(MAX_QUEUE_LENGTH, \ 51 PAGE_SIZE / MAX_PACKET_SIZE) 52 53 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; 54 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; 55 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; 56 static unsigned int queue_length = 21; 57 58 module_param_array(index, int, NULL, 0444); 59 MODULE_PARM_DESC(index, "card index"); 60 module_param_array(id, charp, NULL, 0444); 61 MODULE_PARM_DESC(id, "ID string"); 62 module_param_array(enable, bool, NULL, 0444); 63 MODULE_PARM_DESC(enable, "enable card"); 64 module_param(queue_length, uint, 0644); 65 MODULE_PARM_DESC(queue_length, "USB queue length in microframes, " 66 __stringify(MIN_QUEUE_LENGTH)"-"__stringify(MAX_QUEUE_LENGTH)); 67 68 enum { 69 INTF_PLAYBACK, 70 INTF_CAPTURE, 71 INTF_MIDI, 72 73 INTF_COUNT 74 }; 75 76 /* bits in struct ua101::states */ 77 enum { 78 USB_CAPTURE_RUNNING, 79 USB_PLAYBACK_RUNNING, 80 ALSA_CAPTURE_OPEN, 81 ALSA_PLAYBACK_OPEN, 82 ALSA_CAPTURE_RUNNING, 83 ALSA_PLAYBACK_RUNNING, 84 CAPTURE_URB_COMPLETED, 85 PLAYBACK_URB_COMPLETED, 86 DISCONNECTED, 87 }; 88 89 struct ua101 { 90 struct usb_device *dev; 91 struct snd_card *card; 92 struct usb_interface *intf[INTF_COUNT]; 93 int card_index; 94 struct snd_pcm *pcm; 95 struct list_head midi_list; 96 u64 format_bit; 97 unsigned int rate; 98 unsigned int packets_per_second; 99 spinlock_t lock; 100 struct mutex mutex; 101 unsigned long states; 102 103 /* FIFO to synchronize playback rate to capture rate */ 104 unsigned int rate_feedback_start; 105 unsigned int rate_feedback_count; 106 u8 rate_feedback[MAX_QUEUE_LENGTH]; 107 108 struct list_head ready_playback_urbs; 109 struct tasklet_struct playback_tasklet; 110 wait_queue_head_t alsa_capture_wait; 111 wait_queue_head_t rate_feedback_wait; 112 wait_queue_head_t alsa_playback_wait; 113 struct ua101_stream { 114 struct snd_pcm_substream *substream; 115 unsigned int usb_pipe; 116 unsigned int channels; 117 unsigned int frame_bytes; 118 unsigned int max_packet_bytes; 119 unsigned int period_pos; 120 unsigned int buffer_pos; 121 unsigned int queue_length; 122 struct ua101_urb { 123 struct urb urb; 124 struct usb_iso_packet_descriptor iso_frame_desc[1]; 125 struct list_head ready_list; 126 } *urbs[MAX_QUEUE_LENGTH]; 127 struct { 128 unsigned int size; 129 void *addr; 130 dma_addr_t dma; 131 } buffers[MAX_MEMORY_BUFFERS]; 132 } capture, playback; 133 }; 134 135 static DEFINE_MUTEX(devices_mutex); 136 static unsigned int devices_used; 137 static struct usb_driver ua101_driver; 138 139 static void abort_alsa_playback(struct ua101 *ua); 140 static void abort_alsa_capture(struct ua101 *ua); 141 142 static const char *usb_error_string(int err) 143 { 144 switch (err) { 145 case -ENODEV: 146 return "no device"; 147 case -ENOENT: 148 return "endpoint not enabled"; 149 case -EPIPE: 150 return "endpoint stalled"; 151 case -ENOSPC: 152 return "not enough bandwidth"; 153 case -ESHUTDOWN: 154 return "device disabled"; 155 case -EHOSTUNREACH: 156 return "device suspended"; 157 case -EINVAL: 158 case -EAGAIN: 159 case -EFBIG: 160 case -EMSGSIZE: 161 return "internal error"; 162 default: 163 return "unknown error"; 164 } 165 } 166 167 static void abort_usb_capture(struct ua101 *ua) 168 { 169 if (test_and_clear_bit(USB_CAPTURE_RUNNING, &ua->states)) { 170 wake_up(&ua->alsa_capture_wait); 171 wake_up(&ua->rate_feedback_wait); 172 } 173 } 174 175 static void abort_usb_playback(struct ua101 *ua) 176 { 177 if (test_and_clear_bit(USB_PLAYBACK_RUNNING, &ua->states)) 178 wake_up(&ua->alsa_playback_wait); 179 } 180 181 static void playback_urb_complete(struct urb *usb_urb) 182 { 183 struct ua101_urb *urb = (struct ua101_urb *)usb_urb; 184 struct ua101 *ua = urb->urb.context; 185 unsigned long flags; 186 187 if (unlikely(urb->urb.status == -ENOENT || /* unlinked */ 188 urb->urb.status == -ENODEV || /* device removed */ 189 urb->urb.status == -ECONNRESET || /* unlinked */ 190 urb->urb.status == -ESHUTDOWN)) { /* device disabled */ 191 abort_usb_playback(ua); 192 abort_alsa_playback(ua); 193 return; 194 } 195 196 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) { 197 /* append URB to FIFO */ 198 spin_lock_irqsave(&ua->lock, flags); 199 list_add_tail(&urb->ready_list, &ua->ready_playback_urbs); 200 if (ua->rate_feedback_count > 0) 201 tasklet_schedule(&ua->playback_tasklet); 202 ua->playback.substream->runtime->delay -= 203 urb->urb.iso_frame_desc[0].length / 204 ua->playback.frame_bytes; 205 spin_unlock_irqrestore(&ua->lock, flags); 206 } 207 } 208 209 static void first_playback_urb_complete(struct urb *urb) 210 { 211 struct ua101 *ua = urb->context; 212 213 urb->complete = playback_urb_complete; 214 playback_urb_complete(urb); 215 216 set_bit(PLAYBACK_URB_COMPLETED, &ua->states); 217 wake_up(&ua->alsa_playback_wait); 218 } 219 220 /* copy data from the ALSA ring buffer into the URB buffer */ 221 static bool copy_playback_data(struct ua101_stream *stream, struct urb *urb, 222 unsigned int frames) 223 { 224 struct snd_pcm_runtime *runtime; 225 unsigned int frame_bytes, frames1; 226 const u8 *source; 227 228 runtime = stream->substream->runtime; 229 frame_bytes = stream->frame_bytes; 230 source = runtime->dma_area + stream->buffer_pos * frame_bytes; 231 if (stream->buffer_pos + frames <= runtime->buffer_size) { 232 memcpy(urb->transfer_buffer, source, frames * frame_bytes); 233 } else { 234 /* wrap around at end of ring buffer */ 235 frames1 = runtime->buffer_size - stream->buffer_pos; 236 memcpy(urb->transfer_buffer, source, frames1 * frame_bytes); 237 memcpy(urb->transfer_buffer + frames1 * frame_bytes, 238 runtime->dma_area, (frames - frames1) * frame_bytes); 239 } 240 241 stream->buffer_pos += frames; 242 if (stream->buffer_pos >= runtime->buffer_size) 243 stream->buffer_pos -= runtime->buffer_size; 244 stream->period_pos += frames; 245 if (stream->period_pos >= runtime->period_size) { 246 stream->period_pos -= runtime->period_size; 247 return true; 248 } 249 return false; 250 } 251 252 static inline void add_with_wraparound(struct ua101 *ua, 253 unsigned int *value, unsigned int add) 254 { 255 *value += add; 256 if (*value >= ua->playback.queue_length) 257 *value -= ua->playback.queue_length; 258 } 259 260 static void playback_tasklet(unsigned long data) 261 { 262 struct ua101 *ua = (void *)data; 263 unsigned long flags; 264 unsigned int frames; 265 struct ua101_urb *urb; 266 bool do_period_elapsed = false; 267 int err; 268 269 if (unlikely(!test_bit(USB_PLAYBACK_RUNNING, &ua->states))) 270 return; 271 272 /* 273 * Synchronizing the playback rate to the capture rate is done by using 274 * the same sequence of packet sizes for both streams. 275 * Submitting a playback URB therefore requires both a ready URB and 276 * the size of the corresponding capture packet, i.e., both playback 277 * and capture URBs must have been completed. Since the USB core does 278 * not guarantee that playback and capture complete callbacks are 279 * called alternately, we use two FIFOs for packet sizes and read URBs; 280 * submitting playback URBs is possible as long as both FIFOs are 281 * nonempty. 282 */ 283 spin_lock_irqsave(&ua->lock, flags); 284 while (ua->rate_feedback_count > 0 && 285 !list_empty(&ua->ready_playback_urbs)) { 286 /* take packet size out of FIFO */ 287 frames = ua->rate_feedback[ua->rate_feedback_start]; 288 add_with_wraparound(ua, &ua->rate_feedback_start, 1); 289 ua->rate_feedback_count--; 290 291 /* take URB out of FIFO */ 292 urb = list_first_entry(&ua->ready_playback_urbs, 293 struct ua101_urb, ready_list); 294 list_del(&urb->ready_list); 295 296 /* fill packet with data or silence */ 297 urb->urb.iso_frame_desc[0].length = 298 frames * ua->playback.frame_bytes; 299 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states)) 300 do_period_elapsed |= copy_playback_data(&ua->playback, 301 &urb->urb, 302 frames); 303 else 304 memset(urb->urb.transfer_buffer, 0, 305 urb->urb.iso_frame_desc[0].length); 306 307 /* and off you go ... */ 308 err = usb_submit_urb(&urb->urb, GFP_ATOMIC); 309 if (unlikely(err < 0)) { 310 spin_unlock_irqrestore(&ua->lock, flags); 311 abort_usb_playback(ua); 312 abort_alsa_playback(ua); 313 dev_err(&ua->dev->dev, "USB request error %d: %s\n", 314 err, usb_error_string(err)); 315 return; 316 } 317 ua->playback.substream->runtime->delay += frames; 318 } 319 spin_unlock_irqrestore(&ua->lock, flags); 320 if (do_period_elapsed) 321 snd_pcm_period_elapsed(ua->playback.substream); 322 } 323 324 /* copy data from the URB buffer into the ALSA ring buffer */ 325 static bool copy_capture_data(struct ua101_stream *stream, struct urb *urb, 326 unsigned int frames) 327 { 328 struct snd_pcm_runtime *runtime; 329 unsigned int frame_bytes, frames1; 330 u8 *dest; 331 332 runtime = stream->substream->runtime; 333 frame_bytes = stream->frame_bytes; 334 dest = runtime->dma_area + stream->buffer_pos * frame_bytes; 335 if (stream->buffer_pos + frames <= runtime->buffer_size) { 336 memcpy(dest, urb->transfer_buffer, frames * frame_bytes); 337 } else { 338 /* wrap around at end of ring buffer */ 339 frames1 = runtime->buffer_size - stream->buffer_pos; 340 memcpy(dest, urb->transfer_buffer, frames1 * frame_bytes); 341 memcpy(runtime->dma_area, 342 urb->transfer_buffer + frames1 * frame_bytes, 343 (frames - frames1) * frame_bytes); 344 } 345 346 stream->buffer_pos += frames; 347 if (stream->buffer_pos >= runtime->buffer_size) 348 stream->buffer_pos -= runtime->buffer_size; 349 stream->period_pos += frames; 350 if (stream->period_pos >= runtime->period_size) { 351 stream->period_pos -= runtime->period_size; 352 return true; 353 } 354 return false; 355 } 356 357 static void capture_urb_complete(struct urb *urb) 358 { 359 struct ua101 *ua = urb->context; 360 struct ua101_stream *stream = &ua->capture; 361 unsigned long flags; 362 unsigned int frames, write_ptr; 363 bool do_period_elapsed; 364 int err; 365 366 if (unlikely(urb->status == -ENOENT || /* unlinked */ 367 urb->status == -ENODEV || /* device removed */ 368 urb->status == -ECONNRESET || /* unlinked */ 369 urb->status == -ESHUTDOWN)) /* device disabled */ 370 goto stream_stopped; 371 372 if (urb->status >= 0 && urb->iso_frame_desc[0].status >= 0) 373 frames = urb->iso_frame_desc[0].actual_length / 374 stream->frame_bytes; 375 else 376 frames = 0; 377 378 spin_lock_irqsave(&ua->lock, flags); 379 380 if (frames > 0 && test_bit(ALSA_CAPTURE_RUNNING, &ua->states)) 381 do_period_elapsed = copy_capture_data(stream, urb, frames); 382 else 383 do_period_elapsed = false; 384 385 if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) { 386 err = usb_submit_urb(urb, GFP_ATOMIC); 387 if (unlikely(err < 0)) { 388 spin_unlock_irqrestore(&ua->lock, flags); 389 dev_err(&ua->dev->dev, "USB request error %d: %s\n", 390 err, usb_error_string(err)); 391 goto stream_stopped; 392 } 393 394 /* append packet size to FIFO */ 395 write_ptr = ua->rate_feedback_start; 396 add_with_wraparound(ua, &write_ptr, ua->rate_feedback_count); 397 ua->rate_feedback[write_ptr] = frames; 398 if (ua->rate_feedback_count < ua->playback.queue_length) { 399 ua->rate_feedback_count++; 400 if (ua->rate_feedback_count == 401 ua->playback.queue_length) 402 wake_up(&ua->rate_feedback_wait); 403 } else { 404 /* 405 * Ring buffer overflow; this happens when the playback 406 * stream is not running. Throw away the oldest entry, 407 * so that the playback stream, when it starts, sees 408 * the most recent packet sizes. 409 */ 410 add_with_wraparound(ua, &ua->rate_feedback_start, 1); 411 } 412 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states) && 413 !list_empty(&ua->ready_playback_urbs)) 414 tasklet_schedule(&ua->playback_tasklet); 415 } 416 417 spin_unlock_irqrestore(&ua->lock, flags); 418 419 if (do_period_elapsed) 420 snd_pcm_period_elapsed(stream->substream); 421 422 return; 423 424 stream_stopped: 425 abort_usb_playback(ua); 426 abort_usb_capture(ua); 427 abort_alsa_playback(ua); 428 abort_alsa_capture(ua); 429 } 430 431 static void first_capture_urb_complete(struct urb *urb) 432 { 433 struct ua101 *ua = urb->context; 434 435 urb->complete = capture_urb_complete; 436 capture_urb_complete(urb); 437 438 set_bit(CAPTURE_URB_COMPLETED, &ua->states); 439 wake_up(&ua->alsa_capture_wait); 440 } 441 442 static int submit_stream_urbs(struct ua101 *ua, struct ua101_stream *stream) 443 { 444 unsigned int i; 445 446 for (i = 0; i < stream->queue_length; ++i) { 447 int err = usb_submit_urb(&stream->urbs[i]->urb, GFP_KERNEL); 448 if (err < 0) { 449 dev_err(&ua->dev->dev, "USB request error %d: %s\n", 450 err, usb_error_string(err)); 451 return err; 452 } 453 } 454 return 0; 455 } 456 457 static void kill_stream_urbs(struct ua101_stream *stream) 458 { 459 unsigned int i; 460 461 for (i = 0; i < stream->queue_length; ++i) 462 if (stream->urbs[i]) 463 usb_kill_urb(&stream->urbs[i]->urb); 464 } 465 466 static int enable_iso_interface(struct ua101 *ua, unsigned int intf_index) 467 { 468 struct usb_host_interface *alts; 469 470 alts = ua->intf[intf_index]->cur_altsetting; 471 if (alts->desc.bAlternateSetting != 1) { 472 int err = usb_set_interface(ua->dev, 473 alts->desc.bInterfaceNumber, 1); 474 if (err < 0) { 475 dev_err(&ua->dev->dev, 476 "cannot initialize interface; error %d: %s\n", 477 err, usb_error_string(err)); 478 return err; 479 } 480 } 481 return 0; 482 } 483 484 static void disable_iso_interface(struct ua101 *ua, unsigned int intf_index) 485 { 486 struct usb_host_interface *alts; 487 488 if (!ua->intf[intf_index]) 489 return; 490 491 alts = ua->intf[intf_index]->cur_altsetting; 492 if (alts->desc.bAlternateSetting != 0) { 493 int err = usb_set_interface(ua->dev, 494 alts->desc.bInterfaceNumber, 0); 495 if (err < 0 && !test_bit(DISCONNECTED, &ua->states)) 496 dev_warn(&ua->dev->dev, 497 "interface reset failed; error %d: %s\n", 498 err, usb_error_string(err)); 499 } 500 } 501 502 static void stop_usb_capture(struct ua101 *ua) 503 { 504 clear_bit(USB_CAPTURE_RUNNING, &ua->states); 505 506 kill_stream_urbs(&ua->capture); 507 508 disable_iso_interface(ua, INTF_CAPTURE); 509 } 510 511 static int start_usb_capture(struct ua101 *ua) 512 { 513 int err; 514 515 if (test_bit(DISCONNECTED, &ua->states)) 516 return -ENODEV; 517 518 if (test_bit(USB_CAPTURE_RUNNING, &ua->states)) 519 return 0; 520 521 kill_stream_urbs(&ua->capture); 522 523 err = enable_iso_interface(ua, INTF_CAPTURE); 524 if (err < 0) 525 return err; 526 527 clear_bit(CAPTURE_URB_COMPLETED, &ua->states); 528 ua->capture.urbs[0]->urb.complete = first_capture_urb_complete; 529 ua->rate_feedback_start = 0; 530 ua->rate_feedback_count = 0; 531 532 set_bit(USB_CAPTURE_RUNNING, &ua->states); 533 err = submit_stream_urbs(ua, &ua->capture); 534 if (err < 0) 535 stop_usb_capture(ua); 536 return err; 537 } 538 539 static void stop_usb_playback(struct ua101 *ua) 540 { 541 clear_bit(USB_PLAYBACK_RUNNING, &ua->states); 542 543 kill_stream_urbs(&ua->playback); 544 545 tasklet_kill(&ua->playback_tasklet); 546 547 disable_iso_interface(ua, INTF_PLAYBACK); 548 } 549 550 static int start_usb_playback(struct ua101 *ua) 551 { 552 unsigned int i, frames; 553 struct urb *urb; 554 int err = 0; 555 556 if (test_bit(DISCONNECTED, &ua->states)) 557 return -ENODEV; 558 559 if (test_bit(USB_PLAYBACK_RUNNING, &ua->states)) 560 return 0; 561 562 kill_stream_urbs(&ua->playback); 563 tasklet_kill(&ua->playback_tasklet); 564 565 err = enable_iso_interface(ua, INTF_PLAYBACK); 566 if (err < 0) 567 return err; 568 569 clear_bit(PLAYBACK_URB_COMPLETED, &ua->states); 570 ua->playback.urbs[0]->urb.complete = 571 first_playback_urb_complete; 572 spin_lock_irq(&ua->lock); 573 INIT_LIST_HEAD(&ua->ready_playback_urbs); 574 spin_unlock_irq(&ua->lock); 575 576 /* 577 * We submit the initial URBs all at once, so we have to wait for the 578 * packet size FIFO to be full. 579 */ 580 wait_event(ua->rate_feedback_wait, 581 ua->rate_feedback_count >= ua->playback.queue_length || 582 !test_bit(USB_CAPTURE_RUNNING, &ua->states) || 583 test_bit(DISCONNECTED, &ua->states)); 584 if (test_bit(DISCONNECTED, &ua->states)) { 585 stop_usb_playback(ua); 586 return -ENODEV; 587 } 588 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) { 589 stop_usb_playback(ua); 590 return -EIO; 591 } 592 593 for (i = 0; i < ua->playback.queue_length; ++i) { 594 /* all initial URBs contain silence */ 595 spin_lock_irq(&ua->lock); 596 frames = ua->rate_feedback[ua->rate_feedback_start]; 597 add_with_wraparound(ua, &ua->rate_feedback_start, 1); 598 ua->rate_feedback_count--; 599 spin_unlock_irq(&ua->lock); 600 urb = &ua->playback.urbs[i]->urb; 601 urb->iso_frame_desc[0].length = 602 frames * ua->playback.frame_bytes; 603 memset(urb->transfer_buffer, 0, 604 urb->iso_frame_desc[0].length); 605 } 606 607 set_bit(USB_PLAYBACK_RUNNING, &ua->states); 608 err = submit_stream_urbs(ua, &ua->playback); 609 if (err < 0) 610 stop_usb_playback(ua); 611 return err; 612 } 613 614 static void abort_alsa_capture(struct ua101 *ua) 615 { 616 if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states)) 617 snd_pcm_stop_xrun(ua->capture.substream); 618 } 619 620 static void abort_alsa_playback(struct ua101 *ua) 621 { 622 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states)) 623 snd_pcm_stop_xrun(ua->playback.substream); 624 } 625 626 static int set_stream_hw(struct ua101 *ua, struct snd_pcm_substream *substream, 627 unsigned int channels) 628 { 629 int err; 630 631 substream->runtime->hw.info = 632 SNDRV_PCM_INFO_MMAP | 633 SNDRV_PCM_INFO_MMAP_VALID | 634 SNDRV_PCM_INFO_BATCH | 635 SNDRV_PCM_INFO_INTERLEAVED | 636 SNDRV_PCM_INFO_BLOCK_TRANSFER | 637 SNDRV_PCM_INFO_FIFO_IN_FRAMES; 638 substream->runtime->hw.formats = ua->format_bit; 639 substream->runtime->hw.rates = snd_pcm_rate_to_rate_bit(ua->rate); 640 substream->runtime->hw.rate_min = ua->rate; 641 substream->runtime->hw.rate_max = ua->rate; 642 substream->runtime->hw.channels_min = channels; 643 substream->runtime->hw.channels_max = channels; 644 substream->runtime->hw.buffer_bytes_max = 45000 * 1024; 645 substream->runtime->hw.period_bytes_min = 1; 646 substream->runtime->hw.period_bytes_max = UINT_MAX; 647 substream->runtime->hw.periods_min = 2; 648 substream->runtime->hw.periods_max = UINT_MAX; 649 err = snd_pcm_hw_constraint_minmax(substream->runtime, 650 SNDRV_PCM_HW_PARAM_PERIOD_TIME, 651 1500000 / ua->packets_per_second, 652 UINT_MAX); 653 if (err < 0) 654 return err; 655 err = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24); 656 return err; 657 } 658 659 static int capture_pcm_open(struct snd_pcm_substream *substream) 660 { 661 struct ua101 *ua = substream->private_data; 662 int err; 663 664 ua->capture.substream = substream; 665 err = set_stream_hw(ua, substream, ua->capture.channels); 666 if (err < 0) 667 return err; 668 substream->runtime->hw.fifo_size = 669 DIV_ROUND_CLOSEST(ua->rate, ua->packets_per_second); 670 substream->runtime->delay = substream->runtime->hw.fifo_size; 671 672 mutex_lock(&ua->mutex); 673 err = start_usb_capture(ua); 674 if (err >= 0) 675 set_bit(ALSA_CAPTURE_OPEN, &ua->states); 676 mutex_unlock(&ua->mutex); 677 return err; 678 } 679 680 static int playback_pcm_open(struct snd_pcm_substream *substream) 681 { 682 struct ua101 *ua = substream->private_data; 683 int err; 684 685 ua->playback.substream = substream; 686 err = set_stream_hw(ua, substream, ua->playback.channels); 687 if (err < 0) 688 return err; 689 substream->runtime->hw.fifo_size = 690 DIV_ROUND_CLOSEST(ua->rate * ua->playback.queue_length, 691 ua->packets_per_second); 692 693 mutex_lock(&ua->mutex); 694 err = start_usb_capture(ua); 695 if (err < 0) 696 goto error; 697 err = start_usb_playback(ua); 698 if (err < 0) { 699 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states)) 700 stop_usb_capture(ua); 701 goto error; 702 } 703 set_bit(ALSA_PLAYBACK_OPEN, &ua->states); 704 error: 705 mutex_unlock(&ua->mutex); 706 return err; 707 } 708 709 static int capture_pcm_close(struct snd_pcm_substream *substream) 710 { 711 struct ua101 *ua = substream->private_data; 712 713 mutex_lock(&ua->mutex); 714 clear_bit(ALSA_CAPTURE_OPEN, &ua->states); 715 if (!test_bit(ALSA_PLAYBACK_OPEN, &ua->states)) 716 stop_usb_capture(ua); 717 mutex_unlock(&ua->mutex); 718 return 0; 719 } 720 721 static int playback_pcm_close(struct snd_pcm_substream *substream) 722 { 723 struct ua101 *ua = substream->private_data; 724 725 mutex_lock(&ua->mutex); 726 stop_usb_playback(ua); 727 clear_bit(ALSA_PLAYBACK_OPEN, &ua->states); 728 if (!test_bit(ALSA_CAPTURE_OPEN, &ua->states)) 729 stop_usb_capture(ua); 730 mutex_unlock(&ua->mutex); 731 return 0; 732 } 733 734 static int capture_pcm_hw_params(struct snd_pcm_substream *substream, 735 struct snd_pcm_hw_params *hw_params) 736 { 737 struct ua101 *ua = substream->private_data; 738 int err; 739 740 mutex_lock(&ua->mutex); 741 err = start_usb_capture(ua); 742 mutex_unlock(&ua->mutex); 743 if (err < 0) 744 return err; 745 746 return snd_pcm_lib_alloc_vmalloc_buffer(substream, 747 params_buffer_bytes(hw_params)); 748 } 749 750 static int playback_pcm_hw_params(struct snd_pcm_substream *substream, 751 struct snd_pcm_hw_params *hw_params) 752 { 753 struct ua101 *ua = substream->private_data; 754 int err; 755 756 mutex_lock(&ua->mutex); 757 err = start_usb_capture(ua); 758 if (err >= 0) 759 err = start_usb_playback(ua); 760 mutex_unlock(&ua->mutex); 761 if (err < 0) 762 return err; 763 764 return snd_pcm_lib_alloc_vmalloc_buffer(substream, 765 params_buffer_bytes(hw_params)); 766 } 767 768 static int ua101_pcm_hw_free(struct snd_pcm_substream *substream) 769 { 770 return snd_pcm_lib_free_vmalloc_buffer(substream); 771 } 772 773 static int capture_pcm_prepare(struct snd_pcm_substream *substream) 774 { 775 struct ua101 *ua = substream->private_data; 776 int err; 777 778 mutex_lock(&ua->mutex); 779 err = start_usb_capture(ua); 780 mutex_unlock(&ua->mutex); 781 if (err < 0) 782 return err; 783 784 /* 785 * The EHCI driver schedules the first packet of an iso stream at 10 ms 786 * in the future, i.e., no data is actually captured for that long. 787 * Take the wait here so that the stream is known to be actually 788 * running when the start trigger has been called. 789 */ 790 wait_event(ua->alsa_capture_wait, 791 test_bit(CAPTURE_URB_COMPLETED, &ua->states) || 792 !test_bit(USB_CAPTURE_RUNNING, &ua->states)); 793 if (test_bit(DISCONNECTED, &ua->states)) 794 return -ENODEV; 795 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) 796 return -EIO; 797 798 ua->capture.period_pos = 0; 799 ua->capture.buffer_pos = 0; 800 return 0; 801 } 802 803 static int playback_pcm_prepare(struct snd_pcm_substream *substream) 804 { 805 struct ua101 *ua = substream->private_data; 806 int err; 807 808 mutex_lock(&ua->mutex); 809 err = start_usb_capture(ua); 810 if (err >= 0) 811 err = start_usb_playback(ua); 812 mutex_unlock(&ua->mutex); 813 if (err < 0) 814 return err; 815 816 /* see the comment in capture_pcm_prepare() */ 817 wait_event(ua->alsa_playback_wait, 818 test_bit(PLAYBACK_URB_COMPLETED, &ua->states) || 819 !test_bit(USB_PLAYBACK_RUNNING, &ua->states)); 820 if (test_bit(DISCONNECTED, &ua->states)) 821 return -ENODEV; 822 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states)) 823 return -EIO; 824 825 substream->runtime->delay = 0; 826 ua->playback.period_pos = 0; 827 ua->playback.buffer_pos = 0; 828 return 0; 829 } 830 831 static int capture_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 832 { 833 struct ua101 *ua = substream->private_data; 834 835 switch (cmd) { 836 case SNDRV_PCM_TRIGGER_START: 837 if (!test_bit(USB_CAPTURE_RUNNING, &ua->states)) 838 return -EIO; 839 set_bit(ALSA_CAPTURE_RUNNING, &ua->states); 840 return 0; 841 case SNDRV_PCM_TRIGGER_STOP: 842 clear_bit(ALSA_CAPTURE_RUNNING, &ua->states); 843 return 0; 844 default: 845 return -EINVAL; 846 } 847 } 848 849 static int playback_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 850 { 851 struct ua101 *ua = substream->private_data; 852 853 switch (cmd) { 854 case SNDRV_PCM_TRIGGER_START: 855 if (!test_bit(USB_PLAYBACK_RUNNING, &ua->states)) 856 return -EIO; 857 set_bit(ALSA_PLAYBACK_RUNNING, &ua->states); 858 return 0; 859 case SNDRV_PCM_TRIGGER_STOP: 860 clear_bit(ALSA_PLAYBACK_RUNNING, &ua->states); 861 return 0; 862 default: 863 return -EINVAL; 864 } 865 } 866 867 static inline snd_pcm_uframes_t ua101_pcm_pointer(struct ua101 *ua, 868 struct ua101_stream *stream) 869 { 870 unsigned long flags; 871 unsigned int pos; 872 873 spin_lock_irqsave(&ua->lock, flags); 874 pos = stream->buffer_pos; 875 spin_unlock_irqrestore(&ua->lock, flags); 876 return pos; 877 } 878 879 static snd_pcm_uframes_t capture_pcm_pointer(struct snd_pcm_substream *subs) 880 { 881 struct ua101 *ua = subs->private_data; 882 883 return ua101_pcm_pointer(ua, &ua->capture); 884 } 885 886 static snd_pcm_uframes_t playback_pcm_pointer(struct snd_pcm_substream *subs) 887 { 888 struct ua101 *ua = subs->private_data; 889 890 return ua101_pcm_pointer(ua, &ua->playback); 891 } 892 893 static const struct snd_pcm_ops capture_pcm_ops = { 894 .open = capture_pcm_open, 895 .close = capture_pcm_close, 896 .ioctl = snd_pcm_lib_ioctl, 897 .hw_params = capture_pcm_hw_params, 898 .hw_free = ua101_pcm_hw_free, 899 .prepare = capture_pcm_prepare, 900 .trigger = capture_pcm_trigger, 901 .pointer = capture_pcm_pointer, 902 .page = snd_pcm_lib_get_vmalloc_page, 903 }; 904 905 static const struct snd_pcm_ops playback_pcm_ops = { 906 .open = playback_pcm_open, 907 .close = playback_pcm_close, 908 .ioctl = snd_pcm_lib_ioctl, 909 .hw_params = playback_pcm_hw_params, 910 .hw_free = ua101_pcm_hw_free, 911 .prepare = playback_pcm_prepare, 912 .trigger = playback_pcm_trigger, 913 .pointer = playback_pcm_pointer, 914 .page = snd_pcm_lib_get_vmalloc_page, 915 }; 916 917 static const struct uac_format_type_i_discrete_descriptor * 918 find_format_descriptor(struct usb_interface *interface) 919 { 920 struct usb_host_interface *alt; 921 u8 *extra; 922 int extralen; 923 924 if (interface->num_altsetting != 2) { 925 dev_err(&interface->dev, "invalid num_altsetting\n"); 926 return NULL; 927 } 928 929 alt = &interface->altsetting[0]; 930 if (alt->desc.bNumEndpoints != 0) { 931 dev_err(&interface->dev, "invalid bNumEndpoints\n"); 932 return NULL; 933 } 934 935 alt = &interface->altsetting[1]; 936 if (alt->desc.bNumEndpoints != 1) { 937 dev_err(&interface->dev, "invalid bNumEndpoints\n"); 938 return NULL; 939 } 940 941 extra = alt->extra; 942 extralen = alt->extralen; 943 while (extralen >= sizeof(struct usb_descriptor_header)) { 944 struct uac_format_type_i_discrete_descriptor *desc; 945 946 desc = (struct uac_format_type_i_discrete_descriptor *)extra; 947 if (desc->bLength > extralen) { 948 dev_err(&interface->dev, "descriptor overflow\n"); 949 return NULL; 950 } 951 if (desc->bLength == UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1) && 952 desc->bDescriptorType == USB_DT_CS_INTERFACE && 953 desc->bDescriptorSubtype == UAC_FORMAT_TYPE) { 954 if (desc->bFormatType != UAC_FORMAT_TYPE_I_PCM || 955 desc->bSamFreqType != 1) { 956 dev_err(&interface->dev, 957 "invalid format type\n"); 958 return NULL; 959 } 960 return desc; 961 } 962 extralen -= desc->bLength; 963 extra += desc->bLength; 964 } 965 dev_err(&interface->dev, "sample format descriptor not found\n"); 966 return NULL; 967 } 968 969 static int detect_usb_format(struct ua101 *ua) 970 { 971 const struct uac_format_type_i_discrete_descriptor *fmt_capture; 972 const struct uac_format_type_i_discrete_descriptor *fmt_playback; 973 const struct usb_endpoint_descriptor *epd; 974 unsigned int rate2; 975 976 fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]); 977 fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]); 978 if (!fmt_capture || !fmt_playback) 979 return -ENXIO; 980 981 switch (fmt_capture->bSubframeSize) { 982 case 3: 983 ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE; 984 break; 985 case 4: 986 ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE; 987 break; 988 default: 989 dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n"); 990 return -ENXIO; 991 } 992 if (fmt_capture->bSubframeSize != fmt_playback->bSubframeSize) { 993 dev_err(&ua->dev->dev, 994 "playback/capture sample widths do not match\n"); 995 return -ENXIO; 996 } 997 998 if (fmt_capture->bBitResolution != 24 || 999 fmt_playback->bBitResolution != 24) { 1000 dev_err(&ua->dev->dev, "sample width is not 24 bits\n"); 1001 return -ENXIO; 1002 } 1003 1004 ua->rate = combine_triple(fmt_capture->tSamFreq[0]); 1005 rate2 = combine_triple(fmt_playback->tSamFreq[0]); 1006 if (ua->rate != rate2) { 1007 dev_err(&ua->dev->dev, 1008 "playback/capture rates do not match: %u/%u\n", 1009 rate2, ua->rate); 1010 return -ENXIO; 1011 } 1012 1013 switch (ua->dev->speed) { 1014 case USB_SPEED_FULL: 1015 ua->packets_per_second = 1000; 1016 break; 1017 case USB_SPEED_HIGH: 1018 ua->packets_per_second = 8000; 1019 break; 1020 default: 1021 dev_err(&ua->dev->dev, "unknown device speed\n"); 1022 return -ENXIO; 1023 } 1024 1025 ua->capture.channels = fmt_capture->bNrChannels; 1026 ua->playback.channels = fmt_playback->bNrChannels; 1027 ua->capture.frame_bytes = 1028 fmt_capture->bSubframeSize * ua->capture.channels; 1029 ua->playback.frame_bytes = 1030 fmt_playback->bSubframeSize * ua->playback.channels; 1031 1032 epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc; 1033 if (!usb_endpoint_is_isoc_in(epd)) { 1034 dev_err(&ua->dev->dev, "invalid capture endpoint\n"); 1035 return -ENXIO; 1036 } 1037 ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd)); 1038 ua->capture.max_packet_bytes = usb_endpoint_maxp(epd); 1039 1040 epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc; 1041 if (!usb_endpoint_is_isoc_out(epd)) { 1042 dev_err(&ua->dev->dev, "invalid playback endpoint\n"); 1043 return -ENXIO; 1044 } 1045 ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd)); 1046 ua->playback.max_packet_bytes = usb_endpoint_maxp(epd); 1047 return 0; 1048 } 1049 1050 static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream) 1051 { 1052 unsigned int remaining_packets, packets, packets_per_page, i; 1053 size_t size; 1054 1055 stream->queue_length = queue_length; 1056 stream->queue_length = max(stream->queue_length, 1057 (unsigned int)MIN_QUEUE_LENGTH); 1058 stream->queue_length = min(stream->queue_length, 1059 (unsigned int)MAX_QUEUE_LENGTH); 1060 1061 /* 1062 * The cache pool sizes used by usb_alloc_coherent() (128, 512, 2048) are 1063 * quite bad when used with the packet sizes of this device (e.g. 280, 1064 * 520, 624). Therefore, we allocate and subdivide entire pages, using 1065 * a smaller buffer only for the last chunk. 1066 */ 1067 remaining_packets = stream->queue_length; 1068 packets_per_page = PAGE_SIZE / stream->max_packet_bytes; 1069 for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) { 1070 packets = min(remaining_packets, packets_per_page); 1071 size = packets * stream->max_packet_bytes; 1072 stream->buffers[i].addr = 1073 usb_alloc_coherent(ua->dev, size, GFP_KERNEL, 1074 &stream->buffers[i].dma); 1075 if (!stream->buffers[i].addr) 1076 return -ENOMEM; 1077 stream->buffers[i].size = size; 1078 remaining_packets -= packets; 1079 if (!remaining_packets) 1080 break; 1081 } 1082 if (remaining_packets) { 1083 dev_err(&ua->dev->dev, "too many packets\n"); 1084 return -ENXIO; 1085 } 1086 return 0; 1087 } 1088 1089 static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream) 1090 { 1091 unsigned int i; 1092 1093 for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) 1094 usb_free_coherent(ua->dev, 1095 stream->buffers[i].size, 1096 stream->buffers[i].addr, 1097 stream->buffers[i].dma); 1098 } 1099 1100 static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream, 1101 void (*urb_complete)(struct urb *)) 1102 { 1103 unsigned max_packet_size = stream->max_packet_bytes; 1104 struct ua101_urb *urb; 1105 unsigned int b, u = 0; 1106 1107 for (b = 0; b < ARRAY_SIZE(stream->buffers); ++b) { 1108 unsigned int size = stream->buffers[b].size; 1109 u8 *addr = stream->buffers[b].addr; 1110 dma_addr_t dma = stream->buffers[b].dma; 1111 1112 while (size >= max_packet_size) { 1113 if (u >= stream->queue_length) 1114 goto bufsize_error; 1115 urb = kmalloc(sizeof(*urb), GFP_KERNEL); 1116 if (!urb) 1117 return -ENOMEM; 1118 usb_init_urb(&urb->urb); 1119 urb->urb.dev = ua->dev; 1120 urb->urb.pipe = stream->usb_pipe; 1121 urb->urb.transfer_flags = URB_NO_TRANSFER_DMA_MAP; 1122 urb->urb.transfer_buffer = addr; 1123 urb->urb.transfer_dma = dma; 1124 urb->urb.transfer_buffer_length = max_packet_size; 1125 urb->urb.number_of_packets = 1; 1126 urb->urb.interval = 1; 1127 urb->urb.context = ua; 1128 urb->urb.complete = urb_complete; 1129 urb->urb.iso_frame_desc[0].offset = 0; 1130 urb->urb.iso_frame_desc[0].length = max_packet_size; 1131 stream->urbs[u++] = urb; 1132 size -= max_packet_size; 1133 addr += max_packet_size; 1134 dma += max_packet_size; 1135 } 1136 } 1137 if (u == stream->queue_length) 1138 return 0; 1139 bufsize_error: 1140 dev_err(&ua->dev->dev, "internal buffer size error\n"); 1141 return -ENXIO; 1142 } 1143 1144 static void free_stream_urbs(struct ua101_stream *stream) 1145 { 1146 unsigned int i; 1147 1148 for (i = 0; i < stream->queue_length; ++i) { 1149 kfree(stream->urbs[i]); 1150 stream->urbs[i] = NULL; 1151 } 1152 } 1153 1154 static void free_usb_related_resources(struct ua101 *ua, 1155 struct usb_interface *interface) 1156 { 1157 unsigned int i; 1158 struct usb_interface *intf; 1159 1160 mutex_lock(&ua->mutex); 1161 free_stream_urbs(&ua->capture); 1162 free_stream_urbs(&ua->playback); 1163 mutex_unlock(&ua->mutex); 1164 free_stream_buffers(ua, &ua->capture); 1165 free_stream_buffers(ua, &ua->playback); 1166 1167 for (i = 0; i < ARRAY_SIZE(ua->intf); ++i) { 1168 mutex_lock(&ua->mutex); 1169 intf = ua->intf[i]; 1170 ua->intf[i] = NULL; 1171 mutex_unlock(&ua->mutex); 1172 if (intf) { 1173 usb_set_intfdata(intf, NULL); 1174 if (intf != interface) 1175 usb_driver_release_interface(&ua101_driver, 1176 intf); 1177 } 1178 } 1179 } 1180 1181 static void ua101_card_free(struct snd_card *card) 1182 { 1183 struct ua101 *ua = card->private_data; 1184 1185 mutex_destroy(&ua->mutex); 1186 } 1187 1188 static int ua101_probe(struct usb_interface *interface, 1189 const struct usb_device_id *usb_id) 1190 { 1191 static const struct snd_usb_midi_endpoint_info midi_ep = { 1192 .out_cables = 0x0001, 1193 .in_cables = 0x0001 1194 }; 1195 static const struct snd_usb_audio_quirk midi_quirk = { 1196 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1197 .data = &midi_ep 1198 }; 1199 static const int intf_numbers[2][3] = { 1200 { /* UA-101 */ 1201 [INTF_PLAYBACK] = 0, 1202 [INTF_CAPTURE] = 1, 1203 [INTF_MIDI] = 2, 1204 }, 1205 { /* UA-1000 */ 1206 [INTF_CAPTURE] = 1, 1207 [INTF_PLAYBACK] = 2, 1208 [INTF_MIDI] = 3, 1209 }, 1210 }; 1211 struct snd_card *card; 1212 struct ua101 *ua; 1213 unsigned int card_index, i; 1214 int is_ua1000; 1215 const char *name; 1216 char usb_path[32]; 1217 int err; 1218 1219 is_ua1000 = usb_id->idProduct == 0x0044; 1220 1221 if (interface->altsetting->desc.bInterfaceNumber != 1222 intf_numbers[is_ua1000][0]) 1223 return -ENODEV; 1224 1225 mutex_lock(&devices_mutex); 1226 1227 for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) 1228 if (enable[card_index] && !(devices_used & (1 << card_index))) 1229 break; 1230 if (card_index >= SNDRV_CARDS) { 1231 mutex_unlock(&devices_mutex); 1232 return -ENOENT; 1233 } 1234 err = snd_card_new(&interface->dev, 1235 index[card_index], id[card_index], THIS_MODULE, 1236 sizeof(*ua), &card); 1237 if (err < 0) { 1238 mutex_unlock(&devices_mutex); 1239 return err; 1240 } 1241 card->private_free = ua101_card_free; 1242 ua = card->private_data; 1243 ua->dev = interface_to_usbdev(interface); 1244 ua->card = card; 1245 ua->card_index = card_index; 1246 INIT_LIST_HEAD(&ua->midi_list); 1247 spin_lock_init(&ua->lock); 1248 mutex_init(&ua->mutex); 1249 INIT_LIST_HEAD(&ua->ready_playback_urbs); 1250 tasklet_init(&ua->playback_tasklet, 1251 playback_tasklet, (unsigned long)ua); 1252 init_waitqueue_head(&ua->alsa_capture_wait); 1253 init_waitqueue_head(&ua->rate_feedback_wait); 1254 init_waitqueue_head(&ua->alsa_playback_wait); 1255 1256 ua->intf[0] = interface; 1257 for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) { 1258 ua->intf[i] = usb_ifnum_to_if(ua->dev, 1259 intf_numbers[is_ua1000][i]); 1260 if (!ua->intf[i]) { 1261 dev_err(&ua->dev->dev, "interface %u not found\n", 1262 intf_numbers[is_ua1000][i]); 1263 err = -ENXIO; 1264 goto probe_error; 1265 } 1266 err = usb_driver_claim_interface(&ua101_driver, 1267 ua->intf[i], ua); 1268 if (err < 0) { 1269 ua->intf[i] = NULL; 1270 err = -EBUSY; 1271 goto probe_error; 1272 } 1273 } 1274 1275 err = detect_usb_format(ua); 1276 if (err < 0) 1277 goto probe_error; 1278 1279 name = usb_id->idProduct == 0x0044 ? "UA-1000" : "UA-101"; 1280 strcpy(card->driver, "UA-101"); 1281 strcpy(card->shortname, name); 1282 usb_make_path(ua->dev, usb_path, sizeof(usb_path)); 1283 snprintf(ua->card->longname, sizeof(ua->card->longname), 1284 "EDIROL %s (serial %s), %u Hz at %s, %s speed", name, 1285 ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path, 1286 ua->dev->speed == USB_SPEED_HIGH ? "high" : "full"); 1287 1288 err = alloc_stream_buffers(ua, &ua->capture); 1289 if (err < 0) 1290 goto probe_error; 1291 err = alloc_stream_buffers(ua, &ua->playback); 1292 if (err < 0) 1293 goto probe_error; 1294 1295 err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete); 1296 if (err < 0) 1297 goto probe_error; 1298 err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete); 1299 if (err < 0) 1300 goto probe_error; 1301 1302 err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm); 1303 if (err < 0) 1304 goto probe_error; 1305 ua->pcm->private_data = ua; 1306 strcpy(ua->pcm->name, name); 1307 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops); 1308 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops); 1309 1310 err = snd_usbmidi_create(card, ua->intf[INTF_MIDI], 1311 &ua->midi_list, &midi_quirk); 1312 if (err < 0) 1313 goto probe_error; 1314 1315 err = snd_card_register(card); 1316 if (err < 0) 1317 goto probe_error; 1318 1319 usb_set_intfdata(interface, ua); 1320 devices_used |= 1 << card_index; 1321 1322 mutex_unlock(&devices_mutex); 1323 return 0; 1324 1325 probe_error: 1326 free_usb_related_resources(ua, interface); 1327 snd_card_free(card); 1328 mutex_unlock(&devices_mutex); 1329 return err; 1330 } 1331 1332 static void ua101_disconnect(struct usb_interface *interface) 1333 { 1334 struct ua101 *ua = usb_get_intfdata(interface); 1335 struct list_head *midi; 1336 1337 if (!ua) 1338 return; 1339 1340 mutex_lock(&devices_mutex); 1341 1342 set_bit(DISCONNECTED, &ua->states); 1343 wake_up(&ua->rate_feedback_wait); 1344 1345 /* make sure that userspace cannot create new requests */ 1346 snd_card_disconnect(ua->card); 1347 1348 /* make sure that there are no pending USB requests */ 1349 list_for_each(midi, &ua->midi_list) 1350 snd_usbmidi_disconnect(midi); 1351 abort_alsa_playback(ua); 1352 abort_alsa_capture(ua); 1353 mutex_lock(&ua->mutex); 1354 stop_usb_playback(ua); 1355 stop_usb_capture(ua); 1356 mutex_unlock(&ua->mutex); 1357 1358 free_usb_related_resources(ua, interface); 1359 1360 devices_used &= ~(1 << ua->card_index); 1361 1362 snd_card_free_when_closed(ua->card); 1363 1364 mutex_unlock(&devices_mutex); 1365 } 1366 1367 static const struct usb_device_id ua101_ids[] = { 1368 { USB_DEVICE(0x0582, 0x0044) }, /* UA-1000 high speed */ 1369 { USB_DEVICE(0x0582, 0x007d) }, /* UA-101 high speed */ 1370 { USB_DEVICE(0x0582, 0x008d) }, /* UA-101 full speed */ 1371 { } 1372 }; 1373 MODULE_DEVICE_TABLE(usb, ua101_ids); 1374 1375 static struct usb_driver ua101_driver = { 1376 .name = "snd-ua101", 1377 .id_table = ua101_ids, 1378 .probe = ua101_probe, 1379 .disconnect = ua101_disconnect, 1380 #if 0 1381 .suspend = ua101_suspend, 1382 .resume = ua101_resume, 1383 #endif 1384 }; 1385 1386 module_usb_driver(ua101_driver); 1387