arch/alpha/include/asm/io.h

148

REMAP1(unsigned int, ioread32, const)

arch/alpha/include/asm/io.h

277

extern unsigned int ioread32(const void __iomem *);

arch/alpha/include/asm/io.h

395

ret = IO_CONCAT(__IO_PREFIX,ioread32)(addr);

arch/alpha/include/asm/io.h

423

return ioread32(ioport_map(port, 4));

arch/alpha/include/asm/io.h

432

#define ioread32 ioread32

arch/alpha/include/asm/io.h

542

#define ioread32be(p) swab32(ioread32(p))

arch/alpha/include/asm/io_trivial.h

36

IO_CONCAT(__IO_PREFIX,ioread32)(const void __iomem *a)

arch/alpha/kernel/io.c

365

((struct S *)dst)->x = ioread32(port);

arch/alpha/kernel/io.c

371

*(unsigned int *)dst = ioread32(port);

arch/alpha/kernel/io.c

39

ret = IO_CONCAT(__IO_PREFIX,ioread32)(addr);

arch/alpha/kernel/io.c

79

EXPORT_SYMBOL(ioread32);

arch/alpha/kernel/io.c

98

return ioread32(ioport_map(port, 4));

arch/arc/plat-axs10x/axs10x.c

86

board.val = ioread32((void __iomem *)creg);

arch/arc/plat-axs10x/axs10x.c

97

if (ioread32((void __iomem *) CREG_MB_CONFIG) & (1 << 28))

arch/arm/mach-shmobile/regulator-quirk-rcar-gen2.c

117

mon = ioread32(irqc + IRQC_MONITOR);

arch/arm/mach-shmobile/regulator-quirk-rcar-gen2.c

212

mon = ioread32(irqc + IRQC_MONITOR);

arch/arm/mach-shmobile/regulator-quirk-rcar-gen2.c

86

mon = ioread32(irqc + IRQC_MONITOR);

arch/arm/mach-shmobile/setup-rcar-gen2.c

104

if ((ioread32(base + CNTCR) & 1) == 0 ||

arch/arm/mach-shmobile/setup-rcar-gen2.c

105

ioread32(base + CNTFID0) != freq) {

arch/microblaze/kernel/timer.c

58

return ioread32(addr);

arch/mips/generic/board-ingenic.c

98

cpccr = ioread32(cgu);

arch/mips/pci/pci-mt7620.c

87

return ioread32(bridge_base + reg);

arch/mips/pci/pci-mt7620.c

97

return ioread32(pcie_base + reg);

arch/mips/pci/pci-rt3883.c

84

return ioread32(rpc->base + reg);

arch/parisc/include/asm/io.h

246

extern unsigned int ioread32(const void __iomem *);

arch/parisc/include/asm/io.h

250

#define ioread32 ioread32

arch/parisc/lib/iomap.c

529

EXPORT_SYMBOL(ioread32);

arch/powerpc/platforms/86xx/gef_sbc310.c

108

reg = ioread32(sbc310_regs);

arch/powerpc/platforms/86xx/gef_sbc310.c

117

reg = ioread32(sbc310_regs);

arch/powerpc/platforms/86xx/gef_sbc310.c

126

reg = ioread32(sbc310_regs);

arch/powerpc/platforms/86xx/gef_sbc310.c

99

reg = ioread32(sbc310_regs);

arch/powerpc/platforms/86xx/gef_sbc610.c

100

reg = ioread32(sbc610_regs);

arch/powerpc/platforms/86xx/gef_sbc610.c

109

reg = ioread32(sbc610_regs);

arch/powerpc/platforms/86xx/gef_sbc610.c

118

reg = ioread32(sbc610_regs);

arch/sh/drivers/heartbeat.c

45

new |= ioread32(hd->base) & ~hd->mask;

arch/x86/kernel/cpu/amd.c

1351

value = ioread32(addr);

arch/x86/kernel/early-quirks.c

631

#define bcma_aread32(reg) ioread32(mmio + 1 * BCMA_CORE_SIZE + reg)

arch/x86/mm/testmmiotrace.c

65

if (ioread32(p + i) != v32(i))

arch/x86/mm/testmmiotrace.c

77

ioread32(p + read_far);

drivers/ata/ahci_seattle.c

138

val = ioread32(plat_data->sgpio_ctrl);

drivers/ata/ahci_seattle.c

95

val = ioread32(plat_data->sgpio_ctrl);

drivers/ata/ahci_xgene.c

117

tmp = ioread32(reg);

drivers/ata/ahci_xgene.c

122

tmp = ioread32(reg);

drivers/ata/ata_piix.c

1293

tmp = ioread32(mmio + AHCI_GLOBAL_CTL);

drivers/ata/ata_piix.c

1298

tmp = ioread32(mmio + AHCI_GLOBAL_CTL);

drivers/ata/ata_piix.c

795

*val = ioread32(hpriv->sidpr + PIIX_SIDPR_DATA);

drivers/ata/libata-core.c

6872

tmp = ioread32(reg);

drivers/ata/libata-core.c

6882

tmp = ioread32(reg);

drivers/ata/pata_cs5530.c

53

tuning = ioread32(base + 0x04);

drivers/ata/pata_cs5530.c

80

tuning = ioread32(base + 0x04);

drivers/ata/pata_marvell.c

46

devices = ioread32(barp + 0x0C);

drivers/ata/pata_pdc2027x.c

206

cgcr = ioread32(port_mmio(ap, PDC_GLOBAL_CTL));

drivers/ata/pata_pdc2027x.c

300

ctcr0 = ioread32(dev_mmio(ap, adev, PDC_CTCR0));

drivers/ata/pata_pdc2027x.c

306

ctcr1 = ioread32(dev_mmio(ap, adev, PDC_CTCR1));

drivers/ata/pata_pdc2027x.c

340

ctcr1 = ioread32(dev_mmio(ap, adev, PDC_CTCR1));

drivers/ata/pata_pdc2027x.c

346

ctcr1 = ioread32(dev_mmio(ap, adev, PDC_CTCR1));

drivers/ata/pata_pdc2027x.c

361

ctcr0 = ioread32(dev_mmio(ap, adev, PDC_CTCR0));

drivers/ata/pata_pdc2027x.c

401

u32 ctcr1 = ioread32(dev_mmio(ap, dev, PDC_CTCR1));

drivers/ata/pata_pdc2027x.c

467

bccrl = ioread32(mmio_base + PDC_BYTE_COUNT) & 0x7fff;

drivers/ata/pata_pdc2027x.c

468

bccrh = ioread32(mmio_base + PDC_BYTE_COUNT + 0x100) & 0x7fff;

drivers/ata/pata_pdc2027x.c

471

bccrlv = ioread32(mmio_base + PDC_BYTE_COUNT) & 0x7fff;

drivers/ata/pata_pdc2027x.c

472

bccrhv = ioread32(mmio_base + PDC_BYTE_COUNT + 0x100) & 0x7fff;

drivers/ata/pata_pdc2027x.c

592

scr = ioread32(mmio_base + PDC_SYS_CTL);

drivers/ata/pata_pdc2027x.c

595

ioread32(mmio_base + PDC_SYS_CTL); /* flush */

drivers/ata/pata_pdc2027x.c

609

scr = ioread32(mmio_base + PDC_SYS_CTL);

drivers/ata/pata_pdc2027x.c

612

ioread32(mmio_base + PDC_SYS_CTL); /* flush */

drivers/ata/sata_fsl.c

1027

ata_port_dbg(ap, "ccreg = 0x%x\n", ioread32(hcr_base + CC));

drivers/ata/sata_fsl.c

1028

ata_port_dbg(ap, "cereg = 0x%x\n", ioread32(hcr_base + CE));

drivers/ata/sata_fsl.c

1064

hstatus = ioread32(hcr_base + HSTATUS);

drivers/ata/sata_fsl.c

1065

cereg = ioread32(hcr_base + CE);

drivers/ata/sata_fsl.c

1081

hstatus, cereg, ioread32(hcr_base + DE), SError);

drivers/ata/sata_fsl.c

1119

ioread32(hcr_base + CE), ioread32(hcr_base + DE));

drivers/ata/sata_fsl.c

1125

dereg = ioread32(hcr_base + DE);

drivers/ata/sata_fsl.c

1147

dereg = ioread32(hcr_base + DE);

drivers/ata/sata_fsl.c

1189

hstatus = ioread32(hcr_base + HSTATUS);

drivers/ata/sata_fsl.c

1194

done_mask = ioread32(hcr_base + CC);

drivers/ata/sata_fsl.c

1202

hcontrol = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

1236

ioread32(hcr_base + CA),

drivers/ata/sata_fsl.c

1237

ioread32(hcr_base + CE),

drivers/ata/sata_fsl.c

1238

ioread32(hcr_base + CQ),

drivers/ata/sata_fsl.c

1247

done_mask, ioread32(hcr_base + CA),

drivers/ata/sata_fsl.c

1248

ioread32(hcr_base + CE));

drivers/ata/sata_fsl.c

1253

i, ioread32(hcr_base + CC),

drivers/ata/sata_fsl.c

1254

ioread32(hcr_base + CA));

drivers/ata/sata_fsl.c

1264

ioread32(hcr_base + CC));

drivers/ata/sata_fsl.c

1272

ioread32(hcr_base + CC));

drivers/ata/sata_fsl.c

1288

interrupt_enables = ioread32(hcr_base + HSTATUS);

drivers/ata/sata_fsl.c

1330

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

1334

temp = ioread32(hcr_base + HSTATUS);

drivers/ata/sata_fsl.c

1339

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

1343

dev_dbg(host->dev, "icc = 0x%x\n", ioread32(hcr_base + ICC));

drivers/ata/sata_fsl.c

1363

ioread32(hcr_base + HSTATUS), ioread32(hcr_base + HCONTROL));

drivers/ata/sata_fsl.c

1446

temp = ioread32(csr_base + TRANSCFG);

drivers/ata/sata_fsl.c

1452

ioread32(csr_base + TRANSCFG));

drivers/ata/sata_fsl.c

1567

iowrite32((ioread32(hcr_base + HCONTROL)

drivers/ata/sata_fsl.c

319

hcr_base, ioread32(hcr_base + ICC));

drivers/ata/sata_fsl.c

356

rx_watermark = ioread32(csr_base + TRANSCFG);

drivers/ata/sata_fsl.c

380

temp = ioread32(csr_base + TRANSCFG);

drivers/ata/sata_fsl.c

399

if (unlikely((ioread32(hcr_base + CQ)) & (1 << tag))) {

drivers/ata/sata_fsl.c

548

ioread32(CQ + hcr_base),

drivers/ata/sata_fsl.c

549

ioread32(CA + hcr_base),

drivers/ata/sata_fsl.c

550

ioread32(CE + hcr_base), ioread32(CC + hcr_base));

drivers/ata/sata_fsl.c

558

tag, ioread32(CQ + hcr_base), ioread32(CA + hcr_base));

drivers/ata/sata_fsl.c

561

ioread32(CE + hcr_base),

drivers/ata/sata_fsl.c

562

ioread32(DE + hcr_base),

drivers/ata/sata_fsl.c

563

ioread32(CC + hcr_base),

drivers/ata/sata_fsl.c

564

ioread32(COMMANDSTAT + host_priv->csr_base));

drivers/ata/sata_fsl.c

626

*val = ioread32(ssr_base + (sc_reg * 4));

drivers/ata/sata_fsl.c

637

ioread32(CQ + hcr_base),

drivers/ata/sata_fsl.c

638

ioread32(CA + hcr_base),

drivers/ata/sata_fsl.c

639

ioread32(CE + hcr_base), ioread32(DE + hcr_base));

drivers/ata/sata_fsl.c

641

ioread32(host_priv->csr_base + COMMANDSTAT));

drivers/ata/sata_fsl.c

644

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

648

ioread32(hcr_base + HCONTROL), ioread32(hcr_base + HSTATUS));

drivers/ata/sata_fsl.c

658

temp = ioread32(hcr_base + HSTATUS);

drivers/ata/sata_fsl.c

666

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

670

ioread32(hcr_base + HCONTROL), ioread32(hcr_base + HSTATUS));

drivers/ata/sata_fsl.c

679

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

689

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

694

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

746

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

749

ata_port_dbg(ap, "HStatus = 0x%x\n", ioread32(hcr_base + HSTATUS));

drivers/ata/sata_fsl.c

750

ata_port_dbg(ap, "HControl = 0x%x\n", ioread32(hcr_base + HCONTROL));

drivers/ata/sata_fsl.c

751

ata_port_dbg(ap, "CHBA = 0x%x\n", ioread32(hcr_base + CHBA));

drivers/ata/sata_fsl.c

767

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

789

temp = ioread32(hcr_base + SIGNATURE);

drivers/ata/sata_fsl.c

791

ata_port_dbg(ap, "HStatus = 0x%x\n", ioread32(hcr_base + HSTATUS));

drivers/ata/sata_fsl.c

792

ata_port_dbg(ap, "HControl = 0x%x\n", ioread32(hcr_base + HCONTROL));

drivers/ata/sata_fsl.c

816

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

839

ioread32(hcr_base + HSTATUS),

drivers/ata/sata_fsl.c

840

ioread32(hcr_base + HCONTROL));

drivers/ata/sata_fsl.c

856

temp = ioread32(hcr_base + HCONTROL);

drivers/ata/sata_fsl.c

870

ioread32(hcr_base + HSTATUS),

drivers/ata/sata_fsl.c

871

ioread32(hcr_base + HCONTROL));

drivers/ata/sata_fsl.c

882

ioread32(hcr_base + HSTATUS));

drivers/ata/sata_fsl.c

960

ioread32(CQ + hcr_base),

drivers/ata/sata_fsl.c

961

ioread32(CA + hcr_base), ioread32(CC + hcr_base));

drivers/ata/sata_fsl.c

973

ioread32(CQ + hcr_base),

drivers/ata/sata_fsl.c

974

ioread32(CA + hcr_base), ioread32(CC + hcr_base));

drivers/ata/sata_fsl.c

979

ioread32(hcr_base + HSTATUS),

drivers/ata/sata_fsl.c

980

ioread32(hcr_base + HCONTROL),

drivers/ata/sata_nv.c

1509

*val = ioread32(link->ap->ioaddr.scr_addr + (sc_reg * 4));

drivers/ata/sata_rcar.c

185

val = ioread32(base + SATAPHYACK_REG);

drivers/ata/sata_rcar.c

247

u16 data = ioread32(reg);

drivers/ata/sata_rcar.c

263

return ioread32(ap->ioaddr.status_addr);

drivers/ata/sata_rcar.c

268

return ioread32(ap->ioaddr.altstatus_addr);

drivers/ata/sata_rcar.c

298

nsect = ioread32(ioaddr->nsect_addr);

drivers/ata/sata_rcar.c

299

lbal = ioread32(ioaddr->lbal_addr);

drivers/ata/sata_rcar.c

398

tf->error = ioread32(ioaddr->error_addr);

drivers/ata/sata_rcar.c

399

tf->nsect = ioread32(ioaddr->nsect_addr);

drivers/ata/sata_rcar.c

400

tf->lbal = ioread32(ioaddr->lbal_addr);

drivers/ata/sata_rcar.c

401

tf->lbam = ioread32(ioaddr->lbam_addr);

drivers/ata/sata_rcar.c

402

tf->lbah = ioread32(ioaddr->lbah_addr);

drivers/ata/sata_rcar.c

403

tf->device = ioread32(ioaddr->device_addr);

drivers/ata/sata_rcar.c

407

tf->hob_feature = ioread32(ioaddr->error_addr);

drivers/ata/sata_rcar.c

408

tf->hob_nsect = ioread32(ioaddr->nsect_addr);

drivers/ata/sata_rcar.c

409

tf->hob_lbal = ioread32(ioaddr->lbal_addr);

drivers/ata/sata_rcar.c

410

tf->hob_lbam = ioread32(ioaddr->lbam_addr);

drivers/ata/sata_rcar.c

411

tf->hob_lbah = ioread32(ioaddr->lbah_addr);

drivers/ata/sata_rcar.c

475

ioread32(ap->ioaddr.data_addr);

drivers/ata/sata_rcar.c

487

*val = ioread32(link->ap->ioaddr.scr_addr + (sc_reg << 2));

drivers/ata/sata_rcar.c

549

dmactl = ioread32(base + ATAPI_CONTROL1_REG);

drivers/ata/sata_rcar.c

571

dmactl = ioread32(base + ATAPI_CONTROL1_REG);

drivers/ata/sata_rcar.c

585

dmactl = ioread32(base + ATAPI_CONTROL1_REG);

drivers/ata/sata_rcar.c

602

status = ioread32(priv->base + ATAPI_STATUS_REG);

drivers/ata/sata_rcar.c

657

serror = ioread32(priv->base + SCRSERR_REG);

drivers/ata/sata_rcar.c

707

sataintstat = ioread32(base + SATAINTSTAT_REG);

drivers/ata/sata_rcar.c

767

val = ioread32(base + ATAPI_CONTROL1_REG);

drivers/ata/sata_rcar.c

772

val = ioread32(base + ATAPI_CONTROL1_REG);

drivers/ata/sata_rcar.c

779

val = ioread32(base + ATAPI_CONTROL1_REG);

drivers/ata/sata_sis.c

162

*val = ioread32(base + sc_reg * 4);

drivers/ata/sata_via.c

190

*val = ioread32(link->ap->ioaddr.scr_addr + (4 * sc_reg));

drivers/atm/solos-pci.c

1060

card_flags = ioread32(card->config_regs + FLAGS_ADDR);

drivers/atm/solos-pci.c

1240

ioread32(card->config_regs + FPGA_MODE);

drivers/atm/solos-pci.c

1243

ioread32(card->config_regs + FPGA_MODE);

drivers/atm/solos-pci.c

1246

data32 = ioread32(card->config_regs + FPGA_VER);

drivers/atm/solos-pci.c

1272

data32 = ioread32(card->config_regs + PORTS);

drivers/atm/solos-pci.c

1441

(void)ioread32(card->config_regs + FPGA_MODE);

drivers/atm/solos-pci.c

1455

(void)ioread32(card->config_regs + FPGA_MODE);

drivers/atm/solos-pci.c

527

data32 = ioread32(card->config_regs + GPIO_STATUS);

drivers/atm/solos-pci.c

548

data32 = ioread32(card->config_regs + GPIO_STATUS);

drivers/atm/solos-pci.c

561

data32 = ioread32(card->config_regs + GPIO_STATUS);

drivers/atm/solos-pci.c

691

(void) ioread32(card->config_regs + FPGA_MODE);

drivers/atm/solos-pci.c

702

wait_event(card->fw_wq, !ioread32(card->config_regs + FLASH_BUSY));

drivers/atm/solos-pci.c

730

wait_event(card->fw_wq, !ioread32(card->config_regs + FLASH_BUSY));

drivers/base/regmap/regmap-mmio.c

296

return ioread32(ctx->regs + reg);

drivers/bcma/host_pci.c

134

return ioread32(core->bus->mmio + (1 * BCMA_CORE_SIZE) + offset);

drivers/bcma/host_pci.c

57

return ioread32(core->bus->mmio + offset);

drivers/bluetooth/btintel_pcie.h

525

return ioread32(data->base_addr + offset);

drivers/bluetooth/btintel_pcie.h

545

r = ioread32(data->base_addr + offset);

drivers/bluetooth/btintel_pcie.h

555

r = ioread32(data->base_addr + offset);

drivers/bluetooth/hci_bcm4377.c

1835

bootstage = ioread32(bcm4377->bar2 + bcm4377->hw->bar2_offset + BCM4377_BAR2_BOOTSTAGE);

drivers/bluetooth/hci_bcm4377.c

1836

rti_status = ioread32(bcm4377->bar2 + bcm4377->hw->bar2_offset + BCM4377_BAR2_RTI_STATUS);

drivers/bluetooth/hci_bcm4377.c

843

bootstage = ioread32(bcm4377->bar2 + bcm4377->hw->bar2_offset + BCM4377_BAR2_BOOTSTAGE);

drivers/bluetooth/hci_bcm4377.c

844

rti_status = ioread32(bcm4377->bar2 + bcm4377->hw->bar2_offset + BCM4377_BAR2_RTI_STATUS);

drivers/bus/brcmstb_gisb.c

169

return ioread32(gdev->base + offset);

drivers/bus/qcom-ssc-block-bus.c

50

u32 tmp = ioread32(reg);

drivers/bus/qcom-ssc-block-bus.c

57

u32 tmp = ioread32(reg);

drivers/char/hw_random/amd-rng.c

76

if (ioread32(priv->iobase + RNGDONE) == 0) {

drivers/char/hw_random/amd-rng.c

86

*data = ioread32(priv->iobase + RNGDATA);

drivers/char/hw_random/ba431-rng.c

49

return ioread32(ba431->base + reg);

drivers/char/hw_random/cctrng.c

83

return ioread32(drvdata->cc_base + reg);

drivers/char/hw_random/iproc-rng200.c

106

status = ioread32(priv->base + RNG_INT_STATUS_OFFSET);

drivers/char/hw_random/iproc-rng200.c

118

if ((ioread32(priv->base + RNG_FIFO_COUNT_OFFSET) &

drivers/char/hw_random/iproc-rng200.c

123

*(uint32_t *)buf = ioread32(priv->base +

drivers/char/hw_random/iproc-rng200.c

129

uint32_t rnd_number = ioread32(priv->base +

drivers/char/hw_random/iproc-rng200.c

52

val = ioread32(rng_base + RNG_CTRL_OFFSET);

drivers/char/hw_random/iproc-rng200.c

71

val = ioread32(rng_base + RBG_SOFT_RESET_OFFSET);

drivers/char/hw_random/iproc-rng200.c

75

val = ioread32(rng_base + RNG_SOFT_RESET_OFFSET);

drivers/char/hw_random/iproc-rng200.c

79

val = ioread32(rng_base + RNG_SOFT_RESET_OFFSET);

drivers/char/hw_random/iproc-rng200.c

83

val = ioread32(rng_base + RBG_SOFT_RESET_OFFSET);

drivers/char/tpm/tpm_crb.c

149

if ((ioread32(reg) & mask) == value)

drivers/char/tpm/tpm_crb.c

155

return ((ioread32(reg) & mask) == value);

drivers/char/tpm/tpm_crb.c

358

if ((ioread32(&priv->regs_t->ctrl_start) & CRB_START_INVOKE) !=

drivers/char/tpm/tpm_crb.c

379

if (ioread32(&priv->regs_t->ctrl_sts) & CRB_CTRL_STS_ERROR)

drivers/char/tpm/tpm_crb.c

518

u32 cancel = ioread32(&priv->regs_t->ctrl_cancel);

drivers/char/tpm/tpm_crb.c

692

pa_high = ioread32(&priv->regs_t->ctrl_cmd_pa_high);

drivers/char/tpm/tpm_crb.c

693

pa_low = ioread32(&priv->regs_t->ctrl_cmd_pa_low);

drivers/char/tpm/tpm_crb.c

695

cmd_size = ioread32(&priv->regs_t->ctrl_cmd_size);

drivers/char/tpm/tpm_crb.c

722

rsp_size = ioread32(&priv->regs_t->ctrl_rsp_size);

drivers/char/tpm/tpm_tis.c

188

result_le32 = cpu_to_le32(ioread32(phy->iobase + addr));

drivers/char/tpm/tpm_tis_core.c

1062

clkrun_val = ioread32(data->ilb_base_addr + LPC_CNTRL_OFFSET);

drivers/char/tpm/tpm_tis_core.c

1073

clkrun_val = ioread32(data->ilb_base_addr + LPC_CNTRL_OFFSET);

drivers/char/tpm/tpm_tis_core.c

1163

clkrun_val = ioread32(priv->ilb_base_addr + LPC_CNTRL_OFFSET);

drivers/clk/axs10x/pll_clock.c

106

return ioread32(clk->base + reg);

drivers/clk/axs10x/pll_clock.c

196

if (!(ioread32(clk->lock) & PLL_LOCK))

drivers/clk/axs10x/pll_clock.c

199

if (ioread32(clk->lock) & PLL_ERROR)

drivers/clk/clk-asm9260.c

276

rate = (ioread32(base + HW_SYSPLLCTRL) & 0xffff) * 1000000;

drivers/clk/clk-hsdk-pll.c

128

return ioread32(clk->regs + reg);

drivers/clk/clk-qoriq.c

116

val = ioread32(reg);

drivers/clk/xilinx/xlnx_vcu.c

215

return ioread32(iomem + offset);

drivers/clocksource/em_sti.c

55

return ioread32(p->base + offs);

drivers/clocksource/sh_cmt.c

166

return ioread32(base + (offs << 2));

drivers/clocksource/sh_cmt.c

931

value = ioread32(cmt->mapbase + CMCLKE);

drivers/clocksource/sh_tmu.c

102

return ioread32(ch->base + offs);

drivers/clocksource/timer-econet-en751221.c

103

reg = ioread32(reg_ctl(cpu)) | ctl_bit_enabled(cpu);

drivers/clocksource/timer-econet-en751221.c

118

return (u64)ioread32(reg_count(0));

drivers/clocksource/timer-econet-en751221.c

62

return ioread32(reg_ctl(cpu_id)) & ctl_bit_pending(cpu_id);

drivers/clocksource/timer-econet-en751221.c

76

iowrite32(ioread32(reg_count(cpu)), reg_compare(cpu));

drivers/clocksource/timer-econet-en751221.c

87

next = ioread32(reg_count(cpu)) + delta;

drivers/clocksource/timer-econet-en751221.c

90

if ((s32)(next - ioread32(reg_count(cpu))) < ECONET_MIN_DELTA / 2)

drivers/clocksource/timer-fsl-ftm.c

37

return ioread32(addr);

drivers/clocksource/timer-ralink.c

46

count = ioread32(sdev->membase + SYSTICK_COUNT);

drivers/clocksource/timer-rtl-otto.c

59

return ioread32(base + RTTM_CNT);

drivers/clocksource/timer-rtl-otto.c

79

iowrite32(ioread32(base + RTTM_INT) | RTTM_INT_PENDING, base + RTTM_INT);

drivers/comedi/drivers/mf6x4.c

115

status = ioread32(devpriv->gpioc_reg);

drivers/comedi/drivers/mf6x4.c

166

gpioc = ioread32(devpriv->gpioc_reg);

drivers/counter/ftm-quaddec.c

40

*data = ioread32(ftm->ftm_base + offset);

drivers/cpufreq/pcc-cpufreq.c

163

ioread32(pcch_virt_addr + pcc_cpu_data->output_offset);

drivers/cpufreq/pcc-cpufreq.c

175

curr_freq = (((ioread32(&pcch_hdr->nominal) * (output_buffer & 0xff))

drivers/cpufreq/pcc-cpufreq.c

222

/ (ioread32(&pcch_hdr->nominal) * 1000)) << 8);

drivers/cpufreq/pcc-cpufreq.c

463

mem_resource->minimum, ioread32(&pcch_hdr->signature),

drivers/cpufreq/pcc-cpufreq.c

465

ioread8(&pcch_hdr->minor), ioread32(&pcch_hdr->features),

drivers/cpufreq/pcc-cpufreq.c

467

ioread32(&pcch_hdr->latency));

drivers/cpufreq/pcc-cpufreq.c

474

ioread32(&pcch_hdr->minimum_time),

drivers/cpufreq/pcc-cpufreq.c

475

ioread32(&pcch_hdr->maximum_time),

drivers/cpufreq/pcc-cpufreq.c

476

ioread32(&pcch_hdr->nominal),

drivers/cpufreq/pcc-cpufreq.c

477

ioread32(&pcch_hdr->throttled_frequency),

drivers/cpufreq/pcc-cpufreq.c

478

ioread32(&pcch_hdr->minimum_frequency));

drivers/cpufreq/pcc-cpufreq.c

527

ioread32(&pcch_hdr->minimum_frequency),

drivers/cpufreq/pcc-cpufreq.c

528

ioread32(&pcch_hdr->nominal));

drivers/cpufreq/pcc-cpufreq.c

555

ioread32(&pcch_hdr->nominal) * 1000;

drivers/cpufreq/pcc-cpufreq.c

557

ioread32(&pcch_hdr->minimum_frequency) * 1000;

drivers/crypto/bcm/util.c

457

spu_ofifo_ctrl = ioread32(ipriv->spu.reg_vbase[i] +

drivers/crypto/caam/regs.h

112

return ioread32(reg);

drivers/crypto/caam/regs.h

120

iowrite32((ioread32(reg) & ~clear) | set, reg);

drivers/crypto/caam/regs.h

162

high = ioread32(reg);

drivers/crypto/caam/regs.h

163

low = ioread32(reg + sizeof(u32));

drivers/crypto/ccp/ccp-debugfs.c

224

regval = ioread32(cmd_q->reg_int_enable);

drivers/crypto/ccp/ccp-debugfs.c

63

regval = ioread32(ccp->io_regs + CMD5_PSP_CCP_VERSION);

drivers/crypto/ccp/ccp-dev-v3.c

331

status = ioread32(ccp->io_regs + IRQ_STATUS_REG);

drivers/crypto/ccp/ccp-dev-v3.c

339

cmd_q->q_status = ioread32(cmd_q->reg_status);

drivers/crypto/ccp/ccp-dev-v3.c

340

cmd_q->q_int_status = ioread32(cmd_q->reg_int_status);

drivers/crypto/ccp/ccp-dev-v3.c

380

qmr = ioread32(ccp->io_regs + Q_MASK_REG);

drivers/crypto/ccp/ccp-dev-v3.c

446

ioread32(cmd_q->reg_int_status);

drivers/crypto/ccp/ccp-dev-v3.c

447

ioread32(cmd_q->reg_status);

drivers/crypto/ccp/ccp-dev-v3.c

537

ioread32(cmd_q->reg_int_status);

drivers/crypto/ccp/ccp-dev-v3.c

538

ioread32(cmd_q->reg_status);

drivers/crypto/ccp/ccp-dev-v3.c

71

return CMD_Q_DEPTH(ioread32(cmd_q->reg_status));

drivers/crypto/ccp/ccp-dev-v5.c

1039

ioread32(cmd_q->reg_int_status);

drivers/crypto/ccp/ccp-dev-v5.c

1040

ioread32(cmd_q->reg_status);

drivers/crypto/ccp/ccp-dev-v5.c

1081

rnd = ioread32(ccp->io_regs + TRNG_OUT_REG);

drivers/crypto/ccp/ccp-dev-v5.c

213

head_lo = ioread32(cmd_q->reg_head_lo);

drivers/crypto/ccp/ccp-dev-v5.c

745

status = ioread32(cmd_q->reg_interrupt_status);

drivers/crypto/ccp/ccp-dev-v5.c

749

cmd_q->q_status = ioread32(cmd_q->reg_status);

drivers/crypto/ccp/ccp-dev-v5.c

750

cmd_q->q_int_status = ioread32(cmd_q->reg_int_status);

drivers/crypto/ccp/ccp-dev-v5.c

791

qmr = ioread32(ccp->io_regs + Q_MASK_REG);

drivers/crypto/ccp/ccp-dev-v5.c

881

ioread32(cmd_q->reg_int_status);

drivers/crypto/ccp/ccp-dev-v5.c

882

ioread32(cmd_q->reg_status);

drivers/crypto/ccp/ccp-dev-v5.c

902

status_lo = ioread32(ccp->io_regs + LSB_PRIVATE_MASK_LO_OFFSET);

drivers/crypto/ccp/ccp-dev-v5.c

903

status_hi = ioread32(ccp->io_regs + LSB_PRIVATE_MASK_HI_OFFSET);

drivers/crypto/ccp/ccp-dev.c

515

trng_value = ioread32(ccp->io_regs + TRNG_OUT_REG);

drivers/crypto/ccp/platform-access.c

115

if (ioread32(lo) != lower_32_bits(req_addr) ||

drivers/crypto/ccp/platform-access.c

116

ioread32(hi) != upper_32_bits(req_addr)) {

drivers/crypto/ccp/platform-access.c

128

cmd_reg = ioread32(cmd);

drivers/crypto/ccp/platform-access.c

178

val = FIELD_GET(DOORBELL_CMDRESP_STS, ioread32(cmd));

drivers/crypto/ccp/platform-access.c

27

return FIELD_GET(PSP_CMDRESP_RECOVERY, ioread32(cmd));

drivers/crypto/ccp/psp-dev.c

130

status = ioread32(psp->io_regs + psp->vdata->intsts_reg);

drivers/crypto/ccp/psp-dev.c

146

unsigned int val = ioread32(psp->io_regs + psp->vdata->feature_reg);

drivers/crypto/ccp/psp-dev.c

33

*cmdresp = ioread32(cmdresp_reg);

drivers/crypto/ccp/sev-dev.c

162

reg = ioread32(sev->io_regs + sev->vdata->cmdresp_reg);

drivers/crypto/ccp/sev-dev.c

184

*reg = ioread32(sev->io_regs + sev->vdata->cmdresp_reg);

drivers/crypto/ccp/sev-dev.c

198

*reg = ioread32(sev->io_regs + sev->vdata->cmdresp_reg);

drivers/crypto/ccp/sev-dev.c

971

cmdbuff_hi = ioread32(sev->io_regs + sev->vdata->cmdbuff_addr_hi_reg);

drivers/crypto/ccp/sev-dev.c

972

cmdbuff_lo = ioread32(sev->io_regs + sev->vdata->cmdbuff_addr_lo_reg);

drivers/crypto/ccp/sp-pci.c

49

unsigned int val = ioread32(psp->io_regs + _offset); \

drivers/crypto/ccp/sp-pci.c

80

val = ioread32(psp->io_regs + psp->vdata->bootloader_info_reg);

drivers/crypto/ccp/sp-pci.c

84

val = ioread32(psp->io_regs + psp->vdata->tee->info_reg);

drivers/crypto/ccp/tee-dev.c

259

rptr = ioread32(tee->io_regs + tee->vdata->ring_rptr_reg);

drivers/crypto/ccree/cc_driver.h

219

return ioread32(drvdata->cc_base + reg);

drivers/crypto/geode-aes.c

43

((u32 *) value)[i] = ioread32(_iobase + offset + (i * 4));

drivers/crypto/geode-aes.c

60

status = ioread32(_iobase + AES_INTR_REG);

drivers/crypto/intel/keembay/keembay-ocs-ecc.c

867

status = ioread32(ecc_dev->base_reg + HW_OFFS_OCS_ECC_ISR);

drivers/crypto/intel/keembay/ocs-aes.c

1279

tag[i] = ioread32(aes_dev->base_reg +

drivers/crypto/intel/keembay/ocs-aes.c

1281

yr[i] = ioread32(aes_dev->base_reg +

drivers/crypto/intel/keembay/ocs-aes.c

244

aes_active_reg = ioread32(aes_dev->base_reg +

drivers/crypto/intel/keembay/ocs-aes.c

255

reg = ioread32(aes_dev->base_reg + AES_A_DMA_STATUS_OFFSET);

drivers/crypto/intel/keembay/ocs-aes.c

323

while (ioread32(aes_dev->base_reg + AES_A_DMA_PERF_CNTR_OFFSET) < delay)

drivers/crypto/intel/keembay/ocs-aes.c

340

isr_val = ioread32(aes_dev->base_reg + AES_A_DMA_MSI_ISR_OFFSET);

drivers/crypto/intel/keembay/ocs-aes.c

345

isr_val = ioread32(aes_dev->base_reg + AES_A_DMA_MSI_MASK_OFFSET);

drivers/crypto/intel/keembay/ocs-aes.c

350

isr_val = ioread32(aes_dev->base_reg + AES_ISR_OFFSET);

drivers/crypto/intel/keembay/ocs-aes.c

446

aes_dma_isr = ioread32(aes_dev->base_reg + AES_A_DMA_MSI_ISR_OFFSET);

drivers/crypto/intel/keembay/ocs-aes.c

866

iv32[0] = ioread32(aes_dev->base_reg + AES_IV_0_OFFSET);

drivers/crypto/intel/keembay/ocs-aes.c

867

iv32[1] = ioread32(aes_dev->base_reg + AES_IV_1_OFFSET);

drivers/crypto/intel/keembay/ocs-aes.c

868

iv32[2] = ioread32(aes_dev->base_reg + AES_IV_2_OFFSET);

drivers/crypto/intel/keembay/ocs-aes.c

869

iv32[3] = ioread32(aes_dev->base_reg + AES_IV_3_OFFSET);

drivers/crypto/intel/keembay/ocs-aes.c

902

tag_u32[0] = __swab32(ioread32(aes_dev->base_reg + AES_T_MAC_3_OFFSET));

drivers/crypto/intel/keembay/ocs-aes.c

903

tag_u32[1] = __swab32(ioread32(aes_dev->base_reg + AES_T_MAC_2_OFFSET));

drivers/crypto/intel/keembay/ocs-aes.c

904

tag_u32[2] = __swab32(ioread32(aes_dev->base_reg + AES_T_MAC_1_OFFSET));

drivers/crypto/intel/keembay/ocs-aes.c

905

tag_u32[3] = __swab32(ioread32(aes_dev->base_reg + AES_T_MAC_0_OFFSET));

drivers/crypto/xilinx/xilinx-trng.c

126

*(buf + read) = cpu_to_be32(ioread32(rng_base + TRNG_CORE_OUTPUT_OFFSET));

drivers/crypto/xilinx/xilinx-trng.c

78

val = ioread32(addr);

drivers/dma/altera-msgdma.c

503

while (ioread32(mdev->csr + MSGDMA_CSR_STATUS) &

drivers/dma/altera-msgdma.c

695

count = ioread32(mdev->csr + MSGDMA_CSR_RESP_FILL_LEVEL);

drivers/dma/altera-msgdma.c

710

size = ioread32(mdev->resp +

drivers/dma/altera-msgdma.c

712

status = ioread32(mdev->resp +

drivers/dma/altera-msgdma.c

736

status = ioread32(mdev->csr + MSGDMA_CSR_STATUS);

drivers/dma/amd/ptdma/ptdma-debugfs.c

41

regval = ioread32(pt->io_regs + CMD_PT_VERSION);

drivers/dma/amd/ptdma/ptdma-debugfs.c

80

regval = ioread32(cmd_q->reg_control + 0x000C);

drivers/dma/amd/ptdma/ptdma-dev.c

148

status = ioread32(cmd_q->reg_control + 0x0010);

drivers/dma/amd/ptdma/ptdma-dev.c

151

cmd_q->q_status = ioread32(cmd_q->reg_control + 0x0100);

drivers/dma/amd/ptdma/ptdma-dev.c

152

cmd_q->q_int_status = ioread32(cmd_q->reg_control + 0x0104);

drivers/dma/amd/ptdma/ptdma-dev.c

227

ioread32(cmd_q->reg_control + 0x0104);

drivers/dma/amd/ptdma/ptdma-dev.c

228

ioread32(cmd_q->reg_control + 0x0100);

drivers/dma/amd/ptdma/ptdma-dev.c

294

ioread32(cmd_q->reg_control + 0x0104);

drivers/dma/amd/ptdma/ptdma-dev.c

295

ioread32(cmd_q->reg_control + 0x0100);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

413

val = ioread32(chan->chip->apb_regs + offset);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

62

return ioread32(chip->regs + reg);

drivers/dma/dw-axi-dmac/dw-axi-dmac-platform.c

84

return ioread32(chan->chan_regs + reg);

drivers/dma/fsl-edma-common.h

380

l = ioread32(addr);

drivers/dma/fsl-edma-common.h

381

h = ioread32(addr + 4);

drivers/dma/fsl-edma-common.h

397

val = ioread32(addr);

drivers/dma/fsldma.h

238

#define fsl_ioread32(p) ioread32(p)

drivers/dma/idxd/device.c

1012

ioread32(idxd->reg_base + wq_offset));

drivers/dma/idxd/device.c

1252

reg.bits = ioread32(idxd->reg_base + IDXD_GENCFG_OFFSET);

drivers/dma/idxd/device.c

26

genctrl.bits = ioread32(idxd->reg_base + IDXD_GENCTRL_OFFSET);

drivers/dma/idxd/device.c

328

wqcfg.bits[WQCFG_PASID_IDX] = ioread32(idxd->reg_base + offset);

drivers/dma/idxd/device.c

36

genctrl.bits = ioread32(idxd->reg_base + IDXD_GENCTRL_OFFSET);

drivers/dma/idxd/device.c

366

wqcfg.bits[WQCFG_PASID_IDX] = ioread32(idxd->reg_base + offset);

drivers/dma/idxd/device.c

451

gensts.bits = ioread32(idxd->reg_base + IDXD_GENSTATS_OFFSET);

drivers/dma/idxd/device.c

462

gensts.bits = ioread32(idxd->reg_base + IDXD_GENSTATS_OFFSET);

drivers/dma/idxd/device.c

488

while (ioread32(idxd->reg_base + IDXD_CMDSTS_OFFSET) &

drivers/dma/idxd/device.c

534

stat = ioread32(idxd->reg_base + IDXD_CMDSTS_OFFSET);

drivers/dma/idxd/device.c

668

while (ioread32(idxd->reg_base + IDXD_CMDSTS_OFFSET) & IDXD_CMDSTS_ACTIVE)

drivers/dma/idxd/device.c

670

status = ioread32(idxd->reg_base + IDXD_CMDSTS_OFFSET);

drivers/dma/idxd/device.c

807

genctrl.bits = ioread32(idxd->reg_base + IDXD_GENCTRL_OFFSET);

drivers/dma/idxd/device.c

811

gencfg.bits = ioread32(idxd->reg_base + IDXD_GENCFG_OFFSET);

drivers/dma/idxd/device.c

841

genctrl.bits = ioread32(idxd->reg_base + IDXD_GENCTRL_OFFSET);

drivers/dma/idxd/device.c

900

reg.bits = ioread32(idxd->reg_base + IDXD_GENCFG_OFFSET);

drivers/dma/idxd/device.c

906

ioread32(idxd->reg_base + IDXD_GENCFG_OFFSET));

drivers/dma/idxd/device.c

942

wq->wqcfg->bits[i] |= ioread32(idxd->reg_base + wq_offset);

drivers/dma/idxd/idxd.h

527

reg.bits = ioread32(idxd->reg_base + IDXD_GENCFG_OFFSET);

drivers/dma/idxd/init.c

1206

idxd->hw.version = ioread32(idxd->reg_base + IDXD_VER_OFFSET);

drivers/dma/idxd/init.c

539

idxd->hw.cmd_cap = ioread32(idxd->reg_base + IDXD_CMDCAP_OFFSET);

drivers/dma/idxd/irq.c

415

gensts.bits = ioread32(idxd->reg_base + IDXD_GENSTATS_OFFSET);

drivers/dma/idxd/irq.c

463

cause = ioread32(idxd->reg_base + IDXD_INTCAUSE_OFFSET);

drivers/dma/idxd/perfmon.c

238

ovfstatus = ioread32(OVFSTATUS_REG(idxd));

drivers/dma/idxd/perfmon.c

261

ovfstatus = ioread32(OVFSTATUS_REG(idxd));

drivers/dma/idxd/sysfs.c

1157

occup = ioread32(idxd->reg_base + offset) & WQCFG_OCCUP_MASK;

drivers/dma/mcf-edma-main.c

24

intmap = ioread32(regs->inth);

drivers/dma/mcf-edma-main.c

26

intmap |= ioread32(regs->intl);

drivers/dma/mcf-edma-main.c

46

err = ioread32(regs->errl);

drivers/dma/mcf-edma-main.c

58

err = ioread32(regs->errh);

drivers/dma/nbpfaxi.c

307

u32 data = ioread32(chan->base + offset);

drivers/dma/nbpfaxi.c

324

u32 data = ioread32(nbpf->base + offset);

drivers/dma/ppc4xx/adma.c

1186

return ioread32(&dma_reg->acpl) & (~DMA_CDB_MSK);

drivers/dma/ppc4xx/adma.c

3953

mask = ioread32(&adev->i2o_reg->iopim) & enable;

drivers/dma/ppc4xx/adma.c

3986

mask = ioread32(&adev->i2o_reg->iopim) | disable;

drivers/dma/ppc4xx/adma.c

910

while ((rv = ioread32(&dma_reg->csfpl))) {

drivers/dma/ppc4xx/adma.c

972

rv = ioread32(&dma_reg->dsts);

drivers/dma/timb_dma.c

118

ier = ioread32(td->membase + TIMBDMA_IER);

drivers/dma/timb_dma.c

136

isr = ioread32(td->membase + TIMBDMA_ISR) & (1 << id);

drivers/dma/timb_dma.c

574

isr = ioread32(td->membase + TIMBDMA_ISR);

drivers/dma/timb_dma.c

598

u32 ipr = ioread32(td->membase + TIMBDMA_IPR);

drivers/dma/xgene-dma.c

1018

val = ioread32(pdma->csr_dma + XGENE_DMA_INT);

drivers/dma/xgene-dma.c

1101

val = ioread32(ring->pdma->csr_ring + XGENE_DMA_RING_NE_INT_MODE);

drivers/dma/xgene-dma.c

1112

val = ioread32(ring->pdma->csr_ring +

drivers/dma/xgene-dma.c

1278

val = ioread32(pdma->csr_dma + XGENE_DMA_GCR);

drivers/dma/xgene-dma.c

1288

val = ioread32(pdma->csr_dma + XGENE_DMA_GCR);

drivers/dma/xgene-dma.c

1355

val = ioread32(pdma->csr_dma + XGENE_DMA_IPBRR);

drivers/dma/xgene-dma.c

1366

if (ioread32(pdma->csr_ring + XGENE_DMA_RING_CLKEN) &&

drivers/dma/xgene-dma.c

1367

(!ioread32(pdma->csr_ring + XGENE_DMA_RING_SRST)))

drivers/dma/xgene-dma.c

1377

ioread32(pdma->csr_ring + XGENE_DMA_RING_MEM_RAM_SHUTDOWN);

drivers/dma/xgene-dma.c

1382

if (ioread32(pdma->csr_ring + XGENE_DMA_RING_BLK_MEM_RDY)

drivers/dma/xgene-dma.c

1416

ioread32(pdma->csr_dma + XGENE_DMA_MEM_RAM_SHUTDOWN);

drivers/dma/xgene-dma.c

1421

if (ioread32(pdma->csr_dma + XGENE_DMA_BLK_MEM_RDY)

drivers/dma/xgene-dma.c

348

val = ioread32(pdma->csr_efuse + XGENE_SOC_JTAG1_SHADOW);

drivers/dma/xilinx/xilinx_dma.c

539

return ioread32(chan->xdev->regs + reg);

drivers/dma/xilinx/xilinx_dpdma.c

470

return ioread32(base + offset);

drivers/edac/fsl_ddr_edac.c

50

return pdata->little_endian ? ioread32(addr) : ioread32be(addr);

drivers/firmware/arm_scmi/perf.c

636

*max_perf = ioread32(fci->get_addr);

drivers/firmware/arm_scmi/perf.c

637

*min_perf = ioread32(fci->get_addr + 4);

drivers/firmware/arm_scmi/perf.c

770

*level = ioread32(dom->fc_info[PERF_FC_LEVEL].get_addr);

drivers/firmware/arm_scmi/powercap.c

341

*power_cap = ioread32(dom->fc_info[POWERCAP_FC_CAP].get_addr);

drivers/firmware/arm_scmi/powercap.c

498

*pai = ioread32(dom->fc_info[POWERCAP_FC_PAI].get_addr);

drivers/firmware/arm_scmi/shmem.c

110

spin_until_cond((ioread32(&shmem->channel_status) &

drivers/firmware/arm_scmi/shmem.c

113

if (!(ioread32(&shmem->channel_status) &

drivers/firmware/arm_scmi/shmem.c

133

return ioread32(&shmem->msg_header);

drivers/firmware/arm_scmi/shmem.c

140

size_t len = ioread32(&shmem->length);

drivers/firmware/arm_scmi/shmem.c

142

xfer->hdr.status = ioread32(shmem->msg_payload);

drivers/firmware/arm_scmi/shmem.c

154

size_t len = ioread32(&shmem->length);

drivers/firmware/arm_scmi/shmem.c

173

xfer_id = MSG_XTRACT_TOKEN(ioread32(&shmem->msg_header));

drivers/firmware/arm_scmi/shmem.c

178

return ioread32(&shmem->channel_status) &

drivers/firmware/arm_scmi/shmem.c

185

return (ioread32(&shmem->channel_status) &

drivers/firmware/arm_scmi/shmem.c

191

return ioread32(&shmem->flags) & SCMI_SHMEM_FLAG_INTR_ENABLED;

drivers/firmware/arm_scpi.c

395

match->status = ioread32(&mem->status);

drivers/firmware/arm_scpi.c

402

match->status = ioread32(&mem->status);

drivers/firmware/arm_scpi.c

420

cmd = ioread32(&mem->command);

drivers/fsi/fsi-master-ast-cf.c

1151

if (ioread32(master->sram + CF_STARTED) == 0) {

drivers/fsi/fsi-master-ast-cf.c

913

val = ioread32(master->cvic + CVIC_EN_REG);

drivers/gpio/gpio-aspeed-sgpio.c

457

temp = ioread32(addr);

drivers/gpio/gpio-aspeed-sgpio.c

470

temp = ioread32(addr);

drivers/gpio/gpio-aspeed-sgpio.c

485

return !!(ioread32(addr) & GPIO_BIT(offset));

drivers/gpio/gpio-aspeed-sgpio.c

495

return ioread32(addr);

drivers/gpio/gpio-aspeed-sgpio.c

550

write_val = (ioread32(addr) & ~(mask)) | field_prep(mask, val);

drivers/gpio/gpio-aspeed-sgpio.c

566

return field_get(mask, ioread32(addr));

drivers/gpio/gpio-aspeed-sgpio.c

578

return ioread32(addr);

drivers/gpio/gpio-aspeed.c

1047

temp = ioread32(addr);

drivers/gpio/gpio-aspeed.c

1065

return !!(ioread32(addr) & GPIO_BIT(offset));

drivers/gpio/gpio-aspeed.c

1075

return ioread32(addr);

drivers/gpio/gpio-aspeed.c

1160

write_val = (ioread32(addr) & ~(mask)) | field_prep(mask, val);

drivers/gpio/gpio-aspeed.c

1176

return field_get(mask, ioread32(addr));

drivers/gpio/gpio-aspeed.c

1188

return ioread32(addr);

drivers/gpio/gpio-aspeed.c

814

cycles = ioread32(gpio->base + gpio->config->debounce_timers_array[i]);

drivers/gpio/gpio-cadence.c

107

int_value = ioread32(cgpio->regs + CDNS_GPIO_IRQ_VALUE) & ~mask;

drivers/gpio/gpio-cadence.c

108

int_type = ioread32(cgpio->regs + CDNS_GPIO_IRQ_TYPE) & ~mask;

drivers/gpio/gpio-cadence.c

118

int_any = ioread32(cgpio->regs + CDNS_GPIO_IRQ_ANY_EDGE) & ~mask;

drivers/gpio/gpio-cadence.c

152

status = ioread32(cgpio->regs + CDNS_GPIO_IRQ_STATUS) &

drivers/gpio/gpio-cadence.c

153

~ioread32(cgpio->regs + CDNS_GPIO_IRQ_MASK);

drivers/gpio/gpio-cadence.c

218

dir_prev = ioread32(cgpio->regs + CDNS_GPIO_DIRECTION_MODE);

drivers/gpio/gpio-cadence.c

288

cgpio->bypass_orig = ioread32(cgpio->regs + CDNS_GPIO_BYPASS_MODE);

drivers/gpio/gpio-cadence.c

60

iowrite32(ioread32(cgpio->regs + CDNS_GPIO_BYPASS_MODE) & ~BIT(offset),

drivers/gpio/gpio-cadence.c

72

iowrite32(ioread32(cgpio->regs + CDNS_GPIO_BYPASS_MODE) |

drivers/gpio/gpio-em.c

61

return ioread32(p->base0 + offs);

drivers/gpio/gpio-em.c

63

return ioread32(p->base1 + (offs - GIO_IDT0));

drivers/gpio/gpio-en7523.c

34

u32 dir = ioread32(ctrl->dir[gpio / 16]);

drivers/gpio/gpio-en7523.c

35

u32 output = ioread32(ctrl->output);

drivers/gpio/gpio-en7523.c

70

u32 dir = ioread32(ctrl->dir[gpio / 16]);

drivers/gpio/gpio-ml-ioh.c

115

return !!(ioread32(&chip->reg->regs[chip->ch].pi) & BIT(nr));

drivers/gpio/gpio-ml-ioh.c

127

pm = ioread32(&chip->reg->regs[chip->ch].pm);

drivers/gpio/gpio-ml-ioh.c

132

reg_val = ioread32(&chip->reg->regs[chip->ch].po);

drivers/gpio/gpio-ml-ioh.c

151

pm = ioread32(&chip->reg->regs[chip->ch].pm);

drivers/gpio/gpio-ml-ioh.c

169

ioread32(&chip->reg->regs[chip->ch].po);

drivers/gpio/gpio-ml-ioh.c

171

ioread32(&chip->reg->regs[chip->ch].pm);

drivers/gpio/gpio-ml-ioh.c

173

ioread32(&chip->reg->regs[chip->ch].ien);

drivers/gpio/gpio-ml-ioh.c

175

ioread32(&chip->reg->regs[chip->ch].imask);

drivers/gpio/gpio-ml-ioh.c

177

ioread32(&chip->reg->regs[chip->ch].im_0);

drivers/gpio/gpio-ml-ioh.c

179

ioread32(&chip->reg->regs[chip->ch].im_1);

drivers/gpio/gpio-ml-ioh.c

182

ioread32(&chip->reg->ioh_sel_reg[i]);

drivers/gpio/gpio-ml-ioh.c

286

im = ioread32(im_reg) & ~(IOH_IM_MASK << (im_pos * 4));

drivers/gpio/gpio-ml-ioh.c

296

ien = ioread32(&chip->reg->regs[chip->ch].ien);

drivers/gpio/gpio-ml-ioh.c

330

ien = ioread32(&chip->reg->regs[chip->ch].ien);

drivers/gpio/gpio-ml-ioh.c

344

ien = ioread32(&chip->reg->regs[chip->ch].ien);

drivers/gpio/gpio-ml-ioh.c

358

reg_val = ioread32(&chip->reg->regs[i].istatus);

drivers/gpio/gpio-ml-ioh.c

99

reg_val = ioread32(&chip->reg->regs[chip->ch].po);

drivers/gpio/gpio-pch.c

109

reg_val = ioread32(&chip->reg->po);

drivers/gpio/gpio-pch.c

125

return !!(ioread32(&chip->reg->pi) & BIT(nr));

drivers/gpio/gpio-pch.c

138

reg_val = ioread32(&chip->reg->po);

drivers/gpio/gpio-pch.c

145

pm = ioread32(&chip->reg->pm);

drivers/gpio/gpio-pch.c

162

pm = ioread32(&chip->reg->pm);

drivers/gpio/gpio-pch.c

176

chip->pch_gpio_reg.ien_reg = ioread32(&chip->reg->ien);

drivers/gpio/gpio-pch.c

177

chip->pch_gpio_reg.imask_reg = ioread32(&chip->reg->imask);

drivers/gpio/gpio-pch.c

178

chip->pch_gpio_reg.po_reg = ioread32(&chip->reg->po);

drivers/gpio/gpio-pch.c

179

chip->pch_gpio_reg.pm_reg = ioread32(&chip->reg->pm);

drivers/gpio/gpio-pch.c

180

chip->pch_gpio_reg.im0_reg = ioread32(&chip->reg->im0);

drivers/gpio/gpio-pch.c

182

chip->pch_gpio_reg.im1_reg = ioread32(&chip->reg->im1);

drivers/gpio/gpio-pch.c

184

chip->pch_gpio_reg.gpio_use_sel_reg = ioread32(&chip->reg->gpio_use_sel);

drivers/gpio/gpio-pch.c

271

im = ioread32(im_reg) & ~(PCH_IM_MASK << (im_pos * 4));

drivers/gpio/gpio-pch.c

311

unsigned long reg_val = ioread32(&chip->reg->istatus);

drivers/gpio/gpio-rcar.c

71

return ioread32(p->base + offs);

drivers/gpio/gpio-realtek-otto.c

144

return ioread32(reg);

drivers/gpio/gpio-realtek-otto.c

178

reg_val = ioread32(reg);

drivers/gpio/gpio-sch.c

273

core_status = ioread32(sch->regs + CORE_BANK_OFFSET + GTS);

drivers/gpio/gpio-sch.c

274

resume_status = ioread32(sch->regs + RESUME_BANK_OFFSET + GTS);

drivers/gpio/gpio-tb10x.c

50

return ioread32(gpio->base + offs);

drivers/gpio/gpio-timberdale.c

143

ver = ioread32(tgpio->membase + TGPIO_VER);

drivers/gpio/gpio-timberdale.c

147

lvr = ioread32(tgpio->membase + TGPIO_LVR);

drivers/gpio/gpio-timberdale.c

148

flr = ioread32(tgpio->membase + TGPIO_FLR);

drivers/gpio/gpio-timberdale.c

150

bflr = ioread32(tgpio->membase + TGPIO_BFLR);

drivers/gpio/gpio-timberdale.c

198

ipr = ioread32(tgpio->membase + TGPIO_IPR);

drivers/gpio/gpio-timberdale.c

50

reg = ioread32(tgpio->membase + offset);

drivers/gpio/gpio-timberdale.c

73

value = ioread32(tgpio->membase + TGPIOVAL);

drivers/gpio/gpio-xgene.c

102

dirval = ioread32(chip->base + bank_offset);

drivers/gpio/gpio-xgene.c

123

dirval = ioread32(chip->base + bank_offset);

drivers/gpio/gpio-xgene.c

141

gpio->set_dr_val[bank] = ioread32(gpio->base + bank_offset);

drivers/gpio/gpio-xgene.c

45

return !!(ioread32(chip->base + bank_offset) & BIT(bit_offset));

drivers/gpio/gpio-xgene.c

57

setval = ioread32(chip->base + bank_offset);

drivers/gpio/gpio-xgene.c

85

if (ioread32(chip->base + bank_offset) & BIT(bit_offset))

drivers/gpu/drm/ast/ast_drv.h

269

return ioread32(addr + reg);

drivers/gpu/drm/gma500/gem.c

328

(void)ioread32(pdev->gtt_map + i - 1);

drivers/gpu/drm/gma500/gtt.c

123

ioread32(gtt_slot - 1);

drivers/gpu/drm/gma500/gtt.c

182

(void)ioread32(pdev->gtt_map + i - 1);

drivers/gpu/drm/gma500/gtt.c

98

ioread32(gtt_slot - 1);

drivers/gpu/drm/gma500/intel_gmbus.c

57

#define GMBUS_REG_READ(reg) ioread32(dev_priv->gmbus_reg + (reg))

drivers/gpu/drm/gma500/psb_drv.h

651

return ioread32(dev_priv->vdc_reg + reg);

drivers/gpu/drm/gma500/psb_drv.h

657

return ioread32(dev_priv->aux_reg + reg);

drivers/gpu/drm/gma500/psb_drv.h

726

#define PSB_RVDC32(_offs) ioread32(dev_priv->vdc_reg + (_offs))

drivers/gpu/drm/gma500/psb_drv.h

728

#define PSB_RSGX32(_offs) ioread32(dev_priv->sgx_reg + (_offs))

drivers/gpu/drm/gma500/psb_drv.h

732

#define PSB_RMSVDX32(_offs) ioread32(dev_priv->msvdx_reg + (_offs))

drivers/gpu/drm/i915/display/intel_display_device.c

1534

val = ioread32(addr);

drivers/gpu/drm/i915/display/intel_rom.c

72

return ioread32(rom->oprom + offset);

drivers/gpu/drm/i915/gem/selftests/i915_gem_coherency.c

142

*v = ioread32(&map[offset / sizeof(*map)]);

drivers/gpu/drm/i915/gt/gen6_ppgtt.c

165

ioread32(ppgtt->pd_addr + pde - 1);

drivers/gpu/drm/i915/gt/intel_ggtt.c

640

return vm->pte_decode(ioread32(pte), is_present, is_local);

drivers/gpu/drm/i915/intel_device_info.c

309

val = ioread32(addr);

drivers/gpu/drm/i915/selftests/i915_gem_gtt.c

1418

val = ioread32(vaddr + n);

drivers/gpu/drm/i915/selftests/i915_vma.c

1081

val = ioread32(&map[offset / sizeof(*map)]);

drivers/gpu/drm/imagination/pvr_device.h

571

return ioread32(pvr_dev->regs + reg);

drivers/gpu/drm/mgag200/mgag200_drv.h

35

#define RREG32(reg) ioread32(((void __iomem *)mdev->rmmio) + (reg))

drivers/gpu/drm/nouveau/include/nvif/os.h

46

#define ioread32_native ioread32

drivers/gpu/drm/nouveau/nvkm/subdev/devinit/fbmem.h

64

u32 val = ioread32(p + (off & ~PAGE_MASK));

drivers/gpu/drm/radeon/r100.c

4147

return ioread32(rdev->rio_mem + reg);

drivers/gpu/drm/radeon/r100.c

4150

return ioread32(rdev->rio_mem + RADEON_MM_DATA);

drivers/gpu/drm/renesas/rcar-du/rcar_du_drv.h

142

return ioread32(rcdu->mmio + reg);

drivers/gpu/drm/renesas/rcar-du/rcar_lvds.c

88

return ioread32(lvds->mmio + reg);

drivers/gpu/drm/renesas/rcar-du/rcar_mipi_dsi.c

185

return ioread32(dsi->mmio + reg);

drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c

464

return ioread32(dsi->mmio + dsi->info->phy_reg_offset + reg);

drivers/gpu/drm/renesas/rz-du/rzg2l_mipi_dsi.c

469

return ioread32(dsi->mmio + dsi->info->link_reg_offset + reg);

drivers/gpu/drm/renesas/shmobile/shmob_drm_regs.h

293

return ioread32(sdev->mmio + reg);

drivers/gpu/drm/tidss/tidss_dispc.c

489

return ioread32(dispc->base_common + reg);

drivers/gpu/drm/tidss/tidss_dispc.c

504

return ioread32(base + reg);

drivers/gpu/drm/tidss/tidss_dispc.c

519

return ioread32(base + reg);

drivers/gpu/drm/tidss/tidss_dispc.c

534

return ioread32(base + reg);

drivers/gpu/drm/tilcdc/tilcdc_regs.h

137

return ioread32(priv->mmio + reg);

drivers/gpu/drm/tiny/arcpgu.c

72

return ioread32(arcpgu->regs + reg);

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

678

val = ioread32(dev_priv->rmmio + offset);

drivers/hid/intel-thc-hid/intel-thc/intel-thc-dev.c

18

*val = ioread32(base + reg);

drivers/hwmon/axi-fan-control.c

72

return ioread32(ctl->base + reg);

drivers/hwmon/npcm750-pwm-fan.c

225

tmp_buf = ioread32(NPCM7XX_PWM_REG_CR(data->pwm_base, module));

drivers/hwmon/npcm750-pwm-fan.c

511

*val = ioread32

drivers/hwtracing/intel_th/gth.c

106

val = ioread32(gth->base + reg);

drivers/hwtracing/intel_th/gth.c

135

val = ioread32(gth->base + reg);

drivers/hwtracing/intel_th/gth.c

283

reg = ioread32(gth->base + REG_GTH_SCRPD0);

drivers/hwtracing/intel_th/gth.c

491

reg = ioread32(gth->base + REG_GTH_STAT);

drivers/hwtracing/intel_th/gth.c

553

reg = ioread32(gth->base + REG_GTH_SCRPD0);

drivers/hwtracing/intel_th/gth.c

562

reg = ioread32(gth->base + REG_TSCU_TSUCTRL);

drivers/hwtracing/intel_th/gth.c

610

scrpd = ioread32(gth->base + REG_GTH_SCRPD0);

drivers/hwtracing/intel_th/gth.c

638

reg = ioread32(gth->base + REG_CTS_STAT);

drivers/hwtracing/intel_th/gth.c

68

val = ioread32(gth->base + reg);

drivers/hwtracing/intel_th/gth.c

80

val = ioread32(gth->base + reg);

drivers/hwtracing/intel_th/gth.c

94

val = ioread32(gth->base + reg);

drivers/hwtracing/intel_th/msu.c

1700

(ioread32(msc->reg_base + REG_MSU_MSC0CTL) & MSC_LEN) >>

drivers/hwtracing/intel_th/msu.c

1763

u32 msusts = ioread32(msc->msu_base + REG_MSU_MSUSTS);

drivers/hwtracing/intel_th/msu.c

689

mintctl = ioread32(msc->msu_base + REG_MSU_MINTCTL);

drivers/hwtracing/intel_th/msu.c

692

if (mintctl != ioread32(msc->msu_base + REG_MSU_MINTCTL)) {

drivers/hwtracing/intel_th/msu.c

698

msusts = ioread32(msc->msu_base + REG_MSU_MSUSTS);

drivers/hwtracing/intel_th/msu.c

711

mintctl = ioread32(msc->msu_base + REG_MSU_MINTCTL);

drivers/hwtracing/intel_th/msu.c

786

msc->orig_addr = ioread32(msc->reg_base + REG_MSU_MSC0BAR);

drivers/hwtracing/intel_th/msu.c

787

msc->orig_sz = ioread32(msc->reg_base + REG_MSU_MSC0SIZE);

drivers/hwtracing/intel_th/msu.c

797

reg = ioread32(msc->reg_base + REG_MSU_MSC0CTL);

drivers/hwtracing/intel_th/msu.c

844

reg = ioread32(msc->reg_base + REG_MSU_MSC0STS);

drivers/hwtracing/intel_th/msu.c

847

reg = ioread32(msc->reg_base + REG_MSU_MSC0MWP);

drivers/hwtracing/intel_th/msu.c

853

reg = ioread32(msc->reg_base + REG_MSU_MSC0CTL);

drivers/hwtracing/intel_th/msu.c

867

ioread32(msc->reg_base + REG_MSU_MSC0NWSA));

drivers/hwtracing/intel_th/msu.c

869

reg = ioread32(msc->reg_base + REG_MSU_MSC0STS);

drivers/hwtracing/intel_th/msu.c

872

reg = ioread32(msc->reg_base + REG_MSU_MSUSTS);

drivers/hwtracing/intel_th/pti.c

180

u32 ctl = ioread32(pti->base + REG_PTI_CTL);

drivers/hwtracing/intel_th/sth.c

171

reg = ioread32(sth->base + REG_STH_STHCAP1);

drivers/hwtracing/intel_th/sth.c

174

reg = ioread32(sth->base + REG_STH_STHCAP0);

drivers/i2c/busses/i2c-amd-asf-plat.c

136

reg = ioread32(dev->mmio_cfg.addr);

drivers/i2c/busses/i2c-brcmstb.c

171

#define __bsc_readl(_reg) ioread32(_reg)

drivers/i2c/busses/i2c-eg20t.c

185

val = ioread32(addr + offset);

drivers/i2c/busses/i2c-eg20t.c

193

val = ioread32(addr + offset);

drivers/i2c/busses/i2c-eg20t.c

243

ioread32(p + PCH_I2CCTL), pch_i2cbc, pch_i2ctmr);

drivers/i2c/busses/i2c-eg20t.c

260

while (ioread32(p + PCH_I2CSR) & I2CMBB_BIT) {

drivers/i2c/busses/i2c-eg20t.c

262

pch_dbg(adap, "I2CSR = %x\n", ioread32(p + PCH_I2CSR));

drivers/i2c/busses/i2c-eg20t.c

292

pch_dbg(adap, "I2CCTL = %x\n", ioread32(p + PCH_I2CCTL));

drivers/i2c/busses/i2c-eg20t.c

303

pch_dbg(adap, "I2CCTL = %x\n", ioread32(p + PCH_I2CCTL));

drivers/i2c/busses/i2c-eg20t.c

334

if (ioread32(p + PCH_I2CSR) & PCH_GETACK) {

drivers/i2c/busses/i2c-eg20t.c

349

pch_dbg(adap, "I2CCTL = %x\n", ioread32(p + PCH_I2CCTL));

drivers/i2c/busses/i2c-eg20t.c

379

pch_dbg(adap, "I2CCTL = %x msgs->len = %d\n", ioread32(p + PCH_I2CCTL),

drivers/i2c/busses/i2c-eg20t.c

439

pch_dbg(adap, "I2CCTL = %x\n", ioread32(p + PCH_I2CCTL));

drivers/i2c/busses/i2c-eg20t.c

450

pch_dbg(adap, "I2CCTL = %x\n", ioread32(p + PCH_I2CCTL));

drivers/i2c/busses/i2c-eg20t.c

463

pch_dbg(adap, "I2CCTL = %x\n", ioread32(p + PCH_I2CCTL));

drivers/i2c/busses/i2c-eg20t.c

529

ioread32(p + PCH_I2CDR); /* Dummy read needs */

drivers/i2c/busses/i2c-eg20t.c

539

buf[read_index] = ioread32(p + PCH_I2CDR);

drivers/i2c/busses/i2c-eg20t.c

551

buf[read_index] = ioread32(p + PCH_I2CDR); /* Read final - 1 */

drivers/i2c/busses/i2c-eg20t.c

565

buf[read_index++] = ioread32(p + PCH_I2CDR); /* Read Final */

drivers/i2c/busses/i2c-eg20t.c

581

sts = ioread32(p + PCH_I2CSR);

drivers/i2c/busses/i2c-eg20t.c

592

pch_dbg(adap, "PCH_I2CSR = %x\n", ioread32(p + PCH_I2CSR));

drivers/i2c/busses/i2c-eg20t.c

613

mode = ioread32(p + PCH_I2CMOD);

drivers/i2c/busses/i2c-eg20t.c

620

reg_val = ioread32(p + PCH_I2CSR);

drivers/i2c/busses/i2c-eg20t.c

854

ioread32(p + PCH_I2CSR), ioread32(p + PCH_I2CBUFSTA),

drivers/i2c/busses/i2c-eg20t.c

855

ioread32(p + PCH_I2CESRSTA));

drivers/i2c/busses/i2c-mt7621.c

105

ioread32(i2c->base + REG_SM0CFG2_REG),

drivers/i2c/busses/i2c-mt7621.c

106

ioread32(i2c->base + REG_SM0CTL0_REG),

drivers/i2c/busses/i2c-mt7621.c

107

ioread32(i2c->base + REG_SM0CTL1_REG),

drivers/i2c/busses/i2c-mt7621.c

108

ioread32(i2c->base + REG_SM0D0_REG),

drivers/i2c/busses/i2c-mt7621.c

109

ioread32(i2c->base + REG_SM0D1_REG));

drivers/i2c/busses/i2c-mt7621.c

206

data[0] = ioread32(i2c->base + REG_SM0D0_REG);

drivers/i2c/busses/i2c-mt7621.c

207

data[1] = ioread32(i2c->base + REG_SM0D1_REG);

drivers/i2c/busses/i2c-ocores.c

125

return ioread32(i2c->base + (reg << i2c->reg_shift));

drivers/i2c/busses/i2c-pasemi-core.c

146

ioread32, smbus->ioaddr + REG_SMSTA,

drivers/i2c/busses/i2c-pasemi-core.c

72

ret = ioread32(smbus->ioaddr + reg);

drivers/i2c/busses/i2c-pasemi-core.c

97

ret = readx_poll_timeout(ioread32, smbus->ioaddr + REG_SMSTA,

drivers/i2c/busses/i2c-pnx.c

100

(ioread32(I2C_REG_STS(data)) & mstatus_active)) {

drivers/i2c/busses/i2c-pnx.c

111

(ioread32(I2C_REG_CTL(data)) & mcntrl_reset)) {

drivers/i2c/busses/i2c-pnx.c

145

ioread32(I2C_REG_CTL(alg_data)),

drivers/i2c/busses/i2c-pnx.c

146

ioread32(I2C_REG_STS(alg_data)));

drivers/i2c/busses/i2c-pnx.c

148

} else if (ioread32(I2C_REG_STS(alg_data)) & mstatus_afi) {

drivers/i2c/busses/i2c-pnx.c

160

iowrite32(ioread32(I2C_REG_STS(alg_data)) | mstatus_tdi | mstatus_afi,

drivers/i2c/busses/i2c-pnx.c

187

__func__, ioread32(I2C_REG_STS(alg_data)));

drivers/i2c/busses/i2c-pnx.c

194

(ioread32(I2C_REG_STS(alg_data)) & mstatus_active)) {

drivers/i2c/busses/i2c-pnx.c

201

__func__, ioread32(I2C_REG_STS(alg_data)));

drivers/i2c/busses/i2c-pnx.c

215

__func__, ioread32(I2C_REG_STS(alg_data)));

drivers/i2c/busses/i2c-pnx.c

238

iowrite32(ioread32(I2C_REG_CTL(alg_data)) &

drivers/i2c/busses/i2c-pnx.c

253

iowrite32(ioread32(I2C_REG_CTL(alg_data)) &

drivers/i2c/busses/i2c-pnx.c

265

__func__, ioread32(I2C_REG_STS(alg_data)));

drivers/i2c/busses/i2c-pnx.c

282

__func__, ioread32(I2C_REG_STS(alg_data)));

drivers/i2c/busses/i2c-pnx.c

287

if (ioread32(I2C_REG_STS(alg_data)) & mstatus_rfe) {

drivers/i2c/busses/i2c-pnx.c

305

ctl = ioread32(I2C_REG_CTL(alg_data));

drivers/i2c/busses/i2c-pnx.c

324

val = ioread32(I2C_REG_RX(alg_data));

drivers/i2c/busses/i2c-pnx.c

338

ctl = ioread32(I2C_REG_CTL(alg_data));

drivers/i2c/busses/i2c-pnx.c

348

__func__, ioread32(I2C_REG_STS(alg_data)));

drivers/i2c/busses/i2c-pnx.c

361

ioread32(I2C_REG_STS(alg_data)),

drivers/i2c/busses/i2c-pnx.c

362

ioread32(I2C_REG_CTL(alg_data)),

drivers/i2c/busses/i2c-pnx.c

364

stat = ioread32(I2C_REG_STS(alg_data));

drivers/i2c/busses/i2c-pnx.c

372

ctl = ioread32(I2C_REG_CTL(alg_data));

drivers/i2c/busses/i2c-pnx.c

386

ctl = ioread32(I2C_REG_CTL(alg_data));

drivers/i2c/busses/i2c-pnx.c

415

stat = ioread32(I2C_REG_STS(alg_data));

drivers/i2c/busses/i2c-pnx.c

420

__func__, ioread32(I2C_REG_STS(alg_data)),

drivers/i2c/busses/i2c-pnx.c

421

ioread32(I2C_REG_CTL(alg_data)));

drivers/i2c/busses/i2c-pnx.c

432

ioread32(I2C_REG_STS(alg_data)),

drivers/i2c/busses/i2c-pnx.c

433

ioread32(I2C_REG_CTL(alg_data)));

drivers/i2c/busses/i2c-pnx.c

436

ctl = ioread32(I2C_REG_CTL(alg_data));

drivers/i2c/busses/i2c-pnx.c

450

if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_active) {

drivers/i2c/busses/i2c-pnx.c

454

iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_reset,

drivers/i2c/busses/i2c-pnx.c

461

iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_reset,

drivers/i2c/busses/i2c-pnx.c

465

iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_reset,

drivers/i2c/busses/i2c-pnx.c

490

__func__, num, ioread32(I2C_REG_STS(alg_data)));

drivers/i2c/busses/i2c-pnx.c

525

iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_afie |

drivers/i2c/busses/i2c-pnx.c

547

if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_tdi) {

drivers/i2c/busses/i2c-pnx.c

553

if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_afi) {

drivers/i2c/busses/i2c-pnx.c

569

__func__, ioread32(I2C_REG_STS(alg_data)));

drivers/i2c/busses/i2c-xiic.c

322

ret = ioread32(i2c->base + reg);

drivers/i2c/muxes/i2c-mux-reg.c

41

ioread32(mux->data.reg);

drivers/iio/adc/npcm_adc.c

106

regtemp = ioread32(info->regs + NPCM_ADCCON);

drivers/iio/adc/npcm_adc.c

122

regtemp = ioread32(info->regs + NPCM_ADCCON);

drivers/iio/adc/npcm_adc.c

131

regtemp = ioread32(info->regs + NPCM_ADCCON);

drivers/iio/adc/npcm_adc.c

149

*val = ioread32(info->regs + NPCM_ADCDATA);

drivers/iio/adc/npcm_adc.c

241

reg_con = ioread32(info->regs + NPCM_ADCCON);

drivers/iio/adc/npcm_adc.c

259

reg_con = ioread32(info->regs + NPCM_ADCCON);

drivers/iio/adc/npcm_adc.c

287

reg_con = ioread32(info->regs + NPCM_ADCCON);

drivers/iio/adc/npcm_adc.c

331

regtemp = ioread32(info->regs + NPCM_ADCCON);

drivers/input/serio/arc_ps2.c

121

iowrite32(ioread32(port->status_addr) & ~PS2_STAT_RX_INT_EN,

drivers/input/serio/arc_ps2.c

145

val = ioread32(addr);

drivers/input/serio/arc_ps2.c

205

id = ioread32(arc_ps2->addr);

drivers/input/serio/arc_ps2.c

54

status = ioread32(port->status_addr);

drivers/input/serio/arc_ps2.c

58

data = ioread32(port->data_addr) & 0xff;

drivers/input/serio/arc_ps2.c

94

status = ioread32(port->status_addr);

drivers/iommu/ipmmu-vmsa.c

179

return ioread32(mmu->base + offset);

drivers/ipack/carriers/tpci200.c

555

reg32 = ioread32(tpci200->info->cfg_regs + LAS1_DESC);

drivers/ipack/carriers/tpci200.c

559

reg32 = ioread32(tpci200->info->cfg_regs + LAS2_DESC);

drivers/irqchip/irq-econet-en751221.c

139

pending0 = ioread32(econet_intc.membase + REG_PENDING0);

drivers/irqchip/irq-econet-en751221.c

140

pending1 = ioread32(econet_intc.membase + REG_PENDING1);

drivers/irqchip/irq-econet-en751221.c

64

v = ioread32(econet_intc.membase + reg);

drivers/irqchip/irq-imgpdc.c

98

return ioread32(priv->pdc_base + reg_offs);

drivers/irqchip/irq-imx-mu-msi.c

80

return ioread32(msi_data->regs + offs);

drivers/irqchip/irq-ls-extirq.c

40

intpcr = ioread32(priv->intpcr);

drivers/irqchip/irq-renesas-intc-irqpin.c

78

return ioread32(iomem);

drivers/irqchip/irq-renesas-irqc.c

115

if (ioread32(p->iomem + DETECT_STATUS) & bit) {

drivers/irqchip/irq-renesas-irqc.c

86

tmp = ioread32(p->iomem + IRQC_CONFIG(hw_irq));

drivers/irqchip/irq-starfive-jh8100-intc.c

102

value = ioread32(irqc->base + STARFIVE_INTC_SRC0_INT);

drivers/irqchip/irq-starfive-jh8100-intc.c

40

value = ioread32(irqc->base + reg);

drivers/irqchip/irq-starfive-jh8100-intc.c

50

value = ioread32(irqc->base + reg);

drivers/irqchip/irq-xilinx-intc.c

61

return ioread32(irqc->base + reg);

drivers/mailbox/bcm-pdc-mailbox.c

678

(ioread32((const void __iomem *)&pdcs->rxregs_64->status0) &

drivers/mailbox/bcm-pdc-mailbox.c

940

u32 intstatus = ioread32(pdcs->pdc_reg_vbase + PDC_INTSTATUS_OFFSET);

drivers/mailbox/cix-mailbox.c

128

return ioread32(priv->base + offset - CIX_SHMEM_OFFSET);

drivers/mailbox/cix-mailbox.c

130

return ioread32(priv->base + offset);

drivers/mailbox/imx-mailbox.c

157

return ioread32(priv->base + offs);

drivers/mailbox/mailbox-th1520.c

125

return ioread32(cp->comm_remote_base + offs);

drivers/mailbox/mailbox-th1520.c

127

return ioread32(cp->comm_local_base + offs);

drivers/mailbox/mailbox-th1520.c

536

ioread32(priv->local_icu[i] + TH_1520_MBOX_MASK);

drivers/mailbox/mailbox-th1520.c

93

return ioread32(priv->cur_cpu_ch_base + offs);

drivers/mailbox/pcc.c

304

if (ioread32(&pcc_hdr->flags) & PCC_CMD_COMPLETION_NOTIFY)

drivers/media/pci/cobalt/cobalt-driver.h

304

return ioread32(cobalt->bar0 + reg);

drivers/media/pci/cobalt/cobalt-driver.h

314

return ioread32(cobalt->bar1 + reg);

drivers/media/pci/cobalt/cobalt-driver.h

346

return ioread32(LOWER_DATA);

drivers/media/pci/cobalt/cobalt-irq.c

107

if (ioread32(&fw->status) & M00473_STATUS_BITMAP_FREEWHEEL_MODE_MSK) {

drivers/media/pci/cobalt/cobalt-irq.c

50

uint32_t stat = ioread32(&vmr->irq_status);

drivers/media/pci/cobalt/cobalt-irq.c

53

if (!(ioread32(&vmr->status) &

drivers/media/pci/cobalt/cobalt-irq.c

61

if (ioread32(&clkloss->status) &

drivers/media/pci/cobalt/cobalt-irq.c

72

ioread32(&vmr->vactive_area) != s->timings.bt.height ||

drivers/media/pci/cobalt/cobalt-irq.c

73

ioread32(&vmr->hactive_area) != s->timings.bt.width) {

drivers/media/pci/cobalt/cobalt-irq.c

84

if (!(ioread32(&cvi->status) & M00389_STATUS_BITMAP_LOCK_MSK)) {

drivers/media/pci/cobalt/cobalt-omnitek.c

109

if (ioread32(CS_REG(s->dma_channel)) & DONE)

drivers/media/pci/cobalt/cobalt-omnitek.c

125

u32 capa = ioread32(CAPABILITY_REGISTER);

drivers/media/pci/cobalt/cobalt-omnitek.c

136

u32 status = ioread32(CS_REG(i));

drivers/media/pci/cobalt/cobalt-omnitek.c

137

u32 ctrl = ioread32(CS_REG(i));

drivers/media/pci/cobalt/cobalt-omnitek.c

67

u32 header = ioread32(CAPABILITY_HEADER);

drivers/media/pci/cobalt/cobalt-omnitek.c

68

u32 capa = ioread32(CAPABILITY_REGISTER);

drivers/media/pci/cobalt/cobalt-omnitek.c

88

u32 status = ioread32(CS_REG(i));

drivers/media/pci/cobalt/cobalt-v4l2.c

263

u32 ctrl = ioread32(&vo->control);

drivers/media/pci/cobalt/cobalt-v4l2.c

313

clk_freq = ioread32(&fw->clk_freq);

drivers/media/pci/cobalt/cobalt-v4l2.c

446

regs->val = ioread32(adrs);

drivers/media/pci/cobalt/cobalt-v4l2.c

504

cvi_ctrl = ioread32(&cvi->control);

drivers/media/pci/cobalt/cobalt-v4l2.c

505

cvi_stat = ioread32(&cvi->status);

drivers/media/pci/cobalt/cobalt-v4l2.c

506

vmr_ctrl = ioread32(&vmr->control);

drivers/media/pci/cobalt/cobalt-v4l2.c

507

vmr_stat = ioread32(&vmr->status);

drivers/media/pci/cobalt/cobalt-v4l2.c

509

ioread32(&cvi->frame_width), ioread32(&cvi->frame_height));

drivers/media/pci/cobalt/cobalt-v4l2.c

539

ioread32(&vmr->irq_status) & 0xff,

drivers/media/pci/cobalt/cobalt-v4l2.c

540

ioread32(&vmr->irq_triggers) & 0xff);

drivers/media/pci/cobalt/cobalt-v4l2.c

541

cobalt_info("rx%d: vsync: %d\n", rx, ioread32(&vmr->vsync_time));

drivers/media/pci/cobalt/cobalt-v4l2.c

542

cobalt_info("rx%d: vbp: %d\n", rx, ioread32(&vmr->vback_porch));

drivers/media/pci/cobalt/cobalt-v4l2.c

543

cobalt_info("rx%d: vact: %d\n", rx, ioread32(&vmr->vactive_area));

drivers/media/pci/cobalt/cobalt-v4l2.c

544

cobalt_info("rx%d: vfb: %d\n", rx, ioread32(&vmr->vfront_porch));

drivers/media/pci/cobalt/cobalt-v4l2.c

545

cobalt_info("rx%d: hsync: %d\n", rx, ioread32(&vmr->hsync_time));

drivers/media/pci/cobalt/cobalt-v4l2.c

546

cobalt_info("rx%d: hbp: %d\n", rx, ioread32(&vmr->hback_porch));

drivers/media/pci/cobalt/cobalt-v4l2.c

547

cobalt_info("rx%d: hact: %d\n", rx, ioread32(&vmr->hactive_area));

drivers/media/pci/cobalt/cobalt-v4l2.c

548

cobalt_info("rx%d: hfb: %d\n", rx, ioread32(&vmr->hfront_porch));

drivers/media/pci/cobalt/cobalt-v4l2.c

550

(ioread32(&fw->ctrl) & M00473_CTRL_BITMAP_ENABLE_MSK) ?

drivers/media/pci/cobalt/cobalt-v4l2.c

552

(ioread32(&fw->ctrl) & M00473_CTRL_BITMAP_FORCE_FREEWHEEL_MODE_MSK) ?

drivers/media/pci/cobalt/cobalt-v4l2.c

554

(ioread32(&fw->status) & M00473_STATUS_BITMAP_FREEWHEEL_MODE_MSK) ?

drivers/media/pci/cobalt/cobalt-v4l2.c

558

(ioread32(&clkloss->ctrl) & M00479_CTRL_BITMAP_ENABLE_MSK) ?

drivers/media/pci/cobalt/cobalt-v4l2.c

560

(ioread32(&clkloss->status) & M00479_STATUS_BITMAP_CLOCK_MISSING_MSK) ?

drivers/media/pci/cobalt/cobalt-v4l2.c

562

cobalt_info("rx%d: Packer: %x\n", rx, ioread32(&packer->control));

drivers/media/pci/cobalt/cobalt-v4l2.c

588

stat = ioread32(&vo->rd_status);

drivers/media/pci/cobalt/cobalt-v4l2.c

595

cobalt_info("tx: evcnt: %d\n", ioread32(&vo->rd_evcnt_count));

drivers/media/pci/dt3155/dt3155.c

110

if (ioread32(addr + IIC_CSR2) & NEW_CYCLE)

drivers/media/pci/dt3155/dt3155.c

112

if (ioread32(addr + IIC_CSR2) & NEW_CYCLE)

drivers/media/pci/dt3155/dt3155.c

114

if (ioread32(addr + IIC_CSR1) & DIRECT_ABORT) {

drivers/media/pci/dt3155/dt3155.c

238

tmp = ioread32(ipd->regs + INT_CSR) & (FLD_START | FLD_END_ODD);

drivers/media/pci/dt3155/dt3155.c

246

tmp = ioread32(ipd->regs + CSR1) & (FLD_CRPT_EVEN | FLD_CRPT_ODD);

drivers/media/pci/dt3155/dt3155.c

42

if (ioread32(addr + IIC_CSR2) & NEW_CYCLE)

drivers/media/pci/dt3155/dt3155.c

44

tmp = ioread32(addr + IIC_CSR1);

drivers/media/pci/dt3155/dt3155.c

72

if (ioread32(addr + IIC_CSR2) & NEW_CYCLE)

drivers/media/pci/dt3155/dt3155.c

74

if (ioread32(addr + IIC_CSR1) & DIRECT_ABORT) {

drivers/media/pci/mgb4/mgb4_regs.h

21

ioread32((regs)->membase + (offset))

drivers/media/pci/pt3/pt3.c

730

ver = ioread32(pt3->regs[0] + REG_VERSION);

drivers/media/pci/pt3/pt3_dma.c

32

stat = ioread32(pt3->regs[0] + base + OFST_STATUS);

drivers/media/pci/pt3/pt3_dma.c

38

stat = ioread32(pt3->regs[0] + base + OFST_STATUS);

drivers/media/pci/pt3/pt3_i2c.c

132

v = ioread32(pt3->regs[0] + REG_I2C_R);

drivers/media/pci/pt3/pt3_i2c.c

172

ioread32(pt3->regs[0] + REG_I2C_R);

drivers/media/platform/marvell/mcam-core.h

208

return ioread32(cam->regs + reg);

drivers/media/platform/renesas/rcar-csi2.c

809

return ioread32(priv->base + reg);

drivers/media/platform/renesas/rcar-isp/csisp.c

194

return ioread32(isp->csbase + offset);

drivers/media/platform/renesas/rcar-vin/rcar-dma.c

174

return ioread32(vin->base + offset);

drivers/media/platform/renesas/rcar_fdp1.c

778

u32 value = ioread32(fdp1->regs + reg);

drivers/media/platform/renesas/rcar_jpu.c

470

return ioread32(jpu->regs + reg);

drivers/media/platform/renesas/renesas-ceu.c

307

return ioread32(priv->base + reg_offs);

drivers/media/platform/renesas/rzg2l-cru/rzg2l-csi2.c

269

return ioread32(csi2->base + reg);

drivers/media/platform/renesas/rzg2l-cru/rzg2l-video.c

75

return ioread32(cru->base + regs[offset]);

drivers/media/platform/renesas/rzg2l-cru/rzg2l-video.c

95

return ioread32(cru->base + regs[offset]);

drivers/media/platform/renesas/vsp1/vsp1.h

124

return ioread32(vsp1->mmio + reg);

drivers/media/platform/ti/am437x/am437x-vpfe.c

171

return ioread32(ccdc->ccdc_cfg.base_addr + offset);

drivers/media/platform/ti/cal/cal-camerarx.c

35

return ioread32(phy->base + offset);

drivers/media/platform/ti/cal/cal.h

284

return ioread32(cal->base + offset);

drivers/media/platform/ti/vpe/csc.c

115

ioread32(csc->base + CSC_##r))

drivers/media/platform/ti/vpe/sc.c

26

ioread32(sc->base + CFG_##r))

drivers/media/platform/ti/vpe/vip.c

76

#define reg_read(dev, offset) ioread32((dev)->base + (offset))

drivers/media/platform/ti/vpe/vpdma.c

282

return ioread32(vpdma->base + offset);

drivers/media/platform/ti/vpe/vpe.c

452

return ioread32(dev->base + offset);

drivers/media/platform/via/via-camera.c

279

return ioread32(cam->mmio + reg);

drivers/media/platform/xilinx/xilinx-csi2rxss.c

258

return ioread32(xcsi2rxss->iomem + addr);

drivers/media/platform/xilinx/xilinx-vip.h

136

return ioread32(xvip->iomem + addr);

drivers/media/rc/img-ir/img-ir.h

166

return ioread32(priv->reg_base + reg_offs);

drivers/mfd/cgbc-core.c

67

if (ret || ioread32(cgbc->io_session + CGBC_SESSION_ACCESS))

drivers/mfd/timberdale.c

682

priv->fw.major = ioread32(priv->ctl_membase + TIMB_REV_MAJOR);

drivers/mfd/timberdale.c

683

priv->fw.minor = ioread32(priv->ctl_membase + TIMB_REV_MINOR);

drivers/mfd/timberdale.c

684

priv->fw.config = ioread32(priv->ctl_membase + TIMB_HW_CONFIG);

drivers/misc/hpilo.c

240

iowrite32(ioread32(&device_ccb->send_ctrl) & ~(1 << CTRL_BITPOS_G),

drivers/misc/hpilo.c

242

iowrite32(ioread32(&device_ccb->recv_ctrl) & ~(1 << CTRL_BITPOS_G),

drivers/misc/hpilo.c

249

if (!(ioread32(&device_ccb->send_ctrl) & (1 << CTRL_BITPOS_A))

drivers/misc/hpilo.c

251

!(ioread32(&device_ccb->recv_ctrl) & (1 << CTRL_BITPOS_A)))

drivers/misc/hpilo.c

389

return ioread32(&hw->mmio_vaddr[DB_OUT]);

drivers/misc/keba/cp500.c

822

u32 axi_address = ioread32(cp500->system_startup_addr + CP500_AXI_REG);

drivers/misc/keba/cp500.c

913

cp500_vers = ioread32(cp500->system_startup_addr + CP500_VERSION_REG);

drivers/misc/mei/gsc-me.c

30

*val = ioread32(hw->mem_addr + where + 0xC00);

drivers/misc/mei/hw-me.c

34

return ioread32(hw->mem_addr + offset);

drivers/misc/mei/hw-txe.c

37

return ioread32(base_addr + offset);

drivers/misc/pch_phub.c

149

iowrite32(((ioread32(reg_addr) & ~mask)) | data, reg_addr);

drivers/misc/pch_phub.c

160

chip->phub_id_reg = ioread32(p + PCH_PHUB_ID_REG);

drivers/misc/pch_phub.c

161

chip->q_pri_val_reg = ioread32(p + PCH_PHUB_QUEUE_PRI_VAL_REG);

drivers/misc/pch_phub.c

162

chip->rc_q_maxsize_reg = ioread32(p + PCH_PHUB_RC_QUEUE_MAXSIZE_REG);

drivers/misc/pch_phub.c

163

chip->bri_q_maxsize_reg = ioread32(p + PCH_PHUB_BRI_QUEUE_MAXSIZE_REG);

drivers/misc/pch_phub.c

165

ioread32(p + PCH_PHUB_COMP_RESP_TIMEOUT_REG);

drivers/misc/pch_phub.c

167

ioread32(p + PCH_PHUB_BUS_SLAVE_CONTROL_REG);

drivers/misc/pch_phub.c

169

ioread32(p + PCH_PHUB_DEADLOCK_AVOID_TYPE_REG);

drivers/misc/pch_phub.c

171

ioread32(p + PCH_PHUB_INTPIN_REG_WPERMIT_REG0);

drivers/misc/pch_phub.c

173

ioread32(p + PCH_PHUB_INTPIN_REG_WPERMIT_REG1);

drivers/misc/pch_phub.c

175

ioread32(p + PCH_PHUB_INTPIN_REG_WPERMIT_REG2);

drivers/misc/pch_phub.c

177

ioread32(p + PCH_PHUB_INTPIN_REG_WPERMIT_REG3);

drivers/misc/pch_phub.c

203

ioread32(p + PCH_PHUB_INT_REDUCE_CONTROL_REG_BASE + 4 * i);

drivers/misc/pch_phub.c

208

chip->clkcfg_reg = ioread32(p + CLKCFG_REG_OFFSET);

drivers/misc/pch_phub.c

210

chip->funcsel_reg = ioread32(p + FUNCSEL_REG_OFFSET);

drivers/misc/pch_phub.c

311

word_data = ioread32(mem_addr);

drivers/misc/pci_endpoint_test.c

558

val = ioread32(bar_addr + (i * sub_size));

drivers/misc/pci_endpoint_test.c

566

val = ioread32(bar_addr + (i * sub_size) + sub_size - sizeof(u32));

drivers/misc/phantom.c

124

ioread32(dev->iaddr); /* PCI posting */

drivers/misc/phantom.c

144

ioread32(dev->iaddr); /* PCI posting */

drivers/misc/phantom.c

156

r.value = ioread32(dev->iaddr + r.reg);

drivers/misc/phantom.c

174

rs.values[i] = ioread32(dev->iaddr + i);

drivers/misc/phantom.c

291

ctl = ioread32(dev->iaddr + PHN_CONTROL);

drivers/misc/phantom.c

313

ioread32(dev->iaddr); /* PCI posting */

drivers/misc/phantom.c

394

ioread32(pht->caddr + PHN_IRQCTL); /* PCI posting */

drivers/misc/phantom.c

446

ioread32(pht->caddr + PHN_IRQCTL); /* PCI posting */

drivers/misc/phantom.c

467

ioread32(dev->caddr + PHN_IRQCTL); /* PCI posting */

drivers/misc/phantom.c

73

ioread32(dev->caddr + PHN_IRQCTL); /* PCI posting */

drivers/misc/phantom.c

76

ioread32(dev->caddr + PHN_IRQCTL); /* PCI posting */

drivers/misc/vmw_vmci/vmci_guest.c

106

return ioread32(dev->iobase + reg);

drivers/misc/xilinx_sdfec.c

246

rval = ioread32(xsdfec->regs + addr);

drivers/misc/xilinx_tmr_inject.c

59

return ioread32(xtmr_inject->regs + addr);

drivers/misc/xilinx_tmr_manager.c

69

return ioread32(xtmr_manager->regs + addr);

drivers/mmc/host/moxart-mmc.c

346

*sgp = ioread32(host->base + REG_DATA_WINDOW);

drivers/mmc/host/sdhci-of-esdhc.c

354

value = ioread32(host->ioaddr + ESDHC_CAPABILITIES_1);

drivers/mmc/host/sdhci-of-esdhc.c

356

value = ioread32(host->ioaddr + reg);

drivers/mmc/host/sdhci-of-esdhc.c

380

value = ioread32(host->ioaddr + base);

drivers/mmc/host/sdhci-of-esdhc.c

402

value = ioread32(host->ioaddr + base);

drivers/mmc/host/sdhci-of-esdhc.c

457

value = ioread32(host->ioaddr + base);

drivers/mmc/host/sdhci-of-esdhc.c

492

value = ioread32(host->ioaddr + base);

drivers/mmc/host/tmio_mmc.h

235

return ioread32(host->ctl + (addr << host->bus_shift));

drivers/mmc/host/toshsd.c

296

int_status = ioread32(host->ioaddr + SD_CARDSTATUS);

drivers/mmc/host/toshsd.c

297

int_mask = ioread32(host->ioaddr + SD_INTMASKCARD);

drivers/mmc/host/toshsd.c

329

detail = ioread32(host->ioaddr + SD_ERRORSTATUS0);

drivers/mmc/host/usdhi6rol0.c

225

u32 data = ioread32(host->base + reg);

drivers/mtd/devices/mtd_intel_dg.c

110

return ioread32(base + NVM_TRIGGER_REG);

drivers/mtd/devices/mtd_intel_dg.c

399

reg = ioread32(base2 + NVM_DEBUG_REG);

drivers/mtd/devices/mtd_intel_dg.c

403

reg = ioread32(base2 + NVM_DEBUG_REG);

drivers/mtd/devices/mtd_intel_dg.c

95

u32 reg = ioread32(base + NVM_ACCESS_ERROR_REG) & NVM_ACCESS_ERROR_PCIE_MASK;

drivers/mtd/nand/raw/denali.c

1274

u32 features = ioread32(denali->reg + FEATURES);

drivers/mtd/nand/raw/denali.c

1289

denali->revision = swab16(ioread32(denali->reg + REVISION));

drivers/mtd/nand/raw/denali.c

132

irq_status = ioread32(denali->reg + INTR_STATUS(i));

drivers/mtd/nand/raw/denali.c

1336

denali->oob_skip_bytes = ioread32(denali->reg +

drivers/mtd/nand/raw/denali.c

447

ecc_cor = ioread32(denali->reg + ECC_COR_INFO(bank));

drivers/mtd/nand/raw/denali.c

490

err_addr = ioread32(denali->reg + ECC_ERROR_ADDRESS);

drivers/mtd/nand/raw/denali.c

494

err_cor_info = ioread32(denali->reg + ERR_CORRECTION_INFO);

drivers/mtd/nand/raw/denali.c

61

return ioread32(denali->host + addr);

drivers/mtd/nand/raw/denali.c

689

ioread32(denali->reg + DMA_ENABLE);

drivers/mtd/nand/raw/denali.c

79

return ioread32(denali->host + DENALI_INDEXED_DATA);

drivers/mtd/nand/raw/denali.c

804

tmp = ioread32(denali->reg + RE_2_WE);

drivers/mtd/nand/raw/denali.c

813

tmp = ioread32(denali->reg + RE_2_RE);

drivers/mtd/nand/raw/denali.c

827

tmp = ioread32(denali->reg + TWHR2_AND_WE_2_RE);

drivers/mtd/nand/raw/denali.c

842

tmp = ioread32(denali->reg + TCWAW_AND_ADDR_2_DATA);

drivers/mtd/nand/raw/denali.c

852

tmp = ioread32(denali->reg + RDWR_EN_HI_CNT);

drivers/mtd/nand/raw/denali.c

891

tmp = ioread32(denali->reg + ACC_CLKS);

drivers/mtd/nand/raw/denali.c

896

tmp = ioread32(denali->reg + RDWR_EN_LO_CNT);

drivers/mtd/nand/raw/denali.c

907

tmp = ioread32(denali->reg + CS_SETUP_CNT);

drivers/mtd/nand/raw/denali.c

972

denali->devs_per_cs = ioread32(denali->reg + DEVICES_CONNECTED);

drivers/mtd/nand/raw/qcom_nandc.c

137

return ioread32(nandc->base + offset);

drivers/net/can/c_can/c_can_pci.c

78

return (u16)ioread32(priv->base + 2 * priv->regs[index]);

drivers/net/can/ctucanfd/ctucanfd_base.c

126

return ioread32(priv->mem_base + reg);

drivers/net/can/ctucanfd/ctucanfd_pci.c

147

ctucan_id = ioread32(bar0_base + CTUCAN_BAR0_CTUCAN_ID);

drivers/net/can/ctucanfd/ctucanfd_pci.c

192

cra_a2p_ie = ioread32(cra_addr + CYCLONE_IV_CRA_A2P_IE);

drivers/net/can/ctucanfd/ctucanfd_pci.c

196

cra_a2p_ie = ioread32(cra_addr + CYCLONE_IV_CRA_A2P_IE);

drivers/net/can/flexcan/flexcan-core.c

461

return ioread32(addr);

drivers/net/can/grcan.c

332

return ioread32(reg);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1128

ioread32(KVASER_PCIEFD_SRB_ADDR(pcie) +

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1132

ioread32(KVASER_PCIEFD_SRB_FIFO_ADDR(pcie) + KVASER_PCIEFD_SRB_FIFO_LAST_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1136

srb_status = ioread32(KVASER_PCIEFD_SRB_ADDR(pcie) + KVASER_PCIEFD_SRB_STAT_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1153

version = ioread32(KVASER_PCIEFD_SYSID_ADDR(pcie) + KVASER_PCIEFD_SYSID_VERSION_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1154

build = ioread32(KVASER_PCIEFD_SYSID_ADDR(pcie) + KVASER_PCIEFD_SYSID_BUILD_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1161

srb_status = ioread32(KVASER_PCIEFD_SRB_ADDR(pcie) + KVASER_PCIEFD_SRB_STAT_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1167

pcie->bus_freq = ioread32(KVASER_PCIEFD_SYSID_ADDR(pcie) + KVASER_PCIEFD_SYSID_BUSFREQ_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1168

pcie->freq = ioread32(KVASER_PCIEFD_SYSID_ADDR(pcie) + KVASER_PCIEFD_SYSID_CANFREQ_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1416

status = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_STAT_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1436

ioread32(can->reg_base + KVASER_PCIEFD_KCAN_TX_NR_PACKETS_REG));

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1665

u32 irq = ioread32(KVASER_PCIEFD_SRB_ADDR(pcie) + KVASER_PCIEFD_SRB_IRQ_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1688

u32 irq = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_IRQ_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

1710

u32 pci_irq = ioread32(KVASER_PCIEFD_PCI_IRQ_ADDR(pcie));

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

491

mode = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

505

mode = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

537

mode = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

572

status = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_STAT_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

580

mode = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

607

mode = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

639

pwm_ctrl = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_PWM_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

830

mode = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_MODE_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

973

can->ioc = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_IOC_REG);

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

978

ioread32(can->reg_base + KVASER_PCIEFD_KCAN_TX_NR_PACKETS_REG));

drivers/net/can/kvaser_pciefd/kvaser_pciefd_core.c

996

status = ioread32(can->reg_base + KVASER_PCIEFD_KCAN_STAT_REG);

drivers/net/can/m_can/m_can_pci.c

48

*(unsigned int *)val = ioread32(src);

drivers/net/can/m_can/m_can_platform.c

39

*(unsigned int *)val = ioread32(src);

drivers/net/can/sja1000/kvaser_pci.c

124

intcsr = ioread32(board->conf_addr + S5920_INTCSR);

drivers/net/can/sja1000/kvaser_pci.c

136

tmp_en_io = ioread32(board->conf_addr + S5920_INTCSR);

drivers/net/can/sja1000/plx_pci.c

450

cntrl = ioread32(card->conf_addr + PLX_CNTRL);

drivers/net/can/sja1000/plx_pci.c

468

cntrl = ioread32(card->conf_addr + PLX9056_CNTRL);

drivers/net/can/sja1000/plx_pci.c

728

val = ioread32(card->conf_addr + PLX_INTCSR);

drivers/net/can/softing/softing_fw.c

357

card->id.serial = ioread32(&card->dpram[DPRAM_FCT_PARAM]);

drivers/net/can/xilinx_can.c

394

return ioread32(priv->reg_base + reg);

drivers/net/ethernet/3com/3c59x.c

1893

ioread32(ioaddr + PktStatus),

drivers/net/ethernet/3com/3c59x.c

1914

if (vp->cur_tx - vp->dirty_tx > 0 && ioread32(ioaddr + DownListPtr) == 0)

drivers/net/ethernet/3com/3c59x.c

2009

int bus_status = ioread32(ioaddr + PktStatus);

drivers/net/ethernet/3com/3c59x.c

2217

if (ioread32(ioaddr + DownListPtr) == 0) {

drivers/net/ethernet/3com/3c59x.c

2424

if (ioread32(ioaddr + DownListPtr) ==

drivers/net/ethernet/3com/3c59x.c

2796

int stalled = ioread32(ioaddr + PktStatus) & 0x04; /* Possible racy. But it's only debug stuff */

drivers/net/ethernet/3com/3c59x.c

2803

ioread32(ioaddr + DownListPtr),

drivers/net/ethernet/3com/typhoon.c

1163

if (ioread32(ioaddr + TYPHOON_REG_INTR_STATUS) &

drivers/net/ethernet/3com/typhoon.c

1360

irqEnabled = ioread32(ioaddr + TYPHOON_REG_INTR_ENABLE);

drivers/net/ethernet/3com/typhoon.c

1363

irqMasked = ioread32(ioaddr + TYPHOON_REG_INTR_MASK);

drivers/net/ethernet/3com/typhoon.c

1407

ioread32(ioaddr + TYPHOON_REG_STATUS) !=

drivers/net/ethernet/3com/typhoon.c

1439

ioread32(ioaddr + TYPHOON_REG_STATUS) !=

drivers/net/ethernet/3com/typhoon.c

1449

ioread32(ioaddr + TYPHOON_REG_STATUS));

drivers/net/ethernet/3com/typhoon.c

1483

ioread32(ioaddr + TYPHOON_REG_STATUS));

drivers/net/ethernet/3com/typhoon.c

1766

intr_status = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);

drivers/net/ethernet/3com/typhoon.c

2223

if (ioread32(ioaddr + TYPHOON_REG_STATUS) !=

drivers/net/ethernet/3com/typhoon.c

2235

val = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);

drivers/net/ethernet/3com/typhoon.c

2238

ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);

drivers/net/ethernet/3com/typhoon.c

2240

val = ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);

drivers/net/ethernet/3com/typhoon.c

2248

ioread32(ioaddr + TYPHOON_REG_INTR_STATUS);

drivers/net/ethernet/3com/typhoon.c

308

do { if (likely(use_mmio)) ioread32(x+TYPHOON_REG_HEARTBEAT); } while (0)

drivers/net/ethernet/3com/typhoon.c

393

if (ioread32(ioaddr + TYPHOON_REG_STATUS) ==

drivers/net/ethernet/3com/typhoon.c

433

if (ioread32(ioaddr + TYPHOON_REG_STATUS) == wait_value)

drivers/net/ethernet/alacritech/slic.h

559

return ioread32(sdev->regs + reg);

drivers/net/ethernet/alacritech/slic.h

570

(void)ioread32(sdev->regs + SLIC_REG_HOSTID);

drivers/net/ethernet/altera/altera_tse_ethtool.c

67

u32 rev = ioread32(&priv->mac_dev->megacore_revision);

drivers/net/ethernet/altera/altera_tse_main.c

1430

revision = ioread32(&priv->mac_dev->megacore_revision);

drivers/net/ethernet/amd/pds_core/debugfs.c

42

ioread32(&pdsc->info_regs->fw_heartbeat));

drivers/net/ethernet/amd/pds_core/dev.c

65

pdsc->last_hb = ioread32(&pdsc->info_regs->fw_heartbeat);

drivers/net/ethernet/amd/pds_core/dev.c

94

return ioread32(&pdsc->cmd_regs->done) & PDS_CORE_DEV_CMD_DONE;

drivers/net/ethernet/amd/pds_core/main.c

110

sig = ioread32(&pdsc->info_regs->signature);

drivers/net/ethernet/amd/xgbe/xgbe-common.h

1440

ioread32((_pdata)->xgmac_regs + _reg)

drivers/net/ethernet/amd/xgbe/xgbe-common.h

1464

ioread32((_pdata)->xgmac_regs + \

drivers/net/ethernet/amd/xgbe/xgbe-common.h

1490

ioread32((_channel)->dma_regs + _reg)

drivers/net/ethernet/amd/xgbe/xgbe-common.h

1526

ioread32((_pdata)->xpcs_regs + (_off))

drivers/net/ethernet/amd/xgbe/xgbe-common.h

1624

ioread32((_pdata)->xprop_regs + (_reg))

drivers/net/ethernet/amd/xgbe/xgbe-common.h

1657

ioread32((_pdata)->xi2c_regs + (_reg))

drivers/net/ethernet/apm/xgene-v2/enet.c

23

return ioread32(addr);

drivers/net/ethernet/apm/xgene/xgene_enet_cle.c

112

status = ioread32(base + INDCMD_STATUS);

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

189

ring_state = ioread32(&cmd_base[1]);

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

279

while (!(done = ioread32(cmd_done)) && wait--)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

295

*val = ioread32(addr);

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

303

*val = ioread32(addr);

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

311

*val = ioread32(addr);

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

337

while (!(done = ioread32(cmd_done)) && wait--)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

343

rd_data = ioread32(rd);

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

365

while (!(done = ioread32(cmd_done)) && wait--)

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

372

rd_data = ioread32(rd);

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

679

if (!ioread32(p->ring_csr_addr + CLKEN_ADDR))

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

682

if (ioread32(p->ring_csr_addr + SRST_ADDR))

drivers/net/ethernet/apm/xgene/xgene_enet_hw.c

73

*data = ioread32(pdata->ring_csr_addr + offset);

drivers/net/ethernet/apm/xgene/xgene_enet_ring2.c

176

ring_state = ioread32(&cmd_base[1]);

drivers/net/ethernet/apm/xgene/xgene_enet_sgmac.c

47

return ioread32(p->eth_csr_addr + offset);

drivers/net/ethernet/apm/xgene/xgene_enet_sgmac.c

52

return ioread32(p->eth_diag_csr_addr + offset);

drivers/net/ethernet/apm/xgene/xgene_enet_sgmac.c

57

return ioread32(p->mcx_mac_csr_addr + offset);

drivers/net/ethernet/apm/xgene/xgene_enet_xgmac.c

104

*val = ioread32(addr);

drivers/net/ethernet/apm/xgene/xgene_enet_xgmac.c

118

while (!(done = ioread32(cmd_done)) && wait--)

drivers/net/ethernet/apm/xgene/xgene_enet_xgmac.c

124

*rd_data = ioread32(rd);

drivers/net/ethernet/apm/xgene/xgene_enet_xgmac.c

154

*val = ioread32(addr);

drivers/net/ethernet/apm/xgene/xgene_enet_xgmac.c

57

while (!(done = ioread32(cmd_done)) && wait--)

drivers/net/ethernet/apm/xgene/xgene_enet_xgmac.c

96

*val = ioread32(addr);

drivers/net/ethernet/arc/emac.h

185

return ioread32(priv->regs + reg * sizeof(int));

drivers/net/ethernet/atheros/ag71xx.c

409

(void)ioread32(ag->mac_base + reg);

drivers/net/ethernet/atheros/ag71xx.c

414

return ioread32(ag->mac_base + reg);

drivers/net/ethernet/atheros/ag71xx.c

422

iowrite32(ioread32(r) | mask, r);

drivers/net/ethernet/atheros/ag71xx.c

424

(void)ioread32(r);

drivers/net/ethernet/atheros/ag71xx.c

432

iowrite32(ioread32(r) & ~mask, r);

drivers/net/ethernet/atheros/ag71xx.c

434

(void)ioread32(r);

drivers/net/ethernet/atheros/atlx/atl1.c

1421

value = ioread32(hw->hw_addr + REG_SRAM_RXF_LEN);

drivers/net/ethernet/atheros/atlx/atl1.c

1433

value = ioread32(hw->hw_addr + REG_SRAM_RRD_LEN);

drivers/net/ethernet/atheros/atlx/atl1.c

1610

value = ioread32(adapter->hw.hw_addr + REG_ISR);

drivers/net/ethernet/atheros/atlx/atl1.c

1633

value = ioread32(adapter->hw.hw_addr + 0x1008);

drivers/net/ethernet/atheros/atlx/atl1.c

261

ioread32(hw->hw_addr + REG_MASTER_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

271

icr = ioread32(hw->hw_addr + REG_IDLE_STATUS);

drivers/net/ethernet/atheros/atlx/atl1.c

2827

ioread32(hw->hw_addr + REG_WOL_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

2841

ioread32(hw->hw_addr + REG_MAC_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

2844

ctrl = ioread32(hw->hw_addr + REG_PCIE_PHYMISC);

drivers/net/ethernet/atheros/atlx/atl1.c

2847

ioread32(hw->hw_addr + REG_PCIE_PHYMISC);

drivers/net/ethernet/atheros/atlx/atl1.c

2851

ioread32(hw->hw_addr + REG_WOL_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

2853

ioread32(hw->hw_addr + REG_MAC_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

2861

ioread32(hw->hw_addr + REG_WOL_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

2862

ctrl = ioread32(hw->hw_addr + REG_PCIE_PHYMISC);

drivers/net/ethernet/atheros/atlx/atl1.c

2865

ioread32(hw->hw_addr + REG_PCIE_PHYMISC);

drivers/net/ethernet/atheros/atlx/atl1.c

297

value = ioread32(hw->hw_addr + REG_SPI_FLASH_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

319

ioread32(hw->hw_addr + REG_VPD_CAP);

drivers/net/ethernet/atheros/atlx/atl1.c

323

control = ioread32(hw->hw_addr + REG_VPD_CAP);

drivers/net/ethernet/atheros/atlx/atl1.c

328

*p_value = ioread32(hw->hw_addr + REG_VPD_DATA);

drivers/net/ethernet/atheros/atlx/atl1.c

3470

regbuf[i] = ioread32(hw->hw_addr + (i * sizeof(u32)));

drivers/net/ethernet/atheros/atlx/atl1.c

349

ioread32(hw->hw_addr + REG_MDIO_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

353

val = ioread32(hw->hw_addr + REG_MDIO_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

395

ioread32(hw->hw_addr + REG_SPI_FLASH_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

399

value = ioread32(hw->hw_addr + REG_SPI_FLASH_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

407

*buf = ioread32(hw->hw_addr + REG_SPI_DATA);

drivers/net/ethernet/atheros/atlx/atl1.c

500

addr[0] = ioread32(hw->hw_addr + REG_MAC_STA_ADDR);

drivers/net/ethernet/atheros/atlx/atl1.c

576

mta = ioread32((hw->hw_addr + REG_RX_HASH_TABLE) + (hash_reg << 2));

drivers/net/ethernet/atheros/atlx/atl1.c

597

ioread32(hw->hw_addr + REG_MDIO_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

601

val = ioread32(hw->hw_addr + REG_MDIO_CTRL);

drivers/net/ethernet/atheros/atlx/atl1.c

674

val = ioread32(hw->hw_addr + REG_MDIO_CTRL);

drivers/net/ethernet/atheros/atlx/atl2.h

41

#define ATL2_WRITE_FLUSH(a) (ioread32((a)->hw_addr))

drivers/net/ethernet/atheros/atlx/atl2.h

43

#define ATL2_READ_REG(a, reg) (ioread32((a)->hw_addr + (reg)))

drivers/net/ethernet/atheros/atlx/atl2.h

59

(ioread32(((a)->hw_addr + (reg)) + ((offset) << 2)))

drivers/net/ethernet/atheros/atlx/atlx.c

122

rctl = ioread32(hw->hw_addr + REG_MAC_CTRL);

drivers/net/ethernet/atheros/atlx/atlx.c

148

ioread32(adapter->hw.hw_addr + REG_IMR);

drivers/net/ethernet/atheros/atlx/atlx.c

228

ctrl = ioread32(adapter->hw.hw_addr + REG_MAC_CTRL);

drivers/net/ethernet/cisco/enic/vnic_dev.c

221

status = ioread32(&devcmd->status);

drivers/net/ethernet/cisco/enic/vnic_dev.c

246

status = ioread32(&devcmd->status);

drivers/net/ethernet/cisco/enic/vnic_dev.c

291

fetch_index = ioread32(&dc2c->wq_ctrl->fetch_index);

drivers/net/ethernet/cisco/enic/vnic_dev.c

385

fetch_index = ioread32(&vdev->devcmd2->wq.ctrl->fetch_index);

drivers/net/ethernet/cisco/enic/vnic_dev.c

55

if ((ioread32(&rh->magic) != VNIC_RES_MAGIC) ||

drivers/net/ethernet/cisco/enic/vnic_dev.c

56

(ioread32(&rh->version) != VNIC_RES_VERSION)) {

drivers/net/ethernet/cisco/enic/vnic_dev.c

57

if ((ioread32(&mrh->magic) != MGMTVNIC_MAGIC) ||

drivers/net/ethernet/cisco/enic/vnic_dev.c

58

(ioread32(&mrh->version) != MGMTVNIC_VERSION)) {

drivers/net/ethernet/cisco/enic/vnic_dev.c

62

ioread32(&rh->magic), ioread32(&rh->version));

drivers/net/ethernet/cisco/enic/vnic_dev.c

67

if (ioread32(&mrh->magic) == MGMTVNIC_MAGIC)

drivers/net/ethernet/cisco/enic/vnic_dev.c

76

u32 bar_offset = ioread32(&r->bar_offset);

drivers/net/ethernet/cisco/enic/vnic_dev.c

77

u32 count = ioread32(&r->count);

drivers/net/ethernet/cisco/enic/vnic_intr.h

53

return ioread32(&intr->ctrl->mask);

drivers/net/ethernet/cisco/enic/vnic_intr.h

71

return ioread32(&intr->ctrl->int_credits);

drivers/net/ethernet/cisco/enic/vnic_intr.h

86

return ioread32(legacy_pba);

drivers/net/ethernet/cisco/enic/vnic_rq.c

135

return ioread32(&rq->ctrl->error_status);

drivers/net/ethernet/cisco/enic/vnic_rq.c

158

if (!ioread32(&rq->ctrl->running))

drivers/net/ethernet/cisco/enic/vnic_rq.c

188

fetch_index = ioread32(&rq->ctrl->fetch_index);

drivers/net/ethernet/cisco/enic/vnic_wq.c

155

return ioread32(&wq->ctrl->error_status);

drivers/net/ethernet/cisco/enic/vnic_wq.c

172

if (!(ioread32(&wq->ctrl->running)))

drivers/net/ethernet/dec/tulip/21142.c

143

int csr12 = ioread32(ioaddr + CSR12);

drivers/net/ethernet/dec/tulip/21142.c

144

int csr14 = ioread32(ioaddr + CSR14);

drivers/net/ethernet/dec/tulip/21142.c

207

ioread32(ioaddr + CSR5));

drivers/net/ethernet/dec/tulip/21142.c

212

tp->csr6, ioread32(ioaddr + CSR6),

drivers/net/ethernet/dec/tulip/21142.c

213

ioread32(ioaddr + CSR12));

drivers/net/ethernet/dec/tulip/21142.c

34

int csr12 = ioread32(ioaddr + CSR12);

drivers/net/ethernet/dec/tulip/21142.c

37

int csr14 = ioread32(ioaddr + CSR14);

drivers/net/ethernet/dec/tulip/de2104x.c

366

#define dr32(reg) ioread32(de->regs + (reg))

drivers/net/ethernet/dec/tulip/dmfe.c

145

#define dr32(reg) ioread32(ioaddr + (reg))

drivers/net/ethernet/dec/tulip/eeprom.c

334

#define eeprom_delay() ioread32(ee_addr)

drivers/net/ethernet/dec/tulip/eeprom.c

364

retval = (retval << 1) | ((ioread32(ee_addr) & EE_DATA_READ) ? 1 : 0);

drivers/net/ethernet/dec/tulip/eeprom.c

372

retval = (retval << 1) | ((ioread32(ee_addr) & EE_DATA_READ) ? 1 : 0);

drivers/net/ethernet/dec/tulip/interrupt.c

135

if (ioread32(tp->base_addr + CSR5) == 0xffffffff) {

drivers/net/ethernet/dec/tulip/interrupt.c

280

} while ((ioread32(tp->base_addr + CSR5) & RxIntr));

drivers/net/ethernet/dec/tulip/interrupt.c

500

int csr12 = ioread32(tp->base_addr + CSR12) & 0xff;

drivers/net/ethernet/dec/tulip/interrupt.c

544

csr5 = ioread32(ioaddr + CSR5);

drivers/net/ethernet/dec/tulip/interrupt.c

587

csr5, ioread32(ioaddr + CSR5));

drivers/net/ethernet/dec/tulip/interrupt.c

668

csr5, ioread32(ioaddr + CSR6),

drivers/net/ethernet/dec/tulip/interrupt.c

697

dev->stats.rx_missed_errors += ioread32(ioaddr + CSR8) & 0xffff;

drivers/net/ethernet/dec/tulip/interrupt.c

767

csr5 = ioread32(ioaddr + CSR5);

drivers/net/ethernet/dec/tulip/interrupt.c

798

if (tp->ttimer == 0 || (ioread32(ioaddr + CSR11) & 0xffff) == 0) {

drivers/net/ethernet/dec/tulip/interrupt.c

813

if ((missed = ioread32(ioaddr + CSR8) & 0x1ffff)) {

drivers/net/ethernet/dec/tulip/interrupt.c

819

ioread32(ioaddr + CSR5));

drivers/net/ethernet/dec/tulip/interrupt.c

93

if(((ioread32(tp->base_addr + CSR5)>>17)&0x07) == 4) {

drivers/net/ethernet/dec/tulip/media.c

100

retval = (retval << 1) | ((ioread32(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);

drivers/net/ethernet/dec/tulip/media.c

132

if ( ! (ioread32(ioaddr + 0xA0) & 0x80000000))

drivers/net/ethernet/dec/tulip/media.c

23

#define mdio_delay() ioread32(mdio_addr)

drivers/net/ethernet/dec/tulip/media.c

263

ioread32(ioaddr + CSR15);

drivers/net/ethernet/dec/tulip/media.c

277

ioread32(ioaddr + CSR15); /* flush posted writes */

drivers/net/ethernet/dec/tulip/media.c

290

ioread32(ioaddr + CSR12);

drivers/net/ethernet/dec/tulip/media.c

304

ioread32(ioaddr + CSR12); /* flush posted writes */

drivers/net/ethernet/dec/tulip/media.c

343

ioread32(ioaddr + CSR12) & 0xff);

drivers/net/ethernet/dec/tulip/media.c

349

ioread32(ioaddr + 0xB8),

drivers/net/ethernet/dec/tulip/media.c

383

ioread32(ioaddr + CSR12));

drivers/net/ethernet/dec/tulip/media.c

62

return ioread32(ioaddr + comet_miireg2offset[location]);

drivers/net/ethernet/dec/tulip/media.c

69

ioread32(ioaddr + 0xA0);

drivers/net/ethernet/dec/tulip/media.c

70

ioread32(ioaddr + 0xA0);

drivers/net/ethernet/dec/tulip/media.c

73

if ( ! ((retval = ioread32(ioaddr + 0xA0)) & 0x80000000))

drivers/net/ethernet/dec/tulip/pnic.c

109

int csr12 = ioread32(ioaddr + CSR12);

drivers/net/ethernet/dec/tulip/pnic.c

111

int phy_reg = ioread32(ioaddr + 0xB8);

drivers/net/ethernet/dec/tulip/pnic.c

112

int csr5 = ioread32(ioaddr + CSR5);

drivers/net/ethernet/dec/tulip/pnic.c

129

ioread32(ioaddr + CSR5),

drivers/net/ethernet/dec/tulip/pnic.c

130

ioread32(ioaddr + 0xB8));

drivers/net/ethernet/dec/tulip/pnic.c

162

if(!ioread32(ioaddr + CSR7)) {

drivers/net/ethernet/dec/tulip/pnic.c

23

u32 phy_reg = ioread32(ioaddr + 0xB8);

drivers/net/ethernet/dec/tulip/pnic.c

56

int phy_reg = ioread32(ioaddr + 0xB8);

drivers/net/ethernet/dec/tulip/pnic.c

61

if (ioread32(ioaddr + CSR5) & TPLnkFail) {

drivers/net/ethernet/dec/tulip/pnic.c

62

iowrite32((ioread32(ioaddr + CSR7) & ~TPLnkFail) | TPLnkPass, ioaddr + CSR7);

drivers/net/ethernet/dec/tulip/pnic.c

75

} else if (ioread32(ioaddr + CSR5) & TPLnkPass) {

drivers/net/ethernet/dec/tulip/pnic.c

83

iowrite32((ioread32(ioaddr + CSR7) & ~TPLnkPass) | TPLnkFail, ioaddr + CSR7);

drivers/net/ethernet/dec/tulip/pnic.c

94

if(!ioread32(ioaddr + CSR7)) {

drivers/net/ethernet/dec/tulip/pnic2.c

108

csr14 = (ioread32(ioaddr + CSR14) & 0xfff0ee39);

drivers/net/ethernet/dec/tulip/pnic2.c

135

tp->csr6 = ioread32(ioaddr + CSR6);

drivers/net/ethernet/dec/tulip/pnic2.c

163

csr12 = (ioread32(ioaddr + CSR12) & 0xffff8fff);

drivers/net/ethernet/dec/tulip/pnic2.c

177

int csr12 = ioread32(ioaddr + CSR12);

drivers/net/ethernet/dec/tulip/pnic2.c

182

csr12, csr5, ioread32(ioaddr + CSR14));

drivers/net/ethernet/dec/tulip/pnic2.c

241

csr14 = (ioread32(ioaddr + CSR14) & 0xffffff7f);

drivers/net/ethernet/dec/tulip/pnic2.c

253

tp->csr6 = (ioread32(ioaddr + CSR6) & 0xfe3bd1fd);

drivers/net/ethernet/dec/tulip/pnic2.c

272

ioread32(ioaddr + CSR6),

drivers/net/ethernet/dec/tulip/pnic2.c

273

ioread32(ioaddr + CSR12));

drivers/net/ethernet/dec/tulip/pnic2.c

290

csr14 = (ioread32(ioaddr + CSR14) & 0xffffff7f);

drivers/net/ethernet/dec/tulip/pnic2.c

307

tp->csr6 = (ioread32(ioaddr + CSR6) & 0xfe3bd1fd);

drivers/net/ethernet/dec/tulip/pnic2.c

392

csr14 = (ioread32(ioaddr + CSR14) & 0xffffff7f);

drivers/net/ethernet/dec/tulip/pnic2.c

398

tp->csr6 = (ioread32(ioaddr + CSR6) & 0xfe3bd1fd);

drivers/net/ethernet/dec/tulip/pnic2.c

88

ioread32(ioaddr + CSR12));

drivers/net/ethernet/dec/tulip/timer.c

149

ioread32(ioaddr + CSR12));

drivers/net/ethernet/dec/tulip/timer.c

23

u32 csr12 = ioread32(ioaddr + CSR12);

drivers/net/ethernet/dec/tulip/timer.c

30

ioread32(ioaddr + CSR5), ioread32(ioaddr + CSR6),

drivers/net/ethernet/dec/tulip/timer.c

31

csr12, ioread32(ioaddr + CSR13),

drivers/net/ethernet/dec/tulip/timer.c

32

ioread32(ioaddr + CSR14), ioread32(ioaddr + CSR15));

drivers/net/ethernet/dec/tulip/timer.c

49

ioread32(ioaddr + CSR6),

drivers/net/ethernet/dec/tulip/tulip.h

526

(void) ioread32(ioaddr + CSR6); /* mmio sync */

drivers/net/ethernet/dec/tulip/tulip.h

532

u32 csr6 = ioread32(ioaddr + CSR6);

drivers/net/ethernet/dec/tulip/tulip.h

542

while (--i && (ioread32(ioaddr + CSR5) & (CSR5_TS|CSR5_RS)))

drivers/net/ethernet/dec/tulip/tulip.h

547

ioread32(ioaddr + CSR5),

drivers/net/ethernet/dec/tulip/tulip.h

548

ioread32(ioaddr + CSR6));

drivers/net/ethernet/dec/tulip/tulip_core.c

1060

csr6 = ioread32(ioaddr + CSR6) & ~0x00D5;

drivers/net/ethernet/dec/tulip/tulip_core.c

1491

ioread32(ioaddr + CSR8);

drivers/net/ethernet/dec/tulip/tulip_core.c

1505

value = ioread32(ioaddr + CSR9);

drivers/net/ethernet/dec/tulip/tulip_core.c

1513

put_unaligned_le32(ioread32(ioaddr + 0xA4), addr);

drivers/net/ethernet/dec/tulip/tulip_core.c

1514

put_unaligned_le16(ioread32(ioaddr + 0xA8), addr + 4);

drivers/net/ethernet/dec/tulip/tulip_core.c

1783

tmp = ioread32(ioaddr + CSR18);

drivers/net/ethernet/dec/tulip/tulip_core.c

1789

tmp = ioread32(ioaddr + CSR13);

drivers/net/ethernet/dec/tulip/tulip_core.c

1851

tmp = ioread32(ioaddr + CSR20);

drivers/net/ethernet/dec/tulip/tulip_core.c

434

iowrite32(ioread32(ioaddr+CSR5)| 0x00008010, ioaddr + CSR5);

drivers/net/ethernet/dec/tulip/tulip_core.c

435

iowrite32(ioread32(ioaddr+CSR7)| 0x00008010, ioaddr + CSR7);

drivers/net/ethernet/dec/tulip/tulip_core.c

442

} else if (ioread32(ioaddr + CSR5) & TPLnkPass)

drivers/net/ethernet/dec/tulip/tulip_core.c

465

iowrite32(ioread32(ioaddr + 0x88) | 1, ioaddr + 0x88);

drivers/net/ethernet/dec/tulip/tulip_core.c

487

ioread32(ioaddr + CSR0),

drivers/net/ethernet/dec/tulip/tulip_core.c

488

ioread32(ioaddr + CSR5),

drivers/net/ethernet/dec/tulip/tulip_core.c

489

ioread32(ioaddr + CSR6));

drivers/net/ethernet/dec/tulip/tulip_core.c

544

ioread32(ioaddr + CSR5), ioread32(ioaddr + CSR12),

drivers/net/ethernet/dec/tulip/tulip_core.c

545

ioread32(ioaddr + CSR13), ioread32(ioaddr + CSR14),

drivers/net/ethernet/dec/tulip/tulip_core.c

546

ioread32(ioaddr + CSR15));

drivers/net/ethernet/dec/tulip/tulip_core.c

553

(int)ioread32(ioaddr + CSR5),

drivers/net/ethernet/dec/tulip/tulip_core.c

554

(int)ioread32(ioaddr + CSR6),

drivers/net/ethernet/dec/tulip/tulip_core.c

555

(int)ioread32(ioaddr + CSR7),

drivers/net/ethernet/dec/tulip/tulip_core.c

556

(int)ioread32(ioaddr + CSR12));

drivers/net/ethernet/dec/tulip/tulip_core.c

560

ioread32(ioaddr + CSR5), ioread32(ioaddr + CSR12));

drivers/net/ethernet/dec/tulip/tulip_core.c

768

if (ioread32(ioaddr + CSR6) != 0xffffffff)

drivers/net/ethernet/dec/tulip/tulip_core.c

769

dev->stats.rx_missed_errors += ioread32(ioaddr + CSR8) & 0xffff;

drivers/net/ethernet/dec/tulip/tulip_core.c

830

ioread32 (ioaddr + CSR5));

drivers/net/ethernet/dec/tulip/tulip_core.c

849

dev->stats.rx_missed_errors += ioread32(ioaddr + CSR8) & 0xffff;

drivers/net/ethernet/dec/tulip/tulip_core.c

920

int csr12 = ioread32 (ioaddr + CSR12);

drivers/net/ethernet/dec/tulip/tulip_core.c

921

int csr14 = ioread32 (ioaddr + CSR14);

drivers/net/ethernet/dec/tulip/tulip_core.c

941

((ioread32(ioaddr + CSR6) >> 3) & 0x0040) +

drivers/net/ethernet/dec/tulip/uli526x.c

36

#define ur32(reg) ioread32(ioaddr + (reg))

drivers/net/ethernet/dec/tulip/winbond-840.c

1107

u32 intr_status = ioread32(ioaddr + IntrStatus);

drivers/net/ethernet/dec/tulip/winbond-840.c

1155

ioread32(ioaddr + IntrStatus));

drivers/net/ethernet/dec/tulip/winbond-840.c

1310

np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;

drivers/net/ethernet/dec/tulip/winbond-840.c

1323

np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;

drivers/net/ethernet/dec/tulip/winbond-840.c

1473

ioread32(ioaddr + IntrStatus),

drivers/net/ethernet/dec/tulip/winbond-840.c

1474

ioread32(ioaddr + NetworkConfig));

drivers/net/ethernet/dec/tulip/winbond-840.c

1491

if (ioread32(ioaddr + NetworkConfig) != 0xffffffff)

drivers/net/ethernet/dec/tulip/winbond-840.c

1492

np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;

drivers/net/ethernet/dec/tulip/winbond-840.c

1574

np->stats.rx_missed_errors += ioread32(ioaddr + RxMissed) & 0xffff;

drivers/net/ethernet/dec/tulip/winbond-840.c

1578

BUG_ON(np->csr6 || ioread32(ioaddr + IntrEnable));

drivers/net/ethernet/dec/tulip/winbond-840.c

1601

ioread32(np->base_addr+PCIBusCfg);

drivers/net/ethernet/dec/tulip/winbond-840.c

478

#define eeprom_delay(ee_addr) ioread32(ee_addr)

drivers/net/ethernet/dec/tulip/winbond-840.c

512

retval = (retval << 1) | ((ioread32(ee_addr) & EE_DataIn) ? 1 : 0);

drivers/net/ethernet/dec/tulip/winbond-840.c

529

#define mdio_delay(mdio_addr) ioread32(mdio_addr)

drivers/net/ethernet/dec/tulip/winbond-840.c

577

retval = (retval << 1) | ((ioread32(mdio_addr) & MDIO_DataIn) ? 1 : 0);

drivers/net/ethernet/dec/tulip/winbond-840.c

738

int csr5 = ioread32(ioaddr + IntrStatus);

drivers/net/ethernet/dec/tulip/winbond-840.c

772

ioread32(ioaddr + IntrStatus),

drivers/net/ethernet/dec/tulip/winbond-840.c

773

ioread32(ioaddr + NetworkConfig));

drivers/net/ethernet/dec/tulip/winbond-840.c

918

ioread32(ioaddr + IntrStatus));

drivers/net/ethernet/dec/tulip/winbond-840.c

933

printk(KERN_DEBUG "Tx Descriptor addr %xh\n", ioread32(ioaddr+0x4C));

drivers/net/ethernet/dec/tulip/xircom_cb.c

44

#define xr32(reg) ioread32(ioaddr + (reg))

drivers/net/ethernet/dlink/dl2k.c

16

#define dr32(reg) ioread32(ioaddr + (reg))

drivers/net/ethernet/dlink/sundance.c

1082

if (ioread32 (np->base + TxListPtr) == 0)

drivers/net/ethernet/dlink/sundance.c

1841

ioread32(ioaddr + RxStatus), ioread16(ioaddr + IntrStatus));

drivers/net/ethernet/dlink/sundance.c

1856

if ((ioread32(ioaddr + DMACtrl) & 0xc000) == 0)

drivers/net/ethernet/dlink/sundance.c

453

iowrite32 (reset_cmd | ioread32 (ioaddr), ioaddr);

drivers/net/ethernet/dlink/sundance.c

456

while (ioread32 (ioaddr) & (ResetBusy << 16)) {

drivers/net/ethernet/dlink/sundance.c

617

dev->name, ioread32(ioaddr + ASICCtrl));

drivers/net/ethernet/dlink/sundance.c

653

if (ioread32 (ioaddr + ASICCtrl) & 0x80) {

drivers/net/ethernet/dlink/sundance.c

682

printk("ASIC Control is %x.\n", ioread32(ioaddr + ASICCtrl));

drivers/net/ethernet/dlink/sundance.c

685

printk("ASIC Control is now %x.\n", ioread32(ioaddr + ASICCtrl));

drivers/net/ethernet/dlink/sundance.c

715

#define eeprom_delay(ee_addr) ioread32(ee_addr)

drivers/net/ethernet/dlink/sundance.c

867

iowrite32(ioread32(ioaddr + ASICCtrl) | 0x0C, ioaddr + ASICCtrl);

drivers/net/ethernet/dlink/sundance.c

900

dev->name, ioread32(ioaddr + RxStatus), ioread8(ioaddr + TxStatus),

drivers/net/ethernet/dlink/sundance.c

901

ioread32(ioaddr + MACCtrl0),

drivers/net/ethernet/dlink/sundance.c

954

ioread8(ioaddr + TxStatus), ioread32(ioaddr + RxStatus));

drivers/net/ethernet/dlink/sundance.c

987

ioread32(np->base + TxListPtr),

drivers/net/ethernet/ec_bhf.c

274

priv->ec_io = priv->io + ioread32(ec_info + INFO_BLOCK_OFFSET);

drivers/net/ethernet/ec_bhf.c

275

priv->mii_io = priv->ec_io + ioread32(priv->ec_io + EC_MII_OFFSET);

drivers/net/ethernet/ec_bhf.c

276

priv->fifo_io = priv->ec_io + ioread32(priv->ec_io + EC_FIFO_OFFSET);

drivers/net/ethernet/ec_bhf.c

277

priv->mac_io = priv->ec_io + ioread32(priv->ec_io + EC_MAC_OFFSET);

drivers/net/ethernet/ec_bhf.c

329

mask = ioread32(priv->dma_io + offset);

drivers/net/ethernet/ec_bhf.c

459

stats->rx_packets = ioread32(priv->mac_io + MAC_RX_FRAME_CNT);

drivers/net/ethernet/ec_bhf.c

460

stats->tx_packets = ioread32(priv->mac_io + MAC_TX_FRAME_CNT);

drivers/net/ethernet/emulex/benet/be_cmds.c

4775

reg_val = ioread32(adapter->db + PHYSDEV_CONTROL_OFFSET);

drivers/net/ethernet/emulex/benet/be_cmds.c

4806

sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);

drivers/net/ethernet/emulex/benet/be_cmds.c

640

ready = ioread32(db);

drivers/net/ethernet/emulex/benet/be_cmds.c

716

sem = ioread32(adapter->csr + SLIPORT_SEMAPHORE_OFFSET_BEx);

drivers/net/ethernet/emulex/benet/be_cmds.c

731

sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);

drivers/net/ethernet/emulex/benet/be_main.c

3353

sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);

drivers/net/ethernet/emulex/benet/be_main.c

3356

sliport_err1 = ioread32(adapter->db +

drivers/net/ethernet/emulex/benet/be_main.c

3358

sliport_err2 = ioread32(adapter->db +

drivers/net/ethernet/emulex/benet/be_main.c

3375

ue_lo = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_LOW);

drivers/net/ethernet/emulex/benet/be_main.c

3376

ue_hi = ioread32(adapter->pcicfg + PCICFG_UE_STATUS_HIGH);

drivers/net/ethernet/emulex/benet/be_main.c

3377

ue_lo_mask = ioread32(adapter->pcicfg +

drivers/net/ethernet/emulex/benet/be_main.c

3379

ue_hi_mask = ioread32(adapter->pcicfg +

drivers/net/ethernet/emulex/benet/be_main.c

5255

val = ioread32(adapter->pcicfg + SLIPORT_SOFTRESET_OFFSET);

drivers/net/ethernet/engleder/tsnep_ethtool.c

187

reg = ioread32(adapter->addr + ECM_STAT);

drivers/net/ethernet/engleder/tsnep_ethtool.c

210

reg = ioread32(adapter->addr + TSNEP_QUEUE(i) +

drivers/net/ethernet/engleder/tsnep_main.c

1064

readx_poll_timeout(ioread32, rx->addr + TSNEP_CONTROL, val,

drivers/net/ethernet/engleder/tsnep_main.c

2204

reg = ioread32(adapter->addr + TSNEP_QUEUE(i) +

drivers/net/ethernet/engleder/tsnep_main.c

2222

reg = ioread32(adapter->addr + ECM_STAT);

drivers/net/ethernet/engleder/tsnep_main.c

2410

ioread32(adapter->addr + TSNEP_MAC_ADDRESS_LOW);

drivers/net/ethernet/engleder/tsnep_main.c

2595

type = ioread32(adapter->addr + ECM_TYPE);

drivers/net/ethernet/engleder/tsnep_main.c

370

readx_poll_timeout(ioread32, tx->addr + TSNEP_CONTROL, val,

drivers/net/ethernet/engleder/tsnep_main.c

90

u32 active = ioread32(adapter->addr + ECM_INT_ACTIVE);

drivers/net/ethernet/engleder/tsnep_ptp.c

13

high = ioread32(adapter->addr + ECM_SYSTEM_TIME_HIGH);

drivers/net/ethernet/engleder/tsnep_ptp.c

137

high = ioread32(adapter->addr + ECM_SYSTEM_TIME_HIGH);

drivers/net/ethernet/engleder/tsnep_ptp.c

140

low = ioread32(adapter->addr + ECM_SYSTEM_TIME_LOW);

drivers/net/ethernet/engleder/tsnep_ptp.c

143

high = ioread32(adapter->addr + ECM_SYSTEM_TIME_HIGH);

drivers/net/ethernet/engleder/tsnep_ptp.c

15

low = ioread32(adapter->addr + ECM_SYSTEM_TIME_LOW);

drivers/net/ethernet/engleder/tsnep_ptp.c

17

high = ioread32(adapter->addr + ECM_SYSTEM_TIME_HIGH);

drivers/net/ethernet/engleder/tsnep_ptp.c

186

high = ioread32(adapter->addr + ECM_COUNTER_HIGH);

drivers/net/ethernet/engleder/tsnep_ptp.c

189

low = ioread32(adapter->addr + ECM_COUNTER_LOW);

drivers/net/ethernet/engleder/tsnep_ptp.c

192

high = ioread32(adapter->addr + ECM_COUNTER_HIGH);

drivers/net/ethernet/engleder/tsnep_selftests.c

178

time_high = ioread32(adapter->addr + ECM_SYSTEM_TIME_HIGH);

drivers/net/ethernet/engleder/tsnep_selftests.c

179

*gc_time = ioread32(adapter->addr + TSNEP_GC_TIME);

drivers/net/ethernet/engleder/tsnep_selftests.c

181

time_low = ioread32(adapter->addr + ECM_SYSTEM_TIME_LOW);

drivers/net/ethernet/engleder/tsnep_selftests.c

182

*gc = ioread32(adapter->addr + TSNEP_GC);

drivers/net/ethernet/engleder/tsnep_selftests.c

185

*gc_time = ioread32(adapter->addr + TSNEP_GC_TIME);

drivers/net/ethernet/engleder/tsnep_selftests.c

187

time_high = ioread32(adapter->addr + ECM_SYSTEM_TIME_HIGH);

drivers/net/ethernet/engleder/tsnep_selftests.c

27

if (!(ioread32(adapter->addr + TSNEP_GC) & TSNEP_GC_TIMEOUT_ACTIVE))

drivers/net/ethernet/engleder/tsnep_selftests.c

35

if (ioread32(adapter->addr + TSNEP_GC) & TSNEP_GC_TIMEOUT_SIGNAL)

drivers/net/ethernet/engleder/tsnep_selftests.c

44

if (ioread32(adapter->addr + TSNEP_GC) &

drivers/net/ethernet/engleder/tsnep_selftests.c

64

if (!(ioread32(adapter->addr + TSNEP_GC) & active))

drivers/net/ethernet/engleder/tsnep_selftests.c

73

if (ioread32(adapter->addr + TSNEP_GC) &

drivers/net/ethernet/engleder/tsnep_selftests.c

97

time = ioread32(adapter->addr + ECM_SYSTEM_TIME_LOW);

drivers/net/ethernet/engleder/tsnep_tc.c

383

if (!(ioread32(adapter->addr + TSNEP_GC) &

drivers/net/ethernet/engleder/tsnep_tc.c

52

ioread32(addr);

drivers/net/ethernet/ethoc.c

242

return ioread32(dev->iobase + offset);

drivers/net/ethernet/faraday/ftgmac100.c

1078

phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);

drivers/net/ethernet/faraday/ftgmac100.c

1090

phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);

drivers/net/ethernet/faraday/ftgmac100.c

1095

data = ioread32(priv->base + FTGMAC100_OFFSET_PHYDATA);

drivers/net/ethernet/faraday/ftgmac100.c

1115

phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);

drivers/net/ethernet/faraday/ftgmac100.c

1130

phycr = ioread32(priv->base + FTGMAC100_OFFSET_PHYCR);

drivers/net/ethernet/faraday/ftgmac100.c

1238

status = ioread32(priv->base + FTGMAC100_OFFSET_ISR);

drivers/net/ethernet/faraday/ftgmac100.c

1336

ioread32(priv->base + FTGMAC100_OFFSET_ISR);

drivers/net/ethernet/faraday/ftgmac100.c

152

maccr = ioread32(priv->base + FTGMAC100_OFFSET_MACCR);

drivers/net/ethernet/faraday/ftgmac100.c

1695

maccr = ioread32(priv->base + FTGMAC100_OFFSET_MACCR);

drivers/net/ethernet/faraday/ftgmac100.c

1755

reg = ioread32(priv->base + FTGMAC100_OFFSET_REVR);

drivers/net/ethernet/faraday/ftgmac100.c

239

m = ioread32(priv->base + FTGMAC100_OFFSET_MAC_MADR);

drivers/net/ethernet/faraday/ftgmac100.c

240

l = ioread32(priv->base + FTGMAC100_OFFSET_MAC_LADR);

drivers/net/ethernet/faraday/ftgmac100.c

297

reg = ioread32(priv->base + FTGMAC100_OFFSET_ISR);

drivers/net/ethernet/faraday/ftgmac100.c

344

reg = ioread32(priv->base + FTGMAC100_OFFSET_FEAR);

drivers/net/ethernet/faraday/ftgmac100.c

347

reg = ioread32(priv->base + FTGMAC100_OFFSET_TPAFCR);

drivers/net/ethernet/faraday/ftgmac100.c

356

u32 maccr = ioread32(priv->base + FTGMAC100_OFFSET_MACCR);

drivers/net/ethernet/faraday/ftmac100.c

1083

maccr = ioread32(priv->base + FTMAC100_OFFSET_MACCR);

drivers/net/ethernet/faraday/ftmac100.c

1103

unsigned int maccr = ioread32(priv->base + FTMAC100_OFFSET_MACCR);

drivers/net/ethernet/faraday/ftmac100.c

125

maccr = ioread32(priv->base + FTMAC100_OFFSET_MACCR);

drivers/net/ethernet/faraday/ftmac100.c

802

phycr = ioread32(priv->base + FTMAC100_OFFSET_PHYCR);

drivers/net/ethernet/faraday/ftmac100.c

831

phycr = ioread32(priv->base + FTMAC100_OFFSET_PHYCR);

drivers/net/ethernet/faraday/ftmac100.c

916

status = ioread32(priv->base + FTMAC100_OFFSET_ISR);

drivers/net/ethernet/fealnx.c

1086

"config %8.8x.\n", dev->name, ioread32(ioaddr + ISR),

drivers/net/ethernet/fealnx.c

1087

ioread32(ioaddr + TCRRCR));

drivers/net/ethernet/fealnx.c

1131

ioread32(ioaddr + BCR);

drivers/net/ethernet/fealnx.c

1197

dev->name, ioread32(ioaddr + ISR));

drivers/net/ethernet/fealnx.c

1441

u32 intr_status = ioread32(ioaddr + ISR);

drivers/net/ethernet/fealnx.c

1470

ioread32(ioaddr + TALLY) & 0x7fff;

drivers/net/ethernet/fealnx.c

1474

(ioread32(ioaddr + TALLY) & 0x7fff0000) >> 16;

drivers/net/ethernet/fealnx.c

1556

data = ioread32(ioaddr + TSR);

drivers/net/ethernet/fealnx.c

1588

dev->stats.rx_missed_errors += ioread32(ioaddr + TALLY) & 0x7fff;

drivers/net/ethernet/fealnx.c

1592

(ioread32(ioaddr + TALLY) & 0x7fff0000) >> 16;

drivers/net/ethernet/fealnx.c

1596

dev->name, ioread32(ioaddr + ISR));

drivers/net/ethernet/fealnx.c

1751

ioread32(ioaddr + TALLY) & 0x7fff;

drivers/net/ethernet/fealnx.c

1753

(ioread32(ioaddr + TALLY) & 0x7fff0000) >> 16;

drivers/net/ethernet/fealnx.c

443

if ( (ioread32(ioaddr + TCRRCR) & CR_R_RXSTOP) == CR_R_RXSTOP)

drivers/net/ethernet/fealnx.c

454

if ( (ioread32(ioaddr + TCRRCR) & (CR_R_RXSTOP+CR_R_TXSTOP))

drivers/net/ethernet/fealnx.c

609

if (ioread32(ioaddr + PHYIDENTIFIER) == MysonPHYID)

drivers/net/ethernet/fealnx.c

705

miir = (ulong) ioread32(miiport);

drivers/net/ethernet/fealnx.c

765

miir = ioread32(miiport);

drivers/net/ethernet/fealnx.c

928

if (ioread32(np->mem + BMCRSR) & LinkIsUp2) {

drivers/net/ethernet/fealnx.c

951

if (ioread32(np->mem + TCRRCR) & CR_R_FD)

drivers/net/ethernet/fealnx.c

955

if (ioread32(np->mem + TCRRCR) & CR_R_PS10)

drivers/net/ethernet/freescale/enetc/enetc_hw.h

438

return ioread32(reg);

drivers/net/ethernet/freescale/enetc/enetc_hw.h

455

val = ioread32(reg);

drivers/net/ethernet/freescale/enetc/enetc_hw.h

475

val = ioread32(reg);

drivers/net/ethernet/freescale/enetc/enetc_hw.h

478

val = ioread32(reg);

drivers/net/ethernet/freescale/enetc/enetc_hw.h

509

high = ioread32(reg + 4);

drivers/net/ethernet/freescale/enetc/enetc_hw.h

510

low = ioread32(reg);

drivers/net/ethernet/freescale/enetc/enetc_hw.h

511

tmp = ioread32(reg + 4);

drivers/net/ethernet/freescale/xgmac_mdio.c

66

return ioread32(regs);

drivers/net/ethernet/intel/e100.c

930

if (ioread32(&nic->csr->mdi_ctrl) & mdi_ready)

drivers/net/ethernet/intel/e100.c

943

if ((data_out = ioread32(&nic->csr->mdi_ctrl)) & mdi_ready)

drivers/net/ethernet/micrel/ks8842.c

235

return ioread32(adapter->hw_addr + offset);

drivers/net/ethernet/micrel/ks8842.c

674

*data++ = ioread32(adapter->hw_addr +

drivers/net/ethernet/microchip/lan743x_main.c

127

return ioread32(&adapter->csr.csr_address[offset]);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_ethtool.c

195

*regs_buff++ = ioread32(&hw->reg->INT_ST + i);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

1235

rxdma = ioread32(&hw->reg->DMA_CTRL);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

1245

rxdma = ioread32(&hw->reg->DMA_CTRL);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

1267

int_st = ioread32(&hw->reg->INT_ST);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

1268

int_st = int_st & ioread32(&hw->reg->INT_EN);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

1280

int_en = ioread32(&hw->reg->INT_EN);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

1284

int_st |= ioread32(&hw->reg->INT_ST);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

1285

int_st = int_st & ioread32(&hw->reg->INT_EN);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

1299

int_en = ioread32(&hw->reg->INT_EN);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

1313

int_en = ioread32(&hw->reg->INT_EN);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

1322

IRQ_HANDLED, ioread32(&hw->reg->INT_EN));

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

2082

rctl = ioread32(&hw->reg->RX_MODE);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

2114

adrmask = ioread32(&hw->reg->ADDR_MASK);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

2125

ioread32(&hw->reg->RX_MODE), mc_count);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

2154

ioread32(&adapter->hw.reg->mac_adr[0].high),

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

2155

ioread32(&adapter->hw.reg->mac_adr[0].low));

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

278

adr1a = ioread32(&hw->reg->mac_adr[0].high);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

279

adr1b = ioread32(&hw->reg->mac_adr[0].low);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

302

if (readx_poll_timeout_atomic(ioread32, reg, tmp, !(tmp & bit), 0, 10))

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

327

adrmask = ioread32(&hw->reg->ADDR_MASK);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

360

rctl = ioread32(&hw->reg->MAC_RX_EN);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

368

rctl = ioread32(&hw->reg->MAC_RX_EN);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

409

rx_fctrl = ioread32(&hw->reg->RX_FCTRL);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

438

ioread32(&hw->reg->RX_FCTRL), mac->tx_fc_enable);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

453

wu_evt, ioread32(&hw->reg->ADDR_MASK));

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

457

addr_mask = ioread32(&hw->reg->ADDR_MASK);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

491

if (readx_poll_timeout_atomic(ioread32, &hw->reg->MIIM, data_out,

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

500

readx_poll_timeout_atomic(ioread32, &hw->reg->MIIM, data_out,

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

540

ioread32(&hw->reg->PAUSE_PKT1),

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

541

ioread32(&hw->reg->PAUSE_PKT2),

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

542

ioread32(&hw->reg->PAUSE_PKT3),

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

543

ioread32(&hw->reg->PAUSE_PKT4),

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

544

ioread32(&hw->reg->PAUSE_PKT5));

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

735

ioread32(&hw->reg->INT_ST);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

739

ioread32(&hw->reg->INT_EN));

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

752

ioread32(&hw->reg->INT_ST);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

754

ioread32(&hw->reg->INT_EN));

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

776

tcpip = ioread32(&hw->reg->TCPIP_ACC);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

803

dctrl = ioread32(&hw->reg->DMA_CTRL);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

822

tcpip = ioread32(&hw->reg->TCPIP_ACC);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

848

rxdma = ioread32(&hw->reg->DMA_CTRL);

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

854

ioread32(&hw->reg->MAC_RX_EN),

drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c

855

ioread32(&hw->reg->DMA_CTRL));

drivers/net/ethernet/packetengines/yellowfin.c

1233

ioread32(ioaddr + TxPtr) == (long)&yp->tx_ring[i] ? '>' : ' ',

drivers/net/ethernet/packetengines/yellowfin.c

1246

ioread32(ioaddr + RxPtr) == (long)&yp->rx_ring[i] ? '>' : ' ',

drivers/net/ethernet/packetengines/yellowfin.c

491

ioread32(ioaddr + ChipRev), ioaddr,

drivers/net/ethernet/packetengines/yellowfin.c

694

ioread32(ioaddr + TxStatus),

drivers/net/ethernet/packetengines/yellowfin.c

695

ioread32(ioaddr + RxStatus));

drivers/net/ethernet/pensando/ionic/ionic_dev.c

419

sig = ioread32(&idev->dev_info_regs->signature);

drivers/net/ethernet/pensando/ionic/ionic_dev.c

599

fw_hb = ioread32(&idev->dev_info_regs->fw_heartbeat);

drivers/net/ethernet/pensando/ionic/ionic_dev.c

639

return ioread32(&idev->dev_cmd_regs->done) & IONIC_DEV_CMD_DONE;

drivers/net/ethernet/pensando/ionic/ionic_phc.c

286

ioread32(&ionic->idev.hwstamp_regs->tick_low);

drivers/net/ethernet/pensando/ionic/ionic_phc.c

288

tick_high_before = ioread32(&ionic->idev.hwstamp_regs->tick_high);

drivers/net/ethernet/pensando/ionic/ionic_phc.c

291

tick_low = ioread32(&ionic->idev.hwstamp_regs->tick_low);

drivers/net/ethernet/pensando/ionic/ionic_phc.c

294

tick_high = ioread32(&ionic->idev.hwstamp_regs->tick_high);

drivers/net/ethernet/pensando/ionic/ionic_phc.c

301

tick_low = ioread32(&ionic->idev.hwstamp_regs->tick_low);

drivers/net/ethernet/pensando/ionic/ionic_regs.h

69

cred = ioread32(&intr_ctrl[intr_idx].credits);

drivers/net/ethernet/pensando/ionic/ionic_regs.h

81

cred = ioread32(&intr_ctrl[intr_idx].credits);

drivers/net/ethernet/realtek/8139too.c

665

#define RTL_W32_F(reg, val32) do { iowrite32 ((val32), ioaddr + (reg)); ioread32 (ioaddr + (reg)); } while (0)

drivers/net/ethernet/realtek/8139too.c

675

#define RTL_R32(reg) ioread32 (ioaddr + (reg))

drivers/net/ethernet/renesas/ravb.h

1147

return ioread32(priv->addr + reg);

drivers/net/ethernet/renesas/rcar_gen4_ptp.c

62

ts->tv_nsec = ioread32(ptp_priv->addr + PTPGPTPTM00_REG);

drivers/net/ethernet/renesas/rcar_gen4_ptp.c

63

ts->tv_sec = ioread32(ptp_priv->addr + PTPGPTPTM10_REG) |

drivers/net/ethernet/renesas/rcar_gen4_ptp.c

64

((s64)ioread32(ptp_priv->addr + PTPGPTPTM20_REG) << 32);

drivers/net/ethernet/renesas/rswitch_main.c

1088

if (ioread32(priv->addr + GWTSDIS) & GWCA_TS_IRQ_BIT) {

drivers/net/ethernet/renesas/rswitch_main.c

1131

u32 mrmac0 = ioread32(etha->addr + MRMAC0);

drivers/net/ethernet/renesas/rswitch_main.c

1132

u32 mrmac1 = ioread32(etha->addr + MRMAC1);

drivers/net/ethernet/renesas/rswitch_main.c

1172

pis = FIELD_GET(MPIC_PIS, ioread32(etha->addr + MPIC));

drivers/net/ethernet/renesas/rswitch_main.c

1187

lsc = FIELD_GET(MPIC_LSC, ioread32(etha->addr + MPIC));

drivers/net/ethernet/renesas/rswitch_main.c

1249

val = ioread32(etha->addr + MPSM);

drivers/net/ethernet/renesas/rswitch_main.c

221

dis[i] = ioread32(priv->addr + GWDIS(i));

drivers/net/ethernet/renesas/rswitch_main.c

222

dis[i] &= ioread32(priv->addr + GWDIE(i));

drivers/net/ethernet/renesas/rswitch_main.c

45

iowrite32((ioread32(addr + reg) & ~clear) | set, addr + reg);

drivers/net/ethernet/renesas/rswitch_main.c

68

u32 val = ioread32(coma_addr + RCEC);

drivers/net/ethernet/renesas/rswitch_main.c

82

val = ioread32(coma_addr + RCEC);

drivers/net/ethernet/renesas/rswitch_main.c

85

val = ioread32(coma_addr + RCDC);

drivers/net/ethernet/renesas/rswitch_main.c

94

val = ioread32(priv->addr + CABPIRM);

drivers/net/ethernet/renesas/rtsn.c

72

return ioread32(priv->base + reg);

drivers/net/ethernet/renesas/sh_eth.c

1184

pir = ioread32(bitbang->addr);

drivers/net/ethernet/renesas/sh_eth.c

1212

return (ioread32(bitbang->addr) & PIR_MDI) != 0;

drivers/net/ethernet/renesas/sh_eth.c

2205

*buf++ = ioread32(mdp->tsu_addr +

drivers/net/ethernet/renesas/sh_eth.c

2715

val = ioread32(mdp->tsu_addr + offset);

drivers/net/ethernet/renesas/sh_eth.c

2720

val = ioread32(mdp->tsu_addr + offset + 4);

drivers/net/ethernet/renesas/sh_eth.c

366

return ioread32(mdp->addr + offset);

drivers/net/ethernet/renesas/sh_eth.c

399

return ioread32(mdp->tsu_addr + offset);

drivers/net/ethernet/renesas/sh_eth.c

897

malr[i] = ioread32((void *)GIGA_MALR(i));

drivers/net/ethernet/renesas/sh_eth.c

898

mahr[i] = ioread32((void *)GIGA_MAHR(i));

drivers/net/ethernet/silan/sc92031.c

1130

phy_address = ioread32(port_base + Miicmd1) >> 27;

drivers/net/ethernet/silan/sc92031.c

1131

phy_ctrl = ioread32(port_base + PhyCtrl);

drivers/net/ethernet/silan/sc92031.c

1243

old_phy_ctrl = ioread32(port_base + PhyCtrl);

drivers/net/ethernet/silan/sc92031.c

1262

pm_config = ioread32(port_base + PMConfig);

drivers/net/ethernet/silan/sc92031.c

1290

pm_config = ioread32(port_base + PMConfig)

drivers/net/ethernet/silan/sc92031.c

1460

mac0 = ioread32(port_base + MAC0);

drivers/net/ethernet/silan/sc92031.c

1461

mac1 = ioread32(port_base + MAC0 + 4);

drivers/net/ethernet/silan/sc92031.c

311

ioread32(port_base + MAC0);

drivers/net/ethernet/silan/sc92031.c

320

mii_status = ioread32(port_base + Miistatus);

drivers/net/ethernet/silan/sc92031.c

556

phy_ctrl = ioread32(port_base + PhyCtrl);

drivers/net/ethernet/silan/sc92031.c

644

ioread32(port_base + IntrStatus);

drivers/net/ethernet/silan/sc92031.c

659

tx_status = ioread32(port_base + TxStatus0 + entry * 4);

drivers/net/ethernet/silan/sc92031.c

730

rx_ring_head = ioread32(port_base + RxBufWPtr);

drivers/net/ethernet/silan/sc92031.c

884

intr_status = ioread32(port_base + IntrStatus);

drivers/net/ethernet/silan/sc92031.c

918

temp = (ioread32(port_base + RxStatus0) >> 16) & 0xffff;

drivers/net/ethernet/sis/sis900.c

207

#define sr32(reg) ioread32(ioaddr + (reg))

drivers/net/ethernet/smsc/epic100.c

181

#define er32(reg) ioread32(ioaddr + (reg))

drivers/net/ethernet/smsc/smc91x.h

181

#define SMC_inl(a, r) ioread32((a) + (r))

drivers/net/ethernet/smsc/smsc9420.c

89

return ioread32(pd->ioaddr + offset);

drivers/net/ethernet/ti/davinci_emac.c

358

#define emac_read(reg) ioread32(priv->emac_base + (reg))

drivers/net/ethernet/ti/davinci_emac.c

361

#define emac_ctrl_read(reg) ioread32((priv->ctrl_base + (reg)))

drivers/net/ethernet/toshiba/tc35815.c

379

#define tc_readl(addr) ioread32(addr)

drivers/net/ethernet/via/via-rhine.c

483

#define DWORD_REG_BITS_ON(x, p) do { iowrite32((ioread32((p))|(x)), (p)); } while (0)

drivers/net/ethernet/via/via-rhine.c

487

#define DWORD_REG_BITS_IS_ON(x, p) (ioread32((p)) & (x))

drivers/net/ethernet/via/via-rhine.c

491

#define DWORD_REG_BITS_OFF(x, p) do { iowrite32(ioread32((p)) & (~(x)), (p)); } while (0)

drivers/net/ethernet/via/via-rhine.c

495

#define DWORD_REG_BITS_SET(x, m, p) do { iowrite32((ioread32((p)) & (~(m)))|(x), (p)); } while (0)

drivers/net/ethernet/xilinx/ll_temac_main.c

216

return ioread32(lp->sdma_regs + (reg << 2));

drivers/net/ethernet/xilinx/ll_temac_main.c

81

return ioread32(lp->regs + offset);

drivers/net/ethernet/xilinx/xilinx_axienet.h

654

return ioread32(lp->regs + offset);

drivers/net/ethernet/xilinx/xilinx_axienet_main.c

154

return ioread32(lp->dma_regs + reg);

drivers/net/ethernet/xilinx/xilinx_axienet_main.c

2975

if (ioread32(desc) == 0) { /* sanity check */

drivers/net/ethernet/xilinx/xilinx_axienet_main.c

2977

if (ioread32(desc) > 0) {

drivers/net/ethernet/xilinx/xilinx_emaclite.c

100

#define xemaclite_readl ioread32

drivers/net/fddi/skfp/h/types.h

30

#define inpd(p) ioread32(p)

drivers/net/ipa/gsi.c

1139

channel_mask = ioread32(gsi->virt + reg_offset(reg));

drivers/net/ipa/gsi.c

1160

event_mask = ioread32(gsi->virt + reg_offset(reg));

drivers/net/ipa/gsi.c

1223

val = ioread32(gsi->virt + offset);

drivers/net/ipa/gsi.c

1270

val = ioread32(gsi->virt + reg_offset(reg));

drivers/net/ipa/gsi.c

1299

val = ioread32(gsi->virt + reg_offset(reg));

drivers/net/ipa/gsi.c

1325

event_mask = ioread32(gsi->virt + reg_offset(reg));

drivers/net/ipa/gsi.c

1349

val = ioread32(gsi->virt + reg_offset(reg));

drivers/net/ipa/gsi.c

1377

while ((intr_mask = ioread32(gsi->virt + offset))) {

drivers/net/ipa/gsi.c

1620

index = gsi_ring_index(ring, ioread32(gsi->virt + offset));

drivers/net/ipa/gsi.c

1791

val = ioread32(gsi->virt + offset);

drivers/net/ipa/gsi.c

2029

val = ioread32(gsi->virt + reg_offset(reg));

drivers/net/ipa/gsi.c

2073

val = ioread32(gsi->virt + reg_offset(reg));

drivers/net/ipa/gsi.c

403

val = ioread32(gsi->virt + reg_n_offset(reg, evt_ring_id));

drivers/net/ipa/gsi.c

518

val = ioread32(virt + reg_n_offset(reg, channel_id));

drivers/net/ipa/gsi.c

917

val = ioread32(gsi->virt + offset);

drivers/net/ipa/ipa_endpoint.c

2023

val = ioread32(ipa->reg_virt + reg_offset(reg));

drivers/net/ipa/ipa_endpoint.c

467

val = ioread32(ipa->reg_virt + offset);

drivers/net/ipa/ipa_endpoint.c

505

val = ioread32(ipa->reg_virt + reg_n_offset(reg, unit));

drivers/net/ipa/ipa_interrupt.c

132

pending = ioread32(ipa->reg_virt + offset);

drivers/net/ipa/ipa_interrupt.c

141

pending = ioread32(ipa->reg_virt + offset);

drivers/net/ipa/ipa_interrupt.c

214

val = ioread32(ipa->reg_virt + offset);

drivers/net/ipa/ipa_interrupt.c

62

val = ioread32(ipa->reg_virt + reg_n_offset(reg, unit));

drivers/net/ipa/ipa_main.c

224

val = ioread32(ipa->reg_virt + offset);

drivers/net/ipa/ipa_main.c

271

val = ioread32(ipa->reg_virt + offset);

drivers/net/ipa/ipa_mem.c

333

val = ioread32(ipa->reg_virt + reg_offset(reg));

drivers/net/ipa/ipa_table.c

506

val = ioread32(endpoint->ipa->reg_virt + offset);

drivers/net/ipa/ipa_table.c

565

val = ioread32(ipa->reg_virt + offset);

drivers/net/mdio/mdio-aspeed.c

71

ioread32(ctx->base + ASPEED_MDIO_CTRL);

drivers/net/mdio/mdio-mux-mmioreg.c

80

x = ioread32(p);

drivers/net/mdio/mdio-xgene.c

132

return ioread32(pdata->diag_csr_addr + offset);

drivers/net/mdio/mdio-xgene.c

200

*val = ioread32(addr);

drivers/net/mdio/mdio-xgene.c

40

while (!(done = ioread32(cmd_done)) && wait--)

drivers/net/mdio/mdio-xgene.c

44

rd_data = ioread32(rd);

drivers/net/mdio/mdio-xgene.c

69

while (!(done = ioread32(cmd_done)) && wait--)

drivers/net/wireless/admtek/adm8211.h

11

#define ADM8211_CSR_READ(r) ioread32(&priv->map->r)

drivers/net/wireless/ath/ath10k/ahb.c

44

return ioread32(ar_ahb->mem + offset);

drivers/net/wireless/ath/ath10k/ahb.c

51

return ioread32(ar_ahb->gcc_mem + offset);

drivers/net/wireless/ath/ath10k/ahb.c

65

return ioread32(ar_ahb->tcsr_mem + offset);

drivers/net/wireless/ath/ath10k/pci.c

1592

base_addr = ioread32(ar_pci->mem + QCA99X0_PCIE_BAR0_START_REG);

drivers/net/wireless/ath/ath10k/pci.c

1597

*(u32 *)(buf + i) = ioread32(ar_pci->mem + QCA99X0_CPU_MEM_DATA_REG);

drivers/net/wireless/ath/ath10k/pci.c

1620

*(u32 *)(buf + i) = ioread32(ar_pci->mem + region->start + i);

drivers/net/wireless/ath/ath10k/pci.c

434

u32 val = ioread32(ar_pci->mem + PCIE_LOCAL_BASE_ADDRESS +

drivers/net/wireless/ath/ath10k/pci.c

672

val = ioread32(ar_pci->mem + offset);

drivers/net/wireless/ath/ath10k/snoc.c

488

val = ioread32(ar_snoc->mem + offset);

drivers/net/wireless/ath/ath11k/ahb.c

186

val = ioread32(ab->mem + window_start +

drivers/net/wireless/ath/ath11k/ahb.c

201

return ioread32(ab->mem + offset);

drivers/net/wireless/ath/ath11k/pci.c

121

val = ioread32(ab->mem + window_start +

drivers/net/wireless/ath/ath11k/pci.c

125

val = ioread32(ab->mem + window_start +

drivers/net/wireless/ath/ath11k/pci.c

188

ioread32(ab->mem + ATH11K_PCI_WINDOW_REG_ADDRESS);

drivers/net/wireless/ath/ath11k/pci.c

86

ioread32(ab->mem + ATH11K_PCI_WINDOW_REG_ADDRESS);

drivers/net/wireless/ath/ath11k/pcic.c

200

val = ioread32(ab->mem + offset);

drivers/net/wireless/ath/ath12k/ahb.c

127

return ioread32(ab->mem_ce + offset);

drivers/net/wireless/ath/ath12k/ahb.c

128

return ioread32(ab->mem + offset);

drivers/net/wireless/ath/ath12k/pci.c

1164

val = ioread32(ab->mem + offset);

drivers/net/wireless/ath/ath12k/pci.c

1177

val = ioread32(ab->mem +

drivers/net/wireless/ath/ath12k/pci.c

1180

val = ioread32(ab->mem + window_start +

drivers/net/wireless/ath/ath12k/pci.c

1185

val = ioread32(ab->mem + window_start +

drivers/net/wireless/ath/ath12k/pci.c

124

ioread32(ab->mem + ab_pci->window_reg_addr);

drivers/net/wireless/ath/ath12k/pci.c

177

ioread32(ab->mem + ab_pci->window_reg_addr);

drivers/net/wireless/ath/ath5k/ahb.c

138

reg = ioread32((void __iomem *) AR5K_AR2315_AHB_ARB_CTL);

drivers/net/wireless/ath/ath5k/ahb.c

143

reg = ioread32((void __iomem *) AR5K_AR2315_BYTESWAP);

drivers/net/wireless/ath/ath5k/ahb.c

149

reg = ioread32((void __iomem *) AR5K_AR5312_ENABLE);

drivers/net/wireless/ath/ath5k/ahb.c

202

reg = ioread32((void __iomem *) AR5K_AR2315_AHB_ARB_CTL);

drivers/net/wireless/ath/ath5k/ahb.c

207

reg = ioread32((void __iomem *) AR5K_AR5312_ENABLE);

drivers/net/wireless/ath/ath5k/ath5k.h

1664

return ioread32(ath5k_ahb_reg(ah, reg));

drivers/net/wireless/ath/ath5k/ath5k.h

1676

return ioread32(ah->iobase + reg);

drivers/net/wireless/ath/ath5k/reset.c

478

regval = ioread32(reg);

drivers/net/wireless/ath/ath5k/reset.c

480

regval = ioread32(reg);

drivers/net/wireless/ath/ath5k/reset.c

485

regval = ioread32(reg);

drivers/net/wireless/ath/ath9k/init.c

197

val = ioread32(sc->mem + reg_offset);

drivers/net/wireless/ath/ath9k/init.c

200

val = ioread32(sc->mem + reg_offset);

drivers/net/wireless/ath/ath9k/init.c

219

val = ioread32(sc->mem + reg_offset);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c

483

return (ioread32(address));

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c

549

return (ioread32(address));

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c

568

return (ioread32(addr));

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c

614

*dst32 = cpu_to_le32(ioread32(address));

drivers/net/wireless/intel/ipw2x00/ipw2100.c

329

*val = ioread32(priv->ioaddr + reg);

drivers/net/wireless/marvell/mwifiex/pcie.c

247

*data = ioread32(card->pci_mmap1 + reg);

drivers/net/wireless/marvell/mwl8k.c

1510

ioread32(priv->regs + MWL8K_HIU_INT_CODE);

drivers/net/wireless/marvell/mwl8k.c

2117

tx->timestamp = cpu_to_le32(ioread32(priv->regs +

drivers/net/wireless/marvell/mwl8k.c

3187

cca_cnt = ioread32(priv->regs + NOK_CCA_CNT_REG);

drivers/net/wireless/marvell/mwl8k.c

3191

rx_rdy = ioread32(priv->regs + BBU_RXRDY_CNT_REG);

drivers/net/wireless/marvell/mwl8k.c

3927

status = ioread32(priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);

drivers/net/wireless/marvell/mwl8k.c

4671

status = ioread32(priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);

drivers/net/wireless/marvell/mwl8k.c

5659

ioread32(priv->regs + BBU_RXRDY_CNT_REG);

drivers/net/wireless/marvell/mwl8k.c

5660

ioread32(priv->regs + NOK_CCA_CNT_REG);

drivers/net/wireless/marvell/mwl8k.c

5679

ioread32(priv->regs + BBU_RXRDY_CNT_REG);

drivers/net/wireless/marvell/mwl8k.c

5680

ioread32(priv->regs + NOK_CCA_CNT_REG);

drivers/net/wireless/marvell/mwl8k.c

629

int_code = ioread32(regs +

drivers/net/wireless/marvell/mwl8k.c

634

int_code = ioread32(regs + MWL8K_HIU_INT_CODE);

drivers/net/wireless/marvell/mwl8k.c

708

block_size = ioread32(priv->regs + MWL8K_HIU_SCRATCH);

drivers/net/wireless/marvell/mwl8k.c

794

ready_code = ioread32(priv->regs + MWL8K_HIU_INT_CODE);

drivers/net/wireless/realtek/rtl818x/rtl8180/rtl8180.h

165

return ioread32(addr);

drivers/net/wwan/iosm/iosm_ipc_mmio.c

155

return (enum ipc_mem_exec_stage)ioread32(ipc_mmio->base +

drivers/net/wwan/iosm/iosm_ipc_mmio.c

172

return (enum ipc_mem_device_ipc_state)ioread32(ipc_mmio->base +

drivers/net/wwan/iosm/iosm_ipc_mmio.c

181

return (enum rom_exit_code)ioread32(ipc_mmio->base +

drivers/net/wwan/iosm/iosm_ipc_mmio.c

224

return ioread32(ipc_mmio->base + ipc_mmio->offset.cp_version);

drivers/net/wwan/iosm/iosm_ipc_mmio.c

73

cp_cap = ioread32(ipc_mmio->base + ipc_mmio->offset.cp_capability);

drivers/net/wwan/t7xx/t7xx_cldma.c

100

val = ioread32(ao_base + REG_INFRA_RST2_CLR);

drivers/net/wwan/t7xx/t7xx_cldma.c

143

val = ioread32(reg);

drivers/net/wwan/t7xx/t7xx_cldma.c

152

ch_id = ioread32(hw_info->ap_pdn_base + REG_CLDMA_L2TISAR0);

drivers/net/wwan/t7xx/t7xx_cldma.c

156

ioread32(hw_info->ap_pdn_base + REG_CLDMA_L2TISAR0);

drivers/net/wwan/t7xx/t7xx_cldma.c

163

ch_id = ioread32(hw_info->ap_pdn_base + REG_CLDMA_L2RISAR0);

drivers/net/wwan/t7xx/t7xx_cldma.c

167

ioread32(hw_info->ap_pdn_base + REG_CLDMA_L2RISAR0);

drivers/net/wwan/t7xx/t7xx_cldma.c

178

val = ioread32(reg);

drivers/net/wwan/t7xx/t7xx_cldma.c

238

ul_cfg = ioread32(hw_info->ap_pdn_base + REG_CLDMA_UL_CFG);

drivers/net/wwan/t7xx/t7xx_cldma.c

239

dl_cfg = ioread32(hw_info->ap_ao_base + REG_CLDMA_DL_CFG);

drivers/net/wwan/t7xx/t7xx_cldma.c

32

val = ioread32(hw_info->ap_pdn_base + REG_CLDMA_IP_BUSY);

drivers/net/wwan/t7xx/t7xx_cldma.c

47

ul_cfg = ioread32(hw_info->ap_pdn_base + REG_CLDMA_UL_CFG);

drivers/net/wwan/t7xx/t7xx_cldma.c

89

val = ioread32(ao_base + REG_INFRA_RST2_SET);

drivers/net/wwan/t7xx/t7xx_cldma.c

92

val = ioread32(ao_base + REG_INFRA_RST4_SET);

drivers/net/wwan/t7xx/t7xx_cldma.c

97

val = ioread32(ao_base + REG_INFRA_RST4_CLR);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

1001

unsigned int value = ioread32(hw_info->pcie_base + DPMAIF_ULQ_STA0_n(q_num));

drivers/net/wwan/t7xx/t7xx_dpmaif.c

1041

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_DLQ_WR_IDX +

drivers/net/wwan/t7xx/t7xx_dpmaif.c

1080

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_BAT_RD_IDX);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

1088

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_BAT_WR_IDX);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

1117

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_FRGBAT_RD_IDX);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

1166

ioread32(hw_info->pcie_base + DPMAIF_UL_CHK_BUSY));

drivers/net/wwan/t7xx/t7xx_dpmaif.c

1196

ioread32(hw_info->pcie_base + DPMAIF_DL_CHK_BUSY));

drivers/net/wwan/t7xx/t7xx_dpmaif.c

1204

wr_idx = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_PIT_WR_IDX);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

1206

rd_idx = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_PIT_RD_IDX);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

1273

intr_status = ioread32(hw_info->pcie_base + DPMAIF_AP_L2TISAR0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

138

value = ioread32(hw_info->pcie_base + DPMAIF_AO_UL_AP_L2TIMR0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

177

ip_busy_sts = ioread32(hw_info->pcie_base + DPMAIF_AP_IP_BUSY);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

32

readx_poll_timeout_atomic(ioread32, addr, val, cond, delay_us, timeout_us)

drivers/net/wwan/t7xx/t7xx_dpmaif.c

350

rx_intr_status = ioread32(hw_info->pcie_base + DPMAIF_AP_APDL_L2TISAR0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

351

rx_intr_qdone = ioread32(hw_info->pcie_base + DPMAIF_AO_UL_APDL_L2TIMR0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

358

tx_intr_status = ioread32(hw_info->pcie_base + DPMAIF_AP_L2TISAR0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

359

tx_intr_qdone = ioread32(hw_info->pcie_base + DPMAIF_AO_UL_AP_L2TIMR0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

398

value = ioread32(hw_info->pcie_base + DPMAIF_AP_MEM_CLR);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

430

ap_port_mode = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_RDY_CHK_THRES);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

446

enable_bat_cache = ioread32(hw_info->pcie_base + DPMAIF_DL_BAT_INIT_CON1);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

450

enable_pit_burst = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_RDY_CHK_THRES);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

556

value = ioread32(hw_info->pcie_base + DPMAIF_DL_BAT_INIT_CON1);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

566

value = ioread32(hw_info->pcie_base + DPMAIF_DL_BAT_INIT_CON1);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

580

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_PKTINFO_CON0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

595

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_PKTINFO_CON2);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

605

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_PKTINFO_CON0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

616

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_PKTINFO_CON2);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

627

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_PKTINFO_CON2);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

637

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_RDY_CHK_THRES);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

647

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_RDY_CHK_THRES);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

656

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_RDY_CHK_FRG_THRES);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

666

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_RDY_CHK_FRG_THRES);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

677

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_RDY_CHK_FRG_THRES);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

691

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_RDY_CHK_THRES);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

701

value = ioread32(hw_info->pcie_base + DPMAIF_AO_DL_PIT_SEQ_END);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

718

value = ioread32(hw_info->pcie_base + DPMAIF_DL_DLQPIT_INIT_CON1);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

732

value = ioread32(hw_info->pcie_base + DPMAIF_DL_DLQPIT_INIT_CON3);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

74

value = ioread32(hw_info->pcie_base + DPMAIF_AO_UL_AP_L1TIMR0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

788

value = ioread32(hw_info->pcie_base + DPMAIF_DL_BAT_INIT_CON1);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

865

value = ioread32(hw_info->pcie_base + DPMAIF_UL_DRBSIZE_ADDRH_n(q_num));

drivers/net/wwan/t7xx/t7xx_dpmaif.c

883

value = ioread32(hw_info->pcie_base + DPMAIF_AO_UL_CHNL_ARB0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

898

value = ioread32(hw_info->pcie_base + DPMAIF_AO_UL_CHNL_ARB0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

932

ap_cfg = ioread32(hw_info->pcie_base + DPMAIF_AP_OVERWRITE_CFG);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

949

u32 dpmaif_dl_is_busy = ioread32(hw_info->pcie_base + DPMAIF_DL_CHK_BUSY);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

956

u32 ul_arb_en = ioread32(hw_info->pcie_base + DPMAIF_AO_UL_CHNL_ARB0);

drivers/net/wwan/t7xx/t7xx_dpmaif.c

968

u32 dpmaif_ul_is_busy = ioread32(hw_info->pcie_base + DPMAIF_UL_CHK_BUSY);

drivers/net/wwan/t7xx/t7xx_hif_cldma.c

553

l2_tx_int = ioread32(hw_info->ap_pdn_base + REG_CLDMA_L2TISAR0);

drivers/net/wwan/t7xx/t7xx_hif_cldma.c

554

l2_rx_int = ioread32(hw_info->ap_pdn_base + REG_CLDMA_L2RISAR0);

drivers/net/wwan/t7xx/t7xx_hif_cldma.c

555

l2_tx_int_msk = ioread32(hw_info->ap_pdn_base + REG_CLDMA_L2TIMR0);

drivers/net/wwan/t7xx/t7xx_hif_cldma.c

556

l2_rx_int_msk = ioread32(hw_info->ap_ao_base + REG_CLDMA_L2RIMR0);

drivers/net/wwan/t7xx/t7xx_hif_cldma.c

563

val = ioread32(hw_info->ap_pdn_base + REG_CLDMA_L3TISAR0);

drivers/net/wwan/t7xx/t7xx_hif_cldma.c

565

val = ioread32(hw_info->ap_pdn_base + REG_CLDMA_L3TISAR1);

drivers/net/wwan/t7xx/t7xx_hif_cldma.c

588

val = ioread32(hw_info->ap_pdn_base + REG_CLDMA_L3RISAR0);

drivers/net/wwan/t7xx/t7xx_hif_cldma.c

590

val = ioread32(hw_info->ap_pdn_base + REG_CLDMA_L3RISAR1);

drivers/net/wwan/t7xx/t7xx_mhccif.c

82

return ioread32(t7xx_dev->base_addr.mhccif_rc_base + REG_EP2RC_SW_INT_STS);

drivers/net/wwan/t7xx/t7xx_mhccif.c

97

return ioread32(t7xx_dev->base_addr.mhccif_rc_base + REG_EP2RC_SW_INT_EAP_MASK);

drivers/net/wwan/t7xx/t7xx_modem_ops.c

133

val = ioread32(reset_pcie_reg);

drivers/net/wwan/t7xx/t7xx_modem_ops.c

188

value = ioread32(IREG_BASE(t7xx_dev) + T7XX_PCIE_MISC_DEV_STATUS);

drivers/net/wwan/t7xx/t7xx_modem_ops.c

224

val = ioread32(IREG_BASE(t7xx_dev) + T7XX_PCIE_MISC_DEV_STATUS);

drivers/net/wwan/t7xx/t7xx_pci.c

200

value = ioread32(ctrl_reg);

drivers/net/wwan/t7xx/t7xx_pci.c

214

ret = read_poll_timeout(ioread32, val,

drivers/net/wwan/t7xx/t7xx_pci.c

357

status = ioread32(IREG_BASE(t7xx_dev) + T7XX_PCIE_RESOURCE_STATUS);

drivers/net/wwan/t7xx/t7xx_pci.c

583

prev_state = ioread32(IREG_BASE(t7xx_dev) + T7XX_PCIE_PM_RESUME_STATE);

drivers/net/wwan/t7xx/t7xx_pci.c

590

u32 atr_reg_val = ioread32(IREG_BASE(t7xx_dev) +

drivers/net/wwan/t7xx/t7xx_pcie_mac.c

182

value = ioread32(IREG_BASE(t7xx_dev) + ISTAT_HST_CTRL);

drivers/net/wwan/t7xx/t7xx_state_monitor.c

51

read_poll_timeout(ioread32, status, \

drivers/ntb/hw/idt/ntb_hw_idt.c

332

return ioread32(ndev->cfgspc + (ptrdiff_t)reg);

drivers/ntb/hw/idt/ntb_hw_idt.c

391

data = ioread32(ndev->cfgspc + (ptrdiff_t)IDT_NT_GASADATA);

drivers/ntb/hw/intel/ntb_hw_gen1.c

1010

ntb_cntl = ioread32(ndev->self_mmio + ndev->reg->ntb_ctl);

drivers/ntb/hw/intel/ntb_hw_gen1.c

1427

bar_addr = ioread32(mmio + XEON_SBAR4BASE_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

1433

bar_addr = ioread32(mmio + XEON_SBAR5BASE_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

1454

bar_addr = ioread32(mmio + XEON_SBAR4LMT_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

1460

bar_addr = ioread32(mmio + XEON_SBAR5LMT_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

1497

bar_addr = ioread32(mmio + XEON_PBAR4XLAT_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

1502

bar_addr = ioread32(mmio + XEON_PBAR5XLAT_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

1561

ntb_ctl = ioread32(ndev->self_mmio + ndev->reg->ntb_ctl);

drivers/ntb/hw/intel/ntb_hw_gen1.c

305

return ioread32(mmio + (idx << 2));

drivers/ntb/hw/intel/ntb_hw_gen1.c

620

u.v32 = ioread32(mmio + bar2_off(ndev->xlat_reg->bar2_xlat, 4));

drivers/ntb/hw/intel/ntb_hw_gen1.c

624

u.v32 = ioread32(mmio + bar2_off(ndev->xlat_reg->bar2_xlat, 5));

drivers/ntb/hw/intel/ntb_hw_gen1.c

638

u.v32 = ioread32(mmio + bar2_off(ndev->xlat_reg->bar2_limit, 4));

drivers/ntb/hw/intel/ntb_hw_gen1.c

641

u.v32 = ioread32(mmio + bar2_off(ndev->xlat_reg->bar2_limit, 5));

drivers/ntb/hw/intel/ntb_hw_gen1.c

660

u.v32 = ioread32(mmio + XEON_PBAR4XLAT_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

664

u.v32 = ioread32(mmio + XEON_PBAR5XLAT_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

680

u.v32 = ioread32(mmio + XEON_PBAR4LMT_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

684

u.v32 = ioread32(mmio + XEON_PBAR5LMT_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

707

u.v32 = ioread32(mmio + XEON_SBAR4BASE_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

710

u.v32 = ioread32(mmio + XEON_SBAR5BASE_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen1.c

915

base = ioread32(mmio + base_reg) & NTB_BAR_MASK_32;

drivers/ntb/hw/intel/ntb_hw_gen1.c

925

reg_val = ioread32(mmio + xlat_reg);

drivers/ntb/hw/intel/ntb_hw_gen1.c

933

reg_val = ioread32(mmio + limit_reg);

drivers/ntb/hw/intel/ntb_hw_gen1.c

986

ntb_ctl = ioread32(ndev->self_mmio + ndev->reg->ntb_ctl);

drivers/ntb/hw/intel/ntb_hw_gen3.c

438

ntb_ctl = ioread32(ndev->self_mmio + ndev->reg->ntb_ctl);

drivers/ntb/hw/intel/ntb_hw_gen4.c

207

ppd1 = ioread32(ndev->self_mmio + GEN4_PPD1_OFFSET);

drivers/ntb/hw/intel/ntb_hw_gen4.c

491

ppd0 = ioread32(ndev->self_mmio + get_ppd0(pdev));

drivers/ntb/hw/intel/ntb_hw_gen4.c

496

ppd0 = ioread32(ndev->self_mmio + get_ppd0(pdev));

drivers/ntb/hw/intel/ntb_hw_gen4.c

518

ntb_cntl = ioread32(ndev->self_mmio + ndev->reg->ntb_ctl);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

1035

ctl_val = ioread32(&ctl->bar_entry[bar].ctl);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

1051

bar_error = ioread32(&ctl->bar_error);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

1052

lut_error = ioread32(&ctl->lut_error);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

1070

proxy_id = ioread32(&sndev->mmio_self_ctrl->req_id_table[i]);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

1091

u32 pff = ioread32(&part_cfg->vep_pff_inst_id) & 0xFF;

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

1190

u32 r = ioread32(&ctrl->bar_entry[i].ctl);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

134

ps = ioread32(&ctl->partition_status) & 0xFFFF;

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

1422

event_irq = ioread32(&sndev->stdev->mmio_part_cfg->vep_vector_number);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

147

ioread32(&ctl->partition_status));

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

227

ctl_val = ioread32(&ctl->bar_entry[bar].ctl);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

250

ctl_val = ioread32(&ctl->bar_entry[bar].ctl);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

327

widx, ioread32(&ctl->bar_error));

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

425

u32 pff = ioread32(&part_cfg->vep_pff_inst_id) & 0xFF;

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

426

u32 linksta = ioread32(&stdev->mmio_pff_csr[pff].pci_cap_region[13]);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

773

return ioread32(&sndev->peer_shared->spad[sidx]);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

858

tpart_vec = ioread32(&sndev->mmio_ntb->ntp_info[self].target_part_high);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

860

tpart_vec |= ioread32(&sndev->mmio_ntb->ntp_info[self].target_part_low);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

924

ctl_val = ioread32(&ctl->bar_entry[peer_bar].ctl);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

939

bar_error = ioread32(&ctl->bar_error);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

940

lut_error = ioread32(&ctl->lut_error);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

974

proxy_id = ioread32(&mmio_ctrl->req_id_table[i]);

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

987

error = ioread32(&mmio_ctrl->req_id_error);

drivers/ntb/ntb_transport.c

1758

ioread32(&hdr->flags);

drivers/nvmem/s32g-ocotp-nvmem.c

26

*dst++ = ioread32(s32g_data->base + offset);

drivers/pci/controller/dwc/pci-layerscape-ep.c

59

return ioread32(pci->dbi_base + offset);

drivers/pci/controller/dwc/pci-layerscape.c

100

val = ioread32(pci->dbi_base + PCIE_STRFMR1);

drivers/pci/controller/dwc/pci-layerscape.c

118

return ioread32(pcie->pf_lut_base + off);

drivers/pci/controller/mobiveil/pcie-layerscape-gen4.c

47

return ioread32(pcie->pci.csr_axi_slave_base + PCIE_PF_OFF + off);

drivers/pci/controller/pci-rcar-gen2.c

137

u32 status = ioread32(priv->reg + RCAR_PCI_INT_STATUS_REG);

drivers/pci/controller/pci-rcar-gen2.c

164

val = ioread32(priv->reg + RCAR_PCI_INT_ENABLE_REG);

drivers/pci/controller/pci-rcar-gen2.c

198

val = ioread32(reg + RCAR_PCI_UNIT_REV_REG);

drivers/pci/controller/pci-rcar-gen2.c

202

val = ioread32(reg + RCAR_USBCTR_REG) & ~RCAR_USBCTR_DIRPD;

drivers/pci/controller/pci-rcar-gen2.c

237

val = ioread32(reg + RCAR_PCI_ARBITER_CTR_REG);

drivers/pci/controller/pci-rcar-gen2.c

260

val = ioread32(reg + PCI_COMMAND);

drivers/pci/quirks.c

3994

val = ioread32(mmio_base + PCH_PP_CONTROL) & 0xfffffffe;

drivers/pci/quirks.c

3999

val = ioread32(mmio_base + PCH_PP_STATUS);

drivers/pci/quirks.c

5906

partition_map = ioread32(&mmio_ntb->ep_map);

drivers/pci/quirks.c

5907

partition_map |= ((u64) ioread32(&mmio_ntb->ep_map + 4)) << 32;

drivers/pci/quirks.c

5939

rid_entry = ioread32(&mmio_peer_ctrl->req_id_table[te]);

drivers/pci/quirks.c

6118

if (ioread32(map + 0x2240c) & 0x2) {

drivers/pci/switch/switchtec.c

1026

hdr = ioread32(reg);

drivers/pci/switch/switchtec.c

1031

ctl->data[i] = ioread32(&reg[i + 1]);

drivers/pci/switch/switchtec.c

1133

reg = ioread32(&pcfg->usp_pff_inst_id);

drivers/pci/switch/switchtec.c

1139

reg = ioread32(&pcfg->vep_pff_inst_id) & 0xFF;

drivers/pci/switch/switchtec.c

1146

reg = ioread32(&pcfg->dsp_pff_inst_id[i]);

drivers/pci/switch/switchtec.c

1182

p.pff = ioread32(&pcfg->usp_pff_inst_id);

drivers/pci/switch/switchtec.c

1185

p.pff = ioread32(&pcfg->vep_pff_inst_id) & 0xFF;

drivers/pci/switch/switchtec.c

1192

p.pff = ioread32(&pcfg->dsp_pff_inst_id[p.port - 1]);

drivers/pci/switch/switchtec.c

1276

reg = ioread32(&stdev->mmio_pff_csr[idx].link_state_hdr);

drivers/pci/switch/switchtec.c

1400

hdr = ioread32(hdr_reg);

drivers/pci/switch/switchtec.c

1444

reg = ioread32(&stdev->mmio_part_cfg->mrpc_comp_hdr);

drivers/pci/switch/switchtec.c

1520

dma_mrpc_irq = ioread32(&stdev->mmio_mrpc->dma_vector);

drivers/pci/switch/switchtec.c

153

ioread32(&mmio_dbmsg->odb);

drivers/pci/switch/switchtec.c

1549

reg = ioread32(&pcfg->usp_pff_inst_id);

drivers/pci/switch/switchtec.c

1553

reg = ioread32(&pcfg->vep_pff_inst_id) & 0xFF;

drivers/pci/switch/switchtec.c

1558

reg = ioread32(&pcfg->dsp_pff_inst_id[i]);

drivers/pci/switch/switchtec.c

1629

if (ioread32(&stdev->mmio_mrpc->dma_ver) == 0)

drivers/pci/switch/switchtec.c

235

stuser->status = ioread32(&stdev->mmio_mrpc->status);

drivers/pci/switch/switchtec.c

250

stuser->return_code = ioread32(&stdev->mmio_mrpc->ret_value);

drivers/pci/switch/switchtec.c

313

status = ioread32(&stdev->mmio_mrpc->status);

drivers/pci/switch/switchtec.c

331

ver = ioread32(&stdev->mmio_sys_info->device_version);

drivers/pci/switch/switchtec.c

343

ver = ioread32(&stdev->mmio_sys_info->firmware_version);

drivers/pci/switch/switchtec.c

665

info.flash_length = ioread32(&fi->gen3.flash_length);

drivers/pci/switch/switchtec.c

668

info.flash_length = ioread32(&fi->gen4.flash_length);

drivers/pci/switch/switchtec.c

683

info->address = ioread32(&pi->address);

drivers/pci/switch/switchtec.c

684

info->length = ioread32(&pi->length);

drivers/pci/switch/switchtec.c

697

active_addr = ioread32(&fi->active_cfg);

drivers/pci/switch/switchtec.c

703

active_addr = ioread32(&fi->active_cfg);

drivers/pci/switch/switchtec.c

709

active_addr = ioread32(&fi->active_img);

drivers/pci/switch/switchtec.c

715

active_addr = ioread32(&fi->active_img);

drivers/pci/switch/switchtec.c

80

u32 device = ioread32(&stdev->mmio_sys_info->device_id);

drivers/pci/switch/switchtec.c

902

s->global = ioread32(&stdev->mmio_sw_event->global_summary);

drivers/pci/switch/switchtec.c

904

s->local_part = ioread32(&stdev->mmio_part_cfg->part_event_summary);

drivers/pci/switch/switchtec.c

907

reg = ioread32(&stdev->mmio_part_cfg_all[i].part_event_summary);

drivers/pci/switch/switchtec.c

912

reg = ioread32(&stdev->mmio_pff_csr[i].pff_event_summary);

drivers/phy/freescale/phy-fsl-lynx-28g.c

455

orig = ioread32(reg);

drivers/phy/freescale/phy-fsl-lynx-28g.c

462

ioread32((priv)->base + (off))

drivers/phy/freescale/phy-fsl-lynx-28g.c

468

ioread32((lane)->priv->base + reg((lane)->id))

drivers/phy/freescale/phy-fsl-lynx-28g.c

472

ioread32((pll)->priv->base + reg((pll)->id))

drivers/phy/renesas/r8a779f0-ether-serdes.c

56

return ioread32(addr + offs);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

249

return !(ioread32(acpi_use) & BIT(pin % 32));

drivers/pinctrl/intel/pinctrl-lynxpoint.c

257

value = ioread32(ioxapic_use);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

277

value = ioread32(reg);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

285

seq_printf(s, "0x%08x 0x%08x", value, ioread32(conf2));

drivers/pinctrl/intel/pinctrl-lynxpoint.c

312

value = ioread32(reg);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

328

iowrite32(ioread32(reg) & ~GPINDIS_BIT, reg);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

333

iowrite32(ioread32(reg) | GPINDIS_BIT, reg);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

351

value = ioread32(reg);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

386

value = ioread32(reg);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

425

value = ioread32(conf2);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

467

value = ioread32(conf2);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

511

return !!(ioread32(reg) & IN_LVL_BIT);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

522

iowrite32(ioread32(reg) | OUT_LVL_BIT, reg);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

524

iowrite32(ioread32(reg) & ~OUT_LVL_BIT, reg);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

546

if (ioread32(reg) & DIR_BIT)

drivers/pinctrl/intel/pinctrl-lynxpoint.c

570

pending = ioread32(reg) & ioread32(ena);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

609

iowrite32(ioread32(reg) | BIT(hwirq % 32), reg);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

620

iowrite32(ioread32(reg) & ~BIT(hwirq % 32), reg);

drivers/pinctrl/intel/pinctrl-lynxpoint.c

645

value = ioread32(reg);

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

110

val = ioread32(reg) | pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

121

val = ioread32(reg) & ~pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

134

ioread32(bank->base + NPCM7XX_GP_N_DIN),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

135

ioread32(bank->base + NPCM7XX_GP_N_DOUT),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

136

ioread32(bank->base + NPCM7XX_GP_N_IEM),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

137

ioread32(bank->base + NPCM7XX_GP_N_OE));

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

139

ioread32(bank->base + NPCM7XX_GP_N_PU),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

140

ioread32(bank->base + NPCM7XX_GP_N_PD),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

141

ioread32(bank->base + NPCM7XX_GP_N_DBNC),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

142

ioread32(bank->base + NPCM7XX_GP_N_POL));

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

1425

return ioread32(bank->base + NPCM7XX_GP_N_OSRC)

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

144

ioread32(bank->base + NPCM7XX_GP_N_EVTYP),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

145

ioread32(bank->base + NPCM7XX_GP_N_EVBE),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

146

ioread32(bank->base + NPCM7XX_GP_N_EVEN),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

147

ioread32(bank->base + NPCM7XX_GP_N_EVST));

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

149

ioread32(bank->base + NPCM7XX_GP_N_OTYP),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

1491

val = ioread32(bank->base + NPCM7XX_GP_N_ODSC)

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

150

ioread32(bank->base + NPCM7XX_GP_N_OSRC),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

151

ioread32(bank->base + NPCM7XX_GP_N_ODSC));

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

153

ioread32(bank->base + NPCM7XX_GP_N_OBL0),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

154

ioread32(bank->base + NPCM7XX_GP_N_OBL1),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

155

ioread32(bank->base + NPCM7XX_GP_N_OBL2),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

156

ioread32(bank->base + NPCM7XX_GP_N_OBL3));

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

158

ioread32(bank->base + NPCM7XX_GP_N_SPLCK),

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

159

ioread32(bank->base + NPCM7XX_GP_N_MPLCK));

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

1694

pu = ioread32(bank->base + NPCM7XX_GP_N_PU) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

1695

pd = ioread32(bank->base + NPCM7XX_GP_N_PD) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

1705

ie = ioread32(bank->base + NPCM7XX_GP_N_IEM) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

1706

oe = ioread32(bank->base + NPCM7XX_GP_N_OE) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

1713

rc = !(ioread32(bank->base + NPCM7XX_GP_N_OTYP) & pinmask);

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

1716

rc = ioread32(bank->base + NPCM7XX_GP_N_OTYP) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

1719

rc = ioread32(bank->base + NPCM7XX_GP_N_DBNC) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

216

sts = ioread32(bank->base + NPCM7XX_GP_N_EVST);

drivers/pinctrl/nuvoton/pinctrl-npcm7xx.c

217

en = ioread32(bank->base + NPCM7XX_GP_N_EVEN);

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

124

iowrite32(ioread32(reg) | pinmask, reg);

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

132

iowrite32(ioread32(reg) & ~pinmask, reg);

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

140

ioread32(bank->base + NPCM8XX_GP_N_DIN),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

141

ioread32(bank->base + NPCM8XX_GP_N_DOUT),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

142

ioread32(bank->base + NPCM8XX_GP_N_IEM),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

143

ioread32(bank->base + NPCM8XX_GP_N_OE));

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

145

ioread32(bank->base + NPCM8XX_GP_N_PU),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

146

ioread32(bank->base + NPCM8XX_GP_N_PD),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

147

ioread32(bank->base + NPCM8XX_GP_N_DBNC),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

148

ioread32(bank->base + NPCM8XX_GP_N_POL));

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

150

ioread32(bank->base + NPCM8XX_GP_N_EVTYP),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

151

ioread32(bank->base + NPCM8XX_GP_N_EVBE),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

152

ioread32(bank->base + NPCM8XX_GP_N_EVEN),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

153

ioread32(bank->base + NPCM8XX_GP_N_EVST));

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

155

ioread32(bank->base + NPCM8XX_GP_N_OTYP),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

156

ioread32(bank->base + NPCM8XX_GP_N_OSRC),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

157

ioread32(bank->base + NPCM8XX_GP_N_ODSC));

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

159

ioread32(bank->base + NPCM8XX_GP_N_OBL0),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

160

ioread32(bank->base + NPCM8XX_GP_N_OBL1),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

161

ioread32(bank->base + NPCM8XX_GP_N_OBL2),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

162

ioread32(bank->base + NPCM8XX_GP_N_OBL3));

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

164

ioread32(bank->base + NPCM8XX_GP_N_SPLCK),

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

165

ioread32(bank->base + NPCM8XX_GP_N_MPLCK));

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

1847

return ioread32(bank->base + NPCM8XX_GP_N_OSRC) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

1911

val = ioread32(bank->base + NPCM8XX_GP_N_ODSC) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

217

sts = ioread32(bank->base + NPCM8XX_GP_N_EVST);

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

218

en = ioread32(bank->base + NPCM8XX_GP_N_EVEN);

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

2181

pu = ioread32(bank->base + NPCM8XX_GP_N_PU) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

2182

pd = ioread32(bank->base + NPCM8XX_GP_N_PD) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

2192

ie = ioread32(bank->base + NPCM8XX_GP_N_IEM) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

2193

oe = ioread32(bank->base + NPCM8XX_GP_N_OE) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

2200

rc = !(ioread32(bank->base + NPCM8XX_GP_N_OTYP) & pinmask);

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

2203

rc = ioread32(bank->base + NPCM8XX_GP_N_OTYP) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-npcm8xx.c

2206

rc = ioread32(bank->base + NPCM8XX_GP_N_DBNC) & pinmask;

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c

157

even = ioread32(pctrl->gpio_base + WPCM450_GPEVEN);

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c

181

even = ioread32(pctrl->gpio_base + WPCM450_GPEVEN);

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c

202

level = !!(ioread32(reg) & BIT(offset));

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c

231

evpol = ioread32(pctrl->gpio_base + WPCM450_GPEVPOL);

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c

256

evtype = ioread32(pctrl->gpio_base + WPCM450_GPEVTYPE);

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c

257

evpol = ioread32(pctrl->gpio_base + WPCM450_GPEVPOL);

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c

321

pending = ioread32(pctrl->gpio_base + WPCM450_GPEVST);

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c

322

pending &= ioread32(pctrl->gpio_base + WPCM450_GPEVEN);

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c

935

reg = ioread32(pctrl->gpio_base + WPCM450_GPEVDBNC);

drivers/pinctrl/nuvoton/pinctrl-wpcm450.c

963

reg = ioread32(pctrl->gpio_base + WPCM450_GPEVDBNC);

drivers/pinctrl/pinctrl-tb10x.c

502

pcfg = ioread32(state->base) & ~(PCFG_PORT_MASK(port));

drivers/pinctrl/pinctrl-tb10x.c

511

return (ioread32(state->base) & PCFG_PORT_MASK(port))

drivers/pinctrl/qcom/pinctrl-lpass-lpi.c

228

sval = ioread32(reg);

drivers/pinctrl/qcom/pinctrl-lpass-lpi.c

51

return ioread32(state->tlmm_base + pin_offset + addr);

drivers/pinctrl/renesas/core.c

147

return ioread32(mapped_reg);

drivers/pinctrl/renesas/pfc-sh73a0.c

4034

value = ioread32(addr);

drivers/pinctrl/renesas/pfc-sh73a0.c

4066

value = ioread32(addr);

drivers/platform/x86/amd/hsmp/acpi.c

52

*value = ioread32(sock->virt_base_addr + offset);

drivers/platform/x86/amd/pmc/pmc.c

325

entry_time = ioread32(dev->fch_virt_addr + FCH_S0I3_ENTRY_TIME_H_OFFSET);

drivers/platform/x86/amd/pmc/pmc.c

326

entry_time = entry_time << 32 | ioread32(dev->fch_virt_addr + FCH_S0I3_ENTRY_TIME_L_OFFSET);

drivers/platform/x86/amd/pmc/pmc.c

328

exit_time = ioread32(dev->fch_virt_addr + FCH_S0I3_EXIT_TIME_H_OFFSET);

drivers/platform/x86/amd/pmc/pmc.c

329

exit_time = exit_time << 32 | ioread32(dev->fch_virt_addr + FCH_S0I3_EXIT_TIME_L_OFFSET);

drivers/platform/x86/amd/pmc/pmc.c

461

rc = readx_poll_timeout(ioread32, dev->regbase + response,

drivers/platform/x86/amd/pmc/pmc.c

479

rc = readx_poll_timeout(ioread32, dev->regbase + response,

drivers/platform/x86/amd/pmc/pmc.c

96

return ioread32(dev->regbase + reg_offset);

drivers/platform/x86/amd/pmf/core.c

167

return ioread32(dev->regbase + reg_offset);

drivers/platform/x86/amd/pmf/core.c

211

rc = readx_poll_timeout(ioread32, dev->regbase + AMD_PMF_REGISTER_RESPONSE,

drivers/platform/x86/amd/pmf/core.c

229

rc = readx_poll_timeout(ioread32, dev->regbase + AMD_PMF_REGISTER_RESPONSE,

drivers/platform/x86/ibm_rtl.c

116

cmd_port_val = ioread32(&rtl_table->cmd_port_value);

drivers/platform/x86/ibm_rtl.c

288

addr = ioread32(&rtl_table->cmd_port_address);

drivers/pmdomain/renesas/rcar-gen4-sysc.c

130

iowrite32(ioread32(rcar_gen4_sysc_base + SYSCIER(reg_idx)) | isr_mask,

drivers/pmdomain/renesas/rcar-gen4-sysc.c

132

iowrite32(ioread32(rcar_gen4_sysc_base + SYSCIMR(reg_idx)) | isr_mask,

drivers/pmdomain/renesas/rcar-gen4-sysc.c

145

status = ioread32(rcar_gen4_sysc_base + PDRESR(pdr));

drivers/pmdomain/renesas/rcar-gen4-sysc.c

175

pdr, ioread32(rcar_gen4_sysc_base + SYSCISCR(reg_idx)), ret);

drivers/pmdomain/renesas/rcar-gen4-sysc.c

183

st = ioread32(rcar_gen4_sysc_base + PDRSR(pdr));

drivers/pmdomain/renesas/rcar-sysc.c

125

iowrite32(ioread32(rcar_sysc_base + SYSCIMR) | isr_mask,

drivers/pmdomain/renesas/rcar-sysc.c

127

iowrite32(ioread32(rcar_sysc_base + SYSCIER) | isr_mask,

drivers/pmdomain/renesas/rcar-sysc.c

138

status = ioread32(rcar_sysc_base + pd->chan_offs + PWRER_OFFS);

drivers/pmdomain/renesas/rcar-sysc.c

166

pd->isr_bit, ioread32(rcar_sysc_base + SYSCISR), ret);

drivers/pmdomain/renesas/rcar-sysc.c

174

st = ioread32(rcar_sysc_base + pd->chan_offs + PWRSR_OFFS);

drivers/ptp/ptp_ocp.c

1225

ctrl = ioread32(&bp->reg->ctrl);

drivers/ptp/ptp_ocp.c

1237

time_ns = ioread32(&bp->reg->time_ns);

drivers/ptp/ptp_ocp.c

1238

time_sec = ioread32(&bp->reg->time_sec);

drivers/ptp/ptp_ocp.c

1270

select = ioread32(&bp->reg->select);

drivers/ptp/ptp_ocp.c

1301

select = ioread32(&bp->reg->select);

drivers/ptp/ptp_ocp.c

1498

select = ioread32(&bp->reg->select);

drivers/ptp/ptp_ocp.c

1536

status = ioread32(&bp->pps_to_clk->status);

drivers/ptp/ptp_ocp.c

1555

status = ioread32(&bp->tod->utc_status);

drivers/ptp/ptp_ocp.c

1573

ctrl = ioread32(&bp->reg->ctrl);

drivers/ptp/ptp_ocp.c

1580

ctrl = ioread32(&bp->reg->ctrl);

drivers/ptp/ptp_ocp.c

1608

if ((ioread32(&bp->reg->ctrl) & OCP_CTRL_ENABLE) == 0) {

drivers/ptp/ptp_ocp.c

1615

bp->sync = ioread32(&bp->reg->status) & OCP_STATUS_IN_SYNC;

drivers/ptp/ptp_ocp.c

1635

ctrl = ioread32(&bp->tod->ctrl);

drivers/ptp/ptp_ocp.c

1640

reg = ioread32(&bp->tod->utc_status);

drivers/ptp/ptp_ocp.c

2040

enable = ioread32(&reg->enable);

drivers/ptp/ptp_ocp.c

2041

status = ioread32(&reg->status);

drivers/ptp/ptp_ocp.c

2179

sec = ioread32(&reg->time_sec);

drivers/ptp/ptp_ocp.c

2180

nsec = ioread32(&reg->time_ns);

drivers/ptp/ptp_ocp.c

2346

val = ioread32(&reg->polarity);

drivers/ptp/ptp_ocp.c

2403

ctrl = ioread32(reg);

drivers/ptp/ptp_ocp.c

2469

return (ioread32(gpio) >> shift) & 0xffff;

drivers/ptp/ptp_ocp.c

2486

reg = ioread32(gpio);

drivers/ptp/ptp_ocp.c

2512

reg = ioread32(gpio);

drivers/ptp/ptp_ocp.c

2563

reg = ioread32(&bp->sma_map2->gpio2);

drivers/ptp/ptp_ocp.c

2568

reg = ioread32(&bp->sma_map1->gpio1);

drivers/ptp/ptp_ocp.c

2572

reg = ioread32(&bp->sma_map1->gpio2);

drivers/ptp/ptp_ocp.c

2600

reg = ioread32(gpio);

drivers/ptp/ptp_ocp.c

2624

reg = ioread32(gpio);

drivers/ptp/ptp_ocp.c

2669

version = ioread32(&bp->image->version);

drivers/ptp/ptp_ocp.c

2703

bp->fw_version = ioread32(&bp->image->version);

drivers/ptp/ptp_ocp.c

2793

reg = ioread32(&bp->art_sma->map[i].gpio);

drivers/ptp/ptp_ocp.c

2821

return ioread32(&bp->art_sma->map[sma_nr - 1].gpio) & 0xff;

drivers/ptp/ptp_ocp.c

2840

reg = ioread32(gpio);

drivers/ptp/ptp_ocp.c

2869

bp->fw_version = ioread32(&bp->reg->version);

drivers/ptp/ptp_ocp.c

2903

version = ioread32(&bp->image->version);

drivers/ptp/ptp_ocp.c

3391

val = ioread32(&bp->freq_in[idx]->ctrl);

drivers/ptp/ptp_ocp.c

3412

val = ioread32(&bp->freq_in[idx]->status);

drivers/ptp/ptp_ocp.c

3569

val = ioread32(&bp->irig_out->ctrl);

drivers/ptp/ptp_ocp.c

3610

select = ioread32(&bp->reg->select);

drivers/ptp/ptp_ocp.c

3652

val = ioread32(&bp->reg->status_drift);

drivers/ptp/ptp_ocp.c

3667

val = ioread32(&bp->reg->status_offset);

drivers/ptp/ptp_ocp.c

3682

val = ioread32(&bp->tod->adj_sec);

drivers/ptp/ptp_ocp.c

4035

val = ioread32(&reg->enable);

drivers/ptp/ptp_ocp.c

4037

val = ioread32(&reg->status);

drivers/ptp/ptp_ocp.c

4055

val = ioread32(&reg->ctrl);

drivers/ptp/ptp_ocp.c

4063

val = ioread32(&reg->status);

drivers/ptp/ptp_ocp.c

4104

reg = ioread32(&bp->sma_map1->gpio1);

drivers/ptp/ptp_ocp.c

4108

reg = ioread32(&bp->sma_map1->gpio2);

drivers/ptp/ptp_ocp.c

4112

reg = ioread32(&bp->sma_map2->gpio1);

drivers/ptp/ptp_ocp.c

4116

reg = ioread32(&bp->sma_map2->gpio2);

drivers/ptp/ptp_ocp.c

4139

on = ioread32(&ts_reg->enable);

drivers/ptp/ptp_ocp.c

4147

on = ioread32(&ts_reg->enable);

drivers/ptp/ptp_ocp.c

4155

on = ioread32(&ts_reg->enable);

drivers/ptp/ptp_ocp.c

4163

on = ioread32(&ts_reg->enable);

drivers/ptp/ptp_ocp.c

4171

on = ioread32(&ts_reg->enable);

drivers/ptp/ptp_ocp.c

4180

on = ioread32(&ts_reg->enable);

drivers/ptp/ptp_ocp.c

4199

ctrl = ioread32(&bp->irig_out->ctrl);

drivers/ptp/ptp_ocp.c

4201

val = ioread32(&bp->irig_out->status);

drivers/ptp/ptp_ocp.c

4208

on = ioread32(&bp->irig_in->ctrl) & IRIG_S_CTRL_ENABLE;

drivers/ptp/ptp_ocp.c

4209

val = ioread32(&bp->irig_in->status);

drivers/ptp/ptp_ocp.c

4216

on = ioread32(&bp->dcf_out->ctrl) & DCF_M_CTRL_ENABLE;

drivers/ptp/ptp_ocp.c

4217

val = ioread32(&bp->dcf_out->status);

drivers/ptp/ptp_ocp.c

4224

on = ioread32(&bp->dcf_in->ctrl) & DCF_S_CTRL_ENABLE;

drivers/ptp/ptp_ocp.c

4225

val = ioread32(&bp->dcf_in->status);

drivers/ptp/ptp_ocp.c

4232

on = ioread32(&bp->nmea_out->ctrl) & 1;

drivers/ptp/ptp_ocp.c

4233

val = ioread32(&bp->nmea_out->status);

drivers/ptp/ptp_ocp.c

4240

val = ioread32(&bp->pps_select->gpio1);

drivers/ptp/ptp_ocp.c

4264

val = ioread32(&bp->reg->select);

drivers/ptp/ptp_ocp.c

4318

val = ioread32(&bp->tod->ctrl);

drivers/ptp/ptp_ocp.c

4332

val = ioread32(&bp->tod->version);

drivers/ptp/ptp_ocp.c

4336

val = ioread32(&bp->tod->status);

drivers/ptp/ptp_ocp.c

4339

val = ioread32(&bp->tod->adj_sec);

drivers/ptp/ptp_ocp.c

4344

val = ioread32(&bp->tod->utc_status);

drivers/ptp/ptp_ocp.c

4352

val = ioread32(&bp->tod->leap);

drivers/ptp/ptp_ocp.c

4497

version = ioread32(&bp->reg->version);

drivers/ptp/ptp_ocp.c

4498

select = ioread32(&bp->reg->select);

drivers/ptp/ptp_ocp.c

4534

reg = ioread32(&bp->nmea_out->uart_baud);

drivers/ptp/ptp_ocp.c

4606

idx = ioread32(&bp->pps_select->gpio1);

drivers/ptp/ptp_ocp.c

4722

sync = !!(ioread32(&bp->reg->status) & OCP_STATUS_IN_SYNC);

drivers/ptp/ptp_pch.c

143

val = ioread32(&chip->regs->ts_sel) | (PCH_ECS_ETH);

drivers/ptp/ptp_pch.c

165

val = ioread32(&chip->regs->control) | PCH_TSC_RESET;

drivers/ptp/ptp_pch.c

184

val = ioread32(&chip->regs->ch_event);

drivers/ptp/ptp_pch.c

203

val = ioread32(&chip->regs->src_uuid_lo);

drivers/ptp/ptp_pch.c

214

val = ioread32(&chip->regs->src_uuid_hi);

drivers/ptp/ptp_pch.c

302

val = ioread32(&regs->event);

drivers/rapidio/devices/tsi721.c

1074

while (ioread32(priv->regs + TSI721_ZONE_SEL) &

drivers/rapidio/devices/tsi721.c

1211

regval = ioread32(priv->regs + TSI721_IBWIN_LB(i));

drivers/rapidio/devices/tsi721.c

129

rd_count = ioread32(regs + TSI721_DMAC_DRDCNT);

drivers/rapidio/devices/tsi721.c

145

ioread32(regs + TSI721_DMAC_DWRCNT);

drivers/rapidio/devices/tsi721.c

149

while ((ch_stat = ioread32(regs + TSI721_DMAC_STS))

drivers/rapidio/devices/tsi721.c

1520

ioread32(regs + TSI721_DMAC_INT);

drivers/rapidio/devices/tsi721.c

1524

ioread32(regs + TSI721_DMAC_CTL);

drivers/rapidio/devices/tsi721.c

1540

ch_stat = ioread32(regs + TSI721_DMAC_STS);

drivers/rapidio/devices/tsi721.c

1575

rval = ioread32(priv->regs + TSI721_IBDMAC_INTE(ch));

drivers/rapidio/devices/tsi721.c

1586

rval = ioread32(priv->regs + TSI721_DEV_CHAN_INTE);

drivers/rapidio/devices/tsi721.c

1605

rval = ioread32(priv->regs + TSI721_IBDMAC_INTE(ch));

drivers/rapidio/devices/tsi721.c

1617

rval = ioread32(priv->regs + TSI721_DEV_CHAN_INTE);

drivers/rapidio/devices/tsi721.c

1636

rval = ioread32(priv->regs + TSI721_OBDMAC_INTE(ch));

drivers/rapidio/devices/tsi721.c

1647

rval = ioread32(priv->regs + TSI721_DEV_CHAN_INTE);

drivers/rapidio/devices/tsi721.c

1666

rval = ioread32(priv->regs + TSI721_OBDMAC_INTE(ch));

drivers/rapidio/devices/tsi721.c

1678

rval = ioread32(priv->regs + TSI721_DEV_CHAN_INTE);

drivers/rapidio/devices/tsi721.c

1747

ioread32(priv->regs + TSI721_OBDMAC_DWRCNT(mbox));

drivers/rapidio/devices/tsi721.c

1771

omsg_int = ioread32(priv->regs + TSI721_OBDMAC_INT(ch));

drivers/rapidio/devices/tsi721.c

1854

ioread32(priv->regs + TSI721_OBDMAC_STS(ch)));

drivers/rapidio/devices/tsi721.c

1860

ioread32(priv->regs + TSI721_OBDMAC_CTL(ch));

drivers/rapidio/devices/tsi721.c

1870

ioread32(priv->regs + TSI721_OBDMAC_DRDCNT(ch));

drivers/rapidio/devices/tsi721.c

1882

ch_inte = ioread32(priv->regs + TSI721_DEV_CHAN_INTE);

drivers/rapidio/devices/tsi721.c

192

swr_ptr = ioread32(regs + TSI721_DMAC_DSWP);

drivers/rapidio/devices/tsi721.c

2037

ioread32(priv->regs + TSI721_OBDMAC_DWRCNT(mbox));

drivers/rapidio/devices/tsi721.c

2150

imsg_int = ioread32(priv->regs + TSI721_IBDMAC_INT(ch));

drivers/rapidio/devices/tsi721.c

2174

ch_inte = ioread32(priv->regs + TSI721_DEV_CHAN_INTE);

drivers/rapidio/devices/tsi721.c

2342

ioread32(priv->regs + TSI721_IBDMAC_CTL(ch));

drivers/rapidio/devices/tsi721.c

2587

rval = ioread32(priv->regs + 0x100 + RIO_PORT_N_ERR_STS_CSR(0, 0));

drivers/rapidio/devices/tsi721.c

2589

rval = ioread32(priv->regs + 0x100 + RIO_PORT_N_CTL2_CSR(0, 0));

drivers/rapidio/devices/tsi721.c

2591

rval = ioread32(priv->regs + 0x100 + RIO_PORT_N_CTL_CSR(0, 0));

drivers/rapidio/devices/tsi721.c

265

pw_stat = ioread32(priv->regs + TSI721_RIO_PW_RX_STAT);

drivers/rapidio/devices/tsi721.c

268

pw_buf[0] = ioread32(priv->regs + TSI721_RIO_PW_RX_CAPT(0));

drivers/rapidio/devices/tsi721.c

269

pw_buf[1] = ioread32(priv->regs + TSI721_RIO_PW_RX_CAPT(1));

drivers/rapidio/devices/tsi721.c

270

pw_buf[2] = ioread32(priv->regs + TSI721_RIO_PW_RX_CAPT(2));

drivers/rapidio/devices/tsi721.c

271

pw_buf[3] = ioread32(priv->regs + TSI721_RIO_PW_RX_CAPT(3));

drivers/rapidio/devices/tsi721.c

2747

iowrite32(ioread32(priv->regs + TSI721_DEVCTL) |

drivers/rapidio/devices/tsi721.c

322

rval = ioread32(priv->regs + TSI721_RIO_EM_INT_ENABLE);

drivers/rapidio/devices/tsi721.c

381

regval = ioread32(priv->regs + TSI721_SR_CHINTE(IDB_QUEUE));

drivers/rapidio/devices/tsi721.c

411

wr_ptr = ioread32(priv->regs + TSI721_IDQ_WP(IDB_QUEUE)) % IDB_QSIZE;

drivers/rapidio/devices/tsi721.c

412

rd_ptr = ioread32(priv->regs + TSI721_IDQ_RP(IDB_QUEUE)) % IDB_QSIZE;

drivers/rapidio/devices/tsi721.c

441

wr_ptr = ioread32(priv->regs +

drivers/rapidio/devices/tsi721.c

449

regval = ioread32(priv->regs + TSI721_SR_CHINTE(IDB_QUEUE));

drivers/rapidio/devices/tsi721.c

454

wr_ptr = ioread32(priv->regs + TSI721_IDQ_WP(IDB_QUEUE)) % IDB_QSIZE;

drivers/rapidio/devices/tsi721.c

481

dev_int = ioread32(priv->regs + TSI721_DEV_INT);

drivers/rapidio/devices/tsi721.c

485

dev_ch_int = ioread32(priv->regs + TSI721_DEV_CHAN_INT);

drivers/rapidio/devices/tsi721.c

491

intval = ioread32(priv->regs +

drivers/rapidio/devices/tsi721.c

502

ioread32(priv->regs + TSI721_SR_CHINT(IDB_QUEUE));

drivers/rapidio/devices/tsi721.c

515

ch_inte = ioread32(priv->regs + TSI721_DEV_CHAN_INTE);

drivers/rapidio/devices/tsi721.c

531

ch_inte = ioread32(priv->regs + TSI721_DEV_CHAN_INTE);

drivers/rapidio/devices/tsi721.c

549

intval = ioread32(priv->regs + TSI721_RIO_EM_INT_STAT);

drivers/rapidio/devices/tsi721.c

612

ioread32(priv->regs + TSI721_DEV_INTE);

drivers/rapidio/devices/tsi721.c

66

*data = ioread32(priv->regs + offset);

drivers/rapidio/devices/tsi721.c

669

srio_int = ioread32(priv->regs + TSI721_RIO_EM_INT_STAT);

drivers/rapidio/devices/tsi721.c

693

sr_ch_int = ioread32(priv->regs + TSI721_SR_CHINT(IDB_QUEUE));

drivers/rapidio/devices/tsi721.c

700

sr_ch_int = ioread32(priv->regs + TSI721_SR_CHINT(IDB_QUEUE));

drivers/rapidio/devices/tsi721.c

997

while (ioread32(priv->regs + TSI721_ZONE_SEL) &

drivers/rapidio/devices/tsi721_dma.c

143

ioread32(bdma_chan->regs + TSI721_DMAC_INT);

drivers/rapidio/devices/tsi721_dma.c

198

ioread32(bdma_chan->regs + TSI721_DMAC_CTL);

drivers/rapidio/devices/tsi721_dma.c

217

ch_stat = ioread32(bdma_chan->regs + TSI721_DMAC_STS);

drivers/rapidio/devices/tsi721_dma.c

254

ioread32(bdma_chan->regs + TSI721_DMAC_INT);

drivers/rapidio/devices/tsi721_dma.c

272

sts = ioread32(bdma_chan->regs + TSI721_DMAC_STS);

drivers/rapidio/devices/tsi721_dma.c

327

ioread32(bdma_chan->regs + TSI721_DMAC_DWRCNT);

drivers/rapidio/devices/tsi721_dma.c

442

rd_idx = ioread32(bdma_chan->regs + TSI721_DMAC_DRDCNT);

drivers/rapidio/devices/tsi721_dma.c

576

dmac_int = ioread32(bdma_chan->regs + TSI721_DMAC_INT);

drivers/rapidio/devices/tsi721_dma.c

587

dmac_sts = ioread32(bdma_chan->regs + TSI721_DMAC_STS);

drivers/rapidio/devices/tsi721_dma.c

606

dmac_sts = ioread32(bdma_chan->regs + TSI721_DMAC_STS);

drivers/rapidio/devices/tsi721_dma.c

635

ioread32(bdma_chan->regs + TSI721_DMAC_INT);

drivers/rapidio/devices/tsi721_dma.c

916

dmac_int = ioread32(bdma_chan->regs + TSI721_DMAC_INT);

drivers/rtc/rtc-asm9260.c

120

isr = ioread32(priv->iobase + HW_CIIR);

drivers/rtc/rtc-asm9260.c

141

ctime0 = ioread32(priv->iobase + HW_CTIME0);

drivers/rtc/rtc-asm9260.c

142

ctime1 = ioread32(priv->iobase + HW_CTIME1);

drivers/rtc/rtc-asm9260.c

143

ctime2 = ioread32(priv->iobase + HW_CTIME2);

drivers/rtc/rtc-asm9260.c

145

if (ctime1 != ioread32(priv->iobase + HW_CTIME1)) {

drivers/rtc/rtc-asm9260.c

150

ctime0 = ioread32(priv->iobase + HW_CTIME0);

drivers/rtc/rtc-asm9260.c

151

ctime1 = ioread32(priv->iobase + HW_CTIME1);

drivers/rtc/rtc-asm9260.c

152

ctime2 = ioread32(priv->iobase + HW_CTIME2);

drivers/rtc/rtc-asm9260.c

195

alrm->time.tm_year = ioread32(priv->iobase + HW_ALYEAR);

drivers/rtc/rtc-asm9260.c

196

alrm->time.tm_mon = ioread32(priv->iobase + HW_ALMON);

drivers/rtc/rtc-asm9260.c

197

alrm->time.tm_mday = ioread32(priv->iobase + HW_ALDOM);

drivers/rtc/rtc-asm9260.c

198

alrm->time.tm_wday = ioread32(priv->iobase + HW_ALDOW);

drivers/rtc/rtc-asm9260.c

199

alrm->time.tm_yday = ioread32(priv->iobase + HW_ALDOY);

drivers/rtc/rtc-asm9260.c

200

alrm->time.tm_hour = ioread32(priv->iobase + HW_ALHOUR);

drivers/rtc/rtc-asm9260.c

201

alrm->time.tm_min = ioread32(priv->iobase + HW_ALMIN);

drivers/rtc/rtc-asm9260.c

202

alrm->time.tm_sec = ioread32(priv->iobase + HW_ALSEC);

drivers/rtc/rtc-asm9260.c

204

alrm->enabled = ioread32(priv->iobase + HW_AMR) ? 1 : 0;

drivers/rtc/rtc-asm9260.c

205

alrm->pending = ioread32(priv->iobase + HW_CIIR) ? 1 : 0;

drivers/rtc/rtc-asm9260.c

276

ccr = ioread32(priv->iobase + HW_CCR);

drivers/rtc/rtc-fsl-ftm-alarm.c

50

return ioread32(dev->base + reg);

drivers/scsi/53c700.h

495

ioread32(hostdata->base + reg);

drivers/scsi/be2iscsi/be_cmds.c

1608

sem = ioread32(phba->csr_va + SLIPORT_SEMAPHORE_OFFSET_BEx);

drivers/scsi/be2iscsi/be_cmds.c

603

ready = ioread32(db);

drivers/scsi/be2iscsi/be_main.c

4089

reg = ioread32(addr);

drivers/scsi/be2iscsi/be_main.c

4120

u32 reg = ioread32(addr);

drivers/scsi/be2iscsi/be_main.c

760

isr = ioread32(ctrl->csr + CEV_ISR0_OFFSET +

drivers/scsi/fnic/fnic_main.c

1036

if (!ioread32(&fnic->rq[i].ctrl->enable))

drivers/scsi/fnic/fnic_main.c

1082

if (ioread32(&fnic->rq[i].ctrl->enable))

drivers/scsi/fnic/fnic_main.c

389

error_status = ioread32(&fnic->wq[i].ctrl->error_status);

drivers/scsi/fnic/fnic_main.c

395

error_status = ioread32(&fnic->rq[i].ctrl->error_status);

drivers/scsi/fnic/fnic_main.c

401

error_status = ioread32(&fnic->hw_copy_wq[i].ctrl->error_status);

drivers/scsi/fnic/vnic_dev.c

107

u32 bar_offset = ioread32(&r->bar_offset);

drivers/scsi/fnic/vnic_dev.c

108

u32 count = ioread32(&r->count);

drivers/scsi/fnic/vnic_dev.c

266

status = ioread32(&devcmd->status);

drivers/scsi/fnic/vnic_dev.c

287

status = ioread32(&devcmd->status);

drivers/scsi/fnic/vnic_dev.c

324

posted = ioread32(&dc2c->wq_ctrl->posted_index);

drivers/scsi/fnic/vnic_dev.c

325

fetch_index = ioread32(&dc2c->wq_ctrl->fetch_index);

drivers/scsi/fnic/vnic_dev.c

436

fetch_index = ioread32(&vdev->devcmd2->wq.ctrl->fetch_index);

drivers/scsi/fnic/vnic_dev.c

93

if (ioread32(&rh->magic) != VNIC_RES_MAGIC ||

drivers/scsi/fnic/vnic_dev.c

94

ioread32(&rh->version) != VNIC_RES_VERSION) {

drivers/scsi/fnic/vnic_dev.c

98

ioread32(&rh->magic), ioread32(&rh->version));

drivers/scsi/fnic/vnic_intr.h

81

return ioread32(&intr->ctrl->int_credits);

drivers/scsi/fnic/vnic_intr.h

96

return ioread32(legacy_pba);

drivers/scsi/fnic/vnic_rq.c

116

fetch_index = ioread32(&rq->ctrl->fetch_index);

drivers/scsi/fnic/vnic_rq.c

127

return ioread32(&rq->ctrl->error_status);

drivers/scsi/fnic/vnic_rq.c

143

if (!(ioread32(&rq->ctrl->running)))

drivers/scsi/fnic/vnic_rq.c

159

WARN_ON(ioread32(&rq->ctrl->enable));

drivers/scsi/fnic/vnic_rq.c

172

fetch_index = ioread32(&rq->ctrl->fetch_index);

drivers/scsi/fnic/vnic_wq.c

184

return ioread32(&wq->ctrl->error_status);

drivers/scsi/fnic/vnic_wq.c

200

if (!(ioread32(&wq->ctrl->running)))

drivers/scsi/fnic/vnic_wq.c

215

BUG_ON(ioread32(&wq->ctrl->enable));

drivers/scsi/fnic/vnic_wq_copy.c

26

if (!(ioread32(&wq->ctrl->running)))

drivers/scsi/fnic/vnic_wq_copy.c

33

wq->index, ioread32(&wq->ctrl->fetch_index),

drivers/scsi/fnic/vnic_wq_copy.c

34

ioread32(&wq->ctrl->posted_index));

drivers/scsi/fnic/vnic_wq_copy.c

43

BUG_ON(ioread32(&wq->ctrl->enable));

drivers/scsi/mvumi.c

1100

tmp = ioread32(regs->arm_to_pciea_msg0);

drivers/scsi/mvumi.c

1174

tmp = ioread32(regs->enpointa_mask_reg);

drivers/scsi/mvumi.c

1244

tmp = ioread32(mhba->regs->arm_to_pciea_msg1);

drivers/scsi/mvumi.c

1256

tmp = ioread32(mhba->regs->arm_to_pciea_msg1);

drivers/scsi/mvumi.c

1281

tmp = ioread32(regs->arm_to_pciea_drbl_reg);

drivers/scsi/mvumi.c

1285

tmp = ioread32(regs->enpointa_mask_reg) | regs->int_dl_cpu2pciea;

drivers/scsi/mvumi.c

1903

mask = ioread32(regs->enpointa_mask_reg);

drivers/scsi/mvumi.c

1918

mask = ioread32(regs->enpointa_mask_reg);

drivers/scsi/mvumi.c

1930

status = ioread32(regs->main_int_cause_reg);

drivers/scsi/mvumi.c

1934

tmp = ioread32(regs->outb_isr_cause);

drivers/scsi/mvumi.c

1950

tmp = ioread32(regs->outb_isr_cause);

drivers/scsi/mvumi.c

1955

isr_status = ioread32(regs->arm_to_pciea_drbl_reg);

drivers/scsi/mvumi.c

1974

status = ioread32(mhba->regs->arm_to_pciea_drbl_reg);

drivers/scsi/mvumi.c

407

ib_rp_reg = ioread32(mhba->regs->inb_read_pointer);

drivers/scsi/mvumi.c

429

count = ioread32(mhba->ib_shadow);

drivers/scsi/mvumi.c

496

ob_write = ioread32(regs->outb_copy_pointer);

drivers/scsi/mvumi.c

497

ob_write_shadow = ioread32(mhba->ob_shadow);

drivers/scsi/mvumi.c

516

ob_write = ioread32(regs->outb_read_pointer);

drivers/scsi/mvumi.c

517

ob_write = ioread32(regs->outb_copy_pointer);

drivers/scsi/mvumi.c

586

if (ioread32(regs->arm_to_pciea_msg1) != HANDSHAKE_DONESTATE)

drivers/scsi/mvumi.c

613

tmp = ioread32(regs->arm_to_pciea_msg1);

drivers/scsi/mvumi.c

624

tmp = ioread32(regs->arm_to_pciea_msg1);

drivers/scsi/pmcraid.c

1945

ioread32(pinstance->int_regs.host_ioa_interrupt_reg);

drivers/scsi/pmcraid.c

1949

ioread32(pinstance->int_regs.host_ioa_interrupt_reg);

drivers/scsi/pmcraid.c

1950

int_reg = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);

drivers/scsi/pmcraid.c

1953

ioread32(pinstance->int_regs.host_ioa_interrupt_reg),

drivers/scsi/pmcraid.c

2101

if (ioread32(pinstance->ioa_status) &

drivers/scsi/pmcraid.c

3710

((ioread32(pinstance->int_regs.host_ioa_interrupt_reg)

drivers/scsi/pmcraid.c

3743

ioread32(pinstance->int_regs.host_ioa_interrupt_reg);

drivers/scsi/pmcraid.c

3799

intrs = ioread32(

drivers/scsi/pmcraid.c

3814

ioread32(

drivers/scsi/pmcraid.c

4075

ioread32(pinstance->int_regs.host_ioa_interrupt_reg);

drivers/scsi/pmcraid.c

413

ioread32(pinstance->int_regs.ioa_host_msix_interrupt_reg) :

drivers/scsi/pmcraid.c

414

ioread32(pinstance->int_regs.ioa_host_interrupt_reg);

drivers/scsi/pmcraid.c

431

u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);

drivers/scsi/pmcraid.c

436

ioread32(pinstance->int_regs.global_interrupt_mask_reg);

drivers/scsi/pmcraid.c

441

ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);

drivers/scsi/pmcraid.c

458

u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);

drivers/scsi/pmcraid.c

466

ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);

drivers/scsi/pmcraid.c

470

ioread32(pinstance->int_regs.global_interrupt_mask_reg),

drivers/scsi/pmcraid.c

471

ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg));

drivers/scsi/pmcraid.c

491

ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);

drivers/scsi/pmcraid.c

494

ioread32(pinstance->int_regs.ioa_host_interrupt_clr_reg);

drivers/scsi/pmcraid.c

522

mask = ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);

drivers/scsi/pmcraid.c

523

intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);

drivers/scsi/pmcraid.c

524

alerts = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);

drivers/scsi/pmcraid.c

585

doorbells = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);

drivers/scsi/pmcraid.c

586

intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);

drivers/scsi/pmcraid.c

606

u32 status = ioread32(pinstance->ioa_status);

drivers/scsi/pmcraid.c

667

ioread32(pinstance->int_regs.host_ioa_interrupt_reg);

drivers/scsi/snic/snic_res.c

274

err_status = ioread32(&snic->wq[i].ctrl->error_status);

drivers/scsi/snic/vnic_dev.c

103

u32 bar_offset = ioread32(&r->bar_offset);

drivers/scsi/snic/vnic_dev.c

104

u32 count = ioread32(&r->count);

drivers/scsi/snic/vnic_dev.c

258

fetch_idx = ioread32(&dc2c->wq_ctrl->fetch_index);

drivers/scsi/snic/vnic_dev.c

264

posted = ioread32(&dc2c->wq_ctrl->posted_index);

drivers/scsi/snic/vnic_dev.c

369

fetch_idx = ioread32(&dc2c->wq.ctrl->fetch_index);

drivers/scsi/snic/vnic_dev.c

89

if (ioread32(&rh->magic) != VNIC_RES_MAGIC ||

drivers/scsi/snic/vnic_dev.c

90

ioread32(&rh->version) != VNIC_RES_VERSION) {

drivers/scsi/snic/vnic_dev.c

93

ioread32(&rh->magic), ioread32(&rh->version));

drivers/scsi/snic/vnic_intr.h

70

return ioread32(&intr->ctrl->int_credits);

drivers/scsi/snic/vnic_wq.c

173

return ioread32(&wq->ctrl->error_status);

drivers/scsi/snic/vnic_wq.c

189

if (!(ioread32(&wq->ctrl->running)))

drivers/scsi/snic/vnic_wq.c

204

BUG_ON(ioread32(&wq->ctrl->enable));

drivers/scsi/sym53c8xx_2/sym_hipd.h

186

#define INL_OFF(np, o) ioread32(np->s.ioaddr + (o))

drivers/scsi/wd719x.c

57

return ioread32(wd->base + reg);

drivers/sh/clk/cpg.c

26

return ioread32(clk->mapped_reg);

drivers/sh/clk/cpg.c

39

return ioread32(mapped_status);

drivers/soc/fsl/guts.c

134

uid = ioread32(sfp_base + offset);

drivers/soc/fsl/guts.c

136

uid |= ioread32(sfp_base + offset + 4);

drivers/soc/fsl/guts.c

209

svr = ioread32(&regs->svr);

drivers/soc/fsl/rcpm.c

121

tmp |= ioread32(address);

drivers/soc/loongson/loongson2_guts.c

86

svr = ioread32(&guts->regs->svr);

drivers/soc/renesas/rcar-rst.c

148

saved_mode = ioread32(base + cfg->modemr);

drivers/spi/spi-ar934x.c

108

reg = ioread32(sp->base + AR934X_SPI_REG_CTRL);

drivers/spi/spi-ar934x.c

139

reg = ioread32(sp->base + AR934X_SPI_DATAIN);

drivers/spi/spi-ath79.c

51

return ioread32(sp->base + reg);

drivers/spi/spi-cadence-quadspi.c

811

unsigned int temp = ioread32(ahb_base);

drivers/spi/spi-davinci.c

240

u32 v = ioread32(addr);

drivers/spi/spi-davinci.c

248

u32 v = ioread32(addr);

drivers/spi/spi-davinci.c

570

buf = ioread32(dspi->base + SPIBUF);

drivers/spi/spi-davinci.c

577

status = ioread32(dspi->base + SPIFLG);

drivers/spi/spi-davinci.c

585

spidat1 = ioread32(dspi->base + SPIDAT1);

drivers/spi/spi-davinci.c

649

spidat1 = ioread32(dspi->base + SPIDAT1);

drivers/spi/spi-fsl-qspi.c

357

return ioread32(addr);

drivers/spi/spi-mt7621.c

72

return ioread32(rs->base + reg);

drivers/spi/spi-nxp-fspi.c

436

return ioread32(addr);

drivers/spi/spi-sh-hspi.c

53

return ioread32(hspi->addr + reg);

drivers/spi/spi-sh-msiof.c

73

return ioread32(p->mapbase + reg_offs);

drivers/spi/spi-sh.c

95

return ioread32(ss->addr + offset);

drivers/spi/spi-sifive.c

106

return ioread32(spi->regs + offset);

drivers/spi/spi-topcliff-pch.c

237

return ioread32(data->io_remap_addr + idx);

drivers/spi/spi-topcliff-pch.c

290

pkt_rx_buffer[rx_index++] = ioread32(spdrr);

drivers/spi/spi-topcliff-pch.c

297

reg_spcr_val = ioread32(io_remap_addr + PCH_SPCR);

drivers/spi/spi-topcliff-pch.c

355

reg_spsr_val = ioread32(spsr);

drivers/spi/spi-xilinx.c

103

return ioread32(addr);

drivers/ssb/pci.c

997

return ioread32(bus->mmio + offset);

drivers/staging/axis-fifo/axis-fifo.c

136

if (!ioread32(fifo->base_addr + XLLF_RDFO_OFFSET)) {

drivers/staging/axis-fifo/axis-fifo.c

144

ioread32(fifo->base_addr + XLLF_RDFO_OFFSET));

drivers/staging/axis-fifo/axis-fifo.c

149

bytes_available = ioread32(fifo->base_addr + XLLF_RLR_OFFSET);

drivers/staging/axis-fifo/axis-fifo.c

171

tmp_buf[i] = ioread32(fifo->base_addr +

drivers/staging/axis-fifo/axis-fifo.c

190

ioread32(fifo->base_addr + XLLF_RDFD_OFFSET);

drivers/staging/axis-fifo/axis-fifo.c

240

if (words_to_write > ioread32(fifo->base_addr +

drivers/staging/axis-fifo/axis-fifo.c

249

ioread32(fifo->base_addr + XLLF_TDFV_OFFSET) >= words_to_write);

drivers/staging/axis-fifo/axis-fifo.c

281

if (ioread32(fifo->base_addr + XLLF_RDFO_OFFSET))

drivers/staging/axis-fifo/axis-fifo.c

288

if (ioread32(fifo->base_addr + XLLF_TDFV_OFFSET))

drivers/staging/axis-fifo/axis-fifo.c

300

ier = ioread32(fifo->base_addr + XLLF_IER_OFFSET);

drivers/staging/axis-fifo/axis-fifo.c

301

isr = ioread32(fifo->base_addr + XLLF_ISR_OFFSET);

drivers/staging/axis-fifo/axis-fifo.c

369

u32 val = ioread32(fifo->base_addr + reg->offset);

drivers/staging/media/starfive/camss/stf-camss.h

102

iowrite32(ioread32(stfcamss->isp_base + reg) | mask,

drivers/staging/media/starfive/camss/stf-camss.h

108

return ioread32(stfcamss->syscon_base + reg);

drivers/staging/media/starfive/camss/stf-camss.h

122

value = ioread32(stfcamss->syscon_base + reg);

drivers/staging/media/starfive/camss/stf-camss.h

131

value = ioread32(stfcamss->syscon_base + reg);

drivers/staging/media/starfive/camss/stf-camss.h

73

return ioread32(stfcamss->isp_base + reg);

drivers/staging/media/starfive/camss/stf-camss.h

94

value = ioread32(stfcamss->isp_base + reg) & ~mask;

drivers/staging/vme_user/vme_tsi148.c

1211

*(u32 *)(buf + done) = ioread32(addr + done);

drivers/staging/vme_user/vme_tsi148.c

2302

data = ioread32(tsi148_device->base + TSI148_PCFS_ID) & 0x0000FFFF;

drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c

85

*value = ioread32(((u8 __iomem *)pci_info->proc_priv->mmio_base +

drivers/thermal/intel/int340x_thermal/processor_thermal_device_pci.c

98

current_val = ioread32(((u8 __iomem *)pci_info->proc_priv->mmio_base +

drivers/thermal/renesas/rcar_gen3_thermal.c

118

return ioread32(tsc->base + reg);

drivers/thermal/renesas/rcar_thermal.c

145

return ioread32(common->base + reg);

drivers/thermal/renesas/rcar_thermal.c

163

val = ioread32(common->base + reg);

drivers/thermal/renesas/rcar_thermal.c

172

return ioread32(priv->base + reg);

drivers/thermal/renesas/rcar_thermal.c

188

val = ioread32(priv->base + reg);

drivers/thermal/renesas/rzg2l_thermal.c

67

return ioread32(priv->base + reg);

drivers/thunderbolt/icm.c

1504

val = ioread32(nhi->iobase + REG_FW_STS);

drivers/thunderbolt/icm.c

1714

val = ioread32(tb->nhi->iobase + REG_FW_STS);

drivers/thunderbolt/icm.c

1832

val = ioread32(nhi->iobase + REG_FW_STS);

drivers/thunderbolt/icm.c

1837

val = ioread32(nhi->iobase + REG_FW_STS);

drivers/thunderbolt/icm.c

1865

val = ioread32(nhi->iobase + REG_FW_STS);

drivers/thunderbolt/icm.c

379

val = ioread32(nhi->iobase + REG_FW_STS);

drivers/thunderbolt/nhi.c

117

misc = ioread32(ring->nhi->iobase + REG_DMA_MISC);

drivers/thunderbolt/nhi.c

1239

val = ioread32(nhi->iobase + REG_CAPS);

drivers/thunderbolt/nhi.c

1254

val = ioread32(nhi->iobase + REG_RESET);

drivers/thunderbolt/nhi.c

129

ivr = ioread32(ivr_base + step);

drivers/thunderbolt/nhi.c

136

old = ioread32(ring->nhi->iobase + reg);

drivers/thunderbolt/nhi.c

1365

nhi->hop_count = ioread32(nhi->iobase + REG_CAPS) & 0x3ff;

drivers/thunderbolt/nhi.c

391

val = ioread32(ring->nhi->iobase + reg);

drivers/thunderbolt/nhi.c

67

val = ioread32(nhi->iobase + REG_RING_INTERRUPT_BASE + ring);

drivers/thunderbolt/nhi.c

77

ioread32(nhi->iobase + REG_RING_NOTIFY_BASE + ring);

drivers/thunderbolt/nhi.c

874

val = ioread32(nhi->iobase + REG_INMAIL_CMD);

drivers/thunderbolt/nhi.c

881

val = ioread32(nhi->iobase + REG_INMAIL_CMD);

drivers/thunderbolt/nhi.c

908

val = ioread32(nhi->iobase + REG_OUTMAIL_CMD);

drivers/thunderbolt/nhi.c

933

value = ioread32(nhi->iobase

drivers/tty/serial/8250/8250_pci.c

1111

deviceID = ioread32(p);

drivers/tty/serial/men_z135_uart.c

145

reg = ioread32(port->membase + addr);

drivers/tty/serial/men_z135_uart.c

167

reg = ioread32(port->membase + addr);

drivers/tty/serial/men_z135_uart.c

228

stat_reg = ioread32(port->membase + MEN_Z135_STAT_REG);

drivers/tty/serial/men_z135_uart.c

317

wptr = ioread32(port->membase + MEN_Z135_TX_CTRL);

drivers/tty/serial/men_z135_uart.c

383

uart->stat_reg = ioread32(port->membase + MEN_Z135_STAT_REG);

drivers/tty/serial/men_z135_uart.c

453

wptr = ioread32(port->membase + MEN_Z135_TX_CTRL);

drivers/tty/serial/men_z135_uart.c

475

conf_reg = old = ioread32(port->membase + MEN_Z135_CONF_REG);

drivers/tty/serial/men_z135_uart.c

611

conf_reg = ioread32(port->membase + MEN_Z135_CONF_REG);

drivers/tty/serial/men_z135_uart.c

650

conf_reg = ioread32(port->membase + MEN_Z135_CONF_REG);

drivers/tty/serial/men_z135_uart.c

699

uart_freq = ioread32(port->membase + MEN_Z135_UART_FREQ);

drivers/tty/serial/timbuart.c

100

while (!(ioread32(port->membase + TIMBUART_ISR) & TXBF) &&

drivers/tty/serial/timbuart.c

176

isr = ioread32(uart->port.membase + TIMBUART_ISR);

drivers/tty/serial/timbuart.c

348

uart->last_ier = ioread32(uart->port.membase + TIMBUART_IER);

drivers/tty/serial/timbuart.c

42

u32 ier = ioread32(port->membase + TIMBUART_IER) & ~RXFLAGS;

drivers/tty/serial/timbuart.c

49

u32 ier = ioread32(port->membase + TIMBUART_IER) & ~TXBAE;

drivers/tty/serial/timbuart.c

64

u32 isr = ioread32(port->membase + TIMBUART_ISR);

drivers/tty/serial/timbuart.c

84

while (ioread32(port->membase + TIMBUART_ISR) & RXDP) {

drivers/tty/serial/uartlite.c

105

return ioread32(addr);

drivers/uio/uio_fsl_elbc_gpcm.c

166

if ((ioread32(reg_int_en) & ioread32(reg_int_stat) &

drivers/uio/uio_fsl_elbc_gpcm.c

172

iowrite32(ioread32(reg_int_en) & ~DPM_HOST_INT_GLOBAL_EN, reg_int_en);

drivers/uio/uio_mf624.c

39

iowrite32(ioread32(INTCSR_reg)

drivers/uio/uio_mf624.c

45

iowrite32(ioread32(INTCSR_reg)

drivers/uio/uio_mf624.c

52

iowrite32(ioread32(INTCSR_reg)

drivers/uio/uio_mf624.c

67

iowrite32(ioread32(INTCSR_reg)

drivers/uio/uio_mf624.c

73

iowrite32(ioread32(INTCSR_reg)

drivers/uio/uio_mf624.c

80

iowrite32(ioread32(INTCSR_reg)

drivers/uio/uio_mf624.c

92

if ((ioread32(INTCSR_reg) & INTCSR_ADINT_ENABLE)

drivers/uio/uio_mf624.c

93

&& (ioread32(INTCSR_reg) & INTCSR_ADINT_STATUS)) {

drivers/uio/uio_mf624.c

98

if ((ioread32(INTCSR_reg) & INTCSR_CTR4INT_ENABLE)

drivers/uio/uio_mf624.c

99

&& (ioread32(INTCSR_reg) & INTCSR_CTR4INT_STATUS)) {

drivers/uio/uio_netx.c

40

if (!(ioread32(int_enable_reg) & ioread32(int_status_reg)

drivers/uio/uio_netx.c

45

iowrite32(ioread32(int_enable_reg) & ~DPM_HOST_INT_GLOBAL_EN,

drivers/uio/uio_sercos3.c

58

priv->ier0_cache |= ioread32(ier0);

drivers/uio/uio_sercos3.c

71

iowrite32(ioread32(ier0) | priv->ier0_cache, ier0);

drivers/uio/uio_sercos3.c

81

if (!(ioread32(isr0) & ioread32(ier0)))

drivers/usb/chipidea/ci.h

350

return ioread32(ci->hw_bank.abs + offset) & mask;

drivers/usb/chipidea/ci.h

364

data = (ioread32(ci->hw_bank.abs + offset) & ~mask)

drivers/usb/chipidea/ci.h

380

return ioread32(ci->hw_bank.regmap[reg]) & mask;

drivers/usb/chipidea/ci.h

414

data = (ioread32(ci->hw_bank.regmap[reg]) & ~mask)

drivers/usb/chipidea/ci.h

431

u32 val = ioread32(ci->hw_bank.regmap[reg]) & mask;

drivers/usb/chipidea/core.c

228

ci->hw_bank.op = ci->hw_bank.cap + (ioread32(ci->hw_bank.cap) & 0xff);

drivers/usb/dwc2/platform.c

388

snpsid = ioread32(hsotg->regs + GSNPSID);

drivers/usb/fotg210/fotg210-hcd.c

5537

value = ioread32(&fotg210->regs->otgcsr);

drivers/usb/fotg210/fotg210-udc.c

1027

value = ioread32(fotg210->reg + FOTG210_DMCR);

drivers/usb/fotg210/fotg210-udc.c

1032

value = ioread32(fotg210->reg + FOTG210_DMCR);

drivers/usb/fotg210/fotg210-udc.c

104

val = ioread32(fotg210->reg + FOTG210_EPMAP);

drivers/usb/fotg210/fotg210-udc.c

1057

value = ioread32(fotg210->reg + FOTG210_DMCR);

drivers/usb/fotg210/fotg210-udc.c

1071

value = ioread32(fotg210->reg + FOTG210_DMISGR0);

drivers/usb/fotg210/fotg210-udc.c

110

val = ioread32(fotg210->reg + FOTG210_FIFOMAP);

drivers/usb/fotg210/fotg210-udc.c

116

val = ioread32(fotg210->reg + FOTG210_FIFOCF);

drivers/usb/fotg210/fotg210-udc.c

126

val = ioread32(fotg210->reg + FOTG210_FIFOMAP);

drivers/usb/fotg210/fotg210-udc.c

136

val = ioread32(fotg210->reg + FOTG210_FIFOCF);

drivers/usb/fotg210/fotg210-udc.c

149

val = ioread32(fotg210->reg + offset);

drivers/usb/fotg210/fotg210-udc.c

199

value = ioread32(reg);

drivers/usb/fotg210/fotg210-udc.c

203

value = ioread32(reg);

drivers/usb/fotg210/fotg210-udc.c

272

value = ioread32(fotg210->reg + FOTG210_DMACPSR1);

drivers/usb/fotg210/fotg210-udc.c

278

value = ioread32(fotg210->reg + FOTG210_DMATFNR);

drivers/usb/fotg210/fotg210-udc.c

289

value = ioread32(fotg210->reg + FOTG210_DMISGR2);

drivers/usb/fotg210/fotg210-udc.c

294

value = ioread32(fotg210->reg + FOTG210_DMACPSR1);

drivers/usb/fotg210/fotg210-udc.c

309

value = ioread32(ep->fotg210->reg + FOTG210_DISGR2);

drivers/usb/fotg210/fotg210-udc.c

319

value = ioread32(ep->fotg210->reg + FOTG210_DMACPSR1);

drivers/usb/fotg210/fotg210-udc.c

325

value = ioread32(ep->fotg210->reg +

drivers/usb/fotg210/fotg210-udc.c

331

value = ioread32(ep->fotg210->reg + FOTG210_DCFESR);

drivers/usb/fotg210/fotg210-udc.c

34

u32 value = ioread32(fotg210->reg + offset);

drivers/usb/fotg210/fotg210-udc.c

351

length = ioread32(ep->fotg210->reg +

drivers/usb/fotg210/fotg210-udc.c

397

u32 value = ioread32(ep->fotg210->reg + FOTG210_DMISGR0);

drivers/usb/fotg210/fotg210-udc.c

42

u32 value = ioread32(ep->fotg210->reg + FOTG210_DMISGR1);

drivers/usb/fotg210/fotg210-udc.c

464

value = ioread32(fotg210->reg + FOTG210_DCFESR);

drivers/usb/fotg210/fotg210-udc.c

471

value = ioread32(reg);

drivers/usb/fotg210/fotg210-udc.c

485

value = ioread32(reg);

drivers/usb/fotg210/fotg210-udc.c

53

u32 value = ioread32(ep->fotg210->reg + FOTG210_DMISGR1);

drivers/usb/fotg210/fotg210-udc.c

551

u32 value = ioread32(fotg210->reg + FOTG210_TX0BYTE);

drivers/usb/fotg210/fotg210-udc.c

560

u32 value = ioread32(fotg210->reg + FOTG210_RX0BYTE);

drivers/usb/fotg210/fotg210-udc.c

579

data = ioread32(fotg210->reg + FOTG210_CXPORT);

drivers/usb/fotg210/fotg210-udc.c

589

data = ioread32(fotg210->reg + FOTG210_CXPORT);

drivers/usb/fotg210/fotg210-udc.c

593

data = ioread32(fotg210->reg + FOTG210_CXPORT);

drivers/usb/fotg210/fotg210-udc.c

598

data = ioread32(fotg210->reg + FOTG210_CXPORT);

drivers/usb/fotg210/fotg210-udc.c

612

u32 value = ioread32(fotg210->reg + FOTG210_DAR);

drivers/usb/fotg210/fotg210-udc.c

620

u32 value = ioread32(fotg210->reg + FOTG210_DAR);

drivers/usb/fotg210/fotg210-udc.c

628

u32 value = ioread32(fotg210->reg + FOTG210_DCFESR);

drivers/usb/fotg210/fotg210-udc.c

64

u32 value = ioread32(fotg210->reg + FOTG210_DCFESR);

drivers/usb/fotg210/fotg210-udc.c

716

value = ioread32(reg);

drivers/usb/fotg210/fotg210-udc.c

780

u32 value = ioread32(fotg210->reg + FOTG210_DMCR);

drivers/usb/fotg210/fotg210-udc.c

869

int disgr1 = ioread32(ep->fotg210->reg + FOTG210_DISGR1);

drivers/usb/fotg210/fotg210-udc.c

885

u32 int_grp = ioread32(fotg210->reg + FOTG210_DIGR);

drivers/usb/fotg210/fotg210-udc.c

886

u32 int_msk = ioread32(fotg210->reg + FOTG210_DMIGR);

drivers/usb/fotg210/fotg210-udc.c

894

u32 int_grp2 = ioread32(reg);

drivers/usb/fotg210/fotg210-udc.c

895

u32 int_msk2 = ioread32(fotg210->reg + FOTG210_DMISGR2);

drivers/usb/fotg210/fotg210-udc.c

938

u32 int_grp0 = ioread32(reg);

drivers/usb/fotg210/fotg210-udc.c

939

u32 int_msk0 = ioread32(fotg210->reg + FOTG210_DMISGR0);

drivers/usb/fotg210/fotg210-udc.c

976

u32 int_grp1 = ioread32(reg);

drivers/usb/fotg210/fotg210-udc.c

977

u32 int_msk1 = ioread32(fotg210->reg + FOTG210_DMISGR1);

drivers/usb/fotg210/fotg210-udc.c

999

u32 reg = ioread32(fotg210->reg + FOTG210_PHYTMSR);

drivers/usb/gadget/udc/pch_udc.c

402

return ioread32(dev->base_addr + reg);

drivers/usb/gadget/udc/pch_udc.c

427

return ioread32(ep->dev->base_addr + ep->offset_addr + reg);

drivers/usb/gadget/udc/r8a66597-udc.h

149

data = ioread32(fifoaddr);

drivers/usb/gadget/udc/r8a66597-udc.h

260

return ioread32(r8a66597->sudmac_reg + offset);

drivers/usb/gadget/udc/renesas_usb3.c

411

return ioread32(usb3->reg + offs);

drivers/usb/gadget/udc/renesas_usb3.c

451

return ioread32(reg);

drivers/usb/gadget/udc/udc-xilinx.c

231

return ioread32(addr);

drivers/usb/host/r8a66597.h

177

unsigned long tmp = ioread32(fifoaddr);

drivers/usb/renesas_usbhs/fifo.c

726

data = ioread32(addr);

drivers/usb/renesas_usbhs/rcar3.c

44

return ioread32(priv->base + reg);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

209

if (readx_poll_timeout(ioread32, addr, val, val == select, 10, OCTEP_HW_TIMEOUT)) {

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

223

features_lo = ioread32(&oct_hw->common_cfg->device_feature);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

228

features_hi = ioread32(&oct_hw->common_cfg->device_feature);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

240

features_lo = ioread32(&oct_hw->common_cfg->guest_feature);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

245

features_hi = ioread32(&oct_hw->common_cfg->guest_feature);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

60

return readx_poll_timeout(ioread32, &mbox->sts, val, MBOX_AVAIL(val), 10,

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

68

return readx_poll_timeout(ioread32, &mbox->sts, val, MBOX_RSP(val), 10,

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

90

return ioread32(&mbox->sts);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

95

return ioread32(&mbox->data[word_idx]);

drivers/vdpa/solidrun/snet_ctrl.c

71

return readx_poll_timeout(ioread32, &regs->ctrl, val, SNET_EMPTY_CTRL(val), 10,

drivers/vdpa/solidrun/snet_ctrl.c

79

return readx_poll_timeout(ioread32, &regs->op, val, !val, 10, SNET_CTRL_TIMEOUT);

drivers/vdpa/solidrun/snet_ctrl.c

86

return readx_poll_timeout(ioread32, &regs->ctrl, val, SNET_DATA_READY(val), 10,

drivers/vdpa/solidrun/snet_ctrl.c

92

return ioread32(&ctrl_regs->data[word_idx]);

drivers/vdpa/solidrun/snet_ctrl.c

97

return ioread32(&ctrl_regs->ctrl);

drivers/vdpa/solidrun/snet_main.c

387

ret = readx_poll_timeout(ioread32, snet->bar + snet->psnet->cfg.host_cfg_off,

drivers/vdpa/solidrun/snet_main.c

650

if (ioread32(psnet->bars[i] + off) == SNET_SIGNATURE)

drivers/vdpa/solidrun/snet_vdpa.h

170

return ioread32(psnet->bars[psnet->barno] + off);

drivers/vdpa/solidrun/snet_vdpa.h

175

return ioread32(snet->bar + off);

drivers/vfio/pci/nvgrace-gpu/main.c

250

if ((ioread32(io + C2C_LINK_BAR0_OFFSET) == STATUS_READY) &&

drivers/vfio/pci/nvgrace-gpu/main.c

251

(ioread32(io + HBM_TRAINING_BAR0_OFFSET) == STATUS_READY))

drivers/vfio/pci/vfio_pci_rdwr.c

26

#define vfio_ioread32 ioread32

drivers/vfio/platform/reset/vfio_platform_amdxgbe.c

105

while (--count && (ioread32(xgmac_regs->ioaddr + DMA_MR) & 1))

drivers/vfio/platform/reset/vfio_platform_amdxgbe.c

34

value = ioread32(ioaddr + ((mmd_address & 0xff) << 2));

drivers/vfio/platform/reset/vfio_platform_amdxgbe.c

98

dma_mr_value = ioread32(xgmac_regs->ioaddr + DMA_MR);

drivers/vfio/platform/vfio_platform_common.c

406

val = ioread32(reg->ioaddr + off);

drivers/video/fbdev/ocfb.c

90

return ioread32(fbdev->regs + offset);

drivers/video/fbdev/sh_mobile_lcdcfb.c

306

return ioread32(chan->lcdc->base + chan->reg_offs[reg_nr]);

drivers/video/fbdev/sh_mobile_lcdcfb.c

325

return ioread32(priv->base + reg_offs);

drivers/video/fbdev/via/via-core.c

66

return ioread32(global_dev.engine_mmio + reg);

drivers/video/fbdev/xilinxfb.c

185

return ioread32(drvdata->regs + (offset << 2));

drivers/virtio/virtio_mmio.c

168

l = cpu_to_le32(ioread32(base + offset + sizeof l));

drivers/virtio/virtio_pci_legacy_dev.c

200

return ioread32(ldev->ioaddr + VIRTIO_PCI_QUEUE_PFN);

drivers/virtio/virtio_pci_legacy_dev.c

87

return ioread32(ldev->ioaddr + VIRTIO_PCI_HOST_FEATURES);

drivers/virtio/virtio_pci_legacy_dev.c

99

return ioread32(ldev->ioaddr + VIRTIO_PCI_GUEST_FEATURES);

drivers/virtio/virtio_pci_modern.c

468

l = cpu_to_le32(ioread32(device + offset));

drivers/virtio/virtio_pci_modern.c

472

l = cpu_to_le32(ioread32(device + offset));

drivers/virtio/virtio_pci_modern.c

474

l = cpu_to_le32(ioread32(device + offset + sizeof l));

drivers/w1/masters/amd_axi_w1.c

114

while ((ioread32(amd_axi_w1_local->base_addr + AXIW1_STAT_REG) & AXIW1_READY) == 0) {

drivers/w1/masters/amd_axi_w1.c

133

while ((ioread32(amd_axi_w1_local->base_addr + AXIW1_STAT_REG) & AXIW1_DONE) != 1) {

drivers/w1/masters/amd_axi_w1.c

141

val = (u8)(ioread32(amd_axi_w1_local->base_addr + AXIW1_DATA_REG) & AXIW1_READDATA);

drivers/w1/masters/amd_axi_w1.c

162

while ((ioread32(amd_axi_w1_local->base_addr + AXIW1_STAT_REG) & AXIW1_READY) == 0) {

drivers/w1/masters/amd_axi_w1.c

176

while ((ioread32(amd_axi_w1_local->base_addr + AXIW1_STAT_REG) & AXIW1_DONE) != 1) {

drivers/w1/masters/amd_axi_w1.c

183

val = (u8)(ioread32(amd_axi_w1_local->base_addr + AXIW1_DATA_REG) & 0x000000FF);

drivers/w1/masters/amd_axi_w1.c

203

while ((ioread32(amd_axi_w1_local->base_addr + AXIW1_STAT_REG) & AXIW1_READY) == 0) {

drivers/w1/masters/amd_axi_w1.c

217

while ((ioread32(amd_axi_w1_local->base_addr + AXIW1_STAT_REG) & AXIW1_DONE) != 1) {

drivers/w1/masters/amd_axi_w1.c

244

while ((ioread32(amd_axi_w1_local->base_addr + AXIW1_STAT_REG) & AXIW1_READY) == 0) {

drivers/w1/masters/amd_axi_w1.c

257

while ((ioread32(amd_axi_w1_local->base_addr + AXIW1_STAT_REG) & AXIW1_DONE) != 1) {

drivers/w1/masters/amd_axi_w1.c

263

if ((ioread32(amd_axi_w1_local->base_addr + AXIW1_STAT_REG) & AXIW1_PRESENCE) != 0)

drivers/w1/masters/amd_axi_w1.c

328

if (ioread32(lp->base_addr + AXIW1_IPID_REG) != AXIW1_IPID) {

drivers/w1/masters/amd_axi_w1.c

343

val = ioread32(lp->base_addr + AXIW1_IPVER_REG);

drivers/watchdog/asm9260_wdt.c

158

stat = ioread32(priv->iobase + HW_WDMOD);

drivers/watchdog/asm9260_wdt.c

82

counter = ioread32(priv->iobase + HW_WDTV);

drivers/watchdog/ath79_wdt.c

78

return ioread32(wdt_base + reg);

drivers/watchdog/davinci_wdt.c

125

val = ioread32(davinci_wdt->base + WDTCR);

drivers/watchdog/davinci_wdt.c

134

timer_counter = ioread32(davinci_wdt->base + TIM12);

drivers/watchdog/davinci_wdt.c

135

timer_counter |= ((u64)ioread32(davinci_wdt->base + TIM34) << 32);

drivers/watchdog/mt7621_wdt.c

54

return ioread32(base + reg);

drivers/watchdog/mtk_wdt.c

326

reg = ioread32(wdt_base + WDT_MODE);

drivers/watchdog/mtk_wdt.c

346

u32 reg = ioread32(wdt_base + WDT_MODE);

drivers/watchdog/of_xilinx_wdt.c

108

control_status_reg = ioread32(xdev->base + XWT_TWCSR0_OFFSET);

drivers/watchdog/of_xilinx_wdt.c

139

timer_value1 = ioread32(xdev->base + XWT_TBR_OFFSET);

drivers/watchdog/of_xilinx_wdt.c

140

timer_value2 = ioread32(xdev->base + XWT_TBR_OFFSET);

drivers/watchdog/of_xilinx_wdt.c

145

timer_value2 = ioread32(xdev->base + XWT_TBR_OFFSET);

drivers/watchdog/of_xilinx_wdt.c

63

control_status_reg = ioread32(xdev->base + XWT_TWCSR0_OFFSET);

drivers/watchdog/of_xilinx_wdt.c

85

control_status_reg = ioread32(xdev->base + XWT_TWCSR0_OFFSET);

drivers/watchdog/realtek_otto_wdt.c

151

v = ioread32(ctrl->base + OTTO_WDT_REG_CTRL);

drivers/watchdog/realtek_otto_wdt.c

281

v = ioread32(ctrl->base + OTTO_WDT_REG_CTRL);

drivers/watchdog/realtek_otto_wdt.c

79

v = ioread32(ctrl->base + OTTO_WDT_REG_CTRL);

drivers/watchdog/realtek_otto_wdt.c

91

v = ioread32(ctrl->base + OTTO_WDT_REG_CTRL);

drivers/watchdog/rt2880_wdt.c

64

return ioread32(base + reg);

drivers/watchdog/wdat_wdt.c

77

*value = ioread32(instr->reg);

drivers/watchdog/xilinx_wwdt.c

112

control_status_reg = ioread32(xdev->base + XWWDT_ESR_OFFSET);

drivers/watchdog/xilinx_wwdt.c

90

control_status_reg = ioread32(xdev->base + XWWDT_ESR_OFFSET);

include/asm-generic/io.h

902

#ifndef ioread32

include/asm-generic/io.h

903

#define ioread32 ioread32

include/asm-generic/iomap.h

32

extern unsigned int ioread32(const void __iomem *);

include/linux/cb710.h

176

cb710_sg_dwiter_write_next_block(miter, ioread32(port));

include/linux/fsl/netc_global.h

11

return ioread32(reg);

include/linux/fsl/ptp_qoriq.h

177

return ioread32(addr);

include/linux/fsl_ifc.h

858

val = ioread32(addr);

include/linux/goldfish.h

12

#define gf_ioread32 ioread32

include/linux/io-64-nonatomic-hi-lo.h

64

high = ioread32(addr + sizeof(u32));

include/linux/io-64-nonatomic-hi-lo.h

65

low = ioread32(addr);

include/linux/io-64-nonatomic-lo-hi.h

64

low = ioread32(addr);

include/linux/io-64-nonatomic-lo-hi.h

65

high = ioread32(addr + sizeof(u32));

include/linux/pds/pds_intr.h

133

cred = ioread32(&intr_ctrl->credits);

include/linux/pds/pds_intr.h

145

cred = ioread32(&intr_ctrl->credits);

include/linux/rtsx_pci.h

95

ioread32((pcr)->remap_addr + reg)

include/linux/virtio_pci_modern.h

73

return ioread32(addr);

lib/iomap.c

111

EXPORT_SYMBOL(ioread32);

sound/pci/asihpi/hpi6000.c

1164

data = ioread32(pdo->prHPI_data);

sound/pci/asihpi/hpi6000.c

1204

*(pdata + length - 1) = ioread32(pdo->prHPI_data);

sound/pci/asihpi/hpi6000.c

1571

hPI_error = ioread32(phw->dw2040_HPICSR + HPI_ERROR_REPORT);

sound/pci/asihpi/hpi6000.c

1597

hPIC = ioread32(pdo->prHPI_control);

sound/pci/asihpi/hpi6000.c

673

delay = ioread32(phw->dw2040_HPICSR + HPI_RESET);

sound/pci/asihpi/hpi6000.c

721

data = ioread32(pdo->prHPI_address);

sound/pci/asihpi/hpi6205.c

1300

temp = ioread32(phw->prHSR);

sound/pci/asihpi/hpi6205.c

1309

temp = ioread32(phw->prHDCR);

sound/pci/asihpi/hpi6205.c

1317

if ((temp | C6205_DSPP_MAP1) != ioread32(phw->prDSPP))

sound/pci/asihpi/hpi6205.c

1321

if ((temp | C6205_DSPP_MAP1) != ioread32(phw->prDSPP))

sound/pci/asihpi/hpi6205.c

1325

if ((temp | C6205_DSPP_MAP1) != ioread32(phw->prDSPP))

sound/pci/asihpi/hpi6205.c

1330

if ((temp | C6205_DSPP_MAP1) != ioread32(phw->prDSPP))

sound/pci/asihpi/hpi6205.c

1494

temp = ioread32(phw->prHSR);

sound/pci/asihpi/hpi6205.c

1499

temp = ioread32(phw->prHDCR);

sound/pci/asihpi/hpi6205.c

1541

data = ioread32(p_data);

sound/pci/asihpi/hpi6205.c

2075

r = ioread32(phw->prHDCR);

sound/pci/asihpi/hpi6205.c

714

hsr = ioread32(phw->prHSR);

sound/pci/intel8x0.c

431

return ioread32(chip->bmaddr + offset);

sound/pci/intel8x0m.c

233

return ioread32(chip->bmaddr + offset);

sound/pci/lx6464es/lx_core.c

121

return ioread32(address);

sound/pci/lx6464es/lx_core.c

64

return ioread32(address);

sound/pci/lx6464es/lx_core.c

75

data[i] = ioread32(address + i);

sound/soc/dwc/dwc-pcm.c

54

p[rx_ptr][0] = ioread32(dev->i2s_base + dev->l_reg); \

sound/soc/dwc/dwc-pcm.c

55

p[rx_ptr][1] = ioread32(dev->i2s_base + dev->r_reg); \

sound/soc/renesas/rcar/dma.c

385

return ioread32(rsnd_dmapp_addr(dmac, dma, reg));

sound/soc/renesas/rcar/dma.c

394

u32 val = ioread32(addr);

sound/soc/renesas/rcar/msiof.c

135

#define msiof_read(priv, reg) ioread32((priv)->base + reg)

sound/soc/sof/iomem-utils.c

104

tmp = ioread32(dest + m * 4);

sound/x86/intel_hdmi_audio.c

208

return ioread32(card_ctx->mmio_start + had_config_offset(pipe) + reg);