wait_bit: use wait_for_bit_le32 and remove wait_for_bit

wait_for_bit callers use the 32 bit LE version

Signed-off-by: Álvaro Fernández Rojas <noltari@gmail.com>
Reviewed-by: Daniel Schwierzeck <daniel.schwierzeck@gmail.com>
Reviewed-by: Jagan Teki <jagan@openedev.com>
This commit is contained in:
Álvaro Fernández Rojas 2018-01-23 17:14:55 +01:00 committed by Jagan Teki
parent 91fe458bbf
commit 48263504c8
33 changed files with 205 additions and 263 deletions

View File

@ -21,10 +21,10 @@ static void reset_read_data_fifos(void)
/* Reset data FIFOs twice. */ /* Reset data FIFOs twice. */
setbits_le32(&mmdc0->mpdgctrl0, 1 << 31); setbits_le32(&mmdc0->mpdgctrl0, 1 << 31);
wait_for_bit("MMDC", &mmdc0->mpdgctrl0, 1 << 31, 0, 100, 0); wait_for_bit_le32(&mmdc0->mpdgctrl0, 1 << 31, 0, 100, 0);
setbits_le32(&mmdc0->mpdgctrl0, 1 << 31); setbits_le32(&mmdc0->mpdgctrl0, 1 << 31);
wait_for_bit("MMDC", &mmdc0->mpdgctrl0, 1 << 31, 0, 100, 0); wait_for_bit_le32(&mmdc0->mpdgctrl0, 1 << 31, 0, 100, 0);
} }
static void precharge_all(const bool cs0_enable, const bool cs1_enable) static void precharge_all(const bool cs0_enable, const bool cs1_enable)
@ -39,12 +39,12 @@ static void precharge_all(const bool cs0_enable, const bool cs1_enable)
*/ */
if (cs0_enable) { /* CS0 */ if (cs0_enable) { /* CS0 */
writel(0x04008050, &mmdc0->mdscr); writel(0x04008050, &mmdc0->mdscr);
wait_for_bit("MMDC", &mmdc0->mdscr, 1 << 14, 1, 100, 0); wait_for_bit_le32(&mmdc0->mdscr, 1 << 14, 1, 100, 0);
} }
if (cs1_enable) { /* CS1 */ if (cs1_enable) { /* CS1 */
writel(0x04008058, &mmdc0->mdscr); writel(0x04008058, &mmdc0->mdscr);
wait_for_bit("MMDC", &mmdc0->mdscr, 1 << 14, 1, 100, 0); wait_for_bit_le32(&mmdc0->mdscr, 1 << 14, 1, 100, 0);
} }
} }
@ -146,7 +146,7 @@ int mmdc_do_write_level_calibration(struct mx6_ddr_sysinfo const *sysinfo)
* 7. Upon completion of this process the MMDC de-asserts * 7. Upon completion of this process the MMDC de-asserts
* the MPWLGCR[HW_WL_EN] * the MPWLGCR[HW_WL_EN]
*/ */
wait_for_bit("MMDC", &mmdc0->mpwlgcr, 1 << 0, 0, 100, 0); wait_for_bit_le32(&mmdc0->mpwlgcr, 1 << 0, 0, 100, 0);
/* /*
* 8. check for any errors: check both PHYs for x64 configuration, * 8. check for any errors: check both PHYs for x64 configuration,
@ -278,7 +278,7 @@ int mmdc_do_dqs_calibration(struct mx6_ddr_sysinfo const *sysinfo)
writel(0x00008028, &mmdc0->mdscr); writel(0x00008028, &mmdc0->mdscr);
/* poll to make sure the con_ack bit was asserted */ /* poll to make sure the con_ack bit was asserted */
wait_for_bit("MMDC", &mmdc0->mdscr, 1 << 14, 1, 100, 0); wait_for_bit_le32(&mmdc0->mdscr, 1 << 14, 1, 100, 0);
/* /*
* Check MDMISC register CALIB_PER_CS to see which CS calibration * Check MDMISC register CALIB_PER_CS to see which CS calibration
@ -312,7 +312,7 @@ int mmdc_do_dqs_calibration(struct mx6_ddr_sysinfo const *sysinfo)
* this bit until it clears to indicate completion of the write access. * this bit until it clears to indicate completion of the write access.
*/ */
setbits_le32(&mmdc0->mpswdar0, 1); setbits_le32(&mmdc0->mpswdar0, 1);
wait_for_bit("MMDC", &mmdc0->mpswdar0, 1 << 0, 0, 100, 0); wait_for_bit_le32(&mmdc0->mpswdar0, 1 << 0, 0, 100, 0);
/* Set the RD_DL_ABS# bits to their default values /* Set the RD_DL_ABS# bits to their default values
* (will be calibrated later in the read delay-line calibration). * (will be calibrated later in the read delay-line calibration).
@ -359,7 +359,7 @@ int mmdc_do_dqs_calibration(struct mx6_ddr_sysinfo const *sysinfo)
setbits_le32(&mmdc0->mpdgctrl0, 5 << 28); setbits_le32(&mmdc0->mpdgctrl0, 5 << 28);
/* Poll for completion. MPDGCTRL0[HW_DG_EN] should be 0 */ /* Poll for completion. MPDGCTRL0[HW_DG_EN] should be 0 */
wait_for_bit("MMDC", &mmdc0->mpdgctrl0, 1 << 28, 0, 100, 0); wait_for_bit_le32(&mmdc0->mpdgctrl0, 1 << 28, 0, 100, 0);
/* /*
* Check to see if any errors were encountered during calibration * Check to see if any errors were encountered during calibration
@ -423,7 +423,7 @@ int mmdc_do_dqs_calibration(struct mx6_ddr_sysinfo const *sysinfo)
* setting MPRDDLHWCTL[HW_RD_DL_EN] = 0. Also, ensure that * setting MPRDDLHWCTL[HW_RD_DL_EN] = 0. Also, ensure that
* no error bits were set. * no error bits were set.
*/ */
wait_for_bit("MMDC", &mmdc0->mprddlhwctl, 1 << 4, 0, 100, 0); wait_for_bit_le32(&mmdc0->mprddlhwctl, 1 << 4, 0, 100, 0);
/* check both PHYs for x64 configuration, if x32, check only PHY0 */ /* check both PHYs for x64 configuration, if x32, check only PHY0 */
if (readl(&mmdc0->mprddlhwctl) & 0x0000000f) if (readl(&mmdc0->mprddlhwctl) & 0x0000000f)
@ -477,7 +477,7 @@ int mmdc_do_dqs_calibration(struct mx6_ddr_sysinfo const *sysinfo)
* by setting MPWRDLHWCTL[HW_WR_DL_EN] = 0. * by setting MPWRDLHWCTL[HW_WR_DL_EN] = 0.
* Also, ensure that no error bits were set. * Also, ensure that no error bits were set.
*/ */
wait_for_bit("MMDC", &mmdc0->mpwrdlhwctl, 1 << 4, 0, 100, 0); wait_for_bit_le32(&mmdc0->mpwrdlhwctl, 1 << 4, 0, 100, 0);
/* Check both PHYs for x64 configuration, if x32, check only PHY0 */ /* Check both PHYs for x64 configuration, if x32, check only PHY0 */
if (readl(&mmdc0->mpwrdlhwctl) & 0x0000000f) if (readl(&mmdc0->mpwrdlhwctl) & 0x0000000f)
@ -526,7 +526,7 @@ int mmdc_do_dqs_calibration(struct mx6_ddr_sysinfo const *sysinfo)
writel(0x0, &mmdc0->mdscr); /* CS0 */ writel(0x0, &mmdc0->mdscr); /* CS0 */
/* Poll to make sure the con_ack bit is clear */ /* Poll to make sure the con_ack bit is clear */
wait_for_bit("MMDC", &mmdc0->mdscr, 1 << 14, 0, 100, 0); wait_for_bit_le32(&mmdc0->mdscr, 1 << 14, 0, 100, 0);
/* /*
* Print out the registers that were updated as a result * Print out the registers that were updated as a result

View File

@ -37,8 +37,8 @@ void cm_wait_for_lock(u32 mask)
/* function to poll in the fsm busy bit */ /* function to poll in the fsm busy bit */
int cm_wait_for_fsm(void) int cm_wait_for_fsm(void)
{ {
return wait_for_bit(__func__, (const u32 *)&clock_manager_base->stat, return wait_for_bit_le32(&clock_manager_base->stat,
CLKMGR_STAT_BUSY, false, 20000, false); CLKMGR_STAT_BUSY, false, 20000, false);
} }
int set_cpu_clk_info(void) int set_cpu_clk_info(void)

