xref: /freebsd/sys/dev/usb/quirk/usb_quirk.c (revision e6bfd18d21b225af6a0ed67ceeaf1293b7b9eba5)
1 /* $FreeBSD$ */
2 /*-
3  * SPDX-License-Identifier: BSD-2-Clause
4  *
5  * Copyright (c) 1998 The NetBSD Foundation, Inc. All rights reserved.
6  * Copyright (c) 1998 Lennart Augustsson. All rights reserved.
7  * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28  * SUCH DAMAGE.
29  */
30 
31 #include <sys/stdint.h>
32 #include <sys/stddef.h>
33 #include <sys/param.h>
34 #include <sys/queue.h>
35 #include <sys/types.h>
36 #include <sys/systm.h>
37 #include <sys/kernel.h>
38 #include <sys/bus.h>
39 #include <sys/module.h>
40 #include <sys/lock.h>
41 #include <sys/mutex.h>
42 #include <sys/condvar.h>
43 #include <sys/sysctl.h>
44 #include <sys/sx.h>
45 #include <sys/unistd.h>
46 #include <sys/callout.h>
47 #include <sys/malloc.h>
48 #include <sys/priv.h>
49 
50 #include <dev/usb/usb.h>
51 #include <dev/usb/usb_ioctl.h>
52 #include <dev/usb/usbdi.h>
53 #include "usbdevs.h"
54 
55 #define	USB_DEBUG_VAR usb_debug
56 #include <dev/usb/usb_debug.h>
57 #include <dev/usb/usb_dynamic.h>
58 
59 #include <dev/usb/quirk/usb_quirk.h>
60 
61 MODULE_DEPEND(usb_quirk, usb, 1, 1, 1);
62 MODULE_VERSION(usb_quirk, 1);
63 
64 #define	USB_DEV_QUIRKS_MAX 384
65 #define	USB_SUB_QUIRKS_MAX 8
66 #define	USB_QUIRK_ENVROOT "hw.usb.quirk."
67 
68 struct usb_quirk_entry {
69 	uint16_t vid;
70 	uint16_t pid;
71 	uint16_t lo_rev;
72 	uint16_t hi_rev;
73 	uint16_t quirks[USB_SUB_QUIRKS_MAX];
74 };
75 
76 static struct mtx usb_quirk_mtx;
77 
78 #define	USB_QUIRK_VP(v,p,l,h,...) \
79   { .vid = (v), .pid = (p), .lo_rev = (l), .hi_rev = (h), \
80     .quirks = { __VA_ARGS__ } }
81 #define	USB_QUIRK(v,p,l,h,...) \
82   USB_QUIRK_VP(USB_VENDOR_##v, USB_PRODUCT_##v##_##p, l, h, __VA_ARGS__)
83 
84 static struct usb_quirk_entry usb_quirks[USB_DEV_QUIRKS_MAX] = {
85 	USB_QUIRK(ASUS, LCM, 0x0000, 0xffff, UQ_HID_IGNORE),
86 	USB_QUIRK(INSIDEOUT, EDGEPORT4, 0x094, 0x094, UQ_SWAP_UNICODE),
87 	USB_QUIRK(DALLAS, J6502, 0x0a2, 0x0a2, UQ_BAD_ADC),
88 	USB_QUIRK(DALLAS, J6502, 0x0a2, 0x0a2, UQ_AU_NO_XU),
89 	USB_QUIRK(ALTEC, ADA70, 0x103, 0x103, UQ_BAD_ADC),
90 	USB_QUIRK(ALTEC, ASC495, 0x000, 0x000, UQ_BAD_AUDIO),
91 	USB_QUIRK(QTRONIX, 980N, 0x110, 0x110, UQ_SPUR_BUT_UP),
92 	USB_QUIRK(ALCOR2, KBD_HUB, 0x001, 0x001, UQ_SPUR_BUT_UP),
93 	USB_QUIRK(MCT, HUB0100, 0x102, 0x102, UQ_BUS_POWERED),
94 	USB_QUIRK(MCT, USB232, 0x102, 0x102, UQ_BUS_POWERED),
95 	USB_QUIRK(TI, UTUSB41, 0x110, 0x110, UQ_POWER_CLAIM),
96 	USB_QUIRK(TELEX, MIC1, 0x009, 0x009, UQ_AU_NO_FRAC),
97 	USB_QUIRK(SILICONPORTALS, YAPPHONE, 0x100, 0x100, UQ_AU_INP_ASYNC),
98 	USB_QUIRK(LOGITECH, UN53B, 0x0000, 0xffff, UQ_NO_STRINGS),
99 	USB_QUIRK(LOGITECH, G510S, 0x0000, 0xFFFF, UQ_KBD_BOOTPROTO),
100 	USB_QUIRK(REALTEK, RTL8196EU, 0x0000, 0xffff, UQ_CFG_INDEX_1),
101 	USB_QUIRK(ELSA, MODEM1, 0x0000, 0xffff, UQ_CFG_INDEX_1),
102 	USB_QUIRK(PLANEX2, MZKUE150N, 0x0000, 0xffff, UQ_CFG_INDEX_1),
103 	USB_QUIRK(CISCOLINKSYS, USB3GIGV1, 0x0000, 0xffff, UQ_CFG_INDEX_1),
104 	USB_QUIRK(REALTEK, RTL8156, 0x0000, 0xffff, UQ_CFG_INDEX_2),
105 	/* Quirks for printer devices */
106 	USB_QUIRK(HP, 895C, 0x0000, 0xffff, UQ_BROKEN_BIDIR),
107 	USB_QUIRK(HP, 880C, 0x0000, 0xffff, UQ_BROKEN_BIDIR),
108 	USB_QUIRK(HP, 815C, 0x0000, 0xffff, UQ_BROKEN_BIDIR),
109 	USB_QUIRK(HP, 810C, 0x0000, 0xffff, UQ_BROKEN_BIDIR),
110 	USB_QUIRK(HP, 830C, 0x0000, 0xffff, UQ_BROKEN_BIDIR),
111 	USB_QUIRK(HP, 1220C, 0x0000, 0xffff, UQ_BROKEN_BIDIR),
112 	USB_QUIRK(XEROX, WCM15, 0x0000, 0xffff, UQ_BROKEN_BIDIR),
113 	/* Devices which should be ignored by uhid */
114 	USB_QUIRK(APC, UPS, 0x0000, 0xffff, UQ_HID_IGNORE),
115 	USB_QUIRK(APC, UPS1000, 0x0000, 0xffff, UQ_HID_IGNORE),
116 	USB_QUIRK(BELKIN, F6H375USB, 0x0000, 0xffff, UQ_HID_IGNORE),
117 	USB_QUIRK(BELKIN, F6C550AVR, 0x0000, 0xffff, UQ_HID_IGNORE),
118 	USB_QUIRK(BELKIN, F6C1250TWRK, 0x0000, 0xffff, UQ_HID_IGNORE),
119 	USB_QUIRK(BELKIN, F6C1500TWRK, 0x0000, 0xffff, UQ_HID_IGNORE),
120 	USB_QUIRK(BELKIN, F6C900UNV, 0x0000, 0xffff, UQ_HID_IGNORE),
121 	USB_QUIRK(BELKIN, F6C100UNV, 0x0000, 0xffff, UQ_HID_IGNORE),
122 	USB_QUIRK(BELKIN, F6C120UNV, 0x0000, 0xffff, UQ_HID_IGNORE),
123 	USB_QUIRK(BELKIN, F6C800UNV, 0x0000, 0xffff, UQ_HID_IGNORE),
124 	USB_QUIRK(BELKIN, F6C1100UNV, 0x0000, 0xffff, UQ_HID_IGNORE),
125 	USB_QUIRK(CYBERPOWER, BC900D, 0x0000, 0xffff, UQ_HID_IGNORE),
126 	USB_QUIRK(CYBERPOWER, 1500CAVRLCD, 0x0000, 0xffff, UQ_HID_IGNORE),
127 	USB_QUIRK(CYBERPOWER, OR2200LCDRM2U, 0x0000, 0xffff, UQ_HID_IGNORE),
128 	USB_QUIRK(DELL2, VARIOUS_UPS, 0x0000, 0xffff, UQ_HID_IGNORE),
129 	USB_QUIRK(CYPRESS, SILVERSHIELD, 0x0000, 0xffff, UQ_HID_IGNORE),
130 	USB_QUIRK(DELORME, EARTHMATE, 0x0000, 0xffff, UQ_HID_IGNORE),
131 	USB_QUIRK(DREAMLINK, DL100B, 0x0000, 0xffff, UQ_HID_IGNORE),
132 	USB_QUIRK(MICROCHIP, PICOLCD20X2, 0x0000, 0xffff, UQ_HID_IGNORE),
133 	USB_QUIRK(MICROCHIP, PICOLCD4X20, 0x0000, 0xffff, UQ_HID_IGNORE),
134 	USB_QUIRK(LIEBERT, POWERSURE_PXT, 0x0000, 0xffff, UQ_HID_IGNORE),
135 	USB_QUIRK(LIEBERT2, PSI1000, 0x0000, 0xffff, UQ_HID_IGNORE),
136 	USB_QUIRK(LIEBERT2, POWERSURE_PSA, 0x0000, 0xffff, UQ_HID_IGNORE),
137 	USB_QUIRK(MGE, UPS1, 0x0000, 0xffff, UQ_HID_IGNORE),
138 	USB_QUIRK(MGE, UPS2, 0x0000, 0xffff, UQ_HID_IGNORE),
139 	USB_QUIRK(POWERCOM, IMPERIAL_SERIES, 0x0000, 0xffff, UQ_HID_IGNORE),
140 	USB_QUIRK(POWERCOM, SMART_KING_PRO, 0x0000, 0xffff, UQ_HID_IGNORE),
141 	USB_QUIRK(POWERCOM, WOW, 0x0000, 0xffff, UQ_HID_IGNORE),
142 	USB_QUIRK(POWERCOM, VANGUARD, 0x0000, 0xffff, UQ_HID_IGNORE),
143 	USB_QUIRK(POWERCOM, BLACK_KNIGHT_PRO, 0x0000, 0xffff, UQ_HID_IGNORE),
144 	USB_QUIRK(TRIPPLITE2, AVR550U, 0x0000, 0xffff, UQ_HID_IGNORE),
145 	USB_QUIRK(TRIPPLITE2, AVR750U, 0x0000, 0xffff, UQ_HID_IGNORE),
146 	USB_QUIRK(TRIPPLITE2, ECO550UPS, 0x0000, 0xffff, UQ_HID_IGNORE),
147 	USB_QUIRK(TRIPPLITE2, T750_INTL, 0x0000, 0xffff, UQ_HID_IGNORE),
148 	USB_QUIRK(TRIPPLITE2, RT_2200_INTL, 0x0000, 0xffff, UQ_HID_IGNORE),
149 	USB_QUIRK(TRIPPLITE2, OMNI1000LCD, 0x0000, 0xffff, UQ_HID_IGNORE),
150 	USB_QUIRK(TRIPPLITE2, OMNI900LCD, 0x0000, 0xffff, UQ_HID_IGNORE),
151 	USB_QUIRK(TRIPPLITE2, SMART_2200RMXL2U, 0x0000, 0xffff, UQ_HID_IGNORE),
152 	USB_QUIRK(TRIPPLITE2, UPS_3014, 0x0000, 0xffff, UQ_HID_IGNORE),
153 	USB_QUIRK(TRIPPLITE2, SU1500RTXL2UA, 0x0000, 0xffff, UQ_HID_IGNORE),
154 	USB_QUIRK(TRIPPLITE2, SU6000RT4U, 0x0000, 0xffff, UQ_HID_IGNORE),
155 	USB_QUIRK(TRIPPLITE2, SU1500RTXL2UA_2, 0x0000, 0xffff, UQ_HID_IGNORE),
156 	USB_QUIRK(APPLE, IPHONE, 0x0000, 0xffff, UQ_HID_IGNORE),
157 	USB_QUIRK(APPLE, IPHONE_3G, 0x0000, 0xffff, UQ_HID_IGNORE),
158 	USB_QUIRK(MEGATEC, UPS, 0x0000, 0xffff, UQ_HID_IGNORE),
159 	/* Devices which should be ignored by both ukbd and uhid */
160 	USB_QUIRK(CYPRESS, WISPY1A, 0x0000, 0xffff, UQ_KBD_IGNORE, UQ_HID_IGNORE),
161 	USB_QUIRK(METAGEEK, WISPY1B, 0x0000, 0xffff, UQ_KBD_IGNORE, UQ_HID_IGNORE),
162 	USB_QUIRK(METAGEEK, WISPY24X, 0x0000, 0xffff, UQ_KBD_IGNORE, UQ_HID_IGNORE),
163 	USB_QUIRK(METAGEEK2, WISPYDBX, 0x0000, 0xffff, UQ_KBD_IGNORE, UQ_HID_IGNORE),
164 	USB_QUIRK(TENX, UAUDIO0, 0x0101, 0x0101, UQ_AUDIO_SWAP_LR),
165 	/* MS keyboards do weird things */
166 	USB_QUIRK(MICROSOFT, NATURAL4000, 0x0000, 0xFFFF, UQ_KBD_BOOTPROTO),
167 	USB_QUIRK(MICROSOFT, WLINTELLIMOUSE, 0x0000, 0xffff, UQ_MS_LEADING_BYTE),
168 	/* Quirk for Corsair Vengeance K60 keyboard */
169 	USB_QUIRK(CORSAIR, K60, 0x0000, 0xffff, UQ_KBD_BOOTPROTO),
170 	/* Quirk for Corsair Gaming K68 keyboard */
171 	USB_QUIRK(CORSAIR, K68, 0x0000, 0xffff, UQ_KBD_BOOTPROTO),
172 	/* Quirk for Corsair Vengeance K70 keyboard */
173 	USB_QUIRK(CORSAIR, K70, 0x0000, 0xffff, UQ_KBD_BOOTPROTO),
174 	/* Quirk for Corsair K70 RGB keyboard */
175 	USB_QUIRK(CORSAIR, K70_RGB, 0x0000, 0xffff, UQ_KBD_BOOTPROTO),
176 	/* Quirk for Corsair STRAFE Gaming keyboard */
177 	USB_QUIRK(CORSAIR, STRAFE, 0x0000, 0xffff, UQ_KBD_BOOTPROTO),
178 	USB_QUIRK(CORSAIR, STRAFE2, 0x0000, 0xffff, UQ_KBD_BOOTPROTO),
179 	/* Quirk for Kensington Slimblade Trackball */
180 	USB_QUIRK(KENSINGTON, SLIMBLADE, 0x0000, 0xffff, UQ_MS_VENDOR_BTN),
181 	/* umodem(4) device quirks */
182 	USB_QUIRK(METRICOM, RICOCHET_GS, 0x100, 0x100, UQ_ASSUME_CM_OVER_DATA),
183 	USB_QUIRK(SANYO, SCP4900, 0x000, 0x000, UQ_ASSUME_CM_OVER_DATA),
184 	USB_QUIRK(MOTOROLA2, T720C, 0x001, 0x001, UQ_ASSUME_CM_OVER_DATA),
185 	USB_QUIRK(EICON, DIVA852, 0x100, 0x100, UQ_ASSUME_CM_OVER_DATA),
186 	USB_QUIRK(SIEMENS2, ES75, 0x000, 0x000, UQ_ASSUME_CM_OVER_DATA),
187 	USB_QUIRK(QUALCOMM, CDMA_MSM, 0x0000, 0xffff, UQ_ASSUME_CM_OVER_DATA),
188 	USB_QUIRK(QUALCOMM2, CDMA_MSM, 0x0000, 0xffff, UQ_ASSUME_CM_OVER_DATA),
189 	USB_QUIRK(CURITEL, UM150, 0x0000, 0xffff, UQ_ASSUME_CM_OVER_DATA),
190 	USB_QUIRK(CURITEL, UM175, 0x0000, 0xffff, UQ_ASSUME_CM_OVER_DATA),
191 	USB_QUIRK(VERTEX, VW110L, 0x0000, 0xffff, UQ_ASSUME_CM_OVER_DATA),
192 	USB_QUIRK(BALTECH, SMARTCARDREADER, 0x0000, 0xffff, UQ_IGNORE_CDC_CM),
193 
194 	/* USB Mass Storage Class Quirks */
195 	USB_QUIRK_VP(USB_VENDOR_ASAHIOPTICAL, 0, UQ_MSC_NO_RS_CLEAR_UA,
196 	    UQ_MATCH_VENDOR_ONLY),
197 	USB_QUIRK(ADDON, ATTACHE, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
198 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE),
199 	USB_QUIRK(ADDON, A256MB, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
200 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE),
201 	USB_QUIRK(ADDON, DISKPRO512, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
202 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE),
203 	USB_QUIRK(ADDONICS2, CABLE_205, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
204 	    UQ_MSC_FORCE_PROTO_SCSI),
205 	USB_QUIRK(AIPTEK, POCKETCAM3M, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
206 	    UQ_MSC_FORCE_PROTO_SCSI),
207 	USB_QUIRK(ALCOR, UMCR_9361, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
208 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_GETMAXLUN),
209 	USB_QUIRK(ALCOR, TRANSCEND, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN,
210 	    UQ_MSC_NO_SYNC_CACHE, UQ_MSC_NO_TEST_UNIT_READY),
211 	USB_QUIRK(APACER, HT202, 0x0000, 0xffff, UQ_MSC_NO_TEST_UNIT_READY,
212 	    UQ_MSC_NO_SYNC_CACHE),
213 	USB_QUIRK(ASAHIOPTICAL, OPTIO230, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
214 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
215 	USB_QUIRK(ASAHIOPTICAL, OPTIO330, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
216 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
217 	USB_QUIRK(ATP, EUSB, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
218 	USB_QUIRK(BELKIN, USB2SCSI, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
219 	    UQ_MSC_FORCE_PROTO_SCSI),
220 	USB_QUIRK(CASIO, QV_DIGICAM, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
221 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
222 	USB_QUIRK(CCYU, ED1064, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
223 	    UQ_MSC_FORCE_PROTO_SCSI),
224 	USB_QUIRK(CENTURY, EX35QUAT, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
225 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_FORCE_SHORT_INQ,
226 	    UQ_MSC_NO_START_STOP, UQ_MSC_IGNORE_RESIDUE),
227 	USB_QUIRK(CREATIVE, NOMAD, 0x0001, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
228 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_READ_CAP_OFFBY1),
229 	USB_QUIRK(CYPRESS, XX6830XX, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN,
230 	    UQ_MSC_NO_SYNC_CACHE),
231 	USB_QUIRK(EMTEC, DANEELEC4GB, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
232 	USB_QUIRK(DESKNOTE, UCR_61S2B, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
233 	    UQ_MSC_FORCE_PROTO_SCSI),
234 	USB_QUIRK(DMI, CFSM_RW, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI,
235 	    UQ_MSC_NO_GETMAXLUN),
236 	USB_QUIRK(EMTEC, RUF2PS, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
237 	USB_QUIRK(EPSON, STYLUS_875DC, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
238 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
239 	USB_QUIRK(EPSON, STYLUS_895, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
240 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_GETMAXLUN),
241 	USB_QUIRK(FEIYA, 5IN1, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
242 	    UQ_MSC_FORCE_PROTO_SCSI),
243 	USB_QUIRK(FEIYA, ELANGO, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
244 	USB_QUIRK(FREECOM, DVD, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
245 	USB_QUIRK(FUJIPHOTO, MASS0100, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI_I,
246 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_NO_RS_CLEAR_UA, UQ_MSC_NO_SYNC_CACHE),
247 	USB_QUIRK(GARMIN, DAKOTA20, 0x0000, 0xffff, UQ_MSC_NO_INQUIRY),
248 	USB_QUIRK(GARMIN, FORERUNNER230, 0x0000, 0xffff, UQ_MSC_NO_INQUIRY),
249 	USB_QUIRK(GARMIN, GPSMAP62S, 0x0000, 0xffff, UQ_MSC_NO_INQUIRY),
250 	USB_QUIRK(GARMIN, EDGETOURINGPLUS, 0x0000, 0xffff, UQ_MSC_NO_INQUIRY),
251 	USB_QUIRK(GARMIN, INSTINCTSOLAR, 0x0000, 0xffff, UQ_MSC_NO_INQUIRY),
252 	USB_QUIRK(GENESYS, GL641USB2IDE, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
253 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_FORCE_SHORT_INQ,
254 	    UQ_MSC_NO_START_STOP, UQ_MSC_IGNORE_RESIDUE, UQ_MSC_NO_SYNC_CACHE),
255 	USB_QUIRK(GENESYS, GL641USB2IDE_2, 0x0000, 0xffff,
256 	    UQ_MSC_FORCE_WIRE_BBB, UQ_MSC_FORCE_PROTO_ATAPI,
257 	    UQ_MSC_FORCE_SHORT_INQ, UQ_MSC_NO_START_STOP,
258 	    UQ_MSC_IGNORE_RESIDUE),
259 	USB_QUIRK(GENESYS, GL641USB, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
260 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_FORCE_SHORT_INQ,
261 	    UQ_MSC_NO_START_STOP, UQ_MSC_IGNORE_RESIDUE),
262 	USB_QUIRK(GENESYS, GL641USB_2, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
263 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_WRONG_CSWSIG),
264 	USB_QUIRK(HAGIWARA, FG, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
265 	    UQ_MSC_FORCE_PROTO_SCSI),
266 	USB_QUIRK(HAGIWARA, FGSM, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
267 	    UQ_MSC_FORCE_PROTO_SCSI),
268 	USB_QUIRK(HITACHI, DVDCAM_DZ_MV100A, 0x0000, 0xffff,
269 	    UQ_MSC_FORCE_WIRE_CBI, UQ_MSC_FORCE_PROTO_SCSI,
270 	    UQ_MSC_NO_GETMAXLUN),
271 	USB_QUIRK(HITACHI, DVDCAM_USB, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI_I,
272 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_NO_INQUIRY),
273 	USB_QUIRK(HP, CDW4E, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_ATAPI),
274 	USB_QUIRK(HP, CDW8200, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI_I,
275 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_NO_TEST_UNIT_READY,
276 	    UQ_MSC_NO_START_STOP),
277 	USB_QUIRK(HUAWEI, E3372_INIT, 0, 0xffff, UQ_MSC_NO_INQUIRY,
278 	    UQ_MSC_NO_GETMAXLUN),
279 	USB_QUIRK(IMAGINATION, DBX1, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
280 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_WRONG_CSWSIG),
281 	USB_QUIRK(INSYSTEM, USBCABLE, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
282 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_NO_TEST_UNIT_READY,
283 	    UQ_MSC_NO_START_STOP, UQ_MSC_ALT_IFACE_1),
284 	USB_QUIRK(INSYSTEM, ATAPI, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
285 	    UQ_MSC_FORCE_PROTO_RBC),
286 	USB_QUIRK(INSYSTEM, STORAGE_V2, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
287 	    UQ_MSC_FORCE_PROTO_RBC),
288 	USB_QUIRK(VIALABS, VL701, 0x0000, 0xffff, UQ_MSC_NO_INQUIRY),
289 	USB_QUIRK(IODATA, IU_CD2, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
290 	    UQ_MSC_FORCE_PROTO_SCSI),
291 	USB_QUIRK(IODATA, DVR_UEH8, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
292 	    UQ_MSC_FORCE_PROTO_SCSI),
293 	USB_QUIRK(IOMEGA, ZIP100, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
294 	    UQ_MSC_FORCE_PROTO_SCSI,
295 	    UQ_MSC_NO_TEST_UNIT_READY), /* XXX ZIP drives can also use ATAPI */
296 	USB_QUIRK(JMICRON, JMS566, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN),
297 	USB_QUIRK(JMICRON, JMS567, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN),
298 	USB_QUIRK(JMICRON, JM20337, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
299 	    UQ_MSC_FORCE_PROTO_SCSI,
300 	    UQ_MSC_NO_SYNC_CACHE),
301 	USB_QUIRK(KINGSTON, HYPERX3_0, 0x0000, 0xffff, UQ_MSC_NO_INQUIRY),
302 	USB_QUIRK(KINGSTON, DATATRAVELER3_0, 0x0000, 0xffff, UQ_MSC_NO_PREVENT_ALLOW, UQ_MSC_NO_SYNC_CACHE),
303 	USB_QUIRK(KYOCERA, FINECAM_L3, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
304 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
305 	USB_QUIRK(KYOCERA, FINECAM_S3X, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
306 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_NO_INQUIRY),
307 	USB_QUIRK(KYOCERA, FINECAM_S4, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
308 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_NO_INQUIRY),
309 	USB_QUIRK(KYOCERA, FINECAM_S5, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
310 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
311 	USB_QUIRK(LACIE, HD, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
312 	    UQ_MSC_FORCE_PROTO_RBC),
313 	USB_QUIRK(LEXAR, CF_READER, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
314 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
315 	USB_QUIRK(LEXAR, JUMPSHOT, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
316 	USB_QUIRK(LEXAR, JUMPDRIVE, 0x0000, 0xffff, UQ_MSC_NO_INQUIRY),
317 	USB_QUIRK(LOGITEC, LDR_H443SU2, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
318 	USB_QUIRK(LOGITEC, LDR_H443U2, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
319 	    UQ_MSC_FORCE_PROTO_SCSI,),
320 	USB_QUIRK(MELCO, DUBPXXG, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
321 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_FORCE_SHORT_INQ,
322 	    UQ_MSC_NO_START_STOP, UQ_MSC_IGNORE_RESIDUE),
323 	USB_QUIRK(MICROTECH, DPCM, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
324 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_TEST_UNIT_READY,
325 	    UQ_MSC_NO_START_STOP),
326 	USB_QUIRK(MICRON, REALSSD, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
327 	USB_QUIRK(MICROTECH, SCSIDB25, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
328 	    UQ_MSC_FORCE_PROTO_SCSI),
329 	USB_QUIRK(MICROTECH, SCSIHD50, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
330 	    UQ_MSC_FORCE_PROTO_SCSI),
331 	USB_QUIRK(MINOLTA, E223, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
332 	USB_QUIRK(MINOLTA, F300, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
333 	    UQ_MSC_FORCE_PROTO_SCSI),
334 	USB_QUIRK(MITSUMI, CDRRW, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI |
335 	    UQ_MSC_FORCE_PROTO_ATAPI),
336 	USB_QUIRK(MOTOROLA2, E398, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
337 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_FORCE_SHORT_INQ,
338 	    UQ_MSC_NO_INQUIRY_EVPD, UQ_MSC_NO_GETMAXLUN),
339 	USB_QUIRK_VP(USB_VENDOR_MPMAN, 0, UQ_MSC_NO_SYNC_CACHE,
340 	    UQ_MATCH_VENDOR_ONLY),
341 	USB_QUIRK(MSYSTEMS, DISKONKEY, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
342 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE, UQ_MSC_NO_GETMAXLUN,
343 	    UQ_MSC_NO_RS_CLEAR_UA),
344 	USB_QUIRK(MSYSTEMS, DISKONKEY2, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
345 	    UQ_MSC_FORCE_PROTO_ATAPI),
346 	USB_QUIRK(MYSON, HEDEN, 0x0000, 0xffff, UQ_MSC_IGNORE_RESIDUE,
347 	    UQ_MSC_NO_SYNC_CACHE),
348 	USB_QUIRK(NEODIO, ND3260, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
349 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_FORCE_SHORT_INQ),
350 	USB_QUIRK(NETAC, CF_CARD, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
351 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
352 	USB_QUIRK(NETAC, ONLYDISK, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
353 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE),
354 	USB_QUIRK(NETCHIP, CLIK_40, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_ATAPI,
355 	    UQ_MSC_NO_INQUIRY),
356 	USB_QUIRK(NETCHIP, POCKETBOOK, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
357 	USB_QUIRK(NIKON, D300, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
358 	    UQ_MSC_FORCE_PROTO_SCSI),
359 	USB_QUIRK(OLYMPUS, C1, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
360 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_WRONG_CSWSIG),
361 	USB_QUIRK(OLYMPUS, C700, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN),
362         /* Selected Olympus DSLR and EVIL models.  See ../usbdevs for more
363 	 * details.
364 	 *
365 	 * Not all quirks apply to all models.  The commented-out entries are
366 	 * correct for that model.
367 	 */
368 	USB_QUIRK(OLYMPUS, E_1, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN,
369 	    UQ_MSC_NO_TEST_UNIT_READY, UQ_MSC_NO_PREVENT_ALLOW,
370             UQ_MSC_NO_SYNC_CACHE),
371 	/*
372 	 * Product code 0x118.
373 	 * USB_QUIRK(OLYMPUS, E_300, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN,
374 	 *     UQ_MSC_NO_TEST_UNIT_READY, UQ_MSC_NO_PREVENT_ALLOW,
375          *     UQ_MSC_NO_SYNC_CACHE),
376 	 * USB_QUIRK(OLYMPUS, E_30, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN,
377 	 *     UQ_MSC_NO_TEST_UNIT_READY, UQ_MSC_NO_PREVENT_ALLOW,
378          *     UQ_MSC_NO_SYNC_CACHE), */
379 	USB_QUIRK(OLYMPUS, E_330, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN,
380 	    UQ_MSC_NO_TEST_UNIT_READY, UQ_MSC_NO_PREVENT_ALLOW,
381             UQ_MSC_NO_SYNC_CACHE, UQ_MSC_NO_START_STOP),
382 	USB_QUIRK(OLYMPUS, E_PM1, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN,
383 	    UQ_MSC_NO_TEST_UNIT_READY, UQ_MSC_NO_PREVENT_ALLOW,
384             UQ_MSC_NO_SYNC_CACHE, UQ_MSC_NO_START_STOP),
385         /* Product code 0x12e.
386 	 * USB_QUIRK(OLYMPUS, E_PM2, 0x0000, 0xffff, 0),
387 	 * USB_QUIRK(OLYMPUS, E_M1MarkII, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN,
388 	 *     UQ_MSC_NO_TEST_UNIT_READY, UQ_MSC_NO_PREVENT_ALLOW,
389 	 *     UQ_MSC_NO_SYNC_CACHE),
390 	 * USB_QUIRK(OLYMPUS, E_M5MarkIII, 0x0000, 0xffff, 0),
391 	 */
392 	USB_QUIRK(OLYMPUS, E_M1, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN,
393 	    UQ_MSC_NO_TEST_UNIT_READY, UQ_MSC_NO_PREVENT_ALLOW,
394             UQ_MSC_NO_SYNC_CACHE, UQ_MSC_NO_START_STOP),
395 	USB_QUIRK(ONSPEC, SDS_HOTFIND_D, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
396 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_GETMAXLUN, UQ_MSC_NO_SYNC_CACHE),
397 	USB_QUIRK(ONSPEC, CFMS_RW, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
398 	USB_QUIRK(ONSPEC, CFSM_COMBO, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
399 	USB_QUIRK(ONSPEC, CFSM_READER, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
400 	USB_QUIRK(ONSPEC, CFSM_READER2, 0x0000, 0xffff,
401 	    UQ_MSC_FORCE_PROTO_SCSI),
402 	USB_QUIRK(ONSPEC, MDCFE_B_CF_READER, 0x0000, 0xffff,
403 	    UQ_MSC_FORCE_PROTO_SCSI),
404 	USB_QUIRK(ONSPEC, MDSM_B_READER, 0x0000, 0xffff,
405 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
406 	USB_QUIRK(ONSPEC, READER, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
407 	USB_QUIRK(ONSPEC, UCF100, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
408 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_NO_INQUIRY, UQ_MSC_NO_GETMAXLUN),
409 	USB_QUIRK(ONSPEC2, IMAGEMATE_SDDR55, 0x0000, 0xffff,
410 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_GETMAXLUN),
411 	USB_QUIRK(PANASONIC, KXL840AN, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
412 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_NO_GETMAXLUN),
413 	USB_QUIRK(PANASONIC, KXLCB20AN, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
414 	    UQ_MSC_FORCE_PROTO_SCSI),
415 	USB_QUIRK(PANASONIC, KXLCB35AN, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
416 	    UQ_MSC_FORCE_PROTO_SCSI),
417 	USB_QUIRK(PANASONIC, LS120CAM, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_UFI),
418 	USB_QUIRK(PLEXTOR, 40_12_40U, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
419 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_TEST_UNIT_READY),
420 	USB_QUIRK(PNY, ATTACHE2, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
421 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE,
422 	    UQ_MSC_NO_START_STOP),
423 	USB_QUIRK(PROLIFIC, PL2506, 0x0000, 0xffff,
424 	    UQ_MSC_NO_SYNC_CACHE, UQ_MSC_NO_PREVENT_ALLOW),
425 	USB_QUIRK_VP(USB_VENDOR_SAMSUNG_TECHWIN,
426 	    USB_PRODUCT_SAMSUNG_TECHWIN_DIGIMAX_410, UQ_MSC_FORCE_WIRE_BBB,
427 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
428 	USB_QUIRK(SANDISK, SDDR05A, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
429 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_READ_CAP_OFFBY1,
430 	    UQ_MSC_NO_GETMAXLUN),
431 	USB_QUIRK(SANDISK, SDDR09, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI,
432 	    UQ_MSC_READ_CAP_OFFBY1, UQ_MSC_NO_GETMAXLUN),
433 	USB_QUIRK(SANDISK, SDDR12, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
434 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_READ_CAP_OFFBY1,
435 	    UQ_MSC_NO_GETMAXLUN),
436 	USB_QUIRK(SANDISK, SDCZ2_128, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
437 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE,
438 	    UQ_MSC_NO_SYNC_CACHE),
439 	USB_QUIRK(SANDISK, SDCZ2_256, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
440 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE),
441 	USB_QUIRK(SANDISK, SDCZ4_128, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
442 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE),
443 	USB_QUIRK(SANDISK, SDCZ4_256, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
444 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE),
445 	USB_QUIRK(SANDISK, SDCZ48_32, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE,
446 	    UQ_MSC_NO_TEST_UNIT_READY),
447 	USB_QUIRK(SANDISK, SDDR31, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
448 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_READ_CAP_OFFBY1),
449 	USB_QUIRK(SANDISK, IMAGEMATE_SDDR289, 0x0000, 0xffff,
450 	    UQ_MSC_NO_SYNC_CACHE, UQ_MSC_NO_GETMAXLUN),
451 	USB_QUIRK(SCANLOGIC, SL11R, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
452 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_NO_INQUIRY),
453 	USB_QUIRK(SHUTTLE, EUSB, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI_I,
454 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_NO_TEST_UNIT_READY,
455 	    UQ_MSC_NO_START_STOP, UQ_MSC_SHUTTLE_INIT),
456 	USB_QUIRK(SHUTTLE, CDRW, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
457 	    UQ_MSC_FORCE_PROTO_ATAPI),
458 	USB_QUIRK(SHUTTLE, CF, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
459 	    UQ_MSC_FORCE_PROTO_ATAPI),
460 	USB_QUIRK(SHUTTLE, EUSBATAPI, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
461 	    UQ_MSC_FORCE_PROTO_ATAPI),
462 	USB_QUIRK(SHUTTLE, EUSBCFSM, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
463 	USB_QUIRK(SHUTTLE, EUSCSI, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
464 	    UQ_MSC_FORCE_PROTO_SCSI),
465 	USB_QUIRK(SHUTTLE, HIFD, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
466 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_GETMAXLUN),
467 	USB_QUIRK(SHUTTLE, SDDR09, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI,
468 	    UQ_MSC_NO_GETMAXLUN),
469 	USB_QUIRK(SHUTTLE, ZIOMMC, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
470 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_GETMAXLUN),
471 	USB_QUIRK(SIGMATEL, I_BEAD100, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
472 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_SHUTTLE_INIT),
473 	USB_QUIRK(SIIG, WINTERREADER, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
474 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_IGNORE_RESIDUE),
475 	USB_QUIRK(SKANHEX, MD_7425, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
476 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
477 	USB_QUIRK(SKANHEX, SX_520Z, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
478 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
479 	USB_QUIRK(SONY, HANDYCAM, 0x0500, 0x0500, UQ_MSC_FORCE_WIRE_CBI,
480 	    UQ_MSC_FORCE_PROTO_RBC, UQ_MSC_RBC_PAD_TO_12),
481 	USB_QUIRK(SONY, CLIE_40_MS, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
482 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
483 	USB_QUIRK(SONY, DSC, 0x0500, 0x0500, UQ_MSC_FORCE_WIRE_CBI,
484 	    UQ_MSC_FORCE_PROTO_RBC, UQ_MSC_RBC_PAD_TO_12),
485 	USB_QUIRK(SONY, DSC, 0x0600, 0x0600, UQ_MSC_FORCE_WIRE_CBI,
486 	    UQ_MSC_FORCE_PROTO_RBC, UQ_MSC_RBC_PAD_TO_12),
487 	USB_QUIRK(SONY, DSC, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
488 	    UQ_MSC_FORCE_PROTO_RBC),
489 	USB_QUIRK(SONY, HANDYCAM, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
490 	    UQ_MSC_FORCE_PROTO_RBC),
491 	USB_QUIRK(SONY, MSC, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
492 	    UQ_MSC_FORCE_PROTO_RBC),
493 	USB_QUIRK(SONY, MS_MSC_U03, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
494 	    UQ_MSC_FORCE_PROTO_UFI, UQ_MSC_NO_GETMAXLUN),
495 	USB_QUIRK(SONY, MS_NW_MS7, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
496 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_GETMAXLUN),
497 	USB_QUIRK(SONY, MS_PEG_N760C, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
498 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
499 	USB_QUIRK(SONY, MSACUS1, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
500 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_GETMAXLUN),
501 	USB_QUIRK(SONY, PORTABLE_HDD_V2, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
502 	    UQ_MSC_FORCE_PROTO_SCSI),
503 	USB_QUIRK(STMICRO, ST72682, 0x0000, 0xffff, UQ_MSC_NO_PREVENT_ALLOW),
504 	USB_QUIRK(SUPERTOP, IDE, 0x0000, 0xffff, UQ_MSC_IGNORE_RESIDUE,
505 	    UQ_MSC_NO_SYNC_CACHE),
506 	USB_QUIRK(SUPERTOP, FLASHDRIVE, 0x0000, 0xffff, UQ_MSC_NO_TEST_UNIT_READY,
507 	    UQ_MSC_NO_SYNC_CACHE),
508 	USB_QUIRK(TAUGA, CAMERAMATE, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
509 	USB_QUIRK(TEAC, FD05PUB, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
510 	    UQ_MSC_FORCE_PROTO_UFI),
511 	USB_QUIRK(TECLAST, TLC300, 0x0000, 0xffff, UQ_MSC_NO_TEST_UNIT_READY,
512 	    UQ_MSC_NO_SYNC_CACHE),
513 	USB_QUIRK(TREK, MEMKEY, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
514 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
515 	USB_QUIRK(TREK, THUMBDRIVE_8MB, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
516 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_IGNORE_RESIDUE),
517 	USB_QUIRK(TRUMPION, C3310, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
518 	    UQ_MSC_FORCE_PROTO_UFI),
519 	USB_QUIRK(TRUMPION, MP3, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_RBC),
520 	USB_QUIRK(TRUMPION, T33520, 0x0000, 0xffff, UQ_MSC_FORCE_PROTO_SCSI),
521 	USB_QUIRK(TWINMOS, MDIV, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
522 	    UQ_MSC_FORCE_PROTO_SCSI),
523 	USB_QUIRK(VIA, USB2IDEBRIDGE, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
524 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_SYNC_CACHE),
525 	USB_QUIRK(VIVITAR, 35XX, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
526 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
527 	USB_QUIRK(WESTERN, COMBO, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
528 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_FORCE_SHORT_INQ,
529 	    UQ_MSC_NO_START_STOP, UQ_MSC_IGNORE_RESIDUE),
530 	USB_QUIRK(WESTERN, EXTHDD, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
531 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_FORCE_SHORT_INQ,
532 	    UQ_MSC_NO_START_STOP, UQ_MSC_IGNORE_RESIDUE),
533 	USB_QUIRK(WESTERN, MYBOOK, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
534 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY_EVPD,
535 	    UQ_MSC_NO_SYNC_CACHE),
536 	USB_QUIRK(WESTERN, MYPASSPORT_00, 0x0000, 0xffff, UQ_MSC_FORCE_SHORT_INQ),
537 	USB_QUIRK(WESTERN, MYPASSPORT_01, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
538 	USB_QUIRK(WESTERN, MYPASSPORT_02, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
539 	USB_QUIRK(WESTERN, MYPASSPORT_03, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
540 	USB_QUIRK(WESTERN, MYPASSPORT_04, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
541 	USB_QUIRK(WESTERN, MYPASSPORT_05, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
542 	USB_QUIRK(WESTERN, MYPASSPORT_06, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
543 	USB_QUIRK(WESTERN, MYPASSPORT_07, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
544 	USB_QUIRK(WESTERN, MYPASSPORT_08, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
545 	USB_QUIRK(WESTERN, MYPASSPORT_09, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
546 	USB_QUIRK(WESTERN, MYPASSPORT_10, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
547 	USB_QUIRK(WESTERN, MYPASSPORT_11, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
548 	USB_QUIRK(WESTERN, MYPASSPORTES_00, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
549 	USB_QUIRK(WESTERN, MYPASSPORTES_01, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
550 	USB_QUIRK(WESTERN, MYPASSPORTES_02, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
551 	USB_QUIRK(WESTERN, MYPASSPORTES_03, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
552 	USB_QUIRK(WESTERN, MYPASSPORTES_04, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
553 	USB_QUIRK(WESTERN, MYPASSPORTES_05, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
554 	USB_QUIRK(WESTERN, MYPASSPORTES_06, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
555 	USB_QUIRK(WESTERN, MYPASSPORTES_07, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
556 	USB_QUIRK(WESTERN, MYPASSPORTES_08, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
557 	USB_QUIRK(WESTERN, MYPASSPORTES_09, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
558 	USB_QUIRK(WINMAXGROUP, FLASH64MC, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
559 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY),
560 	USB_QUIRK(YANO, FW800HD, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
561 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_FORCE_SHORT_INQ,
562 	    UQ_MSC_NO_START_STOP, UQ_MSC_IGNORE_RESIDUE),
563 	USB_QUIRK(YANO, U640MO, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI_I,
564 	    UQ_MSC_FORCE_PROTO_ATAPI, UQ_MSC_FORCE_SHORT_INQ),
565 	USB_QUIRK(YEDATA, FLASHBUSTERU, 0x0000, 0x007F, UQ_MSC_FORCE_WIRE_CBI,
566 	    UQ_MSC_FORCE_PROTO_UFI, UQ_MSC_NO_RS_CLEAR_UA, UQ_MSC_FLOPPY_SPEED,
567 	    UQ_MSC_NO_TEST_UNIT_READY, UQ_MSC_NO_GETMAXLUN),
568 	USB_QUIRK(YEDATA, FLASHBUSTERU, 0x0080, 0x0080, UQ_MSC_FORCE_WIRE_CBI_I,
569 	    UQ_MSC_FORCE_PROTO_UFI, UQ_MSC_NO_RS_CLEAR_UA, UQ_MSC_FLOPPY_SPEED,
570 	    UQ_MSC_NO_TEST_UNIT_READY, UQ_MSC_NO_GETMAXLUN),
571 	USB_QUIRK(YEDATA, FLASHBUSTERU, 0x0081, 0xFFFF, UQ_MSC_FORCE_WIRE_CBI_I,
572 	    UQ_MSC_FORCE_PROTO_UFI, UQ_MSC_NO_RS_CLEAR_UA, UQ_MSC_FLOPPY_SPEED,
573 	    UQ_MSC_NO_GETMAXLUN),
574 	USB_QUIRK(ZORAN, EX20DSC, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_CBI,
575 	    UQ_MSC_FORCE_PROTO_ATAPI),
576 	USB_QUIRK(MEIZU, M6_SL, 0x0000, 0xffff, UQ_MSC_FORCE_WIRE_BBB,
577 	    UQ_MSC_FORCE_PROTO_SCSI, UQ_MSC_NO_INQUIRY, UQ_MSC_NO_SYNC_CACHE),
578 	USB_QUIRK(TOSHIBA, TRANSMEMORY, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE,
579 	    UQ_MSC_NO_PREVENT_ALLOW),
580 	USB_QUIRK(VIALABS, USB30SATABRIDGE, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE),
581 	USB_QUIRK(QUALCOMMINC, ZTE_MF730M, 0x0000, 0xffff, UQ_MSC_NO_GETMAXLUN,
582 	    UQ_MSC_NO_INQUIRY, UQ_CFG_INDEX_0),
583 	USB_QUIRK(SMART2, G2MEMKEY, 0x0000, 0xffff, UQ_MSC_NO_INQUIRY),
584 	USB_QUIRK(RALINK, RT_STOR, 0x0001, 0x0001, UQ_MSC_IGNORE),
585 	USB_QUIRK(REALTEK, RTW8821CU_CD, 0x0001, 0x0001, UQ_MSC_IGNORE),
586 	/* Non-standard USB MIDI devices */
587 	USB_QUIRK(ROLAND, UM1, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
588 	USB_QUIRK(ROLAND, SC8850, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
589 	USB_QUIRK(ROLAND, SD90, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
590 	USB_QUIRK(ROLAND, UM880N, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
591 	USB_QUIRK(ROLAND, UA100, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
592 	USB_QUIRK(ROLAND, UM4, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
593 	USB_QUIRK(ROLAND, U8, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
594 	USB_QUIRK(ROLAND, UM2, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
595 	USB_QUIRK(ROLAND, SC8820, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
596 	USB_QUIRK(ROLAND, PC300, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
597 	USB_QUIRK(ROLAND, SK500, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
598 	USB_QUIRK(ROLAND, SCD70, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
599 	USB_QUIRK(ROLAND, UM550, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
600 	USB_QUIRK(ROLAND, SD20, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
601 	USB_QUIRK(ROLAND, SD80, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
602 	USB_QUIRK(ROLAND, UA700, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
603 	USB_QUIRK(ROLAND, PCR300, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
604 	USB_QUIRK(EGO, M4U, 0x0000, 0xffff, UQ_SINGLE_CMD_MIDI),
605 	USB_QUIRK(LOGILINK, U2M, 0x0000, 0xffff, UQ_SINGLE_CMD_MIDI),
606 	USB_QUIRK(MEDELI, DD305, 0x0000, 0xffff, UQ_SINGLE_CMD_MIDI, UQ_MATCH_VENDOR_ONLY),
607 	USB_QUIRK(REDOCTANE, GHMIDI, 0x0000, 0xffff, UQ_SINGLE_CMD_MIDI),
608 	USB_QUIRK(TEXTECH, U2M_1, 0x0000, 0xffff, UQ_SINGLE_CMD_MIDI),
609 	USB_QUIRK(TEXTECH, U2M_2, 0x0000, 0xffff, UQ_SINGLE_CMD_MIDI),
610 	USB_QUIRK(WCH2, U2M, 0x0000, 0xffff, UQ_SINGLE_CMD_MIDI),
611 
612 	/* Non-standard USB AUDIO devices */
613 	USB_QUIRK(MAUDIO, FASTTRACKULTRA, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
614 	USB_QUIRK(MAUDIO, FASTTRACKULTRA8R, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
615 	USB_QUIRK(CMEDIA, CM6206, 0x0000, 0xffff, UQ_AU_SET_SPDIF_CM6206),
616 	USB_QUIRK(PLOYTEC, SPL_CRIMSON_1, 0x0000, 0xffff, UQ_CFG_INDEX_1),
617 	USB_QUIRK(ROLAND, UA25EX_AD, 0x0000, 0xffff, UQ_AU_VENDOR_CLASS),
618 
619 	/*
620 	 * Quirks for manufacturers which USB devices does not respond
621 	 * after issuing non-supported commands:
622 	 */
623 	USB_QUIRK(ALCOR, DUMMY, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE, UQ_MSC_NO_TEST_UNIT_READY, UQ_MATCH_VENDOR_ONLY),
624 	USB_QUIRK(APPLE, DUMMY, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE, UQ_MATCH_VENDOR_ONLY),
625 	USB_QUIRK(FEIYA, DUMMY, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE, UQ_MATCH_VENDOR_ONLY),
626 	USB_QUIRK(REALTEK, DUMMY, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE, UQ_MATCH_VENDOR_ONLY),
627 	USB_QUIRK(INITIO, DUMMY, 0x0000, 0xffff, UQ_MSC_NO_SYNC_CACHE, UQ_MATCH_VENDOR_ONLY),
628 
629 	/* DYMO LabelManager Pnp */
630 	USB_QUIRK(DYMO, LABELMANAGERPNP, 0x0000, 0xffff, UQ_MSC_DYMO_EJECT),
631 
632 	/* Holtek USB gaming keyboard */
633 	USB_QUIRK(HOLTEK, F85, 0x0000, 0xffff, UQ_KBD_BOOTPROTO),
634 };
635 #undef USB_QUIRK_VP
636 #undef USB_QUIRK
637 
638 static const char *usb_quirk_str[USB_QUIRK_MAX] = {
639 	[UQ_NONE]		= "UQ_NONE",
640 	[UQ_MATCH_VENDOR_ONLY]	= "UQ_MATCH_VENDOR_ONLY",
641 	[UQ_AUDIO_SWAP_LR]	= "UQ_AUDIO_SWAP_LR",
642 	[UQ_AU_INP_ASYNC]	= "UQ_AU_INP_ASYNC",
643 	[UQ_AU_NO_FRAC]		= "UQ_AU_NO_FRAC",
644 	[UQ_AU_NO_XU]		= "UQ_AU_NO_XU",
645 	[UQ_BAD_ADC]		= "UQ_BAD_ADC",
646 	[UQ_BAD_AUDIO]		= "UQ_BAD_AUDIO",
647 	[UQ_BROKEN_BIDIR]	= "UQ_BROKEN_BIDIR",
648 	[UQ_BUS_POWERED]	= "UQ_BUS_POWERED",
649 	[UQ_HID_IGNORE]		= "UQ_HID_IGNORE",
650 	[UQ_KBD_IGNORE]		= "UQ_KBD_IGNORE",
651 	[UQ_KBD_BOOTPROTO]	= "UQ_KBD_BOOTPROTO",
652 	[UQ_UMS_IGNORE]		= "UQ_UMS_IGNORE",
653 	[UQ_MS_BAD_CLASS]	= "UQ_MS_BAD_CLASS",
654 	[UQ_MS_LEADING_BYTE]	= "UQ_MS_LEADING_BYTE",
655 	[UQ_MS_REVZ]		= "UQ_MS_REVZ",
656 	[UQ_MS_VENDOR_BTN]	= "UQ_MS_VENDOR_BTN",
657 	[UQ_NO_STRINGS]		= "UQ_NO_STRINGS",
658 	[UQ_POWER_CLAIM]	= "UQ_POWER_CLAIM",
659 	[UQ_SPUR_BUT_UP]	= "UQ_SPUR_BUT_UP",
660 	[UQ_SWAP_UNICODE]	= "UQ_SWAP_UNICODE",
661 	[UQ_CFG_INDEX_1]	= "UQ_CFG_INDEX_1",
662 	[UQ_CFG_INDEX_2]	= "UQ_CFG_INDEX_2",
663 	[UQ_CFG_INDEX_3]	= "UQ_CFG_INDEX_3",
664 	[UQ_CFG_INDEX_4]	= "UQ_CFG_INDEX_4",
665 	[UQ_CFG_INDEX_0]	= "UQ_CFG_INDEX_0",
666 	[UQ_ASSUME_CM_OVER_DATA]	= "UQ_ASSUME_CM_OVER_DATA",
667 	[UQ_IGNORE_CDC_CM]	= "UQ_IGNORE_CDC_CM",
668 	[UQ_MSC_NO_TEST_UNIT_READY]	= "UQ_MSC_NO_TEST_UNIT_READY",
669 	[UQ_MSC_NO_RS_CLEAR_UA]		= "UQ_MSC_NO_RS_CLEAR_UA",
670 	[UQ_MSC_NO_START_STOP]		= "UQ_MSC_NO_START_STOP",
671 	[UQ_MSC_NO_GETMAXLUN]		= "UQ_MSC_NO_GETMAXLUN",
672 	[UQ_MSC_NO_INQUIRY]		= "UQ_MSC_NO_INQUIRY",
673 	[UQ_MSC_NO_INQUIRY_EVPD]	= "UQ_MSC_NO_INQUIRY_EVPD",
674 	[UQ_MSC_NO_PREVENT_ALLOW]	= "UQ_MSC_NO_PREVENT_ALLOW",
675 	[UQ_MSC_NO_SYNC_CACHE]		= "UQ_MSC_NO_SYNC_CACHE",
676 	[UQ_MSC_SHUTTLE_INIT]		= "UQ_MSC_SHUTTLE_INIT",
677 	[UQ_MSC_ALT_IFACE_1]		= "UQ_MSC_ALT_IFACE_1",
678 	[UQ_MSC_FLOPPY_SPEED]		= "UQ_MSC_FLOPPY_SPEED",
679 	[UQ_MSC_IGNORE_RESIDUE]		= "UQ_MSC_IGNORE_RESIDUE",
680 	[UQ_MSC_WRONG_CSWSIG]		= "UQ_MSC_WRONG_CSWSIG",
681 	[UQ_MSC_RBC_PAD_TO_12]		= "UQ_MSC_RBC_PAD_TO_12",
682 	[UQ_MSC_READ_CAP_OFFBY1]	= "UQ_MSC_READ_CAP_OFFBY1",
683 	[UQ_MSC_FORCE_SHORT_INQ]	= "UQ_MSC_FORCE_SHORT_INQ",
684 	[UQ_MSC_FORCE_WIRE_BBB]		= "UQ_MSC_FORCE_WIRE_BBB",
685 	[UQ_MSC_FORCE_WIRE_CBI]		= "UQ_MSC_FORCE_WIRE_CBI",
686 	[UQ_MSC_FORCE_WIRE_CBI_I]	= "UQ_MSC_FORCE_WIRE_CBI_I",
687 	[UQ_MSC_FORCE_PROTO_SCSI]	= "UQ_MSC_FORCE_PROTO_SCSI",
688 	[UQ_MSC_FORCE_PROTO_ATAPI]	= "UQ_MSC_FORCE_PROTO_ATAPI",
689 	[UQ_MSC_FORCE_PROTO_UFI]	= "UQ_MSC_FORCE_PROTO_UFI",
690 	[UQ_MSC_FORCE_PROTO_RBC]	= "UQ_MSC_FORCE_PROTO_RBC",
691 	[UQ_MSC_IGNORE]			= "UQ_MSC_IGNORE",
692 	[UQ_MSC_EJECT_HUAWEI]		= "UQ_MSC_EJECT_HUAWEI",
693 	[UQ_MSC_EJECT_SIERRA]		= "UQ_MSC_EJECT_SIERRA",
694 	[UQ_MSC_EJECT_SCSIEJECT]	= "UQ_MSC_EJECT_SCSIEJECT",
695 	[UQ_MSC_EJECT_REZERO]		= "UQ_MSC_EJECT_REZERO",
696 	[UQ_MSC_EJECT_ZTESTOR]		= "UQ_MSC_EJECT_ZTESTOR",
697 	[UQ_MSC_EJECT_CMOTECH]		= "UQ_MSC_EJECT_CMOTECH",
698 	[UQ_MSC_EJECT_WAIT]		= "UQ_MSC_EJECT_WAIT",
699 	[UQ_MSC_EJECT_SAEL_M460]	= "UQ_MSC_EJECT_SAEL_M460",
700 	[UQ_MSC_EJECT_HUAWEISCSI]	= "UQ_MSC_EJECT_HUAWEISCSI",
701 	[UQ_MSC_EJECT_HUAWEISCSI2]	= "UQ_MSC_EJECT_HUAWEISCSI2",
702 	[UQ_MSC_EJECT_HUAWEISCSI3]	= "UQ_MSC_EJECT_HUAWEISCSI3",
703 	[UQ_MSC_EJECT_HUAWEISCSI4]	= "UQ_MSC_EJECT_HUAWEISCSI4",
704 	[UQ_MSC_EJECT_TCT]		= "UQ_MSC_EJECT_TCT",
705 	[UQ_BAD_MIDI]			= "UQ_BAD_MIDI",
706 	[UQ_AU_VENDOR_CLASS]		= "UQ_AU_VENDOR_CLASS",
707 	[UQ_SINGLE_CMD_MIDI]		= "UQ_SINGLE_CMD_MIDI",
708 	[UQ_MSC_DYMO_EJECT]		= "UQ_MSC_DYMO_EJECT",
709 	[UQ_AU_SET_SPDIF_CM6206]	= "UQ_AU_SET_SPDIF_CM6206",
710 	[UQ_WMT_IGNORE]			= "UQ_WMT_IGNORE",
711 };
712 
713 /*------------------------------------------------------------------------*
714  *	usb_quirkstr
715  *
716  * This function converts an USB quirk code into a string.
717  *------------------------------------------------------------------------*/
718 static const char *
719 usb_quirkstr(uint16_t quirk)
720 {
721 	return ((quirk < USB_QUIRK_MAX && usb_quirk_str[quirk] != NULL) ?
722 	    usb_quirk_str[quirk] : "UQ_UNKNOWN");
723 }
724 
725 /*------------------------------------------------------------------------*
726  *	usb_strquirk
727  *
728  * This function converts a string into a USB quirk code.
729  *
730  * Returns:
731  * Less than USB_QUIRK_MAX: Quirk code
732  * Else: Quirk code not found
733  *------------------------------------------------------------------------*/
734 static uint16_t
735 usb_strquirk(const char *str, size_t len)
736 {
737 	const char *quirk;
738 	uint16_t x;
739 
740 	for (x = 0; x != USB_QUIRK_MAX; x++) {
741 		quirk = usb_quirkstr(x);
742 		if (strncmp(str, quirk, len) == 0 &&
743 		    quirk[len] == 0)
744 			break;
745 	}
746 	return (x);
747 }
748 
749 /*------------------------------------------------------------------------*
750  *	usb_test_quirk_by_info
751  *
752  * Returns:
753  * 0: Quirk not found
754  * Else: Quirk found
755  *------------------------------------------------------------------------*/
756 static uint8_t
757 usb_test_quirk_by_info(const struct usbd_lookup_info *info, uint16_t quirk)
758 {
759 	uint16_t x;
760 	uint16_t y;
761 
762 	if (quirk == UQ_NONE)
763 		goto done;
764 
765 	USB_MTX_LOCK(&usb_quirk_mtx);
766 
767 	for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) {
768 		/* see if quirk information does not match */
769 		if ((usb_quirks[x].vid != info->idVendor) ||
770 		    (usb_quirks[x].lo_rev > info->bcdDevice) ||
771 		    (usb_quirks[x].hi_rev < info->bcdDevice)) {
772 			continue;
773 		}
774 		/* see if quirk only should match vendor ID */
775 		if (usb_quirks[x].pid != info->idProduct) {
776 			if (usb_quirks[x].pid != 0)
777 				continue;
778 
779 			for (y = 0; y != USB_SUB_QUIRKS_MAX; y++) {
780 				if (usb_quirks[x].quirks[y] == UQ_MATCH_VENDOR_ONLY)
781 					break;
782 			}
783 			if (y == USB_SUB_QUIRKS_MAX)
784 				continue;
785 		}
786 		/* lookup quirk */
787 		for (y = 0; y != USB_SUB_QUIRKS_MAX; y++) {
788 			if (usb_quirks[x].quirks[y] == quirk) {
789 				USB_MTX_UNLOCK(&usb_quirk_mtx);
790 				DPRINTF("Found quirk '%s'.\n", usb_quirkstr(quirk));
791 				return (1);
792 			}
793 		}
794 	}
795 	USB_MTX_UNLOCK(&usb_quirk_mtx);
796 done:
797 	return (0);			/* no quirk match */
798 }
799 
800 static struct usb_quirk_entry *
801 usb_quirk_get_entry(uint16_t vid, uint16_t pid,
802     uint16_t lo_rev, uint16_t hi_rev, uint8_t do_alloc)
803 {
804 	uint16_t x;
805 
806 	USB_MTX_ASSERT(&usb_quirk_mtx, MA_OWNED);
807 
808 	if ((vid | pid | lo_rev | hi_rev) == 0) {
809 		/* all zero - special case */
810 		return (usb_quirks + USB_DEV_QUIRKS_MAX - 1);
811 	}
812 	/* search for an existing entry */
813 	for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) {
814 		/* see if quirk information does not match */
815 		if ((usb_quirks[x].vid != vid) ||
816 		    (usb_quirks[x].pid != pid) ||
817 		    (usb_quirks[x].lo_rev != lo_rev) ||
818 		    (usb_quirks[x].hi_rev != hi_rev)) {
819 			continue;
820 		}
821 		return (usb_quirks + x);
822 	}
823 
824 	if (do_alloc == 0) {
825 		/* no match */
826 		return (NULL);
827 	}
828 	/* search for a free entry */
829 	for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) {
830 		/* see if quirk information does not match */
831 		if ((usb_quirks[x].vid |
832 		    usb_quirks[x].pid |
833 		    usb_quirks[x].lo_rev |
834 		    usb_quirks[x].hi_rev) != 0) {
835 			continue;
836 		}
837 		usb_quirks[x].vid = vid;
838 		usb_quirks[x].pid = pid;
839 		usb_quirks[x].lo_rev = lo_rev;
840 		usb_quirks[x].hi_rev = hi_rev;
841 
842 		return (usb_quirks + x);
843 	}
844 
845 	/* no entry found */
846 	return (NULL);
847 }
848 
849 /*------------------------------------------------------------------------*
850  *	usb_quirk_ioctl - handle quirk IOCTLs
851  *
852  * Returns:
853  * 0: Success
854  * Else: Failure
855  *------------------------------------------------------------------------*/
856 static int
857 usb_quirk_ioctl(unsigned long cmd, caddr_t data,
858     int fflag, struct thread *td)
859 {
860 	struct usb_gen_quirk *pgq;
861 	struct usb_quirk_entry *pqe;
862 	uint32_t x;
863 	uint32_t y;
864 	int err;
865 
866 	switch (cmd) {
867 	case USB_DEV_QUIRK_GET:
868 		pgq = (void *)data;
869 		x = pgq->index % USB_SUB_QUIRKS_MAX;
870 		y = pgq->index / USB_SUB_QUIRKS_MAX;
871 		if (y >= USB_DEV_QUIRKS_MAX) {
872 			return (EINVAL);
873 		}
874 		USB_MTX_LOCK(&usb_quirk_mtx);
875 		/* copy out data */
876 		pgq->vid = usb_quirks[y].vid;
877 		pgq->pid = usb_quirks[y].pid;
878 		pgq->bcdDeviceLow = usb_quirks[y].lo_rev;
879 		pgq->bcdDeviceHigh = usb_quirks[y].hi_rev;
880 		strlcpy(pgq->quirkname,
881 		    usb_quirkstr(usb_quirks[y].quirks[x]),
882 		    sizeof(pgq->quirkname));
883 		USB_MTX_UNLOCK(&usb_quirk_mtx);
884 		return (0);		/* success */
885 
886 	case USB_QUIRK_NAME_GET:
887 		pgq = (void *)data;
888 		x = pgq->index;
889 		if (x >= USB_QUIRK_MAX) {
890 			return (EINVAL);
891 		}
892 		strlcpy(pgq->quirkname,
893 		    usb_quirkstr(x), sizeof(pgq->quirkname));
894 		return (0);		/* success */
895 
896 	case USB_DEV_QUIRK_ADD:
897 		pgq = (void *)data;
898 
899 		/* check privileges */
900 		err = priv_check(curthread, PRIV_DRIVER);
901 		if (err) {
902 			return (err);
903 		}
904 		/* convert quirk string into numerical */
905 		for (y = 0; y != USB_DEV_QUIRKS_MAX; y++) {
906 			if (strcmp(pgq->quirkname, usb_quirkstr(y)) == 0) {
907 				break;
908 			}
909 		}
910 		if (y == USB_DEV_QUIRKS_MAX) {
911 			return (EINVAL);
912 		}
913 		if (y == UQ_NONE) {
914 			return (EINVAL);
915 		}
916 		USB_MTX_LOCK(&usb_quirk_mtx);
917 		pqe = usb_quirk_get_entry(pgq->vid, pgq->pid,
918 		    pgq->bcdDeviceLow, pgq->bcdDeviceHigh, 1);
919 		if (pqe == NULL) {
920 			USB_MTX_UNLOCK(&usb_quirk_mtx);
921 			return (EINVAL);
922 		}
923 		for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) {
924 			if (pqe->quirks[x] == UQ_NONE) {
925 				pqe->quirks[x] = y;
926 				break;
927 			}
928 		}
929 		USB_MTX_UNLOCK(&usb_quirk_mtx);
930 		if (x == USB_SUB_QUIRKS_MAX) {
931 			return (ENOMEM);
932 		}
933 		return (0);		/* success */
934 
935 	case USB_DEV_QUIRK_REMOVE:
936 		pgq = (void *)data;
937 		/* check privileges */
938 		err = priv_check(curthread, PRIV_DRIVER);
939 		if (err) {
940 			return (err);
941 		}
942 		/* convert quirk string into numerical */
943 		for (y = 0; y != USB_DEV_QUIRKS_MAX; y++) {
944 			if (strcmp(pgq->quirkname, usb_quirkstr(y)) == 0) {
945 				break;
946 			}
947 		}
948 		if (y == USB_DEV_QUIRKS_MAX) {
949 			return (EINVAL);
950 		}
951 		if (y == UQ_NONE) {
952 			return (EINVAL);
953 		}
954 		USB_MTX_LOCK(&usb_quirk_mtx);
955 		pqe = usb_quirk_get_entry(pgq->vid, pgq->pid,
956 		    pgq->bcdDeviceLow, pgq->bcdDeviceHigh, 0);
957 		if (pqe == NULL) {
958 			USB_MTX_UNLOCK(&usb_quirk_mtx);
959 			return (EINVAL);
960 		}
961 		for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) {
962 			if (pqe->quirks[x] == y) {
963 				pqe->quirks[x] = UQ_NONE;
964 				break;
965 			}
966 		}
967 		if (x == USB_SUB_QUIRKS_MAX) {
968 			USB_MTX_UNLOCK(&usb_quirk_mtx);
969 			return (ENOMEM);
970 		}
971 		for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) {
972 			if (pqe->quirks[x] != UQ_NONE) {
973 				break;
974 			}
975 		}
976 		if (x == USB_SUB_QUIRKS_MAX) {
977 			/* all quirk entries are unused - release */
978 			memset(pqe, 0, sizeof(*pqe));
979 		}
980 		USB_MTX_UNLOCK(&usb_quirk_mtx);
981 		return (0);		/* success */
982 
983 	default:
984 		break;
985 	}
986 	return (ENOIOCTL);
987 }
988 
989 /*------------------------------------------------------------------------*
990  *	usb_quirk_strtou16
991  *
992  * Helper function to scan a 16-bit integer.
993  *------------------------------------------------------------------------*/
994 static uint16_t
995 usb_quirk_strtou16(const char **pptr, const char *name, const char *what)
996 {
997 	unsigned long value;
998 	char *end;
999 
1000 	value = strtoul(*pptr, &end, 0);
1001 	if (value > 65535 || *pptr == end || (*end != ' ' && *end != '\t')) {
1002 		printf("%s: %s 16-bit %s value set to zero\n",
1003 		    name, what, *end == 0 ? "incomplete" : "invalid");
1004 		return (0);
1005 	}
1006 	*pptr = end + 1;
1007 	return ((uint16_t)value);
1008 }
1009 
1010 /*------------------------------------------------------------------------*
1011  *	usb_quirk_add_entry_from_str
1012  *
1013  * Add a USB quirk entry from string.
1014  *     "VENDOR PRODUCT LO_REV HI_REV QUIRK[,QUIRK[,...]]"
1015  *------------------------------------------------------------------------*/
1016 static void
1017 usb_quirk_add_entry_from_str(const char *name, const char *env)
1018 {
1019 	struct usb_quirk_entry entry = { };
1020 	struct usb_quirk_entry *new;
1021 	uint16_t quirk_idx;
1022 	uint16_t quirk;
1023 	const char *end;
1024 
1025 	/* check for invalid environment variable */
1026 	if (name == NULL || env == NULL)
1027 		return;
1028 
1029 	if (bootverbose)
1030 		printf("Adding USB QUIRK '%s' = '%s'\n", name, env);
1031 
1032 	/* parse device information */
1033 	entry.vid = usb_quirk_strtou16(&env, name, "Vendor ID");
1034 	entry.pid = usb_quirk_strtou16(&env, name, "Product ID");
1035 	entry.lo_rev = usb_quirk_strtou16(&env, name, "Low revision");
1036 	entry.hi_rev = usb_quirk_strtou16(&env, name, "High revision");
1037 
1038 	/* parse quirk information */
1039 	quirk_idx = 0;
1040 	while (*env != 0 && quirk_idx != USB_SUB_QUIRKS_MAX) {
1041 		/* skip whitespace before quirks */
1042 		while (*env == ' ' || *env == '\t')
1043 			env++;
1044 
1045 		/* look for quirk separation character */
1046 		end = strchr(env, ',');
1047 		if (end == NULL)
1048 			end = env + strlen(env);
1049 
1050 		/* lookup quirk in string table */
1051 		quirk = usb_strquirk(env, end - env);
1052 		if (quirk < USB_QUIRK_MAX) {
1053 			entry.quirks[quirk_idx++] = quirk;
1054 		} else {
1055 			printf("%s: unknown USB quirk '%.*s' (skipped)\n",
1056 			    name, (int)(end - env), env);
1057 		}
1058 		env = end;
1059 
1060 		/* skip quirk delimiter, if any */
1061 		if (*env != 0)
1062 			env++;
1063 	}
1064 
1065 	/* register quirk */
1066 	if (quirk_idx != 0) {
1067 		if (*env != 0) {
1068 			printf("%s: Too many USB quirks, only %d allowed!\n",
1069 			    name, USB_SUB_QUIRKS_MAX);
1070 		}
1071 		USB_MTX_LOCK(&usb_quirk_mtx);
1072 		new = usb_quirk_get_entry(entry.vid, entry.pid,
1073 		    entry.lo_rev, entry.hi_rev, 1);
1074 		if (new == NULL)
1075 			printf("%s: USB quirks table is full!\n", name);
1076 		else
1077 			memcpy(new->quirks, entry.quirks, sizeof(entry.quirks));
1078 		USB_MTX_UNLOCK(&usb_quirk_mtx);
1079 	} else {
1080 		printf("%s: No USB quirks found!\n", name);
1081 	}
1082 }
1083 
1084 static void
1085 usb_quirk_init(void *arg)
1086 {
1087 	char envkey[sizeof(USB_QUIRK_ENVROOT) + 2];	/* 2 digits max, 0 to 99 */
1088 	int i;
1089 
1090 	/* initialize mutex */
1091 	mtx_init(&usb_quirk_mtx, "USB quirk", NULL, MTX_DEF);
1092 
1093 	/* look for quirks defined by the environment variable */
1094 	for (i = 0; i != 100; i++) {
1095 		snprintf(envkey, sizeof(envkey), USB_QUIRK_ENVROOT "%d", i);
1096 
1097 		/* Stop at first undefined var */
1098 		if (!testenv(envkey))
1099 			break;
1100 
1101 		/* parse environment variable */
1102 		usb_quirk_add_entry_from_str(envkey, kern_getenv(envkey));
1103 	}
1104 
1105 	/* register our function */
1106 	usb_test_quirk_p = &usb_test_quirk_by_info;
1107 	usb_quirk_ioctl_p = &usb_quirk_ioctl;
1108 }
1109 
1110 static void
1111 usb_quirk_uninit(void *arg)
1112 {
1113 	usb_quirk_unload(arg);
1114 
1115 	/* destroy mutex */
1116 	mtx_destroy(&usb_quirk_mtx);
1117 }
1118 
1119 SYSINIT(usb_quirk_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb_quirk_init, NULL);
1120 SYSUNINIT(usb_quirk_uninit, SI_SUB_LOCK, SI_ORDER_ANY, usb_quirk_uninit, NULL);
1121