iwk2.c revision 6f12def440a1ce798ab128210a43414d173669f0
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/*
* Copyright (c) 2007, Intel Corporation
* All rights reserved.
*/
/*
* Copyright (c) 2006
* Copyright (c) 2007
* Damien Bergamini <damien.bergamini@free.fr>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
/*
*/
#include <sys/byteorder.h>
#include <sys/ethernet.h>
#include <sys/mac_provider.h>
#include <sys/mac_wifi.h>
#include <sys/net80211.h>
#include <sys/net80211_proto.h>
#include "iwk_calibration.h"
#include "iwk_hw.h"
#include "iwk_eeprom.h"
#include "iwk2_var.h"
#include <inet/wifi_ioctl.h>
#ifdef DEBUG
#define IWK_DEBUG_80211 (1 << 0)
uint32_t iwk_dbg_flags = 0;
#define IWK_DBG(x) \
iwk_dbg x
#else
#define IWK_DBG(x)
#endif
static void *iwk_soft_state_p = NULL;
static uint8_t iwk_fw_bin [] = {
#include "fw-iw/iw4965.ucode.hex"
};
/* DMA attributes for a shared page */
static ddi_dma_attr_t sh_dma_attr = {
DMA_ATTR_V0, /* version of this structure */
0, /* lowest usable address */
0xffffffffU, /* highest usable address */
0xffffffffU, /* maximum DMAable byte count */
0x1000, /* alignment in bytes */
0x1000, /* burst sizes (any?) */
1, /* minimum transfer */
0xffffffffU, /* maximum transfer */
0xffffffffU, /* maximum segment length */
1, /* maximum number of segments */
1, /* granularity */
0, /* flags (reserved) */
};
/* DMA attributes for a keep warm DRAM descriptor */
static ddi_dma_attr_t kw_dma_attr = {
DMA_ATTR_V0, /* version of this structure */
0, /* lowest usable address */
0xffffffffU, /* highest usable address */
0xffffffffU, /* maximum DMAable byte count */
0x1000, /* alignment in bytes */
0x1000, /* burst sizes (any?) */
1, /* minimum transfer */
0xffffffffU, /* maximum transfer */
0xffffffffU, /* maximum segment length */
1, /* maximum number of segments */
1, /* granularity */
0, /* flags (reserved) */
};
/* DMA attributes for a ring descriptor */
static ddi_dma_attr_t ring_desc_dma_attr = {
DMA_ATTR_V0, /* version of this structure */
0, /* lowest usable address */
0xffffffffU, /* highest usable address */
0xffffffffU, /* maximum DMAable byte count */
0x100, /* alignment in bytes */
0x100, /* burst sizes (any?) */
1, /* minimum transfer */
0xffffffffU, /* maximum transfer */
0xffffffffU, /* maximum segment length */
1, /* maximum number of segments */
1, /* granularity */
0, /* flags (reserved) */
};
/* DMA attributes for a cmd */
static ddi_dma_attr_t cmd_dma_attr = {
DMA_ATTR_V0, /* version of this structure */
0, /* lowest usable address */
0xffffffffU, /* highest usable address */
0xffffffffU, /* maximum DMAable byte count */
4, /* alignment in bytes */
0x100, /* burst sizes (any?) */
1, /* minimum transfer */
0xffffffffU, /* maximum transfer */
0xffffffffU, /* maximum segment length */
1, /* maximum number of segments */
1, /* granularity */
0, /* flags (reserved) */
};
/* DMA attributes for a rx buffer */
static ddi_dma_attr_t rx_buffer_dma_attr = {
DMA_ATTR_V0, /* version of this structure */
0, /* lowest usable address */
0xffffffffU, /* highest usable address */
0xffffffffU, /* maximum DMAable byte count */
0x100, /* alignment in bytes */
0x100, /* burst sizes (any?) */
1, /* minimum transfer */
0xffffffffU, /* maximum transfer */
0xffffffffU, /* maximum segment length */
1, /* maximum number of segments */
1, /* granularity */
0, /* flags (reserved) */
};
/*
* DMA attributes for a tx buffer.
* the maximum number of segments is 4 for the hardware.
* now all the wifi drivers put the whole frame in a single
* descriptor, so we define the maximum number of segments 1,
* just the same as the rx_buffer. we consider leverage the HW
* ability in the future, that is why we don't define rx and tx
* buffer_dma_attr as the same.
*/
static ddi_dma_attr_t tx_buffer_dma_attr = {
DMA_ATTR_V0, /* version of this structure */
0, /* lowest usable address */
0xffffffffU, /* highest usable address */
0xffffffffU, /* maximum DMAable byte count */
4, /* alignment in bytes */
0x100, /* burst sizes (any?) */
1, /* minimum transfer */
0xffffffffU, /* maximum transfer */
0xffffffffU, /* maximum segment length */
1, /* maximum number of segments */
1, /* granularity */
0, /* flags (reserved) */
};
/* DMA attributes for text and data part in the firmware */
static ddi_dma_attr_t fw_dma_attr = {
DMA_ATTR_V0, /* version of this structure */
0, /* lowest usable address */
0xffffffffU, /* highest usable address */
0x7fffffff, /* maximum DMAable byte count */
0x10, /* alignment in bytes */
0x100, /* burst sizes (any?) */
1, /* minimum transfer */
0xffffffffU, /* maximum transfer */
0xffffffffU, /* maximum segment length */
1, /* maximum number of segments */
1, /* granularity */
0, /* flags (reserved) */
};
/* regs access attributes */
static ddi_device_acc_attr_t iwk_reg_accattr = {
};
/* DMA access attributes */
static ddi_device_acc_attr_t iwk_dma_accattr = {
};
static int iwk_ring_init(iwk_sc_t *);
static void iwk_ring_free(iwk_sc_t *);
static int iwk_alloc_shared(iwk_sc_t *);
static void iwk_free_shared(iwk_sc_t *);
static int iwk_alloc_kw(iwk_sc_t *);
static void iwk_free_kw(iwk_sc_t *);
static int iwk_alloc_fw_dma(iwk_sc_t *);
static void iwk_free_fw_dma(iwk_sc_t *);
static int iwk_alloc_rx_ring(iwk_sc_t *);
static void iwk_reset_rx_ring(iwk_sc_t *);
static void iwk_free_rx_ring(iwk_sc_t *);
int, int);
static void iwk_node_free(ieee80211_node_t *);
static void iwk_mac_access_enter(iwk_sc_t *);
static void iwk_mac_access_exit(iwk_sc_t *);
uint32_t *, int);
static int iwk_load_firmware(iwk_sc_t *);
iwk_rx_data_t *);
iwk_rx_data_t *);
static uint8_t iwk_rate_to_plcp(int);
static int iwk_hw_set_before_auth(iwk_sc_t *);
static int iwk_config(iwk_sc_t *);
static void iwk_stop_master(iwk_sc_t *);
static int iwk_power_up(iwk_sc_t *);
static int iwk_preinit(iwk_sc_t *);
static void iwk_amrr_init(iwk_amrr_t *);
static void iwk_amrr_timeout(iwk_sc_t *);
static void iwk_amrr_ratectl(void *, ieee80211_node_t *);
struct iwk_eep_calib_channel_info *chan_info);
struct iwk_tx_power_db *tp_db);
static void iwk_write_event_log(iwk_sc_t *);
static void iwk_write_error_log(iwk_sc_t *);
/*
* GLD specific operations
*/
static int iwk_m_start(void *arg);
static void iwk_m_stop(void *arg);
static void iwk_watchdog(void *arg);
/*
* Supported rates for 802.11b/g modes (in 500Kbps unit).
* 11a and 11n support will be added later.
*/
static const struct ieee80211_rateset iwk_rateset_11b =
{ 4, { 2, 4, 11, 22 } };
static const struct ieee80211_rateset iwk_rateset_11g =
{ 12, { 2, 4, 11, 22, 12, 18, 24, 36, 48, 72, 96, 108 } };
/*
* For mfthread only
*/
extern pri_t minclsyspri;
#define DRV_NAME_4965 "iwk"
/*
* Module Loading Data & Entry Points
*/
static struct modldrv iwk_modldrv = {
"Intel(R) 4965AGN driver(N)",
};
static struct modlinkage iwk_modlinkage = {
};
int
_init(void)
{
int status;
sizeof (iwk_sc_t), 1);
if (status != DDI_SUCCESS)
return (status);
if (status != DDI_SUCCESS) {
}
return (status);
}
int
_fini(void)
{
int status;
if (status == DDI_SUCCESS) {
}
return (status);
}
int
{
}
/*
* Mac Call Back entries
*/
NULL,
NULL,
NULL,
};
#ifdef DEBUG
void
{
if (flags & iwk_dbg_flags) {
}
}
#endif
/*
* device operations
*/
int
{
char strbuf[32];
wifi_data_t wd = { 0 };
int intr_type;
int intr_count;
int intr_actual;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
err = DDI_FAILURE;
goto attach_fail1;
}
if (err != DDI_SUCCESS) {
"iwk_attach(): failed to allocate soft state\n");
goto attach_fail1;
}
if (err != DDI_SUCCESS) {
"iwk_attach(): failed to map config spaces regs\n");
goto attach_fail2;
}
/*
* Map operating registers
*/
if (err != DDI_SUCCESS) {
"iwk_attach(): failed to map device regs\n");
goto attach_fail2a;
}
"Fixed type interrupt is not supported\n");
goto attach_fail_intr_a;
}
"No fixed interrupts\n");
goto attach_fail_intr_a;
}
intr_count, &intr_actual, 0);
"ddi_intr_alloc() failed 0x%x\n", err);
goto attach_fail_intr_b;
}
if (err != DDI_SUCCESS) {
"ddi_intr_get_pri() failed 0x%x\n", err);
goto attach_fail_intr_c;
}
/*
* initialize the mfthread
*/
sc->sc_mf_thread_switch = 0;
/*
* Allocate shared page.
*/
if (err != DDI_SUCCESS) {
"failed to allocate shared page\n");
goto attach_fail3;
}
/*
* Allocate keep warm page.
*/
if (err != DDI_SUCCESS) {
"failed to allocate keep warm page\n");
goto attach_fail3a;
}
/*
* Do some necessary hardware initializations.
*/
if (err != DDI_SUCCESS) {
"failed to init hardware\n");
goto attach_fail4;
}
/* initialize EEPROM */
if (err != 0) {
goto attach_fail4;
}
goto attach_fail4;
}
if (err != DDI_SUCCESS) {
"failed to allocate and initialize ring\n");
goto attach_fail4;
}
if (err != DDI_SUCCESS) {
"failed to allocate firmware dma\n");
goto attach_fail5;
}
/*
* Initialize the wifi part, which will be used by
* generic layer
*/
/*
* use software WEP and TKIP, hardware CCMP;
*/
/*
*/
/*
* support Adhoc mode
*/
/* set supported .11b and .11g rates */
/* set supported .11b and .11g channels (1 through 11) */
for (i = 1; i <= 11; i++) {
}
/*
* init Wifi layer
*/
/*
* different instance has different WPA door
*/
/*
* Override 80211 default routines
*/
/*
* initialize default tx key
*/
ic->ic_def_txkey = 0;
if (err != DDI_SUCCESS) {
"add soft interrupt failed\n");
goto attach_fail7;
}
/*
* Add the interrupt handler
*/
if (err != DDI_SUCCESS) {
"ddi_intr_add_handle() failed\n");
goto attach_fail8;
}
if (err != DDI_SUCCESS) {
"ddi_intr_enable() failed\n");
goto attach_fail_intr_d;
}
/*
* Initialize pointer to device specific functions
*/
"iwk_attach(): failed to do mac_alloc()\n");
goto attach_fail9;
}
/*
* Register the macp to mac
*/
if (err != DDI_SUCCESS) {
"iwk_attach(): failed to do mac_register()\n");
goto attach_fail9;
}
/*
* Create minor node of type DDI_NT_NET_WIFI
*/
if (err != DDI_SUCCESS)
"iwk_attach(): failed to do ddi_create_minor_node()\n");
/*
* Notify link is down now
*/
/*
* create the mf thread to handle the link status,
* recovery fatal error, etc.
*/
return (DDI_SUCCESS);
return (err);
}
int
{
int err;
switch (cmd) {
case DDI_DETACH:
break;
case DDI_SUSPEND:
}
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
return (DDI_FAILURE);
if (err != DDI_SUCCESS)
return (err);
/*
* Destroy the mf_thread
*/
sc->sc_mf_thread_switch = 0;
break;
}
DELAY(500000);
/*
* Unregiste from the MAC layer subsystem
*/
/*
* detach ieee80211
*/
return (DDI_SUCCESS);
}
/*
* quiesce(9E) entry point.
*
* This function is called when the system is single-threaded at high
* PIL with preemption disabled. Therefore, this function must not be
* blocked.
*
* This function returns DDI_SUCCESS on success, or DDI_FAILURE on failure.
* DDI_FAILURE indicates an error condition and should almost never happen.
*/
int
{
/* no message prints and no lock accquisition */
#ifdef DEBUG
iwk_dbg_flags = 0;
#endif
return (DDI_SUCCESS);
}
static void
{
}
/*
* Allocate an area of memory and a DMA handle for accessing it
*/
static int
{
int err;
/*
* Allocate handle
*/
if (err != DDI_SUCCESS) {
return (DDI_FAILURE);
}
/*
* Allocate memory
*/
if (err != DDI_SUCCESS) {
return (DDI_FAILURE);
}
/*
* Bind the two together
*/
if (err != DDI_DMA_MAPPED) {
return (DDI_FAILURE);
}
return (DDI_SUCCESS);
}
/*
* Free one allocated area of DMAable memory
*/
static void
{
}
}
}
}
/*
*
*/
static int
{
int err = DDI_SUCCESS;
char *t;
/*
* firmware image layout:
* |HDR|<-TEXT->|<-DATA->|<-INIT_TEXT->|<-INIT_DATA->|<-BOOT->|
*/
&sc->sc_dma_fw_text);
if (err != DDI_SUCCESS) {
" text dma memory");
goto fail;
}
&sc->sc_dma_fw_data);
if (err != DDI_SUCCESS) {
" data dma memory");
goto fail;
}
&sc->sc_dma_fw_data_bak);
"size:%lx]\n",
if (err != DDI_SUCCESS) {
" data bakeup dma memory");
goto fail;
}
"size:%lx]\n",
if (err != DDI_SUCCESS) {
"init text dma memory");
goto fail;
}
"size:%lx]\n",
if (err != DDI_SUCCESS) {
"init data dma memory");
goto fail;
}
fail:
return (err);
}
static void
{
}
/*
* Allocate a shared page between host and NIC.
*/
static int
{
int err = DDI_SUCCESS;
/* must be aligned on a 4K-page boundary */
if (err != DDI_SUCCESS)
goto fail;
return (err);
fail:
return (err);
}
static void
{
}
/*
* Allocate a keep warm page.
*/
static int
{
int err = DDI_SUCCESS;
/* must be aligned on a 4K-page boundary */
if (err != DDI_SUCCESS)
goto fail;
return (err);
fail:
return (err);
}
static void
{
}
static int
{
int i, err = DDI_SUCCESS;
if (err != DDI_SUCCESS) {
goto fail;
}
/*
* Allocate Rx buffers.
*/
for (i = 0; i < RX_QUEUE_SIZE; i++) {
if (err != DDI_SUCCESS) {
"failed\n", i);
goto fail;
}
/*
* the physical address bit [8-36] are used,
* instead of bit [0-31] in 3945.
*/
}
"size:%lx]\n",
return (err);
fail:
return (err);
}
static void
{
int n;
for (n = 0; n < 2000; n++) {
break;
DELAY(1000);
}
if (n == 2000)
}
static void
{
int i;
for (i = 0; i < RX_QUEUE_SIZE; i++) {
}
}
static int
{
int i, err = DDI_SUCCESS;
TFD_QUEUE_SIZE_MAX * sizeof (iwk_tx_desc_t),
if (err != DDI_SUCCESS) {
"failed\n", qid);
goto fail;
}
TFD_QUEUE_SIZE_MAX * sizeof (iwk_cmd_t),
if (err != DDI_SUCCESS) {
"failed\n", qid);
goto fail;
}
/*
* Allocate Tx buffers.
*/
goto fail;
}
for (i = 0; i < TFD_QUEUE_SIZE_MAX; i++) {
if (err != DDI_SUCCESS) {
"buf[%d] failed\n", i);
goto fail;
}
/* ((i % slots) * sizeof (iwk_cmd_t)); */
}
"size:%lx]\n",
return (err);
fail:
sizeof (iwk_tx_data_t) * TFD_QUEUE_SIZE_MAX);
return (err);
}
static void
{
int i, n;
for (n = 0; n < 200; n++) {
break;
DELAY(10);
}
if (n == 200) {
}
}
}
/*ARGSUSED*/
static void
{
int i;
}
}
}
static int
{
int i, err = DDI_SUCCESS;
for (i = 0; i < IWK_NUM_QUEUES; i++) {
if (i == IWK_CMD_QUEUE_NUM)
continue;
i);
if (err != DDI_SUCCESS)
goto fail;
}
if (err != DDI_SUCCESS)
goto fail;
if (err != DDI_SUCCESS)
goto fail;
return (err);
fail:
return (err);
}
static void
{
int i = IWK_NUM_QUEUES;
while (--i >= 0) {
}
}
/* ARGSUSED */
static ieee80211_node_t *
{
}
static void
{
}
/*ARGSUSED*/
static int
{
int i, err = IWK_SUCCESS;
switch (nstate) {
case IEEE80211_S_SCAN:
switch (ostate) {
case IEEE80211_S_INIT:
{
sc->sc_scan_pending = 0;
/*
* clear association to receive beacons from
* all BSS'es
*/
sizeof (iwk_rxon_cmd_t), 1);
if (err != IWK_SUCCESS) {
"could not clear association\n");
return (err);
}
/* add broadcast node to send probe request */
sizeof (node), 1);
if (err != IWK_SUCCESS) {
"broadcast node\n");
return (err);
}
break;
}
case IEEE80211_S_AUTH:
case IEEE80211_S_ASSOC:
case IEEE80211_S_RUN:
sc->sc_scan_pending = 0;
/* FALLTHRU */
case IEEE80211_S_SCAN:
/* step to next channel before actual FW scan */
"could not initiate scan\n");
}
return (err);
default:
break;
}
break;
case IEEE80211_S_AUTH:
if (ostate == IEEE80211_S_SCAN) {
}
/* reset state to handle reassociations correctly */
/*
* before sending authentication and association request frame,
* we need do something in the hardware, such as setting the
* channel same to the target AP...
*/
"authentication\n");
return (err);
}
break;
case IEEE80211_S_RUN:
if (ostate == IEEE80211_S_SCAN) {
}
/* let LED blink when monitoring */
break;
}
/* IBSS mode */
/*
* clean all nodes in ibss node table
* in order to be consistent with hardware
*/
if (err != IWK_SUCCESS) {
"failed to update configuration "
"in IBSS mode\n");
return (err);
}
}
/* none IBSS mode */
/* update adapter's configuration */
if (err != IWK_SUCCESS) {
"failed to update configuration "
"in none IBSS mode\n");
return (err);
}
}
/* obtain current temperature of chipset */
/*
* make Tx power calibration to determine
* the gains of DSP and radio
*/
if (err) {
"failed to set tx power table\n");
return (err);
}
/*
* allocate and transmit beacon frames
*/
if (err != IWK_SUCCESS) {
"can't transmit beacon frames\n");
return (err);
}
}
/* start automatic rate control */
/* set rate to some reasonable initial value */
while (i > 0 && IEEE80211_RATE(i) > 72)
i--;
} else {
}
/* set LED on after associated */
break;
case IEEE80211_S_INIT:
if (ostate == IEEE80211_S_SCAN) {
}
/* set LED off after init */
break;
case IEEE80211_S_ASSOC:
if (ostate == IEEE80211_S_SCAN) {
}
break;
}
if (nstate == IEEE80211_S_RUN) {
/*
* make initialization for Receiver
* sensitivity calibration
*/
if (err) {
"failed to init RX sensitivity\n");
return (err);
}
/* make initialization for Receiver gain balance */
if (err) {
"failed to init phy calibration\n");
return (err);
}
}
return (err);
}
static void
iwk_watchdog(void *arg)
{
#ifdef DEBUG
#endif
return;
} else {
"node (0x%x), retry (%d)\n",
}
}
/*ARGSUSED*/
{
int err;
case IEEE80211_CIPHER_WEP:
case IEEE80211_CIPHER_TKIP:
return (1); /* sofeware do it. */
case IEEE80211_CIPHER_AES_CCM:
break;
default:
return (0);
}
if (IEEE80211_IS_MULTICAST(mac)) {
/*
* search for node in ibss node table
*/
index1++) {
mac)) {
break;
}
}
if (index1 >= IWK_BROADCAST_ID) {
"have no this node in hardware node table\n");
return (0);
} else {
/*
* configure key for given node in hardware
*/
if (k->wk_flags & IEEE80211_KEY_XMIT) {
} else {
}
sizeof (iwk_add_sta_t), 1);
if (err != IWK_SUCCESS) {
"failed to update IBSS node in hardware\n");
return (0);
}
}
return (1);
} else {
}
if (k->wk_flags & IEEE80211_KEY_XMIT) {
} else {
}
if (err != IWK_SUCCESS) {
"failed to update ap node\n");
return (0);
}
return (1);
}
/*
* exclusive access to mac begin.
*/
static void
{
int n;
/* wait until we succeed */
for (n = 0; n < 1000; n++) {
break;
DELAY(10);
}
if (n == 1000)
}
/*
* exclusive access to mac end.
*/
static void
{
}
static uint32_t
{
}
static void
{
}
static uint32_t
{
}
static void
{
}
static void
{
}
/*
* ucode load/initialization steps:
* 1) load Bootstrap State Machine (BSM) with "bootstrap" uCode image.
* BSM contains a small memory that *always* stays powered up, so it can
* retain the bootstrap program even when the card is in a power-saving
* power-down state. The BSM loads the small program into ARC processor's
* instruction memory when triggered by power-up.
* 2) load Initialize image via bootstrap program.
* The Initialize image sets up regulatory and calibration data for the
* The 4965 reply contains calibration data for temperature, voltage and tx gain
* correction.
*/
static int
{
int n, err = IWK_SUCCESS;
/*
* The physical address bit [4-35] of the initialize uCode.
* In the initialize alive notify interrupt the physical address of
* the runtime ucode will be set for loading.
*/
/* load bootstrap code into BSM memory */
/*
* prepare to load initialize uCode
*/
/* wait while the adapter is busy loading the firmware */
for (n = 0; n < 1000; n++) {
break;
DELAY(10);
}
if (n == 1000) {
return (err);
}
/* for future power-save mode use */
return (err);
}
/*ARGSUSED*/
static void
{
struct ieee80211_frame *wh;
int16_t t;
struct iwk_rx_non_cfg_phy *phyinfo;
/* assuming not 11n here. cope with 11n in phase-II */
return;
}
mrssi = 0;
for (i = 0; i < 3; i++) {
if (ants & (1 << i))
}
/*
* convert dBm to percentage ???
*/
(75 * 75);
if (rssi > 100)
rssi = 100;
if (rssi < 1)
rssi = 1;
"rate=%x chan=%d tstamp=%x non_cfg_phy_count=%x "
return;
}
/*
* discard Rx frames with bad CRC
*/
return;
}
wh = (struct ieee80211_frame *)
sc->sc_assoc_id));
}
#ifdef DEBUG
if (iwk_dbg_flags & IWK_DEBUG_RX)
#endif
if (mp) {
/* send the frame to the 802.11 layer */
} else {
sc->sc_rx_nobuf++;
"iwk_rx_intr(): alloc rx buf failed\n"));
}
/* release node reference */
}
/*ARGSUSED*/
static void
{
" retries=%d frame_count=%x nkill=%d "
"rate=%x duration=%d status=%x\n",
sc->sc_tx_retries++;
sc->sc_tx_retries));
}
sc->sc_tx_timer = 0;
sc->sc_need_reschedule = 0;
}
}
static void
{
return;
}
"qid=%x idx=%d flags=%x type=0x%x\n",
}
static void
{
struct iwk_alive_resp *ar =
/* the microcontroller is ready */
"microcode alive notification minor: %x major: %x type:"
" %x subtype: %x\n",
"microcontroller initialization failed\n"));
}
"initialization alive received.\n"));
sizeof (struct iwk_init_alive_resp));
/* XXX get temperature */
} else {
sizeof (struct iwk_alive_resp));
/*
* Init SCD related registers to make Tx work. XXX
*/
/* read sram address of data base */
/* clear and init SCD_CONTEXT_DATA_OFFSET area. 128 bytes */
i < 128; i += 4)
/* clear and init SCD_TX_STTS_BITMAP_OFFSET area. 256 bytes */
i < 256; i += 4)
/* clear and init SCD_TRANSLATE_TBL_OFFSET area. 32 bytes */
/* initiate the tx queues */
for (i = 0; i < IWK_NUM_QUEUES; i++) {
(SCD_WIN_SIZE & 0x7f));
SCD_CONTEXT_QUEUE_OFFSET(i) + sizeof (uint32_t),
}
/* interrupt enable on each queue0-7 */
/* enable each channel 0-7 */
SCD_TXFACT_REG_TXFIFO_MASK(0, 7));
/*
* queue 0-7 maps to FIFO 0-7 and
* all queues work under FIFO mode (none-scheduler-ack)
*/
for (i = 0; i < 7; i++) {
(1 << SCD_QUEUE_STTS_REG_POS_ACTIVE)|
(i << SCD_QUEUE_STTS_REG_POS_TXF)|
}
}
}
static uint_t
/* LINTED: argument unused in function: unused */
{
return (DDI_INTR_UNCLAIMED);
}
/* disable interrupts */
/*
* firmware has moved the index of the rx queue, driver get it,
* and deal with it.
*/
" cur = %d qid=%x idx=%d flags=%x type=%x len=%d\n",
/* a command other than a tx need to be replied */
case REPLY_4965_RX:
break;
case REPLY_TX:
break;
case REPLY_ALIVE:
break;
case CARD_STATE_NOTIFICATION:
{
/*
* the radio button has to be pushed(OFF). It
* is considered as a hw error, the
* iwk_thread() tries to recover it after the
* button is pushed again(ON)
*/
"iwk_rx_softintr(): "
"Radio transmitter is off\n");
IEEE80211_S_INIT, -1);
}
break;
}
case SCAN_START_NOTIFICATION:
{
"scanning channel %d status %x\n",
break;
}
{
"completed channel %d (burst of %d) status %02x\n",
sc->sc_scan_pending++;
break;
}
case STATISTICS_NOTIFICATION:
/* handle statistics notification */
break;
}
}
/*
* driver dealt with what reveived in rx queue and tell the information
* to the firmware.
*/
/* re-enable interrupts */
sc->sc_rx_softint_pending = 0;
return (DDI_INTR_CLAIMED);
}
static uint_t
/* LINTED: argument unused in function: unused */
{
return (DDI_INTR_UNCLAIMED);
}
if (r == 0 || r == 0xffffffff) {
return (DDI_INTR_UNCLAIMED);
}
/* disable interrupts */
/* ack interrupts */
return (DDI_INTR_CLAIMED);
}
if (r & (BIT_INT_SWERROR | BIT_INT_ERR)) {
#ifdef DEBUG
/* dump event and error logs to dmesg */
#endif /* DEBUG */
/* not capable of fast recovery */
if (!IWK_CHK_FAST_RECOVER(sc))
return (DDI_INTR_CLAIMED);
}
if (r & BIT_INT_RF_KILL) {
}
if ((r & (BIT_INT_FH_RX | BIT_INT_SW_RX)) ||
(rfh & FH_INT_RX_MASK)) {
}
if (r & BIT_INT_ALIVE) {
}
/* re-enable interrupts */
return (DDI_INTR_CLAIMED);
}
static uint8_t
iwk_rate_to_plcp(int rate)
{
switch (rate) {
/* CCK rates */
case 2:
ret = 0xa;
break;
case 4:
ret = 0x14;
break;
case 11:
ret = 0x37;
break;
case 22:
ret = 0x6e;
break;
/* OFDM rates */
case 12:
ret = 0xd;
break;
case 18:
ret = 0xf;
break;
case 24:
ret = 0x5;
break;
case 36:
ret = 0x7;
break;
case 48:
ret = 0x9;
break;
case 72:
ret = 0xb;
break;
case 96:
ret = 0x1;
break;
case 108:
ret = 0x3;
break;
default:
ret = 0;
break;
}
return (ret);
}
static mblk_t *
{
return (NULL);
}
return (NULL);
}
return (mp);
}
break;
}
}
return (mp);
}
/* ARGSUSED */
static int
{
struct ieee80211_frame *wh;
struct ieee80211_key *k = NULL;
if ((type & IEEE80211_FC0_TYPE_MASK) !=
}
goto exit;
}
if ((type & IEEE80211_FC0_TYPE_MASK) !=
}
sc->sc_tx_nobuf++;
goto exit;
}
hdrlen = sizeof (struct ieee80211_frame);
if (m == NULL) { /* can not alloc buf, drop this package */
"iwk_send(): failed to allocate msgbuf\n");
err = IWK_SUCCESS;
goto exit;
}
}
/*
* search for node in ibss node table
*/
for (index1 = IWK_STA_ID;
break;
}
}
/*
* if don't find in ibss node table
*/
if (index1 >= IWK_BROADCAST_ID) {
if (err != IWK_SUCCESS) {
"failed to clean all nodes "
"and add one node\n");
freemsg(m);
err = IWK_SUCCESS;
goto exit;
}
} else {
}
}
freemsg(m);
err = IWK_SUCCESS;
goto exit;
}
} else {
}
k = ieee80211_crypto_encap(ic, m);
if (k == NULL) {
freemsg(m);
err = IWK_SUCCESS;
goto exit;
}
}
/* packet header may have moved, reset our local pointer */
}
#ifdef DEBUG
if (iwk_dbg_flags & IWK_DEBUG_TX)
#endif
/* pickup a rate */
/* mgmt frames are sent at 1M */
} else {
/*
* do it here for the software way rate control.
* later for rate scaling in hardware.
* maybe like the following, for management frame:
* tx->initial_rate_index = LINK_QUAL_MAX_RETRY_NUM - 1;
* for data frame:
* tx->tx_flags |= (LE_32(TX_CMD_FLG_STA_RATE_MSK));
* rate = in->in_rates.ir_rates[in->in_txrate];
* tx->initial_rate_index = 1;
*
* now the txrate is determined in tx cmd flags, set to the
* max value 54M for 11g and 11M for 11b.
*/
} else {
}
}
/* retrieve destination node's id */
} else {
else
}
/* tell h/w to set timestamp in probe responses */
else
} else
tx->dram_lsb_ptr =
tx->dram_msb_ptr = 0;
tx->driver_txop = 0;
tx->next_frame_len = 0;
/*
* first segment includes the tx cmd plus the 802.11 header,
* the second includes the remaining of the 802.11 frame.
*/
"len1 = 0x%x, len2 = 0x%x val1 = 0x%x val2 = 0x%x",
/* kick ring */
}
freemsg(m);
/* release node reference */
if (sc->sc_tx_timer == 0)
exit:
return (err);
}
static void
{
enum ieee80211_opmode oldmod;
/*
* return to STA mode
*/
/* configure rxon */
case IEEE80211_M_STA:
break;
case IEEE80211_M_IBSS:
case IEEE80211_M_AHDEMO:
break;
case IEEE80211_M_HOSTAP:
break;
case IEEE80211_M_MONITOR:
break;
}
/* set antenna */
(0x6 << RXON_RX_CHAIN_FORCE_SEL_POS) |
(0x7 << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS));
sizeof (iwk_rxon_cmd_t), 1);
if (err1 != IWK_SUCCESS) {
"failed to set configure command"
" please run (ifconfig unplumb and"
" ifconfig plumb)\n");
}
/*
* set Tx power for 2.4GHz channels
* (need further investigation. fix tx power at present)
*/
for (i = 0; i < POWER_TABLE_NUM_HT_OFDM_ENTRIES; i++) {
s.ramon_tx_gain = 0x3f3f;
}
= 110 | (110 << 8);
sizeof (txpower), 1);
if (err1 != IWK_SUCCESS) {
" please run (ifconfig unplumb "
"and ifconfig plumb)\n");
}
/* add broadcast node so that we can send broadcast frame */
if (err1 != IWK_SUCCESS) {
"failed to add broadcast node\n");
}
/* TX_LINK_QUALITY cmd */
for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
masks &= ~RATE_MCS_ANT_A_MSK;
link_quality.rate_n_flags[i] =
}
sizeof (link_quality), 1);
if (err1 != IWK_SUCCESS) {
"failed to config link quality table\n");
}
}
/*
* This is special for the hidden AP connection.
* In any case, we should make sure only one 'scan'
* in the driver for a 'connect' CLI command. So
* when connecting to a hidden AP, the scan is just
* sent out to the air when we know the desired
* essid of the AP we want to connect.
*/
if (ic->ic_des_esslen) {
iwk_m_stop(sc);
(void) iwk_m_start(sc);
(void) ieee80211_new_state(ic,
IEEE80211_S_SCAN, -1);
}
}
}
}
/*
*/
/* ARGSUSED */
static int
{
int err = 0;
return (err);
}
static int
{
int err;
wldp_buf);
if (ic->ic_des_esslen) {
iwk_m_stop(sc);
(void) iwk_m_start(sc);
(void) ieee80211_new_state(ic,
IEEE80211_S_SCAN, -1);
}
}
err = 0;
}
return (err);
}
/*ARGSUSED*/
static int
{
switch (stat) {
case MAC_STAT_IFSPEED:
break;
case MAC_STAT_NOXMTBUF:
break;
case MAC_STAT_NORCVBUF:
break;
case MAC_STAT_IERRORS:
break;
case MAC_STAT_RBYTES:
break;
case MAC_STAT_IPACKETS:
break;
case MAC_STAT_OBYTES:
break;
case MAC_STAT_OPACKETS:
break;
case MAC_STAT_OERRORS:
case WIFI_STAT_TX_FAILED:
break;
case WIFI_STAT_TX_RETRANS:
break;
case WIFI_STAT_FCS_ERRORS:
case WIFI_STAT_WEP_ERRORS:
case WIFI_STAT_TX_FRAGS:
case WIFI_STAT_MCAST_TX:
case WIFI_STAT_RTS_SUCCESS:
case WIFI_STAT_RTS_FAILURE:
case WIFI_STAT_ACK_FAILURE:
case WIFI_STAT_RX_FRAGS:
case WIFI_STAT_MCAST_RX:
case WIFI_STAT_RX_DUPS:
default:
return (ENOTSUP);
}
return (IWK_SUCCESS);
}
static int
iwk_m_start(void *arg)
{
int err;
if (err != IWK_SUCCESS) {
/*
* The hw init err(eg. RF is OFF). Return Success to make
* the 'plumb' succeed. The iwk_thread() tries to re-init
* background.
*/
"hardware\n");
return (IWK_SUCCESS);
}
return (IWK_SUCCESS);
}
static void
iwk_m_stop(void *arg)
{
}
/*ARGSUSED*/
static int
{
int err;
if (err != IWK_SUCCESS) {
"iwk_m_unicst(): "
"failed to configure device\n");
goto fail;
}
}
return (IWK_SUCCESS);
fail:
return (err);
}
/*ARGSUSED*/
static int
{
return (IWK_SUCCESS);
}
/*ARGSUSED*/
static int
{
return (IWK_SUCCESS);
}
static void
{
while (sc->sc_mf_thread_switch) {
if (tmp & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW) {
} else {
}
/*
* If in SUSPEND or the RF is OFF, do nothing
*/
continue;
}
/*
* recovery fatal error
*/
"iwk_thread(): "
"try to recover fatal hw error: %d\n", times++));
if (IWK_CHK_FAST_RECOVER(sc)) {
/* save runtime configuration */
} else {
}
if (err != IWK_SUCCESS) {
n++;
if (n < 20)
continue;
}
n = 0;
if (!err)
if (!IWK_CHK_FAST_RECOVER(sc) ||
IEEE80211_S_SCAN, 0);
}
}
"iwk_thread(): lazy resume\n"));
/*
* NB: under WPA mode, this call hangs (door problem?)
* when called in iwk_attach() and iwk_detach() while
* system is in the procedure of CPR. To be safe, let
* the thread do this.
*/
}
"iwk_thread(): "
"wait for probe response\n"));
sc->sc_scan_pending--;
}
/*
* rate ctl
*/
clk = ddi_get_lbolt();
}
}
if (sc->sc_tx_timer) {
timeout++;
if (timeout == 10) {
sc->sc_tx_timer--;
if (sc->sc_tx_timer == 0) {
"iwk_thread(): try to recover from"
" 'send fail\n"));
}
timeout = 0;
}
}
}
}
/*
* Send a command to the firmware.
*/
static int
{
/* kick cmd ring XXX */
}
if (async)
return (IWK_SUCCESS);
else {
0)
break;
}
return (IWK_SUCCESS);
else
return (IWK_FAIL);
}
}
static void
{
}
static int
{
struct ieee80211_rateset rs;
int i, err;
"channel (%d) isn't in proper range\n",
return (IWK_FAIL);
}
/* update adapter's configuration according the info of target AP */
} else { /* assume 802.11b/g */
}
else
else
"filter_flags %x cck %x ofdm %x"
" bssid:%02x:%02x:%02x:%02x:%02x:%2x\n",
sizeof (iwk_rxon_cmd_t), 1);
if (err != IWK_SUCCESS) {
" failed to config chan%d\n",
return (err);
}
/* obtain current temperature of chipset */
/* make Tx power calibration to determine the gains of DSP and radio */
if (err) {
"failed to set tx power table\n");
return (err);
}
/* add default AP node */
if (err != IWK_SUCCESS) {
"failed to add BSS node\n");
return (err);
}
/* TX_LINK_QUALITY cmd */
for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
else
rate = 2;
masks &= ~RATE_MCS_ANT_A_MSK;
link_quality.rate_n_flags[i] =
}
sizeof (link_quality), 1);
if (err != IWK_SUCCESS) {
"failed to config link quality table\n");
return (err);
}
return (IWK_SUCCESS);
}
/*
* Send a scan request(assembly scan cmd) to the firmware.
*/
static int
{
struct ieee80211_frame *wh;
struct ieee80211_rateset *rs;
enum ieee80211_phymode mode;
(0x6 << RXON_RX_CHAIN_FORCE_SEL_POS) |
(0x7 << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS));
if (ic->ic_des_esslen) {
ic->ic_des_esslen);
} else {
}
/*
* a probe request frame is required after the REPLY_SCAN_CMD
*/
/* essid IE */
essid));
}
*frm++ = IEEE80211_ELEMID_SSID;
/* supported rates IE */
*frm++ = IEEE80211_ELEMID_RATES;
if (nrates > IEEE80211_RATE_SIZE)
/* supported xrates IE */
*frm++ = IEEE80211_ELEMID_XRATES;
}
/* optionnal IE (usually for wpa) */
}
/* setup length of probe request */
/*
* the attribute of the scan channels are required after the probe
* request frame.
*/
if (ic->ic_des_esslen) {
} else {
}
frm += sizeof (iwk_scan_chan_t);
}
/*
* maybe for cmd, filling the byte cnt table is not necessary.
* anyway, we fill it here.
*/
}
/* kick cmd ring */
return (IWK_SUCCESS);
}
static int
{
int i, err;
/*
* set power mode. Disable power management at present, do it later
*/
sizeof (powertable), 0);
if (err != IWK_SUCCESS) {
return (err);
}
/* configure bt coexistence */
sizeof (bt), 0);
if (err != IWK_SUCCESS) {
"iwk_config(): "
"failed to configurate bt coexistence\n");
return (err);
}
/* configure rxon */
case IEEE80211_M_STA:
break;
case IEEE80211_M_IBSS:
case IEEE80211_M_AHDEMO:
break;
case IEEE80211_M_HOSTAP:
break;
case IEEE80211_M_MONITOR:
break;
}
/* set antenna */
(0x6 << RXON_RX_CHAIN_FORCE_SEL_POS) |
(0x7 << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS));
sizeof (iwk_rxon_cmd_t), 0);
if (err != IWK_SUCCESS) {
"failed to set configure command\n");
return (err);
}
/* obtain current temperature of chipset */
/* make Tx power calibration to determine the gains of DSP and radio */
if (err) {
"failed to set tx power table\n");
return (err);
}
/* add broadcast node so that we can send broadcast frame */
if (err != IWK_SUCCESS) {
"failed to add broadcast node\n");
return (err);
}
/* TX_LINK_QUALITY cmd ? */
for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
masks &= ~RATE_MCS_ANT_A_MSK;
}
sizeof (link_quality), 0);
if (err != IWK_SUCCESS) {
"failed to config link quality table\n");
return (err);
}
return (IWK_SUCCESS);
}
static void
{
int n;
if ((tmp & CSR_GP_CNTRL_REG_MSK_POWER_SAVE_TYPE) ==
return;
for (n = 0; n < 2000; n++) {
break;
DELAY(1000);
}
if (n == 2000)
"timeout waiting for master stop\n"));
}
static int
{
DELAY(5000);
return (IWK_SUCCESS);
}
static int
{
int n;
/* clear any pending interrupts */
/* wait for clock ready */
for (n = 0; n < 1000; n++) {
break;
DELAY(10);
}
if (n == 1000) {
"iwk_preinit(): timeout waiting for clock ready\n");
return (ETIMEDOUT);
}
DELAY(20);
(void) iwk_power_up(sc);
}
vlink & ~2);
/* make sure power supply on each part of the hardware */
DELAY(5);
return (IWK_SUCCESS);
}
/*
* set up semphore flag to own EEPROM
*/
{
return (IWK_SUCCESS);
DELAY(10000);
}
}
return (IWK_FAIL);
}
/*
* reset semphore flag to release EEPROM
*/
{
tmp & (~CSR_HW_IF_CONFIG_REG_EEP_SEM));
}
/*
* This function load all infomation in eeprom into iwk_eep
* structure in iwk_sc_t structure
*/
{
int i, rr;
/* read eeprom gp register in CSR */
if ((eep_gp & CSR_EEPROM_GP_VALID_MSK) ==
return (IWK_FAIL);
}
if (rr != 0) {
return (IWK_FAIL);
}
for (i = 0; i < 10; i++) {
if (rv & 1)
break;
DELAY(10);
}
if (!(rv & 1)) {
return (IWK_FAIL);
}
}
return (IWK_SUCCESS);
}
/*
* init mac address in ieee80211com_t struct
*/
{
}
static int
{
(void) iwk_preinit(sc);
if (!(tmp & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)) {
goto fail1;
}
/* init Rx ring */
/* init Tx rings */
/* keep warm page */
}
/* clear "radio off" and "disable command" bits */
/* clear any pending interrupts */
/* enable interrupts */
/*
* backup ucode data part for future use.
*/
for (n = 0; n < 2; n++) {
/* load firmware init segment into NIC */
if (err != IWK_SUCCESS) {
"failed to setup boot firmware\n");
continue;
}
/* now press "execute" start running */
break;
}
if (n == 2) {
goto fail1;
}
/* ..and wait at most one second for adapter to initialize */
break;
}
"iwk_init(): timeout waiting for firmware init\n");
goto fail1;
}
/*
* at this point, the firmware is loaded OK, then config the hardware
* with the ucode API, including rxon, txpower, etc.
*/
if (err) {
goto fail1;
}
/* at this point, hardware may receive beacons :) */
return (IWK_SUCCESS);
return (err);
}
static void
{
int i;
/* disable interrupts */
/* reset all Tx rings */
for (i = 0; i < IWK_NUM_QUEUES; i++)
/* reset Rx ring */
DELAY(5);
sc->sc_tx_timer = 0;
sc->sc_scan_pending = 0;
}
/*
* Naive implementation of the Adaptive Multi Rate Retry algorithm:
* "IEEE 802.11 Rate Adaptation: A Practical Approach"
* Mathieu Lacage, Hossein Manshaei, Thierry Turletti
* INRIA Sophia - Projet Planete
*/
#define is_success(amrr) \
#define is_failure(amrr) \
#define is_min_rate(in) \
#define is_max_rate(in) \
#define increase_rate(in) \
#define decrease_rate(in) \
#define IWK_AMRR_MIN_SUCCESS_THRESHOLD 1
#define IWK_AMRR_MAX_SUCCESS_THRESHOLD 15
static void
{
}
static void
{
else
}
/* ARGSUSED */
static void
{
int need_change = 0;
!is_max_rate(in)) {
"AMRR increasing rate %d (txcnt=%d retrycnt=%d)\n",
need_change = 1;
} else {
}
} else if (is_failure(amrr)) {
if (!is_min_rate(in)) {
if (amrr->success_threshold >
} else {
}
"AMRR decreasing rate %d (txcnt=%d retrycnt=%d)\n",
need_change = 1;
}
}
}
/*
* calculate 4965 chipset's kelvin temperature according to
* the data of init alive and satistics notification.
* The details is described in iwk_calibration.h file
*/
{
if (iwk_is_fat_channel(sc)) {
} else {
}
(31-23)) >> (31-23);
} else {
}
"failed to calculate temperature"
"because r3 = r1\n");
return (DDI_FAILURE);
}
return (tempera);
}
/* Determine whether 4965 is using 2.4 GHz band */
{
}
/* Determine whether 4965 is using fat channel */
{
}
/*
* In MIMO mode, determine which group 4965's current channel belong to.
* For more infomation about "channel group",
* please refer to iwk_calibration.h file
*/
{
if (channel >= CALIB_IWK_TX_ATTEN_GR5_FCH &&
return (CALIB_CH_GROUP_5);
}
if (channel >= CALIB_IWK_TX_ATTEN_GR1_FCH &&
return (CALIB_CH_GROUP_1);
}
if (channel >= CALIB_IWK_TX_ATTEN_GR2_FCH &&
return (CALIB_CH_GROUP_2);
}
if (channel >= CALIB_IWK_TX_ATTEN_GR3_FCH &&
return (CALIB_CH_GROUP_3);
}
if (channel >= CALIB_IWK_TX_ATTEN_GR4_FCH &&
return (CALIB_CH_GROUP_4);
}
"can't find txpower group for channel %d.\n", channel);
return (DDI_FAILURE);
}
/* 2.4 GHz */
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14
};
/* 5.2 GHz bands */
183, 184, 185, 187, 188, 189, 192, 196, 7, 8, 11, 12, 16
};
34, 36, 38, 40, 42, 44, 46, 48, 52, 56, 60, 64
};
100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140
};
145, 149, 153, 157, 161, 165
};
1, 2, 3, 4, 5, 6, 7
};
36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157
};
/* Get regulatory data from eeprom for a given channel */
{
int32_t i;
if (is_fat) { /* 11n mode */
if (is_hi_chan) {
} else {
}
for (i = 0; i < 7; i++) {
if (iwk_eep_band_6[i] == chan) {
}
}
for (i = 0; i < 11; i++) {
if (iwk_eep_band_7[i] == chan) {
}
}
} else if (is_24G) { /* 2.4 GHz band */
for (i = 0; i < 14; i++) {
if (iwk_eep_band_1[i] == channel) {
}
}
} else { /* 5 GHz band */
for (i = 0; i < 13; i++) {
if (iwk_eep_band_2[i] == channel) {
}
}
for (i = 0; i < 12; i++) {
if (iwk_eep_band_3[i] == channel) {
}
}
for (i = 0; i < 11; i++) {
if (iwk_eep_band_4[i] == channel) {
}
}
for (i = 0; i < 6; i++) {
if (iwk_eep_band_5[i] == channel) {
}
}
}
return (NULL);
}
/*
* Determine which subband a given channel belongs
* to in 2.4 GHz or 5 GHz band
*/
{
continue;
}
if ((channel >=
(channel <=
break;
}
}
return (b_n);
}
/* Make a special division for interpolation operation */
{
if (num < 0) {
}
if (denom < 0) {
}
return (IWK_SUCCESS);
}
/* Make interpolation operation */
{
return (y1);
} else {
}
}
/* Get interpolation measurement data of a given channel for all chains. */
struct iwk_eep_calib_channel_info *chan_info)
{
int32_t c, m;
/* determine subband number */
if (ban_n >= EEP_TX_POWER_BANDS) {
return (DDI_FAILURE);
}
ch1_n =
ch2_n =
/*
* go through all chains on chipset
*/
for (c = 0; c < EEP_TX_POWER_TX_CHAINS; c++) {
/*
* go through all factory measurements
*/
for (m = 0; m < EEP_TX_POWER_MEASUREMENTS; m++) {
m1_p =
m2_p =
/*
* make interpolation to get actual
* Tx power for given channel
*/
/* make interpolation to get index into gain table */
/* make interpolation to get chipset temperature */
/*
* make interpolation to get power
* amp detector level
*/
}
}
return (IWK_SUCCESS);
}
/*
* Calculate voltage compensation for Tx power. For more infomation,
* please refer to iwk_calibration.h file
*/
{
if ((TX_POWER_IWK_ILLEGAL_VOLTAGE == eep_voltage) ||
return (vol_comp);
}
if (curr_voltage > eep_voltage) {
vol_comp *= 2;
}
vol_comp = 0;
}
return (vol_comp);
}
/*
* Thermal compensation values for txpower for various frequency ranges ...
* ratios from 3:1 to 4.5:1 of degrees (Celsius) per half-dB gain adjust
*/
static struct iwk_txpower_tempera_comp {
{9, 2}, /* group 0 5.2, ch 34-43 */
{4, 1}, /* group 1 5.2, ch 44-70 */
{4, 1}, /* group 2 5.2, ch 71-124 */
{4, 1}, /* group 3 5.2, ch 125-200 */
{3, 1} /* group 4 2.4, ch all */
};
/*
* bit-rate-dependent table to prevent Tx distortion, in half-dB units,
* for OFDM 6, 12, 18, 24, 36, 48, 54, 60 MBit, and CCK all rates.
*/
static int32_t back_off_table[] = {
10, 10, 10, 10, 10, 15, 17, 20, /* OFDM SISO 20 MHz */
10, 10, 10, 10, 10, 15, 17, 20, /* OFDM MIMO 20 MHz */
10, 10, 10, 10, 10, 15, 17, 20, /* OFDM SISO 40 MHz */
10, 10, 10, 10, 10, 15, 17, 20, /* OFDM MIMO 40 MHz */
10 /* CCK */
};
/* determine minimum Tx power index in gain table */
{
return (MIN_TX_GAIN_INDEX_52GHZ_EXT);
}
return (MIN_TX_GAIN_INDEX);
}
/*
* Determine DSP and radio gain according to temperature and other factors.
* This function is the majority of Tx power calibration
*/
struct iwk_tx_power_db *tp_db)
{
int c, r;
struct iwk_eep_channel *eep_chan_p;
struct iwk_eep_calib_measure *measure_p;
/* 2.4 GHz or 5 GHz band */
/* fat channel or not */
/*
* using low half channel number or high half channel number
* identify fat channel
*/
is_high_chan = 1;
}
/* get regulatory channel data from eeprom */
if (NULL == eep_chan_p) {
"iwk_txpower_table_cmd_init(): "
"can't get channel infomation\n");
return (DDI_FAILURE);
}
} else {
"channel(%d) isn't in proper range\n",
channel);
return (DDI_FAILURE);
}
/* initial value of Tx power */
"user TX power is too weak\n");
return (DDI_FAILURE);
"user TX power is too strong\n");
return (DDI_FAILURE);
}
/* determine which group current channel belongs to */
if (tx_grp < 0) {
return (tx_grp);
}
if (is_fat) {
if (is_high_chan) {
channel -= 2;
} else {
channel += 2;
}
}
/* determine saturation power */
if (is_24G) {
} else {
}
if (is_24G) {
} else {
}
}
/* determine regulatory power */
if ((regu_power < IWK_TX_POWER_REGULATORY_MIN) ||
if (is_24G) {
} else {
}
}
/*
* get measurement data for current channel
* suach as temperature,index to gain table,actual Tx power
*/
/* calculate voltage compensation to Tx power */
} else {
}
} else {
}
for (c = 0; c < 2; c++) { /* go through all chains */
/* determine temperature compensation to Tx power */
(void) iwk_division(
degrees_per_05db_num, &tempera_comp[c]);
}
/*
* go through all rate entries in Tx power table
*/
for (r = 0; r < POWER_TABLE_NUM_ENTRIES; r++) {
if (r & 0x8) {
/* need to lower regulatory power for MIMO mode */
is_mimo = 1;
} else {
is_mimo = 0;
}
if (power_limit > curr_regu_power) {
/* final Tx power limit */
}
if (target_power > power_limit) {
}
for (c = 0; c < 2; c++) { /* go through all Tx chains */
if (is_mimo) {
} else {
atten_value = 0;
}
/*
* calculate index in gain table
* this step is very important
*/
(target_power - interpo_actual_pow[c]) -
tempera_comp[c] - voltage_compensation +
if (txpower_gains_idx <
iwk_min_power_index(r, is_24G)) {
}
if (!is_24G) {
/*
* support negative index for 5 GHz
* band
*/
txpower_gains_idx += 9;
}
if (POWER_TABLE_CCK_ENTRY == r) {
/* for CCK mode, make necessary attenuaton */
}
if (txpower_gains_idx > 107) {
txpower_gains_idx = 107;
} else if (txpower_gains_idx < 0) {
txpower_gains_idx = 0;
}
/* search DSP and radio gains in gain table */
txpower_gains.s.radio_tx_gain[c] =
txpower_gains.s.dsp_predis_atten[c] =
"rate_index: %d, "
"gain_index %d, c: %d,is_mimo: %d\n",
r, txpower_gains_idx, c, is_mimo));
}
/* initialize Tx power table */
if (r < POWER_TABLE_NUM_HT_OFDM_ENTRIES) {
} else {
}
}
return (IWK_SUCCESS);
}
/*
* make Tx power calibration to adjust Tx power.
* This is completed by sending out Tx power table command.
*/
{
int rv;
return (IWK_SUCCESS);
}
/* necessary initialization to Tx power table command */
cmd.channel_normal_width = 0;
/* initialize Tx power table */
if (rv) {
return (rv);
}
/* send out Tx power table command */
if (rv) {
return (rv);
}
/* record current temperature */
return (IWK_SUCCESS);
}
/* This function is the handler of statistics notification from uCode */
{
int is_diff;
struct iwk_notif_statistics *statistics_p =
/* update statistics data */
sizeof (struct iwk_notif_statistics));
/* make Receiver gain balance calibration */
(void) iwk_rxgain_diff(sc);
/* make Receiver sensitivity calibration */
(void) iwk_rx_sens(sc);
}
if (!is_diff) {
return;
}
/* calibration current temperature of 4965 chipset */
/* distinct temperature change will trigger Tx power calibration */
/* make Tx power calibration */
(void) iwk_tx_power_calibration(sc);
}
}
/* Determine this station is in associated state or not */
{
}
/* Make necessary preparation for Receiver gain balance calibration */
{
int i, rv;
struct iwk_calibration_cmd cmd;
struct iwk_rx_gain_diff *gain_diff_p;
for (i = 0; i < RX_CHAINS_NUM; i++) {
}
if (iwk_is_associated(sc)) {
cmd.diff_gain_a = 0;
cmd.diff_gain_b = 0;
cmd.diff_gain_c = 0;
/* assume the gains of every Rx chains is balanceable */
sizeof (cmd), 1);
if (rv) {
return (rv);
}
}
return (IWK_SUCCESS);
}
/*
* make Receiver gain balance to balance Rx gain between Rx chains
* and determine which chain is disconnected
*/
{
int max_beacon_chain_n;
int min_noise_chain_n;
struct iwk_calibration_cmd cmd;
struct statistics_rx_non_phy *rx_general_p =
if (INTERFERENCE_DATA_AVAILABLE !=
return (IWK_SUCCESS);
}
return (IWK_SUCCESS);
}
!is_24G)) {
return (IWK_SUCCESS);
}
/* Rx chain's noise strength from statistics notification */
/* Rx chain's beacon strength from statistics notification */
/* accumulate chain's noise strength */
/* accumulate chain's beacon strength */
/* calculate average beacon strength */
/* calculate average noise strength */
/* determine maximum beacon strength among 3 chains */
max_beacon_chain_n = 0;
max_beacon_chain_n = 1;
} else {
max_beacon_chain_n = 2;
}
/* determine which chain is disconnected */
for (i = 0; i < RX_CHAINS_NUM; i++) {
if (i != max_beacon_chain_n) {
beacon_aver[i];
if (beacon_diff > MAX_ALLOWED_DIFF) {
} else {
(1 << i);
}
}
}
/*
* if chain A and B are both disconnected,
* assume the stronger in beacon strength is connected
*/
if (gain_diff_p->disconnect_chain[0] &&
gain_diff_p->disconnect_chain[0] = 0;
} else {
}
}
/* determine minimum noise strength among 3 chains */
if (!gain_diff_p->disconnect_chain[0]) {
min_noise_chain_n = 0;
for (i = 0; i < RX_CHAINS_NUM; i++) {
if (!gain_diff_p->disconnect_chain[i] &&
(noise_aver[i] <=
min_noise_chain_n = i;
}
}
} else {
min_noise_chain_n = 1;
for (i = 0; i < RX_CHAINS_NUM; i++) {
if (!gain_diff_p->disconnect_chain[i] &&
(noise_aver[i] <=
min_noise_chain_n = i;
}
}
}
/* determine gain difference between chains */
for (i = 0; i < RX_CHAINS_NUM; i++) {
if (!gain_diff_p->disconnect_chain[i] &&
gain_diff_p->gain_diff_chain[i])) {
noise_diff = noise_aver[i] -
gain_diff_p->gain_diff_chain[i] =
}
} else {
gain_diff_p->gain_diff_chain[i] = 0;
}
}
if (!gain_diff_p->gain_diff_send) {
/*
* send out PHY calibration command to
* adjust every chain's Rx gain
*/
if (rv) {
return (rv);
}
}
gain_diff_p->beacon_stren_a = 0;
gain_diff_p->beacon_stren_b = 0;
gain_diff_p->beacon_stren_c = 0;
gain_diff_p->noise_stren_a = 0;
gain_diff_p->noise_stren_b = 0;
gain_diff_p->noise_stren_c = 0;
}
return (IWK_SUCCESS);
}
/* Make necessary preparation for Receiver sensitivity calibration */
{
int i, rv;
struct iwk_rx_sensitivity_cmd cmd;
rx_sens_p->cck_beacon_idx = 0;
for (i = 0; i < 10; i++) {
rx_sens_p->cck_beacon_min[i] = 0;
}
rx_sens_p->cck_noise_idx = 0;
rx_sens_p->cck_noise_ref = 0;
for (i = 0; i < 20; i++) {
rx_sens_p->cck_noise_max[i] = 0;
}
rx_sens_p->cck_noise_diff = 0;
/* at first, set up Rx to maximum sensitivity */
if (rv) {
"in the process of initialization, "
"failed to send rx sensitivity command\n");
return (rv);
}
return (IWK_SUCCESS);
}
/*
* make Receiver sensitivity calibration to adjust every chain's Rx sensitivity.
* for more infomation, please refer to iwk_calibration.h file
*/
{
int rv;
struct statistics_rx_non_phy *rx_general_p =
struct iwk_rx_sensitivity_cmd cmd;
"sensitivity initialization has not finished.\n");
return (DDI_FAILURE);
}
if (INTERFERENCE_DATA_AVAILABLE !=
"can't make rx sensitivity calibration,"
"because of invalid statistics\n");
return (DDI_FAILURE);
}
if (!actual_rx_time) {
"can't make rx sensitivity calibration,"
"because has not enough rx time\n"));
return (DDI_FAILURE);
}
/* make Rx sensitivity calibration for OFDM mode */
if (rv) {
return (rv);
}
/* make Rx sensitivity calibration for CCK mode */
if (rv) {
return (rv);
}
/*
* if the sum of false alarm had not changed, nothing will be done
*/
return (IWK_SUCCESS);
}
/*
* send sensitivity command to complete actual sensitivity calibration
*/
if (rv) {
"fail to send rx sensitivity command\n");
return (rv);
}
return (IWK_SUCCESS);
}
/*
* make Rx sensitivity calibration for CCK mode.
* This is preparing parameters for Sensitivity command
*/
{
int i;
struct statistics_rx_non_phy *rx_general_p =
/* accumulate false alarm */
} else {
}
/* accumulate bad plcp */
} else {
}
/*
* calculate relative value
*/
rx_sens_p->cck_noise_diff = 0;
noise_a =
noise_b =
noise_c =
/* determine maximum noise among 3 chains */
} else {
}
/* record maximum noise among 3 chains */
rx_sens_p->cck_noise_idx = 0;
}
/* determine maximum noise among 20 max noise */
for (i = 0; i < 20; i++) {
}
}
/* determine minimum beacon among 3 chains */
} else {
}
/* record miminum beacon among 3 chains */
rx_sens_p->cck_beacon_idx = 0;
}
/* determine maximum beacon among 10 miminum beacon among 3 chains */
for (i = 0; i < 10; i++) {
}
}
/* add a little margin */
max_beacon_10 += 6;
/* record the count of having no false alarms */
} else {
}
/*
* adjust parameters in sensitivity command
* according to different status.
* for more infomation, please refer to iwk_calibration.h file
*/
}
}
} else {
} else {
}
}
} else {
}
} else {
}
} else {
}
} else {
}
} else {
}
} else {
}
}
}
return (IWK_SUCCESS);
}
/*
* make Rx sensitivity calibration for OFDM mode.
* This is preparing parameters for Sensitivity command
*/
{
/* accumulate false alarm */
} else {
}
/* accumulate bad plcp */
} else {
}
/*
* adjust parameter in sensitivity command according to different status
*/
} else {
}
return (IWK_SUCCESS);
}
/*
* additional process to management frames
*/
struct ieee80211_node *in,
{
struct ieee80211_frame *wh;
int err;
switch (subtype) {
}
if (err != IWK_SUCCESS) {
"failed to TX beacon.\n");
}
}
/*
* search for node in ibss node table
*/
index1++) {
break;
}
}
/*
* if don't find in ibss node table
*/
if (index1 >= IWK_BROADCAST_ID) {
if (err != IWK_SUCCESS) {
"failed to clean all nodes "
"and add one node\n");
}
}
}
break;
break;
}
}
/*
* 1) log_event_table_ptr indicates base of the event log. This traces
* a 256-entry history of uCode execution within a circular buffer.
* Its header format is:
*
* uint32_t log_size; log capacity (in number of entries)
* uint32_t type; (1) timestamp with each entry, (0) no timestamp
* uint32_t wraps; # times uCode has wrapped to top of circular buffer
* uint32_t write_index; next circular buffer entry that uCode would fill
*
* The header is followed by the circular buffer of log entries. Entries
* with timestamps have the following format:
*
* uint32_t event_id; range 0 - 1500
* uint32_t timestamp; low 32 bits of TSF (of network, if associated)
* uint32_t data; event_id-specific data value
*
* Entries without timestamps contain only event_id and data.
*/
/*
* iwk_write_event_log - Write event log to dmesg
*/
{
uint32_t i, n, num_events;
/* the top of circular buffer */
if (!(log_event_table_ptr)) {
return;
}
/* Read log header */
sizeof (uint32_t); /* addr of start of log data */
return;
}
if (!wraps) {
num_events = idx;
} else {
}
for (i = 0; i < num_events; i++) {
if (type == 0) { /* no timestamp */
} else { /* timestamp */
printf("Time=%d, Event ID=%d, Data=0x%x\n",
"Time=%d, Event ID=%d, Data=0x%x\n",
}
}
/*
* Print the wrapped around entries, if any
*/
if (wraps) {
for (i = 0; i < idx; i++) {
if (type == 0) { /* no timestamp */
} else { /* timestamp */
"Time = %d, Event ID=%d, Data=0x%x\n",
}
}
}
}
/*
* error_event_table_ptr indicates base of the error log. This contains
* information about any uCode error that occurs. For 4965, the format is:
*
* uint32_t valid; (nonzero) valid, (0) log is empty
* uint32_t error_id; type of error
* uint32_t pc; program counter
* uint32_t blink1; branch link
* uint32_t blink2; branch link
* uint32_t ilink1; interrupt link
* uint32_t ilink2; interrupt link
* uint32_t data1; error-specific data
* uint32_t data2; error-specific data
* uint32_t line; source code line of error
* uint32_t bcon_time; beacon timer
* uint32_t tsf_low; network timestamp function timer
* uint32_t tsf_hi; network timestamp function timer
*/
/*
* iwk_write_error_log - Write error log to dmesg
*/
{
if (!(err_ptr)) {
return;
}
if (!(valid)) {
return;
}
}
static int
{
int i, err = IWK_SUCCESS;
/*
* clean all nodes in ibss node table assure be
* consistent with hardware
*/
for (i = IWK_STA_ID; i < IWK_STATION_COUNT; i++) {
0,
sizeof (iwk_add_sta_t));
}
/*
* configure RX and TX
*/
} else {
}
}
}
sizeof (iwk_rxon_cmd_t), 1);
if (err != IWK_SUCCESS) {
"failed to update configuration.\n");
return (err);
}
return (err);
}
static int
{
int err = IWK_SUCCESS;
/* update adapter's configuration */
"associate ID mismatch: expected %d, "
"got %d\n",
}
/*
* negotiated when associating
*/
" filter_flags %x\n",
sizeof (iwk_rxon_cmd_t), 1);
if (err != IWK_SUCCESS) {
"failed to update configuration\n");
return (err);
}
return (err);
}
static int
{
int err;
/* restore runtime configuration */
/* reset state to handle reassociations correctly */
"failed to setup authentication\n");
return (err);
}
/* update adapter's configuration */
if (err != IWK_SUCCESS) {
"failed to setup association\n");
return (err);
}
/* obtain current temperature of chipset */
/*
* make Tx power calibration to determine
* the gains of DSP and radio
*/
if (err) {
"failed to set tx power table\n");
return (err);
}
/*
* make initialization for Receiver
* sensitivity calibration
*/
if (err) {
"failed to init RX sensitivity\n");
return (err);
}
/* make initialization for Receiver gain balance */
if (err) {
"failed to init phy calibration\n");
return (err);
}
/* set LED on */
/* update keys */
for (int i = 0; i < IEEE80211_KEY_MAX; i++) {
continue;
/* failure */
if (err == 0) {
"failed to setup hardware keys\n");
return (IWK_FAIL);
}
}
}
/* start queue */
return (IWK_SUCCESS);
}
static int
{
int err = IWK_SUCCESS;
int rate;
/*
* allocate and transmit beacon frames
*/
(void) memset(tx_beacon_p, 0,
sizeof (iwk_tx_beacon_cmd_t));
rate = 0;
masks = 0;
LE_32(0xffffffff);
}
"failed to get beacon frame.\n");
return (IWK_FAIL);
}
sizeof (iwk_tx_cmd_t) +
/*
* beacons are sent at 1M
*/
22 == rate) {
}
} else {
mp, 0)) {
}
1);
if (err != IWK_SUCCESS) {
"failed to TX beacon.\n");
return (err);
}
}
return (err);
}
static int
{
int i, rate;
struct ieee80211_rateset rs;
int err = IWK_SUCCESS;
/*
* find a location that is not
* used in ibss node table
*/
for (index = IWK_STA_ID;
break;
}
}
/*
* if have too many nodes in hardware, clean up
*/
if (index < IWK_BROADCAST_ID &&
"failed to remove all nodes in hardware\n");
return (IWK_FAIL);
}
for (i = IWK_STA_ID; i < IWK_STATION_COUNT; i++) {
0, sizeof (iwk_add_sta_t));
}
/*
* add broadcast node so that we
* can send broadcast frame
*/
if (err != IWK_SUCCESS) {
"failed to add broadcast node\n");
return (err);
}
/* TX_LINK_QUALITY cmd */
for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
}
if (err != IWK_SUCCESS) {
"failed to config link quality table\n");
return (err);
}
}
if (index >= IWK_BROADCAST_ID) {
"the count of node in hardware is too much\n");
return (IWK_FAIL);
}
/*
* add a node into hardware
*/
sizeof (iwk_add_sta_t));
sizeof (iwk_add_sta_t), 1);
if (err != IWK_SUCCESS) {
"failed to add IBSS node\n");
ibss_node_p->used = 0;
sizeof (iwk_add_sta_t));
return (err);
}
ic->ic_curchan)];
for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++) {
} else {
rate = 2;
}
}
masks &= ~RATE_MCS_ANT_A_MSK;
link_quality.rate_n_flags[i] =
}
if (err != IWK_SUCCESS) {
"failed to set up TX link quality\n");
ibss_node_p->used = 0;
return (err);
}
return (err);
}