View File

@ -37,15 +37,13 @@ static int cm_write_with_phase(u32 value, u32 reg_address, u32 mask)
int ret; int ret;
/* poll until phase is zero */ /* poll until phase is zero */
ret = wait_for_bit(__func__, (const u32 *)reg_address, mask, ret = wait_for_bit_le32(reg_address, mask, false, 20000, false);
false, 20000, false);
if (ret) if (ret)
return ret; return ret;
writel(value, reg_address); writel(value, reg_address);
return wait_for_bit(__func__, (const u32 *)reg_address, mask, return wait_for_bit_le32(reg_address, mask, false, 20000, false);
false, 20000, false);
} }
/* /*

View File

@ -222,8 +222,8 @@ int socfpga_reset_deassert_bridges_handoff(void)
clrbits_le32(&reset_manager_base->brgmodrst, mask_rstmgr); clrbits_le32(&reset_manager_base->brgmodrst, mask_rstmgr);
/* Poll until all idleack to 0, timeout at 1000ms */ /* Poll until all idleack to 0, timeout at 1000ms */
return wait_for_bit(__func__, &sysmgr_regs->noc_idleack, mask_noc, return wait_for_bit_le32(&sysmgr_regs->noc_idleack, mask_noc,
false, 1000, false); false, 1000, false);
} }
void socfpga_reset_assert_fpga_connected_peripherals(void) void socfpga_reset_assert_fpga_connected_peripherals(void)
@ -343,26 +343,26 @@ int socfpga_bridges_reset(void)
writel(ALT_SYSMGR_NOC_TMO_EN_SET_MSK, &sysmgr_regs->noc_timeout); writel(ALT_SYSMGR_NOC_TMO_EN_SET_MSK, &sysmgr_regs->noc_timeout);
/* Poll until all idleack to 1 */ /* Poll until all idleack to 1 */
ret = wait_for_bit(__func__, &sysmgr_regs->noc_idleack, ret = wait_for_bit_le32(&sysmgr_regs->noc_idleack,
ALT_SYSMGR_NOC_H2F_SET_MSK | ALT_SYSMGR_NOC_H2F_SET_MSK |
ALT_SYSMGR_NOC_LWH2F_SET_MSK | ALT_SYSMGR_NOC_LWH2F_SET_MSK |
ALT_SYSMGR_NOC_F2H_SET_MSK | ALT_SYSMGR_NOC_F2H_SET_MSK |
ALT_SYSMGR_NOC_F2SDR0_SET_MSK | ALT_SYSMGR_NOC_F2SDR0_SET_MSK |
ALT_SYSMGR_NOC_F2SDR1_SET_MSK | ALT_SYSMGR_NOC_F2SDR1_SET_MSK |
ALT_SYSMGR_NOC_F2SDR2_SET_MSK, ALT_SYSMGR_NOC_F2SDR2_SET_MSK,
true, 10000, false); true, 10000, false);
if (ret) if (ret)
return ret; return ret;
/* Poll until all idlestatus to 1 */ /* Poll until all idlestatus to 1 */
ret = wait_for_bit(__func__, &sysmgr_regs->noc_idlestatus, ret = wait_for_bit_le32(&sysmgr_regs->noc_idlestatus,
ALT_SYSMGR_NOC_H2F_SET_MSK | ALT_SYSMGR_NOC_H2F_SET_MSK |
ALT_SYSMGR_NOC_LWH2F_SET_MSK | ALT_SYSMGR_NOC_LWH2F_SET_MSK |
ALT_SYSMGR_NOC_F2H_SET_MSK | ALT_SYSMGR_NOC_F2H_SET_MSK |
ALT_SYSMGR_NOC_F2SDR0_SET_MSK | ALT_SYSMGR_NOC_F2SDR0_SET_MSK |
ALT_SYSMGR_NOC_F2SDR1_SET_MSK | ALT_SYSMGR_NOC_F2SDR1_SET_MSK |
ALT_SYSMGR_NOC_F2SDR2_SET_MSK, ALT_SYSMGR_NOC_F2SDR2_SET_MSK,
true, 10000, false); true, 10000, false);
if (ret) if (ret)
return ret; return ret;

View File

@ -90,7 +90,7 @@ static void ar934x_srif_pll_cfg(void __iomem *pll_reg_base, const u32 srif_val)
setbits_be32(pll_reg_base + 0x8, BIT(30)); setbits_be32(pll_reg_base + 0x8, BIT(30));
udelay(5); udelay(5);
wait_for_bit("clk", pll_reg_base + 0xc, BIT(3), 1, 10, 0); wait_for_bit_le32(pll_reg_base + 0xc, BIT(3), 1, 10, 0);
clrbits_be32(pll_reg_base + 0x8, BIT(30)); clrbits_be32(pll_reg_base + 0x8, BIT(30));
udelay(5); udelay(5);

View File

@ -378,7 +378,7 @@ static int read_adc(u32 *val)
/* start auto calibration */ /* start auto calibration */
setbits_le32(b + ADCx_GC, ADCx_GC_CAL); setbits_le32(b + ADCx_GC, ADCx_GC_CAL);
ret = wait_for_bit("ADC", b + ADCx_GC, ADCx_GC_CAL, ADCx_GC_CAL, 10, 0); ret = wait_for_bit_le32(b + ADCx_GC, ADCx_GC_CAL, ADCx_GC_CAL, 10, 0);
if (ret) if (ret)
goto adc_exit; goto adc_exit;
@ -386,7 +386,7 @@ static int read_adc(u32 *val)
writel(0, b + ADCx_HC0); writel(0, b + ADCx_HC0);
/* wait for conversion */ /* wait for conversion */
ret = wait_for_bit("ADC", b + ADCx_HS, ADCx_HS_C0, ADCx_HS_C0, 10, 0); ret = wait_for_bit_le32(b + ADCx_HS, ADCx_HS_C0, ADCx_HS_C0, 10, 0);
if (ret) if (ret)
goto adc_exit; goto adc_exit;

View File

@ -197,8 +197,8 @@ static ulong pic32_set_refclk(struct pic32_clk_priv *priv, int periph,
writel(REFO_ON | REFO_OE, reg + _CLR_OFFSET); writel(REFO_ON | REFO_OE, reg + _CLR_OFFSET);
/* wait till previous src change is active */ /* wait till previous src change is active */
wait_for_bit(__func__, reg, REFO_DIVSW_EN | REFO_ACTIVE, wait_for_bit_le32(reg, REFO_DIVSW_EN | REFO_ACTIVE,
false, CONFIG_SYS_HZ, false); false, CONFIG_SYS_HZ, false);
/* parent_id */ /* parent_id */
v = readl(reg); v = readl(reg);
@ -223,8 +223,8 @@ static ulong pic32_set_refclk(struct pic32_clk_priv *priv, int periph,
writel(REFO_DIVSW_EN, reg + _SET_OFFSET); writel(REFO_DIVSW_EN, reg + _SET_OFFSET);
/* wait for divider switching to complete */ /* wait for divider switching to complete */
return wait_for_bit(__func__, reg, REFO_DIVSW_EN, false, return wait_for_bit_le32(reg, REFO_DIVSW_EN, false,
CONFIG_SYS_HZ, false); CONFIG_SYS_HZ, false);
} }
static ulong pic32_get_refclk(struct pic32_clk_priv *priv, int periph) static ulong pic32_get_refclk(struct pic32_clk_priv *priv, int periph)
@ -311,8 +311,8 @@ static int pic32_mpll_init(struct pic32_clk_priv *priv)
/* Wait for ready */ /* Wait for ready */
mask = MPLL_RDY | MPLL_VREG_RDY; mask = MPLL_RDY | MPLL_VREG_RDY;
return wait_for_bit(__func__, priv->syscfg_base + CFGMPLL, mask, return wait_for_bit_le32(priv->syscfg_base + CFGMPLL, mask,
true, get_tbclk(), false); true, get_tbclk(), false);
} }
static void pic32_clk_init(struct udevice *dev) static void pic32_clk_init(struct udevice *dev)

View File

@ -1046,8 +1046,8 @@ static int gen3_clk_endisable(struct clk *clk, bool enable)
if (ret) if (ret)
return ret; return ret;
clrbits_le32(priv->base + SMSTPCR(reg), bitmask); clrbits_le32(priv->base + SMSTPCR(reg), bitmask);
return wait_for_bit("MSTP", priv->base + MSTPSR(reg), return wait_for_bit_le32(priv->base + MSTPSR(reg),
bitmask, 0, 100, 0); bitmask, 0, 100, 0);
} else { } else {
setbits_le32(priv->base + SMSTPCR(reg), bitmask); setbits_le32(priv->base + SMSTPCR(reg), bitmask);
return 0; return 0;

View File

@ -57,8 +57,8 @@ static int ddr2_phy_calib_start(void)
writel(SCL_START | SCL_EN, &ddr2_phy->scl_start); writel(SCL_START | SCL_EN, &ddr2_phy->scl_start);
/* Wait for SCL for data byte to pass */ /* Wait for SCL for data byte to pass */
return wait_for_bit(__func__, &ddr2_phy->scl_start, SCL_LUBPASS, return wait_for_bit_le32(&ddr2_phy->scl_start, SCL_LUBPASS,
true, CONFIG_SYS_HZ, false); true, CONFIG_SYS_HZ, false);
} }
/* DDR2 Controller initialization */ /* DDR2 Controller initialization */
@ -256,8 +256,8 @@ void ddr2_ctrl_init(void)
writel(INIT_START, &ctrl->memcon); writel(INIT_START, &ctrl->memcon);
/* wait for all host cmds to be transmitted */ /* wait for all host cmds to be transmitted */
wait_for_bit(__func__, &ctrl->cmdissue, CMD_VALID, false, wait_for_bit_le32(&ctrl->cmdissue, CMD_VALID, false,
CONFIG_SYS_HZ, false); CONFIG_SYS_HZ, false);
/* inform all cmds issued, ready for normal operation */ /* inform all cmds issued, ready for normal operation */
writel(INIT_START | INIT_DONE, &ctrl->memcon); writel(INIT_START | INIT_DONE, &ctrl->memcon);

View File

@ -62,8 +62,7 @@ int is_fpgamgr_user_mode(void)
static int wait_for_user_mode(void) static int wait_for_user_mode(void)
{ {
return wait_for_bit(__func__, return wait_for_bit_le32(&fpga_manager_base->imgcfg_stat,
&fpga_manager_base->imgcfg_stat,
ALT_FPGAMGR_IMGCFG_STAT_F2S_USERMODE_SET_MSK, ALT_FPGAMGR_IMGCFG_STAT_F2S_USERMODE_SET_MSK,
1, FPGA_TIMEOUT_MSEC, false); 1, FPGA_TIMEOUT_MSEC, false);
} }
@ -115,19 +114,17 @@ static int wait_for_nconfig_pin_and_nstatus_pin(void)
/* Poll until f2s_nconfig_pin and f2s_nstatus_pin; loop until de-asserted, /* Poll until f2s_nconfig_pin and f2s_nstatus_pin; loop until de-asserted,
* timeout at 1000ms * timeout at 1000ms
*/ */
return wait_for_bit(__func__, return wait_for_bit_le32(&fpga_manager_base->imgcfg_stat,
&fpga_manager_base->imgcfg_stat, mask,
mask, false, FPGA_TIMEOUT_MSEC, false);
false, FPGA_TIMEOUT_MSEC, false);
} }
static int wait_for_f2s_nstatus_pin(unsigned long value) static int wait_for_f2s_nstatus_pin(unsigned long value)
{ {
/* Poll until f2s to specific value, timeout at 1000ms */ /* Poll until f2s to specific value, timeout at 1000ms */
return wait_for_bit(__func__, return wait_for_bit_le32(&fpga_manager_base->imgcfg_stat,
&fpga_manager_base->imgcfg_stat, ALT_FPGAMGR_IMGCFG_STAT_F2S_NSTATUS_PIN_SET_MSK,
ALT_FPGAMGR_IMGCFG_STAT_F2S_NSTATUS_PIN_SET_MSK, value, FPGA_TIMEOUT_MSEC, false);
value, FPGA_TIMEOUT_MSEC, false);
} }
/* set CD ratio */ /* set CD ratio */

View File

@ -109,15 +109,15 @@ static int msm_sdc_probe(struct udevice *dev)
/* Wait for reset to be written to register */ /* Wait for reset to be written to register */
if (wait_for_bit(__func__, prv->base + SDCC_MCI_STATUS2, if (wait_for_bit_le32(prv->base + SDCC_MCI_STATUS2,
SDCC_MCI_STATUS2_MCI_ACT, false, 10, false)) { SDCC_MCI_STATUS2_MCI_ACT, false, 10, false)) {
printf("msm_sdhci: reset request failed\n"); printf("msm_sdhci: reset request failed\n");
return -EIO; return -EIO;
} }
/* SW reset can take upto 10HCLK + 15MCLK cycles. (min 40us) */ /* SW reset can take upto 10HCLK + 15MCLK cycles. (min 40us) */
if (wait_for_bit(__func__, prv->base + SDCC_MCI_POWER, if (wait_for_bit_le32(prv->base + SDCC_MCI_POWER,
SDCC_MCI_POWER_SW_RST, false, 2, false)) { SDCC_MCI_POWER_SW_RST, false, 2, false)) {
printf("msm_sdhci: stuck in reset\n"); printf("msm_sdhci: stuck in reset\n");
return -ETIMEDOUT; return -ETIMEDOUT;
} }

View File

@ -66,8 +66,8 @@ static inline void flash_initiate_operation(u32 nvmop)
static int flash_wait_till_busy(const char *func, ulong timeout) static int flash_wait_till_busy(const char *func, ulong timeout)
{ {
int ret = wait_for_bit(__func__, &nvm_regs_p->ctrl.raw, int ret = wait_for_bit_le32(&nvm_regs_p->ctrl.raw,
NVM_WR, false, timeout, false); NVM_WR, false, timeout, false);
return ret ? ERR_TIMOUT : ERR_OK; return ret ? ERR_TIMOUT : ERR_OK;
} }

View File

@ -164,8 +164,8 @@ static int ag7xxx_switch_read(struct mii_dev *bus, int addr, int reg, u16 *val)
writel(AG7XXX_ETH_MII_MGMT_CMD_READ, writel(AG7XXX_ETH_MII_MGMT_CMD_READ,
regs + AG7XXX_ETH_MII_MGMT_CMD); regs + AG7XXX_ETH_MII_MGMT_CMD);
ret = wait_for_bit("ag7xxx", regs + AG7XXX_ETH_MII_MGMT_IND, ret = wait_for_bit_le32(regs + AG7XXX_ETH_MII_MGMT_IND,
AG7XXX_ETH_MII_MGMT_IND_BUSY, 0, 1000, 0); AG7XXX_ETH_MII_MGMT_IND_BUSY, 0, 1000, 0);
if (ret) if (ret)
return ret; return ret;
@ -185,8 +185,8 @@ static int ag7xxx_switch_write(struct mii_dev *bus, int addr, int reg, u16 val)
regs + AG7XXX_ETH_MII_MGMT_ADDRESS); regs + AG7XXX_ETH_MII_MGMT_ADDRESS);
writel(val, regs + AG7XXX_ETH_MII_MGMT_CTRL); writel(val, regs + AG7XXX_ETH_MII_MGMT_CTRL);
ret = wait_for_bit("ag7xxx", regs + AG7XXX_ETH_MII_MGMT_IND, ret = wait_for_bit_le32(regs + AG7XXX_ETH_MII_MGMT_IND,
AG7XXX_ETH_MII_MGMT_IND_BUSY, 0, 1000, 0); AG7XXX_ETH_MII_MGMT_IND_BUSY, 0, 1000, 0);
return ret; return ret;
} }
@ -510,13 +510,13 @@ static void ag7xxx_eth_stop(struct udevice *dev)
/* Stop the TX DMA. */ /* Stop the TX DMA. */
writel(0, priv->regs + AG7XXX_ETH_DMA_TX_CTRL); writel(0, priv->regs + AG7XXX_ETH_DMA_TX_CTRL);
wait_for_bit("ag7xxx", priv->regs + AG7XXX_ETH_DMA_TX_CTRL, ~0, 0, wait_for_bit_le32(priv->regs + AG7XXX_ETH_DMA_TX_CTRL, ~0, 0,
1000, 0); 1000, 0);
/* Stop the RX DMA. */ /* Stop the RX DMA. */
writel(0, priv->regs + AG7XXX_ETH_DMA_RX_CTRL); writel(0, priv->regs + AG7XXX_ETH_DMA_RX_CTRL);
wait_for_bit("ag7xxx", priv->regs + AG7XXX_ETH_DMA_RX_CTRL, ~0, 0, wait_for_bit_le32(priv->regs + AG7XXX_ETH_DMA_RX_CTRL, ~0, 0,
1000, 0); 1000, 0);
} }
/* /*

View File

@ -361,8 +361,9 @@ static void eqos_flush_buffer(void *buf, size_t size)
static int eqos_mdio_wait_idle(struct eqos_priv *eqos) static int eqos_mdio_wait_idle(struct eqos_priv *eqos)
{ {
return wait_for_bit(__func__, &eqos->mac_regs->mdio_address, return wait_for_bit_le32(&eqos->mac_regs->mdio_address,
EQOS_MAC_MDIO_ADDRESS_GB, false, 1000000, true); EQOS_MAC_MDIO_ADDRESS_GB, false,
1000000, true);
} }
static int eqos_mdio_read(struct mii_dev *bus, int mdio_addr, int mdio_devad, static int eqos_mdio_read(struct mii_dev *bus, int mdio_addr, int mdio_devad,
@ -588,15 +589,15 @@ static int eqos_calibrate_pads_tegra186(struct udevice *dev)
setbits_le32(&eqos->tegra186_regs->auto_cal_config, setbits_le32(&eqos->tegra186_regs->auto_cal_config,
EQOS_AUTO_CAL_CONFIG_START | EQOS_AUTO_CAL_CONFIG_ENABLE); EQOS_AUTO_CAL_CONFIG_START | EQOS_AUTO_CAL_CONFIG_ENABLE);
ret = wait_for_bit(__func__, &eqos->tegra186_regs->auto_cal_status, ret = wait_for_bit_le32(&eqos->tegra186_regs->auto_cal_status,
EQOS_AUTO_CAL_STATUS_ACTIVE, true, 10, false); EQOS_AUTO_CAL_STATUS_ACTIVE, true, 10, false);
if (ret) { if (ret) {
pr_err("calibrate didn't start"); pr_err("calibrate didn't start");
goto failed; goto failed;
} }
ret = wait_for_bit(__func__, &eqos->tegra186_regs->auto_cal_status, ret = wait_for_bit_le32(&eqos->tegra186_regs->auto_cal_status,
EQOS_AUTO_CAL_STATUS_ACTIVE, false, 10, false); EQOS_AUTO_CAL_STATUS_ACTIVE, false, 10, false);
if (ret) { if (ret) {
pr_err("calibrate didn't finish"); pr_err("calibrate didn't finish");
goto failed; goto failed;
@ -862,8 +863,8 @@ static int eqos_start(struct udevice *dev)
eqos->reg_access_ok = true; eqos->reg_access_ok = true;
ret = wait_for_bit(__func__, &eqos->dma_regs->mode, ret = wait_for_bit_le32(&eqos->dma_regs->mode,
EQOS_DMA_MODE_SWR, false, 10, false); EQOS_DMA_MODE_SWR, false, 10, false);
if (ret) { if (ret) {
pr_err("EQOS_DMA_MODE_SWR stuck"); pr_err("EQOS_DMA_MODE_SWR stuck");
goto err_stop_resets; goto err_stop_resets;

View File

@ -548,8 +548,8 @@ static int ethoc_mdio_read(struct mii_dev *bus, int addr, int devad, int reg)
ethoc_write(priv, MIIADDRESS, MIIADDRESS_ADDR(addr, reg)); ethoc_write(priv, MIIADDRESS, MIIADDRESS_ADDR(addr, reg));
ethoc_write(priv, MIICOMMAND, MIICOMMAND_READ); ethoc_write(priv, MIICOMMAND, MIICOMMAND_READ);
rc = wait_for_bit(__func__, ethoc_reg(priv, MIISTATUS), rc = wait_for_bit_le32(ethoc_reg(priv, MIISTATUS),
MIISTATUS_BUSY, false, CONFIG_SYS_HZ, false); MIISTATUS_BUSY, false, CONFIG_SYS_HZ, false);
if (rc == 0) { if (rc == 0) {
u32 data = ethoc_read(priv, MIIRX_DATA); u32 data = ethoc_read(priv, MIIRX_DATA);
@ -571,8 +571,8 @@ static int ethoc_mdio_write(struct mii_dev *bus, int addr, int devad, int reg,
ethoc_write(priv, MIITX_DATA, val); ethoc_write(priv, MIITX_DATA, val);
ethoc_write(priv, MIICOMMAND, MIICOMMAND_WRITE); ethoc_write(priv, MIICOMMAND, MIICOMMAND_WRITE);
rc = wait_for_bit(__func__, ethoc_reg(priv, MIISTATUS), rc = wait_for_bit_le32(ethoc_reg(priv, MIISTATUS),
MIISTATUS_BUSY, false, CONFIG_SYS_HZ, false); MIISTATUS_BUSY, false, CONFIG_SYS_HZ, false);
if (rc == 0) { if (rc == 0) {
/* reset MII command register */ /* reset MII command register */

View File

@ -64,8 +64,8 @@ static int pic32_mii_init(struct pic32eth_dev *priv)
writel(ETHCON_ON | ETHCON_TXRTS | ETHCON_RXEN, &ectl_p->con1.clr); writel(ETHCON_ON | ETHCON_TXRTS | ETHCON_RXEN, &ectl_p->con1.clr);
/* wait till busy */ /* wait till busy */
wait_for_bit(__func__, &ectl_p->stat.raw, ETHSTAT_BUSY, false, wait_for_bit_le32(&ectl_p->stat.raw, ETHSTAT_BUSY, false,
CONFIG_SYS_HZ, false); CONFIG_SYS_HZ, false);
/* turn controller ON to access PHY over MII */ /* turn controller ON to access PHY over MII */
writel(ETHCON_ON, &ectl_p->con1.set); writel(ETHCON_ON, &ectl_p->con1.set);
@ -239,8 +239,8 @@ static void pic32_ctrl_reset(struct pic32eth_dev *priv)
writel(ETHCON_ON | ETHCON_TXRTS | ETHCON_RXEN, &ectl_p->con1.clr); writel(ETHCON_ON | ETHCON_TXRTS | ETHCON_RXEN, &ectl_p->con1.clr);
/* wait till busy */ /* wait till busy */
wait_for_bit(__func__, &ectl_p->stat.raw, ETHSTAT_BUSY, false, wait_for_bit_le32(&ectl_p->stat.raw, ETHSTAT_BUSY, false,
CONFIG_SYS_HZ, false); CONFIG_SYS_HZ, false);
/* decrement received buffcnt to zero. */ /* decrement received buffcnt to zero. */
while (readl(&ectl_p->stat.raw) & ETHSTAT_BUFCNT) while (readl(&ectl_p->stat.raw) & ETHSTAT_BUFCNT)
writel(ETHCON_BUFCDEC, &ectl_p->con1.set); writel(ETHCON_BUFCDEC, &ectl_p->con1.set);
@ -375,8 +375,8 @@ static void pic32_eth_stop(struct udevice *dev)
mdelay(10); mdelay(10);
/* wait until everything is down */ /* wait until everything is down */
wait_for_bit(__func__, &ectl_p->stat.raw, ETHSTAT_BUSY, false, wait_for_bit_le32(&ectl_p->stat.raw, ETHSTAT_BUSY, false,
2 * CONFIG_SYS_HZ, false); 2 * CONFIG_SYS_HZ, false);
/* clear any existing interrupt event */ /* clear any existing interrupt event */
writel(0xffffffff, &ectl_p->irq.clr); writel(0xffffffff, &ectl_p->irq.clr);

View File

