Annotation of sys/dev/usb/uplcom.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: uplcom.c,v 1.43 2007/06/14 10:11:16 mbalmer Exp $ */
2: /* $NetBSD: uplcom.c,v 1.29 2002/09/23 05:51:23 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: * Simple datasheet
41: * http://www.prolific.com.tw/PDF/PL-2303%20Market%20Spec.pdf
42: * http://www.hitachi-hitec.com/jyouhou/prolific/2303.pdf
43: * (english)
44: *
45: */
46:
47: #include <sys/param.h>
48: #include <sys/systm.h>
49: #include <sys/kernel.h>
50: #include <sys/malloc.h>
51: #include <sys/ioctl.h>
52: #include <sys/conf.h>
53: #include <sys/tty.h>
54: #include <sys/file.h>
55: #include <sys/selinfo.h>
56: #include <sys/proc.h>
57: #include <sys/vnode.h>
58: #include <sys/device.h>
59: #include <sys/poll.h>
60:
61: #include <dev/usb/usb.h>
62: #include <dev/usb/usbcdc.h>
63:
64: #include <dev/usb/usbdi.h>
65: #include <dev/usb/usbdi_util.h>
66: #include <dev/usb/usbdevs.h>
67: #include <dev/usb/usb_quirks.h>
68:
69: #include <dev/usb/usbdevs.h>
70: #include <dev/usb/ucomvar.h>
71:
72: #ifdef UPLCOM_DEBUG
73: #define DPRINTFN(n, x) do { if (uplcomdebug > (n)) printf x; } while (0)
74: int uplcomdebug = 0;
75: #else
76: #define DPRINTFN(n, x)
77: #endif
78: #define DPRINTF(x) DPRINTFN(0, x)
79:
80: #define UPLCOM_CONFIG_INDEX 0
81: #define UPLCOM_IFACE_INDEX 0
82: #define UPLCOM_SECOND_IFACE_INDEX 1
83:
84: #define UPLCOM_SET_REQUEST 0x01
85: #define UPLCOM_SET_CRTSCTS 0x41
86: #define UPLCOM_HX_SET_CRTSCTS 0x61
87: #define RSAQ_STATUS_CTS 0x80
88: #define RSAQ_STATUS_DSR 0x02
89: #define RSAQ_STATUS_DCD 0x01
90:
91: struct uplcom_softc {
92: struct device sc_dev; /* base device */
93: usbd_device_handle sc_udev; /* USB device */
94: usbd_interface_handle sc_iface; /* interface */
95: int sc_iface_number; /* interface number */
96:
97: usbd_interface_handle sc_intr_iface; /* interrupt interface */
98: int sc_intr_number; /* interrupt number */
99: usbd_pipe_handle sc_intr_pipe; /* interrupt pipe */
100: u_char *sc_intr_buf; /* interrupt buffer */
101: int sc_isize;
102:
103: usb_cdc_line_state_t sc_line_state; /* current line state */
104: int sc_dtr; /* current DTR state */
105: int sc_rts; /* current RTS state */
106:
107: struct device *sc_subdev; /* ucom device */
108:
109: u_char sc_dying; /* disconnecting */
110:
111: u_char sc_lsr; /* Local status register */
112: u_char sc_msr; /* uplcom status register */
113: int sc_type_hx; /* HX variant */
114: };
115:
116: /*
117: * These are the maximum number of bytes transferred per frame.
118: * The output buffer size cannot be increased due to the size encoding.
119: */
120: #define UPLCOMIBUFSIZE 256
121: #define UPLCOMOBUFSIZE 256
122:
123: usbd_status uplcom_reset(struct uplcom_softc *);
124: usbd_status uplcom_set_line_coding(struct uplcom_softc *sc,
125: usb_cdc_line_state_t *state);
126: usbd_status uplcom_set_crtscts(struct uplcom_softc *);
127: void uplcom_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
128:
129: void uplcom_set(void *, int, int, int);
130: void uplcom_dtr(struct uplcom_softc *, int);
131: void uplcom_rts(struct uplcom_softc *, int);
132: void uplcom_break(struct uplcom_softc *, int);
133: void uplcom_set_line_state(struct uplcom_softc *);
134: void uplcom_get_status(void *, int portno, u_char *lsr, u_char *msr);
135: #if TODO
136: int uplcom_ioctl(void *, int, u_long, caddr_t, int, struct proc *);
137: #endif
138: int uplcom_param(void *, int, struct termios *);
139: int uplcom_open(void *, int);
140: void uplcom_close(void *, int);
141:
142: struct ucom_methods uplcom_methods = {
143: uplcom_get_status,
144: uplcom_set,
145: uplcom_param,
146: NULL, /* uplcom_ioctl, TODO */
147: uplcom_open,
148: uplcom_close,
149: NULL,
150: NULL,
151: };
152:
153: static const struct usb_devno uplcom_devs[] = {
154: { USB_VENDOR_ALCATEL, USB_PRODUCT_ALCATEL_OT535 },
155: { USB_VENDOR_ANCHOR, USB_PRODUCT_ANCHOR_SERIAL },
156: { USB_VENDOR_ATEN, USB_PRODUCT_ATEN_UC232A },
157: { USB_VENDOR_BELKIN, USB_PRODUCT_BELKIN_F5U257 },
158: { USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_UCSGT },
159: { USB_VENDOR_ELECOM, USB_PRODUCT_ELECOM_UCSGT0 },
160: { USB_VENDOR_HAL, USB_PRODUCT_HAL_IMR001 },
161: { USB_VENDOR_IODATA, USB_PRODUCT_IODATA_USBRSAQ },
162: { USB_VENDOR_LEADTEK, USB_PRODUCT_LEADTEK_9531 },
163: { USB_VENDOR_MOBILEACTION, USB_PRODUCT_MOBILEACTION_MA620 },
164: { USB_VENDOR_NOKIA, USB_PRODUCT_NOKIA_CA42 },
165: { USB_VENDOR_OTI, USB_PRODUCT_OTI_DKU5 },
166: { USB_VENDOR_PLX, USB_PRODUCT_PLX_CA42 },
167: { USB_VENDOR_PANASONIC, USB_PRODUCT_PANASONIC_TYTP50P6S },
168: { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2303 },
169: { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2303X },
170: { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_PL2303X2 },
171: { USB_VENDOR_PROLIFIC, USB_PRODUCT_PROLIFIC_RSAQ2 },
172: { USB_VENDOR_PROLIFIC2, USB_PRODUCT_PROLIFIC2_PL2303 },
173: { USB_VENDOR_RADIOSHACK, USB_PRODUCT_RADIOSHACK_PL2303 },
174: { USB_VENDOR_RATOC, USB_PRODUCT_RATOC_REXUSB60 },
175: { USB_VENDOR_SAGEM, USB_PRODUCT_SAGEM_SERIAL },
176: { USB_VENDOR_SAMSUNG2, USB_PRODUCT_SAMSUNG2_I330 },
177: { USB_VENDOR_SIEMENS3, USB_PRODUCT_SIEMENS3_SX1 },
178: { USB_VENDOR_SIEMENS3, USB_PRODUCT_SIEMENS3_X65 },
179: { USB_VENDOR_SIEMENS3, USB_PRODUCT_SIEMENS3_X75 },
180: { USB_VENDOR_SITECOM, USB_PRODUCT_SITECOM_CN104 },
181: { USB_VENDOR_SOURCENEXT, USB_PRODUCT_SOURCENEXT_KEIKAI8 },
182: { USB_VENDOR_SOURCENEXT, USB_PRODUCT_SOURCENEXT_KEIKAI8_CHG },
183: { USB_VENDOR_SPEEDDRAGON, USB_PRODUCT_SPEEDDRAGON_MS3303H },
184: { USB_VENDOR_SUSTEEN, USB_PRODUCT_SUSTEEN_DCU11 },
185: { USB_VENDOR_SYNTECH, USB_PRODUCT_SYNTECH_SERIAL },
186: { USB_VENDOR_TDK, USB_PRODUCT_TDK_UHA6400 },
187: { USB_VENDOR_TDK, USB_PRODUCT_TDK_UPA9664 },
188: { USB_VENDOR_TRIPPLITE, USB_PRODUCT_TRIPPLITE_U209 }
189: };
190: #define uplcom_lookup(v, p) usb_lookup(uplcom_devs, v, p)
191:
192: int uplcom_match(struct device *, void *, void *);
193: void uplcom_attach(struct device *, struct device *, void *);
194: int uplcom_detach(struct device *, int);
195: int uplcom_activate(struct device *, enum devact);
196:
197: struct cfdriver uplcom_cd = {
198: NULL, "uplcom", DV_DULL
199: };
200:
201: const struct cfattach uplcom_ca = {
202: sizeof(struct uplcom_softc),
203: uplcom_match,
204: uplcom_attach,
205: uplcom_detach,
206: uplcom_activate,
207: };
208:
209: int
210: uplcom_match(struct device *parent, void *match, void *aux)
211: {
212: struct usb_attach_arg *uaa = aux;
213:
214: if (uaa->iface != NULL)
215: return (UMATCH_NONE);
216:
217: return (uplcom_lookup(uaa->vendor, uaa->product) != NULL ?
218: UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
219: }
220:
221: void
222: uplcom_attach(struct device *parent, struct device *self, void *aux)
223: {
224: struct uplcom_softc *sc = (struct uplcom_softc *)self;
225: struct usb_attach_arg *uaa = aux;
226: usbd_device_handle dev = uaa->device;
227: usb_config_descriptor_t *cdesc;
228: usb_device_descriptor_t *ddesc;
229: usb_interface_descriptor_t *id;
230: usb_endpoint_descriptor_t *ed;
231:
232: char *devinfop;
233: char *devname = sc->sc_dev.dv_xname;
234: usbd_status err;
235: int i;
236: struct ucom_attach_args uca;
237:
238: devinfop = usbd_devinfo_alloc(dev, 0);
239: printf("\n%s: %s\n", devname, devinfop);
240: usbd_devinfo_free(devinfop);
241:
242: sc->sc_udev = dev;
243:
244: DPRINTF(("\n\nuplcom attach: sc=%p\n", sc));
245:
246: /* initialize endpoints */
247: uca.bulkin = uca.bulkout = -1;
248: sc->sc_intr_number = -1;
249: sc->sc_intr_pipe = NULL;
250:
251: /* Move the device into the configured state. */
252: err = usbd_set_config_index(dev, UPLCOM_CONFIG_INDEX, 1);
253: if (err) {
254: printf("\n%s: failed to set configuration, err=%s\n",
255: devname, usbd_errstr(err));
256: sc->sc_dying = 1;
257: return;
258: }
259:
260: /* get the config descriptor */
261: cdesc = usbd_get_config_descriptor(sc->sc_udev);
262:
263: if (cdesc == NULL) {
264: printf("%s: failed to get configuration descriptor\n",
265: sc->sc_dev.dv_xname);
266: sc->sc_dying = 1;
267: return;
268: }
269:
270: /* get the device descriptor */
271: ddesc = usbd_get_device_descriptor(sc->sc_udev);
272: if (ddesc == NULL) {
273: printf("%s: failed to get device descriptor\n",
274: sc->sc_dev.dv_xname);
275: sc->sc_dying = 1;
276: return;
277: }
278:
279: /*
280: * The Linux driver suggest this will only be true for the HX
281: * variants. The datasheets disagree.
282: */
283: if (ddesc->bMaxPacketSize == 0x40) {
284: DPRINTF(("%s: Assuming HX variant\n", sc->sc_dev.dv_xname));
285: sc->sc_type_hx = 1;
286: } else
287: sc->sc_type_hx = 0;
288:
289: /* get the (first/common) interface */
290: err = usbd_device2interface_handle(dev, UPLCOM_IFACE_INDEX,
291: &sc->sc_iface);
292: if (err) {
293: printf("\n%s: failed to get interface, err=%s\n",
294: devname, usbd_errstr(err));
295: sc->sc_dying = 1;
296: return;
297: }
298:
299: /* Find the interrupt endpoints */
300:
301: id = usbd_get_interface_descriptor(sc->sc_iface);
302: sc->sc_iface_number = id->bInterfaceNumber;
303:
304: for (i = 0; i < id->bNumEndpoints; i++) {
305: ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
306: if (ed == NULL) {
307: printf("%s: no endpoint descriptor for %d\n",
308: sc->sc_dev.dv_xname, i);
309: sc->sc_dying = 1;
310: return;
311: }
312:
313: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
314: UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
315: sc->sc_intr_number = ed->bEndpointAddress;
316: sc->sc_isize = UGETW(ed->wMaxPacketSize);
317: }
318: }
319:
320: if (sc->sc_intr_number== -1) {
321: printf("%s: Could not find interrupt in\n",
322: sc->sc_dev.dv_xname);
323: sc->sc_dying = 1;
324: return;
325: }
326:
327: /* keep interface for interrupt */
328: sc->sc_intr_iface = sc->sc_iface;
329:
330: /*
331: * USB-RSAQ1 has two interface
332: *
333: * USB-RSAQ1 | USB-RSAQ2
334: * -----------------+-----------------
335: * Interface 0 |Interface 0
336: * Interrupt(0x81) | Interrupt(0x81)
337: * -----------------+ BulkIN(0x02)
338: * Interface 1 | BulkOUT(0x83)
339: * BulkIN(0x02) |
340: * BulkOUT(0x83) |
341: */
342: if (cdesc->bNumInterface == 2) {
343: err = usbd_device2interface_handle(dev,
344: UPLCOM_SECOND_IFACE_INDEX, &sc->sc_iface);
345: if (err) {
346: printf("\n%s: failed to get second interface, err=%s\n",
347: devname, usbd_errstr(err));
348: sc->sc_dying = 1;
349: return;
350: }
351: }
352:
353: /* Find the bulk{in,out} endpoints */
354:
355: id = usbd_get_interface_descriptor(sc->sc_iface);
356: sc->sc_iface_number = id->bInterfaceNumber;
357:
358: for (i = 0; i < id->bNumEndpoints; i++) {
359: ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
360: if (ed == NULL) {
361: printf("%s: no endpoint descriptor for %d\n",
362: sc->sc_dev.dv_xname, i);
363: sc->sc_dying = 1;
364: return;
365: }
366:
367: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
368: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
369: uca.bulkin = ed->bEndpointAddress;
370: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
371: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
372: uca.bulkout = ed->bEndpointAddress;
373: }
374: }
375:
376: if (uca.bulkin == -1) {
377: printf("%s: Could not find data bulk in\n",
378: sc->sc_dev.dv_xname);
379: sc->sc_dying = 1;
380: return;
381: }
382:
383: if (uca.bulkout == -1) {
384: printf("%s: Could not find data bulk out\n",
385: sc->sc_dev.dv_xname);
386: sc->sc_dying = 1;
387: return;
388: }
389:
390: sc->sc_dtr = sc->sc_rts = -1;
391: uca.portno = UCOM_UNK_PORTNO;
392: /* bulkin, bulkout set above */
393: uca.ibufsize = UPLCOMIBUFSIZE;
394: uca.obufsize = UPLCOMOBUFSIZE;
395: uca.ibufsizepad = UPLCOMIBUFSIZE;
396: uca.opkthdrlen = 0;
397: uca.device = dev;
398: uca.iface = sc->sc_iface;
399: uca.methods = &uplcom_methods;
400: uca.arg = sc;
401: uca.info = NULL;
402:
403: err = uplcom_reset(sc);
404:
405: if (err) {
406: printf("%s: reset failed, %s\n", sc->sc_dev.dv_xname,
407: usbd_errstr(err));
408: sc->sc_dying = 1;
409: return;
410: }
411:
412: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
413: &sc->sc_dev);
414:
415: DPRINTF(("uplcom: in=0x%x out=0x%x intr=0x%x\n",
416: uca.bulkin, uca.bulkout, sc->sc_intr_number ));
417: sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
418: }
419:
420: int
421: uplcom_detach(struct device *self, int flags)
422: {
423: struct uplcom_softc *sc = (struct uplcom_softc *)self;
424: int rv = 0;
425:
426: DPRINTF(("uplcom_detach: sc=%p flags=%d\n", sc, flags));
427:
428: if (sc->sc_intr_pipe != NULL) {
429: usbd_abort_pipe(sc->sc_intr_pipe);
430: usbd_close_pipe(sc->sc_intr_pipe);
431: free(sc->sc_intr_buf, M_USBDEV);
432: sc->sc_intr_pipe = NULL;
433: }
434:
435: sc->sc_dying = 1;
436: if (sc->sc_subdev != NULL) {
437: rv = config_detach(sc->sc_subdev, flags);
438: sc->sc_subdev = NULL;
439: }
440:
441: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
442: &sc->sc_dev);
443:
444: return (rv);
445: }
446:
447: int
448: uplcom_activate(struct device *self, enum devact act)
449: {
450: struct uplcom_softc *sc = (struct uplcom_softc *)self;
451: int rv = 0;
452:
453: switch (act) {
454: case DVACT_ACTIVATE:
455: break;
456:
457: case DVACT_DEACTIVATE:
458: if (sc->sc_subdev != NULL)
459: rv = config_deactivate(sc->sc_subdev);
460: sc->sc_dying = 1;
461: break;
462: }
463: return (rv);
464: }
465:
466: usbd_status
467: uplcom_reset(struct uplcom_softc *sc)
468: {
469: usb_device_request_t req;
470: usbd_status err;
471:
472: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
473: req.bRequest = UPLCOM_SET_REQUEST;
474: USETW(req.wValue, 0);
475: USETW(req.wIndex, sc->sc_iface_number);
476: USETW(req.wLength, 0);
477:
478: err = usbd_do_request(sc->sc_udev, &req, 0);
479: if (err)
480: return (EIO);
481:
482: return (0);
483: }
484:
485: void
486: uplcom_set_line_state(struct uplcom_softc *sc)
487: {
488: usb_device_request_t req;
489: int ls;
490:
491: /* Make sure we have initialized state for sc_dtr and sc_rts */
492: if (sc->sc_dtr == -1)
493: sc->sc_dtr = 0;
494: if (sc->sc_rts == -1)
495: sc->sc_rts = 0;
496:
497: ls = (sc->sc_dtr ? UCDC_LINE_DTR : 0) |
498: (sc->sc_rts ? UCDC_LINE_RTS : 0);
499:
500: req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
501: req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
502: USETW(req.wValue, ls);
503: USETW(req.wIndex, sc->sc_iface_number);
504: USETW(req.wLength, 0);
505:
506: (void)usbd_do_request(sc->sc_udev, &req, 0);
507:
508: }
509:
510: void
511: uplcom_set(void *addr, int portno, int reg, int onoff)
512: {
513: struct uplcom_softc *sc = addr;
514:
515: switch (reg) {
516: case UCOM_SET_DTR:
517: uplcom_dtr(sc, onoff);
518: break;
519: case UCOM_SET_RTS:
520: uplcom_rts(sc, onoff);
521: break;
522: case UCOM_SET_BREAK:
523: uplcom_break(sc, onoff);
524: break;
525: default:
526: break;
527: }
528: }
529:
530: void
531: uplcom_dtr(struct uplcom_softc *sc, int onoff)
532: {
533:
534: DPRINTF(("uplcom_dtr: onoff=%d\n", onoff));
535:
536: if (sc->sc_dtr != -1 && !sc->sc_dtr == !onoff)
537: return;
538:
539: sc->sc_dtr = !!onoff;
540:
541: uplcom_set_line_state(sc);
542: }
543:
544: void
545: uplcom_rts(struct uplcom_softc *sc, int onoff)
546: {
547: DPRINTF(("uplcom_rts: onoff=%d\n", onoff));
548:
549: if (sc->sc_rts == -1 && !sc->sc_rts == !onoff)
550: return;
551:
552: sc->sc_rts = !!onoff;
553:
554: uplcom_set_line_state(sc);
555: }
556:
557: void
558: uplcom_break(struct uplcom_softc *sc, int onoff)
559: {
560: usb_device_request_t req;
561:
562: DPRINTF(("uplcom_break: onoff=%d\n", onoff));
563:
564: req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
565: req.bRequest = UCDC_SEND_BREAK;
566: USETW(req.wValue, onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF);
567: USETW(req.wIndex, sc->sc_iface_number);
568: USETW(req.wLength, 0);
569:
570: (void)usbd_do_request(sc->sc_udev, &req, 0);
571: }
572:
573: usbd_status
574: uplcom_set_crtscts(struct uplcom_softc *sc)
575: {
576: usb_device_request_t req;
577: usbd_status err;
578:
579: DPRINTF(("uplcom_set_crtscts: on\n"));
580:
581: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
582: req.bRequest = UPLCOM_SET_REQUEST;
583: USETW(req.wValue, 0);
584: USETW(req.wIndex,
585: (sc->sc_type_hx ? UPLCOM_HX_SET_CRTSCTS : UPLCOM_SET_CRTSCTS));
586: USETW(req.wLength, 0);
587:
588: err = usbd_do_request(sc->sc_udev, &req, 0);
589: if (err) {
590: DPRINTF(("uplcom_set_crtscts: failed, err=%s\n",
591: usbd_errstr(err)));
592: return (err);
593: }
594:
595: return (USBD_NORMAL_COMPLETION);
596: }
597:
598: usbd_status
599: uplcom_set_line_coding(struct uplcom_softc *sc, usb_cdc_line_state_t *state)
600: {
601: usb_device_request_t req;
602: usbd_status err;
603:
604: DPRINTF(("uplcom_set_line_coding: rate=%d fmt=%d parity=%d bits=%d\n",
605: UGETDW(state->dwDTERate), state->bCharFormat,
606: state->bParityType, state->bDataBits));
607:
608: if (memcmp(state, &sc->sc_line_state, UCDC_LINE_STATE_LENGTH) == 0) {
609: DPRINTF(("uplcom_set_line_coding: already set\n"));
610: return (USBD_NORMAL_COMPLETION);
611: }
612:
613: req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
614: req.bRequest = UCDC_SET_LINE_CODING;
615: USETW(req.wValue, 0);
616: USETW(req.wIndex, sc->sc_iface_number);
617: USETW(req.wLength, UCDC_LINE_STATE_LENGTH);
618:
619: err = usbd_do_request(sc->sc_udev, &req, state);
620: if (err) {
621: DPRINTF(("uplcom_set_line_coding: failed, err=%s\n",
622: usbd_errstr(err)));
623: return (err);
624: }
625:
626: sc->sc_line_state = *state;
627:
628: return (USBD_NORMAL_COMPLETION);
629: }
630:
631: int
632: uplcom_param(void *addr, int portno, struct termios *t)
633: {
634: struct uplcom_softc *sc = addr;
635: usbd_status err;
636: usb_cdc_line_state_t ls;
637:
638: DPRINTF(("uplcom_param: sc=%p\n", sc));
639:
640: USETDW(ls.dwDTERate, t->c_ospeed);
641: if (ISSET(t->c_cflag, CSTOPB))
642: ls.bCharFormat = UCDC_STOP_BIT_2;
643: else
644: ls.bCharFormat = UCDC_STOP_BIT_1;
645: if (ISSET(t->c_cflag, PARENB)) {
646: if (ISSET(t->c_cflag, PARODD))
647: ls.bParityType = UCDC_PARITY_ODD;
648: else
649: ls.bParityType = UCDC_PARITY_EVEN;
650: } else
651: ls.bParityType = UCDC_PARITY_NONE;
652: switch (ISSET(t->c_cflag, CSIZE)) {
653: case CS5:
654: ls.bDataBits = 5;
655: break;
656: case CS6:
657: ls.bDataBits = 6;
658: break;
659: case CS7:
660: ls.bDataBits = 7;
661: break;
662: case CS8:
663: ls.bDataBits = 8;
664: break;
665: }
666:
667: err = uplcom_set_line_coding(sc, &ls);
668: if (err) {
669: DPRINTF(("uplcom_param: err=%s\n", usbd_errstr(err)));
670: return (EIO);
671: }
672:
673: if (ISSET(t->c_cflag, CRTSCTS))
674: uplcom_set_crtscts(sc);
675:
676: if (sc->sc_rts == -1 || sc->sc_dtr == -1)
677: uplcom_set_line_state(sc);
678:
679: if (err) {
680: DPRINTF(("uplcom_param: err=%s\n", usbd_errstr(err)));
681: return (EIO);
682: }
683:
684: return (0);
685: }
686:
687: int
688: uplcom_open(void *addr, int portno)
689: {
690: struct uplcom_softc *sc = addr;
691: usb_device_request_t req;
692: usbd_status uerr;
693: int err;
694:
695: if (sc->sc_dying)
696: return (EIO);
697:
698: DPRINTF(("uplcom_open: sc=%p\n", sc));
699:
700: if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) {
701: sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
702: err = usbd_open_pipe_intr(sc->sc_intr_iface, sc->sc_intr_number,
703: USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc,
704: sc->sc_intr_buf, sc->sc_isize,
705: uplcom_intr, USBD_DEFAULT_INTERVAL);
706: if (err) {
707: DPRINTF(("%s: cannot open interrupt pipe (addr %d)\n",
708: sc->sc_dev.dv_xname, sc->sc_intr_number));
709: return (EIO);
710: }
711: }
712:
713: if (sc->sc_type_hx == 1) {
714: /*
715: * Undocumented (vendor unresponsive) - possibly changes
716: * flow control semantics. It is needed for HX variant devices.
717: */
718: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
719: req.bRequest = UPLCOM_SET_REQUEST;
720: USETW(req.wValue, 2);
721: USETW(req.wIndex, 0x44);
722: USETW(req.wLength, 0);
723:
724: uerr = usbd_do_request(sc->sc_udev, &req, 0);
725: if (uerr)
726: return (EIO);
727:
728: /* Reset upstream data pipes */
729: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
730: req.bRequest = UPLCOM_SET_REQUEST;
731: USETW(req.wValue, 8);
732: USETW(req.wIndex, 0);
733: USETW(req.wLength, 0);
734:
735: uerr = usbd_do_request(sc->sc_udev, &req, 0);
736: if (uerr)
737: return (EIO);
738:
739: req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
740: req.bRequest = UPLCOM_SET_REQUEST;
741: USETW(req.wValue, 9);
742: USETW(req.wIndex, 0);
743: USETW(req.wLength, 0);
744:
745: uerr = usbd_do_request(sc->sc_udev, &req, 0);
746: if (uerr)
747: return (EIO);
748: }
749:
750: return (0);
751: }
752:
753: void
754: uplcom_close(void *addr, int portno)
755: {
756: struct uplcom_softc *sc = addr;
757: int err;
758:
759: if (sc->sc_dying)
760: return;
761:
762: DPRINTF(("uplcom_close: close\n"));
763:
764: if (sc->sc_intr_pipe != NULL) {
765: err = usbd_abort_pipe(sc->sc_intr_pipe);
766: if (err)
767: printf("%s: abort interrupt pipe failed: %s\n",
768: sc->sc_dev.dv_xname, usbd_errstr(err));
769: err = usbd_close_pipe(sc->sc_intr_pipe);
770: if (err)
771: printf("%s: close interrupt pipe failed: %s\n",
772: sc->sc_dev.dv_xname, usbd_errstr(err));
773: free(sc->sc_intr_buf, M_USBDEV);
774: sc->sc_intr_pipe = NULL;
775: }
776: }
777:
778: void
779: uplcom_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
780: {
781: struct uplcom_softc *sc = priv;
782: u_char *buf = sc->sc_intr_buf;
783: u_char pstatus;
784:
785: if (sc->sc_dying)
786: return;
787:
788: if (status != USBD_NORMAL_COMPLETION) {
789: if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
790: return;
791:
792: DPRINTF(("%s: abnormal status: %s\n", sc->sc_dev.dv_xname,
793: usbd_errstr(status)));
794: usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
795: return;
796: }
797:
798: DPRINTF(("%s: uplcom status = %02x\n", sc->sc_dev.dv_xname, buf[8]));
799:
800: sc->sc_lsr = sc->sc_msr = 0;
801: pstatus = buf[8];
802: if (ISSET(pstatus, RSAQ_STATUS_CTS))
803: sc->sc_msr |= UMSR_CTS;
804: else
805: sc->sc_msr &= ~UMSR_CTS;
806: if (ISSET(pstatus, RSAQ_STATUS_DSR))
807: sc->sc_msr |= UMSR_DSR;
808: else
809: sc->sc_msr &= ~UMSR_DSR;
810: if (ISSET(pstatus, RSAQ_STATUS_DCD))
811: sc->sc_msr |= UMSR_DCD;
812: else
813: sc->sc_msr &= ~UMSR_DCD;
814: ucom_status_change((struct ucom_softc *) sc->sc_subdev);
815: }
816:
817: void
818: uplcom_get_status(void *addr, int portno, u_char *lsr, u_char *msr)
819: {
820: struct uplcom_softc *sc = addr;
821:
822: DPRINTF(("uplcom_get_status:\n"));
823:
824: if (lsr != NULL)
825: *lsr = sc->sc_lsr;
826: if (msr != NULL)
827: *msr = sc->sc_msr;
828: }
829:
830: #if TODO
831: int
832: uplcom_ioctl(void *addr, int portno, u_long cmd, caddr_t data, int flag,
833: struct proc *p)
834: {
835: struct uplcom_softc *sc = addr;
836: int error = 0;
837:
838: if (sc->sc_dying)
839: return (EIO);
840:
841: DPRINTF(("uplcom_ioctl: cmd=0x%08lx\n", cmd));
842:
843: switch (cmd) {
844: case TIOCNOTTY:
845: case TIOCMGET:
846: case TIOCMSET:
847: case USB_GET_CM_OVER_DATA:
848: case USB_SET_CM_OVER_DATA:
849: break;
850:
851: default:
852: DPRINTF(("uplcom_ioctl: unknown\n"));
853: error = ENOTTY;
854: break;
855: }
856:
857: return (error);
858: }
859: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to uplcom.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb