 @@ -1,1866 +1,1870 @@
-/*	$NetBSD: if_urtwn.c,v 1.34.4.15 2016/12/05 10:55:18 skrll Exp $	*/
+/*	$NetBSD: if_urtwn.c,v 1.34.4.16 2017/01/28 12:04:17 skrll Exp $	*/
 /*	$OpenBSD: if_urtwn.c,v 1.42 2015/02/10 23:25:46 mpi Exp $	*/
 /*-
  * Copyright (c) 2010 Damien Bergamini <damien.bergamini@free.fr>
  * Copyright (c) 2014 Kevin Lo <kevlo@FreeBSD.org>
  * Copyright (c) 2016 Nathanial Sloss <nathanialsloss@yahoo.com.au>
+ *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 /*-
  * Driver for Realtek RTL8188CE-VAU/RTL8188CUS/RTL8188EU/RTL8188RU/RTL8192CU
  * RTL8192EU.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_urtwn.c,v 1.34.4.15 2016/12/05 10:55:18 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_urtwn.c,v 1.34.4.16 2017/01/28 12:04:17 skrll Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_inet.h"
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/sockio.h>
 #include <sys/sysctl.h>
 #include <sys/mbuf.h>
 #include <sys/kernel.h>
 #include <sys/socket.h>
 #include <sys/systm.h>
 #include <sys/module.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/bus.h>
 #include <machine/endian.h>
 #include <sys/intr.h>
 #include <net/bpf.h>
 #include <net/if.h>
 #include <net/if_arp.h>
 #include <net/if_dl.h>
 #include <net/if_ether.h>
 #include <net/if_media.h>
 #include <net/if_types.h>
 #include <netinet/in.h>
 #include <netinet/in_systm.h>
 #include <netinet/in_var.h>
 #include <netinet/ip.h>
 #include <netinet/if_inarp.h>
 #include <net80211/ieee80211_netbsd.h>
 #include <net80211/ieee80211_var.h>
 #include <net80211/ieee80211_radiotap.h>
 #include <dev/firmload.h>
 #include <dev/usb/usb.h>
 #include <dev/usb/usbdi.h>
 #include <dev/usb/usbdivar.h>
 #include <dev/usb/usbdi_util.h>
 #include <dev/usb/usbdevs.h>
 #include <dev/usb/if_urtwnreg.h>
 #include <dev/usb/if_urtwnvar.h>
 #include <dev/usb/if_urtwn_data.h>
 /*
  * The sc_write_mtx locking is to prevent sequences of writes from
  * being intermingled with each other.  I don't know if this is really
  * needed.  I have added it just to be on the safe side.
  */
 #ifdef URTWN_DEBUG
 #define	DBG_INIT	__BIT(0)
 #define	DBG_FN		__BIT(1)
 #define	DBG_TX		__BIT(2)
 #define	DBG_RX		__BIT(3)
 #define	DBG_STM		__BIT(4)
 #define	DBG_RF		__BIT(5)
 #define	DBG_REG		__BIT(6)
 #define	DBG_ALL		0xffffffffU
 u_int urtwn_debug = 0;
 #define DPRINTFN(n, s)	\
 	do { if (urtwn_debug & (n)) printf s; } while (/*CONSTCOND*/0)
 #else
 #define DPRINTFN(n, s)
 #endif
 #define URTWN_DEV(v,p)	{ { USB_VENDOR_##v, USB_PRODUCT_##v##_##p }, 0 }
 #define URTWN_RTL8188E_DEV(v,p) \
 	{ { USB_VENDOR_##v, USB_PRODUCT_##v##_##p }, FLAG_RTL8188E }
 #define URTWN_RTL8192EU_DEV(v,p) \
 	{ { USB_VENDOR_##v, USB_PRODUCT_##v##_##p }, FLAG_RTL8192E }
 static const struct urtwn_dev {
 	struct usb_devno	dev;
 	uint32_t		flags;
 #define	FLAG_RTL8188E	__BIT(0)
 #define	FLAG_RTL8192E	__BIT(1)
 } urtwn_devs[] = {
 	URTWN_DEV(ABOCOM,	RTL8188CU_1),
 	URTWN_DEV(ABOCOM,	RTL8188CU_2),
 	URTWN_DEV(ABOCOM,	RTL8192CU),
 	URTWN_DEV(ASUSTEK,	RTL8192CU),
 	URTWN_DEV(ASUSTEK,	RTL8192CU_3),
 	URTWN_DEV(ASUSTEK,	USBN10NANO),
 	URTWN_DEV(ASUSTEK,	RTL8192CU_3),
 	URTWN_DEV(AZUREWAVE,	RTL8188CE_1),
 	URTWN_DEV(AZUREWAVE,	RTL8188CE_2),
 	URTWN_DEV(AZUREWAVE,	RTL8188CU),
 	URTWN_DEV(BELKIN,	F7D2102),
 	URTWN_DEV(BELKIN,	RTL8188CU),
 	URTWN_DEV(BELKIN,	RTL8188CUS),
 	URTWN_DEV(BELKIN,	RTL8192CU),
 	URTWN_DEV(BELKIN,	RTL8192CU_1),
 	URTWN_DEV(BELKIN,	RTL8192CU_2),
 	URTWN_DEV(CHICONY,	RTL8188CUS_1),
 	URTWN_DEV(CHICONY,	RTL8188CUS_2),
 	URTWN_DEV(CHICONY,	RTL8188CUS_3),
 	URTWN_DEV(CHICONY,	RTL8188CUS_4),
 	URTWN_DEV(CHICONY,	RTL8188CUS_5),
 	URTWN_DEV(CHICONY,	RTL8188CUS_6),
 	URTWN_DEV(COMPARE,	RTL8192CU),
 	URTWN_DEV(COREGA,	RTL8192CU),
 	URTWN_DEV(DLINK,	DWA131B),
 	URTWN_DEV(DLINK,	RTL8188CU),
 	URTWN_DEV(DLINK,	RTL8192CU_1),
 	URTWN_DEV(DLINK,	RTL8192CU_2),
 	URTWN_DEV(DLINK,	RTL8192CU_3),
 	URTWN_DEV(DLINK,	RTL8192CU_4),
 	URTWN_DEV(EDIMAX,	RTL8188CU),
 	URTWN_DEV(EDIMAX,	RTL8192CU),
 	URTWN_DEV(FEIXUN,	RTL8188CU),
 	URTWN_DEV(FEIXUN,	RTL8192CU),
 	URTWN_DEV(GUILLEMOT,	HWNUP150),
 	URTWN_DEV(GUILLEMOT,	RTL8192CU),
 	URTWN_DEV(HAWKING,	RTL8192CU),
 	URTWN_DEV(HAWKING,	RTL8192CU_2),
 	URTWN_DEV(HP3,		RTL8188CU),
 	URTWN_DEV(IODATA,	WNG150UM),
 	URTWN_DEV(IODATA,	RTL8192CU),
 	URTWN_DEV(NETGEAR,	WNA1000M),
 	URTWN_DEV(NETGEAR,	RTL8192CU),
 	URTWN_DEV(NETGEAR4,	RTL8188CU),
 	URTWN_DEV(NOVATECH,	RTL8188CU),
 	URTWN_DEV(PLANEX2,	RTL8188CU_1),
 	URTWN_DEV(PLANEX2,	RTL8188CU_2),
 	URTWN_DEV(PLANEX2,	RTL8192CU),
 	URTWN_DEV(PLANEX2,	RTL8188CU_3),
 	URTWN_DEV(PLANEX2,	RTL8188CU_4),
 	URTWN_DEV(PLANEX2,	RTL8188CUS),
 	URTWN_DEV(REALTEK,	RTL8188CE_0),
 	URTWN_DEV(REALTEK,	RTL8188CE_1),
 	URTWN_DEV(REALTEK,	RTL8188CTV),
 	URTWN_DEV(REALTEK,	RTL8188CU_0),
 	URTWN_DEV(REALTEK,	RTL8188CU_1),
 	URTWN_DEV(REALTEK,	RTL8188CU_2),
 	URTWN_DEV(REALTEK,	RTL8188CU_3),
 	URTWN_DEV(REALTEK,	RTL8188CU_COMBO),
 	URTWN_DEV(REALTEK,	RTL8188CUS),
 	URTWN_DEV(REALTEK,	RTL8188RU),
 	URTWN_DEV(REALTEK,	RTL8188RU_2),
 	URTWN_DEV(REALTEK,	RTL8188RU_3),
 	URTWN_DEV(REALTEK,	RTL8191CU),
 	URTWN_DEV(REALTEK,	RTL8192CE),
 	URTWN_DEV(REALTEK,	RTL8192CU),
 	URTWN_DEV(SITECOMEU,	RTL8188CU),
 	URTWN_DEV(SITECOMEU,	RTL8188CU_2),
 	URTWN_DEV(SITECOMEU,	RTL8192CU),
 	URTWN_DEV(SITECOMEU,	RTL8192CUR2),
 	URTWN_DEV(TPLINK,	RTL8192CU),
 	URTWN_DEV(TRENDNET,	RTL8188CU),
 	URTWN_DEV(TRENDNET,	RTL8192CU),
 	URTWN_DEV(ZYXEL,	RTL8192CU),
 	/* URTWN_RTL8188E */
 	URTWN_RTL8188E_DEV(DLINK, DWA125D1),
 	URTWN_RTL8188E_DEV(ELECOM, WDC150SU2M),
 	URTWN_RTL8188E_DEV(REALTEK, RTL8188ETV),
 	URTWN_RTL8188E_DEV(REALTEK, RTL8188EU),
 	URTWN_RTL8188E_DEV(ABOCOM, RTL8188EU),
 	/* URTWN_RTL8192EU */
 	URTWN_RTL8192EU_DEV(REALTEK,	RTL8192EU),
 };
 #undef URTWN_DEV
 #undef URTWN_RTL8188E_DEV
 #undef URTWN_RTL8192EU_DEV
 static int	urtwn_match(device_t, cfdata_t, void *);
 static void	urtwn_attach(device_t, device_t, void *);
 static int	urtwn_detach(device_t, int);
 static int	urtwn_activate(device_t, enum devact);
 CFATTACH_DECL_NEW(urtwn, sizeof(struct urtwn_softc), urtwn_match,
     urtwn_attach, urtwn_detach, urtwn_activate);
 static int	urtwn_open_pipes(struct urtwn_softc *);
 static void	urtwn_close_pipes(struct urtwn_softc *);
 static int	urtwn_alloc_rx_list(struct urtwn_softc *);
 static void	urtwn_free_rx_list(struct urtwn_softc *);
 static int	urtwn_alloc_tx_list(struct urtwn_softc *);
 static void	urtwn_free_tx_list(struct urtwn_softc *);
 static void	urtwn_task(void *);
 static void	urtwn_do_async(struct urtwn_softc *,
 		    void (*)(struct urtwn_softc *, void *), void *, int);
 static void	urtwn_wait_async(struct urtwn_softc *);
 static int	urtwn_write_region_1(struct urtwn_softc *, uint16_t, uint8_t *,
 		    int);
 static void	urtwn_write_1(struct urtwn_softc *, uint16_t, uint8_t);
 static void	urtwn_write_2(struct urtwn_softc *, uint16_t, uint16_t);
 static void	urtwn_write_4(struct urtwn_softc *, uint16_t, uint32_t);
 static int	urtwn_write_region(struct urtwn_softc *, uint16_t, uint8_t *,
 		    int);
 static int	urtwn_read_region_1(struct urtwn_softc *, uint16_t, uint8_t *,
 		    int);
 static uint8_t	urtwn_read_1(struct urtwn_softc *, uint16_t);
 static uint16_t	urtwn_read_2(struct urtwn_softc *, uint16_t);
 static uint32_t	urtwn_read_4(struct urtwn_softc *, uint16_t);
 static int	urtwn_fw_cmd(struct urtwn_softc *, uint8_t, const void *, int);
 static void	urtwn_r92c_rf_write(struct urtwn_softc *, int, uint8_t,
 		    uint32_t);
 static void	urtwn_r88e_rf_write(struct urtwn_softc *, int, uint8_t,
 		    uint32_t);
 static void	urtwn_r92e_rf_write(struct urtwn_softc *, int, uint8_t,
 		    uint32_t);
 static uint32_t	urtwn_rf_read(struct urtwn_softc *, int, uint8_t);
 static int	urtwn_llt_write(struct urtwn_softc *, uint32_t, uint32_t);
 static uint8_t	urtwn_efuse_read_1(struct urtwn_softc *, uint16_t);
 static void	urtwn_efuse_read(struct urtwn_softc *);
 static void	urtwn_efuse_switch_power(struct urtwn_softc *);
 static int	urtwn_read_chipid(struct urtwn_softc *);
 #ifdef URTWN_DEBUG
 static void	urtwn_dump_rom(struct urtwn_softc *, struct r92c_rom *);
 #endif
 static void	urtwn_read_rom(struct urtwn_softc *);
 static void	urtwn_r88e_read_rom(struct urtwn_softc *);
 static int	urtwn_media_change(struct ifnet *);
 static int	urtwn_ra_init(struct urtwn_softc *);
 static int	urtwn_get_nettype(struct urtwn_softc *);
 static void	urtwn_set_nettype0_msr(struct urtwn_softc *, uint8_t);
 static void	urtwn_tsf_sync_enable(struct urtwn_softc *);
 static void	urtwn_set_led(struct urtwn_softc *, int, int);
 static void	urtwn_calib_to(void *);
 static void	urtwn_calib_to_cb(struct urtwn_softc *, void *);
 static void	urtwn_next_scan(void *);
 static int	urtwn_newstate(struct ieee80211com *, enum ieee80211_state,
 		    int);
 static void	urtwn_newstate_cb(struct urtwn_softc *, void *);
 static int	urtwn_wme_update(struct ieee80211com *);
 static void	urtwn_wme_update_cb(struct urtwn_softc *, void *);
 static void	urtwn_update_avgrssi(struct urtwn_softc *, int, int8_t);
 static int8_t	urtwn_get_rssi(struct urtwn_softc *, int, void *);
 static int8_t	urtwn_r88e_get_rssi(struct urtwn_softc *, int, void *);
 static void	urtwn_rx_frame(struct urtwn_softc *, uint8_t *, int);
 static void	urtwn_rxeof(struct usbd_xfer *, void *, usbd_status);
 static void	urtwn_txeof(struct usbd_xfer *, void *, usbd_status);
 static int	urtwn_tx(struct urtwn_softc *, struct mbuf *,
 		    struct ieee80211_node *, struct urtwn_tx_data *);
 static struct urtwn_tx_data *
 		urtwn_get_tx_data(struct urtwn_softc *, size_t);
 static void	urtwn_start(struct ifnet *);
 static void	urtwn_watchdog(struct ifnet *);
 static int	urtwn_ioctl(struct ifnet *, u_long, void *);
 static int	urtwn_r92c_power_on(struct urtwn_softc *);
 static int	urtwn_r92e_power_on(struct urtwn_softc *);
 static int	urtwn_r88e_power_on(struct urtwn_softc *);
 static int	urtwn_llt_init(struct urtwn_softc *);
 static void	urtwn_fw_reset(struct urtwn_softc *);
 static void	urtwn_r88e_fw_reset(struct urtwn_softc *);
 static int	urtwn_fw_loadpage(struct urtwn_softc *, int, uint8_t *, int);
 static int	urtwn_load_firmware(struct urtwn_softc *);
 static int	urtwn_r92c_dma_init(struct urtwn_softc *);
 static int	urtwn_r88e_dma_init(struct urtwn_softc *);
 static void	urtwn_mac_init(struct urtwn_softc *);
 static void	urtwn_bb_init(struct urtwn_softc *);
 static void	urtwn_rf_init(struct urtwn_softc *);
 static void	urtwn_cam_init(struct urtwn_softc *);
 static void	urtwn_pa_bias_init(struct urtwn_softc *);
 static void	urtwn_rxfilter_init(struct urtwn_softc *);
 static void	urtwn_edca_init(struct urtwn_softc *);
 static void	urtwn_write_txpower(struct urtwn_softc *, int, uint16_t[]);
 static void	urtwn_get_txpower(struct urtwn_softc *, size_t, u_int, u_int,
 		    uint16_t[]);
 static void	urtwn_r88e_get_txpower(struct urtwn_softc *, size_t, u_int,
 		    u_int, uint16_t[]);
 static void	urtwn_set_txpower(struct urtwn_softc *, u_int, u_int);
 static void	urtwn_set_chan(struct urtwn_softc *, struct ieee80211_channel *,
 		    u_int);
 static void	urtwn_iq_calib(struct urtwn_softc *, bool);
 static void	urtwn_lc_calib(struct urtwn_softc *);
 static void	urtwn_temp_calib(struct urtwn_softc *);
 static int	urtwn_init(struct ifnet *);
 static void	urtwn_stop(struct ifnet *, int);
 static int	urtwn_reset(struct ifnet *);
 static void	urtwn_chip_stop(struct urtwn_softc *);
 static void	urtwn_newassoc(struct ieee80211_node *, int);
 static void	urtwn_delay_ms(struct urtwn_softc *, int ms);
 /* Aliases. */
 #define	urtwn_bb_write	urtwn_write_4
 #define	urtwn_bb_read	urtwn_read_4
 #define	urtwn_lookup(d,v,p)	((const struct urtwn_dev *)usb_lookup(d,v,p))
 static const uint16_t addaReg[] = {
 	R92C_FPGA0_XCD_SWITCHCTL, R92C_BLUETOOTH, R92C_RX_WAIT_CCA,
 	R92C_TX_CCK_RFON, R92C_TX_CCK_BBON, R92C_TX_OFDM_RFON,
 	R92C_TX_OFDM_BBON, R92C_TX_TO_RX, R92C_TX_TO_TX, R92C_RX_CCK,
 	R92C_RX_OFDM, R92C_RX_WAIT_RIFS, R92C_RX_TO_RX,
 	R92C_STANDBY, R92C_SLEEP, R92C_PMPD_ANAEN
 };
 static int
 urtwn_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usb_attach_arg *uaa = aux;
 	return urtwn_lookup(urtwn_devs, uaa->uaa_vendor, uaa->uaa_product) !=
 	    NULL ?  UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
+}
 static void
 urtwn_attach(device_t parent, device_t self, void *aux)
+{
 	struct urtwn_softc *sc = device_private(self);
 	struct ieee80211com *ic = &sc->sc_ic;
 	struct ifnet *ifp = &sc->sc_if;
 	struct usb_attach_arg *uaa = aux;
 	char *devinfop;
 	const struct urtwn_dev *dev;
 	usb_device_request_t req;
 	size_t i;
 	int error;
 	sc->sc_dev = self;
 	sc->sc_udev = uaa->uaa_device;
 	sc->chip = 0;
 	dev = urtwn_lookup(urtwn_devs, uaa->uaa_vendor, uaa->uaa_product);
 	if (dev != NULL && ISSET(dev->flags, FLAG_RTL8188E))
 		SET(sc->chip, URTWN_CHIP_88E);
 	if (dev != NULL && ISSET(dev->flags, FLAG_RTL8192E))
 		SET(sc->chip, URTWN_CHIP_92EU);
 	aprint_naive("\n");
 	aprint_normal("\n");
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	devinfop = usbd_devinfo_alloc(sc->sc_udev, 0);
 	aprint_normal_dev(self, "%s\n", devinfop);
 	usbd_devinfo_free(devinfop);
 	req.bmRequestType = UT_WRITE_DEVICE;
 	req.bRequest = UR_SET_FEATURE;
 	USETW(req.wValue, UF_DEVICE_REMOTE_WAKEUP);
 	USETW(req.wIndex, UHF_PORT_SUSPEND);
 	USETW(req.wLength, 0);
 	(void) usbd_do_request(sc->sc_udev, &req, 0);
 	cv_init(&sc->sc_task_cv, "urtwntsk");
 	mutex_init(&sc->sc_task_mtx, MUTEX_DEFAULT, IPL_NET);
 	mutex_init(&sc->sc_tx_mtx, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&sc->sc_rx_mtx, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&sc->sc_fwcmd_mtx, MUTEX_DEFAULT, IPL_NONE);
 	mutex_init(&sc->sc_write_mtx, MUTEX_DEFAULT, IPL_NONE);
 	usb_init_task(&sc->sc_task, urtwn_task, sc, 0);
 	callout_init(&sc->sc_scan_to, 0);
 	callout_setfunc(&sc->sc_scan_to, urtwn_next_scan, sc);
 	callout_init(&sc->sc_calib_to, 0);
 	callout_setfunc(&sc->sc_calib_to, urtwn_calib_to, sc);
 	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 fail;
+	}
 	/* Get the first interface handle. */
 	error = usbd_device2interface_handle(sc->sc_udev, 0, &sc->sc_iface);
 	if (error != 0) {
 		aprint_error_dev(self, "could not get interface handle\n");
 		goto fail;
+	}
 	error = urtwn_read_chipid(sc);
 	if (error != 0) {
 		aprint_error_dev(self, "unsupported test chip\n");
 		goto fail;
+	}
 	/* Determine number of Tx/Rx chains. */
 	if (sc->chip & URTWN_CHIP_92C) {
 		sc->ntxchains = (sc->chip & URTWN_CHIP_92C_1T2R) ? 1 : 2;
 		sc->nrxchains = 2;
 	} else if (sc->chip & URTWN_CHIP_92EU) {
 		sc->ntxchains = 2;
 		sc->nrxchains = 2;
 	} else {
 		sc->ntxchains = 1;
 		sc->nrxchains = 1;
+	}
 	if (ISSET(sc->chip, URTWN_CHIP_88E) ||
 	    ISSET(sc->chip, URTWN_CHIP_92EU))
 		urtwn_r88e_read_rom(sc);
 	else
 		urtwn_read_rom(sc);
 	aprint_normal_dev(self, "MAC/BB RTL%s, RF 6052 %zdT%zdR, address %s\n",
 	    (sc->chip & URTWN_CHIP_92EU) ? "8192EU" :
 	    (sc->chip & URTWN_CHIP_92C) ? "8192CU" :
 	    (sc->chip & URTWN_CHIP_88E) ? "8188EU" :
 	    (sc->board_type == R92C_BOARD_TYPE_HIGHPA) ? "8188RU" :
 	    (sc->board_type == R92C_BOARD_TYPE_MINICARD) ? "8188CE-VAU" :
 	    "8188CUS", sc->ntxchains, sc->nrxchains,
 	    ether_sprintf(ic->ic_myaddr));
 	error = urtwn_open_pipes(sc);
 	if (error != 0) {
 		aprint_error_dev(sc->sc_dev, "could not open pipes\n");
 		goto fail;
+	}
 	aprint_normal_dev(self, "%d rx pipe%s, %d tx pipe%s\n",
 	    sc->rx_npipe, sc->rx_npipe > 1 ? "s" : "",
 	    sc->tx_npipe, sc->tx_npipe > 1 ? "s" : "");
 	/*
 	 * Setup the 802.11 device.
 	 */
 	ic->ic_ifp = ifp;
 	ic->ic_phytype = IEEE80211_T_OFDM;	/* Not only, but not used. */
 	ic->ic_opmode = IEEE80211_M_STA;	/* Default to BSS mode. */
 	ic->ic_state = IEEE80211_S_INIT;
 	/* Set device capabilities. */
 	ic->ic_caps =
 	    IEEE80211_C_MONITOR |	/* Monitor mode supported. */
 	    IEEE80211_C_IBSS |		/* IBSS mode supported */
 	    IEEE80211_C_HOSTAP |	/* HostAp mode supported */
 	    IEEE80211_C_SHPREAMBLE |	/* Short preamble supported. */
 	    IEEE80211_C_SHSLOT |	/* Short slot time supported. */
 	    IEEE80211_C_WME |		/* 802.11e */
 	    IEEE80211_C_WPA;		/* 802.11i */
 	/* Set supported .11b and .11g rates. */
 	ic->ic_sup_rates[IEEE80211_MODE_11B] = ieee80211_std_rateset_11b;
 	ic->ic_sup_rates[IEEE80211_MODE_11G] = ieee80211_std_rateset_11g;
 	/* Set supported .11b and .11g channels (1 through 14). */
 	for (i = 1; i <= 14; i++) {
 		ic->ic_channels[i].ic_freq =
 		    ieee80211_ieee2mhz(i, IEEE80211_CHAN_2GHZ);
 		ic->ic_channels[i].ic_flags =
 		    IEEE80211_CHAN_CCK | IEEE80211_CHAN_OFDM |
 		    IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
+	}
 	ifp->if_softc = sc;
 	ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 	ifp->if_init = urtwn_init;
 	ifp->if_ioctl = urtwn_ioctl;
 	ifp->if_start = urtwn_start;
 	ifp->if_watchdog = urtwn_watchdog;
 	IFQ_SET_READY(&ifp->if_snd);
 	memcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
 	if_attach(ifp);
 	ieee80211_ifattach(ic);
 	/* override default methods */
 	ic->ic_newassoc = urtwn_newassoc;
 	ic->ic_reset = urtwn_reset;
 	ic->ic_wme.wme_update = urtwn_wme_update;
 	/* Override state transition machine. */
 	sc->sc_newstate = ic->ic_newstate;
 	ic->ic_newstate = urtwn_newstate;
 	ieee80211_media_init(ic, urtwn_media_change, ieee80211_media_status);
 	bpf_attach2(ifp, DLT_IEEE802_11_RADIO,
 	    sizeof(struct ieee80211_frame) + IEEE80211_RADIOTAP_HDRLEN,
 	    &sc->sc_drvbpf);
 	sc->sc_rxtap_len = sizeof(sc->sc_rxtapu);
 	sc->sc_rxtap.wr_ihdr.it_len = htole16(sc->sc_rxtap_len);
 	sc->sc_rxtap.wr_ihdr.it_present = htole32(URTWN_RX_RADIOTAP_PRESENT);
 	sc->sc_txtap_len = sizeof(sc->sc_txtapu);
 	sc->sc_txtap.wt_ihdr.it_len = htole16(sc->sc_txtap_len);
 	sc->sc_txtap.wt_ihdr.it_present = htole32(URTWN_TX_RADIOTAP_PRESENT);
 	ieee80211_announce(ic);
 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
 	if (!pmf_device_register(self, NULL, NULL))
 		aprint_error_dev(self, "couldn't establish power handler\n");
 	SET(sc->sc_flags, URTWN_FLAG_ATTACHED);
 	return;
  fail:
 	sc->sc_dying = 1;
 	aprint_error_dev(self, "attach failed\n");
+}
 static int
 urtwn_detach(device_t self, int flags)
+{
 	struct urtwn_softc *sc = device_private(self);
 	struct ifnet *ifp = &sc->sc_if;
 	int s;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	pmf_device_deregister(self);
 	s = splusb();
 	sc->sc_dying = 1;
 	callout_stop(&sc->sc_scan_to);
 	callout_stop(&sc->sc_calib_to);
 	if (ISSET(sc->sc_flags, URTWN_FLAG_ATTACHED)) {
 		usb_rem_task(sc->sc_udev, &sc->sc_task);
 		urtwn_stop(ifp, 0);
 		ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 		bpf_detach(ifp);
 		ieee80211_ifdetach(&sc->sc_ic);
 		if_detach(ifp);
 		/* Close Tx/Rx pipes.  Abort done by urtwn_stop. */
 		urtwn_close_pipes(sc);
+	}
 	splx(s);
 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
 	callout_destroy(&sc->sc_scan_to);
 	callout_destroy(&sc->sc_calib_to);
 	cv_destroy(&sc->sc_task_cv);
 	mutex_destroy(&sc->sc_write_mtx);
 	mutex_destroy(&sc->sc_fwcmd_mtx);
 	mutex_destroy(&sc->sc_tx_mtx);
 	mutex_destroy(&sc->sc_rx_mtx);
 	mutex_destroy(&sc->sc_task_mtx);
 	return 0;
+}
 static int
 urtwn_activate(device_t self, enum devact act)
+{
 	struct urtwn_softc *sc = device_private(self);
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		if_deactivate(sc->sc_ic.ic_ifp);
 		return 0;
 	default:
 		return EOPNOTSUPP;
+	}
+}
 static int
 urtwn_open_pipes(struct urtwn_softc *sc)
+{
 	/* Bulk-out endpoints addresses (from highest to lowest prio). */
 	static uint8_t epaddr[3];
 	static uint8_t rxepaddr[3];
 	usb_interface_descriptor_t *id;
 	usb_endpoint_descriptor_t *ed;
 	size_t i, ntx = 0, nrx = 0;
 	int error;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	/* Determine the number of bulk-out pipes. */
 	id = usbd_get_interface_descriptor(sc->sc_iface);
 	for (i = 0; i < id->bNumEndpoints; i++) {
 		ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
 		if (ed != NULL &&
 		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK &&
 		    UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT) {
 			epaddr[ntx] = ed->bEndpointAddress;
 			ntx++;
+		}
 		if (ed != NULL &&
 		    UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK &&
 		    UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN) {
 			rxepaddr[nrx] = ed->bEndpointAddress;
 			nrx++;
+		}
+	}
 	DPRINTFN(DBG_INIT, ("%s: %s: found %zd bulk-out pipes\n",
 	    device_xname(sc->sc_dev), __func__, ntx));
 	if (ntx == 0 || ntx > R92C_MAX_EPOUT) {
 		aprint_error_dev(sc->sc_dev,
 		    "%zd: invalid number of Tx bulk pipes\n", ntx);
 		return EIO;
+	}
 	sc->rx_npipe = nrx;
 	sc->tx_npipe = ntx;
 	/* Open bulk-in pipe at address 0x81. */
 	for (i = 0; i < nrx; i++) {
 		error = usbd_open_pipe(sc->sc_iface, rxepaddr[i],
 		    USBD_EXCLUSIVE_USE, &sc->rx_pipe[i]);
 		if (error != 0) {
 			aprint_error_dev(sc->sc_dev,
 			    "could not open Rx bulk pipe 0x%02x: %d\n",
 			    rxepaddr[i], error);
 			goto fail;
+		}
+	}
 	/* Open bulk-out pipes (up to 3). */
 	for (i = 0; i < ntx; i++) {
 		error = usbd_open_pipe(sc->sc_iface, epaddr[i],
 		    USBD_EXCLUSIVE_USE, &sc->tx_pipe[i]);
 		if (error != 0) {
 			aprint_error_dev(sc->sc_dev,
 			    "could not open Tx bulk pipe 0x%02x: %d\n",
 			    epaddr[i], error);
 			goto fail;
+		}
+	}
 	/* Map 802.11 access categories to USB pipes. */
 	sc->ac2idx[WME_AC_BK] =
 	sc->ac2idx[WME_AC_BE] = (ntx == 3) ? 2 : ((ntx == 2) ? 1 : 0);
 	sc->ac2idx[WME_AC_VI] = (ntx == 3) ? 1 : 0;
 	sc->ac2idx[WME_AC_VO] = 0;	/* Always use highest prio. */
  fail:
 	if (error != 0)
 		urtwn_close_pipes(sc);
 	return error;
+}
 static void
 urtwn_close_pipes(struct urtwn_softc *sc)
+{
 	struct usbd_pipe *pipe;
 	size_t i;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	/* Close Rx pipes. */
 	CTASSERT(sizeof(pipe) == sizeof(void *));
 	for (i = 0; i < sc->rx_npipe; i++) {
 		pipe = atomic_swap_ptr(&sc->rx_pipe[i], NULL);
 		if (pipe != NULL) {
 			usbd_close_pipe(pipe);
+		}
+	}
 	/* Close Tx pipes. */
 	for (i = 0; i < sc->tx_npipe; i++) {
 		pipe = atomic_swap_ptr(&sc->tx_pipe[i], NULL);
 		if (pipe != NULL) {
 			usbd_close_pipe(pipe);
+		}
+	}
+}
 static int
 urtwn_alloc_rx_list(struct urtwn_softc *sc)
+{
 	struct urtwn_rx_data *data;
 	size_t i;
 	int error = 0;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	for (size_t j = 0; j < sc->rx_npipe; j++) {
 		TAILQ_INIT(&sc->rx_free_list[j]);
 		for (i = 0; i < URTWN_RX_LIST_COUNT; i++) {
 			data = &sc->rx_data[j][i];
 			data->sc = sc;	/* Backpointer for callbacks. */
 			error = usbd_create_xfer(sc->rx_pipe[j], URTWN_RXBUFSZ,
 			    USBD_SHORT_XFER_OK, 0, &data->xfer);
 			if (error) {
 				aprint_error_dev(sc->sc_dev,
 				    "could not allocate xfer\n");
 				break;
+			}
 			data->buf = usbd_get_buffer(data->xfer);
 			TAILQ_INSERT_TAIL(&sc->rx_free_list[j], data, next);
+		}
+	}
 	if (error != 0)
 		urtwn_free_rx_list(sc);
 	return error;
+}
 static void
 urtwn_free_rx_list(struct urtwn_softc *sc)
+{
 	struct usbd_xfer *xfer;
 	size_t i;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	/* NB: Caller must abort pipe first. */
 	for (size_t j = 0; j < sc->rx_npipe; j++) {
 		for (i = 0; i < URTWN_RX_LIST_COUNT; i++) {
 			CTASSERT(sizeof(xfer) == sizeof(void *));
 			xfer = atomic_swap_ptr(&sc->rx_data[j][i].xfer, NULL);
 			if (xfer != NULL)
 				usbd_destroy_xfer(xfer);
+		}
+	}
+}
 static int
 urtwn_alloc_tx_list(struct urtwn_softc *sc)
+{
 	struct urtwn_tx_data *data;
 	size_t i;
 	int error = 0;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	mutex_enter(&sc->sc_tx_mtx);
 	for (size_t j = 0; j < sc->tx_npipe; j++) {
 		TAILQ_INIT(&sc->tx_free_list[j]);
 		for (i = 0; i < URTWN_TX_LIST_COUNT; i++) {
 			data = &sc->tx_data[j][i];
 			data->sc = sc;	/* Backpointer for callbacks. */
 			data->pidx = j;
 			error = usbd_create_xfer(sc->tx_pipe[j],
 			    URTWN_TXBUFSZ, USBD_FORCE_SHORT_XFER, 0,
 			    &data->xfer);
 			if (error) {
 				aprint_error_dev(sc->sc_dev,
 				    "could not allocate xfer\n");
 				goto fail;
+			}
 			data->buf = usbd_get_buffer(data->xfer);
 			/* Append this Tx buffer to our free list. */
 			TAILQ_INSERT_TAIL(&sc->tx_free_list[j], data, next);
+		}
+	}
 	mutex_exit(&sc->sc_tx_mtx);
 	return 0;
  fail:
 	urtwn_free_tx_list(sc);
 	mutex_exit(&sc->sc_tx_mtx);
 	return error;
+}
 static void
 urtwn_free_tx_list(struct urtwn_softc *sc)
+{
 	struct usbd_xfer *xfer;
 	size_t i;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	/* NB: Caller must abort pipe first. */
 	for (size_t j = 0; j < sc->tx_npipe; j++) {
 		for (i = 0; i < URTWN_TX_LIST_COUNT; i++) {
 			CTASSERT(sizeof(xfer) == sizeof(void *));
 			xfer = atomic_swap_ptr(&sc->tx_data[j][i].xfer, NULL);
 			if (xfer != NULL)
 				usbd_destroy_xfer(xfer);
+		}
+	}
+}
 static void
 urtwn_task(void *arg)
+{
 	struct urtwn_softc *sc = arg;
 	struct urtwn_host_cmd_ring *ring = &sc->cmdq;
 	struct urtwn_host_cmd *cmd;
 	int s;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	/* Process host commands. */
 	s = splusb();
 	mutex_spin_enter(&sc->sc_task_mtx);
 	while (ring->next != ring->cur) {
 		cmd = &ring->cmd[ring->next];
 		mutex_spin_exit(&sc->sc_task_mtx);
 		splx(s);
 		/* Invoke callback with kernel lock held. */
 		cmd->cb(sc, cmd->data);
 		s = splusb();
 		mutex_spin_enter(&sc->sc_task_mtx);
 		ring->queued--;
 		ring->next = (ring->next + 1) % URTWN_HOST_CMD_RING_COUNT;
+	}
 	cv_broadcast(&sc->sc_task_cv);
 	mutex_spin_exit(&sc->sc_task_mtx);
 	wakeup(&sc->cmdq);
 	splx(s);
+}
 static void
 urtwn_do_async(struct urtwn_softc *sc, void (*cb)(struct urtwn_softc *, void *),
     void *arg, int len)
+{
 	struct urtwn_host_cmd_ring *ring = &sc->cmdq;
 	struct urtwn_host_cmd *cmd;
 	int s;
 	DPRINTFN(DBG_FN, ("%s: %s: cb=%p, arg=%p, len=%d\n",
 	    device_xname(sc->sc_dev), __func__, cb, arg, len));
 	s = splusb();
 	mutex_spin_enter(&sc->sc_task_mtx);
 	cmd = &ring->cmd[ring->cur];
 	cmd->cb = cb;
 	KASSERT(len <= sizeof(cmd->data));
 	memcpy(cmd->data, arg, len);
 	ring->cur = (ring->cur + 1) % URTWN_HOST_CMD_RING_COUNT;
 	/* If there is no pending command already, schedule a task. */
 	if (!sc->sc_dying && ++ring->queued == 1) {
 		mutex_spin_exit(&sc->sc_task_mtx);
 		usb_add_task(sc->sc_udev, &sc->sc_task, USB_TASKQ_DRIVER);
 	} else
 		mutex_spin_exit(&sc->sc_task_mtx);
 	splx(s);
+}
 static void
 urtwn_wait_async(struct urtwn_softc *sc)
+{
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	/* Wait for all queued asynchronous commands to complete. */
 	mutex_spin_enter(&sc->sc_task_mtx);
 	while (sc->cmdq.queued > 0)
-		tsleep(&sc->cmdq, 0, "endtask", 0);
+		cv_wait(&sc->sc_task_cv, &sc->sc_task_mtx);
 	mutex_spin_exit(&sc->sc_task_mtx);
+}
 static int
 urtwn_write_region_1(struct urtwn_softc *sc, uint16_t addr, uint8_t *buf,
     int len)
+{
 	usb_device_request_t req;
 	usbd_status error;
 	KASSERT(mutex_owned(&sc->sc_write_mtx));
 	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
 	req.bRequest = R92C_REQ_REGS;
 	USETW(req.wValue, addr);
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, len);
 	error = usbd_do_request(sc->sc_udev, &req, buf);
 	if (error != USBD_NORMAL_COMPLETION) {
 		DPRINTFN(DBG_REG, ("%s: %s: error=%d: addr=0x%x, len=%d\n",
 		    device_xname(sc->sc_dev), __func__, error, addr, len));
+	}
 	return error;
+}
 static void
 urtwn_write_1(struct urtwn_softc *sc, uint16_t addr, uint8_t val)