@ -22,8 +22,8 @@ static int pic32_mdio_write(struct mii_dev *bus,
struct pic32_mii_regs *mii_regs = bus->priv; struct pic32_mii_regs *mii_regs = bus->priv;
/* Wait for the previous operation to finish */ /* Wait for the previous operation to finish */
wait_for_bit(__func__, &mii_regs->mind.raw, MIIMIND_BUSY, wait_for_bit_le32(&mii_regs->mind.raw, MIIMIND_BUSY,
false, CONFIG_SYS_HZ, true); false, CONFIG_SYS_HZ, true);
/* Put phyaddr and regaddr into MIIMADD */ /* Put phyaddr and regaddr into MIIMADD */
v = (addr << MIIMADD_PHYADDR_SHIFT) | (reg & MIIMADD_REGADDR); v = (addr << MIIMADD_PHYADDR_SHIFT) | (reg & MIIMADD_REGADDR);
@ -36,8 +36,8 @@ static int pic32_mdio_write(struct mii_dev *bus,
udelay(12); udelay(12);
/* Wait for write to complete */ /* Wait for write to complete */
wait_for_bit(__func__, &mii_regs->mind.raw, MIIMIND_BUSY, wait_for_bit_le32(&mii_regs->mind.raw, MIIMIND_BUSY,
false, CONFIG_SYS_HZ, true); false, CONFIG_SYS_HZ, true);
return 0; return 0;
} }
@ -48,8 +48,8 @@ static int pic32_mdio_read(struct mii_dev *bus, int addr, int devaddr, int reg)
struct pic32_mii_regs *mii_regs = bus->priv; struct pic32_mii_regs *mii_regs = bus->priv;
/* Wait for the previous operation to finish */ /* Wait for the previous operation to finish */
wait_for_bit(__func__, &mii_regs->mind.raw, MIIMIND_BUSY, wait_for_bit_le32(&mii_regs->mind.raw, MIIMIND_BUSY,
false, CONFIG_SYS_HZ, true); false, CONFIG_SYS_HZ, true);
/* Put phyaddr and regaddr into MIIMADD */ /* Put phyaddr and regaddr into MIIMADD */
v = (addr << MIIMADD_PHYADDR_SHIFT) | (reg & MIIMADD_REGADDR); v = (addr << MIIMADD_PHYADDR_SHIFT) | (reg & MIIMADD_REGADDR);
@ -62,9 +62,9 @@ static int pic32_mdio_read(struct mii_dev *bus, int addr, int devaddr, int reg)
udelay(12); udelay(12);
/* Wait for read to complete */ /* Wait for read to complete */
wait_for_bit(__func__, &mii_regs->mind.raw, wait_for_bit_le32(&mii_regs->mind.raw,
MIIMIND_NOTVALID | MIIMIND_BUSY, MIIMIND_NOTVALID | MIIMIND_BUSY,
false, CONFIG_SYS_HZ, false); false, CONFIG_SYS_HZ, false);
/* Clear the command register */ /* Clear the command register */
writel(0, &mii_regs->mcmd.raw); writel(0, &mii_regs->mcmd.raw);
@ -82,22 +82,22 @@ static int pic32_mdio_reset(struct mii_dev *bus)
writel(MIIMCFG_RSTMGMT, &mii_regs->mcfg.raw); writel(MIIMCFG_RSTMGMT, &mii_regs->mcfg.raw);
/* Wait for the operation to finish */ /* Wait for the operation to finish */
wait_for_bit(__func__, &mii_regs->mind.raw, MIIMIND_BUSY, wait_for_bit_le32(&mii_regs->mind.raw, MIIMIND_BUSY,
false, CONFIG_SYS_HZ, true); false, CONFIG_SYS_HZ, true);
/* Clear reset bit */ /* Clear reset bit */
writel(0, &mii_regs->mcfg); writel(0, &mii_regs->mcfg);
/* Wait for the operation to finish */ /* Wait for the operation to finish */
wait_for_bit(__func__, &mii_regs->mind.raw, MIIMIND_BUSY, wait_for_bit_le32(&mii_regs->mind.raw, MIIMIND_BUSY,
false, CONFIG_SYS_HZ, true); false, CONFIG_SYS_HZ, true);
/* Set the MII Management Clock (MDC) - no faster than 2.5 MHz */ /* Set the MII Management Clock (MDC) - no faster than 2.5 MHz */
writel(MIIMCFG_CLKSEL_DIV40, &mii_regs->mcfg.raw); writel(MIIMCFG_CLKSEL_DIV40, &mii_regs->mcfg.raw);
/* Wait for the operation to finish */ /* Wait for the operation to finish */
wait_for_bit(__func__, &mii_regs->mind.raw, MIIMIND_BUSY, wait_for_bit_le32(&mii_regs->mind.raw, MIIMIND_BUSY,
false, CONFIG_SYS_HZ, true); false, CONFIG_SYS_HZ, true);
return 0; return 0;
} }

View File

@ -222,8 +222,8 @@ static int ravb_reset(struct udevice *dev)
writel(CCC_OPC_CONFIG, eth->iobase + RAVB_REG_CCC); writel(CCC_OPC_CONFIG, eth->iobase + RAVB_REG_CCC);
/* Check the operating mode is changed to the config mode. */ /* Check the operating mode is changed to the config mode. */
return wait_for_bit(dev->name, (void *)eth->iobase + RAVB_REG_CSR, return wait_for_bit_le32(eth->iobase + RAVB_REG_CSR,
CSR_OPS_CONFIG, true, 100, true); CSR_OPS_CONFIG, true, 100, true);
} }
static void ravb_base_desc_init(struct ravb_priv *eth) static void ravb_base_desc_init(struct ravb_priv *eth)

View File

