#include <linux/kernel.h>
#include <linux/ctype.h>
#include <linux/etherdevice.h>
-#include <linux/string.h>
+#include <net/mac80211.h>
+
#include <bcmdefs.h>
#include <bcmdevs.h>
-#include <wlc_cfg.h>
#include <osl.h>
#include <bcmutils.h>
#include <bcmwifi.h>
#include <siutils.h>
-#include <bcmendian.h>
#include <pcicfg.h>
#include <bcmsrom.h>
#include <wlioctl.h>
-#include <sbhndpio.h>
#include <sbhnddma.h>
#include <hnddma.h>
#include <hndpmu.h>
-#include <d11.h>
-#include <wlc_rate.h>
-#include <wlc_pub.h>
-#include <wlc_key.h>
-#include <wlc_bsscfg.h>
-#include <wlc_channel.h>
-#include <wlc_event.h>
-#include <wlc_mac80211.h>
-#include <wlc_bmac.h>
-#include <wlc_scb.h>
-#include <wlc_phy_hal.h>
-#include <wlc_phy_shim.h>
-#include <wlc_antsel.h>
-#include <wlc_stf.h>
-#include <wlc_ampdu.h>
-#include <wlc_event.h>
-#include <wl_export.h>
-#include "d11ucode_ext.h"
-#include <wlc_alloc.h>
-#include <net/mac80211.h>
-#include <wl_dbg.h>
+
+#include "d11.h"
+#include "wlc_types.h"
+#include "wlc_cfg.h"
+#include "wlc_rate.h"
+#include "wlc_scb.h"
+#include "wlc_pub.h"
+#include "wlc_key.h"
+#include "wlc_bsscfg.h"
+#include "phy/wlc_phy_hal.h"
+#include "wlc_channel.h"
+#include "wlc_mac80211.h"
+#include "wlc_bmac.h"
+#include "wlc_phy_hal.h"
+#include "wlc_phy_shim.h"
+#include "wlc_antsel.h"
+#include "wlc_stf.h"
+#include "wlc_ampdu.h"
+#include "wl_export.h"
+#include "wlc_alloc.h"
+#include "wl_dbg.h"
/*
* Disable statistics counting for WME
#define WPA_CAP_4_REPLAY_CNTRS RSN_CAP_4_REPLAY_CNTRS
#define WPA_CAP_16_REPLAY_CNTRS RSN_CAP_16_REPLAY_CNTRS
+/*
+ * Indication for txflowcontrol that all priority bits in
+ * TXQ_STOP_FOR_PRIOFC_MASK are to be considered.
+ */
+#define ALLPRIO -1
+
/*
* buffer length needed for wlc_format_ssid
* 32 SSID chars, max of 4 chars for each SSID char "\xFF", plus NULL.
static void wlc_tx_prec_map_init(struct wlc_info *wlc);
static void wlc_watchdog(void *arg);
static void wlc_watchdog_by_timer(void *arg);
+static u16 wlc_rate_shm_offset(struct wlc_info *wlc, u8 rate);
static int wlc_set_rateset(struct wlc_info *wlc, wlc_rateset_t *rs_arg);
static int wlc_iovar_rangecheck(struct wlc_info *wlc, u32 val,
const bcm_iovar_t *vi);
static u8 wlc_local_constraint_qdbm(struct wlc_info *wlc);
/* send and receive */
-static wlc_txq_info_t *wlc_txq_alloc(struct wlc_info *wlc,
- struct osl_info *osh);
+static struct wlc_txq_info *wlc_txq_alloc(struct wlc_info *wlc,
+ struct osl_info *osh);
static void wlc_txq_free(struct wlc_info *wlc, struct osl_info *osh,
- wlc_txq_info_t *qi);
-static void wlc_txflowcontrol_signal(struct wlc_info *wlc, wlc_txq_info_t *qi,
+ struct wlc_txq_info *qi);
+static void wlc_txflowcontrol_signal(struct wlc_info *wlc,
+ struct wlc_txq_info *qi,
bool on, int prio);
static void wlc_txflowcontrol_reset(struct wlc_info *wlc);
static u16 wlc_compute_airtime(struct wlc_info *wlc, ratespec_t rspec,
static void wlc_ht_update_ldpc(struct wlc_info *wlc, s8 val);
static void wlc_war16165(struct wlc_info *wlc, bool tx);
-static void wlc_process_eventq(void *arg);
static void wlc_wme_retries_write(struct wlc_info *wlc);
static bool wlc_attach_stf_ant_init(struct wlc_info *wlc);
static uint wlc_attach_module(struct wlc_info *wlc);
osh = wlc->osh;
- W_REG(osh, ®s->objaddr, (OBJADDR_RCMTA_SEL | (idx * 2)));
- (void)R_REG(osh, ®s->objaddr);
- v32 = R_REG(osh, ®s->objdata);
+ W_REG(®s->objaddr, (OBJADDR_RCMTA_SEL | (idx * 2)));
+ (void)R_REG(®s->objaddr);
+ v32 = R_REG(®s->objdata);
addr[0] = (u8) v32;
addr[1] = (u8) (v32 >> 8);
addr[2] = (u8) (v32 >> 16);
addr[3] = (u8) (v32 >> 24);
- W_REG(osh, ®s->objaddr, (OBJADDR_RCMTA_SEL | ((idx * 2) + 1)));
- (void)R_REG(osh, ®s->objaddr);
- v32 = R_REG(osh, (volatile u16 *)®s->objdata);
+ W_REG(®s->objaddr, (OBJADDR_RCMTA_SEL | ((idx * 2) + 1)));
+ (void)R_REG(®s->objaddr);
+ v32 = R_REG(®s->objdata);
addr[4] = (u8) v32;
addr[5] = (u8) (v32 >> 8);
}
if (bsscfg->up) {
u32 bi;
- /* get beacon period from bsscfg and convert to uS */
+ /* get beacon period and convert to uS */
bi = bsscfg->current_bss->beacon_period << 10;
- /* update the tsf_cfprep register */
- /* since init path would reset to default value */
- W_REG(wlc->osh, ®s->tsf_cfprep,
+ /*
+ * update since init path would reset
+ * to default value
+ */
+ W_REG(®s->tsf_cfprep,
(bi << CFPREP_CBI_SHIFT));
/* Update maccontrol PM related bits */
/* Enable EDCF mode (while the MAC is suspended) */
if (EDCF_ENAB(wlc->pub)) {
- OR_REG(wlc->osh, ®s->ifs_ctl, IFS_USEEDCF);
+ OR_REG(®s->ifs_ctl, IFS_USEEDCF);
wlc_edcf_setparams(wlc->cfg, false);
}
wlc->tx_suspended = false;
/* enable the RF Disable Delay timer */
- W_REG(wlc->osh, &wlc->regs->rfdisabledly, RFDISABLE_DEFAULT);
+ W_REG(&wlc->regs->rfdisabledly, RFDISABLE_DEFAULT);
/* initialize mpc delay */
wlc->mpc_delay_off = wlc->mpc_dlycnt = WLC_MPC_MIN_DELAYCNT;
* Initialize WME parameters; if they haven't been set by some other
* mechanism (IOVar, etc) then read them from the hardware.
*/
- if (WLC_WME_RETRY_SHORT_GET(wlc, 0) == 0) { /* Unintialized; read from HW */
+ if (WLC_WME_RETRY_SHORT_GET(wlc, 0) == 0) { /* Uninitialized; read from HW */
int ac;
ASSERT(wlc->clk);
bool wake_ok;
if (!AP_ACTIVE(wlc)) {
- volatile u32 tmp;
- tmp = R_REG(wlc->osh, &wlc->regs->maccontrol);
+ u32 tmp;
+ tmp = R_REG(&wlc->regs->maccontrol);
- /* If deviceremoved is detected, then don't take any action as this can be called
- * in any context. Assume that caller will take care of the condition. This is just
- * to avoid assert
+ /*
+ * If deviceremoved is detected, then don't take any action as
+ * this can be called in any context. Assume that caller will
+ * take care of the condition. This is just to avoid assert
*/
if (tmp == 0xffffffff) {
WL_ERROR("wl%d: %s: dead chip\n",
WL_TRACE("wl%d: wlc_set_ps_ctrl: hps %d wake %d\n",
wlc->pub->unit, hps, wake);
- v1 = R_REG(wlc->osh, &wlc->regs->maccontrol);
+ v1 = R_REG(&wlc->regs->maccontrol);
v2 = 0;
if (hps)
v2 |= MCTL_HPS;
FOREACH_BSS(wlc, idx, cfg) {
if (!cfg->associated)
continue;
- cfg->target_bss->chanspec = chanspec;
+
cfg->current_bss->chanspec = chanspec;
}
/* init antenna selection */
if (CHSPEC_WLC_BW(old_chanspec) != CHSPEC_WLC_BW(chanspec)) {
- if (WLANTSEL_ENAB(wlc))
- wlc_antsel_init(wlc->asi);
+ wlc_antsel_init(wlc->asi);
/* Fix the hardware rateset based on bw.
* Mainly add MCS32 for 40Mhz, remove MCS 32 for 20Mhz
* or convert to a tx_power_legacy_t struct
*/
if (!old_power) {
- bcopy(&power, pwr, sizeof(tx_power_t));
+ memcpy(pwr, &power, sizeof(tx_power_t));
} else {
int band_idx = CHSPEC_IS2G(power.chanspec) ? 0 : 1;
wlc_ucode_mac_upd(wlc);
/* init antenna selection */
- if (WLANTSEL_ENAB(wlc))
- wlc_antsel_init(wlc->asi);
+ wlc_antsel_init(wlc->asi);
}
0,
{
{EDCF_AC_BE_ACI_STA, EDCF_AC_BE_ECW_STA,
- HTOL16(EDCF_AC_BE_TXOP_STA)},
+ cpu_to_le16(EDCF_AC_BE_TXOP_STA)},
{EDCF_AC_BK_ACI_STA, EDCF_AC_BK_ECW_STA,
- HTOL16(EDCF_AC_BK_TXOP_STA)},
+ cpu_to_le16(EDCF_AC_BK_TXOP_STA)},
{EDCF_AC_VI_ACI_STA, EDCF_AC_VI_ECW_STA,
- HTOL16(EDCF_AC_VI_TXOP_STA)},
+ cpu_to_le16(EDCF_AC_VI_TXOP_STA)},
{EDCF_AC_VO_ACI_STA, EDCF_AC_VO_ECW_STA,
- HTOL16(EDCF_AC_VO_TXOP_STA)}
+ cpu_to_le16(EDCF_AC_VO_TXOP_STA)}
}
};
/* wlc->wme_admctl |= 1 << aci; *//* should be set ?? seems like off by default */
/* fill in shm ac params struct */
- acp_shm.txop = ltoh16(params->txop);
+ acp_shm.txop = le16_to_cpu(params->txop);
/* convert from units of 32us to us for ucode */
wlc->edcf_txop[aci & 0x3] = acp_shm.txop =
EDCF_TXOP2USEC(acp_shm.txop);
acp_shm.cwmax = params->cw_max;
acp_shm.cwcur = acp_shm.cwmin;
acp_shm.bslots =
- R_REG(wlc->osh, &wlc->regs->tsf_random) & acp_shm.cwcur;
+ R_REG(&wlc->regs->tsf_random) & acp_shm.cwcur;
acp_shm.reggap = acp_shm.bslots + acp_shm.aifs;
/* Indicate the new params to the ucode */
acp_shm.status = wlc_read_shm(wlc, (M_EDCF_QINFO +
}
/* fill in shm ac params struct */
- acp_shm.txop = ltoh16(edcf_acp->TXOP);
+ acp_shm.txop = le16_to_cpu(edcf_acp->TXOP);
/* convert from units of 32us to us for ucode */
wlc->edcf_txop[aci] = acp_shm.txop =
EDCF_TXOP2USEC(acp_shm.txop);
>> EDCF_ECWMAX_SHIFT);
acp_shm.cwcur = acp_shm.cwmin;
acp_shm.bslots =
- R_REG(wlc->osh, &wlc->regs->tsf_random) & acp_shm.cwcur;
+ R_REG(&wlc->regs->tsf_random) & acp_shm.cwcur;
acp_shm.reggap = acp_shm.bslots + acp_shm.aifs;
/* Indicate the new params to the ucode */
acp_shm.status = wlc_read_shm(wlc, (M_EDCF_QINFO +
wlc->ibss_coalesce_allowed = true;
wlc->pub->_coex = ON;
- /* intialize mpc delay */
+ /* initialize mpc delay */
wlc->mpc_delay_off = wlc->mpc_dlycnt = WLC_MPC_MIN_DELAYCNT;
wlc->pr80838_war = true;
goto fail;
}
- /* Initialize event queue; needed before following calls */
- wlc->eventq =
- wlc_eventq_attach(wlc->pub, wlc, wlc->wl, wlc_process_eventq);
- if (wlc->eventq == NULL) {
- WL_ERROR("wl%d: wlc_attach: wlc_eventq_attachfailed\n", unit);
- err = 57;
- goto fail;
- }
-
if ((wlc_stf_attach(wlc) != 0)) {
WL_ERROR("wl%d: wlc_attach: wlc_stf_attach failed\n", unit);
err = 68;
uint err = 0;
uint j;
struct wlc_pub *pub;
- wlc_txq_info_t *qi;
+ struct wlc_txq_info *qi;
uint n_disabled;
WL_NONE("wl%d: %s: vendor 0x%x device 0x%x\n",
&& 4 == WLC_NUMRXIVS));
/* allocate struct wlc_info state and its substructures */
- wlc = (struct wlc_info *) wlc_attach_malloc(osh, unit, &err, device);
+ wlc = (struct wlc_info *) wlc_attach_malloc(unit, &err, device);
if (wlc == NULL)
goto fail;
wlc->osh = osh;
wlc_bmac_hw_etheraddr(wlc->hw, wlc->perm_etheraddr);
- bcopy((char *)&wlc->perm_etheraddr, (char *)&pub->cur_etheraddr,
- ETH_ALEN);
+ memcpy(&pub->cur_etheraddr, &wlc->perm_etheraddr, ETH_ALEN);
for (j = 0; j < NBANDS(wlc); j++) {
/* Use band 1 for single band 11a */
/* initialize radio_mpc_disable according to wlc->mpc */
wlc_radio_mpc_upd(wlc);
- if (WLANTSEL_ENAB(wlc)) {
- if ((wlc->pub->sih->chip) == BCM43235_CHIP_ID) {
- if ((getintvar(wlc->pub->vars, "aa2g") == 7) ||
- (getintvar(wlc->pub->vars, "aa5g") == 7)) {
- wlc_bmac_antsel_set(wlc->hw, 1);
- }
- } else {
- wlc_bmac_antsel_set(wlc->hw, wlc->asi->antsel_avail);
+ if ((wlc->pub->sih->chip) == BCM43235_CHIP_ID) {
+ if ((getintvar(wlc->pub->vars, "aa2g") == 7) ||
+ (getintvar(wlc->pub->vars, "aa5g") == 7)) {
+ wlc_bmac_antsel_set(wlc->hw, 1);
}
+ } else {
+ wlc_bmac_antsel_set(wlc->hw, wlc->asi->antsel_avail);
}
if (perr)
if (!wlc_radio_monitor_stop(wlc))
callbacks++;
- if (wlc->eventq) {
- wlc_eventq_detach(wlc->eventq);
- wlc->eventq = NULL;
- }
-
wlc_channel_mgr_detach(wlc->cmi);
wlc_timers_deinit(wlc);
{
/* free dumpcb list */
- dumpcb_t *prev, *ptr;
+ struct dumpcb_s *prev, *ptr;
prev = ptr = wlc->dumpcb_head;
while (ptr) {
ptr = prev->next;
for (i = 0; i < WLC_MAXMODULES; i++)
ASSERT(wlc->modulecb[i].name[0] == '\0');
- wlc_detach_mfree(wlc, wlc->osh);
+ wlc_detach_mfree(wlc);
return callbacks;
}
uint callbacks = 0;
int i;
bool dev_gone = false;
- wlc_txq_info_t *qi;
+ struct wlc_txq_info *qi;
WL_TRACE("wl%d: %s:\n", wlc->pub->unit, __func__);
ASSERT(pktq_empty(&qi->q));
}
- /* flush event queue.
- * Should be the last thing done after all the events are generated
- * Just delivers the events synchronously instead of waiting for a timer
- */
- callbacks += wlc_eventq_down(wlc->eventq);
-
callbacks += wlc_bmac_down_finish(wlc->hw);
/* wlc_bmac_down_finish has done wlc_coredisable(). so clk is off */
/* Set default bss rateset */
wlc->default_bss->rateset.count = rs.count;
- bcopy((char *)rs.rates, (char *)wlc->default_bss->rateset.rates,
- sizeof(wlc->default_bss->rateset.rates));
+ memcpy(wlc->default_bss->rateset.rates, rs.rates,
+ sizeof(wlc->default_bss->rateset.rates));
return ret;
}
wlc_rateset_t rs, new;
uint bandunit;
- bcopy((char *)rs_arg, (char *)&rs, sizeof(wlc_rateset_t));
+ memcpy(&rs, rs_arg, sizeof(wlc_rateset_t));
/* check for bad count value */
if ((rs.count == 0) || (rs.count > WLC_NUMRATES))
/* try the current band */
bandunit = wlc->band->bandunit;
- bcopy((char *)&rs, (char *)&new, sizeof(wlc_rateset_t));
+ memcpy(&new, &rs, sizeof(wlc_rateset_t));
if (wlc_rate_hwrs_filter_sort_validate
(&new, &wlc->bandstate[bandunit]->hw_rateset, true,
wlc->stf->txstreams))
/* try the other band */
if (IS_MBAND_UNLOCKED(wlc)) {
bandunit = OTHERBANDUNIT(wlc);
- bcopy((char *)&rs, (char *)&new, sizeof(wlc_rateset_t));
+ memcpy(&new, &rs, sizeof(wlc_rateset_t));
if (wlc_rate_hwrs_filter_sort_validate(&new,
&wlc->
bandstate[bandunit]->
good:
/* apply new rateset */
- bcopy((char *)&new, (char *)&wlc->default_bss->rateset,
- sizeof(wlc_rateset_t));
- bcopy((char *)&new, (char *)&wlc->bandstate[bandunit]->defrateset,
- sizeof(wlc_rateset_t));
+ memcpy(&wlc->default_bss->rateset, &new, sizeof(wlc_rateset_t));
+ memcpy(&wlc->bandstate[bandunit]->defrateset, &new,
+ sizeof(wlc_rateset_t));
return 0;
}
/* This will prevent the misaligned access */
if (pval && (u32) len >= sizeof(val))
- bcopy(pval, &val, sizeof(val));
+ memcpy(&val, pval, sizeof(val));
else
val = 0;
wlc->default_bss->chanspec = chspec;
/* wlc_BSSinit() will sanitize the rateset before using it.. */
- if (wlc->pub->up && !wlc->pub->associated &&
+ if (wlc->pub->up &&
(WLC_BAND_PI_RADIO_CHANSPEC != chspec)) {
wlc_set_home_chanspec(wlc, chspec);
wlc_suspend_mac_and_wait(wlc);
}
if (r->size == sizeof(u32))
r->val =
- R_REG(osh,
- (u32 *)((unsigned char *)(unsigned long)regs +
+ R_REG((u32 *)((unsigned char *)(unsigned long)regs +
r->byteoff));
else if (r->size == sizeof(u16))
r->val =
- R_REG(osh,
- (u16 *)((unsigned char *)(unsigned long)regs +
+ R_REG((u16 *)((unsigned char *)(unsigned long)regs +
r->byteoff));
else
bcmerror = BCME_BADADDR;
break;
}
if (r->size == sizeof(u32))
- W_REG(osh,
- (u32 *)((unsigned char *)(unsigned long) regs +
+ W_REG((u32 *)((unsigned char *)(unsigned long) regs +
r->byteoff), r->val);
else if (r->size == sizeof(u16))
- W_REG(osh,
- (u16 *)((unsigned char *)(unsigned long) regs +
+ W_REG((u16 *)((unsigned char *)(unsigned long) regs +
r->byteoff), r->val);
else
bcmerror = BCME_BADADDR;
break;
}
- rxstatus = R_REG(wlc->osh, &wlc->regs->phyrxstatus0);
+ rxstatus = R_REG(&wlc->regs->phyrxstatus0);
if (rxstatus == 0xdead || rxstatus == (u16) -1) {
bcmerror = BCME_ERROR;
break;
if (src_key) {
key.index = src_key->id;
key.len = src_key->len;
- bcopy(src_key->data, key.data, key.len);
+ memcpy(key.data, src_key->data, key.len);
key.algo = src_key->algo;
if (WSEC_SOFTKEY(wlc, src_key, bsscfg))
key.flags |= WL_SOFT_KEY;
if (src_key->flags & WSEC_PRIMARY_KEY)
key.flags |= WL_PRIMARY_KEY;
- bcopy(src_key->ea, key.ea,
- ETH_ALEN);
+ memcpy(key.ea, src_key->ea, ETH_ALEN);
}
- bcopy((char *)&key, arg, sizeof(key));
+ memcpy(arg, &key, sizeof(key));
} else
bcmerror = BCME_BADKEYIDX;
break;
seq[6] = 0;
seq[7] = 0;
- bcopy((char *)seq, arg, sizeof(seq));
+ memcpy(arg, seq, sizeof(seq));
} else {
bcmerror = BCME_BADKEYIDX;
}
/* Copy only legacy rateset section */
ret_rs->count = rs->count;
- bcopy(&rs->rates, &ret_rs->rates, rs->count);
+ memcpy(&ret_rs->rates, &rs->rates, rs->count);
break;
}
/* Copy only legacy rateset section */
ret_rs->count = rs.count;
- bcopy(&rs.rates, &ret_rs->rates, rs.count);
+ memcpy(&ret_rs->rates, &rs.rates, rs.count);
break;
}
/* Copy only legacy rateset section */
rs.count = in_rs->count;
- bcopy(&in_rs->rates, &rs.rates, rs.count);
+ memcpy(&rs.rates, &in_rs->rates, rs.count);
/* merge rateset coming in with the current mcsset */
if (N_ENAB(wlc->pub)) {
if (bsscfg->associated)
- bcopy(¤t_bss->rateset.mcs[0],
- rs.mcs, MCSSET_LEN);
+ memcpy(rs.mcs,
+ ¤t_bss->rateset.mcs[0],
+ MCSSET_LEN);
else
- bcopy(&wlc->default_bss->rateset.mcs[0],
- rs.mcs, MCSSET_LEN);
+ memcpy(rs.mcs,
+ &wlc->default_bss->rateset.mcs[0],
+ MCSSET_LEN);
}
bcmerror = wlc_set_rateset(wlc, &rs);
bcmerror = BCME_BUFTOOSHORT;
break;
}
- bcopy((char *)arg, (char *)&rs, sizeof(wlc_rateset_t));
+ memcpy(&rs, arg, sizeof(wlc_rateset_t));
/* check for bad count value */
if (rs.count > WLC_NUMRATES) {
}
/* apply new rateset to the override */
- bcopy((char *)&new, (char *)&wlc->sup_rates_override,
+ memcpy(&wlc->sup_rates_override, &new,
sizeof(wlc_rateset_t));
/* update bcn and probe resp if needed */
bcmerror = BCME_BUFTOOSHORT;
break;
}
- bcopy((char *)&wlc->sup_rates_override, (char *)arg,
- sizeof(wlc_rateset_t));
+ memcpy(arg, &wlc->sup_rates_override, sizeof(wlc_rateset_t));
break;
for (i = 0; i < WLC_MAXMODULES; i++) {
if (!strcmp(wlc->modulecb[i].name, name) &&
(wlc->modulecb[i].hdl == hdl)) {
- memset(&wlc->modulecb[i], 0, sizeof(modulecb_t));
+ memset(&wlc->modulecb[i], 0, sizeof(struct modulecb));
return 0;
}
}
case IOVT_UINT8:
case IOVT_UINT16:
case IOVT_UINT32:
- bcopy(arg, &int_val, sizeof(int));
+ memcpy(&int_val, arg, sizeof(int));
err = wlc_iovar_rangecheck(wlc, int_val, vi);
break;
}
/* convenience int and bool vals for first 8 bytes of buffer */
if (p_len >= (int)sizeof(int_val))
- bcopy(params, &int_val, sizeof(int_val));
+ memcpy(&int_val, params, sizeof(int_val));
if (p_len >= (int)sizeof(int_val) * 2)
- bcopy((void *)((unsigned long)params + sizeof(int_val)), &int_val2,
- sizeof(int_val));
+ memcpy(&int_val2,
+ (void *)((unsigned long)params + sizeof(int_val)),
+ sizeof(int_val));
/* convenience int ptr for 4-byte gets (requires int aligned arg) */
ret_int_ptr = (s32 *) arg;
u16 v;
u16 delta;
- v = ltoh16(cur_stat);
+ v = le16_to_cpu(cur_stat);
delta = (u16)(v - *macstat_snapshot);
if (delta != 0) {
#if defined(BCMDBG)
void wlc_print_txdesc(d11txh_t *txh)
{
- u16 mtcl = ltoh16(txh->MacTxControlLow);
- u16 mtch = ltoh16(txh->MacTxControlHigh);
- u16 mfc = ltoh16(txh->MacFrameControl);
- u16 tfest = ltoh16(txh->TxFesTimeNormal);
- u16 ptcw = ltoh16(txh->PhyTxControlWord);
- u16 ptcw_1 = ltoh16(txh->PhyTxControlWord_1);
- u16 ptcw_1_Fbr = ltoh16(txh->PhyTxControlWord_1_Fbr);
- u16 ptcw_1_Rts = ltoh16(txh->PhyTxControlWord_1_Rts);
- u16 ptcw_1_FbrRts = ltoh16(txh->PhyTxControlWord_1_FbrRts);
- u16 mainrates = ltoh16(txh->MainRates);
- u16 xtraft = ltoh16(txh->XtraFrameTypes);
+ u16 mtcl = le16_to_cpu(txh->MacTxControlLow);
+ u16 mtch = le16_to_cpu(txh->MacTxControlHigh);
+ u16 mfc = le16_to_cpu(txh->MacFrameControl);
+ u16 tfest = le16_to_cpu(txh->TxFesTimeNormal);
+ u16 ptcw = le16_to_cpu(txh->PhyTxControlWord);
+ u16 ptcw_1 = le16_to_cpu(txh->PhyTxControlWord_1);
+ u16 ptcw_1_Fbr = le16_to_cpu(txh->PhyTxControlWord_1_Fbr);
+ u16 ptcw_1_Rts = le16_to_cpu(txh->PhyTxControlWord_1_Rts);
+ u16 ptcw_1_FbrRts = le16_to_cpu(txh->PhyTxControlWord_1_FbrRts);
+ u16 mainrates = le16_to_cpu(txh->MainRates);
+ u16 xtraft = le16_to_cpu(txh->XtraFrameTypes);
u8 *iv = txh->IV;
u8 *ra = txh->TxFrameRA;
- u16 tfestfb = ltoh16(txh->TxFesTimeFallback);
+ u16 tfestfb = le16_to_cpu(txh->TxFesTimeFallback);
u8 *rtspfb = txh->RTSPLCPFallback;
- u16 rtsdfb = ltoh16(txh->RTSDurFallback);
+ u16 rtsdfb = le16_to_cpu(txh->RTSDurFallback);
u8 *fragpfb = txh->FragPLCPFallback;
- u16 fragdfb = ltoh16(txh->FragDurFallback);
- u16 mmodelen = ltoh16(txh->MModeLen);
- u16 mmodefbrlen = ltoh16(txh->MModeFbrLen);
- u16 tfid = ltoh16(txh->TxFrameID);
- u16 txs = ltoh16(txh->TxStatus);
- u16 mnmpdu = ltoh16(txh->MaxNMpdus);
- u16 mabyte = ltoh16(txh->MaxABytes_MRT);
- u16 mabyte_f = ltoh16(txh->MaxABytes_FBR);
- u16 mmbyte = ltoh16(txh->MinMBytes);
+ u16 fragdfb = le16_to_cpu(txh->FragDurFallback);
+ u16 mmodelen = le16_to_cpu(txh->MModeLen);
+ u16 mmodefbrlen = le16_to_cpu(txh->MModeFbrLen);
+ u16 tfid = le16_to_cpu(txh->TxFrameID);
+ u16 txs = le16_to_cpu(txh->TxStatus);
+ u16 mnmpdu = le16_to_cpu(txh->MaxNMpdus);
+ u16 mabyte = le16_to_cpu(txh->MaxABytes_MRT);
+ u16 mabyte_f = le16_to_cpu(txh->MaxABytes_FBR);
+ u16 mmbyte = le16_to_cpu(txh->MinMBytes);
u8 *rtsph = txh->RTSPhyHeader;
struct ieee80211_rts rts = txh->rts_frame;
}
#endif /* defined(BCMDBG) */
-u16 wlc_rate_shm_offset(struct wlc_info *wlc, u8 rate)
+static u16 wlc_rate_shm_offset(struct wlc_info *wlc, u8 rate)
{
return wlc_bmac_rate_shm_offset(wlc->hw, rate);
}
tx_failed[WME_PRIO2AC(p->priority)].packets);
WLCNTADD(wlc->pub->_wme_cnt->
tx_failed[WME_PRIO2AC(p->priority)].bytes,
- pkttotlen(wlc->osh, p));
+ pkttotlen(p));
}
-
- ASSERT(0);
pkt_buf_free_skb(wlc->osh, p, true);
wlc->pub->_cnt->txnobuf++;
}
uint prec)
{
struct wlc_info *wlc = (struct wlc_info *) ctx;
- wlc_txq_info_t *qi = wlc->active_queue; /* Check me */
+ struct wlc_txq_info *qi = wlc->active_queue; /* Check me */
struct pktq *q = &qi->q;
int prio;
ASSERT(sdu);
- fc = ltoh16(d11_header->frame_control);
+ fc = le16_to_cpu(d11_header->frame_control);
type = (fc & IEEE80211_FCTL_FTYPE);
/* 802.11 standard requires management traffic to go at highest priority */
return 0;
}
-void BCMFASTPATH wlc_send_q(struct wlc_info *wlc, wlc_txq_info_t *qi)
+void BCMFASTPATH wlc_send_q(struct wlc_info *wlc, struct wlc_txq_info *qi)
{
struct sk_buff *pkt[DOT11_MAXNUMFRAGS];
int prec;
{
u16 frameid;
- frameid = ltoh16(txh->TxFrameID) & ~(TXFID_SEQ_MASK | TXFID_QUEUE_MASK);
+ frameid = le16_to_cpu(txh->TxFrameID) & ~(TXFID_SEQ_MASK |
+ TXFID_QUEUE_MASK);
frameid |=
(((wlc->
mc_fid_counter++) << TXFID_SEQ_SHIFT) & TXFID_SEQ_MASK) |
* ucode or BSS info as appropriate.
*/
if (fifo == TX_BCMC_FIFO) {
- frameid = ltoh16(txh->TxFrameID);
+ frameid = le16_to_cpu(txh->TxFrameID);
}
u32 rate_val[2];
bool hwtkmic = false;
u16 mimo_ctlchbw = PHY_TXC1_BW_20MHZ;
-#ifdef WLANTSEL
#define ANTCFG_NONE 0xFF
u8 antcfg = ANTCFG_NONE;
u8 fbantcfg = ANTCFG_NONE;
-#endif
uint phyctl1_stf = 0;
u16 durid = 0;
struct ieee80211_tx_rate *txrate[2];
/* locate 802.11 MAC header */
h = (struct ieee80211_hdr *)(p->data);
- fc = ltoh16(h->frame_control);
+ fc = le16_to_cpu(h->frame_control);
type = (fc & IEEE80211_FCTL_FTYPE);
qos = (type == IEEE80211_FTYPE_DATA &&
FC_SUBTYPE_ANY_QOS(fc));
/* compute length of frame in bytes for use in PLCP computations */
- len = pkttotlen(osh, p);
+ len = pkttotlen(p);
phylen = len + FCS_LEN;
/* If WEP enabled, add room in phylen for the additional bytes of
}
/* extract fragment number from frame first */
- seq = ltoh16(seq) & FRAGNUM_MASK;
+ seq = le16_to_cpu(seq) & FRAGNUM_MASK;
seq |= (SCB_SEQNUM(scb, p->priority) << SEQNUM_SHIFT);
- h->seq_ctrl = htol16(seq);
+ h->seq_ctrl = cpu_to_le16(seq);
frameid = ((seq << TXFID_SEQ_SHIFT) & TXFID_SEQ_MASK) |
(queue & TXFID_QUEUE_MASK);
ASSERT(RSPEC_ACTIVE(rspec[k]));
rspec[k] = WLC_RATE_1M;
} else {
- if (WLANTSEL_ENAB(wlc) &&
- !is_multicast_ether_addr(h->addr1)) {
+ if (!is_multicast_ether_addr(h->addr1)) {
/* set tx antenna config */
wlc_antsel_antcfg_get(wlc->asi, false, false, 0,
0, &antcfg, &fbantcfg);
/* (3) PLCP: determine PLCP header and MAC duration, fill d11txh_t */
wlc_compute_plcp(wlc, rspec[0], phylen, plcp);
wlc_compute_plcp(wlc, rspec[1], phylen, plcp_fallback);
- bcopy(plcp_fallback, (char *)&txh->FragPLCPFallback,
- sizeof(txh->FragPLCPFallback));
+ memcpy(&txh->FragPLCPFallback,
+ plcp_fallback, sizeof(txh->FragPLCPFallback));
/* Length field now put in CCK FBR CRC field */
if (IS_CCK(rspec[1])) {
durid =
wlc_compute_frame_dur(wlc, rspec[0], preamble_type[0],
next_frag_len);
- h->duration_id = htol16(durid);
+ h->duration_id = cpu_to_le16(durid);
} else if (use_rifs) {
/* NAV protect to end of next max packet size */
durid =
preamble_type[0],
DOT11_MAX_FRAG_LEN);
durid += RIFS_11N_TIME;
- h->duration_id = htol16(durid);
+ h->duration_id = cpu_to_le16(durid);
}
/* DUR field for fallback rate */
else {
durid = wlc_compute_frame_dur(wlc, rspec[1],
preamble_type[1], next_frag_len);
- txh->FragDurFallback = htol16(durid);
+ txh->FragDurFallback = cpu_to_le16(durid);
}
/* (4) MAC-HDR: MacTxControlLow */
if (hwtkmic)
mcl |= TXC_AMIC;
- txh->MacTxControlLow = htol16(mcl);
+ txh->MacTxControlLow = cpu_to_le16(mcl);
/* MacTxControlHigh */
mch = 0;
}
/* MacFrameControl */
- bcopy((char *)&h->frame_control, (char *)&txh->MacFrameControl,
- sizeof(u16));
- txh->TxFesTimeNormal = htol16(0);
+ memcpy(&txh->MacFrameControl, &h->frame_control, sizeof(u16));
+ txh->TxFesTimeNormal = cpu_to_le16(0);
- txh->TxFesTimeFallback = htol16(0);
+ txh->TxFesTimeFallback = cpu_to_le16(0);
/* TxFrameRA */
- bcopy((char *)&h->addr1, (char *)&txh->TxFrameRA, ETH_ALEN);
+ memcpy(&txh->TxFrameRA, &h->addr1, ETH_ALEN);
/* TxFrameID */
- txh->TxFrameID = htol16(frameid);
+ txh->TxFrameID = cpu_to_le16(frameid);
/* TxStatus, Note the case of recreating the first frag of a suppressed frame
* then we may need to reset the retry cnt's via the status reg
*/
- txh->TxStatus = htol16(status);
+ txh->TxStatus = cpu_to_le16(status);
/* extra fields for ucode AMPDU aggregation, the new fields are added to
* the END of previous structure so that it's compatible in driver.
*/
- txh->MaxNMpdus = htol16(0);
- txh->MaxABytes_MRT = htol16(0);
- txh->MaxABytes_FBR = htol16(0);
- txh->MinMBytes = htol16(0);
+ txh->MaxNMpdus = cpu_to_le16(0);
+ txh->MaxABytes_MRT = cpu_to_le16(0);
+ txh->MaxABytes_FBR = cpu_to_le16(0);
+ txh->MinMBytes = cpu_to_le16(0);
/* (5) RTS/CTS: determine RTS/CTS PLCP header and MAC duration, furnish d11txh_t */
/* RTS PLCP header and RTS frame */
/* RTS/CTS additions to MacTxControlLow */
if (use_cts) {
- txh->MacTxControlLow |= htol16(TXC_SENDCTS);
+ txh->MacTxControlLow |= cpu_to_le16(TXC_SENDCTS);
} else {
- txh->MacTxControlLow |= htol16(TXC_SENDRTS);
- txh->MacTxControlLow |= htol16(TXC_LONGFRAME);
+ txh->MacTxControlLow |= cpu_to_le16(TXC_SENDRTS);
+ txh->MacTxControlLow |= cpu_to_le16(TXC_LONGFRAME);
}
/* RTS PLCP header */
/* fallback rate version of RTS PLCP header */
wlc_compute_plcp(wlc, rts_rspec[1], rts_phylen,
rts_plcp_fallback);
- bcopy(rts_plcp_fallback, (char *)&txh->RTSPLCPFallback,
- sizeof(txh->RTSPLCPFallback));
+ memcpy(&txh->RTSPLCPFallback, rts_plcp_fallback,
+ sizeof(txh->RTSPLCPFallback));
/* RTS frame fields... */
rts = (struct ieee80211_rts *)&txh->rts_frame;
durid = wlc_compute_rtscts_dur(wlc, use_cts, rts_rspec[0],
rspec[0], rts_preamble_type[0],
preamble_type[0], phylen, false);
- rts->duration = htol16(durid);
+ rts->duration = cpu_to_le16(durid);
/* fallback rate version of RTS DUR field */
durid = wlc_compute_rtscts_dur(wlc, use_cts,
rts_rspec[1], rspec[1],
rts_preamble_type[1],
preamble_type[1], phylen, false);
- txh->RTSDurFallback = htol16(durid);
+ txh->RTSDurFallback = cpu_to_le16(durid);
if (use_cts) {
- rts->frame_control = htol16(FC_CTS);
- bcopy((char *)&h->addr2, (char *)&rts->ra, ETH_ALEN);
+ rts->frame_control = cpu_to_le16(FC_CTS);
+ memcpy(&rts->ra, &h->addr2, ETH_ALEN);
} else {
- rts->frame_control = htol16((u16) FC_RTS);
- bcopy((char *)&h->addr1, (char *)&rts->ra,
- 2 * ETH_ALEN);
+ rts->frame_control = cpu_to_le16((u16) FC_RTS);
+ memcpy(&rts->ra, &h->addr1, 2 * ETH_ALEN);
}
/* mainrate
#endif
/* Now that RTS/RTS FB preamble types are updated, write the final value */
- txh->MacTxControlHigh = htol16(mch);
+ txh->MacTxControlHigh = cpu_to_le16(mch);
/* MainRates (both the rts and frag plcp rates have been calculated now) */
- txh->MainRates = htol16(mainrates);
+ txh->MainRates = cpu_to_le16(mainrates);
/* XtraFrameTypes */
xfts = FRAMETYPE(rspec[1], wlc->mimoft);
xfts |= (FRAMETYPE(rts_rspec[1], wlc->mimoft) << XFTS_FBRRTS_FT_SHIFT);
xfts |=
CHSPEC_CHANNEL(WLC_BAND_PI_RADIO_CHANSPEC) << XFTS_CHANNEL_SHIFT;
- txh->XtraFrameTypes = htol16(xfts);
+ txh->XtraFrameTypes = cpu_to_le16(xfts);
/* PhyTxControlWord */
phyctl = FRAMETYPE(rspec[0], wlc->mimoft);
/* phytxant is properly bit shifted */
phyctl |= wlc_stf_d11hdrs_phyctl_txant(wlc, rspec[0]);
- txh->PhyTxControlWord = htol16(phyctl);
+ txh->PhyTxControlWord = cpu_to_le16(phyctl);
/* PhyTxControlWord_1 */
if (WLC_PHY_11N_CAP(wlc->band)) {
u16 phyctl1 = 0;
phyctl1 = wlc_phytxctl1_calc(wlc, rspec[0]);
- txh->PhyTxControlWord_1 = htol16(phyctl1);
+ txh->PhyTxControlWord_1 = cpu_to_le16(phyctl1);
phyctl1 = wlc_phytxctl1_calc(wlc, rspec[1]);
- txh->PhyTxControlWord_1_Fbr = htol16(phyctl1);
+ txh->PhyTxControlWord_1_Fbr = cpu_to_le16(phyctl1);
if (use_rts || use_cts) {
phyctl1 = wlc_phytxctl1_calc(wlc, rts_rspec[0]);
- txh->PhyTxControlWord_1_Rts = htol16(phyctl1);
+ txh->PhyTxControlWord_1_Rts = cpu_to_le16(phyctl1);
phyctl1 = wlc_phytxctl1_calc(wlc, rts_rspec[1]);
- txh->PhyTxControlWord_1_FbrRts = htol16(phyctl1);
+ txh->PhyTxControlWord_1_FbrRts = cpu_to_le16(phyctl1);
}
/*
if (IS_MCS(rspec[0]) && (preamble_type[0] == WLC_MM_PREAMBLE)) {
u16 mmodelen =
wlc_calc_lsig_len(wlc, rspec[0], phylen);
- txh->MModeLen = htol16(mmodelen);
+ txh->MModeLen = cpu_to_le16(mmodelen);
}
if (IS_MCS(rspec[1]) && (preamble_type[1] == WLC_MM_PREAMBLE)) {
u16 mmodefbrlen =
wlc_calc_lsig_len(wlc, rspec[1], phylen);
- txh->MModeFbrLen = htol16(mmodefbrlen);
+ txh->MModeFbrLen = cpu_to_le16(mmodefbrlen);
}
}
wlc_calc_cts_time(wlc, rts_rspec[1],
rts_preamble_type[1]);
/* (SIFS + CTS) + SIFS + frame + SIFS + ACK */
- dur += ltoh16(rts->duration);
- dur_fallback += ltoh16(txh->RTSDurFallback);
+ dur += le16_to_cpu(rts->duration);
+ dur_fallback +=
+ le16_to_cpu(txh->RTSDurFallback);
} else if (use_rifs) {
dur = frag_dur;
dur_fallback = 0;
preamble_type[1], 0);
}
/* NEED to set TxFesTimeNormal (hard) */
- txh->TxFesTimeNormal = htol16((u16) dur);
+ txh->TxFesTimeNormal = cpu_to_le16((u16) dur);
/* NEED to set fallback rate version of TxFesTimeNormal (hard) */
- txh->TxFesTimeFallback = htol16((u16) dur_fallback);
+ txh->TxFesTimeFallback =
+ cpu_to_le16((u16) dur_fallback);
/* update txop byte threshold (txop minus intraframe overhead) */
if (wlc->edcf_txop[ac] >= (dur - frag_dur)) {
/* GP timer is a freerunning 32 bit counter, decrements at 1 us rate */
void wlc_hwtimer_gptimer_set(struct wlc_info *wlc, uint us)
{
- W_REG(wlc->osh, &wlc->regs->gptimer, us);
+ W_REG(&wlc->regs->gptimer, us);
}
void wlc_hwtimer_gptimer_abort(struct wlc_info *wlc)
{
- W_REG(wlc->osh, &wlc->regs->gptimer, 0);
+ W_REG(&wlc->regs->gptimer, 0);
}
static void wlc_hwtimer_gptimer_cb(struct wlc_info *wlc)
/* when interrupt is generated, the counter is loaded with last value
* written and continue to decrement. So it has to be cleaned first
*/
- W_REG(wlc->osh, &wlc->regs->gptimer, 0);
+ W_REG(&wlc->regs->gptimer, 0);
}
/*
if (macintstatus & MI_RFDISABLE) {
WL_ERROR("wl%d: MAC Detected a change on the RF Disable Input 0x%x\n",
wlc->pub->unit,
- R_REG(wlc->osh, ®s->phydebug) & PDBG_RFD);
+ R_REG(®s->phydebug) & PDBG_RFD);
/* delay the cleanup to wl_down in IBSS case */
- if ((R_REG(wlc->osh, ®s->phydebug) & PDBG_RFD)) {
+ if ((R_REG(®s->phydebug) & PDBG_RFD)) {
int idx;
wlc_bsscfg_t *bsscfg;
FOREACH_BSS(wlc, idx, bsscfg) {
goto fatal;
txh = (d11txh_t *) (p->data);
- mcl = ltoh16(txh->MacTxControlLow);
+ mcl = le16_to_cpu(txh->MacTxControlLow);
if (txs->phyerr) {
if (WL_ERROR_ON()) {
wlc_print_txstatus(txs);
}
- ASSERT(txs->frameid == htol16(txh->TxFrameID));
- if (txs->frameid != htol16(txh->TxFrameID))
+ ASSERT(txs->frameid == cpu_to_le16(txh->TxFrameID));
+ if (txs->frameid != cpu_to_le16(txh->TxFrameID))
goto fatal;
tx_info = IEEE80211_SKB_CB(p);
h = (struct ieee80211_hdr *)((u8 *) (txh + 1) + D11_PHY_HDR_LEN);
- fc = ltoh16(h->frame_control);
+ fc = le16_to_cpu(h->frame_control);
scb = (struct scb *)tx_info->control.sta->drv_priv;
WL_NONE("%s: Pkt tx suppressed, possibly channel %d\n",
__func__, CHSPEC_CHANNEL(wlc->default_bss->chanspec));
- tx_rts = htol16(txh->MacTxControlLow) & TXC_SENDRTS;
+ tx_rts = cpu_to_le16(txh->MacTxControlLow) & TXC_SENDRTS;
tx_frame_count =
(txs->status & TX_STATUS_FRM_RTX_MASK) >> TX_STATUS_FRM_RTX_SHIFT;
tx_rts_count =
tx_info->flags |= IEEE80211_TX_STAT_ACK;
}
- totlen = pkttotlen(osh, p);
+ totlen = pkttotlen(p);
free_pdu = true;
wlc_txfifo_complete(wlc, queue, 1);
return;
}
-void wlc_bss_list_free(struct wlc_info *wlc, wlc_bss_list_t *bss_list)
+void wlc_bss_list_free(struct wlc_info *wlc, struct wlc_bss_list *bss_list)
{
uint index;
- wlc_bss_info_t *bi;
if (!bss_list) {
WL_ERROR("%s: Attempting to free NULL list\n", __func__);
}
/* inspect all BSS descriptor */
for (index = 0; index < bss_list->count; index++) {
- bi = bss_list->ptrs[index];
- if (bi) {
- kfree(bi);
- bss_list->ptrs[index] = NULL;
- }
+ kfree(bss_list->ptrs[index]);
+ bss_list->ptrs[index] = NULL;
}
bss_list->count = 0;
}
skb_pull(p, wlc->hwrxoff);
/* fixup rx header endianness */
- ltoh16_buf((void *)rxh, sizeof(d11rxhdr_t));
+ rxh->RxFrameSize = le16_to_cpu(rxh->RxFrameSize);
+ rxh->PhyRxStatus_0 = le16_to_cpu(rxh->PhyRxStatus_0);
+ rxh->PhyRxStatus_1 = le16_to_cpu(rxh->PhyRxStatus_1);
+ rxh->PhyRxStatus_2 = le16_to_cpu(rxh->PhyRxStatus_2);
+ rxh->PhyRxStatus_3 = le16_to_cpu(rxh->PhyRxStatus_3);
+ rxh->PhyRxStatus_4 = le16_to_cpu(rxh->PhyRxStatus_4);
+ rxh->PhyRxStatus_5 = le16_to_cpu(rxh->PhyRxStatus_5);
+ rxh->RxStatus1 = le16_to_cpu(rxh->RxStatus1);
+ rxh->RxStatus2 = le16_to_cpu(rxh->RxStatus2);
+ rxh->RxTSFTime = le16_to_cpu(rxh->RxTSFTime);
+ rxh->RxChan = le16_to_cpu(rxh->RxChan);
/* MAC inserts 2 pad bytes for a4 headers or QoS or A-MSDU subframes */
if (rxh->RxStatus1 & RXS_PBPRES) {
/* check received pkt has at least frame control field */
if (len >= D11_PHY_HDR_LEN + sizeof(h->frame_control)) {
- fc = ltoh16(h->frame_control);
+ fc = le16_to_cpu(h->frame_control);
} else {
wlc->pub->_cnt->rxrunt++;
goto toss;
h = (struct ieee80211_mgmt *)&plcp[1];
/* fill in 802.11 header */
- h->frame_control = htol16((u16) type);
+ h->frame_control = cpu_to_le16((u16) type);
/* DUR is 0 for multicast bcn, or filled in by MAC for prb resp */
/* A1 filled in by MAC for prb resp, broadcast for bcn */
if (type == FC_BEACON)
- bcopy((const char *)ðer_bcast, (char *)&h->da,
- ETH_ALEN);
- bcopy((char *)&cfg->cur_etheraddr, (char *)&h->sa, ETH_ALEN);
- bcopy((char *)&cfg->BSSID, (char *)&h->bssid, ETH_ALEN);
+ memcpy(&h->da, ðer_bcast, ETH_ALEN);
+ memcpy(&h->sa, &cfg->cur_etheraddr, ETH_ALEN);
+ memcpy(&h->bssid, &cfg->BSSID, ETH_ALEN);
/* SEQ filled in by MAC */
return;
}
- if (MBSS_BCN_ENAB(cfg)) { /* Optimize: Some of if/else could be combined */
- } else if (HWBCN_ENAB(cfg)) { /* Hardware beaconing for this config */
+ /* Optimize: Some of if/else could be combined */
+ if (!MBSS_BCN_ENAB(cfg) && HWBCN_ENAB(cfg)) {
+ /* Hardware beaconing for this config */
u16 bcn[BCN_TMPL_LEN / 2];
u32 both_valid = MCMD_BCN0VLD | MCMD_BCN1VLD;
d11regs_t *regs = wlc->regs;
/* Check if both templates are in use, if so sched. an interrupt
* that will call back into this routine
*/
- if ((R_REG(osh, ®s->maccommand) & both_valid) == both_valid) {
+ if ((R_REG(®s->maccommand) & both_valid) == both_valid) {
/* clear any previous status */
- W_REG(osh, ®s->macintstatus, MI_BCNTPL);
+ W_REG(®s->macintstatus, MI_BCNTPL);
}
/* Check that after scheduling the interrupt both of the
* templates are still busy. if not clear the int. & remask
*/
- if ((R_REG(osh, ®s->maccommand) & both_valid) == both_valid) {
+ if ((R_REG(®s->maccommand) & both_valid) == both_valid) {
wlc->defmacintmask |= MI_BCNTPL;
return;
}
/* padding the ssid with zero and copy it into shm */
memset(ssidbuf, 0, IEEE80211_MAX_SSID_LEN);
- bcopy(ssidptr, ssidbuf, cfg->SSID_len);
+ memcpy(ssidbuf, ssidptr, cfg->SSID_len);
wlc_copyto_shm(wlc, base, ssidbuf, IEEE80211_MAX_SSID_LEN);
ASSERT(txh);
h = (struct ieee80211_hdr *)((u8 *) (txh + 1) + D11_PHY_HDR_LEN);
ASSERT(h);
- fc = ltoh16(h->frame_control);
+ fc = le16_to_cpu(h->frame_control);
/* get the pkt queue info. This was put at wlc_sendctl or wlc_send for PDU */
- fifo = ltoh16(txh->TxFrameID) & TXFID_QUEUE_MASK;
+ fifo = le16_to_cpu(txh->TxFrameID) & TXFID_QUEUE_MASK;
scb = NULL;
return BCME_BUSY;
}
- if ((ltoh16(txh->MacFrameControl) & IEEE80211_FCTL_FTYPE) !=
- IEEE80211_FTYPE_DATA)
+ if (!ieee80211_is_data(txh->MacFrameControl))
wlc->pub->_cnt->txctl++;
return 0;
bi->flags |= WLC_BSS_HT;
}
-/* Deferred event processing */
-static void wlc_process_eventq(void *arg)
-{
- struct wlc_info *wlc = (struct wlc_info *) arg;
- wlc_event_t *etmp;
-
- while ((etmp = wlc_eventq_deq(wlc->eventq))) {
- /* Perform OS specific event processing */
- wl_event(wlc->wl, etmp->event.ifname, etmp);
- if (etmp->data) {
- kfree(etmp->data);
- etmp->data = NULL;
- }
- wlc_event_free(wlc->eventq, etmp);
- }
-}
-
void
wlc_uint64_sub(u32 *a_high, u32 *a_low, u32 b_high, u32 b_low)
{
void wlc_ht_mimops_cap_update(struct wlc_info *wlc, u8 mimops_mode)
{
- wlc->ht_cap.cap_info &= ~HT_CAP_MIMO_PS_MASK;
+ wlc->ht_cap.cap_info &= ~IEEE80211_HT_CAP_SM_PS;
wlc->ht_cap.cap_info |= (mimops_mode << IEEE80211_HT_CAP_SM_PS_SHIFT);
if (AP_ENAB(wlc->pub) && wlc->clk) {
/* check for the particular priority flow control bit being set */
bool
-wlc_txflowcontrol_prio_isset(struct wlc_info *wlc, wlc_txq_info_t *q, int prio)
+wlc_txflowcontrol_prio_isset(struct wlc_info *wlc, struct wlc_txq_info *q,
+ int prio)
{
uint prio_mask;
}
/* propogate the flow control to all interfaces using the given tx queue */
-void wlc_txflowcontrol(struct wlc_info *wlc, wlc_txq_info_t *qi,
+void wlc_txflowcontrol(struct wlc_info *wlc, struct wlc_txq_info *qi,
bool on, int prio)
{
uint prio_bits;
}
void
-wlc_txflowcontrol_override(struct wlc_info *wlc, wlc_txq_info_t *qi, bool on,
- uint override)
+wlc_txflowcontrol_override(struct wlc_info *wlc, struct wlc_txq_info *qi,
+ bool on, uint override)
{
uint prev_override;
static void wlc_txflowcontrol_reset(struct wlc_info *wlc)
{
- wlc_txq_info_t *qi;
+ struct wlc_txq_info *qi;
for (qi = wlc->tx_queues; qi != NULL; qi = qi->next) {
if (qi->stopped) {
}
static void
-wlc_txflowcontrol_signal(struct wlc_info *wlc, wlc_txq_info_t *qi, bool on,
+wlc_txflowcontrol_signal(struct wlc_info *wlc, struct wlc_txq_info *qi, bool on,
int prio)
{
struct wlc_if *wlcif;
}
}
-static wlc_txq_info_t *wlc_txq_alloc(struct wlc_info *wlc, struct osl_info *osh)
+static struct wlc_txq_info *wlc_txq_alloc(struct wlc_info *wlc,
+ struct osl_info *osh)
{
- wlc_txq_info_t *qi, *p;
+ struct wlc_txq_info *qi, *p;
- qi = (wlc_txq_info_t *) wlc_calloc(osh, wlc->pub->unit,
- sizeof(wlc_txq_info_t));
- if (qi == NULL) {
- return NULL;
- }
-
- /* Have enough room for control packets along with HI watermark */
- /* Also, add room to txq for total psq packets if all the SCBs leave PS mode */
- /* The watermark for flowcontrol to OS packets will remain the same */
- pktq_init(&qi->q, WLC_PREC_COUNT,
- (2 * wlc->pub->tunables->datahiwat) + PKTQ_LEN_DEFAULT +
- wlc->pub->psq_pkts_total);
-
- /* add this queue to the the global list */
- p = wlc->tx_queues;
- if (p == NULL) {
- wlc->tx_queues = qi;
- } else {
- while (p->next != NULL)
- p = p->next;
- p->next = qi;
+ qi = wlc_calloc(wlc->pub->unit, sizeof(struct wlc_txq_info));
+ if (qi != NULL) {
+ /*
+ * Have enough room for control packets along with HI watermark
+ * Also, add room to txq for total psq packets if all the SCBs
+ * leave PS mode. The watermark for flowcontrol to OS packets
+ * will remain the same
+ */
+ pktq_init(&qi->q, WLC_PREC_COUNT,
+ (2 * wlc->pub->tunables->datahiwat) + PKTQ_LEN_DEFAULT
+ + wlc->pub->psq_pkts_total);
+
+ /* add this queue to the the global list */
+ p = wlc->tx_queues;
+ if (p == NULL) {
+ wlc->tx_queues = qi;
+ } else {
+ while (p->next != NULL)
+ p = p->next;
+ p->next = qi;
+ }
}
-
return qi;
}
static void wlc_txq_free(struct wlc_info *wlc, struct osl_info *osh,
- wlc_txq_info_t *qi)
+ struct wlc_txq_info *qi)
{
- wlc_txq_info_t *p;
+ struct wlc_txq_info *p;
if (qi == NULL)
return;