+{
 	DPRINTFN(DBG_REG, ("%s: %s: addr=0x%x, val=0x%x\n",
 	    device_xname(sc->sc_dev), __func__, addr, val));
 	urtwn_write_region_1(sc, addr, &val, 1);
+}
 static void
 urtwn_write_2(struct urtwn_softc *sc, uint16_t addr, uint16_t val)
+{
 	uint8_t buf[2];
 	DPRINTFN(DBG_REG, ("%s: %s: addr=0x%x, val=0x%x\n",
 	    device_xname(sc->sc_dev), __func__, addr, val));
 	buf[0] = (uint8_t)val;
 	buf[1] = (uint8_t)(val >> 8);
 	urtwn_write_region_1(sc, addr, buf, 2);
+}
 static void
 urtwn_write_4(struct urtwn_softc *sc, uint16_t addr, uint32_t val)
+{
 	uint8_t buf[4];
 	DPRINTFN(DBG_REG, ("%s: %s: addr=0x%x, val=0x%x\n",
 	    device_xname(sc->sc_dev), __func__, addr, val));
 	buf[0] = (uint8_t)val;
 	buf[1] = (uint8_t)(val >> 8);
 	buf[2] = (uint8_t)(val >> 16);
 	buf[3] = (uint8_t)(val >> 24);
 	urtwn_write_region_1(sc, addr, buf, 4);
+}
 static int
 urtwn_write_region(struct urtwn_softc *sc, uint16_t addr, uint8_t *buf, int len)