@ -366,8 +366,8 @@ static int axi_ethernet_init(struct axidma_priv *priv)
* processor mode and hence bypass in this mode * processor mode and hence bypass in this mode
*/ */
if (!priv->eth_hasnobuf) { if (!priv->eth_hasnobuf) {
err = wait_for_bit(__func__, (const u32 *)&regs->is, err = wait_for_bit_le32(&regs->is, XAE_INT_MGTRDY_MASK,
XAE_INT_MGTRDY_MASK, true, 200, false); true, 200, false);
if (err) { if (err) {
printf("%s: Timeout\n", __func__); printf("%s: Timeout\n", __func__);
return 1; return 1;

View File

@ -192,8 +192,8 @@ static u32 phy_setup_op(struct zynq_gem_priv *priv, u32 phy_addr, u32 regnum,
struct zynq_gem_regs *regs = priv->iobase; struct zynq_gem_regs *regs = priv->iobase;
int err; int err;
err = wait_for_bit(__func__, &regs->nwsr, ZYNQ_GEM_NWSR_MDIOIDLE_MASK, err = wait_for_bit_le32(&regs->nwsr, ZYNQ_GEM_NWSR_MDIOIDLE_MASK,
true, 20000, false); true, 20000, false);
if (err) if (err)
return err; return err;
@ -205,8 +205,8 @@ static u32 phy_setup_op(struct zynq_gem_priv *priv, u32 phy_addr, u32 regnum,
/* Write mgtcr and wait for completion */ /* Write mgtcr and wait for completion */
writel(mgtcr, &regs->phymntnc); writel(mgtcr, &regs->phymntnc);
err = wait_for_bit(__func__, &regs->nwsr, ZYNQ_GEM_NWSR_MDIOIDLE_MASK, err = wait_for_bit_le32(&regs->nwsr, ZYNQ_GEM_NWSR_MDIOIDLE_MASK,
true, 20000, false); true, 20000, false);
if (err) if (err)
return err; return err;
@ -514,8 +514,8 @@ static int zynq_gem_send(struct udevice *dev, void *ptr, int len)
if (priv->tx_bd->status & ZYNQ_GEM_TXBUF_EXHAUSTED) if (priv->tx_bd->status & ZYNQ_GEM_TXBUF_EXHAUSTED)
printf("TX buffers exhausted in mid frame\n"); printf("TX buffers exhausted in mid frame\n");
return wait_for_bit(__func__, &regs->txsr, ZYNQ_GEM_TSR_DONE, return wait_for_bit_le32(&regs->txsr, ZYNQ_GEM_TSR_DONE,
true, 20000, true); true, 20000, true);
} }
/* Do not check frame_recd flag in rx_status register 0x20 - just poll BD */ /* Do not check frame_recd flag in rx_status register 0x20 - just poll BD */

View File

@ -266,8 +266,8 @@ static int sti_reset_program_hw(struct reset_ctl *reset_ctl, int assert)
return 0; return 0;
reg = (void __iomem *)base + ch->ack_offset; reg = (void __iomem *)base + ch->ack_offset;
if (wait_for_bit(__func__, reg, BIT(ch->ack_bit), ctrl_val, if (wait_for_bit_le32(reg, BIT(ch->ack_bit), ctrl_val,
1000, false)) { 1000, false)) {
pr_err("Stuck on waiting ack reset_ctl=%p dev=%p id=%lu\n", pr_err("Stuck on waiting ack reset_ctl=%p dev=%p id=%lu\n",
reset_ctl, reset_ctl->dev, reset_ctl->id); reset_ctl, reset_ctl->dev, reset_ctl->id);

View File

@ -51,8 +51,8 @@ static int pic32_serial_init(void __iomem *base, ulong clk, u32 baudrate)
u32 div = DIV_ROUND_CLOSEST(clk, baudrate * 16); u32 div = DIV_ROUND_CLOSEST(clk, baudrate * 16);
/* wait for TX FIFO to empty */ /* wait for TX FIFO to empty */
wait_for_bit(__func__, base + U_STA, UART_TX_EMPTY, wait_for_bit_le32(base + U_STA, UART_TX_EMPTY,
true, CONFIG_SYS_HZ, false); true, CONFIG_SYS_HZ, false);
/* send break */ /* send break */
writel(UART_TX_BRK, base + U_STASET); writel(UART_TX_BRK, base + U_STASET);

View File

@ -394,8 +394,8 @@ out:
* Wait until the transfer is completely done before * Wait until the transfer is completely done before
* we deactivate CS. * we deactivate CS.
*/ */
wait_for_bit(__func__, &reg_base->sr, wait_for_bit_le32(&reg_base->sr,
ATMEL_SPI_SR_TXEMPTY, true, 1000, false); ATMEL_SPI_SR_TXEMPTY, true, 1000, false);
atmel_spi_cs_deactivate(dev); atmel_spi_cs_deactivate(dev);
} }

View File

@ -675,8 +675,8 @@ int cadence_qspi_apb_indirect_read_execute(struct cadence_spi_platdata *plat,
} }
/* Check indirect done status */ /* Check indirect done status */
ret = wait_for_bit("QSPI", plat->regbase + CQSPI_REG_INDIRECTRD, ret = wait_for_bit_le32(plat->regbase + CQSPI_REG_INDIRECTRD,
CQSPI_REG_INDIRECTRD_DONE, 1, 10, 0); CQSPI_REG_INDIRECTRD_DONE, 1, 10, 0);
if (ret) { if (ret) {
printf("Indirect read completion error (%i)\n", ret); printf("Indirect read completion error (%i)\n", ret);
goto failrd; goto failrd;
@ -762,9 +762,9 @@ int cadence_qspi_apb_indirect_write_execute(struct cadence_spi_platdata *plat,
bb_txbuf + rounddown(write_bytes, 4), bb_txbuf + rounddown(write_bytes, 4),
write_bytes % 4); write_bytes % 4);
ret = wait_for_bit("QSPI", plat->regbase + CQSPI_REG_SDRAMLEVEL, ret = wait_for_bit_le32(plat->regbase + CQSPI_REG_SDRAMLEVEL,
CQSPI_REG_SDRAMLEVEL_WR_MASK << CQSPI_REG_SDRAMLEVEL_WR_MASK <<
CQSPI_REG_SDRAMLEVEL_WR_LSB, 0, 10, 0); CQSPI_REG_SDRAMLEVEL_WR_LSB, 0, 10, 0);
if (ret) { if (ret) {
printf("Indirect write timed out (%i)\n", ret); printf("Indirect write timed out (%i)\n", ret);
goto failwr; goto failwr;
@ -775,8 +775,8 @@ int cadence_qspi_apb_indirect_write_execute(struct cadence_spi_platdata *plat,
} }
/* Check indirect done status */ /* Check indirect done status */
ret = wait_for_bit("QSPI", plat->regbase + CQSPI_REG_INDIRECTWR, ret = wait_for_bit_le32(plat->regbase + CQSPI_REG_INDIRECTWR,
CQSPI_REG_INDIRECTWR_DONE, 1, 10, 0); CQSPI_REG_INDIRECTWR_DONE, 1, 10, 0);
if (ret) { if (ret) {
printf("Indirect write completion error (%i)\n", ret); printf("Indirect write completion error (%i)\n", ret);
goto failwr; goto failwr;

View File

@ -1011,11 +1011,11 @@ static int fsl_qspi_probe(struct udevice *bus)
priv->num_chipselect = plat->num_chipselect; priv->num_chipselect = plat->num_chipselect;
/* make sure controller is not busy anywhere */ /* make sure controller is not busy anywhere */
ret = wait_for_bit(__func__, &priv->regs->sr, ret = wait_for_bit_le32(&priv->regs->sr,
QSPI_SR_BUSY_MASK | QSPI_SR_BUSY_MASK |
QSPI_SR_AHB_ACC_MASK | QSPI_SR_AHB_ACC_MASK |
QSPI_SR_IP_ACC_MASK, QSPI_SR_IP_ACC_MASK,
false, 100, false); false, 100, false);
if (ret) { if (ret) {
debug("ERROR : The controller is busy\n"); debug("ERROR : The controller is busy\n");
@ -1173,11 +1173,11 @@ static int fsl_qspi_claim_bus(struct udevice *dev)
priv = dev_get_priv(bus); priv = dev_get_priv(bus);
/* make sure controller is not busy anywhere */ /* make sure controller is not busy anywhere */
ret = wait_for_bit(__func__, &priv->regs->sr, ret = wait_for_bit_le32(&priv->regs->sr,
QSPI_SR_BUSY_MASK | QSPI_SR_BUSY_MASK |
QSPI_SR_AHB_ACC_MASK | QSPI_SR_AHB_ACC_MASK |
QSPI_SR_IP_ACC_MASK, QSPI_SR_IP_ACC_MASK,
false, 100, false); false, 100, false);
if (ret) { if (ret) {
debug("ERROR : The controller is busy\n"); debug("ERROR : The controller is busy\n");

View File

@ -95,8 +95,9 @@ static int spi_legacy_shift_byte(struct spi_reg *reg, unsigned int bytelen,
din_8 = din; din_8 = din;
while (bytelen) { while (bytelen) {
ret = wait_for_bit(__func__, &reg->ctrl, ret = wait_for_bit_le32(&reg->ctrl,
MVEBU_SPI_A3700_XFER_RDY, true, 100, false); MVEBU_SPI_A3700_XFER_RDY,
true,100, false);
if (ret) if (ret)
return ret; return ret;
@ -109,9 +110,9 @@ static int spi_legacy_shift_byte(struct spi_reg *reg, unsigned int bytelen,
writel(pending_dout, &reg->dout); writel(pending_dout, &reg->dout);
if (din) { if (din) {
ret = wait_for_bit(__func__, &reg->ctrl, ret = wait_for_bit_le32(&reg->ctrl,
MVEBU_SPI_A3700_XFER_RDY, MVEBU_SPI_A3700_XFER_RDY,
true, 100, false); true, 100, false);
if (ret) if (ret)
return ret; return ret;
@ -160,8 +161,9 @@ static int mvebu_spi_xfer(struct udevice *dev, unsigned int bitlen,
/* Deactivate CS */ /* Deactivate CS */
if (flags & SPI_XFER_END) { if (flags & SPI_XFER_END) {
ret = wait_for_bit(__func__, &reg->ctrl, ret = wait_for_bit_le32(&reg->ctrl,
MVEBU_SPI_A3700_XFER_RDY, true, 100, false); MVEBU_SPI_A3700_XFER_RDY,
true, 100, false);
if (ret) if (ret)
return ret; return ret;
@ -231,8 +233,8 @@ static int mvebu_spi_probe(struct udevice *bus)
/* Flush read/write FIFO */ /* Flush read/write FIFO */
data = readl(&reg->cfg); data = readl(&reg->cfg);
writel(data | MVEBU_SPI_A3700_FIFO_FLUSH, &reg->cfg); writel(data | MVEBU_SPI_A3700_FIFO_FLUSH, &reg->cfg);
ret = wait_for_bit(__func__, &reg->cfg, MVEBU_SPI_A3700_FIFO_FLUSH, ret = wait_for_bit_le32(&reg->cfg, MVEBU_SPI_A3700_FIFO_FLUSH,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
return ret; return ret;

View File

@ -108,8 +108,8 @@ static void dwc_otg_flush_tx_fifo(struct dwc2_core_regs *regs, const int num)
writel(DWC2_GRSTCTL_TXFFLSH | (num << DWC2_GRSTCTL_TXFNUM_OFFSET), writel(DWC2_GRSTCTL_TXFFLSH | (num << DWC2_GRSTCTL_TXFNUM_OFFSET),
&regs->grstctl); &regs->grstctl);
ret = wait_for_bit(__func__, &regs->grstctl, DWC2_GRSTCTL_TXFFLSH, ret = wait_for_bit_le32(&regs->grstctl, DWC2_GRSTCTL_TXFFLSH,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: Timeout!\n", __func__); printf("%s: Timeout!\n", __func__);
@ -127,8 +127,8 @@ static void dwc_otg_flush_rx_fifo(struct dwc2_core_regs *regs)
int ret; int ret;
writel(DWC2_GRSTCTL_RXFFLSH, &regs->grstctl); writel(DWC2_GRSTCTL_RXFFLSH, &regs->grstctl);
ret = wait_for_bit(__func__, &regs->grstctl, DWC2_GRSTCTL_RXFFLSH, ret = wait_for_bit_le32(&regs->grstctl, DWC2_GRSTCTL_RXFFLSH,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: Timeout!\n", __func__); printf("%s: Timeout!\n", __func__);
@ -145,15 +145,15 @@ static void dwc_otg_core_reset(struct dwc2_core_regs *regs)
int ret; int ret;
/* Wait for AHB master IDLE state. */ /* Wait for AHB master IDLE state. */
ret = wait_for_bit(__func__, &regs->grstctl, DWC2_GRSTCTL_AHBIDLE, ret = wait_for_bit_le32(&regs->grstctl, DWC2_GRSTCTL_AHBIDLE,
true, 1000, false); true, 1000, false);
if (ret) if (ret)
printf("%s: Timeout!\n", __func__); printf("%s: Timeout!\n", __func__);
/* Core Soft Reset */ /* Core Soft Reset */
writel(DWC2_GRSTCTL_CSFTRST, &regs->grstctl); writel(DWC2_GRSTCTL_CSFTRST, &regs->grstctl);
ret = wait_for_bit(__func__, &regs->grstctl, DWC2_GRSTCTL_CSFTRST, ret = wait_for_bit_le32(&regs->grstctl, DWC2_GRSTCTL_CSFTRST,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: Timeout!\n", __func__); printf("%s: Timeout!\n", __func__);
@ -267,8 +267,8 @@ static void dwc_otg_core_host_init(struct udevice *dev,
clrsetbits_le32(&regs->hc_regs[i].hcchar, clrsetbits_le32(&regs->hc_regs[i].hcchar,
DWC2_HCCHAR_EPDIR, DWC2_HCCHAR_EPDIR,
DWC2_HCCHAR_CHEN | DWC2_HCCHAR_CHDIS); DWC2_HCCHAR_CHEN | DWC2_HCCHAR_CHDIS);
ret = wait_for_bit(__func__, &regs->hc_regs[i].hcchar, ret = wait_for_bit_le32(&regs->hc_regs[i].hcchar,
DWC2_HCCHAR_CHEN, false, 1000, false); DWC2_HCCHAR_CHEN, false, 1000, false);
if (ret) if (ret)
printf("%s: Timeout!\n", __func__); printf("%s: Timeout!\n", __func__);
} }
@ -783,8 +783,8 @@ int wait_for_chhltd(struct dwc2_hc_regs *hc_regs, uint32_t *sub, u8 *toggle)
int ret; int ret;
uint32_t hcint, hctsiz; uint32_t hcint, hctsiz;
ret = wait_for_bit(__func__, &hc_regs->hcint, DWC2_HCINT_CHHLTD, true, ret = wait_for_bit_le32(&hc_regs->hcint, DWC2_HCINT_CHHLTD, true,
1000, false); 1000, false);
if (ret) if (ret)
return ret; return ret;

View File

@ -133,8 +133,7 @@ static int ehci_usb_remove(struct udevice *dev)
setbits_le32(&ehci->usbcmd, CMD_RESET); setbits_le32(&ehci->usbcmd, CMD_RESET);
/* Wait for reset */ /* Wait for reset */
if (wait_for_bit(__func__, &ehci->usbcmd, CMD_RESET, false, 30, if (wait_for_bit_le32(&ehci->usbcmd, CMD_RESET, false, 30, false)) {
false)) {
printf("Stuck on USB reset.\n"); printf("Stuck on USB reset.\n");
return -ETIMEDOUT; return -ETIMEDOUT;
} }

View File

@ -142,13 +142,12 @@ static int usb_phy_enable(int index, struct usb_ehci *ehci)
/* Stop then Reset */ /* Stop then Reset */
clrbits_le32(usb_cmd, UCMD_RUN_STOP); clrbits_le32(usb_cmd, UCMD_RUN_STOP);
ret = wait_for_bit(__func__, usb_cmd, UCMD_RUN_STOP, false, 10000, ret = wait_for_bit_le32(usb_cmd, UCMD_RUN_STOP, false, 10000, false);
false);
if (ret) if (ret)
return ret; return ret;
setbits_le32(usb_cmd, UCMD_RESET); setbits_le32(usb_cmd, UCMD_RESET);
ret = wait_for_bit(__func__, usb_cmd, UCMD_RESET, false, 10000, false); ret = wait_for_bit_le32(usb_cmd, UCMD_RESET, false, 10000, false);
if (ret) if (ret)
return ret; return ret;

View File

@ -143,8 +143,8 @@ static int usbpll_setup(void)
setbits_le32(&clk_pwr->usb_ctrl, CLK_USBCTRL_POSTDIV_2POW(0x01)); setbits_le32(&clk_pwr->usb_ctrl, CLK_USBCTRL_POSTDIV_2POW(0x01));
setbits_le32(&clk_pwr->usb_ctrl, CLK_USBCTRL_PLL_PWRUP); setbits_le32(&clk_pwr->usb_ctrl, CLK_USBCTRL_PLL_PWRUP);
ret = wait_for_bit(__func__, &clk_pwr->usb_ctrl, CLK_USBCTRL_PLL_STS, ret = wait_for_bit_le32(&clk_pwr->usb_ctrl, CLK_USBCTRL_PLL_STS,
true, CONFIG_SYS_HZ, false); true, CONFIG_SYS_HZ, false);
if (ret) if (ret)
return ret; return ret;
@ -178,8 +178,8 @@ int usb_cpu_init(void)
/* enable I2C clock */ /* enable I2C clock */
writel(OTG_CLK_I2C_EN, &otg->otg_clk_ctrl); writel(OTG_CLK_I2C_EN, &otg->otg_clk_ctrl);
ret = wait_for_bit(__func__, &otg->otg_clk_sts, OTG_CLK_I2C_EN, true, ret = wait_for_bit_le32(&otg->otg_clk_sts, OTG_CLK_I2C_EN, true,
CONFIG_SYS_HZ, false); CONFIG_SYS_HZ, false);
if (ret) if (ret)
return ret; return ret;
@ -199,8 +199,8 @@ int usb_cpu_init(void)
OTG_CLK_I2C_EN | OTG_CLK_HOST_EN; OTG_CLK_I2C_EN | OTG_CLK_HOST_EN;
writel(mask, &otg->otg_clk_ctrl); writel(mask, &otg->otg_clk_ctrl);
ret = wait_for_bit(__func__, &otg->otg_clk_sts, mask, true, ret = wait_for_bit_le32(&otg->otg_clk_sts, mask, true,
CONFIG_SYS_HZ, false); CONFIG_SYS_HZ, false);
if (ret) if (ret)
return ret; return ret;

View File

@ -55,18 +55,18 @@ static int xhci_rcar_download_fw(struct rcar_xhci *ctx, const u32 *fw_data,
setbits_le32(regs + RCAR_USB3_DL_CTRL, setbits_le32(regs + RCAR_USB3_DL_CTRL,
RCAR_USB3_DL_CTRL_FW_SET_DATA0); RCAR_USB3_DL_CTRL_FW_SET_DATA0);
ret = wait_for_bit("xhci-rcar", regs + RCAR_USB3_DL_CTRL, ret = wait_for_bit_le32(regs + RCAR_USB3_DL_CTRL,
RCAR_USB3_DL_CTRL_FW_SET_DATA0, false, RCAR_USB3_DL_CTRL_FW_SET_DATA0, false,
10, false); 10, false);
if (ret) if (ret)
break; break;
} }
clrbits_le32(regs + RCAR_USB3_DL_CTRL, RCAR_USB3_DL_CTRL_ENABLE); clrbits_le32(regs + RCAR_USB3_DL_CTRL, RCAR_USB3_DL_CTRL_ENABLE);
ret = wait_for_bit("xhci-rcar", regs + RCAR_USB3_DL_CTRL, ret = wait_for_bit_le32(regs + RCAR_USB3_DL_CTRL,
RCAR_USB3_DL_CTRL_FW_SUCCESS, true, RCAR_USB3_DL_CTRL_FW_SUCCESS, true,
10, false); 10, false);
return ret; return ret;
} }

View File

@ -70,26 +70,26 @@ void lcd_ctrl_init(void *lcdbase)
/* Disable DISP signal */ /* Disable DISP signal */
writel(LCDC_LCDDIS_DISPDIS, &regs->lcdc_lcddis); writel(LCDC_LCDDIS_DISPDIS, &regs->lcdc_lcddis);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_DISPSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_DISPSTS,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
/* Disable synchronization */ /* Disable synchronization */
writel(LCDC_LCDDIS_SYNCDIS, &regs->lcdc_lcddis); writel(LCDC_LCDDIS_SYNCDIS, &regs->lcdc_lcddis);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_LCDSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_LCDSTS,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
/* Disable pixel clock */ /* Disable pixel clock */
writel(LCDC_LCDDIS_CLKDIS, &regs->lcdc_lcddis); writel(LCDC_LCDDIS_CLKDIS, &regs->lcdc_lcddis);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_CLKSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_CLKSTS,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
/* Disable PWM */ /* Disable PWM */
writel(LCDC_LCDDIS_PWMDIS, &regs->lcdc_lcddis); writel(LCDC_LCDDIS_PWMDIS, &regs->lcdc_lcddis);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_PWMSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_PWMSTS,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
@ -215,26 +215,26 @@ void lcd_ctrl_init(void *lcdbase)
/* Enable LCD */ /* Enable LCD */
value = readl(&regs->lcdc_lcden); value = readl(&regs->lcdc_lcden);
writel(value | LCDC_LCDEN_CLKEN, &regs->lcdc_lcden); writel(value | LCDC_LCDEN_CLKEN, &regs->lcdc_lcden);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_CLKSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_CLKSTS,
true, 1000, false); true, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
value = readl(&regs->lcdc_lcden); value = readl(&regs->lcdc_lcden);
writel(value | LCDC_LCDEN_SYNCEN, &regs->lcdc_lcden); writel(value | LCDC_LCDEN_SYNCEN, &regs->lcdc_lcden);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_LCDSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_LCDSTS,
true, 1000, false); true, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
value = readl(&regs->lcdc_lcden); value = readl(&regs->lcdc_lcden);
writel(value | LCDC_LCDEN_DISPEN, &regs->lcdc_lcden); writel(value | LCDC_LCDEN_DISPEN, &regs->lcdc_lcden);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_DISPSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_DISPSTS,
true, 1000, false); true, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
value = readl(&regs->lcdc_lcden); value = readl(&regs->lcdc_lcden);
writel(value | LCDC_LCDEN_PWMEN, &regs->lcdc_lcden); writel(value | LCDC_LCDEN_PWMEN, &regs->lcdc_lcden);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_PWMSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_PWMSTS,
true, 1000, false); true, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
@ -299,26 +299,26 @@ static void atmel_hlcdc_init(struct udevice *dev)
/* Disable DISP signal */ /* Disable DISP signal */
writel(LCDC_LCDDIS_DISPDIS, &regs->lcdc_lcddis); writel(LCDC_LCDDIS_DISPDIS, &regs->lcdc_lcddis);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_DISPSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_DISPSTS,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
/* Disable synchronization */ /* Disable synchronization */
writel(LCDC_LCDDIS_SYNCDIS, &regs->lcdc_lcddis); writel(LCDC_LCDDIS_SYNCDIS, &regs->lcdc_lcddis);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_LCDSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_LCDSTS,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
/* Disable pixel clock */ /* Disable pixel clock */
writel(LCDC_LCDDIS_CLKDIS, &regs->lcdc_lcddis); writel(LCDC_LCDDIS_CLKDIS, &regs->lcdc_lcddis);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_CLKSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_CLKSTS,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
/* Disable PWM */ /* Disable PWM */
writel(LCDC_LCDDIS_PWMDIS, &regs->lcdc_lcddis); writel(LCDC_LCDDIS_PWMDIS, &regs->lcdc_lcddis);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_PWMSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_PWMSTS,
false, 1000, false); false, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
@ -451,26 +451,26 @@ static void atmel_hlcdc_init(struct udevice *dev)
/* Enable LCD */ /* Enable LCD */
value = readl(&regs->lcdc_lcden); value = readl(&regs->lcdc_lcden);
writel(value | LCDC_LCDEN_CLKEN, &regs->lcdc_lcden); writel(value | LCDC_LCDEN_CLKEN, &regs->lcdc_lcden);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_CLKSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_CLKSTS,
true, 1000, false); true, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
value = readl(&regs->lcdc_lcden); value = readl(&regs->lcdc_lcden);
writel(value | LCDC_LCDEN_SYNCEN, &regs->lcdc_lcden); writel(value | LCDC_LCDEN_SYNCEN, &regs->lcdc_lcden);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_LCDSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_LCDSTS,
true, 1000, false); true, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
value = readl(&regs->lcdc_lcden); value = readl(&regs->lcdc_lcden);
writel(value | LCDC_LCDEN_DISPEN, &regs->lcdc_lcden); writel(value | LCDC_LCDEN_DISPEN, &regs->lcdc_lcden);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_DISPSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_DISPSTS,
true, 1000, false); true, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
value = readl(&regs->lcdc_lcden); value = readl(&regs->lcdc_lcden);
writel(value | LCDC_LCDEN_PWMEN, &regs->lcdc_lcden); writel(value | LCDC_LCDEN_PWMEN, &regs->lcdc_lcden);
ret = wait_for_bit(__func__, &regs->lcdc_lcdsr, LCDC_LCDSR_PWMSTS, ret = wait_for_bit_le32(&regs->lcdc_lcdsr, LCDC_LCDSR_PWMSTS,
true, 1000, false); true, 1000, false);
if (ret) if (ret)
printf("%s: %d: Timeout!\n", __func__, __LINE__); printf("%s: %d: Timeout!\n", __func__, __LINE__);
} }

View File

@ -15,60 +15,6 @@
#include <linux/errno.h> #include <linux/errno.h>
#include <asm/io.h> #include <asm/io.h>
/**
* wait_for_bit() waits for bit set/cleared in register
*
* Function polls register waiting for specific bit(s) change
* (either 0->1 or 1->0). It can fail under two conditions:
* - Timeout
* - User interaction (CTRL-C)
* Function succeeds only if all bits of masked register are set/cleared
* (depending on set option).
*
* @param prefix Prefix added to timeout messagge (message visible only
* with debug enabled)
* @param reg Register that will be read (using readl())
* @param mask Bit(s) of register that must be active
* @param set Selects wait condition (bit set or clear)
* @param timeout_ms Timeout (in miliseconds)
* @param breakable Enables CTRL-C interruption
* @return 0 on success, -ETIMEDOUT or -EINTR on failure
*/
static inline int wait_for_bit(const char *prefix, const u32 *reg,
const u32 mask, const bool set,
const unsigned int timeout_ms,
const bool breakable)
{
u32 val;
unsigned long start = get_timer(0);
while (1) {
val = readl(reg);
if (!set)
val = ~val;
if ((val & mask) == mask)
return 0;
if (get_timer(start) > timeout_ms)
break;
if (breakable && ctrlc()) {
puts("Abort\n");
return -EINTR;
}
udelay(1);
WATCHDOG_RESET();
}
debug("%s: Timeout (reg=%p mask=%08x wait_set=%i)\n", prefix, reg, mask,
set);
return -ETIMEDOUT;
}
/** /**
* wait_for_bit_x() waits for bit set/cleared in register * wait_for_bit_x() waits for bit set/cleared in register
* *