/*----------------------------------------------------------------------------*/
BOOL kalDevRegRead(IN P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Register, OUT PUINT_32 pu4Value)
{
int ret = 0;
ASSERT(prGlueInfo);
ASSERT(pu4Value);
#if MTK_WCN_HIF_SDIO
ret = mtk_wcn_hif_sdio_readl(prGlueInfo->rHifInfo.cltCtx, u4Register, (PUINT32) pu4Value);
#else
if (!in_interrupt) {
sdio_claim_host(prGlueInfo->rHifInfo.func);
}
*pu4Value = sdio_readl(prGlueInfo->rHifInfo.func, u4Register, &ret);
if (!in_interrupt) {
sdio_release_host(prGlueInfo->rHifInfo.func);
}
#endif
if (ret) {
kalSendAeeWarning(HIF_SDIO_ERR_TITLE_STR,
HIF_SDIO_ERR_DESC_STR "sdio_readl() reports error: %x", ret);
DBGLOG(HAL, ERROR, ("sdio_readl() reports error: %x", ret));
}
return (ret) ? FALSE : TRUE;
} /* end of kalDevRegRead() */
u32 sd_read32(PSDIO_DATA psdio, u32 addr, s32 *err)
{
u32 v;
struct sdio_func *func;
bool claim_needed;
_func_enter_;
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;
DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x\n", __func__, *err, addr, v);
*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)
break;
}
if (i==SD_IO_TRY_CNT)
DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
else
DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
}
_func_exit_;
return v;
}
/* for enumeration use only */
u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset)
{
u32 val;
int error;
sdio_claim_host(bus->host_sdio);
val = sdio_readl(bus->host_sdio, offset, &error);
sdio_release_host(bus->host_sdio);
if (unlikely(error)) {
dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n",
bus->sdio_sbaddr >> 16, offset, val, error);
}
return val;
}
int brcmf_sdioh_request_word(struct brcmf_sdio_dev *sdiodev,
uint rw, uint func, uint addr, u32 *word,
uint nbytes)
{
int err_ret = -EIO;
if (func == 0) {
brcmf_dbg(ERROR, "Only CMD52 allowed to F0\n");
return -EINVAL;
}
brcmf_dbg(INFO, "rw=%d, func=%d, addr=0x%05x, nbytes=%d\n",
rw, func, addr, nbytes);
brcmf_pm_resume_wait(sdiodev, &sdiodev->request_word_wait);
if (brcmf_pm_resume_error(sdiodev))
return -EIO;
/* Claim host controller */
sdio_claim_host(sdiodev->func[func]);
if (rw) { /* CMD52 Write */
if (nbytes == 4)
sdio_writel(sdiodev->func[func], *word, addr,
&err_ret);
else if (nbytes == 2)
sdio_writew(sdiodev->func[func], (*word & 0xFFFF),
addr, &err_ret);
else
brcmf_dbg(ERROR, "Invalid nbytes: %d\n", nbytes);
} else { /* CMD52 Read */
if (nbytes == 4)
*word = sdio_readl(sdiodev->func[func], addr, &err_ret);
else if (nbytes == 2)
*word = sdio_readw(sdiodev->func[func], addr,
&err_ret) & 0xFFFF;
else
brcmf_dbg(ERROR, "Invalid nbytes: %d\n", nbytes);
}
/* Release host controller */
sdio_release_host(sdiodev->func[func]);
if (err_ret)
brcmf_dbg(ERROR, "Failed to %s word, Err: 0x%08x\n",
rw ? "write" : "read", err_ret);
return err_ret;
}
INT32 MTSDIORead32(RTMP_ADAPTER *pAd, UINT32 Offset, UINT32 *Value)
{
INT32 Ret = 0;
void* handle = pAd->OS_Cookie;
struct sdio_func *dev_func = ((POS_COOKIE)handle)->sdio_dev;
sdio_claim_host(dev_func);
*Value = sdio_readl(dev_func, Offset, &Ret);
sdio_release_host(dev_func);
if (Ret) {
DBGPRINT(RT_DEBUG_ERROR, ("RTSDIORead32 failure!\n"));
}
return Ret;
}
u32 sd_read32(PSDIO_DATA psdio, u32 addr, s32 *err)
{
u32 v;
struct sdio_func *func;
_func_enter_;
func = psdio->func;
sdio_claim_host(func);
v = sdio_readl(func, addr, err);
sdio_release_host(func);
if (err && *err)
DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x\n", __func__, *err, addr);
_func_exit_;
return v;
}
u32 brcmf_sdiod_readl(struct brcmf_sdio_dev *sdiodev, u32 addr, int *ret)
{
u32 data = 0;
int retval;
retval = brcmf_sdiod_set_backplane_window(sdiodev, addr);
if (retval)
goto out;
addr &= SBSDIO_SB_OFT_ADDR_MASK;
addr |= SBSDIO_SB_ACCESS_2_4B_FLAG;
data = sdio_readl(sdiodev->func1, addr, &retval);
out:
if (ret)
*ret = retval;
return data;
}
static void ssb_sdio_write32(struct ssb_device *dev, u16 offset, u32 val)
{
struct ssb_bus *bus = dev->bus;
int error = 0;
sdio_claim_host(bus->host_sdio);
if (unlikely(ssb_sdio_switch_core(bus, dev)))
goto out;
offset |= bus->sdio_sbaddr & 0xffff;
offset &= SBSDIO_SB_OFT_ADDR_MASK;
offset |= SBSDIO_SB_ACCESS_2_4B_FLAG; /* 32 bit data access */
sdio_writel(bus->host_sdio, val, offset, &error);
if (error) {
dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %08x, error %d\n",
bus->sdio_sbaddr >> 16, offset, val, error);
}
if (bus->quirks & SSB_QUIRK_SDIO_READ_AFTER_WRITE32)
sdio_readl(bus->host_sdio, 0, &error);
out:
sdio_release_host(bus->host_sdio);
}
static u32 ssb_sdio_read32(struct ssb_device *dev, u16 offset)
{
struct ssb_bus *bus = dev->bus;
u32 val = 0xffffffff;
int error = 0;
sdio_claim_host(bus->host_sdio);
if (unlikely(ssb_sdio_switch_core(bus, dev)))
goto out;
offset |= bus->sdio_sbaddr & 0xffff;
offset &= SBSDIO_SB_OFT_ADDR_MASK;
offset |= SBSDIO_SB_ACCESS_2_4B_FLAG; /* 32 bit data access */
val = sdio_readl(bus->host_sdio, offset, &error);
if (error) {
dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n",
bus->sdio_sbaddr >> 16, offset, val, error);
}
out:
sdio_release_host(bus->host_sdio);
return val;
}
u32 sd_read32(struct intf_hdl *pintfhdl, u32 addr, s32 *err)
{
PADAPTER padapter;
struct dvobj_priv *psdiodev;
PSDIO_DATA psdio;
u32 v=0;
struct sdio_func *func;
bool claim_needed;
_func_enter_;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if(padapter->bSurpriseRemoved){
//DBG_871X(" %s (padapter->bSurpriseRemoved )!!!\n",__FUNCTION__);
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;
DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x\n", __func__, *err, addr, v);
*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{
DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
if(( -ESHUTDOWN == *err ) || ( -ENODEV == *err)){
padapter->bSurpriseRemoved = _TRUE;
}
if(rtw_inc_and_chk_continual_io_error(psdiodev) == _TRUE ){
padapter->bSurpriseRemoved = _TRUE;
break;
}
}
}
if (i==SD_IO_TRY_CNT)
DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
else
DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x, val=0x%x, try_cnt=%d\n", __func__, *err, addr, v, i);
}
_func_exit_;
return v;
}
static struct buffer_descriptor *rx_packet(struct net_adapter *adapter)
{
int ret = 0;
int read_idx;
struct buffer_descriptor *bufdsc;
s32 t_len;
s32 t_index;
s32 t_size;
u8 *t_buff;
read_idx = sdio_readb(adapter->func, SDIO_C2H_RP_REG, &ret);
bufdsc = kmalloc(sizeof(*bufdsc), GFP_KERNEL);
if (unlikely(!bufdsc)) {
pr_err("%s bufdsc alloc fail", __func__);
return NULL;
}
if (unlikely(ret)) {
pr_err("%s sdio_readb error", __func__);
schedule_work(&adapter->wimax_reset);
goto err;
}
#if 0
/*check modem buffer overflow*/
if (read_idx == sdio_readb(adapter->func, SDIO_C2H_WP_REG, &ret)) {
read_idx = -1;
goto err;
}
#endif
#ifdef CMC7xx_MULTIPACKET_SUPPORT
if (adapter->download_complete)
t_len = sdio_readl(adapter->func, (SDIO_RX_BANK_ADDR +
(read_idx * SDIO_RXBANK_SIZE)), &ret);
else
#endif
t_len = sdio_readl(adapter->func, (SDIO_RX_BANK_ADDR +
(read_idx * SDIO_BANK_SIZE)), &ret);
if (unlikely(ret)) {
pr_err("%s sdio_readl error", __func__);
schedule_work(&adapter->wimax_reset);
goto err;
}
#ifdef CMC7xx_MULTIPACKET_SUPPORT
if (adapter->download_complete) {
if (unlikely(t_len > (SDIO_RXBANK_SIZE -
CMC732_PACKET_LENGTH_SIZE))) {
pr_err("%s length out of bound", __func__);
t_len = SDIO_RXBANK_SIZE - CMC732_PACKET_LENGTH_SIZE;
}
sdio_writeb(adapter->func, (read_idx + 1) % SDIO_RXBANK_COUNT,
SDIO_C2H_RP_REG, NULL);
} else
#endif
{
if (unlikely(t_len > (SDIO_BANK_SIZE -
CMC732_PACKET_LENGTH_SIZE))) {
pr_err("%s length out of bound", __func__);
t_len = SDIO_BANK_SIZE - CMC732_PACKET_LENGTH_SIZE;
}
sdio_writeb(adapter->func, (read_idx + 1) % 16,
SDIO_C2H_RP_REG, NULL);
}
bufdsc->buffer = kmalloc(t_len, GFP_KERNEL);
if (unlikely(!bufdsc->buffer)) {
pr_err("%s bufdsc->buffer alloc fail", __func__);
goto err;
}
bufdsc->length = (s32)t_len;
t_buff = (u8 *)bufdsc->buffer;
#ifdef RX_SINGLE_BLOCK_MODE
#ifdef CMC7xx_MULTIPACKET_SUPPORT
if (adapter->download_complete)
t_index = (SDIO_RX_BANK_ADDR +
(SDIO_RXBANK_SIZE * read_idx) + 4);
else
#endif
t_index = (SDIO_RX_BANK_ADDR + (SDIO_BANK_SIZE * read_idx) + 4);
while (likely(t_len)) {
t_size = (t_len > CMC_BLOCK_SIZE) ?
(CMC_BLOCK_SIZE) : t_len;
ret = sdio_memcpy_fromio(adapter->func, (void *)t_buff,
t_index, t_size);
if (unlikely(ret)) {
pr_err("%s sdio_memcpy_fromio fail\n", __func__);
schedule_work(&adapter->wimax_reset);
goto err_2;
}
t_len -= t_size;
t_buff += t_size;
t_index += t_size;
}
#else
ret = sdio_memcpy_fromio(adapter->func, (void *)t_buff,
t_index, t_len);
if (unlikely(ret)) {
pr_err("%s sdio_memcpy_fromio fail", __func__);
schedule_work(&adapter->wimax_reset);
goto err_2;
}
#endif
return bufdsc;
err_2:
kfree(bufdsc->buffer);
err:
kfree(bufdsc);
adapter->netstats.rx_dropped++;
return NULL;
}
