Attachment #208925 for bug #227044

View | Details | Raw Unified | Return to bug 227044
Collapse All | Expand All

Lines 22-28 Link Here

(-)b/share/man/man4/iwmfw.4 (-6 / +9 lines)
22	.\"	22	.\"
23	.\" $FreeBSD$	23	.\" $FreeBSD$
24	.\"	24	.\"
25	.Dd October 29, 2017	25	.Dd November 1, 2019
26	.Dt IWMFW 4	26	.Dt IWMFW 4
27	.Os	27	.Os
28	.Sh NAME	28	.Sh NAME
Lines 48-57 of the following: Link Here
48	.Cd "device iwm7265fw"	48	.Cd "device iwm7265fw"
49	.Cd "device iwm8000Cfw"	49	.Cd "device iwm8000Cfw"
50	.Cd "device iwm8265fw"	50	.Cd "device iwm8265fw"
		51	.Cd "device iwm9000fw"
		52	.Cd "device iwm9260fw"
51	.Ed	53	.Ed
52	.Pp	54	.Pp
53	Alternatively, to load the driver as a	55	Alternatively, to load the driver as a
54	module at boot time, place the following line in	56	module at boot time, place one of the following lines in
55	.Xr loader.conf 5 :	57	.Xr loader.conf 5 :
56	.Bd -literal -offset indent	58	.Bd -literal -offset indent
57	iwm3160fw_load="YES"	59	iwm3160fw_load="YES"
Lines 61-73 iwm7265fw_load="YES" Link Here
61	iwm7265Dfw_load="YES"	63	iwm7265Dfw_load="YES"
62	iwm8000Cfw_load="YES"	64	iwm8000Cfw_load="YES"
63	iwm8265fw_load="YES"	65	iwm8265fw_load="YES"
		66	iwm9000fw_load="YES"
		67	iwm9260fw_load="YES"
64	.Ed	68	.Ed
65	.Sh DESCRIPTION	69	.Sh DESCRIPTION
66	This module provides access to firmware sets for the	70	This module provides access to firmware sets for the
67	Intel Dual Band Wireless WiFi 3160, 3165, 3168, 7260, 7265, 8000, and 8260 series of	71	Intel Dual Band Wireless WiFi 3160, 3165, 3168, 7260, 7265, 8000, 8260,
68	IEEE 802.11n/11ac adapters.	72	9000 and 9260 series of IEEE 802.11n/11ac adapters.
69	It may be	73	It may be statically linked into the kernel, or loaded as a module.
70	statically linked into the kernel, or loaded as a module.
71	.Sh SEE ALSO	74	.Sh SEE ALSO
72	.Xr iwm 4 ,	75	.Xr iwm 4 ,
73	.Xr firmware 9	76	.Xr firmware 9




static int	iwm_run_init_mvm_ucode(struct iwm_softc *, int);
static int	iwm_mvm_config_ltr(struct iwm_softc *sc);
static int	iwm_rx_addbuf(struct iwm_softc *, int, int);
static int	iwm_mvm_get_signal_strength(struct iwm_softc *,
					    struct iwm_rx_phy_info *);
static void	iwm_mvm_rx_rx_phy_cmd(struct iwm_softc *,
                                      struct iwm_rx_packet *);
static int	iwm_get_noise(struct iwm_softc *,
		    const struct iwm_mvm_statistics_rx_non_phy *);
static void	iwm_mvm_handle_rx_statistics(struct iwm_softc *,
		    struct iwm_rx_packet *);
static bool	iwm_mvm_rx_mpdu(struct iwm_softc *, struct mbuf *,
		    uint32_t, bool);
static int	iwm_mvm_rx_tx_cmd_single(struct iwm_softc *,
                                         struct iwm_rx_packet *,
				         struct iwm_node *);

			break;
		}

		case IWM_UCODE_TLV_CMD_VERSIONS:
		case IWM_UCODE_TLV_SDIO_ADMA_ADDR:
		case IWM_UCODE_TLV_FW_GSCAN_CAPA:
			/* ignore, not used by current driver */


		default:
			device_printf(sc->sc_dev,
			    "%s: unknown firmware section %d\n",
			    __func__, tlv_type);
			break;
			goto parse_out;
		}
	}


iwm_alloc_rx_ring(struct iwm_softc *sc, struct iwm_rx_ring *ring)
{
	bus_size_t size;
	size_t descsz;
	int count, i, error;

	ring->cur = 0;
	if (sc->cfg->mqrx_supported) {
		count = IWM_RX_MQ_RING_COUNT;
		descsz = sizeof(uint64_t);
	} else {
		count = IWM_RX_LEGACY_RING_COUNT;
		descsz = sizeof(uint32_t);
	}

	/* Allocate RX descriptors (256-byte aligned). */
	size = count * descsz;
	error = iwm_dma_contig_alloc(sc->sc_dmat, &ring->free_desc_dma, size,
	    256);
	if (error != 0) {
		device_printf(sc->sc_dev,
		    "could not allocate RX ring DMA memory\n");
		goto fail;
	}
	ring->desc = ring->free_desc_dma.vaddr;

	/* Allocate RX status area (16-byte aligned). */
	error = iwm_dma_contig_alloc(sc->sc_dmat, &ring->stat_dma,

	}
	ring->stat = ring->stat_dma.vaddr;

	if (sc->cfg->mqrx_supported) {
		size = count * sizeof(uint32_t);
		error = iwm_dma_contig_alloc(sc->sc_dmat, &ring->used_desc_dma,
		    size, 256);
		if (error != 0) {
			device_printf(sc->sc_dev,
			    "could not allocate RX ring DMA memory\n");
			goto fail;
		}
	}

        /* Create RX buffer DMA tag. */
        error = bus_dma_tag_create(sc->sc_dmat, 1, 0,
            BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,

		    __func__, error);
		goto fail;
	}

	/*
	 * Allocate and map RX buffers.
	 */
	for (i = 0; i < count; i++) {
		struct iwm_rx_data *data = &ring->data[i];
		error = bus_dmamap_create(ring->data_dmat, 0, &data->map);
		if (error != 0) {

static void
iwm_free_rx_ring(struct iwm_softc *sc, struct iwm_rx_ring *ring)
{
	int count, i;

	iwm_dma_contig_free(&ring->free_desc_dma);
	iwm_dma_contig_free(&ring->stat_dma);
	iwm_dma_contig_free(&ring->used_desc_dma);

	count = sc->cfg->mqrx_supported ? IWM_RX_MQ_RING_COUNT :
	    IWM_RX_LEGACY_RING_COUNT;

	for (i = 0; i < count; i++) {
		struct iwm_rx_data *data = &ring->data[i];

		if (data->m != NULL) {

	/* Stop the device, and put it in low power state */
	iwm_apm_stop(sc);

	/* stop and reset the on-board processor */
	IWM_SETBITS(sc, IWM_CSR_RESET, IWM_CSR_RESET_REG_FLAG_SW_RESET);
	DELAY(5000);

	/*
	 * Upon stop, the APM issues an interrupt if HW RF kill is set.
	 */
	iwm_disable_interrupts(sc);
	/* stop and reset the on-board processor */
	IWM_WRITE(sc, IWM_CSR_RESET, IWM_CSR_RESET_REG_FLAG_SW_RESET);

	/*
	 * Even if we stop the HW, we still want the RF kill

	 */
	iwm_enable_rfkill_int(sc);
	iwm_check_rfkill(sc);

	iwm_prepare_card_hw(sc);
}

/* iwlwifi: mvm/ops.c */

	reg_val |= radio_cfg_step << IWM_CSR_HW_IF_CONFIG_REG_POS_PHY_STEP;
	reg_val |= radio_cfg_dash << IWM_CSR_HW_IF_CONFIG_REG_POS_PHY_DASH;

	IWM_WRITE(sc, IWM_CSR_HW_IF_CONFIG_REG,
	    IWM_CSR_HW_IF_CONFIG_REG_MSK_MAC_DASH |
	    IWM_CSR_HW_IF_CONFIG_REG_MSK_MAC_STEP |
	    IWM_CSR_HW_IF_CONFIG_REG_MSK_PHY_STEP |
	    IWM_CSR_HW_IF_CONFIG_REG_MSK_PHY_DASH |
	    IWM_CSR_HW_IF_CONFIG_REG_MSK_PHY_TYPE |
	    IWM_CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI |
	    IWM_CSR_HW_IF_CONFIG_REG_BIT_MAC_SI |
	    reg_val);

	IWM_DPRINTF(sc, IWM_DEBUG_RESET,
	    "Radio type=0x%x-0x%x-0x%x\n", radio_cfg_type,

}

static int
iwm_nic_rx_mq_init(struct iwm_softc *sc)
{
	int enabled;

	if (!iwm_nic_lock(sc))
		return EBUSY;

	/* Stop RX DMA. */
	iwm_write_prph(sc, IWM_RFH_RXF_DMA_CFG, 0);
	/* Disable RX used and free queue operation. */
	iwm_write_prph(sc, IWM_RFH_RXF_RXQ_ACTIVE, 0);

	iwm_write_prph64(sc, IWM_RFH_Q0_FRBDCB_BA_LSB,
	    sc->rxq.free_desc_dma.paddr);
	iwm_write_prph64(sc, IWM_RFH_Q0_URBDCB_BA_LSB,
	    sc->rxq.used_desc_dma.paddr);
	iwm_write_prph64(sc, IWM_RFH_Q0_URBD_STTS_WPTR_LSB,
	    sc->rxq.stat_dma.paddr);
	iwm_write_prph(sc, IWM_RFH_Q0_FRBDCB_WIDX, 0);
	iwm_write_prph(sc, IWM_RFH_Q0_FRBDCB_RIDX, 0);
	iwm_write_prph(sc, IWM_RFH_Q0_URBDCB_WIDX, 0);

	/* We configure only queue 0 for now. */
	enabled = ((1 << 0) << 16) | (1 << 0);

	/* Enable RX DMA, 4KB buffer size. */
	iwm_write_prph(sc, IWM_RFH_RXF_DMA_CFG,
	    IWM_RFH_DMA_EN_ENABLE_VAL |
	    IWM_RFH_RXF_DMA_RB_SIZE_4K |
	    IWM_RFH_RXF_DMA_MIN_RB_4_8 |
	    IWM_RFH_RXF_DMA_DROP_TOO_LARGE_MASK |
	    IWM_RFH_RXF_DMA_RBDCB_SIZE_512);

	/* Enable RX DMA snooping. */
	iwm_write_prph(sc, IWM_RFH_GEN_CFG,
	    IWM_RFH_GEN_CFG_RFH_DMA_SNOOP |
	    IWM_RFH_GEN_CFG_SERVICE_DMA_SNOOP |
	    (sc->cfg->integrated ? IWM_RFH_GEN_CFG_RB_CHUNK_SIZE_64 :
	    IWM_RFH_GEN_CFG_RB_CHUNK_SIZE_128));

	/* Enable the configured queue(s). */
	iwm_write_prph(sc, IWM_RFH_RXF_RXQ_ACTIVE, enabled);

	iwm_nic_unlock(sc);

	IWM_WRITE_1(sc, IWM_CSR_INT_COALESCING, IWM_HOST_INT_TIMEOUT_DEF);

	IWM_WRITE(sc, IWM_RFH_Q0_FRBDCB_WIDX_TRG, 8);

	return (0);
}

static int
iwm_nic_rx_legacy_init(struct iwm_softc *sc)
{
	/*
	 * Initialize RX ring.  This is from the iwn driver.
	 */
	memset(sc->rxq.stat, 0, sizeof(*sc->rxq.stat));

	/* Stop Rx DMA */
	iwm_pcie_rx_stop(sc);


	/* Set physical address of RX ring (256-byte aligned). */
	IWM_WRITE(sc,
	    IWM_FH_RSCSR_CHNL0_RBDCB_BASE_REG,
	    sc->rxq.free_desc_dma.paddr >> 8);

	/* Set physical address of RX status (16-byte aligned). */
	IWM_WRITE(sc,

	if (sc->cfg->host_interrupt_operation_mode)
		IWM_SETBITS(sc, IWM_CSR_INT_COALESCING, IWM_HOST_INT_OPER_MODE);

	/*
	 * Thus sayeth el jefe (iwlwifi) via a comment:
	 *
	 * This value should initially be 0 (before preparing any
	 * RBs), should be 8 after preparing the first 8 RBs (for example)
	 */
	IWM_WRITE(sc, IWM_FH_RSCSR_CHNL0_WPTR, 8);

	iwm_nic_unlock(sc);

	IWM_WRITE(sc, IWM_FH_RSCSR_CHNL0_WPTR, 8);

	return 0;
}

static int
iwm_nic_rx_init(struct iwm_softc *sc)
{
	if (sc->cfg->mqrx_supported)
		return iwm_nic_rx_mq_init(sc);
	else
		return iwm_nic_rx_legacy_init(sc);
}

static int
iwm_nic_tx_init(struct iwm_softc *sc)
{

		    (unsigned long) (txq->desc_dma.paddr >> 8));
	}

	iwm_set_bits_prph(sc, IWM_SCD_GP_CTRL,
	    IWM_SCD_GP_CTRL_AUTO_ACTIVE_MODE |
	    IWM_SCD_GP_CTRL_ENABLE_31_QUEUES);

	iwm_nic_unlock(sc);


int
iwm_enable_txq(struct iwm_softc *sc, int sta_id, int qid, int fifo)
{
	int qmsk;

	qmsk = 1 << qid;

	if (!iwm_nic_lock(sc)) {
		device_printf(sc->sc_dev, "%s: cannot enable txq %d\n",
		    __func__, qid);
		    __func__,
		    qid);
		return EBUSY;
	}

	IWM_WRITE(sc, IWM_HBUS_TARG_WRPTR, qid << 8 | 0);

	if (qid == IWM_MVM_CMD_QUEUE) {
		/* Disable the scheduler. */
		iwm_write_prph(sc, IWM_SCD_EN_CTRL, 0);

		/* Stop the TX queue prior to configuration. */
		iwm_write_prph(sc, IWM_SCD_QUEUE_STATUS_BITS(qid),
		    (0 << IWM_SCD_QUEUE_STTS_REG_POS_ACTIVE) |
		    (1 << IWM_SCD_QUEUE_STTS_REG_POS_SCD_ACT_EN));

		iwm_nic_unlock(sc);

		/* Disable aggregations for this queue. */
		iwm_clear_bits_prph(sc, IWM_SCD_AGGR_SEL, qmsk);

		if (!iwm_nic_lock(sc)) {
			device_printf(sc->sc_dev,

		iwm_write_prph(sc, IWM_SCD_QUEUE_RDPTR(qid), 0);
		iwm_nic_unlock(sc);

		iwm_write_mem32(sc,
		    sc->scd_base_addr + IWM_SCD_CONTEXT_QUEUE_OFFSET(qid), 0);
		/* Set scheduler window size and frame limit. */
		iwm_write_mem32(sc,
		    sc->scd_base_addr + IWM_SCD_CONTEXT_QUEUE_OFFSET(qid) +

		    (fifo << IWM_SCD_QUEUE_STTS_REG_POS_TXF) |
		    (1 << IWM_SCD_QUEUE_STTS_REG_POS_WSL) |
		    IWM_SCD_QUEUE_STTS_REG_MSK);

		/* Enable the scheduler for this queue. */
		iwm_write_prph(sc, IWM_SCD_EN_CTRL, qmsk);
	} else {
		struct iwm_scd_txq_cfg_cmd cmd;
		int error;

			return EBUSY;
	}

	iwm_write_prph(sc, IWM_SCD_EN_CTRL,
	    iwm_read_prph(sc, IWM_SCD_EN_CTRL) | qid);

	iwm_nic_unlock(sc);

	IWM_DPRINTF(sc, IWM_DEBUG_XMIT, "%s: enabled txq %d FIFO %d\n",

	iwm_nic_unlock(sc);

	/* Enable L1-Active */
	if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000) {
		iwm_clear_bits_prph(sc, IWM_APMG_PCIDEV_STT_REG,
		    IWM_APMG_PCIDEV_STT_VAL_L1_ACT_DIS);
	}

iwm_get_sku(const struct iwm_softc *sc, const uint16_t *nvm_sw,
	    const uint16_t *phy_sku)
{
	if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000)
		return le16_to_cpup(nvm_sw + IWM_SKU);

	return le32_to_cpup((const uint32_t *)(phy_sku + IWM_SKU_8000));

static int
iwm_get_nvm_version(const struct iwm_softc *sc, const uint16_t *nvm_sw)
{
	if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000)
		return le16_to_cpup(nvm_sw + IWM_NVM_VERSION);
	else
		return le32_to_cpup((const uint32_t *)(nvm_sw +

iwm_get_radio_cfg(const struct iwm_softc *sc, const uint16_t *nvm_sw,
		  const uint16_t *phy_sku)
{
        if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000)
                return le16_to_cpup(nvm_sw + IWM_RADIO_CFG);

        return le32_to_cpup((const uint32_t *)(phy_sku + IWM_RADIO_CFG_8000));

{
	int n_hw_addr;

	if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000)
		return le16_to_cpup(nvm_sw + IWM_N_HW_ADDRS);

	n_hw_addr = le32_to_cpup((const uint32_t *)(nvm_sw + IWM_N_HW_ADDRS_8000));

iwm_set_radio_cfg(const struct iwm_softc *sc, struct iwm_nvm_data *data,
		  uint32_t radio_cfg)
{
	if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000) {
		data->radio_cfg_type = IWM_NVM_RF_CFG_TYPE_MSK(radio_cfg);
		data->radio_cfg_step = IWM_NVM_RF_CFG_STEP_MSK(radio_cfg);
		data->radio_cfg_dash = IWM_NVM_RF_CFG_DASH_MSK(radio_cfg);

		iwm_set_hw_address_from_csr(sc, data);
        } else
#endif
	if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000) {
		const uint8_t *hw_addr = (const uint8_t *)(nvm_hw + IWM_HW_ADDR);

		/* The byte order is little endian 16 bit, meaning 214365 */

	uint32_t sku, radio_cfg;
	uint16_t lar_config;

	if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000) {
		data = malloc(sizeof(*data) +
		    IWM_NUM_CHANNELS * sizeof(uint16_t),
		    M_DEVBUF, M_NOWAIT | M_ZERO);


	data->n_hw_addrs = iwm_get_n_hw_addrs(sc, nvm_sw);

	if (sc->cfg->device_family >= IWM_DEVICE_FAMILY_8000) {
		/* TODO: use IWL_NVM_EXT */
		uint16_t lar_offset = data->nvm_version < 0xE39 ?
				       IWM_NVM_LAR_OFFSET_8000_OLD :
				       IWM_NVM_LAR_OFFSET_8000;

			    "Can't parse empty OTP/NVM sections\n");
			return NULL;
		}
	} else if (sc->cfg->device_family >= IWM_DEVICE_FAMILY_8000) {
		/* SW and REGULATORY sections are mandatory */
		if (!sections[IWM_NVM_SECTION_TYPE_SW].data ||
		    !sections[IWM_NVM_SECTION_TYPE_REGULATORY].data) {

	IWM_WRITE(sc, IWM_CSR_UCODE_DRV_GP1_CLR, IWM_CSR_UCODE_SW_BIT_RFKILL);

	/* Load the given image to the HW */
	if (sc->cfg->device_family >= IWM_DEVICE_FAMILY_8000)
		ret = iwm_pcie_load_given_ucode_8000(sc, fw);
	else
		ret = iwm_pcie_load_given_ucode(sc, fw);

				      IWM_MVM_UCODE_ALIVE_TIMEOUT);
	IWM_LOCK(sc);
	if (error) {
		if (sc->cfg->device_family >= IWM_DEVICE_FAMILY_8000) {
			uint32_t a = 0x5a5a5a5a, b = 0x5a5a5a5a;
			if (iwm_nic_lock(sc)) {
				a = iwm_read_prph(sc, IWM_SB_CPU_1_STATUS);

		goto error;
	}

	if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000) {
		ret = iwm_send_bt_init_conf(sc);
		if (ret) {
			device_printf(sc->sc_dev,
			    "failed to send bt coex configuration: %d\n", ret);
			goto error;
		}
	}

	if (justnvm) {
		/* Read nvm */
		ret = iwm_nvm_init(sc);

		goto error;
	}

	ret = iwm_send_bt_init_conf(sc);
	if (ret) {
		device_printf(sc->sc_dev,
		    "failed to send bt coex configuration: %d\n", ret);
		goto error;
	}

	/* Send TX valid antennas before triggering calibrations */
	ret = iwm_send_tx_ant_cfg(sc, iwm_mvm_get_valid_tx_ant(sc));
	if (ret) {


	/* Update RX descriptor. */
	KASSERT((seg.ds_addr & 255) == 0, ("seg.ds_addr not aligned"));
	if (sc->cfg->mqrx_supported)
		((uint64_t *)ring->desc)[idx] =
		    htole64(seg.ds_addr | (idx + 1));
	else
		((uint32_t *)ring->desc)[idx] = htole32(seg.ds_addr >> 8);
	bus_dmamap_sync(ring->free_desc_dma.tag, ring->free_desc_dma.map,
	    BUS_DMASYNC_PREWRITE);

	return 0;
}

/* iwlwifi: mvm/rx.c */
/*
 * iwm_mvm_get_signal_strength - use new rx PHY INFO API
 * values are reported by the fw as positive values - need to negate
 * to obtain their dBM.  Account for missing antennas by replacing 0
 * values by -256dBm: practically 0 power and a non-feasible 8 bit value.
 */
static int
iwm_mvm_get_signal_strength(struct iwm_softc *sc, struct iwm_rx_phy_info *phy_info)
{
	int energy_a, energy_b, energy_c, max_energy;
	uint32_t val;

	val = le32toh(phy_info->non_cfg_phy[IWM_RX_INFO_ENERGY_ANT_ABC_IDX]);
	energy_a = (val & IWM_RX_INFO_ENERGY_ANT_A_MSK) >>
	    IWM_RX_INFO_ENERGY_ANT_A_POS;
	energy_a = energy_a ? -energy_a : -256;
	energy_b = (val & IWM_RX_INFO_ENERGY_ANT_B_MSK) >>
	    IWM_RX_INFO_ENERGY_ANT_B_POS;
	energy_b = energy_b ? -energy_b : -256;
	energy_c = (val & IWM_RX_INFO_ENERGY_ANT_C_MSK) >>
	    IWM_RX_INFO_ENERGY_ANT_C_POS;
	energy_c = energy_c ? -energy_c : -256;
	max_energy = MAX(energy_a, energy_b);
	max_energy = MAX(max_energy, energy_c);

	IWM_DPRINTF(sc, IWM_DEBUG_RECV,
	    "energy In A %d B %d C %d , and max %d\n",
	    energy_a, energy_b, energy_c, max_energy);

	return max_energy;
}

static void
iwm_mvm_rx_rx_phy_cmd(struct iwm_softc *sc, struct iwm_rx_packet *pkt)
{

	sc->sc_noise = iwm_get_noise(sc, &stats->rx.general);
}

/* iwlwifi: mvm/rx.c */
/*
 * iwm_mvm_get_signal_strength - use new rx PHY INFO API
 * values are reported by the fw as positive values - need to negate
 * to obtain their dBM.  Account for missing antennas by replacing 0
 * values by -256dBm: practically 0 power and a non-feasible 8 bit value.
 */
static int
iwm_mvm_rx_get_signal_strength(struct iwm_softc *sc,
    struct iwm_rx_phy_info *phy_info)
{
	int energy_a, energy_b, energy_c, max_energy;
	uint32_t val;

	val = le32toh(phy_info->non_cfg_phy[IWM_RX_INFO_ENERGY_ANT_ABC_IDX]);
	energy_a = (val & IWM_RX_INFO_ENERGY_ANT_A_MSK) >>
	    IWM_RX_INFO_ENERGY_ANT_A_POS;
	energy_a = energy_a ? -energy_a : -256;
	energy_b = (val & IWM_RX_INFO_ENERGY_ANT_B_MSK) >>
	    IWM_RX_INFO_ENERGY_ANT_B_POS;
	energy_b = energy_b ? -energy_b : -256;
	energy_c = (val & IWM_RX_INFO_ENERGY_ANT_C_MSK) >>
	    IWM_RX_INFO_ENERGY_ANT_C_POS;
	energy_c = energy_c ? -energy_c : -256;
	max_energy = MAX(energy_a, energy_b);
	max_energy = MAX(max_energy, energy_c);

	IWM_DPRINTF(sc, IWM_DEBUG_RECV,
	    "energy In A %d B %d C %d , and max %d\n",
	    energy_a, energy_b, energy_c, max_energy);

	return max_energy;
}

static int
iwm_mvm_rxmq_get_signal_strength(struct iwm_softc *sc,
    struct iwm_rx_mpdu_desc *desc)
{
	int energy_a, energy_b;

	energy_a = desc->v1.energy_a;
	energy_b = desc->v1.energy_b;
	energy_a = energy_a ? -energy_a : -256;
	energy_b = energy_b ? -energy_b : -256;
	return MAX(energy_a, energy_b);
}

/*
 * iwm_mvm_rx_rx_mpdu - IWM_REPLY_RX_MPDU_CMD handler
 *
 * Handles the actual data of the Rx packet from the fw
 */
static bool
iwm_mvm_rx_rx_mpdu(struct iwm_softc *sc, struct mbuf *m, uint32_t offset,
    bool stolen)
{
	struct ieee80211com *ic = &sc->sc_ic;
	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
	struct ieee80211_frame *wh;
	struct ieee80211_node *ni;
	struct ieee80211_rx_stats rxs;
	struct iwm_rx_phy_info *phy_info;
	struct iwm_rx_mpdu_res_start *rx_res;

		device_printf(sc->sc_dev,
		    "dsp size out of range [0,20]: %d\n",
		    phy_info->cfg_phy_cnt);
		return false;
	}

	if (!(rx_pkt_status & IWM_RX_MPDU_RES_STATUS_CRC_OK) ||
	    !(rx_pkt_status & IWM_RX_MPDU_RES_STATUS_OVERRUN_OK)) {
		IWM_DPRINTF(sc, IWM_DEBUG_RECV,
		    "Bad CRC or FIFO: 0x%08X.\n", rx_pkt_status);
		return false;
	}

	rssi = iwm_mvm_rx_get_signal_strength(sc, phy_info);

	/* Map it to relative value */
	rssi = rssi - sc->sc_noise;

	if (!stolen && iwm_rx_addbuf(sc, IWM_RBUF_SIZE, sc->rxq.cur) != 0) {
		device_printf(sc->sc_dev, "%s: unable to add more buffers\n",
		    __func__);
		return false;
	}

	m->m_data = pkt->data + sizeof(*rx_res);

	IWM_DPRINTF(sc, IWM_DEBUG_RECV,
	    "%s: rssi=%d, noise=%d\n", __func__, rssi, sc->sc_noise);

	ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh);

	IWM_DPRINTF(sc, IWM_DEBUG_RECV,
	    "%s: phy_info: channel=%d, flags=0x%08x\n",
	    __func__,

	/* rssi is in 1/2db units */
	rxs.c_rssi = rssi * 2;
	rxs.c_nf = sc->sc_noise;
	if (ieee80211_add_rx_params(m, &rxs) == 0)
		return false;
			ieee80211_free_node(ni);
		goto fail;
	}

	if (ieee80211_radiotap_active_vap(vap)) {
		struct iwm_rx_radiotap_header *tap = &sc->sc_rxtap;

		}
	}

	return true;
}

static bool
iwm_mvm_rx_mpdu_mq(struct iwm_softc *sc, struct mbuf *m, uint32_t offset,
    bool stolen)
{
	struct ieee80211com *ic = &sc->sc_ic;
	struct ieee80211vap *vap = TAILQ_FIRST(&ic->ic_vaps);
	struct ieee80211_frame *wh;
	struct ieee80211_rx_stats rxs;
	struct iwm_rx_mpdu_desc *desc;
	struct iwm_rx_packet *pkt;
	int rssi;
	uint32_t hdrlen, len, rate_n_flags;
	uint16_t phy_info;
	uint8_t channel;

	pkt = mtodo(m, offset);
	desc = (void *)pkt->data;

	if (!(desc->status & htole16(IWM_RX_MPDU_RES_STATUS_CRC_OK)) ||
	    !(desc->status & htole16(IWM_RX_MPDU_RES_STATUS_OVERRUN_OK))) {
		IWM_DPRINTF(sc, IWM_DEBUG_RECV,
		    "Bad CRC or FIFO: 0x%08X.\n", desc->status);
		return false;
	}

	channel = desc->v1.channel;
	len = le16toh(desc->mpdu_len);
	phy_info = le16toh(desc->phy_info);
	rate_n_flags = desc->v1.rate_n_flags;

	wh = mtodo(m, sizeof(*desc));
	m->m_data = pkt->data + sizeof(*desc);
	m->m_pkthdr.len = m->m_len = len;
	m->m_len = len;

	/* Account for padding following the frame header. */
	if ((desc->mac_flags2 & IWM_RX_MPDU_MFLG2_PAD)) {
		hdrlen = ieee80211_anyhdrsize(wh);
		memmove(mtodo(m, 2), mtodo(m, 0), hdrlen);
		m->m_data = mtodo(m, 2);
		wh = mtod(m, struct ieee80211_frame *);
	}

	/* Map it to relative value */
	rssi = iwm_mvm_rxmq_get_signal_strength(sc, desc);
	rssi = rssi - sc->sc_noise;

	/* replenish ring for the buffer we're going to feed to the sharks */
	if (!stolen && iwm_rx_addbuf(sc, IWM_RBUF_SIZE, sc->rxq.cur) != 0) {
		device_printf(sc->sc_dev, "%s: unable to add more buffers\n",
		    __func__);
		return false;
	}

	IWM_DPRINTF(sc, IWM_DEBUG_RECV,
	    "%s: rssi=%d, noise=%d\n", __func__, rssi, sc->sc_noise);

	/*
	 * Populate an RX state struct with the provided information.
	 */
	bzero(&rxs, sizeof(rxs));
	rxs.r_flags |= IEEE80211_R_IEEE | IEEE80211_R_FREQ;
	rxs.r_flags |= IEEE80211_R_NF | IEEE80211_R_RSSI;
	rxs.c_ieee = channel;
	rxs.c_freq = ieee80211_ieee2mhz(rxs.c_ieee,
	    channel <= 14 ? IEEE80211_CHAN_2GHZ : IEEE80211_CHAN_5GHZ);

	/* rssi is in 1/2db units */
	rxs.c_rssi = rssi * 2;
	rxs.c_nf = sc->sc_noise;
	if (ieee80211_add_rx_params(m, &rxs) == 0)
		return false;

	if (ieee80211_radiotap_active_vap(vap)) {
		struct iwm_rx_radiotap_header *tap = &sc->sc_rxtap;

		tap->wr_flags = 0;
		if ((phy_info & IWM_RX_MPDU_PHY_SHORT_PREAMBLE) != 0)
			tap->wr_flags |= IEEE80211_RADIOTAP_F_SHORTPRE;
		tap->wr_chan_freq = htole16(rxs.c_freq);
		/* XXX only if ic->ic_curchan->ic_ieee == rxs.c_ieee */
		tap->wr_chan_flags = htole16(ic->ic_curchan->ic_flags);
		tap->wr_dbm_antsignal = (int8_t)rssi;
		tap->wr_dbm_antnoise = (int8_t)sc->sc_noise;
		tap->wr_tsft = desc->v1.gp2_on_air_rise;
		switch ((rate_n_flags & 0xff)) {
		/* CCK rates. */
		case  10: tap->wr_rate =   2; break;
		case  20: tap->wr_rate =   4; break;
		case  55: tap->wr_rate =  11; break;
		case 110: tap->wr_rate =  22; break;
		/* OFDM rates. */
		case 0xd: tap->wr_rate =  12; break;
		case 0xf: tap->wr_rate =  18; break;
		case 0x5: tap->wr_rate =  24; break;
		case 0x7: tap->wr_rate =  36; break;
		case 0x9: tap->wr_rate =  48; break;
		case 0xb: tap->wr_rate =  72; break;
		case 0x1: tap->wr_rate =  96; break;
		case 0x3: tap->wr_rate = 108; break;
		/* Unknown rate: should not happen. */
		default:  tap->wr_rate =   0;
		}
	}

	return true;
}

static bool
iwm_mvm_rx_mpdu(struct iwm_softc *sc, struct mbuf *m, uint32_t offset,
    bool stolen)
{
	struct ieee80211com *ic;
	struct ieee80211_frame *wh;
	struct ieee80211_node *ni;
	bool ret;

	ic = &sc->sc_ic;

	ret = sc->cfg->mqrx_supported ?
	    iwm_mvm_rx_mpdu_mq(sc, m, offset, stolen) :
	    iwm_mvm_rx_rx_mpdu(sc, m, offset, stolen);
	if (!ret) {
		counter_u64_add(ic->ic_ierrors, 1);
		return (ret);
	}

	wh = mtod(m, struct ieee80211_frame *);
	ni = ieee80211_find_rxnode(ic, (struct ieee80211_frame_min *)wh);

	IWM_UNLOCK(sc);
	if (ni != NULL) {
		IWM_DPRINTF(sc, IWM_DEBUG_RECV, "input m %p\n", m);

	}
	IWM_LOCK(sc);

	return true;

fail:
	counter_u64_add(ic->ic_ierrors, 1);
	return FALSE;
}

static int

iwm_mvm_rx_tx_cmd(struct iwm_softc *sc, struct iwm_rx_packet *pkt)
{
	struct iwm_cmd_header *cmd_hdr = &pkt->hdr;
	struct iwm_tx_ring *ring;
	struct iwm_tx_data *txd;
	struct iwm_node *in;
	struct mbuf *m;
	int idx, qid, qmsk, status;

	idx = cmd_hdr->idx;
	qid = cmd_hdr->qid;
	qmsk = 1 << qid;

	ring = &sc->txq[qid];
	txd = &ring->data[idx];
	in = txd->in;
	m = txd->m;

	KASSERT(txd->done == 0, ("txd not done"));
	KASSERT(txd->in != NULL, ("txd without node"));


	ieee80211_tx_complete(&in->in_ni, m, status);

	if (--ring->queued < IWM_TX_RING_LOMARK && (sc->qfullmsk & qmsk) != 0) {
		sc->qfullmsk &= ~qmsk;
		if (sc->qfullmsk == 0)
			iwm_start(sc);
		}
	}
}


	    );

	/* XXX TODO: hard-coded TX antenna? */
	if (sc->cfg->device_family == IWM_DEVICE_FAMILY_9000)
		rate_flags = IWM_RATE_MCS_ANT_B_MSK;
	else
		rate_flags = IWM_RATE_MCS_ANT_A_MSK;
	if (IWM_RIDX_IS_CCK(ridx))
		rate_flags |= IWM_RATE_MCS_CCK_MSK;
	tx->rate_n_flags = htole32(rate_flags | rinfo->plcp);

	tid = 0;
	ring = &sc->txq[ac];
	desc = &ring->desc[ring->cur];
	memset(desc, 0, sizeof(*desc));
	data = &ring->data[ring->cur];

	/* Fill out iwm_tx_cmd to send to the firmware */

		ieee80211_radiotap_tx(vap, m);
	}


	totlen = m->m_pkthdr.len;

	flags = 0;
	totlen = m->m_pkthdr.len;
	if (!IEEE80211_IS_MULTICAST(wh->i_addr1)) {
		flags |= IWM_TX_CMD_FLG_ACK;
	}

	if (type == IEEE80211_FC0_TYPE_DATA &&
	    totlen + IEEE80211_CRC_LEN > vap->iv_rtsthreshold &&
	    !IEEE80211_IS_MULTICAST(wh->i_addr1)) {
		flags |= IWM_TX_CMD_FLG_PROT_REQUIRE;
	}

	tx->sta_id = IWM_STATION_ID;
	    type != IEEE80211_FC0_TYPE_DATA)
		tx->sta_id = sc->sc_aux_sta.sta_id;
	else
		tx->sta_id = IWM_STATION_ID;

	if (type == IEEE80211_FC0_TYPE_MGT) {
		uint8_t subtype = wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;

	if (hdrlen & 3) {
		/* First segment length must be a multiple of 4. */
		flags |= IWM_TX_CMD_FLG_MH_PAD;
		tx->offload_assist |= htole16(1 << IWM_TX_CMD_OFFLD_PAD);
		pad = 4 - (hdrlen & 3);
	} else {
		tx->offload_assist = 0;
		pad = 0;
	}
	tx->driver_txop = 0;
	tx->next_frame_len = 0;

	tx->len = htole16(totlen);
	tx->tid_tspec = tid;

	tx->dram_msb_ptr = iwm_get_dma_hi_addr(data->scratch_paddr);

	/* Copy 802.11 header in TX command. */
	memcpy((uint8_t *)tx + sizeof(*tx), wh, hdrlen);

	flags |= IWM_TX_CMD_FLG_BT_DIS | IWM_TX_CMD_FLG_SEQ_CTL;


	    );

	/* Fill TX descriptor. */
	memset(desc, 0, sizeof(*desc));
	desc->num_tbs = 2 + nsegs;

	desc->tbs[0].lo = htole32(data->cmd_paddr);
	desc->tbs[0].hi_n_len = htole16(iwm_get_dma_hi_addr(data->cmd_paddr) |
	    (TB0_SIZE << 4));
	desc->tbs[1].lo = htole32(data->cmd_paddr + TB0_SIZE);
	desc->tbs[1].hi_n_len = htole16(iwm_get_dma_hi_addr(data->cmd_paddr) |
	    ((sizeof(struct iwm_cmd_header) + sizeof(*tx) +
	    hdrlen + pad - TB0_SIZE) << 4));

	/* Other DMA segments are for data payload. */
	for (i = 0; i < nsegs; i++) {
		seg = &segs[i];
		desc->tbs[i + 2].lo = htole32(seg->ds_addr);
		desc->tbs[i + 2].hi_n_len =
		    htole16(iwm_get_dma_hi_addr(seg->ds_addr)) |
		    (seg->ds_len << 4);
	}

	bus_dmamap_sync(ring->data_dmat, data->map,

iwm_mvm_is_lar_supported(struct iwm_softc *sc)
{
	boolean_t nvm_lar = sc->nvm_data->lar_enabled;
	boolean_t tlv_lar = iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_LAR_SUPPORT);
					IWM_UCODE_TLV_CAPA_LAR_SUPPORT);

	if (iwm_lar_disable)
		return FALSE;

	 * Enable LAR only if it is supported by the FW (TLV) &&
	 * enabled in the NVM
	 */
	if (sc->cfg->device_family >= IWM_DEVICE_FAMILY_8000)
		return nvm_lar && tlv_lar;
	else
		return tlv_lar;

static boolean_t
iwm_mvm_is_wifi_mcc_supported(struct iwm_softc *sc)
{
	return iwm_fw_has_api(sc, IWM_UCODE_TLV_API_WIFI_MCC_UPDATE) ||
	    iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_LAR_MULTI_MCC);
	       fw_has_capa(&sc->sc_fw.ucode_capa,
			   IWM_UCODE_TLV_CAPA_LAR_MULTI_MCC);
}

