arch/alpha/include/asm/io.h

146

REMAP1(unsigned int, ioread8, const)

arch/alpha/include/asm/io.h

275

extern unsigned int ioread8(const void __iomem *);

arch/alpha/include/asm/io.h

338

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

arch/alpha/include/asm/io.h

366

return ioread8(ioport_map(port, 1));

arch/alpha/include/asm/io.h

385

#define ioread8 ioread8

arch/alpha/include/asm/io_trivial.h

10

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

arch/alpha/include/asm/io_trivial.h

89

return IO_CONCAT(__IO_PREFIX,ioread8)(addr);

arch/alpha/kernel/io.c

21

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

arch/alpha/kernel/io.c

283

*(unsigned char *)dst = ioread8(port);

arch/alpha/kernel/io.c

290

w = ioread8(port);

arch/alpha/kernel/io.c

291

w |= ioread8(port) << 8;

arch/alpha/kernel/io.c

292

w |= ioread8(port) << 16;

arch/alpha/kernel/io.c

293

w |= ioread8(port) << 24;

arch/alpha/kernel/io.c

300

*(unsigned char *)dst = ioread8(port);

arch/alpha/kernel/io.c

77

EXPORT_SYMBOL(ioread8);

arch/alpha/kernel/io.c

88

return ioread8(ioport_map(port, 1));

arch/parisc/include/asm/io.h

243

extern unsigned int ioread8(const void __iomem *);

arch/parisc/include/asm/io.h

248

#define ioread8 ioread8

arch/parisc/lib/iomap.c

526

EXPORT_SYMBOL(ioread8);

arch/powerpc/platforms/44x/ppc476.c

244

board_rev = ioread8(fpga + reg) & 0x03;

arch/powerpc/sysdev/mmio_nvram.c

53

val = ioread8(mmio_nvram_start + addr);

arch/sh/drivers/heartbeat.c

53

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

arch/x86/mm/testmmiotrace.c

57

if (ioread8(p + i) != i)

drivers/ata/ata_generic.c

62

dma_enabled = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);

drivers/ata/libata-sff.c

1716

nsect = ioread8(ioaddr->nsect_addr);

drivers/ata/libata-sff.c

1717

lbal = ioread8(ioaddr->lbal_addr);

drivers/ata/libata-sff.c

1850

nsect = ioread8(ioaddr->nsect_addr);

drivers/ata/libata-sff.c

1851

lbal = ioread8(ioaddr->lbal_addr);

drivers/ata/libata-sff.c

2861

iowrite8(ioread8(mmio + ATA_DMA_STATUS), mmio + ATA_DMA_STATUS);

drivers/ata/libata-sff.c

2883

dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);

drivers/ata/libata-sff.c

2907

dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);

drivers/ata/libata-sff.c

2944

iowrite8(ioread8(mmio + ATA_DMA_CMD) & ~ATA_DMA_START,

drivers/ata/libata-sff.c

2965

return ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);

drivers/ata/libata-sff.c

3109

(ioread8(bmdma + 2) & 0x80))

drivers/ata/libata-sff.c

396

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

drivers/ata/libata-sff.c

397

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

drivers/ata/libata-sff.c

398

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

drivers/ata/libata-sff.c

399

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

drivers/ata/libata-sff.c

400

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

drivers/ata/libata-sff.c

401

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

drivers/ata/libata-sff.c

406

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

drivers/ata/libata-sff.c

407

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

drivers/ata/libata-sff.c

408

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

drivers/ata/libata-sff.c

409

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

drivers/ata/libata-sff.c

410

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

drivers/ata/libata-sff.c

65

return ioread8(ap->ioaddr.status_addr);

drivers/ata/libata-sff.c

92

tmp = ioread8(ap->ioaddr.altstatus_addr);

drivers/ata/pata_arasan_cf.c

552

status = ioread8(qc->ap->ioaddr.altstatus_addr);

drivers/ata/pata_arasan_cf.c

585

status = ioread8(qc->ap->ioaddr.altstatus_addr);

drivers/ata/pata_atp867x.c

127

b = ioread8(dp->dma_mode);

drivers/ata/pata_atp867x.c

221

b = ioread8(dp->dma_mode);

drivers/ata/pata_atp867x.c

353

ioread8(ATP867X_SYS_INFO(ap)) & ATP867X_IO_SYS_INFO_66MHZ;

drivers/ata/pata_atp867x.c

388

v = ioread8(ATP867X_IOBASE(ap) + 0x28);

drivers/ata/pata_atp867x.c

396

v = ioread8(ATP867X_SYS_INFO(ap));

drivers/ata/pata_cs5530.c

112

reg = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);

drivers/ata/pata_hpt37x.c

482

u8 dma_stat = ioread8(bmdma + ATA_DMA_STATUS);

drivers/ata/pata_hpt37x.c

487

dma_stat = ioread8(bmdma + ATA_DMA_STATUS);

drivers/ata/pata_hpt37x.c

494

dma_cmd = ioread8(bmdma + ATA_DMA_CMD);

drivers/ata/pata_hpt37x.c

497

dma_stat = ioread8(bmdma + ATA_DMA_STATUS);

drivers/ata/pata_hpt3x2n.c

284

iowrite8(ioread8(bmdma+0x70) | 0x32, bmdma+0x70);

drivers/ata/pata_hpt3x2n.c

285

iowrite8(ioread8(bmdma+0x74) | 0x32, bmdma+0x74);

drivers/ata/pata_hpt3x3.c

102

iowrite8(ioread8(mmio + ATA_DMA_CMD) & ~ ATA_DMA_START,

drivers/ata/pata_hpt3x3.c

119

u8 r = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_STATUS);

drivers/ata/pata_it821x.c

680

status = ioread8(ap->ioaddr.status_addr);

drivers/ata/pata_marvell.c

82

if (ioread8(ap->ioaddr.bmdma_addr + 1) & 1)

drivers/ata/pata_ns87415.c

131

dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);

drivers/ata/pata_ns87415.c

187

iowrite8((ioread8(mmio + ATA_DMA_CMD) | ATA_DMA_INTR | ATA_DMA_ERR),

drivers/ata/pata_ns87415.c

231

tmp = ioread8(port);

drivers/ata/pata_ns87415.c

268

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

drivers/ata/pata_ns87415.c

269

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

drivers/ata/pata_ns87415.c

270

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

drivers/ata/pata_ns87415.c

271

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

drivers/ata/pata_ns87415.c

272

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

drivers/ata/pata_ns87415.c

277

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

drivers/ata/pata_ns87415.c

278

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

drivers/ata/pata_ns87415.c

279

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

drivers/ata/pata_ns87415.c

280

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

drivers/ata/pata_ns87415.c

281

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

drivers/ata/pata_octeon_cf.c

311

ioread8(ap->ioaddr.altstatus_addr);

drivers/ata/pata_octeon_cf.c

350

ioread8(ap->ioaddr.altstatus_addr);

drivers/ata/pata_octeon_cf.c

679

status = ioread8(ap->ioaddr.altstatus_addr);

drivers/ata/pata_octeon_cf.c

727

status = ioread8(ap->ioaddr.altstatus_addr);

drivers/ata/pata_pcmcia.c

128

ioread8(ap->ioaddr.data_addr);

drivers/ata/pata_pdc2027x.c

238

return ioread8(port_mmio(ap, PDC_ATA_CTL)) & 0x02;

drivers/ata/pata_pdc202xx_old.c

190

iowrite8(ioread8(clock) | sel66, clock);

drivers/ata/pata_pdc202xx_old.c

192

iowrite8(ioread8(clock) & ~sel66, clock);

drivers/ata/pata_pdc202xx_old.c

240

iowrite8(ioread8(clock) & ~sel66, clock);

drivers/ata/pata_pdc202xx_old.c

244

iowrite8(ioread8(clock) & ~sel66, clock);

drivers/ata/pata_pdc202xx_old.c

268

u8 burst = ioread8(bmdma + 0x1f);

drivers/ata/pata_sil680.c

212

ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);

drivers/ata/sata_mv.c

1946

if (ioread8(ap->ioaddr.altstatus_addr) & ATA_BUSY)

drivers/ata/sata_mv.c

2175

u8 stat = ioread8(ap->ioaddr.status_addr);

drivers/ata/sata_nv.c

1511

irq_stat = ioread8(host->ports[0]->ioaddr.scr_addr + NV_INT_STATUS);

drivers/ata/sata_nv.c

1588

mask = ioread8(scr_addr + NV_INT_ENABLE);

drivers/ata/sata_nv.c

1601

mask = ioread8(scr_addr + NV_INT_ENABLE);

drivers/ata/sata_nv.c

1796

ioread8(ap->ioaddr.error_addr));

drivers/ata/sata_nv.c

2201

dmactl = ioread8(ap->ioaddr.bmdma_addr + ATA_DMA_CMD);

drivers/ata/sata_sil.c

554

