1 // SPDX-License-Identifier: GPL-2.0-only 2 // Copyright (c) 2025 Šerif Rami <ramiserifpersia@gmail.com> 3 /* 4 * ALSA Driver for TASCAM US-144MKII Audio Interface 5 */ 6 7 #include "us144mkii.h" 8 9 MODULE_AUTHOR("Šerif Rami <ramiserifpersia@gmail.com>"); 10 MODULE_DESCRIPTION("ALSA Driver for TASCAM US-144MKII"); 11 MODULE_LICENSE("GPL"); 12 13 /** 14 * @brief Module parameters for ALSA card instantiation. 15 * 16 * These parameters allow users to configure how the ALSA sound card 17 * for the TASCAM US-144MKII is instantiated. 18 * 19 * @param index: Array of integers specifying the ALSA card index for each 20 * device. Defaults to -1 (automatic). 21 * @param id: Array of strings specifying the ALSA card ID for each device. 22 * Defaults to "US144MKII". 23 * @param enable: Array of booleans to enable or disable each device. 24 * Defaults to {1, 0, ..., 0} (first device enabled). 25 * @param dev_idx: Internal counter for the number of TASCAM devices probed. 26 */ 27 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; 28 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; 29 static bool enable[SNDRV_CARDS] = { 1, [1 ...(SNDRV_CARDS - 1)] = 0 }; 30 static int dev_idx; 31 32 static int tascam_probe(struct usb_interface *intf, 33 const struct usb_device_id *usb_id); 34 static void tascam_disconnect(struct usb_interface *intf); 35 static int tascam_suspend(struct usb_interface *intf, pm_message_t message); 36 static int tascam_resume(struct usb_interface *intf); 37 38 void tascam_free_urbs(struct tascam_card *tascam) 39 { 40 int i; 41 42 usb_kill_anchored_urbs(&tascam->playback_anchor); 43 for (i = 0; i < NUM_PLAYBACK_URBS; i++) { 44 if (tascam->playback_urbs[i]) { 45 usb_free_coherent( 46 tascam->dev, tascam->playback_urb_alloc_size, 47 tascam->playback_urbs[i]->transfer_buffer, 48 tascam->playback_urbs[i]->transfer_dma); 49 usb_free_urb(tascam->playback_urbs[i]); 50 tascam->playback_urbs[i] = NULL; 51 } 52 } 53 54 usb_kill_anchored_urbs(&tascam->feedback_anchor); 55 for (i = 0; i < NUM_FEEDBACK_URBS; i++) { 56 if (tascam->feedback_urbs[i]) { 57 usb_free_coherent( 58 tascam->dev, tascam->feedback_urb_alloc_size, 59 tascam->feedback_urbs[i]->transfer_buffer, 60 tascam->feedback_urbs[i]->transfer_dma); 61 usb_free_urb(tascam->feedback_urbs[i]); 62 tascam->feedback_urbs[i] = NULL; 63 } 64 } 65 66 usb_kill_anchored_urbs(&tascam->capture_anchor); 67 for (i = 0; i < NUM_CAPTURE_URBS; i++) { 68 if (tascam->capture_urbs[i]) { 69 usb_free_coherent( 70 tascam->dev, tascam->capture_urb_alloc_size, 71 tascam->capture_urbs[i]->transfer_buffer, 72 tascam->capture_urbs[i]->transfer_dma); 73 usb_free_urb(tascam->capture_urbs[i]); 74 tascam->capture_urbs[i] = NULL; 75 } 76 } 77 78 usb_kill_anchored_urbs(&tascam->midi_in_anchor); 79 for (i = 0; i < NUM_MIDI_IN_URBS; i++) { 80 if (tascam->midi_in_urbs[i]) { 81 usb_free_coherent( 82 tascam->dev, MIDI_IN_BUF_SIZE, 83 tascam->midi_in_urbs[i]->transfer_buffer, 84 tascam->midi_in_urbs[i]->transfer_dma); 85 usb_free_urb(tascam->midi_in_urbs[i]); 86 tascam->midi_in_urbs[i] = NULL; 87 } 88 } 89 90 usb_kill_anchored_urbs(&tascam->midi_out_anchor); 91 for (i = 0; i < NUM_MIDI_OUT_URBS; i++) { 92 if (tascam->midi_out_urbs[i]) { 93 usb_free_coherent( 94 tascam->dev, MIDI_OUT_BUF_SIZE, 95 tascam->midi_out_urbs[i]->transfer_buffer, 96 tascam->midi_out_urbs[i]->transfer_dma); 97 usb_free_urb(tascam->midi_out_urbs[i]); 98 tascam->midi_out_urbs[i] = NULL; 99 } 100 } 101 102 kfree(tascam->capture_routing_buffer); 103 tascam->capture_routing_buffer = NULL; 104 kfree(tascam->capture_decode_dst_block); 105 tascam->capture_decode_dst_block = NULL; 106 kfree(tascam->capture_decode_raw_block); 107 tascam->capture_decode_raw_block = NULL; 108 kfree(tascam->capture_ring_buffer); 109 tascam->capture_ring_buffer = NULL; 110 } 111 112 int tascam_alloc_urbs(struct tascam_card *tascam) 113 { 114 int i; 115 size_t max_packet_size; 116 117 max_packet_size = ((96000 / 8000) + 2) * BYTES_PER_FRAME; 118 tascam->playback_urb_alloc_size = 119 max_packet_size * PLAYBACK_URB_PACKETS; 120 121 for (i = 0; i < NUM_PLAYBACK_URBS; i++) { 122 struct urb *urb = 123 usb_alloc_urb(PLAYBACK_URB_PACKETS, GFP_KERNEL); 124 125 if (!urb) 126 goto error; 127 tascam->playback_urbs[i] = urb; 128 129 urb->transfer_buffer = usb_alloc_coherent( 130 tascam->dev, tascam->playback_urb_alloc_size, 131 GFP_KERNEL, &urb->transfer_dma); 132 if (!urb->transfer_buffer) 133 goto error; 134 135 urb->dev = tascam->dev; 136 urb->pipe = usb_sndisocpipe(tascam->dev, EP_AUDIO_OUT); 137 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; 138 urb->interval = 1; 139 urb->context = tascam; 140 urb->complete = playback_urb_complete; 141 } 142 143 tascam->feedback_urb_alloc_size = 144 FEEDBACK_PACKET_SIZE * FEEDBACK_URB_PACKETS; 145 146 for (i = 0; i < NUM_FEEDBACK_URBS; i++) { 147 struct urb *f_urb = 148 usb_alloc_urb(FEEDBACK_URB_PACKETS, GFP_KERNEL); 149 150 if (!f_urb) 151 goto error; 152 tascam->feedback_urbs[i] = f_urb; 153 154 f_urb->transfer_buffer = usb_alloc_coherent( 155 tascam->dev, tascam->feedback_urb_alloc_size, 156 GFP_KERNEL, &f_urb->transfer_dma); 157 if (!f_urb->transfer_buffer) 158 goto error; 159 160 f_urb->dev = tascam->dev; 161 f_urb->pipe = 162 usb_rcvisocpipe(tascam->dev, EP_PLAYBACK_FEEDBACK); 163 f_urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP; 164 f_urb->interval = 4; 165 f_urb->context = tascam; 166 f_urb->complete = feedback_urb_complete; 167 } 168 169 tascam->capture_urb_alloc_size = CAPTURE_URB_SIZE; 170 for (i = 0; i < NUM_CAPTURE_URBS; i++) { 171 struct urb *c_urb = usb_alloc_urb(0, GFP_KERNEL); 172 173 if (!c_urb) 174 goto error; 175 tascam->capture_urbs[i] = c_urb; 176 177 c_urb->transfer_buffer = usb_alloc_coherent( 178 tascam->dev, tascam->capture_urb_alloc_size, GFP_KERNEL, 179 &c_urb->transfer_dma); 180 if (!c_urb->transfer_buffer) 181 goto error; 182 183 usb_fill_bulk_urb(c_urb, tascam->dev, 184 usb_rcvbulkpipe(tascam->dev, EP_AUDIO_IN), 185 c_urb->transfer_buffer, 186 tascam->capture_urb_alloc_size, 187 capture_urb_complete, tascam); 188 c_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 189 } 190 191 /* MIDI URB and buffer allocation */ 192 for (i = 0; i < NUM_MIDI_IN_URBS; i++) { 193 struct urb *m_urb = usb_alloc_urb(0, GFP_KERNEL); 194 195 if (!m_urb) 196 goto error; 197 tascam->midi_in_urbs[i] = m_urb; 198 m_urb->transfer_buffer = 199 usb_alloc_coherent(tascam->dev, MIDI_IN_BUF_SIZE, 200 GFP_KERNEL, &m_urb->transfer_dma); 201 if (!m_urb->transfer_buffer) 202 goto error; 203 usb_fill_bulk_urb(m_urb, tascam->dev, 204 usb_rcvbulkpipe(tascam->dev, EP_MIDI_IN), 205 m_urb->transfer_buffer, MIDI_IN_BUF_SIZE, 206 tascam_midi_in_urb_complete, tascam); 207 m_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 208 } 209 210 for (i = 0; i < NUM_MIDI_OUT_URBS; i++) { 211 struct urb *m_urb = usb_alloc_urb(0, GFP_KERNEL); 212 213 if (!m_urb) 214 goto error; 215 tascam->midi_out_urbs[i] = m_urb; 216 m_urb->transfer_buffer = 217 usb_alloc_coherent(tascam->dev, MIDI_OUT_BUF_SIZE, 218 GFP_KERNEL, &m_urb->transfer_dma); 219 if (!m_urb->transfer_buffer) 220 goto error; 221 usb_fill_bulk_urb(m_urb, tascam->dev, 222 usb_sndbulkpipe(tascam->dev, EP_MIDI_OUT), 223 m_urb->transfer_buffer, 224 0, /* length set later */ 225 tascam_midi_out_urb_complete, tascam); 226 m_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 227 } 228 229 tascam->capture_ring_buffer = 230 kmalloc(CAPTURE_RING_BUFFER_SIZE, GFP_KERNEL); 231 if (!tascam->capture_ring_buffer) 232 goto error; 233 234 tascam->capture_decode_raw_block = 235 kmalloc(RAW_BYTES_PER_DECODE_BLOCK, GFP_KERNEL); 236 if (!tascam->capture_decode_raw_block) 237 goto error; 238 239 tascam->capture_decode_dst_block = 240 kmalloc(FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME * 241 DECODED_SAMPLE_SIZE, 242 GFP_KERNEL); 243 if (!tascam->capture_decode_dst_block) 244 goto error; 245 246 tascam->capture_routing_buffer = 247 kmalloc(FRAMES_PER_DECODE_BLOCK * DECODED_CHANNELS_PER_FRAME * 248 DECODED_SAMPLE_SIZE, 249 GFP_KERNEL); 250 if (!tascam->capture_routing_buffer) 251 goto error; 252 253 return 0; 254 255 error: 256 dev_err(tascam->card->dev, "Failed to allocate URBs\n"); 257 tascam_free_urbs(tascam); 258 return -ENOMEM; 259 } 260 261 void tascam_stop_work_handler(struct work_struct *work) 262 { 263 struct tascam_card *tascam = 264 container_of(work, struct tascam_card, stop_work); 265 266 usb_kill_anchored_urbs(&tascam->playback_anchor); 267 usb_kill_anchored_urbs(&tascam->feedback_anchor); 268 usb_kill_anchored_urbs(&tascam->capture_anchor); 269 atomic_set(&tascam->active_urbs, 0); 270 } 271 272 /** 273 * tascam_card_private_free() - Frees private data associated with the sound 274 * card. 275 * @card: Pointer to the ALSA sound card instance. 276 * 277 * This function is called when the sound card is being freed. It releases 278 * resources allocated for the tascam_card structure, including the MIDI 279 * input FIFO and decrements the USB device reference count. 280 */ 281 static void tascam_card_private_free(struct snd_card *card) 282 { 283 struct tascam_card *tascam = card->private_data; 284 285 if (tascam) { 286 kfifo_free(&tascam->midi_in_fifo); 287 if (tascam->dev) { 288 usb_put_dev(tascam->dev); 289 tascam->dev = NULL; 290 } 291 } 292 } 293 294 /** 295 * tascam_suspend() - Handles device suspension. 296 * @intf: The USB interface being suspended. 297 * @message: Power management message. 298 * 299 * This function is called when the device is suspended. It stops all active 300 * streams, kills all URBs, and sends a vendor-specific deep sleep command 301 * to the device to ensure a stable low-power state. 302 * 303 * Return: 0 on success. 304 */ 305 static int tascam_suspend(struct usb_interface *intf, pm_message_t message) 306 { 307 struct tascam_card *tascam = usb_get_intfdata(intf); 308 309 if (!tascam) 310 return 0; 311 312 snd_pcm_suspend_all(tascam->pcm); 313 314 cancel_work_sync(&tascam->stop_work); 315 cancel_work_sync(&tascam->capture_work); 316 cancel_work_sync(&tascam->midi_in_work); 317 cancel_work_sync(&tascam->midi_out_work); 318 cancel_work_sync(&tascam->stop_pcm_work); 319 usb_kill_anchored_urbs(&tascam->playback_anchor); 320 usb_kill_anchored_urbs(&tascam->capture_anchor); 321 usb_kill_anchored_urbs(&tascam->feedback_anchor); 322 usb_kill_anchored_urbs(&tascam->midi_in_anchor); 323 usb_kill_anchored_urbs(&tascam->midi_out_anchor); 324 325 dev_info(&intf->dev, "sending deep sleep command\n"); 326 int err = usb_control_msg(tascam->dev, usb_sndctrlpipe(tascam->dev, 0), 327 VENDOR_REQ_DEEP_SLEEP, RT_H2D_VENDOR_DEV, 328 0x0000, 0x0000, NULL, 0, USB_CTRL_TIMEOUT_MS); 329 if (err < 0) 330 dev_err(&intf->dev, "deep sleep command failed: %d\n", err); 331 332 return 0; 333 } 334 335 /** 336 * tascam_resume() - Handles device resumption from suspend. 337 * @intf: The USB interface being resumed. 338 * 339 * This function is called when the device resumes from suspend. It 340 * re-establishes the active USB interface settings and re-configures the sample 341 * rate if it was previously active. 342 * 343 * Return: 0 on success, or a negative error code on failure. 344 */ 345 static int tascam_resume(struct usb_interface *intf) 346 { 347 struct tascam_card *tascam = usb_get_intfdata(intf); 348 int err; 349 350 if (!tascam) 351 return 0; 352 353 dev_info(&intf->dev, "resuming TASCAM US-144MKII\n"); 354 355 /* 356 * The device requires a full re-initialization sequence upon resume. 357 * First, re-establish the active USB interface settings. 358 */ 359 err = usb_set_interface(tascam->dev, 0, 1); 360 if (err < 0) { 361 dev_err(&intf->dev, 362 "resume: failed to set alt setting on intf 0: %d\n", 363 err); 364 return err; 365 } 366 err = usb_set_interface(tascam->dev, 1, 1); 367 if (err < 0) { 368 dev_err(&intf->dev, 369 "resume: failed to set alt setting on intf 1: %d\n", 370 err); 371 return err; 372 } 373 374 /* Re-configure the sample rate if one was previously active */ 375 if (tascam->current_rate > 0) 376 us144mkii_configure_device_for_rate(tascam, 377 tascam->current_rate); 378 379 return 0; 380 } 381 382 static void tascam_error_timer(struct timer_list *t) 383 { 384 struct tascam_card *tascam = 385 container_of(t, struct tascam_card, error_timer); 386 387 if (atomic_read(&tascam->midi_in_active)) 388 schedule_work(&tascam->midi_in_work); 389 if (atomic_read(&tascam->midi_out_active)) 390 schedule_work(&tascam->midi_out_work); 391 } 392 393 /** 394 * tascam_probe() - Probes for the TASCAM US-144MKII device. 395 * @intf: The USB interface being probed. 396 * @usb_id: The USB device ID. 397 * 398 * This function is the entry point for the USB driver when a matching device 399 * is found. It performs initial device setup, including: 400 * - Checking for the second interface (MIDI) and associating it. 401 * - Performing a vendor-specific handshake with the device. 402 * - Setting alternate settings for USB interfaces. 403 * - Creating and registering the ALSA sound card, PCM device, and MIDI device. 404 * - Allocating and initializing URBs for audio and MIDI transfers. 405 * 406 * Return: 0 on success, or a negative error code on failure. 407 */ 408 static int tascam_probe(struct usb_interface *intf, 409 const struct usb_device_id *usb_id) 410 { 411 struct usb_device *dev = interface_to_usbdev(intf); 412 struct snd_card *card; 413 struct tascam_card *tascam; 414 int err; 415 char *handshake_buf __free(kfree) = NULL; 416 417 if (dev->speed != USB_SPEED_HIGH) 418 dev_info( 419 &dev->dev, 420 "Device is connected to a USB 1.1 port, this is not supported.\n"); 421 422 /* The device has two interfaces; we drive both from this driver. */ 423 if (intf->cur_altsetting->desc.bInterfaceNumber == 1) { 424 tascam = usb_get_intfdata(usb_ifnum_to_if(dev, 0)); 425 if (tascam) { 426 usb_set_intfdata(intf, tascam); 427 tascam->iface1 = intf; 428 } 429 return 0; /* Let the core handle this interface */ 430 } 431 432 if (dev_idx >= SNDRV_CARDS) { 433 dev_err(&dev->dev, "Too many TASCAM devices present"); 434 return -ENODEV; 435 } 436 437 if (!enable[dev_idx]) { 438 dev_info(&dev->dev, "TASCAM US-144MKII device disabled"); 439 return -ENOENT; 440 } 441 442 handshake_buf = kmalloc(1, GFP_KERNEL); 443 if (!handshake_buf) 444 return -ENOMEM; 445 446 /* Perform vendor-specific handshake */ 447 err = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 448 VENDOR_REQ_MODE_CONTROL, RT_D2H_VENDOR_DEV, 449 MODE_VAL_HANDSHAKE_READ, 0x0000, handshake_buf, 1, 450 USB_CTRL_TIMEOUT_MS); 451 if (err < 0) { 452 dev_err(&dev->dev, "Handshake read failed with %d\n", err); 453 return err; 454 } 455 456 if (handshake_buf[0] != 0x12 && handshake_buf[0] != 0x16 && 457 handshake_buf[0] != 0x30 && handshake_buf[0] != 0x32) { 458 dev_err(&dev->dev, "Unexpected handshake value: 0x%x\n", 459 handshake_buf[0]); 460 return -ENODEV; 461 } 462 463 /* Set alternate settings to enable audio/MIDI endpoints */ 464 err = usb_set_interface(dev, 0, 1); 465 if (err < 0) { 466 dev_err(&dev->dev, 467 "Failed to set alt setting 1 on interface 0: %d\n", 468 err); 469 return err; 470 } 471 472 err = usb_set_interface(dev, 1, 1); 473 if (err < 0) { 474 dev_err(&dev->dev, 475 "Failed to set alt setting 1 on interface 1: %d\n", 476 err); 477 return err; 478 } 479 480 err = snd_card_new(&dev->dev, index[dev_idx], id[dev_idx], THIS_MODULE, 481 sizeof(struct tascam_card), &card); 482 if (err < 0) { 483 dev_err(&dev->dev, "Failed to create sound card instance\n"); 484 return err; 485 } 486 487 tascam = card->private_data; 488 card->private_free = tascam_card_private_free; 489 tascam->dev = usb_get_dev(dev); 490 tascam->card = card; 491 tascam->iface0 = intf; 492 tascam->digital_out_source = 1; 493 tascam->capture_34_source = 1; 494 495 spin_lock_init(&tascam->lock); 496 spin_lock_init(&tascam->midi_in_lock); 497 spin_lock_init(&tascam->midi_out_lock); 498 init_usb_anchor(&tascam->playback_anchor); 499 init_usb_anchor(&tascam->capture_anchor); 500 init_usb_anchor(&tascam->feedback_anchor); 501 init_usb_anchor(&tascam->midi_in_anchor); 502 init_usb_anchor(&tascam->midi_out_anchor); 503 504 timer_setup(&tascam->error_timer, tascam_error_timer, 0); 505 506 INIT_WORK(&tascam->stop_work, tascam_stop_work_handler); 507 INIT_WORK(&tascam->stop_pcm_work, tascam_stop_pcm_work_handler); 508 INIT_WORK(&tascam->capture_work, tascam_capture_work_handler); 509 init_completion(&tascam->midi_out_drain_completion); 510 511 if (kfifo_alloc(&tascam->midi_in_fifo, MIDI_IN_FIFO_SIZE, GFP_KERNEL)) { 512 snd_card_free(card); 513 return -ENOMEM; 514 } 515 516 strscpy(card->driver, DRIVER_NAME, sizeof(card->driver)); 517 if (le16_to_cpu(dev->descriptor.idProduct) == USB_PID_TASCAM_US144) { 518 strscpy(card->shortname, "TASCAM US-144", 519 sizeof(card->shortname)); 520 } else if (le16_to_cpu(dev->descriptor.idProduct) == USB_PID_TASCAM_US144MKII) { 521 strscpy(card->shortname, "TASCAM US-144MKII", 522 sizeof(card->shortname)); 523 } else { 524 strscpy(card->shortname, "TASCAM Unknown", 525 sizeof(card->shortname)); 526 } 527 snprintf(card->longname, sizeof(card->longname), "%s (%04x:%04x) at %s", 528 card->shortname, USB_VID_TASCAM, dev->descriptor.idProduct, 529 dev_name(&dev->dev)); 530 531 err = snd_pcm_new(card, "US144MKII PCM", 0, 1, 1, &tascam->pcm); 532 if (err < 0) 533 goto free_card; 534 tascam->pcm->private_data = tascam; 535 strscpy(tascam->pcm->name, "US144MKII PCM", sizeof(tascam->pcm->name)); 536 537 err = tascam_init_pcm(tascam->pcm); 538 if (err < 0) 539 goto free_card; 540 541 err = tascam_create_midi(tascam); 542 if (err < 0) 543 goto free_card; 544 545 err = tascam_create_controls(tascam); 546 if (err < 0) 547 goto free_card; 548 549 err = tascam_alloc_urbs(tascam); 550 if (err < 0) 551 goto free_card; 552 553 err = snd_card_register(card); 554 if (err < 0) 555 goto free_card; 556 557 usb_set_intfdata(intf, tascam); 558 559 dev_idx++; 560 return 0; 561 562 free_card: 563 tascam_free_urbs(tascam); 564 snd_card_free(card); 565 return err; 566 } 567 568 /** 569 * tascam_disconnect() - Disconnects the TASCAM US-144MKII device. 570 * @intf: The USB interface being disconnected. 571 * 572 * This function is called when the device is disconnected from the system. 573 * It cleans up all allocated resources, including killing URBs, freeing 574 * the sound card, and releasing memory. 575 */ 576 static void tascam_disconnect(struct usb_interface *intf) 577 { 578 struct tascam_card *tascam = usb_get_intfdata(intf); 579 580 if (!tascam) 581 return; 582 583 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) { 584 /* Ensure all deferred work is complete before freeing resources */ 585 snd_card_disconnect(tascam->card); 586 cancel_work_sync(&tascam->stop_work); 587 cancel_work_sync(&tascam->capture_work); 588 cancel_work_sync(&tascam->midi_in_work); 589 cancel_work_sync(&tascam->midi_out_work); 590 cancel_work_sync(&tascam->stop_pcm_work); 591 592 usb_kill_anchored_urbs(&tascam->playback_anchor); 593 usb_kill_anchored_urbs(&tascam->capture_anchor); 594 usb_kill_anchored_urbs(&tascam->feedback_anchor); 595 usb_kill_anchored_urbs(&tascam->midi_in_anchor); 596 usb_kill_anchored_urbs(&tascam->midi_out_anchor); 597 timer_delete_sync(&tascam->error_timer); 598 tascam_free_urbs(tascam); 599 snd_card_free(tascam->card); 600 dev_idx--; 601 } 602 } 603 604 static const struct usb_device_id tascam_usb_ids[] = { 605 { USB_DEVICE(USB_VID_TASCAM, USB_PID_TASCAM_US144) }, 606 { USB_DEVICE(USB_VID_TASCAM, USB_PID_TASCAM_US144MKII) }, 607 { /* Terminating entry */ } 608 }; 609 MODULE_DEVICE_TABLE(usb, tascam_usb_ids); 610 611 static struct usb_driver tascam_alsa_driver = { 612 .name = DRIVER_NAME, 613 .probe = tascam_probe, 614 .disconnect = tascam_disconnect, 615 .suspend = tascam_suspend, 616 .resume = tascam_resume, 617 .id_table = tascam_usb_ids, 618 }; 619 620 module_usb_driver(tascam_alsa_driver); 621