static int

	int n_channels;
	uint16_t mcc;
#endif
	int resp_v2 = iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_LAR_SUPPORT_V2);
	    IWM_UCODE_TLV_CAPA_LAR_SUPPORT_V2);

	if (!iwm_mvm_is_lar_supported(sc)) {
		IWM_DPRINTF(sc, IWM_DEBUG_LAR, "%s: no LAR support\n",

	if ((error = iwm_send_update_mcc_cmd(sc, "ZZ")) != 0)
		goto error;

	if (iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_UMAC_SCAN)) {
		if ((error = iwm_mvm_config_umac_scan(sc)) != 0)
			goto error;
	}

			     nextpkt->hdr.idx == 0) ||
			    (nextpkt->len_n_flags ==
			     htole32(IWM_FH_RSCSR_FRAME_INVALID))) {
				if (iwm_mvm_rx_mpdu(sc, m, offset, stolen)) {
					stolen = FALSE;
					/* Make sure we abort the loop */
					nextoff = maxoff;

			/*
			 * Use m_copym instead of m_split, because that
			 * makes it easier to keep a valid rx buffer in
			 * the ring, when iwm_mvm_rx_mpdu() fails.
			 *
			 * We need to start m_copym() at offset 0, to get the
			 * M_PKTHDR flag preserved.
			 */
			m1 = m_copym(m, 0, M_COPYALL, M_NOWAIT);
			if (m1) {
				if (iwm_mvm_rx_mpdu(sc, m1, offset, stolen))
					stolen = TRUE;
				else
					m_freem(m1);

static void
iwm_notif_intr(struct iwm_softc *sc)
{
	int count;
	uint32_t wreg;
	uint16_t hw;

	bus_dmamap_sync(sc->rxq.stat_dma.tag, sc->rxq.stat_dma.map,
	    BUS_DMASYNC_POSTREAD);

	if (sc->cfg->mqrx_supported) {
		count = IWM_RX_MQ_RING_COUNT;
		wreg = IWM_RFH_Q0_FRBDCB_WIDX_TRG;
	} else {
		count = IWM_RX_LEGACY_RING_COUNT;
		wreg = IWM_FH_RSCSR_CHNL0_WPTR;
	}

	hw = le16toh(sc->rxq.stat->closed_rb_num) & 0xfff;

	/*

		    "%s: hw = %d cur = %d\n", __func__, hw, ring->cur);
		iwm_handle_rxb(sc, data->m);

		ring->cur = (ring->cur + 1) % count;
	}

	/*

	 * Seems like the hardware gets upset unless we align
	 * the write by 8??
	 */
	hw = (hw == 0) ? count - 1 : hw - 1;
	IWM_WRITE(sc, wreg, rounddown2(hw, 8));
}

static void

#define	PCI_PRODUCT_INTEL_WL_8260_1	0x24f3
#define	PCI_PRODUCT_INTEL_WL_8260_2	0x24f4
#define	PCI_PRODUCT_INTEL_WL_8265_1	0x24fd
#define	PCI_PRODUCT_INTEL_WL_9560_1	0x9df0
#define	PCI_PRODUCT_INTEL_WL_9260_1	0x2526

static const struct iwm_devices {
	uint16_t		device;

	{ PCI_PRODUCT_INTEL_WL_8260_1, &iwm8260_cfg },
	{ PCI_PRODUCT_INTEL_WL_8260_2, &iwm8260_cfg },
	{ PCI_PRODUCT_INTEL_WL_8265_1, &iwm8265_cfg },
	{ PCI_PRODUCT_INTEL_WL_9560_1, &iwm9560_cfg },
	{ PCI_PRODUCT_INTEL_WL_9260_1, &iwm9260_cfg },
};

static int

		    rman_get_rid(sc->sc_mem), sc->sc_mem);
}



static int
iwm_attach(device_t dev)
{


	sc->sc_dev = dev;
	sc->sc_attached = 1;
        sc->sc_debug = (sc->sc_debug | IWM_DEBUG_ANY);
	IWM_LOCK_INIT(sc);
	mbufq_init(&sc->sc_snd, ifqmaxlen);
	callout_init_mtx(&sc->sc_watchdog_to, &sc->sc_mtx, 0);
	callout_init_mtx(&sc->sc_led_blink_to, &sc->sc_mtx, 0);
	TASK_INIT(&sc->sc_es_task, 0, iwm_endscan_cb, sc);

	error = iwm_dev_check(dev);
	if (error != 0)
		goto fail;

	sc->sc_notif_wait = iwm_notification_wait_init(sc);
	if (sc->sc_notif_wait == NULL) {
		device_printf(dev, "failed to init notification wait struct\n");


	sc->sc_wantresp = -1;

	/* Match device id */
	error = iwm_dev_check(dev);
	if (error != 0)
		goto fail;

	sc->sc_hw_rev = IWM_READ(sc, IWM_CSR_HW_REV);
	/*
	 * In the 8000 HW family the format of the 4 bytes of CSR_HW_REV have

	 * "dash" value). To keep hw_rev backwards compatible - we'll store it
	 * in the old format.
	 */
	if (sc->cfg->device_family >= IWM_DEVICE_FAMILY_8000) {
		int ret;
		uint32_t hw_step;


		device_printf(sc->sc_dev,
		    "%s: Previous scan not completed yet\n", __func__);
	}
	if (iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_UMAC_SCAN))
		error = iwm_mvm_umac_scan(sc);
	else
		error = iwm_mvm_lmac_scan(sc);




/*-
 * Based on BSD-licensed source modules in the Linux iwlwifi driver,
 * which were used as the reference documentation for this implementation.
 *
 ******************************************************************************
 *
 * This file is provided under a dual BSD/GPLv2 license.  When using or
 * redistributing this file, you may do so under either license.
 *
 * GPL LICENSE SUMMARY
 *
 * Copyright(c) 2014 Intel Corporation. All rights reserved.
 * Copyright(c) 2014 - 2015 Intel Mobile Communications GmbH
 * Copyright(c) 2016 Intel Deutschland GmbH
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
 * USA
 *
 * The full GNU General Public License is included in this distribution
 * in the file called COPYING.
 *
 * Contact Information:
 *  Intel Linux Wireless <linuxwifi@intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
 * Copyright(c) 2014 Intel Corporation. All rights reserved.
 * Copyright(c) 2014 - 2015 Intel Mobile Communications GmbH
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * 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.
 *  * Neither the name Intel Corporation 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 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
 * OWNER 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>
__FBSDID("$FreeBSD$");

#include "opt_wlan.h"
#include "opt_iwm.h"

#include <sys/param.h>

#include "if_iwm_config.h"

#define IWM9000_FW	"iwm9000fw"

#define IWM_NVM_HW_SECTION_NUM_FAMILY_9000	10

#define IWM_DEVICE_9000_COMMON						\
	.device_family = IWM_DEVICE_FAMILY_9000,			\
	.eeprom_size = IWM_OTP_LOW_IMAGE_SIZE_FAMILY_9000,		\
	.nvm_hw_section_num = IWM_NVM_HW_SECTION_NUM_FAMILY_9000

const struct iwm_cfg iwm9560_cfg = {
	.name = "Intel(R) Dual Band Wireless AC 9560",
	.fw_name = IWM9000_FW,
	IWM_DEVICE_9000_COMMON,
	.host_interrupt_operation_mode = 0,
	.mqrx_supported = 1,
	.integrated = 1,
};




/*-
 * Based on BSD-licensed source modules in the Linux iwlwifi driver,
 * which were used as the reference documentation for this implementation.
 *
 ******************************************************************************
 *
 * This file is provided under a dual BSD/GPLv2 license.  When using or
 * redistributing this file, you may do so under either license.
 *
 * GPL LICENSE SUMMARY
 *
 * Copyright(c) 2014 Intel Corporation. All rights reserved.
 * Copyright(c) 2014 - 2015 Intel Mobile Communications GmbH
 * Copyright(c) 2016 Intel Deutschland GmbH
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
 * USA
 *
 * The full GNU General Public License is included in this distribution
 * in the file called COPYING.
 *
 * Contact Information:
 *  Intel Linux Wireless <linuxwifi@intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
 * Copyright(c) 2014 Intel Corporation. All rights reserved.
 * Copyright(c) 2014 - 2015 Intel Mobile Communications GmbH
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * 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.
 *  * Neither the name Intel Corporation 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 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
 * OWNER 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>
__FBSDID("$FreeBSD$");

#include "opt_wlan.h"
#include "opt_iwm.h"

#include <sys/param.h>

#include "if_iwm_config.h"

#define IWM9260_FW	"iwm9260fw"

#define IWM_NVM_HW_SECTION_NUM_FAMILY_9260	10

#define IWM_DEVICE_9260_COMMON						\
	.device_family = IWM_DEVICE_FAMILY_9000,			\
	.eeprom_size = IWM_OTP_LOW_IMAGE_SIZE_FAMILY_9000,		\
	.nvm_hw_section_num = IWM_NVM_HW_SECTION_NUM_FAMILY_9260

const struct iwm_cfg iwm9260_cfg = {
	.name = "Intel(R) Dual Band Wireless AC 9260",
	.fw_name = IWM9260_FW,
	IWM_DEVICE_9260_COMMON,
	.host_interrupt_operation_mode = 0,
	.mqrx_supported = 1,
};

Lines 78-83 enum iwm_device_family { Link Here

(-)b/sys/dev/iwm/if_iwm_config.h (-7 / +12 lines)
78	IWM_DEVICE_FAMILY_UNDEFINED,	78	IWM_DEVICE_FAMILY_UNDEFINED,
79	IWM_DEVICE_FAMILY_7000,	79	IWM_DEVICE_FAMILY_7000,
80	IWM_DEVICE_FAMILY_8000,	80	IWM_DEVICE_FAMILY_8000,
		81	IWM_DEVICE_FAMILY_9000,
81	};	82	};
82		83
83	#define IWM_DEFAULT_MAX_TX_POWER 22	84	#define IWM_DEFAULT_MAX_TX_POWER 22
Lines 130-142 enum iwm_nvm_type { Link Here
130	*/	131	*/
131	struct iwm_cfg {	132	struct iwm_cfg {
132	const char *name;	133	const char *name;
133	const char *fw_name;	134	const char *fw_name;
134	uint16_t eeprom_size;	135	uint16_t eeprom_size;
135	enum iwm_device_family device_family;	136	enum iwm_device_family device_family;
136	int host_interrupt_operation_mode;	137	int host_interrupt_operation_mode;
137	uint8_t nvm_hw_section_num;	138	int mqrx_supported;
138	int apmg_wake_up_wa;	139	int integrated;
139	enum iwm_nvm_type nvm_type;	140	uint8_t nvm_hw_section_num;
		141	int apmg_wake_up_wa;
		142	enum iwm_nvm_type nvm_type;
140	};	143	};
141		144
142	/*	145	/*
Lines 150-154 extern const struct iwm_cfg iwm7265_cfg; Link Here
150	extern const struct iwm_cfg iwm7265d_cfg;	153	extern const struct iwm_cfg iwm7265d_cfg;
151	extern const struct iwm_cfg iwm8260_cfg;	154	extern const struct iwm_cfg iwm8260_cfg;
152	extern const struct iwm_cfg iwm8265_cfg;	155	extern const struct iwm_cfg iwm8265_cfg;
		156	extern const struct iwm_cfg iwm9560_cfg;
		157	extern const struct iwm_cfg iwm9260_cfg;
153		158
154	#endif /* __IWM_CONFIG_H__ */	159	#endif /* __IWM_CONFIG_H__ */




	IWM_WRITE(sc, IWM_HBUS_TARG_PRPH_WDAT, val);
}

void
iwm_write_prph64(struct iwm_softc *sc, uint64_t addr, uint64_t val)
{
	iwm_write_prph(sc, (uint32_t)addr, val & 0xffffffff);
	iwm_write_prph(sc, (uint32_t)addr + 4, val >> 32);
}

int
iwm_poll_prph(struct iwm_softc *sc, uint32_t addr, uint32_t bits, uint32_t mask,
    int timeout)
{
	do {
		if ((iwm_read_prph(sc, addr) & mask) == (bits & mask))
			return (0);
		DELAY(10);
		timeout -= 10;
	} while (timeout > 0);

	return (ETIMEDOUT);
}

#ifdef IWM_DEBUG
/* iwlwifi: pcie/trans.c */
int

	IWM_SETBITS(sc, IWM_CSR_GP_CNTRL,
	    IWM_CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);

	if (sc->cfg->device_family >= IWM_DEVICE_FAMILY_8000)
		DELAY(2);

	if (iwm_poll_bit(sc, IWM_CSR_GP_CNTRL,

{
	sc->sc_intmask = IWM_CSR_INT_BIT_RF_KILL;
	IWM_WRITE(sc, IWM_CSR_INT_MASK, sc->sc_intmask);
	IWM_SETBITS(sc, IWM_CSR_GP_CNTRL,
	    IWM_CSR_GP_CNTRL_REG_FLAG_RFKILL_WAKE_L1A_EN);
}

int

	if (iwm_set_hw_ready(sc))
		goto out;

	IWM_SETBITS(sc, IWM_CSR_DBG_LINK_PWR_MGMT_REG,
	    IWM_CSR_RESET_LINK_PWR_MGMT_DISABLED);
	DELAY(1000);

	/* If HW is not ready, prepare the conditions to check again */
	IWM_SETBITS(sc, IWM_CSR_HW_IF_CONFIG_REG,

	IWM_DPRINTF(sc, IWM_DEBUG_RESET, "iwm apm start\n");

	/* Disable L0S exit timer (platform NMI Work/Around) */
	if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000) {
		IWM_SETBITS(sc, IWM_CSR_GIO_CHICKEN_BITS,
		    IWM_CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);
	}

void
iwm_apm_stop(struct iwm_softc *sc)
{
	IWM_SETBITS(sc, IWM_CSR_DBG_LINK_PWR_MGMT_REG,
	    IWM_CSR_RESET_LINK_PWR_MGMT_DISABLED);
	IWM_SETBITS(sc, IWM_CSR_HW_IF_CONFIG_REG,
	    IWM_CSR_HW_IF_CONFIG_REG_PREPARE |
	    IWM_CSR_HW_IF_CONFIG_REG_ENABLE_PME);
	DELAY(1000);
	IWM_CLRBITS(sc, IWM_CSR_DBG_LINK_PWR_MGMT_REG,
	    IWM_CSR_RESET_LINK_PWR_MGMT_DISABLED);
	DELAY(5000);

	/* stop device's busmaster DMA activity */
	IWM_SETBITS(sc, IWM_CSR_RESET, IWM_CSR_RESET_REG_FLAG_STOP_MASTER);


	    IWM_CSR_RESET_REG_FLAG_MASTER_DISABLED,
	    IWM_CSR_RESET_REG_FLAG_MASTER_DISABLED, 100))
		device_printf(sc->sc_dev, "timeout waiting for master\n");

	/*
	 * Clear "initialization complete" bit to move adapter from
	 * D0A* (powered-up Active) --> D0U* (Uninitialized) state.
	 */
	IWM_CLRBITS(sc, IWM_CSR_GP_CNTRL,
	    IWM_CSR_GP_CNTRL_REG_FLAG_INIT_DONE);

	IWM_DPRINTF(sc, IWM_DEBUG_TRANS, "%s: iwm apm stop\n", __func__);
}



	/* Reset the entire device */
	IWM_WRITE(sc, IWM_CSR_RESET, IWM_CSR_RESET_REG_FLAG_SW_RESET);
	DELAY(5000);

	if ((error = iwm_apm_init(sc)) != 0)
		return error;

	/* On newer chipsets MSI is disabled by default. */
	if (sc->cfg->mqrx_supported)
		iwm_write_prph(sc, IWM_UREG_CHICK, IWM_UREG_CHICK_MSI_ENABLE);

	iwm_enable_rfkill_int(sc);
	iwm_check_rfkill(sc);


int
iwm_pcie_rx_stop(struct iwm_softc *sc)
{
	int ret;

	ret = 0;
	if (iwm_nic_lock(sc)) {
		if (sc->cfg->mqrx_supported) {
			iwm_write_prph(sc, IWM_RFH_RXF_DMA_CFG, 0);
			ret = iwm_poll_prph(sc, IWM_RFH_GEN_STATUS,
			    IWM_RXF_DMA_IDLE, IWM_RXF_DMA_IDLE, 1000);
		} else {
			IWM_WRITE(sc, IWM_FH_MEM_RCSR_CHNL0_CONFIG_REG, 0);
			ret = iwm_poll_bit(sc, IWM_FH_MEM_RSSR_RX_STATUS_REG,
			    IWM_FH_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
			    IWM_FH_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
			    1000);
		}
		iwm_nic_unlock(sc);
	}
	return ret;

Lines 106-111 Link Here

(-)b/sys/dev/iwm/if_iwm_pcie_trans.h (+4 lines)
106		106
107	extern uint32_t iwm_read_prph(struct iwm_softc *sc, uint32_t addr);	107	extern uint32_t iwm_read_prph(struct iwm_softc *sc, uint32_t addr);
108	extern void iwm_write_prph(struct iwm_softc *sc, uint32_t addr, uint32_t val);	108	extern void iwm_write_prph(struct iwm_softc *sc, uint32_t addr, uint32_t val);
		109	extern void iwm_write_prph64(struct iwm_softc *sc, uint64_t addr,
		110	uint64_t val);
		111	extern int iwm_poll_prph(struct iwm_softc *sc, uint32_t addr, uint32_t bits,
		112	uint32_t mask, int timeout);
109	extern int iwm_read_mem(struct iwm_softc sc, uint32_t addr, void buf, int dwords);	113	extern int iwm_read_mem(struct iwm_softc sc, uint32_t addr, void buf, int dwords);
110	extern int iwm_write_mem(struct iwm_softc sc, uint32_t addr, const void buf,	114	extern int iwm_write_mem(struct iwm_softc sc, uint32_t addr, const void buf,
111	int dwords);	115	int dwords);




iwm_mvm_rrm_scan_needed(struct iwm_softc *sc)
{
	/* require rrm scan whenever the fw supports it */
	return iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT);
			   IWM_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT);
}