+{
 	DPRINTFN(DBG_REG, ("%s: %s: addr=0x%x, len=0x%x\n",
 	    device_xname(sc->sc_dev), __func__, addr, len));
 	return urtwn_write_region_1(sc, addr, buf, len);
+}
 static int
 urtwn_read_region_1(struct urtwn_softc *sc, uint16_t addr, uint8_t *buf,
     int len)
+{
 	usb_device_request_t req;
 	usbd_status error;
 	req.bmRequestType = UT_READ_VENDOR_DEVICE;
 	req.bRequest = R92C_REQ_REGS;
 	USETW(req.wValue, addr);
 	USETW(req.wIndex, 0);
 	USETW(req.wLength, len);
 	error = usbd_do_request(sc->sc_udev, &req, buf);
 	if (error != USBD_NORMAL_COMPLETION) {
 		DPRINTFN(DBG_REG, ("%s: %s: error=%d: addr=0x%x, len=%d\n",
 		    device_xname(sc->sc_dev), __func__, error, addr, len));
+	}
 	return error;
+}
 static uint8_t
 urtwn_read_1(struct urtwn_softc *sc, uint16_t addr)
+{
 	uint8_t val;
 	if (urtwn_read_region_1(sc, addr, &val, 1) != USBD_NORMAL_COMPLETION)
 		return 0xff;
 	DPRINTFN(DBG_REG, ("%s: %s: addr=0x%x, val=0x%x\n",
 	    device_xname(sc->sc_dev), __func__, addr, val));
 	return val;
+}
 static uint16_t
 urtwn_read_2(struct urtwn_softc *sc, uint16_t addr)
