1/*	$NetBSD: stuirda.c,v 1.13 2011/12/23 00:51:44 jakllsch Exp $	*/
2
3/*
4 * Copyright (c) 2001,2007 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Lennart Augustsson (lennart@augustsson.net).
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 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32#include <sys/cdefs.h>
33__KERNEL_RCSID(0, "$NetBSD: stuirda.c,v 1.13 2011/12/23 00:51:44 jakllsch Exp $");
34
35#include <sys/param.h>
36
37#include <sys/device.h>
38#include <sys/systm.h>
39#include <sys/kernel.h>
40#include <sys/device.h>
41#include <sys/ioctl.h>
42#include <sys/conf.h>
43#include <sys/file.h>
44#include <sys/poll.h>
45#include <sys/select.h>
46#include <sys/proc.h>
47
48
49#include <dev/firmload.h>
50#include <dev/usb/usb.h>
51#include <dev/usb/usbdi.h>
52#include <dev/usb/usbdi_util.h>
53#include <dev/usb/usbdevs.h>
54
55#include <dev/ir/ir.h>
56#include <dev/ir/irdaio.h>
57#include <dev/ir/irframevar.h>
58
59#include <dev/usb/uirdavar.h>
60
61#ifdef UIRDA_DEBUG
62#define DPRINTF(x)	if (stuirdadebug) printf x
63#define DPRINTFN(n,x)	if (stuirdadebug>(n)) printf x
64int	stuirdadebug = 1;
65#else
66#define DPRINTF(x)
67#define DPRINTFN(n,x)
68#endif
69
70struct stuirda_softc {
71	struct uirda_softc sc_uirda;
72};
73
74int stuirda_fwload(struct uirda_softc *sc);
75
76/*
77 * These devices need firmware download.
78 */
79Static const struct usb_devno stuirda_devs[] = {
80	{ USB_VENDOR_SIGMATEL, USB_PRODUCT_SIGMATEL_SIR4116 },
81	{ USB_VENDOR_SIGMATEL, USB_PRODUCT_SIGMATEL_FIR4210 },
82	{ USB_VENDOR_SIGMATEL, USB_PRODUCT_SIGMATEL_VFIR4220 },
83};
84#define stuirda_lookup(v, p) (usb_lookup(stuirda_devs, v, p))
85
86int stuirda_write(void *h, struct uio *uio, int flag);
87
88struct irframe_methods stuirda_methods = {
89	uirda_open, uirda_close, uirda_read, stuirda_write, uirda_poll,
90	uirda_kqfilter, uirda_set_params, uirda_get_speeds,
91	uirda_get_turnarounds
92};
93
94#define STUIRDA_HEADER_SIZE 3
95
96#define stuirda_activate uirda_activate
97#define stuirda_detach uirda_detach
98
99int             stuirda_match(device_t, cfdata_t, void *);
100void            stuirda_attach(device_t, device_t, void *);
101int             stuirda_detach(device_t, int);
102int             stuirda_activate(device_t, enum devact);
103extern struct cfdriver stuirda_cd;
104CFATTACH_DECL_NEW(stuirda, sizeof(struct stuirda_softc), stuirda_match, stuirda_attach, stuirda_detach, stuirda_activate);
105
106int
107stuirda_match(device_t parent, cfdata_t match, void *aux)
108{
109	struct usbif_attach_arg *uaa = aux;
110
111	DPRINTFN(50,("stuirda_match\n"));
112
113	if (stuirda_lookup(uaa->vendor, uaa->product) != NULL)
114		return (UMATCH_VENDOR_PRODUCT);
115
116	return (UMATCH_NONE);
117}
118
119void uirda_attach(device_t, device_t, void *);
120
121void
122stuirda_attach(device_t parent, device_t self, void *aux)
123{
124	struct stuirda_softc *sc = device_private(self);
125
126	sc->sc_uirda.sc_loadfw = stuirda_fwload;
127	sc->sc_uirda.sc_irm = &stuirda_methods;
128	sc->sc_uirda.sc_hdszi = STUIRDA_HEADER_SIZE;
129
130	uirda_attach(parent,self,aux);
131}
132
133int
134stuirda_fwload(struct uirda_softc *sc) {
135
136
137	int rc;
138	firmware_handle_t fh;
139	off_t fwsize;
140	usb_device_descriptor_t usbddsc;
141	usbd_xfer_handle	fwxfer;
142	usbd_pipe_handle	fwpipe;
143	usbd_status status;
144	usb_device_request_t req;
145	char *buffer;
146	char *p;
147	char fwname[12];
148	int n;
149	u_int8_t *usbbuf;
150	/* size_t bsize; */
151
152	printf("%s: needing to download firmware\n",
153		device_xname(sc->sc_dev));
154
155	status = usbd_get_device_desc(sc->sc_udev, &usbddsc);
156	if (status) {
157		printf("%s: can't get device descriptor, status %d\n",
158		    device_xname(sc->sc_dev), status);
159		return status;
160	}
161
162	rc = usbd_get_class_desc(sc->sc_udev, UDESC_IRDA, 0,
163		USB_IRDA_DESCRIPTOR_SIZE, &sc->sc_irdadesc);
164	printf("error %d reading class desc\n", rc);
165
166	snprintf(fwname, sizeof(fwname), "4210%02x%02x.sb",
167		usbddsc.bcdDevice[1],
168		usbddsc.bcdDevice[0]);
169
170	printf("%s: Attempting to load firmware %s\n",
171		device_xname(sc->sc_dev), fwname);
172
173	rc = firmware_open("stuirda", fwname, &fh);
174
175	if (rc) {
176		printf("%s: Cannot load firmware\n",
177			device_xname(sc->sc_dev));
178		return 0;
179		return rc;
180	}
181	fwsize = firmware_get_size(fh);
182
183	printf("%s: Firmware size %lld\n",
184		device_xname(sc->sc_dev), (long long)fwsize);
185
186	buffer = firmware_malloc(fwsize);
187	if (buffer == NULL) {
188		printf("%s: Cannot load firmware: out of memory\n",
189			device_xname(sc->sc_dev));
190		goto giveup2;
191	}
192
193	rc = firmware_read(fh, 0, buffer, (size_t)fwsize);
194
195	if (rc) {
196		printf("%s: Cannot read firmware\n", device_xname(sc->sc_dev));
197		goto giveup3;
198	}
199
200	for (p = buffer + sizeof("Product Version:");
201	    p < buffer + fwsize - 5; p++) {
202
203		if (0x1A == *p)
204			break;
205	}
206	if (0x1a != *p || memcmp(p+1, "STMP", 4) != 0) {
207		/* firmware bad */
208		printf("%s: Bad firmware\n", device_xname(sc->sc_dev));
209		goto giveup3;
210	}
211
212	p += 5;
213
214	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
215	req.bRequest = 2 /* XXX magic */;
216	USETW(req.wValue, 0);
217	USETW(req.wIndex, 0);
218	USETW(req.wLength, 0);
219	rc = usbd_do_request(sc->sc_udev, &req, 0);
220	if (rc) {
221		printf("%s: Cannot switch to f/w d/l mode, error %d\n",
222			device_xname(sc->sc_dev), rc);
223		goto giveup3;
224	}
225
226	delay(100000);
227
228	rc = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &fwpipe);
229	if (rc) {
230		printf("%s: Cannot open pipe, rc=%d\n",
231		    device_xname(sc->sc_dev), rc);
232		goto giveup3;
233	}
234	fwxfer = usbd_alloc_xfer(sc->sc_udev);
235	if (fwxfer == NULL) {
236		printf("%s: Cannot alloc xfer\n", device_xname(sc->sc_dev));
237		goto giveup4;
238	}
239	usbbuf = usbd_alloc_buffer(fwxfer, 1024);
240	if (usbbuf == NULL) {
241		printf("%s: Cannot alloc usb buf\n", device_xname(sc->sc_dev));
242		goto giveup5;
243	}
244	n = (buffer + fwsize - p);
245	while (n > 0) {
246		if (n > 1023)
247			n = 1023;
248		memcpy(usbbuf, p, n);
249		rc = usbd_bulk_transfer(fwxfer, fwpipe,
250		    USBD_SYNCHRONOUS|USBD_FORCE_SHORT_XFER,
251		    5000, usbbuf, &n, "uirda-fw-wr");
252		printf("%s: write: rc=%d, %d left\n",
253		    device_xname(sc->sc_dev), rc, n);
254		if (rc) {
255			printf("%s: write: rc=%d, %d bytes written\n",
256			    device_xname(sc->sc_dev), rc, n);
257			goto giveup4;
258		}
259		printf("%s: written %d\n", device_xname(sc->sc_dev), n);
260		p += n;
261		n = (buffer + fwsize - p);
262	}
263	delay(100000);
264	/* TODO: more code here */
265	rc = 0;
266	usbd_free_buffer(fwxfer);
267
268	giveup5: usbd_free_xfer(fwxfer);
269	giveup4: usbd_close_pipe(fwpipe);
270	giveup3: firmware_free(buffer, fwsize);
271	giveup2: firmware_close(fh);
272
273	return rc;
274
275}
276
277int
278stuirda_write(void *h, struct uio *uio, int flag)
279{
280	struct uirda_softc *sc = h;
281	usbd_status err;
282	u_int32_t n;
283	int error = 0;
284
285	DPRINTFN(1,("%s: sc=%p\n", __func__, sc));
286
287	if (sc->sc_dying)
288		return (EIO);
289
290#ifdef DIAGNOSTIC
291	if (sc->sc_wr_buf == NULL)
292		return (EINVAL);
293#endif
294
295	n = uio->uio_resid;
296	if (n > sc->sc_params.maxsize)
297		return (EINVAL);
298
299	sc->sc_refcnt++;
300	mutex_enter(&sc->sc_wr_buf_lk);
301
302	sc->sc_wr_buf[0] = UIRDA_EB_NO_CHANGE | UIRDA_NO_SPEED;
303
304	sc->sc_wr_buf[1] = 0;
305	sc->sc_wr_buf[2] = 7; /* XXX turnaround - maximum for now */
306	if ((n > 0 && (n % 128) == 0 && (n % 512) != 0)) {
307		sc->sc_wr_buf[1] = 1;
308	}
309
310	error = uiomove(sc->sc_wr_buf + STUIRDA_HEADER_SIZE, n, uio);
311	if (!error) {
312		DPRINTFN(1, ("uirdawrite: transfer %d bytes\n", n));
313
314		n += STUIRDA_HEADER_SIZE + sc->sc_wr_buf[1];
315		err = usbd_bulk_transfer(sc->sc_wr_xfer, sc->sc_wr_pipe,
316			  USBD_FORCE_SHORT_XFER|USBD_NO_COPY,
317			  UIRDA_WR_TIMEOUT,
318			  sc->sc_wr_buf, &n, "uirdawr");
319		DPRINTFN(2, ("uirdawrite: err=%d\n", err));
320		if (err) {
321			if (err == USBD_INTERRUPTED)
322				error = EINTR;
323			else if (err == USBD_TIMEOUT)
324				error = ETIMEDOUT;
325			else
326				error = EIO;
327		}
328	}
329
330	mutex_exit(&sc->sc_wr_buf_lk);
331	if (--sc->sc_refcnt < 0)
332		usb_detach_wakeup(sc->sc_dev);
333
334	DPRINTFN(1,("%s: sc=%p done\n", __func__, sc));
335	return (error);
336}
337