Annotation of sys/dev/usb/umct.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: umct.c,v 1.26 2007/06/14 10:11:16 mbalmer Exp $ */
2: /* $NetBSD: umct.c,v 1.10 2003/02/23 04:20:07 simonb Exp $ */
3: /*
4: * Copyright (c) 2001 The NetBSD Foundation, Inc.
5: * All rights reserved.
6: *
7: * This code is derived from software contributed to The NetBSD Foundation
8: * by Ichiro FUKUHARA (ichiro@ichiro.org).
9: *
10: * Redistribution and use in source and binary forms, with or without
11: * modification, are permitted provided that the following conditions
12: * are met:
13: * 1. Redistributions of source code must retain the above copyright
14: * notice, this list of conditions and the following disclaimer.
15: * 2. Redistributions in binary form must reproduce the above copyright
16: * notice, this list of conditions and the following disclaimer in the
17: * documentation and/or other materials provided with the distribution.
18: * 3. All advertising materials mentioning features or use of this software
19: * must display the following acknowledgement:
20: * This product includes software developed by the NetBSD
21: * Foundation, Inc. and its contributors.
22: * 4. Neither the name of The NetBSD Foundation nor the names of its
23: * contributors may be used to endorse or promote products derived
24: * from this software without specific prior written permission.
25: *
26: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
27: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
28: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
30: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
31: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
32: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
33: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
34: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
35: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36: * POSSIBILITY OF SUCH DAMAGE.
37: */
38:
39: /*
40: * MCT USB-RS232 Interface Controller
41: * http://www.mct.com.tw/prod/rs232.html
42: * http://www.dlink.com/products/usb/dsbs25
43: */
44:
45: #include <sys/param.h>
46: #include <sys/systm.h>
47: #include <sys/kernel.h>
48: #include <sys/malloc.h>
49: #include <sys/ioctl.h>
50: #include <sys/conf.h>
51: #include <sys/tty.h>
52: #include <sys/file.h>
53: #include <sys/selinfo.h>
54: #include <sys/proc.h>
55: #include <sys/vnode.h>
56: #include <sys/device.h>
57: #include <sys/poll.h>
58:
59: #include <dev/usb/usb.h>
60: #include <dev/usb/usbcdc.h>
61:
62: #include <dev/usb/usbdi.h>
63: #include <dev/usb/usbdi_util.h>
64: #include <dev/usb/usbdevs.h>
65: #include <dev/usb/usb_quirks.h>
66:
67: #include <dev/usb/usbdevs.h>
68: #include <dev/usb/ucomvar.h>
69:
70: #include <dev/usb/umct.h>
71:
72: #ifdef UMCT_DEBUG
73: #define DPRINTFN(n, x) do { if (umctdebug > (n)) printf x; } while (0)
74: int umctdebug = 0;
75: #else
76: #define DPRINTFN(n, x)
77: #endif
78: #define DPRINTF(x) DPRINTFN(0, x)
79:
80: #define UMCT_CONFIG_INDEX 0
81: #define UMCT_IFACE_INDEX 0
82:
83: struct umct_softc {
84: struct device sc_dev; /* base device */
85: usbd_device_handle sc_udev; /* USB device */
86: usbd_interface_handle sc_iface; /* interface */
87: int sc_iface_number; /* interface number */
88: u_int16_t sc_product;
89:
90: int sc_intr_number; /* interrupt number */
91: usbd_pipe_handle sc_intr_pipe; /* interrupt pipe */
92: u_char *sc_intr_buf; /* interrupt buffer */
93: int sc_isize;
94:
95: usb_cdc_line_state_t sc_line_state; /* current line state */
96: u_char sc_dtr; /* current DTR state */
97: u_char sc_rts; /* current RTS state */
98: u_char sc_break; /* set break */
99:
100: u_char sc_status;
101:
102: struct device *sc_subdev; /* ucom device */
103:
104: u_char sc_dying; /* disconnecting */
105:
106: u_char sc_lsr; /* Local status register */
107: u_char sc_msr; /* umct status register */
108:
109: u_int last_lcr; /* keep lcr register */
110: };
111:
112: /*
113: * These are the maximum number of bytes transferred per frame.
114: * The output buffer size cannot be increased due to the size encoding.
115: */
116: #define UMCTIBUFSIZE 256
117: #define UMCTOBUFSIZE 256
118:
119: void umct_init(struct umct_softc *);
120: void umct_set_baudrate(struct umct_softc *, u_int);
121: void umct_set_lcr(struct umct_softc *, u_int);
122: void umct_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
123:
124: void umct_set(void *, int, int, int);
125: void umct_dtr(struct umct_softc *, int);
126: void umct_rts(struct umct_softc *, int);
127: void umct_break(struct umct_softc *, int);
128: void umct_set_line_state(struct umct_softc *);
129: void umct_get_status(void *, int portno, u_char *lsr, u_char *msr);
130: int umct_param(void *, int, struct termios *);
131: int umct_open(void *, int);
132: void umct_close(void *, int);
133:
134: struct ucom_methods umct_methods = {
135: umct_get_status,
136: umct_set,
137: umct_param,
138: NULL,
139: umct_open,
140: umct_close,
141: NULL,
142: NULL,
143: };
144:
145: static const struct usb_devno umct_devs[] = {
146: /* MCT USB-232 Interface Products */
147: { USB_VENDOR_MCT, USB_PRODUCT_MCT_USB232 },
148: /* Sitecom USB-232 Products */
149: { USB_VENDOR_MCT, USB_PRODUCT_MCT_SITECOM_USB232 },
150: /* D-Link DU-H3SP USB BAY Hub Products */
151: { USB_VENDOR_MCT, USB_PRODUCT_MCT_DU_H3SP_USB232 },
152: /* BELKIN F5U109 */
153: { USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5U109 },
154: /* BELKIN F5U409 */
155: { USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5U409 },
156: };
157: #define umct_lookup(v, p) usb_lookup(umct_devs, v, p)
158:
159: int umct_match(struct device *, void *, void *);
160: void umct_attach(struct device *, struct device *, void *);
161: int umct_detach(struct device *, int);
162: int umct_activate(struct device *, enum devact);
163:
164: struct cfdriver umct_cd = {
165: NULL, "umct", DV_DULL
166: };
167:
168: const struct cfattach umct_ca = {
169: sizeof(struct umct_softc),
170: umct_match,
171: umct_attach,
172: umct_detach,
173: umct_activate,
174: };
175:
176: int
177: umct_match(struct device *parent, void *match, void *aux)
178: {
179: struct usb_attach_arg *uaa = aux;
180:
181: if (uaa->iface != NULL)
182: return (UMATCH_NONE);
183:
184: return (umct_lookup(uaa->vendor, uaa->product) != NULL ?
185: UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
186: }
187:
188: void
189: umct_attach(struct device *parent, struct device *self, void *aux)
190: {
191: struct umct_softc *sc = (struct umct_softc *)self;
192: struct usb_attach_arg *uaa = aux;
193: usbd_device_handle dev = uaa->device;
194: usb_config_descriptor_t *cdesc;
195: usb_interface_descriptor_t *id;
196: usb_endpoint_descriptor_t *ed;
197:
198: char *devinfop;
199: char *devname = sc->sc_dev.dv_xname;
200: usbd_status err;
201: int i;
202: struct ucom_attach_args uca;
203:
204: devinfop = usbd_devinfo_alloc(dev, 0);
205: printf("\n%s: %s\n", devname, devinfop);
206: usbd_devinfo_free(devinfop);
207:
208: sc->sc_udev = dev;
209: sc->sc_product = uaa->product;
210:
211: DPRINTF(("\n\numct attach: sc=%p\n", sc));
212:
213: /* initialize endpoints */
214: uca.bulkin = uca.bulkout = -1;
215: sc->sc_intr_number = -1;
216: sc->sc_intr_pipe = NULL;
217:
218: /* Move the device into the configured state. */
219: err = usbd_set_config_index(dev, UMCT_CONFIG_INDEX, 1);
220: if (err) {
221: printf("\n%s: failed to set configuration, err=%s\n",
222: devname, usbd_errstr(err));
223: sc->sc_dying = 1;
224: return;
225: }
226:
227: /* get the config descriptor */
228: cdesc = usbd_get_config_descriptor(sc->sc_udev);
229:
230: if (cdesc == NULL) {
231: printf("%s: failed to get configuration descriptor\n",
232: sc->sc_dev.dv_xname);
233: sc->sc_dying = 1;
234: return;
235: }
236:
237: /* get the interface */
238: err = usbd_device2interface_handle(dev, UMCT_IFACE_INDEX,
239: &sc->sc_iface);
240: if (err) {
241: printf("\n%s: failed to get interface, err=%s\n",
242: devname, usbd_errstr(err));
243: sc->sc_dying = 1;
244: return;
245: }
246:
247: /* Find the bulk{in,out} and interrupt endpoints */
248:
249: id = usbd_get_interface_descriptor(sc->sc_iface);
250: sc->sc_iface_number = id->bInterfaceNumber;
251:
252: for (i = 0; i < id->bNumEndpoints; i++) {
253: ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
254: if (ed == NULL) {
255: printf("%s: no endpoint descriptor for %d\n",
256: sc->sc_dev.dv_xname, i);
257: sc->sc_dying = 1;
258: return;
259: }
260:
261: /*
262: * The Bulkin endpoint is marked as an interrupt. Since
263: * we can't rely on the endpoint descriptor order, we'll
264: * check the wMaxPacketSize field to differentiate.
265: */
266: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
267: UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT &&
268: UGETW(ed->wMaxPacketSize) != 0x2) {
269: uca.bulkin = ed->bEndpointAddress;
270: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
271: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
272: uca.bulkout = ed->bEndpointAddress;
273: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
274: UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
275: sc->sc_intr_number = ed->bEndpointAddress;
276: sc->sc_isize = UGETW(ed->wMaxPacketSize);
277: }
278: }
279:
280: if (uca.bulkin == -1) {
281: printf("%s: Could not find data bulk in\n",
282: sc->sc_dev.dv_xname);
283: sc->sc_dying = 1;
284: return;
285: }
286:
287: if (uca.bulkout == -1) {
288: printf("%s: Could not find data bulk out\n",
289: sc->sc_dev.dv_xname);
290: sc->sc_dying = 1;
291: return;
292: }
293:
294: if (sc->sc_intr_number== -1) {
295: printf("%s: Could not find interrupt in\n",
296: sc->sc_dev.dv_xname);
297: sc->sc_dying = 1;
298: return;
299: }
300:
301: sc->sc_dtr = sc->sc_rts = 0;
302: uca.portno = UCOM_UNK_PORTNO;
303: /* bulkin, bulkout set above */
304: uca.ibufsize = UMCTIBUFSIZE;
305: if (sc->sc_product == USB_PRODUCT_MCT_SITECOM_USB232)
306: uca.obufsize = 16; /* device is broken */
307: else
308: uca.obufsize = UMCTOBUFSIZE;
309: uca.ibufsizepad = UMCTIBUFSIZE;
310: uca.opkthdrlen = 0;
311: uca.device = dev;
312: uca.iface = sc->sc_iface;
313: uca.methods = &umct_methods;
314: uca.arg = sc;
315: uca.info = NULL;
316:
317: umct_init(sc);
318:
319: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
320: &sc->sc_dev);
321:
322: DPRINTF(("umct: in=0x%x out=0x%x intr=0x%x\n",
323: uca.bulkin, uca.bulkout, sc->sc_intr_number ));
324: sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
325: }
326:
327: int
328: umct_detach(struct device *self, int flags)
329: {
330: struct umct_softc *sc = (struct umct_softc *)self;
331: int rv = 0;
332:
333: DPRINTF(("umct_detach: sc=%p flags=%d\n", sc, flags));
334:
335: if (sc->sc_intr_pipe != NULL) {
336: usbd_abort_pipe(sc->sc_intr_pipe);
337: usbd_close_pipe(sc->sc_intr_pipe);
338: free(sc->sc_intr_buf, M_USBDEV);
339: sc->sc_intr_pipe = NULL;
340: }
341:
342: sc->sc_dying = 1;
343: if (sc->sc_subdev != NULL) {
344: rv = config_detach(sc->sc_subdev, flags);
345: sc->sc_subdev = NULL;
346: }
347:
348: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
349: &sc->sc_dev);
350:
351: return (rv);
352: }
353:
354: int
355: umct_activate(struct device *self, enum devact act)
356: {
357: struct umct_softc *sc = (struct umct_softc *)self;
358: int rv = 0;
359:
360: switch (act) {
361: case DVACT_ACTIVATE:
362: break;
363:
364: case DVACT_DEACTIVATE:
365: if (sc->sc_subdev != NULL)
366: rv = config_deactivate(sc->sc_subdev);
367: sc->sc_dying = 1;
368: break;
369: }
370: return (rv);
371: }
372:
373: void
374: umct_set_line_state(struct umct_softc *sc)
375: {
376: usb_device_request_t req;
377: uByte ls;
378:
379: ls = (sc->sc_dtr ? MCR_DTR : 0) |
380: (sc->sc_rts ? MCR_RTS : 0);
381:
382: DPRINTF(("umct_set_line_state: DTR=%d,RTS=%d,ls=%02x\n",
383: sc->sc_dtr, sc->sc_rts, ls));
384:
385: req.bmRequestType = UMCT_SET_REQUEST;
386: req.bRequest = REQ_SET_MCR;
387: USETW(req.wValue, 0);
388: USETW(req.wIndex, sc->sc_iface_number);
389: USETW(req.wLength, LENGTH_SET_MCR);
390:
391: (void)usbd_do_request(sc->sc_udev, &req, &ls);
392: }
393:
394: void
395: umct_set(void *addr, int portno, int reg, int onoff)
396: {
397: struct umct_softc *sc = addr;
398:
399: switch (reg) {
400: case UCOM_SET_DTR:
401: umct_dtr(sc, onoff);
402: break;
403: case UCOM_SET_RTS:
404: umct_rts(sc, onoff);
405: break;
406: case UCOM_SET_BREAK:
407: umct_break(sc, onoff);
408: break;
409: default:
410: break;
411: }
412: }
413:
414: void
415: umct_dtr(struct umct_softc *sc, int onoff)
416: {
417:
418: DPRINTF(("umct_dtr: onoff=%d\n", onoff));
419:
420: if (sc->sc_dtr == onoff)
421: return;
422: sc->sc_dtr = onoff;
423:
424: umct_set_line_state(sc);
425: }
426:
427: void
428: umct_rts(struct umct_softc *sc, int onoff)
429: {
430: DPRINTF(("umct_rts: onoff=%d\n", onoff));
431:
432: if (sc->sc_rts == onoff)
433: return;
434: sc->sc_rts = onoff;
435:
436: umct_set_line_state(sc);
437: }
438:
439: void
440: umct_break(struct umct_softc *sc, int onoff)
441: {
442: DPRINTF(("umct_break: onoff=%d\n", onoff));
443:
444: umct_set_lcr(sc, onoff ? sc->last_lcr | LCR_SET_BREAK :
445: sc->last_lcr);
446: }
447:
448: void
449: umct_set_lcr(struct umct_softc *sc, u_int data)
450: {
451: usb_device_request_t req;
452: uByte adata;
453:
454: adata = data;
455: req.bmRequestType = UMCT_SET_REQUEST;
456: req.bRequest = REQ_SET_LCR;
457: USETW(req.wValue, 0);
458: USETW(req.wIndex, sc->sc_iface_number);
459: USETW(req.wLength, LENGTH_SET_LCR);
460:
461: /* XXX should check */
462: (void)usbd_do_request(sc->sc_udev, &req, &adata);
463: }
464:
465: void
466: umct_set_baudrate(struct umct_softc *sc, u_int rate)
467: {
468: usb_device_request_t req;
469: uDWord arate;
470: u_int val;
471:
472: if (sc->sc_product == USB_PRODUCT_MCT_SITECOM_USB232 ||
473: sc->sc_product == USB_PRODUCT_BELKIN_F5U109) {
474: switch (rate) {
475: case 300: val = 0x01; break;
476: case 600: val = 0x02; break;
477: case 1200: val = 0x03; break;
478: case 2400: val = 0x04; break;
479: case 4800: val = 0x06; break;
480: case 9600: val = 0x08; break;
481: case 19200: val = 0x09; break;
482: case 38400: val = 0x0a; break;
483: case 57600: val = 0x0b; break;
484: case 115200: val = 0x0c; break;
485: default: val = -1; break;
486: }
487: } else {
488: val = UMCT_BAUD_RATE(rate);
489: }
490: USETDW(arate, val);
491:
492: req.bmRequestType = UMCT_SET_REQUEST;
493: req.bRequest = REQ_SET_BAUD_RATE;
494: USETW(req.wValue, 0);
495: USETW(req.wIndex, sc->sc_iface_number);
496: USETW(req.wLength, LENGTH_BAUD_RATE);
497:
498: /* XXX should check */
499: (void)usbd_do_request(sc->sc_udev, &req, arate);
500: }
501:
502: void
503: umct_init(struct umct_softc *sc)
504: {
505: umct_set_baudrate(sc, 9600);
506: umct_set_lcr(sc, LCR_DATA_BITS_8 | LCR_PARITY_NONE | LCR_STOP_BITS_1);
507: }
508:
509: int
510: umct_param(void *addr, int portno, struct termios *t)
511: {
512: struct umct_softc *sc = addr;
513: u_int data = 0;
514:
515: DPRINTF(("umct_param: sc=%p\n", sc));
516:
517: DPRINTF(("umct_param: BAUDRATE=%d\n", t->c_ospeed));
518:
519: if (ISSET(t->c_cflag, CSTOPB))
520: data |= LCR_STOP_BITS_2;
521: else
522: data |= LCR_STOP_BITS_1;
523: if (ISSET(t->c_cflag, PARENB)) {
524: if (ISSET(t->c_cflag, PARODD))
525: data |= LCR_PARITY_ODD;
526: else
527: data |= LCR_PARITY_EVEN;
528: } else
529: data |= LCR_PARITY_NONE;
530: switch (ISSET(t->c_cflag, CSIZE)) {
531: case CS5:
532: data |= LCR_DATA_BITS_5;
533: break;
534: case CS6:
535: data |= LCR_DATA_BITS_6;
536: break;
537: case CS7:
538: data |= LCR_DATA_BITS_7;
539: break;
540: case CS8:
541: data |= LCR_DATA_BITS_8;
542: break;
543: }
544:
545: umct_set_baudrate(sc, t->c_ospeed);
546:
547: sc->last_lcr = data;
548: umct_set_lcr(sc, data);
549:
550: return (0);
551: }
552:
553: int
554: umct_open(void *addr, int portno)
555: {
556: struct umct_softc *sc = addr;
557: int err, lcr_data;
558:
559: if (sc->sc_dying)
560: return (EIO);
561:
562: DPRINTF(("umct_open: sc=%p\n", sc));
563:
564: /* initialize LCR */
565: lcr_data = LCR_DATA_BITS_8 | LCR_PARITY_NONE |
566: LCR_STOP_BITS_1;
567: umct_set_lcr(sc, lcr_data);
568:
569: if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) {
570: sc->sc_status = 0; /* clear status bit */
571: sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
572: err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_intr_number,
573: USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc,
574: sc->sc_intr_buf, sc->sc_isize,
575: umct_intr, USBD_DEFAULT_INTERVAL);
576: if (err) {
577: DPRINTF(("%s: cannot open interrupt pipe (addr %d)\n",
578: sc->sc_dev.dv_xname, sc->sc_intr_number));
579: return (EIO);
580: }
581: }
582:
583: return (0);
584: }
585:
586: void
587: umct_close(void *addr, int portno)
588: {
589: struct umct_softc *sc = addr;
590: int err;
591:
592: if (sc->sc_dying)
593: return;
594:
595: DPRINTF(("umct_close: close\n"));
596:
597: if (sc->sc_intr_pipe != NULL) {
598: err = usbd_abort_pipe(sc->sc_intr_pipe);
599: if (err)
600: printf("%s: abort interrupt pipe failed: %s\n",
601: sc->sc_dev.dv_xname, usbd_errstr(err));
602: err = usbd_close_pipe(sc->sc_intr_pipe);
603: if (err)
604: printf("%s: close interrupt pipe failed: %s\n",
605: sc->sc_dev.dv_xname, usbd_errstr(err));
606: free(sc->sc_intr_buf, M_USBDEV);
607: sc->sc_intr_pipe = NULL;
608: }
609: }
610:
611: void
612: umct_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
613: {
614: struct umct_softc *sc = priv;
615: u_char *buf = sc->sc_intr_buf;
616: u_char mstatus;
617:
618: if (sc->sc_dying)
619: return;
620:
621: if (status != USBD_NORMAL_COMPLETION) {
622: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
623: return;
624:
625: DPRINTF(("%s: abnormal status: %s\n", sc->sc_dev.dv_xname,
626: usbd_errstr(status)));
627: usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
628: return;
629: }
630:
631: DPRINTF(("%s: umct status = MSR:%02x, LSR:%02x\n",
632: sc->sc_dev.dv_xname, buf[0],buf[1]));
633:
634: sc->sc_lsr = sc->sc_msr = 0;
635: mstatus = buf[0];
636: if (ISSET(mstatus, MSR_DSR))
637: sc->sc_msr |= UMSR_DSR;
638: if (ISSET(mstatus, MSR_DCD))
639: sc->sc_msr |= UMSR_DCD;
640: ucom_status_change((struct ucom_softc *)sc->sc_subdev);
641: }
642:
643: void
644: umct_get_status(void *addr, int portno, u_char *lsr, u_char *msr)
645: {
646: struct umct_softc *sc = addr;
647:
648: DPRINTF(("umct_get_status:\n"));
649:
650: if (lsr != NULL)
651: *lsr = sc->sc_lsr;
652: if (msr != NULL)
653: *msr = sc->sc_msr;
654: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to umct.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb