sound/usb/usx2y/us122l.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Copyright (C) 2007, 2008 Karsten Wiese <fzu@wemgehoertderstaat.de>
   4  */
   5
   6 #include <linux/slab.h>
   7 #include <linux/usb.h>
   8 #include <linux/usb/audio.h>
   9 #include <linux/module.h>
  10 #include <sound/core.h>
  11 #include <sound/hwdep.h>
  12 #include <sound/pcm.h>
  13 #include <sound/initval.h>
  14 #define MODNAME "US122L"
  15 #include "usb_stream.c"
  16 #include "../usbaudio.h"
  17 #include "../midi.h"
  18 #include "us122l.h"
  19
  20 MODULE_AUTHOR("Karsten Wiese <fzu@wemgehoertderstaat.de>");
  21 MODULE_DESCRIPTION("TASCAM "NAME_ALLCAPS" Version 0.5");
  22 MODULE_LICENSE("GPL");
  23
  24 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-max */
  25 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* Id for this card */
  26                                                         /* Enable this card */
  27 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
  28
  29 module_param_array(index, int, NULL, 0444);
  30 MODULE_PARM_DESC(index, "Index value for "NAME_ALLCAPS".");
  31 module_param_array(id, charp, NULL, 0444);
  32 MODULE_PARM_DESC(id, "ID string for "NAME_ALLCAPS".");
  33 module_param_array(enable, bool, NULL, 0444);
  34 MODULE_PARM_DESC(enable, "Enable "NAME_ALLCAPS".");
  35
  36 /* driver_info flags */
  37 #define US122L_FLAG_US144       BIT(0)
  38
  39 static int snd_us122l_card_used[SNDRV_CARDS];
  40
  41 static int us122l_create_usbmidi(struct snd_card *card)
  42 {
  43         static const struct snd_usb_midi_endpoint_info quirk_data = {
  44                 .out_ep = 4,
  45                 .in_ep = 3,
  46                 .out_cables =   0x001,
  47                 .in_cables =    0x001
  48         };
  49         static const struct snd_usb_audio_quirk quirk = {
  50                 .vendor_name =  "US122L",
  51                 .product_name = NAME_ALLCAPS,
  52                 .ifnum =        1,
  53                 .type = QUIRK_MIDI_US122L,
  54                 .data = &quirk_data
  55         };
  56         struct usb_device *dev = US122L(card)->dev;
  57         struct usb_interface *iface = usb_ifnum_to_if(dev, 1);
  58
  59         return snd_usbmidi_create(card, iface,
  60                                   &US122L(card)->midi_list, &quirk);
  61 }
  62
  63 static int us144_create_usbmidi(struct snd_card *card)
  64 {
  65         static const struct snd_usb_midi_endpoint_info quirk_data = {
  66                 .out_ep = 4,
  67                 .in_ep = 3,
  68                 .out_cables =   0x001,
  69                 .in_cables =    0x001
  70         };
  71         static const struct snd_usb_audio_quirk quirk = {
  72                 .vendor_name =  "US144",
  73                 .product_name = NAME_ALLCAPS,
  74                 .ifnum =        0,
  75                 .type = QUIRK_MIDI_US122L,
  76                 .data = &quirk_data
  77         };
  78         struct usb_device *dev = US122L(card)->dev;
  79         struct usb_interface *iface = usb_ifnum_to_if(dev, 0);
  80
  81         return snd_usbmidi_create(card, iface,
  82                                   &US122L(card)->midi_list, &quirk);
  83 }
  84
  85 static void pt_info_set(struct usb_device *dev, u8 v)
  86 {
  87         usb_control_msg_send(dev, 0, 'I',
  88                              USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  89                              v, 0, NULL, 0, 1000, GFP_NOIO);
  90 }
  91
  92 static vm_fault_t usb_stream_hwdep_vm_fault(struct vm_fault *vmf)
  93 {
  94         unsigned long offset;
  95         struct page *page;
  96         void *vaddr;
  97         struct us122l *us122l = vmf->vma->vm_private_data;
  98         struct usb_stream *s;
  99
 100         mutex_lock(&us122l->mutex);
 101         s = us122l->sk.s;
 102         if (!s)
 103                 goto unlock;
 104
 105         offset = vmf->pgoff << PAGE_SHIFT;
 106         if (offset < PAGE_ALIGN(s->read_size)) {
 107                 vaddr = (char *)s + offset;
 108         } else {
 109                 offset -= PAGE_ALIGN(s->read_size);
 110                 if (offset >= PAGE_ALIGN(s->write_size))
 111                         goto unlock;
 112
 113                 vaddr = us122l->sk.write_page + offset;
 114         }
 115         page = virt_to_page(vaddr);
 116
 117         get_page(page);
 118         mutex_unlock(&us122l->mutex);
 119
 120         vmf->page = page;
 121
 122         return 0;
 123 unlock:
 124         mutex_unlock(&us122l->mutex);
 125         return VM_FAULT_SIGBUS;
 126 }
 127
 128
 129 static const struct vm_operations_struct usb_stream_hwdep_vm_ops = {
 130         .fault = usb_stream_hwdep_vm_fault,
 131 };
 132
 133 static int usb_stream_hwdep_open(struct snd_hwdep *hw, struct file *file)
 134 {
 135         struct us122l   *us122l = hw->private_data;
 136         struct usb_interface *iface;
 137
 138         if (hw->used >= 2)
 139                 return -EBUSY;
 140
 141         if (!us122l->first)
 142                 us122l->first = file;
 143
 144         if (us122l->is_us144) {
 145                 iface = usb_ifnum_to_if(us122l->dev, 0);
 146                 usb_autopm_get_interface(iface);
 147         }
 148         iface = usb_ifnum_to_if(us122l->dev, 1);
 149         usb_autopm_get_interface(iface);
 150         return 0;
 151 }
 152
 153 static int usb_stream_hwdep_release(struct snd_hwdep *hw, struct file *file)
 154 {
 155         struct us122l   *us122l = hw->private_data;
 156         struct usb_interface *iface;
 157
 158         if (us122l->is_us144) {
 159                 iface = usb_ifnum_to_if(us122l->dev, 0);
 160                 usb_autopm_put_interface(iface);
 161         }
 162         iface = usb_ifnum_to_if(us122l->dev, 1);
 163         usb_autopm_put_interface(iface);
 164         if (us122l->first == file)
 165                 us122l->first = NULL;
 166         mutex_lock(&us122l->mutex);
 167         if (us122l->master == file)
 168                 us122l->master = us122l->slave;
 169
 170         us122l->slave = NULL;
 171         mutex_unlock(&us122l->mutex);
 172         return 0;
 173 }
 174
 175 static int usb_stream_hwdep_mmap(struct snd_hwdep *hw,
 176                                  struct file *filp, struct vm_area_struct *area)
 177 {
 178         unsigned long   size = area->vm_end - area->vm_start;
 179         struct us122l   *us122l = hw->private_data;
 180         unsigned long offset;
 181         struct usb_stream *s;
 182         int err = 0;
 183         bool read;
 184
 185         offset = area->vm_pgoff << PAGE_SHIFT;
 186         mutex_lock(&us122l->mutex);
 187         s = us122l->sk.s;
 188         read = offset < s->read_size;
 189         if (read && area->vm_flags & VM_WRITE) {
 190                 err = -EPERM;
 191                 goto out;
 192         }
 193         /* if userspace tries to mmap beyond end of our buffer, fail */
 194         if (size > PAGE_ALIGN(read ? s->read_size : s->write_size)) {
 195                 dev_warn(hw->card->dev, "%s: size %lu > %u\n", __func__,
 196                          size, read ? s->read_size : s->write_size);
 197                 err = -EINVAL;
 198                 goto out;
 199         }
 200
 201         area->vm_ops = &usb_stream_hwdep_vm_ops;
 202         vm_flags_set(area, VM_DONTDUMP);
 203         if (!read)
 204                 vm_flags_set(area, VM_DONTEXPAND);
 205         area->vm_private_data = us122l;
 206 out:
 207         mutex_unlock(&us122l->mutex);
 208         return err;
 209 }
 210
 211 static __poll_t usb_stream_hwdep_poll(struct snd_hwdep *hw,
 212                                           struct file *file, poll_table *wait)
 213 {
 214         struct us122l   *us122l = hw->private_data;
 215         unsigned int    *polled;
 216         __poll_t        mask;
 217
 218         poll_wait(file, &us122l->sk.sleep, wait);
 219
 220         mask = EPOLLIN | EPOLLOUT | EPOLLWRNORM | EPOLLERR;
 221         if (mutex_trylock(&us122l->mutex)) {
 222                 struct usb_stream *s = us122l->sk.s;
 223
 224                 if (s && s->state == usb_stream_ready) {
 225                         if (us122l->first == file)
 226                                 polled = &s->periods_polled;
 227                         else
 228                                 polled = &us122l->second_periods_polled;
 229                         if (*polled != s->periods_done) {
 230                                 *polled = s->periods_done;
 231                                 mask = EPOLLIN | EPOLLOUT | EPOLLWRNORM;
 232                         } else {
 233                                 mask = 0;
 234                         }
 235                 }
 236                 mutex_unlock(&us122l->mutex);
 237         }
 238         return mask;
 239 }
 240
 241 static void us122l_stop(struct us122l *us122l)
 242 {
 243         struct list_head *p;
 244
 245         list_for_each(p, &us122l->midi_list)
 246                 snd_usbmidi_input_stop(p);
 247
 248         usb_stream_stop(&us122l->sk);
 249         usb_stream_free(&us122l->sk);
 250 }
 251
 252 static int us122l_set_sample_rate(struct usb_device *dev, int rate)
 253 {
 254         unsigned int ep = 0x81;
 255         unsigned char data[3];
 256         int err;
 257
 258         data[0] = rate;
 259         data[1] = rate >> 8;
 260         data[2] = rate >> 16;
 261         err = usb_control_msg_send(dev, 0, UAC_SET_CUR,
 262                                    USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT,
 263                                    UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, data, 3,
 264                                    1000, GFP_NOIO);
 265         if (err)
 266                 dev_err(&dev->dev, "%d: cannot set freq %d to ep 0x%x\n",
 267                         dev->devnum, rate, ep);
 268         return err;
 269 }
 270
 271 static bool us122l_start(struct us122l *us122l,
 272                          unsigned int rate, unsigned int period_frames)
 273 {
 274         struct list_head *p;
 275         int err;
 276         unsigned int use_packsize = 0;
 277         bool success = false;
 278
 279         if (us122l->dev->speed == USB_SPEED_HIGH) {
 280                 /* The us-122l's descriptor defaults to iso max_packsize 78,
 281                    which isn't needed for samplerates <= 48000.
 282                    Lets save some memory:
 283                 */
 284                 switch (rate) {
 285                 case 44100:
 286                         use_packsize = 36;
 287                         break;
 288                 case 48000:
 289                         use_packsize = 42;
 290                         break;
 291                 case 88200:
 292                         use_packsize = 72;
 293                         break;
 294                 }
 295         }
 296         if (!usb_stream_new(&us122l->sk, us122l->dev, 1, 2,
 297                             rate, use_packsize, period_frames, 6))
 298                 goto out;
 299
 300         err = us122l_set_sample_rate(us122l->dev, rate);
 301         if (err < 0) {
 302                 us122l_stop(us122l);
 303                 dev_err(&us122l->dev->dev, "us122l_set_sample_rate error\n");
 304                 goto out;
 305         }
 306         err = usb_stream_start(&us122l->sk);
 307         if (err < 0) {
 308                 us122l_stop(us122l);
 309                 dev_err(&us122l->dev->dev, "%s error %i\n", __func__, err);
 310                 goto out;
 311         }
 312         list_for_each(p, &us122l->midi_list)
 313                 snd_usbmidi_input_start(p);
 314         success = true;
 315 out:
 316         return success;
 317 }
 318
 319 static int usb_stream_hwdep_ioctl(struct snd_hwdep *hw, struct file *file,
 320                                   unsigned int cmd, unsigned long arg)
 321 {
 322         struct usb_stream_config cfg;
 323         struct us122l *us122l = hw->private_data;
 324         struct usb_stream *s;
 325         unsigned int min_period_frames;
 326         int err = 0;
 327         bool high_speed;
 328
 329         if (cmd != SNDRV_USB_STREAM_IOCTL_SET_PARAMS)
 330                 return -ENOTTY;
 331
 332         if (copy_from_user(&cfg, (void __user *)arg, sizeof(cfg)))
 333                 return -EFAULT;
 334
 335         if (cfg.version != USB_STREAM_INTERFACE_VERSION)
 336                 return -ENXIO;
 337
 338         high_speed = us122l->dev->speed == USB_SPEED_HIGH;
 339         if ((cfg.sample_rate != 44100 && cfg.sample_rate != 48000  &&
 340              (!high_speed ||
 341               (cfg.sample_rate != 88200 && cfg.sample_rate != 96000))) ||
 342             cfg.frame_size != 6 ||
 343             cfg.period_frames > 0x3000)
 344                 return -EINVAL;
 345
 346         switch (cfg.sample_rate) {
 347         case 44100:
 348                 min_period_frames = 48;
 349                 break;
 350         case 48000:
 351                 min_period_frames = 52;
 352                 break;
 353         default:
 354                 min_period_frames = 104;
 355                 break;
 356         }
 357         if (!high_speed)
 358                 min_period_frames <<= 1;
 359         if (cfg.period_frames < min_period_frames)
 360                 return -EINVAL;
 361
 362         snd_power_wait(hw->card);
 363
 364         mutex_lock(&us122l->mutex);
 365         s = us122l->sk.s;
 366         if (!us122l->master) {
 367                 us122l->master = file;
 368         } else if (us122l->master != file) {
 369                 if (!s || memcmp(&cfg, &s->cfg, sizeof(cfg))) {
 370                         err = -EIO;
 371                         goto unlock;
 372                 }
 373                 us122l->slave = file;
 374         }
 375         if (!s || memcmp(&cfg, &s->cfg, sizeof(cfg)) ||
 376             s->state == usb_stream_xrun) {
 377                 us122l_stop(us122l);
 378                 if (!us122l_start(us122l, cfg.sample_rate, cfg.period_frames))
 379                         err = -EIO;
 380                 else
 381                         err = 1;
 382         }
 383 unlock:
 384         mutex_unlock(&us122l->mutex);
 385         wake_up_all(&us122l->sk.sleep);
 386         return err;
 387 }
 388
 389 #define SND_USB_STREAM_ID "USB STREAM"
 390 static int usb_stream_hwdep_new(struct snd_card *card)
 391 {
 392         int err;
 393         struct snd_hwdep *hw;
 394         struct usb_device *dev = US122L(card)->dev;
 395
 396         err = snd_hwdep_new(card, SND_USB_STREAM_ID, 0, &hw);
 397         if (err < 0)
 398                 return err;
 399
 400         hw->iface = SNDRV_HWDEP_IFACE_USB_STREAM;
 401         hw->private_data = US122L(card);
 402         hw->ops.open = usb_stream_hwdep_open;
 403         hw->ops.release = usb_stream_hwdep_release;
 404         hw->ops.ioctl = usb_stream_hwdep_ioctl;
 405         hw->ops.ioctl_compat = usb_stream_hwdep_ioctl;
 406         hw->ops.mmap = usb_stream_hwdep_mmap;
 407         hw->ops.poll = usb_stream_hwdep_poll;
 408
 409         sprintf(hw->name, "/dev/bus/usb/%03d/%03d/hwdeppcm",
 410                 dev->bus->busnum, dev->devnum);
 411         return 0;
 412 }
 413
 414 static bool us122l_create_card(struct snd_card *card)
 415 {
 416         int err;
 417         struct us122l *us122l = US122L(card);
 418
 419         if (us122l->is_us144) {
 420                 err = usb_set_interface(us122l->dev, 0, 1);
 421                 if (err) {
 422                         dev_err(card->dev, "usb_set_interface error\n");
 423                         return false;
 424                 }
 425         }
 426         err = usb_set_interface(us122l->dev, 1, 1);
 427         if (err) {
 428                 dev_err(card->dev, "usb_set_interface error\n");
 429                 return false;
 430         }
 431
 432         pt_info_set(us122l->dev, 0x11);
 433         pt_info_set(us122l->dev, 0x10);
 434
 435         if (!us122l_start(us122l, 44100, 256))
 436                 return false;
 437
 438         if (us122l->is_us144)
 439                 err = us144_create_usbmidi(card);
 440         else
 441                 err = us122l_create_usbmidi(card);
 442         if (err < 0) {
 443                 dev_err(card->dev, "us122l_create_usbmidi error %i\n", err);
 444                 goto stop;
 445         }
 446         err = usb_stream_hwdep_new(card);
 447         if (err < 0) {
 448                 /* release the midi resources */
 449                 struct list_head *p;
 450
 451                 list_for_each(p, &us122l->midi_list)
 452                         snd_usbmidi_disconnect(p);
 453
 454                 goto stop;
 455         }
 456         return true;
 457
 458 stop:
 459         us122l_stop(us122l);
 460         return false;
 461 }
 462
 463 static void snd_us122l_free(struct snd_card *card)
 464 {
 465         struct us122l   *us122l = US122L(card);
 466         int             index = us122l->card_index;
 467
 468         if (index >= 0 && index < SNDRV_CARDS)
 469                 snd_us122l_card_used[index] = 0;
 470 }
 471
 472 static int usx2y_create_card(struct usb_device *device,
 473                              struct usb_interface *intf,
 474                              struct snd_card **cardp,
 475                              unsigned long flags)
 476 {
 477         int             dev;
 478         struct snd_card *card;
 479         int err;
 480
 481         for (dev = 0; dev < SNDRV_CARDS; ++dev)
 482                 if (enable[dev] && !snd_us122l_card_used[dev])
 483                         break;
 484         if (dev >= SNDRV_CARDS)
 485                 return -ENODEV;
 486         err = snd_card_new(&intf->dev, index[dev], id[dev], THIS_MODULE,
 487                            sizeof(struct us122l), &card);
 488         if (err < 0)
 489                 return err;
 490         snd_us122l_card_used[US122L(card)->card_index = dev] = 1;
 491         card->private_free = snd_us122l_free;
 492         US122L(card)->dev = device;
 493         mutex_init(&US122L(card)->mutex);
 494         US122L(card)->sk.dev = device;
 495         init_waitqueue_head(&US122L(card)->sk.sleep);
 496         US122L(card)->is_us144 = flags & US122L_FLAG_US144;
 497         INIT_LIST_HEAD(&US122L(card)->midi_list);
 498         strcpy(card->driver, "USB "NAME_ALLCAPS"");
 499         sprintf(card->shortname, "TASCAM "NAME_ALLCAPS"");
 500         sprintf(card->longname, "%s (%x:%x if %d at %03d/%03d)",
 501                 card->shortname,
 502                 le16_to_cpu(device->descriptor.idVendor),
 503                 le16_to_cpu(device->descriptor.idProduct),
 504                 0,
 505                 US122L(card)->dev->bus->busnum,
 506                 US122L(card)->dev->devnum
 507                 );
 508         *cardp = card;
 509         return 0;
 510 }
 511
 512 static int us122l_usb_probe(struct usb_interface *intf,
 513                             const struct usb_device_id *device_id,
 514                             struct snd_card **cardp)
 515 {
 516         struct usb_device *device = interface_to_usbdev(intf);
 517         struct snd_card *card;
 518         int err;
 519
 520         err = usx2y_create_card(device, intf, &card, device_id->driver_info);
 521         if (err < 0)
 522                 return err;
 523
 524         if (!us122l_create_card(card)) {
 525                 snd_card_free(card);
 526                 return -EINVAL;
 527         }
 528
 529         err = snd_card_register(card);
 530         if (err < 0) {
 531                 snd_card_free(card);
 532                 return err;
 533         }
 534
 535         usb_get_intf(usb_ifnum_to_if(device, 0));
 536         usb_get_dev(device);
 537         *cardp = card;
 538         return 0;
 539 }
 540
 541 static int snd_us122l_probe(struct usb_interface *intf,
 542                             const struct usb_device_id *id)
 543 {
 544         struct usb_device *device = interface_to_usbdev(intf);
 545         struct snd_card *card;
 546         int err;
 547
 548         if (id->driver_info & US122L_FLAG_US144 &&
 549                         device->speed == USB_SPEED_HIGH) {
 550                 dev_err(&device->dev, "disable ehci-hcd to run US-144\n");
 551                 return -ENODEV;
 552         }
 553
 554         if (intf->cur_altsetting->desc.bInterfaceNumber != 1)
 555                 return 0;
 556
 557         err = us122l_usb_probe(usb_get_intf(intf), id, &card);
 558         if (err < 0) {
 559                 usb_put_intf(intf);
 560                 return err;
 561         }
 562
 563         usb_set_intfdata(intf, card);
 564         return 0;
 565 }
 566
 567 static void snd_us122l_disconnect(struct usb_interface *intf)
 568 {
 569         struct snd_card *card;
 570         struct us122l *us122l;
 571         struct list_head *p;
 572
 573         card = usb_get_intfdata(intf);
 574         if (!card)
 575                 return;
 576
 577         snd_card_disconnect(card);
 578
 579         us122l = US122L(card);
 580         mutex_lock(&us122l->mutex);
 581         us122l_stop(us122l);
 582         mutex_unlock(&us122l->mutex);
 583
 584         /* release the midi resources */
 585         list_for_each(p, &us122l->midi_list) {
 586                 snd_usbmidi_disconnect(p);
 587         }
 588
 589         usb_put_intf(usb_ifnum_to_if(us122l->dev, 0));
 590         usb_put_intf(usb_ifnum_to_if(us122l->dev, 1));
 591         usb_put_dev(us122l->dev);
 592
 593         snd_card_free_when_closed(card);
 594 }
 595
 596 static int snd_us122l_suspend(struct usb_interface *intf, pm_message_t message)
 597 {
 598         struct snd_card *card;
 599         struct us122l *us122l;
 600         struct list_head *p;
 601
 602         card = usb_get_intfdata(intf);
 603         if (!card)
 604                 return 0;
 605         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 606
 607         us122l = US122L(card);
 608         if (!us122l)
 609                 return 0;
 610
 611         list_for_each(p, &us122l->midi_list)
 612                 snd_usbmidi_input_stop(p);
 613
 614         mutex_lock(&us122l->mutex);
 615         usb_stream_stop(&us122l->sk);
 616         mutex_unlock(&us122l->mutex);
 617
 618         return 0;
 619 }
 620
 621 static int snd_us122l_resume(struct usb_interface *intf)
 622 {
 623         struct snd_card *card;
 624         struct us122l *us122l;
 625         struct list_head *p;
 626         int err;
 627
 628         card = usb_get_intfdata(intf);
 629         if (!card)
 630                 return 0;
 631
 632         us122l = US122L(card);
 633         if (!us122l)
 634                 return 0;
 635
 636         mutex_lock(&us122l->mutex);
 637         /* needed, doesn't restart without: */
 638         if (us122l->is_us144) {
 639                 err = usb_set_interface(us122l->dev, 0, 1);
 640                 if (err) {
 641                         dev_err(&us122l->dev->dev, "usb_set_interface error\n");
 642                         goto unlock;
 643                 }
 644         }
 645         err = usb_set_interface(us122l->dev, 1, 1);
 646         if (err) {
 647                 dev_err(&us122l->dev->dev, "usb_set_interface error\n");
 648                 goto unlock;
 649         }
 650
 651         pt_info_set(us122l->dev, 0x11);
 652         pt_info_set(us122l->dev, 0x10);
 653
 654         err = us122l_set_sample_rate(us122l->dev,
 655                                      us122l->sk.s->cfg.sample_rate);
 656         if (err < 0) {
 657                 dev_err(&us122l->dev->dev, "us122l_set_sample_rate error\n");
 658                 goto unlock;
 659         }
 660         err = usb_stream_start(&us122l->sk);
 661         if (err)
 662                 goto unlock;
 663
 664         list_for_each(p, &us122l->midi_list)
 665                 snd_usbmidi_input_start(p);
 666 unlock:
 667         mutex_unlock(&us122l->mutex);
 668         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
 669         return err;
 670 }
 671
 672 static const struct usb_device_id snd_us122l_usb_id_table[] = {
 673         {
 674                 .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
 675                 .idVendor =     0x0644,
 676                 .idProduct =    USB_ID_US122L
 677         },
 678         {       /* US-144 only works at USB1.1! Disable module ehci-hcd. */
 679                 .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
 680                 .idVendor =     0x0644,
 681                 .idProduct =    USB_ID_US144,
 682                 .driver_info =  US122L_FLAG_US144
 683         },
 684         {
 685                 .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
 686                 .idVendor =     0x0644,
 687                 .idProduct =    USB_ID_US122MKII
 688         },
 689         {
 690                 .match_flags =  USB_DEVICE_ID_MATCH_DEVICE,
 691                 .idVendor =     0x0644,
 692                 .idProduct =    USB_ID_US144MKII,
 693                 .driver_info =  US122L_FLAG_US144
 694         },
 695         { /* terminator */ }
 696 };
 697 MODULE_DEVICE_TABLE(usb, snd_us122l_usb_id_table);
 698
 699 static struct usb_driver snd_us122l_usb_driver = {
 700         .name =         "snd-usb-us122l",
 701         .probe =        snd_us122l_probe,
 702         .disconnect =   snd_us122l_disconnect,
 703         .suspend =      snd_us122l_suspend,
 704         .resume =       snd_us122l_resume,
 705         .reset_resume = snd_us122l_resume,
 706         .id_table =     snd_us122l_usb_id_table,
 707         .supports_autosuspend = 1
 708 };
 709
 710 module_usb_driver(snd_us122l_usb_driver);