+{
 	uint8_t buf[2];
 	uint16_t val;
 	if (urtwn_read_region_1(sc, addr, buf, 2) != USBD_NORMAL_COMPLETION)
 		return 0xffff;
 	val = LE_READ_2(&buf[0]);
 	DPRINTFN(DBG_REG, ("%s: %s: addr=0x%x, val=0x%x\n",
 	    device_xname(sc->sc_dev), __func__, addr, val));
 	return val;
+}
 static uint32_t
 urtwn_read_4(struct urtwn_softc *sc, uint16_t addr)
+{
 	uint8_t buf[4];
 	uint32_t val;
 	if (urtwn_read_region_1(sc, addr, buf, 4) != USBD_NORMAL_COMPLETION)
 		return 0xffffffff;
 	val = LE_READ_4(&buf[0]);
 	DPRINTFN(DBG_REG, ("%s: %s: addr=0x%x, val=0x%x\n",
 	    device_xname(sc->sc_dev), __func__, addr, val));
 	return val;
+}
 static int
 urtwn_fw_cmd(struct urtwn_softc *sc, uint8_t id, const void *buf, int len)
+{
 	struct r92c_fw_cmd cmd;
 	uint8_t *cp;
 	int fwcur;
 	int ntries;
 	DPRINTFN(DBG_REG, ("%s: %s: id=%d, buf=%p, len=%d\n",
 	    device_xname(sc->sc_dev), __func__, id, buf, len));
 	KASSERT(mutex_owned(&sc->sc_write_mtx));
 	mutex_enter(&sc->sc_fwcmd_mtx);
 	fwcur = sc->fwcur;
 	sc->fwcur = (sc->fwcur + 1) % R92C_H2C_NBOX;
 	mutex_exit(&sc->sc_fwcmd_mtx);
 	/* Wait for current FW box to be empty. */
 	for (ntries = 0; ntries < 100; ntries++) {
 		if (!(urtwn_read_1(sc, R92C_HMETFR) & (1 << fwcur)))
 			break;
 		DELAY(10);
+	}
 	if (ntries == 100) {
 		aprint_error_dev(sc->sc_dev,
 		    "could not send firmware command %d\n", id);
 		return ETIMEDOUT;
+	}
 	memset(&cmd, 0, sizeof(cmd));
 	KASSERT(len <= sizeof(cmd.msg));
 	memcpy(cmd.msg, buf, len);
 	/* Write the first word last since that will trigger the FW. */
 	cp = (uint8_t *)&cmd;
 	cmd.id = id;
 	if (len >= 4) {
 		if (!ISSET(sc->chip, URTWN_CHIP_92EU)) {
 			cmd.id |= R92C_CMD_FLAG_EXT;
 			urtwn_write_region(sc, R92C_HMEBOX_EXT(fwcur),
 			    &cp[1], 2);
 			urtwn_write_4(sc, R92C_HMEBOX(fwcur),
 			    cp[0] + (cp[3] << 8) + (cp[4] << 16) +
 			    (cp[5] << 24));
 		} else {
 			urtwn_write_region(sc, R92E_HMEBOX_EXT(fwcur),
 			    &cp[4], 2);
 			urtwn_write_4(sc, R92C_HMEBOX(fwcur),
 			    cp[0] + (cp[1] << 8) + (cp[2] << 16) +
 			    (cp[3] << 24));
+		}
 	} else {
 		urtwn_write_region(sc, R92C_HMEBOX(fwcur), cp, len);
+	}
 	return 0;
+}
 static __inline void
 urtwn_rf_write(struct urtwn_softc *sc, int chain, uint8_t addr, uint32_t val)
