Add moscom(4) - the driver for MosChip Semiconductor MCS7703 USB to
[dragonfly.git] / sys / dev / usbmisc / moscom / moscom.c
1 /* $OpenBSD: src/sys/dev/usb/moscom.c,v 1.11 2007/10/11 18:33:14 deraadt Exp $ */
2 /* $DragonFly: src/sys/dev/usbmisc/moscom/moscom.c,v 1.1 2007/11/07 08:57:18 hasso Exp $ */
3
4 /*
5  * Copyright (c) 2006 Jonathan Gray <jsg@openbsd.org>
6  *
7  * Permission to use, copy, modify, and distribute this software for any
8  * purpose with or without fee is hereby granted, provided that the above
9  * copyright notice and this permission notice appear in all copies.
10  *
11  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18  */
19
20 #include <sys/param.h>
21 #include <sys/systm.h>
22 #include <sys/kernel.h>
23 #include <sys/conf.h>
24 #include <sys/tty.h>
25 #include <sys/device.h>
26 #include <sys/types.h>
27 #include <sys/bus.h>
28 #include <sys/module.h>
29
30 #include <bus/usb/usb.h>
31 #include <bus/usb/usbdi.h>
32 #include <bus/usb/usbdi_util.h>
33
34 #include <dev/usbmisc/ucom/ucomvar.h>
35
36 #define MOSCOMBUFSZ             256
37 #define MOSCOM_CONFIG_NO        0
38 #define MOSCOM_IFACE_NO         0
39
40 #define MOSCOM_READ             0x0d
41 #define MOSCOM_WRITE            0x0e
42 #define MOSCOM_UART_REG         0x0300
43 #define MOSCOM_VEND_REG         0x0000
44
45 #define MOSCOM_TXBUF            0x00    /* Write */
46 #define MOSCOM_RXBUF            0x00    /* Read */
47 #define MOSCOM_INT              0x01
48 #define MOSCOM_FIFO             0x02    /* Write */
49 #define MOSCOM_ISR              0x02    /* Read */
50 #define MOSCOM_LCR              0x03
51 #define MOSCOM_MCR              0x04
52 #define MOSCOM_LSR              0x05
53 #define MOSCOM_MSR              0x06
54 #define MOSCOM_SCRATCH          0x07
55 #define MOSCOM_DIV_LO           0x08
56 #define MOSCOM_DIV_HI           0x09
57 #define MOSCOM_EFR              0x0a
58 #define MOSCOM_XON1             0x0b
59 #define MOSCOM_XON2             0x0c
60 #define MOSCOM_XOFF1            0x0d
61 #define MOSCOM_XOFF2            0x0e
62
63 #define MOSCOM_BAUDLO           0x00
64 #define MOSCOM_BAUDHI           0x01
65
66 #define MOSCOM_INT_RXEN         0x01
67 #define MOSCOM_INT_TXEN         0x02
68 #define MOSCOM_INT_RSEN         0x04    
69 #define MOSCOM_INT_MDMEM        0x08
70 #define MOSCOM_INT_SLEEP        0x10
71 #define MOSCOM_INT_XOFF         0x20
72 #define MOSCOM_INT_RTS          0x40    
73
74 #define MOSCOM_FIFO_EN          0x01
75 #define MOSCOM_FIFO_RXCLR       0x02
76 #define MOSCOM_FIFO_TXCLR       0x04
77 #define MOSCOM_FIFO_DMA_BLK     0x08
78 #define MOSCOM_FIFO_TXLVL_MASK  0x30
79 #define MOSCOM_FIFO_TXLVL_8     0x00
80 #define MOSCOM_FIFO_TXLVL_16    0x10
81 #define MOSCOM_FIFO_TXLVL_32    0x20
82 #define MOSCOM_FIFO_TXLVL_56    0x30
83 #define MOSCOM_FIFO_RXLVL_MASK  0xc0
84 #define MOSCOM_FIFO_RXLVL_8     0x00
85 #define MOSCOM_FIFO_RXLVL_16    0x40
86 #define MOSCOM_FIFO_RXLVL_56    0x80
87 #define MOSCOM_FIFO_RXLVL_80    0xc0
88
89 #define MOSCOM_ISR_MDM          0x00
90 #define MOSCOM_ISR_NONE         0x01
91 #define MOSCOM_ISR_TX           0x02
92 #define MOSCOM_ISR_RX           0x04
93 #define MOSCOM_ISR_LINE         0x06
94 #define MOSCOM_ISR_RXTIMEOUT    0x0c
95 #define MOSCOM_ISR_RX_XOFF      0x10
96 #define MOSCOM_ISR_RTSCTS       0x20
97 #define MOSCOM_ISR_FIFOEN       0xc0
98
99 #define MOSCOM_LCR_DBITS(x)     (x - 5)
100 #define MOSCOM_LCR_STOP_BITS_1  0x00
101 #define MOSCOM_LCR_STOP_BITS_2  0x04    /* 2 if 6-8 bits/char or 1.5 if 5 */
102 #define MOSCOM_LCR_PARITY_NONE  0x00
103 #define MOSCOM_LCR_PARITY_ODD   0x08
104 #define MOSCOM_LCR_PARITY_EVEN  0x18
105 #define MOSCOM_LCR_BREAK        0x40
106 #define MOSCOM_LCR_DIVLATCH_EN  0x80
107
108 #define MOSCOM_MCR_DTR          0x01
109 #define MOSCOM_MCR_RTS          0x02
110 #define MOSCOM_MCR_LOOP         0x04
111 #define MOSCOM_MCR_INTEN        0x08
112 #define MOSCOM_MCR_LOOPBACK     0x10
113 #define MOSCOM_MCR_XONANY       0x20
114 #define MOSCOM_MCR_IRDA_EN      0x40
115 #define MOSCOM_MCR_BAUD_DIV4    0x80
116
117 #define MOSCOM_LSR_RXDATA       0x01
118 #define MOSCOM_LSR_RXOVER       0x02
119 #define MOSCOM_LSR_RXPAR_ERR    0x04
120 #define MOSCOM_LSR_RXFRM_ERR    0x08
121 #define MOSCOM_LSR_RXBREAK      0x10
122 #define MOSCOM_LSR_TXEMPTY      0x20
123 #define MOSCOM_LSR_TXALLEMPTY   0x40
124 #define MOSCOM_LSR_TXFIFO_ERR   0x80
125
126 #define MOSCOM_MSR_CTS_CHG      0x01
127 #define MOSCOM_MSR_DSR_CHG      0x02
128 #define MOSCOM_MSR_RI_CHG       0x04
129 #define MOSCOM_MSR_CD_CHG       0x08
130 #define MOSCOM_MSR_CTS          0x10
131 #define MOSCOM_MSR_RTS          0x20
132 #define MOSCOM_MSR_RI           0x40
133 #define MOSCOM_MSR_CD           0x80
134
135 #define MOSCOM_BAUD_REF         115200
136
137 struct moscom_softc {
138         struct ucom_softc       sc_ucom;
139         u_char                  sc_msr;
140         u_char                  sc_lsr;
141         u_char                  sc_lcr;
142 };
143
144 static void     moscom_get_status(void *, int, u_char *, u_char *);
145 static void     moscom_set(void *, int, int, int);
146 static int      moscom_param(void *, int, struct termios *);
147 static int      moscom_open(void *, int);
148 static int      moscom_cmd(struct moscom_softc *, int, int);    
149
150 struct ucom_callback moscom_callback = {
151         moscom_get_status,
152         moscom_set,
153         moscom_param,
154         NULL,
155         moscom_open,
156         NULL,
157         NULL,
158         NULL,
159 };
160
161 static const struct usb_devno moscom_devs[] = {
162         { USB_DEVICE(0x9710, 0x7703) }  /* MosChip MCS7703 serial port */
163 };
164
165 static device_probe_t moscom_match;
166 static device_attach_t moscom_attach;
167 static device_detach_t moscom_detach;
168
169 static device_method_t moscom_methods[] = {
170         DEVMETHOD(device_probe, moscom_match),
171         DEVMETHOD(device_attach, moscom_attach),
172         DEVMETHOD(device_detach, moscom_detach),
173         { 0, 0 }
174 };
175
176 static driver_t moscom_driver = {
177         "ucom",
178         moscom_methods,
179         sizeof (struct moscom_softc)
180 };
181
182 DRIVER_MODULE(moscom, uhub, moscom_driver, ucom_devclass, usbd_driver_load, 0);
183 MODULE_DEPEND(moscom, usb, 1, 1, 1);
184 MODULE_DEPEND(moscom, ucom, UCOM_MINVER, UCOM_PREFVER, UCOM_MAXVER);
185 MODULE_VERSION(moscom, 1);
186
187 static int
188 moscom_match(device_t self)
189 {
190         struct usb_attach_arg *uaa = device_get_ivars(self);
191
192         if (uaa->iface != NULL)
193                 return UMATCH_NONE;
194
195         return (usb_lookup(moscom_devs, uaa->vendor, uaa->product) != NULL) ?
196             UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
197 }
198
199 static int
200 moscom_attach(device_t self)
201 {
202         struct moscom_softc *sc = device_get_softc(self);
203         struct usb_attach_arg *uaa = device_get_ivars(self);
204         struct ucom_softc *ucom;
205         usb_interface_descriptor_t *id;
206         usb_endpoint_descriptor_t *ed;
207         usbd_status error;
208         int i;
209
210         bzero(sc, sizeof (struct moscom_softc));
211         ucom = &sc->sc_ucom;
212         ucom->sc_dev = self;
213         ucom->sc_udev = uaa->device;
214         ucom->sc_iface = uaa->iface;
215
216         if (usbd_set_config_index(ucom->sc_udev, MOSCOM_CONFIG_NO, 1) != 0) {
217                 device_printf(ucom->sc_dev, "could not set configuration no\n");
218                 ucom->sc_dying = 1;
219                 return ENXIO;
220         }
221
222         /* get the first interface handle */
223         error = usbd_device2interface_handle(ucom->sc_udev, MOSCOM_IFACE_NO,
224             &ucom->sc_iface);
225         if (error != 0) {
226                 device_printf(ucom->sc_dev, "could not get interface handle\n");
227                 ucom->sc_dying = 1;
228                 return ENXIO;
229         }
230
231         id = usbd_get_interface_descriptor(ucom->sc_iface);
232
233         ucom->sc_bulkin_no = ucom->sc_bulkout_no = -1;
234         for (i = 0; i < id->bNumEndpoints; i++) {
235                 ed = usbd_interface2endpoint_descriptor(ucom->sc_iface, i);
236                 if (ed == NULL) {
237                         device_printf(ucom->sc_dev, "no endpoint descriptor "
238                                       "found for %d\n", i);
239                         ucom->sc_dying = 1;
240                         return ENXIO;
241                 }
242
243                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
244                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
245                         ucom->sc_bulkin_no = ed->bEndpointAddress;
246                 else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
247                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
248                         ucom->sc_bulkout_no = ed->bEndpointAddress;
249         }
250
251         if (ucom->sc_bulkin_no == -1 || ucom->sc_bulkout_no == -1) {
252                 device_printf(ucom->sc_dev, "missing endpoint\n");
253                 ucom->sc_dying = 1;
254                 return ENXIO;
255         }
256
257         ucom->sc_parent = sc;
258         ucom->sc_portno = UCOM_UNK_PORTNO;
259         ucom->sc_ibufsize = MOSCOMBUFSZ;
260         ucom->sc_obufsize = MOSCOMBUFSZ;
261         ucom->sc_ibufsizepad = MOSCOMBUFSZ;
262         ucom->sc_opkthdrlen = 0;
263         ucom->sc_callback = &moscom_callback;
264
265         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, ucom->sc_udev,
266                            ucom->sc_dev);
267
268         return 0;
269 }
270
271 static int
272 moscom_detach(device_t self)
273 {
274         struct moscom_softc *sc = device_get_softc(self);
275         int rv = 0;
276
277         sc->sc_ucom.sc_dying = 1;
278         rv = ucom_detach(&sc->sc_ucom);
279         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_ucom.sc_udev,
280                            sc->sc_ucom.sc_dev);
281
282         return (rv);
283 }
284
285 #if 0 /* endif */
286 int
287 moscom_activate(struct device *self, enum devact act)
288 {
289         struct moscom_softc *sc = (struct moscom_softc *)self;
290         int rv = 0;
291
292         switch (act) {
293         case DVACT_ACTIVATE:
294                 break;
295
296         case DVACT_DEACTIVATE:
297                 if (sc->sc_subdev != NULL)
298                         rv = config_deactivate(sc->sc_subdev);
299                 sc->sc_ucom.sc_dying = 1;
300                 break;
301         }
302         return (rv);
303 }
304 #endif
305
306 static int
307 moscom_open(void *vsc, int portno)
308 {
309         struct moscom_softc *sc = vsc;
310         usb_device_request_t req;
311
312         if (sc->sc_ucom.sc_dying)
313                 return (EIO);
314
315         /* Purge FIFOs or odd things happen */
316         if (moscom_cmd(sc, MOSCOM_FIFO, 0x00) != 0)
317                 return (EIO);
318         
319         if (moscom_cmd(sc, MOSCOM_FIFO, MOSCOM_FIFO_EN |
320             MOSCOM_FIFO_RXCLR | MOSCOM_FIFO_TXCLR |
321             MOSCOM_FIFO_DMA_BLK | MOSCOM_FIFO_RXLVL_MASK) != 0) 
322                 return (EIO);
323
324         /* Magic tell device we're ready for data command */
325         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
326         req.bRequest = MOSCOM_WRITE;
327         USETW(req.wValue, 0x08);
328         USETW(req.wIndex, MOSCOM_INT);
329         USETW(req.wLength, 0);
330         if (usbd_do_request(sc->sc_ucom.sc_udev, &req, NULL) != 0)
331                 return (EIO);
332
333         return (0);
334 }
335
336 static void
337 moscom_set(void *vsc, int portno, int reg, int onoff)
338 {
339         struct moscom_softc *sc = vsc;
340         int val;
341
342         switch (reg) {
343         case UCOM_SET_DTR:
344                 val = onoff ? MOSCOM_MCR_DTR : 0;
345                 break;
346         case UCOM_SET_RTS:
347                 val = onoff ? MOSCOM_MCR_RTS : 0;
348                 break;
349         case UCOM_SET_BREAK:
350                 val = sc->sc_lcr;
351                 if (onoff)
352                         val |= MOSCOM_LCR_BREAK;
353                 moscom_cmd(sc, MOSCOM_LCR, val);
354                 return;
355         default:
356                 return;
357         }
358
359         moscom_cmd(sc, MOSCOM_MCR, val);
360 }
361
362 static int
363 moscom_param(void *vsc, int portno, struct termios *t)
364 {
365         struct moscom_softc *sc = (struct moscom_softc *)vsc;
366         int data;
367
368         if (t->c_ospeed <= 0 || t->c_ospeed > 115200)
369                 return (EINVAL);
370
371         data = MOSCOM_BAUD_REF / t->c_ospeed;
372
373         if (data == 0 || data > 0xffff)
374                 return (EINVAL);
375
376         moscom_cmd(sc, MOSCOM_LCR, MOSCOM_LCR_DIVLATCH_EN);
377         moscom_cmd(sc, MOSCOM_BAUDLO, data & 0xFF);
378         moscom_cmd(sc, MOSCOM_BAUDHI, (data >> 8) & 0xFF);
379
380         if (ISSET(t->c_cflag, CSTOPB))
381                 data = MOSCOM_LCR_STOP_BITS_2;
382         else
383                 data = MOSCOM_LCR_STOP_BITS_1;
384         if (ISSET(t->c_cflag, PARENB)) {
385                 if (ISSET(t->c_cflag, PARODD))
386                         data |= MOSCOM_LCR_PARITY_ODD;
387                 else
388                         data |= MOSCOM_LCR_PARITY_EVEN;
389         } else
390                 data |= MOSCOM_LCR_PARITY_NONE;
391         switch (ISSET(t->c_cflag, CSIZE)) {
392         case CS5:
393                 data |= MOSCOM_LCR_DBITS(5);
394                 break;
395         case CS6:
396                 data |= MOSCOM_LCR_DBITS(6);
397                 break;
398         case CS7:
399                 data |= MOSCOM_LCR_DBITS(7);
400                 break;
401         case CS8:
402                 data |= MOSCOM_LCR_DBITS(8);
403                 break;
404         }
405
406         sc->sc_lcr = data;
407         moscom_cmd(sc, MOSCOM_LCR, sc->sc_lcr);
408
409 #if 0
410         /* XXX flow control */
411         if (ISSET(t->c_cflag, CRTSCTS))
412                 /*  rts/cts flow ctl */
413         } else if (ISSET(t->c_iflag, IXON|IXOFF)) {
414                 /*  xon/xoff flow ctl */
415         } else {
416                 /* disable flow ctl */
417         }
418 #endif
419
420         return (0);
421 }
422
423 static void
424 moscom_get_status(void *vsc, int portno, u_char *lsr, u_char *msr)
425 {
426         struct moscom_softc *sc = vsc;
427         
428         if (msr != NULL)
429                 *msr = sc->sc_msr;
430         if (lsr != NULL)
431                 *lsr = sc->sc_lsr;
432 }
433
434 static int
435 moscom_cmd(struct moscom_softc *sc, int reg, int val)
436 {
437         usb_device_request_t req;
438         usbd_status err;
439         
440         req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
441         req.bRequest = MOSCOM_WRITE;
442         USETW(req.wValue, val + MOSCOM_UART_REG);
443         USETW(req.wIndex, reg);
444         USETW(req.wLength, 0);
445         err = usbd_do_request(sc->sc_ucom.sc_udev, &req, NULL);
446         if (err)
447                 return (EIO);
448         else
449                 return (0);
450 }