API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 30th, 2020
1,034
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 79.60 KB | None | 0 0
raw download clone embed print report
  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. /* FTDI devices */
  43. {
  44. USB_DEVICE(0x0403, 0xb8d8),
  45. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  46. /* .vendor_name = "STARR LABS", */
  47. /* .product_name = "Starr Labs MIDI USB device", */
  48. .ifnum = 0,
  49. .type = QUIRK_MIDI_FTDI
  50. }
  51. },
  52.  
  53. {
  54. /* Creative BT-D1 */
  55. USB_DEVICE(0x041e, 0x0005),
  56. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  57. .ifnum = 1,
  58. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  59. .data = &(const struct audioformat) {
  60. .formats = SNDRV_PCM_FMTBIT_S16_LE,
  61. .channels = 2,
  62. .iface = 1,
  63. .altsetting = 1,
  64. .altset_idx = 1,
  65. .endpoint = 0x03,
  66. .ep_attr = USB_ENDPOINT_XFER_ISOC,
  67. .attributes = 0,
  68. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  69. .rate_min = 48000,
  70. .rate_max = 48000,
  71. }
  72. }
  73. },
  74.  
  75. /* Creative/E-Mu devices */
  76. {
  77. USB_DEVICE(0x041e, 0x3010),
  78. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  79. .vendor_name = "Creative Labs",
  80. .product_name = "Sound Blaster MP3+",
  81. .ifnum = QUIRK_NO_INTERFACE
  82. }
  83. },
  84. /* Creative/Toshiba Multimedia Center SB-0500 */
  85. {
  86. USB_DEVICE(0x041e, 0x3048),
  87. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  88. .vendor_name = "Toshiba",
  89. .product_name = "SB-0500",
  90. .ifnum = QUIRK_NO_INTERFACE
  91. }
  92. },
  93. {
  94. /* E-Mu 0202 USB */
  95. .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  96. .idVendor = 0x041e,
  97. .idProduct = 0x3f02,
  98. .bInterfaceClass = USB_CLASS_AUDIO,
  99. },
  100. {
  101. /* E-Mu 0404 USB */
  102. .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  103. .idVendor = 0x041e,
  104. .idProduct = 0x3f04,
  105. .bInterfaceClass = USB_CLASS_AUDIO,
  106. },
  107. {
  108. /* E-Mu Tracker Pre */
  109. .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  110. .idVendor = 0x041e,
  111. .idProduct = 0x3f0a,
  112. .bInterfaceClass = USB_CLASS_AUDIO,
  113. },
  114. {
  115. /* E-Mu 0204 USB */
  116. .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  117. .idVendor = 0x041e,
  118. .idProduct = 0x3f19,
  119. .bInterfaceClass = USB_CLASS_AUDIO,
  120. },
  121.  
  122. /*
  123. * HP Wireless Audio
  124. * When not ignored, causes instability issues for some users, forcing them to
  125. * blacklist the entire module.
  126. */
  127. {
  128. USB_DEVICE(0x0424, 0xb832),
  129. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  130. .vendor_name = "Standard Microsystems Corp.",
  131. .product_name = "HP Wireless Audio",
  132. .ifnum = QUIRK_ANY_INTERFACE,
  133. .type = QUIRK_COMPOSITE,
  134. .data = (const struct snd_usb_audio_quirk[]) {
  135. /* Mixer */
  136. {
  137. .ifnum = 0,
  138. .type = QUIRK_IGNORE_INTERFACE,
  139. },
  140. /* Playback */
  141. {
  142. .ifnum = 1,
  143. .type = QUIRK_IGNORE_INTERFACE,
  144. },
  145. /* Capture */
  146. {
  147. .ifnum = 2,
  148. .type = QUIRK_IGNORE_INTERFACE,
  149. },
  150. /* HID Device, .ifnum = 3 */
  151. {
  152. .ifnum = -1,
  153. }
  154. }
  155. }
  156. },
  157.  
  158. /*
  159. * Logitech QuickCam: bDeviceClass is vendor-specific, so generic interface
  160. * class matches do not take effect without an explicit ID match.
  161. */
  162. {
  163. .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
  164. USB_DEVICE_ID_MATCH_INT_CLASS |
  165. USB_DEVICE_ID_MATCH_INT_SUBCLASS,
  166. .idVendor = 0x046d,
  167. .idProduct = 0x0850,
  168. .bInterfaceClass = USB_CLASS_AUDIO,
  169. .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
  170. },
  171. {
  172. .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
  173. USB_DEVICE_ID_MATCH_INT_CLASS |
  174. USB_DEVICE_ID_MATCH_INT_SUBCLASS,
  175. .idVendor = 0x046d,
  176. .idProduct = 0x08ae,
  177. .bInterfaceClass = USB_CLASS_AUDIO,
  178. .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
  179. },
  180. {
  181. .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
  182. USB_DEVICE_ID_MATCH_INT_CLASS |
  183. USB_DEVICE_ID_MATCH_INT_SUBCLASS,
  184. .idVendor = 0x046d,
  185. .idProduct = 0x08c6,
  186. .bInterfaceClass = USB_CLASS_AUDIO,
  187. .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
  188. },
  189. {
  190. .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
  191. USB_DEVICE_ID_MATCH_INT_CLASS |
  192. USB_DEVICE_ID_MATCH_INT_SUBCLASS,
  193. .idVendor = 0x046d,
  194. .idProduct = 0x08f0,
  195. .bInterfaceClass = USB_CLASS_AUDIO,
  196. .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
  197. },
  198. {
  199. .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
  200. USB_DEVICE_ID_MATCH_INT_CLASS |
  201. USB_DEVICE_ID_MATCH_INT_SUBCLASS,
  202. .idVendor = 0x046d,
  203. .idProduct = 0x08f5,
  204. .bInterfaceClass = USB_CLASS_AUDIO,
  205. .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
  206. },
  207. {
  208. .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
  209. USB_DEVICE_ID_MATCH_INT_CLASS |
  210. USB_DEVICE_ID_MATCH_INT_SUBCLASS,
  211. .idVendor = 0x046d,
  212. .idProduct = 0x08f6,
  213. .bInterfaceClass = USB_CLASS_AUDIO,
  214. .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL
  215. },
  216. {
  217. .match_flags = USB_DEVICE_ID_MATCH_DEVICE |
  218. USB_DEVICE_ID_MATCH_INT_CLASS |
  219. USB_DEVICE_ID_MATCH_INT_SUBCLASS,
  220. .idVendor = 0x046d,
  221. .idProduct = 0x0990,
  222. .bInterfaceClass = USB_CLASS_AUDIO,
  223. .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
  224. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  225. .vendor_name = "Logitech, Inc.",
  226. .product_name = "QuickCam Pro 9000",
  227. .ifnum = QUIRK_NO_INTERFACE
  228. }
  229. },
  230.  
  231. /*
  232. * Yamaha devices
  233. */
  234.  
  235. #define YAMAHA_DEVICE(id, name) { \
  236. USB_DEVICE(0x0499, id), \
  237. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
  238. .vendor_name = "Yamaha", \
  239. .product_name = name, \
  240. .ifnum = QUIRK_ANY_INTERFACE, \
  241. .type = QUIRK_MIDI_YAMAHA \
  242. } \
  243. }
  244. #define YAMAHA_INTERFACE(id, intf, name) { \
  245. USB_DEVICE_VENDOR_SPEC(0x0499, id), \
  246. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) { \
  247. .vendor_name = "Yamaha", \
  248. .product_name = name, \
  249. .ifnum = intf, \
  250. .type = QUIRK_MIDI_YAMAHA \
  251. } \
  252. }
  253. YAMAHA_DEVICE(0x1000, "UX256"),
  254. YAMAHA_DEVICE(0x1001, "MU1000"),
  255. YAMAHA_DEVICE(0x1002, "MU2000"),
  256. YAMAHA_DEVICE(0x1003, "MU500"),
  257. YAMAHA_INTERFACE(0x1004, 3, "UW500"),
  258. YAMAHA_DEVICE(0x1005, "MOTIF6"),
  259. YAMAHA_DEVICE(0x1006, "MOTIF7"),
  260. YAMAHA_DEVICE(0x1007, "MOTIF8"),
  261. YAMAHA_DEVICE(0x1008, "UX96"),
  262. YAMAHA_DEVICE(0x1009, "UX16"),
  263. YAMAHA_INTERFACE(0x100a, 3, "EOS BX"),
  264. YAMAHA_DEVICE(0x100c, "UC-MX"),
  265. YAMAHA_DEVICE(0x100d, "UC-KX"),
  266. YAMAHA_DEVICE(0x100e, "S08"),
  267. YAMAHA_DEVICE(0x100f, "CLP-150"),
  268. YAMAHA_DEVICE(0x1010, "CLP-170"),
  269. YAMAHA_DEVICE(0x1011, "P-250"),
  270. YAMAHA_DEVICE(0x1012, "TYROS"),
  271. YAMAHA_DEVICE(0x1013, "PF-500"),
  272. YAMAHA_DEVICE(0x1014, "S90"),
  273. YAMAHA_DEVICE(0x1015, "MOTIF-R"),
  274. YAMAHA_DEVICE(0x1016, "MDP-5"),
  275. YAMAHA_DEVICE(0x1017, "CVP-204"),
  276. YAMAHA_DEVICE(0x1018, "CVP-206"),
  277. YAMAHA_DEVICE(0x1019, "CVP-208"),
  278. YAMAHA_DEVICE(0x101a, "CVP-210"),
  279. YAMAHA_DEVICE(0x101b, "PSR-1100"),
  280. YAMAHA_DEVICE(0x101c, "PSR-2100"),
  281. YAMAHA_DEVICE(0x101d, "CLP-175"),
  282. YAMAHA_DEVICE(0x101e, "PSR-K1"),
  283. YAMAHA_DEVICE(0x101f, "EZ-J24"),
  284. YAMAHA_DEVICE(0x1020, "EZ-250i"),
  285. YAMAHA_DEVICE(0x1021, "MOTIF ES 6"),
  286. YAMAHA_DEVICE(0x1022, "MOTIF ES 7"),
  287. YAMAHA_DEVICE(0x1023, "MOTIF ES 8"),
  288. YAMAHA_DEVICE(0x1024, "CVP-301"),
  289. YAMAHA_DEVICE(0x1025, "CVP-303"),
  290. YAMAHA_DEVICE(0x1026, "CVP-305"),
  291. YAMAHA_DEVICE(0x1027, "CVP-307"),
  292. YAMAHA_DEVICE(0x1028, "CVP-309"),
  293. YAMAHA_DEVICE(0x1029, "CVP-309GP"),
  294. YAMAHA_DEVICE(0x102a, "PSR-1500"),
  295. YAMAHA_DEVICE(0x102b, "PSR-3000"),
  296. YAMAHA_DEVICE(0x102e, "ELS-01/01C"),
  297. YAMAHA_DEVICE(0x1030, "PSR-295/293"),
  298. YAMAHA_DEVICE(0x1031, "DGX-205/203"),
  299. YAMAHA_DEVICE(0x1032, "DGX-305"),
  300. YAMAHA_DEVICE(0x1033, "DGX-505"),
  301. YAMAHA_DEVICE(0x1034, NULL),
  302. YAMAHA_DEVICE(0x1035, NULL),
  303. YAMAHA_DEVICE(0x1036, NULL),
  304. YAMAHA_DEVICE(0x1037, NULL),
  305. YAMAHA_DEVICE(0x1038, NULL),
  306. YAMAHA_DEVICE(0x1039, NULL),
  307. YAMAHA_DEVICE(0x103a, NULL),
  308. YAMAHA_DEVICE(0x103b, NULL),
  309. YAMAHA_DEVICE(0x103c, NULL),
  310. YAMAHA_DEVICE(0x103d, NULL),
  311. YAMAHA_DEVICE(0x103e, NULL),
  312. YAMAHA_DEVICE(0x103f, NULL),
  313. YAMAHA_DEVICE(0x1040, NULL),
  314. YAMAHA_DEVICE(0x1041, NULL),
  315. YAMAHA_DEVICE(0x1042, NULL),
  316. YAMAHA_DEVICE(0x1043, NULL),
  317. YAMAHA_DEVICE(0x1044, NULL),
  318. YAMAHA_DEVICE(0x1045, NULL),
  319. YAMAHA_INTERFACE(0x104e, 0, NULL),
  320. YAMAHA_DEVICE(0x104f, NULL),
  321. YAMAHA_DEVICE(0x1050, NULL),
  322. YAMAHA_DEVICE(0x1051, NULL),
  323. YAMAHA_DEVICE(0x1052, NULL),
  324. YAMAHA_INTERFACE(0x1053, 0, NULL),
  325. YAMAHA_INTERFACE(0x1054, 0, NULL),
  326. YAMAHA_DEVICE(0x1055, NULL),
  327. YAMAHA_DEVICE(0x1056, NULL),
  328. YAMAHA_DEVICE(0x1057, NULL),
  329. YAMAHA_DEVICE(0x1058, NULL),
  330. YAMAHA_DEVICE(0x1059, NULL),
  331. YAMAHA_DEVICE(0x105a, NULL),
  332. YAMAHA_DEVICE(0x105b, NULL),
  333. YAMAHA_DEVICE(0x105c, NULL),
  334. YAMAHA_DEVICE(0x105d, NULL),
  335. {
  336. USB_DEVICE(0x0499, 0x1503),
  337. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  338. /* .vendor_name = "Yamaha", */
  339. /* .product_name = "MOX6/MOX8", */
  340. .ifnum = QUIRK_ANY_INTERFACE,
  341. .type = QUIRK_COMPOSITE,
  342. .data = (const struct snd_usb_audio_quirk[]) {
  343. {
  344. .ifnum = 1,
  345. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  346. },
  347. {
  348. .ifnum = 2,
  349. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  350. },
  351. {
  352. .ifnum = 3,
  353. .type = QUIRK_MIDI_YAMAHA
  354. },
  355. {
  356. .ifnum = -1
  357. }
  358. }
  359. }
  360. },
  361. {
  362. USB_DEVICE(0x0499, 0x1507),
  363. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  364. /* .vendor_name = "Yamaha", */
  365. /* .product_name = "THR10", */
  366. .ifnum = QUIRK_ANY_INTERFACE,
  367. .type = QUIRK_COMPOSITE,
  368. .data = (const struct snd_usb_audio_quirk[]) {
  369. {
  370. .ifnum = 1,
  371. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  372. },
  373. {
  374. .ifnum = 2,
  375. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  376. },
  377. {
  378. .ifnum = 3,
  379. .type = QUIRK_MIDI_YAMAHA
  380. },
  381. {
  382. .ifnum = -1
  383. }
  384. }
  385. }
  386. },
  387. {
  388. USB_DEVICE(0x0499, 0x1509),
  389. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  390. /* .vendor_name = "Yamaha", */
  391. /* .product_name = "Steinberg UR22", */
  392. .ifnum = QUIRK_ANY_INTERFACE,
  393. .type = QUIRK_COMPOSITE,
  394. .data = (const struct snd_usb_audio_quirk[]) {
  395. {
  396. .ifnum = 1,
  397. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  398. },
  399. {
  400. .ifnum = 2,
  401. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  402. },
  403. {
  404. .ifnum = 3,
  405. .type = QUIRK_MIDI_YAMAHA
  406. },
  407. {
  408. .ifnum = 4,
  409. .type = QUIRK_IGNORE_INTERFACE
  410. },
  411. {
  412. .ifnum = -1
  413. }
  414. }
  415. }
  416. },
  417. {
  418. USB_DEVICE(0x0499, 0x150a),
  419. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  420. /* .vendor_name = "Yamaha", */
  421. /* .product_name = "THR5A", */
  422. .ifnum = QUIRK_ANY_INTERFACE,
  423. .type = QUIRK_COMPOSITE,
  424. .data = (const struct snd_usb_audio_quirk[]) {
  425. {
  426. .ifnum = 1,
  427. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  428. },
  429. {
  430. .ifnum = 2,
  431. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  432. },
  433. {
  434. .ifnum = 3,
  435. .type = QUIRK_MIDI_YAMAHA
  436. },
  437. {
  438. .ifnum = -1
  439. }
  440. }
  441. }
  442. },
  443. {
  444. USB_DEVICE(0x0499, 0x150c),
  445. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  446. /* .vendor_name = "Yamaha", */
  447. /* .product_name = "THR10C", */
  448. .ifnum = QUIRK_ANY_INTERFACE,
  449. .type = QUIRK_COMPOSITE,
  450. .data = (const struct snd_usb_audio_quirk[]) {
  451. {
  452. .ifnum = 1,
  453. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  454. },
  455. {
  456. .ifnum = 2,
  457. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  458. },
  459. {
  460. .ifnum = 3,
  461. .type = QUIRK_MIDI_YAMAHA
  462. },
  463. {
  464. .ifnum = -1
  465. }
  466. }
  467. }
  468. },
  469. YAMAHA_DEVICE(0x2000, "DGP-7"),
  470. YAMAHA_DEVICE(0x2001, "DGP-5"),
  471. YAMAHA_DEVICE(0x2002, NULL),
  472. YAMAHA_DEVICE(0x2003, NULL),
  473. YAMAHA_DEVICE(0x5000, "CS1D"),
  474. YAMAHA_DEVICE(0x5001, "DSP1D"),
  475. YAMAHA_DEVICE(0x5002, "DME32"),
  476. YAMAHA_DEVICE(0x5003, "DM2000"),
  477. YAMAHA_DEVICE(0x5004, "02R96"),
  478. YAMAHA_DEVICE(0x5005, "ACU16-C"),
  479. YAMAHA_DEVICE(0x5006, "NHB32-C"),
  480. YAMAHA_DEVICE(0x5007, "DM1000"),
  481. YAMAHA_DEVICE(0x5008, "01V96"),
  482. YAMAHA_DEVICE(0x5009, "SPX2000"),
  483. YAMAHA_DEVICE(0x500a, "PM5D"),
  484. YAMAHA_DEVICE(0x500b, "DME64N"),
  485. YAMAHA_DEVICE(0x500c, "DME24N"),
  486. YAMAHA_DEVICE(0x500d, NULL),
  487. YAMAHA_DEVICE(0x500e, NULL),
  488. YAMAHA_DEVICE(0x500f, NULL),
  489. YAMAHA_DEVICE(0x7000, "DTX"),
  490. YAMAHA_DEVICE(0x7010, "UB99"),
  491. #undef YAMAHA_DEVICE
  492. #undef YAMAHA_INTERFACE
  493. /* this catches most recent vendor-specific Yamaha devices */
  494. {
  495. .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
  496. USB_DEVICE_ID_MATCH_INT_CLASS,
  497. .idVendor = 0x0499,
  498. .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
  499. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  500. .ifnum = QUIRK_ANY_INTERFACE,
  501. .type = QUIRK_AUTODETECT
  502. }
  503. },
  504.  
  505. /*
  506. * Roland/RolandED/Edirol/BOSS devices
  507. */
  508. {
  509. USB_DEVICE(0x0582, 0x0000),
  510. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  511. .vendor_name = "Roland",
  512. .product_name = "UA-100",
  513. .ifnum = QUIRK_ANY_INTERFACE,
  514. .type = QUIRK_COMPOSITE,
  515. .data = (const struct snd_usb_audio_quirk[]) {
  516. {
  517. .ifnum = 0,
  518. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  519. .data = & (const struct audioformat) {
  520. .formats = SNDRV_PCM_FMTBIT_S16_LE,
  521. .channels = 4,
  522. .iface = 0,
  523. .altsetting = 1,
  524. .altset_idx = 1,
  525. .attributes = 0,
  526. .endpoint = 0x01,
  527. .ep_attr = 0x09,
  528. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  529. .rate_min = 44100,
  530. .rate_max = 44100,
  531. }
  532. },
  533. {
  534. .ifnum = 1,
  535. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  536. .data = & (const struct audioformat) {
  537. .formats = SNDRV_PCM_FMTBIT_S16_LE,
  538. .channels = 2,
  539. .iface = 1,
  540. .altsetting = 1,
  541. .altset_idx = 1,
  542. .attributes = UAC_EP_CS_ATTR_FILL_MAX,
  543. .endpoint = 0x81,
  544. .ep_attr = 0x05,
  545. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  546. .rate_min = 44100,
  547. .rate_max = 44100,
  548. }
  549. },
  550. {
  551. .ifnum = 2,
  552. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  553. .data = & (const struct snd_usb_midi_endpoint_info) {
  554. .out_cables = 0x0007,
  555. .in_cables = 0x0007
  556. }
  557. },
  558. {
  559. .ifnum = -1
  560. }
  561. }
  562. }
  563. },
  564. {
  565. USB_DEVICE(0x0582, 0x0002),
  566. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  567. .vendor_name = "EDIROL",
  568. .product_name = "UM-4",
  569. .ifnum = QUIRK_ANY_INTERFACE,
  570. .type = QUIRK_COMPOSITE,
  571. .data = (const struct snd_usb_audio_quirk[]) {
  572. {
  573. .ifnum = 0,
  574. .type = QUIRK_IGNORE_INTERFACE
  575. },
  576. {
  577. .ifnum = 1,
  578. .type = QUIRK_IGNORE_INTERFACE
  579. },
  580. {
  581. .ifnum = 2,
  582. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  583. .data = & (const struct snd_usb_midi_endpoint_info) {
  584. .out_cables = 0x000f,
  585. .in_cables = 0x000f
  586. }
  587. },
  588. {
  589. .ifnum = -1
  590. }
  591. }
  592. }
  593. },
  594. {
  595. USB_DEVICE(0x0582, 0x0003),
  596. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  597. .vendor_name = "Roland",
  598. .product_name = "SC-8850",
  599. .ifnum = QUIRK_ANY_INTERFACE,
  600. .type = QUIRK_COMPOSITE,
  601. .data = (const struct snd_usb_audio_quirk[]) {
  602. {
  603. .ifnum = 0,
  604. .type = QUIRK_IGNORE_INTERFACE
  605. },
  606. {
  607. .ifnum = 1,
  608. .type = QUIRK_IGNORE_INTERFACE
  609. },
  610. {
  611. .ifnum = 2,
  612. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  613. .data = & (const struct snd_usb_midi_endpoint_info) {
  614. .out_cables = 0x003f,
  615. .in_cables = 0x003f
  616. }
  617. },
  618. {
  619. .ifnum = -1
  620. }
  621. }
  622. }
  623. },
  624. {
  625. USB_DEVICE(0x0582, 0x0004),
  626. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  627. .vendor_name = "Roland",
  628. .product_name = "U-8",
  629. .ifnum = QUIRK_ANY_INTERFACE,
  630. .type = QUIRK_COMPOSITE,
  631. .data = (const struct snd_usb_audio_quirk[]) {
  632. {
  633. .ifnum = 0,
  634. .type = QUIRK_IGNORE_INTERFACE
  635. },
  636. {
  637. .ifnum = 1,
  638. .type = QUIRK_IGNORE_INTERFACE
  639. },
  640. {
  641. .ifnum = 2,
  642. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  643. .data = & (const struct snd_usb_midi_endpoint_info) {
  644. .out_cables = 0x0005,
  645. .in_cables = 0x0005
  646. }
  647. },
  648. {
  649. .ifnum = -1
  650. }
  651. }
  652. }
  653. },
  654. {
  655. /* Has ID 0x0099 when not in "Advanced Driver" mode.
  656. * The UM-2EX has only one input, but we cannot detect this. */
  657. USB_DEVICE(0x0582, 0x0005),
  658. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  659. .vendor_name = "EDIROL",
  660. .product_name = "UM-2",
  661. .ifnum = QUIRK_ANY_INTERFACE,
  662. .type = QUIRK_COMPOSITE,
  663. .data = (const struct snd_usb_audio_quirk[]) {
  664. {
  665. .ifnum = 0,
  666. .type = QUIRK_IGNORE_INTERFACE
  667. },
  668. {
  669. .ifnum = 1,
  670. .type = QUIRK_IGNORE_INTERFACE
  671. },
  672. {
  673. .ifnum = 2,
  674. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  675. .data = & (const struct snd_usb_midi_endpoint_info) {
  676. .out_cables = 0x0003,
  677. .in_cables = 0x0003
  678. }
  679. },
  680. {
  681. .ifnum = -1
  682. }
  683. }
  684. }
  685. },
  686. {
  687. USB_DEVICE(0x0582, 0x0007),
  688. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  689. .vendor_name = "Roland",
  690. .product_name = "SC-8820",
  691. .ifnum = QUIRK_ANY_INTERFACE,
  692. .type = QUIRK_COMPOSITE,
  693. .data = (const struct snd_usb_audio_quirk[]) {
  694. {
  695. .ifnum = 0,
  696. .type = QUIRK_IGNORE_INTERFACE
  697. },
  698. {
  699. .ifnum = 1,
  700. .type = QUIRK_IGNORE_INTERFACE
  701. },
  702. {
  703. .ifnum = 2,
  704. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  705. .data = & (const struct snd_usb_midi_endpoint_info) {
  706. .out_cables = 0x0013,
  707. .in_cables = 0x0013
  708. }
  709. },
  710. {
  711. .ifnum = -1
  712. }
  713. }
  714. }
  715. },
  716. {
  717. USB_DEVICE(0x0582, 0x0008),
  718. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  719. .vendor_name = "Roland",
  720. .product_name = "PC-300",
  721. .ifnum = QUIRK_ANY_INTERFACE,
  722. .type = QUIRK_COMPOSITE,
  723. .data = (const struct snd_usb_audio_quirk[]) {
  724. {
  725. .ifnum = 0,
  726. .type = QUIRK_IGNORE_INTERFACE
  727. },
  728. {
  729. .ifnum = 1,
  730. .type = QUIRK_IGNORE_INTERFACE
  731. },
  732. {
  733. .ifnum = 2,
  734. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  735. .data = & (const struct snd_usb_midi_endpoint_info) {
  736. .out_cables = 0x0001,
  737. .in_cables = 0x0001
  738. }
  739. },
  740. {
  741. .ifnum = -1
  742. }
  743. }
  744. }
  745. },
  746. {
  747. /* has ID 0x009d when not in "Advanced Driver" mode */
  748. USB_DEVICE(0x0582, 0x0009),
  749. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  750. .vendor_name = "EDIROL",
  751. .product_name = "UM-1",
  752. .ifnum = QUIRK_ANY_INTERFACE,
  753. .type = QUIRK_COMPOSITE,
  754. .data = (const struct snd_usb_audio_quirk[]) {
  755. {
  756. .ifnum = 0,
  757. .type = QUIRK_IGNORE_INTERFACE
  758. },
  759. {
  760. .ifnum = 1,
  761. .type = QUIRK_IGNORE_INTERFACE
  762. },
  763. {
  764. .ifnum = 2,
  765. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  766. .data = & (const struct snd_usb_midi_endpoint_info) {
  767. .out_cables = 0x0001,
  768. .in_cables = 0x0001
  769. }
  770. },
  771. {
  772. .ifnum = -1
  773. }
  774. }
  775. }
  776. },
  777. {
  778. USB_DEVICE(0x0582, 0x000b),
  779. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  780. .vendor_name = "Roland",
  781. .product_name = "SK-500",
  782. .ifnum = QUIRK_ANY_INTERFACE,
  783. .type = QUIRK_COMPOSITE,
  784. .data = (const struct snd_usb_audio_quirk[]) {
  785. {
  786. .ifnum = 0,
  787. .type = QUIRK_IGNORE_INTERFACE
  788. },
  789. {
  790. .ifnum = 1,
  791. .type = QUIRK_IGNORE_INTERFACE
  792. },
  793. {
  794. .ifnum = 2,
  795. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  796. .data = & (const struct snd_usb_midi_endpoint_info) {
  797. .out_cables = 0x0013,
  798. .in_cables = 0x0013
  799. }
  800. },
  801. {
  802. .ifnum = -1
  803. }
  804. }
  805. }
  806. },
  807. {
  808. /* thanks to Emiliano Grilli <emillo@libero.it>
  809. * for helping researching this data */
  810. USB_DEVICE(0x0582, 0x000c),
  811. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  812. .vendor_name = "Roland",
  813. .product_name = "SC-D70",
  814. .ifnum = QUIRK_ANY_INTERFACE,
  815. .type = QUIRK_COMPOSITE,
  816. .data = (const struct snd_usb_audio_quirk[]) {
  817. {
  818. .ifnum = 0,
  819. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  820. },
  821. {
  822. .ifnum = 1,
  823. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  824. },
  825. {
  826. .ifnum = 2,
  827. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  828. .data = & (const struct snd_usb_midi_endpoint_info) {
  829. .out_cables = 0x0007,
  830. .in_cables = 0x0007
  831. }
  832. },
  833. {
  834. .ifnum = -1
  835. }
  836. }
  837. }
  838. },
  839. { /*
  840. * This quirk is for the "Advanced Driver" mode of the Edirol UA-5.
  841. * If the advanced mode switch at the back of the unit is off, the
  842. * UA-5 has ID 0x0582/0x0011 and is standard compliant (no quirks),
  843. * but offers only 16-bit PCM.
  844. * In advanced mode, the UA-5 will output S24_3LE samples (two
  845. * channels) at the rate indicated on the front switch, including
  846. * the 96kHz sample rate.
  847. */
  848. USB_DEVICE(0x0582, 0x0010),
  849. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  850. .vendor_name = "EDIROL",
  851. .product_name = "UA-5",
  852. .ifnum = QUIRK_ANY_INTERFACE,
  853. .type = QUIRK_COMPOSITE,
  854. .data = (const struct snd_usb_audio_quirk[]) {
  855. {
  856. .ifnum = 1,
  857. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  858. },
  859. {
  860. .ifnum = 2,
  861. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  862. },
  863. {
  864. .ifnum = -1
  865. }
  866. }
  867. }
  868. },
  869. {
  870. /* has ID 0x0013 when not in "Advanced Driver" mode */
  871. USB_DEVICE(0x0582, 0x0012),
  872. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  873. .vendor_name = "Roland",
  874. .product_name = "XV-5050",
  875. .ifnum = 0,
  876. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  877. .data = & (const struct snd_usb_midi_endpoint_info) {
  878. .out_cables = 0x0001,
  879. .in_cables = 0x0001
  880. }
  881. }
  882. },
  883. {
  884. /* has ID 0x0015 when not in "Advanced Driver" mode */
  885. USB_DEVICE(0x0582, 0x0014),
  886. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  887. .vendor_name = "EDIROL",
  888. .product_name = "UM-880",
  889. .ifnum = 0,
  890. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  891. .data = & (const struct snd_usb_midi_endpoint_info) {
  892. .out_cables = 0x01ff,
  893. .in_cables = 0x01ff
  894. }
  895. }
  896. },
  897. {
  898. /* has ID 0x0017 when not in "Advanced Driver" mode */
  899. USB_DEVICE(0x0582, 0x0016),
  900. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  901. .vendor_name = "EDIROL",
  902. .product_name = "SD-90",
  903. .ifnum = QUIRK_ANY_INTERFACE,
  904. .type = QUIRK_COMPOSITE,
  905. .data = (const struct snd_usb_audio_quirk[]) {
  906. {
  907. .ifnum = 0,
  908. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  909. },
  910. {
  911. .ifnum = 1,
  912. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  913. },
  914. {
  915. .ifnum = 2,
  916. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  917. .data = & (const struct snd_usb_midi_endpoint_info) {
  918. .out_cables = 0x000f,
  919. .in_cables = 0x000f
  920. }
  921. },
  922. {
  923. .ifnum = -1
  924. }
  925. }
  926. }
  927. },
  928. {
  929. /* has ID 0x001c when not in "Advanced Driver" mode */
  930. USB_DEVICE(0x0582, 0x001b),
  931. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  932. .vendor_name = "Roland",
  933. .product_name = "MMP-2",
  934. .ifnum = QUIRK_ANY_INTERFACE,
  935. .type = QUIRK_COMPOSITE,
  936. .data = (const struct snd_usb_audio_quirk[]) {
  937. {
  938. .ifnum = 0,
  939. .type = QUIRK_IGNORE_INTERFACE
  940. },
  941. {
  942. .ifnum = 1,
  943. .type = QUIRK_IGNORE_INTERFACE
  944. },
  945. {
  946. .ifnum = 2,
  947. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  948. .data = & (const struct snd_usb_midi_endpoint_info) {
  949. .out_cables = 0x0001,
  950. .in_cables = 0x0001
  951. }
  952. },
  953. {
  954. .ifnum = -1
  955. }
  956. }
  957. }
  958. },
  959. {
  960. /* has ID 0x001e when not in "Advanced Driver" mode */
  961. USB_DEVICE(0x0582, 0x001d),
  962. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  963. .vendor_name = "Roland",
  964. .product_name = "V-SYNTH",
  965. .ifnum = 0,
  966. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  967. .data = & (const struct snd_usb_midi_endpoint_info) {
  968. .out_cables = 0x0001,
  969. .in_cables = 0x0001
  970. }
  971. }
  972. },
  973. {
  974. /* has ID 0x0024 when not in "Advanced Driver" mode */
  975. USB_DEVICE(0x0582, 0x0023),
  976. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  977. .vendor_name = "EDIROL",
  978. .product_name = "UM-550",
  979. .ifnum = 0,
  980. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  981. .data = & (const struct snd_usb_midi_endpoint_info) {
  982. .out_cables = 0x003f,
  983. .in_cables = 0x003f
  984. }
  985. }
  986. },
  987. {
  988. /*
  989. * This quirk is for the "Advanced Driver" mode. If off, the UA-20
  990. * has ID 0x0026 and is standard compliant, but has only 16-bit PCM
  991. * and no MIDI.
  992. */
  993. USB_DEVICE(0x0582, 0x0025),
  994. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  995. .vendor_name = "EDIROL",
  996. .product_name = "UA-20",
  997. .ifnum = QUIRK_ANY_INTERFACE,
  998. .type = QUIRK_COMPOSITE,
  999. .data = (const struct snd_usb_audio_quirk[]) {
  1000. {
  1001. .ifnum = 0,
  1002. .type = QUIRK_IGNORE_INTERFACE
  1003. },
  1004. {
  1005. .ifnum = 1,
  1006. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  1007. .data = & (const struct audioformat) {
  1008. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  1009. .channels = 2,
  1010. .iface = 1,
  1011. .altsetting = 1,
  1012. .altset_idx = 1,
  1013. .attributes = 0,
  1014. .endpoint = 0x01,
  1015. .ep_attr = 0x01,
  1016. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  1017. .rate_min = 44100,
  1018. .rate_max = 44100,
  1019. }
  1020. },
  1021. {
  1022. .ifnum = 2,
  1023. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  1024. .data = & (const struct audioformat) {
  1025. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  1026. .channels = 2,
  1027. .iface = 2,
  1028. .altsetting = 1,
  1029. .altset_idx = 1,
  1030. .attributes = 0,
  1031. .endpoint = 0x82,
  1032. .ep_attr = 0x01,
  1033. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  1034. .rate_min = 44100,
  1035. .rate_max = 44100,
  1036. }
  1037. },
  1038. {
  1039. .ifnum = 3,
  1040. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1041. .data = & (const struct snd_usb_midi_endpoint_info) {
  1042. .out_cables = 0x0001,
  1043. .in_cables = 0x0001
  1044. }
  1045. },
  1046. {
  1047. .ifnum = -1
  1048. }
  1049. }
  1050. }
  1051. },
  1052. {
  1053. /* has ID 0x0028 when not in "Advanced Driver" mode */
  1054. USB_DEVICE(0x0582, 0x0027),
  1055. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1056. .vendor_name = "EDIROL",
  1057. .product_name = "SD-20",
  1058. .ifnum = 0,
  1059. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1060. .data = & (const struct snd_usb_midi_endpoint_info) {
  1061. .out_cables = 0x0003,
  1062. .in_cables = 0x0007
  1063. }
  1064. }
  1065. },
  1066. {
  1067. /* has ID 0x002a when not in "Advanced Driver" mode */
  1068. USB_DEVICE(0x0582, 0x0029),
  1069. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1070. .vendor_name = "EDIROL",
  1071. .product_name = "SD-80",
  1072. .ifnum = 0,
  1073. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1074. .data = & (const struct snd_usb_midi_endpoint_info) {
  1075. .out_cables = 0x000f,
  1076. .in_cables = 0x000f
  1077. }
  1078. }
  1079. },
  1080. { /*
  1081. * This quirk is for the "Advanced" modes of the Edirol UA-700.
  1082. * If the sample format switch is not in an advanced setting, the
  1083. * UA-700 has ID 0x0582/0x002c and is standard compliant (no quirks),
  1084. * but offers only 16-bit PCM and no MIDI.
  1085. */
  1086. USB_DEVICE_VENDOR_SPEC(0x0582, 0x002b),
  1087. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1088. .vendor_name = "EDIROL",
  1089. .product_name = "UA-700",
  1090. .ifnum = QUIRK_ANY_INTERFACE,
  1091. .type = QUIRK_COMPOSITE,
  1092. .data = (const struct snd_usb_audio_quirk[]) {
  1093. {
  1094. .ifnum = 1,
  1095. .type = QUIRK_AUDIO_EDIROL_UAXX
  1096. },
  1097. {
  1098. .ifnum = 2,
  1099. .type = QUIRK_AUDIO_EDIROL_UAXX
  1100. },
  1101. {
  1102. .ifnum = 3,
  1103. .type = QUIRK_AUDIO_EDIROL_UAXX
  1104. },
  1105. {
  1106. .ifnum = -1
  1107. }
  1108. }
  1109. }
  1110. },
  1111. {
  1112. /* has ID 0x002e when not in "Advanced Driver" mode */
  1113. USB_DEVICE(0x0582, 0x002d),
  1114. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1115. .vendor_name = "Roland",
  1116. .product_name = "XV-2020",
  1117. .ifnum = 0,
  1118. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1119. .data = & (const struct snd_usb_midi_endpoint_info) {
  1120. .out_cables = 0x0001,
  1121. .in_cables = 0x0001
  1122. }
  1123. }
  1124. },
  1125. {
  1126. /* has ID 0x0030 when not in "Advanced Driver" mode */
  1127. USB_DEVICE(0x0582, 0x002f),
  1128. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1129. .vendor_name = "Roland",
  1130. .product_name = "VariOS",
  1131. .ifnum = 0,
  1132. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1133. .data = & (const struct snd_usb_midi_endpoint_info) {
  1134. .out_cables = 0x0007,
  1135. .in_cables = 0x0007
  1136. }
  1137. }
  1138. },
  1139. {
  1140. /* has ID 0x0034 when not in "Advanced Driver" mode */
  1141. USB_DEVICE(0x0582, 0x0033),
  1142. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1143. .vendor_name = "EDIROL",
  1144. .product_name = "PCR",
  1145. .ifnum = 0,
  1146. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1147. .data = & (const struct snd_usb_midi_endpoint_info) {
  1148. .out_cables = 0x0003,
  1149. .in_cables = 0x0007
  1150. }
  1151. }
  1152. },
  1153. {
  1154. /*
  1155. * Has ID 0x0038 when not in "Advanced Driver" mode;
  1156. * later revisions use IDs 0x0054 and 0x00a2.
  1157. */
  1158. USB_DEVICE(0x0582, 0x0037),
  1159. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1160. .vendor_name = "Roland",
  1161. .product_name = "Digital Piano",
  1162. .ifnum = 0,
  1163. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1164. .data = & (const struct snd_usb_midi_endpoint_info) {
  1165. .out_cables = 0x0001,
  1166. .in_cables = 0x0001
  1167. }
  1168. }
  1169. },
  1170. {
  1171. /*
  1172. * This quirk is for the "Advanced Driver" mode. If off, the GS-10
  1173. * has ID 0x003c and is standard compliant, but has only 16-bit PCM
  1174. * and no MIDI.
  1175. */
  1176. USB_DEVICE_VENDOR_SPEC(0x0582, 0x003b),
  1177. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1178. .vendor_name = "BOSS",
  1179. .product_name = "GS-10",
  1180. .ifnum = QUIRK_ANY_INTERFACE,
  1181. .type = QUIRK_COMPOSITE,
  1182. .data = & (const struct snd_usb_audio_quirk[]) {
  1183. {
  1184. .ifnum = 1,
  1185. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1186. },
  1187. {
  1188. .ifnum = 2,
  1189. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1190. },
  1191. {
  1192. .ifnum = 3,
  1193. .type = QUIRK_MIDI_STANDARD_INTERFACE
  1194. },
  1195. {
  1196. .ifnum = -1
  1197. }
  1198. }
  1199. }
  1200. },
  1201. {
  1202. /* has ID 0x0041 when not in "Advanced Driver" mode */
  1203. USB_DEVICE(0x0582, 0x0040),
  1204. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1205. .vendor_name = "Roland",
  1206. .product_name = "GI-20",
  1207. .ifnum = 0,
  1208. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1209. .data = & (const struct snd_usb_midi_endpoint_info) {
  1210. .out_cables = 0x0001,
  1211. .in_cables = 0x0001
  1212. }
  1213. }
  1214. },
  1215. {
  1216. /* has ID 0x0043 when not in "Advanced Driver" mode */
  1217. USB_DEVICE(0x0582, 0x0042),
  1218. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1219. .vendor_name = "Roland",
  1220. .product_name = "RS-70",
  1221. .ifnum = 0,
  1222. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1223. .data = & (const struct snd_usb_midi_endpoint_info) {
  1224. .out_cables = 0x0001,
  1225. .in_cables = 0x0001
  1226. }
  1227. }
  1228. },
  1229. {
  1230. /* has ID 0x0049 when not in "Advanced Driver" mode */
  1231. USB_DEVICE(0x0582, 0x0047),
  1232. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1233. /* .vendor_name = "EDIROL", */
  1234. /* .product_name = "UR-80", */
  1235. .ifnum = QUIRK_ANY_INTERFACE,
  1236. .type = QUIRK_COMPOSITE,
  1237. .data = (const struct snd_usb_audio_quirk[]) {
  1238. /* in the 96 kHz modes, only interface 1 is there */
  1239. {
  1240. .ifnum = 1,
  1241. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1242. },
  1243. {
  1244. .ifnum = 2,
  1245. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1246. },
  1247. {
  1248. .ifnum = -1
  1249. }
  1250. }
  1251. }
  1252. },
  1253. {
  1254. /* has ID 0x004a when not in "Advanced Driver" mode */
  1255. USB_DEVICE(0x0582, 0x0048),
  1256. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1257. /* .vendor_name = "EDIROL", */
  1258. /* .product_name = "UR-80", */
  1259. .ifnum = 0,
  1260. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1261. .data = & (const struct snd_usb_midi_endpoint_info) {
  1262. .out_cables = 0x0003,
  1263. .in_cables = 0x0007
  1264. }
  1265. }
  1266. },
  1267. {
  1268. /* has ID 0x004e when not in "Advanced Driver" mode */
  1269. USB_DEVICE(0x0582, 0x004c),
  1270. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1271. .vendor_name = "EDIROL",
  1272. .product_name = "PCR-A",
  1273. .ifnum = QUIRK_ANY_INTERFACE,
  1274. .type = QUIRK_COMPOSITE,
  1275. .data = (const struct snd_usb_audio_quirk[]) {
  1276. {
  1277. .ifnum = 1,
  1278. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1279. },
  1280. {
  1281. .ifnum = 2,
  1282. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1283. },
  1284. {
  1285. .ifnum = -1
  1286. }
  1287. }
  1288. }
  1289. },
  1290. {
  1291. /* has ID 0x004f when not in "Advanced Driver" mode */
  1292. USB_DEVICE(0x0582, 0x004d),
  1293. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1294. .vendor_name = "EDIROL",
  1295. .product_name = "PCR-A",
  1296. .ifnum = 0,
  1297. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1298. .data = & (const struct snd_usb_midi_endpoint_info) {
  1299. .out_cables = 0x0003,
  1300. .in_cables = 0x0007
  1301. }
  1302. }
  1303. },
  1304. {
  1305. /*
  1306. * This quirk is for the "Advanced Driver" mode. If off, the UA-3FX
  1307. * is standard compliant, but has only 16-bit PCM.
  1308. */
  1309. USB_DEVICE(0x0582, 0x0050),
  1310. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1311. .vendor_name = "EDIROL",
  1312. .product_name = "UA-3FX",
  1313. .ifnum = QUIRK_ANY_INTERFACE,
  1314. .type = QUIRK_COMPOSITE,
  1315. .data = (const struct snd_usb_audio_quirk[]) {
  1316. {
  1317. .ifnum = 1,
  1318. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1319. },
  1320. {
  1321. .ifnum = 2,
  1322. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1323. },
  1324. {
  1325. .ifnum = -1
  1326. }
  1327. }
  1328. }
  1329. },
  1330. {
  1331. USB_DEVICE(0x0582, 0x0052),
  1332. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1333. .vendor_name = "EDIROL",
  1334. .product_name = "UM-1SX",
  1335. .ifnum = 0,
  1336. .type = QUIRK_MIDI_STANDARD_INTERFACE
  1337. }
  1338. },
  1339. {
  1340. USB_DEVICE(0x0582, 0x0060),
  1341. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1342. .vendor_name = "Roland",
  1343. .product_name = "EXR Series",
  1344. .ifnum = 0,
  1345. .type = QUIRK_MIDI_STANDARD_INTERFACE
  1346. }
  1347. },
  1348. {
  1349. /* has ID 0x0066 when not in "Advanced Driver" mode */
  1350. USB_DEVICE(0x0582, 0x0064),
  1351. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1352. /* .vendor_name = "EDIROL", */
  1353. /* .product_name = "PCR-1", */
  1354. .ifnum = QUIRK_ANY_INTERFACE,
  1355. .type = QUIRK_COMPOSITE,
  1356. .data = (const struct snd_usb_audio_quirk[]) {
  1357. {
  1358. .ifnum = 1,
  1359. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1360. },
  1361. {
  1362. .ifnum = 2,
  1363. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1364. },
  1365. {
  1366. .ifnum = -1
  1367. }
  1368. }
  1369. }
  1370. },
  1371. {
  1372. /* has ID 0x0067 when not in "Advanced Driver" mode */
  1373. USB_DEVICE(0x0582, 0x0065),
  1374. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1375. /* .vendor_name = "EDIROL", */
  1376. /* .product_name = "PCR-1", */
  1377. .ifnum = 0,
  1378. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1379. .data = & (const struct snd_usb_midi_endpoint_info) {
  1380. .out_cables = 0x0001,
  1381. .in_cables = 0x0003
  1382. }
  1383. }
  1384. },
  1385. {
  1386. /* has ID 0x006e when not in "Advanced Driver" mode */
  1387. USB_DEVICE(0x0582, 0x006d),
  1388. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1389. .vendor_name = "Roland",
  1390. .product_name = "FANTOM-X",
  1391. .ifnum = 0,
  1392. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1393. .data = & (const struct snd_usb_midi_endpoint_info) {
  1394. .out_cables = 0x0001,
  1395. .in_cables = 0x0001
  1396. }
  1397. }
  1398. },
  1399. { /*
  1400. * This quirk is for the "Advanced" modes of the Edirol UA-25.
  1401. * If the switch is not in an advanced setting, the UA-25 has
  1402. * ID 0x0582/0x0073 and is standard compliant (no quirks), but
  1403. * offers only 16-bit PCM at 44.1 kHz and no MIDI.
  1404. */
  1405. USB_DEVICE_VENDOR_SPEC(0x0582, 0x0074),
  1406. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1407. .vendor_name = "EDIROL",
  1408. .product_name = "UA-25",
  1409. .ifnum = QUIRK_ANY_INTERFACE,
  1410. .type = QUIRK_COMPOSITE,
  1411. .data = (const struct snd_usb_audio_quirk[]) {
  1412. {
  1413. .ifnum = 0,
  1414. .type = QUIRK_AUDIO_EDIROL_UAXX
  1415. },
  1416. {
  1417. .ifnum = 1,
  1418. .type = QUIRK_AUDIO_EDIROL_UAXX
  1419. },
  1420. {
  1421. .ifnum = 2,
  1422. .type = QUIRK_AUDIO_EDIROL_UAXX
  1423. },
  1424. {
  1425. .ifnum = -1
  1426. }
  1427. }
  1428. }
  1429. },
  1430. {
  1431. /* has ID 0x0076 when not in "Advanced Driver" mode */
  1432. USB_DEVICE(0x0582, 0x0075),
  1433. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1434. .vendor_name = "BOSS",
  1435. .product_name = "DR-880",
  1436. .ifnum = 0,
  1437. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1438. .data = & (const struct snd_usb_midi_endpoint_info) {
  1439. .out_cables = 0x0001,
  1440. .in_cables = 0x0001
  1441. }
  1442. }
  1443. },
  1444. {
  1445. /* has ID 0x007b when not in "Advanced Driver" mode */
  1446. USB_DEVICE_VENDOR_SPEC(0x0582, 0x007a),
  1447. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1448. .vendor_name = "Roland",
  1449. /* "RD" or "RD-700SX"? */
  1450. .ifnum = 0,
  1451. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1452. .data = & (const struct snd_usb_midi_endpoint_info) {
  1453. .out_cables = 0x0003,
  1454. .in_cables = 0x0003
  1455. }
  1456. }
  1457. },
  1458. {
  1459. /* has ID 0x0081 when not in "Advanced Driver" mode */
  1460. USB_DEVICE(0x0582, 0x0080),
  1461. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1462. .vendor_name = "Roland",
  1463. .product_name = "G-70",
  1464. .ifnum = 0,
  1465. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1466. .data = & (const struct snd_usb_midi_endpoint_info) {
  1467. .out_cables = 0x0001,
  1468. .in_cables = 0x0001
  1469. }
  1470. }
  1471. },
  1472. {
  1473. /* has ID 0x008c when not in "Advanced Driver" mode */
  1474. USB_DEVICE(0x0582, 0x008b),
  1475. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1476. .vendor_name = "EDIROL",
  1477. .product_name = "PC-50",
  1478. .ifnum = 0,
  1479. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1480. .data = & (const struct snd_usb_midi_endpoint_info) {
  1481. .out_cables = 0x0001,
  1482. .in_cables = 0x0001
  1483. }
  1484. }
  1485. },
  1486. {
  1487. /*
  1488. * This quirk is for the "Advanced Driver" mode. If off, the UA-4FX
  1489. * is standard compliant, but has only 16-bit PCM and no MIDI.
  1490. */
  1491. USB_DEVICE(0x0582, 0x00a3),
  1492. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1493. .vendor_name = "EDIROL",
  1494. .product_name = "UA-4FX",
  1495. .ifnum = QUIRK_ANY_INTERFACE,
  1496. .type = QUIRK_COMPOSITE,
  1497. .data = (const struct snd_usb_audio_quirk[]) {
  1498. {
  1499. .ifnum = 0,
  1500. .type = QUIRK_AUDIO_EDIROL_UAXX
  1501. },
  1502. {
  1503. .ifnum = 1,
  1504. .type = QUIRK_AUDIO_EDIROL_UAXX
  1505. },
  1506. {
  1507. .ifnum = 2,
  1508. .type = QUIRK_AUDIO_EDIROL_UAXX
  1509. },
  1510. {
  1511. .ifnum = -1
  1512. }
  1513. }
  1514. }
  1515. },
  1516. {
  1517. /* Edirol M-16DX */
  1518. USB_DEVICE(0x0582, 0x00c4),
  1519. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1520. .ifnum = QUIRK_ANY_INTERFACE,
  1521. .type = QUIRK_COMPOSITE,
  1522. .data = (const struct snd_usb_audio_quirk[]) {
  1523. {
  1524. .ifnum = 0,
  1525. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1526. },
  1527. {
  1528. .ifnum = 1,
  1529. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1530. },
  1531. {
  1532. .ifnum = 2,
  1533. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1534. .data = & (const struct snd_usb_midi_endpoint_info) {
  1535. .out_cables = 0x0001,
  1536. .in_cables = 0x0001
  1537. }
  1538. },
  1539. {
  1540. .ifnum = -1
  1541. }
  1542. }
  1543. }
  1544. },
  1545. {
  1546. /* Advanced modes of the Edirol UA-25EX.
  1547. * For the standard mode, UA-25EX has ID 0582:00e7, which
  1548. * offers only 16-bit PCM at 44.1 kHz and no MIDI.
  1549. */
  1550. USB_DEVICE_VENDOR_SPEC(0x0582, 0x00e6),
  1551. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1552. .vendor_name = "EDIROL",
  1553. .product_name = "UA-25EX",
  1554. .ifnum = QUIRK_ANY_INTERFACE,
  1555. .type = QUIRK_COMPOSITE,
  1556. .data = (const struct snd_usb_audio_quirk[]) {
  1557. {
  1558. .ifnum = 0,
  1559. .type = QUIRK_AUDIO_EDIROL_UAXX
  1560. },
  1561. {
  1562. .ifnum = 1,
  1563. .type = QUIRK_AUDIO_EDIROL_UAXX
  1564. },
  1565. {
  1566. .ifnum = 2,
  1567. .type = QUIRK_AUDIO_EDIROL_UAXX
  1568. },
  1569. {
  1570. .ifnum = -1
  1571. }
  1572. }
  1573. }
  1574. },
  1575. {
  1576. /* Edirol UM-3G */
  1577. USB_DEVICE_VENDOR_SPEC(0x0582, 0x0108),
  1578. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1579. .ifnum = 0,
  1580. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1581. .data = & (const struct snd_usb_midi_endpoint_info) {
  1582. .out_cables = 0x0007,
  1583. .in_cables = 0x0007
  1584. }
  1585. }
  1586. },
  1587. {
  1588. /* BOSS ME-25 */
  1589. USB_DEVICE(0x0582, 0x0113),
  1590. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1591. .ifnum = QUIRK_ANY_INTERFACE,
  1592. .type = QUIRK_COMPOSITE,
  1593. .data = (const struct snd_usb_audio_quirk[]) {
  1594. {
  1595. .ifnum = 0,
  1596. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1597. },
  1598. {
  1599. .ifnum = 1,
  1600. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1601. },
  1602. {
  1603. .ifnum = 2,
  1604. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1605. .data = & (const struct snd_usb_midi_endpoint_info) {
  1606. .out_cables = 0x0001,
  1607. .in_cables = 0x0001
  1608. }
  1609. },
  1610. {
  1611. .ifnum = -1
  1612. }
  1613. }
  1614. }
  1615. },
  1616. {
  1617. /* only 44.1 kHz works at the moment */
  1618. USB_DEVICE(0x0582, 0x0120),
  1619. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1620. /* .vendor_name = "Roland", */
  1621. /* .product_name = "OCTO-CAPTURE", */
  1622. .ifnum = QUIRK_ANY_INTERFACE,
  1623. .type = QUIRK_COMPOSITE,
  1624. .data = (const struct snd_usb_audio_quirk[]) {
  1625. {
  1626. .ifnum = 0,
  1627. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  1628. .data = & (const struct audioformat) {
  1629. .formats = SNDRV_PCM_FMTBIT_S32_LE,
  1630. .channels = 10,
  1631. .iface = 0,
  1632. .altsetting = 1,
  1633. .altset_idx = 1,
  1634. .endpoint = 0x05,
  1635. .ep_attr = 0x05,
  1636. .rates = SNDRV_PCM_RATE_44100,
  1637. .rate_min = 44100,
  1638. .rate_max = 44100,
  1639. .nr_rates = 1,
  1640. .rate_table = (unsigned int[]) { 44100 }
  1641. }
  1642. },
  1643. {
  1644. .ifnum = 1,
  1645. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  1646. .data = & (const struct audioformat) {
  1647. .formats = SNDRV_PCM_FMTBIT_S32_LE,
  1648. .channels = 12,
  1649. .iface = 1,
  1650. .altsetting = 1,
  1651. .altset_idx = 1,
  1652. .endpoint = 0x85,
  1653. .ep_attr = 0x25,
  1654. .rates = SNDRV_PCM_RATE_44100,
  1655. .rate_min = 44100,
  1656. .rate_max = 44100,
  1657. .nr_rates = 1,
  1658. .rate_table = (unsigned int[]) { 44100 }
  1659. }
  1660. },
  1661. {
  1662. .ifnum = 2,
  1663. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1664. .data = & (const struct snd_usb_midi_endpoint_info) {
  1665. .out_cables = 0x0001,
  1666. .in_cables = 0x0001
  1667. }
  1668. },
  1669. {
  1670. .ifnum = 3,
  1671. .type = QUIRK_IGNORE_INTERFACE
  1672. },
  1673. {
  1674. .ifnum = 4,
  1675. .type = QUIRK_IGNORE_INTERFACE
  1676. },
  1677. {
  1678. .ifnum = -1
  1679. }
  1680. }
  1681. }
  1682. },
  1683. {
  1684. /* only 44.1 kHz works at the moment */
  1685. USB_DEVICE(0x0582, 0x012f),
  1686. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1687. /* .vendor_name = "Roland", */
  1688. /* .product_name = "QUAD-CAPTURE", */
  1689. .ifnum = QUIRK_ANY_INTERFACE,
  1690. .type = QUIRK_COMPOSITE,
  1691. .data = (const struct snd_usb_audio_quirk[]) {
  1692. {
  1693. .ifnum = 0,
  1694. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  1695. .data = & (const struct audioformat) {
  1696. .formats = SNDRV_PCM_FMTBIT_S32_LE,
  1697. .channels = 4,
  1698. .iface = 0,
  1699. .altsetting = 1,
  1700. .altset_idx = 1,
  1701. .endpoint = 0x05,
  1702. .ep_attr = 0x05,
  1703. .rates = SNDRV_PCM_RATE_44100,
  1704. .rate_min = 44100,
  1705. .rate_max = 44100,
  1706. .nr_rates = 1,
  1707. .rate_table = (unsigned int[]) { 44100 }
  1708. }
  1709. },
  1710. {
  1711. .ifnum = 1,
  1712. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  1713. .data = & (const struct audioformat) {
  1714. .formats = SNDRV_PCM_FMTBIT_S32_LE,
  1715. .channels = 6,
  1716. .iface = 1,
  1717. .altsetting = 1,
  1718. .altset_idx = 1,
  1719. .endpoint = 0x85,
  1720. .ep_attr = 0x25,
  1721. .rates = SNDRV_PCM_RATE_44100,
  1722. .rate_min = 44100,
  1723. .rate_max = 44100,
  1724. .nr_rates = 1,
  1725. .rate_table = (unsigned int[]) { 44100 }
  1726. }
  1727. },
  1728. {
  1729. .ifnum = 2,
  1730. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1731. .data = & (const struct snd_usb_midi_endpoint_info) {
  1732. .out_cables = 0x0001,
  1733. .in_cables = 0x0001
  1734. }
  1735. },
  1736. {
  1737. .ifnum = 3,
  1738. .type = QUIRK_IGNORE_INTERFACE
  1739. },
  1740. {
  1741. .ifnum = 4,
  1742. .type = QUIRK_IGNORE_INTERFACE
  1743. },
  1744. {
  1745. .ifnum = -1
  1746. }
  1747. }
  1748. }
  1749. },
  1750. {
  1751. USB_DEVICE(0x0582, 0x0159),
  1752. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1753. /* .vendor_name = "Roland", */
  1754. /* .product_name = "UA-22", */
  1755. .ifnum = QUIRK_ANY_INTERFACE,
  1756. .type = QUIRK_COMPOSITE,
  1757. .data = (const struct snd_usb_audio_quirk[]) {
  1758. {
  1759. .ifnum = 0,
  1760. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1761. },
  1762. {
  1763. .ifnum = 1,
  1764. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1765. },
  1766. {
  1767. .ifnum = 2,
  1768. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1769. .data = & (const struct snd_usb_midi_endpoint_info) {
  1770. .out_cables = 0x0001,
  1771. .in_cables = 0x0001
  1772. }
  1773. },
  1774. {
  1775. .ifnum = -1
  1776. }
  1777. }
  1778. }
  1779. },
  1780. /* this catches most recent vendor-specific Roland devices */
  1781. {
  1782. .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
  1783. USB_DEVICE_ID_MATCH_INT_CLASS,
  1784. .idVendor = 0x0582,
  1785. .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
  1786. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  1787. .ifnum = QUIRK_ANY_INTERFACE,
  1788. .type = QUIRK_AUTODETECT
  1789. }
  1790. },
  1791.  
  1792. /* Guillemot devices */
  1793. {
  1794. /*
  1795. * This is for the "Windows Edition" where the external MIDI ports are
  1796. * the only MIDI ports; the control data is reported through HID
  1797. * interfaces. The "Macintosh Edition" has ID 0xd002 and uses standard
  1798. * compliant USB MIDI ports for external MIDI and controls.
  1799. */
  1800. USB_DEVICE_VENDOR_SPEC(0x06f8, 0xb000),
  1801. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1802. .vendor_name = "Hercules",
  1803. .product_name = "DJ Console (WE)",
  1804. .ifnum = 4,
  1805. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  1806. .data = & (const struct snd_usb_midi_endpoint_info) {
  1807. .out_cables = 0x0001,
  1808. .in_cables = 0x0001
  1809. }
  1810. }
  1811. },
  1812.  
  1813. /* Midiman/M-Audio devices */
  1814. {
  1815. USB_DEVICE_VENDOR_SPEC(0x0763, 0x1002),
  1816. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1817. .vendor_name = "M-Audio",
  1818. .product_name = "MidiSport 2x2",
  1819. .ifnum = QUIRK_ANY_INTERFACE,
  1820. .type = QUIRK_MIDI_MIDIMAN,
  1821. .data = & (const struct snd_usb_midi_endpoint_info) {
  1822. .out_cables = 0x0003,
  1823. .in_cables = 0x0003
  1824. }
  1825. }
  1826. },
  1827. {
  1828. USB_DEVICE_VENDOR_SPEC(0x0763, 0x1011),
  1829. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1830. .vendor_name = "M-Audio",
  1831. .product_name = "MidiSport 1x1",
  1832. .ifnum = QUIRK_ANY_INTERFACE,
  1833. .type = QUIRK_MIDI_MIDIMAN,
  1834. .data = & (const struct snd_usb_midi_endpoint_info) {
  1835. .out_cables = 0x0001,
  1836. .in_cables = 0x0001
  1837. }
  1838. }
  1839. },
  1840. {
  1841. USB_DEVICE_VENDOR_SPEC(0x0763, 0x1015),
  1842. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1843. .vendor_name = "M-Audio",
  1844. .product_name = "Keystation",
  1845. .ifnum = QUIRK_ANY_INTERFACE,
  1846. .type = QUIRK_MIDI_MIDIMAN,
  1847. .data = & (const struct snd_usb_midi_endpoint_info) {
  1848. .out_cables = 0x0001,
  1849. .in_cables = 0x0001
  1850. }
  1851. }
  1852. },
  1853. {
  1854. USB_DEVICE_VENDOR_SPEC(0x0763, 0x1021),
  1855. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1856. .vendor_name = "M-Audio",
  1857. .product_name = "MidiSport 4x4",
  1858. .ifnum = QUIRK_ANY_INTERFACE,
  1859. .type = QUIRK_MIDI_MIDIMAN,
  1860. .data = & (const struct snd_usb_midi_endpoint_info) {
  1861. .out_cables = 0x000f,
  1862. .in_cables = 0x000f
  1863. }
  1864. }
  1865. },
  1866. {
  1867. /*
  1868. * For hardware revision 1.05; in the later revisions (1.10 and
  1869. * 1.21), 0x1031 is the ID for the device without firmware.
  1870. * Thanks to Olaf Giesbrecht <Olaf_Giesbrecht@yahoo.de>
  1871. */
  1872. USB_DEVICE_VER(0x0763, 0x1031, 0x0100, 0x0109),
  1873. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1874. .vendor_name = "M-Audio",
  1875. .product_name = "MidiSport 8x8",
  1876. .ifnum = QUIRK_ANY_INTERFACE,
  1877. .type = QUIRK_MIDI_MIDIMAN,
  1878. .data = & (const struct snd_usb_midi_endpoint_info) {
  1879. .out_cables = 0x01ff,
  1880. .in_cables = 0x01ff
  1881. }
  1882. }
  1883. },
  1884. {
  1885. USB_DEVICE_VENDOR_SPEC(0x0763, 0x1033),
  1886. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1887. .vendor_name = "M-Audio",
  1888. .product_name = "MidiSport 8x8",
  1889. .ifnum = QUIRK_ANY_INTERFACE,
  1890. .type = QUIRK_MIDI_MIDIMAN,
  1891. .data = & (const struct snd_usb_midi_endpoint_info) {
  1892. .out_cables = 0x01ff,
  1893. .in_cables = 0x01ff
  1894. }
  1895. }
  1896. },
  1897. {
  1898. USB_DEVICE_VENDOR_SPEC(0x0763, 0x1041),
  1899. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1900. .vendor_name = "M-Audio",
  1901. .product_name = "MidiSport 2x4",
  1902. .ifnum = QUIRK_ANY_INTERFACE,
  1903. .type = QUIRK_MIDI_MIDIMAN,
  1904. .data = & (const struct snd_usb_midi_endpoint_info) {
  1905. .out_cables = 0x000f,
  1906. .in_cables = 0x0003
  1907. }
  1908. }
  1909. },
  1910. {
  1911. USB_DEVICE_VENDOR_SPEC(0x0763, 0x2001),
  1912. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1913. .vendor_name = "M-Audio",
  1914. .product_name = "Quattro",
  1915. .ifnum = QUIRK_ANY_INTERFACE,
  1916. .type = QUIRK_COMPOSITE,
  1917. .data = & (const struct snd_usb_audio_quirk[]) {
  1918. /*
  1919. * Interfaces 0-2 are "Windows-compatible", 16-bit only,
  1920. * and share endpoints with the other interfaces.
  1921. * Ignore them. The other interfaces can do 24 bits,
  1922. * but captured samples are big-endian (see usbaudio.c).
  1923. */
  1924. {
  1925. .ifnum = 0,
  1926. .type = QUIRK_IGNORE_INTERFACE
  1927. },
  1928. {
  1929. .ifnum = 1,
  1930. .type = QUIRK_IGNORE_INTERFACE
  1931. },
  1932. {
  1933. .ifnum = 2,
  1934. .type = QUIRK_IGNORE_INTERFACE
  1935. },
  1936. {
  1937. .ifnum = 3,
  1938. .type = QUIRK_IGNORE_INTERFACE
  1939. },
  1940. {
  1941. .ifnum = 4,
  1942. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1943. },
  1944. {
  1945. .ifnum = 5,
  1946. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1947. },
  1948. {
  1949. .ifnum = 6,
  1950. .type = QUIRK_IGNORE_INTERFACE
  1951. },
  1952. {
  1953. .ifnum = 7,
  1954. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1955. },
  1956. {
  1957. .ifnum = 8,
  1958. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  1959. },
  1960. {
  1961. .ifnum = 9,
  1962. .type = QUIRK_MIDI_MIDIMAN,
  1963. .data = & (const struct snd_usb_midi_endpoint_info) {
  1964. .out_cables = 0x0001,
  1965. .in_cables = 0x0001
  1966. }
  1967. },
  1968. {
  1969. .ifnum = -1
  1970. }
  1971. }
  1972. }
  1973. },
  1974. {
  1975. USB_DEVICE_VENDOR_SPEC(0x0763, 0x2003),
  1976. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1977. .vendor_name = "M-Audio",
  1978. .product_name = "AudioPhile",
  1979. .ifnum = 6,
  1980. .type = QUIRK_MIDI_MIDIMAN,
  1981. .data = & (const struct snd_usb_midi_endpoint_info) {
  1982. .out_cables = 0x0001,
  1983. .in_cables = 0x0001
  1984. }
  1985. }
  1986. },
  1987. {
  1988. USB_DEVICE_VENDOR_SPEC(0x0763, 0x2008),
  1989. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  1990. .vendor_name = "M-Audio",
  1991. .product_name = "Ozone",
  1992. .ifnum = 3,
  1993. .type = QUIRK_MIDI_MIDIMAN,
  1994. .data = & (const struct snd_usb_midi_endpoint_info) {
  1995. .out_cables = 0x0001,
  1996. .in_cables = 0x0001
  1997. }
  1998. }
  1999. },
  2000. {
  2001. USB_DEVICE_VENDOR_SPEC(0x0763, 0x200d),
  2002. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2003. .vendor_name = "M-Audio",
  2004. .product_name = "OmniStudio",
  2005. .ifnum = QUIRK_ANY_INTERFACE,
  2006. .type = QUIRK_COMPOSITE,
  2007. .data = & (const struct snd_usb_audio_quirk[]) {
  2008. {
  2009. .ifnum = 0,
  2010. .type = QUIRK_IGNORE_INTERFACE
  2011. },
  2012. {
  2013. .ifnum = 1,
  2014. .type = QUIRK_IGNORE_INTERFACE
  2015. },
  2016. {
  2017. .ifnum = 2,
  2018. .type = QUIRK_IGNORE_INTERFACE
  2019. },
  2020. {
  2021. .ifnum = 3,
  2022. .type = QUIRK_IGNORE_INTERFACE
  2023. },
  2024. {
  2025. .ifnum = 4,
  2026. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2027. },
  2028. {
  2029. .ifnum = 5,
  2030. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2031. },
  2032. {
  2033. .ifnum = 6,
  2034. .type = QUIRK_IGNORE_INTERFACE
  2035. },
  2036. {
  2037. .ifnum = 7,
  2038. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2039. },
  2040. {
  2041. .ifnum = 8,
  2042. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2043. },
  2044. {
  2045. .ifnum = 9,
  2046. .type = QUIRK_MIDI_MIDIMAN,
  2047. .data = & (const struct snd_usb_midi_endpoint_info) {
  2048. .out_cables = 0x0001,
  2049. .in_cables = 0x0001
  2050. }
  2051. },
  2052. {
  2053. .ifnum = -1
  2054. }
  2055. }
  2056. }
  2057. },
  2058. {
  2059. USB_DEVICE(0x0763, 0x2019),
  2060. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2061. /* .vendor_name = "M-Audio", */
  2062. /* .product_name = "Ozone Academic", */
  2063. .ifnum = QUIRK_ANY_INTERFACE,
  2064. .type = QUIRK_COMPOSITE,
  2065. .data = & (const struct snd_usb_audio_quirk[]) {
  2066. {
  2067. .ifnum = 0,
  2068. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2069. },
  2070. {
  2071. .ifnum = 1,
  2072. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2073. },
  2074. {
  2075. .ifnum = 2,
  2076. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2077. },
  2078. {
  2079. .ifnum = 3,
  2080. .type = QUIRK_MIDI_MIDIMAN,
  2081. .data = & (const struct snd_usb_midi_endpoint_info) {
  2082. .out_cables = 0x0001,
  2083. .in_cables = 0x0001
  2084. }
  2085. },
  2086. {
  2087. .ifnum = -1
  2088. }
  2089. }
  2090. }
  2091. },
  2092. {
  2093. USB_DEVICE_VENDOR_SPEC(0x0763, 0x2030),
  2094. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  2095. /* .vendor_name = "M-Audio", */
  2096. /* .product_name = "Fast Track C400", */
  2097. .ifnum = QUIRK_ANY_INTERFACE,
  2098. .type = QUIRK_COMPOSITE,
  2099. .data = &(const struct snd_usb_audio_quirk[]) {
  2100. {
  2101. .ifnum = 1,
  2102. .type = QUIRK_AUDIO_STANDARD_MIXER,
  2103. },
  2104. /* Playback */
  2105. {
  2106. .ifnum = 2,
  2107. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2108. .data = &(const struct audioformat) {
  2109. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  2110. .channels = 6,
  2111. .iface = 2,
  2112. .altsetting = 1,
  2113. .altset_idx = 1,
  2114. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  2115. .endpoint = 0x01,
  2116. .ep_attr = 0x09,
  2117. .rates = SNDRV_PCM_RATE_44100 |
  2118. SNDRV_PCM_RATE_48000 |
  2119. SNDRV_PCM_RATE_88200 |
  2120. SNDRV_PCM_RATE_96000,
  2121. .rate_min = 44100,
  2122. .rate_max = 96000,
  2123. .nr_rates = 4,
  2124. .rate_table = (unsigned int[]) {
  2125. 44100, 48000, 88200, 96000
  2126. },
  2127. .clock = 0x80,
  2128. }
  2129. },
  2130. /* Capture */
  2131. {
  2132. .ifnum = 3,
  2133. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2134. .data = &(const struct audioformat) {
  2135. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  2136. .channels = 4,
  2137. .iface = 3,
  2138. .altsetting = 1,
  2139. .altset_idx = 1,
  2140. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  2141. .endpoint = 0x81,
  2142. .ep_attr = 0x05,
  2143. .rates = SNDRV_PCM_RATE_44100 |
  2144. SNDRV_PCM_RATE_48000 |
  2145. SNDRV_PCM_RATE_88200 |
  2146. SNDRV_PCM_RATE_96000,
  2147. .rate_min = 44100,
  2148. .rate_max = 96000,
  2149. .nr_rates = 4,
  2150. .rate_table = (unsigned int[]) {
  2151. 44100, 48000, 88200, 96000
  2152. },
  2153. .clock = 0x80,
  2154. }
  2155. },
  2156. /* MIDI */
  2157. {
  2158. .ifnum = -1 /* Interface = 4 */
  2159. }
  2160. }
  2161. }
  2162. },
  2163. {
  2164. USB_DEVICE_VENDOR_SPEC(0x0763, 0x2031),
  2165. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  2166. /* .vendor_name = "M-Audio", */
  2167. /* .product_name = "Fast Track C600", */
  2168. .ifnum = QUIRK_ANY_INTERFACE,
  2169. .type = QUIRK_COMPOSITE,
  2170. .data = &(const struct snd_usb_audio_quirk[]) {
  2171. {
  2172. .ifnum = 1,
  2173. .type = QUIRK_AUDIO_STANDARD_MIXER,
  2174. },
  2175. /* Playback */
  2176. {
  2177. .ifnum = 2,
  2178. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2179. .data = &(const struct audioformat) {
  2180. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  2181. .channels = 8,
  2182. .iface = 2,
  2183. .altsetting = 1,
  2184. .altset_idx = 1,
  2185. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  2186. .endpoint = 0x01,
  2187. .ep_attr = 0x09,
  2188. .rates = SNDRV_PCM_RATE_44100 |
  2189. SNDRV_PCM_RATE_48000 |
  2190. SNDRV_PCM_RATE_88200 |
  2191. SNDRV_PCM_RATE_96000,
  2192. .rate_min = 44100,
  2193. .rate_max = 96000,
  2194. .nr_rates = 4,
  2195. .rate_table = (unsigned int[]) {
  2196. 44100, 48000, 88200, 96000
  2197. },
  2198. .clock = 0x80,
  2199. }
  2200. },
  2201. /* Capture */
  2202. {
  2203. .ifnum = 3,
  2204. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2205. .data = &(const struct audioformat) {
  2206. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  2207. .channels = 6,
  2208. .iface = 3,
  2209. .altsetting = 1,
  2210. .altset_idx = 1,
  2211. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  2212. .endpoint = 0x81,
  2213. .ep_attr = 0x05,
  2214. .rates = SNDRV_PCM_RATE_44100 |
  2215. SNDRV_PCM_RATE_48000 |
  2216. SNDRV_PCM_RATE_88200 |
  2217. SNDRV_PCM_RATE_96000,
  2218. .rate_min = 44100,
  2219. .rate_max = 96000,
  2220. .nr_rates = 4,
  2221. .rate_table = (unsigned int[]) {
  2222. 44100, 48000, 88200, 96000
  2223. },
  2224. .clock = 0x80,
  2225. }
  2226. },
  2227. /* MIDI */
  2228. {
  2229. .ifnum = -1 /* Interface = 4 */
  2230. }
  2231. }
  2232. }
  2233. },
  2234. {
  2235. USB_DEVICE_VENDOR_SPEC(0x0763, 0x2080),
  2236. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2237. /* .vendor_name = "M-Audio", */
  2238. /* .product_name = "Fast Track Ultra", */
  2239. .ifnum = QUIRK_ANY_INTERFACE,
  2240. .type = QUIRK_COMPOSITE,
  2241. .data = & (const struct snd_usb_audio_quirk[]) {
  2242. {
  2243. .ifnum = 0,
  2244. .type = QUIRK_AUDIO_STANDARD_MIXER,
  2245. },
  2246. {
  2247. .ifnum = 1,
  2248. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2249. .data = & (const struct audioformat) {
  2250. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  2251. .channels = 8,
  2252. .iface = 1,
  2253. .altsetting = 1,
  2254. .altset_idx = 1,
  2255. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  2256. .endpoint = 0x01,
  2257. .ep_attr = 0x09,
  2258. .rates = SNDRV_PCM_RATE_44100 |
  2259. SNDRV_PCM_RATE_48000 |
  2260. SNDRV_PCM_RATE_88200 |
  2261. SNDRV_PCM_RATE_96000,
  2262. .rate_min = 44100,
  2263. .rate_max = 96000,
  2264. .nr_rates = 4,
  2265. .rate_table = (unsigned int[]) {
  2266. 44100, 48000, 88200, 96000
  2267. }
  2268. }
  2269. },
  2270. {
  2271. .ifnum = 2,
  2272. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2273. .data = & (const struct audioformat) {
  2274. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  2275. .channels = 8,
  2276. .iface = 2,
  2277. .altsetting = 1,
  2278. .altset_idx = 1,
  2279. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  2280. .endpoint = 0x81,
  2281. .ep_attr = 0x05,
  2282. .rates = SNDRV_PCM_RATE_44100 |
  2283. SNDRV_PCM_RATE_48000 |
  2284. SNDRV_PCM_RATE_88200 |
  2285. SNDRV_PCM_RATE_96000,
  2286. .rate_min = 44100,
  2287. .rate_max = 96000,
  2288. .nr_rates = 4,
  2289. .rate_table = (unsigned int[]) {
  2290. 44100, 48000, 88200, 96000
  2291. }
  2292. }
  2293. },
  2294. /* interface 3 (MIDI) is standard compliant */
  2295. {
  2296. .ifnum = -1
  2297. }
  2298. }
  2299. }
  2300. },
  2301. {
  2302. USB_DEVICE_VENDOR_SPEC(0x0763, 0x2081),
  2303. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2304. /* .vendor_name = "M-Audio", */
  2305. /* .product_name = "Fast Track Ultra 8R", */
  2306. .ifnum = QUIRK_ANY_INTERFACE,
  2307. .type = QUIRK_COMPOSITE,
  2308. .data = & (const struct snd_usb_audio_quirk[]) {
  2309. {
  2310. .ifnum = 0,
  2311. .type = QUIRK_AUDIO_STANDARD_MIXER,
  2312. },
  2313. {
  2314. .ifnum = 1,
  2315. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2316. .data = & (const struct audioformat) {
  2317. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  2318. .channels = 8,
  2319. .iface = 1,
  2320. .altsetting = 1,
  2321. .altset_idx = 1,
  2322. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  2323. .endpoint = 0x01,
  2324. .ep_attr = 0x09,
  2325. .rates = SNDRV_PCM_RATE_44100 |
  2326. SNDRV_PCM_RATE_48000 |
  2327. SNDRV_PCM_RATE_88200 |
  2328. SNDRV_PCM_RATE_96000,
  2329. .rate_min = 44100,
  2330. .rate_max = 96000,
  2331. .nr_rates = 4,
  2332. .rate_table = (unsigned int[]) {
  2333. 44100, 48000, 88200, 96000
  2334. }
  2335. }
  2336. },
  2337. {
  2338. .ifnum = 2,
  2339. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2340. .data = & (const struct audioformat) {
  2341. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  2342. .channels = 8,
  2343. .iface = 2,
  2344. .altsetting = 1,
  2345. .altset_idx = 1,
  2346. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  2347. .endpoint = 0x81,
  2348. .ep_attr = 0x05,
  2349. .rates = SNDRV_PCM_RATE_44100 |
  2350. SNDRV_PCM_RATE_48000 |
  2351. SNDRV_PCM_RATE_88200 |
  2352. SNDRV_PCM_RATE_96000,
  2353. .rate_min = 44100,
  2354. .rate_max = 96000,
  2355. .nr_rates = 4,
  2356. .rate_table = (unsigned int[]) {
  2357. 44100, 48000, 88200, 96000
  2358. }
  2359. }
  2360. },
  2361. /* interface 3 (MIDI) is standard compliant */
  2362. {
  2363. .ifnum = -1
  2364. }
  2365. }
  2366. }
  2367. },
  2368.  
  2369. /* Casio devices */
  2370. {
  2371. USB_DEVICE(0x07cf, 0x6801),
  2372. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2373. .vendor_name = "Casio",
  2374. .product_name = "PL-40R",
  2375. .ifnum = 0,
  2376. .type = QUIRK_MIDI_YAMAHA
  2377. }
  2378. },
  2379. {
  2380. /* this ID is used by several devices without a product ID */
  2381. USB_DEVICE(0x07cf, 0x6802),
  2382. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2383. .vendor_name = "Casio",
  2384. .product_name = "Keyboard",
  2385. .ifnum = 0,
  2386. .type = QUIRK_MIDI_YAMAHA
  2387. }
  2388. },
  2389.  
  2390. /* Mark of the Unicorn devices */
  2391. {
  2392. /* thanks to Robert A. Lerche <ral 'at' msbit.com> */
  2393. .match_flags = USB_DEVICE_ID_MATCH_VENDOR |
  2394. USB_DEVICE_ID_MATCH_PRODUCT |
  2395. USB_DEVICE_ID_MATCH_DEV_SUBCLASS,
  2396. .idVendor = 0x07fd,
  2397. .idProduct = 0x0001,
  2398. .bDeviceSubClass = 2,
  2399. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2400. .vendor_name = "MOTU",
  2401. .product_name = "Fastlane",
  2402. .ifnum = QUIRK_ANY_INTERFACE,
  2403. .type = QUIRK_COMPOSITE,
  2404. .data = & (const struct snd_usb_audio_quirk[]) {
  2405. {
  2406. .ifnum = 0,
  2407. .type = QUIRK_MIDI_RAW_BYTES
  2408. },
  2409. {
  2410. .ifnum = 1,
  2411. .type = QUIRK_IGNORE_INTERFACE
  2412. },
  2413. {
  2414. .ifnum = -1
  2415. }
  2416. }
  2417. }
  2418. },
  2419.  
  2420. /* Emagic devices */
  2421. {
  2422. USB_DEVICE(0x086a, 0x0001),
  2423. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2424. .vendor_name = "Emagic",
  2425. /* .product_name = "Unitor8", */
  2426. .ifnum = 2,
  2427. .type = QUIRK_MIDI_EMAGIC,
  2428. .data = & (const struct snd_usb_midi_endpoint_info) {
  2429. .out_cables = 0x80ff,
  2430. .in_cables = 0x80ff
  2431. }
  2432. }
  2433. },
  2434. {
  2435. USB_DEVICE(0x086a, 0x0002),
  2436. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2437. .vendor_name = "Emagic",
  2438. /* .product_name = "AMT8", */
  2439. .ifnum = 2,
  2440. .type = QUIRK_MIDI_EMAGIC,
  2441. .data = & (const struct snd_usb_midi_endpoint_info) {
  2442. .out_cables = 0x80ff,
  2443. .in_cables = 0x80ff
  2444. }
  2445. }
  2446. },
  2447. {
  2448. USB_DEVICE(0x086a, 0x0003),
  2449. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2450. .vendor_name = "Emagic",
  2451. /* .product_name = "MT4", */
  2452. .ifnum = 2,
  2453. .type = QUIRK_MIDI_EMAGIC,
  2454. .data = & (const struct snd_usb_midi_endpoint_info) {
  2455. .out_cables = 0x800f,
  2456. .in_cables = 0x8003
  2457. }
  2458. }
  2459. },
  2460.  
  2461. /* KORG devices */
  2462. {
  2463. USB_DEVICE_VENDOR_SPEC(0x0944, 0x0200),
  2464. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2465. .vendor_name = "KORG, Inc.",
  2466. /* .product_name = "PANDORA PX5D", */
  2467. .ifnum = 3,
  2468. .type = QUIRK_MIDI_STANDARD_INTERFACE,
  2469. }
  2470. },
  2471.  
  2472. {
  2473. USB_DEVICE_VENDOR_SPEC(0x0944, 0x0201),
  2474. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2475. .vendor_name = "KORG, Inc.",
  2476. /* .product_name = "ToneLab ST", */
  2477. .ifnum = 3,
  2478. .type = QUIRK_MIDI_STANDARD_INTERFACE,
  2479. }
  2480. },
  2481.  
  2482. /* AKAI devices */
  2483. {
  2484. USB_DEVICE(0x09e8, 0x0062),
  2485. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2486. .vendor_name = "AKAI",
  2487. .product_name = "MPD16",
  2488. .ifnum = 0,
  2489. .type = QUIRK_MIDI_AKAI,
  2490. }
  2491. },
  2492.  
  2493. {
  2494. /* Akai MPC Element */
  2495. USB_DEVICE(0x09e8, 0x0021),
  2496. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2497. .ifnum = QUIRK_ANY_INTERFACE,
  2498. .type = QUIRK_COMPOSITE,
  2499. .data = & (const struct snd_usb_audio_quirk[]) {
  2500. {
  2501. .ifnum = 0,
  2502. .type = QUIRK_IGNORE_INTERFACE
  2503. },
  2504. {
  2505. .ifnum = 1,
  2506. .type = QUIRK_MIDI_STANDARD_INTERFACE
  2507. },
  2508. {
  2509. .ifnum = -1
  2510. }
  2511. }
  2512. }
  2513. },
  2514.  
  2515. /* Steinberg devices */
  2516. {
  2517. /* Steinberg MI2 */
  2518. USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x2040),
  2519. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2520. .ifnum = QUIRK_ANY_INTERFACE,
  2521. .type = QUIRK_COMPOSITE,
  2522. .data = & (const struct snd_usb_audio_quirk[]) {
  2523. {
  2524. .ifnum = 0,
  2525. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2526. },
  2527. {
  2528. .ifnum = 1,
  2529. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2530. },
  2531. {
  2532. .ifnum = 2,
  2533. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2534. },
  2535. {
  2536. .ifnum = 3,
  2537. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  2538. .data = &(const struct snd_usb_midi_endpoint_info) {
  2539. .out_cables = 0x0001,
  2540. .in_cables = 0x0001
  2541. }
  2542. },
  2543. {
  2544. .ifnum = -1
  2545. }
  2546. }
  2547. }
  2548. },
  2549. {
  2550. /* Steinberg MI4 */
  2551. USB_DEVICE_VENDOR_SPEC(0x0a4e, 0x4040),
  2552. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2553. .ifnum = QUIRK_ANY_INTERFACE,
  2554. .type = QUIRK_COMPOSITE,
  2555. .data = & (const struct snd_usb_audio_quirk[]) {
  2556. {
  2557. .ifnum = 0,
  2558. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2559. },
  2560. {
  2561. .ifnum = 1,
  2562. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2563. },
  2564. {
  2565. .ifnum = 2,
  2566. .type = QUIRK_AUDIO_STANDARD_INTERFACE
  2567. },
  2568. {
  2569. .ifnum = 3,
  2570. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  2571. .data = &(const struct snd_usb_midi_endpoint_info) {
  2572. .out_cables = 0x0001,
  2573. .in_cables = 0x0001
  2574. }
  2575. },
  2576. {
  2577. .ifnum = -1
  2578. }
  2579. }
  2580. }
  2581. },
  2582.  
  2583. /* TerraTec devices */
  2584. {
  2585. USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0012),
  2586. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2587. .vendor_name = "TerraTec",
  2588. .product_name = "PHASE 26",
  2589. .ifnum = 3,
  2590. .type = QUIRK_MIDI_STANDARD_INTERFACE
  2591. }
  2592. },
  2593. {
  2594. USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0013),
  2595. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2596. .vendor_name = "TerraTec",
  2597. .product_name = "PHASE 26",
  2598. .ifnum = 3,
  2599. .type = QUIRK_MIDI_STANDARD_INTERFACE
  2600. }
  2601. },
  2602. {
  2603. USB_DEVICE_VENDOR_SPEC(0x0ccd, 0x0014),
  2604. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2605. .vendor_name = "TerraTec",
  2606. .product_name = "PHASE 26",
  2607. .ifnum = 3,
  2608. .type = QUIRK_MIDI_STANDARD_INTERFACE
  2609. }
  2610. },
  2611. {
  2612. USB_DEVICE(0x0ccd, 0x0028),
  2613. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2614. .vendor_name = "TerraTec",
  2615. .product_name = "Aureon5.1MkII",
  2616. .ifnum = QUIRK_NO_INTERFACE
  2617. }
  2618. },
  2619. {
  2620. USB_DEVICE(0x0ccd, 0x0035),
  2621. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2622. .vendor_name = "Miditech",
  2623. .product_name = "Play'n Roll",
  2624. .ifnum = 0,
  2625. .type = QUIRK_MIDI_CME
  2626. }
  2627. },
  2628.  
  2629. /* Stanton/N2IT Final Scratch v1 device ('Scratchamp') */
  2630. {
  2631. USB_DEVICE(0x103d, 0x0100),
  2632. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2633. .vendor_name = "Stanton",
  2634. .product_name = "ScratchAmp",
  2635. .ifnum = QUIRK_NO_INTERFACE
  2636. }
  2637. },
  2638. {
  2639. USB_DEVICE(0x103d, 0x0101),
  2640. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2641. .vendor_name = "Stanton",
  2642. .product_name = "ScratchAmp",
  2643. .ifnum = QUIRK_NO_INTERFACE
  2644. }
  2645. },
  2646.  
  2647. /* Novation EMS devices */
  2648. {
  2649. USB_DEVICE_VENDOR_SPEC(0x1235, 0x0001),
  2650. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2651. .vendor_name = "Novation",
  2652. .product_name = "ReMOTE Audio/XStation",
  2653. .ifnum = 4,
  2654. .type = QUIRK_MIDI_NOVATION
  2655. }
  2656. },
  2657. {
  2658. USB_DEVICE_VENDOR_SPEC(0x1235, 0x0002),
  2659. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2660. .vendor_name = "Novation",
  2661. .product_name = "Speedio",
  2662. .ifnum = 3,
  2663. .type = QUIRK_MIDI_NOVATION
  2664. }
  2665. },
  2666. {
  2667. USB_DEVICE(0x1235, 0x000a),
  2668. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2669. /* .vendor_name = "Novation", */
  2670. /* .product_name = "Nocturn", */
  2671. .ifnum = 0,
  2672. .type = QUIRK_MIDI_RAW_BYTES
  2673. }
  2674. },
  2675. {
  2676. USB_DEVICE(0x1235, 0x000e),
  2677. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2678. /* .vendor_name = "Novation", */
  2679. /* .product_name = "Launchpad", */
  2680. .ifnum = 0,
  2681. .type = QUIRK_MIDI_RAW_BYTES
  2682. }
  2683. },
  2684. {
  2685. USB_DEVICE(0x1235, 0x0010),
  2686. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  2687. .vendor_name = "Focusrite",
  2688. .product_name = "Saffire 6 USB",
  2689. .ifnum = QUIRK_ANY_INTERFACE,
  2690. .type = QUIRK_COMPOSITE,
  2691. .data = (const struct snd_usb_audio_quirk[]) {
  2692. {
  2693. .ifnum = 0,
  2694. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2695. .data = &(const struct audioformat) {
  2696. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  2697. .channels = 4,
  2698. .iface = 0,
  2699. .altsetting = 1,
  2700. .altset_idx = 1,
  2701. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  2702. .endpoint = 0x01,
  2703. .ep_attr = USB_ENDPOINT_XFER_ISOC,
  2704. .rates = SNDRV_PCM_RATE_44100 |
  2705. SNDRV_PCM_RATE_48000,
  2706. .rate_min = 44100,
  2707. .rate_max = 48000,
  2708. .nr_rates = 2,
  2709. .rate_table = (unsigned int[]) {
  2710. 44100, 48000
  2711. }
  2712. }
  2713. },
  2714. {
  2715. .ifnum = 1,
  2716. .type = QUIRK_MIDI_RAW_BYTES
  2717. },
  2718. {
  2719. .ifnum = -1
  2720. }
  2721. }
  2722. }
  2723. },
  2724. {
  2725. USB_DEVICE(0x1235, 0x0018),
  2726. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2727. .vendor_name = "Novation",
  2728. .product_name = "Twitch",
  2729. .ifnum = QUIRK_ANY_INTERFACE,
  2730. .type = QUIRK_COMPOSITE,
  2731. .data = (const struct snd_usb_audio_quirk[]) {
  2732. {
  2733. .ifnum = 0,
  2734. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2735. .data = & (const struct audioformat) {
  2736. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  2737. .channels = 4,
  2738. .iface = 0,
  2739. .altsetting = 1,
  2740. .altset_idx = 1,
  2741. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  2742. .endpoint = 0x01,
  2743. .ep_attr = USB_ENDPOINT_XFER_ISOC,
  2744. .rates = SNDRV_PCM_RATE_44100 |
  2745. SNDRV_PCM_RATE_48000,
  2746. .rate_min = 44100,
  2747. .rate_max = 48000,
  2748. .nr_rates = 2,
  2749. .rate_table = (unsigned int[]) {
  2750. 44100, 48000
  2751. }
  2752. }
  2753. },
  2754. {
  2755. .ifnum = 1,
  2756. .type = QUIRK_MIDI_RAW_BYTES
  2757. },
  2758. {
  2759. .ifnum = -1
  2760. }
  2761. }
  2762. }
  2763. },
  2764. {
  2765. USB_DEVICE_VENDOR_SPEC(0x1235, 0x4661),
  2766. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2767. .vendor_name = "Novation",
  2768. .product_name = "ReMOTE25",
  2769. .ifnum = 0,
  2770. .type = QUIRK_MIDI_NOVATION
  2771. }
  2772. },
  2773.  
  2774. /* Access Music devices */
  2775. {
  2776. /* VirusTI Desktop */
  2777. USB_DEVICE_VENDOR_SPEC(0x133e, 0x0815),
  2778. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  2779. .ifnum = QUIRK_ANY_INTERFACE,
  2780. .type = QUIRK_COMPOSITE,
  2781. .data = &(const struct snd_usb_audio_quirk[]) {
  2782. {
  2783. .ifnum = 3,
  2784. .type = QUIRK_MIDI_FIXED_ENDPOINT,
  2785. .data = &(const struct snd_usb_midi_endpoint_info) {
  2786. .out_cables = 0x0003,
  2787. .in_cables = 0x0003
  2788. }
  2789. },
  2790. {
  2791. .ifnum = 4,
  2792. .type = QUIRK_IGNORE_INTERFACE
  2793. },
  2794. {
  2795. .ifnum = -1
  2796. }
  2797. }
  2798. }
  2799. },
  2800.  
  2801. /* */
  2802. {
  2803. /* aka. Serato Scratch Live DJ Box */
  2804. USB_DEVICE(0x13e5, 0x0001),
  2805. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2806. .vendor_name = "Rane",
  2807. .product_name = "SL-1",
  2808. .ifnum = QUIRK_NO_INTERFACE
  2809. }
  2810. },
  2811.  
  2812. /* Native Instruments MK2 series */
  2813. {
  2814. /* Komplete Audio 6 */
  2815. .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  2816. .idVendor = 0x17cc,
  2817. .idProduct = 0x1000,
  2818. },
  2819. {
  2820. /* Traktor Audio 6 */
  2821. .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  2822. .idVendor = 0x17cc,
  2823. .idProduct = 0x1010,
  2824. },
  2825. {
  2826. /* Traktor Audio 10 */
  2827. .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  2828. .idVendor = 0x17cc,
  2829. .idProduct = 0x1020,
  2830. },
  2831.  
  2832. /* QinHeng devices */
  2833. {
  2834. USB_DEVICE(0x1a86, 0x752d),
  2835. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  2836. .vendor_name = "QinHeng",
  2837. .product_name = "CH345",
  2838. .ifnum = 1,
  2839. .type = QUIRK_MIDI_CH345
  2840. }
  2841. },
  2842.  
  2843. /* KeithMcMillen Stringport */
  2844. {
  2845. USB_DEVICE(0x1f38, 0x0001),
  2846. .bInterfaceClass = USB_CLASS_AUDIO,
  2847. },
  2848.  
  2849. /* Miditech devices */
  2850. {
  2851. USB_DEVICE(0x4752, 0x0011),
  2852. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2853. .vendor_name = "Miditech",
  2854. .product_name = "Midistart-2",
  2855. .ifnum = 0,
  2856. .type = QUIRK_MIDI_CME
  2857. }
  2858. },
  2859.  
  2860. /* Central Music devices */
  2861. {
  2862. /* this ID used by both Miditech MidiStudio-2 and CME UF-x */
  2863. USB_DEVICE(0x7104, 0x2202),
  2864. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  2865. .ifnum = 0,
  2866. .type = QUIRK_MIDI_CME
  2867. }
  2868. },
  2869.  
  2870. /*
  2871. * Auvitek au0828 devices with audio interface.
  2872. * This should be kept in sync with drivers/media/usb/au0828/au0828-cards.c
  2873. * Please notice that some drivers are DVB only, and don't need to be
  2874. * here. That's the case, for example, of DVICO_FUSIONHDTV7.
  2875. */
  2876.  
  2877. #define AU0828_DEVICE(vid, pid, vname, pname) { \
  2878. USB_DEVICE_VENDOR_SPEC(vid, pid), \
  2879. .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
  2880. USB_DEVICE_ID_MATCH_INT_CLASS | \
  2881. USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
  2882. .bInterfaceClass = USB_CLASS_AUDIO, \
  2883. .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, \
  2884. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { \
  2885. .vendor_name = vname, \
  2886. .product_name = pname, \
  2887. .ifnum = QUIRK_ANY_INTERFACE, \
  2888. .type = QUIRK_AUDIO_ALIGN_TRANSFER, \
  2889. } \
  2890. }
  2891.  
  2892. AU0828_DEVICE(0x2040, 0x7200, "Hauppauge", "HVR-950Q"),
  2893. AU0828_DEVICE(0x2040, 0x7240, "Hauppauge", "HVR-850"),
  2894. AU0828_DEVICE(0x2040, 0x7210, "Hauppauge", "HVR-950Q"),
  2895. AU0828_DEVICE(0x2040, 0x7217, "Hauppauge", "HVR-950Q"),
  2896. AU0828_DEVICE(0x2040, 0x721b, "Hauppauge", "HVR-950Q"),
  2897. AU0828_DEVICE(0x2040, 0x721e, "Hauppauge", "HVR-950Q"),
  2898. AU0828_DEVICE(0x2040, 0x721f, "Hauppauge", "HVR-950Q"),
  2899. AU0828_DEVICE(0x2040, 0x7280, "Hauppauge", "HVR-950Q"),
  2900. AU0828_DEVICE(0x0fd9, 0x0008, "Hauppauge", "HVR-950Q"),
  2901. AU0828_DEVICE(0x2040, 0x7201, "Hauppauge", "HVR-950Q-MXL"),
  2902. AU0828_DEVICE(0x2040, 0x7211, "Hauppauge", "HVR-950Q-MXL"),
  2903. AU0828_DEVICE(0x2040, 0x7281, "Hauppauge", "HVR-950Q-MXL"),
  2904. AU0828_DEVICE(0x05e1, 0x0480, "Hauppauge", "Woodbury"),
  2905. AU0828_DEVICE(0x2040, 0x8200, "Hauppauge", "Woodbury"),
  2906. AU0828_DEVICE(0x2040, 0x7260, "Hauppauge", "HVR-950Q"),
  2907. AU0828_DEVICE(0x2040, 0x7213, "Hauppauge", "HVR-950Q"),
  2908. AU0828_DEVICE(0x2040, 0x7270, "Hauppauge", "HVR-950Q"),
  2909.  
  2910. /* Digidesign Mbox */
  2911. {
  2912. /* Thanks to Clemens Ladisch <clemens@ladisch.de> */
  2913. USB_DEVICE(0x0dba, 0x1000),
  2914. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  2915. .vendor_name = "Digidesign",
  2916. .product_name = "MBox",
  2917. .ifnum = QUIRK_ANY_INTERFACE,
  2918. .type = QUIRK_COMPOSITE,
  2919. .data = (const struct snd_usb_audio_quirk[]){
  2920. {
  2921. .ifnum = 0,
  2922. .type = QUIRK_AUDIO_STANDARD_MIXER,
  2923. },
  2924. {
  2925. .ifnum = 1,
  2926. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2927. .data = &(const struct audioformat) {
  2928. .formats = SNDRV_PCM_FMTBIT_S24_3BE,
  2929. .channels = 2,
  2930. .iface = 1,
  2931. .altsetting = 1,
  2932. .altset_idx = 1,
  2933. .attributes = 0x4,
  2934. .endpoint = 0x02,
  2935. .ep_attr = USB_ENDPOINT_XFER_ISOC |
  2936. USB_ENDPOINT_SYNC_SYNC,
  2937. .maxpacksize = 0x130,
  2938. .rates = SNDRV_PCM_RATE_48000,
  2939. .rate_min = 48000,
  2940. .rate_max = 48000,
  2941. .nr_rates = 1,
  2942. .rate_table = (unsigned int[]) {
  2943. 48000
  2944. }
  2945. }
  2946. },
  2947. {
  2948. .ifnum = 1,
  2949. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2950. .data = &(const struct audioformat) {
  2951. .formats = SNDRV_PCM_FMTBIT_S24_3BE,
  2952. .channels = 2,
  2953. .iface = 1,
  2954. .altsetting = 1,
  2955. .altset_idx = 1,
  2956. .attributes = 0x4,
  2957. .endpoint = 0x81,
  2958. .ep_attr = USB_ENDPOINT_XFER_ISOC |
  2959. USB_ENDPOINT_SYNC_ASYNC,
  2960. .maxpacksize = 0x130,
  2961. .rates = SNDRV_PCM_RATE_48000,
  2962. .rate_min = 48000,
  2963. .rate_max = 48000,
  2964. .nr_rates = 1,
  2965. .rate_table = (unsigned int[]) {
  2966. 48000
  2967. }
  2968. }
  2969. },
  2970. {
  2971. .ifnum = -1
  2972. }
  2973. }
  2974. }
  2975. },
  2976.  
  2977. /* DIGIDESIGN MBOX 2 */
  2978. {
  2979. USB_DEVICE(0x0dba, 0x3000),
  2980. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  2981. .vendor_name = "Digidesign",
  2982. .product_name = "Mbox 2",
  2983. .ifnum = QUIRK_ANY_INTERFACE,
  2984. .type = QUIRK_COMPOSITE,
  2985. .data = (const struct snd_usb_audio_quirk[]) {
  2986. {
  2987. .ifnum = 0,
  2988. .type = QUIRK_IGNORE_INTERFACE
  2989. },
  2990. {
  2991. .ifnum = 1,
  2992. .type = QUIRK_IGNORE_INTERFACE
  2993. },
  2994. {
  2995. .ifnum = 2,
  2996. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  2997. .data = &(const struct audioformat) {
  2998. .formats = SNDRV_PCM_FMTBIT_S24_3BE,
  2999. .channels = 2,
  3000. .iface = 2,
  3001. .altsetting = 2,
  3002. .altset_idx = 1,
  3003. .attributes = 0x00,
  3004. .endpoint = 0x03,
  3005. .ep_attr = USB_ENDPOINT_SYNC_ASYNC,
  3006. .rates = SNDRV_PCM_RATE_48000,
  3007. .rate_min = 48000,
  3008. .rate_max = 48000,
  3009. .nr_rates = 1,
  3010. .rate_table = (unsigned int[]) {
  3011. 48000
  3012. }
  3013. }
  3014. },
  3015. {
  3016. .ifnum = 3,
  3017. .type = QUIRK_IGNORE_INTERFACE
  3018. },
  3019. {
  3020. .ifnum = 4,
  3021. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  3022. .data = &(const struct audioformat) {
  3023. .formats = SNDRV_PCM_FMTBIT_S24_3BE,
  3024. .channels = 2,
  3025. .iface = 4,
  3026. .altsetting = 2,
  3027. .altset_idx = 1,
  3028. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  3029. .endpoint = 0x85,
  3030. .ep_attr = USB_ENDPOINT_SYNC_SYNC,
  3031. .rates = SNDRV_PCM_RATE_48000,
  3032. .rate_min = 48000,
  3033. .rate_max = 48000,
  3034. .nr_rates = 1,
  3035. .rate_table = (unsigned int[]) {
  3036. 48000
  3037. }
  3038. }
  3039. },
  3040. {
  3041. .ifnum = 5,
  3042. .type = QUIRK_IGNORE_INTERFACE
  3043. },
  3044. {
  3045. .ifnum = 6,
  3046. .type = QUIRK_MIDI_MIDIMAN,
  3047. .data = &(const struct snd_usb_midi_endpoint_info) {
  3048. .out_ep = 0x02,
  3049. .out_cables = 0x0001,
  3050. .in_ep = 0x81,
  3051. .in_interval = 0x01,
  3052. .in_cables = 0x0001
  3053. }
  3054. },
  3055. {
  3056. .ifnum = -1
  3057. }
  3058. }
  3059. }
  3060. },
  3061. {
  3062. /* Tascam US122 MKII - playback-only support */
  3063. .match_flags = USB_DEVICE_ID_MATCH_DEVICE,
  3064. .idVendor = 0x0644,
  3065. .idProduct = 0x8021,
  3066. .bInterfaceClass = USB_CLASS_AUDIO,
  3067. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  3068. .vendor_name = "TASCAM",
  3069. .product_name = "US122 MKII",
  3070. .ifnum = QUIRK_ANY_INTERFACE,
  3071. .type = QUIRK_COMPOSITE,
  3072. .data = (const struct snd_usb_audio_quirk[]) {
  3073. {
  3074. .ifnum = 0,
  3075. .type = QUIRK_IGNORE_INTERFACE
  3076. },
  3077. {
  3078. .ifnum = 1,
  3079. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  3080. .data = &(const struct audioformat) {
  3081. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  3082. .channels = 2,
  3083. .iface = 1,
  3084. .altsetting = 1,
  3085. .altset_idx = 1,
  3086. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  3087. .endpoint = 0x02,
  3088. .ep_attr = USB_ENDPOINT_XFER_ISOC,
  3089. .rates = SNDRV_PCM_RATE_44100 |
  3090. SNDRV_PCM_RATE_48000 |
  3091. SNDRV_PCM_RATE_88200 |
  3092. SNDRV_PCM_RATE_96000,
  3093. .rate_min = 44100,
  3094. .rate_max = 96000,
  3095. .nr_rates = 4,
  3096. .rate_table = (unsigned int[]) {
  3097. 44100, 48000, 88200, 96000
  3098. }
  3099. }
  3100. },
  3101. {
  3102. .ifnum = -1
  3103. }
  3104. }
  3105. }
  3106. },
  3107.  
  3108. /* Microsoft XboxLive Headset/Xbox Communicator */
  3109. {
  3110. USB_DEVICE(0x045e, 0x0283),
  3111. .bInterfaceClass = USB_CLASS_PER_INTERFACE,
  3112. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  3113. .vendor_name = "Microsoft",
  3114. .product_name = "XboxLive Headset/Xbox Communicator",
  3115. .ifnum = QUIRK_ANY_INTERFACE,
  3116. .type = QUIRK_COMPOSITE,
  3117. .data = &(const struct snd_usb_audio_quirk[]) {
  3118. {
  3119. /* playback */
  3120. .ifnum = 0,
  3121. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  3122. .data = &(const struct audioformat) {
  3123. .formats = SNDRV_PCM_FMTBIT_S16_LE,
  3124. .channels = 1,
  3125. .iface = 0,
  3126. .altsetting = 0,
  3127. .altset_idx = 0,
  3128. .attributes = 0,
  3129. .endpoint = 0x04,
  3130. .ep_attr = 0x05,
  3131. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  3132. .rate_min = 22050,
  3133. .rate_max = 22050
  3134. }
  3135. },
  3136. {
  3137. /* capture */
  3138. .ifnum = 1,
  3139. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  3140. .data = &(const struct audioformat) {
  3141. .formats = SNDRV_PCM_FMTBIT_S16_LE,
  3142. .channels = 1,
  3143. .iface = 1,
  3144. .altsetting = 0,
  3145. .altset_idx = 0,
  3146. .attributes = 0,
  3147. .endpoint = 0x85,
  3148. .ep_attr = 0x05,
  3149. .rates = SNDRV_PCM_RATE_CONTINUOUS,
  3150. .rate_min = 16000,
  3151. .rate_max = 16000
  3152. }
  3153. },
  3154. {
  3155. .ifnum = -1
  3156. }
  3157. }
  3158. }
  3159. },
  3160.  
  3161. /* Reloop Play */
  3162. {
  3163. USB_DEVICE(0x200c, 0x100b),
  3164. .bInterfaceClass = USB_CLASS_PER_INTERFACE,
  3165. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  3166. .ifnum = QUIRK_ANY_INTERFACE,
  3167. .type = QUIRK_COMPOSITE,
  3168. .data = &(const struct snd_usb_audio_quirk[]) {
  3169. {
  3170. .ifnum = 0,
  3171. .type = QUIRK_AUDIO_STANDARD_MIXER,
  3172. },
  3173. {
  3174. .ifnum = 1,
  3175. .type = QUIRK_AUDIO_FIXED_ENDPOINT,
  3176. .data = &(const struct audioformat) {
  3177. .formats = SNDRV_PCM_FMTBIT_S24_3LE,
  3178. .channels = 4,
  3179. .iface = 1,
  3180. .altsetting = 1,
  3181. .altset_idx = 1,
  3182. .attributes = UAC_EP_CS_ATTR_SAMPLE_RATE,
  3183. .endpoint = 0x01,
  3184. .ep_attr = USB_ENDPOINT_SYNC_ADAPTIVE,
  3185. .rates = SNDRV_PCM_RATE_44100 |
  3186. SNDRV_PCM_RATE_48000,
  3187. .rate_min = 44100,
  3188. .rate_max = 48000,
  3189. .nr_rates = 2,
  3190. .rate_table = (unsigned int[]) {
  3191. 44100, 48000
  3192. }
  3193. }
  3194. },
  3195. {
  3196. .ifnum = -1
  3197. }
  3198. }
  3199. }
  3200. },
  3201.  
  3202. {
  3203. /*
  3204. * ZOOM R16/24 in audio interface mode.
  3205. * Playback requires an extra four byte LE length indicator
  3206. * at the start of each isochronous packet. This quirk is
  3207. * enabled in create_standard_audio_quirk().
  3208. */
  3209. USB_DEVICE(0x1686, 0x00dd),
  3210. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  3211. .ifnum = QUIRK_ANY_INTERFACE,
  3212. .type = QUIRK_COMPOSITE,
  3213. .data = (const struct snd_usb_audio_quirk[]) {
  3214. {
  3215. /* Playback */
  3216. .ifnum = 1,
  3217. .type = QUIRK_AUDIO_STANDARD_INTERFACE,
  3218. },
  3219. {
  3220. /* Capture */
  3221. .ifnum = 2,
  3222. .type = QUIRK_AUDIO_STANDARD_INTERFACE,
  3223. },
  3224. {
  3225. /* Midi */
  3226. .ifnum = 3,
  3227. .type = QUIRK_MIDI_STANDARD_INTERFACE
  3228. },
  3229. {
  3230. .ifnum = -1
  3231. },
  3232. }
  3233. }
  3234. },
  3235.  
  3236. {
  3237. /*
  3238. * Some USB MIDI devices don't have an audio control interface,
  3239. * so we have to grab MIDI streaming interfaces here.
  3240. */
  3241. .match_flags = USB_DEVICE_ID_MATCH_INT_CLASS |
  3242. USB_DEVICE_ID_MATCH_INT_SUBCLASS,
  3243. .bInterfaceClass = USB_CLASS_AUDIO,
  3244. .bInterfaceSubClass = USB_SUBCLASS_MIDISTREAMING,
  3245. .driver_info = (unsigned long) & (const struct snd_usb_audio_quirk) {
  3246. .ifnum = QUIRK_ANY_INTERFACE,
  3247. .type = QUIRK_MIDI_STANDARD_INTERFACE
  3248. }
  3249. },
  3250.  
  3251. {
  3252. /*
  3253. * The original product_name is "USB Sound Device", however this name
  3254. * is also used by the CM106 based cards, so make it unique.
  3255. */
  3256. USB_DEVICE(0x0d8c, 0x0103),
  3257. .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) {
  3258. .product_name = "Audio Advantage MicroII",
  3259. .ifnum = QUIRK_NO_INTERFACE
  3260. }
  3261. },
  3262.  
  3263. #undef USB_DEVICE_VENDOR_SPEC
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!