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 29MODULE_DESCRIPTION("Edirol UA-101/1000 driver"); 30MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>"); 31MODULE_LICENSE("GPL v2"); 32MODULE_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 53static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; 54static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; 55static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP; 56static unsigned int queue_length = 21; 57 58module_param_array(index, int, NULL, 0444); 59MODULE_PARM_DESC(index, "card index"); 60module_param_array(id, charp, NULL, 0444); 61MODULE_PARM_DESC(id, "ID string"); 62module_param_array(enable, bool, NULL, 0444); 63MODULE_PARM_DESC(enable, "enable card"); 64module_param(queue_length, uint, 0644); 65MODULE_PARM_DESC(queue_length, "USB queue length in microframes, " 66 __stringify(MIN_QUEUE_LENGTH)"-"__stringify(MAX_QUEUE_LENGTH)); 67 68enum { 69 INTF_PLAYBACK, 70 INTF_CAPTURE, 71 INTF_MIDI, 72 73 INTF_COUNT 74}; 75 76/* bits in struct ua101::states */ 77enum { 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 89struct 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 135static DEFINE_MUTEX(devices_mutex); 136static unsigned int devices_used; 137static struct usb_driver ua101_driver; 138 139static void abort_alsa_playback(struct ua101 *ua); 140static void abort_alsa_capture(struct ua101 *ua); 141 142static 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 167static 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 175static 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 181static 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 209static 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 */ 221static 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 252static 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 260static 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 */ 325static 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 357static 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 424stream_stopped: 425 abort_usb_playback(ua); 426 abort_usb_capture(ua); 427 abort_alsa_playback(ua); 428 abort_alsa_capture(ua); 429} 430 431static 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 442static 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 457static 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 466static 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 484static 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 502static 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 511static 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 539static 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 550static 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 614static void abort_alsa_capture(struct ua101 *ua) 615{ 616 if (test_bit(ALSA_CAPTURE_RUNNING, &ua->states)) 617 snd_pcm_stop(ua->capture.substream, SNDRV_PCM_STATE_XRUN); 618} 619 620static void abort_alsa_playback(struct ua101 *ua) 621{ 622 if (test_bit(ALSA_PLAYBACK_RUNNING, &ua->states)) 623 snd_pcm_stop(ua->playback.substream, SNDRV_PCM_STATE_XRUN); 624} 625 626static 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 8192000); 653 if (err < 0) 654 return err; 655 err = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 32, 24); 656 return err; 657} 658 659static 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 680static 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); 704error: 705 mutex_unlock(&ua->mutex); 706 return err; 707} 708 709static 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 721static 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 734static 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 750static 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 768static int ua101_pcm_hw_free(struct snd_pcm_substream *substream) 769{ 770 return snd_pcm_lib_free_vmalloc_buffer(substream); 771} 772 773static 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 803static 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 831static 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 849static 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 867static 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 879static 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 886static 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 893static 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 .mmap = snd_pcm_lib_mmap_vmalloc, 904}; 905 906static struct snd_pcm_ops playback_pcm_ops = { 907 .open = playback_pcm_open, 908 .close = playback_pcm_close, 909 .ioctl = snd_pcm_lib_ioctl, 910 .hw_params = playback_pcm_hw_params, 911 .hw_free = ua101_pcm_hw_free, 912 .prepare = playback_pcm_prepare, 913 .trigger = playback_pcm_trigger, 914 .pointer = playback_pcm_pointer, 915 .page = snd_pcm_lib_get_vmalloc_page, 916 .mmap = snd_pcm_lib_mmap_vmalloc, 917}; 918 919static const struct uac_format_type_i_discrete_descriptor * 920find_format_descriptor(struct usb_interface *interface) 921{ 922 struct usb_host_interface *alt; 923 u8 *extra; 924 int extralen; 925 926 if (interface->num_altsetting != 2) { 927 dev_err(&interface->dev, "invalid num_altsetting\n"); 928 return NULL; 929 } 930 931 alt = &interface->altsetting[0]; 932 if (alt->desc.bNumEndpoints != 0) { 933 dev_err(&interface->dev, "invalid bNumEndpoints\n"); 934 return NULL; 935 } 936 937 alt = &interface->altsetting[1]; 938 if (alt->desc.bNumEndpoints != 1) { 939 dev_err(&interface->dev, "invalid bNumEndpoints\n"); 940 return NULL; 941 } 942 943 extra = alt->extra; 944 extralen = alt->extralen; 945 while (extralen >= sizeof(struct usb_descriptor_header)) { 946 struct uac_format_type_i_discrete_descriptor *desc; 947 948 desc = (struct uac_format_type_i_discrete_descriptor *)extra; 949 if (desc->bLength > extralen) { 950 dev_err(&interface->dev, "descriptor overflow\n"); 951 return NULL; 952 } 953 if (desc->bLength == UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1) && 954 desc->bDescriptorType == USB_DT_CS_INTERFACE && 955 desc->bDescriptorSubtype == UAC_FORMAT_TYPE) { 956 if (desc->bFormatType != UAC_FORMAT_TYPE_I_PCM || 957 desc->bSamFreqType != 1) { 958 dev_err(&interface->dev, 959 "invalid format type\n"); 960 return NULL; 961 } 962 return desc; 963 } 964 extralen -= desc->bLength; 965 extra += desc->bLength; 966 } 967 dev_err(&interface->dev, "sample format descriptor not found\n"); 968 return NULL; 969} 970 971static int detect_usb_format(struct ua101 *ua) 972{ 973 const struct uac_format_type_i_discrete_descriptor *fmt_capture; 974 const struct uac_format_type_i_discrete_descriptor *fmt_playback; 975 const struct usb_endpoint_descriptor *epd; 976 unsigned int rate2; 977 978 fmt_capture = find_format_descriptor(ua->intf[INTF_CAPTURE]); 979 fmt_playback = find_format_descriptor(ua->intf[INTF_PLAYBACK]); 980 if (!fmt_capture || !fmt_playback) 981 return -ENXIO; 982 983 switch (fmt_capture->bSubframeSize) { 984 case 3: 985 ua->format_bit = SNDRV_PCM_FMTBIT_S24_3LE; 986 break; 987 case 4: 988 ua->format_bit = SNDRV_PCM_FMTBIT_S32_LE; 989 break; 990 default: 991 dev_err(&ua->dev->dev, "sample width is not 24 or 32 bits\n"); 992 return -ENXIO; 993 } 994 if (fmt_capture->bSubframeSize != fmt_playback->bSubframeSize) { 995 dev_err(&ua->dev->dev, 996 "playback/capture sample widths do not match\n"); 997 return -ENXIO; 998 } 999 1000 if (fmt_capture->bBitResolution != 24 || 1001 fmt_playback->bBitResolution != 24) { 1002 dev_err(&ua->dev->dev, "sample width is not 24 bits\n"); 1003 return -ENXIO; 1004 } 1005 1006 ua->rate = combine_triple(fmt_capture->tSamFreq[0]); 1007 rate2 = combine_triple(fmt_playback->tSamFreq[0]); 1008 if (ua->rate != rate2) { 1009 dev_err(&ua->dev->dev, 1010 "playback/capture rates do not match: %u/%u\n", 1011 rate2, ua->rate); 1012 return -ENXIO; 1013 } 1014 1015 switch (ua->dev->speed) { 1016 case USB_SPEED_FULL: 1017 ua->packets_per_second = 1000; 1018 break; 1019 case USB_SPEED_HIGH: 1020 ua->packets_per_second = 8000; 1021 break; 1022 default: 1023 dev_err(&ua->dev->dev, "unknown device speed\n"); 1024 return -ENXIO; 1025 } 1026 1027 ua->capture.channels = fmt_capture->bNrChannels; 1028 ua->playback.channels = fmt_playback->bNrChannels; 1029 ua->capture.frame_bytes = 1030 fmt_capture->bSubframeSize * ua->capture.channels; 1031 ua->playback.frame_bytes = 1032 fmt_playback->bSubframeSize * ua->playback.channels; 1033 1034 epd = &ua->intf[INTF_CAPTURE]->altsetting[1].endpoint[0].desc; 1035 if (!usb_endpoint_is_isoc_in(epd)) { 1036 dev_err(&ua->dev->dev, "invalid capture endpoint\n"); 1037 return -ENXIO; 1038 } 1039 ua->capture.usb_pipe = usb_rcvisocpipe(ua->dev, usb_endpoint_num(epd)); 1040 ua->capture.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize); 1041 1042 epd = &ua->intf[INTF_PLAYBACK]->altsetting[1].endpoint[0].desc; 1043 if (!usb_endpoint_is_isoc_out(epd)) { 1044 dev_err(&ua->dev->dev, "invalid playback endpoint\n"); 1045 return -ENXIO; 1046 } 1047 ua->playback.usb_pipe = usb_sndisocpipe(ua->dev, usb_endpoint_num(epd)); 1048 ua->playback.max_packet_bytes = le16_to_cpu(epd->wMaxPacketSize); 1049 return 0; 1050} 1051 1052static int alloc_stream_buffers(struct ua101 *ua, struct ua101_stream *stream) 1053{ 1054 unsigned int remaining_packets, packets, packets_per_page, i; 1055 size_t size; 1056 1057 stream->queue_length = queue_length; 1058 stream->queue_length = max(stream->queue_length, 1059 (unsigned int)MIN_QUEUE_LENGTH); 1060 stream->queue_length = min(stream->queue_length, 1061 (unsigned int)MAX_QUEUE_LENGTH); 1062 1063 /* 1064 * The cache pool sizes used by usb_alloc_coherent() (128, 512, 2048) are 1065 * quite bad when used with the packet sizes of this device (e.g. 280, 1066 * 520, 624). Therefore, we allocate and subdivide entire pages, using 1067 * a smaller buffer only for the last chunk. 1068 */ 1069 remaining_packets = stream->queue_length; 1070 packets_per_page = PAGE_SIZE / stream->max_packet_bytes; 1071 for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) { 1072 packets = min(remaining_packets, packets_per_page); 1073 size = packets * stream->max_packet_bytes; 1074 stream->buffers[i].addr = 1075 usb_alloc_coherent(ua->dev, size, GFP_KERNEL, 1076 &stream->buffers[i].dma); 1077 if (!stream->buffers[i].addr) 1078 return -ENOMEM; 1079 stream->buffers[i].size = size; 1080 remaining_packets -= packets; 1081 if (!remaining_packets) 1082 break; 1083 } 1084 if (remaining_packets) { 1085 dev_err(&ua->dev->dev, "too many packets\n"); 1086 return -ENXIO; 1087 } 1088 return 0; 1089} 1090 1091static void free_stream_buffers(struct ua101 *ua, struct ua101_stream *stream) 1092{ 1093 unsigned int i; 1094 1095 for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) 1096 usb_free_coherent(ua->dev, 1097 stream->buffers[i].size, 1098 stream->buffers[i].addr, 1099 stream->buffers[i].dma); 1100} 1101 1102static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream, 1103 void (*urb_complete)(struct urb *)) 1104{ 1105 unsigned max_packet_size = stream->max_packet_bytes; 1106 struct ua101_urb *urb; 1107 unsigned int b, u = 0; 1108 1109 for (b = 0; b < ARRAY_SIZE(stream->buffers); ++b) { 1110 unsigned int size = stream->buffers[b].size; 1111 u8 *addr = stream->buffers[b].addr; 1112 dma_addr_t dma = stream->buffers[b].dma; 1113 1114 while (size >= max_packet_size) { 1115 if (u >= stream->queue_length) 1116 goto bufsize_error; 1117 urb = kmalloc(sizeof(*urb), GFP_KERNEL); 1118 if (!urb) 1119 return -ENOMEM; 1120 usb_init_urb(&urb->urb); 1121 urb->urb.dev = ua->dev; 1122 urb->urb.pipe = stream->usb_pipe; 1123 urb->urb.transfer_flags = URB_ISO_ASAP | 1124 URB_NO_TRANSFER_DMA_MAP; 1125 urb->urb.transfer_buffer = addr; 1126 urb->urb.transfer_dma = dma; 1127 urb->urb.transfer_buffer_length = max_packet_size; 1128 urb->urb.number_of_packets = 1; 1129 urb->urb.interval = 1; 1130 urb->urb.context = ua; 1131 urb->urb.complete = urb_complete; 1132 urb->urb.iso_frame_desc[0].offset = 0; 1133 urb->urb.iso_frame_desc[0].length = max_packet_size; 1134 stream->urbs[u++] = urb; 1135 size -= max_packet_size; 1136 addr += max_packet_size; 1137 dma += max_packet_size; 1138 } 1139 } 1140 if (u == stream->queue_length) 1141 return 0; 1142bufsize_error: 1143 dev_err(&ua->dev->dev, "internal buffer size error\n"); 1144 return -ENXIO; 1145} 1146 1147static void free_stream_urbs(struct ua101_stream *stream) 1148{ 1149 unsigned int i; 1150 1151 for (i = 0; i < stream->queue_length; ++i) { 1152 kfree(stream->urbs[i]); 1153 stream->urbs[i] = NULL; 1154 } 1155} 1156 1157static void free_usb_related_resources(struct ua101 *ua, 1158 struct usb_interface *interface) 1159{ 1160 unsigned int i; 1161 struct usb_interface *intf; 1162 1163 mutex_lock(&ua->mutex); 1164 free_stream_urbs(&ua->capture); 1165 free_stream_urbs(&ua->playback); 1166 mutex_unlock(&ua->mutex); 1167 free_stream_buffers(ua, &ua->capture); 1168 free_stream_buffers(ua, &ua->playback); 1169 1170 for (i = 0; i < ARRAY_SIZE(ua->intf); ++i) { 1171 mutex_lock(&ua->mutex); 1172 intf = ua->intf[i]; 1173 ua->intf[i] = NULL; 1174 mutex_unlock(&ua->mutex); 1175 if (intf) { 1176 usb_set_intfdata(intf, NULL); 1177 if (intf != interface) 1178 usb_driver_release_interface(&ua101_driver, 1179 intf); 1180 } 1181 } 1182} 1183 1184static void ua101_card_free(struct snd_card *card) 1185{ 1186 struct ua101 *ua = card->private_data; 1187 1188 mutex_destroy(&ua->mutex); 1189} 1190 1191static int ua101_probe(struct usb_interface *interface, 1192 const struct usb_device_id *usb_id) 1193{ 1194 static const struct snd_usb_midi_endpoint_info midi_ep = { 1195 .out_cables = 0x0001, 1196 .in_cables = 0x0001 1197 }; 1198 static const struct snd_usb_audio_quirk midi_quirk = { 1199 .type = QUIRK_MIDI_FIXED_ENDPOINT, 1200 .data = &midi_ep 1201 }; 1202 static const int intf_numbers[2][3] = { 1203 { /* UA-101 */ 1204 [INTF_PLAYBACK] = 0, 1205 [INTF_CAPTURE] = 1, 1206 [INTF_MIDI] = 2, 1207 }, 1208 { /* UA-1000 */ 1209 [INTF_CAPTURE] = 1, 1210 [INTF_PLAYBACK] = 2, 1211 [INTF_MIDI] = 3, 1212 }, 1213 }; 1214 struct snd_card *card; 1215 struct ua101 *ua; 1216 unsigned int card_index, i; 1217 int is_ua1000; 1218 const char *name; 1219 char usb_path[32]; 1220 int err; 1221 1222 is_ua1000 = usb_id->idProduct == 0x0044; 1223 1224 if (interface->altsetting->desc.bInterfaceNumber != 1225 intf_numbers[is_ua1000][0]) 1226 return -ENODEV; 1227 1228 mutex_lock(&devices_mutex); 1229 1230 for (card_index = 0; card_index < SNDRV_CARDS; ++card_index) 1231 if (enable[card_index] && !(devices_used & (1 << card_index))) 1232 break; 1233 if (card_index >= SNDRV_CARDS) { 1234 mutex_unlock(&devices_mutex); 1235 return -ENOENT; 1236 } 1237 err = snd_card_create(index[card_index], id[card_index], THIS_MODULE, 1238 sizeof(*ua), &card); 1239 if (err < 0) { 1240 mutex_unlock(&devices_mutex); 1241 return err; 1242 } 1243 card->private_free = ua101_card_free; 1244 ua = card->private_data; 1245 ua->dev = interface_to_usbdev(interface); 1246 ua->card = card; 1247 ua->card_index = card_index; 1248 INIT_LIST_HEAD(&ua->midi_list); 1249 spin_lock_init(&ua->lock); 1250 mutex_init(&ua->mutex); 1251 INIT_LIST_HEAD(&ua->ready_playback_urbs); 1252 tasklet_init(&ua->playback_tasklet, 1253 playback_tasklet, (unsigned long)ua); 1254 init_waitqueue_head(&ua->alsa_capture_wait); 1255 init_waitqueue_head(&ua->rate_feedback_wait); 1256 init_waitqueue_head(&ua->alsa_playback_wait); 1257 1258 ua->intf[0] = interface; 1259 for (i = 1; i < ARRAY_SIZE(ua->intf); ++i) { 1260 ua->intf[i] = usb_ifnum_to_if(ua->dev, 1261 intf_numbers[is_ua1000][i]); 1262 if (!ua->intf[i]) { 1263 dev_err(&ua->dev->dev, "interface %u not found\n", 1264 intf_numbers[is_ua1000][i]); 1265 err = -ENXIO; 1266 goto probe_error; 1267 } 1268 err = usb_driver_claim_interface(&ua101_driver, 1269 ua->intf[i], ua); 1270 if (err < 0) { 1271 ua->intf[i] = NULL; 1272 err = -EBUSY; 1273 goto probe_error; 1274 } 1275 } 1276 1277 snd_card_set_dev(card, &interface->dev); 1278 1279 err = detect_usb_format(ua); 1280 if (err < 0) 1281 goto probe_error; 1282 1283 name = usb_id->idProduct == 0x0044 ? "UA-1000" : "UA-101"; 1284 strcpy(card->driver, "UA-101"); 1285 strcpy(card->shortname, name); 1286 usb_make_path(ua->dev, usb_path, sizeof(usb_path)); 1287 snprintf(ua->card->longname, sizeof(ua->card->longname), 1288 "EDIROL %s (serial %s), %u Hz at %s, %s speed", name, 1289 ua->dev->serial ? ua->dev->serial : "?", ua->rate, usb_path, 1290 ua->dev->speed == USB_SPEED_HIGH ? "high" : "full"); 1291 1292 err = alloc_stream_buffers(ua, &ua->capture); 1293 if (err < 0) 1294 goto probe_error; 1295 err = alloc_stream_buffers(ua, &ua->playback); 1296 if (err < 0) 1297 goto probe_error; 1298 1299 err = alloc_stream_urbs(ua, &ua->capture, capture_urb_complete); 1300 if (err < 0) 1301 goto probe_error; 1302 err = alloc_stream_urbs(ua, &ua->playback, playback_urb_complete); 1303 if (err < 0) 1304 goto probe_error; 1305 1306 err = snd_pcm_new(card, name, 0, 1, 1, &ua->pcm); 1307 if (err < 0) 1308 goto probe_error; 1309 ua->pcm->private_data = ua; 1310 strcpy(ua->pcm->name, name); 1311 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_PLAYBACK, &playback_pcm_ops); 1312 snd_pcm_set_ops(ua->pcm, SNDRV_PCM_STREAM_CAPTURE, &capture_pcm_ops); 1313 1314 err = snd_usbmidi_create(card, ua->intf[INTF_MIDI], 1315 &ua->midi_list, &midi_quirk); 1316 if (err < 0) 1317 goto probe_error; 1318 1319 err = snd_card_register(card); 1320 if (err < 0) 1321 goto probe_error; 1322 1323 usb_set_intfdata(interface, ua); 1324 devices_used |= 1 << card_index; 1325 1326 mutex_unlock(&devices_mutex); 1327 return 0; 1328 1329probe_error: 1330 free_usb_related_resources(ua, interface); 1331 snd_card_free(card); 1332 mutex_unlock(&devices_mutex); 1333 return err; 1334} 1335 1336static void ua101_disconnect(struct usb_interface *interface) 1337{ 1338 struct ua101 *ua = usb_get_intfdata(interface); 1339 struct list_head *midi; 1340 1341 if (!ua) 1342 return; 1343 1344 mutex_lock(&devices_mutex); 1345 1346 set_bit(DISCONNECTED, &ua->states); 1347 wake_up(&ua->rate_feedback_wait); 1348 1349 /* make sure that userspace cannot create new requests */ 1350 snd_card_disconnect(ua->card); 1351 1352 /* make sure that there are no pending USB requests */ 1353 __list_for_each(midi, &ua->midi_list) 1354 snd_usbmidi_disconnect(midi); 1355 abort_alsa_playback(ua); 1356 abort_alsa_capture(ua); 1357 mutex_lock(&ua->mutex); 1358 stop_usb_playback(ua); 1359 stop_usb_capture(ua); 1360 mutex_unlock(&ua->mutex); 1361 1362 free_usb_related_resources(ua, interface); 1363 1364 devices_used &= ~(1 << ua->card_index); 1365 1366 snd_card_free_when_closed(ua->card); 1367 1368 mutex_unlock(&devices_mutex); 1369} 1370 1371static struct usb_device_id ua101_ids[] = { 1372 { USB_DEVICE(0x0582, 0x0044) }, /* UA-1000 high speed */ 1373 { USB_DEVICE(0x0582, 0x007d) }, /* UA-101 high speed */ 1374 { USB_DEVICE(0x0582, 0x008d) }, /* UA-101 full speed */ 1375 { } 1376}; 1377MODULE_DEVICE_TABLE(usb, ua101_ids); 1378 1379static struct usb_driver ua101_driver = { 1380 .name = "snd-ua101", 1381 .id_table = ua101_ids, 1382 .probe = ua101_probe, 1383 .disconnect = ua101_disconnect, 1384#if 0 1385 .suspend = ua101_suspend, 1386 .resume = ua101_resume, 1387#endif 1388}; 1389 1390static int __init alsa_card_ua101_init(void) 1391{ 1392 return usb_register(&ua101_driver); 1393} 1394 1395static void __exit alsa_card_ua101_exit(void) 1396{ 1397 usb_deregister(&ua101_driver); 1398 mutex_destroy(&devices_mutex); 1399} 1400 1401module_init(alsa_card_ua101_init); 1402module_exit(alsa_card_ua101_exit); 1403