ieee80211_pwrsave_smps_t ieee80211_pwrsave_smps_attach(struct ieee80211vap *vap, u_int32_t smpsDynamic)
{
ieee80211_pwrsave_smps_t smps;
osdev_t os_handle = vap->iv_ic->ic_osdev;
smps = (ieee80211_pwrsave_smps_t)OS_MALLOC(os_handle,sizeof(struct ieee80211_pwrsave_smps),0);
if (smps) {
OS_MEMZERO(smps, sizeof(struct ieee80211_pwrsave_smps));
/*
* Initialize pwrsave timer
*/
OS_INIT_TIMER(os_handle,
&smps->ips_timer,
ieee80211_pwrsave_smps_timer,
smps);
if (smpsDynamic && IEEE80211_HAS_DYNAMIC_SMPS_CAP(vap->iv_ic)) {
ieee80211_vap_dynamic_mimo_ps_set(vap);
} else {
ieee80211_vap_dynamic_mimo_ps_clear(vap);
}
smps->ips_smPowerSaveState = IEEE80211_SM_PWRSAVE_DISABLED;
smps->ips_connected = false;
smps->ips_vap = vap;
ieee80211_vap_register_event_handler(vap,ieee80211_pwrsave_smps_vap_event_handler,(void *)smps );
}
return smps;
}
static int gpio_simple_config_led_write(struct file *file, const char *buf,
unsigned long count, void *data)
{
u_int32_t val;
if (sscanf(buf, "%d", &val) != 1)
return -EINVAL;
if(val == SIMPLE_CONFIG_BLINK){
if( ath_gpio_in_val(WPS_LED_GPIO) == 0 ){
initial_led_state = WPS_LED_ON;
}else{
initial_led_state = WPS_LED_OFF;
}
}
if ((val == SIMPLE_CONFIG_BLINK) && !wps_led_blinking) { /* wps LED blinking */
wps_led_blinking = 1;
simple_config_led_state = SIMPLE_CONFIG_BLINK;
ath_gpio_out_val(WPS_LED_GPIO, WPS_LED_ON);
OS_CANCEL_TIMER(&os_timer_t);
OS_INIT_TIMER(NULL, &os_timer_t, wps_led_blink, &os_timer_t);
OS_SET_TIMER(&os_timer_t, 1000);
} else if (val == SIMPLE_CONFIG_FAIL) { /* WPS failed */
wps_led_blinking = 0;
simple_config_led_state = SIMPLE_CONFIG_FAIL;
ath_gpio_out_val(WPS_LED_GPIO, WPS_LED_ON);
OS_CANCEL_TIMER(&os_timer_t);
OS_INIT_TIMER(NULL, &os_timer_t, wps_led_fail, &os_timer_t);
OS_SET_TIMER(&os_timer_t, 200);
} else if (val == SIMPLE_CONFIG_ON) { /* WPS Success */
wps_led_blinking = 0;
simple_config_led_state = SIMPLE_CONFIG_ON;
OS_CANCEL_TIMER(&os_timer_t);
ath_gpio_out_val(WPS_LED_GPIO, WPS_LED_ON);
OS_INIT_TIMER(NULL, &os_timer_t, wps_led_success, &os_timer_t);
OS_SET_TIMER(&os_timer_t, 120000);
} else if (val == SIMPLE_CONFIG_OFF) { /* wps LED off */
wps_led_blinking = 0;
simple_config_led_state = SIMPLE_CONFIG_OFF;
OS_CANCEL_TIMER(&os_timer_t);
ath_gpio_out_val(WPS_LED_GPIO, initial_led_state);
}
return count;
}
/*
* Create a Resource manager.
*/
ieee80211_resmgr_t ieee80211_resmgr_create(struct ieee80211com *ic, ieee80211_resmgr_mode mode)
{
ieee80211_resmgr_t resmgr;
if (ic->ic_tsf_timer == NULL) {
printk("%s: Multi-Channel Scheduler unavailable since no TSF Timer.\n", __func__);
}
else {
ic->ic_caps_ext |= IEEE80211_CEXT_MULTICHAN;
}
if (ic->ic_resmgr) {
printk("%s : ResMgr already exists \n", __func__);
return NULL;
}
/* Allocate ResMgr data structures */
resmgr = (ieee80211_resmgr_t) OS_MALLOC(ic->ic_osdev,
sizeof(struct ieee80211_resmgr),
0);
if (resmgr == NULL) {
printk("%s : ResMgr memory alloction failed\n", __func__);
return NULL;
}
OS_MEMZERO(resmgr, sizeof(struct ieee80211_resmgr));
resmgr->ic = ic;
resmgr->mode = mode;
/* Initialize resource manager state machine */
if (ieee80211_resmgr_sm_create(resmgr) != EOK) {
OS_FREE(resmgr);
printk("%s : ieee80211_resmgr_sm_create failed \n", __func__);
return NULL;
}
if (ic->ic_caps_ext & IEEE80211_CEXT_MULTICHAN) {
if (ieee80211_resmgr_oc_scheduler_create(resmgr, OFF_CHAN_SCHED_POLICY_ROUND_ROBIN) != EOK) {
OS_FREE(resmgr);
printk("%s : ieee80211_resmgr_oc_scheduler_create failed \n", __func__);
return NULL;
}
ASSERT(ic->ic_tsf_timer);
}
else {
/* Do not support P2P */
printk("Error: %s: no Multi-chan hw caps. Disabling Off Channel scheduler.\n", __func__);
}
IEEE80211_RESMGR_LOCK_INIT(resmgr);
spin_lock_init(&resmgr->rm_handler_lock);
OS_INIT_TIMER(ic->ic_osdev, &(resmgr->scandata.canpause_timer), ieee80211_resmgr_canpause_timeout_callback, resmgr);
resmgr->pm_state= IEEE80211_PWRSAVE_FULL_SLEEP;
return resmgr;
}
void ieee80211_prdperfstats_attach(struct ieee80211com *ic)
{
IEEE80211_PRDPERFSTATS_LOCK_INIT(ic);
OS_INIT_TIMER(ic->ic_osdev,
&(ic->ic_prdperfstats_timer),
ieee80211_prdperfstats_gather,
(void *) (ic));
ieee80211_prdperfstat_thrput_attach(ic);
ieee80211_prdperfstat_per_attach(ic);
}
int ieee80211_mlme_vattach(struct ieee80211vap *vap)
{
struct ieee80211com *ic = vap->iv_ic;
ieee80211_mlme_priv_t mlme_priv;
#if 0
vap->iv_debug |= IEEE80211_MSG_MLME;
#endif
if (vap->iv_mlme_priv) {
ASSERT(vap->iv_mlme_priv == 0);
return -1; /* already attached ? */
}
mlme_priv = (ieee80211_mlme_priv_t) OS_MALLOC(ic->ic_osdev, (sizeof(struct ieee80211_mlme_priv)),0);
vap->iv_mlme_priv = mlme_priv;
if (mlme_priv == NULL) {
return -ENOMEM;
} else {
OS_MEMZERO(mlme_priv, sizeof(*mlme_priv));
mlme_priv->im_vap = vap;
mlme_priv->im_osdev = ic->ic_osdev;
OS_INIT_TIMER(ic->ic_osdev, &mlme_priv->im_timeout_timer,
timeout_callback, vap);
/* Default configuration values */
mlme_priv->im_disassoc_timeout = MLME_DEFAULT_DISASSOCIATION_TIMEOUT;
switch(vap->iv_opmode) {
case IEEE80211_M_IBSS:
mlme_adhoc_vattach(vap);
break;
case IEEE80211_M_STA:
mlme_sta_vattach(vap);
break;
default:
break;
}
return 0;
}
}
int
dfs_attach(struct ieee80211com *ic)
{
int i, n;
struct ath_dfs *dfs = (struct ath_dfs *)ic->ic_dfs;
struct ath_dfs_radar_tab_info radar_info;
#define N(a) (sizeof(a)/sizeof(a[0]))
if (dfs != NULL) {
DFS_DPRINTK(dfs, ATH_DEBUG_DFS1,
"%s: ic_dfs was not NULL\n",
__func__);
return 1;
}
if (ic->ic_dfs_state.ignore_dfs) {
DFS_DPRINTK(dfs, ATH_DEBUG_DFS1,
"%s: ignoring dfs\n",
__func__);
return 0;
}
dfs = (struct ath_dfs *)OS_MALLOC(ic->ic_osdev, sizeof(struct ath_dfs), GFP_ATOMIC);
if (dfs == NULL) {
DFS_DPRINTK(dfs, ATH_DEBUG_DFS1,
"%s: ath_dfs allocation failed\n", __func__);
return 1;
}
OS_MEMZERO(dfs, sizeof (struct ath_dfs));
ic->ic_dfs = (void *)dfs;
dfs->ic = ic;
ic->ic_dfs_debug = dfs_get_debug_info;
#ifndef ATH_DFS_RADAR_DETECTION_ONLY
dfs->dfs_nol = NULL;
#endif
/*
* Zero out radar_info. It's possible that the attach function won't
* fetch an initial regulatory configuration; you really do want to
* ensure that the contents indicates there aren't any filters.
*/
OS_MEMZERO(&radar_info, sizeof(radar_info));
ic->ic_dfs_attach(ic, &dfs->dfs_caps, &radar_info);
dfs_clear_stats(ic);
dfs->dfs_event_log_on = 0;
OS_INIT_TIMER(ic->ic_osdev, &(dfs->ath_dfs_task_timer), dfs_task, (void *) (ic));
#ifndef ATH_DFS_RADAR_DETECTION_ONLY
OS_INIT_TIMER(ic->ic_osdev, &(dfs->ath_dfstesttimer), dfs_testtimer_task,
(void *) ic);
dfs->ath_dfs_cac_time = ATH_DFS_WAIT_MS;
dfs->ath_dfstesttime = ATH_DFS_TEST_RETURN_PERIOD_MS;
#endif
ATH_DFSQ_LOCK_INIT(dfs);
STAILQ_INIT(&dfs->dfs_radarq);
ATH_ARQ_LOCK_INIT(dfs);
STAILQ_INIT(&dfs->dfs_arq);
STAILQ_INIT(&(dfs->dfs_eventq));
ATH_DFSEVENTQ_LOCK_INIT(dfs);
dfs->events = (struct dfs_event *)OS_MALLOC(ic->ic_osdev,
sizeof(struct dfs_event)*DFS_MAX_EVENTS,
GFP_ATOMIC);
if (dfs->events == NULL) {
OS_FREE(dfs);
ic->ic_dfs = NULL;
DFS_PRINTK("%s: events allocation failed\n", __func__);
return 1;
}
for (i = 0; i < DFS_MAX_EVENTS; i++) {
STAILQ_INSERT_TAIL(&(dfs->dfs_eventq), &dfs->events[i], re_list);
}
dfs->pulses = (struct dfs_pulseline *)OS_MALLOC(ic->ic_osdev, sizeof(struct dfs_pulseline), GFP_ATOMIC);
if (dfs->pulses == NULL) {
OS_FREE(dfs->events);
dfs->events = NULL;
OS_FREE(dfs);
ic->ic_dfs = NULL;
DFS_PRINTK("%s: pulse buffer allocation failed\n", __func__);
return 1;
}
dfs->pulses->pl_lastelem = DFS_MAX_PULSE_BUFFER_MASK;
/* Allocate memory for radar filters */
for (n=0; n<DFS_MAX_RADAR_TYPES; n++) {
dfs->dfs_radarf[n] = (struct dfs_filtertype *)OS_MALLOC(ic->ic_osdev, sizeof(struct dfs_filtertype),GFP_ATOMIC);
if (dfs->dfs_radarf[n] == NULL) {
DFS_PRINTK("%s: cannot allocate memory for radar filter types\n",
__func__);
goto bad1;
}
OS_MEMZERO(dfs->dfs_radarf[n], sizeof(struct dfs_filtertype));
}
/* Allocate memory for radar table */
dfs->dfs_radartable = (int8_t **)OS_MALLOC(ic->ic_osdev, 256*sizeof(int8_t *), GFP_ATOMIC);
if (dfs->dfs_radartable == NULL) {
DFS_PRINTK("%s: cannot allocate memory for radar table\n",
__func__);
goto bad1;
}
for (n=0; n<256; n++) {
dfs->dfs_radartable[n] = OS_MALLOC(ic->ic_osdev, DFS_MAX_RADAR_OVERLAP*sizeof(int8_t),
GFP_ATOMIC);
if (dfs->dfs_radartable[n] == NULL) {
DFS_PRINTK("%s: cannot allocate memory for radar table entry\n",
__func__);
goto bad2;
}
}
if (usenol == 0)
DFS_PRINTK("%s: NOL disabled\n", __func__);
else if (usenol == 2)
DFS_PRINTK("%s: NOL disabled; no CSA\n", __func__);
dfs->dfs_rinfo.rn_use_nol = usenol;
/* Init the cached extension channel busy for false alarm reduction */
dfs->dfs_rinfo.ext_chan_busy_ts = ic->ic_get_TSF64(ic);
dfs->dfs_rinfo.dfs_ext_chan_busy = 0;
/* Init the Bin5 chirping related data */
dfs->dfs_rinfo.dfs_bin5_chirp_ts = dfs->dfs_rinfo.ext_chan_busy_ts;
dfs->dfs_rinfo.dfs_last_bin5_dur = MAX_BIN5_DUR;
dfs->dfs_b5radars = NULL;
/*
* If dfs_init_radar_filters() fails, we can abort here and
* reconfigure when the first valid channel + radar config
* is available.
*/
if ( dfs_init_radar_filters( ic, &radar_info) ) {
DFS_PRINTK(" %s: Radar Filter Intialization Failed \n",
__func__);
return 1;
}
dfs->ath_dfs_false_rssi_thres = RSSI_POSSIBLY_FALSE;
dfs->ath_dfs_peak_mag = SEARCH_FFT_REPORT_PEAK_MAG_THRSH;
dfs->dfs_phyerr_freq_min = 0x7fffffff;
dfs->dfs_phyerr_freq_max = 0;
dfs->dfs_phyerr_queued_count = 0;
dfs->dfs_phyerr_w53_counter = 0;
dfs->dfs_pri_multiplier = 2;
dfs->ath_dfs_nol_timeout = DFS_NOL_TIMEOUT_S;
return 0;
bad2:
OS_FREE(dfs->dfs_radartable);
dfs->dfs_radartable = NULL;
bad1:
for (n=0; n<DFS_MAX_RADAR_TYPES; n++) {
if (dfs->dfs_radarf[n] != NULL) {
OS_FREE(dfs->dfs_radarf[n]);
dfs->dfs_radarf[n] = NULL;
}
}
if (dfs->pulses) {
OS_FREE(dfs->pulses);
dfs->pulses = NULL;
}
if (dfs->events) {
OS_FREE(dfs->events);
dfs->events = NULL;
}
if (ic->ic_dfs) {
OS_FREE(ic->ic_dfs);
ic->ic_dfs = NULL;
}
return 1;
#undef N
}
void
dfs_nol_addchan(struct ath_dfs *dfs, struct ieee80211_channel *chan,
u_int32_t dfs_nol_timeout)
{
#define TIME_IN_MS 1000
#define TIME_IN_US (TIME_IN_MS * 1000)
struct dfs_nolelem *nol, *elem, *prev;
struct dfs_nol_timer_arg *dfs_nol_arg;
/* XXX for now, assume all events are 20MHz wide */
int ch_width = 20;
if (dfs == NULL) {
DFS_DPRINTK(dfs, ATH_DEBUG_DFS_NOL, "%s: sc_dfs is NULL\n", __func__);
return;
}
nol = dfs->dfs_nol;
prev = dfs->dfs_nol;
elem = NULL;
while (nol != NULL) {
if ((nol->nol_freq == chan->ic_freq) &&
(nol->nol_chwidth == ch_width)) {
nol->nol_start_ticks = adf_os_ticks();
nol->nol_timeout_ms = dfs_nol_timeout*TIME_IN_MS;
DFS_DPRINTK(dfs, ATH_DEBUG_DFS_NOL,
"%s: Update OS Ticks for NOL %d MHz / %d MHz\n",
__func__, nol->nol_freq, nol->nol_chwidth);
OS_CANCEL_TIMER(&nol->nol_timer);
OS_SET_TIMER(&nol->nol_timer, dfs_nol_timeout*TIME_IN_MS);
return;
}
prev = nol;
nol = nol->nol_next;
}
/* Add a new element to the NOL*/
elem = (struct dfs_nolelem *)OS_MALLOC(dfs->ic->ic_osdev, sizeof(struct dfs_nolelem),GFP_ATOMIC);
if (elem == NULL) {
goto bad;
}
dfs_nol_arg = (struct dfs_nol_timer_arg *)OS_MALLOC(dfs->ic->ic_osdev,
sizeof(struct dfs_nol_timer_arg), GFP_ATOMIC);
if (dfs_nol_arg == NULL) {
OS_FREE(elem);
goto bad;
}
elem->nol_freq = chan->ic_freq;
elem->nol_chwidth = ch_width;
elem->nol_start_ticks = adf_os_ticks();
elem->nol_timeout_ms = dfs_nol_timeout*TIME_IN_MS;
elem->nol_next = NULL;
if (prev) {
prev->nol_next = elem;
} else {
/* This is the first element in the NOL */
dfs->dfs_nol = elem;
}
dfs_nol_arg->dfs = dfs;
dfs_nol_arg->delfreq = elem->nol_freq;
dfs_nol_arg->delchwidth = elem->nol_chwidth;
OS_INIT_TIMER(dfs->ic->ic_osdev, &elem->nol_timer, dfs_remove_from_nol,
dfs_nol_arg);
OS_SET_TIMER(&elem->nol_timer, dfs_nol_timeout*TIME_IN_MS);
/* Update the NOL counter */
dfs->dfs_nol_count++;
DFS_DPRINTK(dfs, ATH_DEBUG_DFS_NOL,
"%s: new NOL channel %d MHz / %d MHz\n",
__func__,
elem->nol_freq,
elem->nol_chwidth);
return;
bad:
DFS_DPRINTK(dfs, ATH_DEBUG_DFS_NOL | ATH_DEBUG_DFS,
"%s: failed to allocate memory for nol entry\n", __func__);
#undef TIME_IN_MS
#undef TIME_IN_US
}
/*
* External UMAC Interface
*/
wlan_if_t
wlan_vap_create(wlan_dev_t devhandle,
enum ieee80211_opmode opmode,
int scan_priority_base,
int flags,
u_int8_t *bssid)
{
#if ATH_SUPPORT_FLOWMAC_MODULE
#define FLOWMAC_FLOWCONTROL_VAP 1
#define FLOWMAC_FLOWCONTROL_ETH 2
#endif
struct ieee80211com *ic = devhandle;
struct ieee80211vap *vap;
IEEE80211_DPRINTF_IC(ic, IEEE80211_VERBOSE_LOUD, IEEE80211_MSG_DEBUG,
"%s : enter. devhandle=0x%x, opmode=%s, flags=0x%x\n",
__func__,
devhandle,
ieee80211_opmode2string(opmode),
flags
);
vap = ic->ic_vap_create(ic, opmode, scan_priority_base, flags, bssid);
if (vap == NULL) {
printk("%s: failed to create a vap object\n", __func__);
return NULL;
}
ieee80211_vap_pause_late_vattach(ic,vap);
ieee80211_resmgr_vattach(ic->ic_resmgr, vap);
ieee80211_vap_deleted_clear(vap); /* clear the deleted */
/* when all done, add vap to queue */
IEEE80211_COMM_LOCK(ic);
TAILQ_INSERT_TAIL(&ic->ic_vaps, vap, iv_next);
IEEE80211_COMM_UNLOCK(ic);
IEEE80211_DPRINTF_IC(ic, IEEE80211_VERBOSE_LOUD, IEEE80211_MSG_DEBUG,
"%s : exit. devhandle=0x%x, opmode=%s, flags=0x%x.\n",
__func__,
devhandle,
ieee80211_opmode2string(opmode),
flags
);
/* Begin: gengzj added for wifipos 2013-11-26 */
/*AUTELAN-Added-begin:Added by pengdecai for wifi scan locate function*/
vap->iv_locate = 0;
vap->iv_sl_debug = 0;
vap->iv_sl_asinfo = 0;
vap->iv_sl_pckcnt = 0;
/*AUTELAN-Added-end:Added by pengdecai for wifi scan locate function*/
/* End: gengzj added end */
/* TODO FIXME
* To check the ath layer flow control status in softc and the create
* enable or disable the flow control status in vap
*/
#if ATH_SUPPORT_FLOWMAC_MODULE
vap->iv_flowmac = FLOWMAC_FLOWCONTROL_VAP | FLOWMAC_FLOWCONTROL_ETH;
#endif
ieee80211_vap_cache_attach(vap); //added by duanmingzhe for 80211 cache
/* Begin: Added by wangjia, for traffic limit. 2012-10-25. */
ieee80211_tl_vap_init(vap);
/* End: Added by wangjia, for traffic limit. 2012-10-25. */
/*zhaoyang1 transplant from 717*/
/*Begin:Added by duanmingzhe for user isolation*/
vap->iv_switch = 0;
/*End:Added by duanmingzhe for user isolation*/
/*Begin:Add by duanmingzhe for develop the policy of mac binding*/
vap->vap_dhcp_enable = 0;
vap->vap_ip_auto_learning = 0;
vap->vap_pppoe_enable = 0;
/*End:Add by duanmingzhe for develop the policy of mac binding*/
/*zhaoyang add for noisefloor switch when channel 0*/
vap->noisefloor_enable = 1;
/*zhaoyang add end*/
/*zhaoyang modify for add rd_trap switch*/
#if ATH_SUPPORT_WAPI
vap->rd_trap = 0;
#endif
/*zhaoyang modify end*/
/*suzhaoyu add for customer online-traffic limit*/
vap->lowest_traffic_limit_switch = 0;
vap->lowest_traffic_limit_threshold = 0;
vap->lowest_traffic_limit_timelength =5;
OS_INIT_TIMER(ic->ic_osdev, &(vap->online_traffic_timer), ieee80211_online_traffic_check, (void *) (vap));
/*suzhaoyu addend*/
/*zhaoyang1 transplant end*/
/*<begin : transplant by caizhibang from apv5*/
/*yanggs add for thinap wds*/
vap->vap_wds = 0;
/*yanggs add end*/
/*end : transplant by caizhibang from apv5 >*/
/*zhaoyang modify for default disable UAPSD*/
IEEE80211_VAP_UAPSD_DISABLE(vap);
/*zhaoyang modify end*/
return vap;
}
wlan_btamp_conn_sm_t
wlan_btamp_conn_sm_create(wlan_if_t vaphandle,
wlan_btamp_conn_sm_t *linkHandle,
u_int8_t *peer_addr,
bool initiating)
{
wlan_btamp_conn_sm_t sm;
struct ieee80211vap *vap = vaphandle;
osdev_t oshandle = vap->iv_ic->ic_osdev;
struct ieee80211_node *ni;
sm = (wlan_btamp_conn_sm_t) OS_MALLOC(oshandle, sizeof(struct _wlan_btamp_conn_sm), 0);
if (!sm) {
return NULL;
}
OS_MEMZERO(sm, sizeof(struct _wlan_btamp_conn_sm));
sm->os_handle = oshandle;
sm->vap_handle = vaphandle;
OS_MEMCPY(sm->peer, peer_addr, IEEE80211_ADDR_LEN);
sm->initiating = initiating;
sm->hsm_handle = ieee80211_sm_create(oshandle,
"btamp_conn",
(void *) sm,
IEEE80211_BTAMP_CONN_STATE_BEACONING,
ieee80211_btamp_conn_sm_info,
sizeof(ieee80211_btamp_conn_sm_info)/sizeof(ieee80211_state_info),
MAX_QUEUED_EVENTS,
sizeof(u_int32_t) /* event data of size int */,
MESGQ_PRIORITY_HIGH,
IEEE80211_HSM_ASYNCHRONOUS, /* run the SM asynchronously */
ieee80211_btamp_conn_sm_debug_print,
btamp_event_name,
IEEE80211_N(btamp_event_name));
if (!sm->hsm_handle) {
OS_FREE(sm);
IEEE80211_DPRINTF(vaphandle, IEEE80211_MSG_STATE,
"%s : ieee80211_sm_create failed\n", __func__);
return NULL;
}
sm->max_assoc_attempts = MAX_ASSOC_ATTEMPTS;
sm->max_auth_attempts = MAX_AUTH_ATTEMPTS;
sm->max_mgmt_time = MAX_MGMT_TIME;
OS_INIT_TIMER(oshandle, &(sm->sm_timer), btamp_conn_sm_timer_handler, (void *)sm);
/* Register MLME event handlers */
wlan_vap_register_mlme_event_handlers(vaphandle, (os_if_t)linkHandle, &btamp_mlme_evt_handler);
/* Create a node for the peer mac address */
ni = ieee80211_dup_bss(vap, peer_addr);
if (ni) {
if (initiating) {
IEEE80211_ADDR_COPY(ni->ni_bssid, peer_addr);
/* Set up SSID */
snprintf((char *)ni->ni_essid, 22, "AMP-%02x-%02x-%02x-%02x-%02x-%02x",
peer_addr[0], peer_addr[1], peer_addr[2],
peer_addr[3], peer_addr[4], peer_addr[5]);
ni->ni_esslen = 21;
ni->ni_flags |= IEEE80211_NODE_ERP; // Mark the node as ERP
}
ieee80211_free_node(ni); /* Decrement the extra ref count */
}
return sm;
}
static int gpio_simple_config_led_write(struct file *file, const char *buf,
unsigned long count, void *data)
{
u_int32_t val;
if (sscanf(buf, "%d", &val) != 1)
{
printk("\n val wrong %d\n", val);
return -EINVAL;
}
printk("\n config_led_write %d \n", val);
if (val == SIMPLE_CONFIG_ON) {
printk("\nWPS SIMPLE_CONFIG_ON\n");
/* WPS Success */
simple_config_led_state = SIMPLE_CONFIG_ON;
OS_CANCEL_TIMER(&os_timer_t);
WPSled=WPS_LED_ON;
gpio_wps_other_led_off();
ath_gpio_out_val(wps_led_gpio, WPSled);
wps_success_func();
OS_INIT_TIMER(NULL, &os_timer_t, wps_led_on, &os_timer_t);
OS_SET_TIMER(&os_timer_t, 100);
} else if (val == SIMPLE_CONFIG_OFF) { /* WPS failed */
simple_config_led_state = SIMPLE_CONFIG_OFF;
OS_CANCEL_TIMER(&os_timer_t);
WPSled=WPS_LED_OFF;
gpio_wps_other_led_off();
printk("\nWPS SIMPLE_CONFIG_OFF\n");
ath_gpio_out_val(wps_led_gpio, WPSled);
}
/* START ADD: c00217102 2012-8-12 FOR WS323 */
else if (val == SIMPLE_CONFIG_OVERLAP)
{
printk("\nWPS SIMPLE_CONFIG_OVERLAP\n");
simple_config_led_state = SIMPLE_CONFIG_OVERLAP;
OS_CANCEL_TIMER(&os_timer_t);
WPSled=WPS_LED_ON;
gpio_wps_other_led_off();
ath_gpio_out_val(wps_led_gpio, WPSled);
OS_INIT_TIMER(NULL, &os_timer_t, wps_led_overlap, &os_timer_t);
OS_SET_TIMER(&os_timer_t, 100);
}else if (val == SIMPLE_CONFIG_INGRESS_ERROR)
{
simple_config_led_state = SIMPLE_CONFIG_INGRESS_ERROR;
OS_CANCEL_TIMER(&os_timer_t);
WPSled=WPS_LED_ON;
gpio_wps_other_led_off();
ath_gpio_out_val(wps_led_gpio, WPSled);
printk("\nWPS SIMPLE_CONFIG_INGRESS_ERROR\n");
OS_INIT_TIMER(NULL, &os_timer_t, wps_led_error, &os_timer_t);
OS_SET_TIMER(&os_timer_t, 100);
}
else if (val == SIMPLE_CONFIG_INGRESS)
{
simple_config_led_state = SIMPLE_CONFIG_INGRESS;
OS_CANCEL_TIMER(&os_timer_t);
WPSled=WPS_LED_ON;
gpio_wps_other_led_off();
ath_gpio_out_val(wps_led_gpio, WPSled);
printk("\nWPS SIMPLE_CONFIG_INGRESS\n");
OS_INIT_TIMER(NULL, &os_timer_t, wps_led_ingress, &os_timer_t);
OS_SET_TIMER(&os_timer_t, 100);
}
/* END ADD: c00217102 2012-8-12 FOR WS323 */
return count;
}
int
ieee80211_ifattach(struct ieee80211com *ic, IEEE80211_REG_PARAMETERS *ieee80211_reg_parm)
{
u_int8_t bcast[IEEE80211_ADDR_LEN] = {0xff,0xff,0xff,0xff,0xff,0xff};
int error = 0;
ic->ic_reg_parm = *ieee80211_reg_parm;
/* set up broadcast address */
IEEE80211_ADDR_COPY(ic->ic_broadcast, bcast);
/* initialize channel list */
ieee80211_update_channellist(ic, 0);
/* initialize rate set */
ieee80211_init_rateset(ic);
/* validate ic->ic_curmode */
if (!IEEE80211_SUPPORT_PHY_MODE(ic, ic->ic_curmode))
ic->ic_curmode = IEEE80211_MODE_AUTO;
/* setup initial channel settings */
ic->ic_curchan = ieee80211_get_channel(ic, 0); /* arbitrarily pick the first channel */
/* Enable marking of dfs by default */
ic->ic_flags_ext |= IEEE80211_FEXT_MARKDFS;
if (ic->ic_reg_parm.htEnableWepTkip) {
ieee80211_ic_wep_tkip_htrate_set(ic);
} else {
ieee80211_ic_wep_tkip_htrate_clear(ic);
}
if (ic->ic_reg_parm.htVendorIeEnable)
IEEE80211_ENABLE_HTVIE(ic);
/* whether to ignore 11d beacon */
if (ic->ic_reg_parm.ignore11dBeacon)
IEEE80211_ENABLE_IGNORE_11D_BEACON(ic);
if (ic->ic_reg_parm.disallowAutoCCchange) {
ieee80211_ic_disallowAutoCCchange_set(ic);
}
else {
ieee80211_ic_disallowAutoCCchange_clear(ic);
}
(void) ieee80211_setmode(ic, ic->ic_curmode, ic->ic_opmode);
ic->ic_intval = IEEE80211_BINTVAL_DEFAULT; /* beacon interval */
ic->ic_set_beacon_interval(ic);
ic->ic_lintval = 1; /* listen interval */
ic->ic_lintval_assoc = IEEE80211_LINTVAL_MAX; /* listen interval to use in association */
ic->ic_bmisstimeout = IEEE80211_BMISS_LIMIT * ic->ic_intval;
TAILQ_INIT(&ic->ic_vaps);
ic->ic_txpowlimit = IEEE80211_TXPOWER_MAX;
/* Intialize WDS Auto Detect mode */
ic->ic_flags_ext |= IEEE80211_FEXT_WDS_AUTODETECT;
/*
** Enable the 11d country code IE by default
*/
ic->ic_flags_ext |= IEEE80211_FEXT_COUNTRYIE;
/* setup CWM configuration */
ic->ic_cwm_set_mode(ic, ic->ic_reg_parm.cwmMode);
ic->ic_cwm_set_extoffset(ic, ic->ic_reg_parm.cwmExtOffset);
ic->ic_cwm_set_extprotmode(ic, ic->ic_reg_parm.cwmExtProtMode);
ic->ic_cwm_set_extprotspacing(ic, ic->ic_reg_parm.cwmExtProtSpacing);
#if tbd
/* XXX - TODO - move these into ath layer */
#else
ic->ic_cwm_set_enable(ic, ic->ic_reg_parm.cwmEnable);
ic->ic_cwm_set_extbusythreshold(ic, ic->ic_reg_parm.cwmExtBusyThreshold);
#endif
ic->ic_enable2GHzHt40Cap = ic->ic_reg_parm.enable2GHzHt40Cap;
#ifdef ATH_COALESCING
ic->ic_tx_coalescing = ic->ic_reg_parm.txCoalescingEnable;
#endif
ic->ic_ignoreDynamicHalt = ic->ic_reg_parm.ignoreDynamicHalt;
/* default to auto ADDBA mode */
ic->ic_addba_mode = ADDBA_MODE_AUTO;
if (ic->ic_reg_parm.ht20AdhocEnable) {
/*
* Support HT rates in Ad hoc connections.
*/
if (IEEE80211_SUPPORT_PHY_MODE(ic, IEEE80211_MODE_11NA_HT20) ||
IEEE80211_SUPPORT_PHY_MODE(ic, IEEE80211_MODE_11NG_HT20)) {
ieee80211_ic_ht20Adhoc_set(ic);
if (ic->ic_reg_parm.htAdhocAggrEnable) {
ieee80211_ic_htAdhocAggr_set(ic);
}
}
}
if (ic->ic_reg_parm.ht40AdhocEnable) {
/*
* Support HT rates in Ad hoc connections.
*/
if (IEEE80211_SUPPORT_PHY_MODE(ic, IEEE80211_MODE_11NA_HT40PLUS) ||
IEEE80211_SUPPORT_PHY_MODE(ic, IEEE80211_MODE_11NA_HT40MINUS) ||
IEEE80211_SUPPORT_PHY_MODE(ic, IEEE80211_MODE_11NG_HT40PLUS) ||
IEEE80211_SUPPORT_PHY_MODE(ic, IEEE80211_MODE_11NG_HT40MINUS)) {
ieee80211_ic_ht40Adhoc_set(ic);
if (ic->ic_reg_parm.htAdhocAggrEnable) {
ieee80211_ic_htAdhocAggr_set(ic);
}
}
}
OS_INIT_TIMER(ic->ic_osdev, &(ic->ic_inact_timer), ieee80211_inact_timeout, (void *) (ic));
#if UMAC_SUPPORT_WNM
OS_INIT_TIMER(ic->ic_osdev, &(ic->ic_bssload_timer), ieee80211_bssload_timeout, (void *) (ic));
#endif
if (ic->ic_reg_parm.disable2040Coexist) {
ic->ic_flags |= IEEE80211_F_COEXT_DISABLE;
} else {
ic->ic_flags &= ~IEEE80211_F_COEXT_DISABLE;
}
/* setup other modules */
/* The TSF Timer module is required when P2P or Off-channel support are required */
ic->ic_tsf_timer = ieee80211_tsf_timer_attach(ic);
#if UMAC_SUPPORT_TDLS_CHAN_SWITCH
/* TDLS off-channel support requires TSF timer */
if (ic->ic_tsf_timer) {
ieee80211_ic_off_channel_support_set(ic);
}
else {
ieee80211_ic_off_channel_support_clear(ic);
}
#else
ieee80211_ic_off_channel_support_clear(ic);
#endif
ieee80211_p2p_attach(ic);
ieee80211_crypto_attach(ic);
ieee80211_node_attach(ic);
ieee80211_proto_attach(ic);
ieee80211_power_attach(ic);
ieee80211_mlme_attach(ic);
#if ATH_SUPPORT_DFS
ieee80211_dfs_attach(ic);
#endif /* ATH_SUPPORT_DFS */
if (IEEE80211_ENAB_AOW(ic))
ieee80211_aow_attach(ic);
error = ieee80211_scan_table_attach(ic, &(ic->ic_scan_table), ic->ic_osdev);
if (error) {
ieee80211_node_detach(ic);
return error;
}
/*
* By default overwrite probe response with beacon IE in scan entry.
*/
ieee80211_ic_override_proberesp_ie_set(ic);
error = ieee80211_scan_attach(&(ic->ic_scanner),
ic,
ic->ic_osdev,
ieee80211_is_connected,
ieee80211_is_txq_empty,
ieee80211_is_sw_txq_empty);
if (error) {
/* detach and free already allocated memory for scan */
ieee80211_scan_table_detach(&(ic->ic_scan_table));
ieee80211_node_detach(ic);
return error;
}
ic->ic_resmgr = ieee80211_resmgr_create(ic, IEEE80211_RESMGR_MODE_SINGLE_CHANNEL);
error = ieee80211_acs_attach(&(ic->ic_acs),
ic,
ic->ic_osdev);
if (error) {
/* detach and free already allocated memory for scan */
ieee80211_scan_table_detach(&(ic->ic_scan_table));
ieee80211_scan_detach(&(ic->ic_scanner));
ieee80211_node_detach(ic);
return error;
}
ic->ic_notify_tx_bcn_mgr = ieee80211_notify_tx_bcn_attach(ic);
ieee80211_rptplacement_attach(ic);
IEEE80211_TDLS_ATTACH(ic);
#if UMAC_SUPPORT_VI_DBG
ieee80211_vi_dbg_attach(ic);
#endif
ieee80211_quiet_attach(ic);
ieee80211_admctl_attach(ic);
/*
* Perform steps that require multiple objects to be initialized.
* For example, cross references between objects such as ResMgr and Scanner.
*/
ieee80211_scan_attach_complete(ic->ic_scanner);
ieee80211_resmgr_create_complete(ic->ic_resmgr);
ieee80211_smartantenna_attach(ic);
ieee80211_prdperfstats_attach(ic);
ic->ic_get_ext_chan_info = ieee80211_get_extchan_info;
/* initialization complete */
ic->ic_initialized = 1;
return 0;
}
int __init ath_simple_config_init(void)
{
#ifdef CONFIG_CUS100
u32 mask = 0;
#endif
#ifdef JUMPSTART_GPIO
int req;
#endif
int ret;
#ifdef AP_RESET_GPIO
int req2;
#endif
ret = misc_register(&athfr_miscdev);
if (ret < 0) {
printk("*** ath misc_register failed %d *** \n", ret);
return -1;
}
#ifdef AP_RESET_GPIO
ath_gpio_config_input(AP_RESET_GPIO);
ath_gpio_config_int(AP_RESET_GPIO, INT_TYPE_LEVEL, INT_POL_ACTIVE_LOW);
printk("%s (%s) AP_RESET_GPIO: %d\n", __FILE__, __func__, AP_RESET_GPIO);
#endif
#ifdef JUMPSTART_GPIO
#ifdef CONFIG_CUS100
mask = ath_reg_rd(ATH_MISC_INT_MASK);
ath_reg_wr(ATH_MISC_INT_MASK, mask | (1 << 2));
ath_gpio_config_int(JUMPSTART_GPIO, INT_TYPE_LEVEL,
INT_POL_ACTIVE_HIGH);
ath_gpio_intr_enable(JUMPSTART_GPIO);
ath_gpio_config_input(JUMPSTART_GPIO);
#else
ath_gpio_config_input(JUMPSTART_GPIO);
/* configure Jumpstart GPIO as level triggered interrupt */
ath_gpio_config_int(JUMPSTART_GPIO, INT_TYPE_LEVEL,
INT_POL_ACTIVE_LOW);
printk("%s (%s) JUMPSTART_GPIO: %d\n", __FILE__, __func__,
JUMPSTART_GPIO);
#ifndef CONFIG_MACH_AR934x
ath_reg_rmw_clear(ATH_GPIO_FUNCTIONS, (1 << 2));
ath_reg_rmw_clear(ATH_GPIO_FUNCTIONS, (1 << 16));
ath_reg_rmw_clear(ATH_GPIO_FUNCTIONS, (1 << 20));
#endif
#endif
req = request_irq(ATH_GPIO_IRQn(JUMPSTART_GPIO), jumpstart_irq, 0,
#ifdef AP_RESET_GPIO
"SW JUMPSTART", NULL);
#else
"SW JUMPSTART/FACTORY RESET", NULL);
#endif
if (req != 0) {
printk("request_irq for jumpstart failed (error %d)\n", req);
misc_deregister(&athfr_miscdev);
ath_gpio_intr_shutdown(ATH_GPIO_IRQn(JUMPSTART_GPIO));
return -1;
}
#endif /* #ifdef JUMPSTART_GPIO */
#ifdef AP_RESET_GPIO
req2 = request_irq(ATH_GPIO_IRQn(AP_RESET_GPIO), ath_reset_irq, 0,
"FACTORY RESET", NULL);
if (req2 != 0) {
printk("request_irq for factory reset failed (error %d)\n", req);
misc_deregister(&athfr_miscdev);
free_irq(req, NULL);
return -1;
}
#endif
#ifdef ATH_S17INT_GPIO
ath_gpio_config_input(ATH_S17INT_GPIO);
/* configure S17 interrupt GPIO as level triggered interrupt */
ath_gpio_config_int(ATH_S17INT_GPIO, INT_TYPE_LEVEL,
INT_POL_ACTIVE_LOW);
printk("%s (%s) ATH_S17INT_GPIO: %d\n", __FILE__, __func__,
ATH_S17INT_GPIO);
#endif
#if !defined(CONFIG_I2S) && defined(AP_USB_LED_GPIO)
ath_gpio_config_output(AP_USB_LED_GPIO);
#endif
init_waitqueue_head(&ath_fr_wq);
#ifdef WPS_LED_GPIO
create_simple_config_led_proc_entry();
#endif
#ifdef POWER_ON_GLED_GPIO
printk("%s (%s) POWER_ON_GLED_GPIO: %d\n", __FILE__, __func__, POWER_ON_GLED_GPIO);
ath_gpio_config_output(POWER_ON_GLED_GPIO);
ath_gpio_out_val(POWER_ON_GLED_GPIO, POWER_LED_ON);
#endif
#ifdef POWER_ON_RLED_GPIO
printk("%s (%s) POWER_ON_RLED_GPIO: %d\n", __FILE__, __func__, POWER_ON_RLED_GPIO);
ath_gpio_config_output(POWER_ON_RLED_GPIO);
ath_gpio_out_val(POWER_ON_RLED_GPIO, POWER_LED_OFF);
OS_INIT_TIMER(NULL, &power_on_timer, power_led_blink, NULL);
OS_SET_TIMER(&power_on_timer, POWER_LED_BLINK_INTERVAL);
#endif
return 0;
}