+{
 	sc->sc_rf_write(sc, chain, addr, val);
+}
 static void
 urtwn_r92c_rf_write(struct urtwn_softc *sc, int chain, uint8_t addr,
     uint32_t val)
+{
 	urtwn_bb_write(sc, R92C_LSSI_PARAM(chain),
 	    SM(R92C_LSSI_PARAM_ADDR, addr) | SM(R92C_LSSI_PARAM_DATA, val));
+}
 static void
 urtwn_r88e_rf_write(struct urtwn_softc *sc, int chain, uint8_t addr,
     uint32_t val)
+{
 	urtwn_bb_write(sc, R92C_LSSI_PARAM(chain),
 	    SM(R88E_LSSI_PARAM_ADDR, addr) | SM(R92C_LSSI_PARAM_DATA, val));
+}
 static void
 urtwn_r92e_rf_write(struct urtwn_softc *sc, int chain, uint8_t addr,
     uint32_t val)
+{
 	urtwn_bb_write(sc, R92C_LSSI_PARAM(chain),
 	    SM(R88E_LSSI_PARAM_ADDR, addr) | SM(R92C_LSSI_PARAM_DATA, val));
+}
 static uint32_t
 urtwn_rf_read(struct urtwn_softc *sc, int chain, uint8_t addr)
+{
 	uint32_t reg[R92C_MAX_CHAINS], val;
 	reg[0] = urtwn_bb_read(sc, R92C_HSSI_PARAM2(0));
 	if (chain != 0) {
 		reg[chain] = urtwn_bb_read(sc, R92C_HSSI_PARAM2(chain));
+	}
 	urtwn_bb_write(sc, R92C_HSSI_PARAM2(0),
 	    reg[0] & ~R92C_HSSI_PARAM2_READ_EDGE);
 	DELAY(1000);
 	urtwn_bb_write(sc, R92C_HSSI_PARAM2(chain),
 	    RW(reg[chain], R92C_HSSI_PARAM2_READ_ADDR, addr) |
 	    R92C_HSSI_PARAM2_READ_EDGE);
 	DELAY(1000);
 	urtwn_bb_write(sc, R92C_HSSI_PARAM2(0),
 	    reg[0] | R92C_HSSI_PARAM2_READ_EDGE);
 	DELAY(1000);
 	if (urtwn_bb_read(sc, R92C_HSSI_PARAM1(chain)) & R92C_HSSI_PARAM1_PI) {
 		val = urtwn_bb_read(sc, R92C_HSPI_READBACK(chain));
 	} else {
 		val = urtwn_bb_read(sc, R92C_LSSI_READBACK(chain));
+	}
 	return MS(val, R92C_LSSI_READBACK_DATA);
+}
 static int
 urtwn_llt_write(struct urtwn_softc *sc, uint32_t addr, uint32_t data)
+{
 	int ntries;
 	KASSERT(mutex_owned(&sc->sc_write_mtx));
 	urtwn_write_4(sc, R92C_LLT_INIT,
 	    SM(R92C_LLT_INIT_OP, R92C_LLT_INIT_OP_WRITE) |
 	    SM(R92C_LLT_INIT_ADDR, addr) |
 	    SM(R92C_LLT_INIT_DATA, data));
 	/* Wait for write operation to complete. */
 	for (ntries = 0; ntries < 20; ntries++) {
 		if (MS(urtwn_read_4(sc, R92C_LLT_INIT), R92C_LLT_INIT_OP) ==
 		    R92C_LLT_INIT_OP_NO_ACTIVE) {
 			/* Done */
 			return 0;
+		}
 		DELAY(5);
+	}
 	return ETIMEDOUT;
+}
 static uint8_t
 urtwn_efuse_read_1(struct urtwn_softc *sc, uint16_t addr)
+{
 	uint32_t reg;
 	int ntries;
 	KASSERT(mutex_owned(&sc->sc_write_mtx));
 	reg = urtwn_read_4(sc, R92C_EFUSE_CTRL);
 	reg = RW(reg, R92C_EFUSE_CTRL_ADDR, addr);
 	reg &= ~R92C_EFUSE_CTRL_VALID;
 	urtwn_write_4(sc, R92C_EFUSE_CTRL, reg);
 	/* Wait for read operation to complete. */
 	for (ntries = 0; ntries < 100; ntries++) {
 		reg = urtwn_read_4(sc, R92C_EFUSE_CTRL);
 		if (reg & R92C_EFUSE_CTRL_VALID) {
 			/* Done */
 			return MS(reg, R92C_EFUSE_CTRL_DATA);
+		}
 		DELAY(5);
+	}
 	aprint_error_dev(sc->sc_dev,
 	    "could not read efuse byte at address 0x%04x\n", addr);
 	return 0xff;
+}
 static void
 urtwn_efuse_read(struct urtwn_softc *sc)
+{
 	uint8_t *rom = (uint8_t *)&sc->rom;
 	uint32_t reg;
 	uint16_t addr = 0;
 	uint8_t off, msk;
 	size_t i;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	KASSERT(mutex_owned(&sc->sc_write_mtx));
 	urtwn_efuse_switch_power(sc);
 	memset(&sc->rom, 0xff, sizeof(sc->rom));
 	while (addr < 512) {
 		reg = urtwn_efuse_read_1(sc, addr);
 		if (reg == 0xff)
 			break;
 		addr++;
 		off = reg >> 4;
 		msk = reg & 0xf;
 		for (i = 0; i < 4; i++) {
 			if (msk & (1U << i))
 				continue;
 			rom[off * 8 + i * 2 + 0] = urtwn_efuse_read_1(sc, addr);
 			addr++;
 			rom[off * 8 + i * 2 + 1] = urtwn_efuse_read_1(sc, addr);
 			addr++;
+		}
+	}
 #ifdef URTWN_DEBUG
 	if (urtwn_debug & DBG_INIT) {
 		/* Dump ROM content. */
 		printf("%s: %s", device_xname(sc->sc_dev), __func__);
 		for (i = 0; i < (int)sizeof(sc->rom); i++)
 			printf(":%02x", rom[i]);
 		printf("\n");
+	}
 #endif
+}
 static void
 urtwn_efuse_switch_power(struct urtwn_softc *sc)
+{
 	uint32_t reg;
 	reg = urtwn_read_2(sc, R92C_SYS_ISO_CTRL);
 	if (!(reg & R92C_SYS_ISO_CTRL_PWC_EV12V)) {
 		urtwn_write_2(sc, R92C_SYS_ISO_CTRL,
 		    reg | R92C_SYS_ISO_CTRL_PWC_EV12V);
+	}
 	reg = urtwn_read_2(sc, R92C_SYS_FUNC_EN);
 	if (!(reg & R92C_SYS_FUNC_EN_ELDR)) {
 		urtwn_write_2(sc, R92C_SYS_FUNC_EN,
 		    reg | R92C_SYS_FUNC_EN_ELDR);
+	}
 	reg = urtwn_read_2(sc, R92C_SYS_CLKR);
 	if ((reg & (R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M)) !=
 	    (R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M)) {
 		urtwn_write_2(sc, R92C_SYS_CLKR,
 		    reg | R92C_SYS_CLKR_LOADER_EN | R92C_SYS_CLKR_ANA8M);
+	}
+}
 static int
 urtwn_read_chipid(struct urtwn_softc *sc)
+{
 	uint32_t reg;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	if (ISSET(sc->chip, URTWN_CHIP_88E) ||
 	    ISSET(sc->chip, URTWN_CHIP_92EU))
 		return 0;
 	reg = urtwn_read_4(sc, R92C_SYS_CFG);
 	if (reg & R92C_SYS_CFG_TRP_VAUX_EN) {
 		/* test chip, not supported */
 		return EIO;
+	}
 	if (reg & R92C_SYS_CFG_TYPE_92C) {
 		sc->chip |= URTWN_CHIP_92C;
 		/* Check if it is a castrated 8192C. */
 		if (MS(urtwn_read_4(sc, R92C_HPON_FSM),
 		    R92C_HPON_FSM_CHIP_BONDING_ID) ==
 		    R92C_HPON_FSM_CHIP_BONDING_ID_92C_1T2R) {
 			sc->chip |= URTWN_CHIP_92C_1T2R;
+		}
+	}
 	if (reg & R92C_SYS_CFG_VENDOR_UMC) {
 		sc->chip |= URTWN_CHIP_UMC;
 		if (MS(reg, R92C_SYS_CFG_CHIP_VER_RTL) == 0) {
 			sc->chip |= URTWN_CHIP_UMC_A_CUT;
+		}
+	}
 	return 0;
+}
 #ifdef URTWN_DEBUG
 static void
 urtwn_dump_rom(struct urtwn_softc *sc, struct r92c_rom *rp)
+{
 	aprint_normal_dev(sc->sc_dev,
 	    "id 0x%04x, dbg_sel 0x%x, vid 0x%x, pid 0x%x\n",
 	    rp->id, rp->dbg_sel, rp->vid, rp->pid);
 	aprint_normal_dev(sc->sc_dev,
 	    "usb_opt 0x%x, ep_setting 0x%x, usb_phy 0x%x\n",
 	    rp->usb_opt, rp->ep_setting, rp->usb_phy);
 	aprint_normal_dev(sc->sc_dev,
 	    "macaddr %02x:%02x:%02x:%02x:%02x:%02x\n",
 	    rp->macaddr[0], rp->macaddr[1],
 	    rp->macaddr[2], rp->macaddr[3],
 	    rp->macaddr[4], rp->macaddr[5]);
 	aprint_normal_dev(sc->sc_dev,
 	    "string %s, subcustomer_id 0x%x\n",
 	    rp->string, rp->subcustomer_id);
 	aprint_normal_dev(sc->sc_dev,
 	    "cck_tx_pwr c0: %d %d %d, c1: %d %d %d\n",
 	    rp->cck_tx_pwr[0][0], rp->cck_tx_pwr[0][1], rp->cck_tx_pwr[0][2],
 	    rp->cck_tx_pwr[1][0], rp->cck_tx_pwr[1][1], rp->cck_tx_pwr[1][2]);
 	aprint_normal_dev(sc->sc_dev,
 	    "ht40_1s_tx_pwr c0 %d %d %d, c1 %d %d %d\n",
 	    rp->ht40_1s_tx_pwr[0][0], rp->ht40_1s_tx_pwr[0][1],
 	    rp->ht40_1s_tx_pwr[0][2],
 	    rp->ht40_1s_tx_pwr[1][0], rp->ht40_1s_tx_pwr[1][1],
 	    rp->ht40_1s_tx_pwr[1][2]);
 	aprint_normal_dev(sc->sc_dev,
 	    "ht40_2s_tx_pwr_diff c0: %d %d %d, c1: %d %d %d\n",
 	    rp->ht40_2s_tx_pwr_diff[0] & 0xf, rp->ht40_2s_tx_pwr_diff[1] & 0xf,
 	    rp->ht40_2s_tx_pwr_diff[2] & 0xf,
 	    rp->ht40_2s_tx_pwr_diff[0] >> 4, rp->ht40_2s_tx_pwr_diff[1] & 0xf,
 	    rp->ht40_2s_tx_pwr_diff[2] >> 4);
 	aprint_normal_dev(sc->sc_dev,
 	    "ht20_tx_pwr_diff c0: %d %d %d, c1: %d %d %d\n",
 	    rp->ht20_tx_pwr_diff[0] & 0xf, rp->ht20_tx_pwr_diff[1] & 0xf,
 	    rp->ht20_tx_pwr_diff[2] & 0xf,
 	    rp->ht20_tx_pwr_diff[0] >> 4, rp->ht20_tx_pwr_diff[1] >> 4,
 	    rp->ht20_tx_pwr_diff[2] >> 4);
 	aprint_normal_dev(sc->sc_dev,
 	    "ofdm_tx_pwr_diff c0: %d %d %d, c1: %d %d %d\n",
 	    rp->ofdm_tx_pwr_diff[0] & 0xf, rp->ofdm_tx_pwr_diff[1] & 0xf,
 	    rp->ofdm_tx_pwr_diff[2] & 0xf,
 	    rp->ofdm_tx_pwr_diff[0] >> 4, rp->ofdm_tx_pwr_diff[1] >> 4,
 	    rp->ofdm_tx_pwr_diff[2] >> 4);
 	aprint_normal_dev(sc->sc_dev,
 	    "ht40_max_pwr_offset c0: %d %d %d, c1: %d %d %d\n",
 	    rp->ht40_max_pwr[0] & 0xf, rp->ht40_max_pwr[1] & 0xf,
 	    rp->ht40_max_pwr[2] & 0xf,
 	    rp->ht40_max_pwr[0] >> 4, rp->ht40_max_pwr[1] >> 4,
 	    rp->ht40_max_pwr[2] >> 4);
 	aprint_normal_dev(sc->sc_dev,
 	    "ht20_max_pwr_offset c0: %d %d %d, c1: %d %d %d\n",
 	    rp->ht20_max_pwr[0] & 0xf, rp->ht20_max_pwr[1] & 0xf,
 	    rp->ht20_max_pwr[2] & 0xf,
 	    rp->ht20_max_pwr[0] >> 4, rp->ht20_max_pwr[1] >> 4,
 	    rp->ht20_max_pwr[2] >> 4);
 	aprint_normal_dev(sc->sc_dev,
 	    "xtal_calib %d, tssi %d %d, thermal %d\n",
 	    rp->xtal_calib, rp->tssi[0], rp->tssi[1], rp->thermal_meter);
 	aprint_normal_dev(sc->sc_dev,
 	    "rf_opt1 0x%x, rf_opt2 0x%x, rf_opt3 0x%x, rf_opt4 0x%x\n",
 	    rp->rf_opt1, rp->rf_opt2, rp->rf_opt3, rp->rf_opt4);
 	aprint_normal_dev(sc->sc_dev,
 	    "channnel_plan %d, version %d customer_id 0x%x\n",
 	    rp->channel_plan, rp->version, rp->curstomer_id);
+}
 #endif
 static void
 urtwn_read_rom(struct urtwn_softc *sc)
