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 0x004f when not in "Advanced Driver" mode */
 952         USB_DEVICE(0x0582, 0x004d),
 953         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 954                 .vendor_name = "EDIROL",
 955                 .product_name = "PCR-A",
 956                 .ifnum = 0,
 957                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
 958                 .data = & (const struct snd_usb_midi_endpoint_info) {
 959                         .out_cables = 0x0003,
 960                         .in_cables  = 0x0007
 961                 }
 962         }
 963 },
 964 {
 965         /*
 966          * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
 967          * is standard compliant, but has only 16-bit PCM.
 968          */
 969         USB_DEVICE(0x0582, 0x0050),
 970         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 971                 .vendor_name = "EDIROL",
 972                 .product_name = "UA-3FX",
 973                 .ifnum = QUIRK_ANY_INTERFACE,
 974                 .type = QUIRK_COMPOSITE,
 975                 .data = (const struct snd_usb_audio_quirk[]) {
 976                         {
 977                                 .ifnum = 1,
 978                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 979                         },
 980                         {
 981                                 .ifnum = 2,
 982                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
 983                         },
 984                         {
 985                                 .ifnum = -1
 986                         }
 987                 }
 988         }
 989 },
 990 {
 991         USB_DEVICE(0x0582, 0x0052),
 992         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
 993                 .vendor_name = "EDIROL",
 994                 .product_name = "UM-1SX",
 995                 .ifnum = 0,
 996                 .type = QUIRK_MIDI_STANDARD_INTERFACE
 997         }
 998 },
 999         /* TODO: add Roland EXR support */
