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; }