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 struct snd_usb_audio_quirk) { \
  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 struct snd_usb_audio_quirk) { \
  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(0x100c, "UC-MX"),
  76 YAMAHA_DEVICE(0x100d, "UC-KX"),
  77 YAMAHA_DEVICE(0x100e, "S08"),
  78 YAMAHA_DEVICE(0x100f, "CLP-150"),
  79 YAMAHA_DEVICE(0x1010, "CLP-170"),
  80 YAMAHA_DEVICE(0x1011, "P-250"),
  81 YAMAHA_DEVICE(0x1012, "TYROS"),
  82 YAMAHA_DEVICE(0x1013, "PF-500"),
  83 YAMAHA_DEVICE(0x1014, "S90"),
  84 YAMAHA_DEVICE(0x1015, "MOTIF-R"),
  85 YAMAHA_DEVICE(0x1016, "MDP-5"),
  86 YAMAHA_DEVICE(0x1017, "CVP-204"),
  87 YAMAHA_DEVICE(0x1018, "CVP-206"),
  88 YAMAHA_DEVICE(0x1019, "CVP-208"),
  89 YAMAHA_DEVICE(0x101a, "CVP-210"),
  90 YAMAHA_DEVICE(0x101b, "PSR-1100"),
  91 YAMAHA_DEVICE(0x101c, "PSR-2100"),
  92 YAMAHA_DEVICE(0x101d, "CLP-175"),
  93 YAMAHA_DEVICE(0x101e, "PSR-K1"),
  94 YAMAHA_DEVICE(0x101f, "EZ-J24"),
  95 YAMAHA_DEVICE(0x1020, "EZ-250i"),
  96 YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
  97 YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
  98 YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
  99 YAMAHA_DEVICE(0x1024, "CVP-301"),
 100 YAMAHA_DEVICE(0x1025, "CVP-303"),
 101 YAMAHA_DEVICE(0x1026, "CVP-305"),
 102 YAMAHA_DEVICE(0x1027, "CVP-307"),
 103 YAMAHA_DEVICE(0x1028, "CVP-309"),
 104 YAMAHA_DEVICE(0x1029, "CVP-309GP"),
 105 YAMAHA_DEVICE(0x102a, "PSR-1500"),
 106 YAMAHA_DEVICE(0x102b, "PSR-3000"),
 107 YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
 108 YAMAHA_DEVICE(0x1030, "PSR-295/293"),
 109 YAMAHA_DEVICE(0x1031, "DGX-205/203"),
 110 YAMAHA_DEVICE(0x1032, "DGX-305"),
 111 YAMAHA_DEVICE(0x1033, "DGX-505"),
 112 YAMAHA_DEVICE(0x1034, NULL),
 113 YAMAHA_DEVICE(0x1035, NULL),
 114 YAMAHA_DEVICE(0x1036, NULL),
 115 YAMAHA_DEVICE(0x1037, NULL),
 116 YAMAHA_DEVICE(0x1038, NULL),
 117 YAMAHA_DEVICE(0x1039, NULL),
 118 YAMAHA_DEVICE(0x103a, NULL),
 119 YAMAHA_DEVICE(0x103b, NULL),
 120 YAMAHA_DEVICE(0x103c, NULL),
 121 YAMAHA_DEVICE(0x103d, NULL),
 122 YAMAHA_DEVICE(0x103e, NULL),
 123 YAMAHA_DEVICE(0x103f, NULL),
 124 YAMAHA_DEVICE(0x1040, NULL),
 125 YAMAHA_DEVICE(0x1041, NULL),
 126 YAMAHA_DEVICE(0x1042, NULL),
 127 YAMAHA_DEVICE(0x1043, NULL),
 128 YAMAHA_DEVICE(0x1044, NULL),
 129 YAMAHA_DEVICE(0x1045, NULL),
 130 YAMAHA_DEVICE(0x2000, "DGP-7"),
 131 YAMAHA_DEVICE(0x2001, "DGP-5"),
 132 YAMAHA_DEVICE(0x2002, NULL),
 133 YAMAHA_DEVICE(0x5000, "CS1D"),
 134 YAMAHA_DEVICE(0x5001, "DSP1D"),
 135 YAMAHA_DEVICE(0x5002, "DME32"),
 136 YAMAHA_DEVICE(0x5003, "DM2000"),
 137 YAMAHA_DEVICE(0x5004, "02R96"),
 138 YAMAHA_DEVICE(0x5005, "ACU16-C"),
 139 YAMAHA_DEVICE(0x5006, "NHB32-C"),
 140 YAMAHA_DEVICE(0x5007, "DM1000"),
 141 YAMAHA_DEVICE(0x5008, "01V96"),
 142 YAMAHA_DEVICE(0x5009, "SPX2000"),
 143 YAMAHA_DEVICE(0x500a, "PM5D"),
 144 YAMAHA_DEVICE(0x500b, "DME64N"),
 145 YAMAHA_DEVICE(0x500c, "DME24N"),
 146 YAMAHA_DEVICE(0x500d, NULL),
 147 YAMAHA_DEVICE(0x500e, NULL),
 148 YAMAHA_DEVICE(0x500f, NULL),
 149 YAMAHA_DEVICE(0x7000, "DTX"),
 150 YAMAHA_DEVICE(0x7010, "UB99"),
 151 #undef YAMAHA_DEVICE
 152 #undef YAMAHA_INTERFACE
 153
 154 /*
 155  * Roland/RolandED/Edirol/BOSS devices
 156  */
 157 {
 158         USB_DEVICE(0x0582, 0x0000),
 159         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 160                 .vendor_name = "Roland",
 161                 .product_name = "UA-100",
 162                 .ifnum = QUIRK_ANY_INTERFACE,
 163                 .type = QUIRK_COMPOSITE,
 164                 .data = (const struct snd_usb_audio_quirk[]) {
 165                         {
 166                                 .ifnum = 0,
 167                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 168                                 .data = & (const struct audioformat) {
 169                                         .format = SNDRV_PCM_FORMAT_S16_LE,
 170                                         .channels = 4,
 171                                         .iface = 0,
 172                                         .altsetting = 1,
 173                                         .altset_idx = 1,
 174                                         .attributes = 0,
 175                                         .endpoint = 0x01,
 176                                         .ep_attr = 0x09,
 177                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 178                                         .rate_min = 44100,
 179                                         .rate_max = 44100,
 180                                 }
 181                         },
 182                         {
 183                                 .ifnum = 1,
 184                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 185                                 .data = & (const struct audioformat) {
 186                                         .format = SNDRV_PCM_FORMAT_S16_LE,
 187                                         .channels = 2,
 188                                         .iface = 1,
 189                                         .altsetting = 1,
 190                                         .altset_idx = 1,
 191                                         .attributes = EP_CS_ATTR_FILL_MAX,
 192                                         .endpoint = 0x81,
 193                                         .ep_attr = 0x05,
 194                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 195                                         .rate_min = 44100,
 196                                         .rate_max = 44100,
 197                                 }
 198                         },
 199                         {
 200                                 .ifnum = 2,
 201                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 202                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 203                                         .out_cables = 0x0007,
 204                                         .in_cables  = 0x0007
 205                                 }
 206                         },
 207                         {
 208                                 .ifnum = -1
 209                         }
 210                 }
 211         }
 212 },
 213 {
 214         USB_DEVICE(0x0582, 0x0002),
 215         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 216                 .vendor_name = "EDIROL",
 217                 .product_name = "UM-4",
 218                 .ifnum = QUIRK_ANY_INTERFACE,
 219                 .type = QUIRK_COMPOSITE,
 220                 .data = (const struct snd_usb_audio_quirk[]) {
 221                         {
 222                                 .ifnum = 0,
 223                                 .type = QUIRK_IGNORE_INTERFACE
 224                         },
 225                         {
 226                                 .ifnum = 1,
 227                                 .type = QUIRK_IGNORE_INTERFACE
 228                         },
 229                         {
 230                                 .ifnum = 2,
 231                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 232                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 233                                         .out_cables = 0x000f,
 234                                         .in_cables  = 0x000f
 235                                 }
 236                         },
 237                         {
 238                                 .ifnum = -1
 239                         }
 240                 }
 241         }
 242 },
 243 {
 244         USB_DEVICE(0x0582, 0x0003),
 245         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 246                 .vendor_name = "Roland",
 247                 .product_name = "SC-8850",
 248                 .ifnum = QUIRK_ANY_INTERFACE,
 249                 .type = QUIRK_COMPOSITE,
 250                 .data = (const struct snd_usb_audio_quirk[]) {
 251                         {
 252                                 .ifnum = 0,
 253                                 .type = QUIRK_IGNORE_INTERFACE
 254                         },
 255                         {
 256                                 .ifnum = 1,
 257                                 .type = QUIRK_IGNORE_INTERFACE
 258                         },
 259                         {
 260                                 .ifnum = 2,
 261                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 262                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 263                                         .out_cables = 0x003f,
 264                                         .in_cables  = 0x003f
 265                                 }
 266                         },
 267                         {
 268                                 .ifnum = -1
 269                         }
 270                 }
 271         }
 272 },
 273 {
 274         USB_DEVICE(0x0582, 0x0004),
 275         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 276                 .vendor_name = "Roland",
 277                 .product_name = "U-8",
 278                 .ifnum = QUIRK_ANY_INTERFACE,
 279                 .type = QUIRK_COMPOSITE,
 280                 .data = (const struct snd_usb_audio_quirk[]) {
 281                         {
 282                                 .ifnum = 0,
 283                                 .type = QUIRK_IGNORE_INTERFACE
 284                         },
 285                         {
 286                                 .ifnum = 1,
 287                                 .type = QUIRK_IGNORE_INTERFACE
 288                         },
 289                         {
 290                                 .ifnum = 2,
 291                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 292                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 293                                         .out_cables = 0x0005,
 294                                         .in_cables  = 0x0005
 295                                 }
 296                         },
 297                         {
 298                                 .ifnum = -1
 299                         }
 300                 }
 301         }
 302 },
 303 {
 304         /* Has ID 0x0099 when not in "Advanced Driver" mode.
 305          * The UM-2EX has only one input, but we cannot detect this. */
 306         USB_DEVICE(0x0582, 0x0005),
 307         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 308                 .vendor_name = "EDIROL",
 309                 .product_name = "UM-2",
 310                 .ifnum = QUIRK_ANY_INTERFACE,
 311                 .type = QUIRK_COMPOSITE,
 312                 .data = (const struct snd_usb_audio_quirk[]) {
 313                         {
 314                                 .ifnum = 0,
 315                                 .type = QUIRK_IGNORE_INTERFACE
 316                         },
 317                         {
 318                                 .ifnum = 1,
 319                                 .type = QUIRK_IGNORE_INTERFACE
 320                         },
 321                         {
 322                                 .ifnum = 2,
 323                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 324                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 325                                         .out_cables = 0x0003,
 326                                         .in_cables  = 0x0003
 327                                 }
 328                         },
 329                         {
 330                                 .ifnum = -1
 331                         }
 332                 }
 333         }
 334 },
 335 {
 336         USB_DEVICE(0x0582, 0x0007),
 337         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 338                 .vendor_name = "Roland",
 339                 .product_name = "SC-8820",
 340                 .ifnum = QUIRK_ANY_INTERFACE,
 341                 .type = QUIRK_COMPOSITE,
 342                 .data = (const struct snd_usb_audio_quirk[]) {
 343                         {
 344                                 .ifnum = 0,
 345                                 .type = QUIRK_IGNORE_INTERFACE
 346                         },
 347                         {
 348                                 .ifnum = 1,
 349                                 .type = QUIRK_IGNORE_INTERFACE
 350                         },
 351                         {
 352                                 .ifnum = 2,
 353                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 354                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 355                                         .out_cables = 0x0013,
 356                                         .in_cables  = 0x0013
 357                                 }
 358                         },
 359                         {
 360                                 .ifnum = -1
 361                         }
 362                 }
 363         }
 364 },
 365 {
 366         USB_DEVICE(0x0582, 0x0008),
 367         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 368                 .vendor_name = "Roland",
 369                 .product_name = "PC-300",
 370                 .ifnum = QUIRK_ANY_INTERFACE,
 371                 .type = QUIRK_COMPOSITE,
 372                 .data = (const struct snd_usb_audio_quirk[]) {
 373                         {
 374                                 .ifnum = 0,
 375                                 .type = QUIRK_IGNORE_INTERFACE
 376                         },
 377                         {
 378                                 .ifnum = 1,
 379                                 .type = QUIRK_IGNORE_INTERFACE
 380                         },
 381                         {
 382                                 .ifnum = 2,
 383                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 384                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 385                                         .out_cables = 0x0001,
 386                                         .in_cables  = 0x0001
 387                                 }
 388                         },
 389                         {
 390                                 .ifnum = -1
 391                         }
 392                 }
 393         }
 394 },
 395 {
 396         /* has ID 0x009d when not in "Advanced Driver" mode */
 397         USB_DEVICE(0x0582, 0x0009),
 398         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 399                 .vendor_name = "EDIROL",
 400                 .product_name = "UM-1",
 401                 .ifnum = QUIRK_ANY_INTERFACE,
 402                 .type = QUIRK_COMPOSITE,
 403                 .data = (const struct snd_usb_audio_quirk[]) {
 404                         {
 405                                 .ifnum = 0,
 406                                 .type = QUIRK_IGNORE_INTERFACE
 407                         },
 408                         {
 409                                 .ifnum = 1,
 410                                 .type = QUIRK_IGNORE_INTERFACE
 411                         },
 412                         {
 413                                 .ifnum = 2,
 414                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 415                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 416                                         .out_cables = 0x0001,
 417                                         .in_cables  = 0x0001
 418                                 }
 419                         },
 420                         {
 421                                 .ifnum = -1
 422                         }
 423                 }
 424         }
 425 },
 426 {
 427         USB_DEVICE(0x0582, 0x000b),
 428         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 429                 .vendor_name = "Roland",
 430                 .product_name = "SK-500",
 431                 .ifnum = QUIRK_ANY_INTERFACE,
 432                 .type = QUIRK_COMPOSITE,
 433                 .data = (const struct snd_usb_audio_quirk[]) {
 434                         {
 435                                 .ifnum = 0,
 436                                 .type = QUIRK_IGNORE_INTERFACE
 437                         },
 438                         {
 439                                 .ifnum = 1,
 440                                 .type = QUIRK_IGNORE_INTERFACE
 441                         },
 442                         {
 443                                 .ifnum = 2,
 444                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 445                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 446                                         .out_cables = 0x0013,
 447                                         .in_cables  = 0x0013
 448                                 }
 449                         },
 450                         {
 451                                 .ifnum = -1
 452                         }
 453                 }
 454         }
 455 },
 456 {
 457         /* thanks to Emiliano Grilli <emillo@libero.it>
 458          * for helping researching this data */
 459         USB_DEVICE(0x0582, 0x000c),
 460         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 461                 .vendor_name = "Roland",
 462                 .product_name = "SC-D70",
 463                 .ifnum = QUIRK_ANY_INTERFACE,
 464                 .type = QUIRK_COMPOSITE,
 465                 .data = (const struct snd_usb_audio_quirk[]) {
 466                         {
 467                                 .ifnum = 0,
 468                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 469                                 .data = & (const struct audioformat) {
 470                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
 471                                         .channels = 2,
 472                                         .iface = 0,
 473                                         .altsetting = 1,
 474                                         .altset_idx = 1,
 475                                         .attributes = 0,
 476                                         .endpoint = 0x01,
 477                                         .ep_attr = 0x01,
 478                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 479                                         .rate_min = 44100,
 480                                         .rate_max = 44100,
 481                                 }
 482                         },
 483                         {
 484                                 .ifnum = 1,
 485                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 486                                 .data = & (const struct audioformat) {
 487                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
 488                                         .channels = 2,
 489                                         .iface = 1,
 490                                         .altsetting = 1,
 491                                         .altset_idx = 1,
 492                                         .attributes = 0,
 493                                         .endpoint = 0x81,
 494                                         .ep_attr = 0x01,
 495                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 496                                         .rate_min = 44100,
 497                                         .rate_max = 44100,
 498                                 }
 499                         },
 500                         {
 501                                 .ifnum = 2,
 502                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 503                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 504                                         .out_cables = 0x0007,
 505                                         .in_cables  = 0x0007
 506                                 }
 507                         },
 508                         {
 509                                 .ifnum = -1
 510                         }
 511                 }
 512         }
 513 },
 514 {       /*
 515          * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
 516          * If the advanced mode switch at the back of the unit is off, the
 517          * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
 518          * but offers only 16-bit PCM.
 519          * In advanced mode, the UA-5 will output S24_3LE samples (two
 520          * channels) at the rate indicated on the front switch, including
 521          * the 96kHz sample rate.
 522          */
 523         USB_DEVICE(0x0582, 0x0010),
 524         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 525                 .vendor_name = "EDIROL",
 526                 .product_name = "UA-5",
 527                 .ifnum = QUIRK_ANY_INTERFACE,
 528                 .type = QUIRK_COMPOSITE,
 529                 .data = (const struct snd_usb_audio_quirk[]) {
 530                         {
 531                                 .ifnum = 1,
 532                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 533                         },
 534                         {
 535                                 .ifnum = 2,
 536                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 537                         },
 538                         {
 539                                 .ifnum = -1
 540                         }
 541                 }
 542         }
 543 },
 544 {
 545         /* has ID 0x0013 when not in "Advanced Driver" mode */
 546         USB_DEVICE(0x0582, 0x0012),
 547         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 548                 .vendor_name = "Roland",
 549                 .product_name = "XV-5050",
 550                 .ifnum = 0,
 551                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 552                 .data = & (const struct snd_usb_midi_endpoint_info) {
 553                         .out_cables = 0x0001,
 554                         .in_cables  = 0x0001
 555                 }
 556         }
 557 },
 558 {
 559         /* has ID 0x0015 when not in "Advanced Driver" mode */
 560         USB_DEVICE(0x0582, 0x0014),
 561         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 562                 .vendor_name = "EDIROL",
 563                 .product_name = "UM-880",
 564                 .ifnum = 0,
 565                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 566                 .data = & (const struct snd_usb_midi_endpoint_info) {
 567                         .out_cables = 0x01ff,
 568                         .in_cables  = 0x01ff
 569                 }
 570         }
 571 },
 572 {
 573         /* has ID 0x0017 when not in "Advanced Driver" mode */
 574         USB_DEVICE(0x0582, 0x0016),
 575         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 576                 .vendor_name = "EDIROL",
 577                 .product_name = "SD-90",
 578                 .ifnum = QUIRK_ANY_INTERFACE,
 579                 .type = QUIRK_COMPOSITE,
 580                 .data = (const struct snd_usb_audio_quirk[]) {
 581                         {
 582                                 .ifnum = 0,
 583                                 .type = QUIRK_IGNORE_INTERFACE
 584                         },
 585                         {
 586                                 .ifnum = 1,
 587                                 .type = QUIRK_IGNORE_INTERFACE
 588                         },
 589                         {
 590                                 .ifnum = 2,
 591                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 592                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 593                                         .out_cables = 0x000f,
 594                                         .in_cables  = 0x000f
 595                                 }
 596                         },
 597                         {
 598                                 .ifnum = -1
 599                         }
 600                 }
 601         }
 602 },
 603 {
 604         /* has ID 0x001c when not in "Advanced Driver" mode */
 605         USB_DEVICE(0x0582, 0x001b),
 606         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 607                 .vendor_name = "Roland",
 608                 .product_name = "MMP-2",
 609                 .ifnum = QUIRK_ANY_INTERFACE,
 610                 .type = QUIRK_COMPOSITE,
 611                 .data = (const struct snd_usb_audio_quirk[]) {
 612                         {
 613                                 .ifnum = 0,
 614                                 .type = QUIRK_IGNORE_INTERFACE
 615                         },
 616                         {
 617                                 .ifnum = 1,
 618                                 .type = QUIRK_IGNORE_INTERFACE
 619                         },
 620                         {
 621                                 .ifnum = 2,
 622                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 623                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 624                                         .out_cables = 0x0001,
 625                                         .in_cables  = 0x0001
 626                                 }
 627                         },
 628                         {
 629                                 .ifnum = -1
 630                         }
 631                 }
 632         }
 633 },
 634 {
 635         /* has ID 0x001e when not in "Advanced Driver" mode */
 636         USB_DEVICE(0x0582, 0x001d),
 637         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 638                 .vendor_name = "Roland",
 639                 .product_name = "V-SYNTH",
 640                 .ifnum = 0,
 641                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 642                 .data = & (const struct snd_usb_midi_endpoint_info) {
 643                         .out_cables = 0x0001,
 644                         .in_cables  = 0x0001
 645                 }
 646         }
 647 },
 648 {
 649         /* has ID 0x0024 when not in "Advanced Driver" mode */
 650         USB_DEVICE(0x0582, 0x0023),
 651         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 652                 .vendor_name = "EDIROL",
 653                 .product_name = "UM-550",
 654                 .ifnum = 0,
 655                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 656                 .data = & (const struct snd_usb_midi_endpoint_info) {
 657                         .out_cables = 0x003f,
 658                         .in_cables  = 0x003f
 659                 }
 660         }
 661 },
 662 {
 663         /*
 664          * This quirk is for the "Advanced Driver" mode. If off, the UA-20
 665          * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
 666          * and no MIDI.
 667          */
 668         USB_DEVICE(0x0582, 0x0025),
 669         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 670                 .vendor_name = "EDIROL",
 671                 .product_name = "UA-20",
 672                 .ifnum = QUIRK_ANY_INTERFACE,
 673                 .type = QUIRK_COMPOSITE,
 674                 .data = (const struct snd_usb_audio_quirk[]) {
 675                         {
 676                                 .ifnum = 0,
 677                                 .type = QUIRK_IGNORE_INTERFACE
 678                         },
 679                         {
 680                                 .ifnum = 1,
 681                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 682                                 .data = & (const struct audioformat) {
 683                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
 684                                         .channels = 2,
 685                                         .iface = 1,
 686                                         .altsetting = 1,
 687                                         .altset_idx = 1,
 688                                         .attributes = 0,
 689                                         .endpoint = 0x01,
 690                                         .ep_attr = 0x01,
 691                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 692                                         .rate_min = 44100,
 693                                         .rate_max = 44100,
 694                                 }
 695                         },
 696                         {
 697                                 .ifnum = 2,
 698                                 .type = QUIRK_AUDIO_FIXED_ENDPOINT,
 699                                 .data = & (const struct audioformat) {
 700                                         .format = SNDRV_PCM_FORMAT_S24_3LE,
 701                                         .channels = 2,
 702                                         .iface = 2,
 703                                         .altsetting = 1,
 704                                         .altset_idx = 1,
 705                                         .attributes = 0,
 706                                         .endpoint = 0x82,
 707                                         .ep_attr = 0x01,
 708                                         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 709                                         .rate_min = 44100,
 710                                         .rate_max = 44100,
 711                                 }
 712                         },
 713                         {
 714                                 .ifnum = 3,
 715                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 716                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 717                                         .out_cables = 0x0001,
 718                                         .in_cables  = 0x0001
 719                                 }
 720                         },
 721                         {
 722                                 .ifnum = -1
 723                         }
 724                 }
 725         }
 726 },
 727 {
 728         /* has ID 0x0028 when not in "Advanced Driver" mode */
 729         USB_DEVICE(0x0582, 0x0027),
 730         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 731                 .vendor_name = "EDIROL",
 732                 .product_name = "SD-20",
 733                 .ifnum = 0,
 734                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 735                 .data = & (const struct snd_usb_midi_endpoint_info) {
 736                         .out_cables = 0x0003,
 737                         .in_cables  = 0x0007
 738                 }
 739         }
 740 },
 741 {
 742         /* has ID 0x002a when not in "Advanced Driver" mode */
 743         USB_DEVICE(0x0582, 0x0029),
 744         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 745                 .vendor_name = "EDIROL",
 746                 .product_name = "SD-80",
 747                 .ifnum = 0,
 748                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 749                 .data = & (const struct snd_usb_midi_endpoint_info) {
 750                         .out_cables = 0x000f,
 751                         .in_cables  = 0x000f
 752                 }
 753         }
 754 },
 755 {       /*
 756          * This quirk is for the "Advanced" modes of the Edirol UA-700.
 757          * If the sample format switch is not in an advanced setting, the
 758          * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
 759          * but offers only 16-bit PCM and no MIDI.
 760          */
 761         USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
 762         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 763                 .vendor_name = "EDIROL",
 764                 .product_name = "UA-700",
 765                 .ifnum = QUIRK_ANY_INTERFACE,
 766                 .type = QUIRK_COMPOSITE,
 767                 .data = (const struct snd_usb_audio_quirk[]) {
 768                         {
 769                                 .ifnum = 1,
 770                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 771                         },
 772                         {
 773                                 .ifnum = 2,
 774                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 775                         },
 776                         {
 777                                 .ifnum = 3,
 778                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
 779                         },
 780                         {
 781                                 .ifnum = -1
 782                         }
 783                 }
 784         }
 785 },
 786 {
 787         /* has ID 0x002e when not in "Advanced Driver" mode */
 788         USB_DEVICE(0x0582, 0x002d),
 789         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 790                 .vendor_name = "Roland",
 791                 .product_name = "XV-2020",
 792                 .ifnum = 0,
 793                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 794                 .data = & (const struct snd_usb_midi_endpoint_info) {
 795                         .out_cables = 0x0001,
 796                         .in_cables  = 0x0001
 797                 }
 798         }
 799 },
 800 {
 801         /* has ID 0x0030 when not in "Advanced Driver" mode */
 802         USB_DEVICE(0x0582, 0x002f),
 803         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 804                 .vendor_name = "Roland",
 805                 .product_name = "VariOS",
 806                 .ifnum = 0,
 807                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 808                 .data = & (const struct snd_usb_midi_endpoint_info) {
 809                         .out_cables = 0x0007,
 810                         .in_cables  = 0x0007
 811                 }
 812         }
 813 },
 814 {
 815         /* has ID 0x0034 when not in "Advanced Driver" mode */
 816         USB_DEVICE(0x0582, 0x0033),
 817         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 818                 .vendor_name = "EDIROL",
 819                 .product_name = "PCR",
 820                 .ifnum = 0,
 821                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 822                 .data = & (const struct snd_usb_midi_endpoint_info) {
 823                         .out_cables = 0x0003,
 824                         .in_cables  = 0x0007
 825                 }
 826         }
 827 },
 828         /* TODO: add Roland M-1000 support */
 829 {
 830         /*
 831          * Has ID 0x0038 when not in "Advanced Driver" mode;
 832          * later revisions use IDs 0x0054 and 0x00a2.
 833          */
 834         USB_DEVICE(0x0582, 0x0037),
 835         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 836                 .vendor_name = "Roland",
 837                 .product_name = "Digital Piano",
 838                 .ifnum = 0,
 839                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 840                 .data = & (const struct snd_usb_midi_endpoint_info) {
 841                         .out_cables = 0x0001,
 842                         .in_cables  = 0x0001
 843                 }
 844         }
 845 },
 846 {
 847         /*
 848          * This quirk is for the "Advanced Driver" mode.  If off, the GS-10
 849          * has ID 0x003c and is standard compliant, but has only 16-bit PCM
 850          * and no MIDI.
 851          */
 852         USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
 853         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 854                 .vendor_name = "BOSS",
 855                 .product_name = "GS-10",
 856                 .ifnum = QUIRK_ANY_INTERFACE,
 857                 .type = QUIRK_COMPOSITE,
 858                 .data = & (const struct snd_usb_audio_quirk[]) {
 859                         {
 860                                 .ifnum = 1,
 861                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 862                         },
 863                         {
 864                                 .ifnum = 2,
 865                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 866                         },
 867                         {
 868                                 .ifnum = 3,
 869                                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 870                         },
 871                         {
 872                                 .ifnum = -1
 873                         }
 874                 }
 875         }
 876 },
 877 {
 878         /* has ID 0x0041 when not in "Advanced Driver" mode */
 879         USB_DEVICE(0x0582, 0x0040),
 880         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 881                 .vendor_name = "Roland",
 882                 .product_name = "GI-20",
 883                 .ifnum = 0,
 884                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 885                 .data = & (const struct snd_usb_midi_endpoint_info) {
 886                         .out_cables = 0x0001,
 887                         .in_cables  = 0x0001
 888                 }
 889         }
 890 },
 891 {
 892         /* has ID 0x0043 when not in "Advanced Driver" mode */
 893         USB_DEVICE(0x0582, 0x0042),
 894         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 895                 .vendor_name = "Roland",
 896                 .product_name = "RS-70",
 897                 .ifnum = 0,
 898                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 899                 .data = & (const struct snd_usb_midi_endpoint_info) {
 900                         .out_cables = 0x0001,
 901                         .in_cables  = 0x0001
 902                 }
 903         }
 904 },
 905 {
 906         USB_DEVICE(0x0582, 0x0044),
 907         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 908                 .vendor_name = "Roland",
 909                 .product_name = "UA-1000",
 910                 .ifnum = QUIRK_ANY_INTERFACE,
 911                 .type = QUIRK_COMPOSITE,
 912                 .data = (const struct snd_usb_audio_quirk[]) {
 913                         {
 914                                 .ifnum = 1,
 915                                 .type = QUIRK_AUDIO_EDIROL_UA1000
 916                         },
 917                         {
 918                                 .ifnum = 2,
 919                                 .type = QUIRK_AUDIO_EDIROL_UA1000
 920                         },
 921                         {
 922                                 .ifnum = 3,
 923                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 924                                 .data = & (const struct snd_usb_midi_endpoint_info) {
 925                                         .out_cables = 0x0003,
 926                                         .in_cables  = 0x0003
 927                                 }
 928                         },
 929                         {
 930                                 .ifnum = -1
 931                         }
 932                 }
 933         }
 934 },
 935 {
 936         /* has ID 0x004a when not in "Advanced Driver" mode */
 937         USB_DEVICE(0x0582, 0x0048),
 938         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 939                 .vendor_name = "EDIROL",
 940                 .product_name = "UR-80",
 941                 .ifnum = 0,
 942                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 943                 .data = & (const struct snd_usb_midi_endpoint_info) {
 944                         .out_cables = 0x0003,
 945                         .in_cables  = 0x0007
 946                 }
 947         }
 948 },
 949         /* TODO: add Edirol M-100FX support */
 950 {
 951         /* has ID 0x004e when not in "Advanced Driver" mode */
 952         USB_DEVICE(0x0582, 0x004c),
 953         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 954                 .vendor_name = "EDIROL",
 955                 .product_name = "PCR-A",
 956                 .ifnum = QUIRK_ANY_INTERFACE,
 957                 .type = QUIRK_COMPOSITE,
 958                 .data = (const struct snd_usb_audio_quirk[]) {
 959                         {
 960                                 .ifnum = 1,
 961                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 962                         },
 963                         {
 964                                 .ifnum = 2,
 965                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 966                         },
 967                         {
 968                                 .ifnum = -1
 969                         }
 970                 }
 971         }
 972 },
 973 {
 974         /* has ID 0x004f when not in "Advanced Driver" mode */
 975         USB_DEVICE(0x0582, 0x004d),
 976         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 977                 .vendor_name = "EDIROL",
 978                 .product_name = "PCR-A",
 979                 .ifnum = 0,
 980                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 981                 .data = & (const struct snd_usb_midi_endpoint_info) {
 982                         .out_cables = 0x0003,
 983                         .in_cables  = 0x0007
 984                 }
 985         }
 986 },
 987 {
 988         /*
 989          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
 990          * is standard compliant, but has only 16-bit PCM.
 991          */
 992         USB_DEVICE(0x0582, 0x0050),
 993         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 994                 .vendor_name = "EDIROL",
 995                 .product_name = "UA-3FX",
 996                 .ifnum = QUIRK_ANY_INTERFACE,
 997                 .type = QUIRK_COMPOSITE,
 998                 .data = (const struct snd_usb_audio_quirk[]) {
 999                         {
1000                                 .ifnum = 1,
1001                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1002                         },
1003                         {
1004                                 .ifnum = 2,
1005                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1006                         },
1007                         {
1008                                 .ifnum = -1
1009                         }
1010                 }
1011         }
1012 },
1013 {
1014         USB_DEVICE(0x0582, 0x0052),
1015         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1016                 .vendor_name = "EDIROL",
1017                 .product_name = "UM-1SX",
1018                 .ifnum = 0,
1019                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1020         }
1021 },
1022         /* TODO: add Roland EXR support */
1023 {
1024         /* has ID 0x0067 when not in "Advanced Driver" mode */
1025         USB_DEVICE(0x0582, 0x0065),
1026         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1027                 .vendor_name = "EDIROL",
1028                 .product_name = "PCR-1",
1029                 .ifnum = 0,
1030                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1031                 .data = & (const struct snd_usb_midi_endpoint_info) {
1032                         .out_cables = 0x0001,
1033                         .in_cables  = 0x0003
1034                 }
1035         }
1036 },
1037 {
1038         /* has ID 0x006b when not in "Advanced Driver" mode */
1039         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1040         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1041                 .vendor_name = "Roland",
1042                 .product_name = "SP-606",
1043                 .ifnum = 3,
1044                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1045                 .data = & (const struct snd_usb_midi_endpoint_info) {
1046                         .out_cables = 0x0001,
1047                         .in_cables  = 0x0001
1048                 }
1049         }
1050 },
1051 {
1052         /* has ID 0x006e when not in "Advanced Driver" mode */
1053         USB_DEVICE(0x0582, 0x006d),
1054         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1055                 .vendor_name = "Roland",
1056                 .product_name = "FANTOM-X",
1057                 .ifnum = 0,
1058                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1059                 .data = & (const struct snd_usb_midi_endpoint_info) {
1060                         .out_cables = 0x0001,
1061                         .in_cables  = 0x0001
1062                 }
1063         }
1064 },
1065 {       /*
1066          * This quirk is for the "Advanced" modes of the Edirol UA-25.
1067          * If the switch is not in an advanced setting, the UA-25 has
1068          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1069          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1070          */
1071         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1072         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1073                 .vendor_name = "EDIROL",
1074                 .product_name = "UA-25",
1075                 .ifnum = QUIRK_ANY_INTERFACE,
1076                 .type = QUIRK_COMPOSITE,
1077                 .data = (const struct snd_usb_audio_quirk[]) {
1078                         {
1079                                 .ifnum = 0,
1080                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1081                         },
1082                         {
1083                                 .ifnum = 1,
1084                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1085                         },
1086                         {
1087                                 .ifnum = 2,
1088                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1089                         },
1090                         {
1091                                 .ifnum = -1
1092                         }
1093                 }
1094         }
1095 },
1096 {
1097         /* has ID 0x0076 when not in "Advanced Driver" mode */
1098         USB_DEVICE(0x0582, 0x0075),
1099         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1100                 .vendor_name = "BOSS",
1101                 .product_name = "DR-880",
1102                 .ifnum = 0,
1103                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1104                 .data = & (const struct snd_usb_midi_endpoint_info) {
1105                         .out_cables = 0x0001,
1106                         .in_cables  = 0x0001
1107                 }
1108         }
1109 },
1110 {
1111         /* has ID 0x007b when not in "Advanced Driver" mode */
1112         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1113         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1114                 .vendor_name = "Roland",
1115                 /* "RD" or "RD-700SX"? */
1116                 .ifnum = 0,
1117                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1118                 .data = & (const struct snd_usb_midi_endpoint_info) {
1119                         .out_cables = 0x0003,
1120                         .in_cables  = 0x0003
1121                 }
1122         }
1123 },
1124 /* Roland UA-101 in High-Speed Mode only */
1125 {
1126         USB_DEVICE(0x0582, 0x007d),
1127         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1128                 .vendor_name = "Roland",
1129                 .product_name = "UA-101",
1130                 .ifnum = QUIRK_ANY_INTERFACE,
1131                 .type = QUIRK_COMPOSITE,
1132                 .data = (const struct snd_usb_audio_quirk[]) {
1133                         {
1134                                 .ifnum = 0,
1135                                 .type = QUIRK_AUDIO_EDIROL_UA101
1136                         },
1137                         {
1138                                 .ifnum = 1,
1139                                 .type = QUIRK_AUDIO_EDIROL_UA101
1140                         },
1141                         {
1142                                 .ifnum = 2,
1143                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1144                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1145                                         .out_cables = 0x0001,
1146                                         .in_cables  = 0x0001
1147                                 }
1148                         },
1149                         {
1150                                 .ifnum = -1
1151                         }
1152                 }
1153         }
1154 },
1155 {
1156         /* has ID 0x0081 when not in "Advanced Driver" mode */
1157         USB_DEVICE(0x0582, 0x0080),
1158         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1159                 .vendor_name = "Roland",
1160                 .product_name = "G-70",
1161                 .ifnum = 0,
1162                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1163                 .data = & (const struct snd_usb_midi_endpoint_info) {
1164                         .out_cables = 0x0001,
1165                         .in_cables  = 0x0001
1166                 }
1167         }
1168 },
1169         /* TODO: add Roland V-SYNTH XT support */
1170         /* TODO: add BOSS GT-PRO support */
1171 {
1172         /* has ID 0x008c when not in "Advanced Driver" mode */
1173         USB_DEVICE(0x0582, 0x008b),
1174         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1175                 .vendor_name = "EDIROL",
1176                 .product_name = "PC-50",
1177                 .ifnum = 0,
1178                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1179                 .data = & (const struct snd_usb_midi_endpoint_info) {
1180                         .out_cables = 0x0001,
1181                         .in_cables  = 0x0001
1182                 }
1183         }
1184 },
1185         /* TODO: add Edirol PC-80 support */
1186         /* TODO: add Edirol UA-1EX support */
1187 {
1188         USB_DEVICE(0x0582, 0x009a),
1189         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1190                 .vendor_name = "EDIROL",
1191                 .product_name = "UM-3EX",
1192                 .ifnum = 0,
1193                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1194                 .data = & (const struct snd_usb_midi_endpoint_info) {
1195                         .out_cables = 0x000f,
1196                         .in_cables  = 0x000f
1197                 }
1198         }
1199 },
1200         /* TODO: add Edirol MD-P1 support */
1201
1202 /* Guillemot devices */
1203 {
1204         /*
1205          * This is for the "Windows Edition" where the external MIDI ports are
1206          * the only MIDI ports; the control data is reported through HID
1207          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1208          * compliant USB MIDI ports for external MIDI and controls.
1209          */
1210         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1211         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1212                 .vendor_name = "Hercules",
1213                 .product_name = "DJ Console (WE)",
1214                 .ifnum = 4,
1215                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1216                 .data = & (const struct snd_usb_midi_endpoint_info) {
1217                         .out_cables = 0x0001,
1218                         .in_cables = 0x0001
1219                 }
1220         }
1221 },
1222
1223 /* Midiman/M-Audio devices */
1224 {
1225         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1226         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1227                 .vendor_name = "M-Audio",
1228                 .product_name = "MidiSport 2x2",
1229                 .ifnum = QUIRK_ANY_INTERFACE,
1230                 .type = QUIRK_MIDI_MIDIMAN,
1231                 .data = & (const struct snd_usb_midi_endpoint_info) {
1232                         .out_cables = 0x0003,
1233                         .in_cables  = 0x0003
1234                 }
1235         }
1236 },
1237 {
1238         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1239         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1240                 .vendor_name = "M-Audio",
1241                 .product_name = "MidiSport 1x1",
1242                 .ifnum = QUIRK_ANY_INTERFACE,
1243                 .type = QUIRK_MIDI_MIDIMAN,
1244                 .data = & (const struct snd_usb_midi_endpoint_info) {
1245                         .out_cables = 0x0001,
1246                         .in_cables  = 0x0001
1247                 }
1248         }
1249 },
1250 {
1251         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1252         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1253                 .vendor_name = "M-Audio",
1254                 .product_name = "Keystation",
1255                 .ifnum = QUIRK_ANY_INTERFACE,
1256                 .type = QUIRK_MIDI_MIDIMAN,
1257                 .data = & (const struct snd_usb_midi_endpoint_info) {
1258                         .out_cables = 0x0001,
1259                         .in_cables  = 0x0001
1260                 }
1261         }
1262 },
1263 {
1264         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1265         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1266                 .vendor_name = "M-Audio",
1267                 .product_name = "MidiSport 4x4",
1268                 .ifnum = QUIRK_ANY_INTERFACE,
1269                 .type = QUIRK_MIDI_MIDIMAN,
1270                 .data = & (const struct snd_usb_midi_endpoint_info) {
1271                         .out_cables = 0x000f,
1272                         .in_cables  = 0x000f
1273                 }
1274         }
1275 },
1276 {
1277         /*
1278          * For hardware revision 1.05; in the later revisions (1.10 and
1279          * 1.21), 0x1031 is the ID for the device without firmware.
1280          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1281          */
1282         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1283         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1284                 .vendor_name = "M-Audio",
1285                 .product_name = "MidiSport 8x8",
1286                 .ifnum = QUIRK_ANY_INTERFACE,
1287                 .type = QUIRK_MIDI_MIDIMAN,
1288                 .data = & (const struct snd_usb_midi_endpoint_info) {
1289                         .out_cables = 0x01ff,
1290                         .in_cables  = 0x01ff
1291                 }
1292         }
1293 },
1294 {
1295         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1296         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1297                 .vendor_name = "M-Audio",
1298                 .product_name = "MidiSport 8x8",
1299                 .ifnum = QUIRK_ANY_INTERFACE,
1300                 .type = QUIRK_MIDI_MIDIMAN,
1301                 .data = & (const struct snd_usb_midi_endpoint_info) {
1302                         .out_cables = 0x01ff,
1303                         .in_cables  = 0x01ff
1304                 }
1305         }
1306 },
1307 {
1308         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1309         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1310                 .vendor_name = "M-Audio",
1311                 .product_name = "MidiSport 2x4",
1312                 .ifnum = QUIRK_ANY_INTERFACE,
1313                 .type = QUIRK_MIDI_MIDIMAN,
1314                 .data = & (const struct snd_usb_midi_endpoint_info) {
1315                         .out_cables = 0x000f,
1316                         .in_cables  = 0x0003
1317                 }
1318         }
1319 },
1320 {
1321         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1322         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1323                 .vendor_name = "M-Audio",
1324                 .product_name = "Quattro",
1325                 .ifnum = QUIRK_ANY_INTERFACE,
1326                 .type = QUIRK_COMPOSITE,
1327                 .data = & (const struct snd_usb_audio_quirk[]) {
1328                         /*
1329                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1330                          * and share endpoints with the other interfaces.
1331                          * Ignore them.  The other interfaces can do 24 bits,
1332                          * but captured samples are big-endian (see usbaudio.c).
1333                          */
1334                         {
1335                                 .ifnum = 0,
1336                                 .type = QUIRK_IGNORE_INTERFACE
1337                         },
1338                         {
1339                                 .ifnum = 1,
1340                                 .type = QUIRK_IGNORE_INTERFACE
1341                         },
1342                         {
1343                                 .ifnum = 2,
1344                                 .type = QUIRK_IGNORE_INTERFACE
1345                         },
1346                         {
1347                                 .ifnum = 3,
1348                                 .type = QUIRK_IGNORE_INTERFACE
1349                         },
1350                         {
1351                                 .ifnum = 4,
1352                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1353                         },
1354                         {
1355                                 .ifnum = 5,
1356                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1357                         },
1358                         {
1359                                 .ifnum = 6,
1360                                 .type = QUIRK_IGNORE_INTERFACE
1361                         },
1362                         {
1363                                 .ifnum = 7,
1364                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1365                         },
1366                         {
1367                                 .ifnum = 8,
1368                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1369                         },
1370                         {
1371                                 .ifnum = 9,
1372                                 .type = QUIRK_MIDI_MIDIMAN,
1373                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1374                                         .out_cables = 0x0001,
1375                                         .in_cables  = 0x0001
1376                                 }
1377                         },
1378                         {
1379                                 .ifnum = -1
1380                         }
1381                 }
1382         }
1383 },
1384 {
1385         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1386         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1387                 .vendor_name = "M-Audio",
1388                 .product_name = "AudioPhile",
1389                 .ifnum = 6,
1390                 .type = QUIRK_MIDI_MIDIMAN,
1391                 .data = & (const struct snd_usb_midi_endpoint_info) {
1392                         .out_cables = 0x0001,
1393                         .in_cables  = 0x0001
1394                 }
1395         }
1396 },
1397 {
1398         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1399         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1400                 .vendor_name = "M-Audio",
1401                 .product_name = "Ozone",
1402                 .ifnum = 3,
1403                 .type = QUIRK_MIDI_MIDIMAN,
1404                 .data = & (const struct snd_usb_midi_endpoint_info) {
1405                         .out_cables = 0x0001,
1406                         .in_cables  = 0x0001
1407                 }
1408         }
1409 },
1410 {
1411         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1412         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1413                 .vendor_name = "M-Audio",
1414                 .product_name = "OmniStudio",
1415                 .ifnum = QUIRK_ANY_INTERFACE,
1416                 .type = QUIRK_COMPOSITE,
1417                 .data = & (const struct snd_usb_audio_quirk[]) {
1418                         {
1419                                 .ifnum = 0,
1420                                 .type = QUIRK_IGNORE_INTERFACE
1421                         },
1422                         {
1423                                 .ifnum = 1,
1424                                 .type = QUIRK_IGNORE_INTERFACE
1425                         },
1426                         {
1427                                 .ifnum = 2,
1428                                 .type = QUIRK_IGNORE_INTERFACE
1429                         },
1430                         {
1431                                 .ifnum = 3,
1432                                 .type = QUIRK_IGNORE_INTERFACE
1433                         },
1434                         {
1435                                 .ifnum = 4,
1436                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1437                         },
1438                         {
1439                                 .ifnum = 5,
1440                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1441                         },
1442                         {
1443                                 .ifnum = 6,
1444                                 .type = QUIRK_IGNORE_INTERFACE
1445                         },
1446                         {
1447                                 .ifnum = 7,
1448                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1449                         },
1450                         {
1451                                 .ifnum = 8,
1452                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1453                         },
1454                         {
1455                                 .ifnum = 9,
1456                                 .type = QUIRK_MIDI_MIDIMAN,
1457                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1458                                         .out_cables = 0x0001,
1459                                         .in_cables  = 0x0001
1460                                 }
1461                         },
1462                         {
1463                                 .ifnum = -1
1464                         }
1465                 }
1466         }
1467 },
1468
1469 /* Casio devices */
1470 {
1471         USB_DEVICE(0x07cf, 0x6801),
1472         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1473                 .vendor_name = "Casio",
1474                 .product_name = "PL-40R",
1475                 .ifnum = 0,
1476                 .type = QUIRK_MIDI_YAMAHA
1477         }
1478 },
1479 {
1480         /* this ID is used by several devices without a product ID */
1481         USB_DEVICE(0x07cf, 0x6802),
1482         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1483                 .vendor_name = "Casio",
1484                 .product_name = "Keyboard",
1485                 .ifnum = 0,
1486                 .type = QUIRK_MIDI_YAMAHA
1487         }
1488 },
1489
1490 /* Mark of the Unicorn devices */
1491 {
1492         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1493         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1494                        USB_DEVICE_ID_MATCH_PRODUCT |
1495                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1496         .idVendor = 0x07fd,
1497         .idProduct = 0x0001,
1498         .bDeviceSubClass = 2,
1499         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1500                 .vendor_name = "MOTU",
1501                 .product_name = "Fastlane",
1502                 .ifnum = QUIRK_ANY_INTERFACE,
1503                 .type = QUIRK_COMPOSITE,
1504                 .data = & (const struct snd_usb_audio_quirk[]) {
1505                         {
1506                                 .ifnum = 0,
1507                                 .type = QUIRK_MIDI_RAW
1508                         },
1509                         {
1510                                 .ifnum = 1,
1511                                 .type = QUIRK_IGNORE_INTERFACE
1512                         },
1513                         {
1514                                 .ifnum = -1
1515                         }
1516                 }
1517         }
1518 },
1519
1520 {
1521         /* Creative Sound Blaster MP3+ */
1522         USB_DEVICE(0x041e, 0x3010),
1523         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1524                 .vendor_name = "Creative Labs",
1525                 .product_name = "Sound Blaster MP3+",
1526                 .ifnum = QUIRK_NO_INTERFACE
1527         }
1528
1529 },
1530
1531 /* Emagic devices */
1532 {
1533         USB_DEVICE(0x086a, 0x0001),
1534         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1535                 .vendor_name = "Emagic",
1536                 /* .product_name = "Unitor8", */
1537                 .ifnum = 2,
1538                 .type = QUIRK_MIDI_EMAGIC,
1539                 .data = & (const struct snd_usb_midi_endpoint_info) {
1540                         .out_cables = 0x80ff,
1541                         .in_cables  = 0x80ff
1542                 }
1543         }
1544 },
1545 {
1546         USB_DEVICE(0x086a, 0x0002),
1547         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1548                 .vendor_name = "Emagic",
1549                 /* .product_name = "AMT8", */
1550                 .ifnum = 2,
1551                 .type = QUIRK_MIDI_EMAGIC,
1552                 .data = & (const struct snd_usb_midi_endpoint_info) {
1553                         .out_cables = 0x80ff,
1554                         .in_cables  = 0x80ff
1555                 }
1556         }
1557 },
1558 {
1559         USB_DEVICE(0x086a, 0x0003),
1560         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1561                 .vendor_name = "Emagic",
1562                 /* .product_name = "MT4", */
1563                 .ifnum = 2,
1564                 .type = QUIRK_MIDI_EMAGIC,
1565                 .data = & (const struct snd_usb_midi_endpoint_info) {
1566                         .out_cables = 0x800f,
1567                         .in_cables  = 0x8003
1568                 }
1569         }
1570 },
1571
1572 /* TerraTec devices */
1573 {
1574         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1575         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1576                 .vendor_name = "TerraTec",
1577                 .product_name = "PHASE 26",
1578                 .ifnum = 3,
1579                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1580         }
1581 },
1582 {
1583         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1584         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1585                 .vendor_name = "TerraTec",
1586                 .product_name = "PHASE 26",
1587                 .ifnum = 3,
1588                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1589         }
1590 },
1591 {
1592         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
1593         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1594                 .vendor_name = "TerraTec",
1595                 .product_name = "PHASE 26",
1596                 .ifnum = 3,
1597                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1598         }
1599 },
1600 {
1601         USB_DEVICE(0x0ccd, 0x0035),
1602         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1603                 .vendor_name = "Miditech",
1604                 .product_name = "Play'n Roll",
1605                 .ifnum = 0,
1606                 .type = QUIRK_MIDI_CME
1607         }
1608 },
1609
1610 /* Novation EMS devices */
1611 {
1612         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1613         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1614                 .vendor_name = "Novation",
1615                 .product_name = "ReMOTE Audio/XStation",
1616                 .ifnum = 4,
1617                 .type = QUIRK_MIDI_NOVATION
1618         }
1619 },
1620 {
1621         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1622         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1623                 .vendor_name = "Novation",
1624                 .product_name = "Speedio",
1625                 .ifnum = 3,
1626                 .type = QUIRK_MIDI_NOVATION
1627         }
1628 },
1629 {
1630         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1631         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1632                 .vendor_name = "Novation",
1633                 .product_name = "ReMOTE25",
1634                 .ifnum = 0,
1635                 .type = QUIRK_MIDI_NOVATION
1636         }
1637 },
1638
1639 /* Miditech devices */
1640 {
1641         USB_DEVICE(0x4752, 0x0011),
1642         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1643                 .vendor_name = "Miditech",
1644                 .product_name = "Midistart-2",
1645                 .ifnum = 0,
1646                 .type = QUIRK_MIDI_CME
1647         }
1648 },
1649
1650 /* Central Music devices */
1651 {
1652         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
1653         USB_DEVICE(0x7104, 0x2202),
1654         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1655                 .ifnum = 0,
1656                 .type = QUIRK_MIDI_CME
1657         }
1658 },
1659
1660 {
1661         /*
1662          * Some USB MIDI devices don't have an audio control interface,
1663          * so we have to grab MIDI streaming interfaces here.
1664          */
1665         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
1666                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
1667         .bInterfaceClass = USB_CLASS_AUDIO,
1668         .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
1669         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1670                 .ifnum = QUIRK_ANY_INTERFACE,
1671                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1672         }
1673 },
1674
1675 #undef USB_DEVICE_VENDOR_SPEC