diff -uprN a/DRV/wlan-v10/core/incl/wldebug.h b/DRV/wlan-v10/core/incl/wldebug.h --- a/DRV/wlan-v10/core/incl/wldebug.h 2020-01-16 04:07:34.000000000 -0800 +++ b/DRV/wlan-v10/core/incl/wldebug.h 2020-02-06 06:45:16.000000000 -0800 @@ -406,9 +406,9 @@ void wldbgResetQueueStats(void); * TODO: need BBTX_TMR_TSF is low 32 bit, need HI 32 bit value (No supported on Z1/Z2. Available on SCBT.) */ #ifdef SOC_W906X -#define WLDBG_SET_PKT_TIMESTAMP(x) \ +#define WLDBG_SET_PKT_TIMESTAMP(x, y) \ {\ - x->tstamp.tv64 = (s64)(readl(wlpptr->ioBase1 + BBTX_TMR_TSF));\ + x->tstamp.tv64 = (s64)(wl_util_readl(y, wlpptr->ioBase1 + BBTX_TMR_TSF));\ }\ #else @@ -468,7 +468,7 @@ MACROs for recording RX Fw-To-Drv, Drv a #define WLDBG_PRINT_QUEUE_STATS_RX_LATENCY wldbgPrintPktStats(2) #else -#define WLDBG_SET_PKT_TIMESTAMP(x) +#define WLDBG_SET_PKT_TIMESTAMP(x, y) #define WLDBG_SET_FW_PKT_TIMESTAMP(x, y) #define WLDBG_REC_PKT_DELTA_TIME(x,tm,y,i) #define WLDBG_RX_REC_PKT_FWToDRV_TIME(x,curr_tm) diff -uprN a/DRV/wlan-v10/core/mgt/AP/macmgmtap.c b/DRV/wlan-v10/core/mgt/AP/macmgmtap.c --- a/DRV/wlan-v10/core/mgt/AP/macmgmtap.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/core/mgt/AP/macmgmtap.c 2020-02-06 06:49:16.000000000 -0800 @@ -2575,8 +2575,10 @@ cck_desense_run(struct net_device *netde threshold_ceiling : -r2; wlpptr->cck_des.rx_abort_conf.threshold = threshold; + wl_util_lock(netdev); wlpptr->smacCfgAddr->rssiAbortThres = threshold; wlpptr->smacCfgAddr->rssiAbortEn = 1; + wl_util_unlock(netdev); } } @@ -2590,8 +2592,9 @@ cck_desense_ctrl(struct net_device *netd case CCK_DES_OFF: /* state: Off */ wlFwNewDP_RxSOP(netdev, 4, 0, 0); - + wl_util_lock(netdev); wlpptr->smacCfgAddr->rssiAbortEn = 0; + wl_util_unlock(netdev); wlpptr->cck_des.state &= ~CCK_DES_STATE_ON; break; @@ -2613,10 +2616,12 @@ cck_desense_ctrl(struct net_device *netd } if (wlpptr->cck_des.rx_abort_conf.enable) { + wl_util_lock(netdev); /* Rx abort On */ wlpptr->smacCfgAddr->rssiAbortThres = wlpptr->cck_des.rx_abort_conf.threshold; wlpptr->smacCfgAddr->rssiAbortEn = 1; + wl_util_unlock(netdev); } } diff -uprN a/DRV/wlan-v10/driver/ap8xLnxAcnt.c b/DRV/wlan-v10/driver/ap8xLnxAcnt.c --- a/DRV/wlan-v10/driver/ap8xLnxAcnt.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/ap8xLnxAcnt.c 2020-02-06 21:40:22.000000000 -0800 @@ -199,14 +199,12 @@ wlAcntSetBufSize(struct net_device *netd memTmp[i] = mem; wlpptr->wlpd_p->mmap_ACNTChunk[i].data = mem; } - head = readl(wlpptr->ioBase1 + reg_acnt_head); + head = wl_util_readl(netdev, wlpptr->ioBase1 + reg_acnt_head); if (bAllocFailed) { //back to oldsize - writel(head & (oldSize / ACNT_NCHUNK - 1), - wlpptr->ioBase1 + reg_acnt_tail); - writel(head & (oldSize / ACNT_NCHUNK - 1), - wlpptr->ioBase1 + reg_acnt_head); + wl_util_writel(netdev, head & (oldSize/ACNT_NCHUNK -1), wlpptr->ioBase1 + reg_acnt_tail); + wl_util_writel(netdev, head & (oldSize/ACNT_NCHUNK -1), wlpptr->ioBase1 + reg_acnt_head); for (i = 0; i < ACNT_NCHUNK; i++) { #ifdef SOC_W906X mem = (UINT8 *) wl_dma_alloc_coherent(wlpptr-> @@ -247,10 +245,8 @@ wlAcntSetBufSize(struct net_device *netd SetInfo->ActionType); return 0; } else { - writel(head & (size / ACNT_NCHUNK - 1), - wlpptr->ioBase1 + reg_acnt_tail); - writel(head & (size / ACNT_NCHUNK - 1), - wlpptr->ioBase1 + reg_acnt_head); + wl_util_writel(netdev, head & (size/ACNT_NCHUNK -1), wlpptr->ioBase1 + reg_acnt_tail); + wl_util_writel(netdev, head & (size/ACNT_NCHUNK -1), wlpptr->ioBase1 + reg_acnt_head); wlpptr->wlpd_p->AcntChunkInfo.SizeOfChunk = size / ACNT_NCHUNK; wlpptr->wlpd_p->descData[0].AcntRingSize = size; @@ -1722,7 +1718,7 @@ err_malloc: } #endif tail = head; - writel(tail, priv->ioBase1 + reg_acnt_tail); + wl_util_writel(netdev, tail, priv->ioBase1 + reg_acnt_tail); } #else @@ -1777,7 +1773,7 @@ wlAcntProcess(struct net_device *netdev) skip_process: tail = head; - writel(tail, priv->ioBase1 + MACREG_REG_AcntTail); + wl_util_writel(netdev, tail, priv->ioBase1 + MACREG_REG_AcntTail); /* if ((priv->vmacSta_p->wtp_info.WTP_enabled == FALSE) || (priv->vmacSta_p->wtp_info.mac_mode != WTP_MAC_MODE_SPLITMAC)) { @@ -1822,8 +1818,8 @@ wlAcntPeekRecds(struct net_device *netde unsigned int reg_acnt_tail = MACREG_REG_AcntTail; #endif - *head = readl(wlpptr->ioBase1 + reg_acnt_head); - *tail = readl(wlpptr->ioBase1 + reg_acnt_tail); + *head = wl_util_readl(netdev, wlpptr->ioBase1 + reg_acnt_head); + *tail = wl_util_readl(netdev, wlpptr->ioBase1 + reg_acnt_tail); } void @@ -1843,8 +1839,8 @@ wlAcntReadRecds(struct net_device *netde unsigned int reg_acnt_tail = MACREG_REG_AcntTail; #endif - Head = readl(wlpptr->ioBase1 + reg_acnt_head); - tail = readl(wlpptr->ioBase1 + reg_acnt_tail); + Head = wl_util_readl(netdev, wlpptr->ioBase1 + reg_acnt_head); + tail = wl_util_readl(netdev, wlpptr->ioBase1 + reg_acnt_tail); temSize = Head - tail; //no data or does not move the tail @@ -1866,8 +1862,7 @@ wlAcntReadRecds(struct net_device *netde memcpy(pBuf, &wlpptr->wlpd_p->descData[0].pAcntRing[tail], temBufSize); - writel((tail + temBufSize), - wlpptr->ioBase1 + reg_acnt_tail); + wl_util_writel(netdev, (tail+temBufSize), wlpptr->ioBase1 + reg_acnt_tail); return; } if (temBufSize > Head) { @@ -1875,12 +1870,12 @@ wlAcntReadRecds(struct net_device *netde Head); temBufSize -= Head; *bufSize = temBufSizeOrg - temBufSize; - writel(Head, wlpptr->ioBase1 + reg_acnt_tail); + wl_util_writel(netdev, Head, wlpptr->ioBase1 + reg_acnt_tail); return; } else { memcpy(pBuf, &wlpptr->wlpd_p->descData[0].pAcntRing[0], temBufSize); - writel(temBufSize, wlpptr->ioBase1 + reg_acnt_tail); + wl_util_writel(netdev, temBufSize, wlpptr->ioBase1 + reg_acnt_tail); return; } @@ -1890,15 +1885,13 @@ wlAcntReadRecds(struct net_device *netde &wlpptr->wlpd_p->descData[0].pAcntRing[tail], temSize); *bufSize = temSize; - writel((tail + temSize), - wlpptr->ioBase1 + reg_acnt_tail); + wl_util_writel(netdev, (tail+temSize), wlpptr->ioBase1 + reg_acnt_tail); return; } else { memcpy(pBuf, &wlpptr->wlpd_p->descData[0].pAcntRing[tail], temBufSize); - writel((tail + temBufSize), - wlpptr->ioBase1 + reg_acnt_tail); + wl_util_writel(netdev, (tail+temBufSize), wlpptr->ioBase1 + reg_acnt_tail); return; } } diff -uprN a/DRV/wlan-v10/driver/ap8xLnxApi.c b/DRV/wlan-v10/driver/ap8xLnxApi.c --- a/DRV/wlan-v10/driver/ap8xLnxApi.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/ap8xLnxApi.c 2020-02-06 21:45:56.000000000 -0800 @@ -5374,7 +5374,7 @@ wlioctl_priv_wlparam(struct net_device * rc = -EINVAL; break; } - writel(newtail, priv->ioBase1 + reg_acnt_tail); + wl_util_writel(dev, newtail, priv->ioBase1 + reg_acnt_tail); break; } @@ -19561,6 +19561,7 @@ PwrPerRateGrps: UINT8 i; printk(" MAC CONFIG \n"); + wl_util_lock(netdev); printk("macBmBaseAddr = 0x%X, macBmSize = 0x%X, ddrHighAddr = 0x%X, bpRelQid = %d \n", priv->smacCfgAddr->smacBmBaseAddr, priv->smacCfgAddr->smacBmSize, priv->smacCfgAddr->ddrHighAddr, priv->smacCfgAddr->bpRelQid); printk("bpReqCnt = %d\n", priv->smacCfgAddr->bpReqCnt); @@ -19570,6 +19571,7 @@ PwrPerRateGrps: printk("bpReqInfo size = %d, bpid = %d, qid = %d \n", priv->smacCfgAddr->bpReqInfo[i].size, priv->smacCfgAddr->bpReqInfo[i].bpid, priv->smacCfgAddr->bpReqInfo[i].bpid); } } + wl_util_unlock(netdev); } else if ((strcmp(param[0], "getmacstatus") == 0)) { wl_show_smac_stat(netdev, NULL, NULL); #ifdef DSP_COMMAND @@ -19773,7 +19775,7 @@ PwrPerRateGrps: } } else if ((strcmp(param[0], "bfmee") == 0)) { - + wl_util_lock(netdev); if (strcmp(param[1], "1") == 0) { *(mib->mib_bfmee) = 1; //enable priv->smacCfgAddr->bfControl = 1; @@ -19781,9 +19783,11 @@ PwrPerRateGrps: *(mib->mib_bfmee) = 0; //disable priv->smacCfgAddr->bfControl = 0; } + wl_util_unlock(netdev); printk("\nBFmee is: %s\n", *(mib-> mib_bfmee) ? "enabled" : "disabled"); + } else if ((strcmp(param[0], "beamchange") == 0)) { if (strcmp(param[1], "on") == 0) { diff -uprN a/DRV/wlan-v10/driver/ap8xLnxAR.c b/DRV/wlan-v10/driver/ap8xLnxAR.c --- a/DRV/wlan-v10/driver/ap8xLnxAR.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/ap8xLnxAR.c 2020-02-06 21:29:54.000000000 -0800 @@ -572,14 +572,15 @@ wlTxPPDUAcntHndl(struct net_device *netd U32 usedlen = 0; U16 tid; + wl_util_lock(netdev); wrptr = ptxacntppdu->acntTxBaseAddr_v + (psmac_cfg->acntTxWrPtr - ptxacntppdu->acntTxBaseAddr_p); - + if (txacnt_idmsg > 0) { printk("[TXACNT] ++++++++++++++++++++++++++++++++++++++++++++++++++++\n"); printk("[TXACNT] =>%s(), (base, rdptr, wrptr)=(%x, %x, %x) (%p, %p)\n", __func__, psmac_cfg->acntTxBaseAddr, psmac_cfg->acntTxRdPtr, psmac_cfg->acntTxWrPtr, ptxacntppdu->acntTxRdPtr_v, wrptr); } - + wl_util_unlock(netdev); while (ptxacntppdu->acntTxRdPtr_v != wrptr) { SMAC_ACNT_TX_PPDU_INFO_st *ptxppdu_info; SMAC_ACNT_TX_PPDU_HDR_st *ptxppdu_hdr; @@ -588,9 +589,11 @@ wlTxPPDUAcntHndl(struct net_device *netd if ((*(U32 *) ptxacntppdu->acntTxRdPtr_v) == PPDUACNT_END) { // The rest of the buffer is insufficient for next tx ppdu record => wr-ptr is resette if (txacnt_msg > 0) { + wl_util_lock(netdev); printk("=> Get %x, at (%p, %x) reset rdptr\n", PPDUACNT_END, ptxacntppdu->acntTxRdPtr_v, psmac_cfg->acntTxRdPtr); + wl_util_unlock(netdev); } wlMoveAcntTxRdptr(ptxacntppdu, RESET_ACNTRDPTR); @@ -937,8 +940,10 @@ wlTxPPDUAcntHndl(struct net_device *netd } if (txacnt_idmsg > 0) { + wl_util_lock(netdev); printk("[TXACNT] <=%s(), (rd_v, wr_v)=(%p, %p), (rd_p, wr_p)=(%x, %x)\n", __func__, ptxacntppdu->acntTxRdPtr_v, wrptr, psmac_cfg->acntTxRdPtr, psmac_cfg->acntTxWrPtr); printk("[TXACNT] ----------------------------------------------------\n\n"); + wl_util_unlock(netdev); txacnt_idmsg--; } return; @@ -1000,7 +1005,10 @@ wlRxPPDUAcntHndl(struct net_device *netd U32 usedlen = 0; U16 tid; U8 *bgn_rdpt = prxacntppdu->acntRxRdPtr_v; + + wl_util_lock(netdev); memcpy(&lsmac_cfg, psmac_cfg, sizeof(SMAC_CONFIG_st)); + wl_util_unlock(netdev); wrptr = prxacntppdu->acntRxBaseAddr_v + (psmac_cfg->acntRxWrPtr - prxacntppdu->acntRxBaseAddr_p); @@ -1014,7 +1022,9 @@ wlRxPPDUAcntHndl(struct net_device *netd if (rxacnt_idmsg > 0) { printk("[RXACNT] ++++++++++++++++++++++++++++++++++++++++++++++++++++\n"); + wl_util_lock(netdev); printk("[RXACNT] =>%s(), (base, rdptr, wrptr)=(%x, %x, %x) (%p, %p)\n", __func__, psmac_cfg->acntRxBaseAddr, psmac_cfg->acntRxRdPtr, psmac_cfg->acntRxWrPtr, prxacntppdu->acntRxRdPtr_v, wrptr); + wl_util_unlock(netdev); printk("[RXACNT] => lsmac: %x, %x\n", lsmac_cfg.acntRxRdPtr, lsmac_cfg.acntRxWrPtr); } @@ -1023,9 +1033,11 @@ wlRxPPDUAcntHndl(struct net_device *netd if ((*(U32 *) prxacntppdu->acntRxRdPtr_v) == PPDUACNT_END) { // The rest of the buffer is insufficient for next tx ppdu record => wr-ptr is resette if (rxacnt_idmsg > 0) { + wl_util_lock(netdev); printk("=> Get %x, at (%p, %x) reset rdptr\n", PPDUACNT_END, prxacntppdu->acntRxRdPtr_v, psmac_cfg->acntRxRdPtr); + wl_util_unlock(netdev); } wlMoveAcntRxRdptr(prxacntppdu, RESET_ACNTRDPTR); diff -uprN a/DRV/wlan-v10/driver/ap8xLnxFwcmd.c b/DRV/wlan-v10/driver/ap8xLnxFwcmd.c --- a/DRV/wlan-v10/driver/ap8xLnxFwcmd.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/ap8xLnxFwcmd.c 2020-02-06 22:11:26.000000000 -0800 @@ -144,7 +144,9 @@ SMAC_RX_ENABLE(struct wlprivate *wlpptr, { if (macId != 0xffffffff) *(mib->mib_rx_enable) |= (1 << macId); - *(u32 *) (&((SMAC_CTRL_BLK_st *) wlpptr->ioBase0)->config.rxEnable) = 1; + wl_util_lock(wlpptr->netDev); + *(u32*)(&((SMAC_CTRL_BLK_st*)wlpptr->ioBase0)->config.rxEnable) = 1; + wl_util_unlock(wlpptr->netDev); } static void @@ -154,12 +156,15 @@ SMAC_RX_DISABLE(struct wlprivate *wlpptr if (macId != 0xffffffff) *(mib->mib_rx_enable) &= ~(1 << macId); + wl_util_lock(wlpptr->netDev); if (mib && (*(mib->mib_rx_enable) == 0) && (*(u32 *) (&((SMAC_CTRL_BLK_st *) wlpptr->ioBase0)->config.opMode) == 0)) { *(u32 *) (&((SMAC_CTRL_BLK_st *) wlpptr->ioBase0)->config. rxEnable) = 0; } + + wl_util_unlock(wlpptr->netDev); } #endif /* #ifdef SOC_W906X */ @@ -5755,13 +5760,11 @@ wlsendCommand(struct net_device *netdev) unsigned int reg_gen_ptr = wlpptr->wlpd_p->reg.gen_ptr; unsigned int reg_h2a_int_events = wlpptr->wlpd_p->reg.h2a_int_events; - writel(wlpptr->wlpd_p->pPhysCmdBuf, wlpptr->ioBase1 + reg_gen_ptr); - writel(MACREG_H2ARIC_BIT_DOOR_BELL, - wlpptr->ioBase1 + reg_h2a_int_events); -#else - writel(wlpptr->wlpd_p->pPhysCmdBuf, - wlpptr->ioBase1 + MACREG_REG_GEN_PTR); - writel(MACREG_H2ARIC_BIT_DOOR_BELL, + wl_util_writel(netdev, wlpptr->wlpd_p->pPhysCmdBuf, wlpptr->ioBase1 + reg_gen_ptr); + wl_util_writel(netdev, MACREG_H2ARIC_BIT_DOOR_BELL, wlpptr->ioBase1 + reg_h2a_int_events); +#else + wl_util_writel(netdev, wlpptr->wlpd_p->pPhysCmdBuf, wlpptr->ioBase1+MACREG_REG_GEN_PTR); + wl_util_writel(netdev, MACREG_H2ARIC_BIT_DOOR_BELL, wlpptr->ioBase1 + MACREG_REG_H2A_INTERRUPT_EVENTS); #endif /* #ifdef SOC_W906X */ } @@ -10905,11 +10908,11 @@ PrintTxHisto(struct net_device *netdev, MWL_SPIN_LOCK(&wlpptr->wlpd_p->locks.fwLock); #ifdef SOC_W906X - offchReqHead = readl(wlpptr->ioBase1 + reg_offchreq_head); - offchReqTail = readl(wlpptr->ioBase1 + reg_offchreq_tail); + offchReqHead = wl_util_readl(netdev, wlpptr->ioBase1 + reg_offchreq_head); + offchReqTail = wl_util_readl(netdev, wlpptr->ioBase1 + reg_offchreq_tail); #else - offchReqHead = readl(wlpptr->ioBase1 + MACREG_REG_OffchReqHead); - offchReqTail = readl(wlpptr->ioBase1 + MACREG_REG_OffchReqTail); + offchReqHead = wl_util_readl(netdev, wlpptr->ioBase1 + MACREG_REG_OffchReqHead); + offchReqTail = wl_util_readl(netdev, wlpptr->ioBase1 + MACREG_REG_OffchReqTail); #endif nextOff = offchReqHead * sizeof(offchan_desc_t); pOffChDesc = @@ -11020,9 +11023,9 @@ PrintTxHisto(struct net_device *netdev, else offchReqHead++; #ifdef SOC_W906X - writel(offchReqHead, wlpptr->ioBase1 + reg_offchreq_head); + wl_util_writel(netdev, offchReqHead, wlpptr->ioBase1 + reg_offchreq_head); #else - writel(offchReqHead, wlpptr->ioBase1 + MACREG_REG_OffchReqHead); + wl_util_writel(netdev, offchReqHead, wlpptr->ioBase1 + MACREG_REG_OffchReqHead); #endif MWL_SPIN_UNLOCK(&wlpptr->wlpd_p->locks.fwLock); @@ -11436,17 +11439,20 @@ OFFCHAN_PROCESS_FAIL: if (op_mode != SMAC_OPMODE_NORMAL) { U32 regval; + wl_util_lock(netdev); op_mode |= SMAC_OPMODE_FCS_ERR_PASS; *(u32 *) (&((SMAC_CTRL_BLK_st *) wlpptr->ioBase0)-> config.opMode) = op_mode; + wl_util_unlock(netdev); SMAC_RX_ENABLE(wlpptr, mib, 0xFFFFFFFF); - regval = readl(wlpptr->ioBase1 + BBRX_CFG); + regval = wl_util_readl(netdev, wlpptr->ioBase1 + BBRX_CFG); if ((regval & 0x01) == 0) - writel((regval | 0x01), - wlpptr->ioBase1 + BBRX_CFG); + wl_util_writel(netdev, (regval | 0x01), wlpptr->ioBase1 + BBRX_CFG); } else { + wl_util_lock(netdev); *(u32 *) (&((SMAC_CTRL_BLK_st *) wlpptr->ioBase0)-> config.opMode) = op_mode; + wl_util_unlock(netdev); SMAC_RX_DISABLE(wlpptr, mib, 0xFFFFFFFF); } #else @@ -13171,8 +13177,10 @@ exit: memcpy(&pCmd->TlvData, tlvData, len); #ifdef PRD_CSI_DMA if (type == 12) { + wl_util_lock(netdev); wlpptr->smacCfgAddr->prd_csi_dma_ddr_addr = (UINT32) wlpptr->wlpd_p->pPhysSsuBuf; + wl_util_unlock(netdev); } #endif retval = wlexecuteCommand(netdev, diff -uprN a/DRV/wlan-v10/driver/ap8xLnxFwdl.c b/DRV/wlan-v10/driver/ap8xLnxFwdl.c --- a/DRV/wlan-v10/driver/ap8xLnxFwdl.c 2020-01-16 04:07:32.000000000 -0800 +++ b/DRV/wlan-v10/driver/ap8xLnxFwdl.c 2020-02-06 22:23:27.000000000 -0800 @@ -74,10 +74,10 @@ fw_chunk_transfer(struct net_device *net unsigned int reg_gen_ptr = wlpptr->wlpd_p->reg.gen_ptr; /* write location of data */ - writel(wlpptr->wlpd_p->pPhysFwDlBuf, wlpptr->ioBase1 + reg_gen_ptr); + wl_util_writel(netdev, wlpptr->wlpd_p->pPhysFwDlBuf, wlpptr->ioBase1 + reg_gen_ptr); /* inform bootcode */ - writel(MACREG_H2ARIC_BIT_DOOR_BELL, wlpptr->ioBase1 + reg_event_offset); + wl_util_writel(netdev, MACREG_H2ARIC_BIT_DOOR_BELL, wlpptr->ioBase1 + reg_event_offset); } static inline void @@ -91,11 +91,10 @@ fw_setup_intr(struct wlprivate *wlpptr) unsigned int reg_a2h_status_mask = wlpptr->wlpd_p->reg.a2h_int_status_mask; - writel(MACREG_A2HRIC_BIT_MASK, - wlpptr->ioBase1 + reg_a2h_intr_clear_sel); - writel(0x00, wlpptr->ioBase1 + reg_a2h_intr_cause); - writel(0x00, wlpptr->ioBase1 + reg_a2h_intr_mask); - writel(trigger, wlpptr->ioBase1 + reg_a2h_status_mask); + wl_util_writel(wlpptr->netDev, MACREG_A2HRIC_BIT_MASK, wlpptr->ioBase1 + reg_a2h_intr_clear_sel); + wl_util_writel(wlpptr->netDev, 0x00, wlpptr->ioBase1 + reg_a2h_intr_cause); + wl_util_writel(wlpptr->netDev, 0x00, wlpptr->ioBase1 + reg_a2h_intr_mask); + wl_util_writel(wlpptr->netDev, trigger, wlpptr->ioBase1 + reg_a2h_status_mask); } #endif /* #ifdef SOC_W906X */ @@ -205,12 +204,10 @@ wlFwDownload(struct net_device *netdev) //FW before jumping to boot rom, it will enable PCIe transaction retry, wait for boot code to stop it. WL_MSEC_SLEEP(FW_CHECK_MSECS); - writel(MACREG_A2HRIC_BIT_MASK_MSI, - wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_CLEAR_SEL); - writel(0x00, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_CAUSE); - writel(0x00, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); - writel(MACREG_A2HRIC_BIT_MASK_MSI, - wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_STATUS_MASK); + wl_util_writel(netdev, MACREG_A2HRIC_BIT_MASK_MSI, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_CLEAR_SEL); + wl_util_writel(netdev, 0x00, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_CAUSE); + wl_util_writel(netdev, 0x00, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); + wl_util_writel(netdev, MACREG_A2HRIC_BIT_MASK_MSI, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_STATUS_MASK); /** SC3 MFG FW no longer use this signature if (wlpptr->mfgEnable) @@ -240,26 +237,26 @@ wlFwDownload(struct net_device *netdev) /* len should not be zero. The first len is 0x10 */ /* make sure SCRATCH2 C40 is clear, in case we are too quick */ - while (readl(wlpptr->ioBase1 + reg_len_offset) == 0) ; + while (wl_util_readl(netdev, wlpptr->ioBase1 + reg_len_offset) == 0) ; while (sizeFwDownloaded < wlpptr->FwSize) { - len = readl(wlpptr->ioBase1 + reg_len_offset); + len = wl_util_readl(netdev, wlpptr->ioBase1 + reg_len_offset); if (len > FW_MAX_CHUNK_LEN) { printk("bad len: 0x%x !!", len); return FAIL; } #else /* Disable PFU before FWDL */ - writel(0x100, wlpptr->ioBase1 + 0xE0E4); + wl_util_writel(netdev, 0x100,wlpptr->ioBase1+0xE0E4); /* make sure SCRATCH2 C40 is clear, in case we are too quick */ - while (readl(wlpptr->ioBase1 + 0xc40) == 0) ; + while (wl_util_readl(netdev, wlpptr->ioBase1 + 0xc40) == 0); #ifdef NEW_DP /* download ddr init code */ printk("init ddr...\n"); while (sizeDdrInitDownloaded < sizeDdrInit) { - len = readl(wlpptr->ioBase1 + 0xc40); + len = wl_util_readl(netdev, wlpptr->ioBase1 + 0xc40); if (!len) break; @@ -276,7 +273,7 @@ wlFwDownload(struct net_device *netdev) has to consider how efficient your code can be to meet this timing, or you can alternatively tweak this routines to fit your platform */ do { - intCode = readl(wlpptr->ioBase1 + 0xc1c); + intCode = wl_util_readl(netdev, wlpptr->ioBase1 + 0xc1c); if (intCode != 0) break; currIteration--; @@ -284,7 +281,7 @@ wlFwDownload(struct net_device *netdev) } while (currIteration); do { - intCode = readl(wlpptr->ioBase1 + 0xc1c); + intCode = wl_util_readl(netdev, wlpptr->ioBase1 + 0xc1c); if ((intCode & MACREG_H2ARIC_BIT_DOOR_BELL) != MACREG_H2ARIC_BIT_DOOR_BELL) break; @@ -303,7 +300,7 @@ wlFwDownload(struct net_device *netdev) } #endif while (sizeFwDownloaded < wlpptr->FwSize) { - len = readl(wlpptr->ioBase1 + 0xc40); + len = wl_util_readl(netdev, wlpptr->ioBase1 + 0xc40); #ifdef SOC_W8964 if (len > 512) { printk("bad len: 0x%x !!", len); @@ -337,14 +334,14 @@ wlFwDownload(struct net_device *netdev) has to consider how efficient your code can be to meet this timing, or you can alternatively tweak this routines to fit your platform */ do { - intCode = readl(wlpptr->ioBase1 + reg_cause_offset); + intCode = wl_util_readl(netdev, wlpptr->ioBase1 + reg_cause_offset); if (intCode != 0) break; currIteration--; } while (currIteration); do { - intCode = readl(wlpptr->ioBase1 + reg_cause_offset); + intCode = wl_util_readl(netdev, wlpptr->ioBase1 + reg_cause_offset); if ((intCode & MACREG_H2ARIC_BIT_DOOR_BELL) != MACREG_H2ARIC_BIT_DOOR_BELL) break; @@ -402,7 +399,7 @@ wlFwDownload(struct net_device *netdev) do { currIteration--; - writel(OpMode, wlpptr->ioBase1 + reg_gen_ptr); + wl_util_writel(netdev, OpMode, wlpptr->ioBase1 + reg_gen_ptr); #ifdef SOC_W906X if (IS_BUS_TYPE_MCI(wlpptr)) mdelay(FW_CHECK_MSECS); @@ -410,7 +407,7 @@ wlFwDownload(struct net_device *netdev) #endif WL_MSEC_SLEEP(FW_CHECK_MSECS); - intCode = readl(wlpptr->ioBase1 + reg_int_code); + intCode = wl_util_readl(netdev, wlpptr->ioBase1 + reg_int_code); #ifndef SOC_W906X if (!(currIteration % 0xff)) printk("%x;", intCode); @@ -436,13 +433,13 @@ wlFwDownload(struct net_device *netdev) complete: #ifdef SOC_W906X printk("wlFwDownload complete\nFwDownload time = %u us\nRadio Cal time = %u us\n", (u32) (tick2 - tick1), (u32) (tick4 - tick3)); - writel(wlpptr->wlpd_p->pPhysCmdBuf, wlpptr->ioBase1 + reg_gen_ptr); + wl_util_writel(netdev, wlpptr->wlpd_p->pPhysCmdBuf, wlpptr->ioBase1 + reg_gen_ptr); wlpd_p->downloadSuccessful = TRUE; #else printk("wlFwDownload complete\n"); #endif /* #ifdef SOC_W906X */ - writel(0x00, wlpptr->ioBase1 + reg_int_code); + wl_util_writel(netdev, 0x00, wlpptr->ioBase1 + reg_int_code); WLDBG_EXIT(DBG_LEVEL_3); return SUCCESS; } @@ -454,13 +451,11 @@ wltriggerPciCmd(struct net_device *netde { struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, netdev); - writel(wlpptr->wlpd_p->pPhysCmdBuf, - wlpptr->ioBase1 + MACREG_REG_GEN_PTR); + wl_util_writel(netdev, wlpptr->wlpd_p->pPhysCmdBuf, wlpptr->ioBase1 + MACREG_REG_GEN_PTR); - writel(0x00, wlpptr->ioBase1 + MACREG_REG_INT_CODE); + wl_util_writel(netdev, 0x00, wlpptr->ioBase1 + MACREG_REG_INT_CODE); - writel(MACREG_H2ARIC_BIT_DOOR_BELL, - wlpptr->ioBase1 + MACREG_REG_H2A_INTERRUPT_EVENTS); + wl_util_writel(netdev, MACREG_H2ARIC_BIT_DOOR_BELL, wlpptr->ioBase1 + MACREG_REG_H2A_INTERRUPT_EVENTS); } #endif /* #ifndef SOC_W906X */ @@ -471,16 +466,13 @@ wltriggerPciCmd_bootcode(struct net_devi #ifdef SOC_W906X /* write location of data to c10 */ - writel(wlpptr->wlpd_p->pPhysFwDlBuf, - wlpptr->ioBase1 + MACREG_REG_GEN_PTR); + wl_util_writel(netdev, wlpptr->wlpd_p->pPhysFwDlBuf, wlpptr->ioBase1 + MACREG_REG_GEN_PTR); #else /* write location of data to c10 */ - writel(wlpptr->wlpd_p->pPhysCmdBuf, - wlpptr->ioBase1 + MACREG_REG_GEN_PTR); + wl_util_writel(netdev, wlpptr->wlpd_p->pPhysCmdBuf, wlpptr->ioBase1 + MACREG_REG_GEN_PTR); #endif /* write 2 to c18 */ - writel(MACREG_H2ARIC_BIT_DOOR_BELL, - wlpptr->ioBase1 + MACREG_REG_H2A_INTERRUPT_EVENTS); + wl_util_writel(netdev, MACREG_H2ARIC_BIT_DOOR_BELL, wlpptr->ioBase1 + MACREG_REG_H2A_INTERRUPT_EVENTS); } extern int LoadExternalFw(struct wlprivate *priv, char *filename); diff -uprN a/DRV/wlan-v10/driver/ap8xLnxIntf.c b/DRV/wlan-v10/driver/ap8xLnxIntf.c --- a/DRV/wlan-v10/driver/ap8xLnxIntf.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/ap8xLnxIntf.c 2020-02-06 23:59:47.000000000 -0800 @@ -308,6 +308,19 @@ module_param(protect_rx_rate_thres, int, MODULE_PARM_DESC(protect_rx_rate_thres, "Rx rate threshold for protection check"); +int rddelay = 0; +module_param(rddelay, int, S_IRUGO); +MODULE_PARM_DESC(rddelay, "read delay"); + +int wrdelay = 0; +module_param(wrdelay, int, S_IRUGO); +MODULE_PARM_DESC(wrdelay, "write delay"); + +int intmode = 0; +module_param(intmode, int, S_IRUGO); +MODULE_PARM_DESC(intmode, "interrupt mode, 0: MSI-X, 1: MSI, 2: Legacy"); + + int txq_per_sta_timeout = 0; //0: disable >0: timeout (us) module_param(txq_per_sta_timeout, int, 0644); MODULE_PARM_DESC(txq_per_sta_timeout, @@ -1545,38 +1558,38 @@ wl_init_intr(struct wlprivate *wlpptr) /* PCIe MSIX Mode using New GIC mode: */ //0x38 - writel(SC5_PCIE_MODE_GIC, + wl_util_writel(wlpptr->netDev, SC5_PCIE_MODE_GIC, wlpptr->ioBase1 + SC5_REG_PCIE_INTR_MODE_SEL); //0x30 - writel(SMAC_CTRLBASE_NSS_PCIE_HI_VAL_NOINTR, + wl_util_writel(wlpptr->netDev, SMAC_CTRLBASE_NSS_PCIE_HI_VAL_NOINTR, wlpptr->ioBase1 + SC5_REG_SMAC_CTRLBASE_NSS_PCIE_HI); - writel(PCI_REG_DOORBELL_ADDR, + wl_util_writel(wlpptr->netDev, PCI_REG_DOORBELL_ADDR, wlpptr->ioBase1 + SC5_REG_FRAME_0); - writel(PCI_REG_DOORBELL_ADDR, + wl_util_writel(wlpptr->netDev, PCI_REG_DOORBELL_ADDR, wlpptr->ioBase1 + SC5_REG_FRAME_1); - writel(PCI_REG_DOORBELL_ADDR, + wl_util_writel(wlpptr->netDev, PCI_REG_DOORBELL_ADDR, wlpptr->ioBase1 + SC5_REG_FRAME_2); - writel(PCI_REG_DOORBELL_ADDR, + wl_util_writel(wlpptr->netDev, PCI_REG_DOORBELL_ADDR, wlpptr->ioBase1 + SC5_REG_FRAME_3); } else if (wlpptr->intr_type == PCI_INTR_TYPE_MSI) { wlpptr->num_vectors = 0; /* PCIe MSI Mode using New GIC mode: */ //0x38 - writel(SC5_PCIE_MODE_GIC, + wl_util_writel(wlpptr->netDev, SC5_PCIE_MODE_GIC, wlpptr->ioBase1 + SC5_REG_PCIE_INTR_MODE_SEL); //0x30 - writel(SMAC_CTRLBASE_NSS_PCIE_HI_VAL_NOINTR, + wl_util_writel(wlpptr->netDev, SMAC_CTRLBASE_NSS_PCIE_HI_VAL_NOINTR, wlpptr->ioBase1 + SC5_REG_SMAC_CTRLBASE_NSS_PCIE_HI); - writel(PCI_REG_HOST_ITR_ADDR, + wl_util_writel(wlpptr->netDev, PCI_REG_HOST_ITR_ADDR, wlpptr->ioBase1 + SC5_REG_FRAME_0); - writel(PCI_REG_HOST_ITR_ADDR, + wl_util_writel(wlpptr->netDev, PCI_REG_HOST_ITR_ADDR, wlpptr->ioBase1 + SC5_REG_FRAME_1); - writel(PCI_REG_HOST_ITR_ADDR, + wl_util_writel(wlpptr->netDev, PCI_REG_HOST_ITR_ADDR, wlpptr->ioBase1 + SC5_REG_FRAME_2); - writel(PCI_REG_HOST_ITR_ADDR, + wl_util_writel(wlpptr->netDev, PCI_REG_HOST_ITR_ADDR, wlpptr->ioBase1 + SC5_REG_FRAME_3); } return; @@ -1590,25 +1603,25 @@ wl_init_intr(struct wlprivate *wlpptr) wlpptr->wlpd_p->sysintr_frm.spi_num); // ++++++++ // Fill base address of frame_x - writel(wlpptr->wlpd_p->sysintr_frm.frm_base, + wl_util_writel(wlpptr->netDev, wlpptr->wlpd_p->sysintr_frm.frm_base, wlpptr->ioBase1 + SC5_REG_FRAME_0); WLDBG_INFO(DBG_LEVEL_0, "=> %s(), W906x_REG_FRAME_0, w_reg(ioBase1+%xh) = %xh\n", __func__, SC5_REG_FRAME_0, wlpptr->wlpd_p->sysintr_frm.frm_base); - writel(wlpptr->wlpd_p->sysintr_frm.frm_base, + wl_util_writel(wlpptr->netDev, wlpptr->wlpd_p->sysintr_frm.frm_base, wlpptr->ioBase1 + SC5_REG_FRAME_1); WLDBG_INFO(DBG_LEVEL_0, "=> %s(), W906x_REG_FRAME_1, w_reg(ioBase1+%xh) = %xh\n", __func__, SC5_REG_FRAME_1, wlpptr->wlpd_p->sysintr_frm.frm_base); - writel(wlpptr->wlpd_p->sysintr_frm.frm_base, + wl_util_writel(wlpptr->netDev, wlpptr->wlpd_p->sysintr_frm.frm_base, wlpptr->ioBase1 + SC5_REG_FRAME_2); WLDBG_INFO(DBG_LEVEL_0, "=> %s(), W906x_REG_FRAME_2, w_reg(ioBase1+%xh) = %xh\n", __func__, SC5_REG_FRAME_2, wlpptr->wlpd_p->sysintr_frm.frm_base); - writel(wlpptr->wlpd_p->sysintr_frm.frm_base, + wl_util_writel(wlpptr->netDev, wlpptr->wlpd_p->sysintr_frm.frm_base, wlpptr->ioBase1 + SC5_REG_FRAME_3); WLDBG_INFO(DBG_LEVEL_0, "=> %s(), W906x_REG_FRAME_3, w_reg(ioBase1+%xh) = %xh\n", @@ -1618,12 +1631,12 @@ wl_init_intr(struct wlprivate *wlpptr) // HW PCIE-MSIX setting // => #1, set intr mode selected - writel(SC5_PCIE_MODE_GIC, + wl_util_writel(wlpptr->netDev, SC5_PCIE_MODE_GIC, wlpptr->ioBase1 + SC5_REG_PCIE_INTR_MODE_SEL); printk("=> %s(),w_reg(ioBase1+%xh) = %xh\n", __func__, SC5_REG_PCIE_INTR_MODE_SEL, SC5_PCIE_MODE_GIC); // set hframe register base - writel(wlpptr->hframe_phy_addr, + wl_util_writel(wlpptr->netDev, wlpptr->hframe_phy_addr, wlpptr->ioBase1 + SC5_REG_HFRAME_BASE); printk("=> %s(),w_reg(ioBase1+%xh) = %llxh\n", __func__, SC5_REG_HFRAME_BASE, @@ -1631,26 +1644,26 @@ wl_init_intr(struct wlprivate *wlpptr) // => #2, set ncc pcie val (Using interrupt mode or not) regval = wlpptr->wlpd_p->reg.smac_ctrlbase_nss_hi_val_intr; - writel(regval, + wl_util_writel(wlpptr->netDev, regval, wlpptr->ioBase1 + SC5_REG_SMAC_CTRLBASE_NSS_PCIE_HI); printk("=> %s(),w_reg(ioBase1+%xh) = %xh\n", __func__, SC5_REG_SMAC_CTRLBASE_NSS_PCIE_HI, regval); // => #3, set pcie msi address - writel(wlpptr->wlpd_p->sysintr_frm.frm_base, + wl_util_writel(wlpptr->netDev, wlpptr->wlpd_p->sysintr_frm.frm_base, wlpptr->ioBase1 + SC5_REG_PCIE_MSI_ADDR); printk("=> %s(),w_reg(ioBase1+%xh) = %xh\n", __func__, SC5_REG_PCIE_MSI_ADDR, wlpptr->wlpd_p->sysintr_frm.frm_base); // => #4, Set SC5_REG_PCIE_MSIX_DATA - writel(wlpptr->wlpd_p->sysintr_frm.spi_num, + wl_util_writel(wlpptr->netDev, wlpptr->wlpd_p->sysintr_frm.spi_num, wlpptr->ioBase1 + SC5_REG_PCIE_MSIX_DATA); printk("=> %s(),w_reg(ioBase1+%xh) = %xh\n", __func__, SC5_REG_PCIE_MSIX_DATA, wlpptr->wlpd_p->sysintr_frm.spi_num); - writel(wlpptr->hframe_phy_addr, + wl_util_writel(wlpptr->netDev, wlpptr->hframe_phy_addr, wlpptr->ioBase1 + SC5_REG_BASE_ADDR_HOST_128B); printk("===> w_reg(ioBase1+%xh) = %llxh\n", SC5_REG_BASE_ADDR_HOST_128B, @@ -1732,14 +1745,8 @@ wl_hook_intr(struct wlprivate *wlpptr) } else continue; - writel(0, - wlpptr->ioBase1 + SC5_REG_FRM_SEL(qid, - ((int)(issq) & - 0x1))); - writel(BIT(idx), - wlpptr->ioBase1 + SC5_REG_EFF_ID(qid, - ((int)(issq) & - 0x1))); + wl_util_writel(wlpptr->netDev, 0, wlpptr->ioBase1 + SC5_REG_FRM_SEL(qid, ((int)(issq)&0x1))); + wl_util_writel(wlpptr->netDev, BIT(idx), wlpptr->ioBase1 + SC5_REG_EFF_ID(qid, ((int)(issq)&0x1))); } if (request_irq(wlpptr->netDev->irq, wlISR, IRQF_SHARED, @@ -2161,7 +2168,7 @@ wlprobe_mci(struct platform_device *pdev } /* Set hframe register base */ - writel(wlpptr->hframe_phy_addr, wlpptr->ioBase1 + SC5_REG_HFRAME_BASE); + wl_util_writel(wlpptr->netDev, wlpptr->hframe_phy_addr, wlpptr->ioBase1 + SC5_REG_HFRAME_BASE); dev_info(&pdev->dev, "hframe base addr %llx \n", (long long unsigned int)wlpptr->hframe_phy_addr); @@ -2205,13 +2212,13 @@ intr_sel_frm_effid(struct wlprivate *wlp // Note: Always using frame_0, unless we need different frames // Driver sets the same addres to fm_0 ~ fm_3 now // ref: wl_init_intr() - writel(0, wlpptr->ioBase1 + SC5_REG_FRM_SEL(qid, ((int)(issq) & 0x1))); - WLDBG_INFO(DBG_LEVEL_0, "[FRM_SEL] writel(ioBase1+%xh) = %xh\n", + wl_util_writel(wlpptr->netDev, 0, wlpptr->ioBase1 + SC5_REG_FRM_SEL(qid, ((int)(issq)&0x1))); + WLDBG_INFO(DBG_LEVEL_0, "[FRM_SEL] wl_util_writel(ioBase1+%xh) = %xh\n", SC5_REG_FRM_SEL(qid, ((int)(issq) & 0x1)), 0); // Set the interrupt - writel(intr_id + wlpptr->wlpd_p->sysintr_frm.spi_num, + wl_util_writel(wlpptr->netDev, intr_id+wlpptr->wlpd_p->sysintr_frm.spi_num, wlpptr->ioBase1 + SC5_REG_EFF_ID(qid, ((int)(issq) & 0x1))); - WLDBG_INFO(DBG_LEVEL_0, "[EFF_ID] writel(ioBase1+%xh) = %xh\n", + WLDBG_INFO(DBG_LEVEL_0, "[EFF_ID] wl_util_writel(ioBase1+%xh) = %xh\n", SC5_REG_EFF_ID(qid, ((int)(issq) & 0x1)), intr_id + wlpptr->wlpd_p->sysintr_frm.spi_num); return; @@ -2869,7 +2876,7 @@ here: wlprobe_set_reg_value(wlpptr); wlprobe_set_intr_info(wlpptr); - if (pci_find_capability(pdev, PCI_CAP_ID_MSIX)) { + if (!intmode && pci_find_capability(pdev, PCI_CAP_ID_MSIX)) { int msi_err = 0; wlpptr->intr_type = INTR_TYPE_MSIX; @@ -2919,7 +2926,7 @@ try_msi: wlpptr->intr_type = PCI_INTR_TYPE_MSI; wl_init_intr(wlpptr); - if ((msi_err = pci_enable_msi(pdev)) == 0) { + if ((intmode == 1) && (msi_err = pci_enable_msi(pdev)) == 0) { wlpptr->netDev->irq = pdev->irq; dev_info(&pdev->dev, "MSI Enabled with vector=%d\n", pdev->irq); @@ -3651,10 +3658,10 @@ mfg_send_cmd(struct net_device *netdev) struct cmd_header *cmd_hdr = (struct cmd_header *)&wlpptr->pCmdBuf[2]; u16 len = le16_to_cpu(cmd_hdr->len); - writel(wlpptr->wlpd_p->pPhysCmdBuf, wlpptr->ioBase1 + 0xcd0); - writel(0x00, wlpptr->ioBase1 + 0xcd4); - writel(0x00, wlpptr->ioBase1 + MACREG_REG_INT_CODE); - writel(len + 4, wlpptr->ioBase1 + 0xc40); + wl_util_writel(netdev, wlpptr->wlpd_p->pPhysCmdBuf, wlpptr->ioBase1 + 0xcd0); + wl_util_writel(netdev, 0x00, wlpptr->ioBase1 + 0xcd4); + wl_util_writel(netdev, 0x00, wlpptr->ioBase1 + MACREG_REG_INT_CODE); + wl_util_writel(netdev, len + 4, wlpptr->ioBase1 + 0xc40); #endif #if 0 //For MOCHI writel(wlpptr->wlpd_p->pPhysCmdBuf, @@ -3662,9 +3669,9 @@ mfg_send_cmd(struct net_device *netdev) writel(MACREG_H2ARIC_BIT_DOOR_BELL, wlpptr->ioBase1 + MACREG_REG_H2A_INTERRUPT_EVENTS_MCI); #else //For Auto check (PCIe or Mochi) reference from function wlprobe_set_reg_value(struct wlprivate *wlpptr) - writel(wlpptr->wlpd_p->pPhysCmdBuf, + wl_util_writel(netdev, wlpptr->wlpd_p->pPhysCmdBuf, wlpptr->ioBase1 + wlpptr->wlpd_p->reg.gen_ptr); - writel(MACREG_H2ARIC_BIT_DOOR_BELL, + wl_util_writel(netdev, MACREG_H2ARIC_BIT_DOOR_BELL, wlpptr->ioBase1 + wlpptr->wlpd_p->reg.h2a_int_events); #endif } @@ -3887,6 +3894,7 @@ wlInit(struct net_device *netdev, u_int1 WLDBG_ENTER(DBG_LEVEL_2); + spin_lock_init(&wlpptr->wlpd_p->pcie_iolock); smeCmdBuf_q = (macmgmtQ_CmdBuf_t *) wl_vzalloc(sizeof(macmgmtQ_CmdBuf_t) * SME_CMD_BUF_Q_LIMIT); @@ -4158,13 +4166,13 @@ wlInit(struct net_device *netdev, u_int1 if (SMAC_HAL_VERSION >= 0x0080) { printk("=> %s(), MAC_CONFIG_st->magic = %xh\n", __func__, SMAC_HAL_VERSION); - writel(SMAC_HAL_VERSION, &wlpptr->smacCfgAddr->magic); + wl_util_writel(netdev, SMAC_HAL_VERSION, &wlpptr->smacCfgAddr->magic); //wlpptr->smacCfgAddr->magic = SMAC_HAL_VERSION; } printk("=> %s(), MAC_STATUS_st->verCtrl[3] = %xh\n", __func__, 0xF0000000); - writel(0xF0000000, &wlpptr->smacStatusAddr->verCtrl[3]); + wl_util_writel(netdev, 0xF0000000, &wlpptr->smacStatusAddr->verCtrl[3]); if (wlInitChkSmacRdy(netdev) == FALSE) { WLDBG_ERROR(DBG_LEVEL_0, "Failed to get macRdy at init\n"); @@ -4175,6 +4183,7 @@ wlInit(struct net_device *netdev, u_int1 post_init_bq_idx(netdev, true); // Save the base address of rxSBinfoBaseAddr_v + wl_util_lock(netdev); wlpptr->rxSBinfoBaseAddr_v = wlpptr->smac_base_vp + (wlpptr->smacStatusAddr->rxSBinfoBaseAddr - wlpptr->smacconfig.smacBmBaseAddr); @@ -4186,6 +4195,7 @@ wlInit(struct net_device *netdev, u_int1 wlpptr->smacStatusAddr->rxSBinfoBaseAddr, wlpptr->smacStatusAddr->rxSBinfoUnitSize, (unsigned long)sizeof(RxSidebandInfo_t)); + wl_util_unlock(netdev); do { UINT32 regionIdx; @@ -4782,17 +4792,17 @@ wlInit(struct net_device *netdev, u_int1 goto err_init_rx; } #ifndef NEW_DP - writel((wlpptr->wlpd_p->descData[0].pPhysTxRing), + wl_util_writel(netdev, (wlpptr->wlpd_p->descData[0].pPhysTxRing), wlpptr->ioBase0 + wlpptr->wlpd_p->descData[0].wcbBase); #if NUM_OF_DESCRIPTOR_DATA >3 int i; for (i = 1; i < TOTAL_TX_QUEUES; i++) - writel((wlpptr->wlpd_p->descData[i].pPhysTxRing), + wl_util_writel(netdev, (wlpptr->wlpd_p->descData[i].pPhysTxRing), wlpptr->ioBase0 + wlpptr->wlpd_p->descData[i].wcbBase); #endif - writel((wlpptr->wlpd_p->descData[0].pPhysRxRing), + wl_util_writel(netdev, (wlpptr->wlpd_p->descData[0].pPhysRxRing), wlpptr->ioBase0 + wlpptr->wlpd_p->descData[0].rxDescRead); - writel((wlpptr->wlpd_p->descData[0].pPhysRxRing), + wl_util_writel(netdev, (wlpptr->wlpd_p->descData[0].pPhysRxRing), wlpptr->ioBase0 + wlpptr->wlpd_p->descData[0].rxDescWrite); #endif if (wlFwSetHwSpecs(netdev)) { @@ -5033,7 +5043,7 @@ wlDeinit(struct net_device *netdev) } /* disable all interupts from hframe */ - writel(0x0, wlpptr->ioBase1 + SC5_REG_PCIE_INTR_MODE_SEL); + wl_util_writel(netdev, 0x0, wlpptr->ioBase1 + SC5_REG_PCIE_INTR_MODE_SEL); ap8x_stat_proc_unregister(netdev); ap8xLnxStat_sysfs_exit(netdev); @@ -5690,9 +5700,8 @@ wlSC5MSIX_r7(int irq, void *dev_id) } if ((intStatus & SC5_EVENT_FW) && (wlpptr->event_bufq_vaddr)) { UINT32 wrptr, rdptr; - rdptr = readl(wlpptr->ioBase1 + reg_evt_rdptr); - wrptr = readl(wlpptr->ioBase1 + reg_evt_wrptr); - + rdptr = wl_util_readl(netdev, wlpptr->ioBase1 + reg_evt_rdptr); + wrptr = wl_util_readl(netdev, wlpptr->ioBase1 + reg_evt_wrptr); //printk("%s: SC5_EVENT_FW received rdptr=%d wrptr=%d\n", __func__, rdptr, wrptr); while (rdptr != wrptr) { rx_r7_intr[3]++; @@ -5705,7 +5714,7 @@ wlSC5MSIX_r7(int irq, void *dev_id) rdptr * EVENT_BUFFQ_SIZE); rdptr = (rdptr + 1) % EVENT_BUFFQ_NUM; - writel(rdptr, wlpptr->ioBase1 + reg_evt_rdptr); + wl_util_writel(netdev, rdptr, wlpptr->ioBase1 + reg_evt_rdptr); } intStatus &= ~SC5_EVENT_FW; retVal = IRQ_HANDLED; @@ -5846,6 +5855,8 @@ wlISR(int irq, void *dev_id) irqreturn_t retVal = IRQ_NONE; do { + wl_util_lock(netdev); + udelay(1); intStatus = (readl (wlpptr->ioBase1 + SC5_MACREG_REG_INTERRUPT_CAUSE)); @@ -5857,13 +5868,15 @@ wlISR(int irq, void *dev_id) } if (!wlpptr->wlpd_p->pPciDev->msi_enabled) { + unsigned long tmpval; writel((MACREG_A2HRIC_BIT_MASK_MSI & ~intStatus), wlpptr->ioBase1 + SC5_MACREG_REG_INTERRUPT_CAUSE); + tmpval = readl(wlpptr->ioBase1 + SC5_MACREG_REG_INTERRUPT_CAUSE); } } - + wl_util_unlock(netdev); if (intStatus & SC5_RX_INTR_MASK) { spin_lock(&wlpptr->wlpd_p->locks.intLock); wlpptr->RxQId |= @@ -5988,8 +6001,8 @@ wlISR(int irq, void *dev_id) } if ((intStatus & SC5_EVENT_FW) && (wlpptr->event_bufq_vaddr)) { UINT32 wrptr, rdptr; - rdptr = readl(wlpptr->ioBase1 + reg_evt_rdptr); - wrptr = readl(wlpptr->ioBase1 + reg_evt_wrptr); + rdptr = wl_util_readl(netdev, wlpptr->ioBase1 + reg_evt_rdptr); + wrptr = wl_util_readl(netdev, wlpptr->ioBase1 + reg_evt_wrptr); //printk("%s: SC5_EVENT_FW received rdptr=%d wrptr=%d\n", __func__, rdptr, wrptr); while (rdptr != wrptr) { @@ -6003,7 +6016,7 @@ wlISR(int irq, void *dev_id) rdptr * EVENT_BUFFQ_SIZE); rdptr = (rdptr + 1) % EVENT_BUFFQ_NUM; - writel(rdptr, wlpptr->ioBase1 + reg_evt_rdptr); + wl_util_writel(netdev, rdptr, wlpptr->ioBase1 + reg_evt_rdptr); } intStatus &= ~SC5_EVENT_FW; retVal = IRQ_HANDLED; @@ -6040,11 +6053,9 @@ wlISR(int irq, void *dev_id) unsigned int mask; #endif do { - intStatus = - (readl - (wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_CAUSE)); + intStatus = (wl_util_readl(netdev, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_CAUSE)); #ifdef NAPI - mask = (readl(wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK)); + mask = (wl_util_readl(netdev, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK)); #endif if (intStatus != 0x00000000) { if (intStatus == 0xffffffff) { @@ -6055,7 +6066,7 @@ wlISR(int irq, void *dev_id) #ifdef NAPI intStatus &= mask; #endif - writel((MACREG_A2HRIC_BIT_MASK & ~intStatus), + wl_util_writel(netdev, (MACREG_A2HRIC_BIT_MASK & ~intStatus), wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_CAUSE); } @@ -6237,7 +6248,7 @@ wlISR(int irq, void *dev_id) intStatus &= ~MACREG_A2HRIC_BIT_QUEUE_EMPTY; if (extStaDb_AggrFrameCk(vmacSta_p, 1)) { //interrupt when there are amsdu frames to fw. - writel(MACREG_H2ARIC_BIT_PPA_READY, + wl_util_writel(netdev, MACREG_H2ARIC_BIT_PPA_READY, wlpptr->ioBase1 + MACREG_REG_H2A_INTERRUPT_EVENTS); } @@ -6342,15 +6353,15 @@ wlInterruptEnable(struct net_device *net MACREG_HFCTRL_MASK_MSI; printk("%s(), w_reg(%p)=%xh\n", __func__, (wlpptr->ioBase1 + reg_a2h_intr_mask), 0); - writel(0x00, wlpptr->ioBase1 + reg_a2h_intr_mask); + wl_util_writel(netdev, 0x00, wlpptr->ioBase1 + reg_a2h_intr_mask); //writel((MACREG_A2HRIC_BIT_MASK), printk("%s(), w_reg(%p)=%xh\n", __func__, (wlpptr->ioBase1 + reg_a2h_intr_mask), hfctrl); - writel(hfctrl, wlpptr->ioBase1 + reg_a2h_intr_mask); + wl_util_writel(netdev, hfctrl, wlpptr->ioBase1 + reg_a2h_intr_mask); #else - writel(0x00, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); + wl_util_writel(netdev, 0x00, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); - writel((MACREG_A2HRIC_BIT_MASK), + wl_util_writel(netdev, (MACREG_A2HRIC_BIT_MASK), wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); #endif /* SOC_W906X */ } @@ -6364,9 +6375,9 @@ wlInterruptDisable(struct net_device *ne if (wlChkAdapter(netdev)) { #ifdef SOC_W906X - writel(0x00, wlpptr->ioBase1 + reg_a2h_intr_mask); + wl_util_writel(netdev, 0x00, wlpptr->ioBase1 + reg_a2h_intr_mask); #else - writel(0x00, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); + wl_util_writel(netdev, 0x00, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); #endif /* SOC_W906X */ } } @@ -6379,12 +6390,11 @@ wlInterruptUnMask(struct net_device *net if (wlChkAdapter(netdev)) { #ifdef SOC_W906X - writel((readl(wlpptr->ioBase1 + reg_a2h_intr_mask) | (mask)), + wl_util_writel(netdev, (wl_util_readl(netdev, wlpptr->ioBase1 + reg_a2h_intr_mask) | (mask)), wlpptr->ioBase1 + reg_a2h_intr_mask); #else - writel((readl(wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK) | - (mask)), - wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); + wl_util_writel(netdev, (wl_util_readl(netdev, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK) | (mask)), + wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); #endif /* SOC_W906X */ } } @@ -6397,12 +6407,10 @@ wlInterruptMask(struct net_device *netde if (wlChkAdapter(netdev)) { #ifdef SOC_W906X - writel((readl(wlpptr->ioBase1 + reg_a2h_intr_mask) & (~mask)), + wl_util_writel(netdev, (wl_util_readl(netdev, wlpptr->ioBase1 + reg_a2h_intr_mask) & (~mask)), wlpptr->ioBase1 + reg_a2h_intr_mask); #else - writel((readl(wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK) & - (~mask)), - wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); + wl_util_writel(netdev, (wl_util_readl(netdev, wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK)& (~mask)), wlpptr->ioBase1 + MACREG_REG_A2H_INTERRUPT_MASK); #endif /* SOC_W906X */ } } @@ -6417,9 +6425,7 @@ wlFwReset(struct net_device *netdev) if (wlChkAdapter(netdev)) { WLDBG_INFO(DBG_LEVEL_2, "write ISR_RESET to %u\n", MACREG_REG_H2A_INTERRUPT_EVENTS); - writel(ISR_RESET, - wlpptr->ioBase1 + - MACREG_REG_H2A_INTERRUPT_EVENTS); + wl_util_writel(netdev, ISR_RESET, wlpptr->ioBase1 + MACREG_REG_H2A_INTERRUPT_EVENTS); } else { WLDBG_INFO(DBG_LEVEL_2, "int_code = %u\n", wlpptr->wlpd_p->reg.int_code); @@ -6427,8 +6433,7 @@ wlFwReset(struct net_device *netdev) } #else if (wlChkAdapter(netdev)) { - writel(ISR_RESET, - wlpptr->ioBase1 + MACREG_REG_H2A_INTERRUPT_EVENTS); + wl_util_writel(netdev, ISR_RESET, wlpptr->ioBase1 + MACREG_REG_H2A_INTERRUPT_EVENTS); } #endif } @@ -6441,9 +6446,9 @@ wlChkAdapter(struct net_device *netdev) unsigned int reg_int_code = wlpptr->wlpd_p->reg.int_code; #ifdef SOC_W906X - regval = readl(wlpptr->ioBase1 + reg_int_code); + regval = wl_util_readl(netdev, wlpptr->ioBase1 + reg_int_code); #else - regval = readl(wlpptr->ioBase1 + MACREG_REG_INT_CODE); + regval = wl_util_readl(netdev, wlpptr->ioBase1 + MACREG_REG_INT_CODE); #endif if (regval == 0xffffffff) { printk(" wlChkAdapter FALSE regval = %x \n", regval); @@ -7294,7 +7299,7 @@ wltxwait_txdone(struct net_device *netde do { mdelay(10); wlTxDone(netdev); - txDoneHeadnew = readl(priv->ioBase1 + MACREG_REG_TxDoneHead); + txDoneHeadnew = wl_util_readl(netdev, priv->ioBase1 + MACREG_REG_TxDoneHead); txDoneTail = priv->wlpd_p->descData[0]. TxDoneTail & (MAX_TX_RING_DONE_SIZE - 1); @@ -7454,10 +7459,9 @@ wlFwHardreset(struct net_device *netdev, wltxwait_txdone(netdev); //remember the SendTail which is updated by FW before fw gone. #ifdef SOC_W906X - txSendTail = - readl(priv->ioBase1 + priv->wlpd_p->reg.tx_send_tail); + txSendTail = wl_util_readl(netdev, priv->ioBase1 + priv->wlpd_p->reg.tx_send_tail); #else - txSendTail = readl(priv->ioBase1 + MACREG_REG_TxSendTail); + txSendTail = wl_util_readl(netdev, priv->ioBase1 + MACREG_REG_TxSendTail); #endif /* SOC_W906X */ } #ifdef SOC_W906X @@ -7771,7 +7775,7 @@ wlFwHardreset(struct net_device *netdev, wl_init_intr(priv); wl_hook_intr(priv); - writel(priv->hframe_phy_addr, priv->ioBase1 + SC5_REG_HFRAME_BASE); + wl_util_writel(netdev, priv->hframe_phy_addr, priv->ioBase1 + SC5_REG_HFRAME_BASE); printk("hframe base addr %llx \n", (long long unsigned int)priv->hframe_phy_addr); @@ -7807,7 +7811,7 @@ wlReinit(struct net_device *netdev) printk("=> %s(), MAC_STATUS_st->verCtrl[3] = %xh\n", __func__, 0xF0000000); - writel(0xF0000000, &parent_wlpptr->smacStatusAddr->verCtrl[3]); + wl_util_writel(netdev, 0xF0000000, &parent_wlpptr->smacStatusAddr->verCtrl[3]); if (wlInitChkSmacRdy(netdev) == FALSE) { WLDBG_ERROR(DBG_LEVEL_0, "Failed to get macRdy at init\n"); } else { @@ -7852,12 +7856,12 @@ wlFwHardResetAndReInit(struct net_device U32 regval; *(u32 *) (&((SMAC_CTRL_BLK_st *) priv->ioBase0)->config. rxEnable) = 0; - regval = readl(priv->ioBase1 + BBRX_CFG); + regval = wl_util_readl(netdev, priv->ioBase1 + BBRX_CFG); if (regval & 0x01) - writel((regval & 0xFFFFFFFE), priv->ioBase1 + BBRX_CFG); + wl_util_writel(netdev, (regval & 0xFFFFFFFE), priv->ioBase1 + BBRX_CFG); } /* disable all interupts from hframe */ - writel(0x0, priv->ioBase1 + SC5_REG_PCIE_INTR_MODE_SEL); + wl_util_writel(netdev, 0x0, priv->ioBase1 + SC5_REG_PCIE_INTR_MODE_SEL); /* disable all interrupts from device */ wldisable_intr(netdev); diff -uprN a/DRV/wlan-v10/driver/ap8xLnxIntf.h b/DRV/wlan-v10/driver/ap8xLnxIntf.h --- a/DRV/wlan-v10/driver/ap8xLnxIntf.h 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/ap8xLnxIntf.h 2020-02-06 23:28:28.000000000 -0800 @@ -1280,6 +1280,8 @@ struct wlprivate_data { UINT32 sta_tx_succ[MAX_STNS]; UINT32 sta_keep_alive_tx_succ[MAX_STNS]; #endif /* SOC_W906X */ + spinlock_t pcie_iolock; + unsigned long ioflags; U32 rrm_trigger_time; // rrm trigger time(ms) U32 rrm_interval_time; // offchan interval time(ms) U32 rrm_dwell_time; // fw offchan time(ms) diff -uprN a/DRV/wlan-v10/driver/ap8xLnxStat.c b/DRV/wlan-v10/driver/ap8xLnxStat.c --- a/DRV/wlan-v10/driver/ap8xLnxStat.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/ap8xLnxStat.c 2020-02-06 23:29:54.000000000 -0800 @@ -1043,6 +1043,7 @@ ap8xLnxStat_hw_show(struct kobject *kobj wlpptr->pCmdBuf, (u32) wlpptr->wlpd_p->pPhysCmdBuf); Sysfs_Printk("set qIntOffset = %xh\n", wlpptr->smacconfig.qIntOffset); Sysfs_Printk("MAC_CONFIG_st->magic = %xh\n", wlpptr->smacconfig.magic); + wl_util_lock(netdev); Sysfs_Printk("MAC_STATUS_st->verCtrl[3] = %xh\n", wlpptr->smacStatusAddr->verCtrl[3]); Sysfs_Printk("smac_base (v,p)=(%p, %xh)\n", wlpptr->smac_base_vp, @@ -1052,6 +1053,7 @@ ap8xLnxStat_hw_show(struct kobject *kobj wlpptr->smacStatusAddr->rxSBinfoBaseAddr, wlpptr->smacStatusAddr->rxSBinfoUnitSize, (unsigned long)sizeof(RxSidebandInfo_t)); + wl_util_unlock(netdev); #if 0 /* FW version foramt is changed, below version need remap, temporary disbaled */ Sysfs_Printk("Major Version : %d\n", diff -uprN a/DRV/wlan-v10/driver/W906x/ap8xLnxBQM.c b/DRV/wlan-v10/driver/W906x/ap8xLnxBQM.c --- a/DRV/wlan-v10/driver/W906x/ap8xLnxBQM.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/W906x/ap8xLnxBQM.c 2020-02-06 19:48:09.000000000 -0800 @@ -301,14 +301,14 @@ wlQueryRdPtr(struct net_device * netdev, wlqm = &wlpptr->wlpd_p->descData[qid]; if (qoff == SC5_RQ) { orig_rdinx = wlqm->rq.rdinx; - regval = readl(wlpptr->ioBase1 + SC5_RQ_RDPTR_REG(qid)); + regval = wl_util_readl(netdev, wlpptr->ioBase1 + SC5_RQ_RDPTR_REG(qid)); qsize = wlqm->rq.qsize; WLDBG_INFO(DBG_LEVEL_5, "QINDEX: RQ(%d),r_reg(ioBase1+%xh) = %xh\n", qid, SC5_RQ_RDPTR_REG(qid), regval); } else { orig_rdinx = wlqm->sq.rdinx; - regval = readl(wlpptr->ioBase1 + SC5_SQ_RDPTR_REG(qid)); + regval = wl_util_readl(netdev, wlpptr->ioBase1 + SC5_SQ_RDPTR_REG(qid)); qsize = wlqm->sq.qsize; WLDBG_INFO(DBG_LEVEL_5, "QINDEX: SQ(%d),r_reg(ioBase1+%xh) = %xh\n", qid, @@ -350,7 +350,7 @@ CheckSMACReady(struct net_device * netde u8 i = 0; while (loopcnt++ < 1000) { - regval = readl(parent_wlpptr->ioBase0 + regoff); + regval = wl_util_readl(netdev, parent_wlpptr->ioBase0 + regoff); if (regval == 0x01010101) { break; } @@ -377,7 +377,9 @@ CheckSMACReady(struct net_device * netde u32 regval; while (loopcnt++ < 1000) { + wl_util_lock(netdev); regval = *(UINT32 *) parent_wlpptr->smacStatusAddr->smacRdy; + wl_util_unlock(netdev); if (regval == 0x01010101) { break; } @@ -444,11 +446,11 @@ wlUpdateRdPtr(struct net_device *netdev, rdinx, ptval); if (qoff == SC5_RQ) { - writel(ptval, (wlpptr->ioBase1 + SC5_RQ_RDPTR_REG(qid))); + wl_util_writel(netdev, ptval, (wlpptr->ioBase1 + SC5_RQ_RDPTR_REG(qid))); WLDBG_INFO(DBG_LEVEL_5, "QINDEX(%d) RQ: w_reg(%p)=%xh\n", (wlpptr->ioBase1 + SC5_RQ_RDPTR_REG(qid)), ptval); } else { - writel(ptval, (wlpptr->ioBase1 + SC5_SQ_RDPTR_REG(qid))); + wl_util_writel(netdev, ptval, (wlpptr->ioBase1 + SC5_SQ_RDPTR_REG(qid))); WLDBG_INFO(DBG_LEVEL_5, "QINDEX(%d) SQ: w_reg(%p)=%xh\n", qid, (wlpptr->ioBase1 + SC5_SQ_RDPTR_REG(qid)), ptval); } @@ -475,13 +477,13 @@ wlQueryWrPtr(struct net_device * netdev, wlqm = &wlpptr->wlpd_p->descData[qid]; if (qoff == SC5_RQ) { orig_wrinx = wlqm->rq.wrinx; - regval = readl(wlpptr->ioBase1 + SC5_RQ_WRPTR_REG(qid)); + regval = wl_util_readl(netdev, wlpptr->ioBase1 + SC5_RQ_WRPTR_REG(qid)); qsize = wlqm->rq.qsize; WLDBG_INFO(DBG_LEVEL_5, "QINDEX(%d),r_reg(ioBase1+%xh) = %xh\n", qid, SC5_RQ_WRPTR_REG(qid), regval); } else { orig_wrinx = wlqm->sq.wrinx; - regval = readl(wlpptr->ioBase1 + SC5_SQ_WRPTR_REG(qid)); + regval = wl_util_readl(netdev, wlpptr->ioBase1 + SC5_SQ_WRPTR_REG(qid)); qsize = wlqm->sq.qsize; WLDBG_INFO(DBG_LEVEL_5, "QINDEX(%d),r_reg(ioBase1+%xh) = %xh\n", qid, SC5_SQ_WRPTR_REG(qid), regval); @@ -522,11 +524,11 @@ wlUpdateWrPtr(struct net_device *netdev, wrinx, ptval); if (qoff == SC5_RQ) { - writel(ptval, (wlpptr->ioBase1 + SC5_RQ_WRPTR_REG(qid))); + wl_util_writel(netdev, ptval, (wlpptr->ioBase1 + SC5_RQ_WRPTR_REG(qid))); WLDBG_INFO(DBG_LEVEL_5, "QINDEX(%d),r_reg(ioBase1+%xh) = %xh\n", qid, SC5_RQ_WRPTR_REG(qid), ptval); } else { - writel(ptval, (wlpptr->ioBase1 + SC5_SQ_WRPTR_REG(qid))); + wl_util_writel(netdev, ptval, (wlpptr->ioBase1 + SC5_SQ_WRPTR_REG(qid))); WLDBG_INFO(DBG_LEVEL_5, "QINDEX(%d),r_reg(ioBase1+%xh) = %xh\n", qid, SC5_SQ_WRPTR_REG(qid), ptval); } @@ -606,8 +608,7 @@ wlRxQueueCleanUp(struct net_device *netd } // reset descruptor queue size. wlqm->sq.qsize = 0; - writel(wlqm->sq.qsize, - (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); + wl_util_writel(netdev, wlqm->sq.qsize, (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); // Note: should not change the index, otherwise h/w will issue interrupt //wlqm->sq.rdinx = 0; @@ -658,20 +659,17 @@ wlRxQueueInit(struct net_device *netdev, WLDBG_INFO(DBG_LEVEL_0, "RXQ(%d) qid = %d, CFH base = 0x%X \n", qid, qid, wlqm->sq.phys_addr); // set CFH-UL descruptor queue size and start address. - writel((u32) wlqm->sq.phys_addr, - (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ))); + wl_util_writel(netdev, (u32)wlqm->sq.phys_addr, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ))); WLDBG_INFO(DBG_LEVEL_0, "RXQ(%d), SC5_Q_BASE_ADDR_REG w_reg(ioBase1+%xh) = %xh\n", qid, SC5_Q_BASE_ADDR_REG(qid, SC5_SQ), (u32) wlqm->sq.phys_addr); // high address - writel(smac_buf_hi_addr, - (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ) + 4)); + wl_util_writel(netdev, smac_buf_hi_addr, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ) + 4)); WLDBG_INFO(DBG_LEVEL_0, "RXQ(%d),w_reg(ioBase1+%xh) = %xh\n", qid, (SC5_Q_BASE_ADDR_REG(qid, SC5_SQ) + 4), smac_buf_hi_addr); - writel(((wlqm->sq.qsize * sizeof(wlrxdesc_t)) / 128) << 3, - (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); + wl_util_writel(netdev, ((wlqm->sq.qsize * sizeof(wlrxdesc_t)) / 128) << 3, (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); WLDBG_INFO(DBG_LEVEL_0, "RXQ(%d) SQ, SC5_Q_SIZE_REG w_reg(ioBase1+%xh) = %xh, qsize=%d, sizeof(wlrxdesc_t)=%d\n", qid, SC5_Q_SIZE_REG(qid, SC5_SQ), @@ -720,19 +718,16 @@ wlTxQueueInit(struct net_device *netdev, qid, wlqm->rq.phys_addr); // set CFH-DL descruptor queue size and start address. - writel((u32) wlqm->rq.phys_addr, - (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_RQ))); + wl_util_writel(netdev, smac_buf_hi_addr, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_RQ)) + 4); WLDBG_INFO(DBG_LEVEL_0, "TXQ(%d),RQ, SC5_Q_BASE_ADDR_REG w_reg(ioBase1+%xh) = %xh\n", qid, SC5_Q_BASE_ADDR_REG(qid, SC5_RQ), (u32) wlqm->rq.phys_addr); // high address - writel(smac_buf_hi_addr, - (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_RQ)) + 4); + wl_util_writel(netdev, smac_buf_hi_addr, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_RQ)) + 4); WLDBG_INFO(DBG_LEVEL_0, "TXQ(%d),w_reg(ioBase1+%xh) = %xh\n", qid, (SC5_Q_BASE_ADDR_REG(qid, SC5_RQ) + 4), smac_buf_hi_addr); - writel(((wlqm->rq.qsize * sizeof(wltxdesc_t)) / 128) << 3, - (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_RQ))); + wl_util_writel(netdev, ((wlqm->rq.qsize * sizeof(wltxdesc_t)) / 128) << 3, (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_RQ))); WLDBG_INFO(DBG_LEVEL_0, "TXQ(%d),RQ, SC5_Q_SIZE_REG w_reg(ioBase1+%xh) = %xh, qsize=%d, sizeof(wltxdesc_t)=%d\n", qid, SC5_Q_SIZE_REG(qid, SC5_RQ), @@ -766,8 +761,7 @@ wlTxQueueCleanUp(struct net_device *netd } // reset descruptor queue size. wlqm->rq.qsize = 0; - writel(wlqm->rq.qsize, - (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_RQ))); + wl_util_writel(netdev, wlqm->rq.qsize, (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_RQ))); // Note: should not change the index, otherwise h/w will issue interrupt //wlqm->rq.rdinx = 0; @@ -823,16 +817,14 @@ wlBmQueueInit(struct net_device *netdev, WLDBG_INFO(DBG_LEVEL_0, "BMQ(%d) qid = %d, BPE base = %xh\n", qid, qid, wlqm->rq.phys_addr); // set BMQ descruptor queue size and start address. - writel((u32) wlqm->rq.phys_addr, - (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_RQ))); + wl_util_writel(netdev, (u32)wlqm->rq.phys_addr, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_RQ))); WLDBG_INFO(DBG_LEVEL_0, "BMQ(%d),RQ, SC5_Q_BASE_ADDR_REG w_reg(ioBase1+%llxh) = %xh\n", qid, SC5_Q_BASE_ADDR_REG(qid, SC5_RQ), (u64) wlqm->rq.phys_addr); // High address - writel(smac_buf_hi_addr, - (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_RQ) + 4)); + wl_util_writel(netdev, smac_buf_hi_addr, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_RQ) + 4)); WLDBG_INFO(DBG_LEVEL_0, "BMQ(%d),w_reg(ioBase1+%xh) = %xh\n", qid, (SC5_Q_BASE_ADDR_REG(qid, SC5_RQ) + 4), smac_buf_hi_addr); @@ -840,8 +832,7 @@ wlBmQueueInit(struct net_device *netdev, // Mail from Jerry on 13th Feb 2017: // "The size of queue must align to 128 bytes...." // - writel(((wlqm->rq.qsize * sizeof(bm_pe_hw_t)) / 128) << 3, - (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_RQ))); + wl_util_writel(netdev, ((wlqm->rq.qsize * sizeof(bm_pe_hw_t)) / 128) << 3, (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_RQ))); WLDBG_INFO(DBG_LEVEL_0, "BMQ(%d),RQ, SC5_Q_SIZE_REG w_reg(ioBase1+%xh) = %xh, qsize=%d, sizeof(bm_pe_hw_t)=%d\n", qid, SC5_Q_SIZE_REG(qid, SC5_RQ), @@ -1111,8 +1102,7 @@ wlBmQueueCleanUp(struct net_device *netd } // reset descruptor queue size. wlqm->rq.qsize = 0; - writel(wlqm->rq.qsize, - (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_RQ))); + wl_util_writel(netdev, wlqm->rq.qsize, (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_RQ))); // Note: should not change the index, otherwise h/w will issue interrupt //wlqm->rq.rdinx = 0; @@ -1160,21 +1150,18 @@ wlBufReleaseQueueInit(struct net_device wlqm->sq.rdinx = 0; wlqm->sq.wrinx = 0; // set Release buffer descruptor queue size and start address. - writel(wlqm->sq.phys_addr, - (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ))); + wl_util_writel(netdev, wlqm->sq.phys_addr, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ))); WLDBG_INFO(DBG_LEVEL_0, "BMQ(%d), SQ, SC5_Q_BASE_ADDR_REG(%d): %p, phyaddr=%llxh\n", qid, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ)), (u64) wlqm->sq.phys_addr); // high address - writel(smac_buf_hi_addr, - (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ) + 4)); + wl_util_writel(netdev, smac_buf_hi_addr, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ) + 4)); WLDBG_INFO(DBG_LEVEL_0, "BMQ(%d),w_reg(ioBase1+%xh) = %xh\n", qid, (SC5_Q_BASE_ADDR_REG(qid, SC5_SQ) + 4), smac_buf_hi_addr); - writel(((wlqm->sq.qsize * sizeof(bm_pe_hw_t)) / 128) << 3, - (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); + wl_util_writel(netdev, ((wlqm->sq.qsize * sizeof(bm_pe_hw_t)) / 128) << 3, (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); WLDBG_INFO(DBG_LEVEL_0, "BMQ(%d),SQ, SC5_Q_SIZE_REG w_reg(ioBase1+%xh) = %xh, qsize=%d, sizeof(bm_pe_hw_t)=%d\n", qid, SC5_Q_SIZE_REG(qid, SC5_SQ), @@ -1182,13 +1169,11 @@ wlBufReleaseQueueInit(struct net_device wlqm->sq.qsize, sizeof(bm_pe_hw_t)); /* set TX DONE interrupt threshold and timeout */ - writel(SC5_TXDONE_INT_THRESHOLD, - (wlpptr->ioBase1 + SC5_Q_THRES_REG(qid, SC5_SQ))); + wl_util_writel(netdev, SC5_TXDONE_INT_THRESHOLD, (wlpptr->ioBase1 + SC5_Q_THRES_REG(qid, SC5_SQ))); WLDBG_INFO(DBG_LEVEL_0, "BMQ(%d),w_reg(ioBase1+%xh) = %xh\n", qid, SC5_Q_THRES_REG(qid, SC5_SQ), 0x1); - writel(SQ5_MAC_CTRL_TIMEOUT(SC5_TXDONE_INT_TIMEOUT), - (wlpptr->ioBase1 + SC5_Q_MAC_CTRL_REG(qid, SC5_SQ))); + wl_util_writel(netdev, SQ5_MAC_CTRL_TIMEOUT(SC5_TXDONE_INT_TIMEOUT), (wlpptr->ioBase1 + SC5_Q_MAC_CTRL_REG(qid, SC5_SQ))); WLDBG_INFO(DBG_LEVEL_0, "BMQ(%d),w_reg(ioBase1+%xh) = %xh\n", qid, SC5_Q_MAC_CTRL_REG(qid, SC5_SQ), SQ5_MAC_CTRL_TIMEOUT(0x10)); @@ -1222,8 +1207,7 @@ wlBufReleaseQueueCleanUp(struct net_devi } // reset descruptor queue size. wlqm->sq.qsize = 0; - writel(wlqm->sq.qsize, - (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); + wl_util_writel(netdev, wlqm->sq.qsize, (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); // Note: should not change the index, otherwise h/w will issue interrupt //wlqm->sq.rdinx = 0; @@ -1314,20 +1298,18 @@ wlRAcntQueueInit(struct net_device *netd wlqm->sq.rdinx = 0; wlqm->sq.wrinx = 0; // set Release buffer descruptor queue size and start address. - writel(wlqm->sq.phys_addr, - (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ))); + wl_util_writel(netdev, wlqm->sq.phys_addr, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ))); WLDBG_INFO(DBG_LEVEL_0, "RxAcntQ(%d), SQ, SC5_Q_BASE_ADDR_REG(%d): %p, phyaddr=%llxh\n", qid, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ)), (u64) wlqm->sq.phys_addr); // high address - writel(smac_buf_hi_addr, - (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ) + 4)); + wl_util_writel(netdev, smac_buf_hi_addr, (wlpptr->ioBase1 + SC5_Q_BASE_ADDR_REG(qid, SC5_SQ) + 4)); WLDBG_INFO(DBG_LEVEL_0, "RxAcntQ(%d),w_reg(ioBase1+%xh) = %xh\n", qid, (SC5_Q_BASE_ADDR_REG(qid, SC5_SQ) + 4), smac_buf_hi_addr); - writel(((wlqm->sq.qsize * sizeof(rxacnt_rec)) / 128) << 3, + wl_util_writel(netdev, ((wlqm->sq.qsize * sizeof(rxacnt_rec)) / 128) << 3, (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); WLDBG_INFO(DBG_LEVEL_0, "RxAcntQ(%d),SQ, SC5_Q_SIZE_REG w_reg(ioBase1+%xh) = %xh, qsize=%d, sizeof(rxacnt_rec)=%d\n", @@ -1391,8 +1373,7 @@ wlRAcntQueueCleanUp(struct net_device *n } // reset descruptor queue size. wlqm->sq.qsize = 0; - writel(wlqm->sq.qsize, - (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); + wl_util_writel(netdev, wlqm->sq.qsize, (wlpptr->ioBase1 + SC5_Q_SIZE_REG(qid, SC5_SQ))); wlRAcntBufCleanUp(netdev, qid); // Note: should not change the index, otherwise h/w will issue interrupt @@ -1449,7 +1430,7 @@ wlGetRelBufPe(struct net_device *netdev, invalid_pe = 1; #ifdef ASSERT_MALBUF dbg_level = 0x1; - writel(0xdeadbeef, wlpptr->ioBase1 + PCI_REG_SCRATCH14_REG); + wl_util_writel(netdev, 0xdeadbeef, wlpptr->ioBase1 + PCI_REG_SCRATCH14_REG); wl_dump_dbgrelq_info(netdev, 0x528, 0x52c); wl_dump_dbgrelq_info(netdev, 0x520, 0x524); wl_dump_dbgrelq_info(netdev, 0x518, 0x51c); @@ -1470,7 +1451,7 @@ wlGetRelBufPe(struct net_device *netdev, invalid_pe = 1; #ifdef ASSERT_MALBUF dbg_level = 0x1; - writel(0xdeadbeef, wlpptr->ioBase1 + PCI_REG_SCRATCH14_REG); + wl_util_writel(netdev, 0xdeadbeef, wlpptr->ioBase1 + PCI_REG_SCRATCH14_REG); wl_dump_dbgrelq_info(netdev, 0x528, 0x52c); wl_dump_dbgrelq_info(netdev, 0x520, 0x524); wl_dump_dbgrelq_info(netdev, 0x518, 0x51c); @@ -2058,7 +2039,7 @@ wlPeToSkb(struct net_device *netdev, bm_ return NULL; #else dbg_level = 0x1; - writel(0xdeadbeef, wlpptr->ioBase1 + PCI_REG_SCRATCH14_REG); + wl_util_writel(netdev, 0xdeadbeef, wlpptr->ioBase1 + PCI_REG_SCRATCH14_REG); wl_dump_dbgrelq_info(netdev, 0x528, 0x52c); wl_dump_dbgrelq_info(netdev, 0x520, 0x524); wl_dump_dbgrelq_info(netdev, 0x518, 0x51c); @@ -2777,8 +2758,10 @@ oops_do_dump(struct kmsg_dumper *dumper, wl_show_hframe_info(netdev, NULL); wl_show_pktcnt_stat(netdev, NULL); wlpptr = wlpdptr->masterwlp; + wl_util_lock(netdev); memcpy(&smacStatus, wlpptr->smacStatusAddr, sizeof(SMAC_STATUS_st)); + wl_util_unlock(netdev); wl_show_smac_stat(netdev, &smacStatus, NULL); } printk("================================================================\n"); @@ -3064,7 +3047,7 @@ wlQMInit(struct net_device *netdev) WLDBG_INFO(DBG_LEVEL_0, "w_reg(ioBase1+%xh) = %xh\n", 0x1a848, wlpptr->smacconfig.ddrHighAddr); - writel(wlpptr->smacconfig.ddrHighAddr, wlpptr->ioBase1 + 0x1a848); //hack, smac_control_base_nss + wl_util_writel(netdev, wlpptr->smacconfig.ddrHighAddr, wlpptr->ioBase1 + 0x1a848);//hack, smac_control_base_nss wlpptr->smac_base_vp = wlpd_p->ext_membuf[0].vbuf_pool; @@ -3147,8 +3130,8 @@ wlQMInit(struct net_device *netdev) &wlpptr->event_bufq_paddr, wlpd_p->dma_alloc_flags); - writel(0, wlpptr->ioBase1 + reg_evt_rdptr); - writel(0, wlpptr->ioBase1 + reg_evt_wrptr); + wl_util_writel(netdev, 0, wlpptr->ioBase1 + reg_evt_rdptr); + wl_util_writel(netdev, 0, wlpptr->ioBase1 + reg_evt_wrptr); WLDBG_DATA(DBG_LEVEL_3, "=> Event_buffer_q (v, p)=(%p, %x)\n", wlpptr->event_bufq_vaddr, wlpptr->event_bufq_paddr); @@ -3224,7 +3207,7 @@ wlRxQDump(struct net_device *netdev) "addr: base %p qsize %p rdptr %p wrptr %p \n", addr[0], addr[1], addr[2], addr[3]); for (i = 0; i < 4; i++) - value[i] = readl(addr[i]); + value[i] = wl_util_readl(netdev, addr[i]); WLDBG_INFO(DBG_LEVEL_3, "value: base %x qsize %x rdptr %x wrptr %x \n", value[0], value[1], value[2], value[3]); @@ -3269,7 +3252,7 @@ wlTxQDump(struct net_device *netdev) "addr: base %p qsize %p rdptr %p wrptr %p \n", addr[0], addr[1], addr[2], addr[3]); for (i = 0; i < 4; i++) - value[i] = readl(addr[i]); + value[i] = wl_util_readl(netdev, addr[i]); WLDBG_INFO(DBG_LEVEL_3, "value: base %x qsize %x rdptr %x wrptr %x \n", value[0], value[1], value[2], value[3]); @@ -3310,7 +3293,7 @@ wlBmQDump(struct net_device *netdev) "addr: base %p qsize %p rdptr %p wrptr %p \n", addr[0], addr[1], addr[2], addr[3]); for (i = 0; i < 4; i++) - value[i] = readl(addr[i]); + value[i] = wl_util_readl(netdev, addr[i]); WLDBG_INFO(DBG_LEVEL_3, "value: base %x qsize %x rdptr %x wrptr %x \n", value[0], value[1], value[2], value[3]); @@ -3350,7 +3333,7 @@ wlReleaseQDump(struct net_device *netdev "addr: base %p qsize %p rdptr %p wrptr %p \n", addr[0], addr[1], addr[2], addr[3]); for (i = 0; i < 4; i++) - value[i] = readl(addr[i]); + value[i] = wl_util_readl(netdev, addr[i]); WLDBG_INFO(DBG_LEVEL_3, "value: base %x qsize %x rdptr %x wrptr %x \n", value[0], value[1], value[2], value[3]); @@ -4224,7 +4207,7 @@ wlGetCfhUl(struct net_device * netdev, i wlpd_p->drv_stats_val.rxq_rcv_cnt[0], wlpd_p->drv_stats_val.rxq_rcv_cnt[8], wlpd_p->drv_stats_val.rxq_rcv_cnt[9]); - writel(0xdeadbeef, wlpptr->ioBase1 + PCI_REG_SCRATCH14_REG); + wl_util_writel(netdev, 0xdeadbeef, wlpptr->ioBase1 + PCI_REG_SCRATCH14_REG); wl_dump_dbgrelq_info(netdev, 0x528, 0x52c); wl_dump_dbgrelq_info(netdev, 0x520, 0x524); wl_dump_dbgrelq_info(netdev, 0x518, 0x51c); @@ -5420,9 +5403,7 @@ wl_show_scheduleinfo(struct net_device * wlFwGetQueueStats(netdev, QS_GET_TX_SCHEDULER_INFO, 0, sysfs_buff); if (level == 0 && (addr_val != NULL)) { - fwDbgStateAddr = - readl(wlpptr->ioBase1 + - wlpptr->wlpd_p->reg.FwDbgStateAddr); + fwDbgStateAddr = wl_util_readl(netdev, wlpptr->ioBase1 + wlpptr->wlpd_p->reg.FwDbgStateAddr); wlFwGetAddrValue(netdev, (fwDbgStateAddr + 0x134), 1, addr_val, 0); @@ -5483,8 +5464,10 @@ wl_show_generic_info(struct net_device * int i; unsigned int reg_evt_rdptr = wlpd_p->reg.evt_rdptr; unsigned int reg_evt_wrptr = wlpd_p->reg.evt_wrptr; - + + wl_util_lock(netdev); memcpy(pSMACStatus, wlpptr->smacStatusAddr, sizeof(SMAC_STATUS_st)); + wl_util_unlock(netdev); Sysfs_Printk("Drv_Info:\n"); Sysfs_Printk("\t rx_count = %lu\n", wlpptr->netDevStats.rx_packets); @@ -5519,8 +5502,8 @@ wl_show_generic_info(struct net_device * Sysfs_Printk("\n"); Sysfs_Printk("EventQ\t\tRD ptr\t\tWR ptr\n"); Sysfs_Printk(" \t\t%08x\t%08x\n", - readl(wlpptr->ioBase1 + reg_evt_rdptr), - readl(wlpptr->ioBase1 + reg_evt_wrptr)); + wl_util_readl(netdev, wlpptr->ioBase1 + reg_evt_rdptr), + wl_util_readl(netdev, wlpptr->ioBase1 + reg_evt_wrptr)); Sysfs_Printk("R7 interrupt#\n"); for (i = 0; i < 4; i++) { @@ -5650,10 +5633,7 @@ wl_show_pfw_alive_counts(struct net_devi if (IS_BUS_TYPE_MCI(wlpptr)) { //MOCHI - dmemaddr = - readl(wlpptr->ioBase1 + - wlpptr->wlpd_p->reg.FwDbgStateAddr) - - SMAC_DMEM_START; + dmemaddr = wl_util_readl(netdev, wlpptr->ioBase1 + wlpptr->wlpd_p->reg.FwDbgStateAddr) - SMAC_DMEM_START; //check valid range if (dmemaddr > DMEM_SIZE_SC5_SCBT_A0) @@ -5717,8 +5697,10 @@ wl_show_smac_stat(struct net_device *net if (pSMACStatus == NULL) { // Get the SMAC status now pSMACStatus = &smacStatus; + wl_util_lock(netdev); memcpy(pSMACStatus, wlpptr->smacStatusAddr, sizeof(SMAC_STATUS_st)); + wl_util_unlock(netdev); } Sysfs_Printk("==========================\n"); @@ -6362,7 +6344,9 @@ wl_show_tx_mu_pkcnt_msg(struct net_devic return; memset(pktcnt, 0, 64 * sizeof(UINT32)); + wl_util_lock(netdev); reg = wlpptr->smacStatusAddr->sysRsvdMU[3]; + wl_util_unlock(netdev); wlFwGetAddrValue(netdev, reg, 2, pktcnt, 0); Sysfs_Printk("Tx MU/SU cnt:\n"); @@ -6371,7 +6355,9 @@ wl_show_tx_mu_pkcnt_msg(struct net_devic wl_kfree(pktcnt); Sysfs_Printk("Tx MU-MIMO cnt:\n"); + wl_util_lock(netdev); Sysfs_Printk("[MU-MIMO]: %8u\n", wlpptr->smacStatusAddr->sysRsvdMU[11]); + wl_util_unlock(netdev); } @@ -6432,10 +6418,7 @@ wl_show_dra_stat(struct net_device *netd UINT32 dmemaddr, reg_pc; if (IS_BUS_TYPE_MCI(wlpptr)) { //MOCHI - dmemaddr = - readl(wlpptr->ioBase1 + - wlpptr->wlpd_p->reg.FwDbgStateAddr) - - SMAC_DMEM_START; + dmemaddr = wl_util_readl(netdev, wlpptr->ioBase1 + wlpptr->wlpd_p->reg.FwDbgStateAddr) - SMAC_DMEM_START; pfwdbgstate = (void *)(wlpptr->ioBase0 + dmemaddr); memcpy((void *)tmp_data, (void *)(pfwdbgstate + (PFW_DRA_STAT_CNT_OFFSET - 0x10)), @@ -6659,8 +6642,10 @@ wl_show_stat(struct net_device *netdev, #endif } else if (option == (int)drvstatsopt_smac) { SMAC_STATUS_st smacStatus; + wl_util_lock(netdev); memcpy(&smacStatus, wlpptr->smacStatusAddr, sizeof(SMAC_STATUS_st)); + wl_util_unlock(netdev); wl_show_smac_stat(netdev, &smacStatus, sysfs_buff); } else if (option == (int)drvstatsopt_hframe) { wl_show_hframe_info(netdev, sysfs_buff); @@ -6867,14 +6852,12 @@ wlTxSkbTest_1(struct net_device *netdev, { u32 regval; - regval = readl((wlpptr->ioBase1 + - SC5_RQ_WRPTR_REG(qid))); + regval = wl_util_readl(netdev, (wlpptr->ioBase1 + SC5_RQ_WRPTR_REG(qid))); WLDBG_INFO(DBG_LEVEL_4, "RQ, RQ_WRPTR_REG(%d): %p = %08xh\n", qid, (wlpptr->ioBase1 + SC5_RQ_WRPTR_REG(qid)), regval); - regval = readl((wlpptr->ioBase1 + - SC5_RQ_RDPTR_REG(qid))); + regval = wl_util_readl(netdev, (wlpptr->ioBase1 + SC5_RQ_RDPTR_REG(qid))); WLDBG_INFO(DBG_LEVEL_4, "RQ, RQ_RDPTR_REG(%d): %p = %08xh\n", qid, (wlpptr->ioBase1 + SC5_RQ_RDPTR_REG(qid)), @@ -6909,10 +6892,12 @@ idx_test(struct net_device *netdev, long wlpd_p->idx_test_arg.frameType = frameType; //wlTxSkbTest_1(netdev, pktcnt, pkt_size, txqid); + wl_util_lock(netdev); WLDBG_INFO(DBG_LEVEL_0, "\t txInputCnt = %d\n", wlpptr->smacStatusAddr->txInputCnt); WLDBG_INFO(DBG_LEVEL_0, "\t buf_ret_cnt = %d\n", wlpptr->smacStatusAddr->txBufRetCnt); + wl_util_unlock(netdev); WLDBG_INFO(DBG_LEVEL_0, "\t buffer_full_cnt = %d, sent_cnt=%d\n", wlpd_p->drv_stats_val.txq_full_cnt, wlpd_p->drv_stats_val.txq_drv_sent_cnt); diff -uprN a/DRV/wlan-v10/driver/W906x/ap8xLnxCB.c b/DRV/wlan-v10/driver/W906x/ap8xLnxCB.c --- a/DRV/wlan-v10/driver/W906x/ap8xLnxCB.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/W906x/ap8xLnxCB.c 2020-02-07 02:31:21.000000000 -0800 @@ -321,15 +321,17 @@ set_tsf(struct net_device *netdev, uint6 { struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, netdev); struct wlprivate *parent_wlpptr = GET_PARENT_PRIV(wlpptr); - U32 Shal_BcnBuff_val = (parent_wlpptr->bcnBasePtr + - (((SMAC_CTRL_BLK_st *) wlpptr->ioBase0)->status. - maxSizeBcnbuf) * (wlpptr->vap_id)) - DMEM_BASE; - HAL_BEACON_st *pShal_BcnBuff = - (HAL_BEACON_st *) ((u8 *) wlpptr->ioBase0 + Shal_BcnBuff_val); - U8 l_Shal_BcnBuff[offsetof(HAL_BEACON_st, body)]; + U32 Shal_BcnBuff_val = 0; + HAL_BEACON_st* pShal_BcnBuff = NULL; + U8 l_Shal_BcnBuff[offsetof(HAL_BEACON_st,body)]; HAL_BEACON_st *pl_bcnbuf = (HAL_BEACON_st *) l_Shal_BcnBuff; uint64_t start_tsf, timestamp, new_start_tsf; + + wl_util_lock(netdev); + Shal_BcnBuff_val= (parent_wlpptr->bcnBasePtr + + (((SMAC_CTRL_BLK_st*)wlpptr->ioBase0)->status.maxSizeBcnbuf)*(wlpptr->vap_id)) - DMEM_BASE; + pShal_BcnBuff = (HAL_BEACON_st*)((u8*)wlpptr->ioBase0 + Shal_BcnBuff_val); //printk("=>%s(%s), vapid=%u, (base_of_all, len) = %x, %p, %u\n", __func__, netdev->name, wlpptr->vap_id, // parent_wlpptr->bcnBasePtr, // pShal_BcnBuff, @@ -348,6 +350,7 @@ set_tsf(struct net_device *netdev, uint6 pShal_BcnBuff->startTsf[0] = (U32) new_start_tsf; pShal_BcnBuff->startTsf[1] = (U32) (new_start_tsf >> 32); + wl_util_unlock(netdev); return; } diff -uprN a/DRV/wlan-v10/driver/W906x/ap8xLnxEvent.c b/DRV/wlan-v10/driver/W906x/ap8xLnxEvent.c --- a/DRV/wlan-v10/driver/W906x/ap8xLnxEvent.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/W906x/ap8xLnxEvent.c 2020-02-06 19:58:31.000000000 -0800 @@ -119,6 +119,7 @@ wl_WiFi_AoA_Decode(struct work_struct *w AngleInt = (Angle * 360) / (1 << 12); AngleDec = (Angle * 3600) / (1 << 12) - AngleInt * 10; + wl_util_lock(wlpptr->netDev); // Convert CSI RSSI rssi_value[0] = (wlpptr->smacStatusAddr->CSI_RSSI_AB >> 0) & 0xFFF; // A rssi_value[1] = (wlpptr->smacStatusAddr->CSI_RSSI_AB >> 12) & 0xFFF; // B @@ -155,7 +156,8 @@ wl_WiFi_AoA_Decode(struct work_struct *w rssi_value_signed[2], rssi_value_signed[3], rssi_value_signed[4], rssi_value_signed[5], rssi_value_signed[6], rssi_value_signed[7]); - + + wl_util_unlock(wlpptr->netDev); filp_AoA = filp_open("/tmp/AoA_Output.txt", O_RDWR | O_CREAT | O_TRUNC, 0); @@ -249,9 +251,9 @@ wlEventHandler(vmacApInfo_t * vmacSta_p, break; case HOST_EVT_EXCEPTION: { - u32 is_sfw = - (wlpptr->smacStatusAddr->smacSts[7] == - 0x07390000); + u32 is_sfw; + wl_util_lock(netdev); + is_sfw = (wlpptr->smacStatusAddr->smacSts[7] == 0x07390000); wlpptr->wlpd_p->smon.exceptionEvt_rcvd++; printk("%s %s exception event", wlpptr->wlpd_p->rootdev->name, @@ -280,9 +282,11 @@ wlEventHandler(vmacApInfo_t * vmacSta_p, print_hex_dump(KERN_INFO, "", DUMP_PREFIX_OFFSET, 32, 4, (void *)ptr, 64, false); + } else printk("...\n"); - + + wl_util_unlock(netdev); if (wlpdptr->wlmon_task) wake_up_process(wlpdptr->wlmon_task); } diff -uprN a/DRV/wlan-v10/driver/W906x/ap8xLnxMonitor.c b/DRV/wlan-v10/driver/W906x/ap8xLnxMonitor.c --- a/DRV/wlan-v10/driver/W906x/ap8xLnxMonitor.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/W906x/ap8xLnxMonitor.c 2020-02-06 20:49:00.000000000 -0800 @@ -208,17 +208,17 @@ wlmon_ext_trigger_init(struct wlprivate case 1: cp_gpio_base = ioremap(0xF2440000, SZ_4K); // set CP_MPP[59].function = 0x0 - val = readl(cp_gpio_base + 0x01C); + val = wl_util_readl(wlpptr->netDev, cp_gpio_base + 0x01C); val &= 0xFFFF0FFF; - writel(val, cp_gpio_base + 0x01C); + wl_util_writel(wlpptr->netDev, val, cp_gpio_base + 0x01C); // set CP_GPIO[59].Output = 0 - val = readl(cp_gpio_base + 0x140); + val = wl_util_readl(wlpptr->netDev, cp_gpio_base + 0x140); val &= ~(1 << 27); - writel(val, cp_gpio_base + 0x140); + wl_util_writel(wlpptr->netDev, val, cp_gpio_base + 0x140); // set CP_GPIO[59].OE = 0 (active low) - val = readl(cp_gpio_base + 0x144); + val = wl_util_readl(wlpptr->netDev, cp_gpio_base + 0x144); val &= ~(1 << 27); - writel(val, cp_gpio_base + 0x144); + wl_util_writel(wlpptr->netDev, val, cp_gpio_base + 0x144); break; case 2: /* iwpriv wdev1 setcmd "setreg addr 0xb0000a0c 0x0" // GPIO_OUTPUT: bit[1] := 0, set output '0' for GPIO[1] */ @@ -249,9 +249,9 @@ wlmon_ext_trigger_assert(struct net_devi switch (hm_gpio_trigger) { case 1: // set CP_GPIO[59].Output = 1 - val = readl(cp_gpio_base + 0x140); + val = wl_util_readl(netdev, cp_gpio_base + 0x140); val |= (1 << 27); - writel(val, cp_gpio_base + 0x140); + wl_util_writel(netdev, val, cp_gpio_base + 0x140); break; case 2: tlvData[0] = 1; @@ -260,7 +260,7 @@ wlmon_ext_trigger_assert(struct net_devi wlFwGetTLVSet(wlpptr->netDev, 1, 14, 3, tlvData, buff); break; case 3: - writel(2, wlpptr->ioBase1 + 0x13F84); + wl_util_writel(netdev, 2, wlpptr->ioBase1 + 0x13F84); break; default: dev_err(wlpptr->wlpd_p->dev, @@ -277,9 +277,9 @@ wlmon_ext_trigger_deassert(struct wlpriv switch (hm_gpio_trigger) { case 1: // set CP_GPIO[59].Output = 0 - val = readl(cp_gpio_base + 0x140); + val = wl_util_readl(wlpptr->netDev, cp_gpio_base + 0x140); val &= ~(1 << 27); - writel(val, cp_gpio_base + 0x140); + wl_util_writel(wlpptr->netDev, val, cp_gpio_base + 0x140); break; case 2: case 3: @@ -301,9 +301,9 @@ wlmon_ext_trigger_release(struct wlpriva case 1: if (cp_gpio_base) { // set CP_GPIO[59].Output = 0 - val = readl(cp_gpio_base + 0x140); + val = wl_util_readl(wlpptr->netDev, cp_gpio_base + 0x140); val &= ~(1 << 27); - writel(val, cp_gpio_base + 0x140); + wl_util_writel(wlpptr->netDev, val, cp_gpio_base + 0x140); iounmap(cp_gpio_base); cp_gpio_base = NULL; } @@ -393,8 +393,10 @@ wlmon_smac_detect(struct net_device *net smacL = wlpd_p->smon.cm_heartbit; stuckCnt = wlpd_p->smon.cm_stuckcnt; + wl_util_lock(netdev); memcpy((void *)&smac_cur[0], (void *)&wlpptr->smacStatusAddr->smacSts[0], sizeof(smac_cur)); + wl_util_unlock(netdev); //printk("smacCur:%X %X %X %X %X %X %X\n", smac_cur[0],smac_cur[1],smac_cur[2],smac_cur[3],smac_cur[4],smac_cur[5],smac_cur[6]); @@ -1811,7 +1813,7 @@ wlmon_dbg_show_last_cmd_fw_processed(str addr[0] = (wlpptr->ioBase0 + LAST_CMD_FW_PROCESSED_OFFSET); printk("[HM]: LAST_CMD_FW_PROCESSED:[0x2012383C]=0x%08x\n", - readl(addr[0])); + wl_util_readl(netdev, addr[0])); } void @@ -1890,8 +1892,8 @@ wlmon_dbg_show_adma_cmd_status(struct ne addr[0] = (wlpptr->ioBase0 + ADMA_STUCK_CHK_ADDR); addr[1] = (wlpptr->ioBase0 + CMD_CMP_CHK_ADDR); - printk("ADMA:[0x20123830]=0x%08x\n", readl(addr[0])); - printk("CmdStatus:[0x20123838]=%08x\n", readl(addr[1])); + printk("ADMA:[0x20123830]=0x%08x\n", wl_util_readl(netdev, addr[0])); + printk("CmdStatus:[0x20123838]=%08x\n", wl_util_readl(netdev, addr[1])); } else { u32 *pbuf = NULL; @@ -1914,8 +1916,8 @@ wlmon_dbg_show_adma_cmd_status(struct ne addr[2] = (wlpptr->ioBase1 + EU_FABRIC_STATUS); addr[3] = (wlpptr->ioBase1 + EU_SM_STATUS); - printk("EU FABRIC:[0x9001ABA8]=0x%08x\n", readl(addr[2])); - printk("EU SM:[0x9001C2F4]=0x%08x\n", readl(addr[3])); + printk("EU FABRIC:[0x9001ABA8]=0x%08x\n", wl_util_readl(netdev, addr[2])); + printk("EU SM:[0x9001C2F4]=0x%08x\n", wl_util_readl(netdev, addr[3])); } int @@ -1948,10 +1950,7 @@ wlmon_pfw_alive_counters_detct(struct ne if (wlpptr->wlpd_p->bus_type == BUS_TYPE_MCI) { //MOCHI - dmemaddr = - readl(wlpptr->ioBase1 + - wlpptr->wlpd_p->reg.FwDbgStateAddr) - - SMAC_DMEM_START; + dmemaddr = wl_util_readl(netdev, wlpptr->ioBase1 + wlpptr->wlpd_p->reg.FwDbgStateAddr) - SMAC_DMEM_START; pfwdbgstate = (void *)(wlpptr->ioBase0 + dmemaddr); memcpy((void *)newcnt, (void *)(pfwdbgstate + PFW_ALIVE_CNT_OFFSET), @@ -2138,8 +2137,8 @@ get_mci_errcnt(struct wlprivate * wlpptr regval = 0x40021; //printk("%s(), Write %p = %08x\n", __func__, wlpptr->ioBaseExt+0x04, regval); - writel(regval, wlpptr->ioBaseExt + 0x04); - regval = readl(wlpptr->ioBaseExt + 0x00); + wl_util_writel(wlpptr->netDev, regval, wlpptr->ioBaseExt+0x04); + regval = wl_util_readl(wlpptr->netDev, wlpptr->ioBaseExt + 0x00); //printk("%s(), Read %p = %08x\n", __func__, wlpptr->ioBaseExt+0x00, regval); return (regval & 0xFF); @@ -2737,10 +2736,7 @@ wlmon_dump_hw_regsiters(struct wlprivate str_len += sprintf(&plog[str_len], "--------"); //printk("%s():PCIE: reg_addr_offset: %x\n",__func__, reg_addr_offset); } else { - str_len += - sprintf(&plog[str_len], "%08x", - readl(wlpptr->ioBase1 + - reg_addr_offset)); + str_len += sprintf(&plog[str_len], "%08x", wl_util_readl(wlpptr->netDev, wlpptr->ioBase1 + reg_addr_offset)); } } @@ -3727,9 +3723,10 @@ wlmon_kthread(void *arg) DELAY_COREDUMP_TIME; if (wlpd_p->smon.exceptionEvt_rcvd) { - u32 is_sfw = - (wlpptr->smacStatusAddr->smacSts[7] == - 0x07390000); + u32 is_sfw; + wl_util_lock(netdev); + is_sfw = (wlpptr->smacStatusAddr->smacSts[7] == 0x07390000); + wl_util_unlock(netdev); wlmon_ext_trigger_assert(netdev); printk("%s CoreDump of receiving %s exception event:\n", wlpd_p->rootdev->name, is_sfw ? "SFW" : "PFW"); //print drv/fw version number @@ -3818,8 +3815,10 @@ wlmon_kthread(void *arg) if (wlpd_p->smon.ActiveIf && pCurSmacStatus) { UINT64 tms; + wl_util_lock(netdev); memcpy(pCurSmacStatus, wlpptr->smacStatusAddr, sizeof(SMAC_STATUS_st)); + wl_util_unlock(netdev); convert_tscale(xxGetTimeStamp(), NULL, &tms, NULL); wlpd_p->smon.smacStsLogtime[1] = tms; //record ms timetick of pCurSmacStatus diff -uprN a/DRV/wlan-v10/driver/W906x/ap8xLnxUtil.c b/DRV/wlan-v10/driver/W906x/ap8xLnxUtil.c --- a/DRV/wlan-v10/driver/W906x/ap8xLnxUtil.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/W906x/ap8xLnxUtil.c 2020-02-06 23:25:17.000000000 -0800 @@ -32,6 +32,9 @@ /** internal functions **/ /** public data **/ +extern int rddelay; +extern int wrdelay; +extern int intmode; /** private data **/ @@ -1647,3 +1650,59 @@ wl_util_get_rssi(struct net_device * net } return signed_rssi; } + + +void wl_util_lock(struct net_device *ndev) +{ + struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, ndev); + struct wlprivate_data *wlpd_p = wlpptr->wlpd_p; + + if (intmode == 0) + return; + spin_lock_irqsave(&wlpd_p->pcie_iolock, wlpd_p->ioflags); +} + +void wl_util_unlock(struct net_device *ndev) +{ + struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, ndev); + struct wlprivate_data *wlpd_p = wlpptr->wlpd_p; + + if (intmode == 0) + return; + spin_unlock_irqrestore(&wlpd_p->pcie_iolock, wlpd_p->ioflags); +} + +void wl_util_writel(struct net_device *ndev, u32 v, u32 *c) +{ + struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, ndev); + struct wlprivate_data *wlpd_p = wlpptr->wlpd_p; + + if (intmode == 0) { + writel(v, c); + return; + } + spin_lock_irqsave(&wlpd_p->pcie_iolock, wlpd_p->ioflags); + writel(v, c); + if (wrdelay) + udelay(wrdelay); + spin_unlock_irqrestore(&wlpd_p->pcie_iolock, wlpd_p->ioflags); +} + +u32 wl_util_readl(struct net_device *ndev, const volatile void *c) +{ + u32 v; + struct wlprivate *wlpptr = NETDEV_PRIV_P(struct wlprivate, ndev); + struct wlprivate_data *wlpd_p = wlpptr->wlpd_p; + + if (intmode == 0) { + v = readl(c); + return v; + } + spin_lock_irqsave(&wlpd_p->pcie_iolock, wlpd_p->ioflags); + v = readl(c); + if (rddelay) + udelay(rddelay); + spin_unlock_irqrestore(&wlpd_p->pcie_iolock, wlpd_p->ioflags); + return v; +} + diff -uprN a/DRV/wlan-v10/driver/W906x/ap8xLnxUtil.h b/DRV/wlan-v10/driver/W906x/ap8xLnxUtil.h --- a/DRV/wlan-v10/driver/W906x/ap8xLnxUtil.h 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/W906x/ap8xLnxUtil.h 2020-02-06 23:59:02.000000000 -0800 @@ -206,6 +206,12 @@ void wl_util_dma_free_coherent(struct de extern ssize_t ap8x_kernel_read(struct file *, void *, size_t, loff_t *); #endif +void wl_util_lock(struct net_device *ndev); +void wl_util_unlock(struct net_device *ndev); +void wl_util_writel(struct net_device *ndev, u32 v, u32 *c); +u32 wl_util_readl(struct net_device *ndev, const volatile void *c); + + /* Get free memory info in percentage */ extern u32 ap8x_get_free_sys_mem_info(void); diff -uprN a/DRV/wlan-v10/driver/W906x/ap8xLnxXmit.c b/DRV/wlan-v10/driver/W906x/ap8xLnxXmit.c --- a/DRV/wlan-v10/driver/W906x/ap8xLnxXmit.c 2020-01-16 04:07:33.000000000 -0800 +++ b/DRV/wlan-v10/driver/W906x/ap8xLnxXmit.c 2020-02-06 21:25:01.000000000 -0800 @@ -528,7 +528,7 @@ wlDataTx(struct sk_buff *skb, struct net txqlimit = qosctrl_txQLimit; /* QUEUE_STATS: time stamp the start time of the packet */ - WLDBG_SET_PKT_TIMESTAMP(skb); + WLDBG_SET_PKT_TIMESTAMP(skb, netdev); #ifdef QUEUE_STATS_CNT_HIST pEth = (struct ether_header *)skb->data; /* track per sta tx count */