Djam/u-boot
1
0
Fork 0
mirror of https://github.com/u-boot/u-boot.git synced 2025-04-25 14:56:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

pci: Map bars with offset and length

Browse source 
Evolve dm_pci_map_bar() to include an offset and length parameter. These
allow a portion of the memory to be mapped and range checks to be
applied.

Passing both the offset and length as zero results in the previous
behaviour and this is used to migrate the previous callers.

Signed-off-by: Andrew Scull <ascull@google.com>
Reviewed-by: Bin Meng <bmeng.cn@gmail.com>
This commit is contained in:
Andrew Scull 2022-04-21 16:11:10 +00:00 • committed by Tom Rini
parent 55e6adbd78
commit 12507a2d22
33 changed files with 67 additions and 55 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
arch/x86/cpu/baytrail/cpu.c
View file

@ -56,7 +56,7 @@ static int baytrail_uart_init(void *ctx, struct event *event)
for (i = 0; i < 2; i++) { for (i = 0; i < 2; i++) {
ret = dm_pci_bus_find_bdf(PCI_BDF(0, 0x1e, 3 + i), &dev); ret = dm_pci_bus_find_bdf(PCI_BDF(0, 0x1e, 3 + i), &dev);
if (!ret) { if (!ret) {
base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
hsuart_clock_set(base); hsuart_clock_set(base);
} }

6
drivers/ata/ahci.c
View file

@ -416,7 +416,7 @@ static int ahci_init_one(struct ahci_uc_priv *uc_priv, struct udevice *dev)
uc_priv->udma_mask = 0x7f; /*Fixme,assume to support UDMA6 */ uc_priv->udma_mask = 0x7f; /*Fixme,assume to support UDMA6 */
#if !defined(CONFIG_DM_SCSI) #if !defined(CONFIG_DM_SCSI)
uc_priv->mmio_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_5, uc_priv->mmio_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_5, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
/* Take from kernel: /* Take from kernel:
@ -1148,7 +1148,7 @@ int ahci_probe_scsi_pci(struct udevice *ahci_dev)
ulong base; ulong base;
u16 vendor, device; u16 vendor, device;
base = (ulong)dm_pci_map_bar(ahci_dev, PCI_BASE_ADDRESS_5, base = (ulong)dm_pci_map_bar(ahci_dev, PCI_BASE_ADDRESS_5, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
/* /*
@ -1163,7 +1163,7 @@ int ahci_probe_scsi_pci(struct udevice *ahci_dev)
if (vendor == PCI_VENDOR_ID_CAVIUM && if (vendor == PCI_VENDOR_ID_CAVIUM &&
device == PCI_DEVICE_ID_CAVIUM_SATA) device == PCI_DEVICE_ID_CAVIUM_SATA)
base = (uintptr_t)dm_pci_map_bar(ahci_dev, PCI_BASE_ADDRESS_0, base = (uintptr_t)dm_pci_map_bar(ahci_dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
return ahci_probe_scsi(ahci_dev, base); return ahci_probe_scsi(ahci_dev, base);
} }

4
drivers/ata/sata_sil.c
View file

@ -699,9 +699,9 @@ static int sil_pci_probe(struct udevice *dev)
/* Read out all BARs */ /* Read out all BARs */
sata_info.iobase[0] = (ulong)dm_pci_map_bar(dev, sata_info.iobase[0] = (ulong)dm_pci_map_bar(dev,
PCI_BASE_ADDRESS_0, PCI_REGION_MEM); PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_MEM);
sata_info.iobase[1] = (ulong)dm_pci_map_bar(dev, sata_info.iobase[1] = (ulong)dm_pci_map_bar(dev,
PCI_BASE_ADDRESS_2, PCI_REGION_MEM); PCI_BASE_ADDRESS_2, 0, 0, PCI_REGION_MEM);
/* mask out the unused bits */ /* mask out the unused bits */
sata_info.iobase[0] &= 0xffffff80; sata_info.iobase[0] &= 0xffffff80;

2
drivers/gpio/octeon_gpio.c
View file

@ -183,7 +183,7 @@ static int octeon_gpio_probe(struct udevice *dev)
priv->data = (const struct octeon_gpio_data *)dev_get_driver_data(dev); priv->data = (const struct octeon_gpio_data *)dev_get_driver_data(dev);
if (priv->data->probe == PROBE_PCI) { if (priv->data->probe == PROBE_PCI) {
priv->base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, priv->base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
uc_priv->gpio_count = readq(priv->base + uc_priv->gpio_count = readq(priv->base +
priv->data->reg_offs + GPIO_CONST) & priv->data->reg_offs + GPIO_CONST) &

2
drivers/i2c/designware_i2c_pci.c
View file

@ -59,7 +59,7 @@ static int designware_i2c_pci_of_to_plat(struct udevice *dev)
priv->regs = (struct i2c_regs *)dm_pci_read_bar32(dev, 0); priv->regs = (struct i2c_regs *)dm_pci_read_bar32(dev, 0);
} else { } else {
priv->regs = (struct i2c_regs *) priv->regs = (struct i2c_regs *)
dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, PCI_REGION_MEM); dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_MEM);
} }
if (!priv->regs) if (!priv->regs)
return -EINVAL; return -EINVAL;

2
drivers/i2c/intel_i2c.c
View file

@ -251,7 +251,7 @@ static int intel_i2c_probe(struct udevice *dev)
ulong base; ulong base;
/* Save base address from PCI BAR */ /* Save base address from PCI BAR */
priv->base = (ulong)dm_pci_map_bar(dev, PCI_BASE_ADDRESS_4, priv->base = (ulong)dm_pci_map_bar(dev, PCI_BASE_ADDRESS_4, 0, 0,
PCI_REGION_IO); PCI_REGION_IO);
base = priv->base; base = priv->base;

2
drivers/i2c/octeon_i2c.c
View file

@ -792,7 +792,7 @@ static int octeon_i2c_probe(struct udevice *dev)
debug("TWSI PCI device: %x\n", bdf); debug("TWSI PCI device: %x\n", bdf);
twsi->base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, twsi->base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
} else { } else {
twsi->base = dev_remap_addr(dev); twsi->base = dev_remap_addr(dev);

2
drivers/mmc/octeontx_hsmmc.c
View file

@ -3822,7 +3822,7 @@ static int octeontx_mmc_host_probe(struct udevice *dev)
/* Octeon TX & TX2 use PCI based probing */ /* Octeon TX & TX2 use PCI based probing */
if (device_is_compatible(dev, "cavium,thunder-8890-mmc")) { if (device_is_compatible(dev, "cavium,thunder-8890-mmc")) {
host->base_addr = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, host->base_addr = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
if (!host->base_addr) { if (!host->base_addr) {
pr_err("%s: Error: MMC base address not found\n", pr_err("%s: Error: MMC base address not found\n",

2
drivers/mmc/pci_mmc.c
View file

@ -50,7 +50,7 @@ static int pci_mmc_probe(struct udevice *dev)
desc = mmc_get_blk_desc(&plat->mmc); desc = mmc_get_blk_desc(&plat->mmc);
desc->removable = !(plat->cfg.host_caps & MMC_CAP_NONREMOVABLE); desc->removable = !(plat->cfg.host_caps & MMC_CAP_NONREMOVABLE);
host->ioaddr = (void *)dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, host->ioaddr = (void *)dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
host->name = dev->name; host->name = dev->name;
host->cd_gpio = priv->cd_gpio; host->cd_gpio = priv->cd_gpio;

4
drivers/mtd/nand/raw/octeontx_bch.c
View file

@ -176,7 +176,7 @@ static int octeontx_pci_bchpf_probe(struct udevice *dev)
if (!bch) if (!bch)
return -ENOMEM; return -ENOMEM;
bch->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, PCI_REGION_MEM); bch->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_MEM);
bch->dev = dev; bch->dev = dev;
debug("%s: base address: %p\n", __func__, bch->reg_base); debug("%s: base address: %p\n", __func__, bch->reg_base);
@ -361,7 +361,7 @@ static int octeontx_pci_bchvf_probe(struct udevice *dev)
vf->dev = dev; vf->dev = dev;
/* Map PF's configuration registers */ /* Map PF's configuration registers */
vf->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, PCI_REGION_MEM); vf->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_MEM);
debug("%s: reg base: %p\n", __func__, vf->reg_base); debug("%s: reg base: %p\n", __func__, vf->reg_base);
err = octeontx_cmd_queue_initialize(dev, QID_BCH, QDEPTH - 1, 0, err = octeontx_cmd_queue_initialize(dev, QID_BCH, QDEPTH - 1, 0,

2
drivers/mtd/nand/raw/octeontx_nand.c
View file

@ -2098,7 +2098,7 @@ static int octeontx_pci_nand_probe(struct udevice *dev)
tn->dev = dev; tn->dev = dev;
INIT_LIST_HEAD(&tn->chips); INIT_LIST_HEAD(&tn->chips);
tn->base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, PCI_REGION_MEM); tn->base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_MEM);
if (!tn->base) { if (!tn->base) {
ret = -EINVAL; ret = -EINVAL;
goto release; goto release;

6
drivers/net/bnxt/bnxt.c
View file

@ -28,9 +28,9 @@ static void bnxt_bring_pci(struct bnxt *bp)
dm_pci_read_config16(bp->pdev, PCI_SUBSYSTEM_ID, &bp->subsystem_device); dm_pci_read_config16(bp->pdev, PCI_SUBSYSTEM_ID, &bp->subsystem_device);
dm_pci_read_config16(bp->pdev, PCI_COMMAND, &bp->cmd_reg); dm_pci_read_config16(bp->pdev, PCI_COMMAND, &bp->cmd_reg);
dm_pci_read_config8(bp->pdev, PCI_INTERRUPT_LINE, &bp->irq); dm_pci_read_config8(bp->pdev, PCI_INTERRUPT_LINE, &bp->irq);
bp->bar0 = dm_pci_map_bar(bp->pdev, PCI_BASE_ADDRESS_0, PCI_REGION_MEM); bp->bar0 = dm_pci_map_bar(bp->pdev, PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_MEM);
bp->bar1 = dm_pci_map_bar(bp->pdev, PCI_BASE_ADDRESS_2, PCI_REGION_MEM); bp->bar1 = dm_pci_map_bar(bp->pdev, PCI_BASE_ADDRESS_2, 0, 0, PCI_REGION_MEM);
bp->bar2 = dm_pci_map_bar(bp->pdev, PCI_BASE_ADDRESS_4, PCI_REGION_MEM); bp->bar2 = dm_pci_map_bar(bp->pdev, PCI_BASE_ADDRESS_4, 0, 0, PCI_REGION_MEM);
cmd_reg = bp->cmd_reg | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER; cmd_reg = bp->cmd_reg | PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
cmd_reg |= PCI_COMMAND_INTX_DISABLE; /* disable intr */ cmd_reg |= PCI_COMMAND_INTX_DISABLE; /* disable intr */
dm_pci_write_config16(bp->pdev, PCI_COMMAND, cmd_reg); dm_pci_write_config16(bp->pdev, PCI_COMMAND, cmd_reg);

2
drivers/net/e1000.c
View file

@ -5549,7 +5549,7 @@ static int e1000_init_one(struct e1000_hw *hw, int cardnum, pci_dev_t devno,
hw->eeprom_semaphore_present = true; hw->eeprom_semaphore_present = true;
#endif #endif
#ifdef CONFIG_DM_ETH #ifdef CONFIG_DM_ETH
hw->hw_addr = dm_pci_map_bar(devno, PCI_BASE_ADDRESS_0, hw->hw_addr = dm_pci_map_bar(devno, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
#else #else
hw->hw_addr = pci_map_bar(devno, PCI_BASE_ADDRESS_0, hw->hw_addr = pci_map_bar(devno, PCI_BASE_ADDRESS_0,

2
drivers/net/fsl_enetc.c
View file

@ -339,7 +339,7 @@ static int enetc_probe(struct udevice *dev)
} }
/* initialize register */ /* initialize register */
priv->regs_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0); priv->regs_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0, 0);
if (!priv->regs_base) { if (!priv->regs_base) {
enetc_dbg(dev, "failed to map BAR0\n"); enetc_dbg(dev, "failed to map BAR0\n");
return -EINVAL; return -EINVAL;

2
drivers/net/fsl_enetc_mdio.c
View file

@ -125,7 +125,7 @@ static int enetc_mdio_probe(struct udevice *dev)
{ {
struct enetc_mdio_priv *priv = dev_get_priv(dev); struct enetc_mdio_priv *priv = dev_get_priv(dev);
priv->regs_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0); priv->regs_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0, 0);
if (!priv->regs_base) { if (!priv->regs_base) {
enetc_dbg(dev, "failed to map BAR0\n"); enetc_dbg(dev, "failed to map BAR0\n");
return -EINVAL; return -EINVAL;

4
drivers/net/mscc_eswitch/felix_switch.c
View file

@ -292,13 +292,13 @@ static int felix_probe(struct udevice *dev)
return -ENODEV; return -ENODEV;
} }
priv->imdio_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0); priv->imdio_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0, 0);
if (!priv->imdio_base) { if (!priv->imdio_base) {
dev_err(dev, "failed to map BAR0\n"); dev_err(dev, "failed to map BAR0\n");
return -EINVAL; return -EINVAL;
} }
priv->regs_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_4, 0); priv->regs_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_4, 0, 0, 0);
if (!priv->regs_base) { if (!priv->regs_base) {
dev_err(dev, "failed to map BAR4\n"); dev_err(dev, "failed to map BAR4\n");
return -EINVAL; return -EINVAL;

2
drivers/net/octeontx/bgx.c
View file

@ -1458,7 +1458,7 @@ int octeontx_bgx_probe(struct udevice *dev)
int bgx_idx, node; int bgx_idx, node;
int inc = 1; int inc = 1;
bgx->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, bgx->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
if (!bgx->reg_base) { if (!bgx->reg_base) {
debug("No PCI region found\n"); debug("No PCI region found\n");

2
drivers/net/octeontx/nic_main.c
View file

@ -713,7 +713,7 @@ int nic_initialize(struct udevice *dev)
return -ENOMEM; return -ENOMEM;
/* MAP PF's configuration registers */ /* MAP PF's configuration registers */
nic->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, nic->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
if (!nic->reg_base) { if (!nic->reg_base) {
printf("Cannot map config register space, aborting\n"); printf("Cannot map config register space, aborting\n");

2
drivers/net/octeontx/nicvf_main.c
View file

@ -509,7 +509,7 @@ int nicvf_initialize(struct udevice *dev)
/* Enable TSO support */ /* Enable TSO support */
nicvf->hw_tso = true; nicvf->hw_tso = true;
nicvf->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, nicvf->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
debug("nicvf->reg_base: %p\n", nicvf->reg_base); debug("nicvf->reg_base: %p\n", nicvf->reg_base);

2
drivers/net/octeontx/smi.c
View file

@ -322,7 +322,7 @@ int octeontx_smi_probe(struct udevice *dev)
u64 baseaddr; u64 baseaddr;
debug("SMI PCI device: %x\n", bdf); debug("SMI PCI device: %x\n", bdf);
if (!dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, PCI_REGION_MEM)) { if (!dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_MEM)) {
printf("Failed to map PCI region for bdf %x\n", bdf); printf("Failed to map PCI region for bdf %x\n", bdf);
return -1; return -1;
} }

2
drivers/net/octeontx2/cgx.c
View file

@ -253,7 +253,7 @@ int cgx_probe(struct udevice *dev)
struct cgx *cgx = dev_get_priv(dev); struct cgx *cgx = dev_get_priv(dev);
int err; int err;
cgx->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, cgx->reg_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
cgx->dev = dev; cgx->dev = dev;
cgx->cgx_id = ((u64)(cgx->reg_base) >> 24) & 0x7; cgx->cgx_id = ((u64)(cgx->reg_base) >> 24) & 0x7;

2
drivers/net/octeontx2/rvu_af.c
View file

@ -127,7 +127,7 @@ int rvu_af_probe(struct udevice *dev)
{ {
struct rvu_af *af_ptr = dev_get_priv(dev); struct rvu_af *af_ptr = dev_get_priv(dev);
af_ptr->af_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, af_ptr->af_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
debug("%s RVU AF BAR %p\n", __func__, af_ptr->af_base); debug("%s RVU AF BAR %p\n", __func__, af_ptr->af_base);
af_ptr->dev = dev; af_ptr->dev = dev;

2
drivers/net/octeontx2/rvu_pf.c
View file

@ -58,7 +58,7 @@ int rvu_pf_probe(struct udevice *dev)
debug("%s: name: %s\n", __func__, dev->name); debug("%s: name: %s\n", __func__, dev->name);
rvu->pf_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_2, PCI_REGION_MEM); rvu->pf_base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_2, 0, 0, PCI_REGION_MEM);
rvu->pfid = dev_seq(dev) + 1; // RVU PF's start from 1; rvu->pfid = dev_seq(dev) + 1; // RVU PF's start from 1;
rvu->dev = dev; rvu->dev = dev;
if (!rvu_af_dev) { if (!rvu_af_dev) {

2
drivers/net/pch_gbe.c
View file

@ -449,7 +449,7 @@ static int pch_gbe_probe(struct udevice *dev)
priv->dev = dev; priv->dev = dev;
iobase = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_1, PCI_REGION_MEM); iobase = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_1, 0, 0, PCI_REGION_MEM);
plat->iobase = (ulong)iobase; plat->iobase = (ulong)iobase;
priv->mac_regs = (struct pch_gbe_regs *)iobase; priv->mac_regs = (struct pch_gbe_regs *)iobase;

2
drivers/nvme/nvme_pci.c
View file

@ -28,7 +28,7 @@ static int nvme_probe(struct udevice *udev)
sprintf(ndev->vendor, "0x%.4x", pplat->vendor); sprintf(ndev->vendor, "0x%.4x", pplat->vendor);
ndev->instance = trailing_strtol(udev->name); ndev->instance = trailing_strtol(udev->name);
ndev->bar = dm_pci_map_bar(udev, PCI_BASE_ADDRESS_0, ndev->bar = dm_pci_map_bar(udev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
return nvme_init(udev); return nvme_init(udev);
} }

27
drivers/pci/pci-uclass.c
View file

@ -1561,7 +1561,8 @@ static phys_addr_t dm_pci_map_ea_virt(struct udevice *dev, int ea_off,
return addr; return addr;
} }
static void *dm_pci_map_ea_bar(struct udevice *dev, int bar, int ea_off, static void *dm_pci_map_ea_bar(struct udevice *dev, int bar, size_t offset,
size_t len, int ea_off,
struct pci_child_plat *pdata) struct pci_child_plat *pdata)
{ {
int ea_cnt, i, entry_size; int ea_cnt, i, entry_size;
@ -1604,14 +1605,18 @@ static void *dm_pci_map_ea_bar(struct udevice *dev, int bar, int ea_off,
if (IS_ENABLED(CONFIG_PCI_SRIOV)) if (IS_ENABLED(CONFIG_PCI_SRIOV))
addr += dm_pci_map_ea_virt(dev, ea_off, pdata); addr += dm_pci_map_ea_virt(dev, ea_off, pdata);
if (~((phys_addr_t)0) - addr < offset)
return NULL;
/* size ignored for now */ /* size ignored for now */
return map_physmem(addr, 0, MAP_NOCACHE); return map_physmem(addr + offset, len, MAP_NOCACHE);
} }
return 0; return 0;
} }
void *dm_pci_map_bar(struct udevice *dev, int bar, unsigned long flags) void *dm_pci_map_bar(struct udevice *dev, int bar, size_t offset, size_t len,
unsigned long flags)
{ {
struct pci_child_plat *pdata = dev_get_parent_plat(dev); struct pci_child_plat *pdata = dev_get_parent_plat(dev);
struct udevice *udev = dev; struct udevice *udev = dev;
@ -1636,19 +1641,23 @@ void *dm_pci_map_bar(struct udevice *dev, int bar, unsigned long flags)
*/ */
ea_off = dm_pci_find_capability(udev, PCI_CAP_ID_EA); ea_off = dm_pci_find_capability(udev, PCI_CAP_ID_EA);
if (ea_off) if (ea_off)
return dm_pci_map_ea_bar(udev, bar, ea_off, pdata); return dm_pci_map_ea_bar(udev, bar, offset, len, ea_off, pdata);
/* read BAR address */ /* read BAR address */
dm_pci_read_config32(udev, bar, &bar_response); dm_pci_read_config32(udev, bar, &bar_response);
pci_bus_addr = (pci_addr_t)(bar_response & ~0xf); pci_bus_addr = (pci_addr_t)(bar_response & ~0xf);
if (~((pci_addr_t)0) - pci_bus_addr < offset)
return NULL;
/* /*
* Pass "0" as the length argument to pci_bus_to_virt. The arg * Forward the length argument to dm_pci_bus_to_virt. The length will
* isn't actually used on any platform because U-Boot assumes a static * be used to check that the entire address range has been declared as
* linear mapping. In the future, this could read the BAR size * a PCI range, but a better check would be to probe for the size of
* and pass that as the size if needed. * the bar and prevent overflow more locally.
*/ */
return dm_pci_bus_to_virt(udev, pci_bus_addr, flags, 0, MAP_NOCACHE); return dm_pci_bus_to_virt(udev, pci_bus_addr + offset, flags, len,
MAP_NOCACHE);
} }
static int _dm_pci_find_next_capability(struct udevice *dev, u8 pos, int cap) static int _dm_pci_find_next_capability(struct udevice *dev, u8 pos, int cap)

2
drivers/spi/octeon_spi.c
View file

@ -568,7 +568,7 @@ static int octeon_spi_probe(struct udevice *dev)
pci_dev_t bdf = dm_pci_get_bdf(dev); pci_dev_t bdf = dm_pci_get_bdf(dev);
debug("SPI PCI device: %x\n", bdf); debug("SPI PCI device: %x\n", bdf);
priv->base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, priv->base = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0,
PCI_REGION_MEM); PCI_REGION_MEM);
/* Add base offset */ /* Add base offset */
priv->base += 0x1000; priv->base += 0x1000;

2
drivers/usb/host/ehci-pci.c
View file

@ -36,7 +36,7 @@ static int ehci_pci_init(struct udevice *dev, struct ehci_hccr **ret_hccr,
return ret; return ret;
hccr = (struct ehci_hccr *)dm_pci_map_bar(dev, hccr = (struct ehci_hccr *)dm_pci_map_bar(dev,
PCI_BASE_ADDRESS_0, PCI_REGION_MEM); PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_MEM);
hcor = (struct ehci_hcor *)((uintptr_t) hccr + hcor = (struct ehci_hcor *)((uintptr_t) hccr +
HC_LENGTH(ehci_readl(&hccr->cr_capbase))); HC_LENGTH(ehci_readl(&hccr->cr_capbase)));

2
drivers/usb/host/ohci-pci.c
View file

@ -18,7 +18,7 @@ static int ohci_pci_probe(struct udevice *dev)
{ {
struct ohci_regs *regs; struct ohci_regs *regs;
regs = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, PCI_REGION_MEM); regs = dm_pci_map_bar(dev, PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_MEM);
return ohci_register(dev, regs); return ohci_register(dev, regs);
} }

2
drivers/usb/host/xhci-pci.c
View file

@ -27,7 +27,7 @@ static int xhci_pci_init(struct udevice *dev, struct xhci_hccr **ret_hccr,
u32 cmd; u32 cmd;
hccr = (struct xhci_hccr *)dm_pci_map_bar(dev, hccr = (struct xhci_hccr *)dm_pci_map_bar(dev,
PCI_BASE_ADDRESS_0, PCI_REGION_MEM); PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_MEM);
if (!hccr) { if (!hccr) {
printf("xhci-pci init cannot map PCI mem bar\n"); printf("xhci-pci init cannot map PCI mem bar\n");
return -EIO; return -EIO;

2
drivers/virtio/virtio_pci_legacy.c
View file

@ -319,7 +319,7 @@ static int virtio_pci_probe(struct udevice *udev)
uc_priv->device = subdevice; uc_priv->device = subdevice;
uc_priv->vendor = subvendor; uc_priv->vendor = subvendor;
priv->ioaddr = dm_pci_map_bar(udev, PCI_BASE_ADDRESS_0, PCI_REGION_IO); priv->ioaddr = dm_pci_map_bar(udev, PCI_BASE_ADDRESS_0, 0, 0, PCI_REGION_IO);
if (!priv->ioaddr) if (!priv->ioaddr)
return -ENXIO; return -ENXIO;
debug("(%s): virtio legacy device reg base %04lx\n", debug("(%s): virtio legacy device reg base %04lx\n",

5
include/pci.h
View file

@ -1348,10 +1348,13 @@ pci_addr_t dm_pci_phys_to_bus(struct udevice *dev, phys_addr_t addr, size_t len,
* *
* @dev: Device to check * @dev: Device to check
* @bar: Bar register offset (PCI_BASE_ADDRESS_...) * @bar: Bar register offset (PCI_BASE_ADDRESS_...)
* @offset: Offset from the base to map
* @len: Length to map
* @flags: Flags for the region type (PCI_REGION_...) * @flags: Flags for the region type (PCI_REGION_...)
* @return: pointer to the virtual address to use or 0 on error * @return: pointer to the virtual address to use or 0 on error
*/ */
void *dm_pci_map_bar(struct udevice *dev, int bar, unsigned long flags); void *dm_pci_map_bar(struct udevice *dev, int bar, size_t offset, size_t len,
unsigned long flags);
/** /**
* dm_pci_find_next_capability() - find a capability starting from an offset * dm_pci_find_next_capability() - find a capability starting from an offset

12
test/dm/pci.c
View file

@ -268,27 +268,27 @@ static int dm_test_pci_ea(struct unit_test_state *uts)
ut_asserteq(PCI_CAP_ID_EA_OFFSET, cap); ut_asserteq(PCI_CAP_ID_EA_OFFSET, cap);
/* test swap case in BAR 1 */ /* test swap case in BAR 1 */
bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_0, 0); bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_0, 0, 0, 0);
ut_assertnonnull(bar); ut_assertnonnull(bar);
*(int *)bar = 2; /* swap upper/lower */ *(int *)bar = 2; /* swap upper/lower */
bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_1, 0); bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_1, 0, 0, 0);
ut_assertnonnull(bar); ut_assertnonnull(bar);
strcpy(bar, "ea TEST"); strcpy(bar, "ea TEST");
unmap_sysmem(bar); unmap_sysmem(bar);
bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_1, 0); bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_1, 0, 0, 0);
ut_assertnonnull(bar); ut_assertnonnull(bar);
ut_asserteq_str("EA test", bar); ut_asserteq_str("EA test", bar);
/* test magic values in BARs2, 4; BAR 3 is n/a */ /* test magic values in BARs2, 4; BAR 3 is n/a */
bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_2, 0); bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_2, 0, 0, 0);
ut_assertnonnull(bar); ut_assertnonnull(bar);
ut_asserteq(PCI_EA_BAR2_MAGIC, *(u32 *)bar); ut_asserteq(PCI_EA_BAR2_MAGIC, *(u32 *)bar);
bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_3, 0); bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_3, 0, 0, 0);
ut_assertnull(bar); ut_assertnull(bar);
bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_4, 0); bar = dm_pci_map_bar(swap, PCI_BASE_ADDRESS_4, 0, 0, 0);
ut_assertnonnull(bar); ut_assertnonnull(bar);
ut_asserteq(PCI_EA_BAR4_MAGIC, *(u32 *)bar); ut_asserteq(PCI_EA_BAR4_MAGIC, *(u32 *)bar);