/* $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 __KERNEL_RCSID(0, "$NetBSD: aubtfwl.c,v 1.10 2020/05/30 17:19:45 jakllsch Exp $"); #include #include #include #include #include #include #include #include #include #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; }