void _sd_write32(PSDIO_DATA psdio, u32 addr, u32 v, s32 *err)
{
struct sdio_func *func;
_func_enter_;
func = psdio->func;
sdio_writel(func, v, addr, err);
if (err && *err)
{
int i;
DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x val=0x%08x\n", __func__, *err, addr, v);
*err = 0;
for(i=0; i<SD_IO_TRY_CNT; i++)
{
sdio_writel(func, v, addr, err);
if (*err == 0)
break;
}
if (i==SD_IO_TRY_CNT)
DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x val=0x%08x, try_cnt=%d\n", __func__, *err, addr, v, i);
else
DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x val=0x%08x, try_cnt=%d\n", __func__, *err, addr, v, i);
}
_func_exit_;
}
void sd_write32(struct intf_hdl *pintfhdl, u32 addr, u32 v, s32 *err)
{
PADAPTER padapter;
struct dvobj_priv *psdiodev;
PSDIO_DATA psdio;
struct sdio_func *func;
bool claim_needed;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if (padapter->bSurpriseRemoved){
/* DBG_871X(" %s (padapter->bSurpriseRemoved ||adapter->pwrctrlpriv.pnp_bstop_trx)!!!\n", __FUNCTION__); */
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;
DBG_871X(KERN_ERR "%s: (%d) addr =0x%05x val =0x%08x\n", __func__, *err, addr, v);
*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{
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%08x, try_cnt =%d\n", __func__, *err, addr, v, i);
else
DBG_871X(KERN_ERR "%s: (%d) addr =0x%05x val =0x%08x, try_cnt =%d\n", __func__, *err, addr, v, i);
}
}
void _sd_write32(struct intf_hdl *pintfhdl, u32 addr, u32 v, s32 *err)
{
PADAPTER padapter;
struct dvobj_priv *psdiodev;
PSDIO_DATA psdio;
struct sdio_func *func;
_func_enter_;
padapter = pintfhdl->padapter;
psdiodev = pintfhdl->pintf_dev;
psdio = &psdiodev->intf_data;
if(padapter->bSurpriseRemoved){
//DBG_871X(" %s (padapter->bSurpriseRemoved )!!!\n",__FUNCTION__);
return ;
}
func = psdio->func;
sdio_writel(func, v, addr, err);
if (err && *err)
{
int i;
DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x val=0x%08x\n", __func__, *err, addr, v);
*err = 0;
for(i=0; i<SD_IO_TRY_CNT; i++)
{
sdio_writel(func, v, addr, err);
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%08x, try_cnt=%d\n", __func__, *err, addr, v, i);
else
DBG_871X(KERN_ERR "%s: (%d) addr=0x%05x val=0x%08x, try_cnt=%d\n", __func__, *err, addr, v, i);
}
_func_exit_;
}
/*----------------------------------------------------------------------------*/
BOOL kalDevRegWrite(IN P_GLUE_INFO_T prGlueInfo, IN UINT_32 u4Register, IN UINT_32 u4Value)
{
int ret = 0;
ASSERT(prGlueInfo);
#if MTK_WCN_HIF_SDIO
ret = mtk_wcn_hif_sdio_writel(prGlueInfo->rHifInfo.cltCtx, u4Register, u4Value);
#else
if (!in_interrupt) {
sdio_claim_host(prGlueInfo->rHifInfo.func);
}
sdio_writel(prGlueInfo->rHifInfo.func, u4Value, 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_writel() reports error: %x", ret);
DBGLOG(HAL, ERROR, ("sdio_writel() reports error: %x", ret));
}
return (ret) ? FALSE : TRUE;
} /* end of kalDevRegWrite() */
static void mtk_sdio_interrupt(struct sdio_func *func)
{
P_GLUE_INFO_T prGlueInfo = NULL;
int ret = 0;
prGlueInfo = sdio_get_drvdata(func);
//ASSERT(prGlueInfo);
if (!prGlueInfo) {
//printk(KERN_INFO DRV_NAME"No glue info in mtk_sdio_interrupt()\n");
return;
}
if (prGlueInfo->u4Flag & GLUE_FLAG_HALT) {
sdio_writel(prGlueInfo->rHifInfo.func, WHLPCR_INT_EN_CLR, MCR_WHLPCR, &ret);
//printk(KERN_INFO DRV_NAME"GLUE_FLAG_HALT skip INT\n");
return;
}
sdio_writel(prGlueInfo->rHifInfo.func, WHLPCR_INT_EN_CLR, MCR_WHLPCR, &ret);
#if 0
wlanISR(prGlueInfo->prAdapter, TRUE);
if (prGlueInfo->u4Flag & GLUE_FLAG_HALT) {
/* Should stop now... skip pending interrupt */
//printk(KERN_INFO DRV_NAME"ignore pending interrupt\n");
}
else {
wlanIST(prGlueInfo->prAdapter);
}
#endif
set_bit (GLUE_FLAG_INT_BIT, &prGlueInfo->u4Flag);
/* when we got sdio interrupt, we wake up the tx servie thread*/
#if CFG_SUPPORT_MULTITHREAD
wake_up_interruptible(&prGlueInfo->waitq_hif);
#else
wake_up_interruptible(&prGlueInfo->waitq);
#endif
}
INT32 MTSDIOWrite32(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);
sdio_writel(dev_func, Value, Offset, &Ret);
sdio_release_host(dev_func);
return Ret;
}
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;
}
void sd_write32(PSDIO_DATA psdio, u32 addr, u32 v, s32 *err)
{
struct sdio_func *func;
_func_enter_;
func = psdio->func;
sdio_claim_host(func);
sdio_writel(func, v, addr, err);
sdio_release_host(func);
if (err && *err)
DBG_871X(KERN_ERR "%s: FAIL!(%d) addr=0x%05x val=0x%08x\n", __func__, *err, addr, v);
_func_exit_;
}
void brcmf_sdiod_writel(struct brcmf_sdio_dev *sdiodev, u32 addr,
u32 data, int *ret)
{
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;
sdio_writel(sdiodev->func1, data, addr, &retval);
out:
if (ret)
*ret = retval;
}
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);
}
/*----------------------------------------------------------------------------*/
BOOL
kalDevPortRead(IN P_GLUE_INFO_T prGlueInfo,
IN UINT_16 u2Port,
IN UINT_32 u4Len, OUT PUINT_8 pucBuf, IN UINT_32 u4ValidOutBufSize)
{
P_GL_HIF_INFO_T prHifInfo = NULL;
PUINT_8 pucDst = NULL;
int count = u4Len;
int ret = 0;
int bNum = 0;
#if (MTK_WCN_HIF_SDIO == 0)
struct sdio_func *prSdioFunc = NULL;
#endif
#if DBG
/* printk(KERN_INFO DRV_NAME"++kalDevPortRead++ buf:0x%p, port:0x%x, length:%d\n", pucBuf, u2Port, u4Len); */
#endif
ASSERT(prGlueInfo);
prHifInfo = &prGlueInfo->rHifInfo;
ASSERT(pucBuf);
pucDst = pucBuf;
ASSERT(u4Len <= u4ValidOutBufSize);
#if (MTK_WCN_HIF_SDIO == 0)
prSdioFunc = prHifInfo->func;
ASSERT(prSdioFunc->cur_blksize > 0);
if (!in_interrupt) {
sdio_claim_host(prSdioFunc);
}
/* Split buffer into multiple single block to workaround hifsys */
while (count >= prSdioFunc->cur_blksize) {
count -= prSdioFunc->cur_blksize;
bNum++;
}
if (count > 0 && bNum > 0) {
bNum++;
}
if (bNum > 0) {
ret = sdio_readsb(prSdioFunc, pucDst, u2Port, prSdioFunc->cur_blksize * bNum);
#ifdef CONFIG_X86
/* ENE workaround */
{
int tmp;
sdio_writel(prSdioFunc, 0x0, SDIO_X86_WORKAROUND_WRITE_MCR, &tmp);
}
#endif
} else {
ret = sdio_readsb(prSdioFunc, pucDst, u2Port, count);
}
if (!in_interrupt) {
sdio_release_host(prSdioFunc);
}
#else
/* Split buffer into multiple single block to workaround hifsys */
while (count >= (prGlueInfo->rHifInfo).prFuncInfo->blk_sz) {
count -= ((prGlueInfo->rHifInfo).prFuncInfo->blk_sz);
bNum++;
}
if (count > 0 && bNum > 0) {
bNum++;
}
if (bNum > 0) {
ret =
mtk_wcn_hif_sdio_read_buf(prGlueInfo->rHifInfo.cltCtx, u2Port, (PUINT32) pucDst,
((prGlueInfo->rHifInfo).prFuncInfo->blk_sz) * bNum);
} else {
ret =
mtk_wcn_hif_sdio_read_buf(prGlueInfo->rHifInfo.cltCtx, u2Port, (PUINT32) pucDst,
count);
}
#endif
if (ret) {
kalSendAeeWarning(HIF_SDIO_ERR_TITLE_STR,
HIF_SDIO_ERR_DESC_STR "sdio_readsb() reports error: %x", ret);
DBGLOG(HAL, ERROR, ("sdio_readsb() reports error: %x", ret));
}
return (ret) ? FALSE : TRUE;
} /* end of kalDevPortRead() */
static int write_data(struct sdio_func *func, u32 addr, void *data
, u32 size, u32 access_size)
{
int rv = 0;
struct sqn_sdio_card *sqn_card = sdio_get_drvdata(func);
sqn_pr_enter();
sdio_claim_host(func);
if (is_good_ahb_address(addr, sqn_card->version)
&& 0 == (size % 4) && 4 == access_size)
{
/* write data using AHB */
u8 *data_cp = 0;
#ifdef DEBUG
u8 *read_data = 0;
#endif
sqn_pr_dbg("write data using AHB\n");
sdio_writel(func, addr, SQN_SDIO_ADA_ADDR, &rv);
if (rv) {
sqn_pr_dbg("can't set SQN_SDIO_ADA_ADDR register\n");
goto out;
}
sqn_pr_dbg("after SQN_SDIO_ADA_ADDR\n");
data_cp = kmalloc(size, GFP_KERNEL | GFP_DMA);
memcpy(data_cp, data, size);
rv = sdio_writesb(func, SQN_SDIO_ADA_RDWR, data_cp, size);
if (rv) {
sqn_pr_dbg("can't write to SQN_SDIO_ADA_RDWR register\n");
goto out;
}
kfree(data_cp);
/*
* Workaround when sdio_writesb doesn't work because DMA
* alignment
*/
/*
int i = 0;
for (; i < size/4; ++i) {
sdio_writel(func, *((u32*)data + i), SQN_SDIO_ADA_RDWR, &rv);
if (rv) {
sqn_pr_dbg("can't write to SQN_SDIO_ADA_RDWR register\n");
goto out;
}
}
*/
sqn_pr_dbg("after SQN_SDIO_ADA_RDWR\n");
/* ******** only for debugging ******** */
/* validate written data */
/* #ifdef DEBUG */
#if 0
sqn_pr_dbg("reading data using AHB\n");
sdio_writel(func, addr, SQN_SDIO_ADA_ADDR, &rv);
if (rv) {
sqn_pr_dbg("can't set SQN_SDIO_ADA_ADDR register\n");
goto out;
}
sqn_pr_dbg("after SQN_SDIO_ADA_ADDR\n");
read_data = kmalloc(size, GFP_KERNEL);
rv = sdio_readsb(func, read_data, SQN_SDIO_ADA_RDWR, size);
if (rv) {
sqn_pr_dbg("can't read from SQN_SDIO_ADA_RDWR register\n");
kfree(read_data);
goto out;
}
if (memcmp(data, read_data, size))
sqn_pr_dbg("WARNING: written data are __not__ equal\n");
else
sqn_pr_dbg("OK: written data are equal\n");
kfree(read_data);
#endif /* DEBUG */
/* ******** only for debugging ******** */
} else if (4 == access_size && size >= 4) {
/* write data using CMD53 */
sqn_pr_dbg("write data using CMD53\n");
rv = sdio_memcpy_toio(func, addr, data , size);
} else {
/* write data using CMD52 */
/* not implemented yet, so we use CMD53 */
/* rv = sdio_memcpy_toio(func, addr, data , size); */
int i = 0;
sqn_pr_dbg("write data using CMD52\n");
for (i = 0; i < size; ++i) {
sdio_writeb(func, *((u8*)data + i), addr + i, &rv);
if (rv) {
sqn_pr_dbg("can't write 1 byte to %xh addr using CMD52\n"
, addr + i);
goto out;
}
}
}
out:
sdio_release_host(func);
sqn_pr_leave();
return rv;
}
