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          * This quirk is for the "Advanced" modes of the Edirol UA-700.
 493          * If the sample format switch is not in an advanced setting, the
 494          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
 495          * but offers only 16-bit PCM and no MIDI.
 496          */
 497         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 498         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 499                 .vendor_name = "EDIROL",
 500                 .product_name = "UA-700",
 501                 .ifnum = QUIRK_ANY_INTERFACE,
 502                 .type = QUIRK_COMPOSITE,
 503                 .data = (const snd_usb_audio_quirk_t[]) {
 504                         {
 505                                 .ifnum = 1,
 506                                 .type = QUIRK_AUDIO_EDIROL_UA700
 507                         },
 508                         {
 509                                 .ifnum = 2,
 510                                 .type = QUIRK_AUDIO_EDIROL_UA700
 511                         },
 512                         {
 513                                 .ifnum = 3,
 514                                 .type = QUIRK_AUDIO_EDIROL_UA700
 515                         },
 516                         {
 517                                 .ifnum = -1
 518                         }
 519                 }
 520         }
 521 },
 522 {
 523         USB_DEVICE(0x0582, 0x002d),
 524         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 525                 .vendor_name = "Roland",
 526                 .product_name = "XV-2020",
 527                 .ifnum = 0,
 528                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 529                 .data = & (const snd_usb_midi_endpoint_info_t) {
 530                         .out_cables = 0x0001,
 531                         .in_cables  = 0x0001
 532                 }
 533         }
 534 },
 535 {
 536         USB_DEVICE(0x0582, 0x002f),
 537         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 538                 .vendor_name = "Roland",
 539                 .product_name = "VariOS",
 540                 .ifnum = 0,
 541                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 542                 .data = & (const snd_usb_midi_endpoint_info_t) {
 543                         .out_cables = 0x0007,
 544                         .in_cables  = 0x0007
 545                 }
 546         }
 547 },
 548 {
 549         USB_DEVICE(0x0582, 0x0033),
 550         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 551                 .vendor_name = "EDIROL",
 552                 .product_name = "PCR",
 553                 .ifnum = 0,
 554                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 555                 .data = & (const snd_usb_midi_endpoint_info_t) {
 556                         .out_cables = 0x0003,
 557                         .in_cables  = 0x0007
 558                 }
 559         }
 560 },
 561 {
 562         USB_DEVICE(0x0582, 0x0037),
 563         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 564                 .vendor_name = "Roland",
 565                 .product_name = "Digital Piano",
 566                 .ifnum = 0,
 567                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 568                 .data = & (const snd_usb_midi_endpoint_info_t) {
 569                         .out_cables = 0x0001,
 570                         .in_cables  = 0x0001
 571                 }
 572         }
 573 },
 574 {
 575         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
 576         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 577                 .vendor_name = "BOSS",
 578                 .product_name = "GS-10",
 579                 .ifnum = 3,
 580                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 581                 .data = & (const snd_usb_midi_endpoint_info_t) {
 582                         .out_cables = 0x0003,
 583                         .in_cables  = 0x0003
 584                 }
 585         }
 586 },
 587 {
 588         USB_DEVICE(0x0582, 0x0040),
 589         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 590                 .vendor_name = "Roland",
 591                 .product_name = "GI-20",
 592                 .ifnum = 0,
 593                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 594                 .data = & (const snd_usb_midi_endpoint_info_t) {
 595                         .out_cables = 0x0001,
 596                         .in_cables  = 0x0001
 597                 }
 598         }
 599 },
 600 {
 601         USB_DEVICE(0x0582, 0x0044),
 602         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 603                 .vendor_name = "Roland",
 604                 .product_name = "UA-1000",
 605                 .ifnum = QUIRK_ANY_INTERFACE,
 606                 .type = QUIRK_COMPOSITE,
 607                 .data = (const snd_usb_audio_quirk_t[]) {
 608                         {
 609                                 .ifnum = 1,
 610                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 611                                 .data = & (const struct audioformat) {
 612                                         .format = SNDRV_PCM_FORMAT_S24,
 613                                         .channels = 12,
 614                                         .iface = 1,
 615                                         .altsetting = 1,
 616                                         .altset_idx = 1,
 617                                         .attributes = 0,
 618                                         .endpoint = 0x81,
 619                                         .ep_attr = 0x01,
 620                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 621                                         .rate_min = 48000,
 622                                         .rate_max = 48000,
 623                                 }
 624                         },
 625                         {
 626                                 .ifnum = 2,
 627                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 628                                 .data = & (const struct audioformat) {
 629                                         .format = SNDRV_PCM_FORMAT_S24,
 630                                         .channels = 10,
 631                                         .iface = 2,
 632                                         .altsetting = 1,
 633                                         .altset_idx = 1,
 634                                         .attributes = 0,
 635                                         .endpoint = 0x02,
 636                                         .ep_attr = 0x01,
 637                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 638                                         .rate_min = 48000,
 639                                         .rate_max = 48000,
 640                                 }
 641                         },
 642                         {
 643                                 .ifnum = 3,
 644                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 645                                 .data = & (const snd_usb_midi_endpoint_info_t) {
 646                                         .out_cables = 0x0003,
 647                                         .in_cables  = 0x0003
 648                                 }
 649                         },
 650                         {
 651                                 .ifnum = -1
 652                         }
 653                 }
 654         }
 655 },
 656 {
 657         USB_DEVICE(0x0582, 0x0048),
 658         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 659                 .vendor_name = "EDIROL",
 660                 .product_name = "UR-80",
 661                 .ifnum = 0,
 662                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 663                 .data = & (const snd_usb_midi_endpoint_info_t) {
 664                         .out_cables = 0x0003,
 665                         .in_cables  = 0x0007
 666                 }
 667         }
 668 },
 669 {
 670         USB_DEVICE(0x0582, 0x004d),
 671         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 672                 .vendor_name = "EDIROL",
 673                 .product_name = "PCR-A",
 674                 .ifnum = 0,
 675                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 676                 .data = & (const snd_usb_midi_endpoint_info_t) {
 677                         .out_cables = 0x0003,
 678                         .in_cables  = 0x0007
 679                 }
 680         }
 681 },
 682 {
 683         USB_DEVICE(0x0582, 0x0065),
 684         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 685                 .vendor_name = "EDIROL",
 686                 .product_name = "PCR-1",
 687                 .ifnum = 0,
 688                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 689                 .data = & (const snd_usb_midi_endpoint_info_t) {
 690                         .out_cables = 0x0001,
 691                         .in_cables  = 0x0003
 692                 }
 693         }
 694 },
 695 {
 696         /*
 697          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
 698          * is standard compliant, but has only 16-bit PCM.
 699          */
 700         USB_DEVICE(0x0582, 0x0050),
 701         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 702                 .vendor_name = "EDIROL",
 703                 .product_name = "UA-3FX",
 704                 .ifnum = QUIRK_ANY_INTERFACE,
 705                 .type = QUIRK_COMPOSITE,
 706                 .data = (const snd_usb_audio_quirk_t[]) {
 707                         {
 708                                 .ifnum = 1,
 709                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 710                         },
 711                         {
 712                                 .ifnum = 2,
 713                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 714                         },
 715                         {
 716                                 .ifnum = -1
 717                         }
 718                 }
 719         }
 720 },
 721 {
 722         USB_DEVICE(0x0582, 0x0052),
 723         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 724                 .vendor_name = "EDIROL",
 725                 .product_name = "UM-1SX",
 726                 .ifnum = 0,
 727                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 728         }
 729 },
 730
 731 /* Midiman/M-Audio devices */
 732 {
 733         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
 734         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 735                 .vendor_name = "M-Audio",
 736                 .product_name = "MidiSport 2x2",
 737                 .ifnum = QUIRK_ANY_INTERFACE,
 738                 .type = QUIRK_MIDI_MIDIMAN,
 739                 .data = & (const snd_usb_midi_endpoint_info_t) {
 740                         .out_cables = 0x0003,
 741                         .in_cables  = 0x0003
 742                 }
 743         }
 744 },
 745 {
 746         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
 747         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 748                 .vendor_name = "M-Audio",
 749                 .product_name = "MidiSport 1x1",
 750                 .ifnum = QUIRK_ANY_INTERFACE,
 751                 .type = QUIRK_MIDI_MIDIMAN,
 752                 .data = & (const snd_usb_midi_endpoint_info_t) {
 753                         .out_cables = 0x0001,
 754                         .in_cables  = 0x0001
 755                 }
 756         }
 757 },
 758 {
 759         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
 760         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 761                 .vendor_name = "M-Audio",
 762                 .product_name = "Keystation",
 763                 .ifnum = QUIRK_ANY_INTERFACE,
 764                 .type = QUIRK_MIDI_MIDIMAN,
 765                 .data = & (const snd_usb_midi_endpoint_info_t) {
 766                         .out_cables = 0x0001,
 767                         .in_cables  = 0x0001
 768                 }
 769         }
 770 },
 771 {
 772         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
 773         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 774                 .vendor_name = "M-Audio",
 775                 .product_name = "MidiSport 4x4",
 776                 .ifnum = QUIRK_ANY_INTERFACE,
 777                 .type = QUIRK_MIDI_MIDIMAN,
 778                 .data = & (const snd_usb_midi_endpoint_info_t) {
 779                         .out_cables = 0x000f,
 780                         .in_cables  = 0x000f
 781                 }
 782         }
 783 },
 784 {
 785         /*
 786          * For hardware revision 1.05; in the later revisions (1.10 and
 787          * 1.21), 0x1031 is the ID for the device without firmware.
 788          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
 789          */
 790         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
 791         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 792                 .vendor_name = "M-Audio",
 793                 .product_name = "MidiSport 8x8",
 794                 .ifnum = QUIRK_ANY_INTERFACE,
 795                 .type = QUIRK_MIDI_MIDIMAN,
 796                 .data = & (const snd_usb_midi_endpoint_info_t) {
 797                         .out_cables = 0x01ff,
 798                         .in_cables  = 0x01ff
 799                 }
 800         }
 801 },
 802 {
 803         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
 804         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 805                 .vendor_name = "M-Audio",
 806                 .product_name = "MidiSport 8x8",
 807                 .ifnum = QUIRK_ANY_INTERFACE,
 808                 .type = QUIRK_MIDI_MIDIMAN,
 809                 .data = & (const snd_usb_midi_endpoint_info_t) {
 810                         .out_cables = 0x01ff,
 811                         .in_cables  = 0x01ff
 812                 }
 813         }
 814 },
 815 {
 816         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
 817         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 818                 .vendor_name = "M-Audio",
 819                 .product_name = "MidiSport 2x4",
 820                 .ifnum = QUIRK_ANY_INTERFACE,
 821                 .type = QUIRK_MIDI_MIDIMAN,
 822                 .data = & (const snd_usb_midi_endpoint_info_t) {
 823                         .out_cables = 0x000f,
 824                         .in_cables  = 0x0003
 825                 }
 826         }
 827 },
 828 {
 829         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
 830         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 831                 .vendor_name = "M-Audio",
 832                 .product_name = "Quattro",
 833                 .ifnum = 9,
 834                 .type = QUIRK_MIDI_MIDIMAN,
 835                 .data = & (const snd_usb_midi_endpoint_info_t) {
 836                         .out_cables = 0x0001,
 837                         .in_cables  = 0x0001
 838                 }
 839         }
 840 },
 841 {
 842         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
 843         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 844                 .vendor_name = "M-Audio",
 845                 .product_name = "AudioPhile",
 846                 .ifnum = 6,
 847                 .type = QUIRK_MIDI_MIDIMAN,
 848                 .data = & (const snd_usb_midi_endpoint_info_t) {
 849                         .out_cables = 0x0001,
 850                         .in_cables  = 0x0001
 851                 }
 852         }
 853 },
 854 {
 855         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
 856         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 857                 .vendor_name = "M-Audio",
 858                 .product_name = "Ozone",
 859                 .ifnum = 3,
 860                 .type = QUIRK_MIDI_MIDIMAN,
 861                 .data = & (const snd_usb_midi_endpoint_info_t) {
 862                         .out_cables = 0x0001,
 863                         .in_cables  = 0x0001
 864                 }
 865         }
 866 },
 867 {
 868         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
 869         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 870                 .vendor_name = "M-Audio",
 871                 .product_name = "OmniStudio",
 872                 .ifnum = 9,
 873                 .type = QUIRK_MIDI_MIDIMAN,
 874                 .data = & (const snd_usb_midi_endpoint_info_t) {
 875                         .out_cables = 0x0001,
 876                         .in_cables  = 0x0001
 877                 }
 878         }
 879 },
 880
 881 /* Mark of the Unicorn devices */
 882 {
 883         /* thanks to Woodley Packard <sweaglesw@thibs.menloschool.org> */
 884         USB_DEVICE(0x07fd, 0x0001),
 885         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 886                 .vendor_name = "MOTU",
 887                 .product_name = "Fastlane",
 888                 .ifnum = 1,
 889                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 890                 .data = & (const snd_usb_midi_endpoint_info_t) {
 891                         .out_cables = 0x0003,
 892                         .in_cables  = 0x0003
 893                 }
 894         }
 895 },
 896
 897 {
 898         /* Creative Sound Blaster MP3+ */
 899         USB_DEVICE(0x041e, 0x3010),
 900         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 901                 .vendor_name = "Creative Labs",
 902                 .product_name = "Sound Blaster MP3+",
 903                 .ifnum = QUIRK_NO_INTERFACE
 904         }
 905
 906 },
 907
 908 {
 909         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
 910         .driver_info = (unsigned long) & (const snd_usb_audio_quirk_t) {
 911                 .vendor_name = "Terratec",
 912                 .product_name = "PHASE 26",
 913                 .ifnum = 3,
 914                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 915         }
 916 },
 917
 918 #undef USB_DEVICE_VENDOR_SPEC