microsoft
/
WSL2-Linux-Kernel
зеркало из https://github.com/microsoft/WSL2-Linux-Kernel.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Merge branch 'pci/host-designware' into next 

* pci/host-designware:
  PCI: designware-plat: Remove unused platform data
  PCI: designware-plat: Add local struct device pointers
  PCI: designware-plat: Remove redundant dw_plat_pcie.mem_base
  PCI: designware: Swap order of dw_pcie_writel_unroll() reg/val arguments
  PCI: designware: Uninline register accessors
  PCI: designware: Export dw_pcie_readl_rc(), dw_pcie_writel_rc()
  PCI: designware: Swap order of dw_pcie_writel_rc() reg/val arguments
  PCI: designware: Simplify pcie_host_ops.readl_rc() and .writel_rc() interfaces
  PCI: designware: Simplify dw_pcie_readl_unroll(), dw_pcie_writel_unroll()
  PCI: designware: Rename dw_pcie_valid_config() to dw_pcie_valid_device()
This commit is contained in:
Bjorn Helgaas 2016-10-12 11:14:58 -05:00
Родитель dd5bba52d3 4c9441d1e6
Коммит 22c7e1d4b4
4 изменённых файлов: 67 добавлений и 77 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

10
drivers/pci/host/pci-exynos.c
Просмотреть файл

@ -425,22 +425,20 @@ static void exynos_pcie_enable_interrupts(struct pcie_port *pp)
exynos_pcie_msi_init(pp); exynos_pcie_msi_init(pp);
} }
static inline u32 exynos_pcie_readl_rc(struct pcie_port *pp, static inline u32 exynos_pcie_readl_rc(struct pcie_port *pp, u32 reg)
void __iomem *dbi_base)
{ {
u32 val; u32 val;
exynos_pcie_sideband_dbi_r_mode(pp, true); exynos_pcie_sideband_dbi_r_mode(pp, true);
val = readl(dbi_base); val = readl(pp->dbi_base + reg);
exynos_pcie_sideband_dbi_r_mode(pp, false); exynos_pcie_sideband_dbi_r_mode(pp, false);
return val; return val;
} }
static inline void exynos_pcie_writel_rc(struct pcie_port *pp, static inline void exynos_pcie_writel_rc(struct pcie_port *pp, u32 reg, u32 val)
u32 val, void __iomem *dbi_base)
{ {
exynos_pcie_sideband_dbi_w_mode(pp, true); exynos_pcie_sideband_dbi_w_mode(pp, true);
writel(val, dbi_base); writel(val, pp->dbi_base + reg);
exynos_pcie_sideband_dbi_w_mode(pp, false); exynos_pcie_sideband_dbi_w_mode(pp, false);
} }

25
drivers/pci/host/pcie-designware-plat.c
Просмотреть файл

