1 /* $OpenBSD: umct.c,v 1.13 2004/09/20 21:34:46 deraadt 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/select.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)) logprintf 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 USBBASEDEVICE 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 device_ptr_t 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 Static void umct_init(struct umct_softc *);
120 Static void umct_set_baudrate(struct umct_softc *, u_int);
121 Static void umct_set_lcr(struct umct_softc *, u_int);
122 Static void umct_intr(usbd_xfer_handle, usbd_private_handle, usbd_status);
123
124 Static void umct_set(void *, int, int, int);
125 Static void umct_dtr(struct umct_softc *, int);
126 Static void umct_rts(struct umct_softc *, int);
127 Static void umct_break(struct umct_softc *, int);
128 Static void umct_set_line_state(struct umct_softc *);
129 Static void umct_get_status(void *, int portno, u_char *lsr, u_char *msr);
130 Static int umct_param(void *, int, struct termios *);
131 Static int umct_open(void *, int);
132 Static 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 USB_DECLARE_DRIVER(umct);
160
USB_MATCH(umct)161 USB_MATCH(umct)
162 {
163 USB_MATCH_START(umct, uaa);
164
165 if (uaa->iface != NULL)
166 return (UMATCH_NONE);
167
168 return (umct_lookup(uaa->vendor, uaa->product) != NULL ?
169 UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
170 }
171
USB_ATTACH(umct)172 USB_ATTACH(umct)
173 {
174 USB_ATTACH_START(umct, sc, uaa);
175 usbd_device_handle dev = uaa->device;
176 usb_config_descriptor_t *cdesc;
177 usb_interface_descriptor_t *id;
178 usb_endpoint_descriptor_t *ed;
179
180 char devinfo[1024];
181 char *devname = USBDEVNAME(sc->sc_dev);
182 usbd_status err;
183 int i;
184 struct ucom_attach_args uca;
185
186 usbd_devinfo(dev, 0, devinfo, sizeof devinfo);
187 USB_ATTACH_SETUP;
188 printf("%s: %s\n", devname, devinfo);
189
190 sc->sc_udev = dev;
191 sc->sc_product = uaa->product;
192
193 DPRINTF(("\n\numct attach: sc=%p\n", sc));
194
195 /* initialize endpoints */
196 uca.bulkin = uca.bulkout = -1;
197 sc->sc_intr_number = -1;
198 sc->sc_intr_pipe = NULL;
199
200 /* Move the device into the configured state. */
201 err = usbd_set_config_index(dev, UMCT_CONFIG_INDEX, 1);
202 if (err) {
203 printf("\n%s: failed to set configuration, err=%s\n",
204 devname, usbd_errstr(err));
205 sc->sc_dying = 1;
206 USB_ATTACH_ERROR_RETURN;
207 }
208
209 /* get the config descriptor */
210 cdesc = usbd_get_config_descriptor(sc->sc_udev);
211
212 if (cdesc == NULL) {
213 printf("%s: failed to get configuration descriptor\n",
214 USBDEVNAME(sc->sc_dev));
215 sc->sc_dying = 1;
216 USB_ATTACH_ERROR_RETURN;
217 }
218
219 /* get the interface */
220 err = usbd_device2interface_handle(dev, UMCT_IFACE_INDEX,
221 &sc->sc_iface);
222 if (err) {
223 printf("\n%s: failed to get interface, err=%s\n",
224 devname, usbd_errstr(err));
225 sc->sc_dying = 1;
226 USB_ATTACH_ERROR_RETURN;
227 }
228
229 /* Find the bulk{in,out} and interrupt endpoints */
230
231 id = usbd_get_interface_descriptor(sc->sc_iface);
232 sc->sc_iface_number = id->bInterfaceNumber;
233
234 for (i = 0; i < id->bNumEndpoints; i++) {
235 ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
236 if (ed == NULL) {
237 printf("%s: no endpoint descriptor for %d\n",
238 USBDEVNAME(sc->sc_dev), i);
239 sc->sc_dying = 1;
240 USB_ATTACH_ERROR_RETURN;
241 }
242
243 /*
244 * The Bulkin endpoint is marked as an interrupt. Since
245 * we can't rely on the endpoint descriptor order, we'll
246 * check the wMaxPacketSize field to differentiate.
247 */
248 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
249 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT &&
250 UGETW(ed->wMaxPacketSize) != 0x2) {
251 uca.bulkin = ed->bEndpointAddress;
252 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
253 UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
254 uca.bulkout = ed->bEndpointAddress;
255 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
256 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
257 sc->sc_intr_number = ed->bEndpointAddress;
258 sc->sc_isize = UGETW(ed->wMaxPacketSize);
259 }
260 }
261
262 if (uca.bulkin == -1) {
263 printf("%s: Could not find data bulk in\n",
264 USBDEVNAME(sc->sc_dev));
265 sc->sc_dying = 1;
266 USB_ATTACH_ERROR_RETURN;
267 }
268
269 if (uca.bulkout == -1) {
270 printf("%s: Could not find data bulk out\n",
271 USBDEVNAME(sc->sc_dev));
272 sc->sc_dying = 1;
273 USB_ATTACH_ERROR_RETURN;
274 }
275
276 if (sc->sc_intr_number== -1) {
277 printf("%s: Could not find interrupt in\n",
278 USBDEVNAME(sc->sc_dev));
279 sc->sc_dying = 1;
280 USB_ATTACH_ERROR_RETURN;
281 }
282
283 sc->sc_dtr = sc->sc_rts = 0;
284 uca.portno = UCOM_UNK_PORTNO;
285 /* bulkin, bulkout set above */
286 uca.ibufsize = UMCTIBUFSIZE;
287 if (sc->sc_product == USB_PRODUCT_MCT_SITECOM_USB232)
288 uca.obufsize = 16; /* device is broken */
289 else
290 uca.obufsize = UMCTOBUFSIZE;
291 uca.ibufsizepad = UMCTIBUFSIZE;
292 uca.opkthdrlen = 0;
293 uca.device = dev;
294 uca.iface = sc->sc_iface;
295 uca.methods = &umct_methods;
296 uca.arg = sc;
297 uca.info = NULL;
298
299 umct_init(sc);
300
301 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
302 USBDEV(sc->sc_dev));
303
304 DPRINTF(("umct: in=0x%x out=0x%x intr=0x%x\n",
305 uca.bulkin, uca.bulkout, sc->sc_intr_number ));
306 sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
307
308 USB_ATTACH_SUCCESS_RETURN;
309 }
310
USB_DETACH(umct)311 USB_DETACH(umct)
312 {
313 USB_DETACH_START(umct, sc);
314 int rv = 0;
315
316 DPRINTF(("umct_detach: sc=%p flags=%d\n", sc, flags));
317
318 if (sc->sc_intr_pipe != NULL) {
319 usbd_abort_pipe(sc->sc_intr_pipe);
320 usbd_close_pipe(sc->sc_intr_pipe);
321 free(sc->sc_intr_buf, M_USBDEV);
322 sc->sc_intr_pipe = NULL;
323 }
324
325 sc->sc_dying = 1;
326 if (sc->sc_subdev != NULL) {
327 rv = config_detach(sc->sc_subdev, flags);
328 sc->sc_subdev = NULL;
329 }
330
331 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
332 USBDEV(sc->sc_dev));
333
334 return (rv);
335 }
336
337 int
umct_activate(device_ptr_t self,enum devact act)338 umct_activate(device_ptr_t self, enum devact act)
339 {
340 struct umct_softc *sc = (struct umct_softc *)self;
341 int rv = 0;
342
343 switch (act) {
344 case DVACT_ACTIVATE:
345 return (EOPNOTSUPP);
346
347 case DVACT_DEACTIVATE:
348 if (sc->sc_subdev != NULL)
349 rv = config_deactivate(sc->sc_subdev);
350 sc->sc_dying = 1;
351 break;
352 }
353 return (rv);
354 }
355
356 void
umct_set_line_state(struct umct_softc * sc)357 umct_set_line_state(struct umct_softc *sc)
358 {
359 usb_device_request_t req;
360 uByte ls;
361
362 ls = (sc->sc_dtr ? MCR_DTR : 0) |
363 (sc->sc_rts ? MCR_RTS : 0);
364
365 DPRINTF(("umct_set_line_state: DTR=%d,RTS=%d,ls=%02x\n",
366 sc->sc_dtr, sc->sc_rts, ls));
367
368 req.bmRequestType = UMCT_SET_REQUEST;
369 req.bRequest = REQ_SET_MCR;
370 USETW(req.wValue, 0);
371 USETW(req.wIndex, sc->sc_iface_number);
372 USETW(req.wLength, LENGTH_SET_MCR);
373
374 (void)usbd_do_request(sc->sc_udev, &req, &ls);
375 }
376
377 void
umct_set(void * addr,int portno,int reg,int onoff)378 umct_set(void *addr, int portno, int reg, int onoff)
379 {
380 struct umct_softc *sc = addr;
381
382 switch (reg) {
383 case UCOM_SET_DTR:
384 umct_dtr(sc, onoff);
385 break;
386 case UCOM_SET_RTS:
387 umct_rts(sc, onoff);
388 break;
389 case UCOM_SET_BREAK:
390 umct_break(sc, onoff);
391 break;
392 default:
393 break;
394 }
395 }
396
397 void
umct_dtr(struct umct_softc * sc,int onoff)398 umct_dtr(struct umct_softc *sc, int onoff)
399 {
400
401 DPRINTF(("umct_dtr: onoff=%d\n", onoff));
402
403 if (sc->sc_dtr == onoff)
404 return;
405 sc->sc_dtr = onoff;
406
407 umct_set_line_state(sc);
408 }
409
410 void
umct_rts(struct umct_softc * sc,int onoff)411 umct_rts(struct umct_softc *sc, int onoff)
412 {
413 DPRINTF(("umct_rts: onoff=%d\n", onoff));
414
415 if (sc->sc_rts == onoff)
416 return;
417 sc->sc_rts = onoff;
418
419 umct_set_line_state(sc);
420 }
421
422 void
umct_break(struct umct_softc * sc,int onoff)423 umct_break(struct umct_softc *sc, int onoff)
424 {
425 DPRINTF(("umct_break: onoff=%d\n", onoff));
426
427 umct_set_lcr(sc, onoff ? sc->last_lcr | LCR_SET_BREAK :
428 sc->last_lcr);
429 }
430
431 void
umct_set_lcr(struct umct_softc * sc,u_int data)432 umct_set_lcr(struct umct_softc *sc, u_int data)
433 {
434 usb_device_request_t req;
435 uByte adata;
436
437 adata = data;
438 req.bmRequestType = UMCT_SET_REQUEST;
439 req.bRequest = REQ_SET_LCR;
440 USETW(req.wValue, 0);
441 USETW(req.wIndex, sc->sc_iface_number);
442 USETW(req.wLength, LENGTH_SET_LCR);
443
444 /* XXX should check */
445 (void)usbd_do_request(sc->sc_udev, &req, &adata);
446 }
447
448 void
umct_set_baudrate(struct umct_softc * sc,u_int rate)449 umct_set_baudrate(struct umct_softc *sc, u_int rate)
450 {
451 usb_device_request_t req;
452 uDWord arate;
453 u_int val;
454
455 if (sc->sc_product == USB_PRODUCT_MCT_SITECOM_USB232 ||
456 sc->sc_product == USB_PRODUCT_BELKIN_F5U109) {
457 switch (rate) {
458 case 300: val = 0x01; break;
459 case 600: val = 0x02; break;
460 case 1200: val = 0x03; break;
461 case 2400: val = 0x04; break;
462 case 4800: val = 0x06; break;
463 case 9600: val = 0x08; break;
464 case 19200: val = 0x09; break;
465 case 38400: val = 0x0a; break;
466 case 57600: val = 0x0b; break;
467 case 115200: val = 0x0c; break;
468 default: val = -1; break;
469 }
470 } else {
471 val = UMCT_BAUD_RATE(rate);
472 }
473 USETDW(arate, val);
474
475 req.bmRequestType = UMCT_SET_REQUEST;
476 req.bRequest = REQ_SET_BAUD_RATE;
477 USETW(req.wValue, 0);
478 USETW(req.wIndex, sc->sc_iface_number);
479 USETW(req.wLength, LENGTH_BAUD_RATE);
480
481 /* XXX should check */
482 (void)usbd_do_request(sc->sc_udev, &req, arate);
483 }
484
485 void
umct_init(struct umct_softc * sc)486 umct_init(struct umct_softc *sc)
487 {
488 umct_set_baudrate(sc, 9600);
489 umct_set_lcr(sc, LCR_DATA_BITS_8 | LCR_PARITY_NONE | LCR_STOP_BITS_1);
490 }
491
492 int
umct_param(void * addr,int portno,struct termios * t)493 umct_param(void *addr, int portno, struct termios *t)
494 {
495 struct umct_softc *sc = addr;
496 u_int data = 0;
497
498 DPRINTF(("umct_param: sc=%p\n", sc));
499
500 DPRINTF(("umct_param: BAUDRATE=%d\n", t->c_ospeed));
501
502 if (ISSET(t->c_cflag, CSTOPB))
503 data |= LCR_STOP_BITS_2;
504 else
505 data |= LCR_STOP_BITS_1;
506 if (ISSET(t->c_cflag, PARENB)) {
507 if (ISSET(t->c_cflag, PARODD))
508 data |= LCR_PARITY_ODD;
509 else
510 data |= LCR_PARITY_EVEN;
511 } else
512 data |= LCR_PARITY_NONE;
513 switch (ISSET(t->c_cflag, CSIZE)) {
514 case CS5:
515 data |= LCR_DATA_BITS_5;
516 break;
517 case CS6:
518 data |= LCR_DATA_BITS_6;
519 break;
520 case CS7:
521 data |= LCR_DATA_BITS_7;
522 break;
523 case CS8:
524 data |= LCR_DATA_BITS_8;
525 break;
526 }
527
528 umct_set_baudrate(sc, t->c_ospeed);
529
530 sc->last_lcr = data;
531 umct_set_lcr(sc, data);
532
533 return (0);
534 }
535
536 int
umct_open(void * addr,int portno)537 umct_open(void *addr, int portno)
538 {
539 struct umct_softc *sc = addr;
540 int err, lcr_data;
541
542 if (sc->sc_dying)
543 return (EIO);
544
545 DPRINTF(("umct_open: sc=%p\n", sc));
546
547 /* initialize LCR */
548 lcr_data = LCR_DATA_BITS_8 | LCR_PARITY_NONE |
549 LCR_STOP_BITS_1;
550 umct_set_lcr(sc, lcr_data);
551
552 if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) {
553 sc->sc_status = 0; /* clear status bit */
554 sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);
555 err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_intr_number,
556 USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc,
557 sc->sc_intr_buf, sc->sc_isize,
558 umct_intr, USBD_DEFAULT_INTERVAL);
559 if (err) {
560 DPRINTF(("%s: cannot open interrupt pipe (addr %d)\n",
561 USBDEVNAME(sc->sc_dev), sc->sc_intr_number));
562 return (EIO);
563 }
564 }
565
566 return (0);
567 }
568
569 void
umct_close(void * addr,int portno)570 umct_close(void *addr, int portno)
571 {
572 struct umct_softc *sc = addr;
573 int err;
574
575 if (sc->sc_dying)
576 return;
577
578 DPRINTF(("umct_close: close\n"));
579
580 if (sc->sc_intr_pipe != NULL) {
581 err = usbd_abort_pipe(sc->sc_intr_pipe);
582 if (err)
583 printf("%s: abort interrupt pipe failed: %s\n",
584 USBDEVNAME(sc->sc_dev), usbd_errstr(err));
585 err = usbd_close_pipe(sc->sc_intr_pipe);
586 if (err)
587 printf("%s: close interrupt pipe failed: %s\n",
588 USBDEVNAME(sc->sc_dev), usbd_errstr(err));
589 free(sc->sc_intr_buf, M_USBDEV);
590 sc->sc_intr_pipe = NULL;
591 }
592 }
593
594 void
umct_intr(usbd_xfer_handle xfer,usbd_private_handle priv,usbd_status status)595 umct_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
596 {
597 struct umct_softc *sc = priv;
598 u_char *buf = sc->sc_intr_buf;
599 u_char mstatus;
600
601 if (sc->sc_dying)
602 return;
603
604 if (status != USBD_NORMAL_COMPLETION) {
605 if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
606 return;
607
608 DPRINTF(("%s: abnormal status: %s\n", USBDEVNAME(sc->sc_dev),
609 usbd_errstr(status)));
610 usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
611 return;
612 }
613
614 DPRINTF(("%s: umct status = MSR:%02x, LSR:%02x\n",
615 USBDEVNAME(sc->sc_dev), buf[0],buf[1]));
616
617 sc->sc_lsr = sc->sc_msr = 0;
618 mstatus = buf[0];
619 if (ISSET(mstatus, MSR_DSR))
620 sc->sc_msr |= UMSR_DSR;
621 if (ISSET(mstatus, MSR_DCD))
622 sc->sc_msr |= UMSR_DCD;
623 ucom_status_change((struct ucom_softc *)sc->sc_subdev);
624 }
625
626 void
umct_get_status(void * addr,int portno,u_char * lsr,u_char * msr)627 umct_get_status(void *addr, int portno, u_char *lsr, u_char *msr)
628 {
629 struct umct_softc *sc = addr;
630
631 DPRINTF(("umct_get_status:\n"));
632
633 if (lsr != NULL)
634 *lsr = sc->sc_lsr;
635 if (msr != NULL)
636 *msr = sc->sc_msr;
637 }
638