#ifdef IWM_DEBUG

	/* If this happens, the firmware has mistakenly sent an LMAC
	 * notification during UMAC scans -- warn and ignore it.
	 */
	if (iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_UMAC_SCAN)) {
		device_printf(sc->sc_dev,
		    "%s: Mistakenly got LMAC notification during UMAC scan\n",
		    __func__);

		sc->last_ebs_successful);
}

static int
iwm_mvm_scan_size(struct iwm_softc *sc)
{
	int base_size;

	if (iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_UMAC_SCAN)) {
		if (iwm_fw_has_api(sc, IWM_UCODE_TLV_API_ADAPTIVE_DWELL))
			base_size = IWM_SCAN_REQ_UMAC_SIZE_V7;
		else
			base_size = IWM_SCAN_REQ_UMAC_SIZE_V1;

		return base_size +
		    sizeof(struct iwm_scan_channel_cfg_umac) *
		    sc->sc_fw.ucode_capa.n_scan_channels +
		    sizeof(struct iwm_scan_req_umac_tail);
	} else {
		return sizeof(struct iwm_scan_req_lmac) +
		    sizeof(struct iwm_scan_channel_cfg_lmac) *
		    sc->sc_fw.ucode_capa.n_scan_channels +
		    sizeof(struct iwm_scan_probe_req);
	}
}

int
iwm_mvm_umac_scan(struct iwm_softc *sc)
{

	struct iwm_scan_req_umac *req;
	struct iwm_scan_req_umac_tail *tail;
	size_t req_len;
	uint16_t general_flags;
	uint8_t channel_flags, i, nssid;
	int ret;

	req_len = iwm_mvm_scan_size(sc);
	    (sizeof(struct iwm_scan_channel_cfg_umac) *
	    sc->sc_fw.ucode_capa.n_scan_channels) +
	    sizeof(struct iwm_scan_req_umac_tail);
	if (req_len > IWM_MAX_CMD_PAYLOAD_SIZE)
		return ENOMEM;
	req = malloc(req_len, M_DEVBUF, M_NOWAIT | M_ZERO);


	IWM_DPRINTF(sc, IWM_DEBUG_SCAN, "Handling ieee80211 scan request\n");

	nssid = MIN(ss->ss_nssid, IWM_PROBE_OPTION_MAX);
	req->active_dwell = 10;
	req->passive_dwell = 110;
	req->fragmented_dwell = 44;
	req->extended_dwell = 90;
	req->max_out_time = 0;
	req->suspend_time = 0;

	general_flags = IWM_UMAC_SCAN_GEN_FLAGS_PASS_ALL |
	    IWM_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE;
	if (!iwm_fw_has_api(sc, IWM_UCODE_TLV_API_ADAPTIVE_DWELL))
		general_flags |= IWM_UMAC_SCAN_GEN_FLAGS_EXTENDED_DWELL;
	if (iwm_mvm_rrm_scan_needed(sc))
		general_flags |= IWM_UMAC_SCAN_GEN_FLAGS_RRM_ENABLED;
	if (nssid != 0)
		general_flags |= IWM_UMAC_SCAN_GEN_FLAGS_PRE_CONNECT;
	else
		general_flags |= IWM_UMAC_SCAN_GEN_FLAGS_PASSIVE;

	channel_flags = 0;
	if (iwm_mvm_scan_use_ebs(sc))
		channel_flags = IWM_SCAN_CHANNEL_FLAG_EBS |
		    IWM_SCAN_CHANNEL_FLAG_EBS_ACCURATE |
		    IWM_SCAN_CHANNEL_FLAG_CACHE_ADD;

	req->general_flags = htole16(general_flags);
	req->ooc_priority = htole32(IWM_SCAN_PRIORITY_HIGH);
	    IWM_UMAC_SCAN_GEN_FLAGS_EXTENDED_DWELL);

	/* These timings correspond to iwlwifi's UNASSOC scan. */
	if (iwm_fw_has_api(sc, IWM_UCODE_TLV_API_ADAPTIVE_DWELL)) {
		req->v7.active_dwell = 10;
		req->v7.passive_dwell = 110;
		req->v7.fragmented_dwell = 44;
		req->v7.adwell_default_n_aps_social = 10;
		req->v7.adwell_default_n_aps = 2;
		req->v7.adwell_max_budget = htole16(300);
		req->v7.scan_priority = htole32(IWM_SCAN_PRIORITY_HIGH);
		req->v7.channel.flags = channel_flags;
		req->v7.channel.count = iwm_mvm_umac_scan_fill_channels(sc,
		    (struct iwm_scan_channel_cfg_umac *)req->v7.data, nssid);

		tail = (void *)((char *)&req->v7.data +
		    sizeof(struct iwm_scan_channel_cfg_umac) *
		    sc->sc_fw.ucode_capa.n_scan_channels);
	} else {
		req->v1.active_dwell = 10;
		req->v1.passive_dwell = 110;
		req->v1.fragmented_dwell = 44;
		req->v1.extended_dwell = 90;
		req->v1.scan_priority = htole32(IWM_SCAN_PRIORITY_HIGH);
		req->v1.channel.flags = channel_flags;
		req->v1.channel.count = iwm_mvm_umac_scan_fill_channels(sc,
		    (struct iwm_scan_channel_cfg_umac *)req->v1.data, nssid);

		tail = (void *)((char *)&req->v1.data +
		    sizeof(struct iwm_scan_channel_cfg_umac) *
		    sc->sc_fw.ucode_capa.n_scan_channels);
	}

	/* Check if we're doing an active directed scan. */
	for (i = 0; i < nssid; i++) {

		    tail->direct_scan[i].len);
		/* XXX debug */
	}
	if (nssid != 0) {
		req->general_flags |=
		    htole32(IWM_UMAC_SCAN_GEN_FLAGS_PRE_CONNECT);
	} else
		req->general_flags |= htole32(IWM_UMAC_SCAN_GEN_FLAGS_PASSIVE);

	if (iwm_mvm_scan_use_ebs(sc))
		req->channel_flags = IWM_SCAN_CHANNEL_FLAG_EBS |
				     IWM_SCAN_CHANNEL_FLAG_EBS_ACCURATE |
				     IWM_SCAN_CHANNEL_FLAG_CACHE_ADD;

	if (iwm_mvm_rrm_scan_needed(sc))
		req->general_flags |=
		    htole32(IWM_UMAC_SCAN_GEN_FLAGS_RRM_ENABLED);

	ret = iwm_mvm_fill_probe_req(sc, &tail->preq);
	if (ret) {

	IWM_DPRINTF(sc, IWM_DEBUG_SCAN,
	    "Handling ieee80211 scan request\n");

	req_len = iwm_mvm_scan_size(sc);
	    (sizeof(struct iwm_scan_channel_cfg_lmac) *
	    sc->sc_fw.ucode_capa.n_scan_channels) + sizeof(struct iwm_scan_probe_req);
	if (req_len > IWM_MAX_CMD_PAYLOAD_SIZE)
		return ENOMEM;
	req = malloc(req_len, M_DEVBUF, M_NOWAIT | M_ZERO);


	IWM_DPRINTF(sc, IWM_DEBUG_SCAN, "Preparing to stop scan\n");

	if (iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_UMAC_SCAN))
		ret = iwm_mvm_umac_scan_abort(sc);
	else
		ret = iwm_mvm_lmac_scan_abort(sc);




static inline int
iwm_mvm_add_sta_cmd_size(struct iwm_softc *sc)
{
	return sc->cfg->mqrx_supported ? sizeof(struct iwm_mvm_add_sta_cmd) :
	    sizeof(struct iwm_mvm_add_sta_cmd_v7);
		sizeof(struct iwm_mvm_add_sta_cmd) :
		sizeof(struct iwm_mvm_add_sta_cmd_v7);
#else
	return sizeof(struct iwm_mvm_add_sta_cmd);
#endif
}

/* send station add/update command to firmware */