@ -25,8 +25,7 @@
#include "pcie-designware.h" #include "pcie-designware.h"
struct dw_plat_pcie { struct dw_plat_pcie {
void __iomem *mem_base; struct pcie_port pp; /* pp.dbi_base is DT 0th resource */
struct pcie_port pp;
}; };
static irqreturn_t dw_plat_pcie_msi_irq_handler(int irq, void *arg) static irqreturn_t dw_plat_pcie_msi_irq_handler(int irq, void *arg)
@ -52,6 +51,7 @@ static struct pcie_host_ops dw_plat_pcie_host_ops = {
static int dw_plat_add_pcie_port(struct pcie_port *pp, static int dw_plat_add_pcie_port(struct pcie_port *pp,
struct platform_device *pdev) struct platform_device *pdev)
{ {
struct device *dev = pp->dev;
int ret; int ret;
pp->irq = platform_get_irq(pdev, 1); pp->irq = platform_get_irq(pdev, 1);
@ -63,11 +63,11 @@ static int dw_plat_add_pcie_port(struct pcie_port *pp,
if (pp->msi_irq < 0) if (pp->msi_irq < 0)
return pp->msi_irq; return pp->msi_irq;
ret = devm_request_irq(&pdev->dev, pp->msi_irq, ret = devm_request_irq(dev, pp->msi_irq,
dw_plat_pcie_msi_irq_handler, dw_plat_pcie_msi_irq_handler,
IRQF_SHARED, "dw-plat-pcie-msi", pp); IRQF_SHARED, "dw-plat-pcie-msi", pp);
if (ret) { if (ret) {
dev_err(&pdev->dev, "failed to request MSI IRQ\n"); dev_err(dev, "failed to request MSI IRQ\n");
return ret; return ret;
} }
} }
@ -77,7 +77,7 @@ static int dw_plat_add_pcie_port(struct pcie_port *pp,
ret = dw_pcie_host_init(pp); ret = dw_pcie_host_init(pp);
if (ret) { if (ret) {
dev_err(&pdev->dev, "failed to initialize host\n"); dev_err(dev, "failed to initialize host\n");
return ret; return ret;
} }
@ -86,31 +86,28 @@ static int dw_plat_add_pcie_port(struct pcie_port *pp,
static int dw_plat_pcie_probe(struct platform_device *pdev) static int dw_plat_pcie_probe(struct platform_device *pdev)
{ {
struct device *dev = &pdev->dev;
struct dw_plat_pcie *dw_plat_pcie; struct dw_plat_pcie *dw_plat_pcie;
struct pcie_port *pp; struct pcie_port *pp;
struct resource *res; /* Resource from DT */ struct resource *res; /* Resource from DT */
int ret; int ret;
dw_plat_pcie = devm_kzalloc(&pdev->dev, sizeof(*dw_plat_pcie), dw_plat_pcie = devm_kzalloc(dev, sizeof(*dw_plat_pcie), GFP_KERNEL);
GFP_KERNEL);
if (!dw_plat_pcie) if (!dw_plat_pcie)
return -ENOMEM; return -ENOMEM;
pp = &dw_plat_pcie->pp; pp = &dw_plat_pcie->pp;
pp->dev = &pdev->dev; pp->dev = dev;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0); res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
dw_plat_pcie->mem_base = devm_ioremap_resource(&pdev->dev, res); pp->dbi_base = devm_ioremap_resource(dev, res);
if (IS_ERR(dw_plat_pcie->mem_base)) if (IS_ERR(pp->dbi_base))
return PTR_ERR(dw_plat_pcie->mem_base); return PTR_ERR(pp->dbi_base);
pp->dbi_base = dw_plat_pcie->mem_base;
ret = dw_plat_add_pcie_port(pp, pdev); ret = dw_plat_add_pcie_port(pp, pdev);
if (ret < 0) if (ret < 0)
return ret; return ret;
platform_set_drvdata(pdev, dw_plat_pcie);
return 0; return 0;
} }

102
drivers/pci/host/pcie-designware.c
Просмотреть файл

@ -141,41 +141,35 @@ int dw_pcie_cfg_write(void __iomem *addr, int size, u32 val)
return PCIBIOS_SUCCESSFUL; return PCIBIOS_SUCCESSFUL;
} }
static inline u32 dw_pcie_readl_rc(struct pcie_port *pp, u32 reg) u32 dw_pcie_readl_rc(struct pcie_port *pp, u32 reg)
{ {
if (pp->ops->readl_rc) if (pp->ops->readl_rc)
return pp->ops->readl_rc(pp, pp->dbi_base + reg); return pp->ops->readl_rc(pp, reg);
return readl(pp->dbi_base + reg); return readl(pp->dbi_base + reg);
} }
static inline void dw_pcie_writel_rc(struct pcie_port *pp, u32 val, u32 reg) void dw_pcie_writel_rc(struct pcie_port *pp, u32 reg, u32 val)
{ {
if (pp->ops->writel_rc) if (pp->ops->writel_rc)
pp->ops->writel_rc(pp, val, pp->dbi_base + reg); pp->ops->writel_rc(pp, reg, val);
else else
writel(val, pp->dbi_base + reg); writel(val, pp->dbi_base + reg);
} }
static inline u32 dw_pcie_readl_unroll(struct pcie_port *pp, u32 index, u32 reg) static u32 dw_pcie_readl_unroll(struct pcie_port *pp, u32 index, u32 reg)
{ {
u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index); u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);
if (pp->ops->readl_rc) return dw_pcie_readl_rc(pp, offset + reg);
return pp->ops->readl_rc(pp, pp->dbi_base + offset + reg);
return readl(pp->dbi_base + offset + reg);
} }
static inline void dw_pcie_writel_unroll(struct pcie_port *pp, u32 index, static void dw_pcie_writel_unroll(struct pcie_port *pp, u32 index, u32 reg,
u32 val, u32 reg) u32 val)
{ {
u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index); u32 offset = PCIE_GET_ATU_OUTB_UNR_REG_OFFSET(index);
if (pp->ops->writel_rc) dw_pcie_writel_rc(pp, offset + reg, val);
pp->ops->writel_rc(pp, val, pp->dbi_base + offset + reg);
else
writel(val, pp->dbi_base + offset + reg);
} }
static int dw_pcie_rd_own_conf(struct pcie_port *pp, int where, int size, static int dw_pcie_rd_own_conf(struct pcie_port *pp, int where, int size,
@ -202,35 +196,35 @@ static void dw_pcie_prog_outbound_atu(struct pcie_port *pp, int index,
u32 retries, val; u32 retries, val;
if (pp->iatu_unroll_enabled) { if (pp->iatu_unroll_enabled) {
dw_pcie_writel_unroll(pp, index, dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_LOWER_BASE,
lower_32_bits(cpu_addr), PCIE_ATU_UNR_LOWER_BASE); lower_32_bits(cpu_addr));
dw_pcie_writel_unroll(pp, index, dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_UPPER_BASE,
upper_32_bits(cpu_addr), PCIE_ATU_UNR_UPPER_BASE); upper_32_bits(cpu_addr));
dw_pcie_writel_unroll(pp, index, dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_LIMIT,
lower_32_bits(cpu_addr + size - 1), PCIE_ATU_UNR_LIMIT); lower_32_bits(cpu_addr + size - 1));
dw_pcie_writel_unroll(pp, index, dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_LOWER_TARGET,
lower_32_bits(pci_addr), PCIE_ATU_UNR_LOWER_TARGET); lower_32_bits(pci_addr));
dw_pcie_writel_unroll(pp, index, dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_UPPER_TARGET,
upper_32_bits(pci_addr), PCIE_ATU_UNR_UPPER_TARGET); upper_32_bits(pci_addr));
dw_pcie_writel_unroll(pp, index, dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_REGION_CTRL1,
type, PCIE_ATU_UNR_REGION_CTRL1); type);
dw_pcie_writel_unroll(pp, index, dw_pcie_writel_unroll(pp, index, PCIE_ATU_UNR_REGION_CTRL2,
PCIE_ATU_ENABLE, PCIE_ATU_UNR_REGION_CTRL2); PCIE_ATU_ENABLE);
} else { } else {
dw_pcie_writel_rc(pp, PCIE_ATU_REGION_OUTBOUND | index, dw_pcie_writel_rc(pp, PCIE_ATU_VIEWPORT,
PCIE_ATU_VIEWPORT); PCIE_ATU_REGION_OUTBOUND | index);
dw_pcie_writel_rc(pp, lower_32_bits(cpu_addr), dw_pcie_writel_rc(pp, PCIE_ATU_LOWER_BASE,
PCIE_ATU_LOWER_BASE); lower_32_bits(cpu_addr));
dw_pcie_writel_rc(pp, upper_32_bits(cpu_addr), dw_pcie_writel_rc(pp, PCIE_ATU_UPPER_BASE,
PCIE_ATU_UPPER_BASE); upper_32_bits(cpu_addr));
dw_pcie_writel_rc(pp, lower_32_bits(cpu_addr + size - 1), dw_pcie_writel_rc(pp, PCIE_ATU_LIMIT,
PCIE_ATU_LIMIT); lower_32_bits(cpu_addr + size - 1));
dw_pcie_writel_rc(pp, lower_32_bits(pci_addr), dw_pcie_writel_rc(pp, PCIE_ATU_LOWER_TARGET,
PCIE_ATU_LOWER_TARGET); lower_32_bits(pci_addr));
dw_pcie_writel_rc(pp, upper_32_bits(pci_addr), dw_pcie_writel_rc(pp, PCIE_ATU_UPPER_TARGET,
PCIE_ATU_UPPER_TARGET); upper_32_bits(pci_addr));
dw_pcie_writel_rc(pp, type, PCIE_ATU_CR1); dw_pcie_writel_rc(pp, PCIE_ATU_CR1, type);
dw_pcie_writel_rc(pp, PCIE_ATU_ENABLE, PCIE_ATU_CR2); dw_pcie_writel_rc(pp, PCIE_ATU_CR2, PCIE_ATU_ENABLE);
} }
/* /*
@ -760,8 +754,8 @@ static int dw_pcie_wr_other_conf(struct pcie_port *pp, struct pci_bus *bus,
return ret; return ret;
} }
static int dw_pcie_valid_config(struct pcie_port *pp, static int dw_pcie_valid_device(struct pcie_port *pp, struct pci_bus *bus,
struct pci_bus *bus, int dev) int dev)
{ {
/* If there is no link, then there is no device */ /* If there is no link, then there is no device */
if (bus->number != pp->root_bus_nr) { if (bus->number != pp->root_bus_nr) {
@ -781,7 +775,7 @@ static int dw_pcie_rd_conf(struct pci_bus *bus, u32 devfn, int where,
{ {
struct pcie_port *pp = bus->sysdata; struct pcie_port *pp = bus->sysdata;
if (dw_pcie_valid_config(pp, bus, PCI_SLOT(devfn)) == 0) { if (!dw_pcie_valid_device(pp, bus, PCI_SLOT(devfn))) {
*val = 0xffffffff; *val = 0xffffffff;
return PCIBIOS_DEVICE_NOT_FOUND; return PCIBIOS_DEVICE_NOT_FOUND;
} }
@ -797,7 +791,7 @@ static int dw_pcie_wr_conf(struct pci_bus *bus, u32 devfn,
{ {
struct pcie_port *pp = bus->sysdata; struct pcie_port *pp = bus->sysdata;
if (dw_pcie_valid_config(pp, bus, PCI_SLOT(devfn)) == 0) if (!dw_pcie_valid_device(pp, bus, PCI_SLOT(devfn)))
return PCIBIOS_DEVICE_NOT_FOUND; return PCIBIOS_DEVICE_NOT_FOUND;
if (bus->number == pp->root_bus_nr) if (bus->number == pp->root_bus_nr)
@ -835,7 +829,7 @@ void dw_pcie_setup_rc(struct pcie_port *pp)
dev_err(pp->dev, "num-lanes %u: invalid value\n", pp->lanes); dev_err(pp->dev, "num-lanes %u: invalid value\n", pp->lanes);
return; return;
} }
dw_pcie_writel_rc(pp, val, PCIE_PORT_LINK_CONTROL); dw_pcie_writel_rc(pp, PCIE_PORT_LINK_CONTROL, val);
/* set link width speed control register */ /* set link width speed control register */
val = dw_pcie_readl_rc(pp, PCIE_LINK_WIDTH_SPEED_CONTROL); val = dw_pcie_readl_rc(pp, PCIE_LINK_WIDTH_SPEED_CONTROL);
@ -854,30 +848,30 @@ void dw_pcie_setup_rc(struct pcie_port *pp)
val |= PORT_LOGIC_LINK_WIDTH_8_LANES; val |= PORT_LOGIC_LINK_WIDTH_8_LANES;
break; break;
} }
dw_pcie_writel_rc(pp, val, PCIE_LINK_WIDTH_SPEED_CONTROL); dw_pcie_writel_rc(pp, PCIE_LINK_WIDTH_SPEED_CONTROL, val);
/* setup RC BARs */ /* setup RC BARs */
dw_pcie_writel_rc(pp, 0x00000004, PCI_BASE_ADDRESS_0); dw_pcie_writel_rc(pp, PCI_BASE_ADDRESS_0, 0x00000004);
dw_pcie_writel_rc(pp, 0x00000000, PCI_BASE_ADDRESS_1); dw_pcie_writel_rc(pp, PCI_BASE_ADDRESS_1, 0x00000000);
/* setup interrupt pins */ /* setup interrupt pins */
val = dw_pcie_readl_rc(pp, PCI_INTERRUPT_LINE); val = dw_pcie_readl_rc(pp, PCI_INTERRUPT_LINE);
val &= 0xffff00ff; val &= 0xffff00ff;
val |= 0x00000100; val |= 0x00000100;
dw_pcie_writel_rc(pp, val, PCI_INTERRUPT_LINE); dw_pcie_writel_rc(pp, PCI_INTERRUPT_LINE, val);
/* setup bus numbers */ /* setup bus numbers */
val = dw_pcie_readl_rc(pp, PCI_PRIMARY_BUS); val = dw_pcie_readl_rc(pp, PCI_PRIMARY_BUS);
val &= 0xff000000; val &= 0xff000000;
val |= 0x00010100; val |= 0x00010100;
dw_pcie_writel_rc(pp, val, PCI_PRIMARY_BUS); dw_pcie_writel_rc(pp, PCI_PRIMARY_BUS, val);
/* setup command register */ /* setup command register */
val = dw_pcie_readl_rc(pp, PCI_COMMAND); val = dw_pcie_readl_rc(pp, PCI_COMMAND);
val &= 0xffff0000; val &= 0xffff0000;
val |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY | val |= PCI_COMMAND_IO | PCI_COMMAND_MEMORY |
PCI_COMMAND_MASTER | PCI_COMMAND_SERR; PCI_COMMAND_MASTER | PCI_COMMAND_SERR;
dw_pcie_writel_rc(pp, val, PCI_COMMAND); dw_pcie_writel_rc(pp, PCI_COMMAND, val);
/* /*
* If the platform provides ->rd_other_conf, it means the platform * If the platform provides ->rd_other_conf, it means the platform

7
drivers/pci/host/pcie-designware.h
Просмотреть файл

@ -54,9 +54,8 @@ struct pcie_port {
}; };
struct pcie_host_ops { struct pcie_host_ops {
u32 (*readl_rc)(struct pcie_port *pp, void __iomem *dbi_base); u32 (*readl_rc)(struct pcie_port *pp, u32 reg);
void (*writel_rc)(struct pcie_port *pp, void (*writel_rc)(struct pcie_port *pp, u32 reg, u32 val);
u32 val, void __iomem *dbi_base);
int (*rd_own_conf)(struct pcie_port *pp, int where, int size, u32 *val); int (*rd_own_conf)(struct pcie_port *pp, int where, int size, u32 *val);
int (*wr_own_conf)(struct pcie_port *pp, int where, int size, u32 val); int (*wr_own_conf)(struct pcie_port *pp, int where, int size, u32 val);
int (*rd_other_conf)(struct pcie_port *pp, struct pci_bus *bus, int (*rd_other_conf)(struct pcie_port *pp, struct pci_bus *bus,
@ -73,6 +72,8 @@ struct pcie_host_ops {
int (*msi_host_init)(struct pcie_port *pp, struct msi_controller *chip); int (*msi_host_init)(struct pcie_port *pp, struct msi_controller *chip);
}; };
u32 dw_pcie_readl_rc(struct pcie_port *pp, u32 reg);
void dw_pcie_writel_rc(struct pcie_port *pp, u32 reg, u32 val);
int dw_pcie_cfg_read(void __iomem *addr, int size, u32 *val); int dw_pcie_cfg_read(void __iomem *addr, int size, u32 *val);
int dw_pcie_cfg_write(void __iomem *addr, int size, u32 val); int dw_pcie_cfg_write(void __iomem *addr, int size, u32 val);
irqreturn_t dw_handle_msi_irq(struct pcie_port *pp); irqreturn_t dw_handle_msi_irq(struct pcie_port *pp);