?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'origin/master'
[unleashed/lotheac.git] / usr / src / uts / common / io / usb / usba / usba_devdb.c
blobcb45e9aae4e09cf2d334cdb503ac4ec89036e802
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26
27 #define USBA_FRAMEWORK
28 #include <sys/ksynch.h>
29 #include <sys/strsun.h>
30 #include <sys/usb/usba/usba_impl.h>
31 #include <sys/usb/usba/usba_devdb_impl.h>
32
33 static usb_log_handle_t usba_devdb_log_handle;
34 uint_t usba_devdb_errlevel = USB_LOG_L4;
35 uint_t usba_devdb_errmask = (uint_t)-1;
36
37 boolean_t usba_build_devdb = B_FALSE;
38
39 avl_tree_t usba_devdb; /* tree of records */
40 static krwlock_t usba_devdb_lock; /* lock protecting the tree */
41
42 _NOTE(RWLOCK_PROTECTS_DATA(usba_devdb_lock, usba_devdb))
43
44 /* function prototypes */
45 static int usb_devdb_compare_pathnames(char *, char *);
46 static int usba_devdb_compare(const void *, const void *);
47 static int usba_devdb_build_device_database();
48 static void usba_devdb_destroy_device_database();
49
50 /*
51 * usba_devdb_initialization
52 * Initialize this module that builds the usb device database
53 */
54 void
55 usba_devdb_initialization()
56 {
57 usba_devdb_log_handle = usb_alloc_log_hdl(NULL, "devdb",
58 &usba_devdb_errlevel, &usba_devdb_errmask, NULL, 0);
59
60 USB_DPRINTF_L4(DPRINT_MASK_DEVDB, usba_devdb_log_handle,
61 "usba_devdb_initialization");
62
63 rw_init(&usba_devdb_lock, NULL, RW_DRIVER, NULL);
64
65 rw_enter(&usba_devdb_lock, RW_WRITER);
66
67 usba_build_devdb = B_TRUE;
68
69 /* now create the avl tree */
70 avl_create(&usba_devdb, usba_devdb_compare,
71 sizeof (usba_devdb_info_t),
72 offsetof(struct usba_devdb_info, avl_link));
73
74 (void) usba_devdb_build_device_database();
75
76 usba_build_devdb = B_FALSE;
77
78 rw_exit(&usba_devdb_lock);
79 }
80
81
82 /*
83 * usba_devdb_destroy
84 * Free up all the resources being used by this module
85 */
86 void
87 usba_devdb_destroy()
88 {
89 USB_DPRINTF_L4(DPRINT_MASK_DEVDB, usba_devdb_log_handle,
90 "usba_devdb_destroy");
91
92 rw_enter(&usba_devdb_lock, RW_WRITER);
93
94 usba_devdb_destroy_device_database();
95
96 rw_exit(&usba_devdb_lock);
97
98 rw_destroy(&usba_devdb_lock);
99
100 usb_free_log_hdl(usba_devdb_log_handle);
101 }
102
103
104 /*
105 * usba_devdb_get_var_type:
106 * returns the field from the token
107 */
108 static config_field_t
109 usba_devdb_get_var_type(char *str)
110 {
111 usba_cfg_var_t *cfgvar;
112
113 cfgvar = &usba_cfg_varlist[0];
114 while (cfgvar->field != USB_NONE) {
115 if (strcasecmp(cfgvar->name, str) == 0) {
116 break;
117 } else {
118 cfgvar++;
119 }
120 }
121
122 return (cfgvar->field);
123 }
124
125
126 /*
127 * usba_devdb_get_conf_rec:
128 * Fetch one record from the file
129 */
130 static token_t
131 usba_devdb_get_conf_rec(struct _buf *file, usba_configrec_t **rec)
132 {
133 token_t token;
134 char tokval[MAXPATHLEN];
135 usba_configrec_t *cfgrec;
136 config_field_t cfgvar;
137 u_longlong_t llptr;
138 u_longlong_t value;
139 enum {
140 USB_NEWVAR, USB_CONFIG_VAR, USB_VAR_EQUAL, USB_VAR_VALUE,
141 USB_ERROR
142 } parse_state = USB_NEWVAR;
143
144 cfgrec = (usba_configrec_t *)kmem_zalloc(
145 sizeof (usba_configrec_t), KM_SLEEP);
146 cfgrec->idVendor = cfgrec->idProduct = cfgrec->cfg_index = -1;
147
148 token = kobj_lex(file, tokval, sizeof (tokval));
149 while ((token != EOF) && (token != SEMICOLON)) {
150 switch (token) {
151 case STAR:
152 case POUND:
153 /* skip comments */
154 kobj_find_eol(file);
155 break;
156 case NEWLINE:
157 kobj_newline(file);
158 break;
159 case NAME:
160 case STRING:
161 switch (parse_state) {
162 case USB_NEWVAR:
163 cfgvar = usba_devdb_get_var_type(tokval);
164 if (cfgvar == USB_NONE) {
165 parse_state = USB_ERROR;
166 kobj_file_err(CE_WARN, file,
167 "Syntax Error: Invalid field %s",
168 tokval);
169 } else {
170 parse_state = USB_CONFIG_VAR;
171 }
172 break;
173 case USB_VAR_VALUE:
174 if ((cfgvar == USB_VENDOR) ||
175 (cfgvar == USB_PRODUCT) ||
176 (cfgvar == USB_CFGNDX)) {
177 parse_state = USB_ERROR;
178 kobj_file_err(CE_WARN, file,
179 "Syntax Error: Invalid value %s"
180 " for field: %s\n", tokval,
181 usba_cfg_varlist[cfgvar].name);
182 } else if (kobj_get_string(&llptr, tokval)) {
183 switch (cfgvar) {
184 case USB_SELECTION:
185 cfgrec->selection =
186 (char *)(uintptr_t)llptr;
187 parse_state = USB_NEWVAR;
188 break;
189 case USB_SRNO:
190 cfgrec->serialno =
191 (char *)(uintptr_t)llptr;
192 parse_state = USB_NEWVAR;
193 break;
194 case USB_PATH:
195 cfgrec->pathname =
196 (char *)(uintptr_t)llptr;
197 parse_state = USB_NEWVAR;
198 break;
199 case USB_DRIVER:
200 cfgrec->driver =
201 (char *)(uintptr_t)llptr;
202 parse_state = USB_NEWVAR;
203 break;
204 default:
205 parse_state = USB_ERROR;
206 }
207 } else {
208 parse_state = USB_ERROR;
209 kobj_file_err(CE_WARN, file,
210 "Syntax Error: Invalid value %s"
211 " for field: %s\n", tokval,
212 usba_cfg_varlist[cfgvar].name);
213 }
214 break;
215 case USB_ERROR:
216 /* just skip */
217 break;
218 default:
219 parse_state = USB_ERROR;
220 kobj_file_err(CE_WARN, file,
221 "Syntax Error: at %s", tokval);
222 break;
223 }
224 break;
225 case EQUALS:
226 if (parse_state == USB_CONFIG_VAR) {
227 if (cfgvar == USB_NONE) {
228 parse_state = USB_ERROR;
229 kobj_file_err(CE_WARN, file,
230 "Syntax Error: unexpected '='");
231 } else {
232 parse_state = USB_VAR_VALUE;
233 }
234 } else if (parse_state != USB_ERROR) {
235 kobj_file_err(CE_WARN, file,
236 "Syntax Error: unexpected '='");
237 parse_state = USB_ERROR;
238 }
239 break;
240 case HEXVAL:
241 case DECVAL:
242 if ((parse_state == USB_VAR_VALUE) && (cfgvar !=
243 USB_NONE)) {
244 (void) kobj_getvalue(tokval, &value);
245 switch (cfgvar) {
246 case USB_VENDOR:
247 cfgrec->idVendor = (int)value;
248 parse_state = USB_NEWVAR;
249 break;
250 case USB_PRODUCT:
251 cfgrec->idProduct = (int)value;
252 parse_state = USB_NEWVAR;
253 break;
254 case USB_CFGNDX:
255 cfgrec->cfg_index = (int)value;
256 parse_state = USB_NEWVAR;
257 break;
258 default:
259 kobj_file_err(CE_WARN, file,
260 "Syntax Error: Invalid value for "
261 "%s",
262 usba_cfg_varlist[cfgvar].name);
263 }
264 } else if (parse_state != USB_ERROR) {
265 parse_state = USB_ERROR;
266 kobj_file_err(CE_WARN, file, "Syntax Error:"
267 "unexpected hex/decimal: %s", tokval);
268 }
269 break;
270 default:
271 kobj_file_err(CE_WARN, file, "Syntax Error: at: %s",
272 tokval);
273 parse_state = USB_ERROR;
274 break;
275 }
276 token = kobj_lex(file, tokval, sizeof (tokval));
277 }
278 *rec = cfgrec;
279
280 return (token);
281 }
282
283
284 /*
285 * usba_devdb_free_rec:
286 * Free the record allocated in usba_devdb_get_conf_rec.
287 * We use kobj_free_string as kobj_get_string allocates memory
288 * in mod_sysfile_arena.
289 */
290 static void
291 usba_devdb_free_rec(usba_configrec_t *rec)
292 {
293 if (rec->selection) {
294 kobj_free_string(rec->selection, strlen(rec->selection) + 1);
295 }
296 if (rec->serialno) {
297 kobj_free_string(rec->serialno, strlen(rec->serialno) + 1);
298 }
299 if (rec->pathname) {
300 kobj_free_string(rec->pathname, strlen(rec->pathname) + 1);
301 }
302 if (rec->driver) {
303 kobj_free_string(rec->driver, strlen(rec->driver) + 1);
304 }
305 kmem_free(rec, sizeof (usba_configrec_t));
306 }
307
308
309
310 /*
311 * usb_devdb_compare_pathnames:
312 * Compare the two pathnames. If we are building the tree, we do a
313 * straight string compare to enable correct tree generation. If we
314 * are searching for a matching node, we compare only the selected
315 * portion of the pathname to give a correct match.
316 */
317 static int
318 usb_devdb_compare_pathnames(char *p1, char *p2)
319 {
320 int rval;
321 char *ustr, *hstr;
322
323 USB_DPRINTF_L4(DPRINT_MASK_DEVDB, usba_devdb_log_handle,
324 "usb_devdb_compare_pathnames: p1=0x%p p2=0x%p",
325 (void *)p1, (void *)p2);
326
327 if (p1 && p2) {
328 if (usba_build_devdb == B_TRUE) {
329 /* this is a straight string compare */
330 rval = strcmp(p1, p2);
331 if (rval < 0) {
332
333 return (-1);
334 } else if (rval > 0) {
335
336 return (+1);
337 } else {
338
339 return (0);
340 }
341 } else {
342 /*
343 * Comparing on this is tricky.
344 * p1 is the string hubd is looking for &
345 * p2 is the string in the device db.
346 * At this point hubd knows: ../hubd@P/device@P
347 * while user will specify ..../hubd@P/keyboard@P
348 * First compare till .../hubd@P
349 * Second compare is just P in "device@P"
350 */
351 ustr = strrchr(p2, '/');
352 hstr = strrchr(p1, '/');
353 rval = strncmp(p1, p2,
354 MAX(_PTRDIFF(ustr, p2),
355 _PTRDIFF(hstr, p1)));
356 if (rval < 0) {
357
358 return (-1);
359 } else if (rval > 0) {
360
361 return (+1);
362 } else {
363 /* now compare the ports */
364 hstr = p1 + strlen(p1) -1;
365 ustr = p2 + strlen(p2) -1;
366
367 if (*hstr < *ustr) {
368
369 return (-1);
370 } else if (*hstr > *ustr) {
371
372 return (+1);
373 } else {
374 /* finally got a match */
375
376 return (0);
377 }
378 }
379 }
380 } else if ((p1 == NULL) && (p2 == NULL)) {
381
382 return (0);
383 } else {
384 if (p1 == NULL) {
385
386 return (-1);
387 } else {
388
389 return (+1);
390 }
391 }
392 }
393
394
395 /*
396 * usba_devdb_compare
397 * Compares the two nodes. Returns -1 when p1 < p2, 0 when p1 == p2
398 * and +1 when p1 > p2. This function is invoked by avl_find
399 * Here p1 is always the node that we are trying to insert or match in
400 * the device database.
401 */
402 static int
403 usba_devdb_compare(const void *p1, const void *p2)
404 {
405 usba_configrec_t *u1, *u2;
406 int rval;
407
408 u1 = ((usba_devdb_info_t *)p1)->usb_dev;
409 u2 = ((usba_devdb_info_t *)p2)->usb_dev;
410
411 USB_DPRINTF_L4(DPRINT_MASK_DEVDB, usba_devdb_log_handle,
412 "usba_devdb_compare: p1=0x%p u1=0x%p p2=0x%p u2=0x%p",
413 p1, (void *)u1, p2, (void *)u2);
414
415 /* first match vendor id */
416 if (u1->idVendor < u2->idVendor) {
417
418 return (-1);
419 } else if (u1->idVendor > u2->idVendor) {
420
421 return (+1);
422 } else {
423 /* idvendor match, now check idproduct */
424 if (u1->idProduct < u2->idProduct) {
425
426 return (-1);
427 } else if (u1->idProduct > u2->idProduct) {
428
429 return (+1);
430 } else {
431 /* idproduct match, now check serial no. */
432 if (u1->serialno && u2->serialno) {
433 rval = strcmp(u1->serialno, u2->serialno);
434 if (rval > 0) {
435
436 return (+1);
437 } else if (rval < 0) {
438
439 return (-1);
440 } else {
441 /* srno. matches */
442
443 return (usb_devdb_compare_pathnames(
444 u1->pathname, u2->pathname));
445 }
446 } else if ((u1->serialno == NULL) &&
447 (u2->serialno == NULL)) {
448
449 return (usb_devdb_compare_pathnames(
450 u1->pathname, u2->pathname));
451 } else {
452 if (u1->serialno == NULL) {
453
454 return (-1);
455 } else {
456
457 return (+1);
458 }
459 }
460 }
461 }
462 }
463
464
465 /*
466 * usba_devdb_build_device_database
467 * Builds a height balanced tree of all the records present in the file.
468 * Records that are "not enabled" and are duplicate are discarded.
469 */
470 static int
471 usba_devdb_build_device_database()
472 {
473 struct _buf *file;
474 usba_configrec_t *user_rec;
475 avl_index_t where;
476 usba_devdb_info_t *dbnode;
477 token_t token;
478
479 USB_DPRINTF_L4(DPRINT_MASK_DEVDB, usba_devdb_log_handle,
480 "usba_devdb_build_device_database: Start");
481
482 file = kobj_open_file(usbconf_file);
483 if (file != (struct _buf *)-1) {
484
485 do {
486 user_rec = NULL;
487 token = usba_devdb_get_conf_rec(file, &user_rec);
488
489 if (user_rec != NULL) {
490
491 if ((user_rec->selection == NULL) ||
492 (strcasecmp(user_rec->selection,
493 "enable") != 0)) {
494 /* we don't store disabled entries */
495 usba_devdb_free_rec(user_rec);
496
497 continue;
498 }
499
500 dbnode = (usba_devdb_info_t *)kmem_zalloc(
501 sizeof (usba_devdb_info_t), KM_SLEEP);
502 dbnode->usb_dev = user_rec;
503
504 if (avl_find(&usba_devdb, dbnode, &where) ==
505 NULL) {
506 /* insert new node */
507 avl_insert(&usba_devdb, dbnode, where);
508 } else {
509 /*
510 * we don't maintain duplicate entries
511 */
512 usba_devdb_free_rec(user_rec);
513 kmem_free(dbnode,
514 sizeof (usba_devdb_info_t));
515 }
516 }
517
518 } while (token != EOF);
519
520 kobj_close_file(file);
521 }
522
523 USB_DPRINTF_L4(DPRINT_MASK_DEVDB, usba_devdb_log_handle,
524 "usba_devdb_build_device_database: End");
525
526 /* XXX: return the no. of errors encountered */
527 return (0);
528 }
529
530
531 /*
532 * usba_devdb_destroy_device_database
533 * Destory all records in the tree
534 */
535 static void
536 usba_devdb_destroy_device_database()
537 {
538 usba_devdb_info_t *dbnode;
539 void *cookie = NULL;
540
541 USB_DPRINTF_L4(DPRINT_MASK_DEVDB, usba_devdb_log_handle,
542 "usba_devdb_destroy_device_database");
543
544 /* while there are nodes in the tree, keep destroying them */
545 while ((dbnode = (usba_devdb_info_t *)
546 avl_destroy_nodes(&usba_devdb, &cookie)) != NULL) {
547 /*
548 * destroy record
549 * destroy tree node
550 */
551 usba_devdb_free_rec(dbnode->usb_dev);
552 kmem_free(dbnode, sizeof (usba_devdb_info_t));
553 }
554 avl_destroy(&usba_devdb);
555 }
556
557
558 /*
559 * usba_devdb_get_user_preferences
560 * Returns configrec structure to the caller that contains user
561 * preferences for the device pointed by the parameters.
562 * The first search is for a record that has serial number and/or
563 * a pathname. If search fails, we search for a rule that is generic
564 * i.e. without serial no. and pathname.
565 */
566 usba_configrec_t *
567 usba_devdb_get_user_preferences(int idVendor, int idProduct, char *serialno,
568 char *pathname)
569 {
570 usba_configrec_t *req_rec;
571 usba_devdb_info_t *req_node, *dbnode;
572 avl_index_t where;
573
574 USB_DPRINTF_L4(DPRINT_MASK_DEVDB, usba_devdb_log_handle,
575 "usba_devdb_get_user_preferences");
576
577 req_rec = kmem_zalloc(sizeof (usba_configrec_t), KM_SLEEP);
578 req_node = kmem_zalloc(sizeof (usba_devdb_info_t), KM_SLEEP);
579
580 /* fill in the requested parameters */
581 req_rec->idVendor = idVendor;
582 req_rec->idProduct = idProduct;
583 req_rec->serialno = serialno;
584 req_rec->pathname = pathname;
585
586 req_node->usb_dev = req_rec;
587
588 rw_enter(&usba_devdb_lock, RW_READER);
589
590 /* try to find a perfect match in the device database */
591 dbnode = (usba_devdb_info_t *)avl_find(&usba_devdb, req_node, &where);
592 if (dbnode == NULL) {
593 /* look for a generic rule */
594 req_rec->serialno = req_rec->pathname = NULL;
595 dbnode = (usba_devdb_info_t *)avl_find(&usba_devdb, req_node,
596 &where);
597 }
598 rw_exit(&usba_devdb_lock);
599
600 kmem_free(req_rec, sizeof (usba_configrec_t));
601 kmem_free(req_node, sizeof (usba_devdb_info_t));
602
603 if (dbnode) {
604 return (dbnode->usb_dev);
605 } else {
606 return (NULL);
607 }
608 }
609
610
611 /*
612 * usba_devdb_refresh
613 * Reinitializes the device database. It destroys the old one and creates
614 * a new one by re-reading the file.
615 */
616 int
617 usba_devdb_refresh()
618 {
619 rw_enter(&usba_devdb_lock, RW_WRITER);
620
621 usba_build_devdb = B_TRUE;
622
623 /* destroy all nodes in the existing database */
624 usba_devdb_destroy_device_database();
625
626 /* now build a new one */
627 (void) usba_devdb_build_device_database();
628
629 usba_build_devdb = B_FALSE;
630
631 rw_exit(&usba_devdb_lock);
632
633 return (0);
634 }