static int
iwm_mvm_add_int_sta_common(struct iwm_softc *sc, struct iwm_int_sta *sta,
    const uint8_t *addr, uint16_t mac_id, uint16_t color)
{
	struct iwm_mvm_add_sta_cmd cmd;
	int ret;

	memset(&cmd, 0, sizeof(cmd));
	cmd.sta_id = sta->sta_id;
	cmd.mac_id_n_color = htole32(IWM_FW_CMD_ID_AND_COLOR(mac_id, color));
	if (sta->sta_id == IWM_AUX_STA_ID && sc->cfg->mqrx_supported)
		cmd.station_type = IWM_STA_AUX_ACTIVITY;

	cmd.tfd_queue_msk = htole32(sta->tfd_queue_msk);
	cmd.tid_disable_tx = htole16(0xffff);

	sc->sc_aux_sta.tfd_queue_msk = (1 << IWM_MVM_AUX_QUEUE);

	/* Map Aux queue to fifo - needs to happen before adding Aux station */
	ret = iwm_enable_txq(sc, IWM_AUX_STA_ID, IWM_MVM_AUX_QUEUE,
	    IWM_MVM_TX_FIFO_MCAST);
	if (ret)
		return ret;


Lines 289-295 Link Here

(-)b/sys/dev/iwm/if_iwmreg.h (-49 / +384 lines)
289	#define IWM_CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN (0x00000001)	289	#define IWM_CSR_GP_CNTRL_REG_VAL_MAC_ACCESS_EN (0x00000001)
290		290
291	#define IWM_CSR_GP_CNTRL_REG_MSK_POWER_SAVE_TYPE (0x07000000)	291	#define IWM_CSR_GP_CNTRL_REG_MSK_POWER_SAVE_TYPE (0x07000000)
292	#define IWM_CSR_GP_CNTRL_REG_FLAG_MAC_POWER_SAVE (0x04000000)	292	#define IWM_CSR_GP_CNTRL_REG_FLAG_RFKILL_WAKE_L1A_EN (0x04000000)
293	#define IWM_CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW (0x08000000)	293	#define IWM_CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW (0x08000000)
294		294
295		295
Lines 457-462 enum iwm_secure_boot_status_reg { Link Here
457	#define IWM_LMPM_CHICK 0xa01ff8	457	#define IWM_LMPM_CHICK 0xa01ff8
458	#define IWM_LMPM_CHICK_EXTENDED_ADDR_SPACE 0x01	458	#define IWM_LMPM_CHICK_EXTENDED_ADDR_SPACE 0x01
459		459
		460	#define IWM_UREG_CHICK 0xa05c00
		461	#define IWM_UREG_CHICK_MSI_ENABLE 0x01000000
		462	#define IWM_UREG_CHICK_MSIX_ENABLE 0x02000000
		463
460	#define IWM_FH_TCSR_0_REG0 (0x1D00)	464	#define IWM_FH_TCSR_0_REG0 (0x1D00)
461		465
462	/*	466	/*
Lines 635-640 P2P_PS_SCM\31UAPSD_SUPPORT\32EBS\33P2P_PS_UAPSD\36BCAST_FILTERING\37GO_UAPSD\40L Link Here
635	* longer than the passive one, which is essential for fragmented scan.	639	* longer than the passive one, which is essential for fragmented scan.
636	* @IWM_UCODE_TLV_API_WIFI_MCC_UPDATE: ucode supports MCC updates with source.	640	* @IWM_UCODE_TLV_API_WIFI_MCC_UPDATE: ucode supports MCC updates with source.
637	* @IWM_UCODE_TLV_API_LQ_SS_PARAMS: Configure STBC/BFER via LQ CMD ss_params	641	* @IWM_UCODE_TLV_API_LQ_SS_PARAMS: Configure STBC/BFER via LQ CMD ss_params
		642	* @IWM_UCODE_TLV_API_NEW_VERSION: new versioning format
		643	* @IWM_UCODE_TLV_API_SCAN_TSF_REPORT: Scan start time reported in scan
		644	* iteration complete notification, and the timestamp reported for RX
		645	* received during scan, are reported in TSF of the mac specified in the
		646	* scan request.
		647	* @IWM_UCODE_TLV_API_TKIP_MIC_KEYS: This ucode supports version 2 of
		648	* ADD_MODIFY_STA_KEY_API_S_VER_2.
		649	* @IWM_UCODE_TLV_API_STA_TYPE: This ucode supports station type assignement.
		650	* @IWM_UCODE_TLV_API_NAN2_VER2: This ucode supports NAN API version 2
		651	* @IWM_UCODE_TLV_API_NEW_RX_STATS: should new RX STATISTICS API be used
		652	* @IWM_UCODE_TLV_API_QUOTA_LOW_LATENCY: Quota command includes a field
		653	* indicating low latency direction.
		654	* @IWM_UCODE_TLV_API_DEPRECATE_TTAK: RX status flag TTAK ok (bit 7) is
		655	* deprecated.
		656	* @IWM_UCODE_TLV_API_ADAPTIVE_DWELL_V2: This ucode supports version 8
		657	* of scan request: SCAN_REQUEST_CMD_UMAC_API_S_VER_8
		658	* @IWM_UCODE_TLV_API_FRAG_EBS: This ucode supports fragmented EBS
		659	* @IWM_UCODE_TLV_API_REDUCE_TX_POWER: This ucode supports v5 of
		660	* the REDUCE_TX_POWER_CMD.
		661	* @IWM_UCODE_TLV_API_SHORT_BEACON_NOTIF: This ucode supports the short
		662	* version of the beacon notification.
		663	* @IWM_UCODE_TLV_API_BEACON_FILTER_V4: This ucode supports v4 of
		664	* BEACON_FILTER_CONFIG_API_S_VER_4.
		665	* @IWM_UCODE_TLV_API_REGULATORY_NVM_INFO: This ucode supports v4 of
		666	* REGULATORY_NVM_GET_INFO_RSP_API_S.
		667	* @IWM_UCODE_TLV_API_FTM_NEW_RANGE_REQ: This ucode supports v7 of
		668	* LOCATION_RANGE_REQ_CMD_API_S and v6 of LOCATION_RANGE_RESP_NTFY_API_S.
		669	* @IWM_UCODE_TLV_API_SCAN_OFFLOAD_CHANS: This ucode supports v2 of
		670	* SCAN_OFFLOAD_PROFILE_MATCH_RESULTS_S and v3 of
		671	* SCAN_OFFLOAD_PROFILES_QUERY_RSP_S.
		672	* @IWM_UCODE_TLV_API_MBSSID_HE: This ucode supports v2 of
		673	* STA_CONTEXT_DOT11AX_API_S
		674	* @IWM_UCODE_TLV_CAPA_SAR_TABLE_VER: This ucode supports different sar
		675	* version tables.
638	*	676	*
639	* @IWM_NUM_UCODE_TLV_API: number of bits used	677	* @IWM_NUM_UCODE_TLV_API: number of bits used
640	*/	678	*/
Lines 642-654 enum iwm_ucode_tlv_api { Link Here
642	IWM_UCODE_TLV_API_FRAGMENTED_SCAN = 8,	680	IWM_UCODE_TLV_API_FRAGMENTED_SCAN = 8,
643	IWM_UCODE_TLV_API_WIFI_MCC_UPDATE = 9,	681	IWM_UCODE_TLV_API_WIFI_MCC_UPDATE = 9,
644	IWM_UCODE_TLV_API_LQ_SS_PARAMS = 18,	682	IWM_UCODE_TLV_API_LQ_SS_PARAMS = 18,
645		683	IWM_UCODE_TLV_API_NEW_VERSION = 20,
646	IWM_NUM_UCODE_TLV_API = 32	684	IWM_UCODE_TLV_API_SCAN_TSF_REPORT = 28,
		685	IWM_UCODE_TLV_API_TKIP_MIC_KEYS = 29,
		686	IWM_UCODE_TLV_API_STA_TYPE = 30,
		687	IWM_UCODE_TLV_API_NAN2_VER2 = 31,
		688	IWM_UCODE_TLV_API_ADAPTIVE_DWELL = 32,
		689	IWM_UCODE_TLV_API_OCE = 33,
		690	IWM_UCODE_TLV_API_NEW_BEACON_TEMPLATE = 34,
		691	IWM_UCODE_TLV_API_NEW_RX_STATS = 35,
		692	IWM_UCODE_TLV_API_WOWLAN_KEY_MATERIAL = 36,
		693	IWM_UCODE_TLV_API_QUOTA_LOW_LATENCY = 38,
		694	IWM_UCODE_TLV_API_DEPRECATE_TTAK = 41,
		695	IWM_UCODE_TLV_API_ADAPTIVE_DWELL_V2 = 42,
		696	IWM_UCODE_TLV_API_FRAG_EBS = 44,
		697	IWM_UCODE_TLV_API_REDUCE_TX_POWER = 45,
		698	IWM_UCODE_TLV_API_SHORT_BEACON_NOTIF = 46,
		699	IWM_UCODE_TLV_API_BEACON_FILTER_V4 = 47,
		700	IWM_UCODE_TLV_API_REGULATORY_NVM_INFO = 48,
		701	IWM_UCODE_TLV_API_FTM_NEW_RANGE_REQ = 49,
		702	IWM_UCODE_TLV_API_SCAN_OFFLOAD_CHANS = 50,
		703	IWM_UCODE_TLV_API_MBSSID_HE = 52,
		704	IWM_UCODE_TLV_API_WOWLAN_TCP_SYN_WAKE = 53,
		705	IWM_UCODE_TLV_API_FTM_RTT_ACCURACY = 54,
		706	IWM_UCODE_TLV_API_SAR_TABLE_VER = 55,
		707	IWM_UCODE_TLV_API_ADWELL_HB_DEF_N_AP = 57,
		708	IWM_UCODE_TLV_API_SCAN_EXT_CHAN_VER = 58,
		709
		710	IWM_NUM_UCODE_TLV_API = 128,
647	};	711	};
648		712
649	#define IWM_UCODE_TLV_API_BITS \
650	"\020\10FRAGMENTED_SCAN\11WIFI_MCC_UPDATE\16WIDE_CMD_HDR\22LQ_SS_PARAMS\30EXT_SCAN_PRIO\33TX_POWER_CHAIN"
651
652	/**	713	/**
653	* enum iwm_ucode_tlv_capa - ucode capabilities	714	* enum iwm_ucode_tlv_capa - ucode capabilities
654	* @IWM_UCODE_TLV_CAPA_D0I3_SUPPORT: supports D0i3	715	* @IWM_UCODE_TLV_CAPA_D0I3_SUPPORT: supports D0i3
Lines 933-938 enum iwm_ucode_tlv_type { Link Here
933	IWM_UCODE_TLV_FW_DBG_DEST = 38,	994	IWM_UCODE_TLV_FW_DBG_DEST = 38,
934	IWM_UCODE_TLV_FW_DBG_CONF = 39,	995	IWM_UCODE_TLV_FW_DBG_CONF = 39,
935	IWM_UCODE_TLV_FW_DBG_TRIGGER = 40,	996	IWM_UCODE_TLV_FW_DBG_TRIGGER = 40,
		997	IWM_UCODE_TLV_CMD_VERSIONS = 48,
936	IWM_UCODE_TLV_FW_GSCAN_CAPA = 50,	998	IWM_UCODE_TLV_FW_GSCAN_CAPA = 50,
937	IWM_UCODE_TLV_FW_MEM_SEG = 51,	999	IWM_UCODE_TLV_FW_MEM_SEG = 51,
938	};	1000	};
Lines 1469-1474 static inline unsigned int IWM_FH_MEM_CBBC_QUEUE(unsigned int chnl) Link Here
1469		1531
1470	#define IWM_FH_MEM_TFDIB_REG1_ADDR_BITSHIFT 28	1532	#define IWM_FH_MEM_TFDIB_REG1_ADDR_BITSHIFT 28
1471		1533
		1534	/* 9000 rx series registers */
		1535
		1536	#define IWM_RFH_Q0_FRBDCB_BA_LSB 0xa08000
		1537	#define IWM_RFH_Q_FRBDCB_BA_LSB (IWM_RFH_Q0_FRBDCB_BA_LSB + (q) * 8)
		1538	/* Write index table */
		1539	#define IWM_RFH_Q0_FRBDCB_WIDX 0xa08080
		1540	#define IWM_RFH_Q_FRBDCB_WIDX (IWM_RFH_Q0_FRBDCB_WIDX + (q) * 4)
		1541	/* Write index table - shadow registers */
		1542	#define IWM_RFH_Q0_FRBDCB_WIDX_TRG 0x1c80
		1543	#define IWM_RFH_Q_FRBDCB_WIDX_TRG (IWM_RFH_Q0_FRBDCB_WIDX_TRG + (q) * 4)
		1544	/* Read index table */
		1545	#define IWM_RFH_Q0_FRBDCB_RIDX 0xa080c0
		1546	#define IWM_RFH_Q_FRBDCB_RIDX (IWM_RFH_Q0_FRBDCB_RIDX + (q) * 4)
		1547	/* Used list table */
		1548	#define IWM_RFH_Q0_URBDCB_BA_LSB 0xa08100
		1549	#define IWM_RFH_Q_URBDCB_BA_LSB (IWM_RFH_Q0_URBDCB_BA_LSB + (q) * 8)
		1550	/* Write index table */
		1551	#define IWM_RFH_Q0_URBDCB_WIDX 0xa08180
		1552	#define IWM_RFH_Q_URBDCB_WIDX (IWM_RFH_Q0_URBDCB_WIDX + (q) * 4)
		1553	/* stts */
		1554	#define IWM_RFH_Q0_URBD_STTS_WPTR_LSB 0xa08200
		1555	#define IWM_RFH_Q_URBD_STTS_WPTR_LSB (IWM_RFH_Q0_URBD_STTS_WPTR_LSB + (q) * 8)
		1556
		1557	#define IWM_RFH_GEN_STATUS 0xa09808
		1558	#define IWM_RXF_DMA_IDLE 0x80000000
		1559
		1560	/* DMA configuration */
		1561	#define IWM_RFH_RXF_DMA_CFG 0xa09820
		1562	#define IWM_RFH_RXF_DMA_RB_SIZE_1K 0x00010000
		1563	#define IWM_RFH_RXF_DMA_RB_SIZE_2K 0x00020000
		1564	#define IWM_RFH_RXF_DMA_RB_SIZE_4K 0x00040000
		1565	#define IWM_RFH_RXF_DMA_RBDCB_SIZE_512 0x00900000
		1566	#define IWM_RFH_RXF_DMA_MIN_RB_4_8 0x03000000
		1567	#define IWM_RFH_RXF_DMA_DROP_TOO_LARGE_MASK 0x04000000
		1568	#define IWM_RFH_DMA_EN_ENABLE_VAL 0x80000000
		1569
		1570	#define IWM_RFH_GEN_CFG 0xa09800
		1571	#define IWM_RFH_GEN_CFG_SERVICE_DMA_SNOOP 0x00000001
		1572	#define IWM_RFH_GEN_CFG_RFH_DMA_SNOOP 0x00000002
		1573	#define IWM_RFH_GEN_CFG_RB_CHUNK_SIZE_128 0x00000010
		1574	#define IWM_RFH_GEN_CFG_RB_CHUNK_SIZE_64 0x00000000
		1575
		1576	#define IWM_RFH_RXF_RXQ_ACTIVE 0xa0980c
		1577
		1578	/* end of 9000 rx series registers */
		1579
1472	/* TFDB Area - TFDs buffer table */	1580	/* TFDB Area - TFDs buffer table */
1473	#define IWM_FH_MEM_TFDIB_DRAM_ADDR_LSB_MSK (0xFFFFFFFF)	1581	#define IWM_FH_MEM_TFDIB_DRAM_ADDR_LSB_MSK (0xFFFFFFFF)
1474	#define IWM_FH_TFDIB_LOWER_BOUND (IWM_FH_MEM_LOWER_BOUND + 0x900)	1582	#define IWM_FH_TFDIB_LOWER_BOUND (IWM_FH_MEM_LOWER_BOUND + 0x900)
Lines 2799-2804 enum iwm_mvm_rx_status { Link Here
2799	IWM_RX_MPDU_RES_STATUS2_FILTERING_MSK = (0xc0000000),	2907	IWM_RX_MPDU_RES_STATUS2_FILTERING_MSK = (0xc0000000),
2800	};	2908	};
2801		2909
		2910	enum iwm_rx_mpdu_mac_flags1 {
		2911	IWM_RX_MPDU_MFLG1_ADDRTYPE_MASK = 0x03,
		2912	IWM_RX_MPDU_MFLG1_MIC_CRC_LEN_MASK = 0xf0,
		2913	IWM_RX_MPDU_MFLG1_MIC_CRC_LEN_SHIFT = 3,
		2914	};
		2915
		2916	enum iwm_rx_mpdu_mac_flags2 {
		2917	IWM_RX_MPDU_MFLG2_HDR_LEN_MASK = 0x1f,
		2918	IWM_RX_MPDU_MFLG2_PAD = 0x20,
		2919	IWM_RX_MPDU_MFLG2_AMSDU = 0x40,
		2920	};
		2921
		2922	enum iwm_rx_mpdu_phy_info {
		2923	IWM_RX_MPDU_PHY_AMPDU = (1 << 5),
		2924	IWM_RX_MPDU_PHY_AMPDU_TOGGLE = (1 << 6),
		2925	IWM_RX_MPDU_PHY_SHORT_PREAMBLE = (1 << 7),
		2926	IWM_RX_MPDU_PHY_NCCK_ADDTL_NTFY = (1 << 7),
		2927	IWM_RX_MPDU_PHY_TSF_OVERLOAD = (1 << 8),
		2928	};
		2929
		2930	struct iwm_rx_mpdu_desc_v1 {
		2931	union {
		2932	uint32_t rss_hash;
		2933	uint32_t phy_data2;
		2934	};
		2935	union {
		2936	uint32_t filter_match;
		2937	uint32_t phy_data3;
		2938	};
		2939	uint32_t rate_n_flags;
		2940	uint8_t energy_a;
		2941	uint8_t energy_b;
		2942	uint8_t channel;
		2943	uint8_t mac_context;
		2944	uint32_t gp2_on_air_rise;
		2945	union {
		2946	uint64_t tsf_on_air_rise;
		2947	struct {
		2948	uint32_t phy_data0;
		2949	uint32_t phy_data1;
		2950	};
		2951	};
		2952	} __packed;
		2953
		2954	struct iwm_rx_mpdu_desc {
		2955	uint16_t mpdu_len;
		2956	uint8_t mac_flags1;
		2957	uint8_t mac_flags2;
		2958	uint8_t amsdu_info;
		2959	uint16_t phy_info;
		2960	uint8_t mac_phy_idx;
		2961	uint16_t raw_csum;
		2962	union {
		2963	uint16_t l3l4_flags;
		2964	uint16_t phy_data4;
		2965	};
		2966	uint16_t status;
		2967	uint8_t hash_filter;
		2968	uint8_t sta_id_flags;
		2969	uint32_t reorder_data;
		2970	struct iwm_rx_mpdu_desc_v1 v1;
		2971	} __packed;
		2972
2802	/**	2973	/**
2803	* struct iwm_radio_version_notif - information on the radio version	2974	* struct iwm_radio_version_notif - information on the radio version
2804	* ( IWM_RADIO_VERSION_NOTIFICATION = 0x68 )	2975	* ( IWM_RADIO_VERSION_NOTIFICATION = 0x68 )
Lines 4306-4318 enum iwm_tx_pm_timeouts { Link Here
4306	#define IWM_BAR_DFAULT_RETRY_LIMIT 60	4477	#define IWM_BAR_DFAULT_RETRY_LIMIT 60
4307	#define IWM_LOW_RETRY_LIMIT 7	4478	#define IWM_LOW_RETRY_LIMIT 7
4308		4479
		4480	/**
		4481	* enum iwm_tx_offload_assist_flags_pos - set %iwm_tx_cmd offload_assist values
		4482	* @IWM_TX_CMD_OFFLD_IP_HDR: offset to start of IP header (in words)
		4483	* from mac header end. For normal case it is 4 words for SNAP.
		4484	* note: tx_cmd, mac header and pad are not counted in the offset.
		4485	* This is used to help the offload in case there is tunneling such as
		4486	* IPv6 in IPv4, in such case the ip header offset should point to the
		4487	* inner ip header and IPv4 checksum of the external header should be
		4488	* calculated by driver.
		4489	* @IWM_TX_CMD_OFFLD_L4_EN: enable TCP/UDP checksum
		4490	* @IWM_TX_CMD_OFFLD_L3_EN: enable IP header checksum
		4491	* @IWM_TX_CMD_OFFLD_MH_SIZE: size of the mac header in words. Includes the IV
		4492	* field. Doesn't include the pad.
		4493	* @IWM_TX_CMD_OFFLD_PAD: mark 2-byte pad was inserted after the mac header for
		4494	* alignment
		4495	* @IWM_TX_CMD_OFFLD_AMSDU: mark TX command is A-MSDU
		4496	*/
		4497	enum iwm_tx_offload_assist_flags_pos {
		4498	IWM_TX_CMD_OFFLD_IP_HDR = 0,
		4499	IWM_TX_CMD_OFFLD_L4_EN = 6,
		4500	IWM_TX_CMD_OFFLD_L3_EN = 7,
		4501	IWM_TX_CMD_OFFLD_MH_SIZE = 8,
		4502	IWM_TX_CMD_OFFLD_PAD = 13,
		4503	IWM_TX_CMD_OFFLD_AMSDU = 14,
		4504	};
		4505
		4506	#define IWM_TX_CMD_OFFLD_MH_MASK 0x1f
		4507	#define IWM_TX_CMD_OFFLD_IP_HDR_MASK 0x3f
		4508