+{
 	struct ieee80211com *ic = &sc->sc_ic;
 	struct r92c_rom *rom = &sc->rom;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	mutex_enter(&sc->sc_write_mtx);
 	/* Read full ROM image. */
 	urtwn_efuse_read(sc);
 #ifdef URTWN_DEBUG
 	if (urtwn_debug & DBG_REG)
 		urtwn_dump_rom(sc, rom);
 #endif
 	/* XXX Weird but this is what the vendor driver does. */
 	sc->pa_setting = urtwn_efuse_read_1(sc, 0x1fa);
 	sc->board_type = MS(rom->rf_opt1, R92C_ROM_RF1_BOARD_TYPE);
 	sc->regulatory = MS(rom->rf_opt1, R92C_ROM_RF1_REGULATORY);
 	DPRINTFN(DBG_INIT,
 	    ("%s: %s: PA setting=0x%x, board=0x%x, regulatory=%d\n",
 	    device_xname(sc->sc_dev), __func__, sc->pa_setting,
 	    sc->board_type, sc->regulatory));
 	IEEE80211_ADDR_COPY(ic->ic_myaddr, rom->macaddr);
 	sc->sc_rf_write = urtwn_r92c_rf_write;
 	sc->sc_power_on = urtwn_r92c_power_on;
 	sc->sc_dma_init = urtwn_r92c_dma_init;
 	mutex_exit(&sc->sc_write_mtx);
+}
 static void
 urtwn_r88e_read_rom(struct urtwn_softc *sc)
+{
 	struct ieee80211com *ic = &sc->sc_ic;
 	uint8_t *rom = sc->r88e_rom;
 	uint32_t reg;
 	uint16_t addr = 0;
 	uint8_t off, msk, tmp;
 	int i;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	mutex_enter(&sc->sc_write_mtx);
 	off = 0;
 	urtwn_efuse_switch_power(sc);
 	/* Read full ROM image. */
 	memset(&sc->r88e_rom, 0xff, sizeof(sc->r88e_rom));
 	while (addr < 4096) {
 		reg = urtwn_efuse_read_1(sc, addr);
 		if (reg == 0xff)
 			break;
 		addr++;
 		if ((reg & 0x1f) == 0x0f) {
 			tmp = (reg & 0xe0) >> 5;
 			reg = urtwn_efuse_read_1(sc, addr);
 			if ((reg & 0x0f) != 0x0f)
 				off = ((reg & 0xf0) >> 1) | tmp;
 			addr++;
 		} else
 			off = reg >> 4;
 		msk = reg & 0xf;
 		for (i = 0; i < 4; i++) {
 			if (msk & (1 << i))
 				continue;
 			rom[off * 8 + i * 2 + 0] = urtwn_efuse_read_1(sc, addr);
 			addr++;
 			rom[off * 8 + i * 2 + 1] = urtwn_efuse_read_1(sc, addr);
 			addr++;
+		}
+	}
 #ifdef URTWN_DEBUG
 	if (urtwn_debug & DBG_REG) {
+	}
 #endif
 	addr = 0x10;
 	for (i = 0; i < 6; i++)
 		sc->cck_tx_pwr[i] = sc->r88e_rom[addr++];
 	for (i = 0; i < 5; i++)
 		sc->ht40_tx_pwr[i] = sc->r88e_rom[addr++];
 	sc->bw20_tx_pwr_diff = (sc->r88e_rom[addr] & 0xf0) >> 4;
 	if (sc->bw20_tx_pwr_diff & 0x08)
 		sc->bw20_tx_pwr_diff |= 0xf0;
 	sc->ofdm_tx_pwr_diff = (sc->r88e_rom[addr] & 0xf);
 	if (sc->ofdm_tx_pwr_diff & 0x08)
 		sc->ofdm_tx_pwr_diff |= 0xf0;
 	sc->regulatory = MS(sc->r88e_rom[0xc1], R92C_ROM_RF1_REGULATORY);
 	IEEE80211_ADDR_COPY(ic->ic_myaddr, &sc->r88e_rom[0xd7]);
 	if (ISSET(sc->chip, URTWN_CHIP_92EU)) {
 		sc->sc_power_on = urtwn_r92e_power_on;
 		sc->sc_rf_write = urtwn_r92e_rf_write;
 	} else {
 		sc->sc_power_on = urtwn_r88e_power_on;
 		sc->sc_rf_write = urtwn_r88e_rf_write;
+	}
 	sc->sc_dma_init = urtwn_r88e_dma_init;
 	mutex_exit(&sc->sc_write_mtx);
+}
 static int
 urtwn_media_change(struct ifnet *ifp)
+{
 #ifdef URTWN_DEBUG
 	struct urtwn_softc *sc = ifp->if_softc;
 #endif
 	int error;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	if ((error = ieee80211_media_change(ifp)) != ENETRESET)
 		return error;
 	if ((ifp->if_flags & (IFF_UP | IFF_RUNNING)) ==
 	    (IFF_UP | IFF_RUNNING)) {
 		urtwn_init(ifp);
+	}
 	return 0;
+}
 /*
  * Initialize rate adaptation in firmware.
  */
 static int
 urtwn_ra_init(struct urtwn_softc *sc)
+{
 	static const uint8_t map[] = {
 , 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108
 	};
 	struct ieee80211com *ic = &sc->sc_ic;
 	struct ieee80211_node *ni = ic->ic_bss;
 	struct ieee80211_rateset *rs = &ni->ni_rates;
 	struct r92c_fw_cmd_macid_cfg cmd;
 	uint32_t rates, basicrates;
 	uint32_t mask, rrsr_mask, rrsr_rate;
 	uint8_t mode;
 	size_t maxrate, maxbasicrate, i, j;
 	int error;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	KASSERT(mutex_owned(&sc->sc_write_mtx));
 	/* Get normal and basic rates mask. */
 	rates = basicrates = 1;
 	maxrate = maxbasicrate = 0;
 	for (i = 0; i < rs->rs_nrates; i++) {
 		/* Convert 802.11 rate to HW rate index. */
 		for (j = 0; j < __arraycount(map); j++) {
 			if ((rs->rs_rates[i] & IEEE80211_RATE_VAL) == map[j]) {
 				break;
+			}
+		}
 		if (j == __arraycount(map)) {
 			/* Unknown rate, skip. */
 			continue;
+		}
 		rates |= 1U << j;
 		if (j > maxrate) {
 			maxrate = j;
+		}
 		if (rs->rs_rates[i] & IEEE80211_RATE_BASIC) {
 			basicrates |= 1U << j;
 			if (j > maxbasicrate) {
 				maxbasicrate = j;
+			}
+		}
+	}
 	if (ic->ic_curmode == IEEE80211_MODE_11B) {
 		mode = R92C_RAID_11B;
 	} else {
 		mode = R92C_RAID_11BG;
+	}
 	DPRINTFN(DBG_INIT, ("%s: %s: mode=0x%x rates=0x%x, basicrates=0x%x, "
 	    "maxrate=%zx, maxbasicrate=%zx\n",
 	    device_xname(sc->sc_dev), __func__, mode, rates, basicrates,
 	    maxrate, maxbasicrate));
 	if (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE) {
 		maxbasicrate |= R92C_RATE_SHORTGI;
 		maxrate |= R92C_RATE_SHORTGI;
+	}
 	/* Set rates mask for group addressed frames. */
 	cmd.macid = URTWN_MACID_BC | URTWN_MACID_VALID;
 	if (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE)
 		cmd.macid |= URTWN_MACID_SHORTGI;
 	mask = (mode << 28) | basicrates;
 	cmd.mask[0] = (uint8_t)mask;
 	cmd.mask[1] = (uint8_t)(mask >> 8);
 	cmd.mask[2] = (uint8_t)(mask >> 16);
 	cmd.mask[3] = (uint8_t)(mask >> 24);
 	error = urtwn_fw_cmd(sc, R92C_CMD_MACID_CONFIG, &cmd, sizeof(cmd));
 	if (error != 0) {
 		aprint_error_dev(sc->sc_dev,
 		    "could not add broadcast station\n");
 		return error;
+	}
 	/* Set initial MRR rate. */
 	DPRINTFN(DBG_INIT, ("%s: %s: maxbasicrate=%zd\n",
 	    device_xname(sc->sc_dev), __func__, maxbasicrate));
 	urtwn_write_1(sc, R92C_INIDATA_RATE_SEL(URTWN_MACID_BC), maxbasicrate);
 	/* Set rates mask for unicast frames. */
 	cmd.macid = URTWN_MACID_BSS | URTWN_MACID_VALID;
 	if (ni->ni_capinfo & IEEE80211_CAPINFO_SHORT_PREAMBLE)
 		cmd.macid |= URTWN_MACID_SHORTGI;
 	mask = (mode << 28) | rates;
 	cmd.mask[0] = (uint8_t)mask;
 	cmd.mask[1] = (uint8_t)(mask >> 8);
 	cmd.mask[2] = (uint8_t)(mask >> 16);
 	cmd.mask[3] = (uint8_t)(mask >> 24);
 	error = urtwn_fw_cmd(sc, R92C_CMD_MACID_CONFIG, &cmd, sizeof(cmd));
 	if (error != 0) {
 		aprint_error_dev(sc->sc_dev, "could not add BSS station\n");
 		return error;
+	}
 	/* Set initial MRR rate. */
 	DPRINTFN(DBG_INIT, ("%s: %s: maxrate=%zd\n", device_xname(sc->sc_dev),
 	    __func__, maxrate));
 	urtwn_write_1(sc, R92C_INIDATA_RATE_SEL(URTWN_MACID_BSS), maxrate);
 	rrsr_rate = ic->ic_fixed_rate;
 	if (rrsr_rate == -1)
 		rrsr_rate = 11;
 	rrsr_mask = 0xffff >> (15 - rrsr_rate);
 	urtwn_write_2(sc, R92C_RRSR, rrsr_mask);
 	/* Indicate highest supported rate. */
 	ni->ni_txrate = rs->rs_nrates - 1;
 	return 0;
+}
 static int
 urtwn_get_nettype(struct urtwn_softc *sc)