1000 {
1001         /* has ID 0x0067 when not in "Advanced Driver" mode */
1002         USB_DEVICE(0x0582, 0x0065),
1003         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1004                 .vendor_name = "EDIROL",
1005                 .product_name = "PCR-1",
1006                 .ifnum = 0,
1007                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1008                 .data = & (const struct snd_usb_midi_endpoint_info) {
1009                         .out_cables = 0x0001,
1010                         .in_cables  = 0x0003
1011                 }
1012         }
1013 },
1014 {
1015         /* has ID 0x006b when not in "Advanced Driver" mode */
1016         USB_DEVICE_VENDOR_SPEC(0x0582, 0x006a),
1017         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1018                 .vendor_name = "Roland",
1019                 .product_name = "SP-606",
1020                 .ifnum = 3,
1021                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1022                 .data = & (const struct snd_usb_midi_endpoint_info) {
1023                         .out_cables = 0x0001,
1024                         .in_cables  = 0x0001
1025                 }
1026         }
1027 },
1028 {
1029         /* has ID 0x006e when not in "Advanced Driver" mode */
1030         USB_DEVICE(0x0582, 0x006d),
1031         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1032                 .vendor_name = "Roland",
1033                 .product_name = "FANTOM-X",
1034                 .ifnum = 0,
1035                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1036                 .data = & (const struct snd_usb_midi_endpoint_info) {
1037                         .out_cables = 0x0001,
1038                         .in_cables  = 0x0001
1039                 }
1040         }
1041 },
1042 {       /*
1043          * This quirk is for the "Advanced" modes of the Edirol UA-25.
1044          * If the switch is not in an advanced setting, the UA-25 has
1045          * ID 0x0582/0x0073 and is standard compliant (no quirks), but
1046          * offers only 16-bit PCM at 44.1 kHz and no MIDI.
1047          */
1048         USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
1049         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1050                 .vendor_name = "EDIROL",
1051                 .product_name = "UA-25",
1052                 .ifnum = QUIRK_ANY_INTERFACE,
1053                 .type = QUIRK_COMPOSITE,
1054                 .data = (const struct snd_usb_audio_quirk[]) {
1055                         {
1056                                 .ifnum = 0,
1057                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1058                         },
1059                         {
1060                                 .ifnum = 1,
1061                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1062                         },
1063                         {
1064                                 .ifnum = 2,
1065                                 .type = QUIRK_AUDIO_EDIROL_UA700_UA25
1066                         },
1067                         {
1068                                 .ifnum = -1
1069                         }
1070                 }
1071         }
1072 },
1073 {
1074         /* has ID 0x0076 when not in "Advanced Driver" mode */
1075         USB_DEVICE(0x0582, 0x0075),
1076         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1077                 .vendor_name = "BOSS",
1078                 .product_name = "DR-880",
1079                 .ifnum = 0,
1080                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1081                 .data = & (const struct snd_usb_midi_endpoint_info) {
1082                         .out_cables = 0x0001,
1083                         .in_cables  = 0x0001
1084                 }
1085         }
1086 },
1087 {
1088         /* has ID 0x007b when not in "Advanced Driver" mode */
1089         USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
1090         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1091                 .vendor_name = "Roland",
1092                 /* "RD" or "RD-700SX"? */
1093                 .ifnum = 0,
1094                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1095                 .data = & (const struct snd_usb_midi_endpoint_info) {
1096                         .out_cables = 0x0003,
1097                         .in_cables  = 0x0003
1098                 }
1099         }
1100 },
1101 /* Roland UA-101 in High-Speed Mode only */
1102 {
1103         USB_DEVICE(0x0582, 0x007d),
1104         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1105                 .vendor_name = "Roland",
1106                 .product_name = "UA-101",
1107                 .ifnum = QUIRK_ANY_INTERFACE,
1108                 .type = QUIRK_COMPOSITE,
1109                 .data = (const struct snd_usb_audio_quirk[]) {
1110                         {
1111                                 .ifnum = 0,
1112                                 .type = QUIRK_AUDIO_EDIROL_UA101
1113                         },
1114                         {
1115                                 .ifnum = 1,
1116                                 .type = QUIRK_AUDIO_EDIROL_UA101
1117                         },
1118                         {
1119                                 .ifnum = 2,
1120                                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1121                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1122                                         .out_cables = 0x0001,
1123                                         .in_cables  = 0x0001
1124                                 }
1125                         },
1126                         {
1127                                 .ifnum = -1
1128                         }
1129                 }
1130         }
1131 },
1132 {
1133         /* has ID 0x0081 when not in "Advanced Driver" mode */
1134         USB_DEVICE(0x0582, 0x0080),
1135         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1136                 .vendor_name = "Roland",
1137                 .product_name = "G-70",
1138                 .ifnum = 0,
1139                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1140                 .data = & (const struct snd_usb_midi_endpoint_info) {
1141                         .out_cables = 0x0001,
1142                         .in_cables  = 0x0001
1143                 }
1144         }
1145 },
1146         /* TODO: add Roland V-SYNTH XT support */
1147         /* TODO: add BOSS GT-PRO support */
1148 {
1149         /* has ID 0x008c when not in "Advanced Driver" mode */
1150         USB_DEVICE(0x0582, 0x008b),
1151         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1152                 .vendor_name = "EDIROL",
1153                 .product_name = "PC-50",
1154                 .ifnum = 0,
1155                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1156                 .data = & (const struct snd_usb_midi_endpoint_info) {
1157                         .out_cables = 0x0001,
1158                         .in_cables  = 0x0001
1159                 }
1160         }
1161 },
1162         /* TODO: add Edirol PC-80 support */
1163         /* TODO: add Edirol UA-1EX support */
1164 {
1165         USB_DEVICE(0x0582, 0x009a),
1166         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1167                 .vendor_name = "EDIROL",
1168                 .product_name = "UM-3EX",
1169                 .ifnum = 0,
1170                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1171                 .data = & (const struct snd_usb_midi_endpoint_info) {
1172                         .out_cables = 0x000f,
1173                         .in_cables  = 0x000f
1174                 }
1175         }
1176 },
1177         /* TODO: add Edirol MD-P1 support */
1178
1179 /* Guillemot devices */
1180 {
1181         /*
1182          * This is for the "Windows Edition" where the external MIDI ports are
1183          * the only MIDI ports; the control data is reported through HID
1184          * interfaces.  The "Macintosh Edition" has ID 0xd002 and uses standard
1185          * compliant USB MIDI ports for external MIDI and controls.
1186          */
1187         USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
1188         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1189                 .vendor_name = "Hercules",
1190                 .product_name = "DJ Console (WE)",
1191                 .ifnum = 4,
1192                 .type = QUIRK_MIDI_FIXED_ENDPOINT,
1193                 .data = & (const struct snd_usb_midi_endpoint_info) {
1194                         .out_cables = 0x0001,
1195                         .in_cables = 0x0001
1196                 }
1197         }
1198 },
1199
1200 /* Midiman/M-Audio devices */
1201 {
1202         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
1203         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1204                 .vendor_name = "M-Audio",
1205                 .product_name = "MidiSport 2x2",
1206                 .ifnum = QUIRK_ANY_INTERFACE,
1207                 .type = QUIRK_MIDI_MIDIMAN,
1208                 .data = & (const struct snd_usb_midi_endpoint_info) {
1209                         .out_cables = 0x0003,
1210                         .in_cables  = 0x0003
1211                 }
1212         }
1213 },
1214 {
1215         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
1216         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1217                 .vendor_name = "M-Audio",
1218                 .product_name = "MidiSport 1x1",
1219                 .ifnum = QUIRK_ANY_INTERFACE,
1220                 .type = QUIRK_MIDI_MIDIMAN,
1221                 .data = & (const struct snd_usb_midi_endpoint_info) {
1222                         .out_cables = 0x0001,
1223                         .in_cables  = 0x0001
1224                 }
1225         }
1226 },
1227 {
1228         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
1229         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1230                 .vendor_name = "M-Audio",
1231                 .product_name = "Keystation",
1232                 .ifnum = QUIRK_ANY_INTERFACE,
1233                 .type = QUIRK_MIDI_MIDIMAN,
1234                 .data = & (const struct snd_usb_midi_endpoint_info) {
1235                         .out_cables = 0x0001,
1236                         .in_cables  = 0x0001
1237                 }
1238         }
1239 },
1240 {
1241         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
1242         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1243                 .vendor_name = "M-Audio",
1244                 .product_name = "MidiSport 4x4",
1245                 .ifnum = QUIRK_ANY_INTERFACE,
1246                 .type = QUIRK_MIDI_MIDIMAN,
1247                 .data = & (const struct snd_usb_midi_endpoint_info) {
1248                         .out_cables = 0x000f,
1249                         .in_cables  = 0x000f
1250                 }
1251         }
1252 },
1253 {
1254         /*
1255          * For hardware revision 1.05; in the later revisions (1.10 and
1256          * 1.21), 0x1031 is the ID for the device without firmware.
1257          * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
1258          */
1259         USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
1260         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1261                 .vendor_name = "M-Audio",
1262                 .product_name = "MidiSport 8x8",
1263                 .ifnum = QUIRK_ANY_INTERFACE,
1264                 .type = QUIRK_MIDI_MIDIMAN,
1265                 .data = & (const struct snd_usb_midi_endpoint_info) {
1266                         .out_cables = 0x01ff,
1267                         .in_cables  = 0x01ff
1268                 }
1269         }
1270 },
1271 {
1272         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
1273         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1274                 .vendor_name = "M-Audio",
1275                 .product_name = "MidiSport 8x8",
1276                 .ifnum = QUIRK_ANY_INTERFACE,
1277                 .type = QUIRK_MIDI_MIDIMAN,
1278                 .data = & (const struct snd_usb_midi_endpoint_info) {
1279                         .out_cables = 0x01ff,
1280                         .in_cables  = 0x01ff
1281                 }
1282         }
1283 },
1284 {
1285         USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
1286         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1287                 .vendor_name = "M-Audio",
1288                 .product_name = "MidiSport 2x4",
1289                 .ifnum = QUIRK_ANY_INTERFACE,
1290                 .type = QUIRK_MIDI_MIDIMAN,
1291                 .data = & (const struct snd_usb_midi_endpoint_info) {
1292                         .out_cables = 0x000f,
1293                         .in_cables  = 0x0003
1294                 }
1295         }
1296 },
1297 {
1298         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
1299         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1300                 .vendor_name = "M-Audio",
1301                 .product_name = "Quattro",
1302                 .ifnum = QUIRK_ANY_INTERFACE,
1303                 .type = QUIRK_COMPOSITE,
1304                 .data = & (const struct snd_usb_audio_quirk[]) {
1305                         /*
1306                          * Interfaces 0-2 are "Windows-compatible", 16-bit only,
1307                          * and share endpoints with the other interfaces.
1308                          * Ignore them.  The other interfaces can do 24 bits,
1309                          * but captured samples are big-endian (see usbaudio.c).
1310                          */
1311                         {
1312                                 .ifnum = 0,
1313                                 .type = QUIRK_IGNORE_INTERFACE
1314                         },
1315                         {
1316                                 .ifnum = 1,
1317                                 .type = QUIRK_IGNORE_INTERFACE
1318                         },
1319                         {
1320                                 .ifnum = 2,
1321                                 .type = QUIRK_IGNORE_INTERFACE
1322                         },
1323                         {
1324                                 .ifnum = 3,
1325                                 .type = QUIRK_IGNORE_INTERFACE
1326                         },
1327                         {
1328                                 .ifnum = 4,
1329                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1330                         },
1331                         {
1332                                 .ifnum = 5,
1333                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1334                         },
1335                         {
1336                                 .ifnum = 6,
1337                                 .type = QUIRK_IGNORE_INTERFACE
1338                         },
1339                         {
1340                                 .ifnum = 7,
1341                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1342                         },
1343                         {
1344                                 .ifnum = 8,
1345                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1346                         },
1347                         {
1348                                 .ifnum = 9,
1349                                 .type = QUIRK_MIDI_MIDIMAN,
1350                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1351                                         .out_cables = 0x0001,
1352                                         .in_cables  = 0x0001
1353                                 }
1354                         },
1355                         {
1356                                 .ifnum = -1
1357                         }
1358                 }
1359         }
1360 },
1361 {
1362         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
1363         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1364                 .vendor_name = "M-Audio",
1365                 .product_name = "AudioPhile",
1366                 .ifnum = 6,
1367                 .type = QUIRK_MIDI_MIDIMAN,
1368                 .data = & (const struct snd_usb_midi_endpoint_info) {
1369                         .out_cables = 0x0001,
1370                         .in_cables  = 0x0001
1371                 }
1372         }
1373 },
1374 {
1375         USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
1376         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1377                 .vendor_name = "M-Audio",
1378                 .product_name = "Ozone",
1379                 .ifnum = 3,
1380                 .type = QUIRK_MIDI_MIDIMAN,
1381                 .data = & (const struct snd_usb_midi_endpoint_info) {
1382                         .out_cables = 0x0001,
1383                         .in_cables  = 0x0001
1384                 }
1385         }
1386 },
1387 {
1388         USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
1389         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1390                 .vendor_name = "M-Audio",
1391                 .product_name = "OmniStudio",
1392                 .ifnum = QUIRK_ANY_INTERFACE,
1393                 .type = QUIRK_COMPOSITE,
1394                 .data = & (const struct snd_usb_audio_quirk[]) {
1395                         {
1396                                 .ifnum = 0,
1397                                 .type = QUIRK_IGNORE_INTERFACE
1398                         },
1399                         {
1400                                 .ifnum = 1,
1401                                 .type = QUIRK_IGNORE_INTERFACE
1402                         },
1403                         {
1404                                 .ifnum = 2,
1405                                 .type = QUIRK_IGNORE_INTERFACE
1406                         },
1407                         {
1408                                 .ifnum = 3,
1409                                 .type = QUIRK_IGNORE_INTERFACE
1410                         },
1411                         {
1412                                 .ifnum = 4,
1413                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1414                         },
1415                         {
1416                                 .ifnum = 5,
1417                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1418                         },
1419                         {
1420                                 .ifnum = 6,
1421                                 .type = QUIRK_IGNORE_INTERFACE
1422                         },
1423                         {
1424                                 .ifnum = 7,
1425                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1426                         },
1427                         {
1428                                 .ifnum = 8,
1429                                 .type = QUIRK_AUDIO_STANDARD_INTERFACE
1430                         },
1431                         {
1432                                 .ifnum = 9,
1433                                 .type = QUIRK_MIDI_MIDIMAN,
1434                                 .data = & (const struct snd_usb_midi_endpoint_info) {
1435                                         .out_cables = 0x0001,
1436                                         .in_cables  = 0x0001
1437                                 }
1438                         },
1439                         {
1440                                 .ifnum = -1
1441                         }
1442                 }
1443         }
1444 },
1445
1446 /* Casio devices */
1447 {
1448         USB_DEVICE(0x07cf, 0x6801),
1449         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1450                 .vendor_name = "Casio",
1451                 .product_name = "PL-40R",
1452                 .ifnum = 0,
1453                 .type = QUIRK_MIDI_YAMAHA
1454         }
1455 },
1456 {
1457         /* this ID is used by several devices without a product ID */
1458         USB_DEVICE(0x07cf, 0x6802),
1459         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1460                 .vendor_name = "Casio",
1461                 .product_name = "Keyboard",
1462                 .ifnum = 0,
1463                 .type = QUIRK_MIDI_YAMAHA
1464         }
1465 },
1466
1467 /* Mark of the Unicorn devices */
1468 {
1469         /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
1470         .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
1471                        USB_DEVICE_ID_MATCH_PRODUCT |
1472                        USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
1473         .idVendor = 0x07fd,
1474         .idProduct = 0x0001,
1475         .bDeviceSubClass = 2,
1476         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1477                 .vendor_name = "MOTU",
1478                 .product_name = "Fastlane",
1479                 .ifnum = QUIRK_ANY_INTERFACE,
1480                 .type = QUIRK_COMPOSITE,
1481                 .data = & (const struct snd_usb_audio_quirk[]) {
1482                         {
1483                                 .ifnum = 0,
1484                                 .type = QUIRK_MIDI_RAW
1485                         },
1486                         {
1487                                 .ifnum = 1,
1488                                 .type = QUIRK_IGNORE_INTERFACE
1489                         },
1490                         {
1491                                 .ifnum = -1
1492                         }
1493                 }
1494         }
1495 },
1496
1497 {
1498         /* Creative Sound Blaster MP3+ */
1499         USB_DEVICE(0x041e, 0x3010),
1500         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1501                 .vendor_name = "Creative Labs",
1502                 .product_name = "Sound Blaster MP3+",
1503                 .ifnum = QUIRK_NO_INTERFACE
1504         }
1505
1506 },
1507
1508 /* Emagic devices */
1509 {
1510         USB_DEVICE(0x086a, 0x0001),
1511         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1512                 .vendor_name = "Emagic",
1513                 /* .product_name = "Unitor8", */
1514                 .ifnum = 2,
1515                 .type = QUIRK_MIDI_EMAGIC,
1516                 .data = & (const struct snd_usb_midi_endpoint_info) {
1517                         .out_cables = 0x80ff,
1518                         .in_cables  = 0x80ff
1519                 }
1520         }
1521 },
1522 {
1523         USB_DEVICE(0x086a, 0x0002),
1524         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1525                 .vendor_name = "Emagic",
1526                 /* .product_name = "AMT8", */
1527                 .ifnum = 2,
1528                 .type = QUIRK_MIDI_EMAGIC,
1529                 .data = & (const struct snd_usb_midi_endpoint_info) {
1530                         .out_cables = 0x80ff,
1531                         .in_cables  = 0x80ff
1532                 }
1533         }
1534 },
1535 {
1536         USB_DEVICE(0x086a, 0x0003),
1537         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1538                 .vendor_name = "Emagic",
1539                 /* .product_name = "MT4", */
1540                 .ifnum = 2,
1541                 .type = QUIRK_MIDI_EMAGIC,
1542                 .data = & (const struct snd_usb_midi_endpoint_info) {
1543                         .out_cables = 0x800f,
1544                         .in_cables  = 0x8003
1545                 }
1546         }
1547 },
1548
1549 /* TerraTec devices */
1550 {
1551         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
1552         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1553                 .vendor_name = "TerraTec",
1554                 .product_name = "PHASE 26",
1555                 .ifnum = 3,
1556                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1557         }
1558 },
1559 {
1560         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
1561         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1562                 .vendor_name = "TerraTec",
1563                 .product_name = "PHASE 26",
1564                 .ifnum = 3,
1565                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1566         }
1567 },
1568 {
1569         USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
1570         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1571                 .vendor_name = "TerraTec",
1572                 .product_name = "PHASE 26",
1573                 .ifnum = 3,
1574                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1575         }
1576 },
1577 {
1578         USB_DEVICE(0x0ccd, 0x0035),
1579         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1580                 .vendor_name = "Miditech",
1581                 .product_name = "Play'n Roll",
1582                 .ifnum = 0,
1583                 .type = QUIRK_MIDI_CME
1584         }
1585 },
1586
1587 /* Novation EMS devices */
1588 {
1589         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
1590         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1591                 .vendor_name = "Novation",
1592                 .product_name = "ReMOTE Audio/XStation",
1593                 .ifnum = 4,
1594                 .type = QUIRK_MIDI_NOVATION
1595         }
1596 },
1597 {
1598         USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
1599         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1600                 .vendor_name = "Novation",
1601                 .product_name = "Speedio",
1602                 .ifnum = 3,
1603                 .type = QUIRK_MIDI_NOVATION
1604         }
1605 },
1606 {
1607         USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
1608         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1609                 .vendor_name = "Novation",
1610                 .product_name = "ReMOTE25",
1611                 .ifnum = 0,
1612                 .type = QUIRK_MIDI_NOVATION
1613         }
1614 },
1615
1616 /* Miditech devices */
1617 {
1618         USB_DEVICE(0x4752, 0x0011),
1619         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1620                 .vendor_name = "Miditech",
1621                 .product_name = "Midistart-2",
1622                 .ifnum = 0,
1623                 .type = QUIRK_MIDI_CME
1624         }
1625 },
1626
1627 /* Central Music devices */
1628 {
1629         /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
1630         USB_DEVICE(0x7104, 0x2202),
1631         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1632                 .ifnum = 0,
1633                 .type = QUIRK_MIDI_CME
1634         }
1635 },
1636
1637 {
1638         /*
1639          * Some USB MIDI devices don't have an audio control interface,
1640          * so we have to grab MIDI streaming interfaces here.
1641          */
1642         .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
1643                        USB_DEVICE_ID_MATCH_INT_SUBCLASS,
1644         .bInterfaceClass = USB_CLASS_AUDIO,
1645         .bInterfaceSubClass = USB_SUBCLASS_MIDI_STREAMING,
1646         .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
1647                 .ifnum = QUIRK_ANY_INTERFACE,
1648                 .type = QUIRK_MIDI_STANDARD_INTERFACE
1649         }
1650 },
1651
1652 #undef USB_DEVICE_VENDOR_SPEC