int rtw_regd_init(_adapter * padapter,
void (*reg_notifier) (struct wiphy * wiphy,
struct regulatory_request * request))
{
//struct registry_priv *registrypriv = &padapter->registrypriv;
struct wiphy *wiphy = padapter->rtw_wdev->wiphy;
#if 0
if (rtw_regd == NULL) {
rtw_regd = (struct rtw_regulatory *)
rtw_malloc(sizeof(struct rtw_regulatory));
rtw_regd->alpha2[0] = '9';
rtw_regd->alpha2[1] = '9';
rtw_regd->country_code = COUNTRY_CODE_USER;
}
DBG_8192C("%s: Country alpha2 being used: %c%c\n",
__func__, rtw_regd->alpha2[0], rtw_regd->alpha2[1]);
#endif
_rtw_regd_init_wiphy(NULL, wiphy, reg_notifier);
return 0;
}
static void __nat25_db_network_insert(_adapter *priv,
unsigned char *macAddr, unsigned char *networkAddr)
{
struct nat25_network_db_entry *db;
int hash;
_irqL irqL;
_enter_critical_bh(&priv->br_ext_lock, &irqL);
hash = __nat25_network_hash(networkAddr);
for (db = priv->nethash[hash]; db != NULL; db = db->next_hash) {
if(!memcmp(db->networkAddr, networkAddr, MAX_NETWORK_ADDR_LEN))
{
copy_mac_addr(db->macAddr, macAddr);
db->ageing_timer = jiffies;
_exit_critical_bh(&priv->br_ext_lock, &irqL);
return;
}
}
db = (struct nat25_network_db_entry *) rtw_malloc(sizeof(*db));
if(db == NULL) {
_exit_critical_bh(&priv->br_ext_lock, &irqL);
return;
}
memcpy(db->networkAddr, networkAddr, MAX_NETWORK_ADDR_LEN);
copy_mac_addr(db->macAddr, macAddr);
atomic_set(&db->use_count, 1);
db->ageing_timer = jiffies;
__network_hash_link(priv, db, hash);
_exit_critical_bh(&priv->br_ext_lock, &irqL);
}
void rtw_report_sec_ie(struct adapter *adapter, u8 authmode, u8 *sec_ie)
{
uint len;
u8 *buff, *p, i;
union iwreq_data wrqu;
RT_TRACE(_module_mlme_osdep_c_, _drv_info_,
("+rtw_report_sec_ie, authmode=%d\n", authmode));
buff = NULL;
if (authmode == _WPA_IE_ID_) {
RT_TRACE(_module_mlme_osdep_c_, _drv_info_,
("rtw_report_sec_ie, authmode=%d\n", authmode));
buff = rtw_malloc(IW_CUSTOM_MAX);
if (!buff)
return;
memset(buff, 0, IW_CUSTOM_MAX);
p = buff;
p += sprintf(p, "ASSOCINFO(ReqIEs =");
len = sec_ie[1] + 2;
len = min_t(uint, len, IW_CUSTOM_MAX);
for (i = 0; i < len; i++)
p += sprintf(p, "%02x", sec_ie[i]);
p += sprintf(p, ")");
memset(&wrqu, 0, sizeof(wrqu));
wrqu.data.length = min_t(__u16, p - buff, IW_CUSTOM_MAX);
wireless_send_event(adapter->pnetdev, IWEVCUSTOM, &wrqu, buff);
kfree(buff);
}
}
/*
* 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;
HalSdioGetCmdAddr8723BSdio(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 = RND4(cnt);
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;
}
void rtw_report_sec_ie(struct adapter *adapter, u8 authmode, u8 *sec_ie)
{
uint len;
u8 *buff, *p, i;
union iwreq_data wrqu;
_func_enter_;
RT_TRACE(_module_mlme_osdep_c_, _drv_info_,
("+rtw_report_sec_ie, authmode=%d\n", authmode));
buff = NULL;
if (authmode == _WPA_IE_ID_) {
RT_TRACE(_module_mlme_osdep_c_, _drv_info_,
("rtw_report_sec_ie, authmode=%d\n", authmode));
buff = rtw_malloc(IW_CUSTOM_MAX);
if (!buff)
goto exit;
_rtw_memset(buff, 0, IW_CUSTOM_MAX);
p = buff;
p += sprintf(p, "ASSOCINFO(ReqIEs =");
len = sec_ie[1]+2;
len = (len < IW_CUSTOM_MAX) ? len : IW_CUSTOM_MAX;
for (i = 0; i < len; i++)
p += sprintf(p, "%02x", sec_ie[i]);
p += sprintf(p, ")");
_rtw_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;
wireless_send_event(adapter->pnetdev, IWEVCUSTOM, &wrqu, buff);
kfree(buff);
}
exit:
_func_exit_;
}
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 */
kfree(ori);
}
s32 sdio_writeN(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8* pbuf)
{
PADAPTER padapter;
struct dvobj_priv *psdiodev;
PSDIO_DATA psdio;
u8 bMacPwrCtrlOn;
u8 deviceId;
u16 offset;
u32 ftaddr;
u8 shift;
s32 err;
_func_enter_;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
err = 0;
ftaddr = _cvrt2ftaddr(addr, &deviceId, &offset);
rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
if (((deviceId == WLAN_IOREG_DEVICE_ID) && (offset < 0x100))
|| (_FALSE == bMacPwrCtrlOn)
#ifdef CONFIG_LPS_LCLK
|| (_TRUE == padapter->pwrctrlpriv.bFwCurrentInPSMode)
#endif
)
{
err = sd_cmd52_write(psdio, ftaddr, cnt, pbuf);
return err;
}
shift = ftaddr & 0x3;
if (shift == 0) {
err = sd_write(psdio, ftaddr, cnt, pbuf);
} else {
u8 *ptmpbuf;
u32 n;
ftaddr &= ~(u16)0x3;
n = cnt + shift;
ptmpbuf = rtw_malloc(n);
if (NULL == ptmpbuf) return -1;
err = sd_read(psdio, ftaddr, 4, ptmpbuf);
if (err) {
rtw_mfree(ptmpbuf, n);
return err;
}
_rtw_memcpy(ptmpbuf+shift, pbuf, cnt);
err = sd_write(psdio, ftaddr, n, ptmpbuf);
rtw_mfree(ptmpbuf, n);
}
_func_exit_;
return err;
}
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 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)->bFwCurrentInPSMode)
) {
err = sd_cmd52_read(intfhdl, ftaddr, 4, (u8 *)&le_tmp);
#ifdef SDIO_DEBUG_IO
if (!err) {
#endif
return le32_to_cpu(le_tmp);
#ifdef SDIO_DEBUG_IO
}
DBG_8192C(KERN_ERR "%s: Mac Power off, Read FAIL(%d)! addr = 0x%x\n", __func__, err, addr);
return SDIO_ERR_VAL32;
#endif
}
/* 4 bytes alignment */
shift = ftaddr & 0x3;
if (shift == 0) {
val = sd_read32(intfhdl, ftaddr, NULL);
} else {
u8 *tmpbuf;
tmpbuf = rtw_malloc(8);
if (!tmpbuf) {
DBG_8192C(KERN_ERR "%s: Allocate memory FAIL!(size =8) addr = 0x%x\n", __func__, addr);
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;
}
uint sdbus_read_reg_int(struct intf_priv *pintfpriv, u32 addr, u32 cnt, void *pdata)
{
struct dvobj_priv *pdvobjpriv = (struct dvobj_priv*)pintfpriv->intf_dev;
struct sdio_func *func = pdvobjpriv->func;
u8 *mem = NULL;
int status;
#ifdef CONFIG_IO_4B
u32 addr_org = addr, addr_offset = 0;
u32 cnt_org = cnt;
#endif
_func_enter_;
#ifdef CONFIG_IO_4B
addr_offset = addr % 4;
if (addr_offset) {
addr = addr - addr_offset;
cnt = cnt + addr_offset;
}
if (cnt % 4)
cnt = ((cnt + 4) >> 2) << 2;
#endif
mem = rtw_malloc(cnt);
if (mem == NULL) {
RT_TRACE(_module_hci_ops_os_c_, _drv_emerg_,
("SDIO_STATUS_NO_RESOURCES - memory alloc fail\n"));
return _FAIL;
}
status = sdio_memcpy_fromio(func, mem, addr&0x1FFFF, cnt);
if (status) {
//error
RT_TRACE(_module_hci_ops_os_c_, _drv_emerg_,
("sdbus_read_reg_int error 0x%x\n"
"***** Addr = %x *****\n"
"***** Length = %d *****\n", status, addr, cnt));
status = _FAIL;
} else {
#ifdef CONFIG_IO_4B
if (cnt != cnt_org)
_rtw_memcpy(pdata, mem + addr_offset, cnt_org);
else
#endif
_rtw_memcpy(pdata, mem, cnt);
status = _SUCCESS;
}
rtw_mfree(mem, cnt);
_func_exit_;
return status;
}
/*
* Description:
* Read from RX FIFO
* Round read size to block size,
* and make sure data transfer will be done in one command.
*
* Parameters:
* pintfhdl 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 *pintfhdl,
u32 addr,
u32 cnt,
u8 *mem)
{
PADAPTER padapter;
PSDIO_DATA psdio;
PHAL_DATA_TYPE phal;
u32 oldcnt;
#ifdef SDIO_DYNAMIC_ALLOC_MEM
u8 *oldmem;
#endif
s32 err;
padapter = pintfhdl->padapter;
psdio = &adapter_to_dvobj(padapter)->intf_data;
phal = GET_HAL_DATA(padapter);
HalSdioGetCmdAddr8723BSdio(padapter, addr, phal->SdioRxFIFOCnt++, &addr);
oldcnt = cnt;
if (cnt > psdio->block_transfer_len)
cnt = _RND(cnt, psdio->block_transfer_len);
// cnt = sdio_align_size(cnt);
if (oldcnt != cnt) {
#ifdef SDIO_DYNAMIC_ALLOC_MEM
oldmem = mem;
mem = rtw_malloc(cnt);
if (mem == NULL) {
DBG_8192C(KERN_WARNING "%s: allocate memory %d bytes fail!\n", __func__, cnt);
mem = oldmem;
oldmem == NULL;
}
#else
// in this case, caller should gurante the buffer is big enough
// to receive data after alignment
#endif
}
err = _sd_read(pintfhdl, addr, cnt, mem);
#ifdef SDIO_DYNAMIC_ALLOC_MEM
if ((oldcnt != cnt) && (oldmem)) {
_rtw_memcpy(oldmem, mem, oldcnt);
rtw_mfree(mem, cnt);
}
#endif
if (err) return _FAIL;
return _SUCCESS;
}
s32 sdio_writeN(struct intf_hdl *pintfhdl, u32 addr, u32 cnt, u8* pbuf)
{
PADAPTER padapter;
u8 bMacPwrCtrlOn;
u8 deviceId;
u16 offset;
u32 ftaddr;
u8 shift;
s32 err;
_func_enter_;
padapter = pintfhdl->padapter;
err = 0;
ftaddr = _cvrt2ftaddr(addr, &deviceId, &offset);
// rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
// if (((deviceId == WLAN_IOREG_DEVICE_ID) && (offset < 0x100))
// || (_FALSE == bMacPwrCtrlOn)
// #ifdef CONFIG_LPS_LCLK
// || (_TRUE == adapter_to_pwrctl(padapter)->bFwCurrentInPSMode)
// #endif
// )
// {
// err = sd_cmd52_write(pintfhdl, ftaddr, cnt, pbuf);
// return err;
// }
shift = ftaddr & 0x3;
if (shift == 0) {
err = sd_write(pintfhdl, ftaddr, cnt, pbuf);
} else {
u8 *ptmpbuf;
u32 n;
ftaddr &= ~(u16)0x3;
n = cnt + shift;
ptmpbuf = rtw_malloc(n);
if (NULL == ptmpbuf) return -1;
err = sd_read(pintfhdl, ftaddr, 4, ptmpbuf);
if (err) {
rtw_mfree(ptmpbuf, n);
return err;
}
_rtw_memcpy(ptmpbuf+shift, pbuf, cnt);
err = sd_write(pintfhdl, ftaddr, n, ptmpbuf);
rtw_mfree(ptmpbuf, n);
}
_func_exit_;
return err;
}
/**
* rtw_cbuf_alloc - allocte 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 = (struct rtw_cbuf *)rtw_malloc(sizeof(*cbuf) + sizeof(void*)*size);
if (cbuf) {
cbuf->write = cbuf->read = 0;
cbuf->size = size;
}
return cbuf;
}
int *rtw_dev_get_feature_set_matrix(struct net_device *dev, int *num)
{
int feature_set_full, mem_needed;
int *ret;
*num = 0;
mem_needed = sizeof(int) * MAX_FEATURE_SET_CONCURRRENT_GROUPS;
ret = (int *)rtw_malloc(mem_needed);
if (!ret) {
DBG_871X_LEVEL(_drv_err_, FUNC_NDEV_FMT" failed to allocate %d bytes\n"
, FUNC_NDEV_ARG(dev), mem_needed);
return ret;
}
feature_set_full = rtw_dev_get_feature_set(dev);
ret[0] = (feature_set_full & WIFI_FEATURE_INFRA) |
(feature_set_full & WIFI_FEATURE_INFRA_5G) |
(feature_set_full & WIFI_FEATURE_NAN) |
(feature_set_full & WIFI_FEATURE_D2D_RTT) |
(feature_set_full & WIFI_FEATURE_D2AP_RTT) |
(feature_set_full & WIFI_FEATURE_PNO) |
(feature_set_full & WIFI_FEATURE_BATCH_SCAN) |
(feature_set_full & WIFI_FEATURE_GSCAN) |
(feature_set_full & WIFI_FEATURE_HOTSPOT) |
(feature_set_full & WIFI_FEATURE_ADDITIONAL_STA) |
(feature_set_full & WIFI_FEATURE_EPR);
ret[1] = (feature_set_full & WIFI_FEATURE_INFRA) |
(feature_set_full & WIFI_FEATURE_INFRA_5G) |
/* Not yet verified NAN with P2P */
/* (feature_set_full & WIFI_FEATURE_NAN) | */
(feature_set_full & WIFI_FEATURE_P2P) |
(feature_set_full & WIFI_FEATURE_D2AP_RTT) |
(feature_set_full & WIFI_FEATURE_D2D_RTT) |
(feature_set_full & WIFI_FEATURE_EPR);
ret[2] = (feature_set_full & WIFI_FEATURE_INFRA) |
(feature_set_full & WIFI_FEATURE_INFRA_5G) |
(feature_set_full & WIFI_FEATURE_NAN) |
(feature_set_full & WIFI_FEATURE_D2D_RTT) |
(feature_set_full & WIFI_FEATURE_D2AP_RTT) |
(feature_set_full & WIFI_FEATURE_TDLS) |
(feature_set_full & WIFI_FEATURE_TDLS_OFFCHANNEL) |
(feature_set_full & WIFI_FEATURE_EPR);
*num = MAX_FEATURE_SET_CONCURRRENT_GROUPS;
return ret;
}
static void update_bcn_wps_ie(struct adapter *padapter)
{
u8 *pwps_ie = NULL, *pwps_ie_src;
u8 *premainder_ie, *pbackup_remainder_ie = NULL;
uint wps_ielen = 0, wps_offset, remainder_ielen;
struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
struct mlme_ext_info *pmlmeinfo = &pmlmeext->mlmext_info;
struct wlan_bssid_ex *pnetwork = &pmlmeinfo->network;
unsigned char *ie = pnetwork->ies;
u32 ielen = pnetwork->ie_length;
DBG_88E("%s\n", __func__);
pwps_ie_src = pmlmepriv->wps_beacon_ie;
if (!pwps_ie_src)
return;
pwps_ie = rtw_get_wps_ie(ie + _FIXED_IE_LENGTH_,
ielen - _FIXED_IE_LENGTH_, NULL, &wps_ielen);
if (!pwps_ie || wps_ielen == 0)
return;
wps_offset = (uint)(pwps_ie - ie);
premainder_ie = pwps_ie + wps_ielen;
remainder_ielen = ielen - wps_offset - wps_ielen;
if (remainder_ielen > 0) {
pbackup_remainder_ie = rtw_malloc(remainder_ielen);
if (pbackup_remainder_ie)
memcpy(pbackup_remainder_ie, premainder_ie, remainder_ielen);
}
wps_ielen = (uint)pwps_ie_src[1];/* to get ie data len */
if (wps_offset + wps_ielen + 2 + remainder_ielen <= MAX_IE_SZ) {
memcpy(pwps_ie, pwps_ie_src, wps_ielen + 2);
pwps_ie += wps_ielen + 2;
if (pbackup_remainder_ie)
memcpy(pwps_ie, pbackup_remainder_ie, remainder_ielen);
/* update ie_length */
pnetwork->ie_length = wps_offset + wps_ielen + 2 + remainder_ielen;
}
kfree(pbackup_remainder_ie);
}
/*
* Todo: align address to 4 bytes.
*/
s32 sdio_local_write(
PADAPTER padapter,
u32 addr,
u32 cnt,
u8 *pbuf)
{
PSDIO_DATA psdio;
u8 bMacPwrCtrlOn;
s32 err;
u8 *ptmpbuf;
#ifdef CONFIG_DEBUG_RTL819X
if(addr & 0x3)
DBG_8192C("%s, address must be 4 bytes alignment\n", __FUNCTION__);
if(cnt & 0x3)
DBG_8192C("%s, size must be the multiple of 4 \n", __FUNCTION__);
#endif
psdio = &padapter->dvobjpriv.intf_data;
HalSdioGetCmdAddr8723ASdio(padapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
padapter->HalFunc.GetHwRegHandler(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
if ((_FALSE == bMacPwrCtrlOn)
#ifdef CONFIG_LPS_LCLK
|| (_TRUE == padapter->pwrctrlpriv.bFwCurrentInPSMode)
#endif
)
{
err = sd_cmd52_write(psdio, addr, cnt, pbuf);
return err;
}
ptmpbuf = (u8*)rtw_malloc(cnt);
if(!ptmpbuf)
return (-1);
_rtw_memcpy(ptmpbuf, pbuf, cnt);
err = sd_write(psdio, addr, cnt, ptmpbuf);
if (ptmpbuf)
rtw_mfree(ptmpbuf, cnt);
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)->bFwCurrentInPSMode)
)
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;
}
/*
* Todo: align address to 4 bytes.
*/
s32 sdio_local_write(
PADAPTER padapter,
u32 addr,
u32 cnt,
u8 *pbuf)
{
struct intf_hdl * pintfhdl;
u8 bMacPwrCtrlOn;
s32 err;
u8 *ptmpbuf;
if(addr & 0x3)
DBG_8192C("%s, address must be 4 bytes alignment\n", __FUNCTION__);
if(cnt & 0x3)
DBG_8192C("%s, size must be the multiple of 4 \n", __FUNCTION__);
pintfhdl=&padapter->iopriv.intf;
HalSdioGetCmdAddr8723BSdio(padapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
if ((_FALSE == bMacPwrCtrlOn)
#ifdef CONFIG_LPS_LCLK
|| (_TRUE == adapter_to_pwrctl(padapter)->bFwCurrentInPSMode)
#endif
)
{
err = sd_cmd52_write(pintfhdl, addr, cnt, pbuf);
return err;
}
ptmpbuf = (u8*)rtw_malloc(cnt);
if (!ptmpbuf)
return (-1);
_rtw_memcpy(ptmpbuf, pbuf, cnt);
err = sd_write(pintfhdl, addr, cnt, ptmpbuf);
if (ptmpbuf)
rtw_mfree(ptmpbuf, cnt);
return err;
}
/*
* Todo: align address to 4 bytes.
*/
s32 sdio_local_read(
PADAPTER padapter,
u32 addr,
u32 cnt,
u8 *pbuf)
{
PSDIO_DATA psdio;
u8 bMacPwrCtrlOn;
s32 err;
u8 *ptmpbuf;
u32 n;
psdio = &adapter_to_dvobj(padapter)->intf_data;
HalSdioGetCmdAddr8723ASdio(padapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
if ((_FALSE == bMacPwrCtrlOn)
#ifdef CONFIG_LPS_LCLK
|| (_TRUE == padapter->pwrctrlpriv.bFwCurrentInPSMode)
#endif
)
{
err = sd_cmd52_read(psdio, addr, cnt, pbuf);
return err;
}
n = RND4(cnt);
ptmpbuf = (u8*)rtw_malloc(n);
if (!ptmpbuf)
return (-1);
err = sd_read(psdio, addr, n, ptmpbuf);
if (!err)
_rtw_memcpy(pbuf, ptmpbuf, cnt);
if (ptmpbuf)
rtw_mfree(ptmpbuf, n);
return err;
}
static void sd_recv_loopback(PADAPTER padapter, u32 size)
{
PLOOPBACKDATA ploopback;
u32 readsize, allocsize;
u8 *preadbuf;
readsize = size;
DBG_8192C("%s: read size=%d\n", __func__, readsize);
allocsize = _RND(readsize, adapter_to_dvobj(padapter)->intf_data.block_transfer_len);
ploopback = padapter->ploopback;
if (ploopback) {
ploopback->rxsize = readsize;
preadbuf = ploopback->rxbuf;
}
else {
preadbuf = rtw_malloc(allocsize);
if (preadbuf == NULL) {
DBG_8192C("%s: malloc fail size=%d\n", __func__, allocsize);
return;
}
}
// rtw_read_port(padapter, WLAN_RX0FF_DEVICE_ID, readsize, preadbuf);
sdio_read_port(&padapter->iopriv.intf, WLAN_RX0FF_DEVICE_ID, readsize, preadbuf);
if (ploopback)
_rtw_up_sema(&ploopback->sema);
else {
u32 i;
DBG_8192C("%s: drop pkt\n", __func__);
for (i = 0; i < readsize; i+=4) {
DBG_8192C("%08X", *(u32*)(preadbuf + i));
if ((i+4) & 0x1F) printk(" ");
else printk("\n");
}
printk("\n");
rtw_mfree(preadbuf, allocsize);
}
}
/*
* 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;
if (addr & 0x3)
DBG_8192C("%s, address must be 4 bytes alignment\n", __func__);
if (cnt & 0x3)
DBG_8192C("%s, size must be the multiple of 4\n", __func__);
intfhdl = &adapter->iopriv.intf;
HalSdioGetCmdAddr8723BSdio(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)->bFwCurrentInPSMode)
)
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;
}
/*
* Todo: align address to 4 bytes.
*/
s32 _sdio_local_read(
PADAPTER padapter,
u32 addr,
u32 cnt,
u8 *pbuf)
{
struct intf_hdl * pintfhdl;
u8 bMacPwrCtrlOn;
s32 err;
u8 *ptmpbuf;
u32 n;
pintfhdl=&padapter->iopriv.intf;
HalSdioGetCmdAddr8723ASdio(padapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
if ((_FALSE == bMacPwrCtrlOn)
#ifdef CONFIG_LPS_LCLK
// || (_TRUE == adapter_to_pwrctl(padapter)->bFwCurrentInPSMode)
#endif
)
{
err = _sd_cmd52_read(pintfhdl, addr, cnt, pbuf);
return err;
}
n = RND4(cnt);
ptmpbuf = (u8*)rtw_malloc(n);
if(!ptmpbuf)
return (-1);
err = _sd_read(pintfhdl, addr, n, ptmpbuf);
if (!err)
_rtw_memcpy(pbuf, ptmpbuf, cnt);
if(ptmpbuf)
rtw_mfree(ptmpbuf, n);
return err;
}
static void spi_clean_rxfifo(PADAPTER padapter, u32 size)
{
u8 *pbuf;
u32 bufSize, readsize;
s32 ret;
struct spi_more_data more_data = {0};
pbuf = NULL;
bufSize = adapter_to_dvobj(padapter)->intf_data.block_transfer_len;
do {
pbuf = rtw_malloc(bufSize);
if (pbuf) break;
bufSize /= 2;
if (bufSize == 0) {
DBG_8192C(KERN_ERR "%s: Can't allocate any memory for RX!!\n", __func__);
return;
}
} while (1);
while (size)
{
u8 remain_len = 0;
readsize = (size>bufSize)?bufSize:size;
remain_len = readsize%4;
if (remain_len != 0)
readsize += 4 -remain_len;
ret = spi_read_rx_fifo(padapter, pbuf, readsize, &more_data);
if (ret == _FAIL) {
DBG_8192C(KERN_ERR "%s: read port FAIL! size=%d\n", __func__, readsize);
break;
}
size -= readsize;
}
rtw_mfree(pbuf, bufSize);
}
/*
* Todo: align address to 4 bytes.
*/
s32 _sdio_local_read(
PADAPTER padapter,
u32 addr,
u32 cnt,
u8 *pbuf)
{
PSDIO_DATA psdio;
u8 bMacPwrCtrlOn;
s32 err;
u8 *ptmpbuf;
u32 n;
psdio = &adapter_to_dvobj(padapter)->intf_data;
HalSdioGetCmdAddr8723ASdio(padapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
if (_FALSE == bMacPwrCtrlOn)
{
err = _sd_cmd52_read(psdio, addr, cnt, pbuf);
return err;
}
n = RND4(cnt);
ptmpbuf = (u8*)rtw_malloc(n);
if (!ptmpbuf)
return (-1);
err = _sd_read(psdio, addr, n, ptmpbuf);
if (!err)
_rtw_memcpy(pbuf, ptmpbuf, cnt);
if (ptmpbuf)
rtw_mfree(ptmpbuf, n);
return err;
}
/*
* Todo: align address to 4 bytes.
*/
s32 _sdio_local_read(
PADAPTER padapter,
u32 addr,
u32 cnt,
u8 *pbuf)
{
struct intf_hdl * pintfhdl;
u8 bMacPwrCtrlOn;
s32 err;
u8 *ptmpbuf;
u32 n;
pintfhdl=&padapter->iopriv.intf;
HalSdioGetCmdAddr8723BSdio(padapter, SDIO_LOCAL_DEVICE_ID, addr, &addr);
rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
if (_FALSE == bMacPwrCtrlOn)
{
err = _sd_cmd52_read(pintfhdl, addr, cnt, pbuf);
return err;
}
n = RND4(cnt);
ptmpbuf = (u8*)rtw_malloc(n);
if (!ptmpbuf)
return (-1);
err = _sd_read(pintfhdl, addr, n, ptmpbuf);
if (!err)
_rtw_memcpy(pbuf, ptmpbuf, cnt);
if (ptmpbuf)
rtw_mfree(ptmpbuf, n);
return err;
}
int rtw_regd_init(_adapter *padapter)
{
struct wiphy *wiphy = padapter->rtw_wdev->wiphy;
#if 0
if (rtw_regd == NULL) {
rtw_regd = (struct rtw_regulatory *)
rtw_malloc(sizeof(struct rtw_regulatory));
rtw_regd->alpha2[0] = '9';
rtw_regd->alpha2[1] = '9';
rtw_regd->country_code = COUNTRY_CODE_USER;
}
RTW_INFO("%s: Country alpha2 being used: %c%c\n",
__func__, rtw_regd->alpha2[0], rtw_regd->alpha2[1]);
#endif
_rtw_regd_init_wiphy(NULL, wiphy);
return 0;
}
s32 sdio_write32(struct intf_hdl *pintfhdl, u32 addr, u32 val)
{
PADAPTER padapter;
u8 bMacPwrCtrlOn;
u8 deviceId;
u16 offset;
u32 ftaddr;
u8 shift;
s32 err;
_func_enter_;
padapter = pintfhdl->padapter;
err = 0;
ftaddr = _cvrt2ftaddr(addr, &deviceId, &offset);
rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
if (((deviceId == WLAN_IOREG_DEVICE_ID) && (offset < 0x100))
|| (_FALSE == bMacPwrCtrlOn)
#ifdef CONFIG_LPS_LCLK
|| (_TRUE == adapter_to_pwrctl(padapter)->bFwCurrentInPSMode)
#endif
)
{
val = cpu_to_le32(val);
err = sd_cmd52_write(pintfhdl, ftaddr, 4, (u8*)&val);
return err;
}
// 4 bytes alignment
shift = ftaddr & 0x3;
#if 1
if (shift == 0)
{
sd_write32(pintfhdl, ftaddr, val, &err);
}
else
{
val = cpu_to_le32(val);
err = sd_cmd52_write(pintfhdl, ftaddr, 4, (u8*)&val);
}
#else
if (shift == 0) {
sd_write32(pintfhdl, ftaddr, val, &err);
} else {
u8 *ptmpbuf;
ptmpbuf = (u8*)rtw_malloc(8);
if (NULL == ptmpbuf) return (-1);
ftaddr &= ~(u16)0x3;
err = sd_read(pintfhdl, ftaddr, 8, ptmpbuf);
if (err) {
rtw_mfree(ptmpbuf, 8);
return err;
}
val = cpu_to_le32(val);
_rtw_memcpy(ptmpbuf+shift, &val, 4);
err = sd_write(pintfhdl, ftaddr, 8, ptmpbuf);
rtw_mfree(ptmpbuf, 8);
}
#endif
_func_exit_;
return err;
}
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);
up(&(adapter->xmitpriv.xmit_sema));
}
if (hal->sdio_hisr & SDIO_HISR_CPWM1) {
struct reportpwrstate_parm report;
u8 bcancelled;
_cancel_timer(&(pwrctl->pwr_rpwm_timer), &bcancelled);
report.state = SdioLocalCmd52Read1Byte(adapter, SDIO_REG_HCPWM1_8723B);
/* cpwm_int_hdl(adapter, &report); */
_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;
HalSdioGetCmdAddr8723BSdio(adapter, WLAN_IOREG_DEVICE_ID, addr, &addr);
_sd_read(intfhdl, addr, 4, status);
_sd_write(intfhdl, addr, 4, status);
DBG_8192C("%s: SDIO_HISR_TXERR (0x%08x)\n", __func__, le32_to_cpu(*(u32 *)status));
kfree(status);
} else {
DBG_8192C("%s: SDIO_HISR_TXERR, but can't allocate memory to read status!\n", __func__);
}
}
if (hal->sdio_hisr & SDIO_HISR_TXBCNOK) {
DBG_8192C("%s: SDIO_HISR_TXBCNOK\n", __func__);
}
if (hal->sdio_hisr & SDIO_HISR_TXBCNERR) {
DBG_8192C("%s: SDIO_HISR_TXBCNERR\n", __func__);
}
#ifndef CONFIG_C2H_PACKET_EN
if (hal->sdio_hisr & SDIO_HISR_C2HCMD) {
struct c2h_evt_hdr_88xx *c2h_evt;
DBG_8192C("%s: C2H Command\n", __func__);
c2h_evt = rtw_zmalloc(16);
if (c2h_evt != NULL) {
if (rtw_hal_c2h_evt_read(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((u8 *)c2h_evt);
} else {
rtw_c2h_wk_cmd(adapter, (u8 *)c2h_evt);
}
}
} else {
/* Error handling for malloc fail */
if (rtw_cbuf_push(adapter->evtpriv.c2h_queue, NULL) != _SUCCESS)
DBG_871X("%s rtw_cbuf_push fail\n", __func__);
_set_workitem(&adapter->evtpriv.c2h_wk);
}
}
#endif
if (hal->sdio_hisr & SDIO_HISR_RXFOVW) {
DBG_8192C("%s: Rx Overflow\n", __func__);
}
if (hal->sdio_hisr & SDIO_HISR_RXERR) {
DBG_8192C("%s: Rx Error\n", __func__);
}
if (hal->sdio_hisr & SDIO_HISR_RX_REQUEST) {
struct recv_buf *recvbuf;
int alloc_fail_time = 0;
u32 hisr;
/* DBG_8192C("%s: RX Request, size =%d\n", __func__, hal->SdioRxFIFOSize); */
hal->sdio_hisr ^= SDIO_HISR_RX_REQUEST;
do {
hal->SdioRxFIFOSize = SdioLocalCmd52Read2Byte(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++;
DBG_871X("recvbuf is Null for %d times because alloc memory failed\n", alloc_fail_time);
if (alloc_fail_time >= 10)
break;
}
hal->SdioRxFIFOSize = 0;
} else
break;
hisr = 0;
ReadInterrupt8723BSdio(adapter, &hisr);
hisr &= SDIO_HISR_RX_REQUEST;
if (!hisr)
break;
} while (1);
if (alloc_fail_time == 10)
DBG_871X("exit because alloc memory failed more than 10 times\n");
}
}
void SetFwRsvdPagePkt(PADAPTER Adapter, BOOLEAN bDLFinished)
{
HAL_DATA_TYPE *pHalData = GET_HAL_DATA(Adapter);
struct xmit_frame *pmgntframe;
struct pkt_attrib *pattrib;
struct xmit_priv *pxmitpriv = &(Adapter->xmitpriv);
struct mlme_ext_priv *pmlmeext = &(Adapter->mlmeextpriv);
struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
u32 BeaconLength, ProbeRspLength, PSPollLength, NullFunctionDataLength;
u8 *ReservedPagePacket;
u8 PageNum=0, U1bTmp, TxDescLen=0, TxDescOffset=0;
u16 BufIndex=0;
u32 TotalPacketLen;
u8 u1RsvdPageLoc[3]={0};
BOOLEAN bDLOK = _FALSE;
DBG_871X("%s\n", __FUNCTION__);
ReservedPagePacket = (u8*)rtw_malloc(1000);
if(ReservedPagePacket == NULL){
DBG_871X("%s(): alloc ReservedPagePacket fail !!!\n", __FUNCTION__);
return;
}
_rtw_memset(ReservedPagePacket, 0, 1000);
TxDescLen = 32;//TX_DESC_SIZE;
#ifdef CONFIG_USB_HCI
BufIndex = TXDESC_OFFSET;
TxDescOffset = TxDescLen + PACKET_OFFSET_SZ;;
#else
BufIndex = 0;
TxDescOffset = 0;
#endif
//(1) beacon
ConstructBeacon(Adapter,&ReservedPagePacket[BufIndex],&BeaconLength);
RT_PRINT_DATA(_module_rtl8712_cmd_c_, _drv_info_,
"SetFwRsvdPagePkt(): HW_VAR_SET_TX_CMD: BCN\n",
&ReservedPagePacket[BufIndex], (BeaconLength+BufIndex));
//--------------------------------------------------------------------
// 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.
U1bTmp = (u8)PageNum_128(BeaconLength+TxDescLen);
PageNum += U1bTmp;
// To reserved 2 pages for beacon buffer. 2010.06.24.
if(PageNum == 1)
PageNum+=1;
pHalData->FwRsvdPageStartOffset = PageNum;
BufIndex = (PageNum*128) + TxDescOffset;
//(2) ps-poll
ConstructPSPoll(Adapter, &ReservedPagePacket[BufIndex],&PSPollLength);
FillFakeTxDescriptor92D(Adapter, &ReservedPagePacket[BufIndex-TxDescLen], PSPollLength, _TRUE);
RT_PRINT_DATA(_module_rtl8712_cmd_c_, _drv_info_,
"SetFwRsvdPagePkt(): HW_VAR_SET_TX_CMD: PS-POLL\n",
&ReservedPagePacket[BufIndex-TxDescLen], (PSPollLength+TxDescLen));
SET_H2CCMD_RSVDPAGE_LOC_PSPOLL(u1RsvdPageLoc, PageNum );
//------------------------------------------------------------------
U1bTmp = (u8)PageNum_128(PSPollLength+TxDescLen);
PageNum += U1bTmp;
BufIndex = (PageNum*128) + TxDescOffset;
//(3) null data
ConstructNullFunctionData(
Adapter,
&ReservedPagePacket[BufIndex],
&NullFunctionDataLength,
get_my_bssid(&(pmlmeinfo->network)),
_FALSE);
FillFakeTxDescriptor92D(Adapter, &ReservedPagePacket[BufIndex-TxDescLen], NullFunctionDataLength, _FALSE);
SET_H2CCMD_RSVDPAGE_LOC_NULL_DATA(u1RsvdPageLoc, PageNum);
RT_PRINT_DATA(_module_rtl8712_cmd_c_, _drv_info_,
"SetFwRsvdPagePkt(): HW_VAR_SET_TX_CMD: NULL DATA \n",
&ReservedPagePacket[BufIndex-TxDescLen], (NullFunctionDataLength+TxDescLen));
//------------------------------------------------------------------
U1bTmp = (u8)PageNum_128(NullFunctionDataLength+TxDescLen);
PageNum += U1bTmp;
BufIndex = (PageNum*128) + TxDescOffset;
//(4) probe response
ConstructProbeRsp(
Adapter,
&ReservedPagePacket[BufIndex],
&ProbeRspLength,
get_my_bssid(&(pmlmeinfo->network)),
_FALSE);
FillFakeTxDescriptor92D(Adapter, &ReservedPagePacket[BufIndex-TxDescLen], ProbeRspLength, _FALSE);
SET_H2CCMD_RSVDPAGE_LOC_PROBE_RSP(u1RsvdPageLoc, PageNum);
RT_PRINT_DATA(_module_rtl8712_cmd_c_, _drv_info_,
"SetFwRsvdPagePkt(): HW_VAR_SET_TX_CMD: PROBE RSP \n",
&ReservedPagePacket[BufIndex-TxDescLen], (ProbeRspLength-TxDescLen));
//------------------------------------------------------------------
U1bTmp = (u8)PageNum_128(ProbeRspLength+TxDescLen);
PageNum += U1bTmp;
TotalPacketLen = (PageNum*128);
if ((pmgntframe = alloc_mgtxmitframe(pxmitpriv)) == NULL)
{
return;
}
//update attribute
pattrib = &pmgntframe->attrib;
update_mgntframe_attrib(Adapter, pattrib);
pattrib->qsel = 0x10;
pattrib->pktlen = pattrib->last_txcmdsz = TotalPacketLen - TxDescLen;
_rtw_memcpy(pmgntframe->buf_addr, ReservedPagePacket, TotalPacketLen);
rtw_hal_mgnt_xmit(Adapter, pmgntframe);
bDLOK = _TRUE;
if(bDLOK)
{
DBG_871X("Set RSVD page location to Fw.\n");
FillH2CCmd92D(Adapter, H2C_RSVDPAGE, sizeof(u1RsvdPageLoc), u1RsvdPageLoc);
//FillH2CCmd92D(Adapter, H2C_RSVDPAGE, sizeof(RsvdPageLoc), (u8 *)&RsvdPageLoc);
}
rtw_mfree(ReservedPagePacket,1000);
}
void sd_int_dpc(PADAPTER padapter)
{
PHAL_DATA_TYPE phal;
struct dvobj_priv *dvobj;
struct intf_hdl * pintfhdl=&padapter->iopriv.intf;
struct pwrctrl_priv *pwrctl;
phal = GET_HAL_DATA(padapter);
dvobj = adapter_to_dvobj(padapter);
pwrctl = dvobj_to_pwrctl(dvobj);
#ifdef CONFIG_SDIO_TX_ENABLE_AVAL_INT
if (phal->sdio_hisr & SDIO_HISR_AVAL)
{
//_irqL irql;
u8 freepage[4];
_sdio_local_read(padapter, SDIO_REG_FREE_TXPG, 4, freepage);
//_enter_critical_bh(&phal->SdioTxFIFOFreePageLock, &irql);
//_rtw_memcpy(phal->SdioTxFIFOFreePage, freepage, 4);
//_exit_critical_bh(&phal->SdioTxFIFOFreePageLock, &irql);
//DBG_871X("SDIO_HISR_AVAL, Tx Free Page = 0x%x%x%x%x\n",
// freepage[0],
// freepage[1],
// freepage[2],
// freepage[3]);
_rtw_up_sema(&(padapter->xmitpriv.xmit_sema));
}
#endif
if (phal->sdio_hisr & SDIO_HISR_CPWM1)
{
struct reportpwrstate_parm report;
#ifdef CONFIG_LPS_RPWM_TIMER
u8 bcancelled;
_cancel_timer(&(pwrctl->pwr_rpwm_timer), &bcancelled);
#endif // CONFIG_LPS_RPWM_TIMER
report.state = SdioLocalCmd52Read1Byte(padapter, SDIO_REG_HCPWM1_8723B);
#ifdef CONFIG_LPS_LCLK
//cpwm_int_hdl(padapter, &report);
_set_workitem(&(pwrctl->cpwm_event));
#endif
}
if (phal->sdio_hisr & SDIO_HISR_TXERR)
{
u8 *status;
u32 addr;
status = rtw_malloc(4);
if (status)
{
addr = REG_TXDMA_STATUS;
HalSdioGetCmdAddr8723BSdio(padapter, WLAN_IOREG_DEVICE_ID, addr, &addr);
_sd_read(pintfhdl, addr, 4, status);
_sd_write(pintfhdl, addr, 4, status);
DBG_8192C("%s: SDIO_HISR_TXERR (0x%08x)\n", __func__, le32_to_cpu(*(u32*)status));
rtw_mfree(status, 4);
} else {
DBG_8192C("%s: SDIO_HISR_TXERR, but can't allocate memory to read status!\n", __func__);
}
}
if (phal->sdio_hisr & SDIO_HISR_TXBCNOK)
{
DBG_8192C("%s: SDIO_HISR_TXBCNOK\n", __func__);
}
if (phal->sdio_hisr & SDIO_HISR_TXBCNERR)
{
DBG_8192C("%s: SDIO_HISR_TXBCNERR\n", __func__);
}
#ifndef CONFIG_C2H_PACKET_EN
if (phal->sdio_hisr & SDIO_HISR_C2HCMD)
{
struct c2h_evt_hdr_88xx *c2h_evt;
DBG_8192C("%s: C2H Command\n", __func__);
if ((c2h_evt = (struct c2h_evt_hdr_88xx*)rtw_zmalloc(16)) != NULL) {
if (rtw_hal_c2h_evt_read(padapter, (u8 *)c2h_evt) == _SUCCESS) {
if (c2h_id_filter_ccx_8723b((u8 *)c2h_evt)) {
/* Handle CCX report here */
rtw_hal_c2h_handler(padapter, (u8 *)c2h_evt);
rtw_mfree((u8*)c2h_evt, 16);
} else {
rtw_c2h_wk_cmd(padapter, (u8 *)c2h_evt);
}
}
} else {
/* Error handling for malloc fail */
if (rtw_cbuf_push(padapter->evtpriv.c2h_queue, (void*)NULL) != _SUCCESS)
DBG_871X("%s rtw_cbuf_push fail\n", __func__);
_set_workitem(&padapter->evtpriv.c2h_wk);
}
}
#endif
if (phal->sdio_hisr & SDIO_HISR_RXFOVW)
{
DBG_8192C("%s: Rx Overflow\n", __func__);
}
if (phal->sdio_hisr & SDIO_HISR_RXERR)
{
DBG_8192C("%s: Rx Error\n", __func__);
}
if (phal->sdio_hisr & SDIO_HISR_RX_REQUEST)
{
struct recv_buf *precvbuf;
int alloc_fail_time=0;
u32 hisr;
// DBG_8192C("%s: RX Request, size=%d\n", __func__, phal->SdioRxFIFOSize);
phal->sdio_hisr ^= SDIO_HISR_RX_REQUEST;
do {
phal->SdioRxFIFOSize = SdioLocalCmd52Read2Byte(padapter, SDIO_REG_RX0_REQ_LEN);
if (phal->SdioRxFIFOSize != 0)
{
#ifdef CONFIG_MAC_LOOPBACK_DRIVER
sd_recv_loopback(padapter, phal->SdioRxFIFOSize);
#else
precvbuf = sd_recv_rxfifo(padapter, phal->SdioRxFIFOSize);
if (precvbuf)
sd_rxhandler(padapter, precvbuf);
else
{
alloc_fail_time++;
DBG_871X("precvbuf is Null for %d times because alloc memory failed\n", alloc_fail_time);
if (alloc_fail_time >= 10)
break;
}
phal->SdioRxFIFOSize = 0;
#endif
}
else
break;
hisr = 0;
ReadInterrupt8723BSdio(padapter, &hisr);
hisr &= SDIO_HISR_RX_REQUEST;
if (!hisr)
break;
} while (1);
if(alloc_fail_time==10)
DBG_871X("exit because alloc memory failed more than 10 times \n");
}
}
u32 sdio_read32(struct intf_hdl *pintfhdl, u32 addr)
{
PADAPTER padapter;
u8 bMacPwrCtrlOn;
u8 deviceId;
u16 offset;
u32 ftaddr;
u8 shift;
u32 val;
s32 err;
_func_enter_;
padapter = pintfhdl->padapter;
ftaddr = _cvrt2ftaddr(addr, &deviceId, &offset);
rtw_hal_get_hwreg(padapter, HW_VAR_APFM_ON_MAC, &bMacPwrCtrlOn);
if (((deviceId == WLAN_IOREG_DEVICE_ID) && (offset < 0x100))
|| (_FALSE == bMacPwrCtrlOn)
#ifdef CONFIG_LPS_LCLK
|| (_TRUE == adapter_to_pwrctl(padapter)->bFwCurrentInPSMode)
#endif
)
{
err = sd_cmd52_read(pintfhdl, ftaddr, 4, (u8*)&val);
#ifdef SDIO_DEBUG_IO
if (!err) {
#endif
val = le32_to_cpu(val);
return val;
#ifdef SDIO_DEBUG_IO
}
DBG_8192C(KERN_ERR "%s: Mac Power off, Read FAIL(%d)! addr=0x%x\n", __func__, err, addr);
return SDIO_ERR_VAL32;
#endif
}
// 4 bytes alignment
shift = ftaddr & 0x3;
if (shift == 0) {
val = sd_read32(pintfhdl, ftaddr, NULL);
} else {
u8 *ptmpbuf;
ptmpbuf = (u8*)rtw_malloc(8);
if (NULL == ptmpbuf) {
DBG_8192C(KERN_ERR "%s: Allocate memory FAIL!(size=8) addr=0x%x\n", __func__, addr);
return SDIO_ERR_VAL32;
}
ftaddr &= ~(u16)0x3;
sd_read(pintfhdl, ftaddr, 8, ptmpbuf);
_rtw_memcpy(&val, ptmpbuf+shift, 4);
val = le32_to_cpu(val);
rtw_mfree(ptmpbuf, 8);
}
_func_exit_;
return val;
}