iowrite8(ioread8(ap->ioaddr.bmdma_addr) & ~SIL_DMA_ENABLE,

drivers/ata/sata_sil.c

560

ioread8(ap->ioaddr.bmdma_addr);

drivers/ata/sata_sx4.c

736

ioread8(ap->ioaddr.status_addr);

drivers/ata/sata_sx4.c

814

ioread8(ap->ioaddr.status_addr);

drivers/base/regmap/regmap-mmio.c

248

return ioread8(ctx->regs + reg);

drivers/bcma/host_pci.c

45

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

drivers/bluetooth/hci_bcm4377.c

2112

otp[i] = ioread8(bcm4377->bar0 + bcm4377->hw->otp_offset + i);

drivers/char/tpm/tpm_atmel.c

105

status = ioread8(priv->iobase + 1);

drivers/char/tpm/tpm_atmel.c

110

*buf++ = ioread8(priv->iobase);

drivers/char/tpm/tpm_atmel.c

121

status = ioread8(priv->iobase + 1);

drivers/char/tpm/tpm_atmel.c

132

status = ioread8(priv->iobase + 1);

drivers/char/tpm/tpm_atmel.c

137

*buf++ = ioread8(priv->iobase);

drivers/char/tpm/tpm_atmel.c

141

status = ioread8(priv->iobase + 1);

drivers/char/tpm/tpm_atmel.c

177

return ioread8(priv->iobase + 1);

drivers/char/tpm/tpm_tis.c

181

*result++ = ioread8(phy->iobase + addr);

drivers/char/tpm/tpm_tis.c

58

ioread8(iobase + TPM_ACCESS(0));

drivers/char/tpm/tpm_tis_synquacer.c

44

*result++ = ioread8(phy->iobase + addr);

drivers/char/tpm/tpm_tis_synquacer.c

47

result[1] = ioread8(phy->iobase + addr + 1);

drivers/char/tpm/tpm_tis_synquacer.c

48

result[0] = ioread8(phy->iobase + addr);

drivers/char/tpm/tpm_tis_synquacer.c

51

result[3] = ioread8(phy->iobase + addr + 3);

drivers/char/tpm/tpm_tis_synquacer.c

52

result[2] = ioread8(phy->iobase + addr + 2);

drivers/char/tpm/tpm_tis_synquacer.c

53

result[1] = ioread8(phy->iobase + addr + 1);

drivers/char/tpm/tpm_tis_synquacer.c

54

result[0] = ioread8(phy->iobase + addr);

drivers/clocksource/sh_mtu2.c

161

return ioread8(ch->mtu->mapbase + 0x280);

drivers/clocksource/sh_mtu2.c

168

return ioread8(ch->base + offs);

drivers/clocksource/sh_tmu.c

91

return ioread8(ch->tmu->mapbase + 2);

drivers/clocksource/sh_tmu.c

93

return ioread8(ch->tmu->mapbase + 4);

drivers/cpufreq/pcc-cpufreq.c

466

ioread16(&pcch_hdr->length), ioread8(&pcch_hdr->major),

drivers/cpufreq/pcc-cpufreq.c

467

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

drivers/firmware/qemu_fw_cfg.c

150

ioread8(fw_cfg_reg_data);

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

1164

val = ioread8(master->sram + ARB_REG);

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

328

stat = ioread8(master->sram + CMD_STAT_REG);

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

380

uint8_t rtag = ioread8(master->sram + STAT_RTAG) & 0xf;

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

381

uint8_t rcrc = ioread8(master->sram + STAT_RCRC) & 0xf;

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

449

ioread8(master->sram + STAT_RTAG),

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

450

ioread8(master->sram + STAT_RCRC),

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

458

v = ioread8(master->sram + TRACEBUF + i);

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

970

val = ioread8(master->sram + CF_STARTED);

drivers/gpib/tnt4882/tnt4882_gpib.c

109

retval = ioread8(address);

drivers/gpib/tnt4882/tnt4882_gpib.c

67

return ioread8(priv->nec7210_priv.mmiobase + offset);

drivers/gpib/tnt4882/tnt4882_gpib.c

95

retval = ioread8(address);

drivers/gpio/gpio-104-dio-48e.c

156

ioread8(dio48egpio->regs + DIO48E_DISABLE_COUNTER_TIMER_ADDRESSING);

drivers/gpio/gpio-amd8111.c

104

temp = ioread8(agp->pm + AMD_REG_GPIO(offset));

drivers/gpio/gpio-amd8111.c

119

temp = ioread8(agp->pm + AMD_REG_GPIO(offset));

drivers/gpio/gpio-amd8111.c

133

temp = ioread8(agp->pm + AMD_REG_GPIO(offset));

drivers/gpio/gpio-amd8111.c

150

temp = ioread8(agp->pm + AMD_REG_GPIO(offset));

drivers/gpio/gpio-amd8111.c

80

agp->orig[offset] = ioread8(agp->pm + AMD_REG_GPIO(offset)) &

drivers/gpio/gpio-novalake-events.c

126

reg = ioread8(addr);

drivers/gpio/gpio-novalake-events.c

166

reg = ioread8(addr);

drivers/gpio/gpio-novalake-events.c

194

pending = ioread8(reg + GPE_STS_REG_OFFSET);

drivers/gpio/gpio-novalake-events.c

195

enabled = ioread8(reg + GPE_EN_REG_OFFSET(block_size));

drivers/gpio/gpio-novalake-events.c

93

reg = ioread8(addr);

drivers/gpio/gpio-npcm-sgpio.c

198

reg = ioread8(gpio->base + NPCM_IOXCFG2);

drivers/gpio/gpio-npcm-sgpio.c

235

reg = ioread8(addr);

drivers/gpio/gpio-npcm-sgpio.c

263

reg = ioread8(addr);

drivers/gpio/gpio-npcm-sgpio.c

272

reg = ioread8(gpio->base + NPCM_IOXCTS);

drivers/gpio/gpio-npcm-sgpio.c

292

tmp = ioread8(gpio->base + NPCM_IOXCFG1) & ~NPCM_IOXCFG1_SFT_CLK;

drivers/gpio/gpio-npcm-sgpio.c

347

reg = ioread8(addr);

drivers/gpio/gpio-npcm-sgpio.c

445

reg = ioread8(bank_reg(gpio, bank, EVENT_STS));

drivers/gpio/gpio-sch.c

78

reg_val = !!(ioread8(sch->regs + offset) & BIT(bit));

drivers/gpio/gpio-sch.c

92

reg_val = ioread8(sch->regs + offset);

drivers/gpio/gpio-tqmx86.c

60

return ioread8(gd->io_base + reg);

drivers/gpu/drm/ast/ast_drv.h

268

return ioread8(addr + reg);

drivers/gpu/drm/i915/intel_memory_region.c

48

result[0] = ioread8(va);

drivers/gpu/drm/i915/intel_memory_region.c

49

result[1] = ioread8(va + byte);

drivers/gpu/drm/i915/intel_memory_region.c

50

result[2] = ioread8(va + pagesize - 1);

drivers/gpu/drm/mgag200/mgag200_drv.c

65

orig1 = ioread8(mem + offset);

drivers/gpu/drm/mgag200/mgag200_drv.c

66

orig2 = ioread8(mem + offset + 0x100);

drivers/gpu/drm/mgag200/mgag200_drv.h

33

#define RREG8(reg) ioread8(((void __iomem *)mdev->rmmio) + (reg))

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

54

#define nvif_rd08(a,b) ({ ((u8)nvif_rd((a), ioread8, 1, (b))); })

drivers/gpu/drm/nouveau/include/nvkm/core/device.h

125

#define nvkm_rd08(d,a) ioread8((d)->pri + (a))

drivers/gpu/drm/tiny/cirrus-qemu.c

107

return ioread8(cirrus->mmio + CRT_DATA);

drivers/gpu/drm/tiny/cirrus-qemu.c

129

ioread8(cirrus->mmio + VGA_DAC_MASK);

drivers/gpu/drm/tiny/cirrus-qemu.c

130

ioread8(cirrus->mmio + VGA_DAC_MASK);

drivers/gpu/drm/tiny/cirrus-qemu.c

131

ioread8(cirrus->mmio + VGA_DAC_MASK);

drivers/gpu/drm/tiny/cirrus-qemu.c

132

ioread8(cirrus->mmio + VGA_DAC_MASK);

drivers/gpu/drm/tiny/cirrus-qemu.c

92

return ioread8(cirrus->mmio + SEQ_DATA);

drivers/hwmon/i5k_amb.c

110

return ioread8(data->amb_mmio + offset);

drivers/hwmon/kbatt.c

50

if (ioread8(kbatt->base + KBATT_STATUS_REG) &

drivers/hwmon/kfan.c

203

status = ioread8(kfan->base + KFAN_STATUS_REG);

drivers/hwmon/kfan.c

46

u8 status = ioread8(kfan->base + KFAN_STATUS_REG);

drivers/hwmon/kfan.c

78

return ioread8(kfan->base + KFAN_CONTROL_REG);

drivers/hwmon/npcm750-pwm-fan.c

278

reg_int = ioread8(NPCM7XX_FAN_REG_TIEN(data->fan_base, fan));

drivers/hwmon/npcm750-pwm-fan.c

293

| ioread8(NPCM7XX_FAN_REG_TCKC(data->fan_base,

drivers/hwmon/npcm750-pwm-fan.c

307

| ioread8(NPCM7XX_FAN_REG_TCKC(data->fan_base,

drivers/hwmon/npcm750-pwm-fan.c

407

reg_int = ioread8(NPCM7XX_FAN_REG_TIEN(data->fan_base, fan));

drivers/hwmon/npcm750-pwm-fan.c

412

reg_mode = ioread8(NPCM7XX_FAN_REG_TCKC(data->fan_base, fan));

drivers/hwmon/npcm750-pwm-fan.c

449

reg_int = ioread8(NPCM7XX_FAN_REG_TIEN(data->fan_base, fan));

drivers/hwmon/npcm750-pwm-fan.c

459

reg_mode = ioread8(NPCM7XX_FAN_REG_TCKC(data->fan_base, fan));

drivers/hwmon/npcm750-pwm-fan.c

489

flag = ioread8(NPCM7XX_FAN_REG_TICTRL(data->fan_base, module));

drivers/i2c/busses/i2c-elektor.c

78

int val = ioread8(address);

drivers/i2c/busses/i2c-i801.c

1614

iowrite8(ioread8(SMBAUXCTL(priv)) &

drivers/i2c/busses/i2c-i801.c

1650

priv->original_hstcnt = ioread8(SMBHSTCNT(priv)) & ~SMBHSTCNT_KILL;

drivers/i2c/busses/i2c-i801.c

1652

priv->original_slvcmd = ioread8(SMBSLVCMD(priv));

drivers/i2c/busses/i2c-i801.c

356

status = ioread8(SMBHSTSTS(priv));

drivers/i2c/busses/i2c-i801.c

374

status = ioread8(SMBHSTSTS(priv));

drivers/i2c/busses/i2c-i801.c

384

u8 len = ioread8(SMBHSTDAT0(priv));

drivers/i2c/busses/i2c-i801.c

401

status = ioread8(SMBAUXSTS(priv)) & SMBAUXSTS_CRCE;

drivers/i2c/busses/i2c-i801.c

416

status = ioread8(SMBHSTSTS(priv));

drivers/i2c/busses/i2c-i801.c

533

iowrite8(ioread8(SMBAUXCTL(priv)) | SMBAUXCTL_E32B, SMBAUXCTL(priv));

drivers/i2c/busses/i2c-i801.c

538

ioread8(SMBHSTCNT(priv)); /* reset the data buffer index */

drivers/i2c/busses/i2c-i801.c

555

ioread8(SMBHSTCNT(priv)); /* reset the data buffer index */

drivers/i2c/busses/i2c-i801.c

559

iowrite8(ioread8(SMBAUXCTL(priv)) & ~SMBAUXCTL_E32B, SMBAUXCTL(priv));

drivers/i2c/busses/i2c-i801.c

582

priv->data[priv->count++] = ioread8(SMBBLKDAT(priv));

drivers/i2c/busses/i2c-i801.c

600

addr = ioread8(SMBNTFDADD(priv)) >> 1;

drivers/i2c/busses/i2c-i801.c

641

status = ioread8(SMBSLVSTS(priv));

drivers/i2c/busses/i2c-i801.c

646

status = ioread8(SMBHSTSTS(priv));

drivers/i2c/busses/i2c-i801.c

731

while (ioread8(SMBHSTSTS(priv)) &

drivers/i2c/busses/i2c-i801.c

742

data->block[i] = ioread8(SMBBLKDAT(priv));

drivers/i2c/busses/i2c-i801.c

815

data->byte = ioread8(SMBHSTDAT0(priv));

drivers/i2c/busses/i2c-i801.c

819

data->word = ioread8(SMBHSTDAT0(priv)) +

drivers/i2c/busses/i2c-i801.c

820

(ioread8(SMBHSTDAT1(priv)) << 8);

drivers/i2c/busses/i2c-i801.c

915

iowrite8(ioread8(SMBAUXCTL(priv)) | SMBAUXCTL_CRC, SMBAUXCTL(priv));

drivers/i2c/busses/i2c-i801.c

917

iowrite8(ioread8(SMBAUXCTL(priv)) & (~SMBAUXCTL_CRC),

drivers/i2c/busses/i2c-i801.c

933

iowrite8(ioread8(SMBAUXCTL(priv)) & ~SMBAUXCTL_CRC, SMBAUXCTL(priv));

drivers/i2c/busses/i2c-isch.c

56

return ioread8(priv->smba + offset);

drivers/i2c/busses/i2c-keba.c

129

reg = ioread8(ki2c->base + KI2C_STATUS_REG);

drivers/i2c/busses/i2c-keba.c

138

unsigned int reg = ioread8(ki2c->base + KI2C_CAPABILITY_REG);

drivers/i2c/busses/i2c-keba.c

145

unsigned int reg = ioread8(ki2c->base + KI2C_STATUS_DC_REG);

drivers/i2c/busses/i2c-keba.c

153

unsigned int reg = ioread8(ki2c->base + KI2C_STATUS_DC_REG);

drivers/i2c/busses/i2c-keba.c

164

control_dc = ioread8(ki2c->base + KI2C_CONTROL_DC_REG);

drivers/i2c/busses/i2c-keba.c

402

ioread8(ki2c->base + KI2C_DATA_REG);

drivers/i2c/busses/i2c-keba.c

422

data[i] = ioread8(ki2c->base + KI2C_DATA_REG);

drivers/i2c/busses/i2c-npcm7xx.c

1019

ioread8(bus->reg + NPCM_I2CTXF_STS));

drivers/i2c/busses/i2c-npcm7xx.c

1022

ioread8(bus->reg + NPCM_I2CRXF_STS));

drivers/i2c/busses/i2c-npcm7xx.c

1121

return ioread8(bus->reg + npcm_i2caddr[addr_type]);

drivers/i2c/busses/i2c-npcm7xx.c

1132

if (ioread8(bus->reg + npcm_i2caddr[i]) == slave_add)

drivers/i2c/busses/i2c-npcm7xx.c

1269

ioread8(bus->reg + NPCM_I2CTXF_STS);

drivers/i2c/busses/i2c-npcm7xx.c

1286

if (NPCM_I2CST_XMIT & ioread8(bus->reg + NPCM_I2CST)) {

drivers/i2c/busses/i2c-npcm7xx.c

1314

u8 i2cst = ioread8(bus->reg + NPCM_I2CST);

drivers/i2c/busses/i2c-npcm7xx.c

1403

ioread8(bus->reg + NPCM_I2CFIF_CTS))) {

drivers/i2c/busses/i2c-npcm7xx.c

1437

val = ioread8(bus->reg + NPCM_I2CCST);

drivers/i2c/busses/i2c-npcm7xx.c

1444

i2ccst3 = ioread8(bus->reg + NPCM_I2CCST3);

drivers/i2c/busses/i2c-npcm7xx.c

1445

i2ccst2 = ioread8(bus->reg + NPCM_I2CCST2);

drivers/i2c/busses/i2c-npcm7xx.c

1686

data = ioread8(bus->reg + NPCM_I2CFIF_CTS);

drivers/i2c/busses/i2c-npcm7xx.c

1756

readx_poll_timeout_atomic(ioread8, bus->reg + NPCM_I2CCST, val,

drivers/i2c/busses/i2c-npcm7xx.c

1857

fif_cts = ioread8(bus->reg + NPCM_I2CFIF_CTS);

drivers/i2c/busses/i2c-npcm7xx.c

1900

i2cst = ioread8(bus->reg + NPCM_I2CST);

drivers/i2c/busses/i2c-npcm7xx.c

1920

ioread8(bus->reg + NPCM_I2CCTL1)) == 1) &&

drivers/i2c/busses/i2c-npcm7xx.c

1922

ioread8(bus->reg + NPCM_I2CCST3)))) {

drivers/i2c/busses/i2c-npcm7xx.c

1983

fif_cts = ioread8(bus->reg + NPCM_I2CFIF_CTS);

drivers/i2c/busses/i2c-npcm7xx.c

2148

if (FIELD_GET(I2C_VER_FIFO_EN, ioread8(bus->reg + I2C_VER))) {

drivers/i2c/busses/i2c-npcm7xx.c

2151

val = ioread8(bus->reg + NPCM_I2CFIF_CTL);

drivers/i2c/busses/i2c-npcm7xx.c

2169

val = ioread8(bus->reg + NPCM_I2CCTL1);

drivers/i2c/busses/i2c-npcm7xx.c

2276

i2cfif_cts = ioread8(bus->reg + NPCM_I2CFIF_CTS);

drivers/i2c/busses/i2c-npcm7xx.c

2353

bus_busy = ioread8(bus->reg + NPCM_I2CCST) & NPCM_I2CCST_BB;

drivers/i2c/busses/i2c-npcm7xx.c

2439

(bus->data->rxf_ctl_last_pec & ioread8(bus->reg + NPCM_I2CRXF_CTL)))

drivers/i2c/busses/i2c-npcm7xx.c

602

u8 i2cctl3 = ioread8(bus->reg + NPCM_I2CCTL3);

drivers/i2c/busses/i2c-npcm7xx.c

635

return ioread8(bus->reg + NPCM_I2CSDA);

drivers/i2c/busses/i2c-npcm7xx.c

642

return !!(I2CCTL3_SCL_LVL & ioread8(bus->reg + NPCM_I2CCTL3));

drivers/i2c/busses/i2c-npcm7xx.c

649

return !!(I2CCTL3_SDA_LVL & ioread8(bus->reg + NPCM_I2CCTL3));

drivers/i2c/busses/i2c-npcm7xx.c

680

i2cctl2 = ioread8(bus->reg + NPCM_I2CCTL2);

drivers/i2c/busses/i2c-npcm7xx.c

689

u8 i2cctl2 = ioread8(bus->reg + NPCM_I2CCTL2);

drivers/i2c/busses/i2c-npcm7xx.c

702

val = ioread8(bus->reg + NPCM_I2CCST3);

drivers/i2c/busses/i2c-npcm7xx.c

706

val = ioread8(bus->reg + NPCM_I2CCTL1);

drivers/i2c/busses/i2c-npcm7xx.c

719

tx_fifo_sts = ioread8(bus->reg + NPCM_I2CTXF_STS);

drivers/i2c/busses/i2c-npcm7xx.c

732

rx_fifo_sts = ioread8(bus->reg + NPCM_I2CRXF_STS);

drivers/i2c/busses/i2c-npcm7xx.c

745

val = ioread8(bus->reg + NPCM_I2CFIF_CTS);

drivers/i2c/busses/i2c-npcm7xx.c

754

val = ioread8(bus->reg + NPCM_I2CTXF_STS);

drivers/i2c/busses/i2c-npcm7xx.c

763

val = ioread8(bus->reg + NPCM_I2CRXF_STS);

drivers/i2c/busses/i2c-npcm7xx.c

772

val = ioread8(bus->reg + NPCM_I2CCTL1);

drivers/i2c/busses/i2c-npcm7xx.c

785

val = ioread8(bus->reg + NPCM_I2CCTL1);

drivers/i2c/busses/i2c-npcm7xx.c

801

val = ioread8(bus->reg + NPCM_I2CCTL1);

drivers/i2c/busses/i2c-npcm7xx.c

823

val = ioread8(bus->reg + NPCM_I2CCTL1);

drivers/i2c/busses/i2c-npcm7xx.c

836

val = ioread8(bus->reg + NPCM_I2CCTL1);

drivers/i2c/busses/i2c-npcm7xx.c

857

i2cctl1 = ioread8(bus->reg + NPCM_I2CCTL1);

drivers/i2c/busses/i2c-npcm7xx.c

875

i2cctl1 = ioread8(bus->reg + NPCM_I2CCTL1);

drivers/i2c/busses/i2c-npcm7xx.c

883

i2cctl3 = ioread8(bus->reg + NPCM_I2CCTL3);

drivers/i2c/busses/i2c-npcm7xx.c

916

i2cctl1 = ioread8(bus->reg + NPCM_I2CCTL1);

drivers/i2c/busses/i2c-npcm7xx.c

950

return !!FIELD_GET(NPCM_I2CST_MASTER, ioread8(bus->reg + NPCM_I2CST));

drivers/i2c/busses/i2c-ocores.c

116

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

drivers/i2c/busses/i2c-pca-platform.c

42

return ioread8(i2c->reg_base + reg);

drivers/i2c/busses/i2c-pca-platform.c

48

return ioread8(i2c->reg_base + reg * 2);

drivers/i2c/busses/i2c-pca-platform.c

54

return ioread8(i2c->reg_base + reg * 4);

drivers/i2c/busses/i2c-piix4.c

341

smba_en_lo = ioread8(mmio_cfg.addr);

drivers/i2c/busses/i2c-piix4.c

342

smba_en_hi = ioread8(mmio_cfg.addr + 1);

drivers/i2c/busses/i2c-piix4.c

753

smba_en_lo = ioread8(mmio_cfg->addr + piix4_port_sel_sb800);

drivers/i2c/busses/i2c-sh_mobile.c

196

return ioread8(pd->reg + offs);

drivers/i2c/busses/i2c-viai2c-zhaoxin.c

104

msg->buf[i2c->xfered_len + i] = ioread8(base + ZXI2C_REG_HRDR);

drivers/i2c/busses/i2c-viai2c-zhaoxin.c

111

tmp = ioread8(base + ZXI2C_REG_HCR);

drivers/i2c/busses/i2c-viai2c-zhaoxin.c

127

tmp = ioread8(base + VIAI2C_REG_CR);

drivers/i2c/busses/i2c-viai2c-zhaoxin.c

133

tmp = ioread8(base + VIAI2C_REG_CR);

drivers/i2c/busses/i2c-viai2c-zhaoxin.c

151

tmp = ioread8(base + VIAI2C_REG_CR);

drivers/i2c/busses/i2c-viai2c-zhaoxin.c

239

fstp = ioread8(i2c->base + VIAI2C_REG_TR);

drivers/i2c/busses/i2c-viai2c-zhaoxin.c

319

priv->hrv = ioread8(i2c->base + ZXI2C_REG_REV);

drivers/i2c/busses/i2c-viai2c-zhaoxin.c

62

tmp = ioread8(base + ZXI2C_REG_HCR);

drivers/i2c/busses/i2c-viai2c-zhaoxin.c

78

tmp = ioread8(base + VIAI2C_REG_CR);

drivers/i2c/busses/i2c-xiic.c

294

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

drivers/i2c/busses/i2c-xiic.c

296

ret = ioread8(i2c->base + reg + 3);

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

53

ioread8(mux->data.reg);

drivers/ipack/devices/ipoctal.c

164

value = ioread8(&channel->regs->r.rhr);

drivers/ipack/devices/ipoctal.c

194

isr = ioread8(&channel->block_regs->r.isr);

drivers/ipack/devices/ipoctal.c

195

sr = ioread8(&channel->regs->r.sr);

drivers/ipack/devices/ipoctal.c

225

isr = ioread8(&channel->block_regs->r.isr);

drivers/ipack/devices/ipoctal.c

226

sr = ioread8(&channel->regs->r.sr);

drivers/ipack/ipack.c

362

if ((ioread8(idmem + 1) == 'I') &&

drivers/ipack/ipack.c

363

(ioread8(idmem + 3) == 'P') &&

drivers/ipack/ipack.c

364

(ioread8(idmem + 5) == 'A') &&

drivers/ipack/ipack.c

365

((ioread8(idmem + 7) == 'C') ||

drivers/ipack/ipack.c

366

(ioread8(idmem + 7) == 'H'))) {

drivers/ipack/ipack.c

368

dev->id_avail = ioread8(idmem + 0x15);

drivers/ipack/ipack.c

373

} else if ((ioread8(idmem + 0) == 'I') &&

drivers/ipack/ipack.c

374

(ioread8(idmem + 1) == 'V') &&

drivers/ipack/ipack.c

375

(ioread8(idmem + 2) == 'A') &&

drivers/ipack/ipack.c

376

(ioread8(idmem + 3) == 'T') &&

drivers/ipack/ipack.c

377

(ioread8(idmem + 4) == ' ') &&

drivers/ipack/ipack.c

378

(ioread8(idmem + 5) == '4')) {

drivers/ipack/ipack.c

404

dev->id[i] = ioread8(idmem + (i << 1) + 1);

drivers/ipack/ipack.c

406

dev->id[i] = ioread8(idmem + i);

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

83

return ioread8(iomem);

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

407

ioread8(cobalt->bar1 + COBALT_HDL_INFO_BASE + i);

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

139

status = ioread8(&regs->cr_sr);

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

144

status = ioread8(&regs->cr_sr);

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

198

status = ioread8(&regs->cr_sr);

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

203

status = ioread8(&regs->cr_sr);

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

213

data[i] = ioread8(&regs->txr_rxr);

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

336

status = ioread8(&regs->cr_sr);

drivers/mfd/cgbc-core.c

126

return ioread8(cgbc->io_cmd + CGBC_CMD_ACCESS) == cgbc->session;

drivers/mfd/cgbc-core.c

152

ret = readx_poll_timeout(ioread8, cgbc->io_cmd + CGBC_CMD_STROBE, val,

drivers/mfd/cgbc-core.c

183

ret = read_poll_timeout(ioread8, val, val == CGBC_CMD_STROBE, 0, 100000, false,

drivers/mfd/cgbc-core.c

188

istatus = ioread8(cgbc->io_cmd + CGBC_CMD_DATA);

drivers/mfd/cgbc-core.c

197

_data[i] = ioread8(cgbc->io_cmd + CGBC_CMD_DATA + ((i + 1) % 4));

drivers/mfd/cgbc-core.c

200

data_checksum = ioread8(cgbc->io_cmd + CGBC_CMD_DATA + ((i + 1) % 4));

drivers/mfd/cgbc-core.c

205

data_checksum = ioread8(cgbc->io_cmd + CGBC_CMD_DATA + 1);

drivers/mfd/cgbc-core.c

211

data_checksum = ioread8(cgbc->io_cmd + CGBC_CMD_DATA + 1);

drivers/mfd/cgbc-core.c

78

ret = readx_poll_timeout(ioread8, cgbc->io_session + CGBC_SESSION_CMD, val,

drivers/mfd/cgbc-core.c

85

ret = readx_poll_timeout(ioread8, cgbc->io_session + CGBC_SESSION_CMD, val,

drivers/mfd/cgbc-core.c

90

ret = (int)ioread8(cgbc->io_session + CGBC_SESSION_DATA);

drivers/mfd/janz-cmodio.c

211

priv->hex = ioread8(&priv->ctrl->int_enable);

drivers/mfd/kempld-core.c

157

return ioread8(pld->io_data);

drivers/mfd/kempld-core.c

34

while (ioread8(pld->io_index) & KEMPLD_MUTEX_KEY)

drivers/mfd/kempld-core.c

379

index_reg = ioread8(pld->io_index);

drivers/mfd/kempld-core.c

380

if (index_reg == 0xff && ioread8(pld->io_data) == 0xff) {

drivers/mfd/tqmx86.c

235

val = ioread8(io_base + TQMX86_REG_IO_EXT_INT);

drivers/mfd/tqmx86.c

240

readback = ioread8(io_base + TQMX86_REG_IO_EXT_INT);

drivers/mfd/tqmx86.c

261

board_id = ioread8(io_base + TQMX86_REG_BOARD_ID);

drivers/mfd/tqmx86.c

262

sauc = ioread8(io_base + TQMX86_REG_SAUC);

drivers/mfd/tqmx86.c

264

rev = ioread8(io_base + TQMX86_REG_BOARD_REV);

drivers/misc/hpilo.c

410

iowrite8(ioread8(&hw->mmio_vaddr[DB_IRQ]) | 1, &hw->mmio_vaddr[DB_IRQ]);

drivers/misc/hpilo.c

415

iowrite8(ioread8(&hw->mmio_vaddr[DB_IRQ]) & ~1,

drivers/misc/keba/cp500.c

285

if (ioread8(cp500->system_startup_addr + CP500_RECONFIG_REG) &

drivers/misc/keba/cp500.c

743

u8 present = ioread8(cp500->system_startup_addr + CP500_PRESENT_REG);

drivers/misc/pch_phub.c

164

*data = ioread8(mem_addr);

drivers/misc/pch_phub.c

192

while (ioread8(chip->pch_phub_extrom_base_address +

drivers/misc/pvpanic/pvpanic.c

199

pi->capability &= ioread8(base);

drivers/mtd/nand/raw/technologic-nand-controller.c

63

unsigned char bits = ioread8(data->ctrl) & ~GENMASK(2, 0);

drivers/net/can/cc770/cc770_platform.c

61

return ioread8(priv->reg_base + reg);

drivers/net/can/janz-ican3.c

1362

control = ioread8(&desc->control);

drivers/net/can/janz-ican3.c

1503

stat = ioread8(&mod->ctrl->int_disable) & (1 << mod->num);

drivers/net/can/janz-ican3.c

1508

ioread8(&mod->dpmctrl->interrupt);

drivers/net/can/janz-ican3.c

1537

runold = ioread8(mod->dpm + TARGET_RUNNING);

drivers/net/can/janz-ican3.c

1546

runnew = ioread8(mod->dpm + TARGET_RUNNING);

drivers/net/can/janz-ican3.c

316

peer = ioread8(mod->dpm + MSYNC_PEER);

drivers/net/can/janz-ican3.c

317

locl = ioread8(mod->dpm + MSYNC_LOCL);

drivers/net/can/janz-ican3.c

361

peer = ioread8(mod->dpm + MSYNC_PEER);

drivers/net/can/janz-ican3.c

362

locl = ioread8(mod->dpm + MSYNC_LOCL);

drivers/net/can/sja1000/kvaser_pci.c

108

return ioread8(priv->reg_base + port);

drivers/net/can/sja1000/kvaser_pci.c

150

status = ioread8(base_addr +

drivers/net/can/sja1000/kvaser_pci.c

225

ioread8(board->res_addr + XILINX_VERINT) >> 4;

drivers/net/can/sja1000/peak_pcmcia.c

178

return ioread8(priv->reg_base + port);

drivers/net/can/sja1000/peak_pcmcia.c

213

return ioread8(card->ioport_addr + PCC_COMN_OFF + port);

drivers/net/can/sja1000/plx_pci.c

363

return ioread8(priv->reg_base + port);

drivers/net/can/sja1000/plx_pci.c

521

tmpval = ioread8(bar0_addr + ASEM_RAW_CAN_RST_REGISTER);

drivers/net/can/sja1000/sja1000_platform.c

43

return ioread8(priv->reg_base + reg);

drivers/net/can/sja1000/sja1000_platform.c

53

return ioread8(priv->reg_base + reg * 2);

drivers/net/can/sja1000/sja1000_platform.c

63

return ioread8(priv->reg_base + reg * 4);

drivers/net/can/softing/softing_fw.c

34

ret = ioread8(&card->dpram[DPRAM_FCT_HOST]) +

drivers/net/can/softing/softing_fw.c

35

(ioread8(&card->dpram[DPRAM_FCT_HOST + 1]) << 8);

drivers/net/can/softing/softing_main.c

164

lost_msg = ioread8(&card->dpram[DPRAM_RX_LOST]);

drivers/net/can/softing/softing_main.c

192

fifo_rd = ioread8(&card->dpram[DPRAM_RX_RD]);

drivers/net/can/softing/softing_main.c

193

fifo_wr = ioread8(&card->dpram[DPRAM_RX_WR]);

drivers/net/can/softing/softing_main.c

35

iowrite8(ioread8(&card->dpram[DPRAM_V2_RESET]) & ~1,

drivers/net/can/softing/softing_main.c

360

ir = ioread8(&card->dpram[DPRAM_V2_IRQ_TOHOST]);

drivers/net/can/softing/softing_main.c

370

ir = ioread8(&card->dpram[DPRAM_IRQ_TOHOST]);

drivers/net/can/softing/softing_main.c

45

iowrite8(ioread8(&card->dpram[DPRAM_V2_RESET]) | 1,

drivers/net/can/softing/softing_main.c

73

fifo_wr = ioread8(&card->dpram[DPRAM_TX_WR]);

drivers/net/can/softing/softing_main.c

74

fifo_rd = ioread8(&card->dpram[DPRAM_TX_RD]);

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

1888

dev->name, ioread8(ioaddr + TxStatus),

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

1896

if ((ioread8(ioaddr + TxStatus) & 0x88) == 0x88)

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

1951

tx_status = ioread8(ioaddr + TxStatus);

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

2092

while (--i > 0 && (tx_status = ioread8(ioaddr + TxStatus)) > 0) {

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

2284

dev->name, status, ioread8(ioaddr + Timer));

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

2405

dev->name, status, ioread8(ioaddr + Timer));

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

2534

unsigned char rx_error = ioread8(ioaddr + RxErrors);

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

2737

dev->name, ioread16(ioaddr + EL3_STATUS), ioread8(ioaddr + TxStatus));

drivers/net/ethernet/alibaba/eea/eea_pci.c

82

#define cfg_read8(reg, item) ioread8(cfg_pointer(reg, item))

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

196

ioread8(&pdsc->info_regs->fw_status);

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

273

ioread8(&pdsc->info_regs->fw_status);

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

630

fw_status = ioread8(&pdsc->info_regs->fw_status);

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

258

pdsc->dev_info.asic_type = ioread8(&pdsc->info_regs->asic_type);

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

259

pdsc->dev_info.asic_rev = ioread8(&pdsc->info_regs->asic_rev);

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

261

ioread8(&pdsc->info_regs->fw_status);

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

63

pdsc->fw_status = ioread8(&pdsc->info_regs->fw_status);

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

89

return ioread8(&pdsc->cmd_regs->comp.status);

drivers/net/ethernet/atheros/atlx/atl2.h

48

#define ATL2_READ_REGB(a, reg) (ioread8((a)->hw_addr + (reg)))

drivers/net/ethernet/cisco/enic/vnic_dev.c

73

while ((type = ioread8(&r->type)) != RES_TYPE_EOL) {

drivers/net/ethernet/cisco/enic/vnic_dev.c

75

u8 bar_num = ioread8(&r->bar);

drivers/net/ethernet/dec/tulip/dmfe.c

147

#define dr8(reg) ioread8(ioaddr + (reg))

drivers/net/ethernet/dec/tulip/xircom_cb.c

45

#define xr8(reg) ioread8(ioaddr + (reg))

drivers/net/ethernet/dlink/dl2k.c

18

#define dr8(reg) ioread8(ioaddr + (reg))

drivers/net/ethernet/dlink/sundance.c

1256

hw_frame_id = ioread8(ioaddr + TxFrameId);

drivers/net/ethernet/dlink/sundance.c

1524

dev->stats.rx_missed_errors += ioread8(ioaddr + RxMissed);

drivers/net/ethernet/dlink/sundance.c

1527

dev->stats.tx_carrier_errors += ioread8(ioaddr + StatsCarrierError);

drivers/net/ethernet/dlink/sundance.c

1529

mult_coll = ioread8(ioaddr + StatsMultiColl);

drivers/net/ethernet/dlink/sundance.c

1531

single_coll = ioread8(ioaddr + StatsOneColl);

drivers/net/ethernet/dlink/sundance.c

1533

late_coll = ioread8(ioaddr + StatsLateColl);

drivers/net/ethernet/dlink/sundance.c

1539

np->xstats.tx_deferred += ioread8(ioaddr + StatsTxDefer);

drivers/net/ethernet/dlink/sundance.c

1540

np->xstats.tx_deferred_excessive += ioread8(ioaddr + StatsTxXSDefer);

drivers/net/ethernet/dlink/sundance.c

1541

np->xstats.tx_aborted += ioread8(ioaddr + StatsTxAbort);

drivers/net/ethernet/dlink/sundance.c

1542

np->xstats.tx_bcasts += ioread8(ioaddr + StatsBcastTx);

drivers/net/ethernet/dlink/sundance.c

1543

np->xstats.rx_bcasts += ioread8(ioaddr + StatsBcastRx);

drivers/net/ethernet/dlink/sundance.c

1544

np->xstats.tx_mcasts += ioread8(ioaddr + StatsMcastTx);

drivers/net/ethernet/dlink/sundance.c

1545

np->xstats.rx_mcasts += ioread8(ioaddr + StatsMcastRx);

drivers/net/ethernet/dlink/sundance.c

1750

wol_bits = ioread8(ioaddr + WakeEvent);

drivers/net/ethernet/dlink/sundance.c

1768

wol_bits = ioread8(ioaddr + WakeEvent);

drivers/net/ethernet/dlink/sundance.c

1840

dev->name, ioread8(ioaddr + TxStatus),

drivers/net/ethernet/dlink/sundance.c

737

#define mdio_delay() ioread8(mdio_addr)

drivers/net/ethernet/dlink/sundance.c

784

retval = (retval << 1) | ((ioread8(mdio_addr) & MDIO_Data) ? 1 : 0);

drivers/net/ethernet/dlink/sundance.c

894

iowrite8(ioread8(ioaddr + WakeEvent) | 0x00, ioaddr + WakeEvent);

drivers/net/ethernet/dlink/sundance.c

900

dev->name, ioread32(ioaddr + RxStatus), ioread8(ioaddr + TxStatus),

drivers/net/ethernet/dlink/sundance.c

954

ioread8(ioaddr + TxStatus), ioread32(ioaddr + RxStatus));

drivers/net/ethernet/dlink/sundance.c

972

" resetting...\n", dev->name, ioread8(ioaddr + TxStatus),

drivers/net/ethernet/dlink/sundance.c

973

ioread8(ioaddr + TxFrameId));

drivers/net/ethernet/ec_bhf.c

257

block_count = ioread8(priv->io + INFO_BLOCK_BLK_CNT);

drivers/net/ethernet/ec_bhf.c

271

priv->tx_dma_chan = ioread8(ec_info + INFO_BLOCK_TX_CHAN);

drivers/net/ethernet/ec_bhf.c

272

priv->rx_dma_chan = ioread8(ec_info + INFO_BLOCK_RX_CHAN);

drivers/net/ethernet/ec_bhf.c

456

stats->rx_errors = ioread8(priv->mac_io + MAC_RX_ERR_CNT) +

drivers/net/ethernet/ec_bhf.c

457

ioread8(priv->mac_io + MAC_CRC_ERR_CNT) +

drivers/net/ethernet/ec_bhf.c

458

ioread8(priv->mac_io + MAC_FRAME_ERR_CNT);

drivers/net/ethernet/ec_bhf.c

461

stats->rx_dropped = ioread8(priv->mac_io + MAC_DROPPED_FRMS);

drivers/net/ethernet/fealnx.c

529

addr[i] = ioread8(ioaddr + PAR0 + i);

drivers/net/ethernet/intel/e100.c

1716

iowrite8(ioread8(&nic->csr->scb.cmd_hi) | irq_sw_gen,&nic->csr->scb.cmd_hi);

drivers/net/ethernet/intel/e100.c

1982

if (ioread8(&nic->csr->scb.status) & rus_no_res)

drivers/net/ethernet/intel/e100.c

2010

if (ioread8(&nic->csr->scb.status) & rus_no_res)

drivers/net/ethernet/intel/e100.c

2197

u8 stat_ack = ioread8(&nic->csr->scb.stat_ack);

drivers/net/ethernet/intel/e100.c

2335

"scb.status=0x%02X\n", ioread8(&nic->csr->scb.status));

drivers/net/ethernet/intel/e100.c

2457

buff[0] = ioread8(&nic->csr->scb.cmd_hi) << 24 |

drivers/net/ethernet/intel/e100.c

2458

ioread8(&nic->csr->scb.cmd_lo) << 16 |

drivers/net/ethernet/intel/e100.c

612

(void)ioread8(&nic->csr->scb.status);

drivers/net/ethernet/intel/e100.c

745

ctrl = ioread8(&nic->csr->eeprom_ctrl_lo);

drivers/net/ethernet/intel/e100.c

825

if (likely(!ioread8(&nic->csr->scb.cmd_lo)))

drivers/net/ethernet/mellanox/mlx5/core/health.c

108

u8 synd = ioread8(&h->synd);

drivers/net/ethernet/mellanox/mlx5/core/health.c

111

rfr = mlx5_health_get_rfr(ioread8(&h->rfr_severity));

drivers/net/ethernet/mellanox/mlx5/core/health.c

428

if (!ioread8(&h->synd))

drivers/net/ethernet/mellanox/mlx5/core/health.c

436

rfr_severity = ioread8(&h->rfr_severity);

drivers/net/ethernet/mellanox/mlx5/core/health.c

439

hsynd_str(ioread8(&h->synd)), severity, mlx5_loglevel_str(severity));

drivers/net/ethernet/mellanox/mlx5/core/health.c

454

mlx5_log(dev, severity, "irisc_index %d\n", ioread8(&h->irisc_index));

drivers/net/ethernet/mellanox/mlx5/core/health.c

455

mlx5_log(dev, severity, "synd 0x%x: %s\n", ioread8(&h->synd),

drivers/net/ethernet/mellanox/mlx5/core/health.c

456

hsynd_str(ioread8(&h->synd)));

drivers/net/ethernet/mellanox/mlx5/core/health.c

471

u8 synd = ioread8(&h->synd);

drivers/net/ethernet/mellanox/mlx5/core/health.c

504

if (!ioread8(&h->synd))

drivers/net/ethernet/mellanox/mlx5/core/health.c

519

rfr_severity = ioread8(&h->rfr_severity);

drivers/net/ethernet/mellanox/mlx5/core/health.c

522

devlink_fmsg_u8_pair_put(fmsg, "irisc_index", ioread8(&h->irisc_index));

drivers/net/ethernet/mellanox/mlx5/core/health.c

523

devlink_fmsg_u8_pair_put(fmsg, "synd", ioread8(&h->synd));

drivers/net/ethernet/mellanox/mlx5/core/health.c

820

health->synd = ioread8(&h->synd);

drivers/net/ethernet/mellanox/mlx5/core/health.c

826

health->synd = ioread8(&h->synd);

drivers/net/ethernet/micrel/ks8842.c

221

return ioread8(adapter->hw_addr + offset);

drivers/net/ethernet/pensando/ionic/ionic_dev.c

153

ioread8(&idev->dev_info_regs->fw_status);

drivers/net/ethernet/pensando/ionic/ionic_dev.c

185

idev->dev_info.asic_type = ioread8(&idev->dev_info_regs->asic_type);

drivers/net/ethernet/pensando/ionic/ionic_dev.c

186

idev->dev_info.asic_rev = ioread8(&idev->dev_info_regs->asic_rev);

drivers/net/ethernet/pensando/ionic/ionic_dev.c

486

fw_status = ioread8(&idev->dev_info_regs->fw_status);

drivers/net/ethernet/pensando/ionic/ionic_dev.c

632

return ioread8(&idev->dev_cmd_regs->comp.comp.status);

drivers/net/ethernet/rdc/r6040.c

444

dev->stats.rx_crc_errors += ioread8(ioaddr + ME_CNT1);

drivers/net/ethernet/rdc/r6040.c

445

dev->stats.multicast += ioread8(ioaddr + ME_CNT0);

drivers/net/ethernet/realtek/8139too.c

663

#define RTL_W8_F(reg, val8) do { iowrite8 ((val8), ioaddr + (reg)); ioread8 (ioaddr + (reg)); } while (0)

drivers/net/ethernet/realtek/8139too.c

673

#define RTL_R8(reg) ioread8 (ioaddr + (reg))

drivers/net/ethernet/smsc/epic100.c

187

#define er8(reg) ioread8(ioaddr + (reg))

drivers/net/ethernet/smsc/smc91x.h

179

#define SMC_inb(a, r) ioread8((a) + (r))

drivers/net/ethernet/via/via-rhine.c

1356

iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1FDuplex,

drivers/net/ethernet/via/via-rhine.c

1359

iowrite8(ioread8(ioaddr + ChipCmd1) & ~Cmd1FDuplex,

drivers/net/ethernet/via/via-rhine.c

1864

iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,

drivers/net/ethernet/via/via-rhine.c

2167

iowrite8(ioread8(ioaddr + ChipCmd) | CmdTxOn,

drivers/net/ethernet/via/via-rhine.c

2174

iowrite8(ioread8(ioaddr + ChipCmd1) | Cmd1TxDemand,

drivers/net/ethernet/via/via-rhine.c

2487

iowrite8(ioread8(ioaddr + ConfigA) | 0x03, ioaddr + ConfigA);

drivers/net/ethernet/via/via-rhine.c

2502

iowrite8(ioread8(ioaddr + StickyHW) | 0x04, ioaddr + StickyHW);

drivers/net/ethernet/via/via-rhine.c

2508

iowrite8(ioread8(ioaddr + StickyHW) | 0x03, ioaddr + StickyHW);

drivers/net/ethernet/via/via-rhine.c

269

#define IOSYNC do { ioread8(ioaddr + StationAddr); } while (0)

drivers/net/ethernet/via/via-rhine.c

481

#define BYTE_REG_BITS_ON(x, p) do { iowrite8((ioread8((p))|(x)), (p)); } while (0)

drivers/net/ethernet/via/via-rhine.c

485

#define BYTE_REG_BITS_IS_ON(x, p) (ioread8((p)) & (x))

drivers/net/ethernet/via/via-rhine.c

489

#define BYTE_REG_BITS_OFF(x, p) do { iowrite8(ioread8((p)) & (~(x)), (p)); } while (0)

drivers/net/ethernet/via/via-rhine.c

493

#define BYTE_REG_BITS_SET(x, m, p) do { iowrite8((ioread8((p)) & (~(m)))|(x), (p)); } while (0)

drivers/net/ethernet/via/via-rhine.c

527

bool has_mask_bits = !!(ioread8(ioaddr + reg) & mask);

drivers/net/ethernet/via/via-rhine.c

557

intr_status |= ioread8(ioaddr + IntrStatus2) << 16;

drivers/net/ethernet/via/via-rhine.c

582

iowrite8(ioread8(ioaddr + StickyHW) & 0xFC, ioaddr + StickyHW);

drivers/net/ethernet/via/via-rhine.c

594

wolstat = ioread8(ioaddr + PwrcsrSet);

drivers/net/ethernet/via/via-rhine.c

596

wolstat |= (ioread8(ioaddr + PwrcsrSet1) & 0x03) << 8;

drivers/net/ethernet/via/via-rhine.c

639

if (ioread8(ioaddr + ChipCmd1) & Cmd1Reset) {

drivers/net/ethernet/via/via-rhine.c

650

cmd1 = ioread8(ioaddr + ChipCmd1);

drivers/net/ethernet/via/via-rhine.c

723

iowrite8(ioread8(ioaddr + ConfigA) & 0xFC, ioaddr + ConfigA);

drivers/net/ethernet/via/via-rhine.c

835

if (ioread8(ioaddr + ChipCmd) & CmdTxOn)

drivers/net/ethernet/via/via-rhine.c

937

addr[i] = ioread8(ioaddr + StationAddr + i);

drivers/net/ethernet/via/via-rhine.c

950

phy_id = ioread8(ioaddr + 0x6C);

drivers/net/fddi/skfp/h/types.h

28

#define inp(p) ioread8(p)

drivers/net/mdio/mdio-mux-mmioreg.c

56

x = ioread8(p);

drivers/net/wan/fsl_ucc_hdlc.c

898

priv->guemr = ioread8(&uf_regs->guemr);

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c

502

return (ioread8(address));

drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c

595

*dst8 = ioread8(address);

drivers/net/wireless/intel/ipw2x00/ipw2100.c

354

*val = ioread8(priv->ioaddr + reg);

drivers/net/wireless/marvell/mwifiex/pcie.c

260

*data = ioread8(card->pci_mmap1 + reg);

drivers/net/wireless/realtek/rtl818x/rtl8180/rtl8180.h

155

return ioread8(addr);

drivers/net/wwan/iosm/iosm_ipc_mmio.c

118

ioread8(ipc_mmio->base + ipc_mmio->offset.chip_info);

drivers/net/wwan/iosm/iosm_ipc_mmio.c

124

ioread8(ipc_mmio->base + ipc_mmio->offset.chip_info + 1) + 2;

drivers/ntb/hw/mscc/ntb_hw_switchtec.c

459

return ioread8(&inf->ntp_info[sndev->peer_partition].xlink_enabled);

drivers/pci/controller/dwc/pci-layerscape.c

81

header_type = ioread8(pci->dbi_base + PCI_HEADER_TYPE);

drivers/pci/quirks.c

5939

partition = ioread8(&mmio_ntb->partition_id);

drivers/pci/switch/switchtec.c

1613

stdev->partition = ioread8(part_id);

drivers/pci/switch/switchtec.c

1614

stdev->partition_count = ioread8(&stdev->mmio_ntb->partition_count);

drivers/pci/switch/switchtec.c

422

int rev = ioread8(&stdev->mmio_sys_info->gen3.component_revision);

drivers/pci/switch/switchtec.c

773

if (ioread8(&af->key) == SWITCHTEC_GEN4_KEY0_ACTIVE)

drivers/pci/switch/switchtec.c

780

if (ioread8(&af->key) == SWITCHTEC_GEN4_KEY1_ACTIVE)

drivers/pci/switch/switchtec.c

787

if (ioread8(&af->bl2) == SWITCHTEC_GEN4_BL2_0_ACTIVE)

drivers/pci/switch/switchtec.c

794

if (ioread8(&af->bl2) == SWITCHTEC_GEN4_BL2_1_ACTIVE)

drivers/pci/switch/switchtec.c

801

if (ioread8(&af->cfg) == SWITCHTEC_GEN4_CFG0_ACTIVE)

drivers/pci/switch/switchtec.c

808

if (ioread8(&af->cfg) == SWITCHTEC_GEN4_CFG1_ACTIVE)

drivers/pci/switch/switchtec.c

815

if (ioread8(&af->img) == SWITCHTEC_GEN4_IMG0_ACTIVE)

drivers/pci/switch/switchtec.c

822

if (ioread8(&af->img) == SWITCHTEC_GEN4_IMG1_ACTIVE)

drivers/pinctrl/renesas/core.c

143

return ioread8(mapped_reg);

drivers/pinctrl/renesas/pinctrl.c

928

u32 value = ioread8(reg) & PORTnCR_PULMD_MASK;

drivers/pinctrl/renesas/pinctrl.c

946

u32 value = ioread8(reg) & ~PORTnCR_PULMD_MASK;

drivers/platform/mellanox/mlx-platform.c

7278

*val = ioread8(ctx->base + reg);

drivers/platform/x86/amd/pmc/pmc-quirks.c

379

val = ioread8(addr);

drivers/platform/x86/apple-gmux.c

231

u8 gwr = ioread8(gmux_data->iomem_base + GMUX_MMIO_COMMAND_SEND);

drivers/platform/x86/apple-gmux.c

234

gwr = ioread8(gmux_data->iomem_base + GMUX_MMIO_COMMAND_SEND);

drivers/platform/x86/apple-gmux.c

252

val = ioread8(gmux_data->iomem_base);

drivers/platform/x86/ibm_rtl.c

101

if (ioread8(&rtl_table->rt_status) != value) {

drivers/platform/x86/ibm_rtl.c

106

cmd_port_val = ioread8(&rtl_table->cmd_port_value);

drivers/platform/x86/ibm_rtl.c

122

while (ioread8(&rtl_table->command)) {

drivers/platform/x86/ibm_rtl.c

133

if (ioread8(&rtl_table->command_status)) {

drivers/platform/x86/ibm_rtl.c

147

return sprintf(buf, "%d\n", (int)ioread8(&rtl_table->version));

drivers/platform/x86/ibm_rtl.c

154

return sprintf(buf, "%d\n", ioread8(&rtl_table->rt_status));

drivers/platform/x86/ibm_rtl.c

284

rtl_cmd_width = ioread8(&rtl_table->cmd_granularity);

drivers/platform/x86/ibm_rtl.c

285

rtl_cmd_type = ioread8(&rtl_table->cmd_address_type);

drivers/scsi/53c700.h

486

return ioread8(hostdata->base + (reg^bE));

drivers/scsi/am53c974.c

110

return ioread8(esp->regs + (reg * 4UL));

drivers/scsi/fnic/vnic_dev.c

104

while ((type = ioread8(&r->type)) != RES_TYPE_EOL) {

drivers/scsi/fnic/vnic_dev.c

106

u8 bar_num = ioread8(&r->bar);

drivers/scsi/g_NCR5380.c

39

ioread8(hostdata->io + hostdata->offset + (reg))

drivers/scsi/snic/vnic_dev.c

100

while ((type = ioread8(&r->type)) != RES_TYPE_EOL) {

drivers/scsi/snic/vnic_dev.c

102

u8 bar_num = ioread8(&r->bar);

drivers/scsi/sym53c8xx_2/sym_hipd.h

184

#define INB_OFF(np, o) ioread8(np->s.ioaddr + (o))

drivers/scsi/wd719x.c

52

return ioread8(wd->base + reg);

drivers/sh/clk/cpg.c

22

return ioread8(clk->mapped_reg);

drivers/sh/clk/cpg.c

35

return ioread8(mapped_status);

drivers/soc/fsl/qe/ucc_fast.c

44

&uccf->uf_regs->uccs, ioread8(&uccf->uf_regs->uccs));

drivers/soc/fsl/qe/ucc_fast.c

67

&uccf->uf_regs->guemr, ioread8(&uccf->uf_regs->guemr));

drivers/spi/spi-fsl-espi.c

128

return ioread8(espi->reg_base + offset);

drivers/spi/spi-kspi2.c

159

*rx = ioread8(kspi->base + KSPI2_DATA_REG);

drivers/spi/spi-kspi2.c

365

clk_reg = ioread8(kspi->base + KSPI2_CLK_FREQ_REG);

drivers/spi/spi-lp8841-rtc.c

62

return ioread8(data->iomem) & SPI_LP8841_RTC_MISO;

drivers/spi/spi-npcm-fiu.c

300

*(buf_rx + i) = ioread8(src + i);

drivers/spi/spi-npcm-pspi.c

235

*priv->rx_buf++ = ioread8(priv->base + NPCM_PSPI_DATA);

drivers/spi/spi-npcm-pspi.c

299

stat = ioread8(priv->base + NPCM_PSPI_STAT);

drivers/spi/spi-npcm-pspi.c

306

ioread8(NPCM_PSPI_DATA + priv->base);

drivers/spi/spi-rspi.c

216

return ioread8(rspi->addr + offset);

drivers/spi/spi-sh-sci.c

159

sp->val = ioread8(SCSPTR(sp));

drivers/spi/spi-sh-sci.c

71

return (ioread8(SCSPTR(sp)) & PIN_RXD) ? 1 : 0;

drivers/spi/spi-sh.c

93

return ioread8(ss->addr + (offset >> 2));

drivers/ssb/pci.c

971

return ioread8(bus->mmio + offset);

drivers/staging/vme_user/vme_tsi148.c

1193

*(u8 *)buf = ioread8(addr);

drivers/staging/vme_user/vme_tsi148.c

1200

*(u8 *)(buf + done) = ioread8(addr + done);

drivers/staging/vme_user/vme_tsi148.c

1220

*(u8 *)(buf + done) = ioread8(addr + done);

drivers/staging/vme_user/vme_tsi148.c

224

vec = ioread8(bridge->base + TSI148_LCSR_VIACK[i] + 3);

drivers/tty/serial/8250/8250_keba.c

201

kuart->capability = ioread8(kuart->base + KUART_CAPABILITY) &

drivers/tty/serial/8250/8250_pci.c

1115

number_uarts = ioread8(p + 4);

drivers/tty/serial/men_z135_uart.c

516

msr = ioread8(port->membase + MEN_Z135_STAT_REG + 1);

drivers/tty/serial/pch_uart.c

1444

status = ioread8(up->membase + UART_LSR);

drivers/tty/serial/pch_uart.c

1457

unsigned int msr = ioread8(up->membase + UART_MSR);

drivers/tty/serial/pch_uart.c

1476

u8 lsr = ioread8(priv->membase + UART_LSR);

drivers/tty/serial/pch_uart.c

1481

return ioread8(priv->membase + PCH_UART_RBR);

drivers/tty/serial/pch_uart.c

1495

ier = ioread8(priv->membase + UART_IER);

drivers/tty/serial/pch_uart.c

1573

ier = ioread8(priv->membase + UART_IER);

drivers/tty/serial/pch_uart.c

312

"IER: \t0x%02x\n", ioread8(priv->membase + UART_IER));

drivers/tty/serial/pch_uart.c

314

"IIR: \t0x%02x\n", ioread8(priv->membase + UART_IIR));

drivers/tty/serial/pch_uart.c

316

"LCR: \t0x%02x\n", ioread8(priv->membase + UART_LCR));

drivers/tty/serial/pch_uart.c

318

"MCR: \t0x%02x\n", ioread8(priv->membase + UART_MCR));

drivers/tty/serial/pch_uart.c

320

"LSR: \t0x%02x\n", ioread8(priv->membase + UART_LSR));

drivers/tty/serial/pch_uart.c

322

"MSR: \t0x%02x\n", ioread8(priv->membase + UART_MSR));

drivers/tty/serial/pch_uart.c

325

ioread8(priv->membase + PCH_UART_BRCSR));

drivers/tty/serial/pch_uart.c

327

lcr = ioread8(priv->membase + UART_LCR);

drivers/tty/serial/pch_uart.c

330

"DLL: \t0x%02x\n", ioread8(priv->membase + UART_DLL));

drivers/tty/serial/pch_uart.c

332

"DLM: \t0x%02x\n", ioread8(priv->membase + UART_DLM));

drivers/tty/serial/pch_uart.c

414

u8 ier = ioread8(priv->membase + UART_IER);

drivers/tty/serial/pch_uart.c

422

u8 ier = ioread8(priv->membase + UART_IER);

drivers/tty/serial/pch_uart.c

544

unsigned int msr = ioread8(priv->membase + UART_MSR);

drivers/tty/serial/pch_uart.c

556

lsr = ioread8(priv->membase + UART_LSR);

drivers/tty/serial/pch_uart.c

557

for (i = 0, lsr = ioread8(priv->membase + UART_LSR);

drivers/tty/serial/pch_uart.c

559

lsr = ioread8(priv->membase + UART_LSR)) {

drivers/tty/serial/pch_uart.c

560

rbr = ioread8(priv->membase + PCH_UART_RBR);

drivers/tty/serial/pch_uart.c

577

return ioread8(priv->membase + UART_IIR) &\

drivers/tty/serial/pch_uart.c

583

return ioread8(priv->membase + UART_LSR);

drivers/tty/serial/pch_uart.c

590

lcr = ioread8(priv->membase + UART_LCR);

drivers/tty/serial/sh-sci.c

692

return ioread8(p->membase + (reg->offset << p->regshift));

drivers/tty/serial/timbuart.c

108

ioread8(port->membase + TIMBUART_CTRL),

drivers/tty/serial/timbuart.c

110

ioread8(port->membase + TIMBUART_BAUDRATE));

drivers/tty/serial/timbuart.c

152

u8 ctl = ioread8(port->membase + TIMBUART_CTRL) |

drivers/tty/serial/timbuart.c

195

u8 cts = ioread8(port->membase + TIMBUART_CTRL);

drivers/tty/serial/timbuart.c

347

if (ioread8(uart->port.membase + TIMBUART_IPR)) {

drivers/tty/serial/timbuart.c

72

u8 ctl = ioread8(port->membase + TIMBUART_CTRL) |

drivers/tty/serial/timbuart.c

85

u8 ch = ioread8(port->membase + TIMBUART_RXFIFO);

drivers/uio/uio_aec.c

106

if (!(ioread8(info->priv + INTA_DRVR_ADDR)

drivers/uio/uio_aec.c

131

ioread8(info->priv + MAILBOX);

drivers/uio/uio_aec.c

45

unsigned char status = ioread8(int_flag);

drivers/uio/uio_aec.c

50

status = ioread8(dev_info->priv + MAILBOX);

drivers/uio/uio_aec.c

61

ioread8(i->priv + 0x01),

drivers/uio/uio_aec.c

62

ioread8(i->priv + 0x00),

drivers/uio/uio_aec.c

63

ioread8(i->priv + 0x03),

drivers/uio/uio_aec.c

64

ioread8(i->priv + 0x02),

drivers/uio/uio_aec.c

65

ioread8(i->priv + 0x06),

drivers/uio/uio_aec.c

66

ioread8(i->priv + 0x07));

drivers/uio/uio_cif.c

32

if ((ioread8(plx_intscr) & INT1_ENABLED_AND_ACTIVE)

drivers/uio/uio_cif.c

37

iowrite8(ioread8(plx_intscr) & ~INTSCR_INT1_ENABLE, plx_intscr);

drivers/vdpa/alibaba/eni_vdpa.c

390

*p++ = ioread8(ioaddr + i);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

183

return ioread8(&oct_hw->common_cfg->device_status);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

196

if (readx_poll_timeout(ioread8, &oct_hw->common_cfg->device_status, val, !val, 10,

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

290

old_gen = ioread8(&oct_hw->common_cfg->config_generation);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

293

*p++ = ioread8(oct_hw->dev_cfg + offset + i);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

295

new_gen = ioread8(&oct_hw->common_cfg->config_generation);

drivers/vdpa/octeon_ep/octep_vdpa_hw.c

409

*p++ = ioread8(bar + offset + i);

drivers/vdpa/octeon_ep/octep_vdpa_main.c

103

if (ioread8(oct_hw->vqs[i].cb_notify_addr)) {

drivers/vdpa/octeon_ep/octep_vdpa_main.c

115

if (ioread8(oct_hw->isr)) {

drivers/vdpa/solidrun/snet_main.c

478

*buf_ptr++ = ioread8(cfg_ptr + i);

drivers/vfio/pci/vfio_pci_rdwr.c

38

#define vfio_ioread8 ioread8

drivers/vfio/platform/vfio_platform_common.c

422

val = ioread8(reg->ioaddr + off);

drivers/virt/nitro_enclaves/ne_pci_dev.c

412

dev_enable_reply = ioread8(ne_pci_dev->iomem_base + NE_ENABLE);

drivers/virt/nitro_enclaves/ne_pci_dev.c

443

dev_disable_reply = ioread8(ne_pci_dev->iomem_base + NE_ENABLE);

drivers/virt/nitro_enclaves/ne_pci_dev.c

451

dev_disable_reply = ioread8(ne_pci_dev->iomem_base + NE_ENABLE);

drivers/virtio/virtio_pci_common.c

113

isr = ioread8(vp_dev->isr);

drivers/virtio/virtio_pci_legacy.c

180

ioread8(vp_dev->ldev.ioaddr + VIRTIO_PCI_ISR);

drivers/virtio/virtio_pci_legacy.c

59

ptr[i] = ioread8(ioaddr + i);

drivers/virtio/virtio_pci_legacy_dev.c

123

return ioread8(ldev->ioaddr + VIRTIO_PCI_STATUS);

drivers/virtio/virtio_pci_modern.c

460

b = ioread8(device + offset);

drivers/watchdog/hpwdt.c

176

u8 nmistat = ioread8(hpwdt_nmistat);

drivers/watchdog/hpwdt.c

68

return ioread8(hpwdt_timer_con) & 0x01;

drivers/watchdog/hpwdt.c

89

data = ioread8(hpwdt_timer_con);

drivers/watchdog/lenovo_se30_wdt.c

122

pre_id = ioread8(shm_base_addr + SHM_WIN_ID_OFFSET);

drivers/watchdog/lenovo_se30_wdt.c

127

new_id = ioread8(shm_base_addr + SHM_WIN_ID_OFFSET);

drivers/watchdog/lenovo_se30_wdt.c

145

*data = ioread8(shm_base_addr + SHM_WIN_DAT_OFFSET + reg->idx + idx_offset);

drivers/watchdog/wdat_wdt.c

71

*value = ioread8(instr->reg);

include/asm-generic/io.h

886

#ifndef ioread8

include/asm-generic/io.h

887

#define ioread8 ioread8

include/asm-generic/iomap.h

29

extern unsigned int ioread8(const void __iomem *);

include/linux/apple-gmux.h

80

val = ioread8(iomem_base + GMUX_MMIO_COMMAND_SEND);

include/linux/fsl_ifc.h

879

return ioread8(addr);

include/linux/rtsx_pci.h

103

ioread8((pcr)->remap_addr + reg)

include/linux/virtio_pci_modern.h

64

return ioread8(addr);

include/soc/fsl/qe/qe.h

269

#define qe_setbits_8(_addr, _v) iowrite8(ioread8(_addr) | (_v), (_addr))

include/soc/fsl/qe/qe.h

270

#define qe_clrbits_8(_addr, _v) iowrite8(ioread8(_addr) & ~(_v), (_addr))

include/soc/fsl/qe/qe.h

277

iowrite8((ioread8(addr) & ~(clear)) | (set), (addr))

lib/iomap.c

108

EXPORT_SYMBOL(ioread8);

sound/isa/galaxy/galaxy.c

105

while (ioread8(port + DSP_PORT_STATUS) & 0x80) {

sound/isa/galaxy/galaxy.c

153

if ((ioread8(wss_port + WSS_PORT_SIGNATURE) & 0x3f) != WSS_SIGNATURE)

sound/isa/galaxy/galaxy.c

430

u8 tmp = ioread8(galaxy->config_port + CONFIG_PORT_SET);

sound/isa/galaxy/galaxy.c

447

u8 tmp = ioread8(galaxy->config_port + i - 1);

sound/isa/galaxy/galaxy.c

78

while (!(ioread8(port + DSP_PORT_DATA_AVAIL) & 0x80)) {

sound/isa/galaxy/galaxy.c

83

*val = ioread8(port + DSP_PORT_READ);

sound/isa/sc6000.c

199

val = ioread8(vport + DSP_DATAVAIL);

sound/isa/sc6000.c

213

return ioread8(vport + DSP_READ);

sound/isa/sc6000.c

223

val = ioread8(vport + DSP_STATUS);

sound/pci/intel8x0.c

491

return ioread8(chip->bmaddr + offset);

sound/pci/intel8x0m.c

275

return ioread8(chip->bmaddr + offset);