3 * Copyright (c) 1998 The NetBSD Foundation, Inc. All rights reserved.
4 * Copyright (c) 1998 Lennart Augustsson. All rights reserved.
5 * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 #include <sys/stdint.h>
30 #include <sys/stddef.h>
31 #include <sys/param.h>
32 #include <sys/queue.h>
33 #include <sys/types.h>
34 #include <sys/systm.h>
35 #include <sys/kernel.h>
37 #include <sys/linker_set.h>
38 #include <sys/module.h>
40 #include <sys/mutex.h>
41 #include <sys/condvar.h>
42 #include <sys/sysctl.h>
44 #include <sys/unistd.h>
45 #include <sys/callout.h>
46 #include <sys/malloc.h>
49 #include <dev/usb/usb.h>
50 #include <dev/usb/usb_ioctl.h>
51 #include <dev/usb/usbdi.h>
54 #define USB_DEBUG_VAR usb_debug
55 #include <dev/usb/usb_debug.h>
56 #include <dev/usb/usb_dynamic.h>
58 #include <dev/usb/quirk/usb_quirk.h>
60 MODULE_DEPEND(usb_quirk, usb, 1, 1, 1);
61 MODULE_VERSION(usb_quirk, 1);
64 * The following macro adds one or more quirks for a USB device:
66 #define USB_QUIRK_ENTRY(v,p,l,h,...) \
67 .vid = (v), .pid = (p), .lo_rev = (l), .hi_rev = (h), .quirks = { __VA_ARGS__ }
69 #define USB_DEV_QUIRKS_MAX 128
70 #define USB_SUB_QUIRKS_MAX 8
72 struct usb_quirk_entry {
77 uint16_t quirks[USB_SUB_QUIRKS_MAX];
80 static struct mtx usb_quirk_mtx;
82 static struct usb_quirk_entry usb_quirks[USB_DEV_QUIRKS_MAX] = {
83 {USB_QUIRK_ENTRY(USB_VENDOR_ASUS, USB_PRODUCT_ASUS_LCM, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
84 {USB_QUIRK_ENTRY(USB_VENDOR_INSIDEOUT, USB_PRODUCT_INSIDEOUT_EDGEPORT4, 0x094, 0x094, UQ_SWAP_UNICODE, UQ_NONE)},
85 {USB_QUIRK_ENTRY(USB_VENDOR_DALLAS, USB_PRODUCT_DALLAS_J6502, 0x0a2, 0x0a2, UQ_BAD_ADC, UQ_NONE)},
86 {USB_QUIRK_ENTRY(USB_VENDOR_DALLAS, USB_PRODUCT_DALLAS_J6502, 0x0a2, 0x0a2, UQ_AU_NO_XU, UQ_NONE)},
87 {USB_QUIRK_ENTRY(USB_VENDOR_ALTEC, USB_PRODUCT_ALTEC_ADA70, 0x103, 0x103, UQ_BAD_ADC, UQ_NONE)},
88 {USB_QUIRK_ENTRY(USB_VENDOR_ALTEC, USB_PRODUCT_ALTEC_ASC495, 0x000, 0x000, UQ_BAD_AUDIO, UQ_NONE)},
89 {USB_QUIRK_ENTRY(USB_VENDOR_QTRONIX, USB_PRODUCT_QTRONIX_980N, 0x110, 0x110, UQ_SPUR_BUT_UP, UQ_NONE)},
90 {USB_QUIRK_ENTRY(USB_VENDOR_ALCOR2, USB_PRODUCT_ALCOR2_KBD_HUB, 0x001, 0x001, UQ_SPUR_BUT_UP, UQ_NONE)},
91 {USB_QUIRK_ENTRY(USB_VENDOR_MCT, USB_PRODUCT_MCT_HUB0100, 0x102, 0x102, UQ_BUS_POWERED, UQ_NONE)},
92 {USB_QUIRK_ENTRY(USB_VENDOR_MCT, USB_PRODUCT_MCT_USB232, 0x102, 0x102, UQ_BUS_POWERED, UQ_NONE)},
93 {USB_QUIRK_ENTRY(USB_VENDOR_TI, USB_PRODUCT_TI_UTUSB41, 0x110, 0x110, UQ_POWER_CLAIM, UQ_NONE)},
94 {USB_QUIRK_ENTRY(USB_VENDOR_TELEX, USB_PRODUCT_TELEX_MIC1, 0x009, 0x009, UQ_AU_NO_FRAC, UQ_NONE)},
95 {USB_QUIRK_ENTRY(USB_VENDOR_SILICONPORTALS, USB_PRODUCT_SILICONPORTALS_YAPPHONE, 0x100, 0x100, UQ_AU_INP_ASYNC, UQ_NONE)},
96 {USB_QUIRK_ENTRY(USB_VENDOR_LOGITECH, USB_PRODUCT_LOGITECH_UN53B, 0x0000, 0xFFFF, UQ_NO_STRINGS, UQ_NONE)},
99 * XXX The following quirks should have a more specific revision
102 {USB_QUIRK_ENTRY(USB_VENDOR_HP, USB_PRODUCT_HP_895C, 0x0000, 0xFFFF, UQ_BROKEN_BIDIR, UQ_NONE)},
103 {USB_QUIRK_ENTRY(USB_VENDOR_HP, USB_PRODUCT_HP_880C, 0x0000, 0xFFFF, UQ_BROKEN_BIDIR, UQ_NONE)},
104 {USB_QUIRK_ENTRY(USB_VENDOR_HP, USB_PRODUCT_HP_815C, 0x0000, 0xFFFF, UQ_BROKEN_BIDIR, UQ_NONE)},
105 {USB_QUIRK_ENTRY(USB_VENDOR_HP, USB_PRODUCT_HP_810C, 0x0000, 0xFFFF, UQ_BROKEN_BIDIR, UQ_NONE)},
106 {USB_QUIRK_ENTRY(USB_VENDOR_HP, USB_PRODUCT_HP_830C, 0x0000, 0xFFFF, UQ_BROKEN_BIDIR, UQ_NONE)},
107 {USB_QUIRK_ENTRY(USB_VENDOR_HP, USB_PRODUCT_HP_1220C, 0x0000, 0xFFFF, UQ_BROKEN_BIDIR, UQ_NONE)},
108 {USB_QUIRK_ENTRY(USB_VENDOR_XEROX, USB_PRODUCT_XEROX_WCM15, 0x0000, 0xFFFF, UQ_BROKEN_BIDIR, UQ_NONE)},
109 /* Devices which should be ignored by uhid */
110 {USB_QUIRK_ENTRY(USB_VENDOR_APC, USB_PRODUCT_APC_UPS, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
111 {USB_QUIRK_ENTRY(USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F6C550AVR, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
112 {USB_QUIRK_ENTRY(USB_VENDOR_CYBERPOWER, USB_PRODUCT_CYBERPOWER_1500CAVRLCD, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
113 {USB_QUIRK_ENTRY(USB_VENDOR_DELORME, USB_PRODUCT_DELORME_EARTHMATE, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
114 {USB_QUIRK_ENTRY(USB_VENDOR_ITUNERNET, USB_PRODUCT_ITUNERNET_USBLCD2X20, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
115 {USB_QUIRK_ENTRY(USB_VENDOR_ITUNERNET, USB_PRODUCT_ITUNERNET_USBLCD4X20, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
116 {USB_QUIRK_ENTRY(USB_VENDOR_MGE, USB_PRODUCT_MGE_UPS1, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
117 {USB_QUIRK_ENTRY(USB_VENDOR_MGE, USB_PRODUCT_MGE_UPS2, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
118 {USB_QUIRK_ENTRY(USB_VENDOR_APPLE, USB_PRODUCT_APPLE_IPHONE, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
119 {USB_QUIRK_ENTRY(USB_VENDOR_APPLE, USB_PRODUCT_APPLE_IPHONE_3G, 0x0000, 0xFFFF, UQ_HID_IGNORE, UQ_NONE)},
120 /* Devices which should be ignored by both ukbd and uhid */
121 {USB_QUIRK_ENTRY(USB_VENDOR_CYPRESS, USB_PRODUCT_CYPRESS_WISPY1A, 0x0000, 0xFFFF, UQ_KBD_IGNORE, UQ_HID_IGNORE, UQ_NONE)},
122 {USB_QUIRK_ENTRY(USB_VENDOR_METAGEEK, USB_PRODUCT_METAGEEK_WISPY1B, 0x0000, 0xFFFF, UQ_KBD_IGNORE, UQ_HID_IGNORE, UQ_NONE)},
123 {USB_QUIRK_ENTRY(USB_VENDOR_TENX, USB_PRODUCT_TENX_UAUDIO0, 0x0101, 0x0101, UQ_AUDIO_SWAP_LR, UQ_NONE)},
124 /* MS keyboards do weird things */
125 {USB_QUIRK_ENTRY(USB_VENDOR_MICROSOFT, USB_PRODUCT_MICROSOFT_WLINTELLIMOUSE, 0x0000, 0xFFFF, UQ_MS_LEADING_BYTE, UQ_NONE)},
126 {USB_QUIRK_ENTRY(USB_VENDOR_METAGEEK, USB_PRODUCT_METAGEEK_WISPY24X, 0x0000, 0xFFFF, UQ_KBD_IGNORE, UQ_HID_IGNORE, UQ_NONE)},
129 static const char *usb_quirk_str[USB_QUIRK_MAX] = {
130 [UQ_NONE] = "UQ_NONE",
131 [UQ_AUDIO_SWAP_LR] = "UQ_AUDIO_SWAP_LR",
132 [UQ_AU_INP_ASYNC] = "UQ_AU_INP_ASYNC",
133 [UQ_AU_NO_FRAC] = "UQ_AU_NO_FRAC",
134 [UQ_AU_NO_XU] = "UQ_AU_NO_XU",
135 [UQ_BAD_ADC] = "UQ_BAD_ADC",
136 [UQ_BAD_AUDIO] = "UQ_BAD_AUDIO",
137 [UQ_BROKEN_BIDIR] = "UQ_BROKEN_BIDIR",
138 [UQ_BUS_POWERED] = "UQ_BUS_POWERED",
139 [UQ_HID_IGNORE] = "UQ_HID_IGNORE",
140 [UQ_KBD_IGNORE] = "UQ_KBD_IGNORE",
141 [UQ_MS_BAD_CLASS] = "UQ_MS_BAD_CLASS",
142 [UQ_MS_LEADING_BYTE] = "UQ_MS_LEADING_BYTE",
143 [UQ_MS_REVZ] = "UQ_MS_REVZ",
144 [UQ_NO_STRINGS] = "UQ_NO_STRINGS",
145 [UQ_OPEN_CLEARSTALL] = "UQ_OPEN_CLEARSTALL",
146 [UQ_POWER_CLAIM] = "UQ_POWER_CLAIM",
147 [UQ_SPUR_BUT_UP] = "UQ_SPUR_BUT_UP",
148 [UQ_SWAP_UNICODE] = "UQ_SWAP_UNICODE",
149 [UQ_CFG_INDEX_1] = "UQ_CFG_INDEX_1",
150 [UQ_CFG_INDEX_2] = "UQ_CFG_INDEX_2",
151 [UQ_CFG_INDEX_3] = "UQ_CFG_INDEX_3",
152 [UQ_CFG_INDEX_4] = "UQ_CFG_INDEX_4",
153 [UQ_CFG_INDEX_0] = "UQ_CFG_INDEX_0",
156 /*------------------------------------------------------------------------*
159 * This function converts an USB quirk code into a string.
160 *------------------------------------------------------------------------*/
162 usb_quirkstr(uint16_t quirk)
164 return ((quirk < USB_QUIRK_MAX) ?
165 usb_quirk_str[quirk] : "USB_QUIRK_UNKNOWN");
168 /*------------------------------------------------------------------------*
169 * usb_test_quirk_by_info
174 *------------------------------------------------------------------------*/
176 usb_test_quirk_by_info(const struct usbd_lookup_info *info, uint16_t quirk)
181 if (quirk == UQ_NONE) {
184 mtx_lock(&usb_quirk_mtx);
186 for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) {
187 /* see if quirk information does not match */
188 if ((usb_quirks[x].vid != info->idVendor) ||
189 (usb_quirks[x].pid != info->idProduct) ||
190 (usb_quirks[x].lo_rev > info->bcdDevice) ||
191 (usb_quirks[x].hi_rev < info->bcdDevice)) {
195 for (y = 0; y != USB_SUB_QUIRKS_MAX; y++) {
196 if (usb_quirks[x].quirks[y] == quirk) {
197 mtx_unlock(&usb_quirk_mtx);
198 DPRINTF("Found quirk '%s'.\n", usb_quirkstr(quirk));
205 mtx_unlock(&usb_quirk_mtx);
209 static struct usb_quirk_entry *
210 usb_quirk_get_entry(uint16_t vid, uint16_t pid,
211 uint16_t lo_rev, uint16_t hi_rev, uint8_t do_alloc)
215 mtx_assert(&usb_quirk_mtx, MA_OWNED);
217 if ((vid | pid | lo_rev | hi_rev) == 0) {
218 /* all zero - special case */
219 return (usb_quirks + USB_DEV_QUIRKS_MAX - 1);
221 /* search for an existing entry */
222 for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) {
223 /* see if quirk information does not match */
224 if ((usb_quirks[x].vid != vid) ||
225 (usb_quirks[x].pid != pid) ||
226 (usb_quirks[x].lo_rev != lo_rev) ||
227 (usb_quirks[x].hi_rev != hi_rev)) {
230 return (usb_quirks + x);
237 /* search for a free entry */
238 for (x = 0; x != USB_DEV_QUIRKS_MAX; x++) {
239 /* see if quirk information does not match */
240 if ((usb_quirks[x].vid |
242 usb_quirks[x].lo_rev |
243 usb_quirks[x].hi_rev) != 0) {
246 usb_quirks[x].vid = vid;
247 usb_quirks[x].pid = pid;
248 usb_quirks[x].lo_rev = lo_rev;
249 usb_quirks[x].hi_rev = hi_rev;
251 return (usb_quirks + x);
258 /*------------------------------------------------------------------------*
259 * usb_quirk_ioctl - handle quirk IOCTLs
264 *------------------------------------------------------------------------*/
266 usb_quirk_ioctl(unsigned long cmd, caddr_t data,
267 int fflag, struct thread *td)
269 struct usb_gen_quirk *pgq;
270 struct usb_quirk_entry *pqe;
276 case USB_DEV_QUIRK_GET:
278 x = pgq->index % USB_SUB_QUIRKS_MAX;
279 y = pgq->index / USB_SUB_QUIRKS_MAX;
280 if (y >= USB_DEV_QUIRKS_MAX) {
283 mtx_lock(&usb_quirk_mtx);
285 pgq->vid = usb_quirks[y].vid;
286 pgq->pid = usb_quirks[y].pid;
287 pgq->bcdDeviceLow = usb_quirks[y].lo_rev;
288 pgq->bcdDeviceHigh = usb_quirks[y].hi_rev;
289 strlcpy(pgq->quirkname,
290 usb_quirkstr(usb_quirks[y].quirks[x]),
291 sizeof(pgq->quirkname));
292 mtx_unlock(&usb_quirk_mtx);
293 return (0); /* success */
295 case USB_QUIRK_NAME_GET:
298 if (x >= USB_QUIRK_MAX) {
301 strlcpy(pgq->quirkname,
302 usb_quirkstr(x), sizeof(pgq->quirkname));
303 return (0); /* success */
305 case USB_DEV_QUIRK_ADD:
308 /* check privileges */
309 err = priv_check(curthread, PRIV_DRIVER);
313 /* convert quirk string into numerical */
314 for (y = 0; y != USB_DEV_QUIRKS_MAX; y++) {
315 if (strcmp(pgq->quirkname, usb_quirkstr(y)) == 0) {
319 if (y == USB_DEV_QUIRKS_MAX) {
325 mtx_lock(&usb_quirk_mtx);
326 pqe = usb_quirk_get_entry(pgq->vid, pgq->pid,
327 pgq->bcdDeviceLow, pgq->bcdDeviceHigh, 1);
328 for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) {
329 if (pqe->quirks[x] == UQ_NONE) {
334 mtx_unlock(&usb_quirk_mtx);
335 if (x == USB_SUB_QUIRKS_MAX) {
338 return (0); /* success */
340 case USB_DEV_QUIRK_REMOVE:
342 /* check privileges */
343 err = priv_check(curthread, PRIV_DRIVER);
347 /* convert quirk string into numerical */
348 for (y = 0; y != USB_DEV_QUIRKS_MAX; y++) {
349 if (strcmp(pgq->quirkname, usb_quirkstr(y)) == 0) {
353 if (y == USB_DEV_QUIRKS_MAX) {
359 mtx_lock(&usb_quirk_mtx);
360 pqe = usb_quirk_get_entry(pgq->vid, pgq->pid,
361 pgq->bcdDeviceLow, pgq->bcdDeviceHigh, 0);
362 for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) {
363 if (pqe->quirks[x] == y) {
364 pqe->quirks[x] = UQ_NONE;
368 if (x == USB_SUB_QUIRKS_MAX) {
369 mtx_unlock(&usb_quirk_mtx);
372 for (x = 0; x != USB_SUB_QUIRKS_MAX; x++) {
373 if (pqe->quirks[x] != UQ_NONE) {
377 if (x == USB_SUB_QUIRKS_MAX) {
378 /* all quirk entries are unused - release */
379 memset(pqe, 0, sizeof(pqe));
381 mtx_unlock(&usb_quirk_mtx);
382 return (0); /* success */
391 usb_quirk_init(void *arg)
393 /* initialize mutex */
394 mtx_init(&usb_quirk_mtx, "USB quirk", NULL, MTX_DEF);
396 /* register our function */
397 usb_test_quirk_p = &usb_test_quirk_by_info;
398 usb_quirk_ioctl_p = &usb_quirk_ioctl;
402 usb_quirk_uninit(void *arg)
404 usb_quirk_unload(arg);
407 mtx_destroy(&usb_quirk_mtx);
410 SYSINIT(usb_quirk_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb_quirk_init, NULL);
411 SYSUNINIT(usb_quirk_uninit, SI_SUB_LOCK, SI_ORDER_ANY, usb_quirk_uninit, NULL);