?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x11/components/mesa: fix erroneous dri-drivers-path
[oi-userland.git] / components / library / libusb / ugen / src / libusbugen.c
blobf07afb0c215c756a375af1ffd25ec397073c7ca4
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 (c) 2004, 2011, Oracle and/or its affiliates. All rights reserved.
23 */
24
25 /*
26 * This library can either be used stand-alone or as plugin
27 * to the libusb wrapper library.
28 * The libusb API 0.1.0.10 has been implemented using all original code
29 * which was not derived from opensource.
30 *
31 * XXX issues:
32 * - timeout thru signal
33 * - usb_interrupt/bulk_write/read should have common code
34 */
35
36 #include <stdlib.h>
37 #include <stdio.h>
38 #include <errno.h>
39 #include <unistd.h>
40 #include <string.h>
41 #include <fcntl.h>
42 #include <sys/time.h>
43 #include <dirent.h>
44 #include <stdarg.h>
45 #include <strings.h>
46 #include <sys/stat.h>
47 #include <regex.h>
48
49 #include <sys/usb/clients/ugen/usb_ugen.h>
50 #include "usb.h"
51 #include "libusbugen_impl.h"
52
53 /* global variables */
54 usb_bus_t *usb_busses = NULL;
55 const char *libusb_version = "1.1";
56
57 /* error handling */
58 static char usb_error_string[1024];
59 static int usb_error_errno;
60 static usb_error_type_t usb_error_type = USB_ERROR_TYPE_NONE;
61
62 /* debugging */
63 static int libusb_debug = DEBUG_NONE;
64
65 /* api binding */
66 static int libusb_api = API_RELAXED;
67
68 /* internal function prototypes */
69 static void usb_error_str(int x, char *format, ...);
70 static int usb_error(int x);
71 static void usb_dprintf(int level, char *format, ...);
72 static void usb_dump_data(char *data, int size);
73
74 static int usb_open_ep0(usb_dev_handle_impl_t *hdl);
75 static void usb_close_ep0(usb_dev_handle_impl_t *hdl);
76 static int usb_check_access(usb_dev_handle *dev);
77 static int usb_search_dev_usb(usb_device_t **new_devices);
78 static int usb_do_io(int fd, int stat_fd, char *data, size_t size, int flag);
79 static int usb_send_msg(int fd, int stat_fd, int requesttype, int request,
80 int value, int index, char *data, int size);
81 static int usb_check_device_and_status_open(usb_dev_handle *dev,
82 int ep, int ep_type, int mode);
83 static int usb_get_status(int fd);
84 static void usb_set_ep_iface_alts(usb_dev_handle_impl_t *hdl,
85 usb_dev_handle_info_t *info, int index, int interface, int alternate);
86
87 static int usb_setup_all_configs(usb_dev_handle_impl_t *hdl);
88 static void usb_free_all_configs(usb_device_t *device);
89 static int usb_parse_config(usb_dev_handle_impl_t *hdl, uint_t index);
90 static void usb_free_config(usb_device_t *device, uint_t index);
91 static int usb_parse_interface(usb_dev_handle_impl_t *hdl, uint_t index,
92 uint_t iface, char *cloud);
93 static void usb_free_interface(usb_device_t *device, uint_t index,
94 uint_t iface);
95 static int usb_parse_alternate(usb_dev_handle_impl_t *hdl, uint_t index,
96 uint_t iface, uint_t alt, char *cloud);
97 static void usb_free_alternate(usb_device_t *device, uint_t index,
98 uint_t iface, uint_t alt);
99 static int usb_parse_endpoint(usb_dev_handle_impl_t *hdl, int index,
100 int iface, int alt, int ep, char *cloud);
101 static void usb_find_extra(uchar_t *buf, size_t buflen,
102 unsigned char **extra, int *extralen);
103
104 static void usb_close_all_eps(usb_dev_handle_impl_t *hdl);
105 static void usb_add_device(usb_device_t **list, usb_device_t *dev);
106 static void usb_remove_device(usb_device_t **list, usb_device_t *dev);
107 static int usb_check_device_in_list(usb_device_t *list, usb_device_t *dev);
108
109 static void usb_free_dev(usb_device_t *dev);
110 static void usb_free_bus(usb_bus_t *bus);
111
112 static size_t usb_parse_dev_descr(uchar_t *buf, size_t buflen,
113 struct usb_device_descriptor *ret_descr, size_t ret_buf_len);
114 static size_t usb_parse_cfg_descr(uchar_t *buf, size_t buflen,
115 usb_cfg_descr_t *ret_descr, size_t ret_buf_len,
116 unsigned char **extra, int *extralen);
117 static size_t usb_parse_if_descr(uchar_t *buf, size_t buflen,
118 uint_t if_number, uint_t alt_if_setting,
119 usb_if_descr_t *ret_descr, size_t ret_buf_len,
120 unsigned char **extra, int *extralen);
121 static size_t usb_parse_ep_descr(uchar_t *buf, size_t buflen,
122 uint_t if_number, uint_t alt_if_setting, uint_t ep_index,
123 usb_ep_descr_t *ret_descr, size_t ret_buf_len,
124 unsigned char **extra, int *extralen);
125 static uchar_t usb_ep_index(uint8_t ep_addr);
126
127 /*
128 * libusb_init:
129 *
130 * Returns: 0 or ENOSUP if we cannot support any bus
131 */
132 int
133 libusb_init(void)
134 {
135 return (0);
136 }
137
138 /*
139 * libusb_fini:
140 *
141 * Returns: always returns 0
142 */
143 int
144 libusb_fini(void)
145 {
146 return (0);
147 }
148
149 /*
150 * Entry points:
151 *
152 * usb_set_debug:
153 * sets debug level for tracing
154 */
155 void
156 usb_set_debug(int level)
157 {
158 if (getenv("SUN_LIBUSBUGEN_DEBUG")) {
159
160 level = atoi(getenv("SUN_LIBUSBUGEN_DEBUG"));
161
162 } else if (getenv("SUN_LIBUSB_DEBUG")) {
163
164 level = atoi(getenv("SUN_LIBUSB_DEBUG"));
165 }
166
167 if (level < 0)
168 return;
169
170 libusb_debug = level;
171
172 usb_dprintf(DEBUG_FUNCTIONS, "usb_set_debug(): "
173 "Setting debugging level to %d (%s)\n",
174 level, level ? "on" : "off");
175 }
176
177 /*
178 * usb_init:
179 * not much to initialize. just set debug level
180 */
181 void
182 usb_init(void)
183 {
184 if (getenv("LIBUSB_API_STRICT")) {
185 libusb_api = API_STRICT;
186 }
187
188 usb_set_debug(libusb_debug);
189
190 usb_dprintf(DEBUG_FUNCTIONS, "usb_init(): "
191 "libusb version=%s\n", libusb_version);
192 }
193
194 /*
195 * usb_get_busses:
196 * Returns: usb_busses pointer
197 */
198 usb_bus_t *
199 usb_get_busses(void)
200 {
201 return (usb_busses);
202 }
203
204 /*
205 * usb_find_busses:
206 * finds all busses in the system. On solaris we have
207 * only one flat name space, /dev/usb
208 *
209 * Returns: change in number of busses or negative errno
210 */
211 int
212 usb_find_busses(void)
213 {
214 usb_bus_t *bus;
215
216 /* we only have one name space for all USB busses */
217 if (usb_busses == NULL) {
218 /* never freed */
219 if ((bus = calloc(sizeof (*bus), 1)) == NULL) {
220
221 return (usb_error(ENOMEM));
222 }
223
224 (void) strncpy(bus->dirname, "/dev/usb",
225 sizeof (bus->dirname));
226
227 usb_dprintf(DEBUG_FUNCTIONS, "usb_find_busses(): "
228 "found %s\n", bus->dirname);
229
230 usb_busses = bus;
231
232 return (1);
233 }
234
235 return (0);
236 }
237
238 /*
239 * usb_find_devices:
240 * finds all devices that have appeared and removes devices
241 * from the list that are no longer there
242 *
243 * Returns: change in number of devices or a negative errno
244 */
245 int
246 usb_find_devices(void)
247 {
248 int i, rval, found;
249 int changes = 0;
250 usb_device_t *new_devices;
251 usb_device_t *dev, *next_dev, *new, *next_new;
252
253 new_devices = NULL;
254
255 rval = usb_search_dev_usb(&new_devices);
256 if (rval != 0) {
257
258 return (usb_error(rval));
259 }
260
261 /* is any of devices on the new list also on the old list? */
262 for (dev = usb_busses->devices; dev != NULL; dev = next_dev) {
263 next_dev = dev->next;
264 found = 0;
265 for (new = new_devices; new != NULL; new = next_new) {
266 next_new = new->next;
267 if (strncmp(dev->filename, new->filename,
268 sizeof (dev->filename)) == 0) {
269 usb_remove_device(&new_devices, new);
270 usb_free_dev(new);
271 found++;
272 break;
273 }
274 }
275
276 /* the device must have been hot removed */
277 if (!found) {
278 usb_remove_device(&usb_busses->devices, dev);
279 usb_free_dev(dev);
280 }
281 }
282
283 /* add all new_devices to the old_devices list */
284 usb_dprintf(DEBUG_DETAILED, "moving new to old\n");
285
286 for (new = new_devices; new != NULL; new = next_new) {
287 next_new = new->next;
288 usb_remove_device(&new_devices, new);
289 usb_add_device(&usb_busses->devices, new);
290 (void) usb_close(usb_open(new));
291 changes++;
292 }
293
294 usb_dprintf(DEBUG_DETAILED, "usb_devices list:\n");
295 for (i = 0, dev = usb_busses->devices; dev != NULL;
296 i++, dev = next_dev) {
297 next_dev = dev->next;
298 usb_dprintf(DEBUG_DETAILED, "%d: %s\n", i, dev->filename);
299 }
300
301 return (changes);
302 }
303
304 /*
305 * usb_device:
306 * included because sane uses this
307 * Returns: usb_device structure associated with handle
308 */
309 struct usb_device *
310 usb_device(usb_dev_handle *dev)
311 {
312 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
313
314 return ((hdl != NULL) ? hdl->device : NULL);
315 }
316
317 /*
318 * usb_open:
319 * opens the device for access
320 *
321 * Returns: a usb device handle or NULL
322 */
323 usb_dev_handle *
324 usb_open(usb_device_t *dev)
325 {
326 usb_dev_handle_impl_t *hdl;
327 usb_dev_handle_info_t *info;
328 int i, rval;
329
330 usb_dprintf(DEBUG_FUNCTIONS, "usb_open():\n");
331
332 if (usb_check_device_in_list(usb_busses->devices,
333 dev) == 0) {
334 usb_dprintf(DEBUG_ERRORS, "usb_open(): "
335 "illegal usb_device pointer\n");
336
337 return (NULL);
338 }
339
340 /* create a handle and info structure */
341 if ((hdl = calloc(sizeof (*hdl), 1)) == NULL) {
342
343 return (NULL);
344 }
345 hdl->device = dev;
346 if ((info = calloc(sizeof (*info), 1)) == NULL) {
347 free(hdl);
348
349 return (NULL);
350 }
351
352 hdl->info = info;
353
354 /* set all file descriptors to "closed" */
355 for (i = 0; i < USB_MAXENDPOINTS; i++) {
356 hdl->info->ep_fd[i] = -1;
357 hdl->info->ep_status_fd[i] = -1;
358 if (i > 0) {
359 hdl->info->ep_interface[i] = -1;
360 }
361 }
362
363 /* open default control ep and keep it open */
364 if ((rval = usb_open_ep0(hdl)) != 0) {
365 usb_dprintf(DEBUG_ERRORS, "usb_open_ep0 failed: %d\n", rval);
366 free(info);
367 free(hdl);
368
369 return (NULL);
370 }
371
372 /*
373 * setup config info: trees of configs, interfaces, alternates
374 * and endpoints structures
375 */
376 if (usb_setup_all_configs(hdl) != 0) {
377 usb_free_all_configs(hdl->device);
378 usb_close_ep0(hdl);
379 free(info);
380 free(hdl);
381
382 return (NULL);
383 }
384
385 /* set when the app claims an interface */
386 info->configuration_value =
387 info->claimed_interface = info->alternate = -1;
388
389 usb_dprintf(DEBUG_FUNCTIONS, "usb_open(): hdl=0x%x\n", (int)hdl);
390
391 return ((usb_dev_handle *)hdl);
392 }
393
394 /*
395 * usb_close:
396 * closes the device and free resources
397 *
398 * Returns: 0
399 */
400 int
401 usb_close(usb_dev_handle *dev)
402 {
403 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
404 usb_dev_handle_info_t *info;
405
406 usb_dprintf(DEBUG_FUNCTIONS, "usb_close(): hdl=0x%x\n", hdl);
407
408 if (hdl) {
409 info = hdl->info;
410
411 usb_dprintf(DEBUG_DETAILED,
412 "usb_close(): claimed %d\n",
413 info->claimed_interface);
414
415 if (info->claimed_interface != -1) {
416 (void) usb_release_interface(dev,
417 info->claimed_interface);
418 }
419 usb_close_all_eps(hdl);
420 usb_close_ep0(hdl);
421
422 free(info);
423 free(hdl);
424
425 return (0);
426 }
427
428 return (usb_error(EINVAL));
429 }
430
431 /*
432 * usb_control_msg:
433 * sends a control message
434 *
435 * Returns: actual number of data bytes transferred or
436 * a negative errno
437 */
438 /*ARGSUSED*/
439 int
440 usb_control_msg(usb_dev_handle *dev, int requesttype, int request,
441 int value, int index, char *data, int size, int timeout)
442 {
443 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
444 usb_dev_handle_info_t *info;
445 int additional;
446 int rval;
447
448 usb_dprintf(DEBUG_FUNCTIONS, "usb_control_msg():\n");
449
450 if ((hdl == NULL) || (size < 0)) {
451
452 return (usb_error(EINVAL));
453 }
454 info = hdl->info;
455
456 /*
457 * no need to do validation since ep0 is always open and
458 * we do not need to claim an interface first
459 *
460 * usb_send_msg returns #bytes xferred or negative errno
461 */
462 rval = usb_send_msg(info->ep_fd[0], info->ep_status_fd[0],
463 requesttype, request, value, index, data, size);
464
465 /* less than setup bytes transferred? */
466 if (rval < 8) {
467 usb_error_str(errno,
468 "error sending control message: %d", rval);
469
470 return ((rval >= 0) ?
471 usb_error(EIO) : usb_error(-rval));
472 }
473
474 rval -= 8; /* substract setup length */
475
476 /* for IN requests, now transfer the remaining bytes */
477 if ((size) && (requesttype & USB_DEV_REQ_DEV_TO_HOST)) {
478 additional = usb_do_io(info->ep_fd[0],
479 info->ep_status_fd[0], data, size, READ);
480 } else {
481 additional = rval;
482 }
483
484 usb_dprintf(DEBUG_FUNCTIONS,
485 "usb_control_msg(): additional 0x%x bytes\n", additional);
486
487 return (additional);
488 }
489
490 /*
491 * usb_bulk_write:
492 * writes to a bulk endpoint
493 *
494 * Returns: actual number of data bytes transferred or negative errno
495 */
496 /* ARGSUSED */
497 int
498 usb_bulk_write(usb_dev_handle *dev, int ep, char *data, int size,
499 int timeout)
500 {
501 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
502 usb_dev_handle_info_t *info;
503 int sent, rval;
504 int ep_index = usb_ep_index(ep);
505
506 usb_dprintf(DEBUG_FUNCTIONS, "usb_bulk_write(): ep=0x%x\n", ep);
507
508 if ((hdl == NULL) || (data == NULL) || (size <= 0)) {
509 usb_dprintf(DEBUG_ERRORS,
510 "usb_bulk_write(): NULL handle or data\n");
511
512 return (usb_error(EINVAL));
513 }
514 info = hdl->info;
515
516 /* do some validation first */
517 if ((rval = usb_check_device_and_status_open(dev, ep,
518 USB_ENDPOINT_TYPE_BULK, O_WRONLY)) != 0) {
519 usb_dprintf(DEBUG_ERRORS,
520 "usb_check_device_and_status_open() failed\n");
521
522 return (usb_error(rval));
523 }
524
525 /* now write out the bytes */
526 sent = usb_do_io(info->ep_fd[ep_index], info->ep_status_fd[ep_index],
527 data, size, WRITE);
528
529 return (sent);
530 }
531
532 /*
533 * usb_bulk_read:
534 * reads from a bulk endpoint
535 *
536 * Returns: actual number of data bytes transferred or negative errno
537 */
538 /* ARGSUSED */
539 int
540 usb_bulk_read(usb_dev_handle *dev, int ep, char *data, int size,
541 int timeout)
542 {
543 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
544 usb_dev_handle_info_t *info;
545 int ep_index, received, rval;
546
547 ep |= USB_ENDPOINT_IN;
548 ep_index = usb_ep_index(ep);
549
550 usb_dprintf(DEBUG_FUNCTIONS, "usb_bulk_read(): ep=0x%x\n", ep);
551
552 if ((hdl == NULL) || (data == NULL) || (size <= 0)) {
553 usb_dprintf(DEBUG_ERRORS,
554 "usb_bulk_read(): NULL handle or data\n");
555
556 return (usb_error(EINVAL));
557 }
558 info = hdl->info;
559
560 /* do some validation first */
561 if ((rval = usb_check_device_and_status_open(dev, ep,
562 USB_ENDPOINT_TYPE_BULK, O_RDONLY)) != 0) {
563 usb_dprintf(DEBUG_ERRORS,
564 "usb_check_device_and_status_open() failed\n");
565
566 return (usb_error(rval));
567 }
568
569 /* now read in the bytes */
570 received = usb_do_io(info->ep_fd[ep_index],
571 info->ep_status_fd[ep_index],
572 data, size, READ);
573
574 return (received);
575 }
576
577 /*
578 * usb_interrupt_write:
579 * writes data to an interrupt endpoint
580 *
581 * Returns: actual number of data bytes transferred or negative errno
582 */
583 /* ARGSUSED */
584 int
585 usb_interrupt_write(usb_dev_handle *dev, int ep, char *data, int size,
586 int timeout)
587 {
588 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
589 usb_dev_handle_info_t *info;
590 int sent, rval;
591 int ep_index = usb_ep_index(ep);
592
593 usb_dprintf(DEBUG_FUNCTIONS, "usb_interrupt_write(): ep=0x%x\n", ep);
594
595 if ((hdl == NULL) || (data == NULL) || (size <= 0)) {
596 usb_dprintf(DEBUG_ERRORS,
597 "usb_interrupt_write(): NULL handle or data\n");
598
599 return (usb_error(EINVAL));
600 }
601 info = hdl->info;
602
603 /* do some validation first */
604 if ((rval = usb_check_device_and_status_open(dev, ep,
605 USB_ENDPOINT_TYPE_INTERRUPT, O_WRONLY)) != 0) {
606 usb_dprintf(DEBUG_ERRORS,
607 "usb_check_device_and_status_open() failed\n");
608
609 return (usb_error(rval));
610 }
611
612 /* now transfer the bytes */
613 sent = usb_do_io(info->ep_fd[ep_index],
614 info->ep_status_fd[ep_index],
615 data, size, WRITE);
616
617 return (sent);
618 }
619
620 /*
621 * usb_interrupt_read:
622 * reads data from an interrupt endpoint
623 *
624 * Returns: actual number of data bytes transferred or negative errno
625 */
626 /* ARGSUSED */
627 int
628 usb_interrupt_read(usb_dev_handle *dev, int ep, char *data, int size,
629 int timeout)
630 {
631 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
632 usb_dev_handle_info_t *info;
633 int ep_index, received, rval;
634
635 ep |= USB_ENDPOINT_IN;
636 ep_index = usb_ep_index(ep);
637
638 usb_dprintf(DEBUG_FUNCTIONS, "usb_interrrupt_read(): ep=0x%x\n", ep);
639
640 if ((hdl == NULL) || (data == NULL) || (size <= 0)) {
641 usb_dprintf(DEBUG_ERRORS,
642 "usb_interrupt_read(): NULL handle or data\n");
643
644 return (usb_error(EINVAL));
645 }
646 info = hdl->info;
647
648 /* do some validation first */
649 if ((rval = usb_check_device_and_status_open(dev, ep,
650 USB_ENDPOINT_TYPE_INTERRUPT, O_RDONLY)) != 0) {
651 usb_dprintf(DEBUG_ERRORS,
652 "usb_check_device_and_status_open() failed\n");
653
654 return (usb_error(rval));
655 }
656
657 /* now transfer the bytes */
658 received = usb_do_io(info->ep_fd[ep_index],
659 info->ep_status_fd[ep_index],
660 data, size, READ);
661
662 /* close the endpoint so we stop polling the endpoint now */
663 (void) close(info->ep_fd[ep_index]);
664 (void) close(info->ep_status_fd[ep_index]);
665 info->ep_fd[ep_index] = -1;
666 info->ep_status_fd[ep_index] = -1;
667
668 return (received);
669 }
670
671 /*
672 * usb_get_string:
673 * gets a raw unicode string
674 *
675 * Returns: number of bytes transferred or negative errno
676 */
677 int
678 usb_get_string(usb_dev_handle *dev, int index, int langid, char *buf,
679 size_t buflen)
680 {
681 /*
682 * We can't use usb_get_descriptor() because it's lacking the index
683 * parameter. This will be fixed in libusb 1.0
684 */
685 usb_dprintf(DEBUG_FUNCTIONS,
686 "usb_get_string(): index=%d langid=0x%x len=%d\n",
687 index, langid, buflen);
688
689 if ((dev == NULL) || (buf == NULL) || (buflen == 0)) {
690 usb_dprintf(DEBUG_ERRORS,
691 "usb_get_string(): NULL handle or data\n");
692
693 return (usb_error(EINVAL));
694 }
695
696
697 return (usb_control_msg(dev, USB_DEV_REQ_DEV_TO_HOST,
698 USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) + index,
699 langid, buf, (int)buflen, 1000));
700 }
701
702 /*
703 * usb_get_string_simple:
704 * gets a cooked ascii string
705 *
706 * Returns: number of bytes transferred or negative errno
707 */
708 int
709 usb_get_string_simple(usb_dev_handle *dev, int index, char *buf,
710 size_t buflen)
711 {
712 char tbuf[256];
713 int ret, langid, si, di;
714
715 usb_dprintf(DEBUG_FUNCTIONS, "usb_get_string_simple(): index=%d\n",
716 index);
717
718 if ((dev == NULL) || (buf == NULL) || (buflen == 0)) {
719 usb_dprintf(DEBUG_ERRORS,
720 "usb_get_string_simple(): NULL handle or data\n");
721
722 return (usb_error(EINVAL));
723 }
724
725 (void) memset(buf, 0, buflen);
726
727 /*
728 * Asking for the zero'th index is special - it returns a string
729 * descriptor that contains all the language IDs supported by the
730 * device. Typically there aren't many - often only one. The
731 * language IDs are 16 bit numbers, and they start at the third byte
732 * in the descriptor. See USB 2.0 specification, section 9.6.7, for
733 * more information on this.
734 */
735 ret = usb_get_string(dev, index, 0, tbuf, sizeof (tbuf));
736 usb_dprintf(DEBUG_DETAILED, "usb_get_string() returned %d\n", ret);
737
738 if (ret < 4) {
739 langid = 0x409;
740 } else {
741 langid = tbuf[2] | (tbuf[3] << 8);
742 }
743
744 usb_dprintf(DEBUG_DETAILED, "using langid=0x%x\n", langid);
745
746 ret = usb_get_string(dev, index, langid, tbuf, sizeof (tbuf));
747 if (ret < 0) {
748
749 return (ret);
750 }
751 if (tbuf[1] != USB_DT_STRING) {
752
753 return (-EIO);
754 }
755 if (tbuf[0] > ret) {
756
757 return (-EFBIG);
758 }
759
760 for (di = 0, si = 2; si < tbuf[0]; si += 2) {
761 if (di >= ((int)buflen - 1)) {
762 break;
763 }
764
765 if (tbuf[si + 1]) { /* high byte */
766 buf[di++] = '?';
767 } else {
768 buf[di++] = tbuf[si];
769 }
770 }
771
772 buf[di] = 0;
773
774 return (di);
775 }
776
777 /*
778 * usb_get_descriptor_by_endpoint:
779 * usb_get_descriptor:
780 * get a descriptor. by_endpoint does not appear to make
781 * much sense.
782 *
783 * Returns: number of bytes transferred or negative errno
784 */
785 int
786 usb_get_descriptor_by_endpoint(usb_dev_handle *udev, int ep,
787 uchar_t type, uchar_t index, void *buf, int size)
788 {
789 if ((udev == NULL) || (buf == NULL) || (size <= 0)) {
790 usb_dprintf(DEBUG_ERRORS,
791 "usb_get_descriptor_by_endpoint(): "
792 "NULL handle or data\n");
793
794 return (usb_error(EINVAL));
795 }
796
797 (void) memset(buf, 0, size);
798
799 return (usb_control_msg(udev,
800 ep | USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
801 (type << 8) + index, 0, buf, size, 1000));
802 }
803
804 int
805 usb_get_descriptor(usb_dev_handle *udev, uchar_t type,
806 uchar_t index, void *buf, int size)
807 {
808 if ((udev == NULL) || (buf == NULL) || (size <= 0)) {
809 usb_dprintf(DEBUG_ERRORS,
810 "usb_get_string_simple(): NULL handle or data\n");
811
812 return (usb_error(EINVAL));
813 }
814
815 (void) memset(buf, 0, size);
816
817 return (usb_control_msg(udev,
818 USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR,
819 (type << 8) + index, 0, buf, size, 1000));
820 }
821
822 /*
823 * usb_set_altinterface:
824 * switches to the alternate interface for the device
825 * Note that ugen does not really need this. It does implicit
826 * cfg and alt switches when the endpoint is opened.
827 *
828 * Returns: 0 or negative errno
829 */
830 /* ARGSUSED */
831 int
832 usb_set_altinterface(usb_dev_handle *dev, int alt)
833 {
834 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
835 usb_dev_handle_info_t *info;
836 usb_device_specific_t *dev_specific;
837 int index, iface, err;
838
839 usb_dprintf(DEBUG_FUNCTIONS, "usb_set_altinterface(): "
840 "hdl=0x%x alt=%d\n", hdl, alt);
841
842 if (hdl == NULL) {
843 usb_dprintf(DEBUG_ERRORS,
844 "usb_set_altinterface(): NULL handle\n");
845
846 return (usb_error(EINVAL));
847 }
848
849 info = hdl->info;
850
851 if (libusb_api == API_RELAXED) {
852 if (info->claimed_interface == -1) {
853 /*
854 * usb_claim_interface() should always be called
855 * prior usb_set_altinterface(), but some apps
856 * do not do this, hence we call it here assuming
857 * the default interface.
858 */
859 if ((err = usb_claim_interface(dev, 0))) {
860
861 return (err);
862 }
863 }
864 }
865
866 iface = info->claimed_interface;
867 dev_specific = (usb_device_specific_t *)(hdl->device->dev);
868
869 usb_dprintf(DEBUG_DETAILED, "claimed=%d, cfgvalue=%d, hdl=0x%x\n",
870 info->claimed_interface, info->configuration_value,
871 dev_specific->claimed_interfaces[iface], hdl);
872
873 if ((info->claimed_interface == -1) ||
874 (info->configuration_value == -1) ||
875 (hdl != dev_specific->claimed_interfaces[iface])) {
876
877 return (usb_error(EACCES));
878 }
879
880 usb_close_all_eps(hdl);
881
882 /* find the conf index */
883 for (index = 0; index < hdl->device->descriptor.bNumConfigurations;
884 index++) {
885 if (info->configuration_value ==
886 hdl->device->config[index].bConfigurationValue) {
887 break;
888 }
889 }
890
891 usb_dprintf(DEBUG_DETAILED,
892 "cfg value=%d index=%d, iface=%d, alt=%d #alts=%d\n",
893 info->configuration_value, index, iface, alt,
894 hdl->device->config[index].interface[iface].num_altsetting);
895
896 if ((alt < 0) || (alt >= hdl->device->
897 config[index].interface[iface].num_altsetting)) {
898
899 return (usb_error(EINVAL));
900 }
901
902 info->alternate = alt;
903
904 usb_set_ep_iface_alts(hdl, info, index, iface, alt);
905
906 return (0);
907 }
908
909 /*
910 * usb_set_configuration:
911 * sets the configuration for the device.
912 * ugen implicitly switches configuration and rejects
913 * set configuration requests
914 *
915 * Returns: 0
916 */
917 /* ARGSUSED */
918 int
919 usb_set_configuration(usb_dev_handle *dev, int configuration)
920 {
921 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
922 usb_dev_handle_info_t *info;
923 int index, i;
924
925 usb_dprintf(DEBUG_FUNCTIONS,
926 "usb_set_configuration(): config = %d\n", configuration);
927
928 if (hdl == NULL) {
929 usb_dprintf(DEBUG_ERRORS,
930 "usb_set_configuration(): NULL handle\n");
931
932 return (usb_error(EINVAL));
933 }
934 info = hdl->info;
935
936 /* find the conf index */
937 for (index = 0; index < hdl->device->descriptor.bNumConfigurations;
938 index++) {
939 if (configuration ==
940 hdl->device->config[index].bConfigurationValue) {
941 break;
942 }
943 }
944
945 if (index >= hdl->device->descriptor.bNumConfigurations) {
946 usb_dprintf(DEBUG_ERRORS,
947 "usb_set_configuration(): invalid\n");
948
949 return (usb_error(EINVAL));
950 }
951
952 usb_close_all_eps(hdl);
953 info->configuration_value = configuration;
954 info->configuration_index = index;
955
956 /* reset ep arrays */
957 for (i = 0; i < USB_MAXENDPOINTS; i++) {
958 info->ep_interface[i] = -1;
959 }
960 if (info->claimed_interface != -1) {
961 (void) usb_release_interface(dev, info->claimed_interface);
962 }
963
964 return (0);
965 }
966
967 /*
968 * usb_clear_halt:
969 * clears a halted endpoint
970 * ugen has auto clearing but we send the request anyways
971 *
972 * Returns: 0 or negative errno
973 */
974 /* ARGSUSED */
975 int
976 usb_clear_halt(usb_dev_handle *dev, unsigned int ep)
977 {
978 int rval;
979 int index = usb_ep_index(ep);
980 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
981 usb_dev_handle_info_t *info;
982
983 usb_dprintf(DEBUG_FUNCTIONS, "usb_clear_halt(): ep=0x%x\n", ep);
984
985 if (dev == NULL) {
986 usb_dprintf(DEBUG_ERRORS,
987 "usb_clear_halt(): NULL handle\n");
988
989 return (usb_error(EINVAL));
990 }
991 info = hdl->info;
992
993 usb_dprintf(DEBUG_DETAILED, "index=0x%x, ep_intf=%d\n",
994 index, info->ep_interface[index]);
995
996 if (info->ep_interface[index] == -1) {
997
998 return (usb_error(EINVAL));
999 }
1000
1001
1002 /* only check for ep > 0 */
1003 if (ep && ((rval = usb_check_access(dev) != 0))) {
1004
1005 return (usb_error(rval));
1006 }
1007
1008 rval = usb_control_msg(dev,
1009 USB_DEV_REQ_HOST_TO_DEV | USB_RECIP_ENDPOINT,
1010 USB_REQ_CLEAR_FEATURE, 0, ep, NULL, 0, 0);
1011
1012 if (rval < 0) {
1013 usb_error_str(errno, "could not clear feature on ep=0x%x", ep);
1014 }
1015
1016 return (rval);
1017 }
1018
1019 /*
1020 * usb_claim_interface:
1021 * ugen does not have a claim interface concept but all endpoints
1022 * are opened exclusively. This provides some exclusion. However,
1023 * the interrupt IN endpoint is closed after the read
1024 *
1025 * Returns: 0 or negative errno
1026 */
1027 int
1028 usb_claim_interface(usb_dev_handle *dev, int interface)
1029 {
1030 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
1031 usb_dev_handle_info_t *info;
1032 usb_device_specific_t *dev_specific;
1033 int index;
1034
1035 if (hdl == NULL) {
1036 usb_dprintf(DEBUG_ERRORS,
1037 "usb_claim_interface(): NULL handle\n");
1038
1039 return (usb_error(EINVAL));
1040 }
1041 info = hdl->info;
1042 dev_specific = (usb_device_specific_t *)(hdl->device->dev);
1043
1044 usb_dprintf(DEBUG_FUNCTIONS, "usb_claim_interface(): hdl=0x%x: "
1045 "interface = %d\n", hdl, interface);
1046
1047 if (info->configuration_value == -1) {
1048 index = 0;
1049 } else {
1050 /* find the conf index */
1051 for (index = 0;
1052 index < hdl->device->descriptor.bNumConfigurations;
1053 index++) {
1054 if (info->configuration_value ==
1055 hdl->device->config[index].bConfigurationValue) {
1056 break;
1057 }
1058 }
1059 }
1060 info->configuration_value =
1061 hdl->device->config[index].bConfigurationValue;
1062 info->configuration_index = index;
1063
1064 usb_dprintf(DEBUG_DETAILED, "configuration_value=%d, index=%d\n",
1065 info->configuration_value, index);
1066
1067 /* is this a valid interface? */
1068 if ((interface < 0) || (interface > 255) ||
1069 (interface >= hdl->device->config[index].bNumInterfaces)) {
1070
1071 return (usb_error(EINVAL));
1072 }
1073
1074 /* already claimed? */
1075 if (dev_specific->claimed_interfaces[interface] == hdl) {
1076
1077 return (0);
1078 }
1079
1080 if (info->claimed_interface != -1) {
1081
1082 return (usb_error(EBUSY));
1083 }
1084
1085 if (dev_specific->claimed_interfaces[interface] != 0) {
1086
1087 return (usb_error(EBUSY));
1088 }
1089
1090 usb_dprintf(DEBUG_DETAILED, "usb_claim_interface(): hdl=0x%x: "
1091 "interface = %d, claimed by this udev=%d, by hdl=0x%x\n",
1092 hdl, interface, info->claimed_interface,
1093 dev_specific->claimed_interfaces[interface]);
1094
1095
1096 info->claimed_interface = interface;
1097 info->alternate = 0;
1098 dev_specific->claimed_interfaces[interface] = hdl;
1099
1100 usb_set_ep_iface_alts(hdl, info, index, interface, 0);
1101
1102 return (0);
1103 }
1104
1105 /*
1106 * usb_release_interface:
1107 * releases the acquired interface
1108 *
1109 * Returns: 0 or negative errno
1110 */
1111 /* ARGSUSED */
1112 int
1113 usb_release_interface(usb_dev_handle *dev, int interface)
1114 {
1115 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
1116 usb_dev_handle_info_t *info;
1117 usb_device_specific_t *dev_specific;
1118
1119 if (hdl == NULL) {
1120 usb_dprintf(DEBUG_ERRORS,
1121 "usb_release_interface(): NULL handle\n");
1122
1123 return (usb_error(EINVAL));
1124 }
1125
1126 info = hdl->info;
1127 dev_specific = (usb_device_specific_t *)(hdl->device->dev);
1128
1129 usb_dprintf(DEBUG_FUNCTIONS, "usb_release_interface(): hdl=0x%x: "
1130 "interface = %d\n", hdl, interface);
1131
1132 if ((info->claimed_interface == -1) ||
1133 (info->claimed_interface != interface)) {
1134
1135 return (usb_error(EINVAL));
1136 }
1137
1138 usb_dprintf(DEBUG_DETAILED, "usb_release_interface(): hdl=0x%x: "
1139 "interface = %d, claimed by this udev=%d, by hdl=0x%x\n",
1140 hdl, interface, info->claimed_interface,
1141 dev_specific->claimed_interfaces[interface]);
1142
1143 dev_specific->claimed_interfaces[interface] = 0;
1144 info->claimed_interface = -1;
1145
1146 return (0);
1147 }
1148
1149 /*
1150 * usb_resetep
1151 * resets the endpoint
1152 *
1153 * Returns: 0 or negative errno
1154 */
1155 int
1156 usb_resetep(usb_dev_handle *dev, unsigned int ep)
1157 {
1158 usb_dprintf(DEBUG_FUNCTIONS, "usb_resetep(): ep=0x%x\n", ep);
1159
1160 return (usb_clear_halt(dev, ep));
1161 }
1162
1163 /*
1164 * usb_reset:
1165 * resets the device
1166 * Returns: -ENOTSUP
1167 */
1168 /* ARGSUSED */
1169 int
1170 usb_reset(usb_dev_handle * dev)
1171 {
1172 int rval;
1173
1174 usb_dprintf(DEBUG_FUNCTIONS, "usb_reset():\n");
1175
1176 if (dev == NULL) {
1177 usb_dprintf(DEBUG_ERRORS,
1178 "usb_reset(): NULL handle\n");
1179
1180 return (usb_error(EINVAL));
1181 }
1182
1183 if ((rval = usb_check_access(dev)) != 0) {
1184
1185 return (usb_error(rval));
1186 }
1187
1188 return (usb_error(ENOTSUP));
1189 }
1190
1191 /*
1192 * Helper functions
1193 *
1194 * usb_send_msg:
1195 * creates setup data and send it
1196 *
1197 * Returns: number of bytes transferred or negative errno
1198 */
1199 static int
1200 usb_send_msg(int fd, int stat_fd, int requesttype, int request, int value,
1201 int index, char *data, int size)
1202 {
1203 uint8_t req[8];
1204 int rval;
1205
1206 usb_dprintf(DEBUG_DETAILED, "usb_send_msg():\n"
1207 "\trequesttype 0x%x\n"
1208 "\trequest 0x%x\n"
1209 "\tvalue 0x%x\n"
1210 "\tindex 0x%x\n"
1211 "\tsize 0x%x\n",
1212 requesttype, request, value, index, size);
1213
1214 req[0] = (uint8_t)requesttype;
1215 req[1] = (uint8_t)request;
1216 req[2] = (uint8_t)value;
1217 req[3] = (uint8_t)(value >> 8);
1218 req[4] = (uint8_t)index;
1219 req[5] = (uint8_t)(index >> 8);
1220 req[6] = (uint8_t)size;
1221 req[7] = (uint8_t)(size >> 8);
1222
1223 if (requesttype & USB_DEV_REQ_DEV_TO_HOST) {
1224 rval = usb_do_io(fd, stat_fd, (char *)&req,
1225 sizeof (req), WRITE);
1226 } else {
1227 /* append the write data */
1228 char *buffer;
1229
1230 if ((buffer = malloc(size + 8)) == NULL) {
1231
1232 return (usb_error(ENOMEM));
1233 }
1234
1235 (void) memcpy(buffer, &req, 8);
1236 (void) memcpy(&buffer[8], data, size);
1237 rval = usb_do_io(fd, stat_fd, buffer,
1238 (uint_t)sizeof (req) + size, WRITE);
1239 free(buffer);
1240 }
1241 usb_dprintf(DEBUG_FUNCTIONS, "usb_send_msg(): rval=%d\n", rval);
1242
1243 return (rval);
1244 }
1245
1246 /*
1247 * usb_do_io:
1248 * performs i/o to/from an endpoint and check the
1249 * status of the device if error or short xfer.
1250 *
1251 * Returns: bytes transferred or negative errno
1252 */
1253 static int
1254 usb_do_io(int fd, int stat_fd, char *data, size_t size, int flag)
1255 {
1256 int error;
1257 ssize_t ret;
1258
1259 usb_dprintf(DEBUG_FUNCTIONS, "usb_do_io(): size=0x%x flag=%d\n",
1260 size, flag);
1261
1262 if (size == 0) {
1263
1264 return (0);
1265 }
1266
1267 switch (flag) {
1268 case READ:
1269 ret = read(fd, data, size);
1270 usb_dump_data(data, (int)size);
1271 break;
1272 case WRITE:
1273 usb_dump_data(data, (int)size);
1274 ret = write(fd, data, size);
1275 break;
1276 }
1277 if (ret < 0) {
1278 int save_errno = errno;
1279
1280 /* usb_get_status will do a read and overwrite errno */
1281 error = usb_get_status(stat_fd);
1282 usb_error_str(save_errno, "error %d doing io: errno=%d",
1283 error, save_errno);
1284
1285 return (-save_errno);
1286 }
1287
1288 usb_dprintf(DEBUG_FUNCTIONS, "usb_do_io(): amount=%d\n", ret);
1289
1290 return ((int)ret);
1291 }
1292
1293 /*
1294 * usb_check_access:
1295 * basically checks if the interface has been claimed
1296 *
1297 * Returns: 0 or EACCES/EINVAL
1298 */
1299 static int
1300 usb_check_access(usb_dev_handle *dev)
1301 {
1302 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
1303 usb_dev_handle_info_t *info = hdl->info;
1304
1305 if (hdl == NULL) {
1306
1307 return (EINVAL);
1308 }
1309 info = hdl->info;
1310
1311 usb_dprintf(DEBUG_FUNCTIONS, "usb_check_access(): "
1312 "hdl=0x%x conf=%d claimed=%d alternate=%d\n",
1313 (int)hdl, info->configuration_value,
1314 info->claimed_interface, info->alternate);
1315
1316 if ((info->configuration_value == -1) ||
1317 (info->claimed_interface == -1) ||
1318 (info->alternate == -1)) {
1319
1320 return (EACCES);
1321 }
1322
1323 return (0);
1324 }
1325
1326 /*
1327 * usb_set_ep_iface_alts:
1328 * initialize ep_interface arrays
1329 */
1330 static void
1331 usb_set_ep_iface_alts(usb_dev_handle_impl_t *hdl, usb_dev_handle_info_t *info,
1332 int index, int interface, int alternate)
1333 {
1334 struct usb_interface_descriptor *if_descr;
1335 struct usb_endpoint_descriptor *ep_descr;
1336 int i;
1337
1338 /* reinitialize endpoint arrays */
1339 for (i = 0; i < USB_MAXENDPOINTS; i++) {
1340 info->ep_interface[i] = -1;
1341 }
1342
1343 /*
1344 * for the current config, this interface and alt,
1345 * which endpoints are available
1346 */
1347 if_descr = &hdl->device->config[index].interface[interface].
1348 altsetting[alternate];
1349
1350 usb_dprintf(DEBUG_DETAILED, "cfg%d.%d.%d has %d endpoints\n",
1351 info->configuration_value, interface, alternate,
1352 if_descr->bNumEndpoints);
1353
1354 for (i = 0; i < if_descr->bNumEndpoints; i++) {
1355 ep_descr = &hdl->device->config[index].interface[interface].
1356 altsetting[alternate].endpoint[i];
1357 info->ep_interface[usb_ep_index(
1358 ep_descr->bEndpointAddress)] = interface;
1359 }
1360
1361 usb_dprintf(DEBUG_DETAILED, "ep_interface:\n");
1362 for (i = 0; i < USB_MAXENDPOINTS; i++) {
1363 usb_dprintf(DEBUG_DETAILED, "%d ",
1364 info->ep_interface[i]);
1365 }
1366 usb_dprintf(DEBUG_DETAILED, "\n");
1367 }
1368
1369 /*
1370 * usb_check_device_and_status_open:
1371 * Make sure that the endpoint and status device for the endpoint
1372 * can be opened, or have already been opened.
1373 *
1374 * Returns: errno
1375 */
1376 static int
1377 usb_check_device_and_status_open(usb_dev_handle *dev, int ep, int ep_type,
1378 int mode)
1379 {
1380 usb_dev_handle_impl_t *hdl = (usb_dev_handle_impl_t *)dev;
1381 usb_dev_handle_info_t *info = hdl->info;
1382 char *filename, *statfilename, cfg_num[16], alt_num[16];
1383 int fd, fdstat, index, rval;
1384
1385 index = usb_ep_index(ep);
1386
1387 usb_dprintf(DEBUG_FUNCTIONS,
1388 "usb_check_device_and_status_open(): "
1389 "ep=0x%x mode=%d index=%d\n", ep, mode, index);
1390
1391 if ((rval = usb_check_access(dev)) != 0) {
1392
1393 return (rval);
1394 }
1395
1396 if ((index < 0) || (index > 31)) {
1397
1398 return (EINVAL);
1399 }
1400
1401 usb_dprintf(DEBUG_DETAILED, "claimed=%d ep_interface=%d\n",
1402 info->claimed_interface, info->ep_interface[index]);
1403
1404 if (info->claimed_interface != info->ep_interface[index]) {
1405
1406 return (EINVAL);
1407 }
1408
1409 if ((info->ep_fd[index] > 0) && (info->ep_status_fd[index] > 0)) {
1410
1411 return (0);
1412 }
1413
1414 if (ep == 0) {
1415 /* should already be open */
1416
1417 return (0);
1418 }
1419
1420 if ((filename = malloc(PATH_MAX+1)) == NULL) {
1421
1422 return (ENOMEM);
1423 }
1424 if ((statfilename = malloc(PATH_MAX+1)) == NULL) {
1425 free(filename);
1426
1427 return (ENOMEM);
1428 }
1429
1430 usb_dprintf(DEBUG_DETAILED, "cfgvalue=%d\n",
1431 info->configuration_value);
1432
1433 /* create filename */
1434 if (info->configuration_index > 0) {
1435 (void) snprintf(cfg_num, sizeof (cfg_num), "cfg%d",
1436 info->configuration_value);
1437 } else {
1438 (void) memset(cfg_num, 0, sizeof (cfg_num));
1439 }
1440
1441 if (info->alternate > 0) {
1442 (void) snprintf(alt_num, sizeof (alt_num), ".%d",
1443 info->alternate);
1444 } else {
1445 (void) memset(alt_num, 0, sizeof (alt_num));
1446 }
1447
1448 (void) snprintf(filename, PATH_MAX, "%s/%s/%sif%d%s%s%d",
1449 hdl->device->bus->dirname, hdl->device->filename,
1450 cfg_num, info->ep_interface[index],
1451 alt_num, (ep & USB_EP_DIR_MASK) ? "in" :
1452 "out", (ep & USB_EP_NUM_MASK));
1453
1454 usb_dprintf(DEBUG_DETAILED,
1455 "usb_check_device_and_status_open: %s\n", filename);
1456
1457 /*
1458 * for interrupt IN endpoints, we need to enable one xfer
1459 * mode before opening the endpoint
1460 */
1461 (void) snprintf(statfilename, PATH_MAX, "%sstat", filename);
1462
1463 if ((ep_type == USB_ENDPOINT_TYPE_INTERRUPT) &&
1464 (ep & USB_ENDPOINT_IN)) {
1465 char control = USB_EP_INTR_ONE_XFER;
1466 ssize_t count;
1467
1468 /* open the status device node for the ep first RDWR */
1469 if ((fdstat = open(statfilename, O_RDWR)) == -1) {
1470 usb_error_str(errno, "can't open %s RDWR: %d",
1471 statfilename, errno);
1472
1473 /* might be an older ugen version, try RDONLY */
1474 if ((fdstat = open(statfilename,
1475 O_RDONLY)) == -1) {
1476 usb_error_str(errno,
1477 "can't open %s RDONLY: %d",
1478 filename, errno);
1479 free(filename);
1480 free(statfilename);
1481
1482 return (errno);
1483 }
1484 } else {
1485 count = write(fdstat, &control, sizeof (control));
1486
1487 if (count != 1) {
1488 /* this should have worked */
1489 usb_error_str(errno, "can't write to %s: %d",
1490 filename, errno);
1491 free(filename);
1492 free(statfilename);
1493 (void) close(fdstat);
1494
1495 return (errno);
1496 }
1497 }
1498 } else {
1499 if ((fdstat = open(statfilename, O_RDONLY)) == -1) {
1500 usb_error_str(errno, "can't open %s: %d",
1501 statfilename, errno);
1502 free(filename);
1503 free(statfilename);
1504
1505 return (errno);
1506 }
1507 }
1508
1509 /* open the ep */
1510 if ((fd = open(filename, mode)) == -1) {
1511 usb_error_str(errno, "can't open %s: %d",
1512 filename, errno);
1513 (void) close(fdstat);
1514 free(filename);
1515 free(statfilename);
1516
1517 return (errno);
1518 }
1519
1520 free(filename);
1521 free(statfilename);
1522 info->ep_fd[index] = fd;
1523 info->ep_status_fd[index] = fdstat;
1524
1525
1526 return (0);
1527 }
1528
1529 /*
1530 * usb_ep_index:
1531 * creates an index from endpoint address that can
1532 * be used to index into endpoint lists
1533 *
1534 * Returns: ep index (a number between 0 and 31)
1535 */
1536 static uchar_t
1537 usb_ep_index(uint8_t ep_addr)
1538 {
1539 return ((ep_addr & USB_EP_NUM_MASK) +
1540 ((ep_addr & USB_EP_DIR_MASK) ? 16 : 0));
1541 }
1542
1543 /*
1544 * usb_open_ep0:
1545 * opens default pipe
1546 *
1547 * Returns: errno
1548 */
1549 static int
1550 usb_open_ep0(usb_dev_handle_impl_t *hdl)
1551 {
1552 char *filename;
1553 usb_device_specific_t *dev_specific =
1554 (usb_device_specific_t *)(hdl->device->dev);
1555
1556 usb_dprintf(DEBUG_FUNCTIONS, "usb_open_ep0():\n");
1557
1558 if (dev_specific->ep0_fd) {
1559 dev_specific->ref_count++;
1560 hdl->info->ep_fd[0] = dev_specific->ep0_fd;
1561 hdl->info->ep_status_fd[0] = dev_specific->ep0_fd_stat;
1562
1563 usb_dprintf(DEBUG_DETAILED,
1564 "usb_open_ep0(): already open, ref=%d\n",
1565 dev_specific->ref_count);
1566
1567 return (0);
1568 }
1569
1570 if ((filename = malloc(PATH_MAX+1)) == NULL) {
1571
1572 return (ENOMEM);
1573 }
1574
1575 (void) snprintf(filename, PATH_MAX, "%s/%s/cntrl0",
1576 hdl->device->bus->dirname, hdl->device->filename);
1577
1578 usb_dprintf(DEBUG_DETAILED, "opening %s\n", filename);
1579
1580 hdl->info->ep_fd[0] = open(filename, O_RDWR);
1581 if (hdl->info->ep_fd[0] < 0) {
1582 usb_dprintf(DEBUG_ERRORS, "opening ep0 failed, %d\n",
1583 hdl->info->ep_fd[0]);
1584 free(filename);
1585
1586 return (errno);
1587 }
1588
1589 (void) snprintf(filename, PATH_MAX, "%s/%s/cntrl0stat",
1590 hdl->device->bus->dirname, hdl->device->filename);
1591
1592 usb_dprintf(DEBUG_DETAILED, "opening %s\n", filename);
1593
1594 hdl->info->ep_status_fd[0] = open(filename, O_RDONLY);
1595 if (hdl->info->ep_status_fd[0] < 0) {
1596 free(filename);
1597
1598 return (errno);
1599 }
1600
1601 /* allow sharing between multiple opens */
1602 dev_specific->ep0_fd = hdl->info->ep_fd[0];
1603 dev_specific->ep0_fd_stat = hdl->info->ep_status_fd[0];
1604 dev_specific->ref_count++;
1605
1606 usb_dprintf(DEBUG_DETAILED, "ep0 opened\n");
1607
1608 free(filename);
1609
1610 return (0);
1611 }
1612
1613 /*
1614 * usb_close_ep0:
1615 * closes default ep0
1616 */
1617 static void
1618 usb_close_ep0(usb_dev_handle_impl_t *hdl)
1619 {
1620 usb_device_specific_t *dev_specific =
1621 (usb_device_specific_t *)(hdl->device->dev);
1622
1623 usb_dprintf(DEBUG_FUNCTIONS, "usb_close_ep0():\n");
1624
1625 if (dev_specific->ep0_fd) {
1626 if (--(dev_specific->ref_count) > 0) {
1627 usb_dprintf(DEBUG_DETAILED,
1628 "usb_close_ep0(): ref_count=%d\n",
1629 dev_specific->ref_count);
1630
1631 return;
1632 }
1633 }
1634
1635 if (hdl->info->ep_fd[0] != -1) {
1636 (void) close(hdl->info->ep_fd[0]);
1637 hdl->info->ep_fd[0] = -1;
1638 }
1639 if (hdl->info->ep_status_fd[0] != -1) {
1640 (void) close(hdl->info->ep_status_fd[0]);
1641 hdl->info->ep_status_fd[0] = -1;
1642 }
1643 dev_specific->ep0_fd = 0;
1644 dev_specific->ep0_fd_stat = 0;
1645 }
1646
1647 /*
1648 * usb_close_all_eps:
1649 * closes all open endpoints except 0
1650 */
1651 static void
1652 usb_close_all_eps(usb_dev_handle_impl_t *hdl)
1653 {
1654 int i;
1655
1656 usb_dprintf(DEBUG_FUNCTIONS, "usb_close_all_eps():\n");
1657
1658 for (i = 1; i < USB_MAXENDPOINTS; i++) {
1659 if (hdl->info->ep_fd[i] != -1) {
1660 (void) close(hdl->info->ep_fd[i]);
1661 hdl->info->ep_fd[i] = -1;
1662 }
1663 if (hdl->info->ep_status_fd[i] != -1) {
1664 (void) close(hdl->info->ep_status_fd[i]);
1665 hdl->info->ep_status_fd[i] = -1;
1666 }
1667 }
1668 }
1669
1670 /*
1671 * usb_setup_all_configs:
1672 * parses config cloud for each config
1673 *
1674 * Returns: errno
1675 */
1676 static int
1677 usb_setup_all_configs(usb_dev_handle_impl_t *hdl)
1678 {
1679 char buffer[USB_DEV_DESCR_SIZE];
1680 int rval, len;
1681 uint_t index;
1682
1683 if (hdl->device->config) {
1684
1685 return (0);
1686 }
1687
1688 usb_dprintf(DEBUG_FUNCTIONS, "usb_setup_all_configs():\n");
1689
1690 /* get device descriptor */
1691 rval = usb_control_msg((usb_dev_handle *)hdl,
1692 USB_DEV_REQ_DEV_TO_HOST | USB_TYPE_STANDARD,
1693 USB_REQ_GET_DESCRIPTOR, USB_DESCR_TYPE_SETUP_DEV,
1694 0, buffer, USB_DEV_DESCR_SIZE, 0);
1695
1696 usb_dprintf(DEBUG_DETAILED, "dev descr rval=%d\n", rval);
1697
1698 if (rval != USB_DEV_DESCR_SIZE) {
1699
1700 return (EIO);
1701 }
1702
1703 /* parse device descriptor */
1704 rval = (int)usb_parse_dev_descr((uchar_t *)buffer, sizeof (buffer),
1705 (struct usb_device_descriptor *)&hdl->device->descriptor,
1706 sizeof (struct usb_device_descriptor));
1707
1708 usb_dprintf(DEBUG_DETAILED, "parse dev descr rval=%d\n", rval);
1709
1710 if (rval != (int)sizeof (struct usb_device_descriptor)) {
1711
1712 return (EIO);
1713 }
1714
1715 /* allocate config array */
1716 len = (int) sizeof (struct usb_config_descriptor) *
1717 hdl->device->descriptor.bNumConfigurations;
1718
1719 if ((hdl->device->config = calloc(len, 1)) == NULL) {
1720
1721 return (ENOMEM);
1722 }
1723
1724 /* parse each config cloud */
1725 for (index = 0; index < hdl->device->descriptor.bNumConfigurations;
1726 index++) {
1727 if ((rval = usb_parse_config(hdl, index)) != 0) {
1728
1729 return (rval);
1730 }
1731 }
1732
1733 return (0);
1734 }
1735
1736 /*
1737 * usb_free_all_configs:
1738 * frees all allocated resources
1739 */
1740 static void
1741 usb_free_all_configs(usb_device_t *dev)
1742 {
1743 uint_t index;
1744
1745 usb_dprintf(DEBUG_FUNCTIONS, "usb_free_all_configs(): "
1746 "dev=0x%x config=0x%x #conf=%d\n",
1747 dev, dev->config, dev->descriptor.bNumConfigurations);
1748
1749 if (dev->config) {
1750 for (index = 0; index < dev->descriptor.bNumConfigurations;
1751 index++) {
1752 usb_free_config(dev, index);
1753 }
1754 free(dev->config);
1755 dev->config = NULL;
1756 }
1757 }
1758
1759 /*
1760 * usb_parse_config:
1761 * parse config descriptor and get cloud
1762 *
1763 * Returns: errno
1764 */
1765 static int
1766 usb_parse_config(usb_dev_handle_impl_t *hdl, uint_t index)
1767 {
1768 int rval;
1769 uint_t iface, len;
1770 char buffer[USB_CFG_DESCR_SIZE];
1771 char *cloud;
1772 unsigned char *extra;
1773 int extralen;
1774
1775 usb_dprintf(DEBUG_FUNCTIONS, "usb_parse_config(): index=%d\n",
1776 index);
1777
1778 rval = usb_control_msg((usb_dev_handle *)hdl,
1779 USB_DEV_REQ_DEV_TO_HOST | USB_TYPE_STANDARD,
1780 USB_REQ_GET_DESCRIPTOR, USB_DESCR_TYPE_SETUP_CFG | index,
1781 0, buffer, USB_CFG_DESCR_SIZE, 0);
1782
1783 usb_dprintf(DEBUG_DETAILED, "config descr rval=%d expecting %d\n",
1784 rval, USB_CFG_DESCR_SIZE);
1785
1786 if (rval < USB_CFG_DESCR_SIZE) {
1787
1788 return (EIO);
1789 }
1790
1791 rval = (int)usb_parse_cfg_descr((uchar_t *)buffer, sizeof (buffer),
1792 (usb_cfg_descr_t *)&hdl->device->config[index],
1793 sizeof (usb_cfg_descr_t), &extra, &extralen);
1794
1795 usb_dprintf(DEBUG_DETAILED, "config descr rval=%d expecting %d\n",
1796 rval, sizeof (usb_cfg_descr_t));
1797
1798 if (rval < USB_CFG_DESCR_SIZE) {
1799
1800 return (EIO);
1801 }
1802
1803 usb_dprintf(DEBUG_DETAILED,
1804 "cfg%d: len=%d type=%d total=%d #if=%d cf=%d\n", index,
1805 hdl->device->config[index].bLength,
1806 hdl->device->config[index].bDescriptorType,
1807 hdl->device->config[index].wTotalLength,
1808 hdl->device->config[index].bNumInterfaces,
1809 hdl->device->config[index].bConfigurationValue);
1810
1811 if ((cloud = malloc(hdl->device->config[index].wTotalLength)) ==
1812 NULL) {
1813
1814 return (ENOMEM);
1815 }
1816
1817 /* get complete cloud */
1818 rval = usb_control_msg((usb_dev_handle *)hdl,
1819 USB_DEV_REQ_DEV_TO_HOST | USB_TYPE_STANDARD,
1820 USB_REQ_GET_DESCRIPTOR, USB_DESCR_TYPE_SETUP_CFG | index,
1821 0, (char *)cloud,
1822 hdl->device->config[index].wTotalLength, 0);
1823
1824 if (rval != hdl->device->config[index].wTotalLength) {
1825 free(cloud);
1826
1827 return (EIO);
1828 }
1829
1830 /* parse descriptor again to get extra descriptors */
1831 rval = (int)usb_parse_cfg_descr((uchar_t *)cloud,
1832 hdl->device->config[index].wTotalLength,
1833 (usb_cfg_descr_t *)&hdl->device->config[index],
1834 sizeof (usb_cfg_descr_t), &extra, &extralen);
1835
1836 if (extralen) {
1837 usb_dprintf(DEBUG_DETAILED,
1838 "cfg%d: extra descriptors length=%d:\n",
1839 index, extralen);
1840 usb_dump_data((char *)extra, extralen);
1841
1842 if ((hdl->device->config[index].extra =
1843 calloc(extralen, 1)) == NULL) {
1844 free(cloud);
1845
1846 return (ENOMEM);
1847 }
1848
1849 (void) memcpy(hdl->device->config[index].extra, extra,
1850 extralen);
1851 hdl->device->config[index].extralen = extralen;
1852 }
1853
1854 /* allocate interface array */
1855 len = hdl->device->config[index].bNumInterfaces *
1856 (int)sizeof (struct usb_interface);
1857 if ((hdl->device->config[index].interface = calloc(len, 1)) ==
1858 NULL) {
1859 free(cloud);
1860
1861 return (ENOMEM);
1862 }
1863
1864 for (iface = 0; iface < hdl->device->config[index].bNumInterfaces;
1865 iface++) {
1866 rval = usb_parse_interface(hdl, index, iface, cloud);
1867 if (rval != 0) {
1868 free(cloud);
1869
1870 return (rval);
1871 }
1872 }
1873 free(cloud);
1874
1875 return (0);
1876 }
1877
1878 /*
1879 * usb_free_config:
1880 * frees all allocated config resources
1881 */
1882 static void
1883 usb_free_config(usb_device_t *device, uint_t index)
1884 {
1885 uint_t iface;
1886
1887 usb_dprintf(DEBUG_FUNCTIONS, "usb_free_config(): index=%d\n",
1888 index);
1889
1890 if (device->config[index].interface) {
1891 for (iface = 0; iface < device->config[index].bNumInterfaces;
1892 iface++) {
1893 usb_free_interface(device, index, iface);
1894 }
1895 if (device->config[index].extralen) {
1896 free(device->config[index].extra);
1897 }
1898 free(device->config[index].interface);
1899 }
1900 }
1901
1902 /*
1903 * usb_parse_interface:
1904 * parse an interface descriptor
1905 *
1906 * Returns: errno
1907 */
1908 static int
1909 usb_parse_interface(usb_dev_handle_impl_t *hdl, uint_t index, uint_t iface,
1910 char *cloud)
1911 {
1912 usb_if_descr_t if_descr;
1913 int rval;
1914 uint_t alt, max_alt, len;
1915 unsigned char *extra;
1916 int extralen;
1917
1918 usb_dprintf(DEBUG_FUNCTIONS, "usb_parse_interface(): "
1919 "index=%d, iface=%d\n", index, iface);
1920
1921 /* count the number of alternates for this interface */
1922 for (max_alt = alt = 0; alt < USB_MAXALTSETTING; alt++) {
1923 rval = (int)usb_parse_if_descr((uchar_t *)cloud,
1924 hdl->device->config[index].wTotalLength,
1925 iface, alt, &if_descr, sizeof (if_descr),
1926 &extra, &extralen);
1927
1928 usb_dprintf(DEBUG_DETAILED, "usb_parse_interface: "
1929 "alt %d: rval=%d expecting %d\n",
1930 alt, rval, sizeof (if_descr));
1931
1932 if (rval != (int)sizeof (if_descr)) {
1933
1934 break;
1935 }
1936 max_alt = alt;
1937 }
1938
1939 usb_dprintf(DEBUG_DETAILED,
1940 "usb_parse_interface: max_alt=%d\n", max_alt);
1941
1942 /* allocate alt interface setting array */
1943 len = ++max_alt * (int)sizeof (struct usb_interface_descriptor);
1944 if ((hdl->device->config[index].interface[iface].altsetting =
1945 calloc(len, 1)) == NULL) {
1946
1947 return (ENOMEM);
1948 }
1949 hdl->device->config[index].interface[iface].num_altsetting =
1950 max_alt;
1951 for (alt = 0; alt < max_alt; alt++) {
1952 rval = usb_parse_alternate(hdl, index, iface, alt, cloud);
1953 if (rval != 0) {
1954
1955 return (rval);
1956 }
1957 }
1958
1959 return (0);
1960 }
1961
1962 /*
1963 * usb_free_interface:
1964 * frees interface resources
1965 *
1966 * Returns: errno
1967 */
1968 static void
1969 usb_free_interface(usb_device_t *device, uint_t index, uint_t iface)
1970 {
1971 uint_t alt, max_alt;
1972
1973 usb_dprintf(DEBUG_FUNCTIONS, "usb_free_interface(): "
1974 "index=%d, iface=%d\n", index, iface);
1975
1976 if (device->config[index].interface[iface].altsetting) {
1977 max_alt = device->config[index].interface[iface].
1978 num_altsetting;
1979 for (alt = 0; alt < max_alt; alt++) {
1980 usb_free_alternate(device, index, iface, alt);
1981 }
1982 free(device->config[index].interface[iface].altsetting);
1983 }
1984 }
1985
1986 /*
1987 * usb_parse_alternate:
1988 * parses each alternate descriptor
1989 *
1990 * Returns: errno
1991 */
1992 static int
1993 usb_parse_alternate(usb_dev_handle_impl_t *hdl, uint_t index, uint_t iface,
1994 uint_t alt, char *cloud)
1995 {
1996 uint_t ep, len;
1997 usb_if_descr_t if_descr;
1998 int rval;
1999 unsigned char *extra;
2000 int extralen;
2001
2002 usb_dprintf(DEBUG_FUNCTIONS, "usb_parse_alternate(): "
2003 "index=%d, iface=%d, alt=%d\n", index, iface, alt);
2004
2005 rval = (int)usb_parse_if_descr((uchar_t *)cloud,
2006 hdl->device->config[index].wTotalLength,
2007 iface, alt, &if_descr, sizeof (if_descr), &extra, &extralen);
2008
2009 if (rval != (int)sizeof (if_descr)) {
2010 usb_dprintf(DEBUG_ERRORS, "usb_parse_alternate: rval=%d\n",
2011 rval);
2012
2013 return (EIO);
2014 }
2015
2016 usb_dprintf(DEBUG_DETAILED,
2017 "cfg%d.if%d.%d: len=%d type=%d num=%d alt=%d #ep=%d c=%d"
2018 " sc=%d p=%d i=%d\n", index, iface, alt,
2019 if_descr.bLength,
2020 if_descr.bDescriptorType,
2021 if_descr.bInterfaceNumber,
2022 if_descr.bAlternateSetting,
2023 if_descr.bNumEndpoints,
2024 if_descr.bInterfaceClass,
2025 if_descr.bInterfaceSubClass,
2026 if_descr.bInterfaceProtocol,
2027 if_descr.iInterface);
2028
2029 (void) memcpy(
2030 &hdl->device->config[index].interface[iface].altsetting[alt],
2031 &if_descr, sizeof (if_descr));
2032
2033 if (extralen) {
2034 usb_dprintf(DEBUG_DETAILED,
2035 "cfg%d.if%d.%d: extralen=%d:\n", index, iface, alt,
2036 extralen);
2037 usb_dump_data((char *)extra, extralen);
2038
2039 if ((hdl->device->config[index].interface[iface].
2040 altsetting[alt].extra = calloc(extralen, 1)) == NULL) {
2041
2042 return (ENOMEM);
2043 }
2044 (void) memcpy(
2045 hdl->device->config[index].interface[iface].
2046 altsetting[alt].extra, extra, extralen);
2047 hdl->device->config[index].interface[iface].
2048 altsetting[alt].extralen = extralen;
2049 }
2050
2051 if (if_descr.bNumEndpoints == 0) {
2052
2053 return (0);
2054 }
2055
2056 /* allocate endpoint array for this alternate */
2057 len = if_descr.bNumEndpoints *
2058 (int)sizeof (struct usb_endpoint_descriptor);
2059 if ((hdl->device->config[index].interface[iface].altsetting[alt].
2060 endpoint = calloc(len, 1)) == NULL) {
2061
2062 return (ENOMEM);
2063 }
2064
2065 for (ep = 0; ep < if_descr.bNumEndpoints; ep++) {
2066 rval = usb_parse_endpoint(hdl, index, iface, alt, ep, cloud);
2067
2068 if (rval != 0) {
2069
2070 return (rval);
2071 }
2072 }
2073
2074 return (0);
2075 }
2076
2077 /*
2078 * usb_free_alternate:
2079 * frees all alternate resources
2080 */
2081 static void
2082 usb_free_alternate(usb_device_t *device, uint_t index, uint_t iface,
2083 uint_t alt)
2084 {
2085 usb_dprintf(DEBUG_FUNCTIONS, "usb_free_alternate(): "
2086 "index=%d, iface=%d, alt=%d\n", index, iface, alt);
2087
2088 if (device->config[index].interface[iface].altsetting[alt].
2089 endpoint) {
2090 uint_t ep;
2091 struct usb_interface_descriptor *if_descr =
2092 &device->config[index].
2093 interface[iface].altsetting[alt];
2094
2095 for (ep = 0; ep < if_descr->bNumEndpoints; ep++) {
2096 if (if_descr->extralen) {
2097 free(if_descr->extra);
2098 }
2099 }
2100
2101 if (device->config[index].interface[iface].altsetting[alt].
2102 extralen) {
2103 free(device->config[index].interface[iface].
2104 altsetting[alt].extra);
2105 }
2106 free(device->config[index].interface[iface].altsetting[alt].
2107 endpoint);
2108 }
2109 }
2110
2111 /*
2112 * usb_parse_endpoint:
2113 * parses an endpoint descriptor
2114 *
2115 * Returns: errno
2116 */
2117 static int
2118 usb_parse_endpoint(usb_dev_handle_impl_t *hdl, int index, int iface,
2119 int alt, int ep, char *cloud)
2120 {
2121 usb_ep_descr_t ep_descr;
2122 int rval;
2123 unsigned char *extra;
2124 int extralen;
2125
2126 usb_dprintf(DEBUG_FUNCTIONS, "usb_parse_endpoint(): "
2127 "index=%d, iface=%d, alt=%d, ep=0x%x\n",
2128 index, iface, alt, ep);
2129
2130 rval = (int)usb_parse_ep_descr((uchar_t *)cloud,
2131 hdl->device->config[index].wTotalLength,
2132 iface, alt, ep, &ep_descr, sizeof (ep_descr),
2133 &extra, &extralen);
2134
2135 if (rval < USB_EP_DESCR_SIZE) {
2136 usb_dprintf(DEBUG_ERRORS, "usb_parse_endpoint: rval=%d, "
2137 "expecting %d\n", rval, USB_EP_DESCR_SIZE);
2138
2139 return (rval);
2140 }
2141
2142 usb_dprintf(DEBUG_DETAILED,
2143 "\tl=%d t=%d a=0x%x attr=0x%x max=%d int=%d\n",
2144 ep_descr.bLength, ep_descr.bDescriptorType,
2145 ep_descr.bEndpointAddress, ep_descr.bmAttributes,
2146 ep_descr.wMaxPacketSize, ep_descr.bInterval);
2147
2148 (void) memcpy(&hdl->device->
2149 config[index].interface[iface].altsetting[alt].endpoint[ep],
2150 &ep_descr, sizeof (ep_descr));
2151
2152 if (extralen) {
2153 usb_dprintf(DEBUG_DETAILED,
2154 "cfg%d.if%d.%d.ep%d: extralen=%d:\n",
2155 index, iface, alt, ep, extralen);
2156 usb_dump_data((char *)extra, extralen);
2157
2158 if ((hdl->device->config[index].interface[iface].
2159 altsetting[alt].endpoint[ep].extra =
2160 calloc(extralen, 1)) == NULL) {
2161
2162 return (ENOMEM);
2163 }
2164 (void) memcpy(hdl->device->config[index].interface[iface].
2165 altsetting[alt].endpoint[ep].extra, extra, extralen);
2166 hdl->device->config[index].interface[iface].
2167 altsetting[alt].endpoint[ep].extralen = extralen;
2168 }
2169
2170 return (0);
2171 }
2172
2173 /*
2174 * usb_add_device:
2175 * adds dev to the beginning of the list
2176 */
2177 static void
2178 usb_add_device(usb_device_t **list, usb_device_t *dev)
2179 {
2180 if (*list) {
2181 dev->next = *list;
2182 dev->next->prev = dev;
2183 } else {
2184 dev->next = NULL;
2185 }
2186 dev->prev = NULL;
2187 *list = dev;
2188 }
2189
2190 /*
2191 * usb_remove_device:
2192 * removes dev from a list
2193 */
2194 static void
2195 usb_remove_device(usb_device_t **list, usb_device_t *dev)
2196 {
2197 if (dev->prev) {
2198 dev->prev->next = dev->next;
2199 } else {
2200 *list = dev->next;
2201 }
2202 if (dev->next) {
2203 dev->next->prev = dev->prev;
2204 }
2205 dev->prev = dev->next = NULL;
2206 }
2207
2208 /*
2209 * usb_check_device_in_list:
2210 * checks if dev is in list
2211 *
2212 * Returns: 1 (yes), 0 (no)
2213 */
2214 static int
2215 usb_check_device_in_list(usb_device_t *list, usb_device_t *dev)
2216 {
2217 usb_device_t *d = list;
2218
2219 while (d != NULL) {
2220 if (d == dev) {
2221
2222 return (1);
2223 }
2224 d = d->next;
2225 }
2226
2227 return (0);
2228 }
2229
2230 /*
2231 * usb_free_bus:
2232 * frees the entire bus structure, not used, just for
2233 * completeness
2234 */
2235 static void
2236 usb_free_bus(usb_bus_t *bus)
2237 {
2238 free(bus);
2239 }
2240
2241 /*
2242 * usb_free_dev:
2243 * frees all configs and then the device structure itself
2244 */
2245 static void
2246 usb_free_dev(usb_device_t *dev)
2247 {
2248 usb_dprintf(DEBUG_FUNCTIONS, "usb_free_dev(): 0x%x\n", (int)dev);
2249
2250 usb_free_all_configs(dev);
2251 free(dev->dev);
2252 free(dev);
2253 }
2254
2255 /*
2256 * usb_get_device_status:
2257 * gets status of device
2258 *
2259 * Returns: ugen dev status values
2260 */
2261 static int
2262 usb_get_device_status(int fd)
2263 {
2264 int status, error;
2265
2266 usb_dprintf(DEBUG_FUNCTIONS, "usb_get_device_status():\n");
2267
2268 error = (int)read(fd, &status, (size_t)sizeof (status));
2269 if (error != (int)sizeof (status)) {
2270 usb_error_str(errno, "Could not read device status: %d",
2271 error);
2272
2273 return (USB_DEV_STAT_UNAVAILABLE);
2274 } else {
2275 switch (status) {
2276 case USB_DEV_STAT_ONLINE:
2277 usb_dprintf(DEBUG_DETAILED, "Device is available\n");
2278 break;
2279 case USB_DEV_STAT_DISCONNECTED:
2280 usb_dprintf(DEBUG_DETAILED, "Device has been "
2281 "disconnected\n");
2282 break;
2283 case USB_DEV_STAT_RESUMED:
2284 usb_dprintf(DEBUG_DETAILED,
2285 "Device has been resumed\n");
2286 break;
2287 case USB_DEV_STAT_UNAVAILABLE:
2288 usb_dprintf(DEBUG_DETAILED,
2289 "Device is powered down\n");
2290 break;
2291 default:
2292 usb_dprintf(DEBUG_DETAILED,
2293 "Device status=%d\n", status);
2294 }
2295 }
2296
2297 return (status);
2298 }
2299
2300 /*
2301 * usb_search_dev_usb:
2302 * finds all names of devices in the /usb/dev tree
2303 * this will be the VID/PID and instance no
2304 *
2305 * Returns: errno
2306 */
2307 static int
2308 usb_search_dev_usb(usb_device_t **new_devices)
2309 {
2310 DIR *dir, *subdir;
2311 struct dirent *dir_entry, *subdir_entry;
2312 char *device, *filename;
2313 usb_bus_t *bus = usb_busses;
2314 struct stat statbuf;
2315 regex_t regex;
2316
2317 usb_dprintf(DEBUG_FUNCTIONS, "usb_search_dev_usb():\n");
2318
2319 if ((device = malloc(PATH_MAX+1)) == NULL) {
2320
2321 return (ENOMEM);
2322 }
2323
2324 if ((filename = malloc(PATH_MAX+1)) == NULL) {
2325 free(device);
2326
2327 return (ENOMEM);
2328 }
2329
2330 if (!(dir = opendir(bus->dirname))) {
2331 free(device);
2332 free(filename);
2333
2334 usb_error_str(errno,
2335 "couldn't opendir %s: %d", bus->dirname, errno);
2336
2337 return (errno);
2338 }
2339
2340 /* make sure we only open ugen directories */
2341 if ((regcomp(&regex, "/dev/usb/[0-9a-f]+[.][0-9a-f]+",
2342 REG_EXTENDED) != 0)) {
2343
2344 return (EINVAL);
2345 }
2346
2347 /* search for devices */
2348 while ((dir_entry = readdir(dir)) != NULL) {
2349
2350 usb_dprintf(DEBUG_FUNCTIONS, "usb_search_dev_usb(): dir=%s\n",
2351 dir_entry->d_name);
2352
2353 if (dir_entry->d_name[0] == '.') {
2354 continue;
2355 }
2356 (void) snprintf(device, PATH_MAX, "%s/%s", bus->dirname,
2357 dir_entry->d_name);
2358
2359 /*
2360 * make sure we don't accidentily open /dev/usb/hid* nodes
2361 * which will get them unlinked from the virtual console
2362 */
2363 if (lstat(device, &statbuf) == -1) {
2364 continue;
2365 }
2366 if (!S_ISDIR(statbuf.st_mode)) {
2367 continue;
2368 }
2369
2370 if (regexec(&regex, device, 0, NULL, 0) != 0) {
2371 continue;
2372 }
2373
2374 usb_dprintf(DEBUG_FUNCTIONS, "checking %s\n", device);
2375
2376 /* need to search instances */
2377 if (!(subdir = opendir(device))) {
2378 continue;
2379 }
2380
2381 while ((subdir_entry = readdir(subdir)) != NULL) {
2382 usb_device_t *dev;
2383 usb_device_specific_t *dev_specific;
2384 int fd;
2385
2386 if (subdir_entry->d_name[0] == '.') {
2387 continue;
2388 }
2389
2390 if ((dev = calloc(sizeof (*dev), 1)) == NULL) {
2391 free(device);
2392 free(filename);
2393 regfree(&regex);
2394 (void) closedir(subdir);
2395 (void) closedir(dir);
2396
2397 return (ENOMEM);
2398 }
2399 if ((dev_specific = calloc(sizeof (*dev_specific),
2400 1)) == NULL) {
2401 free(device);
2402 free(filename);
2403 free(dev);
2404 regfree(&regex);
2405 (void) closedir(subdir);
2406 (void) closedir(dir);
2407
2408 return (ENOMEM);
2409 }
2410
2411 dev->dev = (void *)dev_specific;
2412 dev->bus = bus;
2413 (void) snprintf(dev->filename, PATH_MAX, "%s/%s",
2414 dir_entry->d_name, subdir_entry->d_name);
2415
2416 /* See if the device is online */
2417 (void) snprintf(filename, PATH_MAX, "%s/%s/devstat",
2418 bus->dirname, dev->filename);
2419
2420 usb_dprintf(DEBUG_DETAILED, "filename %s\n", filename);
2421 usb_dprintf(DEBUG_DETAILED, "dev filename %s\n",
2422 dev->filename);
2423
2424 if ((fd = open(filename, O_RDONLY|O_EXCL)) < 0) {
2425 usb_dprintf(DEBUG_ERRORS,
2426 "usb_search_dev_usb: Couldn't open %s\n",
2427 filename);
2428 free(dev_specific);
2429 free(dev);
2430 continue;
2431 }
2432 if (usb_get_device_status(fd) != USB_DEV_STAT_ONLINE) {
2433 (void) close(fd);
2434 usb_error_str(EIO, "Device %s is not online",
2435 dev->filename);
2436
2437 free(dev_specific);
2438 free(dev);
2439 continue;
2440 }
2441 (void) close(fd);
2442
2443 usb_add_device(new_devices, dev);
2444 }
2445
2446 (void) closedir(subdir);
2447 }
2448
2449 regfree(&regex);
2450 free(filename);
2451 free(device);
2452 (void) closedir(dir);
2453
2454 return (0);
2455 }
2456
2457 /*
2458 * usb_get_status:
2459 * gets status of endpoint
2460 *
2461 * Returns: ugen's last cmd status
2462 */
2463 static int
2464 usb_get_status(int fd)
2465 {
2466 int status, error;
2467
2468 usb_dprintf(DEBUG_FUNCTIONS, "usb_get_status(): fd=%d\n", fd);
2469
2470 error = (int)read(fd, &status, sizeof (status));
2471 if (error == (int)sizeof (status)) {
2472 switch (status) {
2473 case USB_LC_STAT_NOERROR:
2474 usb_dprintf(DEBUG_DETAILED, "No Error\n");
2475 break;
2476 case USB_LC_STAT_CRC:
2477 usb_dprintf(DEBUG_ERRORS, "CRC Timeout Detected\n");
2478 break;
2479 case USB_LC_STAT_BITSTUFFING:
2480 usb_dprintf(DEBUG_ERRORS, "Bit Stuffing Violation\n");
2481 break;
2482 case USB_LC_STAT_DATA_TOGGLE_MM:
2483 usb_dprintf(DEBUG_ERRORS, "Data Toggle Mismatch\n");
2484 break;
2485 case USB_LC_STAT_STALL:
2486 usb_dprintf(DEBUG_ERRORS, "End Point Stalled\n");
2487 break;
2488 case USB_LC_STAT_DEV_NOT_RESP:
2489 usb_dprintf(DEBUG_ERRORS, "Device is Not Responding\n");
2490 break;
2491 case USB_LC_STAT_PID_CHECKFAILURE:
2492 usb_dprintf(DEBUG_ERRORS, "PID Check Failure\n");
2493 break;
2494 case USB_LC_STAT_UNEXP_PID:
2495 usb_dprintf(DEBUG_ERRORS, "Unexpected PID\n");
2496 break;
2497 case USB_LC_STAT_DATA_OVERRUN:
2498 usb_dprintf(DEBUG_ERRORS, "Data Exceeded Size\n");
2499 break;
2500 case USB_LC_STAT_DATA_UNDERRUN:
2501 usb_dprintf(DEBUG_ERRORS, "Less data received\n");
2502 break;
2503 case USB_LC_STAT_BUFFER_OVERRUN:
2504 usb_dprintf(DEBUG_ERRORS, "Buffer Size Exceeded\n");
2505 break;
2506 case USB_LC_STAT_BUFFER_UNDERRUN:
2507 usb_dprintf(DEBUG_ERRORS, "Buffer Underrun\n");
2508 break;
2509 case USB_LC_STAT_TIMEOUT:
2510 usb_dprintf(DEBUG_ERRORS, "Command Timed Out\n");
2511 break;
2512 case USB_LC_STAT_NOT_ACCESSED:
2513 usb_dprintf(DEBUG_ERRORS, "Not Accessed by h/w\n");
2514 break;
2515 case USB_LC_STAT_UNSPECIFIED_ERR:
2516 usb_dprintf(DEBUG_ERRORS, "Unspecified Error\n");
2517 break;
2518 case USB_LC_STAT_NO_BANDWIDTH:
2519 usb_dprintf(DEBUG_ERRORS, "No Bandwidth\n");
2520 break;
2521 case USB_LC_STAT_HW_ERR:
2522 usb_dprintf(DEBUG_ERRORS,
2523 "Host Controller h/w Error\n");
2524 break;
2525 case USB_LC_STAT_SUSPENDED:
2526 usb_dprintf(DEBUG_ERRORS, "Device was Suspended\n");
2527 break;
2528 case USB_LC_STAT_DISCONNECTED:
2529 usb_dprintf(DEBUG_ERRORS, "Device was Disconnected\n");
2530 break;
2531 case USB_LC_STAT_INTR_BUF_FULL:
2532 usb_dprintf(DEBUG_ERRORS,
2533 "Interrupt buffer was full\n");
2534 break;
2535 case USB_LC_STAT_INVALID_REQ:
2536 usb_dprintf(DEBUG_ERRORS, "Request was Invalid\n");
2537 break;
2538 case USB_LC_STAT_INTERRUPTED:
2539 usb_dprintf(DEBUG_ERRORS, "Request was Interrupted\n");
2540 break;
2541 case USB_LC_STAT_NO_RESOURCES:
2542 usb_dprintf(DEBUG_ERRORS, "No resources available for "
2543 "request\n");
2544 break;
2545 case USB_LC_STAT_INTR_POLLING_FAILED:
2546 usb_dprintf(DEBUG_ERRORS, "Failed to Restart Poll");
2547 break;
2548 default:
2549 usb_dprintf(DEBUG_ERRORS, "Error Not Determined %d\n",
2550 status);
2551 break;
2552 }
2553 }
2554
2555 return (status);
2556 }
2557
2558 /*
2559 * Descriptor parsing functions, taken from USBA code
2560 *
2561 * usb_parse_data:
2562 * take a raw buffer and pads it according to format
2563 *
2564 * Returns: USB_PARSE_ERROR or length parsed
2565 */
2566 static size_t
2567 usb_parse_data(char *format, uchar_t *data, size_t datalen,
2568 void *structure, size_t structlen)
2569 {
2570 int fmt;
2571 size_t counter = 1;
2572 int multiplier = 0;
2573 uchar_t *dataend = data + datalen;
2574 char *structstart = (char *)structure;
2575 void *structend = (void *)((intptr_t)structstart + structlen);
2576
2577 if ((format == NULL) || (data == NULL) || (structure == NULL)) {
2578
2579 return (USB_PARSE_ERROR);
2580 }
2581
2582 while ((fmt = *format) != '\0') {
2583
2584 /*
2585 * Could some one pass a "format" that is greater than
2586 * the structlen? Conversely, one could pass a ret_buf_len
2587 * that is less than the "format" length.
2588 * If so, we need to protect against writing over memory.
2589 */
2590 if (counter++ > structlen) {
2591 break;
2592 }
2593
2594 if (fmt == 'c') {
2595 uint8_t *cp = (uint8_t *)structure;
2596
2597 cp = (uint8_t *)(((uintptr_t)cp + _CHAR_ALIGNMENT - 1) &
2598 ~(_CHAR_ALIGNMENT - 1));
2599 if (((data + 1) > dataend) ||
2600 ((cp + 1) > (uint8_t *)structend))
2601 break;
2602
2603 *cp++ = *data++;
2604 structure = (void *)cp;
2605 if (multiplier) {
2606 multiplier--;
2607 }
2608 if (multiplier == 0) {
2609 format++;
2610 }
2611 } else if (fmt == 's') {
2612 uint16_t *sp = (uint16_t *)structure;
2613
2614 sp = (uint16_t *)
2615 (((uintptr_t)sp + _SHORT_ALIGNMENT - 1) &
2616 ~(_SHORT_ALIGNMENT - 1));
2617 if (((data + 2) > dataend) ||
2618 ((sp + 1) > (uint16_t *)structend))
2619 break;
2620
2621 *sp++ = (data[1] << 8) + data[0];
2622 data += 2;
2623 structure = (void *)sp;
2624 if (multiplier) {
2625 multiplier--;
2626 }
2627 if (multiplier == 0) {
2628 format++;
2629 }
2630 } else if (fmt == 'l') {
2631 uint32_t *lp = (uint32_t *)structure;
2632
2633 lp = (uint32_t *)
2634 (((uintptr_t)lp + _INT_ALIGNMENT - 1) &
2635 ~(_INT_ALIGNMENT - 1));
2636 if (((data + 4) > dataend) ||
2637 ((lp + 1) > (uint32_t *)structend))
2638 break;
2639
2640 *lp++ = (((((
2641 (uint32_t)data[3] << 8) | data[2]) << 8) |
2642 data[1]) << 8) | data[0];
2643 data += 4;
2644 structure = (void *)lp;
2645 if (multiplier) {
2646 multiplier--;
2647 }
2648 if (multiplier == 0) {
2649 format++;
2650 }
2651 } else if (fmt == 'L') {
2652 uint64_t *llp = (uint64_t *)structure;
2653
2654 llp = (uint64_t *)
2655 (((uintptr_t)llp + _LONG_LONG_ALIGNMENT - 1) &
2656 ~(_LONG_LONG_ALIGNMENT - 1));
2657 if (((data + 8) > dataend) ||
2658 ((llp + 1) >= (uint64_t *)structend))
2659 break;
2660
2661 *llp++ = (((((((((((((data[7] << 8) |
2662 data[6]) << 8) | data[5]) << 8) |
2663 data[4]) << 8) | data[3]) << 8) |
2664 data[2]) << 8) | data[1]) << 8) |
2665 data[0];
2666 data += 8;
2667 structure = (void *)llp;
2668 if (multiplier) {
2669 multiplier--;
2670 }
2671 if (multiplier == 0) {
2672 format++;
2673 }
2674 } else if (isdigit(fmt)) {
2675 multiplier = (multiplier * 10) + (fmt - '0');
2676 counter--;
2677 format++;
2678 } else {
2679 multiplier = 0;
2680 break;
2681 }
2682 }
2683
2684 return ((intptr_t)structure - (intptr_t)structstart);
2685 }
2686
2687 /*
2688 * usb_nth_descr:
2689 * finds pointer to n-th descriptor of
2690 * type descr_type, unless the end of the buffer or a descriptor
2691 * of type stop_descr_type1 or stop_descr_type2 is encountered first.
2692 *
2693 * Returns: returns pointer to n-th descriptor
2694 */
2695 static uchar_t *
2696 usb_nth_descr(uchar_t *buf, size_t buflen, int descr_type, uint_t n,
2697 int stop_descr_type1, int stop_descr_type2)
2698 {
2699 uchar_t *bufstart = buf;
2700 uchar_t *bufend = buf + buflen;
2701
2702 if (buf == NULL) {
2703
2704 return (NULL);
2705 }
2706
2707 while (buf + 2 <= bufend) {
2708 if ((buf != bufstart) && ((buf[1] == stop_descr_type1) ||
2709 (buf[1] == stop_descr_type2))) {
2710
2711 return (NULL);
2712 }
2713
2714 if ((descr_type == USB_DESCR_TYPE_ANY) ||
2715 (buf[1] == descr_type)) {
2716 if (n-- == 0) {
2717
2718 return (buf);
2719 }
2720 }
2721
2722 /*
2723 * Check for a bad buffer.
2724 * If buf[0] is 0, then this will be an infite loop
2725 */
2726 INCREMENT_BUF(buf);
2727 }
2728
2729 return (NULL);
2730 }
2731
2732 /*
2733 * usb_parse_dev_descr:
2734 * parse device descriptor
2735 *
2736 * Returns: #bytes parsed
2737 */
2738 static size_t
2739 usb_parse_dev_descr(uchar_t *buf, size_t buflen,
2740 struct usb_device_descriptor *ret_descr, size_t ret_buf_len)
2741 {
2742 if ((buf == NULL) || (ret_descr == NULL) ||
2743 (buflen < 2) || (buf[1] != USB_DESCR_TYPE_DEV)) {
2744
2745 return (USB_PARSE_ERROR);
2746 }
2747
2748 return (usb_parse_data("ccsccccssscccc",
2749 buf, buflen, ret_descr, ret_buf_len));
2750 }
2751
2752 /*
2753 * usb_parse_cfg_descr:
2754 * parse config descriptor
2755 *
2756 * Returns: #bytes parsed
2757 */
2758 static size_t
2759 usb_parse_cfg_descr(uchar_t *buf, size_t buflen, usb_cfg_descr_t *ret_descr,
2760 size_t ret_buf_len, unsigned char **extra, int *extralen)
2761 {
2762 size_t rval;
2763
2764 if ((buf == NULL) || (ret_descr == NULL) ||
2765 (buflen < 2) || (buf[1] != USB_DESCR_TYPE_CFG)) {
2766
2767 return (USB_PARSE_ERROR);
2768 }
2769
2770 rval = usb_parse_data("ccsccccc",
2771 buf, buflen, ret_descr, ret_buf_len);
2772
2773 usb_find_extra(buf, buflen, extra, extralen);
2774
2775 return (rval);
2776 }
2777
2778 /*
2779 * usb_parse_if_descr:
2780 * parse interface descriptor
2781 *
2782 * Returns: #bytes parsed
2783 */
2784 static size_t
2785 usb_parse_if_descr(uchar_t *buf, size_t buflen, uint_t if_number,
2786 uint_t alt_if_setting, usb_if_descr_t *ret_descr, size_t ret_buf_len,
2787 unsigned char **extra, int *extralen)
2788 {
2789 uchar_t *bufend = buf + buflen;
2790 size_t rval;
2791
2792 if ((buf == NULL) || (ret_descr == NULL)) {
2793
2794 return (USB_PARSE_ERROR);
2795 }
2796
2797 while (buf + 4 <= bufend) {
2798 if ((buf[1] == USB_DESCR_TYPE_IF) &&
2799 (buf[2] == if_number) &&
2800 (buf[3] == alt_if_setting)) {
2801
2802 rval = usb_parse_data("ccccccccc",
2803 buf, ((uintptr_t)bufend - (uintptr_t)buf),
2804 ret_descr, ret_buf_len);
2805
2806 usb_find_extra(buf,
2807 ((uintptr_t)bufend - (uintptr_t)buf),
2808 extra, extralen);
2809
2810 return (rval);
2811 }
2812
2813 /*
2814 * Check for a bad buffer.
2815 * If buf[0] is 0, then this will be an infinite loop
2816 */
2817 INCREMENT_BUF(buf);
2818 }
2819
2820 return (USB_PARSE_ERROR);
2821 }
2822
2823
2824 /*
2825 * usb_parse_ep_descr:
2826 * parse config descriptor
2827 * the endpoint index is relative to the interface. index 0 is
2828 * the first endpoint
2829 *
2830 * Returns: #bytes parsed
2831 */
2832 size_t
2833 usb_parse_ep_descr(uchar_t *buf, size_t buflen, uint_t if_number,
2834 uint_t alt_if_setting, uint_t ep_index, usb_ep_descr_t *ret_descr,
2835 size_t ret_buf_len, unsigned char **extra, int *extralen)
2836 {
2837 uchar_t *bufend = buf + buflen;
2838 size_t rval;
2839
2840 if ((buf == NULL) || (ret_descr == NULL)) {
2841
2842 return (USB_PARSE_ERROR);
2843 }
2844
2845 while ((buf + 4) <= bufend) {
2846 if (buf[1] == USB_DESCR_TYPE_IF &&
2847 buf[2] == if_number &&
2848 buf[3] == alt_if_setting) {
2849 if ((buf = usb_nth_descr(buf,
2850 (uintptr_t)bufend - (uintptr_t)buf,
2851 USB_DESCR_TYPE_EP, ep_index,
2852 USB_DESCR_TYPE_IF, -1)) == NULL) {
2853
2854 break;
2855 }
2856
2857 rval = usb_parse_data("ccccsccc", buf,
2858 (uintptr_t)bufend - (uintptr_t)buf,
2859 ret_descr, ret_buf_len);
2860 usb_find_extra(buf, (uintptr_t)bufend - (uintptr_t)buf,
2861 extra, extralen);
2862
2863 return (rval);
2864 }
2865
2866 /*
2867 * Check for a bad buffer.
2868 * If buf[0] is 0, then this will be an infinite loop
2869 */
2870 INCREMENT_BUF(buf);
2871 }
2872
2873 return (USB_PARSE_ERROR);
2874 }
2875
2876 /*
2877 * extra descriptor handling
2878 *
2879 * usb_find_extra:
2880 * finds any non-standard descriptor after the current
2881 * standard descriptor and puts a pointer in extra argument
2882 * and the length in extralen
2883 */
2884 static void
2885 usb_find_extra(uchar_t *buf, size_t buflen,
2886 unsigned char **extra, int *extralen)
2887 {
2888 uchar_t *next = buf + buf[0];
2889
2890 *extralen = 0;
2891 *extra = next;
2892
2893 while (((uintptr_t)next - (uintptr_t)buf + 1) < buflen) {
2894 if ((next[1] == USB_DT_CONFIG) ||
2895 (next[1] == USB_DT_INTERFACE) ||
2896 (next[1] == USB_DT_ENDPOINT)) {
2897 *extralen = (int)((uintptr_t)next -
2898 (uintptr_t)buf - buf[0]);
2899
2900 return;
2901 }
2902 next += next[0];
2903 }
2904 }
2905
2906 /*
2907 * error handling
2908 *
2909 * usb_strerror:
2910 * lookup error string
2911 *
2912 * Returns: error string
2913 */
2914 char *
2915 usb_strerror(void)
2916 {
2917 usb_dprintf(DEBUG_FUNCTIONS, "usb_strerror(): "
2918 "usb_error_type=%d, errno=%d\n", usb_error_type, usb_error_errno);
2919
2920 switch (usb_error_type) {
2921 case USB_ERROR_TYPE_NONE:
2922 return ("No error");
2923
2924 case USB_ERROR_TYPE_STRING:
2925 return (usb_error_string);
2926
2927 case USB_ERROR_TYPE_ERRNO:
2928 if (usb_error_errno > 0) {
2929
2930 return (strerror(usb_error_errno));
2931 }
2932 default:
2933 break;
2934 }
2935
2936 return ("Unknown error");
2937 }
2938
2939 /*
2940 * usb_error:
2941 * stores the error number in the global usb_error_errno
2942 *
2943 * Returns: negative error number
2944 */
2945 static int
2946 usb_error(int x)
2947 {
2948 usb_dprintf(DEBUG_FUNCTIONS, "usb_error(): error=%d\n", x);
2949
2950 usb_error_type = USB_ERROR_TYPE_ERRNO;
2951 usb_error_errno = x;
2952
2953 return (-x);
2954 }
2955
2956 /*
2957 * usb_error_str:
2958 * creates error string
2959 */
2960 static void
2961 usb_error_str(int x, char *format, ...)
2962 {
2963 va_list ap;
2964
2965 va_start(ap, format);
2966
2967 usb_error_type = USB_ERROR_TYPE_ERRNO;
2968 usb_error_errno = x;
2969
2970 (void) vsnprintf(usb_error_string, sizeof (usb_error_string),
2971 format, ap);
2972
2973 usb_dprintf(DEBUG_ERRORS, "USB error (%d): %s\n", x, usb_error_string);
2974
2975 va_end(ap);
2976 }
2977
2978 /*
2979 * usb_dprintf:
2980 * prints out tracing messages according to level
2981 */
2982 static void
2983 usb_dprintf(int level, char *format, ...)
2984 {
2985 va_list ap;
2986 char buf[512];
2987
2988 va_start(ap, format);
2989
2990 (void) vsnprintf(buf, sizeof (buf), format, ap);
2991 if (libusb_debug >= level) {
2992 (void) fprintf(stderr, buf);
2993 }
2994 va_end(ap);
2995 }
2996
2997 /*
2998 * usb_dump_data:
2999 * print data buffer
3000 */
3001 static void
3002 usb_dump_data(char *data, int size)
3003 {
3004 int i;
3005
3006 if (libusb_debug >= DEBUG_DATA_DUMP) {
3007 (void) fprintf(stderr, "data dump:");
3008 for (i = 0; i < size; i++) {
3009 if (i % 16 == 0) {
3010 (void) fprintf(stderr, "\n%08x ", i);
3011 }
3012 (void) fprintf(stderr, "%02x ", (uchar_t)data[i]);
3013 }
3014 (void) fprintf(stderr, "\n");
3015 }
3016 }