xref: /netbsd-src/sys/dev/usb/uipaq.c (revision 404fbe5fb94ca1e054339640cabb2801ce52dd30) 
1 /*	$NetBSD: uipaq.c,v 1.13 2008/07/08 08:47:32 uebayasi Exp $	*/
2 /*	$OpenBSD: uipaq.c,v 1.1 2005/06/17 23:50:33 deraadt Exp $	*/
3 
4 /*
5  * Copyright (c) 2000-2005 The NetBSD Foundation, Inc.
6  * All rights reserved.
7  *
8  * This code is derived from software contributed to The NetBSD Foundation
9  * by Lennart Augustsson (lennart@augustsson.net) at
10  * Carlstedt Research & Technology.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
25  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31  * POSSIBILITY OF SUCH DAMAGE.
32  */
33 
34 /*
35  * iPAQ driver
36  *
37  * 19 July 2003:	Incorporated changes suggested by Sam Lawrance from
38  * 			the uppc module
39  *
40  *
41  * Contact isis@cs.umd.edu if you have any questions/comments about this driver
42  */
43 
44 #include <sys/cdefs.h>
45 __KERNEL_RCSID(0, "$NetBSD: uipaq.c,v 1.13 2008/07/08 08:47:32 uebayasi Exp $");
46 
47 #include <sys/param.h>
48 #include <sys/systm.h>
49 #include <sys/kernel.h>
50 #include <sys/device.h>
51 #include <sys/conf.h>
52 #include <sys/tty.h>
53 
54 #include <dev/usb/usb.h>
55 
56 #include <dev/usb/usbcdc.h>	/*UCDC_* stuff */
57 
58 #include <dev/usb/usbdi.h>
59 #include <dev/usb/usbdi_util.h>
60 #include <dev/usb/usbdevs.h>
61 
62 #include <dev/usb/ucomvar.h>
63 
64 #ifdef UIPAQ_DEBUG
65 #define DPRINTF(x)	if (uipaqdebug) printf x
66 #define DPRINTFN(n,x)	if (uipaqdebug>(n)) printf x
67 int uipaqdebug = 0;
68 #else
69 #define DPRINTF(x)
70 #define DPRINTFN(n,x)
71 #endif
72 
73 #define UIPAQ_CONFIG_NO		1
74 #define UIPAQ_IFACE_INDEX	0
75 
76 #define UIPAQIBUFSIZE 1024
77 #define UIPAQOBUFSIZE 1024
78 
79 struct uipaq_softc {
80 	USBBASEDEVICE		sc_dev;		/* base device */
81 	usbd_device_handle	sc_udev;	/* device */
82 	usbd_interface_handle	sc_iface;	/* interface */
83 
84 	device_t		sc_subdev;	/* ucom uses that */
85 	u_int16_t		sc_lcr;		/* state for DTR/RTS */
86 
87 	u_int16_t		sc_flags;
88 
89 	u_char			sc_dying;
90 };
91 
92 /* Callback routines */
93 Static void	uipaq_set(void *, int, int, int);
94 
95 
96 /* Support routines. */
97 /* based on uppc module by Sam Lawrance */
98 Static void	uipaq_dtr(struct uipaq_softc *sc, int onoff);
99 Static void	uipaq_rts(struct uipaq_softc *sc, int onoff);
100 Static void	uipaq_break(struct uipaq_softc* sc, int onoff);
101 
102 
103 struct ucom_methods uipaq_methods = {
104 	NULL,
105 	uipaq_set,
106 	NULL,
107 	NULL,
108 	NULL,	/*open*/
109 	NULL,	/*close*/
110 	NULL,
111 	NULL
112 };
113 
114 struct uipaq_type {
115 	struct usb_devno	uv_dev;
116 	u_int16_t		uv_flags;
117 };
118 
119 static const struct uipaq_type uipaq_devs[] = {
120 	{{ USB_VENDOR_HP, USB_PRODUCT_HP_2215 }, 0 },
121 	{{ USB_VENDOR_HP, USB_PRODUCT_HP_568J }, 0},
122 	{{ USB_VENDOR_COMPAQ, USB_PRODUCT_COMPAQ_IPAQPOCKETPC} , 0},
123 	{{ USB_VENDOR_CASIO, USB_PRODUCT_CASIO_BE300} , 0},
124 	{{ USB_VENDOR_SHARP, USB_PRODUCT_SHARP_WS007SH} , 0},
125 	{{ USB_VENDOR_SHARP, USB_PRODUCT_SHARP_WS011SH} , 0}
126 };
127 
128 #define uipaq_lookup(v, p) ((const struct uipaq_type *)usb_lookup(uipaq_devs, v, p))
129 
130 int uipaq_match(device_t, cfdata_t, void *);
131 void uipaq_attach(device_t, device_t, void *);
132 void uipaq_childdet(device_t, device_t);
133 int uipaq_detach(device_t, int);
134 int uipaq_activate(device_t, enum devact);
135 extern struct cfdriver uipaq_cd;
136 CFATTACH_DECL2_NEW(uipaq, sizeof(struct uipaq_softc), uipaq_match,
137     uipaq_attach, uipaq_detach, uipaq_activate, NULL, uipaq_childdet);
138 
139 USB_MATCH(uipaq)
140 {
141 	USB_MATCH_START(uipaq, uaa);
142 
143 	DPRINTFN(20,("uipaq: vendor=0x%x, product=0x%x\n",
144 	    uaa->vendor, uaa->product));
145 
146 	return (uipaq_lookup(uaa->vendor, uaa->product) != NULL ?
147 	    UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
148 }
149 
150 USB_ATTACH(uipaq)
151 {
152 	USB_ATTACH_START(uipaq, sc, uaa);
153 	usbd_device_handle dev = uaa->device;
154 	usbd_interface_handle iface;
155 	usb_interface_descriptor_t *id;
156 	usb_endpoint_descriptor_t *ed;
157 	char *devinfop;
158 	const char *devname = device_xname(self);
159 	int i;
160 	usbd_status err;
161 	struct ucom_attach_args uca;
162 
163 	DPRINTFN(10,("\nuipaq_attach: sc=%p\n", sc));
164 
165 	sc->sc_dev = self;
166 
167 	/* Move the device into the configured state. */
168 	err = usbd_set_config_no(dev, UIPAQ_CONFIG_NO, 1);
169 	if (err) {
170 		aprint_error("\n%s: failed to set configuration, err=%s\n",
171 		    devname, usbd_errstr(err));
172 		goto bad;
173 	}
174 
175 	err = usbd_device2interface_handle(dev, UIPAQ_IFACE_INDEX, &iface);
176 	if (err) {
177 		aprint_error("\n%s: failed to get interface, err=%s\n",
178 		    devname, usbd_errstr(err));
179 		goto bad;
180 	}
181 
182 	devinfop = usbd_devinfo_alloc(dev, 0);
183 	USB_ATTACH_SETUP;
184 	aprint_normal_dev(self, "%s\n", devinfop);
185 	usbd_devinfo_free(devinfop);
186 
187 	sc->sc_flags = uipaq_lookup(uaa->vendor, uaa->product)->uv_flags;
188 
189 	id = usbd_get_interface_descriptor(iface);
190 
191 	sc->sc_udev = dev;
192 	sc->sc_iface = iface;
193 
194 	uca.ibufsize = UIPAQIBUFSIZE;
195 	uca.obufsize = UIPAQOBUFSIZE;
196 	uca.ibufsizepad = UIPAQIBUFSIZE;
197 	uca.opkthdrlen = 0;
198 	uca.device = dev;
199 	uca.iface = iface;
200 	uca.methods = &uipaq_methods;
201 	uca.arg = sc;
202 	uca.portno = UCOM_UNK_PORTNO;
203 	uca.info = "Generic";
204 
205 /*	err = uipaq_init(sc);
206 	if (err) {
207 		printf("%s: init failed, %s\n", USBDEVNAME(sc->sc_dev),
208 		    usbd_errstr(err));
209 		goto bad;
210 	}*/
211 
212 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
213 	    USBDEV(sc->sc_dev));
214 
215 	uca.bulkin = uca.bulkout = -1;
216 	for (i=0; i<id->bNumEndpoints; i++) {
217 		ed = usbd_interface2endpoint_descriptor(iface, i);
218 		if (ed == NULL) {
219 			aprint_error_dev(self,
220 			    "no endpoint descriptor for %d\n", i);
221 			goto bad;
222 		}
223 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
224 		    (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
225 			uca.bulkin = ed->bEndpointAddress;
226 		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
227 		    (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
228 			uca.bulkout = ed->bEndpointAddress;
229 		}
230 	}
231 	if (uca.bulkin == -1 || uca.bulkout == -1) {
232 		aprint_error_dev(self, "no proper endpoints found (%d,%d) \n",
233 		    uca.bulkin, uca.bulkout);
234 		USB_ATTACH_ERROR_RETURN;
235 	}
236 
237 	sc->sc_subdev = config_found_sm_loc(self, "ucombus", NULL, &uca,
238 					    ucomprint, ucomsubmatch);
239 
240 	USB_ATTACH_SUCCESS_RETURN;
241 
242 bad:
243 	DPRINTF(("uipaq_attach: ATTACH ERROR\n"));
244 	sc->sc_dying = 1;
245 	USB_ATTACH_ERROR_RETURN;
246 }
247 
248 
249 void
250 uipaq_dtr(struct uipaq_softc* sc, int onoff)
251 {
252 	usb_device_request_t req;
253 	usbd_status err;
254 	int retries = 3;
255 
256 	DPRINTF(("%s: uipaq_dtr: onoff=%x\n", USBDEVNAME(sc->sc_dev), onoff));
257 
258 	/* Avoid sending unnecessary requests */
259 	if (onoff && (sc->sc_lcr & UCDC_LINE_DTR))
260 		return;
261 	if (!onoff && !(sc->sc_lcr & UCDC_LINE_DTR))
262 		return;
263 
264 	/* Other parameters depend on reg */
265 	req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
266 	req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
267 	sc->sc_lcr = onoff ? sc->sc_lcr | UCDC_LINE_DTR : sc->sc_lcr & ~UCDC_LINE_DTR;
268 	USETW(req.wValue, sc->sc_lcr);
269 	USETW(req.wIndex, 0x0);
270 	USETW(req.wLength, 0);
271 
272 	/* Fire off the request a few times if necessary */
273 	while (retries) {
274 		err = usbd_do_request(sc->sc_udev, &req, NULL);
275 		if (!err)
276 			break;
277 		retries--;
278 	}
279 }
280 
281 
282 void
283 uipaq_rts(struct uipaq_softc* sc, int onoff)
284 {
285 	usb_device_request_t req;
286 	usbd_status err;
287 	int retries = 3;
288 
289 	DPRINTF(("%s: uipaq_rts: onoff=%x\n", USBDEVNAME(sc->sc_dev), onoff));
290 
291 	/* Avoid sending unnecessary requests */
292 	if (onoff && (sc->sc_lcr & UCDC_LINE_RTS)) return;
293 	if (!onoff && !(sc->sc_lcr & UCDC_LINE_RTS)) return;
294 
295 	req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
296 	req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
297 	sc->sc_lcr = onoff ? sc->sc_lcr | UCDC_LINE_RTS : sc->sc_lcr & ~UCDC_LINE_RTS;
298 	USETW(req.wValue, sc->sc_lcr);
299 	USETW(req.wIndex, 0x0);
300 	USETW(req.wLength, 0);
301 
302 	while (retries) {
303 		err = usbd_do_request(sc->sc_udev, &req, NULL);
304 		if (!err)
305 			break;
306 		retries--;
307 	}
308 }
309 
310 
311 void
312 uipaq_break(struct uipaq_softc* sc, int onoff)
313 {
314 	usb_device_request_t req;
315 	usbd_status err;
316 	int retries = 3;
317 
318 	DPRINTF(("%s: uipaq_break: onoff=%x\n", USBDEVNAME(sc->sc_dev), onoff));
319 
320 	req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
321 	req.bRequest = UCDC_SEND_BREAK;
322 
323 	USETW(req.wValue, onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF);
324 	USETW(req.wIndex, 0x0);
325 	USETW(req.wLength, 0);
326 
327 	while (retries) {
328 		err = usbd_do_request(sc->sc_udev, &req, NULL);
329 		if (!err)
330 			break;
331 		retries--;
332 	}
333 }
334 
335 
336 void
337 uipaq_set(void *addr, int portno, int reg, int onoff)
338 {
339 	struct uipaq_softc* sc = addr;
340 
341 	switch (reg) {
342 	case UCOM_SET_DTR:
343 		uipaq_dtr(addr, onoff);
344 		break;
345 	case UCOM_SET_RTS:
346 		uipaq_rts(addr, onoff);
347 		break;
348 	case UCOM_SET_BREAK:
349 		uipaq_break(addr, onoff);
350 		break;
351 	default:
352 		aprint_error_dev(sc->sc_dev,
353 		    "unhandled set request: reg=%x onoff=%x\n", reg, onoff);
354 		return;
355 	}
356 }
357 
358 
359 int
360 uipaq_activate(device_t self, enum devact act)
361 {
362 	struct uipaq_softc *sc = device_private(self);
363 	int rv = 0;
364 
365 	switch (act) {
366 	case DVACT_ACTIVATE:
367 		return (EOPNOTSUPP);
368 		break;
369 
370 	case DVACT_DEACTIVATE:
371 		if (sc->sc_subdev != NULL)
372 			rv = config_deactivate(sc->sc_subdev);
373 		sc->sc_dying = 1;
374 		break;
375 	}
376 	return (rv);
377 }
378 
379 void
380 uipaq_childdet(device_t self, device_t child)
381 {
382 	struct uipaq_softc *sc = device_private(self);
383 
384 	KASSERT(sc->sc_subdev == child);
385 	sc->sc_subdev = NULL;
386 }
387 
388 int
389 uipaq_detach(device_t self, int flags)
390 {
391 	struct uipaq_softc *sc = device_private(self);
392 	int rv = 0;
393 
394 	DPRINTF(("uipaq_detach: sc=%p flags=%d\n", sc, flags));
395 	sc->sc_dying = 1;
396 	if (sc->sc_subdev != NULL)
397 		rv |= config_detach(sc->sc_subdev, flags);
398 
399 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
400 	    USBDEV(sc->sc_dev));
401 
402 	return (rv);
403 }
404 
405