python_code
stringlengths 0
1.8M
| repo_name
stringclasses 7
values | file_path
stringlengths 5
99
|
|---|---|---|
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <hal_data.h>
#include <linux/jiffies.h>
void _ips_enter(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
pwrpriv->bips_processing = true;
/* syn ips_mode with request */
pwrpriv->ips_mode = pwrpriv->ips_mode_req;
pwrpriv->ips_enter_cnts++;
if (rf_off == pwrpriv->change_rfpwrstate) {
pwrpriv->bpower_saving = true;
if (pwrpriv->ips_mode == IPS_LEVEL_2)
pwrpriv->bkeepfwalive = true;
rtw_ips_pwr_down(padapter);
pwrpriv->rf_pwrstate = rf_off;
}
pwrpriv->bips_processing = false;
}
void ips_enter(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
hal_btcoex_IpsNotify(padapter, pwrpriv->ips_mode_req);
mutex_lock(&pwrpriv->lock);
_ips_enter(padapter);
mutex_unlock(&pwrpriv->lock);
}
int _ips_leave(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
int result = _SUCCESS;
if ((pwrpriv->rf_pwrstate == rf_off) && (!pwrpriv->bips_processing)) {
pwrpriv->bips_processing = true;
pwrpriv->change_rfpwrstate = rf_on;
pwrpriv->ips_leave_cnts++;
result = rtw_ips_pwr_up(padapter);
if (result == _SUCCESS) {
pwrpriv->rf_pwrstate = rf_on;
}
pwrpriv->bips_processing = false;
pwrpriv->bkeepfwalive = false;
pwrpriv->bpower_saving = false;
}
return result;
}
int ips_leave(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
int ret;
if (!is_primary_adapter(padapter))
return _SUCCESS;
mutex_lock(&pwrpriv->lock);
ret = _ips_leave(padapter);
mutex_unlock(&pwrpriv->lock);
if (ret == _SUCCESS)
hal_btcoex_IpsNotify(padapter, IPS_NONE);
return ret;
}
static bool rtw_pwr_unassociated_idle(struct adapter *adapter)
{
struct adapter *buddy = adapter->pbuddy_adapter;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct xmit_priv *pxmit_priv = &adapter->xmitpriv;
bool ret = false;
if (adapter_to_pwrctl(adapter)->bpower_saving)
goto exit;
if (time_before(jiffies, adapter_to_pwrctl(adapter)->ips_deny_time))
goto exit;
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR)
|| check_fwstate(pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS)
|| check_fwstate(pmlmepriv, WIFI_AP_STATE)
|| check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)
)
goto exit;
/* consider buddy, if exist */
if (buddy) {
struct mlme_priv *b_pmlmepriv = &(buddy->mlmepriv);
if (check_fwstate(b_pmlmepriv, WIFI_ASOC_STATE|WIFI_SITE_MONITOR)
|| check_fwstate(b_pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS)
|| check_fwstate(b_pmlmepriv, WIFI_AP_STATE)
|| check_fwstate(b_pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)
)
goto exit;
}
if (pxmit_priv->free_xmitbuf_cnt != NR_XMITBUFF ||
pxmit_priv->free_xmit_extbuf_cnt != NR_XMIT_EXTBUFF) {
netdev_dbg(adapter->pnetdev,
"There are some pkts to transmit\n");
netdev_dbg(adapter->pnetdev,
"free_xmitbuf_cnt: %d, free_xmit_extbuf_cnt: %d\n",
pxmit_priv->free_xmitbuf_cnt,
pxmit_priv->free_xmit_extbuf_cnt);
goto exit;
}
ret = true;
exit:
return ret;
}
/*
* ATTENTION:
*rtw_ps_processor() doesn't handle LPS.
*/
void rtw_ps_processor(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
u32 ps_deny = 0;
mutex_lock(&adapter_to_pwrctl(padapter)->lock);
ps_deny = rtw_ps_deny_get(padapter);
mutex_unlock(&adapter_to_pwrctl(padapter)->lock);
if (ps_deny != 0)
goto exit;
if (pwrpriv->bInSuspend) {/* system suspend or autosuspend */
pdbgpriv->dbg_ps_insuspend_cnt++;
return;
}
pwrpriv->ps_processing = true;
if (pwrpriv->ips_mode_req == IPS_NONE)
goto exit;
if (!rtw_pwr_unassociated_idle(padapter))
goto exit;
if ((pwrpriv->rf_pwrstate == rf_on) && ((pwrpriv->pwr_state_check_cnts%4) == 0)) {
pwrpriv->change_rfpwrstate = rf_off;
{
ips_enter(padapter);
}
}
exit:
pwrpriv->ps_processing = false;
}
static void pwr_state_check_handler(struct timer_list *t)
{
struct pwrctrl_priv *pwrctrlpriv =
from_timer(pwrctrlpriv, t, pwr_state_check_timer);
struct adapter *padapter = pwrctrlpriv->adapter;
rtw_ps_cmd(padapter);
}
void traffic_check_for_leave_lps(struct adapter *padapter, u8 tx, u32 tx_packets)
{
static unsigned long start_time;
static u32 xmit_cnt;
u8 bLeaveLPS = false;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (tx) { /* from tx */
xmit_cnt += tx_packets;
if (start_time == 0)
start_time = jiffies;
if (jiffies_to_msecs(jiffies - start_time) > 2000) { /* 2 sec == watch dog timer */
if (xmit_cnt > 8) {
if (adapter_to_pwrctl(padapter)->bLeisurePs
&& (adapter_to_pwrctl(padapter)->pwr_mode != PS_MODE_ACTIVE)
&& !(hal_btcoex_IsBtControlLps(padapter))) {
bLeaveLPS = true;
}
}
start_time = jiffies;
xmit_cnt = 0;
}
} else { /* from rx path */
if (pmlmepriv->LinkDetectInfo.NumRxUnicastOkInPeriod > 4/*2*/) {
if (adapter_to_pwrctl(padapter)->bLeisurePs
&& (adapter_to_pwrctl(padapter)->pwr_mode != PS_MODE_ACTIVE)
&& !(hal_btcoex_IsBtControlLps(padapter)))
bLeaveLPS = true;
}
}
if (bLeaveLPS)
/* rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1); */
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, tx?0:1);
}
/*
* Description:
*This function MUST be called under power lock protect
*
* Parameters
*padapter
*pslv power state level, only could be PS_STATE_S0 ~ PS_STATE_S4
*
*/
void rtw_set_rpwm(struct adapter *padapter, u8 pslv)
{
u8 rpwm;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
u8 cpwm_orig;
pslv = PS_STATE(pslv);
if (!pwrpriv->brpwmtimeout) {
if (pwrpriv->rpwm == pslv ||
(pwrpriv->rpwm >= PS_STATE_S2 && pslv >= PS_STATE_S2))
return;
}
if ((padapter->bSurpriseRemoved) || !(padapter->hw_init_completed)) {
pwrpriv->cpwm = PS_STATE_S4;
return;
}
if (padapter->bDriverStopped) {
if (pslv < PS_STATE_S2)
return;
}
rpwm = pslv | pwrpriv->tog;
/* only when from PS_STATE S0/S1 to S2 and higher needs ACK */
if ((pwrpriv->cpwm < PS_STATE_S2) && (pslv >= PS_STATE_S2))
rpwm |= PS_ACK;
pwrpriv->rpwm = pslv;
cpwm_orig = 0;
if (rpwm & PS_ACK)
rtw_hal_get_hwreg(padapter, HW_VAR_CPWM, &cpwm_orig);
if (rpwm & PS_ACK)
_set_timer(&pwrpriv->pwr_rpwm_timer, LPS_RPWM_WAIT_MS);
rtw_hal_set_hwreg(padapter, HW_VAR_SET_RPWM, (u8 *)(&rpwm));
pwrpriv->tog += 0x80;
/* No LPS 32K, No Ack */
if (rpwm & PS_ACK) {
unsigned long start_time;
u8 cpwm_now;
u8 poll_cnt = 0;
start_time = jiffies;
/* polling cpwm */
do {
mdelay(1);
poll_cnt++;
rtw_hal_get_hwreg(padapter, HW_VAR_CPWM, &cpwm_now);
if ((cpwm_orig ^ cpwm_now) & 0x80) {
pwrpriv->cpwm = PS_STATE_S4;
pwrpriv->cpwm_tog = cpwm_now & PS_TOGGLE;
break;
}
if (jiffies_to_msecs(jiffies - start_time) > LPS_RPWM_WAIT_MS) {
_set_timer(&pwrpriv->pwr_rpwm_timer, 1);
break;
}
} while (1);
} else
pwrpriv->cpwm = pslv;
}
static u8 PS_RDY_CHECK(struct adapter *padapter)
{
unsigned long curr_time, delta_time;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
if (pwrpriv->bInSuspend)
return false;
curr_time = jiffies;
delta_time = curr_time - pwrpriv->DelayLPSLastTimeStamp;
if (delta_time < LPS_DELAY_TIME)
return false;
if (check_fwstate(pmlmepriv, WIFI_SITE_MONITOR)
|| check_fwstate(pmlmepriv, WIFI_UNDER_LINKING|WIFI_UNDER_WPS)
|| check_fwstate(pmlmepriv, WIFI_AP_STATE)
|| check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE|WIFI_ADHOC_STATE)
|| rtw_is_scan_deny(padapter)
)
return false;
if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X &&
!padapter->securitypriv.binstallGrpkey)
return false;
if (!rtw_cfg80211_pwr_mgmt(padapter))
return false;
return true;
}
void rtw_set_ps_mode(struct adapter *padapter, u8 ps_mode, u8 smart_ps, u8 bcn_ant_mode, const char *msg)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
if (ps_mode > PM_Card_Disable)
return;
if (pwrpriv->pwr_mode == ps_mode)
if (ps_mode == PS_MODE_ACTIVE)
return;
mutex_lock(&pwrpriv->lock);
/* if (pwrpriv->pwr_mode == PS_MODE_ACTIVE) */
if (ps_mode == PS_MODE_ACTIVE) {
if (!(hal_btcoex_IsBtControlLps(padapter))
|| (hal_btcoex_IsBtControlLps(padapter)
&& !(hal_btcoex_IsLpsOn(padapter)))) {
pwrpriv->pwr_mode = ps_mode;
rtw_set_rpwm(padapter, PS_STATE_S4);
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode));
pwrpriv->fw_current_in_ps_mode = false;
hal_btcoex_LpsNotify(padapter, ps_mode);
}
} else {
if ((PS_RDY_CHECK(padapter) && check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE)) ||
((hal_btcoex_IsBtControlLps(padapter)) && (hal_btcoex_IsLpsOn(padapter)))
) {
u8 pslv;
hal_btcoex_LpsNotify(padapter, ps_mode);
pwrpriv->fw_current_in_ps_mode = true;
pwrpriv->pwr_mode = ps_mode;
pwrpriv->smart_ps = smart_ps;
pwrpriv->bcn_ant_mode = bcn_ant_mode;
rtw_hal_set_hwreg(padapter, HW_VAR_H2C_FW_PWRMODE, (u8 *)(&ps_mode));
pslv = PS_STATE_S2;
if (pwrpriv->alives == 0)
pslv = PS_STATE_S0;
if (!(hal_btcoex_IsBtDisabled(padapter)) &&
(hal_btcoex_IsBtControlLps(padapter))) {
u8 val8;
val8 = hal_btcoex_LpsVal(padapter);
if (val8 & BIT(4))
pslv = PS_STATE_S2;
}
rtw_set_rpwm(padapter, pslv);
}
}
mutex_unlock(&pwrpriv->lock);
}
/*
* Return:
*0: Leave OK
*-1: Timeout
*-2: Other error
*/
s32 LPS_RF_ON_check(struct adapter *padapter, u32 delay_ms)
{
unsigned long start_time;
u8 bAwake = false;
s32 err = 0;
start_time = jiffies;
while (1) {
rtw_hal_get_hwreg(padapter, HW_VAR_FWLPS_RF_ON, &bAwake);
if (bAwake)
break;
if (padapter->bSurpriseRemoved) {
err = -2;
break;
}
if (jiffies_to_msecs(jiffies - start_time) > delay_ms) {
err = -1;
break;
}
msleep(1);
}
return err;
}
/* */
/* Description: */
/* Enter the leisure power save mode. */
/* */
void LPS_Enter(struct adapter *padapter, const char *msg)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
int n_assoc_iface = 0;
char buf[32] = {0};
if (hal_btcoex_IsBtControlLps(padapter))
return;
/* Skip lps enter request if number of assocated adapters is not 1 */
if (check_fwstate(&(dvobj->padapters->mlmepriv), WIFI_ASOC_STATE))
n_assoc_iface++;
if (n_assoc_iface != 1)
return;
/* Skip lps enter request for adapter not port0 */
if (get_iface_type(padapter) != IFACE_PORT0)
return;
if (!PS_RDY_CHECK(dvobj->padapters))
return;
if (pwrpriv->bLeisurePs) {
/* Idle for a while if we connect to AP a while ago. */
if (pwrpriv->LpsIdleCount >= 2) { /* 4 Sec */
if (pwrpriv->pwr_mode == PS_MODE_ACTIVE) {
scnprintf(buf, sizeof(buf), "WIFI-%s", msg);
pwrpriv->bpower_saving = true;
rtw_set_ps_mode(padapter, pwrpriv->power_mgnt, padapter->registrypriv.smart_ps, 0, buf);
}
} else
pwrpriv->LpsIdleCount++;
}
}
/* */
/* Description: */
/* Leave the leisure power save mode. */
/* */
void LPS_Leave(struct adapter *padapter, const char *msg)
{
#define LPS_LEAVE_TIMEOUT_MS 100
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
char buf[32] = {0};
if (hal_btcoex_IsBtControlLps(padapter))
return;
if (pwrpriv->bLeisurePs) {
if (pwrpriv->pwr_mode != PS_MODE_ACTIVE) {
scnprintf(buf, sizeof(buf), "WIFI-%s", msg);
rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0, 0, buf);
if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
LPS_RF_ON_check(padapter, LPS_LEAVE_TIMEOUT_MS);
}
}
pwrpriv->bpower_saving = false;
}
void LeaveAllPowerSaveModeDirect(struct adapter *Adapter)
{
struct adapter *pri_padapter = GET_PRIMARY_ADAPTER(Adapter);
struct mlme_priv *pmlmepriv = &(Adapter->mlmepriv);
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(Adapter);
if (Adapter->bSurpriseRemoved)
return;
if (check_fwstate(pmlmepriv, _FW_LINKED)) { /* connect */
if (pwrpriv->pwr_mode == PS_MODE_ACTIVE)
return;
mutex_lock(&pwrpriv->lock);
rtw_set_rpwm(Adapter, PS_STATE_S4);
mutex_unlock(&pwrpriv->lock);
rtw_lps_ctrl_wk_cmd(pri_padapter, LPS_CTRL_LEAVE, 0);
} else {
if (pwrpriv->rf_pwrstate == rf_off)
ips_leave(pri_padapter);
}
}
/* */
/* Description: Leave all power save mode: LPS, FwLPS, IPS if needed. */
/* Move code to function by tynli. 2010.03.26. */
/* */
void LeaveAllPowerSaveMode(struct adapter *Adapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(Adapter);
u8 enqueue = 0;
int n_assoc_iface = 0;
if (!Adapter->bup)
return;
if (Adapter->bSurpriseRemoved)
return;
if (check_fwstate(&(dvobj->padapters->mlmepriv), WIFI_ASOC_STATE))
n_assoc_iface++;
if (n_assoc_iface) { /* connect */
enqueue = 1;
rtw_lps_ctrl_wk_cmd(Adapter, LPS_CTRL_LEAVE, enqueue);
LPS_Leave_check(Adapter);
} else {
if (adapter_to_pwrctl(Adapter)->rf_pwrstate == rf_off) {
ips_leave(Adapter);
}
}
}
void LPS_Leave_check(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv;
unsigned long start_time;
u8 bReady;
pwrpriv = adapter_to_pwrctl(padapter);
bReady = false;
start_time = jiffies;
cond_resched();
while (1) {
mutex_lock(&pwrpriv->lock);
if (padapter->bSurpriseRemoved ||
!(padapter->hw_init_completed) ||
(pwrpriv->pwr_mode == PS_MODE_ACTIVE))
bReady = true;
mutex_unlock(&pwrpriv->lock);
if (bReady)
break;
if (jiffies_to_msecs(jiffies - start_time) > 100)
break;
msleep(1);
}
}
/*
* Caller:ISR handler...
*
* This will be called when CPWM interrupt is up.
*
* using to update cpwn of drv; and drv willl make a decision to up or down pwr level
*/
void cpwm_int_hdl(struct adapter *padapter, struct reportpwrstate_parm *preportpwrstate)
{
struct pwrctrl_priv *pwrpriv;
pwrpriv = adapter_to_pwrctl(padapter);
mutex_lock(&pwrpriv->lock);
if (pwrpriv->rpwm < PS_STATE_S2)
goto exit;
pwrpriv->cpwm = PS_STATE(preportpwrstate->state);
pwrpriv->cpwm_tog = preportpwrstate->state & PS_TOGGLE;
if (pwrpriv->cpwm >= PS_STATE_S2) {
if (pwrpriv->alives & CMD_ALIVE)
complete(&padapter->cmdpriv.cmd_queue_comp);
if (pwrpriv->alives & XMIT_ALIVE)
complete(&padapter->xmitpriv.xmit_comp);
}
exit:
mutex_unlock(&pwrpriv->lock);
}
static void cpwm_event_callback(struct work_struct *work)
{
struct pwrctrl_priv *pwrpriv = container_of(work, struct pwrctrl_priv, cpwm_event);
struct dvobj_priv *dvobj = pwrctl_to_dvobj(pwrpriv);
struct adapter *adapter = dvobj->if1;
struct reportpwrstate_parm report;
report.state = PS_STATE_S2;
cpwm_int_hdl(adapter, &report);
}
static void rpwmtimeout_workitem_callback(struct work_struct *work)
{
struct adapter *padapter;
struct dvobj_priv *dvobj;
struct pwrctrl_priv *pwrpriv;
pwrpriv = container_of(work, struct pwrctrl_priv, rpwmtimeoutwi);
dvobj = pwrctl_to_dvobj(pwrpriv);
padapter = dvobj->if1;
mutex_lock(&pwrpriv->lock);
if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2))
goto exit;
mutex_unlock(&pwrpriv->lock);
if (rtw_read8(padapter, 0x100) != 0xEA) {
struct reportpwrstate_parm report;
report.state = PS_STATE_S2;
cpwm_int_hdl(padapter, &report);
return;
}
mutex_lock(&pwrpriv->lock);
if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2))
goto exit;
pwrpriv->brpwmtimeout = true;
rtw_set_rpwm(padapter, pwrpriv->rpwm);
pwrpriv->brpwmtimeout = false;
exit:
mutex_unlock(&pwrpriv->lock);
}
/*
* This function is a timer handler, can't do any IO in it.
*/
static void pwr_rpwm_timeout_handler(struct timer_list *t)
{
struct pwrctrl_priv *pwrpriv = from_timer(pwrpriv, t, pwr_rpwm_timer);
if ((pwrpriv->rpwm == pwrpriv->cpwm) || (pwrpriv->cpwm >= PS_STATE_S2))
return;
_set_workitem(&pwrpriv->rpwmtimeoutwi);
}
static inline void register_task_alive(struct pwrctrl_priv *pwrctrl, u32 tag)
{
pwrctrl->alives |= tag;
}
static inline void unregister_task_alive(struct pwrctrl_priv *pwrctrl, u32 tag)
{
pwrctrl->alives &= ~tag;
}
/*
* Description:
*Check if the fw_pwrstate is okay for I/O.
*If not (cpwm is less than S2), then the sub-routine
*will raise the cpwm to be greater than or equal to S2.
*
*Calling Context: Passive
*
*Constraint:
* 1. this function will request pwrctrl->lock
*
* Return Value:
*_SUCCESS hardware is ready for I/O
*_FAIL can't I/O right now
*/
s32 rtw_register_task_alive(struct adapter *padapter, u32 task)
{
s32 res;
struct pwrctrl_priv *pwrctrl;
u8 pslv;
res = _SUCCESS;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S2;
mutex_lock(&pwrctrl->lock);
register_task_alive(pwrctrl, task);
if (pwrctrl->fw_current_in_ps_mode) {
if (pwrctrl->cpwm < pslv) {
if (pwrctrl->cpwm < PS_STATE_S2)
res = _FAIL;
if (pwrctrl->rpwm < pslv)
rtw_set_rpwm(padapter, pslv);
}
}
mutex_unlock(&pwrctrl->lock);
if (res == _FAIL)
if (pwrctrl->cpwm >= PS_STATE_S2)
res = _SUCCESS;
return res;
}
/*
* Description:
*If task is done, call this func. to power down firmware again.
*
*Constraint:
* 1. this function will request pwrctrl->lock
*
* Return Value:
*none
*/
void rtw_unregister_task_alive(struct adapter *padapter, u32 task)
{
struct pwrctrl_priv *pwrctrl;
u8 pslv;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S0;
if (!(hal_btcoex_IsBtDisabled(padapter)) && hal_btcoex_IsBtControlLps(padapter)) {
u8 val8;
val8 = hal_btcoex_LpsVal(padapter);
if (val8 & BIT(4))
pslv = PS_STATE_S2;
}
mutex_lock(&pwrctrl->lock);
unregister_task_alive(pwrctrl, task);
if ((pwrctrl->pwr_mode != PS_MODE_ACTIVE) && pwrctrl->fw_current_in_ps_mode) {
if (pwrctrl->cpwm > pslv)
if ((pslv >= PS_STATE_S2) || (pwrctrl->alives == 0))
rtw_set_rpwm(padapter, pslv);
}
mutex_unlock(&pwrctrl->lock);
}
/*
* Caller: rtw_xmit_thread
*
* Check if the fw_pwrstate is okay for xmit.
* If not (cpwm is less than S3), then the sub-routine
* will raise the cpwm to be greater than or equal to S3.
*
* Calling Context: Passive
*
* Return Value:
* _SUCCESS rtw_xmit_thread can write fifo/txcmd afterwards.
* _FAIL rtw_xmit_thread can not do anything.
*/
s32 rtw_register_tx_alive(struct adapter *padapter)
{
s32 res;
struct pwrctrl_priv *pwrctrl;
u8 pslv;
res = _SUCCESS;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S2;
mutex_lock(&pwrctrl->lock);
register_task_alive(pwrctrl, XMIT_ALIVE);
if (pwrctrl->fw_current_in_ps_mode) {
if (pwrctrl->cpwm < pslv) {
if (pwrctrl->cpwm < PS_STATE_S2)
res = _FAIL;
if (pwrctrl->rpwm < pslv)
rtw_set_rpwm(padapter, pslv);
}
}
mutex_unlock(&pwrctrl->lock);
if (res == _FAIL)
if (pwrctrl->cpwm >= PS_STATE_S2)
res = _SUCCESS;
return res;
}
/*
* Caller: rtw_cmd_thread
*
* Check if the fw_pwrstate is okay for issuing cmd.
* If not (cpwm should be is less than S2), then the sub-routine
* will raise the cpwm to be greater than or equal to S2.
*
* Calling Context: Passive
*
* Return Value:
*_SUCCESS rtw_cmd_thread can issue cmds to firmware afterwards.
*_FAIL rtw_cmd_thread can not do anything.
*/
s32 rtw_register_cmd_alive(struct adapter *padapter)
{
s32 res;
struct pwrctrl_priv *pwrctrl;
u8 pslv;
res = _SUCCESS;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S2;
mutex_lock(&pwrctrl->lock);
register_task_alive(pwrctrl, CMD_ALIVE);
if (pwrctrl->fw_current_in_ps_mode) {
if (pwrctrl->cpwm < pslv) {
if (pwrctrl->cpwm < PS_STATE_S2)
res = _FAIL;
if (pwrctrl->rpwm < pslv)
rtw_set_rpwm(padapter, pslv);
}
}
mutex_unlock(&pwrctrl->lock);
if (res == _FAIL)
if (pwrctrl->cpwm >= PS_STATE_S2)
res = _SUCCESS;
return res;
}
/*
* Caller: ISR
*
* If ISR's txdone,
* No more pkts for TX,
* Then driver shall call this fun. to power down firmware again.
*/
void rtw_unregister_tx_alive(struct adapter *padapter)
{
struct pwrctrl_priv *pwrctrl;
u8 pslv;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S0;
if (!(hal_btcoex_IsBtDisabled(padapter)) && hal_btcoex_IsBtControlLps(padapter)) {
u8 val8;
val8 = hal_btcoex_LpsVal(padapter);
if (val8 & BIT(4))
pslv = PS_STATE_S2;
}
mutex_lock(&pwrctrl->lock);
unregister_task_alive(pwrctrl, XMIT_ALIVE);
if ((pwrctrl->pwr_mode != PS_MODE_ACTIVE) && pwrctrl->fw_current_in_ps_mode) {
if (pwrctrl->cpwm > pslv)
if ((pslv >= PS_STATE_S2) || (pwrctrl->alives == 0))
rtw_set_rpwm(padapter, pslv);
}
mutex_unlock(&pwrctrl->lock);
}
/*
* Caller: ISR
*
* If all commands have been done,
* and no more command to do,
* then driver shall call this fun. to power down firmware again.
*/
void rtw_unregister_cmd_alive(struct adapter *padapter)
{
struct pwrctrl_priv *pwrctrl;
u8 pslv;
pwrctrl = adapter_to_pwrctl(padapter);
pslv = PS_STATE_S0;
if (!(hal_btcoex_IsBtDisabled(padapter)) && hal_btcoex_IsBtControlLps(padapter)) {
u8 val8;
val8 = hal_btcoex_LpsVal(padapter);
if (val8 & BIT(4))
pslv = PS_STATE_S2;
}
mutex_lock(&pwrctrl->lock);
unregister_task_alive(pwrctrl, CMD_ALIVE);
if ((pwrctrl->pwr_mode != PS_MODE_ACTIVE) && pwrctrl->fw_current_in_ps_mode) {
if (pwrctrl->cpwm > pslv) {
if ((pslv >= PS_STATE_S2) || (pwrctrl->alives == 0))
rtw_set_rpwm(padapter, pslv);
}
}
mutex_unlock(&pwrctrl->lock);
}
void rtw_init_pwrctrl_priv(struct adapter *padapter)
{
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
mutex_init(&pwrctrlpriv->lock);
pwrctrlpriv->rf_pwrstate = rf_on;
pwrctrlpriv->ips_enter_cnts = 0;
pwrctrlpriv->ips_leave_cnts = 0;
pwrctrlpriv->bips_processing = false;
pwrctrlpriv->ips_mode = padapter->registrypriv.ips_mode;
pwrctrlpriv->ips_mode_req = padapter->registrypriv.ips_mode;
pwrctrlpriv->pwr_state_check_interval = RTW_PWR_STATE_CHK_INTERVAL;
pwrctrlpriv->pwr_state_check_cnts = 0;
pwrctrlpriv->bInternalAutoSuspend = false;
pwrctrlpriv->bInSuspend = false;
pwrctrlpriv->bkeepfwalive = false;
pwrctrlpriv->LpsIdleCount = 0;
pwrctrlpriv->power_mgnt = padapter->registrypriv.power_mgnt;/* PS_MODE_MIN; */
pwrctrlpriv->bLeisurePs = pwrctrlpriv->power_mgnt != PS_MODE_ACTIVE;
pwrctrlpriv->fw_current_in_ps_mode = false;
pwrctrlpriv->rpwm = 0;
pwrctrlpriv->cpwm = PS_STATE_S4;
pwrctrlpriv->pwr_mode = PS_MODE_ACTIVE;
pwrctrlpriv->smart_ps = padapter->registrypriv.smart_ps;
pwrctrlpriv->bcn_ant_mode = 0;
pwrctrlpriv->dtim = 0;
pwrctrlpriv->tog = 0x80;
rtw_hal_set_hwreg(padapter, HW_VAR_SET_RPWM, (u8 *)(&pwrctrlpriv->rpwm));
_init_workitem(&pwrctrlpriv->cpwm_event, cpwm_event_callback, NULL);
pwrctrlpriv->brpwmtimeout = false;
pwrctrlpriv->adapter = padapter;
_init_workitem(&pwrctrlpriv->rpwmtimeoutwi, rpwmtimeout_workitem_callback, NULL);
timer_setup(&pwrctrlpriv->pwr_rpwm_timer, pwr_rpwm_timeout_handler, 0);
timer_setup(&pwrctrlpriv->pwr_state_check_timer,
pwr_state_check_handler, 0);
pwrctrlpriv->wowlan_mode = false;
pwrctrlpriv->wowlan_ap_mode = false;
}
void rtw_free_pwrctrl_priv(struct adapter *adapter)
{
}
inline void rtw_set_ips_deny(struct adapter *padapter, u32 ms)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
pwrpriv->ips_deny_time = jiffies + msecs_to_jiffies(ms);
}
/*
* rtw_pwr_wakeup - Wake the NIC up from: 1)IPS. 2)USB autosuspend
* @adapter: pointer to struct adapter structure
* @ips_deffer_ms: the ms will prevent from falling into IPS after wakeup
* Return _SUCCESS or _FAIL
*/
int _rtw_pwr_wakeup(struct adapter *padapter, u32 ips_deffer_ms, const char *caller)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(dvobj);
struct mlme_priv *pmlmepriv;
int ret = _SUCCESS;
unsigned long start = jiffies;
unsigned long deny_time = jiffies + msecs_to_jiffies(ips_deffer_ms);
/* for LPS */
LeaveAllPowerSaveMode(padapter);
/* IPS still bound with primary adapter */
padapter = GET_PRIMARY_ADAPTER(padapter);
pmlmepriv = &padapter->mlmepriv;
if (time_before(pwrpriv->ips_deny_time, deny_time))
pwrpriv->ips_deny_time = deny_time;
if (pwrpriv->ps_processing)
while (pwrpriv->ps_processing && jiffies_to_msecs(jiffies - start) <= 3000)
mdelay(10);
if (!(pwrpriv->bInternalAutoSuspend) && pwrpriv->bInSuspend)
while (pwrpriv->bInSuspend && jiffies_to_msecs(jiffies - start) <= 3000
)
mdelay(10);
/* System suspend is not allowed to wakeup */
if (!(pwrpriv->bInternalAutoSuspend) && pwrpriv->bInSuspend) {
ret = _FAIL;
goto exit;
}
/* block??? */
if (pwrpriv->bInternalAutoSuspend && padapter->net_closed) {
ret = _FAIL;
goto exit;
}
/* I think this should be check in IPS, LPS, autosuspend functions... */
if (check_fwstate(pmlmepriv, _FW_LINKED)) {
ret = _SUCCESS;
goto exit;
}
if (rf_off == pwrpriv->rf_pwrstate) {
{
if (ips_leave(padapter) == _FAIL) {
ret = _FAIL;
goto exit;
}
}
}
/* TODO: the following checking need to be merged... */
if (padapter->bDriverStopped || !padapter->bup || !padapter->hw_init_completed) {
ret = false;
goto exit;
}
exit:
deny_time = jiffies + msecs_to_jiffies(ips_deffer_ms);
if (time_before(pwrpriv->ips_deny_time, deny_time))
pwrpriv->ips_deny_time = deny_time;
return ret;
}
int rtw_pm_set_lps(struct adapter *padapter, u8 mode)
{
int ret = 0;
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
if (mode < PS_MODE_NUM) {
if (pwrctrlpriv->power_mgnt != mode) {
if (mode == PS_MODE_ACTIVE)
LeaveAllPowerSaveMode(padapter);
else
pwrctrlpriv->LpsIdleCount = 2;
pwrctrlpriv->power_mgnt = mode;
pwrctrlpriv->bLeisurePs =
pwrctrlpriv->power_mgnt != PS_MODE_ACTIVE;
}
} else
ret = -EINVAL;
return ret;
}
int rtw_pm_set_ips(struct adapter *padapter, u8 mode)
{
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
if (mode == IPS_NORMAL || mode == IPS_LEVEL_2) {
rtw_ips_mode_req(pwrctrlpriv, mode);
return 0;
} else if (mode == IPS_NONE) {
rtw_ips_mode_req(pwrctrlpriv, mode);
if ((padapter->bSurpriseRemoved == 0) && (rtw_pwr_wakeup(padapter) == _FAIL))
return -EFAULT;
} else
return -EINVAL;
return 0;
}
/*
* ATTENTION:
*This function will request pwrctrl LOCK!
*/
void rtw_ps_deny(struct adapter *padapter, enum ps_deny_reason reason)
{
struct pwrctrl_priv *pwrpriv;
pwrpriv = adapter_to_pwrctl(padapter);
mutex_lock(&pwrpriv->lock);
pwrpriv->ps_deny |= BIT(reason);
mutex_unlock(&pwrpriv->lock);
}
/*
* ATTENTION:
*This function will request pwrctrl LOCK!
*/
void rtw_ps_deny_cancel(struct adapter *padapter, enum ps_deny_reason reason)
{
struct pwrctrl_priv *pwrpriv;
pwrpriv = adapter_to_pwrctl(padapter);
mutex_lock(&pwrpriv->lock);
pwrpriv->ps_deny &= ~BIT(reason);
mutex_unlock(&pwrpriv->lock);
}
/*
* ATTENTION:
*Before calling this function pwrctrl lock should be occupied already,
*otherwise it may return incorrect value.
*/
u32 rtw_ps_deny_get(struct adapter *padapter)
{
return adapter_to_pwrctl(padapter)->ps_deny;
}
| linux-master | drivers/staging/rtl8723bs/core/rtw_pwrctrl.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <hal_btcoex.h>
#include <rtw_version.h>
static void dump_4_regs(struct adapter *adapter, int offset)
{
u32 reg[4];
int i;
for (i = 0; i < 4; i++)
reg[i] = rtw_read32(adapter, offset + i);
netdev_dbg(adapter->pnetdev, "0x%03x 0x%08x 0x%08x 0x%08x 0x%08x\n",
i, reg[0], reg[1], reg[2], reg[3]);
}
void mac_reg_dump(struct adapter *adapter)
{
int i;
netdev_dbg(adapter->pnetdev, "======= MAC REG =======\n");
for (i = 0x0; i < 0x800; i += 4)
dump_4_regs(adapter, i);
}
void bb_reg_dump(struct adapter *adapter)
{
int i;
netdev_dbg(adapter->pnetdev, "======= BB REG =======\n");
for (i = 0x800; i < 0x1000 ; i += 4)
dump_4_regs(adapter, i);
}
static void dump_4_rf_regs(struct adapter *adapter, int path, int offset)
{
u8 reg[4];
int i;
for (i = 0; i < 4; i++)
reg[i] = rtw_hal_read_rfreg(adapter, path, offset + i,
0xffffffff);
netdev_dbg(adapter->pnetdev, "0x%02x 0x%08x 0x%08x 0x%08x 0x%08x\n",
i, reg[0], reg[1], reg[2], reg[3]);
}
void rf_reg_dump(struct adapter *adapter)
{
int i, path = 0;
netdev_dbg(adapter->pnetdev, "======= RF REG =======\n");
netdev_dbg(adapter->pnetdev, "RF_Path(%x)\n", path);
for (i = 0; i < 0x100; i++)
dump_4_rf_regs(adapter, path, i);
}
| linux-master | drivers/staging/rtl8723bs/core/rtw_debug.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <linux/etherdevice.h>
#include <drv_types.h>
#include <rtw_debug.h>
#include <hal_btcoex.h>
#include <linux/jiffies.h>
int rtw_init_mlme_priv(struct adapter *padapter)
{
int i;
u8 *pbuf;
struct wlan_network *pnetwork;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
int res = _SUCCESS;
pmlmepriv->nic_hdl = (u8 *)padapter;
pmlmepriv->pscanned = NULL;
pmlmepriv->fw_state = WIFI_STATION_STATE; /* Must sync with rtw_wdev_alloc() */
/* wdev->iftype = NL80211_IFTYPE_STATION */
pmlmepriv->cur_network.network.infrastructure_mode = Ndis802_11AutoUnknown;
pmlmepriv->scan_mode = SCAN_ACTIVE;/* 1: active, 0: passive. Maybe someday we should rename this varable to "active_mode" (Jeff) */
spin_lock_init(&pmlmepriv->lock);
INIT_LIST_HEAD(&pmlmepriv->free_bss_pool.queue);
spin_lock_init(&pmlmepriv->free_bss_pool.lock);
INIT_LIST_HEAD(&pmlmepriv->scanned_queue.queue);
spin_lock_init(&pmlmepriv->scanned_queue.lock);
memset(&pmlmepriv->assoc_ssid, 0, sizeof(struct ndis_802_11_ssid));
pbuf = vzalloc(array_size(MAX_BSS_CNT, sizeof(struct wlan_network)));
if (!pbuf) {
res = _FAIL;
goto exit;
}
pmlmepriv->free_bss_buf = pbuf;
pnetwork = (struct wlan_network *)pbuf;
for (i = 0; i < MAX_BSS_CNT; i++) {
INIT_LIST_HEAD(&pnetwork->list);
list_add_tail(&pnetwork->list, &pmlmepriv->free_bss_pool.queue);
pnetwork++;
}
/* allocate DMA-able/Non-Page memory for cmd_buf and rsp_buf */
rtw_clear_scan_deny(padapter);
#define RTW_ROAM_SCAN_RESULT_EXP_MS 5000
#define RTW_ROAM_RSSI_DIFF_TH 10
#define RTW_ROAM_SCAN_INTERVAL_MS 10000
pmlmepriv->roam_flags = 0
| RTW_ROAM_ON_EXPIRED
| RTW_ROAM_ON_RESUME
;
pmlmepriv->roam_scanr_exp_ms = RTW_ROAM_SCAN_RESULT_EXP_MS;
pmlmepriv->roam_rssi_diff_th = RTW_ROAM_RSSI_DIFF_TH;
pmlmepriv->roam_scan_int_ms = RTW_ROAM_SCAN_INTERVAL_MS;
rtw_init_mlme_timer(padapter);
exit:
return res;
}
static void rtw_free_mlme_ie_data(u8 **ppie, u32 *plen)
{
if (*ppie) {
kfree(*ppie);
*plen = 0;
*ppie = NULL;
}
}
void rtw_free_mlme_priv_ie_data(struct mlme_priv *pmlmepriv)
{
rtw_buf_free(&pmlmepriv->assoc_req, &pmlmepriv->assoc_req_len);
rtw_buf_free(&pmlmepriv->assoc_rsp, &pmlmepriv->assoc_rsp_len);
rtw_free_mlme_ie_data(&pmlmepriv->wps_beacon_ie, &pmlmepriv->wps_beacon_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_req_ie, &pmlmepriv->wps_probe_req_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wps_probe_resp_ie, &pmlmepriv->wps_probe_resp_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->wps_assoc_resp_ie, &pmlmepriv->wps_assoc_resp_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_beacon_ie, &pmlmepriv->p2p_beacon_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_probe_req_ie, &pmlmepriv->p2p_probe_req_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_probe_resp_ie, &pmlmepriv->p2p_probe_resp_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_go_probe_resp_ie, &pmlmepriv->p2p_go_probe_resp_ie_len);
rtw_free_mlme_ie_data(&pmlmepriv->p2p_assoc_req_ie, &pmlmepriv->p2p_assoc_req_ie_len);
}
void _rtw_free_mlme_priv(struct mlme_priv *pmlmepriv)
{
if (pmlmepriv) {
rtw_free_mlme_priv_ie_data(pmlmepriv);
vfree(pmlmepriv->free_bss_buf);
}
}
/*
struct wlan_network *_rtw_dequeue_network(struct __queue *queue)
{
_irqL irqL;
struct wlan_network *pnetwork;
spin_lock_bh(&queue->lock);
if (list_empty(&queue->queue))
pnetwork = NULL;
else
{
pnetwork = container_of(get_next(&queue->queue), struct wlan_network, list);
list_del_init(&(pnetwork->list));
}
spin_unlock_bh(&queue->lock);
return pnetwork;
}
*/
struct wlan_network *rtw_alloc_network(struct mlme_priv *pmlmepriv)
{
struct wlan_network *pnetwork;
struct __queue *free_queue = &pmlmepriv->free_bss_pool;
struct list_head *plist = NULL;
spin_lock_bh(&free_queue->lock);
if (list_empty(&free_queue->queue)) {
pnetwork = NULL;
goto exit;
}
plist = get_next(&(free_queue->queue));
pnetwork = container_of(plist, struct wlan_network, list);
list_del_init(&pnetwork->list);
pnetwork->network_type = 0;
pnetwork->fixed = false;
pnetwork->last_scanned = jiffies;
pnetwork->aid = 0;
pnetwork->join_res = 0;
exit:
spin_unlock_bh(&free_queue->lock);
return pnetwork;
}
void _rtw_free_network(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork, u8 isfreeall)
{
unsigned int delta_time;
u32 lifetime = SCANQUEUE_LIFETIME;
/* _irqL irqL; */
struct __queue *free_queue = &(pmlmepriv->free_bss_pool);
if (!pnetwork)
return;
if (pnetwork->fixed)
return;
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true))
lifetime = 1;
if (!isfreeall) {
delta_time = jiffies_to_msecs(jiffies - pnetwork->last_scanned);
if (delta_time < lifetime)/* unit:msec */
return;
}
spin_lock_bh(&free_queue->lock);
list_del_init(&(pnetwork->list));
list_add_tail(&(pnetwork->list), &(free_queue->queue));
spin_unlock_bh(&free_queue->lock);
}
void _rtw_free_network_nolock(struct mlme_priv *pmlmepriv, struct wlan_network *pnetwork)
{
struct __queue *free_queue = &(pmlmepriv->free_bss_pool);
if (!pnetwork)
return;
if (pnetwork->fixed)
return;
/* spin_lock_irqsave(&free_queue->lock, irqL); */
list_del_init(&(pnetwork->list));
list_add_tail(&(pnetwork->list), get_list_head(free_queue));
/* spin_unlock_irqrestore(&free_queue->lock, irqL); */
}
/*
return the wlan_network with the matching addr
Shall be called under atomic context... to avoid possible racing condition...
*/
struct wlan_network *_rtw_find_network(struct __queue *scanned_queue, u8 *addr)
{
struct list_head *phead, *plist;
struct wlan_network *pnetwork = NULL;
if (is_zero_ether_addr(addr)) {
pnetwork = NULL;
goto exit;
}
/* spin_lock_bh(&scanned_queue->lock); */
phead = get_list_head(scanned_queue);
list_for_each(plist, phead) {
pnetwork = list_entry(plist, struct wlan_network, list);
if (!memcmp(addr, pnetwork->network.mac_address, ETH_ALEN))
break;
}
if (plist == phead)
pnetwork = NULL;
/* spin_unlock_bh(&scanned_queue->lock); */
exit:
return pnetwork;
}
void rtw_free_network_queue(struct adapter *padapter, u8 isfreeall)
{
struct list_head *phead, *plist, *tmp;
struct wlan_network *pnetwork;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct __queue *scanned_queue = &pmlmepriv->scanned_queue;
spin_lock_bh(&scanned_queue->lock);
phead = get_list_head(scanned_queue);
list_for_each_safe(plist, tmp, phead) {
pnetwork = list_entry(plist, struct wlan_network, list);
_rtw_free_network(pmlmepriv, pnetwork, isfreeall);
}
spin_unlock_bh(&scanned_queue->lock);
}
signed int rtw_if_up(struct adapter *padapter)
{
signed int res;
if (padapter->bDriverStopped || padapter->bSurpriseRemoved ||
(check_fwstate(&padapter->mlmepriv, _FW_LINKED) == false))
res = false;
else
res = true;
return res;
}
void rtw_generate_random_ibss(u8 *pibss)
{
unsigned long curtime = jiffies;
pibss[0] = 0x02; /* in ad-hoc mode bit1 must set to 1 */
pibss[1] = 0x11;
pibss[2] = 0x87;
pibss[3] = (u8)(curtime & 0xff) ;/* p[0]; */
pibss[4] = (u8)((curtime>>8) & 0xff) ;/* p[1]; */
pibss[5] = (u8)((curtime>>16) & 0xff) ;/* p[2]; */
}
u8 *rtw_get_capability_from_ie(u8 *ie)
{
return ie + 8 + 2;
}
u16 rtw_get_capability(struct wlan_bssid_ex *bss)
{
__le16 val;
memcpy((u8 *)&val, rtw_get_capability_from_ie(bss->ies), 2);
return le16_to_cpu(val);
}
u8 *rtw_get_beacon_interval_from_ie(u8 *ie)
{
return ie + 8;
}
void rtw_free_mlme_priv(struct mlme_priv *pmlmepriv)
{
_rtw_free_mlme_priv(pmlmepriv);
}
/*
static struct wlan_network *rtw_dequeue_network(struct __queue *queue)
{
struct wlan_network *pnetwork;
pnetwork = _rtw_dequeue_network(queue);
return pnetwork;
}
*/
void rtw_free_network_nolock(struct adapter *padapter, struct wlan_network *pnetwork);
void rtw_free_network_nolock(struct adapter *padapter, struct wlan_network *pnetwork)
{
_rtw_free_network_nolock(&(padapter->mlmepriv), pnetwork);
rtw_cfg80211_unlink_bss(padapter, pnetwork);
}
/*
return the wlan_network with the matching addr
Shall be called under atomic context... to avoid possible racing condition...
*/
struct wlan_network *rtw_find_network(struct __queue *scanned_queue, u8 *addr)
{
struct wlan_network *pnetwork = _rtw_find_network(scanned_queue, addr);
return pnetwork;
}
int rtw_is_same_ibss(struct adapter *adapter, struct wlan_network *pnetwork)
{
int ret = true;
struct security_priv *psecuritypriv = &adapter->securitypriv;
if ((psecuritypriv->dot11PrivacyAlgrthm != _NO_PRIVACY_) &&
(pnetwork->network.privacy == 0))
ret = false;
else if ((psecuritypriv->dot11PrivacyAlgrthm == _NO_PRIVACY_) &&
(pnetwork->network.privacy == 1))
ret = false;
else
ret = true;
return ret;
}
inline int is_same_ess(struct wlan_bssid_ex *a, struct wlan_bssid_ex *b)
{
return (a->ssid.ssid_length == b->ssid.ssid_length)
&& !memcmp(a->ssid.ssid, b->ssid.ssid, a->ssid.ssid_length);
}
int is_same_network(struct wlan_bssid_ex *src, struct wlan_bssid_ex *dst, u8 feature)
{
u16 s_cap, d_cap;
__le16 tmps, tmpd;
if (rtw_bug_check(dst, src, &s_cap, &d_cap) == false)
return false;
memcpy((u8 *)&tmps, rtw_get_capability_from_ie(src->ies), 2);
memcpy((u8 *)&tmpd, rtw_get_capability_from_ie(dst->ies), 2);
s_cap = le16_to_cpu(tmps);
d_cap = le16_to_cpu(tmpd);
return (src->ssid.ssid_length == dst->ssid.ssid_length) &&
/* (src->configuration.ds_config == dst->configuration.ds_config) && */
((!memcmp(src->mac_address, dst->mac_address, ETH_ALEN))) &&
((!memcmp(src->ssid.ssid, dst->ssid.ssid, src->ssid.ssid_length))) &&
((s_cap & WLAN_CAPABILITY_IBSS) ==
(d_cap & WLAN_CAPABILITY_IBSS)) &&
((s_cap & WLAN_CAPABILITY_ESS) ==
(d_cap & WLAN_CAPABILITY_ESS));
}
struct wlan_network *_rtw_find_same_network(struct __queue *scanned_queue, struct wlan_network *network)
{
struct list_head *phead, *plist;
struct wlan_network *found = NULL;
phead = get_list_head(scanned_queue);
list_for_each(plist, phead) {
found = list_entry(plist, struct wlan_network, list);
if (is_same_network(&network->network, &found->network, 0))
break;
}
if (plist == phead)
found = NULL;
return found;
}
struct wlan_network *rtw_get_oldest_wlan_network(struct __queue *scanned_queue)
{
struct list_head *plist, *phead;
struct wlan_network *pwlan = NULL;
struct wlan_network *oldest = NULL;
phead = get_list_head(scanned_queue);
list_for_each(plist, phead) {
pwlan = list_entry(plist, struct wlan_network, list);
if (!pwlan->fixed) {
if (!oldest || time_after(oldest->last_scanned, pwlan->last_scanned))
oldest = pwlan;
}
}
return oldest;
}
void update_network(struct wlan_bssid_ex *dst, struct wlan_bssid_ex *src,
struct adapter *padapter, bool update_ie)
{
long rssi_ori = dst->rssi;
u8 sq_smp = src->phy_info.signal_quality;
u8 ss_final;
u8 sq_final;
long rssi_final;
/* The rule below is 1/5 for sample value, 4/5 for history value */
if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) && is_same_network(&(padapter->mlmepriv.cur_network.network), src, 0)) {
/* Take the recvpriv's value for the connected AP*/
ss_final = padapter->recvpriv.signal_strength;
sq_final = padapter->recvpriv.signal_qual;
/* the rssi value here is undecorated, and will be used for antenna diversity */
if (sq_smp != 101) /* from the right channel */
rssi_final = (src->rssi+dst->rssi*4)/5;
else
rssi_final = rssi_ori;
} else {
if (sq_smp != 101) { /* from the right channel */
ss_final = ((u32)(src->phy_info.signal_strength)+(u32)(dst->phy_info.signal_strength)*4)/5;
sq_final = ((u32)(src->phy_info.signal_quality)+(u32)(dst->phy_info.signal_quality)*4)/5;
rssi_final = (src->rssi+dst->rssi*4)/5;
} else {
/* bss info not receiving from the right channel, use the original RX signal infos */
ss_final = dst->phy_info.signal_strength;
sq_final = dst->phy_info.signal_quality;
rssi_final = dst->rssi;
}
}
if (update_ie) {
dst->reserved[0] = src->reserved[0];
dst->reserved[1] = src->reserved[1];
memcpy((u8 *)dst, (u8 *)src, get_wlan_bssid_ex_sz(src));
}
dst->phy_info.signal_strength = ss_final;
dst->phy_info.signal_quality = sq_final;
dst->rssi = rssi_final;
}
static void update_current_network(struct adapter *adapter, struct wlan_bssid_ex *pnetwork)
{
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
rtw_bug_check(&(pmlmepriv->cur_network.network),
&(pmlmepriv->cur_network.network),
&(pmlmepriv->cur_network.network),
&(pmlmepriv->cur_network.network));
if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) && (is_same_network(&(pmlmepriv->cur_network.network), pnetwork, 0))) {
/* if (pmlmepriv->cur_network.network.ie_length<= pnetwork->ie_length) */
{
update_network(&(pmlmepriv->cur_network.network), pnetwork, adapter, true);
rtw_update_protection(adapter, (pmlmepriv->cur_network.network.ies) + sizeof(struct ndis_802_11_fix_ie),
pmlmepriv->cur_network.network.ie_length);
}
}
}
/*
Caller must hold pmlmepriv->lock first.
*/
void rtw_update_scanned_network(struct adapter *adapter, struct wlan_bssid_ex *target)
{
struct list_head *plist, *phead;
u32 bssid_ex_sz;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct __queue *queue = &(pmlmepriv->scanned_queue);
struct wlan_network *pnetwork = NULL;
struct wlan_network *oldest = NULL;
int target_find = 0;
u8 feature = 0;
spin_lock_bh(&queue->lock);
phead = get_list_head(queue);
list_for_each(plist, phead) {
pnetwork = list_entry(plist, struct wlan_network, list);
rtw_bug_check(pnetwork, pnetwork, pnetwork, pnetwork);
if (is_same_network(&(pnetwork->network), target, feature)) {
target_find = 1;
break;
}
if (rtw_roam_flags(adapter)) {
/* TODO: don't select network in the same ess as oldest if it's new enough*/
}
if (!oldest || time_after(oldest->last_scanned, pnetwork->last_scanned))
oldest = pnetwork;
}
/* If we didn't find a match, then get a new network slot to initialize
* with this beacon's information */
/* if (phead == plist) { */
if (!target_find) {
if (list_empty(&pmlmepriv->free_bss_pool.queue)) {
/* If there are no more slots, expire the oldest */
/* list_del_init(&oldest->list); */
pnetwork = oldest;
if (!pnetwork)
goto exit;
memcpy(&(pnetwork->network), target, get_wlan_bssid_ex_sz(target));
/* variable initialize */
pnetwork->fixed = false;
pnetwork->last_scanned = jiffies;
pnetwork->network_type = 0;
pnetwork->aid = 0;
pnetwork->join_res = 0;
/* bss info not receiving from the right channel */
if (pnetwork->network.phy_info.signal_quality == 101)
pnetwork->network.phy_info.signal_quality = 0;
} else {
/* Otherwise just pull from the free list */
pnetwork = rtw_alloc_network(pmlmepriv); /* will update scan_time */
if (!pnetwork)
goto exit;
bssid_ex_sz = get_wlan_bssid_ex_sz(target);
target->length = bssid_ex_sz;
memcpy(&(pnetwork->network), target, bssid_ex_sz);
pnetwork->last_scanned = jiffies;
/* bss info not receiving from the right channel */
if (pnetwork->network.phy_info.signal_quality == 101)
pnetwork->network.phy_info.signal_quality = 0;
list_add_tail(&(pnetwork->list), &(queue->queue));
}
} else {
/* we have an entry and we are going to update it. But this entry may
* be already expired. In this case we do the same as we found a new
* net and call the new_net handler
*/
bool update_ie = true;
pnetwork->last_scanned = jiffies;
/* target.reserved[0]== 1, means that scanned network is a bcn frame. */
if (pnetwork->network.ie_length > target->ie_length && target->reserved[0] == 1)
update_ie = false;
/* probe resp(3) > beacon(1) > probe req(2) */
if (target->reserved[0] != 2 &&
target->reserved[0] >= pnetwork->network.reserved[0]) {
update_ie = true;
} else {
update_ie = false;
}
update_network(&(pnetwork->network), target, adapter, update_ie);
}
exit:
spin_unlock_bh(&queue->lock);
}
void rtw_add_network(struct adapter *adapter, struct wlan_bssid_ex *pnetwork);
void rtw_add_network(struct adapter *adapter, struct wlan_bssid_ex *pnetwork)
{
/* struct __queue *queue = &(pmlmepriv->scanned_queue); */
/* spin_lock_bh(&queue->lock); */
update_current_network(adapter, pnetwork);
rtw_update_scanned_network(adapter, pnetwork);
/* spin_unlock_bh(&queue->lock); */
}
/* select the desired network based on the capability of the (i)bss. */
/* check items: (1) security */
/* (2) network_type */
/* (3) WMM */
/* (4) HT */
/* (5) others */
int rtw_is_desired_network(struct adapter *adapter, struct wlan_network *pnetwork);
int rtw_is_desired_network(struct adapter *adapter, struct wlan_network *pnetwork)
{
struct security_priv *psecuritypriv = &adapter->securitypriv;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
u32 desired_encmode;
u32 privacy;
/* u8 wps_ie[512]; */
uint wps_ielen;
int bselected = true;
desired_encmode = psecuritypriv->ndisencryptstatus;
privacy = pnetwork->network.privacy;
if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
if (rtw_get_wps_ie(pnetwork->network.ies+_FIXED_IE_LENGTH_, pnetwork->network.ie_length-_FIXED_IE_LENGTH_, NULL, &wps_ielen))
return true;
else
return false;
}
if (adapter->registrypriv.wifi_spec == 1) { /* for correct flow of 8021X to do.... */
u8 *p = NULL;
uint ie_len = 0;
if ((desired_encmode == Ndis802_11EncryptionDisabled) && (privacy != 0))
bselected = false;
if (psecuritypriv->ndisauthtype == Ndis802_11AuthModeWPA2PSK) {
p = rtw_get_ie(pnetwork->network.ies + _BEACON_IE_OFFSET_, WLAN_EID_RSN, &ie_len, (pnetwork->network.ie_length - _BEACON_IE_OFFSET_));
if (p && ie_len > 0)
bselected = true;
else
bselected = false;
}
}
if ((desired_encmode != Ndis802_11EncryptionDisabled) && (privacy == 0))
bselected = false;
if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) {
if (pnetwork->network.infrastructure_mode != pmlmepriv->cur_network.network.infrastructure_mode)
bselected = false;
}
return bselected;
}
/* TODO: Perry : For Power Management */
void rtw_atimdone_event_callback(struct adapter *adapter, u8 *pbuf)
{
}
void rtw_survey_event_callback(struct adapter *adapter, u8 *pbuf)
{
u32 len;
struct wlan_bssid_ex *pnetwork;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
pnetwork = (struct wlan_bssid_ex *)pbuf;
len = get_wlan_bssid_ex_sz(pnetwork);
if (len > (sizeof(struct wlan_bssid_ex)))
return;
spin_lock_bh(&pmlmepriv->lock);
/* update IBSS_network 's timestamp */
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) == true) {
if (!memcmp(&(pmlmepriv->cur_network.network.mac_address), pnetwork->mac_address, ETH_ALEN)) {
struct wlan_network *ibss_wlan = NULL;
memcpy(pmlmepriv->cur_network.network.ies, pnetwork->ies, 8);
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
ibss_wlan = rtw_find_network(&pmlmepriv->scanned_queue, pnetwork->mac_address);
if (ibss_wlan) {
memcpy(ibss_wlan->network.ies, pnetwork->ies, 8);
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
goto exit;
}
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
}
}
/* lock pmlmepriv->lock when you accessing network_q */
if ((check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) == false) {
if (pnetwork->ssid.ssid[0] == 0)
pnetwork->ssid.ssid_length = 0;
rtw_add_network(adapter, pnetwork);
}
exit:
spin_unlock_bh(&pmlmepriv->lock);
}
void rtw_surveydone_event_callback(struct adapter *adapter, u8 *pbuf)
{
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
spin_lock_bh(&pmlmepriv->lock);
if (pmlmepriv->wps_probe_req_ie) {
pmlmepriv->wps_probe_req_ie_len = 0;
kfree(pmlmepriv->wps_probe_req_ie);
pmlmepriv->wps_probe_req_ie = NULL;
}
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) {
spin_unlock_bh(&pmlmepriv->lock);
del_timer_sync(&pmlmepriv->scan_to_timer);
spin_lock_bh(&pmlmepriv->lock);
_clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
}
rtw_set_signal_stat_timer(&adapter->recvpriv);
if (pmlmepriv->to_join) {
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) {
if (check_fwstate(pmlmepriv, _FW_LINKED) == false) {
set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
if (rtw_select_and_join_from_scanned_queue(pmlmepriv) == _SUCCESS) {
_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);
} else {
u8 ret = _SUCCESS;
struct wlan_bssid_ex *pdev_network = &(adapter->registrypriv.dev_network);
u8 *pibss = adapter->registrypriv.dev_network.mac_address;
/* pmlmepriv->fw_state ^= _FW_UNDER_SURVEY;because don't set assoc_timer */
_clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
memcpy(&pdev_network->ssid, &pmlmepriv->assoc_ssid, sizeof(struct ndis_802_11_ssid));
rtw_update_registrypriv_dev_network(adapter);
rtw_generate_random_ibss(pibss);
pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;
pmlmepriv->to_join = false;
ret = rtw_createbss_cmd(adapter);
if (ret != _SUCCESS)
goto unlock;
}
}
} else {
int s_ret;
set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
pmlmepriv->to_join = false;
s_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv);
if (s_ret == _SUCCESS) {
_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);
} else if (s_ret == 2) {/* there is no need to wait for join */
_clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
rtw_indicate_connect(adapter);
} else {
if (rtw_to_roam(adapter) != 0) {
if (rtw_dec_to_roam(adapter) == 0
|| _SUCCESS != rtw_sitesurvey_cmd(adapter, &pmlmepriv->assoc_ssid, 1, NULL, 0)
) {
rtw_set_to_roam(adapter, 0);
rtw_free_assoc_resources(adapter, 1);
rtw_indicate_disconnect(adapter);
} else {
pmlmepriv->to_join = true;
}
} else
rtw_indicate_disconnect(adapter);
_clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
}
}
} else {
if (rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) {
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)
&& check_fwstate(pmlmepriv, _FW_LINKED)) {
if (rtw_select_roaming_candidate(pmlmepriv) == _SUCCESS) {
receive_disconnect(adapter, pmlmepriv->cur_network.network.mac_address
, WLAN_REASON_ACTIVE_ROAM);
}
}
}
}
unlock:
spin_unlock_bh(&pmlmepriv->lock);
rtw_os_xmit_schedule(adapter);
rtw_cfg80211_surveydone_event_callback(adapter);
rtw_indicate_scan_done(adapter, false);
}
void rtw_dummy_event_callback(struct adapter *adapter, u8 *pbuf)
{
}
void rtw_fwdbg_event_callback(struct adapter *adapter, u8 *pbuf)
{
}
static void free_scanqueue(struct mlme_priv *pmlmepriv)
{
struct __queue *free_queue = &pmlmepriv->free_bss_pool;
struct __queue *scan_queue = &pmlmepriv->scanned_queue;
struct list_head *plist, *phead, *ptemp;
spin_lock_bh(&scan_queue->lock);
spin_lock_bh(&free_queue->lock);
phead = get_list_head(scan_queue);
plist = get_next(phead);
while (plist != phead) {
ptemp = get_next(plist);
list_del_init(plist);
list_add_tail(plist, &free_queue->queue);
plist = ptemp;
}
spin_unlock_bh(&free_queue->lock);
spin_unlock_bh(&scan_queue->lock);
}
static void rtw_reset_rx_info(struct debug_priv *pdbgpriv)
{
pdbgpriv->dbg_rx_ampdu_drop_count = 0;
pdbgpriv->dbg_rx_ampdu_forced_indicate_count = 0;
pdbgpriv->dbg_rx_ampdu_loss_count = 0;
pdbgpriv->dbg_rx_dup_mgt_frame_drop_count = 0;
pdbgpriv->dbg_rx_ampdu_window_shift_cnt = 0;
}
static void find_network(struct adapter *adapter)
{
struct wlan_network *pwlan = NULL;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct wlan_network *tgt_network = &pmlmepriv->cur_network;
pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address);
if (pwlan)
pwlan->fixed = false;
if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) &&
(adapter->stapriv.asoc_sta_count == 1))
rtw_free_network_nolock(adapter, pwlan);
}
/*
*rtw_free_assoc_resources: the caller has to lock pmlmepriv->lock
*/
void rtw_free_assoc_resources(struct adapter *adapter, int lock_scanned_queue)
{
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct wlan_network *tgt_network = &pmlmepriv->cur_network;
struct dvobj_priv *psdpriv = adapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE|WIFI_AP_STATE)) {
struct sta_info *psta;
psta = rtw_get_stainfo(&adapter->stapriv, tgt_network->network.mac_address);
rtw_free_stainfo(adapter, psta);
}
if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE)) {
struct sta_info *psta;
rtw_free_all_stainfo(adapter);
psta = rtw_get_bcmc_stainfo(adapter);
rtw_free_stainfo(adapter, psta);
rtw_init_bcmc_stainfo(adapter);
}
find_network(adapter);
if (lock_scanned_queue)
adapter->securitypriv.key_mask = 0;
rtw_reset_rx_info(pdbgpriv);
}
/*
*rtw_indicate_connect: the caller has to lock pmlmepriv->lock
*/
void rtw_indicate_connect(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
pmlmepriv->to_join = false;
if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
set_fwstate(pmlmepriv, _FW_LINKED);
rtw_os_indicate_connect(padapter);
}
rtw_set_to_roam(padapter, 0);
rtw_set_scan_deny(padapter, 3000);
}
/*
*rtw_indicate_disconnect: the caller has to lock pmlmepriv->lock
*/
void rtw_indicate_disconnect(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
_clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING|WIFI_UNDER_WPS);
if (rtw_to_roam(padapter) > 0)
_clr_fwstate_(pmlmepriv, _FW_LINKED);
if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)
|| (rtw_to_roam(padapter) <= 0)
) {
rtw_os_indicate_disconnect(padapter);
/* set ips_deny_time to avoid enter IPS before LPS leave */
rtw_set_ips_deny(padapter, 3000);
_clr_fwstate_(pmlmepriv, _FW_LINKED);
rtw_clear_scan_deny(padapter);
}
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_DISCONNECT, 1);
}
inline void rtw_indicate_scan_done(struct adapter *padapter, bool aborted)
{
rtw_os_indicate_scan_done(padapter, aborted);
if (is_primary_adapter(padapter) &&
(!adapter_to_pwrctl(padapter)->bInSuspend) &&
(!check_fwstate(&padapter->mlmepriv,
WIFI_ASOC_STATE|WIFI_UNDER_LINKING))) {
rtw_set_ips_deny(padapter, 0);
_set_timer(&padapter->mlmepriv.dynamic_chk_timer, 1);
}
}
void rtw_scan_abort(struct adapter *adapter)
{
unsigned long start;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &(adapter->mlmeextpriv);
start = jiffies;
pmlmeext->scan_abort = true;
while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)
&& jiffies_to_msecs(start) <= 200) {
if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
break;
msleep(20);
}
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
rtw_indicate_scan_done(adapter, true);
pmlmeext->scan_abort = false;
}
static struct sta_info *rtw_joinbss_update_stainfo(struct adapter *padapter, struct wlan_network *pnetwork)
{
int i;
struct sta_info *bmc_sta, *psta = NULL;
struct recv_reorder_ctrl *preorder_ctrl;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
psta = rtw_get_stainfo(pstapriv, pnetwork->network.mac_address);
if (!psta)
psta = rtw_alloc_stainfo(pstapriv, pnetwork->network.mac_address);
if (psta) { /* update ptarget_sta */
psta->aid = pnetwork->join_res;
update_sta_info(padapter, psta);
/* update station supportRate */
psta->bssratelen = rtw_get_rateset_len(pnetwork->network.supported_rates);
memcpy(psta->bssrateset, pnetwork->network.supported_rates, psta->bssratelen);
rtw_hal_update_sta_rate_mask(padapter, psta);
psta->wireless_mode = pmlmeext->cur_wireless_mode;
psta->raid = networktype_to_raid_ex(padapter, psta);
/* sta mode */
rtw_hal_set_odm_var(padapter, HAL_ODM_STA_INFO, psta, true);
/* security related */
if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {
padapter->securitypriv.binstallGrpkey = false;
padapter->securitypriv.busetkipkey = false;
padapter->securitypriv.bgrpkey_handshake = false;
psta->ieee8021x_blocked = true;
psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
memset((u8 *)&psta->dot118021x_UncstKey, 0, sizeof(union Keytype));
memset((u8 *)&psta->dot11tkiprxmickey, 0, sizeof(union Keytype));
memset((u8 *)&psta->dot11tkiptxmickey, 0, sizeof(union Keytype));
memset((u8 *)&psta->dot11txpn, 0, sizeof(union pn48));
psta->dot11txpn.val = psta->dot11txpn.val + 1;
memset((u8 *)&psta->dot11wtxpn, 0, sizeof(union pn48));
memset((u8 *)&psta->dot11rxpn, 0, sizeof(union pn48));
}
/* Commented by Albert 2012/07/21 */
/* When doing the WPS, the wps_ie_len won't equal to 0 */
/* And the Wi-Fi driver shouldn't allow the data packet to be transmitted. */
if (padapter->securitypriv.wps_ie_len != 0) {
psta->ieee8021x_blocked = true;
padapter->securitypriv.wps_ie_len = 0;
}
/* for A-MPDU Rx reordering buffer control for bmc_sta & sta_info */
/* if A-MPDU Rx is enabled, resetting rx_ordering_ctrl wstart_b(indicate_seq) to default value = 0xffff */
/* todo: check if AP can send A-MPDU packets */
for (i = 0; i < 16 ; i++) {
/* preorder_ctrl = &precvpriv->recvreorder_ctrl[i]; */
preorder_ctrl = &psta->recvreorder_ctrl[i];
preorder_ctrl->enable = false;
preorder_ctrl->indicate_seq = 0xffff;
preorder_ctrl->wend_b = 0xffff;
preorder_ctrl->wsize_b = 64;/* max_ampdu_sz;ex. 32(kbytes) -> wsize_b =32 */
}
bmc_sta = rtw_get_bcmc_stainfo(padapter);
if (bmc_sta) {
for (i = 0; i < 16 ; i++) {
/* preorder_ctrl = &precvpriv->recvreorder_ctrl[i]; */
preorder_ctrl = &bmc_sta->recvreorder_ctrl[i];
preorder_ctrl->enable = false;
preorder_ctrl->indicate_seq = 0xffff;
preorder_ctrl->wend_b = 0xffff;
preorder_ctrl->wsize_b = 64;/* max_ampdu_sz;ex. 32(kbytes) -> wsize_b =32 */
}
}
}
return psta;
}
/* pnetwork : returns from rtw_joinbss_event_callback */
/* ptarget_wlan: found from scanned_queue */
static void rtw_joinbss_update_network(struct adapter *padapter, struct wlan_network *ptarget_wlan, struct wlan_network *pnetwork)
{
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
/* why not use ptarget_wlan?? */
memcpy(&cur_network->network, &pnetwork->network, pnetwork->network.length);
/* some ies in pnetwork is wrong, so we should use ptarget_wlan ies */
cur_network->network.ie_length = ptarget_wlan->network.ie_length;
memcpy(&cur_network->network.ies[0], &ptarget_wlan->network.ies[0], MAX_IE_SZ);
cur_network->aid = pnetwork->join_res;
rtw_set_signal_stat_timer(&padapter->recvpriv);
padapter->recvpriv.signal_strength = ptarget_wlan->network.phy_info.signal_strength;
padapter->recvpriv.signal_qual = ptarget_wlan->network.phy_info.signal_quality;
/* the ptarget_wlan->network.rssi is raw data, we use ptarget_wlan->network.phy_info.signal_strength instead (has scaled) */
padapter->recvpriv.rssi = translate_percentage_to_dbm(ptarget_wlan->network.phy_info.signal_strength);
rtw_set_signal_stat_timer(&padapter->recvpriv);
/* update fw_state will clr _FW_UNDER_LINKING here indirectly */
switch (pnetwork->network.infrastructure_mode) {
case Ndis802_11Infrastructure:
if (pmlmepriv->fw_state&WIFI_UNDER_WPS)
pmlmepriv->fw_state = WIFI_STATION_STATE|WIFI_UNDER_WPS;
else
pmlmepriv->fw_state = WIFI_STATION_STATE;
break;
case Ndis802_11IBSS:
pmlmepriv->fw_state = WIFI_ADHOC_STATE;
break;
default:
pmlmepriv->fw_state = WIFI_NULL_STATE;
break;
}
rtw_update_protection(padapter, (cur_network->network.ies) + sizeof(struct ndis_802_11_fix_ie),
(cur_network->network.ie_length));
rtw_update_ht_cap(padapter, cur_network->network.ies, cur_network->network.ie_length, (u8) cur_network->network.configuration.ds_config);
}
/* Notes: the function could be > passive_level (the same context as Rx tasklet) */
/* pnetwork : returns from rtw_joinbss_event_callback */
/* ptarget_wlan: found from scanned_queue */
/* if join_res > 0, for (fw_state ==WIFI_STATION_STATE), we check if "ptarget_sta" & "ptarget_wlan" exist. */
/* if join_res > 0, for (fw_state ==WIFI_ADHOC_STATE), we only check if "ptarget_wlan" exist. */
/* if join_res > 0, update "cur_network->network" from "pnetwork->network" if (ptarget_wlan != NULL). */
/* */
/* define REJOIN */
void rtw_joinbss_event_prehandle(struct adapter *adapter, u8 *pbuf)
{
static u8 __maybe_unused retry;
struct sta_info *ptarget_sta = NULL, *pcur_sta = NULL;
struct sta_priv *pstapriv = &adapter->stapriv;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
struct wlan_network *pcur_wlan = NULL, *ptarget_wlan = NULL;
unsigned int the_same_macaddr = false;
rtw_get_encrypt_decrypt_from_registrypriv(adapter);
the_same_macaddr = !memcmp(pnetwork->network.mac_address, cur_network->network.mac_address, ETH_ALEN);
pnetwork->network.length = get_wlan_bssid_ex_sz(&pnetwork->network);
if (pnetwork->network.length > sizeof(struct wlan_bssid_ex))
return;
spin_lock_bh(&pmlmepriv->lock);
pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
if (pnetwork->join_res > 0) {
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
retry = 0;
if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
/* s1. find ptarget_wlan */
if (check_fwstate(pmlmepriv, _FW_LINKED)) {
if (the_same_macaddr) {
ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address);
} else {
pcur_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address);
if (pcur_wlan)
pcur_wlan->fixed = false;
pcur_sta = rtw_get_stainfo(pstapriv, cur_network->network.mac_address);
if (pcur_sta)
rtw_free_stainfo(adapter, pcur_sta);
ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, pnetwork->network.mac_address);
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
if (ptarget_wlan)
ptarget_wlan->fixed = true;
}
}
} else {
ptarget_wlan = _rtw_find_same_network(&pmlmepriv->scanned_queue, pnetwork);
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
if (ptarget_wlan)
ptarget_wlan->fixed = true;
}
}
/* s2. update cur_network */
if (ptarget_wlan) {
rtw_joinbss_update_network(adapter, ptarget_wlan, pnetwork);
} else {
netdev_dbg(adapter->pnetdev,
"Can't find ptarget_wlan when joinbss_event callback\n");
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
goto ignore_joinbss_callback;
}
/* s3. find ptarget_sta & update ptarget_sta after update cur_network only for station mode */
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
ptarget_sta = rtw_joinbss_update_stainfo(adapter, pnetwork);
if (!ptarget_sta) {
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
goto ignore_joinbss_callback;
}
}
/* s4. indicate connect */
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
pmlmepriv->cur_network_scanned = ptarget_wlan;
rtw_indicate_connect(adapter);
}
spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
spin_unlock_bh(&pmlmepriv->lock);
/* s5. Cancel assoc_timer */
del_timer_sync(&pmlmepriv->assoc_timer);
spin_lock_bh(&pmlmepriv->lock);
} else {
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
}
} else if (pnetwork->join_res == -4) {
rtw_reset_securitypriv(adapter);
_set_timer(&pmlmepriv->assoc_timer, 1);
/* rtw_free_assoc_resources(adapter, 1); */
if ((check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) == true)
_clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
} else {/* if join_res < 0 (join fails), then try again */
#ifdef REJOIN
res = _FAIL;
if (retry < 2)
res = rtw_select_and_join_from_scanned_queue(pmlmepriv);
if (res == _SUCCESS) {
/* extend time of assoc_timer */
_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);
retry++;
} else if (res == 2) {/* there is no need to wait for join */
_clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
rtw_indicate_connect(adapter);
} else {
#endif
_set_timer(&pmlmepriv->assoc_timer, 1);
/* rtw_free_assoc_resources(adapter, 1); */
_clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
#ifdef REJOIN
retry = 0;
}
#endif
}
ignore_joinbss_callback:
spin_unlock_bh(&pmlmepriv->lock);
}
void rtw_joinbss_event_callback(struct adapter *adapter, u8 *pbuf)
{
struct wlan_network *pnetwork = (struct wlan_network *)pbuf;
mlmeext_joinbss_event_callback(adapter, pnetwork->join_res);
rtw_os_xmit_schedule(adapter);
}
/* FOR STA, AP , AD-HOC mode */
void rtw_sta_media_status_rpt(struct adapter *adapter, struct sta_info *psta, u32 mstatus)
{
u16 media_status_rpt;
if (!psta)
return;
media_status_rpt = (u16)((psta->mac_id<<8)|mstatus); /* MACID|OPMODE:1 connect */
rtw_hal_set_hwreg(adapter, HW_VAR_H2C_MEDIA_STATUS_RPT, (u8 *)&media_status_rpt);
}
void rtw_stassoc_event_callback(struct adapter *adapter, u8 *pbuf)
{
struct sta_info *psta;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct stassoc_event *pstassoc = (struct stassoc_event *)pbuf;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
struct wlan_network *ptarget_wlan = NULL;
if (rtw_access_ctrl(adapter, pstassoc->macaddr) == false)
return;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr);
if (psta) {
u8 *passoc_req = NULL;
u32 assoc_req_len = 0;
rtw_sta_media_status_rpt(adapter, psta, 1);
ap_sta_info_defer_update(adapter, psta);
/* report to upper layer */
spin_lock_bh(&psta->lock);
if (psta->passoc_req && psta->assoc_req_len > 0) {
passoc_req = rtw_zmalloc(psta->assoc_req_len);
if (passoc_req) {
assoc_req_len = psta->assoc_req_len;
memcpy(passoc_req, psta->passoc_req, assoc_req_len);
kfree(psta->passoc_req);
psta->passoc_req = NULL;
psta->assoc_req_len = 0;
}
}
spin_unlock_bh(&psta->lock);
if (passoc_req && assoc_req_len > 0) {
rtw_cfg80211_indicate_sta_assoc(adapter, passoc_req, assoc_req_len);
kfree(passoc_req);
}
}
return;
}
/* for AD-HOC mode */
psta = rtw_get_stainfo(&adapter->stapriv, pstassoc->macaddr);
if (psta) {
/* the sta have been in sta_info_queue => do nothing */
return; /* between drv has received this event before and fw have not yet to set key to CAM_ENTRY) */
}
psta = rtw_alloc_stainfo(&adapter->stapriv, pstassoc->macaddr);
if (!psta)
return;
/* to do : init sta_info variable */
psta->qos_option = 0;
psta->mac_id = (uint)pstassoc->cam_id;
/* psta->aid = (uint)pstassoc->cam_id; */
/* for ad-hoc mode */
rtw_hal_set_odm_var(adapter, HAL_ODM_STA_INFO, psta, true);
rtw_sta_media_status_rpt(adapter, psta, 1);
if (adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
psta->dot118021XPrivacy = adapter->securitypriv.dot11PrivacyAlgrthm;
psta->ieee8021x_blocked = false;
spin_lock_bh(&pmlmepriv->lock);
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) {
if (adapter->stapriv.asoc_sta_count == 2) {
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
ptarget_wlan = rtw_find_network(&pmlmepriv->scanned_queue, cur_network->network.mac_address);
pmlmepriv->cur_network_scanned = ptarget_wlan;
if (ptarget_wlan)
ptarget_wlan->fixed = true;
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
/* a sta + bc/mc_stainfo (not Ibss_stainfo) */
rtw_indicate_connect(adapter);
}
}
spin_unlock_bh(&pmlmepriv->lock);
mlmeext_sta_add_event_callback(adapter, psta);
}
void rtw_stadel_event_callback(struct adapter *adapter, u8 *pbuf)
{
int mac_id = (-1);
struct sta_info *psta;
struct wlan_network *pwlan = NULL;
struct wlan_bssid_ex *pdev_network = NULL;
u8 *pibss = NULL;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
struct stadel_event *pstadel = (struct stadel_event *)pbuf;
struct wlan_network *tgt_network = &(pmlmepriv->cur_network);
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
psta = rtw_get_stainfo(&adapter->stapriv, pstadel->macaddr);
if (psta)
mac_id = psta->mac_id;
else
mac_id = pstadel->mac_id;
if (mac_id >= 0) {
u16 media_status;
media_status = (mac_id<<8)|0; /* MACID|OPMODE:0 means disconnect */
/* for STA, AP, ADHOC mode, report disconnect stauts to FW */
rtw_hal_set_hwreg(adapter, HW_VAR_H2C_MEDIA_STATUS_RPT, (u8 *)&media_status);
}
/* if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) */
if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
return;
mlmeext_sta_del_event_callback(adapter);
spin_lock_bh(&pmlmepriv->lock);
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
u16 reason = *((unsigned short *)(pstadel->rsvd));
bool roam = false;
struct wlan_network *roam_target = NULL;
if (adapter->registrypriv.wifi_spec == 1) {
roam = false;
} else if (reason == WLAN_REASON_EXPIRATION_CHK && rtw_chk_roam_flags(adapter, RTW_ROAM_ON_EXPIRED)) {
roam = true;
} else if (reason == WLAN_REASON_ACTIVE_ROAM && rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) {
roam = true;
roam_target = pmlmepriv->roam_network;
}
if (roam) {
if (rtw_to_roam(adapter) > 0)
rtw_dec_to_roam(adapter); /* this stadel_event is caused by roaming, decrease to_roam */
else if (rtw_to_roam(adapter) == 0)
rtw_set_to_roam(adapter, adapter->registrypriv.max_roaming_times);
} else {
rtw_set_to_roam(adapter, 0);
}
rtw_free_uc_swdec_pending_queue(adapter);
rtw_free_assoc_resources(adapter, 1);
rtw_indicate_disconnect(adapter);
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
/* remove the network entry in scanned_queue */
pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address);
if (pwlan) {
pwlan->fixed = false;
rtw_free_network_nolock(adapter, pwlan);
}
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
_rtw_roaming(adapter, roam_target);
}
if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||
check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
rtw_free_stainfo(adapter, psta);
if (adapter->stapriv.asoc_sta_count == 1) {/* a sta + bc/mc_stainfo (not Ibss_stainfo) */
u8 ret = _SUCCESS;
/* rtw_indicate_disconnect(adapter);removed@20091105 */
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
/* free old ibss network */
/* pwlan = rtw_find_network(&pmlmepriv->scanned_queue, pstadel->macaddr); */
pwlan = rtw_find_network(&pmlmepriv->scanned_queue, tgt_network->network.mac_address);
if (pwlan) {
pwlan->fixed = false;
rtw_free_network_nolock(adapter, pwlan);
}
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
/* re-create ibss */
pdev_network = &(adapter->registrypriv.dev_network);
pibss = adapter->registrypriv.dev_network.mac_address;
memcpy(pdev_network, &tgt_network->network, get_wlan_bssid_ex_sz(&tgt_network->network));
memcpy(&pdev_network->ssid, &pmlmepriv->assoc_ssid, sizeof(struct ndis_802_11_ssid));
rtw_update_registrypriv_dev_network(adapter);
rtw_generate_random_ibss(pibss);
if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
set_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
_clr_fwstate_(pmlmepriv, WIFI_ADHOC_STATE);
}
ret = rtw_createbss_cmd(adapter);
if (ret != _SUCCESS)
goto unlock;
}
}
unlock:
spin_unlock_bh(&pmlmepriv->lock);
}
void rtw_cpwm_event_callback(struct adapter *padapter, u8 *pbuf)
{
struct reportpwrstate_parm *preportpwrstate;
preportpwrstate = (struct reportpwrstate_parm *)pbuf;
preportpwrstate->state |= (u8)(adapter_to_pwrctl(padapter)->cpwm_tog + 0x80);
cpwm_int_hdl(padapter, preportpwrstate);
}
void rtw_wmm_event_callback(struct adapter *padapter, u8 *pbuf)
{
WMMOnAssocRsp(padapter);
}
/*
* _rtw_join_timeout_handler - Timeout/failure handler for CMD JoinBss
* @adapter: pointer to struct adapter structure
*/
void _rtw_join_timeout_handler(struct timer_list *t)
{
struct adapter *adapter = from_timer(adapter, t,
mlmepriv.assoc_timer);
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
return;
spin_lock_bh(&pmlmepriv->lock);
if (rtw_to_roam(adapter) > 0) { /* join timeout caused by roaming */
while (1) {
rtw_dec_to_roam(adapter);
if (rtw_to_roam(adapter) != 0) { /* try another */
int do_join_r;
do_join_r = rtw_do_join(adapter);
if (do_join_r != _SUCCESS) {
continue;
}
break;
} else {
rtw_indicate_disconnect(adapter);
break;
}
}
} else {
rtw_indicate_disconnect(adapter);
free_scanqueue(pmlmepriv);/* */
/* indicate disconnect for the case that join_timeout and check_fwstate != FW_LINKED */
rtw_cfg80211_indicate_disconnect(adapter);
}
spin_unlock_bh(&pmlmepriv->lock);
}
/*
* rtw_scan_timeout_handler - Timeout/Failure handler for CMD SiteSurvey
* @adapter: pointer to struct adapter structure
*/
void rtw_scan_timeout_handler(struct timer_list *t)
{
struct adapter *adapter = from_timer(adapter, t,
mlmepriv.scan_to_timer);
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
spin_lock_bh(&pmlmepriv->lock);
_clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY);
spin_unlock_bh(&pmlmepriv->lock);
rtw_indicate_scan_done(adapter, true);
}
void rtw_mlme_reset_auto_scan_int(struct adapter *adapter)
{
struct mlme_priv *mlme = &adapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (pmlmeinfo->VHT_enable) /* disable auto scan when connect to 11AC AP */
mlme->auto_scan_int_ms = 0;
else if (adapter->registrypriv.wifi_spec && is_client_associated_to_ap(adapter) == true)
mlme->auto_scan_int_ms = 60*1000;
else if (rtw_chk_roam_flags(adapter, RTW_ROAM_ACTIVE)) {
if (check_fwstate(mlme, WIFI_STATION_STATE) && check_fwstate(mlme, _FW_LINKED))
mlme->auto_scan_int_ms = mlme->roam_scan_int_ms;
} else
mlme->auto_scan_int_ms = 0; /* disabled */
}
static void rtw_auto_scan_handler(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
rtw_mlme_reset_auto_scan_int(padapter);
if (pmlmepriv->auto_scan_int_ms != 0
&& jiffies_to_msecs(jiffies - pmlmepriv->scan_start_time) > pmlmepriv->auto_scan_int_ms) {
if (!padapter->registrypriv.wifi_spec) {
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING) == true)
goto exit;
if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
goto exit;
}
rtw_set_802_11_bssid_list_scan(padapter, NULL, 0);
}
exit:
return;
}
void rtw_dynamic_check_timer_handler(struct adapter *adapter)
{
if (!adapter)
return;
if (!adapter->hw_init_completed)
return;
if (adapter->bDriverStopped || adapter->bSurpriseRemoved)
return;
if (adapter->net_closed)
return;
if ((adapter_to_pwrctl(adapter)->fw_current_in_ps_mode)
&& !(hal_btcoex_IsBtControlLps(adapter))
) {
u8 bEnterPS;
linked_status_chk(adapter);
bEnterPS = traffic_status_watchdog(adapter, 1);
if (bEnterPS) {
/* rtw_lps_ctrl_wk_cmd(adapter, LPS_CTRL_ENTER, 1); */
rtw_hal_dm_watchdog_in_lps(adapter);
} else {
/* call rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1) in traffic_status_watchdog() */
}
} else {
if (is_primary_adapter(adapter))
rtw_dynamic_chk_wk_cmd(adapter);
}
/* auto site survey */
rtw_auto_scan_handler(adapter);
}
inline bool rtw_is_scan_deny(struct adapter *adapter)
{
struct mlme_priv *mlmepriv = &adapter->mlmepriv;
return (atomic_read(&mlmepriv->set_scan_deny) != 0) ? true : false;
}
inline void rtw_clear_scan_deny(struct adapter *adapter)
{
struct mlme_priv *mlmepriv = &adapter->mlmepriv;
atomic_set(&mlmepriv->set_scan_deny, 0);
}
void rtw_set_scan_deny(struct adapter *adapter, u32 ms)
{
struct mlme_priv *mlmepriv = &adapter->mlmepriv;
atomic_set(&mlmepriv->set_scan_deny, 1);
_set_timer(&mlmepriv->set_scan_deny_timer, ms);
}
/*
* Select a new roaming candidate from the original @param candidate and @param competitor
* @return true: candidate is updated
* @return false: candidate is not updated
*/
static int rtw_check_roaming_candidate(struct mlme_priv *mlme
, struct wlan_network **candidate, struct wlan_network *competitor)
{
int updated = false;
struct adapter *adapter = container_of(mlme, struct adapter, mlmepriv);
if (is_same_ess(&competitor->network, &mlme->cur_network.network) == false)
goto exit;
if (rtw_is_desired_network(adapter, competitor) == false)
goto exit;
/* got specific addr to roam */
if (!is_zero_mac_addr(mlme->roam_tgt_addr)) {
if (!memcmp(mlme->roam_tgt_addr, competitor->network.mac_address, ETH_ALEN))
goto update;
else
goto exit;
}
if (jiffies_to_msecs(jiffies - competitor->last_scanned) >= mlme->roam_scanr_exp_ms)
goto exit;
if (competitor->network.rssi - mlme->cur_network_scanned->network.rssi < mlme->roam_rssi_diff_th)
goto exit;
if (*candidate && (*candidate)->network.rssi >= competitor->network.rssi)
goto exit;
update:
*candidate = competitor;
updated = true;
exit:
return updated;
}
int rtw_select_roaming_candidate(struct mlme_priv *mlme)
{
int ret = _FAIL;
struct list_head *phead;
struct __queue *queue = &(mlme->scanned_queue);
struct wlan_network *pnetwork = NULL;
struct wlan_network *candidate = NULL;
if (!mlme->cur_network_scanned) {
rtw_warn_on(1);
return ret;
}
spin_lock_bh(&(mlme->scanned_queue.lock));
phead = get_list_head(queue);
list_for_each(mlme->pscanned, phead) {
pnetwork = list_entry(mlme->pscanned, struct wlan_network,
list);
rtw_check_roaming_candidate(mlme, &candidate, pnetwork);
}
if (!candidate) {
ret = _FAIL;
goto exit;
} else {
mlme->roam_network = candidate;
if (!memcmp(candidate->network.mac_address, mlme->roam_tgt_addr, ETH_ALEN))
eth_zero_addr(mlme->roam_tgt_addr);
}
ret = _SUCCESS;
exit:
spin_unlock_bh(&(mlme->scanned_queue.lock));
return ret;
}
/*
* Select a new join candidate from the original @param candidate and @param competitor
* @return true: candidate is updated
* @return false: candidate is not updated
*/
static int rtw_check_join_candidate(struct mlme_priv *mlme
, struct wlan_network **candidate, struct wlan_network *competitor)
{
int updated = false;
struct adapter *adapter = container_of(mlme, struct adapter, mlmepriv);
/* check bssid, if needed */
if (mlme->assoc_by_bssid) {
if (memcmp(competitor->network.mac_address, mlme->assoc_bssid, ETH_ALEN))
goto exit;
}
/* check ssid, if needed */
if (mlme->assoc_ssid.ssid[0] && mlme->assoc_ssid.ssid_length) {
if (competitor->network.ssid.ssid_length != mlme->assoc_ssid.ssid_length
|| memcmp(competitor->network.ssid.ssid, mlme->assoc_ssid.ssid, mlme->assoc_ssid.ssid_length)
)
goto exit;
}
if (rtw_is_desired_network(adapter, competitor) == false)
goto exit;
if (rtw_to_roam(adapter) > 0) {
if (jiffies_to_msecs(jiffies - competitor->last_scanned) >= mlme->roam_scanr_exp_ms
|| is_same_ess(&competitor->network, &mlme->cur_network.network) == false
)
goto exit;
}
if (!*candidate || (*candidate)->network.rssi < competitor->network.rssi) {
*candidate = competitor;
updated = true;
}
exit:
return updated;
}
/*
Calling context:
The caller of the sub-routine will be in critical section...
The caller must hold the following spinlock
pmlmepriv->lock
*/
int rtw_select_and_join_from_scanned_queue(struct mlme_priv *pmlmepriv)
{
int ret;
struct list_head *phead;
struct adapter *adapter;
struct __queue *queue = &(pmlmepriv->scanned_queue);
struct wlan_network *pnetwork = NULL;
struct wlan_network *candidate = NULL;
adapter = (struct adapter *)pmlmepriv->nic_hdl;
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
if (pmlmepriv->roam_network) {
candidate = pmlmepriv->roam_network;
pmlmepriv->roam_network = NULL;
goto candidate_exist;
}
phead = get_list_head(queue);
list_for_each(pmlmepriv->pscanned, phead) {
pnetwork = list_entry(pmlmepriv->pscanned,
struct wlan_network, list);
rtw_check_join_candidate(pmlmepriv, &candidate, pnetwork);
}
if (!candidate) {
ret = _FAIL;
goto exit;
} else {
goto candidate_exist;
}
candidate_exist:
/* check for situation of _FW_LINKED */
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
rtw_disassoc_cmd(adapter, 0, true);
rtw_indicate_disconnect(adapter);
rtw_free_assoc_resources(adapter, 0);
}
set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
ret = rtw_joinbss_cmd(adapter, candidate);
exit:
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
return ret;
}
signed int rtw_set_auth(struct adapter *adapter, struct security_priv *psecuritypriv)
{
struct cmd_obj *pcmd;
struct setauth_parm *psetauthparm;
struct cmd_priv *pcmdpriv = &(adapter->cmdpriv);
signed int res = _SUCCESS;
pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
if (!pcmd) {
res = _FAIL; /* try again */
goto exit;
}
psetauthparm = rtw_zmalloc(sizeof(struct setauth_parm));
if (!psetauthparm) {
kfree(pcmd);
res = _FAIL;
goto exit;
}
psetauthparm->mode = (unsigned char)psecuritypriv->dot11AuthAlgrthm;
pcmd->cmdcode = _SetAuth_CMD_;
pcmd->parmbuf = (unsigned char *)psetauthparm;
pcmd->cmdsz = (sizeof(struct setauth_parm));
pcmd->rsp = NULL;
pcmd->rspsz = 0;
INIT_LIST_HEAD(&pcmd->list);
res = rtw_enqueue_cmd(pcmdpriv, pcmd);
exit:
return res;
}
signed int rtw_set_key(struct adapter *adapter, struct security_priv *psecuritypriv, signed int keyid, u8 set_tx, bool enqueue)
{
u8 keylen;
struct cmd_obj *pcmd;
struct setkey_parm *psetkeyparm;
struct cmd_priv *pcmdpriv = &(adapter->cmdpriv);
signed int res = _SUCCESS;
psetkeyparm = rtw_zmalloc(sizeof(struct setkey_parm));
if (!psetkeyparm) {
res = _FAIL;
goto exit;
}
if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X)
psetkeyparm->algorithm = (unsigned char)psecuritypriv->dot118021XGrpPrivacy;
else
psetkeyparm->algorithm = (u8)psecuritypriv->dot11PrivacyAlgrthm;
psetkeyparm->keyid = (u8)keyid;/* 0~3 */
psetkeyparm->set_tx = set_tx;
if (is_wep_enc(psetkeyparm->algorithm))
adapter->securitypriv.key_mask |= BIT(psetkeyparm->keyid);
switch (psetkeyparm->algorithm) {
case _WEP40_:
keylen = 5;
memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
break;
case _WEP104_:
keylen = 13;
memcpy(&(psetkeyparm->key[0]), &(psecuritypriv->dot11DefKey[keyid].skey[0]), keylen);
break;
case _TKIP_:
keylen = 16;
memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
psetkeyparm->grpkey = 1;
break;
case _AES_:
keylen = 16;
memcpy(&psetkeyparm->key, &psecuritypriv->dot118021XGrpKey[keyid], keylen);
psetkeyparm->grpkey = 1;
break;
default:
res = _FAIL;
kfree(psetkeyparm);
goto exit;
}
if (enqueue) {
pcmd = rtw_zmalloc(sizeof(struct cmd_obj));
if (!pcmd) {
kfree(psetkeyparm);
res = _FAIL; /* try again */
goto exit;
}
pcmd->cmdcode = _SetKey_CMD_;
pcmd->parmbuf = (u8 *)psetkeyparm;
pcmd->cmdsz = (sizeof(struct setkey_parm));
pcmd->rsp = NULL;
pcmd->rspsz = 0;
INIT_LIST_HEAD(&pcmd->list);
res = rtw_enqueue_cmd(pcmdpriv, pcmd);
} else {
setkey_hdl(adapter, (u8 *)psetkeyparm);
kfree(psetkeyparm);
}
exit:
return res;
}
/* adjust ies for rtw_joinbss_cmd in WMM */
int rtw_restruct_wmm_ie(struct adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len, uint initial_out_len)
{
unsigned int ielength = 0;
unsigned int i, j;
i = 12; /* after the fixed IE */
while (i < in_len) {
ielength = initial_out_len;
if (in_ie[i] == 0xDD && in_ie[i+2] == 0x00 && in_ie[i+3] == 0x50 && in_ie[i+4] == 0xF2 && in_ie[i+5] == 0x02 && i+5 < in_len) { /* WMM element ID and OUI */
for (j = i; j < i + 9; j++) {
out_ie[ielength] = in_ie[j];
ielength++;
}
out_ie[initial_out_len + 1] = 0x07;
out_ie[initial_out_len + 6] = 0x00;
out_ie[initial_out_len + 8] = 0x00;
break;
}
i += (in_ie[i+1]+2); /* to the next IE element */
}
return ielength;
}
/* */
/* Ported from 8185: IsInPreAuthKeyList(). (Renamed from SecIsInPreAuthKeyList(), 2006-10-13.) */
/* Added by Annie, 2006-05-07. */
/* */
/* Search by BSSID, */
/* Return Value: */
/* -1 :if there is no pre-auth key in the table */
/* >= 0 :if there is pre-auth key, and return the entry id */
/* */
/* */
static int SecIsInPMKIDList(struct adapter *Adapter, u8 *bssid)
{
struct security_priv *p = &Adapter->securitypriv;
int i;
for (i = 0; i < NUM_PMKID_CACHE; i++)
if ((p->PMKIDList[i].bUsed) &&
(!memcmp(p->PMKIDList[i].Bssid, bssid, ETH_ALEN)))
return i;
return -1;
}
/* */
/* Check the RSN IE length */
/* If the RSN IE length <= 20, the RSN IE didn't include the PMKID information */
/* 0-11th element in the array are the fixed IE */
/* 12th element in the array is the IE */
/* 13th element in the array is the IE length */
/* */
static int rtw_append_pmkid(struct adapter *Adapter, int iEntry, u8 *ie, uint ie_len)
{
struct security_priv *psecuritypriv = &Adapter->securitypriv;
if (ie[13] <= 20) {
/* The RSN IE didn't include the PMK ID, append the PMK information */
ie[ie_len] = 1;
ie_len++;
ie[ie_len] = 0; /* PMKID count = 0x0100 */
ie_len++;
memcpy(&ie[ie_len], &psecuritypriv->PMKIDList[iEntry].PMKID, 16);
ie_len += 16;
ie[13] += 18;/* PMKID length = 2+16 */
}
return ie_len;
}
signed int rtw_restruct_sec_ie(struct adapter *adapter, u8 *in_ie, u8 *out_ie, uint in_len)
{
u8 authmode = 0x0;
uint ielength;
int iEntry;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct security_priv *psecuritypriv = &adapter->securitypriv;
uint ndisauthmode = psecuritypriv->ndisauthtype;
/* copy fixed ie only */
memcpy(out_ie, in_ie, 12);
ielength = 12;
if ((ndisauthmode == Ndis802_11AuthModeWPA) || (ndisauthmode == Ndis802_11AuthModeWPAPSK))
authmode = WLAN_EID_VENDOR_SPECIFIC;
if ((ndisauthmode == Ndis802_11AuthModeWPA2) || (ndisauthmode == Ndis802_11AuthModeWPA2PSK))
authmode = WLAN_EID_RSN;
if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS)) {
memcpy(out_ie+ielength, psecuritypriv->wps_ie, psecuritypriv->wps_ie_len);
ielength += psecuritypriv->wps_ie_len;
} else if ((authmode == WLAN_EID_VENDOR_SPECIFIC) || (authmode == WLAN_EID_RSN)) {
/* copy RSN or SSN */
memcpy(&out_ie[ielength], &psecuritypriv->supplicant_ie[0], psecuritypriv->supplicant_ie[1]+2);
/* debug for CONFIG_IEEE80211W
{
int jj;
printk("supplicant_ie_length =%d &&&&&&&&&&&&&&&&&&&\n", psecuritypriv->supplicant_ie[1]+2);
for (jj = 0; jj < psecuritypriv->supplicant_ie[1]+2; jj++)
printk(" %02x ", psecuritypriv->supplicant_ie[jj]);
printk("\n");
}*/
ielength += psecuritypriv->supplicant_ie[1]+2;
rtw_report_sec_ie(adapter, authmode, psecuritypriv->supplicant_ie);
}
iEntry = SecIsInPMKIDList(adapter, pmlmepriv->assoc_bssid);
if (iEntry < 0) {
return ielength;
} else {
if (authmode == WLAN_EID_RSN)
ielength = rtw_append_pmkid(adapter, iEntry, out_ie, ielength);
}
return ielength;
}
void rtw_init_registrypriv_dev_network(struct adapter *adapter)
{
struct registry_priv *pregistrypriv = &adapter->registrypriv;
struct eeprom_priv *peepriv = &adapter->eeprompriv;
struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network;
u8 *myhwaddr = myid(peepriv);
memcpy(pdev_network->mac_address, myhwaddr, ETH_ALEN);
memcpy(&pdev_network->ssid, &pregistrypriv->ssid, sizeof(struct ndis_802_11_ssid));
pdev_network->configuration.length = sizeof(struct ndis_802_11_conf);
pdev_network->configuration.beacon_period = 100;
}
void rtw_update_registrypriv_dev_network(struct adapter *adapter)
{
int sz = 0;
struct registry_priv *pregistrypriv = &adapter->registrypriv;
struct wlan_bssid_ex *pdev_network = &pregistrypriv->dev_network;
struct security_priv *psecuritypriv = &adapter->securitypriv;
struct wlan_network *cur_network = &adapter->mlmepriv.cur_network;
/* struct xmit_priv *pxmitpriv = &adapter->xmitpriv; */
pdev_network->privacy = (psecuritypriv->dot11PrivacyAlgrthm > 0 ? 1 : 0) ; /* adhoc no 802.1x */
pdev_network->rssi = 0;
switch (pregistrypriv->wireless_mode) {
case WIRELESS_11B:
pdev_network->network_type_in_use = (Ndis802_11DS);
break;
case WIRELESS_11G:
case WIRELESS_11BG:
case WIRELESS_11_24N:
case WIRELESS_11G_24N:
case WIRELESS_11BG_24N:
pdev_network->network_type_in_use = (Ndis802_11OFDM24);
break;
default:
/* TODO */
break;
}
pdev_network->configuration.ds_config = (pregistrypriv->channel);
if (cur_network->network.infrastructure_mode == Ndis802_11IBSS)
pdev_network->configuration.atim_window = (0);
pdev_network->infrastructure_mode = (cur_network->network.infrastructure_mode);
/* 1. Supported rates */
/* 2. IE */
/* rtw_set_supported_rate(pdev_network->supported_rates, pregistrypriv->wireless_mode) ; will be called in rtw_generate_ie */
sz = rtw_generate_ie(pregistrypriv);
pdev_network->ie_length = sz;
pdev_network->length = get_wlan_bssid_ex_sz((struct wlan_bssid_ex *)pdev_network);
/* notes: translate ie_length & length after assign the length to cmdsz in createbss_cmd(); */
/* pdev_network->ie_length = cpu_to_le32(sz); */
}
void rtw_get_encrypt_decrypt_from_registrypriv(struct adapter *adapter)
{
}
/* the function is at passive_level */
void rtw_joinbss_reset(struct adapter *padapter)
{
u8 threshold;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
/* todo: if you want to do something io/reg/hw setting before join_bss, please add code here */
pmlmepriv->num_FortyMHzIntolerant = 0;
pmlmepriv->num_sta_no_ht = 0;
phtpriv->ampdu_enable = false;/* reset to disabled */
/* TH = 1 => means that invalidate usb rx aggregation */
/* TH = 0 => means that validate usb rx aggregation, use init value. */
if (phtpriv->ht_option) {
if (padapter->registrypriv.wifi_spec == 1)
threshold = 1;
else
threshold = 0;
rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold));
} else {
threshold = 1;
rtw_hal_set_hwreg(padapter, HW_VAR_RXDMA_AGG_PG_TH, (u8 *)(&threshold));
}
}
void rtw_ht_use_default_setting(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
bool bHwLDPCSupport = false, bHwSTBCSupport = false;
bool bHwSupportBeamformer = false, bHwSupportBeamformee = false;
if (pregistrypriv->wifi_spec)
phtpriv->bss_coexist = 1;
else
phtpriv->bss_coexist = 0;
phtpriv->sgi_40m = TEST_FLAG(pregistrypriv->short_gi, BIT1) ? true : false;
phtpriv->sgi_20m = TEST_FLAG(pregistrypriv->short_gi, BIT0) ? true : false;
/* LDPC support */
rtw_hal_get_def_var(padapter, HAL_DEF_RX_LDPC, (u8 *)&bHwLDPCSupport);
CLEAR_FLAGS(phtpriv->ldpc_cap);
if (bHwLDPCSupport) {
if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT4))
SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_RX);
}
rtw_hal_get_def_var(padapter, HAL_DEF_TX_LDPC, (u8 *)&bHwLDPCSupport);
if (bHwLDPCSupport) {
if (TEST_FLAG(pregistrypriv->ldpc_cap, BIT5))
SET_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX);
}
/* STBC */
rtw_hal_get_def_var(padapter, HAL_DEF_TX_STBC, (u8 *)&bHwSTBCSupport);
CLEAR_FLAGS(phtpriv->stbc_cap);
if (bHwSTBCSupport) {
if (TEST_FLAG(pregistrypriv->stbc_cap, BIT5))
SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX);
}
rtw_hal_get_def_var(padapter, HAL_DEF_RX_STBC, (u8 *)&bHwSTBCSupport);
if (bHwSTBCSupport) {
if (TEST_FLAG(pregistrypriv->stbc_cap, BIT4))
SET_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX);
}
/* Beamforming setting */
rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMER, (u8 *)&bHwSupportBeamformer);
rtw_hal_get_def_var(padapter, HAL_DEF_EXPLICIT_BEAMFORMEE, (u8 *)&bHwSupportBeamformee);
CLEAR_FLAGS(phtpriv->beamform_cap);
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT4) && bHwSupportBeamformer)
SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMER_ENABLE);
if (TEST_FLAG(pregistrypriv->beamform_cap, BIT5) && bHwSupportBeamformee)
SET_FLAG(phtpriv->beamform_cap, BEAMFORMING_HT_BEAMFORMEE_ENABLE);
}
void rtw_build_wmm_ie_ht(struct adapter *padapter, u8 *out_ie, uint *pout_len)
{
unsigned char WMM_IE[] = {0x00, 0x50, 0xf2, 0x02, 0x00, 0x01, 0x00};
int out_len;
if (padapter->mlmepriv.qospriv.qos_option == 0) {
out_len = *pout_len;
rtw_set_ie(out_ie+out_len, WLAN_EID_VENDOR_SPECIFIC,
_WMM_IE_Length_, WMM_IE, pout_len);
padapter->mlmepriv.qospriv.qos_option = 1;
}
}
/* the function is >= passive_level */
unsigned int rtw_restructure_ht_ie(struct adapter *padapter, u8 *in_ie, u8 *out_ie, uint in_len, uint *pout_len, u8 channel)
{
u32 ielen, out_len;
enum ieee80211_max_ampdu_length_exp max_rx_ampdu_factor;
unsigned char *p;
struct ieee80211_ht_cap ht_capie;
u8 cbw40_enable = 0, stbc_rx_enable = 0, operation_bw = 0;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
phtpriv->ht_option = false;
out_len = *pout_len;
memset(&ht_capie, 0, sizeof(struct ieee80211_ht_cap));
ht_capie.cap_info = cpu_to_le16(IEEE80211_HT_CAP_DSSSCCK40);
if (phtpriv->sgi_20m)
ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SGI_20);
/* Get HT BW */
if (!in_ie) {
/* TDLS: TODO 20/40 issue */
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
operation_bw = padapter->mlmeextpriv.cur_bwmode;
if (operation_bw > CHANNEL_WIDTH_40)
operation_bw = CHANNEL_WIDTH_40;
} else
/* TDLS: TODO 40? */
operation_bw = CHANNEL_WIDTH_40;
} else {
p = rtw_get_ie(in_ie, WLAN_EID_HT_OPERATION, &ielen, in_len);
if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) {
struct HT_info_element *pht_info = (struct HT_info_element *)(p+2);
if (pht_info->infos[0] & BIT(2)) {
switch (pht_info->infos[0] & 0x3) {
case 1:
case 3:
operation_bw = CHANNEL_WIDTH_40;
break;
default:
operation_bw = CHANNEL_WIDTH_20;
break;
}
} else {
operation_bw = CHANNEL_WIDTH_20;
}
}
}
/* to disable 40M Hz support while gd_bw_40MHz_en = 0 */
if (channel > 14) {
if ((pregistrypriv->bw_mode & 0xf0) > 0)
cbw40_enable = 1;
} else {
if ((pregistrypriv->bw_mode & 0x0f) > 0)
cbw40_enable = 1;
}
if ((cbw40_enable == 1) && (operation_bw == CHANNEL_WIDTH_40)) {
ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SUP_WIDTH);
if (phtpriv->sgi_40m)
ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SGI_40);
}
if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX))
ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_TX_STBC);
/* todo: disable SM power save mode */
ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_SM_PS);
if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_RX)) {
if ((channel <= 14 && pregistrypriv->rx_stbc == 0x1) || /* enable for 2.4GHz */
(pregistrypriv->wifi_spec == 1))
stbc_rx_enable = 1;
}
/* fill default supported_mcs_set */
memcpy(&ht_capie.mcs, pmlmeext->default_supported_mcs_set, 16);
/* update default supported_mcs_set */
if (stbc_rx_enable)
ht_capie.cap_info |= cpu_to_le16(IEEE80211_HT_CAP_RX_STBC_1R);/* RX STBC One spatial stream */
set_mcs_rate_by_mask(ht_capie.mcs.rx_mask, MCS_RATE_1R);
{
u32 rx_packet_offset, max_recvbuf_sz;
rtw_hal_get_def_var(padapter, HAL_DEF_RX_PACKET_OFFSET, &rx_packet_offset);
rtw_hal_get_def_var(padapter, HAL_DEF_MAX_RECVBUF_SZ, &max_recvbuf_sz);
}
if (padapter->driver_rx_ampdu_factor != 0xFF)
max_rx_ampdu_factor =
(enum ieee80211_max_ampdu_length_exp)padapter->driver_rx_ampdu_factor;
else
rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR,
&max_rx_ampdu_factor);
/* rtw_hal_get_def_var(padapter, HW_VAR_MAX_RX_AMPDU_FACTOR, &max_rx_ampdu_factor); */
ht_capie.ampdu_params_info = (max_rx_ampdu_factor&0x03);
if (padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)
ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY&(0x07<<2));
else
ht_capie.ampdu_params_info |= (IEEE80211_HT_CAP_AMPDU_DENSITY&0x00);
rtw_set_ie(out_ie+out_len, WLAN_EID_HT_CAPABILITY,
sizeof(struct ieee80211_ht_cap), (unsigned char *)&ht_capie, pout_len);
phtpriv->ht_option = true;
if (in_ie) {
p = rtw_get_ie(in_ie, WLAN_EID_HT_OPERATION, &ielen, in_len);
if (p && (ielen == sizeof(struct ieee80211_ht_addt_info))) {
out_len = *pout_len;
rtw_set_ie(out_ie+out_len, WLAN_EID_HT_OPERATION, ielen, p+2, pout_len);
}
}
return phtpriv->ht_option;
}
/* the function is > passive_level (in critical_section) */
void rtw_update_ht_cap(struct adapter *padapter, u8 *pie, uint ie_len, u8 channel)
{
u8 *p, max_ampdu_sz;
int len;
/* struct sta_info *bmc_sta, *psta; */
struct ieee80211_ht_cap *pht_capie;
/* struct recv_reorder_ctrl *preorder_ctrl; */
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
/* struct recv_priv *precvpriv = &padapter->recvpriv; */
struct registry_priv *pregistrypriv = &padapter->registrypriv;
/* struct wlan_network *pcur_network = &(pmlmepriv->cur_network);; */
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u8 cbw40_enable = 0;
if (!phtpriv->ht_option)
return;
if ((!pmlmeinfo->HT_info_enable) || (!pmlmeinfo->HT_caps_enable))
return;
/* maybe needs check if ap supports rx ampdu. */
if (!(phtpriv->ampdu_enable) && pregistrypriv->ampdu_enable == 1) {
phtpriv->ampdu_enable = true;
}
/* check Max Rx A-MPDU Size */
len = 0;
p = rtw_get_ie(pie+sizeof(struct ndis_802_11_fix_ie), WLAN_EID_HT_CAPABILITY, &len, ie_len-sizeof(struct ndis_802_11_fix_ie));
if (p && len > 0) {
pht_capie = (struct ieee80211_ht_cap *)(p+2);
max_ampdu_sz = (pht_capie->ampdu_params_info & IEEE80211_HT_CAP_AMPDU_FACTOR);
max_ampdu_sz = 1 << (max_ampdu_sz+3); /* max_ampdu_sz (kbytes); */
phtpriv->rx_ampdu_maxlen = max_ampdu_sz;
}
len = 0;
p = rtw_get_ie(pie+sizeof(struct ndis_802_11_fix_ie), WLAN_EID_HT_OPERATION, &len, ie_len-sizeof(struct ndis_802_11_fix_ie));
if (p && len > 0) {
/* todo: */
}
if (channel > 14) {
if ((pregistrypriv->bw_mode & 0xf0) > 0)
cbw40_enable = 1;
} else {
if ((pregistrypriv->bw_mode & 0x0f) > 0)
cbw40_enable = 1;
}
/* update cur_bwmode & cur_ch_offset */
if ((cbw40_enable) &&
(le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) &
BIT(1)) && (pmlmeinfo->HT_info.infos[0] & BIT(2))) {
int i;
/* update the MCS set */
for (i = 0; i < 16; i++)
pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= pmlmeext->default_supported_mcs_set[i];
/* update the MCS rates */
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_1R);
/* switch to the 40M Hz mode according to the AP */
/* pmlmeext->cur_bwmode = CHANNEL_WIDTH_40; */
switch ((pmlmeinfo->HT_info.infos[0] & 0x3)) {
case EXTCHNL_OFFSET_UPPER:
pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
break;
case EXTCHNL_OFFSET_LOWER:
pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
break;
default:
pmlmeext->cur_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
break;
}
}
/* */
/* Config SM Power Save setting */
/* */
pmlmeinfo->SM_PS =
(le16_to_cpu(pmlmeinfo->HT_caps.u.HT_cap_element.HT_caps_info) &
0x0C) >> 2;
/* */
/* Config current HT Protection mode. */
/* */
pmlmeinfo->HT_protection = pmlmeinfo->HT_info.infos[1] & 0x3;
}
void rtw_issue_addbareq_cmd(struct adapter *padapter, struct xmit_frame *pxmitframe)
{
u8 issued;
int priority;
struct sta_info *psta;
struct ht_priv *phtpriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
s32 bmcst = is_multicast_ether_addr(pattrib->ra);
/* if (bmcst || (padapter->mlmepriv.LinkDetectInfo.bTxBusyTraffic == false)) */
if (bmcst || (padapter->mlmepriv.LinkDetectInfo.NumTxOkInPeriod < 100))
return;
priority = pattrib->priority;
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (pattrib->psta != psta)
return;
if (!psta)
return;
if (!(psta->state & _FW_LINKED))
return;
phtpriv = &psta->htpriv;
if (phtpriv->ht_option && phtpriv->ampdu_enable) {
issued = (phtpriv->agg_enable_bitmap>>priority)&0x1;
issued |= (phtpriv->candidate_tid_bitmap>>priority)&0x1;
if (issued == 0) {
psta->htpriv.candidate_tid_bitmap |= BIT((u8)priority);
rtw_addbareq_cmd(padapter, (u8) priority, pattrib->ra);
}
}
}
void rtw_append_exented_cap(struct adapter *padapter, u8 *out_ie, uint *pout_len)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
u8 cap_content[8] = {0};
if (phtpriv->bss_coexist)
SET_EXT_CAPABILITY_ELE_BSS_COEXIST(cap_content, 1);
rtw_set_ie(out_ie + *pout_len, WLAN_EID_EXT_CAPABILITY, 8, cap_content, pout_len);
}
inline void rtw_set_to_roam(struct adapter *adapter, u8 to_roam)
{
if (to_roam == 0)
adapter->mlmepriv.to_join = false;
adapter->mlmepriv.to_roam = to_roam;
}
inline u8 rtw_dec_to_roam(struct adapter *adapter)
{
adapter->mlmepriv.to_roam--;
return adapter->mlmepriv.to_roam;
}
inline u8 rtw_to_roam(struct adapter *adapter)
{
return adapter->mlmepriv.to_roam;
}
void rtw_roaming(struct adapter *padapter, struct wlan_network *tgt_network)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
spin_lock_bh(&pmlmepriv->lock);
_rtw_roaming(padapter, tgt_network);
spin_unlock_bh(&pmlmepriv->lock);
}
void _rtw_roaming(struct adapter *padapter, struct wlan_network *tgt_network)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *cur_network = &pmlmepriv->cur_network;
if (rtw_to_roam(padapter) > 0) {
memcpy(&pmlmepriv->assoc_ssid, &cur_network->network.ssid, sizeof(struct ndis_802_11_ssid));
pmlmepriv->assoc_by_bssid = false;
while (rtw_do_join(padapter) != _SUCCESS) {
rtw_dec_to_roam(padapter);
if (rtw_to_roam(padapter) <= 0) {
rtw_indicate_disconnect(padapter);
break;
}
}
}
}
signed int rtw_linked_check(struct adapter *padapter)
{
if ((check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == true) ||
(check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE) == true)) {
if (padapter->stapriv.asoc_sta_count > 2)
return true;
} else { /* Station mode */
if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) == true)
return true;
}
return false;
}
| linux-master | drivers/staging/rtl8723bs/core/rtw_mlme.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
u8 rtw_validate_bssid(u8 *bssid)
{
u8 ret = true;
if (is_zero_mac_addr(bssid)
|| is_broadcast_mac_addr(bssid)
|| is_multicast_mac_addr(bssid)
) {
ret = false;
}
return ret;
}
u8 rtw_validate_ssid(struct ndis_802_11_ssid *ssid)
{
u8 ret = true;
if (ssid->ssid_length > 32) {
ret = false;
goto exit;
}
exit:
return ret;
}
u8 rtw_do_join(struct adapter *padapter)
{
struct list_head *plist, *phead;
u8 *pibss = NULL;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct __queue *queue = &(pmlmepriv->scanned_queue);
u8 ret = _SUCCESS;
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
phead = get_list_head(queue);
plist = get_next(phead);
pmlmepriv->cur_network.join_res = -2;
set_fwstate(pmlmepriv, _FW_UNDER_LINKING);
pmlmepriv->pscanned = plist;
pmlmepriv->to_join = true;
if (list_empty(&queue->queue)) {
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
_clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
/* when set_ssid/set_bssid for rtw_do_join(), but scanning queue is empty */
/* we try to issue sitesurvey firstly */
if (pmlmepriv->LinkDetectInfo.bBusyTraffic == false
|| rtw_to_roam(padapter) > 0
) {
/* submit site_survey_cmd */
ret = rtw_sitesurvey_cmd(padapter, &pmlmepriv->assoc_ssid, 1, NULL, 0);
if (ret != _SUCCESS)
pmlmepriv->to_join = false;
} else {
pmlmepriv->to_join = false;
ret = _FAIL;
}
goto exit;
} else {
int select_ret;
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
select_ret = rtw_select_and_join_from_scanned_queue(pmlmepriv);
if (select_ret == _SUCCESS) {
pmlmepriv->to_join = false;
_set_timer(&pmlmepriv->assoc_timer, MAX_JOIN_TIMEOUT);
} else {
if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) {
/* submit createbss_cmd to change to a ADHOC_MASTER */
/* pmlmepriv->lock has been acquired by caller... */
struct wlan_bssid_ex *pdev_network = &(padapter->registrypriv.dev_network);
pmlmepriv->fw_state = WIFI_ADHOC_MASTER_STATE;
pibss = padapter->registrypriv.dev_network.mac_address;
memcpy(&pdev_network->ssid, &pmlmepriv->assoc_ssid, sizeof(struct ndis_802_11_ssid));
rtw_update_registrypriv_dev_network(padapter);
rtw_generate_random_ibss(pibss);
if (rtw_createbss_cmd(padapter) != _SUCCESS) {
ret = false;
goto exit;
}
pmlmepriv->to_join = false;
} else {
/* can't associate ; reset under-linking */
_clr_fwstate_(pmlmepriv, _FW_UNDER_LINKING);
/* when set_ssid/set_bssid for rtw_do_join(), but there are no desired bss in scanning queue */
/* we try to issue sitesurvey firstly */
if (pmlmepriv->LinkDetectInfo.bBusyTraffic == false
|| rtw_to_roam(padapter) > 0
) {
ret = rtw_sitesurvey_cmd(padapter, &pmlmepriv->assoc_ssid, 1, NULL, 0);
if (ret != _SUCCESS)
pmlmepriv->to_join = false;
} else {
ret = _FAIL;
pmlmepriv->to_join = false;
}
}
}
}
exit:
return ret;
}
u8 rtw_set_802_11_ssid(struct adapter *padapter, struct ndis_802_11_ssid *ssid)
{
u8 status = _SUCCESS;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *pnetwork = &pmlmepriv->cur_network;
netdev_dbg(padapter->pnetdev, "set ssid [%s] fw_state = 0x%08x\n",
ssid->ssid, get_fwstate(pmlmepriv));
if (padapter->hw_init_completed == false) {
status = _FAIL;
goto exit;
}
spin_lock_bh(&pmlmepriv->lock);
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true)
goto handle_tkip_countermeasure;
else if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true)
goto release_mlme_lock;
if (check_fwstate(pmlmepriv, _FW_LINKED|WIFI_ADHOC_MASTER_STATE) == true) {
if ((pmlmepriv->assoc_ssid.ssid_length == ssid->ssid_length) &&
(!memcmp(&pmlmepriv->assoc_ssid.ssid, ssid->ssid, ssid->ssid_length))) {
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == false) {
if (rtw_is_same_ibss(padapter, pnetwork) == false) {
/* if in WIFI_ADHOC_MASTER_STATE | WIFI_ADHOC_STATE, create bss or rejoin again */
rtw_disassoc_cmd(padapter, 0, true);
if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
rtw_indicate_disconnect(padapter);
rtw_free_assoc_resources(padapter, 1);
if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) {
_clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
}
} else {
goto release_mlme_lock;/* it means driver is in WIFI_ADHOC_MASTER_STATE, we needn't create bss again. */
}
} else {
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_JOINBSS, 1);
}
} else {
rtw_disassoc_cmd(padapter, 0, true);
if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
rtw_indicate_disconnect(padapter);
rtw_free_assoc_resources(padapter, 1);
if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) {
_clr_fwstate_(pmlmepriv, WIFI_ADHOC_MASTER_STATE);
set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
}
}
}
handle_tkip_countermeasure:
if (rtw_handle_tkip_countermeasure(padapter, __func__) == _FAIL) {
status = _FAIL;
goto release_mlme_lock;
}
if (rtw_validate_ssid(ssid) == false) {
status = _FAIL;
goto release_mlme_lock;
}
memcpy(&pmlmepriv->assoc_ssid, ssid, sizeof(struct ndis_802_11_ssid));
pmlmepriv->assoc_by_bssid = false;
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true)
pmlmepriv->to_join = true;
else
status = rtw_do_join(padapter);
release_mlme_lock:
spin_unlock_bh(&pmlmepriv->lock);
exit:
return status;
}
u8 rtw_set_802_11_connect(struct adapter *padapter, u8 *bssid, struct ndis_802_11_ssid *ssid)
{
u8 status = _SUCCESS;
bool bssid_valid = true;
bool ssid_valid = true;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (!ssid || rtw_validate_ssid(ssid) == false)
ssid_valid = false;
if (!bssid || rtw_validate_bssid(bssid) == false)
bssid_valid = false;
if (!ssid_valid && !bssid_valid) {
status = _FAIL;
goto exit;
}
if (padapter->hw_init_completed == false) {
status = _FAIL;
goto exit;
}
spin_lock_bh(&pmlmepriv->lock);
netdev_dbg(padapter->pnetdev, FUNC_ADPT_FMT " fw_state = 0x%08x\n",
FUNC_ADPT_ARG(padapter), get_fwstate(pmlmepriv));
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true)
goto handle_tkip_countermeasure;
else if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true)
goto release_mlme_lock;
handle_tkip_countermeasure:
if (rtw_handle_tkip_countermeasure(padapter, __func__) == _FAIL) {
status = _FAIL;
goto release_mlme_lock;
}
if (ssid && ssid_valid)
memcpy(&pmlmepriv->assoc_ssid, ssid, sizeof(struct ndis_802_11_ssid));
else
memset(&pmlmepriv->assoc_ssid, 0, sizeof(struct ndis_802_11_ssid));
if (bssid && bssid_valid) {
memcpy(&pmlmepriv->assoc_bssid, bssid, ETH_ALEN);
pmlmepriv->assoc_by_bssid = true;
} else {
pmlmepriv->assoc_by_bssid = false;
}
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true)
pmlmepriv->to_join = true;
else
status = rtw_do_join(padapter);
release_mlme_lock:
spin_unlock_bh(&pmlmepriv->lock);
exit:
return status;
}
u8 rtw_set_802_11_infrastructure_mode(struct adapter *padapter,
enum ndis_802_11_network_infrastructure networktype)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *cur_network = &pmlmepriv->cur_network;
enum ndis_802_11_network_infrastructure *pold_state = &(cur_network->network.infrastructure_mode);
if (*pold_state != networktype) {
if (*pold_state == Ndis802_11APMode) {
/* change to other mode from Ndis802_11APMode */
cur_network->join_res = -1;
stop_ap_mode(padapter);
}
spin_lock_bh(&pmlmepriv->lock);
if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) || (*pold_state == Ndis802_11IBSS))
rtw_disassoc_cmd(padapter, 0, true);
if ((check_fwstate(pmlmepriv, _FW_LINKED) == true) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true))
rtw_free_assoc_resources(padapter, 1);
if ((*pold_state == Ndis802_11Infrastructure) || (*pold_state == Ndis802_11IBSS)) {
if (check_fwstate(pmlmepriv, _FW_LINKED) == true)
rtw_indicate_disconnect(padapter); /* will clr Linked_state; before this function, we must have checked whether issue dis-assoc_cmd or not */
}
*pold_state = networktype;
_clr_fwstate_(pmlmepriv, ~WIFI_NULL_STATE);
switch (networktype) {
case Ndis802_11IBSS:
set_fwstate(pmlmepriv, WIFI_ADHOC_STATE);
break;
case Ndis802_11Infrastructure:
set_fwstate(pmlmepriv, WIFI_STATION_STATE);
break;
case Ndis802_11APMode:
set_fwstate(pmlmepriv, WIFI_AP_STATE);
start_ap_mode(padapter);
/* rtw_indicate_connect(padapter); */
break;
case Ndis802_11AutoUnknown:
case Ndis802_11InfrastructureMax:
break;
}
/* SecClearAllKeys(adapter); */
spin_unlock_bh(&pmlmepriv->lock);
}
return true;
}
u8 rtw_set_802_11_disassociate(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
spin_lock_bh(&pmlmepriv->lock);
if (check_fwstate(pmlmepriv, _FW_LINKED) == true) {
rtw_disassoc_cmd(padapter, 0, true);
rtw_indicate_disconnect(padapter);
/* modify for CONFIG_IEEE80211W, none 11w can use it */
rtw_free_assoc_resources_cmd(padapter);
rtw_pwr_wakeup(padapter);
}
spin_unlock_bh(&pmlmepriv->lock);
return true;
}
u8 rtw_set_802_11_bssid_list_scan(struct adapter *padapter, struct ndis_802_11_ssid *pssid, int ssid_max_num)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
u8 res = true;
if (!padapter) {
res = false;
goto exit;
}
if (padapter->hw_init_completed == false) {
res = false;
goto exit;
}
if ((check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING) == true) ||
(pmlmepriv->LinkDetectInfo.bBusyTraffic == true)) {
/* Scan or linking is in progress, do nothing. */
res = true;
} else {
if (rtw_is_scan_deny(padapter))
return _SUCCESS;
spin_lock_bh(&pmlmepriv->lock);
res = rtw_sitesurvey_cmd(padapter, pssid, ssid_max_num, NULL, 0);
spin_unlock_bh(&pmlmepriv->lock);
}
exit:
return res;
}
u8 rtw_set_802_11_authentication_mode(struct adapter *padapter, enum ndis_802_11_authentication_mode authmode)
{
struct security_priv *psecuritypriv = &padapter->securitypriv;
int res;
u8 ret;
psecuritypriv->ndisauthtype = authmode;
if (psecuritypriv->ndisauthtype > 3)
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
res = rtw_set_auth(padapter, psecuritypriv);
if (res == _SUCCESS)
ret = true;
else
ret = false;
return ret;
}
u8 rtw_set_802_11_add_wep(struct adapter *padapter, struct ndis_802_11_wep *wep)
{
signed int keyid, res;
struct security_priv *psecuritypriv = &(padapter->securitypriv);
u8 ret = _SUCCESS;
keyid = wep->key_index & 0x3fffffff;
if (keyid >= 4) {
ret = false;
goto exit;
}
switch (wep->key_length) {
case 5:
psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
break;
case 13:
psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
break;
default:
psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
break;
}
memcpy(&(psecuritypriv->dot11DefKey[keyid].skey[0]), &(wep->key_material), wep->key_length);
psecuritypriv->dot11DefKeylen[keyid] = wep->key_length;
psecuritypriv->dot11PrivacyKeyIndex = keyid;
res = rtw_set_key(padapter, psecuritypriv, keyid, 1, true);
if (res == _FAIL)
ret = false;
exit:
return ret;
}
/*
* rtw_get_cur_max_rate -
* @adapter: pointer to struct adapter structure
*
* Return 0 or 100Kbps
*/
u16 rtw_get_cur_max_rate(struct adapter *adapter)
{
int i = 0;
u16 rate = 0, max_rate = 0;
struct mlme_priv *pmlmepriv = &adapter->mlmepriv;
struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
struct sta_info *psta = NULL;
u8 short_GI = 0;
if ((check_fwstate(pmlmepriv, _FW_LINKED) != true)
&& (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) != true))
return 0;
psta = rtw_get_stainfo(&adapter->stapriv, get_bssid(pmlmepriv));
if (!psta)
return 0;
short_GI = query_ra_short_GI(psta);
if (is_supported_ht(psta->wireless_mode)) {
max_rate = rtw_mcs_rate(psta->bw_mode == CHANNEL_WIDTH_40 ? 1 : 0,
short_GI,
psta->htpriv.ht_cap.mcs.rx_mask);
} else {
while ((pcur_bss->supported_rates[i] != 0) && (pcur_bss->supported_rates[i] != 0xFF)) {
rate = pcur_bss->supported_rates[i]&0x7F;
if (rate > max_rate)
max_rate = rate;
i++;
}
max_rate = max_rate*10/2;
}
return max_rate;
}
| linux-master | drivers/staging/rtl8723bs/core/rtw_ioctl_set.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <linux/kernel.h>
static const u32 ch_freq_map[] = {
2412,
2417,
2422,
2427,
2432,
2437,
2442,
2447,
2452,
2457,
2462,
2467,
2472,
2484
};
u32 rtw_ch2freq(u32 channel)
{
if (channel == 0 || channel > ARRAY_SIZE(ch_freq_map))
return 2412;
return ch_freq_map[channel - 1];
}
| linux-master | drivers/staging/rtl8723bs/core/rtw_rf.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
static u8 P802_1H_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0xf8 };
static u8 RFC1042_OUI[P80211_OUI_LEN] = { 0x00, 0x00, 0x00 };
static void _init_txservq(struct tx_servq *ptxservq)
{
INIT_LIST_HEAD(&ptxservq->tx_pending);
INIT_LIST_HEAD(&ptxservq->sta_pending.queue);
spin_lock_init(&ptxservq->sta_pending.lock);
ptxservq->qcnt = 0;
}
void _rtw_init_sta_xmit_priv(struct sta_xmit_priv *psta_xmitpriv)
{
memset((unsigned char *)psta_xmitpriv, 0, sizeof(struct sta_xmit_priv));
spin_lock_init(&psta_xmitpriv->lock);
_init_txservq(&psta_xmitpriv->be_q);
_init_txservq(&psta_xmitpriv->bk_q);
_init_txservq(&psta_xmitpriv->vi_q);
_init_txservq(&psta_xmitpriv->vo_q);
INIT_LIST_HEAD(&psta_xmitpriv->legacy_dz);
INIT_LIST_HEAD(&psta_xmitpriv->apsd);
}
s32 _rtw_init_xmit_priv(struct xmit_priv *pxmitpriv, struct adapter *padapter)
{
int i;
struct xmit_buf *pxmitbuf;
struct xmit_frame *pxframe;
signed int res = _SUCCESS;
spin_lock_init(&pxmitpriv->lock);
spin_lock_init(&pxmitpriv->lock_sctx);
init_completion(&pxmitpriv->xmit_comp);
init_completion(&pxmitpriv->terminate_xmitthread_comp);
/*
* Please insert all the queue initializaiton using _rtw_init_queue below
*/
pxmitpriv->adapter = padapter;
INIT_LIST_HEAD(&pxmitpriv->be_pending.queue);
spin_lock_init(&pxmitpriv->be_pending.lock);
INIT_LIST_HEAD(&pxmitpriv->bk_pending.queue);
spin_lock_init(&pxmitpriv->bk_pending.lock);
INIT_LIST_HEAD(&pxmitpriv->vi_pending.queue);
spin_lock_init(&pxmitpriv->vi_pending.lock);
INIT_LIST_HEAD(&pxmitpriv->vo_pending.queue);
spin_lock_init(&pxmitpriv->vo_pending.lock);
INIT_LIST_HEAD(&pxmitpriv->bm_pending.queue);
spin_lock_init(&pxmitpriv->bm_pending.lock);
INIT_LIST_HEAD(&pxmitpriv->free_xmit_queue.queue);
spin_lock_init(&pxmitpriv->free_xmit_queue.lock);
/*
* Please allocate memory with the sz = (struct xmit_frame) * NR_XMITFRAME,
* and initialize free_xmit_frame below.
* Please also apply free_txobj to link_up all the xmit_frames...
*/
pxmitpriv->pallocated_frame_buf = vzalloc(NR_XMITFRAME * sizeof(struct xmit_frame) + 4);
if (!pxmitpriv->pallocated_frame_buf) {
pxmitpriv->pxmit_frame_buf = NULL;
res = _FAIL;
goto exit;
}
pxmitpriv->pxmit_frame_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_frame_buf), 4);
pxframe = (struct xmit_frame *) pxmitpriv->pxmit_frame_buf;
for (i = 0; i < NR_XMITFRAME; i++) {
INIT_LIST_HEAD(&pxframe->list);
pxframe->padapter = padapter;
pxframe->frame_tag = NULL_FRAMETAG;
pxframe->pkt = NULL;
pxframe->buf_addr = NULL;
pxframe->pxmitbuf = NULL;
list_add_tail(&pxframe->list,
&pxmitpriv->free_xmit_queue.queue);
pxframe++;
}
pxmitpriv->free_xmitframe_cnt = NR_XMITFRAME;
pxmitpriv->frag_len = MAX_FRAG_THRESHOLD;
/* init xmit_buf */
INIT_LIST_HEAD(&pxmitpriv->free_xmitbuf_queue.queue);
spin_lock_init(&pxmitpriv->free_xmitbuf_queue.lock);
INIT_LIST_HEAD(&pxmitpriv->pending_xmitbuf_queue.queue);
spin_lock_init(&pxmitpriv->pending_xmitbuf_queue.lock);
pxmitpriv->pallocated_xmitbuf = vzalloc(NR_XMITBUFF * sizeof(struct xmit_buf) + 4);
if (!pxmitpriv->pallocated_xmitbuf) {
res = _FAIL;
goto exit;
}
pxmitpriv->pxmitbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmitbuf), 4);
pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
for (i = 0; i < NR_XMITBUFF; i++) {
INIT_LIST_HEAD(&pxmitbuf->list);
pxmitbuf->priv_data = NULL;
pxmitbuf->padapter = padapter;
pxmitbuf->buf_tag = XMITBUF_DATA;
/* Tx buf allocation may fail sometimes, so sleep and retry. */
res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
if (res == _FAIL) {
msleep(10);
res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
if (res == _FAIL)
goto exit;
}
pxmitbuf->phead = pxmitbuf->pbuf;
pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMITBUF_SZ;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
pxmitbuf->flags = XMIT_VO_QUEUE;
list_add_tail(&pxmitbuf->list,
&pxmitpriv->free_xmitbuf_queue.queue);
#ifdef DBG_XMIT_BUF
pxmitbuf->no = i;
#endif
pxmitbuf++;
}
pxmitpriv->free_xmitbuf_cnt = NR_XMITBUFF;
/* init xframe_ext queue, the same count as extbuf */
INIT_LIST_HEAD(&pxmitpriv->free_xframe_ext_queue.queue);
spin_lock_init(&pxmitpriv->free_xframe_ext_queue.lock);
pxmitpriv->xframe_ext_alloc_addr = vzalloc(NR_XMIT_EXTBUFF * sizeof(struct xmit_frame) + 4);
if (!pxmitpriv->xframe_ext_alloc_addr) {
pxmitpriv->xframe_ext = NULL;
res = _FAIL;
goto exit;
}
pxmitpriv->xframe_ext = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->xframe_ext_alloc_addr), 4);
pxframe = (struct xmit_frame *)pxmitpriv->xframe_ext;
for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
INIT_LIST_HEAD(&pxframe->list);
pxframe->padapter = padapter;
pxframe->frame_tag = NULL_FRAMETAG;
pxframe->pkt = NULL;
pxframe->buf_addr = NULL;
pxframe->pxmitbuf = NULL;
pxframe->ext_tag = 1;
list_add_tail(&pxframe->list,
&pxmitpriv->free_xframe_ext_queue.queue);
pxframe++;
}
pxmitpriv->free_xframe_ext_cnt = NR_XMIT_EXTBUFF;
/* Init xmit extension buff */
INIT_LIST_HEAD(&pxmitpriv->free_xmit_extbuf_queue.queue);
spin_lock_init(&pxmitpriv->free_xmit_extbuf_queue.lock);
pxmitpriv->pallocated_xmit_extbuf = vzalloc(NR_XMIT_EXTBUFF * sizeof(struct xmit_buf) + 4);
if (!pxmitpriv->pallocated_xmit_extbuf) {
res = _FAIL;
goto exit;
}
pxmitpriv->pxmit_extbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitpriv->pallocated_xmit_extbuf), 4);
pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
INIT_LIST_HEAD(&pxmitbuf->list);
pxmitbuf->priv_data = NULL;
pxmitbuf->padapter = padapter;
pxmitbuf->buf_tag = XMITBUF_MGNT;
res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, MAX_XMIT_EXTBUF_SZ + XMITBUF_ALIGN_SZ, true);
if (res == _FAIL) {
res = _FAIL;
goto exit;
}
pxmitbuf->phead = pxmitbuf->pbuf;
pxmitbuf->pend = pxmitbuf->pbuf + MAX_XMIT_EXTBUF_SZ;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
list_add_tail(&pxmitbuf->list,
&pxmitpriv->free_xmit_extbuf_queue.queue);
#ifdef DBG_XMIT_BUF_EXT
pxmitbuf->no = i;
#endif
pxmitbuf++;
}
pxmitpriv->free_xmit_extbuf_cnt = NR_XMIT_EXTBUFF;
for (i = 0; i < CMDBUF_MAX; i++) {
pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i];
if (pxmitbuf) {
INIT_LIST_HEAD(&pxmitbuf->list);
pxmitbuf->priv_data = NULL;
pxmitbuf->padapter = padapter;
pxmitbuf->buf_tag = XMITBUF_CMD;
res = rtw_os_xmit_resource_alloc(padapter, pxmitbuf, MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ, true);
if (res == _FAIL) {
res = _FAIL;
goto exit;
}
pxmitbuf->phead = pxmitbuf->pbuf;
pxmitbuf->pend = pxmitbuf->pbuf + MAX_CMDBUF_SZ;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
pxmitbuf->alloc_sz = MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ;
}
}
res = rtw_alloc_hwxmits(padapter);
if (res == _FAIL)
goto exit;
rtw_init_hwxmits(pxmitpriv->hwxmits, pxmitpriv->hwxmit_entry);
for (i = 0; i < 4; i++)
pxmitpriv->wmm_para_seq[i] = i;
pxmitpriv->ack_tx = false;
mutex_init(&pxmitpriv->ack_tx_mutex);
rtw_sctx_init(&pxmitpriv->ack_tx_ops, 0);
rtw_hal_init_xmit_priv(padapter);
exit:
return res;
}
void _rtw_free_xmit_priv(struct xmit_priv *pxmitpriv)
{
int i;
struct adapter *padapter = pxmitpriv->adapter;
struct xmit_frame *pxmitframe = (struct xmit_frame *) pxmitpriv->pxmit_frame_buf;
struct xmit_buf *pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmitbuf;
rtw_hal_free_xmit_priv(padapter);
if (!pxmitpriv->pxmit_frame_buf)
return;
for (i = 0; i < NR_XMITFRAME; i++) {
rtw_os_xmit_complete(padapter, pxmitframe);
pxmitframe++;
}
for (i = 0; i < NR_XMITBUFF; i++) {
rtw_os_xmit_resource_free(padapter, pxmitbuf, (MAX_XMITBUF_SZ + XMITBUF_ALIGN_SZ), true);
pxmitbuf++;
}
vfree(pxmitpriv->pallocated_frame_buf);
vfree(pxmitpriv->pallocated_xmitbuf);
/* free xframe_ext queue, the same count as extbuf */
pxmitframe = (struct xmit_frame *)pxmitpriv->xframe_ext;
if (pxmitframe) {
for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
rtw_os_xmit_complete(padapter, pxmitframe);
pxmitframe++;
}
}
vfree(pxmitpriv->xframe_ext_alloc_addr);
/* free xmit extension buff */
pxmitbuf = (struct xmit_buf *)pxmitpriv->pxmit_extbuf;
for (i = 0; i < NR_XMIT_EXTBUFF; i++) {
rtw_os_xmit_resource_free(padapter, pxmitbuf, (MAX_XMIT_EXTBUF_SZ + XMITBUF_ALIGN_SZ), true);
pxmitbuf++;
}
vfree(pxmitpriv->pallocated_xmit_extbuf);
for (i = 0; i < CMDBUF_MAX; i++) {
pxmitbuf = &pxmitpriv->pcmd_xmitbuf[i];
if (pxmitbuf)
rtw_os_xmit_resource_free(padapter, pxmitbuf, MAX_CMDBUF_SZ+XMITBUF_ALIGN_SZ, true);
}
rtw_free_hwxmits(padapter);
mutex_destroy(&pxmitpriv->ack_tx_mutex);
}
u8 query_ra_short_GI(struct sta_info *psta)
{
u8 sgi = false, sgi_20m = false, sgi_40m = false;
sgi_20m = psta->htpriv.sgi_20m;
sgi_40m = psta->htpriv.sgi_40m;
switch (psta->bw_mode) {
case CHANNEL_WIDTH_40:
sgi = sgi_40m;
break;
case CHANNEL_WIDTH_20:
default:
sgi = sgi_20m;
break;
}
return sgi;
}
static void update_attrib_vcs_info(struct adapter *padapter, struct xmit_frame *pxmitframe)
{
u32 sz;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
/* struct sta_info *psta = pattrib->psta; */
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
if (pattrib->nr_frags != 1)
sz = padapter->xmitpriv.frag_len;
else /* no frag */
sz = pattrib->last_txcmdsz;
/* (1) RTS_Threshold is compared to the MPDU, not MSDU. */
/* (2) If there are more than one frag in this MSDU, only the first frag uses protection frame. */
/* Other fragments are protected by previous fragment. */
/* So we only need to check the length of first fragment. */
if (pmlmeext->cur_wireless_mode < WIRELESS_11_24N || padapter->registrypriv.wifi_spec) {
if (sz > padapter->registrypriv.rts_thresh) {
pattrib->vcs_mode = RTS_CTS;
} else {
if (pattrib->rtsen)
pattrib->vcs_mode = RTS_CTS;
else if (pattrib->cts2self)
pattrib->vcs_mode = CTS_TO_SELF;
else
pattrib->vcs_mode = NONE_VCS;
}
} else {
while (true) {
/* IOT action */
if ((pmlmeinfo->assoc_AP_vendor == HT_IOT_PEER_ATHEROS) && (pattrib->ampdu_en == true) &&
(padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)) {
pattrib->vcs_mode = CTS_TO_SELF;
break;
}
/* check ERP protection */
if (pattrib->rtsen || pattrib->cts2self) {
if (pattrib->rtsen)
pattrib->vcs_mode = RTS_CTS;
else if (pattrib->cts2self)
pattrib->vcs_mode = CTS_TO_SELF;
break;
}
/* check HT op mode */
if (pattrib->ht_en) {
u8 HTOpMode = pmlmeinfo->HT_protection;
if ((pmlmeext->cur_bwmode && (HTOpMode == 2 || HTOpMode == 3)) ||
(!pmlmeext->cur_bwmode && HTOpMode == 3)) {
pattrib->vcs_mode = RTS_CTS;
break;
}
}
/* check rts */
if (sz > padapter->registrypriv.rts_thresh) {
pattrib->vcs_mode = RTS_CTS;
break;
}
/* to do list: check MIMO power save condition. */
/* check AMPDU aggregation for TXOP */
if (pattrib->ampdu_en == true) {
pattrib->vcs_mode = RTS_CTS;
break;
}
pattrib->vcs_mode = NONE_VCS;
break;
}
}
/* for debug : force driver control vrtl_carrier_sense. */
if (padapter->driver_vcs_en == 1)
pattrib->vcs_mode = padapter->driver_vcs_type;
}
static void update_attrib_phy_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
{
struct mlme_ext_priv *mlmeext = &padapter->mlmeextpriv;
pattrib->rtsen = psta->rtsen;
pattrib->cts2self = psta->cts2self;
pattrib->mdata = 0;
pattrib->eosp = 0;
pattrib->triggered = 0;
pattrib->ampdu_spacing = 0;
/* qos_en, ht_en, init rate, , bw, ch_offset, sgi */
pattrib->qos_en = psta->qos_option;
pattrib->raid = psta->raid;
pattrib->bwmode = min(mlmeext->cur_bwmode, psta->bw_mode);
pattrib->sgi = query_ra_short_GI(psta);
pattrib->ldpc = psta->ldpc;
pattrib->stbc = psta->stbc;
pattrib->ht_en = psta->htpriv.ht_option;
pattrib->ch_offset = psta->htpriv.ch_offset;
pattrib->ampdu_en = false;
if (padapter->driver_ampdu_spacing != 0xFF) /* driver control AMPDU Density for peer sta's rx */
pattrib->ampdu_spacing = padapter->driver_ampdu_spacing;
else
pattrib->ampdu_spacing = psta->htpriv.rx_ampdu_min_spacing;
pattrib->retry_ctrl = false;
}
static s32 update_attrib_sec_info(struct adapter *padapter, struct pkt_attrib *pattrib, struct sta_info *psta)
{
signed int res = _SUCCESS;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
signed int bmcast = is_multicast_ether_addr(pattrib->ra);
memset(pattrib->dot118021x_UncstKey.skey, 0, 16);
memset(pattrib->dot11tkiptxmickey.skey, 0, 16);
pattrib->mac_id = psta->mac_id;
if (psta->ieee8021x_blocked == true) {
pattrib->encrypt = 0;
if ((pattrib->ether_type != 0x888e) && (check_fwstate(pmlmepriv, WIFI_MP_STATE) == false)) {
res = _FAIL;
goto exit;
}
} else {
GET_ENCRY_ALGO(psecuritypriv, psta, pattrib->encrypt, bmcast);
switch (psecuritypriv->dot11AuthAlgrthm) {
case dot11AuthAlgrthm_Open:
case dot11AuthAlgrthm_Shared:
case dot11AuthAlgrthm_Auto:
pattrib->key_idx = (u8)psecuritypriv->dot11PrivacyKeyIndex;
break;
case dot11AuthAlgrthm_8021X:
if (bmcast)
pattrib->key_idx = (u8)psecuritypriv->dot118021XGrpKeyid;
else
pattrib->key_idx = 0;
break;
default:
pattrib->key_idx = 0;
break;
}
/* For WPS 1.0 WEP, driver should not encrypt EAPOL Packet for WPS handshake. */
if (((pattrib->encrypt == _WEP40_) || (pattrib->encrypt == _WEP104_)) && (pattrib->ether_type == 0x888e))
pattrib->encrypt = _NO_PRIVACY_;
}
switch (pattrib->encrypt) {
case _WEP40_:
case _WEP104_:
pattrib->iv_len = 4;
pattrib->icv_len = 4;
WEP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
break;
case _TKIP_:
pattrib->iv_len = 8;
pattrib->icv_len = 4;
if (psecuritypriv->busetkipkey == _FAIL) {
res = _FAIL;
goto exit;
}
if (bmcast)
TKIP_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
else
TKIP_IV(pattrib->iv, psta->dot11txpn, 0);
memcpy(pattrib->dot11tkiptxmickey.skey, psta->dot11tkiptxmickey.skey, 16);
break;
case _AES_:
pattrib->iv_len = 8;
pattrib->icv_len = 8;
if (bmcast)
AES_IV(pattrib->iv, psta->dot11txpn, pattrib->key_idx);
else
AES_IV(pattrib->iv, psta->dot11txpn, 0);
break;
default:
pattrib->iv_len = 0;
pattrib->icv_len = 0;
break;
}
if (pattrib->encrypt > 0)
memcpy(pattrib->dot118021x_UncstKey.skey, psta->dot118021x_UncstKey.skey, 16);
if (pattrib->encrypt &&
((padapter->securitypriv.sw_encrypt) || (!psecuritypriv->hw_decrypted)))
pattrib->bswenc = true;
else
pattrib->bswenc = false;
exit:
return res;
}
u8 qos_acm(u8 acm_mask, u8 priority)
{
switch (priority) {
case 0:
case 3:
if (acm_mask & BIT(1))
priority = 1;
break;
case 1:
case 2:
break;
case 4:
case 5:
if (acm_mask & BIT(2))
priority = 0;
break;
case 6:
case 7:
if (acm_mask & BIT(3))
priority = 5;
break;
default:
break;
}
return priority;
}
static void set_qos(struct pkt_file *ppktfile, struct pkt_attrib *pattrib)
{
struct ethhdr etherhdr;
struct iphdr ip_hdr;
s32 UserPriority = 0;
_rtw_open_pktfile(ppktfile->pkt, ppktfile);
_rtw_pktfile_read(ppktfile, (unsigned char *)ðerhdr, ETH_HLEN);
/* get UserPriority from IP hdr */
if (pattrib->ether_type == 0x0800) {
_rtw_pktfile_read(ppktfile, (u8 *)&ip_hdr, sizeof(ip_hdr));
UserPriority = ip_hdr.tos >> 5;
}
pattrib->priority = UserPriority;
pattrib->hdrlen = WLAN_HDR_A3_QOS_LEN;
pattrib->subtype = WIFI_QOS_DATA_TYPE;
}
static s32 update_attrib(struct adapter *padapter, struct sk_buff *pkt, struct pkt_attrib *pattrib)
{
struct pkt_file pktfile;
struct sta_info *psta = NULL;
struct ethhdr etherhdr;
signed int bmcast;
struct sta_priv *pstapriv = &padapter->stapriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
signed int res = _SUCCESS;
_rtw_open_pktfile(pkt, &pktfile);
_rtw_pktfile_read(&pktfile, (u8 *)ðerhdr, ETH_HLEN);
pattrib->ether_type = ntohs(etherhdr.h_proto);
memcpy(pattrib->dst, ðerhdr.h_dest, ETH_ALEN);
memcpy(pattrib->src, ðerhdr.h_source, ETH_ALEN);
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) {
memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
} else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
memcpy(pattrib->ra, get_bssid(pmlmepriv), ETH_ALEN);
memcpy(pattrib->ta, pattrib->src, ETH_ALEN);
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
memcpy(pattrib->ra, pattrib->dst, ETH_ALEN);
memcpy(pattrib->ta, get_bssid(pmlmepriv), ETH_ALEN);
}
pattrib->pktlen = pktfile.pkt_len;
if (pattrib->ether_type == ETH_P_IP) {
/* The following is for DHCP and ARP packet, we use cck1M to tx these packets and let LPS awake some time */
/* to prevent DHCP protocol fail */
u8 tmp[24];
_rtw_pktfile_read(&pktfile, &tmp[0], 24);
pattrib->dhcp_pkt = 0;
if (pktfile.pkt_len > 282) {/* MINIMUM_DHCP_PACKET_SIZE) { */
if (pattrib->ether_type == ETH_P_IP) {/* IP header */
if (((tmp[21] == 68) && (tmp[23] == 67)) ||
((tmp[21] == 67) && (tmp[23] == 68))) {
/* 68 : UDP BOOTP client */
/* 67 : UDP BOOTP server */
pattrib->dhcp_pkt = 1;
}
}
}
/* for parsing ICMP pakcets */
{
struct iphdr *piphdr = (struct iphdr *)tmp;
pattrib->icmp_pkt = 0;
if (piphdr->protocol == 0x1) /* protocol type in ip header 0x1 is ICMP */
pattrib->icmp_pkt = 1;
}
} else if (pattrib->ether_type == 0x888e) {
netdev_dbg(padapter->pnetdev, "send eapol packet\n");
}
if ((pattrib->ether_type == 0x888e) || (pattrib->dhcp_pkt == 1))
rtw_set_scan_deny(padapter, 3000);
/* If EAPOL , ARP , OR DHCP packet, driver must be in active mode. */
if (pattrib->icmp_pkt == 1)
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_LEAVE, 1);
else if (pattrib->dhcp_pkt == 1)
rtw_lps_ctrl_wk_cmd(padapter, LPS_CTRL_SPECIAL_PACKET, 1);
bmcast = is_multicast_ether_addr(pattrib->ra);
/* get sta_info */
if (bmcast) {
psta = rtw_get_bcmc_stainfo(padapter);
} else {
psta = rtw_get_stainfo(pstapriv, pattrib->ra);
if (!psta) { /* if we cannot get psta => drop the pkt */
res = _FAIL;
goto exit;
} else if ((check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) && (!(psta->state & _FW_LINKED))) {
res = _FAIL;
goto exit;
}
}
if (!psta) {
/* if we cannot get psta => drop the pkt */
res = _FAIL;
goto exit;
}
if (!(psta->state & _FW_LINKED))
return _FAIL;
/* TODO:_lock */
if (update_attrib_sec_info(padapter, pattrib, psta) == _FAIL) {
res = _FAIL;
goto exit;
}
update_attrib_phy_info(padapter, pattrib, psta);
pattrib->psta = psta;
/* TODO:_unlock */
pattrib->pctrl = 0;
pattrib->ack_policy = 0;
/* get ether_hdr_len */
pattrib->pkt_hdrlen = ETH_HLEN;/* pattrib->ether_type == 0x8100) ? (14 + 4): 14; vlan tag */
pattrib->hdrlen = WLAN_HDR_A3_LEN;
pattrib->subtype = WIFI_DATA_TYPE;
pattrib->priority = 0;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE|WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE)) {
if (pattrib->qos_en)
set_qos(&pktfile, pattrib);
} else {
if (pqospriv->qos_option) {
set_qos(&pktfile, pattrib);
if (pmlmepriv->acm_mask != 0)
pattrib->priority = qos_acm(pmlmepriv->acm_mask, pattrib->priority);
}
}
/* pattrib->priority = 5; force to used VI queue, for testing */
exit:
return res;
}
static s32 xmitframe_addmic(struct adapter *padapter, struct xmit_frame *pxmitframe)
{
signed int curfragnum, length;
u8 *pframe, *payload, mic[8];
struct mic_data micdata;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
u8 priority[4] = {0x0, 0x0, 0x0, 0x0};
u8 hw_hdr_offset = 0;
signed int bmcst = is_multicast_ether_addr(pattrib->ra);
hw_hdr_offset = TXDESC_OFFSET;
if (pattrib->encrypt == _TKIP_) {
/* encode mic code */
{
u8 null_key[16] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
pframe = pxmitframe->buf_addr + hw_hdr_offset;
if (bmcst) {
if (!memcmp(psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey, null_key, 16))
return _FAIL;
/* start to calculate the mic code */
rtw_secmicsetkey(&micdata, psecuritypriv->dot118021XGrptxmickey[psecuritypriv->dot118021XGrpKeyid].skey);
} else {
if (!memcmp(&pattrib->dot11tkiptxmickey.skey[0], null_key, 16))
return _FAIL;
/* start to calculate the mic code */
rtw_secmicsetkey(&micdata, &pattrib->dot11tkiptxmickey.skey[0]);
}
if (pframe[1]&1) { /* ToDS == 1 */
rtw_secmicappend(&micdata, &pframe[16], 6); /* DA */
if (pframe[1]&2) /* From Ds == 1 */
rtw_secmicappend(&micdata, &pframe[24], 6);
else
rtw_secmicappend(&micdata, &pframe[10], 6);
} else { /* ToDS == 0 */
rtw_secmicappend(&micdata, &pframe[4], 6); /* DA */
if (pframe[1]&2) /* From Ds == 1 */
rtw_secmicappend(&micdata, &pframe[16], 6);
else
rtw_secmicappend(&micdata, &pframe[10], 6);
}
if (pattrib->qos_en)
priority[0] = (u8)pxmitframe->attrib.priority;
rtw_secmicappend(&micdata, &priority[0], 4);
payload = pframe;
for (curfragnum = 0; curfragnum < pattrib->nr_frags; curfragnum++) {
payload = (u8 *)round_up((SIZE_PTR)(payload), 4);
payload = payload+pattrib->hdrlen+pattrib->iv_len;
if ((curfragnum+1) == pattrib->nr_frags) {
length = pattrib->last_txcmdsz-pattrib->hdrlen-pattrib->iv_len-((pattrib->bswenc) ? pattrib->icv_len : 0);
rtw_secmicappend(&micdata, payload, length);
payload = payload+length;
} else {
length = pxmitpriv->frag_len-pattrib->hdrlen-pattrib->iv_len-((pattrib->bswenc) ? pattrib->icv_len : 0);
rtw_secmicappend(&micdata, payload, length);
payload = payload+length+pattrib->icv_len;
}
}
rtw_secgetmic(&micdata, &mic[0]);
/* add mic code and add the mic code length in last_txcmdsz */
memcpy(payload, &mic[0], 8);
pattrib->last_txcmdsz += 8;
}
}
return _SUCCESS;
}
static s32 xmitframe_swencrypt(struct adapter *padapter, struct xmit_frame *pxmitframe)
{
struct pkt_attrib *pattrib = &pxmitframe->attrib;
if (pattrib->bswenc) {
switch (pattrib->encrypt) {
case _WEP40_:
case _WEP104_:
rtw_wep_encrypt(padapter, (u8 *)pxmitframe);
break;
case _TKIP_:
rtw_tkip_encrypt(padapter, (u8 *)pxmitframe);
break;
case _AES_:
rtw_aes_encrypt(padapter, (u8 *)pxmitframe);
break;
default:
break;
}
}
return _SUCCESS;
}
s32 rtw_make_wlanhdr(struct adapter *padapter, u8 *hdr, struct pkt_attrib *pattrib)
{
u16 *qc;
struct ieee80211_hdr *pwlanhdr = (struct ieee80211_hdr *)hdr;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct qos_priv *pqospriv = &pmlmepriv->qospriv;
u8 qos_option = false;
signed int res = _SUCCESS;
__le16 *fctrl = &pwlanhdr->frame_control;
memset(hdr, 0, WLANHDR_OFFSET);
SetFrameSubType(fctrl, pattrib->subtype);
if (pattrib->subtype & WIFI_DATA_TYPE) {
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
/* to_ds = 1, fr_ds = 0; */
{
/* 1.Data transfer to AP */
/* 2.Arp pkt will relayed by AP */
SetToDs(fctrl);
memcpy(pwlanhdr->addr1, get_bssid(pmlmepriv), ETH_ALEN);
memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
memcpy(pwlanhdr->addr3, pattrib->dst, ETH_ALEN);
}
if (pqospriv->qos_option)
qos_option = true;
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
/* to_ds = 0, fr_ds = 1; */
SetFrDs(fctrl);
memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
memcpy(pwlanhdr->addr2, get_bssid(pmlmepriv), ETH_ALEN);
memcpy(pwlanhdr->addr3, pattrib->src, ETH_ALEN);
if (pattrib->qos_en)
qos_option = true;
} else if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true)) {
memcpy(pwlanhdr->addr1, pattrib->dst, ETH_ALEN);
memcpy(pwlanhdr->addr2, pattrib->src, ETH_ALEN);
memcpy(pwlanhdr->addr3, get_bssid(pmlmepriv), ETH_ALEN);
if (pattrib->qos_en)
qos_option = true;
} else {
res = _FAIL;
goto exit;
}
if (pattrib->mdata)
SetMData(fctrl);
if (pattrib->encrypt)
SetPrivacy(fctrl);
if (qos_option) {
qc = (unsigned short *)(hdr + pattrib->hdrlen - 2);
if (pattrib->priority)
SetPriority(qc, pattrib->priority);
SetEOSP(qc, pattrib->eosp);
SetAckpolicy(qc, pattrib->ack_policy);
}
/* TODO: fill HT Control Field */
/* Update Seq Num will be handled by f/w */
{
struct sta_info *psta;
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (pattrib->psta != psta)
return _FAIL;
if (!psta)
return _FAIL;
if (!(psta->state & _FW_LINKED))
return _FAIL;
if (psta) {
psta->sta_xmitpriv.txseq_tid[pattrib->priority]++;
psta->sta_xmitpriv.txseq_tid[pattrib->priority] &= 0xFFF;
pattrib->seqnum = psta->sta_xmitpriv.txseq_tid[pattrib->priority];
SetSeqNum(hdr, pattrib->seqnum);
/* check if enable ampdu */
if (pattrib->ht_en && psta->htpriv.ampdu_enable)
if (psta->htpriv.agg_enable_bitmap & BIT(pattrib->priority))
pattrib->ampdu_en = true;
/* re-check if enable ampdu by BA_starting_seqctrl */
if (pattrib->ampdu_en == true) {
u16 tx_seq;
tx_seq = psta->BA_starting_seqctrl[pattrib->priority & 0x0f];
/* check BA_starting_seqctrl */
if (SN_LESS(pattrib->seqnum, tx_seq)) {
pattrib->ampdu_en = false;/* AGG BK */
} else if (SN_EQUAL(pattrib->seqnum, tx_seq)) {
psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (tx_seq+1)&0xfff;
pattrib->ampdu_en = true;/* AGG EN */
} else {
psta->BA_starting_seqctrl[pattrib->priority & 0x0f] = (pattrib->seqnum+1)&0xfff;
pattrib->ampdu_en = true;/* AGG EN */
}
}
}
}
} else {
}
exit:
return res;
}
s32 rtw_txframes_pending(struct adapter *padapter)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
return ((!list_empty(&pxmitpriv->be_pending.queue)) ||
(!list_empty(&pxmitpriv->bk_pending.queue)) ||
(!list_empty(&pxmitpriv->vi_pending.queue)) ||
(!list_empty(&pxmitpriv->vo_pending.queue)));
}
/*
* Calculate wlan 802.11 packet MAX size from pkt_attrib
* This function doesn't consider fragment case
*/
u32 rtw_calculate_wlan_pkt_size_by_attribue(struct pkt_attrib *pattrib)
{
u32 len = 0;
len = pattrib->hdrlen + pattrib->iv_len; /* WLAN Header and IV */
len += SNAP_SIZE + sizeof(u16); /* LLC */
len += pattrib->pktlen;
if (pattrib->encrypt == _TKIP_)
len += 8; /* MIC */
len += ((pattrib->bswenc) ? pattrib->icv_len : 0); /* ICV */
return len;
}
/*
* This sub-routine will perform all the following:
* 1. remove 802.3 header.
* 2. create wlan_header, based on the info in pxmitframe
* 3. append sta's iv/ext-iv
* 4. append LLC
* 5. move frag chunk from pframe to pxmitframe->mem
* 6. apply sw-encrypt, if necessary.
*/
s32 rtw_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
{
struct pkt_file pktfile;
s32 frg_inx, frg_len, mpdu_len, llc_sz, mem_sz;
SIZE_PTR addr;
u8 *pframe, *mem_start;
u8 hw_hdr_offset;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
u8 *pbuf_start;
s32 bmcst = is_multicast_ether_addr(pattrib->ra);
s32 res = _SUCCESS;
if (!pxmitframe->buf_addr)
return _FAIL;
pbuf_start = pxmitframe->buf_addr;
hw_hdr_offset = TXDESC_OFFSET;
mem_start = pbuf_start + hw_hdr_offset;
if (rtw_make_wlanhdr(padapter, mem_start, pattrib) == _FAIL) {
res = _FAIL;
goto exit;
}
_rtw_open_pktfile(pkt, &pktfile);
_rtw_pktfile_read(&pktfile, NULL, pattrib->pkt_hdrlen);
frg_inx = 0;
frg_len = pxmitpriv->frag_len - 4;/* 2346-4 = 2342 */
while (1) {
llc_sz = 0;
mpdu_len = frg_len;
pframe = mem_start;
SetMFrag(mem_start);
pframe += pattrib->hdrlen;
mpdu_len -= pattrib->hdrlen;
/* adding icv, if necessary... */
if (pattrib->iv_len) {
memcpy(pframe, pattrib->iv, pattrib->iv_len);
pframe += pattrib->iv_len;
mpdu_len -= pattrib->iv_len;
}
if (frg_inx == 0) {
llc_sz = rtw_put_snap(pframe, pattrib->ether_type);
pframe += llc_sz;
mpdu_len -= llc_sz;
}
if ((pattrib->icv_len > 0) && (pattrib->bswenc))
mpdu_len -= pattrib->icv_len;
if (bmcst) {
/* don't do fragment to broadcast/multicast packets */
mem_sz = _rtw_pktfile_read(&pktfile, pframe, pattrib->pktlen);
} else {
mem_sz = _rtw_pktfile_read(&pktfile, pframe, mpdu_len);
}
pframe += mem_sz;
if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
memcpy(pframe, pattrib->icv, pattrib->icv_len);
pframe += pattrib->icv_len;
}
frg_inx++;
if (bmcst || (rtw_endofpktfile(&pktfile) == true)) {
pattrib->nr_frags = frg_inx;
pattrib->last_txcmdsz = pattrib->hdrlen + pattrib->iv_len + ((pattrib->nr_frags == 1) ? llc_sz:0) +
((pattrib->bswenc) ? pattrib->icv_len : 0) + mem_sz;
ClearMFrag(mem_start);
break;
}
addr = (SIZE_PTR)(pframe);
mem_start = (unsigned char *)round_up(addr, 4) + hw_hdr_offset;
memcpy(mem_start, pbuf_start + hw_hdr_offset, pattrib->hdrlen);
}
if (xmitframe_addmic(padapter, pxmitframe) == _FAIL) {
res = _FAIL;
goto exit;
}
xmitframe_swencrypt(padapter, pxmitframe);
if (bmcst == false)
update_attrib_vcs_info(padapter, pxmitframe);
else
pattrib->vcs_mode = NONE_VCS;
exit:
return res;
}
/* broadcast or multicast management pkt use BIP, unicast management pkt use CCMP encryption */
s32 rtw_mgmt_xmitframe_coalesce(struct adapter *padapter, struct sk_buff *pkt, struct xmit_frame *pxmitframe)
{
u8 *pframe, *mem_start = NULL, *tmp_buf = NULL;
u8 subtype;
struct sta_info *psta = NULL;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
s32 bmcst = is_multicast_ether_addr(pattrib->ra);
u8 *BIP_AAD = NULL;
u8 *MGMT_body = NULL;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ieee80211_hdr *pwlanhdr;
u8 MME[_MME_IE_LENGTH_];
u32 ori_len;
mem_start = pframe = (u8 *)(pxmitframe->buf_addr) + TXDESC_OFFSET;
pwlanhdr = (struct ieee80211_hdr *)pframe;
ori_len = BIP_AAD_SIZE+pattrib->pktlen;
tmp_buf = BIP_AAD = rtw_zmalloc(ori_len);
subtype = GetFrameSubType(pframe); /* bit(7)~bit(2) */
if (!BIP_AAD)
return _FAIL;
spin_lock_bh(&padapter->security_key_mutex);
/* only support station mode */
if (!check_fwstate(pmlmepriv, WIFI_STATION_STATE) || !check_fwstate(pmlmepriv, _FW_LINKED))
goto xmitframe_coalesce_success;
/* IGTK key is not install, it may not support 802.11w */
if (!padapter->securitypriv.binstallBIPkey)
goto xmitframe_coalesce_success;
/* station mode doesn't need TX BIP, just ready the code */
if (bmcst) {
int frame_body_len;
u8 mic[16];
memset(MME, 0, 18);
/* other types doesn't need the BIP */
if (GetFrameSubType(pframe) != WIFI_DEAUTH && GetFrameSubType(pframe) != WIFI_DISASSOC)
goto xmitframe_coalesce_fail;
MGMT_body = pframe + sizeof(struct ieee80211_hdr_3addr);
pframe += pattrib->pktlen;
/* octent 0 and 1 is key index , BIP keyid is 4 or 5, LSB only need octent 0 */
MME[0] = padapter->securitypriv.dot11wBIPKeyid;
/* copy packet number */
memcpy(&MME[2], &pmlmeext->mgnt_80211w_IPN, 6);
/* increase the packet number */
pmlmeext->mgnt_80211w_IPN++;
/* add MME IE with MIC all zero, MME string doesn't include element id and length */
pframe = rtw_set_ie(pframe, WLAN_EID_MMIE, 16,
MME, &pattrib->pktlen);
pattrib->last_txcmdsz = pattrib->pktlen;
/* total frame length - header length */
frame_body_len = pattrib->pktlen - sizeof(struct ieee80211_hdr_3addr);
/* conscruct AAD, copy frame control field */
memcpy(BIP_AAD, &pwlanhdr->frame_control, 2);
ClearRetry(BIP_AAD);
ClearPwrMgt(BIP_AAD);
ClearMData(BIP_AAD);
/* conscruct AAD, copy address 1 to address 3 */
memcpy(BIP_AAD+2, pwlanhdr->addr1, 18);
/* copy management fram body */
memcpy(BIP_AAD+BIP_AAD_SIZE, MGMT_body, frame_body_len);
/* calculate mic */
if (omac1_aes_128(padapter->securitypriv.dot11wBIPKey[padapter->securitypriv.dot11wBIPKeyid].skey
, BIP_AAD, BIP_AAD_SIZE+frame_body_len, mic))
goto xmitframe_coalesce_fail;
/* copy right BIP mic value, total is 128bits, we use the 0~63 bits */
memcpy(pframe-8, mic, 8);
} else { /* unicast mgmt frame TX */
/* start to encrypt mgmt frame */
if (subtype == WIFI_DEAUTH || subtype == WIFI_DISASSOC ||
subtype == WIFI_REASSOCREQ || subtype == WIFI_ACTION) {
if (pattrib->psta)
psta = pattrib->psta;
else
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (!psta)
goto xmitframe_coalesce_fail;
if (!(psta->state & _FW_LINKED) || !pxmitframe->buf_addr)
goto xmitframe_coalesce_fail;
/* according 802.11-2012 standard, these five types are not robust types */
if (subtype == WIFI_ACTION &&
(pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_PUBLIC ||
pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_HT ||
pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_UNPROTECTED_WNM ||
pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_SELF_PROTECTED ||
pframe[WLAN_HDR_A3_LEN] == RTW_WLAN_CATEGORY_P2P))
goto xmitframe_coalesce_fail;
/* before encrypt dump the management packet content */
if (pattrib->encrypt > 0)
memcpy(pattrib->dot118021x_UncstKey.skey, psta->dot118021x_UncstKey.skey, 16);
/* bakeup original management packet */
memcpy(tmp_buf, pframe, pattrib->pktlen);
/* move to data portion */
pframe += pattrib->hdrlen;
/* 802.11w unicast management packet must be _AES_ */
pattrib->iv_len = 8;
/* it's MIC of AES */
pattrib->icv_len = 8;
switch (pattrib->encrypt) {
case _AES_:
/* set AES IV header */
AES_IV(pattrib->iv, psta->dot11wtxpn, 0);
break;
default:
goto xmitframe_coalesce_fail;
}
/* insert iv header into management frame */
memcpy(pframe, pattrib->iv, pattrib->iv_len);
pframe += pattrib->iv_len;
/* copy mgmt data portion after CCMP header */
memcpy(pframe, tmp_buf+pattrib->hdrlen, pattrib->pktlen-pattrib->hdrlen);
/* move pframe to end of mgmt pkt */
pframe += pattrib->pktlen-pattrib->hdrlen;
/* add 8 bytes CCMP IV header to length */
pattrib->pktlen += pattrib->iv_len;
if ((pattrib->icv_len > 0) && (pattrib->bswenc)) {
memcpy(pframe, pattrib->icv, pattrib->icv_len);
pframe += pattrib->icv_len;
}
/* add 8 bytes MIC */
pattrib->pktlen += pattrib->icv_len;
/* set final tx command size */
pattrib->last_txcmdsz = pattrib->pktlen;
/* set protected bit must be beofre SW encrypt */
SetPrivacy(mem_start);
/* software encrypt */
xmitframe_swencrypt(padapter, pxmitframe);
}
}
xmitframe_coalesce_success:
spin_unlock_bh(&padapter->security_key_mutex);
kfree(BIP_AAD);
return _SUCCESS;
xmitframe_coalesce_fail:
spin_unlock_bh(&padapter->security_key_mutex);
kfree(BIP_AAD);
return _FAIL;
}
/* Logical Link Control(LLC) SubNetwork Attachment Point(SNAP) header
* IEEE LLC/SNAP header contains 8 octets
* First 3 octets comprise the LLC portion
* SNAP portion, 5 octets, is divided into two fields:
*Organizationally Unique Identifier(OUI), 3 octets,
*type, defined by that organization, 2 octets.
*/
s32 rtw_put_snap(u8 *data, u16 h_proto)
{
struct ieee80211_snap_hdr *snap;
u8 *oui;
snap = (struct ieee80211_snap_hdr *)data;
snap->dsap = 0xaa;
snap->ssap = 0xaa;
snap->ctrl = 0x03;
if (h_proto == 0x8137 || h_proto == 0x80f3)
oui = P802_1H_OUI;
else
oui = RFC1042_OUI;
snap->oui[0] = oui[0];
snap->oui[1] = oui[1];
snap->oui[2] = oui[2];
*(__be16 *)(data + SNAP_SIZE) = htons(h_proto);
return SNAP_SIZE + sizeof(u16);
}
void rtw_update_protection(struct adapter *padapter, u8 *ie, uint ie_len)
{
uint protection;
u8 *perp;
signed int erp_len;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct registry_priv *pregistrypriv = &padapter->registrypriv;
switch (pxmitpriv->vcs_setting) {
case DISABLE_VCS:
pxmitpriv->vcs = NONE_VCS;
break;
case ENABLE_VCS:
break;
case AUTO_VCS:
default:
perp = rtw_get_ie(ie, WLAN_EID_ERP_INFO, &erp_len, ie_len);
if (!perp) {
pxmitpriv->vcs = NONE_VCS;
} else {
protection = (*(perp + 2)) & BIT(1);
if (protection) {
if (pregistrypriv->vcs_type == RTS_CTS)
pxmitpriv->vcs = RTS_CTS;
else
pxmitpriv->vcs = CTS_TO_SELF;
} else {
pxmitpriv->vcs = NONE_VCS;
}
}
break;
}
}
void rtw_count_tx_stats(struct adapter *padapter, struct xmit_frame *pxmitframe, int sz)
{
struct sta_info *psta = NULL;
struct stainfo_stats *pstats = NULL;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
u8 pkt_num = 1;
if ((pxmitframe->frame_tag&0x0f) == DATA_FRAMETAG) {
pkt_num = pxmitframe->agg_num;
pmlmepriv->LinkDetectInfo.NumTxOkInPeriod += pkt_num;
pxmitpriv->tx_pkts += pkt_num;
pxmitpriv->tx_bytes += sz;
psta = pxmitframe->attrib.psta;
if (psta) {
pstats = &psta->sta_stats;
pstats->tx_pkts += pkt_num;
pstats->tx_bytes += sz;
}
}
}
static struct xmit_buf *__rtw_alloc_cmd_xmitbuf(struct xmit_priv *pxmitpriv,
enum cmdbuf_type buf_type)
{
struct xmit_buf *pxmitbuf = NULL;
pxmitbuf = &pxmitpriv->pcmd_xmitbuf[buf_type];
if (pxmitbuf) {
pxmitbuf->priv_data = NULL;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
pxmitbuf->agg_num = 0;
pxmitbuf->pg_num = 0;
if (pxmitbuf->sctx)
rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
}
return pxmitbuf;
}
struct xmit_frame *__rtw_alloc_cmdxmitframe(struct xmit_priv *pxmitpriv,
enum cmdbuf_type buf_type)
{
struct xmit_frame *pcmdframe;
struct xmit_buf *pxmitbuf;
pcmdframe = rtw_alloc_xmitframe(pxmitpriv);
if (!pcmdframe)
return NULL;
pxmitbuf = __rtw_alloc_cmd_xmitbuf(pxmitpriv, buf_type);
if (!pxmitbuf) {
rtw_free_xmitframe(pxmitpriv, pcmdframe);
return NULL;
}
pcmdframe->frame_tag = MGNT_FRAMETAG;
pcmdframe->pxmitbuf = pxmitbuf;
pcmdframe->buf_addr = pxmitbuf->pbuf;
pxmitbuf->priv_data = pcmdframe;
return pcmdframe;
}
struct xmit_buf *rtw_alloc_xmitbuf_ext(struct xmit_priv *pxmitpriv)
{
unsigned long irqL;
struct xmit_buf *pxmitbuf = NULL;
struct list_head *plist, *phead;
struct __queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
spin_lock_irqsave(&pfree_queue->lock, irqL);
if (list_empty(&pfree_queue->queue)) {
pxmitbuf = NULL;
} else {
phead = get_list_head(pfree_queue);
plist = get_next(phead);
pxmitbuf = container_of(plist, struct xmit_buf, list);
list_del_init(&pxmitbuf->list);
}
if (pxmitbuf) {
pxmitpriv->free_xmit_extbuf_cnt--;
pxmitbuf->priv_data = NULL;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
pxmitbuf->agg_num = 1;
if (pxmitbuf->sctx)
rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
}
spin_unlock_irqrestore(&pfree_queue->lock, irqL);
return pxmitbuf;
}
s32 rtw_free_xmitbuf_ext(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{
unsigned long irqL;
struct __queue *pfree_queue = &pxmitpriv->free_xmit_extbuf_queue;
if (!pxmitbuf)
return _FAIL;
spin_lock_irqsave(&pfree_queue->lock, irqL);
list_del_init(&pxmitbuf->list);
list_add_tail(&pxmitbuf->list, get_list_head(pfree_queue));
pxmitpriv->free_xmit_extbuf_cnt++;
spin_unlock_irqrestore(&pfree_queue->lock, irqL);
return _SUCCESS;
}
struct xmit_buf *rtw_alloc_xmitbuf(struct xmit_priv *pxmitpriv)
{
unsigned long irqL;
struct xmit_buf *pxmitbuf = NULL;
struct list_head *plist, *phead;
struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL);
if (list_empty(&pfree_xmitbuf_queue->queue)) {
pxmitbuf = NULL;
} else {
phead = get_list_head(pfree_xmitbuf_queue);
plist = get_next(phead);
pxmitbuf = container_of(plist, struct xmit_buf, list);
list_del_init(&pxmitbuf->list);
}
if (pxmitbuf) {
pxmitpriv->free_xmitbuf_cnt--;
pxmitbuf->priv_data = NULL;
pxmitbuf->len = 0;
pxmitbuf->pdata = pxmitbuf->ptail = pxmitbuf->phead;
pxmitbuf->agg_num = 0;
pxmitbuf->pg_num = 0;
if (pxmitbuf->sctx)
rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_ALLOC);
}
spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL);
return pxmitbuf;
}
s32 rtw_free_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{
unsigned long irqL;
struct __queue *pfree_xmitbuf_queue = &pxmitpriv->free_xmitbuf_queue;
if (!pxmitbuf)
return _FAIL;
if (pxmitbuf->sctx)
rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_BUF_FREE);
if (pxmitbuf->buf_tag == XMITBUF_CMD) {
} else if (pxmitbuf->buf_tag == XMITBUF_MGNT) {
rtw_free_xmitbuf_ext(pxmitpriv, pxmitbuf);
} else {
spin_lock_irqsave(&pfree_xmitbuf_queue->lock, irqL);
list_del_init(&pxmitbuf->list);
list_add_tail(&pxmitbuf->list,
get_list_head(pfree_xmitbuf_queue));
pxmitpriv->free_xmitbuf_cnt++;
spin_unlock_irqrestore(&pfree_xmitbuf_queue->lock, irqL);
}
return _SUCCESS;
}
static void rtw_init_xmitframe(struct xmit_frame *pxframe)
{
if (pxframe) { /* default value setting */
pxframe->buf_addr = NULL;
pxframe->pxmitbuf = NULL;
memset(&pxframe->attrib, 0, sizeof(struct pkt_attrib));
pxframe->frame_tag = DATA_FRAMETAG;
pxframe->pg_num = 1;
pxframe->agg_num = 1;
pxframe->ack_report = 0;
}
}
/*
* Calling context:
* 1. OS_TXENTRY
* 2. RXENTRY (rx_thread or RX_ISR/RX_CallBack)
*
* If we turn on USE_RXTHREAD, then, no need for critical section.
* Otherwise, we must use _enter/_exit critical to protect free_xmit_queue...
*
* Must be very, very cautious...
*/
struct xmit_frame *rtw_alloc_xmitframe(struct xmit_priv *pxmitpriv)/* _queue *pfree_xmit_queue) */
{
/*
* Please remember to use all the osdep_service api,
* and lock/unlock or _enter/_exit critical to protect
* pfree_xmit_queue
*/
struct xmit_frame *pxframe = NULL;
struct list_head *plist, *phead;
struct __queue *pfree_xmit_queue = &pxmitpriv->free_xmit_queue;
spin_lock_bh(&pfree_xmit_queue->lock);
if (list_empty(&pfree_xmit_queue->queue)) {
pxframe = NULL;
} else {
phead = get_list_head(pfree_xmit_queue);
plist = get_next(phead);
pxframe = container_of(plist, struct xmit_frame, list);
list_del_init(&pxframe->list);
pxmitpriv->free_xmitframe_cnt--;
}
spin_unlock_bh(&pfree_xmit_queue->lock);
rtw_init_xmitframe(pxframe);
return pxframe;
}
struct xmit_frame *rtw_alloc_xmitframe_ext(struct xmit_priv *pxmitpriv)
{
struct xmit_frame *pxframe = NULL;
struct list_head *plist, *phead;
struct __queue *queue = &pxmitpriv->free_xframe_ext_queue;
spin_lock_bh(&queue->lock);
if (list_empty(&queue->queue)) {
pxframe = NULL;
} else {
phead = get_list_head(queue);
plist = get_next(phead);
pxframe = container_of(plist, struct xmit_frame, list);
list_del_init(&pxframe->list);
pxmitpriv->free_xframe_ext_cnt--;
}
spin_unlock_bh(&queue->lock);
rtw_init_xmitframe(pxframe);
return pxframe;
}
struct xmit_frame *rtw_alloc_xmitframe_once(struct xmit_priv *pxmitpriv)
{
struct xmit_frame *pxframe = NULL;
u8 *alloc_addr;
alloc_addr = rtw_zmalloc(sizeof(struct xmit_frame) + 4);
if (!alloc_addr)
goto exit;
pxframe = (struct xmit_frame *)N_BYTE_ALIGMENT((SIZE_PTR)(alloc_addr), 4);
pxframe->alloc_addr = alloc_addr;
pxframe->padapter = pxmitpriv->adapter;
pxframe->frame_tag = NULL_FRAMETAG;
pxframe->pkt = NULL;
pxframe->buf_addr = NULL;
pxframe->pxmitbuf = NULL;
rtw_init_xmitframe(pxframe);
exit:
return pxframe;
}
s32 rtw_free_xmitframe(struct xmit_priv *pxmitpriv, struct xmit_frame *pxmitframe)
{
struct __queue *queue = NULL;
struct adapter *padapter = pxmitpriv->adapter;
struct sk_buff *pndis_pkt = NULL;
if (!pxmitframe)
goto exit;
if (pxmitframe->pkt) {
pndis_pkt = pxmitframe->pkt;
pxmitframe->pkt = NULL;
}
if (pxmitframe->alloc_addr) {
kfree(pxmitframe->alloc_addr);
goto check_pkt_complete;
}
if (pxmitframe->ext_tag == 0)
queue = &pxmitpriv->free_xmit_queue;
else if (pxmitframe->ext_tag == 1)
queue = &pxmitpriv->free_xframe_ext_queue;
else {
}
spin_lock_bh(&queue->lock);
list_del_init(&pxmitframe->list);
list_add_tail(&pxmitframe->list, get_list_head(queue));
if (pxmitframe->ext_tag == 0)
pxmitpriv->free_xmitframe_cnt++;
else if (pxmitframe->ext_tag == 1)
pxmitpriv->free_xframe_ext_cnt++;
spin_unlock_bh(&queue->lock);
check_pkt_complete:
if (pndis_pkt)
rtw_os_pkt_complete(padapter, pndis_pkt);
exit:
return _SUCCESS;
}
void rtw_free_xmitframe_queue(struct xmit_priv *pxmitpriv, struct __queue *pframequeue)
{
struct list_head *plist, *phead, *tmp;
struct xmit_frame *pxmitframe;
spin_lock_bh(&pframequeue->lock);
phead = get_list_head(pframequeue);
list_for_each_safe(plist, tmp, phead) {
pxmitframe = list_entry(plist, struct xmit_frame, list);
rtw_free_xmitframe(pxmitpriv, pxmitframe);
}
spin_unlock_bh(&pframequeue->lock);
}
s32 rtw_xmitframe_enqueue(struct adapter *padapter, struct xmit_frame *pxmitframe)
{
if (rtw_xmit_classifier(padapter, pxmitframe) == _FAIL)
return _FAIL;
return _SUCCESS;
}
struct tx_servq *rtw_get_sta_pending(struct adapter *padapter, struct sta_info *psta, signed int up, u8 *ac)
{
struct tx_servq *ptxservq = NULL;
switch (up) {
case 1:
case 2:
ptxservq = &psta->sta_xmitpriv.bk_q;
*(ac) = 3;
break;
case 4:
case 5:
ptxservq = &psta->sta_xmitpriv.vi_q;
*(ac) = 1;
break;
case 6:
case 7:
ptxservq = &psta->sta_xmitpriv.vo_q;
*(ac) = 0;
break;
case 0:
case 3:
default:
ptxservq = &psta->sta_xmitpriv.be_q;
*(ac) = 2;
break;
}
return ptxservq;
}
/*
* Will enqueue pxmitframe to the proper queue,
* and indicate it to xx_pending list.....
*/
s32 rtw_xmit_classifier(struct adapter *padapter, struct xmit_frame *pxmitframe)
{
u8 ac_index;
struct sta_info *psta;
struct tx_servq *ptxservq;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits;
signed int res = _SUCCESS;
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (pattrib->psta != psta)
return _FAIL;
if (!psta) {
res = _FAIL;
goto exit;
}
if (!(psta->state & _FW_LINKED))
return _FAIL;
ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
if (list_empty(&ptxservq->tx_pending))
list_add_tail(&ptxservq->tx_pending, get_list_head(phwxmits[ac_index].sta_queue));
list_add_tail(&pxmitframe->list, get_list_head(&ptxservq->sta_pending));
ptxservq->qcnt++;
phwxmits[ac_index].accnt++;
exit:
return res;
}
s32 rtw_alloc_hwxmits(struct adapter *padapter)
{
struct hw_xmit *hwxmits;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
pxmitpriv->hwxmit_entry = HWXMIT_ENTRY;
pxmitpriv->hwxmits = NULL;
pxmitpriv->hwxmits = rtw_zmalloc(sizeof(struct hw_xmit) * pxmitpriv->hwxmit_entry);
if (!pxmitpriv->hwxmits)
return _FAIL;
hwxmits = pxmitpriv->hwxmits;
if (pxmitpriv->hwxmit_entry == 5) {
hwxmits[0] .sta_queue = &pxmitpriv->bm_pending;
hwxmits[1] .sta_queue = &pxmitpriv->vo_pending;
hwxmits[2] .sta_queue = &pxmitpriv->vi_pending;
hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
hwxmits[4] .sta_queue = &pxmitpriv->be_pending;
} else if (pxmitpriv->hwxmit_entry == 4) {
hwxmits[0] .sta_queue = &pxmitpriv->vo_pending;
hwxmits[1] .sta_queue = &pxmitpriv->vi_pending;
hwxmits[2] .sta_queue = &pxmitpriv->be_pending;
hwxmits[3] .sta_queue = &pxmitpriv->bk_pending;
} else {
}
return _SUCCESS;
}
void rtw_free_hwxmits(struct adapter *padapter)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
kfree(pxmitpriv->hwxmits);
}
void rtw_init_hwxmits(struct hw_xmit *phwxmit, signed int entry)
{
signed int i;
for (i = 0; i < entry; i++, phwxmit++)
phwxmit->accnt = 0;
}
u32 rtw_get_ff_hwaddr(struct xmit_frame *pxmitframe)
{
u32 addr;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
switch (pattrib->qsel) {
case 0:
case 3:
addr = BE_QUEUE_INX;
break;
case 1:
case 2:
addr = BK_QUEUE_INX;
break;
case 4:
case 5:
addr = VI_QUEUE_INX;
break;
case 6:
case 7:
addr = VO_QUEUE_INX;
break;
case 0x10:
addr = BCN_QUEUE_INX;
break;
case 0x11:/* BC/MC in PS (HIQ) */
addr = HIGH_QUEUE_INX;
break;
case 0x12:
default:
addr = MGT_QUEUE_INX;
break;
}
return addr;
}
static void do_queue_select(struct adapter *padapter, struct pkt_attrib *pattrib)
{
u8 qsel;
qsel = pattrib->priority;
pattrib->qsel = qsel;
}
/*
* The main transmit(tx) entry
*
* Return
*1 enqueue
*0 success, hardware will handle this xmit frame(packet)
*<0 fail
*/
s32 rtw_xmit(struct adapter *padapter, struct sk_buff **ppkt)
{
static unsigned long start;
static u32 drop_cnt;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct xmit_frame *pxmitframe = NULL;
s32 res;
if (start == 0)
start = jiffies;
pxmitframe = rtw_alloc_xmitframe(pxmitpriv);
if (jiffies_to_msecs(jiffies - start) > 2000) {
start = jiffies;
drop_cnt = 0;
}
if (!pxmitframe) {
drop_cnt++;
return -1;
}
res = update_attrib(padapter, *ppkt, &pxmitframe->attrib);
if (res == _FAIL) {
rtw_free_xmitframe(pxmitpriv, pxmitframe);
return -1;
}
pxmitframe->pkt = *ppkt;
do_queue_select(padapter, &pxmitframe->attrib);
spin_lock_bh(&pxmitpriv->lock);
if (xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe) == true) {
spin_unlock_bh(&pxmitpriv->lock);
return 1;
}
spin_unlock_bh(&pxmitpriv->lock);
/* pre_xmitframe */
if (rtw_hal_xmit(padapter, pxmitframe) == false)
return 1;
return 0;
}
#define RTW_HIQ_FILTER_ALLOW_ALL 0
#define RTW_HIQ_FILTER_ALLOW_SPECIAL 1
#define RTW_HIQ_FILTER_DENY_ALL 2
inline bool xmitframe_hiq_filter(struct xmit_frame *xmitframe)
{
bool allow = false;
struct adapter *adapter = xmitframe->padapter;
struct registry_priv *registry = &adapter->registrypriv;
if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_SPECIAL) {
struct pkt_attrib *attrib = &xmitframe->attrib;
if (attrib->ether_type == 0x0806 ||
attrib->ether_type == 0x888e ||
attrib->dhcp_pkt
)
allow = true;
} else if (registry->hiq_filter == RTW_HIQ_FILTER_ALLOW_ALL)
allow = true;
else if (registry->hiq_filter == RTW_HIQ_FILTER_DENY_ALL) {
} else
rtw_warn_on(1);
return allow;
}
signed int xmitframe_enqueue_for_sleeping_sta(struct adapter *padapter, struct xmit_frame *pxmitframe)
{
signed int ret = false;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct pkt_attrib *pattrib = &pxmitframe->attrib;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
signed int bmcst = is_multicast_ether_addr(pattrib->ra);
bool update_tim = false;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == false)
return ret;
psta = rtw_get_stainfo(&padapter->stapriv, pattrib->ra);
if (pattrib->psta != psta)
return false;
if (!psta)
return false;
if (!(psta->state & _FW_LINKED))
return false;
if (pattrib->triggered == 1) {
if (bmcst && xmitframe_hiq_filter(pxmitframe))
pattrib->qsel = 0x11;/* HIQ */
return ret;
}
if (bmcst) {
spin_lock_bh(&psta->sleep_q.lock);
if (pstapriv->sta_dz_bitmap) { /* if anyone sta is in ps mode */
/* pattrib->qsel = 0x11;HIQ */
list_del_init(&pxmitframe->list);
list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
psta->sleepq_len++;
if (!(pstapriv->tim_bitmap & BIT(0)))
update_tim = true;
pstapriv->tim_bitmap |= BIT(0);
pstapriv->sta_dz_bitmap |= BIT(0);
if (update_tim)
update_beacon(padapter, WLAN_EID_TIM, NULL, true);
else
chk_bmc_sleepq_cmd(padapter);
ret = true;
}
spin_unlock_bh(&psta->sleep_q.lock);
return ret;
}
spin_lock_bh(&psta->sleep_q.lock);
if (psta->state&WIFI_SLEEP_STATE) {
u8 wmmps_ac = 0;
if (pstapriv->sta_dz_bitmap & BIT(psta->aid)) {
list_del_init(&pxmitframe->list);
list_add_tail(&pxmitframe->list, get_list_head(&psta->sleep_q));
psta->sleepq_len++;
switch (pattrib->priority) {
case 1:
case 2:
wmmps_ac = psta->uapsd_bk&BIT(0);
break;
case 4:
case 5:
wmmps_ac = psta->uapsd_vi&BIT(0);
break;
case 6:
case 7:
wmmps_ac = psta->uapsd_vo&BIT(0);
break;
case 0:
case 3:
default:
wmmps_ac = psta->uapsd_be&BIT(0);
break;
}
if (wmmps_ac)
psta->sleepq_ac_len++;
if (((psta->has_legacy_ac) && (!wmmps_ac)) || ((!psta->has_legacy_ac) && (wmmps_ac))) {
if (!(pstapriv->tim_bitmap & BIT(psta->aid)))
update_tim = true;
pstapriv->tim_bitmap |= BIT(psta->aid);
if (update_tim)
/* update BCN for TIM IE */
update_beacon(padapter, WLAN_EID_TIM, NULL, true);
}
ret = true;
}
}
spin_unlock_bh(&psta->sleep_q.lock);
return ret;
}
static void dequeue_xmitframes_to_sleeping_queue(struct adapter *padapter, struct sta_info *psta, struct __queue *pframequeue)
{
signed int ret;
struct list_head *plist, *phead, *tmp;
u8 ac_index;
struct tx_servq *ptxservq;
struct pkt_attrib *pattrib;
struct xmit_frame *pxmitframe;
struct hw_xmit *phwxmits = padapter->xmitpriv.hwxmits;
phead = get_list_head(pframequeue);
list_for_each_safe(plist, tmp, phead) {
pxmitframe = list_entry(plist, struct xmit_frame, list);
pattrib = &pxmitframe->attrib;
pattrib->triggered = 0;
ret = xmitframe_enqueue_for_sleeping_sta(padapter, pxmitframe);
if (true == ret) {
ptxservq = rtw_get_sta_pending(padapter, psta, pattrib->priority, (u8 *)(&ac_index));
ptxservq->qcnt--;
phwxmits[ac_index].accnt--;
} else {
}
}
}
void stop_sta_xmit(struct adapter *padapter, struct sta_info *psta)
{
struct sta_info *psta_bmc;
struct sta_xmit_priv *pstaxmitpriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
pstaxmitpriv = &psta->sta_xmitpriv;
/* for BC/MC Frames */
psta_bmc = rtw_get_bcmc_stainfo(padapter);
spin_lock_bh(&pxmitpriv->lock);
psta->state |= WIFI_SLEEP_STATE;
pstapriv->sta_dz_bitmap |= BIT(psta->aid);
dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vo_q.sta_pending);
list_del_init(&pstaxmitpriv->vo_q.tx_pending);
dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->vi_q.sta_pending);
list_del_init(&pstaxmitpriv->vi_q.tx_pending);
dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->be_q.sta_pending);
list_del_init(&pstaxmitpriv->be_q.tx_pending);
dequeue_xmitframes_to_sleeping_queue(padapter, psta, &pstaxmitpriv->bk_q.sta_pending);
list_del_init(&pstaxmitpriv->bk_q.tx_pending);
/* for BC/MC Frames */
pstaxmitpriv = &psta_bmc->sta_xmitpriv;
dequeue_xmitframes_to_sleeping_queue(padapter, psta_bmc, &pstaxmitpriv->be_q.sta_pending);
list_del_init(&pstaxmitpriv->be_q.tx_pending);
spin_unlock_bh(&pxmitpriv->lock);
}
void wakeup_sta_to_xmit(struct adapter *padapter, struct sta_info *psta)
{
u8 update_mask = 0, wmmps_ac = 0;
struct sta_info *psta_bmc;
struct list_head *xmitframe_plist, *xmitframe_phead, *tmp;
struct xmit_frame *pxmitframe = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
psta_bmc = rtw_get_bcmc_stainfo(padapter);
spin_lock_bh(&pxmitpriv->lock);
xmitframe_phead = get_list_head(&psta->sleep_q);
list_for_each_safe(xmitframe_plist, tmp, xmitframe_phead) {
pxmitframe = list_entry(xmitframe_plist, struct xmit_frame,
list);
list_del_init(&pxmitframe->list);
switch (pxmitframe->attrib.priority) {
case 1:
case 2:
wmmps_ac = psta->uapsd_bk&BIT(1);
break;
case 4:
case 5:
wmmps_ac = psta->uapsd_vi&BIT(1);
break;
case 6:
case 7:
wmmps_ac = psta->uapsd_vo&BIT(1);
break;
case 0:
case 3:
default:
wmmps_ac = psta->uapsd_be&BIT(1);
break;
}
psta->sleepq_len--;
if (psta->sleepq_len > 0)
pxmitframe->attrib.mdata = 1;
else
pxmitframe->attrib.mdata = 0;
if (wmmps_ac) {
psta->sleepq_ac_len--;
if (psta->sleepq_ac_len > 0) {
pxmitframe->attrib.mdata = 1;
pxmitframe->attrib.eosp = 0;
} else {
pxmitframe->attrib.mdata = 0;
pxmitframe->attrib.eosp = 1;
}
}
pxmitframe->attrib.triggered = 1;
rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
}
if (psta->sleepq_len == 0) {
if (pstapriv->tim_bitmap & BIT(psta->aid))
update_mask = BIT(0);
pstapriv->tim_bitmap &= ~BIT(psta->aid);
if (psta->state&WIFI_SLEEP_STATE)
psta->state ^= WIFI_SLEEP_STATE;
if (psta->state & WIFI_STA_ALIVE_CHK_STATE) {
psta->expire_to = pstapriv->expire_to;
psta->state ^= WIFI_STA_ALIVE_CHK_STATE;
}
pstapriv->sta_dz_bitmap &= ~BIT(psta->aid);
}
/* for BC/MC Frames */
if (!psta_bmc)
goto _exit;
if ((pstapriv->sta_dz_bitmap&0xfffe) == 0x0) { /* no any sta in ps mode */
xmitframe_phead = get_list_head(&psta_bmc->sleep_q);
list_for_each_safe(xmitframe_plist, tmp, xmitframe_phead) {
pxmitframe = list_entry(xmitframe_plist,
struct xmit_frame, list);
list_del_init(&pxmitframe->list);
psta_bmc->sleepq_len--;
if (psta_bmc->sleepq_len > 0)
pxmitframe->attrib.mdata = 1;
else
pxmitframe->attrib.mdata = 0;
pxmitframe->attrib.triggered = 1;
rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
}
if (psta_bmc->sleepq_len == 0) {
if (pstapriv->tim_bitmap & BIT(0))
update_mask |= BIT(1);
pstapriv->tim_bitmap &= ~BIT(0);
pstapriv->sta_dz_bitmap &= ~BIT(0);
}
}
_exit:
spin_unlock_bh(&pxmitpriv->lock);
if (update_mask)
update_beacon(padapter, WLAN_EID_TIM, NULL, true);
}
void xmit_delivery_enabled_frames(struct adapter *padapter, struct sta_info *psta)
{
u8 wmmps_ac = 0;
struct list_head *xmitframe_plist, *xmitframe_phead, *tmp;
struct xmit_frame *pxmitframe = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
spin_lock_bh(&pxmitpriv->lock);
xmitframe_phead = get_list_head(&psta->sleep_q);
list_for_each_safe(xmitframe_plist, tmp, xmitframe_phead) {
pxmitframe = list_entry(xmitframe_plist, struct xmit_frame,
list);
switch (pxmitframe->attrib.priority) {
case 1:
case 2:
wmmps_ac = psta->uapsd_bk&BIT(1);
break;
case 4:
case 5:
wmmps_ac = psta->uapsd_vi&BIT(1);
break;
case 6:
case 7:
wmmps_ac = psta->uapsd_vo&BIT(1);
break;
case 0:
case 3:
default:
wmmps_ac = psta->uapsd_be&BIT(1);
break;
}
if (!wmmps_ac)
continue;
list_del_init(&pxmitframe->list);
psta->sleepq_len--;
psta->sleepq_ac_len--;
if (psta->sleepq_ac_len > 0) {
pxmitframe->attrib.mdata = 1;
pxmitframe->attrib.eosp = 0;
} else {
pxmitframe->attrib.mdata = 0;
pxmitframe->attrib.eosp = 1;
}
pxmitframe->attrib.triggered = 1;
rtw_hal_xmitframe_enqueue(padapter, pxmitframe);
if ((psta->sleepq_ac_len == 0) && (!psta->has_legacy_ac) && (wmmps_ac)) {
pstapriv->tim_bitmap &= ~BIT(psta->aid);
update_beacon(padapter, WLAN_EID_TIM, NULL, true);
}
}
spin_unlock_bh(&pxmitpriv->lock);
}
void enqueue_pending_xmitbuf(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{
struct __queue *pqueue;
struct adapter *pri_adapter = pxmitpriv->adapter;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
spin_lock_bh(&pqueue->lock);
list_del_init(&pxmitbuf->list);
list_add_tail(&pxmitbuf->list, get_list_head(pqueue));
spin_unlock_bh(&pqueue->lock);
complete(&pri_adapter->xmitpriv.xmit_comp);
}
void enqueue_pending_xmitbuf_to_head(struct xmit_priv *pxmitpriv, struct xmit_buf *pxmitbuf)
{
struct __queue *pqueue;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
spin_lock_bh(&pqueue->lock);
list_del_init(&pxmitbuf->list);
list_add(&pxmitbuf->list, get_list_head(pqueue));
spin_unlock_bh(&pqueue->lock);
}
struct xmit_buf *dequeue_pending_xmitbuf(struct xmit_priv *pxmitpriv)
{
struct xmit_buf *pxmitbuf;
struct __queue *pqueue;
pxmitbuf = NULL;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
spin_lock_bh(&pqueue->lock);
if (!list_empty(&pqueue->queue)) {
struct list_head *plist, *phead;
phead = get_list_head(pqueue);
plist = get_next(phead);
pxmitbuf = container_of(plist, struct xmit_buf, list);
list_del_init(&pxmitbuf->list);
}
spin_unlock_bh(&pqueue->lock);
return pxmitbuf;
}
struct xmit_buf *dequeue_pending_xmitbuf_under_survey(struct xmit_priv *pxmitpriv)
{
struct xmit_buf *pxmitbuf;
struct __queue *pqueue;
pxmitbuf = NULL;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
spin_lock_bh(&pqueue->lock);
if (!list_empty(&pqueue->queue)) {
struct list_head *plist, *phead;
u8 type;
phead = get_list_head(pqueue);
plist = phead;
do {
plist = get_next(plist);
if (plist == phead)
break;
pxmitbuf = container_of(plist, struct xmit_buf, list);
type = GetFrameSubType(pxmitbuf->pbuf + TXDESC_OFFSET);
if ((type == WIFI_PROBEREQ) ||
(type == WIFI_DATA_NULL) ||
(type == WIFI_QOS_DATA_NULL)) {
list_del_init(&pxmitbuf->list);
break;
}
pxmitbuf = NULL;
} while (1);
}
spin_unlock_bh(&pqueue->lock);
return pxmitbuf;
}
signed int check_pending_xmitbuf(struct xmit_priv *pxmitpriv)
{
struct __queue *pqueue;
signed int ret = false;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
spin_lock_bh(&pqueue->lock);
if (!list_empty(&pqueue->queue))
ret = true;
spin_unlock_bh(&pqueue->lock);
return ret;
}
int rtw_xmit_thread(void *context)
{
s32 err;
struct adapter *padapter;
err = _SUCCESS;
padapter = context;
thread_enter("RTW_XMIT_THREAD");
do {
err = rtw_hal_xmit_thread_handler(padapter);
flush_signals_thread();
} while (err == _SUCCESS);
complete(&padapter->xmitpriv.terminate_xmitthread_comp);
return 0;
}
void rtw_sctx_init(struct submit_ctx *sctx, int timeout_ms)
{
sctx->timeout_ms = timeout_ms;
sctx->submit_time = jiffies;
init_completion(&sctx->done);
sctx->status = RTW_SCTX_SUBMITTED;
}
int rtw_sctx_wait(struct submit_ctx *sctx)
{
int ret = _FAIL;
unsigned long expire;
int status = 0;
expire = sctx->timeout_ms ? msecs_to_jiffies(sctx->timeout_ms) : MAX_SCHEDULE_TIMEOUT;
if (!wait_for_completion_timeout(&sctx->done, expire))
/* timeout, do something?? */
status = RTW_SCTX_DONE_TIMEOUT;
else
status = sctx->status;
if (status == RTW_SCTX_DONE_SUCCESS)
ret = _SUCCESS;
return ret;
}
void rtw_sctx_done_err(struct submit_ctx **sctx, int status)
{
if (*sctx) {
(*sctx)->status = status;
complete(&((*sctx)->done));
*sctx = NULL;
}
}
void rtw_sctx_done(struct submit_ctx **sctx)
{
rtw_sctx_done_err(sctx, RTW_SCTX_DONE_SUCCESS);
}
int rtw_ack_tx_wait(struct xmit_priv *pxmitpriv, u32 timeout_ms)
{
struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
pack_tx_ops->submit_time = jiffies;
pack_tx_ops->timeout_ms = timeout_ms;
pack_tx_ops->status = RTW_SCTX_SUBMITTED;
return rtw_sctx_wait(pack_tx_ops);
}
void rtw_ack_tx_done(struct xmit_priv *pxmitpriv, int status)
{
struct submit_ctx *pack_tx_ops = &pxmitpriv->ack_tx_ops;
if (pxmitpriv->ack_tx)
rtw_sctx_done_err(&pack_tx_ops, status);
}
| linux-master | drivers/staging/rtl8723bs/core/rtw_xmit.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2013 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtw_btcoex.h>
#include <hal_btcoex.h>
void rtw_btcoex_MediaStatusNotify(struct adapter *padapter, u8 mediaStatus)
{
if ((mediaStatus == RT_MEDIA_CONNECT)
&& (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == true)) {
rtw_hal_set_hwreg(padapter, HW_VAR_DL_RSVD_PAGE, NULL);
}
hal_btcoex_MediaStatusNotify(padapter, mediaStatus);
}
void rtw_btcoex_HaltNotify(struct adapter *padapter)
{
if (!padapter->bup)
return;
if (padapter->bSurpriseRemoved)
return;
hal_btcoex_HaltNotify(padapter);
}
/* ================================================== */
/* Below Functions are called by BT-Coex */
/* ================================================== */
void rtw_btcoex_RejectApAggregatedPacket(struct adapter *padapter, u8 enable)
{
struct mlme_ext_info *pmlmeinfo;
struct sta_info *psta;
pmlmeinfo = &padapter->mlmeextpriv.mlmext_info;
psta = rtw_get_stainfo(&padapter->stapriv, get_bssid(&padapter->mlmepriv));
if (enable) {
pmlmeinfo->accept_addba_req = false;
if (psta)
send_delba(padapter, 0, psta->hwaddr);
} else {
pmlmeinfo->accept_addba_req = true;
}
}
void rtw_btcoex_LPS_Enter(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv;
u8 lpsVal;
pwrpriv = adapter_to_pwrctl(padapter);
pwrpriv->bpower_saving = true;
lpsVal = hal_btcoex_LpsVal(padapter);
rtw_set_ps_mode(padapter, PS_MODE_MIN, 0, lpsVal, "BTCOEX");
}
void rtw_btcoex_LPS_Leave(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv;
pwrpriv = adapter_to_pwrctl(padapter);
if (pwrpriv->pwr_mode != PS_MODE_ACTIVE) {
rtw_set_ps_mode(padapter, PS_MODE_ACTIVE, 0, 0, "BTCOEX");
LPS_RF_ON_check(padapter, 100);
pwrpriv->bpower_saving = false;
}
}
| linux-master | drivers/staging/rtl8723bs/core/rtw_btcoex.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <hal_com_h2c.h>
static unsigned char ARTHEROS_OUI1[] = {0x00, 0x03, 0x7f};
static unsigned char ARTHEROS_OUI2[] = {0x00, 0x13, 0x74};
static unsigned char BROADCOM_OUI1[] = {0x00, 0x10, 0x18};
static unsigned char BROADCOM_OUI2[] = {0x00, 0x0a, 0xf7};
static unsigned char BROADCOM_OUI3[] = {0x00, 0x05, 0xb5};
static unsigned char CISCO_OUI[] = {0x00, 0x40, 0x96};
static unsigned char MARVELL_OUI[] = {0x00, 0x50, 0x43};
static unsigned char RALINK_OUI[] = {0x00, 0x0c, 0x43};
static unsigned char REALTEK_OUI[] = {0x00, 0xe0, 0x4c};
static unsigned char AIRGOCAP_OUI[] = {0x00, 0x0a, 0xf5};
static unsigned char RSN_TKIP_CIPHER[4] = {0x00, 0x0f, 0xac, 0x02};
static unsigned char WPA_TKIP_CIPHER[4] = {0x00, 0x50, 0xf2, 0x02};
/* define WAIT_FOR_BCN_TO_MIN (3000) */
#define WAIT_FOR_BCN_TO_MIN (6000)
#define WAIT_FOR_BCN_TO_MAX (20000)
#define DISCONNECT_BY_CHK_BCN_FAIL_OBSERV_PERIOD_IN_MS 1000
#define DISCONNECT_BY_CHK_BCN_FAIL_THRESHOLD 3
static u8 rtw_basic_rate_cck[4] = {
IEEE80211_CCK_RATE_1MB | IEEE80211_BASIC_RATE_MASK,
IEEE80211_CCK_RATE_2MB | IEEE80211_BASIC_RATE_MASK,
IEEE80211_CCK_RATE_5MB | IEEE80211_BASIC_RATE_MASK,
IEEE80211_CCK_RATE_11MB | IEEE80211_BASIC_RATE_MASK
};
static u8 rtw_basic_rate_ofdm[3] = {
IEEE80211_OFDM_RATE_6MB | IEEE80211_BASIC_RATE_MASK,
IEEE80211_OFDM_RATE_12MB | IEEE80211_BASIC_RATE_MASK,
IEEE80211_OFDM_RATE_24MB | IEEE80211_BASIC_RATE_MASK
};
u8 networktype_to_raid_ex(struct adapter *adapter, struct sta_info *psta)
{
u8 raid;
switch (psta->wireless_mode) {
case WIRELESS_11B:
raid = RATEID_IDX_B;
break;
case WIRELESS_11G:
raid = RATEID_IDX_G;
break;
case WIRELESS_11BG:
raid = RATEID_IDX_BG;
break;
case WIRELESS_11_24N:
case WIRELESS_11G_24N:
raid = RATEID_IDX_GN_N1SS;
break;
case WIRELESS_11B_24N:
case WIRELESS_11BG_24N:
if (psta->bw_mode == CHANNEL_WIDTH_20) {
raid = RATEID_IDX_BGN_20M_1SS_BN;
} else {
raid = RATEID_IDX_BGN_40M_1SS;
}
break;
default:
raid = RATEID_IDX_BGN_40M_2SS;
break;
}
return raid;
}
unsigned char ratetbl_val_2wifirate(unsigned char rate);
unsigned char ratetbl_val_2wifirate(unsigned char rate)
{
switch (rate & 0x7f) {
case 0:
return IEEE80211_CCK_RATE_1MB;
case 1:
return IEEE80211_CCK_RATE_2MB;
case 2:
return IEEE80211_CCK_RATE_5MB;
case 3:
return IEEE80211_CCK_RATE_11MB;
case 4:
return IEEE80211_OFDM_RATE_6MB;
case 5:
return IEEE80211_OFDM_RATE_9MB;
case 6:
return IEEE80211_OFDM_RATE_12MB;
case 7:
return IEEE80211_OFDM_RATE_18MB;
case 8:
return IEEE80211_OFDM_RATE_24MB;
case 9:
return IEEE80211_OFDM_RATE_36MB;
case 10:
return IEEE80211_OFDM_RATE_48MB;
case 11:
return IEEE80211_OFDM_RATE_54MB;
default:
return 0;
}
}
int is_basicrate(struct adapter *padapter, unsigned char rate);
int is_basicrate(struct adapter *padapter, unsigned char rate)
{
int i;
unsigned char val;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
for (i = 0; i < NumRates; i++) {
val = pmlmeext->basicrate[i];
if ((val != 0xff) && (val != 0xfe))
if (rate == ratetbl_val_2wifirate(val))
return true;
}
return false;
}
unsigned int ratetbl2rateset(struct adapter *padapter, unsigned char *rateset);
unsigned int ratetbl2rateset(struct adapter *padapter, unsigned char *rateset)
{
int i;
unsigned char rate;
unsigned int len = 0;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
for (i = 0; i < NumRates; i++) {
rate = pmlmeext->datarate[i];
switch (rate) {
case 0xff:
return len;
case 0xfe:
continue;
default:
rate = ratetbl_val_2wifirate(rate);
if (is_basicrate(padapter, rate) == true)
rate |= IEEE80211_BASIC_RATE_MASK;
rateset[len] = rate;
len++;
break;
}
}
return len;
}
void get_rate_set(struct adapter *padapter, unsigned char *pbssrate, int *bssrate_len)
{
unsigned char supportedrates[NumRates];
memset(supportedrates, 0, NumRates);
*bssrate_len = ratetbl2rateset(padapter, supportedrates);
memcpy(pbssrate, supportedrates, *bssrate_len);
}
void set_mcs_rate_by_mask(u8 *mcs_set, u32 mask)
{
u8 mcs_rate_1r = (u8)(mask&0xff);
u8 mcs_rate_2r = (u8)((mask>>8)&0xff);
u8 mcs_rate_3r = (u8)((mask>>16)&0xff);
u8 mcs_rate_4r = (u8)((mask>>24)&0xff);
mcs_set[0] &= mcs_rate_1r;
mcs_set[1] &= mcs_rate_2r;
mcs_set[2] &= mcs_rate_3r;
mcs_set[3] &= mcs_rate_4r;
}
void UpdateBrateTbl(struct adapter *Adapter, u8 *mBratesOS)
{
u8 i;
u8 rate;
/* 1M, 2M, 5.5M, 11M, 6M, 12M, 24M are mandatory. */
for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
rate = mBratesOS[i] & 0x7f;
switch (rate) {
case IEEE80211_CCK_RATE_1MB:
case IEEE80211_CCK_RATE_2MB:
case IEEE80211_CCK_RATE_5MB:
case IEEE80211_CCK_RATE_11MB:
case IEEE80211_OFDM_RATE_6MB:
case IEEE80211_OFDM_RATE_12MB:
case IEEE80211_OFDM_RATE_24MB:
mBratesOS[i] |= IEEE80211_BASIC_RATE_MASK;
break;
}
}
}
void UpdateBrateTblForSoftAP(u8 *bssrateset, u32 bssratelen)
{
u8 i;
u8 rate;
for (i = 0; i < bssratelen; i++) {
rate = bssrateset[i] & 0x7f;
switch (rate) {
case IEEE80211_CCK_RATE_1MB:
case IEEE80211_CCK_RATE_2MB:
case IEEE80211_CCK_RATE_5MB:
case IEEE80211_CCK_RATE_11MB:
bssrateset[i] |= IEEE80211_BASIC_RATE_MASK;
break;
}
}
}
void Save_DM_Func_Flag(struct adapter *padapter)
{
u8 bSaveFlag = true;
rtw_hal_set_hwreg(padapter, HW_VAR_DM_FUNC_OP, (u8 *)(&bSaveFlag));
}
void Restore_DM_Func_Flag(struct adapter *padapter)
{
u8 bSaveFlag = false;
rtw_hal_set_hwreg(padapter, HW_VAR_DM_FUNC_OP, (u8 *)(&bSaveFlag));
}
void Switch_DM_Func(struct adapter *padapter, u32 mode, u8 enable)
{
if (enable == true)
rtw_hal_set_hwreg(padapter, HW_VAR_DM_FUNC_SET, (u8 *)(&mode));
else
rtw_hal_set_hwreg(padapter, HW_VAR_DM_FUNC_CLR, (u8 *)(&mode));
}
void Set_MSR(struct adapter *padapter, u8 type)
{
rtw_hal_set_hwreg(padapter, HW_VAR_MEDIA_STATUS, (u8 *)(&type));
}
inline u8 rtw_get_oper_ch(struct adapter *adapter)
{
return adapter_to_dvobj(adapter)->oper_channel;
}
inline void rtw_set_oper_ch(struct adapter *adapter, u8 ch)
{
#ifdef DBG_CH_SWITCH
const int len = 128;
char msg[128] = {0};
int cnt = 0;
int i = 0;
#endif /* DBG_CH_SWITCH */
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
if (dvobj->oper_channel != ch) {
dvobj->on_oper_ch_time = jiffies;
#ifdef DBG_CH_SWITCH
cnt += scnprintf(msg+cnt, len-cnt, "switch to ch %3u", ch);
for (i = 0; i < dvobj->iface_nums; i++) {
struct adapter *iface = dvobj->padapters[i];
cnt += scnprintf(msg+cnt, len-cnt, " [%s:", ADPT_ARG(iface));
if (iface->mlmeextpriv.cur_channel == ch)
cnt += scnprintf(msg+cnt, len-cnt, "C");
else
cnt += scnprintf(msg+cnt, len-cnt, "_");
if (iface->wdinfo.listen_channel == ch && !rtw_p2p_chk_state(&iface->wdinfo, P2P_STATE_NONE))
cnt += scnprintf(msg+cnt, len-cnt, "L");
else
cnt += scnprintf(msg+cnt, len-cnt, "_");
cnt += scnprintf(msg+cnt, len-cnt, "]");
}
#endif /* DBG_CH_SWITCH */
}
dvobj->oper_channel = ch;
}
inline u8 rtw_get_oper_bw(struct adapter *adapter)
{
return adapter_to_dvobj(adapter)->oper_bwmode;
}
inline void rtw_set_oper_bw(struct adapter *adapter, u8 bw)
{
adapter_to_dvobj(adapter)->oper_bwmode = bw;
}
inline u8 rtw_get_oper_choffset(struct adapter *adapter)
{
return adapter_to_dvobj(adapter)->oper_ch_offset;
}
inline void rtw_set_oper_choffset(struct adapter *adapter, u8 offset)
{
adapter_to_dvobj(adapter)->oper_ch_offset = offset;
}
u8 rtw_get_center_ch(u8 channel, u8 chnl_bw, u8 chnl_offset)
{
u8 center_ch = channel;
if (chnl_bw == CHANNEL_WIDTH_40) {
if (chnl_offset == HAL_PRIME_CHNL_OFFSET_LOWER)
center_ch = channel + 2;
else
center_ch = channel - 2;
}
return center_ch;
}
inline unsigned long rtw_get_on_cur_ch_time(struct adapter *adapter)
{
if (adapter->mlmeextpriv.cur_channel == adapter_to_dvobj(adapter)->oper_channel)
return adapter_to_dvobj(adapter)->on_oper_ch_time;
else
return 0;
}
void SelectChannel(struct adapter *padapter, unsigned char channel)
{
if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->setch_mutex)))
return;
/* saved channel info */
rtw_set_oper_ch(padapter, channel);
rtw_hal_set_chan(padapter, channel);
mutex_unlock(&(adapter_to_dvobj(padapter)->setch_mutex));
}
void set_channel_bwmode(struct adapter *padapter, unsigned char channel, unsigned char channel_offset, unsigned short bwmode)
{
u8 center_ch, chnl_offset80 = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
center_ch = rtw_get_center_ch(channel, bwmode, channel_offset);
/* set Channel */
if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->setch_mutex)))
return;
/* saved channel/bw info */
rtw_set_oper_ch(padapter, channel);
rtw_set_oper_bw(padapter, bwmode);
rtw_set_oper_choffset(padapter, channel_offset);
rtw_hal_set_chnl_bw(padapter, center_ch, bwmode, channel_offset, chnl_offset80); /* set center channel */
mutex_unlock(&(adapter_to_dvobj(padapter)->setch_mutex));
}
inline u8 *get_my_bssid(struct wlan_bssid_ex *pnetwork)
{
return pnetwork->mac_address;
}
u16 get_beacon_interval(struct wlan_bssid_ex *bss)
{
__le16 val;
memcpy((unsigned char *)&val, rtw_get_beacon_interval_from_ie(bss->ies), 2);
return le16_to_cpu(val);
}
int is_client_associated_to_ap(struct adapter *padapter)
{
struct mlme_ext_priv *pmlmeext;
struct mlme_ext_info *pmlmeinfo;
if (!padapter)
return _FAIL;
pmlmeext = &padapter->mlmeextpriv;
pmlmeinfo = &(pmlmeext->mlmext_info);
if ((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && ((pmlmeinfo->state&0x03) == WIFI_FW_STATION_STATE))
return true;
else
return _FAIL;
}
int is_client_associated_to_ibss(struct adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if ((pmlmeinfo->state & WIFI_FW_ASSOC_SUCCESS) && ((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE))
return true;
else
return _FAIL;
}
int is_IBSS_empty(struct adapter *padapter)
{
unsigned int i;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
for (i = IBSS_START_MAC_ID; i < NUM_STA; i++) {
if (pmlmeinfo->FW_sta_info[i].status == 1)
return _FAIL;
}
return true;
}
unsigned int decide_wait_for_beacon_timeout(unsigned int bcn_interval)
{
if ((bcn_interval << 2) < WAIT_FOR_BCN_TO_MIN)
return WAIT_FOR_BCN_TO_MIN;
else if ((bcn_interval << 2) > WAIT_FOR_BCN_TO_MAX)
return WAIT_FOR_BCN_TO_MAX;
else
return bcn_interval << 2;
}
void invalidate_cam_all(struct adapter *padapter)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
rtw_hal_set_hwreg(padapter, HW_VAR_CAM_INVALID_ALL, NULL);
spin_lock_bh(&cam_ctl->lock);
cam_ctl->bitmap = 0;
memset(dvobj->cam_cache, 0, sizeof(struct cam_entry_cache)*TOTAL_CAM_ENTRY);
spin_unlock_bh(&cam_ctl->lock);
}
static u32 _ReadCAM(struct adapter *padapter, u32 addr)
{
u32 count = 0, cmd;
cmd = CAM_POLLINIG | addr;
rtw_write32(padapter, RWCAM, cmd);
do {
if (0 == (rtw_read32(padapter, REG_CAMCMD) & CAM_POLLINIG))
break;
} while (count++ < 100);
return rtw_read32(padapter, REG_CAMREAD);
}
void read_cam(struct adapter *padapter, u8 entry, u8 *get_key)
{
u32 j, addr, cmd;
addr = entry << 3;
for (j = 0; j < 6; j++) {
cmd = _ReadCAM(padapter, addr+j);
if (j > 1) /* get key from cam */
memcpy(get_key+(j-2)*4, &cmd, 4);
}
}
void _write_cam(struct adapter *padapter, u8 entry, u16 ctrl, u8 *mac, u8 *key)
{
unsigned int i, val, addr;
int j;
u32 cam_val[2];
addr = entry << 3;
for (j = 5; j >= 0; j--) {
switch (j) {
case 0:
val = (ctrl | (mac[0] << 16) | (mac[1] << 24));
break;
case 1:
val = (mac[2] | (mac[3] << 8) | (mac[4] << 16) | (mac[5] << 24));
break;
default:
i = (j - 2) << 2;
val = (key[i] | (key[i+1] << 8) | (key[i+2] << 16) | (key[i+3] << 24));
break;
}
cam_val[0] = val;
cam_val[1] = addr + (unsigned int)j;
rtw_hal_set_hwreg(padapter, HW_VAR_CAM_WRITE, (u8 *)cam_val);
}
}
void _clear_cam_entry(struct adapter *padapter, u8 entry)
{
unsigned char null_sta[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned char null_key[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
_write_cam(padapter, entry, 0, null_sta, null_key);
}
inline void write_cam(struct adapter *adapter, u8 id, u16 ctrl, u8 *mac, u8 *key)
{
_write_cam(adapter, id, ctrl, mac, key);
write_cam_cache(adapter, id, ctrl, mac, key);
}
inline void clear_cam_entry(struct adapter *adapter, u8 id)
{
_clear_cam_entry(adapter, id);
clear_cam_cache(adapter, id);
}
void write_cam_cache(struct adapter *adapter, u8 id, u16 ctrl, u8 *mac, u8 *key)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
spin_lock_bh(&cam_ctl->lock);
dvobj->cam_cache[id].ctrl = ctrl;
memcpy(dvobj->cam_cache[id].mac, mac, ETH_ALEN);
memcpy(dvobj->cam_cache[id].key, key, 16);
spin_unlock_bh(&cam_ctl->lock);
}
void clear_cam_cache(struct adapter *adapter, u8 id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
spin_lock_bh(&cam_ctl->lock);
memset(&(dvobj->cam_cache[id]), 0, sizeof(struct cam_entry_cache));
spin_unlock_bh(&cam_ctl->lock);
}
static bool _rtw_camid_is_gk(struct adapter *adapter, u8 cam_id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
bool ret = false;
if (cam_id >= TOTAL_CAM_ENTRY)
goto exit;
if (!(cam_ctl->bitmap & BIT(cam_id)))
goto exit;
ret = (dvobj->cam_cache[cam_id].ctrl&BIT6)?true:false;
exit:
return ret;
}
static s16 _rtw_camid_search(struct adapter *adapter, u8 *addr, s16 kid)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
int i;
s16 cam_id = -1;
for (i = 0; i < TOTAL_CAM_ENTRY; i++) {
if (addr && memcmp(dvobj->cam_cache[i].mac, addr, ETH_ALEN))
continue;
if (kid >= 0 && kid != (dvobj->cam_cache[i].ctrl&0x03))
continue;
cam_id = i;
break;
}
return cam_id;
}
s16 rtw_camid_search(struct adapter *adapter, u8 *addr, s16 kid)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
s16 cam_id = -1;
spin_lock_bh(&cam_ctl->lock);
cam_id = _rtw_camid_search(adapter, addr, kid);
spin_unlock_bh(&cam_ctl->lock);
return cam_id;
}
s16 rtw_camid_alloc(struct adapter *adapter, struct sta_info *sta, u8 kid)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
s16 cam_id = -1;
struct mlme_ext_info *mlmeinfo;
spin_lock_bh(&cam_ctl->lock);
mlmeinfo = &adapter->mlmeextpriv.mlmext_info;
if ((((mlmeinfo->state&0x03) == WIFI_FW_AP_STATE) || ((mlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE))
&& !sta) {
/* AP/Ad-hoc mode group key: static alloction to default key by key ID */
if (kid > 3) {
netdev_dbg(adapter->pnetdev,
FUNC_ADPT_FMT " group key with invalid key id:%u\n",
FUNC_ADPT_ARG(adapter), kid);
rtw_warn_on(1);
goto bitmap_handle;
}
cam_id = kid;
} else {
int i;
u8 *addr = sta?sta->hwaddr:NULL;
if (!sta) {
if (!(mlmeinfo->state & WIFI_FW_ASSOC_SUCCESS)) {
/* bypass STA mode group key setting before connected(ex:WEP) because bssid is not ready */
goto bitmap_handle;
}
addr = get_bssid(&adapter->mlmepriv);
}
i = _rtw_camid_search(adapter, addr, kid);
if (i >= 0) {
/* Fix issue that pairwise and group key have same key id. Pairwise key first, group key can overwirte group only(ex: rekey) */
if (sta || _rtw_camid_is_gk(adapter, i))
cam_id = i;
else
netdev_dbg(adapter->pnetdev,
FUNC_ADPT_FMT " group key id:%u the same key id as pairwise key\n",
FUNC_ADPT_ARG(adapter), kid);
goto bitmap_handle;
}
for (i = 4; i < TOTAL_CAM_ENTRY; i++)
if (!(cam_ctl->bitmap & BIT(i)))
break;
if (i == TOTAL_CAM_ENTRY) {
if (sta)
netdev_dbg(adapter->pnetdev,
FUNC_ADPT_FMT " pairwise key with %pM id:%u no room\n",
FUNC_ADPT_ARG(adapter),
MAC_ARG(sta->hwaddr), kid);
else
netdev_dbg(adapter->pnetdev,
FUNC_ADPT_FMT " group key id:%u no room\n",
FUNC_ADPT_ARG(adapter), kid);
rtw_warn_on(1);
goto bitmap_handle;
}
cam_id = i;
}
bitmap_handle:
if (cam_id >= 0 && cam_id < 32)
cam_ctl->bitmap |= BIT(cam_id);
spin_unlock_bh(&cam_ctl->lock);
return cam_id;
}
void rtw_camid_free(struct adapter *adapter, u8 cam_id)
{
struct dvobj_priv *dvobj = adapter_to_dvobj(adapter);
struct cam_ctl_t *cam_ctl = &dvobj->cam_ctl;
spin_lock_bh(&cam_ctl->lock);
if (cam_id < TOTAL_CAM_ENTRY)
cam_ctl->bitmap &= ~(BIT(cam_id));
spin_unlock_bh(&cam_ctl->lock);
}
int allocate_fw_sta_entry(struct adapter *padapter)
{
unsigned int mac_id;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
for (mac_id = IBSS_START_MAC_ID; mac_id < NUM_STA; mac_id++) {
if (pmlmeinfo->FW_sta_info[mac_id].status == 0) {
pmlmeinfo->FW_sta_info[mac_id].status = 1;
pmlmeinfo->FW_sta_info[mac_id].retry = 0;
break;
}
}
return mac_id;
}
void flush_all_cam_entry(struct adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
invalidate_cam_all(padapter);
/* clear default key related key search setting */
rtw_hal_set_hwreg(padapter, HW_VAR_SEC_DK_CFG, (u8 *)false);
memset((u8 *)(pmlmeinfo->FW_sta_info), 0, sizeof(pmlmeinfo->FW_sta_info));
}
int WMM_param_handler(struct adapter *padapter, struct ndis_80211_var_ie *pIE)
{
/* struct registry_priv *pregpriv = &padapter->registrypriv; */
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (pmlmepriv->qospriv.qos_option == 0) {
pmlmeinfo->WMM_enable = 0;
return false;
}
if (!memcmp(&(pmlmeinfo->WMM_param), (pIE->data + 6), sizeof(struct WMM_para_element)))
return false;
else
memcpy(&(pmlmeinfo->WMM_param), (pIE->data + 6), sizeof(struct WMM_para_element));
pmlmeinfo->WMM_enable = 1;
return true;
}
static void sort_wmm_ac_params(u32 *inx, u32 *edca)
{
u32 i, j, change_inx = false;
/* entry indx: 0->vo, 1->vi, 2->be, 3->bk. */
for (i = 0; i < 4; i++) {
for (j = i + 1; j < 4; j++) {
/* compare CW and AIFS */
if ((edca[j] & 0xFFFF) < (edca[i] & 0xFFFF)) {
change_inx = true;
} else if ((edca[j] & 0xFFFF) == (edca[i] & 0xFFFF)) {
/* compare TXOP */
if ((edca[j] >> 16) > (edca[i] >> 16))
change_inx = true;
}
if (change_inx) {
swap(edca[i], edca[j]);
swap(inx[i], inx[j]);
change_inx = false;
}
}
}
}
void WMMOnAssocRsp(struct adapter *padapter)
{
u8 ACI, ACM, AIFS, ECWMin, ECWMax, aSifsTime;
u8 acm_mask;
u16 TXOP;
u32 acParm, i;
u32 edca[4], inx[4];
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct registry_priv *pregpriv = &padapter->registrypriv;
acm_mask = 0;
if (pmlmeext->cur_wireless_mode & WIRELESS_11_24N)
aSifsTime = 16;
else
aSifsTime = 10;
if (pmlmeinfo->WMM_enable == 0) {
padapter->mlmepriv.acm_mask = 0;
AIFS = aSifsTime + (2 * pmlmeinfo->slotTime);
if (pmlmeext->cur_wireless_mode & WIRELESS_11G) {
ECWMin = 4;
ECWMax = 10;
} else if (pmlmeext->cur_wireless_mode & WIRELESS_11B) {
ECWMin = 5;
ECWMax = 10;
} else {
ECWMin = 4;
ECWMax = 10;
}
TXOP = 0;
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BE, (u8 *)(&acParm));
rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BK, (u8 *)(&acParm));
rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VI, (u8 *)(&acParm));
ECWMin = 2;
ECWMax = 3;
TXOP = 0x2f;
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VO, (u8 *)(&acParm));
} else {
edca[0] = edca[1] = edca[2] = edca[3] = 0;
for (i = 0; i < 4; i++) {
ACI = (pmlmeinfo->WMM_param.ac_param[i].ACI_AIFSN >> 5) & 0x03;
ACM = (pmlmeinfo->WMM_param.ac_param[i].ACI_AIFSN >> 4) & 0x01;
/* AIFS = AIFSN * slot time + SIFS - r2t phy delay */
AIFS = (pmlmeinfo->WMM_param.ac_param[i].ACI_AIFSN & 0x0f) * pmlmeinfo->slotTime + aSifsTime;
ECWMin = (pmlmeinfo->WMM_param.ac_param[i].CW & 0x0f);
ECWMax = (pmlmeinfo->WMM_param.ac_param[i].CW & 0xf0) >> 4;
TXOP = le16_to_cpu(pmlmeinfo->WMM_param.ac_param[i].TXOP_limit);
acParm = AIFS | (ECWMin << 8) | (ECWMax << 12) | (TXOP << 16);
switch (ACI) {
case 0x0:
rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BE, (u8 *)(&acParm));
acm_mask |= (ACM ? BIT(1):0);
edca[XMIT_BE_QUEUE] = acParm;
break;
case 0x1:
rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_BK, (u8 *)(&acParm));
/* acm_mask |= (ACM? BIT(0):0); */
edca[XMIT_BK_QUEUE] = acParm;
break;
case 0x2:
rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VI, (u8 *)(&acParm));
acm_mask |= (ACM ? BIT(2):0);
edca[XMIT_VI_QUEUE] = acParm;
break;
case 0x3:
rtw_hal_set_hwreg(padapter, HW_VAR_AC_PARAM_VO, (u8 *)(&acParm));
acm_mask |= (ACM ? BIT(3):0);
edca[XMIT_VO_QUEUE] = acParm;
break;
}
}
if (padapter->registrypriv.acm_method == 1)
rtw_hal_set_hwreg(padapter, HW_VAR_ACM_CTRL, (u8 *)(&acm_mask));
else
padapter->mlmepriv.acm_mask = acm_mask;
inx[0] = 0; inx[1] = 1; inx[2] = 2; inx[3] = 3;
if (pregpriv->wifi_spec == 1)
sort_wmm_ac_params(inx, edca);
for (i = 0; i < 4; i++)
pxmitpriv->wmm_para_seq[i] = inx[i];
}
}
static void bwmode_update_check(struct adapter *padapter, struct ndis_80211_var_ie *pIE)
{
unsigned char new_bwmode;
unsigned char new_ch_offset;
struct HT_info_element *pHT_info;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
u8 cbw40_enable = 0;
if (!pIE)
return;
if (phtpriv->ht_option == false)
return;
if (pIE->length > sizeof(struct HT_info_element))
return;
pHT_info = (struct HT_info_element *)pIE->data;
if (pmlmeext->cur_channel > 14) {
if ((pregistrypriv->bw_mode & 0xf0) > 0)
cbw40_enable = 1;
} else {
if ((pregistrypriv->bw_mode & 0x0f) > 0)
cbw40_enable = 1;
}
if ((pHT_info->infos[0] & BIT(2)) && cbw40_enable) {
new_bwmode = CHANNEL_WIDTH_40;
switch (pHT_info->infos[0] & 0x3) {
case 1:
new_ch_offset = HAL_PRIME_CHNL_OFFSET_LOWER;
break;
case 3:
new_ch_offset = HAL_PRIME_CHNL_OFFSET_UPPER;
break;
default:
new_bwmode = CHANNEL_WIDTH_20;
new_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
break;
}
} else {
new_bwmode = CHANNEL_WIDTH_20;
new_ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
}
if ((new_bwmode != pmlmeext->cur_bwmode) || (new_ch_offset != pmlmeext->cur_ch_offset)) {
pmlmeinfo->bwmode_updated = true;
pmlmeext->cur_bwmode = new_bwmode;
pmlmeext->cur_ch_offset = new_ch_offset;
/* update HT info also */
HT_info_handler(padapter, pIE);
} else {
pmlmeinfo->bwmode_updated = false;
}
if (true == pmlmeinfo->bwmode_updated) {
struct sta_info *psta;
struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network);
struct sta_priv *pstapriv = &padapter->stapriv;
/* set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode); */
/* update ap's stainfo */
psta = rtw_get_stainfo(pstapriv, cur_network->mac_address);
if (psta) {
struct ht_priv *phtpriv_sta = &psta->htpriv;
if (phtpriv_sta->ht_option) {
/* bwmode */
psta->bw_mode = pmlmeext->cur_bwmode;
phtpriv_sta->ch_offset = pmlmeext->cur_ch_offset;
} else {
psta->bw_mode = CHANNEL_WIDTH_20;
phtpriv_sta->ch_offset = HAL_PRIME_CHNL_OFFSET_DONT_CARE;
}
rtw_dm_ra_mask_wk_cmd(padapter, (u8 *)psta);
}
}
}
void HT_caps_handler(struct adapter *padapter, struct ndis_80211_var_ie *pIE)
{
unsigned int i;
u8 max_AMPDU_len, min_MPDU_spacing;
u8 cur_ldpc_cap = 0, cur_stbc_cap = 0;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
if (!pIE)
return;
if (phtpriv->ht_option == false)
return;
pmlmeinfo->HT_caps_enable = 1;
for (i = 0; i < (pIE->length); i++) {
if (i != 2) {
/* Commented by Albert 2010/07/12 */
/* Got the endian issue here. */
pmlmeinfo->HT_caps.u.HT_cap[i] &= (pIE->data[i]);
} else {
/* modify from fw by Thomas 2010/11/17 */
max_AMPDU_len = min(pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x3,
pIE->data[i] & 0x3);
min_MPDU_spacing = max(pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c,
pIE->data[i] & 0x1c);
pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para = max_AMPDU_len | min_MPDU_spacing;
}
}
/* update the MCS set */
for (i = 0; i < 16; i++)
pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate[i] &= pmlmeext->default_supported_mcs_set[i];
/* update the MCS rates */
set_mcs_rate_by_mask(pmlmeinfo->HT_caps.u.HT_cap_element.MCS_rate, MCS_RATE_1R);
if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
/* Config STBC setting */
if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX) &&
GET_HT_CAPABILITY_ELE_TX_STBC(pIE->data))
SET_FLAG(cur_stbc_cap, STBC_HT_ENABLE_TX);
phtpriv->stbc_cap = cur_stbc_cap;
} else {
/* Config LDPC Coding Capability */
if (TEST_FLAG(phtpriv->ldpc_cap, LDPC_HT_ENABLE_TX) &&
GET_HT_CAPABILITY_ELE_LDPC_CAP(pIE->data))
SET_FLAG(cur_ldpc_cap, (LDPC_HT_ENABLE_TX | LDPC_HT_CAP_TX));
phtpriv->ldpc_cap = cur_ldpc_cap;
/* Config STBC setting */
if (TEST_FLAG(phtpriv->stbc_cap, STBC_HT_ENABLE_TX) &&
GET_HT_CAPABILITY_ELE_RX_STBC(pIE->data))
SET_FLAG(cur_stbc_cap, (STBC_HT_ENABLE_TX | STBC_HT_CAP_TX));
phtpriv->stbc_cap = cur_stbc_cap;
}
}
void HT_info_handler(struct adapter *padapter, struct ndis_80211_var_ie *pIE)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct ht_priv *phtpriv = &pmlmepriv->htpriv;
if (!pIE)
return;
if (phtpriv->ht_option == false)
return;
if (pIE->length > sizeof(struct HT_info_element))
return;
pmlmeinfo->HT_info_enable = 1;
memcpy(&(pmlmeinfo->HT_info), pIE->data, pIE->length);
}
void HTOnAssocRsp(struct adapter *padapter)
{
unsigned char max_AMPDU_len;
unsigned char min_MPDU_spacing;
/* struct registry_priv *pregpriv = &padapter->registrypriv; */
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if ((pmlmeinfo->HT_info_enable) && (pmlmeinfo->HT_caps_enable)) {
pmlmeinfo->HT_enable = 1;
} else {
pmlmeinfo->HT_enable = 0;
/* set_channel_bwmode(padapter, pmlmeext->cur_channel, pmlmeext->cur_ch_offset, pmlmeext->cur_bwmode); */
return;
}
/* handle A-MPDU parameter field */
/*
AMPDU_para [1:0]:Max AMPDU Len => 0:8k , 1:16k, 2:32k, 3:64k
AMPDU_para [4:2]:Min MPDU Start Spacing
*/
max_AMPDU_len = pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x03;
min_MPDU_spacing = (pmlmeinfo->HT_caps.u.HT_cap_element.AMPDU_para & 0x1c) >> 2;
rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_MIN_SPACE, (u8 *)(&min_MPDU_spacing));
rtw_hal_set_hwreg(padapter, HW_VAR_AMPDU_FACTOR, (u8 *)(&max_AMPDU_len));
}
void ERP_IE_handler(struct adapter *padapter, struct ndis_80211_var_ie *pIE)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (pIE->length > 1)
return;
pmlmeinfo->ERP_enable = 1;
memcpy(&(pmlmeinfo->ERP_IE), pIE->data, pIE->length);
}
void VCS_update(struct adapter *padapter, struct sta_info *psta)
{
struct registry_priv *pregpriv = &padapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
switch (pregpriv->vrtl_carrier_sense) {/* 0:off 1:on 2:auto */
case 0: /* off */
psta->rtsen = 0;
psta->cts2self = 0;
break;
case 1: /* on */
if (pregpriv->vcs_type == 1) { /* 1:RTS/CTS 2:CTS to self */
psta->rtsen = 1;
psta->cts2self = 0;
} else {
psta->rtsen = 0;
psta->cts2self = 1;
}
break;
case 2: /* auto */
default:
if ((pmlmeinfo->ERP_enable) && (pmlmeinfo->ERP_IE & BIT(1))) {
if (pregpriv->vcs_type == 1) {
psta->rtsen = 1;
psta->cts2self = 0;
} else {
psta->rtsen = 0;
psta->cts2self = 1;
}
} else {
psta->rtsen = 0;
psta->cts2self = 0;
}
break;
}
}
void update_ldpc_stbc_cap(struct sta_info *psta)
{
if (psta->htpriv.ht_option) {
if (TEST_FLAG(psta->htpriv.ldpc_cap, LDPC_HT_ENABLE_TX))
psta->ldpc = 1;
if (TEST_FLAG(psta->htpriv.stbc_cap, STBC_HT_ENABLE_TX))
psta->stbc = 1;
} else {
psta->ldpc = 0;
psta->stbc = 0;
}
}
int rtw_check_bcn_info(struct adapter *Adapter, u8 *pframe, u32 packet_len)
{
unsigned int len;
unsigned char *p;
unsigned short val16, subtype;
struct wlan_network *cur_network = &(Adapter->mlmepriv.cur_network);
/* u8 wpa_ie[255], rsn_ie[255]; */
u16 wpa_len = 0, rsn_len = 0;
u8 encryp_protocol = 0;
struct wlan_bssid_ex *bssid;
int group_cipher = 0, pairwise_cipher = 0, is_8021x = 0;
unsigned char *pbuf;
u32 wpa_ielen = 0;
u8 *pbssid = GetAddr3Ptr(pframe);
struct HT_info_element *pht_info = NULL;
struct ieee80211_ht_cap *pht_cap = NULL;
u32 bcn_channel;
unsigned short ht_cap_info;
unsigned char ht_info_infos_0;
struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
int ssid_len;
if (is_client_associated_to_ap(Adapter) == false)
return true;
len = packet_len - sizeof(struct ieee80211_hdr_3addr);
if (len > MAX_IE_SZ)
return _FAIL;
if (memcmp(cur_network->network.mac_address, pbssid, 6))
return true;
bssid = rtw_zmalloc(sizeof(struct wlan_bssid_ex));
if (!bssid)
return true;
if ((pmlmepriv->timeBcnInfoChkStart != 0) && (jiffies_to_msecs(jiffies - pmlmepriv->timeBcnInfoChkStart) > DISCONNECT_BY_CHK_BCN_FAIL_OBSERV_PERIOD_IN_MS)) {
pmlmepriv->timeBcnInfoChkStart = 0;
pmlmepriv->NumOfBcnInfoChkFail = 0;
}
subtype = GetFrameSubType(pframe) >> 4;
if (subtype == WIFI_BEACON)
bssid->reserved[0] = 1;
bssid->length = sizeof(struct wlan_bssid_ex) - MAX_IE_SZ + len;
/* below is to copy the information element */
bssid->ie_length = len;
memcpy(bssid->ies, (pframe + sizeof(struct ieee80211_hdr_3addr)), bssid->ie_length);
/* check bw and channel offset */
/* parsing HT_CAP_IE */
p = rtw_get_ie(bssid->ies + _FIXED_IE_LENGTH_, WLAN_EID_HT_CAPABILITY, &len, bssid->ie_length - _FIXED_IE_LENGTH_);
if (p && len > 0) {
pht_cap = (struct ieee80211_ht_cap *)(p + 2);
ht_cap_info = le16_to_cpu(pht_cap->cap_info);
} else {
ht_cap_info = 0;
}
/* parsing HT_INFO_IE */
p = rtw_get_ie(bssid->ies + _FIXED_IE_LENGTH_, WLAN_EID_HT_OPERATION, &len, bssid->ie_length - _FIXED_IE_LENGTH_);
if (p && len > 0) {
pht_info = (struct HT_info_element *)(p + 2);
ht_info_infos_0 = pht_info->infos[0];
} else {
ht_info_infos_0 = 0;
}
if (ht_cap_info != cur_network->bcn_info.ht_cap_info ||
((ht_info_infos_0&0x03) != (cur_network->bcn_info.ht_info_infos_0&0x03))) {
{
/* bcn_info_update */
cur_network->bcn_info.ht_cap_info = ht_cap_info;
cur_network->bcn_info.ht_info_infos_0 = ht_info_infos_0;
/* to do : need to check that whether modify related register of BB or not */
}
/* goto _mismatch; */
}
/* Checking for channel */
p = rtw_get_ie(bssid->ies + _FIXED_IE_LENGTH_, WLAN_EID_DS_PARAMS, &len, bssid->ie_length - _FIXED_IE_LENGTH_);
if (p) {
bcn_channel = *(p + 2);
} else {/* In 5G, some ap do not have DSSET IE checking HT info for channel */
rtw_get_ie(bssid->ies + _FIXED_IE_LENGTH_, WLAN_EID_HT_OPERATION,
&len, bssid->ie_length - _FIXED_IE_LENGTH_);
if (pht_info)
bcn_channel = pht_info->primary_channel;
else /* we don't find channel IE, so don't check it */
bcn_channel = Adapter->mlmeextpriv.cur_channel;
}
if (bcn_channel != Adapter->mlmeextpriv.cur_channel)
goto _mismatch;
/* checking SSID */
ssid_len = 0;
p = rtw_get_ie(bssid->ies + _FIXED_IE_LENGTH_, WLAN_EID_SSID, &len, bssid->ie_length - _FIXED_IE_LENGTH_);
if (p) {
ssid_len = *(p + 1);
if (ssid_len > NDIS_802_11_LENGTH_SSID)
ssid_len = 0;
}
memcpy(bssid->ssid.ssid, (p + 2), ssid_len);
bssid->ssid.ssid_length = ssid_len;
if (memcmp(bssid->ssid.ssid, cur_network->network.ssid.ssid, 32) ||
bssid->ssid.ssid_length != cur_network->network.ssid.ssid_length)
if (bssid->ssid.ssid[0] != '\0' &&
bssid->ssid.ssid_length != 0) /* not hidden ssid */
goto _mismatch;
/* check encryption info */
val16 = rtw_get_capability((struct wlan_bssid_ex *)bssid);
if (val16 & BIT(4))
bssid->privacy = 1;
else
bssid->privacy = 0;
if (cur_network->network.privacy != bssid->privacy)
goto _mismatch;
rtw_get_sec_ie(bssid->ies, bssid->ie_length, NULL, &rsn_len, NULL, &wpa_len);
if (rsn_len > 0)
encryp_protocol = ENCRYP_PROTOCOL_WPA2;
else if (wpa_len > 0)
encryp_protocol = ENCRYP_PROTOCOL_WPA;
else
if (bssid->privacy)
encryp_protocol = ENCRYP_PROTOCOL_WEP;
if (cur_network->bcn_info.encryp_protocol != encryp_protocol)
goto _mismatch;
if (encryp_protocol == ENCRYP_PROTOCOL_WPA || encryp_protocol == ENCRYP_PROTOCOL_WPA2) {
pbuf = rtw_get_wpa_ie(&bssid->ies[12], &wpa_ielen, bssid->ie_length-12);
if (pbuf && (wpa_ielen > 0)) {
rtw_parse_wpa_ie(pbuf, wpa_ielen + 2, &group_cipher,
&pairwise_cipher, &is_8021x);
} else {
pbuf = rtw_get_wpa2_ie(&bssid->ies[12], &wpa_ielen, bssid->ie_length-12);
if (pbuf && (wpa_ielen > 0))
rtw_parse_wpa2_ie(pbuf, wpa_ielen + 2, &group_cipher,
&pairwise_cipher, &is_8021x);
}
if (pairwise_cipher != cur_network->bcn_info.pairwise_cipher ||
group_cipher != cur_network->bcn_info.group_cipher)
goto _mismatch;
if (is_8021x != cur_network->bcn_info.is_8021x)
goto _mismatch;
}
kfree(bssid);
return _SUCCESS;
_mismatch:
kfree(bssid);
if (pmlmepriv->NumOfBcnInfoChkFail == 0)
pmlmepriv->timeBcnInfoChkStart = jiffies;
pmlmepriv->NumOfBcnInfoChkFail++;
if ((pmlmepriv->timeBcnInfoChkStart != 0) && (jiffies_to_msecs(jiffies - pmlmepriv->timeBcnInfoChkStart) <= DISCONNECT_BY_CHK_BCN_FAIL_OBSERV_PERIOD_IN_MS)
&& (pmlmepriv->NumOfBcnInfoChkFail >= DISCONNECT_BY_CHK_BCN_FAIL_THRESHOLD)) {
pmlmepriv->timeBcnInfoChkStart = 0;
pmlmepriv->NumOfBcnInfoChkFail = 0;
return _FAIL;
}
return _SUCCESS;
}
void update_beacon_info(struct adapter *padapter, u8 *pframe, uint pkt_len, struct sta_info *psta)
{
unsigned int i;
unsigned int len;
struct ndis_80211_var_ie *pIE;
len = pkt_len - (_BEACON_IE_OFFSET_ + WLAN_HDR_A3_LEN);
for (i = 0; i < len;) {
pIE = (struct ndis_80211_var_ie *)(pframe + (_BEACON_IE_OFFSET_ + WLAN_HDR_A3_LEN) + i);
switch (pIE->element_id) {
case WLAN_EID_VENDOR_SPECIFIC:
/* to update WMM parameter set while receiving beacon */
if (!memcmp(pIE->data, WMM_PARA_OUI, 6) && pIE->length == WLAN_WMM_LEN) /* WMM */
if (WMM_param_handler(padapter, pIE))
report_wmm_edca_update(padapter);
break;
case WLAN_EID_HT_OPERATION: /* HT info */
/* HT_info_handler(padapter, pIE); */
bwmode_update_check(padapter, pIE);
break;
case WLAN_EID_ERP_INFO:
ERP_IE_handler(padapter, pIE);
VCS_update(padapter, psta);
break;
default:
break;
}
i += (pIE->length + 2);
}
}
unsigned int is_ap_in_tkip(struct adapter *padapter)
{
u32 i;
struct ndis_80211_var_ie *pIE;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network);
if (rtw_get_capability((struct wlan_bssid_ex *)cur_network) & WLAN_CAPABILITY_PRIVACY) {
for (i = sizeof(struct ndis_802_11_fix_ie); i < pmlmeinfo->network.ie_length;) {
pIE = (struct ndis_80211_var_ie *)(pmlmeinfo->network.ies + i);
switch (pIE->element_id) {
case WLAN_EID_VENDOR_SPECIFIC:
if ((!memcmp(pIE->data, RTW_WPA_OUI, 4)) && (!memcmp((pIE->data + 12), WPA_TKIP_CIPHER, 4)))
return true;
break;
case WLAN_EID_RSN:
if (!memcmp((pIE->data + 8), RSN_TKIP_CIPHER, 4))
return true;
break;
default:
break;
}
i += (pIE->length + 2);
}
return false;
} else {
return false;
}
}
int support_short_GI(struct adapter *padapter, struct HT_caps_element *pHT_caps, u8 bwmode)
{
unsigned char bit_offset;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (!(pmlmeinfo->HT_enable))
return _FAIL;
bit_offset = (bwmode & CHANNEL_WIDTH_40) ? 6 : 5;
if (le16_to_cpu(pHT_caps->u.HT_cap_element.HT_caps_info) & (0x1 << bit_offset))
return _SUCCESS;
else
return _FAIL;
}
unsigned char get_highest_rate_idx(u32 mask)
{
int i;
unsigned char rate_idx = 0;
for (i = 31; i >= 0; i--) {
if (mask & BIT(i)) {
rate_idx = i;
break;
}
}
return rate_idx;
}
void Update_RA_Entry(struct adapter *padapter, struct sta_info *psta)
{
rtw_hal_update_ra_mask(psta, 0);
}
void set_sta_rate(struct adapter *padapter, struct sta_info *psta)
{
/* rate adaptive */
Update_RA_Entry(padapter, psta);
}
static u32 get_realtek_assoc_AP_vender(struct ndis_80211_var_ie *pIE)
{
u32 Vender = HT_IOT_PEER_REALTEK;
if (pIE->length >= 5) {
if (pIE->data[4] == 1)
/* if (pIE->data[5] & RT_HT_CAP_USE_LONG_PREAMBLE) */
/* bssDesc->BssHT.RT2RT_HT_Mode |= RT_HT_CAP_USE_LONG_PREAMBLE; */
if (pIE->data[5] & RT_HT_CAP_USE_92SE)
/* bssDesc->BssHT.RT2RT_HT_Mode |= RT_HT_CAP_USE_92SE; */
Vender = HT_IOT_PEER_REALTEK_92SE;
if (pIE->data[5] & RT_HT_CAP_USE_SOFTAP)
Vender = HT_IOT_PEER_REALTEK_SOFTAP;
if (pIE->data[4] == 2) {
if (pIE->data[6] & RT_HT_CAP_USE_JAGUAR_BCUT)
Vender = HT_IOT_PEER_REALTEK_JAGUAR_BCUTAP;
if (pIE->data[6] & RT_HT_CAP_USE_JAGUAR_CCUT)
Vender = HT_IOT_PEER_REALTEK_JAGUAR_CCUTAP;
}
}
return Vender;
}
unsigned char check_assoc_AP(u8 *pframe, uint len)
{
unsigned int i;
struct ndis_80211_var_ie *pIE;
for (i = sizeof(struct ndis_802_11_fix_ie); i < len;) {
pIE = (struct ndis_80211_var_ie *)(pframe + i);
switch (pIE->element_id) {
case WLAN_EID_VENDOR_SPECIFIC:
if ((!memcmp(pIE->data, ARTHEROS_OUI1, 3)) || (!memcmp(pIE->data, ARTHEROS_OUI2, 3)))
return HT_IOT_PEER_ATHEROS;
else if ((!memcmp(pIE->data, BROADCOM_OUI1, 3)) ||
(!memcmp(pIE->data, BROADCOM_OUI2, 3)) ||
(!memcmp(pIE->data, BROADCOM_OUI3, 3)))
return HT_IOT_PEER_BROADCOM;
else if (!memcmp(pIE->data, MARVELL_OUI, 3))
return HT_IOT_PEER_MARVELL;
else if (!memcmp(pIE->data, RALINK_OUI, 3))
return HT_IOT_PEER_RALINK;
else if (!memcmp(pIE->data, CISCO_OUI, 3))
return HT_IOT_PEER_CISCO;
else if (!memcmp(pIE->data, REALTEK_OUI, 3))
return get_realtek_assoc_AP_vender(pIE);
else if (!memcmp(pIE->data, AIRGOCAP_OUI, 3))
return HT_IOT_PEER_AIRGO;
else
break;
default:
break;
}
i += (pIE->length + 2);
}
return HT_IOT_PEER_UNKNOWN;
}
void update_IOT_info(struct adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
switch (pmlmeinfo->assoc_AP_vendor) {
case HT_IOT_PEER_MARVELL:
pmlmeinfo->turboMode_cts2self = 1;
pmlmeinfo->turboMode_rtsen = 0;
break;
case HT_IOT_PEER_RALINK:
pmlmeinfo->turboMode_cts2self = 0;
pmlmeinfo->turboMode_rtsen = 1;
/* disable high power */
Switch_DM_Func(padapter, (~DYNAMIC_BB_DYNAMIC_TXPWR), false);
break;
case HT_IOT_PEER_REALTEK:
/* rtw_write16(padapter, 0x4cc, 0xffff); */
/* rtw_write16(padapter, 0x546, 0x01c0); */
/* disable high power */
Switch_DM_Func(padapter, (~DYNAMIC_BB_DYNAMIC_TXPWR), false);
break;
default:
pmlmeinfo->turboMode_cts2self = 0;
pmlmeinfo->turboMode_rtsen = 1;
break;
}
}
void update_capinfo(struct adapter *Adapter, u16 updateCap)
{
struct mlme_ext_priv *pmlmeext = &Adapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
bool ShortPreamble;
/* Check preamble mode, 2005.01.06, by rcnjko. */
/* Mark to update preamble value forever, 2008.03.18 by lanhsin */
/* if (pMgntInfo->RegPreambleMode == PREAMBLE_AUTO) */
{
if (updateCap & cShortPreamble) {
/* Short Preamble */
if (pmlmeinfo->preamble_mode != PREAMBLE_SHORT) { /* PREAMBLE_LONG or PREAMBLE_AUTO */
ShortPreamble = true;
pmlmeinfo->preamble_mode = PREAMBLE_SHORT;
rtw_hal_set_hwreg(Adapter, HW_VAR_ACK_PREAMBLE, (u8 *)&ShortPreamble);
}
} else {
/* Long Preamble */
if (pmlmeinfo->preamble_mode != PREAMBLE_LONG) { /* PREAMBLE_SHORT or PREAMBLE_AUTO */
ShortPreamble = false;
pmlmeinfo->preamble_mode = PREAMBLE_LONG;
rtw_hal_set_hwreg(Adapter, HW_VAR_ACK_PREAMBLE, (u8 *)&ShortPreamble);
}
}
}
if (updateCap & cIBSS) {
/* Filen: See 802.11-2007 p.91 */
pmlmeinfo->slotTime = NON_SHORT_SLOT_TIME;
} else {
/* Filen: See 802.11-2007 p.90 */
if (pmlmeext->cur_wireless_mode & (WIRELESS_11_24N)) {
pmlmeinfo->slotTime = SHORT_SLOT_TIME;
} else if (pmlmeext->cur_wireless_mode & (WIRELESS_11G)) {
if ((updateCap & cShortSlotTime) /* && (!(pMgntInfo->pHTInfo->RT2RT_HT_Mode & RT_HT_CAP_USE_LONG_PREAMBLE)) */)
/* Short Slot Time */
pmlmeinfo->slotTime = SHORT_SLOT_TIME;
else
/* Long Slot Time */
pmlmeinfo->slotTime = NON_SHORT_SLOT_TIME;
} else {
/* B Mode */
pmlmeinfo->slotTime = NON_SHORT_SLOT_TIME;
}
}
rtw_hal_set_hwreg(Adapter, HW_VAR_SLOT_TIME, &pmlmeinfo->slotTime);
}
void update_wireless_mode(struct adapter *padapter)
{
int network_type = 0;
u32 SIFS_Timer;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network);
unsigned char *rate = cur_network->supported_rates;
if ((pmlmeinfo->HT_info_enable) && (pmlmeinfo->HT_caps_enable))
pmlmeinfo->HT_enable = 1;
if (pmlmeinfo->HT_enable)
network_type = WIRELESS_11_24N;
if (rtw_is_cckratesonly_included(rate))
network_type |= WIRELESS_11B;
else if (rtw_is_cckrates_included(rate))
network_type |= WIRELESS_11BG;
else
network_type |= WIRELESS_11G;
pmlmeext->cur_wireless_mode = network_type & padapter->registrypriv.wireless_mode;
SIFS_Timer = 0x0a0a0808; /* 0x0808 -> for CCK, 0x0a0a -> for OFDM */
/* change this value if having IOT issues. */
padapter->HalFunc.SetHwRegHandler(padapter, HW_VAR_RESP_SIFS, (u8 *)&SIFS_Timer);
padapter->HalFunc.SetHwRegHandler(padapter, HW_VAR_WIRELESS_MODE, (u8 *)&(pmlmeext->cur_wireless_mode));
if (pmlmeext->cur_wireless_mode & WIRELESS_11B)
update_mgnt_tx_rate(padapter, IEEE80211_CCK_RATE_1MB);
else
update_mgnt_tx_rate(padapter, IEEE80211_OFDM_RATE_6MB);
}
void update_sta_basic_rate(struct sta_info *psta, u8 wireless_mode)
{
if (is_supported_tx_cck(wireless_mode)) {
/* Only B, B/G, and B/G/N AP could use CCK rate */
memcpy(psta->bssrateset, rtw_basic_rate_cck, 4);
psta->bssratelen = 4;
} else {
memcpy(psta->bssrateset, rtw_basic_rate_ofdm, 3);
psta->bssratelen = 3;
}
}
int update_sta_support_rate(struct adapter *padapter, u8 *pvar_ie, uint var_ie_len, int cam_idx)
{
unsigned int ie_len;
struct ndis_80211_var_ie *pIE;
int supportRateNum = 0;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
pIE = (struct ndis_80211_var_ie *)rtw_get_ie(pvar_ie, WLAN_EID_SUPP_RATES, &ie_len, var_ie_len);
if (!pIE)
return _FAIL;
if (ie_len > sizeof(pmlmeinfo->FW_sta_info[cam_idx].SupportedRates))
return _FAIL;
memcpy(pmlmeinfo->FW_sta_info[cam_idx].SupportedRates, pIE->data, ie_len);
supportRateNum = ie_len;
pIE = (struct ndis_80211_var_ie *)rtw_get_ie(pvar_ie, WLAN_EID_EXT_SUPP_RATES, &ie_len, var_ie_len);
if (pIE && (ie_len <= sizeof(pmlmeinfo->FW_sta_info[cam_idx].SupportedRates) - supportRateNum))
memcpy((pmlmeinfo->FW_sta_info[cam_idx].SupportedRates + supportRateNum), pIE->data, ie_len);
return _SUCCESS;
}
void process_addba_req(struct adapter *padapter, u8 *paddba_req, u8 *addr)
{
struct sta_info *psta;
u16 tid, param;
struct recv_reorder_ctrl *preorder_ctrl;
struct sta_priv *pstapriv = &padapter->stapriv;
struct ADDBA_request *preq = (struct ADDBA_request *)paddba_req;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
psta = rtw_get_stainfo(pstapriv, addr);
if (psta) {
param = le16_to_cpu(preq->BA_para_set);
tid = (param>>2)&0x0f;
preorder_ctrl = &psta->recvreorder_ctrl[tid];
preorder_ctrl->indicate_seq = 0xffff;
preorder_ctrl->enable = pmlmeinfo->accept_addba_req;
}
}
void update_TSF(struct mlme_ext_priv *pmlmeext, u8 *pframe, uint len)
{
u8 *pIE;
__le32 *pbuf;
pIE = pframe + sizeof(struct ieee80211_hdr_3addr);
pbuf = (__le32 *)pIE;
pmlmeext->TSFValue = le32_to_cpu(*(pbuf+1));
pmlmeext->TSFValue = pmlmeext->TSFValue << 32;
pmlmeext->TSFValue |= le32_to_cpu(*pbuf);
}
void correct_TSF(struct adapter *padapter, struct mlme_ext_priv *pmlmeext)
{
rtw_hal_set_hwreg(padapter, HW_VAR_CORRECT_TSF, NULL);
}
void adaptive_early_32k(struct mlme_ext_priv *pmlmeext, u8 *pframe, uint len)
{
int i;
u8 *pIE;
__le32 *pbuf;
u64 tsf = 0;
u32 delay_ms;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
pmlmeext->bcn_cnt++;
pIE = pframe + sizeof(struct ieee80211_hdr_3addr);
pbuf = (__le32 *)pIE;
tsf = le32_to_cpu(*(pbuf+1));
tsf = tsf << 32;
tsf |= le32_to_cpu(*pbuf);
/* delay = (timestamp mod 1024*100)/1000 (unit: ms) */
/* delay_ms = do_div(tsf, (pmlmeinfo->bcn_interval*1024))/1000; */
delay_ms = do_div(tsf, (pmlmeinfo->bcn_interval*1024));
delay_ms = delay_ms/1000;
if (delay_ms >= 8)
pmlmeext->bcn_delay_cnt[8]++;
/* pmlmeext->bcn_delay_ratio[8] = (pmlmeext->bcn_delay_cnt[8] * 100) /pmlmeext->bcn_cnt; */
else
pmlmeext->bcn_delay_cnt[delay_ms]++;
/* pmlmeext->bcn_delay_ratio[delay_ms] = (pmlmeext->bcn_delay_cnt[delay_ms] * 100) /pmlmeext->bcn_cnt; */
/*
for (i = 0; i<9; i++)
{
pmlmeext->bcn_delay_cnt[i] , i, pmlmeext->bcn_delay_ratio[i]);
}
*/
/* dump for adaptive_early_32k */
if (pmlmeext->bcn_cnt > 100 && (pmlmeext->adaptive_tsf_done == true)) {
u8 ratio_20_delay, ratio_80_delay;
u8 DrvBcnEarly, DrvBcnTimeOut;
ratio_20_delay = 0;
ratio_80_delay = 0;
DrvBcnEarly = 0xff;
DrvBcnTimeOut = 0xff;
for (i = 0; i < 9; i++) {
pmlmeext->bcn_delay_ratio[i] = (pmlmeext->bcn_delay_cnt[i] * 100) / pmlmeext->bcn_cnt;
ratio_20_delay += pmlmeext->bcn_delay_ratio[i];
ratio_80_delay += pmlmeext->bcn_delay_ratio[i];
if (ratio_20_delay > 20 && DrvBcnEarly == 0xff)
DrvBcnEarly = i;
if (ratio_80_delay > 80 && DrvBcnTimeOut == 0xff)
DrvBcnTimeOut = i;
/* reset adaptive_early_32k cnt */
pmlmeext->bcn_delay_cnt[i] = 0;
pmlmeext->bcn_delay_ratio[i] = 0;
}
pmlmeext->DrvBcnEarly = DrvBcnEarly;
pmlmeext->DrvBcnTimeOut = DrvBcnTimeOut;
pmlmeext->bcn_cnt = 0;
}
}
void rtw_alloc_macid(struct adapter *padapter, struct sta_info *psta)
{
int i;
struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter);
if (is_broadcast_ether_addr(psta->hwaddr))
return;
if (!memcmp(psta->hwaddr, myid(&padapter->eeprompriv), ETH_ALEN)) {
psta->mac_id = NUM_STA;
return;
}
spin_lock_bh(&pdvobj->lock);
for (i = 0; i < NUM_STA; i++) {
if (pdvobj->macid[i] == false) {
pdvobj->macid[i] = true;
break;
}
}
spin_unlock_bh(&pdvobj->lock);
if (i > (NUM_STA - 1))
psta->mac_id = NUM_STA;
else
psta->mac_id = i;
}
void rtw_release_macid(struct adapter *padapter, struct sta_info *psta)
{
struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter);
if (is_broadcast_ether_addr(psta->hwaddr))
return;
if (!memcmp(psta->hwaddr, myid(&padapter->eeprompriv), ETH_ALEN))
return;
spin_lock_bh(&pdvobj->lock);
if (psta->mac_id < NUM_STA && psta->mac_id != 1) {
if (pdvobj->macid[psta->mac_id] == true) {
pdvobj->macid[psta->mac_id] = false;
psta->mac_id = NUM_STA;
}
}
spin_unlock_bh(&pdvobj->lock);
}
/* For 8188E RA */
u8 rtw_search_max_mac_id(struct adapter *padapter)
{
u8 max_mac_id = 0;
struct dvobj_priv *pdvobj = adapter_to_dvobj(padapter);
int i;
spin_lock_bh(&pdvobj->lock);
for (i = (NUM_STA-1); i >= 0 ; i--) {
if (pdvobj->macid[i] == true)
break;
}
max_mac_id = i;
spin_unlock_bh(&pdvobj->lock);
return max_mac_id;
}
struct adapter *dvobj_get_port0_adapter(struct dvobj_priv *dvobj)
{
if (get_iface_type(dvobj->padapters[i]) != IFACE_PORT0)
return NULL;
return dvobj->padapters;
}
| linux-master | drivers/staging/rtl8723bs/core/rtw_wlan_util.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2013 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <linux/firmware.h>
#include <linux/slab.h>
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtl8723b_hal.h>
#include "hal_com_h2c.h"
static void _FWDownloadEnable(struct adapter *padapter, bool enable)
{
u8 tmp, count = 0;
if (enable) {
/* 8051 enable */
tmp = rtw_read8(padapter, REG_SYS_FUNC_EN+1);
rtw_write8(padapter, REG_SYS_FUNC_EN+1, tmp|0x04);
tmp = rtw_read8(padapter, REG_MCUFWDL);
rtw_write8(padapter, REG_MCUFWDL, tmp|0x01);
do {
tmp = rtw_read8(padapter, REG_MCUFWDL);
if (tmp & 0x01)
break;
rtw_write8(padapter, REG_MCUFWDL, tmp|0x01);
msleep(1);
} while (count++ < 100);
/* 8051 reset */
tmp = rtw_read8(padapter, REG_MCUFWDL+2);
rtw_write8(padapter, REG_MCUFWDL+2, tmp&0xf7);
} else {
/* MCU firmware download disable. */
tmp = rtw_read8(padapter, REG_MCUFWDL);
rtw_write8(padapter, REG_MCUFWDL, tmp&0xfe);
}
}
static int _BlockWrite(struct adapter *padapter, void *buffer, u32 buffSize)
{
int ret = _SUCCESS;
u32 blockSize_p1 = 4; /* (Default) Phase #1 : PCI muse use 4-byte write to download FW */
u32 blockSize_p2 = 8; /* Phase #2 : Use 8-byte, if Phase#1 use big size to write FW. */
u32 blockSize_p3 = 1; /* Phase #3 : Use 1-byte, the remnant of FW image. */
u32 blockCount_p1 = 0, blockCount_p2 = 0, blockCount_p3 = 0;
u32 remainSize_p1 = 0, remainSize_p2 = 0;
u8 *bufferPtr = buffer;
u32 i = 0, offset = 0;
/* printk("====>%s %d\n", __func__, __LINE__); */
/* 3 Phase #1 */
blockCount_p1 = buffSize / blockSize_p1;
remainSize_p1 = buffSize % blockSize_p1;
for (i = 0; i < blockCount_p1; i++) {
ret = rtw_write32(padapter, (FW_8723B_START_ADDRESS + i * blockSize_p1), *((u32 *)(bufferPtr + i * blockSize_p1)));
if (ret == _FAIL) {
printk("====>%s %d i:%d\n", __func__, __LINE__, i);
goto exit;
}
}
/* 3 Phase #2 */
if (remainSize_p1) {
offset = blockCount_p1 * blockSize_p1;
blockCount_p2 = remainSize_p1/blockSize_p2;
remainSize_p2 = remainSize_p1%blockSize_p2;
}
/* 3 Phase #3 */
if (remainSize_p2) {
offset = (blockCount_p1 * blockSize_p1) + (blockCount_p2 * blockSize_p2);
blockCount_p3 = remainSize_p2 / blockSize_p3;
for (i = 0; i < blockCount_p3; i++) {
ret = rtw_write8(padapter, (FW_8723B_START_ADDRESS + offset + i), *(bufferPtr + offset + i));
if (ret == _FAIL) {
printk("====>%s %d i:%d\n", __func__, __LINE__, i);
goto exit;
}
}
}
exit:
return ret;
}
static int _PageWrite(
struct adapter *padapter,
u32 page,
void *buffer,
u32 size
)
{
u8 value8;
u8 u8Page = (u8) (page & 0x07);
value8 = (rtw_read8(padapter, REG_MCUFWDL+2) & 0xF8) | u8Page;
rtw_write8(padapter, REG_MCUFWDL+2, value8);
return _BlockWrite(padapter, buffer, size);
}
static int _WriteFW(struct adapter *padapter, void *buffer, u32 size)
{
/* Since we need dynamic decide method of dwonload fw, so we call this function to get chip version. */
/* We can remove _ReadChipVersion from ReadpadapterInfo8192C later. */
int ret = _SUCCESS;
u32 pageNums, remainSize;
u32 page, offset;
u8 *bufferPtr = buffer;
pageNums = size / MAX_DLFW_PAGE_SIZE;
remainSize = size % MAX_DLFW_PAGE_SIZE;
for (page = 0; page < pageNums; page++) {
offset = page * MAX_DLFW_PAGE_SIZE;
ret = _PageWrite(padapter, page, bufferPtr+offset, MAX_DLFW_PAGE_SIZE);
if (ret == _FAIL) {
printk("====>%s %d\n", __func__, __LINE__);
goto exit;
}
}
if (remainSize) {
offset = pageNums * MAX_DLFW_PAGE_SIZE;
page = pageNums;
ret = _PageWrite(padapter, page, bufferPtr+offset, remainSize);
if (ret == _FAIL) {
printk("====>%s %d\n", __func__, __LINE__);
goto exit;
}
}
exit:
return ret;
}
void _8051Reset8723(struct adapter *padapter)
{
u8 cpu_rst;
u8 io_rst;
/* Reset 8051(WLMCU) IO wrapper */
/* 0x1c[8] = 0 */
/* Suggested by Isaac@SD1 and Gimmy@SD1, coding by Lucas@20130624 */
io_rst = rtw_read8(padapter, REG_RSV_CTRL+1);
io_rst &= ~BIT(0);
rtw_write8(padapter, REG_RSV_CTRL+1, io_rst);
cpu_rst = rtw_read8(padapter, REG_SYS_FUNC_EN+1);
cpu_rst &= ~BIT(2);
rtw_write8(padapter, REG_SYS_FUNC_EN+1, cpu_rst);
/* Enable 8051 IO wrapper */
/* 0x1c[8] = 1 */
io_rst = rtw_read8(padapter, REG_RSV_CTRL+1);
io_rst |= BIT(0);
rtw_write8(padapter, REG_RSV_CTRL+1, io_rst);
cpu_rst = rtw_read8(padapter, REG_SYS_FUNC_EN+1);
cpu_rst |= BIT(2);
rtw_write8(padapter, REG_SYS_FUNC_EN+1, cpu_rst);
}
u8 g_fwdl_chksum_fail;
static s32 polling_fwdl_chksum(
struct adapter *adapter, u32 min_cnt, u32 timeout_ms
)
{
s32 ret = _FAIL;
u32 value32;
unsigned long start = jiffies;
u32 cnt = 0;
/* polling CheckSum report */
do {
cnt++;
value32 = rtw_read32(adapter, REG_MCUFWDL);
if (value32 & FWDL_ChkSum_rpt || adapter->bSurpriseRemoved || adapter->bDriverStopped)
break;
yield();
} while (jiffies_to_msecs(jiffies-start) < timeout_ms || cnt < min_cnt);
if (!(value32 & FWDL_ChkSum_rpt)) {
goto exit;
}
if (g_fwdl_chksum_fail) {
g_fwdl_chksum_fail--;
goto exit;
}
ret = _SUCCESS;
exit:
return ret;
}
u8 g_fwdl_wintint_rdy_fail;
static s32 _FWFreeToGo(struct adapter *adapter, u32 min_cnt, u32 timeout_ms)
{
s32 ret = _FAIL;
u32 value32;
unsigned long start = jiffies;
u32 cnt = 0;
value32 = rtw_read32(adapter, REG_MCUFWDL);
value32 |= MCUFWDL_RDY;
value32 &= ~WINTINI_RDY;
rtw_write32(adapter, REG_MCUFWDL, value32);
_8051Reset8723(adapter);
/* polling for FW ready */
do {
cnt++;
value32 = rtw_read32(adapter, REG_MCUFWDL);
if (value32 & WINTINI_RDY || adapter->bSurpriseRemoved || adapter->bDriverStopped)
break;
yield();
} while (jiffies_to_msecs(jiffies - start) < timeout_ms || cnt < min_cnt);
if (!(value32 & WINTINI_RDY)) {
goto exit;
}
if (g_fwdl_wintint_rdy_fail) {
g_fwdl_wintint_rdy_fail--;
goto exit;
}
ret = _SUCCESS;
exit:
return ret;
}
#define IS_FW_81xxC(padapter) (((GET_HAL_DATA(padapter))->FirmwareSignature & 0xFFF0) == 0x88C0)
void rtl8723b_FirmwareSelfReset(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 u1bTmp;
u8 Delay = 100;
if (
!(IS_FW_81xxC(padapter) && ((pHalData->FirmwareVersion < 0x21) || (pHalData->FirmwareVersion == 0x21 && pHalData->FirmwareSubVersion < 0x01)))
) { /* after 88C Fw v33.1 */
/* 0x1cf = 0x20. Inform 8051 to reset. 2009.12.25. tynli_test */
rtw_write8(padapter, REG_HMETFR+3, 0x20);
u1bTmp = rtw_read8(padapter, REG_SYS_FUNC_EN+1);
while (u1bTmp & BIT2) {
Delay--;
if (Delay == 0)
break;
udelay(50);
u1bTmp = rtw_read8(padapter, REG_SYS_FUNC_EN+1);
}
if (Delay == 0) {
/* force firmware reset */
u1bTmp = rtw_read8(padapter, REG_SYS_FUNC_EN+1);
rtw_write8(padapter, REG_SYS_FUNC_EN+1, u1bTmp&(~BIT2));
}
}
}
/* */
/* Description: */
/* Download 8192C firmware code. */
/* */
/* */
s32 rtl8723b_FirmwareDownload(struct adapter *padapter, bool bUsedWoWLANFw)
{
s32 rtStatus = _SUCCESS;
u8 write_fw = 0;
unsigned long fwdl_start_time;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct rt_firmware *pFirmware;
struct rt_firmware *pBTFirmware;
struct rt_firmware_hdr *pFwHdr = NULL;
u8 *pFirmwareBuf;
u32 FirmwareLen;
const struct firmware *fw;
struct device *device = dvobj_to_dev(padapter->dvobj);
u8 *fwfilepath;
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
u8 tmp_ps;
pFirmware = kzalloc(sizeof(struct rt_firmware), GFP_KERNEL);
if (!pFirmware)
return _FAIL;
pBTFirmware = kzalloc(sizeof(struct rt_firmware), GFP_KERNEL);
if (!pBTFirmware) {
kfree(pFirmware);
return _FAIL;
}
tmp_ps = rtw_read8(padapter, 0xa3);
tmp_ps &= 0xf8;
tmp_ps |= 0x02;
/* 1. write 0xA3[:2:0] = 3b'010 */
rtw_write8(padapter, 0xa3, tmp_ps);
/* 2. read power_state = 0xA0[1:0] */
tmp_ps = rtw_read8(padapter, 0xa0);
tmp_ps &= 0x03;
if (tmp_ps != 0x01)
pdbgpriv->dbg_downloadfw_pwr_state_cnt++;
fwfilepath = "rtlwifi/rtl8723bs_nic.bin";
pr_info("rtl8723bs: acquire FW from file:%s\n", fwfilepath);
rtStatus = request_firmware(&fw, fwfilepath, device);
if (rtStatus) {
pr_err("Request firmware failed with error 0x%x\n", rtStatus);
rtStatus = _FAIL;
goto exit;
}
if (!fw) {
pr_err("Firmware %s not available\n", fwfilepath);
rtStatus = _FAIL;
goto exit;
}
if (fw->size > FW_8723B_SIZE) {
rtStatus = _FAIL;
goto exit;
}
pFirmware->fw_buffer_sz = kmemdup(fw->data, fw->size, GFP_KERNEL);
if (!pFirmware->fw_buffer_sz) {
rtStatus = _FAIL;
goto exit;
}
pFirmware->fw_length = fw->size;
release_firmware(fw);
if (pFirmware->fw_length > FW_8723B_SIZE) {
rtStatus = _FAIL;
netdev_emerg(padapter->pnetdev,
"Firmware size:%u exceed %u\n",
pFirmware->fw_length, FW_8723B_SIZE);
goto release_fw1;
}
pFirmwareBuf = pFirmware->fw_buffer_sz;
FirmwareLen = pFirmware->fw_length;
/* To Check Fw header. Added by tynli. 2009.12.04. */
pFwHdr = (struct rt_firmware_hdr *)pFirmwareBuf;
pHalData->FirmwareVersion = le16_to_cpu(pFwHdr->version);
pHalData->FirmwareSubVersion = le16_to_cpu(pFwHdr->subversion);
pHalData->FirmwareSignature = le16_to_cpu(pFwHdr->signature);
if (IS_FW_HEADER_EXIST_8723B(pFwHdr)) {
/* Shift 32 bytes for FW header */
pFirmwareBuf = pFirmwareBuf + 32;
FirmwareLen = FirmwareLen - 32;
}
/* Suggested by Filen. If 8051 is running in RAM code, driver should inform Fw to reset by itself, */
/* or it will cause download Fw fail. 2010.02.01. by tynli. */
if (rtw_read8(padapter, REG_MCUFWDL) & RAM_DL_SEL) { /* 8051 RAM code */
rtw_write8(padapter, REG_MCUFWDL, 0x00);
rtl8723b_FirmwareSelfReset(padapter);
}
_FWDownloadEnable(padapter, true);
fwdl_start_time = jiffies;
while (
!padapter->bDriverStopped &&
!padapter->bSurpriseRemoved &&
(write_fw++ < 3 || jiffies_to_msecs(jiffies - fwdl_start_time) < 500)
) {
/* reset FWDL chksum */
rtw_write8(padapter, REG_MCUFWDL, rtw_read8(padapter, REG_MCUFWDL)|FWDL_ChkSum_rpt);
rtStatus = _WriteFW(padapter, pFirmwareBuf, FirmwareLen);
if (rtStatus != _SUCCESS)
continue;
rtStatus = polling_fwdl_chksum(padapter, 5, 50);
if (rtStatus == _SUCCESS)
break;
}
_FWDownloadEnable(padapter, false);
if (_SUCCESS != rtStatus)
goto fwdl_stat;
rtStatus = _FWFreeToGo(padapter, 10, 200);
if (_SUCCESS != rtStatus)
goto fwdl_stat;
fwdl_stat:
exit:
kfree(pFirmware->fw_buffer_sz);
kfree(pFirmware);
release_fw1:
kfree(pBTFirmware);
return rtStatus;
}
void rtl8723b_InitializeFirmwareVars(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
/* Init Fw LPS related. */
adapter_to_pwrctl(padapter)->fw_current_in_ps_mode = false;
/* Init H2C cmd. */
rtw_write8(padapter, REG_HMETFR, 0x0f);
/* Init H2C counter. by tynli. 2009.12.09. */
pHalData->LastHMEBoxNum = 0;
/* pHalData->H2CQueueHead = 0; */
/* pHalData->H2CQueueTail = 0; */
/* pHalData->H2CStopInsertQueue = false; */
}
static void rtl8723b_free_hal_data(struct adapter *padapter)
{
}
/* */
/* Efuse related code */
/* */
static u8 hal_EfuseSwitchToBank(
struct adapter *padapter, u8 bank, bool bPseudoTest
)
{
u8 bRet = false;
u32 value32 = 0;
#ifdef HAL_EFUSE_MEMORY
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct efuse_hal *pEfuseHal = &pHalData->EfuseHal;
#endif
if (bPseudoTest) {
#ifdef HAL_EFUSE_MEMORY
pEfuseHal->fakeEfuseBank = bank;
#else
fakeEfuseBank = bank;
#endif
bRet = true;
} else {
value32 = rtw_read32(padapter, EFUSE_TEST);
bRet = true;
switch (bank) {
case 0:
value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_WIFI_SEL_0);
break;
case 1:
value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_BT_SEL_0);
break;
case 2:
value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_BT_SEL_1);
break;
case 3:
value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_BT_SEL_2);
break;
default:
value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_WIFI_SEL_0);
bRet = false;
break;
}
rtw_write32(padapter, EFUSE_TEST, value32);
}
return bRet;
}
static void Hal_GetEfuseDefinition(
struct adapter *padapter,
u8 efuseType,
u8 type,
void *pOut,
bool bPseudoTest
)
{
switch (type) {
case TYPE_EFUSE_MAX_SECTION:
{
u8 *pMax_section;
pMax_section = pOut;
if (efuseType == EFUSE_WIFI)
*pMax_section = EFUSE_MAX_SECTION_8723B;
else
*pMax_section = EFUSE_BT_MAX_SECTION;
}
break;
case TYPE_EFUSE_REAL_CONTENT_LEN:
{
u16 *pu2Tmp;
pu2Tmp = pOut;
if (efuseType == EFUSE_WIFI)
*pu2Tmp = EFUSE_REAL_CONTENT_LEN_8723B;
else
*pu2Tmp = EFUSE_BT_REAL_CONTENT_LEN;
}
break;
case TYPE_AVAILABLE_EFUSE_BYTES_BANK:
{
u16 *pu2Tmp;
pu2Tmp = pOut;
if (efuseType == EFUSE_WIFI)
*pu2Tmp = (EFUSE_REAL_CONTENT_LEN_8723B-EFUSE_OOB_PROTECT_BYTES);
else
*pu2Tmp = (EFUSE_BT_REAL_BANK_CONTENT_LEN-EFUSE_PROTECT_BYTES_BANK);
}
break;
case TYPE_AVAILABLE_EFUSE_BYTES_TOTAL:
{
u16 *pu2Tmp;
pu2Tmp = pOut;
if (efuseType == EFUSE_WIFI)
*pu2Tmp = (EFUSE_REAL_CONTENT_LEN_8723B-EFUSE_OOB_PROTECT_BYTES);
else
*pu2Tmp = (EFUSE_BT_REAL_CONTENT_LEN-(EFUSE_PROTECT_BYTES_BANK*3));
}
break;
case TYPE_EFUSE_MAP_LEN:
{
u16 *pu2Tmp;
pu2Tmp = pOut;
if (efuseType == EFUSE_WIFI)
*pu2Tmp = EFUSE_MAX_MAP_LEN;
else
*pu2Tmp = EFUSE_BT_MAP_LEN;
}
break;
case TYPE_EFUSE_PROTECT_BYTES_BANK:
{
u8 *pu1Tmp;
pu1Tmp = pOut;
if (efuseType == EFUSE_WIFI)
*pu1Tmp = EFUSE_OOB_PROTECT_BYTES;
else
*pu1Tmp = EFUSE_PROTECT_BYTES_BANK;
}
break;
case TYPE_EFUSE_CONTENT_LEN_BANK:
{
u16 *pu2Tmp;
pu2Tmp = pOut;
if (efuseType == EFUSE_WIFI)
*pu2Tmp = EFUSE_REAL_CONTENT_LEN_8723B;
else
*pu2Tmp = EFUSE_BT_REAL_BANK_CONTENT_LEN;
}
break;
default:
{
u8 *pu1Tmp;
pu1Tmp = pOut;
*pu1Tmp = 0;
}
break;
}
}
#define VOLTAGE_V25 0x03
/* */
/* The following is for compile ok */
/* That should be merged with the original in the future */
/* */
#define EFUSE_ACCESS_ON_8723 0x69 /* For RTL8723 only. */
#define REG_EFUSE_ACCESS_8723 0x00CF /* Efuse access protection for RTL8723 */
/* */
static void Hal_BT_EfusePowerSwitch(
struct adapter *padapter, u8 bWrite, u8 PwrState
)
{
u8 tempval;
if (PwrState) {
/* enable BT power cut */
/* 0x6A[14] = 1 */
tempval = rtw_read8(padapter, 0x6B);
tempval |= BIT(6);
rtw_write8(padapter, 0x6B, tempval);
/* Attention!! Between 0x6A[14] and 0x6A[15] setting need 100us delay */
/* So don't write 0x6A[14]= 1 and 0x6A[15]= 0 together! */
msleep(1);
/* disable BT output isolation */
/* 0x6A[15] = 0 */
tempval = rtw_read8(padapter, 0x6B);
tempval &= ~BIT(7);
rtw_write8(padapter, 0x6B, tempval);
} else {
/* enable BT output isolation */
/* 0x6A[15] = 1 */
tempval = rtw_read8(padapter, 0x6B);
tempval |= BIT(7);
rtw_write8(padapter, 0x6B, tempval);
/* Attention!! Between 0x6A[14] and 0x6A[15] setting need 100us delay */
/* So don't write 0x6A[14]= 1 and 0x6A[15]= 0 together! */
/* disable BT power cut */
/* 0x6A[14] = 1 */
tempval = rtw_read8(padapter, 0x6B);
tempval &= ~BIT(6);
rtw_write8(padapter, 0x6B, tempval);
}
}
static void Hal_EfusePowerSwitch(
struct adapter *padapter, u8 bWrite, u8 PwrState
)
{
u8 tempval;
u16 tmpV16;
if (PwrState) {
/* To avoid cannot access efuse registers after disable/enable several times during DTM test. */
/* Suggested by SD1 IsaacHsu. 2013.07.08, added by tynli. */
tempval = rtw_read8(padapter, SDIO_LOCAL_BASE|SDIO_REG_HSUS_CTRL);
if (tempval & BIT(0)) { /* SDIO local register is suspend */
u8 count = 0;
tempval &= ~BIT(0);
rtw_write8(padapter, SDIO_LOCAL_BASE|SDIO_REG_HSUS_CTRL, tempval);
/* check 0x86[1:0]= 10'2h, wait power state to leave suspend */
do {
tempval = rtw_read8(padapter, SDIO_LOCAL_BASE|SDIO_REG_HSUS_CTRL);
tempval &= 0x3;
if (tempval == 0x02)
break;
count++;
if (count >= 100)
break;
mdelay(10);
} while (1);
}
rtw_write8(padapter, REG_EFUSE_ACCESS_8723, EFUSE_ACCESS_ON_8723);
/* Reset: 0x0000h[28], default valid */
tmpV16 = rtw_read16(padapter, REG_SYS_FUNC_EN);
if (!(tmpV16 & FEN_ELDR)) {
tmpV16 |= FEN_ELDR;
rtw_write16(padapter, REG_SYS_FUNC_EN, tmpV16);
}
/* Clock: Gated(0x0008h[5]) 8M(0x0008h[1]) clock from ANA, default valid */
tmpV16 = rtw_read16(padapter, REG_SYS_CLKR);
if ((!(tmpV16 & LOADER_CLK_EN)) || (!(tmpV16 & ANA8M))) {
tmpV16 |= (LOADER_CLK_EN | ANA8M);
rtw_write16(padapter, REG_SYS_CLKR, tmpV16);
}
if (bWrite) {
/* Enable LDO 2.5V before read/write action */
tempval = rtw_read8(padapter, EFUSE_TEST+3);
tempval &= 0x0F;
tempval |= (VOLTAGE_V25 << 4);
rtw_write8(padapter, EFUSE_TEST+3, (tempval | 0x80));
/* rtw_write8(padapter, REG_EFUSE_ACCESS, EFUSE_ACCESS_ON); */
}
} else {
rtw_write8(padapter, REG_EFUSE_ACCESS, EFUSE_ACCESS_OFF);
if (bWrite) {
/* Disable LDO 2.5V after read/write action */
tempval = rtw_read8(padapter, EFUSE_TEST+3);
rtw_write8(padapter, EFUSE_TEST+3, (tempval & 0x7F));
}
}
}
static void hal_ReadEFuse_WiFi(
struct adapter *padapter,
u16 _offset,
u16 _size_byte,
u8 *pbuf,
bool bPseudoTest
)
{
#ifdef HAL_EFUSE_MEMORY
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct efuse_hal *pEfuseHal = &pHalData->EfuseHal;
#endif
u8 *efuseTbl = NULL;
u16 eFuse_Addr = 0;
u8 offset, wden;
u8 efuseHeader, efuseExtHdr, efuseData;
u16 i, total, used;
u8 efuse_usage = 0;
/* */
/* Do NOT excess total size of EFuse table. Added by Roger, 2008.11.10. */
/* */
if ((_offset + _size_byte) > EFUSE_MAX_MAP_LEN)
return;
efuseTbl = rtw_malloc(EFUSE_MAX_MAP_LEN);
if (!efuseTbl)
return;
/* 0xff will be efuse default value instead of 0x00. */
memset(efuseTbl, 0xFF, EFUSE_MAX_MAP_LEN);
/* switch bank back to bank 0 for later BT and wifi use. */
hal_EfuseSwitchToBank(padapter, 0, bPseudoTest);
while (AVAILABLE_EFUSE_ADDR(eFuse_Addr)) {
efuse_OneByteRead(padapter, eFuse_Addr++, &efuseHeader, bPseudoTest);
if (efuseHeader == 0xFF)
break;
/* Check PG header for section num. */
if (EXT_HEADER(efuseHeader)) { /* extended header */
offset = GET_HDR_OFFSET_2_0(efuseHeader);
efuse_OneByteRead(padapter, eFuse_Addr++, &efuseExtHdr, bPseudoTest);
if (ALL_WORDS_DISABLED(efuseExtHdr))
continue;
offset |= ((efuseExtHdr & 0xF0) >> 1);
wden = (efuseExtHdr & 0x0F);
} else {
offset = ((efuseHeader >> 4) & 0x0f);
wden = (efuseHeader & 0x0f);
}
if (offset < EFUSE_MAX_SECTION_8723B) {
u16 addr;
/* Get word enable value from PG header */
addr = offset * PGPKT_DATA_SIZE;
for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
/* Check word enable condition in the section */
if (!(wden & (0x01<<i))) {
efuse_OneByteRead(padapter, eFuse_Addr++, &efuseData, bPseudoTest);
efuseTbl[addr] = efuseData;
efuse_OneByteRead(padapter, eFuse_Addr++, &efuseData, bPseudoTest);
efuseTbl[addr+1] = efuseData;
}
addr += 2;
}
} else {
eFuse_Addr += Efuse_CalculateWordCnts(wden)*2;
}
}
/* Copy from Efuse map to output pointer memory!!! */
for (i = 0; i < _size_byte; i++)
pbuf[i] = efuseTbl[_offset+i];
/* Calculate Efuse utilization */
EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, &total, bPseudoTest);
used = eFuse_Addr - 1;
efuse_usage = (u8)((used*100)/total);
if (bPseudoTest) {
#ifdef HAL_EFUSE_MEMORY
pEfuseHal->fakeEfuseUsedBytes = used;
#else
fakeEfuseUsedBytes = used;
#endif
} else {
rtw_hal_set_hwreg(padapter, HW_VAR_EFUSE_BYTES, (u8 *)&used);
rtw_hal_set_hwreg(padapter, HW_VAR_EFUSE_USAGE, (u8 *)&efuse_usage);
}
kfree(efuseTbl);
}
static void hal_ReadEFuse_BT(
struct adapter *padapter,
u16 _offset,
u16 _size_byte,
u8 *pbuf,
bool bPseudoTest
)
{
#ifdef HAL_EFUSE_MEMORY
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct efuse_hal *pEfuseHal = &pHalData->EfuseHal;
#endif
u8 *efuseTbl;
u8 bank;
u16 eFuse_Addr;
u8 efuseHeader, efuseExtHdr, efuseData;
u8 offset, wden;
u16 i, total, used;
u8 efuse_usage;
/* */
/* Do NOT excess total size of EFuse table. Added by Roger, 2008.11.10. */
/* */
if ((_offset + _size_byte) > EFUSE_BT_MAP_LEN)
return;
efuseTbl = rtw_malloc(EFUSE_BT_MAP_LEN);
if (!efuseTbl)
return;
/* 0xff will be efuse default value instead of 0x00. */
memset(efuseTbl, 0xFF, EFUSE_BT_MAP_LEN);
EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_BANK, &total, bPseudoTest);
for (bank = 1; bank < 3; bank++) { /* 8723b Max bake 0~2 */
if (hal_EfuseSwitchToBank(padapter, bank, bPseudoTest) == false)
goto exit;
eFuse_Addr = 0;
while (AVAILABLE_EFUSE_ADDR(eFuse_Addr)) {
efuse_OneByteRead(padapter, eFuse_Addr++, &efuseHeader, bPseudoTest);
if (efuseHeader == 0xFF)
break;
/* Check PG header for section num. */
if (EXT_HEADER(efuseHeader)) { /* extended header */
offset = GET_HDR_OFFSET_2_0(efuseHeader);
efuse_OneByteRead(padapter, eFuse_Addr++, &efuseExtHdr, bPseudoTest);
if (ALL_WORDS_DISABLED(efuseExtHdr))
continue;
offset |= ((efuseExtHdr & 0xF0) >> 1);
wden = (efuseExtHdr & 0x0F);
} else {
offset = ((efuseHeader >> 4) & 0x0f);
wden = (efuseHeader & 0x0f);
}
if (offset < EFUSE_BT_MAX_SECTION) {
u16 addr;
addr = offset * PGPKT_DATA_SIZE;
for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
/* Check word enable condition in the section */
if (!(wden & (0x01<<i))) {
efuse_OneByteRead(padapter, eFuse_Addr++, &efuseData, bPseudoTest);
efuseTbl[addr] = efuseData;
efuse_OneByteRead(padapter, eFuse_Addr++, &efuseData, bPseudoTest);
efuseTbl[addr+1] = efuseData;
}
addr += 2;
}
} else {
eFuse_Addr += Efuse_CalculateWordCnts(wden)*2;
}
}
if ((eFuse_Addr - 1) < total)
break;
}
/* switch bank back to bank 0 for later BT and wifi use. */
hal_EfuseSwitchToBank(padapter, 0, bPseudoTest);
/* Copy from Efuse map to output pointer memory!!! */
for (i = 0; i < _size_byte; i++)
pbuf[i] = efuseTbl[_offset+i];
/* */
/* Calculate Efuse utilization. */
/* */
EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, &total, bPseudoTest);
used = (EFUSE_BT_REAL_BANK_CONTENT_LEN*(bank-1)) + eFuse_Addr - 1;
efuse_usage = (u8)((used*100)/total);
if (bPseudoTest) {
#ifdef HAL_EFUSE_MEMORY
pEfuseHal->fakeBTEfuseUsedBytes = used;
#else
fakeBTEfuseUsedBytes = used;
#endif
} else {
rtw_hal_set_hwreg(padapter, HW_VAR_EFUSE_BT_BYTES, (u8 *)&used);
rtw_hal_set_hwreg(padapter, HW_VAR_EFUSE_BT_USAGE, (u8 *)&efuse_usage);
}
exit:
kfree(efuseTbl);
}
static void Hal_ReadEFuse(
struct adapter *padapter,
u8 efuseType,
u16 _offset,
u16 _size_byte,
u8 *pbuf,
bool bPseudoTest
)
{
if (efuseType == EFUSE_WIFI)
hal_ReadEFuse_WiFi(padapter, _offset, _size_byte, pbuf, bPseudoTest);
else
hal_ReadEFuse_BT(padapter, _offset, _size_byte, pbuf, bPseudoTest);
}
static u16 hal_EfuseGetCurrentSize_WiFi(
struct adapter *padapter, bool bPseudoTest
)
{
#ifdef HAL_EFUSE_MEMORY
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct efuse_hal *pEfuseHal = &pHalData->EfuseHal;
#endif
u16 efuse_addr = 0;
u16 start_addr = 0; /* for debug */
u8 hoffset = 0, hworden = 0;
u8 efuse_data, word_cnts = 0;
u32 count = 0; /* for debug */
if (bPseudoTest) {
#ifdef HAL_EFUSE_MEMORY
efuse_addr = (u16)pEfuseHal->fakeEfuseUsedBytes;
#else
efuse_addr = (u16)fakeEfuseUsedBytes;
#endif
} else
rtw_hal_get_hwreg(padapter, HW_VAR_EFUSE_BYTES, (u8 *)&efuse_addr);
start_addr = efuse_addr;
/* switch bank back to bank 0 for later BT and wifi use. */
hal_EfuseSwitchToBank(padapter, 0, bPseudoTest);
count = 0;
while (AVAILABLE_EFUSE_ADDR(efuse_addr)) {
if (efuse_OneByteRead(padapter, efuse_addr, &efuse_data, bPseudoTest) == false)
goto error;
if (efuse_data == 0xFF)
break;
if ((start_addr != 0) && (efuse_addr == start_addr)) {
count++;
efuse_data = 0xFF;
if (count < 4) {
/* try again! */
if (count > 2) {
/* try again form address 0 */
efuse_addr = 0;
start_addr = 0;
}
continue;
}
goto error;
}
if (EXT_HEADER(efuse_data)) {
hoffset = GET_HDR_OFFSET_2_0(efuse_data);
efuse_addr++;
efuse_OneByteRead(padapter, efuse_addr, &efuse_data, bPseudoTest);
if (ALL_WORDS_DISABLED(efuse_data))
continue;
hoffset |= ((efuse_data & 0xF0) >> 1);
hworden = efuse_data & 0x0F;
} else {
hoffset = (efuse_data>>4) & 0x0F;
hworden = efuse_data & 0x0F;
}
word_cnts = Efuse_CalculateWordCnts(hworden);
efuse_addr += (word_cnts*2)+1;
}
if (bPseudoTest) {
#ifdef HAL_EFUSE_MEMORY
pEfuseHal->fakeEfuseUsedBytes = efuse_addr;
#else
fakeEfuseUsedBytes = efuse_addr;
#endif
} else
rtw_hal_set_hwreg(padapter, HW_VAR_EFUSE_BYTES, (u8 *)&efuse_addr);
goto exit;
error:
/* report max size to prevent write efuse */
EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, &efuse_addr, bPseudoTest);
exit:
return efuse_addr;
}
static u16 hal_EfuseGetCurrentSize_BT(struct adapter *padapter, u8 bPseudoTest)
{
#ifdef HAL_EFUSE_MEMORY
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct efuse_hal *pEfuseHal = &pHalData->EfuseHal;
#endif
u16 btusedbytes;
u16 efuse_addr;
u8 bank, startBank;
u8 hoffset = 0, hworden = 0;
u8 efuse_data, word_cnts = 0;
u16 retU2 = 0;
if (bPseudoTest) {
#ifdef HAL_EFUSE_MEMORY
btusedbytes = pEfuseHal->fakeBTEfuseUsedBytes;
#else
btusedbytes = fakeBTEfuseUsedBytes;
#endif
} else
rtw_hal_get_hwreg(padapter, HW_VAR_EFUSE_BT_BYTES, (u8 *)&btusedbytes);
efuse_addr = (u16)((btusedbytes%EFUSE_BT_REAL_BANK_CONTENT_LEN));
startBank = (u8)(1+(btusedbytes/EFUSE_BT_REAL_BANK_CONTENT_LEN));
EFUSE_GetEfuseDefinition(padapter, EFUSE_BT, TYPE_AVAILABLE_EFUSE_BYTES_BANK, &retU2, bPseudoTest);
for (bank = startBank; bank < 3; bank++) {
if (hal_EfuseSwitchToBank(padapter, bank, bPseudoTest) == false)
/* bank = EFUSE_MAX_BANK; */
break;
/* only when bank is switched we have to reset the efuse_addr. */
if (bank != startBank)
efuse_addr = 0;
#if 1
while (AVAILABLE_EFUSE_ADDR(efuse_addr)) {
if (efuse_OneByteRead(padapter, efuse_addr,
&efuse_data, bPseudoTest) == false)
/* bank = EFUSE_MAX_BANK; */
break;
if (efuse_data == 0xFF)
break;
if (EXT_HEADER(efuse_data)) {
hoffset = GET_HDR_OFFSET_2_0(efuse_data);
efuse_addr++;
efuse_OneByteRead(padapter, efuse_addr, &efuse_data, bPseudoTest);
if (ALL_WORDS_DISABLED(efuse_data)) {
efuse_addr++;
continue;
}
/* hoffset = ((hoffset & 0xE0) >> 5) | ((efuse_data & 0xF0) >> 1); */
hoffset |= ((efuse_data & 0xF0) >> 1);
hworden = efuse_data & 0x0F;
} else {
hoffset = (efuse_data>>4) & 0x0F;
hworden = efuse_data & 0x0F;
}
word_cnts = Efuse_CalculateWordCnts(hworden);
/* read next header */
efuse_addr += (word_cnts*2)+1;
}
#else
while (
bContinual &&
efuse_OneByteRead(padapter, efuse_addr, &efuse_data, bPseudoTest) &&
AVAILABLE_EFUSE_ADDR(efuse_addr)
) {
if (efuse_data != 0xFF) {
if ((efuse_data&0x1F) == 0x0F) { /* extended header */
hoffset = efuse_data;
efuse_addr++;
efuse_OneByteRead(padapter, efuse_addr, &efuse_data, bPseudoTest);
if ((efuse_data & 0x0F) == 0x0F) {
efuse_addr++;
continue;
} else {
hoffset = ((hoffset & 0xE0) >> 5) | ((efuse_data & 0xF0) >> 1);
hworden = efuse_data & 0x0F;
}
} else {
hoffset = (efuse_data>>4) & 0x0F;
hworden = efuse_data & 0x0F;
}
word_cnts = Efuse_CalculateWordCnts(hworden);
/* read next header */
efuse_addr = efuse_addr + (word_cnts*2)+1;
} else
bContinual = false;
}
#endif
/* Check if we need to check next bank efuse */
if (efuse_addr < retU2)
break; /* don't need to check next bank. */
}
retU2 = ((bank-1)*EFUSE_BT_REAL_BANK_CONTENT_LEN)+efuse_addr;
if (bPseudoTest) {
pEfuseHal->fakeBTEfuseUsedBytes = retU2;
} else {
pEfuseHal->BTEfuseUsedBytes = retU2;
}
return retU2;
}
static u16 Hal_EfuseGetCurrentSize(
struct adapter *padapter, u8 efuseType, bool bPseudoTest
)
{
u16 ret = 0;
if (efuseType == EFUSE_WIFI)
ret = hal_EfuseGetCurrentSize_WiFi(padapter, bPseudoTest);
else
ret = hal_EfuseGetCurrentSize_BT(padapter, bPseudoTest);
return ret;
}
static u8 Hal_EfuseWordEnableDataWrite(
struct adapter *padapter,
u16 efuse_addr,
u8 word_en,
u8 *data,
bool bPseudoTest
)
{
u16 tmpaddr = 0;
u16 start_addr = efuse_addr;
u8 badworden = 0x0F;
u8 tmpdata[PGPKT_DATA_SIZE];
memset(tmpdata, 0xFF, PGPKT_DATA_SIZE);
if (!(word_en & BIT(0))) {
tmpaddr = start_addr;
efuse_OneByteWrite(padapter, start_addr++, data[0], bPseudoTest);
efuse_OneByteWrite(padapter, start_addr++, data[1], bPseudoTest);
efuse_OneByteRead(padapter, tmpaddr, &tmpdata[0], bPseudoTest);
efuse_OneByteRead(padapter, tmpaddr+1, &tmpdata[1], bPseudoTest);
if ((data[0] != tmpdata[0]) || (data[1] != tmpdata[1])) {
badworden &= (~BIT(0));
}
}
if (!(word_en & BIT(1))) {
tmpaddr = start_addr;
efuse_OneByteWrite(padapter, start_addr++, data[2], bPseudoTest);
efuse_OneByteWrite(padapter, start_addr++, data[3], bPseudoTest);
efuse_OneByteRead(padapter, tmpaddr, &tmpdata[2], bPseudoTest);
efuse_OneByteRead(padapter, tmpaddr+1, &tmpdata[3], bPseudoTest);
if ((data[2] != tmpdata[2]) || (data[3] != tmpdata[3])) {
badworden &= (~BIT(1));
}
}
if (!(word_en & BIT(2))) {
tmpaddr = start_addr;
efuse_OneByteWrite(padapter, start_addr++, data[4], bPseudoTest);
efuse_OneByteWrite(padapter, start_addr++, data[5], bPseudoTest);
efuse_OneByteRead(padapter, tmpaddr, &tmpdata[4], bPseudoTest);
efuse_OneByteRead(padapter, tmpaddr+1, &tmpdata[5], bPseudoTest);
if ((data[4] != tmpdata[4]) || (data[5] != tmpdata[5])) {
badworden &= (~BIT(2));
}
}
if (!(word_en & BIT(3))) {
tmpaddr = start_addr;
efuse_OneByteWrite(padapter, start_addr++, data[6], bPseudoTest);
efuse_OneByteWrite(padapter, start_addr++, data[7], bPseudoTest);
efuse_OneByteRead(padapter, tmpaddr, &tmpdata[6], bPseudoTest);
efuse_OneByteRead(padapter, tmpaddr+1, &tmpdata[7], bPseudoTest);
if ((data[6] != tmpdata[6]) || (data[7] != tmpdata[7])) {
badworden &= (~BIT(3));
}
}
return badworden;
}
static s32 Hal_EfusePgPacketRead(
struct adapter *padapter,
u8 offset,
u8 *data,
bool bPseudoTest
)
{
u8 efuse_data, word_cnts = 0;
u16 efuse_addr = 0;
u8 hoffset = 0, hworden = 0;
u8 i;
u8 max_section = 0;
s32 ret;
if (!data)
return false;
EFUSE_GetEfuseDefinition(padapter, EFUSE_WIFI, TYPE_EFUSE_MAX_SECTION, &max_section, bPseudoTest);
if (offset > max_section)
return false;
memset(data, 0xFF, PGPKT_DATA_SIZE);
ret = true;
/* */
/* <Roger_TODO> Efuse has been pre-programmed dummy 5Bytes at the end of Efuse by CP. */
/* Skip dummy parts to prevent unexpected data read from Efuse. */
/* By pass right now. 2009.02.19. */
/* */
while (AVAILABLE_EFUSE_ADDR(efuse_addr)) {
if (efuse_OneByteRead(padapter, efuse_addr++, &efuse_data, bPseudoTest) == false) {
ret = false;
break;
}
if (efuse_data == 0xFF)
break;
if (EXT_HEADER(efuse_data)) {
hoffset = GET_HDR_OFFSET_2_0(efuse_data);
efuse_OneByteRead(padapter, efuse_addr++, &efuse_data, bPseudoTest);
if (ALL_WORDS_DISABLED(efuse_data))
continue;
hoffset |= ((efuse_data & 0xF0) >> 1);
hworden = efuse_data & 0x0F;
} else {
hoffset = (efuse_data>>4) & 0x0F;
hworden = efuse_data & 0x0F;
}
if (hoffset == offset) {
for (i = 0; i < EFUSE_MAX_WORD_UNIT; i++) {
/* Check word enable condition in the section */
if (!(hworden & (0x01<<i))) {
efuse_OneByteRead(padapter, efuse_addr++, &efuse_data, bPseudoTest);
data[i*2] = efuse_data;
efuse_OneByteRead(padapter, efuse_addr++, &efuse_data, bPseudoTest);
data[(i*2)+1] = efuse_data;
}
}
} else {
word_cnts = Efuse_CalculateWordCnts(hworden);
efuse_addr += word_cnts*2;
}
}
return ret;
}
static u8 hal_EfusePgCheckAvailableAddr(
struct adapter *padapter, u8 efuseType, u8 bPseudoTest
)
{
u16 max_available = 0;
u16 current_size;
EFUSE_GetEfuseDefinition(padapter, efuseType, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, &max_available, bPseudoTest);
current_size = Efuse_GetCurrentSize(padapter, efuseType, bPseudoTest);
if (current_size >= max_available)
return false;
return true;
}
static void hal_EfuseConstructPGPkt(
u8 offset,
u8 word_en,
u8 *pData,
struct pgpkt_struct *pTargetPkt
)
{
memset(pTargetPkt->data, 0xFF, PGPKT_DATA_SIZE);
pTargetPkt->offset = offset;
pTargetPkt->word_en = word_en;
efuse_WordEnableDataRead(word_en, pData, pTargetPkt->data);
pTargetPkt->word_cnts = Efuse_CalculateWordCnts(pTargetPkt->word_en);
}
static u8 hal_EfusePartialWriteCheck(
struct adapter *padapter,
u8 efuseType,
u16 *pAddr,
struct pgpkt_struct *pTargetPkt,
u8 bPseudoTest
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct efuse_hal *pEfuseHal = &pHalData->EfuseHal;
u8 bRet = false;
u16 startAddr = 0, efuse_max_available_len = 0, efuse_max = 0;
u8 efuse_data = 0;
EFUSE_GetEfuseDefinition(padapter, efuseType, TYPE_AVAILABLE_EFUSE_BYTES_TOTAL, &efuse_max_available_len, bPseudoTest);
EFUSE_GetEfuseDefinition(padapter, efuseType, TYPE_EFUSE_CONTENT_LEN_BANK, &efuse_max, bPseudoTest);
if (efuseType == EFUSE_WIFI) {
if (bPseudoTest) {
#ifdef HAL_EFUSE_MEMORY
startAddr = (u16)pEfuseHal->fakeEfuseUsedBytes;
#else
startAddr = (u16)fakeEfuseUsedBytes;
#endif
} else
rtw_hal_get_hwreg(padapter, HW_VAR_EFUSE_BYTES, (u8 *)&startAddr);
} else {
if (bPseudoTest) {
#ifdef HAL_EFUSE_MEMORY
startAddr = (u16)pEfuseHal->fakeBTEfuseUsedBytes;
#else
startAddr = (u16)fakeBTEfuseUsedBytes;
#endif
} else
rtw_hal_get_hwreg(padapter, HW_VAR_EFUSE_BT_BYTES, (u8 *)&startAddr);
}
startAddr %= efuse_max;
while (1) {
if (startAddr >= efuse_max_available_len) {
bRet = false;
break;
}
if (efuse_OneByteRead(padapter, startAddr, &efuse_data, bPseudoTest) && (efuse_data != 0xFF)) {
#if 1
bRet = false;
break;
#else
if (EXT_HEADER(efuse_data)) {
cur_header = efuse_data;
startAddr++;
efuse_OneByteRead(padapter, startAddr, &efuse_data, bPseudoTest);
if (ALL_WORDS_DISABLED(efuse_data)) {
bRet = false;
break;
} else {
curPkt.offset = ((cur_header & 0xE0) >> 5) | ((efuse_data & 0xF0) >> 1);
curPkt.word_en = efuse_data & 0x0F;
}
} else {
cur_header = efuse_data;
curPkt.offset = (cur_header>>4) & 0x0F;
curPkt.word_en = cur_header & 0x0F;
}
curPkt.word_cnts = Efuse_CalculateWordCnts(curPkt.word_en);
/* if same header is found but no data followed */
/* write some part of data followed by the header. */
if (
(curPkt.offset == pTargetPkt->offset) &&
(hal_EfuseCheckIfDatafollowed(padapter, curPkt.word_cnts, startAddr+1, bPseudoTest) == false) &&
wordEnMatched(pTargetPkt, &curPkt, &matched_wden) == true
) {
/* Here to write partial data */
badworden = Efuse_WordEnableDataWrite(padapter, startAddr+1, matched_wden, pTargetPkt->data, bPseudoTest);
if (badworden != 0x0F) {
u32 PgWriteSuccess = 0;
/* if write fail on some words, write these bad words again */
if (efuseType == EFUSE_WIFI)
PgWriteSuccess = Efuse_PgPacketWrite(padapter, pTargetPkt->offset, badworden, pTargetPkt->data, bPseudoTest);
else
PgWriteSuccess = Efuse_PgPacketWrite_BT(padapter, pTargetPkt->offset, badworden, pTargetPkt->data, bPseudoTest);
if (!PgWriteSuccess) {
bRet = false; /* write fail, return */
break;
}
}
/* partial write ok, update the target packet for later use */
for (i = 0; i < 4; i++) {
if ((matched_wden & (0x1<<i)) == 0) { /* this word has been written */
pTargetPkt->word_en |= (0x1<<i); /* disable the word */
}
}
pTargetPkt->word_cnts = Efuse_CalculateWordCnts(pTargetPkt->word_en);
}
/* read from next header */
startAddr = startAddr + (curPkt.word_cnts*2) + 1;
#endif
} else {
/* not used header, 0xff */
*pAddr = startAddr;
bRet = true;
break;
}
}
return bRet;
}
static u8 hal_EfusePgPacketWrite1ByteHeader(
struct adapter *padapter,
u8 efuseType,
u16 *pAddr,
struct pgpkt_struct *pTargetPkt,
u8 bPseudoTest
)
{
u8 pg_header = 0, tmp_header = 0;
u16 efuse_addr = *pAddr;
u8 repeatcnt = 0;
pg_header = ((pTargetPkt->offset << 4) & 0xf0) | pTargetPkt->word_en;
do {
efuse_OneByteWrite(padapter, efuse_addr, pg_header, bPseudoTest);
efuse_OneByteRead(padapter, efuse_addr, &tmp_header, bPseudoTest);
if (tmp_header != 0xFF)
break;
if (repeatcnt++ > EFUSE_REPEAT_THRESHOLD_)
return false;
} while (1);
if (tmp_header != pg_header)
return false;
*pAddr = efuse_addr;
return true;
}
static u8 hal_EfusePgPacketWrite2ByteHeader(
struct adapter *padapter,
u8 efuseType,
u16 *pAddr,
struct pgpkt_struct *pTargetPkt,
u8 bPseudoTest
)
{
u16 efuse_addr, efuse_max_available_len = 0;
u8 pg_header = 0, tmp_header = 0;
u8 repeatcnt = 0;
EFUSE_GetEfuseDefinition(padapter, efuseType, TYPE_AVAILABLE_EFUSE_BYTES_BANK, &efuse_max_available_len, bPseudoTest);
efuse_addr = *pAddr;
if (efuse_addr >= efuse_max_available_len)
return false;
pg_header = ((pTargetPkt->offset & 0x07) << 5) | 0x0F;
do {
efuse_OneByteWrite(padapter, efuse_addr, pg_header, bPseudoTest);
efuse_OneByteRead(padapter, efuse_addr, &tmp_header, bPseudoTest);
if (tmp_header != 0xFF)
break;
if (repeatcnt++ > EFUSE_REPEAT_THRESHOLD_)
return false;
} while (1);
if (tmp_header != pg_header)
return false;
/* to write ext_header */
efuse_addr++;
pg_header = ((pTargetPkt->offset & 0x78) << 1) | pTargetPkt->word_en;
do {
efuse_OneByteWrite(padapter, efuse_addr, pg_header, bPseudoTest);
efuse_OneByteRead(padapter, efuse_addr, &tmp_header, bPseudoTest);
if (tmp_header != 0xFF)
break;
if (repeatcnt++ > EFUSE_REPEAT_THRESHOLD_)
return false;
} while (1);
if (tmp_header != pg_header) /* offset PG fail */
return false;
*pAddr = efuse_addr;
return true;
}
static u8 hal_EfusePgPacketWriteHeader(
struct adapter *padapter,
u8 efuseType,
u16 *pAddr,
struct pgpkt_struct *pTargetPkt,
u8 bPseudoTest
)
{
u8 bRet = false;
if (pTargetPkt->offset >= EFUSE_MAX_SECTION_BASE)
bRet = hal_EfusePgPacketWrite2ByteHeader(padapter, efuseType, pAddr, pTargetPkt, bPseudoTest);
else
bRet = hal_EfusePgPacketWrite1ByteHeader(padapter, efuseType, pAddr, pTargetPkt, bPseudoTest);
return bRet;
}
static u8 hal_EfusePgPacketWriteData(
struct adapter *padapter,
u8 efuseType,
u16 *pAddr,
struct pgpkt_struct *pTargetPkt,
u8 bPseudoTest
)
{
u16 efuse_addr;
u8 badworden;
efuse_addr = *pAddr;
badworden = Efuse_WordEnableDataWrite(padapter, efuse_addr+1, pTargetPkt->word_en, pTargetPkt->data, bPseudoTest);
if (badworden != 0x0F)
return false;
return true;
}
static s32 Hal_EfusePgPacketWrite(
struct adapter *padapter,
u8 offset,
u8 word_en,
u8 *pData,
bool bPseudoTest
)
{
struct pgpkt_struct targetPkt;
u16 startAddr = 0;
u8 efuseType = EFUSE_WIFI;
if (!hal_EfusePgCheckAvailableAddr(padapter, efuseType, bPseudoTest))
return false;
hal_EfuseConstructPGPkt(offset, word_en, pData, &targetPkt);
if (!hal_EfusePartialWriteCheck(padapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
return false;
if (!hal_EfusePgPacketWriteHeader(padapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
return false;
if (!hal_EfusePgPacketWriteData(padapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
return false;
return true;
}
static bool Hal_EfusePgPacketWrite_BT(
struct adapter *padapter,
u8 offset,
u8 word_en,
u8 *pData,
bool bPseudoTest
)
{
struct pgpkt_struct targetPkt;
u16 startAddr = 0;
u8 efuseType = EFUSE_BT;
if (!hal_EfusePgCheckAvailableAddr(padapter, efuseType, bPseudoTest))
return false;
hal_EfuseConstructPGPkt(offset, word_en, pData, &targetPkt);
if (!hal_EfusePartialWriteCheck(padapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
return false;
if (!hal_EfusePgPacketWriteHeader(padapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
return false;
if (!hal_EfusePgPacketWriteData(padapter, efuseType, &startAddr, &targetPkt, bPseudoTest))
return false;
return true;
}
static struct hal_version ReadChipVersion8723B(struct adapter *padapter)
{
u32 value32;
struct hal_version ChipVersion;
struct hal_com_data *pHalData;
/* YJ, TODO, move read chip type here */
pHalData = GET_HAL_DATA(padapter);
value32 = rtw_read32(padapter, REG_SYS_CFG);
ChipVersion.ICType = CHIP_8723B;
ChipVersion.ChipType = ((value32 & RTL_ID) ? TEST_CHIP : NORMAL_CHIP);
ChipVersion.VendorType = ((value32 & VENDOR_ID) ? CHIP_VENDOR_UMC : CHIP_VENDOR_TSMC);
ChipVersion.CUTVersion = (value32 & CHIP_VER_RTL_MASK)>>CHIP_VER_RTL_SHIFT; /* IC version (CUT) */
/* For regulator mode. by tynli. 2011.01.14 */
pHalData->RegulatorMode = ((value32 & SPS_SEL) ? RT_LDO_REGULATOR : RT_SWITCHING_REGULATOR);
value32 = rtw_read32(padapter, REG_GPIO_OUTSTS);
ChipVersion.ROMVer = ((value32 & RF_RL_ID) >> 20); /* ROM code version. */
/* For multi-function consideration. Added by Roger, 2010.10.06. */
pHalData->MultiFunc = RT_MULTI_FUNC_NONE;
value32 = rtw_read32(padapter, REG_MULTI_FUNC_CTRL);
pHalData->MultiFunc |= ((value32 & WL_FUNC_EN) ? RT_MULTI_FUNC_WIFI : 0);
pHalData->MultiFunc |= ((value32 & BT_FUNC_EN) ? RT_MULTI_FUNC_BT : 0);
pHalData->MultiFunc |= ((value32 & GPS_FUNC_EN) ? RT_MULTI_FUNC_GPS : 0);
pHalData->PolarityCtl = ((value32 & WL_HWPDN_SL) ? RT_POLARITY_HIGH_ACT : RT_POLARITY_LOW_ACT);
#if 1
dump_chip_info(ChipVersion);
#endif
pHalData->VersionID = ChipVersion;
return ChipVersion;
}
static void rtl8723b_read_chip_version(struct adapter *padapter)
{
ReadChipVersion8723B(padapter);
}
void rtl8723b_InitBeaconParameters(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u16 val16;
u8 val8;
val8 = DIS_TSF_UDT;
val16 = val8 | (val8 << 8); /* port0 and port1 */
/* Enable prot0 beacon function for PSTDMA */
val16 |= EN_BCN_FUNCTION;
rtw_write16(padapter, REG_BCN_CTRL, val16);
/* TODO: Remove these magic number */
rtw_write16(padapter, REG_TBTT_PROHIBIT, 0x6404);/* ms */
/* Firmware will control REG_DRVERLYINT when power saving is enable, */
/* so don't set this register on STA mode. */
if (check_fwstate(&padapter->mlmepriv, WIFI_STATION_STATE) == false)
rtw_write8(padapter, REG_DRVERLYINT, DRIVER_EARLY_INT_TIME_8723B); /* 5ms */
rtw_write8(padapter, REG_BCNDMATIM, BCN_DMA_ATIME_INT_TIME_8723B); /* 2ms */
/* Suggested by designer timchen. Change beacon AIFS to the largest number */
/* because test chip does not contension before sending beacon. by tynli. 2009.11.03 */
rtw_write16(padapter, REG_BCNTCFG, 0x660F);
pHalData->RegBcnCtrlVal = rtw_read8(padapter, REG_BCN_CTRL);
pHalData->RegTxPause = rtw_read8(padapter, REG_TXPAUSE);
pHalData->RegFwHwTxQCtrl = rtw_read8(padapter, REG_FWHW_TXQ_CTRL+2);
pHalData->RegReg542 = rtw_read8(padapter, REG_TBTT_PROHIBIT+2);
pHalData->RegCR_1 = rtw_read8(padapter, REG_CR+1);
}
void _InitBurstPktLen_8723BS(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
rtw_write8(Adapter, 0x4c7, rtw_read8(Adapter, 0x4c7)|BIT(7)); /* enable single pkt ampdu */
rtw_write8(Adapter, REG_RX_PKT_LIMIT_8723B, 0x18); /* for VHT packet length 11K */
rtw_write8(Adapter, REG_MAX_AGGR_NUM_8723B, 0x1F);
rtw_write8(Adapter, REG_PIFS_8723B, 0x00);
rtw_write8(Adapter, REG_FWHW_TXQ_CTRL_8723B, rtw_read8(Adapter, REG_FWHW_TXQ_CTRL)&(~BIT(7)));
if (pHalData->AMPDUBurstMode)
rtw_write8(Adapter, REG_AMPDU_BURST_MODE_8723B, 0x5F);
rtw_write8(Adapter, REG_AMPDU_MAX_TIME_8723B, 0x70);
/* ARFB table 9 for 11ac 5G 2SS */
rtw_write32(Adapter, REG_ARFR0_8723B, 0x00000010);
if (IS_NORMAL_CHIP(pHalData->VersionID))
rtw_write32(Adapter, REG_ARFR0_8723B+4, 0xfffff000);
else
rtw_write32(Adapter, REG_ARFR0_8723B+4, 0x3e0ff000);
/* ARFB table 10 for 11ac 5G 1SS */
rtw_write32(Adapter, REG_ARFR1_8723B, 0x00000010);
rtw_write32(Adapter, REG_ARFR1_8723B+4, 0x003ff000);
}
static void ResumeTxBeacon(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
pHalData->RegFwHwTxQCtrl |= BIT(6);
rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl);
rtw_write8(padapter, REG_TBTT_PROHIBIT+1, 0xff);
pHalData->RegReg542 |= BIT(0);
rtw_write8(padapter, REG_TBTT_PROHIBIT+2, pHalData->RegReg542);
}
static void StopTxBeacon(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
pHalData->RegFwHwTxQCtrl &= ~BIT(6);
rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl);
rtw_write8(padapter, REG_TBTT_PROHIBIT+1, 0x64);
pHalData->RegReg542 &= ~BIT(0);
rtw_write8(padapter, REG_TBTT_PROHIBIT+2, pHalData->RegReg542);
CheckFwRsvdPageContent(padapter); /* 2010.06.23. Added by tynli. */
}
static void _BeaconFunctionEnable(struct adapter *padapter, u8 Enable, u8 Linked)
{
rtw_write8(padapter, REG_BCN_CTRL, DIS_TSF_UDT | EN_BCN_FUNCTION | DIS_BCNQ_SUB);
rtw_write8(padapter, REG_RD_CTRL+1, 0x6F);
}
static void rtl8723b_SetBeaconRelatedRegisters(struct adapter *padapter)
{
u8 val8;
u32 value32;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
u32 bcn_ctrl_reg;
/* reset TSF, enable update TSF, correcting TSF On Beacon */
/* REG_BCN_INTERVAL */
/* REG_BCNDMATIM */
/* REG_ATIMWND */
/* REG_TBTT_PROHIBIT */
/* REG_DRVERLYINT */
/* REG_BCN_MAX_ERR */
/* REG_BCNTCFG (0x510) */
/* REG_DUAL_TSF_RST */
/* REG_BCN_CTRL (0x550) */
bcn_ctrl_reg = REG_BCN_CTRL;
/* */
/* ATIM window */
/* */
rtw_write16(padapter, REG_ATIMWND, 2);
/* */
/* Beacon interval (in unit of TU). */
/* */
rtw_write16(padapter, REG_BCN_INTERVAL, pmlmeinfo->bcn_interval);
rtl8723b_InitBeaconParameters(padapter);
rtw_write8(padapter, REG_SLOT, 0x09);
/* */
/* Reset TSF Timer to zero, added by Roger. 2008.06.24 */
/* */
value32 = rtw_read32(padapter, REG_TCR);
value32 &= ~TSFRST;
rtw_write32(padapter, REG_TCR, value32);
value32 |= TSFRST;
rtw_write32(padapter, REG_TCR, value32);
/* NOTE: Fix test chip's bug (about contention windows's randomness) */
if (check_fwstate(&padapter->mlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE|WIFI_AP_STATE) == true) {
rtw_write8(padapter, REG_RXTSF_OFFSET_CCK, 0x50);
rtw_write8(padapter, REG_RXTSF_OFFSET_OFDM, 0x50);
}
_BeaconFunctionEnable(padapter, true, true);
ResumeTxBeacon(padapter);
val8 = rtw_read8(padapter, bcn_ctrl_reg);
val8 |= DIS_BCNQ_SUB;
rtw_write8(padapter, bcn_ctrl_reg, val8);
}
static void rtl8723b_GetHalODMVar(
struct adapter *Adapter,
enum hal_odm_variable eVariable,
void *pValue1,
void *pValue2
)
{
GetHalODMVar(Adapter, eVariable, pValue1, pValue2);
}
static void rtl8723b_SetHalODMVar(
struct adapter *Adapter,
enum hal_odm_variable eVariable,
void *pValue1,
bool bSet
)
{
SetHalODMVar(Adapter, eVariable, pValue1, bSet);
}
static void hal_notch_filter_8723b(struct adapter *adapter, bool enable)
{
if (enable)
rtw_write8(adapter, rOFDM0_RxDSP+1, rtw_read8(adapter, rOFDM0_RxDSP+1) | BIT1);
else
rtw_write8(adapter, rOFDM0_RxDSP+1, rtw_read8(adapter, rOFDM0_RxDSP+1) & ~BIT1);
}
static void UpdateHalRAMask8723B(struct adapter *padapter, u32 mac_id, u8 rssi_level)
{
u32 mask, rate_bitmap;
u8 shortGIrate = false;
struct sta_info *psta;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_priv *pdmpriv = &pHalData->dmpriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
if (mac_id >= NUM_STA) /* CAM_SIZE */
return;
psta = pmlmeinfo->FW_sta_info[mac_id].psta;
if (!psta)
return;
shortGIrate = query_ra_short_GI(psta);
mask = psta->ra_mask;
rate_bitmap = 0xffffffff;
rate_bitmap = ODM_Get_Rate_Bitmap(&pHalData->odmpriv, mac_id, mask, rssi_level);
mask &= rate_bitmap;
rate_bitmap = hal_btcoex_GetRaMask(padapter);
mask &= ~rate_bitmap;
if (pHalData->fw_ractrl) {
rtl8723b_set_FwMacIdConfig_cmd(padapter, mac_id, psta->raid, psta->bw_mode, shortGIrate, mask);
}
/* set correct initial date rate for each mac_id */
pdmpriv->INIDATA_RATE[mac_id] = psta->init_rate;
}
void rtl8723b_set_hal_ops(struct hal_ops *pHalFunc)
{
pHalFunc->free_hal_data = &rtl8723b_free_hal_data;
pHalFunc->dm_init = &rtl8723b_init_dm_priv;
pHalFunc->read_chip_version = &rtl8723b_read_chip_version;
pHalFunc->UpdateRAMaskHandler = &UpdateHalRAMask8723B;
pHalFunc->set_bwmode_handler = &PHY_SetBWMode8723B;
pHalFunc->set_channel_handler = &PHY_SwChnl8723B;
pHalFunc->set_chnl_bw_handler = &PHY_SetSwChnlBWMode8723B;
pHalFunc->set_tx_power_level_handler = &PHY_SetTxPowerLevel8723B;
pHalFunc->get_tx_power_level_handler = &PHY_GetTxPowerLevel8723B;
pHalFunc->hal_dm_watchdog = &rtl8723b_HalDmWatchDog;
pHalFunc->hal_dm_watchdog_in_lps = &rtl8723b_HalDmWatchDog_in_LPS;
pHalFunc->SetBeaconRelatedRegistersHandler = &rtl8723b_SetBeaconRelatedRegisters;
pHalFunc->Add_RateATid = &rtl8723b_Add_RateATid;
pHalFunc->run_thread = &rtl8723b_start_thread;
pHalFunc->cancel_thread = &rtl8723b_stop_thread;
pHalFunc->read_bbreg = &PHY_QueryBBReg_8723B;
pHalFunc->write_bbreg = &PHY_SetBBReg_8723B;
pHalFunc->read_rfreg = &PHY_QueryRFReg_8723B;
pHalFunc->write_rfreg = &PHY_SetRFReg_8723B;
/* Efuse related function */
pHalFunc->BTEfusePowerSwitch = &Hal_BT_EfusePowerSwitch;
pHalFunc->EfusePowerSwitch = &Hal_EfusePowerSwitch;
pHalFunc->ReadEFuse = &Hal_ReadEFuse;
pHalFunc->EFUSEGetEfuseDefinition = &Hal_GetEfuseDefinition;
pHalFunc->EfuseGetCurrentSize = &Hal_EfuseGetCurrentSize;
pHalFunc->Efuse_PgPacketRead = &Hal_EfusePgPacketRead;
pHalFunc->Efuse_PgPacketWrite = &Hal_EfusePgPacketWrite;
pHalFunc->Efuse_WordEnableDataWrite = &Hal_EfuseWordEnableDataWrite;
pHalFunc->Efuse_PgPacketWrite_BT = &Hal_EfusePgPacketWrite_BT;
pHalFunc->GetHalODMVarHandler = &rtl8723b_GetHalODMVar;
pHalFunc->SetHalODMVarHandler = &rtl8723b_SetHalODMVar;
pHalFunc->xmit_thread_handler = &hal_xmit_handler;
pHalFunc->hal_notch_filter = &hal_notch_filter_8723b;
pHalFunc->c2h_handler = c2h_handler_8723b;
pHalFunc->c2h_id_filter_ccx = c2h_id_filter_ccx_8723b;
pHalFunc->fill_h2c_cmd = &FillH2CCmd8723B;
}
void rtl8723b_InitAntenna_Selection(struct adapter *padapter)
{
u8 val;
val = rtw_read8(padapter, REG_LEDCFG2);
/* Let 8051 take control antenna setting */
val |= BIT(7); /* DPDT_SEL_EN, 0x4C[23] */
rtw_write8(padapter, REG_LEDCFG2, val);
}
void rtl8723b_init_default_value(struct adapter *padapter)
{
struct hal_com_data *pHalData;
struct dm_priv *pdmpriv;
u8 i;
pHalData = GET_HAL_DATA(padapter);
pdmpriv = &pHalData->dmpriv;
padapter->registrypriv.wireless_mode = WIRELESS_11BG_24N;
/* init default value */
pHalData->fw_ractrl = false;
pHalData->bIQKInitialized = false;
if (!adapter_to_pwrctl(padapter)->bkeepfwalive)
pHalData->LastHMEBoxNum = 0;
pHalData->bIQKInitialized = false;
/* init dm default value */
pdmpriv->TM_Trigger = 0;/* for IQK */
/* pdmpriv->binitialized = false; */
/* pdmpriv->prv_traffic_idx = 3; */
/* pdmpriv->initialize = 0; */
pdmpriv->ThermalValue_HP_index = 0;
for (i = 0; i < HP_THERMAL_NUM; i++)
pdmpriv->ThermalValue_HP[i] = 0;
/* init Efuse variables */
pHalData->EfuseUsedBytes = 0;
pHalData->EfuseUsedPercentage = 0;
#ifdef HAL_EFUSE_MEMORY
pHalData->EfuseHal.fakeEfuseBank = 0;
pHalData->EfuseHal.fakeEfuseUsedBytes = 0;
memset(pHalData->EfuseHal.fakeEfuseContent, 0xFF, EFUSE_MAX_HW_SIZE);
memset(pHalData->EfuseHal.fakeEfuseInitMap, 0xFF, EFUSE_MAX_MAP_LEN);
memset(pHalData->EfuseHal.fakeEfuseModifiedMap, 0xFF, EFUSE_MAX_MAP_LEN);
pHalData->EfuseHal.BTEfuseUsedBytes = 0;
pHalData->EfuseHal.BTEfuseUsedPercentage = 0;
memset(pHalData->EfuseHal.BTEfuseContent, 0xFF, EFUSE_MAX_BT_BANK*EFUSE_MAX_HW_SIZE);
memset(pHalData->EfuseHal.BTEfuseInitMap, 0xFF, EFUSE_BT_MAX_MAP_LEN);
memset(pHalData->EfuseHal.BTEfuseModifiedMap, 0xFF, EFUSE_BT_MAX_MAP_LEN);
pHalData->EfuseHal.fakeBTEfuseUsedBytes = 0;
memset(pHalData->EfuseHal.fakeBTEfuseContent, 0xFF, EFUSE_MAX_BT_BANK*EFUSE_MAX_HW_SIZE);
memset(pHalData->EfuseHal.fakeBTEfuseInitMap, 0xFF, EFUSE_BT_MAX_MAP_LEN);
memset(pHalData->EfuseHal.fakeBTEfuseModifiedMap, 0xFF, EFUSE_BT_MAX_MAP_LEN);
#endif
}
u8 GetEEPROMSize8723B(struct adapter *padapter)
{
u8 size = 0;
u32 cr;
cr = rtw_read16(padapter, REG_9346CR);
/* 6: EEPROM used is 93C46, 4: boot from E-Fuse. */
size = (cr & BOOT_FROM_EEPROM) ? 6 : 4;
return size;
}
/* */
/* */
/* LLT R/W/Init function */
/* */
/* */
s32 rtl8723b_InitLLTTable(struct adapter *padapter)
{
unsigned long start, passing_time;
u32 val32;
s32 ret;
ret = _FAIL;
val32 = rtw_read32(padapter, REG_AUTO_LLT);
val32 |= BIT_AUTO_INIT_LLT;
rtw_write32(padapter, REG_AUTO_LLT, val32);
start = jiffies;
do {
val32 = rtw_read32(padapter, REG_AUTO_LLT);
if (!(val32 & BIT_AUTO_INIT_LLT)) {
ret = _SUCCESS;
break;
}
passing_time = jiffies_to_msecs(jiffies - start);
if (passing_time > 1000)
break;
msleep(1);
} while (1);
return ret;
}
static void hal_get_chnl_group_8723b(u8 channel, u8 *group)
{
if (1 <= channel && channel <= 2)
*group = 0;
else if (3 <= channel && channel <= 5)
*group = 1;
else if (6 <= channel && channel <= 8)
*group = 2;
else if (9 <= channel && channel <= 11)
*group = 3;
else if (12 <= channel && channel <= 14)
*group = 4;
}
void Hal_InitPGData(struct adapter *padapter, u8 *PROMContent)
{
struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
if (!pEEPROM->bautoload_fail_flag) { /* autoload OK. */
if (!pEEPROM->EepromOrEfuse) {
/* Read EFUSE real map to shadow. */
EFUSE_ShadowMapUpdate(padapter, EFUSE_WIFI, false);
memcpy((void *)PROMContent, (void *)pEEPROM->efuse_eeprom_data, HWSET_MAX_SIZE_8723B);
}
} else {/* autoload fail */
if (!pEEPROM->EepromOrEfuse)
EFUSE_ShadowMapUpdate(padapter, EFUSE_WIFI, false);
memcpy((void *)PROMContent, (void *)pEEPROM->efuse_eeprom_data, HWSET_MAX_SIZE_8723B);
}
}
void Hal_EfuseParseIDCode(struct adapter *padapter, u8 *hwinfo)
{
struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
/* struct hal_com_data *pHalData = GET_HAL_DATA(padapter); */
u16 EEPROMId;
/* Check 0x8129 again for making sure autoload status!! */
EEPROMId = le16_to_cpu(*((__le16 *)hwinfo));
if (EEPROMId != RTL_EEPROM_ID) {
pEEPROM->bautoload_fail_flag = true;
} else
pEEPROM->bautoload_fail_flag = false;
}
static void Hal_ReadPowerValueFromPROM_8723B(
struct adapter *Adapter,
struct TxPowerInfo24G *pwrInfo24G,
u8 *PROMContent,
bool AutoLoadFail
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
u32 rfPath, eeAddr = EEPROM_TX_PWR_INX_8723B, group, TxCount = 0;
memset(pwrInfo24G, 0, sizeof(struct TxPowerInfo24G));
if (0xFF == PROMContent[eeAddr+1])
AutoLoadFail = true;
if (AutoLoadFail) {
for (rfPath = 0; rfPath < MAX_RF_PATH; rfPath++) {
/* 2.4G default value */
for (group = 0; group < MAX_CHNL_GROUP_24G; group++) {
pwrInfo24G->IndexCCK_Base[rfPath][group] = EEPROM_DEFAULT_24G_INDEX;
pwrInfo24G->IndexBW40_Base[rfPath][group] = EEPROM_DEFAULT_24G_INDEX;
}
for (TxCount = 0; TxCount < MAX_TX_COUNT; TxCount++) {
if (TxCount == 0) {
pwrInfo24G->BW20_Diff[rfPath][0] = EEPROM_DEFAULT_24G_HT20_DIFF;
pwrInfo24G->OFDM_Diff[rfPath][0] = EEPROM_DEFAULT_24G_OFDM_DIFF;
} else {
pwrInfo24G->BW20_Diff[rfPath][TxCount] = EEPROM_DEFAULT_DIFF;
pwrInfo24G->BW40_Diff[rfPath][TxCount] = EEPROM_DEFAULT_DIFF;
pwrInfo24G->CCK_Diff[rfPath][TxCount] = EEPROM_DEFAULT_DIFF;
pwrInfo24G->OFDM_Diff[rfPath][TxCount] = EEPROM_DEFAULT_DIFF;
}
}
}
return;
}
pHalData->bTXPowerDataReadFromEEPORM = true; /* YJ, move, 120316 */
for (rfPath = 0; rfPath < MAX_RF_PATH; rfPath++) {
/* 2 2.4G default value */
for (group = 0; group < MAX_CHNL_GROUP_24G; group++) {
pwrInfo24G->IndexCCK_Base[rfPath][group] = PROMContent[eeAddr++];
if (pwrInfo24G->IndexCCK_Base[rfPath][group] == 0xFF)
pwrInfo24G->IndexCCK_Base[rfPath][group] = EEPROM_DEFAULT_24G_INDEX;
}
for (group = 0; group < MAX_CHNL_GROUP_24G-1; group++) {
pwrInfo24G->IndexBW40_Base[rfPath][group] = PROMContent[eeAddr++];
if (pwrInfo24G->IndexBW40_Base[rfPath][group] == 0xFF)
pwrInfo24G->IndexBW40_Base[rfPath][group] = EEPROM_DEFAULT_24G_INDEX;
}
for (TxCount = 0; TxCount < MAX_TX_COUNT; TxCount++) {
if (TxCount == 0) {
pwrInfo24G->BW40_Diff[rfPath][TxCount] = 0;
if (PROMContent[eeAddr] == 0xFF)
pwrInfo24G->BW20_Diff[rfPath][TxCount] = EEPROM_DEFAULT_24G_HT20_DIFF;
else {
pwrInfo24G->BW20_Diff[rfPath][TxCount] = (PROMContent[eeAddr]&0xf0)>>4;
if (pwrInfo24G->BW20_Diff[rfPath][TxCount] & BIT3) /* 4bit sign number to 8 bit sign number */
pwrInfo24G->BW20_Diff[rfPath][TxCount] |= 0xF0;
}
if (PROMContent[eeAddr] == 0xFF)
pwrInfo24G->OFDM_Diff[rfPath][TxCount] = EEPROM_DEFAULT_24G_OFDM_DIFF;
else {
pwrInfo24G->OFDM_Diff[rfPath][TxCount] = (PROMContent[eeAddr]&0x0f);
if (pwrInfo24G->OFDM_Diff[rfPath][TxCount] & BIT3) /* 4bit sign number to 8 bit sign number */
pwrInfo24G->OFDM_Diff[rfPath][TxCount] |= 0xF0;
}
pwrInfo24G->CCK_Diff[rfPath][TxCount] = 0;
eeAddr++;
} else {
if (PROMContent[eeAddr] == 0xFF)
pwrInfo24G->BW40_Diff[rfPath][TxCount] = EEPROM_DEFAULT_DIFF;
else {
pwrInfo24G->BW40_Diff[rfPath][TxCount] = (PROMContent[eeAddr]&0xf0)>>4;
if (pwrInfo24G->BW40_Diff[rfPath][TxCount] & BIT3) /* 4bit sign number to 8 bit sign number */
pwrInfo24G->BW40_Diff[rfPath][TxCount] |= 0xF0;
}
if (PROMContent[eeAddr] == 0xFF)
pwrInfo24G->BW20_Diff[rfPath][TxCount] = EEPROM_DEFAULT_DIFF;
else {
pwrInfo24G->BW20_Diff[rfPath][TxCount] = (PROMContent[eeAddr]&0x0f);
if (pwrInfo24G->BW20_Diff[rfPath][TxCount] & BIT3) /* 4bit sign number to 8 bit sign number */
pwrInfo24G->BW20_Diff[rfPath][TxCount] |= 0xF0;
}
eeAddr++;
if (PROMContent[eeAddr] == 0xFF)
pwrInfo24G->OFDM_Diff[rfPath][TxCount] = EEPROM_DEFAULT_DIFF;
else {
pwrInfo24G->OFDM_Diff[rfPath][TxCount] = (PROMContent[eeAddr]&0xf0)>>4;
if (pwrInfo24G->OFDM_Diff[rfPath][TxCount] & BIT3) /* 4bit sign number to 8 bit sign number */
pwrInfo24G->OFDM_Diff[rfPath][TxCount] |= 0xF0;
}
if (PROMContent[eeAddr] == 0xFF)
pwrInfo24G->CCK_Diff[rfPath][TxCount] = EEPROM_DEFAULT_DIFF;
else {
pwrInfo24G->CCK_Diff[rfPath][TxCount] = (PROMContent[eeAddr]&0x0f);
if (pwrInfo24G->CCK_Diff[rfPath][TxCount] & BIT3) /* 4bit sign number to 8 bit sign number */
pwrInfo24G->CCK_Diff[rfPath][TxCount] |= 0xF0;
}
eeAddr++;
}
}
}
}
void Hal_EfuseParseTxPowerInfo_8723B(
struct adapter *padapter, u8 *PROMContent, bool AutoLoadFail
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct TxPowerInfo24G pwrInfo24G;
u8 rfPath, ch, TxCount = 1;
Hal_ReadPowerValueFromPROM_8723B(padapter, &pwrInfo24G, PROMContent, AutoLoadFail);
for (rfPath = 0 ; rfPath < MAX_RF_PATH ; rfPath++) {
for (ch = 0 ; ch < CHANNEL_MAX_NUMBER; ch++) {
u8 group = 0;
hal_get_chnl_group_8723b(ch + 1, &group);
if (ch == 14-1) {
pHalData->Index24G_CCK_Base[rfPath][ch] = pwrInfo24G.IndexCCK_Base[rfPath][5];
pHalData->Index24G_BW40_Base[rfPath][ch] = pwrInfo24G.IndexBW40_Base[rfPath][group];
} else {
pHalData->Index24G_CCK_Base[rfPath][ch] = pwrInfo24G.IndexCCK_Base[rfPath][group];
pHalData->Index24G_BW40_Base[rfPath][ch] = pwrInfo24G.IndexBW40_Base[rfPath][group];
}
}
for (TxCount = 0; TxCount < MAX_TX_COUNT; TxCount++) {
pHalData->CCK_24G_Diff[rfPath][TxCount] = pwrInfo24G.CCK_Diff[rfPath][TxCount];
pHalData->OFDM_24G_Diff[rfPath][TxCount] = pwrInfo24G.OFDM_Diff[rfPath][TxCount];
pHalData->BW20_24G_Diff[rfPath][TxCount] = pwrInfo24G.BW20_Diff[rfPath][TxCount];
pHalData->BW40_24G_Diff[rfPath][TxCount] = pwrInfo24G.BW40_Diff[rfPath][TxCount];
}
}
/* 2010/10/19 MH Add Regulator recognize for CU. */
if (!AutoLoadFail) {
pHalData->EEPROMRegulatory = (PROMContent[EEPROM_RF_BOARD_OPTION_8723B]&0x7); /* bit0~2 */
if (PROMContent[EEPROM_RF_BOARD_OPTION_8723B] == 0xFF)
pHalData->EEPROMRegulatory = (EEPROM_DEFAULT_BOARD_OPTION&0x7); /* bit0~2 */
} else
pHalData->EEPROMRegulatory = 0;
}
void Hal_EfuseParseBTCoexistInfo_8723B(
struct adapter *padapter, u8 *hwinfo, bool AutoLoadFail
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 tempval;
u32 tmpu4;
if (!AutoLoadFail) {
tmpu4 = rtw_read32(padapter, REG_MULTI_FUNC_CTRL);
if (tmpu4 & BT_FUNC_EN)
pHalData->EEPROMBluetoothCoexist = true;
else
pHalData->EEPROMBluetoothCoexist = false;
pHalData->EEPROMBluetoothType = BT_RTL8723B;
tempval = hwinfo[EEPROM_RF_BT_SETTING_8723B];
if (tempval != 0xFF) {
pHalData->EEPROMBluetoothAntNum = tempval & BIT(0);
/* EFUSE_0xC3[6] == 0, S1(Main)-RF_PATH_A; */
/* EFUSE_0xC3[6] == 1, S0(Aux)-RF_PATH_B */
if (tempval & BIT(6))
pHalData->ant_path = RF_PATH_B;
else
pHalData->ant_path = RF_PATH_A;
} else {
pHalData->EEPROMBluetoothAntNum = Ant_x1;
if (pHalData->PackageType == PACKAGE_QFN68)
pHalData->ant_path = RF_PATH_B;
else
pHalData->ant_path = RF_PATH_A;
}
} else {
pHalData->EEPROMBluetoothCoexist = false;
pHalData->EEPROMBluetoothType = BT_RTL8723B;
pHalData->EEPROMBluetoothAntNum = Ant_x1;
pHalData->ant_path = RF_PATH_A;
}
if (padapter->registrypriv.ant_num > 0) {
switch (padapter->registrypriv.ant_num) {
case 1:
pHalData->EEPROMBluetoothAntNum = Ant_x1;
break;
case 2:
pHalData->EEPROMBluetoothAntNum = Ant_x2;
break;
default:
break;
}
}
hal_btcoex_SetBTCoexist(padapter, pHalData->EEPROMBluetoothCoexist);
hal_btcoex_SetPgAntNum(padapter, pHalData->EEPROMBluetoothAntNum == Ant_x2 ? 2 : 1);
if (pHalData->EEPROMBluetoothAntNum == Ant_x1)
hal_btcoex_SetSingleAntPath(padapter, pHalData->ant_path);
}
void Hal_EfuseParseEEPROMVer_8723B(
struct adapter *padapter, u8 *hwinfo, bool AutoLoadFail
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
if (!AutoLoadFail)
pHalData->EEPROMVersion = hwinfo[EEPROM_VERSION_8723B];
else
pHalData->EEPROMVersion = 1;
}
void Hal_EfuseParsePackageType_8723B(
struct adapter *padapter, u8 *hwinfo, bool AutoLoadFail
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 package;
u8 efuseContent;
Efuse_PowerSwitch(padapter, false, true);
efuse_OneByteRead(padapter, 0x1FB, &efuseContent, false);
Efuse_PowerSwitch(padapter, false, false);
package = efuseContent & 0x7;
switch (package) {
case 0x4:
pHalData->PackageType = PACKAGE_TFBGA79;
break;
case 0x5:
pHalData->PackageType = PACKAGE_TFBGA90;
break;
case 0x6:
pHalData->PackageType = PACKAGE_QFN68;
break;
case 0x7:
pHalData->PackageType = PACKAGE_TFBGA80;
break;
default:
pHalData->PackageType = PACKAGE_DEFAULT;
break;
}
}
void Hal_EfuseParseVoltage_8723B(
struct adapter *padapter, u8 *hwinfo, bool AutoLoadFail
)
{
struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
/* memcpy(pEEPROM->adjuseVoltageVal, &hwinfo[EEPROM_Voltage_ADDR_8723B], 1); */
pEEPROM->adjuseVoltageVal = (hwinfo[EEPROM_Voltage_ADDR_8723B] & 0xf0) >> 4;
}
void Hal_EfuseParseChnlPlan_8723B(
struct adapter *padapter, u8 *hwinfo, bool AutoLoadFail
)
{
padapter->mlmepriv.ChannelPlan = hal_com_config_channel_plan(
padapter,
hwinfo ? hwinfo[EEPROM_ChannelPlan_8723B] : 0xFF,
padapter->registrypriv.channel_plan,
RT_CHANNEL_DOMAIN_WORLD_NULL,
AutoLoadFail
);
Hal_ChannelPlanToRegulation(padapter, padapter->mlmepriv.ChannelPlan);
}
void Hal_EfuseParseCustomerID_8723B(
struct adapter *padapter, u8 *hwinfo, bool AutoLoadFail
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
if (!AutoLoadFail)
pHalData->EEPROMCustomerID = hwinfo[EEPROM_CustomID_8723B];
else
pHalData->EEPROMCustomerID = 0;
}
void Hal_EfuseParseAntennaDiversity_8723B(
struct adapter *padapter,
u8 *hwinfo,
bool AutoLoadFail
)
{
}
void Hal_EfuseParseXtal_8723B(
struct adapter *padapter, u8 *hwinfo, bool AutoLoadFail
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
if (!AutoLoadFail) {
pHalData->CrystalCap = hwinfo[EEPROM_XTAL_8723B];
if (pHalData->CrystalCap == 0xFF)
pHalData->CrystalCap = EEPROM_Default_CrystalCap_8723B; /* what value should 8812 set? */
} else
pHalData->CrystalCap = EEPROM_Default_CrystalCap_8723B;
}
void Hal_EfuseParseThermalMeter_8723B(
struct adapter *padapter, u8 *PROMContent, u8 AutoLoadFail
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
/* */
/* ThermalMeter from EEPROM */
/* */
if (!AutoLoadFail)
pHalData->EEPROMThermalMeter = PROMContent[EEPROM_THERMAL_METER_8723B];
else
pHalData->EEPROMThermalMeter = EEPROM_Default_ThermalMeter_8723B;
if ((pHalData->EEPROMThermalMeter == 0xff) || AutoLoadFail) {
pHalData->bAPKThermalMeterIgnore = true;
pHalData->EEPROMThermalMeter = EEPROM_Default_ThermalMeter_8723B;
}
}
void Hal_ReadRFGainOffset(
struct adapter *Adapter, u8 *PROMContent, bool AutoloadFail
)
{
/* */
/* BB_RF Gain Offset from EEPROM */
/* */
if (!AutoloadFail) {
Adapter->eeprompriv.EEPROMRFGainOffset = PROMContent[EEPROM_RF_GAIN_OFFSET];
Adapter->eeprompriv.EEPROMRFGainVal = EFUSE_Read1Byte(Adapter, EEPROM_RF_GAIN_VAL);
} else {
Adapter->eeprompriv.EEPROMRFGainOffset = 0;
Adapter->eeprompriv.EEPROMRFGainVal = 0xFF;
}
}
u8 BWMapping_8723B(struct adapter *Adapter, struct pkt_attrib *pattrib)
{
u8 BWSettingOfDesc = 0;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
if (pHalData->CurrentChannelBW == CHANNEL_WIDTH_40) {
if (pattrib->bwmode == CHANNEL_WIDTH_40)
BWSettingOfDesc = 1;
else
BWSettingOfDesc = 0;
} else
BWSettingOfDesc = 0;
/* if (pTcb->bBTTxPacket) */
/* BWSettingOfDesc = 0; */
return BWSettingOfDesc;
}
u8 SCMapping_8723B(struct adapter *Adapter, struct pkt_attrib *pattrib)
{
u8 SCSettingOfDesc = 0;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
if (pHalData->CurrentChannelBW == CHANNEL_WIDTH_40) {
if (pattrib->bwmode == CHANNEL_WIDTH_40) {
SCSettingOfDesc = HT_DATA_SC_DONOT_CARE;
} else if (pattrib->bwmode == CHANNEL_WIDTH_20) {
if (pHalData->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_UPPER) {
SCSettingOfDesc = HT_DATA_SC_20_UPPER_OF_40MHZ;
} else if (pHalData->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_LOWER) {
SCSettingOfDesc = HT_DATA_SC_20_LOWER_OF_40MHZ;
} else {
SCSettingOfDesc = HT_DATA_SC_DONOT_CARE;
}
}
} else {
SCSettingOfDesc = HT_DATA_SC_DONOT_CARE;
}
return SCSettingOfDesc;
}
static void rtl8723b_cal_txdesc_chksum(struct tx_desc *ptxdesc)
{
u16 *usPtr = (u16 *)ptxdesc;
u32 count;
u32 index;
u16 checksum = 0;
/* Clear first */
ptxdesc->txdw7 &= cpu_to_le32(0xffff0000);
/* checksum is always calculated by first 32 bytes, */
/* and it doesn't depend on TX DESC length. */
/* Thomas, Lucas@SD4, 20130515 */
count = 16;
for (index = 0; index < count; index++) {
checksum |= le16_to_cpu(*(__le16 *)(usPtr + index));
}
ptxdesc->txdw7 |= cpu_to_le32(checksum & 0x0000ffff);
}
static u8 fill_txdesc_sectype(struct pkt_attrib *pattrib)
{
u8 sectype = 0;
if ((pattrib->encrypt > 0) && !pattrib->bswenc) {
switch (pattrib->encrypt) {
/* SEC_TYPE */
case _WEP40_:
case _WEP104_:
case _TKIP_:
case _TKIP_WTMIC_:
sectype = 1;
break;
case _AES_:
sectype = 3;
break;
case _NO_PRIVACY_:
default:
break;
}
}
return sectype;
}
static void fill_txdesc_vcs_8723b(struct adapter *padapter, struct pkt_attrib *pattrib, struct txdesc_8723b *ptxdesc)
{
if (pattrib->vcs_mode) {
switch (pattrib->vcs_mode) {
case RTS_CTS:
ptxdesc->rtsen = 1;
/* ENABLE HW RTS */
ptxdesc->hw_rts_en = 1;
break;
case CTS_TO_SELF:
ptxdesc->cts2self = 1;
break;
case NONE_VCS:
default:
break;
}
ptxdesc->rtsrate = 8; /* RTS Rate =24M */
ptxdesc->rts_ratefb_lmt = 0xF;
if (padapter->mlmeextpriv.mlmext_info.preamble_mode == PREAMBLE_SHORT)
ptxdesc->rts_short = 1;
/* Set RTS BW */
if (pattrib->ht_en)
ptxdesc->rts_sc = SCMapping_8723B(padapter, pattrib);
}
}
static void fill_txdesc_phy_8723b(struct adapter *padapter, struct pkt_attrib *pattrib, struct txdesc_8723b *ptxdesc)
{
if (pattrib->ht_en) {
ptxdesc->data_bw = BWMapping_8723B(padapter, pattrib);
ptxdesc->data_sc = SCMapping_8723B(padapter, pattrib);
}
}
static void rtl8723b_fill_default_txdesc(
struct xmit_frame *pxmitframe, u8 *pbuf
)
{
struct adapter *padapter;
struct hal_com_data *pHalData;
struct mlme_ext_priv *pmlmeext;
struct mlme_ext_info *pmlmeinfo;
struct pkt_attrib *pattrib;
struct txdesc_8723b *ptxdesc;
s32 bmcst;
memset(pbuf, 0, TXDESC_SIZE);
padapter = pxmitframe->padapter;
pHalData = GET_HAL_DATA(padapter);
pmlmeext = &padapter->mlmeextpriv;
pmlmeinfo = &(pmlmeext->mlmext_info);
pattrib = &pxmitframe->attrib;
bmcst = is_multicast_ether_addr(pattrib->ra);
ptxdesc = (struct txdesc_8723b *)pbuf;
if (pxmitframe->frame_tag == DATA_FRAMETAG) {
u8 drv_userate = 0;
ptxdesc->macid = pattrib->mac_id; /* CAM_ID(MAC_ID) */
ptxdesc->rate_id = pattrib->raid;
ptxdesc->qsel = pattrib->qsel;
ptxdesc->seq = pattrib->seqnum;
ptxdesc->sectype = fill_txdesc_sectype(pattrib);
fill_txdesc_vcs_8723b(padapter, pattrib, ptxdesc);
if (pattrib->icmp_pkt == 1 && padapter->registrypriv.wifi_spec == 1)
drv_userate = 1;
if (
(pattrib->ether_type != 0x888e) &&
(pattrib->ether_type != 0x0806) &&
(pattrib->ether_type != 0x88B4) &&
(pattrib->dhcp_pkt != 1) &&
(drv_userate != 1)
) {
/* Non EAP & ARP & DHCP type data packet */
if (pattrib->ampdu_en) {
ptxdesc->agg_en = 1; /* AGG EN */
ptxdesc->max_agg_num = 0x1f;
ptxdesc->ampdu_density = pattrib->ampdu_spacing;
} else
ptxdesc->bk = 1; /* AGG BK */
fill_txdesc_phy_8723b(padapter, pattrib, ptxdesc);
ptxdesc->data_ratefb_lmt = 0x1F;
if (!pHalData->fw_ractrl) {
ptxdesc->userate = 1;
if (pHalData->dmpriv.INIDATA_RATE[pattrib->mac_id] & BIT(7))
ptxdesc->data_short = 1;
ptxdesc->datarate = pHalData->dmpriv.INIDATA_RATE[pattrib->mac_id] & 0x7F;
}
if (padapter->fix_rate != 0xFF) { /* modify data rate by iwpriv */
ptxdesc->userate = 1;
if (padapter->fix_rate & BIT(7))
ptxdesc->data_short = 1;
ptxdesc->datarate = (padapter->fix_rate & 0x7F);
ptxdesc->disdatafb = 1;
}
if (pattrib->ldpc)
ptxdesc->data_ldpc = 1;
if (pattrib->stbc)
ptxdesc->data_stbc = 1;
} else {
/* EAP data packet and ARP packet. */
/* Use the 1M data rate to send the EAP/ARP packet. */
/* This will maybe make the handshake smooth. */
ptxdesc->bk = 1; /* AGG BK */
ptxdesc->userate = 1; /* driver uses rate */
if (pmlmeinfo->preamble_mode == PREAMBLE_SHORT)
ptxdesc->data_short = 1;/* DATA_SHORT */
ptxdesc->datarate = MRateToHwRate(pmlmeext->tx_rate);
}
ptxdesc->usb_txagg_num = pxmitframe->agg_num;
} else if (pxmitframe->frame_tag == MGNT_FRAMETAG) {
ptxdesc->macid = pattrib->mac_id; /* CAM_ID(MAC_ID) */
ptxdesc->qsel = pattrib->qsel;
ptxdesc->rate_id = pattrib->raid; /* Rate ID */
ptxdesc->seq = pattrib->seqnum;
ptxdesc->userate = 1; /* driver uses rate, 1M */
ptxdesc->mbssid = pattrib->mbssid & 0xF;
ptxdesc->rty_lmt_en = 1; /* retry limit enable */
if (pattrib->retry_ctrl) {
ptxdesc->data_rt_lmt = 6;
} else {
ptxdesc->data_rt_lmt = 12;
}
ptxdesc->datarate = MRateToHwRate(pmlmeext->tx_rate);
/* CCX-TXRPT ack for xmit mgmt frames. */
if (pxmitframe->ack_report) {
ptxdesc->spe_rpt = 1;
ptxdesc->sw_define = (u8)(GET_PRIMARY_ADAPTER(padapter)->xmitpriv.seq_no);
}
} else {
ptxdesc->macid = pattrib->mac_id; /* CAM_ID(MAC_ID) */
ptxdesc->rate_id = pattrib->raid; /* Rate ID */
ptxdesc->qsel = pattrib->qsel;
ptxdesc->seq = pattrib->seqnum;
ptxdesc->userate = 1; /* driver uses rate */
ptxdesc->datarate = MRateToHwRate(pmlmeext->tx_rate);
}
ptxdesc->pktlen = pattrib->last_txcmdsz;
ptxdesc->offset = TXDESC_SIZE + OFFSET_SZ;
if (bmcst)
ptxdesc->bmc = 1;
/* 2009.11.05. tynli_test. Suggested by SD4 Filen for FW LPS.
* (1) The sequence number of each non-Qos frame / broadcast /
* multicast / mgnt frame should be controlled by Hw because Fw
* will also send null data which we cannot control when Fw LPS
* enable.
* --> default enable non-Qos data sequence number. 2010.06.23.
* by tynli.
* (2) Enable HW SEQ control for beacon packet, because we use
* Hw beacon.
* (3) Use HW Qos SEQ to control the seq num of Ext port non-Qos
* packets.
* 2010.06.23. Added by tynli.
*/
if (!pattrib->qos_en) /* Hw set sequence number */
ptxdesc->en_hwseq = 1; /* HWSEQ_EN */
}
/* Description:
*
* Parameters:
* pxmitframe xmitframe
* pbuf where to fill tx desc
*/
void rtl8723b_update_txdesc(struct xmit_frame *pxmitframe, u8 *pbuf)
{
struct tx_desc *pdesc;
rtl8723b_fill_default_txdesc(pxmitframe, pbuf);
pdesc = (struct tx_desc *)pbuf;
rtl8723b_cal_txdesc_chksum(pdesc);
}
/* */
/* Description: In normal chip, we should send some packet to Hw which will be used by Fw */
/* in FW LPS mode. The function is to fill the Tx descriptor of this packets, then */
/* Fw can tell Hw to send these packet derectly. */
/* Added by tynli. 2009.10.15. */
/* */
/* type1:pspoll, type2:null */
void rtl8723b_fill_fake_txdesc(
struct adapter *padapter,
u8 *pDesc,
u32 BufferLen,
u8 IsPsPoll,
u8 IsBTQosNull,
u8 bDataFrame
)
{
/* Clear all status */
memset(pDesc, 0, TXDESC_SIZE);
SET_TX_DESC_FIRST_SEG_8723B(pDesc, 1); /* bFirstSeg; */
SET_TX_DESC_LAST_SEG_8723B(pDesc, 1); /* bLastSeg; */
SET_TX_DESC_OFFSET_8723B(pDesc, 0x28); /* Offset = 32 */
SET_TX_DESC_PKT_SIZE_8723B(pDesc, BufferLen); /* Buffer size + command header */
SET_TX_DESC_QUEUE_SEL_8723B(pDesc, QSLT_MGNT); /* Fixed queue of Mgnt queue */
/* Set NAVUSEHDR to prevent Ps-poll AId filed to be changed to error value by Hw. */
if (IsPsPoll) {
SET_TX_DESC_NAV_USE_HDR_8723B(pDesc, 1);
} else {
SET_TX_DESC_HWSEQ_EN_8723B(pDesc, 1); /* Hw set sequence number */
SET_TX_DESC_HWSEQ_SEL_8723B(pDesc, 0);
}
if (IsBTQosNull) {
SET_TX_DESC_BT_INT_8723B(pDesc, 1);
}
SET_TX_DESC_USE_RATE_8723B(pDesc, 1); /* use data rate which is set by Sw */
SET_TX_DESC_OWN_8723B((u8 *)pDesc, 1);
SET_TX_DESC_TX_RATE_8723B(pDesc, DESC8723B_RATE1M);
/* */
/* Encrypt the data frame if under security mode excepct null data. Suggested by CCW. */
/* */
if (bDataFrame) {
u32 EncAlg;
EncAlg = padapter->securitypriv.dot11PrivacyAlgrthm;
switch (EncAlg) {
case _NO_PRIVACY_:
SET_TX_DESC_SEC_TYPE_8723B(pDesc, 0x0);
break;
case _WEP40_:
case _WEP104_:
case _TKIP_:
SET_TX_DESC_SEC_TYPE_8723B(pDesc, 0x1);
break;
case _SMS4_:
SET_TX_DESC_SEC_TYPE_8723B(pDesc, 0x2);
break;
case _AES_:
SET_TX_DESC_SEC_TYPE_8723B(pDesc, 0x3);
break;
default:
SET_TX_DESC_SEC_TYPE_8723B(pDesc, 0x0);
break;
}
}
/* USB interface drop packet if the checksum of descriptor isn't correct. */
/* Using this checksum can let hardware recovery from packet bulk out error (e.g. Cancel URC, Bulk out error.). */
rtl8723b_cal_txdesc_chksum((struct tx_desc *)pDesc);
}
static void hw_var_set_opmode(struct adapter *padapter, u8 variable, u8 *val)
{
u8 val8;
u8 mode = *((u8 *)val);
{
/* disable Port0 TSF update */
val8 = rtw_read8(padapter, REG_BCN_CTRL);
val8 |= DIS_TSF_UDT;
rtw_write8(padapter, REG_BCN_CTRL, val8);
/* set net_type */
Set_MSR(padapter, mode);
if ((mode == _HW_STATE_STATION_) || (mode == _HW_STATE_NOLINK_)) {
{
StopTxBeacon(padapter);
}
/* disable atim wnd */
rtw_write8(padapter, REG_BCN_CTRL, DIS_TSF_UDT|EN_BCN_FUNCTION|DIS_ATIM);
/* rtw_write8(padapter, REG_BCN_CTRL, 0x18); */
} else if (mode == _HW_STATE_ADHOC_) {
ResumeTxBeacon(padapter);
rtw_write8(padapter, REG_BCN_CTRL, DIS_TSF_UDT|EN_BCN_FUNCTION|DIS_BCNQ_SUB);
} else if (mode == _HW_STATE_AP_) {
ResumeTxBeacon(padapter);
rtw_write8(padapter, REG_BCN_CTRL, DIS_TSF_UDT|DIS_BCNQ_SUB);
/* Set RCR */
rtw_write32(padapter, REG_RCR, 0x7000208e);/* CBSSID_DATA must set to 0, reject ICV_ERR packet */
/* enable to rx data frame */
rtw_write16(padapter, REG_RXFLTMAP2, 0xFFFF);
/* enable to rx ps-poll */
rtw_write16(padapter, REG_RXFLTMAP1, 0x0400);
/* Beacon Control related register for first time */
rtw_write8(padapter, REG_BCNDMATIM, 0x02); /* 2ms */
/* rtw_write8(padapter, REG_BCN_MAX_ERR, 0xFF); */
rtw_write8(padapter, REG_ATIMWND, 0x0a); /* 10ms */
rtw_write16(padapter, REG_BCNTCFG, 0x00);
rtw_write16(padapter, REG_TBTT_PROHIBIT, 0xff04);
rtw_write16(padapter, REG_TSFTR_SYN_OFFSET, 0x7fff);/* +32767 (~32ms) */
/* reset TSF */
rtw_write8(padapter, REG_DUAL_TSF_RST, BIT(0));
/* enable BCN0 Function for if1 */
/* don't enable update TSF0 for if1 (due to TSF update when beacon/probe rsp are received) */
rtw_write8(padapter, REG_BCN_CTRL, (DIS_TSF_UDT|EN_BCN_FUNCTION|EN_TXBCN_RPT|DIS_BCNQ_SUB));
/* SW_BCN_SEL - Port0 */
/* rtw_write8(Adapter, REG_DWBCN1_CTRL_8192E+2, rtw_read8(Adapter, REG_DWBCN1_CTRL_8192E+2) & ~BIT4); */
rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
/* select BCN on port 0 */
rtw_write8(
padapter,
REG_CCK_CHECK_8723B,
(rtw_read8(padapter, REG_CCK_CHECK_8723B)&~BIT_BCN_PORT_SEL)
);
/* dis BCN1 ATIM WND if if2 is station */
val8 = rtw_read8(padapter, REG_BCN_CTRL_1);
val8 |= DIS_ATIM;
rtw_write8(padapter, REG_BCN_CTRL_1, val8);
}
}
}
static void hw_var_set_macaddr(struct adapter *padapter, u8 variable, u8 *val)
{
u8 idx = 0;
u32 reg_macid;
reg_macid = REG_MACID;
for (idx = 0 ; idx < 6; idx++)
rtw_write8(GET_PRIMARY_ADAPTER(padapter), (reg_macid+idx), val[idx]);
}
static void hw_var_set_bssid(struct adapter *padapter, u8 variable, u8 *val)
{
u8 idx = 0;
u32 reg_bssid;
reg_bssid = REG_BSSID;
for (idx = 0 ; idx < 6; idx++)
rtw_write8(padapter, (reg_bssid+idx), val[idx]);
}
static void hw_var_set_bcn_func(struct adapter *padapter, u8 variable, u8 *val)
{
u32 bcn_ctrl_reg;
bcn_ctrl_reg = REG_BCN_CTRL;
if (*(u8 *)val)
rtw_write8(padapter, bcn_ctrl_reg, (EN_BCN_FUNCTION | EN_TXBCN_RPT));
else {
u8 val8;
val8 = rtw_read8(padapter, bcn_ctrl_reg);
val8 &= ~(EN_BCN_FUNCTION | EN_TXBCN_RPT);
/* Always enable port0 beacon function for PSTDMA */
if (REG_BCN_CTRL == bcn_ctrl_reg)
val8 |= EN_BCN_FUNCTION;
rtw_write8(padapter, bcn_ctrl_reg, val8);
}
}
static void hw_var_set_correct_tsf(struct adapter *padapter, u8 variable, u8 *val)
{
u8 val8;
u64 tsf;
struct mlme_ext_priv *pmlmeext;
struct mlme_ext_info *pmlmeinfo;
pmlmeext = &padapter->mlmeextpriv;
pmlmeinfo = &pmlmeext->mlmext_info;
tsf = pmlmeext->TSFValue-do_div(pmlmeext->TSFValue, (pmlmeinfo->bcn_interval*1024))-1024; /* us */
if (
((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) ||
((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
)
StopTxBeacon(padapter);
{
/* disable related TSF function */
val8 = rtw_read8(padapter, REG_BCN_CTRL);
val8 &= ~EN_BCN_FUNCTION;
rtw_write8(padapter, REG_BCN_CTRL, val8);
rtw_write32(padapter, REG_TSFTR, tsf);
rtw_write32(padapter, REG_TSFTR+4, tsf>>32);
/* enable related TSF function */
val8 = rtw_read8(padapter, REG_BCN_CTRL);
val8 |= EN_BCN_FUNCTION;
rtw_write8(padapter, REG_BCN_CTRL, val8);
}
if (
((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) ||
((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE)
)
ResumeTxBeacon(padapter);
}
static void hw_var_set_mlme_disconnect(struct adapter *padapter, u8 variable, u8 *val)
{
u8 val8;
/* Set RCR to not to receive data frame when NO LINK state */
/* rtw_write32(padapter, REG_RCR, rtw_read32(padapter, REG_RCR) & ~RCR_ADF); */
/* reject all data frames */
rtw_write16(padapter, REG_RXFLTMAP2, 0);
/* reset TSF */
rtw_write8(padapter, REG_DUAL_TSF_RST, BIT(0));
/* disable update TSF */
val8 = rtw_read8(padapter, REG_BCN_CTRL);
val8 |= DIS_TSF_UDT;
rtw_write8(padapter, REG_BCN_CTRL, val8);
}
static void hw_var_set_mlme_sitesurvey(struct adapter *padapter, u8 variable, u8 *val)
{
u32 value_rcr, rcr_clear_bit, reg_bcn_ctl;
u16 value_rxfltmap2;
u8 val8;
struct hal_com_data *pHalData;
struct mlme_priv *pmlmepriv;
pHalData = GET_HAL_DATA(padapter);
pmlmepriv = &padapter->mlmepriv;
reg_bcn_ctl = REG_BCN_CTRL;
rcr_clear_bit = RCR_CBSSID_BCN;
/* config RCR to receive different BSSID & not to receive data frame */
value_rxfltmap2 = 0;
if ((check_fwstate(pmlmepriv, WIFI_AP_STATE) == true))
rcr_clear_bit = RCR_CBSSID_BCN;
value_rcr = rtw_read32(padapter, REG_RCR);
if (*((u8 *)val)) {
/* under sitesurvey */
value_rcr &= ~(rcr_clear_bit);
rtw_write32(padapter, REG_RCR, value_rcr);
rtw_write16(padapter, REG_RXFLTMAP2, value_rxfltmap2);
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE)) {
/* disable update TSF */
val8 = rtw_read8(padapter, reg_bcn_ctl);
val8 |= DIS_TSF_UDT;
rtw_write8(padapter, reg_bcn_ctl, val8);
}
/* Save original RRSR setting. */
pHalData->RegRRSR = rtw_read16(padapter, REG_RRSR);
} else {
/* sitesurvey done */
if (check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)))
/* enable to rx data frame */
rtw_write16(padapter, REG_RXFLTMAP2, 0xFFFF);
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE)) {
/* enable update TSF */
val8 = rtw_read8(padapter, reg_bcn_ctl);
val8 &= ~DIS_TSF_UDT;
rtw_write8(padapter, reg_bcn_ctl, val8);
}
value_rcr |= rcr_clear_bit;
rtw_write32(padapter, REG_RCR, value_rcr);
/* Restore original RRSR setting. */
rtw_write16(padapter, REG_RRSR, pHalData->RegRRSR);
}
}
static void hw_var_set_mlme_join(struct adapter *padapter, u8 variable, u8 *val)
{
u8 val8;
u16 val16;
u32 val32;
u8 RetryLimit;
u8 type;
struct mlme_priv *pmlmepriv;
struct eeprom_priv *pEEPROM;
RetryLimit = 0x30;
type = *(u8 *)val;
pmlmepriv = &padapter->mlmepriv;
pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
if (type == 0) { /* prepare to join */
/* enable to rx data frame.Accept all data frame */
/* rtw_write32(padapter, REG_RCR, rtw_read32(padapter, REG_RCR)|RCR_ADF); */
rtw_write16(padapter, REG_RXFLTMAP2, 0xFFFF);
val32 = rtw_read32(padapter, REG_RCR);
if (padapter->in_cta_test)
val32 &= ~(RCR_CBSSID_DATA | RCR_CBSSID_BCN);/* RCR_ADF */
else
val32 |= RCR_CBSSID_DATA|RCR_CBSSID_BCN;
rtw_write32(padapter, REG_RCR, val32);
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true)
RetryLimit = (pEEPROM->CustomerID == RT_CID_CCX) ? 7 : 48;
else /* Ad-hoc Mode */
RetryLimit = 0x7;
} else if (type == 1) /* joinbss_event call back when join res < 0 */
rtw_write16(padapter, REG_RXFLTMAP2, 0x00);
else if (type == 2) { /* sta add event call back */
/* enable update TSF */
val8 = rtw_read8(padapter, REG_BCN_CTRL);
val8 &= ~DIS_TSF_UDT;
rtw_write8(padapter, REG_BCN_CTRL, val8);
if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE))
RetryLimit = 0x7;
}
val16 = (RetryLimit << RETRY_LIMIT_SHORT_SHIFT) | (RetryLimit << RETRY_LIMIT_LONG_SHIFT);
rtw_write16(padapter, REG_RL, val16);
}
void CCX_FwC2HTxRpt_8723b(struct adapter *padapter, u8 *pdata, u8 len)
{
#define GET_8723B_C2H_TX_RPT_LIFE_TIME_OVER(_Header) LE_BITS_TO_1BYTE((_Header + 0), 6, 1)
#define GET_8723B_C2H_TX_RPT_RETRY_OVER(_Header) LE_BITS_TO_1BYTE((_Header + 0), 7, 1)
if (GET_8723B_C2H_TX_RPT_RETRY_OVER(pdata) | GET_8723B_C2H_TX_RPT_LIFE_TIME_OVER(pdata)) {
rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_CCX_PKT_FAIL);
}
/*
else if (seq_no != padapter->xmitpriv.seq_no) {
rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_CCX_PKT_FAIL);
}
*/
else
rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_SUCCESS);
}
s32 c2h_id_filter_ccx_8723b(u8 *buf)
{
struct c2h_evt_hdr_88xx *c2h_evt = (struct c2h_evt_hdr_88xx *)buf;
s32 ret = false;
if (c2h_evt->id == C2H_CCX_TX_RPT)
ret = true;
return ret;
}
s32 c2h_handler_8723b(struct adapter *padapter, u8 *buf)
{
struct c2h_evt_hdr_88xx *pC2hEvent = (struct c2h_evt_hdr_88xx *)buf;
s32 ret = _SUCCESS;
if (!pC2hEvent) {
ret = _FAIL;
goto exit;
}
switch (pC2hEvent->id) {
case C2H_AP_RPT_RSP:
break;
case C2H_DBG:
{
}
break;
case C2H_CCX_TX_RPT:
/* CCX_FwC2HTxRpt(padapter, QueueID, pC2hEvent->payload); */
break;
case C2H_EXT_RA_RPT:
/* C2HExtRaRptHandler(padapter, pC2hEvent->payload, C2hEvent.CmdLen); */
break;
case C2H_HW_INFO_EXCH:
break;
case C2H_8723B_BT_INFO:
hal_btcoex_BtInfoNotify(padapter, pC2hEvent->plen, pC2hEvent->payload);
break;
default:
break;
}
/* Clear event to notify FW we have read the command. */
/* Note: */
/* If this field isn't clear, the FW won't update the next command message. */
/* rtw_write8(padapter, REG_C2HEVT_CLEAR, C2H_EVT_HOST_CLOSE); */
exit:
return ret;
}
static void process_c2h_event(struct adapter *padapter, struct c2h_evt_hdr_t *pC2hEvent, u8 *c2hBuf)
{
if (!c2hBuf)
return;
switch (pC2hEvent->CmdID) {
case C2H_AP_RPT_RSP:
break;
case C2H_DBG:
{
}
break;
case C2H_CCX_TX_RPT:
/* CCX_FwC2HTxRpt(padapter, QueueID, tmpBuf); */
break;
case C2H_EXT_RA_RPT:
/* C2HExtRaRptHandler(padapter, tmpBuf, C2hEvent.CmdLen); */
break;
case C2H_HW_INFO_EXCH:
break;
case C2H_8723B_BT_INFO:
hal_btcoex_BtInfoNotify(padapter, pC2hEvent->CmdLen, c2hBuf);
break;
default:
break;
}
}
void C2HPacketHandler_8723B(struct adapter *padapter, u8 *pbuffer, u16 length)
{
struct c2h_evt_hdr_t C2hEvent;
u8 *tmpBuf = NULL;
C2hEvent.CmdID = pbuffer[0];
C2hEvent.CmdSeq = pbuffer[1];
C2hEvent.CmdLen = length-2;
tmpBuf = pbuffer+2;
process_c2h_event(padapter, &C2hEvent, tmpBuf);
/* c2h_handler_8723b(padapter,&C2hEvent); */
}
void SetHwReg8723B(struct adapter *padapter, u8 variable, u8 *val)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 val8;
u32 val32;
switch (variable) {
case HW_VAR_MEDIA_STATUS:
val8 = rtw_read8(padapter, MSR) & 0x0c;
val8 |= *val;
rtw_write8(padapter, MSR, val8);
break;
case HW_VAR_MEDIA_STATUS1:
val8 = rtw_read8(padapter, MSR) & 0x03;
val8 |= *val << 2;
rtw_write8(padapter, MSR, val8);
break;
case HW_VAR_SET_OPMODE:
hw_var_set_opmode(padapter, variable, val);
break;
case HW_VAR_MAC_ADDR:
hw_var_set_macaddr(padapter, variable, val);
break;
case HW_VAR_BSSID:
hw_var_set_bssid(padapter, variable, val);
break;
case HW_VAR_BASIC_RATE:
{
struct mlme_ext_info *mlmext_info = &padapter->mlmeextpriv.mlmext_info;
u16 BrateCfg = 0;
u16 rrsr_2g_force_mask = (RRSR_11M|RRSR_5_5M|RRSR_1M);
u16 rrsr_2g_allow_mask = (RRSR_24M|RRSR_12M|RRSR_6M|RRSR_CCK_RATES);
HalSetBrateCfg(padapter, val, &BrateCfg);
/* apply force and allow mask */
BrateCfg |= rrsr_2g_force_mask;
BrateCfg &= rrsr_2g_allow_mask;
/* IOT consideration */
if (mlmext_info->assoc_AP_vendor == HT_IOT_PEER_CISCO) {
/* if peer is cisco and didn't use ofdm rate, we enable 6M ack */
if ((BrateCfg & (RRSR_24M|RRSR_12M|RRSR_6M)) == 0)
BrateCfg |= RRSR_6M;
}
pHalData->BasicRateSet = BrateCfg;
/* Set RRSR rate table. */
rtw_write16(padapter, REG_RRSR, BrateCfg);
rtw_write8(padapter, REG_RRSR+2, rtw_read8(padapter, REG_RRSR+2)&0xf0);
}
break;
case HW_VAR_TXPAUSE:
rtw_write8(padapter, REG_TXPAUSE, *val);
break;
case HW_VAR_BCN_FUNC:
hw_var_set_bcn_func(padapter, variable, val);
break;
case HW_VAR_CORRECT_TSF:
hw_var_set_correct_tsf(padapter, variable, val);
break;
case HW_VAR_CHECK_BSSID:
{
u32 val32;
val32 = rtw_read32(padapter, REG_RCR);
if (*val)
val32 |= RCR_CBSSID_DATA|RCR_CBSSID_BCN;
else
val32 &= ~(RCR_CBSSID_DATA|RCR_CBSSID_BCN);
rtw_write32(padapter, REG_RCR, val32);
}
break;
case HW_VAR_MLME_DISCONNECT:
hw_var_set_mlme_disconnect(padapter, variable, val);
break;
case HW_VAR_MLME_SITESURVEY:
hw_var_set_mlme_sitesurvey(padapter, variable, val);
hal_btcoex_ScanNotify(padapter, *val?true:false);
break;
case HW_VAR_MLME_JOIN:
hw_var_set_mlme_join(padapter, variable, val);
switch (*val) {
case 0:
/* prepare to join */
hal_btcoex_ConnectNotify(padapter, true);
break;
case 1:
/* joinbss_event callback when join res < 0 */
hal_btcoex_ConnectNotify(padapter, false);
break;
case 2:
/* sta add event callback */
/* rtw_btcoex_MediaStatusNotify(padapter, RT_MEDIA_CONNECT); */
break;
}
break;
case HW_VAR_ON_RCR_AM:
val32 = rtw_read32(padapter, REG_RCR);
val32 |= RCR_AM;
rtw_write32(padapter, REG_RCR, val32);
break;
case HW_VAR_OFF_RCR_AM:
val32 = rtw_read32(padapter, REG_RCR);
val32 &= ~RCR_AM;
rtw_write32(padapter, REG_RCR, val32);
break;
case HW_VAR_BEACON_INTERVAL:
rtw_write16(padapter, REG_BCN_INTERVAL, *((u16 *)val));
break;
case HW_VAR_SLOT_TIME:
rtw_write8(padapter, REG_SLOT, *val);
break;
case HW_VAR_RESP_SIFS:
/* SIFS_Timer = 0x0a0a0808; */
/* RESP_SIFS for CCK */
rtw_write8(padapter, REG_RESP_SIFS_CCK, val[0]); /* SIFS_T2T_CCK (0x08) */
rtw_write8(padapter, REG_RESP_SIFS_CCK+1, val[1]); /* SIFS_R2T_CCK(0x08) */
/* RESP_SIFS for OFDM */
rtw_write8(padapter, REG_RESP_SIFS_OFDM, val[2]); /* SIFS_T2T_OFDM (0x0a) */
rtw_write8(padapter, REG_RESP_SIFS_OFDM+1, val[3]); /* SIFS_R2T_OFDM(0x0a) */
break;
case HW_VAR_ACK_PREAMBLE:
{
u8 regTmp;
u8 bShortPreamble = *val;
/* Joseph marked out for Netgear 3500 TKIP channel 7 issue.(Temporarily) */
/* regTmp = (pHalData->nCur40MhzPrimeSC)<<5; */
regTmp = 0;
if (bShortPreamble)
regTmp |= 0x80;
rtw_write8(padapter, REG_RRSR+2, regTmp);
}
break;
case HW_VAR_CAM_EMPTY_ENTRY:
{
u8 ucIndex = *val;
u8 i;
u32 ulCommand = 0;
u32 ulContent = 0;
u32 ulEncAlgo = CAM_AES;
for (i = 0; i < CAM_CONTENT_COUNT; i++) {
/* filled id in CAM config 2 byte */
if (i == 0) {
ulContent |= (ucIndex & 0x03) | ((u16)(ulEncAlgo)<<2);
/* ulContent |= CAM_VALID; */
} else
ulContent = 0;
/* polling bit, and No Write enable, and address */
ulCommand = CAM_CONTENT_COUNT*ucIndex+i;
ulCommand = ulCommand | CAM_POLLINIG | CAM_WRITE;
/* write content 0 is equal to mark as invalid */
rtw_write32(padapter, WCAMI, ulContent); /* mdelay(40); */
rtw_write32(padapter, RWCAM, ulCommand); /* mdelay(40); */
}
}
break;
case HW_VAR_CAM_INVALID_ALL:
rtw_write32(padapter, RWCAM, BIT(31)|BIT(30));
break;
case HW_VAR_CAM_WRITE:
{
u32 cmd;
u32 *cam_val = (u32 *)val;
rtw_write32(padapter, WCAMI, cam_val[0]);
cmd = CAM_POLLINIG | CAM_WRITE | cam_val[1];
rtw_write32(padapter, RWCAM, cmd);
}
break;
case HW_VAR_AC_PARAM_VO:
rtw_write32(padapter, REG_EDCA_VO_PARAM, *((u32 *)val));
break;
case HW_VAR_AC_PARAM_VI:
rtw_write32(padapter, REG_EDCA_VI_PARAM, *((u32 *)val));
break;
case HW_VAR_AC_PARAM_BE:
pHalData->AcParam_BE = ((u32 *)(val))[0];
rtw_write32(padapter, REG_EDCA_BE_PARAM, *((u32 *)val));
break;
case HW_VAR_AC_PARAM_BK:
rtw_write32(padapter, REG_EDCA_BK_PARAM, *((u32 *)val));
break;
case HW_VAR_ACM_CTRL:
{
u8 ctrl = *((u8 *)val);
u8 hwctrl = 0;
if (ctrl != 0) {
hwctrl |= AcmHw_HwEn;
if (ctrl & BIT(1)) /* BE */
hwctrl |= AcmHw_BeqEn;
if (ctrl & BIT(2)) /* VI */
hwctrl |= AcmHw_ViqEn;
if (ctrl & BIT(3)) /* VO */
hwctrl |= AcmHw_VoqEn;
}
rtw_write8(padapter, REG_ACMHWCTRL, hwctrl);
}
break;
case HW_VAR_AMPDU_FACTOR:
{
u32 AMPDULen = (*((u8 *)val));
if (AMPDULen < HT_AGG_SIZE_32K)
AMPDULen = (0x2000 << (*((u8 *)val)))-1;
else
AMPDULen = 0x7fff;
rtw_write32(padapter, REG_AMPDU_MAX_LENGTH_8723B, AMPDULen);
}
break;
case HW_VAR_H2C_FW_PWRMODE:
{
u8 psmode = *val;
/* Forece leave RF low power mode for 1T1R to prevent conficting setting in Fw power */
/* saving sequence. 2010.06.07. Added by tynli. Suggested by SD3 yschang. */
if (psmode != PS_MODE_ACTIVE) {
ODM_RF_Saving(&pHalData->odmpriv, true);
}
/* if (psmode != PS_MODE_ACTIVE) { */
/* rtl8723b_set_lowpwr_lps_cmd(padapter, true); */
/* else { */
/* rtl8723b_set_lowpwr_lps_cmd(padapter, false); */
/* */
rtl8723b_set_FwPwrMode_cmd(padapter, psmode);
}
break;
case HW_VAR_H2C_PS_TUNE_PARAM:
rtl8723b_set_FwPsTuneParam_cmd(padapter);
break;
case HW_VAR_H2C_FW_JOINBSSRPT:
rtl8723b_set_FwJoinBssRpt_cmd(padapter, *val);
break;
case HW_VAR_INITIAL_GAIN:
{
struct dig_t *pDigTable = &pHalData->odmpriv.DM_DigTable;
u32 rx_gain = *(u32 *)val;
if (rx_gain == 0xff) {/* restore rx gain */
ODM_Write_DIG(&pHalData->odmpriv, pDigTable->BackupIGValue);
} else {
pDigTable->BackupIGValue = pDigTable->CurIGValue;
ODM_Write_DIG(&pHalData->odmpriv, rx_gain);
}
}
break;
case HW_VAR_EFUSE_USAGE:
pHalData->EfuseUsedPercentage = *val;
break;
case HW_VAR_EFUSE_BYTES:
pHalData->EfuseUsedBytes = *((u16 *)val);
break;
case HW_VAR_EFUSE_BT_USAGE:
#ifdef HAL_EFUSE_MEMORY
pHalData->EfuseHal.BTEfuseUsedPercentage = *val;
#endif
break;
case HW_VAR_EFUSE_BT_BYTES:
#ifdef HAL_EFUSE_MEMORY
pHalData->EfuseHal.BTEfuseUsedBytes = *((u16 *)val);
#else
BTEfuseUsedBytes = *((u16 *)val);
#endif
break;
case HW_VAR_FIFO_CLEARN_UP:
{
#define RW_RELEASE_EN BIT(18)
#define RXDMA_IDLE BIT(17)
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
u8 trycnt = 100;
/* pause tx */
rtw_write8(padapter, REG_TXPAUSE, 0xff);
/* keep sn */
padapter->xmitpriv.nqos_ssn = rtw_read16(padapter, REG_NQOS_SEQ);
if (!pwrpriv->bkeepfwalive) {
/* RX DMA stop */
val32 = rtw_read32(padapter, REG_RXPKT_NUM);
val32 |= RW_RELEASE_EN;
rtw_write32(padapter, REG_RXPKT_NUM, val32);
do {
val32 = rtw_read32(padapter, REG_RXPKT_NUM);
val32 &= RXDMA_IDLE;
if (val32)
break;
} while (--trycnt);
/* RQPN Load 0 */
rtw_write16(padapter, REG_RQPN_NPQ, 0);
rtw_write32(padapter, REG_RQPN, 0x80000000);
mdelay(2);
}
}
break;
case HW_VAR_APFM_ON_MAC:
pHalData->bMacPwrCtrlOn = *val;
break;
case HW_VAR_NAV_UPPER:
{
u32 usNavUpper = *((u32 *)val);
if (usNavUpper > HAL_NAV_UPPER_UNIT_8723B * 0xFF)
break;
usNavUpper = DIV_ROUND_UP(usNavUpper,
HAL_NAV_UPPER_UNIT_8723B);
rtw_write8(padapter, REG_NAV_UPPER, (u8)usNavUpper);
}
break;
case HW_VAR_H2C_MEDIA_STATUS_RPT:
{
u16 mstatus_rpt = (*(u16 *)val);
u8 mstatus, macId;
mstatus = (u8) (mstatus_rpt & 0xFF);
macId = (u8)(mstatus_rpt >> 8);
rtl8723b_set_FwMediaStatusRpt_cmd(padapter, mstatus, macId);
}
break;
case HW_VAR_BCN_VALID:
{
/* BCN_VALID, BIT16 of REG_TDECTRL = BIT0 of REG_TDECTRL+2, write 1 to clear, Clear by sw */
val8 = rtw_read8(padapter, REG_TDECTRL+2);
val8 |= BIT(0);
rtw_write8(padapter, REG_TDECTRL+2, val8);
}
break;
case HW_VAR_DL_BCN_SEL:
{
/* SW_BCN_SEL - Port0 */
val8 = rtw_read8(padapter, REG_DWBCN1_CTRL_8723B+2);
val8 &= ~BIT(4);
rtw_write8(padapter, REG_DWBCN1_CTRL_8723B+2, val8);
}
break;
case HW_VAR_DO_IQK:
pHalData->bNeedIQK = true;
break;
case HW_VAR_DL_RSVD_PAGE:
if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == true)
rtl8723b_download_BTCoex_AP_mode_rsvd_page(padapter);
else
rtl8723b_download_rsvd_page(padapter, RT_MEDIA_CONNECT);
break;
case HW_VAR_MACID_SLEEP:
/* Input is MACID */
val32 = *(u32 *)val;
if (val32 > 31)
break;
val8 = (u8)val32; /* macid is between 0~31 */
val32 = rtw_read32(padapter, REG_MACID_SLEEP);
if (val32 & BIT(val8))
break;
val32 |= BIT(val8);
rtw_write32(padapter, REG_MACID_SLEEP, val32);
break;
case HW_VAR_MACID_WAKEUP:
/* Input is MACID */
val32 = *(u32 *)val;
if (val32 > 31)
break;
val8 = (u8)val32; /* macid is between 0~31 */
val32 = rtw_read32(padapter, REG_MACID_SLEEP);
if (!(val32 & BIT(val8)))
break;
val32 &= ~BIT(val8);
rtw_write32(padapter, REG_MACID_SLEEP, val32);
break;
default:
SetHwReg(padapter, variable, val);
break;
}
}
void GetHwReg8723B(struct adapter *padapter, u8 variable, u8 *val)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 val8;
u16 val16;
switch (variable) {
case HW_VAR_TXPAUSE:
*val = rtw_read8(padapter, REG_TXPAUSE);
break;
case HW_VAR_BCN_VALID:
{
/* BCN_VALID, BIT16 of REG_TDECTRL = BIT0 of REG_TDECTRL+2 */
val8 = rtw_read8(padapter, REG_TDECTRL+2);
*val = (BIT(0) & val8) ? true : false;
}
break;
case HW_VAR_FWLPS_RF_ON:
{
/* When we halt NIC, we should check if FW LPS is leave. */
u32 valRCR;
if (
padapter->bSurpriseRemoved ||
(adapter_to_pwrctl(padapter)->rf_pwrstate == rf_off)
) {
/* If it is in HW/SW Radio OFF or IPS state, we do not check Fw LPS Leave, */
/* because Fw is unload. */
*val = true;
} else {
valRCR = rtw_read32(padapter, REG_RCR);
valRCR &= 0x00070000;
if (valRCR)
*val = false;
else
*val = true;
}
}
break;
case HW_VAR_EFUSE_USAGE:
*val = pHalData->EfuseUsedPercentage;
break;
case HW_VAR_EFUSE_BYTES:
*((u16 *)val) = pHalData->EfuseUsedBytes;
break;
case HW_VAR_EFUSE_BT_USAGE:
#ifdef HAL_EFUSE_MEMORY
*val = pHalData->EfuseHal.BTEfuseUsedPercentage;
#endif
break;
case HW_VAR_EFUSE_BT_BYTES:
#ifdef HAL_EFUSE_MEMORY
*((u16 *)val) = pHalData->EfuseHal.BTEfuseUsedBytes;
#else
*((u16 *)val) = BTEfuseUsedBytes;
#endif
break;
case HW_VAR_APFM_ON_MAC:
*val = pHalData->bMacPwrCtrlOn;
break;
case HW_VAR_CHK_HI_QUEUE_EMPTY:
val16 = rtw_read16(padapter, REG_TXPKT_EMPTY);
*val = (val16 & BIT(10)) ? true:false;
break;
default:
GetHwReg(padapter, variable, val);
break;
}
}
/* Description:
* Change default setting of specified variable.
*/
u8 SetHalDefVar8723B(struct adapter *padapter, enum hal_def_variable variable, void *pval)
{
u8 bResult;
bResult = _SUCCESS;
switch (variable) {
default:
bResult = SetHalDefVar(padapter, variable, pval);
break;
}
return bResult;
}
/* Description:
* Query setting of specified variable.
*/
u8 GetHalDefVar8723B(struct adapter *padapter, enum hal_def_variable variable, void *pval)
{
u8 bResult;
bResult = _SUCCESS;
switch (variable) {
case HAL_DEF_MAX_RECVBUF_SZ:
*((u32 *)pval) = MAX_RECVBUF_SZ;
break;
case HAL_DEF_RX_PACKET_OFFSET:
*((u32 *)pval) = RXDESC_SIZE + DRVINFO_SZ*8;
break;
case HW_VAR_MAX_RX_AMPDU_FACTOR:
/* [email protected] suggests 16K can get stable performance */
/* The experiment was done on SDIO interface */
/* coding by Lucas@20130730 */
*(u32 *)pval = IEEE80211_HT_MAX_AMPDU_16K;
break;
case HAL_DEF_TX_LDPC:
case HAL_DEF_RX_LDPC:
*((u8 *)pval) = false;
break;
case HAL_DEF_TX_STBC:
*((u8 *)pval) = 0;
break;
case HAL_DEF_RX_STBC:
*((u8 *)pval) = 1;
break;
case HAL_DEF_EXPLICIT_BEAMFORMER:
case HAL_DEF_EXPLICIT_BEAMFORMEE:
*((u8 *)pval) = false;
break;
case HW_DEF_RA_INFO_DUMP:
{
u8 mac_id = *(u8 *)pval;
u32 cmd;
cmd = 0x40000100 | mac_id;
rtw_write32(padapter, REG_HMEBOX_DBG_2_8723B, cmd);
msleep(10);
rtw_read32(padapter, 0x2F0); // info 1
cmd = 0x40000400 | mac_id;
rtw_write32(padapter, REG_HMEBOX_DBG_2_8723B, cmd);
msleep(10);
rtw_read32(padapter, 0x2F0); // info 1
rtw_read32(padapter, 0x2F4); // info 2
rtw_read32(padapter, 0x2F8); // rate mask 1
rtw_read32(padapter, 0x2FC); // rate mask 2
}
break;
case HAL_DEF_TX_PAGE_BOUNDARY:
if (!padapter->registrypriv.wifi_spec) {
*(u8 *)pval = TX_PAGE_BOUNDARY_8723B;
} else {
*(u8 *)pval = WMM_NORMAL_TX_PAGE_BOUNDARY_8723B;
}
break;
case HAL_DEF_MACID_SLEEP:
*(u8 *)pval = true; /* support macid sleep */
break;
default:
bResult = GetHalDefVar(padapter, variable, pval);
break;
}
return bResult;
}
void rtl8723b_start_thread(struct adapter *padapter)
{
struct xmit_priv *xmitpriv = &padapter->xmitpriv;
xmitpriv->SdioXmitThread = kthread_run(rtl8723bs_xmit_thread, padapter, "RTWHALXT");
}
void rtl8723b_stop_thread(struct adapter *padapter)
{
struct xmit_priv *xmitpriv = &padapter->xmitpriv;
/* stop xmit_buf_thread */
if (xmitpriv->SdioXmitThread) {
complete(&xmitpriv->SdioXmitStart);
wait_for_completion(&xmitpriv->SdioXmitTerminate);
xmitpriv->SdioXmitThread = NULL;
}
}
| linux-master | drivers/staging/rtl8723bs/hal/rtl8723b_hal_init.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
*******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtl8723b_hal.h>
/* */
/* Description: */
/* The following mapping is for SDIO host local register space. */
/* */
/* Creadted by Roger, 2011.01.31. */
/* */
static void hal_sdio_get_cmd_addr_8723b(
struct adapter *adapter,
u8 device_id,
u32 addr,
u32 *cmdaddr
)
{
switch (device_id) {
case SDIO_LOCAL_DEVICE_ID:
*cmdaddr = ((SDIO_LOCAL_DEVICE_ID << 13) | (addr & SDIO_LOCAL_MSK));
break;
case WLAN_IOREG_DEVICE_ID:
*cmdaddr = ((WLAN_IOREG_DEVICE_ID << 13) | (addr & WLAN_IOREG_MSK));
break;
case WLAN_TX_HIQ_DEVICE_ID:
*cmdaddr = ((WLAN_TX_HIQ_DEVICE_ID << 13) | (addr & WLAN_FIFO_MSK));
break;
case WLAN_TX_MIQ_DEVICE_ID:
*cmdaddr = ((WLAN_TX_MIQ_DEVICE_ID << 13) | (addr & WLAN_FIFO_MSK));
break;
case WLAN_TX_LOQ_DEVICE_ID:
*cmdaddr = ((WLAN_TX_LOQ_DEVICE_ID << 13) | (addr & WLAN_FIFO_MSK));
break;
case WLAN_RX0FF_DEVICE_ID:
*cmdaddr = ((WLAN_RX0FF_DEVICE_ID << 13) | (addr & WLAN_RX0FF_MSK));
break;
default:
break;
}
}
static u8 get_deviceid(u32 addr)
{
u8 devide_id;
u16 pseudo_id;
pseudo_id = (u16)(addr >> 16);
switch (pseudo_id) {
case 0x1025:
devide_id = SDIO_LOCAL_DEVICE_ID;
break;
case 0x1026:
devide_id = WLAN_IOREG_DEVICE_ID;
break;
case 0x1031:
devide_id = WLAN_TX_HIQ_DEVICE_ID;
break;
case 0x1032:
devide_id = WLAN_TX_MIQ_DEVICE_ID;
break;
case 0x1033:
devide_id = WLAN_TX_LOQ_DEVICE_ID;
break;
case 0x1034:
devide_id = WLAN_RX0FF_DEVICE_ID;
break;
default:
devide_id = WLAN_IOREG_DEVICE_ID;
break;
}
return devide_id;
}
static u32 _cvrt2ftaddr(const u32 addr, u8 *pdevice_id, u16 *poffset)
{
u8 device_id;
u16 offset;
u32 ftaddr;
device_id = get_deviceid(addr);
offset = 0;
switch (device_id) {
case SDIO_LOCAL_DEVICE_ID:
offset = addr & SDIO_LOCAL_MSK;
break;
case WLAN_TX_HIQ_DEVICE_ID:
case WLAN_TX_MIQ_DEVICE_ID:
case WLAN_TX_LOQ_DEVICE_ID:
offset = addr & WLAN_FIFO_MSK;
break;
case WLAN_RX0FF_DEVICE_ID:
offset = addr & WLAN_RX0FF_MSK;
break;
case WLAN_IOREG_DEVICE_ID:
default:
device_id = WLAN_IOREG_DEVICE_ID;
offset = addr & WLAN_IOREG_MSK;
break;
}
ftaddr = (device_id << 13) | offset;
if (pdevice_id)
*pdevice_id = device_id;
if (poffset)
*poffset = offset;
return ftaddr;
}
static u8 sdio_read8(struct intf_hdl *intfhdl, u32 addr)
{
u32 ftaddr;
ftaddr = _cvrt2ftaddr(addr, NULL, NULL);
return sd_read8(intfhdl, ftaddr, NULL);
}
static u16 sdio_read16(struct intf_hdl *intfhdl, u32 addr)
{
u32 ftaddr;
__le16 le_tmp;
ftaddr = _cvrt2ftaddr(addr, NULL, NULL);
sd_cmd52_read(intfhdl, ftaddr, 2, (u8 *)&le_tmp);
return le16_to_cpu(le_tmp);
}
static u32 sdio_read32(struct intf_hdl *intfhdl, u32 addr)
{
struct adapter *adapter;
u8 mac_pwr_ctrl_on;
u8 device_id;
u16 offset;
u32 ftaddr;
u8 shift;
u32 val;
s32 __maybe_unused err;
__le32 le_tmp;
adapter = intfhdl->padapter;
ftaddr = _cvrt2ftaddr(addr, &device_id, &offset);
rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
if (
((device_id == WLAN_IOREG_DEVICE_ID) && (offset < 0x100)) ||
(!mac_pwr_ctrl_on) ||
(adapter_to_pwrctl(adapter)->fw_current_in_ps_mode)
) {
err = sd_cmd52_read(intfhdl, ftaddr, 4, (u8 *)&le_tmp);
return le32_to_cpu(le_tmp);
}
/* 4 bytes alignment */
shift = ftaddr & 0x3;
if (shift == 0) {
val = sd_read32(intfhdl, ftaddr, NULL);
} else {
u8 *tmpbuf;
tmpbuf = rtw_malloc(8);
if (!tmpbuf)
return SDIO_ERR_VAL32;
ftaddr &= ~(u16)0x3;
sd_read(intfhdl, ftaddr, 8, tmpbuf);
memcpy(&le_tmp, tmpbuf + shift, 4);
val = le32_to_cpu(le_tmp);
kfree(tmpbuf);
}
return val;
}
static s32 sdio_readN(struct intf_hdl *intfhdl, u32 addr, u32 cnt, u8 *buf)
{
struct adapter *adapter;
u8 mac_pwr_ctrl_on;
u8 device_id;
u16 offset;
u32 ftaddr;
u8 shift;
s32 err;
adapter = intfhdl->padapter;
err = 0;
ftaddr = _cvrt2ftaddr(addr, &device_id, &offset);
rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
if (
((device_id == WLAN_IOREG_DEVICE_ID) && (offset < 0x100)) ||
(!mac_pwr_ctrl_on) ||
(adapter_to_pwrctl(adapter)->fw_current_in_ps_mode)
)
return sd_cmd52_read(intfhdl, ftaddr, cnt, buf);
/* 4 bytes alignment */
shift = ftaddr & 0x3;
if (shift == 0) {
err = sd_read(intfhdl, ftaddr, cnt, buf);
} else {
u8 *tmpbuf;
u32 n;
ftaddr &= ~(u16)0x3;
n = cnt + shift;
tmpbuf = rtw_malloc(n);
if (!tmpbuf)
return -1;
err = sd_read(intfhdl, ftaddr, n, tmpbuf);
if (!err)
memcpy(buf, tmpbuf + shift, cnt);
kfree(tmpbuf);
}
return err;
}
static s32 sdio_write8(struct intf_hdl *intfhdl, u32 addr, u8 val)
{
u32 ftaddr;
s32 err;
ftaddr = _cvrt2ftaddr(addr, NULL, NULL);
sd_write8(intfhdl, ftaddr, val, &err);
return err;
}
static s32 sdio_write16(struct intf_hdl *intfhdl, u32 addr, u16 val)
{
u32 ftaddr;
__le16 le_tmp;
ftaddr = _cvrt2ftaddr(addr, NULL, NULL);
le_tmp = cpu_to_le16(val);
return sd_cmd52_write(intfhdl, ftaddr, 2, (u8 *)&le_tmp);
}
static s32 sdio_write32(struct intf_hdl *intfhdl, u32 addr, u32 val)
{
struct adapter *adapter;
u8 mac_pwr_ctrl_on;
u8 device_id;
u16 offset;
u32 ftaddr;
u8 shift;
s32 err;
__le32 le_tmp;
adapter = intfhdl->padapter;
err = 0;
ftaddr = _cvrt2ftaddr(addr, &device_id, &offset);
rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
if (
((device_id == WLAN_IOREG_DEVICE_ID) && (offset < 0x100)) ||
(!mac_pwr_ctrl_on) ||
(adapter_to_pwrctl(adapter)->fw_current_in_ps_mode)
) {
le_tmp = cpu_to_le32(val);
return sd_cmd52_write(intfhdl, ftaddr, 4, (u8 *)&le_tmp);
}
/* 4 bytes alignment */
shift = ftaddr & 0x3;
if (shift == 0) {
sd_write32(intfhdl, ftaddr, val, &err);
} else {
le_tmp = cpu_to_le32(val);
err = sd_cmd52_write(intfhdl, ftaddr, 4, (u8 *)&le_tmp);
}
return err;
}
static s32 sdio_writeN(struct intf_hdl *intfhdl, u32 addr, u32 cnt, u8 *buf)
{
struct adapter *adapter;
u8 mac_pwr_ctrl_on;
u8 device_id;
u16 offset;
u32 ftaddr;
u8 shift;
s32 err;
adapter = intfhdl->padapter;
err = 0;
ftaddr = _cvrt2ftaddr(addr, &device_id, &offset);
rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
if (
((device_id == WLAN_IOREG_DEVICE_ID) && (offset < 0x100)) ||
(!mac_pwr_ctrl_on) ||
(adapter_to_pwrctl(adapter)->fw_current_in_ps_mode)
)
return sd_cmd52_write(intfhdl, ftaddr, cnt, buf);
shift = ftaddr & 0x3;
if (shift == 0) {
err = sd_write(intfhdl, ftaddr, cnt, buf);
} else {
u8 *tmpbuf;
u32 n;
ftaddr &= ~(u16)0x3;
n = cnt + shift;
tmpbuf = rtw_malloc(n);
if (!tmpbuf)
return -1;
err = sd_read(intfhdl, ftaddr, 4, tmpbuf);
if (err) {
kfree(tmpbuf);
return err;
}
memcpy(tmpbuf + shift, buf, cnt);
err = sd_write(intfhdl, ftaddr, n, tmpbuf);
kfree(tmpbuf);
}
return err;
}
static void sdio_read_mem(
struct intf_hdl *intfhdl,
u32 addr,
u32 cnt,
u8 *rmem
)
{
sdio_readN(intfhdl, addr, cnt, rmem);
}
static void sdio_write_mem(
struct intf_hdl *intfhdl,
u32 addr,
u32 cnt,
u8 *wmem
)
{
sdio_writeN(intfhdl, addr, cnt, wmem);
}
/*
* Description:
*Read from RX FIFO
*Round read size to block size,
*and make sure data transfer will be done in one command.
*
* Parameters:
*intfhdl a pointer of intf_hdl
*addr port ID
*cnt size to read
*rmem address to put data
*
* Return:
*_SUCCESS(1) Success
*_FAIL(0) Fail
*/
static u32 sdio_read_port(
struct intf_hdl *intfhdl,
u32 addr,
u32 cnt,
u8 *mem
)
{
struct adapter *adapter;
struct sdio_data *psdio;
struct hal_com_data *hal;
s32 err;
adapter = intfhdl->padapter;
psdio = &adapter_to_dvobj(adapter)->intf_data;
hal = GET_HAL_DATA(adapter);
hal_sdio_get_cmd_addr_8723b(adapter, addr, hal->SdioRxFIFOCnt++, &addr);
if (cnt > psdio->block_transfer_len)
cnt = _RND(cnt, psdio->block_transfer_len);
err = _sd_read(intfhdl, addr, cnt, mem);
if (err)
return _FAIL;
return _SUCCESS;
}
/*
* Description:
*Write to TX FIFO
*Align write size block size,
*and make sure data could be written in one command.
*
* Parameters:
*intfhdl a pointer of intf_hdl
*addr port ID
*cnt size to write
*wmem data pointer to write
*
* Return:
*_SUCCESS(1) Success
*_FAIL(0) Fail
*/
static u32 sdio_write_port(
struct intf_hdl *intfhdl,
u32 addr,
u32 cnt,
u8 *mem
)
{
struct adapter *adapter;
struct sdio_data *psdio;
s32 err;
struct xmit_buf *xmitbuf = (struct xmit_buf *)mem;
adapter = intfhdl->padapter;
psdio = &adapter_to_dvobj(adapter)->intf_data;
if (!adapter->hw_init_completed)
return _FAIL;
cnt = round_up(cnt, 4);
hal_sdio_get_cmd_addr_8723b(adapter, addr, cnt >> 2, &addr);
if (cnt > psdio->block_transfer_len)
cnt = _RND(cnt, psdio->block_transfer_len);
err = sd_write(intfhdl, addr, cnt, xmitbuf->pdata);
rtw_sctx_done_err(
&xmitbuf->sctx,
err ? RTW_SCTX_DONE_WRITE_PORT_ERR : RTW_SCTX_DONE_SUCCESS
);
if (err)
return _FAIL;
return _SUCCESS;
}
void sdio_set_intf_ops(struct adapter *adapter, struct _io_ops *ops)
{
ops->_read8 = &sdio_read8;
ops->_read16 = &sdio_read16;
ops->_read32 = &sdio_read32;
ops->_read_mem = &sdio_read_mem;
ops->_read_port = &sdio_read_port;
ops->_write8 = &sdio_write8;
ops->_write16 = &sdio_write16;
ops->_write32 = &sdio_write32;
ops->_writeN = &sdio_writeN;
ops->_write_mem = &sdio_write_mem;
ops->_write_port = &sdio_write_port;
}
/*
* Todo: align address to 4 bytes.
*/
static s32 _sdio_local_read(
struct adapter *adapter,
u32 addr,
u32 cnt,
u8 *buf
)
{
struct intf_hdl *intfhdl;
u8 mac_pwr_ctrl_on;
s32 err;
u8 *tmpbuf;
u32 n;
intfhdl = &adapter->iopriv.intf;
hal_sdio_get_cmd_addr_8723b(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
if (!mac_pwr_ctrl_on)
return _sd_cmd52_read(intfhdl, addr, cnt, buf);
n = round_up(cnt, 4);
tmpbuf = rtw_malloc(n);
if (!tmpbuf)
return -1;
err = _sd_read(intfhdl, addr, n, tmpbuf);
if (!err)
memcpy(buf, tmpbuf, cnt);
kfree(tmpbuf);
return err;
}
/*
* Todo: align address to 4 bytes.
*/
s32 sdio_local_read(
struct adapter *adapter,
u32 addr,
u32 cnt,
u8 *buf
)
{
struct intf_hdl *intfhdl;
u8 mac_pwr_ctrl_on;
s32 err;
u8 *tmpbuf;
u32 n;
intfhdl = &adapter->iopriv.intf;
hal_sdio_get_cmd_addr_8723b(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
if (
(!mac_pwr_ctrl_on) ||
(adapter_to_pwrctl(adapter)->fw_current_in_ps_mode)
)
return sd_cmd52_read(intfhdl, addr, cnt, buf);
n = round_up(cnt, 4);
tmpbuf = rtw_malloc(n);
if (!tmpbuf)
return -1;
err = sd_read(intfhdl, addr, n, tmpbuf);
if (!err)
memcpy(buf, tmpbuf, cnt);
kfree(tmpbuf);
return err;
}
/*
* Todo: align address to 4 bytes.
*/
s32 sdio_local_write(
struct adapter *adapter,
u32 addr,
u32 cnt,
u8 *buf
)
{
struct intf_hdl *intfhdl;
u8 mac_pwr_ctrl_on;
s32 err;
u8 *tmpbuf;
intfhdl = &adapter->iopriv.intf;
hal_sdio_get_cmd_addr_8723b(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
if (
(!mac_pwr_ctrl_on) ||
(adapter_to_pwrctl(adapter)->fw_current_in_ps_mode)
)
return sd_cmd52_write(intfhdl, addr, cnt, buf);
tmpbuf = rtw_malloc(cnt);
if (!tmpbuf)
return -1;
memcpy(tmpbuf, buf, cnt);
err = sd_write(intfhdl, addr, cnt, tmpbuf);
kfree(tmpbuf);
return err;
}
u8 SdioLocalCmd52Read1Byte(struct adapter *adapter, u32 addr)
{
u8 val = 0;
struct intf_hdl *intfhdl = &adapter->iopriv.intf;
hal_sdio_get_cmd_addr_8723b(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
sd_cmd52_read(intfhdl, addr, 1, &val);
return val;
}
static u16 sdio_local_cmd52_read2byte(struct adapter *adapter, u32 addr)
{
__le16 val = 0;
struct intf_hdl *intfhdl = &adapter->iopriv.intf;
hal_sdio_get_cmd_addr_8723b(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
sd_cmd52_read(intfhdl, addr, 2, (u8 *)&val);
return le16_to_cpu(val);
}
static u32 sdio_local_cmd53_read4byte(struct adapter *adapter, u32 addr)
{
u8 mac_pwr_ctrl_on;
u32 val = 0;
struct intf_hdl *intfhdl = &adapter->iopriv.intf;
__le32 le_tmp;
hal_sdio_get_cmd_addr_8723b(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
rtw_hal_get_hwreg(adapter, HW_VAR_APFM_ON_MAC, &mac_pwr_ctrl_on);
if (!mac_pwr_ctrl_on || adapter_to_pwrctl(adapter)->fw_current_in_ps_mode) {
sd_cmd52_read(intfhdl, addr, 4, (u8 *)&le_tmp);
val = le32_to_cpu(le_tmp);
} else {
val = sd_read32(intfhdl, addr, NULL);
}
return val;
}
void SdioLocalCmd52Write1Byte(struct adapter *adapter, u32 addr, u8 v)
{
struct intf_hdl *intfhdl = &adapter->iopriv.intf;
hal_sdio_get_cmd_addr_8723b(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
sd_cmd52_write(intfhdl, addr, 1, &v);
}
static void sdio_local_cmd52_write4byte(struct adapter *adapter, u32 addr, u32 v)
{
struct intf_hdl *intfhdl = &adapter->iopriv.intf;
__le32 le_tmp;
hal_sdio_get_cmd_addr_8723b(adapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
le_tmp = cpu_to_le32(v);
sd_cmd52_write(intfhdl, addr, 4, (u8 *)&le_tmp);
}
static s32 read_interrupt_8723b_sdio(struct adapter *adapter, u32 *phisr)
{
u32 hisr, himr;
u8 val8, hisr_len;
if (!phisr)
return false;
himr = GET_HAL_DATA(adapter)->sdio_himr;
/* decide how many bytes need to be read */
hisr_len = 0;
while (himr) {
hisr_len++;
himr >>= 8;
}
hisr = 0;
while (hisr_len != 0) {
hisr_len--;
val8 = SdioLocalCmd52Read1Byte(adapter, SDIO_REG_HISR + hisr_len);
hisr |= (val8 << (8 * hisr_len));
}
*phisr = hisr;
return true;
}
/* */
/* Description: */
/* Initialize SDIO Host Interrupt Mask configuration variables for future use. */
/* */
/* Assumption: */
/* Using SDIO Local register ONLY for configuration. */
/* */
/* Created by Roger, 2011.02.11. */
/* */
void InitInterrupt8723BSdio(struct adapter *adapter)
{
struct hal_com_data *haldata;
haldata = GET_HAL_DATA(adapter);
haldata->sdio_himr = (u32)(SDIO_HIMR_RX_REQUEST_MSK |
SDIO_HIMR_AVAL_MSK |
0);
}
/* */
/* Description: */
/* Initialize System Host Interrupt Mask configuration variables for future use. */
/* */
/* Created by Roger, 2011.08.03. */
/* */
void InitSysInterrupt8723BSdio(struct adapter *adapter)
{
struct hal_com_data *haldata;
haldata = GET_HAL_DATA(adapter);
haldata->SysIntrMask = (0);
}
/* */
/* Description: */
/* Enalbe SDIO Host Interrupt Mask configuration on SDIO local domain. */
/* */
/* Assumption: */
/* 1. Using SDIO Local register ONLY for configuration. */
/* 2. PASSIVE LEVEL */
/* */
/* Created by Roger, 2011.02.11. */
/* */
void EnableInterrupt8723BSdio(struct adapter *adapter)
{
struct hal_com_data *haldata;
__le32 himr;
u32 tmp;
haldata = GET_HAL_DATA(adapter);
himr = cpu_to_le32(haldata->sdio_himr);
sdio_local_write(adapter, SDIO_REG_HIMR, 4, (u8 *)&himr);
/* Update current system IMR settings */
tmp = rtw_read32(adapter, REG_HSIMR);
rtw_write32(adapter, REG_HSIMR, tmp | haldata->SysIntrMask);
/* */
/* <Roger_Notes> There are some C2H CMDs have been sent before system interrupt is enabled, e.g., C2H, CPWM. */
/* So we need to clear all C2H events that FW has notified, otherwise FW won't schedule any commands anymore. */
/* 2011.10.19. */
/* */
rtw_write8(adapter, REG_C2HEVT_CLEAR, C2H_EVT_HOST_CLOSE);
}
/* */
/* Description: */
/* Disable SDIO Host IMR configuration to mask unnecessary interrupt service. */
/* */
/* Assumption: */
/* Using SDIO Local register ONLY for configuration. */
/* */
/* Created by Roger, 2011.02.11. */
/* */
void DisableInterrupt8723BSdio(struct adapter *adapter)
{
__le32 himr;
himr = cpu_to_le32(SDIO_HIMR_DISABLED);
sdio_local_write(adapter, SDIO_REG_HIMR, 4, (u8 *)&himr);
}
/* */
/* Description: */
/* Using 0x100 to check the power status of FW. */
/* */
/* Assumption: */
/* Using SDIO Local register ONLY for configuration. */
/* */
/* Created by Isaac, 2013.09.10. */
/* */
u8 CheckIPSStatus(struct adapter *adapter)
{
if (rtw_read8(adapter, 0x100) == 0xEA)
return true;
else
return false;
}
static struct recv_buf *sd_recv_rxfifo(struct adapter *adapter, u32 size)
{
u32 readsize, ret;
u8 *readbuf;
struct recv_priv *recv_priv;
struct recv_buf *recvbuf;
/* Patch for some SDIO Host 4 bytes issue */
/* ex. RK3188 */
readsize = round_up(size, 4);
/* 3 1. alloc recvbuf */
recv_priv = &adapter->recvpriv;
recvbuf = rtw_dequeue_recvbuf(&recv_priv->free_recv_buf_queue);
if (!recvbuf) {
netdev_err(adapter->pnetdev, "%s: alloc recvbuf FAIL!\n",
__func__);
return NULL;
}
/* 3 2. alloc skb */
if (!recvbuf->pskb) {
SIZE_PTR tmpaddr = 0;
SIZE_PTR alignment = 0;
recvbuf->pskb = rtw_skb_alloc(MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ);
if (!recvbuf->pskb)
return NULL;
recvbuf->pskb->dev = adapter->pnetdev;
tmpaddr = (SIZE_PTR)recvbuf->pskb->data;
alignment = tmpaddr & (RECVBUFF_ALIGN_SZ - 1);
skb_reserve(recvbuf->pskb, (RECVBUFF_ALIGN_SZ - alignment));
}
/* 3 3. read data from rxfifo */
readbuf = recvbuf->pskb->data;
ret = sdio_read_port(&adapter->iopriv.intf, WLAN_RX0FF_DEVICE_ID, readsize, readbuf);
if (ret == _FAIL)
return NULL;
/* 3 4. init recvbuf */
recvbuf->len = size;
recvbuf->phead = recvbuf->pskb->head;
recvbuf->pdata = recvbuf->pskb->data;
skb_set_tail_pointer(recvbuf->pskb, size);
recvbuf->ptail = skb_tail_pointer(recvbuf->pskb);
recvbuf->pend = skb_end_pointer(recvbuf->pskb);
return recvbuf;
}
static void sd_rxhandler(struct adapter *adapter, struct recv_buf *recvbuf)
{
struct recv_priv *recv_priv;
struct __queue *pending_queue;
recv_priv = &adapter->recvpriv;
pending_queue = &recv_priv->recv_buf_pending_queue;
/* 3 1. enqueue recvbuf */
rtw_enqueue_recvbuf(recvbuf, pending_queue);
/* 3 2. schedule tasklet */
tasklet_schedule(&recv_priv->recv_tasklet);
}
void sd_int_dpc(struct adapter *adapter)
{
struct hal_com_data *hal;
struct dvobj_priv *dvobj;
struct intf_hdl *intfhdl = &adapter->iopriv.intf;
struct pwrctrl_priv *pwrctl;
hal = GET_HAL_DATA(adapter);
dvobj = adapter_to_dvobj(adapter);
pwrctl = dvobj_to_pwrctl(dvobj);
if (hal->sdio_hisr & SDIO_HISR_AVAL) {
u8 freepage[4];
_sdio_local_read(adapter, SDIO_REG_FREE_TXPG, 4, freepage);
complete(&(adapter->xmitpriv.xmit_comp));
}
if (hal->sdio_hisr & SDIO_HISR_CPWM1) {
del_timer_sync(&(pwrctl->pwr_rpwm_timer));
SdioLocalCmd52Read1Byte(adapter, SDIO_REG_HCPWM1_8723B);
_set_workitem(&(pwrctl->cpwm_event));
}
if (hal->sdio_hisr & SDIO_HISR_TXERR) {
u8 *status;
u32 addr;
status = rtw_malloc(4);
if (status) {
addr = REG_TXDMA_STATUS;
hal_sdio_get_cmd_addr_8723b(adapter, WLAN_IOREG_DEVICE_ID, addr, &addr);
_sd_read(intfhdl, addr, 4, status);
_sd_write(intfhdl, addr, 4, status);
kfree(status);
}
}
if (hal->sdio_hisr & SDIO_HISR_C2HCMD) {
struct c2h_evt_hdr_88xx *c2h_evt;
c2h_evt = rtw_zmalloc(16);
if (c2h_evt) {
if (c2h_evt_read_88xx(adapter, (u8 *)c2h_evt) == _SUCCESS) {
if (c2h_id_filter_ccx_8723b((u8 *)c2h_evt)) {
/* Handle CCX report here */
rtw_hal_c2h_handler(adapter, (u8 *)c2h_evt);
kfree(c2h_evt);
} else {
rtw_c2h_wk_cmd(adapter, (u8 *)c2h_evt);
}
} else {
kfree(c2h_evt);
}
} else {
/* Error handling for malloc fail */
rtw_cbuf_push(adapter->evtpriv.c2h_queue, NULL);
_set_workitem(&adapter->evtpriv.c2h_wk);
}
}
if (hal->sdio_hisr & SDIO_HISR_RX_REQUEST) {
struct recv_buf *recvbuf;
int alloc_fail_time = 0;
u32 hisr;
hal->sdio_hisr ^= SDIO_HISR_RX_REQUEST;
do {
hal->SdioRxFIFOSize = sdio_local_cmd52_read2byte(adapter, SDIO_REG_RX0_REQ_LEN);
if (hal->SdioRxFIFOSize != 0) {
recvbuf = sd_recv_rxfifo(adapter, hal->SdioRxFIFOSize);
if (recvbuf)
sd_rxhandler(adapter, recvbuf);
else {
alloc_fail_time++;
if (alloc_fail_time >= 10)
break;
}
hal->SdioRxFIFOSize = 0;
} else
break;
hisr = 0;
read_interrupt_8723b_sdio(adapter, &hisr);
hisr &= SDIO_HISR_RX_REQUEST;
if (!hisr)
break;
} while (1);
}
}
void sd_int_hdl(struct adapter *adapter)
{
struct hal_com_data *hal;
if (
(adapter->bDriverStopped) || (adapter->bSurpriseRemoved)
)
return;
hal = GET_HAL_DATA(adapter);
hal->sdio_hisr = 0;
read_interrupt_8723b_sdio(adapter, &hal->sdio_hisr);
if (hal->sdio_hisr & hal->sdio_himr) {
u32 v32;
hal->sdio_hisr &= hal->sdio_himr;
/* clear HISR */
v32 = hal->sdio_hisr & MASK_SDIO_HISR_CLEAR;
if (v32)
sdio_local_cmd52_write4byte(adapter, SDIO_REG_HISR, v32);
sd_int_dpc(adapter);
}
}
/* */
/* Description: */
/* Query SDIO Local register to query current the number of Free TxPacketBuffer page. */
/* */
/* Assumption: */
/* 1. Running at PASSIVE_LEVEL */
/* 2. RT_TX_SPINLOCK is NOT acquired. */
/* */
/* Created by Roger, 2011.01.28. */
/* */
u8 HalQueryTxBufferStatus8723BSdio(struct adapter *adapter)
{
struct hal_com_data *hal;
u32 numof_free_page;
hal = GET_HAL_DATA(adapter);
numof_free_page = sdio_local_cmd53_read4byte(adapter, SDIO_REG_FREE_TXPG);
memcpy(hal->SdioTxFIFOFreePage, &numof_free_page, 4);
return true;
}
/* */
/* Description: */
/* Query SDIO Local register to get the current number of TX OQT Free Space. */
/* */
void HalQueryTxOQTBufferStatus8723BSdio(struct adapter *adapter)
{
struct hal_com_data *haldata = GET_HAL_DATA(adapter);
haldata->SdioTxOQTFreeSpace = SdioLocalCmd52Read1Byte(adapter, SDIO_REG_OQT_FREE_PG);
}
| linux-master | drivers/staging/rtl8723bs/hal/sdio_ops.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <hal_data.h>
void rtw_hal_chip_configure(struct adapter *padapter)
{
if (padapter->HalFunc.intf_chip_configure)
padapter->HalFunc.intf_chip_configure(padapter);
}
void rtw_hal_read_chip_info(struct adapter *padapter)
{
if (padapter->HalFunc.read_adapter_info)
padapter->HalFunc.read_adapter_info(padapter);
}
void rtw_hal_read_chip_version(struct adapter *padapter)
{
if (padapter->HalFunc.read_chip_version)
padapter->HalFunc.read_chip_version(padapter);
}
void rtw_hal_def_value_init(struct adapter *padapter)
{
if (is_primary_adapter(padapter))
if (padapter->HalFunc.init_default_value)
padapter->HalFunc.init_default_value(padapter);
}
void rtw_hal_free_data(struct adapter *padapter)
{
/* free HAL Data */
rtw_hal_data_deinit(padapter);
if (is_primary_adapter(padapter))
if (padapter->HalFunc.free_hal_data)
padapter->HalFunc.free_hal_data(padapter);
}
void rtw_hal_dm_init(struct adapter *padapter)
{
if (is_primary_adapter(padapter))
if (padapter->HalFunc.dm_init)
padapter->HalFunc.dm_init(padapter);
}
void rtw_hal_dm_deinit(struct adapter *padapter)
{
/* cancel dm timer */
if (is_primary_adapter(padapter))
if (padapter->HalFunc.dm_deinit)
padapter->HalFunc.dm_deinit(padapter);
}
static void rtw_hal_init_opmode(struct adapter *padapter)
{
enum ndis_802_11_network_infrastructure networkType = Ndis802_11InfrastructureMax;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
signed int fw_state;
fw_state = get_fwstate(pmlmepriv);
if (fw_state & WIFI_ADHOC_STATE)
networkType = Ndis802_11IBSS;
else if (fw_state & WIFI_STATION_STATE)
networkType = Ndis802_11Infrastructure;
else if (fw_state & WIFI_AP_STATE)
networkType = Ndis802_11APMode;
else
return;
rtw_setopmode_cmd(padapter, networkType, false);
}
uint rtw_hal_init(struct adapter *padapter)
{
uint status;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
status = padapter->HalFunc.hal_init(padapter);
if (status == _SUCCESS) {
rtw_hal_init_opmode(padapter);
dvobj->padapters->hw_init_completed = true;
if (padapter->registrypriv.notch_filter == 1)
rtw_hal_notch_filter(padapter, 1);
rtw_hal_reset_security_engine(padapter);
rtw_sec_restore_wep_key(dvobj->padapters);
init_hw_mlme_ext(padapter);
rtw_bb_rf_gain_offset(padapter);
} else {
dvobj->padapters->hw_init_completed = false;
}
return status;
}
uint rtw_hal_deinit(struct adapter *padapter)
{
uint status = _SUCCESS;
struct dvobj_priv *dvobj = adapter_to_dvobj(padapter);
status = padapter->HalFunc.hal_deinit(padapter);
if (status == _SUCCESS) {
padapter = dvobj->padapters;
padapter->hw_init_completed = false;
}
return status;
}
void rtw_hal_set_hwreg(struct adapter *padapter, u8 variable, u8 *val)
{
if (padapter->HalFunc.SetHwRegHandler)
padapter->HalFunc.SetHwRegHandler(padapter, variable, val);
}
void rtw_hal_get_hwreg(struct adapter *padapter, u8 variable, u8 *val)
{
if (padapter->HalFunc.GetHwRegHandler)
padapter->HalFunc.GetHwRegHandler(padapter, variable, val);
}
void rtw_hal_set_hwreg_with_buf(struct adapter *padapter, u8 variable, u8 *pbuf, int len)
{
if (padapter->HalFunc.SetHwRegHandlerWithBuf)
padapter->HalFunc.SetHwRegHandlerWithBuf(padapter, variable, pbuf, len);
}
u8 rtw_hal_set_def_var(struct adapter *padapter, enum hal_def_variable eVariable, void *pValue)
{
if (padapter->HalFunc.SetHalDefVarHandler)
return padapter->HalFunc.SetHalDefVarHandler(padapter, eVariable, pValue);
return _FAIL;
}
u8 rtw_hal_get_def_var(struct adapter *padapter, enum hal_def_variable eVariable, void *pValue)
{
if (padapter->HalFunc.GetHalDefVarHandler)
return padapter->HalFunc.GetHalDefVarHandler(padapter, eVariable, pValue);
return _FAIL;
}
void rtw_hal_set_odm_var(struct adapter *padapter, enum hal_odm_variable eVariable, void *pValue1, bool bSet)
{
if (padapter->HalFunc.SetHalODMVarHandler)
padapter->HalFunc.SetHalODMVarHandler(padapter, eVariable, pValue1, bSet);
}
void rtw_hal_get_odm_var(struct adapter *padapter, enum hal_odm_variable eVariable, void *pValue1, void *pValue2)
{
if (padapter->HalFunc.GetHalODMVarHandler)
padapter->HalFunc.GetHalODMVarHandler(padapter, eVariable, pValue1, pValue2);
}
void rtw_hal_enable_interrupt(struct adapter *padapter)
{
if (padapter->HalFunc.enable_interrupt)
padapter->HalFunc.enable_interrupt(padapter);
}
void rtw_hal_disable_interrupt(struct adapter *padapter)
{
if (padapter->HalFunc.disable_interrupt)
padapter->HalFunc.disable_interrupt(padapter);
}
u8 rtw_hal_check_ips_status(struct adapter *padapter)
{
u8 val = false;
if (padapter->HalFunc.check_ips_status)
val = padapter->HalFunc.check_ips_status(padapter);
return val;
}
s32 rtw_hal_xmitframe_enqueue(struct adapter *padapter, struct xmit_frame *pxmitframe)
{
if (padapter->HalFunc.hal_xmitframe_enqueue)
return padapter->HalFunc.hal_xmitframe_enqueue(padapter, pxmitframe);
return false;
}
s32 rtw_hal_xmit(struct adapter *padapter, struct xmit_frame *pxmitframe)
{
if (padapter->HalFunc.hal_xmit)
return padapter->HalFunc.hal_xmit(padapter, pxmitframe);
return false;
}
/*
* [IMPORTANT] This function would be run in interrupt context.
*/
s32 rtw_hal_mgnt_xmit(struct adapter *padapter, struct xmit_frame *pmgntframe)
{
s32 ret = _FAIL;
update_mgntframe_attrib_addr(padapter, pmgntframe);
/* pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET; */
/* pwlanhdr = (struct rtw_ieee80211_hdr *)pframe; */
/* memcpy(pmgntframe->attrib.ra, pwlanhdr->addr1, ETH_ALEN); */
if (padapter->securitypriv.binstallBIPkey == true) {
if (is_multicast_ether_addr(pmgntframe->attrib.ra)) {
pmgntframe->attrib.encrypt = _BIP_;
/* pmgntframe->attrib.bswenc = true; */
} else {
pmgntframe->attrib.encrypt = _AES_;
pmgntframe->attrib.bswenc = true;
}
rtw_mgmt_xmitframe_coalesce(padapter, pmgntframe->pkt, pmgntframe);
}
if (padapter->HalFunc.mgnt_xmit)
ret = padapter->HalFunc.mgnt_xmit(padapter, pmgntframe);
return ret;
}
s32 rtw_hal_init_xmit_priv(struct adapter *padapter)
{
if (padapter->HalFunc.init_xmit_priv)
return padapter->HalFunc.init_xmit_priv(padapter);
return _FAIL;
}
void rtw_hal_free_xmit_priv(struct adapter *padapter)
{
if (padapter->HalFunc.free_xmit_priv)
padapter->HalFunc.free_xmit_priv(padapter);
}
s32 rtw_hal_init_recv_priv(struct adapter *padapter)
{
if (padapter->HalFunc.init_recv_priv)
return padapter->HalFunc.init_recv_priv(padapter);
return _FAIL;
}
void rtw_hal_free_recv_priv(struct adapter *padapter)
{
if (padapter->HalFunc.free_recv_priv)
padapter->HalFunc.free_recv_priv(padapter);
}
void rtw_hal_update_ra_mask(struct sta_info *psta, u8 rssi_level)
{
struct adapter *padapter;
struct mlme_priv *pmlmepriv;
if (!psta)
return;
padapter = psta->padapter;
pmlmepriv = &(padapter->mlmepriv);
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
add_RATid(padapter, psta, rssi_level);
else {
if (padapter->HalFunc.UpdateRAMaskHandler)
padapter->HalFunc.UpdateRAMaskHandler(padapter, psta->mac_id, rssi_level);
}
}
void rtw_hal_add_ra_tid(struct adapter *padapter, u32 bitmap, u8 *arg, u8 rssi_level)
{
if (padapter->HalFunc.Add_RateATid)
padapter->HalFunc.Add_RateATid(padapter, bitmap, arg, rssi_level);
}
/*Start specifical interface thread */
void rtw_hal_start_thread(struct adapter *padapter)
{
if (padapter->HalFunc.run_thread)
padapter->HalFunc.run_thread(padapter);
}
/*Start specifical interface thread */
void rtw_hal_stop_thread(struct adapter *padapter)
{
if (padapter->HalFunc.cancel_thread)
padapter->HalFunc.cancel_thread(padapter);
}
u32 rtw_hal_read_bbreg(struct adapter *padapter, u32 RegAddr, u32 BitMask)
{
u32 data = 0;
if (padapter->HalFunc.read_bbreg)
data = padapter->HalFunc.read_bbreg(padapter, RegAddr, BitMask);
return data;
}
void rtw_hal_write_bbreg(struct adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data)
{
if (padapter->HalFunc.write_bbreg)
padapter->HalFunc.write_bbreg(padapter, RegAddr, BitMask, Data);
}
u32 rtw_hal_read_rfreg(struct adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask)
{
u32 data = 0;
if (padapter->HalFunc.read_rfreg)
data = padapter->HalFunc.read_rfreg(padapter, eRFPath, RegAddr, BitMask);
return data;
}
void rtw_hal_write_rfreg(struct adapter *padapter, u32 eRFPath, u32 RegAddr, u32 BitMask, u32 Data)
{
if (padapter->HalFunc.write_rfreg)
padapter->HalFunc.write_rfreg(padapter, eRFPath, RegAddr, BitMask, Data);
}
void rtw_hal_set_chan(struct adapter *padapter, u8 channel)
{
if (padapter->HalFunc.set_channel_handler)
padapter->HalFunc.set_channel_handler(padapter, channel);
}
void rtw_hal_set_chnl_bw(struct adapter *padapter, u8 channel,
enum channel_width Bandwidth, u8 Offset40, u8 Offset80)
{
if (padapter->HalFunc.set_chnl_bw_handler)
padapter->HalFunc.set_chnl_bw_handler(padapter, channel,
Bandwidth, Offset40,
Offset80);
}
void rtw_hal_dm_watchdog(struct adapter *padapter)
{
if (padapter->HalFunc.hal_dm_watchdog)
padapter->HalFunc.hal_dm_watchdog(padapter);
}
void rtw_hal_dm_watchdog_in_lps(struct adapter *padapter)
{
if (adapter_to_pwrctl(padapter)->fw_current_in_ps_mode) {
if (padapter->HalFunc.hal_dm_watchdog_in_lps)
padapter->HalFunc.hal_dm_watchdog_in_lps(padapter); /* this function caller is in interrupt context */
}
}
void beacon_timing_control(struct adapter *padapter)
{
if (padapter->HalFunc.SetBeaconRelatedRegistersHandler)
padapter->HalFunc.SetBeaconRelatedRegistersHandler(padapter);
}
s32 rtw_hal_xmit_thread_handler(struct adapter *padapter)
{
if (padapter->HalFunc.xmit_thread_handler)
return padapter->HalFunc.xmit_thread_handler(padapter);
return _FAIL;
}
void rtw_hal_notch_filter(struct adapter *adapter, bool enable)
{
if (adapter->HalFunc.hal_notch_filter)
adapter->HalFunc.hal_notch_filter(adapter, enable);
}
void rtw_hal_reset_security_engine(struct adapter *adapter)
{
if (adapter->HalFunc.hal_reset_security_engine)
adapter->HalFunc.hal_reset_security_engine(adapter);
}
bool rtw_hal_c2h_valid(struct adapter *adapter, u8 *buf)
{
return c2h_evt_valid((struct c2h_evt_hdr_88xx *)buf);
}
s32 rtw_hal_c2h_handler(struct adapter *adapter, u8 *c2h_evt)
{
s32 ret = _FAIL;
if (adapter->HalFunc.c2h_handler)
ret = adapter->HalFunc.c2h_handler(adapter, c2h_evt);
return ret;
}
c2h_id_filter rtw_hal_c2h_id_filter_ccx(struct adapter *adapter)
{
return adapter->HalFunc.c2h_id_filter_ccx;
}
s32 rtw_hal_macid_sleep(struct adapter *padapter, u32 macid)
{
u8 support;
support = false;
rtw_hal_get_def_var(padapter, HAL_DEF_MACID_SLEEP, &support);
if (false == support)
return _FAIL;
rtw_hal_set_hwreg(padapter, HW_VAR_MACID_SLEEP, (u8 *)&macid);
return _SUCCESS;
}
s32 rtw_hal_macid_wakeup(struct adapter *padapter, u32 macid)
{
u8 support;
support = false;
rtw_hal_get_def_var(padapter, HAL_DEF_MACID_SLEEP, &support);
if (false == support)
return _FAIL;
rtw_hal_set_hwreg(padapter, HW_VAR_MACID_WAKEUP, (u8 *)&macid);
return _SUCCESS;
}
s32 rtw_hal_fill_h2c_cmd(struct adapter *padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
{
s32 ret = _FAIL;
if (padapter->HalFunc.fill_h2c_cmd)
ret = padapter->HalFunc.fill_h2c_cmd(padapter, ElementID, CmdLen, pCmdBuffer);
return ret;
}
| linux-master | drivers/staging/rtl8723bs/hal/hal_intf.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtl8723b_hal.h>
#include "hal_com_h2c.h"
/*
* Description:
*Call power on sequence to enable card
*
* Return:
*_SUCCESS enable success
*_FAIL enable fail
*/
static u8 CardEnable(struct adapter *padapter)
{
u8 bMacPwrCtrlOn;
u8 ret = _FAIL;
rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
if (!bMacPwrCtrlOn) {
/* RSV_CTRL 0x1C[7:0] = 0x00 */
/* unlock ISO/CLK/Power control register */
rtw_write8(padapter, REG_RSV_CTRL, 0x0);
ret = HalPwrSeqCmdParsing(padapter, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK, PWR_INTF_SDIO_MSK, rtl8723B_card_enable_flow);
if (ret == _SUCCESS) {
u8 bMacPwrCtrlOn = true;
rtw_hal_set_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
}
} else
ret = _SUCCESS;
return ret;
}
static
u8 _InitPowerOn_8723BS(struct adapter *padapter)
{
u8 value8;
u16 value16;
u32 value32;
u8 ret;
/* u8 bMacPwrCtrlOn; */
/* all of these MUST be configured before power on */
/* only cmd52 can be used before power on(card enable) */
ret = CardEnable(padapter);
if (!ret)
return _FAIL;
/* Radio-Off Pin Trigger */
value8 = rtw_read8(padapter, REG_GPIO_INTM + 1);
value8 |= BIT(1); /* Enable falling edge triggering interrupt */
rtw_write8(padapter, REG_GPIO_INTM + 1, value8);
value8 = rtw_read8(padapter, REG_GPIO_IO_SEL_2 + 1);
value8 |= BIT(1);
rtw_write8(padapter, REG_GPIO_IO_SEL_2 + 1, value8);
/* Enable power down and GPIO interrupt */
value16 = rtw_read16(padapter, REG_APS_FSMCO);
value16 |= EnPDN; /* Enable HW power down and RF on */
rtw_write16(padapter, REG_APS_FSMCO, value16);
/* Enable CMD53 R/W Operation */
/* bMacPwrCtrlOn = true; */
/* rtw_hal_set_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn); */
rtw_write8(padapter, REG_CR, 0x00);
/* Enable MAC DMA/WMAC/SCHEDULE/SEC block */
value16 = rtw_read16(padapter, REG_CR);
value16 |= (
HCI_TXDMA_EN |
HCI_RXDMA_EN |
TXDMA_EN |
RXDMA_EN |
PROTOCOL_EN |
SCHEDULE_EN |
ENSEC |
CALTMR_EN
);
rtw_write16(padapter, REG_CR, value16);
hal_btcoex_PowerOnSetting(padapter);
/* external switch to S1 */
/* 0x38[11] = 0x1 */
/* 0x4c[23] = 0x1 */
/* 0x64[0] = 0 */
value16 = rtw_read16(padapter, REG_PWR_DATA);
/* Switch the control of EESK, EECS to RFC for DPDT or Antenna switch */
value16 |= BIT(11); /* BIT_EEPRPAD_RFE_CTRL_EN */
rtw_write16(padapter, REG_PWR_DATA, value16);
value32 = rtw_read32(padapter, REG_LEDCFG0);
value32 |= BIT(23); /* DPDT_SEL_EN, 1 for SW control */
rtw_write32(padapter, REG_LEDCFG0, value32);
value8 = rtw_read8(padapter, REG_PAD_CTRL1_8723B);
value8 &= ~BIT(0); /* BIT_SW_DPDT_SEL_DATA, DPDT_SEL default configuration */
rtw_write8(padapter, REG_PAD_CTRL1_8723B, value8);
return _SUCCESS;
}
/* Tx Page FIFO threshold */
static void _init_available_page_threshold(struct adapter *padapter, u8 numHQ, u8 numNQ, u8 numLQ, u8 numPubQ)
{
u16 HQ_threshold, NQ_threshold, LQ_threshold;
HQ_threshold = (numPubQ + numHQ + 1) >> 1;
HQ_threshold |= (HQ_threshold << 8);
NQ_threshold = (numPubQ + numNQ + 1) >> 1;
NQ_threshold |= (NQ_threshold << 8);
LQ_threshold = (numPubQ + numLQ + 1) >> 1;
LQ_threshold |= (LQ_threshold << 8);
rtw_write16(padapter, 0x218, HQ_threshold);
rtw_write16(padapter, 0x21A, NQ_threshold);
rtw_write16(padapter, 0x21C, LQ_threshold);
}
static void _InitQueueReservedPage(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct registry_priv *pregistrypriv = &padapter->registrypriv;
u32 numHQ = 0;
u32 numLQ = 0;
u32 numNQ = 0;
u32 numPubQ;
u32 value32;
u8 value8;
bool bWiFiConfig = pregistrypriv->wifi_spec;
if (pHalData->OutEpQueueSel & TX_SELE_HQ)
numHQ = bWiFiConfig ? WMM_NORMAL_PAGE_NUM_HPQ_8723B : NORMAL_PAGE_NUM_HPQ_8723B;
if (pHalData->OutEpQueueSel & TX_SELE_LQ)
numLQ = bWiFiConfig ? WMM_NORMAL_PAGE_NUM_LPQ_8723B : NORMAL_PAGE_NUM_LPQ_8723B;
/* NOTE: This step shall be proceed before writing REG_RQPN. */
if (pHalData->OutEpQueueSel & TX_SELE_NQ)
numNQ = bWiFiConfig ? WMM_NORMAL_PAGE_NUM_NPQ_8723B : NORMAL_PAGE_NUM_NPQ_8723B;
numPubQ = TX_TOTAL_PAGE_NUMBER_8723B - numHQ - numLQ - numNQ;
value8 = (u8)_NPQ(numNQ);
rtw_write8(padapter, REG_RQPN_NPQ, value8);
/* TX DMA */
value32 = _HPQ(numHQ) | _LPQ(numLQ) | _PUBQ(numPubQ) | LD_RQPN;
rtw_write32(padapter, REG_RQPN, value32);
rtw_hal_set_sdio_tx_max_length(padapter, numHQ, numNQ, numLQ, numPubQ);
_init_available_page_threshold(padapter, numHQ, numNQ, numLQ, numPubQ);
}
static void _InitTxBufferBoundary(struct adapter *padapter)
{
struct registry_priv *pregistrypriv = &padapter->registrypriv;
/* u16 txdmactrl; */
u8 txpktbuf_bndy;
if (!pregistrypriv->wifi_spec) {
txpktbuf_bndy = TX_PAGE_BOUNDARY_8723B;
} else {
/* for WMM */
txpktbuf_bndy = WMM_NORMAL_TX_PAGE_BOUNDARY_8723B;
}
rtw_write8(padapter, REG_TXPKTBUF_BCNQ_BDNY_8723B, txpktbuf_bndy);
rtw_write8(padapter, REG_TXPKTBUF_MGQ_BDNY_8723B, txpktbuf_bndy);
rtw_write8(padapter, REG_TXPKTBUF_WMAC_LBK_BF_HD_8723B, txpktbuf_bndy);
rtw_write8(padapter, REG_TRXFF_BNDY, txpktbuf_bndy);
rtw_write8(padapter, REG_TDECTRL + 1, txpktbuf_bndy);
}
static void _InitNormalChipRegPriority(
struct adapter *Adapter,
u16 beQ,
u16 bkQ,
u16 viQ,
u16 voQ,
u16 mgtQ,
u16 hiQ
)
{
u16 value16 = (rtw_read16(Adapter, REG_TRXDMA_CTRL) & 0x7);
value16 |=
_TXDMA_BEQ_MAP(beQ) |
_TXDMA_BKQ_MAP(bkQ) |
_TXDMA_VIQ_MAP(viQ) |
_TXDMA_VOQ_MAP(voQ) |
_TXDMA_MGQ_MAP(mgtQ) |
_TXDMA_HIQ_MAP(hiQ);
rtw_write16(Adapter, REG_TRXDMA_CTRL, value16);
}
static void _InitNormalChipOneOutEpPriority(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
u16 value = 0;
switch (pHalData->OutEpQueueSel) {
case TX_SELE_HQ:
value = QUEUE_HIGH;
break;
case TX_SELE_LQ:
value = QUEUE_LOW;
break;
case TX_SELE_NQ:
value = QUEUE_NORMAL;
break;
default:
break;
}
_InitNormalChipRegPriority(
Adapter, value, value, value, value, value, value
);
}
static void _InitNormalChipTwoOutEpPriority(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct registry_priv *pregistrypriv = &Adapter->registrypriv;
u16 beQ, bkQ, viQ, voQ, mgtQ, hiQ;
u16 valueHi = 0;
u16 valueLow = 0;
switch (pHalData->OutEpQueueSel) {
case (TX_SELE_HQ | TX_SELE_LQ):
valueHi = QUEUE_HIGH;
valueLow = QUEUE_LOW;
break;
case (TX_SELE_NQ | TX_SELE_LQ):
valueHi = QUEUE_NORMAL;
valueLow = QUEUE_LOW;
break;
case (TX_SELE_HQ | TX_SELE_NQ):
valueHi = QUEUE_HIGH;
valueLow = QUEUE_NORMAL;
break;
default:
break;
}
if (!pregistrypriv->wifi_spec) {
beQ = valueLow;
bkQ = valueLow;
viQ = valueHi;
voQ = valueHi;
mgtQ = valueHi;
hiQ = valueHi;
} else {
/* for WMM , CONFIG_OUT_EP_WIFI_MODE */
beQ = valueLow;
bkQ = valueHi;
viQ = valueHi;
voQ = valueLow;
mgtQ = valueHi;
hiQ = valueHi;
}
_InitNormalChipRegPriority(Adapter, beQ, bkQ, viQ, voQ, mgtQ, hiQ);
}
static void _InitNormalChipThreeOutEpPriority(struct adapter *padapter)
{
struct registry_priv *pregistrypriv = &padapter->registrypriv;
u16 beQ, bkQ, viQ, voQ, mgtQ, hiQ;
if (!pregistrypriv->wifi_spec) {
/* typical setting */
beQ = QUEUE_LOW;
bkQ = QUEUE_LOW;
viQ = QUEUE_NORMAL;
voQ = QUEUE_HIGH;
mgtQ = QUEUE_HIGH;
hiQ = QUEUE_HIGH;
} else {
/* for WMM */
beQ = QUEUE_LOW;
bkQ = QUEUE_NORMAL;
viQ = QUEUE_NORMAL;
voQ = QUEUE_HIGH;
mgtQ = QUEUE_HIGH;
hiQ = QUEUE_HIGH;
}
_InitNormalChipRegPriority(padapter, beQ, bkQ, viQ, voQ, mgtQ, hiQ);
}
static void _InitQueuePriority(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
switch (pHalData->OutEpNumber) {
case 1:
_InitNormalChipOneOutEpPriority(Adapter);
break;
case 2:
_InitNormalChipTwoOutEpPriority(Adapter);
break;
case 3:
_InitNormalChipThreeOutEpPriority(Adapter);
break;
default:
break;
}
}
static void _InitPageBoundary(struct adapter *padapter)
{
/* RX Page Boundary */
u16 rxff_bndy = RX_DMA_BOUNDARY_8723B;
rtw_write16(padapter, (REG_TRXFF_BNDY + 2), rxff_bndy);
}
static void _InitTransferPageSize(struct adapter *padapter)
{
/* Tx page size is always 128. */
u8 value8;
value8 = _PSRX(PBP_128) | _PSTX(PBP_128);
rtw_write8(padapter, REG_PBP, value8);
}
static void _InitDriverInfoSize(struct adapter *padapter, u8 drvInfoSize)
{
rtw_write8(padapter, REG_RX_DRVINFO_SZ, drvInfoSize);
}
static void _InitNetworkType(struct adapter *padapter)
{
u32 value32;
value32 = rtw_read32(padapter, REG_CR);
/* TODO: use the other function to set network type */
/* value32 = (value32 & ~MASK_NETTYPE) | _NETTYPE(NT_LINK_AD_HOC); */
value32 = (value32 & ~MASK_NETTYPE) | _NETTYPE(NT_LINK_AP);
rtw_write32(padapter, REG_CR, value32);
}
static void _InitWMACSetting(struct adapter *padapter)
{
struct hal_com_data *pHalData;
u16 value16;
pHalData = GET_HAL_DATA(padapter);
pHalData->ReceiveConfig = 0;
pHalData->ReceiveConfig |= RCR_APM | RCR_AM | RCR_AB;
pHalData->ReceiveConfig |= RCR_CBSSID_DATA | RCR_CBSSID_BCN | RCR_AMF;
pHalData->ReceiveConfig |= RCR_HTC_LOC_CTRL;
pHalData->ReceiveConfig |= RCR_APP_PHYST_RXFF | RCR_APP_ICV | RCR_APP_MIC;
rtw_write32(padapter, REG_RCR, pHalData->ReceiveConfig);
/* Accept all multicast address */
rtw_write32(padapter, REG_MAR, 0xFFFFFFFF);
rtw_write32(padapter, REG_MAR + 4, 0xFFFFFFFF);
/* Accept all data frames */
value16 = 0xFFFF;
rtw_write16(padapter, REG_RXFLTMAP2, value16);
/* 2010.09.08 hpfan */
/* Since ADF is removed from RCR, ps-poll will not be indicate to driver, */
/* RxFilterMap should mask ps-poll to gurantee AP mode can rx ps-poll. */
value16 = 0x400;
rtw_write16(padapter, REG_RXFLTMAP1, value16);
/* Accept all management frames */
value16 = 0xFFFF;
rtw_write16(padapter, REG_RXFLTMAP0, value16);
}
static void _InitAdaptiveCtrl(struct adapter *padapter)
{
u16 value16;
u32 value32;
/* Response Rate Set */
value32 = rtw_read32(padapter, REG_RRSR);
value32 &= ~RATE_BITMAP_ALL;
value32 |= RATE_RRSR_CCK_ONLY_1M;
rtw_write32(padapter, REG_RRSR, value32);
/* CF-END Threshold */
/* m_spIoBase->rtw_write8(REG_CFEND_TH, 0x1); */
/* SIFS (used in NAV) */
value16 = _SPEC_SIFS_CCK(0x10) | _SPEC_SIFS_OFDM(0x10);
rtw_write16(padapter, REG_SPEC_SIFS, value16);
/* Retry Limit */
value16 = _LRL(0x30) | _SRL(0x30);
rtw_write16(padapter, REG_RL, value16);
}
static void _InitEDCA(struct adapter *padapter)
{
/* Set Spec SIFS (used in NAV) */
rtw_write16(padapter, REG_SPEC_SIFS, 0x100a);
rtw_write16(padapter, REG_MAC_SPEC_SIFS, 0x100a);
/* Set SIFS for CCK */
rtw_write16(padapter, REG_SIFS_CTX, 0x100a);
/* Set SIFS for OFDM */
rtw_write16(padapter, REG_SIFS_TRX, 0x100a);
/* TXOP */
rtw_write32(padapter, REG_EDCA_BE_PARAM, 0x005EA42B);
rtw_write32(padapter, REG_EDCA_BK_PARAM, 0x0000A44F);
rtw_write32(padapter, REG_EDCA_VI_PARAM, 0x005EA324);
rtw_write32(padapter, REG_EDCA_VO_PARAM, 0x002FA226);
}
static void _InitRetryFunction(struct adapter *padapter)
{
u8 value8;
value8 = rtw_read8(padapter, REG_FWHW_TXQ_CTRL);
value8 |= EN_AMPDU_RTY_NEW;
rtw_write8(padapter, REG_FWHW_TXQ_CTRL, value8);
/* Set ACK timeout */
rtw_write8(padapter, REG_ACKTO, 0x40);
}
static void HalRxAggr8723BSdio(struct adapter *padapter)
{
u8 valueDMATimeout;
u8 valueDMAPageCount;
valueDMATimeout = 0x06;
valueDMAPageCount = 0x06;
rtw_write8(padapter, REG_RXDMA_AGG_PG_TH + 1, valueDMATimeout);
rtw_write8(padapter, REG_RXDMA_AGG_PG_TH, valueDMAPageCount);
}
static void sdio_AggSettingRxUpdate(struct adapter *padapter)
{
u8 valueDMA;
u8 valueRxAggCtrl = 0;
u8 aggBurstNum = 3; /* 0:1, 1:2, 2:3, 3:4 */
u8 aggBurstSize = 0; /* 0:1K, 1:512Byte, 2:256Byte... */
valueDMA = rtw_read8(padapter, REG_TRXDMA_CTRL);
valueDMA |= RXDMA_AGG_EN;
rtw_write8(padapter, REG_TRXDMA_CTRL, valueDMA);
valueRxAggCtrl |= RXDMA_AGG_MODE_EN;
valueRxAggCtrl |= ((aggBurstNum << 2) & 0x0C);
valueRxAggCtrl |= ((aggBurstSize << 4) & 0x30);
rtw_write8(padapter, REG_RXDMA_MODE_CTRL_8723B, valueRxAggCtrl);/* RxAggLowThresh = 4*1K */
}
static void _initSdioAggregationSetting(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
/* Tx aggregation setting */
/* sdio_AggSettingTxUpdate(padapter); */
/* Rx aggregation setting */
HalRxAggr8723BSdio(padapter);
sdio_AggSettingRxUpdate(padapter);
/* 201/12/10 MH Add for USB agg mode dynamic switch. */
pHalData->UsbRxHighSpeedMode = false;
}
static void _InitOperationMode(struct adapter *padapter)
{
struct mlme_ext_priv *pmlmeext;
u8 regBwOpMode = 0;
pmlmeext = &padapter->mlmeextpriv;
/* 1 This part need to modified according to the rate set we filtered!! */
/* */
/* Set RRSR, RATR, and REG_BWOPMODE registers */
/* */
switch (pmlmeext->cur_wireless_mode) {
case WIRELESS_MODE_B:
regBwOpMode = BW_OPMODE_20MHZ;
break;
case WIRELESS_MODE_G:
regBwOpMode = BW_OPMODE_20MHZ;
break;
case WIRELESS_MODE_AUTO:
regBwOpMode = BW_OPMODE_20MHZ;
break;
case WIRELESS_MODE_N_24G:
/* It support CCK rate by default. */
/* CCK rate will be filtered out only when associated AP does not support it. */
regBwOpMode = BW_OPMODE_20MHZ;
break;
default: /* for MacOSX compiler warning. */
break;
}
rtw_write8(padapter, REG_BWOPMODE, regBwOpMode);
}
static void _InitInterrupt(struct adapter *padapter)
{
/* HISR - turn all off */
rtw_write32(padapter, REG_HISR, 0);
/* HIMR - turn all off */
rtw_write32(padapter, REG_HIMR, 0);
/* */
/* Initialize and enable SDIO Host Interrupt. */
/* */
InitInterrupt8723BSdio(padapter);
/* */
/* Initialize system Host Interrupt. */
/* */
InitSysInterrupt8723BSdio(padapter);
}
static void _InitRFType(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
pHalData->rf_chip = RF_6052;
}
static void _RfPowerSave(struct adapter *padapter)
{
/* YJ, TODO */
}
/* */
/* 2010/08/09 MH Add for power down check. */
/* */
static bool HalDetectPwrDownMode(struct adapter *Adapter)
{
u8 tmpvalue;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(Adapter);
EFUSE_ShadowRead(Adapter, 1, 0x7B/*EEPROM_RF_OPT3_92C*/, (u32 *)&tmpvalue);
/* 2010/08/25 MH INF priority > PDN Efuse value. */
if (tmpvalue & BIT4 && pwrctrlpriv->reg_pdnmode)
pHalData->pwrdown = true;
else
pHalData->pwrdown = false;
return pHalData->pwrdown;
} /* HalDetectPwrDownMode */
static u32 rtl8723bs_hal_init(struct adapter *padapter)
{
s32 ret;
struct hal_com_data *pHalData;
struct pwrctrl_priv *pwrctrlpriv;
u32 NavUpper = WiFiNavUpperUs;
u8 u1bTmp;
pHalData = GET_HAL_DATA(padapter);
pwrctrlpriv = adapter_to_pwrctl(padapter);
if (
adapter_to_pwrctl(padapter)->bips_processing == true &&
adapter_to_pwrctl(padapter)->pre_ips_type == 0
) {
unsigned long start_time;
u8 cpwm_orig, cpwm_now;
u8 val8, bMacPwrCtrlOn = true;
/* for polling cpwm */
cpwm_orig = 0;
rtw_hal_get_hwreg(padapter, HW_VAR_CPWM, &cpwm_orig);
/* ser rpwm */
val8 = rtw_read8(padapter, SDIO_LOCAL_BASE | SDIO_REG_HRPWM1);
val8 &= 0x80;
val8 += 0x80;
val8 |= BIT(6);
rtw_write8(padapter, SDIO_LOCAL_BASE | SDIO_REG_HRPWM1, val8);
adapter_to_pwrctl(padapter)->tog = (val8 + 0x80) & 0x80;
/* do polling cpwm */
start_time = jiffies;
do {
mdelay(1);
rtw_hal_get_hwreg(padapter, HW_VAR_CPWM, &cpwm_now);
if ((cpwm_orig ^ cpwm_now) & 0x80)
break;
if (jiffies_to_msecs(jiffies - start_time) > 100)
break;
} while (1);
rtl8723b_set_FwPwrModeInIPS_cmd(padapter, 0);
rtw_hal_set_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
hal_btcoex_InitHwConfig(padapter, false);
return _SUCCESS;
}
/* Disable Interrupt first. */
/* rtw_hal_disable_interrupt(padapter); */
ret = _InitPowerOn_8723BS(padapter);
if (ret == _FAIL)
return _FAIL;
rtw_write8(padapter, REG_EARLY_MODE_CONTROL, 0);
ret = rtl8723b_FirmwareDownload(padapter, false);
if (ret != _SUCCESS) {
padapter->bFWReady = false;
pHalData->fw_ractrl = false;
return ret;
} else {
padapter->bFWReady = true;
pHalData->fw_ractrl = true;
}
rtl8723b_InitializeFirmwareVars(padapter);
/* SIC_Init(padapter); */
if (pwrctrlpriv->reg_rfoff)
pwrctrlpriv->rf_pwrstate = rf_off;
/* 2010/08/09 MH We need to check if we need to turnon or off RF after detecting */
/* HW GPIO pin. Before PHY_RFConfig8192C. */
HalDetectPwrDownMode(padapter);
/* Set RF type for BB/RF configuration */
_InitRFType(padapter);
/* Save target channel */
/* <Roger_Notes> Current Channel will be updated again later. */
pHalData->CurrentChannel = 6;
ret = PHY_MACConfig8723B(padapter);
if (ret != _SUCCESS)
return ret;
/* */
/* d. Initialize BB related configurations. */
/* */
ret = PHY_BBConfig8723B(padapter);
if (ret != _SUCCESS)
return ret;
/* If RF is on, we need to init RF. Otherwise, skip the procedure. */
/* We need to follow SU method to change the RF cfg.txt. Default disable RF TX/RX mode. */
/* if (pHalData->eRFPowerState == eRfOn) */
{
ret = PHY_RFConfig8723B(padapter);
if (ret != _SUCCESS)
return ret;
}
/* */
/* Joseph Note: Keep RfRegChnlVal for later use. */
/* */
pHalData->RfRegChnlVal[0] =
PHY_QueryRFReg(padapter, (enum rf_path)0, RF_CHNLBW, bRFRegOffsetMask);
pHalData->RfRegChnlVal[1] =
PHY_QueryRFReg(padapter, (enum rf_path)1, RF_CHNLBW, bRFRegOffsetMask);
/* if (!pHalData->bMACFuncEnable) { */
_InitQueueReservedPage(padapter);
_InitTxBufferBoundary(padapter);
/* init LLT after tx buffer boundary is defined */
ret = rtl8723b_InitLLTTable(padapter);
if (ret != _SUCCESS)
return _FAIL;
/* */
_InitQueuePriority(padapter);
_InitPageBoundary(padapter);
_InitTransferPageSize(padapter);
/* Get Rx PHY status in order to report RSSI and others. */
_InitDriverInfoSize(padapter, DRVINFO_SZ);
hal_init_macaddr(padapter);
_InitNetworkType(padapter);
_InitWMACSetting(padapter);
_InitAdaptiveCtrl(padapter);
_InitEDCA(padapter);
_InitRetryFunction(padapter);
_initSdioAggregationSetting(padapter);
_InitOperationMode(padapter);
rtl8723b_InitBeaconParameters(padapter);
_InitInterrupt(padapter);
_InitBurstPktLen_8723BS(padapter);
/* YJ, TODO */
rtw_write8(padapter, REG_SECONDARY_CCA_CTRL_8723B, 0x3); /* CCA */
rtw_write8(padapter, 0x976, 0); /* hpfan_todo: 2nd CCA related */
rtw_write16(padapter, REG_PKT_VO_VI_LIFE_TIME, 0x0400); /* unit: 256us. 256ms */
rtw_write16(padapter, REG_PKT_BE_BK_LIFE_TIME, 0x0400); /* unit: 256us. 256ms */
invalidate_cam_all(padapter);
rtw_hal_set_chnl_bw(padapter, padapter->registrypriv.channel,
CHANNEL_WIDTH_20, HAL_PRIME_CHNL_OFFSET_DONT_CARE, HAL_PRIME_CHNL_OFFSET_DONT_CARE);
/* Record original value for template. This is arough data, we can only use the data */
/* for power adjust. The value can not be adjustde according to different power!!! */
/* pHalData->OriginalCckTxPwrIdx = pHalData->CurrentCckTxPwrIdx; */
/* pHalData->OriginalOfdm24GTxPwrIdx = pHalData->CurrentOfdm24GTxPwrIdx; */
rtl8723b_InitAntenna_Selection(padapter);
/* */
/* Disable BAR, suggested by Scott */
/* 2010.04.09 add by hpfan */
/* */
rtw_write32(padapter, REG_BAR_MODE_CTRL, 0x0201ffff);
/* HW SEQ CTRL */
/* set 0x0 to 0xFF by tynli. Default enable HW SEQ NUM. */
rtw_write8(padapter, REG_HWSEQ_CTRL, 0xFF);
/* */
/* Configure SDIO TxRx Control to enable Rx DMA timer masking. */
/* 2010.02.24. */
/* */
rtw_write32(padapter, SDIO_LOCAL_BASE | SDIO_REG_TX_CTRL, 0);
_RfPowerSave(padapter);
rtl8723b_InitHalDm(padapter);
/* */
/* Update current Tx FIFO page status. */
/* */
HalQueryTxBufferStatus8723BSdio(padapter);
HalQueryTxOQTBufferStatus8723BSdio(padapter);
pHalData->SdioTxOQTMaxFreeSpace = pHalData->SdioTxOQTFreeSpace;
/* Enable MACTXEN/MACRXEN block */
u1bTmp = rtw_read8(padapter, REG_CR);
u1bTmp |= (MACTXEN | MACRXEN);
rtw_write8(padapter, REG_CR, u1bTmp);
rtw_hal_set_hwreg(padapter, HW_VAR_NAV_UPPER, (u8 *)&NavUpper);
/* ack for xmit mgmt frames. */
rtw_write32(padapter, REG_FWHW_TXQ_CTRL, rtw_read32(padapter, REG_FWHW_TXQ_CTRL) | BIT(12));
/* pHalData->PreRpwmVal = SdioLocalCmd52Read1Byte(padapter, SDIO_REG_HRPWM1) & 0x80; */
{
pwrctrlpriv->rf_pwrstate = rf_on;
if (pwrctrlpriv->rf_pwrstate == rf_on) {
struct pwrctrl_priv *pwrpriv;
unsigned long start_time;
u8 restore_iqk_rst;
u8 b2Ant;
u8 h2cCmdBuf;
pwrpriv = adapter_to_pwrctl(padapter);
PHY_LCCalibrate_8723B(&pHalData->odmpriv);
/* Inform WiFi FW that it is the beginning of IQK */
h2cCmdBuf = 1;
FillH2CCmd8723B(padapter, H2C_8723B_BT_WLAN_CALIBRATION, 1, &h2cCmdBuf);
start_time = jiffies;
do {
if (rtw_read8(padapter, 0x1e7) & 0x01)
break;
msleep(50);
} while (jiffies_to_msecs(jiffies - start_time) <= 400);
hal_btcoex_IQKNotify(padapter, true);
restore_iqk_rst = pwrpriv->bips_processing;
b2Ant = pHalData->EEPROMBluetoothAntNum == Ant_x2;
PHY_IQCalibrate_8723B(padapter, false, restore_iqk_rst, b2Ant, pHalData->ant_path);
pHalData->odmpriv.RFCalibrateInfo.bIQKInitialized = true;
hal_btcoex_IQKNotify(padapter, false);
/* Inform WiFi FW that it is the finish of IQK */
h2cCmdBuf = 0;
FillH2CCmd8723B(padapter, H2C_8723B_BT_WLAN_CALIBRATION, 1, &h2cCmdBuf);
ODM_TXPowerTrackingCheck(&pHalData->odmpriv);
}
}
/* Init BT hw config. */
hal_btcoex_InitHwConfig(padapter, false);
return _SUCCESS;
}
/* */
/* Description: */
/* RTL8723e card disable power sequence v003 which suggested by Scott. */
/* */
/* First created by tynli. 2011.01.28. */
/* */
static void CardDisableRTL8723BSdio(struct adapter *padapter)
{
u8 u1bTmp;
u8 bMacPwrCtrlOn;
/* Run LPS WL RFOFF flow */
HalPwrSeqCmdParsing(padapter, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK, PWR_INTF_SDIO_MSK, rtl8723B_enter_lps_flow);
/* ==== Reset digital sequence ====== */
u1bTmp = rtw_read8(padapter, REG_MCUFWDL);
if ((u1bTmp & RAM_DL_SEL) && padapter->bFWReady) /* 8051 RAM code */
rtl8723b_FirmwareSelfReset(padapter);
/* Reset MCU 0x2[10]= 0. Suggested by Filen. 2011.01.26. by tynli. */
u1bTmp = rtw_read8(padapter, REG_SYS_FUNC_EN + 1);
u1bTmp &= ~BIT(2); /* 0x2[10], FEN_CPUEN */
rtw_write8(padapter, REG_SYS_FUNC_EN + 1, u1bTmp);
/* MCUFWDL 0x80[1:0]= 0 */
/* reset MCU ready status */
rtw_write8(padapter, REG_MCUFWDL, 0);
/* Reset MCU IO Wrapper, added by Roger, 2011.08.30 */
u1bTmp = rtw_read8(padapter, REG_RSV_CTRL + 1);
u1bTmp &= ~BIT(0);
rtw_write8(padapter, REG_RSV_CTRL + 1, u1bTmp);
u1bTmp = rtw_read8(padapter, REG_RSV_CTRL + 1);
u1bTmp |= BIT(0);
rtw_write8(padapter, REG_RSV_CTRL+1, u1bTmp);
/* ==== Reset digital sequence end ====== */
bMacPwrCtrlOn = false; /* Disable CMD53 R/W */
rtw_hal_set_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
HalPwrSeqCmdParsing(padapter, PWR_CUT_ALL_MSK, PWR_FAB_ALL_MSK, PWR_INTF_SDIO_MSK, rtl8723B_card_disable_flow);
}
static u32 rtl8723bs_hal_deinit(struct adapter *padapter)
{
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
if (padapter->hw_init_completed) {
if (adapter_to_pwrctl(padapter)->bips_processing) {
if (padapter->netif_up) {
int cnt = 0;
u8 val8 = 0;
rtl8723b_set_FwPwrModeInIPS_cmd(padapter, 0x3);
/* poll 0x1cc to make sure H2C command already finished by FW; MAC_0x1cc = 0 means H2C done by FW. */
do {
val8 = rtw_read8(padapter, REG_HMETFR);
cnt++;
mdelay(10);
} while (cnt < 100 && (val8 != 0));
/* H2C done, enter 32k */
if (val8 == 0) {
/* ser rpwm to enter 32k */
val8 = rtw_read8(padapter, SDIO_LOCAL_BASE | SDIO_REG_HRPWM1);
val8 += 0x80;
val8 |= BIT(0);
rtw_write8(padapter, SDIO_LOCAL_BASE | SDIO_REG_HRPWM1, val8);
adapter_to_pwrctl(padapter)->tog = (val8 + 0x80) & 0x80;
cnt = val8 = 0;
do {
val8 = rtw_read8(padapter, REG_CR);
cnt++;
mdelay(10);
} while (cnt < 100 && (val8 != 0xEA));
}
adapter_to_pwrctl(padapter)->pre_ips_type = 0;
} else {
pdbgpriv->dbg_carddisable_cnt++;
CardDisableRTL8723BSdio(padapter);
adapter_to_pwrctl(padapter)->pre_ips_type = 1;
}
} else {
pdbgpriv->dbg_carddisable_cnt++;
CardDisableRTL8723BSdio(padapter);
}
} else
pdbgpriv->dbg_deinit_fail_cnt++;
return _SUCCESS;
}
static u32 rtl8723bs_inirp_init(struct adapter *padapter)
{
return _SUCCESS;
}
static u32 rtl8723bs_inirp_deinit(struct adapter *padapter)
{
return _SUCCESS;
}
static void rtl8723bs_init_default_value(struct adapter *padapter)
{
struct hal_com_data *pHalData;
pHalData = GET_HAL_DATA(padapter);
rtl8723b_init_default_value(padapter);
/* interface related variable */
pHalData->SdioRxFIFOCnt = 0;
}
static void rtl8723bs_interface_configure(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
struct registry_priv *pregistrypriv = &padapter->registrypriv;
bool bWiFiConfig = pregistrypriv->wifi_spec;
pdvobjpriv->RtOutPipe[0] = WLAN_TX_HIQ_DEVICE_ID;
pdvobjpriv->RtOutPipe[1] = WLAN_TX_MIQ_DEVICE_ID;
pdvobjpriv->RtOutPipe[2] = WLAN_TX_LOQ_DEVICE_ID;
if (bWiFiConfig)
pHalData->OutEpNumber = 2;
else
pHalData->OutEpNumber = SDIO_MAX_TX_QUEUE;
switch (pHalData->OutEpNumber) {
case 3:
pHalData->OutEpQueueSel = TX_SELE_HQ | TX_SELE_LQ | TX_SELE_NQ;
break;
case 2:
pHalData->OutEpQueueSel = TX_SELE_HQ | TX_SELE_NQ;
break;
case 1:
pHalData->OutEpQueueSel = TX_SELE_HQ;
break;
default:
break;
}
Hal_MappingOutPipe(padapter, pHalData->OutEpNumber);
}
/* */
/* Description: */
/* We should set Efuse cell selection to WiFi cell in default. */
/* */
/* Assumption: */
/* PASSIVE_LEVEL */
/* */
/* Added by Roger, 2010.11.23. */
/* */
static void _EfuseCellSel(struct adapter *padapter)
{
u32 value32;
value32 = rtw_read32(padapter, EFUSE_TEST);
value32 = (value32 & ~EFUSE_SEL_MASK) | EFUSE_SEL(EFUSE_WIFI_SEL_0);
rtw_write32(padapter, EFUSE_TEST, value32);
}
static void _ReadRFType(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
pHalData->rf_chip = RF_6052;
}
static void Hal_EfuseParseMACAddr_8723BS(
struct adapter *padapter, u8 *hwinfo, bool AutoLoadFail
)
{
u16 i;
u8 sMacAddr[6] = {0x00, 0xE0, 0x4C, 0xb7, 0x23, 0x00};
struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
if (AutoLoadFail) {
/* sMacAddr[5] = (u8)GetRandomNumber(1, 254); */
for (i = 0; i < 6; i++)
pEEPROM->mac_addr[i] = sMacAddr[i];
} else {
/* Read Permanent MAC address */
memcpy(pEEPROM->mac_addr, &hwinfo[EEPROM_MAC_ADDR_8723BS], ETH_ALEN);
}
}
static void Hal_EfuseParseBoardType_8723BS(
struct adapter *padapter, u8 *hwinfo, bool AutoLoadFail
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
if (!AutoLoadFail) {
pHalData->BoardType = (hwinfo[EEPROM_RF_BOARD_OPTION_8723B] & 0xE0) >> 5;
if (pHalData->BoardType == 0xFF)
pHalData->BoardType = (EEPROM_DEFAULT_BOARD_OPTION & 0xE0) >> 5;
} else
pHalData->BoardType = 0;
}
static void _ReadEfuseInfo8723BS(struct adapter *padapter)
{
struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
u8 *hwinfo = NULL;
/* */
/* This part read and parse the eeprom/efuse content */
/* */
hwinfo = pEEPROM->efuse_eeprom_data;
Hal_InitPGData(padapter, hwinfo);
Hal_EfuseParseIDCode(padapter, hwinfo);
Hal_EfuseParseEEPROMVer_8723B(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_EfuseParseMACAddr_8723BS(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_EfuseParseTxPowerInfo_8723B(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_EfuseParseBoardType_8723BS(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
/* */
/* Read Bluetooth co-exist and initialize */
/* */
Hal_EfuseParsePackageType_8723B(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_EfuseParseBTCoexistInfo_8723B(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_EfuseParseChnlPlan_8723B(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_EfuseParseXtal_8723B(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_EfuseParseThermalMeter_8723B(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_EfuseParseAntennaDiversity_8723B(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_EfuseParseCustomerID_8723B(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_EfuseParseVoltage_8723B(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
Hal_ReadRFGainOffset(padapter, hwinfo, pEEPROM->bautoload_fail_flag);
}
static void _ReadPROMContent(struct adapter *padapter)
{
struct eeprom_priv *pEEPROM = GET_EEPROM_EFUSE_PRIV(padapter);
u8 eeValue;
eeValue = rtw_read8(padapter, REG_9346CR);
/* To check system boot selection. */
pEEPROM->EepromOrEfuse = (eeValue & BOOT_FROM_EEPROM) ? true : false;
pEEPROM->bautoload_fail_flag = (eeValue & EEPROM_EN) ? false : true;
/* pHalData->EEType = IS_BOOT_FROM_EEPROM(Adapter) ? EEPROM_93C46 : EEPROM_BOOT_EFUSE; */
_ReadEfuseInfo8723BS(padapter);
}
static void _InitOtherVariable(struct adapter *Adapter)
{
}
/* */
/* Description: */
/* Read HW adapter information by E-Fuse or EEPROM according CR9346 reported. */
/* */
/* Assumption: */
/* PASSIVE_LEVEL (SDIO interface) */
/* */
/* */
static s32 _ReadAdapterInfo8723BS(struct adapter *padapter)
{
u8 val8;
/* before access eFuse, make sure card enable has been called */
if (!padapter->hw_init_completed)
_InitPowerOn_8723BS(padapter);
val8 = rtw_read8(padapter, 0x4e);
val8 |= BIT(6);
rtw_write8(padapter, 0x4e, val8);
_EfuseCellSel(padapter);
_ReadRFType(padapter);
_ReadPROMContent(padapter);
_InitOtherVariable(padapter);
if (!padapter->hw_init_completed) {
rtw_write8(padapter, 0x67, 0x00); /* for BT, Switch Ant control to BT */
CardDisableRTL8723BSdio(padapter);/* for the power consumption issue, wifi ko module is loaded during booting, but wifi GUI is off */
}
return _SUCCESS;
}
static void ReadAdapterInfo8723BS(struct adapter *padapter)
{
/* Read EEPROM size before call any EEPROM function */
padapter->EepromAddressSize = GetEEPROMSize8723B(padapter);
_ReadAdapterInfo8723BS(padapter);
}
/*
* If variable not handled here,
* some variables will be processed in SetHwReg8723B()
*/
static void SetHwReg8723BS(struct adapter *padapter, u8 variable, u8 *val)
{
u8 val8;
switch (variable) {
case HW_VAR_SET_RPWM:
/* rpwm value only use BIT0(clock bit) , BIT6(Ack bit), and BIT7(Toggle bit) */
/* BIT0 value - 1: 32k, 0:40MHz. */
/* BIT6 value - 1: report cpwm value after success set, 0:do not report. */
/* BIT7 value - Toggle bit change. */
{
val8 = *val;
val8 &= 0xC1;
rtw_write8(padapter, SDIO_LOCAL_BASE | SDIO_REG_HRPWM1, val8);
}
break;
case HW_VAR_SET_REQ_FW_PS:
{
u8 req_fw_ps = 0;
req_fw_ps = rtw_read8(padapter, 0x8f);
req_fw_ps |= 0x10;
rtw_write8(padapter, 0x8f, req_fw_ps);
}
break;
case HW_VAR_RXDMA_AGG_PG_TH:
val8 = *val;
break;
case HW_VAR_DM_IN_LPS:
rtl8723b_hal_dm_in_lps(padapter);
break;
default:
SetHwReg8723B(padapter, variable, val);
break;
}
}
/*
* If variable not handled here,
* some variables will be processed in GetHwReg8723B()
*/
static void GetHwReg8723BS(struct adapter *padapter, u8 variable, u8 *val)
{
switch (variable) {
case HW_VAR_CPWM:
*val = rtw_read8(padapter, SDIO_LOCAL_BASE | SDIO_REG_HCPWM1_8723B);
break;
case HW_VAR_FW_PS_STATE:
{
/* 3. read dword 0x88 driver read fw ps state */
*((u16 *)val) = rtw_read16(padapter, 0x88);
}
break;
default:
GetHwReg8723B(padapter, variable, val);
break;
}
}
static void SetHwRegWithBuf8723B(struct adapter *padapter, u8 variable, u8 *pbuf, int len)
{
switch (variable) {
case HW_VAR_C2H_HANDLE:
C2HPacketHandler_8723B(padapter, pbuf, len);
break;
default:
break;
}
}
/* */
/* Description: */
/* Query setting of specified variable. */
/* */
static u8 GetHalDefVar8723BSDIO(
struct adapter *Adapter, enum hal_def_variable eVariable, void *pValue
)
{
u8 bResult = _SUCCESS;
switch (eVariable) {
case HAL_DEF_IS_SUPPORT_ANT_DIV:
break;
case HAL_DEF_CURRENT_ANTENNA:
break;
case HW_VAR_MAX_RX_AMPDU_FACTOR:
/* [email protected] suggests 16K can get stable performance */
/* coding by Lucas@20130730 */
*(u32 *)pValue = IEEE80211_HT_MAX_AMPDU_16K;
break;
default:
bResult = GetHalDefVar8723B(Adapter, eVariable, pValue);
break;
}
return bResult;
}
/* */
/* Description: */
/* Change default setting of specified variable. */
/* */
static u8 SetHalDefVar8723BSDIO(struct adapter *Adapter,
enum hal_def_variable eVariable, void *pValue)
{
return SetHalDefVar8723B(Adapter, eVariable, pValue);
}
void rtl8723bs_set_hal_ops(struct adapter *padapter)
{
struct hal_ops *pHalFunc = &padapter->HalFunc;
rtl8723b_set_hal_ops(pHalFunc);
pHalFunc->hal_init = &rtl8723bs_hal_init;
pHalFunc->hal_deinit = &rtl8723bs_hal_deinit;
pHalFunc->inirp_init = &rtl8723bs_inirp_init;
pHalFunc->inirp_deinit = &rtl8723bs_inirp_deinit;
pHalFunc->init_xmit_priv = &rtl8723bs_init_xmit_priv;
pHalFunc->free_xmit_priv = &rtl8723bs_free_xmit_priv;
pHalFunc->init_recv_priv = &rtl8723bs_init_recv_priv;
pHalFunc->free_recv_priv = &rtl8723bs_free_recv_priv;
pHalFunc->init_default_value = &rtl8723bs_init_default_value;
pHalFunc->intf_chip_configure = &rtl8723bs_interface_configure;
pHalFunc->read_adapter_info = &ReadAdapterInfo8723BS;
pHalFunc->enable_interrupt = &EnableInterrupt8723BSdio;
pHalFunc->disable_interrupt = &DisableInterrupt8723BSdio;
pHalFunc->check_ips_status = &CheckIPSStatus;
pHalFunc->SetHwRegHandler = &SetHwReg8723BS;
pHalFunc->GetHwRegHandler = &GetHwReg8723BS;
pHalFunc->SetHwRegHandlerWithBuf = &SetHwRegWithBuf8723B;
pHalFunc->GetHalDefVarHandler = &GetHalDefVar8723BSDIO;
pHalFunc->SetHalDefVarHandler = &SetHalDefVar8723BSDIO;
pHalFunc->hal_xmit = &rtl8723bs_hal_xmit;
pHalFunc->mgnt_xmit = &rtl8723bs_mgnt_xmit;
pHalFunc->hal_xmitframe_enqueue = &rtl8723bs_hal_xmitframe_enqueue;
}
| linux-master | drivers/staging/rtl8723bs/hal/sdio_halinit.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtl8723b_hal.h>
static void initrecvbuf(struct recv_buf *precvbuf, struct adapter *padapter)
{
INIT_LIST_HEAD(&precvbuf->list);
spin_lock_init(&precvbuf->recvbuf_lock);
precvbuf->adapter = padapter;
}
static void update_recvframe_attrib(struct adapter *padapter,
union recv_frame *precvframe,
struct recv_stat *prxstat)
{
struct rx_pkt_attrib *pattrib;
struct recv_stat report;
struct rxreport_8723b *prxreport = (struct rxreport_8723b *)&report;
report.rxdw0 = prxstat->rxdw0;
report.rxdw1 = prxstat->rxdw1;
report.rxdw2 = prxstat->rxdw2;
report.rxdw3 = prxstat->rxdw3;
report.rxdw4 = prxstat->rxdw4;
report.rxdw5 = prxstat->rxdw5;
pattrib = &precvframe->u.hdr.attrib;
memset(pattrib, 0, sizeof(struct rx_pkt_attrib));
/* update rx report to recv_frame attribute */
pattrib->pkt_rpt_type = prxreport->c2h_ind ? C2H_PACKET : NORMAL_RX;
if (pattrib->pkt_rpt_type == NORMAL_RX) {
/* Normal rx packet */
/* update rx report to recv_frame attribute */
pattrib->pkt_len = (u16)prxreport->pktlen;
pattrib->drvinfo_sz = (u8)(prxreport->drvinfosize << 3);
pattrib->physt = (u8)prxreport->physt;
pattrib->crc_err = (u8)prxreport->crc32;
pattrib->icv_err = (u8)prxreport->icverr;
pattrib->bdecrypted = (u8)(prxreport->swdec ? 0 : 1);
pattrib->encrypt = (u8)prxreport->security;
pattrib->qos = (u8)prxreport->qos;
pattrib->priority = (u8)prxreport->tid;
pattrib->amsdu = (u8)prxreport->amsdu;
pattrib->seq_num = (u16)prxreport->seq;
pattrib->frag_num = (u8)prxreport->frag;
pattrib->mfrag = (u8)prxreport->mf;
pattrib->mdata = (u8)prxreport->md;
pattrib->data_rate = (u8)prxreport->rx_rate;
} else {
pattrib->pkt_len = (u16)prxreport->pktlen;
}
}
/*
* Notice:
*Before calling this function,
*precvframe->u.hdr.rx_data should be ready!
*/
static void update_recvframe_phyinfo(union recv_frame *precvframe,
struct phy_stat *pphy_status)
{
struct adapter *padapter = precvframe->u.hdr.adapter;
struct rx_pkt_attrib *pattrib = &precvframe->u.hdr.attrib;
struct hal_com_data *p_hal_data = GET_HAL_DATA(padapter);
struct odm_phy_info *p_phy_info =
(struct odm_phy_info *)(&pattrib->phy_info);
u8 *wlanhdr = precvframe->u.hdr.rx_data;
u8 *my_bssid;
u8 *rx_bssid;
u8 *rx_ra;
u8 *my_hwaddr;
u8 *sa = NULL;
struct odm_packet_info pkt_info = {
.data_rate = 0x00,
.station_id = 0x00,
.bssid_match = false,
.to_self = false,
.is_beacon = false,
};
/* unsigned long irqL; */
struct sta_priv *pstapriv;
struct sta_info *psta;
my_bssid = get_bssid(&padapter->mlmepriv);
rx_bssid = get_hdr_bssid(wlanhdr);
pkt_info.bssid_match = ((!IsFrameTypeCtrl(wlanhdr)) &&
!pattrib->icv_err && !pattrib->crc_err &&
ether_addr_equal(rx_bssid, my_bssid));
rx_ra = rtl8723bs_get_ra(wlanhdr);
my_hwaddr = myid(&padapter->eeprompriv);
pkt_info.to_self = pkt_info.bssid_match &&
ether_addr_equal(rx_ra, my_hwaddr);
pkt_info.is_beacon = pkt_info.bssid_match &&
(GetFrameSubType(wlanhdr) == WIFI_BEACON);
sa = get_ta(wlanhdr);
pkt_info.station_id = 0xFF;
pstapriv = &padapter->stapriv;
psta = rtw_get_stainfo(pstapriv, sa);
if (psta)
pkt_info.station_id = psta->mac_id;
pkt_info.data_rate = pattrib->data_rate;
/* rtl8723b_query_rx_phy_status(precvframe, pphy_status); */
/* spin_lock_bh(&p_hal_data->odm_stainfo_lock); */
odm_phy_status_query(&p_hal_data->odmpriv, p_phy_info,
(u8 *)pphy_status, &(pkt_info));
if (psta)
psta->rssi = pattrib->phy_info.RecvSignalPower;
/* spin_unlock_bh(&p_hal_data->odm_stainfo_lock); */
precvframe->u.hdr.psta = NULL;
if (
pkt_info.bssid_match &&
(check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == true)
) {
if (psta) {
precvframe->u.hdr.psta = psta;
rtl8723b_process_phy_info(padapter, precvframe);
}
} else if (pkt_info.to_self || pkt_info.is_beacon) {
u32 adhoc_state = WIFI_ADHOC_STATE | WIFI_ADHOC_MASTER_STATE;
if (check_fwstate(&padapter->mlmepriv, adhoc_state))
if (psta)
precvframe->u.hdr.psta = psta;
rtl8723b_process_phy_info(padapter, precvframe);
}
}
static void rtl8723bs_c2h_packet_handler(struct adapter *padapter,
u8 *pbuf, u16 length)
{
u8 *tmp = NULL;
u8 res = false;
if (length == 0)
return;
tmp = rtw_zmalloc(length);
if (!tmp)
return;
memcpy(tmp, pbuf, length);
res = rtw_c2h_packet_wk_cmd(padapter, tmp, length);
if (!res)
kfree(tmp);
}
static inline union recv_frame *try_alloc_recvframe(struct recv_priv *precvpriv,
struct recv_buf *precvbuf)
{
union recv_frame *precvframe;
precvframe = rtw_alloc_recvframe(&precvpriv->free_recv_queue);
if (!precvframe) {
rtw_enqueue_recvbuf_to_head(precvbuf,
&precvpriv->recv_buf_pending_queue);
/* The case of can't allocate recvframe should be temporary, */
/* schedule again and hope recvframe is available next time. */
tasklet_schedule(&precvpriv->recv_tasklet);
}
return precvframe;
}
static inline bool rx_crc_err(struct recv_priv *precvpriv,
struct hal_com_data *p_hal_data,
struct rx_pkt_attrib *pattrib,
union recv_frame *precvframe)
{
/* fix Hardware RX data error, drop whole recv_buffer */
if ((!(p_hal_data->ReceiveConfig & RCR_ACRC32)) && pattrib->crc_err) {
rtw_free_recvframe(precvframe, &precvpriv->free_recv_queue);
return true;
}
return false;
}
static inline bool pkt_exceeds_tail(struct recv_priv *precvpriv,
u8 *end, u8 *tail,
union recv_frame *precvframe)
{
if (end > tail) {
rtw_free_recvframe(precvframe, &precvpriv->free_recv_queue);
return true;
}
return false;
}
static void rtl8723bs_recv_tasklet(struct tasklet_struct *t)
{
struct adapter *padapter = from_tasklet(padapter, t,
recvpriv.recv_tasklet);
struct hal_com_data *p_hal_data;
struct recv_priv *precvpriv;
struct recv_buf *precvbuf;
union recv_frame *precvframe;
struct rx_pkt_attrib *pattrib;
struct __queue *recv_buf_queue;
u8 *ptr;
u32 pkt_offset, skb_len, alloc_sz;
struct sk_buff *pkt_copy = NULL;
u8 shift_sz = 0, rx_report_sz = 0;
p_hal_data = GET_HAL_DATA(padapter);
precvpriv = &padapter->recvpriv;
recv_buf_queue = &precvpriv->recv_buf_pending_queue;
do {
precvbuf = rtw_dequeue_recvbuf(recv_buf_queue);
if (!precvbuf)
break;
ptr = precvbuf->pdata;
while (ptr < precvbuf->ptail) {
precvframe = try_alloc_recvframe(precvpriv, precvbuf);
if (!precvframe)
return;
/* rx desc parsing */
update_recvframe_attrib(padapter, precvframe,
(struct recv_stat *)ptr);
pattrib = &precvframe->u.hdr.attrib;
if (rx_crc_err(precvpriv, p_hal_data,
pattrib, precvframe))
break;
rx_report_sz = RXDESC_SIZE + pattrib->drvinfo_sz;
pkt_offset = rx_report_sz +
pattrib->shift_sz +
pattrib->pkt_len;
if (pkt_exceeds_tail(precvpriv, ptr + pkt_offset,
precvbuf->ptail, precvframe))
break;
if ((pattrib->crc_err) || (pattrib->icv_err)) {
rtw_free_recvframe(precvframe,
&precvpriv->free_recv_queue);
} else {
/* Modified by Albert 20101213 */
/* For 8 bytes IP header alignment. */
if (pattrib->qos) /* Qos data, wireless lan header length is 26 */
shift_sz = 6;
else
shift_sz = 0;
skb_len = pattrib->pkt_len;
/* for first fragment packet, driver need allocate 1536+drvinfo_sz+RXDESC_SIZE to defrag packet. */
/* modify alloc_sz for recvive crc error packet by thomas 2011-06-02 */
if ((pattrib->mfrag == 1) && (pattrib->frag_num == 0)) {
if (skb_len <= 1650)
alloc_sz = 1664;
else
alloc_sz = skb_len + 14;
} else {
alloc_sz = skb_len;
/* 6 is for IP header 8 bytes alignment in QoS packet case. */
/* 8 is for skb->data 4 bytes alignment. */
alloc_sz += 14;
}
pkt_copy = rtw_skb_alloc(alloc_sz);
if (!pkt_copy) {
rtw_free_recvframe(precvframe, &precvpriv->free_recv_queue);
break;
}
pkt_copy->dev = padapter->pnetdev;
precvframe->u.hdr.pkt = pkt_copy;
skb_reserve(pkt_copy, 8 - ((SIZE_PTR)(pkt_copy->data) & 7));/* force pkt_copy->data at 8-byte alignment address */
skb_reserve(pkt_copy, shift_sz);/* force ip_hdr at 8-byte alignment address according to shift_sz. */
memcpy(pkt_copy->data, (ptr + rx_report_sz + pattrib->shift_sz), skb_len);
precvframe->u.hdr.rx_head = pkt_copy->head;
precvframe->u.hdr.rx_data = precvframe->u.hdr.rx_tail = pkt_copy->data;
precvframe->u.hdr.rx_end = skb_end_pointer(pkt_copy);
recvframe_put(precvframe, skb_len);
/* recvframe_pull(precvframe, drvinfo_sz + RXDESC_SIZE); */
if (p_hal_data->ReceiveConfig & RCR_APPFCS)
recvframe_pull_tail(precvframe, IEEE80211_FCS_LEN);
/* move to drv info position */
ptr += RXDESC_SIZE;
/* update drv info */
if (p_hal_data->ReceiveConfig & RCR_APP_BA_SSN) {
/* rtl8723s_update_bassn(padapter, pdrvinfo); */
ptr += 4;
}
if (pattrib->pkt_rpt_type == NORMAL_RX) { /* Normal rx packet */
if (pattrib->physt)
update_recvframe_phyinfo(precvframe, (struct phy_stat *)ptr);
rtw_recv_entry(precvframe);
} else if (pattrib->pkt_rpt_type == C2H_PACKET) {
struct c2h_evt_hdr_t C2hEvent;
u16 len_c2h = pattrib->pkt_len;
u8 *pbuf_c2h = precvframe->u.hdr.rx_data;
u8 *pdata_c2h;
C2hEvent.CmdID = pbuf_c2h[0];
C2hEvent.CmdSeq = pbuf_c2h[1];
C2hEvent.CmdLen = (len_c2h-2);
pdata_c2h = pbuf_c2h+2;
if (C2hEvent.CmdID == C2H_CCX_TX_RPT)
CCX_FwC2HTxRpt_8723b(padapter, pdata_c2h, C2hEvent.CmdLen);
else
rtl8723bs_c2h_packet_handler(padapter, precvframe->u.hdr.rx_data, pattrib->pkt_len);
rtw_free_recvframe(precvframe, &precvpriv->free_recv_queue);
}
}
pkt_offset = round_up(pkt_offset, 8);
precvbuf->pdata += pkt_offset;
ptr = precvbuf->pdata;
precvframe = NULL;
pkt_copy = NULL;
}
rtw_enqueue_recvbuf(precvbuf, &precvpriv->free_recv_buf_queue);
} while (1);
}
/*
* Initialize recv private variable for hardware dependent
* 1. recv buf
* 2. recv tasklet
*
*/
s32 rtl8723bs_init_recv_priv(struct adapter *padapter)
{
s32 res;
u32 i, n;
struct recv_priv *precvpriv;
struct recv_buf *precvbuf;
res = _SUCCESS;
precvpriv = &padapter->recvpriv;
/* 3 1. init recv buffer */
INIT_LIST_HEAD(&precvpriv->free_recv_buf_queue.queue);
spin_lock_init(&precvpriv->free_recv_buf_queue.lock);
INIT_LIST_HEAD(&precvpriv->recv_buf_pending_queue.queue);
spin_lock_init(&precvpriv->recv_buf_pending_queue.lock);
n = NR_RECVBUFF * sizeof(struct recv_buf) + 4;
precvpriv->pallocated_recv_buf = rtw_zmalloc(n);
if (!precvpriv->pallocated_recv_buf) {
res = _FAIL;
goto exit;
}
precvpriv->precv_buf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(precvpriv->pallocated_recv_buf), 4);
/* init each recv buffer */
precvbuf = (struct recv_buf *)precvpriv->precv_buf;
for (i = 0; i < NR_RECVBUFF; i++) {
initrecvbuf(precvbuf, padapter);
if (!precvbuf->pskb) {
SIZE_PTR tmpaddr = 0;
SIZE_PTR alignment = 0;
precvbuf->pskb = rtw_skb_alloc(MAX_RECVBUF_SZ + RECVBUFF_ALIGN_SZ);
if (precvbuf->pskb) {
precvbuf->pskb->dev = padapter->pnetdev;
tmpaddr = (SIZE_PTR)precvbuf->pskb->data;
alignment = tmpaddr & (RECVBUFF_ALIGN_SZ-1);
skb_reserve(precvbuf->pskb, (RECVBUFF_ALIGN_SZ - alignment));
}
}
list_add_tail(&precvbuf->list, &precvpriv->free_recv_buf_queue.queue);
precvbuf++;
}
precvpriv->free_recv_buf_queue_cnt = i;
if (res == _FAIL)
goto initbuferror;
/* 3 2. init tasklet */
tasklet_setup(&precvpriv->recv_tasklet, rtl8723bs_recv_tasklet);
goto exit;
initbuferror:
precvbuf = (struct recv_buf *)precvpriv->precv_buf;
if (precvbuf) {
n = precvpriv->free_recv_buf_queue_cnt;
precvpriv->free_recv_buf_queue_cnt = 0;
for (i = 0; i < n ; i++) {
list_del_init(&precvbuf->list);
rtw_os_recvbuf_resource_free(padapter, precvbuf);
precvbuf++;
}
precvpriv->precv_buf = NULL;
}
kfree(precvpriv->pallocated_recv_buf);
precvpriv->pallocated_recv_buf = NULL;
exit:
return res;
}
/*
* Free recv private variable of hardware dependent
* 1. recv buf
* 2. recv tasklet
*
*/
void rtl8723bs_free_recv_priv(struct adapter *padapter)
{
u32 i;
struct recv_priv *precvpriv;
struct recv_buf *precvbuf;
precvpriv = &padapter->recvpriv;
/* 3 1. kill tasklet */
tasklet_kill(&precvpriv->recv_tasklet);
/* 3 2. free all recv buffers */
precvbuf = (struct recv_buf *)precvpriv->precv_buf;
if (precvbuf) {
precvpriv->free_recv_buf_queue_cnt = 0;
for (i = 0; i < NR_RECVBUFF; i++) {
list_del_init(&precvbuf->list);
rtw_os_recvbuf_resource_free(padapter, precvbuf);
precvbuf++;
}
precvpriv->precv_buf = NULL;
}
kfree(precvpriv->pallocated_recv_buf);
precvpriv->pallocated_recv_buf = NULL;
}
| linux-master | drivers/staging/rtl8723bs/hal/rtl8723bs_recv.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include "Mp_Precomp.h"
/* Global variables, these are static variables */
static struct coex_dm_8723b_1ant GLCoexDm8723b1Ant;
static struct coex_dm_8723b_1ant *pCoexDm = &GLCoexDm8723b1Ant;
static struct coex_sta_8723b_1ant GLCoexSta8723b1Ant;
static struct coex_sta_8723b_1ant *pCoexSta = &GLCoexSta8723b1Ant;
/* local function proto type if needed */
/* local function start with halbtc8723b1ant_ */
static u8 halbtc8723b1ant_BtRssiState(
u8 levelNum, u8 rssiThresh, u8 rssiThresh1
)
{
s32 btRssi = 0;
u8 btRssiState = pCoexSta->preBtRssiState;
btRssi = pCoexSta->btRssi;
if (levelNum == 2) {
if (
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
) {
if (btRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))
btRssiState = BTC_RSSI_STATE_HIGH;
else
btRssiState = BTC_RSSI_STATE_STAY_LOW;
} else {
if (btRssi < rssiThresh)
btRssiState = BTC_RSSI_STATE_LOW;
else
btRssiState = BTC_RSSI_STATE_STAY_HIGH;
}
} else if (levelNum == 3) {
if (rssiThresh > rssiThresh1)
return pCoexSta->preBtRssiState;
if (
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
) {
if (btRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))
btRssiState = BTC_RSSI_STATE_MEDIUM;
else
btRssiState = BTC_RSSI_STATE_STAY_LOW;
} else if (
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_MEDIUM) ||
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_MEDIUM)
) {
if (btRssi >= (rssiThresh1 + BTC_RSSI_COEX_THRESH_TOL_8723B_1ANT))
btRssiState = BTC_RSSI_STATE_HIGH;
else if (btRssi < rssiThresh)
btRssiState = BTC_RSSI_STATE_LOW;
else
btRssiState = BTC_RSSI_STATE_STAY_MEDIUM;
} else {
if (btRssi < rssiThresh1)
btRssiState = BTC_RSSI_STATE_MEDIUM;
else
btRssiState = BTC_RSSI_STATE_STAY_HIGH;
}
}
pCoexSta->preBtRssiState = btRssiState;
return btRssiState;
}
static void halbtc8723b1ant_UpdateRaMask(
struct btc_coexist *pBtCoexist, bool bForceExec, u32 disRateMask
)
{
pCoexDm->curRaMask = disRateMask;
if (bForceExec || (pCoexDm->preRaMask != pCoexDm->curRaMask))
pBtCoexist->fBtcSet(
pBtCoexist,
BTC_SET_ACT_UPDATE_RAMASK,
&pCoexDm->curRaMask
);
pCoexDm->preRaMask = pCoexDm->curRaMask;
}
static void halbtc8723b1ant_AutoRateFallbackRetry(
struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
)
{
bool bWifiUnderBMode = false;
pCoexDm->curArfrType = type;
if (bForceExec || (pCoexDm->preArfrType != pCoexDm->curArfrType)) {
switch (pCoexDm->curArfrType) {
case 0: /* normal mode */
pBtCoexist->fBtcWrite4Byte(
pBtCoexist, 0x430, pCoexDm->backupArfrCnt1
);
pBtCoexist->fBtcWrite4Byte(
pBtCoexist, 0x434, pCoexDm->backupArfrCnt2
);
break;
case 1:
pBtCoexist->fBtcGet(
pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode
);
if (bWifiUnderBMode) {
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x430, 0x0);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x434, 0x01010101);
} else {
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x430, 0x0);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x434, 0x04030201);
}
break;
default:
break;
}
}
pCoexDm->preArfrType = pCoexDm->curArfrType;
}
static void halbtc8723b1ant_RetryLimit(
struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
)
{
pCoexDm->curRetryLimitType = type;
if (
bForceExec ||
(pCoexDm->preRetryLimitType != pCoexDm->curRetryLimitType)
) {
switch (pCoexDm->curRetryLimitType) {
case 0: /* normal mode */
pBtCoexist->fBtcWrite2Byte(
pBtCoexist, 0x42a, pCoexDm->backupRetryLimit
);
break;
case 1: /* retry limit =8 */
pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x42a, 0x0808);
break;
default:
break;
}
}
pCoexDm->preRetryLimitType = pCoexDm->curRetryLimitType;
}
static void halbtc8723b1ant_AmpduMaxTime(
struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
)
{
pCoexDm->curAmpduTimeType = type;
if (
bForceExec || (pCoexDm->preAmpduTimeType != pCoexDm->curAmpduTimeType)
) {
switch (pCoexDm->curAmpduTimeType) {
case 0: /* normal mode */
pBtCoexist->fBtcWrite1Byte(
pBtCoexist, 0x456, pCoexDm->backupAmpduMaxTime
);
break;
case 1: /* AMPDU timw = 0x38 * 32us */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x456, 0x38);
break;
default:
break;
}
}
pCoexDm->preAmpduTimeType = pCoexDm->curAmpduTimeType;
}
static void halbtc8723b1ant_LimitedTx(
struct btc_coexist *pBtCoexist,
bool bForceExec,
u8 raMaskType,
u8 arfrType,
u8 retryLimitType,
u8 ampduTimeType
)
{
switch (raMaskType) {
case 0: /* normal mode */
halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x0);
break;
case 1: /* disable cck 1/2 */
halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x00000003);
break;
case 2: /* disable cck 1/2/5.5, ofdm 6/9/12/18/24, mcs 0/1/2/3/4 */
halbtc8723b1ant_UpdateRaMask(pBtCoexist, bForceExec, 0x0001f1f7);
break;
default:
break;
}
halbtc8723b1ant_AutoRateFallbackRetry(pBtCoexist, bForceExec, arfrType);
halbtc8723b1ant_RetryLimit(pBtCoexist, bForceExec, retryLimitType);
halbtc8723b1ant_AmpduMaxTime(pBtCoexist, bForceExec, ampduTimeType);
}
static void halbtc8723b1ant_LimitedRx(
struct btc_coexist *pBtCoexist,
bool bForceExec,
bool bRejApAggPkt,
bool bBtCtrlAggBufSize,
u8 aggBufSize
)
{
bool bRejectRxAgg = bRejApAggPkt;
bool bBtCtrlRxAggSize = bBtCtrlAggBufSize;
u8 rxAggSize = aggBufSize;
/* */
/* Rx Aggregation related setting */
/* */
pBtCoexist->fBtcSet(
pBtCoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &bRejectRxAgg
);
/* decide BT control aggregation buf size or not */
pBtCoexist->fBtcSet(
pBtCoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bBtCtrlRxAggSize
);
/* aggregation buf size, only work when BT control Rx aggregation size. */
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxAggSize);
/* real update aggregation setting */
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
}
static void halbtc8723b1ant_QueryBtInfo(struct btc_coexist *pBtCoexist)
{
u8 H2C_Parameter[1] = {0};
pCoexSta->bC2hBtInfoReqSent = true;
H2C_Parameter[0] |= BIT0; /* trigger */
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x61, 1, H2C_Parameter);
}
static void halbtc8723b1ant_MonitorBtCtr(struct btc_coexist *pBtCoexist)
{
u32 regHPTxRx, regLPTxRx, u4Tmp;
u32 regHPTx = 0, regHPRx = 0, regLPTx = 0, regLPRx = 0;
static u8 NumOfBtCounterChk;
/* to avoid 0x76e[3] = 1 (WLAN_Act control by PTA) during IPS */
/* if (! (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x76e) & 0x8)) */
if (pCoexSta->bUnderIps) {
pCoexSta->highPriorityTx = 65535;
pCoexSta->highPriorityRx = 65535;
pCoexSta->lowPriorityTx = 65535;
pCoexSta->lowPriorityRx = 65535;
return;
}
regHPTxRx = 0x770;
regLPTxRx = 0x774;
u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regHPTxRx);
regHPTx = u4Tmp & bMaskLWord;
regHPRx = (u4Tmp & bMaskHWord) >> 16;
u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, regLPTxRx);
regLPTx = u4Tmp & bMaskLWord;
regLPRx = (u4Tmp & bMaskHWord) >> 16;
pCoexSta->highPriorityTx = regHPTx;
pCoexSta->highPriorityRx = regHPRx;
pCoexSta->lowPriorityTx = regLPTx;
pCoexSta->lowPriorityRx = regLPRx;
if ((pCoexSta->lowPriorityTx >= 1050) && (!pCoexSta->bC2hBtInquiryPage))
pCoexSta->popEventCnt++;
/* reset counter */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc);
if ((regHPTx == 0) && (regHPRx == 0) && (regLPTx == 0) && (regLPRx == 0)) {
NumOfBtCounterChk++;
if (NumOfBtCounterChk >= 3) {
halbtc8723b1ant_QueryBtInfo(pBtCoexist);
NumOfBtCounterChk = 0;
}
}
}
static void halbtc8723b1ant_MonitorWiFiCtr(struct btc_coexist *pBtCoexist)
{
s32 wifiRssi = 0;
bool bWifiBusy = false, bWifiUnderBMode = false;
static u8 nCCKLockCounter;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi);
pBtCoexist->fBtcGet(
pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode
);
if (pCoexSta->bUnderIps) {
pCoexSta->nCRCOK_CCK = 0;
pCoexSta->nCRCOK_11g = 0;
pCoexSta->nCRCOK_11n = 0;
pCoexSta->nCRCOK_11nAgg = 0;
pCoexSta->nCRCErr_CCK = 0;
pCoexSta->nCRCErr_11g = 0;
pCoexSta->nCRCErr_11n = 0;
pCoexSta->nCRCErr_11nAgg = 0;
} else {
pCoexSta->nCRCOK_CCK = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xf88);
pCoexSta->nCRCOK_11g = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf94);
pCoexSta->nCRCOK_11n = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf90);
pCoexSta->nCRCOK_11nAgg = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xfb8);
pCoexSta->nCRCErr_CCK = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0xf84);
pCoexSta->nCRCErr_11g = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf96);
pCoexSta->nCRCErr_11n = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xf92);
pCoexSta->nCRCErr_11nAgg = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0xfba);
}
/* reset counter */
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0xf16, 0x1, 0x1);
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0xf16, 0x1, 0x0);
if (bWifiBusy && (wifiRssi >= 30) && !bWifiUnderBMode) {
if (
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY) ||
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY)
) {
if (
pCoexSta->nCRCOK_CCK > (
pCoexSta->nCRCOK_11g +
pCoexSta->nCRCOK_11n +
pCoexSta->nCRCOK_11nAgg
)
) {
if (nCCKLockCounter < 5)
nCCKLockCounter++;
} else {
if (nCCKLockCounter > 0)
nCCKLockCounter--;
}
} else {
if (nCCKLockCounter > 0)
nCCKLockCounter--;
}
} else {
if (nCCKLockCounter > 0)
nCCKLockCounter--;
}
if (!pCoexSta->bPreCCKLock) {
if (nCCKLockCounter >= 5)
pCoexSta->bCCKLock = true;
else
pCoexSta->bCCKLock = false;
} else {
if (nCCKLockCounter == 0)
pCoexSta->bCCKLock = false;
else
pCoexSta->bCCKLock = true;
}
pCoexSta->bPreCCKLock = pCoexSta->bCCKLock;
}
static bool halbtc8723b1ant_IsWifiStatusChanged(struct btc_coexist *pBtCoexist)
{
static bool bPreWifiBusy, bPreUnder4way, bPreBtHsOn;
bool bWifiBusy = false, bUnder4way = false, bBtHsOn = false;
bool bWifiConnected = false;
pBtCoexist->fBtcGet(
pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected
);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
pBtCoexist->fBtcGet(
pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way
);
if (bWifiConnected) {
if (bWifiBusy != bPreWifiBusy) {
bPreWifiBusy = bWifiBusy;
return true;
}
if (bUnder4way != bPreUnder4way) {
bPreUnder4way = bUnder4way;
return true;
}
if (bBtHsOn != bPreBtHsOn) {
bPreBtHsOn = bBtHsOn;
return true;
}
}
return false;
}
static void halbtc8723b1ant_UpdateBtLinkInfo(struct btc_coexist *pBtCoexist)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
bool bBtHsOn = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
pBtLinkInfo->bBtLinkExist = pCoexSta->bBtLinkExist;
pBtLinkInfo->bScoExist = pCoexSta->bScoExist;
pBtLinkInfo->bA2dpExist = pCoexSta->bA2dpExist;
pBtLinkInfo->bPanExist = pCoexSta->bPanExist;
pBtLinkInfo->bHidExist = pCoexSta->bHidExist;
/* work around for HS mode. */
if (bBtHsOn) {
pBtLinkInfo->bPanExist = true;
pBtLinkInfo->bBtLinkExist = true;
}
/* check if Sco only */
if (
pBtLinkInfo->bScoExist &&
!pBtLinkInfo->bA2dpExist &&
!pBtLinkInfo->bPanExist &&
!pBtLinkInfo->bHidExist
)
pBtLinkInfo->bScoOnly = true;
else
pBtLinkInfo->bScoOnly = false;
/* check if A2dp only */
if (
!pBtLinkInfo->bScoExist &&
pBtLinkInfo->bA2dpExist &&
!pBtLinkInfo->bPanExist &&
!pBtLinkInfo->bHidExist
)
pBtLinkInfo->bA2dpOnly = true;
else
pBtLinkInfo->bA2dpOnly = false;
/* check if Pan only */
if (
!pBtLinkInfo->bScoExist &&
!pBtLinkInfo->bA2dpExist &&
pBtLinkInfo->bPanExist &&
!pBtLinkInfo->bHidExist
)
pBtLinkInfo->bPanOnly = true;
else
pBtLinkInfo->bPanOnly = false;
/* check if Hid only */
if (
!pBtLinkInfo->bScoExist &&
!pBtLinkInfo->bA2dpExist &&
!pBtLinkInfo->bPanExist &&
pBtLinkInfo->bHidExist
)
pBtLinkInfo->bHidOnly = true;
else
pBtLinkInfo->bHidOnly = false;
}
static u8 halbtc8723b1ant_ActionAlgorithm(struct btc_coexist *pBtCoexist)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
bool bBtHsOn = false;
u8 algorithm = BT_8723B_1ANT_COEX_ALGO_UNDEFINED;
u8 numOfDiffProfile = 0;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
if (!pBtLinkInfo->bBtLinkExist)
return algorithm;
if (pBtLinkInfo->bScoExist)
numOfDiffProfile++;
if (pBtLinkInfo->bHidExist)
numOfDiffProfile++;
if (pBtLinkInfo->bPanExist)
numOfDiffProfile++;
if (pBtLinkInfo->bA2dpExist)
numOfDiffProfile++;
if (numOfDiffProfile == 1) {
if (pBtLinkInfo->bScoExist) {
algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
} else {
if (pBtLinkInfo->bHidExist) {
algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
} else if (pBtLinkInfo->bA2dpExist) {
algorithm = BT_8723B_1ANT_COEX_ALGO_A2DP;
} else if (pBtLinkInfo->bPanExist) {
if (bBtHsOn)
algorithm = BT_8723B_1ANT_COEX_ALGO_PANHS;
else
algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR;
}
}
} else if (numOfDiffProfile == 2) {
if (pBtLinkInfo->bScoExist) {
if (pBtLinkInfo->bHidExist) {
algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
} else if (pBtLinkInfo->bA2dpExist) {
algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
} else if (pBtLinkInfo->bPanExist) {
if (bBtHsOn)
algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
else
algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
}
} else {
if (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist) {
algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
} else if (pBtLinkInfo->bHidExist && pBtLinkInfo->bPanExist) {
if (bBtHsOn)
algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
else
algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
} else if (pBtLinkInfo->bPanExist && pBtLinkInfo->bA2dpExist) {
if (bBtHsOn)
algorithm = BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS;
else
algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP;
}
}
} else if (numOfDiffProfile == 3) {
if (pBtLinkInfo->bScoExist) {
if (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist) {
algorithm = BT_8723B_1ANT_COEX_ALGO_HID;
} else if (
pBtLinkInfo->bHidExist && pBtLinkInfo->bPanExist
) {
if (bBtHsOn)
algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
else
algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
} else if (pBtLinkInfo->bPanExist && pBtLinkInfo->bA2dpExist) {
if (bBtHsOn)
algorithm = BT_8723B_1ANT_COEX_ALGO_SCO;
else
algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
}
} else {
if (
pBtLinkInfo->bHidExist &&
pBtLinkInfo->bPanExist &&
pBtLinkInfo->bA2dpExist
) {
if (bBtHsOn)
algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP;
else
algorithm = BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR;
}
}
} else if (numOfDiffProfile >= 3) {
if (pBtLinkInfo->bScoExist) {
if (
pBtLinkInfo->bHidExist &&
pBtLinkInfo->bPanExist &&
pBtLinkInfo->bA2dpExist
) {
if (!bBtHsOn)
algorithm = BT_8723B_1ANT_COEX_ALGO_PANEDR_HID;
}
}
}
return algorithm;
}
static void halbtc8723b1ant_SetSwPenaltyTxRateAdaptive(
struct btc_coexist *pBtCoexist, bool bLowPenaltyRa
)
{
u8 H2C_Parameter[6] = {0};
H2C_Parameter[0] = 0x6; /* opCode, 0x6 = Retry_Penalty */
if (bLowPenaltyRa) {
H2C_Parameter[1] |= BIT0;
H2C_Parameter[2] = 0x00; /* normal rate except MCS7/6/5, OFDM54/48/36 */
H2C_Parameter[3] = 0xf7; /* MCS7 or OFDM54 */
H2C_Parameter[4] = 0xf8; /* MCS6 or OFDM48 */
H2C_Parameter[5] = 0xf9; /* MCS5 or OFDM36 */
}
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x69, 6, H2C_Parameter);
}
static void halbtc8723b1ant_LowPenaltyRa(
struct btc_coexist *pBtCoexist, bool bForceExec, bool bLowPenaltyRa
)
{
pCoexDm->bCurLowPenaltyRa = bLowPenaltyRa;
if (!bForceExec) {
if (pCoexDm->bPreLowPenaltyRa == pCoexDm->bCurLowPenaltyRa)
return;
}
halbtc8723b1ant_SetSwPenaltyTxRateAdaptive(
pBtCoexist, pCoexDm->bCurLowPenaltyRa
);
pCoexDm->bPreLowPenaltyRa = pCoexDm->bCurLowPenaltyRa;
}
static void halbtc8723b1ant_SetCoexTable(
struct btc_coexist *pBtCoexist,
u32 val0x6c0,
u32 val0x6c4,
u32 val0x6c8,
u8 val0x6cc
)
{
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c0, val0x6c0);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c4, val0x6c4);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c8, val0x6c8);
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cc, val0x6cc);
}
static void halbtc8723b1ant_CoexTable(
struct btc_coexist *pBtCoexist,
bool bForceExec,
u32 val0x6c0,
u32 val0x6c4,
u32 val0x6c8,
u8 val0x6cc
)
{
pCoexDm->curVal0x6c0 = val0x6c0;
pCoexDm->curVal0x6c4 = val0x6c4;
pCoexDm->curVal0x6c8 = val0x6c8;
pCoexDm->curVal0x6cc = val0x6cc;
if (!bForceExec) {
if (
(pCoexDm->preVal0x6c0 == pCoexDm->curVal0x6c0) &&
(pCoexDm->preVal0x6c4 == pCoexDm->curVal0x6c4) &&
(pCoexDm->preVal0x6c8 == pCoexDm->curVal0x6c8) &&
(pCoexDm->preVal0x6cc == pCoexDm->curVal0x6cc)
)
return;
}
halbtc8723b1ant_SetCoexTable(
pBtCoexist, val0x6c0, val0x6c4, val0x6c8, val0x6cc
);
pCoexDm->preVal0x6c0 = pCoexDm->curVal0x6c0;
pCoexDm->preVal0x6c4 = pCoexDm->curVal0x6c4;
pCoexDm->preVal0x6c8 = pCoexDm->curVal0x6c8;
pCoexDm->preVal0x6cc = pCoexDm->curVal0x6cc;
}
static void halbtc8723b1ant_CoexTableWithType(
struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
)
{
pCoexSta->nCoexTableType = type;
switch (type) {
case 0:
halbtc8723b1ant_CoexTable(
pBtCoexist, bForceExec, 0x55555555, 0x55555555, 0xffffff, 0x3
);
break;
case 1:
halbtc8723b1ant_CoexTable(
pBtCoexist, bForceExec, 0x55555555, 0x5a5a5a5a, 0xffffff, 0x3
);
break;
case 2:
halbtc8723b1ant_CoexTable(
pBtCoexist, bForceExec, 0x5a5a5a5a, 0x5a5a5a5a, 0xffffff, 0x3
);
break;
case 3:
halbtc8723b1ant_CoexTable(
pBtCoexist, bForceExec, 0xaaaa5555, 0xaaaa5a5a, 0xffffff, 0x3
);
break;
case 4:
halbtc8723b1ant_CoexTable(
pBtCoexist, bForceExec, 0x55555555, 0xaaaa5a5a, 0xffffff, 0x3
);
break;
case 5:
halbtc8723b1ant_CoexTable(
pBtCoexist, bForceExec, 0x5a5a5a5a, 0xaaaa5a5a, 0xffffff, 0x3
);
break;
case 6:
halbtc8723b1ant_CoexTable(
pBtCoexist, bForceExec, 0x55555555, 0xaaaaaaaa, 0xffffff, 0x3
);
break;
case 7:
halbtc8723b1ant_CoexTable(
pBtCoexist, bForceExec, 0xaaaaaaaa, 0xaaaaaaaa, 0xffffff, 0x3
);
break;
default:
break;
}
}
static void halbtc8723b1ant_SetFwIgnoreWlanAct(
struct btc_coexist *pBtCoexist, bool bEnable
)
{
u8 H2C_Parameter[1] = {0};
if (bEnable)
H2C_Parameter[0] |= BIT0; /* function enable */
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x63, 1, H2C_Parameter);
}
static void halbtc8723b1ant_IgnoreWlanAct(
struct btc_coexist *pBtCoexist, bool bForceExec, bool bEnable
)
{
pCoexDm->bCurIgnoreWlanAct = bEnable;
if (!bForceExec) {
if (pCoexDm->bPreIgnoreWlanAct == pCoexDm->bCurIgnoreWlanAct)
return;
}
halbtc8723b1ant_SetFwIgnoreWlanAct(pBtCoexist, bEnable);
pCoexDm->bPreIgnoreWlanAct = pCoexDm->bCurIgnoreWlanAct;
}
static void halbtc8723b1ant_SetLpsRpwm(
struct btc_coexist *pBtCoexist, u8 lpsVal, u8 rpwmVal
)
{
u8 lps = lpsVal;
u8 rpwm = rpwmVal;
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_LPS_VAL, &lps);
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_RPWM_VAL, &rpwm);
}
static void halbtc8723b1ant_LpsRpwm(
struct btc_coexist *pBtCoexist, bool bForceExec, u8 lpsVal, u8 rpwmVal
)
{
pCoexDm->curLps = lpsVal;
pCoexDm->curRpwm = rpwmVal;
if (!bForceExec) {
if (
(pCoexDm->preLps == pCoexDm->curLps) &&
(pCoexDm->preRpwm == pCoexDm->curRpwm)
) {
return;
}
}
halbtc8723b1ant_SetLpsRpwm(pBtCoexist, lpsVal, rpwmVal);
pCoexDm->preLps = pCoexDm->curLps;
pCoexDm->preRpwm = pCoexDm->curRpwm;
}
static void halbtc8723b1ant_SwMechanism(
struct btc_coexist *pBtCoexist, bool bLowPenaltyRA
)
{
halbtc8723b1ant_LowPenaltyRa(pBtCoexist, NORMAL_EXEC, bLowPenaltyRA);
}
static void halbtc8723b1ant_SetAntPath(
struct btc_coexist *pBtCoexist, u8 antPosType, bool bInitHwCfg, bool bWifiOff
)
{
struct btc_board_info *pBoardInfo = &pBtCoexist->boardInfo;
u32 fwVer = 0, u4Tmp = 0, cntBtCalChk = 0;
bool bPgExtSwitch = false;
bool bUseExtSwitch = false;
bool bIsInMpMode = false;
u8 H2C_Parameter[2] = {0}, u1Tmp = 0;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_EXT_SWITCH, &bPgExtSwitch);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer); /* [31:16]=fw ver, [15:0]=fw sub ver */
if ((fwVer > 0 && fwVer < 0xc0000) || bPgExtSwitch)
bUseExtSwitch = true;
if (bInitHwCfg) {
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780); /* WiFi TRx Mask on */
pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15); /* BT TRx Mask on */
if (fwVer >= 0x180000) {
/* Use H2C to set GNT_BT to HIGH */
H2C_Parameter[0] = 1;
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
} else /* set grant_bt to high */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
/* set wlan_act control by PTA */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x39, 0x8, 0x1);
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x974, 0xff);
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x944, 0x3, 0x3);
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x930, 0x77);
} else if (bWifiOff) {
if (fwVer >= 0x180000) {
/* Use H2C to set GNT_BT to HIGH */
H2C_Parameter[0] = 1;
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
} else /* set grant_bt to high */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
/* set wlan_act to always low */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE, &bIsInMpMode);
if (!bIsInMpMode)
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x0); /* BT select s0/s1 is controlled by BT */
else
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */
/* 0x4c[24:23]= 00, Set Antenna control by BT_RFE_CTRL BT Vendor 0xac = 0xf002 */
u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
u4Tmp &= ~BIT23;
u4Tmp &= ~BIT24;
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
} else {
/* Use H2C to set GNT_BT to LOW */
if (fwVer >= 0x180000) {
if (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765) != 0) {
H2C_Parameter[0] = 0;
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
}
} else {
/* BT calibration check */
while (cntBtCalChk <= 20) {
u1Tmp = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x49d);
cntBtCalChk++;
if (u1Tmp & BIT0)
mdelay(50);
else
break;
}
/* set grant_bt to PTA */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x0);
}
if (pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x76e) != 0xc)
/* set wlan_act control by PTA */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc);
}
if (bUseExtSwitch) {
if (bInitHwCfg) {
/* 0x4c[23]= 0, 0x4c[24]= 1 Antenna control by WL/BT */
u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
u4Tmp &= ~BIT23;
u4Tmp |= BIT24;
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /* fixed internal switch S1->WiFi, S0->BT */
if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {
/* tell firmware "no antenna inverse" */
H2C_Parameter[0] = 0;
H2C_Parameter[1] = 1; /* ext switch type */
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
} else {
/* tell firmware "antenna inverse" */
H2C_Parameter[0] = 1;
H2C_Parameter[1] = 1; /* ext switch type */
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
}
}
/* ext switch setting */
switch (antPosType) {
case BTC_ANT_PATH_WIFI:
if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);
else
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);
break;
case BTC_ANT_PATH_BT:
if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);
else
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);
break;
default:
case BTC_ANT_PATH_PTA:
if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1);
else
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2);
break;
}
} else {
if (bInitHwCfg) {
/* 0x4c[23]= 1, 0x4c[24]= 0 Antenna control by 0x64 */
u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
u4Tmp |= BIT23;
u4Tmp &= ~BIT24;
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
/* Fix Ext switch Main->S1, Aux->S0 */
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x64, 0x1, 0x0);
if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {
/* tell firmware "no antenna inverse" */
H2C_Parameter[0] = 0;
H2C_Parameter[1] = 0; /* internal switch type */
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
} else {
/* tell firmware "antenna inverse" */
H2C_Parameter[0] = 1;
H2C_Parameter[1] = 0; /* internal switch type */
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
}
}
/* internal switch setting */
switch (antPosType) {
case BTC_ANT_PATH_WIFI:
if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
else
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
break;
case BTC_ANT_PATH_BT:
if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
else
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
break;
default:
case BTC_ANT_PATH_PTA:
if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT)
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x200);
else
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x80);
break;
}
}
}
static void halbtc8723b1ant_SetFwPstdma(
struct btc_coexist *pBtCoexist, u8 byte1, u8 byte2, u8 byte3, u8 byte4, u8 byte5
)
{
u8 H2C_Parameter[5] = {0};
u8 realByte1 = byte1, realByte5 = byte5;
bool bApEnable = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);
if (bApEnable) {
if (byte1 & BIT4 && !(byte1 & BIT5)) {
realByte1 &= ~BIT4;
realByte1 |= BIT5;
realByte5 |= BIT5;
realByte5 &= ~BIT6;
}
}
H2C_Parameter[0] = realByte1;
H2C_Parameter[1] = byte2;
H2C_Parameter[2] = byte3;
H2C_Parameter[3] = byte4;
H2C_Parameter[4] = realByte5;
pCoexDm->psTdmaPara[0] = realByte1;
pCoexDm->psTdmaPara[1] = byte2;
pCoexDm->psTdmaPara[2] = byte3;
pCoexDm->psTdmaPara[3] = byte4;
pCoexDm->psTdmaPara[4] = realByte5;
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x60, 5, H2C_Parameter);
}
static void halbtc8723b1ant_PsTdma(
struct btc_coexist *pBtCoexist, bool bForceExec, bool bTurnOn, u8 type
)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
bool bWifiBusy = false;
u8 rssiAdjustVal = 0;
u8 psTdmaByte4Val = 0x50, psTdmaByte0Val = 0x51, psTdmaByte3Val = 0x10;
s8 nWiFiDurationAdjust = 0x0;
/* u32 fwVer = 0; */
pCoexDm->bCurPsTdmaOn = bTurnOn;
pCoexDm->curPsTdma = type;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
if (!bForceExec) {
if (
(pCoexDm->bPrePsTdmaOn == pCoexDm->bCurPsTdmaOn) &&
(pCoexDm->prePsTdma == pCoexDm->curPsTdma)
)
return;
}
if (pCoexSta->nScanAPNum <= 5)
nWiFiDurationAdjust = 5;
else if (pCoexSta->nScanAPNum >= 40)
nWiFiDurationAdjust = -15;
else if (pCoexSta->nScanAPNum >= 20)
nWiFiDurationAdjust = -10;
if (!pCoexSta->bForceLpsOn) { /* only for A2DP-only case 1/2/9/11 */
psTdmaByte0Val = 0x61; /* no null-pkt */
psTdmaByte3Val = 0x11; /* no tx-pause at BT-slot */
psTdmaByte4Val = 0x10; /* 0x778 = d/1 toggle */
}
if (bTurnOn) {
if (pBtLinkInfo->bSlaveRole)
psTdmaByte4Val = psTdmaByte4Val | 0x1; /* 0x778 = 0x1 at wifi slot (no blocking BT Low-Pri pkts) */
switch (type) {
default:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x51, 0x1a, 0x1a, 0x0, psTdmaByte4Val
);
break;
case 1:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist,
psTdmaByte0Val,
0x3a + nWiFiDurationAdjust,
0x03,
psTdmaByte3Val,
psTdmaByte4Val
);
break;
case 2:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist,
psTdmaByte0Val,
0x2d + nWiFiDurationAdjust,
0x03,
psTdmaByte3Val,
psTdmaByte4Val
);
break;
case 3:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x51, 0x1d, 0x1d, 0x0, 0x10
);
break;
case 4:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x93, 0x15, 0x3, 0x14, 0x0
);
break;
case 5:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x61, 0x15, 0x3, 0x11, 0x10
);
break;
case 6:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x61, 0x20, 0x3, 0x11, 0x11
);
break;
case 7:
halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x13, 0xc, 0x5, 0x0, 0x0);
break;
case 8:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x93, 0x25, 0x3, 0x10, 0x0
);
break;
case 9:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist,
psTdmaByte0Val,
0x21,
0x3,
psTdmaByte3Val,
psTdmaByte4Val
);
break;
case 10:
halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x13, 0xa, 0xa, 0x0, 0x40);
break;
case 11:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist,
psTdmaByte0Val,
0x21,
0x03,
psTdmaByte3Val,
psTdmaByte4Val
);
break;
case 12:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x51, 0x0a, 0x0a, 0x0, 0x50
);
break;
case 13:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x51, 0x12, 0x12, 0x0, 0x10
);
break;
case 14:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x51, 0x21, 0x3, 0x10, psTdmaByte4Val
);
break;
case 15:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x13, 0xa, 0x3, 0x8, 0x0
);
break;
case 16:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x93, 0x15, 0x3, 0x10, 0x0
);
break;
case 18:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x93, 0x25, 0x3, 0x10, 0x0
);
break;
case 20:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x61, 0x3f, 0x03, 0x11, 0x10
);
break;
case 21:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x61, 0x25, 0x03, 0x11, 0x11
);
break;
case 22:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x61, 0x25, 0x03, 0x11, 0x10
);
break;
case 23:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0xe3, 0x25, 0x3, 0x31, 0x18
);
break;
case 24:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0xe3, 0x15, 0x3, 0x31, 0x18
);
break;
case 25:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0xe3, 0xa, 0x3, 0x31, 0x18
);
break;
case 26:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0xe3, 0xa, 0x3, 0x31, 0x18
);
break;
case 27:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0xe3, 0x25, 0x3, 0x31, 0x98
);
break;
case 28:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x69, 0x25, 0x3, 0x31, 0x0
);
break;
case 29:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0xab, 0x1a, 0x1a, 0x1, 0x10
);
break;
case 30:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x51, 0x30, 0x3, 0x10, 0x10
);
break;
case 31:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0xd3, 0x1a, 0x1a, 0x0, 0x58
);
break;
case 32:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x61, 0x35, 0x3, 0x11, 0x11
);
break;
case 33:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0xa3, 0x25, 0x3, 0x30, 0x90
);
break;
case 34:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x53, 0x1a, 0x1a, 0x0, 0x10
);
break;
case 35:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x63, 0x1a, 0x1a, 0x0, 0x10
);
break;
case 36:
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0xd3, 0x12, 0x3, 0x14, 0x50
);
break;
case 40: /* SoftAP only with no sta associated, BT disable , TDMA mode for power saving */
/* here softap mode screen off will cost 70-80mA for phone */
halbtc8723b1ant_SetFwPstdma(
pBtCoexist, 0x23, 0x18, 0x00, 0x10, 0x24
);
break;
}
} else {
/* disable PS tdma */
switch (type) {
case 8: /* PTA Control */
halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x8, 0x0, 0x0, 0x0, 0x0);
halbtc8723b1ant_SetAntPath(
pBtCoexist, BTC_ANT_PATH_PTA, false, false
);
break;
case 0:
default: /* Software control, Antenna at BT side */
halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x0, 0x0);
halbtc8723b1ant_SetAntPath(
pBtCoexist, BTC_ANT_PATH_BT, false, false
);
break;
case 9: /* Software control, Antenna at WiFi side */
halbtc8723b1ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x0, 0x0);
halbtc8723b1ant_SetAntPath(
pBtCoexist, BTC_ANT_PATH_WIFI, false, false
);
break;
}
}
rssiAdjustVal = 0;
pBtCoexist->fBtcSet(
pBtCoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE, &rssiAdjustVal
);
/* update pre state */
pCoexDm->bPrePsTdmaOn = pCoexDm->bCurPsTdmaOn;
pCoexDm->prePsTdma = pCoexDm->curPsTdma;
}
static bool halbtc8723b1ant_IsCommonAction(struct btc_coexist *pBtCoexist)
{
bool bCommon = false, bWifiConnected = false, bWifiBusy = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
if (
!bWifiConnected &&
pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE
) {
/* halbtc8723b1ant_SwMechanism(pBtCoexist, false); */
bCommon = true;
} else if (
bWifiConnected &&
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE)
) {
/* halbtc8723b1ant_SwMechanism(pBtCoexist, false); */
bCommon = true;
} else if (
!bWifiConnected &&
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE)
) {
/* halbtc8723b1ant_SwMechanism(pBtCoexist, false); */
bCommon = true;
} else if (
bWifiConnected &&
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE)
) {
/* halbtc8723b1ant_SwMechanism(pBtCoexist, false); */
bCommon = true;
} else if (
!bWifiConnected &&
(pCoexDm->btStatus != BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE)
) {
/* halbtc8723b1ant_SwMechanism(pBtCoexist, false); */
bCommon = true;
} else {
bCommon = false;
}
return bCommon;
}
static void halbtc8723b1ant_TdmaDurationAdjustForAcl(
struct btc_coexist *pBtCoexist, u8 wifiStatus
)
{
static s32 up, dn, m, n, WaitCount;
s32 result; /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
u8 retryCount = 0, btInfoExt;
if (
(wifiStatus == BT_8723B_1ANT_WIFI_STATUS_NON_CONNECTED_ASSO_AUTH_SCAN) ||
(wifiStatus == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN) ||
(wifiStatus == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SPECIAL_PKT)
) {
if (
pCoexDm->curPsTdma != 1 &&
pCoexDm->curPsTdma != 2 &&
pCoexDm->curPsTdma != 3 &&
pCoexDm->curPsTdma != 9
) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
pCoexDm->psTdmaDuAdjType = 9;
up = 0;
dn = 0;
m = 1;
n = 3;
result = 0;
WaitCount = 0;
}
return;
}
if (!pCoexDm->bAutoTdmaAdjust) {
pCoexDm->bAutoTdmaAdjust = true;
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
pCoexDm->psTdmaDuAdjType = 2;
/* */
up = 0;
dn = 0;
m = 1;
n = 3;
result = 0;
WaitCount = 0;
} else {
/* acquire the BT TRx retry count from BT_Info byte2 */
retryCount = pCoexSta->btRetryCnt;
btInfoExt = pCoexSta->btInfoExt;
if (pCoexSta->lowPriorityTx > 1050 || pCoexSta->lowPriorityRx > 1250)
retryCount++;
result = 0;
WaitCount++;
if (retryCount == 0) { /* no retry in the last 2-second duration */
up++;
dn--;
if (dn <= 0)
dn = 0;
if (up >= n) { /* if 連續 n 個2秒 retry count為0, 則調寬WiFi duration */
WaitCount = 0;
n = 3;
up = 0;
dn = 0;
result = 1;
}
} else if (retryCount <= 3) { /* <=3 retry in the last 2-second duration */
up--;
dn++;
if (up <= 0)
up = 0;
if (dn == 2) { /* if 連續 2 個2秒 retry count< 3, 則調窄WiFi duration */
if (WaitCount <= 2)
m++; /* 避免一直在兩個level中來回 */
else
m = 1;
if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */
m = 20;
n = 3 * m;
up = 0;
dn = 0;
WaitCount = 0;
result = -1;
}
} else { /* retry count > 3, 只要1次 retry count > 3, 則調窄WiFi duration */
if (WaitCount == 1)
m++; /* 避免一直在兩個level中來回 */
else
m = 1;
if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */
m = 20;
n = 3 * m;
up = 0;
dn = 0;
WaitCount = 0;
result = -1;
}
if (result == -1) {
if (
BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(btInfoExt) &&
((pCoexDm->curPsTdma == 1) || (pCoexDm->curPsTdma == 2))
) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
pCoexDm->psTdmaDuAdjType = 9;
} else if (pCoexDm->curPsTdma == 1) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
pCoexDm->psTdmaDuAdjType = 2;
} else if (pCoexDm->curPsTdma == 2) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
pCoexDm->psTdmaDuAdjType = 9;
} else if (pCoexDm->curPsTdma == 9) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 11);
pCoexDm->psTdmaDuAdjType = 11;
}
} else if (result == 1) {
if (
BT_INFO_8723B_1ANT_A2DP_BASIC_RATE(btInfoExt) &&
((pCoexDm->curPsTdma == 1) || (pCoexDm->curPsTdma == 2))
) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
pCoexDm->psTdmaDuAdjType = 9;
} else if (pCoexDm->curPsTdma == 11) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
pCoexDm->psTdmaDuAdjType = 9;
} else if (pCoexDm->curPsTdma == 9) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 2);
pCoexDm->psTdmaDuAdjType = 2;
} else if (pCoexDm->curPsTdma == 2) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
pCoexDm->psTdmaDuAdjType = 1;
}
}
if (
pCoexDm->curPsTdma != 1 &&
pCoexDm->curPsTdma != 2 &&
pCoexDm->curPsTdma != 9 &&
pCoexDm->curPsTdma != 11
) /* recover to previous adjust type */
halbtc8723b1ant_PsTdma(
pBtCoexist, NORMAL_EXEC, true, pCoexDm->psTdmaDuAdjType
);
}
}
static void halbtc8723b1ant_PsTdmaCheckForPowerSaveState(
struct btc_coexist *pBtCoexist, bool bNewPsState
)
{
u8 lpsMode = 0x0;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_LPS_MODE, &lpsMode);
if (lpsMode) { /* already under LPS state */
if (bNewPsState) {
/* keep state under LPS, do nothing. */
} else /* will leave LPS state, turn off psTdma first */
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
} else { /* NO PS state */
if (bNewPsState) /* will enter LPS state, turn off psTdma first */
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
else {
/* keep state under NO PS state, do nothing. */
}
}
}
static void halbtc8723b1ant_PowerSaveState(
struct btc_coexist *pBtCoexist, u8 psType, u8 lpsVal, u8 rpwmVal
)
{
bool bLowPwrDisable = false;
switch (psType) {
case BTC_PS_WIFI_NATIVE:
/* recover to original 32k low power setting */
bLowPwrDisable = false;
pBtCoexist->fBtcSet(
pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable
);
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_NORMAL_LPS, NULL);
pCoexSta->bForceLpsOn = false;
break;
case BTC_PS_LPS_ON:
halbtc8723b1ant_PsTdmaCheckForPowerSaveState(pBtCoexist, true);
halbtc8723b1ant_LpsRpwm(pBtCoexist, NORMAL_EXEC, lpsVal, rpwmVal);
/* when coex force to enter LPS, do not enter 32k low power. */
bLowPwrDisable = true;
pBtCoexist->fBtcSet(
pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable
);
/* power save must executed before psTdma. */
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_ENTER_LPS, NULL);
pCoexSta->bForceLpsOn = true;
break;
case BTC_PS_LPS_OFF:
halbtc8723b1ant_PsTdmaCheckForPowerSaveState(pBtCoexist, false);
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_LEAVE_LPS, NULL);
pCoexSta->bForceLpsOn = false;
break;
default:
break;
}
}
/* */
/* */
/* Software Coex Mechanism start */
/* */
/* */
/* */
/* */
/* Non-Software Coex Mechanism start */
/* */
/* */
static void halbtc8723b1ant_ActionWifiMultiPort(struct btc_coexist *pBtCoexist)
{
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
}
static void halbtc8723b1ant_ActionHs(struct btc_coexist *pBtCoexist)
{
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
}
static void halbtc8723b1ant_ActionBtInquiry(struct btc_coexist *pBtCoexist)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
bool bWifiConnected = false;
bool bApEnable = false;
bool bWifiBusy = false;
bool bBtBusy = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bBtBusy);
if (!bWifiConnected && !pCoexSta->bWiFiIsHighPriTask) {
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
} else if (
pBtLinkInfo->bScoExist ||
pBtLinkInfo->bHidExist ||
pBtLinkInfo->bA2dpExist
) {
/* SCO/HID/A2DP busy */
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else if (pBtLinkInfo->bPanExist || bWifiBusy) {
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else {
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
}
}
static void halbtc8723b1ant_ActionBtScoHidOnlyBusy(
struct btc_coexist *pBtCoexist, u8 wifiStatus
)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
bool bWifiConnected = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
/* tdma and coex table */
if (pBtLinkInfo->bScoExist) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 5);
} else { /* HID */
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 6);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 5);
}
}
static void halbtc8723b1ant_ActionWifiConnectedBtAclBusy(
struct btc_coexist *pBtCoexist, u8 wifiStatus
)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
halbtc8723b1ant_BtRssiState(2, 28, 0);
if ((pCoexSta->lowPriorityRx >= 1000) && (pCoexSta->lowPriorityRx != 65535))
pBtLinkInfo->bSlaveRole = true;
else
pBtLinkInfo->bSlaveRole = false;
if (pBtLinkInfo->bHidOnly) { /* HID */
halbtc8723b1ant_ActionBtScoHidOnlyBusy(pBtCoexist, wifiStatus);
pCoexDm->bAutoTdmaAdjust = false;
return;
} else if (pBtLinkInfo->bA2dpOnly) { /* A2DP */
if (wifiStatus == BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
pCoexDm->bAutoTdmaAdjust = false;
} else {
halbtc8723b1ant_TdmaDurationAdjustForAcl(pBtCoexist, wifiStatus);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
pCoexDm->bAutoTdmaAdjust = true;
}
} else if (pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist) { /* HID+A2DP */
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 14);
pCoexDm->bAutoTdmaAdjust = false;
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else if (
pBtLinkInfo->bPanOnly ||
(pBtLinkInfo->bHidExist && pBtLinkInfo->bPanExist)
) { /* PAN(OPP, FTP), HID+PAN(OPP, FTP) */
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
pCoexDm->bAutoTdmaAdjust = false;
} else if (
(pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist) ||
(pBtLinkInfo->bHidExist && pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist)
) { /* A2DP+PAN(OPP, FTP), HID+A2DP+PAN(OPP, FTP) */
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
pCoexDm->bAutoTdmaAdjust = false;
} else {
/* BT no-profile busy (0x9) */
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
pCoexDm->bAutoTdmaAdjust = false;
}
}
static void halbtc8723b1ant_ActionWifiNotConnected(struct btc_coexist *pBtCoexist)
{
/* power save state */
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
/* tdma and coex table */
halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 8);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
}
static void halbtc8723b1ant_ActionWifiNotConnectedScan(
struct btc_coexist *pBtCoexist
)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
/* tdma and coex table */
if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
if (pBtLinkInfo->bA2dpExist) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else if (pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 22);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
}
} else if (
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
) {
halbtc8723b1ant_ActionBtScoHidOnlyBusy(
pBtCoexist, BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
);
} else {
/* Bryant Add */
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
}
}
static void halbtc8723b1ant_ActionWifiNotConnectedAssoAuth(
struct btc_coexist *pBtCoexist
)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
/* tdma and coex table */
if (
(pBtLinkInfo->bScoExist) ||
(pBtLinkInfo->bHidExist) ||
(pBtLinkInfo->bA2dpExist)
) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else if (pBtLinkInfo->bPanExist) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
}
}
static void halbtc8723b1ant_ActionWifiConnectedScan(struct btc_coexist *pBtCoexist)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
/* tdma and coex table */
if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
if (pBtLinkInfo->bA2dpExist) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else if (pBtLinkInfo->bA2dpExist && pBtLinkInfo->bPanExist) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 22);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
}
} else if (
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
) {
halbtc8723b1ant_ActionBtScoHidOnlyBusy(
pBtCoexist, BT_8723B_1ANT_WIFI_STATUS_CONNECTED_SCAN
);
} else {
/* Bryant Add */
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
}
}
static void halbtc8723b1ant_ActionWifiConnectedSpecialPacket(
struct btc_coexist *pBtCoexist
)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
/* tdma and coex table */
if (
(pBtLinkInfo->bScoExist) ||
(pBtLinkInfo->bHidExist) ||
(pBtLinkInfo->bA2dpExist)
) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 32);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else if (pBtLinkInfo->bPanExist) {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 20);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 4);
} else {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
}
}
static void halbtc8723b1ant_ActionWifiConnected(struct btc_coexist *pBtCoexist)
{
bool bWifiBusy = false;
bool bScan = false, bLink = false, bRoam = false;
bool bUnder4way = false, bApEnable = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way);
if (bUnder4way) {
halbtc8723b1ant_ActionWifiConnectedSpecialPacket(pBtCoexist);
return;
}
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
if (bScan || bLink || bRoam) {
if (bScan)
halbtc8723b1ant_ActionWifiConnectedScan(pBtCoexist);
else
halbtc8723b1ant_ActionWifiConnectedSpecialPacket(pBtCoexist);
return;
}
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_AP_MODE_ENABLE, &bApEnable);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
/* power save state */
if (
!bApEnable &&
pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY &&
!pBtCoexist->btLinkInfo.bHidOnly
) {
if (pBtCoexist->btLinkInfo.bA2dpOnly) { /* A2DP */
if (!bWifiBusy)
halbtc8723b1ant_PowerSaveState(
pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0
);
else { /* busy */
if (pCoexSta->nScanAPNum >= BT_8723B_1ANT_WIFI_NOISY_THRESH) /* no force LPS, no PS-TDMA, use pure TDMA */
halbtc8723b1ant_PowerSaveState(
pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0
);
else
halbtc8723b1ant_PowerSaveState(
pBtCoexist, BTC_PS_LPS_ON, 0x50, 0x4
);
}
} else if (
(!pCoexSta->bPanExist) &&
(!pCoexSta->bA2dpExist) &&
(!pCoexSta->bHidExist)
)
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
else
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_LPS_ON, 0x50, 0x4);
} else
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
/* tdma and coex table */
if (!bWifiBusy) {
if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
halbtc8723b1ant_ActionWifiConnectedBtAclBusy(
pBtCoexist,
BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE
);
} else if (
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
) {
halbtc8723b1ant_ActionBtScoHidOnlyBusy(pBtCoexist,
BT_8723B_1ANT_WIFI_STATUS_CONNECTED_IDLE);
} else {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
if ((pCoexSta->highPriorityTx) + (pCoexSta->highPriorityRx) <= 60)
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
}
} else {
if (pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) {
halbtc8723b1ant_ActionWifiConnectedBtAclBusy(
pBtCoexist,
BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
);
} else if (
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
) {
halbtc8723b1ant_ActionBtScoHidOnlyBusy(
pBtCoexist,
BT_8723B_1ANT_WIFI_STATUS_CONNECTED_BUSY
);
} else {
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 8);
if ((pCoexSta->highPriorityTx) + (pCoexSta->highPriorityRx) <= 60)
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
}
}
}
static void halbtc8723b1ant_RunSwCoexistMechanism(struct btc_coexist *pBtCoexist)
{
u8 algorithm = 0;
algorithm = halbtc8723b1ant_ActionAlgorithm(pBtCoexist);
pCoexDm->curAlgorithm = algorithm;
if (halbtc8723b1ant_IsCommonAction(pBtCoexist)) {
} else {
switch (pCoexDm->curAlgorithm) {
case BT_8723B_1ANT_COEX_ALGO_SCO:
/* halbtc8723b1ant_ActionSco(pBtCoexist); */
break;
case BT_8723B_1ANT_COEX_ALGO_HID:
/* halbtc8723b1ant_ActionHid(pBtCoexist); */
break;
case BT_8723B_1ANT_COEX_ALGO_A2DP:
/* halbtc8723b1ant_ActionA2dp(pBtCoexist); */
break;
case BT_8723B_1ANT_COEX_ALGO_A2DP_PANHS:
/* halbtc8723b1ant_ActionA2dpPanHs(pBtCoexist); */
break;
case BT_8723B_1ANT_COEX_ALGO_PANEDR:
/* halbtc8723b1ant_ActionPanEdr(pBtCoexist); */
break;
case BT_8723B_1ANT_COEX_ALGO_PANHS:
/* halbtc8723b1ant_ActionPanHs(pBtCoexist); */
break;
case BT_8723B_1ANT_COEX_ALGO_PANEDR_A2DP:
/* halbtc8723b1ant_ActionPanEdrA2dp(pBtCoexist); */
break;
case BT_8723B_1ANT_COEX_ALGO_PANEDR_HID:
/* halbtc8723b1ant_ActionPanEdrHid(pBtCoexist); */
break;
case BT_8723B_1ANT_COEX_ALGO_HID_A2DP_PANEDR:
/* halbtc8723b1ant_ActionHidA2dpPanEdr(pBtCoexist); */
break;
case BT_8723B_1ANT_COEX_ALGO_HID_A2DP:
/* halbtc8723b1ant_ActionHidA2dp(pBtCoexist); */
break;
default:
break;
}
pCoexDm->preAlgorithm = pCoexDm->curAlgorithm;
}
}
static void halbtc8723b1ant_RunCoexistMechanism(struct btc_coexist *pBtCoexist)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
bool bWifiConnected = false, bBtHsOn = false;
bool bIncreaseScanDevNum = false;
bool bBtCtrlAggBufSize = false;
u8 aggBufSize = 5;
u32 wifiLinkStatus = 0;
u32 numOfWifiLink = 0;
if (pBtCoexist->bManualControl)
return;
if (pBtCoexist->bStopCoexDm)
return;
if (pCoexSta->bUnderIps)
return;
if (
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
){
bIncreaseScanDevNum = true;
}
pBtCoexist->fBtcSet(
pBtCoexist,
BTC_SET_BL_INC_SCAN_DEV_NUM,
&bIncreaseScanDevNum
);
pBtCoexist->fBtcGet(
pBtCoexist,
BTC_GET_BL_WIFI_CONNECTED,
&bWifiConnected
);
pBtCoexist->fBtcGet(
pBtCoexist,
BTC_GET_U4_WIFI_LINK_STATUS,
&wifiLinkStatus
);
numOfWifiLink = wifiLinkStatus >> 16;
if ((numOfWifiLink >= 2) || (wifiLinkStatus & WIFI_P2P_GO_CONNECTED)) {
halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize);
if ((pBtLinkInfo->bA2dpExist) && (pCoexSta->bC2hBtInquiryPage))
halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
else
halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
return;
}
if ((pBtLinkInfo->bBtLinkExist) && (bWifiConnected)) {
halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 1, 1, 0, 1);
if (pBtLinkInfo->bScoExist)
halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, true, 0x5);
else
halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, true, 0x8);
halbtc8723b1ant_SwMechanism(pBtCoexist, true);
halbtc8723b1ant_RunSwCoexistMechanism(pBtCoexist); /* just print debug message */
} else {
halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x5);
halbtc8723b1ant_SwMechanism(pBtCoexist, false);
halbtc8723b1ant_RunSwCoexistMechanism(pBtCoexist); /* just print debug message */
}
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
if (pCoexSta->bC2hBtInquiryPage) {
halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
return;
} else if (bBtHsOn) {
halbtc8723b1ant_ActionHs(pBtCoexist);
return;
}
if (!bWifiConnected) {
bool bScan = false, bLink = false, bRoam = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
if (bScan || bLink || bRoam) {
if (bScan)
halbtc8723b1ant_ActionWifiNotConnectedScan(pBtCoexist);
else
halbtc8723b1ant_ActionWifiNotConnectedAssoAuth(pBtCoexist);
} else
halbtc8723b1ant_ActionWifiNotConnected(pBtCoexist);
} else /* wifi LPS/Busy */
halbtc8723b1ant_ActionWifiConnected(pBtCoexist);
}
static void halbtc8723b1ant_InitCoexDm(struct btc_coexist *pBtCoexist)
{
/* force to reset coex mechanism */
/* sw all off */
halbtc8723b1ant_SwMechanism(pBtCoexist, false);
/* halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 8); */
halbtc8723b1ant_CoexTableWithType(pBtCoexist, FORCE_EXEC, 0);
pCoexSta->popEventCnt = 0;
}
static void halbtc8723b1ant_InitHwConfig(
struct btc_coexist *pBtCoexist,
bool bBackUp,
bool bWifiOnly
)
{
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x550, 0x8, 0x1); /* enable TBTT nterrupt */
/* 0x790[5:0]= 0x5 */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x790, 0x5);
/* Enable counter statistics */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x778, 0x1);
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x40, 0x20, 0x1);
/* Antenna config */
if (bWifiOnly) {
halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_WIFI, true, false);
halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 9);
} else
halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, true, false);
/* PTA parameter */
halbtc8723b1ant_CoexTableWithType(pBtCoexist, FORCE_EXEC, 0);
pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765);
pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x67);
}
/* */
/* work around function start with wa_halbtc8723b1ant_ */
/* */
/* */
/* extern function start with EXhalbtc8723b1ant_ */
/* */
void EXhalbtc8723b1ant_PowerOnSetting(struct btc_coexist *pBtCoexist)
{
struct btc_board_info *pBoardInfo = &pBtCoexist->boardInfo;
u8 u1Tmp = 0x0;
u16 u2Tmp = 0x0;
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x67, 0x20);
/* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
u2Tmp = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0x2);
pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x2, u2Tmp | BIT0 | BIT1);
/* set GRAN_BT = 1 */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
/* set WLAN_ACT = 0 */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
/* */
/* S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
/* Local setting bit define */
/* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
/* BIT1: "0" for internal switch; "1" for external switch */
/* BIT2: "0" for one antenna; "1" for two antenna */
/* NOTE: here default all internal switch and 1-antenna ==> BIT1 = 0 and BIT2 = 0 */
if (pBtCoexist->chipInterface == BTC_INTF_USB) {
/* fixed at S0 for USB interface */
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
u1Tmp |= 0x1; /* antenna inverse */
pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0xfe08, u1Tmp);
pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
} else {
/* for PCIE and SDIO interface, we check efuse 0xc3[6] */
if (pBoardInfo->singleAntPath == 0) {
/* set to S1 */
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
} else if (pBoardInfo->singleAntPath == 1) {
/* set to S0 */
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
u1Tmp |= 0x1; /* antenna inverse */
pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
}
if (pBtCoexist->chipInterface == BTC_INTF_PCI)
pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x384, u1Tmp);
else if (pBtCoexist->chipInterface == BTC_INTF_SDIO)
pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x60, u1Tmp);
}
}
void EXhalbtc8723b1ant_InitHwConfig(struct btc_coexist *pBtCoexist, bool bWifiOnly)
{
halbtc8723b1ant_InitHwConfig(pBtCoexist, true, bWifiOnly);
}
void EXhalbtc8723b1ant_InitCoexDm(struct btc_coexist *pBtCoexist)
{
pBtCoexist->bStopCoexDm = false;
halbtc8723b1ant_InitCoexDm(pBtCoexist);
halbtc8723b1ant_QueryBtInfo(pBtCoexist);
}
void EXhalbtc8723b1ant_IpsNotify(struct btc_coexist *pBtCoexist, u8 type)
{
if (pBtCoexist->bManualControl || pBtCoexist->bStopCoexDm)
return;
if (type == BTC_IPS_ENTER) {
pCoexSta->bUnderIps = true;
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, false, true);
} else if (type == BTC_IPS_LEAVE) {
pCoexSta->bUnderIps = false;
halbtc8723b1ant_InitHwConfig(pBtCoexist, false, false);
halbtc8723b1ant_InitCoexDm(pBtCoexist);
halbtc8723b1ant_QueryBtInfo(pBtCoexist);
}
}
void EXhalbtc8723b1ant_LpsNotify(struct btc_coexist *pBtCoexist, u8 type)
{
if (pBtCoexist->bManualControl || pBtCoexist->bStopCoexDm)
return;
if (type == BTC_LPS_ENABLE)
pCoexSta->bUnderLps = true;
else if (type == BTC_LPS_DISABLE)
pCoexSta->bUnderLps = false;
}
void EXhalbtc8723b1ant_ScanNotify(struct btc_coexist *pBtCoexist, u8 type)
{
bool bWifiConnected = false, bBtHsOn = false;
u32 wifiLinkStatus = 0;
u32 numOfWifiLink = 0;
bool bBtCtrlAggBufSize = false;
u8 aggBufSize = 5;
if (pBtCoexist->bManualControl || pBtCoexist->bStopCoexDm)
return;
if (type == BTC_SCAN_START) {
pCoexSta->bWiFiIsHighPriTask = true;
halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 8); /* Force antenna setup for no scan result issue */
pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x765);
pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x67);
} else {
pCoexSta->bWiFiIsHighPriTask = false;
pBtCoexist->fBtcGet(
pBtCoexist, BTC_GET_U1_AP_NUM, &pCoexSta->nScanAPNum
);
}
if (pBtCoexist->btInfo.bBtDisabled)
return;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
halbtc8723b1ant_QueryBtInfo(pBtCoexist);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_LINK_STATUS, &wifiLinkStatus);
numOfWifiLink = wifiLinkStatus >> 16;
if (numOfWifiLink >= 2) {
halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
halbtc8723b1ant_LimitedRx(
pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize
);
halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
return;
}
if (pCoexSta->bC2hBtInquiryPage) {
halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
return;
} else if (bBtHsOn) {
halbtc8723b1ant_ActionHs(pBtCoexist);
return;
}
if (type == BTC_SCAN_START) {
if (!bWifiConnected) /* non-connected scan */
halbtc8723b1ant_ActionWifiNotConnectedScan(pBtCoexist);
else /* wifi is connected */
halbtc8723b1ant_ActionWifiConnectedScan(pBtCoexist);
} else if (type == BTC_SCAN_FINISH) {
if (!bWifiConnected) /* non-connected scan */
halbtc8723b1ant_ActionWifiNotConnected(pBtCoexist);
else
halbtc8723b1ant_ActionWifiConnected(pBtCoexist);
}
}
void EXhalbtc8723b1ant_ConnectNotify(struct btc_coexist *pBtCoexist, u8 type)
{
bool bWifiConnected = false, bBtHsOn = false;
u32 wifiLinkStatus = 0;
u32 numOfWifiLink = 0;
bool bBtCtrlAggBufSize = false;
u8 aggBufSize = 5;
if (
pBtCoexist->bManualControl ||
pBtCoexist->bStopCoexDm ||
pBtCoexist->btInfo.bBtDisabled
)
return;
if (type == BTC_ASSOCIATE_START) {
pCoexSta->bWiFiIsHighPriTask = true;
pCoexDm->nArpCnt = 0;
} else {
pCoexSta->bWiFiIsHighPriTask = false;
/* pCoexDm->nArpCnt = 0; */
}
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_LINK_STATUS, &wifiLinkStatus);
numOfWifiLink = wifiLinkStatus >> 16;
if (numOfWifiLink >= 2) {
halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
halbtc8723b1ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize);
halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
return;
}
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
if (pCoexSta->bC2hBtInquiryPage) {
halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
return;
} else if (bBtHsOn) {
halbtc8723b1ant_ActionHs(pBtCoexist);
return;
}
if (type == BTC_ASSOCIATE_START) {
halbtc8723b1ant_ActionWifiNotConnectedAssoAuth(pBtCoexist);
} else if (type == BTC_ASSOCIATE_FINISH) {
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
if (!bWifiConnected) /* non-connected scan */
halbtc8723b1ant_ActionWifiNotConnected(pBtCoexist);
else
halbtc8723b1ant_ActionWifiConnected(pBtCoexist);
}
}
void EXhalbtc8723b1ant_MediaStatusNotify(struct btc_coexist *pBtCoexist, u8 type)
{
u8 H2C_Parameter[3] = {0};
u32 wifiBw;
u8 wifiCentralChnl;
bool bWifiUnderBMode = false;
if (
pBtCoexist->bManualControl ||
pBtCoexist->bStopCoexDm ||
pBtCoexist->btInfo.bBtDisabled
)
return;
if (type == BTC_MEDIA_CONNECT) {
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_UNDER_B_MODE, &bWifiUnderBMode);
/* Set CCK Tx/Rx high Pri except 11b mode */
if (bWifiUnderBMode) {
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cd, 0x00); /* CCK Tx */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cf, 0x00); /* CCK Rx */
} else {
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cd, 0x10); /* CCK Tx */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cf, 0x10); /* CCK Rx */
}
pCoexDm->backupArfrCnt1 = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x430);
pCoexDm->backupArfrCnt2 = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x434);
pCoexDm->backupRetryLimit = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0x42a);
pCoexDm->backupAmpduMaxTime = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x456);
} else {
pCoexDm->nArpCnt = 0;
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cd, 0x0); /* CCK Tx */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cf, 0x0); /* CCK Rx */
}
/* only 2.4G we need to inform bt the chnl mask */
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifiCentralChnl);
if ((type == BTC_MEDIA_CONNECT) && (wifiCentralChnl <= 14)) {
/* H2C_Parameter[0] = 0x1; */
H2C_Parameter[0] = 0x0;
H2C_Parameter[1] = wifiCentralChnl;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (wifiBw == BTC_WIFI_BW_HT40)
H2C_Parameter[2] = 0x30;
else
H2C_Parameter[2] = 0x20;
}
pCoexDm->wifiChnlInfo[0] = H2C_Parameter[0];
pCoexDm->wifiChnlInfo[1] = H2C_Parameter[1];
pCoexDm->wifiChnlInfo[2] = H2C_Parameter[2];
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x66, 3, H2C_Parameter);
}
void EXhalbtc8723b1ant_SpecialPacketNotify(struct btc_coexist *pBtCoexist, u8 type)
{
bool bBtHsOn = false;
u32 wifiLinkStatus = 0;
u32 numOfWifiLink = 0;
bool bBtCtrlAggBufSize = false;
u8 aggBufSize = 5;
if (
pBtCoexist->bManualControl ||
pBtCoexist->bStopCoexDm ||
pBtCoexist->btInfo.bBtDisabled
)
return;
if (
type == BTC_PACKET_DHCP ||
type == BTC_PACKET_EAPOL ||
type == BTC_PACKET_ARP
) {
if (type == BTC_PACKET_ARP) {
pCoexDm->nArpCnt++;
if (pCoexDm->nArpCnt >= 10) /* if APR PKT > 10 after connect, do not go to ActionWifiConnectedSpecialPacket(pBtCoexist) */
pCoexSta->bWiFiIsHighPriTask = false;
else
pCoexSta->bWiFiIsHighPriTask = true;
} else {
pCoexSta->bWiFiIsHighPriTask = true;
}
} else {
pCoexSta->bWiFiIsHighPriTask = false;
}
pCoexSta->specialPktPeriodCnt = 0;
pBtCoexist->fBtcGet(
pBtCoexist, BTC_GET_U4_WIFI_LINK_STATUS, &wifiLinkStatus
);
numOfWifiLink = wifiLinkStatus >> 16;
if (numOfWifiLink >= 2) {
halbtc8723b1ant_LimitedTx(pBtCoexist, NORMAL_EXEC, 0, 0, 0, 0);
halbtc8723b1ant_LimitedRx(
pBtCoexist, NORMAL_EXEC, false, bBtCtrlAggBufSize, aggBufSize
);
halbtc8723b1ant_ActionWifiMultiPort(pBtCoexist);
return;
}
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
if (pCoexSta->bC2hBtInquiryPage) {
halbtc8723b1ant_ActionBtInquiry(pBtCoexist);
return;
} else if (bBtHsOn) {
halbtc8723b1ant_ActionHs(pBtCoexist);
return;
}
if (
type == BTC_PACKET_DHCP ||
type == BTC_PACKET_EAPOL ||
((type == BTC_PACKET_ARP) && (pCoexSta->bWiFiIsHighPriTask))
)
halbtc8723b1ant_ActionWifiConnectedSpecialPacket(pBtCoexist);
}
void EXhalbtc8723b1ant_BtInfoNotify(
struct btc_coexist *pBtCoexist, u8 *tmpBuf, u8 length
)
{
u8 btInfo = 0;
u8 i, rspSource = 0;
bool bWifiConnected = false;
bool bBtBusy = false;
pCoexSta->bC2hBtInfoReqSent = false;
rspSource = tmpBuf[0] & 0xf;
if (rspSource >= BT_INFO_SRC_8723B_1ANT_MAX)
rspSource = BT_INFO_SRC_8723B_1ANT_WIFI_FW;
pCoexSta->btInfoC2hCnt[rspSource]++;
for (i = 0; i < length; i++) {
pCoexSta->btInfoC2h[rspSource][i] = tmpBuf[i];
if (i == 1)
btInfo = tmpBuf[i];
}
if (rspSource != BT_INFO_SRC_8723B_1ANT_WIFI_FW) {
pCoexSta->btRetryCnt = pCoexSta->btInfoC2h[rspSource][2] & 0xf;
if (pCoexSta->btRetryCnt >= 1)
pCoexSta->popEventCnt++;
if (pCoexSta->btInfoC2h[rspSource][2] & 0x20)
pCoexSta->bC2hBtPage = true;
else
pCoexSta->bC2hBtPage = false;
pCoexSta->btRssi = pCoexSta->btInfoC2h[rspSource][3] * 2 - 90;
/* pCoexSta->btInfoC2h[rspSource][3]*2+10; */
pCoexSta->btInfoExt = pCoexSta->btInfoC2h[rspSource][4];
pCoexSta->bBtTxRxMask = (pCoexSta->btInfoC2h[rspSource][2] & 0x40);
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TX_RX_MASK, &pCoexSta->bBtTxRxMask);
if (!pCoexSta->bBtTxRxMask) {
/* BT into is responded by BT FW and BT RF REG 0x3C != 0x15 => Need to switch BT TRx Mask */
pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15);
}
/* Here we need to resend some wifi info to BT */
/* because bt is reset and loss of the info. */
if (pCoexSta->btInfoExt & BIT1) {
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
if (bWifiConnected)
EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_CONNECT);
else
EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
}
if (pCoexSta->btInfoExt & BIT3) {
if (!pBtCoexist->bManualControl && !pBtCoexist->bStopCoexDm)
halbtc8723b1ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, false);
} else {
/* BT already NOT ignore Wlan active, do nothing here. */
}
}
/* check BIT2 first ==> check if bt is under inquiry or page scan */
if (btInfo & BT_INFO_8723B_1ANT_B_INQ_PAGE)
pCoexSta->bC2hBtInquiryPage = true;
else
pCoexSta->bC2hBtInquiryPage = false;
/* set link exist status */
if (!(btInfo & BT_INFO_8723B_1ANT_B_CONNECTION)) {
pCoexSta->bBtLinkExist = false;
pCoexSta->bPanExist = false;
pCoexSta->bA2dpExist = false;
pCoexSta->bHidExist = false;
pCoexSta->bScoExist = false;
} else { /* connection exists */
pCoexSta->bBtLinkExist = true;
if (btInfo & BT_INFO_8723B_1ANT_B_FTP)
pCoexSta->bPanExist = true;
else
pCoexSta->bPanExist = false;
if (btInfo & BT_INFO_8723B_1ANT_B_A2DP)
pCoexSta->bA2dpExist = true;
else
pCoexSta->bA2dpExist = false;
if (btInfo & BT_INFO_8723B_1ANT_B_HID)
pCoexSta->bHidExist = true;
else
pCoexSta->bHidExist = false;
if (btInfo & BT_INFO_8723B_1ANT_B_SCO_ESCO)
pCoexSta->bScoExist = true;
else
pCoexSta->bScoExist = false;
}
halbtc8723b1ant_UpdateBtLinkInfo(pBtCoexist);
btInfo = btInfo & 0x1f; /* mask profile bit for connect-ilde identification (for CSR case: A2DP idle --> 0x41) */
if (!(btInfo & BT_INFO_8723B_1ANT_B_CONNECTION)) {
pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_NON_CONNECTED_IDLE;
} else if (btInfo == BT_INFO_8723B_1ANT_B_CONNECTION) {
/* connection exists but no busy */
pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_CONNECTED_IDLE;
} else if (
(btInfo & BT_INFO_8723B_1ANT_B_SCO_ESCO) ||
(btInfo & BT_INFO_8723B_1ANT_B_SCO_BUSY)
) {
pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_SCO_BUSY;
} else if (btInfo & BT_INFO_8723B_1ANT_B_ACL_BUSY) {
if (pCoexDm->btStatus != BT_8723B_1ANT_BT_STATUS_ACL_BUSY)
pCoexDm->bAutoTdmaAdjust = false;
pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_ACL_BUSY;
} else {
pCoexDm->btStatus = BT_8723B_1ANT_BT_STATUS_MAX;
}
if (
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_BUSY) ||
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_SCO_BUSY) ||
(pCoexDm->btStatus == BT_8723B_1ANT_BT_STATUS_ACL_SCO_BUSY)
)
bBtBusy = true;
else
bBtBusy = false;
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bBtBusy);
halbtc8723b1ant_RunCoexistMechanism(pBtCoexist);
}
void EXhalbtc8723b1ant_HaltNotify(struct btc_coexist *pBtCoexist)
{
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
halbtc8723b1ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 0);
halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, false, true);
halbtc8723b1ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true);
EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
pBtCoexist->bStopCoexDm = true;
}
void EXhalbtc8723b1ant_PnpNotify(struct btc_coexist *pBtCoexist, u8 pnpState)
{
if (pnpState == BTC_WIFI_PNP_SLEEP) {
halbtc8723b1ant_PowerSaveState(pBtCoexist, BTC_PS_WIFI_NATIVE, 0x0, 0x0);
halbtc8723b1ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0);
halbtc8723b1ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
halbtc8723b1ant_SetAntPath(pBtCoexist, BTC_ANT_PATH_BT, false, true);
pBtCoexist->bStopCoexDm = true;
} else if (pnpState == BTC_WIFI_PNP_WAKE_UP) {
pBtCoexist->bStopCoexDm = false;
halbtc8723b1ant_InitHwConfig(pBtCoexist, false, false);
halbtc8723b1ant_InitCoexDm(pBtCoexist);
halbtc8723b1ant_QueryBtInfo(pBtCoexist);
}
}
void EXhalbtc8723b1ant_Periodical(struct btc_coexist *pBtCoexist)
{
static u8 disVerInfoCnt;
u32 fwVer = 0, btPatchVer = 0;
if (disVerInfoCnt <= 5) {
disVerInfoCnt += 1;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_BT_PATCH_VER, &btPatchVer);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
}
halbtc8723b1ant_MonitorBtCtr(pBtCoexist);
halbtc8723b1ant_MonitorWiFiCtr(pBtCoexist);
if (
halbtc8723b1ant_IsWifiStatusChanged(pBtCoexist) ||
pCoexDm->bAutoTdmaAdjust
)
halbtc8723b1ant_RunCoexistMechanism(pBtCoexist);
pCoexSta->specialPktPeriodCnt++;
}
| linux-master | drivers/staging/rtl8723bs/hal/HalBtc8723b1Ant.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
/* include "Mp_Precomp.h" */
#include "odm_precomp.h"
void ConfigureTxpowerTrack(struct dm_odm_t *pDM_Odm, struct txpwrtrack_cfg *pConfig)
{
ConfigureTxpowerTrack_8723B(pConfig);
}
/* */
/* <20121113, Kordan> This function should be called when TxAGC changed. */
/* Otherwise the previous compensation is gone, because we record the */
/* delta of temperature between two TxPowerTracking watch dogs. */
/* */
/* NOTE: If Tx BB swing or Tx scaling is varified during run-time, still */
/* need to call this function. */
/* */
void ODM_ClearTxPowerTrackingState(struct dm_odm_t *pDM_Odm)
{
struct hal_com_data *pHalData = GET_HAL_DATA(pDM_Odm->Adapter);
u8 p = 0;
pDM_Odm->BbSwingIdxCckBase = pDM_Odm->DefaultCckIndex;
pDM_Odm->BbSwingIdxCck = pDM_Odm->DefaultCckIndex;
pDM_Odm->RFCalibrateInfo.CCK_index = 0;
for (p = RF_PATH_A; p < MAX_RF_PATH; ++p) {
pDM_Odm->BbSwingIdxOfdmBase[p] = pDM_Odm->DefaultOfdmIndex;
pDM_Odm->BbSwingIdxOfdm[p] = pDM_Odm->DefaultOfdmIndex;
pDM_Odm->RFCalibrateInfo.OFDM_index[p] = pDM_Odm->DefaultOfdmIndex;
pDM_Odm->RFCalibrateInfo.PowerIndexOffset[p] = 0;
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[p] = 0;
pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast[p] = 0;
pDM_Odm->RFCalibrateInfo.PowerIndexOffset[p] = 0;
/* Initial Mix mode power tracking */
pDM_Odm->Absolute_OFDMSwingIdx[p] = 0;
pDM_Odm->Remnant_OFDMSwingIdx[p] = 0;
}
/* Initial at Modify Tx Scaling Mode */
pDM_Odm->Modify_TxAGC_Flag_PathA = false;
/* Initial at Modify Tx Scaling Mode */
pDM_Odm->Modify_TxAGC_Flag_PathB = false;
pDM_Odm->Remnant_CCKSwingIdx = 0;
pDM_Odm->RFCalibrateInfo.ThermalValue = pHalData->EEPROMThermalMeter;
pDM_Odm->RFCalibrateInfo.ThermalValue_IQK = pHalData->EEPROMThermalMeter;
pDM_Odm->RFCalibrateInfo.ThermalValue_LCK = pHalData->EEPROMThermalMeter;
}
void ODM_TXPowerTrackingCallback_ThermalMeter(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
u8 ThermalValue = 0, delta, delta_LCK, p = 0, i = 0;
u8 ThermalValue_AVG_count = 0;
u32 ThermalValue_AVG = 0;
u8 OFDM_min_index = 0; /* OFDM BB Swing should be less than +3.0dB, which is required by Arthur */
u8 Indexforchannel = 0; /* GetRightChnlPlaceforIQK(pHalData->CurrentChannel) */
struct txpwrtrack_cfg c;
/* 4 1. The following TWO tables decide the final index of OFDM/CCK swing table. */
u8 *deltaSwingTableIdx_TUP_A;
u8 *deltaSwingTableIdx_TDOWN_A;
u8 *deltaSwingTableIdx_TUP_B;
u8 *deltaSwingTableIdx_TDOWN_B;
/* 4 2. Initialization (7 steps in total) */
ConfigureTxpowerTrack(pDM_Odm, &c);
(*c.GetDeltaSwingTable)(
pDM_Odm,
(u8 **)&deltaSwingTableIdx_TUP_A,
(u8 **)&deltaSwingTableIdx_TDOWN_A,
(u8 **)&deltaSwingTableIdx_TUP_B,
(u8 **)&deltaSwingTableIdx_TDOWN_B
);
/* cosa add for debug */
pDM_Odm->RFCalibrateInfo.TXPowerTrackingCallbackCnt++;
pDM_Odm->RFCalibrateInfo.bTXPowerTrackingInit = true;
ThermalValue = (u8)PHY_QueryRFReg(pDM_Odm->Adapter, RF_PATH_A, c.ThermalRegAddr, 0xfc00); /* 0x42: RF Reg[15:10] 88E */
if (
!pDM_Odm->RFCalibrateInfo.TxPowerTrackControl ||
pHalData->EEPROMThermalMeter == 0 ||
pHalData->EEPROMThermalMeter == 0xFF
)
return;
/* 4 3. Initialize ThermalValues of RFCalibrateInfo */
/* 4 4. Calculate average thermal meter */
pDM_Odm->RFCalibrateInfo.ThermalValue_AVG[pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index] = ThermalValue;
pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index++;
if (pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index == c.AverageThermalNum) /* Average times = c.AverageThermalNum */
pDM_Odm->RFCalibrateInfo.ThermalValue_AVG_index = 0;
for (i = 0; i < c.AverageThermalNum; i++) {
if (pDM_Odm->RFCalibrateInfo.ThermalValue_AVG[i]) {
ThermalValue_AVG += pDM_Odm->RFCalibrateInfo.ThermalValue_AVG[i];
ThermalValue_AVG_count++;
}
}
/* Calculate Average ThermalValue after average enough times */
if (ThermalValue_AVG_count) {
ThermalValue = (u8)(ThermalValue_AVG / ThermalValue_AVG_count);
}
/* 4 5. Calculate delta, delta_LCK */
/* delta" here is used to determine whether thermal value changes or not. */
delta =
(ThermalValue > pDM_Odm->RFCalibrateInfo.ThermalValue) ?
(ThermalValue - pDM_Odm->RFCalibrateInfo.ThermalValue) :
(pDM_Odm->RFCalibrateInfo.ThermalValue - ThermalValue);
delta_LCK =
(ThermalValue > pDM_Odm->RFCalibrateInfo.ThermalValue_LCK) ?
(ThermalValue - pDM_Odm->RFCalibrateInfo.ThermalValue_LCK) :
(pDM_Odm->RFCalibrateInfo.ThermalValue_LCK - ThermalValue);
/* 4 6. If necessary, do LCK. */
/* Delta temperature is equal to or larger than 20 centigrade. */
if (delta_LCK >= c.Threshold_IQK) {
pDM_Odm->RFCalibrateInfo.ThermalValue_LCK = ThermalValue;
if (c.PHY_LCCalibrate)
(*c.PHY_LCCalibrate)(pDM_Odm);
}
/* 3 7. If necessary, move the index of swing table to adjust Tx power. */
if (delta > 0 && pDM_Odm->RFCalibrateInfo.TxPowerTrackControl) {
/* delta" here is used to record the absolute value of difference. */
delta =
ThermalValue > pHalData->EEPROMThermalMeter ?
(ThermalValue - pHalData->EEPROMThermalMeter) :
(pHalData->EEPROMThermalMeter - ThermalValue);
if (delta >= TXPWR_TRACK_TABLE_SIZE)
delta = TXPWR_TRACK_TABLE_SIZE - 1;
/* 4 7.1 The Final Power Index = BaseIndex + PowerIndexOffset */
if (ThermalValue > pHalData->EEPROMThermalMeter) {
pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast[RF_PATH_A] =
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[RF_PATH_A];
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[RF_PATH_A] =
deltaSwingTableIdx_TUP_A[delta];
/* Record delta swing for mix mode power tracking */
pDM_Odm->Absolute_OFDMSwingIdx[RF_PATH_A] =
deltaSwingTableIdx_TUP_A[delta];
if (c.RfPathCount > 1) {
pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast[RF_PATH_B] =
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[RF_PATH_B];
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[RF_PATH_B] =
deltaSwingTableIdx_TUP_B[delta];
/* Record delta swing for mix mode power tracking */
pDM_Odm->Absolute_OFDMSwingIdx[RF_PATH_B] =
deltaSwingTableIdx_TUP_B[delta];
}
} else {
pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast[RF_PATH_A] =
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[RF_PATH_A];
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[RF_PATH_A] =
-1 * deltaSwingTableIdx_TDOWN_A[delta];
/* Record delta swing for mix mode power tracking */
pDM_Odm->Absolute_OFDMSwingIdx[RF_PATH_A] =
-1 * deltaSwingTableIdx_TDOWN_A[delta];
if (c.RfPathCount > 1) {
pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast[RF_PATH_B] =
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[RF_PATH_B];
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[RF_PATH_B] =
-1 * deltaSwingTableIdx_TDOWN_B[delta];
/* Record delta swing for mix mode power tracking */
pDM_Odm->Absolute_OFDMSwingIdx[RF_PATH_B] =
-1 * deltaSwingTableIdx_TDOWN_B[delta];
}
}
for (p = RF_PATH_A; p < c.RfPathCount; p++) {
if (
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[p] ==
pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast[p]
) /* If Thermal value changes but lookup table value still the same */
pDM_Odm->RFCalibrateInfo.PowerIndexOffset[p] = 0;
else
pDM_Odm->RFCalibrateInfo.PowerIndexOffset[p] = pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[p] - pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast[p]; /* Power Index Diff between 2 times Power Tracking */
pDM_Odm->RFCalibrateInfo.OFDM_index[p] =
pDM_Odm->BbSwingIdxOfdmBase[p] +
pDM_Odm->RFCalibrateInfo.PowerIndexOffset[p];
pDM_Odm->RFCalibrateInfo.CCK_index =
pDM_Odm->BbSwingIdxCckBase +
pDM_Odm->RFCalibrateInfo.PowerIndexOffset[p];
pDM_Odm->BbSwingIdxCck =
pDM_Odm->RFCalibrateInfo.CCK_index;
pDM_Odm->BbSwingIdxOfdm[p] =
pDM_Odm->RFCalibrateInfo.OFDM_index[p];
/* 4 7.1 Handle boundary conditions of index. */
if (pDM_Odm->RFCalibrateInfo.OFDM_index[p] > c.SwingTableSize_OFDM-1)
pDM_Odm->RFCalibrateInfo.OFDM_index[p] = c.SwingTableSize_OFDM-1;
else if (pDM_Odm->RFCalibrateInfo.OFDM_index[p] < OFDM_min_index)
pDM_Odm->RFCalibrateInfo.OFDM_index[p] = OFDM_min_index;
}
if (pDM_Odm->RFCalibrateInfo.CCK_index > c.SwingTableSize_CCK-1)
pDM_Odm->RFCalibrateInfo.CCK_index = c.SwingTableSize_CCK-1;
/* else if (pDM_Odm->RFCalibrateInfo.CCK_index < 0) */
/* pDM_Odm->RFCalibrateInfo.CCK_index = 0; */
} else {
for (p = RF_PATH_A; p < c.RfPathCount; p++)
pDM_Odm->RFCalibrateInfo.PowerIndexOffset[p] = 0;
}
/* Print Swing base & current */
for (p = RF_PATH_A; p < c.RfPathCount; p++) {
}
if (
(pDM_Odm->RFCalibrateInfo.PowerIndexOffset[RF_PATH_A] != 0 ||
pDM_Odm->RFCalibrateInfo.PowerIndexOffset[RF_PATH_B] != 0) &&
pDM_Odm->RFCalibrateInfo.TxPowerTrackControl
) {
/* 4 7.2 Configure the Swing Table to adjust Tx Power. */
pDM_Odm->RFCalibrateInfo.bTxPowerChanged = true; /* Always true after Tx Power is adjusted by power tracking. */
/* */
/* 2012/04/23 MH According to Luke's suggestion, we can not write BB digital */
/* to increase TX power. Otherwise, EVM will be bad. */
/* */
/* 2012/04/25 MH Add for tx power tracking to set tx power in tx agc for 88E. */
if (ThermalValue > pHalData->EEPROMThermalMeter) {
for (p = RF_PATH_A; p < c.RfPathCount; p++)
(*c.ODM_TxPwrTrackSetPwr)(pDM_Odm, MIX_MODE, p, 0);
} else {
for (p = RF_PATH_A; p < c.RfPathCount; p++)
(*c.ODM_TxPwrTrackSetPwr)(pDM_Odm, MIX_MODE, p, Indexforchannel);
}
/* Record last time Power Tracking result as base. */
pDM_Odm->BbSwingIdxCckBase = pDM_Odm->BbSwingIdxCck;
for (p = RF_PATH_A; p < c.RfPathCount; p++)
pDM_Odm->BbSwingIdxOfdmBase[p] = pDM_Odm->BbSwingIdxOfdm[p];
/* Record last Power Tracking Thermal Value */
pDM_Odm->RFCalibrateInfo.ThermalValue = ThermalValue;
}
pDM_Odm->RFCalibrateInfo.TXPowercount = 0;
}
| linux-master | drivers/staging/rtl8723bs/hal/HalPhyRf.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtl8723b_hal.h>
#include "hal_com_h2c.h"
#define MAX_H2C_BOX_NUMS 4
#define MESSAGE_BOX_SIZE 4
#define RTL8723B_MAX_CMD_LEN 7
#define RTL8723B_EX_MESSAGE_BOX_SIZE 4
static u8 _is_fw_read_cmd_down(struct adapter *padapter, u8 msgbox_num)
{
u8 read_down = false;
int retry_cnts = 100;
u8 valid;
do {
valid = rtw_read8(padapter, REG_HMETFR) & BIT(msgbox_num);
if (0 == valid) {
read_down = true;
}
} while ((!read_down) && (retry_cnts--));
return read_down;
}
/*****************************************
* H2C Msg format :
*| 31 - 8 |7-5 | 4 - 0 |
*| h2c_msg |Class |CMD_ID |
*| 31-0 |
*| Ext msg |
*
******************************************/
s32 FillH2CCmd8723B(struct adapter *padapter, u8 ElementID, u32 CmdLen, u8 *pCmdBuffer)
{
u8 h2c_box_num;
u32 msgbox_addr;
u32 msgbox_ex_addr = 0;
struct hal_com_data *pHalData;
u32 h2c_cmd = 0;
u32 h2c_cmd_ex = 0;
s32 ret = _FAIL;
padapter = GET_PRIMARY_ADAPTER(padapter);
pHalData = GET_HAL_DATA(padapter);
if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->h2c_fwcmd_mutex)))
return ret;
if (!pCmdBuffer) {
goto exit;
}
if (CmdLen > RTL8723B_MAX_CMD_LEN) {
goto exit;
}
if (padapter->bSurpriseRemoved)
goto exit;
/* pay attention to if race condition happened in H2C cmd setting. */
do {
h2c_box_num = pHalData->LastHMEBoxNum;
if (!_is_fw_read_cmd_down(padapter, h2c_box_num))
goto exit;
if (CmdLen <= 3)
memcpy((u8 *)(&h2c_cmd)+1, pCmdBuffer, CmdLen);
else {
memcpy((u8 *)(&h2c_cmd)+1, pCmdBuffer, 3);
memcpy((u8 *)(&h2c_cmd_ex), pCmdBuffer+3, CmdLen-3);
/* *(u8 *)(&h2c_cmd) |= BIT(7); */
}
*(u8 *)(&h2c_cmd) |= ElementID;
if (CmdLen > 3) {
msgbox_ex_addr = REG_HMEBOX_EXT0_8723B + (h2c_box_num*RTL8723B_EX_MESSAGE_BOX_SIZE);
rtw_write32(padapter, msgbox_ex_addr, h2c_cmd_ex);
}
msgbox_addr = REG_HMEBOX_0 + (h2c_box_num*MESSAGE_BOX_SIZE);
rtw_write32(padapter, msgbox_addr, h2c_cmd);
pHalData->LastHMEBoxNum = (h2c_box_num+1) % MAX_H2C_BOX_NUMS;
} while (0);
ret = _SUCCESS;
exit:
mutex_unlock(&(adapter_to_dvobj(padapter)->h2c_fwcmd_mutex));
return ret;
}
static void ConstructBeacon(struct adapter *padapter, u8 *pframe, u32 *pLength)
{
struct ieee80211_hdr *pwlanhdr;
__le16 *fctrl;
u32 rate_len, pktlen;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct wlan_bssid_ex *cur_network = &(pmlmeinfo->network);
pwlanhdr = (struct ieee80211_hdr *)pframe;
fctrl = &(pwlanhdr->frame_control);
*(fctrl) = 0;
eth_broadcast_addr(pwlanhdr->addr1);
memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
memcpy(pwlanhdr->addr3, get_my_bssid(cur_network), ETH_ALEN);
SetSeqNum(pwlanhdr, 0/*pmlmeext->mgnt_seq*/);
/* pmlmeext->mgnt_seq++; */
SetFrameSubType(pframe, WIFI_BEACON);
pframe += sizeof(struct ieee80211_hdr_3addr);
pktlen = sizeof(struct ieee80211_hdr_3addr);
/* timestamp will be inserted by hardware */
pframe += 8;
pktlen += 8;
/* beacon interval: 2 bytes */
memcpy(pframe, (unsigned char *)(rtw_get_beacon_interval_from_ie(cur_network->ies)), 2);
pframe += 2;
pktlen += 2;
/* capability info: 2 bytes */
memcpy(pframe, (unsigned char *)(rtw_get_capability_from_ie(cur_network->ies)), 2);
pframe += 2;
pktlen += 2;
if ((pmlmeinfo->state&0x03) == WIFI_FW_AP_STATE) {
pktlen += cur_network->ie_length - sizeof(struct ndis_802_11_fix_ie);
memcpy(pframe, cur_network->ies+sizeof(struct ndis_802_11_fix_ie), pktlen);
goto _ConstructBeacon;
}
/* below for ad-hoc mode */
/* SSID */
pframe = rtw_set_ie(pframe, WLAN_EID_SSID, cur_network->ssid.ssid_length, cur_network->ssid.ssid, &pktlen);
/* supported rates... */
rate_len = rtw_get_rateset_len(cur_network->supported_rates);
pframe = rtw_set_ie(pframe, WLAN_EID_SUPP_RATES, ((rate_len > 8) ? 8 : rate_len), cur_network->supported_rates, &pktlen);
/* DS parameter set */
pframe = rtw_set_ie(pframe, WLAN_EID_DS_PARAMS, 1, (unsigned char *)&(cur_network->configuration.ds_config), &pktlen);
if ((pmlmeinfo->state&0x03) == WIFI_FW_ADHOC_STATE) {
u32 ATIMWindow;
/* IBSS Parameter Set... */
/* ATIMWindow = cur->configuration.ATIMWindow; */
ATIMWindow = 0;
pframe = rtw_set_ie(pframe, WLAN_EID_IBSS_PARAMS, 2, (unsigned char *)(&ATIMWindow), &pktlen);
}
/* todo: ERP IE */
/* EXTERNDED SUPPORTED RATE */
if (rate_len > 8)
pframe = rtw_set_ie(pframe, WLAN_EID_EXT_SUPP_RATES, (rate_len - 8), (cur_network->supported_rates + 8), &pktlen);
/* todo:HT for adhoc */
_ConstructBeacon:
if ((pktlen + TXDESC_SIZE) > 512)
return;
*pLength = pktlen;
}
static void ConstructPSPoll(struct adapter *padapter, u8 *pframe, u32 *pLength)
{
struct ieee80211_hdr *pwlanhdr;
__le16 *fctrl;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
pwlanhdr = (struct ieee80211_hdr *)pframe;
/* Frame control. */
fctrl = &(pwlanhdr->frame_control);
*(fctrl) = 0;
SetPwrMgt(fctrl);
SetFrameSubType(pframe, WIFI_PSPOLL);
/* AID. */
SetDuration(pframe, (pmlmeinfo->aid | 0xc000));
/* BSSID. */
memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
/* TA. */
memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
*pLength = 16;
}
static void ConstructNullFunctionData(
struct adapter *padapter,
u8 *pframe,
u32 *pLength,
u8 *StaAddr,
u8 bQoS,
u8 AC,
u8 bEosp,
u8 bForcePowerSave
)
{
struct ieee80211_hdr *pwlanhdr;
__le16 *fctrl;
u32 pktlen;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *cur_network = &pmlmepriv->cur_network;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
pwlanhdr = (struct ieee80211_hdr *)pframe;
fctrl = &pwlanhdr->frame_control;
*(fctrl) = 0;
if (bForcePowerSave)
SetPwrMgt(fctrl);
switch (cur_network->network.infrastructure_mode) {
case Ndis802_11Infrastructure:
SetToDs(fctrl);
memcpy(pwlanhdr->addr1, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
memcpy(pwlanhdr->addr3, StaAddr, ETH_ALEN);
break;
case Ndis802_11APMode:
SetFrDs(fctrl);
memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
memcpy(pwlanhdr->addr2, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
memcpy(pwlanhdr->addr3, myid(&(padapter->eeprompriv)), ETH_ALEN);
break;
case Ndis802_11IBSS:
default:
memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
memcpy(pwlanhdr->addr2, myid(&(padapter->eeprompriv)), ETH_ALEN);
memcpy(pwlanhdr->addr3, get_my_bssid(&(pmlmeinfo->network)), ETH_ALEN);
break;
}
SetSeqNum(pwlanhdr, 0);
if (bQoS) {
struct ieee80211_qos_hdr *pwlanqoshdr;
SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
pwlanqoshdr = (struct ieee80211_qos_hdr *)pframe;
SetPriority(&pwlanqoshdr->qos_ctrl, AC);
SetEOSP(&pwlanqoshdr->qos_ctrl, bEosp);
pktlen = sizeof(struct ieee80211_qos_hdr);
} else {
SetFrameSubType(pframe, WIFI_DATA_NULL);
pktlen = sizeof(struct ieee80211_hdr_3addr);
}
*pLength = pktlen;
}
/*
* To check if reserved page content is destroyed by beacon because beacon
* is too large.
*/
/* 2010.06.23. Added by tynli. */
void CheckFwRsvdPageContent(struct adapter *Adapter)
{
}
static void rtl8723b_set_FwRsvdPage_cmd(struct adapter *padapter, struct rsvdpage_loc *rsvdpageloc)
{
u8 u1H2CRsvdPageParm[H2C_RSVDPAGE_LOC_LEN] = {0};
SET_8723B_H2CCMD_RSVDPAGE_LOC_PROBE_RSP(u1H2CRsvdPageParm, rsvdpageloc->LocProbeRsp);
SET_8723B_H2CCMD_RSVDPAGE_LOC_PSPOLL(u1H2CRsvdPageParm, rsvdpageloc->LocPsPoll);
SET_8723B_H2CCMD_RSVDPAGE_LOC_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocNullData);
SET_8723B_H2CCMD_RSVDPAGE_LOC_QOS_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocQosNull);
SET_8723B_H2CCMD_RSVDPAGE_LOC_BT_QOS_NULL_DATA(u1H2CRsvdPageParm, rsvdpageloc->LocBTQosNull);
FillH2CCmd8723B(padapter, H2C_8723B_RSVD_PAGE, H2C_RSVDPAGE_LOC_LEN, u1H2CRsvdPageParm);
}
static void rtl8723b_set_FwAoacRsvdPage_cmd(struct adapter *padapter, struct rsvdpage_loc *rsvdpageloc)
{
}
void rtl8723b_set_FwMediaStatusRpt_cmd(struct adapter *padapter, u8 mstatus, u8 macid)
{
u8 u1H2CMediaStatusRptParm[H2C_MEDIA_STATUS_RPT_LEN] = {0};
u8 macid_end = 0;
SET_8723B_H2CCMD_MSRRPT_PARM_OPMODE(u1H2CMediaStatusRptParm, mstatus);
SET_8723B_H2CCMD_MSRRPT_PARM_MACID_IND(u1H2CMediaStatusRptParm, 0);
SET_8723B_H2CCMD_MSRRPT_PARM_MACID(u1H2CMediaStatusRptParm, macid);
SET_8723B_H2CCMD_MSRRPT_PARM_MACID_END(u1H2CMediaStatusRptParm, macid_end);
FillH2CCmd8723B(padapter, H2C_8723B_MEDIA_STATUS_RPT, H2C_MEDIA_STATUS_RPT_LEN, u1H2CMediaStatusRptParm);
}
void rtl8723b_set_FwMacIdConfig_cmd(struct adapter *padapter, u8 mac_id, u8 raid, u8 bw, u8 sgi, u32 mask)
{
u8 u1H2CMacIdConfigParm[H2C_MACID_CFG_LEN] = {0};
SET_8723B_H2CCMD_MACID_CFG_MACID(u1H2CMacIdConfigParm, mac_id);
SET_8723B_H2CCMD_MACID_CFG_RAID(u1H2CMacIdConfigParm, raid);
SET_8723B_H2CCMD_MACID_CFG_SGI_EN(u1H2CMacIdConfigParm, sgi ? 1 : 0);
SET_8723B_H2CCMD_MACID_CFG_BW(u1H2CMacIdConfigParm, bw);
SET_8723B_H2CCMD_MACID_CFG_RATE_MASK0(u1H2CMacIdConfigParm, (u8)(mask & 0x000000ff));
SET_8723B_H2CCMD_MACID_CFG_RATE_MASK1(u1H2CMacIdConfigParm, (u8)((mask & 0x0000ff00) >> 8));
SET_8723B_H2CCMD_MACID_CFG_RATE_MASK2(u1H2CMacIdConfigParm, (u8)((mask & 0x00ff0000) >> 16));
SET_8723B_H2CCMD_MACID_CFG_RATE_MASK3(u1H2CMacIdConfigParm, (u8)((mask & 0xff000000) >> 24));
FillH2CCmd8723B(padapter, H2C_8723B_MACID_CFG, H2C_MACID_CFG_LEN, u1H2CMacIdConfigParm);
}
void rtl8723b_set_rssi_cmd(struct adapter *padapter, u8 *param)
{
u8 u1H2CRssiSettingParm[H2C_RSSI_SETTING_LEN] = {0};
u8 mac_id = *param;
u8 rssi = *(param+2);
u8 uldl_state = 0;
SET_8723B_H2CCMD_RSSI_SETTING_MACID(u1H2CRssiSettingParm, mac_id);
SET_8723B_H2CCMD_RSSI_SETTING_RSSI(u1H2CRssiSettingParm, rssi);
SET_8723B_H2CCMD_RSSI_SETTING_ULDL_STATE(u1H2CRssiSettingParm, uldl_state);
FillH2CCmd8723B(padapter, H2C_8723B_RSSI_SETTING, H2C_RSSI_SETTING_LEN, u1H2CRssiSettingParm);
}
void rtl8723b_set_FwPwrMode_cmd(struct adapter *padapter, u8 psmode)
{
int i;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
u8 u1H2CPwrModeParm[H2C_PWRMODE_LEN] = {0};
u8 PowerState = 0, awake_intvl = 1, byte5 = 0, rlbm = 0;
if (pwrpriv->dtim > 0 && pwrpriv->dtim < 16)
awake_intvl = pwrpriv->dtim+1;/* DTIM = (awake_intvl - 1) */
else
awake_intvl = 3;/* DTIM =2 */
rlbm = 2;
if (padapter->registrypriv.wifi_spec == 1) {
awake_intvl = 2;
rlbm = 2;
}
if (psmode > 0) {
if (hal_btcoex_IsBtControlLps(padapter) == true) {
PowerState = hal_btcoex_RpwmVal(padapter);
byte5 = hal_btcoex_LpsVal(padapter);
if ((rlbm == 2) && (byte5 & BIT(4))) {
/* Keep awake interval to 1 to prevent from */
/* decreasing coex performance */
awake_intvl = 2;
rlbm = 2;
}
} else {
PowerState = 0x00;/* AllON(0x0C), RFON(0x04), RFOFF(0x00) */
byte5 = 0x40;
}
} else {
PowerState = 0x0C;/* AllON(0x0C), RFON(0x04), RFOFF(0x00) */
byte5 = 0x40;
}
SET_8723B_H2CCMD_PWRMODE_PARM_MODE(u1H2CPwrModeParm, (psmode > 0) ? 1 : 0);
SET_8723B_H2CCMD_PWRMODE_PARM_SMART_PS(u1H2CPwrModeParm, pwrpriv->smart_ps);
SET_8723B_H2CCMD_PWRMODE_PARM_RLBM(u1H2CPwrModeParm, rlbm);
SET_8723B_H2CCMD_PWRMODE_PARM_BCN_PASS_TIME(u1H2CPwrModeParm, awake_intvl);
SET_8723B_H2CCMD_PWRMODE_PARM_ALL_QUEUE_UAPSD(u1H2CPwrModeParm, padapter->registrypriv.uapsd_enable);
SET_8723B_H2CCMD_PWRMODE_PARM_PWR_STATE(u1H2CPwrModeParm, PowerState);
SET_8723B_H2CCMD_PWRMODE_PARM_BYTE5(u1H2CPwrModeParm, byte5);
if (psmode != PS_MODE_ACTIVE) {
if (!pmlmeext->adaptive_tsf_done && pmlmeext->bcn_cnt > 0) {
u8 ratio_20_delay, ratio_80_delay;
/* byte 6 for adaptive_early_32k */
/* 0:3] = DrvBcnEarly (ms) , [4:7] = DrvBcnTimeOut (ms) */
/* 20% for DrvBcnEarly, 80% for DrvBcnTimeOut */
ratio_20_delay = 0;
ratio_80_delay = 0;
pmlmeext->DrvBcnEarly = 0xff;
pmlmeext->DrvBcnTimeOut = 0xff;
for (i = 0; i < 9; i++) {
pmlmeext->bcn_delay_ratio[i] = (pmlmeext->bcn_delay_cnt[i]*100)/pmlmeext->bcn_cnt;
ratio_20_delay += pmlmeext->bcn_delay_ratio[i];
ratio_80_delay += pmlmeext->bcn_delay_ratio[i];
if (ratio_20_delay > 20 && pmlmeext->DrvBcnEarly == 0xff)
pmlmeext->DrvBcnEarly = i;
if (ratio_80_delay > 80 && pmlmeext->DrvBcnTimeOut == 0xff)
pmlmeext->DrvBcnTimeOut = i;
/* reset adaptive_early_32k cnt */
pmlmeext->bcn_delay_cnt[i] = 0;
pmlmeext->bcn_delay_ratio[i] = 0;
}
pmlmeext->bcn_cnt = 0;
pmlmeext->adaptive_tsf_done = true;
}
/* offload to FW if fw version > v15.10
pmlmeext->DrvBcnEarly = 0;
pmlmeext->DrvBcnTimeOut =7;
if ((pmlmeext->DrvBcnEarly!= 0Xff) && (pmlmeext->DrvBcnTimeOut!= 0xff))
u1H2CPwrModeParm[H2C_PWRMODE_LEN-1] = BIT(0) | ((pmlmeext->DrvBcnEarly<<1)&0x0E) |((pmlmeext->DrvBcnTimeOut<<4)&0xf0) ;
*/
}
hal_btcoex_RecordPwrMode(padapter, u1H2CPwrModeParm, H2C_PWRMODE_LEN);
FillH2CCmd8723B(padapter, H2C_8723B_SET_PWR_MODE, H2C_PWRMODE_LEN, u1H2CPwrModeParm);
}
void rtl8723b_set_FwPsTuneParam_cmd(struct adapter *padapter)
{
u8 u1H2CPsTuneParm[H2C_PSTUNEPARAM_LEN] = {0};
u8 bcn_to_limit = 10; /* 10 * 100 * awakeinterval (ms) */
u8 dtim_timeout = 5; /* ms wait broadcast data timer */
u8 ps_timeout = 20; /* ms Keep awake when tx */
u8 dtim_period = 3;
SET_8723B_H2CCMD_PSTUNE_PARM_BCN_TO_LIMIT(u1H2CPsTuneParm, bcn_to_limit);
SET_8723B_H2CCMD_PSTUNE_PARM_DTIM_TIMEOUT(u1H2CPsTuneParm, dtim_timeout);
SET_8723B_H2CCMD_PSTUNE_PARM_PS_TIMEOUT(u1H2CPsTuneParm, ps_timeout);
SET_8723B_H2CCMD_PSTUNE_PARM_ADOPT(u1H2CPsTuneParm, 1);
SET_8723B_H2CCMD_PSTUNE_PARM_DTIM_PERIOD(u1H2CPsTuneParm, dtim_period);
FillH2CCmd8723B(padapter, H2C_8723B_PS_TUNING_PARA, H2C_PSTUNEPARAM_LEN, u1H2CPsTuneParm);
}
void rtl8723b_set_FwPwrModeInIPS_cmd(struct adapter *padapter, u8 cmd_param)
{
FillH2CCmd8723B(padapter, H2C_8723B_FWLPS_IN_IPS_, 1, &cmd_param);
}
/*
* Description: Fill the reserved packets that FW will use to RSVD page.
* Now we just send 4 types packet to rsvd page.
* (1)Beacon, (2)Ps-poll, (3)Null data, (4)ProbeRsp.
*
* Input:
*
* bDLFinished - false: At the first time we will send all the packets as
* a large packet to Hw, so we need to set the packet length to total length.
*
* true: At the second time, we should send the first packet (default:beacon)
* to Hw again and set the length in descriptor to the real beacon length.
*/
/* 2009.10.15 by tynli. */
static void rtl8723b_set_FwRsvdPagePkt(
struct adapter *padapter, bool bDLFinished
)
{
struct xmit_frame *pcmdframe;
struct pkt_attrib *pattrib;
struct xmit_priv *pxmitpriv;
struct mlme_ext_priv *pmlmeext;
struct mlme_ext_info *pmlmeinfo;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
u32 BeaconLength = 0, PSPollLength = 0;
u32 NullDataLength = 0, QosNullLength = 0, BTQosNullLength = 0;
u8 *ReservedPagePacket;
u8 TxDescLen = TXDESC_SIZE, TxDescOffset = TXDESC_OFFSET;
u8 TotalPageNum = 0, CurtPktPageNum = 0, RsvdPageNum = 0;
u16 BufIndex, PageSize = 128;
u32 TotalPacketLen, MaxRsvdPageBufSize = 0;
struct rsvdpage_loc RsvdPageLoc;
pxmitpriv = &padapter->xmitpriv;
pmlmeext = &padapter->mlmeextpriv;
pmlmeinfo = &pmlmeext->mlmext_info;
RsvdPageNum = BCNQ_PAGE_NUM_8723B + WOWLAN_PAGE_NUM_8723B;
MaxRsvdPageBufSize = RsvdPageNum*PageSize;
pcmdframe = rtw_alloc_cmdxmitframe(pxmitpriv);
if (!pcmdframe)
return;
ReservedPagePacket = pcmdframe->buf_addr;
memset(&RsvdPageLoc, 0, sizeof(struct rsvdpage_loc));
/* 3 (1) beacon */
BufIndex = TxDescOffset;
ConstructBeacon(padapter, &ReservedPagePacket[BufIndex], &BeaconLength);
/* When we count the first page size, we need to reserve description size for the RSVD */
/* packet, it will be filled in front of the packet in TXPKTBUF. */
CurtPktPageNum = (u8)PageNum_128(TxDescLen + BeaconLength);
/* If we don't add 1 more page, the WOWLAN function has a problem. Baron thinks it's a bug of firmware */
if (CurtPktPageNum == 1)
CurtPktPageNum += 1;
TotalPageNum += CurtPktPageNum;
BufIndex += (CurtPktPageNum*PageSize);
/* 3 (2) ps-poll */
RsvdPageLoc.LocPsPoll = TotalPageNum;
ConstructPSPoll(padapter, &ReservedPagePacket[BufIndex], &PSPollLength);
rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], PSPollLength, true, false, false);
CurtPktPageNum = (u8)PageNum_128(TxDescLen + PSPollLength);
TotalPageNum += CurtPktPageNum;
BufIndex += (CurtPktPageNum*PageSize);
/* 3 (3) null data */
RsvdPageLoc.LocNullData = TotalPageNum;
ConstructNullFunctionData(
padapter,
&ReservedPagePacket[BufIndex],
&NullDataLength,
get_my_bssid(&pmlmeinfo->network),
false, 0, 0, false
);
rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], NullDataLength, false, false, false);
CurtPktPageNum = (u8)PageNum_128(TxDescLen + NullDataLength);
TotalPageNum += CurtPktPageNum;
BufIndex += (CurtPktPageNum*PageSize);
/* 3 (5) Qos null data */
RsvdPageLoc.LocQosNull = TotalPageNum;
ConstructNullFunctionData(
padapter,
&ReservedPagePacket[BufIndex],
&QosNullLength,
get_my_bssid(&pmlmeinfo->network),
true, 0, 0, false
);
rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], QosNullLength, false, false, false);
CurtPktPageNum = (u8)PageNum_128(TxDescLen + QosNullLength);
TotalPageNum += CurtPktPageNum;
BufIndex += (CurtPktPageNum*PageSize);
/* 3 (6) BT Qos null data */
RsvdPageLoc.LocBTQosNull = TotalPageNum;
ConstructNullFunctionData(
padapter,
&ReservedPagePacket[BufIndex],
&BTQosNullLength,
get_my_bssid(&pmlmeinfo->network),
true, 0, 0, false
);
rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], BTQosNullLength, false, true, false);
CurtPktPageNum = (u8)PageNum_128(TxDescLen + BTQosNullLength);
TotalPageNum += CurtPktPageNum;
BufIndex += (CurtPktPageNum*PageSize);
TotalPacketLen = BufIndex + BTQosNullLength;
if (TotalPacketLen > MaxRsvdPageBufSize) {
goto error;
} else {
/* update attribute */
pattrib = &pcmdframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->qsel = 0x10;
pattrib->pktlen = pattrib->last_txcmdsz = TotalPacketLen - TxDescOffset;
dump_mgntframe_and_wait(padapter, pcmdframe, 100);
}
if (check_fwstate(pmlmepriv, _FW_LINKED)) {
rtl8723b_set_FwRsvdPage_cmd(padapter, &RsvdPageLoc);
rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
} else {
rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
}
return;
error:
rtw_free_xmitframe(pxmitpriv, pcmdframe);
}
void rtl8723b_download_rsvd_page(struct adapter *padapter, u8 mstatus)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
bool bcn_valid = false;
u8 DLBcnCount = 0;
u32 poll = 0;
u8 val8;
if (mstatus == RT_MEDIA_CONNECT) {
bool bRecover = false;
u8 v8;
/* We should set AID, correct TSF, HW seq enable before set JoinBssReport to Fw in 88/92C. */
/* Suggested by filen. Added by tynli. */
rtw_write16(padapter, REG_BCN_PSR_RPT, (0xC000|pmlmeinfo->aid));
/* set REG_CR bit 8 */
v8 = rtw_read8(padapter, REG_CR+1);
v8 |= BIT(0); /* ENSWBCN */
rtw_write8(padapter, REG_CR+1, v8);
/* Disable Hw protection for a time which revserd for Hw sending beacon. */
/* Fix download reserved page packet fail that access collision with the protection time. */
/* 2010.05.11. Added by tynli. */
val8 = rtw_read8(padapter, REG_BCN_CTRL);
val8 &= ~EN_BCN_FUNCTION;
val8 |= DIS_TSF_UDT;
rtw_write8(padapter, REG_BCN_CTRL, val8);
/* Set FWHW_TXQ_CTRL 0x422[6]= 0 to tell Hw the packet is not a real beacon frame. */
if (pHalData->RegFwHwTxQCtrl & BIT(6))
bRecover = true;
/* To tell Hw the packet is not a real beacon frame. */
rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl & ~BIT(6));
pHalData->RegFwHwTxQCtrl &= ~BIT(6);
/* Clear beacon valid check bit. */
rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
DLBcnCount = 0;
poll = 0;
do {
/* download rsvd page. */
rtl8723b_set_FwRsvdPagePkt(padapter, 0);
DLBcnCount++;
do {
yield();
/* mdelay(10); */
/* check rsvd page download OK. */
rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, (u8 *)(&bcn_valid));
poll++;
} while (!bcn_valid && (poll%10) != 0 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
} while (!bcn_valid && DLBcnCount <= 100 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
if (padapter->bSurpriseRemoved || padapter->bDriverStopped) {
} else {
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
pwrctl->fw_psmode_iface_id = padapter->iface_id;
}
/* 2010.05.11. Added by tynli. */
val8 = rtw_read8(padapter, REG_BCN_CTRL);
val8 |= EN_BCN_FUNCTION;
val8 &= ~DIS_TSF_UDT;
rtw_write8(padapter, REG_BCN_CTRL, val8);
/* To make sure that if there exists an adapter which would like to send beacon. */
/* If exists, the origianl value of 0x422[6] will be 1, we should check this to */
/* prevent from setting 0x422[6] to 0 after download reserved page, or it will cause */
/* the beacon cannot be sent by HW. */
/* 2010.06.23. Added by tynli. */
if (bRecover) {
rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl | BIT(6));
pHalData->RegFwHwTxQCtrl |= BIT(6);
}
/* Clear CR[8] or beacon packet will not be send to TxBuf anymore. */
v8 = rtw_read8(padapter, REG_CR+1);
v8 &= ~BIT(0); /* ~ENSWBCN */
rtw_write8(padapter, REG_CR+1, v8);
}
}
void rtl8723b_set_FwJoinBssRpt_cmd(struct adapter *padapter, u8 mstatus)
{
if (mstatus == 1)
rtl8723b_download_rsvd_page(padapter, RT_MEDIA_CONNECT);
}
/* arg[0] = macid */
/* arg[1] = raid */
/* arg[2] = shortGIrate */
/* arg[3] = init_rate */
void rtl8723b_Add_RateATid(
struct adapter *padapter,
u32 bitmap,
u8 *arg,
u8 rssi_level
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
struct sta_info *psta;
u8 mac_id = arg[0];
u8 raid = arg[1];
u8 shortGI = arg[2];
u8 bw;
u32 mask = bitmap&0x0FFFFFFF;
psta = pmlmeinfo->FW_sta_info[mac_id].psta;
if (!psta)
return;
bw = psta->bw_mode;
if (rssi_level != DM_RATR_STA_INIT)
mask = ODM_Get_Rate_Bitmap(&pHalData->odmpriv, mac_id, mask, rssi_level);
rtl8723b_set_FwMacIdConfig_cmd(padapter, mac_id, raid, bw, shortGI, mask);
}
static void ConstructBtNullFunctionData(
struct adapter *padapter,
u8 *pframe,
u32 *pLength,
u8 *StaAddr,
u8 bQoS,
u8 AC,
u8 bEosp,
u8 bForcePowerSave
)
{
struct ieee80211_hdr *pwlanhdr;
__le16 *fctrl;
u32 pktlen;
u8 bssid[ETH_ALEN];
pwlanhdr = (struct ieee80211_hdr *)pframe;
if (!StaAddr) {
memcpy(bssid, myid(&padapter->eeprompriv), ETH_ALEN);
StaAddr = bssid;
}
fctrl = &pwlanhdr->frame_control;
*fctrl = 0;
if (bForcePowerSave)
SetPwrMgt(fctrl);
SetFrDs(fctrl);
memcpy(pwlanhdr->addr1, StaAddr, ETH_ALEN);
memcpy(pwlanhdr->addr2, myid(&padapter->eeprompriv), ETH_ALEN);
memcpy(pwlanhdr->addr3, myid(&padapter->eeprompriv), ETH_ALEN);
SetDuration(pwlanhdr, 0);
SetSeqNum(pwlanhdr, 0);
if (bQoS) {
struct ieee80211_qos_hdr *pwlanqoshdr;
SetFrameSubType(pframe, WIFI_QOS_DATA_NULL);
pwlanqoshdr = (struct ieee80211_qos_hdr *)pframe;
SetPriority(&pwlanqoshdr->qos_ctrl, AC);
SetEOSP(&pwlanqoshdr->qos_ctrl, bEosp);
pktlen = sizeof(struct ieee80211_qos_hdr);
} else {
SetFrameSubType(pframe, WIFI_DATA_NULL);
pktlen = sizeof(struct ieee80211_hdr_3addr);
}
*pLength = pktlen;
}
static void SetFwRsvdPagePkt_BTCoex(struct adapter *padapter)
{
struct xmit_frame *pcmdframe;
struct pkt_attrib *pattrib;
struct xmit_priv *pxmitpriv;
u32 BeaconLength = 0;
u32 BTQosNullLength = 0;
u8 *ReservedPagePacket;
u8 TxDescLen, TxDescOffset;
u8 TotalPageNum = 0, CurtPktPageNum = 0, RsvdPageNum = 0;
u16 BufIndex, PageSize;
u32 TotalPacketLen, MaxRsvdPageBufSize = 0;
struct rsvdpage_loc RsvdPageLoc;
pxmitpriv = &padapter->xmitpriv;
TxDescLen = TXDESC_SIZE;
TxDescOffset = TXDESC_OFFSET;
PageSize = PAGE_SIZE_TX_8723B;
RsvdPageNum = BCNQ_PAGE_NUM_8723B;
MaxRsvdPageBufSize = RsvdPageNum*PageSize;
pcmdframe = rtw_alloc_cmdxmitframe(pxmitpriv);
if (!pcmdframe)
return;
ReservedPagePacket = pcmdframe->buf_addr;
memset(&RsvdPageLoc, 0, sizeof(struct rsvdpage_loc));
/* 3 (1) beacon */
BufIndex = TxDescOffset;
ConstructBeacon(padapter, &ReservedPagePacket[BufIndex], &BeaconLength);
/* When we count the first page size, we need to reserve description size for the RSVD */
/* packet, it will be filled in front of the packet in TXPKTBUF. */
CurtPktPageNum = (u8)PageNum_128(TxDescLen + BeaconLength);
/* If we don't add 1 more page, the WOWLAN function has a problem. Baron thinks it's a bug of firmware */
if (CurtPktPageNum == 1)
CurtPktPageNum += 1;
TotalPageNum += CurtPktPageNum;
BufIndex += (CurtPktPageNum*PageSize);
/* Jump to lastest page */
if (BufIndex < (MaxRsvdPageBufSize - PageSize)) {
BufIndex = TxDescOffset + (MaxRsvdPageBufSize - PageSize);
TotalPageNum = BCNQ_PAGE_NUM_8723B - 1;
}
/* 3 (6) BT Qos null data */
RsvdPageLoc.LocBTQosNull = TotalPageNum;
ConstructBtNullFunctionData(
padapter,
&ReservedPagePacket[BufIndex],
&BTQosNullLength,
NULL,
true, 0, 0, false
);
rtl8723b_fill_fake_txdesc(padapter, &ReservedPagePacket[BufIndex-TxDescLen], BTQosNullLength, false, true, false);
CurtPktPageNum = (u8)PageNum_128(TxDescLen + BTQosNullLength);
TotalPageNum += CurtPktPageNum;
TotalPacketLen = BufIndex + BTQosNullLength;
if (TotalPacketLen > MaxRsvdPageBufSize)
goto error;
/* update attribute */
pattrib = &pcmdframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->qsel = 0x10;
pattrib->pktlen = pattrib->last_txcmdsz = TotalPacketLen - TxDescOffset;
dump_mgntframe_and_wait(padapter, pcmdframe, 100);
rtl8723b_set_FwRsvdPage_cmd(padapter, &RsvdPageLoc);
rtl8723b_set_FwAoacRsvdPage_cmd(padapter, &RsvdPageLoc);
return;
error:
rtw_free_xmitframe(pxmitpriv, pcmdframe);
}
void rtl8723b_download_BTCoex_AP_mode_rsvd_page(struct adapter *padapter)
{
struct hal_com_data *pHalData;
struct mlme_ext_priv *pmlmeext;
struct mlme_ext_info *pmlmeinfo;
u8 bRecover = false;
u8 bcn_valid = false;
u8 DLBcnCount = 0;
u32 poll = 0;
u8 val8;
pHalData = GET_HAL_DATA(padapter);
pmlmeext = &padapter->mlmeextpriv;
pmlmeinfo = &pmlmeext->mlmext_info;
/* We should set AID, correct TSF, HW seq enable before set JoinBssReport to Fw in 88/92C. */
/* Suggested by filen. Added by tynli. */
rtw_write16(padapter, REG_BCN_PSR_RPT, (0xC000|pmlmeinfo->aid));
/* set REG_CR bit 8 */
val8 = rtw_read8(padapter, REG_CR+1);
val8 |= BIT(0); /* ENSWBCN */
rtw_write8(padapter, REG_CR+1, val8);
/* Disable Hw protection for a time which revserd for Hw sending beacon. */
/* Fix download reserved page packet fail that access collision with the protection time. */
/* 2010.05.11. Added by tynli. */
val8 = rtw_read8(padapter, REG_BCN_CTRL);
val8 &= ~EN_BCN_FUNCTION;
val8 |= DIS_TSF_UDT;
rtw_write8(padapter, REG_BCN_CTRL, val8);
/* Set FWHW_TXQ_CTRL 0x422[6]= 0 to tell Hw the packet is not a real beacon frame. */
if (pHalData->RegFwHwTxQCtrl & BIT(6))
bRecover = true;
/* To tell Hw the packet is not a real beacon frame. */
pHalData->RegFwHwTxQCtrl &= ~BIT(6);
rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl);
/* Clear beacon valid check bit. */
rtw_hal_set_hwreg(padapter, HW_VAR_BCN_VALID, NULL);
rtw_hal_set_hwreg(padapter, HW_VAR_DL_BCN_SEL, NULL);
DLBcnCount = 0;
poll = 0;
do {
SetFwRsvdPagePkt_BTCoex(padapter);
DLBcnCount++;
do {
yield();
/* mdelay(10); */
/* check rsvd page download OK. */
rtw_hal_get_hwreg(padapter, HW_VAR_BCN_VALID, &bcn_valid);
poll++;
} while (!bcn_valid && (poll%10) != 0 && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
} while (!bcn_valid && (DLBcnCount <= 100) && !padapter->bSurpriseRemoved && !padapter->bDriverStopped);
if (bcn_valid) {
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
pwrctl->fw_psmode_iface_id = padapter->iface_id;
}
/* 2010.05.11. Added by tynli. */
val8 = rtw_read8(padapter, REG_BCN_CTRL);
val8 |= EN_BCN_FUNCTION;
val8 &= ~DIS_TSF_UDT;
rtw_write8(padapter, REG_BCN_CTRL, val8);
/* To make sure that if there exists an adapter which would like to send beacon. */
/* If exists, the origianl value of 0x422[6] will be 1, we should check this to */
/* prevent from setting 0x422[6] to 0 after download reserved page, or it will cause */
/* the beacon cannot be sent by HW. */
/* 2010.06.23. Added by tynli. */
if (bRecover) {
pHalData->RegFwHwTxQCtrl |= BIT(6);
rtw_write8(padapter, REG_FWHW_TXQ_CTRL+2, pHalData->RegFwHwTxQCtrl);
}
/* Clear CR[8] or beacon packet will not be send to TxBuf anymore. */
val8 = rtw_read8(padapter, REG_CR+1);
val8 &= ~BIT(0); /* ~ENSWBCN */
rtw_write8(padapter, REG_CR+1, val8);
}
| linux-master | drivers/staging/rtl8723bs/hal/rtl8723b_cmd.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <hal_data.h>
u8 rtw_hal_sdio_max_txoqt_free_space(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
if (pHalData->SdioTxOQTMaxFreeSpace < 8)
pHalData->SdioTxOQTMaxFreeSpace = 8;
return pHalData->SdioTxOQTMaxFreeSpace;
}
u8 rtw_hal_sdio_query_tx_freepage(
struct adapter *padapter, u8 PageIdx, u8 RequiredPageNum
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
if ((pHalData->SdioTxFIFOFreePage[PageIdx]+pHalData->SdioTxFIFOFreePage[PUBLIC_QUEUE_IDX]) >= (RequiredPageNum))
return true;
else
return false;
}
void rtw_hal_sdio_update_tx_freepage(
struct adapter *padapter, u8 PageIdx, u8 RequiredPageNum
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 DedicatedPgNum = 0;
u8 RequiredPublicFreePgNum = 0;
/* _irqL irql; */
/* spin_lock_bh(&pHalData->SdioTxFIFOFreePageLock); */
DedicatedPgNum = pHalData->SdioTxFIFOFreePage[PageIdx];
if (RequiredPageNum <= DedicatedPgNum) {
pHalData->SdioTxFIFOFreePage[PageIdx] -= RequiredPageNum;
} else {
pHalData->SdioTxFIFOFreePage[PageIdx] = 0;
RequiredPublicFreePgNum = RequiredPageNum - DedicatedPgNum;
pHalData->SdioTxFIFOFreePage[PUBLIC_QUEUE_IDX] -= RequiredPublicFreePgNum;
}
/* spin_unlock_bh(&pHalData->SdioTxFIFOFreePageLock); */
}
void rtw_hal_set_sdio_tx_max_length(
struct adapter *padapter, u8 numHQ, u8 numNQ, u8 numLQ, u8 numPubQ
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u32 page_size;
u32 lenHQ, lenNQ, lenLQ;
rtw_hal_get_def_var(padapter, HAL_DEF_TX_PAGE_SIZE, &page_size);
lenHQ = ((numHQ + numPubQ) >> 1) * page_size;
lenNQ = ((numNQ + numPubQ) >> 1) * page_size;
lenLQ = ((numLQ + numPubQ) >> 1) * page_size;
pHalData->sdio_tx_max_len[HI_QUEUE_IDX] =
(lenHQ > MAX_XMITBUF_SZ) ? MAX_XMITBUF_SZ : lenHQ;
pHalData->sdio_tx_max_len[MID_QUEUE_IDX] =
(lenNQ > MAX_XMITBUF_SZ) ? MAX_XMITBUF_SZ : lenNQ;
pHalData->sdio_tx_max_len[LOW_QUEUE_IDX] =
(lenLQ > MAX_XMITBUF_SZ) ? MAX_XMITBUF_SZ : lenLQ;
}
u32 rtw_hal_get_sdio_tx_max_length(struct adapter *padapter, u8 queue_idx)
{
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u32 deviceId, max_len;
deviceId = ffaddr2deviceId(pdvobjpriv, queue_idx);
switch (deviceId) {
case WLAN_TX_HIQ_DEVICE_ID:
max_len = pHalData->sdio_tx_max_len[HI_QUEUE_IDX];
break;
case WLAN_TX_MIQ_DEVICE_ID:
max_len = pHalData->sdio_tx_max_len[MID_QUEUE_IDX];
break;
case WLAN_TX_LOQ_DEVICE_ID:
max_len = pHalData->sdio_tx_max_len[LOW_QUEUE_IDX];
break;
default:
max_len = pHalData->sdio_tx_max_len[MID_QUEUE_IDX];
break;
}
return max_len;
}
| linux-master | drivers/staging/rtl8723bs/hal/hal_sdio.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
/*++
Copyright (c) Realtek Semiconductor Corp. All rights reserved.
Module Name:
HalPwrSeqCmd.c
Abstract:
Implement HW Power sequence configuration CMD handling routine for Realtek devices.
Major Change History:
When Who What
---------- --------------- -------------------------------
2011-10-26 Lucas Modify to be compatible with SD4-CE driver.
2011-07-07 Roger Create.
--*/
#include <drv_types.h>
#include <rtw_debug.h>
#include <HalPwrSeqCmd.h>
/* */
/* Description: */
/* This routine deal with the Power Configuration CMDs parsing for RTL8723/RTL8188E Series IC. */
/* */
/* Assumption: */
/* We should follow specific format which was released from HW SD. */
/* */
/* 2011.07.07, added by Roger. */
/* */
u8 HalPwrSeqCmdParsing(
struct adapter *padapter,
u8 CutVersion,
u8 FabVersion,
u8 InterfaceType,
struct wlan_pwr_cfg PwrSeqCmd[]
)
{
struct wlan_pwr_cfg PwrCfgCmd;
u8 bPollingBit = false;
u32 AryIdx = 0;
u8 value = 0;
u32 offset = 0;
u32 pollingCount = 0; /* polling autoload done. */
u32 maxPollingCnt = 5000;
do {
PwrCfgCmd = PwrSeqCmd[AryIdx];
/* 2 Only Handle the command whose FAB, CUT, and Interface are matched */
if (
(GET_PWR_CFG_FAB_MASK(PwrCfgCmd) & FabVersion) &&
(GET_PWR_CFG_CUT_MASK(PwrCfgCmd) & CutVersion) &&
(GET_PWR_CFG_INTF_MASK(PwrCfgCmd) & InterfaceType)
) {
switch (GET_PWR_CFG_CMD(PwrCfgCmd)) {
case PWR_CMD_READ:
break;
case PWR_CMD_WRITE:
offset = GET_PWR_CFG_OFFSET(PwrCfgCmd);
/* */
/* <Roger_Notes> We should deal with interface specific address mapping for some interfaces, e.g., SDIO interface */
/* 2011.07.07. */
/* */
if (GET_PWR_CFG_BASE(PwrCfgCmd) == PWR_BASEADDR_SDIO) {
/* Read Back SDIO Local value */
value = SdioLocalCmd52Read1Byte(padapter, offset);
value &= ~(GET_PWR_CFG_MASK(PwrCfgCmd));
value |= (
GET_PWR_CFG_VALUE(PwrCfgCmd) &
GET_PWR_CFG_MASK(PwrCfgCmd)
);
/* Write Back SDIO Local value */
SdioLocalCmd52Write1Byte(padapter, offset, value);
} else {
/* Read the value from system register */
value = rtw_read8(padapter, offset);
value &= (~(GET_PWR_CFG_MASK(PwrCfgCmd)));
value |= (
GET_PWR_CFG_VALUE(PwrCfgCmd)
&GET_PWR_CFG_MASK(PwrCfgCmd)
);
/* Write the value back to system register */
rtw_write8(padapter, offset, value);
}
break;
case PWR_CMD_POLLING:
bPollingBit = false;
offset = GET_PWR_CFG_OFFSET(PwrCfgCmd);
do {
if (GET_PWR_CFG_BASE(PwrCfgCmd) == PWR_BASEADDR_SDIO)
value = SdioLocalCmd52Read1Byte(padapter, offset);
else
value = rtw_read8(padapter, offset);
value = value&GET_PWR_CFG_MASK(PwrCfgCmd);
if (
value == (GET_PWR_CFG_VALUE(PwrCfgCmd) &
GET_PWR_CFG_MASK(PwrCfgCmd))
)
bPollingBit = true;
else
udelay(10);
if (pollingCount++ > maxPollingCnt)
return false;
} while (!bPollingBit);
break;
case PWR_CMD_DELAY:
if (GET_PWR_CFG_VALUE(PwrCfgCmd) == PWRSEQ_DELAY_US)
udelay(GET_PWR_CFG_OFFSET(PwrCfgCmd));
else
udelay(GET_PWR_CFG_OFFSET(PwrCfgCmd)*1000);
break;
case PWR_CMD_END:
/* When this command is parsed, end the process */
return true;
default:
break;
}
}
AryIdx++;/* Add Array Index */
} while (1);
return true;
}
| linux-master | drivers/staging/rtl8723bs/hal/HalPwrSeqCmd.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
/*
*
This file includes all kinds of Power Action event for RTL8723B
and corresponding hardware configurtions which are released from HW SD.
Major Change History:
When Who What
---------- --------------- -------------------------------
2011-08-08 Roger Create.
*/
#include "hal_pwr_seq.h"
/* drivers should parse below arrays and do the corresponding actions */
/* 3 Power on Array */
struct wlan_pwr_cfg rtl8723B_power_on_flow[
RTL8723B_TRANS_CARDEMU_TO_ACT_STEPS+
RTL8723B_TRANS_END_STEPS
] = {
RTL8723B_TRANS_CARDEMU_TO_ACT
RTL8723B_TRANS_END
};
/* 3Radio off GPIO Array */
struct wlan_pwr_cfg rtl8723B_radio_off_flow[
RTL8723B_TRANS_ACT_TO_CARDEMU_STEPS+
RTL8723B_TRANS_END_STEPS
] = {
RTL8723B_TRANS_ACT_TO_CARDEMU
RTL8723B_TRANS_END
};
/* 3Card Disable Array */
struct wlan_pwr_cfg rtl8723B_card_disable_flow[
RTL8723B_TRANS_ACT_TO_CARDEMU_STEPS+
RTL8723B_TRANS_CARDEMU_TO_PDN_STEPS+
RTL8723B_TRANS_END_STEPS
] = {
RTL8723B_TRANS_ACT_TO_CARDEMU
RTL8723B_TRANS_CARDEMU_TO_CARDDIS
RTL8723B_TRANS_END
};
/* 3 Card Enable Array */
struct wlan_pwr_cfg rtl8723B_card_enable_flow[
RTL8723B_TRANS_ACT_TO_CARDEMU_STEPS+
RTL8723B_TRANS_CARDEMU_TO_PDN_STEPS+
RTL8723B_TRANS_END_STEPS
] = {
RTL8723B_TRANS_CARDDIS_TO_CARDEMU
RTL8723B_TRANS_CARDEMU_TO_ACT
RTL8723B_TRANS_END
};
/* 3Suspend Array */
struct wlan_pwr_cfg rtl8723B_suspend_flow[
RTL8723B_TRANS_ACT_TO_CARDEMU_STEPS+
RTL8723B_TRANS_CARDEMU_TO_SUS_STEPS+
RTL8723B_TRANS_END_STEPS
] = {
RTL8723B_TRANS_ACT_TO_CARDEMU
RTL8723B_TRANS_CARDEMU_TO_SUS
RTL8723B_TRANS_END
};
/* 3 Resume Array */
struct wlan_pwr_cfg rtl8723B_resume_flow[
RTL8723B_TRANS_ACT_TO_CARDEMU_STEPS+
RTL8723B_TRANS_CARDEMU_TO_SUS_STEPS+
RTL8723B_TRANS_END_STEPS
] = {
RTL8723B_TRANS_SUS_TO_CARDEMU
RTL8723B_TRANS_CARDEMU_TO_ACT
RTL8723B_TRANS_END
};
/* 3HWPDN Array */
struct wlan_pwr_cfg rtl8723B_hwpdn_flow[
RTL8723B_TRANS_ACT_TO_CARDEMU_STEPS+
RTL8723B_TRANS_CARDEMU_TO_PDN_STEPS+
RTL8723B_TRANS_END_STEPS
] = {
RTL8723B_TRANS_ACT_TO_CARDEMU
RTL8723B_TRANS_CARDEMU_TO_PDN
RTL8723B_TRANS_END
};
/* 3 Enter LPS */
struct wlan_pwr_cfg rtl8723B_enter_lps_flow[
RTL8723B_TRANS_ACT_TO_LPS_STEPS+RTL8723B_TRANS_END_STEPS
] = {
/* FW behavior */
RTL8723B_TRANS_ACT_TO_LPS
RTL8723B_TRANS_END
};
/* 3 Leave LPS */
struct wlan_pwr_cfg rtl8723B_leave_lps_flow[
RTL8723B_TRANS_LPS_TO_ACT_STEPS+RTL8723B_TRANS_END_STEPS
] = {
/* FW behavior */
RTL8723B_TRANS_LPS_TO_ACT
RTL8723B_TRANS_END
};
/* 3 Enter SW LPS */
struct wlan_pwr_cfg rtl8723B_enter_swlps_flow[
RTL8723B_TRANS_ACT_TO_SWLPS_STEPS+RTL8723B_TRANS_END_STEPS
] = {
/* SW behavior */
RTL8723B_TRANS_ACT_TO_SWLPS
RTL8723B_TRANS_END
};
/* 3 Leave SW LPS */
struct wlan_pwr_cfg rtl8723B_leave_swlps_flow[
RTL8723B_TRANS_SWLPS_TO_ACT_STEPS+RTL8723B_TRANS_END_STEPS
] = {
/* SW behavior */
RTL8723B_TRANS_SWLPS_TO_ACT
RTL8723B_TRANS_END
};
| linux-master | drivers/staging/rtl8723bs/hal/hal_pwr_seq.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <linux/kernel.h>
#include "odm_precomp.h"
static bool CheckPositive(
struct dm_odm_t *pDM_Odm, const u32 Condition1, const u32 Condition2
)
{
u8 _BoardType =
((pDM_Odm->BoardType & BIT4) >> 4) << 0 | /* _GLNA */
((pDM_Odm->BoardType & BIT3) >> 3) << 1 | /* _GPA */
((pDM_Odm->BoardType & BIT7) >> 7) << 2 | /* _ALNA */
((pDM_Odm->BoardType & BIT6) >> 6) << 3 | /* _APA */
((pDM_Odm->BoardType & BIT2) >> 2) << 4; /* _BT */
u32 cond1 = Condition1, cond2 = Condition2;
u32 driver1 =
pDM_Odm->CutVersion << 24 |
pDM_Odm->SupportPlatform << 16 |
pDM_Odm->PackageType << 12 |
pDM_Odm->SupportInterface << 8 |
_BoardType;
u32 driver2 =
pDM_Odm->TypeGLNA << 0 |
pDM_Odm->TypeGPA << 8 |
pDM_Odm->TypeALNA << 16 |
pDM_Odm->TypeAPA << 24;
/* Value Defined Check =============== */
/* QFN Type [15:12] and Cut Version [27:24] need to do value check */
if (((cond1 & 0x0000F000) != 0) && ((cond1 & 0x0000F000) != (driver1 & 0x0000F000)))
return false;
if (((cond1 & 0x0F000000) != 0) && ((cond1 & 0x0F000000) != (driver1 & 0x0F000000)))
return false;
/* Bit Defined Check ================ */
/* We don't care [31:28] and [23:20] */
/* */
cond1 &= 0x000F0FFF;
driver1 &= 0x000F0FFF;
if ((cond1 & driver1) == cond1) {
u32 bitMask = 0;
if ((cond1 & 0x0F) == 0) /* BoardType is DONTCARE */
return true;
if ((cond1 & BIT0) != 0) /* GLNA */
bitMask |= 0x000000FF;
if ((cond1 & BIT1) != 0) /* GPA */
bitMask |= 0x0000FF00;
if ((cond1 & BIT2) != 0) /* ALNA */
bitMask |= 0x00FF0000;
if ((cond1 & BIT3) != 0) /* APA */
bitMask |= 0xFF000000;
/* BoardType of each RF path is matched */
if ((cond2 & bitMask) == (driver2 & bitMask))
return true;
}
return false;
}
static bool CheckNegative(
struct dm_odm_t *pDM_Odm, const u32 Condition1, const u32 Condition2
)
{
return true;
}
/******************************************************************************
* AGC_TAB.TXT
******************************************************************************/
static u32 Array_MP_8723B_AGC_TAB[] = {
0xC78, 0xFD000001,
0xC78, 0xFC010001,
0xC78, 0xFB020001,
0xC78, 0xFA030001,
0xC78, 0xF9040001,
0xC78, 0xF8050001,
0xC78, 0xF7060001,
0xC78, 0xF6070001,
0xC78, 0xF5080001,
0xC78, 0xF4090001,
0xC78, 0xF30A0001,
0xC78, 0xF20B0001,
0xC78, 0xF10C0001,
0xC78, 0xF00D0001,
0xC78, 0xEF0E0001,
0xC78, 0xEE0F0001,
0xC78, 0xED100001,
0xC78, 0xEC110001,
0xC78, 0xEB120001,
0xC78, 0xEA130001,
0xC78, 0xE9140001,
0xC78, 0xE8150001,
0xC78, 0xE7160001,
0xC78, 0xE6170001,
0xC78, 0xE5180001,
0xC78, 0xE4190001,
0xC78, 0xE31A0001,
0xC78, 0xA51B0001,
0xC78, 0xA41C0001,
0xC78, 0xA31D0001,
0xC78, 0x671E0001,
0xC78, 0x661F0001,
0xC78, 0x65200001,
0xC78, 0x64210001,
0xC78, 0x63220001,
0xC78, 0x4A230001,
0xC78, 0x49240001,
0xC78, 0x48250001,
0xC78, 0x47260001,
0xC78, 0x46270001,
0xC78, 0x45280001,
0xC78, 0x44290001,
0xC78, 0x432A0001,
0xC78, 0x422B0001,
0xC78, 0x292C0001,
0xC78, 0x282D0001,
0xC78, 0x272E0001,
0xC78, 0x262F0001,
0xC78, 0x0A300001,
0xC78, 0x09310001,
0xC78, 0x08320001,
0xC78, 0x07330001,
0xC78, 0x06340001,
0xC78, 0x05350001,
0xC78, 0x04360001,
0xC78, 0x03370001,
0xC78, 0x02380001,
0xC78, 0x01390001,
0xC78, 0x013A0001,
0xC78, 0x013B0001,
0xC78, 0x013C0001,
0xC78, 0x013D0001,
0xC78, 0x013E0001,
0xC78, 0x013F0001,
0xC78, 0xFC400001,
0xC78, 0xFB410001,
0xC78, 0xFA420001,
0xC78, 0xF9430001,
0xC78, 0xF8440001,
0xC78, 0xF7450001,
0xC78, 0xF6460001,
0xC78, 0xF5470001,
0xC78, 0xF4480001,
0xC78, 0xF3490001,
0xC78, 0xF24A0001,
0xC78, 0xF14B0001,
0xC78, 0xF04C0001,
0xC78, 0xEF4D0001,
0xC78, 0xEE4E0001,
0xC78, 0xED4F0001,
0xC78, 0xEC500001,
0xC78, 0xEB510001,
0xC78, 0xEA520001,
0xC78, 0xE9530001,
0xC78, 0xE8540001,
0xC78, 0xE7550001,
0xC78, 0xE6560001,
0xC78, 0xE5570001,
0xC78, 0xE4580001,
0xC78, 0xE3590001,
0xC78, 0xA65A0001,
0xC78, 0xA55B0001,
0xC78, 0xA45C0001,
0xC78, 0xA35D0001,
0xC78, 0x675E0001,
0xC78, 0x665F0001,
0xC78, 0x65600001,
0xC78, 0x64610001,
0xC78, 0x63620001,
0xC78, 0x62630001,
0xC78, 0x61640001,
0xC78, 0x48650001,
0xC78, 0x47660001,
0xC78, 0x46670001,
0xC78, 0x45680001,
0xC78, 0x44690001,
0xC78, 0x436A0001,
0xC78, 0x426B0001,
0xC78, 0x286C0001,
0xC78, 0x276D0001,
0xC78, 0x266E0001,
0xC78, 0x256F0001,
0xC78, 0x24700001,
0xC78, 0x09710001,
0xC78, 0x08720001,
0xC78, 0x07730001,
0xC78, 0x06740001,
0xC78, 0x05750001,
0xC78, 0x04760001,
0xC78, 0x03770001,
0xC78, 0x02780001,
0xC78, 0x01790001,
0xC78, 0x017A0001,
0xC78, 0x017B0001,
0xC78, 0x017C0001,
0xC78, 0x017D0001,
0xC78, 0x017E0001,
0xC78, 0x017F0001,
0xC50, 0x69553422,
0xC50, 0x69553420,
0x824, 0x00390204,
};
void ODM_ReadAndConfig_MP_8723B_AGC_TAB(struct dm_odm_t *pDM_Odm)
{
u32 i = 0;
u32 ArrayLen = ARRAY_SIZE(Array_MP_8723B_AGC_TAB);
u32 *Array = Array_MP_8723B_AGC_TAB;
for (i = 0; i < ArrayLen; i += 2) {
u32 v1 = Array[i];
u32 v2 = Array[i+1];
/* This (offset, data) pair doesn't care the condition. */
if (v1 < 0x40000000) {
odm_ConfigBB_AGC_8723B(pDM_Odm, v1, bMaskDWord, v2);
continue;
} else {
/* This line is the beginning of branch. */
bool bMatched = true;
u8 cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
if (cCond == COND_ELSE) { /* ELSE, ENDIF */
bMatched = true;
READ_NEXT_PAIR(v1, v2, i);
} else if (!CheckPositive(pDM_Odm, v1, v2)) {
bMatched = false;
READ_NEXT_PAIR(v1, v2, i);
READ_NEXT_PAIR(v1, v2, i);
} else {
READ_NEXT_PAIR(v1, v2, i);
if (!CheckNegative(pDM_Odm, v1, v2))
bMatched = false;
else
bMatched = true;
READ_NEXT_PAIR(v1, v2, i);
}
if (!bMatched) {
/* Condition isn't matched.
* Discard the following (offset, data) pairs.
*/
while (v1 < 0x40000000 && i < ArrayLen-2)
READ_NEXT_PAIR(v1, v2, i);
i -= 2; /* prevent from for-loop += 2 */
} else {
/* Configure matched pairs and skip to end of if-else. */
while (v1 < 0x40000000 && i < ArrayLen-2) {
odm_ConfigBB_AGC_8723B(pDM_Odm, v1, bMaskDWord, v2);
READ_NEXT_PAIR(v1, v2, i);
}
/* Keeps reading until ENDIF. */
cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
while (cCond != COND_ENDIF && i < ArrayLen-2) {
READ_NEXT_PAIR(v1, v2, i);
cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
}
}
}
}
}
/******************************************************************************
* PHY_REG.TXT
******************************************************************************/
static u32 Array_MP_8723B_PHY_REG[] = {
0x800, 0x80040000,
0x804, 0x00000003,
0x808, 0x0000FC00,
0x80C, 0x0000000A,
0x810, 0x10001331,
0x814, 0x020C3D10,
0x818, 0x02200385,
0x81C, 0x00000000,
0x820, 0x01000100,
0x824, 0x00190204,
0x828, 0x00000000,
0x82C, 0x00000000,
0x830, 0x00000000,
0x834, 0x00000000,
0x838, 0x00000000,
0x83C, 0x00000000,
0x840, 0x00010000,
0x844, 0x00000000,
0x848, 0x00000000,
0x84C, 0x00000000,
0x850, 0x00000000,
0x854, 0x00000000,
0x858, 0x569A11A9,
0x85C, 0x01000014,
0x860, 0x66F60110,
0x864, 0x061F0649,
0x868, 0x00000000,
0x86C, 0x27272700,
0x870, 0x07000760,
0x874, 0x25004000,
0x878, 0x00000808,
0x87C, 0x00000000,
0x880, 0xB0000C1C,
0x884, 0x00000001,
0x888, 0x00000000,
0x88C, 0xCCC000C0,
0x890, 0x00000800,
0x894, 0xFFFFFFFE,
0x898, 0x40302010,
0x89C, 0x00706050,
0x900, 0x00000000,
0x904, 0x00000023,
0x908, 0x00000000,
0x90C, 0x81121111,
0x910, 0x00000002,
0x914, 0x00000201,
0xA00, 0x00D047C8,
0xA04, 0x80FF800C,
0xA08, 0x8C838300,
0xA0C, 0x2E7F120F,
0xA10, 0x9500BB78,
0xA14, 0x1114D028,
0xA18, 0x00881117,
0xA1C, 0x89140F00,
0xA20, 0x1A1B0000,
0xA24, 0x090E1317,
0xA28, 0x00000204,
0xA2C, 0x00D30000,
0xA70, 0x101FBF00,
0xA74, 0x00000007,
0xA78, 0x00000900,
0xA7C, 0x225B0606,
0xA80, 0x21806490,
0xB2C, 0x00000000,
0xC00, 0x48071D40,
0xC04, 0x03A05611,
0xC08, 0x000000E4,
0xC0C, 0x6C6C6C6C,
0xC10, 0x08800000,
0xC14, 0x40000100,
0xC18, 0x08800000,
0xC1C, 0x40000100,
0xC20, 0x00000000,
0xC24, 0x00000000,
0xC28, 0x00000000,
0xC2C, 0x00000000,
0xC30, 0x69E9AC44,
0xC34, 0x469652AF,
0xC38, 0x49795994,
0xC3C, 0x0A97971C,
0xC40, 0x1F7C403F,
0xC44, 0x000100B7,
0xC48, 0xEC020107,
0xC4C, 0x007F037F,
0xC50, 0x69553420,
0xC54, 0x43BC0094,
0xC58, 0x00013149,
0xC5C, 0x00250492,
0xC60, 0x00000000,
0xC64, 0x7112848B,
0xC68, 0x47C00BFF,
0xC6C, 0x00000036,
0xC70, 0x2C7F000D,
0xC74, 0x020610DB,
0xC78, 0x0000001F,
0xC7C, 0x00B91612,
0xC80, 0x390000E4,
0xC84, 0x20F60000,
0xC88, 0x40000100,
0xC8C, 0x20200000,
0xC90, 0x00020E1A,
0xC94, 0x00000000,
0xC98, 0x00020E1A,
0xC9C, 0x00007F7F,
0xCA0, 0x00000000,
0xCA4, 0x000300A0,
0xCA8, 0x00000000,
0xCAC, 0x00000000,
0xCB0, 0x00000000,
0xCB4, 0x00000000,
0xCB8, 0x00000000,
0xCBC, 0x28000000,
0xCC0, 0x00000000,
0xCC4, 0x00000000,
0xCC8, 0x00000000,
0xCCC, 0x00000000,
0xCD0, 0x00000000,
0xCD4, 0x00000000,
0xCD8, 0x64B22427,
0xCDC, 0x00766932,
0xCE0, 0x00222222,
0xCE4, 0x00000000,
0xCE8, 0x37644302,
0xCEC, 0x2F97D40C,
0xD00, 0x00000740,
0xD04, 0x40020401,
0xD08, 0x0000907F,
0xD0C, 0x20010201,
0xD10, 0xA0633333,
0xD14, 0x3333BC53,
0xD18, 0x7A8F5B6F,
0xD2C, 0xCC979975,
0xD30, 0x00000000,
0xD34, 0x80608000,
0xD38, 0x00000000,
0xD3C, 0x00127353,
0xD40, 0x00000000,
0xD44, 0x00000000,
0xD48, 0x00000000,
0xD4C, 0x00000000,
0xD50, 0x6437140A,
0xD54, 0x00000000,
0xD58, 0x00000282,
0xD5C, 0x30032064,
0xD60, 0x4653DE68,
0xD64, 0x04518A3C,
0xD68, 0x00002101,
0xD6C, 0x2A201C16,
0xD70, 0x1812362E,
0xD74, 0x322C2220,
0xD78, 0x000E3C24,
0xE00, 0x2D2D2D2D,
0xE04, 0x2D2D2D2D,
0xE08, 0x0390272D,
0xE10, 0x2D2D2D2D,
0xE14, 0x2D2D2D2D,
0xE18, 0x2D2D2D2D,
0xE1C, 0x2D2D2D2D,
0xE28, 0x00000000,
0xE30, 0x1000DC1F,
0xE34, 0x10008C1F,
0xE38, 0x02140102,
0xE3C, 0x681604C2,
0xE40, 0x01007C00,
0xE44, 0x01004800,
0xE48, 0xFB000000,
0xE4C, 0x000028D1,
0xE50, 0x1000DC1F,
0xE54, 0x10008C1F,
0xE58, 0x02140102,
0xE5C, 0x28160D05,
0xE60, 0x00000008,
0xE68, 0x001B2556,
0xE6C, 0x00C00096,
0xE70, 0x00C00096,
0xE74, 0x01000056,
0xE78, 0x01000014,
0xE7C, 0x01000056,
0xE80, 0x01000014,
0xE84, 0x00C00096,
0xE88, 0x01000056,
0xE8C, 0x00C00096,
0xED0, 0x00C00096,
0xED4, 0x00C00096,
0xED8, 0x00C00096,
0xEDC, 0x000000D6,
0xEE0, 0x000000D6,
0xEEC, 0x01C00016,
0xF14, 0x00000003,
0xF4C, 0x00000000,
0xF00, 0x00000300,
0x820, 0x01000100,
0x800, 0x83040000,
};
void ODM_ReadAndConfig_MP_8723B_PHY_REG(struct dm_odm_t *pDM_Odm)
{
u32 i = 0;
u32 ArrayLen = ARRAY_SIZE(Array_MP_8723B_PHY_REG);
u32 *Array = Array_MP_8723B_PHY_REG;
for (i = 0; i < ArrayLen; i += 2) {
u32 v1 = Array[i];
u32 v2 = Array[i+1];
/* This (offset, data) pair doesn't care the condition. */
if (v1 < 0x40000000) {
odm_ConfigBB_PHY_8723B(pDM_Odm, v1, bMaskDWord, v2);
continue;
} else {
/* This line is the beginning of branch. */
bool bMatched = true;
u8 cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
if (cCond == COND_ELSE) { /* ELSE, ENDIF */
bMatched = true;
READ_NEXT_PAIR(v1, v2, i);
} else if (!CheckPositive(pDM_Odm, v1, v2)) {
bMatched = false;
READ_NEXT_PAIR(v1, v2, i);
READ_NEXT_PAIR(v1, v2, i);
} else {
READ_NEXT_PAIR(v1, v2, i);
if (!CheckNegative(pDM_Odm, v1, v2))
bMatched = false;
else
bMatched = true;
READ_NEXT_PAIR(v1, v2, i);
}
if (!bMatched) {
/* Condition isn't matched.
* Discard the following (offset, data) pairs.
*/
while (v1 < 0x40000000 && i < ArrayLen-2)
READ_NEXT_PAIR(v1, v2, i);
i -= 2; /* prevent from for-loop += 2 */
} else { /* Configure matched pairs and skip to end of if-else. */
while (v1 < 0x40000000 && i < ArrayLen-2) {
odm_ConfigBB_PHY_8723B(pDM_Odm, v1, bMaskDWord, v2);
READ_NEXT_PAIR(v1, v2, i);
}
/* Keeps reading until ENDIF. */
cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
while (cCond != COND_ENDIF && i < ArrayLen-2) {
READ_NEXT_PAIR(v1, v2, i);
cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
}
}
}
}
}
/******************************************************************************
* PHY_REG_PG.TXT
******************************************************************************/
static u32 Array_MP_8723B_PHY_REG_PG[] = {
0, 0x00000e08, 0x0000ff00, 0x00003800,
0, 0x0000086c, 0xffffff00, 0x32343600,
0, 0x00000e00, 0xffffffff, 0x40424444,
0, 0x00000e04, 0xffffffff, 0x28323638,
0, 0x00000e10, 0xffffffff, 0x38404244,
0, 0x00000e14, 0xffffffff, 0x26303436
};
void ODM_ReadAndConfig_MP_8723B_PHY_REG_PG(struct dm_odm_t *pDM_Odm)
{
u32 i = 0;
u32 *Array = Array_MP_8723B_PHY_REG_PG;
pDM_Odm->PhyRegPgVersion = 1;
pDM_Odm->PhyRegPgValueType = PHY_REG_PG_EXACT_VALUE;
for (i = 0; i < ARRAY_SIZE(Array_MP_8723B_PHY_REG_PG); i += 4) {
u32 v1 = Array[i];
u32 v2 = Array[i+1];
u32 v3 = Array[i+2];
u32 v4 = Array[i+3];
odm_ConfigBB_PHY_REG_PG_8723B(pDM_Odm, v1, v2, v3, v4);
}
}
| linux-master | drivers/staging/rtl8723bs/hal/HalHWImg8723B_BB.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <linux/kernel.h>
#include "odm_precomp.h"
static bool CheckPositive(
struct dm_odm_t *pDM_Odm, const u32 Condition1, const u32 Condition2
)
{
u8 _BoardType =
((pDM_Odm->BoardType & BIT4) >> 4) << 0 | /* _GLNA */
((pDM_Odm->BoardType & BIT3) >> 3) << 1 | /* _GPA */
((pDM_Odm->BoardType & BIT7) >> 7) << 2 | /* _ALNA */
((pDM_Odm->BoardType & BIT6) >> 6) << 3 | /* _APA */
((pDM_Odm->BoardType & BIT2) >> 2) << 4; /* _BT */
u32 cond1 = Condition1, cond2 = Condition2;
u32 driver1 =
pDM_Odm->CutVersion << 24 |
pDM_Odm->SupportPlatform << 16 |
pDM_Odm->PackageType << 12 |
pDM_Odm->SupportInterface << 8 |
_BoardType;
u32 driver2 =
pDM_Odm->TypeGLNA << 0 |
pDM_Odm->TypeGPA << 8 |
pDM_Odm->TypeALNA << 16 |
pDM_Odm->TypeAPA << 24;
/* Value Defined Check =============== */
/* QFN Type [15:12] and Cut Version [27:24] need to do value check */
if (((cond1 & 0x0000F000) != 0) && ((cond1 & 0x0000F000) != (driver1 & 0x0000F000)))
return false;
if (((cond1 & 0x0F000000) != 0) && ((cond1 & 0x0F000000) != (driver1 & 0x0F000000)))
return false;
/* Bit Defined Check ================ */
/* We don't care [31:28] and [23:20] */
/* */
cond1 &= 0x000F0FFF;
driver1 &= 0x000F0FFF;
if ((cond1 & driver1) == cond1) {
u32 bitMask = 0;
if ((cond1 & 0x0F) == 0) /* BoardType is DONTCARE */
return true;
if ((cond1 & BIT0) != 0) /* GLNA */
bitMask |= 0x000000FF;
if ((cond1 & BIT1) != 0) /* GPA */
bitMask |= 0x0000FF00;
if ((cond1 & BIT2) != 0) /* ALNA */
bitMask |= 0x00FF0000;
if ((cond1 & BIT3) != 0) /* APA */
bitMask |= 0xFF000000;
if ((cond2 & bitMask) == (driver2 & bitMask)) /* BoardType of each RF path is matched */
return true;
}
return false;
}
static bool CheckNegative(
struct dm_odm_t *pDM_Odm, const u32 Condition1, const u32 Condition2
)
{
return true;
}
/******************************************************************************
* MAC_REG.TXT
******************************************************************************/
static u32 Array_MP_8723B_MAC_REG[] = {
0x02F, 0x00000030,
0x035, 0x00000000,
0x039, 0x00000008,
0x04E, 0x000000E0,
0x064, 0x00000000,
0x067, 0x00000020,
0x428, 0x0000000A,
0x429, 0x00000010,
0x430, 0x00000000,
0x431, 0x00000000,
0x432, 0x00000000,
0x433, 0x00000001,
0x434, 0x00000004,
0x435, 0x00000005,
0x436, 0x00000007,
0x437, 0x00000008,
0x43C, 0x00000004,
0x43D, 0x00000005,
0x43E, 0x00000007,
0x43F, 0x00000008,
0x440, 0x0000005D,
0x441, 0x00000001,
0x442, 0x00000000,
0x444, 0x00000010,
0x445, 0x00000000,
0x446, 0x00000000,
0x447, 0x00000000,
0x448, 0x00000000,
0x449, 0x000000F0,
0x44A, 0x0000000F,
0x44B, 0x0000003E,
0x44C, 0x00000010,
0x44D, 0x00000000,
0x44E, 0x00000000,
0x44F, 0x00000000,
0x450, 0x00000000,
0x451, 0x000000F0,
0x452, 0x0000000F,
0x453, 0x00000000,
0x456, 0x0000005E,
0x460, 0x00000066,
0x461, 0x00000066,
0x4C8, 0x000000FF,
0x4C9, 0x00000008,
0x4CC, 0x000000FF,
0x4CD, 0x000000FF,
0x4CE, 0x00000001,
0x500, 0x00000026,
0x501, 0x000000A2,
0x502, 0x0000002F,
0x503, 0x00000000,
0x504, 0x00000028,
0x505, 0x000000A3,
0x506, 0x0000005E,
0x507, 0x00000000,
0x508, 0x0000002B,
0x509, 0x000000A4,
0x50A, 0x0000005E,
0x50B, 0x00000000,
0x50C, 0x0000004F,
0x50D, 0x000000A4,
0x50E, 0x00000000,
0x50F, 0x00000000,
0x512, 0x0000001C,
0x514, 0x0000000A,
0x516, 0x0000000A,
0x525, 0x0000004F,
0x550, 0x00000010,
0x551, 0x00000010,
0x559, 0x00000002,
0x55C, 0x00000050,
0x55D, 0x000000FF,
0x605, 0x00000030,
0x608, 0x0000000E,
0x609, 0x0000002A,
0x620, 0x000000FF,
0x621, 0x000000FF,
0x622, 0x000000FF,
0x623, 0x000000FF,
0x624, 0x000000FF,
0x625, 0x000000FF,
0x626, 0x000000FF,
0x627, 0x000000FF,
0x638, 0x00000050,
0x63C, 0x0000000A,
0x63D, 0x0000000A,
0x63E, 0x0000000E,
0x63F, 0x0000000E,
0x640, 0x00000040,
0x642, 0x00000040,
0x643, 0x00000000,
0x652, 0x000000C8,
0x66E, 0x00000005,
0x700, 0x00000021,
0x701, 0x00000043,
0x702, 0x00000065,
0x703, 0x00000087,
0x708, 0x00000021,
0x709, 0x00000043,
0x70A, 0x00000065,
0x70B, 0x00000087,
0x765, 0x00000018,
0x76E, 0x00000004,
};
void ODM_ReadAndConfig_MP_8723B_MAC_REG(struct dm_odm_t *pDM_Odm)
{
u32 i = 0;
u32 ArrayLen = ARRAY_SIZE(Array_MP_8723B_MAC_REG);
u32 *Array = Array_MP_8723B_MAC_REG;
for (i = 0; i < ArrayLen; i += 2) {
u32 v1 = Array[i];
u32 v2 = Array[i+1];
/* This (offset, data) pair doesn't care the condition. */
if (v1 < 0x40000000) {
odm_ConfigMAC_8723B(pDM_Odm, v1, (u8)v2);
continue;
} else {
/* This line is the beginning of branch. */
bool bMatched = true;
u8 cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
if (cCond == COND_ELSE) { /* ELSE, ENDIF */
bMatched = true;
READ_NEXT_PAIR(v1, v2, i);
} else if (!CheckPositive(pDM_Odm, v1, v2)) {
bMatched = false;
READ_NEXT_PAIR(v1, v2, i);
READ_NEXT_PAIR(v1, v2, i);
} else {
READ_NEXT_PAIR(v1, v2, i);
if (!CheckNegative(pDM_Odm, v1, v2))
bMatched = false;
else
bMatched = true;
READ_NEXT_PAIR(v1, v2, i);
}
if (!bMatched) {
/* Condition isn't matched. Discard the following (offset, data) pairs. */
while (v1 < 0x40000000 && i < ArrayLen-2)
READ_NEXT_PAIR(v1, v2, i);
i -= 2; /* prevent from for-loop += 2 */
} else { /* Configure matched pairs and skip to end of if-else. */
while (v1 < 0x40000000 && i < ArrayLen-2) {
odm_ConfigMAC_8723B(pDM_Odm, v1, (u8)v2);
READ_NEXT_PAIR(v1, v2, i);
}
/* Keeps reading until ENDIF. */
cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
while (cCond != COND_ENDIF && i < ArrayLen-2) {
READ_NEXT_PAIR(v1, v2, i);
cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
}
}
}
}
}
| linux-master | drivers/staging/rtl8723bs/hal/HalHWImg8723B_MAC.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include "odm_precomp.h"
static void odm_SetCrystalCap(void *pDM_VOID, u8 CrystalCap)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct cfo_tracking *pCfoTrack = &pDM_Odm->DM_CfoTrack;
if (pCfoTrack->CrystalCap == CrystalCap)
return;
pCfoTrack->CrystalCap = CrystalCap;
/* 0x2C[23:18] = 0x2C[17:12] = CrystalCap */
CrystalCap = CrystalCap & 0x3F;
PHY_SetBBReg(
pDM_Odm->Adapter,
REG_MAC_PHY_CTRL,
0x00FFF000,
(CrystalCap | (CrystalCap << 6))
);
}
static u8 odm_GetDefaultCrytaltalCap(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct adapter *Adapter = pDM_Odm->Adapter;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
return pHalData->CrystalCap & 0x3f;
}
static void odm_SetATCStatus(void *pDM_VOID, bool ATCStatus)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct cfo_tracking *pCfoTrack = &pDM_Odm->DM_CfoTrack;
if (pCfoTrack->bATCStatus == ATCStatus)
return;
PHY_SetBBReg(
pDM_Odm->Adapter,
ODM_REG(BB_ATC, pDM_Odm),
ODM_BIT(BB_ATC, pDM_Odm),
ATCStatus
);
pCfoTrack->bATCStatus = ATCStatus;
}
static bool odm_GetATCStatus(void *pDM_VOID)
{
bool ATCStatus;
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
ATCStatus = (bool)PHY_QueryBBReg(
pDM_Odm->Adapter,
ODM_REG(BB_ATC, pDM_Odm),
ODM_BIT(BB_ATC, pDM_Odm)
);
return ATCStatus;
}
void ODM_CfoTrackingReset(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct cfo_tracking *pCfoTrack = &pDM_Odm->DM_CfoTrack;
pCfoTrack->DefXCap = odm_GetDefaultCrytaltalCap(pDM_Odm);
pCfoTrack->bAdjust = true;
odm_SetCrystalCap(pDM_Odm, pCfoTrack->DefXCap);
odm_SetATCStatus(pDM_Odm, true);
}
void ODM_CfoTrackingInit(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct cfo_tracking *pCfoTrack = &pDM_Odm->DM_CfoTrack;
pCfoTrack->DefXCap =
pCfoTrack->CrystalCap = odm_GetDefaultCrytaltalCap(pDM_Odm);
pCfoTrack->bATCStatus = odm_GetATCStatus(pDM_Odm);
pCfoTrack->bAdjust = true;
}
void ODM_CfoTracking(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct cfo_tracking *pCfoTrack = &pDM_Odm->DM_CfoTrack;
int CFO_kHz_A, CFO_ave = 0;
int CFO_ave_diff;
int CrystalCap = (int)pCfoTrack->CrystalCap;
u8 Adjust_Xtal = 1;
/* 4 Support ability */
if (!(pDM_Odm->SupportAbility & ODM_BB_CFO_TRACKING)) {
return;
}
if (!pDM_Odm->bLinked || !pDM_Odm->bOneEntryOnly) {
/* 4 No link or more than one entry */
ODM_CfoTrackingReset(pDM_Odm);
} else {
/* 3 1. CFO Tracking */
/* 4 1.1 No new packet */
if (pCfoTrack->packetCount == pCfoTrack->packetCount_pre) {
return;
}
pCfoTrack->packetCount_pre = pCfoTrack->packetCount;
/* 4 1.2 Calculate CFO */
CFO_kHz_A = (int)(pCfoTrack->CFO_tail[0] * 3125) / 1280;
CFO_ave = CFO_kHz_A;
/* 4 1.3 Avoid abnormal large CFO */
CFO_ave_diff =
(pCfoTrack->CFO_ave_pre >= CFO_ave) ?
(pCfoTrack->CFO_ave_pre-CFO_ave) :
(CFO_ave-pCfoTrack->CFO_ave_pre);
if (
CFO_ave_diff > 20 &&
pCfoTrack->largeCFOHit == 0 &&
!pCfoTrack->bAdjust
) {
pCfoTrack->largeCFOHit = 1;
return;
} else
pCfoTrack->largeCFOHit = 0;
pCfoTrack->CFO_ave_pre = CFO_ave;
/* 4 1.4 Dynamic Xtal threshold */
if (pCfoTrack->bAdjust == false) {
if (CFO_ave > CFO_TH_XTAL_HIGH || CFO_ave < (-CFO_TH_XTAL_HIGH))
pCfoTrack->bAdjust = true;
} else {
if (CFO_ave < CFO_TH_XTAL_LOW && CFO_ave > (-CFO_TH_XTAL_LOW))
pCfoTrack->bAdjust = false;
}
/* 4 1.5 BT case: Disable CFO tracking */
if (pDM_Odm->bBtEnabled) {
pCfoTrack->bAdjust = false;
odm_SetCrystalCap(pDM_Odm, pCfoTrack->DefXCap);
}
/* 4 1.6 Big jump */
if (pCfoTrack->bAdjust) {
if (CFO_ave > CFO_TH_XTAL_LOW)
Adjust_Xtal = Adjust_Xtal+((CFO_ave-CFO_TH_XTAL_LOW)>>2);
else if (CFO_ave < (-CFO_TH_XTAL_LOW))
Adjust_Xtal = Adjust_Xtal+((CFO_TH_XTAL_LOW-CFO_ave)>>2);
}
/* 4 1.7 Adjust Crystal Cap. */
if (pCfoTrack->bAdjust) {
if (CFO_ave > CFO_TH_XTAL_LOW)
CrystalCap = CrystalCap + Adjust_Xtal;
else if (CFO_ave < (-CFO_TH_XTAL_LOW))
CrystalCap = CrystalCap - Adjust_Xtal;
if (CrystalCap > 0x3f)
CrystalCap = 0x3f;
else if (CrystalCap < 0)
CrystalCap = 0;
odm_SetCrystalCap(pDM_Odm, (u8)CrystalCap);
}
/* 3 2. Dynamic ATC switch */
if (CFO_ave < CFO_TH_ATC && CFO_ave > -CFO_TH_ATC) {
odm_SetATCStatus(pDM_Odm, false);
} else {
odm_SetATCStatus(pDM_Odm, true);
}
}
}
void odm_parsing_cfo(void *dm_void, void *pkt_info_void, s8 *cfotail)
{
struct dm_odm_t *dm_odm = (struct dm_odm_t *)dm_void;
struct odm_packet_info *pkt_info = pkt_info_void;
struct cfo_tracking *cfo_track = &dm_odm->DM_CfoTrack;
u8 i;
if (!(dm_odm->SupportAbility & ODM_BB_CFO_TRACKING))
return;
if (pkt_info->station_id != 0) {
/*
* 3 Update CFO report for path-A & path-B
* Only paht-A and path-B have CFO tail and short CFO
*/
for (i = RF_PATH_A; i <= RF_PATH_B; i++)
cfo_track->CFO_tail[i] = (int)cfotail[i];
/* 3 Update packet counter */
if (cfo_track->packetCount == 0xffffffff)
cfo_track->packetCount = 0;
else
cfo_track->packetCount++;
}
}
| linux-master | drivers/staging/rtl8723bs/hal/odm_CfoTracking.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include "odm_precomp.h"
/* Global var */
u32 OFDMSwingTable[OFDM_TABLE_SIZE] = {
0x7f8001fe, /* 0, +6.0dB */
0x788001e2, /* 1, +5.5dB */
0x71c001c7, /* 2, +5.0dB */
0x6b8001ae, /* 3, +4.5dB */
0x65400195, /* 4, +4.0dB */
0x5fc0017f, /* 5, +3.5dB */
0x5a400169, /* 6, +3.0dB */
0x55400155, /* 7, +2.5dB */
0x50800142, /* 8, +2.0dB */
0x4c000130, /* 9, +1.5dB */
0x47c0011f, /* 10, +1.0dB */
0x43c0010f, /* 11, +0.5dB */
0x40000100, /* 12, +0dB */
0x3c8000f2, /* 13, -0.5dB */
0x390000e4, /* 14, -1.0dB */
0x35c000d7, /* 15, -1.5dB */
0x32c000cb, /* 16, -2.0dB */
0x300000c0, /* 17, -2.5dB */
0x2d4000b5, /* 18, -3.0dB */
0x2ac000ab, /* 19, -3.5dB */
0x288000a2, /* 20, -4.0dB */
0x26000098, /* 21, -4.5dB */
0x24000090, /* 22, -5.0dB */
0x22000088, /* 23, -5.5dB */
0x20000080, /* 24, -6.0dB */
0x1e400079, /* 25, -6.5dB */
0x1c800072, /* 26, -7.0dB */
0x1b00006c, /* 27. -7.5dB */
0x19800066, /* 28, -8.0dB */
0x18000060, /* 29, -8.5dB */
0x16c0005b, /* 30, -9.0dB */
0x15800056, /* 31, -9.5dB */
0x14400051, /* 32, -10.0dB */
0x1300004c, /* 33, -10.5dB */
0x12000048, /* 34, -11.0dB */
0x11000044, /* 35, -11.5dB */
0x10000040, /* 36, -12.0dB */
};
u8 CCKSwingTable_Ch1_Ch13[CCK_TABLE_SIZE][8] = {
{0x36, 0x35, 0x2e, 0x25, 0x1c, 0x12, 0x09, 0x04}, /* 0, +0dB */
{0x33, 0x32, 0x2b, 0x23, 0x1a, 0x11, 0x08, 0x04}, /* 1, -0.5dB */
{0x30, 0x2f, 0x29, 0x21, 0x19, 0x10, 0x08, 0x03}, /* 2, -1.0dB */
{0x2d, 0x2d, 0x27, 0x1f, 0x18, 0x0f, 0x08, 0x03}, /* 3, -1.5dB */
{0x2b, 0x2a, 0x25, 0x1e, 0x16, 0x0e, 0x07, 0x03}, /* 4, -2.0dB */
{0x28, 0x28, 0x22, 0x1c, 0x15, 0x0d, 0x07, 0x03}, /* 5, -2.5dB */
{0x26, 0x25, 0x21, 0x1b, 0x14, 0x0d, 0x06, 0x03}, /* 6, -3.0dB */
{0x24, 0x23, 0x1f, 0x19, 0x13, 0x0c, 0x06, 0x03}, /* 7, -3.5dB */
{0x22, 0x21, 0x1d, 0x18, 0x11, 0x0b, 0x06, 0x02}, /* 8, -4.0dB */
{0x20, 0x20, 0x1b, 0x16, 0x11, 0x08, 0x05, 0x02}, /* 9, -4.5dB */
{0x1f, 0x1e, 0x1a, 0x15, 0x10, 0x0a, 0x05, 0x02}, /* 10, -5.0dB */
{0x1d, 0x1c, 0x18, 0x14, 0x0f, 0x0a, 0x05, 0x02}, /* 11, -5.5dB */
{0x1b, 0x1a, 0x17, 0x13, 0x0e, 0x09, 0x04, 0x02}, /* 12, -6.0dB <== default */
{0x1a, 0x19, 0x16, 0x12, 0x0d, 0x09, 0x04, 0x02}, /* 13, -6.5dB */
{0x18, 0x17, 0x15, 0x11, 0x0c, 0x08, 0x04, 0x02}, /* 14, -7.0dB */
{0x17, 0x16, 0x13, 0x10, 0x0c, 0x08, 0x04, 0x02}, /* 15, -7.5dB */
{0x16, 0x15, 0x12, 0x0f, 0x0b, 0x07, 0x04, 0x01}, /* 16, -8.0dB */
{0x14, 0x14, 0x11, 0x0e, 0x0b, 0x07, 0x03, 0x02}, /* 17, -8.5dB */
{0x13, 0x13, 0x10, 0x0d, 0x0a, 0x06, 0x03, 0x01}, /* 18, -9.0dB */
{0x12, 0x12, 0x0f, 0x0c, 0x09, 0x06, 0x03, 0x01}, /* 19, -9.5dB */
{0x11, 0x11, 0x0f, 0x0c, 0x09, 0x06, 0x03, 0x01}, /* 20, -10.0dB */
{0x10, 0x10, 0x0e, 0x0b, 0x08, 0x05, 0x03, 0x01}, /* 21, -10.5dB */
{0x0f, 0x0f, 0x0d, 0x0b, 0x08, 0x05, 0x03, 0x01}, /* 22, -11.0dB */
{0x0e, 0x0e, 0x0c, 0x0a, 0x08, 0x05, 0x02, 0x01}, /* 23, -11.5dB */
{0x0d, 0x0d, 0x0c, 0x0a, 0x07, 0x05, 0x02, 0x01}, /* 24, -12.0dB */
{0x0d, 0x0c, 0x0b, 0x09, 0x07, 0x04, 0x02, 0x01}, /* 25, -12.5dB */
{0x0c, 0x0c, 0x0a, 0x09, 0x06, 0x04, 0x02, 0x01}, /* 26, -13.0dB */
{0x0b, 0x0b, 0x0a, 0x08, 0x06, 0x04, 0x02, 0x01}, /* 27, -13.5dB */
{0x0b, 0x0a, 0x09, 0x08, 0x06, 0x04, 0x02, 0x01}, /* 28, -14.0dB */
{0x0a, 0x0a, 0x09, 0x07, 0x05, 0x03, 0x02, 0x01}, /* 29, -14.5dB */
{0x0a, 0x09, 0x08, 0x07, 0x05, 0x03, 0x02, 0x01}, /* 30, -15.0dB */
{0x09, 0x09, 0x08, 0x06, 0x05, 0x03, 0x01, 0x01}, /* 31, -15.5dB */
{0x09, 0x08, 0x07, 0x06, 0x04, 0x03, 0x01, 0x01} /* 32, -16.0dB */
};
u8 CCKSwingTable_Ch14[CCK_TABLE_SIZE][8] = {
{0x36, 0x35, 0x2e, 0x1b, 0x00, 0x00, 0x00, 0x00}, /* 0, +0dB */
{0x33, 0x32, 0x2b, 0x19, 0x00, 0x00, 0x00, 0x00}, /* 1, -0.5dB */
{0x30, 0x2f, 0x29, 0x18, 0x00, 0x00, 0x00, 0x00}, /* 2, -1.0dB */
{0x2d, 0x2d, 0x17, 0x17, 0x00, 0x00, 0x00, 0x00}, /* 3, -1.5dB */
{0x2b, 0x2a, 0x25, 0x15, 0x00, 0x00, 0x00, 0x00}, /* 4, -2.0dB */
{0x28, 0x28, 0x24, 0x14, 0x00, 0x00, 0x00, 0x00}, /* 5, -2.5dB */
{0x26, 0x25, 0x21, 0x13, 0x00, 0x00, 0x00, 0x00}, /* 6, -3.0dB */
{0x24, 0x23, 0x1f, 0x12, 0x00, 0x00, 0x00, 0x00}, /* 7, -3.5dB */
{0x22, 0x21, 0x1d, 0x11, 0x00, 0x00, 0x00, 0x00}, /* 8, -4.0dB */
{0x20, 0x20, 0x1b, 0x10, 0x00, 0x00, 0x00, 0x00}, /* 9, -4.5dB */
{0x1f, 0x1e, 0x1a, 0x0f, 0x00, 0x00, 0x00, 0x00}, /* 10, -5.0dB */
{0x1d, 0x1c, 0x18, 0x0e, 0x00, 0x00, 0x00, 0x00}, /* 11, -5.5dB */
{0x1b, 0x1a, 0x17, 0x0e, 0x00, 0x00, 0x00, 0x00}, /* 12, -6.0dB <== default */
{0x1a, 0x19, 0x16, 0x0d, 0x00, 0x00, 0x00, 0x00}, /* 13, -6.5dB */
{0x18, 0x17, 0x15, 0x0c, 0x00, 0x00, 0x00, 0x00}, /* 14, -7.0dB */
{0x17, 0x16, 0x13, 0x0b, 0x00, 0x00, 0x00, 0x00}, /* 15, -7.5dB */
{0x16, 0x15, 0x12, 0x0b, 0x00, 0x00, 0x00, 0x00}, /* 16, -8.0dB */
{0x14, 0x14, 0x11, 0x0a, 0x00, 0x00, 0x00, 0x00}, /* 17, -8.5dB */
{0x13, 0x13, 0x10, 0x0a, 0x00, 0x00, 0x00, 0x00}, /* 18, -9.0dB */
{0x12, 0x12, 0x0f, 0x09, 0x00, 0x00, 0x00, 0x00}, /* 19, -9.5dB */
{0x11, 0x11, 0x0f, 0x09, 0x00, 0x00, 0x00, 0x00}, /* 20, -10.0dB */
{0x10, 0x10, 0x0e, 0x08, 0x00, 0x00, 0x00, 0x00}, /* 21, -10.5dB */
{0x0f, 0x0f, 0x0d, 0x08, 0x00, 0x00, 0x00, 0x00}, /* 22, -11.0dB */
{0x0e, 0x0e, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00}, /* 23, -11.5dB */
{0x0d, 0x0d, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00}, /* 24, -12.0dB */
{0x0d, 0x0c, 0x0b, 0x06, 0x00, 0x00, 0x00, 0x00}, /* 25, -12.5dB */
{0x0c, 0x0c, 0x0a, 0x06, 0x00, 0x00, 0x00, 0x00}, /* 26, -13.0dB */
{0x0b, 0x0b, 0x0a, 0x06, 0x00, 0x00, 0x00, 0x00}, /* 27, -13.5dB */
{0x0b, 0x0a, 0x09, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 28, -14.0dB */
{0x0a, 0x0a, 0x09, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 29, -14.5dB */
{0x0a, 0x09, 0x08, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 30, -15.0dB */
{0x09, 0x09, 0x08, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 31, -15.5dB */
{0x09, 0x08, 0x07, 0x04, 0x00, 0x00, 0x00, 0x00} /* 32, -16.0dB */
};
u32 OFDMSwingTable_New[OFDM_TABLE_SIZE] = {
0x0b40002d, /* 0, -15.0dB */
0x0c000030, /* 1, -14.5dB */
0x0cc00033, /* 2, -14.0dB */
0x0d800036, /* 3, -13.5dB */
0x0e400039, /* 4, -13.0dB */
0x0f00003c, /* 5, -12.5dB */
0x10000040, /* 6, -12.0dB */
0x11000044, /* 7, -11.5dB */
0x12000048, /* 8, -11.0dB */
0x1300004c, /* 9, -10.5dB */
0x14400051, /* 10, -10.0dB */
0x15800056, /* 11, -9.5dB */
0x16c0005b, /* 12, -9.0dB */
0x18000060, /* 13, -8.5dB */
0x19800066, /* 14, -8.0dB */
0x1b00006c, /* 15, -7.5dB */
0x1c800072, /* 16, -7.0dB */
0x1e400079, /* 17, -6.5dB */
0x20000080, /* 18, -6.0dB */
0x22000088, /* 19, -5.5dB */
0x24000090, /* 20, -5.0dB */
0x26000098, /* 21, -4.5dB */
0x288000a2, /* 22, -4.0dB */
0x2ac000ab, /* 23, -3.5dB */
0x2d4000b5, /* 24, -3.0dB */
0x300000c0, /* 25, -2.5dB */
0x32c000cb, /* 26, -2.0dB */
0x35c000d7, /* 27, -1.5dB */
0x390000e4, /* 28, -1.0dB */
0x3c8000f2, /* 29, -0.5dB */
0x40000100, /* 30, +0dB */
0x43c0010f, /* 31, +0.5dB */
0x47c0011f, /* 32, +1.0dB */
0x4c000130, /* 33, +1.5dB */
0x50800142, /* 34, +2.0dB */
0x55400155, /* 35, +2.5dB */
0x5a400169, /* 36, +3.0dB */
0x5fc0017f, /* 37, +3.5dB */
0x65400195, /* 38, +4.0dB */
0x6b8001ae, /* 39, +4.5dB */
0x71c001c7, /* 40, +5.0dB */
0x788001e2, /* 41, +5.5dB */
0x7f8001fe /* 42, +6.0dB */
};
u8 CCKSwingTable_Ch1_Ch13_New[CCK_TABLE_SIZE][8] = {
{0x09, 0x08, 0x07, 0x06, 0x04, 0x03, 0x01, 0x01}, /* 0, -16.0dB */
{0x09, 0x09, 0x08, 0x06, 0x05, 0x03, 0x01, 0x01}, /* 1, -15.5dB */
{0x0a, 0x09, 0x08, 0x07, 0x05, 0x03, 0x02, 0x01}, /* 2, -15.0dB */
{0x0a, 0x0a, 0x09, 0x07, 0x05, 0x03, 0x02, 0x01}, /* 3, -14.5dB */
{0x0b, 0x0a, 0x09, 0x08, 0x06, 0x04, 0x02, 0x01}, /* 4, -14.0dB */
{0x0b, 0x0b, 0x0a, 0x08, 0x06, 0x04, 0x02, 0x01}, /* 5, -13.5dB */
{0x0c, 0x0c, 0x0a, 0x09, 0x06, 0x04, 0x02, 0x01}, /* 6, -13.0dB */
{0x0d, 0x0c, 0x0b, 0x09, 0x07, 0x04, 0x02, 0x01}, /* 7, -12.5dB */
{0x0d, 0x0d, 0x0c, 0x0a, 0x07, 0x05, 0x02, 0x01}, /* 8, -12.0dB */
{0x0e, 0x0e, 0x0c, 0x0a, 0x08, 0x05, 0x02, 0x01}, /* 9, -11.5dB */
{0x0f, 0x0f, 0x0d, 0x0b, 0x08, 0x05, 0x03, 0x01}, /* 10, -11.0dB */
{0x10, 0x10, 0x0e, 0x0b, 0x08, 0x05, 0x03, 0x01}, /* 11, -10.5dB */
{0x11, 0x11, 0x0f, 0x0c, 0x09, 0x06, 0x03, 0x01}, /* 12, -10.0dB */
{0x12, 0x12, 0x0f, 0x0c, 0x09, 0x06, 0x03, 0x01}, /* 13, -9.5dB */
{0x13, 0x13, 0x10, 0x0d, 0x0a, 0x06, 0x03, 0x01}, /* 14, -9.0dB */
{0x14, 0x14, 0x11, 0x0e, 0x0b, 0x07, 0x03, 0x02}, /* 15, -8.5dB */
{0x16, 0x15, 0x12, 0x0f, 0x0b, 0x07, 0x04, 0x01}, /* 16, -8.0dB */
{0x17, 0x16, 0x13, 0x10, 0x0c, 0x08, 0x04, 0x02}, /* 17, -7.5dB */
{0x18, 0x17, 0x15, 0x11, 0x0c, 0x08, 0x04, 0x02}, /* 18, -7.0dB */
{0x1a, 0x19, 0x16, 0x12, 0x0d, 0x09, 0x04, 0x02}, /* 19, -6.5dB */
{0x1b, 0x1a, 0x17, 0x13, 0x0e, 0x09, 0x04, 0x02}, /* 20, -6.0dB */
{0x1d, 0x1c, 0x18, 0x14, 0x0f, 0x0a, 0x05, 0x02}, /* 21, -5.5dB */
{0x1f, 0x1e, 0x1a, 0x15, 0x10, 0x0a, 0x05, 0x02}, /* 22, -5.0dB */
{0x20, 0x20, 0x1b, 0x16, 0x11, 0x08, 0x05, 0x02}, /* 23, -4.5dB */
{0x22, 0x21, 0x1d, 0x18, 0x11, 0x0b, 0x06, 0x02}, /* 24, -4.0dB */
{0x24, 0x23, 0x1f, 0x19, 0x13, 0x0c, 0x06, 0x03}, /* 25, -3.5dB */
{0x26, 0x25, 0x21, 0x1b, 0x14, 0x0d, 0x06, 0x03}, /* 26, -3.0dB */
{0x28, 0x28, 0x22, 0x1c, 0x15, 0x0d, 0x07, 0x03}, /* 27, -2.5dB */
{0x2b, 0x2a, 0x25, 0x1e, 0x16, 0x0e, 0x07, 0x03}, /* 28, -2.0dB */
{0x2d, 0x2d, 0x27, 0x1f, 0x18, 0x0f, 0x08, 0x03}, /* 29, -1.5dB */
{0x30, 0x2f, 0x29, 0x21, 0x19, 0x10, 0x08, 0x03}, /* 30, -1.0dB */
{0x33, 0x32, 0x2b, 0x23, 0x1a, 0x11, 0x08, 0x04}, /* 31, -0.5dB */
{0x36, 0x35, 0x2e, 0x25, 0x1c, 0x12, 0x09, 0x04} /* 32, +0dB */
};
u8 CCKSwingTable_Ch14_New[CCK_TABLE_SIZE][8] = {
{0x09, 0x08, 0x07, 0x04, 0x00, 0x00, 0x00, 0x00}, /* 0, -16.0dB */
{0x09, 0x09, 0x08, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 1, -15.5dB */
{0x0a, 0x09, 0x08, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 2, -15.0dB */
{0x0a, 0x0a, 0x09, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 3, -14.5dB */
{0x0b, 0x0a, 0x09, 0x05, 0x00, 0x00, 0x00, 0x00}, /* 4, -14.0dB */
{0x0b, 0x0b, 0x0a, 0x06, 0x00, 0x00, 0x00, 0x00}, /* 5, -13.5dB */
{0x0c, 0x0c, 0x0a, 0x06, 0x00, 0x00, 0x00, 0x00}, /* 6, -13.0dB */
{0x0d, 0x0c, 0x0b, 0x06, 0x00, 0x00, 0x00, 0x00}, /* 7, -12.5dB */
{0x0d, 0x0d, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00}, /* 8, -12.0dB */
{0x0e, 0x0e, 0x0c, 0x07, 0x00, 0x00, 0x00, 0x00}, /* 9, -11.5dB */
{0x0f, 0x0f, 0x0d, 0x08, 0x00, 0x00, 0x00, 0x00}, /* 10, -11.0dB */
{0x10, 0x10, 0x0e, 0x08, 0x00, 0x00, 0x00, 0x00}, /* 11, -10.5dB */
{0x11, 0x11, 0x0f, 0x09, 0x00, 0x00, 0x00, 0x00}, /* 12, -10.0dB */
{0x12, 0x12, 0x0f, 0x09, 0x00, 0x00, 0x00, 0x00}, /* 13, -9.5dB */
{0x13, 0x13, 0x10, 0x0a, 0x00, 0x00, 0x00, 0x00}, /* 14, -9.0dB */
{0x14, 0x14, 0x11, 0x0a, 0x00, 0x00, 0x00, 0x00}, /* 15, -8.5dB */
{0x16, 0x15, 0x12, 0x0b, 0x00, 0x00, 0x00, 0x00}, /* 16, -8.0dB */
{0x17, 0x16, 0x13, 0x0b, 0x00, 0x00, 0x00, 0x00}, /* 17, -7.5dB */
{0x18, 0x17, 0x15, 0x0c, 0x00, 0x00, 0x00, 0x00}, /* 18, -7.0dB */
{0x1a, 0x19, 0x16, 0x0d, 0x00, 0x00, 0x00, 0x00}, /* 19, -6.5dB */
{0x1b, 0x1a, 0x17, 0x0e, 0x00, 0x00, 0x00, 0x00}, /* 20, -6.0dB */
{0x1d, 0x1c, 0x18, 0x0e, 0x00, 0x00, 0x00, 0x00}, /* 21, -5.5dB */
{0x1f, 0x1e, 0x1a, 0x0f, 0x00, 0x00, 0x00, 0x00}, /* 22, -5.0dB */
{0x20, 0x20, 0x1b, 0x10, 0x00, 0x00, 0x00, 0x00}, /* 23, -4.5dB */
{0x22, 0x21, 0x1d, 0x11, 0x00, 0x00, 0x00, 0x00}, /* 24, -4.0dB */
{0x24, 0x23, 0x1f, 0x12, 0x00, 0x00, 0x00, 0x00}, /* 25, -3.5dB */
{0x26, 0x25, 0x21, 0x13, 0x00, 0x00, 0x00, 0x00}, /* 26, -3.0dB */
{0x28, 0x28, 0x24, 0x14, 0x00, 0x00, 0x00, 0x00}, /* 27, -2.5dB */
{0x2b, 0x2a, 0x25, 0x15, 0x00, 0x00, 0x00, 0x00}, /* 28, -2.0dB */
{0x2d, 0x2d, 0x17, 0x17, 0x00, 0x00, 0x00, 0x00}, /* 29, -1.5dB */
{0x30, 0x2f, 0x29, 0x18, 0x00, 0x00, 0x00, 0x00}, /* 30, -1.0dB */
{0x33, 0x32, 0x2b, 0x19, 0x00, 0x00, 0x00, 0x00}, /* 31, -0.5dB */
{0x36, 0x35, 0x2e, 0x1b, 0x00, 0x00, 0x00, 0x00} /* 32, +0dB */
};
u32 TxScalingTable_Jaguar[TXSCALE_TABLE_SIZE] = {
0x081, /* 0, -12.0dB */
0x088, /* 1, -11.5dB */
0x090, /* 2, -11.0dB */
0x099, /* 3, -10.5dB */
0x0A2, /* 4, -10.0dB */
0x0AC, /* 5, -9.5dB */
0x0B6, /* 6, -9.0dB */
0x0C0, /* 7, -8.5dB */
0x0CC, /* 8, -8.0dB */
0x0D8, /* 9, -7.5dB */
0x0E5, /* 10, -7.0dB */
0x0F2, /* 11, -6.5dB */
0x101, /* 12, -6.0dB */
0x110, /* 13, -5.5dB */
0x120, /* 14, -5.0dB */
0x131, /* 15, -4.5dB */
0x143, /* 16, -4.0dB */
0x156, /* 17, -3.5dB */
0x16A, /* 18, -3.0dB */
0x180, /* 19, -2.5dB */
0x197, /* 20, -2.0dB */
0x1AF, /* 21, -1.5dB */
0x1C8, /* 22, -1.0dB */
0x1E3, /* 23, -0.5dB */
0x200, /* 24, +0 dB */
0x21E, /* 25, +0.5dB */
0x23E, /* 26, +1.0dB */
0x261, /* 27, +1.5dB */
0x285, /* 28, +2.0dB */
0x2AB, /* 29, +2.5dB */
0x2D3, /* 30, +3.0dB */
0x2FE, /* 31, +3.5dB */
0x32B, /* 32, +4.0dB */
0x35C, /* 33, +4.5dB */
0x38E, /* 34, +5.0dB */
0x3C4, /* 35, +5.5dB */
0x3FE /* 36, +6.0dB */
};
/* Remove Edca by Yu Chen */
static void odm_CommonInfoSelfInit(struct dm_odm_t *pDM_Odm)
{
pDM_Odm->bCckHighPower = (bool) PHY_QueryBBReg(pDM_Odm->Adapter, ODM_REG(CCK_RPT_FORMAT, pDM_Odm), ODM_BIT(CCK_RPT_FORMAT, pDM_Odm));
pDM_Odm->RFPathRxEnable = (u8) PHY_QueryBBReg(pDM_Odm->Adapter, ODM_REG(BB_RX_PATH, pDM_Odm), ODM_BIT(BB_RX_PATH, pDM_Odm));
pDM_Odm->TxRate = 0xFF;
}
static void odm_CommonInfoSelfUpdate(struct dm_odm_t *pDM_Odm)
{
u8 EntryCnt = 0;
u8 i;
PSTA_INFO_T pEntry;
if (*(pDM_Odm->pBandWidth) == ODM_BW40M) {
if (*(pDM_Odm->pSecChOffset) == 1)
pDM_Odm->ControlChannel = *(pDM_Odm->pChannel)-2;
else if (*(pDM_Odm->pSecChOffset) == 2)
pDM_Odm->ControlChannel = *(pDM_Odm->pChannel)+2;
} else
pDM_Odm->ControlChannel = *(pDM_Odm->pChannel);
for (i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++) {
pEntry = pDM_Odm->pODM_StaInfo[i];
if (IS_STA_VALID(pEntry))
EntryCnt++;
}
if (EntryCnt == 1)
pDM_Odm->bOneEntryOnly = true;
else
pDM_Odm->bOneEntryOnly = false;
}
static void odm_CmnInfoInit_Debug(struct dm_odm_t *pDM_Odm)
{
}
static void odm_BasicDbgMessage(struct dm_odm_t *pDM_Odm)
{
}
/* 3 ============================================================ */
/* 3 RATR MASK */
/* 3 ============================================================ */
/* 3 ============================================================ */
/* 3 Rate Adaptive */
/* 3 ============================================================ */
static void odm_RateAdaptiveMaskInit(struct dm_odm_t *pDM_Odm)
{
struct odm_rate_adaptive *pOdmRA = &pDM_Odm->RateAdaptive;
pOdmRA->Type = DM_Type_ByDriver;
if (pOdmRA->Type == DM_Type_ByDriver)
pDM_Odm->bUseRAMask = true;
else
pDM_Odm->bUseRAMask = false;
pOdmRA->RATRState = DM_RATR_STA_INIT;
pOdmRA->LdpcThres = 35;
pOdmRA->bUseLdpc = false;
pOdmRA->HighRSSIThresh = 50;
pOdmRA->LowRSSIThresh = 20;
}
u32 ODM_Get_Rate_Bitmap(
struct dm_odm_t *pDM_Odm,
u32 macid,
u32 ra_mask,
u8 rssi_level
)
{
PSTA_INFO_T pEntry;
u32 rate_bitmap = 0;
u8 WirelessMode;
pEntry = pDM_Odm->pODM_StaInfo[macid];
if (!IS_STA_VALID(pEntry))
return ra_mask;
WirelessMode = pEntry->wireless_mode;
switch (WirelessMode) {
case ODM_WM_B:
if (ra_mask & 0x0000000c) /* 11M or 5.5M enable */
rate_bitmap = 0x0000000d;
else
rate_bitmap = 0x0000000f;
break;
case (ODM_WM_G):
if (rssi_level == DM_RATR_STA_HIGH)
rate_bitmap = 0x00000f00;
else
rate_bitmap = 0x00000ff0;
break;
case (ODM_WM_B|ODM_WM_G):
if (rssi_level == DM_RATR_STA_HIGH)
rate_bitmap = 0x00000f00;
else if (rssi_level == DM_RATR_STA_MIDDLE)
rate_bitmap = 0x00000ff0;
else
rate_bitmap = 0x00000ff5;
break;
case (ODM_WM_B|ODM_WM_G|ODM_WM_N24G):
case (ODM_WM_B|ODM_WM_N24G):
case (ODM_WM_G|ODM_WM_N24G):
if (rssi_level == DM_RATR_STA_HIGH)
rate_bitmap = 0x000f0000;
else if (rssi_level == DM_RATR_STA_MIDDLE)
rate_bitmap = 0x000ff000;
else {
if (*(pDM_Odm->pBandWidth) == ODM_BW40M)
rate_bitmap = 0x000ff015;
else
rate_bitmap = 0x000ff005;
}
break;
default:
rate_bitmap = 0x0fffffff;
break;
}
return ra_mask & rate_bitmap;
}
static void odm_RefreshRateAdaptiveMaskCE(struct dm_odm_t *pDM_Odm)
{
u8 i;
struct adapter *padapter = pDM_Odm->Adapter;
if (padapter->bDriverStopped) {
return;
}
if (!pDM_Odm->bUseRAMask) {
return;
}
for (i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++) {
PSTA_INFO_T pstat = pDM_Odm->pODM_StaInfo[i];
if (IS_STA_VALID(pstat)) {
if (is_multicast_ether_addr(pstat->hwaddr)) /* if (psta->mac_id == 1) */
continue;
if (true == ODM_RAStateCheck(pDM_Odm, pstat->rssi_stat.UndecoratedSmoothedPWDB, false, &pstat->rssi_level)) {
/* printk("RSSI:%d, RSSI_LEVEL:%d\n", pstat->rssi_stat.UndecoratedSmoothedPWDB, pstat->rssi_level); */
rtw_hal_update_ra_mask(pstat, pstat->rssi_level);
}
}
}
}
/*-----------------------------------------------------------------------------
* Function: odm_RefreshRateAdaptiveMask()
*
* Overview: Update rate table mask according to rssi
*
* Input: NONE
*
* Output: NONE
*
* Return: NONE
*
* Revised History:
*When Who Remark
*05/27/2009 hpfan Create Version 0.
*
* --------------------------------------------------------------------------
*/
static void odm_RefreshRateAdaptiveMask(struct dm_odm_t *pDM_Odm)
{
if (!(pDM_Odm->SupportAbility & ODM_BB_RA_MASK)) {
return;
}
odm_RefreshRateAdaptiveMaskCE(pDM_Odm);
}
/* Return Value: bool */
/* - true: RATRState is changed. */
bool ODM_RAStateCheck(
struct dm_odm_t *pDM_Odm,
s32 RSSI,
bool bForceUpdate,
u8 *pRATRState
)
{
struct odm_rate_adaptive *pRA = &pDM_Odm->RateAdaptive;
const u8 GoUpGap = 5;
u8 HighRSSIThreshForRA = pRA->HighRSSIThresh;
u8 LowRSSIThreshForRA = pRA->LowRSSIThresh;
u8 RATRState;
/* Threshold Adjustment: */
/* when RSSI state trends to go up one or two levels, make sure RSSI is high enough. */
/* Here GoUpGap is added to solve the boundary's level alternation issue. */
switch (*pRATRState) {
case DM_RATR_STA_INIT:
case DM_RATR_STA_HIGH:
break;
case DM_RATR_STA_MIDDLE:
HighRSSIThreshForRA += GoUpGap;
break;
case DM_RATR_STA_LOW:
HighRSSIThreshForRA += GoUpGap;
LowRSSIThreshForRA += GoUpGap;
break;
default:
netdev_dbg(pDM_Odm->Adapter->pnetdev,
"wrong rssi level setting %d !", *pRATRState);
break;
}
/* Decide RATRState by RSSI. */
if (RSSI > HighRSSIThreshForRA)
RATRState = DM_RATR_STA_HIGH;
else if (RSSI > LowRSSIThreshForRA)
RATRState = DM_RATR_STA_MIDDLE;
else
RATRState = DM_RATR_STA_LOW;
/* printk("==>%s, RATRState:0x%02x , RSSI:%d\n", __func__, RATRState, RSSI); */
if (*pRATRState != RATRState || bForceUpdate) {
*pRATRState = RATRState;
return true;
}
return false;
}
/* */
/* 3 ============================================================ */
/* 3 RSSI Monitor */
/* 3 ============================================================ */
static void odm_RSSIMonitorInit(struct dm_odm_t *pDM_Odm)
{
struct ra_t *pRA_Table = &pDM_Odm->DM_RA_Table;
pRA_Table->firstconnect = false;
}
static void FindMinimumRSSI(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_priv *pdmpriv = &pHalData->dmpriv;
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
/* 1 1.Determine the minimum RSSI */
if (
(pDM_Odm->bLinked != true) &&
(pdmpriv->EntryMinUndecoratedSmoothedPWDB == 0)
) {
pdmpriv->MinUndecoratedPWDBForDM = 0;
} else
pdmpriv->MinUndecoratedPWDBForDM = pdmpriv->EntryMinUndecoratedSmoothedPWDB;
}
static void odm_RSSIMonitorCheckCE(struct dm_odm_t *pDM_Odm)
{
struct adapter *Adapter = pDM_Odm->Adapter;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct dm_priv *pdmpriv = &pHalData->dmpriv;
int i;
int tmpEntryMaxPWDB = 0, tmpEntryMinPWDB = 0xff;
u8 sta_cnt = 0;
u32 PWDB_rssi[NUM_STA] = {0};/* 0~15]:MACID, [16~31]:PWDB_rssi */
struct ra_t *pRA_Table = &pDM_Odm->DM_RA_Table;
if (pDM_Odm->bLinked != true)
return;
pRA_Table->firstconnect = pDM_Odm->bLinked;
/* if (check_fwstate(&Adapter->mlmepriv, WIFI_AP_STATE|WIFI_ADHOC_STATE|WIFI_ADHOC_MASTER_STATE) == true) */
{
struct sta_info *psta;
for (i = 0; i < ODM_ASSOCIATE_ENTRY_NUM; i++) {
psta = pDM_Odm->pODM_StaInfo[i];
if (IS_STA_VALID(psta)) {
if (is_multicast_ether_addr(psta->hwaddr)) /* if (psta->mac_id == 1) */
continue;
if (psta->rssi_stat.UndecoratedSmoothedPWDB == (-1))
continue;
if (psta->rssi_stat.UndecoratedSmoothedPWDB < tmpEntryMinPWDB)
tmpEntryMinPWDB = psta->rssi_stat.UndecoratedSmoothedPWDB;
if (psta->rssi_stat.UndecoratedSmoothedPWDB > tmpEntryMaxPWDB)
tmpEntryMaxPWDB = psta->rssi_stat.UndecoratedSmoothedPWDB;
if (psta->rssi_stat.UndecoratedSmoothedPWDB != (-1))
PWDB_rssi[sta_cnt++] = (psta->mac_id | (psta->rssi_stat.UndecoratedSmoothedPWDB<<16));
}
}
/* printk("%s ==> sta_cnt(%d)\n", __func__, sta_cnt); */
for (i = 0; i < sta_cnt; i++) {
if (PWDB_rssi[i] != (0)) {
if (pHalData->fw_ractrl == true)/* Report every sta's RSSI to FW */
rtl8723b_set_rssi_cmd(Adapter, (u8 *)(&PWDB_rssi[i]));
}
}
}
if (tmpEntryMaxPWDB != 0) /* If associated entry is found */
pdmpriv->EntryMaxUndecoratedSmoothedPWDB = tmpEntryMaxPWDB;
else
pdmpriv->EntryMaxUndecoratedSmoothedPWDB = 0;
if (tmpEntryMinPWDB != 0xff) /* If associated entry is found */
pdmpriv->EntryMinUndecoratedSmoothedPWDB = tmpEntryMinPWDB;
else
pdmpriv->EntryMinUndecoratedSmoothedPWDB = 0;
FindMinimumRSSI(Adapter);/* get pdmpriv->MinUndecoratedPWDBForDM */
pDM_Odm->RSSI_Min = pdmpriv->MinUndecoratedPWDBForDM;
/* ODM_CmnInfoUpdate(&pHalData->odmpriv , ODM_CMNINFO_RSSI_MIN, pdmpriv->MinUndecoratedPWDBForDM); */
}
static void odm_RSSIMonitorCheck(struct dm_odm_t *pDM_Odm)
{
if (!(pDM_Odm->SupportAbility & ODM_BB_RSSI_MONITOR))
return;
odm_RSSIMonitorCheckCE(pDM_Odm);
} /* odm_RSSIMonitorCheck */
/* 3 ============================================================ */
/* 3 SW Antenna Diversity */
/* 3 ============================================================ */
static void odm_SwAntDetectInit(struct dm_odm_t *pDM_Odm)
{
struct swat_t *pDM_SWAT_Table = &pDM_Odm->DM_SWAT_Table;
pDM_SWAT_Table->SWAS_NoLink_BK_Reg92c = rtw_read32(pDM_Odm->Adapter, rDPDT_control);
pDM_SWAT_Table->PreAntenna = MAIN_ANT;
pDM_SWAT_Table->CurAntenna = MAIN_ANT;
pDM_SWAT_Table->SWAS_NoLink_State = 0;
}
/* 3 ============================================================ */
/* 3 Tx Power Tracking */
/* 3 ============================================================ */
static u8 getSwingIndex(struct dm_odm_t *pDM_Odm)
{
struct adapter *Adapter = pDM_Odm->Adapter;
u8 i = 0;
u32 bbSwing;
u32 swingTableSize;
u32 *pSwingTable;
bbSwing = PHY_QueryBBReg(Adapter, rOFDM0_XATxIQImbalance, 0xFFC00000);
pSwingTable = OFDMSwingTable_New;
swingTableSize = OFDM_TABLE_SIZE;
for (i = 0; i < swingTableSize; ++i) {
u32 tableValue = pSwingTable[i];
if (tableValue >= 0x100000)
tableValue >>= 22;
if (bbSwing == tableValue)
break;
}
return i;
}
void odm_TXPowerTrackingInit(struct dm_odm_t *pDM_Odm)
{
u8 defaultSwingIndex = getSwingIndex(pDM_Odm);
u8 p = 0;
struct adapter *Adapter = pDM_Odm->Adapter;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct dm_priv *pdmpriv = &pHalData->dmpriv;
pdmpriv->bTXPowerTracking = true;
pdmpriv->TXPowercount = 0;
pdmpriv->bTXPowerTrackingInit = false;
if (*(pDM_Odm->mp_mode) != 1)
pdmpriv->TxPowerTrackControl = true;
else
pdmpriv->TxPowerTrackControl = false;
/* pDM_Odm->RFCalibrateInfo.TxPowerTrackControl = true; */
pDM_Odm->RFCalibrateInfo.ThermalValue = pHalData->EEPROMThermalMeter;
pDM_Odm->RFCalibrateInfo.ThermalValue_IQK = pHalData->EEPROMThermalMeter;
pDM_Odm->RFCalibrateInfo.ThermalValue_LCK = pHalData->EEPROMThermalMeter;
/* The index of "0 dB" in SwingTable. */
pDM_Odm->DefaultOfdmIndex = (defaultSwingIndex >= OFDM_TABLE_SIZE) ? 30 : defaultSwingIndex;
pDM_Odm->DefaultCckIndex = 20;
pDM_Odm->BbSwingIdxCckBase = pDM_Odm->DefaultCckIndex;
pDM_Odm->RFCalibrateInfo.CCK_index = pDM_Odm->DefaultCckIndex;
for (p = RF_PATH_A; p < MAX_RF_PATH; ++p) {
pDM_Odm->BbSwingIdxOfdmBase[p] = pDM_Odm->DefaultOfdmIndex;
pDM_Odm->RFCalibrateInfo.OFDM_index[p] = pDM_Odm->DefaultOfdmIndex;
pDM_Odm->RFCalibrateInfo.DeltaPowerIndex[p] = 0;
pDM_Odm->RFCalibrateInfo.DeltaPowerIndexLast[p] = 0;
pDM_Odm->RFCalibrateInfo.PowerIndexOffset[p] = 0;
}
}
void ODM_TXPowerTrackingCheck(struct dm_odm_t *pDM_Odm)
{
struct adapter *Adapter = pDM_Odm->Adapter;
if (!(pDM_Odm->SupportAbility & ODM_RF_TX_PWR_TRACK))
return;
if (!pDM_Odm->RFCalibrateInfo.TM_Trigger) { /* at least delay 1 sec */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_T_METER_NEW, (BIT17 | BIT16), 0x03);
pDM_Odm->RFCalibrateInfo.TM_Trigger = 1;
return;
} else {
ODM_TXPowerTrackingCallback_ThermalMeter(Adapter);
pDM_Odm->RFCalibrateInfo.TM_Trigger = 0;
}
}
/* */
/* 3 Export Interface */
/* */
/* */
/* 2011/09/21 MH Add to describe different team necessary resource allocate?? */
/* */
void ODM_DMInit(struct dm_odm_t *pDM_Odm)
{
odm_CommonInfoSelfInit(pDM_Odm);
odm_CmnInfoInit_Debug(pDM_Odm);
odm_DIGInit(pDM_Odm);
odm_NHMCounterStatisticsInit(pDM_Odm);
odm_AdaptivityInit(pDM_Odm);
odm_RateAdaptiveMaskInit(pDM_Odm);
ODM_CfoTrackingInit(pDM_Odm);
ODM_EdcaTurboInit(pDM_Odm);
odm_RSSIMonitorInit(pDM_Odm);
odm_TXPowerTrackingInit(pDM_Odm);
ODM_ClearTxPowerTrackingState(pDM_Odm);
odm_DynamicBBPowerSavingInit(pDM_Odm);
odm_DynamicTxPowerInit(pDM_Odm);
odm_SwAntDetectInit(pDM_Odm);
}
/* */
/* 2011/09/20 MH This is the entry pointer for all team to execute HW out source DM. */
/* You can not add any dummy function here, be care, you can only use DM structure */
/* to perform any new ODM_DM. */
/* */
void ODM_DMWatchdog(struct dm_odm_t *pDM_Odm)
{
odm_CommonInfoSelfUpdate(pDM_Odm);
odm_BasicDbgMessage(pDM_Odm);
odm_FalseAlarmCounterStatistics(pDM_Odm);
odm_NHMCounterStatistics(pDM_Odm);
odm_RSSIMonitorCheck(pDM_Odm);
/* For CE Platform(SPRD or Tablet) */
/* 8723A or 8189ES platform */
/* NeilChen--2012--08--24-- */
/* Fix Leave LPS issue */
if ((adapter_to_pwrctl(pDM_Odm->Adapter)->pwr_mode != PS_MODE_ACTIVE) /* in LPS mode */
/* */
/* (pDM_Odm->SupportICType & (ODM_RTL8723A))|| */
/* (pDM_Odm->SupportICType & (ODM_RTL8188E) &&(&&(((pDM_Odm->SupportInterface == ODM_ITRF_SDIO))) */
/* */
) {
odm_DIGbyRSSI_LPS(pDM_Odm);
} else
odm_DIG(pDM_Odm);
{
struct dig_t *pDM_DigTable = &pDM_Odm->DM_DigTable;
odm_Adaptivity(pDM_Odm, pDM_DigTable->CurIGValue);
}
odm_CCKPacketDetectionThresh(pDM_Odm);
if (*(pDM_Odm->pbPowerSaving) == true)
return;
odm_RefreshRateAdaptiveMask(pDM_Odm);
odm_EdcaTurboCheck(pDM_Odm);
ODM_CfoTracking(pDM_Odm);
ODM_TXPowerTrackingCheck(pDM_Odm);
/* odm_EdcaTurboCheck(pDM_Odm); */
/* 2010.05.30 LukeLee: For CE platform, files in IC subfolders may not be included to be compiled, */
/* so compile flags must be left here to prevent from compile errors */
pDM_Odm->PhyDbgInfo.NumQryBeaconPkt = 0;
}
/* */
/* Init /.. Fixed HW value. Only init time. */
/* */
void ODM_CmnInfoInit(struct dm_odm_t *pDM_Odm, enum odm_cmninfo_e CmnInfo, u32 Value)
{
/* */
/* This section is used for init value */
/* */
switch (CmnInfo) {
/* */
/* Fixed ODM value. */
/* */
case ODM_CMNINFO_ABILITY:
pDM_Odm->SupportAbility = (u32)Value;
break;
case ODM_CMNINFO_PLATFORM:
pDM_Odm->SupportPlatform = (u8)Value;
break;
case ODM_CMNINFO_INTERFACE:
pDM_Odm->SupportInterface = (u8)Value;
break;
case ODM_CMNINFO_IC_TYPE:
pDM_Odm->SupportICType = Value;
break;
case ODM_CMNINFO_CUT_VER:
pDM_Odm->CutVersion = (u8)Value;
break;
case ODM_CMNINFO_FAB_VER:
pDM_Odm->FabVersion = (u8)Value;
break;
case ODM_CMNINFO_RFE_TYPE:
pDM_Odm->RFEType = (u8)Value;
break;
case ODM_CMNINFO_RF_ANTENNA_TYPE:
pDM_Odm->AntDivType = (u8)Value;
break;
case ODM_CMNINFO_PACKAGE_TYPE:
pDM_Odm->PackageType = (u8)Value;
break;
case ODM_CMNINFO_EXT_LNA:
pDM_Odm->ExtLNA = (u8)Value;
break;
case ODM_CMNINFO_EXT_PA:
pDM_Odm->ExtPA = (u8)Value;
break;
case ODM_CMNINFO_GPA:
pDM_Odm->TypeGPA = (enum odm_type_gpa_e)Value;
break;
case ODM_CMNINFO_APA:
pDM_Odm->TypeAPA = (enum odm_type_apa_e)Value;
break;
case ODM_CMNINFO_GLNA:
pDM_Odm->TypeGLNA = (enum odm_type_glna_e)Value;
break;
case ODM_CMNINFO_ALNA:
pDM_Odm->TypeALNA = (enum odm_type_alna_e)Value;
break;
case ODM_CMNINFO_EXT_TRSW:
pDM_Odm->ExtTRSW = (u8)Value;
break;
case ODM_CMNINFO_PATCH_ID:
pDM_Odm->PatchID = (u8)Value;
break;
case ODM_CMNINFO_BINHCT_TEST:
pDM_Odm->bInHctTest = (bool)Value;
break;
case ODM_CMNINFO_BWIFI_TEST:
pDM_Odm->bWIFITest = (bool)Value;
break;
case ODM_CMNINFO_SMART_CONCURRENT:
pDM_Odm->bDualMacSmartConcurrent = (bool)Value;
break;
/* To remove the compiler warning, must add an empty default statement to handle the other values. */
default:
/* do nothing */
break;
}
}
void ODM_CmnInfoHook(struct dm_odm_t *pDM_Odm, enum odm_cmninfo_e CmnInfo, void *pValue)
{
/* */
/* Hook call by reference pointer. */
/* */
switch (CmnInfo) {
/* */
/* Dynamic call by reference pointer. */
/* */
case ODM_CMNINFO_MAC_PHY_MODE:
pDM_Odm->pMacPhyMode = pValue;
break;
case ODM_CMNINFO_TX_UNI:
pDM_Odm->pNumTxBytesUnicast = pValue;
break;
case ODM_CMNINFO_RX_UNI:
pDM_Odm->pNumRxBytesUnicast = pValue;
break;
case ODM_CMNINFO_WM_MODE:
pDM_Odm->pwirelessmode = pValue;
break;
case ODM_CMNINFO_SEC_CHNL_OFFSET:
pDM_Odm->pSecChOffset = pValue;
break;
case ODM_CMNINFO_SEC_MODE:
pDM_Odm->pSecurity = pValue;
break;
case ODM_CMNINFO_BW:
pDM_Odm->pBandWidth = pValue;
break;
case ODM_CMNINFO_CHNL:
pDM_Odm->pChannel = pValue;
break;
case ODM_CMNINFO_DMSP_GET_VALUE:
pDM_Odm->pbGetValueFromOtherMac = pValue;
break;
case ODM_CMNINFO_BUDDY_ADAPTOR:
pDM_Odm->pBuddyAdapter = pValue;
break;
case ODM_CMNINFO_DMSP_IS_MASTER:
pDM_Odm->pbMasterOfDMSP = pValue;
break;
case ODM_CMNINFO_SCAN:
pDM_Odm->pbScanInProcess = pValue;
break;
case ODM_CMNINFO_POWER_SAVING:
pDM_Odm->pbPowerSaving = pValue;
break;
case ODM_CMNINFO_ONE_PATH_CCA:
pDM_Odm->pOnePathCCA = pValue;
break;
case ODM_CMNINFO_DRV_STOP:
pDM_Odm->pbDriverStopped = pValue;
break;
case ODM_CMNINFO_PNP_IN:
pDM_Odm->pbDriverIsGoingToPnpSetPowerSleep = pValue;
break;
case ODM_CMNINFO_INIT_ON:
pDM_Odm->pinit_adpt_in_progress = pValue;
break;
case ODM_CMNINFO_ANT_TEST:
pDM_Odm->pAntennaTest = pValue;
break;
case ODM_CMNINFO_NET_CLOSED:
pDM_Odm->pbNet_closed = pValue;
break;
case ODM_CMNINFO_FORCED_RATE:
pDM_Odm->pForcedDataRate = pValue;
break;
case ODM_CMNINFO_FORCED_IGI_LB:
pDM_Odm->pu1ForcedIgiLb = pValue;
break;
case ODM_CMNINFO_MP_MODE:
pDM_Odm->mp_mode = pValue;
break;
/* case ODM_CMNINFO_RTSTA_AID: */
/* pDM_Odm->pAidMap = (u8 *)pValue; */
/* break; */
/* case ODM_CMNINFO_BT_COEXIST: */
/* pDM_Odm->BTCoexist = (bool *)pValue; */
/* case ODM_CMNINFO_STA_STATUS: */
/* pDM_Odm->pODM_StaInfo[] = (PSTA_INFO_T)pValue; */
/* break; */
/* case ODM_CMNINFO_PHY_STATUS: */
/* pDM_Odm->pPhyInfo = (ODM_PHY_INFO *)pValue; */
/* break; */
/* case ODM_CMNINFO_MAC_STATUS: */
/* pDM_Odm->pMacInfo = (struct odm_mac_status_info *)pValue; */
/* break; */
/* To remove the compiler warning, must add an empty default statement to handle the other values. */
default:
/* do nothing */
break;
}
}
void ODM_CmnInfoPtrArrayHook(
struct dm_odm_t *pDM_Odm,
enum odm_cmninfo_e CmnInfo,
u16 Index,
void *pValue
)
{
/* */
/* Hook call by reference pointer. */
/* */
switch (CmnInfo) {
/* */
/* Dynamic call by reference pointer. */
/* */
case ODM_CMNINFO_STA_STATUS:
pDM_Odm->pODM_StaInfo[Index] = (PSTA_INFO_T)pValue;
break;
/* To remove the compiler warning, must add an empty default statement to handle the other values. */
default:
/* do nothing */
break;
}
}
/* */
/* Update Band/CHannel/.. The values are dynamic but non-per-packet. */
/* */
void ODM_CmnInfoUpdate(struct dm_odm_t *pDM_Odm, u32 CmnInfo, u64 Value)
{
/* */
/* This init variable may be changed in run time. */
/* */
switch (CmnInfo) {
case ODM_CMNINFO_LINK_IN_PROGRESS:
pDM_Odm->bLinkInProcess = (bool)Value;
break;
case ODM_CMNINFO_ABILITY:
pDM_Odm->SupportAbility = (u32)Value;
break;
case ODM_CMNINFO_WIFI_DIRECT:
pDM_Odm->bWIFI_Direct = (bool)Value;
break;
case ODM_CMNINFO_WIFI_DISPLAY:
pDM_Odm->bWIFI_Display = (bool)Value;
break;
case ODM_CMNINFO_LINK:
pDM_Odm->bLinked = (bool)Value;
break;
case ODM_CMNINFO_STATION_STATE:
pDM_Odm->bsta_state = (bool)Value;
break;
case ODM_CMNINFO_RSSI_MIN:
pDM_Odm->RSSI_Min = (u8)Value;
break;
case ODM_CMNINFO_RA_THRESHOLD_HIGH:
pDM_Odm->RateAdaptive.HighRSSIThresh = (u8)Value;
break;
case ODM_CMNINFO_RA_THRESHOLD_LOW:
pDM_Odm->RateAdaptive.LowRSSIThresh = (u8)Value;
break;
/* The following is for BT HS mode and BT coexist mechanism. */
case ODM_CMNINFO_BT_ENABLED:
pDM_Odm->bBtEnabled = (bool)Value;
break;
case ODM_CMNINFO_BT_HS_CONNECT_PROCESS:
pDM_Odm->bBtConnectProcess = (bool)Value;
break;
case ODM_CMNINFO_BT_HS_RSSI:
pDM_Odm->btHsRssi = (u8)Value;
break;
case ODM_CMNINFO_BT_OPERATION:
pDM_Odm->bBtHsOperation = (bool)Value;
break;
case ODM_CMNINFO_BT_LIMITED_DIG:
pDM_Odm->bBtLimitedDig = (bool)Value;
break;
case ODM_CMNINFO_BT_DISABLE_EDCA:
pDM_Odm->bBtDisableEdcaTurbo = (bool)Value;
break;
/*
case ODM_CMNINFO_OP_MODE:
pDM_Odm->OPMode = (u8)Value;
break;
case ODM_CMNINFO_WM_MODE:
pDM_Odm->WirelessMode = (u8)Value;
break;
case ODM_CMNINFO_SEC_CHNL_OFFSET:
pDM_Odm->SecChOffset = (u8)Value;
break;
case ODM_CMNINFO_SEC_MODE:
pDM_Odm->Security = (u8)Value;
break;
case ODM_CMNINFO_BW:
pDM_Odm->BandWidth = (u8)Value;
break;
case ODM_CMNINFO_CHNL:
pDM_Odm->Channel = (u8)Value;
break;
*/
default:
/* do nothing */
break;
}
}
/* 3 ============================================================ */
/* 3 DIG */
/* 3 ============================================================ */
/*-----------------------------------------------------------------------------
* Function: odm_DIGInit()
*
* Overview: Set DIG scheme init value.
*
* Input: NONE
*
* Output: NONE
*
* Return: NONE
*
* Revised History:
*When Who Remark
*
*---------------------------------------------------------------------------
*/
/* Remove DIG by yuchen */
/* Remove DIG and FA check by Yu Chen */
/* 3 ============================================================ */
/* 3 BB Power Save */
/* 3 ============================================================ */
/* Remove BB power saving by Yuchen */
/* 3 ============================================================ */
/* 3 Dynamic Tx Power */
/* 3 ============================================================ */
/* Remove BY YuChen */
| linux-master | drivers/staging/rtl8723bs/hal/odm.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtl8723b_hal.h>
static u8 rtw_sdio_wait_enough_TxOQT_space(struct adapter *padapter, u8 agg_num)
{
u32 n = 0;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
while (pHalData->SdioTxOQTFreeSpace < agg_num) {
if (
(padapter->bSurpriseRemoved) ||
(padapter->bDriverStopped)
)
return false;
HalQueryTxOQTBufferStatus8723BSdio(padapter);
if ((++n % 60) == 0) {
msleep(1);
/* yield(); */
}
}
pHalData->SdioTxOQTFreeSpace -= agg_num;
return true;
}
static s32 rtl8723_dequeue_writeport(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
struct xmit_buf *pxmitbuf;
struct adapter *pri_padapter = padapter;
s32 ret = 0;
u8 PageIdx = 0;
u32 deviceId;
u8 bUpdatePageNum = false;
ret = ret || check_fwstate(pmlmepriv, _FW_UNDER_SURVEY);
if (ret)
pxmitbuf = dequeue_pending_xmitbuf_under_survey(pxmitpriv);
else
pxmitbuf = dequeue_pending_xmitbuf(pxmitpriv);
if (!pxmitbuf)
return true;
deviceId = ffaddr2deviceId(pdvobjpriv, pxmitbuf->ff_hwaddr);
/* translate fifo addr to queue index */
switch (deviceId) {
case WLAN_TX_HIQ_DEVICE_ID:
PageIdx = HI_QUEUE_IDX;
break;
case WLAN_TX_MIQ_DEVICE_ID:
PageIdx = MID_QUEUE_IDX;
break;
case WLAN_TX_LOQ_DEVICE_ID:
PageIdx = LOW_QUEUE_IDX;
break;
}
query_free_page:
/* check if hardware tx fifo page is enough */
if (!rtw_hal_sdio_query_tx_freepage(pri_padapter, PageIdx, pxmitbuf->pg_num)) {
if (!bUpdatePageNum) {
/* Total number of page is NOT available, so update current FIFO status */
HalQueryTxBufferStatus8723BSdio(padapter);
bUpdatePageNum = true;
goto query_free_page;
} else {
bUpdatePageNum = false;
enqueue_pending_xmitbuf_to_head(pxmitpriv, pxmitbuf);
return true;
}
}
if (
(padapter->bSurpriseRemoved) ||
(padapter->bDriverStopped)
)
goto free_xmitbuf;
if (rtw_sdio_wait_enough_TxOQT_space(padapter, pxmitbuf->agg_num) == false)
goto free_xmitbuf;
traffic_check_for_leave_lps(padapter, true, pxmitbuf->agg_num);
rtw_write_port(padapter, deviceId, pxmitbuf->len, (u8 *)pxmitbuf);
rtw_hal_sdio_update_tx_freepage(pri_padapter, PageIdx, pxmitbuf->pg_num);
free_xmitbuf:
/* rtw_free_xmitframe(pxmitpriv, pframe); */
/* pxmitbuf->priv_data = NULL; */
rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
return _FAIL;
}
/*
* Description
*Transmit xmitbuf to hardware tx fifo
*
* Return
*_SUCCESS ok
*_FAIL something error
*/
s32 rtl8723bs_xmit_buf_handler(struct adapter *padapter)
{
struct xmit_priv *pxmitpriv;
u8 queue_empty, queue_pending;
s32 ret;
pxmitpriv = &padapter->xmitpriv;
if (wait_for_completion_interruptible(&pxmitpriv->xmit_comp)) {
netdev_emerg(padapter->pnetdev,
"%s: down SdioXmitBufSema fail!\n", __func__);
return _FAIL;
}
ret = (padapter->bDriverStopped) || (padapter->bSurpriseRemoved);
if (ret)
return _FAIL;
queue_pending = check_pending_xmitbuf(pxmitpriv);
if (!queue_pending)
return _SUCCESS;
ret = rtw_register_tx_alive(padapter);
if (ret != _SUCCESS) {
return _SUCCESS;
}
do {
queue_empty = rtl8723_dequeue_writeport(padapter);
/* dump secondary adapter xmitbuf */
} while (!queue_empty);
rtw_unregister_tx_alive(padapter);
return _SUCCESS;
}
/*
* Description:
*Aggregation packets and send to hardware
*
* Return:
*0 Success
*-1 Hardware resource(TX FIFO) not ready
*-2 Software resource(xmitbuf) not ready
*/
static s32 xmit_xmitframes(struct adapter *padapter, struct xmit_priv *pxmitpriv)
{
s32 err, ret;
u32 k = 0;
struct hw_xmit *hwxmits, *phwxmit;
u8 idx, hwentry;
struct tx_servq *ptxservq;
struct list_head *sta_plist, *sta_phead, *frame_plist, *frame_phead, *tmp;
struct xmit_frame *pxmitframe;
struct __queue *pframe_queue;
struct xmit_buf *pxmitbuf;
u32 txlen, max_xmit_len;
u8 txdesc_size = TXDESC_SIZE;
int inx[4];
err = 0;
hwxmits = pxmitpriv->hwxmits;
hwentry = pxmitpriv->hwxmit_entry;
ptxservq = NULL;
pxmitframe = NULL;
pframe_queue = NULL;
pxmitbuf = NULL;
if (padapter->registrypriv.wifi_spec == 1) {
for (idx = 0; idx < 4; idx++)
inx[idx] = pxmitpriv->wmm_para_seq[idx];
} else {
inx[0] = 0;
inx[1] = 1;
inx[2] = 2;
inx[3] = 3;
}
/* 0(VO), 1(VI), 2(BE), 3(BK) */
for (idx = 0; idx < hwentry; idx++) {
phwxmit = hwxmits + inx[idx];
if (
(check_pending_xmitbuf(pxmitpriv)) &&
(padapter->mlmepriv.LinkDetectInfo.bHigherBusyTxTraffic)
) {
if ((phwxmit->accnt > 0) && (phwxmit->accnt < 5)) {
err = -2;
break;
}
}
max_xmit_len = rtw_hal_get_sdio_tx_max_length(padapter, inx[idx]);
spin_lock_bh(&pxmitpriv->lock);
sta_phead = get_list_head(phwxmit->sta_queue);
/* because stop_sta_xmit may delete sta_plist at any time */
/* so we should add lock here, or while loop can not exit */
list_for_each_safe(sta_plist, tmp, sta_phead) {
ptxservq = list_entry(sta_plist, struct tx_servq,
tx_pending);
pframe_queue = &ptxservq->sta_pending;
frame_phead = get_list_head(pframe_queue);
while (list_empty(frame_phead) == false) {
frame_plist = get_next(frame_phead);
pxmitframe = container_of(frame_plist, struct xmit_frame, list);
/* check xmit_buf size enough or not */
txlen = txdesc_size + rtw_wlan_pkt_size(pxmitframe);
if (!pxmitbuf ||
((_RND(pxmitbuf->len, 8) + txlen) > max_xmit_len) ||
(k >= (rtw_hal_sdio_max_txoqt_free_space(padapter) - 1))
) {
if (pxmitbuf) {
/* pxmitbuf->priv_data will be NULL, and will crash here */
if (pxmitbuf->len > 0 &&
pxmitbuf->priv_data) {
struct xmit_frame *pframe;
pframe = (struct xmit_frame *)pxmitbuf->priv_data;
pframe->agg_num = k;
pxmitbuf->agg_num = k;
rtl8723b_update_txdesc(pframe, pframe->buf_addr);
rtw_free_xmitframe(pxmitpriv, pframe);
pxmitbuf->priv_data = NULL;
enqueue_pending_xmitbuf(pxmitpriv, pxmitbuf);
/* can not yield under lock */
/* yield(); */
} else
rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
}
pxmitbuf = rtw_alloc_xmitbuf(pxmitpriv);
if (!pxmitbuf) {
#ifdef DBG_XMIT_BUF
netdev_err(padapter->pnetdev,
"%s: xmit_buf is not enough!\n",
__func__);
#endif
err = -2;
complete(&(pxmitpriv->xmit_comp));
break;
}
k = 0;
}
/* ok to send, remove frame from queue */
if (check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE) == true)
if (
(pxmitframe->attrib.psta->state & WIFI_SLEEP_STATE) &&
(pxmitframe->attrib.triggered == 0)
)
break;
list_del_init(&pxmitframe->list);
ptxservq->qcnt--;
phwxmit->accnt--;
if (k == 0) {
pxmitbuf->ff_hwaddr = rtw_get_ff_hwaddr(pxmitframe);
pxmitbuf->priv_data = (u8 *)pxmitframe;
}
/* coalesce the xmitframe to xmitbuf */
pxmitframe->pxmitbuf = pxmitbuf;
pxmitframe->buf_addr = pxmitbuf->ptail;
ret = rtw_xmitframe_coalesce(padapter, pxmitframe->pkt, pxmitframe);
if (ret == _FAIL) {
netdev_err(padapter->pnetdev,
"%s: coalesce FAIL!",
__func__);
/* Todo: error handler */
} else {
k++;
if (k != 1)
rtl8723b_update_txdesc(pxmitframe, pxmitframe->buf_addr);
rtw_count_tx_stats(padapter, pxmitframe, pxmitframe->attrib.last_txcmdsz);
txlen = txdesc_size + pxmitframe->attrib.last_txcmdsz;
pxmitframe->pg_num = (txlen + 127) / 128;
pxmitbuf->pg_num += (txlen + 127) / 128;
pxmitbuf->ptail += _RND(txlen, 8); /* round to 8 bytes alignment */
pxmitbuf->len = _RND(pxmitbuf->len, 8) + txlen;
}
if (k != 1)
rtw_free_xmitframe(pxmitpriv, pxmitframe);
pxmitframe = NULL;
}
if (list_empty(&pframe_queue->queue))
list_del_init(&ptxservq->tx_pending);
if (err)
break;
}
spin_unlock_bh(&pxmitpriv->lock);
/* dump xmit_buf to hw tx fifo */
if (pxmitbuf) {
if (pxmitbuf->len > 0) {
struct xmit_frame *pframe;
pframe = (struct xmit_frame *)pxmitbuf->priv_data;
pframe->agg_num = k;
pxmitbuf->agg_num = k;
rtl8723b_update_txdesc(pframe, pframe->buf_addr);
rtw_free_xmitframe(pxmitpriv, pframe);
pxmitbuf->priv_data = NULL;
enqueue_pending_xmitbuf(pxmitpriv, pxmitbuf);
yield();
} else
rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
pxmitbuf = NULL;
}
if (err)
break;
}
return err;
}
/*
* Description
*Transmit xmitframe from queue
*
* Return
*_SUCCESS ok
*_FAIL something error
*/
static s32 rtl8723bs_xmit_handler(struct adapter *padapter)
{
struct xmit_priv *pxmitpriv;
s32 ret;
pxmitpriv = &padapter->xmitpriv;
if (wait_for_completion_interruptible(&pxmitpriv->SdioXmitStart)) {
netdev_emerg(padapter->pnetdev, "%s: SdioXmitStart fail!\n",
__func__);
return _FAIL;
}
next:
if (
(padapter->bDriverStopped) ||
(padapter->bSurpriseRemoved)
)
return _FAIL;
spin_lock_bh(&pxmitpriv->lock);
ret = rtw_txframes_pending(padapter);
spin_unlock_bh(&pxmitpriv->lock);
if (ret == 0) {
return _SUCCESS;
}
/* dequeue frame and write to hardware */
ret = xmit_xmitframes(padapter, pxmitpriv);
if (ret == -2) {
/* here sleep 1ms will cause big TP loss of TX */
/* from 50+ to 40+ */
if (padapter->registrypriv.wifi_spec)
msleep(1);
else
yield();
goto next;
}
spin_lock_bh(&pxmitpriv->lock);
ret = rtw_txframes_pending(padapter);
spin_unlock_bh(&pxmitpriv->lock);
if (ret == 1) {
goto next;
}
return _SUCCESS;
}
int rtl8723bs_xmit_thread(void *context)
{
s32 ret;
struct adapter *padapter;
struct xmit_priv *pxmitpriv;
u8 thread_name[20];
ret = _SUCCESS;
padapter = context;
pxmitpriv = &padapter->xmitpriv;
rtw_sprintf(thread_name, 20, "RTWHALXT-%s", ADPT_ARG(padapter));
thread_enter(thread_name);
do {
ret = rtl8723bs_xmit_handler(padapter);
if (signal_pending(current)) {
flush_signals(current);
}
} while (_SUCCESS == ret);
complete(&pxmitpriv->SdioXmitTerminate);
return 0;
}
s32 rtl8723bs_mgnt_xmit(
struct adapter *padapter, struct xmit_frame *pmgntframe
)
{
s32 ret = _SUCCESS;
struct pkt_attrib *pattrib;
struct xmit_buf *pxmitbuf;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
u8 *pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
u8 txdesc_size = TXDESC_SIZE;
pattrib = &pmgntframe->attrib;
pxmitbuf = pmgntframe->pxmitbuf;
rtl8723b_update_txdesc(pmgntframe, pmgntframe->buf_addr);
pxmitbuf->len = txdesc_size + pattrib->last_txcmdsz;
pxmitbuf->pg_num = (pxmitbuf->len + 127) / 128; /* 128 is tx page size */
pxmitbuf->ptail = pmgntframe->buf_addr + pxmitbuf->len;
pxmitbuf->ff_hwaddr = rtw_get_ff_hwaddr(pmgntframe);
rtw_count_tx_stats(padapter, pmgntframe, pattrib->last_txcmdsz);
rtw_free_xmitframe(pxmitpriv, pmgntframe);
pxmitbuf->priv_data = NULL;
if (GetFrameSubType(pframe) == WIFI_BEACON) { /* dump beacon directly */
ret = rtw_write_port(padapter, pdvobjpriv->Queue2Pipe[pxmitbuf->ff_hwaddr], pxmitbuf->len, (u8 *)pxmitbuf);
if (ret != _SUCCESS)
rtw_sctx_done_err(&pxmitbuf->sctx, RTW_SCTX_DONE_WRITE_PORT_ERR);
rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
} else
enqueue_pending_xmitbuf(pxmitpriv, pxmitbuf);
return ret;
}
/*
* Description:
*Handle xmitframe(packet) come from rtw_xmit()
*
* Return:
*true dump packet directly ok
*false enqueue, temporary can't transmit packets to hardware
*/
s32 rtl8723bs_hal_xmit(
struct adapter *padapter, struct xmit_frame *pxmitframe
)
{
struct xmit_priv *pxmitpriv;
s32 err;
pxmitframe->attrib.qsel = pxmitframe->attrib.priority;
pxmitpriv = &padapter->xmitpriv;
if (
(pxmitframe->frame_tag == DATA_FRAMETAG) &&
(pxmitframe->attrib.ether_type != 0x0806) &&
(pxmitframe->attrib.ether_type != 0x888e) &&
(pxmitframe->attrib.dhcp_pkt != 1)
) {
if (padapter->mlmepriv.LinkDetectInfo.bBusyTraffic)
rtw_issue_addbareq_cmd(padapter, pxmitframe);
}
spin_lock_bh(&pxmitpriv->lock);
err = rtw_xmitframe_enqueue(padapter, pxmitframe);
spin_unlock_bh(&pxmitpriv->lock);
if (err != _SUCCESS) {
rtw_free_xmitframe(pxmitpriv, pxmitframe);
pxmitpriv->tx_drop++;
return true;
}
complete(&pxmitpriv->SdioXmitStart);
return false;
}
s32 rtl8723bs_hal_xmitframe_enqueue(
struct adapter *padapter, struct xmit_frame *pxmitframe
)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
s32 err;
err = rtw_xmitframe_enqueue(padapter, pxmitframe);
if (err != _SUCCESS) {
rtw_free_xmitframe(pxmitpriv, pxmitframe);
pxmitpriv->tx_drop++;
} else {
complete(&pxmitpriv->SdioXmitStart);
}
return err;
}
/*
* Return
*_SUCCESS start thread ok
*_FAIL start thread fail
*
*/
s32 rtl8723bs_init_xmit_priv(struct adapter *padapter)
{
struct xmit_priv *xmitpriv = &padapter->xmitpriv;
struct hal_com_data *phal;
phal = GET_HAL_DATA(padapter);
spin_lock_init(&phal->SdioTxFIFOFreePageLock);
init_completion(&xmitpriv->SdioXmitStart);
init_completion(&xmitpriv->SdioXmitTerminate);
return _SUCCESS;
}
void rtl8723bs_free_xmit_priv(struct adapter *padapter)
{
struct xmit_priv *pxmitpriv;
struct xmit_buf *pxmitbuf;
struct __queue *pqueue;
struct list_head *plist, *phead;
struct list_head tmplist;
pxmitpriv = &padapter->xmitpriv;
pqueue = &pxmitpriv->pending_xmitbuf_queue;
phead = get_list_head(pqueue);
INIT_LIST_HEAD(&tmplist);
spin_lock_bh(&pqueue->lock);
if (!list_empty(&pqueue->queue)) {
/* Insert tmplist to end of queue, and delete phead */
/* then tmplist become head of queue. */
list_add_tail(&tmplist, phead);
list_del_init(phead);
}
spin_unlock_bh(&pqueue->lock);
phead = &tmplist;
while (list_empty(phead) == false) {
plist = get_next(phead);
list_del_init(plist);
pxmitbuf = container_of(plist, struct xmit_buf, list);
rtw_free_xmitframe(pxmitpriv, (struct xmit_frame *)pxmitbuf->priv_data);
pxmitbuf->priv_data = NULL;
rtw_free_xmitbuf(pxmitpriv, pxmitbuf);
}
}
| linux-master | drivers/staging/rtl8723bs/hal/rtl8723bs_xmit.c |
// SPDX-License-Identifier: GPL-2.0
/*****************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include "odm_precomp.h"
/* MACRO definition for pRFCalibrateInfo->TxIQC_8723B[0] */
#define PATH_S0 1 /* RF_PATH_B */
#define IDX_0xC94 0
#define IDX_0xC80 1
#define IDX_0xC14 0
#define IDX_0xCA0 1
#define KEY 0
#define VAL 1
/* MACRO definition for pRFCalibrateInfo->TxIQC_8723B[1] */
#define PATH_S1 0 /* RF_PATH_A */
#define IDX_0xC4C 2
/*---------------------------Define Local Constant---------------------------*/
/* In the case that we fail to read TxPowerTrack.txt, we use the table for
* 88E as the default table.
*/
static u8 DeltaSwingTableIdx_2GA_N_8188E[] = {
0, 0, 0, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6,
7, 7, 7, 7, 8, 8, 9, 9, 10, 10, 10, 11, 11, 11, 11
};
static u8 DeltaSwingTableIdx_2GA_P_8188E[] = {
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4, 4,
4, 4, 4, 5, 5, 7, 7, 8, 8, 8, 9, 9, 9, 9, 9
};
/* 3 ============================================================ */
/* 3 Tx Power Tracking */
/* 3 ============================================================ */
static void setIqkMatrix_8723B(
struct dm_odm_t *pDM_Odm,
u8 OFDM_index,
u8 RFPath,
s32 IqkResult_X,
s32 IqkResult_Y
)
{
s32 ele_A = 0, ele_D, ele_C = 0, value32;
if (OFDM_index >= OFDM_TABLE_SIZE)
OFDM_index = OFDM_TABLE_SIZE-1;
ele_D = (OFDMSwingTable_New[OFDM_index] & 0xFFC00000)>>22;
/* new element A = element D x X */
if (IqkResult_X != 0) {
if ((IqkResult_X & 0x00000200) != 0) /* consider minus */
IqkResult_X = IqkResult_X | 0xFFFFFC00;
ele_A = ((IqkResult_X * ele_D)>>8)&0x000003FF;
/* new element C = element D x Y */
if ((IqkResult_Y & 0x00000200) != 0)
IqkResult_Y = IqkResult_Y | 0xFFFFFC00;
ele_C = ((IqkResult_Y * ele_D)>>8)&0x000003FF;
/* if (RFPath == RF_PATH_A) */
switch (RFPath) {
case RF_PATH_A:
/* write new elements A, C, D to regC80 and regC94,
* element B is always 0
*/
value32 = (ele_D<<22)|((ele_C&0x3F)<<16)|ele_A;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XATxIQImbalance, bMaskDWord, value32);
value32 = (ele_C&0x000003C0)>>6;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XCTxAFE, bMaskH4Bits, value32);
value32 = ((IqkResult_X * ele_D)>>7)&0x01;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, BIT24, value32);
break;
case RF_PATH_B:
/* write new elements A, C, D to regC88 and regC9C,
* element B is always 0
*/
value32 = (ele_D<<22)|((ele_C&0x3F)<<16)|ele_A;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XBTxIQImbalance, bMaskDWord, value32);
value32 = (ele_C&0x000003C0)>>6;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XDTxAFE, bMaskH4Bits, value32);
value32 = ((IqkResult_X * ele_D)>>7)&0x01;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, BIT28, value32);
break;
default:
break;
}
} else {
switch (RFPath) {
case RF_PATH_A:
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XATxIQImbalance, bMaskDWord, OFDMSwingTable_New[OFDM_index]);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XCTxAFE, bMaskH4Bits, 0x00);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, BIT24, 0x00);
break;
case RF_PATH_B:
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XBTxIQImbalance, bMaskDWord, OFDMSwingTable_New[OFDM_index]);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XDTxAFE, bMaskH4Bits, 0x00);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, BIT28, 0x00);
break;
default:
break;
}
}
}
static void setCCKFilterCoefficient(struct dm_odm_t *pDM_Odm, u8 CCKSwingIndex)
{
if (!pDM_Odm->RFCalibrateInfo.bCCKinCH14) {
rtw_write8(pDM_Odm->Adapter, 0xa22, CCKSwingTable_Ch1_Ch13_New[CCKSwingIndex][0]);
rtw_write8(pDM_Odm->Adapter, 0xa23, CCKSwingTable_Ch1_Ch13_New[CCKSwingIndex][1]);
rtw_write8(pDM_Odm->Adapter, 0xa24, CCKSwingTable_Ch1_Ch13_New[CCKSwingIndex][2]);
rtw_write8(pDM_Odm->Adapter, 0xa25, CCKSwingTable_Ch1_Ch13_New[CCKSwingIndex][3]);
rtw_write8(pDM_Odm->Adapter, 0xa26, CCKSwingTable_Ch1_Ch13_New[CCKSwingIndex][4]);
rtw_write8(pDM_Odm->Adapter, 0xa27, CCKSwingTable_Ch1_Ch13_New[CCKSwingIndex][5]);
rtw_write8(pDM_Odm->Adapter, 0xa28, CCKSwingTable_Ch1_Ch13_New[CCKSwingIndex][6]);
rtw_write8(pDM_Odm->Adapter, 0xa29, CCKSwingTable_Ch1_Ch13_New[CCKSwingIndex][7]);
} else {
rtw_write8(pDM_Odm->Adapter, 0xa22, CCKSwingTable_Ch14_New[CCKSwingIndex][0]);
rtw_write8(pDM_Odm->Adapter, 0xa23, CCKSwingTable_Ch14_New[CCKSwingIndex][1]);
rtw_write8(pDM_Odm->Adapter, 0xa24, CCKSwingTable_Ch14_New[CCKSwingIndex][2]);
rtw_write8(pDM_Odm->Adapter, 0xa25, CCKSwingTable_Ch14_New[CCKSwingIndex][3]);
rtw_write8(pDM_Odm->Adapter, 0xa26, CCKSwingTable_Ch14_New[CCKSwingIndex][4]);
rtw_write8(pDM_Odm->Adapter, 0xa27, CCKSwingTable_Ch14_New[CCKSwingIndex][5]);
rtw_write8(pDM_Odm->Adapter, 0xa28, CCKSwingTable_Ch14_New[CCKSwingIndex][6]);
rtw_write8(pDM_Odm->Adapter, 0xa29, CCKSwingTable_Ch14_New[CCKSwingIndex][7]);
}
}
void DoIQK_8723B(
struct dm_odm_t *pDM_Odm,
u8 DeltaThermalIndex,
u8 ThermalValue,
u8 Threshold
)
{
}
/*-----------------------------------------------------------------------------
* Function: odm_TxPwrTrackSetPwr88E()
*
* Overview: 88E change all channel tx power according to flag.
* OFDM & CCK are all different.
*
* Input: NONE
*
* Output: NONE
*
* Return: NONE
*
* Revised History:
*When Who Remark
*04/23/2012 MHC Create Version 0.
*
*---------------------------------------------------------------------------*/
void ODM_TxPwrTrackSetPwr_8723B(
struct dm_odm_t *pDM_Odm,
enum pwrtrack_method Method,
u8 RFPath,
u8 ChannelMappedIndex
)
{
struct adapter *Adapter = pDM_Odm->Adapter;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
u8 PwrTrackingLimit_OFDM = 34; /* 0dB */
u8 PwrTrackingLimit_CCK = 28; /* 2dB */
u8 TxRate = 0xFF;
u8 Final_OFDM_Swing_Index = 0;
u8 Final_CCK_Swing_Index = 0;
{
u16 rate = *(pDM_Odm->pForcedDataRate);
if (!rate) { /* auto rate */
if (pDM_Odm->TxRate != 0xFF)
TxRate = HwRateToMRate(pDM_Odm->TxRate);
} else /* force rate */
TxRate = (u8)rate;
}
if (TxRate != 0xFF) {
/* 2 CCK */
if ((TxRate >= MGN_1M) && (TxRate <= MGN_11M))
PwrTrackingLimit_CCK = 28; /* 2dB */
/* 2 OFDM */
else if ((TxRate >= MGN_6M) && (TxRate <= MGN_48M))
PwrTrackingLimit_OFDM = 36; /* 3dB */
else if (TxRate == MGN_54M)
PwrTrackingLimit_OFDM = 34; /* 2dB */
/* 2 HT */
else if ((TxRate >= MGN_MCS0) && (TxRate <= MGN_MCS2)) /* QPSK/BPSK */
PwrTrackingLimit_OFDM = 38; /* 4dB */
else if ((TxRate >= MGN_MCS3) && (TxRate <= MGN_MCS4)) /* 16QAM */
PwrTrackingLimit_OFDM = 36; /* 3dB */
else if ((TxRate >= MGN_MCS5) && (TxRate <= MGN_MCS7)) /* 64QAM */
PwrTrackingLimit_OFDM = 34; /* 2dB */
else
PwrTrackingLimit_OFDM = pDM_Odm->DefaultOfdmIndex; /* Default OFDM index = 30 */
}
if (Method == TXAGC) {
struct adapter *Adapter = pDM_Odm->Adapter;
pDM_Odm->Remnant_OFDMSwingIdx[RFPath] = pDM_Odm->Absolute_OFDMSwingIdx[RFPath];
pDM_Odm->Modify_TxAGC_Flag_PathA = true;
pDM_Odm->Modify_TxAGC_Flag_PathA_CCK = true;
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, CCK);
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, OFDM);
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, HT_MCS0_MCS7);
} else if (Method == BBSWING) {
Final_OFDM_Swing_Index = pDM_Odm->DefaultOfdmIndex + pDM_Odm->Absolute_OFDMSwingIdx[RFPath];
Final_CCK_Swing_Index = pDM_Odm->DefaultCckIndex + pDM_Odm->Absolute_OFDMSwingIdx[RFPath];
/* Adjust BB swing by OFDM IQ matrix */
if (Final_OFDM_Swing_Index >= PwrTrackingLimit_OFDM)
Final_OFDM_Swing_Index = PwrTrackingLimit_OFDM;
else if (Final_OFDM_Swing_Index <= 0)
Final_OFDM_Swing_Index = 0;
if (Final_CCK_Swing_Index >= CCK_TABLE_SIZE)
Final_CCK_Swing_Index = CCK_TABLE_SIZE-1;
else if (pDM_Odm->BbSwingIdxCck <= 0)
Final_CCK_Swing_Index = 0;
setIqkMatrix_8723B(pDM_Odm, Final_OFDM_Swing_Index, RFPath,
pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][0],
pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][1]);
setCCKFilterCoefficient(pDM_Odm, Final_CCK_Swing_Index);
} else if (Method == MIX_MODE) {
Final_OFDM_Swing_Index = pDM_Odm->DefaultOfdmIndex + pDM_Odm->Absolute_OFDMSwingIdx[RFPath];
Final_CCK_Swing_Index = pDM_Odm->DefaultCckIndex + pDM_Odm->Absolute_OFDMSwingIdx[RFPath];
if (Final_OFDM_Swing_Index > PwrTrackingLimit_OFDM) { /* BBSwing higher then Limit */
pDM_Odm->Remnant_OFDMSwingIdx[RFPath] = Final_OFDM_Swing_Index - PwrTrackingLimit_OFDM;
setIqkMatrix_8723B(pDM_Odm, PwrTrackingLimit_OFDM, RFPath,
pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][0],
pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][1]);
pDM_Odm->Modify_TxAGC_Flag_PathA = true;
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, OFDM);
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, HT_MCS0_MCS7);
} else if (Final_OFDM_Swing_Index <= 0) {
pDM_Odm->Remnant_OFDMSwingIdx[RFPath] = Final_OFDM_Swing_Index;
setIqkMatrix_8723B(pDM_Odm, 0, RFPath,
pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][0],
pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][1]);
pDM_Odm->Modify_TxAGC_Flag_PathA = true;
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, OFDM);
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, HT_MCS0_MCS7);
} else {
setIqkMatrix_8723B(pDM_Odm, Final_OFDM_Swing_Index, RFPath,
pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][0],
pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[ChannelMappedIndex][1]);
if (pDM_Odm->Modify_TxAGC_Flag_PathA) { /* If TxAGC has changed, reset TxAGC again */
pDM_Odm->Remnant_OFDMSwingIdx[RFPath] = 0;
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, OFDM);
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, HT_MCS0_MCS7);
pDM_Odm->Modify_TxAGC_Flag_PathA = false;
}
}
if (Final_CCK_Swing_Index > PwrTrackingLimit_CCK) {
pDM_Odm->Remnant_CCKSwingIdx = Final_CCK_Swing_Index - PwrTrackingLimit_CCK;
setCCKFilterCoefficient(pDM_Odm, PwrTrackingLimit_CCK);
pDM_Odm->Modify_TxAGC_Flag_PathA_CCK = true;
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, CCK);
} else if (Final_CCK_Swing_Index <= 0) { /* Lowest CCK Index = 0 */
pDM_Odm->Remnant_CCKSwingIdx = Final_CCK_Swing_Index;
setCCKFilterCoefficient(pDM_Odm, 0);
pDM_Odm->Modify_TxAGC_Flag_PathA_CCK = true;
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, CCK);
} else {
setCCKFilterCoefficient(pDM_Odm, Final_CCK_Swing_Index);
if (pDM_Odm->Modify_TxAGC_Flag_PathA_CCK) { /* If TxAGC has changed, reset TxAGC again */
pDM_Odm->Remnant_CCKSwingIdx = 0;
PHY_SetTxPowerIndexByRateSection(Adapter, RFPath, pHalData->CurrentChannel, CCK);
pDM_Odm->Modify_TxAGC_Flag_PathA_CCK = false;
}
}
} else
return; /* This method is not supported. */
}
static void GetDeltaSwingTable_8723B(
struct dm_odm_t *pDM_Odm,
u8 **TemperatureUP_A,
u8 **TemperatureDOWN_A,
u8 **TemperatureUP_B,
u8 **TemperatureDOWN_B
)
{
struct adapter *Adapter = pDM_Odm->Adapter;
struct odm_rf_cal_t *pRFCalibrateInfo = &pDM_Odm->RFCalibrateInfo;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
u16 rate = *(pDM_Odm->pForcedDataRate);
u8 channel = pHalData->CurrentChannel;
if (1 <= channel && channel <= 14) {
if (IS_CCK_RATE(rate)) {
*TemperatureUP_A = pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_P;
*TemperatureDOWN_A = pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_N;
*TemperatureUP_B = pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_P;
*TemperatureDOWN_B = pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_N;
} else {
*TemperatureUP_A = pRFCalibrateInfo->DeltaSwingTableIdx_2GA_P;
*TemperatureDOWN_A = pRFCalibrateInfo->DeltaSwingTableIdx_2GA_N;
*TemperatureUP_B = pRFCalibrateInfo->DeltaSwingTableIdx_2GB_P;
*TemperatureDOWN_B = pRFCalibrateInfo->DeltaSwingTableIdx_2GB_N;
}
} else {
*TemperatureUP_A = (u8 *)DeltaSwingTableIdx_2GA_P_8188E;
*TemperatureDOWN_A = (u8 *)DeltaSwingTableIdx_2GA_N_8188E;
*TemperatureUP_B = (u8 *)DeltaSwingTableIdx_2GA_P_8188E;
*TemperatureDOWN_B = (u8 *)DeltaSwingTableIdx_2GA_N_8188E;
}
}
void ConfigureTxpowerTrack_8723B(struct txpwrtrack_cfg *pConfig)
{
pConfig->SwingTableSize_CCK = CCK_TABLE_SIZE;
pConfig->SwingTableSize_OFDM = OFDM_TABLE_SIZE;
pConfig->Threshold_IQK = IQK_THRESHOLD;
pConfig->AverageThermalNum = AVG_THERMAL_NUM_8723B;
pConfig->RfPathCount = MAX_PATH_NUM_8723B;
pConfig->ThermalRegAddr = RF_T_METER_8723B;
pConfig->ODM_TxPwrTrackSetPwr = ODM_TxPwrTrackSetPwr_8723B;
pConfig->DoIQK = DoIQK_8723B;
pConfig->PHY_LCCalibrate = PHY_LCCalibrate_8723B;
pConfig->GetDeltaSwingTable = GetDeltaSwingTable_8723B;
}
/* 1 7. IQK */
#define MAX_TOLERANCE 5
/* bit0 = 1 => Tx OK, bit1 = 1 => Rx OK */
static u8 phy_PathA_IQK_8723B(
struct adapter *padapter, bool configPathB, u8 RF_Path
)
{
u32 regEAC, regE94, regE9C, tmp, Path_SEL_BB /*, regEA4*/;
u8 result = 0x00;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
/* Save RF Path */
Path_SEL_BB = PHY_QueryBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord);
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
/* enable path A PA in TXIQK mode */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_RCK_OS, bRFRegOffsetMask, 0x18000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G1, bRFRegOffsetMask, 0x0003f);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G2, bRFRegOffsetMask, 0xc7f87);
/* disable path B PA in TXIQK mode */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xed, bRFRegOffsetMask, 0x00020); */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0x43, bRFRegOffsetMask, 0x40ec1); */
/* 1 Tx IQK */
/* IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK, bMaskDWord, 0x01007c00);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK, bMaskDWord, 0x01004800);
/* path-A IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_A, bMaskDWord, 0x18008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_A, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
/* PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_A, bMaskDWord, 0x8214010a); */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_A, bMaskDWord, 0x821303ea);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_A, bMaskDWord, 0x28110000);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_B, bMaskDWord, 0x82110000);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_B, bMaskDWord, 0x28110000);
/* LO calibration setting */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Rsp, bMaskDWord, 0x00462911);
/* enter IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x808000);
/* Ant switch */
if (configPathB || (RF_Path == 0))
/* wifi switch to S1 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, 0x00000000);
else
/* wifi switch to S0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, 0x00000280);
/* GNT_BT = 0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00000800);
/* One shot, path A LOK & IQK */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf9000000);
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf8000000);
/* delay x ms */
/* PlatformStallExecution(IQK_DELAY_TIME_8723B*1000); */
mdelay(IQK_DELAY_TIME_8723B);
/* restore Ant Path */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, Path_SEL_BB);
/* GNT_BT = 1 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00001800);
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
/* Check failed */
regEAC = PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_After_IQK_A_2, bMaskDWord);
regE94 = PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_Before_IQK_A, bMaskDWord);
regE9C = PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_After_IQK_A, bMaskDWord);
/* Allen 20131125 */
tmp = (regE9C & 0x03FF0000)>>16;
if ((tmp & 0x200) > 0)
tmp = 0x400 - tmp;
if (
!(regEAC & BIT28) &&
(((regE94 & 0x03FF0000)>>16) != 0x142) &&
(((regE9C & 0x03FF0000)>>16) != 0x42) &&
(((regE94 & 0x03FF0000)>>16) < 0x110) &&
(((regE94 & 0x03FF0000)>>16) > 0xf0) &&
(tmp < 0xf)
)
result |= 0x01;
else /* if Tx not OK, ignore Rx */
return result;
return result;
}
/* bit0 = 1 => Tx OK, bit1 = 1 => Rx OK */
static u8 phy_PathA_RxIQK8723B(
struct adapter *padapter, bool configPathB, u8 RF_Path
)
{
u32 regEAC, regE94, regE9C, regEA4, u4tmp, tmp, Path_SEL_BB;
u8 result = 0x00;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
/* Save RF Path */
Path_SEL_BB = PHY_QueryBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord);
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
/* 1 Get TXIMR setting */
/* modify RXIQK mode table */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_RCK_OS, bRFRegOffsetMask, 0x18000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G1, bRFRegOffsetMask, 0x0001f);
/* LNA2 off, PA on for Dcut */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G2, bRFRegOffsetMask, 0xf7fb7);
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x0); */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x808000);
/* IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK, bMaskDWord, 0x01007c00);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK, bMaskDWord, 0x01004800);
/* path-A IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_A, bMaskDWord, 0x18008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_A, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
/* PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_A, bMaskDWord, 0x82160c1f); */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_A, bMaskDWord, 0x82130ff0);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_A, bMaskDWord, 0x28110000);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_B, bMaskDWord, 0x82110000);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_B, bMaskDWord, 0x28110000);
/* LO calibration setting */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Rsp, bMaskDWord, 0x0046a911);
/* enter IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x808000);
/* Ant switch */
if (configPathB || (RF_Path == 0))
/* wifi switch to S1 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, 0x00000000);
else
/* wifi switch to S0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, 0x00000280);
/* GNT_BT = 0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00000800);
/* One shot, path A LOK & IQK */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf9000000);
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf8000000);
/* delay x ms */
/* PlatformStallExecution(IQK_DELAY_TIME_8723B*1000); */
mdelay(IQK_DELAY_TIME_8723B);
/* restore Ant Path */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, Path_SEL_BB);
/* GNT_BT = 1 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00001800);
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
/* Check failed */
regEAC = PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_After_IQK_A_2, bMaskDWord);
regE94 = PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_Before_IQK_A, bMaskDWord);
regE9C = PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_After_IQK_A, bMaskDWord);
/* Allen 20131125 */
tmp = (regE9C & 0x03FF0000)>>16;
if ((tmp & 0x200) > 0)
tmp = 0x400 - tmp;
if (
!(regEAC & BIT28) &&
(((regE94 & 0x03FF0000)>>16) != 0x142) &&
(((regE9C & 0x03FF0000)>>16) != 0x42) &&
(((regE94 & 0x03FF0000)>>16) < 0x110) &&
(((regE94 & 0x03FF0000)>>16) > 0xf0) &&
(tmp < 0xf)
)
result |= 0x01;
else /* if Tx not OK, ignore Rx */
return result;
u4tmp = 0x80007C00 | (regE94&0x3FF0000) | ((regE9C&0x3FF0000) >> 16);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK, bMaskDWord, u4tmp);
/* modify RXIQK mode table */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_RCK_OS, bRFRegOffsetMask, 0x18000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G1, bRFRegOffsetMask, 0x0001f);
/* LAN2 on, PA off for Dcut */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G2, bRFRegOffsetMask, 0xf7d77);
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x0); */
/* PA, PAD setting */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xdf, bRFRegOffsetMask, 0xf80);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0x55, bRFRegOffsetMask, 0x4021f);
/* IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK, bMaskDWord, 0x01004800);
/* path-A IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_A, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_A, bMaskDWord, 0x18008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_A, bMaskDWord, 0x82110000);
/* PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_A, bMaskDWord, 0x281604c2); */
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_A, bMaskDWord, 0x2813001f);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_B, bMaskDWord, 0x82110000);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_B, bMaskDWord, 0x28110000);
/* LO calibration setting */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Rsp, bMaskDWord, 0x0046a8d1);
/* enter IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x808000);
/* Ant switch */
if (configPathB || (RF_Path == 0))
/* wifi switch to S1 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, 0x00000000);
else
/* wifi switch to S0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, 0x00000280);
/* GNT_BT = 0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00000800);
/* One shot, path A LOK & IQK */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf9000000);
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf8000000);
/* delay x ms */
/* PlatformStallExecution(IQK_DELAY_TIME_8723B*1000); */
mdelay(IQK_DELAY_TIME_8723B);
/* restore Ant Path */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, Path_SEL_BB);
/* GNT_BT = 1 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00001800);
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
/* Check failed */
regEAC = PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_After_IQK_A_2, bMaskDWord);
regEA4 = PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_Before_IQK_A_2, bMaskDWord);
/* PA/PAD controlled by 0x0 */
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xdf, bRFRegOffsetMask, 0x780);
/* Allen 20131125 */
tmp = (regEAC & 0x03FF0000)>>16;
if ((tmp & 0x200) > 0)
tmp = 0x400 - tmp;
if (
!(regEAC & BIT27) && /* if Tx is OK, check whether Rx is OK */
(((regEA4 & 0x03FF0000)>>16) != 0x132) &&
(((regEAC & 0x03FF0000)>>16) != 0x36) &&
(((regEA4 & 0x03FF0000)>>16) < 0x110) &&
(((regEA4 & 0x03FF0000)>>16) > 0xf0) &&
(tmp < 0xf)
)
result |= 0x02;
return result;
}
/* bit0 = 1 => Tx OK, bit1 = 1 => Rx OK */
static u8 phy_PathB_IQK_8723B(struct adapter *padapter)
{
u32 regEAC, regE94, regE9C, tmp, Path_SEL_BB/*, regEC4, regECC, Path_SEL_BB*/;
u8 result = 0x00;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
/* Save RF Path */
Path_SEL_BB = PHY_QueryBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord);
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
/* in TXIQK mode */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x1); */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_RCK_OS, bRFRegOffsetMask, 0x20000); */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G1, bRFRegOffsetMask, 0x0003f); */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G2, bRFRegOffsetMask, 0xc7f87); */
/* enable path B PA in TXIQK mode */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xed, 0x20, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0x43, bRFRegOffsetMask, 0x30fc1);
/* 1 Tx IQK */
/* IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK, bMaskDWord, 0x01007c00);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK, bMaskDWord, 0x01004800);
/* path-A IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_A, bMaskDWord, 0x18008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_A, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
/* PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_A, bMaskDWord, 0x82140114); */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_A, bMaskDWord, 0x821303ea);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_A, bMaskDWord, 0x28110000);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_B, bMaskDWord, 0x82110000);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_B, bMaskDWord, 0x28110000);
/* LO calibration setting */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Rsp, bMaskDWord, 0x00462911);
/* enter IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x808000);
/* switch to path B */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, 0x00000280);
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xb0, bRFRegOffsetMask, 0xeffe0); */
/* GNT_BT = 0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00000800);
/* One shot, path B LOK & IQK */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf9000000);
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf8000000);
/* delay x ms */
/* PlatformStallExecution(IQK_DELAY_TIME_88E*1000); */
mdelay(IQK_DELAY_TIME_8723B);
/* restore Ant Path */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, Path_SEL_BB);
/* GNT_BT = 1 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00001800);
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
/* Check failed */
regEAC = PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_After_IQK_A_2, bMaskDWord);
regE94 = PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_Before_IQK_A, bMaskDWord);
regE9C = PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_After_IQK_A, bMaskDWord);
/* Allen 20131125 */
tmp = (regE9C & 0x03FF0000)>>16;
if ((tmp & 0x200) > 0)
tmp = 0x400 - tmp;
if (
!(regEAC & BIT28) &&
(((regE94 & 0x03FF0000)>>16) != 0x142) &&
(((regE9C & 0x03FF0000)>>16) != 0x42) &&
(((regE94 & 0x03FF0000)>>16) < 0x110) &&
(((regE94 & 0x03FF0000)>>16) > 0xf0) &&
(tmp < 0xf)
)
result |= 0x01;
return result;
}
/* bit0 = 1 => Tx OK, bit1 = 1 => Rx OK */
static u8 phy_PathB_RxIQK8723B(struct adapter *padapter, bool configPathB)
{
u32 regE94, regE9C, regEA4, regEAC, u4tmp, tmp, Path_SEL_BB;
u8 result = 0x00;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
/* Save RF Path */
Path_SEL_BB = PHY_QueryBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord);
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
/* switch to path B */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, 0x00000280);
/* modify RXIQK mode table */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_RCK_OS, bRFRegOffsetMask, 0x18000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G1, bRFRegOffsetMask, 0x0001f);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G2, bRFRegOffsetMask, 0xf7fb7);
/* open PA S1 & SMIXER */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xed, 0x20, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0x43, bRFRegOffsetMask, 0x30fcd);
/* IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK, bMaskDWord, 0x01007c00);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK, bMaskDWord, 0x01004800);
/* path-B IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_A, bMaskDWord, 0x18008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_A, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
/* PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_A, bMaskDWord, 0x82160c1f); */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_A, bMaskDWord, 0x82130ff0);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_A, bMaskDWord, 0x28110000);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_B, bMaskDWord, 0x82110000);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_B, bMaskDWord, 0x28110000);
/* LO calibration setting */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Rsp, bMaskDWord, 0x0046a911);
/* enter IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x808000);
/* switch to path B */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, 0x00000280);
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xb0, bRFRegOffsetMask, 0xeffe0); */
/* GNT_BT = 0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00000800);
/* One shot, path B TXIQK @ RXIQK */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf9000000);
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf8000000);
/* delay x ms */
/* PlatformStallExecution(IQK_DELAY_TIME_88E*1000); */
mdelay(IQK_DELAY_TIME_8723B);
/* restore Ant Path */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, Path_SEL_BB);
/* GNT_BT = 1 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00001800);
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
/* Check failed */
regEAC = PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_After_IQK_A_2, bMaskDWord);
regE94 = PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_Before_IQK_A, bMaskDWord);
regE9C = PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_After_IQK_A, bMaskDWord);
/* Allen 20131125 */
tmp = (regE9C & 0x03FF0000)>>16;
if ((tmp & 0x200) > 0)
tmp = 0x400 - tmp;
if (
!(regEAC & BIT28) &&
(((regE94 & 0x03FF0000)>>16) != 0x142) &&
(((regE9C & 0x03FF0000)>>16) != 0x42) &&
(((regE94 & 0x03FF0000)>>16) < 0x110) &&
(((regE94 & 0x03FF0000)>>16) > 0xf0) &&
(tmp < 0xf)
)
result |= 0x01;
else /* if Tx not OK, ignore Rx */
return result;
u4tmp = 0x80007C00 | (regE94&0x3FF0000) | ((regE9C&0x3FF0000) >> 16);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK, bMaskDWord, u4tmp);
/* modify RXIQK mode table */
/* 20121009, Kordan> RF Mode = 3 */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_RCK_OS, bRFRegOffsetMask, 0x18000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G1, bRFRegOffsetMask, 0x0001f);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G2, bRFRegOffsetMask, 0xf7d77);
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x0); */
/* open PA S1 & close SMIXER */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xed, 0x20, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0x43, bRFRegOffsetMask, 0x30ebd);
/* PA, PAD setting */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xdf, bRFRegOffsetMask, 0xf80); */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0x56, bRFRegOffsetMask, 0x51000); */
/* IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK, bMaskDWord, 0x01004800);
/* path-B IQK setting */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_A, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_A, bMaskDWord, 0x18008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_B, bMaskDWord, 0x38008c1c);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_A, bMaskDWord, 0x82110000);
/* PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_A, bMaskDWord, 0x281604c2); */
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_A, bMaskDWord, 0x2813001f);
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_PI_B, bMaskDWord, 0x82110000);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_PI_B, bMaskDWord, 0x28110000);
/* LO calibration setting */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Rsp, bMaskDWord, 0x0046a8d1);
/* enter IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x808000);
/* switch to path B */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, 0x00000280);
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xb0, bRFRegOffsetMask, 0xeffe0); */
/* GNT_BT = 0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00000800);
/* One shot, path B LOK & IQK */
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf9000000);
PHY_SetBBReg(pDM_Odm->Adapter, rIQK_AGC_Pts, bMaskDWord, 0xf8000000);
/* delay x ms */
/* PlatformStallExecution(IQK_DELAY_TIME_88E*1000); */
mdelay(IQK_DELAY_TIME_8723B);
/* restore Ant Path */
PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, Path_SEL_BB);
/* GNT_BT = 1 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, 0x00001800);
/* leave IQK mode */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
/* Check failed */
regEAC = PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_After_IQK_A_2, bMaskDWord);
regEA4 = PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_Before_IQK_A_2, bMaskDWord);
/* PA/PAD controlled by 0x0 */
/* leave IQK mode */
/* PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, 0xffffff00, 0x00000000); */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_B, 0xdf, bRFRegOffsetMask, 0x180); */
/* Allen 20131125 */
tmp = (regEAC & 0x03FF0000)>>16;
if ((tmp & 0x200) > 0)
tmp = 0x400 - tmp;
if (
!(regEAC & BIT27) && /* if Tx is OK, check whether Rx is OK */
(((regEA4 & 0x03FF0000)>>16) != 0x132) &&
(((regEAC & 0x03FF0000)>>16) != 0x36) &&
(((regEA4 & 0x03FF0000)>>16) < 0x110) &&
(((regEA4 & 0x03FF0000)>>16) > 0xf0) &&
(tmp < 0xf)
)
result |= 0x02;
return result;
}
static void _PHY_PathAFillIQKMatrix8723B(
struct adapter *padapter,
bool bIQKOK,
s32 result[][8],
u8 final_candidate,
bool bTxOnly
)
{
u32 Oldval_0, X, TX0_A, reg;
s32 Y, TX0_C;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
struct odm_rf_cal_t *pRFCalibrateInfo = &pDM_Odm->RFCalibrateInfo;
if (final_candidate == 0xFF)
return;
else if (bIQKOK) {
Oldval_0 = (PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XATxIQImbalance, bMaskDWord) >> 22) & 0x3FF;
X = result[final_candidate][0];
if ((X & 0x00000200) != 0)
X = X | 0xFFFFFC00;
TX0_A = (X * Oldval_0) >> 8;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XATxIQImbalance, 0x3FF, TX0_A);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, BIT(31), ((X*Oldval_0>>7) & 0x1));
Y = result[final_candidate][1];
if ((Y & 0x00000200) != 0)
Y = Y | 0xFFFFFC00;
/* 2 Tx IQC */
TX0_C = (Y * Oldval_0) >> 8;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XCTxAFE, 0xF0000000, ((TX0_C&0x3C0)>>6));
pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC94][KEY] = rOFDM0_XCTxAFE;
pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC94][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XCTxAFE, bMaskDWord);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XATxIQImbalance, 0x003F0000, (TX0_C&0x3F));
pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC80][KEY] = rOFDM0_XATxIQImbalance;
pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC80][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XATxIQImbalance, bMaskDWord);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, BIT(29), ((Y*Oldval_0>>7) & 0x1));
pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC4C][KEY] = rOFDM0_ECCAThreshold;
pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC4C][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, bMaskDWord);
if (bTxOnly) {
/* <20130226, Kordan> Saving RxIQC, otherwise not initialized. */
pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xCA0][KEY] = rOFDM0_RxIQExtAnta;
pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xCA0][VAL] = 0xfffffff & PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_RxIQExtAnta, bMaskDWord);
pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xC14][KEY] = rOFDM0_XARxIQImbalance;
/* pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xC14][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XARxIQImbalance, bMaskDWord); */
pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xC14][VAL] = 0x40000100;
return;
}
reg = result[final_candidate][2];
/* 2 Rx IQC */
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XARxIQImbalance, 0x3FF, reg);
reg = result[final_candidate][3] & 0x3F;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XARxIQImbalance, 0xFC00, reg);
pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xC14][KEY] = rOFDM0_XARxIQImbalance;
pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xC14][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XARxIQImbalance, bMaskDWord);
reg = (result[final_candidate][3] >> 6) & 0xF;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_RxIQExtAnta, 0xF0000000, reg);
pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xCA0][KEY] = rOFDM0_RxIQExtAnta;
pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xCA0][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_RxIQExtAnta, bMaskDWord);
}
}
static void _PHY_PathBFillIQKMatrix8723B(
struct adapter *padapter,
bool bIQKOK,
s32 result[][8],
u8 final_candidate,
bool bTxOnly /* do Tx only */
)
{
u32 Oldval_1, X, TX1_A, reg;
s32 Y, TX1_C;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
struct odm_rf_cal_t *pRFCalibrateInfo = &pDM_Odm->RFCalibrateInfo;
if (final_candidate == 0xFF)
return;
else if (bIQKOK) {
Oldval_1 = (PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XBTxIQImbalance, bMaskDWord) >> 22) & 0x3FF;
X = result[final_candidate][4];
if ((X & 0x00000200) != 0)
X = X | 0xFFFFFC00;
TX1_A = (X * Oldval_1) >> 8;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XBTxIQImbalance, 0x3FF, TX1_A);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, BIT(27), ((X*Oldval_1>>7) & 0x1));
Y = result[final_candidate][5];
if ((Y & 0x00000200) != 0)
Y = Y | 0xFFFFFC00;
TX1_C = (Y * Oldval_1) >> 8;
/* 2 Tx IQC */
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XDTxAFE, 0xF0000000, ((TX1_C&0x3C0)>>6));
/* pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC9C][KEY] = rOFDM0_XDTxAFE; */
/* pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC9C][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XDTxAFE, bMaskDWord); */
pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC94][KEY] = rOFDM0_XCTxAFE;
pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC94][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XDTxAFE, bMaskDWord);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XBTxIQImbalance, 0x003F0000, (TX1_C&0x3F));
pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC80][KEY] = rOFDM0_XATxIQImbalance;
pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC80][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XBTxIQImbalance, bMaskDWord);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, BIT(25), ((Y*Oldval_1>>7) & 0x1));
pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC4C][KEY] = rOFDM0_ECCAThreshold;
pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC4C][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, bMaskDWord);
if (bTxOnly) {
pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xC14][KEY] = rOFDM0_XARxIQImbalance;
/* pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xC14][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XARxIQImbalance, bMaskDWord); */
pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xC14][VAL] = 0x40000100;
pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xCA0][KEY] = rOFDM0_RxIQExtAnta;
pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xCA0][VAL] = 0x0fffffff & PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_RxIQExtAnta, bMaskDWord);
return;
}
/* 2 Rx IQC */
reg = result[final_candidate][6];
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XBRxIQImbalance, 0x3FF, reg);
reg = result[final_candidate][7] & 0x3F;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_XBRxIQImbalance, 0xFC00, reg);
pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xC14][KEY] = rOFDM0_XARxIQImbalance;
pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xC14][VAL] = PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_XBRxIQImbalance, bMaskDWord);
reg = (result[final_candidate][7] >> 6) & 0xF;
/* PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_AGCRSSITable, 0x0000F000, reg); */
pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xCA0][KEY] = rOFDM0_RxIQExtAnta;
pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xCA0][VAL] = (reg << 28)|(PHY_QueryBBReg(pDM_Odm->Adapter, rOFDM0_RxIQExtAnta, bMaskDWord)&0x0fffffff);
}
}
/* */
/* 2011/07/26 MH Add an API for testing IQK fail case. */
/* */
/* MP Already declare in odm.c */
void ODM_SetIQCbyRFpath(struct dm_odm_t *pDM_Odm, u32 RFpath)
{
struct odm_rf_cal_t *pRFCalibrateInfo = &pDM_Odm->RFCalibrateInfo;
if (
(pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC80][VAL] != 0x0) &&
(pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xC14][VAL] != 0x0) &&
(pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC80][VAL] != 0x0) &&
(pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xC14][VAL] != 0x0)
) {
if (RFpath) { /* S1: RFpath = 0, S0:RFpath = 1 */
/* S0 TX IQC */
PHY_SetBBReg(pDM_Odm->Adapter, pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC94][KEY], bMaskDWord, pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC94][VAL]);
PHY_SetBBReg(pDM_Odm->Adapter, pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC80][KEY], bMaskDWord, pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC80][VAL]);
PHY_SetBBReg(pDM_Odm->Adapter, pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC4C][KEY], bMaskDWord, pRFCalibrateInfo->TxIQC_8723B[PATH_S0][IDX_0xC4C][VAL]);
/* S0 RX IQC */
PHY_SetBBReg(pDM_Odm->Adapter, pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xC14][KEY], bMaskDWord, pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xC14][VAL]);
PHY_SetBBReg(pDM_Odm->Adapter, pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xCA0][KEY], bMaskDWord, pRFCalibrateInfo->RxIQC_8723B[PATH_S0][IDX_0xCA0][VAL]);
} else {
/* S1 TX IQC */
PHY_SetBBReg(pDM_Odm->Adapter, pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC94][KEY], bMaskDWord, pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC94][VAL]);
PHY_SetBBReg(pDM_Odm->Adapter, pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC80][KEY], bMaskDWord, pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC80][VAL]);
PHY_SetBBReg(pDM_Odm->Adapter, pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC4C][KEY], bMaskDWord, pRFCalibrateInfo->TxIQC_8723B[PATH_S1][IDX_0xC4C][VAL]);
/* S1 RX IQC */
PHY_SetBBReg(pDM_Odm->Adapter, pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xC14][KEY], bMaskDWord, pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xC14][VAL]);
PHY_SetBBReg(pDM_Odm->Adapter, pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xCA0][KEY], bMaskDWord, pRFCalibrateInfo->RxIQC_8723B[PATH_S1][IDX_0xCA0][VAL]);
}
}
}
static bool ODM_CheckPowerStatus(struct adapter *Adapter)
{
return true;
}
static void _PHY_SaveADDARegisters8723B(
struct adapter *padapter,
u32 *ADDAReg,
u32 *ADDABackup,
u32 RegisterNum
)
{
u32 i;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
if (!ODM_CheckPowerStatus(padapter))
return;
for (i = 0 ; i < RegisterNum ; i++) {
ADDABackup[i] = PHY_QueryBBReg(pDM_Odm->Adapter, ADDAReg[i], bMaskDWord);
}
}
static void _PHY_SaveMACRegisters8723B(
struct adapter *padapter, u32 *MACReg, u32 *MACBackup
)
{
u32 i;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
for (i = 0 ; i < (IQK_MAC_REG_NUM - 1); i++) {
MACBackup[i] = rtw_read8(pDM_Odm->Adapter, MACReg[i]);
}
MACBackup[i] = rtw_read32(pDM_Odm->Adapter, MACReg[i]);
}
static void _PHY_ReloadADDARegisters8723B(
struct adapter *padapter,
u32 *ADDAReg,
u32 *ADDABackup,
u32 RegiesterNum
)
{
u32 i;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
for (i = 0 ; i < RegiesterNum; i++) {
PHY_SetBBReg(pDM_Odm->Adapter, ADDAReg[i], bMaskDWord, ADDABackup[i]);
}
}
static void _PHY_ReloadMACRegisters8723B(
struct adapter *padapter, u32 *MACReg, u32 *MACBackup
)
{
u32 i;
for (i = 0 ; i < (IQK_MAC_REG_NUM - 1); i++) {
rtw_write8(padapter, MACReg[i], (u8)MACBackup[i]);
}
rtw_write32(padapter, MACReg[i], MACBackup[i]);
}
static void _PHY_PathADDAOn8723B(
struct adapter *padapter,
u32 *ADDAReg,
bool is2T
)
{
u32 pathOn;
u32 i;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
pathOn = 0x01c00014;
if (!is2T) {
pathOn = 0x01c00014;
PHY_SetBBReg(pDM_Odm->Adapter, ADDAReg[0], bMaskDWord, 0x01c00014);
} else {
PHY_SetBBReg(pDM_Odm->Adapter, ADDAReg[0], bMaskDWord, pathOn);
}
for (i = 1 ; i < IQK_ADDA_REG_NUM ; i++) {
PHY_SetBBReg(pDM_Odm->Adapter, ADDAReg[i], bMaskDWord, pathOn);
}
}
static void _PHY_MACSettingCalibration8723B(
struct adapter *padapter, u32 *MACReg, u32 *MACBackup
)
{
u32 i = 0;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
rtw_write8(pDM_Odm->Adapter, MACReg[i], 0x3F);
for (i = 1 ; i < (IQK_MAC_REG_NUM - 1); i++) {
rtw_write8(pDM_Odm->Adapter, MACReg[i], (u8)(MACBackup[i]&(~BIT3)));
}
rtw_write8(pDM_Odm->Adapter, MACReg[i], (u8)(MACBackup[i]&(~BIT5)));
}
static bool phy_SimularityCompare_8723B(
struct adapter *padapter,
s32 result[][8],
u8 c1,
u8 c2
)
{
u32 i, j, diff, SimularityBitMap, bound = 0;
u8 final_candidate[2] = {0xFF, 0xFF}; /* for path A and path B */
bool bResult = true;
s32 tmp1 = 0, tmp2 = 0;
bound = 8;
SimularityBitMap = 0;
for (i = 0; i < bound; i++) {
if ((i == 1) || (i == 3) || (i == 5) || (i == 7)) {
if ((result[c1][i] & 0x00000200) != 0)
tmp1 = result[c1][i] | 0xFFFFFC00;
else
tmp1 = result[c1][i];
if ((result[c2][i] & 0x00000200) != 0)
tmp2 = result[c2][i] | 0xFFFFFC00;
else
tmp2 = result[c2][i];
} else {
tmp1 = result[c1][i];
tmp2 = result[c2][i];
}
diff = (tmp1 > tmp2) ? (tmp1 - tmp2) : (tmp2 - tmp1);
if (diff > MAX_TOLERANCE) {
if ((i == 2 || i == 6) && !SimularityBitMap) {
if (result[c1][i]+result[c1][i+1] == 0)
final_candidate[(i/4)] = c2;
else if (result[c2][i]+result[c2][i+1] == 0)
final_candidate[(i/4)] = c1;
else
SimularityBitMap = SimularityBitMap|(1<<i);
} else
SimularityBitMap = SimularityBitMap|(1<<i);
}
}
if (SimularityBitMap == 0) {
for (i = 0; i < (bound/4); i++) {
if (final_candidate[i] != 0xFF) {
for (j = i*4; j < (i+1)*4-2; j++)
result[3][j] = result[final_candidate[i]][j];
bResult = false;
}
}
return bResult;
} else {
if (!(SimularityBitMap & 0x03)) { /* path A TX OK */
for (i = 0; i < 2; i++)
result[3][i] = result[c1][i];
}
if (!(SimularityBitMap & 0x0c)) { /* path A RX OK */
for (i = 2; i < 4; i++)
result[3][i] = result[c1][i];
}
if (!(SimularityBitMap & 0x30)) { /* path B TX OK */
for (i = 4; i < 6; i++)
result[3][i] = result[c1][i];
}
if (!(SimularityBitMap & 0xc0)) { /* path B RX OK */
for (i = 6; i < 8; i++)
result[3][i] = result[c1][i];
}
return false;
}
}
static void phy_IQCalibrate_8723B(
struct adapter *padapter,
s32 result[][8],
u8 t,
bool is2T,
u8 RF_Path
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
u32 i;
u8 PathAOK, PathBOK;
u8 tmp0xc50 = (u8)PHY_QueryBBReg(pDM_Odm->Adapter, 0xC50, bMaskByte0);
u8 tmp0xc58 = (u8)PHY_QueryBBReg(pDM_Odm->Adapter, 0xC58, bMaskByte0);
u32 ADDA_REG[IQK_ADDA_REG_NUM] = {
rFPGA0_XCD_SwitchControl,
rBlue_Tooth,
rRx_Wait_CCA,
rTx_CCK_RFON,
rTx_CCK_BBON,
rTx_OFDM_RFON,
rTx_OFDM_BBON,
rTx_To_Rx,
rTx_To_Tx,
rRx_CCK,
rRx_OFDM,
rRx_Wait_RIFS,
rRx_TO_Rx,
rStandby,
rSleep,
rPMPD_ANAEN
};
u32 IQK_MAC_REG[IQK_MAC_REG_NUM] = {
REG_TXPAUSE,
REG_BCN_CTRL,
REG_BCN_CTRL_1,
REG_GPIO_MUXCFG
};
/* since 92C & 92D have the different define in IQK_BB_REG */
u32 IQK_BB_REG_92C[IQK_BB_REG_NUM] = {
rOFDM0_TRxPathEnable,
rOFDM0_TRMuxPar,
rFPGA0_XCD_RFInterfaceSW,
rConfig_AntA,
rConfig_AntB,
rFPGA0_XAB_RFInterfaceSW,
rFPGA0_XA_RFInterfaceOE,
rFPGA0_XB_RFInterfaceOE,
rCCK0_AFESetting
};
const u32 retryCount = 2;
/* Note: IQ calibration must be performed after loading */
/* PHY_REG.txt , and radio_a, radio_b.txt */
/* u32 bbvalue; */
if (t == 0) {
/* Save ADDA parameters, turn Path A ADDA on */
_PHY_SaveADDARegisters8723B(padapter, ADDA_REG, pDM_Odm->RFCalibrateInfo.ADDA_backup, IQK_ADDA_REG_NUM);
_PHY_SaveMACRegisters8723B(padapter, IQK_MAC_REG, pDM_Odm->RFCalibrateInfo.IQK_MAC_backup);
_PHY_SaveADDARegisters8723B(padapter, IQK_BB_REG_92C, pDM_Odm->RFCalibrateInfo.IQK_BB_backup, IQK_BB_REG_NUM);
}
_PHY_PathADDAOn8723B(padapter, ADDA_REG, is2T);
/* no serial mode */
/* save RF path for 8723B */
/* Path_SEL_BB = PHY_QueryBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord); */
/* Path_SEL_RF = PHY_QueryRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xb0, 0xfffff); */
/* MAC settings */
_PHY_MACSettingCalibration8723B(padapter, IQK_MAC_REG, pDM_Odm->RFCalibrateInfo.IQK_MAC_backup);
/* BB setting */
/* PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_RFMOD, BIT24, 0x00); */
PHY_SetBBReg(pDM_Odm->Adapter, rCCK0_AFESetting, 0x0f000000, 0xf);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_TRxPathEnable, bMaskDWord, 0x03a05600);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_TRMuxPar, bMaskDWord, 0x000800e4);
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_XCD_RFInterfaceSW, bMaskDWord, 0x22204000);
/* PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_XAB_RFInterfaceSW, BIT10, 0x01); */
/* PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_XAB_RFInterfaceSW, BIT26, 0x01); */
/* PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_XA_RFInterfaceOE, BIT10, 0x00); */
/* PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_XB_RFInterfaceOE, BIT10, 0x00); */
/* RX IQ calibration setting for 8723B D cut large current issue when leaving IPS */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_RCK_OS, bRFRegOffsetMask, 0x30000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G1, bRFRegOffsetMask, 0x0001f);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G2, bRFRegOffsetMask, 0xf7fb7);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xed, 0x20, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0x43, bRFRegOffsetMask, 0x60fbd);
/* path A TX IQK */
for (i = 0 ; i < retryCount ; i++) {
PathAOK = phy_PathA_IQK_8723B(padapter, is2T, RF_Path);
/* if (PathAOK == 0x03) { */
if (PathAOK == 0x01) {
/* Path A Tx IQK Success */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
pDM_Odm->RFCalibrateInfo.TxLOK[RF_PATH_A] = PHY_QueryRFReg(pDM_Odm->Adapter, RF_PATH_A, 0x8, bRFRegOffsetMask);
result[t][0] = (PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_Before_IQK_A, bMaskDWord)&0x3FF0000)>>16;
result[t][1] = (PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_After_IQK_A, bMaskDWord)&0x3FF0000)>>16;
break;
}
}
/* path A RXIQK */
for (i = 0 ; i < retryCount ; i++) {
PathAOK = phy_PathA_RxIQK8723B(padapter, is2T, RF_Path);
if (PathAOK == 0x03) {
/* result[t][0] = (PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_Before_IQK_A, bMaskDWord)&0x3FF0000)>>16; */
/* result[t][1] = (PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_After_IQK_A, bMaskDWord)&0x3FF0000)>>16; */
result[t][2] = (PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_Before_IQK_A_2, bMaskDWord)&0x3FF0000)>>16;
result[t][3] = (PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_After_IQK_A_2, bMaskDWord)&0x3FF0000)>>16;
break;
}
}
if (0x00 == PathAOK) {
}
/* path B IQK */
if (is2T) {
/* path B TX IQK */
for (i = 0 ; i < retryCount ; i++) {
PathBOK = phy_PathB_IQK_8723B(padapter);
if (PathBOK == 0x01) {
/* Path B Tx IQK Success */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0x000000);
pDM_Odm->RFCalibrateInfo.TxLOK[RF_PATH_B] = PHY_QueryRFReg(pDM_Odm->Adapter, RF_PATH_B, 0x8, bRFRegOffsetMask);
result[t][4] = (PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_Before_IQK_A, bMaskDWord)&0x3FF0000)>>16;
result[t][5] = (PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_After_IQK_A, bMaskDWord)&0x3FF0000)>>16;
break;
}
}
/* path B RX IQK */
for (i = 0 ; i < retryCount ; i++) {
PathBOK = phy_PathB_RxIQK8723B(padapter, is2T);
if (PathBOK == 0x03) {
/* result[t][0] = (PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_Before_IQK_A, bMaskDWord)&0x3FF0000)>>16; */
/* result[t][1] = (PHY_QueryBBReg(pDM_Odm->Adapter, rTx_Power_After_IQK_A, bMaskDWord)&0x3FF0000)>>16; */
result[t][6] = (PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_Before_IQK_A_2, bMaskDWord)&0x3FF0000)>>16;
result[t][7] = (PHY_QueryBBReg(pDM_Odm->Adapter, rRx_Power_After_IQK_A_2, bMaskDWord)&0x3FF0000)>>16;
break;
}
}
/* Allen end */
}
/* Back to BB mode, load original value */
PHY_SetBBReg(pDM_Odm->Adapter, rFPGA0_IQK, bMaskH3Bytes, 0);
if (t != 0) {
/* Reload ADDA power saving parameters */
_PHY_ReloadADDARegisters8723B(padapter, ADDA_REG, pDM_Odm->RFCalibrateInfo.ADDA_backup, IQK_ADDA_REG_NUM);
/* Reload MAC parameters */
_PHY_ReloadMACRegisters8723B(padapter, IQK_MAC_REG, pDM_Odm->RFCalibrateInfo.IQK_MAC_backup);
_PHY_ReloadADDARegisters8723B(padapter, IQK_BB_REG_92C, pDM_Odm->RFCalibrateInfo.IQK_BB_backup, IQK_BB_REG_NUM);
/* Reload RF path */
/* PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, Path_SEL_BB); */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xb0, 0xfffff, Path_SEL_RF); */
/* Allen initial gain 0xc50 */
/* Restore RX initial gain */
PHY_SetBBReg(pDM_Odm->Adapter, 0xc50, bMaskByte0, 0x50);
PHY_SetBBReg(pDM_Odm->Adapter, 0xc50, bMaskByte0, tmp0xc50);
if (is2T) {
PHY_SetBBReg(pDM_Odm->Adapter, 0xc58, bMaskByte0, 0x50);
PHY_SetBBReg(pDM_Odm->Adapter, 0xc58, bMaskByte0, tmp0xc58);
}
/* load 0xe30 IQC default value */
PHY_SetBBReg(pDM_Odm->Adapter, rTx_IQK_Tone_A, bMaskDWord, 0x01008c00);
PHY_SetBBReg(pDM_Odm->Adapter, rRx_IQK_Tone_A, bMaskDWord, 0x01008c00);
}
}
static void phy_LCCalibrate_8723B(struct dm_odm_t *pDM_Odm, bool is2T)
{
u8 tmpReg;
u32 RF_Amode = 0, RF_Bmode = 0, LC_Cal;
struct adapter *padapter = pDM_Odm->Adapter;
/* Check continuous TX and Packet TX */
tmpReg = rtw_read8(pDM_Odm->Adapter, 0xd03);
if ((tmpReg&0x70) != 0) /* Deal with contisuous TX case */
rtw_write8(pDM_Odm->Adapter, 0xd03, tmpReg&0x8F); /* disable all continuous TX */
else /* Deal with Packet TX case */
rtw_write8(pDM_Odm->Adapter, REG_TXPAUSE, 0xFF); /* block all queues */
if ((tmpReg&0x70) != 0) {
/* 1. Read original RF mode */
/* Path-A */
RF_Amode = PHY_QueryRFReg(padapter, RF_PATH_A, RF_AC, bMask12Bits);
/* Path-B */
if (is2T)
RF_Bmode = PHY_QueryRFReg(padapter, RF_PATH_B, RF_AC, bMask12Bits);
/* 2. Set RF mode = standby mode */
/* Path-A */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_AC, bMask12Bits, (RF_Amode&0x8FFFF)|0x10000);
/* Path-B */
if (is2T)
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_B, RF_AC, bMask12Bits, (RF_Bmode&0x8FFFF)|0x10000);
}
/* 3. Read RF reg18 */
LC_Cal = PHY_QueryRFReg(padapter, RF_PATH_A, RF_CHNLBW, bMask12Bits);
/* 4. Set LC calibration begin bit15 */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xB0, bRFRegOffsetMask, 0xDFBE0); /* LDO ON */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_CHNLBW, bMask12Bits, LC_Cal|0x08000);
mdelay(100);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xB0, bRFRegOffsetMask, 0xDFFE0); /* LDO OFF */
/* Channel 10 LC calibration issue for 8723bs with 26M xtal */
if (pDM_Odm->SupportInterface == ODM_ITRF_SDIO && pDM_Odm->PackageType >= 0x2) {
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_CHNLBW, bMask12Bits, LC_Cal);
}
/* Restore original situation */
if ((tmpReg&0x70) != 0) { /* Deal with contisuous TX case */
/* Path-A */
rtw_write8(pDM_Odm->Adapter, 0xd03, tmpReg);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_AC, bMask12Bits, RF_Amode);
/* Path-B */
if (is2T)
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_B, RF_AC, bMask12Bits, RF_Bmode);
} else /* Deal with Packet TX case */
rtw_write8(pDM_Odm->Adapter, REG_TXPAUSE, 0x00);
}
/* IQK version:V2.5 20140123 */
/* IQK is controlled by Is2ant, RF path */
void PHY_IQCalibrate_8723B(
struct adapter *padapter,
bool bReCovery,
bool bRestore,
bool Is2ant, /* false:1ant, true:2-ant */
u8 RF_Path /* 0:S1, 1:S0 */
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
s32 result[4][8]; /* last is final result */
u8 i, final_candidate;
bool bPathAOK, bPathBOK;
s32 RegE94, RegE9C, RegEA4, RegEB4, RegEBC, RegEC4, RegTmp = 0;
bool is12simular, is13simular, is23simular;
bool bSingleTone = false, bCarrierSuppression = false;
u32 IQK_BB_REG_92C[IQK_BB_REG_NUM] = {
rOFDM0_XARxIQImbalance,
rOFDM0_XBRxIQImbalance,
rOFDM0_ECCAThreshold,
rOFDM0_AGCRSSITable,
rOFDM0_XATxIQImbalance,
rOFDM0_XBTxIQImbalance,
rOFDM0_XCTxAFE,
rOFDM0_XDTxAFE,
rOFDM0_RxIQExtAnta
};
/* u32 Path_SEL_BB = 0; */
u32 GNT_BT_default;
if (!ODM_CheckPowerStatus(padapter))
return;
if (!(pDM_Odm->SupportAbility & ODM_RF_CALIBRATION))
return;
/* 20120213<Kordan> Turn on when continuous Tx to pass lab testing. (required by Edlu) */
if (bSingleTone || bCarrierSuppression)
return;
if (pDM_Odm->RFCalibrateInfo.bIQKInProgress)
return;
pDM_Odm->RFCalibrateInfo.bIQKInProgress = true;
if (bRestore) {
u32 offset, data;
u8 path, bResult = SUCCESS;
struct odm_rf_cal_t *pRFCalibrateInfo = &pDM_Odm->RFCalibrateInfo;
path = (PHY_QueryBBReg(pDM_Odm->Adapter, rS0S1_PathSwitch, bMaskByte0) == 0x00) ? RF_PATH_A : RF_PATH_B;
/* Restore TX IQK */
for (i = 0; i < 3; ++i) {
offset = pRFCalibrateInfo->TxIQC_8723B[path][i][0];
data = pRFCalibrateInfo->TxIQC_8723B[path][i][1];
if ((offset == 0) || (data == 0)) {
bResult = FAIL;
break;
}
PHY_SetBBReg(pDM_Odm->Adapter, offset, bMaskDWord, data);
}
/* Restore RX IQK */
for (i = 0; i < 2; ++i) {
offset = pRFCalibrateInfo->RxIQC_8723B[path][i][0];
data = pRFCalibrateInfo->RxIQC_8723B[path][i][1];
if ((offset == 0) || (data == 0)) {
bResult = FAIL;
break;
}
PHY_SetBBReg(pDM_Odm->Adapter, offset, bMaskDWord, data);
}
if (pDM_Odm->RFCalibrateInfo.TxLOK[RF_PATH_A] == 0) {
bResult = FAIL;
} else {
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXM_IDAC, bRFRegOffsetMask, pDM_Odm->RFCalibrateInfo.TxLOK[RF_PATH_A]);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_B, RF_TXM_IDAC, bRFRegOffsetMask, pDM_Odm->RFCalibrateInfo.TxLOK[RF_PATH_B]);
}
if (bResult == SUCCESS)
return;
}
if (bReCovery) {
_PHY_ReloadADDARegisters8723B(padapter, IQK_BB_REG_92C, pDM_Odm->RFCalibrateInfo.IQK_BB_backup_recover, 9);
return;
}
/* save default GNT_BT */
GNT_BT_default = PHY_QueryBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord);
/* Save RF Path */
/* Path_SEL_BB = PHY_QueryBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord); */
/* Path_SEL_RF = PHY_QueryRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xb0, 0xfffff); */
/* set GNT_BT = 0, pause BT traffic */
/* PHY_SetBBReg(pDM_Odm->Adapter, 0x764, BIT12, 0x0); */
/* PHY_SetBBReg(pDM_Odm->Adapter, 0x764, BIT11, 0x1); */
for (i = 0; i < 8; i++) {
result[0][i] = 0;
result[1][i] = 0;
result[2][i] = 0;
result[3][i] = 0;
}
final_candidate = 0xff;
bPathAOK = false;
bPathBOK = false;
is12simular = false;
is23simular = false;
is13simular = false;
for (i = 0; i < 3; i++) {
phy_IQCalibrate_8723B(padapter, result, i, Is2ant, RF_Path);
if (i == 1) {
is12simular = phy_SimularityCompare_8723B(padapter, result, 0, 1);
if (is12simular) {
final_candidate = 0;
break;
}
}
if (i == 2) {
is13simular = phy_SimularityCompare_8723B(padapter, result, 0, 2);
if (is13simular) {
final_candidate = 0;
break;
}
is23simular = phy_SimularityCompare_8723B(padapter, result, 1, 2);
if (is23simular) {
final_candidate = 1;
} else {
for (i = 0; i < 8; i++)
RegTmp += result[3][i];
if (RegTmp != 0)
final_candidate = 3;
else
final_candidate = 0xFF;
}
}
}
for (i = 0; i < 4; i++) {
RegE94 = result[i][0];
RegE9C = result[i][1];
RegEA4 = result[i][2];
RegEB4 = result[i][4];
RegEBC = result[i][5];
RegEC4 = result[i][6];
}
if (final_candidate != 0xff) {
pDM_Odm->RFCalibrateInfo.RegE94 = RegE94 = result[final_candidate][0];
pDM_Odm->RFCalibrateInfo.RegE9C = RegE9C = result[final_candidate][1];
RegEA4 = result[final_candidate][2];
pDM_Odm->RFCalibrateInfo.RegEB4 = RegEB4 = result[final_candidate][4];
pDM_Odm->RFCalibrateInfo.RegEBC = RegEBC = result[final_candidate][5];
RegEC4 = result[final_candidate][6];
bPathAOK = bPathBOK = true;
} else {
pDM_Odm->RFCalibrateInfo.RegE94 = pDM_Odm->RFCalibrateInfo.RegEB4 = 0x100; /* X default value */
pDM_Odm->RFCalibrateInfo.RegE9C = pDM_Odm->RFCalibrateInfo.RegEBC = 0x0; /* Y default value */
}
{
if (RegE94 != 0)
_PHY_PathAFillIQKMatrix8723B(padapter, bPathAOK, result, final_candidate, (RegEA4 == 0));
}
{
if (RegEB4 != 0)
_PHY_PathBFillIQKMatrix8723B(padapter, bPathBOK, result, final_candidate, (RegEC4 == 0));
}
/* To Fix BSOD when final_candidate is 0xff */
/* by sherry 20120321 */
if (final_candidate < 4) {
for (i = 0; i < IQK_MATRIX_REG_NUM; i++)
pDM_Odm->RFCalibrateInfo.iqk_matrix_regs_setting_value[0][i] = result[final_candidate][i];
}
_PHY_SaveADDARegisters8723B(padapter, IQK_BB_REG_92C, pDM_Odm->RFCalibrateInfo.IQK_BB_backup_recover, 9);
/* restore GNT_BT */
PHY_SetBBReg(pDM_Odm->Adapter, 0x764, bMaskDWord, GNT_BT_default);
/* Restore RF Path */
/* PHY_SetBBReg(pDM_Odm->Adapter, 0x948, bMaskDWord, Path_SEL_BB); */
/* PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xb0, 0xfffff, Path_SEL_RF); */
/* Resotr RX mode table parameter */
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_WE_LUT, 0x80000, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_RCK_OS, bRFRegOffsetMask, 0x18000);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G1, bRFRegOffsetMask, 0x0001f);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, RF_TXPA_G2, bRFRegOffsetMask, 0xe6177);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0xed, 0x20, 0x1);
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH_A, 0x43, bRFRegOffsetMask, 0x300bd);
/* set GNT_BT = HW control */
/* PHY_SetBBReg(pDM_Odm->Adapter, 0x764, BIT12, 0x0); */
/* PHY_SetBBReg(pDM_Odm->Adapter, 0x764, BIT11, 0x0); */
if (Is2ant) {
if (RF_Path == 0x0) /* S1 */
ODM_SetIQCbyRFpath(pDM_Odm, 0);
else /* S0 */
ODM_SetIQCbyRFpath(pDM_Odm, 1);
}
pDM_Odm->RFCalibrateInfo.bIQKInProgress = false;
}
void PHY_LCCalibrate_8723B(struct dm_odm_t *pDM_Odm)
{
bool bSingleTone = false, bCarrierSuppression = false;
u32 timeout = 2000, timecount = 0;
if (!(pDM_Odm->SupportAbility & ODM_RF_CALIBRATION))
return;
/* 20120213<Kordan> Turn on when continuous Tx to pass lab testing. (required by Edlu) */
if (bSingleTone || bCarrierSuppression)
return;
while (*(pDM_Odm->pbScanInProcess) && timecount < timeout) {
mdelay(50);
timecount += 50;
}
pDM_Odm->RFCalibrateInfo.bLCKInProgress = true;
phy_LCCalibrate_8723B(pDM_Odm, false);
pDM_Odm->RFCalibrateInfo.bLCKInProgress = false;
}
| linux-master | drivers/staging/rtl8723bs/hal/HalPhyRf_8723B.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <rtl8723b_hal.h>
static void process_rssi(struct adapter *padapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
struct signal_stat *signal_stat = &padapter->recvpriv.signal_strength_data;
/* if (pRfd->Status.bPacketToSelf || pRfd->Status.bPacketBeacon) */
{
if (signal_stat->update_req) {
signal_stat->total_num = 0;
signal_stat->total_val = 0;
signal_stat->update_req = 0;
}
signal_stat->total_num++;
signal_stat->total_val += pattrib->phy_info.SignalStrength;
signal_stat->avg_val = signal_stat->total_val / signal_stat->total_num;
}
} /* Process_UI_RSSI_8192C */
static void process_link_qual(struct adapter *padapter, union recv_frame *prframe)
{
struct rx_pkt_attrib *pattrib;
struct signal_stat *signal_stat;
if (!prframe || !padapter)
return;
pattrib = &prframe->u.hdr.attrib;
signal_stat = &padapter->recvpriv.signal_qual_data;
if (signal_stat->update_req) {
signal_stat->total_num = 0;
signal_stat->total_val = 0;
signal_stat->update_req = 0;
}
signal_stat->total_num++;
signal_stat->total_val += pattrib->phy_info.SignalQuality;
signal_stat->avg_val = signal_stat->total_val / signal_stat->total_num;
} /* Process_UiLinkQuality8192S */
void rtl8723b_process_phy_info(struct adapter *padapter, void *prframe)
{
union recv_frame *precvframe = prframe;
/* */
/* Check RSSI */
/* */
process_rssi(padapter, precvframe);
/* */
/* Check PWDB. */
/* */
/* process_PWDB(padapter, precvframe); */
/* UpdateRxSignalStatistics8192C(Adapter, pRfd); */
/* */
/* Check EVM */
/* */
process_link_qual(padapter, precvframe);
#ifdef DBG_RX_SIGNAL_DISPLAY_RAW_DATA
rtw_store_phy_info(padapter, prframe);
#endif
}
| linux-master | drivers/staging/rtl8723bs/hal/rtl8723b_rxdesc.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include "odm_precomp.h"
void odm_NHMCounterStatisticsInit(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
/* PHY parameters initialize for n series */
rtw_write16(pDM_Odm->Adapter, ODM_REG_NHM_TIMER_11N+2, 0x2710); /* 0x894[31:16]= 0x2710 Time duration for NHM unit: 4us, 0x2710 =40ms */
/* rtw_write16(pDM_Odm->Adapter, ODM_REG_NHM_TIMER_11N+2, 0x4e20); 0x894[31:16]= 0x4e20 Time duration for NHM unit: 4us, 0x4e20 =80ms */
rtw_write16(pDM_Odm->Adapter, ODM_REG_NHM_TH9_TH10_11N+2, 0xffff); /* 0x890[31:16]= 0xffff th_9, th_10 */
/* rtw_write32(pDM_Odm->Adapter, ODM_REG_NHM_TH3_TO_TH0_11N, 0xffffff5c); 0x898 = 0xffffff5c th_3, th_2, th_1, th_0 */
rtw_write32(pDM_Odm->Adapter, ODM_REG_NHM_TH3_TO_TH0_11N, 0xffffff52); /* 0x898 = 0xffffff52 th_3, th_2, th_1, th_0 */
rtw_write32(pDM_Odm->Adapter, ODM_REG_NHM_TH7_TO_TH4_11N, 0xffffffff); /* 0x89c = 0xffffffff th_7, th_6, th_5, th_4 */
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG_FPGA0_IQK_11N, bMaskByte0, 0xff); /* 0xe28[7:0]= 0xff th_8 */
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG_NHM_TH9_TH10_11N, BIT10|BIT9|BIT8, 0x7); /* 0x890[9:8]=3 enable CCX */
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG_OFDM_FA_RSTC_11N, BIT7, 0x1); /* 0xc0c[7]= 1 max power among all RX ants */
}
void odm_NHMCounterStatistics(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
/* Get NHM report */
odm_GetNHMCounterStatistics(pDM_Odm);
/* Reset NHM counter */
odm_NHMCounterStatisticsReset(pDM_Odm);
}
void odm_GetNHMCounterStatistics(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
u32 value32 = 0;
value32 = PHY_QueryBBReg(pDM_Odm->Adapter, ODM_REG_NHM_CNT_11N, bMaskDWord);
pDM_Odm->NHM_cnt_0 = (u8)(value32 & bMaskByte0);
}
void odm_NHMCounterStatisticsReset(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG_NHM_TH9_TH10_11N, BIT1, 0);
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG_NHM_TH9_TH10_11N, BIT1, 1);
}
void odm_NHMBBInit(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
pDM_Odm->adaptivity_flag = 0;
pDM_Odm->tolerance_cnt = 3;
pDM_Odm->NHMLastTxOkcnt = 0;
pDM_Odm->NHMLastRxOkcnt = 0;
pDM_Odm->NHMCurTxOkcnt = 0;
pDM_Odm->NHMCurRxOkcnt = 0;
}
/* */
void odm_NHMBB(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
/* u8 test_status; */
/* struct false_ALARM_STATISTICS *pFalseAlmCnt = &pDM_Odm->FalseAlmCnt; */
pDM_Odm->NHMCurTxOkcnt =
*(pDM_Odm->pNumTxBytesUnicast)-pDM_Odm->NHMLastTxOkcnt;
pDM_Odm->NHMCurRxOkcnt =
*(pDM_Odm->pNumRxBytesUnicast)-pDM_Odm->NHMLastRxOkcnt;
pDM_Odm->NHMLastTxOkcnt =
*(pDM_Odm->pNumTxBytesUnicast);
pDM_Odm->NHMLastRxOkcnt =
*(pDM_Odm->pNumRxBytesUnicast);
if ((pDM_Odm->NHMCurTxOkcnt) + 1 > (u64)(pDM_Odm->NHMCurRxOkcnt<<2) + 1) { /* Tx > 4*Rx possible for adaptivity test */
if (pDM_Odm->NHM_cnt_0 >= 190 || pDM_Odm->adaptivity_flag == true) {
/* Enable EDCCA since it is possible running Adaptivity testing */
/* test_status = 1; */
pDM_Odm->adaptivity_flag = true;
pDM_Odm->tolerance_cnt = 0;
} else {
if (pDM_Odm->tolerance_cnt < 3)
pDM_Odm->tolerance_cnt = pDM_Odm->tolerance_cnt + 1;
else
pDM_Odm->tolerance_cnt = 4;
/* test_status = 5; */
if (pDM_Odm->tolerance_cnt > 3) {
/* test_status = 3; */
pDM_Odm->adaptivity_flag = false;
}
}
} else { /* TX<RX */
if (pDM_Odm->adaptivity_flag == true && pDM_Odm->NHM_cnt_0 <= 200) {
/* test_status = 2; */
pDM_Odm->tolerance_cnt = 0;
} else {
if (pDM_Odm->tolerance_cnt < 3)
pDM_Odm->tolerance_cnt = pDM_Odm->tolerance_cnt + 1;
else
pDM_Odm->tolerance_cnt = 4;
/* test_status = 5; */
if (pDM_Odm->tolerance_cnt > 3) {
/* test_status = 4; */
pDM_Odm->adaptivity_flag = false;
}
}
}
}
void odm_SearchPwdBLowerBound(void *pDM_VOID, u8 IGI_target)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
u32 value32 = 0;
u8 cnt, IGI;
bool bAdjust = true;
s8 TH_L2H_dmc, TH_H2L_dmc;
s8 Diff;
IGI = 0x50; /* find H2L, L2H lower bound */
ODM_Write_DIG(pDM_Odm, IGI);
Diff = IGI_target-(s8)IGI;
TH_L2H_dmc = pDM_Odm->TH_L2H_ini + Diff;
if (TH_L2H_dmc > 10)
TH_L2H_dmc = 10;
TH_H2L_dmc = TH_L2H_dmc - pDM_Odm->TH_EDCCA_HL_diff;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, bMaskByte0, (u8)TH_L2H_dmc);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, bMaskByte2, (u8)TH_H2L_dmc);
mdelay(5);
while (bAdjust) {
for (cnt = 0; cnt < 20; cnt++) {
value32 = PHY_QueryBBReg(pDM_Odm->Adapter, ODM_REG_RPT_11N, bMaskDWord);
if (value32 & BIT30)
pDM_Odm->txEdcca1 = pDM_Odm->txEdcca1 + 1;
else if (value32 & BIT29)
pDM_Odm->txEdcca1 = pDM_Odm->txEdcca1 + 1;
else
pDM_Odm->txEdcca0 = pDM_Odm->txEdcca0 + 1;
}
if (pDM_Odm->txEdcca1 > 5) {
IGI = IGI-1;
TH_L2H_dmc = TH_L2H_dmc + 1;
if (TH_L2H_dmc > 10)
TH_L2H_dmc = 10;
TH_H2L_dmc = TH_L2H_dmc - pDM_Odm->TH_EDCCA_HL_diff;
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, bMaskByte0, (u8)TH_L2H_dmc);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, bMaskByte2, (u8)TH_H2L_dmc);
pDM_Odm->TxHangFlg = true;
pDM_Odm->txEdcca1 = 0;
pDM_Odm->txEdcca0 = 0;
if (TH_L2H_dmc == 10) {
bAdjust = false;
pDM_Odm->TxHangFlg = false;
pDM_Odm->txEdcca1 = 0;
pDM_Odm->txEdcca0 = 0;
pDM_Odm->H2L_lb = TH_H2L_dmc;
pDM_Odm->L2H_lb = TH_L2H_dmc;
pDM_Odm->Adaptivity_IGI_upper = IGI;
}
} else {
bAdjust = false;
pDM_Odm->TxHangFlg = false;
pDM_Odm->txEdcca1 = 0;
pDM_Odm->txEdcca0 = 0;
pDM_Odm->H2L_lb = TH_H2L_dmc;
pDM_Odm->L2H_lb = TH_L2H_dmc;
pDM_Odm->Adaptivity_IGI_upper = IGI;
}
}
}
void odm_AdaptivityInit(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
if (pDM_Odm->Carrier_Sense_enable == false)
pDM_Odm->TH_L2H_ini = 0xf7; /* -7 */
else
pDM_Odm->TH_L2H_ini = 0xa;
pDM_Odm->AdapEn_RSSI = 20;
pDM_Odm->TH_EDCCA_HL_diff = 7;
pDM_Odm->IGI_Base = 0x32;
pDM_Odm->IGI_target = 0x1c;
pDM_Odm->ForceEDCCA = 0;
pDM_Odm->NHM_disable = false;
pDM_Odm->TxHangFlg = true;
pDM_Odm->txEdcca0 = 0;
pDM_Odm->txEdcca1 = 0;
pDM_Odm->H2L_lb = 0;
pDM_Odm->L2H_lb = 0;
pDM_Odm->Adaptivity_IGI_upper = 0;
odm_NHMBBInit(pDM_Odm);
PHY_SetBBReg(pDM_Odm->Adapter, REG_RD_CTRL, BIT11, 1); /* stop counting if EDCCA is asserted */
}
void odm_Adaptivity(void *pDM_VOID, u8 IGI)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
s8 TH_L2H_dmc, TH_H2L_dmc;
s8 Diff, IGI_target;
bool EDCCA_State = false;
if (!(pDM_Odm->SupportAbility & ODM_BB_ADAPTIVITY)) {
return;
}
if (*pDM_Odm->pBandWidth == ODM_BW20M) /* CHANNEL_WIDTH_20 */
IGI_target = pDM_Odm->IGI_Base;
else if (*pDM_Odm->pBandWidth == ODM_BW40M)
IGI_target = pDM_Odm->IGI_Base + 2;
else
IGI_target = pDM_Odm->IGI_Base;
pDM_Odm->IGI_target = (u8) IGI_target;
/* Search pwdB lower bound */
if (pDM_Odm->TxHangFlg == true) {
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG_DBG_RPT_11N, bMaskDWord, 0x208);
odm_SearchPwdBLowerBound(pDM_Odm, pDM_Odm->IGI_target);
}
if ((!pDM_Odm->bLinked) || (*pDM_Odm->pChannel > 149)) { /* Band4 doesn't need adaptivity */
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, bMaskByte0, 0x7f);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, bMaskByte2, 0x7f);
return;
}
if (!pDM_Odm->ForceEDCCA) {
if (pDM_Odm->RSSI_Min > pDM_Odm->AdapEn_RSSI)
EDCCA_State = true;
else if (pDM_Odm->RSSI_Min < (pDM_Odm->AdapEn_RSSI - 5))
EDCCA_State = false;
} else
EDCCA_State = true;
if (
pDM_Odm->bLinked &&
pDM_Odm->Carrier_Sense_enable == false &&
pDM_Odm->NHM_disable == false &&
pDM_Odm->TxHangFlg == false
)
odm_NHMBB(pDM_Odm);
if (EDCCA_State) {
Diff = IGI_target-(s8)IGI;
TH_L2H_dmc = pDM_Odm->TH_L2H_ini + Diff;
if (TH_L2H_dmc > 10)
TH_L2H_dmc = 10;
TH_H2L_dmc = TH_L2H_dmc - pDM_Odm->TH_EDCCA_HL_diff;
/* replace lower bound to prevent EDCCA always equal */
if (TH_H2L_dmc < pDM_Odm->H2L_lb)
TH_H2L_dmc = pDM_Odm->H2L_lb;
if (TH_L2H_dmc < pDM_Odm->L2H_lb)
TH_L2H_dmc = pDM_Odm->L2H_lb;
} else {
TH_L2H_dmc = 0x7f;
TH_H2L_dmc = 0x7f;
}
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, bMaskByte0, (u8)TH_L2H_dmc);
PHY_SetBBReg(pDM_Odm->Adapter, rOFDM0_ECCAThreshold, bMaskByte2, (u8)TH_H2L_dmc);
}
void ODM_Write_DIG(void *pDM_VOID, u8 CurrentIGI)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct dig_t *pDM_DigTable = &pDM_Odm->DM_DigTable;
if (pDM_DigTable->bStopDIG) {
return;
}
if (pDM_DigTable->CurIGValue != CurrentIGI) {
/* 1 Check initial gain by upper bound */
if (!pDM_DigTable->bPSDInProgress) {
if (CurrentIGI > pDM_DigTable->rx_gain_range_max) {
CurrentIGI = pDM_DigTable->rx_gain_range_max;
}
}
/* 1 Set IGI value */
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG(IGI_A, pDM_Odm), ODM_BIT(IGI, pDM_Odm), CurrentIGI);
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG(IGI_B, pDM_Odm), ODM_BIT(IGI, pDM_Odm), CurrentIGI);
pDM_DigTable->CurIGValue = CurrentIGI;
}
}
bool odm_DigAbort(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
/* SupportAbility */
if (!(pDM_Odm->SupportAbility & ODM_BB_FA_CNT)) {
return true;
}
/* SupportAbility */
if (!(pDM_Odm->SupportAbility & ODM_BB_DIG)) {
return true;
}
/* ScanInProcess */
if (*(pDM_Odm->pbScanInProcess)) {
return true;
}
/* add by Neil Chen to avoid PSD is processing */
if (pDM_Odm->bDMInitialGainEnable == false) {
return true;
}
return false;
}
void odm_DIGInit(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct dig_t *pDM_DigTable = &pDM_Odm->DM_DigTable;
pDM_DigTable->bStopDIG = false;
pDM_DigTable->bPSDInProgress = false;
pDM_DigTable->CurIGValue = (u8) PHY_QueryBBReg(pDM_Odm->Adapter, ODM_REG(IGI_A, pDM_Odm), ODM_BIT(IGI, pDM_Odm));
pDM_DigTable->RssiLowThresh = DM_DIG_THRESH_LOW;
pDM_DigTable->RssiHighThresh = DM_DIG_THRESH_HIGH;
pDM_DigTable->FALowThresh = DMfalseALARM_THRESH_LOW;
pDM_DigTable->FAHighThresh = DMfalseALARM_THRESH_HIGH;
pDM_DigTable->BackoffVal = DM_DIG_BACKOFF_DEFAULT;
pDM_DigTable->BackoffVal_range_max = DM_DIG_BACKOFF_MAX;
pDM_DigTable->BackoffVal_range_min = DM_DIG_BACKOFF_MIN;
pDM_DigTable->PreCCK_CCAThres = 0xFF;
pDM_DigTable->CurCCK_CCAThres = 0x83;
pDM_DigTable->ForbiddenIGI = DM_DIG_MIN_NIC;
pDM_DigTable->LargeFAHit = 0;
pDM_DigTable->Recover_cnt = 0;
pDM_DigTable->bMediaConnect_0 = false;
pDM_DigTable->bMediaConnect_1 = false;
/* To Initialize pDM_Odm->bDMInitialGainEnable == false to avoid DIG error */
pDM_Odm->bDMInitialGainEnable = true;
pDM_DigTable->DIG_Dynamic_MIN_0 = DM_DIG_MIN_NIC;
pDM_DigTable->DIG_Dynamic_MIN_1 = DM_DIG_MIN_NIC;
/* To Initi BT30 IGI */
pDM_DigTable->BT30_CurIGI = 0x32;
pDM_DigTable->rx_gain_range_max = DM_DIG_MAX_NIC;
pDM_DigTable->rx_gain_range_min = DM_DIG_MIN_NIC;
}
void odm_DIG(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
/* Common parameters */
struct dig_t *pDM_DigTable = &pDM_Odm->DM_DigTable;
struct false_ALARM_STATISTICS *pFalseAlmCnt = &pDM_Odm->FalseAlmCnt;
bool FirstConnect, FirstDisConnect;
u8 DIG_MaxOfMin, DIG_Dynamic_MIN;
u8 dm_dig_max, dm_dig_min;
u8 CurrentIGI = pDM_DigTable->CurIGValue;
u8 offset;
u32 dm_FA_thres[3];
u8 Adap_IGI_Upper = 0;
u32 TxTp = 0, RxTp = 0;
bool bDFSBand = false;
bool bPerformance = true, bFirstTpTarget = false, bFirstCoverage = false;
if (odm_DigAbort(pDM_Odm))
return;
if (pDM_Odm->adaptivity_flag == true)
Adap_IGI_Upper = pDM_Odm->Adaptivity_IGI_upper;
/* 1 Update status */
DIG_Dynamic_MIN = pDM_DigTable->DIG_Dynamic_MIN_0;
FirstConnect = (pDM_Odm->bLinked) && (pDM_DigTable->bMediaConnect_0 == false);
FirstDisConnect = (!pDM_Odm->bLinked) && (pDM_DigTable->bMediaConnect_0 == true);
/* 1 Boundary Decision */
/* 2 For WIN\CE */
dm_dig_max = 0x5A;
dm_dig_min = DM_DIG_MIN_NIC;
DIG_MaxOfMin = DM_DIG_MAX_AP;
/* 1 Adjust boundary by RSSI */
if (pDM_Odm->bLinked && bPerformance) {
/* 2 Modify DIG upper bound */
/* 4 Modify DIG upper bound for 92E, 8723A\B, 8821 & 8812 BT */
if (pDM_Odm->bBtLimitedDig == 1) {
offset = 10;
} else
offset = 15;
if ((pDM_Odm->RSSI_Min + offset) > dm_dig_max)
pDM_DigTable->rx_gain_range_max = dm_dig_max;
else if ((pDM_Odm->RSSI_Min + offset) < dm_dig_min)
pDM_DigTable->rx_gain_range_max = dm_dig_min;
else
pDM_DigTable->rx_gain_range_max = pDM_Odm->RSSI_Min + offset;
/* 2 Modify DIG lower bound */
/* if (pDM_Odm->bOneEntryOnly) */
{
if (pDM_Odm->RSSI_Min < dm_dig_min)
DIG_Dynamic_MIN = dm_dig_min;
else if (pDM_Odm->RSSI_Min > DIG_MaxOfMin)
DIG_Dynamic_MIN = DIG_MaxOfMin;
else
DIG_Dynamic_MIN = pDM_Odm->RSSI_Min;
}
} else {
pDM_DigTable->rx_gain_range_max = dm_dig_max;
DIG_Dynamic_MIN = dm_dig_min;
}
/* 1 Force Lower Bound for AntDiv */
if (pDM_Odm->bLinked && !pDM_Odm->bOneEntryOnly) {
if (pDM_Odm->SupportAbility & ODM_BB_ANT_DIV) {
if (
pDM_Odm->AntDivType == CG_TRX_HW_ANTDIV ||
pDM_Odm->AntDivType == CG_TRX_SMART_ANTDIV ||
pDM_Odm->AntDivType == S0S1_SW_ANTDIV
) {
if (pDM_DigTable->AntDiv_RSSI_max > DIG_MaxOfMin)
DIG_Dynamic_MIN = DIG_MaxOfMin;
else
DIG_Dynamic_MIN = (u8) pDM_DigTable->AntDiv_RSSI_max;
}
}
}
/* 1 Modify DIG lower bound, deal with abnormal case */
/* 2 Abnormal false alarm case */
if (FirstDisConnect) {
pDM_DigTable->rx_gain_range_min = DIG_Dynamic_MIN;
pDM_DigTable->ForbiddenIGI = DIG_Dynamic_MIN;
} else
pDM_DigTable->rx_gain_range_min =
odm_ForbiddenIGICheck(pDM_Odm, DIG_Dynamic_MIN, CurrentIGI);
if (pDM_Odm->bLinked && !FirstConnect) {
if (
(pDM_Odm->PhyDbgInfo.NumQryBeaconPkt < 5) &&
pDM_Odm->bsta_state
) {
pDM_DigTable->rx_gain_range_min = dm_dig_min;
}
}
/* 2 Abnormal lower bound case */
if (pDM_DigTable->rx_gain_range_min > pDM_DigTable->rx_gain_range_max) {
pDM_DigTable->rx_gain_range_min = pDM_DigTable->rx_gain_range_max;
}
/* 1 False alarm threshold decision */
odm_FAThresholdCheck(pDM_Odm, bDFSBand, bPerformance, RxTp, TxTp, dm_FA_thres);
/* 1 Adjust initial gain by false alarm */
if (pDM_Odm->bLinked && bPerformance) {
if (bFirstTpTarget || FirstConnect) {
pDM_DigTable->LargeFAHit = 0;
if (pDM_Odm->RSSI_Min < DIG_MaxOfMin) {
if (CurrentIGI < pDM_Odm->RSSI_Min)
CurrentIGI = pDM_Odm->RSSI_Min;
} else {
if (CurrentIGI < DIG_MaxOfMin)
CurrentIGI = DIG_MaxOfMin;
}
} else {
if (pFalseAlmCnt->Cnt_all > dm_FA_thres[2])
CurrentIGI = CurrentIGI + 4;
else if (pFalseAlmCnt->Cnt_all > dm_FA_thres[1])
CurrentIGI = CurrentIGI + 2;
else if (pFalseAlmCnt->Cnt_all < dm_FA_thres[0])
CurrentIGI = CurrentIGI - 2;
if (
(pDM_Odm->PhyDbgInfo.NumQryBeaconPkt < 5) &&
(pFalseAlmCnt->Cnt_all < DM_DIG_FA_TH1) &&
(pDM_Odm->bsta_state)
) {
CurrentIGI = pDM_DigTable->rx_gain_range_min;
}
}
} else {
if (FirstDisConnect || bFirstCoverage) {
CurrentIGI = dm_dig_min;
} else {
if (pFalseAlmCnt->Cnt_all > dm_FA_thres[2])
CurrentIGI = CurrentIGI + 4;
else if (pFalseAlmCnt->Cnt_all > dm_FA_thres[1])
CurrentIGI = CurrentIGI + 2;
else if (pFalseAlmCnt->Cnt_all < dm_FA_thres[0])
CurrentIGI = CurrentIGI - 2;
}
}
/* 1 Check initial gain by upper/lower bound */
if (CurrentIGI < pDM_DigTable->rx_gain_range_min)
CurrentIGI = pDM_DigTable->rx_gain_range_min;
if (CurrentIGI > pDM_DigTable->rx_gain_range_max)
CurrentIGI = pDM_DigTable->rx_gain_range_max;
/* 1 Force upper bound and lower bound for adaptivity */
if (
pDM_Odm->SupportAbility & ODM_BB_ADAPTIVITY &&
pDM_Odm->adaptivity_flag == true
) {
if (CurrentIGI > Adap_IGI_Upper)
CurrentIGI = Adap_IGI_Upper;
if (pDM_Odm->IGI_LowerBound != 0) {
if (CurrentIGI < pDM_Odm->IGI_LowerBound)
CurrentIGI = pDM_Odm->IGI_LowerBound;
}
}
/* 1 Update status */
if (pDM_Odm->bBtHsOperation) {
if (pDM_Odm->bLinked) {
if (pDM_DigTable->BT30_CurIGI > (CurrentIGI))
ODM_Write_DIG(pDM_Odm, CurrentIGI);
else
ODM_Write_DIG(pDM_Odm, pDM_DigTable->BT30_CurIGI);
pDM_DigTable->bMediaConnect_0 = pDM_Odm->bLinked;
pDM_DigTable->DIG_Dynamic_MIN_0 = DIG_Dynamic_MIN;
} else {
if (pDM_Odm->bLinkInProcess)
ODM_Write_DIG(pDM_Odm, 0x1c);
else if (pDM_Odm->bBtConnectProcess)
ODM_Write_DIG(pDM_Odm, 0x28);
else
ODM_Write_DIG(pDM_Odm, pDM_DigTable->BT30_CurIGI);/* ODM_Write_DIG(pDM_Odm, pDM_DigTable->CurIGValue); */
}
} else { /* BT is not using */
ODM_Write_DIG(pDM_Odm, CurrentIGI);/* ODM_Write_DIG(pDM_Odm, pDM_DigTable->CurIGValue); */
pDM_DigTable->bMediaConnect_0 = pDM_Odm->bLinked;
pDM_DigTable->DIG_Dynamic_MIN_0 = DIG_Dynamic_MIN;
}
}
void odm_DIGbyRSSI_LPS(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct false_ALARM_STATISTICS *pFalseAlmCnt = &pDM_Odm->FalseAlmCnt;
u8 RSSI_Lower = DM_DIG_MIN_NIC; /* 0x1E or 0x1C */
u8 CurrentIGI = pDM_Odm->RSSI_Min;
CurrentIGI = CurrentIGI+RSSI_OFFSET_DIG;
/* Using FW PS mode to make IGI */
/* Adjust by FA in LPS MODE */
if (pFalseAlmCnt->Cnt_all > DM_DIG_FA_TH2_LPS)
CurrentIGI = CurrentIGI+4;
else if (pFalseAlmCnt->Cnt_all > DM_DIG_FA_TH1_LPS)
CurrentIGI = CurrentIGI+2;
else if (pFalseAlmCnt->Cnt_all < DM_DIG_FA_TH0_LPS)
CurrentIGI = CurrentIGI-2;
/* Lower bound checking */
/* RSSI Lower bound check */
RSSI_Lower = max(pDM_Odm->RSSI_Min - 10, DM_DIG_MIN_NIC);
/* Upper and Lower Bound checking */
if (CurrentIGI > DM_DIG_MAX_NIC)
CurrentIGI = DM_DIG_MAX_NIC;
else if (CurrentIGI < RSSI_Lower)
CurrentIGI = RSSI_Lower;
ODM_Write_DIG(pDM_Odm, CurrentIGI);
/* ODM_Write_DIG(pDM_Odm, pDM_DigTable->CurIGValue); */
}
/* 3 ============================================================ */
/* 3 FASLE ALARM CHECK */
/* 3 ============================================================ */
void odm_FalseAlarmCounterStatistics(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct false_ALARM_STATISTICS *FalseAlmCnt = &pDM_Odm->FalseAlmCnt;
u32 ret_value;
if (!(pDM_Odm->SupportAbility & ODM_BB_FA_CNT))
return;
/* hold ofdm counter */
/* hold page C counter */
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG_OFDM_FA_HOLDC_11N, BIT31, 1);
/* hold page D counter */
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG_OFDM_FA_RSTD_11N, BIT31, 1);
ret_value = PHY_QueryBBReg(
pDM_Odm->Adapter, ODM_REG_OFDM_FA_TYPE1_11N, bMaskDWord
);
FalseAlmCnt->Cnt_Fast_Fsync = (ret_value&0xffff);
FalseAlmCnt->Cnt_SB_Search_fail = ((ret_value&0xffff0000)>>16);
ret_value = PHY_QueryBBReg(
pDM_Odm->Adapter, ODM_REG_OFDM_FA_TYPE2_11N, bMaskDWord
);
FalseAlmCnt->Cnt_OFDM_CCA = (ret_value&0xffff);
FalseAlmCnt->Cnt_Parity_Fail = ((ret_value&0xffff0000)>>16);
ret_value = PHY_QueryBBReg(
pDM_Odm->Adapter, ODM_REG_OFDM_FA_TYPE3_11N, bMaskDWord
);
FalseAlmCnt->Cnt_Rate_Illegal = (ret_value&0xffff);
FalseAlmCnt->Cnt_Crc8_fail = ((ret_value&0xffff0000)>>16);
ret_value = PHY_QueryBBReg(
pDM_Odm->Adapter, ODM_REG_OFDM_FA_TYPE4_11N, bMaskDWord
);
FalseAlmCnt->Cnt_Mcs_fail = (ret_value&0xffff);
FalseAlmCnt->Cnt_Ofdm_fail =
FalseAlmCnt->Cnt_Parity_Fail +
FalseAlmCnt->Cnt_Rate_Illegal +
FalseAlmCnt->Cnt_Crc8_fail +
FalseAlmCnt->Cnt_Mcs_fail +
FalseAlmCnt->Cnt_Fast_Fsync +
FalseAlmCnt->Cnt_SB_Search_fail;
{
/* hold cck counter */
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG_CCK_FA_RST_11N, BIT12, 1);
PHY_SetBBReg(pDM_Odm->Adapter, ODM_REG_CCK_FA_RST_11N, BIT14, 1);
ret_value = PHY_QueryBBReg(
pDM_Odm->Adapter, ODM_REG_CCK_FA_LSB_11N, bMaskByte0
);
FalseAlmCnt->Cnt_Cck_fail = ret_value;
ret_value = PHY_QueryBBReg(
pDM_Odm->Adapter, ODM_REG_CCK_FA_MSB_11N, bMaskByte3
);
FalseAlmCnt->Cnt_Cck_fail += (ret_value&0xff)<<8;
ret_value = PHY_QueryBBReg(
pDM_Odm->Adapter, ODM_REG_CCK_CCA_CNT_11N, bMaskDWord
);
FalseAlmCnt->Cnt_CCK_CCA =
((ret_value&0xFF)<<8) | ((ret_value&0xFF00)>>8);
}
FalseAlmCnt->Cnt_all = (
FalseAlmCnt->Cnt_Fast_Fsync +
FalseAlmCnt->Cnt_SB_Search_fail +
FalseAlmCnt->Cnt_Parity_Fail +
FalseAlmCnt->Cnt_Rate_Illegal +
FalseAlmCnt->Cnt_Crc8_fail +
FalseAlmCnt->Cnt_Mcs_fail +
FalseAlmCnt->Cnt_Cck_fail
);
FalseAlmCnt->Cnt_CCA_all =
FalseAlmCnt->Cnt_OFDM_CCA + FalseAlmCnt->Cnt_CCK_CCA;
}
void odm_FAThresholdCheck(
void *pDM_VOID,
bool bDFSBand,
bool bPerformance,
u32 RxTp,
u32 TxTp,
u32 *dm_FA_thres
)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
if (pDM_Odm->bLinked && (bPerformance || bDFSBand)) {
/* For NIC */
dm_FA_thres[0] = DM_DIG_FA_TH0;
dm_FA_thres[1] = DM_DIG_FA_TH1;
dm_FA_thres[2] = DM_DIG_FA_TH2;
} else {
dm_FA_thres[0] = 2000;
dm_FA_thres[1] = 4000;
dm_FA_thres[2] = 5000;
}
}
u8 odm_ForbiddenIGICheck(void *pDM_VOID, u8 DIG_Dynamic_MIN, u8 CurrentIGI)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct dig_t *pDM_DigTable = &pDM_Odm->DM_DigTable;
struct false_ALARM_STATISTICS *pFalseAlmCnt = &pDM_Odm->FalseAlmCnt;
u8 rx_gain_range_min = pDM_DigTable->rx_gain_range_min;
if (pFalseAlmCnt->Cnt_all > 10000) {
if (pDM_DigTable->LargeFAHit != 3)
pDM_DigTable->LargeFAHit++;
/* if (pDM_DigTable->ForbiddenIGI < pDM_DigTable->CurIGValue) */
if (pDM_DigTable->ForbiddenIGI < CurrentIGI) {
pDM_DigTable->ForbiddenIGI = CurrentIGI;
/* pDM_DigTable->ForbiddenIGI = pDM_DigTable->CurIGValue; */
pDM_DigTable->LargeFAHit = 1;
}
if (pDM_DigTable->LargeFAHit >= 3) {
if ((pDM_DigTable->ForbiddenIGI + 2) > pDM_DigTable->rx_gain_range_max)
rx_gain_range_min = pDM_DigTable->rx_gain_range_max;
else
rx_gain_range_min = (pDM_DigTable->ForbiddenIGI + 2);
pDM_DigTable->Recover_cnt = 1800;
}
} else {
if (pDM_DigTable->Recover_cnt != 0) {
pDM_DigTable->Recover_cnt--;
} else {
if (pDM_DigTable->LargeFAHit < 3) {
if ((pDM_DigTable->ForbiddenIGI - 2) < DIG_Dynamic_MIN) { /* DM_DIG_MIN) */
pDM_DigTable->ForbiddenIGI = DIG_Dynamic_MIN; /* DM_DIG_MIN; */
rx_gain_range_min = DIG_Dynamic_MIN; /* DM_DIG_MIN; */
} else {
pDM_DigTable->ForbiddenIGI -= 2;
rx_gain_range_min = (pDM_DigTable->ForbiddenIGI + 2);
}
} else
pDM_DigTable->LargeFAHit = 0;
}
}
return rx_gain_range_min;
}
/* 3 ============================================================ */
/* 3 CCK Packet Detect Threshold */
/* 3 ============================================================ */
void odm_CCKPacketDetectionThresh(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct false_ALARM_STATISTICS *FalseAlmCnt = &pDM_Odm->FalseAlmCnt;
u8 CurCCK_CCAThres;
if (
!(pDM_Odm->SupportAbility & ODM_BB_CCK_PD) ||
!(pDM_Odm->SupportAbility & ODM_BB_FA_CNT)
) {
return;
}
if (pDM_Odm->ExtLNA)
return;
if (pDM_Odm->bLinked) {
if (pDM_Odm->RSSI_Min > 25)
CurCCK_CCAThres = 0xcd;
else if ((pDM_Odm->RSSI_Min <= 25) && (pDM_Odm->RSSI_Min > 10))
CurCCK_CCAThres = 0x83;
else {
if (FalseAlmCnt->Cnt_Cck_fail > 1000)
CurCCK_CCAThres = 0x83;
else
CurCCK_CCAThres = 0x40;
}
} else {
if (FalseAlmCnt->Cnt_Cck_fail > 1000)
CurCCK_CCAThres = 0x83;
else
CurCCK_CCAThres = 0x40;
}
ODM_Write_CCK_CCA_Thres(pDM_Odm, CurCCK_CCAThres);
}
void ODM_Write_CCK_CCA_Thres(void *pDM_VOID, u8 CurCCK_CCAThres)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct dig_t *pDM_DigTable = &pDM_Odm->DM_DigTable;
/* modify by Guo.Mingzhi 2012-01-03 */
if (pDM_DigTable->CurCCK_CCAThres != CurCCK_CCAThres)
rtw_write8(pDM_Odm->Adapter, ODM_REG(CCK_CCA, pDM_Odm), CurCCK_CCAThres);
pDM_DigTable->PreCCK_CCAThres = pDM_DigTable->CurCCK_CCAThres;
pDM_DigTable->CurCCK_CCAThres = CurCCK_CCAThres;
}
| linux-master | drivers/staging/rtl8723bs/hal/odm_DIG.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include "odm_precomp.h"
static u32 edca_setting_DL_GMode[HT_IOT_PEER_MAX] = {
/*UNKNOWN, REALTEK_90, ALTEK_92SE BROADCOM, LINK ATHEROS,
*CISCO, MERU, MARVELL, 92U_AP, SELF_AP
*/
0x4322, 0xa44f, 0x5e4322, 0xa42b, 0x5e4322, 0x4322,
0xa42b, 0x5ea42b, 0xa44f, 0x5e4322, 0x5ea42b
};
static u32 edca_setting_UL[HT_IOT_PEER_MAX] = {
/*UNKNOWN, REALTEK_90, REALTEK_92SE, BROADCOM, RALINK, ATHEROS,
*CISCO, MERU, MARVELL, 92U_AP, SELF_AP(DownLink/Tx)
*/
0x5e4322, 0xa44f, 0x5e4322, 0x5ea32b, 0x5ea422, 0x5ea322,
0x3ea430, 0x5ea42b, 0x5ea44f, 0x5e4322, 0x5e4322};
static u32 edca_setting_DL[HT_IOT_PEER_MAX] = {
/*UNKNOWN, REALTEK_90, REALTEK_92SE, BROADCOM, RALINK, ATHEROS,
*CISCO, MERU, MARVELL, 92U_AP, SELF_AP(UpLink/Rx)
*/
0xa44f, 0x5ea44f, 0x5e4322, 0x5ea42b, 0xa44f, 0xa630,
0x5ea630, 0x5ea42b, 0xa44f, 0xa42b, 0xa42b};
void ODM_EdcaTurboInit(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct adapter *Adapter = pDM_Odm->Adapter;
pDM_Odm->DM_EDCA_Table.bCurrentTurboEDCA = false;
pDM_Odm->DM_EDCA_Table.bIsCurRDLState = false;
Adapter->recvpriv.bIsAnyNonBEPkts = false;
} /* ODM_InitEdcaTurbo */
void odm_EdcaTurboCheck(void *pDM_VOID)
{
/* In HW integration first stage, we provide 4 different handles to
* operate at the same time. In stage2/3, we need to prove universal
* interface and merge all HW dynamic mechanism.
*/
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
if (!(pDM_Odm->SupportAbility & ODM_MAC_EDCA_TURBO))
return;
odm_EdcaTurboCheckCE(pDM_Odm);
} /* odm_CheckEdcaTurbo */
void odm_EdcaTurboCheckCE(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct adapter *Adapter = pDM_Odm->Adapter;
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(Adapter);
struct recv_priv *precvpriv = &(Adapter->recvpriv);
struct registry_priv *pregpriv = &Adapter->registrypriv;
struct mlme_ext_priv *pmlmeext = &(Adapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u32 EDCA_BE_UL = 0x5ea42b;
u32 EDCA_BE_DL = 0x5ea42b;
u32 iot_peer = 0;
u8 wirelessmode = 0xFF; /* invalid value */
u32 trafficIndex;
u32 edca_param;
u64 cur_tx_bytes = 0;
u64 cur_rx_bytes = 0;
u8 bbtchange = false;
u8 biasonrx = false;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
if (!pDM_Odm->bLinked) {
precvpriv->bIsAnyNonBEPkts = false;
return;
}
if (pregpriv->wifi_spec == 1) {
precvpriv->bIsAnyNonBEPkts = false;
return;
}
if (pDM_Odm->pwirelessmode)
wirelessmode = *(pDM_Odm->pwirelessmode);
iot_peer = pmlmeinfo->assoc_AP_vendor;
if (iot_peer >= HT_IOT_PEER_MAX) {
precvpriv->bIsAnyNonBEPkts = false;
return;
}
/* Check if the status needs to be changed. */
if ((bbtchange) || (!precvpriv->bIsAnyNonBEPkts)) {
cur_tx_bytes = pdvobjpriv->traffic_stat.cur_tx_bytes;
cur_rx_bytes = pdvobjpriv->traffic_stat.cur_rx_bytes;
/* traffic, TX or RX */
if (biasonrx) {
if (cur_tx_bytes > (cur_rx_bytes << 2)) {
/* Uplink TP is present. */
trafficIndex = UP_LINK;
} else { /* Balance TP is present. */
trafficIndex = DOWN_LINK;
}
} else {
if (cur_rx_bytes > (cur_tx_bytes << 2)) {
/* Downlink TP is present. */
trafficIndex = DOWN_LINK;
} else { /* Balance TP is present. */
trafficIndex = UP_LINK;
}
}
/* 92D txop can't be set to 0x3e for cisco1250 */
if ((iot_peer == HT_IOT_PEER_CISCO) &&
(wirelessmode == ODM_WM_N24G)) {
EDCA_BE_DL = edca_setting_DL[iot_peer];
EDCA_BE_UL = edca_setting_UL[iot_peer];
} else if ((iot_peer == HT_IOT_PEER_CISCO) &&
((wirelessmode == ODM_WM_G) ||
(wirelessmode == (ODM_WM_B | ODM_WM_G)) ||
(wirelessmode == ODM_WM_B))) {
EDCA_BE_DL = edca_setting_DL_GMode[iot_peer];
} else if ((iot_peer == HT_IOT_PEER_AIRGO) &&
(wirelessmode == ODM_WM_G)) {
EDCA_BE_DL = 0xa630;
} else if (iot_peer == HT_IOT_PEER_MARVELL) {
EDCA_BE_DL = edca_setting_DL[iot_peer];
EDCA_BE_UL = edca_setting_UL[iot_peer];
} else if (iot_peer == HT_IOT_PEER_ATHEROS) {
/* Set DL EDCA for Atheros peer to 0x3ea42b. */
EDCA_BE_DL = edca_setting_DL[iot_peer];
}
if (trafficIndex == DOWN_LINK)
edca_param = EDCA_BE_DL;
else
edca_param = EDCA_BE_UL;
rtw_write32(Adapter, REG_EDCA_BE_PARAM, edca_param);
pDM_Odm->DM_EDCA_Table.prv_traffic_idx = trafficIndex;
pDM_Odm->DM_EDCA_Table.bCurrentTurboEDCA = true;
} else {
/* Turn Off EDCA turbo here. */
/* Restore original EDCA according to the declaration of AP. */
if (pDM_Odm->DM_EDCA_Table.bCurrentTurboEDCA) {
rtw_write32(Adapter, REG_EDCA_BE_PARAM, pHalData->AcParam_BE);
pDM_Odm->DM_EDCA_Table.bCurrentTurboEDCA = false;
}
}
}
| linux-master | drivers/staging/rtl8723bs/hal/odm_EdcaTurboCheck.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2013 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <hal_data.h>
#include <rtw_debug.h>
#include <hal_btcoex.h>
#include <Mp_Precomp.h>
/* Global variables */
struct btc_coexist GLBtCoexist;
static u8 GLBtcWiFiInScanState;
static u8 GLBtcWiFiInIQKState;
/* */
/* Debug related function */
/* */
static u8 halbtcoutsrc_IsBtCoexistAvailable(struct btc_coexist *pBtCoexist)
{
if (!pBtCoexist->bBinded || !pBtCoexist->Adapter)
return false;
return true;
}
static void halbtcoutsrc_LeaveLps(struct btc_coexist *pBtCoexist)
{
struct adapter *padapter;
padapter = pBtCoexist->Adapter;
pBtCoexist->btInfo.bBtCtrlLps = true;
pBtCoexist->btInfo.bBtLpsOn = false;
rtw_btcoex_LPS_Leave(padapter);
}
static void halbtcoutsrc_EnterLps(struct btc_coexist *pBtCoexist)
{
struct adapter *padapter;
padapter = pBtCoexist->Adapter;
pBtCoexist->btInfo.bBtCtrlLps = true;
pBtCoexist->btInfo.bBtLpsOn = true;
rtw_btcoex_LPS_Enter(padapter);
}
static void halbtcoutsrc_NormalLps(struct btc_coexist *pBtCoexist)
{
struct adapter *padapter;
padapter = pBtCoexist->Adapter;
if (pBtCoexist->btInfo.bBtCtrlLps) {
pBtCoexist->btInfo.bBtLpsOn = false;
rtw_btcoex_LPS_Leave(padapter);
pBtCoexist->btInfo.bBtCtrlLps = false;
/* recover the LPS state to the original */
}
}
/*
* Constraint:
* 1. this function will request pwrctrl->lock
*/
static void halbtcoutsrc_LeaveLowPower(struct btc_coexist *pBtCoexist)
{
struct adapter *padapter;
s32 ready;
unsigned long stime;
unsigned long utime;
u32 timeout; /* unit: ms */
padapter = pBtCoexist->Adapter;
ready = _FAIL;
#ifdef LPS_RPWM_WAIT_MS
timeout = LPS_RPWM_WAIT_MS;
#else /* !LPS_RPWM_WAIT_MS */
timeout = 30;
#endif /* !LPS_RPWM_WAIT_MS */
stime = jiffies;
do {
ready = rtw_register_task_alive(padapter, BTCOEX_ALIVE);
if (_SUCCESS == ready)
break;
utime = jiffies_to_msecs(jiffies - stime);
if (utime > timeout)
break;
msleep(1);
} while (1);
}
/*
* Constraint:
* 1. this function will request pwrctrl->lock
*/
static void halbtcoutsrc_NormalLowPower(struct btc_coexist *pBtCoexist)
{
struct adapter *padapter;
padapter = pBtCoexist->Adapter;
rtw_unregister_task_alive(padapter, BTCOEX_ALIVE);
}
static void halbtcoutsrc_DisableLowPower(struct btc_coexist *pBtCoexist, u8 bLowPwrDisable)
{
pBtCoexist->btInfo.bBtDisableLowPwr = bLowPwrDisable;
if (bLowPwrDisable)
halbtcoutsrc_LeaveLowPower(pBtCoexist); /* leave 32k low power. */
else
halbtcoutsrc_NormalLowPower(pBtCoexist); /* original 32k low power behavior. */
}
static void halbtcoutsrc_AggregationCheck(struct btc_coexist *pBtCoexist)
{
struct adapter *padapter;
bool bNeedToAct;
padapter = pBtCoexist->Adapter;
bNeedToAct = false;
if (pBtCoexist->btInfo.bRejectAggPkt) {
rtw_btcoex_RejectApAggregatedPacket(padapter, true);
} else {
if (pBtCoexist->btInfo.bPreBtCtrlAggBufSize !=
pBtCoexist->btInfo.bBtCtrlAggBufSize) {
bNeedToAct = true;
pBtCoexist->btInfo.bPreBtCtrlAggBufSize = pBtCoexist->btInfo.bBtCtrlAggBufSize;
}
if (pBtCoexist->btInfo.bBtCtrlAggBufSize) {
if (pBtCoexist->btInfo.preAggBufSize !=
pBtCoexist->btInfo.aggBufSize){
bNeedToAct = true;
}
pBtCoexist->btInfo.preAggBufSize = pBtCoexist->btInfo.aggBufSize;
}
if (bNeedToAct) {
rtw_btcoex_RejectApAggregatedPacket(padapter, true);
rtw_btcoex_RejectApAggregatedPacket(padapter, false);
}
}
}
static u8 halbtcoutsrc_IsWifiBusy(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv;
pmlmepriv = &padapter->mlmepriv;
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == true) {
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
return true;
if (pmlmepriv->LinkDetectInfo.bBusyTraffic)
return true;
}
return false;
}
static u32 _halbtcoutsrc_GetWifiLinkStatus(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv;
u8 bp2p;
u32 portConnectedStatus;
pmlmepriv = &padapter->mlmepriv;
bp2p = false;
portConnectedStatus = 0;
if (check_fwstate(pmlmepriv, WIFI_ASOC_STATE) == true) {
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
if (bp2p)
portConnectedStatus |= WIFI_P2P_GO_CONNECTED;
else
portConnectedStatus |= WIFI_AP_CONNECTED;
} else {
if (bp2p)
portConnectedStatus |= WIFI_P2P_GC_CONNECTED;
else
portConnectedStatus |= WIFI_STA_CONNECTED;
}
}
return portConnectedStatus;
}
static u32 halbtcoutsrc_GetWifiLinkStatus(struct btc_coexist *pBtCoexist)
{
/* */
/* return value: */
/* [31:16]=> connected port number */
/* [15:0]=> port connected bit define */
/* */
struct adapter *padapter;
u32 retVal;
u32 portConnectedStatus, numOfConnectedPort;
padapter = pBtCoexist->Adapter;
portConnectedStatus = 0;
numOfConnectedPort = 0;
retVal = _halbtcoutsrc_GetWifiLinkStatus(padapter);
if (retVal) {
portConnectedStatus |= retVal;
numOfConnectedPort++;
}
retVal = (numOfConnectedPort << 16) | portConnectedStatus;
return retVal;
}
static u32 halbtcoutsrc_GetBtPatchVer(struct btc_coexist *pBtCoexist)
{
return pBtCoexist->btInfo.btRealFwVer;
}
static s32 halbtcoutsrc_GetWifiRssi(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
return pHalData->dmpriv.EntryMinUndecoratedSmoothedPWDB;
}
static u8 halbtcoutsrc_GetWifiScanAPNum(struct adapter *padapter)
{
struct mlme_ext_priv *pmlmeext;
static u8 scan_AP_num;
pmlmeext = &padapter->mlmeextpriv;
if (!GLBtcWiFiInScanState) {
if (pmlmeext->sitesurvey_res.bss_cnt > 0xFF)
scan_AP_num = 0xFF;
else
scan_AP_num = (u8)pmlmeext->sitesurvey_res.bss_cnt;
}
return scan_AP_num;
}
static u8 halbtcoutsrc_Get(void *pBtcContext, u8 getType, void *pOutBuf)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
struct hal_com_data *pHalData;
struct mlme_ext_priv *mlmeext;
u8 *pu8;
s32 *pS4Tmp;
u32 *pU4Tmp;
u8 ret;
pBtCoexist = (struct btc_coexist *)pBtcContext;
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return false;
padapter = pBtCoexist->Adapter;
pHalData = GET_HAL_DATA(padapter);
mlmeext = &padapter->mlmeextpriv;
pu8 = pOutBuf;
pS4Tmp = pOutBuf;
pU4Tmp = pOutBuf;
ret = true;
switch (getType) {
case BTC_GET_BL_HS_OPERATION:
*pu8 = false;
ret = false;
break;
case BTC_GET_BL_HS_CONNECTING:
*pu8 = false;
ret = false;
break;
case BTC_GET_BL_WIFI_CONNECTED:
*pu8 = check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE);
break;
case BTC_GET_BL_WIFI_BUSY:
*pu8 = halbtcoutsrc_IsWifiBusy(padapter);
break;
case BTC_GET_BL_WIFI_SCAN:
/* Use the value of the new variable GLBtcWiFiInScanState to judge whether WiFi is in scan state or not, since the originally used flag
WIFI_SITE_MONITOR in fwstate may not be cleared in time */
*pu8 = GLBtcWiFiInScanState;
break;
case BTC_GET_BL_WIFI_LINK:
*pu8 = check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING);
break;
case BTC_GET_BL_WIFI_ROAM:
*pu8 = check_fwstate(&padapter->mlmepriv, WIFI_UNDER_LINKING);
break;
case BTC_GET_BL_WIFI_4_WAY_PROGRESS:
*pu8 = false;
break;
case BTC_GET_BL_WIFI_AP_MODE_ENABLE:
*pu8 = check_fwstate(&padapter->mlmepriv, WIFI_AP_STATE);
break;
case BTC_GET_BL_WIFI_ENABLE_ENCRYPTION:
*pu8 = padapter->securitypriv.dot11PrivacyAlgrthm != 0;
break;
case BTC_GET_BL_WIFI_UNDER_B_MODE:
if (mlmeext->cur_wireless_mode == WIRELESS_11B)
*pu8 = true;
else
*pu8 = false;
break;
case BTC_GET_BL_WIFI_IS_IN_MP_MODE:
*pu8 = false;
break;
case BTC_GET_BL_EXT_SWITCH:
*pu8 = false;
break;
case BTC_GET_S4_WIFI_RSSI:
*pS4Tmp = halbtcoutsrc_GetWifiRssi(padapter);
break;
case BTC_GET_S4_HS_RSSI:
*pS4Tmp = 0;
ret = false;
break;
case BTC_GET_U4_WIFI_BW:
if (is_legacy_only(mlmeext->cur_wireless_mode))
*pU4Tmp = BTC_WIFI_BW_LEGACY;
else if (pHalData->CurrentChannelBW == CHANNEL_WIDTH_20)
*pU4Tmp = BTC_WIFI_BW_HT20;
else
*pU4Tmp = BTC_WIFI_BW_HT40;
break;
case BTC_GET_U4_WIFI_TRAFFIC_DIRECTION:
{
struct rt_link_detect_t *plinkinfo;
plinkinfo = &padapter->mlmepriv.LinkDetectInfo;
if (plinkinfo->NumTxOkInPeriod > plinkinfo->NumRxOkInPeriod)
*pU4Tmp = BTC_WIFI_TRAFFIC_TX;
else
*pU4Tmp = BTC_WIFI_TRAFFIC_RX;
}
break;
case BTC_GET_U4_WIFI_FW_VER:
*pU4Tmp = pHalData->FirmwareVersion << 16;
*pU4Tmp |= pHalData->FirmwareSubVersion;
break;
case BTC_GET_U4_WIFI_LINK_STATUS:
*pU4Tmp = halbtcoutsrc_GetWifiLinkStatus(pBtCoexist);
break;
case BTC_GET_U4_BT_PATCH_VER:
*pU4Tmp = halbtcoutsrc_GetBtPatchVer(pBtCoexist);
break;
case BTC_GET_U1_WIFI_DOT11_CHNL:
*pu8 = padapter->mlmeextpriv.cur_channel;
break;
case BTC_GET_U1_WIFI_CENTRAL_CHNL:
*pu8 = pHalData->CurrentChannel;
break;
case BTC_GET_U1_WIFI_HS_CHNL:
*pu8 = 0;
ret = false;
break;
case BTC_GET_U1_MAC_PHY_MODE:
*pu8 = BTC_SMSP;
/* *pU1Tmp = BTC_DMSP; */
/* *pU1Tmp = BTC_DMDP; */
/* *pU1Tmp = BTC_MP_UNKNOWN; */
break;
case BTC_GET_U1_AP_NUM:
*pu8 = halbtcoutsrc_GetWifiScanAPNum(padapter);
break;
/* 1Ant =========== */
case BTC_GET_U1_LPS_MODE:
*pu8 = padapter->dvobj->pwrctl_priv.pwr_mode;
break;
default:
ret = false;
break;
}
return ret;
}
static u8 halbtcoutsrc_Set(void *pBtcContext, u8 setType, void *pInBuf)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
u8 *pu8;
u32 *pU4Tmp;
u8 ret;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
pu8 = pInBuf;
pU4Tmp = pInBuf;
ret = true;
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return false;
switch (setType) {
/* set some u8 type variables. */
case BTC_SET_BL_BT_DISABLE:
pBtCoexist->btInfo.bBtDisabled = *pu8;
break;
case BTC_SET_BL_BT_TRAFFIC_BUSY:
pBtCoexist->btInfo.bBtBusy = *pu8;
break;
case BTC_SET_BL_BT_LIMITED_DIG:
pBtCoexist->btInfo.bLimitedDig = *pu8;
break;
case BTC_SET_BL_FORCE_TO_ROAM:
pBtCoexist->btInfo.bForceToRoam = *pu8;
break;
case BTC_SET_BL_TO_REJ_AP_AGG_PKT:
pBtCoexist->btInfo.bRejectAggPkt = *pu8;
break;
case BTC_SET_BL_BT_CTRL_AGG_SIZE:
pBtCoexist->btInfo.bBtCtrlAggBufSize = *pu8;
break;
case BTC_SET_BL_INC_SCAN_DEV_NUM:
pBtCoexist->btInfo.bIncreaseScanDevNum = *pu8;
break;
case BTC_SET_BL_BT_TX_RX_MASK:
pBtCoexist->btInfo.bBtTxRxMask = *pu8;
break;
/* set some u8 type variables. */
case BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON:
pBtCoexist->btInfo.rssiAdjustForAgcTableOn = *pu8;
break;
case BTC_SET_U1_AGG_BUF_SIZE:
pBtCoexist->btInfo.aggBufSize = *pu8;
break;
/* the following are some action which will be triggered */
case BTC_SET_ACT_GET_BT_RSSI:
ret = false;
break;
case BTC_SET_ACT_AGGREGATE_CTRL:
halbtcoutsrc_AggregationCheck(pBtCoexist);
break;
/* 1Ant =========== */
/* set some u8 type variables. */
case BTC_SET_U1_RSSI_ADJ_VAL_FOR_1ANT_COEX_TYPE:
pBtCoexist->btInfo.rssiAdjustFor1AntCoexType = *pu8;
break;
case BTC_SET_U1_LPS_VAL:
pBtCoexist->btInfo.lpsVal = *pu8;
break;
case BTC_SET_U1_RPWM_VAL:
pBtCoexist->btInfo.rpwmVal = *pu8;
break;
/* the following are some action which will be triggered */
case BTC_SET_ACT_LEAVE_LPS:
halbtcoutsrc_LeaveLps(pBtCoexist);
break;
case BTC_SET_ACT_ENTER_LPS:
halbtcoutsrc_EnterLps(pBtCoexist);
break;
case BTC_SET_ACT_NORMAL_LPS:
halbtcoutsrc_NormalLps(pBtCoexist);
break;
case BTC_SET_ACT_DISABLE_LOW_POWER:
halbtcoutsrc_DisableLowPower(pBtCoexist, *pu8);
break;
case BTC_SET_ACT_UPDATE_RAMASK:
pBtCoexist->btInfo.raMask = *pU4Tmp;
if (check_fwstate(&padapter->mlmepriv, WIFI_ASOC_STATE) == true) {
struct sta_info *psta;
struct wlan_bssid_ex *cur_network;
cur_network = &padapter->mlmeextpriv.mlmext_info.network;
psta = rtw_get_stainfo(&padapter->stapriv, cur_network->mac_address);
rtw_hal_update_ra_mask(psta, 0);
}
break;
case BTC_SET_ACT_SEND_MIMO_PS:
ret = false;
break;
case BTC_SET_ACT_CTRL_BT_INFO:
ret = false;
break;
case BTC_SET_ACT_CTRL_BT_COEX:
ret = false;
break;
case BTC_SET_ACT_CTRL_8723B_ANT:
ret = false;
break;
/* */
default:
ret = false;
break;
}
return ret;
}
/* */
/* IO related function */
/* */
static u8 halbtcoutsrc_Read1Byte(void *pBtcContext, u32 RegAddr)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
return rtw_read8(padapter, RegAddr);
}
static u16 halbtcoutsrc_Read2Byte(void *pBtcContext, u32 RegAddr)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
return rtw_read16(padapter, RegAddr);
}
static u32 halbtcoutsrc_Read4Byte(void *pBtcContext, u32 RegAddr)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
return rtw_read32(padapter, RegAddr);
}
static void halbtcoutsrc_Write1Byte(void *pBtcContext, u32 RegAddr, u8 Data)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
rtw_write8(padapter, RegAddr, Data);
}
static void halbtcoutsrc_BitMaskWrite1Byte(void *pBtcContext, u32 regAddr, u8 bitMask, u8 data1b)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
u8 originalValue, bitShift;
u8 i;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
originalValue = 0;
bitShift = 0;
if (bitMask != 0xFF) {
originalValue = rtw_read8(padapter, regAddr);
for (i = 0; i <= 7; i++) {
if ((bitMask >> i) & 0x1)
break;
}
bitShift = i;
data1b = (originalValue & ~bitMask) | ((data1b << bitShift) & bitMask);
}
rtw_write8(padapter, regAddr, data1b);
}
static void halbtcoutsrc_Write2Byte(void *pBtcContext, u32 RegAddr, u16 Data)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
rtw_write16(padapter, RegAddr, Data);
}
static void halbtcoutsrc_Write4Byte(void *pBtcContext, u32 RegAddr, u32 Data)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
rtw_write32(padapter, RegAddr, Data);
}
static void halbtcoutsrc_WriteLocalReg1Byte(void *pBtcContext, u32 RegAddr, u8 Data)
{
struct btc_coexist *pBtCoexist = (struct btc_coexist *)pBtcContext;
struct adapter *Adapter = pBtCoexist->Adapter;
if (BTC_INTF_SDIO == pBtCoexist->chipInterface)
rtw_write8(Adapter, SDIO_LOCAL_BASE | RegAddr, Data);
else
rtw_write8(Adapter, RegAddr, Data);
}
static void halbtcoutsrc_SetBbReg(void *pBtcContext, u32 RegAddr, u32 BitMask, u32 Data)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
PHY_SetBBReg(padapter, RegAddr, BitMask, Data);
}
static u32 halbtcoutsrc_GetBbReg(void *pBtcContext, u32 RegAddr, u32 BitMask)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
return PHY_QueryBBReg(padapter, RegAddr, BitMask);
}
static void halbtcoutsrc_SetRfReg(void *pBtcContext, u8 eRFPath, u32 RegAddr, u32 BitMask, u32 Data)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
PHY_SetRFReg(padapter, eRFPath, RegAddr, BitMask, Data);
}
static u32 halbtcoutsrc_GetRfReg(void *pBtcContext, u8 eRFPath, u32 RegAddr, u32 BitMask)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
return PHY_QueryRFReg(padapter, eRFPath, RegAddr, BitMask);
}
static void halbtcoutsrc_SetBtReg(void *pBtcContext, u8 RegType, u32 RegAddr, u32 Data)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
u8 CmdBuffer1[4] = {0};
u8 CmdBuffer2[4] = {0};
u8 *AddrToSet = (u8 *)&RegAddr;
u8 *ValueToSet = (u8 *)&Data;
u8 OperVer = 0;
u8 ReqNum = 0;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
CmdBuffer1[0] |= (OperVer & 0x0f); /* Set OperVer */
CmdBuffer1[0] |= ((ReqNum << 4) & 0xf0); /* Set ReqNum */
CmdBuffer1[1] = 0x0d; /* Set OpCode to BT_LO_OP_WRITE_REG_VALUE */
CmdBuffer1[2] = ValueToSet[0]; /* Set WriteRegValue */
rtw_hal_fill_h2c_cmd(padapter, 0x67, 4, &(CmdBuffer1[0]));
msleep(200);
ReqNum++;
CmdBuffer2[0] |= (OperVer & 0x0f); /* Set OperVer */
CmdBuffer2[0] |= ((ReqNum << 4) & 0xf0); /* Set ReqNum */
CmdBuffer2[1] = 0x0c; /* Set OpCode of BT_LO_OP_WRITE_REG_ADDR */
CmdBuffer2[3] = AddrToSet[0]; /* Set WriteRegAddr */
rtw_hal_fill_h2c_cmd(padapter, 0x67, 4, &(CmdBuffer2[0]));
}
static u32 halbtcoutsrc_GetBtReg(void *pBtcContext, u8 RegType, u32 RegAddr)
{
/* To be implemented. Always return 0 temporarily */
return 0;
}
static void halbtcoutsrc_FillH2cCmd(void *pBtcContext, u8 elementId, u32 cmdLen, u8 *pCmdBuffer)
{
struct btc_coexist *pBtCoexist;
struct adapter *padapter;
pBtCoexist = (struct btc_coexist *)pBtcContext;
padapter = pBtCoexist->Adapter;
rtw_hal_fill_h2c_cmd(padapter, elementId, cmdLen, pCmdBuffer);
}
/* */
/* Extern functions called by other module */
/* */
static u8 EXhalbtcoutsrc_BindBtCoexWithAdapter(void *padapter)
{
struct btc_coexist *pBtCoexist = &GLBtCoexist;
if (pBtCoexist->bBinded)
return false;
else
pBtCoexist->bBinded = true;
pBtCoexist->statistics.cntBind++;
pBtCoexist->Adapter = padapter;
pBtCoexist->stackInfo.bProfileNotified = false;
pBtCoexist->btInfo.bBtCtrlAggBufSize = false;
pBtCoexist->btInfo.aggBufSize = 5;
pBtCoexist->btInfo.bIncreaseScanDevNum = false;
/* set default antenna position to main port */
pBtCoexist->boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
return true;
}
void hal_btcoex_Initialize(void *padapter)
{
struct btc_coexist *pBtCoexist;
memset(&GLBtCoexist, 0, sizeof(GLBtCoexist));
pBtCoexist = &GLBtCoexist;
/* pBtCoexist->statistics.cntBind++; */
pBtCoexist->chipInterface = BTC_INTF_SDIO;
EXhalbtcoutsrc_BindBtCoexWithAdapter(padapter);
pBtCoexist->fBtcRead1Byte = halbtcoutsrc_Read1Byte;
pBtCoexist->fBtcWrite1Byte = halbtcoutsrc_Write1Byte;
pBtCoexist->fBtcWrite1ByteBitMask = halbtcoutsrc_BitMaskWrite1Byte;
pBtCoexist->fBtcRead2Byte = halbtcoutsrc_Read2Byte;
pBtCoexist->fBtcWrite2Byte = halbtcoutsrc_Write2Byte;
pBtCoexist->fBtcRead4Byte = halbtcoutsrc_Read4Byte;
pBtCoexist->fBtcWrite4Byte = halbtcoutsrc_Write4Byte;
pBtCoexist->fBtcWriteLocalReg1Byte = halbtcoutsrc_WriteLocalReg1Byte;
pBtCoexist->fBtcSetBbReg = halbtcoutsrc_SetBbReg;
pBtCoexist->fBtcGetBbReg = halbtcoutsrc_GetBbReg;
pBtCoexist->fBtcSetRfReg = halbtcoutsrc_SetRfReg;
pBtCoexist->fBtcGetRfReg = halbtcoutsrc_GetRfReg;
pBtCoexist->fBtcFillH2c = halbtcoutsrc_FillH2cCmd;
pBtCoexist->fBtcGet = halbtcoutsrc_Get;
pBtCoexist->fBtcSet = halbtcoutsrc_Set;
pBtCoexist->fBtcGetBtReg = halbtcoutsrc_GetBtReg;
pBtCoexist->fBtcSetBtReg = halbtcoutsrc_SetBtReg;
pBtCoexist->boardInfo.singleAntPath = 0;
GLBtcWiFiInScanState = false;
GLBtcWiFiInIQKState = false;
}
void EXhalbtcoutsrc_PowerOnSetting(struct btc_coexist *pBtCoexist)
{
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
/* Power on setting function is only added in 8723B currently */
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_PowerOnSetting(pBtCoexist);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_PowerOnSetting(pBtCoexist);
}
void EXhalbtcoutsrc_InitHwConfig(struct btc_coexist *pBtCoexist, u8 bWifiOnly)
{
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
pBtCoexist->statistics.cntInitHwConfig++;
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_InitHwConfig(pBtCoexist, bWifiOnly);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_InitHwConfig(pBtCoexist, bWifiOnly);
}
void EXhalbtcoutsrc_InitCoexDm(struct btc_coexist *pBtCoexist)
{
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
pBtCoexist->statistics.cntInitCoexDm++;
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_InitCoexDm(pBtCoexist);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_InitCoexDm(pBtCoexist);
pBtCoexist->bInitilized = true;
}
void EXhalbtcoutsrc_IpsNotify(struct btc_coexist *pBtCoexist, u8 type)
{
u8 ipsType;
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
pBtCoexist->statistics.cntIpsNotify++;
if (pBtCoexist->bManualControl)
return;
if (IPS_NONE == type)
ipsType = BTC_IPS_LEAVE;
else
ipsType = BTC_IPS_ENTER;
/* All notify is called in cmd thread, don't need to leave low power again */
/* halbtcoutsrc_LeaveLowPower(pBtCoexist); */
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_IpsNotify(pBtCoexist, ipsType);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_IpsNotify(pBtCoexist, ipsType);
/* halbtcoutsrc_NormalLowPower(pBtCoexist); */
}
void EXhalbtcoutsrc_LpsNotify(struct btc_coexist *pBtCoexist, u8 type)
{
u8 lpsType;
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
pBtCoexist->statistics.cntLpsNotify++;
if (pBtCoexist->bManualControl)
return;
if (PS_MODE_ACTIVE == type)
lpsType = BTC_LPS_DISABLE;
else
lpsType = BTC_LPS_ENABLE;
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_LpsNotify(pBtCoexist, lpsType);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_LpsNotify(pBtCoexist, lpsType);
}
void EXhalbtcoutsrc_ScanNotify(struct btc_coexist *pBtCoexist, u8 type)
{
u8 scanType;
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
pBtCoexist->statistics.cntScanNotify++;
if (pBtCoexist->bManualControl)
return;
if (type) {
scanType = BTC_SCAN_START;
GLBtcWiFiInScanState = true;
} else {
scanType = BTC_SCAN_FINISH;
GLBtcWiFiInScanState = false;
}
/* All notify is called in cmd thread, don't need to leave low power again */
/* halbtcoutsrc_LeaveLowPower(pBtCoexist); */
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_ScanNotify(pBtCoexist, scanType);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_ScanNotify(pBtCoexist, scanType);
/* halbtcoutsrc_NormalLowPower(pBtCoexist); */
}
void EXhalbtcoutsrc_ConnectNotify(struct btc_coexist *pBtCoexist, u8 action)
{
u8 assoType;
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
pBtCoexist->statistics.cntConnectNotify++;
if (pBtCoexist->bManualControl)
return;
if (action)
assoType = BTC_ASSOCIATE_START;
else
assoType = BTC_ASSOCIATE_FINISH;
/* All notify is called in cmd thread, don't need to leave low power again */
/* halbtcoutsrc_LeaveLowPower(pBtCoexist); */
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_ConnectNotify(pBtCoexist, assoType);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_ConnectNotify(pBtCoexist, assoType);
/* halbtcoutsrc_NormalLowPower(pBtCoexist); */
}
void EXhalbtcoutsrc_MediaStatusNotify(struct btc_coexist *pBtCoexist, enum
rt_media_status mediaStatus)
{
u8 mStatus;
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
pBtCoexist->statistics.cntMediaStatusNotify++;
if (pBtCoexist->bManualControl)
return;
if (RT_MEDIA_CONNECT == mediaStatus)
mStatus = BTC_MEDIA_CONNECT;
else
mStatus = BTC_MEDIA_DISCONNECT;
/* All notify is called in cmd thread, don't need to leave low power again */
/* halbtcoutsrc_LeaveLowPower(pBtCoexist); */
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, mStatus);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_MediaStatusNotify(pBtCoexist, mStatus);
/* halbtcoutsrc_NormalLowPower(pBtCoexist); */
}
void EXhalbtcoutsrc_SpecialPacketNotify(struct btc_coexist *pBtCoexist, u8 pktType)
{
u8 packetType;
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
pBtCoexist->statistics.cntSpecialPacketNotify++;
if (pBtCoexist->bManualControl)
return;
if (PACKET_DHCP == pktType) {
packetType = BTC_PACKET_DHCP;
} else if (PACKET_EAPOL == pktType) {
packetType = BTC_PACKET_EAPOL;
} else if (PACKET_ARP == pktType) {
packetType = BTC_PACKET_ARP;
} else {
return;
}
/* All notify is called in cmd thread, don't need to leave low power again */
/* halbtcoutsrc_LeaveLowPower(pBtCoexist); */
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_SpecialPacketNotify(pBtCoexist, packetType);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_SpecialPacketNotify(pBtCoexist, packetType);
/* halbtcoutsrc_NormalLowPower(pBtCoexist); */
}
void EXhalbtcoutsrc_BtInfoNotify(struct btc_coexist *pBtCoexist, u8 *tmpBuf, u8 length)
{
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
pBtCoexist->statistics.cntBtInfoNotify++;
/* All notify is called in cmd thread, don't need to leave low power again */
/* halbtcoutsrc_LeaveLowPower(pBtCoexist); */
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_BtInfoNotify(pBtCoexist, tmpBuf, length);
/* halbtcoutsrc_NormalLowPower(pBtCoexist); */
}
void EXhalbtcoutsrc_HaltNotify(struct btc_coexist *pBtCoexist)
{
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_HaltNotify(pBtCoexist);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_HaltNotify(pBtCoexist);
pBtCoexist->bBinded = false;
}
void EXhalbtcoutsrc_PnpNotify(struct btc_coexist *pBtCoexist, u8 pnpState)
{
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
/* */
/* currently only 1ant we have to do the notification, */
/* once pnp is notified to sleep state, we have to leave LPS that we can sleep normally. */
/* */
if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_PnpNotify(pBtCoexist, pnpState);
else if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_PnpNotify(pBtCoexist, pnpState);
}
void EXhalbtcoutsrc_Periodical(struct btc_coexist *pBtCoexist)
{
if (!halbtcoutsrc_IsBtCoexistAvailable(pBtCoexist))
return;
pBtCoexist->statistics.cntPeriodical++;
/* Periodical should be called in cmd thread, */
/* don't need to leave low power again */
/* halbtcoutsrc_LeaveLowPower(pBtCoexist); */
if (pBtCoexist->boardInfo.btdmAntNum == 2)
EXhalbtc8723b2ant_Periodical(pBtCoexist);
else if (pBtCoexist->boardInfo.btdmAntNum == 1)
EXhalbtc8723b1ant_Periodical(pBtCoexist);
/* halbtcoutsrc_NormalLowPower(pBtCoexist); */
}
void EXhalbtcoutsrc_SetAntNum(u8 type, u8 antNum)
{
if (BT_COEX_ANT_TYPE_PG == type) {
GLBtCoexist.boardInfo.pgAntNum = antNum;
GLBtCoexist.boardInfo.btdmAntNum = antNum;
} else if (BT_COEX_ANT_TYPE_ANTDIV == type) {
GLBtCoexist.boardInfo.btdmAntNum = antNum;
/* GLBtCoexist.boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT; */
} else if (BT_COEX_ANT_TYPE_DETECTED == type) {
GLBtCoexist.boardInfo.btdmAntNum = antNum;
/* GLBtCoexist.boardInfo.btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT; */
}
}
/* */
/* Currently used by 8723b only, S0 or S1 */
/* */
void EXhalbtcoutsrc_SetSingleAntPath(u8 singleAntPath)
{
GLBtCoexist.boardInfo.singleAntPath = singleAntPath;
}
/*
* Description:
*Run BT-Coexist mechanism or not
*
*/
void hal_btcoex_SetBTCoexist(struct adapter *padapter, u8 bBtExist)
{
struct hal_com_data *pHalData;
pHalData = GET_HAL_DATA(padapter);
pHalData->bt_coexist.bBtExist = bBtExist;
}
/*
* Dewcription:
*Check is co-exist mechanism enabled or not
*
* Return:
*true Enable BT co-exist mechanism
*false Disable BT co-exist mechanism
*/
bool hal_btcoex_IsBtExist(struct adapter *padapter)
{
struct hal_com_data *pHalData;
pHalData = GET_HAL_DATA(padapter);
return pHalData->bt_coexist.bBtExist;
}
bool hal_btcoex_IsBtDisabled(struct adapter *padapter)
{
if (!hal_btcoex_IsBtExist(padapter))
return true;
if (GLBtCoexist.btInfo.bBtDisabled)
return true;
else
return false;
}
void hal_btcoex_SetPgAntNum(struct adapter *padapter, u8 antNum)
{
struct hal_com_data *pHalData;
pHalData = GET_HAL_DATA(padapter);
pHalData->bt_coexist.btTotalAntNum = antNum;
EXhalbtcoutsrc_SetAntNum(BT_COEX_ANT_TYPE_PG, antNum);
}
void hal_btcoex_SetSingleAntPath(struct adapter *padapter, u8 singleAntPath)
{
EXhalbtcoutsrc_SetSingleAntPath(singleAntPath);
}
void hal_btcoex_PowerOnSetting(struct adapter *padapter)
{
EXhalbtcoutsrc_PowerOnSetting(&GLBtCoexist);
}
void hal_btcoex_InitHwConfig(struct adapter *padapter, u8 bWifiOnly)
{
if (!hal_btcoex_IsBtExist(padapter))
return;
EXhalbtcoutsrc_InitHwConfig(&GLBtCoexist, bWifiOnly);
EXhalbtcoutsrc_InitCoexDm(&GLBtCoexist);
}
void hal_btcoex_IpsNotify(struct adapter *padapter, u8 type)
{
EXhalbtcoutsrc_IpsNotify(&GLBtCoexist, type);
}
void hal_btcoex_LpsNotify(struct adapter *padapter, u8 type)
{
EXhalbtcoutsrc_LpsNotify(&GLBtCoexist, type);
}
void hal_btcoex_ScanNotify(struct adapter *padapter, u8 type)
{
EXhalbtcoutsrc_ScanNotify(&GLBtCoexist, type);
}
void hal_btcoex_ConnectNotify(struct adapter *padapter, u8 action)
{
EXhalbtcoutsrc_ConnectNotify(&GLBtCoexist, action);
}
void hal_btcoex_MediaStatusNotify(struct adapter *padapter, u8 mediaStatus)
{
EXhalbtcoutsrc_MediaStatusNotify(&GLBtCoexist, mediaStatus);
}
void hal_btcoex_SpecialPacketNotify(struct adapter *padapter, u8 pktType)
{
EXhalbtcoutsrc_SpecialPacketNotify(&GLBtCoexist, pktType);
}
void hal_btcoex_IQKNotify(struct adapter *padapter, u8 state)
{
GLBtcWiFiInIQKState = state;
}
void hal_btcoex_BtInfoNotify(struct adapter *padapter, u8 length, u8 *tmpBuf)
{
if (GLBtcWiFiInIQKState)
return;
EXhalbtcoutsrc_BtInfoNotify(&GLBtCoexist, tmpBuf, length);
}
void hal_btcoex_SuspendNotify(struct adapter *padapter, u8 state)
{
if (state == 1)
state = BTC_WIFI_PNP_SLEEP;
else
state = BTC_WIFI_PNP_WAKE_UP;
EXhalbtcoutsrc_PnpNotify(&GLBtCoexist, state);
}
void hal_btcoex_HaltNotify(struct adapter *padapter)
{
EXhalbtcoutsrc_HaltNotify(&GLBtCoexist);
}
void hal_btcoex_Handler(struct adapter *padapter)
{
EXhalbtcoutsrc_Periodical(&GLBtCoexist);
}
s32 hal_btcoex_IsBTCoexCtrlAMPDUSize(struct adapter *padapter)
{
return (s32)GLBtCoexist.btInfo.bBtCtrlAggBufSize;
}
bool hal_btcoex_IsBtControlLps(struct adapter *padapter)
{
if (!hal_btcoex_IsBtExist(padapter))
return false;
if (GLBtCoexist.btInfo.bBtDisabled)
return false;
if (GLBtCoexist.btInfo.bBtCtrlLps)
return true;
return false;
}
bool hal_btcoex_IsLpsOn(struct adapter *padapter)
{
if (!hal_btcoex_IsBtExist(padapter))
return false;
if (GLBtCoexist.btInfo.bBtDisabled)
return false;
if (GLBtCoexist.btInfo.bBtLpsOn)
return true;
return false;
}
u8 hal_btcoex_RpwmVal(struct adapter *padapter)
{
return GLBtCoexist.btInfo.rpwmVal;
}
u8 hal_btcoex_LpsVal(struct adapter *padapter)
{
return GLBtCoexist.btInfo.lpsVal;
}
u32 hal_btcoex_GetRaMask(struct adapter *padapter)
{
if (!hal_btcoex_IsBtExist(padapter))
return 0;
if (GLBtCoexist.btInfo.bBtDisabled)
return 0;
if (GLBtCoexist.boardInfo.btdmAntNum != 1)
return 0;
return GLBtCoexist.btInfo.raMask;
}
void hal_btcoex_RecordPwrMode(struct adapter *padapter, u8 *pCmdBuf, u8 cmdLen)
{
memcpy(GLBtCoexist.pwrModeVal, pCmdBuf, cmdLen);
}
| linux-master | drivers/staging/rtl8723bs/hal/hal_btcoex.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <linux/kernel.h>
#include <drv_types.h>
#include <rtw_debug.h>
#include "hal_com_h2c.h"
#include "odm_precomp.h"
u8 rtw_hal_data_init(struct adapter *padapter)
{
if (is_primary_adapter(padapter)) { /* if (padapter->isprimary) */
padapter->hal_data_sz = sizeof(struct hal_com_data);
padapter->HalData = vzalloc(padapter->hal_data_sz);
if (!padapter->HalData)
return _FAIL;
}
return _SUCCESS;
}
void rtw_hal_data_deinit(struct adapter *padapter)
{
if (is_primary_adapter(padapter)) { /* if (padapter->isprimary) */
if (padapter->HalData) {
vfree(padapter->HalData);
padapter->HalData = NULL;
padapter->hal_data_sz = 0;
}
}
}
void dump_chip_info(struct hal_version ChipVersion)
{
char buf[128];
size_t cnt = 0;
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "Chip Version Info: CHIP_8723B_%s_",
IS_NORMAL_CHIP(ChipVersion) ? "Normal_Chip" : "Test_Chip");
if (IS_CHIP_VENDOR_TSMC(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "TSMC_");
else if (IS_CHIP_VENDOR_UMC(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "UMC_");
else if (IS_CHIP_VENDOR_SMIC(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "SMIC_");
if (IS_A_CUT(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "A_CUT_");
else if (IS_B_CUT(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "B_CUT_");
else if (IS_C_CUT(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "C_CUT_");
else if (IS_D_CUT(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "D_CUT_");
else if (IS_E_CUT(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "E_CUT_");
else if (IS_I_CUT(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "I_CUT_");
else if (IS_J_CUT(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "J_CUT_");
else if (IS_K_CUT(ChipVersion))
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "K_CUT_");
else
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt,
"UNKNOWN_CUT(%d)_", ChipVersion.CUTVersion);
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "1T1R_");
cnt += scnprintf(buf + cnt, sizeof(buf) - cnt, "RomVer(%d)\n", ChipVersion.ROMVer);
}
#define EEPROM_CHANNEL_PLAN_BY_HW_MASK 0x80
/*
* Description:
*Use hardware(efuse), driver parameter(registry) and default channel plan
*to decide which one should be used.
*
* Parameters:
*padapter pointer of adapter
*hw_channel_plan channel plan from HW (efuse/eeprom)
* BIT[7] software configure mode; 0:Enable, 1:disable
* BIT[6:0] Channel Plan
*sw_channel_plan channel plan from SW (registry/module param)
*def_channel_plan channel plan used when HW/SW both invalid
*AutoLoadFail efuse autoload fail or not
*
* Return:
*Final channel plan decision
*
*/
u8 hal_com_config_channel_plan(
struct adapter *padapter,
u8 hw_channel_plan,
u8 sw_channel_plan,
u8 def_channel_plan,
bool AutoLoadFail
)
{
struct hal_com_data *pHalData;
u8 chnlPlan;
pHalData = GET_HAL_DATA(padapter);
pHalData->bDisableSWChannelPlan = false;
chnlPlan = def_channel_plan;
if (0xFF == hw_channel_plan)
AutoLoadFail = true;
if (!AutoLoadFail) {
u8 hw_chnlPlan;
hw_chnlPlan = hw_channel_plan & (~EEPROM_CHANNEL_PLAN_BY_HW_MASK);
if (rtw_is_channel_plan_valid(hw_chnlPlan)) {
if (hw_channel_plan & EEPROM_CHANNEL_PLAN_BY_HW_MASK)
pHalData->bDisableSWChannelPlan = true;
chnlPlan = hw_chnlPlan;
}
}
if (
(false == pHalData->bDisableSWChannelPlan) &&
rtw_is_channel_plan_valid(sw_channel_plan)
)
chnlPlan = sw_channel_plan;
return chnlPlan;
}
bool HAL_IsLegalChannel(struct adapter *adapter, u32 Channel)
{
bool bLegalChannel = true;
if ((Channel <= 14) && (Channel >= 1)) {
if (is_supported_24g(adapter->registrypriv.wireless_mode) == false)
bLegalChannel = false;
} else {
bLegalChannel = false;
}
return bLegalChannel;
}
u8 MRateToHwRate(u8 rate)
{
u8 ret = DESC_RATE1M;
switch (rate) {
case MGN_1M:
ret = DESC_RATE1M;
break;
case MGN_2M:
ret = DESC_RATE2M;
break;
case MGN_5_5M:
ret = DESC_RATE5_5M;
break;
case MGN_11M:
ret = DESC_RATE11M;
break;
case MGN_6M:
ret = DESC_RATE6M;
break;
case MGN_9M:
ret = DESC_RATE9M;
break;
case MGN_12M:
ret = DESC_RATE12M;
break;
case MGN_18M:
ret = DESC_RATE18M;
break;
case MGN_24M:
ret = DESC_RATE24M;
break;
case MGN_36M:
ret = DESC_RATE36M;
break;
case MGN_48M:
ret = DESC_RATE48M;
break;
case MGN_54M:
ret = DESC_RATE54M;
break;
case MGN_MCS0:
ret = DESC_RATEMCS0;
break;
case MGN_MCS1:
ret = DESC_RATEMCS1;
break;
case MGN_MCS2:
ret = DESC_RATEMCS2;
break;
case MGN_MCS3:
ret = DESC_RATEMCS3;
break;
case MGN_MCS4:
ret = DESC_RATEMCS4;
break;
case MGN_MCS5:
ret = DESC_RATEMCS5;
break;
case MGN_MCS6:
ret = DESC_RATEMCS6;
break;
case MGN_MCS7:
ret = DESC_RATEMCS7;
break;
default:
break;
}
return ret;
}
u8 HwRateToMRate(u8 rate)
{
u8 ret_rate = MGN_1M;
switch (rate) {
case DESC_RATE1M:
ret_rate = MGN_1M;
break;
case DESC_RATE2M:
ret_rate = MGN_2M;
break;
case DESC_RATE5_5M:
ret_rate = MGN_5_5M;
break;
case DESC_RATE11M:
ret_rate = MGN_11M;
break;
case DESC_RATE6M:
ret_rate = MGN_6M;
break;
case DESC_RATE9M:
ret_rate = MGN_9M;
break;
case DESC_RATE12M:
ret_rate = MGN_12M;
break;
case DESC_RATE18M:
ret_rate = MGN_18M;
break;
case DESC_RATE24M:
ret_rate = MGN_24M;
break;
case DESC_RATE36M:
ret_rate = MGN_36M;
break;
case DESC_RATE48M:
ret_rate = MGN_48M;
break;
case DESC_RATE54M:
ret_rate = MGN_54M;
break;
case DESC_RATEMCS0:
ret_rate = MGN_MCS0;
break;
case DESC_RATEMCS1:
ret_rate = MGN_MCS1;
break;
case DESC_RATEMCS2:
ret_rate = MGN_MCS2;
break;
case DESC_RATEMCS3:
ret_rate = MGN_MCS3;
break;
case DESC_RATEMCS4:
ret_rate = MGN_MCS4;
break;
case DESC_RATEMCS5:
ret_rate = MGN_MCS5;
break;
case DESC_RATEMCS6:
ret_rate = MGN_MCS6;
break;
case DESC_RATEMCS7:
ret_rate = MGN_MCS7;
break;
default:
break;
}
return ret_rate;
}
void HalSetBrateCfg(struct adapter *Adapter, u8 *mBratesOS, u16 *pBrateCfg)
{
u8 i, is_brate, brate;
for (i = 0; i < NDIS_802_11_LENGTH_RATES_EX; i++) {
is_brate = mBratesOS[i] & IEEE80211_BASIC_RATE_MASK;
brate = mBratesOS[i] & 0x7f;
if (is_brate) {
switch (brate) {
case IEEE80211_CCK_RATE_1MB:
*pBrateCfg |= RATE_1M;
break;
case IEEE80211_CCK_RATE_2MB:
*pBrateCfg |= RATE_2M;
break;
case IEEE80211_CCK_RATE_5MB:
*pBrateCfg |= RATE_5_5M;
break;
case IEEE80211_CCK_RATE_11MB:
*pBrateCfg |= RATE_11M;
break;
case IEEE80211_OFDM_RATE_6MB:
*pBrateCfg |= RATE_6M;
break;
case IEEE80211_OFDM_RATE_9MB:
*pBrateCfg |= RATE_9M;
break;
case IEEE80211_OFDM_RATE_12MB:
*pBrateCfg |= RATE_12M;
break;
case IEEE80211_OFDM_RATE_18MB:
*pBrateCfg |= RATE_18M;
break;
case IEEE80211_OFDM_RATE_24MB:
*pBrateCfg |= RATE_24M;
break;
case IEEE80211_OFDM_RATE_36MB:
*pBrateCfg |= RATE_36M;
break;
case IEEE80211_OFDM_RATE_48MB:
*pBrateCfg |= RATE_48M;
break;
case IEEE80211_OFDM_RATE_54MB:
*pBrateCfg |= RATE_54M;
break;
}
}
}
}
static void _OneOutPipeMapping(struct adapter *padapter)
{
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
pdvobjpriv->Queue2Pipe[0] = pdvobjpriv->RtOutPipe[0];/* VO */
pdvobjpriv->Queue2Pipe[1] = pdvobjpriv->RtOutPipe[0];/* VI */
pdvobjpriv->Queue2Pipe[2] = pdvobjpriv->RtOutPipe[0];/* BE */
pdvobjpriv->Queue2Pipe[3] = pdvobjpriv->RtOutPipe[0];/* BK */
pdvobjpriv->Queue2Pipe[4] = pdvobjpriv->RtOutPipe[0];/* BCN */
pdvobjpriv->Queue2Pipe[5] = pdvobjpriv->RtOutPipe[0];/* MGT */
pdvobjpriv->Queue2Pipe[6] = pdvobjpriv->RtOutPipe[0];/* HIGH */
pdvobjpriv->Queue2Pipe[7] = pdvobjpriv->RtOutPipe[0];/* TXCMD */
}
static void _TwoOutPipeMapping(struct adapter *padapter, bool bWIFICfg)
{
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
if (bWIFICfg) { /* WMM */
/* BK, BE, VI, VO, BCN, CMD, MGT, HIGH, HCCA */
/* 0, 1, 0, 1, 0, 0, 0, 0, 0 }; */
/* 0:ep_0 num, 1:ep_1 num */
pdvobjpriv->Queue2Pipe[0] = pdvobjpriv->RtOutPipe[1];/* VO */
pdvobjpriv->Queue2Pipe[1] = pdvobjpriv->RtOutPipe[0];/* VI */
pdvobjpriv->Queue2Pipe[2] = pdvobjpriv->RtOutPipe[1];/* BE */
pdvobjpriv->Queue2Pipe[3] = pdvobjpriv->RtOutPipe[0];/* BK */
pdvobjpriv->Queue2Pipe[4] = pdvobjpriv->RtOutPipe[0];/* BCN */
pdvobjpriv->Queue2Pipe[5] = pdvobjpriv->RtOutPipe[0];/* MGT */
pdvobjpriv->Queue2Pipe[6] = pdvobjpriv->RtOutPipe[0];/* HIGH */
pdvobjpriv->Queue2Pipe[7] = pdvobjpriv->RtOutPipe[0];/* TXCMD */
} else { /* typical setting */
/* BK, BE, VI, VO, BCN, CMD, MGT, HIGH, HCCA */
/* 1, 1, 0, 0, 0, 0, 0, 0, 0 }; */
/* 0:ep_0 num, 1:ep_1 num */
pdvobjpriv->Queue2Pipe[0] = pdvobjpriv->RtOutPipe[0];/* VO */
pdvobjpriv->Queue2Pipe[1] = pdvobjpriv->RtOutPipe[0];/* VI */
pdvobjpriv->Queue2Pipe[2] = pdvobjpriv->RtOutPipe[1];/* BE */
pdvobjpriv->Queue2Pipe[3] = pdvobjpriv->RtOutPipe[1];/* BK */
pdvobjpriv->Queue2Pipe[4] = pdvobjpriv->RtOutPipe[0];/* BCN */
pdvobjpriv->Queue2Pipe[5] = pdvobjpriv->RtOutPipe[0];/* MGT */
pdvobjpriv->Queue2Pipe[6] = pdvobjpriv->RtOutPipe[0];/* HIGH */
pdvobjpriv->Queue2Pipe[7] = pdvobjpriv->RtOutPipe[0];/* TXCMD */
}
}
static void _ThreeOutPipeMapping(struct adapter *padapter, bool bWIFICfg)
{
struct dvobj_priv *pdvobjpriv = adapter_to_dvobj(padapter);
if (bWIFICfg) { /* for WMM */
/* BK, BE, VI, VO, BCN, CMD, MGT, HIGH, HCCA */
/* 1, 2, 1, 0, 0, 0, 0, 0, 0 }; */
/* 0:H, 1:N, 2:L */
pdvobjpriv->Queue2Pipe[0] = pdvobjpriv->RtOutPipe[0];/* VO */
pdvobjpriv->Queue2Pipe[1] = pdvobjpriv->RtOutPipe[1];/* VI */
pdvobjpriv->Queue2Pipe[2] = pdvobjpriv->RtOutPipe[2];/* BE */
pdvobjpriv->Queue2Pipe[3] = pdvobjpriv->RtOutPipe[1];/* BK */
pdvobjpriv->Queue2Pipe[4] = pdvobjpriv->RtOutPipe[0];/* BCN */
pdvobjpriv->Queue2Pipe[5] = pdvobjpriv->RtOutPipe[0];/* MGT */
pdvobjpriv->Queue2Pipe[6] = pdvobjpriv->RtOutPipe[0];/* HIGH */
pdvobjpriv->Queue2Pipe[7] = pdvobjpriv->RtOutPipe[0];/* TXCMD */
} else { /* typical setting */
/* BK, BE, VI, VO, BCN, CMD, MGT, HIGH, HCCA */
/* 2, 2, 1, 0, 0, 0, 0, 0, 0 }; */
/* 0:H, 1:N, 2:L */
pdvobjpriv->Queue2Pipe[0] = pdvobjpriv->RtOutPipe[0];/* VO */
pdvobjpriv->Queue2Pipe[1] = pdvobjpriv->RtOutPipe[1];/* VI */
pdvobjpriv->Queue2Pipe[2] = pdvobjpriv->RtOutPipe[2];/* BE */
pdvobjpriv->Queue2Pipe[3] = pdvobjpriv->RtOutPipe[2];/* BK */
pdvobjpriv->Queue2Pipe[4] = pdvobjpriv->RtOutPipe[0];/* BCN */
pdvobjpriv->Queue2Pipe[5] = pdvobjpriv->RtOutPipe[0];/* MGT */
pdvobjpriv->Queue2Pipe[6] = pdvobjpriv->RtOutPipe[0];/* HIGH */
pdvobjpriv->Queue2Pipe[7] = pdvobjpriv->RtOutPipe[0];/* TXCMD */
}
}
bool Hal_MappingOutPipe(struct adapter *padapter, u8 NumOutPipe)
{
struct registry_priv *pregistrypriv = &padapter->registrypriv;
bool bWIFICfg = (pregistrypriv->wifi_spec) ? true : false;
bool result = true;
switch (NumOutPipe) {
case 2:
_TwoOutPipeMapping(padapter, bWIFICfg);
break;
case 3:
case 4:
_ThreeOutPipeMapping(padapter, bWIFICfg);
break;
case 1:
_OneOutPipeMapping(padapter);
break;
default:
result = false;
break;
}
return result;
}
void hal_init_macaddr(struct adapter *adapter)
{
rtw_hal_set_hwreg(adapter, HW_VAR_MAC_ADDR, adapter->eeprompriv.mac_addr);
}
void rtw_init_hal_com_default_value(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
pHalData->AntDetection = 1;
}
/*
* C2H event format:
* Field TRIGGER CONTENT CMD_SEQ CMD_LEN CMD_ID
* BITS [127:120] [119:16] [15:8] [7:4] [3:0]
*/
void c2h_evt_clear(struct adapter *adapter)
{
rtw_write8(adapter, REG_C2HEVT_CLEAR, C2H_EVT_HOST_CLOSE);
}
/*
* C2H event format:
* Field TRIGGER CMD_LEN CONTENT CMD_SEQ CMD_ID
* BITS [127:120] [119:112] [111:16] [15:8] [7:0]
*/
s32 c2h_evt_read_88xx(struct adapter *adapter, u8 *buf)
{
s32 ret = _FAIL;
struct c2h_evt_hdr_88xx *c2h_evt;
int i;
u8 trigger;
if (!buf)
goto exit;
trigger = rtw_read8(adapter, REG_C2HEVT_CLEAR);
if (trigger == C2H_EVT_HOST_CLOSE)
goto exit; /* Not ready */
else if (trigger != C2H_EVT_FW_CLOSE)
goto clear_evt; /* Not a valid value */
c2h_evt = (struct c2h_evt_hdr_88xx *)buf;
memset(c2h_evt, 0, 16);
c2h_evt->id = rtw_read8(adapter, REG_C2HEVT_MSG_NORMAL);
c2h_evt->seq = rtw_read8(adapter, REG_C2HEVT_CMD_SEQ_88XX);
c2h_evt->plen = rtw_read8(adapter, REG_C2HEVT_CMD_LEN_88XX);
/* Read the content */
for (i = 0; i < c2h_evt->plen; i++)
c2h_evt->payload[i] = rtw_read8(adapter, REG_C2HEVT_MSG_NORMAL + 2 + i);
ret = _SUCCESS;
clear_evt:
/*
* Clear event to notify FW we have read the command.
* If this field isn't clear, the FW won't update the next command message.
*/
c2h_evt_clear(adapter);
exit:
return ret;
}
u8 rtw_get_mgntframe_raid(struct adapter *adapter, unsigned char network_type)
{
return (network_type & WIRELESS_11B) ? RATEID_IDX_B : RATEID_IDX_G;
}
void rtw_hal_update_sta_rate_mask(struct adapter *padapter, struct sta_info *psta)
{
u8 i, limit;
u32 tx_ra_bitmap;
if (!psta)
return;
tx_ra_bitmap = 0;
/* b/g mode ra_bitmap */
for (i = 0; i < sizeof(psta->bssrateset); i++) {
if (psta->bssrateset[i])
tx_ra_bitmap |= rtw_get_bit_value_from_ieee_value(psta->bssrateset[i]&0x7f);
}
/* n mode ra_bitmap */
if (psta->htpriv.ht_option) {
limit = 8; /* 1R */
for (i = 0; i < limit; i++) {
if (psta->htpriv.ht_cap.mcs.rx_mask[i/8] & BIT(i%8))
tx_ra_bitmap |= BIT(i+12);
}
}
psta->ra_mask = tx_ra_bitmap;
psta->init_rate = get_highest_rate_idx(tx_ra_bitmap)&0x3f;
}
void hw_var_port_switch(struct adapter *adapter)
{
}
void SetHwReg(struct adapter *adapter, u8 variable, u8 *val)
{
struct hal_com_data *hal_data = GET_HAL_DATA(adapter);
struct dm_odm_t *odm = &(hal_data->odmpriv);
switch (variable) {
case HW_VAR_PORT_SWITCH:
hw_var_port_switch(adapter);
break;
case HW_VAR_INIT_RTS_RATE:
rtw_warn_on(1);
break;
case HW_VAR_SEC_CFG:
{
u16 reg_scr;
reg_scr = rtw_read16(adapter, REG_SECCFG);
rtw_write16(adapter, REG_SECCFG, reg_scr|SCR_CHK_KEYID|SCR_RxDecEnable|SCR_TxEncEnable);
}
break;
case HW_VAR_SEC_DK_CFG:
{
struct security_priv *sec = &adapter->securitypriv;
u8 reg_scr = rtw_read8(adapter, REG_SECCFG);
if (val) { /* Enable default key related setting */
reg_scr |= SCR_TXBCUSEDK;
if (sec->dot11AuthAlgrthm != dot11AuthAlgrthm_8021X)
reg_scr |= (SCR_RxUseDK|SCR_TxUseDK);
} else /* Disable default key related setting */
reg_scr &= ~(SCR_RXBCUSEDK|SCR_TXBCUSEDK|SCR_RxUseDK|SCR_TxUseDK);
rtw_write8(adapter, REG_SECCFG, reg_scr);
}
break;
case HW_VAR_DM_FLAG:
odm->SupportAbility = *((u32 *)val);
break;
case HW_VAR_DM_FUNC_OP:
if (*((u8 *)val) == true) {
/* save dm flag */
odm->BK_SupportAbility = odm->SupportAbility;
} else {
/* restore dm flag */
odm->SupportAbility = odm->BK_SupportAbility;
}
break;
case HW_VAR_DM_FUNC_SET:
if (*((u32 *)val) == DYNAMIC_ALL_FUNC_ENABLE) {
struct dm_priv *dm = &hal_data->dmpriv;
dm->DMFlag = dm->InitDMFlag;
odm->SupportAbility = dm->InitODMFlag;
} else {
odm->SupportAbility |= *((u32 *)val);
}
break;
case HW_VAR_DM_FUNC_CLR:
/*
* input is already a mask to clear function
* don't invert it again! George, Lucas@20130513
*/
odm->SupportAbility &= *((u32 *)val);
break;
case HW_VAR_AMPDU_MIN_SPACE:
/* TODO - Is something needed here? */
break;
case HW_VAR_WIRELESS_MODE:
/* TODO - Is something needed here? */
break;
default:
netdev_dbg(adapter->pnetdev,
FUNC_ADPT_FMT " variable(%d) not defined!\n",
FUNC_ADPT_ARG(adapter), variable);
break;
}
}
void GetHwReg(struct adapter *adapter, u8 variable, u8 *val)
{
struct hal_com_data *hal_data = GET_HAL_DATA(adapter);
struct dm_odm_t *odm = &(hal_data->odmpriv);
switch (variable) {
case HW_VAR_BASIC_RATE:
*((u16 *)val) = hal_data->BasicRateSet;
break;
case HW_VAR_DM_FLAG:
*((u32 *)val) = odm->SupportAbility;
break;
default:
netdev_dbg(adapter->pnetdev,
FUNC_ADPT_FMT " variable(%d) not defined!\n",
FUNC_ADPT_ARG(adapter), variable);
break;
}
}
u8 SetHalDefVar(
struct adapter *adapter, enum hal_def_variable variable, void *value
)
{
struct hal_com_data *hal_data = GET_HAL_DATA(adapter);
struct dm_odm_t *odm = &(hal_data->odmpriv);
u8 bResult = _SUCCESS;
switch (variable) {
case HAL_DEF_DBG_RX_INFO_DUMP:
if (odm->bLinked) {
#ifdef DBG_RX_SIGNAL_DISPLAY_RAW_DATA
rtw_dump_raw_rssi_info(adapter);
#endif
}
break;
case HW_DEF_ODM_DBG_FLAG:
ODM_CmnInfoUpdate(odm, ODM_CMNINFO_DBG_COMP, *((u64 *)value));
break;
case HW_DEF_ODM_DBG_LEVEL:
ODM_CmnInfoUpdate(odm, ODM_CMNINFO_DBG_LEVEL, *((u32 *)value));
break;
case HAL_DEF_DBG_DM_FUNC:
{
u8 dm_func = *((u8 *)value);
struct dm_priv *dm = &hal_data->dmpriv;
if (dm_func == 0) { /* disable all dynamic func */
odm->SupportAbility = DYNAMIC_FUNC_DISABLE;
} else if (dm_func == 1) {/* disable DIG */
odm->SupportAbility &= (~DYNAMIC_BB_DIG);
} else if (dm_func == 2) {/* disable High power */
odm->SupportAbility &= (~DYNAMIC_BB_DYNAMIC_TXPWR);
} else if (dm_func == 3) {/* disable tx power tracking */
odm->SupportAbility &= (~DYNAMIC_RF_CALIBRATION);
} else if (dm_func == 4) {/* disable BT coexistence */
dm->DMFlag &= (~DYNAMIC_FUNC_BT);
} else if (dm_func == 5) {/* disable antenna diversity */
odm->SupportAbility &= (~DYNAMIC_BB_ANT_DIV);
} else if (dm_func == 6) {/* turn on all dynamic func */
if (!(odm->SupportAbility & DYNAMIC_BB_DIG)) {
struct dig_t *pDigTable = &odm->DM_DigTable;
pDigTable->CurIGValue = rtw_read8(adapter, 0xc50);
}
dm->DMFlag |= DYNAMIC_FUNC_BT;
odm->SupportAbility = DYNAMIC_ALL_FUNC_ENABLE;
}
}
break;
case HAL_DEF_DBG_DUMP_RXPKT:
hal_data->bDumpRxPkt = *((u8 *)value);
break;
case HAL_DEF_DBG_DUMP_TXPKT:
hal_data->bDumpTxPkt = *((u8 *)value);
break;
case HAL_DEF_ANT_DETECT:
hal_data->AntDetection = *((u8 *)value);
break;
default:
netdev_dbg(adapter->pnetdev,
"%s: [WARNING] HAL_DEF_VARIABLE(%d) not defined!\n",
__func__, variable);
bResult = _FAIL;
break;
}
return bResult;
}
u8 GetHalDefVar(
struct adapter *adapter, enum hal_def_variable variable, void *value
)
{
struct hal_com_data *hal_data = GET_HAL_DATA(adapter);
u8 bResult = _SUCCESS;
switch (variable) {
case HAL_DEF_UNDERCORATEDSMOOTHEDPWDB:
{
struct mlme_priv *pmlmepriv;
struct sta_priv *pstapriv;
struct sta_info *psta;
pmlmepriv = &adapter->mlmepriv;
pstapriv = &adapter->stapriv;
psta = rtw_get_stainfo(pstapriv, pmlmepriv->cur_network.network.mac_address);
if (psta)
*((int *)value) = psta->rssi_stat.UndecoratedSmoothedPWDB;
}
break;
case HAL_DEF_DBG_DM_FUNC:
*((u32 *)value) = hal_data->odmpriv.SupportAbility;
break;
case HAL_DEF_DBG_DUMP_RXPKT:
*((u8 *)value) = hal_data->bDumpRxPkt;
break;
case HAL_DEF_DBG_DUMP_TXPKT:
*((u8 *)value) = hal_data->bDumpTxPkt;
break;
case HAL_DEF_ANT_DETECT:
*((u8 *)value) = hal_data->AntDetection;
break;
case HAL_DEF_MACID_SLEEP:
*(u8 *)value = false;
break;
case HAL_DEF_TX_PAGE_SIZE:
*((u32 *)value) = PAGE_SIZE_128;
break;
default:
netdev_dbg(adapter->pnetdev,
"%s: [WARNING] HAL_DEF_VARIABLE(%d) not defined!\n",
__func__, variable);
bResult = _FAIL;
break;
}
return bResult;
}
void GetHalODMVar(
struct adapter *Adapter,
enum hal_odm_variable eVariable,
void *pValue1,
void *pValue2
)
{
switch (eVariable) {
default:
break;
}
}
void SetHalODMVar(
struct adapter *Adapter,
enum hal_odm_variable eVariable,
void *pValue1,
bool bSet
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct dm_odm_t *podmpriv = &pHalData->odmpriv;
/* _irqL irqL; */
switch (eVariable) {
case HAL_ODM_STA_INFO:
{
struct sta_info *psta = pValue1;
if (bSet) {
ODM_CmnInfoPtrArrayHook(podmpriv, ODM_CMNINFO_STA_STATUS, psta->mac_id, psta);
} else {
/* spin_lock_bh(&pHalData->odm_stainfo_lock); */
ODM_CmnInfoPtrArrayHook(podmpriv, ODM_CMNINFO_STA_STATUS, psta->mac_id, NULL);
/* spin_unlock_bh(&pHalData->odm_stainfo_lock); */
}
}
break;
case HAL_ODM_P2P_STATE:
ODM_CmnInfoUpdate(podmpriv, ODM_CMNINFO_WIFI_DIRECT, bSet);
break;
case HAL_ODM_WIFI_DISPLAY_STATE:
ODM_CmnInfoUpdate(podmpriv, ODM_CMNINFO_WIFI_DISPLAY, bSet);
break;
default:
break;
}
}
bool eqNByte(u8 *str1, u8 *str2, u32 num)
{
if (num == 0)
return false;
while (num > 0) {
num--;
if (str1[num] != str2[num])
return false;
}
return true;
}
bool GetU1ByteIntegerFromStringInDecimal(char *Str, u8 *pInt)
{
u16 i = 0;
*pInt = 0;
while (Str[i] != '\0') {
if (Str[i] >= '0' && Str[i] <= '9') {
*pInt *= 10;
*pInt += (Str[i] - '0');
} else
return false;
++i;
}
return true;
}
void rtw_hal_check_rxfifo_full(struct adapter *adapter)
{
struct dvobj_priv *psdpriv = adapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
int save_cnt = false;
/* switch counter to RX fifo */
/* printk("8723b or 8192e , MAC_667 set 0xf0\n"); */
rtw_write8(adapter, REG_RXERR_RPT+3, rtw_read8(adapter, REG_RXERR_RPT+3)|0xf0);
save_cnt = true;
/* todo: other chips */
if (save_cnt) {
/* rtw_write8(adapter, REG_RXERR_RPT+3, rtw_read8(adapter, REG_RXERR_RPT+3)|0xa0); */
pdbgpriv->dbg_rx_fifo_last_overflow = pdbgpriv->dbg_rx_fifo_curr_overflow;
pdbgpriv->dbg_rx_fifo_curr_overflow = rtw_read16(adapter, REG_RXERR_RPT);
pdbgpriv->dbg_rx_fifo_diff_overflow = pdbgpriv->dbg_rx_fifo_curr_overflow-pdbgpriv->dbg_rx_fifo_last_overflow;
}
}
#ifdef DBG_RX_SIGNAL_DISPLAY_RAW_DATA
void rtw_dump_raw_rssi_info(struct adapter *padapter)
{
u8 isCCKrate, rf_path;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct rx_raw_rssi *psample_pkt_rssi = &padapter->recvpriv.raw_rssi_info;
isCCKrate = psample_pkt_rssi->data_rate <= DESC_RATE11M;
if (isCCKrate)
psample_pkt_rssi->mimo_signal_strength[0] = psample_pkt_rssi->pwdball;
for (rf_path = 0; rf_path < pHalData->NumTotalRFPath; rf_path++) {
if (!isCCKrate) {
printk(", rx_ofdm_pwr:%d(dBm), rx_ofdm_snr:%d(dB)\n",
psample_pkt_rssi->ofdm_pwr[rf_path], psample_pkt_rssi->ofdm_snr[rf_path]);
} else {
printk("\n");
}
}
}
void rtw_store_phy_info(struct adapter *padapter, union recv_frame *prframe)
{
u8 isCCKrate, rf_path;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct rx_pkt_attrib *pattrib = &prframe->u.hdr.attrib;
struct odm_phy_info *pPhyInfo = (PODM_PHY_INFO_T)(&pattrib->phy_info);
struct rx_raw_rssi *psample_pkt_rssi = &padapter->recvpriv.raw_rssi_info;
psample_pkt_rssi->data_rate = pattrib->data_rate;
isCCKrate = pattrib->data_rate <= DESC_RATE11M;
psample_pkt_rssi->pwdball = pPhyInfo->rx_pwd_ba11;
psample_pkt_rssi->pwr_all = pPhyInfo->recv_signal_power;
for (rf_path = 0; rf_path < pHalData->NumTotalRFPath; rf_path++) {
psample_pkt_rssi->mimo_signal_strength[rf_path] = pPhyInfo->rx_mimo_signal_strength[rf_path];
psample_pkt_rssi->mimo_signal_quality[rf_path] = pPhyInfo->rx_mimo_signal_quality[rf_path];
if (!isCCKrate) {
psample_pkt_rssi->ofdm_pwr[rf_path] = pPhyInfo->RxPwr[rf_path];
psample_pkt_rssi->ofdm_snr[rf_path] = pPhyInfo->RxSNR[rf_path];
}
}
}
#endif
static u32 Array_kfreemap[] = {
0xf8, 0xe,
0xf6, 0xc,
0xf4, 0xa,
0xf2, 0x8,
0xf0, 0x6,
0xf3, 0x4,
0xf5, 0x2,
0xf7, 0x0,
0xf9, 0x0,
0xfc, 0x0,
};
void rtw_bb_rf_gain_offset(struct adapter *padapter)
{
u8 value = padapter->eeprompriv.EEPROMRFGainOffset;
u32 res, i = 0;
u32 *Array = Array_kfreemap;
u32 v1 = 0, v2 = 0, target = 0;
if (value & BIT4) {
if (padapter->eeprompriv.EEPROMRFGainVal != 0xff) {
res = rtw_hal_read_rfreg(padapter, RF_PATH_A, 0x7f, 0xffffffff);
res &= 0xfff87fff;
/* res &= 0xfff87fff; */
for (i = 0; i < ARRAY_SIZE(Array_kfreemap); i += 2) {
v1 = Array[i];
v2 = Array[i+1];
if (v1 == padapter->eeprompriv.EEPROMRFGainVal) {
target = v2;
break;
}
}
PHY_SetRFReg(padapter, RF_PATH_A, REG_RF_BB_GAIN_OFFSET, BIT18|BIT17|BIT16|BIT15, target);
/* res |= (padapter->eeprompriv.EEPROMRFGainVal & 0x0f)<< 15; */
/* rtw_hal_write_rfreg(padapter, RF_PATH_A, REG_RF_BB_GAIN_OFFSET, RF_GAIN_OFFSET_MASK, res); */
res = rtw_hal_read_rfreg(padapter, RF_PATH_A, 0x7f, 0xffffffff);
}
}
}
| linux-master | drivers/staging/rtl8723bs/hal/hal_com.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtl8723b_hal.h>
/**
* phy_CalculateBitShift - Get shifted position of the BitMask.
* @BitMask: Bitmask.
*
* Return: Return the shift bit position of the mask
*/
static u32 phy_CalculateBitShift(u32 BitMask)
{
u32 i;
for (i = 0; i <= 31; i++) {
if (((BitMask>>i) & 0x1) == 1)
break;
}
return i;
}
/**
* PHY_QueryBBReg_8723B - Read "specific bits" from BB register.
* @Adapter:
* @RegAddr: The target address to be readback
* @BitMask: The target bit position in the target address
* to be readback
*
* Return: The readback register value
*
* .. Note:: This function is equal to "GetRegSetting" in PHY programming
* guide
*/
u32 PHY_QueryBBReg_8723B(struct adapter *Adapter, u32 RegAddr, u32 BitMask)
{
u32 OriginalValue, BitShift;
OriginalValue = rtw_read32(Adapter, RegAddr);
BitShift = phy_CalculateBitShift(BitMask);
return (OriginalValue & BitMask) >> BitShift;
}
/**
* PHY_SetBBReg_8723B - Write "Specific bits" to BB register (page 8~).
* @Adapter:
* @RegAddr: The target address to be modified
* @BitMask: The target bit position in the target address
* to be modified
* @Data: The new register value in the target bit position
* of the target address
*
* .. Note:: This function is equal to "PutRegSetting" in PHY programming
* guide
*/
void PHY_SetBBReg_8723B(
struct adapter *Adapter,
u32 RegAddr,
u32 BitMask,
u32 Data
)
{
/* u16 BBWaitCounter = 0; */
u32 OriginalValue, BitShift;
if (BitMask != bMaskDWord) { /* if not "double word" write */
OriginalValue = rtw_read32(Adapter, RegAddr);
BitShift = phy_CalculateBitShift(BitMask);
Data = ((OriginalValue & (~BitMask)) | ((Data << BitShift) & BitMask));
}
rtw_write32(Adapter, RegAddr, Data);
}
/* */
/* 2. RF register R/W API */
/* */
static u32 phy_RFSerialRead_8723B(
struct adapter *Adapter, enum rf_path eRFPath, u32 Offset
)
{
u32 retValue = 0;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct bb_register_def *pPhyReg = &pHalData->PHYRegDef[eRFPath];
u32 NewOffset;
u32 tmplong2;
u8 RfPiEnable = 0;
u32 MaskforPhySet = 0;
int i = 0;
/* */
/* Make sure RF register offset is correct */
/* */
Offset &= 0xff;
NewOffset = Offset;
if (eRFPath == RF_PATH_A) {
tmplong2 = PHY_QueryBBReg(Adapter, rFPGA0_XA_HSSIParameter2|MaskforPhySet, bMaskDWord);
tmplong2 = (tmplong2 & (~bLSSIReadAddress)) | (NewOffset<<23) | bLSSIReadEdge; /* T65 RF */
PHY_SetBBReg(Adapter, rFPGA0_XA_HSSIParameter2|MaskforPhySet, bMaskDWord, tmplong2&(~bLSSIReadEdge));
} else {
tmplong2 = PHY_QueryBBReg(Adapter, rFPGA0_XB_HSSIParameter2|MaskforPhySet, bMaskDWord);
tmplong2 = (tmplong2 & (~bLSSIReadAddress)) | (NewOffset<<23) | bLSSIReadEdge; /* T65 RF */
PHY_SetBBReg(Adapter, rFPGA0_XB_HSSIParameter2|MaskforPhySet, bMaskDWord, tmplong2&(~bLSSIReadEdge));
}
tmplong2 = PHY_QueryBBReg(Adapter, rFPGA0_XA_HSSIParameter2|MaskforPhySet, bMaskDWord);
PHY_SetBBReg(Adapter, rFPGA0_XA_HSSIParameter2|MaskforPhySet, bMaskDWord, tmplong2 & (~bLSSIReadEdge));
PHY_SetBBReg(Adapter, rFPGA0_XA_HSSIParameter2|MaskforPhySet, bMaskDWord, tmplong2 | bLSSIReadEdge);
udelay(10);
for (i = 0; i < 2; i++)
udelay(MAX_STALL_TIME);
udelay(10);
if (eRFPath == RF_PATH_A)
RfPiEnable = (u8)PHY_QueryBBReg(Adapter, rFPGA0_XA_HSSIParameter1|MaskforPhySet, BIT8);
else if (eRFPath == RF_PATH_B)
RfPiEnable = (u8)PHY_QueryBBReg(Adapter, rFPGA0_XB_HSSIParameter1|MaskforPhySet, BIT8);
if (RfPiEnable) {
/* Read from BBreg8b8, 12 bits for 8190, 20bits for T65 RF */
retValue = PHY_QueryBBReg(Adapter, pPhyReg->rfLSSIReadBackPi|MaskforPhySet, bLSSIReadBackData);
} else {
/* Read from BBreg8a0, 12 bits for 8190, 20 bits for T65 RF */
retValue = PHY_QueryBBReg(Adapter, pPhyReg->rfLSSIReadBack|MaskforPhySet, bLSSIReadBackData);
}
return retValue;
}
/**
* phy_RFSerialWrite_8723B - Write data to RF register (page 8~).
* @Adapter:
* @eRFPath: Radio path of A/B/C/D
* @Offset: The target address to be read
* @Data: The new register Data in the target bit position
* of the target to be read
*
* .. Note:: Threre are three types of serial operations:
* 1. Software serial write
* 2. Hardware LSSI-Low Speed Serial Interface
* 3. Hardware HSSI-High speed
* serial write. Driver need to implement (1) and (2).
* This function is equal to the combination of RF_ReadReg() and RFLSSIRead()
*
* .. Note:: For RF8256 only
* The total count of RTL8256(Zebra4) register is around 36 bit it only employs
* 4-bit RF address. RTL8256 uses "register mode control bit" (Reg00[12], Reg00[10])
* to access register address bigger than 0xf. See "Appendix-4 in PHY Configuration
* programming guide" for more details.
* Thus, we define a sub-finction for RTL8526 register address conversion
* ===========================================================
* Register Mode RegCTL[1] RegCTL[0] Note
* (Reg00[12]) (Reg00[10])
* ===========================================================
* Reg_Mode0 0 x Reg 0 ~15(0x0 ~ 0xf)
* ------------------------------------------------------------------
* Reg_Mode1 1 0 Reg 16 ~30(0x1 ~ 0xf)
* ------------------------------------------------------------------
* Reg_Mode2 1 1 Reg 31 ~ 45(0x1 ~ 0xf)
* ------------------------------------------------------------------
*
*2008/09/02 MH Add 92S RF definition
*
*
*
*/
static void phy_RFSerialWrite_8723B(
struct adapter *Adapter,
enum rf_path eRFPath,
u32 Offset,
u32 Data
)
{
u32 DataAndAddr = 0;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct bb_register_def *pPhyReg = &pHalData->PHYRegDef[eRFPath];
u32 NewOffset;
Offset &= 0xff;
/* */
/* Switch page for 8256 RF IC */
/* */
NewOffset = Offset;
/* */
/* Put write addr in [5:0] and write data in [31:16] */
/* */
DataAndAddr = ((NewOffset<<20) | (Data&0x000fffff)) & 0x0fffffff; /* T65 RF */
/* */
/* Write Operation */
/* */
PHY_SetBBReg(Adapter, pPhyReg->rf3wireOffset, bMaskDWord, DataAndAddr);
}
/**
* PHY_QueryRFReg_8723B - Query "Specific bits" to RF register (page 8~).
* @Adapter:
* @eRFPath: Radio path of A/B/C/D
* @RegAddr: The target address to be read
* @BitMask: The target bit position in the target address
* to be read
*
* Return: Readback value
*
* .. Note:: This function is equal to "GetRFRegSetting" in PHY
* programming guide
*/
u32 PHY_QueryRFReg_8723B(
struct adapter *Adapter,
u8 eRFPath,
u32 RegAddr,
u32 BitMask
)
{
u32 Original_Value, BitShift;
Original_Value = phy_RFSerialRead_8723B(Adapter, eRFPath, RegAddr);
BitShift = phy_CalculateBitShift(BitMask);
return (Original_Value & BitMask) >> BitShift;
}
/**
* PHY_SetRFReg_8723B - Write "Specific bits" to RF register (page 8~).
* @Adapter:
* @eRFPath: Radio path of A/B/C/D
* @RegAddr: The target address to be modified
* @BitMask: The target bit position in the target address
* to be modified
* @Data: The new register Data in the target bit position
* of the target address
*
* .. Note:: This function is equal to "PutRFRegSetting" in PHY
* programming guide.
*/
void PHY_SetRFReg_8723B(
struct adapter *Adapter,
u8 eRFPath,
u32 RegAddr,
u32 BitMask,
u32 Data
)
{
u32 Original_Value, BitShift;
/* RF data is 12 bits only */
if (BitMask != bRFRegOffsetMask) {
Original_Value = phy_RFSerialRead_8723B(Adapter, eRFPath, RegAddr);
BitShift = phy_CalculateBitShift(BitMask);
Data = ((Original_Value & (~BitMask)) | (Data<<BitShift));
}
phy_RFSerialWrite_8723B(Adapter, eRFPath, RegAddr, Data);
}
/* */
/* 3. Initial MAC/BB/RF config by reading MAC/BB/RF txt. */
/* */
/*-----------------------------------------------------------------------------
* PHY_MACConfig8192C - Condig MAC by header file or parameter file.
*
* Revised History:
* When Who Remark
* 08/12/2008 MHC Create Version 0.
*
*---------------------------------------------------------------------------
*/
s32 PHY_MACConfig8723B(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
ODM_ReadAndConfig_MP_8723B_MAC_REG(&pHalData->odmpriv);
return _SUCCESS;
}
/**
* phy_InitBBRFRegisterDefinition - Initialize Register definition offset for
* Radio Path A/B/C/D
* @Adapter:
*
* .. Note:: The initialization value is constant and it should never be changes
*/
static void phy_InitBBRFRegisterDefinition(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
/* RF Interface Sowrtware Control */
pHalData->PHYRegDef[RF_PATH_A].rfintfs = rFPGA0_XAB_RFInterfaceSW; /* 16 LSBs if read 32-bit from 0x870 */
pHalData->PHYRegDef[RF_PATH_B].rfintfs = rFPGA0_XAB_RFInterfaceSW; /* 16 MSBs if read 32-bit from 0x870 (16-bit for 0x872) */
/* RF Interface Output (and Enable) */
pHalData->PHYRegDef[RF_PATH_A].rfintfo = rFPGA0_XA_RFInterfaceOE; /* 16 LSBs if read 32-bit from 0x860 */
pHalData->PHYRegDef[RF_PATH_B].rfintfo = rFPGA0_XB_RFInterfaceOE; /* 16 LSBs if read 32-bit from 0x864 */
/* RF Interface (Output and) Enable */
pHalData->PHYRegDef[RF_PATH_A].rfintfe = rFPGA0_XA_RFInterfaceOE; /* 16 MSBs if read 32-bit from 0x860 (16-bit for 0x862) */
pHalData->PHYRegDef[RF_PATH_B].rfintfe = rFPGA0_XB_RFInterfaceOE; /* 16 MSBs if read 32-bit from 0x864 (16-bit for 0x866) */
pHalData->PHYRegDef[RF_PATH_A].rf3wireOffset = rFPGA0_XA_LSSIParameter; /* LSSI Parameter */
pHalData->PHYRegDef[RF_PATH_B].rf3wireOffset = rFPGA0_XB_LSSIParameter;
pHalData->PHYRegDef[RF_PATH_A].rfHSSIPara2 = rFPGA0_XA_HSSIParameter2; /* wire control parameter2 */
pHalData->PHYRegDef[RF_PATH_B].rfHSSIPara2 = rFPGA0_XB_HSSIParameter2; /* wire control parameter2 */
/* Tranceiver Readback LSSI/HSPI mode */
pHalData->PHYRegDef[RF_PATH_A].rfLSSIReadBack = rFPGA0_XA_LSSIReadBack;
pHalData->PHYRegDef[RF_PATH_B].rfLSSIReadBack = rFPGA0_XB_LSSIReadBack;
pHalData->PHYRegDef[RF_PATH_A].rfLSSIReadBackPi = TransceiverA_HSPI_Readback;
pHalData->PHYRegDef[RF_PATH_B].rfLSSIReadBackPi = TransceiverB_HSPI_Readback;
}
static int phy_BB8723b_Config_ParaFile(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
/* Read Tx Power Limit File */
PHY_InitTxPowerLimit(Adapter);
if (
Adapter->registrypriv.RegEnableTxPowerLimit == 1 ||
(Adapter->registrypriv.RegEnableTxPowerLimit == 2 && pHalData->EEPROMRegulatory == 1)
) {
ODM_ConfigRFWithHeaderFile(&pHalData->odmpriv,
CONFIG_RF_TXPWR_LMT, 0);
}
/* */
/* 1. Read PHY_REG.TXT BB INIT!! */
/* */
ODM_ConfigBBWithHeaderFile(&pHalData->odmpriv, CONFIG_BB_PHY_REG);
/* If EEPROM or EFUSE autoload OK, We must config by PHY_REG_PG.txt */
PHY_InitTxPowerByRate(Adapter);
if (
Adapter->registrypriv.RegEnableTxPowerByRate == 1 ||
(Adapter->registrypriv.RegEnableTxPowerByRate == 2 && pHalData->EEPROMRegulatory != 2)
) {
ODM_ConfigBBWithHeaderFile(&pHalData->odmpriv,
CONFIG_BB_PHY_REG_PG);
if (pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE)
PHY_TxPowerByRateConfiguration(Adapter);
if (
Adapter->registrypriv.RegEnableTxPowerLimit == 1 ||
(Adapter->registrypriv.RegEnableTxPowerLimit == 2 && pHalData->EEPROMRegulatory == 1)
)
PHY_ConvertTxPowerLimitToPowerIndex(Adapter);
}
/* */
/* 2. Read BB AGC table Initialization */
/* */
ODM_ConfigBBWithHeaderFile(&pHalData->odmpriv, CONFIG_BB_AGC_TAB);
return _SUCCESS;
}
int PHY_BBConfig8723B(struct adapter *Adapter)
{
int rtStatus = _SUCCESS;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
u32 RegVal;
u8 CrystalCap;
phy_InitBBRFRegisterDefinition(Adapter);
/* Enable BB and RF */
RegVal = rtw_read16(Adapter, REG_SYS_FUNC_EN);
rtw_write16(Adapter, REG_SYS_FUNC_EN, (u16)(RegVal|BIT13|BIT0|BIT1));
rtw_write32(Adapter, 0x948, 0x280); /* Others use Antenna S1 */
rtw_write8(Adapter, REG_RF_CTRL, RF_EN|RF_RSTB|RF_SDMRSTB);
msleep(1);
PHY_SetRFReg(Adapter, RF_PATH_A, 0x1, 0xfffff, 0x780);
rtw_write8(Adapter, REG_SYS_FUNC_EN, FEN_PPLL|FEN_PCIEA|FEN_DIO_PCIE|FEN_BB_GLB_RSTn|FEN_BBRSTB);
rtw_write8(Adapter, REG_AFE_XTAL_CTRL+1, 0x80);
/* */
/* Config BB and AGC */
/* */
rtStatus = phy_BB8723b_Config_ParaFile(Adapter);
/* 0x2C[23:18] = 0x2C[17:12] = CrystalCap */
CrystalCap = pHalData->CrystalCap & 0x3F;
PHY_SetBBReg(Adapter, REG_MAC_PHY_CTRL, 0xFFF000, (CrystalCap | (CrystalCap << 6)));
return rtStatus;
}
static void phy_LCK_8723B(struct adapter *Adapter)
{
PHY_SetRFReg(Adapter, RF_PATH_A, 0xB0, bRFRegOffsetMask, 0xDFBE0);
PHY_SetRFReg(Adapter, RF_PATH_A, RF_CHNLBW, bRFRegOffsetMask, 0x8C01);
mdelay(200);
PHY_SetRFReg(Adapter, RF_PATH_A, 0xB0, bRFRegOffsetMask, 0xDFFE0);
}
int PHY_RFConfig8723B(struct adapter *Adapter)
{
int rtStatus = _SUCCESS;
/* */
/* RF config */
/* */
rtStatus = PHY_RF6052_Config8723B(Adapter);
phy_LCK_8723B(Adapter);
return rtStatus;
}
/**************************************************************************************************************
* Description:
* The low-level interface to set TxAGC , called by both MP and Normal Driver.
*
* <20120830, Kordan>
**************************************************************************************************************/
void PHY_SetTxPowerIndex(
struct adapter *Adapter,
u32 PowerIndex,
u8 RFPath,
u8 Rate
)
{
if (RFPath == RF_PATH_A || RFPath == RF_PATH_B) {
switch (Rate) {
case MGN_1M:
PHY_SetBBReg(Adapter, rTxAGC_A_CCK1_Mcs32, bMaskByte1, PowerIndex);
break;
case MGN_2M:
PHY_SetBBReg(Adapter, rTxAGC_B_CCK11_A_CCK2_11, bMaskByte1, PowerIndex);
break;
case MGN_5_5M:
PHY_SetBBReg(Adapter, rTxAGC_B_CCK11_A_CCK2_11, bMaskByte2, PowerIndex);
break;
case MGN_11M:
PHY_SetBBReg(Adapter, rTxAGC_B_CCK11_A_CCK2_11, bMaskByte3, PowerIndex);
break;
case MGN_6M:
PHY_SetBBReg(Adapter, rTxAGC_A_Rate18_06, bMaskByte0, PowerIndex);
break;
case MGN_9M:
PHY_SetBBReg(Adapter, rTxAGC_A_Rate18_06, bMaskByte1, PowerIndex);
break;
case MGN_12M:
PHY_SetBBReg(Adapter, rTxAGC_A_Rate18_06, bMaskByte2, PowerIndex);
break;
case MGN_18M:
PHY_SetBBReg(Adapter, rTxAGC_A_Rate18_06, bMaskByte3, PowerIndex);
break;
case MGN_24M:
PHY_SetBBReg(Adapter, rTxAGC_A_Rate54_24, bMaskByte0, PowerIndex);
break;
case MGN_36M:
PHY_SetBBReg(Adapter, rTxAGC_A_Rate54_24, bMaskByte1, PowerIndex);
break;
case MGN_48M:
PHY_SetBBReg(Adapter, rTxAGC_A_Rate54_24, bMaskByte2, PowerIndex);
break;
case MGN_54M:
PHY_SetBBReg(Adapter, rTxAGC_A_Rate54_24, bMaskByte3, PowerIndex);
break;
case MGN_MCS0:
PHY_SetBBReg(Adapter, rTxAGC_A_Mcs03_Mcs00, bMaskByte0, PowerIndex);
break;
case MGN_MCS1:
PHY_SetBBReg(Adapter, rTxAGC_A_Mcs03_Mcs00, bMaskByte1, PowerIndex);
break;
case MGN_MCS2:
PHY_SetBBReg(Adapter, rTxAGC_A_Mcs03_Mcs00, bMaskByte2, PowerIndex);
break;
case MGN_MCS3:
PHY_SetBBReg(Adapter, rTxAGC_A_Mcs03_Mcs00, bMaskByte3, PowerIndex);
break;
case MGN_MCS4:
PHY_SetBBReg(Adapter, rTxAGC_A_Mcs07_Mcs04, bMaskByte0, PowerIndex);
break;
case MGN_MCS5:
PHY_SetBBReg(Adapter, rTxAGC_A_Mcs07_Mcs04, bMaskByte1, PowerIndex);
break;
case MGN_MCS6:
PHY_SetBBReg(Adapter, rTxAGC_A_Mcs07_Mcs04, bMaskByte2, PowerIndex);
break;
case MGN_MCS7:
PHY_SetBBReg(Adapter, rTxAGC_A_Mcs07_Mcs04, bMaskByte3, PowerIndex);
break;
default:
break;
}
}
}
u8 PHY_GetTxPowerIndex(
struct adapter *padapter,
u8 RFPath,
u8 Rate,
enum channel_width BandWidth,
u8 Channel
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
s8 txPower = 0, powerDiffByRate = 0, limit = 0;
txPower = (s8) PHY_GetTxPowerIndexBase(padapter, RFPath, Rate, BandWidth, Channel);
powerDiffByRate = PHY_GetTxPowerByRate(padapter, RF_PATH_A, Rate);
limit = phy_get_tx_pwr_lmt(
padapter,
padapter->registrypriv.RegPwrTblSel,
pHalData->CurrentChannelBW,
RFPath,
Rate,
pHalData->CurrentChannel
);
powerDiffByRate = powerDiffByRate > limit ? limit : powerDiffByRate;
txPower += powerDiffByRate;
txPower += PHY_GetTxPowerTrackingOffset(padapter, RFPath, Rate);
if (txPower > MAX_POWER_INDEX)
txPower = MAX_POWER_INDEX;
return (u8) txPower;
}
void PHY_SetTxPowerLevel8723B(struct adapter *Adapter, u8 Channel)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
struct fat_t *pDM_FatTable = &pDM_Odm->DM_FatTable;
u8 RFPath = RF_PATH_A;
if (pHalData->AntDivCfg) {/* antenna diversity Enable */
RFPath = ((pDM_FatTable->RxIdleAnt == MAIN_ANT) ? RF_PATH_A : RF_PATH_B);
} else { /* antenna diversity disable */
RFPath = pHalData->ant_path;
}
PHY_SetTxPowerLevelByPath(Adapter, Channel, RFPath);
}
void PHY_GetTxPowerLevel8723B(struct adapter *Adapter, s32 *powerlevel)
{
}
static void phy_SetRegBW_8723B(
struct adapter *Adapter, enum channel_width CurrentBW
)
{
u16 RegRfMod_BW, u2tmp = 0;
RegRfMod_BW = rtw_read16(Adapter, REG_TRXPTCL_CTL_8723B);
switch (CurrentBW) {
case CHANNEL_WIDTH_20:
rtw_write16(Adapter, REG_TRXPTCL_CTL_8723B, (RegRfMod_BW & 0xFE7F)); /* BIT 7 = 0, BIT 8 = 0 */
break;
case CHANNEL_WIDTH_40:
u2tmp = RegRfMod_BW | BIT7;
rtw_write16(Adapter, REG_TRXPTCL_CTL_8723B, (u2tmp & 0xFEFF)); /* BIT 7 = 1, BIT 8 = 0 */
break;
default:
break;
}
}
static u8 phy_GetSecondaryChnl_8723B(struct adapter *Adapter)
{
u8 SCSettingOf40 = 0, SCSettingOf20 = 0;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
if (pHalData->CurrentChannelBW == CHANNEL_WIDTH_40) {
if (pHalData->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_UPPER)
SCSettingOf20 = HT_DATA_SC_20_UPPER_OF_40MHZ;
else if (pHalData->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_LOWER)
SCSettingOf20 = HT_DATA_SC_20_LOWER_OF_40MHZ;
}
return (SCSettingOf40 << 4) | SCSettingOf20;
}
static void phy_PostSetBwMode8723B(struct adapter *Adapter)
{
u8 SubChnlNum = 0;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
/* 3 Set Reg668 Reg440 BW */
phy_SetRegBW_8723B(Adapter, pHalData->CurrentChannelBW);
/* 3 Set Reg483 */
SubChnlNum = phy_GetSecondaryChnl_8723B(Adapter);
rtw_write8(Adapter, REG_DATA_SC_8723B, SubChnlNum);
/* 3 */
/* 3<2>Set PHY related register */
/* 3 */
switch (pHalData->CurrentChannelBW) {
/* 20 MHz channel*/
case CHANNEL_WIDTH_20:
PHY_SetBBReg(Adapter, rFPGA0_RFMOD, bRFMOD, 0x0);
PHY_SetBBReg(Adapter, rFPGA1_RFMOD, bRFMOD, 0x0);
PHY_SetBBReg(Adapter, rOFDM0_TxPseudoNoiseWgt, (BIT31|BIT30), 0x0);
break;
/* 40 MHz channel*/
case CHANNEL_WIDTH_40:
PHY_SetBBReg(Adapter, rFPGA0_RFMOD, bRFMOD, 0x1);
PHY_SetBBReg(Adapter, rFPGA1_RFMOD, bRFMOD, 0x1);
/* Set Control channel to upper or lower. These settings are required only for 40MHz */
PHY_SetBBReg(Adapter, rCCK0_System, bCCKSideBand, (pHalData->nCur40MhzPrimeSC>>1));
PHY_SetBBReg(Adapter, rOFDM1_LSTF, 0xC00, pHalData->nCur40MhzPrimeSC);
PHY_SetBBReg(Adapter, 0x818, (BIT26|BIT27), (pHalData->nCur40MhzPrimeSC == HAL_PRIME_CHNL_OFFSET_LOWER) ? 2 : 1);
break;
default:
break;
}
/* 3<3>Set RF related register */
PHY_RF6052SetBandwidth8723B(Adapter, pHalData->CurrentChannelBW);
}
static void phy_SwChnl8723B(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 channelToSW = pHalData->CurrentChannel;
if (pHalData->rf_chip == RF_PSEUDO_11N)
return;
pHalData->RfRegChnlVal[0] = ((pHalData->RfRegChnlVal[0] & 0xfffff00) | channelToSW);
PHY_SetRFReg(padapter, RF_PATH_A, RF_CHNLBW, 0x3FF, pHalData->RfRegChnlVal[0]);
PHY_SetRFReg(padapter, RF_PATH_B, RF_CHNLBW, 0x3FF, pHalData->RfRegChnlVal[0]);
}
static void phy_SwChnlAndSetBwMode8723B(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
if (Adapter->bDriverStopped || Adapter->bSurpriseRemoved)
return;
if (pHalData->bSwChnl) {
phy_SwChnl8723B(Adapter);
pHalData->bSwChnl = false;
}
if (pHalData->bSetChnlBW) {
phy_PostSetBwMode8723B(Adapter);
pHalData->bSetChnlBW = false;
}
PHY_SetTxPowerLevel8723B(Adapter, pHalData->CurrentChannel);
}
static void PHY_HandleSwChnlAndSetBW8723B(
struct adapter *Adapter,
bool bSwitchChannel,
bool bSetBandWidth,
u8 ChannelNum,
enum channel_width ChnlWidth,
enum extchnl_offset ExtChnlOffsetOf40MHz,
enum extchnl_offset ExtChnlOffsetOf80MHz,
u8 CenterFrequencyIndex1
)
{
/* static bool bInitialzed = false; */
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
u8 tmpChannel = pHalData->CurrentChannel;
enum channel_width tmpBW = pHalData->CurrentChannelBW;
u8 tmpnCur40MhzPrimeSC = pHalData->nCur40MhzPrimeSC;
u8 tmpnCur80MhzPrimeSC = pHalData->nCur80MhzPrimeSC;
u8 tmpCenterFrequencyIndex1 = pHalData->CurrentCenterFrequencyIndex1;
/* check is swchnl or setbw */
if (!bSwitchChannel && !bSetBandWidth)
return;
/* skip change for channel or bandwidth is the same */
if (bSwitchChannel) {
{
if (HAL_IsLegalChannel(Adapter, ChannelNum))
pHalData->bSwChnl = true;
}
}
if (bSetBandWidth)
pHalData->bSetChnlBW = true;
if (!pHalData->bSetChnlBW && !pHalData->bSwChnl)
return;
if (pHalData->bSwChnl) {
pHalData->CurrentChannel = ChannelNum;
pHalData->CurrentCenterFrequencyIndex1 = ChannelNum;
}
if (pHalData->bSetChnlBW) {
pHalData->CurrentChannelBW = ChnlWidth;
pHalData->nCur40MhzPrimeSC = ExtChnlOffsetOf40MHz;
pHalData->nCur80MhzPrimeSC = ExtChnlOffsetOf80MHz;
pHalData->CurrentCenterFrequencyIndex1 = CenterFrequencyIndex1;
}
/* Switch workitem or set timer to do switch channel or setbandwidth operation */
if ((!Adapter->bDriverStopped) && (!Adapter->bSurpriseRemoved)) {
phy_SwChnlAndSetBwMode8723B(Adapter);
} else {
if (pHalData->bSwChnl) {
pHalData->CurrentChannel = tmpChannel;
pHalData->CurrentCenterFrequencyIndex1 = tmpChannel;
}
if (pHalData->bSetChnlBW) {
pHalData->CurrentChannelBW = tmpBW;
pHalData->nCur40MhzPrimeSC = tmpnCur40MhzPrimeSC;
pHalData->nCur80MhzPrimeSC = tmpnCur80MhzPrimeSC;
pHalData->CurrentCenterFrequencyIndex1 = tmpCenterFrequencyIndex1;
}
}
}
void PHY_SetBWMode8723B(
struct adapter *Adapter,
enum channel_width Bandwidth, /* 20M or 40M */
unsigned char Offset /* Upper, Lower, or Don't care */
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
PHY_HandleSwChnlAndSetBW8723B(Adapter, false, true, pHalData->CurrentChannel, Bandwidth, Offset, Offset, pHalData->CurrentChannel);
}
/* Call after initialization */
void PHY_SwChnl8723B(struct adapter *Adapter, u8 channel)
{
PHY_HandleSwChnlAndSetBW8723B(Adapter, true, false, channel, 0, 0, 0, channel);
}
void PHY_SetSwChnlBWMode8723B(
struct adapter *Adapter,
u8 channel,
enum channel_width Bandwidth,
u8 Offset40,
u8 Offset80
)
{
PHY_HandleSwChnlAndSetBW8723B(Adapter, true, true, channel, Bandwidth, Offset40, Offset80, channel);
}
| linux-master | drivers/staging/rtl8723bs/hal/rtl8723b_phycfg.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include "odm_precomp.h"
#define READ_AND_CONFIG_MP(ic, txt) (ODM_ReadAndConfig_MP_##ic##txt(pDM_Odm))
#define READ_AND_CONFIG READ_AND_CONFIG_MP
static u8 odm_query_rx_pwr_percentage(s8 ant_power)
{
if ((ant_power <= -100) || (ant_power >= 20))
return 0;
else if (ant_power >= 0)
return 100;
else
return 100 + ant_power;
}
s32 odm_signal_scale_mapping(struct dm_odm_t *dm_odm, s32 curr_sig)
{
s32 ret_sig = 0;
if (dm_odm->SupportInterface == ODM_ITRF_SDIO) {
if (curr_sig >= 51 && curr_sig <= 100)
ret_sig = 100;
else if (curr_sig >= 41 && curr_sig <= 50)
ret_sig = 80 + ((curr_sig - 40)*2);
else if (curr_sig >= 31 && curr_sig <= 40)
ret_sig = 66 + (curr_sig - 30);
else if (curr_sig >= 21 && curr_sig <= 30)
ret_sig = 54 + (curr_sig - 20);
else if (curr_sig >= 10 && curr_sig <= 20)
ret_sig = 42 + (((curr_sig - 10) * 2) / 3);
else if (curr_sig >= 5 && curr_sig <= 9)
ret_sig = 22 + (((curr_sig - 5) * 3) / 2);
else if (curr_sig >= 1 && curr_sig <= 4)
ret_sig = 6 + (((curr_sig - 1) * 3) / 2);
else
ret_sig = curr_sig;
}
return ret_sig;
}
static u8 odm_evm_db_to_percentage(s8 value)
{
/* */
/* -33dB~0dB to 0%~99% */
/* */
s8 ret_val;
ret_val = value;
ret_val /= 2;
if (ret_val >= 0)
ret_val = 0;
if (ret_val <= -33)
ret_val = -33;
ret_val = 0 - ret_val;
ret_val *= 3;
if (ret_val == 99)
ret_val = 100;
return ret_val;
}
static s8 odm_cck_rssi(u8 lna_idx, u8 vga_idx)
{
s8 rx_pwr_all = 0x00;
switch (lna_idx) {
/* 46 53 73 95 201301231630 */
/* 46 53 77 99 201301241630 */
case 6:
rx_pwr_all = -34 - (2 * vga_idx);
break;
case 4:
rx_pwr_all = -14 - (2 * vga_idx);
break;
case 1:
rx_pwr_all = 6 - (2 * vga_idx);
break;
case 0:
rx_pwr_all = 16 - (2 * vga_idx);
break;
default:
/* rx_pwr_all = -53+(2*(31-VGA_idx)); */
break;
}
return rx_pwr_all;
}
static void odm_rx_phy_status_parsing(struct dm_odm_t *dm_odm,
struct odm_phy_info *phy_info,
u8 *phy_status,
struct odm_packet_info *pkt_info)
{
u8 i;
s8 rx_pwr[4], rx_pwr_all = 0;
u8 evm, pwdb_all = 0, pwdb_all_bt;
u8 rssi, total_rssi = 0;
bool is_cck_rate = false;
u8 rf_rx_num = 0;
u8 lna_idx, vga_idx;
struct phy_status_rpt_8192cd_t *phy_sta_rpt = (struct phy_status_rpt_8192cd_t *)phy_status;
is_cck_rate = pkt_info->data_rate <= DESC_RATE11M;
phy_info->rx_mimo_signal_quality[RF_PATH_A] = -1;
phy_info->rx_mimo_signal_quality[RF_PATH_B] = -1;
if (is_cck_rate) {
u8 cck_agc_rpt;
dm_odm->PhyDbgInfo.NumQryPhyStatusCCK++;
/*
* (1)Hardware does not provide RSSI for CCK/
* (2)PWDB, Average PWDB calculated by
* hardware (for rate adaptive)
*/
cck_agc_rpt = phy_sta_rpt->cck_agc_rpt_ofdm_cfosho_a;
/*
* 2011.11.28 LukeLee: 88E use different LNA & VGA gain table
* The RSSI formula should be modified according to the gain table
*/
lna_idx = ((cck_agc_rpt & 0xE0)>>5);
vga_idx = (cck_agc_rpt & 0x1F);
rx_pwr_all = odm_cck_rssi(lna_idx, vga_idx);
pwdb_all = odm_query_rx_pwr_percentage(rx_pwr_all);
if (pwdb_all > 100)
pwdb_all = 100;
phy_info->rx_pwd_ba11 = pwdb_all;
phy_info->bt_rx_rssi_percentage = pwdb_all;
phy_info->recv_signal_power = rx_pwr_all;
/* (3) Get Signal Quality (EVM) */
/* if (pPktinfo->bPacketMatchBSSID) */
{
u8 sq, sq_rpt;
if (phy_info->rx_pwd_ba11 > 40 && !dm_odm->bInHctTest)
sq = 100;
else {
sq_rpt = phy_sta_rpt->cck_sig_qual_ofdm_pwdb_all;
if (sq_rpt > 64)
sq = 0;
else if (sq_rpt < 20)
sq = 100;
else
sq = ((64-sq_rpt) * 100) / 44;
}
phy_info->signal_quality = sq;
phy_info->rx_mimo_signal_quality[RF_PATH_A] = sq;
phy_info->rx_mimo_signal_quality[RF_PATH_B] = -1;
}
} else { /* is OFDM rate */
dm_odm->PhyDbgInfo.NumQryPhyStatusOFDM++;
/*
* (1)Get RSSI for HT rate
*/
for (i = RF_PATH_A; i < RF_PATH_MAX; i++) {
/* 2008/01/30 MH we will judge RF RX path now. */
if (dm_odm->RFPathRxEnable & BIT(i))
rf_rx_num++;
/* else */
/* continue; */
rx_pwr[i] = ((phy_sta_rpt->path_agc[i].gain & 0x3F) * 2) - 110;
phy_info->rx_pwr[i] = rx_pwr[i];
/* Translate DBM to percentage. */
rssi = odm_query_rx_pwr_percentage(rx_pwr[i]);
total_rssi += rssi;
phy_info->rx_mimo_signal_strength[i] = (u8)rssi;
/* Get Rx snr value in DB */
phy_info->rx_snr[i] = dm_odm->PhyDbgInfo.RxSNRdB[i] = (s32)(phy_sta_rpt->path_rxsnr[i]/2);
}
/*
* (2)PWDB, Average PWDB calculated by hardware (for rate adaptive)
*/
rx_pwr_all = ((phy_sta_rpt->cck_sig_qual_ofdm_pwdb_all >> 1) & 0x7f) - 110;
pwdb_all_bt = pwdb_all = odm_query_rx_pwr_percentage(rx_pwr_all);
phy_info->rx_pwd_ba11 = pwdb_all;
phy_info->bt_rx_rssi_percentage = pwdb_all_bt;
phy_info->rx_power = rx_pwr_all;
phy_info->recv_signal_power = rx_pwr_all;
/*
* (3)EVM of HT rate
*
* Only spatial stream 1 makes sense
*
* Do not use shift operation like "rx_evmX >>= 1"
* because the compiler of free build environment
* fill most significant bit to "zero" when doing
* shifting operation which may change a negative
* value to positive one, then the dbm value (which
* is supposed to be negative) is not correct
* anymore.
*/
evm = odm_evm_db_to_percentage(phy_sta_rpt->stream_rxevm[0]); /* dbm */
/* Fill value in RFD, Get the first spatial stream only */
phy_info->signal_quality = (u8)(evm & 0xff);
phy_info->rx_mimo_signal_quality[RF_PATH_A] = (u8)(evm & 0xff);
odm_parsing_cfo(dm_odm, pkt_info, phy_sta_rpt->path_cfotail);
}
/*
* UI BSS List signal strength(in percentage), make it good
* looking, from 0~100.
* It is assigned to the BSS List in GetValueFromBeaconOrProbeRsp().
*/
if (is_cck_rate) {
phy_info->signal_strength = (u8)(odm_signal_scale_mapping(dm_odm, pwdb_all));
} else {
if (rf_rx_num != 0) {
phy_info->signal_strength = (u8)(odm_signal_scale_mapping(dm_odm, total_rssi /= rf_rx_num));
}
}
}
static void odm_Process_RSSIForDM(
struct dm_odm_t *pDM_Odm, struct odm_phy_info *pPhyInfo, struct odm_packet_info *pPktinfo
)
{
s32 UndecoratedSmoothedPWDB, UndecoratedSmoothedCCK, UndecoratedSmoothedOFDM, RSSI_Ave;
u8 isCCKrate = 0;
u8 RSSI_max, RSSI_min, i;
u32 OFDM_pkt = 0;
u32 Weighting = 0;
PSTA_INFO_T pEntry;
if (pPktinfo->station_id == 0xFF)
return;
pEntry = pDM_Odm->pODM_StaInfo[pPktinfo->station_id];
if (!IS_STA_VALID(pEntry))
return;
if ((!pPktinfo->bssid_match))
return;
if (pPktinfo->is_beacon)
pDM_Odm->PhyDbgInfo.NumQryBeaconPkt++;
isCCKrate = ((pPktinfo->data_rate <= DESC_RATE11M)) ? true : false;
pDM_Odm->RxRate = pPktinfo->data_rate;
/* Statistic for antenna/path diversity------------------ */
if (pDM_Odm->SupportAbility & ODM_BB_ANT_DIV) {
}
/* Smart Antenna Debug Message------------------ */
UndecoratedSmoothedCCK = pEntry->rssi_stat.UndecoratedSmoothedCCK;
UndecoratedSmoothedOFDM = pEntry->rssi_stat.UndecoratedSmoothedOFDM;
UndecoratedSmoothedPWDB = pEntry->rssi_stat.UndecoratedSmoothedPWDB;
if (pPktinfo->to_self || pPktinfo->is_beacon) {
if (!isCCKrate) { /* ofdm rate */
if (pPhyInfo->rx_mimo_signal_strength[RF_PATH_B] == 0) {
RSSI_Ave = pPhyInfo->rx_mimo_signal_strength[RF_PATH_A];
pDM_Odm->RSSI_A = pPhyInfo->rx_mimo_signal_strength[RF_PATH_A];
pDM_Odm->RSSI_B = 0;
} else {
pDM_Odm->RSSI_A = pPhyInfo->rx_mimo_signal_strength[RF_PATH_A];
pDM_Odm->RSSI_B = pPhyInfo->rx_mimo_signal_strength[RF_PATH_B];
if (
pPhyInfo->rx_mimo_signal_strength[RF_PATH_A] >
pPhyInfo->rx_mimo_signal_strength[RF_PATH_B]
) {
RSSI_max = pPhyInfo->rx_mimo_signal_strength[RF_PATH_A];
RSSI_min = pPhyInfo->rx_mimo_signal_strength[RF_PATH_B];
} else {
RSSI_max = pPhyInfo->rx_mimo_signal_strength[RF_PATH_B];
RSSI_min = pPhyInfo->rx_mimo_signal_strength[RF_PATH_A];
}
if ((RSSI_max-RSSI_min) < 3)
RSSI_Ave = RSSI_max;
else if ((RSSI_max-RSSI_min) < 6)
RSSI_Ave = RSSI_max - 1;
else if ((RSSI_max-RSSI_min) < 10)
RSSI_Ave = RSSI_max - 2;
else
RSSI_Ave = RSSI_max - 3;
}
/* 1 Process OFDM RSSI */
if (UndecoratedSmoothedOFDM <= 0) /* initialize */
UndecoratedSmoothedOFDM = pPhyInfo->rx_pwd_ba11;
else {
if (pPhyInfo->rx_pwd_ba11 > (u32)UndecoratedSmoothedOFDM) {
UndecoratedSmoothedOFDM =
((UndecoratedSmoothedOFDM*(Rx_Smooth_Factor-1)) +
RSSI_Ave)/Rx_Smooth_Factor;
UndecoratedSmoothedOFDM = UndecoratedSmoothedOFDM + 1;
} else {
UndecoratedSmoothedOFDM =
((UndecoratedSmoothedOFDM*(Rx_Smooth_Factor-1)) +
RSSI_Ave)/Rx_Smooth_Factor;
}
}
pEntry->rssi_stat.PacketMap = (pEntry->rssi_stat.PacketMap<<1) | BIT0;
} else {
RSSI_Ave = pPhyInfo->rx_pwd_ba11;
pDM_Odm->RSSI_A = (u8) pPhyInfo->rx_pwd_ba11;
pDM_Odm->RSSI_B = 0;
/* 1 Process CCK RSSI */
if (UndecoratedSmoothedCCK <= 0) /* initialize */
UndecoratedSmoothedCCK = pPhyInfo->rx_pwd_ba11;
else {
if (pPhyInfo->rx_pwd_ba11 > (u32)UndecoratedSmoothedCCK) {
UndecoratedSmoothedCCK =
((UndecoratedSmoothedCCK*(Rx_Smooth_Factor-1)) +
pPhyInfo->rx_pwd_ba11)/Rx_Smooth_Factor;
UndecoratedSmoothedCCK = UndecoratedSmoothedCCK + 1;
} else {
UndecoratedSmoothedCCK =
((UndecoratedSmoothedCCK*(Rx_Smooth_Factor-1)) +
pPhyInfo->rx_pwd_ba11)/Rx_Smooth_Factor;
}
}
pEntry->rssi_stat.PacketMap = pEntry->rssi_stat.PacketMap<<1;
}
/* if (pEntry) */
{
/* 2011.07.28 LukeLee: modified to prevent unstable CCK RSSI */
if (pEntry->rssi_stat.ValidBit >= 64)
pEntry->rssi_stat.ValidBit = 64;
else
pEntry->rssi_stat.ValidBit++;
for (i = 0; i < pEntry->rssi_stat.ValidBit; i++)
OFDM_pkt += (u8)(pEntry->rssi_stat.PacketMap>>i)&BIT0;
if (pEntry->rssi_stat.ValidBit == 64) {
Weighting = ((OFDM_pkt<<4) > 64)?64:(OFDM_pkt<<4);
UndecoratedSmoothedPWDB = (Weighting*UndecoratedSmoothedOFDM+(64-Weighting)*UndecoratedSmoothedCCK)>>6;
} else {
if (pEntry->rssi_stat.ValidBit != 0)
UndecoratedSmoothedPWDB = (OFDM_pkt*UndecoratedSmoothedOFDM+(pEntry->rssi_stat.ValidBit-OFDM_pkt)*UndecoratedSmoothedCCK)/pEntry->rssi_stat.ValidBit;
else
UndecoratedSmoothedPWDB = 0;
}
pEntry->rssi_stat.UndecoratedSmoothedCCK = UndecoratedSmoothedCCK;
pEntry->rssi_stat.UndecoratedSmoothedOFDM = UndecoratedSmoothedOFDM;
pEntry->rssi_stat.UndecoratedSmoothedPWDB = UndecoratedSmoothedPWDB;
}
}
}
/* */
/* Endianness before calling this API */
/* */
void odm_phy_status_query(struct dm_odm_t *dm_odm, struct odm_phy_info *phy_info,
u8 *phy_status, struct odm_packet_info *pkt_info)
{
odm_rx_phy_status_parsing(dm_odm, phy_info, phy_status, pkt_info);
if (!dm_odm->RSSI_test)
odm_Process_RSSIForDM(dm_odm, phy_info, pkt_info);
}
/* */
/* If you want to add a new IC, Please follow below template and generate a new one. */
/* */
/* */
enum hal_status ODM_ConfigRFWithHeaderFile(
struct dm_odm_t *pDM_Odm,
enum ODM_RF_Config_Type ConfigType,
enum rf_path eRFPath
)
{
if (ConfigType == CONFIG_RF_RADIO)
READ_AND_CONFIG(8723B, _RadioA);
else if (ConfigType == CONFIG_RF_TXPWR_LMT)
READ_AND_CONFIG(8723B, _TXPWR_LMT);
return HAL_STATUS_SUCCESS;
}
enum hal_status ODM_ConfigRFWithTxPwrTrackHeaderFile(struct dm_odm_t *pDM_Odm)
{
if (pDM_Odm->SupportInterface == ODM_ITRF_SDIO)
READ_AND_CONFIG(8723B, _TxPowerTrack_SDIO);
return HAL_STATUS_SUCCESS;
}
enum hal_status ODM_ConfigBBWithHeaderFile(
struct dm_odm_t *pDM_Odm, enum ODM_BB_Config_Type ConfigType
)
{
if (ConfigType == CONFIG_BB_PHY_REG)
READ_AND_CONFIG(8723B, _PHY_REG);
else if (ConfigType == CONFIG_BB_AGC_TAB)
READ_AND_CONFIG(8723B, _AGC_TAB);
else if (ConfigType == CONFIG_BB_PHY_REG_PG)
READ_AND_CONFIG(8723B, _PHY_REG_PG);
return HAL_STATUS_SUCCESS;
}
| linux-master | drivers/staging/rtl8723bs/hal/odm_HWConfig.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <linux/kernel.h>
#include "odm_precomp.h"
static bool CheckPositive(
struct dm_odm_t *pDM_Odm, const u32 Condition1, const u32 Condition2
)
{
u8 _BoardType =
((pDM_Odm->BoardType & BIT4) >> 4) << 0 | /* _GLNA */
((pDM_Odm->BoardType & BIT3) >> 3) << 1 | /* _GPA */
((pDM_Odm->BoardType & BIT7) >> 7) << 2 | /* _ALNA */
((pDM_Odm->BoardType & BIT6) >> 6) << 3 | /* _APA */
((pDM_Odm->BoardType & BIT2) >> 2) << 4; /* _BT */
u32 cond1 = Condition1, cond2 = Condition2;
u32 driver1 =
pDM_Odm->CutVersion << 24 |
pDM_Odm->SupportPlatform << 16 |
pDM_Odm->PackageType << 12 |
pDM_Odm->SupportInterface << 8 |
_BoardType;
u32 driver2 =
pDM_Odm->TypeGLNA << 0 |
pDM_Odm->TypeGPA << 8 |
pDM_Odm->TypeALNA << 16 |
pDM_Odm->TypeAPA << 24;
/* Value Defined Check =============== */
/* QFN Type [15:12] and Cut Version [27:24] need to do value check */
if (
((cond1 & 0x0000F000) != 0) &&
((cond1 & 0x0000F000) != (driver1 & 0x0000F000))
)
return false;
if (
((cond1 & 0x0F000000) != 0) &&
((cond1 & 0x0F000000) != (driver1 & 0x0F000000))
)
return false;
/* Bit Defined Check ================ */
/* We don't care [31:28] and [23:20] */
cond1 &= 0x000F0FFF;
driver1 &= 0x000F0FFF;
if ((cond1 & driver1) == cond1) {
u32 bitMask = 0;
if ((cond1 & 0x0F) == 0) /* BoardType is DONTCARE */
return true;
if ((cond1 & BIT0) != 0) /* GLNA */
bitMask |= 0x000000FF;
if ((cond1 & BIT1) != 0) /* GPA */
bitMask |= 0x0000FF00;
if ((cond1 & BIT2) != 0) /* ALNA */
bitMask |= 0x00FF0000;
if ((cond1 & BIT3) != 0) /* APA */
bitMask |= 0xFF000000;
/* BoardType of each RF path is matched */
if ((cond2 & bitMask) == (driver2 & bitMask))
return true;
return false;
}
return false;
}
static bool CheckNegative(
struct dm_odm_t *pDM_Odm, const u32 Condition1, const u32 Condition2
)
{
return true;
}
/******************************************************************************
* RadioA.TXT
******************************************************************************/
static u32 Array_MP_8723B_RadioA[] = {
0x000, 0x00010000,
0x0B0, 0x000DFFE0,
0x0FE, 0x00000000,
0x0FE, 0x00000000,
0x0FE, 0x00000000,
0x0B1, 0x00000018,
0x0FE, 0x00000000,
0x0FE, 0x00000000,
0x0FE, 0x00000000,
0x0B2, 0x00084C00,
0x0B5, 0x0000D2CC,
0x0B6, 0x000925AA,
0x0B7, 0x00000010,
0x0B8, 0x0000907F,
0x05C, 0x00000002,
0x07C, 0x00000002,
0x07E, 0x00000005,
0x08B, 0x0006FC00,
0x0B0, 0x000FF9F0,
0x01C, 0x000739D2,
0x01E, 0x00000000,
0x0DF, 0x00000780,
0x050, 0x00067435,
0x80002000, 0x00000000, 0x40000000, 0x00000000,
0x051, 0x0006B10E,
0x90003000, 0x00000000, 0x40000000, 0x00000000,
0x051, 0x0006B10E,
0x90004000, 0x00000000, 0x40000000, 0x00000000,
0x051, 0x0006B10E,
0xA0000000, 0x00000000,
0x051, 0x0006B04E,
0xB0000000, 0x00000000,
0x052, 0x000007D2,
0x053, 0x00000000,
0x054, 0x00050400,
0x055, 0x0004026E,
0x0DD, 0x0000004C,
0x070, 0x00067435,
0x80002000, 0x00000000, 0x40000000, 0x00000000,
0x071, 0x0006B10E,
0x90003000, 0x00000000, 0x40000000, 0x00000000,
0x071, 0x0006B10E,
0x90004000, 0x00000000, 0x40000000, 0x00000000,
0x071, 0x0006B10E,
0xA0000000, 0x00000000,
0x071, 0x0006B04E,
0xB0000000, 0x00000000,
0x072, 0x000007D2,
0x073, 0x00000000,
0x074, 0x00050400,
0x075, 0x0004026E,
0x0EF, 0x00000100,
0x034, 0x0000ADD7,
0x035, 0x00005C00,
0x034, 0x00009DD4,
0x035, 0x00005000,
0x034, 0x00008DD1,
0x035, 0x00004400,
0x034, 0x00007DCE,
0x035, 0x00003800,
0x034, 0x00006CD1,
0x035, 0x00004400,
0x034, 0x00005CCE,
0x035, 0x00003800,
0x034, 0x000048CE,
0x035, 0x00004400,
0x034, 0x000034CE,
0x035, 0x00003800,
0x034, 0x00002451,
0x035, 0x00004400,
0x034, 0x0000144E,
0x035, 0x00003800,
0x034, 0x00000051,
0x035, 0x00004400,
0x0EF, 0x00000000,
0x0EF, 0x00000100,
0x0ED, 0x00000010,
0x044, 0x0000ADD7,
0x044, 0x00009DD4,
0x044, 0x00008DD1,
0x044, 0x00007DCE,
0x044, 0x00006CC1,
0x044, 0x00005CCE,
0x044, 0x000044D1,
0x044, 0x000034CE,
0x044, 0x00002451,
0x044, 0x0000144E,
0x044, 0x00000051,
0x0EF, 0x00000000,
0x0ED, 0x00000000,
0x07F, 0x00020080,
0x0EF, 0x00002000,
0x03B, 0x000380EF,
0x03B, 0x000302FE,
0x03B, 0x00028CE6,
0x03B, 0x000200BC,
0x03B, 0x000188A5,
0x03B, 0x00010FBC,
0x03B, 0x00008F71,
0x03B, 0x00000900,
0x0EF, 0x00000000,
0x0ED, 0x00000001,
0x040, 0x000380EF,
0x040, 0x000302FE,
0x040, 0x00028CE6,
0x040, 0x000200BC,
0x040, 0x000188A5,
0x040, 0x00010FBC,
0x040, 0x00008F71,
0x040, 0x00000900,
0x0ED, 0x00000000,
0x082, 0x00080000,
0x083, 0x00008000,
0x084, 0x00048D80,
0x085, 0x00068000,
0x0A2, 0x00080000,
0x0A3, 0x00008000,
0x0A4, 0x00048D80,
0x0A5, 0x00068000,
0x0ED, 0x00000002,
0x0EF, 0x00000002,
0x056, 0x00000032,
0x076, 0x00000032,
0x001, 0x00000780,
};
void ODM_ReadAndConfig_MP_8723B_RadioA(struct dm_odm_t *pDM_Odm)
{
u32 i = 0;
u32 ArrayLen = ARRAY_SIZE(Array_MP_8723B_RadioA);
u32 *Array = Array_MP_8723B_RadioA;
for (i = 0; i < ArrayLen; i += 2) {
u32 v1 = Array[i];
u32 v2 = Array[i+1];
/* This (offset, data) pair doesn't care the condition. */
if (v1 < 0x40000000) {
odm_ConfigRF_RadioA_8723B(pDM_Odm, v1, v2);
continue;
} else {
/* This line is the beginning of branch. */
bool bMatched = true;
u8 cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
if (cCond == COND_ELSE) { /* ELSE, ENDIF */
bMatched = true;
READ_NEXT_PAIR(v1, v2, i);
} else if (!CheckPositive(pDM_Odm, v1, v2)) {
bMatched = false;
READ_NEXT_PAIR(v1, v2, i);
READ_NEXT_PAIR(v1, v2, i);
} else {
READ_NEXT_PAIR(v1, v2, i);
if (!CheckNegative(pDM_Odm, v1, v2))
bMatched = false;
else
bMatched = true;
READ_NEXT_PAIR(v1, v2, i);
}
if (!bMatched) {
/* Condition isn't matched.
* Discard the following (offset, data) pairs.
*/
while (v1 < 0x40000000 && i < ArrayLen-2)
READ_NEXT_PAIR(v1, v2, i);
i -= 2; /* prevent from for-loop += 2 */
} else {
/* Configure matched pairs and skip to end of if-else. */
while (v1 < 0x40000000 && i < ArrayLen-2) {
odm_ConfigRF_RadioA_8723B(pDM_Odm, v1, v2);
READ_NEXT_PAIR(v1, v2, i);
}
/* Keeps reading until ENDIF. */
cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
while (cCond != COND_ENDIF && i < ArrayLen-2) {
READ_NEXT_PAIR(v1, v2, i);
cCond = (u8)((v1 & (BIT29|BIT28)) >> 28);
}
}
}
}
}
/******************************************************************************
* TxPowerTrack_SDIO.TXT
******************************************************************************/
static u8 gDeltaSwingTableIdx_MP_2GB_N_TxPowerTrack_SDIO_8723B[] = {
0, 0, 1, 2, 2, 2, 3, 3, 3, 4, 5, 5, 6, 6, 6, 6,
7, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 13, 14, 15
};
static u8 gDeltaSwingTableIdx_MP_2GB_P_TxPowerTrack_SDIO_8723B[] = {
0, 0, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 8, 8,
9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 15
};
static u8 gDeltaSwingTableIdx_MP_2GA_N_TxPowerTrack_SDIO_8723B[] = {
0, 0, 1, 2, 2, 2, 3, 3, 3, 4, 5, 5, 6, 6, 6, 6,
7, 7, 7, 8, 8, 9, 9, 10, 10, 11, 12, 13, 14, 15
};
static u8 gDeltaSwingTableIdx_MP_2GA_P_TxPowerTrack_SDIO_8723B[] = {
0, 0, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 8, 8,
9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 15
};
static u8 gDeltaSwingTableIdx_MP_2GCCKB_N_TxPowerTrack_SDIO_8723B[] = {
0, 0, 1, 2, 2, 3, 3, 4, 4, 5, 6, 6, 7, 7, 7, 8,
8, 8, 9, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 15
};
static u8 gDeltaSwingTableIdx_MP_2GCCKB_P_TxPowerTrack_SDIO_8723B[] = {
0, 0, 1, 2, 2, 2, 3, 3, 3, 4, 5, 5, 6, 6, 7, 7,
8, 8, 9, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 15
};
static u8 gDeltaSwingTableIdx_MP_2GCCKA_N_TxPowerTrack_SDIO_8723B[] = {
0, 0, 1, 2, 2, 3, 3, 4, 4, 5, 6, 6, 7, 7, 7, 8,
8, 8, 9, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 15
};
static u8 gDeltaSwingTableIdx_MP_2GCCKA_P_TxPowerTrack_SDIO_8723B[] = {
0, 0, 1, 2, 2, 2, 3, 3, 3, 4, 5, 5, 6, 6, 7, 7,
8, 8, 9, 9, 9, 10, 10, 11, 11, 12, 12, 13, 14, 15
};
void ODM_ReadAndConfig_MP_8723B_TxPowerTrack_SDIO(struct dm_odm_t *pDM_Odm)
{
struct odm_rf_cal_t *pRFCalibrateInfo = &pDM_Odm->RFCalibrateInfo;
memcpy(
pRFCalibrateInfo->DeltaSwingTableIdx_2GA_P,
gDeltaSwingTableIdx_MP_2GA_P_TxPowerTrack_SDIO_8723B,
DELTA_SWINGIDX_SIZE
);
memcpy(
pRFCalibrateInfo->DeltaSwingTableIdx_2GA_N,
gDeltaSwingTableIdx_MP_2GA_N_TxPowerTrack_SDIO_8723B,
DELTA_SWINGIDX_SIZE
);
memcpy(
pRFCalibrateInfo->DeltaSwingTableIdx_2GB_P,
gDeltaSwingTableIdx_MP_2GB_P_TxPowerTrack_SDIO_8723B,
DELTA_SWINGIDX_SIZE
);
memcpy(
pRFCalibrateInfo->DeltaSwingTableIdx_2GB_N,
gDeltaSwingTableIdx_MP_2GB_N_TxPowerTrack_SDIO_8723B,
DELTA_SWINGIDX_SIZE
);
memcpy(
pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_P,
gDeltaSwingTableIdx_MP_2GCCKA_P_TxPowerTrack_SDIO_8723B,
DELTA_SWINGIDX_SIZE
);
memcpy(
pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKA_N,
gDeltaSwingTableIdx_MP_2GCCKA_N_TxPowerTrack_SDIO_8723B,
DELTA_SWINGIDX_SIZE
);
memcpy(
pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_P,
gDeltaSwingTableIdx_MP_2GCCKB_P_TxPowerTrack_SDIO_8723B,
DELTA_SWINGIDX_SIZE
);
memcpy(
pRFCalibrateInfo->DeltaSwingTableIdx_2GCCKB_N,
gDeltaSwingTableIdx_MP_2GCCKB_N_TxPowerTrack_SDIO_8723B,
DELTA_SWINGIDX_SIZE
);
}
/******************************************************************************
* TXPWR_LMT.TXT
******************************************************************************/
static u8 *Array_MP_8723B_TXPWR_LMT[] = {
"FCC", "20M", "CCK", "1T", "01", "32",
"ETSI", "20M", "CCK", "1T", "01", "32",
"MKK", "20M", "CCK", "1T", "01", "32",
"FCC", "20M", "CCK", "1T", "02", "32",
"ETSI", "20M", "CCK", "1T", "02", "32",
"MKK", "20M", "CCK", "1T", "02", "32",
"FCC", "20M", "CCK", "1T", "03", "32",
"ETSI", "20M", "CCK", "1T", "03", "32",
"MKK", "20M", "CCK", "1T", "03", "32",
"FCC", "20M", "CCK", "1T", "04", "32",
"ETSI", "20M", "CCK", "1T", "04", "32",
"MKK", "20M", "CCK", "1T", "04", "32",
"FCC", "20M", "CCK", "1T", "05", "32",
"ETSI", "20M", "CCK", "1T", "05", "32",
"MKK", "20M", "CCK", "1T", "05", "32",
"FCC", "20M", "CCK", "1T", "06", "32",
"ETSI", "20M", "CCK", "1T", "06", "32",
"MKK", "20M", "CCK", "1T", "06", "32",
"FCC", "20M", "CCK", "1T", "07", "32",
"ETSI", "20M", "CCK", "1T", "07", "32",
"MKK", "20M", "CCK", "1T", "07", "32",
"FCC", "20M", "CCK", "1T", "08", "32",
"ETSI", "20M", "CCK", "1T", "08", "32",
"MKK", "20M", "CCK", "1T", "08", "32",
"FCC", "20M", "CCK", "1T", "09", "32",
"ETSI", "20M", "CCK", "1T", "09", "32",
"MKK", "20M", "CCK", "1T", "09", "32",
"FCC", "20M", "CCK", "1T", "10", "32",
"ETSI", "20M", "CCK", "1T", "10", "32",
"MKK", "20M", "CCK", "1T", "10", "32",
"FCC", "20M", "CCK", "1T", "11", "32",
"ETSI", "20M", "CCK", "1T", "11", "32",
"MKK", "20M", "CCK", "1T", "11", "32",
"FCC", "20M", "CCK", "1T", "12", "63",
"ETSI", "20M", "CCK", "1T", "12", "32",
"MKK", "20M", "CCK", "1T", "12", "32",
"FCC", "20M", "CCK", "1T", "13", "63",
"ETSI", "20M", "CCK", "1T", "13", "32",
"MKK", "20M", "CCK", "1T", "13", "32",
"FCC", "20M", "CCK", "1T", "14", "63",
"ETSI", "20M", "CCK", "1T", "14", "63",
"MKK", "20M", "CCK", "1T", "14", "32",
"FCC", "20M", "OFDM", "1T", "01", "28",
"ETSI", "20M", "OFDM", "1T", "01", "32",
"MKK", "20M", "OFDM", "1T", "01", "32",
"FCC", "20M", "OFDM", "1T", "02", "28",
"ETSI", "20M", "OFDM", "1T", "02", "32",
"MKK", "20M", "OFDM", "1T", "02", "32",
"FCC", "20M", "OFDM", "1T", "03", "32",
"ETSI", "20M", "OFDM", "1T", "03", "32",
"MKK", "20M", "OFDM", "1T", "03", "32",
"FCC", "20M", "OFDM", "1T", "04", "32",
"ETSI", "20M", "OFDM", "1T", "04", "32",
"MKK", "20M", "OFDM", "1T", "04", "32",
"FCC", "20M", "OFDM", "1T", "05", "32",
"ETSI", "20M", "OFDM", "1T", "05", "32",
"MKK", "20M", "OFDM", "1T", "05", "32",
"FCC", "20M", "OFDM", "1T", "06", "32",
"ETSI", "20M", "OFDM", "1T", "06", "32",
"MKK", "20M", "OFDM", "1T", "06", "32",
"FCC", "20M", "OFDM", "1T", "07", "32",
"ETSI", "20M", "OFDM", "1T", "07", "32",
"MKK", "20M", "OFDM", "1T", "07", "32",
"FCC", "20M", "OFDM", "1T", "08", "32",
"ETSI", "20M", "OFDM", "1T", "08", "32",
"MKK", "20M", "OFDM", "1T", "08", "32",
"FCC", "20M", "OFDM", "1T", "09", "32",
"ETSI", "20M", "OFDM", "1T", "09", "32",
"MKK", "20M", "OFDM", "1T", "09", "32",
"FCC", "20M", "OFDM", "1T", "10", "28",
"ETSI", "20M", "OFDM", "1T", "10", "32",
"MKK", "20M", "OFDM", "1T", "10", "32",
"FCC", "20M", "OFDM", "1T", "11", "28",
"ETSI", "20M", "OFDM", "1T", "11", "32",
"MKK", "20M", "OFDM", "1T", "11", "32",
"FCC", "20M", "OFDM", "1T", "12", "63",
"ETSI", "20M", "OFDM", "1T", "12", "32",
"MKK", "20M", "OFDM", "1T", "12", "32",
"FCC", "20M", "OFDM", "1T", "13", "63",
"ETSI", "20M", "OFDM", "1T", "13", "32",
"MKK", "20M", "OFDM", "1T", "13", "32",
"FCC", "20M", "OFDM", "1T", "14", "63",
"ETSI", "20M", "OFDM", "1T", "14", "63",
"MKK", "20M", "OFDM", "1T", "14", "63",
"FCC", "20M", "HT", "1T", "01", "26",
"ETSI", "20M", "HT", "1T", "01", "32",
"MKK", "20M", "HT", "1T", "01", "32",
"FCC", "20M", "HT", "1T", "02", "26",
"ETSI", "20M", "HT", "1T", "02", "32",
"MKK", "20M", "HT", "1T", "02", "32",
"FCC", "20M", "HT", "1T", "03", "32",
"ETSI", "20M", "HT", "1T", "03", "32",
"MKK", "20M", "HT", "1T", "03", "32",
"FCC", "20M", "HT", "1T", "04", "32",
"ETSI", "20M", "HT", "1T", "04", "32",
"MKK", "20M", "HT", "1T", "04", "32",
"FCC", "20M", "HT", "1T", "05", "32",
"ETSI", "20M", "HT", "1T", "05", "32",
"MKK", "20M", "HT", "1T", "05", "32",
"FCC", "20M", "HT", "1T", "06", "32",
"ETSI", "20M", "HT", "1T", "06", "32",
"MKK", "20M", "HT", "1T", "06", "32",
"FCC", "20M", "HT", "1T", "07", "32",
"ETSI", "20M", "HT", "1T", "07", "32",
"MKK", "20M", "HT", "1T", "07", "32",
"FCC", "20M", "HT", "1T", "08", "32",
"ETSI", "20M", "HT", "1T", "08", "32",
"MKK", "20M", "HT", "1T", "08", "32",
"FCC", "20M", "HT", "1T", "09", "32",
"ETSI", "20M", "HT", "1T", "09", "32",
"MKK", "20M", "HT", "1T", "09", "32",
"FCC", "20M", "HT", "1T", "10", "26",
"ETSI", "20M", "HT", "1T", "10", "32",
"MKK", "20M", "HT", "1T", "10", "32",
"FCC", "20M", "HT", "1T", "11", "26",
"ETSI", "20M", "HT", "1T", "11", "32",
"MKK", "20M", "HT", "1T", "11", "32",
"FCC", "20M", "HT", "1T", "12", "63",
"ETSI", "20M", "HT", "1T", "12", "32",
"MKK", "20M", "HT", "1T", "12", "32",
"FCC", "20M", "HT", "1T", "13", "63",
"ETSI", "20M", "HT", "1T", "13", "32",
"MKK", "20M", "HT", "1T", "13", "32",
"FCC", "20M", "HT", "1T", "14", "63",
"ETSI", "20M", "HT", "1T", "14", "63",
"MKK", "20M", "HT", "1T", "14", "63",
"FCC", "40M", "HT", "1T", "01", "63",
"ETSI", "40M", "HT", "1T", "01", "63",
"MKK", "40M", "HT", "1T", "01", "63",
"FCC", "40M", "HT", "1T", "02", "63",
"ETSI", "40M", "HT", "1T", "02", "63",
"MKK", "40M", "HT", "1T", "02", "63",
"FCC", "40M", "HT", "1T", "03", "26",
"ETSI", "40M", "HT", "1T", "03", "32",
"MKK", "40M", "HT", "1T", "03", "32",
"FCC", "40M", "HT", "1T", "04", "26",
"ETSI", "40M", "HT", "1T", "04", "32",
"MKK", "40M", "HT", "1T", "04", "32",
"FCC", "40M", "HT", "1T", "05", "32",
"ETSI", "40M", "HT", "1T", "05", "32",
"MKK", "40M", "HT", "1T", "05", "32",
"FCC", "40M", "HT", "1T", "06", "32",
"ETSI", "40M", "HT", "1T", "06", "32",
"MKK", "40M", "HT", "1T", "06", "32",
"FCC", "40M", "HT", "1T", "07", "32",
"ETSI", "40M", "HT", "1T", "07", "32",
"MKK", "40M", "HT", "1T", "07", "32",
"FCC", "40M", "HT", "1T", "08", "26",
"ETSI", "40M", "HT", "1T", "08", "32",
"MKK", "40M", "HT", "1T", "08", "32",
"FCC", "40M", "HT", "1T", "09", "26",
"ETSI", "40M", "HT", "1T", "09", "32",
"MKK", "40M", "HT", "1T", "09", "32",
"FCC", "40M", "HT", "1T", "10", "26",
"ETSI", "40M", "HT", "1T", "10", "32",
"MKK", "40M", "HT", "1T", "10", "32",
"FCC", "40M", "HT", "1T", "11", "26",
"ETSI", "40M", "HT", "1T", "11", "32",
"MKK", "40M", "HT", "1T", "11", "32",
"FCC", "40M", "HT", "1T", "12", "63",
"ETSI", "40M", "HT", "1T", "12", "32",
"MKK", "40M", "HT", "1T", "12", "32",
"FCC", "40M", "HT", "1T", "13", "63",
"ETSI", "40M", "HT", "1T", "13", "32",
"MKK", "40M", "HT", "1T", "13", "32",
"FCC", "40M", "HT", "1T", "14", "63",
"ETSI", "40M", "HT", "1T", "14", "63",
"MKK", "40M", "HT", "1T", "14", "63"
};
void ODM_ReadAndConfig_MP_8723B_TXPWR_LMT(struct dm_odm_t *pDM_Odm)
{
u32 i = 0;
u8 **Array = Array_MP_8723B_TXPWR_LMT;
for (i = 0; i < ARRAY_SIZE(Array_MP_8723B_TXPWR_LMT); i += 6) {
u8 *regulation = Array[i];
u8 *bandwidth = Array[i+1];
u8 *rate = Array[i+2];
u8 *rfPath = Array[i+3];
u8 *chnl = Array[i+4];
u8 *val = Array[i+5];
odm_ConfigBB_TXPWR_LMT_8723B(
pDM_Odm,
regulation,
bandwidth,
rate,
rfPath,
chnl,
val
);
}
}
| linux-master | drivers/staging/rtl8723bs/hal/HalHWImg8723B_RF.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
/* Description: */
/* This file is for 92CE/92CU dynamic mechanism only */
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtl8723b_hal.h>
/* Global var */
static void dm_CheckStatistics(struct adapter *Adapter)
{
}
/* */
/* functions */
/* */
static void Init_ODM_ComInfo_8723b(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
struct dm_priv *pdmpriv = &pHalData->dmpriv;
u8 cut_ver, fab_ver;
/* */
/* Init Value */
/* */
memset(pDM_Odm, 0, sizeof(*pDM_Odm));
pDM_Odm->Adapter = Adapter;
#define ODM_CE 0x04
ODM_CmnInfoInit(pDM_Odm, ODM_CMNINFO_PLATFORM, ODM_CE);
ODM_CmnInfoInit(pDM_Odm, ODM_CMNINFO_INTERFACE, RTW_SDIO);
ODM_CmnInfoInit(pDM_Odm, ODM_CMNINFO_PACKAGE_TYPE, pHalData->PackageType);
ODM_CmnInfoInit(pDM_Odm, ODM_CMNINFO_IC_TYPE, ODM_RTL8723B);
fab_ver = ODM_TSMC;
cut_ver = ODM_CUT_A;
ODM_CmnInfoInit(pDM_Odm, ODM_CMNINFO_FAB_VER, fab_ver);
ODM_CmnInfoInit(pDM_Odm, ODM_CMNINFO_CUT_VER, cut_ver);
ODM_CmnInfoInit(pDM_Odm, ODM_CMNINFO_PATCH_ID, pHalData->CustomerID);
/* ODM_CMNINFO_BINHCT_TEST only for MP Team */
ODM_CmnInfoInit(pDM_Odm, ODM_CMNINFO_BWIFI_TEST, Adapter->registrypriv.wifi_spec);
pdmpriv->InitODMFlag = ODM_RF_CALIBRATION|ODM_RF_TX_PWR_TRACK;
ODM_CmnInfoUpdate(pDM_Odm, ODM_CMNINFO_ABILITY, pdmpriv->InitODMFlag);
}
static void Update_ODM_ComInfo_8723b(struct adapter *Adapter)
{
struct mlme_ext_priv *pmlmeext = &Adapter->mlmeextpriv;
struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
struct dvobj_priv *dvobj = adapter_to_dvobj(Adapter);
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(Adapter);
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
struct dm_priv *pdmpriv = &pHalData->dmpriv;
int i;
u8 zero = 0;
pdmpriv->InitODMFlag = 0
| ODM_BB_DIG
| ODM_BB_RA_MASK
| ODM_BB_DYNAMIC_TXPWR
| ODM_BB_FA_CNT
| ODM_BB_RSSI_MONITOR
| ODM_BB_CCK_PD
| ODM_BB_PWR_SAVE
| ODM_BB_CFO_TRACKING
| ODM_MAC_EDCA_TURBO
| ODM_RF_TX_PWR_TRACK
| ODM_RF_CALIBRATION
;
/* */
/* Pointer reference */
/* */
/* ODM_CMNINFO_MAC_PHY_MODE pHalData->MacPhyMode92D */
/* ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_MAC_PHY_MODE,&(pDM_Odm->u8_temp)); */
ODM_CmnInfoUpdate(pDM_Odm, ODM_CMNINFO_ABILITY, pdmpriv->InitODMFlag);
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_TX_UNI, &(dvobj->traffic_stat.tx_bytes));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_RX_UNI, &(dvobj->traffic_stat.rx_bytes));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_WM_MODE, &(pmlmeext->cur_wireless_mode));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_SEC_CHNL_OFFSET, &(pHalData->nCur40MhzPrimeSC));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_SEC_MODE, &(Adapter->securitypriv.dot11PrivacyAlgrthm));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_BW, &(pHalData->CurrentChannelBW));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_CHNL, &(pHalData->CurrentChannel));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_NET_CLOSED, &(Adapter->net_closed));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_MP_MODE, &zero);
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_FORCED_IGI_LB, &(pHalData->u1ForcedIgiLb));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_FORCED_RATE, &(pHalData->ForcedDataRate));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_SCAN, &(pmlmepriv->bScanInProcess));
ODM_CmnInfoHook(pDM_Odm, ODM_CMNINFO_POWER_SAVING, &(pwrctrlpriv->bpower_saving));
for (i = 0; i < NUM_STA; i++)
ODM_CmnInfoPtrArrayHook(pDM_Odm, ODM_CMNINFO_STA_STATUS, i, NULL);
}
void rtl8723b_InitHalDm(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct dm_priv *pdmpriv = &pHalData->dmpriv;
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
pdmpriv->DM_Type = DM_Type_ByDriver;
pdmpriv->DMFlag = DYNAMIC_FUNC_DISABLE;
pdmpriv->DMFlag |= DYNAMIC_FUNC_BT;
pdmpriv->InitDMFlag = pdmpriv->DMFlag;
Update_ODM_ComInfo_8723b(Adapter);
ODM_DMInit(pDM_Odm);
}
void rtl8723b_HalDmWatchDog(struct adapter *Adapter)
{
bool fw_current_in_ps_mode = false;
bool bFwPSAwake = true;
u8 hw_init_completed = false;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
hw_init_completed = Adapter->hw_init_completed;
if (hw_init_completed == false)
goto skip_dm;
fw_current_in_ps_mode = adapter_to_pwrctl(Adapter)->fw_current_in_ps_mode;
rtw_hal_get_hwreg(Adapter, HW_VAR_FWLPS_RF_ON, (u8 *)(&bFwPSAwake));
if (
(hw_init_completed == true) &&
((!fw_current_in_ps_mode) && bFwPSAwake)
) {
/* */
/* Calculate Tx/Rx statistics. */
/* */
dm_CheckStatistics(Adapter);
rtw_hal_check_rxfifo_full(Adapter);
}
/* ODM */
if (hw_init_completed == true) {
u8 bLinked = false;
u8 bsta_state = false;
bool bBtDisabled = true;
if (rtw_linked_check(Adapter)) {
bLinked = true;
if (check_fwstate(&Adapter->mlmepriv, WIFI_STATION_STATE))
bsta_state = true;
}
ODM_CmnInfoUpdate(&pHalData->odmpriv, ODM_CMNINFO_LINK, bLinked);
ODM_CmnInfoUpdate(&pHalData->odmpriv, ODM_CMNINFO_STATION_STATE, bsta_state);
/* ODM_CmnInfoUpdate(&pHalData->odmpriv , ODM_CMNINFO_RSSI_MIN, pdmpriv->MinUndecoratedPWDBForDM); */
bBtDisabled = hal_btcoex_IsBtDisabled(Adapter);
ODM_CmnInfoUpdate(&pHalData->odmpriv, ODM_CMNINFO_BT_ENABLED,
!bBtDisabled);
ODM_DMWatchdog(&pHalData->odmpriv);
}
skip_dm:
return;
}
void rtl8723b_hal_dm_in_lps(struct adapter *padapter)
{
u32 PWDB_rssi = 0;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct sta_info *psta = NULL;
/* update IGI */
ODM_Write_DIG(pDM_Odm, pDM_Odm->RSSI_Min);
/* set rssi to fw */
psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
if (psta && (psta->rssi_stat.UndecoratedSmoothedPWDB > 0)) {
PWDB_rssi = (psta->mac_id | (psta->rssi_stat.UndecoratedSmoothedPWDB<<16));
rtl8723b_set_rssi_cmd(padapter, (u8 *)&PWDB_rssi);
}
}
void rtl8723b_HalDmWatchDog_in_LPS(struct adapter *Adapter)
{
u8 bLinked = false;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct mlme_priv *pmlmepriv = &Adapter->mlmepriv;
struct dm_priv *pdmpriv = &pHalData->dmpriv;
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
struct dig_t *pDM_DigTable = &pDM_Odm->DM_DigTable;
struct sta_priv *pstapriv = &Adapter->stapriv;
struct sta_info *psta = NULL;
if (Adapter->hw_init_completed == false)
goto skip_lps_dm;
if (rtw_linked_check(Adapter))
bLinked = true;
ODM_CmnInfoUpdate(&pHalData->odmpriv, ODM_CMNINFO_LINK, bLinked);
if (bLinked == false)
goto skip_lps_dm;
if (!(pDM_Odm->SupportAbility & ODM_BB_RSSI_MONITOR))
goto skip_lps_dm;
/* ODM_DMWatchdog(&pHalData->odmpriv); */
/* Do DIG by RSSI In LPS-32K */
/* 1 Find MIN-RSSI */
psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
if (!psta)
goto skip_lps_dm;
pdmpriv->EntryMinUndecoratedSmoothedPWDB = psta->rssi_stat.UndecoratedSmoothedPWDB;
if (pdmpriv->EntryMinUndecoratedSmoothedPWDB <= 0)
goto skip_lps_dm;
pdmpriv->MinUndecoratedPWDBForDM = pdmpriv->EntryMinUndecoratedSmoothedPWDB;
pDM_Odm->RSSI_Min = pdmpriv->MinUndecoratedPWDBForDM;
/* if (pDM_DigTable->CurIGValue != pDM_Odm->RSSI_Min) */
if (
(pDM_DigTable->CurIGValue > pDM_Odm->RSSI_Min + 5) ||
(pDM_DigTable->CurIGValue < pDM_Odm->RSSI_Min - 5)
)
rtw_dm_in_lps_wk_cmd(Adapter);
skip_lps_dm:
return;
}
void rtl8723b_init_dm_priv(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct dm_priv *pdmpriv = &pHalData->dmpriv;
memset(pdmpriv, 0, sizeof(struct dm_priv));
Init_ODM_ComInfo_8723b(Adapter);
}
| linux-master | drivers/staging/rtl8723bs/hal/rtl8723b_dm.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include "Mp_Precomp.h"
/* defines */
#define HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(val) \
do { \
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, val); \
pCoexDm->psTdmaDuAdjType = val; \
} while (0)
/* Global variables, these are static variables */
static struct coex_dm_8723b_2ant GLCoexDm8723b2Ant;
static struct coex_dm_8723b_2ant *pCoexDm = &GLCoexDm8723b2Ant;
static struct coex_sta_8723b_2ant GLCoexSta8723b2Ant;
static struct coex_sta_8723b_2ant *pCoexSta = &GLCoexSta8723b2Ant;
/* local function start with halbtc8723b2ant_ */
static u8 halbtc8723b2ant_BtRssiState(
u8 levelNum, u8 rssiThresh, u8 rssiThresh1
)
{
s32 btRssi = 0;
u8 btRssiState = pCoexSta->preBtRssiState;
btRssi = pCoexSta->btRssi;
if (levelNum == 2) {
if (
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
) {
if (btRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
btRssiState = BTC_RSSI_STATE_HIGH;
} else {
btRssiState = BTC_RSSI_STATE_STAY_LOW;
}
} else {
if (btRssi < rssiThresh) {
btRssiState = BTC_RSSI_STATE_LOW;
} else {
btRssiState = BTC_RSSI_STATE_STAY_HIGH;
}
}
} else if (levelNum == 3) {
if (rssiThresh > rssiThresh1) {
return pCoexSta->preBtRssiState;
}
if (
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_LOW) ||
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_LOW)
) {
if (btRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
btRssiState = BTC_RSSI_STATE_MEDIUM;
} else {
btRssiState = BTC_RSSI_STATE_STAY_LOW;
}
} else if (
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_MEDIUM) ||
(pCoexSta->preBtRssiState == BTC_RSSI_STATE_STAY_MEDIUM)
) {
if (btRssi >= (rssiThresh1 + BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
btRssiState = BTC_RSSI_STATE_HIGH;
} else if (btRssi < rssiThresh) {
btRssiState = BTC_RSSI_STATE_LOW;
} else {
btRssiState = BTC_RSSI_STATE_STAY_MEDIUM;
}
} else {
if (btRssi < rssiThresh1) {
btRssiState = BTC_RSSI_STATE_MEDIUM;
} else {
btRssiState = BTC_RSSI_STATE_STAY_HIGH;
}
}
}
pCoexSta->preBtRssiState = btRssiState;
return btRssiState;
}
static u8 halbtc8723b2ant_WifiRssiState(
struct btc_coexist *pBtCoexist,
u8 index,
u8 levelNum,
u8 rssiThresh,
u8 rssiThresh1
)
{
s32 wifiRssi = 0;
u8 wifiRssiState = pCoexSta->preWifiRssiState[index];
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_S4_WIFI_RSSI, &wifiRssi);
if (levelNum == 2) {
if (
(pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_LOW) ||
(pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_LOW)
) {
if (wifiRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
wifiRssiState = BTC_RSSI_STATE_HIGH;
} else {
wifiRssiState = BTC_RSSI_STATE_STAY_LOW;
}
} else {
if (wifiRssi < rssiThresh) {
wifiRssiState = BTC_RSSI_STATE_LOW;
} else {
wifiRssiState = BTC_RSSI_STATE_STAY_HIGH;
}
}
} else if (levelNum == 3) {
if (rssiThresh > rssiThresh1) {
return pCoexSta->preWifiRssiState[index];
}
if (
(pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_LOW) ||
(pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_LOW)
) {
if (wifiRssi >= (rssiThresh + BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
wifiRssiState = BTC_RSSI_STATE_MEDIUM;
} else {
wifiRssiState = BTC_RSSI_STATE_STAY_LOW;
}
} else if (
(pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_MEDIUM) ||
(pCoexSta->preWifiRssiState[index] == BTC_RSSI_STATE_STAY_MEDIUM)
) {
if (wifiRssi >= (rssiThresh1 + BTC_RSSI_COEX_THRESH_TOL_8723B_2ANT)) {
wifiRssiState = BTC_RSSI_STATE_HIGH;
} else if (wifiRssi < rssiThresh) {
wifiRssiState = BTC_RSSI_STATE_LOW;
} else {
wifiRssiState = BTC_RSSI_STATE_STAY_MEDIUM;
}
} else {
if (wifiRssi < rssiThresh1) {
wifiRssiState = BTC_RSSI_STATE_MEDIUM;
} else {
wifiRssiState = BTC_RSSI_STATE_STAY_HIGH;
}
}
}
pCoexSta->preWifiRssiState[index] = wifiRssiState;
return wifiRssiState;
}
static void halbtc8723b2ant_LimitedRx(
struct btc_coexist *pBtCoexist,
bool bForceExec,
bool bRejApAggPkt,
bool bBtCtrlAggBufSize,
u8 aggBufSize
)
{
bool bRejectRxAgg = bRejApAggPkt;
bool bBtCtrlRxAggSize = bBtCtrlAggBufSize;
u8 rxAggSize = aggBufSize;
/* */
/* Rx Aggregation related setting */
/* */
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_TO_REJ_AP_AGG_PKT, &bRejectRxAgg);
/* decide BT control aggregation buf size or not */
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_CTRL_AGG_SIZE, &bBtCtrlRxAggSize);
/* aggregation buf size, only work when BT control Rx aggregation size. */
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_AGG_BUF_SIZE, &rxAggSize);
/* real update aggregation setting */
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_AGGREGATE_CTRL, NULL);
}
static void halbtc8723b2ant_QueryBtInfo(struct btc_coexist *pBtCoexist)
{
u8 H2C_Parameter[1] = {0};
pCoexSta->bC2hBtInfoReqSent = true;
H2C_Parameter[0] |= BIT0; /* trigger */
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x61, 1, H2C_Parameter);
}
static bool halbtc8723b2ant_IsWifiStatusChanged(struct btc_coexist *pBtCoexist)
{
static bool bPreWifiBusy, bPreUnder4way, bPreBtHsOn;
bool bWifiBusy = false, bUnder4way = false, bBtHsOn = false;
bool bWifiConnected = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_4_WAY_PROGRESS, &bUnder4way);
if (bWifiConnected) {
if (bWifiBusy != bPreWifiBusy) {
bPreWifiBusy = bWifiBusy;
return true;
}
if (bUnder4way != bPreUnder4way) {
bPreUnder4way = bUnder4way;
return true;
}
if (bBtHsOn != bPreBtHsOn) {
bPreBtHsOn = bBtHsOn;
return true;
}
}
return false;
}
static void halbtc8723b2ant_UpdateBtLinkInfo(struct btc_coexist *pBtCoexist)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
bool bBtHsOn = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
pBtLinkInfo->bBtLinkExist = pCoexSta->bBtLinkExist;
pBtLinkInfo->bScoExist = pCoexSta->bScoExist;
pBtLinkInfo->bA2dpExist = pCoexSta->bA2dpExist;
pBtLinkInfo->bPanExist = pCoexSta->bPanExist;
pBtLinkInfo->bHidExist = pCoexSta->bHidExist;
/* work around for HS mode. */
if (bBtHsOn) {
pBtLinkInfo->bPanExist = true;
pBtLinkInfo->bBtLinkExist = true;
}
/* check if Sco only */
if (
pBtLinkInfo->bScoExist &&
!pBtLinkInfo->bA2dpExist &&
!pBtLinkInfo->bPanExist &&
!pBtLinkInfo->bHidExist
)
pBtLinkInfo->bScoOnly = true;
else
pBtLinkInfo->bScoOnly = false;
/* check if A2dp only */
if (
!pBtLinkInfo->bScoExist &&
pBtLinkInfo->bA2dpExist &&
!pBtLinkInfo->bPanExist &&
!pBtLinkInfo->bHidExist
)
pBtLinkInfo->bA2dpOnly = true;
else
pBtLinkInfo->bA2dpOnly = false;
/* check if Pan only */
if (
!pBtLinkInfo->bScoExist &&
!pBtLinkInfo->bA2dpExist &&
pBtLinkInfo->bPanExist &&
!pBtLinkInfo->bHidExist
)
pBtLinkInfo->bPanOnly = true;
else
pBtLinkInfo->bPanOnly = false;
/* check if Hid only */
if (
!pBtLinkInfo->bScoExist &&
!pBtLinkInfo->bA2dpExist &&
!pBtLinkInfo->bPanExist &&
pBtLinkInfo->bHidExist
)
pBtLinkInfo->bHidOnly = true;
else
pBtLinkInfo->bHidOnly = false;
}
static u8 halbtc8723b2ant_ActionAlgorithm(struct btc_coexist *pBtCoexist)
{
struct btc_bt_link_info *pBtLinkInfo = &pBtCoexist->btLinkInfo;
bool bBtHsOn = false;
u8 algorithm = BT_8723B_2ANT_COEX_ALGO_UNDEFINED;
u8 numOfDiffProfile = 0;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
if (!pBtLinkInfo->bBtLinkExist) {
return algorithm;
}
if (pBtLinkInfo->bScoExist)
numOfDiffProfile++;
if (pBtLinkInfo->bHidExist)
numOfDiffProfile++;
if (pBtLinkInfo->bPanExist)
numOfDiffProfile++;
if (pBtLinkInfo->bA2dpExist)
numOfDiffProfile++;
if (numOfDiffProfile == 1) {
if (pBtLinkInfo->bScoExist) {
algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
} else {
if (pBtLinkInfo->bHidExist) {
algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
} else if (pBtLinkInfo->bA2dpExist) {
algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP;
} else if (pBtLinkInfo->bPanExist) {
if (bBtHsOn) {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANHS;
} else {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR;
}
}
}
} else if (numOfDiffProfile == 2) {
if (pBtLinkInfo->bScoExist) {
if (pBtLinkInfo->bHidExist) {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
} else if (pBtLinkInfo->bA2dpExist) {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
} else if (pBtLinkInfo->bPanExist) {
if (bBtHsOn) {
algorithm = BT_8723B_2ANT_COEX_ALGO_SCO;
} else {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
}
}
} else {
if (
pBtLinkInfo->bHidExist &&
pBtLinkInfo->bA2dpExist
) {
algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
} else if (
pBtLinkInfo->bHidExist &&
pBtLinkInfo->bPanExist
) {
if (bBtHsOn) {
algorithm = BT_8723B_2ANT_COEX_ALGO_HID;
} else {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
}
} else if (
pBtLinkInfo->bPanExist &&
pBtLinkInfo->bA2dpExist
) {
if (bBtHsOn) {
algorithm = BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS;
} else {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP;
}
}
}
} else if (numOfDiffProfile == 3) {
if (pBtLinkInfo->bScoExist) {
if (
pBtLinkInfo->bHidExist &&
pBtLinkInfo->bA2dpExist
) {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
} else if (
pBtLinkInfo->bHidExist &&
pBtLinkInfo->bPanExist
) {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
} else if (
pBtLinkInfo->bPanExist &&
pBtLinkInfo->bA2dpExist
) {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
}
} else {
if (
pBtLinkInfo->bHidExist &&
pBtLinkInfo->bPanExist &&
pBtLinkInfo->bA2dpExist
) {
if (bBtHsOn) {
algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP;
} else {
algorithm = BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR;
}
}
}
} else if (numOfDiffProfile >= 3) {
if (pBtLinkInfo->bScoExist) {
if (
pBtLinkInfo->bHidExist &&
pBtLinkInfo->bPanExist &&
pBtLinkInfo->bA2dpExist
) {
if (bBtHsOn) {
} else {
algorithm = BT_8723B_2ANT_COEX_ALGO_PANEDR_HID;
}
}
}
}
return algorithm;
}
static void halbtc8723b2ant_SetFwDacSwingLevel(
struct btc_coexist *pBtCoexist, u8 dacSwingLvl
)
{
u8 H2C_Parameter[1] = {0};
/* There are several type of dacswing */
/* 0x18/ 0x10/ 0xc/ 0x8/ 0x4/ 0x6 */
H2C_Parameter[0] = dacSwingLvl;
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x64, 1, H2C_Parameter);
}
static void halbtc8723b2ant_SetFwDecBtPwr(
struct btc_coexist *pBtCoexist, u8 decBtPwrLvl
)
{
u8 H2C_Parameter[1] = {0};
H2C_Parameter[0] = decBtPwrLvl;
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x62, 1, H2C_Parameter);
}
static void halbtc8723b2ant_DecBtPwr(
struct btc_coexist *pBtCoexist, bool bForceExec, u8 decBtPwrLvl
)
{
pCoexDm->curBtDecPwrLvl = decBtPwrLvl;
if (!bForceExec) {
if (pCoexDm->preBtDecPwrLvl == pCoexDm->curBtDecPwrLvl)
return;
}
halbtc8723b2ant_SetFwDecBtPwr(pBtCoexist, pCoexDm->curBtDecPwrLvl);
pCoexDm->preBtDecPwrLvl = pCoexDm->curBtDecPwrLvl;
}
static void halbtc8723b2ant_FwDacSwingLvl(
struct btc_coexist *pBtCoexist, bool bForceExec, u8 fwDacSwingLvl
)
{
pCoexDm->curFwDacSwingLvl = fwDacSwingLvl;
if (!bForceExec) {
if (pCoexDm->preFwDacSwingLvl == pCoexDm->curFwDacSwingLvl)
return;
}
halbtc8723b2ant_SetFwDacSwingLevel(pBtCoexist, pCoexDm->curFwDacSwingLvl);
pCoexDm->preFwDacSwingLvl = pCoexDm->curFwDacSwingLvl;
}
static void halbtc8723b2ant_SetSwRfRxLpfCorner(
struct btc_coexist *pBtCoexist,
bool bRxRfShrinkOn
)
{
if (bRxRfShrinkOn) {
/* Shrink RF Rx LPF corner */
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff, 0xffffc);
} else {
/* Resume RF Rx LPF corner */
/* After initialized, we can use pCoexDm->btRf0x1eBackup */
if (pBtCoexist->bInitilized) {
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff, pCoexDm->btRf0x1eBackup);
}
}
}
static void halbtc8723b2ant_RfShrink(
struct btc_coexist *pBtCoexist, bool bForceExec, bool bRxRfShrinkOn
)
{
pCoexDm->bCurRfRxLpfShrink = bRxRfShrinkOn;
if (!bForceExec) {
if (pCoexDm->bPreRfRxLpfShrink == pCoexDm->bCurRfRxLpfShrink)
return;
}
halbtc8723b2ant_SetSwRfRxLpfCorner(pBtCoexist, pCoexDm->bCurRfRxLpfShrink);
pCoexDm->bPreRfRxLpfShrink = pCoexDm->bCurRfRxLpfShrink;
}
static void halbtc8723b2ant_SetSwPenaltyTxRateAdaptive(
struct btc_coexist *pBtCoexist, bool bLowPenaltyRa
)
{
u8 H2C_Parameter[6] = {0};
H2C_Parameter[0] = 0x6; /* opCode, 0x6 = Retry_Penalty */
if (bLowPenaltyRa) {
H2C_Parameter[1] |= BIT0;
H2C_Parameter[2] = 0x00; /* normal rate except MCS7/6/5, OFDM54/48/36 */
H2C_Parameter[3] = 0xf7; /* MCS7 or OFDM54 */
H2C_Parameter[4] = 0xf8; /* MCS6 or OFDM48 */
H2C_Parameter[5] = 0xf9; /* MCS5 or OFDM36 */
}
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x69, 6, H2C_Parameter);
}
static void halbtc8723b2ant_LowPenaltyRa(
struct btc_coexist *pBtCoexist, bool bForceExec, bool bLowPenaltyRa
)
{
/* return; */
pCoexDm->bCurLowPenaltyRa = bLowPenaltyRa;
if (!bForceExec) {
if (pCoexDm->bPreLowPenaltyRa == pCoexDm->bCurLowPenaltyRa)
return;
}
halbtc8723b2ant_SetSwPenaltyTxRateAdaptive(pBtCoexist, pCoexDm->bCurLowPenaltyRa);
pCoexDm->bPreLowPenaltyRa = pCoexDm->bCurLowPenaltyRa;
}
static void halbtc8723b2ant_SetDacSwingReg(struct btc_coexist *pBtCoexist, u32 level)
{
u8 val = (u8)level;
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x883, 0x3e, val);
}
static void halbtc8723b2ant_SetSwFullTimeDacSwing(
struct btc_coexist *pBtCoexist, bool bSwDacSwingOn, u32 swDacSwingLvl
)
{
if (bSwDacSwingOn)
halbtc8723b2ant_SetDacSwingReg(pBtCoexist, swDacSwingLvl);
else
halbtc8723b2ant_SetDacSwingReg(pBtCoexist, 0x18);
}
static void halbtc8723b2ant_DacSwing(
struct btc_coexist *pBtCoexist,
bool bForceExec,
bool bDacSwingOn,
u32 dacSwingLvl
)
{
pCoexDm->bCurDacSwingOn = bDacSwingOn;
pCoexDm->curDacSwingLvl = dacSwingLvl;
if (!bForceExec) {
if ((pCoexDm->bPreDacSwingOn == pCoexDm->bCurDacSwingOn) &&
(pCoexDm->preDacSwingLvl == pCoexDm->curDacSwingLvl))
return;
}
mdelay(30);
halbtc8723b2ant_SetSwFullTimeDacSwing(pBtCoexist, bDacSwingOn, dacSwingLvl);
pCoexDm->bPreDacSwingOn = pCoexDm->bCurDacSwingOn;
pCoexDm->preDacSwingLvl = pCoexDm->curDacSwingLvl;
}
static void halbtc8723b2ant_SetAgcTable(
struct btc_coexist *pBtCoexist, bool bAgcTableEn
)
{
u8 rssiAdjustVal = 0;
/* BB AGC Gain Table */
if (bAgcTableEn) {
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6e1A0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6d1B0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6c1C0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6b1D0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x6a1E0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x691F0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0x68200001);
} else {
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xaa1A0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa91B0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa81C0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa71D0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa61E0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa51F0001);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0xc78, 0xa4200001);
}
/* RF Gain */
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xef, 0xfffff, 0x02000);
if (bAgcTableEn) {
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x38fff);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x38ffe);
} else {
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x380c3);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x3b, 0xfffff, 0x28ce6);
}
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xef, 0xfffff, 0x0);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xed, 0xfffff, 0x1);
if (bAgcTableEn) {
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x38fff);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x38ffe);
} else {
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x380c3);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x40, 0xfffff, 0x28ce6);
}
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0xed, 0xfffff, 0x0);
/* set rssiAdjustVal for wifi module. */
if (bAgcTableEn)
rssiAdjustVal = 8;
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_U1_RSSI_ADJ_VAL_FOR_AGC_TABLE_ON, &rssiAdjustVal);
}
static void halbtc8723b2ant_AgcTable(
struct btc_coexist *pBtCoexist, bool bForceExec, bool bAgcTableEn
)
{
pCoexDm->bCurAgcTableEn = bAgcTableEn;
if (!bForceExec) {
if (pCoexDm->bPreAgcTableEn == pCoexDm->bCurAgcTableEn)
return;
}
halbtc8723b2ant_SetAgcTable(pBtCoexist, bAgcTableEn);
pCoexDm->bPreAgcTableEn = pCoexDm->bCurAgcTableEn;
}
static void halbtc8723b2ant_SetCoexTable(
struct btc_coexist *pBtCoexist,
u32 val0x6c0,
u32 val0x6c4,
u32 val0x6c8,
u8 val0x6cc
)
{
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c0, val0x6c0);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c4, val0x6c4);
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x6c8, val0x6c8);
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x6cc, val0x6cc);
}
static void halbtc8723b2ant_CoexTable(
struct btc_coexist *pBtCoexist,
bool bForceExec,
u32 val0x6c0,
u32 val0x6c4,
u32 val0x6c8,
u8 val0x6cc
)
{
pCoexDm->curVal0x6c0 = val0x6c0;
pCoexDm->curVal0x6c4 = val0x6c4;
pCoexDm->curVal0x6c8 = val0x6c8;
pCoexDm->curVal0x6cc = val0x6cc;
if (!bForceExec) {
if (
(pCoexDm->preVal0x6c0 == pCoexDm->curVal0x6c0) &&
(pCoexDm->preVal0x6c4 == pCoexDm->curVal0x6c4) &&
(pCoexDm->preVal0x6c8 == pCoexDm->curVal0x6c8) &&
(pCoexDm->preVal0x6cc == pCoexDm->curVal0x6cc)
)
return;
}
halbtc8723b2ant_SetCoexTable(pBtCoexist, val0x6c0, val0x6c4, val0x6c8, val0x6cc);
pCoexDm->preVal0x6c0 = pCoexDm->curVal0x6c0;
pCoexDm->preVal0x6c4 = pCoexDm->curVal0x6c4;
pCoexDm->preVal0x6c8 = pCoexDm->curVal0x6c8;
pCoexDm->preVal0x6cc = pCoexDm->curVal0x6cc;
}
static void halbtc8723b2ant_CoexTableWithType(
struct btc_coexist *pBtCoexist, bool bForceExec, u8 type
)
{
switch (type) {
case 0:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55555555, 0x55555555, 0xffff, 0x3);
break;
case 1:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55555555, 0x5afa5afa, 0xffff, 0x3);
break;
case 2:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5a5a5a5a, 0x5a5a5a5a, 0xffff, 0x3);
break;
case 3:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0xaaaaaaaa, 0xaaaaaaaa, 0xffff, 0x3);
break;
case 4:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0xffffffff, 0xffffffff, 0xffff, 0x3);
break;
case 5:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5fff5fff, 0x5fff5fff, 0xffff, 0x3);
break;
case 6:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5a5a5a5a, 0xffff, 0x3);
break;
case 7:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0xfafafafa, 0xffff, 0x3);
break;
case 8:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x5aea5aea, 0x5aea5aea, 0xffff, 0x3);
break;
case 9:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5aea5aea, 0xffff, 0x3);
break;
case 10:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5aff5aff, 0xffff, 0x3);
break;
case 11:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5a5f5a5f, 0xffff, 0x3);
break;
case 12:
halbtc8723b2ant_CoexTable(pBtCoexist, bForceExec, 0x55ff55ff, 0x5f5f5f5f, 0xffff, 0x3);
break;
default:
break;
}
}
static void halbtc8723b2ant_SetFwIgnoreWlanAct(
struct btc_coexist *pBtCoexist, bool bEnable
)
{
u8 H2C_Parameter[1] = {0};
if (bEnable)
H2C_Parameter[0] |= BIT0; /* function enable */
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x63, 1, H2C_Parameter);
}
static void halbtc8723b2ant_IgnoreWlanAct(
struct btc_coexist *pBtCoexist, bool bForceExec, bool bEnable
)
{
pCoexDm->bCurIgnoreWlanAct = bEnable;
if (!bForceExec) {
if (pCoexDm->bPreIgnoreWlanAct == pCoexDm->bCurIgnoreWlanAct)
return;
}
halbtc8723b2ant_SetFwIgnoreWlanAct(pBtCoexist, bEnable);
pCoexDm->bPreIgnoreWlanAct = pCoexDm->bCurIgnoreWlanAct;
}
static void halbtc8723b2ant_SetFwPstdma(
struct btc_coexist *pBtCoexist,
u8 byte1,
u8 byte2,
u8 byte3,
u8 byte4,
u8 byte5
)
{
u8 H2C_Parameter[5] = {0};
H2C_Parameter[0] = byte1;
H2C_Parameter[1] = byte2;
H2C_Parameter[2] = byte3;
H2C_Parameter[3] = byte4;
H2C_Parameter[4] = byte5;
pCoexDm->psTdmaPara[0] = byte1;
pCoexDm->psTdmaPara[1] = byte2;
pCoexDm->psTdmaPara[2] = byte3;
pCoexDm->psTdmaPara[3] = byte4;
pCoexDm->psTdmaPara[4] = byte5;
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x60, 5, H2C_Parameter);
}
static void halbtc8723b2ant_SwMechanism1(
struct btc_coexist *pBtCoexist,
bool bShrinkRxLPF,
bool bLowPenaltyRA,
bool bLimitedDIG,
bool bBTLNAConstrain
)
{
halbtc8723b2ant_RfShrink(pBtCoexist, NORMAL_EXEC, bShrinkRxLPF);
halbtc8723b2ant_LowPenaltyRa(pBtCoexist, NORMAL_EXEC, bLowPenaltyRA);
}
static void halbtc8723b2ant_SwMechanism2(
struct btc_coexist *pBtCoexist,
bool bAGCTableShift,
bool bADCBackOff,
bool bSWDACSwing,
u32 dacSwingLvl
)
{
halbtc8723b2ant_AgcTable(pBtCoexist, NORMAL_EXEC, bAGCTableShift);
halbtc8723b2ant_DacSwing(pBtCoexist, NORMAL_EXEC, bSWDACSwing, dacSwingLvl);
}
static void halbtc8723b2ant_SetAntPath(
struct btc_coexist *pBtCoexist, u8 antPosType, bool bInitHwCfg, bool bWifiOff
)
{
struct btc_board_info *pBoardInfo = &pBtCoexist->boardInfo;
u32 fwVer = 0, u4Tmp = 0;
bool bPgExtSwitch = false;
bool bUseExtSwitch = false;
u8 H2C_Parameter[2] = {0};
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_EXT_SWITCH, &bPgExtSwitch);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer); /* [31:16]=fw ver, [15:0]=fw sub ver */
if ((fwVer > 0 && fwVer < 0xc0000) || bPgExtSwitch)
bUseExtSwitch = true;
if (bInitHwCfg) {
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x39, 0x8, 0x1);
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x974, 0xff);
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x944, 0x3, 0x3);
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x930, 0x77);
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1);
if (fwVer >= 0x180000) {
/* Use H2C to set GNT_BT to LOW */
H2C_Parameter[0] = 0;
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
} else {
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x0);
}
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); /* WiFi TRx Mask off */
pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x01); /* BT TRx Mask off */
if (pBoardInfo->btdmAntPos == BTC_ANTENNA_AT_MAIN_PORT) {
/* tell firmware "no antenna inverse" */
H2C_Parameter[0] = 0;
} else {
/* tell firmware "antenna inverse" */
H2C_Parameter[0] = 1;
}
if (bUseExtSwitch) {
/* ext switch type */
H2C_Parameter[1] = 1;
} else {
/* int switch type */
H2C_Parameter[1] = 0;
}
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x65, 2, H2C_Parameter);
}
/* ext switch setting */
if (bUseExtSwitch) {
if (bInitHwCfg) {
/* 0x4c[23]= 0, 0x4c[24]= 1 Antenna control by WL/BT */
u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
u4Tmp &= ~BIT23;
u4Tmp |= BIT24;
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
}
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /* fixed internal switch S1->WiFi, S0->BT */
switch (antPosType) {
case BTC_ANT_WIFI_AT_MAIN:
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x1); /* ext switch main at wifi */
break;
case BTC_ANT_WIFI_AT_AUX:
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x92c, 0x3, 0x2); /* ext switch aux at wifi */
break;
}
} else { /* internal switch */
if (bInitHwCfg) {
/* 0x4c[23]= 0, 0x4c[24]= 1 Antenna control by WL/BT */
u4Tmp = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x4c);
u4Tmp |= BIT23;
u4Tmp &= ~BIT24;
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x4c, u4Tmp);
}
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x64, 0x1, 0x0); /* fixed external switch S1->Main, S0->Aux */
switch (antPosType) {
case BTC_ANT_WIFI_AT_MAIN:
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0); /* fixed internal switch S1->WiFi, S0->BT */
break;
case BTC_ANT_WIFI_AT_AUX:
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280); /* fixed internal switch S0->WiFi, S1->BT */
break;
}
}
}
static void halbtc8723b2ant_PsTdma(
struct btc_coexist *pBtCoexist, bool bForceExec, bool bTurnOn, u8 type
)
{
pCoexDm->bCurPsTdmaOn = bTurnOn;
pCoexDm->curPsTdma = type;
if (!bForceExec) {
if (
(pCoexDm->bPrePsTdmaOn == pCoexDm->bCurPsTdmaOn) &&
(pCoexDm->prePsTdma == pCoexDm->curPsTdma)
)
return;
}
if (bTurnOn) {
switch (type) {
case 1:
default:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90);
break;
case 2:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0xe1, 0x90);
break;
case 3:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1c, 0x3, 0xf1, 0x90);
break;
case 4:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x10, 0x03, 0xf1, 0x90);
break;
case 5:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0x60, 0x90);
break;
case 6:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0x60, 0x90);
break;
case 7:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1c, 0x3, 0x70, 0x90);
break;
case 8:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xa3, 0x10, 0x3, 0x70, 0x90);
break;
case 9:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90);
break;
case 10:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0xe1, 0x90);
break;
case 11:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0xa, 0xa, 0xe1, 0x90);
break;
case 12:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0xe1, 0x90);
break;
case 13:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0x60, 0x90);
break;
case 14:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x12, 0x12, 0x60, 0x90);
break;
case 15:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0xa, 0xa, 0x60, 0x90);
break;
case 16:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0x60, 0x90);
break;
case 17:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xa3, 0x2f, 0x2f, 0x60, 0x90);
break;
case 18:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x5, 0x5, 0xe1, 0x90);
break;
case 19:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x25, 0x25, 0xe1, 0x90);
break;
case 20:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x25, 0x25, 0x60, 0x90);
break;
case 21:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x15, 0x03, 0x70, 0x90);
break;
case 71:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0xe3, 0x1a, 0x1a, 0xe1, 0x90);
break;
}
} else {
/* disable PS tdma */
switch (type) {
case 0:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x40, 0x0);
break;
case 1:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x48, 0x0);
break;
default:
halbtc8723b2ant_SetFwPstdma(pBtCoexist, 0x0, 0x0, 0x0, 0x40, 0x0);
break;
}
}
/* update pre state */
pCoexDm->bPrePsTdmaOn = pCoexDm->bCurPsTdmaOn;
pCoexDm->prePsTdma = pCoexDm->curPsTdma;
}
static void halbtc8723b2ant_CoexAllOff(struct btc_coexist *pBtCoexist)
{
/* fw all off */
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
/* sw all off */
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
/* hw all off */
/* pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0); */
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
}
static void halbtc8723b2ant_InitCoexDm(struct btc_coexist *pBtCoexist)
{
/* force to reset coex mechanism */
halbtc8723b2ant_PsTdma(pBtCoexist, FORCE_EXEC, false, 1);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, FORCE_EXEC, 6);
halbtc8723b2ant_DecBtPwr(pBtCoexist, FORCE_EXEC, 0);
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
static void halbtc8723b2ant_ActionBtInquiry(struct btc_coexist *pBtCoexist)
{
bool bWifiConnected = false;
bool bLowPwrDisable = true;
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
if (bWifiConnected) {
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 3);
} else {
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
}
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, FORCE_EXEC, 6);
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
pCoexDm->bNeedRecover0x948 = true;
pCoexDm->backup0x948 = pBtCoexist->fBtcRead4Byte(pBtCoexist, 0x948);
halbtc8723b2ant_SetAntPath(pBtCoexist, BTC_ANT_WIFI_AT_AUX, false, false);
}
static bool halbtc8723b2ant_IsCommonAction(struct btc_coexist *pBtCoexist)
{
u8 btRssiState = BTC_RSSI_STATE_HIGH;
bool bCommon = false, bWifiConnected = false, bWifiBusy = false;
bool bBtHsOn = false, bLowPwrDisable = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_HS_OPERATION, &bBtHsOn);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_BUSY, &bWifiBusy);
if (!bWifiConnected) {
bLowPwrDisable = false;
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
bCommon = true;
} else {
if (BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE == pCoexDm->btStatus) {
bLowPwrDisable = false;
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb);
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
bCommon = true;
} else if (BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE == pCoexDm->btStatus) {
bLowPwrDisable = true;
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
if (bBtHsOn)
return false;
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb);
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
bCommon = true;
} else {
bLowPwrDisable = true;
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_ACT_DISABLE_LOW_POWER, &bLowPwrDisable);
if (bWifiBusy) {
bCommon = false;
} else {
if (bBtHsOn)
return false;
btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 21);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 0xb);
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
bCommon = true;
}
}
}
return bCommon;
}
static void halbtc8723b2ant_TdmaDurationAdjust(
struct btc_coexist *pBtCoexist, bool bScoHid, bool bTxPause, u8 maxInterval
)
{
static s32 up, dn, m, n, WaitCount;
s32 result; /* 0: no change, +1: increase WiFi duration, -1: decrease WiFi duration */
u8 retryCount = 0;
if (!pCoexDm->bAutoTdmaAdjust) {
pCoexDm->bAutoTdmaAdjust = true;
{
if (bScoHid) {
if (bTxPause) {
if (maxInterval == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(13);
else if (maxInterval == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(14);
else
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
} else {
if (maxInterval == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(9);
else if (maxInterval == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(10);
else
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
}
} else {
if (bTxPause) {
if (maxInterval == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(5);
else if (maxInterval == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(6);
else
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
} else {
if (maxInterval == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(1);
else if (maxInterval == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(2);
else
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
}
}
}
/* */
up = 0;
dn = 0;
m = 1;
n = 3;
result = 0;
WaitCount = 0;
} else {
/* acquire the BT TRx retry count from BT_Info byte2 */
retryCount = pCoexSta->btRetryCnt;
result = 0;
WaitCount++;
if (retryCount == 0) { /* no retry in the last 2-second duration */
up++;
dn--;
if (dn <= 0)
dn = 0;
if (up >= n) { /* if 連續 n 個2秒 retry count為0, 則調寬WiFi duration */
WaitCount = 0;
n = 3;
up = 0;
dn = 0;
result = 1;
}
} else if (retryCount <= 3) { /* <=3 retry in the last 2-second duration */
up--;
dn++;
if (up <= 0)
up = 0;
if (dn == 2) { /* if 連續 2 個2秒 retry count< 3, 則調窄WiFi duration */
if (WaitCount <= 2)
m++; /* 避免一直在兩個level中來回 */
else
m = 1;
if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */
m = 20;
n = 3 * m;
up = 0;
dn = 0;
WaitCount = 0;
result = -1;
}
} else { /* retry count > 3, 只要1次 retry count > 3, 則調窄WiFi duration */
if (WaitCount == 1)
m++; /* 避免一直在兩個level中來回 */
else
m = 1;
if (m >= 20) /* m 最大值 = 20 ' 最大120秒 recheck是否調整 WiFi duration. */
m = 20;
n = 3 * m;
up = 0;
dn = 0;
WaitCount = 0;
result = -1;
}
if (maxInterval == 1) {
if (bTxPause) {
if (pCoexDm->curPsTdma == 71)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(5);
else if (pCoexDm->curPsTdma == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(5);
else if (pCoexDm->curPsTdma == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(6);
else if (pCoexDm->curPsTdma == 3)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 4)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(8);
if (pCoexDm->curPsTdma == 9)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(13);
else if (pCoexDm->curPsTdma == 10)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(14);
else if (pCoexDm->curPsTdma == 11)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 12)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(16);
if (result == -1) {
if (pCoexDm->curPsTdma == 5)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(6);
else if (pCoexDm->curPsTdma == 6)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 7)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(8);
else if (pCoexDm->curPsTdma == 13)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(14);
else if (pCoexDm->curPsTdma == 14)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 15)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(16);
} else if (result == 1) {
if (pCoexDm->curPsTdma == 8)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 7)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(6);
else if (pCoexDm->curPsTdma == 6)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(5);
else if (pCoexDm->curPsTdma == 16)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 15)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(14);
else if (pCoexDm->curPsTdma == 14)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(13);
}
} else {
if (pCoexDm->curPsTdma == 5)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(71);
else if (pCoexDm->curPsTdma == 6)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(2);
else if (pCoexDm->curPsTdma == 7)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 8)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(4);
if (pCoexDm->curPsTdma == 13)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(9);
else if (pCoexDm->curPsTdma == 14)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(10);
else if (pCoexDm->curPsTdma == 15)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 16)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(12);
if (result == -1) {
if (pCoexDm->curPsTdma == 71)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(1);
else if (pCoexDm->curPsTdma == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(2);
else if (pCoexDm->curPsTdma == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 3)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(4);
else if (pCoexDm->curPsTdma == 9)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(10);
else if (pCoexDm->curPsTdma == 10)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 11)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(12);
} else if (result == 1) {
if (pCoexDm->curPsTdma == 4)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 3)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(2);
else if (pCoexDm->curPsTdma == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(1);
else if (pCoexDm->curPsTdma == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(71);
else if (pCoexDm->curPsTdma == 12)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 11)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(10);
else if (pCoexDm->curPsTdma == 10)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(9);
}
}
} else if (maxInterval == 2) {
if (bTxPause) {
if (pCoexDm->curPsTdma == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(6);
else if (pCoexDm->curPsTdma == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(6);
else if (pCoexDm->curPsTdma == 3)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 4)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(8);
if (pCoexDm->curPsTdma == 9)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(14);
else if (pCoexDm->curPsTdma == 10)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(14);
else if (pCoexDm->curPsTdma == 11)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 12)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(16);
if (result == -1) {
if (pCoexDm->curPsTdma == 5)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(6);
else if (pCoexDm->curPsTdma == 6)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 7)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(8);
else if (pCoexDm->curPsTdma == 13)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(14);
else if (pCoexDm->curPsTdma == 14)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 15)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(16);
} else if (result == 1) {
if (pCoexDm->curPsTdma == 8)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 7)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(6);
else if (pCoexDm->curPsTdma == 6)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(6);
else if (pCoexDm->curPsTdma == 16)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 15)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(14);
else if (pCoexDm->curPsTdma == 14)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(14);
}
} else {
if (pCoexDm->curPsTdma == 5)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(2);
else if (pCoexDm->curPsTdma == 6)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(2);
else if (pCoexDm->curPsTdma == 7)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 8)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(4);
if (pCoexDm->curPsTdma == 13)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(10);
else if (pCoexDm->curPsTdma == 14)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(10);
else if (pCoexDm->curPsTdma == 15)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 16)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(12);
if (result == -1) {
if (pCoexDm->curPsTdma == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(2);
else if (pCoexDm->curPsTdma == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 3)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(4);
else if (pCoexDm->curPsTdma == 9)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(10);
else if (pCoexDm->curPsTdma == 10)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 11)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(12);
} else if (result == 1) {
if (pCoexDm->curPsTdma == 4)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 3)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(2);
else if (pCoexDm->curPsTdma == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(2);
else if (pCoexDm->curPsTdma == 12)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 11)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(10);
else if (pCoexDm->curPsTdma == 10)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(10);
}
}
} else if (maxInterval == 3) {
if (bTxPause) {
if (pCoexDm->curPsTdma == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 3)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 4)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(8);
if (pCoexDm->curPsTdma == 9)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 10)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 11)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 12)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(16);
if (result == -1) {
if (pCoexDm->curPsTdma == 5)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 6)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 7)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(8);
else if (pCoexDm->curPsTdma == 13)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 14)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 15)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(16);
} else if (result == 1) {
if (pCoexDm->curPsTdma == 8)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 7)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 6)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(7);
else if (pCoexDm->curPsTdma == 16)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 15)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
else if (pCoexDm->curPsTdma == 14)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(15);
}
} else {
if (pCoexDm->curPsTdma == 5)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 6)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 7)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 8)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(4);
if (pCoexDm->curPsTdma == 13)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 14)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 15)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 16)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(12);
if (result == -1) {
if (pCoexDm->curPsTdma == 1)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 3)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(4);
else if (pCoexDm->curPsTdma == 9)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 10)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 11)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(12);
} else if (result == 1) {
if (pCoexDm->curPsTdma == 4)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 3)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 2)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(3);
else if (pCoexDm->curPsTdma == 12)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 11)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
else if (pCoexDm->curPsTdma == 10)
HAL_BTC8723B2ANT_DMA_DURATION_ADJUST(11);
}
}
}
}
/* if current PsTdma not match with the recorded one (when scan, dhcp...), */
/* then we have to adjust it back to the previous record one. */
if (pCoexDm->curPsTdma != pCoexDm->psTdmaDuAdjType) {
bool bScan = false, bLink = false, bRoam = false;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_SCAN, &bScan);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_LINK, &bLink);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_ROAM, &bRoam);
if (!bScan && !bLink && !bRoam)
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, pCoexDm->psTdmaDuAdjType);
}
}
/* SCO only or SCO+PAN(HS) */
static void halbtc8723b2ant_ActionSco(struct btc_coexist *pBtCoexist)
{
u8 wifiRssiState, btRssiState;
u32 wifiBw;
wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 4);
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (BTC_WIFI_BW_LEGACY == wifiBw) /* for SCO quality at 11b/g mode */
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 2);
else /* for SCO quality & wifi performance balance at 11n mode */
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 8);
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 0); /* for voice quality */
/* sw mechanism */
if (BTC_WIFI_BW_HT40 == wifiBw) {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x4);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, true, 0x4);
}
} else {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x4);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, true, 0x4);
}
}
}
static void halbtc8723b2ant_ActionHid(struct btc_coexist *pBtCoexist)
{
u8 wifiRssiState, btRssiState;
u32 wifiBw;
wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (BTC_WIFI_BW_LEGACY == wifiBw) /* for HID at 11b/g mode */
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
else /* for HID quality & wifi performance balance at 11n mode */
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 9);
if (
(btRssiState == BTC_RSSI_STATE_HIGH) ||
(btRssiState == BTC_RSSI_STATE_STAY_HIGH)
)
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 9);
else
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 13);
/* sw mechanism */
if (BTC_WIFI_BW_HT40 == wifiBw) {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
} else {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
}
}
/* A2DP only / PAN(EDR) only/ A2DP+PAN(HS) */
static void halbtc8723b2ant_ActionA2dp(struct btc_coexist *pBtCoexist)
{
u8 wifiRssiState, wifiRssiState1, btRssiState;
u32 wifiBw;
u8 apNum = 0;
wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
wifiRssiState1 = halbtc8723b2ant_WifiRssiState(pBtCoexist, 1, 2, 40, 0);
btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
/* define the office environment */
if (apNum >= 10 && BTC_RSSI_HIGH(wifiRssiState1)) {
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
/* sw mechanism */
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (BTC_WIFI_BW_HT40 == wifiBw) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, true, 0x18);
}
return;
}
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
if (
(btRssiState == BTC_RSSI_STATE_HIGH) ||
(btRssiState == BTC_RSSI_STATE_STAY_HIGH)
)
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, false, 1);
else
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 1);
/* sw mechanism */
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (BTC_WIFI_BW_HT40 == wifiBw) {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
} else {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
}
}
static void halbtc8723b2ant_ActionA2dpPanHs(struct btc_coexist *pBtCoexist)
{
u8 wifiRssiState, btRssiState;
u32 wifiBw;
wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 2);
/* sw mechanism */
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (BTC_WIFI_BW_HT40 == wifiBw) {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
} else {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
}
}
static void halbtc8723b2ant_ActionPanEdr(struct btc_coexist *pBtCoexist)
{
u8 wifiRssiState, btRssiState;
u32 wifiBw;
wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 10);
if (
(btRssiState == BTC_RSSI_STATE_HIGH) ||
(btRssiState == BTC_RSSI_STATE_STAY_HIGH)
)
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 1);
else
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, true, 5);
/* sw mechanism */
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (BTC_WIFI_BW_HT40 == wifiBw) {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
} else {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
}
}
/* PAN(HS) only */
static void halbtc8723b2ant_ActionPanHs(struct btc_coexist *pBtCoexist)
{
u8 wifiRssiState, btRssiState;
u32 wifiBw;
wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
halbtc8723b2ant_PsTdma(pBtCoexist, NORMAL_EXEC, false, 1);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (BTC_WIFI_BW_HT40 == wifiBw) {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
} else {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
}
}
/* PAN(EDR)+A2DP */
static void halbtc8723b2ant_ActionPanEdrA2dp(struct btc_coexist *pBtCoexist)
{
u8 wifiRssiState, btRssiState;
u32 wifiBw;
wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (
(btRssiState == BTC_RSSI_STATE_HIGH) ||
(btRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 12);
if (BTC_WIFI_BW_HT40 == wifiBw)
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 3);
else
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, false, 3);
} else {
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, false, true, 3);
}
/* sw mechanism */
if (BTC_WIFI_BW_HT40 == wifiBw) {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
} else {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, false, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
}
}
static void halbtc8723b2ant_ActionPanEdrHid(struct btc_coexist *pBtCoexist)
{
u8 wifiRssiState, btRssiState;
u32 wifiBw;
wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
if (
(btRssiState == BTC_RSSI_STATE_HIGH) ||
(btRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
if (BTC_WIFI_BW_HT40 == wifiBw) {
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 3);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 11);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780);
} else {
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
}
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 2);
} else {
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 11);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2);
}
/* sw mechanism */
if (BTC_WIFI_BW_HT40 == wifiBw) {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
} else {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
}
}
/* HID+A2DP+PAN(EDR) */
static void halbtc8723b2ant_ActionHidA2dpPanEdr(struct btc_coexist *pBtCoexist)
{
u8 wifiRssiState, btRssiState;
u32 wifiBw;
wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, false, 0x8);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
if (
(btRssiState == BTC_RSSI_STATE_HIGH) ||
(btRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
if (BTC_WIFI_BW_HT40 == wifiBw)
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2);
else
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 3);
} else
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 3);
/* sw mechanism */
if (BTC_WIFI_BW_HT40 == wifiBw) {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
} else {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
}
}
static void halbtc8723b2ant_ActionHidA2dp(struct btc_coexist *pBtCoexist)
{
u8 wifiRssiState, btRssiState;
u32 wifiBw;
u8 apNum = 0;
wifiRssiState = halbtc8723b2ant_WifiRssiState(pBtCoexist, 0, 2, 15, 0);
/* btRssiState = halbtc8723b2ant_BtRssiState(2, 29, 0); */
btRssiState = halbtc8723b2ant_BtRssiState(3, 29, 37);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x0);
halbtc8723b2ant_LimitedRx(pBtCoexist, NORMAL_EXEC, false, true, 0x5);
halbtc8723b2ant_FwDacSwingLvl(pBtCoexist, NORMAL_EXEC, 6);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (BTC_WIFI_BW_LEGACY == wifiBw) {
if (BTC_RSSI_HIGH(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else if (BTC_RSSI_MEDIUM(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
} else {
/* only 802.11N mode we have to dec bt power to 4 degree */
if (BTC_RSSI_HIGH(btRssiState)) {
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
/* need to check ap Number of Not */
if (apNum < 10)
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 4);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
} else if (BTC_RSSI_MEDIUM(btRssiState))
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 2);
else
halbtc8723b2ant_DecBtPwr(pBtCoexist, NORMAL_EXEC, 0);
}
halbtc8723b2ant_CoexTableWithType(pBtCoexist, NORMAL_EXEC, 7);
if (
(btRssiState == BTC_RSSI_STATE_HIGH) ||
(btRssiState == BTC_RSSI_STATE_STAY_HIGH)
)
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, false, 2);
else
halbtc8723b2ant_TdmaDurationAdjust(pBtCoexist, true, true, 2);
/* sw mechanism */
if (BTC_WIFI_BW_HT40 == wifiBw) {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, true, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
} else {
if (
(wifiRssiState == BTC_RSSI_STATE_HIGH) ||
(wifiRssiState == BTC_RSSI_STATE_STAY_HIGH)
) {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, true, false, false, 0x18);
} else {
halbtc8723b2ant_SwMechanism1(pBtCoexist, false, true, false, false);
halbtc8723b2ant_SwMechanism2(pBtCoexist, false, false, false, 0x18);
}
}
}
static void halbtc8723b2ant_RunCoexistMechanism(struct btc_coexist *pBtCoexist)
{
u8 algorithm = 0;
if (pBtCoexist->bManualControl) {
return;
}
if (pCoexSta->bUnderIps) {
return;
}
algorithm = halbtc8723b2ant_ActionAlgorithm(pBtCoexist);
if (pCoexSta->bC2hBtInquiryPage && (BT_8723B_2ANT_COEX_ALGO_PANHS != algorithm)) {
halbtc8723b2ant_ActionBtInquiry(pBtCoexist);
return;
} else {
if (pCoexDm->bNeedRecover0x948) {
pCoexDm->bNeedRecover0x948 = false;
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, pCoexDm->backup0x948);
}
}
pCoexDm->curAlgorithm = algorithm;
if (halbtc8723b2ant_IsCommonAction(pBtCoexist)) {
pCoexDm->bAutoTdmaAdjust = false;
} else {
if (pCoexDm->curAlgorithm != pCoexDm->preAlgorithm) {
pCoexDm->bAutoTdmaAdjust = false;
}
switch (pCoexDm->curAlgorithm) {
case BT_8723B_2ANT_COEX_ALGO_SCO:
halbtc8723b2ant_ActionSco(pBtCoexist);
break;
case BT_8723B_2ANT_COEX_ALGO_HID:
halbtc8723b2ant_ActionHid(pBtCoexist);
break;
case BT_8723B_2ANT_COEX_ALGO_A2DP:
halbtc8723b2ant_ActionA2dp(pBtCoexist);
break;
case BT_8723B_2ANT_COEX_ALGO_A2DP_PANHS:
halbtc8723b2ant_ActionA2dpPanHs(pBtCoexist);
break;
case BT_8723B_2ANT_COEX_ALGO_PANEDR:
halbtc8723b2ant_ActionPanEdr(pBtCoexist);
break;
case BT_8723B_2ANT_COEX_ALGO_PANHS:
halbtc8723b2ant_ActionPanHs(pBtCoexist);
break;
case BT_8723B_2ANT_COEX_ALGO_PANEDR_A2DP:
halbtc8723b2ant_ActionPanEdrA2dp(pBtCoexist);
break;
case BT_8723B_2ANT_COEX_ALGO_PANEDR_HID:
halbtc8723b2ant_ActionPanEdrHid(pBtCoexist);
break;
case BT_8723B_2ANT_COEX_ALGO_HID_A2DP_PANEDR:
halbtc8723b2ant_ActionHidA2dpPanEdr(pBtCoexist);
break;
case BT_8723B_2ANT_COEX_ALGO_HID_A2DP:
halbtc8723b2ant_ActionHidA2dp(pBtCoexist);
break;
default:
halbtc8723b2ant_CoexAllOff(pBtCoexist);
break;
}
pCoexDm->preAlgorithm = pCoexDm->curAlgorithm;
}
}
static void halbtc8723b2ant_WifiOffHwCfg(struct btc_coexist *pBtCoexist)
{
bool bIsInMpMode = false;
u8 H2C_Parameter[2] = {0};
u32 fwVer = 0;
/* set wlan_act to low */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
pBtCoexist->fBtcSetRfReg(pBtCoexist, BTC_RF_A, 0x1, 0xfffff, 0x780); /* WiFi goto standby while GNT_BT 0-->1 */
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
if (fwVer >= 0x180000) {
/* Use H2C to set GNT_BT to HIGH */
H2C_Parameter[0] = 1;
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x6E, 1, H2C_Parameter);
} else
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_IS_IN_MP_MODE, &bIsInMpMode);
if (!bIsInMpMode)
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x0); /* BT select s0/s1 is controlled by BT */
else
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x67, 0x20, 0x1); /* BT select s0/s1 is controlled by WiFi */
}
static void halbtc8723b2ant_InitHwConfig(struct btc_coexist *pBtCoexist, bool bBackUp)
{
u8 u1Tmp = 0;
/* backup rf 0x1e value */
pCoexDm->btRf0x1eBackup =
pBtCoexist->fBtcGetRfReg(pBtCoexist, BTC_RF_A, 0x1e, 0xfffff);
/* 0x790[5:0]= 0x5 */
u1Tmp = pBtCoexist->fBtcRead1Byte(pBtCoexist, 0x790);
u1Tmp &= 0xc0;
u1Tmp |= 0x5;
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x790, u1Tmp);
/* Antenna config */
halbtc8723b2ant_SetAntPath(pBtCoexist, BTC_ANT_WIFI_AT_MAIN, true, false);
/* PTA parameter */
halbtc8723b2ant_CoexTableWithType(pBtCoexist, FORCE_EXEC, 0);
/* Enable counter statistics */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0xc); /* 0x76e[3] = 1, WLAN_Act control by PTA */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x778, 0x3);
pBtCoexist->fBtcWrite1ByteBitMask(pBtCoexist, 0x40, 0x20, 0x1);
}
/* */
/* work around function start with wa_halbtc8723b2ant_ */
/* */
/* */
/* extern function start with EXhalbtc8723b2ant_ */
/* */
void EXhalbtc8723b2ant_PowerOnSetting(struct btc_coexist *pBtCoexist)
{
struct btc_board_info *pBoardInfo = &pBtCoexist->boardInfo;
u8 u1Tmp = 0x4; /* Set BIT2 by default since it's 2ant case */
u16 u2Tmp = 0x0;
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x67, 0x20);
/* enable BB, REG_SYS_FUNC_EN such that we can write 0x948 correctly. */
u2Tmp = pBtCoexist->fBtcRead2Byte(pBtCoexist, 0x2);
pBtCoexist->fBtcWrite2Byte(pBtCoexist, 0x2, u2Tmp | BIT0 | BIT1);
/* set GRAN_BT = 1 */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x765, 0x18);
/* set WLAN_ACT = 0 */
pBtCoexist->fBtcWrite1Byte(pBtCoexist, 0x76e, 0x4);
/* */
/* S0 or S1 setting and Local register setting(By the setting fw can get ant number, S0/S1, ... info) */
/* Local setting bit define */
/* BIT0: "0" for no antenna inverse; "1" for antenna inverse */
/* BIT1: "0" for internal switch; "1" for external switch */
/* BIT2: "0" for one antenna; "1" for two antenna */
/* NOTE: here default all internal switch and 1-antenna ==> BIT1 = 0 and BIT2 = 0 */
if (pBtCoexist->chipInterface == BTC_INTF_USB) {
/* fixed at S0 for USB interface */
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
u1Tmp |= 0x1; /* antenna inverse */
pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0xfe08, u1Tmp);
pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
} else {
/* for PCIE and SDIO interface, we check efuse 0xc3[6] */
if (pBoardInfo->singleAntPath == 0) {
/* set to S1 */
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x280);
pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_MAIN_PORT;
} else if (pBoardInfo->singleAntPath == 1) {
/* set to S0 */
pBtCoexist->fBtcWrite4Byte(pBtCoexist, 0x948, 0x0);
u1Tmp |= 0x1; /* antenna inverse */
pBoardInfo->btdmAntPos = BTC_ANTENNA_AT_AUX_PORT;
}
if (pBtCoexist->chipInterface == BTC_INTF_PCI)
pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x384, u1Tmp);
else if (pBtCoexist->chipInterface == BTC_INTF_SDIO)
pBtCoexist->fBtcWriteLocalReg1Byte(pBtCoexist, 0x60, u1Tmp);
}
}
void EXhalbtc8723b2ant_InitHwConfig(struct btc_coexist *pBtCoexist, bool bWifiOnly)
{
halbtc8723b2ant_InitHwConfig(pBtCoexist, true);
}
void EXhalbtc8723b2ant_InitCoexDm(struct btc_coexist *pBtCoexist)
{
halbtc8723b2ant_InitCoexDm(pBtCoexist);
}
void EXhalbtc8723b2ant_IpsNotify(struct btc_coexist *pBtCoexist, u8 type)
{
if (BTC_IPS_ENTER == type) {
pCoexSta->bUnderIps = true;
halbtc8723b2ant_WifiOffHwCfg(pBtCoexist);
halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true);
halbtc8723b2ant_CoexAllOff(pBtCoexist);
} else if (BTC_IPS_LEAVE == type) {
pCoexSta->bUnderIps = false;
halbtc8723b2ant_InitHwConfig(pBtCoexist, false);
halbtc8723b2ant_InitCoexDm(pBtCoexist);
halbtc8723b2ant_QueryBtInfo(pBtCoexist);
}
}
void EXhalbtc8723b2ant_LpsNotify(struct btc_coexist *pBtCoexist, u8 type)
{
if (BTC_LPS_ENABLE == type) {
pCoexSta->bUnderLps = true;
} else if (BTC_LPS_DISABLE == type) {
pCoexSta->bUnderLps = false;
}
}
void EXhalbtc8723b2ant_ScanNotify(struct btc_coexist *pBtCoexist, u8 type)
{
if (BTC_SCAN_START == type) {
} else if (BTC_SCAN_FINISH == type) {
}
}
void EXhalbtc8723b2ant_ConnectNotify(struct btc_coexist *pBtCoexist, u8 type)
{
if (BTC_ASSOCIATE_START == type) {
} else if (BTC_ASSOCIATE_FINISH == type) {
}
}
void EXhalbtc8723b2ant_MediaStatusNotify(struct btc_coexist *pBtCoexist, u8 type)
{
u8 H2C_Parameter[3] = {0};
u32 wifiBw;
u8 wifiCentralChnl;
u8 apNum = 0;
/* only 2.4G we need to inform bt the chnl mask */
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_WIFI_CENTRAL_CHNL, &wifiCentralChnl);
if ((BTC_MEDIA_CONNECT == type) && (wifiCentralChnl <= 14)) {
H2C_Parameter[0] = 0x1;
H2C_Parameter[1] = wifiCentralChnl;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_BW, &wifiBw);
if (BTC_WIFI_BW_HT40 == wifiBw)
H2C_Parameter[2] = 0x30;
else {
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U1_AP_NUM, &apNum);
if (apNum < 10)
H2C_Parameter[2] = 0x30;
else
H2C_Parameter[2] = 0x20;
}
}
pCoexDm->wifiChnlInfo[0] = H2C_Parameter[0];
pCoexDm->wifiChnlInfo[1] = H2C_Parameter[1];
pCoexDm->wifiChnlInfo[2] = H2C_Parameter[2];
pBtCoexist->fBtcFillH2c(pBtCoexist, 0x66, 3, H2C_Parameter);
}
void EXhalbtc8723b2ant_SpecialPacketNotify(struct btc_coexist *pBtCoexist, u8 type)
{
}
void EXhalbtc8723b2ant_BtInfoNotify(
struct btc_coexist *pBtCoexist, u8 *tmpBuf, u8 length
)
{
u8 btInfo = 0;
u8 i, rspSource = 0;
bool bBtBusy = false, bLimitedDig = false;
bool bWifiConnected = false;
pCoexSta->bC2hBtInfoReqSent = false;
rspSource = tmpBuf[0] & 0xf;
if (rspSource >= BT_INFO_SRC_8723B_2ANT_MAX)
rspSource = BT_INFO_SRC_8723B_2ANT_WIFI_FW;
pCoexSta->btInfoC2hCnt[rspSource]++;
for (i = 0; i < length; i++) {
pCoexSta->btInfoC2h[rspSource][i] = tmpBuf[i];
if (i == 1)
btInfo = tmpBuf[i];
}
if (pBtCoexist->bManualControl) {
return;
}
if (BT_INFO_SRC_8723B_2ANT_WIFI_FW != rspSource) {
pCoexSta->btRetryCnt = pCoexSta->btInfoC2h[rspSource][2] & 0xf; /* [3:0] */
pCoexSta->btRssi = pCoexSta->btInfoC2h[rspSource][3] * 2 + 10;
pCoexSta->btInfoExt = pCoexSta->btInfoC2h[rspSource][4];
pCoexSta->bBtTxRxMask = (pCoexSta->btInfoC2h[rspSource][2] & 0x40);
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TX_RX_MASK, &pCoexSta->bBtTxRxMask);
if (pCoexSta->bBtTxRxMask) {
/* BT into is responded by BT FW and BT RF REG 0x3C != 0x01 => Need to switch BT TRx Mask */
pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x01);
}
/* Here we need to resend some wifi info to BT */
/* because bt is reset and loss of the info. */
if ((pCoexSta->btInfoExt & BIT1)) {
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_BL_WIFI_CONNECTED, &bWifiConnected);
if (bWifiConnected)
EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_CONNECT);
else
EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
}
if ((pCoexSta->btInfoExt & BIT3)) {
halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, false);
} else {
/* BT already NOT ignore Wlan active, do nothing here. */
}
}
/* check BIT2 first ==> check if bt is under inquiry or page scan */
if (btInfo & BT_INFO_8723B_2ANT_B_INQ_PAGE)
pCoexSta->bC2hBtInquiryPage = true;
else
pCoexSta->bC2hBtInquiryPage = false;
/* set link exist status */
if (!(btInfo & BT_INFO_8723B_2ANT_B_CONNECTION)) {
pCoexSta->bBtLinkExist = false;
pCoexSta->bPanExist = false;
pCoexSta->bA2dpExist = false;
pCoexSta->bHidExist = false;
pCoexSta->bScoExist = false;
} else { /* connection exists */
pCoexSta->bBtLinkExist = true;
if (btInfo & BT_INFO_8723B_2ANT_B_FTP)
pCoexSta->bPanExist = true;
else
pCoexSta->bPanExist = false;
if (btInfo & BT_INFO_8723B_2ANT_B_A2DP)
pCoexSta->bA2dpExist = true;
else
pCoexSta->bA2dpExist = false;
if (btInfo & BT_INFO_8723B_2ANT_B_HID)
pCoexSta->bHidExist = true;
else
pCoexSta->bHidExist = false;
if (btInfo & BT_INFO_8723B_2ANT_B_SCO_ESCO)
pCoexSta->bScoExist = true;
else
pCoexSta->bScoExist = false;
}
halbtc8723b2ant_UpdateBtLinkInfo(pBtCoexist);
if (!(btInfo & BT_INFO_8723B_2ANT_B_CONNECTION)) {
pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_NON_CONNECTED_IDLE;
} else if (btInfo == BT_INFO_8723B_2ANT_B_CONNECTION) { /* connection exists but no busy */
pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_CONNECTED_IDLE;
} else if (
(btInfo & BT_INFO_8723B_2ANT_B_SCO_ESCO) ||
(btInfo & BT_INFO_8723B_2ANT_B_SCO_BUSY)
) {
pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_SCO_BUSY;
} else if (btInfo & BT_INFO_8723B_2ANT_B_ACL_BUSY) {
pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_ACL_BUSY;
} else {
pCoexDm->btStatus = BT_8723B_2ANT_BT_STATUS_MAX;
}
if (
(BT_8723B_2ANT_BT_STATUS_ACL_BUSY == pCoexDm->btStatus) ||
(BT_8723B_2ANT_BT_STATUS_SCO_BUSY == pCoexDm->btStatus) ||
(BT_8723B_2ANT_BT_STATUS_ACL_SCO_BUSY == pCoexDm->btStatus)
) {
bBtBusy = true;
bLimitedDig = true;
} else {
bBtBusy = false;
bLimitedDig = false;
}
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_TRAFFIC_BUSY, &bBtBusy);
pCoexDm->bLimitedDig = bLimitedDig;
pBtCoexist->fBtcSet(pBtCoexist, BTC_SET_BL_BT_LIMITED_DIG, &bLimitedDig);
halbtc8723b2ant_RunCoexistMechanism(pBtCoexist);
}
void EXhalbtc8723b2ant_HaltNotify(struct btc_coexist *pBtCoexist)
{
halbtc8723b2ant_WifiOffHwCfg(pBtCoexist);
pBtCoexist->fBtcSetBtReg(pBtCoexist, BTC_BT_REG_RF, 0x3c, 0x15); /* BT goto standby while GNT_BT 1-->0 */
halbtc8723b2ant_IgnoreWlanAct(pBtCoexist, FORCE_EXEC, true);
EXhalbtc8723b2ant_MediaStatusNotify(pBtCoexist, BTC_MEDIA_DISCONNECT);
}
void EXhalbtc8723b2ant_PnpNotify(struct btc_coexist *pBtCoexist, u8 pnpState)
{
if (BTC_WIFI_PNP_SLEEP == pnpState) {
} else if (BTC_WIFI_PNP_WAKE_UP == pnpState) {
halbtc8723b2ant_InitHwConfig(pBtCoexist, false);
halbtc8723b2ant_InitCoexDm(pBtCoexist);
halbtc8723b2ant_QueryBtInfo(pBtCoexist);
}
}
void EXhalbtc8723b2ant_Periodical(struct btc_coexist *pBtCoexist)
{
static u8 disVerInfoCnt;
u32 fwVer = 0, btPatchVer = 0;
if (disVerInfoCnt <= 5) {
disVerInfoCnt += 1;
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_BT_PATCH_VER, &btPatchVer);
pBtCoexist->fBtcGet(pBtCoexist, BTC_GET_U4_WIFI_FW_VER, &fwVer);
}
if (
halbtc8723b2ant_IsWifiStatusChanged(pBtCoexist) ||
pCoexDm->bAutoTdmaAdjust
)
halbtc8723b2ant_RunCoexistMechanism(pBtCoexist);
}
| linux-master | drivers/staging/rtl8723bs/hal/HalBtc8723b2Ant.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include "odm_precomp.h"
void odm_DynamicBBPowerSavingInit(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct ps_t *pDM_PSTable = &pDM_Odm->DM_PSTable;
pDM_PSTable->PreCCAState = CCA_MAX;
pDM_PSTable->CurCCAState = CCA_MAX;
pDM_PSTable->PreRFState = RF_MAX;
pDM_PSTable->CurRFState = RF_MAX;
pDM_PSTable->Rssi_val_min = 0;
pDM_PSTable->initialize = 0;
}
void ODM_RF_Saving(void *pDM_VOID, u8 bForceInNormal)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct ps_t *pDM_PSTable = &pDM_Odm->DM_PSTable;
u8 Rssi_Up_bound = 30;
u8 Rssi_Low_bound = 25;
if (pDM_Odm->PatchID == 40) { /* RT_CID_819x_FUNAI_TV */
Rssi_Up_bound = 50;
Rssi_Low_bound = 45;
}
if (pDM_PSTable->initialize == 0) {
pDM_PSTable->Reg874 = (PHY_QueryBBReg(pDM_Odm->Adapter, 0x874, bMaskDWord)&0x1CC000)>>14;
pDM_PSTable->RegC70 = (PHY_QueryBBReg(pDM_Odm->Adapter, 0xc70, bMaskDWord)&BIT3)>>3;
pDM_PSTable->Reg85C = (PHY_QueryBBReg(pDM_Odm->Adapter, 0x85c, bMaskDWord)&0xFF000000)>>24;
pDM_PSTable->RegA74 = (PHY_QueryBBReg(pDM_Odm->Adapter, 0xa74, bMaskDWord)&0xF000)>>12;
/* Reg818 = PHY_QueryBBReg(padapter, 0x818, bMaskDWord); */
pDM_PSTable->initialize = 1;
}
if (!bForceInNormal) {
if (pDM_Odm->RSSI_Min != 0xFF) {
if (pDM_PSTable->PreRFState == RF_Normal) {
if (pDM_Odm->RSSI_Min >= Rssi_Up_bound)
pDM_PSTable->CurRFState = RF_Save;
else
pDM_PSTable->CurRFState = RF_Normal;
} else {
if (pDM_Odm->RSSI_Min <= Rssi_Low_bound)
pDM_PSTable->CurRFState = RF_Normal;
else
pDM_PSTable->CurRFState = RF_Save;
}
} else
pDM_PSTable->CurRFState = RF_MAX;
} else
pDM_PSTable->CurRFState = RF_Normal;
if (pDM_PSTable->PreRFState != pDM_PSTable->CurRFState) {
if (pDM_PSTable->CurRFState == RF_Save) {
PHY_SetBBReg(pDM_Odm->Adapter, 0x874, 0x1C0000, 0x2); /* Reg874[20:18]=3'b010 */
PHY_SetBBReg(pDM_Odm->Adapter, 0xc70, BIT3, 0); /* RegC70[3]= 1'b0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x85c, 0xFF000000, 0x63); /* Reg85C[31:24]= 0x63 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x874, 0xC000, 0x2); /* Reg874[15:14]=2'b10 */
PHY_SetBBReg(pDM_Odm->Adapter, 0xa74, 0xF000, 0x3); /* RegA75[7:4]= 0x3 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x818, BIT28, 0x0); /* Reg818[28]= 1'b0 */
PHY_SetBBReg(pDM_Odm->Adapter, 0x818, BIT28, 0x1); /* Reg818[28]= 1'b1 */
} else {
PHY_SetBBReg(pDM_Odm->Adapter, 0x874, 0x1CC000, pDM_PSTable->Reg874);
PHY_SetBBReg(pDM_Odm->Adapter, 0xc70, BIT3, pDM_PSTable->RegC70);
PHY_SetBBReg(pDM_Odm->Adapter, 0x85c, 0xFF000000, pDM_PSTable->Reg85C);
PHY_SetBBReg(pDM_Odm->Adapter, 0xa74, 0xF000, pDM_PSTable->RegA74);
PHY_SetBBReg(pDM_Odm->Adapter, 0x818, BIT28, 0x0);
}
pDM_PSTable->PreRFState = pDM_PSTable->CurRFState;
}
}
| linux-master | drivers/staging/rtl8723bs/hal/odm_DynamicBBPowerSaving.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include "odm_precomp.h"
void odm_ConfigRFReg_8723B(
struct dm_odm_t *pDM_Odm,
u32 Addr,
u32 Data,
enum rf_path RF_PATH,
u32 RegAddr
)
{
if (Addr == 0xfe || Addr == 0xffe)
msleep(50);
else {
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH, RegAddr, bRFRegOffsetMask, Data);
/* Add 1us delay between BB/RF register setting. */
udelay(1);
/* For disable/enable test in high temperature, the B6 value will fail to fill. Suggestion by BB Stanley, 2013.06.25. */
if (Addr == 0xb6) {
u32 getvalue = 0;
u8 count = 0;
getvalue = PHY_QueryRFReg(
pDM_Odm->Adapter, RF_PATH, Addr, bMaskDWord
);
udelay(1);
while ((getvalue>>8) != (Data>>8)) {
count++;
PHY_SetRFReg(pDM_Odm->Adapter, RF_PATH, RegAddr, bRFRegOffsetMask, Data);
udelay(1);
getvalue = PHY_QueryRFReg(pDM_Odm->Adapter, RF_PATH, Addr, bMaskDWord);
if (count > 5)
break;
}
}
if (Addr == 0xb2) {
u32 getvalue = 0;
u8 count = 0;
getvalue = PHY_QueryRFReg(
pDM_Odm->Adapter, RF_PATH, Addr, bMaskDWord
);
udelay(1);
while (getvalue != Data) {
count++;
PHY_SetRFReg(
pDM_Odm->Adapter,
RF_PATH,
RegAddr,
bRFRegOffsetMask,
Data
);
udelay(1);
/* Do LCK againg */
PHY_SetRFReg(
pDM_Odm->Adapter,
RF_PATH,
0x18,
bRFRegOffsetMask,
0x0fc07
);
udelay(1);
getvalue = PHY_QueryRFReg(
pDM_Odm->Adapter, RF_PATH, Addr, bMaskDWord
);
if (count > 5)
break;
}
}
}
}
void odm_ConfigRF_RadioA_8723B(struct dm_odm_t *pDM_Odm, u32 Addr, u32 Data)
{
u32 content = 0x1000; /* RF_Content: radioa_txt */
u32 maskforPhySet = (u32)(content&0xE000);
odm_ConfigRFReg_8723B(
pDM_Odm,
Addr,
Data,
RF_PATH_A,
Addr|maskforPhySet
);
}
void odm_ConfigMAC_8723B(struct dm_odm_t *pDM_Odm, u32 Addr, u8 Data)
{
rtw_write8(pDM_Odm->Adapter, Addr, Data);
}
void odm_ConfigBB_AGC_8723B(
struct dm_odm_t *pDM_Odm,
u32 Addr,
u32 Bitmask,
u32 Data
)
{
PHY_SetBBReg(pDM_Odm->Adapter, Addr, Bitmask, Data);
/* Add 1us delay between BB/RF register setting. */
udelay(1);
}
void odm_ConfigBB_PHY_REG_PG_8723B(
struct dm_odm_t *pDM_Odm,
u32 RfPath,
u32 Addr,
u32 Bitmask,
u32 Data
)
{
if (Addr == 0xfe || Addr == 0xffe)
msleep(50);
else {
PHY_StoreTxPowerByRate(pDM_Odm->Adapter, RfPath, Addr, Bitmask, Data);
}
}
void odm_ConfigBB_PHY_8723B(
struct dm_odm_t *pDM_Odm,
u32 Addr,
u32 Bitmask,
u32 Data
)
{
if (Addr == 0xfe)
msleep(50);
else if (Addr == 0xfd)
mdelay(5);
else if (Addr == 0xfc)
mdelay(1);
else if (Addr == 0xfb)
udelay(50);
else if (Addr == 0xfa)
udelay(5);
else if (Addr == 0xf9)
udelay(1);
else {
PHY_SetBBReg(pDM_Odm->Adapter, Addr, Bitmask, Data);
}
/* Add 1us delay between BB/RF register setting. */
udelay(1);
}
void odm_ConfigBB_TXPWR_LMT_8723B(
struct dm_odm_t *pDM_Odm,
u8 *Regulation,
u8 *Bandwidth,
u8 *RateSection,
u8 *RfPath,
u8 *Channel,
u8 *PowerLimit
)
{
PHY_SetTxPowerLimit(
pDM_Odm->Adapter,
Regulation,
Bandwidth,
RateSection,
RfPath,
Channel,
PowerLimit
);
}
| linux-master | drivers/staging/rtl8723bs/hal/odm_RegConfig8723B.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
/******************************************************************************
*
*
* Module: rtl8192c_rf6052.c (Source C File)
*
* Note: Provide RF 6052 series relative API.
*
* Function:
*
* Export:
*
* Abbrev:
*
* History:
* Data Who Remark
*
* 09/25/2008 MHC Create initial version.
* 11/05/2008 MHC Add API for tw power setting.
*
*
******************************************************************************/
#include <rtl8723b_hal.h>
/*---------------------------Define Local Constant---------------------------*/
/*---------------------------Define Local Constant---------------------------*/
/*------------------------Define global variable-----------------------------*/
/*------------------------Define global variable-----------------------------*/
/*------------------------Define local variable------------------------------*/
/* 2008/11/20 MH For Debug only, RF */
/*------------------------Define local variable------------------------------*/
/*-----------------------------------------------------------------------------
* Function: PHY_RF6052SetBandwidth()
*
* Overview: This function is called by SetBWModeCallback8190Pci() only
*
* Input: struct adapter * Adapter
* WIRELESS_BANDWIDTH_E Bandwidth 20M or 40M
*
* Output: NONE
*
* Return: NONE
*
* Note: For RF type 0222D
*---------------------------------------------------------------------------*/
void PHY_RF6052SetBandwidth8723B(
struct adapter *Adapter, enum channel_width Bandwidth
) /* 20M or 40M */
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
switch (Bandwidth) {
case CHANNEL_WIDTH_20:
pHalData->RfRegChnlVal[0] = ((pHalData->RfRegChnlVal[0] & 0xfffff3ff) | BIT10 | BIT11);
PHY_SetRFReg(Adapter, RF_PATH_A, RF_CHNLBW, bRFRegOffsetMask, pHalData->RfRegChnlVal[0]);
PHY_SetRFReg(Adapter, RF_PATH_B, RF_CHNLBW, bRFRegOffsetMask, pHalData->RfRegChnlVal[0]);
break;
case CHANNEL_WIDTH_40:
pHalData->RfRegChnlVal[0] = ((pHalData->RfRegChnlVal[0] & 0xfffff3ff) | BIT10);
PHY_SetRFReg(Adapter, RF_PATH_A, RF_CHNLBW, bRFRegOffsetMask, pHalData->RfRegChnlVal[0]);
PHY_SetRFReg(Adapter, RF_PATH_B, RF_CHNLBW, bRFRegOffsetMask, pHalData->RfRegChnlVal[0]);
break;
default:
break;
}
}
static int phy_RF6052_Config_ParaFile(struct adapter *Adapter)
{
u32 u4RegValue = 0;
u8 eRFPath;
struct bb_register_def *pPhyReg;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
/* 3----------------------------------------------------------------- */
/* 3 <2> Initialize RF */
/* 3----------------------------------------------------------------- */
/* for (eRFPath = RF_PATH_A; eRFPath <pHalData->NumTotalRFPath; eRFPath++) */
for (eRFPath = 0; eRFPath < pHalData->NumTotalRFPath; eRFPath++) {
pPhyReg = &pHalData->PHYRegDef[eRFPath];
/*----Store original RFENV control type----*/
switch (eRFPath) {
case RF_PATH_A:
u4RegValue = PHY_QueryBBReg(Adapter, pPhyReg->rfintfs, bRFSI_RFENV);
break;
case RF_PATH_B:
u4RegValue = PHY_QueryBBReg(Adapter, pPhyReg->rfintfs, bRFSI_RFENV << 16);
break;
}
/*----Set RF_ENV enable----*/
PHY_SetBBReg(Adapter, pPhyReg->rfintfe, bRFSI_RFENV << 16, 0x1);
udelay(1);/* PlatformStallExecution(1); */
/*----Set RF_ENV output high----*/
PHY_SetBBReg(Adapter, pPhyReg->rfintfo, bRFSI_RFENV, 0x1);
udelay(1);/* PlatformStallExecution(1); */
/* Set bit number of Address and Data for RF register */
PHY_SetBBReg(Adapter, pPhyReg->rfHSSIPara2, b3WireAddressLength, 0x0); /* Set 1 to 4 bits for 8255 */
udelay(1);/* PlatformStallExecution(1); */
PHY_SetBBReg(Adapter, pPhyReg->rfHSSIPara2, b3WireDataLength, 0x0); /* Set 0 to 12 bits for 8255 */
udelay(1);/* PlatformStallExecution(1); */
/*----Initialize RF fom connfiguration file----*/
switch (eRFPath) {
case RF_PATH_A:
case RF_PATH_B:
ODM_ConfigRFWithHeaderFile(&pHalData->odmpriv,
CONFIG_RF_RADIO, eRFPath);
break;
}
/*----Restore RFENV control type----*/
switch (eRFPath) {
case RF_PATH_A:
PHY_SetBBReg(Adapter, pPhyReg->rfintfs, bRFSI_RFENV, u4RegValue);
break;
case RF_PATH_B:
PHY_SetBBReg(Adapter, pPhyReg->rfintfs, bRFSI_RFENV << 16, u4RegValue);
break;
}
}
/* 3 ----------------------------------------------------------------- */
/* 3 Configuration of Tx Power Tracking */
/* 3 ----------------------------------------------------------------- */
ODM_ConfigRFWithTxPwrTrackHeaderFile(&pHalData->odmpriv);
return _SUCCESS;
}
int PHY_RF6052_Config8723B(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
/* */
/* Initialize general global value */
/* */
pHalData->NumTotalRFPath = 1;
/* */
/* Config BB and RF */
/* */
return phy_RF6052_Config_ParaFile(Adapter);
}
/* End of HalRf6052.c */
| linux-master | drivers/staging/rtl8723bs/hal/rtl8723b_rf6052.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <hal_data.h>
#include <linux/kernel.h>
u8 PHY_GetTxPowerByRateBase(struct adapter *Adapter, u8 RfPath,
enum rate_section RateSection)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
u8 value = 0;
if (RfPath >= RF_PATH_MAX)
return 0;
switch (RateSection) {
case CCK:
value = pHalData->TxPwrByRateBase2_4G[RfPath][0];
break;
case OFDM:
value = pHalData->TxPwrByRateBase2_4G[RfPath][1];
break;
case HT_MCS0_MCS7:
value = pHalData->TxPwrByRateBase2_4G[RfPath][2];
break;
default:
break;
}
return value;
}
static void
phy_SetTxPowerByRateBase(struct adapter *Adapter, u8 RfPath,
enum rate_section RateSection, u8 Value)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
if (RfPath >= RF_PATH_MAX)
return;
switch (RateSection) {
case CCK:
pHalData->TxPwrByRateBase2_4G[RfPath][0] = Value;
break;
case OFDM:
pHalData->TxPwrByRateBase2_4G[RfPath][1] = Value;
break;
case HT_MCS0_MCS7:
pHalData->TxPwrByRateBase2_4G[RfPath][2] = Value;
break;
default:
break;
}
}
static void
phy_StoreTxPowerByRateBase(
struct adapter *padapter
)
{
u8 path, base;
for (path = RF_PATH_A; path <= RF_PATH_B; ++path) {
base = PHY_GetTxPowerByRate(padapter, path, MGN_11M);
phy_SetTxPowerByRateBase(padapter, path, CCK, base);
base = PHY_GetTxPowerByRate(padapter, path, MGN_54M);
phy_SetTxPowerByRateBase(padapter, path, OFDM, base);
base = PHY_GetTxPowerByRate(padapter, path, MGN_MCS7);
phy_SetTxPowerByRateBase(padapter, path, HT_MCS0_MCS7, base);
}
}
u8 PHY_GetRateSectionIndexOfTxPowerByRate(
struct adapter *padapter, u32 RegAddr, u32 BitMask
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
u8 index = 0;
if (pDM_Odm->PhyRegPgVersion == 0) {
switch (RegAddr) {
case rTxAGC_A_Rate18_06:
index = 0;
break;
case rTxAGC_A_Rate54_24:
index = 1;
break;
case rTxAGC_A_CCK1_Mcs32:
index = 6;
break;
case rTxAGC_B_CCK11_A_CCK2_11:
if (BitMask == bMaskH3Bytes)
index = 7;
else if (BitMask == 0x000000ff)
index = 15;
break;
case rTxAGC_A_Mcs03_Mcs00:
index = 2;
break;
case rTxAGC_A_Mcs07_Mcs04:
index = 3;
break;
case rTxAGC_B_Rate18_06:
index = 8;
break;
case rTxAGC_B_Rate54_24:
index = 9;
break;
case rTxAGC_B_CCK1_55_Mcs32:
index = 14;
break;
case rTxAGC_B_Mcs03_Mcs00:
index = 10;
break;
case rTxAGC_B_Mcs07_Mcs04:
index = 11;
break;
default:
break;
}
}
return index;
}
void
PHY_GetRateValuesOfTxPowerByRate(
struct adapter *padapter,
u32 RegAddr,
u32 BitMask,
u32 Value,
u8 *RateIndex,
s8 *PwrByRateVal,
u8 *RateNum
)
{
u8 i = 0;
switch (RegAddr) {
case rTxAGC_A_Rate18_06:
case rTxAGC_B_Rate18_06:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_6M);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_9M);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_12M);
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_18M);
for (i = 0; i < 4; ++i) {
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 4;
break;
case rTxAGC_A_Rate54_24:
case rTxAGC_B_Rate54_24:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_24M);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_36M);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_48M);
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_54M);
for (i = 0; i < 4; ++i) {
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 4;
break;
case rTxAGC_A_CCK1_Mcs32:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_1M);
PwrByRateVal[0] = (s8) ((((Value >> (8 + 4)) & 0xF)) * 10 +
((Value >> 8) & 0xF));
*RateNum = 1;
break;
case rTxAGC_B_CCK11_A_CCK2_11:
if (BitMask == 0xffffff00) {
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_2M);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_5_5M);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_11M);
for (i = 1; i < 4; ++i) {
PwrByRateVal[i - 1] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 3;
} else if (BitMask == 0x000000ff) {
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_11M);
PwrByRateVal[0] = (s8) ((((Value >> 4) & 0xF)) * 10 + (Value & 0xF));
*RateNum = 1;
}
break;
case rTxAGC_A_Mcs03_Mcs00:
case rTxAGC_B_Mcs03_Mcs00:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS0);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS1);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS2);
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS3);
for (i = 0; i < 4; ++i) {
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 4;
break;
case rTxAGC_A_Mcs07_Mcs04:
case rTxAGC_B_Mcs07_Mcs04:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS4);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS5);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS6);
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS7);
for (i = 0; i < 4; ++i) {
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 4;
break;
case rTxAGC_B_CCK1_55_Mcs32:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_1M);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_2M);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_5_5M);
for (i = 1; i < 4; ++i) {
PwrByRateVal[i - 1] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 3;
break;
case 0xC20:
case 0xE20:
case 0x1820:
case 0x1a20:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_1M);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_2M);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_5_5M);
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_11M);
for (i = 0; i < 4; ++i) {
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 4;
break;
case 0xC24:
case 0xE24:
case 0x1824:
case 0x1a24:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_6M);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_9M);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_12M);
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_18M);
for (i = 0; i < 4; ++i) {
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 4;
break;
case 0xC28:
case 0xE28:
case 0x1828:
case 0x1a28:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_24M);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_36M);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_48M);
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_54M);
for (i = 0; i < 4; ++i) {
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 4;
break;
case 0xC2C:
case 0xE2C:
case 0x182C:
case 0x1a2C:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS0);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS1);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS2);
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS3);
for (i = 0; i < 4; ++i) {
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 4;
break;
case 0xC30:
case 0xE30:
case 0x1830:
case 0x1a30:
RateIndex[0] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS4);
RateIndex[1] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS5);
RateIndex[2] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS6);
RateIndex[3] = PHY_GetRateIndexOfTxPowerByRate(MGN_MCS7);
for (i = 0; i < 4; ++i) {
PwrByRateVal[i] = (s8) ((((Value >> (i * 8 + 4)) & 0xF)) * 10 +
((Value >> (i * 8)) & 0xF));
}
*RateNum = 4;
break;
default:
break;
}
}
static void PHY_StoreTxPowerByRateNew(struct adapter *padapter, u32 RfPath,
u32 RegAddr, u32 BitMask, u32 Data)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 i = 0, rateIndex[4] = {0}, rateNum = 0;
s8 PwrByRateVal[4] = {0};
PHY_GetRateValuesOfTxPowerByRate(padapter, RegAddr, BitMask, Data, rateIndex, PwrByRateVal, &rateNum);
if (RfPath >= RF_PATH_MAX)
return;
for (i = 0; i < rateNum; ++i) {
pHalData->TxPwrByRateOffset[RfPath][rateIndex[i]] = PwrByRateVal[i];
}
}
static void PHY_StoreTxPowerByRateOld(
struct adapter *padapter, u32 RegAddr, u32 BitMask, u32 Data
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 index = PHY_GetRateSectionIndexOfTxPowerByRate(padapter, RegAddr, BitMask);
pHalData->MCSTxPowerLevelOriginalOffset[pHalData->pwrGroupCnt][index] = Data;
}
void PHY_InitTxPowerByRate(struct adapter *padapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 rfPath, rate;
for (rfPath = RF_PATH_A; rfPath < MAX_RF_PATH_NUM; ++rfPath)
for (rate = 0; rate < TX_PWR_BY_RATE_NUM_RATE; ++rate)
pHalData->TxPwrByRateOffset[rfPath][rate] = 0;
}
void PHY_StoreTxPowerByRate(
struct adapter *padapter,
u32 RfPath,
u32 RegAddr,
u32 BitMask,
u32 Data
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
if (pDM_Odm->PhyRegPgVersion > 0)
PHY_StoreTxPowerByRateNew(padapter, RfPath, RegAddr, BitMask, Data);
else if (pDM_Odm->PhyRegPgVersion == 0) {
PHY_StoreTxPowerByRateOld(padapter, RegAddr, BitMask, Data);
}
}
static void
phy_ConvertTxPowerByRateInDbmToRelativeValues(
struct adapter *padapter
)
{
u8 base = 0, i = 0, value = 0, path = 0;
u8 cckRates[4] = {
MGN_1M, MGN_2M, MGN_5_5M, MGN_11M
};
u8 ofdmRates[8] = {
MGN_6M, MGN_9M, MGN_12M, MGN_18M, MGN_24M, MGN_36M, MGN_48M, MGN_54M
};
u8 mcs0_7Rates[8] = {
MGN_MCS0, MGN_MCS1, MGN_MCS2, MGN_MCS3, MGN_MCS4, MGN_MCS5, MGN_MCS6, MGN_MCS7
};
for (path = RF_PATH_A; path < RF_PATH_MAX; ++path) {
/* CCK */
base = PHY_GetTxPowerByRate(padapter, path, MGN_11M);
for (i = 0; i < ARRAY_SIZE(cckRates); ++i) {
value = PHY_GetTxPowerByRate(padapter, path, cckRates[i]);
PHY_SetTxPowerByRate(padapter, path, cckRates[i], value - base);
}
/* OFDM */
base = PHY_GetTxPowerByRate(padapter, path, MGN_54M);
for (i = 0; i < sizeof(ofdmRates); ++i) {
value = PHY_GetTxPowerByRate(padapter, path, ofdmRates[i]);
PHY_SetTxPowerByRate(padapter, path, ofdmRates[i], value - base);
}
/* HT MCS0~7 */
base = PHY_GetTxPowerByRate(padapter, path, MGN_MCS7);
for (i = 0; i < sizeof(mcs0_7Rates); ++i) {
value = PHY_GetTxPowerByRate(padapter, path, mcs0_7Rates[i]);
PHY_SetTxPowerByRate(padapter, path, mcs0_7Rates[i], value - base);
}
}
}
/*
* This function must be called if the value in the PHY_REG_PG.txt(or header)
* is exact dBm values
*/
void PHY_TxPowerByRateConfiguration(struct adapter *padapter)
{
phy_StoreTxPowerByRateBase(padapter);
phy_ConvertTxPowerByRateInDbmToRelativeValues(padapter);
}
void PHY_SetTxPowerIndexByRateSection(
struct adapter *padapter, u8 RFPath, u8 Channel, u8 RateSection
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
if (RateSection == CCK) {
u8 cckRates[] = {MGN_1M, MGN_2M, MGN_5_5M, MGN_11M};
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
pHalData->CurrentChannelBW,
Channel, cckRates,
ARRAY_SIZE(cckRates));
} else if (RateSection == OFDM) {
u8 ofdmRates[] = {MGN_6M, MGN_9M, MGN_12M, MGN_18M, MGN_24M, MGN_36M, MGN_48M, MGN_54M};
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
pHalData->CurrentChannelBW,
Channel, ofdmRates,
ARRAY_SIZE(ofdmRates));
} else if (RateSection == HT_MCS0_MCS7) {
u8 htRates1T[] = {MGN_MCS0, MGN_MCS1, MGN_MCS2, MGN_MCS3, MGN_MCS4, MGN_MCS5, MGN_MCS6, MGN_MCS7};
PHY_SetTxPowerIndexByRateArray(padapter, RFPath,
pHalData->CurrentChannelBW,
Channel, htRates1T,
ARRAY_SIZE(htRates1T));
}
}
u8 PHY_GetTxPowerIndexBase(
struct adapter *padapter,
u8 RFPath,
u8 Rate,
enum channel_width BandWidth,
u8 Channel
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 txPower = 0;
u8 chnlIdx = (Channel-1);
if (HAL_IsLegalChannel(padapter, Channel) == false)
chnlIdx = 0;
if (IS_CCK_RATE(Rate))
txPower = pHalData->Index24G_CCK_Base[RFPath][chnlIdx];
else if (MGN_6M <= Rate)
txPower = pHalData->Index24G_BW40_Base[RFPath][chnlIdx];
/* OFDM-1T */
if ((MGN_6M <= Rate && Rate <= MGN_54M) && !IS_CCK_RATE(Rate))
txPower += pHalData->OFDM_24G_Diff[RFPath][TX_1S];
if (BandWidth == CHANNEL_WIDTH_20) { /* BW20-1S, BW20-2S */
if (MGN_MCS0 <= Rate && Rate <= MGN_MCS7)
txPower += pHalData->BW20_24G_Diff[RFPath][TX_1S];
} else if (BandWidth == CHANNEL_WIDTH_40) { /* BW40-1S, BW40-2S */
if (MGN_MCS0 <= Rate && Rate <= MGN_MCS7)
txPower += pHalData->BW40_24G_Diff[RFPath][TX_1S];
}
return txPower;
}
s8 PHY_GetTxPowerTrackingOffset(struct adapter *padapter, u8 RFPath, u8 Rate)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
struct dm_odm_t *pDM_Odm = &pHalData->odmpriv;
s8 offset = 0;
if (pDM_Odm->RFCalibrateInfo.TxPowerTrackControl == false)
return offset;
if ((Rate == MGN_1M) || (Rate == MGN_2M) || (Rate == MGN_5_5M) || (Rate == MGN_11M))
offset = pDM_Odm->Remnant_CCKSwingIdx;
else
offset = pDM_Odm->Remnant_OFDMSwingIdx[RFPath];
return offset;
}
u8 PHY_GetRateIndexOfTxPowerByRate(u8 Rate)
{
u8 index = 0;
switch (Rate) {
case MGN_1M:
index = 0;
break;
case MGN_2M:
index = 1;
break;
case MGN_5_5M:
index = 2;
break;
case MGN_11M:
index = 3;
break;
case MGN_6M:
index = 4;
break;
case MGN_9M:
index = 5;
break;
case MGN_12M:
index = 6;
break;
case MGN_18M:
index = 7;
break;
case MGN_24M:
index = 8;
break;
case MGN_36M:
index = 9;
break;
case MGN_48M:
index = 10;
break;
case MGN_54M:
index = 11;
break;
case MGN_MCS0:
index = 12;
break;
case MGN_MCS1:
index = 13;
break;
case MGN_MCS2:
index = 14;
break;
case MGN_MCS3:
index = 15;
break;
case MGN_MCS4:
index = 16;
break;
case MGN_MCS5:
index = 17;
break;
case MGN_MCS6:
index = 18;
break;
case MGN_MCS7:
index = 19;
break;
default:
break;
}
return index;
}
s8 PHY_GetTxPowerByRate(struct adapter *padapter, u8 RFPath, u8 Rate)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
s8 value = 0;
u8 rateIndex = PHY_GetRateIndexOfTxPowerByRate(Rate);
if ((padapter->registrypriv.RegEnableTxPowerByRate == 2 && pHalData->EEPROMRegulatory == 2) ||
padapter->registrypriv.RegEnableTxPowerByRate == 0)
return 0;
if (RFPath >= RF_PATH_MAX)
return value;
if (rateIndex >= TX_PWR_BY_RATE_NUM_RATE)
return value;
return pHalData->TxPwrByRateOffset[RFPath][rateIndex];
}
void PHY_SetTxPowerByRate(
struct adapter *padapter,
u8 RFPath,
u8 Rate,
s8 Value
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(padapter);
u8 rateIndex = PHY_GetRateIndexOfTxPowerByRate(Rate);
if (RFPath >= RF_PATH_MAX)
return;
if (rateIndex >= TX_PWR_BY_RATE_NUM_RATE)
return;
pHalData->TxPwrByRateOffset[RFPath][rateIndex] = Value;
}
void PHY_SetTxPowerLevelByPath(struct adapter *Adapter, u8 channel, u8 path)
{
PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, CCK);
PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, OFDM);
PHY_SetTxPowerIndexByRateSection(Adapter, path, channel, HT_MCS0_MCS7);
}
void PHY_SetTxPowerIndexByRateArray(
struct adapter *padapter,
u8 RFPath,
enum channel_width BandWidth,
u8 Channel,
u8 *Rates,
u8 RateArraySize
)
{
u32 powerIndex = 0;
int i = 0;
for (i = 0; i < RateArraySize; ++i) {
powerIndex = PHY_GetTxPowerIndex(padapter, RFPath, Rates[i], BandWidth, Channel);
PHY_SetTxPowerIndex(padapter, powerIndex, RFPath, Rates[i]);
}
}
static s8 phy_GetWorldWideLimit(s8 *LimitTable)
{
s8 min = LimitTable[0];
u8 i = 0;
for (i = 0; i < MAX_REGULATION_NUM; ++i) {
if (LimitTable[i] < min)
min = LimitTable[i];
}
return min;
}
static s8 phy_GetChannelIndexOfTxPowerLimit(u8 Channel)
{
return Channel - 1;
}
static s16 get_bandwidth_idx(const enum channel_width bandwidth)
{
switch (bandwidth) {
case CHANNEL_WIDTH_20:
return 0;
case CHANNEL_WIDTH_40:
return 1;
default:
return -1;
}
}
static s16 get_rate_sctn_idx(const u8 rate)
{
switch (rate) {
case MGN_1M: case MGN_2M: case MGN_5_5M: case MGN_11M:
return 0;
case MGN_6M: case MGN_9M: case MGN_12M: case MGN_18M:
case MGN_24M: case MGN_36M: case MGN_48M: case MGN_54M:
return 1;
case MGN_MCS0: case MGN_MCS1: case MGN_MCS2: case MGN_MCS3:
case MGN_MCS4: case MGN_MCS5: case MGN_MCS6: case MGN_MCS7:
return 2;
default:
return -1;
}
}
s8 phy_get_tx_pwr_lmt(struct adapter *adapter, u32 reg_pwr_tbl_sel,
enum channel_width bandwidth,
u8 rf_path, u8 data_rate, u8 channel)
{
s16 idx_regulation = -1;
s16 idx_bandwidth = -1;
s16 idx_rate_sctn = -1;
s16 idx_channel = -1;
s8 pwr_lmt = MAX_POWER_INDEX;
struct hal_com_data *hal_data = GET_HAL_DATA(adapter);
s8 limits[10] = {0}; u8 i = 0;
if (((adapter->registrypriv.RegEnableTxPowerLimit == 2) &&
(hal_data->EEPROMRegulatory != 1)) ||
(adapter->registrypriv.RegEnableTxPowerLimit == 0))
return MAX_POWER_INDEX;
switch (adapter->registrypriv.RegPwrTblSel) {
case 1:
idx_regulation = TXPWR_LMT_ETSI;
break;
case 2:
idx_regulation = TXPWR_LMT_MKK;
break;
case 3:
idx_regulation = TXPWR_LMT_FCC;
break;
case 4:
idx_regulation = TXPWR_LMT_WW;
break;
default:
idx_regulation = hal_data->Regulation2_4G;
break;
}
idx_bandwidth = get_bandwidth_idx(bandwidth);
idx_rate_sctn = get_rate_sctn_idx(data_rate);
/* workaround for wrong index combination to obtain tx power limit, */
/* OFDM only exists in BW 20M */
/* CCK table will only be given in BW 20M */
/* HT on 80M will reference to HT on 40M */
if (idx_rate_sctn == 0 || idx_rate_sctn == 1)
idx_bandwidth = 0;
channel = phy_GetChannelIndexOfTxPowerLimit(channel);
if (idx_regulation == -1 || idx_bandwidth == -1 ||
idx_rate_sctn == -1 || idx_channel == -1)
return MAX_POWER_INDEX;
for (i = 0; i < MAX_REGULATION_NUM; i++)
limits[i] = hal_data->TxPwrLimit_2_4G[i]
[idx_bandwidth]
[idx_rate_sctn]
[idx_channel]
[rf_path];
pwr_lmt = (idx_regulation == TXPWR_LMT_WW) ?
phy_GetWorldWideLimit(limits) :
hal_data->TxPwrLimit_2_4G[idx_regulation]
[idx_bandwidth]
[idx_rate_sctn]
[idx_channel]
[rf_path];
return pwr_lmt;
}
void PHY_ConvertTxPowerLimitToPowerIndex(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
u8 BW40PwrBasedBm2_4G = 0x2E;
u8 regulation, bw, channel, rateSection;
s8 tempValue = 0, tempPwrLmt = 0;
u8 rfPath = 0;
for (regulation = 0; regulation < MAX_REGULATION_NUM; ++regulation) {
for (bw = 0; bw < MAX_2_4G_BANDWIDTH_NUM; ++bw) {
for (channel = 0; channel < CHANNEL_MAX_NUMBER_2G; ++channel) {
for (rateSection = 0; rateSection < MAX_RATE_SECTION_NUM; ++rateSection) {
tempPwrLmt = pHalData->TxPwrLimit_2_4G[regulation][bw][rateSection][channel][RF_PATH_A];
for (rfPath = RF_PATH_A; rfPath < MAX_RF_PATH_NUM; ++rfPath) {
if (pHalData->odmpriv.PhyRegPgValueType == PHY_REG_PG_EXACT_VALUE) {
if (rateSection == 2) /* HT 1T */
BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, rfPath, HT_MCS0_MCS7);
else if (rateSection == 1) /* OFDM */
BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, rfPath, OFDM);
else if (rateSection == 0) /* CCK */
BW40PwrBasedBm2_4G = PHY_GetTxPowerByRateBase(Adapter, rfPath, CCK);
} else
BW40PwrBasedBm2_4G = Adapter->registrypriv.RegPowerBase * 2;
if (tempPwrLmt != MAX_POWER_INDEX) {
tempValue = tempPwrLmt - BW40PwrBasedBm2_4G;
pHalData->TxPwrLimit_2_4G[regulation][bw][rateSection][channel][rfPath] = tempValue;
}
}
}
}
}
}
}
void PHY_InitTxPowerLimit(struct adapter *Adapter)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
u8 i, j, k, l, m;
for (i = 0; i < MAX_REGULATION_NUM; ++i) {
for (j = 0; j < MAX_2_4G_BANDWIDTH_NUM; ++j)
for (k = 0; k < MAX_RATE_SECTION_NUM; ++k)
for (m = 0; m < CHANNEL_MAX_NUMBER_2G; ++m)
for (l = 0; l < MAX_RF_PATH_NUM; ++l)
pHalData->TxPwrLimit_2_4G[i][j][k][m][l] = MAX_POWER_INDEX;
}
}
void PHY_SetTxPowerLimit(
struct adapter *Adapter,
u8 *Regulation,
u8 *Bandwidth,
u8 *RateSection,
u8 *RfPath,
u8 *Channel,
u8 *PowerLimit
)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
u8 regulation = 0, bandwidth = 0, rateSection = 0, channel;
s8 powerLimit = 0, prevPowerLimit, channelIndex;
GetU1ByteIntegerFromStringInDecimal((s8 *)Channel, &channel);
GetU1ByteIntegerFromStringInDecimal((s8 *)PowerLimit, &powerLimit);
powerLimit = powerLimit > MAX_POWER_INDEX ? MAX_POWER_INDEX : powerLimit;
if (eqNByte(Regulation, (u8 *)("FCC"), 3))
regulation = 0;
else if (eqNByte(Regulation, (u8 *)("MKK"), 3))
regulation = 1;
else if (eqNByte(Regulation, (u8 *)("ETSI"), 4))
regulation = 2;
else if (eqNByte(Regulation, (u8 *)("WW13"), 4))
regulation = 3;
if (eqNByte(RateSection, (u8 *)("CCK"), 3) && eqNByte(RfPath, (u8 *)("1T"), 2))
rateSection = 0;
else if (eqNByte(RateSection, (u8 *)("OFDM"), 4) && eqNByte(RfPath, (u8 *)("1T"), 2))
rateSection = 1;
else if (eqNByte(RateSection, (u8 *)("HT"), 2) && eqNByte(RfPath, (u8 *)("1T"), 2))
rateSection = 2;
else
return;
if (eqNByte(Bandwidth, (u8 *)("20M"), 3))
bandwidth = 0;
else if (eqNByte(Bandwidth, (u8 *)("40M"), 3))
bandwidth = 1;
channelIndex = phy_GetChannelIndexOfTxPowerLimit(channel);
if (channelIndex == -1)
return;
prevPowerLimit = pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][RF_PATH_A];
if (powerLimit < prevPowerLimit)
pHalData->TxPwrLimit_2_4G[regulation][bandwidth][rateSection][channelIndex][RF_PATH_A] = powerLimit;
}
void Hal_ChannelPlanToRegulation(struct adapter *Adapter, u16 ChannelPlan)
{
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
pHalData->Regulation2_4G = TXPWR_LMT_WW;
switch (ChannelPlan) {
case RT_CHANNEL_DOMAIN_WORLD_NULL:
pHalData->Regulation2_4G = TXPWR_LMT_WW;
break;
case RT_CHANNEL_DOMAIN_ETSI1_NULL:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_FCC1_NULL:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_MKK1_NULL:
pHalData->Regulation2_4G = TXPWR_LMT_MKK;
break;
case RT_CHANNEL_DOMAIN_ETSI2_NULL:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_FCC1_FCC1:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI1:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_MKK1_MKK1:
pHalData->Regulation2_4G = TXPWR_LMT_MKK;
break;
case RT_CHANNEL_DOMAIN_WORLD_KCC1:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_FCC2:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_FCC3:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_FCC4:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_FCC5:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_FCC6:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_FCC1_FCC7:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI2:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI3:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_MKK1_MKK2:
pHalData->Regulation2_4G = TXPWR_LMT_MKK;
break;
case RT_CHANNEL_DOMAIN_MKK1_MKK3:
pHalData->Regulation2_4G = TXPWR_LMT_MKK;
break;
case RT_CHANNEL_DOMAIN_FCC1_NCC1:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_FCC1_NCC2:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_GLOBAL_NULL:
pHalData->Regulation2_4G = TXPWR_LMT_WW;
break;
case RT_CHANNEL_DOMAIN_ETSI1_ETSI4:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_FCC1_FCC2:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_FCC1_NCC3:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI5:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_FCC1_FCC8:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI6:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI7:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI8:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI9:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI10:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI11:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_FCC1_NCC4:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI12:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_FCC1_FCC9:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_WORLD_ETSI13:
pHalData->Regulation2_4G = TXPWR_LMT_ETSI;
break;
case RT_CHANNEL_DOMAIN_FCC1_FCC10:
pHalData->Regulation2_4G = TXPWR_LMT_FCC;
break;
case RT_CHANNEL_DOMAIN_REALTEK_DEFINE: /* Realtek Reserve */
pHalData->Regulation2_4G = TXPWR_LMT_WW;
break;
default:
break;
}
}
| linux-master | drivers/staging/rtl8723bs/hal/hal_com_phycfg.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include "odm_precomp.h"
void odm_DynamicTxPowerInit(void *pDM_VOID)
{
struct dm_odm_t *pDM_Odm = (struct dm_odm_t *)pDM_VOID;
struct adapter *Adapter = pDM_Odm->Adapter;
struct hal_com_data *pHalData = GET_HAL_DATA(Adapter);
struct dm_priv *pdmpriv = &pHalData->dmpriv;
pdmpriv->bDynamicTxPowerEnable = false;
pdmpriv->LastDTPLvl = TxHighPwrLevel_Normal;
pdmpriv->DynamicTxHighPowerLvl = TxHighPwrLevel_Normal;
}
| linux-master | drivers/staging/rtl8723bs/hal/odm_DynamicTxPower.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
/*
* Translate the OS dependent @param error_code to OS independent RTW_STATUS_CODE
* @return: one of RTW_STATUS_CODE
*/
inline int RTW_STATUS_CODE(int error_code)
{
if (error_code >= 0)
return _SUCCESS;
return _FAIL;
}
void *_rtw_malloc(u32 sz)
{
return kmalloc(sz, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
}
void *_rtw_zmalloc(u32 sz)
{
void *pbuf = _rtw_malloc(sz);
if (pbuf)
memset(pbuf, 0, sz);
return pbuf;
}
inline struct sk_buff *_rtw_skb_alloc(u32 sz)
{
return __dev_alloc_skb(sz, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
}
inline struct sk_buff *_rtw_skb_copy(const struct sk_buff *skb)
{
return skb_copy(skb, in_interrupt() ? GFP_ATOMIC : GFP_KERNEL);
}
inline int _rtw_netif_rx(struct net_device *ndev, struct sk_buff *skb)
{
skb->dev = ndev;
return netif_rx(skb);
}
struct net_device *rtw_alloc_etherdev_with_old_priv(int sizeof_priv, void *old_priv)
{
struct net_device *pnetdev;
struct rtw_netdev_priv_indicator *pnpi;
pnetdev = alloc_etherdev_mq(sizeof(struct rtw_netdev_priv_indicator), 4);
if (!pnetdev)
goto RETURN;
pnpi = netdev_priv(pnetdev);
pnpi->priv = old_priv;
pnpi->sizeof_priv = sizeof_priv;
RETURN:
return pnetdev;
}
struct net_device *rtw_alloc_etherdev(int sizeof_priv)
{
struct net_device *pnetdev;
struct rtw_netdev_priv_indicator *pnpi;
pnetdev = alloc_etherdev_mq(sizeof(struct rtw_netdev_priv_indicator), 4);
if (!pnetdev)
goto RETURN;
pnpi = netdev_priv(pnetdev);
pnpi->priv = vzalloc(sizeof_priv);
if (!pnpi->priv) {
free_netdev(pnetdev);
pnetdev = NULL;
goto RETURN;
}
pnpi->sizeof_priv = sizeof_priv;
RETURN:
return pnetdev;
}
void rtw_free_netdev(struct net_device *netdev)
{
struct rtw_netdev_priv_indicator *pnpi;
if (!netdev)
goto RETURN;
pnpi = netdev_priv(netdev);
if (!pnpi->priv)
goto RETURN;
vfree(pnpi->priv);
free_netdev(netdev);
RETURN:
return;
}
void rtw_buf_free(u8 **buf, u32 *buf_len)
{
if (!buf || !buf_len)
return;
if (*buf) {
*buf_len = 0;
kfree(*buf);
*buf = NULL;
}
}
void rtw_buf_update(u8 **buf, u32 *buf_len, u8 *src, u32 src_len)
{
u32 ori_len = 0, dup_len = 0;
u8 *ori = NULL;
u8 *dup = NULL;
if (!buf || !buf_len)
return;
if (!src || !src_len)
goto keep_ori;
/* duplicate src */
dup = rtw_malloc(src_len);
if (dup) {
dup_len = src_len;
memcpy(dup, src, dup_len);
}
keep_ori:
ori = *buf;
ori_len = *buf_len;
/* replace buf with dup */
*buf_len = 0;
*buf = dup;
*buf_len = dup_len;
/* free ori */
if (ori && ori_len > 0)
kfree(ori);
}
/**
* rtw_cbuf_full - test if cbuf is full
* @cbuf: pointer of struct rtw_cbuf
*
* Returns: true if cbuf is full
*/
inline bool rtw_cbuf_full(struct rtw_cbuf *cbuf)
{
return (cbuf->write == cbuf->read - 1) ? true : false;
}
/**
* rtw_cbuf_empty - test if cbuf is empty
* @cbuf: pointer of struct rtw_cbuf
*
* Returns: true if cbuf is empty
*/
inline bool rtw_cbuf_empty(struct rtw_cbuf *cbuf)
{
return (cbuf->write == cbuf->read) ? true : false;
}
/**
* rtw_cbuf_push - push a pointer into cbuf
* @cbuf: pointer of struct rtw_cbuf
* @buf: pointer to push in
*
* Lock free operation, be careful of the use scheme
* Returns: true push success
*/
bool rtw_cbuf_push(struct rtw_cbuf *cbuf, void *buf)
{
if (rtw_cbuf_full(cbuf))
return _FAIL;
cbuf->bufs[cbuf->write] = buf;
cbuf->write = (cbuf->write + 1) % cbuf->size;
return _SUCCESS;
}
/**
* rtw_cbuf_pop - pop a pointer from cbuf
* @cbuf: pointer of struct rtw_cbuf
*
* Lock free operation, be careful of the use scheme
* Returns: pointer popped out
*/
void *rtw_cbuf_pop(struct rtw_cbuf *cbuf)
{
void *buf;
if (rtw_cbuf_empty(cbuf))
return NULL;
buf = cbuf->bufs[cbuf->read];
cbuf->read = (cbuf->read + 1) % cbuf->size;
return buf;
}
/**
* rtw_cbuf_alloc - allocate a rtw_cbuf with given size and do initialization
* @size: size of pointer
*
* Returns: pointer of srtuct rtw_cbuf, NULL for allocation failure
*/
struct rtw_cbuf *rtw_cbuf_alloc(u32 size)
{
struct rtw_cbuf *cbuf;
cbuf = rtw_malloc(struct_size(cbuf, bufs, size));
if (cbuf) {
cbuf->write = cbuf->read = 0;
cbuf->size = size;
}
return cbuf;
}
| linux-master | drivers/staging/rtl8723bs/os_dep/osdep_service.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <linux/etherdevice.h>
#include <drv_types.h>
#include <rtw_debug.h>
#include <linux/jiffies.h>
#include <rtw_wifi_regd.h>
#define RTW_MAX_MGMT_TX_CNT (8)
#define RTW_SCAN_IE_LEN_MAX 2304
#define RTW_MAX_REMAIN_ON_CHANNEL_DURATION 5000 /* ms */
#define RTW_MAX_NUM_PMKIDS 4
static const u32 rtw_cipher_suites[] = {
WLAN_CIPHER_SUITE_WEP40,
WLAN_CIPHER_SUITE_WEP104,
WLAN_CIPHER_SUITE_TKIP,
WLAN_CIPHER_SUITE_CCMP,
WLAN_CIPHER_SUITE_AES_CMAC,
};
#define RATETAB_ENT(_rate, _rateid, _flags) \
{ \
.bitrate = (_rate), \
.hw_value = (_rateid), \
.flags = (_flags), \
}
#define CHAN2G(_channel, _freq, _flags) { \
.band = NL80211_BAND_2GHZ, \
.center_freq = (_freq), \
.hw_value = (_channel), \
.flags = (_flags), \
.max_antenna_gain = 0, \
.max_power = 30, \
}
/* if wowlan is not supported, kernel generate a disconnect at each suspend
* cf: /net/wireless/sysfs.c, so register a stub wowlan.
* Moreover wowlan has to be enabled via a the nl80211_set_wowlan callback.
* (from user space, e.g. iw phy0 wowlan enable)
*/
static __maybe_unused const struct wiphy_wowlan_support wowlan_stub = {
.flags = WIPHY_WOWLAN_ANY,
.n_patterns = 0,
.pattern_max_len = 0,
.pattern_min_len = 0,
.max_pkt_offset = 0,
};
static struct ieee80211_rate rtw_rates[] = {
RATETAB_ENT(10, 0x1, 0),
RATETAB_ENT(20, 0x2, 0),
RATETAB_ENT(55, 0x4, 0),
RATETAB_ENT(110, 0x8, 0),
RATETAB_ENT(60, 0x10, 0),
RATETAB_ENT(90, 0x20, 0),
RATETAB_ENT(120, 0x40, 0),
RATETAB_ENT(180, 0x80, 0),
RATETAB_ENT(240, 0x100, 0),
RATETAB_ENT(360, 0x200, 0),
RATETAB_ENT(480, 0x400, 0),
RATETAB_ENT(540, 0x800, 0),
};
#define rtw_g_rates (rtw_rates + 0)
#define RTW_G_RATES_NUM 12
#define RTW_2G_CHANNELS_NUM 14
static struct ieee80211_channel rtw_2ghz_channels[] = {
CHAN2G(1, 2412, 0),
CHAN2G(2, 2417, 0),
CHAN2G(3, 2422, 0),
CHAN2G(4, 2427, 0),
CHAN2G(5, 2432, 0),
CHAN2G(6, 2437, 0),
CHAN2G(7, 2442, 0),
CHAN2G(8, 2447, 0),
CHAN2G(9, 2452, 0),
CHAN2G(10, 2457, 0),
CHAN2G(11, 2462, 0),
CHAN2G(12, 2467, 0),
CHAN2G(13, 2472, 0),
CHAN2G(14, 2484, 0),
};
static void rtw_2g_channels_init(struct ieee80211_channel *channels)
{
memcpy((void *)channels, (void *)rtw_2ghz_channels,
sizeof(struct ieee80211_channel) * RTW_2G_CHANNELS_NUM
);
}
static void rtw_2g_rates_init(struct ieee80211_rate *rates)
{
memcpy(rates, rtw_g_rates,
sizeof(struct ieee80211_rate) * RTW_G_RATES_NUM
);
}
static struct ieee80211_supported_band *rtw_spt_band_alloc(
enum nl80211_band band
)
{
struct ieee80211_supported_band *spt_band = NULL;
int n_channels, n_bitrates;
if (band == NL80211_BAND_2GHZ) {
n_channels = RTW_2G_CHANNELS_NUM;
n_bitrates = RTW_G_RATES_NUM;
} else {
goto exit;
}
spt_band = rtw_zmalloc(sizeof(struct ieee80211_supported_band) +
sizeof(struct ieee80211_channel) * n_channels +
sizeof(struct ieee80211_rate) * n_bitrates);
if (!spt_band)
goto exit;
spt_band->channels = (struct ieee80211_channel *)(((u8 *)spt_band) + sizeof(struct ieee80211_supported_band));
spt_band->bitrates = (struct ieee80211_rate *)(((u8 *)spt_band->channels) + sizeof(struct ieee80211_channel) * n_channels);
spt_band->band = band;
spt_band->n_channels = n_channels;
spt_band->n_bitrates = n_bitrates;
if (band == NL80211_BAND_2GHZ) {
rtw_2g_channels_init(spt_band->channels);
rtw_2g_rates_init(spt_band->bitrates);
}
/* spt_band.ht_cap */
exit:
return spt_band;
}
static const struct ieee80211_txrx_stypes
rtw_cfg80211_default_mgmt_stypes[NUM_NL80211_IFTYPES] = {
[NL80211_IFTYPE_ADHOC] = {
.tx = 0xffff,
.rx = BIT(IEEE80211_STYPE_ACTION >> 4)
},
[NL80211_IFTYPE_STATION] = {
.tx = 0xffff,
.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
},
[NL80211_IFTYPE_AP] = {
.tx = 0xffff,
.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
BIT(IEEE80211_STYPE_DISASSOC >> 4) |
BIT(IEEE80211_STYPE_AUTH >> 4) |
BIT(IEEE80211_STYPE_DEAUTH >> 4) |
BIT(IEEE80211_STYPE_ACTION >> 4)
},
[NL80211_IFTYPE_AP_VLAN] = {
/* copy AP */
.tx = 0xffff,
.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
BIT(IEEE80211_STYPE_DISASSOC >> 4) |
BIT(IEEE80211_STYPE_AUTH >> 4) |
BIT(IEEE80211_STYPE_DEAUTH >> 4) |
BIT(IEEE80211_STYPE_ACTION >> 4)
},
[NL80211_IFTYPE_P2P_CLIENT] = {
.tx = 0xffff,
.rx = BIT(IEEE80211_STYPE_ACTION >> 4) |
BIT(IEEE80211_STYPE_PROBE_REQ >> 4)
},
[NL80211_IFTYPE_P2P_GO] = {
.tx = 0xffff,
.rx = BIT(IEEE80211_STYPE_ASSOC_REQ >> 4) |
BIT(IEEE80211_STYPE_REASSOC_REQ >> 4) |
BIT(IEEE80211_STYPE_PROBE_REQ >> 4) |
BIT(IEEE80211_STYPE_DISASSOC >> 4) |
BIT(IEEE80211_STYPE_AUTH >> 4) |
BIT(IEEE80211_STYPE_DEAUTH >> 4) |
BIT(IEEE80211_STYPE_ACTION >> 4)
},
};
static int rtw_ieee80211_channel_to_frequency(int chan, int band)
{
if (band == NL80211_BAND_2GHZ) {
if (chan == 14)
return 2484;
else if (chan < 14)
return 2407 + chan * 5;
}
return 0; /* not supported */
}
#define MAX_BSSINFO_LEN 1000
struct cfg80211_bss *rtw_cfg80211_inform_bss(struct adapter *padapter, struct wlan_network *pnetwork)
{
struct ieee80211_channel *notify_channel;
struct cfg80211_bss *bss = NULL;
/* struct ieee80211_supported_band *band; */
u16 channel;
u32 freq;
u64 notify_timestamp;
s32 notify_signal;
u8 *buf = NULL, *pbuf;
size_t len, bssinf_len = 0;
struct ieee80211_hdr *pwlanhdr;
__le16 *fctrl;
struct wireless_dev *wdev = padapter->rtw_wdev;
struct wiphy *wiphy = wdev->wiphy;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
bssinf_len = pnetwork->network.ie_length + sizeof(struct ieee80211_hdr_3addr);
if (bssinf_len > MAX_BSSINFO_LEN)
goto exit;
{
u16 wapi_len = 0;
if (rtw_get_wapi_ie(pnetwork->network.ies, pnetwork->network.ie_length, NULL, &wapi_len) > 0) {
if (wapi_len > 0)
goto exit;
}
}
/* To reduce PBC Overlap rate */
/* spin_lock_bh(&pwdev_priv->scan_req_lock); */
if (adapter_wdev_data(padapter)->scan_request) {
u8 *psr = NULL, sr = 0;
struct ndis_802_11_ssid *pssid = &pnetwork->network.ssid;
struct cfg80211_scan_request *request = adapter_wdev_data(padapter)->scan_request;
struct cfg80211_ssid *ssids = request->ssids;
u32 wpsielen = 0;
u8 *wpsie = NULL;
wpsie = rtw_get_wps_ie(pnetwork->network.ies + _FIXED_IE_LENGTH_, pnetwork->network.ie_length - _FIXED_IE_LENGTH_, NULL, &wpsielen);
if (wpsie && wpsielen > 0)
psr = rtw_get_wps_attr_content(wpsie, wpsielen, WPS_ATTR_SELECTED_REGISTRAR, (u8 *)(&sr), NULL);
if (sr != 0) {
/* it means under processing WPS */
if (request->n_ssids == 1 && request->n_channels == 1) {
if (ssids[0].ssid_len != 0 &&
(pssid->ssid_length != ssids[0].ssid_len ||
memcmp(pssid->ssid, ssids[0].ssid, ssids[0].ssid_len))) {
if (psr)
*psr = 0; /* clear sr */
}
}
}
}
/* spin_unlock_bh(&pwdev_priv->scan_req_lock); */
channel = pnetwork->network.configuration.ds_config;
freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
notify_channel = ieee80211_get_channel(wiphy, freq);
notify_timestamp = ktime_to_us(ktime_get_boottime());
/* We've set wiphy's signal_type as CFG80211_SIGNAL_TYPE_MBM: signal strength in mBm (100*dBm) */
if (check_fwstate(pmlmepriv, _FW_LINKED) == true &&
is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network, 0)) {
notify_signal = 100 * translate_percentage_to_dbm(padapter->recvpriv.signal_strength);/* dbm */
} else {
notify_signal = 100 * translate_percentage_to_dbm(pnetwork->network.phy_info.signal_strength);/* dbm */
}
buf = kzalloc(MAX_BSSINFO_LEN, GFP_ATOMIC);
if (!buf)
goto exit;
pbuf = buf;
pwlanhdr = (struct ieee80211_hdr *)pbuf;
fctrl = &(pwlanhdr->frame_control);
*(fctrl) = 0;
SetSeqNum(pwlanhdr, 0/*pmlmeext->mgnt_seq*/);
/* pmlmeext->mgnt_seq++; */
if (pnetwork->network.reserved[0] == 1) { /* WIFI_BEACON */
eth_broadcast_addr(pwlanhdr->addr1);
SetFrameSubType(pbuf, WIFI_BEACON);
} else {
memcpy(pwlanhdr->addr1, myid(&(padapter->eeprompriv)), ETH_ALEN);
SetFrameSubType(pbuf, WIFI_PROBERSP);
}
memcpy(pwlanhdr->addr2, pnetwork->network.mac_address, ETH_ALEN);
memcpy(pwlanhdr->addr3, pnetwork->network.mac_address, ETH_ALEN);
pbuf += sizeof(struct ieee80211_hdr_3addr);
len = sizeof(struct ieee80211_hdr_3addr);
memcpy(pbuf, pnetwork->network.ies, pnetwork->network.ie_length);
len += pnetwork->network.ie_length;
*((__le64 *)pbuf) = cpu_to_le64(notify_timestamp);
bss = cfg80211_inform_bss_frame(wiphy, notify_channel, (struct ieee80211_mgmt *)buf,
len, notify_signal, GFP_ATOMIC);
if (unlikely(!bss))
goto exit;
cfg80211_put_bss(wiphy, bss);
kfree(buf);
exit:
return bss;
}
/*
* Check the given bss is valid by kernel API cfg80211_get_bss()
* @padapter : the given adapter
*
* return true if bss is valid, false for not found.
*/
int rtw_cfg80211_check_bss(struct adapter *padapter)
{
struct wlan_bssid_ex *pnetwork = &(padapter->mlmeextpriv.mlmext_info.network);
struct cfg80211_bss *bss = NULL;
struct ieee80211_channel *notify_channel = NULL;
u32 freq;
if (!(pnetwork) || !(padapter->rtw_wdev))
return false;
freq = rtw_ieee80211_channel_to_frequency(pnetwork->configuration.ds_config, NL80211_BAND_2GHZ);
notify_channel = ieee80211_get_channel(padapter->rtw_wdev->wiphy, freq);
bss = cfg80211_get_bss(padapter->rtw_wdev->wiphy, notify_channel,
pnetwork->mac_address, pnetwork->ssid.ssid,
pnetwork->ssid.ssid_length,
IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
cfg80211_put_bss(padapter->rtw_wdev->wiphy, bss);
return (bss != NULL);
}
void rtw_cfg80211_ibss_indicate_connect(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
struct wireless_dev *pwdev = padapter->rtw_wdev;
struct wiphy *wiphy = pwdev->wiphy;
int freq = (int)cur_network->network.configuration.ds_config;
struct ieee80211_channel *chan;
if (pwdev->iftype != NL80211_IFTYPE_ADHOC)
return;
if (!rtw_cfg80211_check_bss(padapter)) {
struct wlan_bssid_ex *pnetwork = &(padapter->mlmeextpriv.mlmext_info.network);
struct wlan_network *scanned = pmlmepriv->cur_network_scanned;
if (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) {
memcpy(&cur_network->network, pnetwork, sizeof(struct wlan_bssid_ex));
rtw_cfg80211_inform_bss(padapter, cur_network);
} else {
if (!scanned) {
rtw_warn_on(1);
return;
}
if (!memcmp(&(scanned->network.ssid), &(pnetwork->ssid), sizeof(struct ndis_802_11_ssid))
&& !memcmp(scanned->network.mac_address, pnetwork->mac_address, sizeof(NDIS_802_11_MAC_ADDRESS))
)
rtw_cfg80211_inform_bss(padapter, scanned);
else
rtw_warn_on(1);
}
if (!rtw_cfg80211_check_bss(padapter))
netdev_dbg(padapter->pnetdev,
FUNC_ADPT_FMT " BSS not found !!\n",
FUNC_ADPT_ARG(padapter));
}
/* notify cfg80211 that device joined an IBSS */
chan = ieee80211_get_channel(wiphy, freq);
cfg80211_ibss_joined(padapter->pnetdev, cur_network->network.mac_address, chan, GFP_ATOMIC);
}
void rtw_cfg80211_indicate_connect(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
struct wireless_dev *pwdev = padapter->rtw_wdev;
if (pwdev->iftype != NL80211_IFTYPE_STATION
&& pwdev->iftype != NL80211_IFTYPE_P2P_CLIENT
) {
return;
}
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
return;
{
struct wlan_bssid_ex *pnetwork = &(padapter->mlmeextpriv.mlmext_info.network);
struct wlan_network *scanned = pmlmepriv->cur_network_scanned;
if (!scanned) {
rtw_warn_on(1);
goto check_bss;
}
if (!memcmp(scanned->network.mac_address, pnetwork->mac_address, sizeof(NDIS_802_11_MAC_ADDRESS))
&& !memcmp(&(scanned->network.ssid), &(pnetwork->ssid), sizeof(struct ndis_802_11_ssid))
)
rtw_cfg80211_inform_bss(padapter, scanned);
else
rtw_warn_on(1);
}
check_bss:
if (!rtw_cfg80211_check_bss(padapter))
netdev_dbg(padapter->pnetdev,
FUNC_ADPT_FMT " BSS not found !!\n",
FUNC_ADPT_ARG(padapter));
if (rtw_to_roam(padapter) > 0) {
struct wiphy *wiphy = pwdev->wiphy;
struct ieee80211_channel *notify_channel;
u32 freq;
u16 channel = cur_network->network.configuration.ds_config;
struct cfg80211_roam_info roam_info = {};
freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
notify_channel = ieee80211_get_channel(wiphy, freq);
roam_info.links[0].channel = notify_channel;
roam_info.links[0].bssid = cur_network->network.mac_address;
roam_info.req_ie =
pmlmepriv->assoc_req + sizeof(struct ieee80211_hdr_3addr) + 2;
roam_info.req_ie_len =
pmlmepriv->assoc_req_len - sizeof(struct ieee80211_hdr_3addr) - 2;
roam_info.resp_ie =
pmlmepriv->assoc_rsp + sizeof(struct ieee80211_hdr_3addr) + 6;
roam_info.resp_ie_len =
pmlmepriv->assoc_rsp_len - sizeof(struct ieee80211_hdr_3addr) - 6;
cfg80211_roamed(padapter->pnetdev, &roam_info, GFP_ATOMIC);
} else {
cfg80211_connect_result(padapter->pnetdev, cur_network->network.mac_address
, pmlmepriv->assoc_req + sizeof(struct ieee80211_hdr_3addr) + 2
, pmlmepriv->assoc_req_len - sizeof(struct ieee80211_hdr_3addr) - 2
, pmlmepriv->assoc_rsp + sizeof(struct ieee80211_hdr_3addr) + 6
, pmlmepriv->assoc_rsp_len - sizeof(struct ieee80211_hdr_3addr) - 6
, WLAN_STATUS_SUCCESS, GFP_ATOMIC);
}
}
void rtw_cfg80211_indicate_disconnect(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct wireless_dev *pwdev = padapter->rtw_wdev;
if (pwdev->iftype != NL80211_IFTYPE_STATION
&& pwdev->iftype != NL80211_IFTYPE_P2P_CLIENT
) {
return;
}
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true)
return;
if (!padapter->mlmepriv.not_indic_disco) {
if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
cfg80211_disconnected(padapter->pnetdev, 0,
NULL, 0, true, GFP_ATOMIC);
} else {
cfg80211_connect_result(padapter->pnetdev, NULL, NULL, 0, NULL, 0,
WLAN_STATUS_UNSPECIFIED_FAILURE, GFP_ATOMIC/*GFP_KERNEL*/);
}
}
}
static int rtw_cfg80211_ap_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
{
int ret = 0;
u32 wep_key_idx, wep_key_len;
struct sta_info *psta = NULL, *pbcmc_sta = NULL;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &(padapter->securitypriv);
struct sta_priv *pstapriv = &padapter->stapriv;
char *grpkey = padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey;
char *txkey = padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey;
char *rxkey = padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey;
param->u.crypt.err = 0;
param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
if (param_len != sizeof(struct ieee_param) + param->u.crypt.key_len) {
ret = -EINVAL;
goto exit;
}
if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
if (param->u.crypt.idx >= WEP_KEYS) {
ret = -EINVAL;
goto exit;
}
} else {
psta = rtw_get_stainfo(pstapriv, param->sta_addr);
if (!psta)
/* ret = -EINVAL; */
goto exit;
}
if (strcmp(param->u.crypt.alg, "none") == 0 && !psta)
goto exit;
if (strcmp(param->u.crypt.alg, "WEP") == 0 && !psta) {
wep_key_idx = param->u.crypt.idx;
wep_key_len = param->u.crypt.key_len;
if ((wep_key_idx >= WEP_KEYS) || (wep_key_len <= 0)) {
ret = -EINVAL;
goto exit;
}
if (wep_key_len > 0)
wep_key_len = wep_key_len <= 5 ? 5 : 13;
if (psecuritypriv->bWepDefaultKeyIdxSet == 0) {
/* wep default key has not been set, so use this key index as default key. */
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
if (wep_key_len == 13) {
psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
}
psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx;
}
memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), param->u.crypt.key, wep_key_len);
psecuritypriv->dot11DefKeylen[wep_key_idx] = wep_key_len;
rtw_ap_set_wep_key(padapter, param->u.crypt.key, wep_key_len, wep_key_idx, 1);
goto exit;
}
/* group key */
if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
/* group key */
if (param->u.crypt.set_tx == 0) {
if (strcmp(param->u.crypt.alg, "WEP") == 0) {
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
if (param->u.crypt.key_len == 13)
psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
/* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
/* set mic key */
memcpy(txkey, &(param->u.crypt.key[16]), 8);
memcpy(rxkey, &(param->u.crypt.key[24]), 8);
psecuritypriv->busetkipkey = true;
} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
psecuritypriv->dot118021XGrpPrivacy = _AES_;
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
} else {
psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
}
psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
psecuritypriv->binstallGrpkey = true;
psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */
rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
if (pbcmc_sta) {
pbcmc_sta->ieee8021x_blocked = false;
pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
}
}
goto exit;
}
if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) { /* psk/802_1x */
if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
if (param->u.crypt.set_tx == 1) { /* pairwise key */
memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
if (strcmp(param->u.crypt.alg, "WEP") == 0) {
psta->dot118021XPrivacy = _WEP40_;
if (param->u.crypt.key_len == 13)
psta->dot118021XPrivacy = _WEP104_;
} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
psta->dot118021XPrivacy = _TKIP_;
/* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
/* set mic key */
memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
psecuritypriv->busetkipkey = true;
} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
psta->dot118021XPrivacy = _AES_;
} else {
psta->dot118021XPrivacy = _NO_PRIVACY_;
}
rtw_ap_set_pairwise_key(padapter, psta);
psta->ieee8021x_blocked = false;
psta->bpairwise_key_installed = true;
} else { /* group key??? */
if (strcmp(param->u.crypt.alg, "WEP") == 0) {
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
if (param->u.crypt.key_len == 13)
psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
/* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
/* set mic key */
memcpy(txkey, &(param->u.crypt.key[16]), 8);
memcpy(rxkey, &(param->u.crypt.key[24]), 8);
psecuritypriv->busetkipkey = true;
} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
psecuritypriv->dot118021XGrpPrivacy = _AES_;
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
} else {
psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
}
psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
psecuritypriv->binstallGrpkey = true;
psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */
rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
if (pbcmc_sta) {
pbcmc_sta->ieee8021x_blocked = false;
pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
}
}
}
}
exit:
return ret;
}
static int rtw_cfg80211_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
{
int ret = 0;
u8 max_idx;
u32 wep_key_idx, wep_key_len;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
param->u.crypt.err = 0;
param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
if (param_len < (u32)((u8 *)param->u.crypt.key - (u8 *)param) + param->u.crypt.key_len) {
ret = -EINVAL;
goto exit;
}
if (param->sta_addr[0] != 0xff || param->sta_addr[1] != 0xff ||
param->sta_addr[2] != 0xff || param->sta_addr[3] != 0xff ||
param->sta_addr[4] != 0xff || param->sta_addr[5] != 0xff) {
ret = -EINVAL;
goto exit;
}
if (strcmp(param->u.crypt.alg, "WEP") == 0)
max_idx = WEP_KEYS - 1;
else
max_idx = BIP_MAX_KEYID;
if (param->u.crypt.idx > max_idx) {
netdev_err(dev, "Error crypt.idx %d > %d\n", param->u.crypt.idx, max_idx);
ret = -EINVAL;
goto exit;
}
if (strcmp(param->u.crypt.alg, "WEP") == 0) {
wep_key_idx = param->u.crypt.idx;
wep_key_len = param->u.crypt.key_len;
if (wep_key_len <= 0) {
ret = -EINVAL;
goto exit;
}
if (psecuritypriv->bWepDefaultKeyIdxSet == 0) {
/* wep default key has not been set, so use this key index as default key. */
wep_key_len = wep_key_len <= 5 ? 5 : 13;
psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
if (wep_key_len == 13) {
psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
}
psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx;
}
memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), param->u.crypt.key, wep_key_len);
psecuritypriv->dot11DefKeylen[wep_key_idx] = wep_key_len;
rtw_set_key(padapter, psecuritypriv, wep_key_idx, 0, true);
goto exit;
}
if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) { /* 802_1x */
struct sta_info *psta, *pbcmc_sta;
struct sta_priv *pstapriv = &padapter->stapriv;
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_MP_STATE) == true) { /* sta mode */
psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
if (psta) {
/* Jeff: don't disable ieee8021x_blocked while clearing key */
if (strcmp(param->u.crypt.alg, "none") != 0)
psta->ieee8021x_blocked = false;
if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) ||
(padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled)) {
psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
}
if (param->u.crypt.set_tx == 1) { /* pairwise key */
memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */
/* DEBUG_ERR(("\nset key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len)); */
memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
padapter->securitypriv.busetkipkey = false;
/* _set_timer(&padapter->securitypriv.tkip_timer, 50); */
}
rtw_setstakey_cmd(padapter, psta, true, true);
} else { /* group key */
if (strcmp(param->u.crypt.alg, "TKIP") == 0 || strcmp(param->u.crypt.alg, "CCMP") == 0) {
memcpy(padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
memcpy(padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
memcpy(padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
padapter->securitypriv.binstallGrpkey = true;
padapter->securitypriv.dot118021XGrpKeyid = param->u.crypt.idx;
rtw_set_key(padapter, &padapter->securitypriv, param->u.crypt.idx, 1, true);
} else if (strcmp(param->u.crypt.alg, "BIP") == 0) {
/* save the IGTK key, length 16 bytes */
memcpy(padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
/*
for (no = 0;no<16;no++)
printk(" %02x ", padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey[no]);
*/
padapter->securitypriv.dot11wBIPKeyid = param->u.crypt.idx;
padapter->securitypriv.binstallBIPkey = true;
}
}
}
pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
if (!pbcmc_sta) {
/* DEBUG_ERR(("Set OID_802_11_ADD_KEY: bcmc stainfo is null\n")); */
} else {
/* Jeff: don't disable ieee8021x_blocked while clearing key */
if (strcmp(param->u.crypt.alg, "none") != 0)
pbcmc_sta->ieee8021x_blocked = false;
if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) ||
(padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled)) {
pbcmc_sta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
}
}
} else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) { /* adhoc mode */
}
}
exit:
return ret;
}
static int cfg80211_rtw_add_key(struct wiphy *wiphy, struct net_device *ndev,
int link_id, u8 key_index, bool pairwise,
const u8 *mac_addr, struct key_params *params)
{
char *alg_name;
u32 param_len;
struct ieee_param *param = NULL;
int ret = 0;
struct adapter *padapter = rtw_netdev_priv(ndev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
param_len = sizeof(struct ieee_param) + params->key_len;
param = rtw_malloc(param_len);
if (!param)
return -1;
memset(param, 0, param_len);
param->cmd = IEEE_CMD_SET_ENCRYPTION;
eth_broadcast_addr(param->sta_addr);
switch (params->cipher) {
case IW_AUTH_CIPHER_NONE:
/* todo: remove key */
/* remove = 1; */
alg_name = "none";
break;
case WLAN_CIPHER_SUITE_WEP40:
case WLAN_CIPHER_SUITE_WEP104:
alg_name = "WEP";
break;
case WLAN_CIPHER_SUITE_TKIP:
alg_name = "TKIP";
break;
case WLAN_CIPHER_SUITE_CCMP:
alg_name = "CCMP";
break;
case WLAN_CIPHER_SUITE_AES_CMAC:
alg_name = "BIP";
break;
default:
ret = -ENOTSUPP;
goto addkey_end;
}
strncpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
if (!mac_addr || is_broadcast_ether_addr(mac_addr))
param->u.crypt.set_tx = 0; /* for wpa/wpa2 group key */
else
param->u.crypt.set_tx = 1; /* for wpa/wpa2 pairwise key */
param->u.crypt.idx = key_index;
if (params->seq_len && params->seq)
memcpy(param->u.crypt.seq, (u8 *)params->seq, params->seq_len);
if (params->key_len && params->key) {
param->u.crypt.key_len = params->key_len;
memcpy(param->u.crypt.key, (u8 *)params->key, params->key_len);
}
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) == true) {
ret = rtw_cfg80211_set_encryption(ndev, param, param_len);
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
if (mac_addr)
memcpy(param->sta_addr, (void *)mac_addr, ETH_ALEN);
ret = rtw_cfg80211_ap_set_encryption(ndev, param, param_len);
} else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true
|| check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) {
ret = rtw_cfg80211_set_encryption(ndev, param, param_len);
}
addkey_end:
kfree(param);
return ret;
}
static int cfg80211_rtw_get_key(struct wiphy *wiphy, struct net_device *ndev,
int link_id, u8 key_index, bool pairwise,
const u8 *mac_addr, void *cookie,
void (*callback)(void *cookie,
struct key_params*))
{
return 0;
}
static int cfg80211_rtw_del_key(struct wiphy *wiphy, struct net_device *ndev,
int link_id, u8 key_index, bool pairwise,
const u8 *mac_addr)
{
struct adapter *padapter = rtw_netdev_priv(ndev);
struct security_priv *psecuritypriv = &padapter->securitypriv;
if (key_index == psecuritypriv->dot11PrivacyKeyIndex) {
/* clear the flag of wep default key set. */
psecuritypriv->bWepDefaultKeyIdxSet = 0;
}
return 0;
}
static int cfg80211_rtw_set_default_key(struct wiphy *wiphy,
struct net_device *ndev, int link_id,
u8 key_index, bool unicast,
bool multicast)
{
struct adapter *padapter = rtw_netdev_priv(ndev);
struct security_priv *psecuritypriv = &padapter->securitypriv;
if ((key_index < WEP_KEYS) && ((psecuritypriv->dot11PrivacyAlgrthm == _WEP40_) || (psecuritypriv->dot11PrivacyAlgrthm == _WEP104_))) { /* set wep default key */
psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
psecuritypriv->dot11PrivacyKeyIndex = key_index;
psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
if (psecuritypriv->dot11DefKeylen[key_index] == 13) {
psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
}
psecuritypriv->bWepDefaultKeyIdxSet = 1; /* set the flag to represent that wep default key has been set */
}
return 0;
}
static int cfg80211_rtw_get_station(struct wiphy *wiphy,
struct net_device *ndev,
const u8 *mac,
struct station_info *sinfo)
{
int ret = 0;
struct adapter *padapter = rtw_netdev_priv(ndev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
sinfo->filled = 0;
if (!mac) {
ret = -ENOENT;
goto exit;
}
psta = rtw_get_stainfo(pstapriv, (u8 *)mac);
if (!psta) {
ret = -ENOENT;
goto exit;
}
/* for infra./P2PClient mode */
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)
&& check_fwstate(pmlmepriv, _FW_LINKED)) {
struct wlan_network *cur_network = &(pmlmepriv->cur_network);
if (memcmp((u8 *)mac, cur_network->network.mac_address, ETH_ALEN)) {
ret = -ENOENT;
goto exit;
}
sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
sinfo->signal = translate_percentage_to_dbm(padapter->recvpriv.signal_strength);
sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
sinfo->txrate.legacy = rtw_get_cur_max_rate(padapter);
sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS);
sinfo->rx_packets = sta_rx_data_pkts(psta);
sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_PACKETS);
sinfo->tx_packets = psta->sta_stats.tx_pkts;
sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED);
}
/* for Ad-Hoc/AP mode */
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) ||
check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||
check_fwstate(pmlmepriv, WIFI_AP_STATE)) &&
check_fwstate(pmlmepriv, _FW_LINKED)) {
/* TODO: should acquire station info... */
}
exit:
return ret;
}
static int cfg80211_rtw_change_iface(struct wiphy *wiphy,
struct net_device *ndev,
enum nl80211_iftype type,
struct vif_params *params)
{
enum nl80211_iftype old_type;
enum ndis_802_11_network_infrastructure networkType;
struct adapter *padapter = rtw_netdev_priv(ndev);
struct wireless_dev *rtw_wdev = padapter->rtw_wdev;
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
int ret = 0;
if (adapter_to_dvobj(padapter)->processing_dev_remove == true) {
ret = -EPERM;
goto exit;
}
{
if (netdev_open(ndev) != 0) {
ret = -EPERM;
goto exit;
}
}
if (rtw_pwr_wakeup(padapter) == _FAIL) {
ret = -EPERM;
goto exit;
}
old_type = rtw_wdev->iftype;
if (old_type != type) {
pmlmeext->action_public_rxseq = 0xffff;
pmlmeext->action_public_dialog_token = 0xff;
}
switch (type) {
case NL80211_IFTYPE_ADHOC:
networkType = Ndis802_11IBSS;
break;
case NL80211_IFTYPE_STATION:
networkType = Ndis802_11Infrastructure;
break;
case NL80211_IFTYPE_AP:
networkType = Ndis802_11APMode;
break;
default:
ret = -EOPNOTSUPP;
goto exit;
}
rtw_wdev->iftype = type;
if (rtw_set_802_11_infrastructure_mode(padapter, networkType) == false) {
rtw_wdev->iftype = old_type;
ret = -EPERM;
goto exit;
}
rtw_setopmode_cmd(padapter, networkType, true);
exit:
return ret;
}
void rtw_cfg80211_indicate_scan_done(struct adapter *adapter, bool aborted)
{
struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(adapter);
struct cfg80211_scan_info info = {
.aborted = aborted
};
spin_lock_bh(&pwdev_priv->scan_req_lock);
if (pwdev_priv->scan_request) {
/* avoid WARN_ON(request != wiphy_to_dev(request->wiphy)->scan_req); */
if (pwdev_priv->scan_request->wiphy == pwdev_priv->rtw_wdev->wiphy)
cfg80211_scan_done(pwdev_priv->scan_request, &info);
pwdev_priv->scan_request = NULL;
}
spin_unlock_bh(&pwdev_priv->scan_req_lock);
}
void rtw_cfg80211_unlink_bss(struct adapter *padapter, struct wlan_network *pnetwork)
{
struct wireless_dev *pwdev = padapter->rtw_wdev;
struct wiphy *wiphy = pwdev->wiphy;
struct cfg80211_bss *bss = NULL;
struct wlan_bssid_ex *select_network = &pnetwork->network;
bss = cfg80211_get_bss(wiphy, NULL/*notify_channel*/,
select_network->mac_address,
select_network->ssid.ssid,
select_network->ssid.ssid_length,
IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
if (bss) {
cfg80211_unlink_bss(wiphy, bss);
cfg80211_put_bss(padapter->rtw_wdev->wiphy, bss);
}
}
void rtw_cfg80211_surveydone_event_callback(struct adapter *padapter)
{
struct list_head *plist, *phead;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct __queue *queue = &(pmlmepriv->scanned_queue);
struct wlan_network *pnetwork = NULL;
spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
phead = get_list_head(queue);
list_for_each(plist, phead)
{
pnetwork = list_entry(plist, struct wlan_network, list);
/* report network only if the current channel set contains the channel to which this network belongs */
if (rtw_ch_set_search_ch(padapter->mlmeextpriv.channel_set, pnetwork->network.configuration.ds_config) >= 0
&& true == rtw_validate_ssid(&(pnetwork->network.ssid))) {
/* ev =translate_scan(padapter, a, pnetwork, ev, stop); */
rtw_cfg80211_inform_bss(padapter, pnetwork);
}
}
spin_unlock_bh(&(pmlmepriv->scanned_queue.lock));
}
static int rtw_cfg80211_set_probe_req_wpsp2pie(struct adapter *padapter, char *buf, int len)
{
int ret = 0;
uint wps_ielen = 0;
u8 *wps_ie;
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
if (len > 0) {
wps_ie = rtw_get_wps_ie(buf, len, NULL, &wps_ielen);
if (wps_ie) {
if (pmlmepriv->wps_probe_req_ie) {
pmlmepriv->wps_probe_req_ie_len = 0;
kfree(pmlmepriv->wps_probe_req_ie);
pmlmepriv->wps_probe_req_ie = NULL;
}
pmlmepriv->wps_probe_req_ie = rtw_malloc(wps_ielen);
if (!pmlmepriv->wps_probe_req_ie)
return -EINVAL;
memcpy(pmlmepriv->wps_probe_req_ie, wps_ie, wps_ielen);
pmlmepriv->wps_probe_req_ie_len = wps_ielen;
}
}
return ret;
}
static int cfg80211_rtw_scan(struct wiphy *wiphy
, struct cfg80211_scan_request *request)
{
struct net_device *ndev = wdev_to_ndev(request->wdev);
int i;
u8 _status = false;
int ret = 0;
struct ndis_802_11_ssid *ssid = NULL;
struct rtw_ieee80211_channel ch[RTW_CHANNEL_SCAN_AMOUNT];
u8 survey_times = 3;
u8 survey_times_for_one_ch = 6;
struct cfg80211_ssid *ssids = request->ssids;
int j = 0;
bool need_indicate_scan_done = false;
struct adapter *padapter;
struct rtw_wdev_priv *pwdev_priv;
struct mlme_priv *pmlmepriv;
if (!ndev) {
ret = -EINVAL;
goto exit;
}
padapter = rtw_netdev_priv(ndev);
pwdev_priv = adapter_wdev_data(padapter);
pmlmepriv = &padapter->mlmepriv;
/* endif */
spin_lock_bh(&pwdev_priv->scan_req_lock);
pwdev_priv->scan_request = request;
spin_unlock_bh(&pwdev_priv->scan_req_lock);
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
if (check_fwstate(pmlmepriv, WIFI_UNDER_WPS | _FW_UNDER_SURVEY | _FW_UNDER_LINKING) == true) {
need_indicate_scan_done = true;
goto check_need_indicate_scan_done;
}
}
rtw_ps_deny(padapter, PS_DENY_SCAN);
if (rtw_pwr_wakeup(padapter) == _FAIL) {
need_indicate_scan_done = true;
goto check_need_indicate_scan_done;
}
if (request->ie && request->ie_len > 0)
rtw_cfg80211_set_probe_req_wpsp2pie(padapter, (u8 *)request->ie, request->ie_len);
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true) {
need_indicate_scan_done = true;
goto check_need_indicate_scan_done;
} else if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) {
ret = -EBUSY;
goto check_need_indicate_scan_done;
}
if (pmlmepriv->LinkDetectInfo.bBusyTraffic == true) {
static unsigned long lastscantime;
unsigned long passtime;
passtime = jiffies_to_msecs(jiffies - lastscantime);
lastscantime = jiffies;
if (passtime > 12000) {
need_indicate_scan_done = true;
goto check_need_indicate_scan_done;
}
}
if (rtw_is_scan_deny(padapter)) {
need_indicate_scan_done = true;
goto check_need_indicate_scan_done;
}
ssid = kzalloc(RTW_SSID_SCAN_AMOUNT * sizeof(struct ndis_802_11_ssid),
GFP_KERNEL);
if (!ssid) {
ret = -ENOMEM;
goto check_need_indicate_scan_done;
}
/* parsing request ssids, n_ssids */
for (i = 0; i < request->n_ssids && i < RTW_SSID_SCAN_AMOUNT; i++) {
memcpy(ssid[i].ssid, ssids[i].ssid, ssids[i].ssid_len);
ssid[i].ssid_length = ssids[i].ssid_len;
}
/* parsing channels, n_channels */
memset(ch, 0, sizeof(struct rtw_ieee80211_channel) * RTW_CHANNEL_SCAN_AMOUNT);
for (i = 0; i < request->n_channels && i < RTW_CHANNEL_SCAN_AMOUNT; i++) {
ch[i].hw_value = request->channels[i]->hw_value;
ch[i].flags = request->channels[i]->flags;
}
spin_lock_bh(&pmlmepriv->lock);
if (request->n_channels == 1) {
for (i = 1; i < survey_times_for_one_ch; i++)
memcpy(&ch[i], &ch[0], sizeof(struct rtw_ieee80211_channel));
_status = rtw_sitesurvey_cmd(padapter, ssid, RTW_SSID_SCAN_AMOUNT, ch, survey_times_for_one_ch);
} else if (request->n_channels <= 4) {
for (j = request->n_channels - 1; j >= 0; j--)
for (i = 0; i < survey_times; i++)
memcpy(&ch[j * survey_times + i], &ch[j], sizeof(struct rtw_ieee80211_channel));
_status = rtw_sitesurvey_cmd(padapter, ssid, RTW_SSID_SCAN_AMOUNT, ch, survey_times * request->n_channels);
} else {
_status = rtw_sitesurvey_cmd(padapter, ssid, RTW_SSID_SCAN_AMOUNT, NULL, 0);
}
spin_unlock_bh(&pmlmepriv->lock);
if (_status == false)
ret = -1;
check_need_indicate_scan_done:
kfree(ssid);
if (need_indicate_scan_done) {
rtw_cfg80211_surveydone_event_callback(padapter);
rtw_cfg80211_indicate_scan_done(padapter, false);
}
rtw_ps_deny_cancel(padapter, PS_DENY_SCAN);
exit:
return ret;
}
static int cfg80211_rtw_set_wiphy_params(struct wiphy *wiphy, u32 changed)
{
return 0;
}
static int rtw_cfg80211_set_wpa_version(struct security_priv *psecuritypriv, u32 wpa_version)
{
if (!wpa_version) {
psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
return 0;
}
if (wpa_version & (NL80211_WPA_VERSION_1 | NL80211_WPA_VERSION_2))
psecuritypriv->ndisauthtype = Ndis802_11AuthModeWPAPSK;
return 0;
}
static int rtw_cfg80211_set_auth_type(struct security_priv *psecuritypriv,
enum nl80211_auth_type sme_auth_type)
{
switch (sme_auth_type) {
case NL80211_AUTHTYPE_AUTOMATIC:
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
break;
case NL80211_AUTHTYPE_OPEN_SYSTEM:
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
if (psecuritypriv->ndisauthtype > Ndis802_11AuthModeWPA)
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
break;
case NL80211_AUTHTYPE_SHARED_KEY:
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
default:
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
/* return -ENOTSUPP; */
}
return 0;
}
static int rtw_cfg80211_set_cipher(struct security_priv *psecuritypriv, u32 cipher, bool ucast)
{
u32 ndisencryptstatus = Ndis802_11EncryptionDisabled;
u32 *profile_cipher = ucast ? &psecuritypriv->dot11PrivacyAlgrthm :
&psecuritypriv->dot118021XGrpPrivacy;
if (!cipher) {
*profile_cipher = _NO_PRIVACY_;
psecuritypriv->ndisencryptstatus = ndisencryptstatus;
return 0;
}
switch (cipher) {
case IW_AUTH_CIPHER_NONE:
*profile_cipher = _NO_PRIVACY_;
ndisencryptstatus = Ndis802_11EncryptionDisabled;
break;
case WLAN_CIPHER_SUITE_WEP40:
*profile_cipher = _WEP40_;
ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
case WLAN_CIPHER_SUITE_WEP104:
*profile_cipher = _WEP104_;
ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
case WLAN_CIPHER_SUITE_TKIP:
*profile_cipher = _TKIP_;
ndisencryptstatus = Ndis802_11Encryption2Enabled;
break;
case WLAN_CIPHER_SUITE_CCMP:
*profile_cipher = _AES_;
ndisencryptstatus = Ndis802_11Encryption3Enabled;
break;
default:
return -ENOTSUPP;
}
if (ucast) {
psecuritypriv->ndisencryptstatus = ndisencryptstatus;
/* if (psecuritypriv->dot11PrivacyAlgrthm >= _AES_) */
/* psecuritypriv->ndisauthtype = Ndis802_11AuthModeWPA2PSK; */
}
return 0;
}
static int rtw_cfg80211_set_key_mgt(struct security_priv *psecuritypriv, u32 key_mgt)
{
if (key_mgt == WLAN_AKM_SUITE_8021X)
/* auth_type = UMAC_AUTH_TYPE_8021X; */
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
else if (key_mgt == WLAN_AKM_SUITE_PSK) {
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
}
return 0;
}
static int rtw_cfg80211_set_wpa_ie(struct adapter *padapter, u8 *pie, size_t ielen)
{
u8 *buf = NULL;
int group_cipher = 0, pairwise_cipher = 0;
int ret = 0;
int wpa_ielen = 0;
int wpa2_ielen = 0;
u8 *pwpa, *pwpa2;
u8 null_addr[] = {0, 0, 0, 0, 0, 0};
if (!pie || !ielen) {
/* Treat this as normal case, but need to clear WIFI_UNDER_WPS */
_clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
goto exit;
}
if (ielen > MAX_WPA_IE_LEN + MAX_WPS_IE_LEN + MAX_P2P_IE_LEN) {
ret = -EINVAL;
goto exit;
}
buf = rtw_zmalloc(ielen);
if (!buf) {
ret = -ENOMEM;
goto exit;
}
memcpy(buf, pie, ielen);
if (ielen < RSN_HEADER_LEN) {
ret = -1;
goto exit;
}
pwpa = rtw_get_wpa_ie(buf, &wpa_ielen, ielen);
if (pwpa && wpa_ielen > 0) {
if (rtw_parse_wpa_ie(pwpa, wpa_ielen + 2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK;
memcpy(padapter->securitypriv.supplicant_ie, &pwpa[0], wpa_ielen + 2);
}
}
pwpa2 = rtw_get_wpa2_ie(buf, &wpa2_ielen, ielen);
if (pwpa2 && wpa2_ielen > 0) {
if (rtw_parse_wpa2_ie(pwpa2, wpa2_ielen + 2, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK;
memcpy(padapter->securitypriv.supplicant_ie, &pwpa2[0], wpa2_ielen + 2);
}
}
if (group_cipher == 0)
group_cipher = WPA_CIPHER_NONE;
if (pairwise_cipher == 0)
pairwise_cipher = WPA_CIPHER_NONE;
switch (group_cipher) {
case WPA_CIPHER_NONE:
padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
break;
case WPA_CIPHER_WEP40:
padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
case WPA_CIPHER_TKIP:
padapter->securitypriv.dot118021XGrpPrivacy = _TKIP_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
break;
case WPA_CIPHER_CCMP:
padapter->securitypriv.dot118021XGrpPrivacy = _AES_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
break;
case WPA_CIPHER_WEP104:
padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
}
switch (pairwise_cipher) {
case WPA_CIPHER_NONE:
padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
break;
case WPA_CIPHER_WEP40:
padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
case WPA_CIPHER_TKIP:
padapter->securitypriv.dot11PrivacyAlgrthm = _TKIP_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
break;
case WPA_CIPHER_CCMP:
padapter->securitypriv.dot11PrivacyAlgrthm = _AES_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
break;
case WPA_CIPHER_WEP104:
padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
}
{/* handle wps_ie */
uint wps_ielen;
u8 *wps_ie;
wps_ie = rtw_get_wps_ie(buf, ielen, NULL, &wps_ielen);
if (wps_ie && wps_ielen > 0) {
padapter->securitypriv.wps_ie_len = min_t(uint, wps_ielen, MAX_WPS_IE_LEN);
memcpy(padapter->securitypriv.wps_ie, wps_ie, padapter->securitypriv.wps_ie_len);
set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS);
} else {
_clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
}
}
/* TKIP and AES disallow multicast packets until installing group key */
if (padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_
|| padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_WTMIC_
|| padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)
/* WPS open need to enable multicast */
/* check_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS) == true) */
rtw_hal_set_hwreg(padapter, HW_VAR_OFF_RCR_AM, null_addr);
exit:
kfree(buf);
if (ret)
_clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
return ret;
}
static int cfg80211_rtw_join_ibss(struct wiphy *wiphy, struct net_device *ndev,
struct cfg80211_ibss_params *params)
{
struct adapter *padapter = rtw_netdev_priv(ndev);
struct ndis_802_11_ssid ndis_ssid;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
int ret = 0;
if (rtw_pwr_wakeup(padapter) == _FAIL) {
ret = -EPERM;
goto exit;
}
if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
ret = -EPERM;
goto exit;
}
if (!params->ssid || !params->ssid_len) {
ret = -EINVAL;
goto exit;
}
if (params->ssid_len > IW_ESSID_MAX_SIZE) {
ret = -E2BIG;
goto exit;
}
memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
ndis_ssid.ssid_length = params->ssid_len;
memcpy(ndis_ssid.ssid, (u8 *)params->ssid, params->ssid_len);
psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled;
psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
ret = rtw_cfg80211_set_auth_type(psecuritypriv, NL80211_AUTHTYPE_OPEN_SYSTEM);
rtw_set_802_11_authentication_mode(padapter, psecuritypriv->ndisauthtype);
if (rtw_set_802_11_ssid(padapter, &ndis_ssid) == false) {
ret = -1;
goto exit;
}
exit:
return ret;
}
static int cfg80211_rtw_leave_ibss(struct wiphy *wiphy, struct net_device *ndev)
{
struct adapter *padapter = rtw_netdev_priv(ndev);
struct wireless_dev *rtw_wdev = padapter->rtw_wdev;
enum nl80211_iftype old_type;
int ret = 0;
old_type = rtw_wdev->iftype;
rtw_set_to_roam(padapter, 0);
if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
rtw_scan_abort(padapter);
LeaveAllPowerSaveMode(padapter);
rtw_wdev->iftype = NL80211_IFTYPE_STATION;
if (rtw_set_802_11_infrastructure_mode(padapter, Ndis802_11Infrastructure) == false) {
rtw_wdev->iftype = old_type;
ret = -EPERM;
goto leave_ibss;
}
rtw_setopmode_cmd(padapter, Ndis802_11Infrastructure, true);
}
leave_ibss:
return ret;
}
static int cfg80211_rtw_connect(struct wiphy *wiphy, struct net_device *ndev,
struct cfg80211_connect_params *sme)
{
int ret = 0;
enum ndis_802_11_authentication_mode authmode;
struct ndis_802_11_ssid ndis_ssid;
struct adapter *padapter = rtw_netdev_priv(ndev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
padapter->mlmepriv.not_indic_disco = true;
if (adapter_wdev_data(padapter)->block == true) {
ret = -EBUSY;
goto exit;
}
rtw_ps_deny(padapter, PS_DENY_JOIN);
if (rtw_pwr_wakeup(padapter) == _FAIL) {
ret = -EPERM;
goto exit;
}
if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
ret = -EPERM;
goto exit;
}
if (!sme->ssid || !sme->ssid_len) {
ret = -EINVAL;
goto exit;
}
if (sme->ssid_len > IW_ESSID_MAX_SIZE) {
ret = -E2BIG;
goto exit;
}
memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
ndis_ssid.ssid_length = sme->ssid_len;
memcpy(ndis_ssid.ssid, (u8 *)sme->ssid, sme->ssid_len);
if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING) == true) {
ret = -EBUSY;
goto exit;
}
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY) == true)
rtw_scan_abort(padapter);
psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled;
psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
ret = rtw_cfg80211_set_wpa_version(psecuritypriv, sme->crypto.wpa_versions);
if (ret < 0)
goto exit;
ret = rtw_cfg80211_set_auth_type(psecuritypriv, sme->auth_type);
if (ret < 0)
goto exit;
ret = rtw_cfg80211_set_wpa_ie(padapter, (u8 *)sme->ie, sme->ie_len);
if (ret < 0)
goto exit;
if (sme->crypto.n_ciphers_pairwise) {
ret = rtw_cfg80211_set_cipher(psecuritypriv, sme->crypto.ciphers_pairwise[0], true);
if (ret < 0)
goto exit;
}
/* For WEP Shared auth */
if ((psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_Shared ||
psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_Auto) && sme->key) {
u32 wep_key_idx, wep_key_len, wep_total_len;
struct ndis_802_11_wep *pwep = NULL;
wep_key_idx = sme->key_idx;
wep_key_len = sme->key_len;
if (sme->key_idx > WEP_KEYS) {
ret = -EINVAL;
goto exit;
}
if (wep_key_len > 0) {
wep_key_len = wep_key_len <= 5 ? 5 : 13;
wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, key_material);
pwep = rtw_malloc(wep_total_len);
if (!pwep) {
ret = -ENOMEM;
goto exit;
}
memset(pwep, 0, wep_total_len);
pwep->key_length = wep_key_len;
pwep->length = wep_total_len;
if (wep_key_len == 13) {
padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
}
} else {
ret = -EINVAL;
goto exit;
}
pwep->key_index = wep_key_idx;
pwep->key_index |= 0x80000000;
memcpy(pwep->key_material, (void *)sme->key, pwep->key_length);
if (rtw_set_802_11_add_wep(padapter, pwep) == (u8)_FAIL)
ret = -EOPNOTSUPP;
kfree(pwep);
if (ret < 0)
goto exit;
}
ret = rtw_cfg80211_set_cipher(psecuritypriv, sme->crypto.cipher_group, false);
if (ret < 0)
return ret;
if (sme->crypto.n_akm_suites) {
ret = rtw_cfg80211_set_key_mgt(psecuritypriv, sme->crypto.akm_suites[0]);
if (ret < 0)
goto exit;
}
authmode = psecuritypriv->ndisauthtype;
rtw_set_802_11_authentication_mode(padapter, authmode);
/* rtw_set_802_11_encryption_mode(padapter, padapter->securitypriv.ndisencryptstatus); */
if (rtw_set_802_11_connect(padapter, (u8 *)sme->bssid, &ndis_ssid) == false) {
ret = -1;
goto exit;
}
exit:
rtw_ps_deny_cancel(padapter, PS_DENY_JOIN);
padapter->mlmepriv.not_indic_disco = false;
return ret;
}
static int cfg80211_rtw_disconnect(struct wiphy *wiphy, struct net_device *ndev,
u16 reason_code)
{
struct adapter *padapter = rtw_netdev_priv(ndev);
rtw_set_to_roam(padapter, 0);
rtw_scan_abort(padapter);
LeaveAllPowerSaveMode(padapter);
rtw_disassoc_cmd(padapter, 500, false);
rtw_indicate_disconnect(padapter);
rtw_free_assoc_resources(padapter, 1);
rtw_pwr_wakeup(padapter);
return 0;
}
static int cfg80211_rtw_set_txpower(struct wiphy *wiphy,
struct wireless_dev *wdev,
enum nl80211_tx_power_setting type, int mbm)
{
return 0;
}
static int cfg80211_rtw_get_txpower(struct wiphy *wiphy,
struct wireless_dev *wdev, int *dbm)
{
*dbm = (12);
return 0;
}
inline bool rtw_cfg80211_pwr_mgmt(struct adapter *adapter)
{
struct rtw_wdev_priv *rtw_wdev_priv = adapter_wdev_data(adapter);
return rtw_wdev_priv->power_mgmt;
}
static int cfg80211_rtw_set_power_mgmt(struct wiphy *wiphy,
struct net_device *ndev,
bool enabled, int timeout)
{
struct adapter *padapter = rtw_netdev_priv(ndev);
struct rtw_wdev_priv *rtw_wdev_priv = adapter_wdev_data(padapter);
rtw_wdev_priv->power_mgmt = enabled;
if (!enabled)
LPS_Leave(padapter, "CFG80211_PWRMGMT");
return 0;
}
static int cfg80211_rtw_set_pmksa(struct wiphy *wiphy,
struct net_device *ndev,
struct cfg80211_pmksa *pmksa)
{
u8 index, blInserted = false;
struct adapter *padapter = rtw_netdev_priv(ndev);
struct security_priv *psecuritypriv = &padapter->securitypriv;
if (is_zero_ether_addr((u8 *)pmksa->bssid))
return -EINVAL;
blInserted = false;
/* overwrite PMKID */
for (index = 0 ; index < NUM_PMKID_CACHE; index++) {
if (!memcmp(psecuritypriv->PMKIDList[index].Bssid, (u8 *)pmksa->bssid, ETH_ALEN)) {
memcpy(psecuritypriv->PMKIDList[index].PMKID, (u8 *)pmksa->pmkid, WLAN_PMKID_LEN);
psecuritypriv->PMKIDList[index].bUsed = true;
psecuritypriv->PMKIDIndex = index + 1;
blInserted = true;
break;
}
}
if (!blInserted) {
memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].Bssid, (u8 *)pmksa->bssid, ETH_ALEN);
memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].PMKID, (u8 *)pmksa->pmkid, WLAN_PMKID_LEN);
psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].bUsed = true;
psecuritypriv->PMKIDIndex++;
if (psecuritypriv->PMKIDIndex == 16)
psecuritypriv->PMKIDIndex = 0;
}
return 0;
}
static int cfg80211_rtw_del_pmksa(struct wiphy *wiphy,
struct net_device *ndev,
struct cfg80211_pmksa *pmksa)
{
u8 index, bMatched = false;
struct adapter *padapter = rtw_netdev_priv(ndev);
struct security_priv *psecuritypriv = &padapter->securitypriv;
for (index = 0 ; index < NUM_PMKID_CACHE; index++) {
if (!memcmp(psecuritypriv->PMKIDList[index].Bssid, (u8 *)pmksa->bssid, ETH_ALEN)) {
/*
* BSSID is matched, the same AP => Remove this PMKID information
* and reset it.
*/
eth_zero_addr(psecuritypriv->PMKIDList[index].Bssid);
memset(psecuritypriv->PMKIDList[index].PMKID, 0x00, WLAN_PMKID_LEN);
psecuritypriv->PMKIDList[index].bUsed = false;
bMatched = true;
break;
}
}
if (!bMatched)
return -EINVAL;
return 0;
}
static int cfg80211_rtw_flush_pmksa(struct wiphy *wiphy,
struct net_device *ndev)
{
struct adapter *padapter = rtw_netdev_priv(ndev);
struct security_priv *psecuritypriv = &padapter->securitypriv;
memset(&psecuritypriv->PMKIDList[0], 0x00, sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);
psecuritypriv->PMKIDIndex = 0;
return 0;
}
void rtw_cfg80211_indicate_sta_assoc(struct adapter *padapter, u8 *pmgmt_frame, uint frame_len)
{
struct net_device *ndev = padapter->pnetdev;
{
struct station_info sinfo = {};
u8 ie_offset;
if (GetFrameSubType(pmgmt_frame) == WIFI_ASSOCREQ)
ie_offset = _ASOCREQ_IE_OFFSET_;
else /* WIFI_REASSOCREQ */
ie_offset = _REASOCREQ_IE_OFFSET_;
sinfo.filled = 0;
sinfo.assoc_req_ies = pmgmt_frame + WLAN_HDR_A3_LEN + ie_offset;
sinfo.assoc_req_ies_len = frame_len - WLAN_HDR_A3_LEN - ie_offset;
cfg80211_new_sta(ndev, GetAddr2Ptr(pmgmt_frame), &sinfo, GFP_ATOMIC);
}
}
void rtw_cfg80211_indicate_sta_disassoc(struct adapter *padapter, unsigned char *da, unsigned short reason)
{
struct net_device *ndev = padapter->pnetdev;
cfg80211_del_sta(ndev, da, GFP_ATOMIC);
}
static u8 rtw_get_chan_type(struct adapter *adapter)
{
struct mlme_ext_priv *mlme_ext = &adapter->mlmeextpriv;
switch (mlme_ext->cur_bwmode) {
case CHANNEL_WIDTH_20:
if (is_supported_ht(adapter->registrypriv.wireless_mode))
return NL80211_CHAN_HT20;
else
return NL80211_CHAN_NO_HT;
case CHANNEL_WIDTH_40:
if (mlme_ext->cur_ch_offset == HAL_PRIME_CHNL_OFFSET_UPPER)
return NL80211_CHAN_HT40PLUS;
else
return NL80211_CHAN_HT40MINUS;
default:
return NL80211_CHAN_HT20;
}
return NL80211_CHAN_HT20;
}
static int cfg80211_rtw_get_channel(struct wiphy *wiphy, struct wireless_dev *wdev,
unsigned int link_id,
struct cfg80211_chan_def *chandef)
{
struct adapter *adapter = wiphy_to_adapter(wiphy);
struct registry_priv *registrypriv = &adapter->registrypriv;
enum nl80211_channel_type chan_type;
struct ieee80211_channel *chan = NULL;
int channel;
int freq;
if (!adapter->rtw_wdev)
return -ENODEV;
channel = rtw_get_oper_ch(adapter);
if (!channel)
return -ENODATA;
freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
chan = ieee80211_get_channel(adapter->rtw_wdev->wiphy, freq);
if (registrypriv->ht_enable) {
chan_type = rtw_get_chan_type(adapter);
cfg80211_chandef_create(chandef, chan, chan_type);
} else {
cfg80211_chandef_create(chandef, chan, NL80211_CHAN_NO_HT);
}
return 0;
}
static netdev_tx_t rtw_cfg80211_monitor_if_xmit_entry(struct sk_buff *skb, struct net_device *ndev)
{
int rtap_len;
int qos_len = 0;
int dot11_hdr_len = 24;
int snap_len = 6;
unsigned char *pdata;
u16 frame_control;
unsigned char src_mac_addr[6];
unsigned char dst_mac_addr[6];
struct ieee80211_hdr *dot11_hdr;
struct ieee80211_radiotap_header *rtap_hdr;
struct adapter *padapter = rtw_netdev_priv(ndev);
if (!skb)
goto fail;
if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
goto fail;
rtap_hdr = (struct ieee80211_radiotap_header *)skb->data;
if (unlikely(rtap_hdr->it_version))
goto fail;
rtap_len = ieee80211_get_radiotap_len(skb->data);
if (unlikely(skb->len < rtap_len))
goto fail;
if (rtap_len != 14)
goto fail;
/* Skip the ratio tap header */
skb_pull(skb, rtap_len);
dot11_hdr = (struct ieee80211_hdr *)skb->data;
frame_control = le16_to_cpu(dot11_hdr->frame_control);
/* Check if the QoS bit is set */
if ((frame_control & IEEE80211_FCTL_FTYPE) == IEEE80211_FTYPE_DATA) {
/* Check if this ia a Wireless Distribution System (WDS) frame
* which has 4 MAC addresses
*/
if (frame_control & 0x0080)
qos_len = 2;
if ((frame_control & 0x0300) == 0x0300)
dot11_hdr_len += 6;
memcpy(dst_mac_addr, dot11_hdr->addr1, sizeof(dst_mac_addr));
memcpy(src_mac_addr, dot11_hdr->addr2, sizeof(src_mac_addr));
/* Skip the 802.11 header, QoS (if any) and SNAP, but leave spaces for
* two MAC addresses
*/
skb_pull(skb, dot11_hdr_len + qos_len + snap_len - sizeof(src_mac_addr) * 2);
pdata = (unsigned char *)skb->data;
memcpy(pdata, dst_mac_addr, sizeof(dst_mac_addr));
memcpy(pdata + sizeof(dst_mac_addr), src_mac_addr, sizeof(src_mac_addr));
/* Use the real net device to transmit the packet */
_rtw_xmit_entry(skb, padapter->pnetdev);
return NETDEV_TX_OK;
} else if ((frame_control & (IEEE80211_FCTL_FTYPE | IEEE80211_FCTL_STYPE)) ==
(IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION)) {
/* only for action frames */
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
/* u8 category, action, OUI_Subtype, dialogToken = 0; */
/* unsigned char *frame_body; */
struct ieee80211_hdr *pwlanhdr;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
u8 *buf = skb->data;
u32 len = skb->len;
u8 category, action;
if (rtw_action_frame_parse(buf, len, &category, &action) == false)
goto fail;
/* starting alloc mgmt frame to dump it */
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (!pmgntframe)
goto fail;
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->retry_ctrl = false;
memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
memcpy(pframe, (void *)buf, len);
pattrib->pktlen = len;
pwlanhdr = (struct ieee80211_hdr *)pframe;
/* update seq number */
pmlmeext->mgnt_seq = GetSequence(pwlanhdr);
pattrib->seqnum = pmlmeext->mgnt_seq;
pmlmeext->mgnt_seq++;
pattrib->last_txcmdsz = pattrib->pktlen;
dump_mgntframe(padapter, pmgntframe);
}
fail:
dev_kfree_skb_any(skb);
return NETDEV_TX_OK;
}
static const struct net_device_ops rtw_cfg80211_monitor_if_ops = {
.ndo_start_xmit = rtw_cfg80211_monitor_if_xmit_entry,
};
static int rtw_cfg80211_add_monitor_if(struct adapter *padapter, char *name, struct net_device **ndev)
{
int ret = 0;
struct net_device *mon_ndev = NULL;
struct wireless_dev *mon_wdev = NULL;
struct rtw_netdev_priv_indicator *pnpi;
struct rtw_wdev_priv *pwdev_priv = adapter_wdev_data(padapter);
if (!name) {
ret = -EINVAL;
goto out;
}
if (pwdev_priv->pmon_ndev) {
ret = -EBUSY;
goto out;
}
mon_ndev = alloc_etherdev(sizeof(struct rtw_netdev_priv_indicator));
if (!mon_ndev) {
ret = -ENOMEM;
goto out;
}
mon_ndev->type = ARPHRD_IEEE80211_RADIOTAP;
strncpy(mon_ndev->name, name, IFNAMSIZ);
mon_ndev->name[IFNAMSIZ - 1] = 0;
mon_ndev->needs_free_netdev = true;
mon_ndev->priv_destructor = rtw_ndev_destructor;
mon_ndev->netdev_ops = &rtw_cfg80211_monitor_if_ops;
pnpi = netdev_priv(mon_ndev);
pnpi->priv = padapter;
pnpi->sizeof_priv = sizeof(struct adapter);
/* wdev */
mon_wdev = rtw_zmalloc(sizeof(struct wireless_dev));
if (!mon_wdev) {
ret = -ENOMEM;
goto out;
}
mon_wdev->wiphy = padapter->rtw_wdev->wiphy;
mon_wdev->netdev = mon_ndev;
mon_wdev->iftype = NL80211_IFTYPE_MONITOR;
mon_ndev->ieee80211_ptr = mon_wdev;
ret = cfg80211_register_netdevice(mon_ndev);
if (ret)
goto out;
*ndev = pwdev_priv->pmon_ndev = mon_ndev;
memcpy(pwdev_priv->ifname_mon, name, IFNAMSIZ + 1);
out:
if (ret && mon_wdev) {
kfree(mon_wdev);
mon_wdev = NULL;
}
if (ret && mon_ndev) {
free_netdev(mon_ndev);
*ndev = mon_ndev = NULL;
}
return ret;
}
static struct wireless_dev *
cfg80211_rtw_add_virtual_intf(
struct wiphy *wiphy,
const char *name,
unsigned char name_assign_type,
enum nl80211_iftype type, struct vif_params *params)
{
int ret = 0;
struct net_device *ndev = NULL;
struct adapter *padapter = wiphy_to_adapter(wiphy);
switch (type) {
case NL80211_IFTYPE_ADHOC:
case NL80211_IFTYPE_AP_VLAN:
case NL80211_IFTYPE_WDS:
case NL80211_IFTYPE_MESH_POINT:
ret = -ENODEV;
break;
case NL80211_IFTYPE_MONITOR:
ret = rtw_cfg80211_add_monitor_if(padapter, (char *)name, &ndev);
break;
case NL80211_IFTYPE_P2P_CLIENT:
case NL80211_IFTYPE_STATION:
ret = -ENODEV;
break;
case NL80211_IFTYPE_P2P_GO:
case NL80211_IFTYPE_AP:
ret = -ENODEV;
break;
default:
ret = -ENODEV;
break;
}
return ndev ? ndev->ieee80211_ptr : ERR_PTR(ret);
}
static int cfg80211_rtw_del_virtual_intf(struct wiphy *wiphy,
struct wireless_dev *wdev
)
{
struct net_device *ndev = wdev_to_ndev(wdev);
int ret = 0;
struct adapter *adapter;
struct rtw_wdev_priv *pwdev_priv;
if (!ndev) {
ret = -EINVAL;
goto exit;
}
adapter = rtw_netdev_priv(ndev);
pwdev_priv = adapter_wdev_data(adapter);
cfg80211_unregister_netdevice(ndev);
if (ndev == pwdev_priv->pmon_ndev) {
pwdev_priv->pmon_ndev = NULL;
pwdev_priv->ifname_mon[0] = '\0';
}
exit:
return ret;
}
static int rtw_add_beacon(struct adapter *adapter, const u8 *head, size_t head_len, const u8 *tail, size_t tail_len)
{
int ret = 0;
u8 *pbuf = NULL;
uint len, wps_ielen = 0;
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
return -EINVAL;
if (head_len < 24)
return -EINVAL;
pbuf = rtw_zmalloc(head_len + tail_len);
if (!pbuf)
return -ENOMEM;
memcpy(pbuf, (void *)head + 24, head_len - 24);/* 24 =beacon header len. */
memcpy(pbuf + head_len - 24, (void *)tail, tail_len);
len = head_len + tail_len - 24;
/* check wps ie if inclued */
rtw_get_wps_ie(pbuf + _FIXED_IE_LENGTH_, len - _FIXED_IE_LENGTH_, NULL, &wps_ielen);
/* pbss_network->ies will not include p2p_ie, wfd ie */
rtw_ies_remove_ie(pbuf, &len, _BEACON_IE_OFFSET_, WLAN_EID_VENDOR_SPECIFIC, P2P_OUI, 4);
rtw_ies_remove_ie(pbuf, &len, _BEACON_IE_OFFSET_, WLAN_EID_VENDOR_SPECIFIC, WFD_OUI, 4);
if (rtw_check_beacon_data(adapter, pbuf, len) == _SUCCESS)
ret = 0;
else
ret = -EINVAL;
kfree(pbuf);
return ret;
}
static int cfg80211_rtw_start_ap(struct wiphy *wiphy, struct net_device *ndev,
struct cfg80211_ap_settings *settings)
{
int ret = 0;
struct adapter *adapter = rtw_netdev_priv(ndev);
ret = rtw_add_beacon(adapter, settings->beacon.head,
settings->beacon.head_len, settings->beacon.tail,
settings->beacon.tail_len);
adapter->mlmeextpriv.mlmext_info.hidden_ssid_mode = settings->hidden_ssid;
if (settings->ssid && settings->ssid_len) {
struct wlan_bssid_ex *pbss_network = &adapter->mlmepriv.cur_network.network;
struct wlan_bssid_ex *pbss_network_ext = &adapter->mlmeextpriv.mlmext_info.network;
memcpy(pbss_network->ssid.ssid, (void *)settings->ssid, settings->ssid_len);
pbss_network->ssid.ssid_length = settings->ssid_len;
memcpy(pbss_network_ext->ssid.ssid, (void *)settings->ssid, settings->ssid_len);
pbss_network_ext->ssid.ssid_length = settings->ssid_len;
}
return ret;
}
static int cfg80211_rtw_change_beacon(struct wiphy *wiphy,
struct net_device *ndev,
struct cfg80211_beacon_data *info)
{
struct adapter *adapter = rtw_netdev_priv(ndev);
return rtw_add_beacon(adapter, info->head, info->head_len, info->tail, info->tail_len);
}
static int cfg80211_rtw_stop_ap(struct wiphy *wiphy, struct net_device *ndev,
unsigned int link_id)
{
return 0;
}
static int cfg80211_rtw_add_station(struct wiphy *wiphy,
struct net_device *ndev,
const u8 *mac,
struct station_parameters *params)
{
return 0;
}
static int cfg80211_rtw_del_station(struct wiphy *wiphy, struct net_device *ndev,
struct station_del_parameters *params)
{
int ret = 0;
struct list_head *phead, *plist, *tmp;
u8 updated = false;
struct sta_info *psta = NULL;
struct adapter *padapter = rtw_netdev_priv(ndev);
struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
struct sta_priv *pstapriv = &padapter->stapriv;
const u8 *mac = params->mac;
if (check_fwstate(pmlmepriv, (_FW_LINKED | WIFI_AP_STATE)) != true)
return -EINVAL;
if (!mac) {
flush_all_cam_entry(padapter); /* clear CAM */
rtw_sta_flush(padapter);
return 0;
}
if (mac[0] == 0xff && mac[1] == 0xff &&
mac[2] == 0xff && mac[3] == 0xff &&
mac[4] == 0xff && mac[5] == 0xff) {
return -EINVAL;
}
spin_lock_bh(&pstapriv->asoc_list_lock);
phead = &pstapriv->asoc_list;
/* check asoc_queue */
list_for_each_safe(plist, tmp, phead) {
psta = list_entry(plist, struct sta_info, asoc_list);
if (!memcmp((u8 *)mac, psta->hwaddr, ETH_ALEN)) {
if (psta->dot8021xalg != 1 || psta->bpairwise_key_installed) {
list_del_init(&psta->asoc_list);
pstapriv->asoc_list_cnt--;
updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
psta = NULL;
break;
}
}
}
spin_unlock_bh(&pstapriv->asoc_list_lock);
associated_clients_update(padapter, updated);
return ret;
}
static int cfg80211_rtw_change_station(struct wiphy *wiphy,
struct net_device *ndev,
const u8 *mac,
struct station_parameters *params)
{
return 0;
}
static struct sta_info *rtw_sta_info_get_by_idx(const int idx, struct sta_priv *pstapriv)
{
struct list_head *phead, *plist;
struct sta_info *psta = NULL;
int i = 0;
phead = &pstapriv->asoc_list;
plist = get_next(phead);
/* check asoc_queue */
while (phead != plist) {
if (idx == i)
psta = container_of(plist, struct sta_info, asoc_list);
plist = get_next(plist);
i++;
}
return psta;
}
static int cfg80211_rtw_dump_station(struct wiphy *wiphy,
struct net_device *ndev,
int idx, u8 *mac,
struct station_info *sinfo)
{
int ret = 0;
struct adapter *padapter = rtw_netdev_priv(ndev);
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
spin_lock_bh(&pstapriv->asoc_list_lock);
psta = rtw_sta_info_get_by_idx(idx, pstapriv);
spin_unlock_bh(&pstapriv->asoc_list_lock);
if (psta == NULL) {
ret = -ENOENT;
goto exit;
}
memcpy(mac, psta->hwaddr, ETH_ALEN);
sinfo->filled = BIT_ULL(NL80211_STA_INFO_SIGNAL);
sinfo->signal = psta->rssi;
exit:
return ret;
}
static int cfg80211_rtw_change_bss(struct wiphy *wiphy,
struct net_device *ndev,
struct bss_parameters *params)
{
return 0;
}
void rtw_cfg80211_rx_action(struct adapter *adapter, u8 *frame, uint frame_len, const char *msg)
{
s32 freq;
int channel;
u8 category, action;
channel = rtw_get_oper_ch(adapter);
rtw_action_frame_parse(frame, frame_len, &category, &action);
freq = rtw_ieee80211_channel_to_frequency(channel, NL80211_BAND_2GHZ);
rtw_cfg80211_rx_mgmt(adapter, freq, 0, frame, frame_len, GFP_ATOMIC);
}
static int _cfg80211_rtw_mgmt_tx(struct adapter *padapter, u8 tx_ch, const u8 *buf, size_t len)
{
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
unsigned char *pframe;
int ret = _FAIL;
bool __maybe_unused ack = true;
struct ieee80211_hdr *pwlanhdr;
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
rtw_set_scan_deny(padapter, 1000);
rtw_scan_abort(padapter);
if (tx_ch != rtw_get_oper_ch(padapter)) {
if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED))
pmlmeext->cur_channel = tx_ch;
set_channel_bwmode(padapter, tx_ch, HAL_PRIME_CHNL_OFFSET_DONT_CARE, CHANNEL_WIDTH_20);
}
/* starting alloc mgmt frame to dump it */
pmgntframe = alloc_mgtxmitframe(pxmitpriv);
if (!pmgntframe) {
/* ret = -ENOMEM; */
ret = _FAIL;
goto exit;
}
/* update attribute */
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(padapter, pattrib);
pattrib->retry_ctrl = false;
memset(pmgntframe->buf_addr, 0, WLANHDR_OFFSET + TXDESC_OFFSET);
pframe = (u8 *)(pmgntframe->buf_addr) + TXDESC_OFFSET;
memcpy(pframe, (void *)buf, len);
pattrib->pktlen = len;
pwlanhdr = (struct ieee80211_hdr *)pframe;
/* update seq number */
pmlmeext->mgnt_seq = GetSequence(pwlanhdr);
pattrib->seqnum = pmlmeext->mgnt_seq;
pmlmeext->mgnt_seq++;
pattrib->last_txcmdsz = pattrib->pktlen;
if (dump_mgntframe_and_wait_ack(padapter, pmgntframe) != _SUCCESS) {
ack = false;
ret = _FAIL;
} else {
msleep(50);
ret = _SUCCESS;
}
exit:
return ret;
}
static int cfg80211_rtw_mgmt_tx(struct wiphy *wiphy, struct wireless_dev *wdev,
struct cfg80211_mgmt_tx_params *params,
u64 *cookie)
{
struct net_device *ndev = wdev_to_ndev(wdev);
struct ieee80211_channel *chan = params->chan;
const u8 *buf = params->buf;
size_t len = params->len;
int ret = 0;
int tx_ret;
u32 dump_limit = RTW_MAX_MGMT_TX_CNT;
u32 dump_cnt = 0;
bool ack = true;
u8 tx_ch = (u8)ieee80211_frequency_to_channel(chan->center_freq);
u8 category, action;
int type = (-1);
struct adapter *padapter;
struct rtw_wdev_priv *pwdev_priv;
if (!ndev) {
ret = -EINVAL;
goto exit;
}
padapter = rtw_netdev_priv(ndev);
pwdev_priv = adapter_wdev_data(padapter);
/* cookie generation */
*cookie = (unsigned long)buf;
/* indicate ack before issue frame to avoid racing with rsp frame */
rtw_cfg80211_mgmt_tx_status(padapter, *cookie, buf, len, ack, GFP_KERNEL);
if (rtw_action_frame_parse(buf, len, &category, &action) == false)
goto exit;
rtw_ps_deny(padapter, PS_DENY_MGNT_TX);
if (rtw_pwr_wakeup(padapter) == _FAIL) {
ret = -EFAULT;
goto cancel_ps_deny;
}
do {
dump_cnt++;
tx_ret = _cfg80211_rtw_mgmt_tx(padapter, tx_ch, buf, len);
} while (dump_cnt < dump_limit && tx_ret != _SUCCESS);
switch (type) {
case P2P_GO_NEGO_CONF:
rtw_clear_scan_deny(padapter);
break;
case P2P_INVIT_RESP:
if (pwdev_priv->invit_info.flags & BIT(0) && pwdev_priv->invit_info.status == 0) {
rtw_set_scan_deny(padapter, 5000);
rtw_pwr_wakeup_ex(padapter, 5000);
rtw_clear_scan_deny(padapter);
}
break;
}
cancel_ps_deny:
rtw_ps_deny_cancel(padapter, PS_DENY_MGNT_TX);
exit:
return ret;
}
static void rtw_cfg80211_init_ht_capab(struct ieee80211_sta_ht_cap *ht_cap, enum nl80211_band band)
{
#define MAX_BIT_RATE_40MHZ_MCS15 300 /* Mbps */
#define MAX_BIT_RATE_40MHZ_MCS7 150 /* Mbps */
ht_cap->ht_supported = true;
ht_cap->cap = IEEE80211_HT_CAP_SUP_WIDTH_20_40 |
IEEE80211_HT_CAP_SGI_40 | IEEE80211_HT_CAP_SGI_20 |
IEEE80211_HT_CAP_DSSSCCK40 | IEEE80211_HT_CAP_MAX_AMSDU;
/*
*Maximum length of AMPDU that the STA can receive.
*Length = 2 ^ (13 + max_ampdu_length_exp) - 1 (octets)
*/
ht_cap->ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
/*Minimum MPDU start spacing , */
ht_cap->ampdu_density = IEEE80211_HT_MPDU_DENSITY_16;
ht_cap->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
/*
*hw->wiphy->bands[NL80211_BAND_2GHZ]
*base on ant_num
*rx_mask: RX mask
*if rx_ant = 1 rx_mask[0]= 0xff;==>MCS0-MCS7
*if rx_ant =2 rx_mask[1]= 0xff;==>MCS8-MCS15
*if rx_ant >=3 rx_mask[2]= 0xff;
*if BW_40 rx_mask[4]= 0x01;
*highest supported RX rate
*/
ht_cap->mcs.rx_mask[0] = 0xFF;
ht_cap->mcs.rx_mask[1] = 0x00;
ht_cap->mcs.rx_mask[4] = 0x01;
ht_cap->mcs.rx_highest = cpu_to_le16(MAX_BIT_RATE_40MHZ_MCS7);
}
void rtw_cfg80211_init_wiphy(struct adapter *padapter)
{
struct ieee80211_supported_band *bands;
struct wireless_dev *pwdev = padapter->rtw_wdev;
struct wiphy *wiphy = pwdev->wiphy;
{
bands = wiphy->bands[NL80211_BAND_2GHZ];
if (bands)
rtw_cfg80211_init_ht_capab(&bands->ht_cap, NL80211_BAND_2GHZ);
}
/* copy mac_addr to wiphy */
memcpy(wiphy->perm_addr, padapter->eeprompriv.mac_addr, ETH_ALEN);
}
static void rtw_cfg80211_preinit_wiphy(struct adapter *padapter, struct wiphy *wiphy)
{
wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
wiphy->max_scan_ssids = RTW_SSID_SCAN_AMOUNT;
wiphy->max_scan_ie_len = RTW_SCAN_IE_LEN_MAX;
wiphy->max_num_pmkids = RTW_MAX_NUM_PMKIDS;
wiphy->max_remain_on_channel_duration = RTW_MAX_REMAIN_ON_CHANNEL_DURATION;
wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION)
| BIT(NL80211_IFTYPE_ADHOC)
| BIT(NL80211_IFTYPE_AP)
| BIT(NL80211_IFTYPE_MONITOR)
;
wiphy->mgmt_stypes = rtw_cfg80211_default_mgmt_stypes;
wiphy->software_iftypes |= BIT(NL80211_IFTYPE_MONITOR);
wiphy->cipher_suites = rtw_cipher_suites;
wiphy->n_cipher_suites = ARRAY_SIZE(rtw_cipher_suites);
/* if (padapter->registrypriv.wireless_mode & WIRELESS_11G) */
wiphy->bands[NL80211_BAND_2GHZ] = rtw_spt_band_alloc(NL80211_BAND_2GHZ);
wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
wiphy->flags |= WIPHY_FLAG_OFFCHAN_TX | WIPHY_FLAG_HAVE_AP_SME;
#if defined(CONFIG_PM)
wiphy->max_sched_scan_reqs = 1;
#endif
#if defined(CONFIG_PM)
wiphy->wowlan = &wowlan_stub;
#endif
if (padapter->registrypriv.power_mgnt != PS_MODE_ACTIVE)
wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
else
wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
}
static struct cfg80211_ops rtw_cfg80211_ops = {
.change_virtual_intf = cfg80211_rtw_change_iface,
.add_key = cfg80211_rtw_add_key,
.get_key = cfg80211_rtw_get_key,
.del_key = cfg80211_rtw_del_key,
.set_default_key = cfg80211_rtw_set_default_key,
.get_station = cfg80211_rtw_get_station,
.scan = cfg80211_rtw_scan,
.set_wiphy_params = cfg80211_rtw_set_wiphy_params,
.connect = cfg80211_rtw_connect,
.disconnect = cfg80211_rtw_disconnect,
.join_ibss = cfg80211_rtw_join_ibss,
.leave_ibss = cfg80211_rtw_leave_ibss,
.set_tx_power = cfg80211_rtw_set_txpower,
.get_tx_power = cfg80211_rtw_get_txpower,
.set_power_mgmt = cfg80211_rtw_set_power_mgmt,
.set_pmksa = cfg80211_rtw_set_pmksa,
.del_pmksa = cfg80211_rtw_del_pmksa,
.flush_pmksa = cfg80211_rtw_flush_pmksa,
.get_channel = cfg80211_rtw_get_channel,
.add_virtual_intf = cfg80211_rtw_add_virtual_intf,
.del_virtual_intf = cfg80211_rtw_del_virtual_intf,
.start_ap = cfg80211_rtw_start_ap,
.change_beacon = cfg80211_rtw_change_beacon,
.stop_ap = cfg80211_rtw_stop_ap,
.add_station = cfg80211_rtw_add_station,
.del_station = cfg80211_rtw_del_station,
.change_station = cfg80211_rtw_change_station,
.dump_station = cfg80211_rtw_dump_station,
.change_bss = cfg80211_rtw_change_bss,
.mgmt_tx = cfg80211_rtw_mgmt_tx,
};
int rtw_wdev_alloc(struct adapter *padapter, struct device *dev)
{
int ret = 0;
struct wiphy *wiphy;
struct wireless_dev *wdev;
struct rtw_wdev_priv *pwdev_priv;
struct net_device *pnetdev = padapter->pnetdev;
/* wiphy */
wiphy = wiphy_new(&rtw_cfg80211_ops, sizeof(struct adapter *));
if (!wiphy) {
ret = -ENOMEM;
goto exit;
}
set_wiphy_dev(wiphy, dev);
*((struct adapter **)wiphy_priv(wiphy)) = padapter;
rtw_cfg80211_preinit_wiphy(padapter, wiphy);
/* init regulary domain */
rtw_regd_init(wiphy, rtw_reg_notifier);
ret = wiphy_register(wiphy);
if (ret < 0)
goto free_wiphy;
/* wdev */
wdev = rtw_zmalloc(sizeof(struct wireless_dev));
if (!wdev) {
ret = -ENOMEM;
goto unregister_wiphy;
}
wdev->wiphy = wiphy;
wdev->netdev = pnetdev;
wdev->iftype = NL80211_IFTYPE_STATION; /* will be init in rtw_hal_init() */
/* Must sync with _rtw_init_mlme_priv() */
/* pmlmepriv->fw_state = WIFI_STATION_STATE */
padapter->rtw_wdev = wdev;
pnetdev->ieee80211_ptr = wdev;
/* init pwdev_priv */
pwdev_priv = adapter_wdev_data(padapter);
pwdev_priv->rtw_wdev = wdev;
pwdev_priv->pmon_ndev = NULL;
pwdev_priv->ifname_mon[0] = '\0';
pwdev_priv->padapter = padapter;
pwdev_priv->scan_request = NULL;
spin_lock_init(&pwdev_priv->scan_req_lock);
pwdev_priv->p2p_enabled = false;
pwdev_priv->provdisc_req_issued = false;
rtw_wdev_invit_info_init(&pwdev_priv->invit_info);
rtw_wdev_nego_info_init(&pwdev_priv->nego_info);
pwdev_priv->bandroid_scan = false;
if (padapter->registrypriv.power_mgnt != PS_MODE_ACTIVE)
pwdev_priv->power_mgmt = true;
else
pwdev_priv->power_mgmt = false;
return ret;
unregister_wiphy:
wiphy_unregister(wiphy);
free_wiphy:
wiphy_free(wiphy);
exit:
return ret;
}
void rtw_wdev_free(struct wireless_dev *wdev)
{
if (!wdev)
return;
kfree(wdev->wiphy->bands[NL80211_BAND_2GHZ]);
wiphy_free(wdev->wiphy);
kfree(wdev);
}
void rtw_wdev_unregister(struct wireless_dev *wdev)
{
struct net_device *ndev;
struct adapter *adapter;
struct rtw_wdev_priv *pwdev_priv;
if (!wdev)
return;
ndev = wdev_to_ndev(wdev);
if (!ndev)
return;
adapter = rtw_netdev_priv(ndev);
pwdev_priv = adapter_wdev_data(adapter);
rtw_cfg80211_indicate_scan_done(adapter, true);
if (pwdev_priv->pmon_ndev)
unregister_netdev(pwdev_priv->pmon_ndev);
wiphy_unregister(wdev->wiphy);
}
| linux-master | drivers/staging/rtl8723bs/os_dep/ioctl_cfg80211.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
uint rtw_remainder_len(struct pkt_file *pfile)
{
return (pfile->buf_len - ((SIZE_PTR)(pfile->cur_addr) - (SIZE_PTR)(pfile->buf_start)));
}
void _rtw_open_pktfile(struct sk_buff *pktptr, struct pkt_file *pfile)
{
pfile->pkt = pktptr;
pfile->cur_addr = pfile->buf_start = pktptr->data;
pfile->pkt_len = pfile->buf_len = pktptr->len;
pfile->cur_buffer = pfile->buf_start;
}
uint _rtw_pktfile_read(struct pkt_file *pfile, u8 *rmem, uint rlen)
{
uint len = 0;
len = rtw_remainder_len(pfile);
len = (rlen > len) ? len : rlen;
if (rmem)
skb_copy_bits(pfile->pkt, pfile->buf_len - pfile->pkt_len, rmem, len);
pfile->cur_addr += len;
pfile->pkt_len -= len;
return len;
}
signed int rtw_endofpktfile(struct pkt_file *pfile)
{
if (pfile->pkt_len == 0)
return true;
return false;
}
int rtw_os_xmit_resource_alloc(struct adapter *padapter, struct xmit_buf *pxmitbuf, u32 alloc_sz, u8 flag)
{
if (alloc_sz > 0) {
pxmitbuf->pallocated_buf = rtw_zmalloc(alloc_sz);
if (!pxmitbuf->pallocated_buf)
return _FAIL;
pxmitbuf->pbuf = (u8 *)N_BYTE_ALIGMENT((SIZE_PTR)(pxmitbuf->pallocated_buf), XMITBUF_ALIGN_SZ);
}
return _SUCCESS;
}
void rtw_os_xmit_resource_free(struct adapter *padapter, struct xmit_buf *pxmitbuf, u32 free_sz, u8 flag)
{
if (free_sz > 0)
kfree(pxmitbuf->pallocated_buf);
}
#define WMM_XMIT_THRESHOLD (NR_XMITFRAME * 2 / 5)
void rtw_os_pkt_complete(struct adapter *padapter, struct sk_buff *pkt)
{
u16 queue;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
queue = skb_get_queue_mapping(pkt);
if (padapter->registrypriv.wifi_spec) {
if (__netif_subqueue_stopped(padapter->pnetdev, queue) &&
(pxmitpriv->hwxmits[queue].accnt < WMM_XMIT_THRESHOLD))
netif_wake_subqueue(padapter->pnetdev, queue);
} else {
if (__netif_subqueue_stopped(padapter->pnetdev, queue))
netif_wake_subqueue(padapter->pnetdev, queue);
}
dev_kfree_skb_any(pkt);
}
void rtw_os_xmit_complete(struct adapter *padapter, struct xmit_frame *pxframe)
{
if (pxframe->pkt)
rtw_os_pkt_complete(padapter, pxframe->pkt);
pxframe->pkt = NULL;
}
void rtw_os_xmit_schedule(struct adapter *padapter)
{
struct adapter *pri_adapter = padapter;
if (!padapter)
return;
if (!list_empty(&padapter->xmitpriv.pending_xmitbuf_queue.queue))
complete(&pri_adapter->xmitpriv.xmit_comp);
}
static void rtw_check_xmit_resource(struct adapter *padapter, struct sk_buff *pkt)
{
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
u16 queue;
queue = skb_get_queue_mapping(pkt);
if (padapter->registrypriv.wifi_spec) {
/* No free space for Tx, tx_worker is too slow */
if (pxmitpriv->hwxmits[queue].accnt > WMM_XMIT_THRESHOLD)
netif_stop_subqueue(padapter->pnetdev, queue);
} else {
if (pxmitpriv->free_xmitframe_cnt <= 4) {
if (!netif_tx_queue_stopped(netdev_get_tx_queue(padapter->pnetdev, queue)))
netif_stop_subqueue(padapter->pnetdev, queue);
}
}
}
static int rtw_mlcst2unicst(struct adapter *padapter, struct sk_buff *skb)
{
struct sta_priv *pstapriv = &padapter->stapriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct list_head *phead, *plist;
struct sk_buff *newskb;
struct sta_info *psta = NULL;
u8 chk_alive_num = 0;
char chk_alive_list[NUM_STA];
u8 bc_addr[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u8 null_addr[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
int i;
s32 res;
spin_lock_bh(&pstapriv->asoc_list_lock);
phead = &pstapriv->asoc_list;
/* free sta asoc_queue */
list_for_each(plist, phead) {
int stainfo_offset;
psta = list_entry(plist, struct sta_info, asoc_list);
stainfo_offset = rtw_stainfo_offset(pstapriv, psta);
if (stainfo_offset_valid(stainfo_offset)) {
chk_alive_list[chk_alive_num++] = stainfo_offset;
}
}
spin_unlock_bh(&pstapriv->asoc_list_lock);
for (i = 0; i < chk_alive_num; i++) {
psta = rtw_get_stainfo_by_offset(pstapriv, chk_alive_list[i]);
if (!(psta->state & _FW_LINKED))
continue;
/* avoid come from STA1 and send back STA1 */
if (!memcmp(psta->hwaddr, &skb->data[6], 6) ||
!memcmp(psta->hwaddr, null_addr, 6) ||
!memcmp(psta->hwaddr, bc_addr, 6))
continue;
newskb = rtw_skb_copy(skb);
if (newskb) {
memcpy(newskb->data, psta->hwaddr, 6);
res = rtw_xmit(padapter, &newskb);
if (res < 0) {
pxmitpriv->tx_drop++;
dev_kfree_skb_any(newskb);
}
} else {
pxmitpriv->tx_drop++;
/* dev_kfree_skb_any(skb); */
return false; /* Caller shall tx this multicast frame via normal way. */
}
}
dev_kfree_skb_any(skb);
return true;
}
void _rtw_xmit_entry(struct sk_buff *pkt, struct net_device *pnetdev)
{
struct adapter *padapter = rtw_netdev_priv(pnetdev);
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
s32 res = 0;
if (rtw_if_up(padapter) == false)
goto drop_packet;
rtw_check_xmit_resource(padapter, pkt);
if (!rtw_mc2u_disable
&& check_fwstate(pmlmepriv, WIFI_AP_STATE) == true
&& (IP_MCAST_MAC(pkt->data)
|| ICMPV6_MCAST_MAC(pkt->data)
)
&& padapter->registrypriv.wifi_spec == 0) {
if (pxmitpriv->free_xmitframe_cnt > (NR_XMITFRAME / 4)) {
res = rtw_mlcst2unicst(padapter, pkt);
if (res)
return;
}
}
res = rtw_xmit(padapter, &pkt);
if (res < 0)
goto drop_packet;
return;
drop_packet:
pxmitpriv->tx_drop++;
dev_kfree_skb_any(pkt);
}
netdev_tx_t rtw_xmit_entry(struct sk_buff *pkt, struct net_device *pnetdev)
{
if (pkt)
_rtw_xmit_entry(pkt, pnetdev);
return NETDEV_TX_OK;
}
| linux-master | drivers/staging/rtl8723bs/os_dep/xmit_linux.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <hal_data.h>
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Realtek Wireless Lan Driver");
MODULE_AUTHOR("Realtek Semiconductor Corp.");
MODULE_VERSION(DRIVERVERSION);
/* module param defaults */
static int rtw_chip_version;
static int rtw_rfintfs = HWPI;
static int rtw_lbkmode;/* RTL8712_AIR_TRX; */
static int rtw_network_mode = Ndis802_11IBSS;/* Ndis802_11Infrastructure;infra, ad-hoc, auto */
/* struct ndis_802_11_ssid ssid; */
static int rtw_channel = 1;/* ad-hoc support requirement */
static int rtw_wireless_mode = WIRELESS_11BG_24N;
static int rtw_vrtl_carrier_sense = AUTO_VCS;
static int rtw_vcs_type = RTS_CTS;/* */
static int rtw_rts_thresh = 2347;/* */
static int rtw_frag_thresh = 2346;/* */
static int rtw_preamble = PREAMBLE_LONG;/* long, short, auto */
static int rtw_scan_mode = 1;/* active, passive */
static int rtw_adhoc_tx_pwr = 1;
static int rtw_soft_ap;
/* int smart_ps = 1; */
static int rtw_power_mgnt = 1;
static int rtw_ips_mode = IPS_NORMAL;
module_param(rtw_ips_mode, int, 0644);
MODULE_PARM_DESC(rtw_ips_mode, "The default IPS mode");
static int rtw_smart_ps = 2;
static int rtw_check_fw_ps = 1;
static int rtw_usb_rxagg_mode = 2;/* USB_RX_AGG_DMA = 1, USB_RX_AGG_USB =2 */
module_param(rtw_usb_rxagg_mode, int, 0644);
static int rtw_radio_enable = 1;
static int rtw_long_retry_lmt = 7;
static int rtw_short_retry_lmt = 7;
static int rtw_busy_thresh = 40;
/* int qos_enable = 0; */
static int rtw_ack_policy = NORMAL_ACK;
static int rtw_software_encrypt;
static int rtw_software_decrypt;
static int rtw_acm_method;/* 0:By SW 1:By HW. */
static int rtw_wmm_enable = 1;/* default is set to enable the wmm. */
static int rtw_uapsd_enable;
static int rtw_uapsd_max_sp = NO_LIMIT;
static int rtw_uapsd_acbk_en;
static int rtw_uapsd_acbe_en;
static int rtw_uapsd_acvi_en;
static int rtw_uapsd_acvo_en;
int rtw_ht_enable = 1;
/*
* 0: 20 MHz, 1: 40 MHz
* 2.4G use bit 0 ~ 3
* 0x01 means enable 2.4G 40MHz
*/
static int rtw_bw_mode = 0x01;
static int rtw_ampdu_enable = 1;/* for enable tx_ampdu ,0: disable, 0x1:enable (but wifi_spec should be 0), 0x2: force enable (don't care wifi_spec) */
static int rtw_rx_stbc = 1;/* 0: disable, 1:enable 2.4g */
static int rtw_ampdu_amsdu;/* 0: disabled, 1:enabled, 2:auto . There is an IOT issu with DLINK DIR-629 when the flag turn on */
/* Short GI support Bit Map */
/* BIT0 - 20MHz, 0: non-support, 1: support */
/* BIT1 - 40MHz, 0: non-support, 1: support */
/* BIT2 - 80MHz, 0: non-support, 1: support */
/* BIT3 - 160MHz, 0: non-support, 1: support */
static int rtw_short_gi = 0xf;
/* BIT0: Enable VHT LDPC Rx, BIT1: Enable VHT LDPC Tx, BIT4: Enable HT LDPC Rx, BIT5: Enable HT LDPC Tx */
static int rtw_ldpc_cap = 0x33;
/* BIT0: Enable VHT STBC Rx, BIT1: Enable VHT STBC Tx, BIT4: Enable HT STBC Rx, BIT5: Enable HT STBC Tx */
static int rtw_stbc_cap = 0x13;
/* BIT0: Enable VHT Beamformer, BIT1: Enable VHT Beamformee, BIT4: Enable HT Beamformer, BIT5: Enable HT Beamformee */
static int rtw_beamform_cap = 0x2;
static int rtw_lowrate_two_xmit = 1;/* Use 2 path Tx to transmit MCS0~7 and legacy mode */
static int rtw_low_power;
static int rtw_wifi_spec;
static int rtw_channel_plan = RT_CHANNEL_DOMAIN_MAX;
static int rtw_ant_num = -1; /* <0: undefined, >0: Antenna number */
module_param(rtw_ant_num, int, 0644);
MODULE_PARM_DESC(rtw_ant_num, "Antenna number setting");
static int rtw_antdiv_cfg = 1; /* 0:OFF , 1:ON, 2:decide by Efuse config */
static int rtw_antdiv_type; /* 0:decide by efuse 1: for 88EE, 1Tx and 1RxCG are diversity.(2 Ant with SPDT), 2: for 88EE, 1Tx and 2Rx are diversity.(2 Ant, Tx and RxCG are both on aux port, RxCS is on main port), 3: for 88EE, 1Tx and 1RxCG are fixed.(1Ant, Tx and RxCG are both on aux port) */
static int rtw_hw_wps_pbc;
int rtw_mc2u_disable;
static int rtw_80211d;
static int rtw_qos_opt_enable;/* 0: disable, 1:enable */
module_param(rtw_qos_opt_enable, int, 0644);
static char *ifname = "wlan%d";
module_param(ifname, charp, 0644);
MODULE_PARM_DESC(ifname, "The default name to allocate for first interface");
char *rtw_initmac; /* temp mac address if users want to use instead of the mac address in Efuse */
module_param(rtw_initmac, charp, 0644);
module_param(rtw_channel_plan, int, 0644);
module_param(rtw_chip_version, int, 0644);
module_param(rtw_rfintfs, int, 0644);
module_param(rtw_lbkmode, int, 0644);
module_param(rtw_network_mode, int, 0644);
module_param(rtw_channel, int, 0644);
module_param(rtw_wmm_enable, int, 0644);
module_param(rtw_vrtl_carrier_sense, int, 0644);
module_param(rtw_vcs_type, int, 0644);
module_param(rtw_busy_thresh, int, 0644);
module_param(rtw_ht_enable, int, 0644);
module_param(rtw_bw_mode, int, 0644);
module_param(rtw_ampdu_enable, int, 0644);
module_param(rtw_rx_stbc, int, 0644);
module_param(rtw_ampdu_amsdu, int, 0644);
module_param(rtw_lowrate_two_xmit, int, 0644);
module_param(rtw_power_mgnt, int, 0644);
module_param(rtw_smart_ps, int, 0644);
module_param(rtw_low_power, int, 0644);
module_param(rtw_wifi_spec, int, 0644);
module_param(rtw_antdiv_cfg, int, 0644);
module_param(rtw_antdiv_type, int, 0644);
module_param(rtw_hw_wps_pbc, int, 0644);
static uint rtw_max_roaming_times = 2;
module_param(rtw_max_roaming_times, uint, 0644);
MODULE_PARM_DESC(rtw_max_roaming_times, "The max roaming times to try");
module_param(rtw_mc2u_disable, int, 0644);
module_param(rtw_80211d, int, 0644);
MODULE_PARM_DESC(rtw_80211d, "Enable 802.11d mechanism");
static uint rtw_notch_filter;
module_param(rtw_notch_filter, uint, 0644);
MODULE_PARM_DESC(rtw_notch_filter, "0:Disable, 1:Enable, 2:Enable only for P2P");
#define CONFIG_RTW_HIQ_FILTER 1
static uint rtw_hiq_filter = CONFIG_RTW_HIQ_FILTER;
module_param(rtw_hiq_filter, uint, 0644);
MODULE_PARM_DESC(rtw_hiq_filter, "0:allow all, 1:allow special, 2:deny all");
static int rtw_tx_pwr_lmt_enable;
static int rtw_tx_pwr_by_rate;
module_param(rtw_tx_pwr_lmt_enable, int, 0644);
MODULE_PARM_DESC(rtw_tx_pwr_lmt_enable, "0:Disable, 1:Enable, 2: Depend on efuse");
module_param(rtw_tx_pwr_by_rate, int, 0644);
MODULE_PARM_DESC(rtw_tx_pwr_by_rate, "0:Disable, 1:Enable, 2: Depend on efuse");
static int netdev_close(struct net_device *pnetdev);
static void loadparam(struct adapter *padapter, struct net_device *pnetdev)
{
struct registry_priv *registry_par = &padapter->registrypriv;
registry_par->chip_version = (u8)rtw_chip_version;
registry_par->rfintfs = (u8)rtw_rfintfs;
registry_par->lbkmode = (u8)rtw_lbkmode;
/* registry_par->hci = (u8)hci; */
registry_par->network_mode = (u8)rtw_network_mode;
memcpy(registry_par->ssid.ssid, "ANY", 3);
registry_par->ssid.ssid_length = 3;
registry_par->channel = (u8)rtw_channel;
registry_par->wireless_mode = (u8)rtw_wireless_mode;
registry_par->vrtl_carrier_sense = (u8)rtw_vrtl_carrier_sense;
registry_par->vcs_type = (u8)rtw_vcs_type;
registry_par->rts_thresh = (u16)rtw_rts_thresh;
registry_par->frag_thresh = (u16)rtw_frag_thresh;
registry_par->preamble = (u8)rtw_preamble;
registry_par->scan_mode = (u8)rtw_scan_mode;
registry_par->adhoc_tx_pwr = (u8)rtw_adhoc_tx_pwr;
registry_par->soft_ap = (u8)rtw_soft_ap;
registry_par->smart_ps = (u8)rtw_smart_ps;
registry_par->check_fw_ps = (u8)rtw_check_fw_ps;
registry_par->power_mgnt = (u8)rtw_power_mgnt;
registry_par->ips_mode = (u8)rtw_ips_mode;
registry_par->radio_enable = (u8)rtw_radio_enable;
registry_par->long_retry_lmt = (u8)rtw_long_retry_lmt;
registry_par->short_retry_lmt = (u8)rtw_short_retry_lmt;
registry_par->busy_thresh = (u16)rtw_busy_thresh;
/* registry_par->qos_enable = (u8)rtw_qos_enable; */
registry_par->ack_policy = (u8)rtw_ack_policy;
registry_par->software_encrypt = (u8)rtw_software_encrypt;
registry_par->software_decrypt = (u8)rtw_software_decrypt;
registry_par->acm_method = (u8)rtw_acm_method;
registry_par->usb_rxagg_mode = (u8)rtw_usb_rxagg_mode;
/* UAPSD */
registry_par->wmm_enable = (u8)rtw_wmm_enable;
registry_par->uapsd_enable = (u8)rtw_uapsd_enable;
registry_par->uapsd_max_sp = (u8)rtw_uapsd_max_sp;
registry_par->uapsd_acbk_en = (u8)rtw_uapsd_acbk_en;
registry_par->uapsd_acbe_en = (u8)rtw_uapsd_acbe_en;
registry_par->uapsd_acvi_en = (u8)rtw_uapsd_acvi_en;
registry_par->uapsd_acvo_en = (u8)rtw_uapsd_acvo_en;
registry_par->ht_enable = (u8)rtw_ht_enable;
registry_par->bw_mode = (u8)rtw_bw_mode;
registry_par->ampdu_enable = (u8)rtw_ampdu_enable;
registry_par->rx_stbc = (u8)rtw_rx_stbc;
registry_par->ampdu_amsdu = (u8)rtw_ampdu_amsdu;
registry_par->short_gi = (u8)rtw_short_gi;
registry_par->ldpc_cap = (u8)rtw_ldpc_cap;
registry_par->stbc_cap = (u8)rtw_stbc_cap;
registry_par->beamform_cap = (u8)rtw_beamform_cap;
registry_par->lowrate_two_xmit = (u8)rtw_lowrate_two_xmit;
registry_par->low_power = (u8)rtw_low_power;
registry_par->wifi_spec = (u8)rtw_wifi_spec;
registry_par->channel_plan = (u8)rtw_channel_plan;
registry_par->ant_num = (s8)rtw_ant_num;
registry_par->accept_addba_req = true;
registry_par->antdiv_cfg = (u8)rtw_antdiv_cfg;
registry_par->antdiv_type = (u8)rtw_antdiv_type;
registry_par->hw_wps_pbc = (u8)rtw_hw_wps_pbc;
registry_par->max_roaming_times = (u8)rtw_max_roaming_times;
registry_par->enable80211d = (u8)rtw_80211d;
snprintf(registry_par->ifname, 16, "%s", ifname);
registry_par->notch_filter = (u8)rtw_notch_filter;
registry_par->RegEnableTxPowerLimit = (u8)rtw_tx_pwr_lmt_enable;
registry_par->RegEnableTxPowerByRate = (u8)rtw_tx_pwr_by_rate;
registry_par->RegPowerBase = 14;
registry_par->TxBBSwing_2G = 0xFF;
registry_par->bEn_RFE = 1;
registry_par->RFE_Type = 64;
registry_par->qos_opt_enable = (u8)rtw_qos_opt_enable;
registry_par->hiq_filter = (u8)rtw_hiq_filter;
}
static int rtw_net_set_mac_address(struct net_device *pnetdev, void *p)
{
struct adapter *padapter = rtw_netdev_priv(pnetdev);
struct sockaddr *addr = p;
if (!padapter->bup) {
/* addr->sa_data[4], addr->sa_data[5]); */
memcpy(padapter->eeprompriv.mac_addr, addr->sa_data, ETH_ALEN);
/* eth_hw_addr_set(pnetdev, addr->sa_data); */
/* padapter->bset_hwaddr = true; */
}
return 0;
}
static struct net_device_stats *rtw_net_get_stats(struct net_device *pnetdev)
{
struct adapter *padapter = rtw_netdev_priv(pnetdev);
struct xmit_priv *pxmitpriv = &(padapter->xmitpriv);
struct recv_priv *precvpriv = &(padapter->recvpriv);
padapter->stats.tx_packets = pxmitpriv->tx_pkts;/* pxmitpriv->tx_pkts++; */
padapter->stats.rx_packets = precvpriv->rx_pkts;/* precvpriv->rx_pkts++; */
padapter->stats.tx_dropped = pxmitpriv->tx_drop;
padapter->stats.rx_dropped = precvpriv->rx_drop;
padapter->stats.tx_bytes = pxmitpriv->tx_bytes;
padapter->stats.rx_bytes = precvpriv->rx_bytes;
return &padapter->stats;
}
/*
* AC to queue mapping
*
* AC_VO -> queue 0
* AC_VI -> queue 1
* AC_BE -> queue 2
* AC_BK -> queue 3
*/
static const u16 rtw_1d_to_queue[8] = { 2, 3, 3, 2, 1, 1, 0, 0 };
/* Given a data frame determine the 802.1p/1d tag to use. */
static unsigned int rtw_classify8021d(struct sk_buff *skb)
{
unsigned int dscp;
/* skb->priority values from 256->263 are magic values to
* directly indicate a specific 802.1d priority. This is used
* to allow 802.1d priority to be passed directly in from VLAN
* tags, etc.
*/
if (skb->priority >= 256 && skb->priority <= 263)
return skb->priority - 256;
switch (skb->protocol) {
case htons(ETH_P_IP):
dscp = ip_hdr(skb)->tos & 0xfc;
break;
default:
return 0;
}
return dscp >> 5;
}
static u16 rtw_select_queue(struct net_device *dev, struct sk_buff *skb,
struct net_device *sb_dev)
{
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
skb->priority = rtw_classify8021d(skb);
if (pmlmepriv->acm_mask != 0)
skb->priority = qos_acm(pmlmepriv->acm_mask, skb->priority);
return rtw_1d_to_queue[skb->priority];
}
u16 rtw_recv_select_queue(struct sk_buff *skb)
{
struct iphdr *piphdr;
unsigned int dscp;
__be16 eth_type;
u32 priority;
u8 *pdata = skb->data;
memcpy(ð_type, pdata + (ETH_ALEN << 1), 2);
switch (be16_to_cpu(eth_type)) {
case ETH_P_IP:
piphdr = (struct iphdr *)(pdata + ETH_HLEN);
dscp = piphdr->tos & 0xfc;
priority = dscp >> 5;
break;
default:
priority = 0;
}
return rtw_1d_to_queue[priority];
}
static int rtw_ndev_notifier_call(struct notifier_block *nb, unsigned long state, void *ptr)
{
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
if (dev->netdev_ops->ndo_do_ioctl != rtw_ioctl)
return NOTIFY_DONE;
netdev_dbg(dev, FUNC_NDEV_FMT " state:%lu\n", FUNC_NDEV_ARG(dev),
state);
return NOTIFY_DONE;
}
static struct notifier_block rtw_ndev_notifier = {
.notifier_call = rtw_ndev_notifier_call,
};
int rtw_ndev_notifier_register(void)
{
return register_netdevice_notifier(&rtw_ndev_notifier);
}
void rtw_ndev_notifier_unregister(void)
{
unregister_netdevice_notifier(&rtw_ndev_notifier);
}
static int rtw_ndev_init(struct net_device *dev)
{
struct adapter *adapter = rtw_netdev_priv(dev);
netdev_dbg(dev, FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(adapter));
strncpy(adapter->old_ifname, dev->name, IFNAMSIZ);
return 0;
}
static void rtw_ndev_uninit(struct net_device *dev)
{
struct adapter *adapter = rtw_netdev_priv(dev);
netdev_dbg(dev, FUNC_ADPT_FMT "\n", FUNC_ADPT_ARG(adapter));
}
static const struct net_device_ops rtw_netdev_ops = {
.ndo_init = rtw_ndev_init,
.ndo_uninit = rtw_ndev_uninit,
.ndo_open = netdev_open,
.ndo_stop = netdev_close,
.ndo_start_xmit = rtw_xmit_entry,
.ndo_select_queue = rtw_select_queue,
.ndo_set_mac_address = rtw_net_set_mac_address,
.ndo_get_stats = rtw_net_get_stats,
.ndo_do_ioctl = rtw_ioctl,
};
int rtw_init_netdev_name(struct net_device *pnetdev, const char *ifname)
{
if (dev_alloc_name(pnetdev, ifname) < 0) {
pr_err("dev_alloc_name, fail for %s\n", ifname);
return 1;
}
netif_carrier_off(pnetdev);
/* rtw_netif_stop_queue(pnetdev); */
return 0;
}
struct net_device *rtw_init_netdev(struct adapter *old_padapter)
{
struct adapter *padapter;
struct net_device *pnetdev;
if (old_padapter)
pnetdev = rtw_alloc_etherdev_with_old_priv(sizeof(struct adapter), (void *)old_padapter);
else
pnetdev = rtw_alloc_etherdev(sizeof(struct adapter));
pr_info("pnetdev = %p\n", pnetdev);
if (!pnetdev)
return NULL;
padapter = rtw_netdev_priv(pnetdev);
padapter->pnetdev = pnetdev;
/* pnetdev->init = NULL; */
pnetdev->netdev_ops = &rtw_netdev_ops;
/* pnetdev->tx_timeout = NULL; */
pnetdev->watchdog_timeo = HZ * 3; /* 3 second timeout */
/* step 2. */
loadparam(padapter, pnetdev);
return pnetdev;
}
void rtw_unregister_netdevs(struct dvobj_priv *dvobj)
{
struct adapter *padapter = NULL;
struct net_device *pnetdev = NULL;
padapter = dvobj->padapters;
if (!padapter)
return;
pnetdev = padapter->pnetdev;
if ((padapter->DriverState != DRIVER_DISAPPEAR) && pnetdev)
unregister_netdev(pnetdev); /* will call netdev_close() */
rtw_wdev_unregister(padapter->rtw_wdev);
}
u32 rtw_start_drv_threads(struct adapter *padapter)
{
u32 _status = _SUCCESS;
padapter->xmitThread = kthread_run(rtw_xmit_thread, padapter, "RTW_XMIT_THREAD");
if (IS_ERR(padapter->xmitThread))
_status = _FAIL;
padapter->cmdThread = kthread_run(rtw_cmd_thread, padapter, "RTW_CMD_THREAD");
if (IS_ERR(padapter->cmdThread))
_status = _FAIL;
else
wait_for_completion(&padapter->cmdpriv.terminate_cmdthread_comp); /* wait for cmd_thread to run */
rtw_hal_start_thread(padapter);
return _status;
}
void rtw_stop_drv_threads(struct adapter *padapter)
{
rtw_stop_cmd_thread(padapter);
/* Below is to termindate tx_thread... */
complete(&padapter->xmitpriv.xmit_comp);
wait_for_completion(&padapter->xmitpriv.terminate_xmitthread_comp);
rtw_hal_stop_thread(padapter);
}
static void rtw_init_default_value(struct adapter *padapter)
{
struct registry_priv *pregistrypriv = &padapter->registrypriv;
struct xmit_priv *pxmitpriv = &padapter->xmitpriv;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
/* xmit_priv */
pxmitpriv->vcs_setting = pregistrypriv->vrtl_carrier_sense;
pxmitpriv->vcs = pregistrypriv->vcs_type;
pxmitpriv->vcs_type = pregistrypriv->vcs_type;
/* pxmitpriv->rts_thresh = pregistrypriv->rts_thresh; */
pxmitpriv->frag_len = pregistrypriv->frag_thresh;
/* recv_priv */
/* mlme_priv */
pmlmepriv->scan_mode = SCAN_ACTIVE;
/* qos_priv */
/* pmlmepriv->qospriv.qos_option = pregistrypriv->wmm_enable; */
/* ht_priv */
pmlmepriv->htpriv.ampdu_enable = false;/* set to disabled */
/* security_priv */
/* rtw_get_encrypt_decrypt_from_registrypriv(padapter); */
psecuritypriv->binstallGrpkey = _FAIL;
psecuritypriv->sw_encrypt = pregistrypriv->software_encrypt;
psecuritypriv->sw_decrypt = pregistrypriv->software_decrypt;
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
psecuritypriv->dot11PrivacyKeyIndex = 0;
psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
psecuritypriv->dot118021XGrpKeyid = 1;
psecuritypriv->ndisauthtype = Ndis802_11AuthModeOpen;
psecuritypriv->ndisencryptstatus = Ndis802_11WEPDisabled;
/* registry_priv */
rtw_init_registrypriv_dev_network(padapter);
rtw_update_registrypriv_dev_network(padapter);
/* hal_priv */
rtw_hal_def_value_init(padapter);
/* misc. */
RTW_ENABLE_FUNC(padapter, DF_RX_BIT);
RTW_ENABLE_FUNC(padapter, DF_TX_BIT);
padapter->bLinkInfoDump = 0;
padapter->bNotifyChannelChange = 0;
/* for debug purpose */
padapter->fix_rate = 0xFF;
padapter->driver_ampdu_spacing = 0xFF;
padapter->driver_rx_ampdu_factor = 0xFF;
}
struct dvobj_priv *devobj_init(void)
{
struct dvobj_priv *pdvobj = NULL;
pdvobj = rtw_zmalloc(sizeof(*pdvobj));
if (!pdvobj)
return NULL;
mutex_init(&pdvobj->hw_init_mutex);
mutex_init(&pdvobj->h2c_fwcmd_mutex);
mutex_init(&pdvobj->setch_mutex);
mutex_init(&pdvobj->setbw_mutex);
spin_lock_init(&pdvobj->lock);
pdvobj->macid[1] = true; /* macid = 1 for bc/mc stainfo */
pdvobj->processing_dev_remove = false;
atomic_set(&pdvobj->disable_func, 0);
spin_lock_init(&pdvobj->cam_ctl.lock);
return pdvobj;
}
void devobj_deinit(struct dvobj_priv *pdvobj)
{
if (!pdvobj)
return;
mutex_destroy(&pdvobj->hw_init_mutex);
mutex_destroy(&pdvobj->h2c_fwcmd_mutex);
mutex_destroy(&pdvobj->setch_mutex);
mutex_destroy(&pdvobj->setbw_mutex);
kfree(pdvobj);
}
void rtw_reset_drv_sw(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
/* hal_priv */
if (is_primary_adapter(padapter))
rtw_hal_def_value_init(padapter);
RTW_ENABLE_FUNC(padapter, DF_RX_BIT);
RTW_ENABLE_FUNC(padapter, DF_TX_BIT);
padapter->bLinkInfoDump = 0;
padapter->xmitpriv.tx_pkts = 0;
padapter->recvpriv.rx_pkts = 0;
pmlmepriv->LinkDetectInfo.bBusyTraffic = false;
/* pmlmepriv->LinkDetectInfo.TrafficBusyState = false; */
pmlmepriv->LinkDetectInfo.TrafficTransitionCount = 0;
pmlmepriv->LinkDetectInfo.LowPowerTransitionCount = 0;
_clr_fwstate_(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING);
pwrctrlpriv->pwr_state_check_cnts = 0;
/* mlmeextpriv */
padapter->mlmeextpriv.sitesurvey_res.state = SCAN_DISABLE;
rtw_set_signal_stat_timer(&padapter->recvpriv);
}
u8 rtw_init_drv_sw(struct adapter *padapter)
{
rtw_init_default_value(padapter);
rtw_init_hal_com_default_value(padapter);
if (rtw_init_cmd_priv(&padapter->cmdpriv))
return _FAIL;
padapter->cmdpriv.padapter = padapter;
if (rtw_init_evt_priv(&padapter->evtpriv))
goto free_cmd_priv;
if (rtw_init_mlme_priv(padapter) == _FAIL)
goto free_evt_priv;
init_mlme_ext_priv(padapter);
if (_rtw_init_xmit_priv(&padapter->xmitpriv, padapter) == _FAIL)
goto free_mlme_ext;
if (_rtw_init_recv_priv(&padapter->recvpriv, padapter) == _FAIL)
goto free_xmit_priv;
/* add for CONFIG_IEEE80211W, none 11w also can use */
spin_lock_init(&padapter->security_key_mutex);
/* We don't need to memset padapter->XXX to zero, because adapter is allocated by vzalloc(). */
/* memset((unsigned char *)&padapter->securitypriv, 0, sizeof (struct security_priv)); */
if (_rtw_init_sta_priv(&padapter->stapriv) == _FAIL)
goto free_recv_priv;
padapter->stapriv.padapter = padapter;
padapter->setband = GHZ24_50;
padapter->fix_rate = 0xFF;
rtw_init_bcmc_stainfo(padapter);
rtw_init_pwrctrl_priv(padapter);
rtw_hal_dm_init(padapter);
return _SUCCESS;
free_recv_priv:
_rtw_free_recv_priv(&padapter->recvpriv);
free_xmit_priv:
_rtw_free_xmit_priv(&padapter->xmitpriv);
free_mlme_ext:
free_mlme_ext_priv(&padapter->mlmeextpriv);
rtw_free_mlme_priv(&padapter->mlmepriv);
free_evt_priv:
rtw_free_evt_priv(&padapter->evtpriv);
free_cmd_priv:
rtw_free_cmd_priv(&padapter->cmdpriv);
return _FAIL;
}
void rtw_cancel_all_timer(struct adapter *padapter)
{
del_timer_sync(&padapter->mlmepriv.assoc_timer);
del_timer_sync(&padapter->mlmepriv.scan_to_timer);
del_timer_sync(&padapter->mlmepriv.dynamic_chk_timer);
del_timer_sync(&(adapter_to_pwrctl(padapter)->pwr_state_check_timer));
del_timer_sync(&padapter->mlmepriv.set_scan_deny_timer);
rtw_clear_scan_deny(padapter);
del_timer_sync(&padapter->recvpriv.signal_stat_timer);
/* cancel dm timer */
rtw_hal_dm_deinit(padapter);
}
u8 rtw_free_drv_sw(struct adapter *padapter)
{
free_mlme_ext_priv(&padapter->mlmeextpriv);
rtw_free_cmd_priv(&padapter->cmdpriv);
rtw_free_evt_priv(&padapter->evtpriv);
rtw_free_mlme_priv(&padapter->mlmepriv);
/* free_io_queue(padapter); */
_rtw_free_xmit_priv(&padapter->xmitpriv);
_rtw_free_sta_priv(&padapter->stapriv); /* will free bcmc_stainfo here */
_rtw_free_recv_priv(&padapter->recvpriv);
rtw_free_pwrctrl_priv(padapter);
/* kfree((void *)padapter); */
rtw_hal_free_data(padapter);
/* free the old_pnetdev */
if (padapter->rereg_nd_name_priv.old_pnetdev) {
free_netdev(padapter->rereg_nd_name_priv.old_pnetdev);
padapter->rereg_nd_name_priv.old_pnetdev = NULL;
}
/* clear pbuddystruct adapter to avoid access wrong pointer. */
if (padapter->pbuddy_adapter)
padapter->pbuddy_adapter->pbuddy_adapter = NULL;
return _SUCCESS;
}
static int _rtw_drv_register_netdev(struct adapter *padapter, char *name)
{
int ret = _SUCCESS;
struct net_device *pnetdev = padapter->pnetdev;
/* alloc netdev name */
if (rtw_init_netdev_name(pnetdev, name))
return _FAIL;
eth_hw_addr_set(pnetdev, padapter->eeprompriv.mac_addr);
/* Tell the network stack we exist */
if (register_netdev(pnetdev) != 0) {
ret = _FAIL;
goto error_register_netdev;
}
return ret;
error_register_netdev:
rtw_free_drv_sw(padapter);
rtw_free_netdev(pnetdev);
return ret;
}
int rtw_drv_register_netdev(struct adapter *if1)
{
struct dvobj_priv *dvobj = if1->dvobj;
struct adapter *padapter = dvobj->padapters;
char *name = if1->registrypriv.ifname;
return _rtw_drv_register_netdev(padapter, name);
}
static int _netdev_open(struct net_device *pnetdev)
{
uint status;
struct adapter *padapter = rtw_netdev_priv(pnetdev);
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
padapter->netif_up = true;
if (pwrctrlpriv->ps_flag) {
padapter->net_closed = false;
goto netdev_open_normal_process;
}
if (!padapter->bup) {
padapter->bDriverStopped = false;
padapter->bSurpriseRemoved = false;
padapter->bCardDisableWOHSM = false;
status = rtw_hal_init(padapter);
if (status == _FAIL)
goto netdev_open_error;
status = rtw_start_drv_threads(padapter);
if (status == _FAIL)
goto netdev_open_error;
if (padapter->intf_start)
padapter->intf_start(padapter);
rtw_cfg80211_init_wiphy(padapter);
padapter->bup = true;
pwrctrlpriv->bips_processing = false;
}
padapter->net_closed = false;
_set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
if (!rtw_netif_queue_stopped(pnetdev))
rtw_netif_start_queue(pnetdev);
else
rtw_netif_wake_queue(pnetdev);
netdev_open_normal_process:
return 0;
netdev_open_error:
padapter->bup = false;
netif_carrier_off(pnetdev);
rtw_netif_stop_queue(pnetdev);
return (-1);
}
int netdev_open(struct net_device *pnetdev)
{
int ret;
struct adapter *padapter = rtw_netdev_priv(pnetdev);
struct pwrctrl_priv *pwrctrlpriv = adapter_to_pwrctl(padapter);
if (pwrctrlpriv->bInSuspend)
return 0;
if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex)))
return -1;
ret = _netdev_open(pnetdev);
mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
return ret;
}
static int ips_netdrv_open(struct adapter *padapter)
{
int status = _SUCCESS;
/* struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter); */
padapter->net_closed = false;
padapter->bDriverStopped = false;
padapter->bCardDisableWOHSM = false;
/* padapter->bup = true; */
status = rtw_hal_init(padapter);
if (status == _FAIL)
goto netdev_open_error;
if (padapter->intf_start)
padapter->intf_start(padapter);
_set_timer(&padapter->mlmepriv.dynamic_chk_timer, 2000);
return _SUCCESS;
netdev_open_error:
return _FAIL;
}
int rtw_ips_pwr_up(struct adapter *padapter)
{
return ips_netdrv_open(padapter);
}
void rtw_ips_pwr_down(struct adapter *padapter)
{
padapter->bCardDisableWOHSM = true;
padapter->net_closed = true;
rtw_ips_dev_unload(padapter);
padapter->bCardDisableWOHSM = false;
}
void rtw_ips_dev_unload(struct adapter *padapter)
{
if (!padapter->bSurpriseRemoved)
rtw_hal_deinit(padapter);
}
static int pm_netdev_open(struct net_device *pnetdev, u8 bnormal)
{
int status = -1;
struct adapter *padapter = rtw_netdev_priv(pnetdev);
if (bnormal) {
if (mutex_lock_interruptible(&(adapter_to_dvobj(padapter)->hw_init_mutex)) == 0) {
status = _netdev_open(pnetdev);
mutex_unlock(&(adapter_to_dvobj(padapter)->hw_init_mutex));
}
} else {
status = (_SUCCESS == ips_netdrv_open(padapter)) ? (0) : (-1);
}
return status;
}
static int netdev_close(struct net_device *pnetdev)
{
struct adapter *padapter = rtw_netdev_priv(pnetdev);
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
if (pwrctl->bInternalAutoSuspend) {
/* rtw_pwr_wakeup(padapter); */
if (pwrctl->rf_pwrstate == rf_off)
pwrctl->ps_flag = true;
}
padapter->net_closed = true;
padapter->netif_up = false;
/*if (!padapter->hw_init_completed)
{
padapter->bDriverStopped = true;
rtw_dev_unload(padapter);
}
else*/
if (pwrctl->rf_pwrstate == rf_on) {
/* s1. */
if (pnetdev) {
if (!rtw_netif_queue_stopped(pnetdev))
rtw_netif_stop_queue(pnetdev);
}
/* s2. */
LeaveAllPowerSaveMode(padapter);
rtw_disassoc_cmd(padapter, 500, false);
/* s2-2. indicate disconnect to os */
rtw_indicate_disconnect(padapter);
/* s2-3. */
rtw_free_assoc_resources(padapter, 1);
/* s2-4. */
rtw_free_network_queue(padapter, true);
}
rtw_scan_abort(padapter);
adapter_wdev_data(padapter)->bandroid_scan = false;
return 0;
}
void rtw_ndev_destructor(struct net_device *ndev)
{
kfree(ndev->ieee80211_ptr);
}
void rtw_dev_unload(struct adapter *padapter)
{
struct pwrctrl_priv *pwrctl = adapter_to_pwrctl(padapter);
struct dvobj_priv *pobjpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &pobjpriv->drv_dbg;
struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
u8 cnt = 0;
if (padapter->bup) {
padapter->bDriverStopped = true;
if (padapter->xmitpriv.ack_tx)
rtw_ack_tx_done(&padapter->xmitpriv, RTW_SCTX_DONE_DRV_STOP);
if (padapter->intf_stop)
padapter->intf_stop(padapter);
if (!pwrctl->bInternalAutoSuspend)
rtw_stop_drv_threads(padapter);
while (atomic_read(&pcmdpriv->cmdthd_running)) {
if (cnt > 5) {
break;
} else {
cnt++;
msleep(10);
}
}
/* check the status of IPS */
if (rtw_hal_check_ips_status(padapter) || pwrctl->rf_pwrstate == rf_off) {
/* check HW status and SW state */
netdev_dbg(padapter->pnetdev,
"%s: driver in IPS-FWLPS\n", __func__);
pdbgpriv->dbg_dev_unload_inIPS_cnt++;
LeaveAllPowerSaveMode(padapter);
} else {
netdev_dbg(padapter->pnetdev,
"%s: driver not in IPS\n", __func__);
}
if (!padapter->bSurpriseRemoved) {
hal_btcoex_IpsNotify(padapter, pwrctl->ips_mode_req);
/* amy modify 20120221 for power seq is different between driver open and ips */
rtw_hal_deinit(padapter);
padapter->bSurpriseRemoved = true;
}
padapter->bup = false;
}
}
static int rtw_suspend_free_assoc_resource(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME)) {
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)
&& check_fwstate(pmlmepriv, _FW_LINKED)) {
rtw_set_to_roam(padapter, 1);
}
}
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE) && check_fwstate(pmlmepriv, _FW_LINKED)) {
rtw_disassoc_cmd(padapter, 0, false);
/* s2-2. indicate disconnect to os */
rtw_indicate_disconnect(padapter);
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
rtw_sta_flush(padapter);
}
/* s2-3. */
rtw_free_assoc_resources(padapter, 1);
/* s2-4. */
rtw_free_network_queue(padapter, true);
if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY))
rtw_indicate_scan_done(padapter, 1);
if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) {
netdev_dbg(padapter->pnetdev, "%s: fw_under_linking\n",
__func__);
rtw_indicate_disconnect(padapter);
}
return _SUCCESS;
}
static void rtw_suspend_normal(struct adapter *padapter)
{
struct net_device *pnetdev = padapter->pnetdev;
if (pnetdev) {
netif_carrier_off(pnetdev);
rtw_netif_stop_queue(pnetdev);
}
rtw_suspend_free_assoc_resource(padapter);
if ((rtw_hal_check_ips_status(padapter)) || (adapter_to_pwrctl(padapter)->rf_pwrstate == rf_off))
netdev_dbg(padapter->pnetdev,
"%s: ### ERROR #### driver in IPS ####ERROR###!!!\n",
__func__);
rtw_dev_unload(padapter);
/* sdio_deinit(adapter_to_dvobj(padapter)); */
if (padapter->intf_deinit)
padapter->intf_deinit(adapter_to_dvobj(padapter));
}
void rtw_suspend_common(struct adapter *padapter)
{
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
unsigned long start_time = jiffies;
netdev_dbg(padapter->pnetdev, " suspend start\n");
pdbgpriv->dbg_suspend_cnt++;
pwrpriv->bInSuspend = true;
while (pwrpriv->bips_processing)
msleep(1);
if ((!padapter->bup) || (padapter->bDriverStopped) || (padapter->bSurpriseRemoved)) {
pdbgpriv->dbg_suspend_error_cnt++;
goto exit;
}
rtw_ps_deny(padapter, PS_DENY_SUSPEND);
rtw_cancel_all_timer(padapter);
LeaveAllPowerSaveModeDirect(padapter);
rtw_stop_cmd_thread(padapter);
/* wait for the latest FW to remove this condition. */
if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
hal_btcoex_SuspendNotify(padapter, 0);
else if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
hal_btcoex_SuspendNotify(padapter, 1);
rtw_ps_deny_cancel(padapter, PS_DENY_SUSPEND);
rtw_suspend_normal(padapter);
netdev_dbg(padapter->pnetdev, "rtw suspend success in %d ms\n",
jiffies_to_msecs(jiffies - start_time));
exit:
return;
}
static int rtw_resume_process_normal(struct adapter *padapter)
{
struct net_device *pnetdev;
struct pwrctrl_priv *pwrpriv;
struct mlme_priv *pmlmepriv;
struct dvobj_priv *psdpriv;
struct debug_priv *pdbgpriv;
int ret = _SUCCESS;
if (!padapter) {
ret = -1;
goto exit;
}
pnetdev = padapter->pnetdev;
pwrpriv = adapter_to_pwrctl(padapter);
pmlmepriv = &padapter->mlmepriv;
psdpriv = padapter->dvobj;
pdbgpriv = &psdpriv->drv_dbg;
/* interface init */
/* if (sdio_init(adapter_to_dvobj(padapter)) != _SUCCESS) */
if ((padapter->intf_init) && (padapter->intf_init(adapter_to_dvobj(padapter)) != _SUCCESS)) {
ret = -1;
goto exit;
}
rtw_hal_disable_interrupt(padapter);
/* if (sdio_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS) */
if ((padapter->intf_alloc_irq) && (padapter->intf_alloc_irq(adapter_to_dvobj(padapter)) != _SUCCESS)) {
ret = -1;
goto exit;
}
rtw_reset_drv_sw(padapter);
pwrpriv->bkeepfwalive = false;
if (pm_netdev_open(pnetdev, true) != 0) {
ret = -1;
pdbgpriv->dbg_resume_error_cnt++;
goto exit;
}
netif_device_attach(pnetdev);
netif_carrier_on(pnetdev);
if (padapter->pid[1] != 0)
rtw_signal_process(padapter->pid[1], SIGUSR2);
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) {
if (rtw_chk_roam_flags(padapter, RTW_ROAM_ON_RESUME))
rtw_roaming(padapter, NULL);
} else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
rtw_ap_restore_network(padapter);
}
exit:
return ret;
}
int rtw_resume_common(struct adapter *padapter)
{
int ret = 0;
unsigned long start_time = jiffies;
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
netdev_dbg(padapter->pnetdev, "resume start\n");
rtw_resume_process_normal(padapter);
hal_btcoex_SuspendNotify(padapter, 0);
if (pwrpriv) {
pwrpriv->bInSuspend = false;
}
netdev_dbg(padapter->pnetdev, "%s:%d in %d ms\n", __func__, ret,
jiffies_to_msecs(jiffies - start_time));
return ret;
}
| linux-master | drivers/staging/rtl8723bs/os_dep/os_intfs.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <hal_btcoex.h>
#include <linux/jiffies.h>
#ifndef dev_to_sdio_func
#define dev_to_sdio_func(d) container_of(d, struct sdio_func, dev)
#endif
static const struct sdio_device_id sdio_ids[] = {
{ SDIO_DEVICE(0x024c, 0x0523), },
{ SDIO_DEVICE(0x024c, 0x0525), },
{ SDIO_DEVICE(0x024c, 0x0623), },
{ SDIO_DEVICE(0x024c, 0x0626), },
{ SDIO_DEVICE(0x024c, 0x0627), },
{ SDIO_DEVICE(0x024c, 0xb723), },
{ /* end: all zeroes */ },
};
MODULE_DEVICE_TABLE(sdio, sdio_ids);
static int rtw_drv_init(struct sdio_func *func, const struct sdio_device_id *id);
static void rtw_dev_remove(struct sdio_func *func);
static int rtw_sdio_resume(struct device *dev);
static int rtw_sdio_suspend(struct device *dev);
static const struct dev_pm_ops rtw_sdio_pm_ops = {
.suspend = rtw_sdio_suspend,
.resume = rtw_sdio_resume,
};
static struct sdio_driver rtl8723bs_sdio_driver = {
.probe = rtw_drv_init,
.remove = rtw_dev_remove,
.name = "rtl8723bs",
.id_table = sdio_ids,
.drv = {
.pm = &rtw_sdio_pm_ops,
}
};
static void sd_sync_int_hdl(struct sdio_func *func)
{
struct dvobj_priv *psdpriv;
psdpriv = sdio_get_drvdata(func);
if (!psdpriv->if1)
return;
rtw_sdio_set_irq_thd(psdpriv, current);
sd_int_hdl(psdpriv->if1);
rtw_sdio_set_irq_thd(psdpriv, NULL);
}
static int sdio_alloc_irq(struct dvobj_priv *dvobj)
{
struct sdio_data *psdio_data;
struct sdio_func *func;
int err;
psdio_data = &dvobj->intf_data;
func = psdio_data->func;
sdio_claim_host(func);
err = sdio_claim_irq(func, &sd_sync_int_hdl);
if (err) {
dvobj->drv_dbg.dbg_sdio_alloc_irq_error_cnt++;
printk(KERN_CRIT "%s: sdio_claim_irq FAIL(%d)!\n", __func__, err);
} else {
dvobj->drv_dbg.dbg_sdio_alloc_irq_cnt++;
dvobj->irq_alloc = 1;
}
sdio_release_host(func);
return err?_FAIL:_SUCCESS;
}
static void sdio_free_irq(struct dvobj_priv *dvobj)
{
struct sdio_data *psdio_data;
struct sdio_func *func;
int err;
if (dvobj->irq_alloc) {
psdio_data = &dvobj->intf_data;
func = psdio_data->func;
if (func) {
sdio_claim_host(func);
err = sdio_release_irq(func);
if (err) {
dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++;
netdev_err(dvobj->if1->pnetdev,
"%s: sdio_release_irq FAIL(%d)!\n",
__func__, err);
} else
dvobj->drv_dbg.dbg_sdio_free_irq_cnt++;
sdio_release_host(func);
}
dvobj->irq_alloc = 0;
}
}
static u32 sdio_init(struct dvobj_priv *dvobj)
{
struct sdio_data *psdio_data;
struct sdio_func *func;
int err;
psdio_data = &dvobj->intf_data;
func = psdio_data->func;
/* 3 1. init SDIO bus */
sdio_claim_host(func);
err = sdio_enable_func(func);
if (err) {
dvobj->drv_dbg.dbg_sdio_init_error_cnt++;
goto release;
}
err = sdio_set_block_size(func, 512);
if (err) {
dvobj->drv_dbg.dbg_sdio_init_error_cnt++;
goto release;
}
psdio_data->block_transfer_len = 512;
psdio_data->tx_block_mode = 1;
psdio_data->rx_block_mode = 1;
release:
sdio_release_host(func);
if (err)
return _FAIL;
return _SUCCESS;
}
static void sdio_deinit(struct dvobj_priv *dvobj)
{
struct sdio_func *func;
int err;
func = dvobj->intf_data.func;
if (func) {
sdio_claim_host(func);
err = sdio_disable_func(func);
if (err)
dvobj->drv_dbg.dbg_sdio_deinit_error_cnt++;
if (dvobj->irq_alloc) {
err = sdio_release_irq(func);
if (err)
dvobj->drv_dbg.dbg_sdio_free_irq_error_cnt++;
else
dvobj->drv_dbg.dbg_sdio_free_irq_cnt++;
}
sdio_release_host(func);
}
}
static struct dvobj_priv *sdio_dvobj_init(struct sdio_func *func)
{
int status = _FAIL;
struct dvobj_priv *dvobj = NULL;
struct sdio_data *psdio;
dvobj = devobj_init();
if (!dvobj)
goto exit;
sdio_set_drvdata(func, dvobj);
psdio = &dvobj->intf_data;
psdio->func = func;
if (sdio_init(dvobj) != _SUCCESS)
goto free_dvobj;
rtw_reset_continual_io_error(dvobj);
status = _SUCCESS;
free_dvobj:
if (status != _SUCCESS && dvobj) {
sdio_set_drvdata(func, NULL);
devobj_deinit(dvobj);
dvobj = NULL;
}
exit:
return dvobj;
}
static void sdio_dvobj_deinit(struct sdio_func *func)
{
struct dvobj_priv *dvobj = sdio_get_drvdata(func);
sdio_set_drvdata(func, NULL);
if (dvobj) {
sdio_deinit(dvobj);
devobj_deinit(dvobj);
}
}
void rtw_set_hal_ops(struct adapter *padapter)
{
/* alloc memory for HAL DATA */
rtw_hal_data_init(padapter);
rtl8723bs_set_hal_ops(padapter);
}
static void sd_intf_start(struct adapter *padapter)
{
if (!padapter)
return;
/* hal dep */
rtw_hal_enable_interrupt(padapter);
}
static void sd_intf_stop(struct adapter *padapter)
{
if (!padapter)
return;
/* hal dep */
rtw_hal_disable_interrupt(padapter);
}
static struct adapter *rtw_sdio_if1_init(struct dvobj_priv *dvobj, const struct sdio_device_id *pdid)
{
int status = _FAIL;
struct net_device *pnetdev;
struct adapter *padapter = NULL;
struct sdio_data *psdio = &dvobj->intf_data;
padapter = vzalloc(sizeof(*padapter));
if (!padapter)
goto exit;
padapter->dvobj = dvobj;
dvobj->if1 = padapter;
padapter->bDriverStopped = true;
dvobj->padapters = padapter;
padapter->iface_id = 0;
/* 3 1. init network device data */
pnetdev = rtw_init_netdev(padapter);
if (!pnetdev)
goto free_adapter;
SET_NETDEV_DEV(pnetdev, dvobj_to_dev(dvobj));
padapter = rtw_netdev_priv(pnetdev);
/* 3 3. init driver special setting, interface, OS and hardware relative */
/* 4 3.1 set hardware operation functions */
rtw_set_hal_ops(padapter);
/* 3 5. initialize Chip version */
padapter->intf_start = &sd_intf_start;
padapter->intf_stop = &sd_intf_stop;
padapter->intf_init = &sdio_init;
padapter->intf_deinit = &sdio_deinit;
padapter->intf_alloc_irq = &sdio_alloc_irq;
padapter->intf_free_irq = &sdio_free_irq;
if (rtw_init_io_priv(padapter, sdio_set_intf_ops) == _FAIL)
goto free_hal_data;
rtw_hal_read_chip_version(padapter);
rtw_hal_chip_configure(padapter);
hal_btcoex_Initialize((void *) padapter);
/* 3 6. read efuse/eeprom data */
rtw_hal_read_chip_info(padapter);
/* 3 7. init driver common data */
if (rtw_init_drv_sw(padapter) == _FAIL)
goto free_hal_data;
rtw_wdev_alloc(padapter, dvobj_to_dev(dvobj));
/* 3 8. get WLan MAC address */
/* set mac addr */
rtw_macaddr_cfg(&psdio->func->dev, padapter->eeprompriv.mac_addr);
rtw_hal_disable_interrupt(padapter);
status = _SUCCESS;
free_hal_data:
if (status != _SUCCESS && padapter->HalData)
kfree(padapter->HalData);
if (status != _SUCCESS) {
rtw_wdev_unregister(padapter->rtw_wdev);
rtw_wdev_free(padapter->rtw_wdev);
}
free_adapter:
if (status != _SUCCESS) {
if (pnetdev)
rtw_free_netdev(pnetdev);
else
vfree((u8 *)padapter);
padapter = NULL;
}
exit:
return padapter;
}
static void rtw_sdio_if1_deinit(struct adapter *if1)
{
struct net_device *pnetdev = if1->pnetdev;
struct mlme_priv *pmlmepriv = &if1->mlmepriv;
if (check_fwstate(pmlmepriv, _FW_LINKED))
rtw_disassoc_cmd(if1, 0, false);
free_mlme_ap_info(if1);
rtw_cancel_all_timer(if1);
rtw_dev_unload(if1);
if (if1->rtw_wdev)
rtw_wdev_free(if1->rtw_wdev);
rtw_free_drv_sw(if1);
if (pnetdev)
rtw_free_netdev(pnetdev);
}
/*
* drv_init() - a device potentially for us
*
* notes: drv_init() is called when the bus driver has located a card for us to support.
* We accept the new device by returning 0.
*/
static int rtw_drv_init(
struct sdio_func *func,
const struct sdio_device_id *id)
{
int status = _FAIL;
struct adapter *if1 = NULL;
struct dvobj_priv *dvobj;
dvobj = sdio_dvobj_init(func);
if (!dvobj)
goto exit;
if1 = rtw_sdio_if1_init(dvobj, id);
if (!if1)
goto free_dvobj;
/* dev_alloc_name && register_netdev */
status = rtw_drv_register_netdev(if1);
if (status != _SUCCESS)
goto free_if1;
if (sdio_alloc_irq(dvobj) != _SUCCESS)
goto free_if1;
rtw_ndev_notifier_register();
status = _SUCCESS;
free_if1:
if (status != _SUCCESS && if1)
rtw_sdio_if1_deinit(if1);
free_dvobj:
if (status != _SUCCESS)
sdio_dvobj_deinit(func);
exit:
return status == _SUCCESS ? 0 : -ENODEV;
}
static void rtw_dev_remove(struct sdio_func *func)
{
struct dvobj_priv *dvobj = sdio_get_drvdata(func);
struct adapter *padapter = dvobj->if1;
dvobj->processing_dev_remove = true;
rtw_unregister_netdevs(dvobj);
if (!padapter->bSurpriseRemoved) {
int err;
/* test surprise remove */
sdio_claim_host(func);
sdio_readb(func, 0, &err);
sdio_release_host(func);
if (err == -ENOMEDIUM)
padapter->bSurpriseRemoved = true;
}
rtw_ps_deny(padapter, PS_DENY_DRV_REMOVE);
rtw_pm_set_ips(padapter, IPS_NONE);
rtw_pm_set_lps(padapter, PS_MODE_ACTIVE);
LeaveAllPowerSaveMode(padapter);
rtw_btcoex_HaltNotify(padapter);
rtw_sdio_if1_deinit(padapter);
sdio_dvobj_deinit(func);
}
static int rtw_sdio_suspend(struct device *dev)
{
struct sdio_func *func = dev_to_sdio_func(dev);
struct dvobj_priv *psdpriv = sdio_get_drvdata(func);
struct pwrctrl_priv *pwrpriv = dvobj_to_pwrctl(psdpriv);
struct adapter *padapter = psdpriv->if1;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
if (padapter->bDriverStopped)
return 0;
if (pwrpriv->bInSuspend) {
pdbgpriv->dbg_suspend_error_cnt++;
return 0;
}
rtw_suspend_common(padapter);
return 0;
}
static int rtw_resume_process(struct adapter *padapter)
{
struct pwrctrl_priv *pwrpriv = adapter_to_pwrctl(padapter);
struct dvobj_priv *psdpriv = padapter->dvobj;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
if (!pwrpriv->bInSuspend) {
pdbgpriv->dbg_resume_error_cnt++;
return -1;
}
return rtw_resume_common(padapter);
}
static int rtw_sdio_resume(struct device *dev)
{
struct sdio_func *func = dev_to_sdio_func(dev);
struct dvobj_priv *psdpriv = sdio_get_drvdata(func);
struct adapter *padapter = psdpriv->if1;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
int ret = 0;
struct debug_priv *pdbgpriv = &psdpriv->drv_dbg;
pdbgpriv->dbg_resume_cnt++;
ret = rtw_resume_process(padapter);
pmlmeext->last_scan_time = jiffies;
return ret;
}
static int __init rtw_drv_entry(void)
{
int ret;
ret = sdio_register_driver(&rtl8723bs_sdio_driver);
if (ret != 0)
rtw_ndev_notifier_unregister();
return ret;
}
static void __exit rtw_drv_halt(void)
{
sdio_unregister_driver(&rtl8723bs_sdio_driver);
rtw_ndev_notifier_unregister();
}
module_init(rtw_drv_entry);
module_exit(rtw_drv_halt);
| linux-master | drivers/staging/rtl8723bs/os_dep/sdio_intf.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <linux/jiffies.h>
#include <net/cfg80211.h>
#include <asm/unaligned.h>
void rtw_os_free_recvframe(union recv_frame *precvframe)
{
if (precvframe->u.hdr.pkt) {
dev_kfree_skb_any(precvframe->u.hdr.pkt);/* free skb by driver */
precvframe->u.hdr.pkt = NULL;
}
}
/* alloc os related resource in union recv_frame */
void rtw_os_recv_resource_alloc(struct adapter *padapter, union recv_frame *precvframe)
{
precvframe->u.hdr.pkt_newalloc = precvframe->u.hdr.pkt = NULL;
}
/* free os related resource in union recv_frame */
void rtw_os_recv_resource_free(struct recv_priv *precvpriv)
{
signed int i;
union recv_frame *precvframe;
precvframe = (union recv_frame *) precvpriv->precv_frame_buf;
for (i = 0; i < NR_RECVFRAME; i++) {
if (precvframe->u.hdr.pkt) {
/* free skb by driver */
dev_kfree_skb_any(precvframe->u.hdr.pkt);
precvframe->u.hdr.pkt = NULL;
}
precvframe++;
}
}
/* free os related resource in struct recv_buf */
void rtw_os_recvbuf_resource_free(struct adapter *padapter, struct recv_buf *precvbuf)
{
if (precvbuf->pskb) {
dev_kfree_skb_any(precvbuf->pskb);
}
}
struct sk_buff *rtw_os_alloc_msdu_pkt(union recv_frame *prframe, u16 nSubframe_Length, u8 *pdata)
{
u16 eth_type;
struct sk_buff *sub_skb;
struct rx_pkt_attrib *pattrib;
pattrib = &prframe->u.hdr.attrib;
sub_skb = rtw_skb_alloc(nSubframe_Length + 12);
if (!sub_skb)
return NULL;
skb_reserve(sub_skb, 12);
skb_put_data(sub_skb, (pdata + ETH_HLEN), nSubframe_Length);
eth_type = get_unaligned_be16(&sub_skb->data[6]);
if (sub_skb->len >= 8 &&
((!memcmp(sub_skb->data, rfc1042_header, SNAP_SIZE) &&
eth_type != ETH_P_AARP && eth_type != ETH_P_IPX) ||
!memcmp(sub_skb->data, bridge_tunnel_header, SNAP_SIZE))) {
/*
* remove RFC1042 or Bridge-Tunnel encapsulation and replace
* EtherType
*/
skb_pull(sub_skb, SNAP_SIZE);
memcpy(skb_push(sub_skb, ETH_ALEN), pattrib->src, ETH_ALEN);
memcpy(skb_push(sub_skb, ETH_ALEN), pattrib->dst, ETH_ALEN);
} else {
__be16 len;
/* Leave Ethernet header part of hdr and full payload */
len = htons(sub_skb->len);
memcpy(skb_push(sub_skb, 2), &len, 2);
memcpy(skb_push(sub_skb, ETH_ALEN), pattrib->src, ETH_ALEN);
memcpy(skb_push(sub_skb, ETH_ALEN), pattrib->dst, ETH_ALEN);
}
return sub_skb;
}
void rtw_os_recv_indicate_pkt(struct adapter *padapter, struct sk_buff *pkt, struct rx_pkt_attrib *pattrib)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
/* Indicate the packets to upper layer */
if (pkt) {
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) == true) {
struct sk_buff *pskb2 = NULL;
struct sta_info *psta = NULL;
struct sta_priv *pstapriv = &padapter->stapriv;
int bmcast = is_multicast_ether_addr(pattrib->dst);
if (memcmp(pattrib->dst, myid(&padapter->eeprompriv), ETH_ALEN)) {
if (bmcast) {
psta = rtw_get_bcmc_stainfo(padapter);
pskb2 = skb_clone(pkt, GFP_ATOMIC);
} else {
psta = rtw_get_stainfo(pstapriv, pattrib->dst);
}
if (psta) {
struct net_device *pnetdev = (struct net_device *)padapter->pnetdev;
/* skb->ip_summed = CHECKSUM_NONE; */
pkt->dev = pnetdev;
skb_set_queue_mapping(pkt, rtw_recv_select_queue(pkt));
_rtw_xmit_entry(pkt, pnetdev);
if (bmcast && pskb2)
pkt = pskb2;
else
return;
}
} else {
/* to APself */
}
}
pkt->protocol = eth_type_trans(pkt, padapter->pnetdev);
pkt->dev = padapter->pnetdev;
pkt->ip_summed = CHECKSUM_NONE;
rtw_netif_rx(padapter->pnetdev, pkt);
}
}
void rtw_handle_tkip_mic_err(struct adapter *padapter, u8 bgroup)
{
enum nl80211_key_type key_type = 0;
union iwreq_data wrqu;
struct iw_michaelmicfailure ev;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
unsigned long cur_time = 0;
if (psecuritypriv->last_mic_err_time == 0) {
psecuritypriv->last_mic_err_time = jiffies;
} else {
cur_time = jiffies;
if (cur_time - psecuritypriv->last_mic_err_time < 60*HZ) {
psecuritypriv->btkip_countermeasure = true;
psecuritypriv->last_mic_err_time = 0;
psecuritypriv->btkip_countermeasure_time = cur_time;
} else {
psecuritypriv->last_mic_err_time = jiffies;
}
}
if (bgroup) {
key_type |= NL80211_KEYTYPE_GROUP;
} else {
key_type |= NL80211_KEYTYPE_PAIRWISE;
}
cfg80211_michael_mic_failure(padapter->pnetdev, (u8 *)&pmlmepriv->assoc_bssid[0], key_type, -1,
NULL, GFP_ATOMIC);
memset(&ev, 0x00, sizeof(ev));
if (bgroup) {
ev.flags |= IW_MICFAILURE_GROUP;
} else {
ev.flags |= IW_MICFAILURE_PAIRWISE;
}
ev.src_addr.sa_family = ARPHRD_ETHER;
memcpy(ev.src_addr.sa_data, &pmlmepriv->assoc_bssid[0], ETH_ALEN);
memset(&wrqu, 0x00, sizeof(wrqu));
wrqu.data.length = sizeof(ev);
}
int rtw_recv_indicatepkt(struct adapter *padapter, union recv_frame *precv_frame)
{
struct recv_priv *precvpriv;
struct __queue *pfree_recv_queue;
struct sk_buff *skb;
struct rx_pkt_attrib *pattrib = &precv_frame->u.hdr.attrib;
precvpriv = &(padapter->recvpriv);
pfree_recv_queue = &(precvpriv->free_recv_queue);
skb = precv_frame->u.hdr.pkt;
if (!skb)
goto _recv_indicatepkt_drop;
skb->data = precv_frame->u.hdr.rx_data;
skb_set_tail_pointer(skb, precv_frame->u.hdr.len);
skb->len = precv_frame->u.hdr.len;
rtw_os_recv_indicate_pkt(padapter, skb, pattrib);
/* pointers to NULL before rtw_free_recvframe() */
precv_frame->u.hdr.pkt = NULL;
rtw_free_recvframe(precv_frame, pfree_recv_queue);
return _SUCCESS;
_recv_indicatepkt_drop:
/* enqueue back to free_recv_queue */
rtw_free_recvframe(precv_frame, pfree_recv_queue);
return _FAIL;
}
void rtw_init_recv_timer(struct recv_reorder_ctrl *preorder_ctrl)
{
timer_setup(&preorder_ctrl->reordering_ctrl_timer,
rtw_reordering_ctrl_timeout_handler, 0);
}
| linux-master | drivers/staging/rtl8723bs/os_dep/recv_linux.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <linux/etherdevice.h>
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtw_mp.h>
#include <hal_btcoex.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
#define RTL_IOCTL_WPA_SUPPLICANT (SIOCIWFIRSTPRIV + 30)
static int wpa_set_auth_algs(struct net_device *dev, u32 value)
{
struct adapter *padapter = rtw_netdev_priv(dev);
int ret = 0;
if ((value & IW_AUTH_ALG_SHARED_KEY) && (value & IW_AUTH_ALG_OPEN_SYSTEM)) {
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeAutoSwitch;
padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
} else if (value & IW_AUTH_ALG_SHARED_KEY) {
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeShared;
padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
} else if (value & IW_AUTH_ALG_OPEN_SYSTEM) {
/* padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled; */
if (padapter->securitypriv.ndisauthtype < Ndis802_11AuthModeWPAPSK) {
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
}
} else {
ret = -EINVAL;
}
return ret;
}
static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
{
int ret = 0;
u8 max_idx;
u32 wep_key_idx, wep_key_len, wep_total_len;
struct ndis_802_11_wep *pwep = NULL;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
param->u.crypt.err = 0;
param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
if (param_len < (u32)((u8 *)param->u.crypt.key - (u8 *)param) + param->u.crypt.key_len) {
ret = -EINVAL;
goto exit;
}
if (param->sta_addr[0] != 0xff || param->sta_addr[1] != 0xff ||
param->sta_addr[2] != 0xff || param->sta_addr[3] != 0xff ||
param->sta_addr[4] != 0xff || param->sta_addr[5] != 0xff) {
ret = -EINVAL;
goto exit;
}
if (strcmp(param->u.crypt.alg, "WEP") == 0)
max_idx = WEP_KEYS - 1;
else
max_idx = BIP_MAX_KEYID;
if (param->u.crypt.idx > max_idx) {
netdev_err(dev, "Error crypt.idx %d > %d\n", param->u.crypt.idx, max_idx);
ret = -EINVAL;
goto exit;
}
if (strcmp(param->u.crypt.alg, "WEP") == 0) {
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
wep_key_idx = param->u.crypt.idx;
wep_key_len = param->u.crypt.key_len;
if (wep_key_len > 0) {
wep_key_len = wep_key_len <= 5 ? 5 : 13;
wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, key_material);
/* Allocate a full structure to avoid potentially running off the end. */
pwep = kzalloc(sizeof(*pwep), GFP_KERNEL);
if (!pwep) {
ret = -ENOMEM;
goto exit;
}
pwep->key_length = wep_key_len;
pwep->length = wep_total_len;
if (wep_key_len == 13) {
padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
}
} else {
ret = -EINVAL;
goto exit;
}
pwep->key_index = wep_key_idx;
pwep->key_index |= 0x80000000;
memcpy(pwep->key_material, param->u.crypt.key, pwep->key_length);
if (param->u.crypt.set_tx) {
if (rtw_set_802_11_add_wep(padapter, pwep) == (u8)_FAIL)
ret = -EOPNOTSUPP;
} else {
/* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */
/* psecuritypriv->dot11PrivacyKeyIndex =keyid", but can rtw_set_key to fw/cam */
if (wep_key_idx >= WEP_KEYS) {
ret = -EOPNOTSUPP;
goto exit;
}
memcpy(&psecuritypriv->dot11DefKey[wep_key_idx].skey[0], pwep->key_material, pwep->key_length);
psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->key_length;
rtw_set_key(padapter, psecuritypriv, wep_key_idx, 0, true);
}
goto exit;
}
if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) { /* 802_1x */
struct sta_info *psta, *pbcmc_sta;
struct sta_priv *pstapriv = &padapter->stapriv;
if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | WIFI_MP_STATE) == true) { /* sta mode */
psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
if (!psta) {
/* DEBUG_ERR(("Set wpa_set_encryption: Obtain Sta_info fail\n")); */
} else {
/* Jeff: don't disable ieee8021x_blocked while clearing key */
if (strcmp(param->u.crypt.alg, "none") != 0)
psta->ieee8021x_blocked = false;
if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) ||
(padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled)) {
psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
}
if (param->u.crypt.set_tx == 1) { /* pairwise key */
memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */
/* DEBUG_ERR(("\nset key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len)); */
memcpy(psta->dot11tkiptxmickey.skey, ¶m->u.crypt.key[16], 8);
memcpy(psta->dot11tkiprxmickey.skey, ¶m->u.crypt.key[24], 8);
padapter->securitypriv.busetkipkey = false;
/* _set_timer(&padapter->securitypriv.tkip_timer, 50); */
}
rtw_setstakey_cmd(padapter, psta, true, true);
} else { /* group key */
if (strcmp(param->u.crypt.alg, "TKIP") == 0 || strcmp(param->u.crypt.alg, "CCMP") == 0) {
memcpy(padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
/* only TKIP group key need to install this */
if (param->u.crypt.key_len > 16) {
memcpy(padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey, ¶m->u.crypt.key[16], 8);
memcpy(padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey, ¶m->u.crypt.key[24], 8);
}
padapter->securitypriv.binstallGrpkey = true;
padapter->securitypriv.dot118021XGrpKeyid = param->u.crypt.idx;
rtw_set_key(padapter, &padapter->securitypriv, param->u.crypt.idx, 1, true);
} else if (strcmp(param->u.crypt.alg, "BIP") == 0) {
/* printk("BIP key_len =%d , index =%d @@@@@@@@@@@@@@@@@@\n", param->u.crypt.key_len, param->u.crypt.idx); */
/* save the IGTK key, length 16 bytes */
memcpy(padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
/*printk("IGTK key below:\n");
for (no = 0;no<16;no++)
printk(" %02x ", padapter->securitypriv.dot11wBIPKey[param->u.crypt.idx].skey[no]);
printk("\n");*/
padapter->securitypriv.dot11wBIPKeyid = param->u.crypt.idx;
padapter->securitypriv.binstallBIPkey = true;
}
}
}
pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
if (!pbcmc_sta) {
/* DEBUG_ERR(("Set OID_802_11_ADD_KEY: bcmc stainfo is null\n")); */
} else {
/* Jeff: don't disable ieee8021x_blocked while clearing key */
if (strcmp(param->u.crypt.alg, "none") != 0)
pbcmc_sta->ieee8021x_blocked = false;
if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) ||
(padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled)) {
pbcmc_sta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
}
}
} else if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
/* adhoc mode */
}
}
exit:
kfree(pwep);
return ret;
}
static int rtw_set_wpa_ie(struct adapter *padapter, char *pie, unsigned short ielen)
{
u8 *buf = NULL;
int group_cipher = 0, pairwise_cipher = 0;
int ret = 0;
u8 null_addr[] = {0, 0, 0, 0, 0, 0};
if (ielen > MAX_WPA_IE_LEN || !pie) {
_clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
if (!pie)
return ret;
else
return -EINVAL;
}
if (ielen) {
buf = rtw_zmalloc(ielen);
if (!buf) {
ret = -ENOMEM;
goto exit;
}
memcpy(buf, pie, ielen);
if (ielen < RSN_HEADER_LEN) {
ret = -1;
goto exit;
}
if (rtw_parse_wpa_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK;
memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen);
}
if (rtw_parse_wpa2_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK;
memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen);
}
if (group_cipher == 0)
group_cipher = WPA_CIPHER_NONE;
if (pairwise_cipher == 0)
pairwise_cipher = WPA_CIPHER_NONE;
switch (group_cipher) {
case WPA_CIPHER_NONE:
padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
break;
case WPA_CIPHER_WEP40:
padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
case WPA_CIPHER_TKIP:
padapter->securitypriv.dot118021XGrpPrivacy = _TKIP_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
break;
case WPA_CIPHER_CCMP:
padapter->securitypriv.dot118021XGrpPrivacy = _AES_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
break;
case WPA_CIPHER_WEP104:
padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
}
switch (pairwise_cipher) {
case WPA_CIPHER_NONE:
padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
break;
case WPA_CIPHER_WEP40:
padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
case WPA_CIPHER_TKIP:
padapter->securitypriv.dot11PrivacyAlgrthm = _TKIP_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
break;
case WPA_CIPHER_CCMP:
padapter->securitypriv.dot11PrivacyAlgrthm = _AES_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
break;
case WPA_CIPHER_WEP104:
padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
break;
}
_clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
{/* set wps_ie */
u16 cnt = 0;
u8 eid, wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
while (cnt < ielen) {
eid = buf[cnt];
if ((eid == WLAN_EID_VENDOR_SPECIFIC) && (!memcmp(&buf[cnt + 2], wps_oui, 4))) {
padapter->securitypriv.wps_ie_len = ((buf[cnt + 1] + 2) < MAX_WPS_IE_LEN) ? (buf[cnt + 1] + 2) : MAX_WPS_IE_LEN;
memcpy(padapter->securitypriv.wps_ie, &buf[cnt], padapter->securitypriv.wps_ie_len);
set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS);
cnt += buf[cnt + 1] + 2;
break;
} else {
cnt += buf[cnt + 1] + 2; /* goto next */
}
}
}
}
/* TKIP and AES disallow multicast packets until installing group key */
if (padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_ ||
padapter->securitypriv.dot11PrivacyAlgrthm == _TKIP_WTMIC_ ||
padapter->securitypriv.dot11PrivacyAlgrthm == _AES_)
/* WPS open need to enable multicast */
/* check_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS) == true) */
rtw_hal_set_hwreg(padapter, HW_VAR_OFF_RCR_AM, null_addr);
exit:
kfree(buf);
return ret;
}
static int wpa_set_param(struct net_device *dev, u8 name, u32 value)
{
uint ret = 0;
struct adapter *padapter = rtw_netdev_priv(dev);
switch (name) {
case IEEE_PARAM_WPA_ENABLED:
padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; /* 802.1x */
/* ret = ieee80211_wpa_enable(ieee, value); */
switch ((value) & 0xff) {
case 1: /* WPA */
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; /* WPA_PSK */
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
break;
case 2: /* WPA2 */
padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; /* WPA2_PSK */
padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
break;
}
break;
case IEEE_PARAM_TKIP_COUNTERMEASURES:
/* ieee->tkip_countermeasures =value; */
break;
case IEEE_PARAM_DROP_UNENCRYPTED:
{
/* HACK:
*
* wpa_supplicant calls set_wpa_enabled when the driver
* is loaded and unloaded, regardless of if WPA is being
* used. No other calls are made which can be used to
* determine if encryption will be used or not prior to
* association being expected. If encryption is not being
* used, drop_unencrypted is set to false, else true -- we
* can use this to determine if the CAP_PRIVACY_ON bit should
* be set.
*/
break;
}
case IEEE_PARAM_PRIVACY_INVOKED:
/* ieee->privacy_invoked =value; */
break;
case IEEE_PARAM_AUTH_ALGS:
ret = wpa_set_auth_algs(dev, value);
break;
case IEEE_PARAM_IEEE_802_1X:
/* ieee->ieee802_1x =value; */
break;
case IEEE_PARAM_WPAX_SELECT:
/* added for WPA2 mixed mode */
/*
spin_lock_irqsave(&ieee->wpax_suitlist_lock, flags);
ieee->wpax_type_set = 1;
ieee->wpax_type_notify = value;
spin_unlock_irqrestore(&ieee->wpax_suitlist_lock, flags);
*/
break;
default:
ret = -EOPNOTSUPP;
break;
}
return ret;
}
static int wpa_mlme(struct net_device *dev, u32 command, u32 reason)
{
int ret = 0;
struct adapter *padapter = rtw_netdev_priv(dev);
switch (command) {
case IEEE_MLME_STA_DEAUTH:
if (!rtw_set_802_11_disassociate(padapter))
ret = -1;
break;
case IEEE_MLME_STA_DISASSOC:
if (!rtw_set_802_11_disassociate(padapter))
ret = -1;
break;
default:
ret = -EOPNOTSUPP;
break;
}
return ret;
}
static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p)
{
struct ieee_param *param;
uint ret = 0;
/* down(&ieee->wx_sem); */
if (!p->pointer || p->length != sizeof(struct ieee_param))
return -EINVAL;
param = rtw_malloc(p->length);
if (!param)
return -ENOMEM;
if (copy_from_user(param, p->pointer, p->length)) {
kfree(param);
return -EFAULT;
}
switch (param->cmd) {
case IEEE_CMD_SET_WPA_PARAM:
ret = wpa_set_param(dev, param->u.wpa_param.name, param->u.wpa_param.value);
break;
case IEEE_CMD_SET_WPA_IE:
/* ret = wpa_set_wpa_ie(dev, param, p->length); */
ret = rtw_set_wpa_ie(rtw_netdev_priv(dev), (char *)param->u.wpa_ie.data, (u16)param->u.wpa_ie.len);
break;
case IEEE_CMD_SET_ENCRYPTION:
ret = wpa_set_encryption(dev, param, p->length);
break;
case IEEE_CMD_MLME:
ret = wpa_mlme(dev, param->u.mlme.command, param->u.mlme.reason_code);
break;
default:
ret = -EOPNOTSUPP;
break;
}
if (ret == 0 && copy_to_user(p->pointer, param, p->length))
ret = -EFAULT;
kfree(param);
/* up(&ieee->wx_sem); */
return ret;
}
static int rtw_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
{
int ret = 0;
u32 wep_key_idx, wep_key_len, wep_total_len;
struct ndis_802_11_wep *pwep = NULL;
struct sta_info *psta = NULL, *pbcmc_sta = NULL;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct security_priv *psecuritypriv = &padapter->securitypriv;
struct sta_priv *pstapriv = &padapter->stapriv;
char *txkey = padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey;
char *rxkey = padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey;
char *grpkey = psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey;
param->u.crypt.err = 0;
param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
/* sizeof(struct ieee_param) = 64 bytes; */
/* if (param_len != (u32) ((u8 *) param->u.crypt.key - (u8 *) param) + param->u.crypt.key_len) */
if (param_len != sizeof(struct ieee_param) + param->u.crypt.key_len) {
ret = -EINVAL;
goto exit;
}
if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
if (param->u.crypt.idx >= WEP_KEYS) {
ret = -EINVAL;
goto exit;
}
} else {
psta = rtw_get_stainfo(pstapriv, param->sta_addr);
if (!psta)
/* ret = -EINVAL; */
goto exit;
}
if (strcmp(param->u.crypt.alg, "none") == 0 && !psta) {
/* todo:clear default encryption keys */
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
psecuritypriv->ndisencryptstatus = Ndis802_11EncryptionDisabled;
psecuritypriv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
goto exit;
}
if (strcmp(param->u.crypt.alg, "WEP") == 0 && !psta) {
wep_key_idx = param->u.crypt.idx;
wep_key_len = param->u.crypt.key_len;
if ((wep_key_idx >= WEP_KEYS) || (wep_key_len <= 0)) {
ret = -EINVAL;
goto exit;
}
if (wep_key_len > 0) {
wep_key_len = wep_key_len <= 5 ? 5 : 13;
wep_total_len = wep_key_len + FIELD_OFFSET(struct ndis_802_11_wep, key_material);
/* Allocate a full structure to avoid potentially running off the end. */
pwep = kzalloc(sizeof(*pwep), GFP_KERNEL);
if (!pwep)
goto exit;
pwep->key_length = wep_key_len;
pwep->length = wep_total_len;
}
pwep->key_index = wep_key_idx;
memcpy(pwep->key_material, param->u.crypt.key, pwep->key_length);
if (param->u.crypt.set_tx) {
psecuritypriv->dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
if (pwep->key_length == 13) {
psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
}
psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx;
memcpy(&psecuritypriv->dot11DefKey[wep_key_idx].skey[0], pwep->key_material, pwep->key_length);
psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->key_length;
rtw_ap_set_wep_key(padapter, pwep->key_material, pwep->key_length, wep_key_idx, 1);
} else {
/* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */
/* psecuritypriv->dot11PrivacyKeyIndex =keyid", but can rtw_set_key to cam */
memcpy(&psecuritypriv->dot11DefKey[wep_key_idx].skey[0], pwep->key_material, pwep->key_length);
psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->key_length;
rtw_ap_set_wep_key(padapter, pwep->key_material, pwep->key_length, wep_key_idx, 0);
}
goto exit;
}
if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) { /* group key */
if (param->u.crypt.set_tx == 1) {
if (strcmp(param->u.crypt.alg, "WEP") == 0) {
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
if (param->u.crypt.key_len == 13)
psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
/* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
/* set mic key */
memcpy(txkey, ¶m->u.crypt.key[16], 8);
memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, ¶m->u.crypt.key[24], 8);
psecuritypriv->busetkipkey = true;
} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
psecuritypriv->dot118021XGrpPrivacy = _AES_;
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
} else {
psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
}
psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
psecuritypriv->binstallGrpkey = true;
psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */
rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
if (pbcmc_sta) {
pbcmc_sta->ieee8021x_blocked = false;
pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
}
}
goto exit;
}
if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) { /* psk/802_1x */
if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
if (param->u.crypt.set_tx == 1) {
memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
if (strcmp(param->u.crypt.alg, "WEP") == 0) {
psta->dot118021XPrivacy = _WEP40_;
if (param->u.crypt.key_len == 13)
psta->dot118021XPrivacy = _WEP104_;
} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
psta->dot118021XPrivacy = _TKIP_;
/* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
/* set mic key */
memcpy(psta->dot11tkiptxmickey.skey, ¶m->u.crypt.key[16], 8);
memcpy(psta->dot11tkiprxmickey.skey, ¶m->u.crypt.key[24], 8);
psecuritypriv->busetkipkey = true;
} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
psta->dot118021XPrivacy = _AES_;
} else {
psta->dot118021XPrivacy = _NO_PRIVACY_;
}
rtw_ap_set_pairwise_key(padapter, psta);
psta->ieee8021x_blocked = false;
} else { /* group key??? */
if (strcmp(param->u.crypt.alg, "WEP") == 0) {
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
if (param->u.crypt.key_len == 13)
psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
} else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
/* DEBUG_ERR("set key length :param->u.crypt.key_len =%d\n", param->u.crypt.key_len); */
/* set mic key */
memcpy(txkey, ¶m->u.crypt.key[16], 8);
memcpy(rxkey, ¶m->u.crypt.key[24], 8);
psecuritypriv->busetkipkey = true;
} else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
psecuritypriv->dot118021XGrpPrivacy = _AES_;
memcpy(grpkey, param->u.crypt.key, (param->u.crypt.key_len > 16 ? 16 : param->u.crypt.key_len));
} else {
psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
}
psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
psecuritypriv->binstallGrpkey = true;
psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */
rtw_ap_set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
if (pbcmc_sta) {
pbcmc_sta->ieee8021x_blocked = false;
pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
}
}
}
}
exit:
kfree(pwep);
return ret;
}
static int rtw_set_beacon(struct net_device *dev, struct ieee_param *param, int len)
{
int ret = 0;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_priv *pstapriv = &padapter->stapriv;
unsigned char *pbuf = param->u.bcn_ie.buf;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
return -EINVAL;
memcpy(&pstapriv->max_num_sta, param->u.bcn_ie.reserved, 2);
if ((pstapriv->max_num_sta > NUM_STA) || (pstapriv->max_num_sta <= 0))
pstapriv->max_num_sta = NUM_STA;
if (rtw_check_beacon_data(padapter, pbuf, (len - 12 - 2)) == _SUCCESS)/* 12 = param header, 2:no packed */
ret = 0;
else
ret = -EINVAL;
return ret;
}
static void rtw_hostapd_sta_flush(struct net_device *dev)
{
/* _irqL irqL; */
/* struct list_head *phead, *plist; */
/* struct sta_info *psta = NULL; */
struct adapter *padapter = rtw_netdev_priv(dev);
/* struct sta_priv *pstapriv = &padapter->stapriv; */
flush_all_cam_entry(padapter); /* clear CAM */
rtw_sta_flush(padapter);
}
static int rtw_add_sta(struct net_device *dev, struct ieee_param *param)
{
int ret = 0;
struct sta_info *psta = NULL;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_priv *pstapriv = &padapter->stapriv;
if (check_fwstate(pmlmepriv, (_FW_LINKED | WIFI_AP_STATE)) != true)
return -EINVAL;
if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
return -EINVAL;
}
/*
psta = rtw_get_stainfo(pstapriv, param->sta_addr);
if (psta)
{
rtw_free_stainfo(padapter, psta);
psta = NULL;
}
*/
/* psta = rtw_alloc_stainfo(pstapriv, param->sta_addr); */
psta = rtw_get_stainfo(pstapriv, param->sta_addr);
if (psta) {
int flags = param->u.add_sta.flags;
psta->aid = param->u.add_sta.aid;/* aid = 1~2007 */
memcpy(psta->bssrateset, param->u.add_sta.tx_supp_rates, 16);
/* check wmm cap. */
if (WLAN_STA_WME & flags)
psta->qos_option = 1;
else
psta->qos_option = 0;
if (pmlmepriv->qospriv.qos_option == 0)
psta->qos_option = 0;
/* chec 802.11n ht cap. */
if (WLAN_STA_HT & flags) {
psta->htpriv.ht_option = true;
psta->qos_option = 1;
memcpy((void *)&psta->htpriv.ht_cap, (void *)¶m->u.add_sta.ht_cap, sizeof(struct ieee80211_ht_cap));
} else {
psta->htpriv.ht_option = false;
}
if (!pmlmepriv->htpriv.ht_option)
psta->htpriv.ht_option = false;
update_sta_info_apmode(padapter, psta);
} else {
ret = -ENOMEM;
}
return ret;
}
static int rtw_del_sta(struct net_device *dev, struct ieee_param *param)
{
int ret = 0;
struct sta_info *psta = NULL;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_priv *pstapriv = &padapter->stapriv;
if (check_fwstate(pmlmepriv, (_FW_LINKED | WIFI_AP_STATE)) != true)
return -EINVAL;
if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
return -EINVAL;
}
psta = rtw_get_stainfo(pstapriv, param->sta_addr);
if (psta) {
u8 updated = false;
spin_lock_bh(&pstapriv->asoc_list_lock);
if (list_empty(&psta->asoc_list) == false) {
list_del_init(&psta->asoc_list);
pstapriv->asoc_list_cnt--;
updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
}
spin_unlock_bh(&pstapriv->asoc_list_lock);
associated_clients_update(padapter, updated);
psta = NULL;
}
return ret;
}
static int rtw_ioctl_get_sta_data(struct net_device *dev, struct ieee_param *param, int len)
{
int ret = 0;
struct sta_info *psta = NULL;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_priv *pstapriv = &padapter->stapriv;
struct ieee_param_ex *param_ex = (struct ieee_param_ex *)param;
struct sta_data *psta_data = (struct sta_data *)param_ex->data;
if (check_fwstate(pmlmepriv, (_FW_LINKED | WIFI_AP_STATE)) != true)
return -EINVAL;
if (param_ex->sta_addr[0] == 0xff && param_ex->sta_addr[1] == 0xff &&
param_ex->sta_addr[2] == 0xff && param_ex->sta_addr[3] == 0xff &&
param_ex->sta_addr[4] == 0xff && param_ex->sta_addr[5] == 0xff) {
return -EINVAL;
}
psta = rtw_get_stainfo(pstapriv, param_ex->sta_addr);
if (psta) {
psta_data->aid = (u16)psta->aid;
psta_data->capability = psta->capability;
psta_data->flags = psta->flags;
/*
nonerp_set : BIT(0)
no_short_slot_time_set : BIT(1)
no_short_preamble_set : BIT(2)
no_ht_gf_set : BIT(3)
no_ht_set : BIT(4)
ht_20mhz_set : BIT(5)
*/
psta_data->sta_set = ((psta->nonerp_set) |
(psta->no_short_slot_time_set << 1) |
(psta->no_short_preamble_set << 2) |
(psta->no_ht_gf_set << 3) |
(psta->no_ht_set << 4) |
(psta->ht_20mhz_set << 5));
psta_data->tx_supp_rates_len = psta->bssratelen;
memcpy(psta_data->tx_supp_rates, psta->bssrateset, psta->bssratelen);
memcpy(&psta_data->ht_cap, &psta->htpriv.ht_cap, sizeof(struct ieee80211_ht_cap));
psta_data->rx_pkts = psta->sta_stats.rx_data_pkts;
psta_data->rx_bytes = psta->sta_stats.rx_bytes;
psta_data->rx_drops = psta->sta_stats.rx_drops;
psta_data->tx_pkts = psta->sta_stats.tx_pkts;
psta_data->tx_bytes = psta->sta_stats.tx_bytes;
psta_data->tx_drops = psta->sta_stats.tx_drops;
} else {
ret = -1;
}
return ret;
}
static int rtw_get_sta_wpaie(struct net_device *dev, struct ieee_param *param)
{
int ret = 0;
struct sta_info *psta = NULL;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct sta_priv *pstapriv = &padapter->stapriv;
if (check_fwstate(pmlmepriv, (_FW_LINKED | WIFI_AP_STATE)) != true)
return -EINVAL;
if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
return -EINVAL;
}
psta = rtw_get_stainfo(pstapriv, param->sta_addr);
if (psta) {
if ((psta->wpa_ie[0] == WLAN_EID_RSN) || (psta->wpa_ie[0] == WLAN_EID_VENDOR_SPECIFIC)) {
int wpa_ie_len;
int copy_len;
wpa_ie_len = psta->wpa_ie[1];
copy_len = ((wpa_ie_len + 2) > sizeof(psta->wpa_ie)) ? (sizeof(psta->wpa_ie)) : (wpa_ie_len + 2);
param->u.wpa_ie.len = copy_len;
memcpy(param->u.wpa_ie.reserved, psta->wpa_ie, copy_len);
}
} else {
ret = -1;
}
return ret;
}
static int rtw_set_wps_beacon(struct net_device *dev, struct ieee_param *param, int len)
{
int ret = 0;
unsigned char wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
int ie_len;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
return -EINVAL;
ie_len = len - 12 - 2;/* 12 = param header, 2:no packed */
kfree(pmlmepriv->wps_beacon_ie);
pmlmepriv->wps_beacon_ie = NULL;
if (ie_len > 0) {
pmlmepriv->wps_beacon_ie = rtw_malloc(ie_len);
pmlmepriv->wps_beacon_ie_len = ie_len;
if (!pmlmepriv->wps_beacon_ie)
return -EINVAL;
memcpy(pmlmepriv->wps_beacon_ie, param->u.bcn_ie.buf, ie_len);
update_beacon(padapter, WLAN_EID_VENDOR_SPECIFIC, wps_oui, true);
pmlmeext->bstart_bss = true;
}
return ret;
}
static int rtw_set_wps_probe_resp(struct net_device *dev, struct ieee_param *param, int len)
{
int ret = 0;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
int ie_len;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
return -EINVAL;
ie_len = len - 12 - 2;/* 12 = param header, 2:no packed */
kfree(pmlmepriv->wps_probe_resp_ie);
pmlmepriv->wps_probe_resp_ie = NULL;
if (ie_len > 0) {
pmlmepriv->wps_probe_resp_ie = rtw_malloc(ie_len);
pmlmepriv->wps_probe_resp_ie_len = ie_len;
if (!pmlmepriv->wps_probe_resp_ie)
return -EINVAL;
memcpy(pmlmepriv->wps_probe_resp_ie, param->u.bcn_ie.buf, ie_len);
}
return ret;
}
static int rtw_set_wps_assoc_resp(struct net_device *dev, struct ieee_param *param, int len)
{
int ret = 0;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
int ie_len;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
return -EINVAL;
ie_len = len - 12 - 2;/* 12 = param header, 2:no packed */
kfree(pmlmepriv->wps_assoc_resp_ie);
pmlmepriv->wps_assoc_resp_ie = NULL;
if (ie_len > 0) {
pmlmepriv->wps_assoc_resp_ie = rtw_malloc(ie_len);
pmlmepriv->wps_assoc_resp_ie_len = ie_len;
if (!pmlmepriv->wps_assoc_resp_ie)
return -EINVAL;
memcpy(pmlmepriv->wps_assoc_resp_ie, param->u.bcn_ie.buf, ie_len);
}
return ret;
}
static int rtw_set_hidden_ssid(struct net_device *dev, struct ieee_param *param, int len)
{
int ret = 0;
struct adapter *adapter = rtw_netdev_priv(dev);
struct mlme_priv *mlmepriv = &adapter->mlmepriv;
struct mlme_ext_priv *mlmeext = &adapter->mlmeextpriv;
struct mlme_ext_info *mlmeinfo = &mlmeext->mlmext_info;
int ie_len;
u8 *ssid_ie;
char ssid[NDIS_802_11_LENGTH_SSID + 1];
signed int ssid_len;
u8 ignore_broadcast_ssid;
if (check_fwstate(mlmepriv, WIFI_AP_STATE) != true)
return -EPERM;
if (param->u.bcn_ie.reserved[0] != 0xea)
return -EINVAL;
mlmeinfo->hidden_ssid_mode = ignore_broadcast_ssid = param->u.bcn_ie.reserved[1];
ie_len = len - 12 - 2;/* 12 = param header, 2:no packed */
ssid_ie = rtw_get_ie(param->u.bcn_ie.buf, WLAN_EID_SSID, &ssid_len, ie_len);
if (ssid_ie && ssid_len > 0 && ssid_len <= NDIS_802_11_LENGTH_SSID) {
struct wlan_bssid_ex *pbss_network = &mlmepriv->cur_network.network;
struct wlan_bssid_ex *pbss_network_ext = &mlmeinfo->network;
memcpy(ssid, ssid_ie + 2, ssid_len);
ssid[ssid_len] = 0x0;
memcpy(pbss_network->ssid.ssid, (void *)ssid, ssid_len);
pbss_network->ssid.ssid_length = ssid_len;
memcpy(pbss_network_ext->ssid.ssid, (void *)ssid, ssid_len);
pbss_network_ext->ssid.ssid_length = ssid_len;
}
return ret;
}
static int rtw_ioctl_acl_remove_sta(struct net_device *dev, struct ieee_param *param, int len)
{
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
return -EINVAL;
if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
return -EINVAL;
}
rtw_acl_remove_sta(padapter, param->sta_addr);
return 0;
}
static int rtw_ioctl_acl_add_sta(struct net_device *dev, struct ieee_param *param, int len)
{
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
return -EINVAL;
if (param->sta_addr[0] == 0xff && param->sta_addr[1] == 0xff &&
param->sta_addr[2] == 0xff && param->sta_addr[3] == 0xff &&
param->sta_addr[4] == 0xff && param->sta_addr[5] == 0xff) {
return -EINVAL;
}
return rtw_acl_add_sta(padapter, param->sta_addr);
}
static int rtw_ioctl_set_macaddr_acl(struct net_device *dev, struct ieee_param *param, int len)
{
int ret = 0;
struct adapter *padapter = rtw_netdev_priv(dev);
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
if (check_fwstate(pmlmepriv, WIFI_AP_STATE) != true)
return -EINVAL;
rtw_set_macaddr_acl(padapter, param->u.mlme.command);
return ret;
}
static int rtw_hostapd_ioctl(struct net_device *dev, struct iw_point *p)
{
struct ieee_param *param;
int ret = 0;
struct adapter *padapter = rtw_netdev_priv(dev);
/*
* this function is expect to call in master mode, which allows no power saving
* so, we just check hw_init_completed
*/
if (!padapter->hw_init_completed)
return -EPERM;
if (!p->pointer || p->length != sizeof(*param))
return -EINVAL;
param = rtw_malloc(p->length);
if (!param)
return -ENOMEM;
if (copy_from_user(param, p->pointer, p->length)) {
kfree(param);
return -EFAULT;
}
switch (param->cmd) {
case RTL871X_HOSTAPD_FLUSH:
rtw_hostapd_sta_flush(dev);
break;
case RTL871X_HOSTAPD_ADD_STA:
ret = rtw_add_sta(dev, param);
break;
case RTL871X_HOSTAPD_REMOVE_STA:
ret = rtw_del_sta(dev, param);
break;
case RTL871X_HOSTAPD_SET_BEACON:
ret = rtw_set_beacon(dev, param, p->length);
break;
case RTL871X_SET_ENCRYPTION:
ret = rtw_set_encryption(dev, param, p->length);
break;
case RTL871X_HOSTAPD_GET_WPAIE_STA:
ret = rtw_get_sta_wpaie(dev, param);
break;
case RTL871X_HOSTAPD_SET_WPS_BEACON:
ret = rtw_set_wps_beacon(dev, param, p->length);
break;
case RTL871X_HOSTAPD_SET_WPS_PROBE_RESP:
ret = rtw_set_wps_probe_resp(dev, param, p->length);
break;
case RTL871X_HOSTAPD_SET_WPS_ASSOC_RESP:
ret = rtw_set_wps_assoc_resp(dev, param, p->length);
break;
case RTL871X_HOSTAPD_SET_HIDDEN_SSID:
ret = rtw_set_hidden_ssid(dev, param, p->length);
break;
case RTL871X_HOSTAPD_GET_INFO_STA:
ret = rtw_ioctl_get_sta_data(dev, param, p->length);
break;
case RTL871X_HOSTAPD_SET_MACADDR_ACL:
ret = rtw_ioctl_set_macaddr_acl(dev, param, p->length);
break;
case RTL871X_HOSTAPD_ACL_ADD_STA:
ret = rtw_ioctl_acl_add_sta(dev, param, p->length);
break;
case RTL871X_HOSTAPD_ACL_REMOVE_STA:
ret = rtw_ioctl_acl_remove_sta(dev, param, p->length);
break;
default:
ret = -EOPNOTSUPP;
break;
}
if (ret == 0 && copy_to_user(p->pointer, param, p->length))
ret = -EFAULT;
kfree(param);
return ret;
}
/* copy from net/wireless/wext.c end */
int rtw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
struct iwreq *wrq = (struct iwreq *)rq;
int ret = 0;
switch (cmd) {
case RTL_IOCTL_WPA_SUPPLICANT:
ret = wpa_supplicant_ioctl(dev, &wrq->u.data);
break;
case RTL_IOCTL_HOSTAPD:
ret = rtw_hostapd_ioctl(dev, &wrq->u.data);
break;
default:
ret = -EOPNOTSUPP;
break;
}
return ret;
}
| linux-master | drivers/staging/rtl8723bs/os_dep/ioctl_linux.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2009-2010 Realtek Corporation.
*
*****************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
#include <rtw_wifi_regd.h>
/*
* REG_RULE(freq start, freq end, bandwidth, max gain, eirp, reg_flags)
*/
/*
* Only these channels all allow active
* scan on all world regulatory domains
*/
/* 2G chan 01 - chan 11 */
#define RTW_2GHZ_CH01_11 \
REG_RULE(2412 - 10, 2462 + 10, 40, 0, 20, 0)
/*
* We enable active scan on these a case
* by case basis by regulatory domain
*/
/* 2G chan 12 - chan 13, PASSIV SCAN */
#define RTW_2GHZ_CH12_13 \
REG_RULE(2467 - 10, 2472 + 10, 40, 0, 20, \
NL80211_RRF_PASSIVE_SCAN)
static const struct ieee80211_regdomain rtw_regdom_rd = {
.n_reg_rules = 2,
.alpha2 = "99",
.reg_rules = {
RTW_2GHZ_CH01_11,
RTW_2GHZ_CH12_13,
}
};
static int rtw_ieee80211_channel_to_frequency(int chan, int band)
{
/* NL80211_BAND_2GHZ */
if (chan == 14)
return 2484;
else if (chan < 14)
return 2407 + chan * 5;
else
return 0; /* not supported */
}
static void _rtw_reg_apply_flags(struct wiphy *wiphy)
{
struct adapter *padapter = wiphy_to_adapter(wiphy);
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct rt_channel_info *channel_set = pmlmeext->channel_set;
u8 max_chan_nums = pmlmeext->max_chan_nums;
struct ieee80211_supported_band *sband;
struct ieee80211_channel *ch;
unsigned int i, j;
u16 channel;
u32 freq;
/* all channels disable */
for (i = 0; i < NUM_NL80211_BANDS; i++) {
sband = wiphy->bands[i];
if (sband) {
for (j = 0; j < sband->n_channels; j++) {
ch = &sband->channels[j];
if (ch)
ch->flags = IEEE80211_CHAN_DISABLED;
}
}
}
/* channels apply by channel plans. */
for (i = 0; i < max_chan_nums; i++) {
channel = channel_set[i].ChannelNum;
freq =
rtw_ieee80211_channel_to_frequency(channel,
NL80211_BAND_2GHZ);
ch = ieee80211_get_channel(wiphy, freq);
if (ch) {
if (channel_set[i].ScanType == SCAN_PASSIVE)
ch->flags = IEEE80211_CHAN_NO_IR;
else
ch->flags = 0;
}
}
}
static int _rtw_reg_notifier_apply(struct wiphy *wiphy,
struct regulatory_request *request,
struct rtw_regulatory *reg)
{
/* Hard code flags */
_rtw_reg_apply_flags(wiphy);
return 0;
}
static const struct ieee80211_regdomain *_rtw_regdomain_select(struct
rtw_regulatory
*reg)
{
return &rtw_regdom_rd;
}
static void _rtw_regd_init_wiphy(struct rtw_regulatory *reg,
struct wiphy *wiphy,
void (*reg_notifier)(struct wiphy *wiphy,
struct
regulatory_request *
request))
{
const struct ieee80211_regdomain *regd;
wiphy->reg_notifier = reg_notifier;
wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG;
wiphy->regulatory_flags &= ~REGULATORY_STRICT_REG;
wiphy->regulatory_flags &= ~REGULATORY_DISABLE_BEACON_HINTS;
regd = _rtw_regdomain_select(reg);
wiphy_apply_custom_regulatory(wiphy, regd);
/* Hard code flags */
_rtw_reg_apply_flags(wiphy);
}
void rtw_regd_init(struct wiphy *wiphy,
void (*reg_notifier)(struct wiphy *wiphy,
struct regulatory_request *request))
{
_rtw_regd_init_wiphy(NULL, wiphy, reg_notifier);
}
void rtw_reg_notifier(struct wiphy *wiphy, struct regulatory_request *request)
{
struct rtw_regulatory *reg = NULL;
_rtw_reg_notifier_apply(wiphy, request, reg);
}
| linux-master | drivers/staging/rtl8723bs/os_dep/wifi_regd.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
*
*******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
static bool rtw_sdio_claim_host_needed(struct sdio_func *func)
{
struct dvobj_priv *dvobj = sdio_get_drvdata(func);
struct sdio_data *sdio_data = &dvobj->intf_data;
if (sdio_data->sys_sdio_irq_thd && sdio_data->sys_sdio_irq_thd == current)
return false;
return true;
}
inline void rtw_sdio_set_irq_thd(struct dvobj_priv *dvobj, void *thd_hdl)
{
struct sdio_data *sdio_data = &dvobj->intf_data;
sdio_data->sys_sdio_irq_thd = thd_hdl;
}
/*
* Return:
*0 Success
*others Fail
*/
s32 _sd_cmd52_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
int err = 0, i;
struct sdio_func *func;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return err;
func = psdio->func;
for (i = 0; i < cnt; i++) {
pdata[i] = sdio_readb(func, addr + i, &err);
if (err)
break;
}
return err;
}
/*
* Return:
*0 Success
*others Fail
*/
s32 sd_cmd52_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
int err = 0;
struct sdio_func *func;
bool claim_needed;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return err;
func = psdio->func;
claim_needed = rtw_sdio_claim_host_needed(func);
if (claim_needed)
sdio_claim_host(func);
err = _sd_cmd52_read(pintfhdl, addr, cnt, pdata);
if (claim_needed)
sdio_release_host(func);
return err;
}
/*
* Return:
*0 Success
*others Fail
*/
s32 _sd_cmd52_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
int err = 0, i;
struct sdio_func *func;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return err;
func = psdio->func;
for (i = 0; i < cnt; i++) {
sdio_writeb(func, pdata[i], addr + i, &err);
if (err)
break;
}
return err;
}
/*
* Return:
*0 Success
*others Fail
*/
s32 sd_cmd52_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8 *pdata)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
int err = 0;
struct sdio_func *func;
bool claim_needed;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return err;
func = psdio->func;
claim_needed = rtw_sdio_claim_host_needed(func);
if (claim_needed)
sdio_claim_host(func);
err = _sd_cmd52_write(pintfhdl, addr, cnt, pdata);
if (claim_needed)
sdio_release_host(func);
return err;
}
u8 sd_read8(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
u8 v = 0;
struct sdio_func *func;
bool claim_needed;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return v;
func = psdio->func;
claim_needed = rtw_sdio_claim_host_needed(func);
if (claim_needed)
sdio_claim_host(func);
v = sdio_readb(func, addr, err);
if (claim_needed)
sdio_release_host(func);
return v;
}
u32 sd_read32(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
u32 v = 0;
struct sdio_func *func;
bool claim_needed;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return v;
func = psdio->func;
claim_needed = rtw_sdio_claim_host_needed(func);
if (claim_needed)
sdio_claim_host(func);
v = sdio_readl(func, addr, err);
if (claim_needed)
sdio_release_host(func);
if (err && *err) {
int i;
*err = 0;
for (i = 0; i < SD_IO_TRY_CNT; i++) {
if (claim_needed)
sdio_claim_host(func);
v = sdio_readl(func, addr, err);
if (claim_needed)
sdio_release_host(func);
if (*err == 0) {
rtw_reset_continual_io_error(psdiodev);
break;
} else {
if ((-ESHUTDOWN == *err) || (-ENODEV == *err))
padapter->bSurpriseRemoved = true;
if (rtw_inc_and_chk_continual_io_error(psdiodev) == true) {
padapter->bSurpriseRemoved = true;
break;
}
}
}
}
return v;
}
void sd_write8(struct intf_hdl *pintfhdl, u32 addr, u8 v, s32 *err)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
struct sdio_func *func;
bool claim_needed;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return;
func = psdio->func;
claim_needed = rtw_sdio_claim_host_needed(func);
if (claim_needed)
sdio_claim_host(func);
sdio_writeb(func, v, addr, err);
if (claim_needed)
sdio_release_host(func);
}
void sd_write32(struct intf_hdl *pintfhdl, u32 addr, u32 v, s32 *err)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
struct sdio_func *func;
bool claim_needed;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return;
func = psdio->func;
claim_needed = rtw_sdio_claim_host_needed(func);
if (claim_needed)
sdio_claim_host(func);
sdio_writel(func, v, addr, err);
if (claim_needed)
sdio_release_host(func);
if (err && *err) {
int i;
*err = 0;
for (i = 0; i < SD_IO_TRY_CNT; i++) {
if (claim_needed)
sdio_claim_host(func);
sdio_writel(func, v, addr, err);
if (claim_needed)
sdio_release_host(func);
if (*err == 0) {
rtw_reset_continual_io_error(psdiodev);
break;
} else {
if ((-ESHUTDOWN == *err) || (-ENODEV == *err))
padapter->bSurpriseRemoved = true;
if (rtw_inc_and_chk_continual_io_error(psdiodev) == true) {
padapter->bSurpriseRemoved = true;
break;
}
}
}
}
}
/*
* Use CMD53 to read data from SDIO device.
* This function MUST be called after sdio_claim_host() or
* in SDIO ISR(host had been claimed).
*
* Parameters:
*psdio pointer of SDIO_DATA
*addr address to read
*cnt amount to read
*pdata pointer to put data, this should be a "DMA:able scratch buffer"!
*
* Return:
*0 Success
*others Fail
*/
s32 _sd_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
int err = -EPERM;
struct sdio_func *func;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return err;
func = psdio->func;
if (unlikely((cnt == 1) || (cnt == 2))) {
int i;
u8 *pbuf = pdata;
for (i = 0; i < cnt; i++) {
*(pbuf + i) = sdio_readb(func, addr + i, &err);
if (err)
break;
}
return err;
}
err = sdio_memcpy_fromio(func, pdata, addr, cnt);
return err;
}
/*
* Use CMD53 to read data from SDIO device.
*
* Parameters:
*psdio pointer of SDIO_DATA
*addr address to read
*cnt amount to read
*pdata pointer to put data, this should be a "DMA:able scratch buffer"!
*
* Return:
*0 Success
*others Fail
*/
s32 sd_read(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
struct sdio_func *func;
bool claim_needed;
s32 err = -EPERM;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return err;
func = psdio->func;
claim_needed = rtw_sdio_claim_host_needed(func);
if (claim_needed)
sdio_claim_host(func);
err = _sd_read(pintfhdl, addr, cnt, pdata);
if (claim_needed)
sdio_release_host(func);
return err;
}
/*
* Use CMD53 to write data to SDIO device.
* This function MUST be called after sdio_claim_host() or
* in SDIO ISR(host had been claimed).
*
* Parameters:
*psdio pointer of SDIO_DATA
*addr address to write
*cnt amount to write
*pdata data pointer, this should be a "DMA:able scratch buffer"!
*
* Return:
*0 Success
*others Fail
*/
s32 _sd_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
struct sdio_func *func;
u32 size;
s32 err = -EPERM;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return err;
func = psdio->func;
/* size = sdio_align_size(func, cnt); */
if (unlikely((cnt == 1) || (cnt == 2))) {
int i;
u8 *pbuf = pdata;
for (i = 0; i < cnt; i++) {
sdio_writeb(func, *(pbuf + i), addr + i, &err);
if (err)
break;
}
return err;
}
size = cnt;
err = sdio_memcpy_toio(func, addr, pdata, size);
return err;
}
/*
* Use CMD53 to write data to SDIO device.
*
* Parameters:
* psdio pointer of SDIO_DATA
* addr address to write
* cnt amount to write
* pdata data pointer, this should be a "DMA:able scratch buffer"!
*
* Return:
* 0 Success
* others Fail
*/
s32 sd_write(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, void *pdata)
{
struct adapter *padapter;
struct dvobj_priv *psdiodev;
struct sdio_data *psdio;
struct sdio_func *func;
bool claim_needed;
s32 err = -EPERM;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved)
return err;
func = psdio->func;
claim_needed = rtw_sdio_claim_host_needed(func);
if (claim_needed)
sdio_claim_host(func);
err = _sd_write(pintfhdl, addr, cnt, pdata);
if (claim_needed)
sdio_release_host(func);
return err;
}
| linux-master | drivers/staging/rtl8723bs/os_dep/sdio_ops_linux.c |
// SPDX-License-Identifier: GPL-2.0
/******************************************************************************
*
* Copyright(c) 2007 - 2011 Realtek Corporation. All rights reserved.
*
******************************************************************************/
#include <drv_types.h>
#include <rtw_debug.h>
static void _dynamic_check_timer_handler(struct timer_list *t)
{
struct adapter *adapter =
from_timer(adapter, t, mlmepriv.dynamic_chk_timer);
rtw_dynamic_check_timer_handler(adapter);
_set_timer(&adapter->mlmepriv.dynamic_chk_timer, 2000);
}
static void _rtw_set_scan_deny_timer_hdl(struct timer_list *t)
{
struct adapter *adapter =
from_timer(adapter, t, mlmepriv.set_scan_deny_timer);
rtw_clear_scan_deny(adapter);
}
void rtw_init_mlme_timer(struct adapter *padapter)
{
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
timer_setup(&pmlmepriv->assoc_timer, _rtw_join_timeout_handler, 0);
timer_setup(&pmlmepriv->scan_to_timer, rtw_scan_timeout_handler, 0);
timer_setup(&pmlmepriv->dynamic_chk_timer,
_dynamic_check_timer_handler, 0);
timer_setup(&pmlmepriv->set_scan_deny_timer,
_rtw_set_scan_deny_timer_hdl, 0);
}
void rtw_os_indicate_connect(struct adapter *adapter)
{
struct mlme_priv *pmlmepriv = &(adapter->mlmepriv);
if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) == true) ||
(check_fwstate(pmlmepriv, WIFI_ADHOC_STATE) == true)) {
rtw_cfg80211_ibss_indicate_connect(adapter);
} else {
rtw_cfg80211_indicate_connect(adapter);
}
netif_carrier_on(adapter->pnetdev);
if (adapter->pid[2] != 0)
rtw_signal_process(adapter->pid[2], SIGALRM);
}
void rtw_os_indicate_scan_done(struct adapter *padapter, bool aborted)
{
rtw_cfg80211_indicate_scan_done(padapter, aborted);
}
static struct rt_pmkid_list backupPMKIDList[NUM_PMKID_CACHE];
void rtw_reset_securitypriv(struct adapter *adapter)
{
u8 backupPMKIDIndex = 0;
u8 backupTKIPCountermeasure = 0x00;
u32 backupTKIPcountermeasure_time = 0;
/* add for CONFIG_IEEE80211W, none 11w also can use */
struct mlme_ext_priv *pmlmeext = &adapter->mlmeextpriv;
spin_lock_bh(&adapter->security_key_mutex);
if (adapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) {
/* 802.1x */
/* Added by Albert 2009/02/18 */
/* We have to backup the PMK information for WiFi PMK Caching test item. */
/* */
/* Backup the btkip_countermeasure information. */
/* When the countermeasure is trigger, the driver have to disconnect with AP for 60 seconds. */
memcpy(&backupPMKIDList[0], &adapter->securitypriv.PMKIDList[0], sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);
backupPMKIDIndex = adapter->securitypriv.PMKIDIndex;
backupTKIPCountermeasure = adapter->securitypriv.btkip_countermeasure;
backupTKIPcountermeasure_time = adapter->securitypriv.btkip_countermeasure_time;
/* reset RX BIP packet number */
pmlmeext->mgnt_80211w_IPN_rx = 0;
memset((unsigned char *)&adapter->securitypriv, 0, sizeof(struct security_priv));
/* Added by Albert 2009/02/18 */
/* Restore the PMK information to securitypriv structure for the following connection. */
memcpy(&adapter->securitypriv.PMKIDList[0], &backupPMKIDList[0], sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);
adapter->securitypriv.PMKIDIndex = backupPMKIDIndex;
adapter->securitypriv.btkip_countermeasure = backupTKIPCountermeasure;
adapter->securitypriv.btkip_countermeasure_time = backupTKIPcountermeasure_time;
adapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
adapter->securitypriv.ndisencryptstatus = Ndis802_11WEPDisabled;
} else {
/* reset values in securitypriv */
/* if (adapter->mlmepriv.fw_state & WIFI_STATION_STATE) */
/* */
struct security_priv *psec_priv = &adapter->securitypriv;
psec_priv->dot11AuthAlgrthm = dot11AuthAlgrthm_Open; /* open system */
psec_priv->dot11PrivacyAlgrthm = _NO_PRIVACY_;
psec_priv->dot11PrivacyKeyIndex = 0;
psec_priv->dot118021XGrpPrivacy = _NO_PRIVACY_;
psec_priv->dot118021XGrpKeyid = 1;
psec_priv->ndisauthtype = Ndis802_11AuthModeOpen;
psec_priv->ndisencryptstatus = Ndis802_11WEPDisabled;
/* */
}
/* add for CONFIG_IEEE80211W, none 11w also can use */
spin_unlock_bh(&adapter->security_key_mutex);
}
void rtw_os_indicate_disconnect(struct adapter *adapter)
{
/* struct rt_pmkid_list backupPMKIDList[ NUM_PMKID_CACHE ]; */
netif_carrier_off(adapter->pnetdev); /* Do it first for tx broadcast pkt after disconnection issue! */
rtw_cfg80211_indicate_disconnect(adapter);
/* modify for CONFIG_IEEE80211W, none 11w also can use the same command */
rtw_reset_securitypriv_cmd(adapter);
}
void rtw_report_sec_ie(struct adapter *adapter, u8 authmode, u8 *sec_ie)
{
uint len;
u8 *buff, *p, i;
union iwreq_data wrqu;
buff = NULL;
if (authmode == WLAN_EID_VENDOR_SPECIFIC) {
buff = rtw_zmalloc(IW_CUSTOM_MAX);
if (!buff)
return;
p = buff;
p += scnprintf(p, IW_CUSTOM_MAX - (p - buff), "ASSOCINFO(ReqIEs =");
len = sec_ie[1] + 2;
len = (len < IW_CUSTOM_MAX) ? len : IW_CUSTOM_MAX;
for (i = 0; i < len; i++)
p += scnprintf(p, IW_CUSTOM_MAX - (p - buff), "%02x", sec_ie[i]);
p += scnprintf(p, IW_CUSTOM_MAX - (p - buff), ")");
memset(&wrqu, 0, sizeof(wrqu));
wrqu.data.length = p - buff;
wrqu.data.length = (wrqu.data.length < IW_CUSTOM_MAX) ? wrqu.data.length : IW_CUSTOM_MAX;
kfree(buff);
}
}
void init_addba_retry_timer(struct adapter *padapter, struct sta_info *psta)
{
timer_setup(&psta->addba_retry_timer, addba_timer_hdl, 0);
}
void init_mlme_ext_timer(struct adapter *padapter)
{
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
timer_setup(&pmlmeext->survey_timer, survey_timer_hdl, 0);
timer_setup(&pmlmeext->link_timer, link_timer_hdl, 0);
timer_setup(&pmlmeext->sa_query_timer, sa_query_timer_hdl, 0);
}
| linux-master | drivers/staging/rtl8723bs/os_dep/mlme_linux.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: handle WMAC/802.3/802.11 rx & tx functions
*
* Author: Lyndon Chen
*
* Date: May 20, 2003
*
* Functions:
* vnt_generate_tx_parameter - Generate tx dma required parameter.
* vnt_get_rsvtime- get frame reserved time
* vnt_fill_cts_head- fulfill CTS ctl header
*
* Revision History:
*
*/
#include <linux/etherdevice.h>
#include "device.h"
#include "rxtx.h"
#include "card.h"
#include "mac.h"
#include "rf.h"
#include "usbpipe.h"
static const u16 vnt_time_stampoff[2][MAX_RATE] = {
/* Long Preamble */
{384, 288, 226, 209, 54, 43, 37, 31, 28, 25, 24, 23},
/* Short Preamble */
{384, 192, 130, 113, 54, 43, 37, 31, 28, 25, 24, 23},
};
#define DATADUR_B 10
#define DATADUR_A 11
static const u8 vnt_phy_signal[] = {
0x00, /* RATE_1M */
0x01, /* RATE_2M */
0x02, /* RATE_5M */
0x03, /* RATE_11M */
0x8b, /* RATE_6M */
0x8f, /* RATE_9M */
0x8a, /* RATE_12M */
0x8e, /* RATE_18M */
0x89, /* RATE_24M */
0x8d, /* RATE_36M */
0x88, /* RATE_48M */
0x8c /* RATE_54M */
};
static struct vnt_usb_send_context
*vnt_get_free_context(struct vnt_private *priv)
{
struct vnt_usb_send_context *context = NULL;
int ii;
for (ii = 0; ii < priv->num_tx_context; ii++) {
if (!priv->tx_context[ii])
return NULL;
context = priv->tx_context[ii];
if (!context->in_use) {
context->in_use = true;
return context;
}
}
if (ii == priv->num_tx_context) {
dev_dbg(&priv->usb->dev, "%s No Free Tx Context\n", __func__);
ieee80211_stop_queues(priv->hw);
}
return NULL;
}
/* Get Length, Service, and Signal fields of Phy for Tx */
static void vnt_get_phy_field(struct vnt_private *priv, u32 frame_length,
u16 tx_rate, u8 pkt_type,
struct vnt_phy_field *phy)
{
u32 bit_count;
u32 count = 0;
u32 tmp;
int ext_bit;
int i;
u8 mask = 0;
u8 preamble_type = priv->preamble_type;
bit_count = frame_length * 8;
ext_bit = false;
switch (tx_rate) {
case RATE_1M:
count = bit_count;
break;
case RATE_2M:
count = bit_count / 2;
break;
case RATE_5M:
count = DIV_ROUND_UP(bit_count * 10, 55);
break;
case RATE_11M:
count = bit_count / 11;
tmp = count * 11;
if (tmp != bit_count) {
count++;
if ((bit_count - tmp) <= 3)
ext_bit = true;
}
break;
}
if (tx_rate > RATE_11M) {
if (pkt_type == PK_TYPE_11A)
mask = BIT(4);
} else if (tx_rate > RATE_1M) {
if (preamble_type == PREAMBLE_SHORT)
mask = BIT(3);
}
i = tx_rate > RATE_54M ? RATE_54M : tx_rate;
phy->signal = vnt_phy_signal[i] | mask;
phy->service = 0x00;
if (pkt_type == PK_TYPE_11B) {
if (ext_bit)
phy->service |= 0x80;
phy->len = cpu_to_le16((u16)count);
} else {
phy->len = cpu_to_le16((u16)frame_length);
}
}
static __le16 vnt_time_stamp_off(struct vnt_private *priv, u16 rate)
{
return cpu_to_le16(vnt_time_stampoff[priv->preamble_type % 2]
[rate % MAX_RATE]);
}
static __le16 vnt_rxtx_rsvtime_le16(struct vnt_usb_send_context *context)
{
struct vnt_private *priv = context->priv;
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(context->skb);
struct ieee80211_rate *rate = ieee80211_get_tx_rate(priv->hw, info);
return ieee80211_generic_frame_duration(priv->hw,
info->control.vif, info->band,
context->frame_len,
rate);
}
static __le16 vnt_get_rts_duration(struct vnt_usb_send_context *context)
{
struct vnt_private *priv = context->priv;
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(context->skb);
return ieee80211_rts_duration(priv->hw, priv->vif,
context->frame_len, info);
}
static __le16 vnt_get_cts_duration(struct vnt_usb_send_context *context)
{
struct vnt_private *priv = context->priv;
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(context->skb);
return ieee80211_ctstoself_duration(priv->hw, priv->vif,
context->frame_len, info);
}
static void vnt_rxtx_datahead_g(struct vnt_usb_send_context *tx_context,
struct vnt_tx_datahead_g *buf)
{
struct vnt_private *priv = tx_context->priv;
struct ieee80211_hdr *hdr =
(struct ieee80211_hdr *)tx_context->skb->data;
u32 frame_len = tx_context->frame_len;
u16 rate = tx_context->tx_rate;
/* Get SignalField,ServiceField,Length */
vnt_get_phy_field(priv, frame_len, rate, tx_context->pkt_type, &buf->a);
vnt_get_phy_field(priv, frame_len, priv->top_cck_basic_rate,
PK_TYPE_11B, &buf->b);
/* Get Duration and TimeStamp */
buf->duration_a = hdr->duration_id;
buf->duration_b = hdr->duration_id;
buf->time_stamp_off_a = vnt_time_stamp_off(priv, rate);
buf->time_stamp_off_b = vnt_time_stamp_off(priv,
priv->top_cck_basic_rate);
}
static void vnt_rxtx_datahead_ab(struct vnt_usb_send_context *tx_context,
struct vnt_tx_datahead_ab *buf)
{
struct vnt_private *priv = tx_context->priv;
struct ieee80211_hdr *hdr =
(struct ieee80211_hdr *)tx_context->skb->data;
u32 frame_len = tx_context->frame_len;
u16 rate = tx_context->tx_rate;
/* Get SignalField,ServiceField,Length */
vnt_get_phy_field(priv, frame_len, rate,
tx_context->pkt_type, &buf->ab);
/* Get Duration and TimeStampOff */
buf->duration = hdr->duration_id;
buf->time_stamp_off = vnt_time_stamp_off(priv, rate);
}
static void vnt_fill_ieee80211_rts(struct vnt_usb_send_context *tx_context,
struct ieee80211_rts *rts, __le16 duration)
{
struct ieee80211_hdr *hdr =
(struct ieee80211_hdr *)tx_context->skb->data;
rts->duration = duration;
rts->frame_control =
cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_RTS);
ether_addr_copy(rts->ra, hdr->addr1);
ether_addr_copy(rts->ta, hdr->addr2);
}
static void vnt_rxtx_rts_g_head(struct vnt_usb_send_context *tx_context,
struct vnt_rts_g *buf)
{
struct vnt_private *priv = tx_context->priv;
u16 rts_frame_len = 20;
vnt_get_phy_field(priv, rts_frame_len, priv->top_cck_basic_rate,
PK_TYPE_11B, &buf->b);
vnt_get_phy_field(priv, rts_frame_len, priv->top_ofdm_basic_rate,
tx_context->pkt_type, &buf->a);
buf->duration_bb = vnt_get_rts_duration(tx_context);
buf->duration_aa = buf->duration_bb;
buf->duration_ba = buf->duration_bb;
vnt_fill_ieee80211_rts(tx_context, &buf->data, buf->duration_aa);
vnt_rxtx_datahead_g(tx_context, &buf->data_head);
}
static void vnt_rxtx_rts_ab_head(struct vnt_usb_send_context *tx_context,
struct vnt_rts_ab *buf)
{
struct vnt_private *priv = tx_context->priv;
u16 rts_frame_len = 20;
vnt_get_phy_field(priv, rts_frame_len, priv->top_ofdm_basic_rate,
tx_context->pkt_type, &buf->ab);
buf->duration = vnt_get_rts_duration(tx_context);
vnt_fill_ieee80211_rts(tx_context, &buf->data, buf->duration);
vnt_rxtx_datahead_ab(tx_context, &buf->data_head);
}
static void vnt_fill_cts_head(struct vnt_usb_send_context *tx_context,
union vnt_tx_data_head *head)
{
struct vnt_private *priv = tx_context->priv;
struct vnt_cts *buf = &head->cts_g;
u32 cts_frame_len = 14;
/* Get SignalField,ServiceField,Length */
vnt_get_phy_field(priv, cts_frame_len, priv->top_cck_basic_rate,
PK_TYPE_11B, &buf->b);
/* Get CTSDuration_ba */
buf->duration_ba = vnt_get_cts_duration(tx_context);
/*Get CTS Frame body*/
buf->data.duration = buf->duration_ba;
buf->data.frame_control =
cpu_to_le16(IEEE80211_FTYPE_CTL | IEEE80211_STYPE_CTS);
ether_addr_copy(buf->data.ra, priv->current_net_addr);
vnt_rxtx_datahead_g(tx_context, &buf->data_head);
}
/* returns true if mic_hdr is needed */
static bool vnt_fill_txkey(struct vnt_tx_buffer *tx_buffer, struct sk_buff *skb)
{
struct vnt_tx_fifo_head *fifo = &tx_buffer->fifo_head;
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
struct ieee80211_key_conf *tx_key = info->control.hw_key;
struct vnt_mic_hdr *mic_hdr;
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
u64 pn64;
u16 payload_len = skb->len;
u8 *iv = ((u8 *)hdr + ieee80211_get_hdrlen_from_skb(skb));
/* strip header and icv len from payload */
payload_len -= ieee80211_get_hdrlen_from_skb(skb);
payload_len -= tx_key->icv_len;
switch (tx_key->cipher) {
case WLAN_CIPHER_SUITE_WEP40:
case WLAN_CIPHER_SUITE_WEP104:
memcpy(fifo->tx_key, iv, 3);
memcpy(fifo->tx_key + 3, tx_key->key, tx_key->keylen);
if (tx_key->keylen == WLAN_KEY_LEN_WEP40) {
memcpy(fifo->tx_key + 8, iv, 3);
memcpy(fifo->tx_key + 11,
tx_key->key, WLAN_KEY_LEN_WEP40);
}
fifo->frag_ctl |= cpu_to_le16(FRAGCTL_LEGACY);
break;
case WLAN_CIPHER_SUITE_TKIP:
ieee80211_get_tkip_p2k(tx_key, skb, fifo->tx_key);
fifo->frag_ctl |= cpu_to_le16(FRAGCTL_TKIP);
break;
case WLAN_CIPHER_SUITE_CCMP:
if (info->control.use_cts_prot) {
if (info->control.use_rts)
mic_hdr = &tx_buffer->tx_head.tx_rts.tx.mic.hdr;
else
mic_hdr = &tx_buffer->tx_head.tx_cts.tx.mic.hdr;
} else {
mic_hdr = &tx_buffer->tx_head.tx_ab.tx.mic.hdr;
}
mic_hdr->id = 0x59;
mic_hdr->payload_len = cpu_to_be16(payload_len);
ether_addr_copy(mic_hdr->mic_addr2, hdr->addr2);
pn64 = atomic64_read(&tx_key->tx_pn);
mic_hdr->ccmp_pn[5] = pn64;
mic_hdr->ccmp_pn[4] = pn64 >> 8;
mic_hdr->ccmp_pn[3] = pn64 >> 16;
mic_hdr->ccmp_pn[2] = pn64 >> 24;
mic_hdr->ccmp_pn[1] = pn64 >> 32;
mic_hdr->ccmp_pn[0] = pn64 >> 40;
if (ieee80211_has_a4(hdr->frame_control))
mic_hdr->hlen = cpu_to_be16(28);
else
mic_hdr->hlen = cpu_to_be16(22);
ether_addr_copy(mic_hdr->addr1, hdr->addr1);
ether_addr_copy(mic_hdr->addr2, hdr->addr2);
ether_addr_copy(mic_hdr->addr3, hdr->addr3);
mic_hdr->frame_control = cpu_to_le16(le16_to_cpu(hdr->frame_control) & 0xc78f);
mic_hdr->seq_ctrl = cpu_to_le16(le16_to_cpu(hdr->seq_ctrl) & 0xf);
if (ieee80211_has_a4(hdr->frame_control))
ether_addr_copy(mic_hdr->addr4, hdr->addr4);
memcpy(fifo->tx_key, tx_key->key, WLAN_KEY_LEN_CCMP);
fifo->frag_ctl |= cpu_to_le16(FRAGCTL_AES);
return true;
default:
break;
}
return false;
}
static void vnt_rxtx_rts(struct vnt_usb_send_context *tx_context)
{
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_context->skb);
struct vnt_tx_buffer *tx_buffer = tx_context->tx_buffer;
union vnt_tx_head *tx_head = &tx_buffer->tx_head;
struct vnt_rrv_time_rts *buf = &tx_head->tx_rts.rts;
union vnt_tx_data_head *head = &tx_head->tx_rts.tx.head;
buf->rts_rrv_time_aa = vnt_get_rts_duration(tx_context);
buf->rts_rrv_time_ba = buf->rts_rrv_time_aa;
buf->rts_rrv_time_bb = buf->rts_rrv_time_aa;
buf->rrv_time_a = vnt_rxtx_rsvtime_le16(tx_context);
buf->rrv_time_b = buf->rrv_time_a;
if (info->control.hw_key) {
if (vnt_fill_txkey(tx_buffer, tx_context->skb))
head = &tx_head->tx_rts.tx.mic.head;
}
vnt_rxtx_rts_g_head(tx_context, &head->rts_g);
}
static void vnt_rxtx_cts(struct vnt_usb_send_context *tx_context)
{
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_context->skb);
struct vnt_tx_buffer *tx_buffer = tx_context->tx_buffer;
union vnt_tx_head *tx_head = &tx_buffer->tx_head;
struct vnt_rrv_time_cts *buf = &tx_head->tx_cts.cts;
union vnt_tx_data_head *head = &tx_head->tx_cts.tx.head;
buf->rrv_time_a = vnt_rxtx_rsvtime_le16(tx_context);
buf->rrv_time_b = buf->rrv_time_a;
buf->cts_rrv_time_ba = vnt_get_cts_duration(tx_context);
if (info->control.hw_key) {
if (vnt_fill_txkey(tx_buffer, tx_context->skb))
head = &tx_head->tx_cts.tx.mic.head;
}
vnt_fill_cts_head(tx_context, head);
}
static void vnt_rxtx_ab(struct vnt_usb_send_context *tx_context)
{
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_context->skb);
struct vnt_tx_buffer *tx_buffer = tx_context->tx_buffer;
union vnt_tx_head *tx_head = &tx_buffer->tx_head;
struct vnt_rrv_time_ab *buf = &tx_head->tx_ab.ab;
union vnt_tx_data_head *head = &tx_head->tx_ab.tx.head;
buf->rrv_time = vnt_rxtx_rsvtime_le16(tx_context);
if (info->control.hw_key) {
if (vnt_fill_txkey(tx_buffer, tx_context->skb))
head = &tx_head->tx_ab.tx.mic.head;
}
if (info->control.use_rts) {
buf->rts_rrv_time = vnt_get_rts_duration(tx_context);
vnt_rxtx_rts_ab_head(tx_context, &head->rts_ab);
return;
}
vnt_rxtx_datahead_ab(tx_context, &head->data_head_ab);
}
static void vnt_generate_tx_parameter(struct vnt_usb_send_context *tx_context)
{
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_context->skb);
if (info->control.use_cts_prot) {
if (info->control.use_rts) {
vnt_rxtx_rts(tx_context);
return;
}
vnt_rxtx_cts(tx_context);
return;
}
vnt_rxtx_ab(tx_context);
}
static u16 vnt_get_hdr_size(struct ieee80211_tx_info *info)
{
u16 size = sizeof(struct vnt_tx_datahead_ab);
if (info->control.use_cts_prot) {
if (info->control.use_rts)
size = sizeof(struct vnt_rts_g);
else
size = sizeof(struct vnt_cts);
} else if (info->control.use_rts) {
size = sizeof(struct vnt_rts_ab);
}
if (info->control.hw_key) {
if (info->control.hw_key->cipher == WLAN_CIPHER_SUITE_CCMP)
size += sizeof(struct vnt_mic_hdr);
}
/* Get rrv_time header */
if (info->control.use_cts_prot) {
if (info->control.use_rts)
size += sizeof(struct vnt_rrv_time_rts);
else
size += sizeof(struct vnt_rrv_time_cts);
} else {
size += sizeof(struct vnt_rrv_time_ab);
}
size += sizeof(struct vnt_tx_fifo_head);
return size;
}
int vnt_tx_packet(struct vnt_private *priv, struct sk_buff *skb)
{
struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
struct ieee80211_tx_rate *tx_rate = &info->control.rates[0];
struct ieee80211_rate *rate;
struct ieee80211_hdr *hdr;
struct vnt_tx_buffer *tx_buffer;
struct vnt_tx_fifo_head *tx_buffer_head;
struct vnt_usb_send_context *tx_context;
unsigned long flags;
u8 pkt_type;
hdr = (struct ieee80211_hdr *)(skb->data);
rate = ieee80211_get_tx_rate(priv->hw, info);
if (rate->hw_value > RATE_11M) {
if (info->band == NL80211_BAND_5GHZ) {
pkt_type = PK_TYPE_11A;
} else {
if (tx_rate->flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
if (priv->basic_rates & VNT_B_RATES)
pkt_type = PK_TYPE_11GB;
else
pkt_type = PK_TYPE_11GA;
} else {
pkt_type = PK_TYPE_11A;
}
}
} else {
pkt_type = PK_TYPE_11B;
}
spin_lock_irqsave(&priv->lock, flags);
tx_context = vnt_get_free_context(priv);
if (!tx_context) {
dev_dbg(&priv->usb->dev, "%s No free context\n", __func__);
spin_unlock_irqrestore(&priv->lock, flags);
return -ENOMEM;
}
tx_context->pkt_type = pkt_type;
tx_context->frame_len = skb->len + 4;
tx_context->tx_rate = rate->hw_value;
spin_unlock_irqrestore(&priv->lock, flags);
tx_context->skb = skb_clone(skb, GFP_ATOMIC);
if (!tx_context->skb) {
tx_context->in_use = false;
return -ENOMEM;
}
tx_buffer = skb_push(skb, vnt_get_hdr_size(info));
tx_context->tx_buffer = tx_buffer;
tx_buffer_head = &tx_buffer->fifo_head;
tx_context->type = CONTEXT_DATA_PACKET;
/*Set fifo controls */
if (pkt_type == PK_TYPE_11A)
tx_buffer_head->fifo_ctl = 0;
else if (pkt_type == PK_TYPE_11B)
tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11B);
else if (pkt_type == PK_TYPE_11GB)
tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GB);
else if (pkt_type == PK_TYPE_11GA)
tx_buffer_head->fifo_ctl = cpu_to_le16(FIFOCTL_11GA);
if (!ieee80211_is_data(hdr->frame_control)) {
tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_GENINT |
FIFOCTL_ISDMA0);
tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_TMOEN);
tx_buffer_head->time_stamp =
cpu_to_le16(DEFAULT_MGN_LIFETIME_RES_64us);
} else {
tx_buffer_head->time_stamp =
cpu_to_le16(DEFAULT_MSDU_LIFETIME_RES_64us);
}
if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_NEEDACK);
if (ieee80211_has_retry(hdr->frame_control))
tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LRETRY);
if (info->control.use_rts)
tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_RTS);
if (ieee80211_has_a4(hdr->frame_control))
tx_buffer_head->fifo_ctl |= cpu_to_le16(FIFOCTL_LHEAD);
tx_buffer_head->frag_ctl =
cpu_to_le16(ieee80211_hdrlen(hdr->frame_control) << 10);
if (info->control.hw_key)
tx_context->frame_len += info->control.hw_key->icv_len;
tx_buffer_head->current_rate = cpu_to_le16(rate->hw_value);
vnt_generate_tx_parameter(tx_context);
tx_buffer_head->frag_ctl |= cpu_to_le16(FRAGCTL_NONFRAG);
priv->seq_counter = (le16_to_cpu(hdr->seq_ctrl) &
IEEE80211_SCTL_SEQ) >> 4;
spin_lock_irqsave(&priv->lock, flags);
if (vnt_tx_context(priv, tx_context, skb)) {
dev_kfree_skb(tx_context->skb);
spin_unlock_irqrestore(&priv->lock, flags);
return -EIO;
}
dev_kfree_skb(skb);
spin_unlock_irqrestore(&priv->lock, flags);
return 0;
}
static int vnt_beacon_xmit(struct vnt_private *priv, struct sk_buff *skb)
{
struct vnt_tx_short_buf_head *short_head;
struct ieee80211_tx_info *info;
struct vnt_usb_send_context *context;
struct ieee80211_mgmt *mgmt_hdr;
unsigned long flags;
u32 frame_size = skb->len + 4;
u16 current_rate;
spin_lock_irqsave(&priv->lock, flags);
context = vnt_get_free_context(priv);
if (!context) {
dev_dbg(&priv->usb->dev, "%s No free context!\n", __func__);
spin_unlock_irqrestore(&priv->lock, flags);
return -ENOMEM;
}
context->skb = skb;
spin_unlock_irqrestore(&priv->lock, flags);
mgmt_hdr = (struct ieee80211_mgmt *)skb->data;
short_head = skb_push(skb, sizeof(*short_head));
if (priv->bb_type == BB_TYPE_11A) {
current_rate = RATE_6M;
/* Get SignalField,ServiceField,Length */
vnt_get_phy_field(priv, frame_size, current_rate,
PK_TYPE_11A, &short_head->ab);
/* Get TimeStampOff */
short_head->time_stamp_off =
vnt_time_stamp_off(priv, current_rate);
} else {
current_rate = RATE_1M;
short_head->fifo_ctl |= cpu_to_le16(FIFOCTL_11B);
/* Get SignalField,ServiceField,Length */
vnt_get_phy_field(priv, frame_size, current_rate,
PK_TYPE_11B, &short_head->ab);
/* Get TimeStampOff */
short_head->time_stamp_off =
vnt_time_stamp_off(priv, current_rate);
}
/* Get Duration */
short_head->duration = mgmt_hdr->duration;
/* time stamp always 0 */
mgmt_hdr->u.beacon.timestamp = 0;
info = IEEE80211_SKB_CB(skb);
if (info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)mgmt_hdr;
hdr->duration_id = 0;
hdr->seq_ctrl = cpu_to_le16(priv->seq_counter << 4);
}
priv->seq_counter++;
if (priv->seq_counter > 0x0fff)
priv->seq_counter = 0;
context->type = CONTEXT_BEACON_PACKET;
spin_lock_irqsave(&priv->lock, flags);
if (vnt_tx_context(priv, context, skb))
ieee80211_free_txskb(priv->hw, context->skb);
spin_unlock_irqrestore(&priv->lock, flags);
return 0;
}
int vnt_beacon_make(struct vnt_private *priv, struct ieee80211_vif *vif)
{
struct sk_buff *beacon;
beacon = ieee80211_beacon_get(priv->hw, vif, 0);
if (!beacon)
return -ENOMEM;
if (vnt_beacon_xmit(priv, beacon)) {
ieee80211_free_txskb(priv->hw, beacon);
return -ENODEV;
}
return 0;
}
int vnt_beacon_enable(struct vnt_private *priv, struct ieee80211_vif *vif,
struct ieee80211_bss_conf *conf)
{
vnt_mac_reg_bits_off(priv, MAC_REG_TCR, TCR_AUTOBCNTX);
vnt_mac_reg_bits_off(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
vnt_mac_set_beacon_interval(priv, conf->beacon_int);
vnt_clear_current_tsf(priv);
vnt_mac_reg_bits_on(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
vnt_reset_next_tbtt(priv, conf->beacon_int);
return vnt_beacon_make(priv, vif);
}
| linux-master | drivers/staging/vt6656/rxtx.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: MAC routines
*
* Author: Tevin Chen
*
* Date: May 21, 1996
*
* Functions:
*
* Revision History:
*/
#include <linux/etherdevice.h>
#include "desc.h"
#include "mac.h"
#include "usbpipe.h"
int vnt_mac_set_filter(struct vnt_private *priv, u64 mc_filter)
{
__le64 le_mc = cpu_to_le64(mc_filter);
return vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_MAR0,
MESSAGE_REQUEST_MACREG, sizeof(le_mc),
(u8 *)&le_mc);
}
int vnt_mac_shutdown(struct vnt_private *priv)
{
return vnt_control_out(priv, MESSAGE_TYPE_MACSHUTDOWN, 0, 0, 0, NULL);
}
int vnt_mac_set_bb_type(struct vnt_private *priv, u8 type)
{
u8 data[2];
data[0] = type;
data[1] = EN_CFG_BB_TYPE_MASK;
return vnt_control_out(priv, MESSAGE_TYPE_WRITE_MASK, MAC_REG_ENCFG0,
MESSAGE_REQUEST_MACREG, ARRAY_SIZE(data),
data);
}
int vnt_mac_disable_keyentry(struct vnt_private *priv, u8 entry_idx)
{
return vnt_control_out(priv, MESSAGE_TYPE_CLRKEYENTRY, 0, 0,
sizeof(entry_idx), &entry_idx);
}
int vnt_mac_set_keyentry(struct vnt_private *priv, u16 key_ctl, u32 entry_idx,
u32 key_idx, u8 *addr, u8 *key)
{
struct vnt_mac_set_key set_key;
u16 offset;
offset = MISCFIFO_KEYETRY0;
offset += entry_idx * MISCFIFO_KEYENTRYSIZE;
set_key.u.write.key_ctl = cpu_to_le16(key_ctl);
ether_addr_copy(set_key.u.write.addr, addr);
/* swap over swap[0] and swap[1] to get correct write order */
swap(set_key.u.swap[0], set_key.u.swap[1]);
memcpy(set_key.key, key, WLAN_KEY_LEN_CCMP);
dev_dbg(&priv->usb->dev, "offset %d key ctl %d set key %24ph\n",
offset, key_ctl, (u8 *)&set_key);
return vnt_control_out(priv, MESSAGE_TYPE_SETKEY, offset,
(u16)key_idx, sizeof(struct vnt_mac_set_key),
(u8 *)&set_key);
}
int vnt_mac_reg_bits_off(struct vnt_private *priv, u8 reg_ofs, u8 bits)
{
u8 data[2];
data[0] = 0;
data[1] = bits;
return vnt_control_out(priv, MESSAGE_TYPE_WRITE_MASK, reg_ofs,
MESSAGE_REQUEST_MACREG, ARRAY_SIZE(data), data);
}
int vnt_mac_reg_bits_on(struct vnt_private *priv, u8 reg_ofs, u8 bits)
{
u8 data[2];
data[0] = bits;
data[1] = bits;
return vnt_control_out(priv, MESSAGE_TYPE_WRITE_MASK, reg_ofs,
MESSAGE_REQUEST_MACREG, ARRAY_SIZE(data), data);
}
int vnt_mac_write_word(struct vnt_private *priv, u8 reg_ofs, u16 word)
{
u8 data[2];
data[0] = (u8)(word & 0xff);
data[1] = (u8)(word >> 8);
return vnt_control_out(priv, MESSAGE_TYPE_WRITE, reg_ofs,
MESSAGE_REQUEST_MACREG, ARRAY_SIZE(data), data);
}
int vnt_mac_set_bssid_addr(struct vnt_private *priv, u8 *addr)
{
return vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_BSSID0,
MESSAGE_REQUEST_MACREG, ETH_ALEN, addr);
}
int vnt_mac_enable_protect_mode(struct vnt_private *priv)
{
u8 data[2];
data[0] = EN_CFG_PROTECT_MD;
data[1] = EN_CFG_PROTECT_MD;
return vnt_control_out(priv, MESSAGE_TYPE_WRITE_MASK, MAC_REG_ENCFG0,
MESSAGE_REQUEST_MACREG, ARRAY_SIZE(data), data);
}
int vnt_mac_disable_protect_mode(struct vnt_private *priv)
{
u8 data[2];
data[0] = 0;
data[1] = EN_CFG_PROTECT_MD;
return vnt_control_out(priv, MESSAGE_TYPE_WRITE_MASK, MAC_REG_ENCFG0,
MESSAGE_REQUEST_MACREG, ARRAY_SIZE(data), data);
}
int vnt_mac_enable_barker_preamble_mode(struct vnt_private *priv)
{
u8 data[2];
data[0] = EN_CFG_BARKER_PREAM;
data[1] = EN_CFG_BARKER_PREAM;
return vnt_control_out(priv, MESSAGE_TYPE_WRITE_MASK, MAC_REG_ENCFG2,
MESSAGE_REQUEST_MACREG, ARRAY_SIZE(data), data);
}
int vnt_mac_disable_barker_preamble_mode(struct vnt_private *priv)
{
u8 data[2];
data[0] = 0;
data[1] = EN_CFG_BARKER_PREAM;
return vnt_control_out(priv, MESSAGE_TYPE_WRITE_MASK, MAC_REG_ENCFG2,
MESSAGE_REQUEST_MACREG, ARRAY_SIZE(data), data);
}
int vnt_mac_set_beacon_interval(struct vnt_private *priv, u16 interval)
{
u8 data[2];
data[0] = (u8)(interval & 0xff);
data[1] = (u8)(interval >> 8);
return vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_BI,
MESSAGE_REQUEST_MACREG, ARRAY_SIZE(data), data);
}
int vnt_mac_set_led(struct vnt_private *priv, u8 state, u8 led)
{
u8 data[2];
data[0] = led;
data[1] = state;
return vnt_control_out(priv, MESSAGE_TYPE_WRITE_MASK, MAC_REG_PAPEDELAY,
MESSAGE_REQUEST_MACREG, ARRAY_SIZE(data), data);
}
| linux-master | drivers/staging/vt6656/mac.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: Implement functions to access baseband
*
* Author: Jerry Chen
*
* Date: Jun. 5, 2002
*
* Functions:
* vnt_get_frame_time - Calculate data frame transmitting time
* vnt_get_phy_field - Calculate PhyLength, PhyService and Phy
* Signal parameter for baseband Tx
* vnt_vt3184_init - VIA VT3184 baseband chip init code
*
* Revision History:
*
*
*/
#include <linux/bits.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include "device.h"
#include "mac.h"
#include "baseband.h"
#include "rf.h"
#include "usbpipe.h"
static const u8 vnt_vt3184_agc[] = {
0x00, 0x00, 0x02, 0x02, 0x04, 0x04, 0x06, 0x06,
0x08, 0x08, 0x0a, 0x0a, 0x0c, 0x0c, 0x0e, 0x0e, /* 0x0f */
0x10, 0x10, 0x12, 0x12, 0x14, 0x14, 0x16, 0x16,
0x18, 0x18, 0x1a, 0x1a, 0x1c, 0x1c, 0x1e, 0x1e, /* 0x1f */
0x20, 0x20, 0x22, 0x22, 0x24, 0x24, 0x26, 0x26,
0x28, 0x28, 0x2a, 0x2a, 0x2c, 0x2c, 0x2e, 0x2e, /* 0x2f */
0x30, 0x30, 0x32, 0x32, 0x34, 0x34, 0x36, 0x36,
0x38, 0x38, 0x3a, 0x3a, 0x3c, 0x3c, 0x3e, 0x3e /* 0x3f */
};
static u8 vnt_vt3184_al2230[] = {
0x31, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
0x70, 0x45, 0x2a, 0x76, 0x00, 0x00, 0x80, 0x00, /* 0x0f */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x8e, 0x0a, 0x00, 0x00, 0x00, /* 0x1f */
0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x0c, /* 0x2f */
0x26, 0x5b, 0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa,
0xff, 0xff, 0x79, 0x00, 0x00, 0x0b, 0x48, 0x04, /* 0x3f */
0x00, 0x08, 0x00, 0x08, 0x08, 0x14, 0x05, 0x09,
0x00, 0x00, 0x00, 0x00, 0x09, 0x73, 0x00, 0xc5, /* 0x4f */
0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x5f */
0xe4, 0x80, 0x00, 0x00, 0x00, 0x00, 0x98, 0x0a,
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, /* 0x6f */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x7f */
0x8c, 0x01, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
0x08, 0x00, 0x1f, 0xb7, 0x88, 0x47, 0xaa, 0x00, /* 0x8f */
0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xeb,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, /* 0x9f */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
0x18, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x18, /* 0xaf */
0x38, 0x30, 0x00, 0x00, 0xff, 0x0f, 0xe4, 0xe2,
0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, /* 0xbf */
0x18, 0x20, 0x07, 0x18, 0xff, 0xff, 0x0e, 0x0a,
0x0e, 0x00, 0x82, 0xa7, 0x3c, 0x10, 0x30, 0x05, /* 0xcf */
0x40, 0x12, 0x00, 0x00, 0x10, 0x28, 0x80, 0x2a,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xdf */
0x00, 0xf3, 0x00, 0x00, 0x00, 0x10, 0x00, 0x12,
0x00, 0xf4, 0x00, 0xff, 0x79, 0x20, 0x30, 0x05, /* 0xef */
0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /* 0xff */
};
/* {{RobertYu:20060515, new BB setting for VT3226D0 */
static const u8 vnt_vt3184_vt3226d0[] = {
0x31, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00,
0x70, 0x45, 0x2a, 0x76, 0x00, 0x00, 0x80, 0x00, /* 0x0f */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x8e, 0x0a, 0x00, 0x00, 0x00, /* 0x1f */
0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0x00, 0x0c, /* 0x2f */
0x26, 0x5b, 0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa,
0xff, 0xff, 0x79, 0x00, 0x00, 0x0b, 0x48, 0x04, /* 0x3f */
0x00, 0x08, 0x00, 0x08, 0x08, 0x14, 0x05, 0x09,
0x00, 0x00, 0x00, 0x00, 0x09, 0x73, 0x00, 0xc5, /* 0x4f */
0x00, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xd0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x5f */
0xe4, 0x80, 0x00, 0x00, 0x00, 0x00, 0x98, 0x0a,
0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x00, /* 0x6f */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x7f */
0x8c, 0x01, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00,
0x08, 0x00, 0x1f, 0xb7, 0x88, 0x47, 0xaa, 0x00, /* 0x8f */
0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xeb,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, /* 0x9f */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, /* 0xaf */
0x38, 0x30, 0x00, 0x00, 0xff, 0x0f, 0xe4, 0xe2,
0x00, 0x00, 0x00, 0x03, 0x01, 0x00, 0x00, 0x00, /* 0xbf */
0x18, 0x20, 0x07, 0x18, 0xff, 0xff, 0x10, 0x0a,
0x0e, 0x00, 0x84, 0xa7, 0x3c, 0x10, 0x24, 0x05, /* 0xcf */
0x40, 0x12, 0x00, 0x00, 0x10, 0x28, 0x80, 0x2a,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0xdf */
0x00, 0xf3, 0x00, 0x00, 0x00, 0x10, 0x00, 0x10,
0x00, 0xf4, 0x00, 0xff, 0x79, 0x20, 0x30, 0x08, /* 0xef */
0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 /* 0xff */
};
struct vnt_threshold {
u8 bb_pre_ed_rssi;
u8 cr_201;
u8 cr_206;
};
static const struct vnt_threshold al2230_vnt_threshold[] = {
{0, 0x00, 0x30}, /* Max sensitivity */
{68, 0x00, 0x36},
{67, 0x00, 0x43},
{66, 0x00, 0x51},
{65, 0x00, 0x62},
{64, 0x00, 0x79},
{63, 0x00, 0x93},
{62, 0x00, 0xb9},
{61, 0x00, 0xe3},
{60, 0x01, 0x18},
{59, 0x01, 0x54},
{58, 0x01, 0xa0},
{57, 0x02, 0x20},
{56, 0x02, 0xa0},
{55, 0x03, 0x00},
{53, 0x06, 0x00},
{51, 0x09, 0x00},
{49, 0x0e, 0x00},
{47, 0x15, 0x00},
{46, 0x1a, 0x00},
{45, 0xff, 0x00}
};
static const struct vnt_threshold vt3226_vnt_threshold[] = {
{0, 0x00, 0x24}, /* Max sensitivity */
{68, 0x00, 0x2d},
{67, 0x00, 0x36},
{66, 0x00, 0x43},
{65, 0x00, 0x52},
{64, 0x00, 0x68},
{63, 0x00, 0x80},
{62, 0x00, 0x9c},
{61, 0x00, 0xc0},
{60, 0x00, 0xea},
{59, 0x01, 0x30},
{58, 0x01, 0x70},
{57, 0x01, 0xb0},
{56, 0x02, 0x30},
{55, 0x02, 0xc0},
{53, 0x04, 0x00},
{51, 0x07, 0x00},
{49, 0x0a, 0x00},
{47, 0x11, 0x00},
{45, 0x18, 0x00},
{43, 0x26, 0x00},
{42, 0x36, 0x00},
{41, 0xff, 0x00}
};
/*
* Description: Set Antenna mode
*
* Parameters:
* In:
* priv - Device Structure
* antenna_mode - Antenna Mode
* Out:
* none
*
* Return Value: none
*
*/
int vnt_set_antenna_mode(struct vnt_private *priv, u8 antenna_mode)
{
switch (antenna_mode) {
case ANT_TXA:
case ANT_TXB:
break;
case ANT_RXA:
priv->bb_rx_conf &= 0xFC;
break;
case ANT_RXB:
priv->bb_rx_conf &= 0xFE;
priv->bb_rx_conf |= 0x02;
break;
}
return vnt_control_out(priv, MESSAGE_TYPE_SET_ANTMD,
(u16)antenna_mode, 0, 0, NULL);
}
/*
* Description: Set Antenna mode
*
* Parameters:
* In:
* pDevice - Device Structure
* byAntennaMode - Antenna Mode
* Out:
* none
*
* Return Value: none
*
*/
int vnt_vt3184_init(struct vnt_private *priv)
{
int ret;
u16 length;
u8 *addr = NULL;
const u8 *c_addr;
u8 data;
ret = vnt_control_in(priv, MESSAGE_TYPE_READ, 0, MESSAGE_REQUEST_EEPROM,
EEP_MAX_CONTEXT_SIZE, priv->eeprom);
if (ret)
goto end;
priv->rf_type = priv->eeprom[EEP_OFS_RFTYPE];
dev_dbg(&priv->usb->dev, "RF Type %d\n", priv->rf_type);
if ((priv->rf_type == RF_AL2230) ||
(priv->rf_type == RF_AL2230S)) {
priv->bb_rx_conf = vnt_vt3184_al2230[10];
length = sizeof(vnt_vt3184_al2230);
addr = vnt_vt3184_al2230;
priv->bb_vga[0] = 0x1c;
priv->bb_vga[1] = 0x10;
priv->bb_vga[2] = 0x0;
priv->bb_vga[3] = 0x0;
} else if ((priv->rf_type == RF_VT3226) ||
(priv->rf_type == RF_VT3226D0)) {
priv->bb_rx_conf = vnt_vt3184_vt3226d0[10];
length = sizeof(vnt_vt3184_vt3226d0);
c_addr = vnt_vt3184_vt3226d0;
priv->bb_vga[0] = 0x20;
priv->bb_vga[1] = 0x10;
priv->bb_vga[2] = 0x0;
priv->bb_vga[3] = 0x0;
/* Fix VT3226 DFC system timing issue */
ret = vnt_mac_reg_bits_on(priv, MAC_REG_SOFTPWRCTL2,
SOFTPWRCTL_RFLEOPT);
if (ret)
goto end;
} else {
goto end;
}
if (addr)
c_addr = addr;
ret = vnt_control_out_blocks(priv, VNT_REG_BLOCK_SIZE,
MESSAGE_REQUEST_BBREG, length, c_addr);
if (ret)
goto end;
ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE, 0,
MESSAGE_REQUEST_BBAGC,
sizeof(vnt_vt3184_agc), vnt_vt3184_agc);
if (ret)
goto end;
if ((priv->rf_type == RF_VT3226) ||
(priv->rf_type == RF_VT3226D0)) {
data = (priv->rf_type == RF_VT3226D0) ? 0x11 : 0x23;
ret = vnt_control_out_u8(priv, MESSAGE_REQUEST_MACREG,
MAC_REG_ITRTMSET, data);
if (ret)
goto end;
ret = vnt_mac_reg_bits_on(priv, MAC_REG_PAPEDELAY, BIT(0));
if (ret)
goto end;
}
ret = vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x04, 0x7f);
if (ret)
goto end;
ret = vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x0d, 0x01);
if (ret)
goto end;
ret = vnt_rf_table_download(priv);
if (ret)
goto end;
/* Fix for TX USB resets from vendors driver */
ret = vnt_control_in(priv, MESSAGE_TYPE_READ, USB_REG4,
MESSAGE_REQUEST_MEM, sizeof(data), &data);
if (ret)
goto end;
data |= 0x2;
ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE, USB_REG4,
MESSAGE_REQUEST_MEM, sizeof(data), &data);
end:
return ret;
}
/*
* Description: Set ShortSlotTime mode
*
* Parameters:
* In:
* priv - Device Structure
* Out:
* none
*
* Return Value: none
*
*/
int vnt_set_short_slot_time(struct vnt_private *priv)
{
int ret = 0;
u8 bb_vga = 0;
if (priv->short_slot_time)
priv->bb_rx_conf &= 0xdf;
else
priv->bb_rx_conf |= 0x20;
ret = vnt_control_in_u8(priv, MESSAGE_REQUEST_BBREG, 0xe7, &bb_vga);
if (ret)
return ret;
if (bb_vga == priv->bb_vga[0])
priv->bb_rx_conf |= 0x20;
return vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x0a,
priv->bb_rx_conf);
}
int vnt_set_vga_gain_offset(struct vnt_private *priv, u8 data)
{
int ret;
ret = vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0xE7, data);
if (ret)
return ret;
/* patch for 3253B0 Baseband with Cardbus module */
if (priv->short_slot_time)
priv->bb_rx_conf &= 0xdf; /* 1101 1111 */
else
priv->bb_rx_conf |= 0x20; /* 0010 0000 */
return vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x0a,
priv->bb_rx_conf);
}
/*
* Description: vnt_set_deep_sleep
*
* Parameters:
* In:
* priv - Device Structure
* Out:
* none
*
* Return Value: none
*
*/
int vnt_set_deep_sleep(struct vnt_private *priv)
{
int ret = 0;
/* CR12 */
ret = vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x0c, 0x17);
if (ret)
return ret;
/* CR13 */
return vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x0d, 0xB9);
}
int vnt_exit_deep_sleep(struct vnt_private *priv)
{
int ret = 0;
/* CR12 */
ret = vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x0c, 0x00);
if (ret)
return ret;
/* CR13 */
return vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0x0d, 0x01);
}
int vnt_update_pre_ed_threshold(struct vnt_private *priv, int scanning)
{
const struct vnt_threshold *threshold = NULL;
u8 length;
u8 cr_201, cr_206;
u8 ed_inx;
int ret;
switch (priv->rf_type) {
case RF_AL2230:
case RF_AL2230S:
threshold = al2230_vnt_threshold;
length = ARRAY_SIZE(al2230_vnt_threshold);
break;
case RF_VT3226:
case RF_VT3226D0:
threshold = vt3226_vnt_threshold;
length = ARRAY_SIZE(vt3226_vnt_threshold);
break;
}
if (!threshold)
return -EINVAL;
for (ed_inx = scanning ? 0 : length - 1; ed_inx > 0; ed_inx--) {
if (priv->bb_pre_ed_rssi <= threshold[ed_inx].bb_pre_ed_rssi)
break;
}
cr_201 = threshold[ed_inx].cr_201;
cr_206 = threshold[ed_inx].cr_206;
if (ed_inx == priv->bb_pre_ed_index && !scanning)
return 0;
priv->bb_pre_ed_index = ed_inx;
dev_dbg(&priv->usb->dev, "%s bb_pre_ed_rssi %d\n",
__func__, priv->bb_pre_ed_rssi);
ret = vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0xc9, cr_201);
if (ret)
return ret;
return vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG, 0xce, cr_206);
}
| linux-master | drivers/staging/vt6656/baseband.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: Handles the management command interface functions
*
* Author: Lyndon Chen
*
* Date: May 8, 2003
*
* Functions:
* vnt_cmd_complete - Command Complete function
* vnt_schedule_command - Push Command and wait Command Scheduler to do
* vnt_cmd_timer_wait- Call back timer
*
* Revision History:
*
*/
#include "device.h"
#include "mac.h"
#include "wcmd.h"
#include "power.h"
#include "usbpipe.h"
#include "rxtx.h"
#include "rf.h"
static void vnt_cmd_timer_wait(struct vnt_private *priv, unsigned long msecs)
{
schedule_delayed_work(&priv->run_command_work, msecs_to_jiffies(msecs));
}
static u32 add_one_with_wrap_around(u32 var, u8 modulo)
{
if (var >= (modulo - 1))
var = 0;
else
var++;
return var;
}
static int vnt_cmd_complete(struct vnt_private *priv)
{
priv->command_state = WLAN_CMD_IDLE;
if (priv->free_cmd_queue == CMD_Q_SIZE) {
/* Command Queue Empty */
priv->cmd_running = false;
return true;
}
priv->command = priv->cmd_queue[priv->cmd_dequeue_idx];
priv->cmd_dequeue_idx = add_one_with_wrap_around(priv->cmd_dequeue_idx, CMD_Q_SIZE);
priv->free_cmd_queue++;
priv->cmd_running = true;
switch (priv->command) {
case WLAN_CMD_INIT_MAC80211:
priv->command_state = WLAN_CMD_INIT_MAC80211_START;
break;
case WLAN_CMD_TBTT_WAKEUP:
priv->command_state = WLAN_CMD_TBTT_WAKEUP_START;
break;
case WLAN_CMD_BECON_SEND:
priv->command_state = WLAN_CMD_BECON_SEND_START;
break;
case WLAN_CMD_SETPOWER:
priv->command_state = WLAN_CMD_SETPOWER_START;
break;
case WLAN_CMD_CHANGE_ANTENNA:
priv->command_state = WLAN_CMD_CHANGE_ANTENNA_START;
break;
default:
break;
}
vnt_cmd_timer_wait(priv, 0);
return true;
}
void vnt_run_command(struct work_struct *work)
{
struct vnt_private *priv =
container_of(work, struct vnt_private, run_command_work.work);
if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags))
return;
if (!priv->cmd_running)
return;
switch (priv->command_state) {
case WLAN_CMD_INIT_MAC80211_START:
if (priv->mac_hw)
break;
dev_info(&priv->usb->dev, "Starting mac80211\n");
if (vnt_init(priv)) {
/* If fail all ends TODO retry */
dev_err(&priv->usb->dev, "failed to start\n");
usb_set_intfdata(priv->intf, NULL);
ieee80211_free_hw(priv->hw);
return;
}
break;
case WLAN_CMD_TBTT_WAKEUP_START:
vnt_next_tbtt_wakeup(priv);
break;
case WLAN_CMD_BECON_SEND_START:
if (!priv->vif)
break;
vnt_beacon_make(priv, priv->vif);
vnt_mac_reg_bits_on(priv, MAC_REG_TCR, TCR_AUTOBCNTX);
break;
case WLAN_CMD_SETPOWER_START:
vnt_rf_setpower(priv, priv->hw->conf.chandef.chan);
break;
case WLAN_CMD_CHANGE_ANTENNA_START:
dev_dbg(&priv->usb->dev, "Change from Antenna%d to",
priv->rx_antenna_sel);
if (priv->rx_antenna_sel == 0) {
priv->rx_antenna_sel = 1;
if (priv->tx_rx_ant_inv)
vnt_set_antenna_mode(priv, ANT_RXA);
else
vnt_set_antenna_mode(priv, ANT_RXB);
} else {
priv->rx_antenna_sel = 0;
if (priv->tx_rx_ant_inv)
vnt_set_antenna_mode(priv, ANT_RXB);
else
vnt_set_antenna_mode(priv, ANT_RXA);
}
break;
default:
break;
}
vnt_cmd_complete(priv);
}
int vnt_schedule_command(struct vnt_private *priv, enum vnt_cmd command)
{
if (priv->free_cmd_queue == 0)
return false;
priv->cmd_queue[priv->cmd_enqueue_idx] = command;
priv->cmd_enqueue_idx = add_one_with_wrap_around(priv->cmd_enqueue_idx, CMD_Q_SIZE);
priv->free_cmd_queue--;
if (!priv->cmd_running)
vnt_cmd_complete(priv);
return true;
}
void vnt_reset_command_timer(struct vnt_private *priv)
{
priv->free_cmd_queue = CMD_Q_SIZE;
priv->cmd_dequeue_idx = 0;
priv->cmd_enqueue_idx = 0;
priv->command_state = WLAN_CMD_IDLE;
priv->cmd_running = false;
}
| linux-master | drivers/staging/vt6656/wcmd.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: Channel number mapping
*
* Author: Lucas Lin
*
* Date: Dec 24, 2004
*
*
*
* Revision History:
* 01-18-2005 RobertYu: remove the for loop searching in
* ChannelValid, change ChannelRuleTab
* to lookup-type, reorder table items.
*
*
*/
#include "device.h"
#include "channel.h"
#include "rf.h"
static struct ieee80211_rate vnt_rates_bg[] = {
{ .bitrate = 10, .hw_value = RATE_1M },
{ .bitrate = 20, .hw_value = RATE_2M },
{ .bitrate = 55, .hw_value = RATE_5M },
{ .bitrate = 110, .hw_value = RATE_11M },
{ .bitrate = 60, .hw_value = RATE_6M },
{ .bitrate = 90, .hw_value = RATE_9M },
{ .bitrate = 120, .hw_value = RATE_12M },
{ .bitrate = 180, .hw_value = RATE_18M },
{ .bitrate = 240, .hw_value = RATE_24M },
{ .bitrate = 360, .hw_value = RATE_36M },
{ .bitrate = 480, .hw_value = RATE_48M },
{ .bitrate = 540, .hw_value = RATE_54M },
};
static struct ieee80211_channel vnt_channels_2ghz[] = {
{ .center_freq = 2412, .hw_value = 1 },
{ .center_freq = 2417, .hw_value = 2 },
{ .center_freq = 2422, .hw_value = 3 },
{ .center_freq = 2427, .hw_value = 4 },
{ .center_freq = 2432, .hw_value = 5 },
{ .center_freq = 2437, .hw_value = 6 },
{ .center_freq = 2442, .hw_value = 7 },
{ .center_freq = 2447, .hw_value = 8 },
{ .center_freq = 2452, .hw_value = 9 },
{ .center_freq = 2457, .hw_value = 10 },
{ .center_freq = 2462, .hw_value = 11 },
{ .center_freq = 2467, .hw_value = 12 },
{ .center_freq = 2472, .hw_value = 13 },
{ .center_freq = 2484, .hw_value = 14 }
};
static struct ieee80211_supported_band vnt_supported_2ghz_band = {
.channels = vnt_channels_2ghz,
.n_channels = ARRAY_SIZE(vnt_channels_2ghz),
.bitrates = vnt_rates_bg,
.n_bitrates = ARRAY_SIZE(vnt_rates_bg),
};
void vnt_init_bands(struct vnt_private *priv)
{
struct ieee80211_channel *ch;
int i;
ch = vnt_channels_2ghz;
for (i = 0; i < ARRAY_SIZE(vnt_channels_2ghz); i++) {
ch[i].max_power = VNT_RF_MAX_POWER;
ch[i].flags = IEEE80211_CHAN_NO_HT40;
}
priv->hw->wiphy->bands[NL80211_BAND_2GHZ] =
&vnt_supported_2ghz_band;
}
| linux-master | drivers/staging/vt6656/channel.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: Handles 802.11 power management functions
*
* Author: Lyndon Chen
*
* Date: July 17, 2002
*
* Functions:
* vnt_enable_power_saving - Enable Power Saving Mode
* PSvDiasblePowerSaving - Disable Power Saving Mode
* vnt_next_tbtt_wakeup - Decide if we need to wake up at next Beacon
*
* Revision History:
*
*/
#include "mac.h"
#include "device.h"
#include "power.h"
#include "wcmd.h"
#include "rxtx.h"
#include "card.h"
#include "usbpipe.h"
/*
*
* Routine Description:
* Enable hw power saving functions
*
* Return Value:
* None.
*
*/
void vnt_enable_power_saving(struct vnt_private *priv, u16 listen_interval)
{
u16 aid = priv->current_aid | BIT(14) | BIT(15);
/* set period of power up before TBTT */
vnt_mac_write_word(priv, MAC_REG_PWBT, C_PWBT);
if (priv->op_mode != NL80211_IFTYPE_ADHOC)
/* set AID */
vnt_mac_write_word(priv, MAC_REG_AIDATIM, aid);
/* Warren:06-18-2004,the sequence must follow
* PSEN->AUTOSLEEP->GO2DOZE
*/
/* enable power saving hw function */
vnt_mac_reg_bits_on(priv, MAC_REG_PSCTL, PSCTL_PSEN);
/* Set AutoSleep */
vnt_mac_reg_bits_on(priv, MAC_REG_PSCFG, PSCFG_AUTOSLEEP);
/* Warren:MUST turn on this once before turn on AUTOSLEEP ,or the
* AUTOSLEEP doesn't work
*/
vnt_mac_reg_bits_on(priv, MAC_REG_PSCTL, PSCTL_GO2DOZE);
/* always listen beacon */
vnt_mac_reg_bits_on(priv, MAC_REG_PSCTL, PSCTL_ALBCN);
dev_dbg(&priv->usb->dev, "PS:Power Saving Mode Enable...\n");
}
int vnt_disable_power_saving(struct vnt_private *priv)
{
int ret;
/* disable power saving hw function */
ret = vnt_control_out(priv, MESSAGE_TYPE_DISABLE_PS, 0,
0, 0, NULL);
if (ret)
return ret;
/* clear AutoSleep */
vnt_mac_reg_bits_off(priv, MAC_REG_PSCFG, PSCFG_AUTOSLEEP);
/* set always listen beacon */
vnt_mac_reg_bits_on(priv, MAC_REG_PSCTL, PSCTL_ALBCN);
return 0;
}
/*
*
* Routine Description:
* Check if Next TBTT must wake up
*
* Return Value:
* None.
*
*/
int vnt_next_tbtt_wakeup(struct vnt_private *priv)
{
struct ieee80211_hw *hw = priv->hw;
struct ieee80211_conf *conf = &hw->conf;
int wake_up = false;
if (conf->listen_interval > 1) {
/* Turn on wake up to listen next beacon */
vnt_mac_reg_bits_on(priv, MAC_REG_PSCTL, PSCTL_LNBCN);
wake_up = true;
}
return wake_up;
}
| linux-master | drivers/staging/vt6656/power.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: Handle USB control endpoint
*
* Author: Warren Hsu
*
* Date: Mar. 29, 2005
*
* Functions:
* vnt_control_out - Write variable length bytes to MEM/BB/MAC/EEPROM
* vnt_control_in - Read variable length bytes from MEM/BB/MAC/EEPROM
* vnt_control_out_u8 - Write one byte to MEM/BB/MAC/EEPROM
* vnt_control_in_u8 - Read one byte from MEM/BB/MAC/EEPROM
*
* Revision History:
* 04-05-2004 Jerry Chen: Initial release
* 11-24-2004 Warren Hsu: Add ControlvWriteByte,ControlvReadByte,
* ControlvMaskByte
*
*/
#include "rxtx.h"
#include "desc.h"
#include "device.h"
#include "usbpipe.h"
#include "mac.h"
#include "rf.h"
#define USB_CTL_WAIT 500 /* ms */
int vnt_control_out(struct vnt_private *priv, u8 request, u16 value,
u16 index, u16 length, const u8 *buffer)
{
int ret = 0;
u8 *usb_buffer;
if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
ret = -EINVAL;
goto end;
}
mutex_lock(&priv->usb_lock);
usb_buffer = kmemdup(buffer, length, GFP_KERNEL);
if (!usb_buffer) {
ret = -ENOMEM;
goto end_unlock;
}
ret = usb_control_msg(priv->usb,
usb_sndctrlpipe(priv->usb, 0),
request, 0x40, value,
index, usb_buffer, length, USB_CTL_WAIT);
kfree(usb_buffer);
if (ret == (int)length)
ret = 0;
else
ret = -EIO;
end_unlock:
mutex_unlock(&priv->usb_lock);
end:
return ret;
}
int vnt_control_out_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 data)
{
return vnt_control_out(priv, MESSAGE_TYPE_WRITE,
reg_off, reg, sizeof(u8), &data);
}
int vnt_control_out_blocks(struct vnt_private *priv,
u16 block, u8 reg, u16 length, const u8 *data)
{
int ret = 0, i;
for (i = 0; i < length; i += block) {
u16 len = min_t(int, length - i, block);
ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE,
i, reg, len, data + i);
if (ret)
goto end;
}
end:
return ret;
}
int vnt_control_in(struct vnt_private *priv, u8 request, u16 value,
u16 index, u16 length, u8 *buffer)
{
int ret = 0;
u8 *usb_buffer;
if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
ret = -EINVAL;
goto end;
}
mutex_lock(&priv->usb_lock);
usb_buffer = kmalloc(length, GFP_KERNEL);
if (!usb_buffer) {
ret = -ENOMEM;
goto end_unlock;
}
ret = usb_control_msg(priv->usb,
usb_rcvctrlpipe(priv->usb, 0),
request, 0xc0, value,
index, usb_buffer, length, USB_CTL_WAIT);
if (ret == length)
memcpy(buffer, usb_buffer, length);
kfree(usb_buffer);
if (ret == (int)length)
ret = 0;
else
ret = -EIO;
end_unlock:
mutex_unlock(&priv->usb_lock);
end:
return ret;
}
int vnt_control_in_u8(struct vnt_private *priv, u8 reg, u8 reg_off, u8 *data)
{
return vnt_control_in(priv, MESSAGE_TYPE_READ,
reg_off, reg, sizeof(u8), data);
}
static int vnt_int_report_rate(struct vnt_private *priv, u8 pkt_no, u8 tsr)
{
struct vnt_usb_send_context *context;
struct ieee80211_tx_info *info;
u8 tx_retry = (tsr & 0xf0) >> 4;
s8 idx;
if (pkt_no >= priv->num_tx_context)
return -EINVAL;
context = priv->tx_context[pkt_no];
if (!context->skb)
return -EINVAL;
info = IEEE80211_SKB_CB(context->skb);
idx = info->control.rates[0].idx;
ieee80211_tx_info_clear_status(info);
info->status.rates[0].count = tx_retry;
if (!(tsr & TSR_TMO)) {
info->status.rates[0].idx = idx;
if (!(info->flags & IEEE80211_TX_CTL_NO_ACK))
info->flags |= IEEE80211_TX_STAT_ACK;
}
ieee80211_tx_status_irqsafe(priv->hw, context->skb);
context->in_use = false;
return 0;
}
static void vnt_int_process_data(struct vnt_private *priv)
{
struct vnt_interrupt_data *int_data;
struct ieee80211_low_level_stats *low_stats = &priv->low_stats;
dev_dbg(&priv->usb->dev, "---->s_nsInterruptProcessData\n");
int_data = (struct vnt_interrupt_data *)priv->int_buf.data_buf;
if (int_data->tsr0 & TSR_VALID)
vnt_int_report_rate(priv, int_data->pkt0, int_data->tsr0);
if (int_data->tsr1 & TSR_VALID)
vnt_int_report_rate(priv, int_data->pkt1, int_data->tsr1);
if (int_data->tsr2 & TSR_VALID)
vnt_int_report_rate(priv, int_data->pkt2, int_data->tsr2);
if (int_data->tsr3 & TSR_VALID)
vnt_int_report_rate(priv, int_data->pkt3, int_data->tsr3);
if (!int_data->isr0)
return;
if (int_data->isr0 & ISR_BNTX && priv->op_mode == NL80211_IFTYPE_AP)
vnt_schedule_command(priv, WLAN_CMD_BECON_SEND);
priv->current_tsf = le64_to_cpu(int_data->tsf);
low_stats->dot11RTSSuccessCount += int_data->rts_success;
low_stats->dot11RTSFailureCount += int_data->rts_fail;
low_stats->dot11ACKFailureCount += int_data->ack_fail;
low_stats->dot11FCSErrorCount += int_data->fcs_err;
}
static void vnt_start_interrupt_urb_complete(struct urb *urb)
{
struct vnt_private *priv = urb->context;
int status = urb->status;
switch (status) {
case 0:
case -ETIMEDOUT:
break;
case -ECONNRESET:
case -ENOENT:
case -ESHUTDOWN:
return;
default:
break;
}
if (status)
dev_dbg(&priv->usb->dev, "%s status = %d\n", __func__, status);
else
vnt_int_process_data(priv);
if (!test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags))
status = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC);
if (status)
dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", status);
}
int vnt_start_interrupt_urb(struct vnt_private *priv)
{
int ret = 0;
dev_dbg(&priv->usb->dev, "---->Interrupt Polling Thread\n");
usb_fill_int_urb(priv->interrupt_urb,
priv->usb,
usb_rcvintpipe(priv->usb, 1),
priv->int_buf.data_buf,
MAX_INTERRUPT_SIZE,
vnt_start_interrupt_urb_complete,
priv,
priv->int_interval);
ret = usb_submit_urb(priv->interrupt_urb, GFP_ATOMIC);
if (ret)
dev_dbg(&priv->usb->dev, "Submit int URB failed %d\n", ret);
return ret;
}
static int vnt_rx_data(struct vnt_private *priv, struct vnt_rcb *ptr_rcb,
unsigned long bytes_received)
{
struct ieee80211_hw *hw = priv->hw;
struct ieee80211_supported_band *sband;
struct sk_buff *skb;
struct ieee80211_rx_status *rx_status;
struct vnt_rx_header *head;
struct vnt_rx_tail *tail;
u32 frame_size;
int ii;
u16 rx_bitrate, pay_load_with_padding;
u8 rate_idx = 0;
long rx_dbm;
skb = ptr_rcb->skb;
rx_status = IEEE80211_SKB_RXCB(skb);
/* [31:16]RcvByteCount ( not include 4-byte Status ) */
head = (struct vnt_rx_header *)skb->data;
frame_size = head->wbk_status >> 16;
frame_size += 4;
if (bytes_received != frame_size) {
dev_dbg(&priv->usb->dev, "------- WRONG Length 1\n");
return false;
}
if ((bytes_received > 2372) || (bytes_received <= 40)) {
/* Frame Size error drop this packet.*/
dev_dbg(&priv->usb->dev, "------ WRONG Length 2\n");
return false;
}
/* real Frame Size = USBframe_size -4WbkStatus - 4RxStatus */
/* -8TSF - 4RSR - 4SQ3 - ?Padding */
/* if SQ3 the range is 24~27, if no SQ3 the range is 20~23 */
/*Fix hardware bug => PLCP_Length error */
if (((bytes_received - head->pay_load_len) > 27) ||
((bytes_received - head->pay_load_len) < 24) ||
(bytes_received < head->pay_load_len)) {
dev_dbg(&priv->usb->dev, "Wrong PLCP Length %x\n",
head->pay_load_len);
return false;
}
sband = hw->wiphy->bands[hw->conf.chandef.chan->band];
rx_bitrate = head->rx_rate * 5; /* rx_rate * 5 */
for (ii = 0; ii < sband->n_bitrates; ii++) {
if (sband->bitrates[ii].bitrate == rx_bitrate) {
rate_idx = ii;
break;
}
}
if (ii == sband->n_bitrates) {
dev_dbg(&priv->usb->dev, "Wrong Rx Bit Rate %d\n", rx_bitrate);
return false;
}
pay_load_with_padding = ((head->pay_load_len / 4) +
((head->pay_load_len % 4) ? 1 : 0)) * 4;
tail = (struct vnt_rx_tail *)(skb->data +
sizeof(*head) + pay_load_with_padding);
priv->tsf_time = le64_to_cpu(tail->tsf_time);
if (tail->rsr & (RSR_IVLDTYP | RSR_IVLDLEN))
return false;
vnt_rf_rssi_to_dbm(priv, tail->rssi, &rx_dbm);
priv->bb_pre_ed_rssi = (u8)-rx_dbm + 1;
priv->current_rssi = priv->bb_pre_ed_rssi;
skb_pull(skb, sizeof(*head));
skb_trim(skb, head->pay_load_len);
rx_status->mactime = priv->tsf_time;
rx_status->band = hw->conf.chandef.chan->band;
rx_status->signal = rx_dbm;
rx_status->flag = 0;
rx_status->freq = hw->conf.chandef.chan->center_freq;
if (!(tail->rsr & RSR_CRCOK))
rx_status->flag |= RX_FLAG_FAILED_FCS_CRC;
rx_status->rate_idx = rate_idx;
if (tail->new_rsr & NEWRSR_DECRYPTOK)
rx_status->flag |= RX_FLAG_DECRYPTED;
ieee80211_rx_irqsafe(priv->hw, skb);
return true;
}
static void vnt_submit_rx_urb_complete(struct urb *urb)
{
struct vnt_rcb *rcb = urb->context;
struct vnt_private *priv = rcb->priv;
switch (urb->status) {
case 0:
break;
case -ECONNRESET:
case -ENOENT:
case -ESHUTDOWN:
return;
case -ETIMEDOUT:
default:
dev_dbg(&priv->usb->dev, "BULK In failed %d\n", urb->status);
break;
}
if (urb->actual_length) {
if (vnt_rx_data(priv, rcb, urb->actual_length)) {
rcb->skb = dev_alloc_skb(priv->rx_buf_sz);
if (!rcb->skb)
return;
} else {
skb_push(rcb->skb, skb_headroom(rcb->skb));
skb_trim(rcb->skb, 0);
}
urb->transfer_buffer = skb_put(rcb->skb,
skb_tailroom(rcb->skb));
}
if (usb_submit_urb(urb, GFP_ATOMIC))
dev_dbg(&priv->usb->dev, "Failed to re submit rx skb\n");
}
int vnt_submit_rx_urb(struct vnt_private *priv, struct vnt_rcb *rcb)
{
int ret = 0;
struct urb *urb = rcb->urb;
if (!rcb->skb) {
dev_dbg(&priv->usb->dev, "rcb->skb is null\n");
ret = -EINVAL;
goto end;
}
usb_fill_bulk_urb(urb,
priv->usb,
usb_rcvbulkpipe(priv->usb, 2),
skb_put(rcb->skb, skb_tailroom(rcb->skb)),
MAX_TOTAL_SIZE_WITH_ALL_HEADERS,
vnt_submit_rx_urb_complete,
rcb);
ret = usb_submit_urb(urb, GFP_ATOMIC);
if (ret)
dev_dbg(&priv->usb->dev, "Submit Rx URB failed %d\n", ret);
end:
return ret;
}
static void vnt_tx_context_complete(struct urb *urb)
{
struct vnt_usb_send_context *context = urb->context;
struct vnt_private *priv = context->priv;
switch (urb->status) {
case 0:
dev_dbg(&priv->usb->dev,
"Write %d bytes\n", urb->actual_length);
break;
case -ECONNRESET:
case -ENOENT:
case -ESHUTDOWN:
context->in_use = false;
return;
case -ETIMEDOUT:
default:
dev_dbg(&priv->usb->dev, "BULK Out failed %d\n", urb->status);
break;
}
if (context->type == CONTEXT_DATA_PACKET)
ieee80211_wake_queues(priv->hw);
if (urb->status || context->type == CONTEXT_BEACON_PACKET) {
if (context->skb)
ieee80211_free_txskb(priv->hw, context->skb);
context->in_use = false;
}
}
int vnt_tx_context(struct vnt_private *priv,
struct vnt_usb_send_context *context,
struct sk_buff *skb)
{
struct vnt_tx_usb_header *usb;
struct urb *urb;
int status;
u16 count = skb->len;
usb = skb_push(skb, sizeof(*usb));
usb->tx_byte_count = cpu_to_le16(count);
usb->pkt_no = context->pkt_no;
usb->type = context->type;
if (test_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags)) {
context->in_use = false;
return -ENODEV;
}
if (skb->len > MAX_TOTAL_SIZE_WITH_ALL_HEADERS) {
context->in_use = false;
return -E2BIG;
}
urb = usb_alloc_urb(0, GFP_ATOMIC);
if (!urb) {
context->in_use = false;
return -ENOMEM;
}
usb_fill_bulk_urb(urb,
priv->usb,
usb_sndbulkpipe(priv->usb, 3),
skb->data,
skb->len,
vnt_tx_context_complete,
context);
usb_anchor_urb(urb, &priv->tx_submitted);
status = usb_submit_urb(urb, GFP_ATOMIC);
if (status) {
dev_dbg(&priv->usb->dev, "Submit Tx URB failed %d\n", status);
usb_unanchor_urb(urb);
context->in_use = false;
}
usb_free_urb(urb);
return status;
}
| linux-master | drivers/staging/vt6656/usbpipe.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: rf function code
*
* Author: Jerry Chen
*
* Date: Feb. 19, 2004
*
* Functions:
* vnt_rf_write_embedded - Embedded write RF register via MAC
*
* Revision History:
* RF_VT3226: RobertYu:20051111, VT3226C0 and before
* RF_VT3226D0: RobertYu:20051228
* RF_VT3342A0: RobertYu:20060609
*
*/
#include <linux/errno.h>
#include "mac.h"
#include "rf.h"
#include "baseband.h"
#include "usbpipe.h"
#define CB_AL2230_INIT_SEQ 15
#define CB_AL7230_INIT_SEQ 16
#define CB_VT3226_INIT_SEQ 11
#define CB_VT3342_INIT_SEQ 13
static u8 al2230_init_table[CB_AL2230_INIT_SEQ][3] = {
{0x03, 0xf7, 0x90},
{0x03, 0x33, 0x31},
{0x01, 0xb8, 0x02},
{0x00, 0xff, 0xf3},
{0x00, 0x05, 0xa4},
{0x0f, 0x4d, 0xc5},
{0x08, 0x05, 0xb6},
{0x01, 0x47, 0xc7},
{0x00, 0x06, 0x88},
{0x04, 0x03, 0xb9},
{0x00, 0xdb, 0xba},
{0x00, 0x09, 0x9b},
{0x0b, 0xdf, 0xfc},
{0x00, 0x00, 0x0d},
{0x00, 0x58, 0x0f}
};
static u8 al2230_channel_table0[CB_MAX_CHANNEL_24G][3] = {
{0x03, 0xf7, 0x90},
{0x03, 0xf7, 0x90},
{0x03, 0xe7, 0x90},
{0x03, 0xe7, 0x90},
{0x03, 0xf7, 0xa0},
{0x03, 0xf7, 0xa0},
{0x03, 0xe7, 0xa0},
{0x03, 0xe7, 0xa0},
{0x03, 0xf7, 0xb0},
{0x03, 0xf7, 0xb0},
{0x03, 0xe7, 0xb0},
{0x03, 0xe7, 0xb0},
{0x03, 0xf7, 0xc0},
{0x03, 0xe7, 0xc0}
};
static u8 al2230_channel_table1[CB_MAX_CHANNEL_24G][3] = {
{0x03, 0x33, 0x31},
{0x0b, 0x33, 0x31},
{0x03, 0x33, 0x31},
{0x0b, 0x33, 0x31},
{0x03, 0x33, 0x31},
{0x0b, 0x33, 0x31},
{0x03, 0x33, 0x31},
{0x0b, 0x33, 0x31},
{0x03, 0x33, 0x31},
{0x0b, 0x33, 0x31},
{0x03, 0x33, 0x31},
{0x0b, 0x33, 0x31},
{0x03, 0x33, 0x31},
{0x06, 0x66, 0x61}
};
static u8 vt3226_init_table[CB_VT3226_INIT_SEQ][3] = {
{0x03, 0xff, 0x80},
{0x02, 0x82, 0xa1},
{0x03, 0xc6, 0xa2},
{0x01, 0x97, 0x93},
{0x03, 0x66, 0x64},
{0x00, 0x61, 0xa5},
{0x01, 0x7b, 0xd6},
{0x00, 0x80, 0x17},
{0x03, 0xf8, 0x08},
{0x00, 0x02, 0x39},
{0x02, 0x00, 0x2a}
};
static u8 vt3226d0_init_table[CB_VT3226_INIT_SEQ][3] = {
{0x03, 0xff, 0x80},
{0x03, 0x02, 0x21},
{0x03, 0xc6, 0xa2},
{0x01, 0x97, 0x93},
{0x03, 0x66, 0x64},
{0x00, 0x71, 0xa5},
{0x01, 0x15, 0xc6},
{0x01, 0x2e, 0x07},
{0x00, 0x58, 0x08},
{0x00, 0x02, 0x79},
{0x02, 0x01, 0xaa}
};
static u8 vt3226_channel_table0[CB_MAX_CHANNEL_24G][3] = {
{0x01, 0x97, 0x83},
{0x01, 0x97, 0x83},
{0x01, 0x97, 0x93},
{0x01, 0x97, 0x93},
{0x01, 0x97, 0x93},
{0x01, 0x97, 0x93},
{0x01, 0x97, 0xa3},
{0x01, 0x97, 0xa3},
{0x01, 0x97, 0xa3},
{0x01, 0x97, 0xa3},
{0x01, 0x97, 0xb3},
{0x01, 0x97, 0xb3},
{0x01, 0x97, 0xb3},
{0x03, 0x37, 0xc3}
};
static u8 vt3226_channel_table1[CB_MAX_CHANNEL_24G][3] = {
{0x02, 0x66, 0x64},
{0x03, 0x66, 0x64},
{0x00, 0x66, 0x64},
{0x01, 0x66, 0x64},
{0x02, 0x66, 0x64},
{0x03, 0x66, 0x64},
{0x00, 0x66, 0x64},
{0x01, 0x66, 0x64},
{0x02, 0x66, 0x64},
{0x03, 0x66, 0x64},
{0x00, 0x66, 0x64},
{0x01, 0x66, 0x64},
{0x02, 0x66, 0x64},
{0x00, 0xcc, 0xc4}
};
static const u32 vt3226d0_lo_current_table[CB_MAX_CHANNEL_24G] = {
0x0135c600,
0x0135c600,
0x0235c600,
0x0235c600,
0x0235c600,
0x0335c600,
0x0335c600,
0x0335c600,
0x0335c600,
0x0335c600,
0x0335c600,
0x0335c600,
0x0335c600,
0x0135c600
};
enum {
VNT_TABLE_INIT = 0,
VNT_TABLE_INIT_2 = 0,
VNT_TABLE_0 = 1,
VNT_TABLE_1 = 2,
VNT_TABLE_2 = 1
};
struct vnt_table_info {
u8 *addr;
int length;
};
static const struct vnt_table_info vnt_table_seq[][3] = {
{ /* RF_AL2230, RF_AL2230S init table, channel table 0 and 1 */
{&al2230_init_table[0][0], CB_AL2230_INIT_SEQ * 3},
{&al2230_channel_table0[0][0], CB_MAX_CHANNEL_24G * 3},
{&al2230_channel_table1[0][0], CB_MAX_CHANNEL_24G * 3}
}, { /* RF_VT3226 init table, channel table 0 and 1 */
{&vt3226_init_table[0][0], CB_VT3226_INIT_SEQ * 3},
{&vt3226_channel_table0[0][0], CB_MAX_CHANNEL_24G * 3},
{&vt3226_channel_table1[0][0], CB_MAX_CHANNEL_24G * 3}
}, { /* RF_VT3226D0 init table, channel table 0 and 1 */
{&vt3226d0_init_table[0][0], CB_VT3226_INIT_SEQ * 3},
{&vt3226_channel_table0[0][0], CB_MAX_CHANNEL_24G * 3},
{&vt3226_channel_table1[0][0], CB_MAX_CHANNEL_24G * 3}
}
};
/*
* Description: Write to IF/RF, by embedded programming
*/
int vnt_rf_write_embedded(struct vnt_private *priv, u32 data)
{
u8 reg_data[4];
data |= (VNT_RF_REG_LEN << 3) | IFREGCTL_REGW;
reg_data[0] = (u8)data;
reg_data[1] = (u8)(data >> 8);
reg_data[2] = (u8)(data >> 16);
reg_data[3] = (u8)(data >> 24);
return vnt_control_out(priv, MESSAGE_TYPE_WRITE_IFRF, 0, 0,
ARRAY_SIZE(reg_data), reg_data);
}
static u8 vnt_rf_addpower(struct vnt_private *priv)
{
int base;
s32 rssi = -priv->current_rssi;
if (!rssi)
return 7;
if (priv->rf_type == RF_VT3226D0)
base = -60;
else
base = -70;
if (rssi < base)
return ((rssi - base + 1) / -5) * 2 + 5;
return 0;
}
/* Set Tx power by power level and rate */
static int vnt_rf_set_txpower(struct vnt_private *priv, u8 power,
struct ieee80211_channel *ch)
{
u32 power_setting = 0;
int ret = 0;
power += vnt_rf_addpower(priv);
if (power > VNT_RF_MAX_POWER)
power = VNT_RF_MAX_POWER;
if (priv->power == power)
return 0;
priv->power = power;
switch (priv->rf_type) {
case RF_AL2230:
power_setting = 0x0404090 | (power << 12);
ret = vnt_rf_write_embedded(priv, power_setting);
if (ret)
return ret;
if (ch->flags & IEEE80211_CHAN_NO_OFDM)
ret = vnt_rf_write_embedded(priv, 0x0001b400);
else
ret = vnt_rf_write_embedded(priv, 0x0005a400);
break;
case RF_AL2230S:
power_setting = 0x0404090 | (power << 12);
ret = vnt_rf_write_embedded(priv, power_setting);
if (ret)
return ret;
if (ch->flags & IEEE80211_CHAN_NO_OFDM) {
ret = vnt_rf_write_embedded(priv, 0x040c1400);
if (ret)
return ret;
ret = vnt_rf_write_embedded(priv, 0x00299b00);
} else {
ret = vnt_rf_write_embedded(priv, 0x0005a400);
if (ret)
return ret;
ret = vnt_rf_write_embedded(priv, 0x00099b00);
}
break;
case RF_VT3226:
power_setting = ((0x3f - power) << 20) | (0x17 << 8);
ret = vnt_rf_write_embedded(priv, power_setting);
break;
case RF_VT3226D0:
if (ch->flags & IEEE80211_CHAN_NO_OFDM) {
u16 hw_value = ch->hw_value;
power_setting = ((0x3f - power) << 20) | (0xe07 << 8);
ret = vnt_rf_write_embedded(priv, power_setting);
if (ret)
return ret;
ret = vnt_rf_write_embedded(priv, 0x03c6a200);
if (ret)
return ret;
dev_dbg(&priv->usb->dev,
"%s 11b channel [%d]\n", __func__, hw_value);
hw_value--;
if (hw_value < ARRAY_SIZE(vt3226d0_lo_current_table)) {
ret = vnt_rf_write_embedded(priv,
vt3226d0_lo_current_table[hw_value]);
if (ret)
return ret;
}
ret = vnt_rf_write_embedded(priv, 0x015C0800);
} else {
dev_dbg(&priv->usb->dev,
"@@@@ %s> 11G mode\n", __func__);
power_setting = ((0x3f - power) << 20) | (0x7 << 8);
ret = vnt_rf_write_embedded(priv, power_setting);
if (ret)
return ret;
ret = vnt_rf_write_embedded(priv, 0x00C6A200);
if (ret)
return ret;
ret = vnt_rf_write_embedded(priv, 0x016BC600);
if (ret)
return ret;
ret = vnt_rf_write_embedded(priv, 0x00900800);
}
break;
default:
break;
}
return ret;
}
/* Set Tx power by channel number type */
int vnt_rf_setpower(struct vnt_private *priv,
struct ieee80211_channel *ch)
{
u16 channel;
u8 power = priv->cck_pwr;
if (!ch)
return -EINVAL;
/* set channel number to array number */
channel = ch->hw_value - 1;
if (ch->flags & IEEE80211_CHAN_NO_OFDM) {
if (channel < ARRAY_SIZE(priv->cck_pwr_tbl))
power = priv->cck_pwr_tbl[channel];
} else if (ch->band == NL80211_BAND_5GHZ) {
/* remove 14 channels to array size */
channel -= 14;
if (channel < ARRAY_SIZE(priv->ofdm_a_pwr_tbl))
power = priv->ofdm_a_pwr_tbl[channel];
} else {
if (channel < ARRAY_SIZE(priv->ofdm_pwr_tbl))
power = priv->ofdm_pwr_tbl[channel];
}
return vnt_rf_set_txpower(priv, power, ch);
}
/* Convert rssi to dbm */
void vnt_rf_rssi_to_dbm(struct vnt_private *priv, u8 rssi, long *dbm)
{
u8 idx = ((rssi & 0xc0) >> 6) & 0x03;
long b = rssi & 0x3f;
long a = 0;
u8 airoharf[4] = {0, 18, 0, 40};
switch (priv->rf_type) {
case RF_AL2230:
case RF_AL2230S:
case RF_VT3226:
case RF_VT3226D0:
a = airoharf[idx];
break;
default:
break;
}
*dbm = -1 * (a + b * 2);
}
int vnt_rf_table_download(struct vnt_private *priv)
{
int ret;
int idx = -1;
const struct vnt_table_info *table_seq;
switch (priv->rf_type) {
case RF_AL2230:
case RF_AL2230S:
idx = 0;
break;
case RF_VT3226:
idx = 1;
break;
case RF_VT3226D0:
idx = 2;
break;
}
if (idx < 0)
return 0;
table_seq = &vnt_table_seq[idx][0];
/* Init Table */
ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE, 0,
MESSAGE_REQUEST_RF_INIT,
table_seq[VNT_TABLE_INIT].length,
table_seq[VNT_TABLE_INIT].addr);
if (ret)
return ret;
/* Channel Table 0 */
ret = vnt_control_out_blocks(priv, VNT_REG_BLOCK_SIZE,
MESSAGE_REQUEST_RF_CH0,
table_seq[VNT_TABLE_0].length,
table_seq[VNT_TABLE_0].addr);
if (ret)
return ret;
/* Channel Table 1 */
ret = vnt_control_out_blocks(priv, VNT_REG_BLOCK_SIZE,
MESSAGE_REQUEST_RF_CH1,
table_seq[VNT_TABLE_1].length,
table_seq[VNT_TABLE_1].addr);
return ret;
}
| linux-master | drivers/staging/vt6656/rf.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: Provide functions to setup NIC operation mode
* Functions:
* vnt_set_rspinf - Set RSPINF
* vnt_update_ifs - Update slotTime,SIFS,DIFS, and EIFS
* vnt_update_top_rates - Update BasicTopRate
* vnt_add_basic_rate - Add to BasicRateSet
* vnt_ofdm_min_rate - Check if any OFDM rate is in BasicRateSet
* vnt_get_tsf_offset - Calculate TSFOffset
* vnt_get_next_tbtt - Calculate Next Beacon TSF counter
* vnt_reset_next_tbtt - Set NIC Beacon time
* vnt_update_next_tbtt - Sync. NIC Beacon time
* vnt_radio_power_off - Turn Off NIC Radio Power
* vnt_radio_power_on - Turn On NIC Radio Power
*
* Revision History:
* 06-10-2003 Bryan YC Fan: Re-write codes to support VT3253 spec.
* 08-26-2003 Kyle Hsu: Modify the definition type of dwIoBase.
* 09-01-2003 Bryan YC Fan: Add vnt_update_ifs().
*
*/
#include <linux/bitops.h>
#include <linux/errno.h>
#include "device.h"
#include "card.h"
#include "baseband.h"
#include "mac.h"
#include "desc.h"
#include "rf.h"
#include "power.h"
#include "key.h"
#include "usbpipe.h"
/* const u16 cw_rxbcntsf_off[MAX_RATE] =
* {17, 34, 96, 192, 34, 23, 17, 11, 8, 5, 4, 3};
*/
static const u16 cw_rxbcntsf_off[MAX_RATE] = {
192, 96, 34, 17, 34, 23, 17, 11, 8, 5, 4, 3
};
int vnt_set_channel(struct vnt_private *priv, u32 connection_channel)
{
int ret;
if (connection_channel > CB_MAX_CHANNEL || !connection_channel)
return -EINVAL;
/* clear NAV */
vnt_mac_reg_bits_on(priv, MAC_REG_MACCR, MACCR_CLRNAV);
/* Set Channel[7] = 0 to tell H/W channel is changing now. */
vnt_mac_reg_bits_off(priv, MAC_REG_CHANNEL,
(BIT(7) | BIT(5) | BIT(4)));
ret = vnt_control_out(priv, MESSAGE_TYPE_SELECT_CHANNEL,
connection_channel, 0, 0, NULL);
if (ret)
return ret;
return vnt_control_out_u8(priv, MESSAGE_REQUEST_MACREG, MAC_REG_CHANNEL,
(u8)(connection_channel | 0x80));
}
static const u8 vnt_rspinf_b_short_table[] = {
0x70, 0x00, 0x00, 0x00, 0x38, 0x00, 0x09, 0x00,
0x15, 0x00, 0x0a, 0x00, 0x0b, 0x00, 0x0b, 0x80
};
static const u8 vnt_rspinf_b_long_table[] = {
0x70, 0x00, 0x00, 0x00, 0x38, 0x00, 0x01, 0x00,
0x15, 0x00, 0x02, 0x00, 0x0b, 0x00, 0x03, 0x80
};
static const u8 vnt_rspinf_a_table[] = {
0x9b, 0x18, 0x9f, 0x10, 0x9a, 0x0a, 0x9e, 0x08, 0x99,
0x08, 0x9d, 0x04, 0x98, 0x04, 0x9c, 0x04, 0x9c, 0x04
};
static const u8 vnt_rspinf_gb_table[] = {
0x8b, 0x1e, 0x8f, 0x16, 0x8a, 0x12, 0x8e, 0x0e, 0x89,
0x0e, 0x8d, 0x0a, 0x88, 0x0a, 0x8c, 0x0a, 0x8c, 0x0a
};
int vnt_set_rspinf(struct vnt_private *priv, u8 bb_type)
{
const u8 *data;
u16 len;
int ret;
if (priv->preamble_type) {
data = vnt_rspinf_b_short_table;
len = ARRAY_SIZE(vnt_rspinf_b_short_table);
} else {
data = vnt_rspinf_b_long_table;
len = ARRAY_SIZE(vnt_rspinf_b_long_table);
}
/* RSPINF_b_1 to RSPINF_b_11 */
ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_RSPINF_B_1,
MESSAGE_REQUEST_MACREG, len, data);
if (ret)
return ret;
if (bb_type == BB_TYPE_11A) {
data = vnt_rspinf_a_table;
len = ARRAY_SIZE(vnt_rspinf_a_table);
} else {
data = vnt_rspinf_gb_table;
len = ARRAY_SIZE(vnt_rspinf_gb_table);
}
/* RSPINF_a_6 to RSPINF_a_72 */
return vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_RSPINF_A_6,
MESSAGE_REQUEST_MACREG, len, data);
}
int vnt_update_ifs(struct vnt_private *priv)
{
u8 max_min = 0;
u8 data[4];
int ret;
if (priv->packet_type == PK_TYPE_11A) {
priv->slot = C_SLOT_SHORT;
priv->sifs = C_SIFS_A;
priv->difs = C_SIFS_A + 2 * C_SLOT_SHORT;
max_min = 4;
} else {
priv->sifs = C_SIFS_BG;
if (priv->short_slot_time) {
priv->slot = C_SLOT_SHORT;
max_min = 4;
} else {
priv->slot = C_SLOT_LONG;
max_min = 5;
}
priv->difs = C_SIFS_BG + 2 * priv->slot;
}
priv->eifs = C_EIFS;
data[0] = (u8)priv->sifs;
data[1] = (u8)priv->difs;
data[2] = (u8)priv->eifs;
data[3] = (u8)priv->slot;
ret = vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_SIFS,
MESSAGE_REQUEST_MACREG, 4, &data[0]);
if (ret)
return ret;
max_min |= 0xa0;
return vnt_control_out(priv, MESSAGE_TYPE_WRITE, MAC_REG_CWMAXMIN0,
MESSAGE_REQUEST_MACREG, 1, &max_min);
}
void vnt_update_top_rates(struct vnt_private *priv)
{
int pos;
pos = fls(priv->basic_rates & GENMASK(RATE_54M, RATE_6M));
priv->top_ofdm_basic_rate = pos ? (pos - 1) : RATE_24M;
pos = fls(priv->basic_rates & GENMASK(RATE_11M, RATE_1M));
priv->top_cck_basic_rate = pos ? (pos - 1) : RATE_1M;
}
bool vnt_ofdm_min_rate(struct vnt_private *priv)
{
return priv->basic_rates & GENMASK(RATE_54M, RATE_6M) ? true : false;
}
u8 vnt_get_pkt_type(struct vnt_private *priv)
{
if (priv->bb_type == BB_TYPE_11A || priv->bb_type == BB_TYPE_11B)
return (u8)priv->bb_type;
else if (vnt_ofdm_min_rate(priv))
return PK_TYPE_11GA;
return PK_TYPE_11GB;
}
/*
* Description: Calculate TSF offset of two TSF input
* Get TSF Offset from RxBCN's TSF and local TSF
*
* Parameters:
* In:
* rx_rate - rx rate.
* tsf1 - Rx BCN's TSF
* tsf2 - Local TSF
* Out:
* none
*
* Return Value: TSF Offset value
*
*/
u64 vnt_get_tsf_offset(u8 rx_rate, u64 tsf1, u64 tsf2)
{
return tsf1 - tsf2 - (u64)cw_rxbcntsf_off[rx_rate % MAX_RATE];
}
int vnt_adjust_tsf(struct vnt_private *priv, u8 rx_rate,
u64 time_stamp, u64 local_tsf)
{
u64 tsf_offset = 0;
u8 data[8];
tsf_offset = vnt_get_tsf_offset(rx_rate, time_stamp, local_tsf);
data[0] = (u8)tsf_offset;
data[1] = (u8)(tsf_offset >> 8);
data[2] = (u8)(tsf_offset >> 16);
data[3] = (u8)(tsf_offset >> 24);
data[4] = (u8)(tsf_offset >> 32);
data[5] = (u8)(tsf_offset >> 40);
data[6] = (u8)(tsf_offset >> 48);
data[7] = (u8)(tsf_offset >> 56);
return vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT,
MESSAGE_REQUEST_TSF, 0, 8, data);
}
/*
* Description: Clear NIC TSF counter
* Clear local TSF counter
*
* Parameters:
* In:
* priv - The adapter to be read
*
* Return Value: true if success; otherwise false
*
*/
bool vnt_clear_current_tsf(struct vnt_private *priv)
{
vnt_mac_reg_bits_on(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTRST);
priv->current_tsf = 0;
return true;
}
/*
* Description: Read NIC TSF counter
* Get NEXTTBTT from adjusted TSF and Beacon Interval
*
* Parameters:
* In:
* tsf - Current TSF counter
* beacon_interval - Beacon Interval
* Out:
* tsf - Current TSF counter
*
* Return Value: TSF value of next Beacon
*
*/
u64 vnt_get_next_tbtt(u64 tsf, u16 beacon_interval)
{
u32 beacon_int;
beacon_int = beacon_interval * 1024;
/* Next TBTT =
* ((local_current_TSF / beacon_interval) + 1) * beacon_interval
*/
if (beacon_int) {
do_div(tsf, beacon_int);
tsf += 1;
tsf *= beacon_int;
}
return tsf;
}
int vnt_reset_next_tbtt(struct vnt_private *priv, u16 beacon_interval)
{
u64 next_tbtt = 0;
u8 data[8];
vnt_clear_current_tsf(priv);
next_tbtt = vnt_get_next_tbtt(next_tbtt, beacon_interval);
data[0] = (u8)next_tbtt;
data[1] = (u8)(next_tbtt >> 8);
data[2] = (u8)(next_tbtt >> 16);
data[3] = (u8)(next_tbtt >> 24);
data[4] = (u8)(next_tbtt >> 32);
data[5] = (u8)(next_tbtt >> 40);
data[6] = (u8)(next_tbtt >> 48);
data[7] = (u8)(next_tbtt >> 56);
return vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT,
MESSAGE_REQUEST_TBTT, 0, 8, data);
}
int vnt_update_next_tbtt(struct vnt_private *priv, u64 tsf,
u16 beacon_interval)
{
u8 data[8];
int ret;
tsf = vnt_get_next_tbtt(tsf, beacon_interval);
data[0] = (u8)tsf;
data[1] = (u8)(tsf >> 8);
data[2] = (u8)(tsf >> 16);
data[3] = (u8)(tsf >> 24);
data[4] = (u8)(tsf >> 32);
data[5] = (u8)(tsf >> 40);
data[6] = (u8)(tsf >> 48);
data[7] = (u8)(tsf >> 56);
ret = vnt_control_out(priv, MESSAGE_TYPE_SET_TSFTBTT,
MESSAGE_REQUEST_TBTT, 0, 8, data);
if (ret)
return ret;
dev_dbg(&priv->usb->dev, "%s TBTT: %8llx\n", __func__, tsf);
return 0;
}
/*
* Description: Turn off Radio power
*
* Parameters:
* In:
* priv - The adapter to be turned off
* Out:
* none
*
* Return Value: true if success; otherwise false
*
*/
int vnt_radio_power_off(struct vnt_private *priv)
{
int ret = 0;
switch (priv->rf_type) {
case RF_AL2230:
case RF_AL2230S:
case RF_VT3226:
case RF_VT3226D0:
ret = vnt_mac_reg_bits_off(priv, MAC_REG_SOFTPWRCTL,
(SOFTPWRCTL_SWPE2 |
SOFTPWRCTL_SWPE3));
break;
}
if (ret)
goto end;
ret = vnt_mac_reg_bits_off(priv, MAC_REG_HOSTCR, HOSTCR_RXON);
if (ret)
goto end;
ret = vnt_set_deep_sleep(priv);
if (ret)
goto end;
ret = vnt_mac_reg_bits_on(priv, MAC_REG_GPIOCTL1, GPIO3_INTMD);
end:
return ret;
}
/*
* Description: Turn on Radio power
*
* Parameters:
* In:
* priv - The adapter to be turned on
* Out:
* none
*
* Return Value: true if success; otherwise false
*
*/
int vnt_radio_power_on(struct vnt_private *priv)
{
int ret = 0;
ret = vnt_exit_deep_sleep(priv);
if (ret)
return ret;
ret = vnt_mac_reg_bits_on(priv, MAC_REG_HOSTCR, HOSTCR_RXON);
if (ret)
return ret;
switch (priv->rf_type) {
case RF_AL2230:
case RF_AL2230S:
case RF_VT3226:
case RF_VT3226D0:
ret = vnt_mac_reg_bits_on(priv, MAC_REG_SOFTPWRCTL,
(SOFTPWRCTL_SWPE2 |
SOFTPWRCTL_SWPE3));
if (ret)
return ret;
}
return vnt_mac_reg_bits_off(priv, MAC_REG_GPIOCTL1, GPIO3_INTMD);
}
int vnt_set_bss_mode(struct vnt_private *priv)
{
int ret;
unsigned char type = priv->bb_type;
unsigned char data = 0;
unsigned char bb_vga_2_3 = 0x00;
ret = vnt_mac_set_bb_type(priv, type);
if (ret)
return ret;
priv->packet_type = vnt_get_pkt_type(priv);
if (priv->bb_type == BB_TYPE_11A) {
data = 0x03;
bb_vga_2_3 = 0x10;
} else if (priv->bb_type == BB_TYPE_11B) {
data = 0x02;
} else if (priv->bb_type == BB_TYPE_11G) {
data = 0x08;
}
if (data) {
ret = vnt_control_out_u8(priv, MESSAGE_REQUEST_BBREG,
0x88, data);
if (ret)
return ret;
}
ret = vnt_update_ifs(priv);
if (ret)
return ret;
ret = vnt_set_rspinf(priv, priv->bb_type);
if (ret)
return ret;
priv->bb_vga[2] = bb_vga_2_3;
priv->bb_vga[3] = bb_vga_2_3;
return vnt_set_vga_gain_offset(priv, priv->bb_vga[0]);
}
| linux-master | drivers/staging/vt6656/card.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: Implement functions for 802.11i Key management
*
* Author: Jerry Chen
*
* Date: May 29, 2003
*
* Functions:
*
* Revision History:
*
*/
#include "mac.h"
#include "key.h"
#include "usbpipe.h"
int vnt_key_init_table(struct vnt_private *priv)
{
u8 i;
u8 data[MAX_KEY_TABLE];
for (i = 0; i < MAX_KEY_TABLE; i++)
data[i] = i;
return vnt_control_out(priv, MESSAGE_TYPE_CLRKEYENTRY,
0, 0, ARRAY_SIZE(data), data);
}
static int vnt_set_keymode(struct ieee80211_hw *hw, u8 *mac_addr,
struct ieee80211_key_conf *key, u32 key_type,
u32 mode)
{
struct vnt_private *priv = hw->priv;
u8 broadcast[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
u16 key_mode = 0;
u32 entry = 0;
u8 *bssid;
u8 key_inx = key->keyidx;
u8 i;
if (mac_addr)
bssid = mac_addr;
else
bssid = &broadcast[0];
if (key_type != VNT_KEY_DEFAULTKEY) {
for (i = 0; i < (MAX_KEY_TABLE - 1); i++) {
if (!test_bit(i, &priv->key_entry_inuse)) {
set_bit(i, &priv->key_entry_inuse);
key->hw_key_idx = i;
entry = key->hw_key_idx;
break;
}
}
}
switch (key_type) {
case VNT_KEY_DEFAULTKEY:
/* default key last entry */
entry = MAX_KEY_TABLE - 1;
key->hw_key_idx = entry;
fallthrough;
case VNT_KEY_GROUP_ADDRESS:
key_mode = mode | (mode << 4);
break;
case VNT_KEY_GROUP:
key_mode = mode << 4;
break;
case VNT_KEY_PAIRWISE:
key_mode |= mode;
key_inx = 4;
break;
default:
return -EINVAL;
}
key_mode |= key_type;
if (mode == KEY_CTL_WEP) {
if (key->keylen == WLAN_KEY_LEN_WEP40)
key->key[15] &= 0x7f;
if (key->keylen == WLAN_KEY_LEN_WEP104)
key->key[15] |= 0x80;
}
return vnt_mac_set_keyentry(priv, key_mode, entry,
key_inx, bssid, key->key);
}
int vnt_set_keys(struct ieee80211_hw *hw, struct ieee80211_sta *sta,
struct ieee80211_vif *vif, struct ieee80211_key_conf *key)
{
struct vnt_private *priv = hw->priv;
u8 *mac_addr = NULL;
u8 key_dec_mode = 0;
if (sta)
mac_addr = &sta->addr[0];
switch (key->cipher) {
case WLAN_CIPHER_SUITE_WEP40:
case WLAN_CIPHER_SUITE_WEP104:
vnt_set_keymode(hw, mac_addr, key, VNT_KEY_DEFAULTKEY,
KEY_CTL_WEP);
key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
return vnt_set_keymode(hw, mac_addr, key, VNT_KEY_DEFAULTKEY,
KEY_CTL_WEP);
case WLAN_CIPHER_SUITE_TKIP:
key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
key_dec_mode = KEY_CTL_TKIP;
break;
case WLAN_CIPHER_SUITE_CCMP:
if (priv->local_id <= MAC_REVISION_A1)
return -EOPNOTSUPP;
key_dec_mode = KEY_CTL_CCMP;
key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
break;
default:
return -EOPNOTSUPP;
}
if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
return vnt_set_keymode(hw, mac_addr, key, VNT_KEY_PAIRWISE,
key_dec_mode);
return vnt_set_keymode(hw, mac_addr, key,
VNT_KEY_GROUP_ADDRESS, key_dec_mode);
}
| linux-master | drivers/staging/vt6656/key.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 1996, 2003 VIA Networking Technologies, Inc.
* All rights reserved.
*
* Purpose: driver entry for initial, open, close, tx and rx.
*
* Author: Lyndon Chen
*
* Date: Dec 8, 2005
*
* Functions:
*
* vt6656_probe - module initial (insmod) driver entry
* vnt_free_tx_bufs - free tx buffer function
* vnt_init_registers- initial MAC & BBP & RF internal registers.
*
* Revision History:
*/
#undef __NO_VERSION__
#include <linux/bits.h>
#include <linux/etherdevice.h>
#include <linux/file.h>
#include <linux/kernel.h>
#include "device.h"
#include "card.h"
#include "baseband.h"
#include "mac.h"
#include "power.h"
#include "wcmd.h"
#include "rxtx.h"
#include "rf.h"
#include "usbpipe.h"
#include "channel.h"
/*
* define module options
*/
/* version information */
#define DRIVER_AUTHOR \
"VIA Networking Technologies, Inc., <[email protected]>"
MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION(DEVICE_FULL_DRV_NAM);
#define RX_DESC_DEF0 64
static int vnt_rx_buffers = RX_DESC_DEF0;
module_param_named(rx_buffers, vnt_rx_buffers, int, 0644);
MODULE_PARM_DESC(rx_buffers, "Number of receive usb rx buffers");
#define TX_DESC_DEF0 64
static int vnt_tx_buffers = TX_DESC_DEF0;
module_param_named(tx_buffers, vnt_tx_buffers, int, 0644);
MODULE_PARM_DESC(tx_buffers, "Number of receive usb tx buffers");
#define RTS_THRESH_DEF 2347
#define FRAG_THRESH_DEF 2346
/* BasebandType[] baseband type selected
* 0: indicate 802.11a type
* 1: indicate 802.11b type
* 2: indicate 802.11g type
*/
#define BBP_TYPE_DEF 2
/*
* Static vars definitions
*/
static const struct usb_device_id vt6656_table[] = {
{USB_DEVICE(VNT_USB_VENDOR_ID, VNT_USB_PRODUCT_ID)},
{}
};
static void vnt_set_options(struct vnt_private *priv)
{
/* Set number of TX buffers */
if (vnt_tx_buffers < CB_MIN_TX_DESC || vnt_tx_buffers > CB_MAX_TX_DESC)
priv->num_tx_context = TX_DESC_DEF0;
else
priv->num_tx_context = vnt_tx_buffers;
/* Set number of RX buffers */
if (vnt_rx_buffers < CB_MIN_RX_DESC || vnt_rx_buffers > CB_MAX_RX_DESC)
priv->num_rcb = RX_DESC_DEF0;
else
priv->num_rcb = vnt_rx_buffers;
priv->op_mode = NL80211_IFTYPE_UNSPECIFIED;
priv->bb_type = BBP_TYPE_DEF;
priv->packet_type = priv->bb_type;
priv->preamble_type = PREAMBLE_LONG;
priv->exist_sw_net_addr = false;
}
static int vnt_download_firmware(struct vnt_private *priv)
{
struct device *dev = &priv->usb->dev;
const struct firmware *fw;
u16 length;
int ii;
int ret = 0;
dev_dbg(dev, "---->Download firmware\n");
ret = request_firmware(&fw, FIRMWARE_NAME, dev);
if (ret) {
dev_err(dev, "firmware file %s request failed (%d)\n",
FIRMWARE_NAME, ret);
goto end;
}
for (ii = 0; ii < fw->size; ii += FIRMWARE_CHUNK_SIZE) {
length = min_t(int, fw->size - ii, FIRMWARE_CHUNK_SIZE);
ret = vnt_control_out(priv, 0, 0x1200 + ii, 0x0000, length,
fw->data + ii);
if (ret)
goto free_fw;
dev_dbg(dev, "Download firmware...%d %zu\n", ii, fw->size);
}
free_fw:
release_firmware(fw);
end:
return ret;
}
static int vnt_firmware_branch_to_sram(struct vnt_private *priv)
{
dev_dbg(&priv->usb->dev, "---->Branch to Sram\n");
return vnt_control_out(priv, 1, 0x1200, 0x0000, 0, NULL);
}
static int vnt_check_firmware_version(struct vnt_private *priv)
{
int ret = 0;
ret = vnt_control_in(priv, MESSAGE_TYPE_READ, 0,
MESSAGE_REQUEST_VERSION, 2,
(u8 *)&priv->firmware_version);
if (ret) {
dev_dbg(&priv->usb->dev,
"Could not get firmware version: %d.\n", ret);
goto end;
}
dev_dbg(&priv->usb->dev, "Firmware Version [%04x]\n",
priv->firmware_version);
if (priv->firmware_version == 0xFFFF) {
dev_dbg(&priv->usb->dev, "In Loader.\n");
ret = -EINVAL;
goto end;
}
if (priv->firmware_version < FIRMWARE_VERSION) {
/* branch to loader for download new firmware */
ret = vnt_firmware_branch_to_sram(priv);
if (ret) {
dev_dbg(&priv->usb->dev,
"Could not branch to SRAM: %d.\n", ret);
} else {
ret = -EINVAL;
}
}
end:
return ret;
}
/*
* initialization of MAC & BBP registers
*/
static int vnt_init_registers(struct vnt_private *priv)
{
int ret;
struct vnt_cmd_card_init *init_cmd = &priv->init_command;
struct vnt_rsp_card_init *init_rsp = &priv->init_response;
u8 antenna;
int ii;
u8 tmp;
u8 calib_tx_iq = 0, calib_tx_dc = 0, calib_rx_iq = 0;
dev_dbg(&priv->usb->dev, "---->INIbInitAdapter. [%d][%d]\n",
DEVICE_INIT_COLD, priv->packet_type);
ret = vnt_check_firmware_version(priv);
if (ret) {
ret = vnt_download_firmware(priv);
if (ret) {
dev_dbg(&priv->usb->dev,
"Could not download firmware: %d.\n", ret);
goto end;
}
ret = vnt_firmware_branch_to_sram(priv);
if (ret) {
dev_dbg(&priv->usb->dev,
"Could not branch to SRAM: %d.\n", ret);
goto end;
}
}
ret = vnt_vt3184_init(priv);
if (ret) {
dev_dbg(&priv->usb->dev, "vnt_vt3184_init fail\n");
goto end;
}
init_cmd->init_class = DEVICE_INIT_COLD;
init_cmd->exist_sw_net_addr = priv->exist_sw_net_addr;
for (ii = 0; ii < ARRAY_SIZE(init_cmd->sw_net_addr); ii++)
init_cmd->sw_net_addr[ii] = priv->current_net_addr[ii];
init_cmd->short_retry_limit = priv->hw->wiphy->retry_short;
init_cmd->long_retry_limit = priv->hw->wiphy->retry_long;
/* issue card_init command to device */
ret = vnt_control_out(priv, MESSAGE_TYPE_CARDINIT, 0, 0,
sizeof(struct vnt_cmd_card_init),
(u8 *)init_cmd);
if (ret) {
dev_dbg(&priv->usb->dev, "Issue Card init fail\n");
goto end;
}
ret = vnt_control_in(priv, MESSAGE_TYPE_INIT_RSP, 0, 0,
sizeof(struct vnt_rsp_card_init),
(u8 *)init_rsp);
if (ret) {
dev_dbg(&priv->usb->dev, "Cardinit request in status fail!\n");
goto end;
}
/* local ID for AES functions */
ret = vnt_control_in(priv, MESSAGE_TYPE_READ, MAC_REG_LOCALID,
MESSAGE_REQUEST_MACREG, 1, &priv->local_id);
if (ret)
goto end;
/* do MACbSoftwareReset in MACvInitialize */
priv->top_ofdm_basic_rate = RATE_24M;
priv->top_cck_basic_rate = RATE_1M;
/* target to IF pin while programming to RF chip */
priv->power = 0xFF;
priv->cck_pwr = priv->eeprom[EEP_OFS_PWR_CCK];
priv->ofdm_pwr_g = priv->eeprom[EEP_OFS_PWR_OFDMG];
/* load power table */
for (ii = 0; ii < ARRAY_SIZE(priv->cck_pwr_tbl); ii++) {
priv->cck_pwr_tbl[ii] =
priv->eeprom[ii + EEP_OFS_CCK_PWR_TBL];
if (priv->cck_pwr_tbl[ii] == 0)
priv->cck_pwr_tbl[ii] = priv->cck_pwr;
priv->ofdm_pwr_tbl[ii] =
priv->eeprom[ii + EEP_OFS_OFDM_PWR_TBL];
if (priv->ofdm_pwr_tbl[ii] == 0)
priv->ofdm_pwr_tbl[ii] = priv->ofdm_pwr_g;
}
/*
* original zonetype is USA, but custom zonetype is Europe,
* then need to recover 12, 13, 14 channels with 11 channel
*/
for (ii = 11; ii < ARRAY_SIZE(priv->cck_pwr_tbl); ii++) {
priv->cck_pwr_tbl[ii] = priv->cck_pwr_tbl[10];
priv->ofdm_pwr_tbl[ii] = priv->ofdm_pwr_tbl[10];
}
priv->ofdm_pwr_a = 0x34; /* same as RFbMA2829SelectChannel */
/* load OFDM A power table */
for (ii = 0; ii < CB_MAX_CHANNEL_5G; ii++) {
priv->ofdm_a_pwr_tbl[ii] =
priv->eeprom[ii + EEP_OFS_OFDMA_PWR_TBL];
if (priv->ofdm_a_pwr_tbl[ii] == 0)
priv->ofdm_a_pwr_tbl[ii] = priv->ofdm_pwr_a;
}
antenna = priv->eeprom[EEP_OFS_ANTENNA];
if (antenna & EEP_ANTINV)
priv->tx_rx_ant_inv = true;
else
priv->tx_rx_ant_inv = false;
antenna &= (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
if (antenna == 0) /* if not set default is both */
antenna = (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN);
if (antenna == (EEP_ANTENNA_AUX | EEP_ANTENNA_MAIN)) {
priv->tx_antenna_mode = ANT_B;
priv->rx_antenna_sel = 1;
if (priv->tx_rx_ant_inv)
priv->rx_antenna_mode = ANT_A;
else
priv->rx_antenna_mode = ANT_B;
} else {
priv->rx_antenna_sel = 0;
if (antenna & EEP_ANTENNA_AUX) {
priv->tx_antenna_mode = ANT_A;
if (priv->tx_rx_ant_inv)
priv->rx_antenna_mode = ANT_B;
else
priv->rx_antenna_mode = ANT_A;
} else {
priv->tx_antenna_mode = ANT_B;
if (priv->tx_rx_ant_inv)
priv->rx_antenna_mode = ANT_A;
else
priv->rx_antenna_mode = ANT_B;
}
}
/* Set initial antenna mode */
ret = vnt_set_antenna_mode(priv, priv->rx_antenna_mode);
if (ret)
goto end;
/* default Auto Mode */
priv->bb_type = BB_TYPE_11G;
/* get RFType */
priv->rf_type = init_rsp->rf_type;
/* load vt3266 calibration parameters in EEPROM */
if (priv->rf_type == RF_VT3226D0) {
if ((priv->eeprom[EEP_OFS_MAJOR_VER] == 0x1) &&
(priv->eeprom[EEP_OFS_MINOR_VER] >= 0x4)) {
calib_tx_iq = priv->eeprom[EEP_OFS_CALIB_TX_IQ];
calib_tx_dc = priv->eeprom[EEP_OFS_CALIB_TX_DC];
calib_rx_iq = priv->eeprom[EEP_OFS_CALIB_RX_IQ];
if (calib_tx_iq || calib_tx_dc || calib_rx_iq) {
/* CR255, enable TX/RX IQ and
* DC compensation mode
*/
ret = vnt_control_out_u8(priv,
MESSAGE_REQUEST_BBREG,
0xff, 0x03);
if (ret)
goto end;
/* CR251, TX I/Q Imbalance Calibration */
ret = vnt_control_out_u8(priv,
MESSAGE_REQUEST_BBREG,
0xfb, calib_tx_iq);
if (ret)
goto end;
/* CR252, TX DC-Offset Calibration */
ret = vnt_control_out_u8(priv,
MESSAGE_REQUEST_BBREG,
0xfC, calib_tx_dc);
if (ret)
goto end;
/* CR253, RX I/Q Imbalance Calibration */
ret = vnt_control_out_u8(priv,
MESSAGE_REQUEST_BBREG,
0xfd, calib_rx_iq);
if (ret)
goto end;
} else {
/* CR255, turn off
* BB Calibration compensation
*/
ret = vnt_control_out_u8(priv,
MESSAGE_REQUEST_BBREG,
0xff, 0x0);
if (ret)
goto end;
}
}
}
/* get permanent network address */
memcpy(priv->permanent_net_addr, init_rsp->net_addr, 6);
ether_addr_copy(priv->current_net_addr, priv->permanent_net_addr);
/* if exist SW network address, use it */
dev_dbg(&priv->usb->dev, "Network address = %pM\n",
priv->current_net_addr);
priv->radio_ctl = priv->eeprom[EEP_OFS_RADIOCTL];
if ((priv->radio_ctl & EEP_RADIOCTL_ENABLE) != 0) {
ret = vnt_control_in(priv, MESSAGE_TYPE_READ,
MAC_REG_GPIOCTL1, MESSAGE_REQUEST_MACREG,
1, &tmp);
if (ret)
goto end;
if ((tmp & GPIO3_DATA) == 0) {
ret = vnt_mac_reg_bits_on(priv, MAC_REG_GPIOCTL1,
GPIO3_INTMD);
} else {
ret = vnt_mac_reg_bits_off(priv, MAC_REG_GPIOCTL1,
GPIO3_INTMD);
}
if (ret)
goto end;
}
ret = vnt_mac_set_led(priv, LEDSTS_TMLEN, 0x38);
if (ret)
goto end;
ret = vnt_mac_set_led(priv, LEDSTS_STS, LEDSTS_SLOW);
if (ret)
goto end;
ret = vnt_mac_reg_bits_on(priv, MAC_REG_GPIOCTL0, BIT(0));
if (ret)
goto end;
ret = vnt_radio_power_on(priv);
if (ret)
goto end;
dev_dbg(&priv->usb->dev, "<----INIbInitAdapter Exit\n");
end:
return ret;
}
static void vnt_free_tx_bufs(struct vnt_private *priv)
{
struct vnt_usb_send_context *tx_context;
int ii;
usb_kill_anchored_urbs(&priv->tx_submitted);
for (ii = 0; ii < priv->num_tx_context; ii++) {
tx_context = priv->tx_context[ii];
if (!tx_context)
continue;
kfree(tx_context);
}
}
static void vnt_free_rx_bufs(struct vnt_private *priv)
{
struct vnt_rcb *rcb;
int ii;
for (ii = 0; ii < priv->num_rcb; ii++) {
rcb = priv->rcb[ii];
if (!rcb)
continue;
/* deallocate URBs */
if (rcb->urb) {
usb_kill_urb(rcb->urb);
usb_free_urb(rcb->urb);
}
/* deallocate skb */
if (rcb->skb)
dev_kfree_skb(rcb->skb);
kfree(rcb);
}
}
static void vnt_free_int_bufs(struct vnt_private *priv)
{
kfree(priv->int_buf.data_buf);
}
static int vnt_alloc_bufs(struct vnt_private *priv)
{
int ret;
struct vnt_usb_send_context *tx_context;
struct vnt_rcb *rcb;
int ii;
init_usb_anchor(&priv->tx_submitted);
for (ii = 0; ii < priv->num_tx_context; ii++) {
tx_context = kmalloc(sizeof(*tx_context), GFP_KERNEL);
if (!tx_context) {
ret = -ENOMEM;
goto free_tx;
}
priv->tx_context[ii] = tx_context;
tx_context->priv = priv;
tx_context->pkt_no = ii;
tx_context->in_use = false;
}
for (ii = 0; ii < priv->num_rcb; ii++) {
priv->rcb[ii] = kzalloc(sizeof(*priv->rcb[ii]), GFP_KERNEL);
if (!priv->rcb[ii]) {
ret = -ENOMEM;
goto free_rx_tx;
}
rcb = priv->rcb[ii];
rcb->priv = priv;
/* allocate URBs */
rcb->urb = usb_alloc_urb(0, GFP_KERNEL);
if (!rcb->urb) {
ret = -ENOMEM;
goto free_rx_tx;
}
rcb->skb = dev_alloc_skb(priv->rx_buf_sz);
if (!rcb->skb) {
ret = -ENOMEM;
goto free_rx_tx;
}
/* submit rx urb */
ret = vnt_submit_rx_urb(priv, rcb);
if (ret)
goto free_rx_tx;
}
priv->interrupt_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!priv->interrupt_urb) {
ret = -ENOMEM;
goto free_rx_tx;
}
priv->int_buf.data_buf = kmalloc(MAX_INTERRUPT_SIZE, GFP_KERNEL);
if (!priv->int_buf.data_buf) {
ret = -ENOMEM;
goto free_rx_tx_urb;
}
return 0;
free_rx_tx_urb:
usb_free_urb(priv->interrupt_urb);
free_rx_tx:
vnt_free_rx_bufs(priv);
free_tx:
vnt_free_tx_bufs(priv);
return ret;
}
static void vnt_tx_80211(struct ieee80211_hw *hw,
struct ieee80211_tx_control *control,
struct sk_buff *skb)
{
struct vnt_private *priv = hw->priv;
if (vnt_tx_packet(priv, skb))
ieee80211_free_txskb(hw, skb);
}
static int vnt_start(struct ieee80211_hw *hw)
{
int ret;
struct vnt_private *priv = hw->priv;
priv->rx_buf_sz = MAX_TOTAL_SIZE_WITH_ALL_HEADERS;
ret = vnt_alloc_bufs(priv);
if (ret) {
dev_dbg(&priv->usb->dev, "vnt_alloc_bufs fail...\n");
goto err;
}
clear_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags);
ret = vnt_init_registers(priv);
if (ret) {
dev_dbg(&priv->usb->dev, " init register fail\n");
goto free_all;
}
ret = vnt_key_init_table(priv);
if (ret)
goto free_all;
priv->int_interval = 1; /* bInterval is set to 1 */
ret = vnt_start_interrupt_urb(priv);
if (ret)
goto free_all;
ieee80211_wake_queues(hw);
return 0;
free_all:
vnt_free_rx_bufs(priv);
vnt_free_tx_bufs(priv);
vnt_free_int_bufs(priv);
usb_kill_urb(priv->interrupt_urb);
usb_free_urb(priv->interrupt_urb);
err:
return ret;
}
static void vnt_stop(struct ieee80211_hw *hw)
{
struct vnt_private *priv = hw->priv;
int i;
if (!priv)
return;
for (i = 0; i < MAX_KEY_TABLE; i++)
vnt_mac_disable_keyentry(priv, i);
/* clear all keys */
priv->key_entry_inuse = 0;
if (!test_bit(DEVICE_FLAGS_UNPLUG, &priv->flags))
vnt_mac_shutdown(priv);
ieee80211_stop_queues(hw);
set_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags);
cancel_delayed_work_sync(&priv->run_command_work);
priv->cmd_running = false;
vnt_free_tx_bufs(priv);
vnt_free_rx_bufs(priv);
vnt_free_int_bufs(priv);
usb_kill_urb(priv->interrupt_urb);
usb_free_urb(priv->interrupt_urb);
}
static int vnt_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
{
struct vnt_private *priv = hw->priv;
priv->vif = vif;
switch (vif->type) {
case NL80211_IFTYPE_STATION:
break;
case NL80211_IFTYPE_ADHOC:
vnt_mac_reg_bits_off(priv, MAC_REG_RCR, RCR_UNICAST);
vnt_mac_reg_bits_on(priv, MAC_REG_HOSTCR, HOSTCR_ADHOC);
break;
case NL80211_IFTYPE_AP:
vnt_mac_reg_bits_off(priv, MAC_REG_RCR, RCR_UNICAST);
vnt_mac_reg_bits_on(priv, MAC_REG_HOSTCR, HOSTCR_AP);
break;
default:
return -EOPNOTSUPP;
}
priv->op_mode = vif->type;
/* LED blink on TX */
vnt_mac_set_led(priv, LEDSTS_STS, LEDSTS_INTER);
return 0;
}
static void vnt_remove_interface(struct ieee80211_hw *hw,
struct ieee80211_vif *vif)
{
struct vnt_private *priv = hw->priv;
switch (vif->type) {
case NL80211_IFTYPE_STATION:
break;
case NL80211_IFTYPE_ADHOC:
vnt_mac_reg_bits_off(priv, MAC_REG_TCR, TCR_AUTOBCNTX);
vnt_mac_reg_bits_off(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
vnt_mac_reg_bits_off(priv, MAC_REG_HOSTCR, HOSTCR_ADHOC);
break;
case NL80211_IFTYPE_AP:
vnt_mac_reg_bits_off(priv, MAC_REG_TCR, TCR_AUTOBCNTX);
vnt_mac_reg_bits_off(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
vnt_mac_reg_bits_off(priv, MAC_REG_HOSTCR, HOSTCR_AP);
break;
default:
break;
}
vnt_radio_power_off(priv);
priv->op_mode = NL80211_IFTYPE_UNSPECIFIED;
/* LED slow blink */
vnt_mac_set_led(priv, LEDSTS_STS, LEDSTS_SLOW);
}
static int vnt_config(struct ieee80211_hw *hw, u32 changed)
{
struct vnt_private *priv = hw->priv;
struct ieee80211_conf *conf = &hw->conf;
if (changed & IEEE80211_CONF_CHANGE_PS) {
if (conf->flags & IEEE80211_CONF_PS)
vnt_enable_power_saving(priv, conf->listen_interval);
else
vnt_disable_power_saving(priv);
}
if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) ||
(conf->flags & IEEE80211_CONF_OFFCHANNEL)) {
vnt_set_channel(priv, conf->chandef.chan->hw_value);
if (conf->chandef.chan->band == NL80211_BAND_5GHZ)
priv->bb_type = BB_TYPE_11A;
else
priv->bb_type = BB_TYPE_11G;
}
if (changed & IEEE80211_CONF_CHANGE_POWER)
vnt_rf_setpower(priv, conf->chandef.chan);
if (conf->flags & (IEEE80211_CONF_OFFCHANNEL | IEEE80211_CONF_IDLE))
/* Set max sensitivity*/
vnt_update_pre_ed_threshold(priv, true);
else
vnt_update_pre_ed_threshold(priv, false);
return 0;
}
static void vnt_bss_info_changed(struct ieee80211_hw *hw,
struct ieee80211_vif *vif,
struct ieee80211_bss_conf *conf, u64 changed)
{
struct vnt_private *priv = hw->priv;
priv->current_aid = vif->cfg.aid;
if (changed & BSS_CHANGED_BSSID && conf->bssid)
vnt_mac_set_bssid_addr(priv, (u8 *)conf->bssid);
if (changed & BSS_CHANGED_BASIC_RATES) {
priv->basic_rates = conf->basic_rates;
vnt_update_top_rates(priv);
dev_dbg(&priv->usb->dev, "basic rates %x\n", conf->basic_rates);
}
if (changed & BSS_CHANGED_ERP_PREAMBLE) {
if (conf->use_short_preamble) {
vnt_mac_enable_barker_preamble_mode(priv);
priv->preamble_type = PREAMBLE_SHORT;
} else {
vnt_mac_disable_barker_preamble_mode(priv);
priv->preamble_type = PREAMBLE_LONG;
}
}
if (changed & BSS_CHANGED_ERP_CTS_PROT) {
if (conf->use_cts_prot)
vnt_mac_enable_protect_mode(priv);
else
vnt_mac_disable_protect_mode(priv);
}
if (changed & BSS_CHANGED_ERP_SLOT) {
if (conf->use_short_slot)
priv->short_slot_time = true;
else
priv->short_slot_time = false;
vnt_set_short_slot_time(priv);
vnt_set_vga_gain_offset(priv, priv->bb_vga[0]);
}
if (changed & (BSS_CHANGED_BASIC_RATES | BSS_CHANGED_ERP_PREAMBLE |
BSS_CHANGED_ERP_SLOT))
vnt_set_bss_mode(priv);
if (changed & (BSS_CHANGED_TXPOWER | BSS_CHANGED_BANDWIDTH))
vnt_rf_setpower(priv, conf->chandef.chan);
if (changed & BSS_CHANGED_BEACON_ENABLED) {
dev_dbg(&priv->usb->dev,
"Beacon enable %d\n", conf->enable_beacon);
if (conf->enable_beacon) {
vnt_beacon_enable(priv, vif, conf);
vnt_mac_reg_bits_on(priv, MAC_REG_TCR, TCR_AUTOBCNTX);
} else {
vnt_mac_reg_bits_off(priv, MAC_REG_TCR, TCR_AUTOBCNTX);
}
}
if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INFO) &&
priv->op_mode != NL80211_IFTYPE_AP) {
if (vif->cfg.assoc && conf->beacon_rate) {
u16 ps_beacon_int = conf->beacon_int;
if (conf->dtim_period)
ps_beacon_int *= conf->dtim_period;
else if (hw->conf.listen_interval)
ps_beacon_int *= hw->conf.listen_interval;
vnt_mac_reg_bits_on(priv, MAC_REG_TFTCTL,
TFTCTL_TSFCNTREN);
vnt_mac_set_beacon_interval(priv, ps_beacon_int);
vnt_reset_next_tbtt(priv, conf->beacon_int);
vnt_adjust_tsf(priv, conf->beacon_rate->hw_value,
conf->sync_tsf, priv->current_tsf);
vnt_update_next_tbtt(priv,
conf->sync_tsf, ps_beacon_int);
} else {
vnt_clear_current_tsf(priv);
vnt_mac_reg_bits_off(priv, MAC_REG_TFTCTL,
TFTCTL_TSFCNTREN);
}
}
}
static u64 vnt_prepare_multicast(struct ieee80211_hw *hw,
struct netdev_hw_addr_list *mc_list)
{
struct vnt_private *priv = hw->priv;
struct netdev_hw_addr *ha;
u64 mc_filter = 0;
u32 bit_nr;
netdev_hw_addr_list_for_each(ha, mc_list) {
bit_nr = ether_crc(ETH_ALEN, ha->addr) >> 26;
mc_filter |= BIT_ULL(bit_nr);
}
priv->mc_list_count = mc_list->count;
return mc_filter;
}
static void vnt_configure(struct ieee80211_hw *hw,
unsigned int changed_flags,
unsigned int *total_flags, u64 multicast)
{
struct vnt_private *priv = hw->priv;
u8 rx_mode = 0;
*total_flags &= FIF_ALLMULTI | FIF_OTHER_BSS | FIF_BCN_PRBRESP_PROMISC;
vnt_control_in(priv, MESSAGE_TYPE_READ, MAC_REG_RCR,
MESSAGE_REQUEST_MACREG, sizeof(u8), &rx_mode);
dev_dbg(&priv->usb->dev, "rx mode in = %x\n", rx_mode);
if (changed_flags & FIF_ALLMULTI) {
if (*total_flags & FIF_ALLMULTI) {
if (priv->mc_list_count > 2)
vnt_mac_set_filter(priv, ~0);
else
vnt_mac_set_filter(priv, multicast);
rx_mode |= RCR_MULTICAST | RCR_BROADCAST;
} else {
rx_mode &= ~(RCR_MULTICAST | RCR_BROADCAST);
}
}
if (changed_flags & (FIF_OTHER_BSS | FIF_BCN_PRBRESP_PROMISC)) {
if (*total_flags & (FIF_OTHER_BSS | FIF_BCN_PRBRESP_PROMISC))
rx_mode &= ~RCR_BSSID;
else
rx_mode |= RCR_BSSID;
}
vnt_control_out_u8(priv, MESSAGE_REQUEST_MACREG, MAC_REG_RCR, rx_mode);
dev_dbg(&priv->usb->dev, "rx mode out= %x\n", rx_mode);
}
static int vnt_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
struct ieee80211_vif *vif, struct ieee80211_sta *sta,
struct ieee80211_key_conf *key)
{
struct vnt_private *priv = hw->priv;
switch (cmd) {
case SET_KEY:
return vnt_set_keys(hw, sta, vif, key);
case DISABLE_KEY:
if (test_bit(key->hw_key_idx, &priv->key_entry_inuse)) {
clear_bit(key->hw_key_idx, &priv->key_entry_inuse);
vnt_mac_disable_keyentry(priv, key->hw_key_idx);
}
break;
default:
break;
}
return 0;
}
static int vnt_get_stats(struct ieee80211_hw *hw,
struct ieee80211_low_level_stats *stats)
{
struct vnt_private *priv = hw->priv;
memcpy(stats, &priv->low_stats, sizeof(*stats));
return 0;
}
static u64 vnt_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
{
struct vnt_private *priv = hw->priv;
return priv->current_tsf;
}
static void vnt_set_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
u64 tsf)
{
struct vnt_private *priv = hw->priv;
vnt_update_next_tbtt(priv, tsf, vif->bss_conf.beacon_int);
}
static void vnt_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
{
struct vnt_private *priv = hw->priv;
vnt_mac_reg_bits_off(priv, MAC_REG_TFTCTL, TFTCTL_TSFCNTREN);
vnt_clear_current_tsf(priv);
}
static const struct ieee80211_ops vnt_mac_ops = {
.tx = vnt_tx_80211,
.wake_tx_queue = ieee80211_handle_wake_tx_queue,
.start = vnt_start,
.stop = vnt_stop,
.add_interface = vnt_add_interface,
.remove_interface = vnt_remove_interface,
.config = vnt_config,
.bss_info_changed = vnt_bss_info_changed,
.prepare_multicast = vnt_prepare_multicast,
.configure_filter = vnt_configure,
.set_key = vnt_set_key,
.get_stats = vnt_get_stats,
.get_tsf = vnt_get_tsf,
.set_tsf = vnt_set_tsf,
.reset_tsf = vnt_reset_tsf,
};
int vnt_init(struct vnt_private *priv)
{
if (vnt_init_registers(priv))
return -EAGAIN;
SET_IEEE80211_PERM_ADDR(priv->hw, priv->permanent_net_addr);
vnt_init_bands(priv);
if (ieee80211_register_hw(priv->hw))
return -ENODEV;
priv->mac_hw = true;
vnt_radio_power_off(priv);
return 0;
}
static int
vt6656_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
struct usb_device *udev;
struct vnt_private *priv;
struct ieee80211_hw *hw;
struct wiphy *wiphy;
int rc;
udev = usb_get_dev(interface_to_usbdev(intf));
dev_notice(&udev->dev, "%s Ver. %s\n",
DEVICE_FULL_DRV_NAM, DEVICE_VERSION);
dev_notice(&udev->dev,
"Copyright (c) 2004 VIA Networking Technologies, Inc.\n");
hw = ieee80211_alloc_hw(sizeof(struct vnt_private), &vnt_mac_ops);
if (!hw) {
dev_err(&udev->dev, "could not register ieee80211_hw\n");
rc = -ENOMEM;
goto err_nomem;
}
priv = hw->priv;
priv->hw = hw;
priv->usb = udev;
priv->intf = intf;
vnt_set_options(priv);
spin_lock_init(&priv->lock);
mutex_init(&priv->usb_lock);
INIT_DELAYED_WORK(&priv->run_command_work, vnt_run_command);
usb_set_intfdata(intf, priv);
wiphy = priv->hw->wiphy;
wiphy->frag_threshold = FRAG_THRESH_DEF;
wiphy->rts_threshold = RTS_THRESH_DEF;
wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP);
ieee80211_hw_set(priv->hw, TIMING_BEACON_ONLY);
ieee80211_hw_set(priv->hw, SIGNAL_DBM);
ieee80211_hw_set(priv->hw, RX_INCLUDES_FCS);
ieee80211_hw_set(priv->hw, REPORTS_TX_ACK_STATUS);
ieee80211_hw_set(priv->hw, SUPPORTS_PS);
ieee80211_hw_set(priv->hw, PS_NULLFUNC_STACK);
priv->hw->extra_tx_headroom =
sizeof(struct vnt_tx_buffer) + sizeof(struct vnt_tx_usb_header);
priv->hw->max_signal = 100;
SET_IEEE80211_DEV(priv->hw, &intf->dev);
rc = usb_reset_device(priv->usb);
if (rc)
dev_warn(&priv->usb->dev,
"%s reset fail status=%d\n", __func__, rc);
clear_bit(DEVICE_FLAGS_DISCONNECTED, &priv->flags);
vnt_reset_command_timer(priv);
vnt_schedule_command(priv, WLAN_CMD_INIT_MAC80211);
return 0;
err_nomem:
usb_put_dev(udev);
return rc;
}
static void vt6656_disconnect(struct usb_interface *intf)
{
struct vnt_private *priv = usb_get_intfdata(intf);
if (!priv)
return;
if (priv->mac_hw)
ieee80211_unregister_hw(priv->hw);
usb_set_intfdata(intf, NULL);
usb_put_dev(interface_to_usbdev(intf));
set_bit(DEVICE_FLAGS_UNPLUG, &priv->flags);
ieee80211_free_hw(priv->hw);
}
#ifdef CONFIG_PM
static int vt6656_suspend(struct usb_interface *intf, pm_message_t message)
{
return 0;
}
static int vt6656_resume(struct usb_interface *intf)
{
return 0;
}
#endif /* CONFIG_PM */
MODULE_DEVICE_TABLE(usb, vt6656_table);
static struct usb_driver vt6656_driver = {
.name = DEVICE_NAME,
.probe = vt6656_probe,
.disconnect = vt6656_disconnect,
.id_table = vt6656_table,
#ifdef CONFIG_PM
.suspend = vt6656_suspend,
.resume = vt6656_resume,
#endif /* CONFIG_PM */
};
module_usb_driver(vt6656_driver);
MODULE_FIRMWARE(FIRMWARE_NAME);
| linux-master | drivers/staging/vt6656/main_usb.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Bridged-Phy Bus driver
*
* Copyright 2014 Google Inc.
* Copyright 2014 Linaro Ltd.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/types.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/greybus.h>
#include "gbphy.h"
#define GB_GBPHY_AUTOSUSPEND_MS 3000
struct gbphy_host {
struct gb_bundle *bundle;
struct list_head devices;
};
static DEFINE_IDA(gbphy_id);
static ssize_t protocol_id_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
return sprintf(buf, "0x%02x\n", gbphy_dev->cport_desc->protocol_id);
}
static DEVICE_ATTR_RO(protocol_id);
static struct attribute *gbphy_dev_attrs[] = {
&dev_attr_protocol_id.attr,
NULL,
};
ATTRIBUTE_GROUPS(gbphy_dev);
static void gbphy_dev_release(struct device *dev)
{
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
ida_simple_remove(&gbphy_id, gbphy_dev->id);
kfree(gbphy_dev);
}
#ifdef CONFIG_PM
static int gb_gbphy_idle(struct device *dev)
{
pm_runtime_mark_last_busy(dev);
pm_request_autosuspend(dev);
return 0;
}
#endif
static const struct dev_pm_ops gb_gbphy_pm_ops = {
SET_RUNTIME_PM_OPS(pm_generic_runtime_suspend,
pm_generic_runtime_resume,
gb_gbphy_idle)
};
static const struct device_type greybus_gbphy_dev_type = {
.name = "gbphy_device",
.release = gbphy_dev_release,
.pm = &gb_gbphy_pm_ops,
};
static int gbphy_dev_uevent(const struct device *dev, struct kobj_uevent_env *env)
{
const struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
const struct greybus_descriptor_cport *cport_desc = gbphy_dev->cport_desc;
const struct gb_bundle *bundle = gbphy_dev->bundle;
const struct gb_interface *intf = bundle->intf;
const struct gb_module *module = intf->module;
const struct gb_host_device *hd = intf->hd;
if (add_uevent_var(env, "BUS=%u", hd->bus_id))
return -ENOMEM;
if (add_uevent_var(env, "MODULE=%u", module->module_id))
return -ENOMEM;
if (add_uevent_var(env, "INTERFACE=%u", intf->interface_id))
return -ENOMEM;
if (add_uevent_var(env, "GREYBUS_ID=%08x/%08x",
intf->vendor_id, intf->product_id))
return -ENOMEM;
if (add_uevent_var(env, "BUNDLE=%u", gbphy_dev->bundle->id))
return -ENOMEM;
if (add_uevent_var(env, "BUNDLE_CLASS=%02x", bundle->class))
return -ENOMEM;
if (add_uevent_var(env, "GBPHY=%u", gbphy_dev->id))
return -ENOMEM;
if (add_uevent_var(env, "PROTOCOL_ID=%02x", cport_desc->protocol_id))
return -ENOMEM;
return 0;
}
static const struct gbphy_device_id *
gbphy_dev_match_id(struct gbphy_device *gbphy_dev,
struct gbphy_driver *gbphy_drv)
{
const struct gbphy_device_id *id = gbphy_drv->id_table;
if (!id)
return NULL;
for (; id->protocol_id; id++)
if (id->protocol_id == gbphy_dev->cport_desc->protocol_id)
return id;
return NULL;
}
static int gbphy_dev_match(struct device *dev, struct device_driver *drv)
{
struct gbphy_driver *gbphy_drv = to_gbphy_driver(drv);
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
const struct gbphy_device_id *id;
id = gbphy_dev_match_id(gbphy_dev, gbphy_drv);
if (id)
return 1;
return 0;
}
static int gbphy_dev_probe(struct device *dev)
{
struct gbphy_driver *gbphy_drv = to_gbphy_driver(dev->driver);
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
const struct gbphy_device_id *id;
int ret;
id = gbphy_dev_match_id(gbphy_dev, gbphy_drv);
if (!id)
return -ENODEV;
/* for old kernels we need get_sync to resume parent devices */
ret = gb_pm_runtime_get_sync(gbphy_dev->bundle);
if (ret < 0)
return ret;
pm_runtime_set_autosuspend_delay(dev, GB_GBPHY_AUTOSUSPEND_MS);
pm_runtime_use_autosuspend(dev);
pm_runtime_get_noresume(dev);
pm_runtime_set_active(dev);
pm_runtime_enable(dev);
/*
* Drivers should call put on the gbphy dev before returning
* from probe if they support runtime pm.
*/
ret = gbphy_drv->probe(gbphy_dev, id);
if (ret) {
pm_runtime_disable(dev);
pm_runtime_set_suspended(dev);
pm_runtime_put_noidle(dev);
pm_runtime_dont_use_autosuspend(dev);
}
gb_pm_runtime_put_autosuspend(gbphy_dev->bundle);
return ret;
}
static void gbphy_dev_remove(struct device *dev)
{
struct gbphy_driver *gbphy_drv = to_gbphy_driver(dev->driver);
struct gbphy_device *gbphy_dev = to_gbphy_dev(dev);
gbphy_drv->remove(gbphy_dev);
pm_runtime_disable(dev);
pm_runtime_set_suspended(dev);
pm_runtime_put_noidle(dev);
pm_runtime_dont_use_autosuspend(dev);
}
static struct bus_type gbphy_bus_type = {
.name = "gbphy",
.match = gbphy_dev_match,
.probe = gbphy_dev_probe,
.remove = gbphy_dev_remove,
.uevent = gbphy_dev_uevent,
};
int gb_gbphy_register_driver(struct gbphy_driver *driver,
struct module *owner, const char *mod_name)
{
int retval;
if (greybus_disabled())
return -ENODEV;
driver->driver.bus = &gbphy_bus_type;
driver->driver.name = driver->name;
driver->driver.owner = owner;
driver->driver.mod_name = mod_name;
retval = driver_register(&driver->driver);
if (retval)
return retval;
pr_info("registered new driver %s\n", driver->name);
return 0;
}
EXPORT_SYMBOL_GPL(gb_gbphy_register_driver);
void gb_gbphy_deregister_driver(struct gbphy_driver *driver)
{
driver_unregister(&driver->driver);
}
EXPORT_SYMBOL_GPL(gb_gbphy_deregister_driver);
static struct gbphy_device *gb_gbphy_create_dev(struct gb_bundle *bundle,
struct greybus_descriptor_cport *cport_desc)
{
struct gbphy_device *gbphy_dev;
int retval;
int id;
id = ida_simple_get(&gbphy_id, 1, 0, GFP_KERNEL);
if (id < 0)
return ERR_PTR(id);
gbphy_dev = kzalloc(sizeof(*gbphy_dev), GFP_KERNEL);
if (!gbphy_dev) {
ida_simple_remove(&gbphy_id, id);
return ERR_PTR(-ENOMEM);
}
gbphy_dev->id = id;
gbphy_dev->bundle = bundle;
gbphy_dev->cport_desc = cport_desc;
gbphy_dev->dev.parent = &bundle->dev;
gbphy_dev->dev.bus = &gbphy_bus_type;
gbphy_dev->dev.type = &greybus_gbphy_dev_type;
gbphy_dev->dev.groups = gbphy_dev_groups;
gbphy_dev->dev.dma_mask = bundle->dev.dma_mask;
dev_set_name(&gbphy_dev->dev, "gbphy%d", id);
retval = device_register(&gbphy_dev->dev);
if (retval) {
put_device(&gbphy_dev->dev);
return ERR_PTR(retval);
}
return gbphy_dev;
}
static void gb_gbphy_disconnect(struct gb_bundle *bundle)
{
struct gbphy_host *gbphy_host = greybus_get_drvdata(bundle);
struct gbphy_device *gbphy_dev, *temp;
int ret;
ret = gb_pm_runtime_get_sync(bundle);
if (ret < 0)
gb_pm_runtime_get_noresume(bundle);
list_for_each_entry_safe(gbphy_dev, temp, &gbphy_host->devices, list) {
list_del(&gbphy_dev->list);
device_unregister(&gbphy_dev->dev);
}
kfree(gbphy_host);
}
static int gb_gbphy_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct gbphy_host *gbphy_host;
struct gbphy_device *gbphy_dev;
int i;
if (bundle->num_cports == 0)
return -ENODEV;
gbphy_host = kzalloc(sizeof(*gbphy_host), GFP_KERNEL);
if (!gbphy_host)
return -ENOMEM;
gbphy_host->bundle = bundle;
INIT_LIST_HEAD(&gbphy_host->devices);
greybus_set_drvdata(bundle, gbphy_host);
/*
* Create a bunch of children devices, one per cport, and bind the
* bridged phy drivers to them.
*/
for (i = 0; i < bundle->num_cports; ++i) {
gbphy_dev = gb_gbphy_create_dev(bundle, &bundle->cport_desc[i]);
if (IS_ERR(gbphy_dev)) {
gb_gbphy_disconnect(bundle);
return PTR_ERR(gbphy_dev);
}
list_add(&gbphy_dev->list, &gbphy_host->devices);
}
gb_pm_runtime_put_autosuspend(bundle);
return 0;
}
static const struct greybus_bundle_id gb_gbphy_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_BRIDGED_PHY) },
{ },
};
MODULE_DEVICE_TABLE(greybus, gb_gbphy_id_table);
static struct greybus_driver gb_gbphy_driver = {
.name = "gbphy",
.probe = gb_gbphy_probe,
.disconnect = gb_gbphy_disconnect,
.id_table = gb_gbphy_id_table,
};
static int __init gbphy_init(void)
{
int retval;
retval = bus_register(&gbphy_bus_type);
if (retval) {
pr_err("gbphy bus register failed (%d)\n", retval);
return retval;
}
retval = greybus_register(&gb_gbphy_driver);
if (retval) {
pr_err("error registering greybus driver\n");
goto error_gbphy;
}
return 0;
error_gbphy:
bus_unregister(&gbphy_bus_type);
ida_destroy(&gbphy_id);
return retval;
}
module_init(gbphy_init);
static void __exit gbphy_exit(void)
{
greybus_deregister(&gb_gbphy_driver);
bus_unregister(&gbphy_bus_type);
ida_destroy(&gbphy_id);
}
module_exit(gbphy_exit);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/gbphy.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Component Authentication Protocol (CAP) Driver.
*
* Copyright 2016 Google Inc.
* Copyright 2016 Linaro Ltd.
*/
#include <linux/greybus.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/ioctl.h>
#include <linux/uaccess.h>
#include "greybus_authentication.h"
#include "firmware.h"
#define CAP_TIMEOUT_MS 1000
/*
* Number of minor devices this driver supports.
* There will be exactly one required per Interface.
*/
#define NUM_MINORS U8_MAX
struct gb_cap {
struct device *parent;
struct gb_connection *connection;
struct kref kref;
struct list_head node;
bool disabled; /* connection getting disabled */
struct mutex mutex;
struct cdev cdev;
struct device *class_device;
dev_t dev_num;
};
static struct class *cap_class;
static dev_t cap_dev_num;
static DEFINE_IDA(cap_minors_map);
static LIST_HEAD(cap_list);
static DEFINE_MUTEX(list_mutex);
static void cap_kref_release(struct kref *kref)
{
struct gb_cap *cap = container_of(kref, struct gb_cap, kref);
kfree(cap);
}
/*
* All users of cap take a reference (from within list_mutex lock), before
* they get a pointer to play with. And the structure will be freed only after
* the last user has put the reference to it.
*/
static void put_cap(struct gb_cap *cap)
{
kref_put(&cap->kref, cap_kref_release);
}
/* Caller must call put_cap() after using struct gb_cap */
static struct gb_cap *get_cap(struct cdev *cdev)
{
struct gb_cap *cap;
mutex_lock(&list_mutex);
list_for_each_entry(cap, &cap_list, node) {
if (&cap->cdev == cdev) {
kref_get(&cap->kref);
goto unlock;
}
}
cap = NULL;
unlock:
mutex_unlock(&list_mutex);
return cap;
}
static int cap_get_endpoint_uid(struct gb_cap *cap, u8 *euid)
{
struct gb_connection *connection = cap->connection;
struct gb_cap_get_endpoint_uid_response response;
int ret;
ret = gb_operation_sync(connection, GB_CAP_TYPE_GET_ENDPOINT_UID, NULL,
0, &response, sizeof(response));
if (ret) {
dev_err(cap->parent, "failed to get endpoint uid (%d)\n", ret);
return ret;
}
memcpy(euid, response.uid, sizeof(response.uid));
return 0;
}
static int cap_get_ims_certificate(struct gb_cap *cap, u32 class, u32 id,
u8 *certificate, u32 *size, u8 *result)
{
struct gb_connection *connection = cap->connection;
struct gb_cap_get_ims_certificate_request *request;
struct gb_cap_get_ims_certificate_response *response;
size_t max_size = gb_operation_get_payload_size_max(connection);
struct gb_operation *op;
int ret;
op = gb_operation_create_flags(connection,
GB_CAP_TYPE_GET_IMS_CERTIFICATE,
sizeof(*request), max_size,
GB_OPERATION_FLAG_SHORT_RESPONSE,
GFP_KERNEL);
if (!op)
return -ENOMEM;
request = op->request->payload;
request->certificate_class = cpu_to_le32(class);
request->certificate_id = cpu_to_le32(id);
ret = gb_operation_request_send_sync(op);
if (ret) {
dev_err(cap->parent, "failed to get certificate (%d)\n", ret);
goto done;
}
response = op->response->payload;
*result = response->result_code;
*size = op->response->payload_size - sizeof(*response);
memcpy(certificate, response->certificate, *size);
done:
gb_operation_put(op);
return ret;
}
static int cap_authenticate(struct gb_cap *cap, u32 auth_type, u8 *uid,
u8 *challenge, u8 *result, u8 *auth_response,
u32 *signature_size, u8 *signature)
{
struct gb_connection *connection = cap->connection;
struct gb_cap_authenticate_request *request;
struct gb_cap_authenticate_response *response;
size_t max_size = gb_operation_get_payload_size_max(connection);
struct gb_operation *op;
int ret;
op = gb_operation_create_flags(connection, GB_CAP_TYPE_AUTHENTICATE,
sizeof(*request), max_size,
GB_OPERATION_FLAG_SHORT_RESPONSE,
GFP_KERNEL);
if (!op)
return -ENOMEM;
request = op->request->payload;
request->auth_type = cpu_to_le32(auth_type);
memcpy(request->uid, uid, sizeof(request->uid));
memcpy(request->challenge, challenge, sizeof(request->challenge));
ret = gb_operation_request_send_sync(op);
if (ret) {
dev_err(cap->parent, "failed to authenticate (%d)\n", ret);
goto done;
}
response = op->response->payload;
*result = response->result_code;
*signature_size = op->response->payload_size - sizeof(*response);
memcpy(auth_response, response->response, sizeof(response->response));
memcpy(signature, response->signature, *signature_size);
done:
gb_operation_put(op);
return ret;
}
/* Char device fops */
static int cap_open(struct inode *inode, struct file *file)
{
struct gb_cap *cap = get_cap(inode->i_cdev);
/* cap structure can't get freed until file descriptor is closed */
if (cap) {
file->private_data = cap;
return 0;
}
return -ENODEV;
}
static int cap_release(struct inode *inode, struct file *file)
{
struct gb_cap *cap = file->private_data;
put_cap(cap);
return 0;
}
static int cap_ioctl(struct gb_cap *cap, unsigned int cmd,
void __user *buf)
{
struct cap_ioc_get_endpoint_uid endpoint_uid;
struct cap_ioc_get_ims_certificate *ims_cert;
struct cap_ioc_authenticate *authenticate;
size_t size;
int ret;
switch (cmd) {
case CAP_IOC_GET_ENDPOINT_UID:
ret = cap_get_endpoint_uid(cap, endpoint_uid.uid);
if (ret)
return ret;
if (copy_to_user(buf, &endpoint_uid, sizeof(endpoint_uid)))
return -EFAULT;
return 0;
case CAP_IOC_GET_IMS_CERTIFICATE:
size = sizeof(*ims_cert);
ims_cert = memdup_user(buf, size);
if (IS_ERR(ims_cert))
return PTR_ERR(ims_cert);
ret = cap_get_ims_certificate(cap, ims_cert->certificate_class,
ims_cert->certificate_id,
ims_cert->certificate,
&ims_cert->cert_size,
&ims_cert->result_code);
if (!ret && copy_to_user(buf, ims_cert, size))
ret = -EFAULT;
kfree(ims_cert);
return ret;
case CAP_IOC_AUTHENTICATE:
size = sizeof(*authenticate);
authenticate = memdup_user(buf, size);
if (IS_ERR(authenticate))
return PTR_ERR(authenticate);
ret = cap_authenticate(cap, authenticate->auth_type,
authenticate->uid,
authenticate->challenge,
&authenticate->result_code,
authenticate->response,
&authenticate->signature_size,
authenticate->signature);
if (!ret && copy_to_user(buf, authenticate, size))
ret = -EFAULT;
kfree(authenticate);
return ret;
default:
return -ENOTTY;
}
}
static long cap_ioctl_unlocked(struct file *file, unsigned int cmd,
unsigned long arg)
{
struct gb_cap *cap = file->private_data;
struct gb_bundle *bundle = cap->connection->bundle;
int ret = -ENODEV;
/*
* Serialize ioctls.
*
* We don't want the user to do multiple authentication operations in
* parallel.
*
* This is also used to protect ->disabled, which is used to check if
* the connection is getting disconnected, so that we don't start any
* new operations.
*/
mutex_lock(&cap->mutex);
if (!cap->disabled) {
ret = gb_pm_runtime_get_sync(bundle);
if (!ret) {
ret = cap_ioctl(cap, cmd, (void __user *)arg);
gb_pm_runtime_put_autosuspend(bundle);
}
}
mutex_unlock(&cap->mutex);
return ret;
}
static const struct file_operations cap_fops = {
.owner = THIS_MODULE,
.open = cap_open,
.release = cap_release,
.unlocked_ioctl = cap_ioctl_unlocked,
};
int gb_cap_connection_init(struct gb_connection *connection)
{
struct gb_cap *cap;
int ret, minor;
if (!connection)
return 0;
cap = kzalloc(sizeof(*cap), GFP_KERNEL);
if (!cap)
return -ENOMEM;
cap->parent = &connection->bundle->dev;
cap->connection = connection;
mutex_init(&cap->mutex);
gb_connection_set_data(connection, cap);
kref_init(&cap->kref);
mutex_lock(&list_mutex);
list_add(&cap->node, &cap_list);
mutex_unlock(&list_mutex);
ret = gb_connection_enable(connection);
if (ret)
goto err_list_del;
minor = ida_simple_get(&cap_minors_map, 0, NUM_MINORS, GFP_KERNEL);
if (minor < 0) {
ret = minor;
goto err_connection_disable;
}
/* Add a char device to allow userspace to interact with cap */
cap->dev_num = MKDEV(MAJOR(cap_dev_num), minor);
cdev_init(&cap->cdev, &cap_fops);
ret = cdev_add(&cap->cdev, cap->dev_num, 1);
if (ret)
goto err_remove_ida;
/* Add a soft link to the previously added char-dev within the bundle */
cap->class_device = device_create(cap_class, cap->parent, cap->dev_num,
NULL, "gb-authenticate-%d", minor);
if (IS_ERR(cap->class_device)) {
ret = PTR_ERR(cap->class_device);
goto err_del_cdev;
}
return 0;
err_del_cdev:
cdev_del(&cap->cdev);
err_remove_ida:
ida_simple_remove(&cap_minors_map, minor);
err_connection_disable:
gb_connection_disable(connection);
err_list_del:
mutex_lock(&list_mutex);
list_del(&cap->node);
mutex_unlock(&list_mutex);
put_cap(cap);
return ret;
}
void gb_cap_connection_exit(struct gb_connection *connection)
{
struct gb_cap *cap;
if (!connection)
return;
cap = gb_connection_get_data(connection);
device_destroy(cap_class, cap->dev_num);
cdev_del(&cap->cdev);
ida_simple_remove(&cap_minors_map, MINOR(cap->dev_num));
/*
* Disallow any new ioctl operations on the char device and wait for
* existing ones to finish.
*/
mutex_lock(&cap->mutex);
cap->disabled = true;
mutex_unlock(&cap->mutex);
/* All pending greybus operations should have finished by now */
gb_connection_disable(cap->connection);
/* Disallow new users to get access to the cap structure */
mutex_lock(&list_mutex);
list_del(&cap->node);
mutex_unlock(&list_mutex);
/*
* All current users of cap would have taken a reference to it by
* now, we can drop our reference and wait the last user will get
* cap freed.
*/
put_cap(cap);
}
int cap_init(void)
{
int ret;
cap_class = class_create("gb_authenticate");
if (IS_ERR(cap_class))
return PTR_ERR(cap_class);
ret = alloc_chrdev_region(&cap_dev_num, 0, NUM_MINORS,
"gb_authenticate");
if (ret)
goto err_remove_class;
return 0;
err_remove_class:
class_destroy(cap_class);
return ret;
}
void cap_exit(void)
{
unregister_chrdev_region(cap_dev_num, NUM_MINORS);
class_destroy(cap_class);
ida_destroy(&cap_minors_map);
}
| linux-master | drivers/staging/greybus/authentication.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus driver for the log protocol
*
* Copyright 2016 Google Inc.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/sizes.h>
#include <linux/uaccess.h>
#include <linux/greybus.h>
struct gb_log {
struct gb_connection *connection;
};
static int gb_log_request_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct device *dev = &connection->bundle->dev;
struct gb_log_send_log_request *receive;
u16 len;
if (op->type != GB_LOG_TYPE_SEND_LOG) {
dev_err(dev, "unknown request type 0x%02x\n", op->type);
return -EINVAL;
}
/* Verify size of payload */
if (op->request->payload_size < sizeof(*receive)) {
dev_err(dev, "log request too small (%zu < %zu)\n",
op->request->payload_size, sizeof(*receive));
return -EINVAL;
}
receive = op->request->payload;
len = le16_to_cpu(receive->len);
if (len != (op->request->payload_size - sizeof(*receive))) {
dev_err(dev, "log request wrong size %d vs %zu\n", len,
(op->request->payload_size - sizeof(*receive)));
return -EINVAL;
}
if (len == 0) {
dev_err(dev, "log request of 0 bytes?\n");
return -EINVAL;
}
if (len > GB_LOG_MAX_LEN) {
dev_err(dev, "log request too big: %d\n", len);
return -EINVAL;
}
/* Ensure the buffer is 0 terminated */
receive->msg[len - 1] = '\0';
/*
* Print with dev_dbg() so that it can be easily turned off using
* dynamic debugging (and prevent any DoS)
*/
dev_dbg(dev, "%s", receive->msg);
return 0;
}
static int gb_log_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct greybus_descriptor_cport *cport_desc;
struct gb_connection *connection;
struct gb_log *log;
int retval;
if (bundle->num_cports != 1)
return -ENODEV;
cport_desc = &bundle->cport_desc[0];
if (cport_desc->protocol_id != GREYBUS_PROTOCOL_LOG)
return -ENODEV;
log = kzalloc(sizeof(*log), GFP_KERNEL);
if (!log)
return -ENOMEM;
connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
gb_log_request_handler);
if (IS_ERR(connection)) {
retval = PTR_ERR(connection);
goto error_free;
}
log->connection = connection;
greybus_set_drvdata(bundle, log);
retval = gb_connection_enable(connection);
if (retval)
goto error_connection_destroy;
return 0;
error_connection_destroy:
gb_connection_destroy(connection);
error_free:
kfree(log);
return retval;
}
static void gb_log_disconnect(struct gb_bundle *bundle)
{
struct gb_log *log = greybus_get_drvdata(bundle);
struct gb_connection *connection = log->connection;
gb_connection_disable(connection);
gb_connection_destroy(connection);
kfree(log);
}
static const struct greybus_bundle_id gb_log_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_LOG) },
{ }
};
MODULE_DEVICE_TABLE(greybus, gb_log_id_table);
static struct greybus_driver gb_log_driver = {
.name = "log",
.probe = gb_log_probe,
.disconnect = gb_log_disconnect,
.id_table = gb_log_id_table,
};
module_greybus_driver(gb_log_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/log.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Audio Device Class Protocol helpers
*
* Copyright 2015-2016 Google Inc.
*/
#include <linux/greybus.h>
#include "audio_codec.h"
/* TODO: Split into separate calls */
int gb_audio_gb_get_topology(struct gb_connection *connection,
struct gb_audio_topology **topology)
{
struct gb_audio_get_topology_size_response size_resp;
struct gb_audio_topology *topo;
u16 size;
int ret;
ret = gb_operation_sync(connection, GB_AUDIO_TYPE_GET_TOPOLOGY_SIZE,
NULL, 0, &size_resp, sizeof(size_resp));
if (ret)
return ret;
size = le16_to_cpu(size_resp.size);
if (size < sizeof(*topo))
return -ENODATA;
topo = kzalloc(size, GFP_KERNEL);
if (!topo)
return -ENOMEM;
ret = gb_operation_sync(connection, GB_AUDIO_TYPE_GET_TOPOLOGY, NULL, 0,
topo, size);
if (ret) {
kfree(topo);
return ret;
}
*topology = topo;
return 0;
}
EXPORT_SYMBOL_GPL(gb_audio_gb_get_topology);
int gb_audio_gb_get_control(struct gb_connection *connection,
u8 control_id, u8 index,
struct gb_audio_ctl_elem_value *value)
{
struct gb_audio_get_control_request req;
struct gb_audio_get_control_response resp;
int ret;
req.control_id = control_id;
req.index = index;
ret = gb_operation_sync(connection, GB_AUDIO_TYPE_GET_CONTROL,
&req, sizeof(req), &resp, sizeof(resp));
if (ret)
return ret;
memcpy(value, &resp.value, sizeof(*value));
return 0;
}
EXPORT_SYMBOL_GPL(gb_audio_gb_get_control);
int gb_audio_gb_set_control(struct gb_connection *connection,
u8 control_id, u8 index,
struct gb_audio_ctl_elem_value *value)
{
struct gb_audio_set_control_request req;
req.control_id = control_id;
req.index = index;
memcpy(&req.value, value, sizeof(req.value));
return gb_operation_sync(connection, GB_AUDIO_TYPE_SET_CONTROL,
&req, sizeof(req), NULL, 0);
}
EXPORT_SYMBOL_GPL(gb_audio_gb_set_control);
int gb_audio_gb_enable_widget(struct gb_connection *connection,
u8 widget_id)
{
struct gb_audio_enable_widget_request req;
req.widget_id = widget_id;
return gb_operation_sync(connection, GB_AUDIO_TYPE_ENABLE_WIDGET,
&req, sizeof(req), NULL, 0);
}
EXPORT_SYMBOL_GPL(gb_audio_gb_enable_widget);
int gb_audio_gb_disable_widget(struct gb_connection *connection,
u8 widget_id)
{
struct gb_audio_disable_widget_request req;
req.widget_id = widget_id;
return gb_operation_sync(connection, GB_AUDIO_TYPE_DISABLE_WIDGET,
&req, sizeof(req), NULL, 0);
}
EXPORT_SYMBOL_GPL(gb_audio_gb_disable_widget);
int gb_audio_gb_get_pcm(struct gb_connection *connection, u16 data_cport,
u32 *format, u32 *rate, u8 *channels,
u8 *sig_bits)
{
struct gb_audio_get_pcm_request req;
struct gb_audio_get_pcm_response resp;
int ret;
req.data_cport = cpu_to_le16(data_cport);
ret = gb_operation_sync(connection, GB_AUDIO_TYPE_GET_PCM,
&req, sizeof(req), &resp, sizeof(resp));
if (ret)
return ret;
*format = le32_to_cpu(resp.format);
*rate = le32_to_cpu(resp.rate);
*channels = resp.channels;
*sig_bits = resp.sig_bits;
return 0;
}
EXPORT_SYMBOL_GPL(gb_audio_gb_get_pcm);
int gb_audio_gb_set_pcm(struct gb_connection *connection, u16 data_cport,
u32 format, u32 rate, u8 channels,
u8 sig_bits)
{
struct gb_audio_set_pcm_request req;
req.data_cport = cpu_to_le16(data_cport);
req.format = cpu_to_le32(format);
req.rate = cpu_to_le32(rate);
req.channels = channels;
req.sig_bits = sig_bits;
return gb_operation_sync(connection, GB_AUDIO_TYPE_SET_PCM,
&req, sizeof(req), NULL, 0);
}
EXPORT_SYMBOL_GPL(gb_audio_gb_set_pcm);
int gb_audio_gb_set_tx_data_size(struct gb_connection *connection,
u16 data_cport, u16 size)
{
struct gb_audio_set_tx_data_size_request req;
req.data_cport = cpu_to_le16(data_cport);
req.size = cpu_to_le16(size);
return gb_operation_sync(connection, GB_AUDIO_TYPE_SET_TX_DATA_SIZE,
&req, sizeof(req), NULL, 0);
}
EXPORT_SYMBOL_GPL(gb_audio_gb_set_tx_data_size);
int gb_audio_gb_activate_tx(struct gb_connection *connection,
u16 data_cport)
{
struct gb_audio_activate_tx_request req;
req.data_cport = cpu_to_le16(data_cport);
return gb_operation_sync(connection, GB_AUDIO_TYPE_ACTIVATE_TX,
&req, sizeof(req), NULL, 0);
}
EXPORT_SYMBOL_GPL(gb_audio_gb_activate_tx);
int gb_audio_gb_deactivate_tx(struct gb_connection *connection,
u16 data_cport)
{
struct gb_audio_deactivate_tx_request req;
req.data_cport = cpu_to_le16(data_cport);
return gb_operation_sync(connection, GB_AUDIO_TYPE_DEACTIVATE_TX,
&req, sizeof(req), NULL, 0);
}
EXPORT_SYMBOL_GPL(gb_audio_gb_deactivate_tx);
int gb_audio_gb_set_rx_data_size(struct gb_connection *connection,
u16 data_cport, u16 size)
{
struct gb_audio_set_rx_data_size_request req;
req.data_cport = cpu_to_le16(data_cport);
req.size = cpu_to_le16(size);
return gb_operation_sync(connection, GB_AUDIO_TYPE_SET_RX_DATA_SIZE,
&req, sizeof(req), NULL, 0);
}
EXPORT_SYMBOL_GPL(gb_audio_gb_set_rx_data_size);
int gb_audio_gb_activate_rx(struct gb_connection *connection,
u16 data_cport)
{
struct gb_audio_activate_rx_request req;
req.data_cport = cpu_to_le16(data_cport);
return gb_operation_sync(connection, GB_AUDIO_TYPE_ACTIVATE_RX,
&req, sizeof(req), NULL, 0);
}
EXPORT_SYMBOL_GPL(gb_audio_gb_activate_rx);
int gb_audio_gb_deactivate_rx(struct gb_connection *connection,
u16 data_cport)
{
struct gb_audio_deactivate_rx_request req;
req.data_cport = cpu_to_le16(data_cport);
return gb_operation_sync(connection, GB_AUDIO_TYPE_DEACTIVATE_RX,
&req, sizeof(req), NULL, 0);
}
EXPORT_SYMBOL_GPL(gb_audio_gb_deactivate_rx);
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("greybus:audio-gb");
MODULE_DESCRIPTION("Greybus Audio Device Class Protocol library");
MODULE_AUTHOR("Mark Greer <[email protected]>");
| linux-master | drivers/staging/greybus/audio_gb.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Arche Platform driver to enable Unipro link.
*
* Copyright 2014-2015 Google Inc.
* Copyright 2014-2015 Linaro Ltd.
*/
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/of_platform.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/suspend.h>
#include <linux/time.h>
#include <linux/greybus.h>
#include <linux/of.h>
#include "arche_platform.h"
#if IS_ENABLED(CONFIG_USB_HSIC_USB3613)
#include <linux/usb/usb3613.h>
#else
static inline int usb3613_hub_mode_ctrl(bool unused)
{
return 0;
}
#endif
#define WD_COLDBOOT_PULSE_WIDTH_MS 30
enum svc_wakedetect_state {
WD_STATE_IDLE, /* Default state = pulled high/low */
WD_STATE_BOOT_INIT, /* WD = falling edge (low) */
WD_STATE_COLDBOOT_TRIG, /* WD = rising edge (high), > 30msec */
WD_STATE_STANDBYBOOT_TRIG, /* As of now not used ?? */
WD_STATE_COLDBOOT_START, /* Cold boot process started */
WD_STATE_STANDBYBOOT_START, /* Not used */
};
struct arche_platform_drvdata {
/* Control GPIO signals to and from AP <=> SVC */
struct gpio_desc *svc_reset;
bool is_reset_act_hi;
struct gpio_desc *svc_sysboot;
struct gpio_desc *wake_detect; /* bi-dir,maps to WAKE_MOD & WAKE_FRAME signals */
enum arche_platform_state state;
struct gpio_desc *svc_refclk_req;
struct clk *svc_ref_clk;
struct pinctrl *pinctrl;
struct pinctrl_state *pin_default;
int num_apbs;
enum svc_wakedetect_state wake_detect_state;
int wake_detect_irq;
spinlock_t wake_lock; /* Protect wake_detect_state */
struct mutex platform_state_mutex; /* Protect state */
unsigned long wake_detect_start;
struct notifier_block pm_notifier;
struct device *dev;
};
/* Requires calling context to hold arche_pdata->platform_state_mutex */
static void arche_platform_set_state(struct arche_platform_drvdata *arche_pdata,
enum arche_platform_state state)
{
arche_pdata->state = state;
}
/* Requires arche_pdata->wake_lock is held by calling context */
static void arche_platform_set_wake_detect_state(struct arche_platform_drvdata *arche_pdata,
enum svc_wakedetect_state state)
{
arche_pdata->wake_detect_state = state;
}
static inline void svc_reset_onoff(struct gpio_desc *gpio, bool onoff)
{
gpiod_set_raw_value(gpio, onoff);
}
static int apb_cold_boot(struct device *dev, void *data)
{
int ret;
ret = apb_ctrl_coldboot(dev);
if (ret)
dev_warn(dev, "failed to coldboot\n");
/*Child nodes are independent, so do not exit coldboot operation */
return 0;
}
static int apb_poweroff(struct device *dev, void *data)
{
apb_ctrl_poweroff(dev);
/* Enable HUB3613 into HUB mode. */
if (usb3613_hub_mode_ctrl(false))
dev_warn(dev, "failed to control hub device\n");
return 0;
}
static void arche_platform_wd_irq_en(struct arche_platform_drvdata *arche_pdata)
{
/* Enable interrupt here, to read event back from SVC */
enable_irq(arche_pdata->wake_detect_irq);
}
static irqreturn_t arche_platform_wd_irq_thread(int irq, void *devid)
{
struct arche_platform_drvdata *arche_pdata = devid;
unsigned long flags;
spin_lock_irqsave(&arche_pdata->wake_lock, flags);
if (arche_pdata->wake_detect_state != WD_STATE_COLDBOOT_TRIG) {
/* Something is wrong */
spin_unlock_irqrestore(&arche_pdata->wake_lock, flags);
return IRQ_HANDLED;
}
arche_platform_set_wake_detect_state(arche_pdata,
WD_STATE_COLDBOOT_START);
spin_unlock_irqrestore(&arche_pdata->wake_lock, flags);
/* It should complete power cycle, so first make sure it is poweroff */
device_for_each_child(arche_pdata->dev, NULL, apb_poweroff);
/* Bring APB out of reset: cold boot sequence */
device_for_each_child(arche_pdata->dev, NULL, apb_cold_boot);
/* Enable HUB3613 into HUB mode. */
if (usb3613_hub_mode_ctrl(true))
dev_warn(arche_pdata->dev, "failed to control hub device\n");
spin_lock_irqsave(&arche_pdata->wake_lock, flags);
arche_platform_set_wake_detect_state(arche_pdata, WD_STATE_IDLE);
spin_unlock_irqrestore(&arche_pdata->wake_lock, flags);
return IRQ_HANDLED;
}
static irqreturn_t arche_platform_wd_irq(int irq, void *devid)
{
struct arche_platform_drvdata *arche_pdata = devid;
unsigned long flags;
spin_lock_irqsave(&arche_pdata->wake_lock, flags);
if (gpiod_get_value(arche_pdata->wake_detect)) {
/* wake/detect rising */
/*
* If wake/detect line goes high after low, within less than
* 30msec, then standby boot sequence is initiated, which is not
* supported/implemented as of now. So ignore it.
*/
if (arche_pdata->wake_detect_state == WD_STATE_BOOT_INIT) {
if (time_before(jiffies,
arche_pdata->wake_detect_start +
msecs_to_jiffies(WD_COLDBOOT_PULSE_WIDTH_MS))) {
arche_platform_set_wake_detect_state(arche_pdata,
WD_STATE_IDLE);
} else {
/*
* Check we are not in middle of irq thread
* already
*/
if (arche_pdata->wake_detect_state !=
WD_STATE_COLDBOOT_START) {
arche_platform_set_wake_detect_state(arche_pdata,
WD_STATE_COLDBOOT_TRIG);
spin_unlock_irqrestore(&arche_pdata->wake_lock,
flags);
return IRQ_WAKE_THREAD;
}
}
}
} else {
/* wake/detect falling */
if (arche_pdata->wake_detect_state == WD_STATE_IDLE) {
arche_pdata->wake_detect_start = jiffies;
/*
* In the beginning, when wake/detect goes low
* (first time), we assume it is meant for coldboot
* and set the flag. If wake/detect line stays low
* beyond 30msec, then it is coldboot else fallback
* to standby boot.
*/
arche_platform_set_wake_detect_state(arche_pdata,
WD_STATE_BOOT_INIT);
}
}
spin_unlock_irqrestore(&arche_pdata->wake_lock, flags);
return IRQ_HANDLED;
}
/*
* Requires arche_pdata->platform_state_mutex to be held
*/
static int
arche_platform_coldboot_seq(struct arche_platform_drvdata *arche_pdata)
{
int ret;
if (arche_pdata->state == ARCHE_PLATFORM_STATE_ACTIVE)
return 0;
dev_info(arche_pdata->dev, "Booting from cold boot state\n");
svc_reset_onoff(arche_pdata->svc_reset, arche_pdata->is_reset_act_hi);
gpiod_set_value(arche_pdata->svc_sysboot, 0);
usleep_range(100, 200);
ret = clk_prepare_enable(arche_pdata->svc_ref_clk);
if (ret) {
dev_err(arche_pdata->dev, "failed to enable svc_ref_clk: %d\n",
ret);
return ret;
}
/* bring SVC out of reset */
svc_reset_onoff(arche_pdata->svc_reset, !arche_pdata->is_reset_act_hi);
arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_ACTIVE);
return 0;
}
/*
* Requires arche_pdata->platform_state_mutex to be held
*/
static int
arche_platform_fw_flashing_seq(struct arche_platform_drvdata *arche_pdata)
{
int ret;
if (arche_pdata->state == ARCHE_PLATFORM_STATE_FW_FLASHING)
return 0;
dev_info(arche_pdata->dev, "Switching to FW flashing state\n");
svc_reset_onoff(arche_pdata->svc_reset, arche_pdata->is_reset_act_hi);
gpiod_set_value(arche_pdata->svc_sysboot, 1);
usleep_range(100, 200);
ret = clk_prepare_enable(arche_pdata->svc_ref_clk);
if (ret) {
dev_err(arche_pdata->dev, "failed to enable svc_ref_clk: %d\n",
ret);
return ret;
}
svc_reset_onoff(arche_pdata->svc_reset, !arche_pdata->is_reset_act_hi);
arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_FW_FLASHING);
return 0;
}
/*
* Requires arche_pdata->platform_state_mutex to be held
*/
static void
arche_platform_poweroff_seq(struct arche_platform_drvdata *arche_pdata)
{
unsigned long flags;
if (arche_pdata->state == ARCHE_PLATFORM_STATE_OFF)
return;
/* If in fw_flashing mode, then no need to repeate things again */
if (arche_pdata->state != ARCHE_PLATFORM_STATE_FW_FLASHING) {
disable_irq(arche_pdata->wake_detect_irq);
spin_lock_irqsave(&arche_pdata->wake_lock, flags);
arche_platform_set_wake_detect_state(arche_pdata,
WD_STATE_IDLE);
spin_unlock_irqrestore(&arche_pdata->wake_lock, flags);
}
clk_disable_unprepare(arche_pdata->svc_ref_clk);
/* As part of exit, put APB back in reset state */
svc_reset_onoff(arche_pdata->svc_reset, arche_pdata->is_reset_act_hi);
arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_OFF);
}
static ssize_t state_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct arche_platform_drvdata *arche_pdata = dev_get_drvdata(dev);
int ret = 0;
mutex_lock(&arche_pdata->platform_state_mutex);
if (sysfs_streq(buf, "off")) {
if (arche_pdata->state == ARCHE_PLATFORM_STATE_OFF)
goto exit;
/* If SVC goes down, bring down APB's as well */
device_for_each_child(arche_pdata->dev, NULL, apb_poweroff);
arche_platform_poweroff_seq(arche_pdata);
} else if (sysfs_streq(buf, "active")) {
if (arche_pdata->state == ARCHE_PLATFORM_STATE_ACTIVE)
goto exit;
/* First we want to make sure we power off everything
* and then activate back again
*/
device_for_each_child(arche_pdata->dev, NULL, apb_poweroff);
arche_platform_poweroff_seq(arche_pdata);
arche_platform_wd_irq_en(arche_pdata);
ret = arche_platform_coldboot_seq(arche_pdata);
if (ret)
goto exit;
} else if (sysfs_streq(buf, "standby")) {
if (arche_pdata->state == ARCHE_PLATFORM_STATE_STANDBY)
goto exit;
dev_warn(arche_pdata->dev, "standby state not supported\n");
} else if (sysfs_streq(buf, "fw_flashing")) {
if (arche_pdata->state == ARCHE_PLATFORM_STATE_FW_FLASHING)
goto exit;
/*
* Here we only control SVC.
*
* In case of FW_FLASHING mode we do not want to control
* APBs, as in case of V2, SPI bus is shared between both
* the APBs. So let user chose which APB he wants to flash.
*/
arche_platform_poweroff_seq(arche_pdata);
ret = arche_platform_fw_flashing_seq(arche_pdata);
if (ret)
goto exit;
} else {
dev_err(arche_pdata->dev, "unknown state\n");
ret = -EINVAL;
}
exit:
mutex_unlock(&arche_pdata->platform_state_mutex);
return ret ? ret : count;
}
static ssize_t state_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct arche_platform_drvdata *arche_pdata = dev_get_drvdata(dev);
switch (arche_pdata->state) {
case ARCHE_PLATFORM_STATE_OFF:
return sprintf(buf, "off\n");
case ARCHE_PLATFORM_STATE_ACTIVE:
return sprintf(buf, "active\n");
case ARCHE_PLATFORM_STATE_STANDBY:
return sprintf(buf, "standby\n");
case ARCHE_PLATFORM_STATE_FW_FLASHING:
return sprintf(buf, "fw_flashing\n");
default:
return sprintf(buf, "unknown state\n");
}
}
static DEVICE_ATTR_RW(state);
static int arche_platform_pm_notifier(struct notifier_block *notifier,
unsigned long pm_event, void *unused)
{
struct arche_platform_drvdata *arche_pdata =
container_of(notifier, struct arche_platform_drvdata,
pm_notifier);
int ret = NOTIFY_DONE;
mutex_lock(&arche_pdata->platform_state_mutex);
switch (pm_event) {
case PM_SUSPEND_PREPARE:
if (arche_pdata->state != ARCHE_PLATFORM_STATE_ACTIVE) {
ret = NOTIFY_STOP;
break;
}
device_for_each_child(arche_pdata->dev, NULL, apb_poweroff);
arche_platform_poweroff_seq(arche_pdata);
break;
case PM_POST_SUSPEND:
if (arche_pdata->state != ARCHE_PLATFORM_STATE_OFF)
break;
arche_platform_wd_irq_en(arche_pdata);
arche_platform_coldboot_seq(arche_pdata);
break;
default:
break;
}
mutex_unlock(&arche_pdata->platform_state_mutex);
return ret;
}
static int arche_platform_probe(struct platform_device *pdev)
{
struct arche_platform_drvdata *arche_pdata;
struct device *dev = &pdev->dev;
struct device_node *np = dev->of_node;
int ret;
unsigned int flags;
arche_pdata = devm_kzalloc(&pdev->dev, sizeof(*arche_pdata),
GFP_KERNEL);
if (!arche_pdata)
return -ENOMEM;
/* setup svc reset gpio */
arche_pdata->is_reset_act_hi = of_property_read_bool(np,
"svc,reset-active-high");
if (arche_pdata->is_reset_act_hi)
flags = GPIOD_OUT_HIGH;
else
flags = GPIOD_OUT_LOW;
arche_pdata->svc_reset = devm_gpiod_get(dev, "svc,reset", flags);
if (IS_ERR(arche_pdata->svc_reset)) {
ret = PTR_ERR(arche_pdata->svc_reset);
dev_err(dev, "failed to request svc-reset GPIO: %d\n", ret);
return ret;
}
arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_OFF);
arche_pdata->svc_sysboot = devm_gpiod_get(dev, "svc,sysboot",
GPIOD_OUT_LOW);
if (IS_ERR(arche_pdata->svc_sysboot)) {
ret = PTR_ERR(arche_pdata->svc_sysboot);
dev_err(dev, "failed to request sysboot0 GPIO: %d\n", ret);
return ret;
}
/* setup the clock request gpio first */
arche_pdata->svc_refclk_req = devm_gpiod_get(dev, "svc,refclk-req",
GPIOD_IN);
if (IS_ERR(arche_pdata->svc_refclk_req)) {
ret = PTR_ERR(arche_pdata->svc_refclk_req);
dev_err(dev, "failed to request svc-clk-req GPIO: %d\n", ret);
return ret;
}
/* setup refclk2 to follow the pin */
arche_pdata->svc_ref_clk = devm_clk_get(dev, "svc_ref_clk");
if (IS_ERR(arche_pdata->svc_ref_clk)) {
ret = PTR_ERR(arche_pdata->svc_ref_clk);
dev_err(dev, "failed to get svc_ref_clk: %d\n", ret);
return ret;
}
platform_set_drvdata(pdev, arche_pdata);
arche_pdata->num_apbs = of_get_child_count(np);
dev_dbg(dev, "Number of APB's available - %d\n", arche_pdata->num_apbs);
arche_pdata->wake_detect = devm_gpiod_get(dev, "svc,wake-detect",
GPIOD_IN);
if (IS_ERR(arche_pdata->wake_detect)) {
ret = PTR_ERR(arche_pdata->wake_detect);
dev_err(dev, "Failed requesting wake_detect GPIO: %d\n", ret);
return ret;
}
arche_platform_set_wake_detect_state(arche_pdata, WD_STATE_IDLE);
arche_pdata->dev = &pdev->dev;
spin_lock_init(&arche_pdata->wake_lock);
mutex_init(&arche_pdata->platform_state_mutex);
arche_pdata->wake_detect_irq =
gpiod_to_irq(arche_pdata->wake_detect);
ret = devm_request_threaded_irq(dev, arche_pdata->wake_detect_irq,
arche_platform_wd_irq,
arche_platform_wd_irq_thread,
IRQF_TRIGGER_FALLING |
IRQF_TRIGGER_RISING | IRQF_ONESHOT,
dev_name(dev), arche_pdata);
if (ret) {
dev_err(dev, "failed to request wake detect IRQ %d\n", ret);
return ret;
}
disable_irq(arche_pdata->wake_detect_irq);
ret = device_create_file(dev, &dev_attr_state);
if (ret) {
dev_err(dev, "failed to create state file in sysfs\n");
return ret;
}
ret = of_platform_populate(np, NULL, NULL, dev);
if (ret) {
dev_err(dev, "failed to populate child nodes %d\n", ret);
goto err_device_remove;
}
arche_pdata->pm_notifier.notifier_call = arche_platform_pm_notifier;
ret = register_pm_notifier(&arche_pdata->pm_notifier);
if (ret) {
dev_err(dev, "failed to register pm notifier %d\n", ret);
goto err_device_remove;
}
/* Explicitly power off if requested */
if (!of_property_read_bool(pdev->dev.of_node, "arche,init-off")) {
mutex_lock(&arche_pdata->platform_state_mutex);
ret = arche_platform_coldboot_seq(arche_pdata);
if (ret) {
dev_err(dev, "Failed to cold boot svc %d\n", ret);
goto err_coldboot;
}
arche_platform_wd_irq_en(arche_pdata);
mutex_unlock(&arche_pdata->platform_state_mutex);
}
dev_info(dev, "Device registered successfully\n");
return 0;
err_coldboot:
mutex_unlock(&arche_pdata->platform_state_mutex);
err_device_remove:
device_remove_file(&pdev->dev, &dev_attr_state);
return ret;
}
static int arche_remove_child(struct device *dev, void *unused)
{
struct platform_device *pdev = to_platform_device(dev);
platform_device_unregister(pdev);
return 0;
}
static void arche_platform_remove(struct platform_device *pdev)
{
struct arche_platform_drvdata *arche_pdata = platform_get_drvdata(pdev);
unregister_pm_notifier(&arche_pdata->pm_notifier);
device_remove_file(&pdev->dev, &dev_attr_state);
device_for_each_child(&pdev->dev, NULL, arche_remove_child);
arche_platform_poweroff_seq(arche_pdata);
if (usb3613_hub_mode_ctrl(false))
dev_warn(arche_pdata->dev, "failed to control hub device\n");
}
static __maybe_unused int arche_platform_suspend(struct device *dev)
{
/*
* If timing profile premits, we may shutdown bridge
* completely
*
* TODO: sequence ??
*
* Also, need to make sure we meet precondition for unipro suspend
* Precondition: Definition ???
*/
return 0;
}
static __maybe_unused int arche_platform_resume(struct device *dev)
{
/*
* At least for ES2 we have to meet the delay requirement between
* unipro switch and AP bridge init, depending on whether bridge is in
* OFF state or standby state.
*
* Based on whether bridge is in standby or OFF state we may have to
* assert multiple signals. Please refer to WDM spec, for more info.
*
*/
return 0;
}
static void arche_platform_shutdown(struct platform_device *pdev)
{
struct arche_platform_drvdata *arche_pdata = platform_get_drvdata(pdev);
arche_platform_poweroff_seq(arche_pdata);
usb3613_hub_mode_ctrl(false);
}
static SIMPLE_DEV_PM_OPS(arche_platform_pm_ops,
arche_platform_suspend,
arche_platform_resume);
static const struct of_device_id arche_platform_of_match[] = {
/* Use PID/VID of SVC device */
{ .compatible = "google,arche-platform", },
{ },
};
static const struct of_device_id arche_combined_id[] = {
/* Use PID/VID of SVC device */
{ .compatible = "google,arche-platform", },
{ .compatible = "usbffff,2", },
{ },
};
MODULE_DEVICE_TABLE(of, arche_combined_id);
static struct platform_driver arche_platform_device_driver = {
.probe = arche_platform_probe,
.remove_new = arche_platform_remove,
.shutdown = arche_platform_shutdown,
.driver = {
.name = "arche-platform-ctrl",
.pm = &arche_platform_pm_ops,
.of_match_table = arche_platform_of_match,
}
};
static int __init arche_init(void)
{
int retval;
retval = platform_driver_register(&arche_platform_device_driver);
if (retval)
return retval;
retval = arche_apb_init();
if (retval)
platform_driver_unregister(&arche_platform_device_driver);
return retval;
}
module_init(arche_init);
static void __exit arche_exit(void)
{
arche_apb_exit();
platform_driver_unregister(&arche_platform_device_driver);
}
module_exit(arche_exit);
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Vaibhav Hiremath <[email protected]>");
MODULE_DESCRIPTION("Arche Platform Driver");
| linux-master | drivers/staging/greybus/arche-platform.c |
// SPDX-License-Identifier: GPL-2.0
/*
* SD/MMC Greybus driver.
*
* Copyright 2014-2015 Google Inc.
* Copyright 2014-2015 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/mmc/core.h>
#include <linux/mmc/host.h>
#include <linux/mmc/mmc.h>
#include <linux/scatterlist.h>
#include <linux/workqueue.h>
#include <linux/greybus.h>
#include "gbphy.h"
struct gb_sdio_host {
struct gb_connection *connection;
struct gbphy_device *gbphy_dev;
struct mmc_host *mmc;
struct mmc_request *mrq;
struct mutex lock; /* lock for this host */
size_t data_max;
spinlock_t xfer; /* lock to cancel ongoing transfer */
bool xfer_stop;
struct workqueue_struct *mrq_workqueue;
struct work_struct mrqwork;
u8 queued_events;
bool removed;
bool card_present;
bool read_only;
};
#define GB_SDIO_RSP_R1_R5_R6_R7 (GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \
GB_SDIO_RSP_OPCODE)
#define GB_SDIO_RSP_R3_R4 (GB_SDIO_RSP_PRESENT)
#define GB_SDIO_RSP_R2 (GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \
GB_SDIO_RSP_136)
#define GB_SDIO_RSP_R1B (GB_SDIO_RSP_PRESENT | GB_SDIO_RSP_CRC | \
GB_SDIO_RSP_OPCODE | GB_SDIO_RSP_BUSY)
/* kernel vdd starts at 0x80 and we need to translate to greybus ones 0x01 */
#define GB_SDIO_VDD_SHIFT 8
#ifndef MMC_CAP2_CORE_RUNTIME_PM
#define MMC_CAP2_CORE_RUNTIME_PM 0
#endif
static inline bool single_op(struct mmc_command *cmd)
{
u32 opcode = cmd->opcode;
return opcode == MMC_WRITE_BLOCK ||
opcode == MMC_READ_SINGLE_BLOCK;
}
static void _gb_sdio_set_host_caps(struct gb_sdio_host *host, u32 r)
{
u32 caps = 0;
u32 caps2 = 0;
caps = ((r & GB_SDIO_CAP_NONREMOVABLE) ? MMC_CAP_NONREMOVABLE : 0) |
((r & GB_SDIO_CAP_4_BIT_DATA) ? MMC_CAP_4_BIT_DATA : 0) |
((r & GB_SDIO_CAP_8_BIT_DATA) ? MMC_CAP_8_BIT_DATA : 0) |
((r & GB_SDIO_CAP_MMC_HS) ? MMC_CAP_MMC_HIGHSPEED : 0) |
((r & GB_SDIO_CAP_SD_HS) ? MMC_CAP_SD_HIGHSPEED : 0) |
((r & GB_SDIO_CAP_1_2V_DDR) ? MMC_CAP_1_2V_DDR : 0) |
((r & GB_SDIO_CAP_1_8V_DDR) ? MMC_CAP_1_8V_DDR : 0) |
((r & GB_SDIO_CAP_POWER_OFF_CARD) ? MMC_CAP_POWER_OFF_CARD : 0) |
((r & GB_SDIO_CAP_UHS_SDR12) ? MMC_CAP_UHS_SDR12 : 0) |
((r & GB_SDIO_CAP_UHS_SDR25) ? MMC_CAP_UHS_SDR25 : 0) |
((r & GB_SDIO_CAP_UHS_SDR50) ? MMC_CAP_UHS_SDR50 : 0) |
((r & GB_SDIO_CAP_UHS_SDR104) ? MMC_CAP_UHS_SDR104 : 0) |
((r & GB_SDIO_CAP_UHS_DDR50) ? MMC_CAP_UHS_DDR50 : 0) |
((r & GB_SDIO_CAP_DRIVER_TYPE_A) ? MMC_CAP_DRIVER_TYPE_A : 0) |
((r & GB_SDIO_CAP_DRIVER_TYPE_C) ? MMC_CAP_DRIVER_TYPE_C : 0) |
((r & GB_SDIO_CAP_DRIVER_TYPE_D) ? MMC_CAP_DRIVER_TYPE_D : 0);
caps2 = ((r & GB_SDIO_CAP_HS200_1_2V) ? MMC_CAP2_HS200_1_2V_SDR : 0) |
((r & GB_SDIO_CAP_HS400_1_2V) ? MMC_CAP2_HS400_1_2V : 0) |
((r & GB_SDIO_CAP_HS400_1_8V) ? MMC_CAP2_HS400_1_8V : 0) |
((r & GB_SDIO_CAP_HS200_1_8V) ? MMC_CAP2_HS200_1_8V_SDR : 0);
host->mmc->caps = caps;
host->mmc->caps2 = caps2 | MMC_CAP2_CORE_RUNTIME_PM;
if (caps & MMC_CAP_NONREMOVABLE)
host->card_present = true;
}
static u32 _gb_sdio_get_host_ocr(u32 ocr)
{
return (((ocr & GB_SDIO_VDD_165_195) ? MMC_VDD_165_195 : 0) |
((ocr & GB_SDIO_VDD_20_21) ? MMC_VDD_20_21 : 0) |
((ocr & GB_SDIO_VDD_21_22) ? MMC_VDD_21_22 : 0) |
((ocr & GB_SDIO_VDD_22_23) ? MMC_VDD_22_23 : 0) |
((ocr & GB_SDIO_VDD_23_24) ? MMC_VDD_23_24 : 0) |
((ocr & GB_SDIO_VDD_24_25) ? MMC_VDD_24_25 : 0) |
((ocr & GB_SDIO_VDD_25_26) ? MMC_VDD_25_26 : 0) |
((ocr & GB_SDIO_VDD_26_27) ? MMC_VDD_26_27 : 0) |
((ocr & GB_SDIO_VDD_27_28) ? MMC_VDD_27_28 : 0) |
((ocr & GB_SDIO_VDD_28_29) ? MMC_VDD_28_29 : 0) |
((ocr & GB_SDIO_VDD_29_30) ? MMC_VDD_29_30 : 0) |
((ocr & GB_SDIO_VDD_30_31) ? MMC_VDD_30_31 : 0) |
((ocr & GB_SDIO_VDD_31_32) ? MMC_VDD_31_32 : 0) |
((ocr & GB_SDIO_VDD_32_33) ? MMC_VDD_32_33 : 0) |
((ocr & GB_SDIO_VDD_33_34) ? MMC_VDD_33_34 : 0) |
((ocr & GB_SDIO_VDD_34_35) ? MMC_VDD_34_35 : 0) |
((ocr & GB_SDIO_VDD_35_36) ? MMC_VDD_35_36 : 0)
);
}
static int gb_sdio_get_caps(struct gb_sdio_host *host)
{
struct gb_sdio_get_caps_response response;
struct mmc_host *mmc = host->mmc;
u16 data_max;
u32 blksz;
u32 ocr;
u32 r;
int ret;
ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_GET_CAPABILITIES,
NULL, 0, &response, sizeof(response));
if (ret < 0)
return ret;
r = le32_to_cpu(response.caps);
_gb_sdio_set_host_caps(host, r);
/* get the max block size that could fit our payload */
data_max = gb_operation_get_payload_size_max(host->connection);
data_max = min(data_max - sizeof(struct gb_sdio_transfer_request),
data_max - sizeof(struct gb_sdio_transfer_response));
blksz = min_t(u16, le16_to_cpu(response.max_blk_size), data_max);
blksz = max_t(u32, 512, blksz);
mmc->max_blk_size = rounddown_pow_of_two(blksz);
mmc->max_blk_count = le16_to_cpu(response.max_blk_count);
host->data_max = data_max;
/* get ocr supported values */
ocr = _gb_sdio_get_host_ocr(le32_to_cpu(response.ocr));
mmc->ocr_avail = ocr;
mmc->ocr_avail_sdio = mmc->ocr_avail;
mmc->ocr_avail_sd = mmc->ocr_avail;
mmc->ocr_avail_mmc = mmc->ocr_avail;
/* get frequency range values */
mmc->f_min = le32_to_cpu(response.f_min);
mmc->f_max = le32_to_cpu(response.f_max);
return 0;
}
static void _gb_queue_event(struct gb_sdio_host *host, u8 event)
{
if (event & GB_SDIO_CARD_INSERTED)
host->queued_events &= ~GB_SDIO_CARD_REMOVED;
else if (event & GB_SDIO_CARD_REMOVED)
host->queued_events &= ~GB_SDIO_CARD_INSERTED;
host->queued_events |= event;
}
static int _gb_sdio_process_events(struct gb_sdio_host *host, u8 event)
{
u8 state_changed = 0;
if (event & GB_SDIO_CARD_INSERTED) {
if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
return 0;
if (host->card_present)
return 0;
host->card_present = true;
state_changed = 1;
}
if (event & GB_SDIO_CARD_REMOVED) {
if (host->mmc->caps & MMC_CAP_NONREMOVABLE)
return 0;
if (!(host->card_present))
return 0;
host->card_present = false;
state_changed = 1;
}
if (event & GB_SDIO_WP)
host->read_only = true;
if (state_changed) {
dev_info(mmc_dev(host->mmc), "card %s now event\n",
(host->card_present ? "inserted" : "removed"));
mmc_detect_change(host->mmc, 0);
}
return 0;
}
static int gb_sdio_request_handler(struct gb_operation *op)
{
struct gb_sdio_host *host = gb_connection_get_data(op->connection);
struct gb_message *request;
struct gb_sdio_event_request *payload;
u8 type = op->type;
int ret = 0;
u8 event;
if (type != GB_SDIO_TYPE_EVENT) {
dev_err(mmc_dev(host->mmc),
"unsupported unsolicited event: %u\n", type);
return -EINVAL;
}
request = op->request;
if (request->payload_size < sizeof(*payload)) {
dev_err(mmc_dev(host->mmc), "wrong event size received (%zu < %zu)\n",
request->payload_size, sizeof(*payload));
return -EINVAL;
}
payload = request->payload;
event = payload->event;
if (host->removed)
_gb_queue_event(host, event);
else
ret = _gb_sdio_process_events(host, event);
return ret;
}
static int gb_sdio_set_ios(struct gb_sdio_host *host,
struct gb_sdio_set_ios_request *request)
{
int ret;
ret = gbphy_runtime_get_sync(host->gbphy_dev);
if (ret)
return ret;
ret = gb_operation_sync(host->connection, GB_SDIO_TYPE_SET_IOS, request,
sizeof(*request), NULL, 0);
gbphy_runtime_put_autosuspend(host->gbphy_dev);
return ret;
}
static int _gb_sdio_send(struct gb_sdio_host *host, struct mmc_data *data,
size_t len, u16 nblocks, off_t skip)
{
struct gb_sdio_transfer_request *request;
struct gb_sdio_transfer_response *response;
struct gb_operation *operation;
struct scatterlist *sg = data->sg;
unsigned int sg_len = data->sg_len;
size_t copied;
u16 send_blksz;
u16 send_blocks;
int ret;
WARN_ON(len > host->data_max);
operation = gb_operation_create(host->connection, GB_SDIO_TYPE_TRANSFER,
len + sizeof(*request),
sizeof(*response), GFP_KERNEL);
if (!operation)
return -ENOMEM;
request = operation->request->payload;
request->data_flags = data->flags >> 8;
request->data_blocks = cpu_to_le16(nblocks);
request->data_blksz = cpu_to_le16(data->blksz);
copied = sg_pcopy_to_buffer(sg, sg_len, &request->data[0], len, skip);
if (copied != len) {
ret = -EINVAL;
goto err_put_operation;
}
ret = gb_operation_request_send_sync(operation);
if (ret < 0)
goto err_put_operation;
response = operation->response->payload;
send_blocks = le16_to_cpu(response->data_blocks);
send_blksz = le16_to_cpu(response->data_blksz);
if (len != send_blksz * send_blocks) {
dev_err(mmc_dev(host->mmc), "send: size received: %zu != %d\n",
len, send_blksz * send_blocks);
ret = -EINVAL;
}
err_put_operation:
gb_operation_put(operation);
return ret;
}
static int _gb_sdio_recv(struct gb_sdio_host *host, struct mmc_data *data,
size_t len, u16 nblocks, off_t skip)
{
struct gb_sdio_transfer_request *request;
struct gb_sdio_transfer_response *response;
struct gb_operation *operation;
struct scatterlist *sg = data->sg;
unsigned int sg_len = data->sg_len;
size_t copied;
u16 recv_blksz;
u16 recv_blocks;
int ret;
WARN_ON(len > host->data_max);
operation = gb_operation_create(host->connection, GB_SDIO_TYPE_TRANSFER,
sizeof(*request),
len + sizeof(*response), GFP_KERNEL);
if (!operation)
return -ENOMEM;
request = operation->request->payload;
request->data_flags = data->flags >> 8;
request->data_blocks = cpu_to_le16(nblocks);
request->data_blksz = cpu_to_le16(data->blksz);
ret = gb_operation_request_send_sync(operation);
if (ret < 0)
goto err_put_operation;
response = operation->response->payload;
recv_blocks = le16_to_cpu(response->data_blocks);
recv_blksz = le16_to_cpu(response->data_blksz);
if (len != recv_blksz * recv_blocks) {
dev_err(mmc_dev(host->mmc), "recv: size received: %d != %zu\n",
recv_blksz * recv_blocks, len);
ret = -EINVAL;
goto err_put_operation;
}
copied = sg_pcopy_from_buffer(sg, sg_len, &response->data[0], len,
skip);
if (copied != len)
ret = -EINVAL;
err_put_operation:
gb_operation_put(operation);
return ret;
}
static int gb_sdio_transfer(struct gb_sdio_host *host, struct mmc_data *data)
{
size_t left, len;
off_t skip = 0;
int ret = 0;
u16 nblocks;
if (single_op(data->mrq->cmd) && data->blocks > 1) {
ret = -ETIMEDOUT;
goto out;
}
left = data->blksz * data->blocks;
while (left) {
/* check is a stop transmission is pending */
spin_lock(&host->xfer);
if (host->xfer_stop) {
host->xfer_stop = false;
spin_unlock(&host->xfer);
ret = -EINTR;
goto out;
}
spin_unlock(&host->xfer);
len = min(left, host->data_max);
nblocks = len / data->blksz;
len = nblocks * data->blksz;
if (data->flags & MMC_DATA_READ) {
ret = _gb_sdio_recv(host, data, len, nblocks, skip);
if (ret < 0)
goto out;
} else {
ret = _gb_sdio_send(host, data, len, nblocks, skip);
if (ret < 0)
goto out;
}
data->bytes_xfered += len;
left -= len;
skip += len;
}
out:
data->error = ret;
return ret;
}
static int gb_sdio_command(struct gb_sdio_host *host, struct mmc_command *cmd)
{
struct gb_sdio_command_request request = {0};
struct gb_sdio_command_response response;
struct mmc_data *data = host->mrq->data;
unsigned int timeout_ms;
u8 cmd_flags;
u8 cmd_type;
int i;
int ret;
switch (mmc_resp_type(cmd)) {
case MMC_RSP_NONE:
cmd_flags = GB_SDIO_RSP_NONE;
break;
case MMC_RSP_R1:
cmd_flags = GB_SDIO_RSP_R1_R5_R6_R7;
break;
case MMC_RSP_R1B:
cmd_flags = GB_SDIO_RSP_R1B;
break;
case MMC_RSP_R2:
cmd_flags = GB_SDIO_RSP_R2;
break;
case MMC_RSP_R3:
cmd_flags = GB_SDIO_RSP_R3_R4;
break;
default:
dev_err(mmc_dev(host->mmc), "cmd flag invalid 0x%04x\n",
mmc_resp_type(cmd));
ret = -EINVAL;
goto out;
}
switch (mmc_cmd_type(cmd)) {
case MMC_CMD_BC:
cmd_type = GB_SDIO_CMD_BC;
break;
case MMC_CMD_BCR:
cmd_type = GB_SDIO_CMD_BCR;
break;
case MMC_CMD_AC:
cmd_type = GB_SDIO_CMD_AC;
break;
case MMC_CMD_ADTC:
cmd_type = GB_SDIO_CMD_ADTC;
break;
default:
dev_err(mmc_dev(host->mmc), "cmd type invalid 0x%04x\n",
mmc_cmd_type(cmd));
ret = -EINVAL;
goto out;
}
request.cmd = cmd->opcode;
request.cmd_flags = cmd_flags;
request.cmd_type = cmd_type;
request.cmd_arg = cpu_to_le32(cmd->arg);
/* some controllers need to know at command time data details */
if (data) {
request.data_blocks = cpu_to_le16(data->blocks);
request.data_blksz = cpu_to_le16(data->blksz);
}
timeout_ms = cmd->busy_timeout ? cmd->busy_timeout :
GB_OPERATION_TIMEOUT_DEFAULT;
ret = gb_operation_sync_timeout(host->connection, GB_SDIO_TYPE_COMMAND,
&request, sizeof(request), &response,
sizeof(response), timeout_ms);
if (ret < 0)
goto out;
/* no response expected */
if (cmd_flags == GB_SDIO_RSP_NONE)
goto out;
/* long response expected */
if (cmd_flags & GB_SDIO_RSP_R2)
for (i = 0; i < 4; i++)
cmd->resp[i] = le32_to_cpu(response.resp[i]);
else
cmd->resp[0] = le32_to_cpu(response.resp[0]);
out:
cmd->error = ret;
return ret;
}
static void gb_sdio_mrq_work(struct work_struct *work)
{
struct gb_sdio_host *host;
struct mmc_request *mrq;
int ret;
host = container_of(work, struct gb_sdio_host, mrqwork);
ret = gbphy_runtime_get_sync(host->gbphy_dev);
if (ret)
return;
mutex_lock(&host->lock);
mrq = host->mrq;
if (!mrq) {
mutex_unlock(&host->lock);
gbphy_runtime_put_autosuspend(host->gbphy_dev);
dev_err(mmc_dev(host->mmc), "mmc request is NULL");
return;
}
if (host->removed) {
mrq->cmd->error = -ESHUTDOWN;
goto done;
}
if (mrq->sbc) {
ret = gb_sdio_command(host, mrq->sbc);
if (ret < 0)
goto done;
}
ret = gb_sdio_command(host, mrq->cmd);
if (ret < 0)
goto done;
if (mrq->data) {
ret = gb_sdio_transfer(host, mrq->data);
if (ret < 0)
goto done;
}
if (mrq->stop) {
ret = gb_sdio_command(host, mrq->stop);
if (ret < 0)
goto done;
}
done:
host->mrq = NULL;
mutex_unlock(&host->lock);
mmc_request_done(host->mmc, mrq);
gbphy_runtime_put_autosuspend(host->gbphy_dev);
}
static void gb_mmc_request(struct mmc_host *mmc, struct mmc_request *mrq)
{
struct gb_sdio_host *host = mmc_priv(mmc);
struct mmc_command *cmd = mrq->cmd;
/* Check if it is a cancel to ongoing transfer */
if (cmd->opcode == MMC_STOP_TRANSMISSION) {
spin_lock(&host->xfer);
host->xfer_stop = true;
spin_unlock(&host->xfer);
}
mutex_lock(&host->lock);
WARN_ON(host->mrq);
host->mrq = mrq;
if (host->removed) {
mrq->cmd->error = -ESHUTDOWN;
goto out;
}
if (!host->card_present) {
mrq->cmd->error = -ENOMEDIUM;
goto out;
}
queue_work(host->mrq_workqueue, &host->mrqwork);
mutex_unlock(&host->lock);
return;
out:
host->mrq = NULL;
mutex_unlock(&host->lock);
mmc_request_done(mmc, mrq);
}
static void gb_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
{
struct gb_sdio_host *host = mmc_priv(mmc);
struct gb_sdio_set_ios_request request;
int ret;
u8 power_mode;
u8 bus_width;
u8 timing;
u8 signal_voltage;
u8 drv_type;
u32 vdd = 0;
mutex_lock(&host->lock);
request.clock = cpu_to_le32(ios->clock);
if (ios->vdd)
vdd = 1 << (ios->vdd - GB_SDIO_VDD_SHIFT);
request.vdd = cpu_to_le32(vdd);
request.bus_mode = ios->bus_mode == MMC_BUSMODE_OPENDRAIN ?
GB_SDIO_BUSMODE_OPENDRAIN :
GB_SDIO_BUSMODE_PUSHPULL;
switch (ios->power_mode) {
case MMC_POWER_OFF:
default:
power_mode = GB_SDIO_POWER_OFF;
break;
case MMC_POWER_UP:
power_mode = GB_SDIO_POWER_UP;
break;
case MMC_POWER_ON:
power_mode = GB_SDIO_POWER_ON;
break;
case MMC_POWER_UNDEFINED:
power_mode = GB_SDIO_POWER_UNDEFINED;
break;
}
request.power_mode = power_mode;
switch (ios->bus_width) {
case MMC_BUS_WIDTH_1:
bus_width = GB_SDIO_BUS_WIDTH_1;
break;
case MMC_BUS_WIDTH_4:
default:
bus_width = GB_SDIO_BUS_WIDTH_4;
break;
case MMC_BUS_WIDTH_8:
bus_width = GB_SDIO_BUS_WIDTH_8;
break;
}
request.bus_width = bus_width;
switch (ios->timing) {
case MMC_TIMING_LEGACY:
default:
timing = GB_SDIO_TIMING_LEGACY;
break;
case MMC_TIMING_MMC_HS:
timing = GB_SDIO_TIMING_MMC_HS;
break;
case MMC_TIMING_SD_HS:
timing = GB_SDIO_TIMING_SD_HS;
break;
case MMC_TIMING_UHS_SDR12:
timing = GB_SDIO_TIMING_UHS_SDR12;
break;
case MMC_TIMING_UHS_SDR25:
timing = GB_SDIO_TIMING_UHS_SDR25;
break;
case MMC_TIMING_UHS_SDR50:
timing = GB_SDIO_TIMING_UHS_SDR50;
break;
case MMC_TIMING_UHS_SDR104:
timing = GB_SDIO_TIMING_UHS_SDR104;
break;
case MMC_TIMING_UHS_DDR50:
timing = GB_SDIO_TIMING_UHS_DDR50;
break;
case MMC_TIMING_MMC_DDR52:
timing = GB_SDIO_TIMING_MMC_DDR52;
break;
case MMC_TIMING_MMC_HS200:
timing = GB_SDIO_TIMING_MMC_HS200;
break;
case MMC_TIMING_MMC_HS400:
timing = GB_SDIO_TIMING_MMC_HS400;
break;
}
request.timing = timing;
switch (ios->signal_voltage) {
case MMC_SIGNAL_VOLTAGE_330:
signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_330;
break;
case MMC_SIGNAL_VOLTAGE_180:
default:
signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_180;
break;
case MMC_SIGNAL_VOLTAGE_120:
signal_voltage = GB_SDIO_SIGNAL_VOLTAGE_120;
break;
}
request.signal_voltage = signal_voltage;
switch (ios->drv_type) {
case MMC_SET_DRIVER_TYPE_A:
drv_type = GB_SDIO_SET_DRIVER_TYPE_A;
break;
case MMC_SET_DRIVER_TYPE_C:
drv_type = GB_SDIO_SET_DRIVER_TYPE_C;
break;
case MMC_SET_DRIVER_TYPE_D:
drv_type = GB_SDIO_SET_DRIVER_TYPE_D;
break;
case MMC_SET_DRIVER_TYPE_B:
default:
drv_type = GB_SDIO_SET_DRIVER_TYPE_B;
break;
}
request.drv_type = drv_type;
ret = gb_sdio_set_ios(host, &request);
if (ret < 0)
goto out;
memcpy(&mmc->ios, ios, sizeof(mmc->ios));
out:
mutex_unlock(&host->lock);
}
static int gb_mmc_get_ro(struct mmc_host *mmc)
{
struct gb_sdio_host *host = mmc_priv(mmc);
mutex_lock(&host->lock);
if (host->removed) {
mutex_unlock(&host->lock);
return -ESHUTDOWN;
}
mutex_unlock(&host->lock);
return host->read_only;
}
static int gb_mmc_get_cd(struct mmc_host *mmc)
{
struct gb_sdio_host *host = mmc_priv(mmc);
mutex_lock(&host->lock);
if (host->removed) {
mutex_unlock(&host->lock);
return -ESHUTDOWN;
}
mutex_unlock(&host->lock);
return host->card_present;
}
static int gb_mmc_switch_voltage(struct mmc_host *mmc, struct mmc_ios *ios)
{
return 0;
}
static const struct mmc_host_ops gb_sdio_ops = {
.request = gb_mmc_request,
.set_ios = gb_mmc_set_ios,
.get_ro = gb_mmc_get_ro,
.get_cd = gb_mmc_get_cd,
.start_signal_voltage_switch = gb_mmc_switch_voltage,
};
static int gb_sdio_probe(struct gbphy_device *gbphy_dev,
const struct gbphy_device_id *id)
{
struct gb_connection *connection;
struct mmc_host *mmc;
struct gb_sdio_host *host;
int ret = 0;
mmc = mmc_alloc_host(sizeof(*host), &gbphy_dev->dev);
if (!mmc)
return -ENOMEM;
connection = gb_connection_create(gbphy_dev->bundle,
le16_to_cpu(gbphy_dev->cport_desc->id),
gb_sdio_request_handler);
if (IS_ERR(connection)) {
ret = PTR_ERR(connection);
goto exit_mmc_free;
}
host = mmc_priv(mmc);
host->mmc = mmc;
host->removed = true;
host->connection = connection;
gb_connection_set_data(connection, host);
host->gbphy_dev = gbphy_dev;
gb_gbphy_set_data(gbphy_dev, host);
ret = gb_connection_enable_tx(connection);
if (ret)
goto exit_connection_destroy;
ret = gb_sdio_get_caps(host);
if (ret < 0)
goto exit_connection_disable;
mmc->ops = &gb_sdio_ops;
mmc->max_segs = host->mmc->max_blk_count;
/* for now we make a map 1:1 between max request and segment size */
mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
mmc->max_seg_size = mmc->max_req_size;
mutex_init(&host->lock);
spin_lock_init(&host->xfer);
host->mrq_workqueue = alloc_workqueue("mmc-%s", 0, 1,
dev_name(&gbphy_dev->dev));
if (!host->mrq_workqueue) {
ret = -ENOMEM;
goto exit_connection_disable;
}
INIT_WORK(&host->mrqwork, gb_sdio_mrq_work);
ret = gb_connection_enable(connection);
if (ret)
goto exit_wq_destroy;
ret = mmc_add_host(mmc);
if (ret < 0)
goto exit_wq_destroy;
host->removed = false;
ret = _gb_sdio_process_events(host, host->queued_events);
host->queued_events = 0;
gbphy_runtime_put_autosuspend(gbphy_dev);
return ret;
exit_wq_destroy:
destroy_workqueue(host->mrq_workqueue);
exit_connection_disable:
gb_connection_disable(connection);
exit_connection_destroy:
gb_connection_destroy(connection);
exit_mmc_free:
mmc_free_host(mmc);
return ret;
}
static void gb_sdio_remove(struct gbphy_device *gbphy_dev)
{
struct gb_sdio_host *host = gb_gbphy_get_data(gbphy_dev);
struct gb_connection *connection = host->connection;
struct mmc_host *mmc;
int ret;
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
gbphy_runtime_get_noresume(gbphy_dev);
mutex_lock(&host->lock);
host->removed = true;
mmc = host->mmc;
gb_connection_set_data(connection, NULL);
mutex_unlock(&host->lock);
destroy_workqueue(host->mrq_workqueue);
gb_connection_disable_rx(connection);
mmc_remove_host(mmc);
gb_connection_disable(connection);
gb_connection_destroy(connection);
mmc_free_host(mmc);
}
static const struct gbphy_device_id gb_sdio_id_table[] = {
{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_SDIO) },
{ },
};
MODULE_DEVICE_TABLE(gbphy, gb_sdio_id_table);
static struct gbphy_driver sdio_driver = {
.name = "sdio",
.probe = gb_sdio_probe,
.remove = gb_sdio_remove,
.id_table = gb_sdio_id_table,
};
module_gbphy_driver(sdio_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/sdio.c |
// SPDX-License-Identifier: GPL-2.0
/*
* BOOTROM Greybus driver.
*
* Copyright 2016 Google Inc.
* Copyright 2016 Linaro Ltd.
*/
#include <linux/firmware.h>
#include <linux/jiffies.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>
#include <linux/greybus.h>
#include "firmware.h"
/* Timeout, in jiffies, within which the next request must be received */
#define NEXT_REQ_TIMEOUT_MS 1000
/*
* FIXME: Reduce this timeout once svc core handles parallel processing of
* events from the SVC, which are handled sequentially today.
*/
#define MODE_SWITCH_TIMEOUT_MS 10000
enum next_request_type {
NEXT_REQ_FIRMWARE_SIZE,
NEXT_REQ_GET_FIRMWARE,
NEXT_REQ_READY_TO_BOOT,
NEXT_REQ_MODE_SWITCH,
};
struct gb_bootrom {
struct gb_connection *connection;
const struct firmware *fw;
u8 protocol_major;
u8 protocol_minor;
enum next_request_type next_request;
struct delayed_work dwork;
struct mutex mutex; /* Protects bootrom->fw */
};
static void free_firmware(struct gb_bootrom *bootrom)
{
if (!bootrom->fw)
return;
release_firmware(bootrom->fw);
bootrom->fw = NULL;
}
static void gb_bootrom_timedout(struct work_struct *work)
{
struct delayed_work *dwork = to_delayed_work(work);
struct gb_bootrom *bootrom = container_of(dwork,
struct gb_bootrom, dwork);
struct device *dev = &bootrom->connection->bundle->dev;
const char *reason;
switch (bootrom->next_request) {
case NEXT_REQ_FIRMWARE_SIZE:
reason = "Firmware Size Request";
break;
case NEXT_REQ_GET_FIRMWARE:
reason = "Get Firmware Request";
break;
case NEXT_REQ_READY_TO_BOOT:
reason = "Ready to Boot Request";
break;
case NEXT_REQ_MODE_SWITCH:
reason = "Interface Mode Switch";
break;
default:
reason = NULL;
dev_err(dev, "Invalid next-request: %u", bootrom->next_request);
break;
}
dev_err(dev, "Timed out waiting for %s from the Module\n", reason);
mutex_lock(&bootrom->mutex);
free_firmware(bootrom);
mutex_unlock(&bootrom->mutex);
/* TODO: Power-off Module ? */
}
static void gb_bootrom_set_timeout(struct gb_bootrom *bootrom,
enum next_request_type next,
unsigned long timeout)
{
bootrom->next_request = next;
schedule_delayed_work(&bootrom->dwork, msecs_to_jiffies(timeout));
}
static void gb_bootrom_cancel_timeout(struct gb_bootrom *bootrom)
{
cancel_delayed_work_sync(&bootrom->dwork);
}
/*
* The es2 chip doesn't have VID/PID programmed into the hardware and we need to
* hack that up to distinguish different modules and their firmware blobs.
*
* This fetches VID/PID (over bootrom protocol) for es2 chip only, when VID/PID
* already sent during hotplug are 0.
*
* Otherwise, we keep intf->vendor_id/product_id same as what's passed
* during hotplug.
*/
static void bootrom_es2_fixup_vid_pid(struct gb_bootrom *bootrom)
{
struct gb_bootrom_get_vid_pid_response response;
struct gb_connection *connection = bootrom->connection;
struct gb_interface *intf = connection->bundle->intf;
int ret;
if (!(intf->quirks & GB_INTERFACE_QUIRK_NO_GMP_IDS))
return;
ret = gb_operation_sync(connection, GB_BOOTROM_TYPE_GET_VID_PID,
NULL, 0, &response, sizeof(response));
if (ret) {
dev_err(&connection->bundle->dev,
"Bootrom get vid/pid operation failed (%d)\n", ret);
return;
}
/*
* NOTE: This is hacked, so that the same values of VID/PID can be used
* by next firmware level as well. The uevent for bootrom will still
* have VID/PID as 0, though after this point the sysfs files will start
* showing the updated values. But yeah, that's a bit racy as the same
* sysfs files would be showing 0 before this point.
*/
intf->vendor_id = le32_to_cpu(response.vendor_id);
intf->product_id = le32_to_cpu(response.product_id);
dev_dbg(&connection->bundle->dev, "Bootrom got vid (0x%x)/pid (0x%x)\n",
intf->vendor_id, intf->product_id);
}
/* This returns path of the firmware blob on the disk */
static int find_firmware(struct gb_bootrom *bootrom, u8 stage)
{
struct gb_connection *connection = bootrom->connection;
struct gb_interface *intf = connection->bundle->intf;
char firmware_name[49];
int rc;
/* Already have a firmware, free it */
free_firmware(bootrom);
/* Bootrom protocol is only supported for loading Stage 2 firmware */
if (stage != 2) {
dev_err(&connection->bundle->dev, "Invalid boot stage: %u\n",
stage);
return -EINVAL;
}
/*
* Create firmware name
*
* XXX Name it properly..
*/
snprintf(firmware_name, sizeof(firmware_name),
FW_NAME_PREFIX "%08x_%08x_%08x_%08x_s2l.tftf",
intf->ddbl1_manufacturer_id, intf->ddbl1_product_id,
intf->vendor_id, intf->product_id);
// FIXME:
// Turn to dev_dbg later after everyone has valid bootloaders with good
// ids, but leave this as dev_info for now to make it easier to track
// down "empty" vid/pid modules.
dev_info(&connection->bundle->dev, "Firmware file '%s' requested\n",
firmware_name);
rc = request_firmware(&bootrom->fw, firmware_name,
&connection->bundle->dev);
if (rc) {
dev_err(&connection->bundle->dev,
"failed to find %s firmware (%d)\n", firmware_name, rc);
}
return rc;
}
static int gb_bootrom_firmware_size_request(struct gb_operation *op)
{
struct gb_bootrom *bootrom = gb_connection_get_data(op->connection);
struct gb_bootrom_firmware_size_request *size_request =
op->request->payload;
struct gb_bootrom_firmware_size_response *size_response;
struct device *dev = &op->connection->bundle->dev;
int ret;
/* Disable timeouts */
gb_bootrom_cancel_timeout(bootrom);
if (op->request->payload_size != sizeof(*size_request)) {
dev_err(dev, "%s: illegal size of firmware size request (%zu != %zu)\n",
__func__, op->request->payload_size,
sizeof(*size_request));
ret = -EINVAL;
goto queue_work;
}
mutex_lock(&bootrom->mutex);
ret = find_firmware(bootrom, size_request->stage);
if (ret)
goto unlock;
if (!gb_operation_response_alloc(op, sizeof(*size_response),
GFP_KERNEL)) {
dev_err(dev, "%s: error allocating response\n", __func__);
free_firmware(bootrom);
ret = -ENOMEM;
goto unlock;
}
size_response = op->response->payload;
size_response->size = cpu_to_le32(bootrom->fw->size);
dev_dbg(dev, "%s: firmware size %d bytes\n",
__func__, size_response->size);
unlock:
mutex_unlock(&bootrom->mutex);
queue_work:
if (!ret) {
/* Refresh timeout */
gb_bootrom_set_timeout(bootrom, NEXT_REQ_GET_FIRMWARE,
NEXT_REQ_TIMEOUT_MS);
}
return ret;
}
static int gb_bootrom_get_firmware(struct gb_operation *op)
{
struct gb_bootrom *bootrom = gb_connection_get_data(op->connection);
const struct firmware *fw;
struct gb_bootrom_get_firmware_request *firmware_request;
struct gb_bootrom_get_firmware_response *firmware_response;
struct device *dev = &op->connection->bundle->dev;
unsigned int offset, size;
enum next_request_type next_request;
int ret = 0;
/* Disable timeouts */
gb_bootrom_cancel_timeout(bootrom);
if (op->request->payload_size != sizeof(*firmware_request)) {
dev_err(dev, "%s: Illegal size of get firmware request (%zu %zu)\n",
__func__, op->request->payload_size,
sizeof(*firmware_request));
ret = -EINVAL;
goto queue_work;
}
mutex_lock(&bootrom->mutex);
fw = bootrom->fw;
if (!fw) {
dev_err(dev, "%s: firmware not available\n", __func__);
ret = -EINVAL;
goto unlock;
}
firmware_request = op->request->payload;
offset = le32_to_cpu(firmware_request->offset);
size = le32_to_cpu(firmware_request->size);
if (offset >= fw->size || size > fw->size - offset) {
dev_warn(dev, "bad firmware request (offs = %u, size = %u)\n",
offset, size);
ret = -EINVAL;
goto unlock;
}
if (!gb_operation_response_alloc(op, sizeof(*firmware_response) + size,
GFP_KERNEL)) {
dev_err(dev, "%s: error allocating response\n", __func__);
ret = -ENOMEM;
goto unlock;
}
firmware_response = op->response->payload;
memcpy(firmware_response->data, fw->data + offset, size);
dev_dbg(dev, "responding with firmware (offs = %u, size = %u)\n",
offset, size);
unlock:
mutex_unlock(&bootrom->mutex);
queue_work:
/* Refresh timeout */
if (!ret && (offset + size == fw->size))
next_request = NEXT_REQ_READY_TO_BOOT;
else
next_request = NEXT_REQ_GET_FIRMWARE;
gb_bootrom_set_timeout(bootrom, next_request, NEXT_REQ_TIMEOUT_MS);
return ret;
}
static int gb_bootrom_ready_to_boot(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_bootrom *bootrom = gb_connection_get_data(connection);
struct gb_bootrom_ready_to_boot_request *rtb_request;
struct device *dev = &connection->bundle->dev;
u8 status;
int ret = 0;
/* Disable timeouts */
gb_bootrom_cancel_timeout(bootrom);
if (op->request->payload_size != sizeof(*rtb_request)) {
dev_err(dev, "%s: Illegal size of ready to boot request (%zu %zu)\n",
__func__, op->request->payload_size,
sizeof(*rtb_request));
ret = -EINVAL;
goto queue_work;
}
rtb_request = op->request->payload;
status = rtb_request->status;
/* Return error if the blob was invalid */
if (status == GB_BOOTROM_BOOT_STATUS_INVALID) {
ret = -EINVAL;
goto queue_work;
}
/*
* XXX Should we return error for insecure firmware?
*/
dev_dbg(dev, "ready to boot: 0x%x, 0\n", status);
queue_work:
/*
* Refresh timeout, the Interface shall load the new personality and
* send a new hotplug request, which shall get rid of the bootrom
* connection. As that can take some time, increase the timeout a bit.
*/
gb_bootrom_set_timeout(bootrom, NEXT_REQ_MODE_SWITCH,
MODE_SWITCH_TIMEOUT_MS);
return ret;
}
static int gb_bootrom_request_handler(struct gb_operation *op)
{
u8 type = op->type;
switch (type) {
case GB_BOOTROM_TYPE_FIRMWARE_SIZE:
return gb_bootrom_firmware_size_request(op);
case GB_BOOTROM_TYPE_GET_FIRMWARE:
return gb_bootrom_get_firmware(op);
case GB_BOOTROM_TYPE_READY_TO_BOOT:
return gb_bootrom_ready_to_boot(op);
default:
dev_err(&op->connection->bundle->dev,
"unsupported request: %u\n", type);
return -EINVAL;
}
}
static int gb_bootrom_get_version(struct gb_bootrom *bootrom)
{
struct gb_bundle *bundle = bootrom->connection->bundle;
struct gb_bootrom_version_request request;
struct gb_bootrom_version_response response;
int ret;
request.major = GB_BOOTROM_VERSION_MAJOR;
request.minor = GB_BOOTROM_VERSION_MINOR;
ret = gb_operation_sync(bootrom->connection,
GB_BOOTROM_TYPE_VERSION,
&request, sizeof(request), &response,
sizeof(response));
if (ret) {
dev_err(&bundle->dev,
"failed to get protocol version: %d\n",
ret);
return ret;
}
if (response.major > request.major) {
dev_err(&bundle->dev,
"unsupported major protocol version (%u > %u)\n",
response.major, request.major);
return -ENOTSUPP;
}
bootrom->protocol_major = response.major;
bootrom->protocol_minor = response.minor;
dev_dbg(&bundle->dev, "%s - %u.%u\n", __func__, response.major,
response.minor);
return 0;
}
static int gb_bootrom_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct greybus_descriptor_cport *cport_desc;
struct gb_connection *connection;
struct gb_bootrom *bootrom;
int ret;
if (bundle->num_cports != 1)
return -ENODEV;
cport_desc = &bundle->cport_desc[0];
if (cport_desc->protocol_id != GREYBUS_PROTOCOL_BOOTROM)
return -ENODEV;
bootrom = kzalloc(sizeof(*bootrom), GFP_KERNEL);
if (!bootrom)
return -ENOMEM;
connection = gb_connection_create(bundle,
le16_to_cpu(cport_desc->id),
gb_bootrom_request_handler);
if (IS_ERR(connection)) {
ret = PTR_ERR(connection);
goto err_free_bootrom;
}
gb_connection_set_data(connection, bootrom);
bootrom->connection = connection;
mutex_init(&bootrom->mutex);
INIT_DELAYED_WORK(&bootrom->dwork, gb_bootrom_timedout);
greybus_set_drvdata(bundle, bootrom);
ret = gb_connection_enable_tx(connection);
if (ret)
goto err_connection_destroy;
ret = gb_bootrom_get_version(bootrom);
if (ret)
goto err_connection_disable;
bootrom_es2_fixup_vid_pid(bootrom);
ret = gb_connection_enable(connection);
if (ret)
goto err_connection_disable;
/* Refresh timeout */
gb_bootrom_set_timeout(bootrom, NEXT_REQ_FIRMWARE_SIZE,
NEXT_REQ_TIMEOUT_MS);
/* Tell bootrom we're ready. */
ret = gb_operation_sync(connection, GB_BOOTROM_TYPE_AP_READY, NULL, 0,
NULL, 0);
if (ret) {
dev_err(&connection->bundle->dev,
"failed to send AP READY: %d\n", ret);
goto err_cancel_timeout;
}
dev_dbg(&bundle->dev, "AP_READY sent\n");
return 0;
err_cancel_timeout:
gb_bootrom_cancel_timeout(bootrom);
err_connection_disable:
gb_connection_disable(connection);
err_connection_destroy:
gb_connection_destroy(connection);
err_free_bootrom:
kfree(bootrom);
return ret;
}
static void gb_bootrom_disconnect(struct gb_bundle *bundle)
{
struct gb_bootrom *bootrom = greybus_get_drvdata(bundle);
dev_dbg(&bundle->dev, "%s\n", __func__);
gb_connection_disable(bootrom->connection);
/* Disable timeouts */
gb_bootrom_cancel_timeout(bootrom);
/*
* Release firmware:
*
* As the connection and the delayed work are already disabled, we don't
* need to lock access to bootrom->fw here.
*/
free_firmware(bootrom);
gb_connection_destroy(bootrom->connection);
kfree(bootrom);
}
static const struct greybus_bundle_id gb_bootrom_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_BOOTROM) },
{ }
};
static struct greybus_driver gb_bootrom_driver = {
.name = "bootrom",
.probe = gb_bootrom_probe,
.disconnect = gb_bootrom_disconnect,
.id_table = gb_bootrom_id_table,
};
module_greybus_driver(gb_bootrom_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/bootrom.c |
// SPDX-License-Identifier: GPL-2.0
/*
* USB host driver for the Greybus "generic" USB module.
*
* Copyright 2014 Google Inc.
* Copyright 2014 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/usb.h>
#include <linux/usb/hcd.h>
#include <linux/greybus.h>
#include "gbphy.h"
/* Greybus USB request types */
#define GB_USB_TYPE_HCD_START 0x02
#define GB_USB_TYPE_HCD_STOP 0x03
#define GB_USB_TYPE_HUB_CONTROL 0x04
struct gb_usb_hub_control_request {
__le16 typeReq;
__le16 wValue;
__le16 wIndex;
__le16 wLength;
};
struct gb_usb_hub_control_response {
DECLARE_FLEX_ARRAY(u8, buf);
};
struct gb_usb_device {
struct gb_connection *connection;
struct gbphy_device *gbphy_dev;
};
static inline struct gb_usb_device *to_gb_usb_device(struct usb_hcd *hcd)
{
return (struct gb_usb_device *)hcd->hcd_priv;
}
static inline struct usb_hcd *gb_usb_device_to_hcd(struct gb_usb_device *dev)
{
return container_of((void *)dev, struct usb_hcd, hcd_priv);
}
static void hcd_stop(struct usb_hcd *hcd)
{
struct gb_usb_device *dev = to_gb_usb_device(hcd);
int ret;
ret = gb_operation_sync(dev->connection, GB_USB_TYPE_HCD_STOP,
NULL, 0, NULL, 0);
if (ret)
dev_err(&dev->gbphy_dev->dev, "HCD stop failed '%d'\n", ret);
}
static int hcd_start(struct usb_hcd *hcd)
{
struct usb_bus *bus = hcd_to_bus(hcd);
struct gb_usb_device *dev = to_gb_usb_device(hcd);
int ret;
ret = gb_operation_sync(dev->connection, GB_USB_TYPE_HCD_START,
NULL, 0, NULL, 0);
if (ret) {
dev_err(&dev->gbphy_dev->dev, "HCD start failed '%d'\n", ret);
return ret;
}
hcd->state = HC_STATE_RUNNING;
if (bus->root_hub)
usb_hcd_resume_root_hub(hcd);
return 0;
}
static int urb_enqueue(struct usb_hcd *hcd, struct urb *urb, gfp_t mem_flags)
{
return -ENXIO;
}
static int urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
{
return -ENXIO;
}
static int get_frame_number(struct usb_hcd *hcd)
{
return 0;
}
static int hub_status_data(struct usb_hcd *hcd, char *buf)
{
return 0;
}
static int hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, u16 wIndex,
char *buf, u16 wLength)
{
struct gb_usb_device *dev = to_gb_usb_device(hcd);
struct gb_operation *operation;
struct gb_usb_hub_control_request *request;
struct gb_usb_hub_control_response *response;
size_t response_size;
int ret;
/* FIXME: handle unspecified lengths */
response_size = sizeof(*response) + wLength;
operation = gb_operation_create(dev->connection,
GB_USB_TYPE_HUB_CONTROL,
sizeof(*request),
response_size,
GFP_KERNEL);
if (!operation)
return -ENOMEM;
request = operation->request->payload;
request->typeReq = cpu_to_le16(typeReq);
request->wValue = cpu_to_le16(wValue);
request->wIndex = cpu_to_le16(wIndex);
request->wLength = cpu_to_le16(wLength);
ret = gb_operation_request_send_sync(operation);
if (ret)
goto out;
if (wLength) {
/* Greybus core has verified response size */
response = operation->response->payload;
memcpy(buf, response->buf, wLength);
}
out:
gb_operation_put(operation);
return ret;
}
static const struct hc_driver usb_gb_hc_driver = {
.description = "greybus-hcd",
.product_desc = "Greybus USB Host Controller",
.hcd_priv_size = sizeof(struct gb_usb_device),
.flags = HCD_USB2,
.start = hcd_start,
.stop = hcd_stop,
.urb_enqueue = urb_enqueue,
.urb_dequeue = urb_dequeue,
.get_frame_number = get_frame_number,
.hub_status_data = hub_status_data,
.hub_control = hub_control,
};
static int gb_usb_probe(struct gbphy_device *gbphy_dev,
const struct gbphy_device_id *id)
{
struct gb_connection *connection;
struct device *dev = &gbphy_dev->dev;
struct gb_usb_device *gb_usb_dev;
struct usb_hcd *hcd;
int retval;
hcd = usb_create_hcd(&usb_gb_hc_driver, dev, dev_name(dev));
if (!hcd)
return -ENOMEM;
connection = gb_connection_create(gbphy_dev->bundle,
le16_to_cpu(gbphy_dev->cport_desc->id),
NULL);
if (IS_ERR(connection)) {
retval = PTR_ERR(connection);
goto exit_usb_put;
}
gb_usb_dev = to_gb_usb_device(hcd);
gb_usb_dev->connection = connection;
gb_connection_set_data(connection, gb_usb_dev);
gb_usb_dev->gbphy_dev = gbphy_dev;
gb_gbphy_set_data(gbphy_dev, gb_usb_dev);
hcd->has_tt = 1;
retval = gb_connection_enable(connection);
if (retval)
goto exit_connection_destroy;
/*
* FIXME: The USB bridged-PHY protocol driver depends on changes to
* USB core which are not yet upstream.
*
* Disable for now.
*/
if (1) {
dev_warn(dev, "USB protocol disabled\n");
retval = -EPROTONOSUPPORT;
goto exit_connection_disable;
}
retval = usb_add_hcd(hcd, 0, 0);
if (retval)
goto exit_connection_disable;
return 0;
exit_connection_disable:
gb_connection_disable(connection);
exit_connection_destroy:
gb_connection_destroy(connection);
exit_usb_put:
usb_put_hcd(hcd);
return retval;
}
static void gb_usb_remove(struct gbphy_device *gbphy_dev)
{
struct gb_usb_device *gb_usb_dev = gb_gbphy_get_data(gbphy_dev);
struct gb_connection *connection = gb_usb_dev->connection;
struct usb_hcd *hcd = gb_usb_device_to_hcd(gb_usb_dev);
usb_remove_hcd(hcd);
gb_connection_disable(connection);
gb_connection_destroy(connection);
usb_put_hcd(hcd);
}
static const struct gbphy_device_id gb_usb_id_table[] = {
{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_USB) },
{ },
};
MODULE_DEVICE_TABLE(gbphy, gb_usb_id_table);
static struct gbphy_driver usb_driver = {
.name = "usb",
.probe = gb_usb_probe,
.remove = gb_usb_remove,
.id_table = gb_usb_id_table,
};
module_gbphy_driver(usb_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/usb.c |
// SPDX-License-Identifier: GPL-2.0
/*
* SPI bridge PHY driver.
*
* Copyright 2014-2016 Google Inc.
* Copyright 2014-2016 Linaro Ltd.
*/
#include <linux/module.h>
#include <linux/greybus.h>
#include "gbphy.h"
#include "spilib.h"
static struct spilib_ops *spilib_ops;
static int gb_spi_probe(struct gbphy_device *gbphy_dev,
const struct gbphy_device_id *id)
{
struct gb_connection *connection;
int ret;
connection = gb_connection_create(gbphy_dev->bundle,
le16_to_cpu(gbphy_dev->cport_desc->id),
NULL);
if (IS_ERR(connection))
return PTR_ERR(connection);
ret = gb_connection_enable(connection);
if (ret)
goto exit_connection_destroy;
ret = gb_spilib_master_init(connection, &gbphy_dev->dev, spilib_ops);
if (ret)
goto exit_connection_disable;
gb_gbphy_set_data(gbphy_dev, connection);
gbphy_runtime_put_autosuspend(gbphy_dev);
return 0;
exit_connection_disable:
gb_connection_disable(connection);
exit_connection_destroy:
gb_connection_destroy(connection);
return ret;
}
static void gb_spi_remove(struct gbphy_device *gbphy_dev)
{
struct gb_connection *connection = gb_gbphy_get_data(gbphy_dev);
int ret;
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
gbphy_runtime_get_noresume(gbphy_dev);
gb_spilib_master_exit(connection);
gb_connection_disable(connection);
gb_connection_destroy(connection);
}
static const struct gbphy_device_id gb_spi_id_table[] = {
{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_SPI) },
{ },
};
MODULE_DEVICE_TABLE(gbphy, gb_spi_id_table);
static struct gbphy_driver spi_driver = {
.name = "spi",
.probe = gb_spi_probe,
.remove = gb_spi_remove,
.id_table = gb_spi_id_table,
};
module_gbphy_driver(spi_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/spi.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus driver for the Raw protocol
*
* Copyright 2015 Google Inc.
* Copyright 2015 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/sizes.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/idr.h>
#include <linux/uaccess.h>
#include <linux/greybus.h>
struct gb_raw {
struct gb_connection *connection;
struct list_head list;
int list_data;
struct mutex list_lock;
dev_t dev;
struct cdev cdev;
struct device *device;
};
struct raw_data {
struct list_head entry;
u32 len;
u8 data[];
};
static struct class *raw_class;
static int raw_major;
static const struct file_operations raw_fops;
static DEFINE_IDA(minors);
/* Number of minor devices this driver supports */
#define NUM_MINORS 256
/* Maximum size of any one send data buffer we support */
#define MAX_PACKET_SIZE (PAGE_SIZE * 2)
/*
* Maximum size of the data in the receive buffer we allow before we start to
* drop messages on the floor
*/
#define MAX_DATA_SIZE (MAX_PACKET_SIZE * 8)
/*
* Add the raw data message to the list of received messages.
*/
static int receive_data(struct gb_raw *raw, u32 len, u8 *data)
{
struct raw_data *raw_data;
struct device *dev = &raw->connection->bundle->dev;
int retval = 0;
if (len > MAX_PACKET_SIZE) {
dev_err(dev, "Too big of a data packet, rejected\n");
return -EINVAL;
}
mutex_lock(&raw->list_lock);
if ((raw->list_data + len) > MAX_DATA_SIZE) {
dev_err(dev, "Too much data in receive buffer, now dropping packets\n");
retval = -EINVAL;
goto exit;
}
raw_data = kmalloc(sizeof(*raw_data) + len, GFP_KERNEL);
if (!raw_data) {
retval = -ENOMEM;
goto exit;
}
raw->list_data += len;
raw_data->len = len;
memcpy(&raw_data->data[0], data, len);
list_add_tail(&raw_data->entry, &raw->list);
exit:
mutex_unlock(&raw->list_lock);
return retval;
}
static int gb_raw_request_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct device *dev = &connection->bundle->dev;
struct gb_raw *raw = greybus_get_drvdata(connection->bundle);
struct gb_raw_send_request *receive;
u32 len;
if (op->type != GB_RAW_TYPE_SEND) {
dev_err(dev, "unknown request type 0x%02x\n", op->type);
return -EINVAL;
}
/* Verify size of payload */
if (op->request->payload_size < sizeof(*receive)) {
dev_err(dev, "raw receive request too small (%zu < %zu)\n",
op->request->payload_size, sizeof(*receive));
return -EINVAL;
}
receive = op->request->payload;
len = le32_to_cpu(receive->len);
if (len != (int)(op->request->payload_size - sizeof(__le32))) {
dev_err(dev, "raw receive request wrong size %d vs %d\n", len,
(int)(op->request->payload_size - sizeof(__le32)));
return -EINVAL;
}
if (len == 0) {
dev_err(dev, "raw receive request of 0 bytes?\n");
return -EINVAL;
}
return receive_data(raw, len, receive->data);
}
static int gb_raw_send(struct gb_raw *raw, u32 len, const char __user *data)
{
struct gb_connection *connection = raw->connection;
struct gb_raw_send_request *request;
int retval;
request = kmalloc(len + sizeof(*request), GFP_KERNEL);
if (!request)
return -ENOMEM;
if (copy_from_user(&request->data[0], data, len)) {
kfree(request);
return -EFAULT;
}
request->len = cpu_to_le32(len);
retval = gb_operation_sync(connection, GB_RAW_TYPE_SEND,
request, len + sizeof(*request),
NULL, 0);
kfree(request);
return retval;
}
static int gb_raw_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct greybus_descriptor_cport *cport_desc;
struct gb_connection *connection;
struct gb_raw *raw;
int retval;
int minor;
if (bundle->num_cports != 1)
return -ENODEV;
cport_desc = &bundle->cport_desc[0];
if (cport_desc->protocol_id != GREYBUS_PROTOCOL_RAW)
return -ENODEV;
raw = kzalloc(sizeof(*raw), GFP_KERNEL);
if (!raw)
return -ENOMEM;
connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
gb_raw_request_handler);
if (IS_ERR(connection)) {
retval = PTR_ERR(connection);
goto error_free;
}
INIT_LIST_HEAD(&raw->list);
mutex_init(&raw->list_lock);
raw->connection = connection;
greybus_set_drvdata(bundle, raw);
minor = ida_simple_get(&minors, 0, 0, GFP_KERNEL);
if (minor < 0) {
retval = minor;
goto error_connection_destroy;
}
raw->dev = MKDEV(raw_major, minor);
cdev_init(&raw->cdev, &raw_fops);
retval = gb_connection_enable(connection);
if (retval)
goto error_remove_ida;
retval = cdev_add(&raw->cdev, raw->dev, 1);
if (retval)
goto error_connection_disable;
raw->device = device_create(raw_class, &connection->bundle->dev,
raw->dev, raw, "gb!raw%d", minor);
if (IS_ERR(raw->device)) {
retval = PTR_ERR(raw->device);
goto error_del_cdev;
}
return 0;
error_del_cdev:
cdev_del(&raw->cdev);
error_connection_disable:
gb_connection_disable(connection);
error_remove_ida:
ida_simple_remove(&minors, minor);
error_connection_destroy:
gb_connection_destroy(connection);
error_free:
kfree(raw);
return retval;
}
static void gb_raw_disconnect(struct gb_bundle *bundle)
{
struct gb_raw *raw = greybus_get_drvdata(bundle);
struct gb_connection *connection = raw->connection;
struct raw_data *raw_data;
struct raw_data *temp;
// FIXME - handle removing a connection when the char device node is open.
device_destroy(raw_class, raw->dev);
cdev_del(&raw->cdev);
gb_connection_disable(connection);
ida_simple_remove(&minors, MINOR(raw->dev));
gb_connection_destroy(connection);
mutex_lock(&raw->list_lock);
list_for_each_entry_safe(raw_data, temp, &raw->list, entry) {
list_del(&raw_data->entry);
kfree(raw_data);
}
mutex_unlock(&raw->list_lock);
kfree(raw);
}
/*
* Character device node interfaces.
*
* Note, we are using read/write to only allow a single read/write per message.
* This means for read(), you have to provide a big enough buffer for the full
* message to be copied into. If the buffer isn't big enough, the read() will
* fail with -ENOSPC.
*/
static int raw_open(struct inode *inode, struct file *file)
{
struct cdev *cdev = inode->i_cdev;
struct gb_raw *raw = container_of(cdev, struct gb_raw, cdev);
file->private_data = raw;
return 0;
}
static ssize_t raw_write(struct file *file, const char __user *buf,
size_t count, loff_t *ppos)
{
struct gb_raw *raw = file->private_data;
int retval;
if (!count)
return 0;
if (count > MAX_PACKET_SIZE)
return -E2BIG;
retval = gb_raw_send(raw, count, buf);
if (retval)
return retval;
return count;
}
static ssize_t raw_read(struct file *file, char __user *buf, size_t count,
loff_t *ppos)
{
struct gb_raw *raw = file->private_data;
int retval = 0;
struct raw_data *raw_data;
mutex_lock(&raw->list_lock);
if (list_empty(&raw->list))
goto exit;
raw_data = list_first_entry(&raw->list, struct raw_data, entry);
if (raw_data->len > count) {
retval = -ENOSPC;
goto exit;
}
if (copy_to_user(buf, &raw_data->data[0], raw_data->len)) {
retval = -EFAULT;
goto exit;
}
list_del(&raw_data->entry);
raw->list_data -= raw_data->len;
retval = raw_data->len;
kfree(raw_data);
exit:
mutex_unlock(&raw->list_lock);
return retval;
}
static const struct file_operations raw_fops = {
.owner = THIS_MODULE,
.write = raw_write,
.read = raw_read,
.open = raw_open,
.llseek = noop_llseek,
};
static const struct greybus_bundle_id gb_raw_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_RAW) },
{ }
};
MODULE_DEVICE_TABLE(greybus, gb_raw_id_table);
static struct greybus_driver gb_raw_driver = {
.name = "raw",
.probe = gb_raw_probe,
.disconnect = gb_raw_disconnect,
.id_table = gb_raw_id_table,
};
static int raw_init(void)
{
dev_t dev;
int retval;
raw_class = class_create("gb_raw");
if (IS_ERR(raw_class)) {
retval = PTR_ERR(raw_class);
goto error_class;
}
retval = alloc_chrdev_region(&dev, 0, NUM_MINORS, "gb_raw");
if (retval < 0)
goto error_chrdev;
raw_major = MAJOR(dev);
retval = greybus_register(&gb_raw_driver);
if (retval)
goto error_gb;
return 0;
error_gb:
unregister_chrdev_region(dev, NUM_MINORS);
error_chrdev:
class_destroy(raw_class);
error_class:
return retval;
}
module_init(raw_init);
static void __exit raw_exit(void)
{
greybus_deregister(&gb_raw_driver);
unregister_chrdev_region(MKDEV(raw_major, 0), NUM_MINORS);
class_destroy(raw_class);
ida_destroy(&minors);
}
module_exit(raw_exit);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/raw.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Power Supply driver for a Greybus module.
*
* Copyright 2014-2015 Google Inc.
* Copyright 2014-2015 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/power_supply.h>
#include <linux/slab.h>
#include <linux/greybus.h>
#define PROP_MAX 32
struct gb_power_supply_prop {
enum power_supply_property prop;
u8 gb_prop;
int val;
int previous_val;
bool is_writeable;
};
struct gb_power_supply {
u8 id;
bool registered;
struct power_supply *psy;
struct power_supply_desc desc;
char name[64];
struct gb_power_supplies *supplies;
struct delayed_work work;
char *manufacturer;
char *model_name;
char *serial_number;
u8 type;
u8 properties_count;
u8 properties_count_str;
unsigned long last_update;
u8 cache_invalid;
unsigned int update_interval;
bool changed;
struct gb_power_supply_prop *props;
enum power_supply_property *props_raw;
bool pm_acquired;
struct mutex supply_lock;
};
struct gb_power_supplies {
struct gb_connection *connection;
u8 supplies_count;
struct gb_power_supply *supply;
struct mutex supplies_lock;
};
#define to_gb_power_supply(x) power_supply_get_drvdata(x)
/*
* General power supply properties that could be absent from various reasons,
* like kernel versions or vendor specific versions
*/
#ifndef POWER_SUPPLY_PROP_VOLTAGE_BOOT
#define POWER_SUPPLY_PROP_VOLTAGE_BOOT -1
#endif
#ifndef POWER_SUPPLY_PROP_CURRENT_BOOT
#define POWER_SUPPLY_PROP_CURRENT_BOOT -1
#endif
#ifndef POWER_SUPPLY_PROP_CALIBRATE
#define POWER_SUPPLY_PROP_CALIBRATE -1
#endif
/* cache time in milliseconds, if cache_time is set to 0 cache is disable */
static unsigned int cache_time = 1000;
/*
* update interval initial and maximum value, between the two will
* back-off exponential
*/
static unsigned int update_interval_init = 1 * HZ;
static unsigned int update_interval_max = 30 * HZ;
struct gb_power_supply_changes {
enum power_supply_property prop;
u32 tolerance_change;
void (*prop_changed)(struct gb_power_supply *gbpsy,
struct gb_power_supply_prop *prop);
};
static void gb_power_supply_state_change(struct gb_power_supply *gbpsy,
struct gb_power_supply_prop *prop);
static const struct gb_power_supply_changes psy_props_changes[] = {
{ .prop = GB_POWER_SUPPLY_PROP_STATUS,
.tolerance_change = 0,
.prop_changed = gb_power_supply_state_change,
},
{ .prop = GB_POWER_SUPPLY_PROP_TEMP,
.tolerance_change = 500,
.prop_changed = NULL,
},
{ .prop = GB_POWER_SUPPLY_PROP_ONLINE,
.tolerance_change = 0,
.prop_changed = NULL,
},
};
static int get_psp_from_gb_prop(int gb_prop, enum power_supply_property *psp)
{
int prop;
switch (gb_prop) {
case GB_POWER_SUPPLY_PROP_STATUS:
prop = POWER_SUPPLY_PROP_STATUS;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_TYPE:
prop = POWER_SUPPLY_PROP_CHARGE_TYPE;
break;
case GB_POWER_SUPPLY_PROP_HEALTH:
prop = POWER_SUPPLY_PROP_HEALTH;
break;
case GB_POWER_SUPPLY_PROP_PRESENT:
prop = POWER_SUPPLY_PROP_PRESENT;
break;
case GB_POWER_SUPPLY_PROP_ONLINE:
prop = POWER_SUPPLY_PROP_ONLINE;
break;
case GB_POWER_SUPPLY_PROP_AUTHENTIC:
prop = POWER_SUPPLY_PROP_AUTHENTIC;
break;
case GB_POWER_SUPPLY_PROP_TECHNOLOGY:
prop = POWER_SUPPLY_PROP_TECHNOLOGY;
break;
case GB_POWER_SUPPLY_PROP_CYCLE_COUNT:
prop = POWER_SUPPLY_PROP_CYCLE_COUNT;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_MAX:
prop = POWER_SUPPLY_PROP_VOLTAGE_MAX;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_MIN:
prop = POWER_SUPPLY_PROP_VOLTAGE_MIN;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
prop = POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
prop = POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_NOW:
prop = POWER_SUPPLY_PROP_VOLTAGE_NOW;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_AVG:
prop = POWER_SUPPLY_PROP_VOLTAGE_AVG;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_OCV:
prop = POWER_SUPPLY_PROP_VOLTAGE_OCV;
break;
case GB_POWER_SUPPLY_PROP_VOLTAGE_BOOT:
prop = POWER_SUPPLY_PROP_VOLTAGE_BOOT;
break;
case GB_POWER_SUPPLY_PROP_CURRENT_MAX:
prop = POWER_SUPPLY_PROP_CURRENT_MAX;
break;
case GB_POWER_SUPPLY_PROP_CURRENT_NOW:
prop = POWER_SUPPLY_PROP_CURRENT_NOW;
break;
case GB_POWER_SUPPLY_PROP_CURRENT_AVG:
prop = POWER_SUPPLY_PROP_CURRENT_AVG;
break;
case GB_POWER_SUPPLY_PROP_CURRENT_BOOT:
prop = POWER_SUPPLY_PROP_CURRENT_BOOT;
break;
case GB_POWER_SUPPLY_PROP_POWER_NOW:
prop = POWER_SUPPLY_PROP_POWER_NOW;
break;
case GB_POWER_SUPPLY_PROP_POWER_AVG:
prop = POWER_SUPPLY_PROP_POWER_AVG;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
prop = POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN:
prop = POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_FULL:
prop = POWER_SUPPLY_PROP_CHARGE_FULL;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_EMPTY:
prop = POWER_SUPPLY_PROP_CHARGE_EMPTY;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_NOW:
prop = POWER_SUPPLY_PROP_CHARGE_NOW;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_AVG:
prop = POWER_SUPPLY_PROP_CHARGE_AVG;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_COUNTER:
prop = POWER_SUPPLY_PROP_CHARGE_COUNTER;
break;
case GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
prop = POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT;
break;
case GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
prop = POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX;
break;
case GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
prop = POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE;
break;
case GB_POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
prop = POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
prop = POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX:
prop = POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT_MAX;
break;
case GB_POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
prop = POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
prop = POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN:
prop = POWER_SUPPLY_PROP_ENERGY_EMPTY_DESIGN;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_FULL:
prop = POWER_SUPPLY_PROP_ENERGY_FULL;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_EMPTY:
prop = POWER_SUPPLY_PROP_ENERGY_EMPTY;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_NOW:
prop = POWER_SUPPLY_PROP_ENERGY_NOW;
break;
case GB_POWER_SUPPLY_PROP_ENERGY_AVG:
prop = POWER_SUPPLY_PROP_ENERGY_AVG;
break;
case GB_POWER_SUPPLY_PROP_CAPACITY:
prop = POWER_SUPPLY_PROP_CAPACITY;
break;
case GB_POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN:
prop = POWER_SUPPLY_PROP_CAPACITY_ALERT_MIN;
break;
case GB_POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX:
prop = POWER_SUPPLY_PROP_CAPACITY_ALERT_MAX;
break;
case GB_POWER_SUPPLY_PROP_CAPACITY_LEVEL:
prop = POWER_SUPPLY_PROP_CAPACITY_LEVEL;
break;
case GB_POWER_SUPPLY_PROP_TEMP:
prop = POWER_SUPPLY_PROP_TEMP;
break;
case GB_POWER_SUPPLY_PROP_TEMP_MAX:
prop = POWER_SUPPLY_PROP_TEMP_MAX;
break;
case GB_POWER_SUPPLY_PROP_TEMP_MIN:
prop = POWER_SUPPLY_PROP_TEMP_MIN;
break;
case GB_POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
prop = POWER_SUPPLY_PROP_TEMP_ALERT_MIN;
break;
case GB_POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
prop = POWER_SUPPLY_PROP_TEMP_ALERT_MAX;
break;
case GB_POWER_SUPPLY_PROP_TEMP_AMBIENT:
prop = POWER_SUPPLY_PROP_TEMP_AMBIENT;
break;
case GB_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN:
prop = POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MIN;
break;
case GB_POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX:
prop = POWER_SUPPLY_PROP_TEMP_AMBIENT_ALERT_MAX;
break;
case GB_POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
prop = POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW;
break;
case GB_POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
prop = POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG;
break;
case GB_POWER_SUPPLY_PROP_TIME_TO_FULL_NOW:
prop = POWER_SUPPLY_PROP_TIME_TO_FULL_NOW;
break;
case GB_POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
prop = POWER_SUPPLY_PROP_TIME_TO_FULL_AVG;
break;
case GB_POWER_SUPPLY_PROP_TYPE:
prop = POWER_SUPPLY_PROP_TYPE;
break;
case GB_POWER_SUPPLY_PROP_SCOPE:
prop = POWER_SUPPLY_PROP_SCOPE;
break;
case GB_POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT:
prop = POWER_SUPPLY_PROP_CHARGE_TERM_CURRENT;
break;
case GB_POWER_SUPPLY_PROP_CALIBRATE:
prop = POWER_SUPPLY_PROP_CALIBRATE;
break;
default:
prop = -1;
break;
}
if (prop < 0)
return prop;
*psp = (enum power_supply_property)prop;
return 0;
}
static struct gb_connection *get_conn_from_psy(struct gb_power_supply *gbpsy)
{
return gbpsy->supplies->connection;
}
static struct gb_power_supply_prop *get_psy_prop(struct gb_power_supply *gbpsy,
enum power_supply_property psp)
{
int i;
for (i = 0; i < gbpsy->properties_count; i++)
if (gbpsy->props[i].prop == psp)
return &gbpsy->props[i];
return NULL;
}
static int is_psy_prop_writeable(struct gb_power_supply *gbpsy,
enum power_supply_property psp)
{
struct gb_power_supply_prop *prop;
prop = get_psy_prop(gbpsy, psp);
if (!prop)
return -ENOENT;
return prop->is_writeable ? 1 : 0;
}
static int is_prop_valint(enum power_supply_property psp)
{
return ((psp < POWER_SUPPLY_PROP_MODEL_NAME) ? 1 : 0);
}
static void next_interval(struct gb_power_supply *gbpsy)
{
if (gbpsy->update_interval == update_interval_max)
return;
/* do some exponential back-off in the update interval */
gbpsy->update_interval *= 2;
if (gbpsy->update_interval > update_interval_max)
gbpsy->update_interval = update_interval_max;
}
static void __gb_power_supply_changed(struct gb_power_supply *gbpsy)
{
power_supply_changed(gbpsy->psy);
}
static void gb_power_supply_state_change(struct gb_power_supply *gbpsy,
struct gb_power_supply_prop *prop)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
int ret;
/*
* Check gbpsy->pm_acquired to make sure only one pair of 'get_sync'
* and 'put_autosuspend' runtime pm call for state property change.
*/
mutex_lock(&gbpsy->supply_lock);
if ((prop->val == GB_POWER_SUPPLY_STATUS_CHARGING) &&
!gbpsy->pm_acquired) {
ret = gb_pm_runtime_get_sync(connection->bundle);
if (ret)
dev_err(&connection->bundle->dev,
"Fail to set wake lock for charging state\n");
else
gbpsy->pm_acquired = true;
} else {
if (gbpsy->pm_acquired) {
ret = gb_pm_runtime_put_autosuspend(connection->bundle);
if (ret)
dev_err(&connection->bundle->dev,
"Fail to set wake unlock for none charging\n");
else
gbpsy->pm_acquired = false;
}
}
mutex_unlock(&gbpsy->supply_lock);
}
static void check_changed(struct gb_power_supply *gbpsy,
struct gb_power_supply_prop *prop)
{
const struct gb_power_supply_changes *psyc;
int val = prop->val;
int prev_val = prop->previous_val;
bool changed = false;
int i;
for (i = 0; i < ARRAY_SIZE(psy_props_changes); i++) {
psyc = &psy_props_changes[i];
if (prop->prop == psyc->prop) {
if (!psyc->tolerance_change)
changed = true;
else if (val < prev_val &&
prev_val - val > psyc->tolerance_change)
changed = true;
else if (val > prev_val &&
val - prev_val > psyc->tolerance_change)
changed = true;
if (changed && psyc->prop_changed)
psyc->prop_changed(gbpsy, prop);
if (changed)
gbpsy->changed = true;
break;
}
}
}
static int total_props(struct gb_power_supply *gbpsy)
{
/* this return the intval plus the strval properties */
return (gbpsy->properties_count + gbpsy->properties_count_str);
}
static void prop_append(struct gb_power_supply *gbpsy,
enum power_supply_property prop)
{
enum power_supply_property *new_props_raw;
gbpsy->properties_count_str++;
new_props_raw = krealloc(gbpsy->props_raw, total_props(gbpsy) *
sizeof(enum power_supply_property),
GFP_KERNEL);
if (!new_props_raw)
return;
gbpsy->props_raw = new_props_raw;
gbpsy->props_raw[total_props(gbpsy) - 1] = prop;
}
static int __gb_power_supply_set_name(char *init_name, char *name, size_t len)
{
unsigned int i = 0;
int ret = 0;
struct power_supply *psy;
if (!strlen(init_name))
init_name = "gb_power_supply";
strscpy(name, init_name, len);
while ((ret < len) && (psy = power_supply_get_by_name(name))) {
power_supply_put(psy);
ret = snprintf(name, len, "%s_%u", init_name, ++i);
}
if (ret >= len)
return -ENOMEM;
return i;
}
static void _gb_power_supply_append_props(struct gb_power_supply *gbpsy)
{
if (strlen(gbpsy->manufacturer))
prop_append(gbpsy, POWER_SUPPLY_PROP_MANUFACTURER);
if (strlen(gbpsy->model_name))
prop_append(gbpsy, POWER_SUPPLY_PROP_MODEL_NAME);
if (strlen(gbpsy->serial_number))
prop_append(gbpsy, POWER_SUPPLY_PROP_SERIAL_NUMBER);
}
static int gb_power_supply_description_get(struct gb_power_supply *gbpsy)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
struct gb_power_supply_get_description_request req;
struct gb_power_supply_get_description_response resp;
int ret;
req.psy_id = gbpsy->id;
ret = gb_operation_sync(connection,
GB_POWER_SUPPLY_TYPE_GET_DESCRIPTION,
&req, sizeof(req), &resp, sizeof(resp));
if (ret < 0)
return ret;
gbpsy->manufacturer = kstrndup(resp.manufacturer, PROP_MAX, GFP_KERNEL);
if (!gbpsy->manufacturer)
return -ENOMEM;
gbpsy->model_name = kstrndup(resp.model, PROP_MAX, GFP_KERNEL);
if (!gbpsy->model_name)
return -ENOMEM;
gbpsy->serial_number = kstrndup(resp.serial_number, PROP_MAX,
GFP_KERNEL);
if (!gbpsy->serial_number)
return -ENOMEM;
gbpsy->type = le16_to_cpu(resp.type);
gbpsy->properties_count = resp.properties_count;
return 0;
}
static int gb_power_supply_prop_descriptors_get(struct gb_power_supply *gbpsy)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
struct gb_power_supply_get_property_descriptors_request *req;
struct gb_power_supply_get_property_descriptors_response *resp;
struct gb_operation *op;
u8 props_count = gbpsy->properties_count;
enum power_supply_property psp;
int ret;
int i, r = 0;
if (props_count == 0)
return 0;
op = gb_operation_create(connection,
GB_POWER_SUPPLY_TYPE_GET_PROP_DESCRIPTORS,
sizeof(*req),
struct_size(resp, props, props_count),
GFP_KERNEL);
if (!op)
return -ENOMEM;
req = op->request->payload;
req->psy_id = gbpsy->id;
ret = gb_operation_request_send_sync(op);
if (ret < 0)
goto out_put_operation;
resp = op->response->payload;
/* validate received properties */
for (i = 0; i < props_count; i++) {
ret = get_psp_from_gb_prop(resp->props[i].property, &psp);
if (ret < 0) {
dev_warn(&connection->bundle->dev,
"greybus property %u it is not supported by this kernel, dropped\n",
resp->props[i].property);
gbpsy->properties_count--;
}
}
gbpsy->props = kcalloc(gbpsy->properties_count, sizeof(*gbpsy->props),
GFP_KERNEL);
if (!gbpsy->props) {
ret = -ENOMEM;
goto out_put_operation;
}
gbpsy->props_raw = kcalloc(gbpsy->properties_count,
sizeof(*gbpsy->props_raw), GFP_KERNEL);
if (!gbpsy->props_raw) {
ret = -ENOMEM;
goto out_put_operation;
}
/* Store available properties, skip the ones we do not support */
for (i = 0; i < props_count; i++) {
ret = get_psp_from_gb_prop(resp->props[i].property, &psp);
if (ret < 0) {
r++;
continue;
}
gbpsy->props[i - r].prop = psp;
gbpsy->props[i - r].gb_prop = resp->props[i].property;
gbpsy->props_raw[i - r] = psp;
if (resp->props[i].is_writeable)
gbpsy->props[i - r].is_writeable = true;
}
/*
* now append the properties that we already got information in the
* get_description operation. (char * ones)
*/
_gb_power_supply_append_props(gbpsy);
ret = 0;
out_put_operation:
gb_operation_put(op);
return ret;
}
static int __gb_power_supply_property_update(struct gb_power_supply *gbpsy,
enum power_supply_property psp)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
struct gb_power_supply_prop *prop;
struct gb_power_supply_get_property_request req;
struct gb_power_supply_get_property_response resp;
int val;
int ret;
prop = get_psy_prop(gbpsy, psp);
if (!prop)
return -EINVAL;
req.psy_id = gbpsy->id;
req.property = prop->gb_prop;
ret = gb_operation_sync(connection, GB_POWER_SUPPLY_TYPE_GET_PROPERTY,
&req, sizeof(req), &resp, sizeof(resp));
if (ret < 0)
return ret;
val = le32_to_cpu(resp.prop_val);
if (val == prop->val)
return 0;
prop->previous_val = prop->val;
prop->val = val;
check_changed(gbpsy, prop);
return 0;
}
static int __gb_power_supply_property_get(struct gb_power_supply *gbpsy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct gb_power_supply_prop *prop;
prop = get_psy_prop(gbpsy, psp);
if (!prop)
return -EINVAL;
val->intval = prop->val;
return 0;
}
static int __gb_power_supply_property_strval_get(struct gb_power_supply *gbpsy,
enum power_supply_property psp,
union power_supply_propval *val)
{
switch (psp) {
case POWER_SUPPLY_PROP_MODEL_NAME:
val->strval = gbpsy->model_name;
break;
case POWER_SUPPLY_PROP_MANUFACTURER:
val->strval = gbpsy->manufacturer;
break;
case POWER_SUPPLY_PROP_SERIAL_NUMBER:
val->strval = gbpsy->serial_number;
break;
default:
break;
}
return 0;
}
static int _gb_power_supply_property_get(struct gb_power_supply *gbpsy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
int ret;
/*
* Properties of type const char *, were already fetched on
* get_description operation and should be cached in gb
*/
if (is_prop_valint(psp))
ret = __gb_power_supply_property_get(gbpsy, psp, val);
else
ret = __gb_power_supply_property_strval_get(gbpsy, psp, val);
if (ret < 0)
dev_err(&connection->bundle->dev, "get property %u\n", psp);
return 0;
}
static int is_cache_valid(struct gb_power_supply *gbpsy)
{
/* check if cache is good enough or it has expired */
if (gbpsy->cache_invalid) {
gbpsy->cache_invalid = 0;
return 0;
}
if (gbpsy->last_update &&
time_is_after_jiffies(gbpsy->last_update +
msecs_to_jiffies(cache_time)))
return 1;
return 0;
}
static int gb_power_supply_status_get(struct gb_power_supply *gbpsy)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
int ret = 0;
int i;
if (is_cache_valid(gbpsy))
return 0;
ret = gb_pm_runtime_get_sync(connection->bundle);
if (ret)
return ret;
for (i = 0; i < gbpsy->properties_count; i++) {
ret = __gb_power_supply_property_update(gbpsy,
gbpsy->props[i].prop);
if (ret < 0)
break;
}
if (ret == 0)
gbpsy->last_update = jiffies;
gb_pm_runtime_put_autosuspend(connection->bundle);
return ret;
}
static void gb_power_supply_status_update(struct gb_power_supply *gbpsy)
{
/* check if there a change that need to be reported */
gb_power_supply_status_get(gbpsy);
if (!gbpsy->changed)
return;
gbpsy->update_interval = update_interval_init;
__gb_power_supply_changed(gbpsy);
gbpsy->changed = false;
}
static void gb_power_supply_work(struct work_struct *work)
{
struct gb_power_supply *gbpsy = container_of(work,
struct gb_power_supply,
work.work);
/*
* if the poll interval is not set, disable polling, this is helpful
* specially at unregister time.
*/
if (!gbpsy->update_interval)
return;
gb_power_supply_status_update(gbpsy);
next_interval(gbpsy);
schedule_delayed_work(&gbpsy->work, gbpsy->update_interval);
}
static int get_property(struct power_supply *b,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct gb_power_supply *gbpsy = to_gb_power_supply(b);
gb_power_supply_status_get(gbpsy);
return _gb_power_supply_property_get(gbpsy, psp, val);
}
static int gb_power_supply_property_set(struct gb_power_supply *gbpsy,
enum power_supply_property psp,
int val)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
struct gb_power_supply_prop *prop;
struct gb_power_supply_set_property_request req;
int ret;
ret = gb_pm_runtime_get_sync(connection->bundle);
if (ret)
return ret;
prop = get_psy_prop(gbpsy, psp);
if (!prop) {
ret = -EINVAL;
goto out;
}
req.psy_id = gbpsy->id;
req.property = prop->gb_prop;
req.prop_val = cpu_to_le32((s32)val);
ret = gb_operation_sync(connection, GB_POWER_SUPPLY_TYPE_SET_PROPERTY,
&req, sizeof(req), NULL, 0);
if (ret < 0)
goto out;
/* cache immediately the new value */
prop->val = val;
out:
gb_pm_runtime_put_autosuspend(connection->bundle);
return ret;
}
static int set_property(struct power_supply *b,
enum power_supply_property psp,
const union power_supply_propval *val)
{
struct gb_power_supply *gbpsy = to_gb_power_supply(b);
return gb_power_supply_property_set(gbpsy, psp, val->intval);
}
static int property_is_writeable(struct power_supply *b,
enum power_supply_property psp)
{
struct gb_power_supply *gbpsy = to_gb_power_supply(b);
return is_psy_prop_writeable(gbpsy, psp);
}
static int gb_power_supply_register(struct gb_power_supply *gbpsy)
{
struct gb_connection *connection = get_conn_from_psy(gbpsy);
struct power_supply_config cfg = {};
cfg.drv_data = gbpsy;
gbpsy->desc.name = gbpsy->name;
gbpsy->desc.type = gbpsy->type;
gbpsy->desc.properties = gbpsy->props_raw;
gbpsy->desc.num_properties = total_props(gbpsy);
gbpsy->desc.get_property = get_property;
gbpsy->desc.set_property = set_property;
gbpsy->desc.property_is_writeable = property_is_writeable;
gbpsy->psy = power_supply_register(&connection->bundle->dev,
&gbpsy->desc, &cfg);
return PTR_ERR_OR_ZERO(gbpsy->psy);
}
static void _gb_power_supply_free(struct gb_power_supply *gbpsy)
{
kfree(gbpsy->serial_number);
kfree(gbpsy->model_name);
kfree(gbpsy->manufacturer);
kfree(gbpsy->props_raw);
kfree(gbpsy->props);
}
static void _gb_power_supply_release(struct gb_power_supply *gbpsy)
{
gbpsy->update_interval = 0;
cancel_delayed_work_sync(&gbpsy->work);
if (gbpsy->registered)
power_supply_unregister(gbpsy->psy);
_gb_power_supply_free(gbpsy);
}
static void _gb_power_supplies_release(struct gb_power_supplies *supplies)
{
int i;
if (!supplies->supply)
return;
mutex_lock(&supplies->supplies_lock);
for (i = 0; i < supplies->supplies_count; i++)
_gb_power_supply_release(&supplies->supply[i]);
kfree(supplies->supply);
mutex_unlock(&supplies->supplies_lock);
kfree(supplies);
}
static int gb_power_supplies_get_count(struct gb_power_supplies *supplies)
{
struct gb_power_supply_get_supplies_response resp;
int ret;
ret = gb_operation_sync(supplies->connection,
GB_POWER_SUPPLY_TYPE_GET_SUPPLIES,
NULL, 0, &resp, sizeof(resp));
if (ret < 0)
return ret;
if (!resp.supplies_count)
return -EINVAL;
supplies->supplies_count = resp.supplies_count;
return ret;
}
static int gb_power_supply_config(struct gb_power_supplies *supplies, int id)
{
struct gb_power_supply *gbpsy = &supplies->supply[id];
int ret;
gbpsy->supplies = supplies;
gbpsy->id = id;
ret = gb_power_supply_description_get(gbpsy);
if (ret < 0)
return ret;
return gb_power_supply_prop_descriptors_get(gbpsy);
}
static int gb_power_supply_enable(struct gb_power_supply *gbpsy)
{
int ret;
/* guarantee that we have an unique name, before register */
ret = __gb_power_supply_set_name(gbpsy->model_name, gbpsy->name,
sizeof(gbpsy->name));
if (ret < 0)
return ret;
mutex_init(&gbpsy->supply_lock);
ret = gb_power_supply_register(gbpsy);
if (ret < 0)
return ret;
gbpsy->update_interval = update_interval_init;
INIT_DELAYED_WORK(&gbpsy->work, gb_power_supply_work);
schedule_delayed_work(&gbpsy->work, 0);
/* everything went fine, mark it for release code to know */
gbpsy->registered = true;
return 0;
}
static int gb_power_supplies_setup(struct gb_power_supplies *supplies)
{
struct gb_connection *connection = supplies->connection;
int ret;
int i;
mutex_lock(&supplies->supplies_lock);
ret = gb_power_supplies_get_count(supplies);
if (ret < 0)
goto out;
supplies->supply = kcalloc(supplies->supplies_count,
sizeof(struct gb_power_supply),
GFP_KERNEL);
if (!supplies->supply) {
ret = -ENOMEM;
goto out;
}
for (i = 0; i < supplies->supplies_count; i++) {
ret = gb_power_supply_config(supplies, i);
if (ret < 0) {
dev_err(&connection->bundle->dev,
"Fail to configure supplies devices\n");
goto out;
}
}
out:
mutex_unlock(&supplies->supplies_lock);
return ret;
}
static int gb_power_supplies_register(struct gb_power_supplies *supplies)
{
struct gb_connection *connection = supplies->connection;
int ret = 0;
int i;
mutex_lock(&supplies->supplies_lock);
for (i = 0; i < supplies->supplies_count; i++) {
ret = gb_power_supply_enable(&supplies->supply[i]);
if (ret < 0) {
dev_err(&connection->bundle->dev,
"Fail to enable supplies devices\n");
break;
}
}
mutex_unlock(&supplies->supplies_lock);
return ret;
}
static int gb_supplies_request_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_power_supplies *supplies = gb_connection_get_data(connection);
struct gb_power_supply *gbpsy;
struct gb_message *request;
struct gb_power_supply_event_request *payload;
u8 psy_id;
u8 event;
int ret = 0;
if (op->type != GB_POWER_SUPPLY_TYPE_EVENT) {
dev_err(&connection->bundle->dev,
"Unsupported unsolicited event: %u\n", op->type);
return -EINVAL;
}
request = op->request;
if (request->payload_size < sizeof(*payload)) {
dev_err(&connection->bundle->dev,
"Wrong event size received (%zu < %zu)\n",
request->payload_size, sizeof(*payload));
return -EINVAL;
}
payload = request->payload;
psy_id = payload->psy_id;
mutex_lock(&supplies->supplies_lock);
if (psy_id >= supplies->supplies_count ||
!supplies->supply[psy_id].registered) {
dev_err(&connection->bundle->dev,
"Event received for unconfigured power_supply id: %d\n",
psy_id);
ret = -EINVAL;
goto out_unlock;
}
event = payload->event;
/*
* we will only handle events after setup is done and before release is
* running. For that just check update_interval.
*/
gbpsy = &supplies->supply[psy_id];
if (!gbpsy->update_interval) {
ret = -ESHUTDOWN;
goto out_unlock;
}
if (event & GB_POWER_SUPPLY_UPDATE) {
/*
* we need to make sure we invalidate cache, if not no new
* values for the properties will be fetch and the all propose
* of this event is missed
*/
gbpsy->cache_invalid = 1;
gb_power_supply_status_update(gbpsy);
}
out_unlock:
mutex_unlock(&supplies->supplies_lock);
return ret;
}
static int gb_power_supply_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct greybus_descriptor_cport *cport_desc;
struct gb_connection *connection;
struct gb_power_supplies *supplies;
int ret;
if (bundle->num_cports != 1)
return -ENODEV;
cport_desc = &bundle->cport_desc[0];
if (cport_desc->protocol_id != GREYBUS_PROTOCOL_POWER_SUPPLY)
return -ENODEV;
supplies = kzalloc(sizeof(*supplies), GFP_KERNEL);
if (!supplies)
return -ENOMEM;
connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
gb_supplies_request_handler);
if (IS_ERR(connection)) {
ret = PTR_ERR(connection);
goto out;
}
supplies->connection = connection;
gb_connection_set_data(connection, supplies);
mutex_init(&supplies->supplies_lock);
greybus_set_drvdata(bundle, supplies);
/* We aren't ready to receive an incoming request yet */
ret = gb_connection_enable_tx(connection);
if (ret)
goto error_connection_destroy;
ret = gb_power_supplies_setup(supplies);
if (ret < 0)
goto error_connection_disable;
/* We are ready to receive an incoming request now, enable RX as well */
ret = gb_connection_enable(connection);
if (ret)
goto error_connection_disable;
ret = gb_power_supplies_register(supplies);
if (ret < 0)
goto error_connection_disable;
gb_pm_runtime_put_autosuspend(bundle);
return 0;
error_connection_disable:
gb_connection_disable(connection);
error_connection_destroy:
gb_connection_destroy(connection);
out:
_gb_power_supplies_release(supplies);
return ret;
}
static void gb_power_supply_disconnect(struct gb_bundle *bundle)
{
struct gb_power_supplies *supplies = greybus_get_drvdata(bundle);
gb_connection_disable(supplies->connection);
gb_connection_destroy(supplies->connection);
_gb_power_supplies_release(supplies);
}
static const struct greybus_bundle_id gb_power_supply_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_POWER_SUPPLY) },
{ }
};
MODULE_DEVICE_TABLE(greybus, gb_power_supply_id_table);
static struct greybus_driver gb_power_supply_driver = {
.name = "power_supply",
.probe = gb_power_supply_probe,
.disconnect = gb_power_supply_disconnect,
.id_table = gb_power_supply_id_table,
};
module_greybus_driver(gb_power_supply_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/power_supply.c |
// SPDX-License-Identifier: GPL-2.0
/*
* GPIO Greybus driver.
*
* Copyright 2014 Google Inc.
* Copyright 2014 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/irq.h>
#include <linux/irqdomain.h>
#include <linux/gpio/driver.h>
#include <linux/mutex.h>
#include <linux/greybus.h>
#include "gbphy.h"
struct gb_gpio_line {
/* The following has to be an array of line_max entries */
/* --> make them just a flags field */
u8 active: 1,
direction: 1, /* 0 = output, 1 = input */
value: 1; /* 0 = low, 1 = high */
u16 debounce_usec;
u8 irq_type;
bool irq_type_pending;
bool masked;
bool masked_pending;
};
struct gb_gpio_controller {
struct gbphy_device *gbphy_dev;
struct gb_connection *connection;
u8 line_max; /* max line number */
struct gb_gpio_line *lines;
struct gpio_chip chip;
struct irq_chip irqc;
struct mutex irq_lock;
};
static inline struct gb_gpio_controller *gpio_chip_to_gb_gpio_controller(struct gpio_chip *chip)
{
return container_of(chip, struct gb_gpio_controller, chip);
}
static struct gpio_chip *irq_data_to_gpio_chip(struct irq_data *d)
{
return d->domain->host_data;
}
static int gb_gpio_line_count_operation(struct gb_gpio_controller *ggc)
{
struct gb_gpio_line_count_response response;
int ret;
ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_LINE_COUNT,
NULL, 0, &response, sizeof(response));
if (!ret)
ggc->line_max = response.count;
return ret;
}
static int gb_gpio_activate_operation(struct gb_gpio_controller *ggc, u8 which)
{
struct gb_gpio_activate_request request;
struct gbphy_device *gbphy_dev = ggc->gbphy_dev;
int ret;
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
return ret;
request.which = which;
ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_ACTIVATE,
&request, sizeof(request), NULL, 0);
if (ret) {
gbphy_runtime_put_autosuspend(gbphy_dev);
return ret;
}
ggc->lines[which].active = true;
return 0;
}
static void gb_gpio_deactivate_operation(struct gb_gpio_controller *ggc,
u8 which)
{
struct gbphy_device *gbphy_dev = ggc->gbphy_dev;
struct device *dev = &gbphy_dev->dev;
struct gb_gpio_deactivate_request request;
int ret;
request.which = which;
ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_DEACTIVATE,
&request, sizeof(request), NULL, 0);
if (ret) {
dev_err(dev, "failed to deactivate gpio %u\n", which);
goto out_pm_put;
}
ggc->lines[which].active = false;
out_pm_put:
gbphy_runtime_put_autosuspend(gbphy_dev);
}
static int gb_gpio_get_direction_operation(struct gb_gpio_controller *ggc,
u8 which)
{
struct device *dev = &ggc->gbphy_dev->dev;
struct gb_gpio_get_direction_request request;
struct gb_gpio_get_direction_response response;
int ret;
u8 direction;
request.which = which;
ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_GET_DIRECTION,
&request, sizeof(request),
&response, sizeof(response));
if (ret)
return ret;
direction = response.direction;
if (direction && direction != 1) {
dev_warn(dev, "gpio %u direction was %u (should be 0 or 1)\n",
which, direction);
}
ggc->lines[which].direction = direction ? 1 : 0;
return 0;
}
static int gb_gpio_direction_in_operation(struct gb_gpio_controller *ggc,
u8 which)
{
struct gb_gpio_direction_in_request request;
int ret;
request.which = which;
ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_DIRECTION_IN,
&request, sizeof(request), NULL, 0);
if (!ret)
ggc->lines[which].direction = 1;
return ret;
}
static int gb_gpio_direction_out_operation(struct gb_gpio_controller *ggc,
u8 which, bool value_high)
{
struct gb_gpio_direction_out_request request;
int ret;
request.which = which;
request.value = value_high ? 1 : 0;
ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_DIRECTION_OUT,
&request, sizeof(request), NULL, 0);
if (!ret)
ggc->lines[which].direction = 0;
return ret;
}
static int gb_gpio_get_value_operation(struct gb_gpio_controller *ggc,
u8 which)
{
struct device *dev = &ggc->gbphy_dev->dev;
struct gb_gpio_get_value_request request;
struct gb_gpio_get_value_response response;
int ret;
u8 value;
request.which = which;
ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_GET_VALUE,
&request, sizeof(request),
&response, sizeof(response));
if (ret) {
dev_err(dev, "failed to get value of gpio %u\n", which);
return ret;
}
value = response.value;
if (value && value != 1) {
dev_warn(dev, "gpio %u value was %u (should be 0 or 1)\n",
which, value);
}
ggc->lines[which].value = value ? 1 : 0;
return 0;
}
static void gb_gpio_set_value_operation(struct gb_gpio_controller *ggc,
u8 which, bool value_high)
{
struct device *dev = &ggc->gbphy_dev->dev;
struct gb_gpio_set_value_request request;
int ret;
if (ggc->lines[which].direction == 1) {
dev_warn(dev, "refusing to set value of input gpio %u\n",
which);
return;
}
request.which = which;
request.value = value_high ? 1 : 0;
ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_SET_VALUE,
&request, sizeof(request), NULL, 0);
if (ret) {
dev_err(dev, "failed to set value of gpio %u\n", which);
return;
}
ggc->lines[which].value = request.value;
}
static int gb_gpio_set_debounce_operation(struct gb_gpio_controller *ggc,
u8 which, u16 debounce_usec)
{
struct gb_gpio_set_debounce_request request;
int ret;
request.which = which;
request.usec = cpu_to_le16(debounce_usec);
ret = gb_operation_sync(ggc->connection, GB_GPIO_TYPE_SET_DEBOUNCE,
&request, sizeof(request), NULL, 0);
if (!ret)
ggc->lines[which].debounce_usec = debounce_usec;
return ret;
}
static void _gb_gpio_irq_mask(struct gb_gpio_controller *ggc, u8 hwirq)
{
struct device *dev = &ggc->gbphy_dev->dev;
struct gb_gpio_irq_mask_request request;
int ret;
request.which = hwirq;
ret = gb_operation_sync(ggc->connection,
GB_GPIO_TYPE_IRQ_MASK,
&request, sizeof(request), NULL, 0);
if (ret)
dev_err(dev, "failed to mask irq: %d\n", ret);
}
static void _gb_gpio_irq_unmask(struct gb_gpio_controller *ggc, u8 hwirq)
{
struct device *dev = &ggc->gbphy_dev->dev;
struct gb_gpio_irq_unmask_request request;
int ret;
request.which = hwirq;
ret = gb_operation_sync(ggc->connection,
GB_GPIO_TYPE_IRQ_UNMASK,
&request, sizeof(request), NULL, 0);
if (ret)
dev_err(dev, "failed to unmask irq: %d\n", ret);
}
static void _gb_gpio_irq_set_type(struct gb_gpio_controller *ggc,
u8 hwirq, u8 type)
{
struct device *dev = &ggc->gbphy_dev->dev;
struct gb_gpio_irq_type_request request;
int ret;
request.which = hwirq;
request.type = type;
ret = gb_operation_sync(ggc->connection,
GB_GPIO_TYPE_IRQ_TYPE,
&request, sizeof(request), NULL, 0);
if (ret)
dev_err(dev, "failed to set irq type: %d\n", ret);
}
static void gb_gpio_irq_mask(struct irq_data *d)
{
struct gpio_chip *chip = irq_data_to_gpio_chip(d);
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
struct gb_gpio_line *line = &ggc->lines[d->hwirq];
line->masked = true;
line->masked_pending = true;
}
static void gb_gpio_irq_unmask(struct irq_data *d)
{
struct gpio_chip *chip = irq_data_to_gpio_chip(d);
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
struct gb_gpio_line *line = &ggc->lines[d->hwirq];
line->masked = false;
line->masked_pending = true;
}
static int gb_gpio_irq_set_type(struct irq_data *d, unsigned int type)
{
struct gpio_chip *chip = irq_data_to_gpio_chip(d);
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
struct gb_gpio_line *line = &ggc->lines[d->hwirq];
struct device *dev = &ggc->gbphy_dev->dev;
u8 irq_type;
switch (type) {
case IRQ_TYPE_NONE:
irq_type = GB_GPIO_IRQ_TYPE_NONE;
break;
case IRQ_TYPE_EDGE_RISING:
irq_type = GB_GPIO_IRQ_TYPE_EDGE_RISING;
break;
case IRQ_TYPE_EDGE_FALLING:
irq_type = GB_GPIO_IRQ_TYPE_EDGE_FALLING;
break;
case IRQ_TYPE_EDGE_BOTH:
irq_type = GB_GPIO_IRQ_TYPE_EDGE_BOTH;
break;
case IRQ_TYPE_LEVEL_LOW:
irq_type = GB_GPIO_IRQ_TYPE_LEVEL_LOW;
break;
case IRQ_TYPE_LEVEL_HIGH:
irq_type = GB_GPIO_IRQ_TYPE_LEVEL_HIGH;
break;
default:
dev_err(dev, "unsupported irq type: %u\n", type);
return -EINVAL;
}
line->irq_type = irq_type;
line->irq_type_pending = true;
return 0;
}
static void gb_gpio_irq_bus_lock(struct irq_data *d)
{
struct gpio_chip *chip = irq_data_to_gpio_chip(d);
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
mutex_lock(&ggc->irq_lock);
}
static void gb_gpio_irq_bus_sync_unlock(struct irq_data *d)
{
struct gpio_chip *chip = irq_data_to_gpio_chip(d);
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
struct gb_gpio_line *line = &ggc->lines[d->hwirq];
if (line->irq_type_pending) {
_gb_gpio_irq_set_type(ggc, d->hwirq, line->irq_type);
line->irq_type_pending = false;
}
if (line->masked_pending) {
if (line->masked)
_gb_gpio_irq_mask(ggc, d->hwirq);
else
_gb_gpio_irq_unmask(ggc, d->hwirq);
line->masked_pending = false;
}
mutex_unlock(&ggc->irq_lock);
}
static int gb_gpio_request_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_gpio_controller *ggc = gb_connection_get_data(connection);
struct device *dev = &ggc->gbphy_dev->dev;
struct gb_message *request;
struct gb_gpio_irq_event_request *event;
u8 type = op->type;
int irq, ret;
if (type != GB_GPIO_TYPE_IRQ_EVENT) {
dev_err(dev, "unsupported unsolicited request: %u\n", type);
return -EINVAL;
}
request = op->request;
if (request->payload_size < sizeof(*event)) {
dev_err(dev, "short event received (%zu < %zu)\n",
request->payload_size, sizeof(*event));
return -EINVAL;
}
event = request->payload;
if (event->which > ggc->line_max) {
dev_err(dev, "invalid hw irq: %d\n", event->which);
return -EINVAL;
}
irq = irq_find_mapping(ggc->chip.irq.domain, event->which);
if (!irq) {
dev_err(dev, "failed to find IRQ\n");
return -EINVAL;
}
ret = generic_handle_irq_safe(irq);
if (ret)
dev_err(dev, "failed to invoke irq handler\n");
return ret;
}
static int gb_gpio_request(struct gpio_chip *chip, unsigned int offset)
{
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
return gb_gpio_activate_operation(ggc, (u8)offset);
}
static void gb_gpio_free(struct gpio_chip *chip, unsigned int offset)
{
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
gb_gpio_deactivate_operation(ggc, (u8)offset);
}
static int gb_gpio_get_direction(struct gpio_chip *chip, unsigned int offset)
{
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
u8 which;
int ret;
which = (u8)offset;
ret = gb_gpio_get_direction_operation(ggc, which);
if (ret)
return ret;
return ggc->lines[which].direction ? 1 : 0;
}
static int gb_gpio_direction_input(struct gpio_chip *chip, unsigned int offset)
{
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
return gb_gpio_direction_in_operation(ggc, (u8)offset);
}
static int gb_gpio_direction_output(struct gpio_chip *chip, unsigned int offset,
int value)
{
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
return gb_gpio_direction_out_operation(ggc, (u8)offset, !!value);
}
static int gb_gpio_get(struct gpio_chip *chip, unsigned int offset)
{
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
u8 which;
int ret;
which = (u8)offset;
ret = gb_gpio_get_value_operation(ggc, which);
if (ret)
return ret;
return ggc->lines[which].value;
}
static void gb_gpio_set(struct gpio_chip *chip, unsigned int offset, int value)
{
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
gb_gpio_set_value_operation(ggc, (u8)offset, !!value);
}
static int gb_gpio_set_config(struct gpio_chip *chip, unsigned int offset,
unsigned long config)
{
struct gb_gpio_controller *ggc = gpio_chip_to_gb_gpio_controller(chip);
u32 debounce;
if (pinconf_to_config_param(config) != PIN_CONFIG_INPUT_DEBOUNCE)
return -ENOTSUPP;
debounce = pinconf_to_config_argument(config);
if (debounce > U16_MAX)
return -EINVAL;
return gb_gpio_set_debounce_operation(ggc, (u8)offset, (u16)debounce);
}
static int gb_gpio_controller_setup(struct gb_gpio_controller *ggc)
{
int ret;
/* Now find out how many lines there are */
ret = gb_gpio_line_count_operation(ggc);
if (ret)
return ret;
ggc->lines = kcalloc(ggc->line_max + 1, sizeof(*ggc->lines),
GFP_KERNEL);
if (!ggc->lines)
return -ENOMEM;
return ret;
}
static int gb_gpio_probe(struct gbphy_device *gbphy_dev,
const struct gbphy_device_id *id)
{
struct gb_connection *connection;
struct gb_gpio_controller *ggc;
struct gpio_chip *gpio;
struct gpio_irq_chip *girq;
struct irq_chip *irqc;
int ret;
ggc = kzalloc(sizeof(*ggc), GFP_KERNEL);
if (!ggc)
return -ENOMEM;
connection =
gb_connection_create(gbphy_dev->bundle,
le16_to_cpu(gbphy_dev->cport_desc->id),
gb_gpio_request_handler);
if (IS_ERR(connection)) {
ret = PTR_ERR(connection);
goto exit_ggc_free;
}
ggc->connection = connection;
gb_connection_set_data(connection, ggc);
ggc->gbphy_dev = gbphy_dev;
gb_gbphy_set_data(gbphy_dev, ggc);
ret = gb_connection_enable_tx(connection);
if (ret)
goto exit_connection_destroy;
ret = gb_gpio_controller_setup(ggc);
if (ret)
goto exit_connection_disable;
irqc = &ggc->irqc;
irqc->irq_mask = gb_gpio_irq_mask;
irqc->irq_unmask = gb_gpio_irq_unmask;
irqc->irq_set_type = gb_gpio_irq_set_type;
irqc->irq_bus_lock = gb_gpio_irq_bus_lock;
irqc->irq_bus_sync_unlock = gb_gpio_irq_bus_sync_unlock;
irqc->name = "greybus_gpio";
mutex_init(&ggc->irq_lock);
gpio = &ggc->chip;
gpio->label = "greybus_gpio";
gpio->parent = &gbphy_dev->dev;
gpio->owner = THIS_MODULE;
gpio->request = gb_gpio_request;
gpio->free = gb_gpio_free;
gpio->get_direction = gb_gpio_get_direction;
gpio->direction_input = gb_gpio_direction_input;
gpio->direction_output = gb_gpio_direction_output;
gpio->get = gb_gpio_get;
gpio->set = gb_gpio_set;
gpio->set_config = gb_gpio_set_config;
gpio->base = -1; /* Allocate base dynamically */
gpio->ngpio = ggc->line_max + 1;
gpio->can_sleep = true;
girq = &gpio->irq;
girq->chip = irqc;
/* The event comes from the outside so no parent handler */
girq->parent_handler = NULL;
girq->num_parents = 0;
girq->parents = NULL;
girq->default_type = IRQ_TYPE_NONE;
girq->handler = handle_level_irq;
ret = gb_connection_enable(connection);
if (ret)
goto exit_line_free;
ret = gpiochip_add(gpio);
if (ret) {
dev_err(&gbphy_dev->dev, "failed to add gpio chip: %d\n", ret);
goto exit_line_free;
}
gbphy_runtime_put_autosuspend(gbphy_dev);
return 0;
exit_line_free:
kfree(ggc->lines);
exit_connection_disable:
gb_connection_disable(connection);
exit_connection_destroy:
gb_connection_destroy(connection);
exit_ggc_free:
kfree(ggc);
return ret;
}
static void gb_gpio_remove(struct gbphy_device *gbphy_dev)
{
struct gb_gpio_controller *ggc = gb_gbphy_get_data(gbphy_dev);
struct gb_connection *connection = ggc->connection;
int ret;
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
gbphy_runtime_get_noresume(gbphy_dev);
gb_connection_disable_rx(connection);
gpiochip_remove(&ggc->chip);
gb_connection_disable(connection);
gb_connection_destroy(connection);
kfree(ggc->lines);
kfree(ggc);
}
static const struct gbphy_device_id gb_gpio_id_table[] = {
{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_GPIO) },
{ },
};
MODULE_DEVICE_TABLE(gbphy, gb_gpio_id_table);
static struct gbphy_driver gpio_driver = {
.name = "gpio",
.probe = gb_gpio_probe,
.remove = gb_gpio_remove,
.id_table = gb_gpio_id_table,
};
module_gbphy_driver(gpio_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/gpio.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus audio driver
* Copyright 2015 Google Inc.
* Copyright 2015 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <sound/soc.h>
#include <sound/pcm_params.h>
#include "audio_codec.h"
#include "audio_apbridgea.h"
#include "audio_manager.h"
/*
* gb_snd management functions
*/
static int gbaudio_request_jack(struct gbaudio_module_info *module,
struct gb_audio_jack_event_request *req)
{
int report;
struct snd_jack *jack = module->headset.jack.jack;
struct snd_jack *btn_jack = module->button.jack.jack;
if (!jack) {
dev_err_ratelimited(module->dev,
"Invalid jack event received:type: %u, event: %u\n",
req->jack_attribute, req->event);
return -EINVAL;
}
dev_warn_ratelimited(module->dev,
"Jack Event received: type: %u, event: %u\n",
req->jack_attribute, req->event);
if (req->event == GB_AUDIO_JACK_EVENT_REMOVAL) {
module->jack_type = 0;
if (btn_jack && module->button_status) {
snd_soc_jack_report(&module->button.jack, 0,
module->button_mask);
module->button_status = 0;
}
snd_soc_jack_report(&module->headset.jack, 0,
module->jack_mask);
return 0;
}
report = req->jack_attribute & module->jack_mask;
if (!report) {
dev_err_ratelimited(module->dev,
"Invalid jack event received:type: %u, event: %u\n",
req->jack_attribute, req->event);
return -EINVAL;
}
if (module->jack_type)
dev_warn_ratelimited(module->dev,
"Modifying jack from %d to %d\n",
module->jack_type, report);
module->jack_type = report;
snd_soc_jack_report(&module->headset.jack, report, module->jack_mask);
return 0;
}
static int gbaudio_request_button(struct gbaudio_module_info *module,
struct gb_audio_button_event_request *req)
{
int soc_button_id, report;
struct snd_jack *btn_jack = module->button.jack.jack;
if (!btn_jack) {
dev_err_ratelimited(module->dev,
"Invalid button event received:type: %u, event: %u\n",
req->button_id, req->event);
return -EINVAL;
}
dev_warn_ratelimited(module->dev,
"Button Event received: id: %u, event: %u\n",
req->button_id, req->event);
/* currently supports 4 buttons only */
if (!module->jack_type) {
dev_err_ratelimited(module->dev,
"Jack not present. Bogus event!!\n");
return -EINVAL;
}
report = module->button_status & module->button_mask;
soc_button_id = 0;
switch (req->button_id) {
case 1:
soc_button_id = SND_JACK_BTN_0 & module->button_mask;
break;
case 2:
soc_button_id = SND_JACK_BTN_1 & module->button_mask;
break;
case 3:
soc_button_id = SND_JACK_BTN_2 & module->button_mask;
break;
case 4:
soc_button_id = SND_JACK_BTN_3 & module->button_mask;
break;
}
if (!soc_button_id) {
dev_err_ratelimited(module->dev,
"Invalid button request received\n");
return -EINVAL;
}
if (req->event == GB_AUDIO_BUTTON_EVENT_PRESS)
report = report | soc_button_id;
else
report = report & ~soc_button_id;
module->button_status = report;
snd_soc_jack_report(&module->button.jack, report, module->button_mask);
return 0;
}
static int gbaudio_request_stream(struct gbaudio_module_info *module,
struct gb_audio_streaming_event_request *req)
{
dev_warn(module->dev, "Audio Event received: cport: %u, event: %u\n",
le16_to_cpu(req->data_cport), req->event);
return 0;
}
static int gbaudio_codec_request_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gbaudio_module_info *module =
greybus_get_drvdata(connection->bundle);
struct gb_operation_msg_hdr *header = op->request->header;
struct gb_audio_streaming_event_request *stream_req;
struct gb_audio_jack_event_request *jack_req;
struct gb_audio_button_event_request *button_req;
int ret;
switch (header->type) {
case GB_AUDIO_TYPE_STREAMING_EVENT:
stream_req = op->request->payload;
ret = gbaudio_request_stream(module, stream_req);
break;
case GB_AUDIO_TYPE_JACK_EVENT:
jack_req = op->request->payload;
ret = gbaudio_request_jack(module, jack_req);
break;
case GB_AUDIO_TYPE_BUTTON_EVENT:
button_req = op->request->payload;
ret = gbaudio_request_button(module, button_req);
break;
default:
dev_err_ratelimited(&connection->bundle->dev,
"Invalid Audio Event received\n");
return -EINVAL;
}
return ret;
}
static int gb_audio_add_mgmt_connection(struct gbaudio_module_info *gbmodule,
struct greybus_descriptor_cport *cport_desc,
struct gb_bundle *bundle)
{
struct gb_connection *connection;
/* Management Cport */
if (gbmodule->mgmt_connection) {
dev_err(&bundle->dev,
"Can't have multiple Management connections\n");
return -ENODEV;
}
connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
gbaudio_codec_request_handler);
if (IS_ERR(connection))
return PTR_ERR(connection);
greybus_set_drvdata(bundle, gbmodule);
gbmodule->mgmt_connection = connection;
return 0;
}
static int gb_audio_add_data_connection(struct gbaudio_module_info *gbmodule,
struct greybus_descriptor_cport *cport_desc,
struct gb_bundle *bundle)
{
struct gb_connection *connection;
struct gbaudio_data_connection *dai;
dai = devm_kzalloc(gbmodule->dev, sizeof(*dai), GFP_KERNEL);
if (!dai)
return -ENOMEM;
connection = gb_connection_create_offloaded(bundle,
le16_to_cpu(cport_desc->id),
GB_CONNECTION_FLAG_CSD);
if (IS_ERR(connection)) {
devm_kfree(gbmodule->dev, dai);
return PTR_ERR(connection);
}
greybus_set_drvdata(bundle, gbmodule);
dai->id = 0;
dai->data_cport = cpu_to_le16(connection->intf_cport_id);
dai->connection = connection;
list_add(&dai->list, &gbmodule->data_list);
return 0;
}
/*
* This is the basic hook get things initialized and registered w/ gb
*/
static int gb_audio_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct device *dev = &bundle->dev;
struct gbaudio_module_info *gbmodule;
struct greybus_descriptor_cport *cport_desc;
struct gb_audio_manager_module_descriptor desc;
struct gbaudio_data_connection *dai, *_dai;
int ret, i;
struct gb_audio_topology *topology;
/* There should be at least one Management and one Data cport */
if (bundle->num_cports < 2)
return -ENODEV;
/*
* There can be only one Management connection and any number of data
* connections.
*/
gbmodule = devm_kzalloc(dev, sizeof(*gbmodule), GFP_KERNEL);
if (!gbmodule)
return -ENOMEM;
gbmodule->num_data_connections = bundle->num_cports - 1;
INIT_LIST_HEAD(&gbmodule->data_list);
INIT_LIST_HEAD(&gbmodule->widget_list);
INIT_LIST_HEAD(&gbmodule->ctl_list);
INIT_LIST_HEAD(&gbmodule->widget_ctl_list);
INIT_LIST_HEAD(&gbmodule->jack_list);
gbmodule->dev = dev;
snprintf(gbmodule->name, sizeof(gbmodule->name), "%s.%s", dev->driver->name,
dev_name(dev));
greybus_set_drvdata(bundle, gbmodule);
/* Create all connections */
for (i = 0; i < bundle->num_cports; i++) {
cport_desc = &bundle->cport_desc[i];
switch (cport_desc->protocol_id) {
case GREYBUS_PROTOCOL_AUDIO_MGMT:
ret = gb_audio_add_mgmt_connection(gbmodule, cport_desc,
bundle);
if (ret)
goto destroy_connections;
break;
case GREYBUS_PROTOCOL_AUDIO_DATA:
ret = gb_audio_add_data_connection(gbmodule, cport_desc,
bundle);
if (ret)
goto destroy_connections;
break;
default:
dev_err(dev, "Unsupported protocol: 0x%02x\n",
cport_desc->protocol_id);
ret = -ENODEV;
goto destroy_connections;
}
}
/* There must be a management cport */
if (!gbmodule->mgmt_connection) {
ret = -EINVAL;
dev_err(dev, "Missing management connection\n");
goto destroy_connections;
}
/* Initialize management connection */
ret = gb_connection_enable(gbmodule->mgmt_connection);
if (ret) {
dev_err(dev, "%d: Error while enabling mgmt connection\n", ret);
goto destroy_connections;
}
gbmodule->dev_id = gbmodule->mgmt_connection->intf->interface_id;
/*
* FIXME: malloc for topology happens via audio_gb driver
* should be done within codec driver itself
*/
ret = gb_audio_gb_get_topology(gbmodule->mgmt_connection, &topology);
if (ret) {
dev_err(dev, "%d:Error while fetching topology\n", ret);
goto disable_connection;
}
/* process topology data */
ret = gbaudio_tplg_parse_data(gbmodule, topology);
if (ret) {
dev_err(dev, "%d:Error while parsing topology data\n",
ret);
goto free_topology;
}
gbmodule->topology = topology;
/* Initialize data connections */
list_for_each_entry(dai, &gbmodule->data_list, list) {
ret = gb_connection_enable(dai->connection);
if (ret) {
dev_err(dev,
"%d:Error while enabling %d:data connection\n",
ret, le16_to_cpu(dai->data_cport));
goto disable_data_connection;
}
}
/* register module with gbcodec */
ret = gbaudio_register_module(gbmodule);
if (ret)
goto disable_data_connection;
/* inform above layer for uevent */
dev_dbg(dev, "Inform set_event:%d to above layer\n", 1);
/* prepare for the audio manager */
strscpy(desc.name, gbmodule->name, sizeof(desc.name));
desc.vid = 2; /* todo */
desc.pid = 3; /* todo */
desc.intf_id = gbmodule->dev_id;
desc.op_devices = gbmodule->op_devices;
desc.ip_devices = gbmodule->ip_devices;
gbmodule->manager_id = gb_audio_manager_add(&desc);
dev_dbg(dev, "Add GB Audio device:%s\n", gbmodule->name);
gb_pm_runtime_put_autosuspend(bundle);
return 0;
disable_data_connection:
list_for_each_entry_safe(dai, _dai, &gbmodule->data_list, list)
gb_connection_disable(dai->connection);
gbaudio_tplg_release(gbmodule);
gbmodule->topology = NULL;
free_topology:
kfree(topology);
disable_connection:
gb_connection_disable(gbmodule->mgmt_connection);
destroy_connections:
list_for_each_entry_safe(dai, _dai, &gbmodule->data_list, list) {
gb_connection_destroy(dai->connection);
list_del(&dai->list);
devm_kfree(dev, dai);
}
if (gbmodule->mgmt_connection)
gb_connection_destroy(gbmodule->mgmt_connection);
devm_kfree(dev, gbmodule);
return ret;
}
static void gb_audio_disconnect(struct gb_bundle *bundle)
{
struct gbaudio_module_info *gbmodule = greybus_get_drvdata(bundle);
struct gbaudio_data_connection *dai, *_dai;
gb_pm_runtime_get_sync(bundle);
/* cleanup module related resources first */
gbaudio_unregister_module(gbmodule);
/* inform uevent to above layers */
gb_audio_manager_remove(gbmodule->manager_id);
gbaudio_tplg_release(gbmodule);
kfree(gbmodule->topology);
gbmodule->topology = NULL;
gb_connection_disable(gbmodule->mgmt_connection);
list_for_each_entry_safe(dai, _dai, &gbmodule->data_list, list) {
gb_connection_disable(dai->connection);
gb_connection_destroy(dai->connection);
list_del(&dai->list);
devm_kfree(gbmodule->dev, dai);
}
gb_connection_destroy(gbmodule->mgmt_connection);
gbmodule->mgmt_connection = NULL;
devm_kfree(&bundle->dev, gbmodule);
}
static const struct greybus_bundle_id gb_audio_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_AUDIO) },
{ }
};
MODULE_DEVICE_TABLE(greybus, gb_audio_id_table);
#ifdef CONFIG_PM
static int gb_audio_suspend(struct device *dev)
{
struct gb_bundle *bundle = to_gb_bundle(dev);
struct gbaudio_module_info *gbmodule = greybus_get_drvdata(bundle);
struct gbaudio_data_connection *dai;
list_for_each_entry(dai, &gbmodule->data_list, list)
gb_connection_disable(dai->connection);
gb_connection_disable(gbmodule->mgmt_connection);
return 0;
}
static int gb_audio_resume(struct device *dev)
{
struct gb_bundle *bundle = to_gb_bundle(dev);
struct gbaudio_module_info *gbmodule = greybus_get_drvdata(bundle);
struct gbaudio_data_connection *dai;
int ret;
ret = gb_connection_enable(gbmodule->mgmt_connection);
if (ret) {
dev_err(dev, "%d:Error while enabling mgmt connection\n", ret);
return ret;
}
list_for_each_entry(dai, &gbmodule->data_list, list) {
ret = gb_connection_enable(dai->connection);
if (ret) {
dev_err(dev,
"%d:Error while enabling %d:data connection\n",
ret, le16_to_cpu(dai->data_cport));
return ret;
}
}
return 0;
}
#endif
static const struct dev_pm_ops gb_audio_pm_ops = {
SET_RUNTIME_PM_OPS(gb_audio_suspend, gb_audio_resume, NULL)
};
static struct greybus_driver gb_audio_driver = {
.name = "gb-audio",
.probe = gb_audio_probe,
.disconnect = gb_audio_disconnect,
.id_table = gb_audio_id_table,
.driver.pm = &gb_audio_pm_ops,
};
module_greybus_driver(gb_audio_driver);
MODULE_DESCRIPTION("Greybus Audio module driver");
MODULE_AUTHOR("Vaibhav Agarwal <[email protected]>");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:gbaudio-module");
| linux-master | drivers/staging/greybus/audio_module.c |
// SPDX-License-Identifier: GPL-2.0
/*
* I2C bridge driver for the Greybus "generic" I2C module.
*
* Copyright 2014 Google Inc.
* Copyright 2014 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/greybus.h>
#include "gbphy.h"
struct gb_i2c_device {
struct gb_connection *connection;
struct gbphy_device *gbphy_dev;
u32 functionality;
struct i2c_adapter adapter;
};
/*
* Map Greybus i2c functionality bits into Linux ones
*/
static u32 gb_i2c_functionality_map(u32 gb_i2c_functionality)
{
return gb_i2c_functionality; /* All bits the same for now */
}
/*
* Do initial setup of the i2c device. This includes verifying we
* can support it (based on the protocol version it advertises).
* If that's OK, we get and cached its functionality bits.
*
* Note: gb_i2c_dev->connection is assumed to have been valid.
*/
static int gb_i2c_device_setup(struct gb_i2c_device *gb_i2c_dev)
{
struct gb_i2c_functionality_response response;
u32 functionality;
int ret;
ret = gb_operation_sync(gb_i2c_dev->connection,
GB_I2C_TYPE_FUNCTIONALITY,
NULL, 0, &response, sizeof(response));
if (ret)
return ret;
functionality = le32_to_cpu(response.functionality);
gb_i2c_dev->functionality = gb_i2c_functionality_map(functionality);
return 0;
}
/*
* Map Linux i2c_msg flags into Greybus i2c transfer op flags.
*/
static u16 gb_i2c_transfer_op_flags_map(u16 flags)
{
return flags; /* All flags the same for now */
}
static void
gb_i2c_fill_transfer_op(struct gb_i2c_transfer_op *op, struct i2c_msg *msg)
{
u16 flags = gb_i2c_transfer_op_flags_map(msg->flags);
op->addr = cpu_to_le16(msg->addr);
op->flags = cpu_to_le16(flags);
op->size = cpu_to_le16(msg->len);
}
static struct gb_operation *
gb_i2c_operation_create(struct gb_connection *connection,
struct i2c_msg *msgs, u32 msg_count)
{
struct gb_i2c_device *gb_i2c_dev = gb_connection_get_data(connection);
struct gb_i2c_transfer_request *request;
struct gb_operation *operation;
struct gb_i2c_transfer_op *op;
struct i2c_msg *msg;
u32 data_out_size = 0;
u32 data_in_size = 0;
size_t request_size;
void *data;
u16 op_count;
u32 i;
if (msg_count > (u32)U16_MAX) {
dev_err(&gb_i2c_dev->gbphy_dev->dev, "msg_count (%u) too big\n",
msg_count);
return NULL;
}
op_count = (u16)msg_count;
/*
* In addition to space for all message descriptors we need
* to have enough to hold all outbound message data.
*/
msg = msgs;
for (i = 0; i < msg_count; i++, msg++)
if (msg->flags & I2C_M_RD)
data_in_size += (u32)msg->len;
else
data_out_size += (u32)msg->len;
request_size = sizeof(*request);
request_size += msg_count * sizeof(*op);
request_size += data_out_size;
/* Response consists only of incoming data */
operation = gb_operation_create(connection, GB_I2C_TYPE_TRANSFER,
request_size, data_in_size, GFP_KERNEL);
if (!operation)
return NULL;
request = operation->request->payload;
request->op_count = cpu_to_le16(op_count);
/* Fill in the ops array */
op = &request->ops[0];
msg = msgs;
for (i = 0; i < msg_count; i++)
gb_i2c_fill_transfer_op(op++, msg++);
if (!data_out_size)
return operation;
/* Copy over the outgoing data; it starts after the last op */
data = op;
msg = msgs;
for (i = 0; i < msg_count; i++) {
if (!(msg->flags & I2C_M_RD)) {
memcpy(data, msg->buf, msg->len);
data += msg->len;
}
msg++;
}
return operation;
}
static void gb_i2c_decode_response(struct i2c_msg *msgs, u32 msg_count,
struct gb_i2c_transfer_response *response)
{
struct i2c_msg *msg = msgs;
u8 *data;
u32 i;
if (!response)
return;
data = response->data;
for (i = 0; i < msg_count; i++) {
if (msg->flags & I2C_M_RD) {
memcpy(msg->buf, data, msg->len);
data += msg->len;
}
msg++;
}
}
/*
* Some i2c transfer operations return results that are expected.
*/
static bool gb_i2c_expected_transfer_error(int errno)
{
return errno == -EAGAIN || errno == -ENODEV;
}
static int gb_i2c_transfer_operation(struct gb_i2c_device *gb_i2c_dev,
struct i2c_msg *msgs, u32 msg_count)
{
struct gb_connection *connection = gb_i2c_dev->connection;
struct device *dev = &gb_i2c_dev->gbphy_dev->dev;
struct gb_operation *operation;
int ret;
operation = gb_i2c_operation_create(connection, msgs, msg_count);
if (!operation)
return -ENOMEM;
ret = gbphy_runtime_get_sync(gb_i2c_dev->gbphy_dev);
if (ret)
goto exit_operation_put;
ret = gb_operation_request_send_sync(operation);
if (!ret) {
struct gb_i2c_transfer_response *response;
response = operation->response->payload;
gb_i2c_decode_response(msgs, msg_count, response);
ret = msg_count;
} else if (!gb_i2c_expected_transfer_error(ret)) {
dev_err(dev, "transfer operation failed (%d)\n", ret);
}
gbphy_runtime_put_autosuspend(gb_i2c_dev->gbphy_dev);
exit_operation_put:
gb_operation_put(operation);
return ret;
}
static int gb_i2c_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
int msg_count)
{
struct gb_i2c_device *gb_i2c_dev;
gb_i2c_dev = i2c_get_adapdata(adap);
return gb_i2c_transfer_operation(gb_i2c_dev, msgs, msg_count);
}
static u32 gb_i2c_functionality(struct i2c_adapter *adap)
{
struct gb_i2c_device *gb_i2c_dev = i2c_get_adapdata(adap);
return gb_i2c_dev->functionality;
}
static const struct i2c_algorithm gb_i2c_algorithm = {
.master_xfer = gb_i2c_master_xfer,
.functionality = gb_i2c_functionality,
};
static int gb_i2c_probe(struct gbphy_device *gbphy_dev,
const struct gbphy_device_id *id)
{
struct gb_connection *connection;
struct gb_i2c_device *gb_i2c_dev;
struct i2c_adapter *adapter;
int ret;
gb_i2c_dev = kzalloc(sizeof(*gb_i2c_dev), GFP_KERNEL);
if (!gb_i2c_dev)
return -ENOMEM;
connection =
gb_connection_create(gbphy_dev->bundle,
le16_to_cpu(gbphy_dev->cport_desc->id),
NULL);
if (IS_ERR(connection)) {
ret = PTR_ERR(connection);
goto exit_i2cdev_free;
}
gb_i2c_dev->connection = connection;
gb_connection_set_data(connection, gb_i2c_dev);
gb_i2c_dev->gbphy_dev = gbphy_dev;
gb_gbphy_set_data(gbphy_dev, gb_i2c_dev);
ret = gb_connection_enable(connection);
if (ret)
goto exit_connection_destroy;
ret = gb_i2c_device_setup(gb_i2c_dev);
if (ret)
goto exit_connection_disable;
/* Looks good; up our i2c adapter */
adapter = &gb_i2c_dev->adapter;
adapter->owner = THIS_MODULE;
adapter->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
adapter->algo = &gb_i2c_algorithm;
adapter->dev.parent = &gbphy_dev->dev;
snprintf(adapter->name, sizeof(adapter->name), "Greybus i2c adapter");
i2c_set_adapdata(adapter, gb_i2c_dev);
ret = i2c_add_adapter(adapter);
if (ret)
goto exit_connection_disable;
gbphy_runtime_put_autosuspend(gbphy_dev);
return 0;
exit_connection_disable:
gb_connection_disable(connection);
exit_connection_destroy:
gb_connection_destroy(connection);
exit_i2cdev_free:
kfree(gb_i2c_dev);
return ret;
}
static void gb_i2c_remove(struct gbphy_device *gbphy_dev)
{
struct gb_i2c_device *gb_i2c_dev = gb_gbphy_get_data(gbphy_dev);
struct gb_connection *connection = gb_i2c_dev->connection;
int ret;
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
gbphy_runtime_get_noresume(gbphy_dev);
i2c_del_adapter(&gb_i2c_dev->adapter);
gb_connection_disable(connection);
gb_connection_destroy(connection);
kfree(gb_i2c_dev);
}
static const struct gbphy_device_id gb_i2c_id_table[] = {
{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_I2C) },
{ },
};
MODULE_DEVICE_TABLE(gbphy, gb_i2c_id_table);
static struct gbphy_driver i2c_driver = {
.name = "i2c",
.probe = gb_i2c_probe,
.remove = gb_i2c_remove,
.id_table = gb_i2c_id_table,
};
module_gbphy_driver(i2c_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/i2c.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Firmware Core Bundle Driver.
*
* Copyright 2016 Google Inc.
* Copyright 2016 Linaro Ltd.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/firmware.h>
#include <linux/greybus.h>
#include "firmware.h"
#include "spilib.h"
struct gb_fw_core {
struct gb_connection *download_connection;
struct gb_connection *mgmt_connection;
struct gb_connection *spi_connection;
struct gb_connection *cap_connection;
};
static struct spilib_ops *spilib_ops;
struct gb_connection *to_fw_mgmt_connection(struct device *dev)
{
struct gb_fw_core *fw_core = dev_get_drvdata(dev);
return fw_core->mgmt_connection;
}
static int gb_fw_spi_connection_init(struct gb_connection *connection)
{
int ret;
if (!connection)
return 0;
ret = gb_connection_enable(connection);
if (ret)
return ret;
ret = gb_spilib_master_init(connection, &connection->bundle->dev,
spilib_ops);
if (ret) {
gb_connection_disable(connection);
return ret;
}
return 0;
}
static void gb_fw_spi_connection_exit(struct gb_connection *connection)
{
if (!connection)
return;
gb_spilib_master_exit(connection);
gb_connection_disable(connection);
}
static int gb_fw_core_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct greybus_descriptor_cport *cport_desc;
struct gb_connection *connection;
struct gb_fw_core *fw_core;
int ret, i;
u16 cport_id;
u8 protocol_id;
fw_core = kzalloc(sizeof(*fw_core), GFP_KERNEL);
if (!fw_core)
return -ENOMEM;
/* Parse CPorts and create connections */
for (i = 0; i < bundle->num_cports; i++) {
cport_desc = &bundle->cport_desc[i];
cport_id = le16_to_cpu(cport_desc->id);
protocol_id = cport_desc->protocol_id;
switch (protocol_id) {
case GREYBUS_PROTOCOL_FW_MANAGEMENT:
/* Disallow multiple Firmware Management CPorts */
if (fw_core->mgmt_connection) {
dev_err(&bundle->dev,
"multiple management CPorts found\n");
ret = -EINVAL;
goto err_destroy_connections;
}
connection = gb_connection_create(bundle, cport_id,
gb_fw_mgmt_request_handler);
if (IS_ERR(connection)) {
ret = PTR_ERR(connection);
dev_err(&bundle->dev,
"failed to create management connection (%d)\n",
ret);
goto err_destroy_connections;
}
fw_core->mgmt_connection = connection;
break;
case GREYBUS_PROTOCOL_FW_DOWNLOAD:
/* Disallow multiple Firmware Download CPorts */
if (fw_core->download_connection) {
dev_err(&bundle->dev,
"multiple download CPorts found\n");
ret = -EINVAL;
goto err_destroy_connections;
}
connection = gb_connection_create(bundle, cport_id,
gb_fw_download_request_handler);
if (IS_ERR(connection)) {
dev_err(&bundle->dev, "failed to create download connection (%ld)\n",
PTR_ERR(connection));
} else {
fw_core->download_connection = connection;
}
break;
case GREYBUS_PROTOCOL_SPI:
/* Disallow multiple SPI CPorts */
if (fw_core->spi_connection) {
dev_err(&bundle->dev,
"multiple SPI CPorts found\n");
ret = -EINVAL;
goto err_destroy_connections;
}
connection = gb_connection_create(bundle, cport_id,
NULL);
if (IS_ERR(connection)) {
dev_err(&bundle->dev, "failed to create SPI connection (%ld)\n",
PTR_ERR(connection));
} else {
fw_core->spi_connection = connection;
}
break;
case GREYBUS_PROTOCOL_AUTHENTICATION:
/* Disallow multiple CAP CPorts */
if (fw_core->cap_connection) {
dev_err(&bundle->dev, "multiple Authentication CPorts found\n");
ret = -EINVAL;
goto err_destroy_connections;
}
connection = gb_connection_create(bundle, cport_id,
NULL);
if (IS_ERR(connection)) {
dev_err(&bundle->dev, "failed to create Authentication connection (%ld)\n",
PTR_ERR(connection));
} else {
fw_core->cap_connection = connection;
}
break;
default:
dev_err(&bundle->dev, "invalid protocol id (0x%02x)\n",
protocol_id);
ret = -EINVAL;
goto err_destroy_connections;
}
}
/* Firmware Management connection is mandatory */
if (!fw_core->mgmt_connection) {
dev_err(&bundle->dev, "missing management connection\n");
ret = -ENODEV;
goto err_destroy_connections;
}
ret = gb_fw_download_connection_init(fw_core->download_connection);
if (ret) {
/* We may still be able to work with the Interface */
dev_err(&bundle->dev, "failed to initialize firmware download connection, disable it (%d)\n",
ret);
gb_connection_destroy(fw_core->download_connection);
fw_core->download_connection = NULL;
}
ret = gb_fw_spi_connection_init(fw_core->spi_connection);
if (ret) {
/* We may still be able to work with the Interface */
dev_err(&bundle->dev, "failed to initialize SPI connection, disable it (%d)\n",
ret);
gb_connection_destroy(fw_core->spi_connection);
fw_core->spi_connection = NULL;
}
ret = gb_cap_connection_init(fw_core->cap_connection);
if (ret) {
/* We may still be able to work with the Interface */
dev_err(&bundle->dev, "failed to initialize CAP connection, disable it (%d)\n",
ret);
gb_connection_destroy(fw_core->cap_connection);
fw_core->cap_connection = NULL;
}
ret = gb_fw_mgmt_connection_init(fw_core->mgmt_connection);
if (ret) {
/* We may still be able to work with the Interface */
dev_err(&bundle->dev, "failed to initialize firmware management connection, disable it (%d)\n",
ret);
goto err_exit_connections;
}
greybus_set_drvdata(bundle, fw_core);
/* FIXME: Remove this after S2 Loader gets runtime PM support */
if (!(bundle->intf->quirks & GB_INTERFACE_QUIRK_NO_PM))
gb_pm_runtime_put_autosuspend(bundle);
return 0;
err_exit_connections:
gb_cap_connection_exit(fw_core->cap_connection);
gb_fw_spi_connection_exit(fw_core->spi_connection);
gb_fw_download_connection_exit(fw_core->download_connection);
err_destroy_connections:
gb_connection_destroy(fw_core->mgmt_connection);
gb_connection_destroy(fw_core->cap_connection);
gb_connection_destroy(fw_core->spi_connection);
gb_connection_destroy(fw_core->download_connection);
kfree(fw_core);
return ret;
}
static void gb_fw_core_disconnect(struct gb_bundle *bundle)
{
struct gb_fw_core *fw_core = greybus_get_drvdata(bundle);
int ret;
/* FIXME: Remove this after S2 Loader gets runtime PM support */
if (!(bundle->intf->quirks & GB_INTERFACE_QUIRK_NO_PM)) {
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
gb_pm_runtime_get_noresume(bundle);
}
gb_fw_mgmt_connection_exit(fw_core->mgmt_connection);
gb_cap_connection_exit(fw_core->cap_connection);
gb_fw_spi_connection_exit(fw_core->spi_connection);
gb_fw_download_connection_exit(fw_core->download_connection);
gb_connection_destroy(fw_core->mgmt_connection);
gb_connection_destroy(fw_core->cap_connection);
gb_connection_destroy(fw_core->spi_connection);
gb_connection_destroy(fw_core->download_connection);
kfree(fw_core);
}
static const struct greybus_bundle_id gb_fw_core_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_FW_MANAGEMENT) },
{ }
};
static struct greybus_driver gb_fw_core_driver = {
.name = "gb-firmware",
.probe = gb_fw_core_probe,
.disconnect = gb_fw_core_disconnect,
.id_table = gb_fw_core_id_table,
};
static int fw_core_init(void)
{
int ret;
ret = fw_mgmt_init();
if (ret) {
pr_err("Failed to initialize fw-mgmt core (%d)\n", ret);
return ret;
}
ret = cap_init();
if (ret) {
pr_err("Failed to initialize component authentication core (%d)\n",
ret);
goto fw_mgmt_exit;
}
ret = greybus_register(&gb_fw_core_driver);
if (ret)
goto cap_exit;
return 0;
cap_exit:
cap_exit();
fw_mgmt_exit:
fw_mgmt_exit();
return ret;
}
module_init(fw_core_init);
static void __exit fw_core_exit(void)
{
greybus_deregister(&gb_fw_core_driver);
cap_exit();
fw_mgmt_exit();
}
module_exit(fw_core_exit);
MODULE_ALIAS("greybus:firmware");
MODULE_AUTHOR("Viresh Kumar <[email protected]>");
MODULE_DESCRIPTION("Greybus Firmware Bundle Driver");
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/fw-core.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus operations
*
* Copyright 2015-2016 Google Inc.
*/
#include <linux/slab.h>
#include "audio_manager.h"
#include "audio_manager_private.h"
#define to_gb_audio_module_attr(x) \
container_of(x, struct gb_audio_manager_module_attribute, attr)
static inline struct gb_audio_manager_module *to_gb_audio_module(struct kobject *kobj)
{
return container_of(kobj, struct gb_audio_manager_module, kobj);
}
struct gb_audio_manager_module_attribute {
struct attribute attr;
ssize_t (*show)(struct gb_audio_manager_module *module,
struct gb_audio_manager_module_attribute *attr,
char *buf);
ssize_t (*store)(struct gb_audio_manager_module *module,
struct gb_audio_manager_module_attribute *attr,
const char *buf, size_t count);
};
static ssize_t gb_audio_module_attr_show(struct kobject *kobj,
struct attribute *attr, char *buf)
{
struct gb_audio_manager_module_attribute *attribute;
struct gb_audio_manager_module *module;
attribute = to_gb_audio_module_attr(attr);
module = to_gb_audio_module(kobj);
if (!attribute->show)
return -EIO;
return attribute->show(module, attribute, buf);
}
static ssize_t gb_audio_module_attr_store(struct kobject *kobj,
struct attribute *attr,
const char *buf, size_t len)
{
struct gb_audio_manager_module_attribute *attribute;
struct gb_audio_manager_module *module;
attribute = to_gb_audio_module_attr(attr);
module = to_gb_audio_module(kobj);
if (!attribute->store)
return -EIO;
return attribute->store(module, attribute, buf, len);
}
static const struct sysfs_ops gb_audio_module_sysfs_ops = {
.show = gb_audio_module_attr_show,
.store = gb_audio_module_attr_store,
};
static void gb_audio_module_release(struct kobject *kobj)
{
struct gb_audio_manager_module *module = to_gb_audio_module(kobj);
pr_info("Destroying audio module #%d\n", module->id);
/* TODO -> delete from list */
kfree(module);
}
static ssize_t gb_audio_module_name_show(struct gb_audio_manager_module *module,
struct gb_audio_manager_module_attribute *attr, char *buf)
{
return sprintf(buf, "%s", module->desc.name);
}
static struct gb_audio_manager_module_attribute gb_audio_module_name_attribute =
__ATTR(name, 0664, gb_audio_module_name_show, NULL);
static ssize_t gb_audio_module_vid_show(struct gb_audio_manager_module *module,
struct gb_audio_manager_module_attribute *attr, char *buf)
{
return sprintf(buf, "%d", module->desc.vid);
}
static struct gb_audio_manager_module_attribute gb_audio_module_vid_attribute =
__ATTR(vid, 0664, gb_audio_module_vid_show, NULL);
static ssize_t gb_audio_module_pid_show(struct gb_audio_manager_module *module,
struct gb_audio_manager_module_attribute *attr, char *buf)
{
return sprintf(buf, "%d", module->desc.pid);
}
static struct gb_audio_manager_module_attribute gb_audio_module_pid_attribute =
__ATTR(pid, 0664, gb_audio_module_pid_show, NULL);
static ssize_t gb_audio_module_intf_id_show(struct gb_audio_manager_module *module,
struct gb_audio_manager_module_attribute *attr,
char *buf)
{
return sprintf(buf, "%d", module->desc.intf_id);
}
static struct gb_audio_manager_module_attribute
gb_audio_module_intf_id_attribute =
__ATTR(intf_id, 0664, gb_audio_module_intf_id_show, NULL);
static ssize_t gb_audio_module_ip_devices_show(struct gb_audio_manager_module *module,
struct gb_audio_manager_module_attribute *attr,
char *buf)
{
return sprintf(buf, "0x%X", module->desc.ip_devices);
}
static struct gb_audio_manager_module_attribute
gb_audio_module_ip_devices_attribute =
__ATTR(ip_devices, 0664, gb_audio_module_ip_devices_show, NULL);
static ssize_t gb_audio_module_op_devices_show(struct gb_audio_manager_module *module,
struct gb_audio_manager_module_attribute *attr,
char *buf)
{
return sprintf(buf, "0x%X", module->desc.op_devices);
}
static struct gb_audio_manager_module_attribute
gb_audio_module_op_devices_attribute =
__ATTR(op_devices, 0664, gb_audio_module_op_devices_show, NULL);
static struct attribute *gb_audio_module_default_attrs[] = {
&gb_audio_module_name_attribute.attr,
&gb_audio_module_vid_attribute.attr,
&gb_audio_module_pid_attribute.attr,
&gb_audio_module_intf_id_attribute.attr,
&gb_audio_module_ip_devices_attribute.attr,
&gb_audio_module_op_devices_attribute.attr,
NULL, /* need to NULL terminate the list of attributes */
};
ATTRIBUTE_GROUPS(gb_audio_module_default);
static struct kobj_type gb_audio_module_type = {
.sysfs_ops = &gb_audio_module_sysfs_ops,
.release = gb_audio_module_release,
.default_groups = gb_audio_module_default_groups,
};
static void send_add_uevent(struct gb_audio_manager_module *module)
{
char name_string[128];
char vid_string[64];
char pid_string[64];
char intf_id_string[64];
char ip_devices_string[64];
char op_devices_string[64];
char *envp[] = {
name_string,
vid_string,
pid_string,
intf_id_string,
ip_devices_string,
op_devices_string,
NULL
};
snprintf(name_string, 128, "NAME=%s", module->desc.name);
snprintf(vid_string, 64, "VID=%d", module->desc.vid);
snprintf(pid_string, 64, "PID=%d", module->desc.pid);
snprintf(intf_id_string, 64, "INTF_ID=%d", module->desc.intf_id);
snprintf(ip_devices_string, 64, "I/P DEVICES=0x%X",
module->desc.ip_devices);
snprintf(op_devices_string, 64, "O/P DEVICES=0x%X",
module->desc.op_devices);
kobject_uevent_env(&module->kobj, KOBJ_ADD, envp);
}
int gb_audio_manager_module_create(struct gb_audio_manager_module **module,
struct kset *manager_kset,
int id, struct gb_audio_manager_module_descriptor *desc)
{
int err;
struct gb_audio_manager_module *m;
m = kzalloc(sizeof(*m), GFP_ATOMIC);
if (!m)
return -ENOMEM;
/* Initialize the node */
INIT_LIST_HEAD(&m->list);
/* Set the module id */
m->id = id;
/* Copy the provided descriptor */
memcpy(&m->desc, desc, sizeof(*desc));
/* set the kset */
m->kobj.kset = manager_kset;
/*
* Initialize and add the kobject to the kernel. All the default files
* will be created here. As we have already specified a kset for this
* kobject, we don't have to set a parent for the kobject, the kobject
* will be placed beneath that kset automatically.
*/
err = kobject_init_and_add(&m->kobj, &gb_audio_module_type, NULL, "%d",
id);
if (err) {
pr_err("failed initializing kobject for audio module #%d\n", id);
kobject_put(&m->kobj);
return err;
}
/*
* Notify the object was created
*/
send_add_uevent(m);
*module = m;
pr_info("Created audio module #%d\n", id);
return 0;
}
void gb_audio_manager_module_dump(struct gb_audio_manager_module *module)
{
pr_info("audio module #%d name=%s vid=%d pid=%d intf_id=%d i/p devices=0x%X o/p devices=0x%X\n",
module->id,
module->desc.name,
module->desc.vid,
module->desc.pid,
module->desc.intf_id,
module->desc.ip_devices,
module->desc.op_devices);
}
| linux-master | drivers/staging/greybus/audio_manager_module.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus SPI library
*
* Copyright 2014-2016 Google Inc.
* Copyright 2014-2016 Linaro Ltd.
*/
#include <linux/bitops.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/greybus.h>
#include <linux/spi/spi.h>
#include "spilib.h"
struct gb_spilib {
struct gb_connection *connection;
struct device *parent;
struct spi_transfer *first_xfer;
struct spi_transfer *last_xfer;
struct spilib_ops *ops;
u32 rx_xfer_offset;
u32 tx_xfer_offset;
u32 last_xfer_size;
unsigned int op_timeout;
u16 mode;
u16 flags;
u32 bits_per_word_mask;
u8 num_chipselect;
u32 min_speed_hz;
u32 max_speed_hz;
};
#define GB_SPI_STATE_MSG_DONE ((void *)0)
#define GB_SPI_STATE_MSG_IDLE ((void *)1)
#define GB_SPI_STATE_MSG_RUNNING ((void *)2)
#define GB_SPI_STATE_OP_READY ((void *)3)
#define GB_SPI_STATE_OP_DONE ((void *)4)
#define GB_SPI_STATE_MSG_ERROR ((void *)-1)
#define XFER_TIMEOUT_TOLERANCE 200
static struct spi_master *get_master_from_spi(struct gb_spilib *spi)
{
return gb_connection_get_data(spi->connection);
}
static int tx_header_fit_operation(u32 tx_size, u32 count, size_t data_max)
{
size_t headers_size;
data_max -= sizeof(struct gb_spi_transfer_request);
headers_size = (count + 1) * sizeof(struct gb_spi_transfer);
return tx_size + headers_size > data_max ? 0 : 1;
}
static size_t calc_rx_xfer_size(u32 rx_size, u32 *tx_xfer_size, u32 len,
size_t data_max)
{
size_t rx_xfer_size;
data_max -= sizeof(struct gb_spi_transfer_response);
if (rx_size + len > data_max)
rx_xfer_size = data_max - rx_size;
else
rx_xfer_size = len;
/* if this is a write_read, for symmetry read the same as write */
if (*tx_xfer_size && rx_xfer_size > *tx_xfer_size)
rx_xfer_size = *tx_xfer_size;
if (*tx_xfer_size && rx_xfer_size < *tx_xfer_size)
*tx_xfer_size = rx_xfer_size;
return rx_xfer_size;
}
static size_t calc_tx_xfer_size(u32 tx_size, u32 count, size_t len,
size_t data_max)
{
size_t headers_size;
data_max -= sizeof(struct gb_spi_transfer_request);
headers_size = (count + 1) * sizeof(struct gb_spi_transfer);
if (tx_size + headers_size + len > data_max)
return data_max - (tx_size + sizeof(struct gb_spi_transfer));
return len;
}
static void clean_xfer_state(struct gb_spilib *spi)
{
spi->first_xfer = NULL;
spi->last_xfer = NULL;
spi->rx_xfer_offset = 0;
spi->tx_xfer_offset = 0;
spi->last_xfer_size = 0;
spi->op_timeout = 0;
}
static bool is_last_xfer_done(struct gb_spilib *spi)
{
struct spi_transfer *last_xfer = spi->last_xfer;
if ((spi->tx_xfer_offset + spi->last_xfer_size == last_xfer->len) ||
(spi->rx_xfer_offset + spi->last_xfer_size == last_xfer->len))
return true;
return false;
}
static int setup_next_xfer(struct gb_spilib *spi, struct spi_message *msg)
{
struct spi_transfer *last_xfer = spi->last_xfer;
if (msg->state != GB_SPI_STATE_OP_DONE)
return 0;
/*
* if we transferred all content of the last transfer, reset values and
* check if this was the last transfer in the message
*/
if (is_last_xfer_done(spi)) {
spi->tx_xfer_offset = 0;
spi->rx_xfer_offset = 0;
spi->op_timeout = 0;
if (last_xfer == list_last_entry(&msg->transfers,
struct spi_transfer,
transfer_list))
msg->state = GB_SPI_STATE_MSG_DONE;
else
spi->first_xfer = list_next_entry(last_xfer,
transfer_list);
return 0;
}
spi->first_xfer = last_xfer;
if (last_xfer->tx_buf)
spi->tx_xfer_offset += spi->last_xfer_size;
if (last_xfer->rx_buf)
spi->rx_xfer_offset += spi->last_xfer_size;
return 0;
}
static struct spi_transfer *get_next_xfer(struct spi_transfer *xfer,
struct spi_message *msg)
{
if (xfer == list_last_entry(&msg->transfers, struct spi_transfer,
transfer_list))
return NULL;
return list_next_entry(xfer, transfer_list);
}
/* Routines to transfer data */
static struct gb_operation *gb_spi_operation_create(struct gb_spilib *spi,
struct gb_connection *connection, struct spi_message *msg)
{
struct gb_spi_transfer_request *request;
struct spi_device *dev = msg->spi;
struct spi_transfer *xfer;
struct gb_spi_transfer *gb_xfer;
struct gb_operation *operation;
u32 tx_size = 0, rx_size = 0, count = 0, xfer_len = 0, request_size;
u32 tx_xfer_size = 0, rx_xfer_size = 0, len;
u32 total_len = 0;
unsigned int xfer_timeout;
size_t data_max;
void *tx_data;
data_max = gb_operation_get_payload_size_max(connection);
xfer = spi->first_xfer;
/* Find number of transfers queued and tx/rx length in the message */
while (msg->state != GB_SPI_STATE_OP_READY) {
msg->state = GB_SPI_STATE_MSG_RUNNING;
spi->last_xfer = xfer;
if (!xfer->tx_buf && !xfer->rx_buf) {
dev_err(spi->parent,
"bufferless transfer, length %u\n", xfer->len);
msg->state = GB_SPI_STATE_MSG_ERROR;
return NULL;
}
tx_xfer_size = 0;
rx_xfer_size = 0;
if (xfer->tx_buf) {
len = xfer->len - spi->tx_xfer_offset;
if (!tx_header_fit_operation(tx_size, count, data_max))
break;
tx_xfer_size = calc_tx_xfer_size(tx_size, count,
len, data_max);
spi->last_xfer_size = tx_xfer_size;
}
if (xfer->rx_buf) {
len = xfer->len - spi->rx_xfer_offset;
rx_xfer_size = calc_rx_xfer_size(rx_size, &tx_xfer_size,
len, data_max);
spi->last_xfer_size = rx_xfer_size;
}
tx_size += tx_xfer_size;
rx_size += rx_xfer_size;
total_len += spi->last_xfer_size;
count++;
xfer = get_next_xfer(xfer, msg);
if (!xfer || total_len >= data_max)
msg->state = GB_SPI_STATE_OP_READY;
}
/*
* In addition to space for all message descriptors we need
* to have enough to hold all tx data.
*/
request_size = sizeof(*request);
request_size += count * sizeof(*gb_xfer);
request_size += tx_size;
/* Response consists only of incoming data */
operation = gb_operation_create(connection, GB_SPI_TYPE_TRANSFER,
request_size, rx_size, GFP_KERNEL);
if (!operation)
return NULL;
request = operation->request->payload;
request->count = cpu_to_le16(count);
request->mode = dev->mode;
request->chip_select = spi_get_chipselect(dev, 0);
gb_xfer = &request->transfers[0];
tx_data = gb_xfer + count; /* place tx data after last gb_xfer */
/* Fill in the transfers array */
xfer = spi->first_xfer;
while (msg->state != GB_SPI_STATE_OP_DONE) {
int xfer_delay;
if (xfer == spi->last_xfer)
xfer_len = spi->last_xfer_size;
else
xfer_len = xfer->len;
/* make sure we do not timeout in a slow transfer */
xfer_timeout = xfer_len * 8 * MSEC_PER_SEC / xfer->speed_hz;
xfer_timeout += GB_OPERATION_TIMEOUT_DEFAULT;
if (xfer_timeout > spi->op_timeout)
spi->op_timeout = xfer_timeout;
gb_xfer->speed_hz = cpu_to_le32(xfer->speed_hz);
gb_xfer->len = cpu_to_le32(xfer_len);
xfer_delay = spi_delay_to_ns(&xfer->delay, xfer) / 1000;
xfer_delay = clamp_t(u16, xfer_delay, 0, U16_MAX);
gb_xfer->delay_usecs = cpu_to_le16(xfer_delay);
gb_xfer->cs_change = xfer->cs_change;
gb_xfer->bits_per_word = xfer->bits_per_word;
/* Copy tx data */
if (xfer->tx_buf) {
gb_xfer->xfer_flags |= GB_SPI_XFER_WRITE;
memcpy(tx_data, xfer->tx_buf + spi->tx_xfer_offset,
xfer_len);
tx_data += xfer_len;
}
if (xfer->rx_buf)
gb_xfer->xfer_flags |= GB_SPI_XFER_READ;
if (xfer == spi->last_xfer) {
if (!is_last_xfer_done(spi))
gb_xfer->xfer_flags |= GB_SPI_XFER_INPROGRESS;
msg->state = GB_SPI_STATE_OP_DONE;
continue;
}
gb_xfer++;
xfer = get_next_xfer(xfer, msg);
}
msg->actual_length += total_len;
return operation;
}
static void gb_spi_decode_response(struct gb_spilib *spi,
struct spi_message *msg,
struct gb_spi_transfer_response *response)
{
struct spi_transfer *xfer = spi->first_xfer;
void *rx_data = response->data;
u32 xfer_len;
while (xfer) {
/* Copy rx data */
if (xfer->rx_buf) {
if (xfer == spi->first_xfer)
xfer_len = xfer->len - spi->rx_xfer_offset;
else if (xfer == spi->last_xfer)
xfer_len = spi->last_xfer_size;
else
xfer_len = xfer->len;
memcpy(xfer->rx_buf + spi->rx_xfer_offset, rx_data,
xfer_len);
rx_data += xfer_len;
}
if (xfer == spi->last_xfer)
break;
xfer = list_next_entry(xfer, transfer_list);
}
}
static int gb_spi_transfer_one_message(struct spi_master *master,
struct spi_message *msg)
{
struct gb_spilib *spi = spi_master_get_devdata(master);
struct gb_connection *connection = spi->connection;
struct gb_spi_transfer_response *response;
struct gb_operation *operation;
int ret = 0;
spi->first_xfer = list_first_entry_or_null(&msg->transfers,
struct spi_transfer,
transfer_list);
if (!spi->first_xfer) {
ret = -ENOMEM;
goto out;
}
msg->state = GB_SPI_STATE_MSG_IDLE;
while (msg->state != GB_SPI_STATE_MSG_DONE &&
msg->state != GB_SPI_STATE_MSG_ERROR) {
operation = gb_spi_operation_create(spi, connection, msg);
if (!operation) {
msg->state = GB_SPI_STATE_MSG_ERROR;
ret = -EINVAL;
continue;
}
ret = gb_operation_request_send_sync_timeout(operation,
spi->op_timeout);
if (!ret) {
response = operation->response->payload;
if (response)
gb_spi_decode_response(spi, msg, response);
} else {
dev_err(spi->parent,
"transfer operation failed: %d\n", ret);
msg->state = GB_SPI_STATE_MSG_ERROR;
}
gb_operation_put(operation);
setup_next_xfer(spi, msg);
}
out:
msg->status = ret;
clean_xfer_state(spi);
spi_finalize_current_message(master);
return ret;
}
static int gb_spi_prepare_transfer_hardware(struct spi_master *master)
{
struct gb_spilib *spi = spi_master_get_devdata(master);
return spi->ops->prepare_transfer_hardware(spi->parent);
}
static int gb_spi_unprepare_transfer_hardware(struct spi_master *master)
{
struct gb_spilib *spi = spi_master_get_devdata(master);
spi->ops->unprepare_transfer_hardware(spi->parent);
return 0;
}
static int gb_spi_setup(struct spi_device *spi)
{
/* Nothing to do for now */
return 0;
}
static void gb_spi_cleanup(struct spi_device *spi)
{
/* Nothing to do for now */
}
/* Routines to get controller information */
/*
* Map Greybus spi mode bits/flags/bpw into Linux ones.
* All bits are same for now and so these macro's return same values.
*/
#define gb_spi_mode_map(mode) mode
#define gb_spi_flags_map(flags) flags
static int gb_spi_get_master_config(struct gb_spilib *spi)
{
struct gb_spi_master_config_response response;
u16 mode, flags;
int ret;
ret = gb_operation_sync(spi->connection, GB_SPI_TYPE_MASTER_CONFIG,
NULL, 0, &response, sizeof(response));
if (ret < 0)
return ret;
mode = le16_to_cpu(response.mode);
spi->mode = gb_spi_mode_map(mode);
flags = le16_to_cpu(response.flags);
spi->flags = gb_spi_flags_map(flags);
spi->bits_per_word_mask = le32_to_cpu(response.bits_per_word_mask);
spi->num_chipselect = response.num_chipselect;
spi->min_speed_hz = le32_to_cpu(response.min_speed_hz);
spi->max_speed_hz = le32_to_cpu(response.max_speed_hz);
return 0;
}
static int gb_spi_setup_device(struct gb_spilib *spi, u8 cs)
{
struct spi_master *master = get_master_from_spi(spi);
struct gb_spi_device_config_request request;
struct gb_spi_device_config_response response;
struct spi_board_info spi_board = { {0} };
struct spi_device *spidev;
int ret;
u8 dev_type;
request.chip_select = cs;
ret = gb_operation_sync(spi->connection, GB_SPI_TYPE_DEVICE_CONFIG,
&request, sizeof(request),
&response, sizeof(response));
if (ret < 0)
return ret;
dev_type = response.device_type;
if (dev_type == GB_SPI_SPI_DEV)
strscpy(spi_board.modalias, "spidev",
sizeof(spi_board.modalias));
else if (dev_type == GB_SPI_SPI_NOR)
strscpy(spi_board.modalias, "spi-nor",
sizeof(spi_board.modalias));
else if (dev_type == GB_SPI_SPI_MODALIAS)
memcpy(spi_board.modalias, response.name,
sizeof(spi_board.modalias));
else
return -EINVAL;
spi_board.mode = le16_to_cpu(response.mode);
spi_board.bus_num = master->bus_num;
spi_board.chip_select = cs;
spi_board.max_speed_hz = le32_to_cpu(response.max_speed_hz);
spidev = spi_new_device(master, &spi_board);
if (!spidev)
return -EINVAL;
return 0;
}
int gb_spilib_master_init(struct gb_connection *connection, struct device *dev,
struct spilib_ops *ops)
{
struct gb_spilib *spi;
struct spi_master *master;
int ret;
u8 i;
/* Allocate master with space for data */
master = spi_alloc_master(dev, sizeof(*spi));
if (!master) {
dev_err(dev, "cannot alloc SPI master\n");
return -ENOMEM;
}
spi = spi_master_get_devdata(master);
spi->connection = connection;
gb_connection_set_data(connection, master);
spi->parent = dev;
spi->ops = ops;
/* get master configuration */
ret = gb_spi_get_master_config(spi);
if (ret)
goto exit_spi_put;
master->bus_num = -1; /* Allow spi-core to allocate it dynamically */
master->num_chipselect = spi->num_chipselect;
master->mode_bits = spi->mode;
master->flags = spi->flags;
master->bits_per_word_mask = spi->bits_per_word_mask;
/* Attach methods */
master->cleanup = gb_spi_cleanup;
master->setup = gb_spi_setup;
master->transfer_one_message = gb_spi_transfer_one_message;
if (ops && ops->prepare_transfer_hardware) {
master->prepare_transfer_hardware =
gb_spi_prepare_transfer_hardware;
}
if (ops && ops->unprepare_transfer_hardware) {
master->unprepare_transfer_hardware =
gb_spi_unprepare_transfer_hardware;
}
master->auto_runtime_pm = true;
ret = spi_register_master(master);
if (ret < 0)
goto exit_spi_put;
/* now, fetch the devices configuration */
for (i = 0; i < spi->num_chipselect; i++) {
ret = gb_spi_setup_device(spi, i);
if (ret < 0) {
dev_err(dev, "failed to allocate spi device %d: %d\n",
i, ret);
goto exit_spi_unregister;
}
}
return 0;
exit_spi_put:
spi_master_put(master);
return ret;
exit_spi_unregister:
spi_unregister_master(master);
return ret;
}
EXPORT_SYMBOL_GPL(gb_spilib_master_init);
void gb_spilib_master_exit(struct gb_connection *connection)
{
struct spi_master *master = gb_connection_get_data(connection);
spi_unregister_master(master);
}
EXPORT_SYMBOL_GPL(gb_spilib_master_exit);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/spilib.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Audio Sound SoC helper APIs
*/
#include <sound/core.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include "audio_helper.h"
#define gbaudio_dapm_for_each_direction(dir) \
for ((dir) = SND_SOC_DAPM_DIR_IN; (dir) <= SND_SOC_DAPM_DIR_OUT; \
(dir)++)
static void gbaudio_dapm_link_dai_widget(struct snd_soc_dapm_widget *dai_w,
struct snd_soc_card *card)
{
struct snd_soc_dapm_widget *w;
struct snd_soc_dapm_widget *src, *sink;
struct snd_soc_dai *dai = dai_w->priv;
/* ...find all widgets with the same stream and link them */
list_for_each_entry(w, &card->widgets, list) {
if (w->dapm != dai_w->dapm)
continue;
switch (w->id) {
case snd_soc_dapm_dai_in:
case snd_soc_dapm_dai_out:
continue;
default:
break;
}
if (!w->sname || !strstr(w->sname, dai_w->sname))
continue;
/*
* check if widget is already linked,
* if (w->linked)
* return;
*/
if (dai_w->id == snd_soc_dapm_dai_in) {
src = dai_w;
sink = w;
} else {
src = w;
sink = dai_w;
}
dev_dbg(dai->dev, "%s -> %s\n", src->name, sink->name);
/* Add the DAPM path and set widget's linked status
* snd_soc_dapm_add_path(w->dapm, src, sink, NULL, NULL);
* w->linked = 1;
*/
}
}
int gbaudio_dapm_link_component_dai_widgets(struct snd_soc_card *card,
struct snd_soc_dapm_context *dapm)
{
struct snd_soc_dapm_widget *dai_w;
/* For each DAI widget... */
list_for_each_entry(dai_w, &card->widgets, list) {
if (dai_w->dapm != dapm)
continue;
switch (dai_w->id) {
case snd_soc_dapm_dai_in:
case snd_soc_dapm_dai_out:
break;
default:
continue;
}
gbaudio_dapm_link_dai_widget(dai_w, card);
}
return 0;
}
static void gbaudio_dapm_free_path(struct snd_soc_dapm_path *path)
{
list_del(&path->list_node[SND_SOC_DAPM_DIR_IN]);
list_del(&path->list_node[SND_SOC_DAPM_DIR_OUT]);
list_del(&path->list_kcontrol);
list_del(&path->list);
kfree(path);
}
static void gbaudio_dapm_free_widget(struct snd_soc_dapm_widget *w)
{
struct snd_soc_dapm_path *p, *next_p;
enum snd_soc_dapm_direction dir;
list_del(&w->list);
/*
* remove source and sink paths associated to this widget.
* While removing the path, remove reference to it from both
* source and sink widgets so that path is removed only once.
*/
gbaudio_dapm_for_each_direction(dir) {
snd_soc_dapm_widget_for_each_path_safe(w, dir, p, next_p)
gbaudio_dapm_free_path(p);
}
kfree(w->kcontrols);
kfree_const(w->name);
kfree_const(w->sname);
kfree(w);
}
int gbaudio_dapm_free_controls(struct snd_soc_dapm_context *dapm,
const struct snd_soc_dapm_widget *widget,
int num)
{
int i;
struct snd_soc_dapm_widget *w, *tmp_w;
mutex_lock(&dapm->card->dapm_mutex);
for (i = 0; i < num; i++) {
/* below logic can be optimized to identify widget pointer */
w = NULL;
list_for_each_entry(tmp_w, &dapm->card->widgets, list) {
if (tmp_w->dapm == dapm &&
!strcmp(tmp_w->name, widget->name)) {
w = tmp_w;
break;
}
}
if (!w) {
dev_err(dapm->dev, "%s: widget not found\n",
widget->name);
widget++;
continue;
}
widget++;
gbaudio_dapm_free_widget(w);
}
mutex_unlock(&dapm->card->dapm_mutex);
return 0;
}
static int gbaudio_remove_controls(struct snd_card *card, struct device *dev,
const struct snd_kcontrol_new *controls,
int num_controls, const char *prefix)
{
int i, err;
for (i = 0; i < num_controls; i++) {
const struct snd_kcontrol_new *control = &controls[i];
struct snd_ctl_elem_id id;
if (prefix)
snprintf(id.name, sizeof(id.name), "%s %s", prefix,
control->name);
else
strscpy(id.name, control->name, sizeof(id.name));
id.numid = 0;
id.iface = control->iface;
id.device = control->device;
id.subdevice = control->subdevice;
id.index = control->index;
err = snd_ctl_remove_id(card, &id);
if (err < 0)
dev_err(dev, "%d: Failed to remove %s\n", err,
control->name);
}
return 0;
}
int gbaudio_remove_component_controls(struct snd_soc_component *component,
const struct snd_kcontrol_new *controls,
unsigned int num_controls)
{
struct snd_card *card = component->card->snd_card;
return gbaudio_remove_controls(card, component->dev, controls,
num_controls, component->name_prefix);
}
| linux-master | drivers/staging/greybus/audio_helper.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Lights protocol driver.
*
* Copyright 2015 Google Inc.
* Copyright 2015 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/leds.h>
#include <linux/led-class-flash.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/greybus.h>
#include <media/v4l2-flash-led-class.h>
#define NAMES_MAX 32
struct gb_channel {
u8 id;
u32 flags;
u32 color;
char *color_name;
u8 fade_in;
u8 fade_out;
u32 mode;
char *mode_name;
struct attribute **attrs;
struct attribute_group *attr_group;
const struct attribute_group **attr_groups;
struct led_classdev *led;
#if IS_REACHABLE(CONFIG_LEDS_CLASS_FLASH)
struct led_classdev_flash fled;
struct led_flash_setting intensity_uA;
struct led_flash_setting timeout_us;
#else
struct led_classdev cled;
#endif
struct gb_light *light;
bool is_registered;
bool releasing;
bool strobe_state;
bool active;
struct mutex lock;
};
struct gb_light {
u8 id;
char *name;
struct gb_lights *glights;
u32 flags;
u8 channels_count;
struct gb_channel *channels;
bool has_flash;
bool ready;
#if IS_REACHABLE(CONFIG_V4L2_FLASH_LED_CLASS)
struct v4l2_flash *v4l2_flash;
struct v4l2_flash *v4l2_flash_ind;
#endif
};
struct gb_lights {
struct gb_connection *connection;
u8 lights_count;
struct gb_light *lights;
struct mutex lights_lock;
};
static void gb_lights_channel_free(struct gb_channel *channel);
static struct gb_connection *get_conn_from_channel(struct gb_channel *channel)
{
return channel->light->glights->connection;
}
static struct gb_connection *get_conn_from_light(struct gb_light *light)
{
return light->glights->connection;
}
static bool is_channel_flash(struct gb_channel *channel)
{
return !!(channel->mode & (GB_CHANNEL_MODE_FLASH | GB_CHANNEL_MODE_TORCH
| GB_CHANNEL_MODE_INDICATOR));
}
#if IS_REACHABLE(CONFIG_LEDS_CLASS_FLASH)
static struct gb_channel *get_channel_from_cdev(struct led_classdev *cdev)
{
struct led_classdev_flash *fled_cdev = lcdev_to_flcdev(cdev);
return container_of(fled_cdev, struct gb_channel, fled);
}
static struct led_classdev *get_channel_cdev(struct gb_channel *channel)
{
return &channel->fled.led_cdev;
}
static struct gb_channel *get_channel_from_mode(struct gb_light *light,
u32 mode)
{
struct gb_channel *channel = NULL;
int i;
for (i = 0; i < light->channels_count; i++) {
channel = &light->channels[i];
if (channel && channel->mode == mode)
break;
}
return channel;
}
static int __gb_lights_flash_intensity_set(struct gb_channel *channel,
u32 intensity)
{
struct gb_connection *connection = get_conn_from_channel(channel);
struct gb_bundle *bundle = connection->bundle;
struct gb_lights_set_flash_intensity_request req;
int ret;
if (channel->releasing)
return -ESHUTDOWN;
ret = gb_pm_runtime_get_sync(bundle);
if (ret < 0)
return ret;
req.light_id = channel->light->id;
req.channel_id = channel->id;
req.intensity_uA = cpu_to_le32(intensity);
ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FLASH_INTENSITY,
&req, sizeof(req), NULL, 0);
gb_pm_runtime_put_autosuspend(bundle);
return ret;
}
static int __gb_lights_flash_brightness_set(struct gb_channel *channel)
{
u32 intensity;
/* If the channel is flash we need to get the attached torch channel */
if (channel->mode & GB_CHANNEL_MODE_FLASH)
channel = get_channel_from_mode(channel->light,
GB_CHANNEL_MODE_TORCH);
/* For not flash we need to convert brightness to intensity */
intensity = channel->intensity_uA.min +
(channel->intensity_uA.step * channel->led->brightness);
return __gb_lights_flash_intensity_set(channel, intensity);
}
#else
static struct gb_channel *get_channel_from_cdev(struct led_classdev *cdev)
{
return container_of(cdev, struct gb_channel, cled);
}
static struct led_classdev *get_channel_cdev(struct gb_channel *channel)
{
return &channel->cled;
}
static int __gb_lights_flash_brightness_set(struct gb_channel *channel)
{
return 0;
}
#endif
static int gb_lights_color_set(struct gb_channel *channel, u32 color);
static int gb_lights_fade_set(struct gb_channel *channel);
static void led_lock(struct led_classdev *cdev)
{
mutex_lock(&cdev->led_access);
}
static void led_unlock(struct led_classdev *cdev)
{
mutex_unlock(&cdev->led_access);
}
#define gb_lights_fade_attr(__dir) \
static ssize_t fade_##__dir##_show(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
struct led_classdev *cdev = dev_get_drvdata(dev); \
struct gb_channel *channel = get_channel_from_cdev(cdev); \
\
return sprintf(buf, "%u\n", channel->fade_##__dir); \
} \
\
static ssize_t fade_##__dir##_store(struct device *dev, \
struct device_attribute *attr, \
const char *buf, size_t size) \
{ \
struct led_classdev *cdev = dev_get_drvdata(dev); \
struct gb_channel *channel = get_channel_from_cdev(cdev); \
u8 fade; \
int ret; \
\
led_lock(cdev); \
if (led_sysfs_is_disabled(cdev)) { \
ret = -EBUSY; \
goto unlock; \
} \
\
ret = kstrtou8(buf, 0, &fade); \
if (ret < 0) { \
dev_err(dev, "could not parse fade value %d\n", ret); \
goto unlock; \
} \
if (channel->fade_##__dir == fade) \
goto unlock; \
channel->fade_##__dir = fade; \
\
ret = gb_lights_fade_set(channel); \
if (ret < 0) \
goto unlock; \
\
ret = size; \
unlock: \
led_unlock(cdev); \
return ret; \
} \
static DEVICE_ATTR_RW(fade_##__dir)
gb_lights_fade_attr(in);
gb_lights_fade_attr(out);
static ssize_t color_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct led_classdev *cdev = dev_get_drvdata(dev);
struct gb_channel *channel = get_channel_from_cdev(cdev);
return sprintf(buf, "0x%08x\n", channel->color);
}
static ssize_t color_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t size)
{
struct led_classdev *cdev = dev_get_drvdata(dev);
struct gb_channel *channel = get_channel_from_cdev(cdev);
u32 color;
int ret;
led_lock(cdev);
if (led_sysfs_is_disabled(cdev)) {
ret = -EBUSY;
goto unlock;
}
ret = kstrtou32(buf, 0, &color);
if (ret < 0) {
dev_err(dev, "could not parse color value %d\n", ret);
goto unlock;
}
ret = gb_lights_color_set(channel, color);
if (ret < 0)
goto unlock;
channel->color = color;
ret = size;
unlock:
led_unlock(cdev);
return ret;
}
static DEVICE_ATTR_RW(color);
static int channel_attr_groups_set(struct gb_channel *channel,
struct led_classdev *cdev)
{
int attr = 0;
int size = 0;
if (channel->flags & GB_LIGHT_CHANNEL_MULTICOLOR)
size++;
if (channel->flags & GB_LIGHT_CHANNEL_FADER)
size += 2;
if (!size)
return 0;
/* Set attributes based in the channel flags */
channel->attrs = kcalloc(size + 1, sizeof(*channel->attrs), GFP_KERNEL);
if (!channel->attrs)
return -ENOMEM;
channel->attr_group = kzalloc(sizeof(*channel->attr_group), GFP_KERNEL);
if (!channel->attr_group)
return -ENOMEM;
channel->attr_groups = kcalloc(2, sizeof(*channel->attr_groups),
GFP_KERNEL);
if (!channel->attr_groups)
return -ENOMEM;
if (channel->flags & GB_LIGHT_CHANNEL_MULTICOLOR)
channel->attrs[attr++] = &dev_attr_color.attr;
if (channel->flags & GB_LIGHT_CHANNEL_FADER) {
channel->attrs[attr++] = &dev_attr_fade_in.attr;
channel->attrs[attr++] = &dev_attr_fade_out.attr;
}
channel->attr_group->attrs = channel->attrs;
channel->attr_groups[0] = channel->attr_group;
cdev->groups = channel->attr_groups;
return 0;
}
static int gb_lights_fade_set(struct gb_channel *channel)
{
struct gb_connection *connection = get_conn_from_channel(channel);
struct gb_bundle *bundle = connection->bundle;
struct gb_lights_set_fade_request req;
int ret;
if (channel->releasing)
return -ESHUTDOWN;
ret = gb_pm_runtime_get_sync(bundle);
if (ret < 0)
return ret;
req.light_id = channel->light->id;
req.channel_id = channel->id;
req.fade_in = channel->fade_in;
req.fade_out = channel->fade_out;
ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FADE,
&req, sizeof(req), NULL, 0);
gb_pm_runtime_put_autosuspend(bundle);
return ret;
}
static int gb_lights_color_set(struct gb_channel *channel, u32 color)
{
struct gb_connection *connection = get_conn_from_channel(channel);
struct gb_bundle *bundle = connection->bundle;
struct gb_lights_set_color_request req;
int ret;
if (channel->releasing)
return -ESHUTDOWN;
ret = gb_pm_runtime_get_sync(bundle);
if (ret < 0)
return ret;
req.light_id = channel->light->id;
req.channel_id = channel->id;
req.color = cpu_to_le32(color);
ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_COLOR,
&req, sizeof(req), NULL, 0);
gb_pm_runtime_put_autosuspend(bundle);
return ret;
}
static int __gb_lights_led_brightness_set(struct gb_channel *channel)
{
struct gb_lights_set_brightness_request req;
struct gb_connection *connection = get_conn_from_channel(channel);
struct gb_bundle *bundle = connection->bundle;
bool old_active;
int ret;
mutex_lock(&channel->lock);
ret = gb_pm_runtime_get_sync(bundle);
if (ret < 0)
goto out_unlock;
old_active = channel->active;
req.light_id = channel->light->id;
req.channel_id = channel->id;
req.brightness = (u8)channel->led->brightness;
ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_BRIGHTNESS,
&req, sizeof(req), NULL, 0);
if (ret < 0)
goto out_pm_put;
if (channel->led->brightness)
channel->active = true;
else
channel->active = false;
/* we need to keep module alive when turning to active state */
if (!old_active && channel->active)
goto out_unlock;
/*
* on the other hand if going to inactive we still hold a reference and
* need to put it, so we could go to suspend.
*/
if (old_active && !channel->active)
gb_pm_runtime_put_autosuspend(bundle);
out_pm_put:
gb_pm_runtime_put_autosuspend(bundle);
out_unlock:
mutex_unlock(&channel->lock);
return ret;
}
static int __gb_lights_brightness_set(struct gb_channel *channel)
{
int ret;
if (channel->releasing)
return 0;
if (is_channel_flash(channel))
ret = __gb_lights_flash_brightness_set(channel);
else
ret = __gb_lights_led_brightness_set(channel);
return ret;
}
static int gb_brightness_set(struct led_classdev *cdev,
enum led_brightness value)
{
struct gb_channel *channel = get_channel_from_cdev(cdev);
channel->led->brightness = value;
return __gb_lights_brightness_set(channel);
}
static enum led_brightness gb_brightness_get(struct led_classdev *cdev)
{
struct gb_channel *channel = get_channel_from_cdev(cdev);
return channel->led->brightness;
}
static int gb_blink_set(struct led_classdev *cdev, unsigned long *delay_on,
unsigned long *delay_off)
{
struct gb_channel *channel = get_channel_from_cdev(cdev);
struct gb_connection *connection = get_conn_from_channel(channel);
struct gb_bundle *bundle = connection->bundle;
struct gb_lights_blink_request req;
bool old_active;
int ret;
if (channel->releasing)
return -ESHUTDOWN;
if (!delay_on || !delay_off)
return -EINVAL;
mutex_lock(&channel->lock);
ret = gb_pm_runtime_get_sync(bundle);
if (ret < 0)
goto out_unlock;
old_active = channel->active;
req.light_id = channel->light->id;
req.channel_id = channel->id;
req.time_on_ms = cpu_to_le16(*delay_on);
req.time_off_ms = cpu_to_le16(*delay_off);
ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_BLINK, &req,
sizeof(req), NULL, 0);
if (ret < 0)
goto out_pm_put;
if (*delay_on)
channel->active = true;
else
channel->active = false;
/* we need to keep module alive when turning to active state */
if (!old_active && channel->active)
goto out_unlock;
/*
* on the other hand if going to inactive we still hold a reference and
* need to put it, so we could go to suspend.
*/
if (old_active && !channel->active)
gb_pm_runtime_put_autosuspend(bundle);
out_pm_put:
gb_pm_runtime_put_autosuspend(bundle);
out_unlock:
mutex_unlock(&channel->lock);
return ret;
}
static void gb_lights_led_operations_set(struct gb_channel *channel,
struct led_classdev *cdev)
{
cdev->brightness_get = gb_brightness_get;
cdev->brightness_set_blocking = gb_brightness_set;
if (channel->flags & GB_LIGHT_CHANNEL_BLINK)
cdev->blink_set = gb_blink_set;
}
#if IS_REACHABLE(CONFIG_V4L2_FLASH_LED_CLASS)
/* V4L2 specific helpers */
static const struct v4l2_flash_ops v4l2_flash_ops;
static void __gb_lights_channel_v4l2_config(struct led_flash_setting *channel_s,
struct led_flash_setting *v4l2_s)
{
v4l2_s->min = channel_s->min;
v4l2_s->max = channel_s->max;
v4l2_s->step = channel_s->step;
/* For v4l2 val is the default value */
v4l2_s->val = channel_s->max;
}
static int gb_lights_light_v4l2_register(struct gb_light *light)
{
struct gb_connection *connection = get_conn_from_light(light);
struct device *dev = &connection->bundle->dev;
struct v4l2_flash_config sd_cfg = { {0} }, sd_cfg_ind = { {0} };
struct led_classdev_flash *fled;
struct led_classdev *iled = NULL;
struct gb_channel *channel_torch, *channel_ind, *channel_flash;
channel_torch = get_channel_from_mode(light, GB_CHANNEL_MODE_TORCH);
if (channel_torch)
__gb_lights_channel_v4l2_config(&channel_torch->intensity_uA,
&sd_cfg.intensity);
channel_ind = get_channel_from_mode(light, GB_CHANNEL_MODE_INDICATOR);
if (channel_ind) {
__gb_lights_channel_v4l2_config(&channel_ind->intensity_uA,
&sd_cfg_ind.intensity);
iled = &channel_ind->fled.led_cdev;
}
channel_flash = get_channel_from_mode(light, GB_CHANNEL_MODE_FLASH);
WARN_ON(!channel_flash);
fled = &channel_flash->fled;
snprintf(sd_cfg.dev_name, sizeof(sd_cfg.dev_name), "%s", light->name);
snprintf(sd_cfg_ind.dev_name, sizeof(sd_cfg_ind.dev_name),
"%s indicator", light->name);
/* Set the possible values to faults, in our case all faults */
sd_cfg.flash_faults = LED_FAULT_OVER_VOLTAGE | LED_FAULT_TIMEOUT |
LED_FAULT_OVER_TEMPERATURE | LED_FAULT_SHORT_CIRCUIT |
LED_FAULT_OVER_CURRENT | LED_FAULT_INDICATOR |
LED_FAULT_UNDER_VOLTAGE | LED_FAULT_INPUT_VOLTAGE |
LED_FAULT_LED_OVER_TEMPERATURE;
light->v4l2_flash = v4l2_flash_init(dev, NULL, fled, &v4l2_flash_ops,
&sd_cfg);
if (IS_ERR(light->v4l2_flash))
return PTR_ERR(light->v4l2_flash);
if (channel_ind) {
light->v4l2_flash_ind =
v4l2_flash_indicator_init(dev, NULL, iled, &sd_cfg_ind);
if (IS_ERR(light->v4l2_flash_ind)) {
v4l2_flash_release(light->v4l2_flash);
return PTR_ERR(light->v4l2_flash_ind);
}
}
return 0;
}
static void gb_lights_light_v4l2_unregister(struct gb_light *light)
{
v4l2_flash_release(light->v4l2_flash_ind);
v4l2_flash_release(light->v4l2_flash);
}
#else
static int gb_lights_light_v4l2_register(struct gb_light *light)
{
struct gb_connection *connection = get_conn_from_light(light);
dev_err(&connection->bundle->dev, "no support for v4l2 subdevices\n");
return 0;
}
static void gb_lights_light_v4l2_unregister(struct gb_light *light)
{
}
#endif
#if IS_REACHABLE(CONFIG_LEDS_CLASS_FLASH)
/* Flash specific operations */
static int gb_lights_flash_intensity_set(struct led_classdev_flash *fcdev,
u32 brightness)
{
struct gb_channel *channel = container_of(fcdev, struct gb_channel,
fled);
int ret;
ret = __gb_lights_flash_intensity_set(channel, brightness);
if (ret < 0)
return ret;
fcdev->brightness.val = brightness;
return 0;
}
static int gb_lights_flash_intensity_get(struct led_classdev_flash *fcdev,
u32 *brightness)
{
*brightness = fcdev->brightness.val;
return 0;
}
static int gb_lights_flash_strobe_set(struct led_classdev_flash *fcdev,
bool state)
{
struct gb_channel *channel = container_of(fcdev, struct gb_channel,
fled);
struct gb_connection *connection = get_conn_from_channel(channel);
struct gb_bundle *bundle = connection->bundle;
struct gb_lights_set_flash_strobe_request req;
int ret;
if (channel->releasing)
return -ESHUTDOWN;
ret = gb_pm_runtime_get_sync(bundle);
if (ret < 0)
return ret;
req.light_id = channel->light->id;
req.channel_id = channel->id;
req.state = state ? 1 : 0;
ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FLASH_STROBE,
&req, sizeof(req), NULL, 0);
if (!ret)
channel->strobe_state = state;
gb_pm_runtime_put_autosuspend(bundle);
return ret;
}
static int gb_lights_flash_strobe_get(struct led_classdev_flash *fcdev,
bool *state)
{
struct gb_channel *channel = container_of(fcdev, struct gb_channel,
fled);
*state = channel->strobe_state;
return 0;
}
static int gb_lights_flash_timeout_set(struct led_classdev_flash *fcdev,
u32 timeout)
{
struct gb_channel *channel = container_of(fcdev, struct gb_channel,
fled);
struct gb_connection *connection = get_conn_from_channel(channel);
struct gb_bundle *bundle = connection->bundle;
struct gb_lights_set_flash_timeout_request req;
int ret;
if (channel->releasing)
return -ESHUTDOWN;
ret = gb_pm_runtime_get_sync(bundle);
if (ret < 0)
return ret;
req.light_id = channel->light->id;
req.channel_id = channel->id;
req.timeout_us = cpu_to_le32(timeout);
ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_SET_FLASH_TIMEOUT,
&req, sizeof(req), NULL, 0);
if (!ret)
fcdev->timeout.val = timeout;
gb_pm_runtime_put_autosuspend(bundle);
return ret;
}
static int gb_lights_flash_fault_get(struct led_classdev_flash *fcdev,
u32 *fault)
{
struct gb_channel *channel = container_of(fcdev, struct gb_channel,
fled);
struct gb_connection *connection = get_conn_from_channel(channel);
struct gb_bundle *bundle = connection->bundle;
struct gb_lights_get_flash_fault_request req;
struct gb_lights_get_flash_fault_response resp;
int ret;
if (channel->releasing)
return -ESHUTDOWN;
ret = gb_pm_runtime_get_sync(bundle);
if (ret < 0)
return ret;
req.light_id = channel->light->id;
req.channel_id = channel->id;
ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_GET_FLASH_FAULT,
&req, sizeof(req), &resp, sizeof(resp));
if (!ret)
*fault = le32_to_cpu(resp.fault);
gb_pm_runtime_put_autosuspend(bundle);
return ret;
}
static const struct led_flash_ops gb_lights_flash_ops = {
.flash_brightness_set = gb_lights_flash_intensity_set,
.flash_brightness_get = gb_lights_flash_intensity_get,
.strobe_set = gb_lights_flash_strobe_set,
.strobe_get = gb_lights_flash_strobe_get,
.timeout_set = gb_lights_flash_timeout_set,
.fault_get = gb_lights_flash_fault_get,
};
static int __gb_lights_channel_torch_attach(struct gb_channel *channel,
struct gb_channel *channel_torch)
{
char *name;
/* we can only attach torch to a flash channel */
if (!(channel->mode & GB_CHANNEL_MODE_FLASH))
return 0;
/* Move torch brightness to the destination */
channel->led->max_brightness = channel_torch->led->max_brightness;
/* append mode name to flash name */
name = kasprintf(GFP_KERNEL, "%s_%s", channel->led->name,
channel_torch->mode_name);
if (!name)
return -ENOMEM;
kfree(channel->led->name);
channel->led->name = name;
channel_torch->led = channel->led;
return 0;
}
static int __gb_lights_flash_led_register(struct gb_channel *channel)
{
struct gb_connection *connection = get_conn_from_channel(channel);
struct led_classdev_flash *fled = &channel->fled;
struct led_flash_setting *fset;
struct gb_channel *channel_torch;
int ret;
fled->ops = &gb_lights_flash_ops;
fled->led_cdev.flags |= LED_DEV_CAP_FLASH;
fset = &fled->brightness;
fset->min = channel->intensity_uA.min;
fset->max = channel->intensity_uA.max;
fset->step = channel->intensity_uA.step;
fset->val = channel->intensity_uA.max;
/* Only the flash mode have the timeout constraints settings */
if (channel->mode & GB_CHANNEL_MODE_FLASH) {
fset = &fled->timeout;
fset->min = channel->timeout_us.min;
fset->max = channel->timeout_us.max;
fset->step = channel->timeout_us.step;
fset->val = channel->timeout_us.max;
}
/*
* If light have torch mode channel, this channel will be the led
* classdev of the registered above flash classdev
*/
channel_torch = get_channel_from_mode(channel->light,
GB_CHANNEL_MODE_TORCH);
if (channel_torch) {
ret = __gb_lights_channel_torch_attach(channel, channel_torch);
if (ret < 0)
goto fail;
}
ret = led_classdev_flash_register(&connection->bundle->dev, fled);
if (ret < 0)
goto fail;
channel->is_registered = true;
return 0;
fail:
channel->led = NULL;
return ret;
}
static void __gb_lights_flash_led_unregister(struct gb_channel *channel)
{
if (!channel->is_registered)
return;
led_classdev_flash_unregister(&channel->fled);
}
static int gb_lights_channel_flash_config(struct gb_channel *channel)
{
struct gb_connection *connection = get_conn_from_channel(channel);
struct gb_lights_get_channel_flash_config_request req;
struct gb_lights_get_channel_flash_config_response conf;
struct led_flash_setting *fset;
int ret;
req.light_id = channel->light->id;
req.channel_id = channel->id;
ret = gb_operation_sync(connection,
GB_LIGHTS_TYPE_GET_CHANNEL_FLASH_CONFIG,
&req, sizeof(req), &conf, sizeof(conf));
if (ret < 0)
return ret;
/*
* Intensity constraints for flash related modes: flash, torch,
* indicator. They will be needed for v4l2 registration.
*/
fset = &channel->intensity_uA;
fset->min = le32_to_cpu(conf.intensity_min_uA);
fset->max = le32_to_cpu(conf.intensity_max_uA);
fset->step = le32_to_cpu(conf.intensity_step_uA);
/*
* On flash type, max brightness is set as the number of intensity steps
* available.
*/
channel->led->max_brightness = (fset->max - fset->min) / fset->step;
/* Only the flash mode have the timeout constraints settings */
if (channel->mode & GB_CHANNEL_MODE_FLASH) {
fset = &channel->timeout_us;
fset->min = le32_to_cpu(conf.timeout_min_us);
fset->max = le32_to_cpu(conf.timeout_max_us);
fset->step = le32_to_cpu(conf.timeout_step_us);
}
return 0;
}
#else
static int gb_lights_channel_flash_config(struct gb_channel *channel)
{
struct gb_connection *connection = get_conn_from_channel(channel);
dev_err(&connection->bundle->dev, "no support for flash devices\n");
return 0;
}
static int __gb_lights_flash_led_register(struct gb_channel *channel)
{
return 0;
}
static void __gb_lights_flash_led_unregister(struct gb_channel *channel)
{
}
#endif
static int __gb_lights_led_register(struct gb_channel *channel)
{
struct gb_connection *connection = get_conn_from_channel(channel);
struct led_classdev *cdev = get_channel_cdev(channel);
int ret;
ret = led_classdev_register(&connection->bundle->dev, cdev);
if (ret < 0)
channel->led = NULL;
else
channel->is_registered = true;
return ret;
}
static int gb_lights_channel_register(struct gb_channel *channel)
{
/* Normal LED channel, just register in led classdev and we are done */
if (!is_channel_flash(channel))
return __gb_lights_led_register(channel);
/*
* Flash Type need more work, register flash classdev, indicator as
* flash classdev, torch will be led classdev of the flash classdev.
*/
if (!(channel->mode & GB_CHANNEL_MODE_TORCH))
return __gb_lights_flash_led_register(channel);
return 0;
}
static void __gb_lights_led_unregister(struct gb_channel *channel)
{
struct led_classdev *cdev = get_channel_cdev(channel);
if (!channel->is_registered)
return;
led_classdev_unregister(cdev);
kfree(cdev->name);
cdev->name = NULL;
channel->led = NULL;
}
static void gb_lights_channel_unregister(struct gb_channel *channel)
{
/* The same as register, handle channels differently */
if (!is_channel_flash(channel)) {
__gb_lights_led_unregister(channel);
return;
}
if (channel->mode & GB_CHANNEL_MODE_TORCH)
__gb_lights_led_unregister(channel);
else
__gb_lights_flash_led_unregister(channel);
}
static int gb_lights_channel_config(struct gb_light *light,
struct gb_channel *channel)
{
struct gb_lights_get_channel_config_response conf;
struct gb_lights_get_channel_config_request req;
struct gb_connection *connection = get_conn_from_light(light);
struct led_classdev *cdev = get_channel_cdev(channel);
char *name;
int ret;
req.light_id = light->id;
req.channel_id = channel->id;
ret = gb_operation_sync(connection, GB_LIGHTS_TYPE_GET_CHANNEL_CONFIG,
&req, sizeof(req), &conf, sizeof(conf));
if (ret < 0)
return ret;
channel->light = light;
channel->mode = le32_to_cpu(conf.mode);
channel->flags = le32_to_cpu(conf.flags);
channel->color = le32_to_cpu(conf.color);
channel->color_name = kstrndup(conf.color_name, NAMES_MAX, GFP_KERNEL);
if (!channel->color_name)
return -ENOMEM;
channel->mode_name = kstrndup(conf.mode_name, NAMES_MAX, GFP_KERNEL);
if (!channel->mode_name)
return -ENOMEM;
channel->led = cdev;
name = kasprintf(GFP_KERNEL, "%s:%s:%s", light->name,
channel->color_name, channel->mode_name);
if (!name)
return -ENOMEM;
cdev->name = name;
cdev->max_brightness = conf.max_brightness;
ret = channel_attr_groups_set(channel, cdev);
if (ret < 0)
return ret;
gb_lights_led_operations_set(channel, cdev);
/*
* If it is not a flash related channel (flash, torch or indicator) we
* are done here. If not, continue and fetch flash related
* configurations.
*/
if (!is_channel_flash(channel))
return ret;
light->has_flash = true;
return gb_lights_channel_flash_config(channel);
}
static int gb_lights_light_config(struct gb_lights *glights, u8 id)
{
struct gb_light *light = &glights->lights[id];
struct gb_lights_get_light_config_request req;
struct gb_lights_get_light_config_response conf;
int ret;
int i;
light->glights = glights;
light->id = id;
req.id = id;
ret = gb_operation_sync(glights->connection,
GB_LIGHTS_TYPE_GET_LIGHT_CONFIG,
&req, sizeof(req), &conf, sizeof(conf));
if (ret < 0)
return ret;
if (!conf.channel_count)
return -EINVAL;
if (!strlen(conf.name))
return -EINVAL;
light->channels_count = conf.channel_count;
light->name = kstrndup(conf.name, NAMES_MAX, GFP_KERNEL);
if (!light->name)
return -ENOMEM;
light->channels = kcalloc(light->channels_count,
sizeof(struct gb_channel), GFP_KERNEL);
if (!light->channels)
return -ENOMEM;
/* First we collect all the configurations for all channels */
for (i = 0; i < light->channels_count; i++) {
light->channels[i].id = i;
ret = gb_lights_channel_config(light, &light->channels[i]);
if (ret < 0)
return ret;
}
return 0;
}
static int gb_lights_light_register(struct gb_light *light)
{
int ret;
int i;
/*
* Then, if everything went ok in getting configurations, we register
* the classdev, flash classdev and v4l2 subsystem, if a flash device is
* found.
*/
for (i = 0; i < light->channels_count; i++) {
ret = gb_lights_channel_register(&light->channels[i]);
if (ret < 0)
return ret;
mutex_init(&light->channels[i].lock);
}
light->ready = true;
if (light->has_flash) {
ret = gb_lights_light_v4l2_register(light);
if (ret < 0) {
light->has_flash = false;
return ret;
}
}
return 0;
}
static void gb_lights_channel_free(struct gb_channel *channel)
{
kfree(channel->attrs);
kfree(channel->attr_group);
kfree(channel->attr_groups);
kfree(channel->color_name);
kfree(channel->mode_name);
mutex_destroy(&channel->lock);
}
static void gb_lights_channel_release(struct gb_channel *channel)
{
channel->releasing = true;
gb_lights_channel_unregister(channel);
gb_lights_channel_free(channel);
}
static void gb_lights_light_release(struct gb_light *light)
{
int i;
light->ready = false;
if (light->has_flash)
gb_lights_light_v4l2_unregister(light);
light->has_flash = false;
for (i = 0; i < light->channels_count; i++)
gb_lights_channel_release(&light->channels[i]);
light->channels_count = 0;
kfree(light->channels);
light->channels = NULL;
kfree(light->name);
light->name = NULL;
}
static void gb_lights_release(struct gb_lights *glights)
{
int i;
if (!glights)
return;
mutex_lock(&glights->lights_lock);
if (!glights->lights)
goto free_glights;
for (i = 0; i < glights->lights_count; i++)
gb_lights_light_release(&glights->lights[i]);
kfree(glights->lights);
free_glights:
mutex_unlock(&glights->lights_lock);
mutex_destroy(&glights->lights_lock);
kfree(glights);
}
static int gb_lights_get_count(struct gb_lights *glights)
{
struct gb_lights_get_lights_response resp;
int ret;
ret = gb_operation_sync(glights->connection, GB_LIGHTS_TYPE_GET_LIGHTS,
NULL, 0, &resp, sizeof(resp));
if (ret < 0)
return ret;
if (!resp.lights_count)
return -EINVAL;
glights->lights_count = resp.lights_count;
return 0;
}
static int gb_lights_create_all(struct gb_lights *glights)
{
struct gb_connection *connection = glights->connection;
int ret;
int i;
mutex_lock(&glights->lights_lock);
ret = gb_lights_get_count(glights);
if (ret < 0)
goto out;
glights->lights = kcalloc(glights->lights_count,
sizeof(struct gb_light), GFP_KERNEL);
if (!glights->lights) {
ret = -ENOMEM;
goto out;
}
for (i = 0; i < glights->lights_count; i++) {
ret = gb_lights_light_config(glights, i);
if (ret < 0) {
dev_err(&connection->bundle->dev,
"Fail to configure lights device\n");
goto out;
}
}
out:
mutex_unlock(&glights->lights_lock);
return ret;
}
static int gb_lights_register_all(struct gb_lights *glights)
{
struct gb_connection *connection = glights->connection;
int ret = 0;
int i;
mutex_lock(&glights->lights_lock);
for (i = 0; i < glights->lights_count; i++) {
ret = gb_lights_light_register(&glights->lights[i]);
if (ret < 0) {
dev_err(&connection->bundle->dev,
"Fail to enable lights device\n");
break;
}
}
mutex_unlock(&glights->lights_lock);
return ret;
}
static int gb_lights_request_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct device *dev = &connection->bundle->dev;
struct gb_lights *glights = gb_connection_get_data(connection);
struct gb_light *light;
struct gb_message *request;
struct gb_lights_event_request *payload;
int ret = 0;
u8 light_id;
u8 event;
if (op->type != GB_LIGHTS_TYPE_EVENT) {
dev_err(dev, "Unsupported unsolicited event: %u\n", op->type);
return -EINVAL;
}
request = op->request;
if (request->payload_size < sizeof(*payload)) {
dev_err(dev, "Wrong event size received (%zu < %zu)\n",
request->payload_size, sizeof(*payload));
return -EINVAL;
}
payload = request->payload;
light_id = payload->light_id;
if (light_id >= glights->lights_count ||
!glights->lights[light_id].ready) {
dev_err(dev, "Event received for unconfigured light id: %d\n",
light_id);
return -EINVAL;
}
event = payload->event;
if (event & GB_LIGHTS_LIGHT_CONFIG) {
light = &glights->lights[light_id];
mutex_lock(&glights->lights_lock);
gb_lights_light_release(light);
ret = gb_lights_light_config(glights, light_id);
if (!ret)
ret = gb_lights_light_register(light);
if (ret < 0)
gb_lights_light_release(light);
mutex_unlock(&glights->lights_lock);
}
return ret;
}
static int gb_lights_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct greybus_descriptor_cport *cport_desc;
struct gb_connection *connection;
struct gb_lights *glights;
int ret;
if (bundle->num_cports != 1)
return -ENODEV;
cport_desc = &bundle->cport_desc[0];
if (cport_desc->protocol_id != GREYBUS_PROTOCOL_LIGHTS)
return -ENODEV;
glights = kzalloc(sizeof(*glights), GFP_KERNEL);
if (!glights)
return -ENOMEM;
mutex_init(&glights->lights_lock);
connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
gb_lights_request_handler);
if (IS_ERR(connection)) {
ret = PTR_ERR(connection);
goto out;
}
glights->connection = connection;
gb_connection_set_data(connection, glights);
greybus_set_drvdata(bundle, glights);
/* We aren't ready to receive an incoming request yet */
ret = gb_connection_enable_tx(connection);
if (ret)
goto error_connection_destroy;
/*
* Setup all the lights devices over this connection, if anything goes
* wrong tear down all lights
*/
ret = gb_lights_create_all(glights);
if (ret < 0)
goto error_connection_disable;
/* We are ready to receive an incoming request now, enable RX as well */
ret = gb_connection_enable(connection);
if (ret)
goto error_connection_disable;
/* Enable & register lights */
ret = gb_lights_register_all(glights);
if (ret < 0)
goto error_connection_disable;
gb_pm_runtime_put_autosuspend(bundle);
return 0;
error_connection_disable:
gb_connection_disable(connection);
error_connection_destroy:
gb_connection_destroy(connection);
out:
gb_lights_release(glights);
return ret;
}
static void gb_lights_disconnect(struct gb_bundle *bundle)
{
struct gb_lights *glights = greybus_get_drvdata(bundle);
if (gb_pm_runtime_get_sync(bundle))
gb_pm_runtime_get_noresume(bundle);
gb_connection_disable(glights->connection);
gb_connection_destroy(glights->connection);
gb_lights_release(glights);
}
static const struct greybus_bundle_id gb_lights_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_LIGHTS) },
{ }
};
MODULE_DEVICE_TABLE(greybus, gb_lights_id_table);
static struct greybus_driver gb_lights_driver = {
.name = "lights",
.probe = gb_lights_probe,
.disconnect = gb_lights_disconnect,
.id_table = gb_lights_id_table,
};
module_greybus_driver(gb_lights_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/light.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Vibrator protocol driver.
*
* Copyright 2014 Google Inc.
* Copyright 2014 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/device.h>
#include <linux/kdev_t.h>
#include <linux/idr.h>
#include <linux/pm_runtime.h>
#include <linux/greybus.h>
struct gb_vibrator_device {
struct gb_connection *connection;
struct device *dev;
int minor; /* vibrator minor number */
struct delayed_work delayed_work;
};
/* Greybus Vibrator operation types */
#define GB_VIBRATOR_TYPE_ON 0x02
#define GB_VIBRATOR_TYPE_OFF 0x03
static int turn_off(struct gb_vibrator_device *vib)
{
struct gb_bundle *bundle = vib->connection->bundle;
int ret;
ret = gb_operation_sync(vib->connection, GB_VIBRATOR_TYPE_OFF,
NULL, 0, NULL, 0);
gb_pm_runtime_put_autosuspend(bundle);
return ret;
}
static int turn_on(struct gb_vibrator_device *vib, u16 timeout_ms)
{
struct gb_bundle *bundle = vib->connection->bundle;
int ret;
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
/* Vibrator was switched ON earlier */
if (cancel_delayed_work_sync(&vib->delayed_work))
turn_off(vib);
ret = gb_operation_sync(vib->connection, GB_VIBRATOR_TYPE_ON,
NULL, 0, NULL, 0);
if (ret) {
gb_pm_runtime_put_autosuspend(bundle);
return ret;
}
schedule_delayed_work(&vib->delayed_work, msecs_to_jiffies(timeout_ms));
return 0;
}
static void gb_vibrator_worker(struct work_struct *work)
{
struct delayed_work *delayed_work = to_delayed_work(work);
struct gb_vibrator_device *vib =
container_of(delayed_work,
struct gb_vibrator_device,
delayed_work);
turn_off(vib);
}
static ssize_t timeout_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t count)
{
struct gb_vibrator_device *vib = dev_get_drvdata(dev);
unsigned long val;
int retval;
retval = kstrtoul(buf, 10, &val);
if (retval < 0) {
dev_err(dev, "could not parse timeout value %d\n", retval);
return retval;
}
if (val)
retval = turn_on(vib, (u16)val);
else
retval = turn_off(vib);
if (retval)
return retval;
return count;
}
static DEVICE_ATTR_WO(timeout);
static struct attribute *vibrator_attrs[] = {
&dev_attr_timeout.attr,
NULL,
};
ATTRIBUTE_GROUPS(vibrator);
static struct class vibrator_class = {
.name = "vibrator",
.dev_groups = vibrator_groups,
};
static DEFINE_IDA(minors);
static int gb_vibrator_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct greybus_descriptor_cport *cport_desc;
struct gb_connection *connection;
struct gb_vibrator_device *vib;
struct device *dev;
int retval;
if (bundle->num_cports != 1)
return -ENODEV;
cport_desc = &bundle->cport_desc[0];
if (cport_desc->protocol_id != GREYBUS_PROTOCOL_VIBRATOR)
return -ENODEV;
vib = kzalloc(sizeof(*vib), GFP_KERNEL);
if (!vib)
return -ENOMEM;
connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
NULL);
if (IS_ERR(connection)) {
retval = PTR_ERR(connection);
goto err_free_vib;
}
gb_connection_set_data(connection, vib);
vib->connection = connection;
greybus_set_drvdata(bundle, vib);
retval = gb_connection_enable(connection);
if (retval)
goto err_connection_destroy;
/*
* For now we create a device in sysfs for the vibrator, but odds are
* there is a "real" device somewhere in the kernel for this, but I
* can't find it at the moment...
*/
vib->minor = ida_simple_get(&minors, 0, 0, GFP_KERNEL);
if (vib->minor < 0) {
retval = vib->minor;
goto err_connection_disable;
}
dev = device_create(&vibrator_class, &bundle->dev,
MKDEV(0, 0), vib, "vibrator%d", vib->minor);
if (IS_ERR(dev)) {
retval = -EINVAL;
goto err_ida_remove;
}
vib->dev = dev;
INIT_DELAYED_WORK(&vib->delayed_work, gb_vibrator_worker);
gb_pm_runtime_put_autosuspend(bundle);
return 0;
err_ida_remove:
ida_simple_remove(&minors, vib->minor);
err_connection_disable:
gb_connection_disable(connection);
err_connection_destroy:
gb_connection_destroy(connection);
err_free_vib:
kfree(vib);
return retval;
}
static void gb_vibrator_disconnect(struct gb_bundle *bundle)
{
struct gb_vibrator_device *vib = greybus_get_drvdata(bundle);
int ret;
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
gb_pm_runtime_get_noresume(bundle);
if (cancel_delayed_work_sync(&vib->delayed_work))
turn_off(vib);
device_unregister(vib->dev);
ida_simple_remove(&minors, vib->minor);
gb_connection_disable(vib->connection);
gb_connection_destroy(vib->connection);
kfree(vib);
}
static const struct greybus_bundle_id gb_vibrator_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_VIBRATOR) },
{ }
};
MODULE_DEVICE_TABLE(greybus, gb_vibrator_id_table);
static struct greybus_driver gb_vibrator_driver = {
.name = "vibrator",
.probe = gb_vibrator_probe,
.disconnect = gb_vibrator_disconnect,
.id_table = gb_vibrator_id_table,
};
static __init int gb_vibrator_init(void)
{
int retval;
retval = class_register(&vibrator_class);
if (retval)
return retval;
retval = greybus_register(&gb_vibrator_driver);
if (retval)
goto err_class_unregister;
return 0;
err_class_unregister:
class_unregister(&vibrator_class);
return retval;
}
module_init(gb_vibrator_init);
static __exit void gb_vibrator_exit(void)
{
greybus_deregister(&gb_vibrator_driver);
class_unregister(&vibrator_class);
ida_destroy(&minors);
}
module_exit(gb_vibrator_exit);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/vibrator.c |
// SPDX-License-Identifier: GPL-2.0
/*
* HID class driver for the Greybus.
*
* Copyright 2014 Google Inc.
* Copyright 2014 Linaro Ltd.
*/
#include <linux/bitops.h>
#include <linux/hid.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/greybus.h>
/* Greybus HID device's structure */
struct gb_hid {
struct gb_bundle *bundle;
struct gb_connection *connection;
struct hid_device *hid;
struct gb_hid_desc_response hdesc;
unsigned long flags;
#define GB_HID_STARTED 0x01
#define GB_HID_READ_PENDING 0x04
unsigned int bufsize;
char *inbuf;
};
/* Routines to get controller's information over greybus */
/* Operations performed on greybus */
static int gb_hid_get_desc(struct gb_hid *ghid)
{
return gb_operation_sync(ghid->connection, GB_HID_TYPE_GET_DESC, NULL,
0, &ghid->hdesc, sizeof(ghid->hdesc));
}
static int gb_hid_get_report_desc(struct gb_hid *ghid, char *rdesc)
{
int ret;
ret = gb_pm_runtime_get_sync(ghid->bundle);
if (ret)
return ret;
ret = gb_operation_sync(ghid->connection, GB_HID_TYPE_GET_REPORT_DESC,
NULL, 0, rdesc,
le16_to_cpu(ghid->hdesc.wReportDescLength));
gb_pm_runtime_put_autosuspend(ghid->bundle);
return ret;
}
static int gb_hid_set_power(struct gb_hid *ghid, int type)
{
int ret;
ret = gb_pm_runtime_get_sync(ghid->bundle);
if (ret)
return ret;
ret = gb_operation_sync(ghid->connection, type, NULL, 0, NULL, 0);
gb_pm_runtime_put_autosuspend(ghid->bundle);
return ret;
}
static int gb_hid_get_report(struct gb_hid *ghid, u8 report_type, u8 report_id,
unsigned char *buf, int len)
{
struct gb_hid_get_report_request request;
int ret;
ret = gb_pm_runtime_get_sync(ghid->bundle);
if (ret)
return ret;
request.report_type = report_type;
request.report_id = report_id;
ret = gb_operation_sync(ghid->connection, GB_HID_TYPE_GET_REPORT,
&request, sizeof(request), buf, len);
gb_pm_runtime_put_autosuspend(ghid->bundle);
return ret;
}
static int gb_hid_set_report(struct gb_hid *ghid, u8 report_type, u8 report_id,
unsigned char *buf, int len)
{
struct gb_hid_set_report_request *request;
struct gb_operation *operation;
int ret, size = sizeof(*request) + len - 1;
ret = gb_pm_runtime_get_sync(ghid->bundle);
if (ret)
return ret;
operation = gb_operation_create(ghid->connection,
GB_HID_TYPE_SET_REPORT, size, 0,
GFP_KERNEL);
if (!operation) {
gb_pm_runtime_put_autosuspend(ghid->bundle);
return -ENOMEM;
}
request = operation->request->payload;
request->report_type = report_type;
request->report_id = report_id;
memcpy(request->report, buf, len);
ret = gb_operation_request_send_sync(operation);
if (ret) {
dev_err(&operation->connection->bundle->dev,
"failed to set report: %d\n", ret);
} else {
ret = len;
}
gb_operation_put(operation);
gb_pm_runtime_put_autosuspend(ghid->bundle);
return ret;
}
static int gb_hid_request_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_hid *ghid = gb_connection_get_data(connection);
struct gb_hid_input_report_request *request = op->request->payload;
if (op->type != GB_HID_TYPE_IRQ_EVENT) {
dev_err(&connection->bundle->dev,
"unsupported unsolicited request\n");
return -EINVAL;
}
if (test_bit(GB_HID_STARTED, &ghid->flags))
hid_input_report(ghid->hid, HID_INPUT_REPORT,
request->report, op->request->payload_size, 1);
return 0;
}
static int gb_hid_report_len(struct hid_report *report)
{
return ((report->size - 1) >> 3) + 1 +
report->device->report_enum[report->type].numbered;
}
static void gb_hid_find_max_report(struct hid_device *hid, unsigned int type,
unsigned int *max)
{
struct hid_report *report;
unsigned int size;
list_for_each_entry(report, &hid->report_enum[type].report_list, list) {
size = gb_hid_report_len(report);
if (*max < size)
*max = size;
}
}
static void gb_hid_free_buffers(struct gb_hid *ghid)
{
kfree(ghid->inbuf);
ghid->inbuf = NULL;
ghid->bufsize = 0;
}
static int gb_hid_alloc_buffers(struct gb_hid *ghid, size_t bufsize)
{
ghid->inbuf = kzalloc(bufsize, GFP_KERNEL);
if (!ghid->inbuf)
return -ENOMEM;
ghid->bufsize = bufsize;
return 0;
}
/* Routines dealing with reports */
static void gb_hid_init_report(struct gb_hid *ghid, struct hid_report *report)
{
unsigned int size;
size = gb_hid_report_len(report);
if (gb_hid_get_report(ghid, report->type, report->id, ghid->inbuf,
size))
return;
/*
* hid->driver_lock is held as we are in probe function,
* we just need to setup the input fields, so using
* hid_report_raw_event is safe.
*/
hid_report_raw_event(ghid->hid, report->type, ghid->inbuf, size, 1);
}
static void gb_hid_init_reports(struct gb_hid *ghid)
{
struct hid_device *hid = ghid->hid;
struct hid_report *report;
list_for_each_entry(report,
&hid->report_enum[HID_INPUT_REPORT].report_list,
list)
gb_hid_init_report(ghid, report);
list_for_each_entry(report,
&hid->report_enum[HID_FEATURE_REPORT].report_list,
list)
gb_hid_init_report(ghid, report);
}
static int __gb_hid_get_raw_report(struct hid_device *hid,
unsigned char report_number, __u8 *buf, size_t count,
unsigned char report_type)
{
struct gb_hid *ghid = hid->driver_data;
int ret;
if (report_type == HID_OUTPUT_REPORT)
return -EINVAL;
ret = gb_hid_get_report(ghid, report_type, report_number, buf, count);
if (!ret)
ret = count;
return ret;
}
static int __gb_hid_output_raw_report(struct hid_device *hid, __u8 *buf,
size_t len, unsigned char report_type)
{
struct gb_hid *ghid = hid->driver_data;
int report_id = buf[0];
int ret;
if (report_type == HID_INPUT_REPORT)
return -EINVAL;
if (report_id) {
buf++;
len--;
}
ret = gb_hid_set_report(ghid, report_type, report_id, buf, len);
if (report_id && ret >= 0)
ret++; /* add report_id to the number of transferred bytes */
return 0;
}
static int gb_hid_raw_request(struct hid_device *hid, unsigned char reportnum,
__u8 *buf, size_t len, unsigned char rtype,
int reqtype)
{
switch (reqtype) {
case HID_REQ_GET_REPORT:
return __gb_hid_get_raw_report(hid, reportnum, buf, len, rtype);
case HID_REQ_SET_REPORT:
if (buf[0] != reportnum)
return -EINVAL;
return __gb_hid_output_raw_report(hid, buf, len, rtype);
default:
return -EIO;
}
}
/* HID Callbacks */
static int gb_hid_parse(struct hid_device *hid)
{
struct gb_hid *ghid = hid->driver_data;
unsigned int rsize;
char *rdesc;
int ret;
rsize = le16_to_cpu(ghid->hdesc.wReportDescLength);
if (!rsize || rsize > HID_MAX_DESCRIPTOR_SIZE) {
dbg_hid("weird size of report descriptor (%u)\n", rsize);
return -EINVAL;
}
rdesc = kzalloc(rsize, GFP_KERNEL);
if (!rdesc)
return -ENOMEM;
ret = gb_hid_get_report_desc(ghid, rdesc);
if (ret) {
hid_err(hid, "reading report descriptor failed\n");
goto free_rdesc;
}
ret = hid_parse_report(hid, rdesc, rsize);
if (ret)
dbg_hid("parsing report descriptor failed\n");
free_rdesc:
kfree(rdesc);
return ret;
}
static int gb_hid_start(struct hid_device *hid)
{
struct gb_hid *ghid = hid->driver_data;
unsigned int bufsize = HID_MIN_BUFFER_SIZE;
int ret;
gb_hid_find_max_report(hid, HID_INPUT_REPORT, &bufsize);
gb_hid_find_max_report(hid, HID_OUTPUT_REPORT, &bufsize);
gb_hid_find_max_report(hid, HID_FEATURE_REPORT, &bufsize);
if (bufsize > HID_MAX_BUFFER_SIZE)
bufsize = HID_MAX_BUFFER_SIZE;
ret = gb_hid_alloc_buffers(ghid, bufsize);
if (ret)
return ret;
if (!(hid->quirks & HID_QUIRK_NO_INIT_REPORTS))
gb_hid_init_reports(ghid);
return 0;
}
static void gb_hid_stop(struct hid_device *hid)
{
struct gb_hid *ghid = hid->driver_data;
gb_hid_free_buffers(ghid);
}
static int gb_hid_open(struct hid_device *hid)
{
struct gb_hid *ghid = hid->driver_data;
int ret;
ret = gb_hid_set_power(ghid, GB_HID_TYPE_PWR_ON);
if (ret < 0)
return ret;
set_bit(GB_HID_STARTED, &ghid->flags);
return 0;
}
static void gb_hid_close(struct hid_device *hid)
{
struct gb_hid *ghid = hid->driver_data;
int ret;
clear_bit(GB_HID_STARTED, &ghid->flags);
/* Save some power */
ret = gb_hid_set_power(ghid, GB_HID_TYPE_PWR_OFF);
if (ret)
dev_err(&ghid->connection->bundle->dev,
"failed to power off (%d)\n", ret);
}
static int gb_hid_power(struct hid_device *hid, int lvl)
{
struct gb_hid *ghid = hid->driver_data;
switch (lvl) {
case PM_HINT_FULLON:
return gb_hid_set_power(ghid, GB_HID_TYPE_PWR_ON);
case PM_HINT_NORMAL:
return gb_hid_set_power(ghid, GB_HID_TYPE_PWR_OFF);
}
return 0;
}
/* HID structure to pass callbacks */
static const struct hid_ll_driver gb_hid_ll_driver = {
.parse = gb_hid_parse,
.start = gb_hid_start,
.stop = gb_hid_stop,
.open = gb_hid_open,
.close = gb_hid_close,
.power = gb_hid_power,
.raw_request = gb_hid_raw_request,
};
static int gb_hid_init(struct gb_hid *ghid)
{
struct hid_device *hid = ghid->hid;
int ret;
ret = gb_hid_get_desc(ghid);
if (ret)
return ret;
hid->version = le16_to_cpu(ghid->hdesc.bcdHID);
hid->vendor = le16_to_cpu(ghid->hdesc.wVendorID);
hid->product = le16_to_cpu(ghid->hdesc.wProductID);
hid->country = ghid->hdesc.bCountryCode;
hid->driver_data = ghid;
hid->ll_driver = &gb_hid_ll_driver;
hid->dev.parent = &ghid->connection->bundle->dev;
// hid->bus = BUS_GREYBUS; /* Need a bustype for GREYBUS in <linux/input.h> */
/* Set HID device's name */
snprintf(hid->name, sizeof(hid->name), "%s %04X:%04X",
dev_name(&ghid->connection->bundle->dev),
hid->vendor, hid->product);
return 0;
}
static int gb_hid_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct greybus_descriptor_cport *cport_desc;
struct gb_connection *connection;
struct hid_device *hid;
struct gb_hid *ghid;
int ret;
if (bundle->num_cports != 1)
return -ENODEV;
cport_desc = &bundle->cport_desc[0];
if (cport_desc->protocol_id != GREYBUS_PROTOCOL_HID)
return -ENODEV;
ghid = kzalloc(sizeof(*ghid), GFP_KERNEL);
if (!ghid)
return -ENOMEM;
connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
gb_hid_request_handler);
if (IS_ERR(connection)) {
ret = PTR_ERR(connection);
goto err_free_ghid;
}
gb_connection_set_data(connection, ghid);
ghid->connection = connection;
hid = hid_allocate_device();
if (IS_ERR(hid)) {
ret = PTR_ERR(hid);
goto err_connection_destroy;
}
ghid->hid = hid;
ghid->bundle = bundle;
greybus_set_drvdata(bundle, ghid);
ret = gb_connection_enable(connection);
if (ret)
goto err_destroy_hid;
ret = gb_hid_init(ghid);
if (ret)
goto err_connection_disable;
ret = hid_add_device(hid);
if (ret) {
hid_err(hid, "can't add hid device: %d\n", ret);
goto err_connection_disable;
}
gb_pm_runtime_put_autosuspend(bundle);
return 0;
err_connection_disable:
gb_connection_disable(connection);
err_destroy_hid:
hid_destroy_device(hid);
err_connection_destroy:
gb_connection_destroy(connection);
err_free_ghid:
kfree(ghid);
return ret;
}
static void gb_hid_disconnect(struct gb_bundle *bundle)
{
struct gb_hid *ghid = greybus_get_drvdata(bundle);
if (gb_pm_runtime_get_sync(bundle))
gb_pm_runtime_get_noresume(bundle);
hid_destroy_device(ghid->hid);
gb_connection_disable(ghid->connection);
gb_connection_destroy(ghid->connection);
kfree(ghid);
}
static const struct greybus_bundle_id gb_hid_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_HID) },
{ }
};
MODULE_DEVICE_TABLE(greybus, gb_hid_id_table);
static struct greybus_driver gb_hid_driver = {
.name = "hid",
.probe = gb_hid_probe,
.disconnect = gb_hid_disconnect,
.id_table = gb_hid_id_table,
};
module_greybus_driver(gb_hid_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/hid.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus operations
*
* Copyright 2015-2016 Google Inc.
*/
#include <linux/string.h>
#include <linux/sysfs.h>
#include "audio_manager.h"
#include "audio_manager_private.h"
static ssize_t manager_sysfs_add_store(struct kobject *kobj,
struct kobj_attribute *attr,
const char *buf, size_t count)
{
struct gb_audio_manager_module_descriptor desc = { {0} };
int num = sscanf(buf,
"name=%" GB_AUDIO_MANAGER_MODULE_NAME_LEN_SSCANF
"s vid=%d pid=%d intf_id=%d i/p devices=0x%X o/p devices=0x%X",
desc.name, &desc.vid, &desc.pid, &desc.intf_id,
&desc.ip_devices, &desc.op_devices);
if (num != 7)
return -EINVAL;
num = gb_audio_manager_add(&desc);
if (num < 0)
return -EINVAL;
return count;
}
static struct kobj_attribute manager_add_attribute =
__ATTR(add, 0664, NULL, manager_sysfs_add_store);
static ssize_t manager_sysfs_remove_store(struct kobject *kobj,
struct kobj_attribute *attr,
const char *buf, size_t count)
{
int id;
int num = kstrtoint(buf, 10, &id);
if (num != 1)
return -EINVAL;
num = gb_audio_manager_remove(id);
if (num)
return num;
return count;
}
static struct kobj_attribute manager_remove_attribute =
__ATTR(remove, 0664, NULL, manager_sysfs_remove_store);
static ssize_t manager_sysfs_dump_store(struct kobject *kobj,
struct kobj_attribute *attr,
const char *buf, size_t count)
{
int id;
int num = kstrtoint(buf, 10, &id);
if (num == 1) {
num = gb_audio_manager_dump_module(id);
if (num)
return num;
} else if (!strncmp("all", buf, 3)) {
gb_audio_manager_dump_all();
} else {
return -EINVAL;
}
return count;
}
static struct kobj_attribute manager_dump_attribute =
__ATTR(dump, 0664, NULL, manager_sysfs_dump_store);
static void manager_sysfs_init_attribute(struct kobject *kobj,
struct kobj_attribute *kattr)
{
int err;
err = sysfs_create_file(kobj, &kattr->attr);
if (err) {
pr_warn("creating the sysfs entry for %s failed: %d\n",
kattr->attr.name, err);
}
}
void gb_audio_manager_sysfs_init(struct kobject *kobj)
{
manager_sysfs_init_attribute(kobj, &manager_add_attribute);
manager_sysfs_init_attribute(kobj, &manager_remove_attribute);
manager_sysfs_init_attribute(kobj, &manager_dump_attribute);
}
| linux-master | drivers/staging/greybus/audio_manager_sysfs.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus audio driver
* Copyright 2015-2016 Google Inc.
* Copyright 2015-2016 Linaro Ltd.
*/
#include <linux/greybus.h>
#include "audio_codec.h"
#define GBAUDIO_INVALID_ID 0xFF
/* mixer control */
struct gb_mixer_control {
int min, max;
unsigned int reg, rreg, shift, rshift, invert;
};
struct gbaudio_ctl_pvt {
unsigned int ctl_id;
unsigned int data_cport;
unsigned int access;
unsigned int vcount;
struct gb_audio_ctl_elem_info *info;
};
static struct gbaudio_module_info *find_gb_module(struct gbaudio_codec_info *codec,
char const *name)
{
int dev_id;
char begin[NAME_SIZE];
struct gbaudio_module_info *module;
if (!name)
return NULL;
if (sscanf(name, "%s %d", begin, &dev_id) != 2)
return NULL;
dev_dbg(codec->dev, "%s:Find module#%d\n", __func__, dev_id);
mutex_lock(&codec->lock);
list_for_each_entry(module, &codec->module_list, list) {
if (module->dev_id == dev_id) {
mutex_unlock(&codec->lock);
return module;
}
}
mutex_unlock(&codec->lock);
dev_warn(codec->dev, "%s: module#%d missing in codec list\n", name,
dev_id);
return NULL;
}
static const char *gbaudio_map_controlid(struct gbaudio_module_info *module,
__u8 control_id, __u8 index)
{
struct gbaudio_control *control;
if (control_id == GBAUDIO_INVALID_ID)
return NULL;
list_for_each_entry(control, &module->ctl_list, list) {
if (control->id == control_id) {
if (index == GBAUDIO_INVALID_ID)
return control->name;
if (index >= control->items)
return NULL;
return control->texts[index];
}
}
list_for_each_entry(control, &module->widget_ctl_list, list) {
if (control->id == control_id) {
if (index == GBAUDIO_INVALID_ID)
return control->name;
if (index >= control->items)
return NULL;
return control->texts[index];
}
}
return NULL;
}
static int gbaudio_map_controlname(struct gbaudio_module_info *module,
const char *name)
{
struct gbaudio_control *control;
list_for_each_entry(control, &module->ctl_list, list) {
if (!strncmp(control->name, name, NAME_SIZE))
return control->id;
}
dev_warn(module->dev, "%s: missing in modules controls list\n", name);
return -EINVAL;
}
static int gbaudio_map_wcontrolname(struct gbaudio_module_info *module,
const char *name)
{
struct gbaudio_control *control;
list_for_each_entry(control, &module->widget_ctl_list, list) {
if (!strncmp(control->wname, name, NAME_SIZE))
return control->id;
}
dev_warn(module->dev, "%s: missing in modules controls list\n", name);
return -EINVAL;
}
static int gbaudio_map_widgetname(struct gbaudio_module_info *module,
const char *name)
{
struct gbaudio_widget *widget;
list_for_each_entry(widget, &module->widget_list, list) {
if (!strncmp(widget->name, name, NAME_SIZE))
return widget->id;
}
dev_warn(module->dev, "%s: missing in modules widgets list\n", name);
return -EINVAL;
}
static const char *gbaudio_map_widgetid(struct gbaudio_module_info *module,
__u8 widget_id)
{
struct gbaudio_widget *widget;
list_for_each_entry(widget, &module->widget_list, list) {
if (widget->id == widget_id)
return widget->name;
}
return NULL;
}
static const char **gb_generate_enum_strings(struct gbaudio_module_info *gb,
struct gb_audio_enumerated *gbenum)
{
const char **strings;
int i;
unsigned int items;
__u8 *data;
items = le32_to_cpu(gbenum->items);
strings = devm_kcalloc(gb->dev, items, sizeof(char *), GFP_KERNEL);
if (!strings)
return NULL;
data = gbenum->names;
for (i = 0; i < items; i++) {
strings[i] = (const char *)data;
while (*data != '\0')
data++;
data++;
}
return strings;
}
static int gbcodec_mixer_ctl_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{
unsigned int max;
const char *name;
struct gbaudio_ctl_pvt *data;
struct gb_audio_ctl_elem_info *info;
struct gbaudio_module_info *module;
struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
struct gbaudio_codec_info *gbcodec = snd_soc_component_get_drvdata(comp);
dev_dbg(comp->dev, "Entered %s:%s\n", __func__, kcontrol->id.name);
data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
info = (struct gb_audio_ctl_elem_info *)data->info;
if (!info) {
dev_err(comp->dev, "NULL info for %s\n", uinfo->id.name);
return -EINVAL;
}
/* update uinfo */
uinfo->access = data->access;
uinfo->count = data->vcount;
uinfo->type = (__force snd_ctl_elem_type_t)info->type;
switch (info->type) {
case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
uinfo->value.integer.min = le32_to_cpu(info->value.integer.min);
uinfo->value.integer.max = le32_to_cpu(info->value.integer.max);
break;
case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
max = le32_to_cpu(info->value.enumerated.items);
uinfo->value.enumerated.items = max;
if (uinfo->value.enumerated.item > max - 1)
uinfo->value.enumerated.item = max - 1;
module = find_gb_module(gbcodec, kcontrol->id.name);
if (!module)
return -EINVAL;
name = gbaudio_map_controlid(module, data->ctl_id,
uinfo->value.enumerated.item);
strscpy(uinfo->value.enumerated.name, name, sizeof(uinfo->value.enumerated.name));
break;
default:
dev_err(comp->dev, "Invalid type: %d for %s:kcontrol\n",
info->type, kcontrol->id.name);
break;
}
return 0;
}
static int gbcodec_mixer_ctl_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int ret;
struct gb_audio_ctl_elem_info *info;
struct gbaudio_ctl_pvt *data;
struct gb_audio_ctl_elem_value gbvalue;
struct gbaudio_module_info *module;
struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
struct gbaudio_codec_info *gb = snd_soc_component_get_drvdata(comp);
struct gb_bundle *bundle;
dev_dbg(comp->dev, "Entered %s:%s\n", __func__, kcontrol->id.name);
module = find_gb_module(gb, kcontrol->id.name);
if (!module)
return -EINVAL;
data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
info = (struct gb_audio_ctl_elem_info *)data->info;
bundle = to_gb_bundle(module->dev);
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
ret = gb_audio_gb_get_control(module->mgmt_connection, data->ctl_id,
GB_AUDIO_INVALID_INDEX, &gbvalue);
gb_pm_runtime_put_autosuspend(bundle);
if (ret) {
dev_err_ratelimited(comp->dev, "%d:Error in %s for %s\n", ret,
__func__, kcontrol->id.name);
return ret;
}
/* update ucontrol */
switch (info->type) {
case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
ucontrol->value.integer.value[0] =
le32_to_cpu(gbvalue.value.integer_value[0]);
if (data->vcount == 2)
ucontrol->value.integer.value[1] =
le32_to_cpu(gbvalue.value.integer_value[1]);
break;
case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
ucontrol->value.enumerated.item[0] =
le32_to_cpu(gbvalue.value.enumerated_item[0]);
if (data->vcount == 2)
ucontrol->value.enumerated.item[1] =
le32_to_cpu(gbvalue.value.enumerated_item[1]);
break;
default:
dev_err(comp->dev, "Invalid type: %d for %s:kcontrol\n",
info->type, kcontrol->id.name);
ret = -EINVAL;
break;
}
return ret;
}
static int gbcodec_mixer_ctl_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int ret = 0;
struct gb_audio_ctl_elem_info *info;
struct gbaudio_ctl_pvt *data;
struct gb_audio_ctl_elem_value gbvalue;
struct gbaudio_module_info *module;
struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
struct gbaudio_codec_info *gb = snd_soc_component_get_drvdata(comp);
struct gb_bundle *bundle;
dev_dbg(comp->dev, "Entered %s:%s\n", __func__, kcontrol->id.name);
module = find_gb_module(gb, kcontrol->id.name);
if (!module)
return -EINVAL;
data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
info = (struct gb_audio_ctl_elem_info *)data->info;
bundle = to_gb_bundle(module->dev);
/* update ucontrol */
switch (info->type) {
case GB_AUDIO_CTL_ELEM_TYPE_BOOLEAN:
case GB_AUDIO_CTL_ELEM_TYPE_INTEGER:
gbvalue.value.integer_value[0] =
cpu_to_le32(ucontrol->value.integer.value[0]);
if (data->vcount == 2)
gbvalue.value.integer_value[1] =
cpu_to_le32(ucontrol->value.integer.value[1]);
break;
case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
gbvalue.value.enumerated_item[0] =
cpu_to_le32(ucontrol->value.enumerated.item[0]);
if (data->vcount == 2)
gbvalue.value.enumerated_item[1] =
cpu_to_le32(ucontrol->value.enumerated.item[1]);
break;
default:
dev_err(comp->dev, "Invalid type: %d for %s:kcontrol\n",
info->type, kcontrol->id.name);
ret = -EINVAL;
break;
}
if (ret)
return ret;
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
ret = gb_audio_gb_set_control(module->mgmt_connection, data->ctl_id,
GB_AUDIO_INVALID_INDEX, &gbvalue);
gb_pm_runtime_put_autosuspend(bundle);
if (ret) {
dev_err_ratelimited(comp->dev, "%d:Error in %s for %s\n", ret,
__func__, kcontrol->id.name);
}
return ret;
}
#define SOC_MIXER_GB(xname, kcount, data) \
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
.count = kcount, .info = gbcodec_mixer_ctl_info, \
.get = gbcodec_mixer_ctl_get, .put = gbcodec_mixer_ctl_put, \
.private_value = (unsigned long)data }
/*
* although below callback functions seems redundant to above functions.
* same are kept to allow provision for different handling in case
* of DAPM related sequencing, etc.
*/
static int gbcodec_mixer_dapm_ctl_info(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_info *uinfo)
{
int platform_max, platform_min;
struct gbaudio_ctl_pvt *data;
struct gb_audio_ctl_elem_info *info;
data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
info = (struct gb_audio_ctl_elem_info *)data->info;
/* update uinfo */
platform_max = le32_to_cpu(info->value.integer.max);
platform_min = le32_to_cpu(info->value.integer.min);
if (platform_max == 1 &&
!strnstr(kcontrol->id.name, " Volume", sizeof(kcontrol->id.name)))
uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
else
uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
uinfo->count = data->vcount;
uinfo->value.integer.min = platform_min;
uinfo->value.integer.max = platform_max;
return 0;
}
static int gbcodec_mixer_dapm_ctl_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int ret;
struct gbaudio_ctl_pvt *data;
struct gb_audio_ctl_elem_value gbvalue;
struct gbaudio_module_info *module;
struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
struct snd_soc_dapm_widget *widget = wlist->widgets[0];
struct device *codec_dev = widget->dapm->dev;
struct gbaudio_codec_info *gb = dev_get_drvdata(codec_dev);
struct gb_bundle *bundle;
dev_dbg(codec_dev, "Entered %s:%s\n", __func__, kcontrol->id.name);
module = find_gb_module(gb, kcontrol->id.name);
if (!module)
return -EINVAL;
data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
bundle = to_gb_bundle(module->dev);
if (data->vcount == 2)
dev_warn(widget->dapm->dev,
"GB: Control '%s' is stereo, which is not supported\n",
kcontrol->id.name);
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
ret = gb_audio_gb_get_control(module->mgmt_connection, data->ctl_id,
GB_AUDIO_INVALID_INDEX, &gbvalue);
gb_pm_runtime_put_autosuspend(bundle);
if (ret) {
dev_err_ratelimited(codec_dev, "%d:Error in %s for %s\n", ret,
__func__, kcontrol->id.name);
return ret;
}
/* update ucontrol */
ucontrol->value.integer.value[0] =
le32_to_cpu(gbvalue.value.integer_value[0]);
return ret;
}
static int gbcodec_mixer_dapm_ctl_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int ret, wi, max, connect;
unsigned int mask, val;
struct gb_audio_ctl_elem_info *info;
struct gbaudio_ctl_pvt *data;
struct gb_audio_ctl_elem_value gbvalue;
struct gbaudio_module_info *module;
struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
struct snd_soc_dapm_widget *widget = wlist->widgets[0];
struct device *codec_dev = widget->dapm->dev;
struct gbaudio_codec_info *gb = dev_get_drvdata(codec_dev);
struct gb_bundle *bundle;
dev_dbg(codec_dev, "Entered %s:%s\n", __func__, kcontrol->id.name);
module = find_gb_module(gb, kcontrol->id.name);
if (!module)
return -EINVAL;
data = (struct gbaudio_ctl_pvt *)kcontrol->private_value;
info = (struct gb_audio_ctl_elem_info *)data->info;
bundle = to_gb_bundle(module->dev);
if (data->vcount == 2)
dev_warn(widget->dapm->dev,
"GB: Control '%s' is stereo, which is not supported\n",
kcontrol->id.name);
max = le32_to_cpu(info->value.integer.max);
mask = (1 << fls(max)) - 1;
val = ucontrol->value.integer.value[0] & mask;
connect = !!val;
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
ret = gb_audio_gb_get_control(module->mgmt_connection, data->ctl_id,
GB_AUDIO_INVALID_INDEX, &gbvalue);
if (ret)
goto exit;
/* update ucontrol */
if (le32_to_cpu(gbvalue.value.integer_value[0]) != val) {
for (wi = 0; wi < wlist->num_widgets; wi++) {
widget = wlist->widgets[wi];
snd_soc_dapm_mixer_update_power(widget->dapm, kcontrol,
connect, NULL);
}
gbvalue.value.integer_value[0] =
cpu_to_le32(ucontrol->value.integer.value[0]);
ret = gb_audio_gb_set_control(module->mgmt_connection,
data->ctl_id,
GB_AUDIO_INVALID_INDEX, &gbvalue);
}
exit:
gb_pm_runtime_put_autosuspend(bundle);
if (ret)
dev_err_ratelimited(codec_dev, "%d:Error in %s for %s\n", ret,
__func__, kcontrol->id.name);
return ret;
}
#define SOC_DAPM_MIXER_GB(xname, kcount, data) \
{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
.count = kcount, .info = gbcodec_mixer_dapm_ctl_info, \
.get = gbcodec_mixer_dapm_ctl_get, .put = gbcodec_mixer_dapm_ctl_put, \
.private_value = (unsigned long)data}
static int gbcodec_event_spk(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *k, int event)
{
/* Ensure GB speaker is connected */
return 0;
}
static int gbcodec_event_hp(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *k, int event)
{
/* Ensure GB module supports jack slot */
return 0;
}
static int gbcodec_event_int_mic(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *k, int event)
{
/* Ensure GB module supports jack slot */
return 0;
}
static int gbaudio_validate_kcontrol_count(struct gb_audio_widget *w)
{
int ret = 0;
switch (w->type) {
case snd_soc_dapm_spk:
case snd_soc_dapm_hp:
case snd_soc_dapm_mic:
case snd_soc_dapm_output:
case snd_soc_dapm_input:
if (w->ncontrols)
ret = -EINVAL;
break;
case snd_soc_dapm_switch:
case snd_soc_dapm_mux:
if (w->ncontrols != 1)
ret = -EINVAL;
break;
default:
break;
}
return ret;
}
static int gbcodec_enum_ctl_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int ret, ctl_id;
struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
struct gbaudio_codec_info *gb = snd_soc_component_get_drvdata(comp);
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
struct gb_audio_ctl_elem_value gbvalue;
struct gbaudio_module_info *module;
struct gb_bundle *bundle;
module = find_gb_module(gb, kcontrol->id.name);
if (!module)
return -EINVAL;
ctl_id = gbaudio_map_controlname(module, kcontrol->id.name);
if (ctl_id < 0)
return -EINVAL;
bundle = to_gb_bundle(module->dev);
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
ret = gb_audio_gb_get_control(module->mgmt_connection, ctl_id,
GB_AUDIO_INVALID_INDEX, &gbvalue);
gb_pm_runtime_put_autosuspend(bundle);
if (ret) {
dev_err_ratelimited(comp->dev, "%d:Error in %s for %s\n", ret,
__func__, kcontrol->id.name);
return ret;
}
ucontrol->value.enumerated.item[0] =
le32_to_cpu(gbvalue.value.enumerated_item[0]);
if (e->shift_l != e->shift_r)
ucontrol->value.enumerated.item[1] =
le32_to_cpu(gbvalue.value.enumerated_item[1]);
return 0;
}
static int gbcodec_enum_ctl_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int ret, ctl_id;
struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
struct gbaudio_codec_info *gb = snd_soc_component_get_drvdata(comp);
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
struct gb_audio_ctl_elem_value gbvalue;
struct gbaudio_module_info *module;
struct gb_bundle *bundle;
module = find_gb_module(gb, kcontrol->id.name);
if (!module)
return -EINVAL;
ctl_id = gbaudio_map_controlname(module, kcontrol->id.name);
if (ctl_id < 0)
return -EINVAL;
if (ucontrol->value.enumerated.item[0] > e->items - 1)
return -EINVAL;
gbvalue.value.enumerated_item[0] =
cpu_to_le32(ucontrol->value.enumerated.item[0]);
if (e->shift_l != e->shift_r) {
if (ucontrol->value.enumerated.item[1] > e->items - 1)
return -EINVAL;
gbvalue.value.enumerated_item[1] =
cpu_to_le32(ucontrol->value.enumerated.item[1]);
}
bundle = to_gb_bundle(module->dev);
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
ret = gb_audio_gb_set_control(module->mgmt_connection, ctl_id,
GB_AUDIO_INVALID_INDEX, &gbvalue);
gb_pm_runtime_put_autosuspend(bundle);
if (ret) {
dev_err_ratelimited(comp->dev, "%d:Error in %s for %s\n",
ret, __func__, kcontrol->id.name);
}
return ret;
}
static int gbaudio_tplg_create_enum_kctl(struct gbaudio_module_info *gb,
struct snd_kcontrol_new *kctl,
struct gb_audio_control *ctl)
{
struct soc_enum *gbe;
struct gb_audio_enumerated *gb_enum;
int i;
gbe = devm_kzalloc(gb->dev, sizeof(*gbe), GFP_KERNEL);
if (!gbe)
return -ENOMEM;
gb_enum = &ctl->info.value.enumerated;
/* since count=1, and reg is dummy */
gbe->items = le32_to_cpu(gb_enum->items);
gbe->texts = gb_generate_enum_strings(gb, gb_enum);
if (!gbe->texts)
return -ENOMEM;
/* debug enum info */
dev_dbg(gb->dev, "Max:%d, name_length:%d\n", gbe->items,
le16_to_cpu(gb_enum->names_length));
for (i = 0; i < gbe->items; i++)
dev_dbg(gb->dev, "src[%d]: %s\n", i, gbe->texts[i]);
*kctl = (struct snd_kcontrol_new)
SOC_ENUM_EXT(ctl->name, *gbe, gbcodec_enum_ctl_get,
gbcodec_enum_ctl_put);
return 0;
}
static int gbaudio_tplg_create_kcontrol(struct gbaudio_module_info *gb,
struct snd_kcontrol_new *kctl,
struct gb_audio_control *ctl)
{
int ret = 0;
struct gbaudio_ctl_pvt *ctldata;
switch (ctl->iface) {
case (__force int)SNDRV_CTL_ELEM_IFACE_MIXER:
switch (ctl->info.type) {
case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
ret = gbaudio_tplg_create_enum_kctl(gb, kctl, ctl);
break;
default:
ctldata = devm_kzalloc(gb->dev,
sizeof(struct gbaudio_ctl_pvt),
GFP_KERNEL);
if (!ctldata)
return -ENOMEM;
ctldata->ctl_id = ctl->id;
ctldata->data_cport = le16_to_cpu(ctl->data_cport);
ctldata->access = le32_to_cpu(ctl->access);
ctldata->vcount = ctl->count_values;
ctldata->info = &ctl->info;
*kctl = (struct snd_kcontrol_new)
SOC_MIXER_GB(ctl->name, ctl->count, ctldata);
ctldata = NULL;
break;
}
break;
default:
return -EINVAL;
}
dev_dbg(gb->dev, "%s:%d control created\n", ctl->name, ctl->id);
return ret;
}
static int gbcodec_enum_dapm_ctl_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int ret, ctl_id;
struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
struct snd_soc_dapm_widget *widget = wlist->widgets[0];
struct gbaudio_module_info *module;
struct gb_audio_ctl_elem_value gbvalue;
struct device *codec_dev = widget->dapm->dev;
struct gbaudio_codec_info *gb = dev_get_drvdata(codec_dev);
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
struct gb_bundle *bundle;
module = find_gb_module(gb, kcontrol->id.name);
if (!module)
return -EINVAL;
ctl_id = gbaudio_map_wcontrolname(module, kcontrol->id.name);
if (ctl_id < 0)
return -EINVAL;
bundle = to_gb_bundle(module->dev);
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
ret = gb_audio_gb_get_control(module->mgmt_connection, ctl_id,
GB_AUDIO_INVALID_INDEX, &gbvalue);
gb_pm_runtime_put_autosuspend(bundle);
if (ret) {
dev_err_ratelimited(codec_dev, "%d:Error in %s for %s\n", ret,
__func__, kcontrol->id.name);
return ret;
}
ucontrol->value.enumerated.item[0] = le32_to_cpu(gbvalue.value.enumerated_item[0]);
if (e->shift_l != e->shift_r)
ucontrol->value.enumerated.item[1] =
le32_to_cpu(gbvalue.value.enumerated_item[1]);
return 0;
}
static int gbcodec_enum_dapm_ctl_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int ret, wi, ctl_id;
unsigned int val, mux, change;
unsigned int mask;
struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);
struct snd_soc_dapm_widget *widget = wlist->widgets[0];
struct gb_audio_ctl_elem_value gbvalue;
struct gbaudio_module_info *module;
struct device *codec_dev = widget->dapm->dev;
struct gbaudio_codec_info *gb = dev_get_drvdata(codec_dev);
struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
struct gb_bundle *bundle;
if (ucontrol->value.enumerated.item[0] > e->items - 1)
return -EINVAL;
module = find_gb_module(gb, kcontrol->id.name);
if (!module)
return -EINVAL;
ctl_id = gbaudio_map_wcontrolname(module, kcontrol->id.name);
if (ctl_id < 0)
return -EINVAL;
change = 0;
bundle = to_gb_bundle(module->dev);
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
ret = gb_audio_gb_get_control(module->mgmt_connection, ctl_id,
GB_AUDIO_INVALID_INDEX, &gbvalue);
gb_pm_runtime_put_autosuspend(bundle);
if (ret) {
dev_err_ratelimited(codec_dev, "%d:Error in %s for %s\n", ret,
__func__, kcontrol->id.name);
return ret;
}
mux = ucontrol->value.enumerated.item[0];
val = mux << e->shift_l;
mask = e->mask << e->shift_l;
if (le32_to_cpu(gbvalue.value.enumerated_item[0]) !=
ucontrol->value.enumerated.item[0]) {
change = 1;
gbvalue.value.enumerated_item[0] =
cpu_to_le32(ucontrol->value.enumerated.item[0]);
}
if (e->shift_l != e->shift_r) {
if (ucontrol->value.enumerated.item[1] > e->items - 1)
return -EINVAL;
val |= ucontrol->value.enumerated.item[1] << e->shift_r;
mask |= e->mask << e->shift_r;
if (le32_to_cpu(gbvalue.value.enumerated_item[1]) !=
ucontrol->value.enumerated.item[1]) {
change = 1;
gbvalue.value.enumerated_item[1] =
cpu_to_le32(ucontrol->value.enumerated.item[1]);
}
}
if (change) {
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
ret = gb_audio_gb_set_control(module->mgmt_connection, ctl_id,
GB_AUDIO_INVALID_INDEX, &gbvalue);
gb_pm_runtime_put_autosuspend(bundle);
if (ret) {
dev_err_ratelimited(codec_dev,
"%d:Error in %s for %s\n", ret,
__func__, kcontrol->id.name);
}
for (wi = 0; wi < wlist->num_widgets; wi++) {
widget = wlist->widgets[wi];
snd_soc_dapm_mux_update_power(widget->dapm, kcontrol,
val, e, NULL);
}
}
return change;
}
static int gbaudio_tplg_create_enum_ctl(struct gbaudio_module_info *gb,
struct snd_kcontrol_new *kctl,
struct gb_audio_control *ctl)
{
struct soc_enum *gbe;
struct gb_audio_enumerated *gb_enum;
int i;
gbe = devm_kzalloc(gb->dev, sizeof(*gbe), GFP_KERNEL);
if (!gbe)
return -ENOMEM;
gb_enum = &ctl->info.value.enumerated;
/* since count=1, and reg is dummy */
gbe->items = le32_to_cpu(gb_enum->items);
gbe->texts = gb_generate_enum_strings(gb, gb_enum);
if (!gbe->texts)
return -ENOMEM;
/* debug enum info */
dev_dbg(gb->dev, "Max:%d, name_length:%d\n", gbe->items,
le16_to_cpu(gb_enum->names_length));
for (i = 0; i < gbe->items; i++)
dev_dbg(gb->dev, "src[%d]: %s\n", i, gbe->texts[i]);
*kctl = (struct snd_kcontrol_new)
SOC_DAPM_ENUM_EXT(ctl->name, *gbe, gbcodec_enum_dapm_ctl_get,
gbcodec_enum_dapm_ctl_put);
return 0;
}
static int gbaudio_tplg_create_mixer_ctl(struct gbaudio_module_info *gb,
struct snd_kcontrol_new *kctl,
struct gb_audio_control *ctl)
{
struct gbaudio_ctl_pvt *ctldata;
ctldata = devm_kzalloc(gb->dev, sizeof(struct gbaudio_ctl_pvt),
GFP_KERNEL);
if (!ctldata)
return -ENOMEM;
ctldata->ctl_id = ctl->id;
ctldata->data_cport = le16_to_cpu(ctl->data_cport);
ctldata->access = le32_to_cpu(ctl->access);
ctldata->vcount = ctl->count_values;
ctldata->info = &ctl->info;
*kctl = (struct snd_kcontrol_new)
SOC_DAPM_MIXER_GB(ctl->name, ctl->count, ctldata);
return 0;
}
static int gbaudio_tplg_create_wcontrol(struct gbaudio_module_info *gb,
struct snd_kcontrol_new *kctl,
struct gb_audio_control *ctl)
{
int ret;
switch (ctl->iface) {
case (__force int)SNDRV_CTL_ELEM_IFACE_MIXER:
switch (ctl->info.type) {
case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:
ret = gbaudio_tplg_create_enum_ctl(gb, kctl, ctl);
break;
default:
ret = gbaudio_tplg_create_mixer_ctl(gb, kctl, ctl);
break;
}
break;
default:
return -EINVAL;
}
dev_dbg(gb->dev, "%s:%d DAPM control created, ret:%d\n", ctl->name,
ctl->id, ret);
return ret;
}
static int gbaudio_widget_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
int wid;
int ret;
struct device *codec_dev = w->dapm->dev;
struct gbaudio_codec_info *gbcodec = dev_get_drvdata(codec_dev);
struct gbaudio_module_info *module;
struct gb_bundle *bundle;
dev_dbg(codec_dev, "%s %s %d\n", __func__, w->name, event);
/* Find relevant module */
module = find_gb_module(gbcodec, w->name);
if (!module)
return -EINVAL;
/* map name to widget id */
wid = gbaudio_map_widgetname(module, w->name);
if (wid < 0) {
dev_err(codec_dev, "Invalid widget name:%s\n", w->name);
return -EINVAL;
}
bundle = to_gb_bundle(module->dev);
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
ret = gb_audio_gb_enable_widget(module->mgmt_connection, wid);
if (!ret)
ret = gbaudio_module_update(gbcodec, w, module, 1);
break;
case SND_SOC_DAPM_POST_PMD:
ret = gb_audio_gb_disable_widget(module->mgmt_connection, wid);
if (!ret)
ret = gbaudio_module_update(gbcodec, w, module, 0);
break;
}
if (ret)
dev_err_ratelimited(codec_dev,
"%d: widget, event:%d failed:%d\n", wid,
event, ret);
gb_pm_runtime_put_autosuspend(bundle);
return ret;
}
static const struct snd_soc_dapm_widget gbaudio_widgets[] = {
[snd_soc_dapm_spk] = SND_SOC_DAPM_SPK(NULL, gbcodec_event_spk),
[snd_soc_dapm_hp] = SND_SOC_DAPM_HP(NULL, gbcodec_event_hp),
[snd_soc_dapm_mic] = SND_SOC_DAPM_MIC(NULL, gbcodec_event_int_mic),
[snd_soc_dapm_output] = SND_SOC_DAPM_OUTPUT(NULL),
[snd_soc_dapm_input] = SND_SOC_DAPM_INPUT(NULL),
[snd_soc_dapm_switch] = SND_SOC_DAPM_SWITCH_E(NULL, SND_SOC_NOPM,
0, 0, NULL,
gbaudio_widget_event,
SND_SOC_DAPM_PRE_PMU |
SND_SOC_DAPM_POST_PMD),
[snd_soc_dapm_pga] = SND_SOC_DAPM_PGA_E(NULL, SND_SOC_NOPM,
0, 0, NULL, 0,
gbaudio_widget_event,
SND_SOC_DAPM_PRE_PMU |
SND_SOC_DAPM_POST_PMD),
[snd_soc_dapm_mixer] = SND_SOC_DAPM_MIXER_E(NULL, SND_SOC_NOPM,
0, 0, NULL, 0,
gbaudio_widget_event,
SND_SOC_DAPM_PRE_PMU |
SND_SOC_DAPM_POST_PMD),
[snd_soc_dapm_mux] = SND_SOC_DAPM_MUX_E(NULL, SND_SOC_NOPM,
0, 0, NULL,
gbaudio_widget_event,
SND_SOC_DAPM_PRE_PMU |
SND_SOC_DAPM_POST_PMD),
[snd_soc_dapm_aif_in] = SND_SOC_DAPM_AIF_IN_E(NULL, NULL, 0,
SND_SOC_NOPM, 0, 0,
gbaudio_widget_event,
SND_SOC_DAPM_PRE_PMU |
SND_SOC_DAPM_POST_PMD),
[snd_soc_dapm_aif_out] = SND_SOC_DAPM_AIF_OUT_E(NULL, NULL, 0,
SND_SOC_NOPM, 0, 0,
gbaudio_widget_event,
SND_SOC_DAPM_PRE_PMU |
SND_SOC_DAPM_POST_PMD),
};
static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module,
struct snd_soc_dapm_widget *dw,
struct gb_audio_widget *w, int *w_size)
{
int i, ret, csize;
struct snd_kcontrol_new *widget_kctls;
struct gb_audio_control *curr;
struct gbaudio_control *control, *_control;
size_t size;
char temp_name[NAME_SIZE];
ret = gbaudio_validate_kcontrol_count(w);
if (ret) {
dev_err(module->dev, "Invalid kcontrol count=%d for %s\n",
w->ncontrols, w->name);
return ret;
}
/* allocate memory for kcontrol */
if (w->ncontrols) {
size = sizeof(struct snd_kcontrol_new) * w->ncontrols;
widget_kctls = devm_kzalloc(module->dev, size, GFP_KERNEL);
if (!widget_kctls)
return -ENOMEM;
}
*w_size = sizeof(struct gb_audio_widget);
/* create relevant kcontrols */
curr = w->ctl;
for (i = 0; i < w->ncontrols; i++) {
ret = gbaudio_tplg_create_wcontrol(module, &widget_kctls[i],
curr);
if (ret) {
dev_err(module->dev,
"%s:%d type widget_ctl not supported\n",
curr->name, curr->iface);
goto error;
}
control = devm_kzalloc(module->dev,
sizeof(struct gbaudio_control),
GFP_KERNEL);
if (!control) {
ret = -ENOMEM;
goto error;
}
control->id = curr->id;
control->name = curr->name;
control->wname = w->name;
if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED) {
struct gb_audio_enumerated *gbenum =
&curr->info.value.enumerated;
csize = offsetof(struct gb_audio_control, info);
csize += offsetof(struct gb_audio_ctl_elem_info, value);
csize += offsetof(struct gb_audio_enumerated, names);
csize += le16_to_cpu(gbenum->names_length);
control->texts = (const char * const *)
gb_generate_enum_strings(module, gbenum);
if (!control->texts) {
ret = -ENOMEM;
goto error;
}
control->items = le32_to_cpu(gbenum->items);
} else {
csize = sizeof(struct gb_audio_control);
}
*w_size += csize;
curr = (void *)curr + csize;
list_add(&control->list, &module->widget_ctl_list);
dev_dbg(module->dev, "%s: control of type %d created\n",
widget_kctls[i].name, widget_kctls[i].iface);
}
/* Prefix dev_id to widget control_name */
strscpy(temp_name, w->name, sizeof(temp_name));
snprintf(w->name, sizeof(w->name), "GB %d %s", module->dev_id, temp_name);
switch (w->type) {
case snd_soc_dapm_spk:
*dw = gbaudio_widgets[w->type];
module->op_devices |= GBAUDIO_DEVICE_OUT_SPEAKER;
break;
case snd_soc_dapm_hp:
*dw = gbaudio_widgets[w->type];
module->op_devices |= (GBAUDIO_DEVICE_OUT_WIRED_HEADSET
| GBAUDIO_DEVICE_OUT_WIRED_HEADPHONE);
module->ip_devices |= GBAUDIO_DEVICE_IN_WIRED_HEADSET;
break;
case snd_soc_dapm_mic:
*dw = gbaudio_widgets[w->type];
module->ip_devices |= GBAUDIO_DEVICE_IN_BUILTIN_MIC;
break;
case snd_soc_dapm_output:
case snd_soc_dapm_input:
case snd_soc_dapm_switch:
case snd_soc_dapm_pga:
case snd_soc_dapm_mixer:
case snd_soc_dapm_mux:
*dw = gbaudio_widgets[w->type];
break;
case snd_soc_dapm_aif_in:
case snd_soc_dapm_aif_out:
*dw = gbaudio_widgets[w->type];
dw->sname = w->sname;
break;
default:
ret = -EINVAL;
goto error;
}
dw->name = w->name;
dev_dbg(module->dev, "%s: widget of type %d created\n", dw->name,
dw->id);
return 0;
error:
list_for_each_entry_safe(control, _control, &module->widget_ctl_list,
list) {
list_del(&control->list);
devm_kfree(module->dev, control);
}
return ret;
}
static int gbaudio_tplg_process_kcontrols(struct gbaudio_module_info *module,
struct gb_audio_control *controls)
{
int i, csize, ret;
struct snd_kcontrol_new *dapm_kctls;
struct gb_audio_control *curr;
struct gbaudio_control *control, *_control;
size_t size;
char temp_name[NAME_SIZE];
size = sizeof(struct snd_kcontrol_new) * module->num_controls;
dapm_kctls = devm_kzalloc(module->dev, size, GFP_KERNEL);
if (!dapm_kctls)
return -ENOMEM;
curr = controls;
for (i = 0; i < module->num_controls; i++) {
ret = gbaudio_tplg_create_kcontrol(module, &dapm_kctls[i],
curr);
if (ret) {
dev_err(module->dev, "%s:%d type not supported\n",
curr->name, curr->iface);
goto error;
}
control = devm_kzalloc(module->dev, sizeof(struct
gbaudio_control),
GFP_KERNEL);
if (!control) {
ret = -ENOMEM;
goto error;
}
control->id = curr->id;
/* Prefix dev_id to widget_name */
strscpy(temp_name, curr->name, sizeof(temp_name));
snprintf(curr->name, sizeof(curr->name), "GB %d %s", module->dev_id,
temp_name);
control->name = curr->name;
if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED) {
struct gb_audio_enumerated *gbenum =
&curr->info.value.enumerated;
csize = offsetof(struct gb_audio_control, info);
csize += offsetof(struct gb_audio_ctl_elem_info, value);
csize += offsetof(struct gb_audio_enumerated, names);
csize += le16_to_cpu(gbenum->names_length);
control->texts = (const char * const *)
gb_generate_enum_strings(module, gbenum);
if (!control->texts) {
ret = -ENOMEM;
goto error;
}
control->items = le32_to_cpu(gbenum->items);
} else {
csize = sizeof(struct gb_audio_control);
}
list_add(&control->list, &module->ctl_list);
dev_dbg(module->dev, "%d:%s created of type %d\n", curr->id,
curr->name, curr->info.type);
curr = (void *)curr + csize;
}
module->controls = dapm_kctls;
return 0;
error:
list_for_each_entry_safe(control, _control, &module->ctl_list,
list) {
list_del(&control->list);
devm_kfree(module->dev, control);
}
devm_kfree(module->dev, dapm_kctls);
return ret;
}
static int gbaudio_tplg_process_widgets(struct gbaudio_module_info *module,
struct gb_audio_widget *widgets)
{
int i, ret, w_size;
struct snd_soc_dapm_widget *dapm_widgets;
struct gb_audio_widget *curr;
struct gbaudio_widget *widget, *_widget;
size_t size;
size = sizeof(struct snd_soc_dapm_widget) * module->num_dapm_widgets;
dapm_widgets = devm_kzalloc(module->dev, size, GFP_KERNEL);
if (!dapm_widgets)
return -ENOMEM;
curr = widgets;
for (i = 0; i < module->num_dapm_widgets; i++) {
ret = gbaudio_tplg_create_widget(module, &dapm_widgets[i],
curr, &w_size);
if (ret) {
dev_err(module->dev, "%s:%d type not supported\n",
curr->name, curr->type);
goto error;
}
widget = devm_kzalloc(module->dev, sizeof(struct
gbaudio_widget),
GFP_KERNEL);
if (!widget) {
ret = -ENOMEM;
goto error;
}
widget->id = curr->id;
widget->name = curr->name;
list_add(&widget->list, &module->widget_list);
curr = (void *)curr + w_size;
}
module->dapm_widgets = dapm_widgets;
return 0;
error:
list_for_each_entry_safe(widget, _widget, &module->widget_list,
list) {
list_del(&widget->list);
devm_kfree(module->dev, widget);
}
devm_kfree(module->dev, dapm_widgets);
return ret;
}
static int gbaudio_tplg_process_routes(struct gbaudio_module_info *module,
struct gb_audio_route *routes)
{
int i, ret;
struct snd_soc_dapm_route *dapm_routes;
struct gb_audio_route *curr;
size_t size;
size = sizeof(struct snd_soc_dapm_route) * module->num_dapm_routes;
dapm_routes = devm_kzalloc(module->dev, size, GFP_KERNEL);
if (!dapm_routes)
return -ENOMEM;
module->dapm_routes = dapm_routes;
curr = routes;
for (i = 0; i < module->num_dapm_routes; i++) {
dapm_routes->sink =
gbaudio_map_widgetid(module, curr->destination_id);
if (!dapm_routes->sink) {
dev_err(module->dev, "%d:%d:%d:%d - Invalid sink\n",
curr->source_id, curr->destination_id,
curr->control_id, curr->index);
ret = -EINVAL;
goto error;
}
dapm_routes->source =
gbaudio_map_widgetid(module, curr->source_id);
if (!dapm_routes->source) {
dev_err(module->dev, "%d:%d:%d:%d - Invalid source\n",
curr->source_id, curr->destination_id,
curr->control_id, curr->index);
ret = -EINVAL;
goto error;
}
dapm_routes->control =
gbaudio_map_controlid(module,
curr->control_id,
curr->index);
if ((curr->control_id != GBAUDIO_INVALID_ID) &&
!dapm_routes->control) {
dev_err(module->dev, "%d:%d:%d:%d - Invalid control\n",
curr->source_id, curr->destination_id,
curr->control_id, curr->index);
ret = -EINVAL;
goto error;
}
dev_dbg(module->dev, "Route {%s, %s, %s}\n", dapm_routes->sink,
(dapm_routes->control) ? dapm_routes->control : "NULL",
dapm_routes->source);
dapm_routes++;
curr++;
}
return 0;
error:
devm_kfree(module->dev, module->dapm_routes);
return ret;
}
static int gbaudio_tplg_process_header(struct gbaudio_module_info *module,
struct gb_audio_topology *tplg_data)
{
/* fetch no. of kcontrols, widgets & routes */
module->num_controls = tplg_data->num_controls;
module->num_dapm_widgets = tplg_data->num_widgets;
module->num_dapm_routes = tplg_data->num_routes;
/* update block offset */
module->dai_offset = (unsigned long)&tplg_data->data;
module->control_offset = module->dai_offset +
le32_to_cpu(tplg_data->size_dais);
module->widget_offset = module->control_offset +
le32_to_cpu(tplg_data->size_controls);
module->route_offset = module->widget_offset +
le32_to_cpu(tplg_data->size_widgets);
dev_dbg(module->dev, "DAI offset is 0x%lx\n", module->dai_offset);
dev_dbg(module->dev, "control offset is %lx\n",
module->control_offset);
dev_dbg(module->dev, "widget offset is %lx\n", module->widget_offset);
dev_dbg(module->dev, "route offset is %lx\n", module->route_offset);
return 0;
}
int gbaudio_tplg_parse_data(struct gbaudio_module_info *module,
struct gb_audio_topology *tplg_data)
{
int ret;
struct gb_audio_control *controls;
struct gb_audio_widget *widgets;
struct gb_audio_route *routes;
unsigned int jack_type;
if (!tplg_data)
return -EINVAL;
ret = gbaudio_tplg_process_header(module, tplg_data);
if (ret) {
dev_err(module->dev, "%d: Error in parsing topology header\n",
ret);
return ret;
}
/* process control */
controls = (struct gb_audio_control *)module->control_offset;
ret = gbaudio_tplg_process_kcontrols(module, controls);
if (ret) {
dev_err(module->dev,
"%d: Error in parsing controls data\n", ret);
return ret;
}
dev_dbg(module->dev, "Control parsing finished\n");
/* process widgets */
widgets = (struct gb_audio_widget *)module->widget_offset;
ret = gbaudio_tplg_process_widgets(module, widgets);
if (ret) {
dev_err(module->dev,
"%d: Error in parsing widgets data\n", ret);
return ret;
}
dev_dbg(module->dev, "Widget parsing finished\n");
/* process route */
routes = (struct gb_audio_route *)module->route_offset;
ret = gbaudio_tplg_process_routes(module, routes);
if (ret) {
dev_err(module->dev,
"%d: Error in parsing routes data\n", ret);
return ret;
}
dev_dbg(module->dev, "Route parsing finished\n");
/* parse jack capabilities */
jack_type = le32_to_cpu(tplg_data->jack_type);
if (jack_type) {
module->jack_mask = jack_type & GBCODEC_JACK_MASK;
module->button_mask = jack_type & GBCODEC_JACK_BUTTON_MASK;
}
return ret;
}
void gbaudio_tplg_release(struct gbaudio_module_info *module)
{
struct gbaudio_control *control, *_control;
struct gbaudio_widget *widget, *_widget;
if (!module->topology)
return;
/* release kcontrols */
list_for_each_entry_safe(control, _control, &module->ctl_list,
list) {
list_del(&control->list);
devm_kfree(module->dev, control);
}
if (module->controls)
devm_kfree(module->dev, module->controls);
/* release widget controls */
list_for_each_entry_safe(control, _control, &module->widget_ctl_list,
list) {
list_del(&control->list);
devm_kfree(module->dev, control);
}
/* release widgets */
list_for_each_entry_safe(widget, _widget, &module->widget_list,
list) {
list_del(&widget->list);
devm_kfree(module->dev, widget);
}
if (module->dapm_widgets)
devm_kfree(module->dev, module->dapm_widgets);
/* release routes */
if (module->dapm_routes)
devm_kfree(module->dev, module->dapm_routes);
}
| linux-master | drivers/staging/greybus/audio_topology.c |
// SPDX-License-Identifier: GPL-2.0
/*
* PWM Greybus driver.
*
* Copyright 2014 Google Inc.
* Copyright 2014 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/pwm.h>
#include <linux/greybus.h>
#include "gbphy.h"
struct gb_pwm_chip {
struct gb_connection *connection;
u8 pwm_max; /* max pwm number */
struct pwm_chip chip;
};
static inline struct gb_pwm_chip *pwm_chip_to_gb_pwm_chip(struct pwm_chip *chip)
{
return container_of(chip, struct gb_pwm_chip, chip);
}
static int gb_pwm_count_operation(struct gb_pwm_chip *pwmc)
{
struct gb_pwm_count_response response;
int ret;
ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_PWM_COUNT,
NULL, 0, &response, sizeof(response));
if (ret)
return ret;
pwmc->pwm_max = response.count;
return 0;
}
static int gb_pwm_activate_operation(struct gb_pwm_chip *pwmc,
u8 which)
{
struct gb_pwm_activate_request request;
struct gbphy_device *gbphy_dev;
int ret;
if (which > pwmc->pwm_max)
return -EINVAL;
request.which = which;
gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
return ret;
ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_ACTIVATE,
&request, sizeof(request), NULL, 0);
gbphy_runtime_put_autosuspend(gbphy_dev);
return ret;
}
static int gb_pwm_deactivate_operation(struct gb_pwm_chip *pwmc,
u8 which)
{
struct gb_pwm_deactivate_request request;
struct gbphy_device *gbphy_dev;
int ret;
if (which > pwmc->pwm_max)
return -EINVAL;
request.which = which;
gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
return ret;
ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_DEACTIVATE,
&request, sizeof(request), NULL, 0);
gbphy_runtime_put_autosuspend(gbphy_dev);
return ret;
}
static int gb_pwm_config_operation(struct gb_pwm_chip *pwmc,
u8 which, u32 duty, u32 period)
{
struct gb_pwm_config_request request;
struct gbphy_device *gbphy_dev;
int ret;
if (which > pwmc->pwm_max)
return -EINVAL;
request.which = which;
request.duty = cpu_to_le32(duty);
request.period = cpu_to_le32(period);
gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
return ret;
ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_CONFIG,
&request, sizeof(request), NULL, 0);
gbphy_runtime_put_autosuspend(gbphy_dev);
return ret;
}
static int gb_pwm_set_polarity_operation(struct gb_pwm_chip *pwmc,
u8 which, u8 polarity)
{
struct gb_pwm_polarity_request request;
struct gbphy_device *gbphy_dev;
int ret;
if (which > pwmc->pwm_max)
return -EINVAL;
request.which = which;
request.polarity = polarity;
gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
return ret;
ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_POLARITY,
&request, sizeof(request), NULL, 0);
gbphy_runtime_put_autosuspend(gbphy_dev);
return ret;
}
static int gb_pwm_enable_operation(struct gb_pwm_chip *pwmc,
u8 which)
{
struct gb_pwm_enable_request request;
struct gbphy_device *gbphy_dev;
int ret;
if (which > pwmc->pwm_max)
return -EINVAL;
request.which = which;
gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
return ret;
ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_ENABLE,
&request, sizeof(request), NULL, 0);
if (ret)
gbphy_runtime_put_autosuspend(gbphy_dev);
return ret;
}
static int gb_pwm_disable_operation(struct gb_pwm_chip *pwmc,
u8 which)
{
struct gb_pwm_disable_request request;
struct gbphy_device *gbphy_dev;
int ret;
if (which > pwmc->pwm_max)
return -EINVAL;
request.which = which;
ret = gb_operation_sync(pwmc->connection, GB_PWM_TYPE_DISABLE,
&request, sizeof(request), NULL, 0);
gbphy_dev = to_gbphy_dev(pwmc->chip.dev);
gbphy_runtime_put_autosuspend(gbphy_dev);
return ret;
}
static int gb_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
{
struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
return gb_pwm_activate_operation(pwmc, pwm->hwpwm);
};
static void gb_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
{
struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
if (pwm_is_enabled(pwm))
dev_warn(chip->dev, "freeing PWM device without disabling\n");
gb_pwm_deactivate_operation(pwmc, pwm->hwpwm);
}
static int gb_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
const struct pwm_state *state)
{
int err;
bool enabled = pwm->state.enabled;
u64 period = state->period;
u64 duty_cycle = state->duty_cycle;
struct gb_pwm_chip *pwmc = pwm_chip_to_gb_pwm_chip(chip);
/* Set polarity */
if (state->polarity != pwm->state.polarity) {
if (enabled) {
gb_pwm_disable_operation(pwmc, pwm->hwpwm);
enabled = false;
}
err = gb_pwm_set_polarity_operation(pwmc, pwm->hwpwm, state->polarity);
if (err)
return err;
}
if (!state->enabled) {
if (enabled)
gb_pwm_disable_operation(pwmc, pwm->hwpwm);
return 0;
}
/*
* Set period and duty cycle
*
* PWM privodes 64-bit period and duty_cycle, but greybus only accepts
* 32-bit, so their values have to be limited to U32_MAX.
*/
if (period > U32_MAX)
period = U32_MAX;
if (duty_cycle > period)
duty_cycle = period;
err = gb_pwm_config_operation(pwmc, pwm->hwpwm, duty_cycle, period);
if (err)
return err;
/* enable/disable */
if (!enabled)
return gb_pwm_enable_operation(pwmc, pwm->hwpwm);
return 0;
}
static const struct pwm_ops gb_pwm_ops = {
.request = gb_pwm_request,
.free = gb_pwm_free,
.apply = gb_pwm_apply,
.owner = THIS_MODULE,
};
static int gb_pwm_probe(struct gbphy_device *gbphy_dev,
const struct gbphy_device_id *id)
{
struct gb_connection *connection;
struct gb_pwm_chip *pwmc;
struct pwm_chip *chip;
int ret;
pwmc = kzalloc(sizeof(*pwmc), GFP_KERNEL);
if (!pwmc)
return -ENOMEM;
connection = gb_connection_create(gbphy_dev->bundle,
le16_to_cpu(gbphy_dev->cport_desc->id),
NULL);
if (IS_ERR(connection)) {
ret = PTR_ERR(connection);
goto exit_pwmc_free;
}
pwmc->connection = connection;
gb_connection_set_data(connection, pwmc);
gb_gbphy_set_data(gbphy_dev, pwmc);
ret = gb_connection_enable(connection);
if (ret)
goto exit_connection_destroy;
/* Query number of pwms present */
ret = gb_pwm_count_operation(pwmc);
if (ret)
goto exit_connection_disable;
chip = &pwmc->chip;
chip->dev = &gbphy_dev->dev;
chip->ops = &gb_pwm_ops;
chip->npwm = pwmc->pwm_max + 1;
ret = pwmchip_add(chip);
if (ret) {
dev_err(&gbphy_dev->dev,
"failed to register PWM: %d\n", ret);
goto exit_connection_disable;
}
gbphy_runtime_put_autosuspend(gbphy_dev);
return 0;
exit_connection_disable:
gb_connection_disable(connection);
exit_connection_destroy:
gb_connection_destroy(connection);
exit_pwmc_free:
kfree(pwmc);
return ret;
}
static void gb_pwm_remove(struct gbphy_device *gbphy_dev)
{
struct gb_pwm_chip *pwmc = gb_gbphy_get_data(gbphy_dev);
struct gb_connection *connection = pwmc->connection;
int ret;
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
gbphy_runtime_get_noresume(gbphy_dev);
pwmchip_remove(&pwmc->chip);
gb_connection_disable(connection);
gb_connection_destroy(connection);
kfree(pwmc);
}
static const struct gbphy_device_id gb_pwm_id_table[] = {
{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_PWM) },
{ },
};
MODULE_DEVICE_TABLE(gbphy, gb_pwm_id_table);
static struct gbphy_driver pwm_driver = {
.name = "pwm",
.probe = gb_pwm_probe,
.remove = gb_pwm_remove,
.id_table = gb_pwm_id_table,
};
module_gbphy_driver(pwm_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/pwm.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Camera protocol driver.
*
* Copyright 2015 Google Inc.
* Copyright 2015 Linaro Ltd.
*/
#include <linux/debugfs.h>
#include <linux/fs.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/uaccess.h>
#include <linux/vmalloc.h>
#include <linux/greybus.h>
#include "gb-camera.h"
#include "greybus_protocols.h"
enum gb_camera_debugs_buffer_id {
GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
GB_CAMERA_DEBUGFS_BUFFER_MAX,
};
struct gb_camera_debugfs_buffer {
char data[PAGE_SIZE];
size_t length;
};
enum gb_camera_state {
GB_CAMERA_STATE_UNCONFIGURED,
GB_CAMERA_STATE_CONFIGURED,
};
/**
* struct gb_camera - A Greybus Camera Device
* @connection: the greybus connection for camera management
* @data_connection: the greybus connection for camera data
* @data_cport_id: the data CPort ID on the module side
* @mutex: protects the connection and state fields
* @state: the current module state
* @debugfs: debugfs entries for camera protocol operations testing
* @module: Greybus camera module registered to HOST processor.
*/
struct gb_camera {
struct gb_bundle *bundle;
struct gb_connection *connection;
struct gb_connection *data_connection;
u16 data_cport_id;
struct mutex mutex;
enum gb_camera_state state;
struct {
struct dentry *root;
struct gb_camera_debugfs_buffer *buffers;
} debugfs;
struct gb_camera_module module;
};
struct gb_camera_stream_config {
unsigned int width;
unsigned int height;
unsigned int format;
unsigned int vc;
unsigned int dt[2];
unsigned int max_size;
};
struct gb_camera_fmt_info {
enum v4l2_mbus_pixelcode mbus_code;
unsigned int gb_format;
unsigned int bpp;
};
/* GB format to media code map */
static const struct gb_camera_fmt_info gb_fmt_info[] = {
{
.mbus_code = V4L2_MBUS_FMT_UYVY8_1X16,
.gb_format = 0x01,
.bpp = 16,
},
{
.mbus_code = V4L2_MBUS_FMT_NV12_1x8,
.gb_format = 0x12,
.bpp = 12,
},
{
.mbus_code = V4L2_MBUS_FMT_NV21_1x8,
.gb_format = 0x13,
.bpp = 12,
},
{
.mbus_code = V4L2_MBUS_FMT_YU12_1x8,
.gb_format = 0x16,
.bpp = 12,
},
{
.mbus_code = V4L2_MBUS_FMT_YV12_1x8,
.gb_format = 0x17,
.bpp = 12,
},
{
.mbus_code = V4L2_MBUS_FMT_JPEG_1X8,
.gb_format = 0x40,
.bpp = 0,
},
{
.mbus_code = V4L2_MBUS_FMT_GB_CAM_METADATA_1X8,
.gb_format = 0x41,
.bpp = 0,
},
{
.mbus_code = V4L2_MBUS_FMT_GB_CAM_DEBUG_DATA_1X8,
.gb_format = 0x42,
.bpp = 0,
},
{
.mbus_code = V4L2_MBUS_FMT_SBGGR10_1X10,
.gb_format = 0x80,
.bpp = 10,
},
{
.mbus_code = V4L2_MBUS_FMT_SGBRG10_1X10,
.gb_format = 0x81,
.bpp = 10,
},
{
.mbus_code = V4L2_MBUS_FMT_SGRBG10_1X10,
.gb_format = 0x82,
.bpp = 10,
},
{
.mbus_code = V4L2_MBUS_FMT_SRGGB10_1X10,
.gb_format = 0x83,
.bpp = 10,
},
{
.mbus_code = V4L2_MBUS_FMT_SBGGR12_1X12,
.gb_format = 0x84,
.bpp = 12,
},
{
.mbus_code = V4L2_MBUS_FMT_SGBRG12_1X12,
.gb_format = 0x85,
.bpp = 12,
},
{
.mbus_code = V4L2_MBUS_FMT_SGRBG12_1X12,
.gb_format = 0x86,
.bpp = 12,
},
{
.mbus_code = V4L2_MBUS_FMT_SRGGB12_1X12,
.gb_format = 0x87,
.bpp = 12,
},
};
static const struct gb_camera_fmt_info *gb_camera_get_format_info(u16 gb_fmt)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
if (gb_fmt_info[i].gb_format == gb_fmt)
return &gb_fmt_info[i];
}
return NULL;
}
#define ES2_APB_CDSI0_CPORT 16
#define ES2_APB_CDSI1_CPORT 17
#define GB_CAMERA_MAX_SETTINGS_SIZE 8192
#define gcam_dbg(gcam, format...) dev_dbg(&gcam->bundle->dev, format)
#define gcam_info(gcam, format...) dev_info(&gcam->bundle->dev, format)
#define gcam_err(gcam, format...) dev_err(&gcam->bundle->dev, format)
static int gb_camera_operation_sync_flags(struct gb_connection *connection,
int type, unsigned int flags,
void *request, size_t request_size,
void *response, size_t *response_size)
{
struct gb_operation *operation;
int ret;
operation = gb_operation_create_flags(connection, type, request_size,
*response_size, flags,
GFP_KERNEL);
if (!operation)
return -ENOMEM;
if (request_size)
memcpy(operation->request->payload, request, request_size);
ret = gb_operation_request_send_sync(operation);
if (ret) {
dev_err(&connection->hd->dev,
"%s: synchronous operation of type 0x%02x failed: %d\n",
connection->name, type, ret);
} else {
*response_size = operation->response->payload_size;
if (operation->response->payload_size)
memcpy(response, operation->response->payload,
operation->response->payload_size);
}
gb_operation_put(operation);
return ret;
}
static int gb_camera_get_max_pkt_size(struct gb_camera *gcam,
struct gb_camera_configure_streams_response *resp)
{
unsigned int max_pkt_size = 0;
unsigned int i;
for (i = 0; i < resp->num_streams; i++) {
struct gb_camera_stream_config_response *cfg = &resp->config[i];
const struct gb_camera_fmt_info *fmt_info;
unsigned int pkt_size;
fmt_info = gb_camera_get_format_info(cfg->format);
if (!fmt_info) {
gcam_err(gcam, "unsupported greybus image format: %d\n",
cfg->format);
return -EIO;
}
if (fmt_info->bpp == 0) {
pkt_size = le32_to_cpu(cfg->max_pkt_size);
if (pkt_size == 0) {
gcam_err(gcam,
"Stream %u: invalid zero maximum packet size\n",
i);
return -EIO;
}
} else {
pkt_size = le16_to_cpu(cfg->width) * fmt_info->bpp / 8;
if (pkt_size != le32_to_cpu(cfg->max_pkt_size)) {
gcam_err(gcam,
"Stream %u: maximum packet size mismatch (%u/%u)\n",
i, pkt_size, cfg->max_pkt_size);
return -EIO;
}
}
max_pkt_size = max(pkt_size, max_pkt_size);
}
return max_pkt_size;
}
/*
* Validate the stream configuration response verifying padding is correctly
* set and the returned number of streams is supported
*/
static const int gb_camera_configure_streams_validate_response(
struct gb_camera *gcam,
struct gb_camera_configure_streams_response *resp,
unsigned int nstreams)
{
unsigned int i;
/* Validate the returned response structure */
if (resp->padding[0] || resp->padding[1]) {
gcam_err(gcam, "response padding != 0\n");
return -EIO;
}
if (resp->num_streams > nstreams) {
gcam_err(gcam, "got #streams %u > request %u\n",
resp->num_streams, nstreams);
return -EIO;
}
for (i = 0; i < resp->num_streams; i++) {
struct gb_camera_stream_config_response *cfg = &resp->config[i];
if (cfg->padding) {
gcam_err(gcam, "stream #%u padding != 0\n", i);
return -EIO;
}
}
return 0;
}
/* -----------------------------------------------------------------------------
* Hardware Configuration
*/
static int gb_camera_set_intf_power_mode(struct gb_camera *gcam, u8 intf_id,
bool hs)
{
struct gb_svc *svc = gcam->connection->hd->svc;
int ret;
if (hs)
ret = gb_svc_intf_set_power_mode(svc, intf_id,
GB_SVC_UNIPRO_HS_SERIES_A,
GB_SVC_UNIPRO_FAST_MODE, 2, 2,
GB_SVC_SMALL_AMPLITUDE,
GB_SVC_NO_DE_EMPHASIS,
GB_SVC_UNIPRO_FAST_MODE, 2, 2,
GB_SVC_PWRM_RXTERMINATION |
GB_SVC_PWRM_TXTERMINATION, 0,
NULL, NULL);
else
ret = gb_svc_intf_set_power_mode(svc, intf_id,
GB_SVC_UNIPRO_HS_SERIES_A,
GB_SVC_UNIPRO_SLOW_AUTO_MODE,
2, 1,
GB_SVC_SMALL_AMPLITUDE,
GB_SVC_NO_DE_EMPHASIS,
GB_SVC_UNIPRO_SLOW_AUTO_MODE,
2, 1,
0, 0,
NULL, NULL);
return ret;
}
static int gb_camera_set_power_mode(struct gb_camera *gcam, bool hs)
{
struct gb_interface *intf = gcam->connection->intf;
struct gb_svc *svc = gcam->connection->hd->svc;
int ret;
ret = gb_camera_set_intf_power_mode(gcam, intf->interface_id, hs);
if (ret < 0) {
gcam_err(gcam, "failed to set module interface to %s (%d)\n",
hs ? "HS" : "PWM", ret);
return ret;
}
ret = gb_camera_set_intf_power_mode(gcam, svc->ap_intf_id, hs);
if (ret < 0) {
gb_camera_set_intf_power_mode(gcam, intf->interface_id, !hs);
gcam_err(gcam, "failed to set AP interface to %s (%d)\n",
hs ? "HS" : "PWM", ret);
return ret;
}
return 0;
}
struct ap_csi_config_request {
__u8 csi_id;
__u8 flags;
#define GB_CAMERA_CSI_FLAG_CLOCK_CONTINUOUS 0x01
__u8 num_lanes;
__u8 padding;
__le32 csi_clk_freq;
__le32 max_pkt_size;
} __packed;
/*
* TODO: Compute the number of lanes dynamically based on bandwidth
* requirements.
*/
#define GB_CAMERA_CSI_NUM_DATA_LANES 4
#define GB_CAMERA_CSI_CLK_FREQ_MAX 999000000U
#define GB_CAMERA_CSI_CLK_FREQ_MIN 100000000U
#define GB_CAMERA_CSI_CLK_FREQ_MARGIN 150000000U
static int gb_camera_setup_data_connection(struct gb_camera *gcam,
struct gb_camera_configure_streams_response *resp,
struct gb_camera_csi_params *csi_params)
{
struct ap_csi_config_request csi_cfg;
struct gb_connection *conn;
unsigned int clk_freq;
int ret;
/*
* Create the data connection between the camera module data CPort and
* APB CDSI1. The CDSI1 CPort ID is hardcoded by the ES2 bridge.
*/
conn = gb_connection_create_offloaded(gcam->bundle, gcam->data_cport_id,
GB_CONNECTION_FLAG_NO_FLOWCTRL |
GB_CONNECTION_FLAG_CDSI1);
if (IS_ERR(conn))
return PTR_ERR(conn);
gcam->data_connection = conn;
gb_connection_set_data(conn, gcam);
ret = gb_connection_enable(conn);
if (ret)
goto error_conn_destroy;
/* Set the UniPro link to high speed mode. */
ret = gb_camera_set_power_mode(gcam, true);
if (ret < 0)
goto error_conn_disable;
/*
* Configure the APB-A CSI-2 transmitter.
*
* Hardcode the number of lanes to 4 and compute the bus clock frequency
* based on the module bandwidth requirements with a safety margin.
*/
memset(&csi_cfg, 0, sizeof(csi_cfg));
csi_cfg.csi_id = 1;
csi_cfg.flags = 0;
csi_cfg.num_lanes = GB_CAMERA_CSI_NUM_DATA_LANES;
clk_freq = resp->data_rate / 2 / GB_CAMERA_CSI_NUM_DATA_LANES;
clk_freq = clamp(clk_freq + GB_CAMERA_CSI_CLK_FREQ_MARGIN,
GB_CAMERA_CSI_CLK_FREQ_MIN,
GB_CAMERA_CSI_CLK_FREQ_MAX);
csi_cfg.csi_clk_freq = clk_freq;
ret = gb_camera_get_max_pkt_size(gcam, resp);
if (ret < 0) {
ret = -EIO;
goto error_power;
}
csi_cfg.max_pkt_size = ret;
ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
sizeof(csi_cfg),
GB_APB_REQUEST_CSI_TX_CONTROL, false);
if (ret < 0) {
gcam_err(gcam, "failed to start the CSI transmitter\n");
goto error_power;
}
if (csi_params) {
csi_params->clk_freq = csi_cfg.csi_clk_freq;
csi_params->num_lanes = csi_cfg.num_lanes;
}
return 0;
error_power:
gb_camera_set_power_mode(gcam, false);
error_conn_disable:
gb_connection_disable(gcam->data_connection);
error_conn_destroy:
gb_connection_destroy(gcam->data_connection);
gcam->data_connection = NULL;
return ret;
}
static void gb_camera_teardown_data_connection(struct gb_camera *gcam)
{
struct ap_csi_config_request csi_cfg;
int ret;
/* Stop the APB1 CSI transmitter. */
memset(&csi_cfg, 0, sizeof(csi_cfg));
csi_cfg.csi_id = 1;
ret = gb_hd_output(gcam->connection->hd, &csi_cfg,
sizeof(csi_cfg),
GB_APB_REQUEST_CSI_TX_CONTROL, false);
if (ret < 0)
gcam_err(gcam, "failed to stop the CSI transmitter\n");
/* Set the UniPro link to low speed mode. */
gb_camera_set_power_mode(gcam, false);
/* Destroy the data connection. */
gb_connection_disable(gcam->data_connection);
gb_connection_destroy(gcam->data_connection);
gcam->data_connection = NULL;
}
/* -----------------------------------------------------------------------------
* Camera Protocol Operations
*/
static int gb_camera_capabilities(struct gb_camera *gcam,
u8 *capabilities, size_t *size)
{
int ret;
ret = gb_pm_runtime_get_sync(gcam->bundle);
if (ret)
return ret;
mutex_lock(&gcam->mutex);
if (!gcam->connection) {
ret = -EINVAL;
goto done;
}
ret = gb_camera_operation_sync_flags(gcam->connection,
GB_CAMERA_TYPE_CAPABILITIES,
GB_OPERATION_FLAG_SHORT_RESPONSE,
NULL, 0,
(void *)capabilities, size);
if (ret)
gcam_err(gcam, "failed to retrieve capabilities: %d\n", ret);
done:
mutex_unlock(&gcam->mutex);
gb_pm_runtime_put_autosuspend(gcam->bundle);
return ret;
}
static int gb_camera_configure_streams(struct gb_camera *gcam,
unsigned int *num_streams,
unsigned int *flags,
struct gb_camera_stream_config *streams,
struct gb_camera_csi_params *csi_params)
{
struct gb_camera_configure_streams_request *req;
struct gb_camera_configure_streams_response *resp;
unsigned int nstreams = *num_streams;
unsigned int i;
size_t req_size;
size_t resp_size;
int ret;
if (nstreams > GB_CAMERA_MAX_STREAMS)
return -EINVAL;
req_size = sizeof(*req) + nstreams * sizeof(req->config[0]);
resp_size = sizeof(*resp) + nstreams * sizeof(resp->config[0]);
req = kmalloc(req_size, GFP_KERNEL);
resp = kmalloc(resp_size, GFP_KERNEL);
if (!req || !resp) {
kfree(req);
kfree(resp);
return -ENOMEM;
}
req->num_streams = nstreams;
req->flags = *flags;
req->padding = 0;
for (i = 0; i < nstreams; ++i) {
struct gb_camera_stream_config_request *cfg = &req->config[i];
cfg->width = cpu_to_le16(streams[i].width);
cfg->height = cpu_to_le16(streams[i].height);
cfg->format = cpu_to_le16(streams[i].format);
cfg->padding = 0;
}
mutex_lock(&gcam->mutex);
ret = gb_pm_runtime_get_sync(gcam->bundle);
if (ret)
goto done_skip_pm_put;
if (!gcam->connection) {
ret = -EINVAL;
goto done;
}
ret = gb_camera_operation_sync_flags(gcam->connection,
GB_CAMERA_TYPE_CONFIGURE_STREAMS,
GB_OPERATION_FLAG_SHORT_RESPONSE,
req, req_size,
resp, &resp_size);
if (ret < 0)
goto done;
ret = gb_camera_configure_streams_validate_response(gcam, resp,
nstreams);
if (ret < 0)
goto done;
*flags = resp->flags;
*num_streams = resp->num_streams;
for (i = 0; i < resp->num_streams; ++i) {
struct gb_camera_stream_config_response *cfg = &resp->config[i];
streams[i].width = le16_to_cpu(cfg->width);
streams[i].height = le16_to_cpu(cfg->height);
streams[i].format = le16_to_cpu(cfg->format);
streams[i].vc = cfg->virtual_channel;
streams[i].dt[0] = cfg->data_type[0];
streams[i].dt[1] = cfg->data_type[1];
streams[i].max_size = le32_to_cpu(cfg->max_size);
}
if ((resp->flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED) ||
(req->flags & GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY))
goto done;
if (gcam->state == GB_CAMERA_STATE_CONFIGURED) {
gb_camera_teardown_data_connection(gcam);
gcam->state = GB_CAMERA_STATE_UNCONFIGURED;
/*
* When unconfiguring streams release the PM runtime reference
* that was acquired when streams were configured. The bundle
* won't be suspended until the PM runtime reference acquired at
* the beginning of this function gets released right before
* returning.
*/
gb_pm_runtime_put_noidle(gcam->bundle);
}
if (resp->num_streams == 0)
goto done;
/*
* Make sure the bundle won't be suspended until streams get
* unconfigured after the stream is configured successfully
*/
gb_pm_runtime_get_noresume(gcam->bundle);
/* Setup CSI-2 connection from APB-A to AP */
ret = gb_camera_setup_data_connection(gcam, resp, csi_params);
if (ret < 0) {
memset(req, 0, sizeof(*req));
gb_operation_sync(gcam->connection,
GB_CAMERA_TYPE_CONFIGURE_STREAMS,
req, sizeof(*req),
resp, sizeof(*resp));
*flags = 0;
*num_streams = 0;
gb_pm_runtime_put_noidle(gcam->bundle);
goto done;
}
gcam->state = GB_CAMERA_STATE_CONFIGURED;
done:
gb_pm_runtime_put_autosuspend(gcam->bundle);
done_skip_pm_put:
mutex_unlock(&gcam->mutex);
kfree(req);
kfree(resp);
return ret;
}
static int gb_camera_capture(struct gb_camera *gcam, u32 request_id,
unsigned int streams, unsigned int num_frames,
size_t settings_size, const void *settings)
{
struct gb_camera_capture_request *req;
size_t req_size;
int ret;
if (settings_size > GB_CAMERA_MAX_SETTINGS_SIZE)
return -EINVAL;
req_size = sizeof(*req) + settings_size;
req = kmalloc(req_size, GFP_KERNEL);
if (!req)
return -ENOMEM;
req->request_id = cpu_to_le32(request_id);
req->streams = streams;
req->padding = 0;
req->num_frames = cpu_to_le16(num_frames);
memcpy(req->settings, settings, settings_size);
mutex_lock(&gcam->mutex);
if (!gcam->connection) {
ret = -EINVAL;
goto done;
}
ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_CAPTURE,
req, req_size, NULL, 0);
done:
mutex_unlock(&gcam->mutex);
kfree(req);
return ret;
}
static int gb_camera_flush(struct gb_camera *gcam, u32 *request_id)
{
struct gb_camera_flush_response resp;
int ret;
mutex_lock(&gcam->mutex);
if (!gcam->connection) {
ret = -EINVAL;
goto done;
}
ret = gb_operation_sync(gcam->connection, GB_CAMERA_TYPE_FLUSH, NULL, 0,
&resp, sizeof(resp));
if (ret < 0)
goto done;
if (request_id)
*request_id = le32_to_cpu(resp.request_id);
done:
mutex_unlock(&gcam->mutex);
return ret;
}
static int gb_camera_request_handler(struct gb_operation *op)
{
struct gb_camera *gcam = gb_connection_get_data(op->connection);
struct gb_camera_metadata_request *payload;
struct gb_message *request;
if (op->type != GB_CAMERA_TYPE_METADATA) {
gcam_err(gcam, "Unsupported unsolicited event: %u\n", op->type);
return -EINVAL;
}
request = op->request;
if (request->payload_size < sizeof(*payload)) {
gcam_err(gcam, "Wrong event size received (%zu < %zu)\n",
request->payload_size, sizeof(*payload));
return -EINVAL;
}
payload = request->payload;
gcam_dbg(gcam, "received metadata for request %u, frame %u, stream %u\n",
payload->request_id, payload->frame_number, payload->stream);
return 0;
}
/* -----------------------------------------------------------------------------
* Interface with HOST gmp camera.
*/
static unsigned int gb_camera_mbus_to_gb(enum v4l2_mbus_pixelcode mbus_code)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
if (gb_fmt_info[i].mbus_code == mbus_code)
return gb_fmt_info[i].gb_format;
}
return gb_fmt_info[0].gb_format;
}
static enum v4l2_mbus_pixelcode gb_camera_gb_to_mbus(u16 gb_fmt)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(gb_fmt_info); i++) {
if (gb_fmt_info[i].gb_format == gb_fmt)
return gb_fmt_info[i].mbus_code;
}
return gb_fmt_info[0].mbus_code;
}
static ssize_t gb_camera_op_capabilities(void *priv, char *data, size_t len)
{
struct gb_camera *gcam = priv;
size_t capabilities_len = len;
int ret;
ret = gb_camera_capabilities(gcam, data, &capabilities_len);
if (ret)
return ret;
return capabilities_len;
}
static int gb_camera_op_configure_streams(void *priv, unsigned int *nstreams,
unsigned int *flags, struct gb_camera_stream *streams,
struct gb_camera_csi_params *csi_params)
{
struct gb_camera *gcam = priv;
struct gb_camera_stream_config *gb_streams;
unsigned int gb_flags = 0;
unsigned int gb_nstreams = *nstreams;
unsigned int i;
int ret;
if (gb_nstreams > GB_CAMERA_MAX_STREAMS)
return -EINVAL;
gb_streams = kcalloc(gb_nstreams, sizeof(*gb_streams), GFP_KERNEL);
if (!gb_streams)
return -ENOMEM;
for (i = 0; i < gb_nstreams; i++) {
gb_streams[i].width = streams[i].width;
gb_streams[i].height = streams[i].height;
gb_streams[i].format =
gb_camera_mbus_to_gb(streams[i].pixel_code);
}
if (*flags & GB_CAMERA_IN_FLAG_TEST)
gb_flags |= GB_CAMERA_CONFIGURE_STREAMS_TEST_ONLY;
ret = gb_camera_configure_streams(gcam, &gb_nstreams,
&gb_flags, gb_streams, csi_params);
if (ret < 0)
goto done;
if (gb_nstreams > *nstreams) {
ret = -EINVAL;
goto done;
}
*flags = 0;
if (gb_flags & GB_CAMERA_CONFIGURE_STREAMS_ADJUSTED)
*flags |= GB_CAMERA_OUT_FLAG_ADJUSTED;
for (i = 0; i < gb_nstreams; i++) {
streams[i].width = gb_streams[i].width;
streams[i].height = gb_streams[i].height;
streams[i].vc = gb_streams[i].vc;
streams[i].dt[0] = gb_streams[i].dt[0];
streams[i].dt[1] = gb_streams[i].dt[1];
streams[i].max_size = gb_streams[i].max_size;
streams[i].pixel_code =
gb_camera_gb_to_mbus(gb_streams[i].format);
}
*nstreams = gb_nstreams;
done:
kfree(gb_streams);
return ret;
}
static int gb_camera_op_capture(void *priv, u32 request_id,
unsigned int streams, unsigned int num_frames,
size_t settings_size, const void *settings)
{
struct gb_camera *gcam = priv;
return gb_camera_capture(gcam, request_id, streams, num_frames,
settings_size, settings);
}
static int gb_camera_op_flush(void *priv, u32 *request_id)
{
struct gb_camera *gcam = priv;
return gb_camera_flush(gcam, request_id);
}
static const struct gb_camera_ops gb_cam_ops = {
.capabilities = gb_camera_op_capabilities,
.configure_streams = gb_camera_op_configure_streams,
.capture = gb_camera_op_capture,
.flush = gb_camera_op_flush,
};
/* -----------------------------------------------------------------------------
* DebugFS
*/
static ssize_t gb_camera_debugfs_capabilities(struct gb_camera *gcam,
char *buf, size_t len)
{
struct gb_camera_debugfs_buffer *buffer =
&gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES];
size_t size = 1024;
unsigned int i;
u8 *caps;
int ret;
caps = kmalloc(size, GFP_KERNEL);
if (!caps)
return -ENOMEM;
ret = gb_camera_capabilities(gcam, caps, &size);
if (ret < 0)
goto done;
/*
* hex_dump_to_buffer() doesn't return the number of bytes dumped prior
* to v4.0, we need our own implementation :-(
*/
buffer->length = 0;
for (i = 0; i < size; i += 16) {
unsigned int nbytes = min_t(unsigned int, size - i, 16);
buffer->length += sprintf(buffer->data + buffer->length,
"%*ph\n", nbytes, caps + i);
}
done:
kfree(caps);
return ret;
}
static ssize_t gb_camera_debugfs_configure_streams(struct gb_camera *gcam,
char *buf, size_t len)
{
struct gb_camera_debugfs_buffer *buffer =
&gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_STREAMS];
struct gb_camera_stream_config *streams;
unsigned int nstreams;
unsigned int flags;
unsigned int i;
char *token;
int ret;
/* Retrieve number of streams to configure */
token = strsep(&buf, ";");
if (!token)
return -EINVAL;
ret = kstrtouint(token, 10, &nstreams);
if (ret < 0)
return ret;
if (nstreams > GB_CAMERA_MAX_STREAMS)
return -EINVAL;
token = strsep(&buf, ";");
if (!token)
return -EINVAL;
ret = kstrtouint(token, 10, &flags);
if (ret < 0)
return ret;
/* For each stream to configure parse width, height and format */
streams = kcalloc(nstreams, sizeof(*streams), GFP_KERNEL);
if (!streams)
return -ENOMEM;
for (i = 0; i < nstreams; ++i) {
struct gb_camera_stream_config *stream = &streams[i];
/* width */
token = strsep(&buf, ";");
if (!token) {
ret = -EINVAL;
goto done;
}
ret = kstrtouint(token, 10, &stream->width);
if (ret < 0)
goto done;
/* height */
token = strsep(&buf, ";");
if (!token)
goto done;
ret = kstrtouint(token, 10, &stream->height);
if (ret < 0)
goto done;
/* Image format code */
token = strsep(&buf, ";");
if (!token)
goto done;
ret = kstrtouint(token, 16, &stream->format);
if (ret < 0)
goto done;
}
ret = gb_camera_configure_streams(gcam, &nstreams, &flags, streams,
NULL);
if (ret < 0)
goto done;
buffer->length = sprintf(buffer->data, "%u;%u;", nstreams, flags);
for (i = 0; i < nstreams; ++i) {
struct gb_camera_stream_config *stream = &streams[i];
buffer->length += sprintf(buffer->data + buffer->length,
"%u;%u;%u;%u;%u;%u;%u;",
stream->width, stream->height,
stream->format, stream->vc,
stream->dt[0], stream->dt[1],
stream->max_size);
}
ret = len;
done:
kfree(streams);
return ret;
};
static ssize_t gb_camera_debugfs_capture(struct gb_camera *gcam,
char *buf, size_t len)
{
unsigned int request_id;
unsigned int streams_mask;
unsigned int num_frames;
char *token;
int ret;
/* Request id */
token = strsep(&buf, ";");
if (!token)
return -EINVAL;
ret = kstrtouint(token, 10, &request_id);
if (ret < 0)
return ret;
/* Stream mask */
token = strsep(&buf, ";");
if (!token)
return -EINVAL;
ret = kstrtouint(token, 16, &streams_mask);
if (ret < 0)
return ret;
/* number of frames */
token = strsep(&buf, ";");
if (!token)
return -EINVAL;
ret = kstrtouint(token, 10, &num_frames);
if (ret < 0)
return ret;
ret = gb_camera_capture(gcam, request_id, streams_mask, num_frames, 0,
NULL);
if (ret < 0)
return ret;
return len;
}
static ssize_t gb_camera_debugfs_flush(struct gb_camera *gcam,
char *buf, size_t len)
{
struct gb_camera_debugfs_buffer *buffer =
&gcam->debugfs.buffers[GB_CAMERA_DEBUGFS_BUFFER_FLUSH];
unsigned int req_id;
int ret;
ret = gb_camera_flush(gcam, &req_id);
if (ret < 0)
return ret;
buffer->length = sprintf(buffer->data, "%u", req_id);
return len;
}
struct gb_camera_debugfs_entry {
const char *name;
unsigned int mask;
unsigned int buffer;
ssize_t (*execute)(struct gb_camera *gcam, char *buf, size_t len);
};
static const struct gb_camera_debugfs_entry gb_camera_debugfs_entries[] = {
{
.name = "capabilities",
.mask = S_IFREG | 0444,
.buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPABILITIES,
.execute = gb_camera_debugfs_capabilities,
}, {
.name = "configure_streams",
.mask = S_IFREG | 0666,
.buffer = GB_CAMERA_DEBUGFS_BUFFER_STREAMS,
.execute = gb_camera_debugfs_configure_streams,
}, {
.name = "capture",
.mask = S_IFREG | 0666,
.buffer = GB_CAMERA_DEBUGFS_BUFFER_CAPTURE,
.execute = gb_camera_debugfs_capture,
}, {
.name = "flush",
.mask = S_IFREG | 0666,
.buffer = GB_CAMERA_DEBUGFS_BUFFER_FLUSH,
.execute = gb_camera_debugfs_flush,
},
};
static ssize_t gb_camera_debugfs_read(struct file *file, char __user *buf,
size_t len, loff_t *offset)
{
const struct gb_camera_debugfs_entry *op = file->private_data;
struct gb_camera *gcam = file_inode(file)->i_private;
struct gb_camera_debugfs_buffer *buffer;
ssize_t ret;
/* For read-only entries the operation is triggered by a read. */
if (!(op->mask & 0222)) {
ret = op->execute(gcam, NULL, 0);
if (ret < 0)
return ret;
}
buffer = &gcam->debugfs.buffers[op->buffer];
return simple_read_from_buffer(buf, len, offset, buffer->data,
buffer->length);
}
static ssize_t gb_camera_debugfs_write(struct file *file,
const char __user *buf, size_t len,
loff_t *offset)
{
const struct gb_camera_debugfs_entry *op = file->private_data;
struct gb_camera *gcam = file_inode(file)->i_private;
ssize_t ret;
char *kbuf;
if (len > 1024)
return -EINVAL;
kbuf = memdup_user_nul(buf, len);
if (IS_ERR(kbuf))
return PTR_ERR(kbuf);
ret = op->execute(gcam, kbuf, len);
done:
kfree(kbuf);
return ret;
}
static int gb_camera_debugfs_open(struct inode *inode, struct file *file)
{
unsigned int i;
for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
const struct gb_camera_debugfs_entry *entry =
&gb_camera_debugfs_entries[i];
if (!strcmp(file->f_path.dentry->d_iname, entry->name)) {
file->private_data = (void *)entry;
break;
}
}
return 0;
}
static const struct file_operations gb_camera_debugfs_ops = {
.open = gb_camera_debugfs_open,
.read = gb_camera_debugfs_read,
.write = gb_camera_debugfs_write,
};
static int gb_camera_debugfs_init(struct gb_camera *gcam)
{
struct gb_connection *connection = gcam->connection;
char dirname[27];
unsigned int i;
/*
* Create root debugfs entry and a file entry for each camera operation.
*/
snprintf(dirname, 27, "camera-%u.%u", connection->intf->interface_id,
gcam->bundle->id);
gcam->debugfs.root = debugfs_create_dir(dirname, gb_debugfs_get());
gcam->debugfs.buffers =
vmalloc(array_size(GB_CAMERA_DEBUGFS_BUFFER_MAX,
sizeof(*gcam->debugfs.buffers)));
if (!gcam->debugfs.buffers)
return -ENOMEM;
for (i = 0; i < ARRAY_SIZE(gb_camera_debugfs_entries); ++i) {
const struct gb_camera_debugfs_entry *entry =
&gb_camera_debugfs_entries[i];
gcam->debugfs.buffers[i].length = 0;
debugfs_create_file(entry->name, entry->mask,
gcam->debugfs.root, gcam,
&gb_camera_debugfs_ops);
}
return 0;
}
static void gb_camera_debugfs_cleanup(struct gb_camera *gcam)
{
debugfs_remove_recursive(gcam->debugfs.root);
vfree(gcam->debugfs.buffers);
}
/* -----------------------------------------------------------------------------
* Init & Cleanup
*/
static void gb_camera_cleanup(struct gb_camera *gcam)
{
gb_camera_debugfs_cleanup(gcam);
mutex_lock(&gcam->mutex);
if (gcam->data_connection) {
gb_connection_disable(gcam->data_connection);
gb_connection_destroy(gcam->data_connection);
gcam->data_connection = NULL;
}
if (gcam->connection) {
gb_connection_disable(gcam->connection);
gb_connection_destroy(gcam->connection);
gcam->connection = NULL;
}
mutex_unlock(&gcam->mutex);
}
static void gb_camera_release_module(struct kref *ref)
{
struct gb_camera_module *cam_mod =
container_of(ref, struct gb_camera_module, refcount);
kfree(cam_mod->priv);
}
static int gb_camera_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct gb_connection *conn;
struct gb_camera *gcam;
u16 mgmt_cport_id = 0;
u16 data_cport_id = 0;
unsigned int i;
int ret;
/*
* The camera bundle must contain exactly two CPorts, one for the
* camera management protocol and one for the camera data protocol.
*/
if (bundle->num_cports != 2)
return -ENODEV;
for (i = 0; i < bundle->num_cports; ++i) {
struct greybus_descriptor_cport *desc = &bundle->cport_desc[i];
switch (desc->protocol_id) {
case GREYBUS_PROTOCOL_CAMERA_MGMT:
mgmt_cport_id = le16_to_cpu(desc->id);
break;
case GREYBUS_PROTOCOL_CAMERA_DATA:
data_cport_id = le16_to_cpu(desc->id);
break;
default:
return -ENODEV;
}
}
if (!mgmt_cport_id || !data_cport_id)
return -ENODEV;
gcam = kzalloc(sizeof(*gcam), GFP_KERNEL);
if (!gcam)
return -ENOMEM;
mutex_init(&gcam->mutex);
gcam->bundle = bundle;
gcam->state = GB_CAMERA_STATE_UNCONFIGURED;
gcam->data_cport_id = data_cport_id;
conn = gb_connection_create(bundle, mgmt_cport_id,
gb_camera_request_handler);
if (IS_ERR(conn)) {
ret = PTR_ERR(conn);
goto error;
}
gcam->connection = conn;
gb_connection_set_data(conn, gcam);
ret = gb_connection_enable(conn);
if (ret)
goto error;
ret = gb_camera_debugfs_init(gcam);
if (ret < 0)
goto error;
gcam->module.priv = gcam;
gcam->module.ops = &gb_cam_ops;
gcam->module.interface_id = gcam->connection->intf->interface_id;
gcam->module.release = gb_camera_release_module;
ret = gb_camera_register(&gcam->module);
if (ret < 0)
goto error;
greybus_set_drvdata(bundle, gcam);
gb_pm_runtime_put_autosuspend(gcam->bundle);
return 0;
error:
gb_camera_cleanup(gcam);
kfree(gcam);
return ret;
}
static void gb_camera_disconnect(struct gb_bundle *bundle)
{
struct gb_camera *gcam = greybus_get_drvdata(bundle);
int ret;
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
gb_pm_runtime_get_noresume(bundle);
gb_camera_cleanup(gcam);
gb_camera_unregister(&gcam->module);
}
static const struct greybus_bundle_id gb_camera_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_CAMERA) },
{ },
};
#ifdef CONFIG_PM
static int gb_camera_suspend(struct device *dev)
{
struct gb_bundle *bundle = to_gb_bundle(dev);
struct gb_camera *gcam = greybus_get_drvdata(bundle);
if (gcam->data_connection)
gb_connection_disable(gcam->data_connection);
gb_connection_disable(gcam->connection);
return 0;
}
static int gb_camera_resume(struct device *dev)
{
struct gb_bundle *bundle = to_gb_bundle(dev);
struct gb_camera *gcam = greybus_get_drvdata(bundle);
int ret;
ret = gb_connection_enable(gcam->connection);
if (ret) {
gcam_err(gcam, "failed to enable connection: %d\n", ret);
return ret;
}
if (gcam->data_connection) {
ret = gb_connection_enable(gcam->data_connection);
if (ret) {
gcam_err(gcam,
"failed to enable data connection: %d\n", ret);
return ret;
}
}
return 0;
}
#endif
static const struct dev_pm_ops gb_camera_pm_ops = {
SET_RUNTIME_PM_OPS(gb_camera_suspend, gb_camera_resume, NULL)
};
static struct greybus_driver gb_camera_driver = {
.name = "camera",
.probe = gb_camera_probe,
.disconnect = gb_camera_disconnect,
.id_table = gb_camera_id_table,
.driver.pm = &gb_camera_pm_ops,
};
module_greybus_driver(gb_camera_driver);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/camera.c |
// SPDX-License-Identifier: GPL-2.0
/*
* APBridge ALSA SoC dummy codec driver
* Copyright 2016 Google Inc.
* Copyright 2016 Linaro Ltd.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/pm_runtime.h>
#include <sound/soc.h>
#include <sound/pcm_params.h>
#include <uapi/linux/input.h>
#include "audio_codec.h"
#include "audio_apbridgea.h"
#include "audio_manager.h"
#include "audio_helper.h"
static struct gbaudio_codec_info *gbcodec;
static struct gbaudio_data_connection *
find_data(struct gbaudio_module_info *module, int id)
{
struct gbaudio_data_connection *data;
list_for_each_entry(data, &module->data_list, list) {
if (id == data->id)
return data;
}
return NULL;
}
static struct gbaudio_stream_params *
find_dai_stream_params(struct gbaudio_codec_info *codec, int id, int stream)
{
struct gbaudio_codec_dai *dai;
list_for_each_entry(dai, &codec->dai_list, list) {
if (dai->id == id)
return &dai->params[stream];
}
return NULL;
}
static int gbaudio_module_enable_tx(struct gbaudio_codec_info *codec,
struct gbaudio_module_info *module, int id)
{
int module_state, ret = 0;
u16 data_cport, i2s_port, cportid;
u8 sig_bits, channels;
u32 format, rate;
struct gbaudio_data_connection *data;
struct gbaudio_stream_params *params;
/* find the dai */
data = find_data(module, id);
if (!data) {
dev_err(module->dev, "%d:DATA connection missing\n", id);
return -ENODEV;
}
module_state = data->state[SNDRV_PCM_STREAM_PLAYBACK];
params = find_dai_stream_params(codec, id, SNDRV_PCM_STREAM_PLAYBACK);
if (!params) {
dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
return -EINVAL;
}
/* register cport */
if (module_state < GBAUDIO_CODEC_STARTUP) {
i2s_port = 0; /* fixed for now */
cportid = data->connection->hd_cport_id;
ret = gb_audio_apbridgea_register_cport(data->connection,
i2s_port, cportid,
AUDIO_APBRIDGEA_DIRECTION_TX);
if (ret) {
dev_err_ratelimited(module->dev, "reg_cport failed:%d\n", ret);
return ret;
}
data->state[SNDRV_PCM_STREAM_PLAYBACK] = GBAUDIO_CODEC_STARTUP;
dev_dbg(module->dev, "Dynamic Register %d DAI\n", cportid);
}
/* hw_params */
if (module_state < GBAUDIO_CODEC_HWPARAMS) {
format = params->format;
channels = params->channels;
rate = params->rate;
sig_bits = params->sig_bits;
data_cport = data->connection->intf_cport_id;
ret = gb_audio_gb_set_pcm(module->mgmt_connection, data_cport,
format, rate, channels, sig_bits);
if (ret) {
dev_err_ratelimited(module->dev, "set_pcm failed:%d\n", ret);
return ret;
}
data->state[SNDRV_PCM_STREAM_PLAYBACK] = GBAUDIO_CODEC_HWPARAMS;
dev_dbg(module->dev, "Dynamic hw_params %d DAI\n", data_cport);
}
/* prepare */
if (module_state < GBAUDIO_CODEC_PREPARE) {
data_cport = data->connection->intf_cport_id;
ret = gb_audio_gb_set_tx_data_size(module->mgmt_connection,
data_cport, 192);
if (ret) {
dev_err_ratelimited(module->dev,
"set_tx_data_size failed:%d\n",
ret);
return ret;
}
ret = gb_audio_gb_activate_tx(module->mgmt_connection, data_cport);
if (ret) {
dev_err_ratelimited(module->dev,
"activate_tx failed:%d\n", ret);
return ret;
}
data->state[SNDRV_PCM_STREAM_PLAYBACK] = GBAUDIO_CODEC_PREPARE;
dev_dbg(module->dev, "Dynamic prepare %d DAI\n", data_cport);
}
return 0;
}
static int gbaudio_module_disable_tx(struct gbaudio_module_info *module, int id)
{
int ret;
u16 data_cport, cportid, i2s_port;
int module_state;
struct gbaudio_data_connection *data;
/* find the dai */
data = find_data(module, id);
if (!data) {
dev_err(module->dev, "%d:DATA connection missing\n", id);
return -ENODEV;
}
module_state = data->state[SNDRV_PCM_STREAM_PLAYBACK];
if (module_state > GBAUDIO_CODEC_HWPARAMS) {
data_cport = data->connection->intf_cport_id;
ret = gb_audio_gb_deactivate_tx(module->mgmt_connection,
data_cport);
if (ret) {
dev_err_ratelimited(module->dev,
"deactivate_tx failed:%d\n", ret);
return ret;
}
dev_dbg(module->dev, "Dynamic deactivate %d DAI\n", data_cport);
data->state[SNDRV_PCM_STREAM_PLAYBACK] = GBAUDIO_CODEC_HWPARAMS;
}
if (module_state > GBAUDIO_CODEC_SHUTDOWN) {
i2s_port = 0; /* fixed for now */
cportid = data->connection->hd_cport_id;
ret = gb_audio_apbridgea_unregister_cport(data->connection,
i2s_port, cportid,
AUDIO_APBRIDGEA_DIRECTION_TX);
if (ret) {
dev_err_ratelimited(module->dev,
"unregister_cport failed:%d\n", ret);
return ret;
}
dev_dbg(module->dev, "Dynamic Unregister %d DAI\n", cportid);
data->state[SNDRV_PCM_STREAM_PLAYBACK] = GBAUDIO_CODEC_SHUTDOWN;
}
return 0;
}
static int gbaudio_module_enable_rx(struct gbaudio_codec_info *codec,
struct gbaudio_module_info *module, int id)
{
int module_state, ret = 0;
u16 data_cport, i2s_port, cportid;
u8 sig_bits, channels;
u32 format, rate;
struct gbaudio_data_connection *data;
struct gbaudio_stream_params *params;
/* find the dai */
data = find_data(module, id);
if (!data) {
dev_err(module->dev, "%d:DATA connection missing\n", id);
return -ENODEV;
}
module_state = data->state[SNDRV_PCM_STREAM_CAPTURE];
params = find_dai_stream_params(codec, id, SNDRV_PCM_STREAM_CAPTURE);
if (!params) {
dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
return -EINVAL;
}
/* register cport */
if (module_state < GBAUDIO_CODEC_STARTUP) {
i2s_port = 0; /* fixed for now */
cportid = data->connection->hd_cport_id;
ret = gb_audio_apbridgea_register_cport(data->connection,
i2s_port, cportid,
AUDIO_APBRIDGEA_DIRECTION_RX);
if (ret) {
dev_err_ratelimited(module->dev, "reg_cport failed:%d\n", ret);
return ret;
}
data->state[SNDRV_PCM_STREAM_CAPTURE] = GBAUDIO_CODEC_STARTUP;
dev_dbg(module->dev, "Dynamic Register %d DAI\n", cportid);
}
/* hw_params */
if (module_state < GBAUDIO_CODEC_HWPARAMS) {
format = params->format;
channels = params->channels;
rate = params->rate;
sig_bits = params->sig_bits;
data_cport = data->connection->intf_cport_id;
ret = gb_audio_gb_set_pcm(module->mgmt_connection, data_cport,
format, rate, channels, sig_bits);
if (ret) {
dev_err_ratelimited(module->dev, "set_pcm failed:%d\n", ret);
return ret;
}
data->state[SNDRV_PCM_STREAM_CAPTURE] = GBAUDIO_CODEC_HWPARAMS;
dev_dbg(module->dev, "Dynamic hw_params %d DAI\n", data_cport);
}
/* prepare */
if (module_state < GBAUDIO_CODEC_PREPARE) {
data_cport = data->connection->intf_cport_id;
ret = gb_audio_gb_set_rx_data_size(module->mgmt_connection,
data_cport, 192);
if (ret) {
dev_err_ratelimited(module->dev,
"set_rx_data_size failed:%d\n",
ret);
return ret;
}
ret = gb_audio_gb_activate_rx(module->mgmt_connection,
data_cport);
if (ret) {
dev_err_ratelimited(module->dev,
"activate_rx failed:%d\n", ret);
return ret;
}
data->state[SNDRV_PCM_STREAM_CAPTURE] = GBAUDIO_CODEC_PREPARE;
dev_dbg(module->dev, "Dynamic prepare %d DAI\n", data_cport);
}
return 0;
}
static int gbaudio_module_disable_rx(struct gbaudio_module_info *module, int id)
{
int ret;
u16 data_cport, cportid, i2s_port;
int module_state;
struct gbaudio_data_connection *data;
/* find the dai */
data = find_data(module, id);
if (!data) {
dev_err(module->dev, "%d:DATA connection missing\n", id);
return -ENODEV;
}
module_state = data->state[SNDRV_PCM_STREAM_CAPTURE];
if (module_state > GBAUDIO_CODEC_HWPARAMS) {
data_cport = data->connection->intf_cport_id;
ret = gb_audio_gb_deactivate_rx(module->mgmt_connection,
data_cport);
if (ret) {
dev_err_ratelimited(module->dev,
"deactivate_rx failed:%d\n", ret);
return ret;
}
dev_dbg(module->dev, "Dynamic deactivate %d DAI\n", data_cport);
data->state[SNDRV_PCM_STREAM_CAPTURE] = GBAUDIO_CODEC_HWPARAMS;
}
if (module_state > GBAUDIO_CODEC_SHUTDOWN) {
i2s_port = 0; /* fixed for now */
cportid = data->connection->hd_cport_id;
ret = gb_audio_apbridgea_unregister_cport(data->connection,
i2s_port, cportid,
AUDIO_APBRIDGEA_DIRECTION_RX);
if (ret) {
dev_err_ratelimited(module->dev,
"unregister_cport failed:%d\n", ret);
return ret;
}
dev_dbg(module->dev, "Dynamic Unregister %d DAI\n", cportid);
data->state[SNDRV_PCM_STREAM_CAPTURE] = GBAUDIO_CODEC_SHUTDOWN;
}
return 0;
}
int gbaudio_module_update(struct gbaudio_codec_info *codec,
struct snd_soc_dapm_widget *w,
struct gbaudio_module_info *module, int enable)
{
int dai_id, ret;
char intf_name[NAME_SIZE], dir[NAME_SIZE];
dev_dbg(module->dev, "%s:Module update %s sequence\n", w->name,
enable ? "Enable" : "Disable");
if ((w->id != snd_soc_dapm_aif_in) && (w->id != snd_soc_dapm_aif_out)) {
dev_dbg(codec->dev, "No action required for %s\n", w->name);
return 0;
}
/* parse dai_id from AIF widget's stream_name */
ret = sscanf(w->sname, "%s %d %s", intf_name, &dai_id, dir);
if (ret < 3) {
dev_err(codec->dev, "Error while parsing dai_id for %s\n", w->name);
return -EINVAL;
}
mutex_lock(&codec->lock);
if (w->id == snd_soc_dapm_aif_in) {
if (enable)
ret = gbaudio_module_enable_tx(codec, module, dai_id);
else
ret = gbaudio_module_disable_tx(module, dai_id);
} else if (w->id == snd_soc_dapm_aif_out) {
if (enable)
ret = gbaudio_module_enable_rx(codec, module, dai_id);
else
ret = gbaudio_module_disable_rx(module, dai_id);
}
mutex_unlock(&codec->lock);
return ret;
}
EXPORT_SYMBOL(gbaudio_module_update);
/*
* codec DAI ops
*/
static int gbcodec_startup(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
struct gbaudio_stream_params *params;
mutex_lock(&codec->lock);
if (list_empty(&codec->module_list)) {
dev_err(codec->dev, "No codec module available\n");
mutex_unlock(&codec->lock);
return -ENODEV;
}
params = find_dai_stream_params(codec, dai->id, substream->stream);
if (!params) {
dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
mutex_unlock(&codec->lock);
return -EINVAL;
}
params->state = GBAUDIO_CODEC_STARTUP;
mutex_unlock(&codec->lock);
/* to prevent suspend in case of active audio */
pm_stay_awake(dai->dev);
return 0;
}
static void gbcodec_shutdown(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
struct gbaudio_stream_params *params;
mutex_lock(&codec->lock);
if (list_empty(&codec->module_list))
dev_info(codec->dev, "No codec module available during shutdown\n");
params = find_dai_stream_params(codec, dai->id, substream->stream);
if (!params) {
dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
mutex_unlock(&codec->lock);
return;
}
params->state = GBAUDIO_CODEC_SHUTDOWN;
mutex_unlock(&codec->lock);
pm_relax(dai->dev);
}
static int gbcodec_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *hwparams,
struct snd_soc_dai *dai)
{
int ret;
u8 sig_bits, channels;
u32 format, rate;
struct gbaudio_module_info *module;
struct gbaudio_data_connection *data;
struct gb_bundle *bundle;
struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
struct gbaudio_stream_params *params;
mutex_lock(&codec->lock);
if (list_empty(&codec->module_list)) {
dev_err(codec->dev, "No codec module available\n");
mutex_unlock(&codec->lock);
return -ENODEV;
}
/*
* assuming, currently only 48000 Hz, 16BIT_LE, stereo
* is supported, validate params before configuring codec
*/
if (params_channels(hwparams) != 2) {
dev_err(dai->dev, "Invalid channel count:%d\n",
params_channels(hwparams));
mutex_unlock(&codec->lock);
return -EINVAL;
}
channels = params_channels(hwparams);
if (params_rate(hwparams) != 48000) {
dev_err(dai->dev, "Invalid sampling rate:%d\n",
params_rate(hwparams));
mutex_unlock(&codec->lock);
return -EINVAL;
}
rate = GB_AUDIO_PCM_RATE_48000;
if (params_format(hwparams) != SNDRV_PCM_FORMAT_S16_LE) {
dev_err(dai->dev, "Invalid format:%d\n", params_format(hwparams));
mutex_unlock(&codec->lock);
return -EINVAL;
}
format = GB_AUDIO_PCM_FMT_S16_LE;
/* find the data connection */
list_for_each_entry(module, &codec->module_list, list) {
data = find_data(module, dai->id);
if (data)
break;
}
if (!data) {
dev_err(dai->dev, "DATA connection missing\n");
mutex_unlock(&codec->lock);
return -EINVAL;
}
params = find_dai_stream_params(codec, dai->id, substream->stream);
if (!params) {
dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
mutex_unlock(&codec->lock);
return -EINVAL;
}
bundle = to_gb_bundle(module->dev);
ret = gb_pm_runtime_get_sync(bundle);
if (ret) {
mutex_unlock(&codec->lock);
return ret;
}
ret = gb_audio_apbridgea_set_config(data->connection, 0,
AUDIO_APBRIDGEA_PCM_FMT_16,
AUDIO_APBRIDGEA_PCM_RATE_48000,
6144000);
if (ret) {
dev_err_ratelimited(dai->dev, "%d: Error during set_config\n",
ret);
gb_pm_runtime_put_noidle(bundle);
mutex_unlock(&codec->lock);
return ret;
}
gb_pm_runtime_put_noidle(bundle);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
sig_bits = dai->driver->playback.sig_bits;
else
sig_bits = dai->driver->capture.sig_bits;
params->state = GBAUDIO_CODEC_HWPARAMS;
params->format = format;
params->rate = rate;
params->channels = channels;
params->sig_bits = sig_bits;
mutex_unlock(&codec->lock);
return 0;
}
static int gbcodec_prepare(struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
int ret;
struct gbaudio_module_info *module = NULL, *iter;
struct gbaudio_data_connection *data;
struct gb_bundle *bundle;
struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
struct gbaudio_stream_params *params;
mutex_lock(&codec->lock);
if (list_empty(&codec->module_list)) {
dev_err(codec->dev, "No codec module available\n");
mutex_unlock(&codec->lock);
return -ENODEV;
}
list_for_each_entry(iter, &codec->module_list, list) {
/* find the dai */
data = find_data(iter, dai->id);
if (data) {
module = iter;
break;
}
}
if (!data) {
dev_err(dai->dev, "DATA connection missing\n");
mutex_unlock(&codec->lock);
return -ENODEV;
}
params = find_dai_stream_params(codec, dai->id, substream->stream);
if (!params) {
dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
mutex_unlock(&codec->lock);
return -EINVAL;
}
bundle = to_gb_bundle(module->dev);
ret = gb_pm_runtime_get_sync(bundle);
if (ret) {
mutex_unlock(&codec->lock);
return ret;
}
switch (substream->stream) {
case SNDRV_PCM_STREAM_PLAYBACK:
ret = gb_audio_apbridgea_set_tx_data_size(data->connection, 0, 192);
break;
case SNDRV_PCM_STREAM_CAPTURE:
ret = gb_audio_apbridgea_set_rx_data_size(data->connection, 0, 192);
break;
}
if (ret) {
gb_pm_runtime_put_noidle(bundle);
mutex_unlock(&codec->lock);
dev_err_ratelimited(dai->dev, "set_data_size failed:%d\n", ret);
return ret;
}
gb_pm_runtime_put_noidle(bundle);
params->state = GBAUDIO_CODEC_PREPARE;
mutex_unlock(&codec->lock);
return 0;
}
static int gbcodec_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
{
int ret;
struct gbaudio_data_connection *data;
struct gbaudio_module_info *module = NULL, *iter;
struct gb_bundle *bundle;
struct gbaudio_codec_info *codec = dev_get_drvdata(dai->dev);
struct gbaudio_stream_params *params;
dev_dbg(dai->dev, "Mute:%d, Direction:%s\n", mute,
stream ? "CAPTURE" : "PLAYBACK");
mutex_lock(&codec->lock);
params = find_dai_stream_params(codec, dai->id, stream);
if (!params) {
dev_err(codec->dev, "Failed to fetch dai_stream pointer\n");
mutex_unlock(&codec->lock);
return -EINVAL;
}
if (list_empty(&codec->module_list)) {
dev_err(codec->dev, "No codec module available\n");
if (mute) {
params->state = GBAUDIO_CODEC_STOP;
ret = 0;
} else {
ret = -ENODEV;
}
mutex_unlock(&codec->lock);
return ret;
}
list_for_each_entry(iter, &codec->module_list, list) {
/* find the dai */
data = find_data(iter, dai->id);
if (data) {
module = iter;
break;
}
}
if (!data) {
dev_err(dai->dev, "%s DATA connection missing\n",
dai->name);
mutex_unlock(&codec->lock);
return -ENODEV;
}
bundle = to_gb_bundle(module->dev);
ret = gb_pm_runtime_get_sync(bundle);
if (ret) {
mutex_unlock(&codec->lock);
return ret;
}
if (!mute && !stream) {/* start playback */
ret = gb_audio_apbridgea_prepare_tx(data->connection, 0);
if (!ret)
ret = gb_audio_apbridgea_start_tx(data->connection, 0, 0);
params->state = GBAUDIO_CODEC_START;
} else if (!mute && stream) {/* start capture */
ret = gb_audio_apbridgea_prepare_rx(data->connection, 0);
if (!ret)
ret = gb_audio_apbridgea_start_rx(data->connection, 0);
params->state = GBAUDIO_CODEC_START;
} else if (mute && !stream) {/* stop playback */
ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
if (!ret)
ret = gb_audio_apbridgea_shutdown_tx(data->connection, 0);
params->state = GBAUDIO_CODEC_STOP;
} else if (mute && stream) {/* stop capture */
ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
if (!ret)
ret = gb_audio_apbridgea_shutdown_rx(data->connection, 0);
params->state = GBAUDIO_CODEC_STOP;
} else {
ret = -EINVAL;
}
if (ret)
dev_err_ratelimited(dai->dev,
"%s:Error during %s %s stream:%d\n",
module->name, mute ? "Mute" : "Unmute",
stream ? "Capture" : "Playback", ret);
gb_pm_runtime_put_noidle(bundle);
mutex_unlock(&codec->lock);
return ret;
}
static const struct snd_soc_dai_ops gbcodec_dai_ops = {
.startup = gbcodec_startup,
.shutdown = gbcodec_shutdown,
.hw_params = gbcodec_hw_params,
.prepare = gbcodec_prepare,
.mute_stream = gbcodec_mute_stream,
};
static struct snd_soc_dai_driver gbaudio_dai[] = {
{
.name = "apb-i2s0",
.id = 0,
.playback = {
.stream_name = "I2S 0 Playback",
.rates = SNDRV_PCM_RATE_48000,
.formats = SNDRV_PCM_FMTBIT_S16_LE,
.rate_max = 48000,
.rate_min = 48000,
.channels_min = 1,
.channels_max = 2,
.sig_bits = 16,
},
.capture = {
.stream_name = "I2S 0 Capture",
.rates = SNDRV_PCM_RATE_48000,
.formats = SNDRV_PCM_FMTBIT_S16_LE,
.rate_max = 48000,
.rate_min = 48000,
.channels_min = 1,
.channels_max = 2,
.sig_bits = 16,
},
.ops = &gbcodec_dai_ops,
},
};
static int gbaudio_init_jack(struct gbaudio_module_info *module,
struct snd_soc_card *card)
{
int ret;
struct gbaudio_jack *jack, *n;
struct snd_soc_jack_pin *headset, *button;
if (!module->jack_mask)
return 0;
snprintf(module->jack_name, NAME_SIZE, "GB %d Headset Jack",
module->dev_id);
headset = devm_kzalloc(module->dev, sizeof(*headset), GFP_KERNEL);
if (!headset)
return -ENOMEM;
headset->pin = module->jack_name;
headset->mask = module->jack_mask;
ret = snd_soc_card_jack_new_pins(card, module->jack_name,
module->jack_mask,
&module->headset.jack, headset, 1);
if (ret) {
dev_err(module->dev, "Failed to create new jack\n");
return ret;
}
/* Add to module's jack list */
list_add(&module->headset.list, &module->jack_list);
if (!module->button_mask)
return 0;
snprintf(module->button_name, NAME_SIZE, "GB %d Button Jack",
module->dev_id);
button = devm_kzalloc(module->dev, sizeof(*button), GFP_KERNEL);
if (!button) {
ret = -ENOMEM;
goto free_jacks;
}
button->pin = module->button_name;
button->mask = module->button_mask;
ret = snd_soc_card_jack_new_pins(card, module->button_name,
module->button_mask,
&module->button.jack,
button, 1);
if (ret) {
dev_err(module->dev, "Failed to create button jack\n");
goto free_jacks;
}
/* Add to module's jack list */
list_add(&module->button.list, &module->jack_list);
/*
* Currently, max 4 buttons are supported with following key mapping
* BTN_0 = KEY_MEDIA
* BTN_1 = KEY_VOICECOMMAND
* BTN_2 = KEY_VOLUMEUP
* BTN_3 = KEY_VOLUMEDOWN
*/
if (module->button_mask & SND_JACK_BTN_0) {
ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_0,
KEY_MEDIA);
if (ret) {
dev_err(module->dev, "Failed to set BTN_0\n");
goto free_jacks;
}
}
if (module->button_mask & SND_JACK_BTN_1) {
ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_1,
KEY_VOICECOMMAND);
if (ret) {
dev_err(module->dev, "Failed to set BTN_1\n");
goto free_jacks;
}
}
if (module->button_mask & SND_JACK_BTN_2) {
ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_2,
KEY_VOLUMEUP);
if (ret) {
dev_err(module->dev, "Failed to set BTN_2\n");
goto free_jacks;
}
}
if (module->button_mask & SND_JACK_BTN_3) {
ret = snd_jack_set_key(module->button.jack.jack, SND_JACK_BTN_3,
KEY_VOLUMEDOWN);
if (ret) {
dev_err(module->dev, "Failed to set BTN_0\n");
goto free_jacks;
}
}
/* FIXME
* verify if this is really required
set_bit(INPUT_PROP_NO_DUMMY_RELEASE,
module->button.jack.jack->input_dev->propbit);
*/
return 0;
free_jacks:
list_for_each_entry_safe(jack, n, &module->jack_list, list) {
snd_device_free(card->snd_card, jack->jack.jack);
list_del(&jack->list);
}
return ret;
}
int gbaudio_register_module(struct gbaudio_module_info *module)
{
int ret;
struct snd_soc_component *comp;
struct gbaudio_jack *jack = NULL;
if (!gbcodec) {
dev_err(module->dev, "GB Codec not yet probed\n");
return -EAGAIN;
}
comp = gbcodec->component;
mutex_lock(&gbcodec->register_mutex);
if (module->num_dais) {
dev_err(gbcodec->dev,
"%d:DAIs not supported via gbcodec driver\n",
module->num_dais);
mutex_unlock(&gbcodec->register_mutex);
return -EINVAL;
}
ret = gbaudio_init_jack(module, comp->card);
if (ret) {
mutex_unlock(&gbcodec->register_mutex);
return ret;
}
if (module->dapm_widgets)
snd_soc_dapm_new_controls(&comp->dapm, module->dapm_widgets,
module->num_dapm_widgets);
if (module->controls)
snd_soc_add_component_controls(comp, module->controls,
module->num_controls);
if (module->dapm_routes)
snd_soc_dapm_add_routes(&comp->dapm, module->dapm_routes,
module->num_dapm_routes);
/* card already instantiated, create widgets here only */
if (comp->card->instantiated) {
gbaudio_dapm_link_component_dai_widgets(comp->card, &comp->dapm);
#ifdef CONFIG_SND_JACK
/*
* register jack devices for this module
* from codec->jack_list
*/
list_for_each_entry(jack, &module->jack_list, list) {
snd_device_register(comp->card->snd_card,
jack->jack.jack);
}
#endif
}
mutex_lock(&gbcodec->lock);
list_add(&module->list, &gbcodec->module_list);
mutex_unlock(&gbcodec->lock);
if (comp->card->instantiated)
ret = snd_soc_dapm_new_widgets(comp->card);
dev_dbg(comp->dev, "Registered %s module\n", module->name);
mutex_unlock(&gbcodec->register_mutex);
return ret;
}
EXPORT_SYMBOL(gbaudio_register_module);
static void gbaudio_codec_clean_data_tx(struct gbaudio_data_connection *data)
{
u16 i2s_port, cportid;
int ret;
if (list_is_singular(&gbcodec->module_list)) {
ret = gb_audio_apbridgea_stop_tx(data->connection, 0);
if (ret)
return;
ret = gb_audio_apbridgea_shutdown_tx(data->connection, 0);
if (ret)
return;
}
i2s_port = 0; /* fixed for now */
cportid = data->connection->hd_cport_id;
ret = gb_audio_apbridgea_unregister_cport(data->connection,
i2s_port, cportid,
AUDIO_APBRIDGEA_DIRECTION_TX);
data->state[0] = GBAUDIO_CODEC_SHUTDOWN;
}
static void gbaudio_codec_clean_data_rx(struct gbaudio_data_connection *data)
{
u16 i2s_port, cportid;
int ret;
if (list_is_singular(&gbcodec->module_list)) {
ret = gb_audio_apbridgea_stop_rx(data->connection, 0);
if (ret)
return;
ret = gb_audio_apbridgea_shutdown_rx(data->connection, 0);
if (ret)
return;
}
i2s_port = 0; /* fixed for now */
cportid = data->connection->hd_cport_id;
ret = gb_audio_apbridgea_unregister_cport(data->connection,
i2s_port, cportid,
AUDIO_APBRIDGEA_DIRECTION_RX);
data->state[1] = GBAUDIO_CODEC_SHUTDOWN;
}
static void gbaudio_codec_cleanup(struct gbaudio_module_info *module)
{
struct gbaudio_data_connection *data;
int pb_state, cap_state;
dev_dbg(gbcodec->dev, "%s: removed, cleanup APBridge\n", module->name);
list_for_each_entry(data, &module->data_list, list) {
pb_state = data->state[0];
cap_state = data->state[1];
if (pb_state > GBAUDIO_CODEC_SHUTDOWN)
gbaudio_codec_clean_data_tx(data);
if (cap_state > GBAUDIO_CODEC_SHUTDOWN)
gbaudio_codec_clean_data_rx(data);
}
}
void gbaudio_unregister_module(struct gbaudio_module_info *module)
{
struct snd_soc_component *comp = gbcodec->component;
struct gbaudio_jack *jack, *n;
int mask;
dev_dbg(comp->dev, "Unregister %s module\n", module->name);
mutex_lock(&gbcodec->register_mutex);
mutex_lock(&gbcodec->lock);
gbaudio_codec_cleanup(module);
list_del(&module->list);
dev_dbg(comp->dev, "Process Unregister %s module\n", module->name);
mutex_unlock(&gbcodec->lock);
#ifdef CONFIG_SND_JACK
/* free jack devices for this module jack_list */
list_for_each_entry_safe(jack, n, &module->jack_list, list) {
if (jack == &module->headset)
mask = GBCODEC_JACK_MASK;
else if (jack == &module->button)
mask = GBCODEC_JACK_BUTTON_MASK;
else
mask = 0;
if (mask) {
dev_dbg(module->dev, "Report %s removal\n",
jack->jack.jack->id);
snd_soc_jack_report(&jack->jack, 0, mask);
snd_device_free(comp->card->snd_card,
jack->jack.jack);
list_del(&jack->list);
}
}
#endif
if (module->dapm_routes) {
dev_dbg(comp->dev, "Removing %d routes\n",
module->num_dapm_routes);
snd_soc_dapm_del_routes(&comp->dapm, module->dapm_routes,
module->num_dapm_routes);
}
if (module->controls) {
dev_dbg(comp->dev, "Removing %d controls\n",
module->num_controls);
/* release control semaphore */
gbaudio_remove_component_controls(comp, module->controls,
module->num_controls);
}
if (module->dapm_widgets) {
dev_dbg(comp->dev, "Removing %d widgets\n",
module->num_dapm_widgets);
gbaudio_dapm_free_controls(&comp->dapm, module->dapm_widgets,
module->num_dapm_widgets);
}
dev_dbg(comp->dev, "Unregistered %s module\n", module->name);
mutex_unlock(&gbcodec->register_mutex);
}
EXPORT_SYMBOL(gbaudio_unregister_module);
/*
* component driver ops
*/
static int gbcodec_probe(struct snd_soc_component *comp)
{
int i;
struct gbaudio_codec_info *info;
struct gbaudio_codec_dai *dai;
info = devm_kzalloc(comp->dev, sizeof(*info), GFP_KERNEL);
if (!info)
return -ENOMEM;
info->dev = comp->dev;
INIT_LIST_HEAD(&info->module_list);
mutex_init(&info->lock);
mutex_init(&info->register_mutex);
INIT_LIST_HEAD(&info->dai_list);
/* init dai_list used to maintain runtime stream info */
for (i = 0; i < ARRAY_SIZE(gbaudio_dai); i++) {
dai = devm_kzalloc(comp->dev, sizeof(*dai), GFP_KERNEL);
if (!dai)
return -ENOMEM;
dai->id = gbaudio_dai[i].id;
list_add(&dai->list, &info->dai_list);
}
info->component = comp;
snd_soc_component_set_drvdata(comp, info);
gbcodec = info;
device_init_wakeup(comp->dev, 1);
return 0;
}
static int gbcodec_write(struct snd_soc_component *comp, unsigned int reg,
unsigned int value)
{
return 0;
}
static unsigned int gbcodec_read(struct snd_soc_component *comp,
unsigned int reg)
{
return 0;
}
static const struct snd_soc_component_driver soc_codec_dev_gbaudio = {
.probe = gbcodec_probe,
.read = gbcodec_read,
.write = gbcodec_write,
};
#ifdef CONFIG_PM
static int gbaudio_codec_suspend(struct device *dev)
{
dev_dbg(dev, "%s: suspend\n", __func__);
return 0;
}
static int gbaudio_codec_resume(struct device *dev)
{
dev_dbg(dev, "%s: resume\n", __func__);
return 0;
}
static const struct dev_pm_ops gbaudio_codec_pm_ops = {
.suspend = gbaudio_codec_suspend,
.resume = gbaudio_codec_resume,
};
#endif
static int gbaudio_codec_probe(struct platform_device *pdev)
{
return devm_snd_soc_register_component(&pdev->dev,
&soc_codec_dev_gbaudio,
gbaudio_dai, ARRAY_SIZE(gbaudio_dai));
}
static const struct of_device_id greybus_asoc_machine_of_match[] = {
{ .compatible = "toshiba,apb-dummy-codec", },
{},
};
static struct platform_driver gbaudio_codec_driver = {
.driver = {
.name = "apb-dummy-codec",
#ifdef CONFIG_PM
.pm = &gbaudio_codec_pm_ops,
#endif
.of_match_table = greybus_asoc_machine_of_match,
},
.probe = gbaudio_codec_probe,
};
module_platform_driver(gbaudio_codec_driver);
MODULE_DESCRIPTION("APBridge ALSA SoC dummy codec driver");
MODULE_AUTHOR("Vaibhav Agarwal <[email protected]>");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:apb-dummy-codec");
| linux-master | drivers/staging/greybus/audio_codec.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Arche Platform driver to control APB.
*
* Copyright 2014-2015 Google Inc.
* Copyright 2014-2015 Linaro Ltd.
*/
#include <linux/clk.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/interrupt.h>
#include <linux/of_irq.h>
#include <linux/module.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/pm.h>
#include <linux/regulator/consumer.h>
#include <linux/spinlock.h>
#include "arche_platform.h"
static void apb_bootret_deassert(struct device *dev);
struct arche_apb_ctrl_drvdata {
/* Control GPIO signals to and from AP <=> AP Bridges */
struct gpio_desc *resetn;
struct gpio_desc *boot_ret;
struct gpio_desc *pwroff;
struct gpio_desc *wake_in;
struct gpio_desc *wake_out;
struct gpio_desc *pwrdn;
enum arche_platform_state state;
bool init_disabled;
struct regulator *vcore;
struct regulator *vio;
struct gpio_desc *clk_en;
struct clk *clk;
struct pinctrl *pinctrl;
struct pinctrl_state *pin_default;
/* V2: SPI Bus control */
struct gpio_desc *spi_en;
bool spi_en_polarity_high;
};
/*
* Note that these low level api's are active high
*/
static inline void deassert_reset(struct gpio_desc *gpio)
{
gpiod_set_raw_value(gpio, 1);
}
static inline void assert_reset(struct gpio_desc *gpio)
{
gpiod_set_raw_value(gpio, 0);
}
/*
* Note: Please do not modify the below sequence, as it is as per the spec
*/
static int coldboot_seq(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
int ret;
if (apb->init_disabled ||
apb->state == ARCHE_PLATFORM_STATE_ACTIVE)
return 0;
/* Hold APB in reset state */
assert_reset(apb->resetn);
if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING && apb->spi_en)
devm_gpiod_put(dev, apb->spi_en);
/* Enable power to APB */
if (!IS_ERR(apb->vcore)) {
ret = regulator_enable(apb->vcore);
if (ret) {
dev_err(dev, "failed to enable core regulator\n");
return ret;
}
}
if (!IS_ERR(apb->vio)) {
ret = regulator_enable(apb->vio);
if (ret) {
dev_err(dev, "failed to enable IO regulator\n");
return ret;
}
}
apb_bootret_deassert(dev);
/* On DB3 clock was not mandatory */
if (apb->clk_en)
gpiod_set_value(apb->clk_en, 1);
usleep_range(100, 200);
/* deassert reset to APB : Active-low signal */
deassert_reset(apb->resetn);
apb->state = ARCHE_PLATFORM_STATE_ACTIVE;
return 0;
}
static int fw_flashing_seq(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
int ret;
if (apb->init_disabled ||
apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING)
return 0;
ret = regulator_enable(apb->vcore);
if (ret) {
dev_err(dev, "failed to enable core regulator\n");
return ret;
}
ret = regulator_enable(apb->vio);
if (ret) {
dev_err(dev, "failed to enable IO regulator\n");
return ret;
}
if (apb->spi_en) {
unsigned long flags;
if (apb->spi_en_polarity_high)
flags = GPIOD_OUT_HIGH;
else
flags = GPIOD_OUT_LOW;
apb->spi_en = devm_gpiod_get(dev, "spi-en", flags);
if (IS_ERR(apb->spi_en)) {
ret = PTR_ERR(apb->spi_en);
dev_err(dev, "Failed requesting SPI bus en GPIO: %d\n",
ret);
return ret;
}
}
/* for flashing device should be in reset state */
assert_reset(apb->resetn);
apb->state = ARCHE_PLATFORM_STATE_FW_FLASHING;
return 0;
}
static int standby_boot_seq(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
if (apb->init_disabled)
return 0;
/*
* Even if it is in OFF state,
* then we do not want to change the state
*/
if (apb->state == ARCHE_PLATFORM_STATE_STANDBY ||
apb->state == ARCHE_PLATFORM_STATE_OFF)
return 0;
if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING && apb->spi_en)
devm_gpiod_put(dev, apb->spi_en);
/*
* As per WDM spec, do nothing
*
* Pasted from WDM spec,
* - A falling edge on POWEROFF_L is detected (a)
* - WDM enters standby mode, but no output signals are changed
*/
/* TODO: POWEROFF_L is input to WDM module */
apb->state = ARCHE_PLATFORM_STATE_STANDBY;
return 0;
}
static void poweroff_seq(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
if (apb->init_disabled || apb->state == ARCHE_PLATFORM_STATE_OFF)
return;
if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING && apb->spi_en)
devm_gpiod_put(dev, apb->spi_en);
/* disable the clock */
if (apb->clk_en)
gpiod_set_value(apb->clk_en, 0);
if (!IS_ERR(apb->vcore) && regulator_is_enabled(apb->vcore) > 0)
regulator_disable(apb->vcore);
if (!IS_ERR(apb->vio) && regulator_is_enabled(apb->vio) > 0)
regulator_disable(apb->vio);
/* As part of exit, put APB back in reset state */
assert_reset(apb->resetn);
apb->state = ARCHE_PLATFORM_STATE_OFF;
/* TODO: May have to send an event to SVC about this exit */
}
static void apb_bootret_deassert(struct device *dev)
{
struct arche_apb_ctrl_drvdata *apb = dev_get_drvdata(dev);
gpiod_set_value(apb->boot_ret, 0);
}
int apb_ctrl_coldboot(struct device *dev)
{
return coldboot_seq(to_platform_device(dev));
}
int apb_ctrl_fw_flashing(struct device *dev)
{
return fw_flashing_seq(to_platform_device(dev));
}
int apb_ctrl_standby_boot(struct device *dev)
{
return standby_boot_seq(to_platform_device(dev));
}
void apb_ctrl_poweroff(struct device *dev)
{
poweroff_seq(to_platform_device(dev));
}
static ssize_t state_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct platform_device *pdev = to_platform_device(dev);
struct arche_apb_ctrl_drvdata *apb = platform_get_drvdata(pdev);
int ret = 0;
bool is_disabled;
if (sysfs_streq(buf, "off")) {
if (apb->state == ARCHE_PLATFORM_STATE_OFF)
return count;
poweroff_seq(pdev);
} else if (sysfs_streq(buf, "active")) {
if (apb->state == ARCHE_PLATFORM_STATE_ACTIVE)
return count;
poweroff_seq(pdev);
is_disabled = apb->init_disabled;
apb->init_disabled = false;
ret = coldboot_seq(pdev);
if (ret)
apb->init_disabled = is_disabled;
} else if (sysfs_streq(buf, "standby")) {
if (apb->state == ARCHE_PLATFORM_STATE_STANDBY)
return count;
ret = standby_boot_seq(pdev);
} else if (sysfs_streq(buf, "fw_flashing")) {
if (apb->state == ARCHE_PLATFORM_STATE_FW_FLASHING)
return count;
/*
* First we want to make sure we power off everything
* and then enter FW flashing state
*/
poweroff_seq(pdev);
ret = fw_flashing_seq(pdev);
} else {
dev_err(dev, "unknown state\n");
ret = -EINVAL;
}
return ret ? ret : count;
}
static ssize_t state_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct arche_apb_ctrl_drvdata *apb = dev_get_drvdata(dev);
switch (apb->state) {
case ARCHE_PLATFORM_STATE_OFF:
return sprintf(buf, "off%s\n",
apb->init_disabled ? ",disabled" : "");
case ARCHE_PLATFORM_STATE_ACTIVE:
return sprintf(buf, "active\n");
case ARCHE_PLATFORM_STATE_STANDBY:
return sprintf(buf, "standby\n");
case ARCHE_PLATFORM_STATE_FW_FLASHING:
return sprintf(buf, "fw_flashing\n");
default:
return sprintf(buf, "unknown state\n");
}
}
static DEVICE_ATTR_RW(state);
static int apb_ctrl_get_devtree_data(struct platform_device *pdev,
struct arche_apb_ctrl_drvdata *apb)
{
struct device *dev = &pdev->dev;
int ret;
apb->resetn = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW);
if (IS_ERR(apb->resetn)) {
ret = PTR_ERR(apb->resetn);
dev_err(dev, "Failed requesting reset GPIO: %d\n", ret);
return ret;
}
apb->boot_ret = devm_gpiod_get(dev, "boot-ret", GPIOD_OUT_LOW);
if (IS_ERR(apb->boot_ret)) {
ret = PTR_ERR(apb->boot_ret);
dev_err(dev, "Failed requesting bootret GPIO: %d\n", ret);
return ret;
}
/* It's not mandatory to support power management interface */
apb->pwroff = devm_gpiod_get_optional(dev, "pwr-off", GPIOD_IN);
if (IS_ERR(apb->pwroff)) {
ret = PTR_ERR(apb->pwroff);
dev_err(dev, "Failed requesting pwroff_n GPIO: %d\n", ret);
return ret;
}
/* Do not make clock mandatory as of now (for DB3) */
apb->clk_en = devm_gpiod_get_optional(dev, "clock-en", GPIOD_OUT_LOW);
if (IS_ERR(apb->clk_en)) {
ret = PTR_ERR(apb->clk_en);
dev_err(dev, "Failed requesting APB clock en GPIO: %d\n", ret);
return ret;
}
apb->pwrdn = devm_gpiod_get(dev, "pwr-down", GPIOD_OUT_LOW);
if (IS_ERR(apb->pwrdn)) {
ret = PTR_ERR(apb->pwrdn);
dev_warn(dev, "Failed requesting power down GPIO: %d\n", ret);
return ret;
}
/* Regulators are optional, as we may have fixed supply coming in */
apb->vcore = devm_regulator_get(dev, "vcore");
if (IS_ERR(apb->vcore))
dev_warn(dev, "no core regulator found\n");
apb->vio = devm_regulator_get(dev, "vio");
if (IS_ERR(apb->vio))
dev_warn(dev, "no IO regulator found\n");
apb->pinctrl = devm_pinctrl_get(&pdev->dev);
if (IS_ERR(apb->pinctrl)) {
dev_err(&pdev->dev, "could not get pinctrl handle\n");
return PTR_ERR(apb->pinctrl);
}
apb->pin_default = pinctrl_lookup_state(apb->pinctrl, "default");
if (IS_ERR(apb->pin_default)) {
dev_err(&pdev->dev, "could not get default pin state\n");
return PTR_ERR(apb->pin_default);
}
/* Only applicable for platform >= V2 */
if (of_property_read_bool(pdev->dev.of_node, "gb,spi-en-active-high"))
apb->spi_en_polarity_high = true;
return 0;
}
static int arche_apb_ctrl_probe(struct platform_device *pdev)
{
int ret;
struct arche_apb_ctrl_drvdata *apb;
struct device *dev = &pdev->dev;
apb = devm_kzalloc(&pdev->dev, sizeof(*apb), GFP_KERNEL);
if (!apb)
return -ENOMEM;
ret = apb_ctrl_get_devtree_data(pdev, apb);
if (ret) {
dev_err(dev, "failed to get apb devicetree data %d\n", ret);
return ret;
}
/* Initially set APB to OFF state */
apb->state = ARCHE_PLATFORM_STATE_OFF;
/* Check whether device needs to be enabled on boot */
if (of_property_read_bool(pdev->dev.of_node, "arche,init-disable"))
apb->init_disabled = true;
platform_set_drvdata(pdev, apb);
/* Create sysfs interface to allow user to change state dynamically */
ret = device_create_file(dev, &dev_attr_state);
if (ret) {
dev_err(dev, "failed to create state file in sysfs\n");
return ret;
}
dev_info(&pdev->dev, "Device registered successfully\n");
return 0;
}
static void arche_apb_ctrl_remove(struct platform_device *pdev)
{
device_remove_file(&pdev->dev, &dev_attr_state);
poweroff_seq(pdev);
platform_set_drvdata(pdev, NULL);
}
static int __maybe_unused arche_apb_ctrl_suspend(struct device *dev)
{
/*
* If timing profile permits, we may shutdown bridge
* completely
*
* TODO: sequence ??
*
* Also, need to make sure we meet precondition for unipro suspend
* Precondition: Definition ???
*/
return 0;
}
static int __maybe_unused arche_apb_ctrl_resume(struct device *dev)
{
/*
* At least for ES2 we have to meet the delay requirement between
* unipro switch and AP bridge init, depending on whether bridge is in
* OFF state or standby state.
*
* Based on whether bridge is in standby or OFF state we may have to
* assert multiple signals. Please refer to WDM spec, for more info.
*
*/
return 0;
}
static void arche_apb_ctrl_shutdown(struct platform_device *pdev)
{
apb_ctrl_poweroff(&pdev->dev);
}
static SIMPLE_DEV_PM_OPS(arche_apb_ctrl_pm_ops, arche_apb_ctrl_suspend,
arche_apb_ctrl_resume);
static const struct of_device_id arche_apb_ctrl_of_match[] = {
{ .compatible = "usbffff,2", },
{ },
};
static struct platform_driver arche_apb_ctrl_device_driver = {
.probe = arche_apb_ctrl_probe,
.remove_new = arche_apb_ctrl_remove,
.shutdown = arche_apb_ctrl_shutdown,
.driver = {
.name = "arche-apb-ctrl",
.pm = &arche_apb_ctrl_pm_ops,
.of_match_table = arche_apb_ctrl_of_match,
}
};
int __init arche_apb_init(void)
{
return platform_driver_register(&arche_apb_ctrl_device_driver);
}
void __exit arche_apb_exit(void)
{
platform_driver_unregister(&arche_apb_ctrl_device_driver);
}
| linux-master | drivers/staging/greybus/arche-apb-ctrl.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus operations
*
* Copyright 2015-2016 Google Inc.
*/
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/spinlock.h>
#include <linux/idr.h>
#include "audio_manager.h"
#include "audio_manager_private.h"
static struct kset *manager_kset;
static LIST_HEAD(modules_list);
static DECLARE_RWSEM(modules_rwsem);
static DEFINE_IDA(module_id);
/* helpers */
static struct gb_audio_manager_module *gb_audio_manager_get_locked(int id)
{
struct gb_audio_manager_module *module;
if (id < 0)
return NULL;
list_for_each_entry(module, &modules_list, list) {
if (module->id == id)
return module;
}
return NULL;
}
/* public API */
int gb_audio_manager_add(struct gb_audio_manager_module_descriptor *desc)
{
struct gb_audio_manager_module *module;
int id;
int err;
id = ida_simple_get(&module_id, 0, 0, GFP_KERNEL);
if (id < 0)
return id;
err = gb_audio_manager_module_create(&module, manager_kset,
id, desc);
if (err) {
ida_simple_remove(&module_id, id);
return err;
}
/* Add it to the list */
down_write(&modules_rwsem);
list_add_tail(&module->list, &modules_list);
up_write(&modules_rwsem);
return module->id;
}
EXPORT_SYMBOL_GPL(gb_audio_manager_add);
int gb_audio_manager_remove(int id)
{
struct gb_audio_manager_module *module;
down_write(&modules_rwsem);
module = gb_audio_manager_get_locked(id);
if (!module) {
up_write(&modules_rwsem);
return -EINVAL;
}
list_del(&module->list);
kobject_put(&module->kobj);
up_write(&modules_rwsem);
ida_simple_remove(&module_id, id);
return 0;
}
EXPORT_SYMBOL_GPL(gb_audio_manager_remove);
void gb_audio_manager_remove_all(void)
{
struct gb_audio_manager_module *module, *next;
int is_empty;
down_write(&modules_rwsem);
list_for_each_entry_safe(module, next, &modules_list, list) {
list_del(&module->list);
ida_simple_remove(&module_id, module->id);
kobject_put(&module->kobj);
}
is_empty = list_empty(&modules_list);
up_write(&modules_rwsem);
if (!is_empty)
pr_warn("Not all nodes were deleted\n");
}
EXPORT_SYMBOL_GPL(gb_audio_manager_remove_all);
struct gb_audio_manager_module *gb_audio_manager_get_module(int id)
{
struct gb_audio_manager_module *module;
down_read(&modules_rwsem);
module = gb_audio_manager_get_locked(id);
kobject_get(&module->kobj);
up_read(&modules_rwsem);
return module;
}
EXPORT_SYMBOL_GPL(gb_audio_manager_get_module);
void gb_audio_manager_put_module(struct gb_audio_manager_module *module)
{
kobject_put(&module->kobj);
}
EXPORT_SYMBOL_GPL(gb_audio_manager_put_module);
int gb_audio_manager_dump_module(int id)
{
struct gb_audio_manager_module *module;
down_read(&modules_rwsem);
module = gb_audio_manager_get_locked(id);
up_read(&modules_rwsem);
if (!module)
return -EINVAL;
gb_audio_manager_module_dump(module);
return 0;
}
EXPORT_SYMBOL_GPL(gb_audio_manager_dump_module);
void gb_audio_manager_dump_all(void)
{
struct gb_audio_manager_module *module;
int count = 0;
down_read(&modules_rwsem);
list_for_each_entry(module, &modules_list, list) {
gb_audio_manager_module_dump(module);
count++;
}
up_read(&modules_rwsem);
pr_info("Number of connected modules: %d\n", count);
}
EXPORT_SYMBOL_GPL(gb_audio_manager_dump_all);
/*
* module init/deinit
*/
static int __init manager_init(void)
{
manager_kset = kset_create_and_add(GB_AUDIO_MANAGER_NAME, NULL,
kernel_kobj);
if (!manager_kset)
return -ENOMEM;
#ifdef GB_AUDIO_MANAGER_SYSFS
gb_audio_manager_sysfs_init(&manager_kset->kobj);
#endif
return 0;
}
static void __exit manager_exit(void)
{
gb_audio_manager_remove_all();
kset_unregister(manager_kset);
ida_destroy(&module_id);
}
module_init(manager_init);
module_exit(manager_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Svetlin Ankov <[email protected]>");
| linux-master | drivers/staging/greybus/audio_manager.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Loopback bridge driver for the Greybus loopback module.
*
* Copyright 2014 Google Inc.
* Copyright 2014 Linaro Ltd.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/slab.h>
#include <linux/kthread.h>
#include <linux/delay.h>
#include <linux/random.h>
#include <linux/sizes.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/kfifo.h>
#include <linux/debugfs.h>
#include <linux/list_sort.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
#include <linux/atomic.h>
#include <linux/pm_runtime.h>
#include <linux/greybus.h>
#include <asm/div64.h>
#define NSEC_PER_DAY 86400000000000ULL
struct gb_loopback_stats {
u32 min;
u32 max;
u64 sum;
u32 count;
};
struct gb_loopback_device {
struct dentry *root;
u32 count;
size_t size_max;
/* We need to take a lock in atomic context */
spinlock_t lock;
wait_queue_head_t wq;
};
static struct gb_loopback_device gb_dev;
struct gb_loopback_async_operation {
struct gb_loopback *gb;
struct gb_operation *operation;
ktime_t ts;
int (*completion)(struct gb_loopback_async_operation *op_async);
};
struct gb_loopback {
struct gb_connection *connection;
struct dentry *file;
struct kfifo kfifo_lat;
struct mutex mutex;
struct task_struct *task;
struct device *dev;
wait_queue_head_t wq;
wait_queue_head_t wq_completion;
atomic_t outstanding_operations;
/* Per connection stats */
ktime_t ts;
struct gb_loopback_stats latency;
struct gb_loopback_stats throughput;
struct gb_loopback_stats requests_per_second;
struct gb_loopback_stats apbridge_unipro_latency;
struct gb_loopback_stats gbphy_firmware_latency;
int type;
int async;
int id;
u32 size;
u32 iteration_max;
u32 iteration_count;
int us_wait;
u32 error;
u32 requests_completed;
u32 requests_timedout;
u32 timeout;
u32 jiffy_timeout;
u32 timeout_min;
u32 timeout_max;
u32 outstanding_operations_max;
u64 elapsed_nsecs;
u32 apbridge_latency_ts;
u32 gbphy_latency_ts;
u32 send_count;
};
static struct class loopback_class = {
.name = "gb_loopback",
};
static DEFINE_IDA(loopback_ida);
/* Min/max values in jiffies */
#define GB_LOOPBACK_TIMEOUT_MIN 1
#define GB_LOOPBACK_TIMEOUT_MAX 10000
#define GB_LOOPBACK_FIFO_DEFAULT 8192
static unsigned int kfifo_depth = GB_LOOPBACK_FIFO_DEFAULT;
module_param(kfifo_depth, uint, 0444);
/* Maximum size of any one send data buffer we support */
#define MAX_PACKET_SIZE (PAGE_SIZE * 2)
#define GB_LOOPBACK_US_WAIT_MAX 1000000
/* interface sysfs attributes */
#define gb_loopback_ro_attr(field) \
static ssize_t field##_show(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
struct gb_loopback *gb = dev_get_drvdata(dev); \
return sprintf(buf, "%u\n", gb->field); \
} \
static DEVICE_ATTR_RO(field)
#define gb_loopback_ro_stats_attr(name, field, type) \
static ssize_t name##_##field##_show(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
struct gb_loopback *gb = dev_get_drvdata(dev); \
/* Report 0 for min and max if no transfer succeeded */ \
if (!gb->requests_completed) \
return sprintf(buf, "0\n"); \
return sprintf(buf, "%" #type "\n", gb->name.field); \
} \
static DEVICE_ATTR_RO(name##_##field)
#define gb_loopback_ro_avg_attr(name) \
static ssize_t name##_avg_show(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
struct gb_loopback_stats *stats; \
struct gb_loopback *gb; \
u64 avg, rem; \
u32 count; \
gb = dev_get_drvdata(dev); \
stats = &gb->name; \
count = stats->count ? stats->count : 1; \
avg = stats->sum + count / 2000000; /* round closest */ \
rem = do_div(avg, count); \
rem *= 1000000; \
do_div(rem, count); \
return sprintf(buf, "%llu.%06u\n", avg, (u32)rem); \
} \
static DEVICE_ATTR_RO(name##_avg)
#define gb_loopback_stats_attrs(field) \
gb_loopback_ro_stats_attr(field, min, u); \
gb_loopback_ro_stats_attr(field, max, u); \
gb_loopback_ro_avg_attr(field)
#define gb_loopback_attr(field, type) \
static ssize_t field##_show(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
struct gb_loopback *gb = dev_get_drvdata(dev); \
return sprintf(buf, "%" #type "\n", gb->field); \
} \
static ssize_t field##_store(struct device *dev, \
struct device_attribute *attr, \
const char *buf, \
size_t len) \
{ \
int ret; \
struct gb_loopback *gb = dev_get_drvdata(dev); \
mutex_lock(&gb->mutex); \
ret = sscanf(buf, "%"#type, &gb->field); \
if (ret != 1) \
len = -EINVAL; \
else \
gb_loopback_check_attr(gb, bundle); \
mutex_unlock(&gb->mutex); \
return len; \
} \
static DEVICE_ATTR_RW(field)
#define gb_dev_loopback_ro_attr(field, conn) \
static ssize_t field##_show(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
struct gb_loopback *gb = dev_get_drvdata(dev); \
return sprintf(buf, "%u\n", gb->field); \
} \
static DEVICE_ATTR_RO(field)
#define gb_dev_loopback_rw_attr(field, type) \
static ssize_t field##_show(struct device *dev, \
struct device_attribute *attr, \
char *buf) \
{ \
struct gb_loopback *gb = dev_get_drvdata(dev); \
return sprintf(buf, "%" #type "\n", gb->field); \
} \
static ssize_t field##_store(struct device *dev, \
struct device_attribute *attr, \
const char *buf, \
size_t len) \
{ \
int ret; \
struct gb_loopback *gb = dev_get_drvdata(dev); \
mutex_lock(&gb->mutex); \
ret = sscanf(buf, "%"#type, &gb->field); \
if (ret != 1) \
len = -EINVAL; \
else \
gb_loopback_check_attr(gb); \
mutex_unlock(&gb->mutex); \
return len; \
} \
static DEVICE_ATTR_RW(field)
static void gb_loopback_reset_stats(struct gb_loopback *gb);
static void gb_loopback_check_attr(struct gb_loopback *gb)
{
if (gb->us_wait > GB_LOOPBACK_US_WAIT_MAX)
gb->us_wait = GB_LOOPBACK_US_WAIT_MAX;
if (gb->size > gb_dev.size_max)
gb->size = gb_dev.size_max;
gb->requests_timedout = 0;
gb->requests_completed = 0;
gb->iteration_count = 0;
gb->send_count = 0;
gb->error = 0;
if (kfifo_depth < gb->iteration_max) {
dev_warn(gb->dev,
"cannot log bytes %u kfifo_depth %u\n",
gb->iteration_max, kfifo_depth);
}
kfifo_reset_out(&gb->kfifo_lat);
switch (gb->type) {
case GB_LOOPBACK_TYPE_PING:
case GB_LOOPBACK_TYPE_TRANSFER:
case GB_LOOPBACK_TYPE_SINK:
gb->jiffy_timeout = usecs_to_jiffies(gb->timeout);
if (!gb->jiffy_timeout)
gb->jiffy_timeout = GB_LOOPBACK_TIMEOUT_MIN;
else if (gb->jiffy_timeout > GB_LOOPBACK_TIMEOUT_MAX)
gb->jiffy_timeout = GB_LOOPBACK_TIMEOUT_MAX;
gb_loopback_reset_stats(gb);
wake_up(&gb->wq);
break;
default:
gb->type = 0;
break;
}
}
/* Time to send and receive one message */
gb_loopback_stats_attrs(latency);
/* Number of requests sent per second on this cport */
gb_loopback_stats_attrs(requests_per_second);
/* Quantity of data sent and received on this cport */
gb_loopback_stats_attrs(throughput);
/* Latency across the UniPro link from APBridge's perspective */
gb_loopback_stats_attrs(apbridge_unipro_latency);
/* Firmware induced overhead in the GPBridge */
gb_loopback_stats_attrs(gbphy_firmware_latency);
/* Number of errors encountered during loop */
gb_loopback_ro_attr(error);
/* Number of requests successfully completed async */
gb_loopback_ro_attr(requests_completed);
/* Number of requests timed out async */
gb_loopback_ro_attr(requests_timedout);
/* Timeout minimum in useconds */
gb_loopback_ro_attr(timeout_min);
/* Timeout minimum in useconds */
gb_loopback_ro_attr(timeout_max);
/*
* Type of loopback message to send based on protocol type definitions
* 0 => Don't send message
* 2 => Send ping message continuously (message without payload)
* 3 => Send transfer message continuously (message with payload,
* payload returned in response)
* 4 => Send a sink message (message with payload, no payload in response)
*/
gb_dev_loopback_rw_attr(type, d);
/* Size of transfer message payload: 0-4096 bytes */
gb_dev_loopback_rw_attr(size, u);
/* Time to wait between two messages: 0-1000 ms */
gb_dev_loopback_rw_attr(us_wait, d);
/* Maximum iterations for a given operation: 1-(2^32-1), 0 implies infinite */
gb_dev_loopback_rw_attr(iteration_max, u);
/* The current index of the for (i = 0; i < iteration_max; i++) loop */
gb_dev_loopback_ro_attr(iteration_count, false);
/* A flag to indicate synchronous or asynchronous operations */
gb_dev_loopback_rw_attr(async, u);
/* Timeout of an individual asynchronous request */
gb_dev_loopback_rw_attr(timeout, u);
/* Maximum number of in-flight operations before back-off */
gb_dev_loopback_rw_attr(outstanding_operations_max, u);
static struct attribute *loopback_attrs[] = {
&dev_attr_latency_min.attr,
&dev_attr_latency_max.attr,
&dev_attr_latency_avg.attr,
&dev_attr_requests_per_second_min.attr,
&dev_attr_requests_per_second_max.attr,
&dev_attr_requests_per_second_avg.attr,
&dev_attr_throughput_min.attr,
&dev_attr_throughput_max.attr,
&dev_attr_throughput_avg.attr,
&dev_attr_apbridge_unipro_latency_min.attr,
&dev_attr_apbridge_unipro_latency_max.attr,
&dev_attr_apbridge_unipro_latency_avg.attr,
&dev_attr_gbphy_firmware_latency_min.attr,
&dev_attr_gbphy_firmware_latency_max.attr,
&dev_attr_gbphy_firmware_latency_avg.attr,
&dev_attr_type.attr,
&dev_attr_size.attr,
&dev_attr_us_wait.attr,
&dev_attr_iteration_count.attr,
&dev_attr_iteration_max.attr,
&dev_attr_async.attr,
&dev_attr_error.attr,
&dev_attr_requests_completed.attr,
&dev_attr_requests_timedout.attr,
&dev_attr_timeout.attr,
&dev_attr_outstanding_operations_max.attr,
&dev_attr_timeout_min.attr,
&dev_attr_timeout_max.attr,
NULL,
};
ATTRIBUTE_GROUPS(loopback);
static void gb_loopback_calculate_stats(struct gb_loopback *gb, bool error);
static u32 gb_loopback_nsec_to_usec_latency(u64 elapsed_nsecs)
{
do_div(elapsed_nsecs, NSEC_PER_USEC);
return elapsed_nsecs;
}
static u64 __gb_loopback_calc_latency(u64 t1, u64 t2)
{
if (t2 > t1)
return t2 - t1;
else
return NSEC_PER_DAY - t2 + t1;
}
static u64 gb_loopback_calc_latency(ktime_t ts, ktime_t te)
{
return __gb_loopback_calc_latency(ktime_to_ns(ts), ktime_to_ns(te));
}
static int gb_loopback_operation_sync(struct gb_loopback *gb, int type,
void *request, int request_size,
void *response, int response_size)
{
struct gb_operation *operation;
ktime_t ts, te;
int ret;
ts = ktime_get();
operation = gb_operation_create(gb->connection, type, request_size,
response_size, GFP_KERNEL);
if (!operation)
return -ENOMEM;
if (request_size)
memcpy(operation->request->payload, request, request_size);
ret = gb_operation_request_send_sync(operation);
if (ret) {
dev_err(&gb->connection->bundle->dev,
"synchronous operation failed: %d\n", ret);
goto out_put_operation;
} else {
if (response_size == operation->response->payload_size) {
memcpy(response, operation->response->payload,
response_size);
} else {
dev_err(&gb->connection->bundle->dev,
"response size %zu expected %d\n",
operation->response->payload_size,
response_size);
ret = -EINVAL;
goto out_put_operation;
}
}
te = ktime_get();
/* Calculate the total time the message took */
gb->elapsed_nsecs = gb_loopback_calc_latency(ts, te);
out_put_operation:
gb_operation_put(operation);
return ret;
}
static void gb_loopback_async_wait_all(struct gb_loopback *gb)
{
wait_event(gb->wq_completion,
!atomic_read(&gb->outstanding_operations));
}
static void gb_loopback_async_operation_callback(struct gb_operation *operation)
{
struct gb_loopback_async_operation *op_async;
struct gb_loopback *gb;
ktime_t te;
int result;
te = ktime_get();
result = gb_operation_result(operation);
op_async = gb_operation_get_data(operation);
gb = op_async->gb;
mutex_lock(&gb->mutex);
if (!result && op_async->completion)
result = op_async->completion(op_async);
if (!result) {
gb->elapsed_nsecs = gb_loopback_calc_latency(op_async->ts, te);
} else {
gb->error++;
if (result == -ETIMEDOUT)
gb->requests_timedout++;
}
gb->iteration_count++;
gb_loopback_calculate_stats(gb, result);
mutex_unlock(&gb->mutex);
dev_dbg(&gb->connection->bundle->dev, "complete operation %d\n",
operation->id);
/* Wake up waiters */
atomic_dec(&op_async->gb->outstanding_operations);
wake_up(&gb->wq_completion);
/* Release resources */
gb_operation_put(operation);
kfree(op_async);
}
static int gb_loopback_async_operation(struct gb_loopback *gb, int type,
void *request, int request_size,
int response_size,
void *completion)
{
struct gb_loopback_async_operation *op_async;
struct gb_operation *operation;
int ret;
op_async = kzalloc(sizeof(*op_async), GFP_KERNEL);
if (!op_async)
return -ENOMEM;
operation = gb_operation_create(gb->connection, type, request_size,
response_size, GFP_KERNEL);
if (!operation) {
kfree(op_async);
return -ENOMEM;
}
if (request_size)
memcpy(operation->request->payload, request, request_size);
gb_operation_set_data(operation, op_async);
op_async->gb = gb;
op_async->operation = operation;
op_async->completion = completion;
op_async->ts = ktime_get();
atomic_inc(&gb->outstanding_operations);
ret = gb_operation_request_send(operation,
gb_loopback_async_operation_callback,
jiffies_to_msecs(gb->jiffy_timeout),
GFP_KERNEL);
if (ret) {
atomic_dec(&gb->outstanding_operations);
gb_operation_put(operation);
kfree(op_async);
}
return ret;
}
static int gb_loopback_sync_sink(struct gb_loopback *gb, u32 len)
{
struct gb_loopback_transfer_request *request;
int retval;
request = kmalloc(len + sizeof(*request), GFP_KERNEL);
if (!request)
return -ENOMEM;
request->len = cpu_to_le32(len);
retval = gb_loopback_operation_sync(gb, GB_LOOPBACK_TYPE_SINK,
request, len + sizeof(*request),
NULL, 0);
kfree(request);
return retval;
}
static int gb_loopback_sync_transfer(struct gb_loopback *gb, u32 len)
{
struct gb_loopback_transfer_request *request;
struct gb_loopback_transfer_response *response;
int retval;
gb->apbridge_latency_ts = 0;
gb->gbphy_latency_ts = 0;
request = kmalloc(len + sizeof(*request), GFP_KERNEL);
if (!request)
return -ENOMEM;
response = kmalloc(len + sizeof(*response), GFP_KERNEL);
if (!response) {
kfree(request);
return -ENOMEM;
}
memset(request->data, 0x5A, len);
request->len = cpu_to_le32(len);
retval = gb_loopback_operation_sync(gb, GB_LOOPBACK_TYPE_TRANSFER,
request, len + sizeof(*request),
response, len + sizeof(*response));
if (retval)
goto gb_error;
if (memcmp(request->data, response->data, len)) {
dev_err(&gb->connection->bundle->dev,
"Loopback Data doesn't match\n");
retval = -EREMOTEIO;
}
gb->apbridge_latency_ts = (u32)__le32_to_cpu(response->reserved0);
gb->gbphy_latency_ts = (u32)__le32_to_cpu(response->reserved1);
gb_error:
kfree(request);
kfree(response);
return retval;
}
static int gb_loopback_sync_ping(struct gb_loopback *gb)
{
return gb_loopback_operation_sync(gb, GB_LOOPBACK_TYPE_PING,
NULL, 0, NULL, 0);
}
static int gb_loopback_async_sink(struct gb_loopback *gb, u32 len)
{
struct gb_loopback_transfer_request *request;
int retval;
request = kmalloc(len + sizeof(*request), GFP_KERNEL);
if (!request)
return -ENOMEM;
request->len = cpu_to_le32(len);
retval = gb_loopback_async_operation(gb, GB_LOOPBACK_TYPE_SINK,
request, len + sizeof(*request),
0, NULL);
kfree(request);
return retval;
}
static int gb_loopback_async_transfer_complete(
struct gb_loopback_async_operation *op_async)
{
struct gb_loopback *gb;
struct gb_operation *operation;
struct gb_loopback_transfer_request *request;
struct gb_loopback_transfer_response *response;
size_t len;
int retval = 0;
gb = op_async->gb;
operation = op_async->operation;
request = operation->request->payload;
response = operation->response->payload;
len = le32_to_cpu(request->len);
if (memcmp(request->data, response->data, len)) {
dev_err(&gb->connection->bundle->dev,
"Loopback Data doesn't match operation id %d\n",
operation->id);
retval = -EREMOTEIO;
} else {
gb->apbridge_latency_ts =
(u32)__le32_to_cpu(response->reserved0);
gb->gbphy_latency_ts =
(u32)__le32_to_cpu(response->reserved1);
}
return retval;
}
static int gb_loopback_async_transfer(struct gb_loopback *gb, u32 len)
{
struct gb_loopback_transfer_request *request;
int retval, response_len;
request = kmalloc(len + sizeof(*request), GFP_KERNEL);
if (!request)
return -ENOMEM;
memset(request->data, 0x5A, len);
request->len = cpu_to_le32(len);
response_len = sizeof(struct gb_loopback_transfer_response);
retval = gb_loopback_async_operation(gb, GB_LOOPBACK_TYPE_TRANSFER,
request, len + sizeof(*request),
len + response_len,
gb_loopback_async_transfer_complete);
if (retval)
goto gb_error;
gb_error:
kfree(request);
return retval;
}
static int gb_loopback_async_ping(struct gb_loopback *gb)
{
return gb_loopback_async_operation(gb, GB_LOOPBACK_TYPE_PING,
NULL, 0, 0, NULL);
}
static int gb_loopback_request_handler(struct gb_operation *operation)
{
struct gb_connection *connection = operation->connection;
struct gb_loopback_transfer_request *request;
struct gb_loopback_transfer_response *response;
struct device *dev = &connection->bundle->dev;
size_t len;
/* By convention, the AP initiates the version operation */
switch (operation->type) {
case GB_LOOPBACK_TYPE_PING:
case GB_LOOPBACK_TYPE_SINK:
return 0;
case GB_LOOPBACK_TYPE_TRANSFER:
if (operation->request->payload_size < sizeof(*request)) {
dev_err(dev, "transfer request too small (%zu < %zu)\n",
operation->request->payload_size,
sizeof(*request));
return -EINVAL; /* -EMSGSIZE */
}
request = operation->request->payload;
len = le32_to_cpu(request->len);
if (len > gb_dev.size_max) {
dev_err(dev, "transfer request too large (%zu > %zu)\n",
len, gb_dev.size_max);
return -EINVAL;
}
if (!gb_operation_response_alloc(operation,
len + sizeof(*response), GFP_KERNEL)) {
dev_err(dev, "error allocating response\n");
return -ENOMEM;
}
response = operation->response->payload;
response->len = cpu_to_le32(len);
if (len)
memcpy(response->data, request->data, len);
return 0;
default:
dev_err(dev, "unsupported request: %u\n", operation->type);
return -EINVAL;
}
}
static void gb_loopback_reset_stats(struct gb_loopback *gb)
{
struct gb_loopback_stats reset = {
.min = U32_MAX,
};
/* Reset per-connection stats */
memcpy(&gb->latency, &reset,
sizeof(struct gb_loopback_stats));
memcpy(&gb->throughput, &reset,
sizeof(struct gb_loopback_stats));
memcpy(&gb->requests_per_second, &reset,
sizeof(struct gb_loopback_stats));
memcpy(&gb->apbridge_unipro_latency, &reset,
sizeof(struct gb_loopback_stats));
memcpy(&gb->gbphy_firmware_latency, &reset,
sizeof(struct gb_loopback_stats));
/* Should be initialized at least once per transaction set */
gb->apbridge_latency_ts = 0;
gb->gbphy_latency_ts = 0;
gb->ts = ktime_set(0, 0);
}
static void gb_loopback_update_stats(struct gb_loopback_stats *stats, u32 val)
{
if (stats->min > val)
stats->min = val;
if (stats->max < val)
stats->max = val;
stats->sum += val;
stats->count++;
}
static void gb_loopback_update_stats_window(struct gb_loopback_stats *stats,
u64 val, u32 count)
{
stats->sum += val;
stats->count += count;
do_div(val, count);
if (stats->min > val)
stats->min = val;
if (stats->max < val)
stats->max = val;
}
static void gb_loopback_requests_update(struct gb_loopback *gb, u32 latency)
{
u64 req = gb->requests_completed * USEC_PER_SEC;
gb_loopback_update_stats_window(&gb->requests_per_second, req, latency);
}
static void gb_loopback_throughput_update(struct gb_loopback *gb, u32 latency)
{
u64 aggregate_size = sizeof(struct gb_operation_msg_hdr) * 2;
switch (gb->type) {
case GB_LOOPBACK_TYPE_PING:
break;
case GB_LOOPBACK_TYPE_SINK:
aggregate_size += sizeof(struct gb_loopback_transfer_request) +
gb->size;
break;
case GB_LOOPBACK_TYPE_TRANSFER:
aggregate_size += sizeof(struct gb_loopback_transfer_request) +
sizeof(struct gb_loopback_transfer_response) +
gb->size * 2;
break;
default:
return;
}
aggregate_size *= gb->requests_completed;
aggregate_size *= USEC_PER_SEC;
gb_loopback_update_stats_window(&gb->throughput, aggregate_size,
latency);
}
static void gb_loopback_calculate_latency_stats(struct gb_loopback *gb)
{
u32 lat;
/* Express latency in terms of microseconds */
lat = gb_loopback_nsec_to_usec_latency(gb->elapsed_nsecs);
/* Log latency stastic */
gb_loopback_update_stats(&gb->latency, lat);
/* Raw latency log on a per thread basis */
kfifo_in(&gb->kfifo_lat, (unsigned char *)&lat, sizeof(lat));
/* Log the firmware supplied latency values */
gb_loopback_update_stats(&gb->apbridge_unipro_latency,
gb->apbridge_latency_ts);
gb_loopback_update_stats(&gb->gbphy_firmware_latency,
gb->gbphy_latency_ts);
}
static void gb_loopback_calculate_stats(struct gb_loopback *gb, bool error)
{
u64 nlat;
u32 lat;
ktime_t te;
if (!error) {
gb->requests_completed++;
gb_loopback_calculate_latency_stats(gb);
}
te = ktime_get();
nlat = gb_loopback_calc_latency(gb->ts, te);
if (nlat >= NSEC_PER_SEC || gb->iteration_count == gb->iteration_max) {
lat = gb_loopback_nsec_to_usec_latency(nlat);
gb_loopback_throughput_update(gb, lat);
gb_loopback_requests_update(gb, lat);
if (gb->iteration_count != gb->iteration_max) {
gb->ts = te;
gb->requests_completed = 0;
}
}
}
static void gb_loopback_async_wait_to_send(struct gb_loopback *gb)
{
if (!(gb->async && gb->outstanding_operations_max))
return;
wait_event_interruptible(gb->wq_completion,
(atomic_read(&gb->outstanding_operations) <
gb->outstanding_operations_max) ||
kthread_should_stop());
}
static int gb_loopback_fn(void *data)
{
int error = 0;
int us_wait = 0;
int type;
int ret;
u32 size;
struct gb_loopback *gb = data;
struct gb_bundle *bundle = gb->connection->bundle;
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
while (1) {
if (!gb->type) {
gb_pm_runtime_put_autosuspend(bundle);
wait_event_interruptible(gb->wq, gb->type ||
kthread_should_stop());
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
return ret;
}
if (kthread_should_stop())
break;
/* Limit the maximum number of in-flight async operations */
gb_loopback_async_wait_to_send(gb);
if (kthread_should_stop())
break;
mutex_lock(&gb->mutex);
/* Optionally terminate */
if (gb->send_count == gb->iteration_max) {
mutex_unlock(&gb->mutex);
/* Wait for synchronous and asynchronous completion */
gb_loopback_async_wait_all(gb);
/* Mark complete unless user-space has poked us */
mutex_lock(&gb->mutex);
if (gb->iteration_count == gb->iteration_max) {
gb->type = 0;
gb->send_count = 0;
sysfs_notify(&gb->dev->kobj, NULL,
"iteration_count");
dev_dbg(&bundle->dev, "load test complete\n");
} else {
dev_dbg(&bundle->dev,
"continuing on with new test set\n");
}
mutex_unlock(&gb->mutex);
continue;
}
size = gb->size;
us_wait = gb->us_wait;
type = gb->type;
if (ktime_to_ns(gb->ts) == 0)
gb->ts = ktime_get();
/* Else operations to perform */
if (gb->async) {
if (type == GB_LOOPBACK_TYPE_PING)
error = gb_loopback_async_ping(gb);
else if (type == GB_LOOPBACK_TYPE_TRANSFER)
error = gb_loopback_async_transfer(gb, size);
else if (type == GB_LOOPBACK_TYPE_SINK)
error = gb_loopback_async_sink(gb, size);
if (error) {
gb->error++;
gb->iteration_count++;
}
} else {
/* We are effectively single threaded here */
if (type == GB_LOOPBACK_TYPE_PING)
error = gb_loopback_sync_ping(gb);
else if (type == GB_LOOPBACK_TYPE_TRANSFER)
error = gb_loopback_sync_transfer(gb, size);
else if (type == GB_LOOPBACK_TYPE_SINK)
error = gb_loopback_sync_sink(gb, size);
if (error)
gb->error++;
gb->iteration_count++;
gb_loopback_calculate_stats(gb, !!error);
}
gb->send_count++;
mutex_unlock(&gb->mutex);
if (us_wait) {
if (us_wait < 20000)
usleep_range(us_wait, us_wait + 100);
else
msleep(us_wait / 1000);
}
}
gb_pm_runtime_put_autosuspend(bundle);
return 0;
}
static int gb_loopback_dbgfs_latency_show_common(struct seq_file *s,
struct kfifo *kfifo,
struct mutex *mutex)
{
u32 latency;
int retval;
if (kfifo_len(kfifo) == 0) {
retval = -EAGAIN;
goto done;
}
mutex_lock(mutex);
retval = kfifo_out(kfifo, &latency, sizeof(latency));
if (retval > 0) {
seq_printf(s, "%u", latency);
retval = 0;
}
mutex_unlock(mutex);
done:
return retval;
}
static int gb_loopback_dbgfs_latency_show(struct seq_file *s, void *unused)
{
struct gb_loopback *gb = s->private;
return gb_loopback_dbgfs_latency_show_common(s, &gb->kfifo_lat,
&gb->mutex);
}
DEFINE_SHOW_ATTRIBUTE(gb_loopback_dbgfs_latency);
#define DEBUGFS_NAMELEN 32
static int gb_loopback_probe(struct gb_bundle *bundle,
const struct greybus_bundle_id *id)
{
struct greybus_descriptor_cport *cport_desc;
struct gb_connection *connection;
struct gb_loopback *gb;
struct device *dev;
int retval;
char name[DEBUGFS_NAMELEN];
unsigned long flags;
if (bundle->num_cports != 1)
return -ENODEV;
cport_desc = &bundle->cport_desc[0];
if (cport_desc->protocol_id != GREYBUS_PROTOCOL_LOOPBACK)
return -ENODEV;
gb = kzalloc(sizeof(*gb), GFP_KERNEL);
if (!gb)
return -ENOMEM;
connection = gb_connection_create(bundle, le16_to_cpu(cport_desc->id),
gb_loopback_request_handler);
if (IS_ERR(connection)) {
retval = PTR_ERR(connection);
goto out_kzalloc;
}
gb->connection = connection;
greybus_set_drvdata(bundle, gb);
init_waitqueue_head(&gb->wq);
init_waitqueue_head(&gb->wq_completion);
atomic_set(&gb->outstanding_operations, 0);
gb_loopback_reset_stats(gb);
/* Reported values to user-space for min/max timeouts */
gb->timeout_min = jiffies_to_usecs(GB_LOOPBACK_TIMEOUT_MIN);
gb->timeout_max = jiffies_to_usecs(GB_LOOPBACK_TIMEOUT_MAX);
if (!gb_dev.count) {
/* Calculate maximum payload */
gb_dev.size_max = gb_operation_get_payload_size_max(connection);
if (gb_dev.size_max <=
sizeof(struct gb_loopback_transfer_request)) {
retval = -EINVAL;
goto out_connection_destroy;
}
gb_dev.size_max -= sizeof(struct gb_loopback_transfer_request);
}
/* Create per-connection sysfs and debugfs data-points */
snprintf(name, sizeof(name), "raw_latency_%s",
dev_name(&connection->bundle->dev));
gb->file = debugfs_create_file(name, S_IFREG | 0444, gb_dev.root, gb,
&gb_loopback_dbgfs_latency_fops);
gb->id = ida_simple_get(&loopback_ida, 0, 0, GFP_KERNEL);
if (gb->id < 0) {
retval = gb->id;
goto out_debugfs_remove;
}
retval = gb_connection_enable(connection);
if (retval)
goto out_ida_remove;
dev = device_create_with_groups(&loopback_class,
&connection->bundle->dev,
MKDEV(0, 0), gb, loopback_groups,
"gb_loopback%d", gb->id);
if (IS_ERR(dev)) {
retval = PTR_ERR(dev);
goto out_connection_disable;
}
gb->dev = dev;
/* Allocate kfifo */
if (kfifo_alloc(&gb->kfifo_lat, kfifo_depth * sizeof(u32),
GFP_KERNEL)) {
retval = -ENOMEM;
goto out_conn;
}
/* Fork worker thread */
mutex_init(&gb->mutex);
gb->task = kthread_run(gb_loopback_fn, gb, "gb_loopback");
if (IS_ERR(gb->task)) {
retval = PTR_ERR(gb->task);
goto out_kfifo;
}
spin_lock_irqsave(&gb_dev.lock, flags);
gb_dev.count++;
spin_unlock_irqrestore(&gb_dev.lock, flags);
gb_connection_latency_tag_enable(connection);
gb_pm_runtime_put_autosuspend(bundle);
return 0;
out_kfifo:
kfifo_free(&gb->kfifo_lat);
out_conn:
device_unregister(dev);
out_connection_disable:
gb_connection_disable(connection);
out_ida_remove:
ida_simple_remove(&loopback_ida, gb->id);
out_debugfs_remove:
debugfs_remove(gb->file);
out_connection_destroy:
gb_connection_destroy(connection);
out_kzalloc:
kfree(gb);
return retval;
}
static void gb_loopback_disconnect(struct gb_bundle *bundle)
{
struct gb_loopback *gb = greybus_get_drvdata(bundle);
unsigned long flags;
int ret;
ret = gb_pm_runtime_get_sync(bundle);
if (ret)
gb_pm_runtime_get_noresume(bundle);
gb_connection_disable(gb->connection);
if (!IS_ERR_OR_NULL(gb->task))
kthread_stop(gb->task);
kfifo_free(&gb->kfifo_lat);
gb_connection_latency_tag_disable(gb->connection);
debugfs_remove(gb->file);
/*
* FIXME: gb_loopback_async_wait_all() is redundant now, as connection
* is disabled at the beginning and so we can't have any more
* incoming/outgoing requests.
*/
gb_loopback_async_wait_all(gb);
spin_lock_irqsave(&gb_dev.lock, flags);
gb_dev.count--;
spin_unlock_irqrestore(&gb_dev.lock, flags);
device_unregister(gb->dev);
ida_simple_remove(&loopback_ida, gb->id);
gb_connection_destroy(gb->connection);
kfree(gb);
}
static const struct greybus_bundle_id gb_loopback_id_table[] = {
{ GREYBUS_DEVICE_CLASS(GREYBUS_CLASS_LOOPBACK) },
{ }
};
MODULE_DEVICE_TABLE(greybus, gb_loopback_id_table);
static struct greybus_driver gb_loopback_driver = {
.name = "loopback",
.probe = gb_loopback_probe,
.disconnect = gb_loopback_disconnect,
.id_table = gb_loopback_id_table,
};
static int loopback_init(void)
{
int retval;
spin_lock_init(&gb_dev.lock);
gb_dev.root = debugfs_create_dir("gb_loopback", NULL);
retval = class_register(&loopback_class);
if (retval)
goto err;
retval = greybus_register(&gb_loopback_driver);
if (retval)
goto err_unregister;
return 0;
err_unregister:
class_unregister(&loopback_class);
err:
debugfs_remove_recursive(gb_dev.root);
return retval;
}
module_init(loopback_init);
static void __exit loopback_exit(void)
{
debugfs_remove_recursive(gb_dev.root);
greybus_deregister(&gb_loopback_driver);
class_unregister(&loopback_class);
ida_destroy(&loopback_ida);
}
module_exit(loopback_exit);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/loopback.c |
// SPDX-License-Identifier: GPL-2.0
/*
* UART driver for the Greybus "generic" UART module.
*
* Copyright 2014 Google Inc.
* Copyright 2014 Linaro Ltd.
*
* Heavily based on drivers/usb/class/cdc-acm.c and
* drivers/usb/serial/usb-serial.c.
*/
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/module.h>
#include <linux/sched/signal.h>
#include <linux/wait.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/mutex.h>
#include <linux/tty.h>
#include <linux/serial.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/idr.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/kfifo.h>
#include <linux/workqueue.h>
#include <linux/completion.h>
#include <linux/greybus.h>
#include "gbphy.h"
#define GB_NUM_MINORS 16 /* 16 is more than enough */
#define GB_NAME "ttyGB"
#define GB_UART_WRITE_FIFO_SIZE PAGE_SIZE
#define GB_UART_WRITE_ROOM_MARGIN 1 /* leave some space in fifo */
#define GB_UART_FIRMWARE_CREDITS 4096
#define GB_UART_CREDIT_WAIT_TIMEOUT_MSEC 10000
struct gb_tty {
struct gbphy_device *gbphy_dev;
struct tty_port port;
void *buffer;
size_t buffer_payload_max;
struct gb_connection *connection;
u16 cport_id;
unsigned int minor;
unsigned char clocal;
bool disconnected;
spinlock_t read_lock;
spinlock_t write_lock;
struct async_icount iocount;
struct async_icount oldcount;
wait_queue_head_t wioctl;
struct mutex mutex;
u8 ctrlin; /* input control lines */
u8 ctrlout; /* output control lines */
struct gb_uart_set_line_coding_request line_coding;
struct work_struct tx_work;
struct kfifo write_fifo;
bool close_pending;
unsigned int credits;
struct completion credits_complete;
};
static struct tty_driver *gb_tty_driver;
static DEFINE_IDR(tty_minors);
static DEFINE_MUTEX(table_lock);
static int gb_uart_receive_data_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_tty *gb_tty = gb_connection_get_data(connection);
struct tty_port *port = &gb_tty->port;
struct gb_message *request = op->request;
struct gb_uart_recv_data_request *receive_data;
u16 recv_data_size;
int count;
unsigned long tty_flags = TTY_NORMAL;
if (request->payload_size < sizeof(*receive_data)) {
dev_err(&gb_tty->gbphy_dev->dev,
"short receive-data request received (%zu < %zu)\n",
request->payload_size, sizeof(*receive_data));
return -EINVAL;
}
receive_data = op->request->payload;
recv_data_size = le16_to_cpu(receive_data->size);
if (recv_data_size != request->payload_size - sizeof(*receive_data)) {
dev_err(&gb_tty->gbphy_dev->dev,
"malformed receive-data request received (%u != %zu)\n",
recv_data_size,
request->payload_size - sizeof(*receive_data));
return -EINVAL;
}
if (!recv_data_size)
return -EINVAL;
if (receive_data->flags) {
if (receive_data->flags & GB_UART_RECV_FLAG_BREAK)
tty_flags = TTY_BREAK;
else if (receive_data->flags & GB_UART_RECV_FLAG_PARITY)
tty_flags = TTY_PARITY;
else if (receive_data->flags & GB_UART_RECV_FLAG_FRAMING)
tty_flags = TTY_FRAME;
/* overrun is special, not associated with a char */
if (receive_data->flags & GB_UART_RECV_FLAG_OVERRUN)
tty_insert_flip_char(port, 0, TTY_OVERRUN);
}
count = tty_insert_flip_string_fixed_flag(port, receive_data->data,
tty_flags, recv_data_size);
if (count != recv_data_size) {
dev_err(&gb_tty->gbphy_dev->dev,
"UART: RX 0x%08x bytes only wrote 0x%08x\n",
recv_data_size, count);
}
if (count)
tty_flip_buffer_push(port);
return 0;
}
static int gb_uart_serial_state_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_tty *gb_tty = gb_connection_get_data(connection);
struct gb_message *request = op->request;
struct gb_uart_serial_state_request *serial_state;
if (request->payload_size < sizeof(*serial_state)) {
dev_err(&gb_tty->gbphy_dev->dev,
"short serial-state event received (%zu < %zu)\n",
request->payload_size, sizeof(*serial_state));
return -EINVAL;
}
serial_state = request->payload;
gb_tty->ctrlin = serial_state->control;
return 0;
}
static int gb_uart_receive_credits_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_tty *gb_tty = gb_connection_get_data(connection);
struct gb_message *request = op->request;
struct gb_uart_receive_credits_request *credit_request;
unsigned long flags;
unsigned int incoming_credits;
int ret = 0;
if (request->payload_size < sizeof(*credit_request)) {
dev_err(&gb_tty->gbphy_dev->dev,
"short receive_credits event received (%zu < %zu)\n",
request->payload_size,
sizeof(*credit_request));
return -EINVAL;
}
credit_request = request->payload;
incoming_credits = le16_to_cpu(credit_request->count);
spin_lock_irqsave(&gb_tty->write_lock, flags);
gb_tty->credits += incoming_credits;
if (gb_tty->credits > GB_UART_FIRMWARE_CREDITS) {
gb_tty->credits -= incoming_credits;
ret = -EINVAL;
}
spin_unlock_irqrestore(&gb_tty->write_lock, flags);
if (ret) {
dev_err(&gb_tty->gbphy_dev->dev,
"invalid number of incoming credits: %d\n",
incoming_credits);
return ret;
}
if (!gb_tty->close_pending)
schedule_work(&gb_tty->tx_work);
/*
* the port the tty layer may be waiting for credits
*/
tty_port_tty_wakeup(&gb_tty->port);
if (gb_tty->credits == GB_UART_FIRMWARE_CREDITS)
complete(&gb_tty->credits_complete);
return ret;
}
static int gb_uart_request_handler(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct gb_tty *gb_tty = gb_connection_get_data(connection);
int type = op->type;
int ret;
switch (type) {
case GB_UART_TYPE_RECEIVE_DATA:
ret = gb_uart_receive_data_handler(op);
break;
case GB_UART_TYPE_SERIAL_STATE:
ret = gb_uart_serial_state_handler(op);
break;
case GB_UART_TYPE_RECEIVE_CREDITS:
ret = gb_uart_receive_credits_handler(op);
break;
default:
dev_err(&gb_tty->gbphy_dev->dev,
"unsupported unsolicited request: 0x%02x\n", type);
ret = -EINVAL;
}
return ret;
}
static void gb_uart_tx_write_work(struct work_struct *work)
{
struct gb_uart_send_data_request *request;
struct gb_tty *gb_tty;
unsigned long flags;
unsigned int send_size;
int ret;
gb_tty = container_of(work, struct gb_tty, tx_work);
request = gb_tty->buffer;
while (1) {
if (gb_tty->close_pending)
break;
spin_lock_irqsave(&gb_tty->write_lock, flags);
send_size = gb_tty->buffer_payload_max;
if (send_size > gb_tty->credits)
send_size = gb_tty->credits;
send_size = kfifo_out_peek(&gb_tty->write_fifo,
&request->data[0],
send_size);
if (!send_size) {
spin_unlock_irqrestore(&gb_tty->write_lock, flags);
break;
}
gb_tty->credits -= send_size;
spin_unlock_irqrestore(&gb_tty->write_lock, flags);
request->size = cpu_to_le16(send_size);
ret = gb_operation_sync(gb_tty->connection,
GB_UART_TYPE_SEND_DATA,
request, sizeof(*request) + send_size,
NULL, 0);
if (ret) {
dev_err(&gb_tty->gbphy_dev->dev,
"send data error: %d\n", ret);
spin_lock_irqsave(&gb_tty->write_lock, flags);
gb_tty->credits += send_size;
spin_unlock_irqrestore(&gb_tty->write_lock, flags);
if (!gb_tty->close_pending)
schedule_work(work);
return;
}
spin_lock_irqsave(&gb_tty->write_lock, flags);
ret = kfifo_out(&gb_tty->write_fifo, &request->data[0],
send_size);
spin_unlock_irqrestore(&gb_tty->write_lock, flags);
tty_port_tty_wakeup(&gb_tty->port);
}
}
static int send_line_coding(struct gb_tty *tty)
{
return gb_operation_sync(tty->connection, GB_UART_TYPE_SET_LINE_CODING,
&tty->line_coding, sizeof(tty->line_coding),
NULL, 0);
}
static int send_control(struct gb_tty *gb_tty, u8 control)
{
struct gb_uart_set_control_line_state_request request;
request.control = control;
return gb_operation_sync(gb_tty->connection,
GB_UART_TYPE_SET_CONTROL_LINE_STATE,
&request, sizeof(request), NULL, 0);
}
static int send_break(struct gb_tty *gb_tty, u8 state)
{
struct gb_uart_set_break_request request;
if ((state != 0) && (state != 1)) {
dev_err(&gb_tty->gbphy_dev->dev,
"invalid break state of %d\n", state);
return -EINVAL;
}
request.state = state;
return gb_operation_sync(gb_tty->connection, GB_UART_TYPE_SEND_BREAK,
&request, sizeof(request), NULL, 0);
}
static int gb_uart_wait_for_all_credits(struct gb_tty *gb_tty)
{
int ret;
if (gb_tty->credits == GB_UART_FIRMWARE_CREDITS)
return 0;
ret = wait_for_completion_timeout(&gb_tty->credits_complete,
msecs_to_jiffies(GB_UART_CREDIT_WAIT_TIMEOUT_MSEC));
if (!ret) {
dev_err(&gb_tty->gbphy_dev->dev,
"time out waiting for credits\n");
return -ETIMEDOUT;
}
return 0;
}
static int gb_uart_flush(struct gb_tty *gb_tty, u8 flags)
{
struct gb_uart_serial_flush_request request;
request.flags = flags;
return gb_operation_sync(gb_tty->connection, GB_UART_TYPE_FLUSH_FIFOS,
&request, sizeof(request), NULL, 0);
}
static struct gb_tty *get_gb_by_minor(unsigned int minor)
{
struct gb_tty *gb_tty;
mutex_lock(&table_lock);
gb_tty = idr_find(&tty_minors, minor);
if (gb_tty) {
mutex_lock(&gb_tty->mutex);
if (gb_tty->disconnected) {
mutex_unlock(&gb_tty->mutex);
gb_tty = NULL;
} else {
tty_port_get(&gb_tty->port);
mutex_unlock(&gb_tty->mutex);
}
}
mutex_unlock(&table_lock);
return gb_tty;
}
static int alloc_minor(struct gb_tty *gb_tty)
{
int minor;
mutex_lock(&table_lock);
minor = idr_alloc(&tty_minors, gb_tty, 0, GB_NUM_MINORS, GFP_KERNEL);
mutex_unlock(&table_lock);
if (minor >= 0)
gb_tty->minor = minor;
return minor;
}
static void release_minor(struct gb_tty *gb_tty)
{
int minor = gb_tty->minor;
gb_tty->minor = 0; /* Maybe should use an invalid value instead */
mutex_lock(&table_lock);
idr_remove(&tty_minors, minor);
mutex_unlock(&table_lock);
}
static int gb_tty_install(struct tty_driver *driver, struct tty_struct *tty)
{
struct gb_tty *gb_tty;
int retval;
gb_tty = get_gb_by_minor(tty->index);
if (!gb_tty)
return -ENODEV;
retval = tty_standard_install(driver, tty);
if (retval)
goto error;
tty->driver_data = gb_tty;
return 0;
error:
tty_port_put(&gb_tty->port);
return retval;
}
static int gb_tty_open(struct tty_struct *tty, struct file *file)
{
struct gb_tty *gb_tty = tty->driver_data;
return tty_port_open(&gb_tty->port, tty, file);
}
static void gb_tty_close(struct tty_struct *tty, struct file *file)
{
struct gb_tty *gb_tty = tty->driver_data;
tty_port_close(&gb_tty->port, tty, file);
}
static void gb_tty_cleanup(struct tty_struct *tty)
{
struct gb_tty *gb_tty = tty->driver_data;
tty_port_put(&gb_tty->port);
}
static void gb_tty_hangup(struct tty_struct *tty)
{
struct gb_tty *gb_tty = tty->driver_data;
tty_port_hangup(&gb_tty->port);
}
static ssize_t gb_tty_write(struct tty_struct *tty, const u8 *buf, size_t count)
{
struct gb_tty *gb_tty = tty->driver_data;
count = kfifo_in_spinlocked(&gb_tty->write_fifo, buf, count,
&gb_tty->write_lock);
if (count && !gb_tty->close_pending)
schedule_work(&gb_tty->tx_work);
return count;
}
static unsigned int gb_tty_write_room(struct tty_struct *tty)
{
struct gb_tty *gb_tty = tty->driver_data;
unsigned long flags;
int room;
spin_lock_irqsave(&gb_tty->write_lock, flags);
room = kfifo_avail(&gb_tty->write_fifo);
spin_unlock_irqrestore(&gb_tty->write_lock, flags);
room -= GB_UART_WRITE_ROOM_MARGIN;
if (room < 0)
return 0;
return room;
}
static unsigned int gb_tty_chars_in_buffer(struct tty_struct *tty)
{
struct gb_tty *gb_tty = tty->driver_data;
unsigned long flags;
unsigned int chars;
spin_lock_irqsave(&gb_tty->write_lock, flags);
chars = kfifo_len(&gb_tty->write_fifo);
if (gb_tty->credits < GB_UART_FIRMWARE_CREDITS)
chars += GB_UART_FIRMWARE_CREDITS - gb_tty->credits;
spin_unlock_irqrestore(&gb_tty->write_lock, flags);
return chars;
}
static int gb_tty_break_ctl(struct tty_struct *tty, int state)
{
struct gb_tty *gb_tty = tty->driver_data;
return send_break(gb_tty, state ? 1 : 0);
}
static void gb_tty_set_termios(struct tty_struct *tty,
const struct ktermios *termios_old)
{
struct gb_uart_set_line_coding_request newline;
struct gb_tty *gb_tty = tty->driver_data;
struct ktermios *termios = &tty->termios;
u8 newctrl = gb_tty->ctrlout;
newline.rate = cpu_to_le32(tty_get_baud_rate(tty));
newline.format = termios->c_cflag & CSTOPB ?
GB_SERIAL_2_STOP_BITS : GB_SERIAL_1_STOP_BITS;
newline.parity = termios->c_cflag & PARENB ?
(termios->c_cflag & PARODD ? 1 : 2) +
(termios->c_cflag & CMSPAR ? 2 : 0) : 0;
newline.data_bits = tty_get_char_size(termios->c_cflag);
/* FIXME: needs to clear unsupported bits in the termios */
gb_tty->clocal = ((termios->c_cflag & CLOCAL) != 0);
if (C_BAUD(tty) == B0) {
newline.rate = gb_tty->line_coding.rate;
newctrl &= ~(GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
} else if (termios_old && (termios_old->c_cflag & CBAUD) == B0) {
newctrl |= (GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
}
if (newctrl != gb_tty->ctrlout) {
gb_tty->ctrlout = newctrl;
send_control(gb_tty, newctrl);
}
if (C_CRTSCTS(tty) && C_BAUD(tty) != B0)
newline.flow_control = GB_SERIAL_AUTO_RTSCTS_EN;
else
newline.flow_control = 0;
if (memcmp(&gb_tty->line_coding, &newline, sizeof(newline))) {
memcpy(&gb_tty->line_coding, &newline, sizeof(newline));
send_line_coding(gb_tty);
}
}
static int gb_tty_tiocmget(struct tty_struct *tty)
{
struct gb_tty *gb_tty = tty->driver_data;
return (gb_tty->ctrlout & GB_UART_CTRL_DTR ? TIOCM_DTR : 0) |
(gb_tty->ctrlout & GB_UART_CTRL_RTS ? TIOCM_RTS : 0) |
(gb_tty->ctrlin & GB_UART_CTRL_DSR ? TIOCM_DSR : 0) |
(gb_tty->ctrlin & GB_UART_CTRL_RI ? TIOCM_RI : 0) |
(gb_tty->ctrlin & GB_UART_CTRL_DCD ? TIOCM_CD : 0) |
TIOCM_CTS;
}
static int gb_tty_tiocmset(struct tty_struct *tty, unsigned int set,
unsigned int clear)
{
struct gb_tty *gb_tty = tty->driver_data;
u8 newctrl = gb_tty->ctrlout;
set = (set & TIOCM_DTR ? GB_UART_CTRL_DTR : 0) |
(set & TIOCM_RTS ? GB_UART_CTRL_RTS : 0);
clear = (clear & TIOCM_DTR ? GB_UART_CTRL_DTR : 0) |
(clear & TIOCM_RTS ? GB_UART_CTRL_RTS : 0);
newctrl = (newctrl & ~clear) | set;
if (gb_tty->ctrlout == newctrl)
return 0;
gb_tty->ctrlout = newctrl;
return send_control(gb_tty, newctrl);
}
static void gb_tty_throttle(struct tty_struct *tty)
{
struct gb_tty *gb_tty = tty->driver_data;
unsigned char stop_char;
int retval;
if (I_IXOFF(tty)) {
stop_char = STOP_CHAR(tty);
retval = gb_tty_write(tty, &stop_char, 1);
if (retval <= 0)
return;
}
if (tty->termios.c_cflag & CRTSCTS) {
gb_tty->ctrlout &= ~GB_UART_CTRL_RTS;
retval = send_control(gb_tty, gb_tty->ctrlout);
}
}
static void gb_tty_unthrottle(struct tty_struct *tty)
{
struct gb_tty *gb_tty = tty->driver_data;
unsigned char start_char;
int retval;
if (I_IXOFF(tty)) {
start_char = START_CHAR(tty);
retval = gb_tty_write(tty, &start_char, 1);
if (retval <= 0)
return;
}
if (tty->termios.c_cflag & CRTSCTS) {
gb_tty->ctrlout |= GB_UART_CTRL_RTS;
retval = send_control(gb_tty, gb_tty->ctrlout);
}
}
static int get_serial_info(struct tty_struct *tty,
struct serial_struct *ss)
{
struct gb_tty *gb_tty = tty->driver_data;
ss->line = gb_tty->minor;
ss->close_delay = jiffies_to_msecs(gb_tty->port.close_delay) / 10;
ss->closing_wait =
gb_tty->port.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
ASYNC_CLOSING_WAIT_NONE :
jiffies_to_msecs(gb_tty->port.closing_wait) / 10;
return 0;
}
static int set_serial_info(struct tty_struct *tty,
struct serial_struct *ss)
{
struct gb_tty *gb_tty = tty->driver_data;
unsigned int closing_wait;
unsigned int close_delay;
int retval = 0;
close_delay = msecs_to_jiffies(ss->close_delay * 10);
closing_wait = ss->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
ASYNC_CLOSING_WAIT_NONE :
msecs_to_jiffies(ss->closing_wait * 10);
mutex_lock(&gb_tty->port.mutex);
if (!capable(CAP_SYS_ADMIN)) {
if ((close_delay != gb_tty->port.close_delay) ||
(closing_wait != gb_tty->port.closing_wait))
retval = -EPERM;
} else {
gb_tty->port.close_delay = close_delay;
gb_tty->port.closing_wait = closing_wait;
}
mutex_unlock(&gb_tty->port.mutex);
return retval;
}
static int wait_serial_change(struct gb_tty *gb_tty, unsigned long arg)
{
int retval = 0;
DECLARE_WAITQUEUE(wait, current);
struct async_icount old;
struct async_icount new;
if (!(arg & (TIOCM_DSR | TIOCM_RI | TIOCM_CD)))
return -EINVAL;
do {
spin_lock_irq(&gb_tty->read_lock);
old = gb_tty->oldcount;
new = gb_tty->iocount;
gb_tty->oldcount = new;
spin_unlock_irq(&gb_tty->read_lock);
if ((arg & TIOCM_DSR) && (old.dsr != new.dsr))
break;
if ((arg & TIOCM_CD) && (old.dcd != new.dcd))
break;
if ((arg & TIOCM_RI) && (old.rng != new.rng))
break;
add_wait_queue(&gb_tty->wioctl, &wait);
set_current_state(TASK_INTERRUPTIBLE);
schedule();
remove_wait_queue(&gb_tty->wioctl, &wait);
if (gb_tty->disconnected) {
if (arg & TIOCM_CD)
break;
retval = -ENODEV;
} else if (signal_pending(current)) {
retval = -ERESTARTSYS;
}
} while (!retval);
return retval;
}
static int gb_tty_get_icount(struct tty_struct *tty,
struct serial_icounter_struct *icount)
{
struct gb_tty *gb_tty = tty->driver_data;
icount->dsr = gb_tty->iocount.dsr;
icount->rng = gb_tty->iocount.rng;
icount->dcd = gb_tty->iocount.dcd;
icount->frame = gb_tty->iocount.frame;
icount->overrun = gb_tty->iocount.overrun;
icount->parity = gb_tty->iocount.parity;
icount->brk = gb_tty->iocount.brk;
return 0;
}
static int gb_tty_ioctl(struct tty_struct *tty, unsigned int cmd,
unsigned long arg)
{
struct gb_tty *gb_tty = tty->driver_data;
switch (cmd) {
case TIOCMIWAIT:
return wait_serial_change(gb_tty, arg);
}
return -ENOIOCTLCMD;
}
static void gb_tty_dtr_rts(struct tty_port *port, bool active)
{
struct gb_tty *gb_tty;
u8 newctrl;
gb_tty = container_of(port, struct gb_tty, port);
newctrl = gb_tty->ctrlout;
if (active)
newctrl |= (GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
else
newctrl &= ~(GB_UART_CTRL_DTR | GB_UART_CTRL_RTS);
gb_tty->ctrlout = newctrl;
send_control(gb_tty, newctrl);
}
static int gb_tty_port_activate(struct tty_port *port,
struct tty_struct *tty)
{
struct gb_tty *gb_tty;
gb_tty = container_of(port, struct gb_tty, port);
return gbphy_runtime_get_sync(gb_tty->gbphy_dev);
}
static void gb_tty_port_shutdown(struct tty_port *port)
{
struct gb_tty *gb_tty;
unsigned long flags;
int ret;
gb_tty = container_of(port, struct gb_tty, port);
gb_tty->close_pending = true;
cancel_work_sync(&gb_tty->tx_work);
spin_lock_irqsave(&gb_tty->write_lock, flags);
kfifo_reset_out(&gb_tty->write_fifo);
spin_unlock_irqrestore(&gb_tty->write_lock, flags);
if (gb_tty->credits == GB_UART_FIRMWARE_CREDITS)
goto out;
ret = gb_uart_flush(gb_tty, GB_SERIAL_FLAG_FLUSH_TRANSMITTER);
if (ret) {
dev_err(&gb_tty->gbphy_dev->dev,
"error flushing transmitter: %d\n", ret);
}
gb_uart_wait_for_all_credits(gb_tty);
out:
gb_tty->close_pending = false;
gbphy_runtime_put_autosuspend(gb_tty->gbphy_dev);
}
static void gb_tty_port_destruct(struct tty_port *port)
{
struct gb_tty *gb_tty = container_of(port, struct gb_tty, port);
if (gb_tty->minor != GB_NUM_MINORS)
release_minor(gb_tty);
kfifo_free(&gb_tty->write_fifo);
kfree(gb_tty->buffer);
kfree(gb_tty);
}
static const struct tty_operations gb_ops = {
.install = gb_tty_install,
.open = gb_tty_open,
.close = gb_tty_close,
.cleanup = gb_tty_cleanup,
.hangup = gb_tty_hangup,
.write = gb_tty_write,
.write_room = gb_tty_write_room,
.ioctl = gb_tty_ioctl,
.throttle = gb_tty_throttle,
.unthrottle = gb_tty_unthrottle,
.chars_in_buffer = gb_tty_chars_in_buffer,
.break_ctl = gb_tty_break_ctl,
.set_termios = gb_tty_set_termios,
.tiocmget = gb_tty_tiocmget,
.tiocmset = gb_tty_tiocmset,
.get_icount = gb_tty_get_icount,
.set_serial = set_serial_info,
.get_serial = get_serial_info,
};
static const struct tty_port_operations gb_port_ops = {
.dtr_rts = gb_tty_dtr_rts,
.activate = gb_tty_port_activate,
.shutdown = gb_tty_port_shutdown,
.destruct = gb_tty_port_destruct,
};
static int gb_uart_probe(struct gbphy_device *gbphy_dev,
const struct gbphy_device_id *id)
{
struct gb_connection *connection;
size_t max_payload;
struct gb_tty *gb_tty;
struct device *tty_dev;
int retval;
int minor;
connection = gb_connection_create(gbphy_dev->bundle,
le16_to_cpu(gbphy_dev->cport_desc->id),
gb_uart_request_handler);
if (IS_ERR(connection))
return PTR_ERR(connection);
max_payload = gb_operation_get_payload_size_max(connection);
if (max_payload < sizeof(struct gb_uart_send_data_request)) {
retval = -EINVAL;
goto exit_connection_destroy;
}
gb_tty = kzalloc(sizeof(*gb_tty), GFP_KERNEL);
if (!gb_tty) {
retval = -ENOMEM;
goto exit_connection_destroy;
}
tty_port_init(&gb_tty->port);
gb_tty->port.ops = &gb_port_ops;
gb_tty->minor = GB_NUM_MINORS;
gb_tty->buffer_payload_max = max_payload -
sizeof(struct gb_uart_send_data_request);
gb_tty->buffer = kzalloc(gb_tty->buffer_payload_max, GFP_KERNEL);
if (!gb_tty->buffer) {
retval = -ENOMEM;
goto exit_put_port;
}
INIT_WORK(&gb_tty->tx_work, gb_uart_tx_write_work);
retval = kfifo_alloc(&gb_tty->write_fifo, GB_UART_WRITE_FIFO_SIZE,
GFP_KERNEL);
if (retval)
goto exit_put_port;
gb_tty->credits = GB_UART_FIRMWARE_CREDITS;
init_completion(&gb_tty->credits_complete);
minor = alloc_minor(gb_tty);
if (minor < 0) {
if (minor == -ENOSPC) {
dev_err(&gbphy_dev->dev,
"no more free minor numbers\n");
retval = -ENODEV;
} else {
retval = minor;
}
goto exit_put_port;
}
gb_tty->minor = minor;
spin_lock_init(&gb_tty->write_lock);
spin_lock_init(&gb_tty->read_lock);
init_waitqueue_head(&gb_tty->wioctl);
mutex_init(&gb_tty->mutex);
gb_tty->connection = connection;
gb_tty->gbphy_dev = gbphy_dev;
gb_connection_set_data(connection, gb_tty);
gb_gbphy_set_data(gbphy_dev, gb_tty);
retval = gb_connection_enable_tx(connection);
if (retval)
goto exit_put_port;
send_control(gb_tty, gb_tty->ctrlout);
/* initialize the uart to be 9600n81 */
gb_tty->line_coding.rate = cpu_to_le32(9600);
gb_tty->line_coding.format = GB_SERIAL_1_STOP_BITS;
gb_tty->line_coding.parity = GB_SERIAL_NO_PARITY;
gb_tty->line_coding.data_bits = 8;
send_line_coding(gb_tty);
retval = gb_connection_enable(connection);
if (retval)
goto exit_connection_disable;
tty_dev = tty_port_register_device(&gb_tty->port, gb_tty_driver, minor,
&gbphy_dev->dev);
if (IS_ERR(tty_dev)) {
retval = PTR_ERR(tty_dev);
goto exit_connection_disable;
}
gbphy_runtime_put_autosuspend(gbphy_dev);
return 0;
exit_connection_disable:
gb_connection_disable(connection);
exit_put_port:
tty_port_put(&gb_tty->port);
exit_connection_destroy:
gb_connection_destroy(connection);
return retval;
}
static void gb_uart_remove(struct gbphy_device *gbphy_dev)
{
struct gb_tty *gb_tty = gb_gbphy_get_data(gbphy_dev);
struct gb_connection *connection = gb_tty->connection;
struct tty_struct *tty;
int ret;
ret = gbphy_runtime_get_sync(gbphy_dev);
if (ret)
gbphy_runtime_get_noresume(gbphy_dev);
mutex_lock(&gb_tty->mutex);
gb_tty->disconnected = true;
wake_up_all(&gb_tty->wioctl);
mutex_unlock(&gb_tty->mutex);
tty = tty_port_tty_get(&gb_tty->port);
if (tty) {
tty_vhangup(tty);
tty_kref_put(tty);
}
gb_connection_disable_rx(connection);
tty_unregister_device(gb_tty_driver, gb_tty->minor);
gb_connection_disable(connection);
gb_connection_destroy(connection);
tty_port_put(&gb_tty->port);
}
static int gb_tty_init(void)
{
int retval = 0;
gb_tty_driver = tty_alloc_driver(GB_NUM_MINORS, 0);
if (IS_ERR(gb_tty_driver)) {
pr_err("Can not allocate tty driver\n");
retval = -ENOMEM;
goto fail_unregister_dev;
}
gb_tty_driver->driver_name = "gb";
gb_tty_driver->name = GB_NAME;
gb_tty_driver->major = 0;
gb_tty_driver->minor_start = 0;
gb_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
gb_tty_driver->subtype = SERIAL_TYPE_NORMAL;
gb_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
gb_tty_driver->init_termios = tty_std_termios;
gb_tty_driver->init_termios.c_cflag = B9600 | CS8 |
CREAD | HUPCL | CLOCAL;
tty_set_operations(gb_tty_driver, &gb_ops);
retval = tty_register_driver(gb_tty_driver);
if (retval) {
pr_err("Can not register tty driver: %d\n", retval);
goto fail_put_gb_tty;
}
return 0;
fail_put_gb_tty:
tty_driver_kref_put(gb_tty_driver);
fail_unregister_dev:
return retval;
}
static void gb_tty_exit(void)
{
tty_unregister_driver(gb_tty_driver);
tty_driver_kref_put(gb_tty_driver);
idr_destroy(&tty_minors);
}
static const struct gbphy_device_id gb_uart_id_table[] = {
{ GBPHY_PROTOCOL(GREYBUS_PROTOCOL_UART) },
{ },
};
MODULE_DEVICE_TABLE(gbphy, gb_uart_id_table);
static struct gbphy_driver uart_driver = {
.name = "uart",
.probe = gb_uart_probe,
.remove = gb_uart_remove,
.id_table = gb_uart_id_table,
};
static int gb_uart_driver_init(void)
{
int ret;
ret = gb_tty_init();
if (ret)
return ret;
ret = gb_gbphy_register(&uart_driver);
if (ret) {
gb_tty_exit();
return ret;
}
return 0;
}
module_init(gb_uart_driver_init);
static void gb_uart_driver_exit(void)
{
gb_gbphy_deregister(&uart_driver);
gb_tty_exit();
}
module_exit(gb_uart_driver_exit);
MODULE_LICENSE("GPL v2");
| linux-master | drivers/staging/greybus/uart.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Audio Device Class Protocol helpers
*
* Copyright 2015-2016 Google Inc.
*/
#include <linux/greybus.h>
#include "audio_apbridgea.h"
#include "audio_codec.h"
int gb_audio_apbridgea_set_config(struct gb_connection *connection,
__u16 i2s_port, __u32 format, __u32 rate,
__u32 mclk_freq)
{
struct audio_apbridgea_set_config_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_SET_CONFIG;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
req.format = cpu_to_le32(format);
req.rate = cpu_to_le32(rate);
req.mclk_freq = cpu_to_le32(mclk_freq);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_set_config);
int gb_audio_apbridgea_register_cport(struct gb_connection *connection,
__u16 i2s_port, __u16 cportid,
__u8 direction)
{
struct audio_apbridgea_register_cport_request req;
int ret;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_REGISTER_CPORT;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
req.cport = cpu_to_le16(cportid);
req.direction = direction;
ret = gb_pm_runtime_get_sync(connection->bundle);
if (ret)
return ret;
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_register_cport);
int gb_audio_apbridgea_unregister_cport(struct gb_connection *connection,
__u16 i2s_port, __u16 cportid,
__u8 direction)
{
struct audio_apbridgea_unregister_cport_request req;
int ret;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_UNREGISTER_CPORT;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
req.cport = cpu_to_le16(cportid);
req.direction = direction;
ret = gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
gb_pm_runtime_put_autosuspend(connection->bundle);
return ret;
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_unregister_cport);
int gb_audio_apbridgea_set_tx_data_size(struct gb_connection *connection,
__u16 i2s_port, __u16 size)
{
struct audio_apbridgea_set_tx_data_size_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_SET_TX_DATA_SIZE;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
req.size = cpu_to_le16(size);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_set_tx_data_size);
int gb_audio_apbridgea_prepare_tx(struct gb_connection *connection,
__u16 i2s_port)
{
struct audio_apbridgea_prepare_tx_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_PREPARE_TX;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_prepare_tx);
int gb_audio_apbridgea_start_tx(struct gb_connection *connection,
__u16 i2s_port, __u64 timestamp)
{
struct audio_apbridgea_start_tx_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_START_TX;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
req.timestamp = cpu_to_le64(timestamp);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_start_tx);
int gb_audio_apbridgea_stop_tx(struct gb_connection *connection, __u16 i2s_port)
{
struct audio_apbridgea_stop_tx_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_STOP_TX;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_stop_tx);
int gb_audio_apbridgea_shutdown_tx(struct gb_connection *connection,
__u16 i2s_port)
{
struct audio_apbridgea_shutdown_tx_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_SHUTDOWN_TX;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_shutdown_tx);
int gb_audio_apbridgea_set_rx_data_size(struct gb_connection *connection,
__u16 i2s_port, __u16 size)
{
struct audio_apbridgea_set_rx_data_size_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_SET_RX_DATA_SIZE;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
req.size = cpu_to_le16(size);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_set_rx_data_size);
int gb_audio_apbridgea_prepare_rx(struct gb_connection *connection,
__u16 i2s_port)
{
struct audio_apbridgea_prepare_rx_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_PREPARE_RX;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_prepare_rx);
int gb_audio_apbridgea_start_rx(struct gb_connection *connection,
__u16 i2s_port)
{
struct audio_apbridgea_start_rx_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_START_RX;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_start_rx);
int gb_audio_apbridgea_stop_rx(struct gb_connection *connection, __u16 i2s_port)
{
struct audio_apbridgea_stop_rx_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_STOP_RX;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_stop_rx);
int gb_audio_apbridgea_shutdown_rx(struct gb_connection *connection,
__u16 i2s_port)
{
struct audio_apbridgea_shutdown_rx_request req;
req.hdr.type = AUDIO_APBRIDGEA_TYPE_SHUTDOWN_RX;
req.hdr.i2s_port = cpu_to_le16(i2s_port);
return gb_hd_output(connection->hd, &req, sizeof(req),
GB_APB_REQUEST_AUDIO_CONTROL, true);
}
EXPORT_SYMBOL_GPL(gb_audio_apbridgea_shutdown_rx);
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("greybus:audio-apbridgea");
MODULE_DESCRIPTION("Greybus Special APBridgeA Audio Protocol library");
MODULE_AUTHOR("Mark Greer <[email protected]>");
| linux-master | drivers/staging/greybus/audio_apbridgea.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Firmware Download Protocol Driver.
*
* Copyright 2016 Google Inc.
* Copyright 2016 Linaro Ltd.
*/
#include <linux/firmware.h>
#include <linux/jiffies.h>
#include <linux/mutex.h>
#include <linux/workqueue.h>
#include <linux/greybus.h>
#include "firmware.h"
/* Estimated minimum buffer size, actual size can be smaller than this */
#define MIN_FETCH_SIZE 512
/* Timeout, in jiffies, within which fetch or release firmware must be called */
#define NEXT_REQ_TIMEOUT_J msecs_to_jiffies(1000)
struct fw_request {
u8 firmware_id;
bool disabled;
bool timedout;
char name[FW_NAME_SIZE];
const struct firmware *fw;
struct list_head node;
struct delayed_work dwork;
/* Timeout, in jiffies, within which the firmware shall download */
unsigned long release_timeout_j;
struct kref kref;
struct fw_download *fw_download;
};
struct fw_download {
struct device *parent;
struct gb_connection *connection;
struct list_head fw_requests;
struct ida id_map;
struct mutex mutex;
};
static void fw_req_release(struct kref *kref)
{
struct fw_request *fw_req = container_of(kref, struct fw_request, kref);
dev_dbg(fw_req->fw_download->parent, "firmware %s released\n",
fw_req->name);
release_firmware(fw_req->fw);
/*
* The request timed out and the module may send a fetch-fw or
* release-fw request later. Lets block the id we allocated for this
* request, so that the AP doesn't refer to a later fw-request (with
* same firmware_id) for the old timedout fw-request.
*
* NOTE:
*
* This also means that after 255 timeouts we will fail to service new
* firmware downloads. But what else can we do in that case anyway? Lets
* just hope that it never happens.
*/
if (!fw_req->timedout)
ida_simple_remove(&fw_req->fw_download->id_map,
fw_req->firmware_id);
kfree(fw_req);
}
/*
* Incoming requests are serialized for a connection, and the only race possible
* is between the timeout handler freeing this and an incoming request.
*
* The operations on the fw-request list are protected by the mutex and
* get_fw_req() increments the reference count before returning a fw_req pointer
* to the users.
*
* free_firmware() also takes the mutex while removing an entry from the list,
* it guarantees that every user of fw_req has taken a kref-reference by now and
* we wouldn't have any new users.
*
* Once the last user drops the reference, the fw_req structure is freed.
*/
static void put_fw_req(struct fw_request *fw_req)
{
kref_put(&fw_req->kref, fw_req_release);
}
/* Caller must call put_fw_req() after using struct fw_request */
static struct fw_request *get_fw_req(struct fw_download *fw_download,
u8 firmware_id)
{
struct fw_request *fw_req;
mutex_lock(&fw_download->mutex);
list_for_each_entry(fw_req, &fw_download->fw_requests, node) {
if (fw_req->firmware_id == firmware_id) {
kref_get(&fw_req->kref);
goto unlock;
}
}
fw_req = NULL;
unlock:
mutex_unlock(&fw_download->mutex);
return fw_req;
}
static void free_firmware(struct fw_download *fw_download,
struct fw_request *fw_req)
{
/* Already disabled from timeout handlers */
if (fw_req->disabled)
return;
mutex_lock(&fw_download->mutex);
list_del(&fw_req->node);
mutex_unlock(&fw_download->mutex);
fw_req->disabled = true;
put_fw_req(fw_req);
}
static void fw_request_timedout(struct work_struct *work)
{
struct delayed_work *dwork = to_delayed_work(work);
struct fw_request *fw_req = container_of(dwork,
struct fw_request, dwork);
struct fw_download *fw_download = fw_req->fw_download;
dev_err(fw_download->parent,
"Timed out waiting for fetch / release firmware requests: %u\n",
fw_req->firmware_id);
fw_req->timedout = true;
free_firmware(fw_download, fw_req);
}
static int exceeds_release_timeout(struct fw_request *fw_req)
{
struct fw_download *fw_download = fw_req->fw_download;
if (time_before(jiffies, fw_req->release_timeout_j))
return 0;
dev_err(fw_download->parent,
"Firmware download didn't finish in time, abort: %d\n",
fw_req->firmware_id);
fw_req->timedout = true;
free_firmware(fw_download, fw_req);
return -ETIMEDOUT;
}
/* This returns path of the firmware blob on the disk */
static struct fw_request *find_firmware(struct fw_download *fw_download,
const char *tag)
{
struct gb_interface *intf = fw_download->connection->bundle->intf;
struct fw_request *fw_req;
int ret, req_count;
fw_req = kzalloc(sizeof(*fw_req), GFP_KERNEL);
if (!fw_req)
return ERR_PTR(-ENOMEM);
/* Allocate ids from 1 to 255 (u8-max), 0 is an invalid id */
ret = ida_simple_get(&fw_download->id_map, 1, 256, GFP_KERNEL);
if (ret < 0) {
dev_err(fw_download->parent,
"failed to allocate firmware id (%d)\n", ret);
goto err_free_req;
}
fw_req->firmware_id = ret;
snprintf(fw_req->name, sizeof(fw_req->name),
FW_NAME_PREFIX "%08x_%08x_%08x_%08x_%s.tftf",
intf->ddbl1_manufacturer_id, intf->ddbl1_product_id,
intf->vendor_id, intf->product_id, tag);
dev_info(fw_download->parent, "Requested firmware package '%s'\n",
fw_req->name);
ret = request_firmware(&fw_req->fw, fw_req->name, fw_download->parent);
if (ret) {
dev_err(fw_download->parent,
"firmware request failed for %s (%d)\n", fw_req->name,
ret);
goto err_free_id;
}
fw_req->fw_download = fw_download;
kref_init(&fw_req->kref);
mutex_lock(&fw_download->mutex);
list_add(&fw_req->node, &fw_download->fw_requests);
mutex_unlock(&fw_download->mutex);
/* Timeout, in jiffies, within which firmware should get loaded */
req_count = DIV_ROUND_UP(fw_req->fw->size, MIN_FETCH_SIZE);
fw_req->release_timeout_j = jiffies + req_count * NEXT_REQ_TIMEOUT_J;
INIT_DELAYED_WORK(&fw_req->dwork, fw_request_timedout);
schedule_delayed_work(&fw_req->dwork, NEXT_REQ_TIMEOUT_J);
return fw_req;
err_free_id:
ida_simple_remove(&fw_download->id_map, fw_req->firmware_id);
err_free_req:
kfree(fw_req);
return ERR_PTR(ret);
}
static int fw_download_find_firmware(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct fw_download *fw_download = gb_connection_get_data(connection);
struct gb_fw_download_find_firmware_request *request;
struct gb_fw_download_find_firmware_response *response;
struct fw_request *fw_req;
const char *tag;
if (op->request->payload_size != sizeof(*request)) {
dev_err(fw_download->parent,
"illegal size of find firmware request (%zu != %zu)\n",
op->request->payload_size, sizeof(*request));
return -EINVAL;
}
request = op->request->payload;
tag = (const char *)request->firmware_tag;
/* firmware_tag must be null-terminated */
if (strnlen(tag, GB_FIRMWARE_TAG_MAX_SIZE) ==
GB_FIRMWARE_TAG_MAX_SIZE) {
dev_err(fw_download->parent,
"firmware-tag is not null-terminated\n");
return -EINVAL;
}
fw_req = find_firmware(fw_download, tag);
if (IS_ERR(fw_req))
return PTR_ERR(fw_req);
if (!gb_operation_response_alloc(op, sizeof(*response), GFP_KERNEL)) {
dev_err(fw_download->parent, "error allocating response\n");
free_firmware(fw_download, fw_req);
return -ENOMEM;
}
response = op->response->payload;
response->firmware_id = fw_req->firmware_id;
response->size = cpu_to_le32(fw_req->fw->size);
dev_dbg(fw_download->parent,
"firmware size is %zu bytes\n", fw_req->fw->size);
return 0;
}
static int fw_download_fetch_firmware(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct fw_download *fw_download = gb_connection_get_data(connection);
struct gb_fw_download_fetch_firmware_request *request;
struct gb_fw_download_fetch_firmware_response *response;
struct fw_request *fw_req;
const struct firmware *fw;
unsigned int offset, size;
u8 firmware_id;
int ret = 0;
if (op->request->payload_size != sizeof(*request)) {
dev_err(fw_download->parent,
"Illegal size of fetch firmware request (%zu %zu)\n",
op->request->payload_size, sizeof(*request));
return -EINVAL;
}
request = op->request->payload;
offset = le32_to_cpu(request->offset);
size = le32_to_cpu(request->size);
firmware_id = request->firmware_id;
fw_req = get_fw_req(fw_download, firmware_id);
if (!fw_req) {
dev_err(fw_download->parent,
"firmware not available for id: %02u\n", firmware_id);
return -EINVAL;
}
/* Make sure work handler isn't running in parallel */
cancel_delayed_work_sync(&fw_req->dwork);
/* We timed-out before reaching here ? */
if (fw_req->disabled) {
ret = -ETIMEDOUT;
goto put_fw;
}
/*
* Firmware download must finish within a limited time interval. If it
* doesn't, then we might have a buggy Module on the other side. Abort
* download.
*/
ret = exceeds_release_timeout(fw_req);
if (ret)
goto put_fw;
fw = fw_req->fw;
if (offset >= fw->size || size > fw->size - offset) {
dev_err(fw_download->parent,
"bad fetch firmware request (offs = %u, size = %u)\n",
offset, size);
ret = -EINVAL;
goto put_fw;
}
if (!gb_operation_response_alloc(op, sizeof(*response) + size,
GFP_KERNEL)) {
dev_err(fw_download->parent,
"error allocating fetch firmware response\n");
ret = -ENOMEM;
goto put_fw;
}
response = op->response->payload;
memcpy(response->data, fw->data + offset, size);
dev_dbg(fw_download->parent,
"responding with firmware (offs = %u, size = %u)\n", offset,
size);
/* Refresh timeout */
schedule_delayed_work(&fw_req->dwork, NEXT_REQ_TIMEOUT_J);
put_fw:
put_fw_req(fw_req);
return ret;
}
static int fw_download_release_firmware(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct fw_download *fw_download = gb_connection_get_data(connection);
struct gb_fw_download_release_firmware_request *request;
struct fw_request *fw_req;
u8 firmware_id;
if (op->request->payload_size != sizeof(*request)) {
dev_err(fw_download->parent,
"Illegal size of release firmware request (%zu %zu)\n",
op->request->payload_size, sizeof(*request));
return -EINVAL;
}
request = op->request->payload;
firmware_id = request->firmware_id;
fw_req = get_fw_req(fw_download, firmware_id);
if (!fw_req) {
dev_err(fw_download->parent,
"firmware not available for id: %02u\n", firmware_id);
return -EINVAL;
}
cancel_delayed_work_sync(&fw_req->dwork);
free_firmware(fw_download, fw_req);
put_fw_req(fw_req);
dev_dbg(fw_download->parent, "release firmware\n");
return 0;
}
int gb_fw_download_request_handler(struct gb_operation *op)
{
u8 type = op->type;
switch (type) {
case GB_FW_DOWNLOAD_TYPE_FIND_FIRMWARE:
return fw_download_find_firmware(op);
case GB_FW_DOWNLOAD_TYPE_FETCH_FIRMWARE:
return fw_download_fetch_firmware(op);
case GB_FW_DOWNLOAD_TYPE_RELEASE_FIRMWARE:
return fw_download_release_firmware(op);
default:
dev_err(&op->connection->bundle->dev,
"unsupported request: %u\n", type);
return -EINVAL;
}
}
int gb_fw_download_connection_init(struct gb_connection *connection)
{
struct fw_download *fw_download;
int ret;
if (!connection)
return 0;
fw_download = kzalloc(sizeof(*fw_download), GFP_KERNEL);
if (!fw_download)
return -ENOMEM;
fw_download->parent = &connection->bundle->dev;
INIT_LIST_HEAD(&fw_download->fw_requests);
ida_init(&fw_download->id_map);
gb_connection_set_data(connection, fw_download);
fw_download->connection = connection;
mutex_init(&fw_download->mutex);
ret = gb_connection_enable(connection);
if (ret)
goto err_destroy_id_map;
return 0;
err_destroy_id_map:
ida_destroy(&fw_download->id_map);
kfree(fw_download);
return ret;
}
void gb_fw_download_connection_exit(struct gb_connection *connection)
{
struct fw_download *fw_download;
struct fw_request *fw_req, *tmp;
if (!connection)
return;
fw_download = gb_connection_get_data(connection);
gb_connection_disable(fw_download->connection);
/*
* Make sure we have a reference to the pending requests, before they
* are freed from the timeout handler.
*/
mutex_lock(&fw_download->mutex);
list_for_each_entry(fw_req, &fw_download->fw_requests, node)
kref_get(&fw_req->kref);
mutex_unlock(&fw_download->mutex);
/* Release pending firmware packages */
list_for_each_entry_safe(fw_req, tmp, &fw_download->fw_requests, node) {
cancel_delayed_work_sync(&fw_req->dwork);
free_firmware(fw_download, fw_req);
put_fw_req(fw_req);
}
ida_destroy(&fw_download->id_map);
kfree(fw_download);
}
| linux-master | drivers/staging/greybus/fw-download.c |
// SPDX-License-Identifier: GPL-2.0
/*
* Greybus Firmware Management Protocol Driver.
*
* Copyright 2016 Google Inc.
* Copyright 2016 Linaro Ltd.
*/
#include <linux/cdev.h>
#include <linux/completion.h>
#include <linux/firmware.h>
#include <linux/fs.h>
#include <linux/idr.h>
#include <linux/ioctl.h>
#include <linux/uaccess.h>
#include <linux/greybus.h>
#include "firmware.h"
#include "greybus_firmware.h"
#define FW_MGMT_TIMEOUT_MS 1000
struct fw_mgmt {
struct device *parent;
struct gb_connection *connection;
struct kref kref;
struct list_head node;
/* Common id-map for interface and backend firmware requests */
struct ida id_map;
struct mutex mutex;
struct completion completion;
struct cdev cdev;
struct device *class_device;
dev_t dev_num;
unsigned int timeout_jiffies;
bool disabled; /* connection getting disabled */
/* Interface Firmware specific fields */
bool mode_switch_started;
bool intf_fw_loaded;
u8 intf_fw_request_id;
u8 intf_fw_status;
u16 intf_fw_major;
u16 intf_fw_minor;
/* Backend Firmware specific fields */
u8 backend_fw_request_id;
u8 backend_fw_status;
};
/*
* Number of minor devices this driver supports.
* There will be exactly one required per Interface.
*/
#define NUM_MINORS U8_MAX
static struct class *fw_mgmt_class;
static dev_t fw_mgmt_dev_num;
static DEFINE_IDA(fw_mgmt_minors_map);
static LIST_HEAD(fw_mgmt_list);
static DEFINE_MUTEX(list_mutex);
static void fw_mgmt_kref_release(struct kref *kref)
{
struct fw_mgmt *fw_mgmt = container_of(kref, struct fw_mgmt, kref);
ida_destroy(&fw_mgmt->id_map);
kfree(fw_mgmt);
}
/*
* All users of fw_mgmt take a reference (from within list_mutex lock), before
* they get a pointer to play with. And the structure will be freed only after
* the last user has put the reference to it.
*/
static void put_fw_mgmt(struct fw_mgmt *fw_mgmt)
{
kref_put(&fw_mgmt->kref, fw_mgmt_kref_release);
}
/* Caller must call put_fw_mgmt() after using struct fw_mgmt */
static struct fw_mgmt *get_fw_mgmt(struct cdev *cdev)
{
struct fw_mgmt *fw_mgmt;
mutex_lock(&list_mutex);
list_for_each_entry(fw_mgmt, &fw_mgmt_list, node) {
if (&fw_mgmt->cdev == cdev) {
kref_get(&fw_mgmt->kref);
goto unlock;
}
}
fw_mgmt = NULL;
unlock:
mutex_unlock(&list_mutex);
return fw_mgmt;
}
static int fw_mgmt_interface_fw_version_operation(struct fw_mgmt *fw_mgmt,
struct fw_mgmt_ioc_get_intf_version *fw_info)
{
struct gb_connection *connection = fw_mgmt->connection;
struct gb_fw_mgmt_interface_fw_version_response response;
int ret;
ret = gb_operation_sync(connection,
GB_FW_MGMT_TYPE_INTERFACE_FW_VERSION, NULL, 0,
&response, sizeof(response));
if (ret) {
dev_err(fw_mgmt->parent,
"failed to get interface firmware version (%d)\n", ret);
return ret;
}
fw_info->major = le16_to_cpu(response.major);
fw_info->minor = le16_to_cpu(response.minor);
strncpy(fw_info->firmware_tag, response.firmware_tag,
GB_FIRMWARE_TAG_MAX_SIZE);
/*
* The firmware-tag should be NULL terminated, otherwise throw error but
* don't fail.
*/
if (fw_info->firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE - 1] != '\0') {
dev_err(fw_mgmt->parent,
"fw-version: firmware-tag is not NULL terminated\n");
fw_info->firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE - 1] = '\0';
}
return 0;
}
static int fw_mgmt_load_and_validate_operation(struct fw_mgmt *fw_mgmt,
u8 load_method, const char *tag)
{
struct gb_fw_mgmt_load_and_validate_fw_request request;
int ret;
if (load_method != GB_FW_LOAD_METHOD_UNIPRO &&
load_method != GB_FW_LOAD_METHOD_INTERNAL) {
dev_err(fw_mgmt->parent,
"invalid load-method (%d)\n", load_method);
return -EINVAL;
}
request.load_method = load_method;
strncpy(request.firmware_tag, tag, GB_FIRMWARE_TAG_MAX_SIZE);
/*
* The firmware-tag should be NULL terminated, otherwise throw error and
* fail.
*/
if (request.firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE - 1] != '\0') {
dev_err(fw_mgmt->parent, "load-and-validate: firmware-tag is not NULL terminated\n");
return -EINVAL;
}
/* Allocate ids from 1 to 255 (u8-max), 0 is an invalid id */
ret = ida_simple_get(&fw_mgmt->id_map, 1, 256, GFP_KERNEL);
if (ret < 0) {
dev_err(fw_mgmt->parent, "failed to allocate request id (%d)\n",
ret);
return ret;
}
fw_mgmt->intf_fw_request_id = ret;
fw_mgmt->intf_fw_loaded = false;
request.request_id = ret;
ret = gb_operation_sync(fw_mgmt->connection,
GB_FW_MGMT_TYPE_LOAD_AND_VALIDATE_FW, &request,
sizeof(request), NULL, 0);
if (ret) {
ida_simple_remove(&fw_mgmt->id_map,
fw_mgmt->intf_fw_request_id);
fw_mgmt->intf_fw_request_id = 0;
dev_err(fw_mgmt->parent,
"load and validate firmware request failed (%d)\n",
ret);
return ret;
}
return 0;
}
static int fw_mgmt_interface_fw_loaded_operation(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct fw_mgmt *fw_mgmt = gb_connection_get_data(connection);
struct gb_fw_mgmt_loaded_fw_request *request;
/* No pending load and validate request ? */
if (!fw_mgmt->intf_fw_request_id) {
dev_err(fw_mgmt->parent,
"unexpected firmware loaded request received\n");
return -ENODEV;
}
if (op->request->payload_size != sizeof(*request)) {
dev_err(fw_mgmt->parent, "illegal size of firmware loaded request (%zu != %zu)\n",
op->request->payload_size, sizeof(*request));
return -EINVAL;
}
request = op->request->payload;
/* Invalid request-id ? */
if (request->request_id != fw_mgmt->intf_fw_request_id) {
dev_err(fw_mgmt->parent, "invalid request id for firmware loaded request (%02u != %02u)\n",
fw_mgmt->intf_fw_request_id, request->request_id);
return -ENODEV;
}
ida_simple_remove(&fw_mgmt->id_map, fw_mgmt->intf_fw_request_id);
fw_mgmt->intf_fw_request_id = 0;
fw_mgmt->intf_fw_status = request->status;
fw_mgmt->intf_fw_major = le16_to_cpu(request->major);
fw_mgmt->intf_fw_minor = le16_to_cpu(request->minor);
if (fw_mgmt->intf_fw_status == GB_FW_LOAD_STATUS_FAILED)
dev_err(fw_mgmt->parent,
"failed to load interface firmware, status:%02x\n",
fw_mgmt->intf_fw_status);
else if (fw_mgmt->intf_fw_status == GB_FW_LOAD_STATUS_VALIDATION_FAILED)
dev_err(fw_mgmt->parent,
"failed to validate interface firmware, status:%02x\n",
fw_mgmt->intf_fw_status);
else
fw_mgmt->intf_fw_loaded = true;
complete(&fw_mgmt->completion);
return 0;
}
static int fw_mgmt_backend_fw_version_operation(struct fw_mgmt *fw_mgmt,
struct fw_mgmt_ioc_get_backend_version *fw_info)
{
struct gb_connection *connection = fw_mgmt->connection;
struct gb_fw_mgmt_backend_fw_version_request request;
struct gb_fw_mgmt_backend_fw_version_response response;
int ret;
strncpy(request.firmware_tag, fw_info->firmware_tag,
GB_FIRMWARE_TAG_MAX_SIZE);
/*
* The firmware-tag should be NULL terminated, otherwise throw error and
* fail.
*/
if (request.firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE - 1] != '\0') {
dev_err(fw_mgmt->parent, "backend-version: firmware-tag is not NULL terminated\n");
return -EINVAL;
}
ret = gb_operation_sync(connection,
GB_FW_MGMT_TYPE_BACKEND_FW_VERSION, &request,
sizeof(request), &response, sizeof(response));
if (ret) {
dev_err(fw_mgmt->parent, "failed to get version of %s backend firmware (%d)\n",
fw_info->firmware_tag, ret);
return ret;
}
fw_info->status = response.status;
/* Reset version as that should be non-zero only for success case */
fw_info->major = 0;
fw_info->minor = 0;
switch (fw_info->status) {
case GB_FW_BACKEND_VERSION_STATUS_SUCCESS:
fw_info->major = le16_to_cpu(response.major);
fw_info->minor = le16_to_cpu(response.minor);
break;
case GB_FW_BACKEND_VERSION_STATUS_NOT_AVAILABLE:
case GB_FW_BACKEND_VERSION_STATUS_RETRY:
break;
case GB_FW_BACKEND_VERSION_STATUS_NOT_SUPPORTED:
dev_err(fw_mgmt->parent,
"Firmware with tag %s is not supported by Interface\n",
fw_info->firmware_tag);
break;
default:
dev_err(fw_mgmt->parent, "Invalid status received: %u\n",
fw_info->status);
}
return 0;
}
static int fw_mgmt_backend_fw_update_operation(struct fw_mgmt *fw_mgmt,
char *tag)
{
struct gb_fw_mgmt_backend_fw_update_request request;
int ret;
strncpy(request.firmware_tag, tag, GB_FIRMWARE_TAG_MAX_SIZE);
/*
* The firmware-tag should be NULL terminated, otherwise throw error and
* fail.
*/
if (request.firmware_tag[GB_FIRMWARE_TAG_MAX_SIZE - 1] != '\0') {
dev_err(fw_mgmt->parent, "backend-update: firmware-tag is not NULL terminated\n");
return -EINVAL;
}
/* Allocate ids from 1 to 255 (u8-max), 0 is an invalid id */
ret = ida_simple_get(&fw_mgmt->id_map, 1, 256, GFP_KERNEL);
if (ret < 0) {
dev_err(fw_mgmt->parent, "failed to allocate request id (%d)\n",
ret);
return ret;
}
fw_mgmt->backend_fw_request_id = ret;
request.request_id = ret;
ret = gb_operation_sync(fw_mgmt->connection,
GB_FW_MGMT_TYPE_BACKEND_FW_UPDATE, &request,
sizeof(request), NULL, 0);
if (ret) {
ida_simple_remove(&fw_mgmt->id_map,
fw_mgmt->backend_fw_request_id);
fw_mgmt->backend_fw_request_id = 0;
dev_err(fw_mgmt->parent,
"backend %s firmware update request failed (%d)\n", tag,
ret);
return ret;
}
return 0;
}
static int fw_mgmt_backend_fw_updated_operation(struct gb_operation *op)
{
struct gb_connection *connection = op->connection;
struct fw_mgmt *fw_mgmt = gb_connection_get_data(connection);
struct gb_fw_mgmt_backend_fw_updated_request *request;
/* No pending load and validate request ? */
if (!fw_mgmt->backend_fw_request_id) {
dev_err(fw_mgmt->parent, "unexpected backend firmware updated request received\n");
return -ENODEV;
}
if (op->request->payload_size != sizeof(*request)) {
dev_err(fw_mgmt->parent, "illegal size of backend firmware updated request (%zu != %zu)\n",
op->request->payload_size, sizeof(*request));
return -EINVAL;
}
request = op->request->payload;
/* Invalid request-id ? */
if (request->request_id != fw_mgmt->backend_fw_request_id) {
dev_err(fw_mgmt->parent, "invalid request id for backend firmware updated request (%02u != %02u)\n",
fw_mgmt->backend_fw_request_id, request->request_id);
return -ENODEV;
}
ida_simple_remove(&fw_mgmt->id_map, fw_mgmt->backend_fw_request_id);
fw_mgmt->backend_fw_request_id = 0;
fw_mgmt->backend_fw_status = request->status;
if ((fw_mgmt->backend_fw_status != GB_FW_BACKEND_FW_STATUS_SUCCESS) &&
(fw_mgmt->backend_fw_status != GB_FW_BACKEND_FW_STATUS_RETRY))
dev_err(fw_mgmt->parent,
"failed to load backend firmware: %02x\n",
fw_mgmt->backend_fw_status);
complete(&fw_mgmt->completion);
return 0;
}
/* Char device fops */
static int fw_mgmt_open(struct inode *inode, struct file *file)
{
struct fw_mgmt *fw_mgmt = get_fw_mgmt(inode->i_cdev);
/* fw_mgmt structure can't get freed until file descriptor is closed */
if (fw_mgmt) {
file->private_data = fw_mgmt;
return 0;
}
return -ENODEV;
}
static int fw_mgmt_release(struct inode *inode, struct file *file)
{
struct fw_mgmt *fw_mgmt = file->private_data;
put_fw_mgmt(fw_mgmt);
return 0;
}
static int fw_mgmt_ioctl(struct fw_mgmt *fw_mgmt, unsigned int cmd,
void __user *buf)
{
struct fw_mgmt_ioc_get_intf_version intf_fw_info;
struct fw_mgmt_ioc_get_backend_version backend_fw_info;
struct fw_mgmt_ioc_intf_load_and_validate intf_load;
struct fw_mgmt_ioc_backend_fw_update backend_update;
unsigned int timeout;
int ret;
/* Reject any operations after mode-switch has started */
if (fw_mgmt->mode_switch_started)
return -EBUSY;
switch (cmd) {
case FW_MGMT_IOC_GET_INTF_FW:
ret = fw_mgmt_interface_fw_version_operation(fw_mgmt,
&intf_fw_info);
if (ret)
return ret;
if (copy_to_user(buf, &intf_fw_info, sizeof(intf_fw_info)))
return -EFAULT;
return 0;
case FW_MGMT_IOC_GET_BACKEND_FW:
if (copy_from_user(&backend_fw_info, buf,
sizeof(backend_fw_info)))
return -EFAULT;
ret = fw_mgmt_backend_fw_version_operation(fw_mgmt,
&backend_fw_info);
if (ret)
return ret;
if (copy_to_user(buf, &backend_fw_info,
sizeof(backend_fw_info)))
return -EFAULT;
return 0;
case FW_MGMT_IOC_INTF_LOAD_AND_VALIDATE:
if (copy_from_user(&intf_load, buf, sizeof(intf_load)))
return -EFAULT;
ret = fw_mgmt_load_and_validate_operation(fw_mgmt,
intf_load.load_method, intf_load.firmware_tag);
if (ret)
return ret;
if (!wait_for_completion_timeout(&fw_mgmt->completion,
fw_mgmt->timeout_jiffies)) {
dev_err(fw_mgmt->parent, "timed out waiting for firmware load and validation to finish\n");
return -ETIMEDOUT;
}
intf_load.status = fw_mgmt->intf_fw_status;
intf_load.major = fw_mgmt->intf_fw_major;
intf_load.minor = fw_mgmt->intf_fw_minor;
if (copy_to_user(buf, &intf_load, sizeof(intf_load)))
return -EFAULT;
return 0;
case FW_MGMT_IOC_INTF_BACKEND_FW_UPDATE:
if (copy_from_user(&backend_update, buf,
sizeof(backend_update)))
return -EFAULT;
ret = fw_mgmt_backend_fw_update_operation(fw_mgmt,
backend_update.firmware_tag);
if (ret)
return ret;
if (!wait_for_completion_timeout(&fw_mgmt->completion,
fw_mgmt->timeout_jiffies)) {
dev_err(fw_mgmt->parent, "timed out waiting for backend firmware update to finish\n");
return -ETIMEDOUT;
}
backend_update.status = fw_mgmt->backend_fw_status;
if (copy_to_user(buf, &backend_update, sizeof(backend_update)))
return -EFAULT;
return 0;
case FW_MGMT_IOC_SET_TIMEOUT_MS:
if (get_user(timeout, (unsigned int __user *)buf))
return -EFAULT;
if (!timeout) {
dev_err(fw_mgmt->parent, "timeout can't be zero\n");
return -EINVAL;
}
fw_mgmt->timeout_jiffies = msecs_to_jiffies(timeout);
return 0;
case FW_MGMT_IOC_MODE_SWITCH:
if (!fw_mgmt->intf_fw_loaded) {
dev_err(fw_mgmt->parent,
"Firmware not loaded for mode-switch\n");
return -EPERM;
}
/*
* Disallow new ioctls as the fw-core bundle driver is going to
* get disconnected soon and the character device will get
* removed.
*/
fw_mgmt->mode_switch_started = true;
ret = gb_interface_request_mode_switch(fw_mgmt->connection->intf);
if (ret) {
dev_err(fw_mgmt->parent, "Mode-switch failed: %d\n",
ret);
fw_mgmt->mode_switch_started = false;
return ret;
}
return 0;
default:
return -ENOTTY;
}
}
static long fw_mgmt_ioctl_unlocked(struct file *file, unsigned int cmd,
unsigned long arg)
{
struct fw_mgmt *fw_mgmt = file->private_data;
struct gb_bundle *bundle = fw_mgmt->connection->bundle;
int ret = -ENODEV;
/*
* Serialize ioctls.
*
* We don't want the user to do few operations in parallel. For example,
* updating Interface firmware in parallel for the same Interface. There
* is no need to do things in parallel for speed and we can avoid having
* complicated code for now.
*
* This is also used to protect ->disabled, which is used to check if
* the connection is getting disconnected, so that we don't start any
* new operations.
*/
mutex_lock(&fw_mgmt->mutex);
if (!fw_mgmt->disabled) {
ret = gb_pm_runtime_get_sync(bundle);
if (!ret) {
ret = fw_mgmt_ioctl(fw_mgmt, cmd, (void __user *)arg);
gb_pm_runtime_put_autosuspend(bundle);
}
}
mutex_unlock(&fw_mgmt->mutex);
return ret;
}
static const struct file_operations fw_mgmt_fops = {
.owner = THIS_MODULE,
.open = fw_mgmt_open,
.release = fw_mgmt_release,
.unlocked_ioctl = fw_mgmt_ioctl_unlocked,
};
int gb_fw_mgmt_request_handler(struct gb_operation *op)
{
u8 type = op->type;
switch (type) {
case GB_FW_MGMT_TYPE_LOADED_FW:
return fw_mgmt_interface_fw_loaded_operation(op);
case GB_FW_MGMT_TYPE_BACKEND_FW_UPDATED:
return fw_mgmt_backend_fw_updated_operation(op);
default:
dev_err(&op->connection->bundle->dev,
"unsupported request: %u\n", type);
return -EINVAL;
}
}
int gb_fw_mgmt_connection_init(struct gb_connection *connection)
{
struct fw_mgmt *fw_mgmt;
int ret, minor;
if (!connection)
return 0;
fw_mgmt = kzalloc(sizeof(*fw_mgmt), GFP_KERNEL);
if (!fw_mgmt)
return -ENOMEM;
fw_mgmt->parent = &connection->bundle->dev;
fw_mgmt->timeout_jiffies = msecs_to_jiffies(FW_MGMT_TIMEOUT_MS);
fw_mgmt->connection = connection;
gb_connection_set_data(connection, fw_mgmt);
init_completion(&fw_mgmt->completion);
ida_init(&fw_mgmt->id_map);
mutex_init(&fw_mgmt->mutex);
kref_init(&fw_mgmt->kref);
mutex_lock(&list_mutex);
list_add(&fw_mgmt->node, &fw_mgmt_list);
mutex_unlock(&list_mutex);
ret = gb_connection_enable(connection);
if (ret)
goto err_list_del;
minor = ida_simple_get(&fw_mgmt_minors_map, 0, NUM_MINORS, GFP_KERNEL);
if (minor < 0) {
ret = minor;
goto err_connection_disable;
}
/* Add a char device to allow userspace to interact with fw-mgmt */
fw_mgmt->dev_num = MKDEV(MAJOR(fw_mgmt_dev_num), minor);
cdev_init(&fw_mgmt->cdev, &fw_mgmt_fops);
ret = cdev_add(&fw_mgmt->cdev, fw_mgmt->dev_num, 1);
if (ret)
goto err_remove_ida;
/* Add a soft link to the previously added char-dev within the bundle */
fw_mgmt->class_device = device_create(fw_mgmt_class, fw_mgmt->parent,
fw_mgmt->dev_num, NULL,
"gb-fw-mgmt-%d", minor);
if (IS_ERR(fw_mgmt->class_device)) {
ret = PTR_ERR(fw_mgmt->class_device);
goto err_del_cdev;
}
return 0;
err_del_cdev:
cdev_del(&fw_mgmt->cdev);
err_remove_ida:
ida_simple_remove(&fw_mgmt_minors_map, minor);
err_connection_disable:
gb_connection_disable(connection);
err_list_del:
mutex_lock(&list_mutex);
list_del(&fw_mgmt->node);
mutex_unlock(&list_mutex);
put_fw_mgmt(fw_mgmt);
return ret;
}
void gb_fw_mgmt_connection_exit(struct gb_connection *connection)
{
struct fw_mgmt *fw_mgmt;
if (!connection)
return;
fw_mgmt = gb_connection_get_data(connection);
device_destroy(fw_mgmt_class, fw_mgmt->dev_num);
cdev_del(&fw_mgmt->cdev);
ida_simple_remove(&fw_mgmt_minors_map, MINOR(fw_mgmt->dev_num));
/*
* Disallow any new ioctl operations on the char device and wait for
* existing ones to finish.
*/
mutex_lock(&fw_mgmt->mutex);
fw_mgmt->disabled = true;
mutex_unlock(&fw_mgmt->mutex);
/* All pending greybus operations should have finished by now */
gb_connection_disable(fw_mgmt->connection);
/* Disallow new users to get access to the fw_mgmt structure */
mutex_lock(&list_mutex);
list_del(&fw_mgmt->node);
mutex_unlock(&list_mutex);
/*
* All current users of fw_mgmt would have taken a reference to it by
* now, we can drop our reference and wait the last user will get
* fw_mgmt freed.
*/
put_fw_mgmt(fw_mgmt);
}
int fw_mgmt_init(void)
{
int ret;
fw_mgmt_class = class_create("gb_fw_mgmt");
if (IS_ERR(fw_mgmt_class))
return PTR_ERR(fw_mgmt_class);
ret = alloc_chrdev_region(&fw_mgmt_dev_num, 0, NUM_MINORS,
"gb_fw_mgmt");
if (ret)
goto err_remove_class;
return 0;
err_remove_class:
class_destroy(fw_mgmt_class);
return ret;
}
void fw_mgmt_exit(void)
{
unregister_chrdev_region(fw_mgmt_dev_num, NUM_MINORS);
class_destroy(fw_mgmt_class);
ida_destroy(&fw_mgmt_minors_map);
}
| linux-master | drivers/staging/greybus/fw-management.c |
// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
/*
* Sample code to test CAP protocol
*
* Copyright(c) 2016 Google Inc. All rights reserved.
* Copyright(c) 2016 Linaro Ltd. All rights reserved.
*/
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "../../greybus_authentication.h"
struct cap_ioc_get_endpoint_uid uid;
struct cap_ioc_get_ims_certificate cert = {
.certificate_class = 0,
.certificate_id = 0,
};
struct cap_ioc_authenticate authenticate = {
.auth_type = 0,
.challenge = {0},
};
int main(int argc, char *argv[])
{
unsigned int timeout = 10000;
char *capdev;
int fd, ret;
/* Make sure arguments are correct */
if (argc != 2) {
printf("\nUsage: ./firmware <Path of the gb-cap-X dev>\n");
return 0;
}
capdev = argv[1];
printf("Opening %s authentication device\n", capdev);
fd = open(capdev, O_RDWR);
if (fd < 0) {
printf("Failed to open: %s\n", capdev);
return -1;
}
/* Get UID */
printf("Get UID\n");
ret = ioctl(fd, CAP_IOC_GET_ENDPOINT_UID, &uid);
if (ret < 0) {
printf("Failed to get UID: %s (%d)\n", capdev, ret);
ret = -1;
goto close_fd;
}
printf("UID received: 0x%llx\n", *(unsigned long long int *)(uid.uid));
/* Get certificate */
printf("Get IMS certificate\n");
ret = ioctl(fd, CAP_IOC_GET_IMS_CERTIFICATE, &cert);
if (ret < 0) {
printf("Failed to get IMS certificate: %s (%d)\n", capdev, ret);
ret = -1;
goto close_fd;
}
printf("IMS Certificate size: %d\n", cert.cert_size);
/* Authenticate */
printf("Authenticate module\n");
memcpy(authenticate.uid, uid.uid, 8);
ret = ioctl(fd, CAP_IOC_AUTHENTICATE, &authenticate);
if (ret < 0) {
printf("Failed to authenticate module: %s (%d)\n", capdev, ret);
ret = -1;
goto close_fd;
}
printf("Authenticated, result (%02x), sig-size (%02x)\n",
authenticate.result_code, authenticate.signature_size);
close_fd:
close(fd);
return ret;
}
| linux-master | drivers/staging/greybus/Documentation/firmware/authenticate.c |
// SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
/*
* Sample code to test firmware-management protocol
*
* Copyright(c) 2016 Google Inc. All rights reserved.
* Copyright(c) 2016 Linaro Ltd. All rights reserved.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "../../greybus_firmware.h"
#define FW_DEV_DEFAULT "/dev/gb-fw-mgmt-0"
#define FW_TAG_INT_DEFAULT "s3f"
#define FW_TAG_BCND_DEFAULT "bf_01"
#define FW_UPDATE_TYPE_DEFAULT 0
#define FW_TIMEOUT_DEFAULT 10000
static const char *firmware_tag;
static const char *fwdev = FW_DEV_DEFAULT;
static unsigned int fw_update_type = FW_UPDATE_TYPE_DEFAULT;
static unsigned int fw_timeout = FW_TIMEOUT_DEFAULT;
static struct fw_mgmt_ioc_get_intf_version intf_fw_info;
static struct fw_mgmt_ioc_get_backend_version backend_fw_info;
static struct fw_mgmt_ioc_intf_load_and_validate intf_load;
static struct fw_mgmt_ioc_backend_fw_update backend_update;
static void usage(void)
{
printf("\nUsage: ./firmware <gb-fw-mgmt-X (default: gb-fw-mgmt-0)> <interface: 0, backend: 1 (default: 0)> <firmware-tag> (default: \"s3f\"/\"bf_01\") <timeout (default: 10000 ms)>\n");
}
static int update_intf_firmware(int fd)
{
int ret;
/* Get Interface Firmware Version */
printf("Get Interface Firmware Version\n");
ret = ioctl(fd, FW_MGMT_IOC_GET_INTF_FW, &intf_fw_info);
if (ret < 0) {
printf("Failed to get interface firmware version: %s (%d)\n",
fwdev, ret);
return -1;
}
printf("Interface Firmware tag (%s), major (%d), minor (%d)\n",
intf_fw_info.firmware_tag, intf_fw_info.major,
intf_fw_info.minor);
/* Try Interface Firmware load over Unipro */
printf("Loading Interface Firmware\n");
intf_load.load_method = GB_FW_U_LOAD_METHOD_UNIPRO;
intf_load.status = 0;
intf_load.major = 0;
intf_load.minor = 0;
strncpy((char *)&intf_load.firmware_tag, firmware_tag,
GB_FIRMWARE_U_TAG_MAX_SIZE);
ret = ioctl(fd, FW_MGMT_IOC_INTF_LOAD_AND_VALIDATE, &intf_load);
if (ret < 0) {
printf("Failed to load interface firmware: %s (%d)\n", fwdev,
ret);
return -1;
}
if (intf_load.status != GB_FW_U_LOAD_STATUS_VALIDATED &&
intf_load.status != GB_FW_U_LOAD_STATUS_UNVALIDATED) {
printf("Load status says loading failed: %d\n",
intf_load.status);
return -1;
}
printf("Interface Firmware (%s) Load done: major: %d, minor: %d, status: %d\n",
firmware_tag, intf_load.major, intf_load.minor,
intf_load.status);
/* Initiate Mode-switch to the newly loaded firmware */
printf("Initiate Mode switch\n");
ret = ioctl(fd, FW_MGMT_IOC_MODE_SWITCH);
if (ret < 0)
printf("Failed to initiate mode-switch (%d)\n", ret);
return ret;
}
static int update_backend_firmware(int fd)
{
int ret;
/* Get Backend Firmware Version */
printf("Getting Backend Firmware Version\n");
strncpy((char *)&backend_fw_info.firmware_tag, firmware_tag,
GB_FIRMWARE_U_TAG_MAX_SIZE);
retry_fw_version:
ret = ioctl(fd, FW_MGMT_IOC_GET_BACKEND_FW, &backend_fw_info);
if (ret < 0) {
printf("Failed to get backend firmware version: %s (%d)\n",
fwdev, ret);
return -1;
}
printf("Backend Firmware tag (%s), major (%d), minor (%d), status (%d)\n",
backend_fw_info.firmware_tag, backend_fw_info.major,
backend_fw_info.minor, backend_fw_info.status);
if (backend_fw_info.status == GB_FW_U_BACKEND_VERSION_STATUS_RETRY)
goto retry_fw_version;
if ((backend_fw_info.status != GB_FW_U_BACKEND_VERSION_STATUS_SUCCESS)
&& (backend_fw_info.status != GB_FW_U_BACKEND_VERSION_STATUS_NOT_AVAILABLE)) {
printf("Failed to get backend firmware version: %s (%d)\n",
fwdev, backend_fw_info.status);
return -1;
}
/* Try Backend Firmware Update over Unipro */
printf("Updating Backend Firmware\n");
strncpy((char *)&backend_update.firmware_tag, firmware_tag,
GB_FIRMWARE_U_TAG_MAX_SIZE);
retry_fw_update:
backend_update.status = 0;
ret = ioctl(fd, FW_MGMT_IOC_INTF_BACKEND_FW_UPDATE, &backend_update);
if (ret < 0) {
printf("Failed to load backend firmware: %s (%d)\n", fwdev, ret);
return -1;
}
if (backend_update.status == GB_FW_U_BACKEND_FW_STATUS_RETRY) {
printf("Retrying firmware update: %d\n", backend_update.status);
goto retry_fw_update;
}
if (backend_update.status != GB_FW_U_BACKEND_FW_STATUS_SUCCESS) {
printf("Load status says loading failed: %d\n",
backend_update.status);
} else {
printf("Backend Firmware (%s) Load done: status: %d\n",
firmware_tag, backend_update.status);
}
return 0;
}
int main(int argc, char *argv[])
{
int fd, ret;
char *endptr;
if (argc > 1 &&
(!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help"))) {
usage();
return -1;
}
if (argc > 1)
fwdev = argv[1];
if (argc > 2)
fw_update_type = strtoul(argv[2], &endptr, 10);
if (argc > 3)
firmware_tag = argv[3];
else if (!fw_update_type)
firmware_tag = FW_TAG_INT_DEFAULT;
else
firmware_tag = FW_TAG_BCND_DEFAULT;
if (argc > 4)
fw_timeout = strtoul(argv[4], &endptr, 10);
printf("Trying Firmware update: fwdev: %s, type: %s, tag: %s, timeout: %u\n",
fwdev, fw_update_type == 0 ? "interface" : "backend",
firmware_tag, fw_timeout);
printf("Opening %s firmware management device\n", fwdev);
fd = open(fwdev, O_RDWR);
if (fd < 0) {
printf("Failed to open: %s\n", fwdev);
return -1;
}
/* Set Timeout */
printf("Setting timeout to %u ms\n", fw_timeout);
ret = ioctl(fd, FW_MGMT_IOC_SET_TIMEOUT_MS, &fw_timeout);
if (ret < 0) {
printf("Failed to set timeout: %s (%d)\n", fwdev, ret);
ret = -1;
goto close_fd;
}
if (!fw_update_type)
ret = update_intf_firmware(fd);
else
ret = update_backend_firmware(fd);
close_fd:
close(fd);
return ret;
}
| linux-master | drivers/staging/greybus/Documentation/firmware/firmware.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* abstraction of the spi interface of HopeRf rf69 radio module
*
* Copyright (C) 2016 Wolf-Entwicklungen
* Marcus Wolf <[email protected]>
*/
#include <linux/types.h>
#include <linux/spi/spi.h>
#include "rf69.h"
#include "rf69_registers.h"
#define F_OSC 32000000 /* in Hz */
#define FIFO_SIZE 66 /* in byte */
/*-------------------------------------------------------------------------*/
u8 rf69_read_reg(struct spi_device *spi, u8 addr)
{
return spi_w8r8(spi, addr);
}
static int rf69_write_reg(struct spi_device *spi, u8 addr, u8 value)
{
char buffer[2];
buffer[0] = addr | WRITE_BIT;
buffer[1] = value;
return spi_write(spi, &buffer, ARRAY_SIZE(buffer));
}
/*-------------------------------------------------------------------------*/
static int rf69_set_bit(struct spi_device *spi, u8 reg, u8 mask)
{
u8 tmp;
tmp = rf69_read_reg(spi, reg);
tmp = tmp | mask;
return rf69_write_reg(spi, reg, tmp);
}
static int rf69_clear_bit(struct spi_device *spi, u8 reg, u8 mask)
{
u8 tmp;
tmp = rf69_read_reg(spi, reg);
tmp = tmp & ~mask;
return rf69_write_reg(spi, reg, tmp);
}
static inline int rf69_read_mod_write(struct spi_device *spi, u8 reg,
u8 mask, u8 value)
{
u8 tmp;
tmp = rf69_read_reg(spi, reg);
tmp = (tmp & ~mask) | value;
return rf69_write_reg(spi, reg, tmp);
}
/*-------------------------------------------------------------------------*/
int rf69_get_version(struct spi_device *spi)
{
return rf69_read_reg(spi, REG_VERSION);
}
int rf69_set_mode(struct spi_device *spi, enum mode mode)
{
static const u8 mode_map[] = {
[transmit] = OPMODE_MODE_TRANSMIT,
[receive] = OPMODE_MODE_RECEIVE,
[synthesizer] = OPMODE_MODE_SYNTHESIZER,
[standby] = OPMODE_MODE_STANDBY,
[mode_sleep] = OPMODE_MODE_SLEEP,
};
if (unlikely(mode >= ARRAY_SIZE(mode_map))) {
dev_dbg(&spi->dev, "set: illegal mode %u\n", mode);
return -EINVAL;
}
return rf69_read_mod_write(spi, REG_OPMODE, MASK_OPMODE_MODE,
mode_map[mode]);
/*
* we are using packet mode, so this check is not really needed
* but waiting for mode ready is necessary when going from sleep
* because the FIFO may not be immediately available from previous mode
* while (_mode == RF69_MODE_SLEEP && (READ_REG(REG_IRQFLAGS1) &
RF_IRQFLAGS1_MODEREADY) == 0x00); // Wait for ModeReady
*/
}
int rf69_set_data_mode(struct spi_device *spi, u8 data_mode)
{
return rf69_read_mod_write(spi, REG_DATAMODUL, MASK_DATAMODUL_MODE,
data_mode);
}
int rf69_set_modulation(struct spi_device *spi, enum modulation modulation)
{
static const u8 modulation_map[] = {
[OOK] = DATAMODUL_MODULATION_TYPE_OOK,
[FSK] = DATAMODUL_MODULATION_TYPE_FSK,
};
if (unlikely(modulation >= ARRAY_SIZE(modulation_map))) {
dev_dbg(&spi->dev, "set: illegal modulation %u\n", modulation);
return -EINVAL;
}
return rf69_read_mod_write(spi, REG_DATAMODUL,
MASK_DATAMODUL_MODULATION_TYPE,
modulation_map[modulation]);
}
static enum modulation rf69_get_modulation(struct spi_device *spi)
{
u8 modulation_reg;
modulation_reg = rf69_read_reg(spi, REG_DATAMODUL);
switch (modulation_reg & MASK_DATAMODUL_MODULATION_TYPE) {
case DATAMODUL_MODULATION_TYPE_OOK:
return OOK;
case DATAMODUL_MODULATION_TYPE_FSK:
return FSK;
default:
return UNDEF;
}
}
int rf69_set_modulation_shaping(struct spi_device *spi,
enum mod_shaping mod_shaping)
{
switch (rf69_get_modulation(spi)) {
case FSK:
switch (mod_shaping) {
case SHAPING_OFF:
return rf69_read_mod_write(spi, REG_DATAMODUL,
MASK_DATAMODUL_MODULATION_SHAPE,
DATAMODUL_MODULATION_SHAPE_NONE);
case SHAPING_1_0:
return rf69_read_mod_write(spi, REG_DATAMODUL,
MASK_DATAMODUL_MODULATION_SHAPE,
DATAMODUL_MODULATION_SHAPE_1_0);
case SHAPING_0_5:
return rf69_read_mod_write(spi, REG_DATAMODUL,
MASK_DATAMODUL_MODULATION_SHAPE,
DATAMODUL_MODULATION_SHAPE_0_5);
case SHAPING_0_3:
return rf69_read_mod_write(spi, REG_DATAMODUL,
MASK_DATAMODUL_MODULATION_SHAPE,
DATAMODUL_MODULATION_SHAPE_0_3);
default:
dev_dbg(&spi->dev, "set: illegal mod shaping for FSK %u\n", mod_shaping);
return -EINVAL;
}
case OOK:
switch (mod_shaping) {
case SHAPING_OFF:
return rf69_read_mod_write(spi, REG_DATAMODUL,
MASK_DATAMODUL_MODULATION_SHAPE,
DATAMODUL_MODULATION_SHAPE_NONE);
case SHAPING_BR:
return rf69_read_mod_write(spi, REG_DATAMODUL,
MASK_DATAMODUL_MODULATION_SHAPE,
DATAMODUL_MODULATION_SHAPE_BR);
case SHAPING_2BR:
return rf69_read_mod_write(spi, REG_DATAMODUL,
MASK_DATAMODUL_MODULATION_SHAPE,
DATAMODUL_MODULATION_SHAPE_2BR);
default:
dev_dbg(&spi->dev, "set: illegal mod shaping for OOK %u\n", mod_shaping);
return -EINVAL;
}
default:
dev_dbg(&spi->dev, "set: modulation undefined\n");
return -EINVAL;
}
}
int rf69_set_bit_rate(struct spi_device *spi, u16 bit_rate)
{
int retval;
u32 bit_rate_reg;
u8 msb;
u8 lsb;
enum modulation mod;
// check if modulation is configured
mod = rf69_get_modulation(spi);
if (mod == UNDEF) {
dev_dbg(&spi->dev, "setBitRate: modulation is undefined\n");
return -EINVAL;
}
// check input value
if (bit_rate < 1200 || (mod == OOK && bit_rate > 32768)) {
dev_dbg(&spi->dev, "setBitRate: illegal input param\n");
return -EINVAL;
}
// calculate reg settings
bit_rate_reg = (F_OSC / bit_rate);
msb = (bit_rate_reg & 0xff00) >> 8;
lsb = (bit_rate_reg & 0xff);
// transmit to RF 69
retval = rf69_write_reg(spi, REG_BITRATE_MSB, msb);
if (retval)
return retval;
retval = rf69_write_reg(spi, REG_BITRATE_LSB, lsb);
if (retval)
return retval;
return 0;
}
int rf69_set_deviation(struct spi_device *spi, u32 deviation)
{
int retval;
u64 f_reg;
u64 f_step;
u32 bit_rate_reg;
u32 bit_rate;
u8 msb;
u8 lsb;
u64 factor = 1000000; // to improve precision of calculation
// calculate bit rate
bit_rate_reg = rf69_read_reg(spi, REG_BITRATE_MSB) << 8;
bit_rate_reg |= rf69_read_reg(spi, REG_BITRATE_LSB);
bit_rate = F_OSC / bit_rate_reg;
/*
* frequency deviation must exceed 600 Hz but not exceed
* 500kHz when taking bitrate dependency into consideration
* to ensure proper modulation
*/
if (deviation < 600 || (deviation + (bit_rate / 2)) > 500000) {
dev_dbg(&spi->dev,
"set_deviation: illegal input param: %u\n", deviation);
return -EINVAL;
}
// calculat f step
f_step = F_OSC * factor;
do_div(f_step, 524288); // 524288 = 2^19
// calculate register settings
f_reg = deviation * factor;
do_div(f_reg, f_step);
msb = (f_reg & 0xff00) >> 8;
lsb = (f_reg & 0xff);
// check msb
if (msb & ~FDEVMASB_MASK) {
dev_dbg(&spi->dev, "set_deviation: err in calc of msb\n");
return -EINVAL;
}
// write to chip
retval = rf69_write_reg(spi, REG_FDEV_MSB, msb);
if (retval)
return retval;
retval = rf69_write_reg(spi, REG_FDEV_LSB, lsb);
if (retval)
return retval;
return 0;
}
int rf69_set_frequency(struct spi_device *spi, u32 frequency)
{
int retval;
u32 f_max;
u64 f_reg;
u64 f_step;
u8 msb;
u8 mid;
u8 lsb;
u64 factor = 1000000; // to improve precision of calculation
// calculat f step
f_step = F_OSC * factor;
do_div(f_step, 524288); // 524288 = 2^19
// check input value
f_max = div_u64(f_step * 8388608, factor);
if (frequency > f_max) {
dev_dbg(&spi->dev, "setFrequency: illegal input param\n");
return -EINVAL;
}
// calculate reg settings
f_reg = frequency * factor;
do_div(f_reg, f_step);
msb = (f_reg & 0xff0000) >> 16;
mid = (f_reg & 0xff00) >> 8;
lsb = (f_reg & 0xff);
// write to chip
retval = rf69_write_reg(spi, REG_FRF_MSB, msb);
if (retval)
return retval;
retval = rf69_write_reg(spi, REG_FRF_MID, mid);
if (retval)
return retval;
retval = rf69_write_reg(spi, REG_FRF_LSB, lsb);
if (retval)
return retval;
return 0;
}
int rf69_enable_amplifier(struct spi_device *spi, u8 amplifier_mask)
{
return rf69_set_bit(spi, REG_PALEVEL, amplifier_mask);
}
int rf69_disable_amplifier(struct spi_device *spi, u8 amplifier_mask)
{
return rf69_clear_bit(spi, REG_PALEVEL, amplifier_mask);
}
int rf69_set_output_power_level(struct spi_device *spi, u8 power_level)
{
u8 pa_level, ocp, test_pa1, test_pa2;
bool pa0, pa1, pa2, high_power;
u8 min_power_level;
// check register pa_level
pa_level = rf69_read_reg(spi, REG_PALEVEL);
pa0 = pa_level & MASK_PALEVEL_PA0;
pa1 = pa_level & MASK_PALEVEL_PA1;
pa2 = pa_level & MASK_PALEVEL_PA2;
// check high power mode
ocp = rf69_read_reg(spi, REG_OCP);
test_pa1 = rf69_read_reg(spi, REG_TESTPA1);
test_pa2 = rf69_read_reg(spi, REG_TESTPA2);
high_power = (ocp == 0x0f) && (test_pa1 == 0x5d) && (test_pa2 == 0x7c);
if (pa0 && !pa1 && !pa2) {
power_level += 18;
min_power_level = 0;
} else if (!pa0 && pa1 && !pa2) {
power_level += 18;
min_power_level = 16;
} else if (!pa0 && pa1 && pa2) {
if (high_power)
power_level += 11;
else
power_level += 14;
min_power_level = 16;
} else {
goto failed;
}
// check input value
if (power_level > 0x1f)
goto failed;
if (power_level < min_power_level)
goto failed;
// write value
return rf69_read_mod_write(spi, REG_PALEVEL, MASK_PALEVEL_OUTPUT_POWER,
power_level);
failed:
dev_dbg(&spi->dev, "set: illegal power level %u\n", power_level);
return -EINVAL;
}
int rf69_set_pa_ramp(struct spi_device *spi, enum pa_ramp pa_ramp)
{
static const u8 pa_ramp_map[] = {
[ramp3400] = PARAMP_3400,
[ramp2000] = PARAMP_2000,
[ramp1000] = PARAMP_1000,
[ramp500] = PARAMP_500,
[ramp250] = PARAMP_250,
[ramp125] = PARAMP_125,
[ramp100] = PARAMP_100,
[ramp62] = PARAMP_62,
[ramp50] = PARAMP_50,
[ramp40] = PARAMP_40,
[ramp31] = PARAMP_31,
[ramp25] = PARAMP_25,
[ramp20] = PARAMP_20,
[ramp15] = PARAMP_15,
[ramp10] = PARAMP_10,
};
if (unlikely(pa_ramp >= ARRAY_SIZE(pa_ramp_map))) {
dev_dbg(&spi->dev, "set: illegal pa_ramp %u\n", pa_ramp);
return -EINVAL;
}
return rf69_write_reg(spi, REG_PARAMP, pa_ramp_map[pa_ramp]);
}
int rf69_set_antenna_impedance(struct spi_device *spi,
enum antenna_impedance antenna_impedance)
{
switch (antenna_impedance) {
case fifty_ohm:
return rf69_clear_bit(spi, REG_LNA, MASK_LNA_ZIN);
case two_hundred_ohm:
return rf69_set_bit(spi, REG_LNA, MASK_LNA_ZIN);
default:
dev_dbg(&spi->dev, "set: illegal antenna impedance %u\n", antenna_impedance);
return -EINVAL;
}
}
int rf69_set_lna_gain(struct spi_device *spi, enum lna_gain lna_gain)
{
static const u8 lna_gain_map[] = {
[automatic] = LNA_GAIN_AUTO,
[max] = LNA_GAIN_MAX,
[max_minus_6] = LNA_GAIN_MAX_MINUS_6,
[max_minus_12] = LNA_GAIN_MAX_MINUS_12,
[max_minus_24] = LNA_GAIN_MAX_MINUS_24,
[max_minus_36] = LNA_GAIN_MAX_MINUS_36,
[max_minus_48] = LNA_GAIN_MAX_MINUS_48,
};
if (unlikely(lna_gain >= ARRAY_SIZE(lna_gain_map))) {
dev_dbg(&spi->dev, "set: illegal lna gain %u\n", lna_gain);
return -EINVAL;
}
return rf69_read_mod_write(spi, REG_LNA, MASK_LNA_GAIN,
lna_gain_map[lna_gain]);
}
static int rf69_set_bandwidth_intern(struct spi_device *spi, u8 reg,
enum mantisse mantisse, u8 exponent)
{
u8 bandwidth;
// check value for mantisse and exponent
if (exponent > 7) {
dev_dbg(&spi->dev, "set: illegal bandwidth exponent %u\n", exponent);
return -EINVAL;
}
if (mantisse != mantisse16 &&
mantisse != mantisse20 &&
mantisse != mantisse24) {
dev_dbg(&spi->dev, "set: illegal bandwidth mantisse %u\n", mantisse);
return -EINVAL;
}
// read old value
bandwidth = rf69_read_reg(spi, reg);
// "delete" mantisse and exponent = just keep the DCC setting
bandwidth = bandwidth & MASK_BW_DCC_FREQ;
// add new mantisse
switch (mantisse) {
case mantisse16:
bandwidth = bandwidth | BW_MANT_16;
break;
case mantisse20:
bandwidth = bandwidth | BW_MANT_20;
break;
case mantisse24:
bandwidth = bandwidth | BW_MANT_24;
break;
}
// add new exponent
bandwidth = bandwidth | exponent;
// write back
return rf69_write_reg(spi, reg, bandwidth);
}
int rf69_set_bandwidth(struct spi_device *spi, enum mantisse mantisse,
u8 exponent)
{
return rf69_set_bandwidth_intern(spi, REG_RXBW, mantisse, exponent);
}
int rf69_set_bandwidth_during_afc(struct spi_device *spi,
enum mantisse mantisse,
u8 exponent)
{
return rf69_set_bandwidth_intern(spi, REG_AFCBW, mantisse, exponent);
}
int rf69_set_ook_threshold_dec(struct spi_device *spi,
enum threshold_decrement threshold_decrement)
{
static const u8 td_map[] = {
[dec_every8th] = OOKPEAK_THRESHDEC_EVERY_8TH,
[dec_every4th] = OOKPEAK_THRESHDEC_EVERY_4TH,
[dec_every2nd] = OOKPEAK_THRESHDEC_EVERY_2ND,
[dec_once] = OOKPEAK_THRESHDEC_ONCE,
[dec_twice] = OOKPEAK_THRESHDEC_TWICE,
[dec_4times] = OOKPEAK_THRESHDEC_4_TIMES,
[dec_8times] = OOKPEAK_THRESHDEC_8_TIMES,
[dec_16times] = OOKPEAK_THRESHDEC_16_TIMES,
};
if (unlikely(threshold_decrement >= ARRAY_SIZE(td_map))) {
dev_dbg(&spi->dev, "set: illegal OOK threshold decrement %u\n",
threshold_decrement);
return -EINVAL;
}
return rf69_read_mod_write(spi, REG_OOKPEAK, MASK_OOKPEAK_THRESDEC,
td_map[threshold_decrement]);
}
int rf69_set_dio_mapping(struct spi_device *spi, u8 dio_number, u8 value)
{
u8 mask;
u8 shift;
u8 dio_addr;
u8 dio_value;
switch (dio_number) {
case 0:
mask = MASK_DIO0;
shift = SHIFT_DIO0;
dio_addr = REG_DIOMAPPING1;
break;
case 1:
mask = MASK_DIO1;
shift = SHIFT_DIO1;
dio_addr = REG_DIOMAPPING1;
break;
case 2:
mask = MASK_DIO2;
shift = SHIFT_DIO2;
dio_addr = REG_DIOMAPPING1;
break;
case 3:
mask = MASK_DIO3;
shift = SHIFT_DIO3;
dio_addr = REG_DIOMAPPING1;
break;
case 4:
mask = MASK_DIO4;
shift = SHIFT_DIO4;
dio_addr = REG_DIOMAPPING2;
break;
case 5:
mask = MASK_DIO5;
shift = SHIFT_DIO5;
dio_addr = REG_DIOMAPPING2;
break;
default:
dev_dbg(&spi->dev, "set: illegal dio number %u\n", dio_number);
return -EINVAL;
}
// read reg
dio_value = rf69_read_reg(spi, dio_addr);
// delete old value
dio_value = dio_value & ~mask;
// add new value
dio_value = dio_value | value << shift;
// write back
return rf69_write_reg(spi, dio_addr, dio_value);
}
int rf69_set_rssi_threshold(struct spi_device *spi, u8 threshold)
{
/* no value check needed - u8 exactly matches register size */
return rf69_write_reg(spi, REG_RSSITHRESH, threshold);
}
int rf69_set_preamble_length(struct spi_device *spi, u16 preamble_length)
{
int retval;
u8 msb, lsb;
/* no value check needed - u16 exactly matches register size */
/* calculate reg settings */
msb = (preamble_length & 0xff00) >> 8;
lsb = (preamble_length & 0xff);
/* transmit to chip */
retval = rf69_write_reg(spi, REG_PREAMBLE_MSB, msb);
if (retval)
return retval;
return rf69_write_reg(spi, REG_PREAMBLE_LSB, lsb);
}
int rf69_enable_sync(struct spi_device *spi)
{
return rf69_set_bit(spi, REG_SYNC_CONFIG, MASK_SYNC_CONFIG_SYNC_ON);
}
int rf69_disable_sync(struct spi_device *spi)
{
return rf69_clear_bit(spi, REG_SYNC_CONFIG, MASK_SYNC_CONFIG_SYNC_ON);
}
int rf69_set_fifo_fill_condition(struct spi_device *spi,
enum fifo_fill_condition fifo_fill_condition)
{
switch (fifo_fill_condition) {
case always:
return rf69_set_bit(spi, REG_SYNC_CONFIG,
MASK_SYNC_CONFIG_FIFO_FILL_CONDITION);
case after_sync_interrupt:
return rf69_clear_bit(spi, REG_SYNC_CONFIG,
MASK_SYNC_CONFIG_FIFO_FILL_CONDITION);
default:
dev_dbg(&spi->dev, "set: illegal fifo fill condition %u\n", fifo_fill_condition);
return -EINVAL;
}
}
int rf69_set_sync_size(struct spi_device *spi, u8 sync_size)
{
// check input value
if (sync_size > 0x07) {
dev_dbg(&spi->dev, "set: illegal sync size %u\n", sync_size);
return -EINVAL;
}
// write value
return rf69_read_mod_write(spi, REG_SYNC_CONFIG,
MASK_SYNC_CONFIG_SYNC_SIZE,
(sync_size << 3));
}
int rf69_set_sync_values(struct spi_device *spi, u8 sync_values[8])
{
int retval = 0;
retval += rf69_write_reg(spi, REG_SYNCVALUE1, sync_values[0]);
retval += rf69_write_reg(spi, REG_SYNCVALUE2, sync_values[1]);
retval += rf69_write_reg(spi, REG_SYNCVALUE3, sync_values[2]);
retval += rf69_write_reg(spi, REG_SYNCVALUE4, sync_values[3]);
retval += rf69_write_reg(spi, REG_SYNCVALUE5, sync_values[4]);
retval += rf69_write_reg(spi, REG_SYNCVALUE6, sync_values[5]);
retval += rf69_write_reg(spi, REG_SYNCVALUE7, sync_values[6]);
retval += rf69_write_reg(spi, REG_SYNCVALUE8, sync_values[7]);
return retval;
}
int rf69_set_packet_format(struct spi_device *spi,
enum packet_format packet_format)
{
switch (packet_format) {
case packet_length_var:
return rf69_set_bit(spi, REG_PACKETCONFIG1,
MASK_PACKETCONFIG1_PACKET_FORMAT_VARIABLE);
case packet_length_fix:
return rf69_clear_bit(spi, REG_PACKETCONFIG1,
MASK_PACKETCONFIG1_PACKET_FORMAT_VARIABLE);
default:
dev_dbg(&spi->dev, "set: illegal packet format %u\n", packet_format);
return -EINVAL;
}
}
int rf69_enable_crc(struct spi_device *spi)
{
return rf69_set_bit(spi, REG_PACKETCONFIG1, MASK_PACKETCONFIG1_CRC_ON);
}
int rf69_disable_crc(struct spi_device *spi)
{
return rf69_clear_bit(spi, REG_PACKETCONFIG1, MASK_PACKETCONFIG1_CRC_ON);
}
int rf69_set_address_filtering(struct spi_device *spi,
enum address_filtering address_filtering)
{
static const u8 af_map[] = {
[filtering_off] = PACKETCONFIG1_ADDRESSFILTERING_OFF,
[node_address] = PACKETCONFIG1_ADDRESSFILTERING_NODE,
[node_or_broadcast_address] =
PACKETCONFIG1_ADDRESSFILTERING_NODEBROADCAST,
};
if (unlikely(address_filtering >= ARRAY_SIZE(af_map))) {
dev_dbg(&spi->dev, "set: illegal address filtering %u\n", address_filtering);
return -EINVAL;
}
return rf69_read_mod_write(spi, REG_PACKETCONFIG1,
MASK_PACKETCONFIG1_ADDRESSFILTERING,
af_map[address_filtering]);
}
int rf69_set_payload_length(struct spi_device *spi, u8 payload_length)
{
return rf69_write_reg(spi, REG_PAYLOAD_LENGTH, payload_length);
}
int rf69_set_node_address(struct spi_device *spi, u8 node_address)
{
return rf69_write_reg(spi, REG_NODEADRS, node_address);
}
int rf69_set_broadcast_address(struct spi_device *spi, u8 broadcast_address)
{
return rf69_write_reg(spi, REG_BROADCASTADRS, broadcast_address);
}
int rf69_set_tx_start_condition(struct spi_device *spi,
enum tx_start_condition tx_start_condition)
{
switch (tx_start_condition) {
case fifo_level:
return rf69_clear_bit(spi, REG_FIFO_THRESH,
MASK_FIFO_THRESH_TXSTART);
case fifo_not_empty:
return rf69_set_bit(spi, REG_FIFO_THRESH,
MASK_FIFO_THRESH_TXSTART);
default:
dev_dbg(&spi->dev, "set: illegal tx start condition %u\n", tx_start_condition);
return -EINVAL;
}
}
int rf69_set_fifo_threshold(struct spi_device *spi, u8 threshold)
{
int retval;
/* check input value */
if (threshold & ~MASK_FIFO_THRESH_VALUE) {
dev_dbg(&spi->dev, "set: illegal fifo threshold %u\n", threshold);
return -EINVAL;
}
/* write value */
retval = rf69_read_mod_write(spi, REG_FIFO_THRESH,
MASK_FIFO_THRESH_VALUE,
threshold);
if (retval)
return retval;
/*
* access the fifo to activate new threshold
* retval (mis-) used as buffer here
*/
return rf69_read_fifo(spi, (u8 *)&retval, 1);
}
int rf69_set_dagc(struct spi_device *spi, enum dagc dagc)
{
static const u8 dagc_map[] = {
[normal_mode] = DAGC_NORMAL,
[improve] = DAGC_IMPROVED_LOWBETA0,
[improve_for_low_modulation_index] = DAGC_IMPROVED_LOWBETA1,
};
if (unlikely(dagc >= ARRAY_SIZE(dagc_map))) {
dev_dbg(&spi->dev, "set: illegal dagc %u\n", dagc);
return -EINVAL;
}
return rf69_write_reg(spi, REG_TESTDAGC, dagc_map[dagc]);
}
/*-------------------------------------------------------------------------*/
int rf69_read_fifo(struct spi_device *spi, u8 *buffer, unsigned int size)
{
int i;
struct spi_transfer transfer;
u8 local_buffer[FIFO_SIZE + 1] = {};
int retval;
if (size > FIFO_SIZE) {
dev_dbg(&spi->dev,
"read fifo: passed in buffer bigger then internal buffer\n");
return -EMSGSIZE;
}
/* prepare a bidirectional transfer */
local_buffer[0] = REG_FIFO;
memset(&transfer, 0, sizeof(transfer));
transfer.tx_buf = local_buffer;
transfer.rx_buf = local_buffer;
transfer.len = size + 1;
retval = spi_sync_transfer(spi, &transfer, 1);
/* print content read from fifo for debugging purposes */
for (i = 0; i < size; i++)
dev_dbg(&spi->dev, "%d - 0x%x\n", i, local_buffer[i + 1]);
memcpy(buffer, &local_buffer[1], size);
return retval;
}
int rf69_write_fifo(struct spi_device *spi, u8 *buffer, unsigned int size)
{
int i;
u8 local_buffer[FIFO_SIZE + 1];
if (size > FIFO_SIZE) {
dev_dbg(&spi->dev,
"write fifo: passed in buffer bigger then internal buffer\n");
return -EMSGSIZE;
}
local_buffer[0] = REG_FIFO | WRITE_BIT;
memcpy(&local_buffer[1], buffer, size);
/* print content written from fifo for debugging purposes */
for (i = 0; i < size; i++)
dev_dbg(&spi->dev, "%d - 0x%x\n", i, buffer[i]);
return spi_write(spi, local_buffer, size + 1);
}
| linux-master | drivers/staging/pi433/rf69.c |
// SPDX-License-Identifier: GPL-2.0+
/*
* userspace interface for pi433 radio module
*
* Pi433 is a 433MHz radio module for the Raspberry Pi.
* It is based on the HopeRf Module RFM69CW. Therefore inside of this
* driver, you'll find an abstraction of the rf69 chip.
*
* If needed, this driver could be extended, to also support other
* devices, basing on HopeRfs rf69.
*
* The driver can also be extended, to support other modules of
* HopeRf with a similar interace - e. g. RFM69HCW, RFM12, RFM95, ...
*
* Copyright (C) 2016 Wolf-Entwicklungen
* Marcus Wolf <[email protected]>
*/
#undef DEBUG
#include <linux/init.h>
#include <linux/module.h>
#include <linux/idr.h>
#include <linux/ioctl.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/err.h>
#include <linux/kfifo.h>
#include <linux/errno.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/gpio/consumer.h>
#include <linux/kthread.h>
#include <linux/wait.h>
#include <linux/spi/spi.h>
#ifdef CONFIG_COMPAT
#include <linux/compat.h>
#endif
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include "pi433_if.h"
#include "rf69.h"
#define N_PI433_MINORS BIT(MINORBITS) /*32*/ /* ... up to 256 */
#define MAX_MSG_SIZE 900 /* min: FIFO_SIZE! */
#define MSG_FIFO_SIZE 65536 /* 65536 = 2^16 */
#define NUM_DIO 2
static dev_t pi433_dev;
static DEFINE_IDR(pi433_idr);
static DEFINE_MUTEX(minor_lock); /* Protect idr accesses */
static struct dentry *root_dir; /* debugfs root directory for the driver */
static struct class *pi433_class; /* mainly for udev to create /dev/pi433 */
/*
* tx config is instance specific
* so with each open a new tx config struct is needed
*/
/*
* rx config is device specific
* so we have just one rx config, ebedded in device struct
*/
struct pi433_device {
/* device handling related values */
dev_t devt;
int minor;
struct device *dev;
struct cdev *cdev;
struct spi_device *spi;
/* irq related values */
struct gpio_desc *gpiod[NUM_DIO];
int irq_num[NUM_DIO];
u8 irq_state[NUM_DIO];
/* tx related values */
STRUCT_KFIFO_REC_1(MSG_FIFO_SIZE) tx_fifo;
struct mutex tx_fifo_lock; /* serialize userspace writers */
struct task_struct *tx_task_struct;
wait_queue_head_t tx_wait_queue;
u8 free_in_fifo;
char buffer[MAX_MSG_SIZE];
/* rx related values */
struct pi433_rx_cfg rx_cfg;
u8 *rx_buffer;
unsigned int rx_buffer_size;
u32 rx_bytes_to_drop;
u32 rx_bytes_dropped;
unsigned int rx_position;
struct mutex rx_lock; /* protects rx_* variable accesses */
wait_queue_head_t rx_wait_queue;
/* fifo wait queue */
struct task_struct *fifo_task_struct;
wait_queue_head_t fifo_wait_queue;
/* flags */
bool rx_active;
bool tx_active;
bool interrupt_rx_allowed;
};
struct pi433_instance {
struct pi433_device *device;
struct pi433_tx_cfg tx_cfg;
/* control flags */
bool tx_cfg_initialized;
};
/*-------------------------------------------------------------------------*/
/* GPIO interrupt handlers */
static irqreturn_t DIO0_irq_handler(int irq, void *dev_id)
{
struct pi433_device *device = dev_id;
if (device->irq_state[DIO0] == DIO_PACKET_SENT) {
device->free_in_fifo = FIFO_SIZE;
dev_dbg(device->dev, "DIO0 irq: Packet sent\n");
wake_up_interruptible(&device->fifo_wait_queue);
} else if (device->irq_state[DIO0] == DIO_RSSI_DIO0) {
dev_dbg(device->dev, "DIO0 irq: RSSI level over threshold\n");
wake_up_interruptible(&device->rx_wait_queue);
} else if (device->irq_state[DIO0] == DIO_PAYLOAD_READY) {
dev_dbg(device->dev, "DIO0 irq: Payload ready\n");
device->free_in_fifo = 0;
wake_up_interruptible(&device->fifo_wait_queue);
}
return IRQ_HANDLED;
}
static irqreturn_t DIO1_irq_handler(int irq, void *dev_id)
{
struct pi433_device *device = dev_id;
if (device->irq_state[DIO1] == DIO_FIFO_NOT_EMPTY_DIO1) {
device->free_in_fifo = FIFO_SIZE;
} else if (device->irq_state[DIO1] == DIO_FIFO_LEVEL) {
if (device->rx_active)
device->free_in_fifo = FIFO_THRESHOLD - 1;
else
device->free_in_fifo = FIFO_SIZE - FIFO_THRESHOLD - 1;
}
dev_dbg(device->dev,
"DIO1 irq: %d bytes free in fifo\n", device->free_in_fifo);
wake_up_interruptible(&device->fifo_wait_queue);
return IRQ_HANDLED;
}
/*-------------------------------------------------------------------------*/
static int
rf69_set_rx_cfg(struct pi433_device *dev, struct pi433_rx_cfg *rx_cfg)
{
int ret;
int payload_length;
/* receiver config */
ret = rf69_set_frequency(dev->spi, rx_cfg->frequency);
if (ret < 0)
return ret;
ret = rf69_set_modulation(dev->spi, rx_cfg->modulation);
if (ret < 0)
return ret;
ret = rf69_set_bit_rate(dev->spi, rx_cfg->bit_rate);
if (ret < 0)
return ret;
ret = rf69_set_antenna_impedance(dev->spi, rx_cfg->antenna_impedance);
if (ret < 0)
return ret;
ret = rf69_set_rssi_threshold(dev->spi, rx_cfg->rssi_threshold);
if (ret < 0)
return ret;
ret = rf69_set_ook_threshold_dec(dev->spi, rx_cfg->threshold_decrement);
if (ret < 0)
return ret;
ret = rf69_set_bandwidth(dev->spi, rx_cfg->bw_mantisse,
rx_cfg->bw_exponent);
if (ret < 0)
return ret;
ret = rf69_set_bandwidth_during_afc(dev->spi, rx_cfg->bw_mantisse,
rx_cfg->bw_exponent);
if (ret < 0)
return ret;
ret = rf69_set_dagc(dev->spi, rx_cfg->dagc);
if (ret < 0)
return ret;
dev->rx_bytes_to_drop = rx_cfg->bytes_to_drop;
/* packet config */
/* enable */
if (rx_cfg->enable_sync == OPTION_ON) {
ret = rf69_enable_sync(dev->spi);
if (ret < 0)
return ret;
ret = rf69_set_fifo_fill_condition(dev->spi,
after_sync_interrupt);
if (ret < 0)
return ret;
} else {
ret = rf69_disable_sync(dev->spi);
if (ret < 0)
return ret;
ret = rf69_set_fifo_fill_condition(dev->spi, always);
if (ret < 0)
return ret;
}
if (rx_cfg->enable_length_byte == OPTION_ON) {
ret = rf69_set_packet_format(dev->spi, packet_length_var);
if (ret < 0)
return ret;
} else {
ret = rf69_set_packet_format(dev->spi, packet_length_fix);
if (ret < 0)
return ret;
}
ret = rf69_set_address_filtering(dev->spi,
rx_cfg->enable_address_filtering);
if (ret < 0)
return ret;
if (rx_cfg->enable_crc == OPTION_ON) {
ret = rf69_enable_crc(dev->spi);
if (ret < 0)
return ret;
} else {
ret = rf69_disable_crc(dev->spi);
if (ret < 0)
return ret;
}
/* lengths */
ret = rf69_set_sync_size(dev->spi, rx_cfg->sync_length);
if (ret < 0)
return ret;
if (rx_cfg->enable_length_byte == OPTION_ON) {
ret = rf69_set_payload_length(dev->spi, 0xff);
if (ret < 0)
return ret;
} else if (rx_cfg->fixed_message_length != 0) {
payload_length = rx_cfg->fixed_message_length;
if (rx_cfg->enable_length_byte == OPTION_ON)
payload_length++;
if (rx_cfg->enable_address_filtering != filtering_off)
payload_length++;
ret = rf69_set_payload_length(dev->spi, payload_length);
if (ret < 0)
return ret;
} else {
ret = rf69_set_payload_length(dev->spi, 0);
if (ret < 0)
return ret;
}
/* values */
if (rx_cfg->enable_sync == OPTION_ON) {
ret = rf69_set_sync_values(dev->spi, rx_cfg->sync_pattern);
if (ret < 0)
return ret;
}
if (rx_cfg->enable_address_filtering != filtering_off) {
ret = rf69_set_node_address(dev->spi, rx_cfg->node_address);
if (ret < 0)
return ret;
ret = rf69_set_broadcast_address(dev->spi,
rx_cfg->broadcast_address);
if (ret < 0)
return ret;
}
return 0;
}
static int
rf69_set_tx_cfg(struct pi433_device *dev, struct pi433_tx_cfg *tx_cfg)
{
int ret;
ret = rf69_set_frequency(dev->spi, tx_cfg->frequency);
if (ret < 0)
return ret;
ret = rf69_set_modulation(dev->spi, tx_cfg->modulation);
if (ret < 0)
return ret;
ret = rf69_set_bit_rate(dev->spi, tx_cfg->bit_rate);
if (ret < 0)
return ret;
ret = rf69_set_deviation(dev->spi, tx_cfg->dev_frequency);
if (ret < 0)
return ret;
ret = rf69_set_pa_ramp(dev->spi, tx_cfg->pa_ramp);
if (ret < 0)
return ret;
ret = rf69_set_modulation_shaping(dev->spi, tx_cfg->mod_shaping);
if (ret < 0)
return ret;
ret = rf69_set_tx_start_condition(dev->spi, tx_cfg->tx_start_condition);
if (ret < 0)
return ret;
/* packet format enable */
if (tx_cfg->enable_preamble == OPTION_ON) {
ret = rf69_set_preamble_length(dev->spi,
tx_cfg->preamble_length);
if (ret < 0)
return ret;
} else {
ret = rf69_set_preamble_length(dev->spi, 0);
if (ret < 0)
return ret;
}
if (tx_cfg->enable_sync == OPTION_ON) {
ret = rf69_set_sync_size(dev->spi, tx_cfg->sync_length);
if (ret < 0)
return ret;
ret = rf69_set_sync_values(dev->spi, tx_cfg->sync_pattern);
if (ret < 0)
return ret;
ret = rf69_enable_sync(dev->spi);
if (ret < 0)
return ret;
} else {
ret = rf69_disable_sync(dev->spi);
if (ret < 0)
return ret;
}
if (tx_cfg->enable_length_byte == OPTION_ON) {
ret = rf69_set_packet_format(dev->spi, packet_length_var);
if (ret < 0)
return ret;
} else {
ret = rf69_set_packet_format(dev->spi, packet_length_fix);
if (ret < 0)
return ret;
}
if (tx_cfg->enable_crc == OPTION_ON) {
ret = rf69_enable_crc(dev->spi);
if (ret < 0)
return ret;
} else {
ret = rf69_disable_crc(dev->spi);
if (ret < 0)
return ret;
}
return 0;
}
/*-------------------------------------------------------------------------*/
static int pi433_start_rx(struct pi433_device *dev)
{
int retval;
/* return without action, if no pending read request */
if (!dev->rx_active)
return 0;
/* setup for receiving */
retval = rf69_set_rx_cfg(dev, &dev->rx_cfg);
if (retval)
return retval;
/* setup rssi irq */
retval = rf69_set_dio_mapping(dev->spi, DIO0, DIO_RSSI_DIO0);
if (retval < 0)
return retval;
dev->irq_state[DIO0] = DIO_RSSI_DIO0;
irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
/* setup fifo level interrupt */
retval = rf69_set_fifo_threshold(dev->spi, FIFO_SIZE - FIFO_THRESHOLD);
if (retval < 0)
return retval;
retval = rf69_set_dio_mapping(dev->spi, DIO1, DIO_FIFO_LEVEL);
if (retval < 0)
return retval;
dev->irq_state[DIO1] = DIO_FIFO_LEVEL;
irq_set_irq_type(dev->irq_num[DIO1], IRQ_TYPE_EDGE_RISING);
/* set module to receiving mode */
retval = rf69_set_mode(dev->spi, receive);
if (retval < 0)
return retval;
return 0;
}
/*-------------------------------------------------------------------------*/
static int pi433_receive(void *data)
{
struct pi433_device *dev = data;
struct spi_device *spi = dev->spi;
int bytes_to_read, bytes_total;
int retval;
dev->interrupt_rx_allowed = false;
/* wait for any tx to finish */
dev_dbg(dev->dev, "rx: going to wait for any tx to finish\n");
retval = wait_event_interruptible(dev->rx_wait_queue, !dev->tx_active);
if (retval) {
/* wait was interrupted */
dev->interrupt_rx_allowed = true;
wake_up_interruptible(&dev->tx_wait_queue);
return retval;
}
/* prepare status vars */
dev->free_in_fifo = FIFO_SIZE;
dev->rx_position = 0;
dev->rx_bytes_dropped = 0;
/* setup radio module to listen for something "in the air" */
retval = pi433_start_rx(dev);
if (retval)
return retval;
/* now check RSSI, if low wait for getting high (RSSI interrupt) */
while (!(rf69_read_reg(spi, REG_IRQFLAGS1) & MASK_IRQFLAGS1_RSSI)) {
/* allow tx to interrupt us while waiting for high RSSI */
dev->interrupt_rx_allowed = true;
wake_up_interruptible(&dev->tx_wait_queue);
/* wait for RSSI level to become high */
dev_dbg(dev->dev, "rx: going to wait for high RSSI level\n");
retval = wait_event_interruptible(dev->rx_wait_queue,
rf69_read_reg(spi, REG_IRQFLAGS1) &
MASK_IRQFLAGS1_RSSI);
if (retval) /* wait was interrupted */
goto abort;
dev->interrupt_rx_allowed = false;
/* cross check for ongoing tx */
if (!dev->tx_active)
break;
}
/* configure payload ready irq */
retval = rf69_set_dio_mapping(spi, DIO0, DIO_PAYLOAD_READY);
if (retval < 0)
goto abort;
dev->irq_state[DIO0] = DIO_PAYLOAD_READY;
irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
/* fixed or unlimited length? */
if (dev->rx_cfg.fixed_message_length != 0) {
if (dev->rx_cfg.fixed_message_length > dev->rx_buffer_size) {
retval = -1;
goto abort;
}
bytes_total = dev->rx_cfg.fixed_message_length;
dev_dbg(dev->dev, "rx: msg len set to %d by fixed length\n",
bytes_total);
} else {
bytes_total = dev->rx_buffer_size;
dev_dbg(dev->dev, "rx: msg len set to %d as requested by read\n",
bytes_total);
}
/* length byte enabled? */
if (dev->rx_cfg.enable_length_byte == OPTION_ON) {
retval = wait_event_interruptible(dev->fifo_wait_queue,
dev->free_in_fifo < FIFO_SIZE);
if (retval) /* wait was interrupted */
goto abort;
rf69_read_fifo(spi, (u8 *)&bytes_total, 1);
if (bytes_total > dev->rx_buffer_size) {
retval = -1;
goto abort;
}
dev->free_in_fifo++;
dev_dbg(dev->dev, "rx: msg len reset to %d due to length byte\n",
bytes_total);
}
/* address byte enabled? */
if (dev->rx_cfg.enable_address_filtering != filtering_off) {
u8 dummy;
bytes_total--;
retval = wait_event_interruptible(dev->fifo_wait_queue,
dev->free_in_fifo < FIFO_SIZE);
if (retval) /* wait was interrupted */
goto abort;
rf69_read_fifo(spi, &dummy, 1);
dev->free_in_fifo++;
dev_dbg(dev->dev, "rx: address byte stripped off\n");
}
/* get payload */
while (dev->rx_position < bytes_total) {
if (!(rf69_read_reg(spi, REG_IRQFLAGS2) & MASK_IRQFLAGS2_PAYLOAD_READY)) {
retval = wait_event_interruptible(dev->fifo_wait_queue,
dev->free_in_fifo < FIFO_SIZE);
if (retval) /* wait was interrupted */
goto abort;
}
/* need to drop bytes or acquire? */
if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped)
bytes_to_read = dev->rx_bytes_to_drop -
dev->rx_bytes_dropped;
else
bytes_to_read = bytes_total - dev->rx_position;
/* access the fifo */
if (bytes_to_read > FIFO_SIZE - dev->free_in_fifo)
bytes_to_read = FIFO_SIZE - dev->free_in_fifo;
retval = rf69_read_fifo(spi,
&dev->rx_buffer[dev->rx_position],
bytes_to_read);
if (retval) /* read failed */
goto abort;
dev->free_in_fifo += bytes_to_read;
/* adjust status vars */
if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped)
dev->rx_bytes_dropped += bytes_to_read;
else
dev->rx_position += bytes_to_read;
}
/* rx done, wait was interrupted or error occurred */
abort:
dev->interrupt_rx_allowed = true;
if (rf69_set_mode(dev->spi, standby))
pr_err("rf69_set_mode(): radio module failed to go standby\n");
wake_up_interruptible(&dev->tx_wait_queue);
if (retval)
return retval;
else
return bytes_total;
}
static int pi433_tx_thread(void *data)
{
struct pi433_device *device = data;
struct spi_device *spi = device->spi;
struct pi433_tx_cfg tx_cfg;
size_t size;
bool rx_interrupted = false;
int position, repetitions;
int retval;
while (1) {
/* wait for fifo to be populated or for request to terminate*/
dev_dbg(device->dev, "thread: going to wait for new messages\n");
wait_event_interruptible(device->tx_wait_queue,
(!kfifo_is_empty(&device->tx_fifo) ||
kthread_should_stop()));
if (kthread_should_stop())
return 0;
/*
* get data from fifo in the following order:
* - tx_cfg
* - size of message
* - message
*/
retval = kfifo_out(&device->tx_fifo, &tx_cfg, sizeof(tx_cfg));
if (retval != sizeof(tx_cfg)) {
dev_dbg(device->dev,
"reading tx_cfg from fifo failed: got %d byte(s), expected %d\n",
retval, (unsigned int)sizeof(tx_cfg));
continue;
}
retval = kfifo_out(&device->tx_fifo, &size, sizeof(size_t));
if (retval != sizeof(size_t)) {
dev_dbg(device->dev,
"reading msg size from fifo failed: got %d, expected %d\n",
retval, (unsigned int)sizeof(size_t));
continue;
}
/* use fixed message length, if requested */
if (tx_cfg.fixed_message_length != 0)
size = tx_cfg.fixed_message_length;
/* increase size, if len byte is requested */
if (tx_cfg.enable_length_byte == OPTION_ON)
size++;
/* increase size, if adr byte is requested */
if (tx_cfg.enable_address_byte == OPTION_ON)
size++;
/* prime buffer */
memset(device->buffer, 0, size);
position = 0;
/* add length byte, if requested */
if (tx_cfg.enable_length_byte == OPTION_ON)
/*
* according to spec, length byte itself must be
* excluded from the length calculation
*/
device->buffer[position++] = size - 1;
/* add adr byte, if requested */
if (tx_cfg.enable_address_byte == OPTION_ON)
device->buffer[position++] = tx_cfg.address_byte;
/* finally get message data from fifo */
retval = kfifo_out(&device->tx_fifo, &device->buffer[position],
sizeof(device->buffer) - position);
dev_dbg(device->dev,
"read %d message byte(s) from fifo queue.\n", retval);
/*
* if rx is active, we need to interrupt the waiting for
* incoming telegrams, to be able to send something.
* We are only allowed, if currently no reception takes
* place otherwise we need to wait for the incoming telegram
* to finish
*/
wait_event_interruptible(device->tx_wait_queue,
!device->rx_active ||
device->interrupt_rx_allowed);
/*
* prevent race conditions
* irq will be reenabled after tx config is set
*/
disable_irq(device->irq_num[DIO0]);
device->tx_active = true;
/* clear fifo, set fifo threshold, set payload length */
retval = rf69_set_mode(spi, standby); /* this clears the fifo */
if (retval < 0)
goto abort;
if (device->rx_active && !rx_interrupted) {
/*
* rx is currently waiting for a telegram;
* we need to set the radio module to standby
*/
rx_interrupted = true;
}
retval = rf69_set_fifo_threshold(spi, FIFO_THRESHOLD);
if (retval < 0)
goto abort;
if (tx_cfg.enable_length_byte == OPTION_ON) {
retval = rf69_set_payload_length(spi, size * tx_cfg.repetitions);
if (retval < 0)
goto abort;
} else {
retval = rf69_set_payload_length(spi, 0);
if (retval < 0)
goto abort;
}
/* configure the rf chip */
retval = rf69_set_tx_cfg(device, &tx_cfg);
if (retval < 0)
goto abort;
/* enable fifo level interrupt */
retval = rf69_set_dio_mapping(spi, DIO1, DIO_FIFO_LEVEL);
if (retval < 0)
goto abort;
device->irq_state[DIO1] = DIO_FIFO_LEVEL;
irq_set_irq_type(device->irq_num[DIO1], IRQ_TYPE_EDGE_FALLING);
/* enable packet sent interrupt */
retval = rf69_set_dio_mapping(spi, DIO0, DIO_PACKET_SENT);
if (retval < 0)
goto abort;
device->irq_state[DIO0] = DIO_PACKET_SENT;
irq_set_irq_type(device->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
enable_irq(device->irq_num[DIO0]); /* was disabled by rx active check */
/* enable transmission */
retval = rf69_set_mode(spi, transmit);
if (retval < 0)
goto abort;
/* transfer this msg (and repetitions) to chip fifo */
device->free_in_fifo = FIFO_SIZE;
position = 0;
repetitions = tx_cfg.repetitions;
while ((repetitions > 0) && (size > position)) {
if ((size - position) > device->free_in_fifo) {
/* msg to big for fifo - take a part */
int write_size = device->free_in_fifo;
device->free_in_fifo = 0;
rf69_write_fifo(spi,
&device->buffer[position],
write_size);
position += write_size;
} else {
/* msg fits into fifo - take all */
device->free_in_fifo -= size;
repetitions--;
rf69_write_fifo(spi,
&device->buffer[position],
(size - position));
position = 0; /* reset for next repetition */
}
retval = wait_event_interruptible(device->fifo_wait_queue,
device->free_in_fifo > 0);
if (retval) {
dev_dbg(device->dev, "ABORT\n");
goto abort;
}
}
/* we are done. Wait for packet to get sent */
dev_dbg(device->dev,
"thread: wait for packet to get sent/fifo to be empty\n");
wait_event_interruptible(device->fifo_wait_queue,
device->free_in_fifo == FIFO_SIZE ||
kthread_should_stop());
if (kthread_should_stop())
return 0;
/* STOP_TRANSMISSION */
dev_dbg(device->dev, "thread: Packet sent. Set mode to stby.\n");
retval = rf69_set_mode(spi, standby);
if (retval < 0)
goto abort;
/* everything sent? */
if (kfifo_is_empty(&device->tx_fifo)) {
abort:
if (rx_interrupted) {
rx_interrupted = false;
pi433_start_rx(device);
}
device->tx_active = false;
wake_up_interruptible(&device->rx_wait_queue);
}
}
}
/*-------------------------------------------------------------------------*/
static ssize_t
pi433_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos)
{
struct pi433_instance *instance;
struct pi433_device *device;
int bytes_received;
ssize_t retval;
/* check, whether internal buffer is big enough for requested size */
if (size > MAX_MSG_SIZE)
return -EMSGSIZE;
instance = filp->private_data;
device = instance->device;
/* just one read request at a time */
mutex_lock(&device->rx_lock);
if (device->rx_active) {
mutex_unlock(&device->rx_lock);
return -EAGAIN;
}
device->rx_active = true;
mutex_unlock(&device->rx_lock);
/* start receiving */
/* will block until something was received*/
device->rx_buffer_size = size;
bytes_received = pi433_receive(device);
/* release rx */
mutex_lock(&device->rx_lock);
device->rx_active = false;
mutex_unlock(&device->rx_lock);
/* if read was successful copy to user space*/
if (bytes_received > 0) {
retval = copy_to_user(buf, device->rx_buffer, bytes_received);
if (retval)
return -EFAULT;
}
return bytes_received;
}
static ssize_t
pi433_write(struct file *filp, const char __user *buf,
size_t count, loff_t *f_pos)
{
struct pi433_instance *instance;
struct pi433_device *device;
int retval;
unsigned int required, available, copied;
instance = filp->private_data;
device = instance->device;
/*
* check, whether internal buffer (tx thread) is big enough
* for requested size
*/
if (count > MAX_MSG_SIZE)
return -EMSGSIZE;
/*
* check if tx_cfg has been initialized otherwise we won't be able to
* config the RF trasmitter correctly due to invalid settings
*/
if (!instance->tx_cfg_initialized) {
dev_notice_once(device->dev,
"write: failed due to unconfigured tx_cfg (see PI433_IOC_WR_TX_CFG)\n");
return -EINVAL;
}
/*
* write the following sequence into fifo:
* - tx_cfg
* - size of message
* - message
*/
mutex_lock(&device->tx_fifo_lock);
required = sizeof(instance->tx_cfg) + sizeof(size_t) + count;
available = kfifo_avail(&device->tx_fifo);
if (required > available) {
dev_dbg(device->dev, "write to fifo failed: %d bytes required but %d available\n",
required, available);
mutex_unlock(&device->tx_fifo_lock);
return -EAGAIN;
}
retval = kfifo_in(&device->tx_fifo, &instance->tx_cfg,
sizeof(instance->tx_cfg));
if (retval != sizeof(instance->tx_cfg))
goto abort;
retval = kfifo_in(&device->tx_fifo, &count, sizeof(size_t));
if (retval != sizeof(size_t))
goto abort;
retval = kfifo_from_user(&device->tx_fifo, buf, count, &copied);
if (retval || copied != count)
goto abort;
mutex_unlock(&device->tx_fifo_lock);
/* start transfer */
wake_up_interruptible(&device->tx_wait_queue);
dev_dbg(device->dev, "write: generated new msg with %d bytes.\n", copied);
return copied;
abort:
dev_warn(device->dev,
"write to fifo failed, non recoverable: 0x%x\n", retval);
mutex_unlock(&device->tx_fifo_lock);
return -EAGAIN;
}
static long pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
struct pi433_instance *instance;
struct pi433_device *device;
struct pi433_tx_cfg tx_cfg;
void __user *argp = (void __user *)arg;
/* Check type and command number */
if (_IOC_TYPE(cmd) != PI433_IOC_MAGIC)
return -ENOTTY;
instance = filp->private_data;
device = instance->device;
if (!device)
return -ESHUTDOWN;
switch (cmd) {
case PI433_IOC_RD_TX_CFG:
if (copy_to_user(argp, &instance->tx_cfg,
sizeof(struct pi433_tx_cfg)))
return -EFAULT;
break;
case PI433_IOC_WR_TX_CFG:
if (copy_from_user(&tx_cfg, argp, sizeof(struct pi433_tx_cfg)))
return -EFAULT;
mutex_lock(&device->tx_fifo_lock);
memcpy(&instance->tx_cfg, &tx_cfg, sizeof(struct pi433_tx_cfg));
instance->tx_cfg_initialized = true;
mutex_unlock(&device->tx_fifo_lock);
break;
case PI433_IOC_RD_RX_CFG:
if (copy_to_user(argp, &device->rx_cfg,
sizeof(struct pi433_rx_cfg)))
return -EFAULT;
break;
case PI433_IOC_WR_RX_CFG:
mutex_lock(&device->rx_lock);
/* during pendig read request, change of config not allowed */
if (device->rx_active) {
mutex_unlock(&device->rx_lock);
return -EAGAIN;
}
if (copy_from_user(&device->rx_cfg, argp,
sizeof(struct pi433_rx_cfg))) {
mutex_unlock(&device->rx_lock);
return -EFAULT;
}
mutex_unlock(&device->rx_lock);
break;
default:
return -EINVAL;
}
return 0;
}
/*-------------------------------------------------------------------------*/
static int pi433_open(struct inode *inode, struct file *filp)
{
struct pi433_device *device;
struct pi433_instance *instance;
mutex_lock(&minor_lock);
device = idr_find(&pi433_idr, iminor(inode));
mutex_unlock(&minor_lock);
if (!device) {
pr_debug("device: minor %d unknown.\n", iminor(inode));
return -ENODEV;
}
instance = kzalloc(sizeof(*instance), GFP_KERNEL);
if (!instance)
return -ENOMEM;
/* setup instance data*/
instance->device = device;
/* instance data as context */
filp->private_data = instance;
stream_open(inode, filp);
return 0;
}
static int pi433_release(struct inode *inode, struct file *filp)
{
struct pi433_instance *instance;
instance = filp->private_data;
kfree(instance);
filp->private_data = NULL;
return 0;
}
/*-------------------------------------------------------------------------*/
static int setup_gpio(struct pi433_device *device)
{
char name[5];
int retval;
int i;
const irq_handler_t DIO_irq_handler[NUM_DIO] = {
DIO0_irq_handler,
DIO1_irq_handler
};
for (i = 0; i < NUM_DIO; i++) {
/* "construct" name and get the gpio descriptor */
snprintf(name, sizeof(name), "DIO%d", i);
device->gpiod[i] = gpiod_get(&device->spi->dev, name,
0 /*GPIOD_IN*/);
if (device->gpiod[i] == ERR_PTR(-ENOENT)) {
dev_dbg(&device->spi->dev,
"Could not find entry for %s. Ignoring.\n", name);
continue;
}
if (device->gpiod[i] == ERR_PTR(-EBUSY))
dev_dbg(&device->spi->dev, "%s is busy.\n", name);
if (IS_ERR(device->gpiod[i])) {
retval = PTR_ERR(device->gpiod[i]);
/* release already allocated gpios */
for (i--; i >= 0; i--) {
free_irq(device->irq_num[i], device);
gpiod_put(device->gpiod[i]);
}
return retval;
}
/* configure the pin */
retval = gpiod_direction_input(device->gpiod[i]);
if (retval)
return retval;
/* configure irq */
device->irq_num[i] = gpiod_to_irq(device->gpiod[i]);
if (device->irq_num[i] < 0) {
device->gpiod[i] = ERR_PTR(-EINVAL);
return device->irq_num[i];
}
retval = request_irq(device->irq_num[i],
DIO_irq_handler[i],
0, /* flags */
name,
device);
if (retval)
return retval;
dev_dbg(&device->spi->dev, "%s successfully configured\n", name);
}
return 0;
}
static void free_gpio(struct pi433_device *device)
{
int i;
for (i = 0; i < NUM_DIO; i++) {
/* check if gpiod is valid */
if (IS_ERR(device->gpiod[i]))
continue;
free_irq(device->irq_num[i], device);
gpiod_put(device->gpiod[i]);
}
}
static int pi433_get_minor(struct pi433_device *device)
{
int retval = -ENOMEM;
mutex_lock(&minor_lock);
retval = idr_alloc(&pi433_idr, device, 0, N_PI433_MINORS, GFP_KERNEL);
if (retval >= 0) {
device->minor = retval;
retval = 0;
} else if (retval == -ENOSPC) {
dev_err(&device->spi->dev, "too many pi433 devices\n");
retval = -EINVAL;
}
mutex_unlock(&minor_lock);
return retval;
}
static void pi433_free_minor(struct pi433_device *dev)
{
mutex_lock(&minor_lock);
idr_remove(&pi433_idr, dev->minor);
mutex_unlock(&minor_lock);
}
/*-------------------------------------------------------------------------*/
static const struct file_operations pi433_fops = {
.owner = THIS_MODULE,
/*
* REVISIT switch to aio primitives, so that userspace
* gets more complete API coverage. It'll simplify things
* too, except for the locking.
*/
.write = pi433_write,
.read = pi433_read,
.unlocked_ioctl = pi433_ioctl,
.compat_ioctl = compat_ptr_ioctl,
.open = pi433_open,
.release = pi433_release,
.llseek = no_llseek,
};
static int pi433_debugfs_regs_show(struct seq_file *m, void *p)
{
struct pi433_device *dev;
u8 reg_data[114];
int i;
char *fmt = "0x%02x, 0x%02x\n";
int ret;
dev = m->private;
mutex_lock(&dev->tx_fifo_lock);
mutex_lock(&dev->rx_lock);
// wait for on-going operations to finish
ret = wait_event_interruptible(dev->rx_wait_queue, !dev->tx_active);
if (ret)
goto out_unlock;
ret = wait_event_interruptible(dev->tx_wait_queue, !dev->rx_active);
if (ret)
goto out_unlock;
// skip FIFO register (0x0) otherwise this can affect some of uC ops
for (i = 1; i < 0x50; i++)
reg_data[i] = rf69_read_reg(dev->spi, i);
reg_data[REG_TESTLNA] = rf69_read_reg(dev->spi, REG_TESTLNA);
reg_data[REG_TESTPA1] = rf69_read_reg(dev->spi, REG_TESTPA1);
reg_data[REG_TESTPA2] = rf69_read_reg(dev->spi, REG_TESTPA2);
reg_data[REG_TESTDAGC] = rf69_read_reg(dev->spi, REG_TESTDAGC);
reg_data[REG_TESTAFC] = rf69_read_reg(dev->spi, REG_TESTAFC);
seq_puts(m, "# reg, val\n");
for (i = 1; i < 0x50; i++)
seq_printf(m, fmt, i, reg_data[i]);
seq_printf(m, fmt, REG_TESTLNA, reg_data[REG_TESTLNA]);
seq_printf(m, fmt, REG_TESTPA1, reg_data[REG_TESTPA1]);
seq_printf(m, fmt, REG_TESTPA2, reg_data[REG_TESTPA2]);
seq_printf(m, fmt, REG_TESTDAGC, reg_data[REG_TESTDAGC]);
seq_printf(m, fmt, REG_TESTAFC, reg_data[REG_TESTAFC]);
out_unlock:
mutex_unlock(&dev->rx_lock);
mutex_unlock(&dev->tx_fifo_lock);
return ret;
}
DEFINE_SHOW_ATTRIBUTE(pi433_debugfs_regs);
/*-------------------------------------------------------------------------*/
static int pi433_probe(struct spi_device *spi)
{
struct pi433_device *device;
int retval;
struct dentry *entry;
/* setup spi parameters */
spi->mode = 0x00;
spi->bits_per_word = 8;
/*
* spi->max_speed_hz = 10000000;
* 1MHz already set by device tree overlay
*/
retval = spi_setup(spi);
if (retval) {
dev_dbg(&spi->dev, "configuration of SPI interface failed!\n");
return retval;
}
dev_dbg(&spi->dev,
"spi interface setup: mode 0x%2x, %d bits per word, %dhz max speed\n",
spi->mode, spi->bits_per_word, spi->max_speed_hz);
/* read chip version */
retval = rf69_get_version(spi);
if (retval < 0)
return retval;
switch (retval) {
case 0x24:
dev_dbg(&spi->dev, "found pi433 (ver. 0x%x)\n", retval);
break;
default:
dev_dbg(&spi->dev, "unknown chip version: 0x%x\n", retval);
return -ENODEV;
}
/* Allocate driver data */
device = kzalloc(sizeof(*device), GFP_KERNEL);
if (!device)
return -ENOMEM;
/* Initialize the driver data */
device->spi = spi;
device->rx_active = false;
device->tx_active = false;
device->interrupt_rx_allowed = false;
/* init rx buffer */
device->rx_buffer = kmalloc(MAX_MSG_SIZE, GFP_KERNEL);
if (!device->rx_buffer) {
retval = -ENOMEM;
goto RX_failed;
}
/* init wait queues */
init_waitqueue_head(&device->tx_wait_queue);
init_waitqueue_head(&device->rx_wait_queue);
init_waitqueue_head(&device->fifo_wait_queue);
/* init fifo */
INIT_KFIFO(device->tx_fifo);
/* init mutexes and locks */
mutex_init(&device->tx_fifo_lock);
mutex_init(&device->rx_lock);
/* setup GPIO (including irq_handler) for the different DIOs */
retval = setup_gpio(device);
if (retval) {
dev_dbg(&spi->dev, "setup of GPIOs failed\n");
goto GPIO_failed;
}
/* setup the radio module */
retval = rf69_set_mode(spi, standby);
if (retval < 0)
goto minor_failed;
retval = rf69_set_data_mode(spi, DATAMODUL_MODE_PACKET);
if (retval < 0)
goto minor_failed;
retval = rf69_enable_amplifier(spi, MASK_PALEVEL_PA0);
if (retval < 0)
goto minor_failed;
retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA1);
if (retval < 0)
goto minor_failed;
retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA2);
if (retval < 0)
goto minor_failed;
retval = rf69_set_output_power_level(spi, 13);
if (retval < 0)
goto minor_failed;
retval = rf69_set_antenna_impedance(spi, fifty_ohm);
if (retval < 0)
goto minor_failed;
/* determ minor number */
retval = pi433_get_minor(device);
if (retval) {
dev_dbg(&spi->dev, "get of minor number failed\n");
goto minor_failed;
}
/* create device */
device->devt = MKDEV(MAJOR(pi433_dev), device->minor);
device->dev = device_create(pi433_class,
&spi->dev,
device->devt,
device,
"pi433.%d",
device->minor);
if (IS_ERR(device->dev)) {
pr_err("pi433: device register failed\n");
retval = PTR_ERR(device->dev);
goto device_create_failed;
} else {
dev_dbg(device->dev,
"created device for major %d, minor %d\n",
MAJOR(pi433_dev),
device->minor);
}
/* start tx thread */
device->tx_task_struct = kthread_run(pi433_tx_thread,
device,
"pi433.%d_tx_task",
device->minor);
if (IS_ERR(device->tx_task_struct)) {
dev_dbg(device->dev, "start of send thread failed\n");
retval = PTR_ERR(device->tx_task_struct);
goto send_thread_failed;
}
/* create cdev */
device->cdev = cdev_alloc();
if (!device->cdev) {
dev_dbg(device->dev, "allocation of cdev failed\n");
retval = -ENOMEM;
goto cdev_failed;
}
device->cdev->owner = THIS_MODULE;
cdev_init(device->cdev, &pi433_fops);
retval = cdev_add(device->cdev, device->devt, 1);
if (retval) {
dev_dbg(device->dev, "register of cdev failed\n");
goto del_cdev;
}
/* spi setup */
spi_set_drvdata(spi, device);
entry = debugfs_create_dir(dev_name(device->dev), root_dir);
debugfs_create_file("regs", 0400, entry, device, &pi433_debugfs_regs_fops);
return 0;
del_cdev:
cdev_del(device->cdev);
cdev_failed:
kthread_stop(device->tx_task_struct);
send_thread_failed:
device_destroy(pi433_class, device->devt);
device_create_failed:
pi433_free_minor(device);
minor_failed:
free_gpio(device);
GPIO_failed:
kfree(device->rx_buffer);
RX_failed:
kfree(device);
return retval;
}
static void pi433_remove(struct spi_device *spi)
{
struct pi433_device *device = spi_get_drvdata(spi);
debugfs_lookup_and_remove(dev_name(device->dev), root_dir);
/* free GPIOs */
free_gpio(device);
/* make sure ops on existing fds can abort cleanly */
device->spi = NULL;
kthread_stop(device->tx_task_struct);
device_destroy(pi433_class, device->devt);
cdev_del(device->cdev);
pi433_free_minor(device);
kfree(device->rx_buffer);
kfree(device);
}
static const struct of_device_id pi433_dt_ids[] = {
{ .compatible = "Smarthome-Wolf,pi433" },
{},
};
MODULE_DEVICE_TABLE(of, pi433_dt_ids);
static struct spi_driver pi433_spi_driver = {
.driver = {
.name = "pi433",
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(pi433_dt_ids),
},
.probe = pi433_probe,
.remove = pi433_remove,
/*
* NOTE: suspend/resume methods are not necessary here.
* We don't do anything except pass the requests to/from
* the underlying controller. The refrigerator handles
* most issues; the controller driver handles the rest.
*/
};
/*-------------------------------------------------------------------------*/
static int __init pi433_init(void)
{
int status;
/*
* If MAX_MSG_SIZE is smaller then FIFO_SIZE, the driver won't
* work stable - risk of buffer overflow
*/
if (MAX_MSG_SIZE < FIFO_SIZE)
return -EINVAL;
/*
* Claim device numbers. Then register a class
* that will key udev/mdev to add/remove /dev nodes.
* Last, register the driver which manages those device numbers.
*/
status = alloc_chrdev_region(&pi433_dev, 0, N_PI433_MINORS, "pi433");
if (status < 0)
return status;
pi433_class = class_create("pi433");
if (IS_ERR(pi433_class)) {
unregister_chrdev(MAJOR(pi433_dev),
pi433_spi_driver.driver.name);
return PTR_ERR(pi433_class);
}
root_dir = debugfs_create_dir(KBUILD_MODNAME, NULL);
status = spi_register_driver(&pi433_spi_driver);
if (status < 0) {
class_destroy(pi433_class);
unregister_chrdev(MAJOR(pi433_dev),
pi433_spi_driver.driver.name);
}
return status;
}
module_init(pi433_init);
static void __exit pi433_exit(void)
{
spi_unregister_driver(&pi433_spi_driver);
class_destroy(pi433_class);
unregister_chrdev(MAJOR(pi433_dev), pi433_spi_driver.driver.name);
debugfs_remove(root_dir);
}
module_exit(pi433_exit);
MODULE_AUTHOR("Marcus Wolf, <[email protected]>");
MODULE_DESCRIPTION("Driver for Pi433");
MODULE_LICENSE("GPL");
MODULE_ALIAS("spi:pi433");
| linux-master | drivers/staging/pi433/pi433_if.c |
// SPDX-License-Identifier: GPL-2.0
/*
* This file is based on code from OCTEON SDK by Cavium Networks.
*
* Copyright (c) 2003-2007 Cavium Networks
*/
#include <linux/platform_device.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/phy.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/of_mdio.h>
#include <linux/of_net.h>
#include <linux/if_ether.h>
#include <linux/if_vlan.h>
#include <net/dst.h>
#include "octeon-ethernet.h"
#include "ethernet-defines.h"
#include "ethernet-mem.h"
#include "ethernet-rx.h"
#include "ethernet-tx.h"
#include "ethernet-mdio.h"
#include "ethernet-util.h"
#define OCTEON_MAX_MTU 65392
static int num_packet_buffers = 1024;
module_param(num_packet_buffers, int, 0444);
MODULE_PARM_DESC(num_packet_buffers, "\n"
"\tNumber of packet buffers to allocate and store in the\n"
"\tFPA. By default, 1024 packet buffers are used.\n");
static int pow_receive_group = 15;
module_param(pow_receive_group, int, 0444);
MODULE_PARM_DESC(pow_receive_group, "\n"
"\tPOW group to receive packets from. All ethernet hardware\n"
"\twill be configured to send incoming packets to this POW\n"
"\tgroup. Also any other software can submit packets to this\n"
"\tgroup for the kernel to process.");
static int receive_group_order;
module_param(receive_group_order, int, 0444);
MODULE_PARM_DESC(receive_group_order, "\n"
"\tOrder (0..4) of receive groups to take into use. Ethernet hardware\n"
"\twill be configured to send incoming packets to multiple POW\n"
"\tgroups. pow_receive_group parameter is ignored when multiple\n"
"\tgroups are taken into use and groups are allocated starting\n"
"\tfrom 0. By default, a single group is used.\n");
int pow_send_group = -1;
module_param(pow_send_group, int, 0644);
MODULE_PARM_DESC(pow_send_group, "\n"
"\tPOW group to send packets to other software on. This\n"
"\tcontrols the creation of the virtual device pow0.\n"
"\talways_use_pow also depends on this value.");
int always_use_pow;
module_param(always_use_pow, int, 0444);
MODULE_PARM_DESC(always_use_pow, "\n"
"\tWhen set, always send to the pow group. This will cause\n"
"\tpackets sent to real ethernet devices to be sent to the\n"
"\tPOW group instead of the hardware. Unless some other\n"
"\tapplication changes the config, packets will still be\n"
"\treceived from the low level hardware. Use this option\n"
"\tto allow a CVMX app to intercept all packets from the\n"
"\tlinux kernel. You must specify pow_send_group along with\n"
"\tthis option.");
char pow_send_list[128] = "";
module_param_string(pow_send_list, pow_send_list, sizeof(pow_send_list), 0444);
MODULE_PARM_DESC(pow_send_list, "\n"
"\tComma separated list of ethernet devices that should use the\n"
"\tPOW for transmit instead of the actual ethernet hardware. This\n"
"\tis a per port version of always_use_pow. always_use_pow takes\n"
"\tprecedence over this list. For example, setting this to\n"
"\t\"eth2,spi3,spi7\" would cause these three devices to transmit\n"
"\tusing the pow_send_group.");
int rx_napi_weight = 32;
module_param(rx_napi_weight, int, 0444);
MODULE_PARM_DESC(rx_napi_weight, "The NAPI WEIGHT parameter.");
/* Mask indicating which receive groups are in use. */
int pow_receive_groups;
/*
* cvm_oct_poll_queue_stopping - flag to indicate polling should stop.
*
* Set to one right before cvm_oct_poll_queue is destroyed.
*/
atomic_t cvm_oct_poll_queue_stopping = ATOMIC_INIT(0);
/*
* Array of every ethernet device owned by this driver indexed by
* the ipd input port number.
*/
struct net_device *cvm_oct_device[TOTAL_NUMBER_OF_PORTS];
u64 cvm_oct_tx_poll_interval;
static void cvm_oct_rx_refill_worker(struct work_struct *work);
static DECLARE_DELAYED_WORK(cvm_oct_rx_refill_work, cvm_oct_rx_refill_worker);
static void cvm_oct_rx_refill_worker(struct work_struct *work)
{
/*
* FPA 0 may have been drained, try to refill it if we need
* more than num_packet_buffers / 2, otherwise normal receive
* processing will refill it. If it were drained, no packets
* could be received so cvm_oct_napi_poll would never be
* invoked to do the refill.
*/
cvm_oct_rx_refill_pool(num_packet_buffers / 2);
if (!atomic_read(&cvm_oct_poll_queue_stopping))
schedule_delayed_work(&cvm_oct_rx_refill_work, HZ);
}
static void cvm_oct_periodic_worker(struct work_struct *work)
{
struct octeon_ethernet *priv = container_of(work,
struct octeon_ethernet,
port_periodic_work.work);
if (priv->poll)
priv->poll(cvm_oct_device[priv->port]);
cvm_oct_device[priv->port]->netdev_ops->ndo_get_stats
(cvm_oct_device[priv->port]);
if (!atomic_read(&cvm_oct_poll_queue_stopping))
schedule_delayed_work(&priv->port_periodic_work, HZ);
}
static void cvm_oct_configure_common_hw(void)
{
/* Setup the FPA */
cvmx_fpa_enable();
cvm_oct_mem_fill_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
num_packet_buffers);
cvm_oct_mem_fill_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
num_packet_buffers);
if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
cvm_oct_mem_fill_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 1024);
#ifdef __LITTLE_ENDIAN
{
union cvmx_ipd_ctl_status ipd_ctl_status;
ipd_ctl_status.u64 = cvmx_read_csr(CVMX_IPD_CTL_STATUS);
ipd_ctl_status.s.pkt_lend = 1;
ipd_ctl_status.s.wqe_lend = 1;
cvmx_write_csr(CVMX_IPD_CTL_STATUS, ipd_ctl_status.u64);
}
#endif
cvmx_helper_setup_red(num_packet_buffers / 4, num_packet_buffers / 8);
}
/**
* cvm_oct_free_work- Free a work queue entry
*
* @work_queue_entry: Work queue entry to free
*
* Returns Zero on success, Negative on failure.
*/
int cvm_oct_free_work(void *work_queue_entry)
{
struct cvmx_wqe *work = work_queue_entry;
int segments = work->word2.s.bufs;
union cvmx_buf_ptr segment_ptr = work->packet_ptr;
while (segments--) {
union cvmx_buf_ptr next_ptr = *(union cvmx_buf_ptr *)
cvmx_phys_to_ptr(segment_ptr.s.addr - 8);
if (unlikely(!segment_ptr.s.i))
cvmx_fpa_free(cvm_oct_get_buffer_ptr(segment_ptr),
segment_ptr.s.pool,
CVMX_FPA_PACKET_POOL_SIZE / 128);
segment_ptr = next_ptr;
}
cvmx_fpa_free(work, CVMX_FPA_WQE_POOL, 1);
return 0;
}
EXPORT_SYMBOL(cvm_oct_free_work);
/**
* cvm_oct_common_get_stats - get the low level ethernet statistics
* @dev: Device to get the statistics from
*
* Returns Pointer to the statistics
*/
static struct net_device_stats *cvm_oct_common_get_stats(struct net_device *dev)
{
cvmx_pip_port_status_t rx_status;
cvmx_pko_port_status_t tx_status;
struct octeon_ethernet *priv = netdev_priv(dev);
if (priv->port < CVMX_PIP_NUM_INPUT_PORTS) {
if (octeon_is_simulation()) {
/* The simulator doesn't support statistics */
memset(&rx_status, 0, sizeof(rx_status));
memset(&tx_status, 0, sizeof(tx_status));
} else {
cvmx_pip_get_port_status(priv->port, 1, &rx_status);
cvmx_pko_get_port_status(priv->port, 1, &tx_status);
}
dev->stats.rx_packets += rx_status.inb_packets;
dev->stats.tx_packets += tx_status.packets;
dev->stats.rx_bytes += rx_status.inb_octets;
dev->stats.tx_bytes += tx_status.octets;
dev->stats.multicast += rx_status.multicast_packets;
dev->stats.rx_crc_errors += rx_status.inb_errors;
dev->stats.rx_frame_errors += rx_status.fcs_align_err_packets;
dev->stats.rx_dropped += rx_status.dropped_packets;
}
return &dev->stats;
}
/**
* cvm_oct_common_change_mtu - change the link MTU
* @dev: Device to change
* @new_mtu: The new MTU
*
* Returns Zero on success
*/
static int cvm_oct_common_change_mtu(struct net_device *dev, int new_mtu)
{
struct octeon_ethernet *priv = netdev_priv(dev);
int interface = INTERFACE(priv->port);
#if IS_ENABLED(CONFIG_VLAN_8021Q)
int vlan_bytes = VLAN_HLEN;
#else
int vlan_bytes = 0;
#endif
int mtu_overhead = ETH_HLEN + ETH_FCS_LEN + vlan_bytes;
dev->mtu = new_mtu;
if ((interface < 2) &&
(cvmx_helper_interface_get_mode(interface) !=
CVMX_HELPER_INTERFACE_MODE_SPI)) {
int index = INDEX(priv->port);
/* Add ethernet header and FCS, and VLAN if configured. */
int max_packet = new_mtu + mtu_overhead;
if (OCTEON_IS_MODEL(OCTEON_CN3XXX) ||
OCTEON_IS_MODEL(OCTEON_CN58XX)) {
/* Signal errors on packets larger than the MTU */
cvmx_write_csr(CVMX_GMXX_RXX_FRM_MAX(index, interface),
max_packet);
} else {
/*
* Set the hardware to truncate packets larger
* than the MTU and smaller the 64 bytes.
*/
union cvmx_pip_frm_len_chkx frm_len_chk;
frm_len_chk.u64 = 0;
frm_len_chk.s.minlen = VLAN_ETH_ZLEN;
frm_len_chk.s.maxlen = max_packet;
cvmx_write_csr(CVMX_PIP_FRM_LEN_CHKX(interface),
frm_len_chk.u64);
}
/*
* Set the hardware to truncate packets larger than
* the MTU. The jabber register must be set to a
* multiple of 8 bytes, so round up.
*/
cvmx_write_csr(CVMX_GMXX_RXX_JABBER(index, interface),
(max_packet + 7) & ~7u);
}
return 0;
}
/**
* cvm_oct_common_set_multicast_list - set the multicast list
* @dev: Device to work on
*/
static void cvm_oct_common_set_multicast_list(struct net_device *dev)
{
union cvmx_gmxx_prtx_cfg gmx_cfg;
struct octeon_ethernet *priv = netdev_priv(dev);
int interface = INTERFACE(priv->port);
if ((interface < 2) &&
(cvmx_helper_interface_get_mode(interface) !=
CVMX_HELPER_INTERFACE_MODE_SPI)) {
union cvmx_gmxx_rxx_adr_ctl control;
int index = INDEX(priv->port);
control.u64 = 0;
control.s.bcst = 1; /* Allow broadcast MAC addresses */
if (!netdev_mc_empty(dev) || (dev->flags & IFF_ALLMULTI) ||
(dev->flags & IFF_PROMISC))
/* Force accept multicast packets */
control.s.mcst = 2;
else
/* Force reject multicast packets */
control.s.mcst = 1;
if (dev->flags & IFF_PROMISC)
/*
* Reject matches if promisc. Since CAM is
* shut off, should accept everything.
*/
control.s.cam_mode = 0;
else
/* Filter packets based on the CAM */
control.s.cam_mode = 1;
gmx_cfg.u64 =
cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
gmx_cfg.u64 & ~1ull);
cvmx_write_csr(CVMX_GMXX_RXX_ADR_CTL(index, interface),
control.u64);
if (dev->flags & IFF_PROMISC)
cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
(index, interface), 0);
else
cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM_EN
(index, interface), 1);
cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
gmx_cfg.u64);
}
}
static int cvm_oct_set_mac_filter(struct net_device *dev)
{
struct octeon_ethernet *priv = netdev_priv(dev);
union cvmx_gmxx_prtx_cfg gmx_cfg;
int interface = INTERFACE(priv->port);
if ((interface < 2) &&
(cvmx_helper_interface_get_mode(interface) !=
CVMX_HELPER_INTERFACE_MODE_SPI)) {
int i;
const u8 *ptr = dev->dev_addr;
u64 mac = 0;
int index = INDEX(priv->port);
for (i = 0; i < 6; i++)
mac = (mac << 8) | (u64)ptr[i];
gmx_cfg.u64 =
cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
gmx_cfg.u64 & ~1ull);
cvmx_write_csr(CVMX_GMXX_SMACX(index, interface), mac);
cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM0(index, interface),
ptr[0]);
cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM1(index, interface),
ptr[1]);
cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM2(index, interface),
ptr[2]);
cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM3(index, interface),
ptr[3]);
cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM4(index, interface),
ptr[4]);
cvmx_write_csr(CVMX_GMXX_RXX_ADR_CAM5(index, interface),
ptr[5]);
cvm_oct_common_set_multicast_list(dev);
cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface),
gmx_cfg.u64);
}
return 0;
}
/**
* cvm_oct_common_set_mac_address - set the hardware MAC address for a device
* @dev: The device in question.
* @addr: Socket address.
*
* Returns Zero on success
*/
static int cvm_oct_common_set_mac_address(struct net_device *dev, void *addr)
{
int r = eth_mac_addr(dev, addr);
if (r)
return r;
return cvm_oct_set_mac_filter(dev);
}
/**
* cvm_oct_common_init - per network device initialization
* @dev: Device to initialize
*
* Returns Zero on success
*/
int cvm_oct_common_init(struct net_device *dev)
{
struct octeon_ethernet *priv = netdev_priv(dev);
int ret;
ret = of_get_ethdev_address(priv->of_node, dev);
if (ret)
eth_hw_addr_random(dev);
/*
* Force the interface to use the POW send if always_use_pow
* was specified or it is in the pow send list.
*/
if ((pow_send_group != -1) &&
(always_use_pow || strstr(pow_send_list, dev->name)))
priv->queue = -1;
if (priv->queue != -1)
dev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
/* We do our own locking, Linux doesn't need to */
dev->features |= NETIF_F_LLTX;
dev->ethtool_ops = &cvm_oct_ethtool_ops;
cvm_oct_set_mac_filter(dev);
dev_set_mtu(dev, dev->mtu);
/*
* Zero out stats for port so we won't mistakenly show
* counters from the bootloader.
*/
memset(dev->netdev_ops->ndo_get_stats(dev), 0,
sizeof(struct net_device_stats));
if (dev->netdev_ops->ndo_stop)
dev->netdev_ops->ndo_stop(dev);
return 0;
}
void cvm_oct_common_uninit(struct net_device *dev)
{
if (dev->phydev)
phy_disconnect(dev->phydev);
}
int cvm_oct_common_open(struct net_device *dev,
void (*link_poll)(struct net_device *))
{
union cvmx_gmxx_prtx_cfg gmx_cfg;
struct octeon_ethernet *priv = netdev_priv(dev);
int interface = INTERFACE(priv->port);
int index = INDEX(priv->port);
union cvmx_helper_link_info link_info;
int rv;
rv = cvm_oct_phy_setup_device(dev);
if (rv)
return rv;
gmx_cfg.u64 = cvmx_read_csr(CVMX_GMXX_PRTX_CFG(index, interface));
gmx_cfg.s.en = 1;
if (octeon_has_feature(OCTEON_FEATURE_PKND))
gmx_cfg.s.pknd = priv->port;
cvmx_write_csr(CVMX_GMXX_PRTX_CFG(index, interface), gmx_cfg.u64);
if (octeon_is_simulation())
return 0;
if (dev->phydev) {
int r = phy_read_status(dev->phydev);
if (r == 0 && dev->phydev->link == 0)
netif_carrier_off(dev);
cvm_oct_adjust_link(dev);
} else {
link_info = cvmx_helper_link_get(priv->port);
if (!link_info.s.link_up)
netif_carrier_off(dev);
priv->poll = link_poll;
link_poll(dev);
}
return 0;
}
void cvm_oct_link_poll(struct net_device *dev)
{
struct octeon_ethernet *priv = netdev_priv(dev);
union cvmx_helper_link_info link_info;
link_info = cvmx_helper_link_get(priv->port);
if (link_info.u64 == priv->link_info)
return;
if (cvmx_helper_link_set(priv->port, link_info))
link_info.u64 = priv->link_info;
else
priv->link_info = link_info.u64;
if (link_info.s.link_up) {
if (!netif_carrier_ok(dev))
netif_carrier_on(dev);
} else if (netif_carrier_ok(dev)) {
netif_carrier_off(dev);
}
cvm_oct_note_carrier(priv, link_info);
}
static int cvm_oct_xaui_open(struct net_device *dev)
{
return cvm_oct_common_open(dev, cvm_oct_link_poll);
}
static const struct net_device_ops cvm_oct_npi_netdev_ops = {
.ndo_init = cvm_oct_common_init,
.ndo_uninit = cvm_oct_common_uninit,
.ndo_start_xmit = cvm_oct_xmit,
.ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
.ndo_set_mac_address = cvm_oct_common_set_mac_address,
.ndo_eth_ioctl = cvm_oct_ioctl,
.ndo_change_mtu = cvm_oct_common_change_mtu,
.ndo_get_stats = cvm_oct_common_get_stats,
#ifdef CONFIG_NET_POLL_CONTROLLER
.ndo_poll_controller = cvm_oct_poll_controller,
#endif
};
static const struct net_device_ops cvm_oct_xaui_netdev_ops = {
.ndo_init = cvm_oct_common_init,
.ndo_uninit = cvm_oct_common_uninit,
.ndo_open = cvm_oct_xaui_open,
.ndo_stop = cvm_oct_common_stop,
.ndo_start_xmit = cvm_oct_xmit,
.ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
.ndo_set_mac_address = cvm_oct_common_set_mac_address,
.ndo_eth_ioctl = cvm_oct_ioctl,
.ndo_change_mtu = cvm_oct_common_change_mtu,
.ndo_get_stats = cvm_oct_common_get_stats,
#ifdef CONFIG_NET_POLL_CONTROLLER
.ndo_poll_controller = cvm_oct_poll_controller,
#endif
};
static const struct net_device_ops cvm_oct_sgmii_netdev_ops = {
.ndo_init = cvm_oct_sgmii_init,
.ndo_uninit = cvm_oct_common_uninit,
.ndo_open = cvm_oct_sgmii_open,
.ndo_stop = cvm_oct_common_stop,
.ndo_start_xmit = cvm_oct_xmit,
.ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
.ndo_set_mac_address = cvm_oct_common_set_mac_address,
.ndo_eth_ioctl = cvm_oct_ioctl,
.ndo_change_mtu = cvm_oct_common_change_mtu,
.ndo_get_stats = cvm_oct_common_get_stats,
#ifdef CONFIG_NET_POLL_CONTROLLER
.ndo_poll_controller = cvm_oct_poll_controller,
#endif
};
static const struct net_device_ops cvm_oct_spi_netdev_ops = {
.ndo_init = cvm_oct_spi_init,
.ndo_uninit = cvm_oct_spi_uninit,
.ndo_start_xmit = cvm_oct_xmit,
.ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
.ndo_set_mac_address = cvm_oct_common_set_mac_address,
.ndo_eth_ioctl = cvm_oct_ioctl,
.ndo_change_mtu = cvm_oct_common_change_mtu,
.ndo_get_stats = cvm_oct_common_get_stats,
#ifdef CONFIG_NET_POLL_CONTROLLER
.ndo_poll_controller = cvm_oct_poll_controller,
#endif
};
static const struct net_device_ops cvm_oct_rgmii_netdev_ops = {
.ndo_init = cvm_oct_common_init,
.ndo_uninit = cvm_oct_common_uninit,
.ndo_open = cvm_oct_rgmii_open,
.ndo_stop = cvm_oct_common_stop,
.ndo_start_xmit = cvm_oct_xmit,
.ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
.ndo_set_mac_address = cvm_oct_common_set_mac_address,
.ndo_eth_ioctl = cvm_oct_ioctl,
.ndo_change_mtu = cvm_oct_common_change_mtu,
.ndo_get_stats = cvm_oct_common_get_stats,
#ifdef CONFIG_NET_POLL_CONTROLLER
.ndo_poll_controller = cvm_oct_poll_controller,
#endif
};
static const struct net_device_ops cvm_oct_pow_netdev_ops = {
.ndo_init = cvm_oct_common_init,
.ndo_start_xmit = cvm_oct_xmit_pow,
.ndo_set_rx_mode = cvm_oct_common_set_multicast_list,
.ndo_set_mac_address = cvm_oct_common_set_mac_address,
.ndo_eth_ioctl = cvm_oct_ioctl,
.ndo_change_mtu = cvm_oct_common_change_mtu,
.ndo_get_stats = cvm_oct_common_get_stats,
#ifdef CONFIG_NET_POLL_CONTROLLER
.ndo_poll_controller = cvm_oct_poll_controller,
#endif
};
static struct device_node *cvm_oct_of_get_child
(const struct device_node *parent, int reg_val)
{
struct device_node *node;
const __be32 *addr;
int size;
for_each_child_of_node(parent, node) {
addr = of_get_property(node, "reg", &size);
if (addr && (be32_to_cpu(*addr) == reg_val))
break;
}
return node;
}
static struct device_node *cvm_oct_node_for_port(struct device_node *pip,
int interface, int port)
{
struct device_node *ni, *np;
ni = cvm_oct_of_get_child(pip, interface);
if (!ni)
return NULL;
np = cvm_oct_of_get_child(ni, port);
of_node_put(ni);
return np;
}
static void cvm_set_rgmii_delay(struct octeon_ethernet *priv, int iface,
int port)
{
struct device_node *np = priv->of_node;
u32 delay_value;
bool rx_delay;
bool tx_delay;
/* By default, both RX/TX delay is enabled in
* __cvmx_helper_rgmii_enable().
*/
rx_delay = true;
tx_delay = true;
if (!of_property_read_u32(np, "rx-delay", &delay_value)) {
cvmx_write_csr(CVMX_ASXX_RX_CLK_SETX(port, iface), delay_value);
rx_delay = delay_value > 0;
}
if (!of_property_read_u32(np, "tx-delay", &delay_value)) {
cvmx_write_csr(CVMX_ASXX_TX_CLK_SETX(port, iface), delay_value);
tx_delay = delay_value > 0;
}
if (!rx_delay && !tx_delay)
priv->phy_mode = PHY_INTERFACE_MODE_RGMII_ID;
else if (!rx_delay)
priv->phy_mode = PHY_INTERFACE_MODE_RGMII_RXID;
else if (!tx_delay)
priv->phy_mode = PHY_INTERFACE_MODE_RGMII_TXID;
else
priv->phy_mode = PHY_INTERFACE_MODE_RGMII;
}
static int cvm_oct_probe(struct platform_device *pdev)
{
int num_interfaces;
int interface;
int fau = FAU_NUM_PACKET_BUFFERS_TO_FREE;
int qos;
struct device_node *pip;
int mtu_overhead = ETH_HLEN + ETH_FCS_LEN;
#if IS_ENABLED(CONFIG_VLAN_8021Q)
mtu_overhead += VLAN_HLEN;
#endif
pip = pdev->dev.of_node;
if (!pip) {
pr_err("Error: No 'pip' in /aliases\n");
return -EINVAL;
}
cvm_oct_configure_common_hw();
cvmx_helper_initialize_packet_io_global();
if (receive_group_order) {
if (receive_group_order > 4)
receive_group_order = 4;
pow_receive_groups = (1 << (1 << receive_group_order)) - 1;
} else {
pow_receive_groups = BIT(pow_receive_group);
}
/* Change the input group for all ports before input is enabled */
num_interfaces = cvmx_helper_get_number_of_interfaces();
for (interface = 0; interface < num_interfaces; interface++) {
int num_ports = cvmx_helper_ports_on_interface(interface);
int port;
for (port = cvmx_helper_get_ipd_port(interface, 0);
port < cvmx_helper_get_ipd_port(interface, num_ports);
port++) {
union cvmx_pip_prt_tagx pip_prt_tagx;
pip_prt_tagx.u64 =
cvmx_read_csr(CVMX_PIP_PRT_TAGX(port));
if (receive_group_order) {
int tag_mask;
/* We support only 16 groups at the moment, so
* always disable the two additional "hidden"
* tag_mask bits on CN68XX.
*/
if (OCTEON_IS_MODEL(OCTEON_CN68XX))
pip_prt_tagx.u64 |= 0x3ull << 44;
tag_mask = ~((1 << receive_group_order) - 1);
pip_prt_tagx.s.grptagbase = 0;
pip_prt_tagx.s.grptagmask = tag_mask;
pip_prt_tagx.s.grptag = 1;
pip_prt_tagx.s.tag_mode = 0;
pip_prt_tagx.s.inc_prt_flag = 1;
pip_prt_tagx.s.ip6_dprt_flag = 1;
pip_prt_tagx.s.ip4_dprt_flag = 1;
pip_prt_tagx.s.ip6_sprt_flag = 1;
pip_prt_tagx.s.ip4_sprt_flag = 1;
pip_prt_tagx.s.ip6_dst_flag = 1;
pip_prt_tagx.s.ip4_dst_flag = 1;
pip_prt_tagx.s.ip6_src_flag = 1;
pip_prt_tagx.s.ip4_src_flag = 1;
pip_prt_tagx.s.grp = 0;
} else {
pip_prt_tagx.s.grptag = 0;
pip_prt_tagx.s.grp = pow_receive_group;
}
cvmx_write_csr(CVMX_PIP_PRT_TAGX(port),
pip_prt_tagx.u64);
}
}
cvmx_helper_ipd_and_packet_input_enable();
memset(cvm_oct_device, 0, sizeof(cvm_oct_device));
/*
* Initialize the FAU used for counting packet buffers that
* need to be freed.
*/
cvmx_fau_atomic_write32(FAU_NUM_PACKET_BUFFERS_TO_FREE, 0);
/* Initialize the FAU used for counting tx SKBs that need to be freed */
cvmx_fau_atomic_write32(FAU_TOTAL_TX_TO_CLEAN, 0);
if ((pow_send_group != -1)) {
struct net_device *dev;
dev = alloc_etherdev(sizeof(struct octeon_ethernet));
if (dev) {
/* Initialize the device private structure. */
struct octeon_ethernet *priv = netdev_priv(dev);
SET_NETDEV_DEV(dev, &pdev->dev);
dev->netdev_ops = &cvm_oct_pow_netdev_ops;
priv->imode = CVMX_HELPER_INTERFACE_MODE_DISABLED;
priv->port = CVMX_PIP_NUM_INPUT_PORTS;
priv->queue = -1;
strscpy(dev->name, "pow%d", sizeof(dev->name));
for (qos = 0; qos < 16; qos++)
skb_queue_head_init(&priv->tx_free_list[qos]);
dev->min_mtu = VLAN_ETH_ZLEN - mtu_overhead;
dev->max_mtu = OCTEON_MAX_MTU - mtu_overhead;
if (register_netdev(dev) < 0) {
pr_err("Failed to register ethernet device for POW\n");
free_netdev(dev);
} else {
cvm_oct_device[CVMX_PIP_NUM_INPUT_PORTS] = dev;
pr_info("%s: POW send group %d, receive group %d\n",
dev->name, pow_send_group,
pow_receive_group);
}
} else {
pr_err("Failed to allocate ethernet device for POW\n");
}
}
num_interfaces = cvmx_helper_get_number_of_interfaces();
for (interface = 0; interface < num_interfaces; interface++) {
cvmx_helper_interface_mode_t imode =
cvmx_helper_interface_get_mode(interface);
int num_ports = cvmx_helper_ports_on_interface(interface);
int port;
int port_index;
for (port_index = 0,
port = cvmx_helper_get_ipd_port(interface, 0);
port < cvmx_helper_get_ipd_port(interface, num_ports);
port_index++, port++) {
struct octeon_ethernet *priv;
struct net_device *dev =
alloc_etherdev(sizeof(struct octeon_ethernet));
if (!dev) {
pr_err("Failed to allocate ethernet device for port %d\n",
port);
continue;
}
/* Initialize the device private structure. */
SET_NETDEV_DEV(dev, &pdev->dev);
priv = netdev_priv(dev);
priv->netdev = dev;
priv->of_node = cvm_oct_node_for_port(pip, interface,
port_index);
INIT_DELAYED_WORK(&priv->port_periodic_work,
cvm_oct_periodic_worker);
priv->imode = imode;
priv->port = port;
priv->queue = cvmx_pko_get_base_queue(priv->port);
priv->fau = fau - cvmx_pko_get_num_queues(port) * 4;
priv->phy_mode = PHY_INTERFACE_MODE_NA;
for (qos = 0; qos < 16; qos++)
skb_queue_head_init(&priv->tx_free_list[qos]);
for (qos = 0; qos < cvmx_pko_get_num_queues(port);
qos++)
cvmx_fau_atomic_write32(priv->fau + qos * 4, 0);
dev->min_mtu = VLAN_ETH_ZLEN - mtu_overhead;
dev->max_mtu = OCTEON_MAX_MTU - mtu_overhead;
switch (priv->imode) {
/* These types don't support ports to IPD/PKO */
case CVMX_HELPER_INTERFACE_MODE_DISABLED:
case CVMX_HELPER_INTERFACE_MODE_PCIE:
case CVMX_HELPER_INTERFACE_MODE_PICMG:
break;
case CVMX_HELPER_INTERFACE_MODE_NPI:
dev->netdev_ops = &cvm_oct_npi_netdev_ops;
strscpy(dev->name, "npi%d", sizeof(dev->name));
break;
case CVMX_HELPER_INTERFACE_MODE_XAUI:
dev->netdev_ops = &cvm_oct_xaui_netdev_ops;
strscpy(dev->name, "xaui%d", sizeof(dev->name));
break;
case CVMX_HELPER_INTERFACE_MODE_LOOP:
dev->netdev_ops = &cvm_oct_npi_netdev_ops;
strscpy(dev->name, "loop%d", sizeof(dev->name));
break;
case CVMX_HELPER_INTERFACE_MODE_SGMII:
priv->phy_mode = PHY_INTERFACE_MODE_SGMII;
dev->netdev_ops = &cvm_oct_sgmii_netdev_ops;
strscpy(dev->name, "eth%d", sizeof(dev->name));
break;
case CVMX_HELPER_INTERFACE_MODE_SPI:
dev->netdev_ops = &cvm_oct_spi_netdev_ops;
strscpy(dev->name, "spi%d", sizeof(dev->name));
break;
case CVMX_HELPER_INTERFACE_MODE_GMII:
priv->phy_mode = PHY_INTERFACE_MODE_GMII;
dev->netdev_ops = &cvm_oct_rgmii_netdev_ops;
strscpy(dev->name, "eth%d", sizeof(dev->name));
break;
case CVMX_HELPER_INTERFACE_MODE_RGMII:
dev->netdev_ops = &cvm_oct_rgmii_netdev_ops;
strscpy(dev->name, "eth%d", sizeof(dev->name));
cvm_set_rgmii_delay(priv, interface,
port_index);
break;
}
if (priv->of_node && of_phy_is_fixed_link(priv->of_node)) {
if (of_phy_register_fixed_link(priv->of_node)) {
netdev_err(dev, "Failed to register fixed link for interface %d, port %d\n",
interface, priv->port);
dev->netdev_ops = NULL;
}
}
if (!dev->netdev_ops) {
free_netdev(dev);
} else if (register_netdev(dev) < 0) {
pr_err("Failed to register ethernet device for interface %d, port %d\n",
interface, priv->port);
free_netdev(dev);
} else {
cvm_oct_device[priv->port] = dev;
fau -=
cvmx_pko_get_num_queues(priv->port) *
sizeof(u32);
schedule_delayed_work(&priv->port_periodic_work,
HZ);
}
}
}
cvm_oct_tx_initialize();
cvm_oct_rx_initialize();
/*
* 150 uS: about 10 1500-byte packets at 1GE.
*/
cvm_oct_tx_poll_interval = 150 * (octeon_get_clock_rate() / 1000000);
schedule_delayed_work(&cvm_oct_rx_refill_work, HZ);
return 0;
}
static void cvm_oct_remove(struct platform_device *pdev)
{
int port;
cvmx_ipd_disable();
atomic_inc_return(&cvm_oct_poll_queue_stopping);
cancel_delayed_work_sync(&cvm_oct_rx_refill_work);
cvm_oct_rx_shutdown();
cvm_oct_tx_shutdown();
cvmx_pko_disable();
/* Free the ethernet devices */
for (port = 0; port < TOTAL_NUMBER_OF_PORTS; port++) {
if (cvm_oct_device[port]) {
struct net_device *dev = cvm_oct_device[port];
struct octeon_ethernet *priv = netdev_priv(dev);
cancel_delayed_work_sync(&priv->port_periodic_work);
cvm_oct_tx_shutdown_dev(dev);
unregister_netdev(dev);
free_netdev(dev);
cvm_oct_device[port] = NULL;
}
}
cvmx_pko_shutdown();
cvmx_ipd_free_ptr();
/* Free the HW pools */
cvm_oct_mem_empty_fpa(CVMX_FPA_PACKET_POOL, CVMX_FPA_PACKET_POOL_SIZE,
num_packet_buffers);
cvm_oct_mem_empty_fpa(CVMX_FPA_WQE_POOL, CVMX_FPA_WQE_POOL_SIZE,
num_packet_buffers);
if (CVMX_FPA_OUTPUT_BUFFER_POOL != CVMX_FPA_PACKET_POOL)
cvm_oct_mem_empty_fpa(CVMX_FPA_OUTPUT_BUFFER_POOL,
CVMX_FPA_OUTPUT_BUFFER_POOL_SIZE, 128);
}
static const struct of_device_id cvm_oct_match[] = {
{
.compatible = "cavium,octeon-3860-pip",
},
{},
};
MODULE_DEVICE_TABLE(of, cvm_oct_match);
static struct platform_driver cvm_oct_driver = {
.probe = cvm_oct_probe,
.remove_new = cvm_oct_remove,
.driver = {
.name = KBUILD_MODNAME,
.of_match_table = cvm_oct_match,
},
};
module_platform_driver(cvm_oct_driver);
MODULE_SOFTDEP("pre: mdio-cavium");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Cavium Networks <[email protected]>");
MODULE_DESCRIPTION("Cavium Networks Octeon ethernet driver.");
| linux-master | drivers/staging/octeon/ethernet.c |
// SPDX-License-Identifier: GPL-2.0
/*
* This file is based on code from OCTEON SDK by Cavium Networks.
*
* Copyright (c) 2003-2010 Cavium Networks
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/cache.h>
#include <linux/cpumask.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ip.h>
#include <linux/string.h>
#include <linux/prefetch.h>
#include <linux/ratelimit.h>
#include <linux/smp.h>
#include <linux/interrupt.h>
#include <net/dst.h>
#ifdef CONFIG_XFRM
#include <linux/xfrm.h>
#include <net/xfrm.h>
#endif /* CONFIG_XFRM */
#include "octeon-ethernet.h"
#include "ethernet-defines.h"
#include "ethernet-mem.h"
#include "ethernet-rx.h"
#include "ethernet-util.h"
static atomic_t oct_rx_ready = ATOMIC_INIT(0);
static struct oct_rx_group {
int irq;
int group;
struct napi_struct napi;
} oct_rx_group[16];
/**
* cvm_oct_do_interrupt - interrupt handler.
* @irq: Interrupt number.
* @napi_id: Cookie to identify the NAPI instance.
*
* The interrupt occurs whenever the POW has packets in our group.
*
*/
static irqreturn_t cvm_oct_do_interrupt(int irq, void *napi_id)
{
/* Disable the IRQ and start napi_poll. */
disable_irq_nosync(irq);
napi_schedule(napi_id);
return IRQ_HANDLED;
}
/**
* cvm_oct_check_rcv_error - process receive errors
* @work: Work queue entry pointing to the packet.
*
* Returns Non-zero if the packet can be dropped, zero otherwise.
*/
static inline int cvm_oct_check_rcv_error(struct cvmx_wqe *work)
{
int port;
if (octeon_has_feature(OCTEON_FEATURE_PKND))
port = work->word0.pip.cn68xx.pknd;
else
port = work->word1.cn38xx.ipprt;
if ((work->word2.snoip.err_code == 10) && (work->word1.len <= 64))
/*
* Ignore length errors on min size packets. Some
* equipment incorrectly pads packets to 64+4FCS
* instead of 60+4FCS. Note these packets still get
* counted as frame errors.
*/
return 0;
if (work->word2.snoip.err_code == 5 ||
work->word2.snoip.err_code == 7) {
/*
* We received a packet with either an alignment error
* or a FCS error. This may be signalling that we are
* running 10Mbps with GMXX_RXX_FRM_CTL[PRE_CHK]
* off. If this is the case we need to parse the
* packet to determine if we can remove a non spec
* preamble and generate a correct packet.
*/
int interface = cvmx_helper_get_interface_num(port);
int index = cvmx_helper_get_interface_index_num(port);
union cvmx_gmxx_rxx_frm_ctl gmxx_rxx_frm_ctl;
gmxx_rxx_frm_ctl.u64 =
cvmx_read_csr(CVMX_GMXX_RXX_FRM_CTL(index, interface));
if (gmxx_rxx_frm_ctl.s.pre_chk == 0) {
u8 *ptr =
cvmx_phys_to_ptr(work->packet_ptr.s.addr);
int i = 0;
while (i < work->word1.len - 1) {
if (*ptr != 0x55)
break;
ptr++;
i++;
}
if (*ptr == 0xd5) {
/* Port received 0xd5 preamble */
work->packet_ptr.s.addr += i + 1;
work->word1.len -= i + 5;
return 0;
}
if ((*ptr & 0xf) == 0xd) {
/* Port received 0xd preamble */
work->packet_ptr.s.addr += i;
work->word1.len -= i + 4;
for (i = 0; i < work->word1.len; i++) {
*ptr =
((*ptr & 0xf0) >> 4) |
((*(ptr + 1) & 0xf) << 4);
ptr++;
}
return 0;
}
printk_ratelimited("Port %d unknown preamble, packet dropped\n",
port);
cvm_oct_free_work(work);
return 1;
}
}
printk_ratelimited("Port %d receive error code %d, packet dropped\n",
port, work->word2.snoip.err_code);
cvm_oct_free_work(work);
return 1;
}
static void copy_segments_to_skb(struct cvmx_wqe *work, struct sk_buff *skb)
{
int segments = work->word2.s.bufs;
union cvmx_buf_ptr segment_ptr = work->packet_ptr;
int len = work->word1.len;
int segment_size;
while (segments--) {
union cvmx_buf_ptr next_ptr;
next_ptr = *(union cvmx_buf_ptr *)
cvmx_phys_to_ptr(segment_ptr.s.addr - 8);
/*
* Octeon Errata PKI-100: The segment size is wrong.
*
* Until it is fixed, calculate the segment size based on
* the packet pool buffer size.
* When it is fixed, the following line should be replaced
* with this one:
* int segment_size = segment_ptr.s.size;
*/
segment_size =
CVMX_FPA_PACKET_POOL_SIZE -
(segment_ptr.s.addr -
(((segment_ptr.s.addr >> 7) -
segment_ptr.s.back) << 7));
/* Don't copy more than what is left in the packet */
if (segment_size > len)
segment_size = len;
/* Copy the data into the packet */
skb_put_data(skb, cvmx_phys_to_ptr(segment_ptr.s.addr),
segment_size);
len -= segment_size;
segment_ptr = next_ptr;
}
}
static int cvm_oct_poll(struct oct_rx_group *rx_group, int budget)
{
const int coreid = cvmx_get_core_num();
u64 old_group_mask;
u64 old_scratch;
int rx_count = 0;
int did_work_request = 0;
int packet_not_copied;
/* Prefetch cvm_oct_device since we know we need it soon */
prefetch(cvm_oct_device);
if (USE_ASYNC_IOBDMA) {
/* Save scratch in case userspace is using it */
CVMX_SYNCIOBDMA;
old_scratch = cvmx_scratch_read64(CVMX_SCR_SCRATCH);
}
/* Only allow work for our group (and preserve priorities) */
if (OCTEON_IS_MODEL(OCTEON_CN68XX)) {
old_group_mask = cvmx_read_csr(CVMX_SSO_PPX_GRP_MSK(coreid));
cvmx_write_csr(CVMX_SSO_PPX_GRP_MSK(coreid),
BIT(rx_group->group));
cvmx_read_csr(CVMX_SSO_PPX_GRP_MSK(coreid)); /* Flush */
} else {
old_group_mask = cvmx_read_csr(CVMX_POW_PP_GRP_MSKX(coreid));
cvmx_write_csr(CVMX_POW_PP_GRP_MSKX(coreid),
(old_group_mask & ~0xFFFFull) |
BIT(rx_group->group));
}
if (USE_ASYNC_IOBDMA) {
cvmx_pow_work_request_async(CVMX_SCR_SCRATCH, CVMX_POW_NO_WAIT);
did_work_request = 1;
}
while (rx_count < budget) {
struct sk_buff *skb = NULL;
struct sk_buff **pskb = NULL;
int skb_in_hw;
struct cvmx_wqe *work;
int port;
if (USE_ASYNC_IOBDMA && did_work_request)
work = cvmx_pow_work_response_async(CVMX_SCR_SCRATCH);
else
work = cvmx_pow_work_request_sync(CVMX_POW_NO_WAIT);
prefetch(work);
did_work_request = 0;
if (!work) {
if (OCTEON_IS_MODEL(OCTEON_CN68XX)) {
cvmx_write_csr(CVMX_SSO_WQ_IQ_DIS,
BIT(rx_group->group));
cvmx_write_csr(CVMX_SSO_WQ_INT,
BIT(rx_group->group));
} else {
union cvmx_pow_wq_int wq_int;
wq_int.u64 = 0;
wq_int.s.iq_dis = BIT(rx_group->group);
wq_int.s.wq_int = BIT(rx_group->group);
cvmx_write_csr(CVMX_POW_WQ_INT, wq_int.u64);
}
break;
}
pskb = (struct sk_buff **)
(cvm_oct_get_buffer_ptr(work->packet_ptr) -
sizeof(void *));
prefetch(pskb);
if (USE_ASYNC_IOBDMA && rx_count < (budget - 1)) {
cvmx_pow_work_request_async_nocheck(CVMX_SCR_SCRATCH,
CVMX_POW_NO_WAIT);
did_work_request = 1;
}
rx_count++;
skb_in_hw = work->word2.s.bufs == 1;
if (likely(skb_in_hw)) {
skb = *pskb;
prefetch(&skb->head);
prefetch(&skb->len);
}
if (octeon_has_feature(OCTEON_FEATURE_PKND))
port = work->word0.pip.cn68xx.pknd;
else
port = work->word1.cn38xx.ipprt;
prefetch(cvm_oct_device[port]);
/* Immediately throw away all packets with receive errors */
if (unlikely(work->word2.snoip.rcv_error)) {
if (cvm_oct_check_rcv_error(work))
continue;
}
/*
* We can only use the zero copy path if skbuffs are
* in the FPA pool and the packet fits in a single
* buffer.
*/
if (likely(skb_in_hw)) {
skb->data = skb->head + work->packet_ptr.s.addr -
cvmx_ptr_to_phys(skb->head);
prefetch(skb->data);
skb->len = work->word1.len;
skb_set_tail_pointer(skb, skb->len);
packet_not_copied = 1;
} else {
/*
* We have to copy the packet. First allocate
* an skbuff for it.
*/
skb = dev_alloc_skb(work->word1.len);
if (!skb) {
cvm_oct_free_work(work);
continue;
}
/*
* Check if we've received a packet that was
* entirely stored in the work entry.
*/
if (unlikely(work->word2.s.bufs == 0)) {
u8 *ptr = work->packet_data;
if (likely(!work->word2.s.not_IP)) {
/*
* The beginning of the packet
* moves for IP packets.
*/
if (work->word2.s.is_v6)
ptr += 2;
else
ptr += 6;
}
skb_put_data(skb, ptr, work->word1.len);
/* No packet buffers to free */
} else {
copy_segments_to_skb(work, skb);
}
packet_not_copied = 0;
}
if (likely((port < TOTAL_NUMBER_OF_PORTS) &&
cvm_oct_device[port])) {
struct net_device *dev = cvm_oct_device[port];
/*
* Only accept packets for devices that are
* currently up.
*/
if (likely(dev->flags & IFF_UP)) {
skb->protocol = eth_type_trans(skb, dev);
skb->dev = dev;
if (unlikely(work->word2.s.not_IP ||
work->word2.s.IP_exc ||
work->word2.s.L4_error ||
!work->word2.s.tcp_or_udp))
skb->ip_summed = CHECKSUM_NONE;
else
skb->ip_summed = CHECKSUM_UNNECESSARY;
/* Increment RX stats for virtual ports */
if (port >= CVMX_PIP_NUM_INPUT_PORTS) {
dev->stats.rx_packets++;
dev->stats.rx_bytes += skb->len;
}
netif_receive_skb(skb);
} else {
/*
* Drop any packet received for a device that
* isn't up.
*/
dev->stats.rx_dropped++;
dev_kfree_skb_irq(skb);
}
} else {
/*
* Drop any packet received for a device that
* doesn't exist.
*/
printk_ratelimited("Port %d not controlled by Linux, packet dropped\n",
port);
dev_kfree_skb_irq(skb);
}
/*
* Check to see if the skbuff and work share the same
* packet buffer.
*/
if (likely(packet_not_copied)) {
/*
* This buffer needs to be replaced, increment
* the number of buffers we need to free by
* one.
*/
cvmx_fau_atomic_add32(FAU_NUM_PACKET_BUFFERS_TO_FREE,
1);
cvmx_fpa_free(work, CVMX_FPA_WQE_POOL, 1);
} else {
cvm_oct_free_work(work);
}
}
/* Restore the original POW group mask */
if (OCTEON_IS_MODEL(OCTEON_CN68XX)) {
cvmx_write_csr(CVMX_SSO_PPX_GRP_MSK(coreid), old_group_mask);
cvmx_read_csr(CVMX_SSO_PPX_GRP_MSK(coreid)); /* Flush */
} else {
cvmx_write_csr(CVMX_POW_PP_GRP_MSKX(coreid), old_group_mask);
}
if (USE_ASYNC_IOBDMA) {
/* Restore the scratch area */
cvmx_scratch_write64(CVMX_SCR_SCRATCH, old_scratch);
}
cvm_oct_rx_refill_pool(0);
return rx_count;
}
/**
* cvm_oct_napi_poll - the NAPI poll function.
* @napi: The NAPI instance.
* @budget: Maximum number of packets to receive.
*
* Returns the number of packets processed.
*/
static int cvm_oct_napi_poll(struct napi_struct *napi, int budget)
{
struct oct_rx_group *rx_group = container_of(napi, struct oct_rx_group,
napi);
int rx_count;
rx_count = cvm_oct_poll(rx_group, budget);
if (rx_count < budget) {
/* No more work */
napi_complete_done(napi, rx_count);
enable_irq(rx_group->irq);
}
return rx_count;
}
#ifdef CONFIG_NET_POLL_CONTROLLER
/**
* cvm_oct_poll_controller - poll for receive packets
* device.
*
* @dev: Device to poll. Unused
*/
void cvm_oct_poll_controller(struct net_device *dev)
{
int i;
if (!atomic_read(&oct_rx_ready))
return;
for (i = 0; i < ARRAY_SIZE(oct_rx_group); i++) {
if (!(pow_receive_groups & BIT(i)))
continue;
cvm_oct_poll(&oct_rx_group[i], 16);
}
}
#endif
void cvm_oct_rx_initialize(void)
{
int i;
struct net_device *dev_for_napi = NULL;
for (i = 0; i < TOTAL_NUMBER_OF_PORTS; i++) {
if (cvm_oct_device[i]) {
dev_for_napi = cvm_oct_device[i];
break;
}
}
if (!dev_for_napi)
panic("No net_devices were allocated.");
for (i = 0; i < ARRAY_SIZE(oct_rx_group); i++) {
int ret;
if (!(pow_receive_groups & BIT(i)))
continue;
netif_napi_add_weight(dev_for_napi, &oct_rx_group[i].napi,
cvm_oct_napi_poll, rx_napi_weight);
napi_enable(&oct_rx_group[i].napi);
oct_rx_group[i].irq = OCTEON_IRQ_WORKQ0 + i;
oct_rx_group[i].group = i;
/* Register an IRQ handler to receive POW interrupts */
ret = request_irq(oct_rx_group[i].irq, cvm_oct_do_interrupt, 0,
"Ethernet", &oct_rx_group[i].napi);
if (ret)
panic("Could not acquire Ethernet IRQ %d\n",
oct_rx_group[i].irq);
disable_irq_nosync(oct_rx_group[i].irq);
/* Enable POW interrupt when our port has at least one packet */
if (OCTEON_IS_MODEL(OCTEON_CN68XX)) {
union cvmx_sso_wq_int_thrx int_thr;
union cvmx_pow_wq_int_pc int_pc;
int_thr.u64 = 0;
int_thr.s.tc_en = 1;
int_thr.s.tc_thr = 1;
cvmx_write_csr(CVMX_SSO_WQ_INT_THRX(i), int_thr.u64);
int_pc.u64 = 0;
int_pc.s.pc_thr = 5;
cvmx_write_csr(CVMX_SSO_WQ_INT_PC, int_pc.u64);
} else {
union cvmx_pow_wq_int_thrx int_thr;
union cvmx_pow_wq_int_pc int_pc;
int_thr.u64 = 0;
int_thr.s.tc_en = 1;
int_thr.s.tc_thr = 1;
cvmx_write_csr(CVMX_POW_WQ_INT_THRX(i), int_thr.u64);
int_pc.u64 = 0;
int_pc.s.pc_thr = 5;
cvmx_write_csr(CVMX_POW_WQ_INT_PC, int_pc.u64);
}
/* Schedule NAPI now. This will indirectly enable the
* interrupt.
*/
napi_schedule(&oct_rx_group[i].napi);
}
atomic_inc(&oct_rx_ready);
}
void cvm_oct_rx_shutdown(void)
{
int i;
for (i = 0; i < ARRAY_SIZE(oct_rx_group); i++) {
if (!(pow_receive_groups & BIT(i)))
continue;
/* Disable POW interrupt */
if (OCTEON_IS_MODEL(OCTEON_CN68XX))
cvmx_write_csr(CVMX_SSO_WQ_INT_THRX(i), 0);
else
cvmx_write_csr(CVMX_POW_WQ_INT_THRX(i), 0);
/* Free the interrupt handler */
free_irq(oct_rx_group[i].irq, cvm_oct_device);
netif_napi_del(&oct_rx_group[i].napi);
}
}
| linux-master | drivers/staging/octeon/ethernet-rx.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.