+{
 	struct ieee80211com *ic = &sc->sc_ic;
 	int type;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	switch (ic->ic_opmode) {
 	case IEEE80211_M_STA:
 		type = R92C_CR_NETTYPE_INFRA;
 		break;
 	case IEEE80211_M_IBSS:
 		type = R92C_CR_NETTYPE_ADHOC;
 		break;
 	default:
 		type = R92C_CR_NETTYPE_NOLINK;
 		break;
+	}
 	return type;
+}
 static void
 urtwn_set_nettype0_msr(struct urtwn_softc *sc, uint8_t type)
+{
 	uint8_t	reg;
 	DPRINTFN(DBG_FN, ("%s: %s: type=%d\n", device_xname(sc->sc_dev),
 	    __func__, type));
 	KASSERT(mutex_owned(&sc->sc_write_mtx));
 	reg = urtwn_read_1(sc, R92C_CR + 2) & 0x0c;
 	urtwn_write_1(sc, R92C_CR + 2, reg | type);
+}
 static void
 urtwn_tsf_sync_enable(struct urtwn_softc *sc)
+{
 	struct ieee80211_node *ni = sc->sc_ic.ic_bss;
 	uint64_t tsf;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	KASSERT(mutex_owned(&sc->sc_write_mtx));
 	/* Enable TSF synchronization. */
 	urtwn_write_1(sc, R92C_BCN_CTRL,
 	    urtwn_read_1(sc, R92C_BCN_CTRL) & ~R92C_BCN_CTRL_DIS_TSF_UDT0);
 	/* Correct TSF */
 	urtwn_write_1(sc, R92C_BCN_CTRL,
 	    urtwn_read_1(sc, R92C_BCN_CTRL) & ~R92C_BCN_CTRL_EN_BCN);
 	/* Set initial TSF. */
 	tsf = ni->ni_tstamp.tsf;
 	tsf = le64toh(tsf);
 	tsf = tsf - (tsf % (ni->ni_intval * IEEE80211_DUR_TU));
 	tsf -= IEEE80211_DUR_TU;
 	urtwn_write_4(sc, R92C_TSFTR + 0, (uint32_t)tsf);
 	urtwn_write_4(sc, R92C_TSFTR + 4, (uint32_t)(tsf >> 32));
 	urtwn_write_1(sc, R92C_BCN_CTRL,
 	    urtwn_read_1(sc, R92C_BCN_CTRL) | R92C_BCN_CTRL_EN_BCN);
+}
 static void
 urtwn_set_led(struct urtwn_softc *sc, int led, int on)
+{
 	uint8_t reg;
 	DPRINTFN(DBG_FN, ("%s: %s: led=%d, on=%d\n", device_xname(sc->sc_dev),
 	    __func__, led, on));
 	KASSERT(mutex_owned(&sc->sc_write_mtx));
 	if (led == URTWN_LED_LINK) {
 		if (ISSET(sc->chip, URTWN_CHIP_92EU)) {
 			urtwn_write_1(sc, 0x64, urtwn_read_1(sc, 0x64) & 0xfe);
 			reg = urtwn_read_1(sc, R92C_LEDCFG1) & R92E_LEDSON;
 			urtwn_write_1(sc, R92C_LEDCFG1, reg |
 			    (R92C_LEDCFG0_DIS << 1));
 			if (on) {
 				reg = urtwn_read_1(sc, R92C_LEDCFG1) &
 				    R92E_LEDSON;
 				urtwn_write_1(sc, R92C_LEDCFG1, reg);
+			}
 		} else if (ISSET(sc->chip, URTWN_CHIP_88E)) {
 			reg = urtwn_read_1(sc, R92C_LEDCFG2) & 0xf0;
 			urtwn_write_1(sc, R92C_LEDCFG2, reg | 0x60);
 			if (!on) {
 				reg = urtwn_read_1(sc, R92C_LEDCFG2) & 0x90;
 				urtwn_write_1(sc, R92C_LEDCFG2,
 				    reg | R92C_LEDCFG0_DIS);
 				reg = urtwn_read_1(sc, R92C_MAC_PINMUX_CFG);
 				urtwn_write_1(sc, R92C_MAC_PINMUX_CFG,
 				    reg & 0xfe);
+			}
 		} else {
 			reg = urtwn_read_1(sc, R92C_LEDCFG0) & 0x70;
 			if (!on) {
 				reg |= R92C_LEDCFG0_DIS;
+			}
 			urtwn_write_1(sc, R92C_LEDCFG0, reg);
+		}
 		sc->ledlink = on;	/* Save LED state. */
+	}
+}
 static void
 urtwn_calib_to(void *arg)
+{
 	struct urtwn_softc *sc = arg;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return;
 	/* Do it in a process context. */
 	urtwn_do_async(sc, urtwn_calib_to_cb, NULL, 0);
+}
 /* ARGSUSED */
 static void
 urtwn_calib_to_cb(struct urtwn_softc *sc, void *arg)
+{
 	struct r92c_fw_cmd_rssi cmd;
 	struct r92e_fw_cmd_rssi cmde;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_ic.ic_state != IEEE80211_S_RUN)
 		goto restart_timer;
 	mutex_enter(&sc->sc_write_mtx);
 	if (sc->avg_pwdb != -1) {
 		/* Indicate Rx signal strength to FW for rate adaptation. */
 		memset(&cmd, 0, sizeof(cmd));
 		memset(&cmde, 0, sizeof(cmde));
 		cmd.macid = 0;	/* BSS. */
 		cmde.macid = 0;	/* BSS. */
 		cmd.pwdb = sc->avg_pwdb;
 		cmde.pwdb = sc->avg_pwdb;
 		DPRINTFN(DBG_RF, ("%s: %s: sending RSSI command avg=%d\n",
 		    device_xname(sc->sc_dev), __func__, sc->avg_pwdb));
 		if (!ISSET(sc->chip, URTWN_CHIP_92EU)) {
 			urtwn_fw_cmd(sc, R92C_CMD_RSSI_SETTING, &cmd,
 			    sizeof(cmd));
 		} else {
 			urtwn_fw_cmd(sc, R92E_CMD_RSSI_REPORT, &cmde,
 			    sizeof(cmde));
+		}
+	}
 	/* Do temperature compensation. */
 	urtwn_temp_calib(sc);
 	mutex_exit(&sc->sc_write_mtx);
  restart_timer:
 	if (!sc->sc_dying) {
 		/* Restart calibration timer. */
 		callout_schedule(&sc->sc_calib_to, hz);
+	}
+}
 static void
 urtwn_next_scan(void *arg)
+{
 	struct urtwn_softc *sc = arg;
 	int s;
 	DPRINTFN(DBG_FN, ("%s: %s\n", device_xname(sc->sc_dev), __func__));
 	if (sc->sc_dying)
 		return;
 	s = splnet();
 	if (sc->sc_ic.ic_state == IEEE80211_S_SCAN)
 		ieee80211_next_scan(&sc->sc_ic);
 	splx(s);
+}
 static void
 urtwn_newassoc(struct ieee80211_node *ni, int isnew)
+{
 	DPRINTFN(DBG_FN, ("%s: new node %s\n", __func__,
 	    ether_sprintf(ni->ni_macaddr)));
 	/* start with lowest Tx rate */
 	ni->ni_txrate = 0;
+}
 static int
 urtwn_newstate(struct ieee80211com *ic, enum ieee80211_state nstate, int arg)
+{
 	struct urtwn_softc *sc = ic->ic_ifp->if_softc;
 	struct urtwn_cmd_newstate cmd;
 	DPRINTFN(DBG_FN, ("%s: %s: nstate=%s(%d), arg=%d\n",
 	    device_xname(sc->sc_dev), __func__,
 	    ieee80211_state_name[nstate], nstate, arg));
 	callout_stop(&sc->sc_scan_to);
 	callout_stop(&sc->sc_calib_to);
 	/* Do it in a process context. */
 	cmd.state = nstate;
 	cmd.arg = arg;
 	urtwn_do_async(sc, urtwn_newstate_cb, &cmd, sizeof(cmd));
 	return 0;
+}
 static void
 urtwn_newstate_cb(struct urtwn_softc *sc, void *arg)
