1ceea551afe69343f7c4ab4e00e89a1b945b6931
[dragonfly.git] / sys / dev / usbmisc / uark / uark.c
1 /*      $DragonFly: src/sys/dev/usbmisc/uark/uark.c,v 1.1 2007/08/14 22:28:11 hasso Exp $       */
2 /*      $OpenBSD: uark.c,v 1.9 2007/06/13 06:25:03 mbalmer 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 #include <bus/usb/usbdevs.h>
34
35 #include <dev/usbmisc/ucom/ucomvar.h>
36
37 #ifdef UARK_DEBUG
38 #define DPRINTFN(n, x)  do { if (uarkdebug > (n)) kprintf x; } while (0)
39 int     uarkebug = 0;
40 #else
41 #define DPRINTFN(n, x)
42 #endif
43 #define DPRINTF(x) DPRINTFN(0, x)
44
45 #define UARKBUFSZ               256
46 #define UARK_CONFIG_NO          0
47 #define UARK_IFACE_NO           0
48
49 #define UARK_SET_DATA_BITS(x)   (x - 5)
50
51 #define UARK_PARITY_NONE        0x00
52 #define UARK_PARITY_ODD         0x08
53 #define UARK_PARITY_EVEN        0x18
54
55 #define UARK_STOP_BITS_1        0x00
56 #define UARK_STOP_BITS_2        0x04
57
58 #define UARK_BAUD_REF           3000000
59
60 #define UARK_WRITE              0x40
61 #define UARK_READ               0xc0
62
63 #define UARK_REQUEST            0xfe
64
65 struct uark_softc {
66         struct ucom_softc       sc_ucom;
67         u_char                  sc_msr;
68         u_char                  sc_lsr;
69 };
70
71 void    uark_get_status(void *, int portno, u_char *lsr, u_char *msr);
72 void    uark_set(void *, int, int, int);
73 int     uark_param(void *, int, struct termios *);
74 int     uark_open(void *sc, int);
75 void    uark_break(void *, int, int);
76 int     uark_cmd(struct uark_softc *, uint16_t, uint16_t);
77
78 struct ucom_callback uark_callback = {
79         uark_get_status,
80         uark_set,
81         uark_param,
82         NULL,
83         NULL,
84         NULL,
85         NULL,
86         NULL,
87 };
88
89 static const struct usb_devno uark_devs[] = {
90         { USB_VENDOR_ARKMICRO,          USB_PRODUCT_ARKMICRO_ARK3116 }
91 };
92
93 static device_probe_t uark_match;
94 static device_attach_t uark_attach;
95 static device_detach_t uark_detach;
96
97 static device_method_t uark_methods[] = {
98         /* Device interface */
99         DEVMETHOD(device_probe, uark_match),
100         DEVMETHOD(device_attach, uark_attach),
101         DEVMETHOD(device_detach, uark_detach),
102         { 0, 0 }
103 };
104
105 static driver_t uark_driver = {
106         "ucom",
107         uark_methods,
108         sizeof (struct uark_softc)
109 };
110
111 DRIVER_MODULE(uark, uhub, uark_driver, ucom_devclass, usbd_driver_load, 0);
112 MODULE_DEPEND(uark, usb, 1, 1, 1);
113 MODULE_DEPEND(uark, ucom, UCOM_MINVER, UCOM_PREFVER, UCOM_MAXVER);
114 MODULE_VERSION(uark, 1);
115
116 static int
117 uark_match(device_t self)
118 {
119         struct usb_attach_arg *uaa = device_get_ivars(self);
120
121         if (uaa->iface != NULL)
122                 return UMATCH_NONE;
123
124         return (usb_lookup(uark_devs, uaa->vendor, uaa->product) != NULL) ?
125             UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
126 }
127
128 static int
129 uark_attach(device_t self)
130 {
131         struct uark_softc *sc = device_get_softc(self);
132         struct usb_attach_arg *uaa = device_get_ivars(self);
133         struct ucom_softc *ucom;
134         usb_interface_descriptor_t *id;
135         usb_endpoint_descriptor_t *ed;
136         usbd_status error;
137         char *devinfo;
138         const char *devname;
139         int i;
140
141         devinfo = kmalloc(1024, M_USBDEV, M_INTWAIT);
142         ucom = &sc->sc_ucom;
143
144         bzero(sc, sizeof (struct uark_softc));
145
146         usbd_devinfo(uaa->device, 0, devinfo);
147         ucom->sc_dev = self;
148         device_set_desc_copy(self, devinfo);
149
150         ucom->sc_udev = uaa->device;
151         ucom->sc_iface = uaa->iface;
152
153         devname = device_get_nameunit(ucom->sc_dev);
154         kprintf("%s: %s\n", devname, devinfo);
155         kfree(devinfo, M_USBDEV);
156
157         if (usbd_set_config_index(ucom->sc_udev, UARK_CONFIG_NO, 1) != 0) {
158                 kprintf("%s: could not set configuration no\n", devname);
159                 goto error;
160         }
161
162         /* get the first interface handle */
163         error = usbd_device2interface_handle(ucom->sc_udev, UARK_IFACE_NO,
164             &ucom->sc_iface);
165         if (error != 0) {
166                 kprintf("%s: could not get interface handle\n", devname);
167                 goto error;
168         }
169
170         id = usbd_get_interface_descriptor(ucom->sc_iface);
171
172         ucom->sc_bulkin_no = ucom->sc_bulkout_no = -1;
173         for (i = 0; i < id->bNumEndpoints; i++) {
174                 ed = usbd_interface2endpoint_descriptor(ucom->sc_iface, i);
175                 if (ed == NULL) {
176                         kprintf("%s: no endpoint descriptor found for %d\n",
177                             devname, i);
178                         goto error;
179                 }
180
181                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
182                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
183                         ucom->sc_bulkin_no = ed->bEndpointAddress;
184                 else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
185                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
186                         ucom->sc_bulkout_no = ed->bEndpointAddress;
187         }
188
189         if (ucom->sc_bulkin_no == -1 || ucom->sc_bulkout_no == -1) {
190                 kprintf("%s: missing endpoint\n", devname);
191                 goto error;
192         }
193
194         ucom->sc_parent = sc;
195         ucom->sc_portno = UCOM_UNK_PORTNO;
196         ucom->sc_ibufsize = UARKBUFSZ;
197         ucom->sc_obufsize = UARKBUFSZ;
198         ucom->sc_ibufsizepad = UARKBUFSZ;
199         ucom->sc_opkthdrlen = 0;
200         ucom->sc_callback = &uark_callback;
201
202         usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, ucom->sc_udev,
203                            ucom->sc_dev);
204         
205         DPRINTF(("uark: in = 0x%x, out = 0x%x, intr = 0x%x\n",
206                  ucom->sc_bulkin_no, ucom->sc_bulkout_no, sc->sc_intr_number));
207
208         ucom_attach(&sc->sc_ucom);
209
210         return 0;
211
212 error:
213         ucom->sc_dying = 1;
214         return ENXIO;
215 }
216
217 static int
218 uark_detach(device_t self)
219 {
220         struct uark_softc *sc = device_get_softc(self);
221         int rv = 0;
222
223         DPRINTF(("uark_detach: sc=%p\n", sc));
224         sc->sc_ucom.sc_dying = 1;
225         rv = ucom_detach(&sc->sc_ucom);
226         usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_ucom.sc_udev,
227                            sc->sc_ucom.sc_dev);
228
229         return (rv);
230 }
231
232 #if 0 /* not yet */
233 int
234 uark_activate(struct device *self, enum devact act)
235 {
236         struct uark_softc *sc = (struct uark_softc *)self;
237         int rv = 0;
238
239         switch (act) {
240         case DVACT_ACTIVATE:
241                 break;
242
243         case DVACT_DEACTIVATE:
244                 if (sc->sc_subdev != NULL)
245                         rv = config_deactivate(sc->sc_subdev);
246                 sc->sc_dying = 1;
247                 break;
248         }
249         return (rv);
250 }
251 #endif
252
253 void
254 uark_set(void *vsc, int portno, int reg, int onoff)
255 {
256         struct uark_softc *sc = vsc;
257
258         switch (reg) {
259         case UCOM_SET_BREAK:
260                 uark_break(sc, portno, onoff);
261                 return;
262         case UCOM_SET_DTR:
263         case UCOM_SET_RTS:
264         default:
265                 return;
266         }
267 }
268
269 int
270 uark_param(void *vsc, int portno, struct termios *t)
271 {
272         struct uark_softc *sc = (struct uark_softc *)vsc;
273         int data;
274
275         switch (t->c_ospeed) {
276         case 300:
277         case 600:
278         case 1200:
279         case 1800:
280         case 2400:
281         case 4800:
282         case 9600:
283         case 19200:
284         case 38400:
285         case 57600:
286         case 115200:
287                 uark_cmd(sc, 3, 0x83);
288                 uark_cmd(sc, 0, (UARK_BAUD_REF / t->c_ospeed) & 0xFF);
289                 uark_cmd(sc, 1, (UARK_BAUD_REF / t->c_ospeed) >> 8);
290                 uark_cmd(sc, 3, 0x03);
291                 break;
292         default:
293                 return (EINVAL);
294         }
295
296         if (ISSET(t->c_cflag, CSTOPB))
297                 data = UARK_STOP_BITS_2;
298         else
299                 data = UARK_STOP_BITS_1;
300
301         if (ISSET(t->c_cflag, PARENB)) {
302                 if (ISSET(t->c_cflag, PARODD))
303                         data |= UARK_PARITY_ODD;
304                 else
305                         data |= UARK_PARITY_EVEN;
306         } else
307                 data |= UARK_PARITY_NONE;
308
309         switch (ISSET(t->c_cflag, CSIZE)) {
310         case CS5:
311                 data |= UARK_SET_DATA_BITS(5);
312                 break;
313         case CS6:
314                 data |= UARK_SET_DATA_BITS(6);
315                 break;
316         case CS7:
317                 data |= UARK_SET_DATA_BITS(7);
318                 break;
319         case CS8:
320                 data |= UARK_SET_DATA_BITS(8);
321                 break;
322         }
323
324         uark_cmd(sc, 3, 0x00);
325         uark_cmd(sc, 3, data);
326
327 #if 0
328         /* XXX flow control */
329         if (ISSET(t->c_cflag, CRTSCTS))
330                 /*  rts/cts flow ctl */
331         } else if (ISSET(t->c_iflag, IXON|IXOFF)) {
332                 /*  xon/xoff flow ctl */
333         } else {
334                 /* disable flow ctl */
335         }
336 #endif
337
338         return (0);
339 }
340
341 void
342 uark_get_status(void *vsc, int portno, u_char *lsr, u_char *msr)
343 {
344         struct uark_softc *sc = vsc;
345         
346         if (msr != NULL)
347                 *msr = sc->sc_msr;
348         if (lsr != NULL)
349                 *lsr = sc->sc_lsr;
350 }
351
352 void
353 uark_break(void *vsc, int portno, int onoff)
354 {
355 #ifdef UARK_DEBUG
356         struct uark_softc *sc = vsc;
357
358         kprintf("%s: break %s!\n", device_get_nameunit(sc->sc_ucom->sc_dev),
359             onoff ? "on" : "off");
360
361         if (onoff)
362                 /* break on */
363                 uark_cmd(sc, 4, 0x01);
364         else
365                 uark_cmd(sc, 4, 0x00);
366 #endif
367 }
368
369 int
370 uark_cmd(struct uark_softc *sc, uint16_t index, uint16_t value)
371 {
372         usb_device_request_t req;
373         usbd_status err;
374
375         req.bmRequestType = UARK_WRITE;
376         req.bRequest = UARK_REQUEST;
377         USETW(req.wValue, value);
378         USETW(req.wIndex, index);
379         USETW(req.wLength, 0);
380         err = usbd_do_request(sc->sc_ucom.sc_udev, &req, NULL);
381
382         if (err)
383                 return (EIO);
384
385         return (0);
386 }