4309	/* TODO: complete documentation for try_cnt and btkill_cnt */	4509	/* TODO: complete documentation for try_cnt and btkill_cnt */
4310	/**	4510	/**
4311	* struct iwm_tx_cmd - TX command struct to FW	4511	* struct iwm_tx_cmd - TX command struct to FW
4312	* ( IWM_TX_CMD = 0x1c )	4512	* ( IWM_TX_CMD = 0x1c )
4313	* @len: in bytes of the payload, see below for details	4513	* @len: in bytes of the payload, see below for details
4314	* @next_frame_len: same as len, but for next frame (0 if not applicable)	4514	* @offload_assist: TX offload configuration
4315	* Used for fragmentation and bursting, but not in 11n aggregation.
4316	* @tx_flags: combination of IWM_TX_CMD_FLG_*	4515	* @tx_flags: combination of IWM_TX_CMD_FLG_*
4317	* @rate_n_flags: rate for all Tx attempts, if IWM_TX_CMD_FLG_STA_RATE_MSK is	4516	* @rate_n_flags: rate for all Tx attempts, if IWM_TX_CMD_FLG_STA_RATE_MSK is
4318	* cleared. Combination of IWM_RATE_MCS_*	4517	* cleared. Combination of IWM_RATE_MCS_*
Lines 4348-4354 enum iwm_tx_pm_timeouts { Link Here
4348	*/	4547	*/
4349	struct iwm_tx_cmd {	4548	struct iwm_tx_cmd {
4350	uint16_t len;	4549	uint16_t len;
4351	uint16_t next_frame_len;	4550	uint16_t offload_assist;
4352	uint32_t tx_flags;	4551	uint32_t tx_flags;
4353	struct {	4552	struct {
4354	uint8_t try_cnt;	4553	uint8_t try_cnt;
Lines 4361-4368 struct iwm_tx_cmd { Link Here
4361	uint8_t initial_rate_index;	4560	uint8_t initial_rate_index;
4362	uint8_t reserved2;	4561	uint8_t reserved2;
4363	uint8_t key[16];	4562	uint8_t key[16];
4364	uint16_t next_frame_flags;	4563	uint32_t reserved3;
4365	uint16_t reserved3;
4366	uint32_t life_time;	4564	uint32_t life_time;
4367	uint32_t dram_lsb_ptr;	4565	uint32_t dram_lsb_ptr;
4368	uint8_t dram_msb_ptr;	4566	uint8_t dram_msb_ptr;
Lines 4370-4376 struct iwm_tx_cmd { Link Here
4370	uint8_t data_retry_limit;	4568	uint8_t data_retry_limit;
4371	uint8_t tid_tspec;	4569	uint8_t tid_tspec;
4372	uint16_t pm_frame_timeout;	4570	uint16_t pm_frame_timeout;
4373	uint16_t driver_txop;	4571	uint16_t reserved4;
4374	uint8_t payload[0];	4572	uint8_t payload[0];
4375	struct ieee80211_frame hdr[0];	4573	struct ieee80211_frame hdr[0];
4376	} __packed; /* IWM_TX_CMD_API_S_VER_3 */	4574	} __packed; /* IWM_TX_CMD_API_S_VER_3 */
Lines 5289-5310 struct iwm_scan_req_umac_tail { Link Here
5289	struct iwm_ssid_ie direct_scan[IWM_PROBE_OPTION_MAX];	5487	struct iwm_ssid_ie direct_scan[IWM_PROBE_OPTION_MAX];
5290	} __packed;	5488	} __packed;
5291		5489
		5490	/**
		5491	* struct iwm_scan_uma_chan_param
		5492	* @flags: channel flags &enum iwm_scan_channel_flags
		5493	* @count: num of channels in scan request
		5494	* @reserved: for future use and alignment
		5495	*/
		5496	struct iwm_scan_umac_chan_param {
		5497	uint8_t flags;
		5498	uint8_t count;
		5499	uint16_t reserved;
		5500	} __packed;
		5501
5292	/**	5502	/**
5293	* struct iwm_scan_req_umac	5503	* struct iwm_scan_req_umac
5294	* @flags: &enum iwm_umac_scan_flags	5504	* @flags: &enum iwm_umac_scan_flags
5295	* @uid: scan id, &enum iwm_umac_scan_uid_offsets	5505	* @uid: scan id, &enum iwm_umac_scan_uid_offsets
5296	* @ooc_priority: out of channel priority - &enum iwm_scan_priority	5506	* @ooc_priority: out of channel priority - &enum iwm_scan_priority
5297	* @general_flags: &enum iwm_umac_scan_general_flags	5507	* @general_flags: &enum iwm_umac_scan_general_flags
		5508	* @scan_start_mac_id: report the scan start TSF time according to this mac TSF
5298	* @extended_dwell: dwell time for channels 1, 6 and 11	5509	* @extended_dwell: dwell time for channels 1, 6 and 11
5299	* @active_dwell: dwell time for active scan	5510	* @active_dwell: dwell time for active scan per LMAC
5300	* @passive_dwell: dwell time for passive scan	5511	* @passive_dwell: dwell time for passive scan per LMAC
5301	* @fragmented_dwell: dwell time for fragmented passive scan	5512	* @fragmented_dwell: dwell time for fragmented passive scan
5302	* @max_out_time: max out of serving channel time	5513	* @adwell_default_n_aps: for adaptive dwell the default number of APs
5303	* @suspend_time: max suspend time	5514	* per channel
5304	* @scan_priority: scan internal prioritization &enum iwm_scan_priority	5515	* @adwell_default_n_aps_social: for adaptive dwell the default
5305	* @channel_flags: &enum iwm_scan_channel_flags	5516	* number of APs per social (1,6,11) channel
5306	* @n_channels: num of channels in scan request	5517	* @general_flags2: &enum iwl_umac_scan_general_flags2
		5518	* @adwell_max_budget: for adaptive dwell the maximal budget of TU to be added
		5519	* to total scan time
		5520	* @max_out_time: max out of serving channel time, per LMAC - for CDB there
		5521	* are 2 LMACs
		5522	* @suspend_time: max suspend time, per LMAC - for CDB there are 2 LMACs
		5523	* @scan_priority: scan internal prioritization &enum iwl_scan_priority
		5524	* @num_of_fragments: Number of fragments needed for full coverage per band.
		5525	* Relevant only for fragmented scan.
		5526	* @channel: &struct iwl_scan_umac_chan_param
5307	* @reserved: for future use and alignment	5527	* @reserved: for future use and alignment
		5528	* @reserved3: for future use and alignment
5308	* @data: &struct iwm_scan_channel_cfg_umac and	5529	* @data: &struct iwm_scan_channel_cfg_umac and
5309	* &struct iwm_scan_req_umac_tail	5530	* &struct iwm_scan_req_umac_tail
5310	*/	5531	*/
Lines 5312-5332 struct iwm_scan_req_umac { Link Here
5312	uint32_t flags;	5533	uint32_t flags;
5313	uint32_t uid;	5534	uint32_t uid;
5314	uint32_t ooc_priority;	5535	uint32_t ooc_priority;
5315	/* SCAN_GENERAL_PARAMS_API_S_VER_1 */	5536	uint16_t general_flags;
5316	uint32_t general_flags;	5537	uint8_t reserved;
5317	uint8_t extended_dwell;	5538	uint8_t scan_start_mac_id;
5318	uint8_t active_dwell;	5539	union {
5319	uint8_t passive_dwell;	5540	struct {
5320	uint8_t fragmented_dwell;	5541	uint8_t extended_dwell;
5321	uint32_t max_out_time;	5542	uint8_t active_dwell;
5322	uint32_t suspend_time;	5543	uint8_t passive_dwell;
5323	uint32_t scan_priority;	5544	uint8_t fragmented_dwell;
5324	/* SCAN_CHANNEL_PARAMS_API_S_VER_1 */	5545	uint32_t max_out_time;
5325	uint8_t channel_flags;	5546	uint32_t suspend_time;
5326	uint8_t n_channels;	5547	uint32_t scan_priority;
5327	uint16_t reserved;	5548	struct iwm_scan_umac_chan_param channel;
5328	uint8_t data[];	5549	uint8_t data[];
5329	} __packed; /* SCAN_REQUEST_CMD_UMAC_API_S_VER_1 */	5550	} v1;
		5551	struct {
		5552	uint8_t active_dwell;
		5553	uint8_t passive_dwell;
		5554	uint8_t fragmented_dwell;
		5555	uint8_t adwell_default_n_aps;
		5556	uint8_t adwell_default_n_aps_social;
		5557	uint8_t reserved3;
		5558	uint16_t adwell_max_budget;
		5559	uint32_t max_out_time[2];
		5560	uint32_t suspend_time[2];
		5561	uint32_t scan_priority;
		5562	struct iwm_scan_umac_chan_param channel;
		5563	uint8_t data[];
		5564	} v7;
		5565	};
		5566	} __packed;
		5567
		5568	#define IWM_SCAN_REQ_UMAC_SIZE_V7 48
		5569	#define IWM_SCAN_REQ_UMAC_SIZE_V1 36
5330		5570
5331	/**	5571	/**
5332	* struct iwm_umac_scan_abort	5572	* struct iwm_umac_scan_abort
Lines 5636-5665 struct iwm_mvm_keyinfo { Link Here
5636	#define IWM_ADD_STA_BAID_SHIFT 8	5876	#define IWM_ADD_STA_BAID_SHIFT 8
5637		5877
5638	/**	5878	/**
5639	* struct iwm_mvm_add_sta_cmd - Add/modify a station in the fw's sta table.	5879	* struct iwl_mvm_add_sta_cmd_v7 - Add/modify a station in the fw's sta table.
5640	* ( REPLY_ADD_STA = 0x18 )	5880	* ( REPLY_ADD_STA = 0x18 )
5641	* @add_modify: 1: modify existing, 0: add new station	5881	* @add_modify: see &enum iwl_sta_mode
5642	* @awake_acs:	5882	* @awake_acs: ACs to transmit data on while station is sleeping (for U-APSD)
5643	* @tid_disable_tx: is tid BIT(tid) enabled for Tx. Clear BIT(x) to enable	5883	* @tid_disable_tx: is tid BIT(tid) enabled for Tx. Clear BIT(x) to enable
5644	* AMPDU for tid x. Set %IWM_STA_MODIFY_TID_DISABLE_TX to change this field.	5884	* AMPDU for tid x. Set %STA_MODIFY_TID_DISABLE_TX to change this field.
5645	* @mac_id_n_color: the Mac context this station belongs to	5885	* @mac_id_n_color: the Mac context this station belongs to,
5646	* @addr[IEEE80211_ADDR_LEN]: station's MAC address	5886	* see &enum iwl_ctxt_id_and_color
		5887	* @addr: station's MAC address
		5888	* @reserved2: reserved
5647	* @sta_id: index of station in uCode's station table	5889	* @sta_id: index of station in uCode's station table
5648	* @modify_mask: IWM_STA_MODIFY_*, selects which parameters to modify vs. leave	5890	* @modify_mask: STA_MODIFY_*, selects which parameters to modify vs. leave
5649	* alone. 1 - modify, 0 - don't change.	5891	* alone. 1 - modify, 0 - don't change.
5650	* @station_flags: look at %iwm_sta_flags	5892	* @reserved3: reserved
5651	* @station_flags_msk: what of %station_flags have changed	5893	* @station_flags: look at &enum iwl_sta_flags
		5894	* @station_flags_msk: what of %station_flags have changed,
		5895	* also &enum iwl_sta_flags
5652	* @add_immediate_ba_tid: tid for which to add block-ack support (Rx)	5896	* @add_immediate_ba_tid: tid for which to add block-ack support (Rx)
5653	* Set %IWM_STA_MODIFY_ADD_BA_TID to use this field, and also set	5897	* Set %STA_MODIFY_ADD_BA_TID to use this field, and also set
5654	* add_immediate_ba_ssn.	5898	* add_immediate_ba_ssn.
5655	* @remove_immediate_ba_tid: tid for which to remove block-ack support (Rx)	5899	* @remove_immediate_ba_tid: tid for which to remove block-ack support (Rx)
5656	* Set %IWM_STA_MODIFY_REMOVE_BA_TID to use this field	5900	* Set %STA_MODIFY_REMOVE_BA_TID to use this field
5657	* @add_immediate_ba_ssn: ssn for the Rx block-ack session. Used together with	5901	* @add_immediate_ba_ssn: ssn for the Rx block-ack session. Used together with
5658	* add_immediate_ba_tid.	5902	* add_immediate_ba_tid.
5659	* @sleep_tx_count: number of packets to transmit to station even though it is	5903	* @sleep_tx_count: number of packets to transmit to station even though it is
5660	* asleep. Used to synchronise PS-poll and u-APSD responses while ucode	5904	* asleep. Used to synchronise PS-poll and u-APSD responses while ucode
5661	* keeps track of STA sleep state.	5905	* keeps track of STA sleep state.
5662	* @sleep_state_flags: Look at %iwm_sta_sleep_flag.	5906	* @sleep_state_flags: Look at &enum iwl_sta_sleep_flag.
5663	* @assoc_id: assoc_id to be sent in VHT PLCP (9-bit), for grp use 0, for AP	5907	* @assoc_id: assoc_id to be sent in VHT PLCP (9-bit), for grp use 0, for AP
5664	* mac-addr.	5908	* mac-addr.
5665	* @beamform_flags: beam forming controls	5909	* @beamform_flags: beam forming controls
Lines 5667-5678 struct iwm_mvm_keyinfo { Link Here
5667	*	5911	*
5668	* The device contains an internal table of per-station information, with info	5912	* The device contains an internal table of per-station information, with info
5669	* on security keys, aggregation parameters, and Tx rates for initial Tx	5913	* on security keys, aggregation parameters, and Tx rates for initial Tx
5670	* attempt and any retries (set by IWM_REPLY_TX_LINK_QUALITY_CMD).	5914	* attempt and any retries (set by REPLY_TX_LINK_QUALITY_CMD).
5671	*	5915	*
5672	* ADD_STA sets up the table entry for one station, either creating a new	5916	* ADD_STA sets up the table entry for one station, either creating a new
5673	* entry, or modifying a pre-existing one.	5917	* entry, or modifying a pre-existing one.
5674	*/	5918	*/
5675	struct iwm_mvm_add_sta_cmd {	5919	struct iwm_mvm_add_sta_cmd_v7 {
5676	uint8_t add_modify;	5920	uint8_t add_modify;
5677	uint8_t awake_acs;	5921	uint8_t awake_acs;
5678	uint16_t tid_disable_tx;	5922	uint16_t tid_disable_tx;
Lines 5691-5699 struct iwm_mvm_add_sta_cmd { Link Here
5691	uint16_t sleep_state_flags;	5935	uint16_t sleep_state_flags;
5692	uint16_t assoc_id;	5936	uint16_t assoc_id;
5693	uint16_t beamform_flags;	5937	uint16_t beamform_flags;
5694	uint32_t tfd_queue_msk;	5938	uint16_t tfd_queue_msk;
5695	} __packed; /* ADD_STA_CMD_API_S_VER_7 */	5939	} __packed; /* ADD_STA_CMD_API_S_VER_7 */
5696		5940
		5941	/**
		5942	* enum iwm_sta_type - FW station types
		5943	* ( REPLY_ADD_STA = 0x18 )
		5944	* @IWM_STA_LINK: Link station - normal RX and TX traffic.
		5945	* @IWM_STA_GENERAL_PURPOSE: General purpose. In AP mode used for beacons
		5946	* and probe responses.
		5947	* @IWM_STA_MULTICAST: multicast traffic,
		5948	* @IWM_STA_TDLS_LINK: TDLS link station
		5949	* @IWM_STA_AUX_ACTIVITY: auxilary station (scan, ROC and so on).
		5950	*/
		5951	enum iwm_sta_type {
		5952	IWM_STA_LINK,
		5953	IWM_STA_GENERAL_PURPOSE,
		5954	IWM_STA_MULTICAST,
		5955	IWM_STA_TDLS_LINK,
		5956	IWM_STA_AUX_ACTIVITY,
		5957	};
		5958
		5959	/**
		5960	* struct iwm_mvm_add_sta_cmd - Add/modify a station in the fw's sta table.
		5961	* ( REPLY_ADD_STA = 0x18 )
		5962	* @add_modify: see &enum iwm_sta_mode
		5963	* @awake_acs: ACs to transmit data on while station is sleeping (for U-APSD)
		5964	* @tid_disable_tx: is tid BIT(tid) enabled for Tx. Clear BIT(x) to enable
		5965	* AMPDU for tid x. Set %STA_MODIFY_TID_DISABLE_TX to change this field.
		5966	* @mac_id_n_color: the Mac context this station belongs to,
		5967	* see &enum iwl_ctxt_id_and_color
		5968	* @addr: station's MAC address
		5969	* @reserved2: reserved
		5970	* @sta_id: index of station in uCode's station table
		5971	* @modify_mask: STA_MODIFY_*, selects which parameters to modify vs. leave
		5972	* alone. 1 - modify, 0 - don't change.
		5973	* @reserved3: reserved
		5974	* @station_flags: look at &enum iwm_sta_flags
		5975	* @station_flags_msk: what of %station_flags have changed,
		5976	* also &enum iwm_sta_flags
		5977	* @add_immediate_ba_tid: tid for which to add block-ack support (Rx)
		5978	* Set %STA_MODIFY_ADD_BA_TID to use this field, and also set
		5979	* add_immediate_ba_ssn.
		5980	* @remove_immediate_ba_tid: tid for which to remove block-ack support (Rx)
		5981	* Set %STA_MODIFY_REMOVE_BA_TID to use this field
		5982	* @add_immediate_ba_ssn: ssn for the Rx block-ack session. Used together with
		5983	* add_immediate_ba_tid.
		5984	* @sleep_tx_count: number of packets to transmit to station even though it is
		5985	* asleep. Used to synchronise PS-poll and u-APSD responses while ucode
		5986	* keeps track of STA sleep state.
		5987	* @station_type: type of this station. See &enum iwl_sta_type.
		5988	* @sleep_state_flags: Look at &enum iwl_sta_sleep_flag.
		5989	* @assoc_id: assoc_id to be sent in VHT PLCP (9-bit), for grp use 0, for AP
		5990	* mac-addr.
		5991	* @beamform_flags: beam forming controls
		5992	* @tfd_queue_msk: tfd queues used by this station.
		5993	* Obselete for new TX API (9 and above).
		5994	* @rx_ba_window: aggregation window size
		5995	* @sp_length: the size of the SP in actual number of frames
		5996	* @uapsd_acs: 4 LS bits are trigger enabled ACs, 4 MS bits are the deliver
		5997	* enabled ACs.
		5998	*
		5999	* The device contains an internal table of per-station information, with info
		6000	* on security keys, aggregation parameters, and Tx rates for initial Tx
		6001	* attempt and any retries (set by REPLY_TX_LINK_QUALITY_CMD).
		6002	*
		6003	* ADD_STA sets up the table entry for one station, either creating a new
		6004	* entry, or modifying a pre-existing one.
6005	*/
6006	struct iwm_mvm_add_sta_cmd {
6007	uint8_t add_modify;
6008	uint8_t awake_acs;
6009	uint16_t tid_disable_tx;
6010	uint32_t mac_id_n_color;
6011	uint8_t addr[IEEE80211_ADDR_LEN]; /* _STA_ID_MODIFY_INFO_API_S_VER_1 */
6012	uint16_t reserved2;
6013	uint8_t sta_id;
6014	uint8_t modify_mask;
6015	uint16_t reserved3;
6016	uint32_t station_flags;
6017	uint32_t station_flags_msk;
6018	uint8_t add_immediate_ba_tid;
6019	uint8_t remove_immediate_ba_tid;
6020	uint16_t add_immediate_ba_ssn;
6021	uint16_t sleep_tx_count;
6022	uint8_t sleep_state_flags;
6023	uint8_t station_type;
6024	uint16_t assoc_id;
6025	uint16_t beamform_flags;
6026	uint32_t tfd_queue_msk;
6027	uint16_t rx_ba_window;
6028	uint8_t sp_length;
6029	uint8_t uapsd_acs;
6030	} __packed; /* ADD_STA_CMD_API_S_VER_10 */
6031
5697	/**	6032	/**
5698	* struct iwm_mvm_add_sta_key_cmd - add/modify sta key	6033	* struct iwm_mvm_add_sta_key_cmd - add/modify sta key
5699	* ( IWM_REPLY_ADD_STA_KEY = 0x17 )	6034	* ( IWM_REPLY_ADD_STA_KEY = 0x17 )




	uint8_t enabled_capa[howmany(IWM_NUM_UCODE_TLV_CAPA, NBBY)];
};

static inline int
fw_has_api(const struct iwm_ucode_capabilities *capabilities,
	   unsigned int api)
{
	return isset(capabilities->enabled_api, api);
}

static inline int
fw_has_capa(const struct iwm_ucode_capabilities *capabilities,
	    unsigned int capa)
{
	return isset(capabilities->enabled_capa, capa);
}

/* one for each uCode image (inst/data, init/runtime/wowlan) */
struct iwm_fw_desc {
	const void *data;	/* vmalloc'ed data */

	int			cur;
};

#define IWM_RX_LEGACY_RING_COUNT	256
#define IWM_RX_MQ_RING_COUNT		512

#define IWM_RBUF_SIZE		4096

#define IWM_MAX_SCATTER		20

struct iwm_rx_data {
	struct mbuf	*m;

};

struct iwm_rx_ring {
	struct iwm_dma_info	free_desc_dma;
	struct iwm_dma_info	used_desc_dma;
	struct iwm_dma_info	stat_dma;
	struct iwm_dma_info	buf_dma;
	void			*desc;
	struct iwm_rb_status	*stat;
	struct iwm_rx_data	data[512];
	bus_dmamap_t		spare_map;	/* for iwm_rx_addbuf() */
	bus_dma_tag_t           data_dmat;
	int			cur;

	struct iwm_rx_ring	rxq;
	int			qfullmsk;

	int			sc_sf_state;

	/* ICT table. */
	struct iwm_dma_info	ict_dma;
	int			ict_cur;

	struct iwm_notif_statistics_v10 sc_stats;
	int			sc_noise;

	caddr_t			sc_drvbpf;

	struct iwm_rx_radiotap_header sc_rxtap;
	struct iwm_tx_radiotap_header sc_txtap;


#define	IWM_LOCK(_sc)		mtx_lock(&(_sc)->sc_mtx)
#define	IWM_UNLOCK(_sc)		mtx_unlock(&(_sc)->sc_mtx)
#define IWM_LOCK_DESTROY(_sc)	mtx_destroy(&(_sc)->sc_mtx)

static inline bool
iwm_fw_has_api(struct iwm_softc *sc, unsigned int api)
{
	return isset(sc->sc_fw.ucode_capa.enabled_api, api);
}

static inline bool
iwm_fw_has_capa(struct iwm_softc *sc, unsigned int capa)
{
	return isset(sc->sc_fw.ucode_capa.enabled_capa, capa);
}

Lines 7-13 KMOD= if_iwm Link Here

(-)b/sys/modules/iwm/Makefile (-1 / +2 lines)
7	SRCS= if_iwm.c if_iwm_binding.c if_iwm_util.c if_iwm_phy_db.c	7	SRCS= if_iwm.c if_iwm_binding.c if_iwm_util.c if_iwm_phy_db.c
8	SRCS+= if_iwm_mac_ctxt.c if_iwm_phy_ctxt.c if_iwm_time_event.c	8	SRCS+= if_iwm_mac_ctxt.c if_iwm_phy_ctxt.c if_iwm_time_event.c
9	SRCS+= if_iwm_power.c if_iwm_scan.c if_iwm_led.c if_iwm_notif_wait.c	9	SRCS+= if_iwm_power.c if_iwm_scan.c if_iwm_led.c if_iwm_notif_wait.c
10	SRCS+= if_iwm_7000.c if_iwm_8000.c if_iwm_fw.c if_iwm_sta.c if_iwm_sf.c	10	SRCS+= if_iwm_7000.c if_iwm_8000.c if_iwm_9000.c if_iwm_fw.c if_iwm_9260.c
		11	SRCS+= if_iwm_sta.c if_iwm_sf.c
11	# bus layer	12	# bus layer
12	SRCS+= if_iwm_pcie_trans.c	13	SRCS+= if_iwm_pcie_trans.c
13	SRCS+= device_if.h bus_if.h pci_if.h opt_wlan.h opt_iwm.h	14	SRCS+= device_if.h bus_if.h pci_if.h opt_wlan.h opt_iwm.h

Return to bug 227044

Added Link Here

(-)b/sys/dev/iwm/if_iwm_9000.c (+97 lines)
1	/*-
2	* Based on BSD-licensed source modules in the Linux iwlwifi driver,
3	* which were used as the reference documentation for this implementation.
4	*
5	******************************************************************************
6	*
7	* This file is provided under a dual BSD/GPLv2 license. When using or
8	* redistributing this file, you may do so under either license.
9	*
10	* GPL LICENSE SUMMARY
11	*
12	* Copyright(c) 2014 Intel Corporation. All rights reserved.
13	* Copyright(c) 2014 - 2015 Intel Mobile Communications GmbH
14	* Copyright(c) 2016 Intel Deutschland GmbH
15	*
16	* This program is free software; you can redistribute it and/or modify
17	* it under the terms of version 2 of the GNU General Public License as
18	* published by the Free Software Foundation.
19	*
20	* This program is distributed in the hope that it will be useful, but
21	* WITHOUT ANY WARRANTY; without even the implied warranty of
22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23	* General Public License for more details.
24	*
25	* You should have received a copy of the GNU General Public License
26	* along with this program; if not, write to the Free Software
27	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
28	* USA
29	*
30	* The full GNU General Public License is included in this distribution
31	* in the file called COPYING.
32	*
33	* Contact Information:
34	* Intel Linux Wireless <linuxwifi@intel.com>
35	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
36	*
37	* BSD LICENSE
38	*
39	* Copyright(c) 2014 Intel Corporation. All rights reserved.
40	* Copyright(c) 2014 - 2015 Intel Mobile Communications GmbH
41	* All rights reserved.
42	*
43	* Redistribution and use in source and binary forms, with or without
44	* modification, are permitted provided that the following conditions
45	* are met:
46	*
47	* * Redistributions of source code must retain the above copyright
48	* notice, this list of conditions and the following disclaimer.
49	* * Redistributions in binary form must reproduce the above copyright
50	* notice, this list of conditions and the following disclaimer in
51	* the documentation and/or other materials provided with the
52	* distribution.
53	* * Neither the name Intel Corporation nor the names of its
54	* contributors may be used to endorse or promote products derived
55	* from this software without specific prior written permission.
56	*
57	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
58	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
59	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
60	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
61	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
62	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
63	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
64	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
65	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
66	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
67	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
68	*
69	*****************************************************************************/
70
71	#include <sys/cdefs.h>
72	__FBSDID("$FreeBSD$");
73
74	#include "opt_wlan.h"
75	#include "opt_iwm.h"
76
77	#include <sys/param.h>
78
79	#include "if_iwm_config.h"
80
81	#define IWM9000_FW "iwm9000fw"
82
83	#define IWM_NVM_HW_SECTION_NUM_FAMILY_9000 10
84
85	#define IWM_DEVICE_9000_COMMON \
86	.device_family = IWM_DEVICE_FAMILY_9000, \
87	.eeprom_size = IWM_OTP_LOW_IMAGE_SIZE_FAMILY_9000, \
88	.nvm_hw_section_num = IWM_NVM_HW_SECTION_NUM_FAMILY_9000
89
90	const struct iwm_cfg iwm9560_cfg = {
91	.name = "Intel(R) Dual Band Wireless AC 9560",
92	.fw_name = IWM9000_FW,
93	IWM_DEVICE_9000_COMMON,
94	.host_interrupt_operation_mode = 0,
95	.mqrx_supported = 1,
96	.integrated = 1,
97	};

Added Link Here

(-)b/sys/dev/iwm/if_iwm_9260.c (+96 lines)
1	/*-
2	* Based on BSD-licensed source modules in the Linux iwlwifi driver,
3	* which were used as the reference documentation for this implementation.
4	*
5	******************************************************************************
6	*
7	* This file is provided under a dual BSD/GPLv2 license. When using or
8	* redistributing this file, you may do so under either license.
9	*
10	* GPL LICENSE SUMMARY
11	*
12	* Copyright(c) 2014 Intel Corporation. All rights reserved.
13	* Copyright(c) 2014 - 2015 Intel Mobile Communications GmbH
14	* Copyright(c) 2016 Intel Deutschland GmbH
15	*
16	* This program is free software; you can redistribute it and/or modify
17	* it under the terms of version 2 of the GNU General Public License as
18	* published by the Free Software Foundation.
19	*
20	* This program is distributed in the hope that it will be useful, but
21	* WITHOUT ANY WARRANTY; without even the implied warranty of
22	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
23	* General Public License for more details.
24	*
25	* You should have received a copy of the GNU General Public License
26	* along with this program; if not, write to the Free Software
27	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
28	* USA
29	*
30	* The full GNU General Public License is included in this distribution
31	* in the file called COPYING.
32	*
33	* Contact Information:
34	* Intel Linux Wireless <linuxwifi@intel.com>
35	* Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
36	*
37	* BSD LICENSE
38	*
39	* Copyright(c) 2014 Intel Corporation. All rights reserved.
40	* Copyright(c) 2014 - 2015 Intel Mobile Communications GmbH
41	* All rights reserved.
42	*
43	* Redistribution and use in source and binary forms, with or without
44	* modification, are permitted provided that the following conditions
45	* are met:
46	*
47	* * Redistributions of source code must retain the above copyright
48	* notice, this list of conditions and the following disclaimer.
49	* * Redistributions in binary form must reproduce the above copyright
50	* notice, this list of conditions and the following disclaimer in
51	* the documentation and/or other materials provided with the
52	* distribution.
53	* * Neither the name Intel Corporation nor the names of its
54	* contributors may be used to endorse or promote products derived
55	* from this software without specific prior written permission.
56	*
57	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
58	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
59	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
60	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
61	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
62	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
63	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
64	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
65	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
66	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
67	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
68	*
69	*****************************************************************************/
70
71	#include <sys/cdefs.h>
72	__FBSDID("$FreeBSD$");
73
74	#include "opt_wlan.h"
75	#include "opt_iwm.h"
76
77	#include <sys/param.h>
78
79	#include "if_iwm_config.h"
80
81	#define IWM9260_FW "iwm9260fw"
82
83	#define IWM_NVM_HW_SECTION_NUM_FAMILY_9260 10
84
85	#define IWM_DEVICE_9260_COMMON \
86	.device_family = IWM_DEVICE_FAMILY_9000, \
87	.eeprom_size = IWM_OTP_LOW_IMAGE_SIZE_FAMILY_9000, \
88	.nvm_hw_section_num = IWM_NVM_HW_SECTION_NUM_FAMILY_9260
89
90	const struct iwm_cfg iwm9260_cfg = {
91	.name = "Intel(R) Dual Band Wireless AC 9260",
92	.fw_name = IWM9260_FW,
93	IWM_DEVICE_9260_COMMON,
94	.host_interrupt_operation_mode = 0,
95	.mqrx_supported = 1,
96	};

Lines 185-190 iwm_write_prph(struct iwm_softc *sc, uint32_t addr, uint32_t val) Link Here

(-)b/sys/dev/iwm/if_iwm_pcie_trans.c (-10 / +65 lines)
185	IWM_WRITE(sc, IWM_HBUS_TARG_PRPH_WDAT, val);	185	IWM_WRITE(sc, IWM_HBUS_TARG_PRPH_WDAT, val);
186	}	186	}
187		187
		188	void
		189	iwm_write_prph64(struct iwm_softc *sc, uint64_t addr, uint64_t val)
		190	{
		191	iwm_write_prph(sc, (uint32_t)addr, val & 0xffffffff);
		192	iwm_write_prph(sc, (uint32_t)addr + 4, val >> 32);
		193	}
		194
		195	int
		196	iwm_poll_prph(struct iwm_softc *sc, uint32_t addr, uint32_t bits, uint32_t mask,
		197	int timeout)
		198	{
		199	do {
		200	if ((iwm_read_prph(sc, addr) & mask) == (bits & mask))
		201	return (0);
		202	DELAY(10);
		203	timeout -= 10;
		204	} while (timeout > 0);
		205
		206	return (ETIMEDOUT);
		207	}
		208
188	#ifdef IWM_DEBUG	209	#ifdef IWM_DEBUG
189	/* iwlwifi: pcie/trans.c */	210	/* iwlwifi: pcie/trans.c */
190	int	211	int
Lines 261-267 iwm_nic_lock(struct iwm_softc *sc) Link Here
261	IWM_SETBITS(sc, IWM_CSR_GP_CNTRL,	282	IWM_SETBITS(sc, IWM_CSR_GP_CNTRL,
262	IWM_CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);	283	IWM_CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
263		284
264	if (sc->cfg->device_family == IWM_DEVICE_FAMILY_8000)	285	if (sc->cfg->device_family >= IWM_DEVICE_FAMILY_8000)
265	DELAY(2);	286	DELAY(2);
266		287
267	if (iwm_poll_bit(sc, IWM_CSR_GP_CNTRL,	288	if (iwm_poll_bit(sc, IWM_CSR_GP_CNTRL,
Lines 325-330 iwm_enable_rfkill_int(struct iwm_softc *sc) Link Here
325	{	346	{
326	sc->sc_intmask = IWM_CSR_INT_BIT_RF_KILL;	347	sc->sc_intmask = IWM_CSR_INT_BIT_RF_KILL;
327	IWM_WRITE(sc, IWM_CSR_INT_MASK, sc->sc_intmask);	348	IWM_WRITE(sc, IWM_CSR_INT_MASK, sc->sc_intmask);
		349	IWM_SETBITS(sc, IWM_CSR_GP_CNTRL,
		350	IWM_CSR_GP_CNTRL_REG_FLAG_RFKILL_WAKE_L1A_EN);
328	}	351	}
329		352
330	int	353	int
Lines 383-389 iwm_prepare_card_hw(struct iwm_softc *sc) Link Here
383	if (iwm_set_hw_ready(sc))	406	if (iwm_set_hw_ready(sc))
384	goto out;	407	goto out;
385		408
386	DELAY(100);	409	IWM_SETBITS(sc, IWM_CSR_DBG_LINK_PWR_MGMT_REG,
		410	IWM_CSR_RESET_LINK_PWR_MGMT_DISABLED);
		411	DELAY(1000);
387		412
388	/* If HW is not ready, prepare the conditions to check again */	413	/* If HW is not ready, prepare the conditions to check again */
389	IWM_SETBITS(sc, IWM_CSR_HW_IF_CONFIG_REG,	414	IWM_SETBITS(sc, IWM_CSR_HW_IF_CONFIG_REG,
Lines 454-460 iwm_apm_init(struct iwm_softc *sc) Link Here
454	IWM_DPRINTF(sc, IWM_DEBUG_RESET, "iwm apm start\n");	479	IWM_DPRINTF(sc, IWM_DEBUG_RESET, "iwm apm start\n");
455		480
456	/* Disable L0S exit timer (platform NMI Work/Around) */	481	/* Disable L0S exit timer (platform NMI Work/Around) */
457	if (sc->cfg->device_family != IWM_DEVICE_FAMILY_8000) {	482	if (sc->cfg->device_family < IWM_DEVICE_FAMILY_8000) {
458	IWM_SETBITS(sc, IWM_CSR_GIO_CHICKEN_BITS,	483	IWM_SETBITS(sc, IWM_CSR_GIO_CHICKEN_BITS,
459	IWM_CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);	484	IWM_CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);
460	}	485	}
Lines 569-574 iwm_apm_init(struct iwm_softc *sc) Link Here
569	void	594	void
570	iwm_apm_stop(struct iwm_softc *sc)	595	iwm_apm_stop(struct iwm_softc *sc)
571	{	596	{
		597	IWM_SETBITS(sc, IWM_CSR_DBG_LINK_PWR_MGMT_REG,
		598	IWM_CSR_RESET_LINK_PWR_MGMT_DISABLED);
		599	IWM_SETBITS(sc, IWM_CSR_HW_IF_CONFIG_REG,
		600	IWM_CSR_HW_IF_CONFIG_REG_PREPARE \|
		601	IWM_CSR_HW_IF_CONFIG_REG_ENABLE_PME);
		602	DELAY(1000);
		603	IWM_CLRBITS(sc, IWM_CSR_DBG_LINK_PWR_MGMT_REG,
		604	IWM_CSR_RESET_LINK_PWR_MGMT_DISABLED);
		605	DELAY(5000);
		606
572	/* stop device's busmaster DMA activity */	607	/* stop device's busmaster DMA activity */
573	IWM_SETBITS(sc, IWM_CSR_RESET, IWM_CSR_RESET_REG_FLAG_STOP_MASTER);	608	IWM_SETBITS(sc, IWM_CSR_RESET, IWM_CSR_RESET_REG_FLAG_STOP_MASTER);
574		609
Lines 576-581 iwm_apm_stop(struct iwm_softc *sc) Link Here
576	IWM_CSR_RESET_REG_FLAG_MASTER_DISABLED,	611	IWM_CSR_RESET_REG_FLAG_MASTER_DISABLED,
577	IWM_CSR_RESET_REG_FLAG_MASTER_DISABLED, 100))	612	IWM_CSR_RESET_REG_FLAG_MASTER_DISABLED, 100))
578	device_printf(sc->sc_dev, "timeout waiting for master\n");	613	device_printf(sc->sc_dev, "timeout waiting for master\n");
		614
		615	/*
		616	* Clear "initialization complete" bit to move adapter from
		617	* D0A* (powered-up Active) --> D0U* (Uninitialized) state.
		618	*/
		619	IWM_CLRBITS(sc, IWM_CSR_GP_CNTRL,
		620	IWM_CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
		621
579	IWM_DPRINTF(sc, IWM_DEBUG_TRANS, "%s: iwm apm stop\n", __func__);	622	IWM_DPRINTF(sc, IWM_DEBUG_TRANS, "%s: iwm apm stop\n", __func__);
580	}	623	}
581		624
Lines 590-600 iwm_start_hw(struct iwm_softc *sc) Link Here
590		633
591	/* Reset the entire device */	634	/* Reset the entire device */
592	IWM_WRITE(sc, IWM_CSR_RESET, IWM_CSR_RESET_REG_FLAG_SW_RESET);	635	IWM_WRITE(sc, IWM_CSR_RESET, IWM_CSR_RESET_REG_FLAG_SW_RESET);
593	DELAY(10);	636	DELAY(5000);
594		637
595	if ((error = iwm_apm_init(sc)) != 0)	638	if ((error = iwm_apm_init(sc)) != 0)
596	return error;	639	return error;
597		640
		641	/* On newer chipsets MSI is disabled by default. */
		642	if (sc->cfg->mqrx_supported)
		643	iwm_write_prph(sc, IWM_UREG_CHICK, IWM_UREG_CHICK_MSI_ENABLE);
		644
598	iwm_enable_rfkill_int(sc);	645	iwm_enable_rfkill_int(sc);
599	iwm_check_rfkill(sc);	646	iwm_check_rfkill(sc);
600		647
Lines 613-625 iwm_set_pwr(struct iwm_softc *sc) Link Here
613	int	660	int
614	iwm_pcie_rx_stop(struct iwm_softc *sc)	661	iwm_pcie_rx_stop(struct iwm_softc *sc)
615	{	662	{
616	int ret = 0;	663	int ret;
		664
		665	ret = 0;
617	if (iwm_nic_lock(sc)) {	666	if (iwm_nic_lock(sc)) {
618	IWM_WRITE(sc, IWM_FH_MEM_RCSR_CHNL0_CONFIG_REG, 0);	667	if (sc->cfg->mqrx_supported) {
619	ret = iwm_poll_bit(sc, IWM_FH_MEM_RSSR_RX_STATUS_REG,	668	iwm_write_prph(sc, IWM_RFH_RXF_DMA_CFG, 0);
620	IWM_FH_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,	669	ret = iwm_poll_prph(sc, IWM_RFH_GEN_STATUS,
621	IWM_FH_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,	670	IWM_RXF_DMA_IDLE, IWM_RXF_DMA_IDLE, 1000);
622	1000);	671	} else {
		672	IWM_WRITE(sc, IWM_FH_MEM_RCSR_CHNL0_CONFIG_REG, 0);
		673	ret = iwm_poll_bit(sc, IWM_FH_MEM_RSSR_RX_STATUS_REG,
		674	IWM_FH_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
		675	IWM_FH_RSSR_CHNL0_RX_STATUS_CHNL_IDLE,
		676	1000);
		677	}
623	iwm_nic_unlock(sc);	678	iwm_nic_unlock(sc);
624	}	679	}
625	return ret;	680	return ret;

Lines 215-222 static inline boolean_t Link Here

(-)b/sys/dev/iwm/if_iwm_scan.c (-44 / +78 lines)
215	iwm_mvm_rrm_scan_needed(struct iwm_softc *sc)	215	iwm_mvm_rrm_scan_needed(struct iwm_softc *sc)
216	{	216	{
217	/* require rrm scan whenever the fw supports it */	217	/* require rrm scan whenever the fw supports it */
218	return fw_has_capa(&sc->sc_fw.ucode_capa,	218	return iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT);
219	IWM_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT);
220	}	219	}
221		220
222	#ifdef IWM_DEBUG	221	#ifdef IWM_DEBUG
Lines 251-257 iwm_mvm_rx_lmac_scan_complete_notif(struct iwm_softc *sc, Link Here
251	/* If this happens, the firmware has mistakenly sent an LMAC	250	/* If this happens, the firmware has mistakenly sent an LMAC
252	* notification during UMAC scans -- warn and ignore it.	251	* notification during UMAC scans -- warn and ignore it.
253	*/	252	*/
254	if (fw_has_capa(&sc->sc_fw.ucode_capa, IWM_UCODE_TLV_CAPA_UMAC_SCAN)) {	253	if (iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_UMAC_SCAN)) {
255	device_printf(sc->sc_dev,	254	device_printf(sc->sc_dev,
256	"%s: Mistakenly got LMAC notification during UMAC scan\n",	255	"%s: Mistakenly got LMAC notification during UMAC scan\n",
257	__func__);	256	__func__);
Lines 581-586 iwm_mvm_scan_use_ebs(struct iwm_softc *sc) Link Here
581	sc->last_ebs_successful);	580	sc->last_ebs_successful);
582	}	581	}
583		582
		583	static int
		584	iwm_mvm_scan_size(struct iwm_softc *sc)
		585	{
		586	int base_size;
		587
		588	if (iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_UMAC_SCAN)) {
		589	if (iwm_fw_has_api(sc, IWM_UCODE_TLV_API_ADAPTIVE_DWELL))
		590	base_size = IWM_SCAN_REQ_UMAC_SIZE_V7;
		591	else
		592	base_size = IWM_SCAN_REQ_UMAC_SIZE_V1;
		593
		594	return base_size +
		595	sizeof(struct iwm_scan_channel_cfg_umac) *
		596	sc->sc_fw.ucode_capa.n_scan_channels +
		597	sizeof(struct iwm_scan_req_umac_tail);
		598	} else {
		599	return sizeof(struct iwm_scan_req_lmac) +
		600	sizeof(struct iwm_scan_channel_cfg_lmac) *
		601	sc->sc_fw.ucode_capa.n_scan_channels +
		602	sizeof(struct iwm_scan_probe_req);
		603	}
		604	}
		605
584	int	606	int
585	iwm_mvm_umac_scan(struct iwm_softc *sc)	607	iwm_mvm_umac_scan(struct iwm_softc *sc)
586	{	608	{
Lines 594-606 iwm_mvm_umac_scan(struct iwm_softc *sc) Link Here
594	struct iwm_scan_req_umac *req;	616	struct iwm_scan_req_umac *req;
595	struct iwm_scan_req_umac_tail *tail;	617	struct iwm_scan_req_umac_tail *tail;
596	size_t req_len;	618	size_t req_len;
597	uint8_t i, nssid;	619	uint16_t general_flags;
		620	uint8_t channel_flags, i, nssid;
598	int ret;	621	int ret;
599		622
600	req_len = sizeof(struct iwm_scan_req_umac) +	623	req_len = iwm_mvm_scan_size(sc);
601	(sizeof(struct iwm_scan_channel_cfg_umac) *
602	sc->sc_fw.ucode_capa.n_scan_channels) +
603	sizeof(struct iwm_scan_req_umac_tail);
604	if (req_len > IWM_MAX_CMD_PAYLOAD_SIZE)	624	if (req_len > IWM_MAX_CMD_PAYLOAD_SIZE)
605	return ENOMEM;	625	return ENOMEM;
606	req = malloc(req_len, M_DEVBUF, M_NOWAIT \| M_ZERO);	626	req = malloc(req_len, M_DEVBUF, M_NOWAIT \| M_ZERO);
Lines 612-639 iwm_mvm_umac_scan(struct iwm_softc *sc) Link Here
612		632
613	IWM_DPRINTF(sc, IWM_DEBUG_SCAN, "Handling ieee80211 scan request\n");	633	IWM_DPRINTF(sc, IWM_DEBUG_SCAN, "Handling ieee80211 scan request\n");
614		634
615	/* These timings correspond to iwlwifi's UNASSOC scan. */	635	nssid = MIN(ss->ss_nssid, IWM_PROBE_OPTION_MAX);
616	req->active_dwell = 10;
617	req->passive_dwell = 110;
618	req->fragmented_dwell = 44;
619	req->extended_dwell = 90;
620	req->max_out_time = 0;
621	req->suspend_time = 0;
622		636
623	req->scan_priority = htole32(IWM_SCAN_PRIORITY_HIGH);	637	general_flags = IWM_UMAC_SCAN_GEN_FLAGS_PASS_ALL \|
624	req->ooc_priority = htole32(IWM_SCAN_PRIORITY_HIGH);	638	IWM_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE;
		639	if (!iwm_fw_has_api(sc, IWM_UCODE_TLV_API_ADAPTIVE_DWELL))
		640	general_flags \|= IWM_UMAC_SCAN_GEN_FLAGS_EXTENDED_DWELL;
		641	if (iwm_mvm_rrm_scan_needed(sc))
		642	general_flags \|= IWM_UMAC_SCAN_GEN_FLAGS_RRM_ENABLED;
		643	if (nssid != 0)
		644	general_flags \|= IWM_UMAC_SCAN_GEN_FLAGS_PRE_CONNECT;
		645	else
		646	general_flags \|= IWM_UMAC_SCAN_GEN_FLAGS_PASSIVE;
625		647
626	nssid = MIN(ss->ss_nssid, IWM_PROBE_OPTION_MAX);	648	channel_flags = 0;
627	req->n_channels = iwm_mvm_umac_scan_fill_channels(sc,	649	if (iwm_mvm_scan_use_ebs(sc))
628	(struct iwm_scan_channel_cfg_umac *)req->data, nssid);	650	channel_flags = IWM_SCAN_CHANNEL_FLAG_EBS \|
		651	IWM_SCAN_CHANNEL_FLAG_EBS_ACCURATE \|
		652	IWM_SCAN_CHANNEL_FLAG_CACHE_ADD;
629		653
630	req->general_flags = htole32(IWM_UMAC_SCAN_GEN_FLAGS_PASS_ALL \|	654	req->general_flags = htole16(general_flags);
631	IWM_UMAC_SCAN_GEN_FLAGS_ITER_COMPLETE \|	655	req->ooc_priority = htole32(IWM_SCAN_PRIORITY_HIGH);
632	IWM_UMAC_SCAN_GEN_FLAGS_EXTENDED_DWELL);
633		656
634	tail = (void )((char )&req->data +	657	/* These timings correspond to iwlwifi's UNASSOC scan. */
635	sizeof(struct iwm_scan_channel_cfg_umac) *	658	if (iwm_fw_has_api(sc, IWM_UCODE_TLV_API_ADAPTIVE_DWELL)) {
636	sc->sc_fw.ucode_capa.n_scan_channels);	659	req->v7.active_dwell = 10;
		660	req->v7.passive_dwell = 110;
		661	req->v7.fragmented_dwell = 44;
		662	req->v7.adwell_default_n_aps_social = 10;
		663	req->v7.adwell_default_n_aps = 2;
		664	req->v7.adwell_max_budget = htole16(300);
		665	req->v7.scan_priority = htole32(IWM_SCAN_PRIORITY_HIGH);
		666	req->v7.channel.flags = channel_flags;
		667	req->v7.channel.count = iwm_mvm_umac_scan_fill_channels(sc,
		668	(struct iwm_scan_channel_cfg_umac *)req->v7.data, nssid);
		669
		670	tail = (void )((char )&req->v7.data +
		671	sizeof(struct iwm_scan_channel_cfg_umac) *
		672	sc->sc_fw.ucode_capa.n_scan_channels);
		673	} else {
		674	req->v1.active_dwell = 10;
		675	req->v1.passive_dwell = 110;
		676	req->v1.fragmented_dwell = 44;
		677	req->v1.extended_dwell = 90;
		678	req->v1.scan_priority = htole32(IWM_SCAN_PRIORITY_HIGH);
		679	req->v1.channel.flags = channel_flags;
		680	req->v1.channel.count = iwm_mvm_umac_scan_fill_channels(sc,
		681	(struct iwm_scan_channel_cfg_umac *)req->v1.data, nssid);
		682
		683	tail = (void )((char )&req->v1.data +
		684	sizeof(struct iwm_scan_channel_cfg_umac) *
		685	sc->sc_fw.ucode_capa.n_scan_channels);
		686	}
637		687
638	/* Check if we're doing an active directed scan. */	688	/* Check if we're doing an active directed scan. */
639	for (i = 0; i < nssid; i++) {	689	for (i = 0; i < nssid; i++) {
Lines 644-663 iwm_mvm_umac_scan(struct iwm_softc *sc) Link Here
644	tail->direct_scan[i].len);	694	tail->direct_scan[i].len);
645	/* XXX debug */	695	/* XXX debug */
646	}	696	}
647	if (nssid != 0) {
648	req->general_flags \|=
649	htole32(IWM_UMAC_SCAN_GEN_FLAGS_PRE_CONNECT);
650	} else
651	req->general_flags \|= htole32(IWM_UMAC_SCAN_GEN_FLAGS_PASSIVE);
652
653	if (iwm_mvm_scan_use_ebs(sc))
654	req->channel_flags = IWM_SCAN_CHANNEL_FLAG_EBS \|
655	IWM_SCAN_CHANNEL_FLAG_EBS_ACCURATE \|
656	IWM_SCAN_CHANNEL_FLAG_CACHE_ADD;
657
658	if (iwm_mvm_rrm_scan_needed(sc))
659	req->general_flags \|=
660	htole32(IWM_UMAC_SCAN_GEN_FLAGS_RRM_ENABLED);
661		697
662	ret = iwm_mvm_fill_probe_req(sc, &tail->preq);	698	ret = iwm_mvm_fill_probe_req(sc, &tail->preq);
663	if (ret) {	699	if (ret) {
Lines 695-703 iwm_mvm_lmac_scan(struct iwm_softc *sc) Link Here
695	IWM_DPRINTF(sc, IWM_DEBUG_SCAN,	731	IWM_DPRINTF(sc, IWM_DEBUG_SCAN,
696	"Handling ieee80211 scan request\n");	732	"Handling ieee80211 scan request\n");
697		733
698	req_len = sizeof(struct iwm_scan_req_lmac) +	734	req_len = iwm_mvm_scan_size(sc);
699	(sizeof(struct iwm_scan_channel_cfg_lmac) *
700	sc->sc_fw.ucode_capa.n_scan_channels) + sizeof(struct iwm_scan_probe_req);
701	if (req_len > IWM_MAX_CMD_PAYLOAD_SIZE)	735	if (req_len > IWM_MAX_CMD_PAYLOAD_SIZE)
702	return ENOMEM;	736	return ENOMEM;
703	req = malloc(req_len, M_DEVBUF, M_NOWAIT \| M_ZERO);	737	req = malloc(req_len, M_DEVBUF, M_NOWAIT \| M_ZERO);
Lines 866-872 iwm_mvm_scan_stop_wait(struct iwm_softc *sc) Link Here
866		900
867	IWM_DPRINTF(sc, IWM_DEBUG_SCAN, "Preparing to stop scan\n");	901	IWM_DPRINTF(sc, IWM_DEBUG_SCAN, "Preparing to stop scan\n");
868		902
869	if (fw_has_capa(&sc->sc_fw.ucode_capa, IWM_UCODE_TLV_CAPA_UMAC_SCAN))	903	if (iwm_fw_has_capa(sc, IWM_UCODE_TLV_CAPA_UMAC_SCAN))
870	ret = iwm_mvm_umac_scan_abort(sc);	904	ret = iwm_mvm_umac_scan_abort(sc);
871	else	905	else
872	ret = iwm_mvm_lmac_scan_abort(sc);	906	ret = iwm_mvm_lmac_scan_abort(sc);

Lines 138-150 __FBSDID("$FreeBSD$"); Link Here

(-)b/sys/dev/iwm/if_iwm_sta.c (-9 / +7 lines)
138	static inline int	138	static inline int
139	iwm_mvm_add_sta_cmd_size(struct iwm_softc *sc)	139	iwm_mvm_add_sta_cmd_size(struct iwm_softc *sc)
140	{	140	{
141	#ifdef notyet	141	return sc->cfg->mqrx_supported ? sizeof(struct iwm_mvm_add_sta_cmd) :
142	return iwm_mvm_has_new_rx_api(mvm) ?	142	sizeof(struct iwm_mvm_add_sta_cmd_v7);
143	sizeof(struct iwm_mvm_add_sta_cmd) :
144	sizeof(struct iwm_mvm_add_sta_cmd_v7);
145	#else
146	return sizeof(struct iwm_mvm_add_sta_cmd);
147	#endif
148	}	143	}
149		144
150	/* send station add/update command to firmware */	145	/* send station add/update command to firmware */
Lines 318-324 iwm_mvm_rm_sta_id(struct iwm_softc sc, struct ieee80211vap vap) Link Here
318		313
319	static int	314	static int
320	iwm_mvm_add_int_sta_common(struct iwm_softc sc, struct iwm_int_sta sta,	315	iwm_mvm_add_int_sta_common(struct iwm_softc sc, struct iwm_int_sta sta,
321	const uint8_t *addr, uint16_t mac_id, uint16_t color)	316	const uint8_t *addr, uint16_t mac_id, uint16_t color)
322	{	317	{
323	struct iwm_mvm_add_sta_cmd cmd;	318	struct iwm_mvm_add_sta_cmd cmd;
324	int ret;	319	int ret;
Lines 327-332 iwm_mvm_add_int_sta_common(struct iwm_softc sc, struct iwm_int_sta sta, Link Here
327	memset(&cmd, 0, sizeof(cmd));	322	memset(&cmd, 0, sizeof(cmd));
328	cmd.sta_id = sta->sta_id;	323	cmd.sta_id = sta->sta_id;
329	cmd.mac_id_n_color = htole32(IWM_FW_CMD_ID_AND_COLOR(mac_id, color));	324	cmd.mac_id_n_color = htole32(IWM_FW_CMD_ID_AND_COLOR(mac_id, color));
		325	if (sta->sta_id == IWM_AUX_STA_ID && sc->cfg->mqrx_supported)
		326	cmd.station_type = IWM_STA_AUX_ACTIVITY;
330		327
331	cmd.tfd_queue_msk = htole32(sta->tfd_queue_msk);	328	cmd.tfd_queue_msk = htole32(sta->tfd_queue_msk);
332	cmd.tid_disable_tx = htole16(0xffff);	329	cmd.tid_disable_tx = htole16(0xffff);
Lines 362-368 iwm_mvm_add_aux_sta(struct iwm_softc *sc) Link Here
362	sc->sc_aux_sta.tfd_queue_msk = (1 << IWM_MVM_AUX_QUEUE);	359	sc->sc_aux_sta.tfd_queue_msk = (1 << IWM_MVM_AUX_QUEUE);
363		360
364	/* Map Aux queue to fifo - needs to happen before adding Aux station */	361	/* Map Aux queue to fifo - needs to happen before adding Aux station */
365	ret = iwm_enable_txq(sc, 0, IWM_MVM_AUX_QUEUE, IWM_MVM_TX_FIFO_MCAST);	362	ret = iwm_enable_txq(sc, IWM_AUX_STA_ID, IWM_MVM_AUX_QUEUE,
		363	IWM_MVM_TX_FIFO_MCAST);
366	if (ret)	364	if (ret)
367	return ret;	365	return ret;
368		366

Lines 165-184 struct iwm_ucode_capabilities { Link Here

(-)b/sys/dev/iwm/if_iwmvar.h (-24 / +20 lines)
165	uint8_t enabled_capa[howmany(IWM_NUM_UCODE_TLV_CAPA, NBBY)];	165	uint8_t enabled_capa[howmany(IWM_NUM_UCODE_TLV_CAPA, NBBY)];
166	};	166	};
167		167
168	static inline int
169	fw_has_api(const struct iwm_ucode_capabilities *capabilities,
170	unsigned int api)
171	{
172	return isset(capabilities->enabled_api, api);
173	}
174
175	static inline int
176	fw_has_capa(const struct iwm_ucode_capabilities *capabilities,
177	unsigned int capa)
178	{
179	return isset(capabilities->enabled_capa, capa);
180	}
181
182	/* one for each uCode image (inst/data, init/runtime/wowlan) */	168	/* one for each uCode image (inst/data, init/runtime/wowlan) */
183	struct iwm_fw_desc {	169	struct iwm_fw_desc {
184	const void data; / vmalloc'ed data */	170	const void data; / vmalloc'ed data */
Lines 299-309 struct iwm_tx_ring { Link Here
299	int cur;	285	int cur;
300	};	286	};
301		287
302	#define IWM_RX_RING_COUNT 256	288	#define IWM_RX_LEGACY_RING_COUNT 256
303	/* Linux driver optionally uses 8k buffer */	289	#define IWM_RX_MQ_RING_COUNT 512
		290
304	#define IWM_RBUF_SIZE 4096	291	#define IWM_RBUF_SIZE 4096
305		292
306	#define IWM_MAX_SCATTER 20	293	#define IWM_MAX_SCATTER 20
307		294
308	struct iwm_rx_data {	295	struct iwm_rx_data {
309	struct mbuf *m;	296	struct mbuf *m;
Lines 311-322 struct iwm_rx_data { Link Here
311	};	298	};
312		299
313	struct iwm_rx_ring {	300	struct iwm_rx_ring {
314	struct iwm_dma_info desc_dma;	301	struct iwm_dma_info free_desc_dma;
		302	struct iwm_dma_info used_desc_dma;
315	struct iwm_dma_info stat_dma;	303	struct iwm_dma_info stat_dma;
316	struct iwm_dma_info buf_dma;	304	struct iwm_dma_info buf_dma;
317	uint32_t *desc;	305	void *desc;
318	struct iwm_rb_status *stat;	306	struct iwm_rb_status *stat;
319	struct iwm_rx_data data[IWM_RX_RING_COUNT];	307	struct iwm_rx_data data[512];
320	bus_dmamap_t spare_map; /* for iwm_rx_addbuf() */	308	bus_dmamap_t spare_map; /* for iwm_rx_addbuf() */
321	bus_dma_tag_t data_dmat;	309	bus_dma_tag_t data_dmat;
322	int cur;	310	int cur;
Lines 459-466 struct iwm_softc { Link Here
459	struct iwm_rx_ring rxq;	447	struct iwm_rx_ring rxq;
460	int qfullmsk;	448	int qfullmsk;
461		449
462	int sc_sf_state;
463
464	/* ICT table. */	450	/* ICT table. */
465	struct iwm_dma_info ict_dma;	451	struct iwm_dma_info ict_dma;
466	int ict_cur;	452	int ict_cur;
Lines 526-533 struct iwm_softc { Link Here
526	struct iwm_notif_statistics_v10 sc_stats;	512	struct iwm_notif_statistics_v10 sc_stats;
527	int sc_noise;	513	int sc_noise;
528		514
529	caddr_t sc_drvbpf;
530
531	struct iwm_rx_radiotap_header sc_rxtap;	515	struct iwm_rx_radiotap_header sc_rxtap;
532	struct iwm_tx_radiotap_header sc_txtap;	516	struct iwm_tx_radiotap_header sc_txtap;
533		517
Lines 580-582 struct iwm_softc { Link Here
580	#define IWM_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx)	564	#define IWM_LOCK(_sc) mtx_lock(&(_sc)->sc_mtx)
581	#define IWM_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx)	565	#define IWM_UNLOCK(_sc) mtx_unlock(&(_sc)->sc_mtx)
582	#define IWM_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->sc_mtx)	566	#define IWM_LOCK_DESTROY(_sc) mtx_destroy(&(_sc)->sc_mtx)
		567
		568	static inline bool
		569	iwm_fw_has_api(struct iwm_softc *sc, unsigned int api)
		570	{
		571	return isset(sc->sc_fw.ucode_capa.enabled_api, api);
		572	}
		573
		574	static inline bool
		575	iwm_fw_has_capa(struct iwm_softc *sc, unsigned int capa)
		576	{
		577	return isset(sc->sc_fw.ucode_capa.enabled_capa, capa);
		578	}