sound/usb/usbquirks.h

   1 /*
   2  * ALSA USB Audio Driver
   3  *
   4  * Copyright (c) 2002 by Takashi Iwai <tiwai@suse.de>,
   5  *                       Clemens Ladisch <clemens@ladisch.de>
   6  *
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  21  */
  22
  23 /*
  24  * The contents of this file are part of the driver's id_table.
  25  *
  26  * In a perfect world, this file would be empty.
  27  */
  28
  29 /*
  30  * Use this for devices where other interfaces are standard compliant,
  31  * to prevent the quirk being applied to those interfaces. (To work with
  32  * hotplugging, bDeviceClass must be set to USB_CLASS_PER_INTERFACE.)
  33  */
  34 #define USB_DEVICE_VENDOR_SPEC(vend, prod) \
  35         .match_flags = USB_DEVICE_ID_MATCH_VENDOR | \
  36                        USB_DEVICE_ID_MATCH_PRODUCT | \
  37                        USB_DEVICE_ID_MATCH_INT_CLASS, \
  38         .idVendor = vend, \
  39         .idProduct = prod, \
  40         .bInterfaceClass = USB_CLASS_VENDOR_SPEC
  41
  42 /*
  43  * Yamaha devices
  44  */
  45
  46 #define YAMAHA_DEVICE(id, name) { \
  47         USB_DEVICE(0x0499, id), \
  48         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { \
  49                 .vendor_name = "Yamaha", \
  50                 .product_name = name, \
  51                 .ifnum = QUIRK_ANY_INTERFACE, \
  52                 .type = QUIRK_MIDI_YAMAHA \
  53         } \
  54 }
  55 #define YAMAHA_INTERFACE(id, intf, name) { \
  56         USB_DEVICE_VENDOR_SPEC(0x0499, id), \
  57         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) { \
  58                 .vendor_name = "Yamaha", \
  59                 .product_name = name, \
  60                 .ifnum = intf, \
  61                 .type = QUIRK_MIDI_YAMAHA \
  62         } \
  63 }
  64 YAMAHA_DEVICE(0x1000, "UX256"),
  65 YAMAHA_DEVICE(0x1001, "MU1000"),
  66 YAMAHA_DEVICE(0x1002, "MU2000"),
  67 YAMAHA_DEVICE(0x1003, "MU500"),
  68 YAMAHA_INTERFACE(0x1004, 3, "UW500"),
  69 YAMAHA_DEVICE(0x1005, "MOTIF6"),
  70 YAMAHA_DEVICE(0x1006, "MOTIF7"),
  71 YAMAHA_DEVICE(0x1007, "MOTIF8"),
  72 YAMAHA_DEVICE(0x1008, "UX96"),
  73 YAMAHA_DEVICE(0x1009, "UX16"),
  74 YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
  75 YAMAHA_DEVICE(0x100e, "S08"),
  76 YAMAHA_DEVICE(0x100f, "CLP-150"),
  77 YAMAHA_DEVICE(0x1010, "CLP-170"),
  78 YAMAHA_DEVICE(0x1011, "P-250"),
  79 YAMAHA_DEVICE(0x1012, "TYROS"),
  80 YAMAHA_DEVICE(0x1013, "PF-500"),
  81 YAMAHA_DEVICE(0x1014, "S90"),
  82 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
  83 YAMAHA_DEVICE(0x1017, "CVP-204"),
  84 YAMAHA_DEVICE(0x1018, "CVP-206"),
  85 YAMAHA_DEVICE(0x1019, "CVP-208"),
  86 YAMAHA_DEVICE(0x101a, "CVP-210"),
  87 YAMAHA_DEVICE(0x101b, "PSR-1100"),
  88 YAMAHA_DEVICE(0x101c, "PSR-2100"),
  89 YAMAHA_DEVICE(0x101e, "PSR-K1"),
  90 YAMAHA_DEVICE(0x1020, "EZ-250i"),
  91 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
  92 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
  93 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
  94 YAMAHA_DEVICE(0x5000, "CS1D"),
  95 YAMAHA_DEVICE(0x5001, "DSP1D"),
  96 YAMAHA_DEVICE(0x5002, "DME32"),
  97 YAMAHA_DEVICE(0x5003, "DM2000"),
  98 YAMAHA_DEVICE(0x5004, "02R96"),
  99 YAMAHA_DEVICE(0x5005, "ACU16-C"),
 100 YAMAHA_DEVICE(0x5006, "NHB32-C"),
 101 YAMAHA_DEVICE(0x5007, "DM1000"),
 102 YAMAHA_DEVICE(0x5008, "01V96"),
 103 #undef YAMAHA_DEVICE
 104 #undef YAMAHA_INTERFACE
 105
 106 /*
 107  * Roland/RolandED/Edirol/BOSS devices
 108  */
 109 {
 110         USB_DEVICE(0x0582, 0x0000),
 111         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 112                 .vendor_name = "Roland",
 113                 .product_name = "UA-100",
 114                 .ifnum = QUIRK_ANY_INTERFACE,
 115                 .type = QUIRK_COMPOSITE,
 116                 .data = & (const snd_usb_audio_quirk_t[]) {
 117                         {
 118                                 .ifnum = 0,
 119                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 120                                 .data = & (const struct audioformat) {
 121                                         .format = SNDRV_PCM_FORMAT_S16_LE,
 122                                         .channels = 4,
 123                                         .iface = 0,
 124                                         .altsetting = 1,
 125                                         .altset_idx = 1,
 126                                         .attributes = 0,
 127                                         .endpoint = 0x01,
 128                                         .ep_attr = 0x09,
 129                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 130                                         .rate_min = 44100,
 131                                         .rate_max = 44100,
 132                                 }
 133                         },
 134                         {
 135                                 .ifnum = 1,
 136                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 137                                 .data = & (const struct audioformat) {
 138                                         .format = SNDRV_PCM_FORMAT_S16_LE,
 139                                         .channels = 2,
 140                                         .iface = 1,
 141                                         .altsetting = 1,
 142                                         .altset_idx = 1,
 143                                         .attributes = EP_CS_ATTR_FILL_MAX,
 144                                         .endpoint = 0x81,
 145                                         .ep_attr = 0x05,
 146                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 147                                         .rate_min = 44100,
 148                                         .rate_max = 44100,
 149                                 }
 150                         },
 151                         {
 152                                 .ifnum = 2,
 153                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 154                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 155                                         .out_cables = 0x0007,
 156                                         .in_cables  = 0x0007
 157                                 }
 158                         },
 159                         {
 160                                 .ifnum = -1
 161                         }
 162                 }
 163         }
 164 },
 165 {
 166         USB_DEVICE(0x0582, 0x0002),
 167         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 168                 .vendor_name = "EDIROL",
 169                 .product_name = "UM-4",
 170                 .ifnum = 2,
 171                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 172                 .data = & (const snd_usb_midi_endpoint_info_t) {
 173                         .out_cables = 0x000f,
 174                         .in_cables  = 0x000f
 175                 }
 176         }
 177 },
 178 {
 179         USB_DEVICE(0x0582, 0x0003),
 180         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 181                 .vendor_name = "Roland",
 182                 .product_name = "SC-8850",
 183                 .ifnum = 2,
 184                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 185                 .data = & (const snd_usb_midi_endpoint_info_t) {
 186                         .out_cables = 0x003f,
 187                         .in_cables  = 0x003f
 188                 }
 189         }
 190 },
 191 {
 192         USB_DEVICE(0x0582, 0x0004),
 193         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 194                 .vendor_name = "Roland",
 195                 .product_name = "U-8",
 196                 .ifnum = 2,
 197                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 198                 .data = & (const snd_usb_midi_endpoint_info_t) {
 199                         .out_cables = 0x0005,
 200                         .in_cables  = 0x0005
 201                 }
 202         }
 203 },
 204 {
 205         USB_DEVICE(0x0582, 0x0005),
 206         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 207                 .vendor_name = "EDIROL",
 208                 .product_name = "UM-2",
 209                 .ifnum = 2,
 210                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 211                 .data = & (const snd_usb_midi_endpoint_info_t) {
 212                         .out_cables = 0x0003,
 213                         .in_cables  = 0x0003
 214                 }
 215         }
 216 },
 217 {
 218         USB_DEVICE(0x0582, 0x0007),
 219         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 220                 .vendor_name = "Roland",
 221                 .product_name = "SC-8820",
 222                 .ifnum = 2,
 223                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 224                 .data = & (const snd_usb_midi_endpoint_info_t) {
 225                         .out_cables = 0x0013,
 226                         .in_cables  = 0x0013
 227                 }
 228         }
 229 },
 230 {
 231         USB_DEVICE(0x0582, 0x0008),
 232         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 233                 .vendor_name = "Roland",
 234                 .product_name = "PC-300",
 235                 .ifnum = 2,
 236                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 237                 .data = & (const snd_usb_midi_endpoint_info_t) {
 238                         .out_cables = 0x0001,
 239                         .in_cables  = 0x0001
 240                 }
 241         }
 242 },
 243 {
 244         USB_DEVICE(0x0582, 0x0009),
 245         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 246                 .vendor_name = "EDIROL",
 247                 .product_name = "UM-1",
 248                 .ifnum = 2,
 249                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 250                 .data = & (const snd_usb_midi_endpoint_info_t) {
 251                         .out_cables = 0x0001,
 252                         .in_cables  = 0x0001
 253                 }
 254         }
 255 },
 256 {
 257         USB_DEVICE(0x0582, 0x000b),
 258         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 259                 .vendor_name = "Roland",
 260                 .product_name = "SK-500",
 261                 .ifnum = 2,
 262                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 263                 .data = & (const snd_usb_midi_endpoint_info_t) {
 264                         .out_cables = 0x0013,
 265                         .in_cables  = 0x0013
 266                 }
 267         }
 268 },
 269 {
 270         /* thanks to Emiliano Grilli <emillo@libero.it> for helping researching this data */
 271         USB_DEVICE(0x0582, 0x000c),
 272         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 273                 .vendor_name = "Roland",
 274                 .product_name = "SC-D70",
 275                 .ifnum = QUIRK_ANY_INTERFACE,
 276                 .type = QUIRK_COMPOSITE,
 277                 .data = & (const snd_usb_audio_quirk_t[]) {
 278                         {
 279                                 .ifnum = 0,
 280                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 281                                 .data = & (const struct audioformat) {
 282                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
 283                                         .channels = 2,
 284                                         .iface = 0,
 285                                         .altsetting = 1,
 286                                         .altset_idx = 1,
 287                                         .attributes = 0,
 288                                         .endpoint = 0x01,
 289                                         .ep_attr = 0x01,
 290                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 291                                         .rate_min = 44100,
 292                                         .rate_max = 44100,
 293                                 }
 294                         },
 295                         {
 296                                 .ifnum = 1,
 297                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 298                                 .data = & (const struct audioformat) {
 299                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
 300                                         .channels = 2,
 301                                         .iface = 1,
 302                                         .altsetting = 1,
 303                                         .altset_idx = 1,
 304                                         .attributes = 0,
 305                                         .endpoint = 0x81,
 306                                         .ep_attr = 0x01,
 307                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 308                                         .rate_min = 44100,
 309                                         .rate_max = 44100,
 310                                 }
 311                         },
 312                         {
 313                                 .ifnum = 2,
 314                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 315                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 316                                         .out_cables = 0x0007,
 317                                         .in_cables  = 0x0007
 318                                 }
 319                         },
 320                         {
 321                                 .ifnum = -1
 322                         }
 323                 }
 324         }
 325 },
 326 {       /*
 327          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 328          * If the advanced mode switch at the back of the unit is off, the
 329          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 330          * but offers only 16-bit PCM.
 331          * In advanced mode, the UA-5 will output S24_3LE samples (two
 332          * channels) at the rate indicated on the front switch, including
 333          * the 96kHz sample rate.
 334          */
 335         USB_DEVICE(0x0582, 0x0010),
 336         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 337                 .vendor_name = "EDIROL",
 338                 .product_name = "UA-5",
 339                 .ifnum = QUIRK_ANY_INTERFACE,
 340                 .type = QUIRK_COMPOSITE,
 341                 .data = & (const snd_usb_audio_quirk_t[]) {
 342                         {
 343                                 .ifnum = 1,
 344                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 345                         },
 346                         {
 347                                 .ifnum = 2,
 348                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 349                         },
 350                         {
 351                                 .ifnum = -1
 352                         }
 353                 }
 354         }
 355 },
 356 {
 357         USB_DEVICE(0x0582, 0x0012),
 358         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 359                 .vendor_name = "Roland",
 360                 .product_name = "XV-5050",
 361                 .ifnum = 0,
 362                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 363                 .data = & (const snd_usb_midi_endpoint_info_t) {
 364                         .out_cables = 0x0001,
 365                         .in_cables  = 0x0001
 366                 }
 367         }
 368 },
 369 {
 370         USB_DEVICE(0x0582, 0x0014),
 371         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 372                 .vendor_name = "EDIROL",
 373                 .product_name = "UM-880",
 374                 .ifnum = 0,
 375                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 376                 .data = & (const snd_usb_midi_endpoint_info_t) {
 377                         .out_cables = 0x01ff,
 378                         .in_cables  = 0x01ff
 379                 }
 380         }
 381 },
 382 {
 383         USB_DEVICE(0x0582, 0x0016),
 384         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 385                 .vendor_name = "EDIROL",
 386                 .product_name = "SD-90",
 387                 .ifnum = 2,
 388                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 389                 .data = & (const snd_usb_midi_endpoint_info_t) {
 390                         .out_cables = 0x000f,
 391                         .in_cables  = 0x000f
 392                 }
 393         }
 394 },
 395 {
 396         USB_DEVICE(0x0582, 0x001b),
 397         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 398                 .vendor_name = "Roland",
 399                 .product_name = "MMP-2",
 400                 .ifnum = 2,
 401                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 402                 .data = & (const snd_usb_midi_endpoint_info_t) {
 403                         .out_cables = 0x0001,
 404                         .in_cables  = 0x0001
 405                 }
 406         }
 407 },
 408 {
 409         USB_DEVICE(0x0582, 0x001d),
 410         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 411                 .vendor_name = "Roland",
 412                 .product_name = "V-SYNTH",
 413                 .ifnum = 0,
 414                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 415                 .data = & (const snd_usb_midi_endpoint_info_t) {
 416                         .out_cables = 0x0001,
 417                         .in_cables  = 0x0001
 418                 }
 419         }
 420 },
 421 {
 422         USB_DEVICE(0x0582, 0x0023),
 423         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 424                 .vendor_name = "EDIROL",
 425                 .product_name = "UM-550",
 426                 .ifnum = 0,
 427                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 428                 .data = & (const snd_usb_midi_endpoint_info_t) {
 429                         .out_cables = 0x003f,
 430                         .in_cables  = 0x003f
 431                 }
 432         }
 433 },
 434 {
 435         /*
 436          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 437          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 438          * and no MIDI.
 439          */
 440         USB_DEVICE(0x0582, 0x0025),
 441         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 442                 .vendor_name = "EDIROL",
 443                 .product_name = "UA-20",
 444                 .ifnum = QUIRK_ANY_INTERFACE,
 445                 .type = QUIRK_COMPOSITE,
 446                 .data = & (const snd_usb_audio_quirk_t[]) {
 447                         {
 448                                 .ifnum = 1,
 449                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 450                         },
 451                         {
 452                                 .ifnum = 2,
 453                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 454                         },
 455                         {
 456                                 .ifnum = 3,
 457                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 458                         },
 459                         {
 460                                 .ifnum = -1
 461                         }
 462                 }
 463         }
 464 },
 465 {
 466         USB_DEVICE(0x0582, 0x0027),
 467         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 468                 .vendor_name = "EDIROL",
 469                 .product_name = "SD-20",
 470                 .ifnum = 0,
 471                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 472                 .data = & (const snd_usb_midi_endpoint_info_t) {
 473                         .out_cables = 0x0003,
 474                         .in_cables  = 0x0007
 475                 }
 476         }
 477 },
 478 {
 479         USB_DEVICE(0x0582, 0x0029),
 480         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 481                 .vendor_name = "EDIROL",
 482                 .product_name = "SD-80",
 483                 .ifnum = 0,
 484                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 485                 .data = & (const snd_usb_midi_endpoint_info_t) {
 486                         .out_cables = 0x000f,
 487                         .in_cables  = 0x000f
 488                 }
 489         }
 490 },
 491 {
 492         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 493         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 494                 .vendor_name = "EDIROL",
 495                 .product_name = "UA-700",
 496                 .ifnum = 3,
 497                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 498                 .data = & (const snd_usb_midi_endpoint_info_t) {
 499                         .out_cables = 0x0003,
 500                         .in_cables  = 0x0003
 501                 }
 502         }
 503 },
 504 {
 505         USB_DEVICE(0x0582, 0x002d),
 506         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 507                 .vendor_name = "Roland",
 508                 .product_name = "XV-2020",
 509                 .ifnum = 0,
 510                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 511                 .data = & (const snd_usb_midi_endpoint_info_t) {
 512                         .out_cables = 0x0001,
 513                         .in_cables  = 0x0001
 514                 }
 515         }
 516 },
 517 {
 518         USB_DEVICE(0x0582, 0x002f),
 519         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 520                 .vendor_name = "Roland",
 521                 .product_name = "VariOS",
 522                 .ifnum = 0,
 523                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 524                 .data = & (const snd_usb_midi_endpoint_info_t) {
 525                         .out_cables = 0x0007,
 526                         .in_cables  = 0x0007
 527                 }
 528         }
 529 },
 530 {
 531         USB_DEVICE(0x0582, 0x0033),
 532         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 533                 .vendor_name = "EDIROL",
 534                 .product_name = "PCR",
 535                 .ifnum = 0,
 536                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 537                 .data = & (const snd_usb_midi_endpoint_info_t) {
 538                         .out_cables = 0x0003,
 539                         .in_cables  = 0x0007
 540                 }
 541         }
 542 },
 543 {
 544         USB_DEVICE(0x0582, 0x0037),
 545         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 546                 .vendor_name = "Roland",
 547                 .product_name = "Digital Piano",
 548                 .ifnum = 0,
 549                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 550                 .data = & (const snd_usb_midi_endpoint_info_t) {
 551                         .out_cables = 0x0001,
 552                         .in_cables  = 0x0001
 553                 }
 554         }
 555 },
 556 {
 557         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
 558         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 559                 .vendor_name = "BOSS",
 560                 .product_name = "GS-10",
 561                 .ifnum = 3,
 562                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 563                 .data = & (const snd_usb_midi_endpoint_info_t) {
 564                         .out_cables = 0x0003,
 565                         .in_cables  = 0x0003
 566                 }
 567         }
 568 },
 569 {
 570         USB_DEVICE(0x0582, 0x0040),
 571         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 572                 .vendor_name = "Roland",
 573                 .product_name = "GI-20",
 574                 .ifnum = 0,
 575                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 576                 .data = & (const snd_usb_midi_endpoint_info_t) {
 577                         .out_cables = 0x0001,
 578                         .in_cables  = 0x0001
 579                 }
 580         }
 581 },
 582 {
 583         USB_DEVICE(0x0582, 0x0048),
 584         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 585                 .vendor_name = "EDIROL",
 586                 .product_name = "UR-80",
 587                 .ifnum = 0,
 588                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 589                 .data = & (const snd_usb_midi_endpoint_info_t) {
 590                         .out_cables = 0x0003,
 591                         .in_cables  = 0x0007
 592                 }
 593         }
 594 },
 595 {
 596         USB_DEVICE(0x0582, 0x004d),
 597         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 598                 .vendor_name = "EDIROL",
 599                 .product_name = "PCR-A",
 600                 .ifnum = 0,
 601                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 602                 .data = & (const snd_usb_midi_endpoint_info_t) {
 603                         .out_cables = 0x0003,
 604                         .in_cables  = 0x0007
 605                 }
 606         }
 607 },
 608 {
 609         USB_DEVICE(0x0582, 0x0065),
 610         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 611                 .vendor_name = "EDIROL",
 612                 .product_name = "PCR-1",
 613                 .ifnum = 0,
 614                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 615                 .data = & (const snd_usb_midi_endpoint_info_t) {
 616                         .out_cables = 0x0001,
 617                         .in_cables  = 0x0003
 618                 }
 619         }
 620 },
 621 {
 622         /*
 623          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
 624          * is standard compliant, but has only 16-bit PCM.
 625          */
 626         USB_DEVICE(0x0582, 0x0050),
 627         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 628                 .vendor_name = "EDIROL",
 629                 .product_name = "UA-3FX",
 630                 .ifnum = QUIRK_ANY_INTERFACE,
 631                 .type = QUIRK_COMPOSITE,
 632                 .data = & (const snd_usb_audio_quirk_t[]) {
 633                         {
 634                                 .ifnum = 1,
 635                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 636                         },
 637                         {
 638                                 .ifnum = 2,
 639                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 640                         },
 641                         {
 642                                 .ifnum = -1
 643                         }
 644                 }
 645         }
 646 },
 647 {
 648         USB_DEVICE(0x0582, 0x0052),
 649         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 650                 .vendor_name = "EDIROL",
 651                 .product_name = "UM-1SX",
 652                 .ifnum = 0,
 653                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 654         }
 655 },
 656
 657 /* Midiman/M-Audio devices */
 658 {
 659         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
 660         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 661                 .vendor_name = "M-Audio",
 662                 .product_name = "MidiSport 2x2",
 663                 .ifnum = QUIRK_ANY_INTERFACE,
 664                 .type = QUIRK_MIDI_MIDIMAN,
 665                 .data = & (const snd_usb_midi_endpoint_info_t) {
 666                         .out_cables = 0x0003,
 667                         .in_cables  = 0x0003
 668                 }
 669         }
 670 },
 671 {
 672         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
 673         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 674                 .vendor_name = "M-Audio",
 675                 .product_name = "MidiSport 1x1",
 676                 .ifnum = QUIRK_ANY_INTERFACE,
 677                 .type = QUIRK_MIDI_MIDIMAN,
 678                 .data = & (const snd_usb_midi_endpoint_info_t) {
 679                         .out_cables = 0x0001,
 680                         .in_cables  = 0x0001
 681                 }
 682         }
 683 },
 684 {
 685         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
 686         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 687                 .vendor_name = "M-Audio",
 688                 .product_name = "Keystation",
 689                 .ifnum = QUIRK_ANY_INTERFACE,
 690                 .type = QUIRK_MIDI_MIDIMAN,
 691                 .data = & (const snd_usb_midi_endpoint_info_t) {
 692                         .out_cables = 0x0001,
 693                         .in_cables  = 0x0001
 694                 }
 695         }
 696 },
 697 {
 698         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
 699         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 700                 .vendor_name = "M-Audio",
 701                 .product_name = "MidiSport 4x4",
 702                 .ifnum = QUIRK_ANY_INTERFACE,
 703                 .type = QUIRK_MIDI_MIDIMAN,
 704                 .data = & (const snd_usb_midi_endpoint_info_t) {
 705                         .out_cables = 0x000f,
 706                         .in_cables  = 0x000f
 707                 }
 708         }
 709 },
 710 {
 711         /*
 712          * For hardware revision 1.05; in the later revisions (1.10 and
 713          * 1.21), 0x1031 is the ID for the device without firmware.
 714          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
 715          */
 716         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
 717         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 718                 .vendor_name = "M-Audio",
 719                 .product_name = "MidiSport 8x8",
 720                 .ifnum = QUIRK_ANY_INTERFACE,
 721                 .type = QUIRK_MIDI_MIDIMAN,
 722                 .data = & (const snd_usb_midi_endpoint_info_t) {
 723                         .out_cables = 0x01ff,
 724                         .in_cables  = 0x01ff
 725                 }
 726         }
 727 },
 728 {
 729         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
 730         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 731                 .vendor_name = "M-Audio",
 732                 .product_name = "MidiSport 8x8",
 733                 .ifnum = QUIRK_ANY_INTERFACE,
 734                 .type = QUIRK_MIDI_MIDIMAN,
 735                 .data = & (const snd_usb_midi_endpoint_info_t) {
 736                         .out_cables = 0x01ff,
 737                         .in_cables  = 0x01ff
 738                 }
 739         }
 740 },
 741 {
 742         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
 743         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 744                 .vendor_name = "M-Audio",
 745                 .product_name = "MidiSport 2x4",
 746                 .ifnum = QUIRK_ANY_INTERFACE,
 747                 .type = QUIRK_MIDI_MIDIMAN,
 748                 .data = & (const snd_usb_midi_endpoint_info_t) {
 749                         .out_cables = 0x000f,
 750                         .in_cables  = 0x0003
 751                 }
 752         }
 753 },
 754 {
 755         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
 756         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 757                 .vendor_name = "M-Audio",
 758                 .product_name = "Quattro",
 759                 .ifnum = 9,
 760                 .type = QUIRK_MIDI_MIDIMAN,
 761                 .data = & (const snd_usb_midi_endpoint_info_t) {
 762                         .out_cables = 0x0001,
 763                         .in_cables  = 0x0001
 764                 }
 765         }
 766 },
 767 {
 768         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
 769         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 770                 .vendor_name = "M-Audio",
 771                 .product_name = "AudioPhile",
 772                 .ifnum = 6,
 773                 .type = QUIRK_MIDI_MIDIMAN,
 774                 .data = & (const snd_usb_midi_endpoint_info_t) {
 775                         .out_cables = 0x0001,
 776                         .in_cables  = 0x0001
 777                 }
 778         }
 779 },
 780 {
 781         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
 782         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 783                 .vendor_name = "M-Audio",
 784                 .product_name = "Ozone",
 785                 .ifnum = 3,
 786                 .type = QUIRK_MIDI_MIDIMAN,
 787                 .data = & (const snd_usb_midi_endpoint_info_t) {
 788                         .out_cables = 0x0001,
 789                         .in_cables  = 0x0001
 790                 }
 791         }
 792 },
 793 {
 794         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
 795         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 796                 .vendor_name = "M-Audio",
 797                 .product_name = "OmniStudio",
 798                 .ifnum = 9,
 799                 .type = QUIRK_MIDI_MIDIMAN,
 800                 .data = & (const snd_usb_midi_endpoint_info_t) {
 801                         .out_cables = 0x0001,
 802                         .in_cables  = 0x0001
 803                 }
 804         }
 805 },
 806
 807 /* Mark of the Unicorn devices */
 808 {
 809         /* thanks to Woodley Packard <sweaglesw@thibs.menloschool.org> */
 810         USB_DEVICE(0x07fd, 0x0001),
 811         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 812                 .vendor_name = "MOTU",
 813                 .product_name = "Fastlane",
 814                 .ifnum = 1,
 815                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 816                 .data = & (const snd_usb_midi_endpoint_info_t) {
 817                         .out_cables = 0x0003,
 818                         .in_cables  = 0x0003
 819                 }
 820         }
 821 },
 822
 823 {
 824         /* Creative Sound Blaster MP3+ */
 825         USB_DEVICE(0x041e, 0x3010),
 826         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 827                 .vendor_name = "Creative Labs",
 828                 .product_name = "Sound Blaster MP3+",
 829                 .ifnum = QUIRK_NO_INTERFACE
 830         }
 831
 832 },
 833
 834 {
 835         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
 836         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 837                 .vendor_name = "Terratec",
 838                 .product_name = "PHASE 26",
 839                 .ifnum = 3,
 840                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 841         }
 842 },
 843
 844 #undef USB_DEVICE_VENDOR_SPEC