xref: /src/sys/dev/usb/aubtfwl.c

/* $NetBSD: aubtfwl.c,v 1.10 2020/05/30 17:19:45 jakllsch Exp $ */

/*
 * Copyright (c) 2011 Jonathan A. Kollasch
 * All rights reserved.
 *
 * 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT HOLDER 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: aubtfwl.c,v 1.10 2020/05/30 17:19:45 jakllsch Exp $");

#include <sys/param.h>
#include <sys/kmem.h>
#include <dev/usb/usb.h>
#include <dev/usb/usbdevs.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdivar.h>
#include <dev/usb/usbdi_util.h>
#include <dev/firmload.h>

#include <dev/usb/aubtfwlreg.h>

#define AR3K_FIRMWARE_CHUNK_SIZE 4096

static int aubtfwl_match(device_t, cfdata_t, void *);
static void aubtfwl_attach(device_t, device_t, void *);
static int aubtfwl_detach(device_t, int);
static void aubtfwl_attach_hook(device_t);

struct aubtfwl_softc {
	struct usbd_device *sc_udev;
	int sc_flags;
#define AUBT_IS_AR3012		1
};

CFATTACH_DECL_NEW(aubtfwl, sizeof(struct aubtfwl_softc), aubtfwl_match, aubtfwl_attach, aubtfwl_detach, NULL);

static const struct usb_devno ar3k_devs[] = {
	{ USB_VENDOR_ATHEROS2, USB_PRODUCT_ATHEROS2_AR3011 },
};

static const struct usb_devno ar3k12_devs[] = {
	{ USB_VENDOR_FOXCONN, USB_PRODUCT_FOXCONN_AR3012 },
};

static int
aubtfwl_match(device_t parent, cfdata_t match, void *aux)
{
	const struct usb_attach_arg * const uaa = aux;

	if (usb_lookup(ar3k_devs, uaa->uaa_vendor, uaa->uaa_product))
		return UMATCH_VENDOR_PRODUCT;

	if (usb_lookup(ar3k12_devs, uaa->uaa_vendor, uaa->uaa_product)) {
		return (UGETW(uaa->uaa_device->ud_ddesc.bcdDevice) > 1)?
			UMATCH_NONE : UMATCH_VENDOR_PRODUCT;
	}

	return UMATCH_NONE;
}

static void
aubtfwl_attach(device_t parent, device_t self, void *aux)
{
	const struct usb_attach_arg * const uaa = aux;
	struct aubtfwl_softc * const sc = device_private(self);
	aprint_naive("\n");
	aprint_normal("\n");
	sc->sc_udev = uaa->uaa_device;
	sc->sc_flags = 0;

	if (usb_lookup(ar3k12_devs, uaa->uaa_vendor, uaa->uaa_product))
		sc->sc_flags |= AUBT_IS_AR3012;

	config_mountroot(self, aubtfwl_attach_hook);
}

static int
aubtfwl_detach(device_t self, int flags)
{
	struct aubtfwl_softc * const sc = device_private(self);

	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, self);

	return 0;
}

/* Returns 0 if firmware was correctly loaded */
static int
aubtfwl_firmware_load(device_t self, const char *name) {
	struct aubtfwl_softc * const sc = device_private(self);
	struct usbd_interface *iface;
	struct usbd_pipe *pipe;
	struct usbd_xfer *xfer;
	void *buf;
	usb_device_request_t req;
	int error = 0;
	firmware_handle_t fwh;
	size_t fws;
	size_t fwo = 0;
	uint32_t n;

	memset(&req, 0, sizeof(req));

	error = firmware_open("ubt", name, &fwh);
	if (error != 0) {
		aprint_error_dev(self, "'%s' open fail %d\n", name, error);
		return error;
	}
	fws = firmware_get_size(fwh);

	error = usbd_set_config_no(sc->sc_udev, 1, 0);
	if (error != 0) {
		aprint_error_dev(self, "failed to set configuration"
		    ", err=%s\n", usbd_errstr(error));
		goto out_firmware;
	}

	error = usbd_device2interface_handle(sc->sc_udev, 0, &iface);
	if (error) {
		aprint_error_dev(self, "failed to get interface, %s\n",
		   usbd_errstr(error));
		goto out_firmware;
	}

	error = usbd_open_pipe(iface, UE_DIR_OUT|2, USBD_EXCLUSIVE_USE, &pipe);
	if (error) {
		aprint_error_dev(self, "failed to open pipe, %s\n",
		   usbd_errstr(error));
		goto out_firmware;
	}

	error = usbd_create_xfer(pipe, AR3K_FIRMWARE_CHUNK_SIZE, 0, 0, &xfer);
	if (error) {
		aprint_verbose_dev(self, "cannot create xfer(%d)\n",
		    error);
		goto out_pipe;
	}
	buf = usbd_get_buffer(xfer);

	error = firmware_read(fwh, fwo, buf, AR3K_FIRMWARE_HEADER_SIZE);
	if (error != 0) {
		aprint_error_dev(self, "firmware_read failed %d\n", error);
		goto out_xfer;
	}

	req.bRequest = AR3K_SEND_FIRMWARE;
	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
	USETW(req.wValue, 0);
	USETW(req.wIndex, 0);
	USETW(req.wLength, AR3K_FIRMWARE_HEADER_SIZE);

	aprint_verbose_dev(self, "beginning firmware load\n");

	error = usbd_do_request(sc->sc_udev, &req, buf);
	if (error != 0) {
		aprint_error_dev(self, "%s\n", usbd_errstr(error));
		return error;
	}
	fwo = AR3K_FIRMWARE_HEADER_SIZE;

	while (fwo < fws) {
		n = uimin(AR3K_FIRMWARE_CHUNK_SIZE, fws - fwo);
		error = firmware_read(fwh, fwo, buf, n);
		if (error != 0) {
			break;
		}
		error = usbd_bulk_transfer(xfer, pipe, 0, USBD_DEFAULT_TIMEOUT,
		    buf, &n);
		if (error != USBD_NORMAL_COMPLETION) {
			aprint_error_dev(self, "xfer failed, %s\n",
			   usbd_errstr(error));
			break;
		}
		fwo += n;
	}

	if (error == 0)
		aprint_verbose_dev(self, "firmware load complete\n");

out_xfer:
	usbd_destroy_xfer(xfer);
out_pipe:
	usbd_close_pipe(pipe);
out_firmware:
	firmware_close(fwh);

	return !!error;
}

