jcs.org
jcs's openbsd hax
openbsd
1/* $OpenBSD: uslcom.c,v 1.45 2024/05/23 03:21:09 jsg Exp $ */
2
3/*
4 * Copyright (c) 2006 Jonathan Gray <jsg@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18
19#include <sys/param.h>
20#include <sys/systm.h>
21#include <sys/tty.h>
22#include <sys/device.h>
23
24#include <dev/usb/usb.h>
25#include <dev/usb/usbdi.h>
26#include <dev/usb/usbdevs.h>
27
28#include <dev/usb/ucomvar.h>
29
30#ifdef USLCOM_DEBUG
31#define DPRINTFN(n, x) do { if (uslcomdebug > (n)) printf x; } while (0)
32int uslcomdebug = 0;
33#else
34#define DPRINTFN(n, x)
35#endif
36#define DPRINTF(x) DPRINTFN(0, x)
37
38#define USLCOMBUFSZ 256
39
40#define USLCOM_SET_DATA_BITS(x) (x << 8)
41
42#define USLCOM_WRITE 0x41
43#define USLCOM_READ 0xc1
44
45#define USLCOM_UART 0x00
46#define USLCOM_SET_BAUD_DIV 0x01
47#define USLCOM_DATA 0x03
48#define USLCOM_BREAK 0x05
49#define USLCOM_CTRL 0x07
50#define USLCOM_SET_FLOW 0x13
51#define USLCOM_SET_BAUD_RATE 0x1e
52
53#define USLCOM_UART_DISABLE 0x00
54#define USLCOM_UART_ENABLE 0x01
55
56#define USLCOM_CTRL_DTR_ON 0x0001
57#define USLCOM_CTRL_DTR_SET 0x0100
58#define USLCOM_CTRL_RTS_ON 0x0002
59#define USLCOM_CTRL_RTS_SET 0x0200
60#define USLCOM_CTRL_CTS 0x0010
61#define USLCOM_CTRL_DSR 0x0020
62#define USLCOM_CTRL_DCD 0x0080
63
64#define USLCOM_BAUD_REF 3686400 /* 3.6864 MHz */
65
66#define USLCOM_STOP_BITS_1 0x00
67#define USLCOM_STOP_BITS_2 0x02
68
69#define USLCOM_PARITY_NONE 0x00
70#define USLCOM_PARITY_ODD 0x10
71#define USLCOM_PARITY_EVEN 0x20
72
73#define USLCOM_BREAK_OFF 0x00
74#define USLCOM_BREAK_ON 0x01
75
76/* USLCOM_SET_FLOW values - 1st word */
77#define USLCOM_FLOW_DTR_ON 0x00000001 /* DTR static active */
78#define USLCOM_FLOW_CTS_HS 0x00000008 /* CTS handshake */
79/* USLCOM_SET_FLOW values - 2nd word */
80#define USLCOM_FLOW_RTS_ON 0x00000040 /* RTS static active */
81#define USLCOM_FLOW_RTS_HS 0x00000080 /* RTS handshake */
82
83struct uslcom_softc {
84 struct device sc_dev;
85 struct usbd_device *sc_udev;
86 struct usbd_interface *sc_iface;
87 struct device *sc_subdev;
88
89 u_char sc_msr;
90 u_char sc_lsr;
91};
92
93void uslcom_get_status(void *, int portno, u_char *lsr, u_char *msr);
94void uslcom_set(void *, int, int, int);
95int uslcom_param(void *, int, struct termios *);
96int uslcom_open(void *sc, int portno);
97void uslcom_close(void *, int);
98void uslcom_break(void *sc, int portno, int onoff);
99
100const struct ucom_methods uslcom_methods = {
101 uslcom_get_status,
102 uslcom_set,
103 uslcom_param,
104 NULL,
105 uslcom_open,
106 uslcom_close,
107 NULL,
108 NULL,
109};
110
111static const struct usb_devno uslcom_devs[] = {
112 { USB_VENDOR_ARUBA, USB_PRODUCT_ARUBA_CP210X },
113 { USB_VENDOR_BALTECH, USB_PRODUCT_BALTECH_CARDREADER },
114 { USB_VENDOR_CLIPSAL, USB_PRODUCT_CLIPSAL_5000CT2 },
115 { USB_VENDOR_CLIPSAL, USB_PRODUCT_CLIPSAL_5500PACA },
116 { USB_VENDOR_CLIPSAL, USB_PRODUCT_CLIPSAL_5500PCU },
117 { USB_VENDOR_CLIPSAL, USB_PRODUCT_CLIPSAL_560884 },
118 { USB_VENDOR_CLIPSAL, USB_PRODUCT_CLIPSAL_5800PC },
119 { USB_VENDOR_CLIPSAL, USB_PRODUCT_CLIPSAL_C5000CT2 },
120 { USB_VENDOR_CLIPSAL, USB_PRODUCT_CLIPSAL_L51XX },
121 { USB_VENDOR_CORSAIR, USB_PRODUCT_CORSAIR_CP210X },
122 { USB_VENDOR_DATAAPEX, USB_PRODUCT_DATAAPEX_MULTICOM },
123 { USB_VENDOR_DELL, USB_PRODUCT_DELL_DW700 },
124 { USB_VENDOR_DIGIANSWER, USB_PRODUCT_DIGIANSWER_ZIGBEE802154 },
125 { USB_VENDOR_DYNASTREAM, USB_PRODUCT_DYNASTREAM_ANT2USB },
126 { USB_VENDOR_DYNASTREAM, USB_PRODUCT_DYNASTREAM_ANTDEVBOARD },
127 { USB_VENDOR_DYNASTREAM, USB_PRODUCT_DYNASTREAM_ANTDEVBOARD2 },
128 { USB_VENDOR_ELV, USB_PRODUCT_ELV_USBI2C },
129 { USB_VENDOR_FESTO, USB_PRODUCT_FESTO_CMSP },
130 { USB_VENDOR_FESTO, USB_PRODUCT_FESTO_CPX_USB },
131 { USB_VENDOR_FOXCONN, USB_PRODUCT_FOXCONN_PIRELLI_DP_L10 },
132 { USB_VENDOR_FOXCONN, USB_PRODUCT_FOXCONN_TCOM_TC_300 },
133 { USB_VENDOR_GEMPLUS, USB_PRODUCT_GEMPLUS_PROXPU },
134 { USB_VENDOR_JABLOTRON, USB_PRODUCT_JABLOTRON_PC60B },
135 { USB_VENDOR_KAMSTRUP, USB_PRODUCT_KAMSTRUP_MBUS_250D },
136 { USB_VENDOR_KAMSTRUP, USB_PRODUCT_KAMSTRUP_OPTICALEYE },
137 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M121 },
138 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M218A },
139 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M219 },
140 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M233 },
141 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M235 },
142 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M335 },
143 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M336 },
144 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M350 },
145 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M371 },
146 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M411 },
147 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M425 },
148 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M455A },
149 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M465 },
150 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M475A },
151 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M625A },
152 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M642A },
153 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M648 },
154 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M737 },
155 { USB_VENDOR_LAKESHORE, USB_PRODUCT_LAKESHORE_M776 },
156 { USB_VENDOR_LINKINSTRUMENTS, USB_PRODUCT_LINKINSTRUMENTS_MSO19 },
157 { USB_VENDOR_LINKINSTRUMENTS, USB_PRODUCT_LINKINSTRUMENTS_MSO28 },
158 { USB_VENDOR_LINKINSTRUMENTS, USB_PRODUCT_LINKINSTRUMENTS_MSO28_2 },
159 { USB_VENDOR_MEI, USB_PRODUCT_MEI_CASHFLOW_SC },
160 { USB_VENDOR_MEI, USB_PRODUCT_MEI_S2000 },
161 { USB_VENDOR_NETGEAR, USB_PRODUCT_NETGEAR_M7100 },
162 { USB_VENDOR_OREGONSCI, USB_PRODUCT_OREGONSCI_OWL_CM160 },
163 { USB_VENDOR_OWEN, USB_PRODUCT_OWEN_AC4 },
164 { USB_VENDOR_PHILIPS, USB_PRODUCT_PHILIPS_ACE1001 },
165 { USB_VENDOR_RENESAS, USB_PRODUCT_RENESAS_RX610 },
166 { USB_VENDOR_SEL, USB_PRODUCT_SEL_C662 },
167 { USB_VENDOR_SELUXIT, USB_PRODUCT_SELUXIT_RF },
168 { USB_VENDOR_SIEMENS4, USB_PRODUCT_SIEMENS4_RUGGEDCOM },
169 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_AC_SERV_CAN },
170 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_AC_SERV_CIS },
171 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_AC_SERV_IBUS },
172 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_AC_SERV_OBD },
173 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_AEROCOMM },
174 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_AMBER_AMB2560 },
175 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_ARGUSISP },
176 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_ARKHAM_DS101_A },
177 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_ARKHAM_DS101_M },
178 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_ARYGON_MIFARE },
179 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_AVIT_USB_TTL },
180 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_BALLUFF_RFID },
181 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_BEI_VCP },
182 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_BSM7DUSB },
183 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_B_G_H3000 },
184 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_C2_EDGE_MODEM },
185 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_CELDEVKIT },
186 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_CP210X_1 },
187 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_CP210X_2 },
188 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_CP210X_3 },
189 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_CRUMB128 },
190 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_CYGNAL },
191 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_CYGNAL_DEBUG },
192 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_CYGNAL_GPS },
193 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_DEGREECONT },
194 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_DEKTEK_DTAPLUS },
195 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_DESKTOPMOBILE },
196 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_EDG1228 },
197 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_EM357 },
198 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_EM357LR },
199 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_EMS_C1007 },
200 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_GSM2228 },
201 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_HAMLINKUSB },
202 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_HUBZ },
203 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_IMS_USB_RS422 },
204 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_INFINITY_MIC },
205 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_INSYS_MODEM },
206 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_IPLINK1220 },
207 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_IRZ_SG10 },
208 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_JUNIPER_BX_CONS },
209 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_KCF_PRN },
210 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_KETRA_N1 },
211 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_KYOCERA_GPS },
212 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_LIPOWSKY_HARP },
213 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_LIPOWSKY_JTAG },
214 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_LIPOWSKY_LIN },
215 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_MC35PU },
216 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_MJS_TOSLINK },
217 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_MMB_ZIGBEE },
218 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_MSD_DASHHAWK },
219 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_MULTIPLEX_RC },
220 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_OPTRIS_MSPRO },
221 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_PII_ZIGBEE },
222 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_PLUGDRIVE },
223 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_POLOLU },
224 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_PREON32 },
225 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_PROCYON_AVS },
226 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_RIGBLASTER },
227 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_RIGTALK },
228 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_SB_PARAMOUNT_ME },
229 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_SB_PARAMOUNT_ME2 },
230 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_SUUNTO },
231 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_TAMSMASTER },
232 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_TELEGESIS_ETRX2 },
233 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_TRACIENT },
234 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_TRAQMATE },
235 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_USBCOUNT50 },
236 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_USBPULSE100 },
237 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_USBSCOPE50 },
238 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_USBWAVE12 },
239 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_VSTABI },
240 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_WAVIT },
241 { USB_VENDOR_SILABS, USB_PRODUCT_SILABS_ZEPHYR_BIO },
242 { USB_VENDOR_SILABS2, USB_PRODUCT_SILABS2_DCU11CLONE },
243 { USB_VENDOR_SILABS3, USB_PRODUCT_SILABS3_GPRS_MODEM },
244 { USB_VENDOR_SILABS4, USB_PRODUCT_SILABS4_100EU_MODEM },
245 { USB_VENDOR_SILABS5, USB_PRODUCT_SILABS5_EM358X },
246 { USB_VENDOR_SYNTECH, USB_PRODUCT_SYNTECH_CIPHERLAB100 },
247 { USB_VENDOR_USI, USB_PRODUCT_USI_MC60 },
248 { USB_VENDOR_VAISALA, USB_PRODUCT_VAISALA_USBINSTCABLE },
249 { USB_VENDOR_VOTI, USB_PRODUCT_VOTI_SELETEK_1 },
250 { USB_VENDOR_VOTI, USB_PRODUCT_VOTI_SELETEK_2 },
251 { USB_VENDOR_WAGO, USB_PRODUCT_WAGO_SERVICECABLE },
252 { USB_VENDOR_WAVESENSE, USB_PRODUCT_WAVESENSE_JAZZ },
253 { USB_VENDOR_WIENERPLEINBAUS, USB_PRODUCT_WIENERPLEINBAUS_CML },
254 { USB_VENDOR_WIENERPLEINBAUS, USB_PRODUCT_WIENERPLEINBAUS_MPOD },
255 { USB_VENDOR_WIENERPLEINBAUS, USB_PRODUCT_WIENERPLEINBAUS_PL512 },
256 { USB_VENDOR_WIENERPLEINBAUS, USB_PRODUCT_WIENERPLEINBAUS_RCM },
257 { USB_VENDOR_WMR, USB_PRODUCT_WMR_RIGBLASTER },
258};
259
260int uslcom_match(struct device *, void *, void *);
261void uslcom_attach(struct device *, struct device *, void *);
262int uslcom_detach(struct device *, int);
263
264struct cfdriver uslcom_cd = {
265 NULL, "uslcom", DV_DULL
266};
267
268const struct cfattach uslcom_ca = {
269 sizeof(struct uslcom_softc), uslcom_match, uslcom_attach, uslcom_detach
270};
271
272int
273uslcom_match(struct device *parent, void *match, void *aux)
274{
275 struct usb_attach_arg *uaa = aux;
276
277 if (uaa->iface == NULL)
278 return UMATCH_NONE;
279
280 return (usb_lookup(uslcom_devs, uaa->vendor, uaa->product) != NULL) ?
281 UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
282}
283
284void
285uslcom_attach(struct device *parent, struct device *self, void *aux)
286{
287 struct uslcom_softc *sc = (struct uslcom_softc *)self;
288 struct usb_attach_arg *uaa = aux;
289 struct ucom_attach_args uca;
290 usb_interface_descriptor_t *id;
291 usb_endpoint_descriptor_t *ed;
292 int i;
293
294 bzero(&uca, sizeof(uca));
295 sc->sc_udev = uaa->device;
296 sc->sc_iface = uaa->iface;
297
298 id = usbd_get_interface_descriptor(sc->sc_iface);
299
300 uca.bulkin = uca.bulkout = -1;
301 for (i = 0; i < id->bNumEndpoints; i++) {
302 ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
303 if (ed == NULL) {
304 printf("%s: no endpoint descriptor found for %d\n",
305 sc->sc_dev.dv_xname, i);
306 usbd_deactivate(sc->sc_udev);
307 return;
308 }
309
310 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
311 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
312 uca.bulkin = ed->bEndpointAddress;
313 else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
314 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
315 uca.bulkout = ed->bEndpointAddress;
316 }
317
318 if (uca.bulkin == -1 || uca.bulkout == -1) {
319 printf("%s: missing endpoint\n", sc->sc_dev.dv_xname);
320 usbd_deactivate(sc->sc_udev);
321 return;
322 }
323
324 uca.portno = id->bInterfaceNumber;
325 uca.ibufsize = USLCOMBUFSZ;
326 uca.obufsize = USLCOMBUFSZ;
327 uca.ibufsizepad = USLCOMBUFSZ;
328 uca.opkthdrlen = 0;
329 uca.device = sc->sc_udev;
330 uca.iface = sc->sc_iface;
331 uca.methods = &uslcom_methods;
332 uca.arg = sc;
333 uca.info = NULL;
334
335 sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
336}
337
338int
339uslcom_detach(struct device *self, int flags)
340{
341 struct uslcom_softc *sc = (struct uslcom_softc *)self;
342 int rv = 0;
343
344 if (sc->sc_subdev != NULL) {
345 rv = config_detach(sc->sc_subdev, flags);
346 sc->sc_subdev = NULL;
347 }
348
349 return (rv);
350}
351
352int
353uslcom_open(void *vsc, int portno)
354{
355 struct uslcom_softc *sc = vsc;
356 usb_device_request_t req;
357 usbd_status err;
358
359 if (usbd_is_dying(sc->sc_udev))
360 return (EIO);
361
362 req.bmRequestType = USLCOM_WRITE;
363 req.bRequest = USLCOM_UART;
364 USETW(req.wValue, USLCOM_UART_ENABLE);
365 USETW(req.wIndex, portno);
366 USETW(req.wLength, 0);
367 err = usbd_do_request(sc->sc_udev, &req, NULL);
368 if (err)
369 return (EIO);
370
371 return (0);
372}
373
374void
375uslcom_close(void *vsc, int portno)
376{
377 struct uslcom_softc *sc = vsc;
378 usb_device_request_t req;
379
380 if (usbd_is_dying(sc->sc_udev))
381 return;
382
383 req.bmRequestType = USLCOM_WRITE;
384 req.bRequest = USLCOM_UART;
385 USETW(req.wValue, USLCOM_UART_DISABLE);
386 USETW(req.wIndex, portno);
387 USETW(req.wLength, 0);
388 usbd_do_request(sc->sc_udev, &req, NULL);
389}
390
391void
392uslcom_set(void *vsc, int portno, int reg, int onoff)
393{
394 struct uslcom_softc *sc = vsc;
395 usb_device_request_t req;
396 int ctl;
397
398 switch (reg) {
399 case UCOM_SET_DTR:
400 ctl = onoff ? USLCOM_CTRL_DTR_ON : 0;
401 ctl |= USLCOM_CTRL_DTR_SET;
402 break;
403 case UCOM_SET_RTS:
404 ctl = onoff ? USLCOM_CTRL_RTS_ON : 0;
405 ctl |= USLCOM_CTRL_RTS_SET;
406 break;
407 case UCOM_SET_BREAK:
408 uslcom_break(sc, portno, onoff);
409 return;
410 default:
411 return;
412 }
413 req.bmRequestType = USLCOM_WRITE;
414 req.bRequest = USLCOM_CTRL;
415 USETW(req.wValue, ctl);
416 USETW(req.wIndex, portno);
417 USETW(req.wLength, 0);
418 usbd_do_request(sc->sc_udev, &req, NULL);
419}
420
421int
422uslcom_param(void *vsc, int portno, struct termios *t)
423{
424 struct uslcom_softc *sc = (struct uslcom_softc *)vsc;
425 usbd_status err;
426 usb_device_request_t req;
427 uint32_t baudrate, flowctrl[4];
428 int data;
429
430 if (t->c_ospeed <= 0 || t->c_ospeed > 2000000)
431 return (EINVAL);
432
433 baudrate = t->c_ospeed;
434 req.bmRequestType = USLCOM_WRITE;
435 req.bRequest = USLCOM_SET_BAUD_RATE;
436 USETW(req.wValue, 0);
437 USETW(req.wIndex, portno);
438 USETW(req.wLength, sizeof(baudrate));
439 err = usbd_do_request(sc->sc_udev, &req, &baudrate);
440 if (err)
441 return (EIO);
442
443 if (ISSET(t->c_cflag, CSTOPB))
444 data = USLCOM_STOP_BITS_2;
445 else
446 data = USLCOM_STOP_BITS_1;
447 if (ISSET(t->c_cflag, PARENB)) {
448 if (ISSET(t->c_cflag, PARODD))
449 data |= USLCOM_PARITY_ODD;
450 else
451 data |= USLCOM_PARITY_EVEN;
452 } else
453 data |= USLCOM_PARITY_NONE;
454 switch (ISSET(t->c_cflag, CSIZE)) {
455 case CS5:
456 data |= USLCOM_SET_DATA_BITS(5);
457 break;
458 case CS6:
459 data |= USLCOM_SET_DATA_BITS(6);
460 break;
461 case CS7:
462 data |= USLCOM_SET_DATA_BITS(7);
463 break;
464 case CS8:
465 data |= USLCOM_SET_DATA_BITS(8);
466 break;
467 }
468
469 req.bmRequestType = USLCOM_WRITE;
470 req.bRequest = USLCOM_DATA;
471 USETW(req.wValue, data);
472 USETW(req.wIndex, portno);
473 USETW(req.wLength, 0);
474 err = usbd_do_request(sc->sc_udev, &req, NULL);
475 if (err)
476 return (EIO);
477
478 if (ISSET(t->c_cflag, CRTSCTS)) {
479 /* rts/cts flow ctl */
480 flowctrl[0] = htole32(USLCOM_FLOW_DTR_ON | USLCOM_FLOW_CTS_HS);
481 flowctrl[1] = htole32(USLCOM_FLOW_RTS_HS);
482 } else {
483 /* disable flow ctl */
484 flowctrl[0] = htole32(USLCOM_FLOW_DTR_ON);
485 flowctrl[1] = htole32(USLCOM_FLOW_RTS_ON);
486 }
487 flowctrl[2] = 0;
488 flowctrl[3] = 0;
489
490 req.bmRequestType = USLCOM_WRITE;
491 req.bRequest = USLCOM_SET_FLOW;
492 USETW(req.wValue, 0);
493 USETW(req.wIndex, portno);
494 USETW(req.wLength, sizeof(flowctrl));
495 err = usbd_do_request(sc->sc_udev, &req, flowctrl);
496 if (err)
497 return (EIO);
498
499 return (0);
500}
501
502void
503uslcom_get_status(void *vsc, int portno, u_char *lsr, u_char *msr)
504{
505 struct uslcom_softc *sc = vsc;
506
507 if (msr != NULL)
508 *msr = sc->sc_msr;
509 if (lsr != NULL)
510 *lsr = sc->sc_lsr;
511}
512
513void
514uslcom_break(void *vsc, int portno, int onoff)
515{
516 struct uslcom_softc *sc = vsc;
517 usb_device_request_t req;
518 int brk = onoff ? USLCOM_BREAK_ON : USLCOM_BREAK_OFF;
519
520 req.bmRequestType = USLCOM_WRITE;
521 req.bRequest = USLCOM_BREAK;
522 USETW(req.wValue, brk);
523 USETW(req.wIndex, portno);
524 USETW(req.wLength, 0);
525 usbd_do_request(sc->sc_udev, &req, NULL);
526}