+{
 	struct urtwn_cmd_newstate *cmd = arg;
 	struct ieee80211com *ic = &sc->sc_ic;
 	struct ieee80211_node *ni;
 	enum ieee80211_state ostate = ic->ic_state;
 	enum ieee80211_state nstate = cmd->state;
 	uint32_t reg;
 	uint8_t sifs_time, msr;
 	int s;
 	DPRINTFN(DBG_FN|DBG_STM, ("%s: %s: %s(%d)->%s(%d)\n",
 	    device_xname(sc->sc_dev), __func__,
 	    ieee80211_state_name[ostate], ostate,
 	    ieee80211_state_name[nstate], nstate));
 	s = splnet();
 	mutex_enter(&sc->sc_write_mtx);
 	callout_stop(&sc->sc_scan_to);
 	callout_stop(&sc->sc_calib_to);
 	switch (ostate) {
 	case IEEE80211_S_INIT:
 		break;
 	case IEEE80211_S_SCAN:
 		if (nstate != IEEE80211_S_SCAN) {
 			/*
 			 * End of scanning
 			 */
 			/* flush 4-AC Queue after site_survey */
 			urtwn_write_1(sc, R92C_TXPAUSE, 0x0);
 			/* Allow Rx from our BSSID only. */
 			urtwn_write_4(sc, R92C_RCR,
 			    urtwn_read_4(sc, R92C_RCR) |
 			      R92C_RCR_CBSSID_DATA | R92C_RCR_CBSSID_BCN);
+		}
 		break;

 @@ -1,206 +1,205 @@
-$NetBSD: TODO.usbmp,v 1.8.4.9 2017/01/28 10:15:01 skrll Exp $
+$NetBSD: TODO.usbmp,v 1.8.4.10 2017/01/28 12:04:17 skrll Exp $
 the majority of the USB MP device interface is documented in usbdivar.h.
 flesh out most of usbdi(9).
 usb_event_thread() startup should use something to sync companions
 KERNEL_LOCK
   - auvitek.c
   - auvitek_dtv.c
   - emdtv.c
   - emdtv_dtv.c
   - ubt.c
   - uhub.c
   - usscanner.c
 usb_detach_{waitold,wakeup} to cv_{wait,broadcast} conversion:
   - drivers:
       if_aue.c
       if_axe.c
       if_axen.c
       if_smsc.c
       if_udav.c
       if_url.c
       ubt.c
       ucycom.c
       udsir.c
       uhso.c
       uirda.c
       ulpt.c
       urio.c
       uscanner.c
       usscanner.c
       ustir.c
       utoppy.c
 use usb_delay_ms_locked() in places
 convert uhidev users to MPSAFE:
   ucycom(4)
   - own cdevsw that isn't D_MPSAFE; need to check intr handlers
   uhid(4)
   - D_MPSAFE not set as all users need it first.
   - mostly done
   ukbd(4)
   ums(4)
   uts(4)
   pbms(4)
   - depends upon wscons? check intr
   uyurex(4)
   - sysmon -- hm?
 splusb drivers:
   - auvitek_dtv.c
   - auvitek_video.c
   - emdtv_dtv.c
   - if_athn_usb.c
   - if_aue.c
   - if_axe.c
   - if_axen.c
   - if_cdce.c
   - if_cue.c
   - if_kue.c
   - if_otus.c
   - if_rum.c
   - if_run.c
   - if_smsc.c
   - if_udav.c
   - if_upl.c
   - if_ural.c
   - if_url.c
   - if_urndis.c
   - if_urtw.c
   - if_urtwn.c
   - if_zyd.c
   - ubt.c
   - ucycom.c
   - udsir.c
   - uhso.c
   - ukbd.c
   - ulpt.c
   - urio.c
   - uscanner.c
   - usscanner.c
   - ustir.c
   - utoppy.c
   - uvideo.c
 wakeup/tsleep drivers:
   - if_run.c
   - if_urtwn.c
   - if_zyd.c
   - ucycom.c
   - udsir.c
   - uirda.c
   - umass_isdata.c
   - ustir.c
 missing D_MPSAFE drivers:
   - ucycom
   - ugen		- partially ready
   - uhso
   - ulpt
   - urio
   - usb
   - uscanner
   - utoppy
 missing CALLOUT_MPSAFE drivers:
   - if_aue.c
   - if_axe.c
   - if_axen.c
   - if_cue.c
   - if_otus.c
   - if_rum.c
   - if_run.c
   - if_smsc.c
   - if_udav.c
   - if_upgt.c
   - if_ural.c
   - if_url.c
   - if_urtw.c
   - if_urtwn.c
   - if_zyd.c
   - ukbd.c
   - ulpt.c
   - uyurex.c
 driver testing:		STATUS
   - uhub		working
   - uhid		working
   - uhidev		working
   - ums			working
   - uts
   - ukbd		working
   - ucycom
   - uep
   - udl
   - ulpt		attaches ok
   - uhso		working
   - umass		working
   - uaudio		working
   - umidi		working
   - uirda
   - stuirda
   - ustir
   - irmce
   - aue
   - axe			working
   - cdce
   - cue
   - kue
   - udav
   - url
   - urndis
   - atu
   - otus
   - ral
   - rum
   - run
   - urtw		working
   - urtwn
   - upgt
   - zyd
   - upl
   - uberry
   - uipad
   - urio
   - uscanner		?
   - usscanner
   - utoppy
   - uyap
   - udsbr
   - ugen		mostly done
   - pseye		working
   - uvideo
   - auvitek		?
   - emdtv		?
   - ubt			working
   - aubtfwl
   - u3ginit
 ucom attachments:
   - umodem		working
   - uark
   - ubsa
   - uchcom
   - uftdi		working
   - uipaq
   - umct
   - uplcom		attaches ok
   - uslsa		working
   - uvscom
   - moscom
   - uvisor
   - ukyopon
   - u3g
   - ugensa

 @@ -1,201 +1,202 @@
-/*	$NetBSD: if_urtwnvar.h,v 1.8.4.4 2016/12/05 10:55:18 skrll Exp $	*/
+/*	$NetBSD: if_urtwnvar.h,v 1.8.4.5 2017/01/28 12:04:17 skrll Exp $	*/
 /*	$OpenBSD: if_urtwnreg.h,v 1.3 2010/11/16 18:02:59 damien Exp $	*/
 /*-
  * Copyright (c) 2010 Damien Bergamini <damien.bergamini@free.fr>
+ *
  * Permission to use, copy, modify, and distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 #ifndef _IF_URTWNVAR_H_
 #define _IF_URTWNVAR_H_
 /*
  * Driver definitions.
  */
 #define URTWN_RX_LIST_COUNT		1
 #define URTWN_TX_LIST_COUNT		8
 #define URTWN_HOST_CMD_RING_COUNT	32
 #define URTWN_RXBUFSZ	(16 * 1024)
 #define URTWN_TXBUFSZ	(sizeof(struct r92c_tx_desc) + IEEE80211_MAX_LEN + 8)
 #define URTWN_RIDX_COUNT	28
 #define URTWN_TX_TIMEOUT	5000	/* ms */
 #define URTWN_LED_LINK	0
 #define URTWN_LED_DATA	1
 struct urtwn_rx_radiotap_header {
 	struct ieee80211_radiotap_header wr_ihdr;
 	uint8_t		wr_flags;
 	uint8_t		wr_rate;
 	uint16_t	wr_chan_freq;
 	uint16_t	wr_chan_flags;
 	uint8_t		wr_dbm_antsignal;
 } __packed;
 #define URTWN_RX_RADIOTAP_PRESENT			\
 	(1 << IEEE80211_RADIOTAP_FLAGS |		\
 << IEEE80211_RADIOTAP_RATE |			\
 << IEEE80211_RADIOTAP_CHANNEL |		\
 << IEEE80211_RADIOTAP_DBM_ANTSIGNAL)
 struct urtwn_tx_radiotap_header {
 	struct ieee80211_radiotap_header wt_ihdr;
 	uint8_t		wt_flags;
 	uint16_t	wt_chan_freq;
 	uint16_t	wt_chan_flags;
 } __packed;
 #define URTWN_TX_RADIOTAP_PRESENT			\
 	(1 << IEEE80211_RADIOTAP_FLAGS |		\
 << IEEE80211_RADIOTAP_CHANNEL)
 struct urtwn_softc;
 struct urtwn_rx_data {
 	struct urtwn_softc		*sc;
 	size_t				pidx;
 	struct usbd_xfer		*xfer;
 	uint8_t				*buf;
 	TAILQ_ENTRY(urtwn_rx_data)	next;
 };
 struct urtwn_tx_data {
 	struct urtwn_softc		*sc;
 	size_t				pidx;
 	struct usbd_xfer		*xfer;
 	uint8_t				*buf;
 	TAILQ_ENTRY(urtwn_tx_data)	next;
 };
 struct urtwn_host_cmd {
 	void	(*cb)(struct urtwn_softc *, void *);
 	uint8_t	data[256];
 };
 struct urtwn_cmd_newstate {
 	enum ieee80211_state	state;
 	int			arg;
 };
 struct urtwn_host_cmd_ring {
 	struct urtwn_host_cmd	cmd[URTWN_HOST_CMD_RING_COUNT];
 	int			cur;
 	int			next;
 	int			queued;
 };
 #if 1	/* XXX: sys/net80211/ieee80211.h */
 #define	IEEE80211_HTINFO_2NDCHAN	0x03	/* secondary/ext chan offset */
 #define	IEEE80211_HTINFO_2NDCHAN_S	0
 #define	IEEE80211_HTINFO_2NDCHAN_NONE	0x00	/* no secondary/ext channel */
 #define	IEEE80211_HTINFO_2NDCHAN_ABOVE	0x01	/* above private channel */
 /* NB: 2 is reserved */
 #define	IEEE80211_HTINFO_2NDCHAN_BELOW	0x03	/* below primary channel */
 #endif	/* XXX: 1 */
 struct urtwn_softc {
 	device_t			sc_dev;
 	struct ieee80211com		sc_ic;
 	struct ethercom			sc_ec;
 #define sc_if   sc_ec.ec_if
 	int				(*sc_newstate)(struct ieee80211com *,
 					    enum ieee80211_state, int);
 	struct usbd_device *		sc_udev;
 	struct usbd_interface *		sc_iface;
 	u_int				sc_flags;
 #define URTWN_FLAG_CCK_HIPWR	__BIT(0)
 #define	URTWN_FLAG_ATTACHED	__BIT(1)
 #define	URTWN_FLAG_FWREADY	__BIT(2)
 	int				sc_dying;
 	struct usb_task			sc_task;
 	callout_t			sc_scan_to;
 	callout_t			sc_calib_to;
 	kcondvar_t			sc_task_cv;
 	kmutex_t			sc_task_mtx;
 	kmutex_t			sc_fwcmd_mtx;
 	kmutex_t			sc_tx_mtx;
 	kmutex_t			sc_rx_mtx;
 	kmutex_t			sc_write_mtx;
 	struct usbd_pipe *		rx_pipe[R92C_MAX_EPIN];
 	int				rx_npipe;
 	struct usbd_pipe *		tx_pipe[R92C_MAX_EPOUT];
 	int				tx_npipe;
 	int				ac2idx[WME_NUM_AC];
 	u_int				chip;
 #define URTWN_CHIP_92C		0x01
 #define URTWN_CHIP_92C_1T2R	0x02
 #define URTWN_CHIP_UMC		0x04
 #define URTWN_CHIP_UMC_A_CUT	0x08
 #define URTWN_CHIP_88E		0x10
 #define URTWN_CHIP_92EU		0x20
 	void				(*sc_rf_write)(struct urtwn_softc *,
 					    int, uint8_t, uint32_t);
 	int				(*sc_power_on)(struct urtwn_softc *);
 	int				(*sc_dma_init)(struct urtwn_softc *);
 	uint8_t				board_type;
 	uint8_t				regulatory;
 	uint8_t				pa_setting;
 	int				avg_pwdb;
 	int				thcal_state;
 	int				thcal_lctemp;
 	size_t				ntxchains;
 	size_t				nrxchains;
 	int				ledlink;
 	bool				iqk_inited;
 	int				tx_timer;
 	struct urtwn_host_cmd_ring	cmdq;
 	int				fwcur;
 	struct urtwn_rx_data		rx_data[R92C_MAX_EPIN][URTWN_RX_LIST_COUNT];
 	struct urtwn_tx_data		tx_data[R92C_MAX_EPOUT][URTWN_TX_LIST_COUNT];
 	TAILQ_HEAD(, urtwn_tx_data)	tx_free_list[R92C_MAX_EPOUT];
 	TAILQ_HEAD(, urtwn_rx_data)	rx_free_list[R92C_MAX_EPIN];
 	struct r92c_rom			rom;
 	uint8_t				r88e_rom[4096];
 	uint8_t				cck_tx_pwr[6];
 	uint8_t				ht40_tx_pwr[5];
 	int8_t				bw20_tx_pwr_diff;
 	int8_t				ofdm_tx_pwr_diff;
 	uint32_t			rf_chnlbw[R92C_MAX_CHAINS];
 	struct bpf_if *			sc_drvbpf;
 	union {
 		struct urtwn_rx_radiotap_header th;
 		uint8_t	pad[64];
 	}				sc_rxtapu;
 #define sc_rxtap	sc_rxtapu.th
 	int				sc_rxtap_len;
 	union {
 		struct urtwn_tx_radiotap_header th;
 		uint8_t	pad[64];
 	}				sc_txtapu;
 #define sc_txtap	sc_txtapu.th
 	int				sc_txtap_len;
 	bool				sc_running;
 };
 #endif /* _IF_URTWNVAR_H_ */