1*beecddb6Sthorpej /* $NetBSD: uchcom.c,v 1.40 2021/08/07 16:19:17 thorpej Exp $ */
2d0a32c7bStshiozak
3d0a32c7bStshiozak /*
4d0a32c7bStshiozak * Copyright (c) 2007 The NetBSD Foundation, Inc.
5d0a32c7bStshiozak * All rights reserved.
6d0a32c7bStshiozak *
7d0a32c7bStshiozak * This code is derived from software contributed to The NetBSD Foundation
8d0a32c7bStshiozak * by Takuya SHIOZAKI (tshiozak@netbsd.org).
9d0a32c7bStshiozak *
10d0a32c7bStshiozak * Redistribution and use in source and binary forms, with or without
11d0a32c7bStshiozak * modification, are permitted provided that the following conditions
12d0a32c7bStshiozak * are met:
13d0a32c7bStshiozak * 1. Redistributions of source code must retain the above copyright
14d0a32c7bStshiozak * notice, this list of conditions and the following disclaimer.
15d0a32c7bStshiozak * 2. Redistributions in binary form must reproduce the above copyright
16d0a32c7bStshiozak * notice, this list of conditions and the following disclaimer in the
17d0a32c7bStshiozak * documentation and/or other materials provided with the distribution.
18d0a32c7bStshiozak *
19d0a32c7bStshiozak * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20d0a32c7bStshiozak * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21d0a32c7bStshiozak * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22d0a32c7bStshiozak * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23d0a32c7bStshiozak * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24d0a32c7bStshiozak * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25d0a32c7bStshiozak * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26d0a32c7bStshiozak * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27d0a32c7bStshiozak * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28d0a32c7bStshiozak * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29d0a32c7bStshiozak * POSSIBILITY OF SUCH DAMAGE.
30d0a32c7bStshiozak */
31d0a32c7bStshiozak
32d0a32c7bStshiozak #include <sys/cdefs.h>
33*beecddb6Sthorpej __KERNEL_RCSID(0, "$NetBSD: uchcom.c,v 1.40 2021/08/07 16:19:17 thorpej Exp $");
340e72af92Sskrll
350e72af92Sskrll #ifdef _KERNEL_OPT
360e72af92Sskrll #include "opt_usb.h"
370e72af92Sskrll #endif
38d0a32c7bStshiozak
39d0a32c7bStshiozak /*
40d0a32c7bStshiozak * driver for WinChipHead CH341/340, the worst USB-serial chip in the world.
41d0a32c7bStshiozak */
42d0a32c7bStshiozak
43d0a32c7bStshiozak #include <sys/param.h>
44d0a32c7bStshiozak #include <sys/systm.h>
45d0a32c7bStshiozak #include <sys/kernel.h>
4671112a2eSskrll #include <sys/kmem.h>
47d0a32c7bStshiozak #include <sys/ioctl.h>
48d0a32c7bStshiozak #include <sys/conf.h>
49d0a32c7bStshiozak #include <sys/tty.h>
50d0a32c7bStshiozak #include <sys/file.h>
51d0a32c7bStshiozak #include <sys/select.h>
52d0a32c7bStshiozak #include <sys/proc.h>
53d0a32c7bStshiozak #include <sys/device.h>
54d0a32c7bStshiozak #include <sys/poll.h>
55d0a32c7bStshiozak
56d0a32c7bStshiozak #include <dev/usb/usb.h>
57d0a32c7bStshiozak
58d0a32c7bStshiozak #include <dev/usb/usbdi.h>
59d0a32c7bStshiozak #include <dev/usb/usbdi_util.h>
60d0a32c7bStshiozak #include <dev/usb/usbdevs.h>
61d0a32c7bStshiozak
62d0a32c7bStshiozak #include <dev/usb/ucomvar.h>
63d0a32c7bStshiozak
64d0a32c7bStshiozak #ifdef UCHCOM_DEBUG
6549337c88Sdyoung #define DPRINTFN(n, x) if (uchcomdebug > (n)) printf x
66d0a32c7bStshiozak int uchcomdebug = 0;
67d0a32c7bStshiozak #else
68d0a32c7bStshiozak #define DPRINTFN(n, x)
69d0a32c7bStshiozak #endif
70d0a32c7bStshiozak #define DPRINTF(x) DPRINTFN(0, x)
71d0a32c7bStshiozak
72d0a32c7bStshiozak #define UCHCOM_IFACE_INDEX 0
73d0a32c7bStshiozak #define UCHCOM_CONFIG_INDEX 0
74d0a32c7bStshiozak
75d0a32c7bStshiozak #define UCHCOM_INPUT_BUF_SIZE 8
76d0a32c7bStshiozak
77d0a32c7bStshiozak #define UCHCOM_REQ_GET_VERSION 0x5F
78d0a32c7bStshiozak #define UCHCOM_REQ_READ_REG 0x95
79d0a32c7bStshiozak #define UCHCOM_REQ_WRITE_REG 0x9A
80d0a32c7bStshiozak #define UCHCOM_REQ_RESET 0xA1
81d0a32c7bStshiozak #define UCHCOM_REQ_SET_DTRRTS 0xA4
82d0a32c7bStshiozak
83d0a32c7bStshiozak #define UCHCOM_REG_STAT1 0x06
84d0a32c7bStshiozak #define UCHCOM_REG_STAT2 0x07
85d0a32c7bStshiozak #define UCHCOM_REG_BPS_PRE 0x12
86d0a32c7bStshiozak #define UCHCOM_REG_BPS_DIV 0x13
87e216d5ceSjakllsch #define UCHCOM_REG_BREAK 0x05
88e216d5ceSjakllsch #define UCHCOM_REG_LCR 0x18
89d0a32c7bStshiozak #define UCHCOM_REG_LCR2 0x25
90d0a32c7bStshiozak
91d0a32c7bStshiozak #define UCHCOM_VER_20 0x20
924011c52eSbouyer #define UCHCOM_VER_30 0x30
93d0a32c7bStshiozak
947235b322Sjakllsch #define UCHCOM_BPS_PRE_IMM 0x80 /* CH341: immediate RX forwarding */
957235b322Sjakllsch
96d0a32c7bStshiozak #define UCHCOM_DTR_MASK 0x20
97d0a32c7bStshiozak #define UCHCOM_RTS_MASK 0x40
98d0a32c7bStshiozak
99e216d5ceSjakllsch #define UCHCOM_BREAK_MASK 0x01
100d0a32c7bStshiozak
101e216d5ceSjakllsch #define UCHCOM_LCR_CS5 0x00
102e216d5ceSjakllsch #define UCHCOM_LCR_CS6 0x01
103e216d5ceSjakllsch #define UCHCOM_LCR_CS7 0x02
104e216d5ceSjakllsch #define UCHCOM_LCR_CS8 0x03
105e216d5ceSjakllsch #define UCHCOM_LCR_STOPB 0x04
106e216d5ceSjakllsch #define UCHCOM_LCR_PARENB 0x08
107e216d5ceSjakllsch #define UCHCOM_LCR_PARODD 0x00
108e216d5ceSjakllsch #define UCHCOM_LCR_PAREVEN 0x10
109e216d5ceSjakllsch #define UCHCOM_LCR_PARMARK 0x20
110e216d5ceSjakllsch #define UCHCOM_LCR_PARSPACE 0x30
111e216d5ceSjakllsch #define UCHCOM_LCR_TXE 0x40
112e216d5ceSjakllsch #define UCHCOM_LCR_RXE 0x80
113d0a32c7bStshiozak
114d0a32c7bStshiozak #define UCHCOM_INTR_STAT1 0x02
115d0a32c7bStshiozak #define UCHCOM_INTR_STAT2 0x03
116d0a32c7bStshiozak #define UCHCOM_INTR_LEAST 4
117d0a32c7bStshiozak
118d0a32c7bStshiozak #define UCHCOMIBUFSIZE 256
119d0a32c7bStshiozak #define UCHCOMOBUFSIZE 256
120d0a32c7bStshiozak
121d0a32c7bStshiozak struct uchcom_softc
122d0a32c7bStshiozak {
12349337c88Sdyoung device_t sc_dev;
12471112a2eSskrll struct usbd_device * sc_udev;
12549337c88Sdyoung device_t sc_subdev;
12671112a2eSskrll struct usbd_interface * sc_iface;
127b88e5d5dSmrg bool sc_dying;
128d0a32c7bStshiozak /* */
129d0a32c7bStshiozak int sc_intr_endpoint;
130d0a32c7bStshiozak int sc_intr_size;
13171112a2eSskrll struct usbd_pipe * sc_intr_pipe;
132d0a32c7bStshiozak u_char *sc_intr_buf;
133d0a32c7bStshiozak /* */
134d0a32c7bStshiozak uint8_t sc_version;
135d0a32c7bStshiozak int sc_dtr;
136d0a32c7bStshiozak int sc_rts;
137d0a32c7bStshiozak u_char sc_lsr;
138d0a32c7bStshiozak u_char sc_msr;
139d0a32c7bStshiozak };
140d0a32c7bStshiozak
141d0a32c7bStshiozak struct uchcom_endpoints
142d0a32c7bStshiozak {
143d0a32c7bStshiozak int ep_bulkin;
144d0a32c7bStshiozak int ep_bulkout;
145d0a32c7bStshiozak int ep_intr;
146d0a32c7bStshiozak int ep_intr_size;
147d0a32c7bStshiozak };
148d0a32c7bStshiozak
149d0a32c7bStshiozak struct uchcom_divider
150d0a32c7bStshiozak {
151d0a32c7bStshiozak uint8_t dv_prescaler;
152d0a32c7bStshiozak uint8_t dv_div;
153d0a32c7bStshiozak };
154d0a32c7bStshiozak
155cecf4762Snisimura /* 0,1,2,3,7 are prescale factors for given 4x 12000000 clock formula */
156512fc964Sjakllsch static const uint32_t rates4x[8] = {
157512fc964Sjakllsch [0] = 4 * 12000000 / 1024,
158512fc964Sjakllsch [1] = 4 * 12000000 / 128,
159512fc964Sjakllsch [2] = 4 * 12000000 / 16,
160512fc964Sjakllsch [3] = 4 * 12000000 / 2,
161512fc964Sjakllsch [7] = 4 * 12000000,
162d0a32c7bStshiozak };
163d0a32c7bStshiozak
164d0a32c7bStshiozak static const struct usb_devno uchcom_devs[] = {
165e325bb77Sjakllsch { USB_VENDOR_QINHENG2, USB_PRODUCT_QINHENG2_CH341SER },
166e325bb77Sjakllsch { USB_VENDOR_QINHENG, USB_PRODUCT_QINHENG_CH340 },
167e325bb77Sjakllsch { USB_VENDOR_QINHENG, USB_PRODUCT_QINHENG_CH341_ASP },
168d0a32c7bStshiozak };
169d0a32c7bStshiozak #define uchcom_lookup(v, p) usb_lookup(uchcom_devs, v, p)
170d0a32c7bStshiozak
171b88e5d5dSmrg static void uchcom_get_status(void *, int, u_char *, u_char *);
172b88e5d5dSmrg static void uchcom_set(void *, int, int, int);
173b88e5d5dSmrg static int uchcom_param(void *, int, struct termios *);
174b88e5d5dSmrg static int uchcom_open(void *, int);
175b88e5d5dSmrg static void uchcom_close(void *, int);
176b88e5d5dSmrg static void uchcom_intr(struct usbd_xfer *, void *,
177d0a32c7bStshiozak usbd_status);
178d0a32c7bStshiozak
179d0a32c7bStshiozak static int set_config(struct uchcom_softc *);
18071112a2eSskrll static int find_ifaces(struct uchcom_softc *, struct usbd_interface **);
181d0a32c7bStshiozak static int find_endpoints(struct uchcom_softc *,
182d0a32c7bStshiozak struct uchcom_endpoints *);
183d0a32c7bStshiozak static void close_intr_pipe(struct uchcom_softc *);
184d0a32c7bStshiozak
185d0a32c7bStshiozak
18607f3c95dSmaxv static const struct ucom_methods uchcom_methods = {
187d0a32c7bStshiozak .ucom_get_status = uchcom_get_status,
188d0a32c7bStshiozak .ucom_set = uchcom_set,
189d0a32c7bStshiozak .ucom_param = uchcom_param,
190d0a32c7bStshiozak .ucom_open = uchcom_open,
191d0a32c7bStshiozak .ucom_close = uchcom_close,
192d0a32c7bStshiozak };
193d0a32c7bStshiozak
19425e6116aSmrg static int uchcom_match(device_t, cfdata_t, void *);
19525e6116aSmrg static void uchcom_attach(device_t, device_t, void *);
19625e6116aSmrg static void uchcom_childdet(device_t, device_t);
19725e6116aSmrg static int uchcom_detach(device_t, int);
1980b1dce29Sdyoung
1993624455eScube CFATTACH_DECL2_NEW(uchcom,
2000b1dce29Sdyoung sizeof(struct uchcom_softc),
2010b1dce29Sdyoung uchcom_match,
2020b1dce29Sdyoung uchcom_attach,
2030b1dce29Sdyoung uchcom_detach,
20425e6116aSmrg NULL,
2050b1dce29Sdyoung NULL,
2060b1dce29Sdyoung uchcom_childdet);
207d0a32c7bStshiozak
208d0a32c7bStshiozak /* ----------------------------------------------------------------------
209d0a32c7bStshiozak * driver entry points
210d0a32c7bStshiozak */
211d0a32c7bStshiozak
21225e6116aSmrg static int
uchcom_match(device_t parent,cfdata_t match,void * aux)21349337c88Sdyoung uchcom_match(device_t parent, cfdata_t match, void *aux)
214d0a32c7bStshiozak {
21549337c88Sdyoung struct usb_attach_arg *uaa = aux;
216d0a32c7bStshiozak
21771112a2eSskrll return (uchcom_lookup(uaa->uaa_vendor, uaa->uaa_product) != NULL ?
218d0a32c7bStshiozak UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
219d0a32c7bStshiozak }
220d0a32c7bStshiozak
22125e6116aSmrg static void
uchcom_attach(device_t parent,device_t self,void * aux)22249337c88Sdyoung uchcom_attach(device_t parent, device_t self, void *aux)
223d0a32c7bStshiozak {
22449337c88Sdyoung struct uchcom_softc *sc = device_private(self);
22549337c88Sdyoung struct usb_attach_arg *uaa = aux;
22671112a2eSskrll struct usbd_device *dev = uaa->uaa_device;
227d0a32c7bStshiozak char *devinfop;
228d0a32c7bStshiozak struct uchcom_endpoints endpoints;
22971112a2eSskrll struct ucom_attach_args ucaa;
230d0a32c7bStshiozak
2315fab894cSplunky aprint_naive("\n");
2325fab894cSplunky aprint_normal("\n");
2335fab894cSplunky
234d0a32c7bStshiozak devinfop = usbd_devinfo_alloc(dev, 0);
2353624455eScube aprint_normal_dev(self, "%s\n", devinfop);
236d0a32c7bStshiozak usbd_devinfo_free(devinfop);
237d0a32c7bStshiozak
2383624455eScube sc->sc_dev = self;
239d0a32c7bStshiozak sc->sc_udev = dev;
240b88e5d5dSmrg sc->sc_dying = false;
241d0a32c7bStshiozak sc->sc_dtr = sc->sc_rts = -1;
242d0a32c7bStshiozak sc->sc_lsr = sc->sc_msr = 0;
243d0a32c7bStshiozak
244d0a32c7bStshiozak DPRINTF(("\n\nuchcom attach: sc=%p\n", sc));
245d0a32c7bStshiozak
246d0a32c7bStshiozak if (set_config(sc))
247d0a32c7bStshiozak goto failed;
248d0a32c7bStshiozak
249d0a32c7bStshiozak if (find_ifaces(sc, &sc->sc_iface))
250d0a32c7bStshiozak goto failed;
251d0a32c7bStshiozak
252d0a32c7bStshiozak if (find_endpoints(sc, &endpoints))
253d0a32c7bStshiozak goto failed;
254d0a32c7bStshiozak
255d0a32c7bStshiozak sc->sc_intr_endpoint = endpoints.ep_intr;
256d0a32c7bStshiozak sc->sc_intr_size = endpoints.ep_intr_size;
257d0a32c7bStshiozak
258d0a32c7bStshiozak /* setup ucom layer */
25971112a2eSskrll ucaa.ucaa_portno = UCOM_UNK_PORTNO;
26071112a2eSskrll ucaa.ucaa_bulkin = endpoints.ep_bulkin;
26171112a2eSskrll ucaa.ucaa_bulkout = endpoints.ep_bulkout;
26271112a2eSskrll ucaa.ucaa_ibufsize = UCHCOMIBUFSIZE;
26371112a2eSskrll ucaa.ucaa_obufsize = UCHCOMOBUFSIZE;
26471112a2eSskrll ucaa.ucaa_ibufsizepad = UCHCOMIBUFSIZE;
26571112a2eSskrll ucaa.ucaa_opkthdrlen = 0;
26671112a2eSskrll ucaa.ucaa_device = dev;
26771112a2eSskrll ucaa.ucaa_iface = sc->sc_iface;
26871112a2eSskrll ucaa.ucaa_methods = &uchcom_methods;
26971112a2eSskrll ucaa.ucaa_arg = sc;
27071112a2eSskrll ucaa.ucaa_info = NULL;
271d0a32c7bStshiozak
272575a7585Smsaitoh usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
273d0a32c7bStshiozak
2743bee0c11Sthorpej sc->sc_subdev = config_found(self, &ucaa, ucomprint,
275*beecddb6Sthorpej CFARGS(.submatch = ucomsubmatch));
276d0a32c7bStshiozak
27749337c88Sdyoung return;
278d0a32c7bStshiozak
279d0a32c7bStshiozak failed:
280b88e5d5dSmrg sc->sc_dying = true;
28149337c88Sdyoung return;
282d0a32c7bStshiozak }
283d0a32c7bStshiozak
28425e6116aSmrg static void
uchcom_childdet(device_t self,device_t child)2850b1dce29Sdyoung uchcom_childdet(device_t self, device_t child)
2860b1dce29Sdyoung {
2870b1dce29Sdyoung struct uchcom_softc *sc = device_private(self);
2880b1dce29Sdyoung
2890b1dce29Sdyoung KASSERT(sc->sc_subdev == child);
2900b1dce29Sdyoung sc->sc_subdev = NULL;
2910b1dce29Sdyoung }
2920b1dce29Sdyoung
29325e6116aSmrg static int
uchcom_detach(device_t self,int flags)29449337c88Sdyoung uchcom_detach(device_t self, int flags)
295d0a32c7bStshiozak {
29649337c88Sdyoung struct uchcom_softc *sc = device_private(self);
297d0a32c7bStshiozak int rv = 0;
298d0a32c7bStshiozak
299d0a32c7bStshiozak DPRINTF(("uchcom_detach: sc=%p flags=%d\n", sc, flags));
300d0a32c7bStshiozak
301d0a32c7bStshiozak close_intr_pipe(sc);
302d0a32c7bStshiozak
303b88e5d5dSmrg sc->sc_dying = true;
304b88e5d5dSmrg
30525e6116aSmrg if (sc->sc_subdev != NULL) {
306d0a32c7bStshiozak rv = config_detach(sc->sc_subdev, flags);
30725e6116aSmrg sc->sc_subdev = NULL;
30825e6116aSmrg }
309d0a32c7bStshiozak
310575a7585Smsaitoh usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
311d0a32c7bStshiozak
312d0a32c7bStshiozak return rv;
313d0a32c7bStshiozak }
314d0a32c7bStshiozak
315d0a32c7bStshiozak static int
set_config(struct uchcom_softc * sc)316d0a32c7bStshiozak set_config(struct uchcom_softc *sc)
317d0a32c7bStshiozak {
318d0a32c7bStshiozak usbd_status err;
319d0a32c7bStshiozak
320d0a32c7bStshiozak err = usbd_set_config_index(sc->sc_udev, UCHCOM_CONFIG_INDEX, 1);
321d0a32c7bStshiozak if (err) {
3223624455eScube aprint_error_dev(sc->sc_dev,
3233624455eScube "failed to set configuration: %s\n", usbd_errstr(err));
324d0a32c7bStshiozak return -1;
325d0a32c7bStshiozak }
326d0a32c7bStshiozak
327d0a32c7bStshiozak return 0;
328d0a32c7bStshiozak }
329d0a32c7bStshiozak
330d0a32c7bStshiozak static int
find_ifaces(struct uchcom_softc * sc,struct usbd_interface ** riface)33171112a2eSskrll find_ifaces(struct uchcom_softc *sc, struct usbd_interface **riface)
332d0a32c7bStshiozak {
333d0a32c7bStshiozak usbd_status err;
334d0a32c7bStshiozak
335d0a32c7bStshiozak err = usbd_device2interface_handle(sc->sc_udev, UCHCOM_IFACE_INDEX,
336d0a32c7bStshiozak riface);
337d0a32c7bStshiozak if (err) {
3383624455eScube aprint_error("\n%s: failed to get interface: %s\n",
33949337c88Sdyoung device_xname(sc->sc_dev), usbd_errstr(err));
340d0a32c7bStshiozak return -1;
341d0a32c7bStshiozak }
342d0a32c7bStshiozak
343d0a32c7bStshiozak return 0;
344d0a32c7bStshiozak }
345d0a32c7bStshiozak
346d0a32c7bStshiozak static int
find_endpoints(struct uchcom_softc * sc,struct uchcom_endpoints * endpoints)347d0a32c7bStshiozak find_endpoints(struct uchcom_softc *sc, struct uchcom_endpoints *endpoints)
348d0a32c7bStshiozak {
349d0a32c7bStshiozak int i, bin=-1, bout=-1, intr=-1, isize=0;
350d0a32c7bStshiozak usb_interface_descriptor_t *id;
351d0a32c7bStshiozak usb_endpoint_descriptor_t *ed;
352d0a32c7bStshiozak
353d0a32c7bStshiozak id = usbd_get_interface_descriptor(sc->sc_iface);
354d0a32c7bStshiozak
355d0a32c7bStshiozak for (i = 0; i < id->bNumEndpoints; i++) {
356d0a32c7bStshiozak ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
357d0a32c7bStshiozak if (ed == NULL) {
3583624455eScube aprint_error_dev(sc->sc_dev,
3593624455eScube "no endpoint descriptor for %d\n", i);
360d0a32c7bStshiozak return -1;
361d0a32c7bStshiozak }
362d0a32c7bStshiozak
363d0a32c7bStshiozak if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
364d0a32c7bStshiozak UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
365d0a32c7bStshiozak intr = ed->bEndpointAddress;
366d0a32c7bStshiozak isize = UGETW(ed->wMaxPacketSize);
367d0a32c7bStshiozak } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
368d0a32c7bStshiozak UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
369d0a32c7bStshiozak bin = ed->bEndpointAddress;
370d0a32c7bStshiozak } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
371d0a32c7bStshiozak UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
372d0a32c7bStshiozak bout = ed->bEndpointAddress;
373d0a32c7bStshiozak }
374d0a32c7bStshiozak }
375d0a32c7bStshiozak
376d0a32c7bStshiozak if (intr == -1 || bin == -1 || bout == -1) {
377d0a32c7bStshiozak if (intr == -1) {
3783624455eScube aprint_error_dev(sc->sc_dev,
3793624455eScube "no interrupt end point\n");
380d0a32c7bStshiozak }
381d0a32c7bStshiozak if (bin == -1) {
3823624455eScube aprint_error_dev(sc->sc_dev,
3833624455eScube "no data bulk in end point\n");
384d0a32c7bStshiozak }
385d0a32c7bStshiozak if (bout == -1) {
3863624455eScube aprint_error_dev(sc->sc_dev,
3873624455eScube "no data bulk out end point\n");
388d0a32c7bStshiozak }
389d0a32c7bStshiozak return -1;
390d0a32c7bStshiozak }
391d0a32c7bStshiozak if (isize < UCHCOM_INTR_LEAST) {
3923624455eScube aprint_error_dev(sc->sc_dev, "intr pipe is too short\n");
393d0a32c7bStshiozak return -1;
394d0a32c7bStshiozak }
395d0a32c7bStshiozak
396d0a32c7bStshiozak DPRINTF(("%s: bulkin=%d, bulkout=%d, intr=%d, isize=%d\n",
39749337c88Sdyoung device_xname(sc->sc_dev), bin, bout, intr, isize));
398d0a32c7bStshiozak
399d0a32c7bStshiozak endpoints->ep_intr = intr;
400d0a32c7bStshiozak endpoints->ep_intr_size = isize;
401d0a32c7bStshiozak endpoints->ep_bulkin = bin;
402d0a32c7bStshiozak endpoints->ep_bulkout = bout;
403d0a32c7bStshiozak
404d0a32c7bStshiozak return 0;
405d0a32c7bStshiozak }
406d0a32c7bStshiozak
407d0a32c7bStshiozak
408d0a32c7bStshiozak /* ----------------------------------------------------------------------
409d0a32c7bStshiozak * low level i/o
410d0a32c7bStshiozak */
411d0a32c7bStshiozak
412d0a32c7bStshiozak static __inline usbd_status
generic_control_out(struct uchcom_softc * sc,uint8_t reqno,uint16_t value,uint16_t index)413d0a32c7bStshiozak generic_control_out(struct uchcom_softc *sc, uint8_t reqno,
414d0a32c7bStshiozak uint16_t value, uint16_t index)
415d0a32c7bStshiozak {
416d0a32c7bStshiozak usb_device_request_t req;
417d0a32c7bStshiozak
418d0a32c7bStshiozak req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
419d0a32c7bStshiozak req.bRequest = reqno;
420d0a32c7bStshiozak USETW(req.wValue, value);
421d0a32c7bStshiozak USETW(req.wIndex, index);
422d0a32c7bStshiozak USETW(req.wLength, 0);
423d0a32c7bStshiozak
424d0a32c7bStshiozak return usbd_do_request(sc->sc_udev, &req, 0);
425d0a32c7bStshiozak }
426d0a32c7bStshiozak
427d0a32c7bStshiozak static __inline usbd_status
generic_control_in(struct uchcom_softc * sc,uint8_t reqno,uint16_t value,uint16_t index,void * buf,int buflen,int * actlen)428d0a32c7bStshiozak generic_control_in(struct uchcom_softc *sc, uint8_t reqno,
429d0a32c7bStshiozak uint16_t value, uint16_t index, void *buf, int buflen,
430d0a32c7bStshiozak int *actlen)
431d0a32c7bStshiozak {
432d0a32c7bStshiozak usb_device_request_t req;
433d0a32c7bStshiozak
434d0a32c7bStshiozak req.bmRequestType = UT_READ_VENDOR_DEVICE;
435d0a32c7bStshiozak req.bRequest = reqno;
436d0a32c7bStshiozak USETW(req.wValue, value);
437d0a32c7bStshiozak USETW(req.wIndex, index);
438d0a32c7bStshiozak USETW(req.wLength, (uint16_t)buflen);
439d0a32c7bStshiozak
440d0a32c7bStshiozak return usbd_do_request_flags(sc->sc_udev, &req, buf,
441d0a32c7bStshiozak USBD_SHORT_XFER_OK, actlen,
442d0a32c7bStshiozak USBD_DEFAULT_TIMEOUT);
443d0a32c7bStshiozak }
444d0a32c7bStshiozak
445d0a32c7bStshiozak static __inline usbd_status
write_reg(struct uchcom_softc * sc,uint8_t reg1,uint8_t val1,uint8_t reg2,uint8_t val2)446d0a32c7bStshiozak write_reg(struct uchcom_softc *sc,
447d0a32c7bStshiozak uint8_t reg1, uint8_t val1, uint8_t reg2, uint8_t val2)
448d0a32c7bStshiozak {
4494f8d1b77Schristos DPRINTF(("%s: write reg 0x%02X<-0x%02X, 0x%02X<-0x%02X\n",
45010f796b0Sjakllsch device_xname(sc->sc_dev),
451d0a32c7bStshiozak (unsigned)reg1, (unsigned)val1,
452d0a32c7bStshiozak (unsigned)reg2, (unsigned)val2));
453d0a32c7bStshiozak return generic_control_out(
454d0a32c7bStshiozak sc, UCHCOM_REQ_WRITE_REG,
455d0a32c7bStshiozak reg1|((uint16_t)reg2<<8), val1|((uint16_t)val2<<8));
456d0a32c7bStshiozak }
457d0a32c7bStshiozak
458d0a32c7bStshiozak static __inline usbd_status
read_reg(struct uchcom_softc * sc,uint8_t reg1,uint8_t * rval1,uint8_t reg2,uint8_t * rval2)459d0a32c7bStshiozak read_reg(struct uchcom_softc *sc,
460d0a32c7bStshiozak uint8_t reg1, uint8_t *rval1, uint8_t reg2, uint8_t *rval2)
461d0a32c7bStshiozak {
462d0a32c7bStshiozak uint8_t buf[UCHCOM_INPUT_BUF_SIZE];
463d0a32c7bStshiozak usbd_status err;
464d0a32c7bStshiozak int actin;
465d0a32c7bStshiozak
466d0a32c7bStshiozak err = generic_control_in(
467d0a32c7bStshiozak sc, UCHCOM_REQ_READ_REG,
46871112a2eSskrll reg1|((uint16_t)reg2<<8), 0, buf, sizeof(buf), &actin);
469d0a32c7bStshiozak if (err)
470d0a32c7bStshiozak return err;
471d0a32c7bStshiozak
4724f8d1b77Schristos DPRINTF(("%s: read reg 0x%02X->0x%02X, 0x%02X->0x%02X\n",
47310f796b0Sjakllsch device_xname(sc->sc_dev),
474d0a32c7bStshiozak (unsigned)reg1, (unsigned)buf[0],
475d0a32c7bStshiozak (unsigned)reg2, (unsigned)buf[1]));
476d0a32c7bStshiozak
477d0a32c7bStshiozak if (rval1) *rval1 = buf[0];
478d0a32c7bStshiozak if (rval2) *rval2 = buf[1];
479d0a32c7bStshiozak
480d0a32c7bStshiozak return USBD_NORMAL_COMPLETION;
481d0a32c7bStshiozak }
482d0a32c7bStshiozak
483d0a32c7bStshiozak static __inline usbd_status
get_version(struct uchcom_softc * sc,uint8_t * rver)484d0a32c7bStshiozak get_version(struct uchcom_softc *sc, uint8_t *rver)
485d0a32c7bStshiozak {
486d0a32c7bStshiozak uint8_t buf[UCHCOM_INPUT_BUF_SIZE];
487d0a32c7bStshiozak usbd_status err;
488d0a32c7bStshiozak int actin;
489d0a32c7bStshiozak
490d0a32c7bStshiozak err = generic_control_in(
49171112a2eSskrll sc, UCHCOM_REQ_GET_VERSION, 0, 0, buf, sizeof(buf), &actin);
492d0a32c7bStshiozak if (err)
493d0a32c7bStshiozak return err;
494d0a32c7bStshiozak
495d0a32c7bStshiozak if (rver) *rver = buf[0];
496d0a32c7bStshiozak
497d0a32c7bStshiozak return USBD_NORMAL_COMPLETION;
498d0a32c7bStshiozak }
499d0a32c7bStshiozak
500d0a32c7bStshiozak static __inline usbd_status
get_status(struct uchcom_softc * sc,uint8_t * rval)501d0a32c7bStshiozak get_status(struct uchcom_softc *sc, uint8_t *rval)
502d0a32c7bStshiozak {
503d0a32c7bStshiozak return read_reg(sc, UCHCOM_REG_STAT1, rval, UCHCOM_REG_STAT2, NULL);
504d0a32c7bStshiozak }
505d0a32c7bStshiozak
506d0a32c7bStshiozak static __inline usbd_status
set_dtrrts_10(struct uchcom_softc * sc,uint8_t val)507d0a32c7bStshiozak set_dtrrts_10(struct uchcom_softc *sc, uint8_t val)
508d0a32c7bStshiozak {
509d0a32c7bStshiozak return write_reg(sc, UCHCOM_REG_STAT1, val, UCHCOM_REG_STAT1, val);
510d0a32c7bStshiozak }
511d0a32c7bStshiozak
512d0a32c7bStshiozak static __inline usbd_status
set_dtrrts_20(struct uchcom_softc * sc,uint8_t val)513d0a32c7bStshiozak set_dtrrts_20(struct uchcom_softc *sc, uint8_t val)
514d0a32c7bStshiozak {
515d0a32c7bStshiozak return generic_control_out(sc, UCHCOM_REQ_SET_DTRRTS, val, 0);
516d0a32c7bStshiozak }
517d0a32c7bStshiozak
518d0a32c7bStshiozak
519d0a32c7bStshiozak /* ----------------------------------------------------------------------
520d0a32c7bStshiozak * middle layer
521d0a32c7bStshiozak */
522d0a32c7bStshiozak
523d0a32c7bStshiozak static int
update_version(struct uchcom_softc * sc)524d0a32c7bStshiozak update_version(struct uchcom_softc *sc)
525d0a32c7bStshiozak {
526d0a32c7bStshiozak usbd_status err;
527d0a32c7bStshiozak
528d0a32c7bStshiozak err = get_version(sc, &sc->sc_version);
529d0a32c7bStshiozak if (err) {
53056556042Sjakllsch device_printf(sc->sc_dev, "cannot get version: %s\n",
5313624455eScube usbd_errstr(err));
532d0a32c7bStshiozak return EIO;
533d0a32c7bStshiozak }
5344011c52eSbouyer DPRINTF(("%s: update_version %d\n", device_xname(sc->sc_dev), sc->sc_version));
535d0a32c7bStshiozak
536d0a32c7bStshiozak return 0;
537d0a32c7bStshiozak }
538d0a32c7bStshiozak
539d0a32c7bStshiozak static void
convert_status(struct uchcom_softc * sc,uint8_t cur)540d0a32c7bStshiozak convert_status(struct uchcom_softc *sc, uint8_t cur)
541d0a32c7bStshiozak {
542d0a32c7bStshiozak sc->sc_dtr = !(cur & UCHCOM_DTR_MASK);
543d0a32c7bStshiozak sc->sc_rts = !(cur & UCHCOM_RTS_MASK);
544d0a32c7bStshiozak
545d0a32c7bStshiozak cur = ~cur & 0x0F;
546d0a32c7bStshiozak sc->sc_msr = (cur << 4) | ((sc->sc_msr >> 4) ^ cur);
547d0a32c7bStshiozak }
548d0a32c7bStshiozak
549d0a32c7bStshiozak static int
update_status(struct uchcom_softc * sc)550d0a32c7bStshiozak update_status(struct uchcom_softc *sc)
551d0a32c7bStshiozak {
552d0a32c7bStshiozak usbd_status err;
553d0a32c7bStshiozak uint8_t cur;
554d0a32c7bStshiozak
555d0a32c7bStshiozak err = get_status(sc, &cur);
556d0a32c7bStshiozak if (err) {
55756556042Sjakllsch device_printf(sc->sc_dev,
5583624455eScube "cannot update status: %s\n", usbd_errstr(err));
559d0a32c7bStshiozak return EIO;
560d0a32c7bStshiozak }
561d0a32c7bStshiozak convert_status(sc, cur);
562d0a32c7bStshiozak
563d0a32c7bStshiozak return 0;
564d0a32c7bStshiozak }
565d0a32c7bStshiozak
566d0a32c7bStshiozak
567d0a32c7bStshiozak static int
set_dtrrts(struct uchcom_softc * sc,int dtr,int rts)568d0a32c7bStshiozak set_dtrrts(struct uchcom_softc *sc, int dtr, int rts)
569d0a32c7bStshiozak {
570d0a32c7bStshiozak usbd_status err;
571d0a32c7bStshiozak uint8_t val = 0;
572d0a32c7bStshiozak
573d0a32c7bStshiozak if (dtr) val |= UCHCOM_DTR_MASK;
574d0a32c7bStshiozak if (rts) val |= UCHCOM_RTS_MASK;
575d0a32c7bStshiozak
576d0a32c7bStshiozak if (sc->sc_version < UCHCOM_VER_20)
577d0a32c7bStshiozak err = set_dtrrts_10(sc, ~val);
578d0a32c7bStshiozak else
579d0a32c7bStshiozak err = set_dtrrts_20(sc, ~val);
580d0a32c7bStshiozak
581d0a32c7bStshiozak if (err) {
58256556042Sjakllsch device_printf(sc->sc_dev, "cannot set DTR/RTS: %s\n",
5833624455eScube usbd_errstr(err));
584d0a32c7bStshiozak return EIO;
585d0a32c7bStshiozak }
586d0a32c7bStshiozak
587d0a32c7bStshiozak return 0;
588d0a32c7bStshiozak }
589d0a32c7bStshiozak
590d0a32c7bStshiozak static int
set_break(struct uchcom_softc * sc,int onoff)591d0a32c7bStshiozak set_break(struct uchcom_softc *sc, int onoff)
592d0a32c7bStshiozak {
593d0a32c7bStshiozak usbd_status err;
594e216d5ceSjakllsch uint8_t brk, lcr;
595d0a32c7bStshiozak
596e216d5ceSjakllsch err = read_reg(sc, UCHCOM_REG_BREAK, &brk, UCHCOM_REG_LCR, &lcr);
597d0a32c7bStshiozak if (err)
598d0a32c7bStshiozak return EIO;
599d0a32c7bStshiozak if (onoff) {
600d0a32c7bStshiozak /* on - clear bits */
601e216d5ceSjakllsch brk &= ~UCHCOM_BREAK_MASK;
602e216d5ceSjakllsch lcr &= ~UCHCOM_LCR_TXE;
603d0a32c7bStshiozak } else {
604d0a32c7bStshiozak /* off - set bits */
605e216d5ceSjakllsch brk |= UCHCOM_BREAK_MASK;
606e216d5ceSjakllsch lcr |= UCHCOM_LCR_TXE;
607d0a32c7bStshiozak }
608e216d5ceSjakllsch err = write_reg(sc, UCHCOM_REG_BREAK, brk, UCHCOM_REG_LCR, lcr);
609d0a32c7bStshiozak if (err)
610d0a32c7bStshiozak return EIO;
611d0a32c7bStshiozak
612d0a32c7bStshiozak return 0;
613d0a32c7bStshiozak }
614d0a32c7bStshiozak
615d0a32c7bStshiozak static int
calc_divider_settings(struct uchcom_divider * dp,uint32_t rate)616d0a32c7bStshiozak calc_divider_settings(struct uchcom_divider *dp, uint32_t rate)
617d0a32c7bStshiozak {
618cecf4762Snisimura /*
619cecf4762Snisimura * combined with rates4x[] defined above, this routine generates,
620cecf4762Snisimura * 1200: prescale = 1/0x1, divisor = 178/0xb2
621cecf4762Snisimura * 2400: prescale = 1/0x1, divisor = 217/0xd9
622cecf4762Snisimura * 4800: prescale = 2/0x2, divisor = 100/0x64
623cecf4762Snisimura * 9600: prescale = 2/0x2, divisor = 178/0xb2
624cecf4762Snisimura * 19200: prescale = 2/0x2, divisor = 217/0xd9
625cecf4762Snisimura * 38400: prescale = 3/0x3, divisor = 100/0x64
626cecf4762Snisimura * 57600: prescale = 2/0x2, divisor = 243/0xf3
627cecf4762Snisimura * 115200: prescale = 3/0x3, divisor = 204/0xcc
628cecf4762Snisimura * 921600: prescale = 7/0x7, divisor = 243/0xf3
629cecf4762Snisimura * 500000: prescale = 3/0x3, divisor = 244/0xf4
630cecf4762Snisimura * 1000000: prescale = 3/0x3, divisor = 250/0xfa
631cecf4762Snisimura * 1500000: prescale = 3/0x3, divisor = 252/0xfc
632cecf4762Snisimura * 2000000: prescale = 3/0x3, divisor = 253/0xfd
633cecf4762Snisimura * 2500000: unsupported
634cecf4762Snisimura * 3000000: prescale = 3/0x3, divisor = 254/0xfe
635cecf4762Snisimura */
636512fc964Sjakllsch size_t i;
637512fc964Sjakllsch uint32_t best, div, pre;
638512fc964Sjakllsch const uint32_t rate4x = rate * 4U;
639d0a32c7bStshiozak
640512fc964Sjakllsch if (rate == 0 || rate > 3000000)
641d0a32c7bStshiozak return -1;
642d0a32c7bStshiozak
643512fc964Sjakllsch pre = __arraycount(rates4x);
644512fc964Sjakllsch best = UINT32_MAX;
645512fc964Sjakllsch
646512fc964Sjakllsch for (i = 0; i < __arraycount(rates4x); i++) {
647512fc964Sjakllsch uint32_t score, try;
648512fc964Sjakllsch try = rates4x[i] * 2 / rate4x;
649512fc964Sjakllsch try = (try / 2) + (try & 1);
650512fc964Sjakllsch if (try < 2)
651512fc964Sjakllsch continue;
652512fc964Sjakllsch if (try > 255)
653512fc964Sjakllsch try = 255;
654512fc964Sjakllsch score = abs((int)rate4x - rates4x[i] / try);
655512fc964Sjakllsch if (score < best) {
656512fc964Sjakllsch best = score;
657512fc964Sjakllsch pre = i;
658512fc964Sjakllsch div = try;
659512fc964Sjakllsch }
660512fc964Sjakllsch }
661512fc964Sjakllsch
662512fc964Sjakllsch if (pre >= __arraycount(rates4x))
663d0a32c7bStshiozak return -1;
664512fc964Sjakllsch if ((rates4x[pre] / div / 4) < (rate * 99 / 100))
665512fc964Sjakllsch return -1;
666512fc964Sjakllsch if ((rates4x[pre] / div / 4) > (rate * 101 / 100))
667512fc964Sjakllsch return -1;
668512fc964Sjakllsch
669512fc964Sjakllsch dp->dv_prescaler = pre;
670cecf4762Snisimura dp->dv_div = 256 - div;
671d0a32c7bStshiozak
672d0a32c7bStshiozak return 0;
673d0a32c7bStshiozak }
674d0a32c7bStshiozak
675d0a32c7bStshiozak static int
set_dte_rate(struct uchcom_softc * sc,uint32_t rate)676d0a32c7bStshiozak set_dte_rate(struct uchcom_softc *sc, uint32_t rate)
677d0a32c7bStshiozak {
678d0a32c7bStshiozak usbd_status err;
679d0a32c7bStshiozak struct uchcom_divider dv;
680d0a32c7bStshiozak
681d0a32c7bStshiozak if (calc_divider_settings(&dv, rate))
682d0a32c7bStshiozak return EINVAL;
683d0a32c7bStshiozak
684d0a32c7bStshiozak if ((err = write_reg(sc,
6857235b322Sjakllsch UCHCOM_REG_BPS_PRE,
6867235b322Sjakllsch dv.dv_prescaler | UCHCOM_BPS_PRE_IMM,
6874e4e99d7Sjakllsch UCHCOM_REG_BPS_DIV, dv.dv_div))) {
68856556042Sjakllsch device_printf(sc->sc_dev, "cannot set DTE rate: %s\n",
6893624455eScube usbd_errstr(err));
690d0a32c7bStshiozak return EIO;
691d0a32c7bStshiozak }
692d0a32c7bStshiozak
693d0a32c7bStshiozak return 0;
694d0a32c7bStshiozak }
695d0a32c7bStshiozak
696d0a32c7bStshiozak static int
set_line_control(struct uchcom_softc * sc,tcflag_t cflag)697d0a32c7bStshiozak set_line_control(struct uchcom_softc *sc, tcflag_t cflag)
698d0a32c7bStshiozak {
699d0a32c7bStshiozak usbd_status err;
700e216d5ceSjakllsch uint8_t lcr = 0, lcr2 = 0;
701d0a32c7bStshiozak
702e216d5ceSjakllsch err = read_reg(sc, UCHCOM_REG_LCR, &lcr, UCHCOM_REG_LCR2, &lcr2);
703d0a32c7bStshiozak if (err) {
70456556042Sjakllsch device_printf(sc->sc_dev, "cannot get LCR: %s\n",
7053624455eScube usbd_errstr(err));
706d0a32c7bStshiozak return EIO;
707d0a32c7bStshiozak }
708d0a32c7bStshiozak
709e216d5ceSjakllsch lcr = UCHCOM_LCR_RXE | UCHCOM_LCR_TXE;
710d0a32c7bStshiozak
711d0a32c7bStshiozak switch (ISSET(cflag, CSIZE)) {
712d0a32c7bStshiozak case CS5:
713e216d5ceSjakllsch lcr |= UCHCOM_LCR_CS5;
714e216d5ceSjakllsch break;
715d0a32c7bStshiozak case CS6:
716e216d5ceSjakllsch lcr |= UCHCOM_LCR_CS6;
717e216d5ceSjakllsch break;
718d0a32c7bStshiozak case CS7:
719e216d5ceSjakllsch lcr |= UCHCOM_LCR_CS7;
720e216d5ceSjakllsch break;
721d0a32c7bStshiozak case CS8:
722e216d5ceSjakllsch lcr |= UCHCOM_LCR_CS8;
723d0a32c7bStshiozak break;
724d0a32c7bStshiozak }
725d0a32c7bStshiozak
726d0a32c7bStshiozak if (ISSET(cflag, PARENB)) {
727e216d5ceSjakllsch lcr |= UCHCOM_LCR_PARENB;
728e216d5ceSjakllsch if (!ISSET(cflag, PARODD))
729e216d5ceSjakllsch lcr |= UCHCOM_LCR_PAREVEN;
730d0a32c7bStshiozak }
731d0a32c7bStshiozak
732e216d5ceSjakllsch if (ISSET(cflag, CSTOPB)) {
733e216d5ceSjakllsch lcr |= UCHCOM_LCR_STOPB;
734e216d5ceSjakllsch }
735e216d5ceSjakllsch
736e216d5ceSjakllsch err = write_reg(sc, UCHCOM_REG_LCR, lcr, UCHCOM_REG_LCR2, lcr2);
737d0a32c7bStshiozak if (err) {
73856556042Sjakllsch device_printf(sc->sc_dev, "cannot set LCR: %s\n",
7393624455eScube usbd_errstr(err));
740d0a32c7bStshiozak return EIO;
741d0a32c7bStshiozak }
742d0a32c7bStshiozak
743d0a32c7bStshiozak return 0;
744d0a32c7bStshiozak }
745d0a32c7bStshiozak
746d0a32c7bStshiozak static int
clear_chip(struct uchcom_softc * sc)747d0a32c7bStshiozak clear_chip(struct uchcom_softc *sc)
748d0a32c7bStshiozak {
749d0a32c7bStshiozak usbd_status err;
750d0a32c7bStshiozak
75149337c88Sdyoung DPRINTF(("%s: clear\n", device_xname(sc->sc_dev)));
752d0a32c7bStshiozak err = generic_control_out(sc, UCHCOM_REQ_RESET, 0, 0);
753d0a32c7bStshiozak if (err) {
75456556042Sjakllsch device_printf(sc->sc_dev, "cannot clear: %s\n",
7553624455eScube usbd_errstr(err));
756d0a32c7bStshiozak return EIO;
757d0a32c7bStshiozak }
758cecf4762Snisimura /*
759cecf4762Snisimura * this REQ_RESET call ends up with
760cecf4762Snisimura * LCR=0xc0 (8N1)
761ffd43472Snisimura * PRE=0x02, DIV=0xd9 (19200)
762cecf4762Snisimura */
763d0a32c7bStshiozak return 0;
764d0a32c7bStshiozak }
765d0a32c7bStshiozak
766d0a32c7bStshiozak static int
setup_comm(struct uchcom_softc * sc)767d0a32c7bStshiozak setup_comm(struct uchcom_softc *sc)
768d0a32c7bStshiozak {
769d0a32c7bStshiozak int ret;
770d0a32c7bStshiozak
771d0a32c7bStshiozak ret = update_version(sc);
772d0a32c7bStshiozak if (ret)
773d0a32c7bStshiozak return ret;
774d0a32c7bStshiozak
775d0a32c7bStshiozak ret = clear_chip(sc);
776d0a32c7bStshiozak if (ret)
777d0a32c7bStshiozak return ret;
778d0a32c7bStshiozak
779d0a32c7bStshiozak ret = set_dte_rate(sc, TTYDEF_SPEED);
780d0a32c7bStshiozak if (ret)
781d0a32c7bStshiozak return ret;
782d0a32c7bStshiozak
783d0a32c7bStshiozak ret = set_line_control(sc, CS8);
784d0a32c7bStshiozak if (ret)
785d0a32c7bStshiozak return ret;
786d0a32c7bStshiozak
787d0a32c7bStshiozak ret = update_status(sc);
788d0a32c7bStshiozak if (ret)
789d0a32c7bStshiozak return ret;
790d0a32c7bStshiozak
791d0a32c7bStshiozak sc->sc_dtr = sc->sc_rts = 1;
792d0a32c7bStshiozak ret = set_dtrrts(sc, sc->sc_dtr, sc->sc_rts);
793d0a32c7bStshiozak if (ret)
794d0a32c7bStshiozak return ret;
795d0a32c7bStshiozak
796d0a32c7bStshiozak return 0;
797d0a32c7bStshiozak }
798d0a32c7bStshiozak
799d0a32c7bStshiozak static int
setup_intr_pipe(struct uchcom_softc * sc)800d0a32c7bStshiozak setup_intr_pipe(struct uchcom_softc *sc)
801d0a32c7bStshiozak {
802d0a32c7bStshiozak usbd_status err;
803d0a32c7bStshiozak
804d0a32c7bStshiozak if (sc->sc_intr_endpoint != -1 && sc->sc_intr_pipe == NULL) {
80571112a2eSskrll sc->sc_intr_buf = kmem_alloc(sc->sc_intr_size, KM_SLEEP);
806d0a32c7bStshiozak err = usbd_open_pipe_intr(sc->sc_iface,
807d0a32c7bStshiozak sc->sc_intr_endpoint,
808d0a32c7bStshiozak USBD_SHORT_XFER_OK,
809d0a32c7bStshiozak &sc->sc_intr_pipe, sc,
810d0a32c7bStshiozak sc->sc_intr_buf,
811d0a32c7bStshiozak sc->sc_intr_size,
812d0a32c7bStshiozak uchcom_intr, USBD_DEFAULT_INTERVAL);
813d0a32c7bStshiozak if (err) {
81456556042Sjakllsch device_printf(sc->sc_dev,
8153624455eScube "cannot open interrupt pipe: %s\n",
816d0a32c7bStshiozak usbd_errstr(err));
817d0a32c7bStshiozak return EIO;
818d0a32c7bStshiozak }
819d0a32c7bStshiozak }
820d0a32c7bStshiozak return 0;
821d0a32c7bStshiozak }
822d0a32c7bStshiozak
823d0a32c7bStshiozak static void
close_intr_pipe(struct uchcom_softc * sc)824d0a32c7bStshiozak close_intr_pipe(struct uchcom_softc *sc)
825d0a32c7bStshiozak {
826d0a32c7bStshiozak
827d0a32c7bStshiozak if (sc->sc_intr_pipe != NULL) {
828c5f8c01eSmrg usbd_abort_pipe(sc->sc_intr_pipe);
829c5f8c01eSmrg usbd_close_pipe(sc->sc_intr_pipe);
830d0a32c7bStshiozak sc->sc_intr_pipe = NULL;
831d0a32c7bStshiozak }
832c5f8c01eSmrg if (sc->sc_intr_buf != NULL) {
833c5f8c01eSmrg kmem_free(sc->sc_intr_buf, sc->sc_intr_size);
834c5f8c01eSmrg sc->sc_intr_buf = NULL;
835c5f8c01eSmrg }
836d0a32c7bStshiozak }
837d0a32c7bStshiozak
838d0a32c7bStshiozak
839d0a32c7bStshiozak /* ----------------------------------------------------------------------
840d0a32c7bStshiozak * methods for ucom
841d0a32c7bStshiozak */
842b88e5d5dSmrg static void
uchcom_get_status(void * arg,int portno,u_char * rlsr,u_char * rmsr)843d0a32c7bStshiozak uchcom_get_status(void *arg, int portno, u_char *rlsr, u_char *rmsr)
844d0a32c7bStshiozak {
845d0a32c7bStshiozak struct uchcom_softc *sc = arg;
846d0a32c7bStshiozak
847d0a32c7bStshiozak if (sc->sc_dying)
848d0a32c7bStshiozak return;
849d0a32c7bStshiozak
850d0a32c7bStshiozak *rlsr = sc->sc_lsr;
851d0a32c7bStshiozak *rmsr = sc->sc_msr;
852d0a32c7bStshiozak }
853d0a32c7bStshiozak
854b88e5d5dSmrg static void
uchcom_set(void * arg,int portno,int reg,int onoff)855d0a32c7bStshiozak uchcom_set(void *arg, int portno, int reg, int onoff)
856d0a32c7bStshiozak {
857d0a32c7bStshiozak struct uchcom_softc *sc = arg;
858d0a32c7bStshiozak
859d0a32c7bStshiozak if (sc->sc_dying)
860d0a32c7bStshiozak return;
861d0a32c7bStshiozak
862d0a32c7bStshiozak switch (reg) {
863d0a32c7bStshiozak case UCOM_SET_DTR:
864d0a32c7bStshiozak sc->sc_dtr = !!onoff;
865d0a32c7bStshiozak set_dtrrts(sc, sc->sc_dtr, sc->sc_rts);
866d0a32c7bStshiozak break;
867d0a32c7bStshiozak case UCOM_SET_RTS:
868d0a32c7bStshiozak sc->sc_rts = !!onoff;
869d0a32c7bStshiozak set_dtrrts(sc, sc->sc_dtr, sc->sc_rts);
870d0a32c7bStshiozak break;
871d0a32c7bStshiozak case UCOM_SET_BREAK:
872d0a32c7bStshiozak set_break(sc, onoff);
873d0a32c7bStshiozak break;
874d0a32c7bStshiozak }
875d0a32c7bStshiozak }
876d0a32c7bStshiozak
877b88e5d5dSmrg static int
uchcom_param(void * arg,int portno,struct termios * t)878d0a32c7bStshiozak uchcom_param(void *arg, int portno, struct termios *t)
879d0a32c7bStshiozak {
880d0a32c7bStshiozak struct uchcom_softc *sc = arg;
881d0a32c7bStshiozak int ret;
882d0a32c7bStshiozak
883d0a32c7bStshiozak if (sc->sc_dying)
88425e6116aSmrg return EIO;
885d0a32c7bStshiozak
886d0a32c7bStshiozak ret = set_line_control(sc, t->c_cflag);
887d0a32c7bStshiozak if (ret)
888d0a32c7bStshiozak return ret;
889d0a32c7bStshiozak
890d0a32c7bStshiozak ret = set_dte_rate(sc, t->c_ospeed);
891d0a32c7bStshiozak if (ret)
892d0a32c7bStshiozak return ret;
893d0a32c7bStshiozak
894d0a32c7bStshiozak return 0;
895d0a32c7bStshiozak }
896d0a32c7bStshiozak
897b88e5d5dSmrg static int
uchcom_open(void * arg,int portno)898d0a32c7bStshiozak uchcom_open(void *arg, int portno)
899d0a32c7bStshiozak {
900d0a32c7bStshiozak int ret;
901d0a32c7bStshiozak struct uchcom_softc *sc = arg;
902d0a32c7bStshiozak
903c5f8c01eSmrg if (sc->sc_dying)
904d0a32c7bStshiozak return EIO;
905b88e5d5dSmrg
906b88e5d5dSmrg ret = setup_intr_pipe(sc);
907c5f8c01eSmrg if (ret)
908b88e5d5dSmrg return ret;
909c5f8c01eSmrg
910c5f8c01eSmrg ret = setup_comm(sc);
911c5f8c01eSmrg if (ret)
912c5f8c01eSmrg return ret;
913c5f8c01eSmrg
914c5f8c01eSmrg return 0;
915b88e5d5dSmrg }
916b88e5d5dSmrg
917b88e5d5dSmrg static void
uchcom_close(void * arg,int portno)918d0a32c7bStshiozak uchcom_close(void *arg, int portno)
919d0a32c7bStshiozak {
920d0a32c7bStshiozak struct uchcom_softc *sc = arg;
921d0a32c7bStshiozak
922c5f8c01eSmrg if (sc->sc_dying)
923c5f8c01eSmrg return;
924c5f8c01eSmrg
925d0a32c7bStshiozak close_intr_pipe(sc);
926d0a32c7bStshiozak }
927d0a32c7bStshiozak
928d0a32c7bStshiozak
929d0a32c7bStshiozak /* ----------------------------------------------------------------------
930d0a32c7bStshiozak * callback when the modem status is changed.
931d0a32c7bStshiozak */
932b88e5d5dSmrg static void
uchcom_intr(struct usbd_xfer * xfer,void * priv,usbd_status status)93371112a2eSskrll uchcom_intr(struct usbd_xfer *xfer, void * priv,
934d0a32c7bStshiozak usbd_status status)
935d0a32c7bStshiozak {
936d0a32c7bStshiozak struct uchcom_softc *sc = priv;
937d0a32c7bStshiozak u_char *buf = sc->sc_intr_buf;
938d0a32c7bStshiozak
939d0a32c7bStshiozak if (sc->sc_dying)
940d0a32c7bStshiozak return;
941d0a32c7bStshiozak
942d0a32c7bStshiozak if (status != USBD_NORMAL_COMPLETION) {
943d0a32c7bStshiozak if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)
944d0a32c7bStshiozak return;
945d0a32c7bStshiozak
946d0a32c7bStshiozak DPRINTF(("%s: abnormal status: %s\n",
94749337c88Sdyoung device_xname(sc->sc_dev), usbd_errstr(status)));
948d0a32c7bStshiozak usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);
949d0a32c7bStshiozak return;
950d0a32c7bStshiozak }
9514f8d1b77Schristos DPRINTF(("%s: intr: 0x%02X 0x%02X 0x%02X 0x%02X "
9524f8d1b77Schristos "0x%02X 0x%02X 0x%02X 0x%02X\n",
95349337c88Sdyoung device_xname(sc->sc_dev),
954d0a32c7bStshiozak (unsigned)buf[0], (unsigned)buf[1],
955d0a32c7bStshiozak (unsigned)buf[2], (unsigned)buf[3],
956d0a32c7bStshiozak (unsigned)buf[4], (unsigned)buf[5],
957d0a32c7bStshiozak (unsigned)buf[6], (unsigned)buf[7]));
958d0a32c7bStshiozak
959d0a32c7bStshiozak convert_status(sc, buf[UCHCOM_INTR_STAT1]);
9603624455eScube ucom_status_change(device_private(sc->sc_subdev));
961d0a32c7bStshiozak }
962