static int
aubtfwl_get_state(struct aubtfwl_softc *sc, uint8_t *state) {
	usb_device_request_t req;
	int error = 0;

	memset(&req, 0, sizeof(req));

	req.bRequest = AR3K_GET_STATE;
	req.bmRequestType = UT_READ_VENDOR_DEVICE;
	USETW(req.wValue, 0);
	USETW(req.wIndex, 0);
	USETW(req.wLength, sizeof(*state));

	error = usbd_do_request(sc->sc_udev, &req, state);

	return error;
}

static int
aubtfwl_get_version(struct aubtfwl_softc *sc, struct ar3k_version *ver) {
	usb_device_request_t req;
	int error = 0;

	memset(&req, 0, sizeof(req));

	req.bRequest = AR3K_GET_VERSION;
	req.bmRequestType = UT_READ_VENDOR_DEVICE;
	USETW(req.wValue, 0);
	USETW(req.wIndex, 0);
	USETW(req.wLength, sizeof(*ver));

	error = usbd_do_request(sc->sc_udev, &req, ver);

#if BYTE_ORDER == BIG_ENDIAN
	if (error == USBD_NORMAL_COMPLETION) {
		ver->rom = bswap32(ver->rom);
		ver->build = bswap32(ver->build);
		ver->ram = bswap32(ver->ram);
	}
#endif
	return error;
}

static int
aubtfwl_send_command(struct aubtfwl_softc *sc, uByte cmd) {
	usb_device_request_t req;
	int error = 0;

	memset(&req, 0, sizeof(req));

	req.bRequest = cmd;
	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
	USETW(req.wValue, 0);
	USETW(req.wIndex, 0);
	USETW(req.wLength, 0);

	error = usbd_do_request(sc->sc_udev, &req, NULL);

	return error;
}

static void
aubtfwl_attach_hook(device_t self)
{
	struct aubtfwl_softc * const sc = device_private(self);
	char *fw_name;
	struct ar3k_version ver;
	uint8_t state;
	int clock = 0;
	int error = 0;

	if (sc->sc_flags & AUBT_IS_AR3012) {
		error = aubtfwl_get_version(sc, &ver);
		if (!error)
			error = aubtfwl_get_state(sc, &state);

		if (error) {
			aprint_error_dev(self,
				"couldn't get version or state\n");
			return;
		}

		aprint_verbose_dev(self, "state is 0x%02x\n", state);

		if (!(state & AR3K_STATE_IS_PATCHED)) {
			fw_name = kmem_asprintf("ar3k/AthrBT_0x%08x.dfu",
			    ver.rom);
			error = aubtfwl_firmware_load(self, fw_name);
			kmem_strfree(fw_name);

			if (error)
				return;
		}

		switch (ver.clock) {
		case AR3K_CLOCK_19M:
			clock = 19;
			break;
		case AR3K_CLOCK_26M:
			clock = 26;
			break;
		case AR3K_CLOCK_40M:
			clock = 40;
			break;
		}

		fw_name = kmem_asprintf("ar3k/ramps_0x%08x_%d.dfu",
		    ver.rom, clock);
		aubtfwl_firmware_load(self, fw_name);
		kmem_strfree(fw_name);

		if ((state & AR3K_STATE_MODE_MASK) != AR3K_STATE_MODE_NORMAL) {
			error = aubtfwl_send_command(sc, AR3K_SET_NORMAL_MODE);
			if (error) {
				aprint_error_dev(self,
					"couldn't set normal mode: %s",
					usbd_errstr(error));
				return;
			}
		}

		/* Apparently some devices will fail this, so ignore result */
		(void) aubtfwl_send_command(sc, AR3K_SWITCH_VID_PID);
	} else {
		aubtfwl_firmware_load(self, "ath3k-1.fw");
	}

	return;
}