NetBSD/sys/dev/usb/ubtbcmfw.c

297 lines
8.0 KiB
C

/* $NetBSD: ubtbcmfw.c,v 1.9 2004/09/17 14:11:24 skrll Exp $ */
/*
* Copyright (c) 2002 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Lennart Augustsson <lennart@augustsson.net>.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the NetBSD
* Foundation, Inc. and its contributors.
* 4. Neither the name of The NetBSD Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ubtbcmfw.c,v 1.9 2004/09/17 14:11:24 skrll Exp $");
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/conf.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/proc.h>
#include <sys/fcntl.h>
#include <sys/sysctl.h>
#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbdevs.h>
/*
* Download firmware to BCM2033.
*/
#define CONFIG_NO 1
#define IFACE_IDX 0 /* Control interface */
/* Fixed endpoints */
#define INTR_IN_EP 0x81
#define BULK_OUT_EP 0x02
Static char ubtbcmfw_fwpath[128] = "/usr/libdata/firmware/bcm2033";
#define MINI_DRIVER "BCM2033-MD.hex"
#define FIRMWARE "BCM2033-FW.bin"
struct ubtbcmfw_softc {
USBBASEDEVICE sc_dev; /* base device */
};
Static int
ubtbcmfw_load_file(usbd_device_handle dev, usbd_pipe_handle out,
const char *filename);
Static usbd_status
ubtbcmfw_write(usbd_device_handle dev, usbd_pipe_handle out,
char *buf, uint count);
Static usbd_status
ubtbcmfw_read(usbd_device_handle dev, usbd_pipe_handle in,
char *buf, uint *count);
USB_DECLARE_DRIVER(ubtbcmfw);
USB_MATCH(ubtbcmfw)
{
USB_MATCH_START(ubtbcmfw, uaa);
if (uaa->iface != NULL)
return (UMATCH_NONE);
/* Match the boot device. */
if (uaa->vendor == USB_VENDOR_BROADCOM &&
uaa->product == USB_PRODUCT_BROADCOM_BCM2033NF)
return (UMATCH_VENDOR_PRODUCT);
return (UMATCH_NONE);
}
USB_ATTACH(ubtbcmfw)
{
USB_ATTACH_START(ubtbcmfw, sc, uaa);
usbd_device_handle dev = uaa->device;
usbd_interface_handle iface;
usbd_status err;
char devinfo[1024];
char name[256];
char buf[16];
usbd_pipe_handle intr_in_pipe;
usbd_pipe_handle bulk_out_pipe;
uint n;
usbd_devinfo(dev, 0, devinfo, sizeof(devinfo));
USB_ATTACH_SETUP;
printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfo);
err = usbd_set_config_no(dev, CONFIG_NO, 1);
if (err) {
printf("%s: setting config no failed\n",
USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
err = usbd_device2interface_handle(dev, IFACE_IDX, &iface);
if (err) {
printf("%s: getting interface handle failed\n",
USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
/* Will be used as a bulk pipe. */
err = usbd_open_pipe(iface, INTR_IN_EP, 0, &intr_in_pipe);
if (err) {
printf("%s: open bulk in failed\n", USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
err = usbd_open_pipe(iface, BULK_OUT_EP, 0, &bulk_out_pipe);
if (err) {
printf("%s: open bulk in failed\n", USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
printf("%s: downloading firmware\n", USBDEVNAME(sc->sc_dev));
snprintf(name, sizeof name, "%s/%s", ubtbcmfw_fwpath, MINI_DRIVER);
err = ubtbcmfw_load_file(dev, bulk_out_pipe, name);
if (err) {
printf("%s: loading mini-driver failed\n",
USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
usbd_delay_ms(dev, 1);
err = ubtbcmfw_write(dev, bulk_out_pipe, "#", 1);
if (err) {
printf("%s: write # failed\n", USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
buf[0] = 0;
n = 10;
err = ubtbcmfw_read(dev, intr_in_pipe, buf, &n);
if (err) {
printf("%s: read # failed\n", USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
if (buf[0] != '#') {
printf("%s: memory select failed\n", USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
snprintf(name, sizeof name, "%s/%s", ubtbcmfw_fwpath, FIRMWARE);
err = ubtbcmfw_load_file(dev, bulk_out_pipe, name);
if (err) {
printf("%s: loading firmware failed\n",
USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
n = 10;
err = ubtbcmfw_read(dev, intr_in_pipe, buf, &n);
if (err) {
printf("%s: read . failed\n", USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
if (buf[0] != '.') {
printf("%s: firmware load failed\n", USBDEVNAME(sc->sc_dev));
USB_ATTACH_ERROR_RETURN;
}
usbd_close_pipe(intr_in_pipe);
usbd_close_pipe(bulk_out_pipe);
printf("%s: firmware download complete\n",
USBDEVNAME(sc->sc_dev));
usbd_delay_ms(dev, 500);
USB_ATTACH_SUCCESS_RETURN;
}
USB_DETACH(ubtbcmfw)
{
/*USB_DETACH_START(ubtbcmfw, sc);*/
return (0);
}
int
ubtbcmfw_activate(device_ptr_t self, enum devact act)
{
return 0;
}
Static int
ubtbcmfw_load_file(usbd_device_handle dev, usbd_pipe_handle out,
const char *filename)
{
struct proc *p = curproc;
struct nameidata nd;
struct vnode *vp;
size_t resid, offs, size;
int error;
char buf[1024];
struct timeval delta;
NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, filename, p);
/* Loop until we are well passed boot */
for (;;) {
error = vn_open(&nd, FREAD, 0);
if (!error)
break;
timersub(&boottime, &time, &delta);
if (delta.tv_sec > 60)
break;
printf("ubtbcmfw_load_file: waiting for firmware file\n");
if (tsleep(buf, PZERO, "ubtbcmfw", hz * 5) != EWOULDBLOCK)
break;
}
if (error)
return (error);
vp = nd.ni_vp;
VOP_UNLOCK(vp, 0);
if (nd.ni_vp->v_type != VREG) {
error = EACCES;
goto out;
}
for (offs = 0; ; offs += size) {
size = sizeof buf;
error = vn_rdwr(UIO_READ, vp, buf, size, offs, UIO_SYSSPACE,
IO_NODELOCKED | IO_SYNC, p->p_ucred, &resid, NULL);
size -= resid;
if (error || size == 0)
break;
if (ubtbcmfw_write(dev, out, buf, size)) {
error = EIO;
break;
}
}
out:
vn_close(vp, FREAD, p->p_ucred, p);
return error;
}
Static usbd_status
ubtbcmfw_write(usbd_device_handle dev, usbd_pipe_handle out,
char *buf, uint count)
{
usbd_xfer_handle xfer;
usbd_status err;
uint n;
xfer = usbd_alloc_xfer(dev);
if (xfer == NULL)
return (USBD_NOMEM);
n = count;
err = usbd_bulk_transfer(xfer, out, 0, USBD_DEFAULT_TIMEOUT,
buf, &n, "ubtfwr");
usbd_free_xfer(xfer);
return (err);
}
Static usbd_status
ubtbcmfw_read(usbd_device_handle dev, usbd_pipe_handle in,
char *buf, uint *count)
{
usbd_xfer_handle xfer;
usbd_status err;
xfer = usbd_alloc_xfer(dev);
if (xfer == NULL)
return (USBD_NOMEM);
err = usbd_bulk_transfer(xfer, in, USBD_SHORT_XFER_OK,
USBD_DEFAULT_TIMEOUT, buf, count, "ubtfrd");
usbd_free_xfer(xfer);
return (err);
}