Home | History | Annotate | Line # | Download | only in usb
stuirda.c revision 1.15
      1 /*	$NetBSD: stuirda.c,v 1.14 2012/03/06 03:35:29 mrg 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 (at) 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.14 2012/03/06 03:35:29 mrg 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
     64 int	stuirdadebug = 1;
     65 #else
     66 #define DPRINTF(x)
     67 #define DPRINTFN(n,x)
     68 #endif
     69 
     70 struct stuirda_softc {
     71 	struct uirda_softc sc_uirda;
     72 };
     73 
     74 int stuirda_fwload(struct uirda_softc *sc);
     75 
     76 /*
     77  * These devices need firmware download.
     78  */
     79 Static 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 
     86 int stuirda_write(void *h, struct uio *uio, int flag);
     87 
     88 struct 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 
     99 int             stuirda_match(device_t, cfdata_t, void *);
    100 void            stuirda_attach(device_t, device_t, void *);
    101 int             stuirda_detach(device_t, int);
    102 int             stuirda_activate(device_t, enum devact);
    103 extern struct cfdriver stuirda_cd;
    104 CFATTACH_DECL_NEW(stuirda, sizeof(struct stuirda_softc), stuirda_match, stuirda_attach, stuirda_detach, stuirda_activate);
    105 
    106 int
    107 stuirda_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 
    119 void uirda_attach(device_t, device_t, void *);
    120 
    121 void
    122 stuirda_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 
    133 int
    134 stuirda_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 
    277 int
    278 stuirda_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_wakeupold(sc->sc_dev);
    333 
    334 	DPRINTFN(1,("%s: sc=%p done\n", __func__, sc));
    335 	return (error);
    336 }
    337