* [PATCH 01/10] PCI: rcar: Rename accessors
@ 2016-10-07 16:24 Bjorn Helgaas
2016-10-07 16:24 ` [PATCH 02/10] PCI: rcar: Name private struct pointer "rcar" consistently Bjorn Helgaas
` (9 more replies)
0 siblings, 10 replies; 11+ messages in thread
From: Bjorn Helgaas @ 2016-10-07 16:24 UTC (permalink / raw)
To: Simon Horman; +Cc: linux-renesas-soc, linux-pci
Rename rcar_pci_read_reg() to rcar_readl() and rcar_pci_write_reg() to
rcar_writel() for consistency with other drivers. No functional change
intended.
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
drivers/pci/host/pcie-rcar.c | 142 ++++++++++++++++++++----------------------
1 file changed, 68 insertions(+), 74 deletions(-)
diff --git a/drivers/pci/host/pcie-rcar.c b/drivers/pci/host/pcie-rcar.c
index e06b1d3..b6899c8 100644
--- a/drivers/pci/host/pcie-rcar.c
+++ b/drivers/pci/host/pcie-rcar.c
@@ -152,16 +152,15 @@ struct rcar_pcie {
struct rcar_msi msi;
};
-static void rcar_pci_write_reg(struct rcar_pcie *pcie, unsigned long val,
- unsigned long reg)
+static unsigned long rcar_readl(struct rcar_pcie *pcie, unsigned long reg)
{
- writel(val, pcie->base + reg);
+ return readl(pcie->base + reg);
}
-static unsigned long rcar_pci_read_reg(struct rcar_pcie *pcie,
- unsigned long reg)
+static void rcar_writel(struct rcar_pcie *pcie, unsigned long val,
+ unsigned long reg)
{
- return readl(pcie->base + reg);
+ writel(val, pcie->base + reg);
}
enum {
@@ -172,17 +171,17 @@ enum {
static void rcar_rmw32(struct rcar_pcie *pcie, int where, u32 mask, u32 data)
{
int shift = 8 * (where & 3);
- u32 val = rcar_pci_read_reg(pcie, where & ~3);
+ u32 val = rcar_readl(pcie, where & ~3);
val &= ~(mask << shift);
val |= data << shift;
- rcar_pci_write_reg(pcie, val, where & ~3);
+ rcar_writel(pcie, val, where & ~3);
}
static u32 rcar_read_conf(struct rcar_pcie *pcie, int where)
{
int shift = 8 * (where & 3);
- u32 val = rcar_pci_read_reg(pcie, where & ~3);
+ u32 val = rcar_readl(pcie, where & ~3);
return val >> shift;
}
@@ -219,13 +218,13 @@ static int rcar_pcie_config_access(struct rcar_pcie *pcie,
return PCIBIOS_DEVICE_NOT_FOUND;
if (access_type == RCAR_PCI_ACCESS_READ) {
- *data = rcar_pci_read_reg(pcie, PCICONF(index));
+ *data = rcar_readl(pcie, PCICONF(index));
} else {
/* Keep an eye out for changes to the root bus number */
if (pci_is_root_bus(bus) && (reg == PCI_PRIMARY_BUS))
pcie->root_bus_nr = *data & 0xff;
- rcar_pci_write_reg(pcie, *data, PCICONF(index));
+ rcar_writel(pcie, *data, PCICONF(index));
}
return PCIBIOS_SUCCESSFUL;
@@ -235,20 +234,20 @@ static int rcar_pcie_config_access(struct rcar_pcie *pcie,
return PCIBIOS_DEVICE_NOT_FOUND;
/* Clear errors */
- rcar_pci_write_reg(pcie, rcar_pci_read_reg(pcie, PCIEERRFR), PCIEERRFR);
+ rcar_writel(pcie, rcar_readl(pcie, PCIEERRFR), PCIEERRFR);
/* Set the PIO address */
- rcar_pci_write_reg(pcie, PCIE_CONF_BUS(bus->number) |
- PCIE_CONF_DEV(dev) | PCIE_CONF_FUNC(func) | reg, PCIECAR);
+ rcar_writel(pcie, PCIE_CONF_BUS(bus->number) |
+ PCIE_CONF_DEV(dev) | PCIE_CONF_FUNC(func) | reg, PCIECAR);
/* Enable the configuration access */
if (bus->parent->number == pcie->root_bus_nr)
- rcar_pci_write_reg(pcie, CONFIG_SEND_ENABLE | TYPE0, PCIECCTLR);
+ rcar_writel(pcie, CONFIG_SEND_ENABLE | TYPE0, PCIECCTLR);
else
- rcar_pci_write_reg(pcie, CONFIG_SEND_ENABLE | TYPE1, PCIECCTLR);
+ rcar_writel(pcie, CONFIG_SEND_ENABLE | TYPE1, PCIECCTLR);
/* Check for errors */
- if (rcar_pci_read_reg(pcie, PCIEERRFR) & UNSUPPORTED_REQUEST)
+ if (rcar_readl(pcie, PCIEERRFR) & UNSUPPORTED_REQUEST)
return PCIBIOS_DEVICE_NOT_FOUND;
/* Check for master and target aborts */
@@ -257,12 +256,12 @@ static int rcar_pcie_config_access(struct rcar_pcie *pcie,
return PCIBIOS_DEVICE_NOT_FOUND;
if (access_type == RCAR_PCI_ACCESS_READ)
- *data = rcar_pci_read_reg(pcie, PCIECDR);
+ *data = rcar_readl(pcie, PCIECDR);
else
- rcar_pci_write_reg(pcie, *data, PCIECDR);
+ rcar_writel(pcie, *data, PCIECDR);
/* Disable the configuration access */
- rcar_pci_write_reg(pcie, 0, PCIECCTLR);
+ rcar_writel(pcie, 0, PCIECCTLR);
return PCIBIOS_SUCCESSFUL;
}
@@ -337,7 +336,7 @@ static void rcar_pcie_setup_window(int win, struct rcar_pcie *pcie,
resource_size_t res_start;
u32 mask;
- rcar_pci_write_reg(pcie, 0x00000000, PCIEPTCTLR(win));
+ rcar_writel(pcie, 0x00000000, PCIEPTCTLR(win));
/*
* The PAMR mask is calculated in units of 128Bytes, which
@@ -345,23 +344,22 @@ static void rcar_pcie_setup_window(int win, struct rcar_pcie *pcie,
*/
size = resource_size(res);
mask = (roundup_pow_of_two(size) / SZ_128) - 1;
- rcar_pci_write_reg(pcie, mask << 7, PCIEPAMR(win));
+ rcar_writel(pcie, mask << 7, PCIEPAMR(win));
if (res->flags & IORESOURCE_IO)
res_start = pci_pio_to_address(res->start);
else
res_start = res->start;
- rcar_pci_write_reg(pcie, upper_32_bits(res_start), PCIEPAUR(win));
- rcar_pci_write_reg(pcie, lower_32_bits(res_start) & ~0x7F,
- PCIEPALR(win));
+ rcar_writel(pcie, upper_32_bits(res_start), PCIEPAUR(win));
+ rcar_writel(pcie, lower_32_bits(res_start) & ~0x7F, PCIEPALR(win));
/* First resource is for IO */
mask = PAR_ENABLE;
if (res->flags & IORESOURCE_IO)
mask |= IO_SPACE;
- rcar_pci_write_reg(pcie, mask, PCIEPTCTLR(win));
+ rcar_writel(pcie, mask, PCIEPTCTLR(win));
}
static int rcar_pcie_setup(struct list_head *resource, struct rcar_pcie *pci)
@@ -400,15 +398,15 @@ static void rcar_pcie_force_speedup(struct rcar_pcie *pcie)
unsigned int timeout = 1000;
u32 macsr;
- if ((rcar_pci_read_reg(pcie, MACS2R) & LINK_SPEED) != LINK_SPEED_5_0GTS)
+ if ((rcar_readl(pcie, MACS2R) & LINK_SPEED) != LINK_SPEED_5_0GTS)
return;
- if (rcar_pci_read_reg(pcie, MACCTLR) & SPEED_CHANGE) {
+ if (rcar_readl(pcie, MACCTLR) & SPEED_CHANGE) {
dev_err(pcie->dev, "Speed change already in progress\n");
return;
}
- macsr = rcar_pci_read_reg(pcie, MACSR);
+ macsr = rcar_readl(pcie, MACSR);
if ((macsr & LINK_SPEED) == LINK_SPEED_5_0GTS)
goto done;
@@ -421,16 +419,16 @@ static void rcar_pcie_force_speedup(struct rcar_pcie *pcie)
/* Clear SPCHGFIN, SPCHGSUC, and SPCHGFAIL */
if (macsr & (SPCHGFIN | SPCHGSUC | SPCHGFAIL))
- rcar_pci_write_reg(pcie, macsr, MACSR);
+ rcar_writel(pcie, macsr, MACSR);
/* Start link speed change */
rcar_rmw32(pcie, MACCTLR, SPEED_CHANGE, SPEED_CHANGE);
while (timeout--) {
- macsr = rcar_pci_read_reg(pcie, MACSR);
+ macsr = rcar_readl(pcie, MACSR);
if (macsr & SPCHGFIN) {
/* Clear the interrupt bits */
- rcar_pci_write_reg(pcie, macsr, MACSR);
+ rcar_writel(pcie, macsr, MACSR);
if (macsr & SPCHGFAIL)
dev_err(pcie->dev, "Speed change failed\n");
@@ -490,7 +488,7 @@ static int phy_wait_for_ack(struct rcar_pcie *pcie)
unsigned int timeout = 100;
while (timeout--) {
- if (rcar_pci_read_reg(pcie, H1_PCIEPHYADRR) & PHY_ACK)
+ if (rcar_readl(pcie, H1_PCIEPHYADRR) & PHY_ACK)
return 0;
udelay(100);
@@ -513,15 +511,15 @@ static void phy_write_reg(struct rcar_pcie *pcie,
((addr & 0xff) << ADR_POS);
/* Set write data */
- rcar_pci_write_reg(pcie, data, H1_PCIEPHYDOUTR);
- rcar_pci_write_reg(pcie, phyaddr, H1_PCIEPHYADRR);
+ rcar_writel(pcie, data, H1_PCIEPHYDOUTR);
+ rcar_writel(pcie, phyaddr, H1_PCIEPHYADRR);
/* Ignore errors as they will be dealt with if the data link is down */
phy_wait_for_ack(pcie);
/* Clear command */
- rcar_pci_write_reg(pcie, 0, H1_PCIEPHYDOUTR);
- rcar_pci_write_reg(pcie, 0, H1_PCIEPHYADRR);
+ rcar_writel(pcie, 0, H1_PCIEPHYDOUTR);
+ rcar_writel(pcie, 0, H1_PCIEPHYADRR);
/* Ignore errors as they will be dealt with if the data link is down */
phy_wait_for_ack(pcie);
@@ -532,7 +530,7 @@ static int rcar_pcie_wait_for_dl(struct rcar_pcie *pcie)
unsigned int timeout = 10;
while (timeout--) {
- if ((rcar_pci_read_reg(pcie, PCIETSTR) & DATA_LINK_ACTIVE))
+ if ((rcar_readl(pcie, PCIETSTR) & DATA_LINK_ACTIVE))
return 0;
msleep(5);
@@ -546,17 +544,17 @@ static int rcar_pcie_hw_init(struct rcar_pcie *pcie)
int err;
/* Begin initialization */
- rcar_pci_write_reg(pcie, 0, PCIETCTLR);
+ rcar_writel(pcie, 0, PCIETCTLR);
/* Set mode */
- rcar_pci_write_reg(pcie, 1, PCIEMSR);
+ rcar_writel(pcie, 1, PCIEMSR);
/*
* Initial header for port config space is type 1, set the device
* class to match. Hardware takes care of propagating the IDSETR
* settings, so there is no need to bother with a quirk.
*/
- rcar_pci_write_reg(pcie, PCI_CLASS_BRIDGE_PCI << 16, IDSETR1);
+ rcar_writel(pcie, PCI_CLASS_BRIDGE_PCI << 16, IDSETR1);
/*
* Setup Secondary Bus Number & Subordinate Bus Number, even though
@@ -587,10 +585,10 @@ static int rcar_pcie_hw_init(struct rcar_pcie *pcie)
/* Enable MSI */
if (IS_ENABLED(CONFIG_PCI_MSI))
- rcar_pci_write_reg(pcie, 0x801f0000, PCIEMSITXR);
+ rcar_writel(pcie, 0x801f0000, PCIEMSITXR);
/* Finish initialization - establish a PCI Express link */
- rcar_pci_write_reg(pcie, CFINIT, PCIETCTLR);
+ rcar_writel(pcie, CFINIT, PCIETCTLR);
/* This will timeout if we don't have a link. */
err = rcar_pcie_wait_for_dl(pcie);
@@ -628,7 +626,7 @@ static int rcar_pcie_hw_init_h1(struct rcar_pcie *pcie)
phy_write_reg(pcie, 0, 0x66, 0x1, 0x00008000);
while (timeout--) {
- if (rcar_pci_read_reg(pcie, H1_PCIEPHYSR))
+ if (rcar_readl(pcie, H1_PCIEPHYSR))
return rcar_pcie_hw_init(pcie);
msleep(5);
@@ -643,16 +641,16 @@ static int rcar_pcie_hw_init_gen2(struct rcar_pcie *pcie)
* These settings come from the R-Car Series, 2nd Generation User's
* Manual, section 50.3.1 (2) Initialization of the physical layer.
*/
- rcar_pci_write_reg(pcie, 0x000f0030, GEN2_PCIEPHYADDR);
- rcar_pci_write_reg(pcie, 0x00381203, GEN2_PCIEPHYDATA);
- rcar_pci_write_reg(pcie, 0x00000001, GEN2_PCIEPHYCTRL);
- rcar_pci_write_reg(pcie, 0x00000006, GEN2_PCIEPHYCTRL);
+ rcar_writel(pcie, 0x000f0030, GEN2_PCIEPHYADDR);
+ rcar_writel(pcie, 0x00381203, GEN2_PCIEPHYDATA);
+ rcar_writel(pcie, 0x00000001, GEN2_PCIEPHYCTRL);
+ rcar_writel(pcie, 0x00000006, GEN2_PCIEPHYCTRL);
- rcar_pci_write_reg(pcie, 0x000f0054, GEN2_PCIEPHYADDR);
+ rcar_writel(pcie, 0x000f0054, GEN2_PCIEPHYADDR);
/* The following value is for DC connection, no termination resistor */
- rcar_pci_write_reg(pcie, 0x13802007, GEN2_PCIEPHYDATA);
- rcar_pci_write_reg(pcie, 0x00000001, GEN2_PCIEPHYCTRL);
- rcar_pci_write_reg(pcie, 0x00000006, GEN2_PCIEPHYCTRL);
+ rcar_writel(pcie, 0x13802007, GEN2_PCIEPHYDATA);
+ rcar_writel(pcie, 0x00000001, GEN2_PCIEPHYCTRL);
+ rcar_writel(pcie, 0x00000006, GEN2_PCIEPHYCTRL);
return rcar_pcie_hw_init(pcie);
}
@@ -699,7 +697,7 @@ static irqreturn_t rcar_pcie_msi_irq(int irq, void *data)
struct rcar_msi *msi = &pcie->msi;
unsigned long reg;
- reg = rcar_pci_read_reg(pcie, PCIEMSIFR);
+ reg = rcar_readl(pcie, PCIEMSIFR);
/* MSI & INTx share an interrupt - we only handle MSI here */
if (!reg)
@@ -710,7 +708,7 @@ static irqreturn_t rcar_pcie_msi_irq(int irq, void *data)
unsigned int irq;
/* clear the interrupt */
- rcar_pci_write_reg(pcie, 1 << index, PCIEMSIFR);
+ rcar_writel(pcie, 1 << index, PCIEMSIFR);
irq = irq_find_mapping(msi->domain, index);
if (irq) {
@@ -724,7 +722,7 @@ static irqreturn_t rcar_pcie_msi_irq(int irq, void *data)
}
/* see if there's any more pending in this vector */
- reg = rcar_pci_read_reg(pcie, PCIEMSIFR);
+ reg = rcar_readl(pcie, PCIEMSIFR);
}
return IRQ_HANDLED;
@@ -751,8 +749,8 @@ static int rcar_msi_setup_irq(struct msi_controller *chip, struct pci_dev *pdev,
irq_set_msi_desc(irq, desc);
- msg.address_lo = rcar_pci_read_reg(pcie, PCIEMSIALR) & ~MSIFE;
- msg.address_hi = rcar_pci_read_reg(pcie, PCIEMSIAUR);
+ msg.address_lo = rcar_readl(pcie, PCIEMSIALR) & ~MSIFE;
+ msg.address_hi = rcar_readl(pcie, PCIEMSIAUR);
msg.data = hwirq;
pci_write_msi_msg(irq, &msg);
@@ -803,8 +801,8 @@ static int rcar_msi_setup_irqs(struct msi_controller *chip,
desc->nvec_used = nvec;
desc->msi_attrib.multiple = order_base_2(nvec);
- msg.address_lo = rcar_pci_read_reg(pcie, PCIEMSIALR) & ~MSIFE;
- msg.address_hi = rcar_pci_read_reg(pcie, PCIEMSIAUR);
+ msg.address_lo = rcar_readl(pcie, PCIEMSIALR) & ~MSIFE;
+ msg.address_hi = rcar_readl(pcie, PCIEMSIAUR);
msg.data = hwirq;
pci_write_msi_msg(irq, &msg);
@@ -886,11 +884,11 @@ static int rcar_pcie_enable_msi(struct rcar_pcie *pcie)
msi->pages = __get_free_pages(GFP_KERNEL, 0);
base = virt_to_phys((void *)msi->pages);
- rcar_pci_write_reg(pcie, base | MSIFE, PCIEMSIALR);
- rcar_pci_write_reg(pcie, 0, PCIEMSIAUR);
+ rcar_writel(pcie, base | MSIFE, PCIEMSIALR);
+ rcar_writel(pcie, 0, PCIEMSIAUR);
/* enable all MSI interrupts */
- rcar_pci_write_reg(pcie, 0xffffffff, PCIEMSIIER);
+ rcar_writel(pcie, 0xffffffff, PCIEMSIIER);
return 0;
@@ -997,17 +995,13 @@ static int rcar_pcie_inbound_ranges(struct rcar_pcie *pcie,
* Set up 64-bit inbound regions as the range parser doesn't
* distinguish between 32 and 64-bit types.
*/
- rcar_pci_write_reg(pcie, lower_32_bits(pci_addr),
- PCIEPRAR(idx));
- rcar_pci_write_reg(pcie, lower_32_bits(cpu_addr), PCIELAR(idx));
- rcar_pci_write_reg(pcie, lower_32_bits(mask) | flags,
- PCIELAMR(idx));
-
- rcar_pci_write_reg(pcie, upper_32_bits(pci_addr),
- PCIEPRAR(idx + 1));
- rcar_pci_write_reg(pcie, upper_32_bits(cpu_addr),
- PCIELAR(idx + 1));
- rcar_pci_write_reg(pcie, 0, PCIELAMR(idx + 1));
+ rcar_writel(pcie, lower_32_bits(pci_addr), PCIEPRAR(idx));
+ rcar_writel(pcie, lower_32_bits(cpu_addr), PCIELAR(idx));
+ rcar_writel(pcie, lower_32_bits(mask) | flags, PCIELAMR(idx));
+
+ rcar_writel(pcie, upper_32_bits(pci_addr), PCIEPRAR(idx + 1));
+ rcar_writel(pcie, upper_32_bits(cpu_addr), PCIELAR(idx + 1));
+ rcar_writel(pcie, 0, PCIELAMR(idx + 1));
pci_addr += size;
cpu_addr += size;
@@ -1166,7 +1160,7 @@ static int rcar_pcie_probe(struct platform_device *pdev)
goto err_pm_put;
}
- data = rcar_pci_read_reg(pcie, MACSR);
+ data = rcar_readl(pcie, MACSR);
dev_info(&pdev->dev, "PCIe x%d: link up\n", (data >> 20) & 0x3f);
if (IS_ENABLED(CONFIG_PCI_MSI)) {
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH 02/10] PCI: rcar: Name private struct pointer "rcar" consistently
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
@ 2016-10-07 16:24 ` Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 03/10] PCI: rcar: Swap order of rcar_writel() reg/val arguments Bjorn Helgaas
` (8 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Bjorn Helgaas @ 2016-10-07 16:24 UTC (permalink / raw)
To: Simon Horman; +Cc: linux-renesas-soc, linux-pci
Use a device-specific name, "rcar", for struct rcar_pcie pointers
to hint that this is device-specific information. No functional change
intended.
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
drivers/pci/host/pcie-rcar.c | 388 +++++++++++++++++++++---------------------
1 file changed, 194 insertions(+), 194 deletions(-)
diff --git a/drivers/pci/host/pcie-rcar.c b/drivers/pci/host/pcie-rcar.c
index b6899c8..145b54d 100644
--- a/drivers/pci/host/pcie-rcar.c
+++ b/drivers/pci/host/pcie-rcar.c
@@ -152,15 +152,15 @@ struct rcar_pcie {
struct rcar_msi msi;
};
-static unsigned long rcar_readl(struct rcar_pcie *pcie, unsigned long reg)
+static unsigned long rcar_readl(struct rcar_pcie *rcar, unsigned long reg)
{
- return readl(pcie->base + reg);
+ return readl(rcar->base + reg);
}
-static void rcar_writel(struct rcar_pcie *pcie, unsigned long val,
+static void rcar_writel(struct rcar_pcie *rcar, unsigned long val,
unsigned long reg)
{
- writel(val, pcie->base + reg);
+ writel(val, rcar->base + reg);
}
enum {
@@ -168,26 +168,26 @@ enum {
RCAR_PCI_ACCESS_WRITE,
};
-static void rcar_rmw32(struct rcar_pcie *pcie, int where, u32 mask, u32 data)
+static void rcar_rmw32(struct rcar_pcie *rcar, int where, u32 mask, u32 data)
{
int shift = 8 * (where & 3);
- u32 val = rcar_readl(pcie, where & ~3);
+ u32 val = rcar_readl(rcar, where & ~3);
val &= ~(mask << shift);
val |= data << shift;
- rcar_writel(pcie, val, where & ~3);
+ rcar_writel(rcar, val, where & ~3);
}
-static u32 rcar_read_conf(struct rcar_pcie *pcie, int where)
+static u32 rcar_read_conf(struct rcar_pcie *rcar, int where)
{
int shift = 8 * (where & 3);
- u32 val = rcar_readl(pcie, where & ~3);
+ u32 val = rcar_readl(rcar, where & ~3);
return val >> shift;
}
/* Serialization is provided by 'pci_lock' in drivers/pci/access.c */
-static int rcar_pcie_config_access(struct rcar_pcie *pcie,
+static int rcar_pcie_config_access(struct rcar_pcie *rcar,
unsigned char access_type, struct pci_bus *bus,
unsigned int devfn, int where, u32 *data)
{
@@ -218,50 +218,50 @@ static int rcar_pcie_config_access(struct rcar_pcie *pcie,
return PCIBIOS_DEVICE_NOT_FOUND;
if (access_type == RCAR_PCI_ACCESS_READ) {
- *data = rcar_readl(pcie, PCICONF(index));
+ *data = rcar_readl(rcar, PCICONF(index));
} else {
/* Keep an eye out for changes to the root bus number */
if (pci_is_root_bus(bus) && (reg == PCI_PRIMARY_BUS))
- pcie->root_bus_nr = *data & 0xff;
+ rcar->root_bus_nr = *data & 0xff;
- rcar_writel(pcie, *data, PCICONF(index));
+ rcar_writel(rcar, *data, PCICONF(index));
}
return PCIBIOS_SUCCESSFUL;
}
- if (pcie->root_bus_nr < 0)
+ if (rcar->root_bus_nr < 0)
return PCIBIOS_DEVICE_NOT_FOUND;
/* Clear errors */
- rcar_writel(pcie, rcar_readl(pcie, PCIEERRFR), PCIEERRFR);
+ rcar_writel(rcar, rcar_readl(rcar, PCIEERRFR), PCIEERRFR);
/* Set the PIO address */
- rcar_writel(pcie, PCIE_CONF_BUS(bus->number) |
+ rcar_writel(rcar, PCIE_CONF_BUS(bus->number) |
PCIE_CONF_DEV(dev) | PCIE_CONF_FUNC(func) | reg, PCIECAR);
/* Enable the configuration access */
- if (bus->parent->number == pcie->root_bus_nr)
- rcar_writel(pcie, CONFIG_SEND_ENABLE | TYPE0, PCIECCTLR);
+ if (bus->parent->number == rcar->root_bus_nr)
+ rcar_writel(rcar, CONFIG_SEND_ENABLE | TYPE0, PCIECCTLR);
else
- rcar_writel(pcie, CONFIG_SEND_ENABLE | TYPE1, PCIECCTLR);
+ rcar_writel(rcar, CONFIG_SEND_ENABLE | TYPE1, PCIECCTLR);
/* Check for errors */
- if (rcar_readl(pcie, PCIEERRFR) & UNSUPPORTED_REQUEST)
+ if (rcar_readl(rcar, PCIEERRFR) & UNSUPPORTED_REQUEST)
return PCIBIOS_DEVICE_NOT_FOUND;
/* Check for master and target aborts */
- if (rcar_read_conf(pcie, RCONF(PCI_STATUS)) &
+ if (rcar_read_conf(rcar, RCONF(PCI_STATUS)) &
(PCI_STATUS_REC_MASTER_ABORT | PCI_STATUS_REC_TARGET_ABORT))
return PCIBIOS_DEVICE_NOT_FOUND;
if (access_type == RCAR_PCI_ACCESS_READ)
- *data = rcar_readl(pcie, PCIECDR);
+ *data = rcar_readl(rcar, PCIECDR);
else
- rcar_writel(pcie, *data, PCIECDR);
+ rcar_writel(rcar, *data, PCIECDR);
/* Disable the configuration access */
- rcar_writel(pcie, 0, PCIECCTLR);
+ rcar_writel(rcar, 0, PCIECCTLR);
return PCIBIOS_SUCCESSFUL;
}
@@ -269,10 +269,10 @@ static int rcar_pcie_config_access(struct rcar_pcie *pcie,
static int rcar_pcie_read_conf(struct pci_bus *bus, unsigned int devfn,
int where, int size, u32 *val)
{
- struct rcar_pcie *pcie = bus->sysdata;
+ struct rcar_pcie *rcar = bus->sysdata;
int ret;
- ret = rcar_pcie_config_access(pcie, RCAR_PCI_ACCESS_READ,
+ ret = rcar_pcie_config_access(rcar, RCAR_PCI_ACCESS_READ,
bus, devfn, where, val);
if (ret != PCIBIOS_SUCCESSFUL) {
*val = 0xffffffff;
@@ -294,11 +294,11 @@ static int rcar_pcie_read_conf(struct pci_bus *bus, unsigned int devfn,
static int rcar_pcie_write_conf(struct pci_bus *bus, unsigned int devfn,
int where, int size, u32 val)
{
- struct rcar_pcie *pcie = bus->sysdata;
+ struct rcar_pcie *rcar = bus->sysdata;
int shift, ret;
u32 data;
- ret = rcar_pcie_config_access(pcie, RCAR_PCI_ACCESS_READ,
+ ret = rcar_pcie_config_access(rcar, RCAR_PCI_ACCESS_READ,
bus, devfn, where, &data);
if (ret != PCIBIOS_SUCCESSFUL)
return ret;
@@ -317,7 +317,7 @@ static int rcar_pcie_write_conf(struct pci_bus *bus, unsigned int devfn,
} else
data = val;
- ret = rcar_pcie_config_access(pcie, RCAR_PCI_ACCESS_WRITE,
+ ret = rcar_pcie_config_access(rcar, RCAR_PCI_ACCESS_WRITE,
bus, devfn, where, &data);
return ret;
@@ -328,7 +328,7 @@ static struct pci_ops rcar_pcie_ops = {
.write = rcar_pcie_write_conf,
};
-static void rcar_pcie_setup_window(int win, struct rcar_pcie *pcie,
+static void rcar_pcie_setup_window(int win, struct rcar_pcie *rcar,
struct resource *res)
{
/* Setup PCIe address space mappings for each resource */
@@ -336,7 +336,7 @@ static void rcar_pcie_setup_window(int win, struct rcar_pcie *pcie,
resource_size_t res_start;
u32 mask;
- rcar_writel(pcie, 0x00000000, PCIEPTCTLR(win));
+ rcar_writel(rcar, 0x00000000, PCIEPTCTLR(win));
/*
* The PAMR mask is calculated in units of 128Bytes, which
@@ -344,22 +344,22 @@ static void rcar_pcie_setup_window(int win, struct rcar_pcie *pcie,
*/
size = resource_size(res);
mask = (roundup_pow_of_two(size) / SZ_128) - 1;
- rcar_writel(pcie, mask << 7, PCIEPAMR(win));
+ rcar_writel(rcar, mask << 7, PCIEPAMR(win));
if (res->flags & IORESOURCE_IO)
res_start = pci_pio_to_address(res->start);
else
res_start = res->start;
- rcar_writel(pcie, upper_32_bits(res_start), PCIEPAUR(win));
- rcar_writel(pcie, lower_32_bits(res_start) & ~0x7F, PCIEPALR(win));
+ rcar_writel(rcar, upper_32_bits(res_start), PCIEPAUR(win));
+ rcar_writel(rcar, lower_32_bits(res_start) & ~0x7F, PCIEPALR(win));
/* First resource is for IO */
mask = PAR_ENABLE;
if (res->flags & IORESOURCE_IO)
mask |= IO_SPACE;
- rcar_writel(pcie, mask, PCIEPTCTLR(win));
+ rcar_writel(rcar, mask, PCIEPTCTLR(win));
}
static int rcar_pcie_setup(struct list_head *resource, struct rcar_pcie *pci)
@@ -393,45 +393,45 @@ static int rcar_pcie_setup(struct list_head *resource, struct rcar_pcie *pci)
return 1;
}
-static void rcar_pcie_force_speedup(struct rcar_pcie *pcie)
+static void rcar_pcie_force_speedup(struct rcar_pcie *rcar)
{
unsigned int timeout = 1000;
u32 macsr;
- if ((rcar_readl(pcie, MACS2R) & LINK_SPEED) != LINK_SPEED_5_0GTS)
+ if ((rcar_readl(rcar, MACS2R) & LINK_SPEED) != LINK_SPEED_5_0GTS)
return;
- if (rcar_readl(pcie, MACCTLR) & SPEED_CHANGE) {
- dev_err(pcie->dev, "Speed change already in progress\n");
+ if (rcar_readl(rcar, MACCTLR) & SPEED_CHANGE) {
+ dev_err(rcar->dev, "Speed change already in progress\n");
return;
}
- macsr = rcar_readl(pcie, MACSR);
+ macsr = rcar_readl(rcar, MACSR);
if ((macsr & LINK_SPEED) == LINK_SPEED_5_0GTS)
goto done;
/* Set target link speed to 5.0 GT/s */
- rcar_rmw32(pcie, EXPCAP(12), PCI_EXP_LNKSTA_CLS,
+ rcar_rmw32(rcar, EXPCAP(12), PCI_EXP_LNKSTA_CLS,
PCI_EXP_LNKSTA_CLS_5_0GB);
/* Set speed change reason as intentional factor */
- rcar_rmw32(pcie, MACCGSPSETR, SPCNGRSN, 0);
+ rcar_rmw32(rcar, MACCGSPSETR, SPCNGRSN, 0);
/* Clear SPCHGFIN, SPCHGSUC, and SPCHGFAIL */
if (macsr & (SPCHGFIN | SPCHGSUC | SPCHGFAIL))
- rcar_writel(pcie, macsr, MACSR);
+ rcar_writel(rcar, macsr, MACSR);
/* Start link speed change */
- rcar_rmw32(pcie, MACCTLR, SPEED_CHANGE, SPEED_CHANGE);
+ rcar_rmw32(rcar, MACCTLR, SPEED_CHANGE, SPEED_CHANGE);
while (timeout--) {
- macsr = rcar_readl(pcie, MACSR);
+ macsr = rcar_readl(rcar, MACSR);
if (macsr & SPCHGFIN) {
/* Clear the interrupt bits */
- rcar_writel(pcie, macsr, MACSR);
+ rcar_writel(rcar, macsr, MACSR);
if (macsr & SPCHGFAIL)
- dev_err(pcie->dev, "Speed change failed\n");
+ dev_err(rcar->dev, "Speed change failed\n");
goto done;
}
@@ -439,34 +439,34 @@ static void rcar_pcie_force_speedup(struct rcar_pcie *pcie)
msleep(1);
};
- dev_err(pcie->dev, "Speed change timed out\n");
+ dev_err(rcar->dev, "Speed change timed out\n");
done:
- dev_info(pcie->dev, "Current link speed is %s GT/s\n",
+ dev_info(rcar->dev, "Current link speed is %s GT/s\n",
(macsr & LINK_SPEED) == LINK_SPEED_5_0GTS ? "5" : "2.5");
}
-static int rcar_pcie_enable(struct rcar_pcie *pcie)
+static int rcar_pcie_enable(struct rcar_pcie *rcar)
{
struct pci_bus *bus, *child;
LIST_HEAD(res);
/* Try setting 5 GT/s link speed */
- rcar_pcie_force_speedup(pcie);
+ rcar_pcie_force_speedup(rcar);
- rcar_pcie_setup(&res, pcie);
+ rcar_pcie_setup(&res, rcar);
pci_add_flags(PCI_REASSIGN_ALL_RSRC | PCI_REASSIGN_ALL_BUS);
if (IS_ENABLED(CONFIG_PCI_MSI))
- bus = pci_scan_root_bus_msi(pcie->dev, pcie->root_bus_nr,
- &rcar_pcie_ops, pcie, &res, &pcie->msi.chip);
+ bus = pci_scan_root_bus_msi(rcar->dev, rcar->root_bus_nr,
+ &rcar_pcie_ops, rcar, &res, &rcar->msi.chip);
else
- bus = pci_scan_root_bus(pcie->dev, pcie->root_bus_nr,
- &rcar_pcie_ops, pcie, &res);
+ bus = pci_scan_root_bus(rcar->dev, rcar->root_bus_nr,
+ &rcar_pcie_ops, rcar, &res);
if (!bus) {
- dev_err(pcie->dev, "Scanning rootbus failed");
+ dev_err(rcar->dev, "Scanning rootbus failed");
return -ENODEV;
}
@@ -483,23 +483,23 @@ static int rcar_pcie_enable(struct rcar_pcie *pcie)
return 0;
}
-static int phy_wait_for_ack(struct rcar_pcie *pcie)
+static int phy_wait_for_ack(struct rcar_pcie *rcar)
{
unsigned int timeout = 100;
while (timeout--) {
- if (rcar_readl(pcie, H1_PCIEPHYADRR) & PHY_ACK)
+ if (rcar_readl(rcar, H1_PCIEPHYADRR) & PHY_ACK)
return 0;
udelay(100);
}
- dev_err(pcie->dev, "Access to PCIe phy timed out\n");
+ dev_err(rcar->dev, "Access to PCIe phy timed out\n");
return -ETIMEDOUT;
}
-static void phy_write_reg(struct rcar_pcie *pcie,
+static void phy_write_reg(struct rcar_pcie *rcar,
unsigned int rate, unsigned int addr,
unsigned int lane, unsigned int data)
{
@@ -511,26 +511,26 @@ static void phy_write_reg(struct rcar_pcie *pcie,
((addr & 0xff) << ADR_POS);
/* Set write data */
- rcar_writel(pcie, data, H1_PCIEPHYDOUTR);
- rcar_writel(pcie, phyaddr, H1_PCIEPHYADRR);
+ rcar_writel(rcar, data, H1_PCIEPHYDOUTR);
+ rcar_writel(rcar, phyaddr, H1_PCIEPHYADRR);
/* Ignore errors as they will be dealt with if the data link is down */
- phy_wait_for_ack(pcie);
+ phy_wait_for_ack(rcar);
/* Clear command */
- rcar_writel(pcie, 0, H1_PCIEPHYDOUTR);
- rcar_writel(pcie, 0, H1_PCIEPHYADRR);
+ rcar_writel(rcar, 0, H1_PCIEPHYDOUTR);
+ rcar_writel(rcar, 0, H1_PCIEPHYADRR);
/* Ignore errors as they will be dealt with if the data link is down */
- phy_wait_for_ack(pcie);
+ phy_wait_for_ack(rcar);
}
-static int rcar_pcie_wait_for_dl(struct rcar_pcie *pcie)
+static int rcar_pcie_wait_for_dl(struct rcar_pcie *rcar)
{
unsigned int timeout = 10;
while (timeout--) {
- if ((rcar_readl(pcie, PCIETSTR) & DATA_LINK_ACTIVE))
+ if ((rcar_readl(rcar, PCIETSTR) & DATA_LINK_ACTIVE))
return 0;
msleep(5);
@@ -539,95 +539,95 @@ static int rcar_pcie_wait_for_dl(struct rcar_pcie *pcie)
return -ETIMEDOUT;
}
-static int rcar_pcie_hw_init(struct rcar_pcie *pcie)
+static int rcar_pcie_hw_init(struct rcar_pcie *rcar)
{
int err;
/* Begin initialization */
- rcar_writel(pcie, 0, PCIETCTLR);
+ rcar_writel(rcar, 0, PCIETCTLR);
/* Set mode */
- rcar_writel(pcie, 1, PCIEMSR);
+ rcar_writel(rcar, 1, PCIEMSR);
/*
* Initial header for port config space is type 1, set the device
* class to match. Hardware takes care of propagating the IDSETR
* settings, so there is no need to bother with a quirk.
*/
- rcar_writel(pcie, PCI_CLASS_BRIDGE_PCI << 16, IDSETR1);
+ rcar_writel(rcar, PCI_CLASS_BRIDGE_PCI << 16, IDSETR1);
/*
* Setup Secondary Bus Number & Subordinate Bus Number, even though
* they aren't used, to avoid bridge being detected as broken.
*/
- rcar_rmw32(pcie, RCONF(PCI_SECONDARY_BUS), 0xff, 1);
- rcar_rmw32(pcie, RCONF(PCI_SUBORDINATE_BUS), 0xff, 1);
+ rcar_rmw32(rcar, RCONF(PCI_SECONDARY_BUS), 0xff, 1);
+ rcar_rmw32(rcar, RCONF(PCI_SUBORDINATE_BUS), 0xff, 1);
/* Initialize default capabilities. */
- rcar_rmw32(pcie, REXPCAP(0), 0xff, PCI_CAP_ID_EXP);
- rcar_rmw32(pcie, REXPCAP(PCI_EXP_FLAGS),
+ rcar_rmw32(rcar, REXPCAP(0), 0xff, PCI_CAP_ID_EXP);
+ rcar_rmw32(rcar, REXPCAP(PCI_EXP_FLAGS),
PCI_EXP_FLAGS_TYPE, PCI_EXP_TYPE_ROOT_PORT << 4);
- rcar_rmw32(pcie, RCONF(PCI_HEADER_TYPE), 0x7f,
+ rcar_rmw32(rcar, RCONF(PCI_HEADER_TYPE), 0x7f,
PCI_HEADER_TYPE_BRIDGE);
/* Enable data link layer active state reporting */
- rcar_rmw32(pcie, REXPCAP(PCI_EXP_LNKCAP), PCI_EXP_LNKCAP_DLLLARC,
+ rcar_rmw32(rcar, REXPCAP(PCI_EXP_LNKCAP), PCI_EXP_LNKCAP_DLLLARC,
PCI_EXP_LNKCAP_DLLLARC);
/* Write out the physical slot number = 0 */
- rcar_rmw32(pcie, REXPCAP(PCI_EXP_SLTCAP), PCI_EXP_SLTCAP_PSN, 0);
+ rcar_rmw32(rcar, REXPCAP(PCI_EXP_SLTCAP), PCI_EXP_SLTCAP_PSN, 0);
/* Set the completion timer timeout to the maximum 50ms. */
- rcar_rmw32(pcie, TLCTLR + 1, 0x3f, 50);
+ rcar_rmw32(rcar, TLCTLR + 1, 0x3f, 50);
/* Terminate list of capabilities (Next Capability Offset=0) */
- rcar_rmw32(pcie, RVCCAP(0), 0xfff00000, 0);
+ rcar_rmw32(rcar, RVCCAP(0), 0xfff00000, 0);
/* Enable MSI */
if (IS_ENABLED(CONFIG_PCI_MSI))
- rcar_writel(pcie, 0x801f0000, PCIEMSITXR);
+ rcar_writel(rcar, 0x801f0000, PCIEMSITXR);
/* Finish initialization - establish a PCI Express link */
- rcar_writel(pcie, CFINIT, PCIETCTLR);
+ rcar_writel(rcar, CFINIT, PCIETCTLR);
/* This will timeout if we don't have a link. */
- err = rcar_pcie_wait_for_dl(pcie);
+ err = rcar_pcie_wait_for_dl(rcar);
if (err)
return err;
/* Enable INTx interrupts */
- rcar_rmw32(pcie, PCIEINTXR, 0, 0xF << 8);
+ rcar_rmw32(rcar, PCIEINTXR, 0, 0xF << 8);
wmb();
return 0;
}
-static int rcar_pcie_hw_init_h1(struct rcar_pcie *pcie)
+static int rcar_pcie_hw_init_h1(struct rcar_pcie *rcar)
{
unsigned int timeout = 10;
/* Initialize the phy */
- phy_write_reg(pcie, 0, 0x42, 0x1, 0x0EC34191);
- phy_write_reg(pcie, 1, 0x42, 0x1, 0x0EC34180);
- phy_write_reg(pcie, 0, 0x43, 0x1, 0x00210188);
- phy_write_reg(pcie, 1, 0x43, 0x1, 0x00210188);
- phy_write_reg(pcie, 0, 0x44, 0x1, 0x015C0014);
- phy_write_reg(pcie, 1, 0x44, 0x1, 0x015C0014);
- phy_write_reg(pcie, 1, 0x4C, 0x1, 0x786174A0);
- phy_write_reg(pcie, 1, 0x4D, 0x1, 0x048000BB);
- phy_write_reg(pcie, 0, 0x51, 0x1, 0x079EC062);
- phy_write_reg(pcie, 0, 0x52, 0x1, 0x20000000);
- phy_write_reg(pcie, 1, 0x52, 0x1, 0x20000000);
- phy_write_reg(pcie, 1, 0x56, 0x1, 0x00003806);
-
- phy_write_reg(pcie, 0, 0x60, 0x1, 0x004B03A5);
- phy_write_reg(pcie, 0, 0x64, 0x1, 0x3F0F1F0F);
- phy_write_reg(pcie, 0, 0x66, 0x1, 0x00008000);
+ phy_write_reg(rcar, 0, 0x42, 0x1, 0x0EC34191);
+ phy_write_reg(rcar, 1, 0x42, 0x1, 0x0EC34180);
+ phy_write_reg(rcar, 0, 0x43, 0x1, 0x00210188);
+ phy_write_reg(rcar, 1, 0x43, 0x1, 0x00210188);
+ phy_write_reg(rcar, 0, 0x44, 0x1, 0x015C0014);
+ phy_write_reg(rcar, 1, 0x44, 0x1, 0x015C0014);
+ phy_write_reg(rcar, 1, 0x4C, 0x1, 0x786174A0);
+ phy_write_reg(rcar, 1, 0x4D, 0x1, 0x048000BB);
+ phy_write_reg(rcar, 0, 0x51, 0x1, 0x079EC062);
+ phy_write_reg(rcar, 0, 0x52, 0x1, 0x20000000);
+ phy_write_reg(rcar, 1, 0x52, 0x1, 0x20000000);
+ phy_write_reg(rcar, 1, 0x56, 0x1, 0x00003806);
+
+ phy_write_reg(rcar, 0, 0x60, 0x1, 0x004B03A5);
+ phy_write_reg(rcar, 0, 0x64, 0x1, 0x3F0F1F0F);
+ phy_write_reg(rcar, 0, 0x66, 0x1, 0x00008000);
while (timeout--) {
- if (rcar_readl(pcie, H1_PCIEPHYSR))
- return rcar_pcie_hw_init(pcie);
+ if (rcar_readl(rcar, H1_PCIEPHYSR))
+ return rcar_pcie_hw_init(rcar);
msleep(5);
}
@@ -635,24 +635,24 @@ static int rcar_pcie_hw_init_h1(struct rcar_pcie *pcie)
return -ETIMEDOUT;
}
-static int rcar_pcie_hw_init_gen2(struct rcar_pcie *pcie)
+static int rcar_pcie_hw_init_gen2(struct rcar_pcie *rcar)
{
/*
* These settings come from the R-Car Series, 2nd Generation User's
* Manual, section 50.3.1 (2) Initialization of the physical layer.
*/
- rcar_writel(pcie, 0x000f0030, GEN2_PCIEPHYADDR);
- rcar_writel(pcie, 0x00381203, GEN2_PCIEPHYDATA);
- rcar_writel(pcie, 0x00000001, GEN2_PCIEPHYCTRL);
- rcar_writel(pcie, 0x00000006, GEN2_PCIEPHYCTRL);
+ rcar_writel(rcar, 0x000f0030, GEN2_PCIEPHYADDR);
+ rcar_writel(rcar, 0x00381203, GEN2_PCIEPHYDATA);
+ rcar_writel(rcar, 0x00000001, GEN2_PCIEPHYCTRL);
+ rcar_writel(rcar, 0x00000006, GEN2_PCIEPHYCTRL);
- rcar_writel(pcie, 0x000f0054, GEN2_PCIEPHYADDR);
+ rcar_writel(rcar, 0x000f0054, GEN2_PCIEPHYADDR);
/* The following value is for DC connection, no termination resistor */
- rcar_writel(pcie, 0x13802007, GEN2_PCIEPHYDATA);
- rcar_writel(pcie, 0x00000001, GEN2_PCIEPHYCTRL);
- rcar_writel(pcie, 0x00000006, GEN2_PCIEPHYCTRL);
+ rcar_writel(rcar, 0x13802007, GEN2_PCIEPHYDATA);
+ rcar_writel(rcar, 0x00000001, GEN2_PCIEPHYCTRL);
+ rcar_writel(rcar, 0x00000006, GEN2_PCIEPHYCTRL);
- return rcar_pcie_hw_init(pcie);
+ return rcar_pcie_hw_init(rcar);
}
static int rcar_msi_alloc(struct rcar_msi *chip)
@@ -693,11 +693,11 @@ static void rcar_msi_free(struct rcar_msi *chip, unsigned long irq)
static irqreturn_t rcar_pcie_msi_irq(int irq, void *data)
{
- struct rcar_pcie *pcie = data;
- struct rcar_msi *msi = &pcie->msi;
+ struct rcar_pcie *rcar = data;
+ struct rcar_msi *msi = &rcar->msi;
unsigned long reg;
- reg = rcar_readl(pcie, PCIEMSIFR);
+ reg = rcar_readl(rcar, PCIEMSIFR);
/* MSI & INTx share an interrupt - we only handle MSI here */
if (!reg)
@@ -708,21 +708,21 @@ static irqreturn_t rcar_pcie_msi_irq(int irq, void *data)
unsigned int irq;
/* clear the interrupt */
- rcar_writel(pcie, 1 << index, PCIEMSIFR);
+ rcar_writel(rcar, 1 << index, PCIEMSIFR);
irq = irq_find_mapping(msi->domain, index);
if (irq) {
if (test_bit(index, msi->used))
generic_handle_irq(irq);
else
- dev_info(pcie->dev, "unhandled MSI\n");
+ dev_info(rcar->dev, "unhandled MSI\n");
} else {
/* Unknown MSI, just clear it */
- dev_dbg(pcie->dev, "unexpected MSI\n");
+ dev_dbg(rcar->dev, "unexpected MSI\n");
}
/* see if there's any more pending in this vector */
- reg = rcar_readl(pcie, PCIEMSIFR);
+ reg = rcar_readl(rcar, PCIEMSIFR);
}
return IRQ_HANDLED;
@@ -732,7 +732,7 @@ static int rcar_msi_setup_irq(struct msi_controller *chip, struct pci_dev *pdev,
struct msi_desc *desc)
{
struct rcar_msi *msi = to_rcar_msi(chip);
- struct rcar_pcie *pcie = container_of(chip, struct rcar_pcie, msi.chip);
+ struct rcar_pcie *rcar = container_of(chip, struct rcar_pcie, msi.chip);
struct msi_msg msg;
unsigned int irq;
int hwirq;
@@ -749,8 +749,8 @@ static int rcar_msi_setup_irq(struct msi_controller *chip, struct pci_dev *pdev,
irq_set_msi_desc(irq, desc);
- msg.address_lo = rcar_readl(pcie, PCIEMSIALR) & ~MSIFE;
- msg.address_hi = rcar_readl(pcie, PCIEMSIAUR);
+ msg.address_lo = rcar_readl(rcar, PCIEMSIALR) & ~MSIFE;
+ msg.address_hi = rcar_readl(rcar, PCIEMSIAUR);
msg.data = hwirq;
pci_write_msi_msg(irq, &msg);
@@ -761,7 +761,7 @@ static int rcar_msi_setup_irq(struct msi_controller *chip, struct pci_dev *pdev,
static int rcar_msi_setup_irqs(struct msi_controller *chip,
struct pci_dev *pdev, int nvec, int type)
{
- struct rcar_pcie *pcie = container_of(chip, struct rcar_pcie, msi.chip);
+ struct rcar_pcie *rcar = container_of(chip, struct rcar_pcie, msi.chip);
struct rcar_msi *msi = to_rcar_msi(chip);
struct msi_desc *desc;
struct msi_msg msg;
@@ -801,8 +801,8 @@ static int rcar_msi_setup_irqs(struct msi_controller *chip,
desc->nvec_used = nvec;
desc->msi_attrib.multiple = order_base_2(nvec);
- msg.address_lo = rcar_readl(pcie, PCIEMSIALR) & ~MSIFE;
- msg.address_hi = rcar_readl(pcie, PCIEMSIAUR);
+ msg.address_lo = rcar_readl(rcar, PCIEMSIALR) & ~MSIFE;
+ msg.address_hi = rcar_readl(rcar, PCIEMSIAUR);
msg.data = hwirq;
pci_write_msi_msg(irq, &msg);
@@ -839,21 +839,21 @@ static const struct irq_domain_ops msi_domain_ops = {
.map = rcar_msi_map,
};
-static int rcar_pcie_enable_msi(struct rcar_pcie *pcie)
+static int rcar_pcie_enable_msi(struct rcar_pcie *rcar)
{
- struct platform_device *pdev = to_platform_device(pcie->dev);
- struct rcar_msi *msi = &pcie->msi;
+ struct platform_device *pdev = to_platform_device(rcar->dev);
+ struct rcar_msi *msi = &rcar->msi;
unsigned long base;
int err, i;
mutex_init(&msi->lock);
- msi->chip.dev = pcie->dev;
+ msi->chip.dev = rcar->dev;
msi->chip.setup_irq = rcar_msi_setup_irq;
msi->chip.setup_irqs = rcar_msi_setup_irqs;
msi->chip.teardown_irq = rcar_msi_teardown_irq;
- msi->domain = irq_domain_add_linear(pcie->dev->of_node, INT_PCI_MSI_NR,
+ msi->domain = irq_domain_add_linear(rcar->dev->of_node, INT_PCI_MSI_NR,
&msi_domain_ops, &msi->chip);
if (!msi->domain) {
dev_err(&pdev->dev, "failed to create IRQ domain\n");
@@ -866,7 +866,7 @@ static int rcar_pcie_enable_msi(struct rcar_pcie *pcie)
/* Two irqs are for MSI, but they are also used for non-MSI irqs */
err = devm_request_irq(&pdev->dev, msi->irq1, rcar_pcie_msi_irq,
IRQF_SHARED | IRQF_NO_THREAD,
- rcar_msi_irq_chip.name, pcie);
+ rcar_msi_irq_chip.name, rcar);
if (err < 0) {
dev_err(&pdev->dev, "failed to request IRQ: %d\n", err);
goto err;
@@ -874,7 +874,7 @@ static int rcar_pcie_enable_msi(struct rcar_pcie *pcie)
err = devm_request_irq(&pdev->dev, msi->irq2, rcar_pcie_msi_irq,
IRQF_SHARED | IRQF_NO_THREAD,
- rcar_msi_irq_chip.name, pcie);
+ rcar_msi_irq_chip.name, rcar);
if (err < 0) {
dev_err(&pdev->dev, "failed to request IRQ: %d\n", err);
goto err;
@@ -884,11 +884,11 @@ static int rcar_pcie_enable_msi(struct rcar_pcie *pcie)
msi->pages = __get_free_pages(GFP_KERNEL, 0);
base = virt_to_phys((void *)msi->pages);
- rcar_writel(pcie, base | MSIFE, PCIEMSIALR);
- rcar_writel(pcie, 0, PCIEMSIAUR);
+ rcar_writel(rcar, base | MSIFE, PCIEMSIALR);
+ rcar_writel(rcar, 0, PCIEMSIAUR);
/* enable all MSI interrupts */
- rcar_writel(pcie, 0xffffffff, PCIEMSIIER);
+ rcar_writel(rcar, 0xffffffff, PCIEMSIIER);
return 0;
@@ -898,7 +898,7 @@ err:
}
static int rcar_pcie_get_resources(struct platform_device *pdev,
- struct rcar_pcie *pcie)
+ struct rcar_pcie *rcar)
{
struct resource res;
int err, i;
@@ -907,56 +907,56 @@ static int rcar_pcie_get_resources(struct platform_device *pdev,
if (err)
return err;
- pcie->base = devm_ioremap_resource(&pdev->dev, &res);
- if (IS_ERR(pcie->base))
- return PTR_ERR(pcie->base);
+ rcar->base = devm_ioremap_resource(&pdev->dev, &res);
+ if (IS_ERR(rcar->base))
+ return PTR_ERR(rcar->base);
- pcie->clk = devm_clk_get(&pdev->dev, "pcie");
- if (IS_ERR(pcie->clk)) {
- dev_err(pcie->dev, "cannot get platform clock\n");
- return PTR_ERR(pcie->clk);
+ rcar->clk = devm_clk_get(&pdev->dev, "pcie");
+ if (IS_ERR(rcar->clk)) {
+ dev_err(rcar->dev, "cannot get platform clock\n");
+ return PTR_ERR(rcar->clk);
}
- err = clk_prepare_enable(pcie->clk);
+ err = clk_prepare_enable(rcar->clk);
if (err)
return err;
- pcie->bus_clk = devm_clk_get(&pdev->dev, "pcie_bus");
- if (IS_ERR(pcie->bus_clk)) {
- dev_err(pcie->dev, "cannot get pcie bus clock\n");
- err = PTR_ERR(pcie->bus_clk);
+ rcar->bus_clk = devm_clk_get(&pdev->dev, "pcie_bus");
+ if (IS_ERR(rcar->bus_clk)) {
+ dev_err(rcar->dev, "cannot get pcie bus clock\n");
+ err = PTR_ERR(rcar->bus_clk);
goto fail_clk;
}
- err = clk_prepare_enable(pcie->bus_clk);
+ err = clk_prepare_enable(rcar->bus_clk);
if (err)
goto fail_clk;
i = irq_of_parse_and_map(pdev->dev.of_node, 0);
if (!i) {
- dev_err(pcie->dev, "cannot get platform resources for msi interrupt\n");
+ dev_err(rcar->dev, "cannot get platform resources for msi interrupt\n");
err = -ENOENT;
goto err_map_reg;
}
- pcie->msi.irq1 = i;
+ rcar->msi.irq1 = i;
i = irq_of_parse_and_map(pdev->dev.of_node, 1);
if (!i) {
- dev_err(pcie->dev, "cannot get platform resources for msi interrupt\n");
+ dev_err(rcar->dev, "cannot get platform resources for msi interrupt\n");
err = -ENOENT;
goto err_map_reg;
}
- pcie->msi.irq2 = i;
+ rcar->msi.irq2 = i;
return 0;
err_map_reg:
- clk_disable_unprepare(pcie->bus_clk);
+ clk_disable_unprepare(rcar->bus_clk);
fail_clk:
- clk_disable_unprepare(pcie->clk);
+ clk_disable_unprepare(rcar->clk);
return err;
}
-static int rcar_pcie_inbound_ranges(struct rcar_pcie *pcie,
+static int rcar_pcie_inbound_ranges(struct rcar_pcie *rcar,
struct of_pci_range *range,
int *index)
{
@@ -995,20 +995,20 @@ static int rcar_pcie_inbound_ranges(struct rcar_pcie *pcie,
* Set up 64-bit inbound regions as the range parser doesn't
* distinguish between 32 and 64-bit types.
*/
- rcar_writel(pcie, lower_32_bits(pci_addr), PCIEPRAR(idx));
- rcar_writel(pcie, lower_32_bits(cpu_addr), PCIELAR(idx));
- rcar_writel(pcie, lower_32_bits(mask) | flags, PCIELAMR(idx));
+ rcar_writel(rcar, lower_32_bits(pci_addr), PCIEPRAR(idx));
+ rcar_writel(rcar, lower_32_bits(cpu_addr), PCIELAR(idx));
+ rcar_writel(rcar, lower_32_bits(mask) | flags, PCIELAMR(idx));
- rcar_writel(pcie, upper_32_bits(pci_addr), PCIEPRAR(idx + 1));
- rcar_writel(pcie, upper_32_bits(cpu_addr), PCIELAR(idx + 1));
- rcar_writel(pcie, 0, PCIELAMR(idx + 1));
+ rcar_writel(rcar, upper_32_bits(pci_addr), PCIEPRAR(idx + 1));
+ rcar_writel(rcar, upper_32_bits(cpu_addr), PCIELAR(idx + 1));
+ rcar_writel(rcar, 0, PCIELAMR(idx + 1));
pci_addr += size;
cpu_addr += size;
idx += 2;
if (idx > MAX_NR_INBOUND_MAPS) {
- dev_err(pcie->dev, "Failed to map inbound regions!\n");
+ dev_err(rcar->dev, "Failed to map inbound regions!\n");
return -EINVAL;
}
}
@@ -1035,7 +1035,7 @@ static int pci_dma_range_parser_init(struct of_pci_range_parser *parser,
return 0;
}
-static int rcar_pcie_parse_map_dma_ranges(struct rcar_pcie *pcie,
+static int rcar_pcie_parse_map_dma_ranges(struct rcar_pcie *rcar,
struct device_node *np)
{
struct of_pci_range range;
@@ -1050,10 +1050,10 @@ static int rcar_pcie_parse_map_dma_ranges(struct rcar_pcie *pcie,
for_each_of_pci_range(&parser, &range) {
u64 end = range.cpu_addr + range.size - 1;
- dev_dbg(pcie->dev, "0x%08x 0x%016llx..0x%016llx -> 0x%016llx\n",
+ dev_dbg(rcar->dev, "0x%08x 0x%016llx..0x%016llx -> 0x%016llx\n",
range.flags, range.cpu_addr, end, range.pci_addr);
- err = rcar_pcie_inbound_ranges(pcie, &range, &index);
+ err = rcar_pcie_inbound_ranges(rcar, &range, &index);
if (err)
return err;
}
@@ -1073,24 +1073,24 @@ static const struct of_device_id rcar_pcie_of_match[] = {
{},
};
-static int rcar_pcie_parse_request_of_pci_ranges(struct rcar_pcie *pci)
+static int rcar_pcie_parse_request_of_pci_ranges(struct rcar_pcie *rcar)
{
int err;
- struct device *dev = pci->dev;
+ struct device *dev = rcar->dev;
struct device_node *np = dev->of_node;
resource_size_t iobase;
struct resource_entry *win, *tmp;
- err = of_pci_get_host_bridge_resources(np, 0, 0xff, &pci->resources,
+ err = of_pci_get_host_bridge_resources(np, 0, 0xff, &rcar->resources,
&iobase);
if (err)
return err;
- err = devm_request_pci_bus_resources(dev, &pci->resources);
+ err = devm_request_pci_bus_resources(dev, &rcar->resources);
if (err)
goto out_release_res;
- resource_list_for_each_entry_safe(win, tmp, &pci->resources) {
+ resource_list_for_each_entry_safe(win, tmp, &rcar->resources) {
struct resource *res = win->res;
if (resource_type(res) == IORESOURCE_IO) {
@@ -1107,64 +1107,64 @@ static int rcar_pcie_parse_request_of_pci_ranges(struct rcar_pcie *pci)
return 0;
out_release_res:
- pci_free_resource_list(&pci->resources);
+ pci_free_resource_list(&rcar->resources);
return err;
}
static int rcar_pcie_probe(struct platform_device *pdev)
{
- struct rcar_pcie *pcie;
+ struct rcar_pcie *rcar;
unsigned int data;
const struct of_device_id *of_id;
int err;
int (*hw_init_fn)(struct rcar_pcie *);
- pcie = devm_kzalloc(&pdev->dev, sizeof(*pcie), GFP_KERNEL);
- if (!pcie)
+ rcar = devm_kzalloc(&pdev->dev, sizeof(*rcar), GFP_KERNEL);
+ if (!rcar)
return -ENOMEM;
- pcie->dev = &pdev->dev;
- platform_set_drvdata(pdev, pcie);
+ rcar->dev = &pdev->dev;
+ platform_set_drvdata(pdev, rcar);
- INIT_LIST_HEAD(&pcie->resources);
+ INIT_LIST_HEAD(&rcar->resources);
- rcar_pcie_parse_request_of_pci_ranges(pcie);
+ rcar_pcie_parse_request_of_pci_ranges(rcar);
- err = rcar_pcie_get_resources(pdev, pcie);
+ err = rcar_pcie_get_resources(pdev, rcar);
if (err < 0) {
dev_err(&pdev->dev, "failed to request resources: %d\n", err);
return err;
}
- err = rcar_pcie_parse_map_dma_ranges(pcie, pdev->dev.of_node);
+ err = rcar_pcie_parse_map_dma_ranges(rcar, pdev->dev.of_node);
if (err)
return err;
- of_id = of_match_device(rcar_pcie_of_match, pcie->dev);
+ of_id = of_match_device(rcar_pcie_of_match, rcar->dev);
if (!of_id || !of_id->data)
return -EINVAL;
hw_init_fn = of_id->data;
- pm_runtime_enable(pcie->dev);
- err = pm_runtime_get_sync(pcie->dev);
+ pm_runtime_enable(rcar->dev);
+ err = pm_runtime_get_sync(rcar->dev);
if (err < 0) {
- dev_err(pcie->dev, "pm_runtime_get_sync failed\n");
+ dev_err(rcar->dev, "pm_runtime_get_sync failed\n");
goto err_pm_disable;
}
/* Failure to get a link might just be that no cards are inserted */
- err = hw_init_fn(pcie);
+ err = hw_init_fn(rcar);
if (err) {
dev_info(&pdev->dev, "PCIe link down\n");
err = 0;
goto err_pm_put;
}
- data = rcar_readl(pcie, MACSR);
+ data = rcar_readl(rcar, MACSR);
dev_info(&pdev->dev, "PCIe x%d: link up\n", (data >> 20) & 0x3f);
if (IS_ENABLED(CONFIG_PCI_MSI)) {
- err = rcar_pcie_enable_msi(pcie);
+ err = rcar_pcie_enable_msi(rcar);
if (err < 0) {
dev_err(&pdev->dev,
"failed to enable MSI support: %d\n",
@@ -1173,17 +1173,17 @@ static int rcar_pcie_probe(struct platform_device *pdev)
}
}
- err = rcar_pcie_enable(pcie);
+ err = rcar_pcie_enable(rcar);
if (err)
goto err_pm_put;
return 0;
err_pm_put:
- pm_runtime_put(pcie->dev);
+ pm_runtime_put(rcar->dev);
err_pm_disable:
- pm_runtime_disable(pcie->dev);
+ pm_runtime_disable(rcar->dev);
return err;
}
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH 03/10] PCI: rcar: Swap order of rcar_writel() reg/val arguments
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
2016-10-07 16:24 ` [PATCH 02/10] PCI: rcar: Name private struct pointer "rcar" consistently Bjorn Helgaas
@ 2016-10-07 16:25 ` Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 04/10] PCI: rcar: Add local struct device pointers Bjorn Helgaas
` (7 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Bjorn Helgaas @ 2016-10-07 16:25 UTC (permalink / raw)
To: Simon Horman; +Cc: linux-renesas-soc, linux-pci
Swap order of rcar_writel() arguments to match the "dev, pos, val" order
used by pci_write_config_word() and other drivers. No functional change
intended.
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
drivers/pci/host/pcie-rcar.c | 90 +++++++++++++++++++++---------------------
1 file changed, 45 insertions(+), 45 deletions(-)
diff --git a/drivers/pci/host/pcie-rcar.c b/drivers/pci/host/pcie-rcar.c
index 145b54d..cd777e8 100644
--- a/drivers/pci/host/pcie-rcar.c
+++ b/drivers/pci/host/pcie-rcar.c
@@ -157,8 +157,8 @@ static unsigned long rcar_readl(struct rcar_pcie *rcar, unsigned long reg)
return readl(rcar->base + reg);
}
-static void rcar_writel(struct rcar_pcie *rcar, unsigned long val,
- unsigned long reg)
+static void rcar_writel(struct rcar_pcie *rcar, unsigned long reg,
+ unsigned long val)
{
writel(val, rcar->base + reg);
}
@@ -175,7 +175,7 @@ static void rcar_rmw32(struct rcar_pcie *rcar, int where, u32 mask, u32 data)
val &= ~(mask << shift);
val |= data << shift;
- rcar_writel(rcar, val, where & ~3);
+ rcar_writel(rcar, where & ~3, val);
}
static u32 rcar_read_conf(struct rcar_pcie *rcar, int where)
@@ -224,7 +224,7 @@ static int rcar_pcie_config_access(struct rcar_pcie *rcar,
if (pci_is_root_bus(bus) && (reg == PCI_PRIMARY_BUS))
rcar->root_bus_nr = *data & 0xff;
- rcar_writel(rcar, *data, PCICONF(index));
+ rcar_writel(rcar, PCICONF(index), *data);
}
return PCIBIOS_SUCCESSFUL;
@@ -234,17 +234,17 @@ static int rcar_pcie_config_access(struct rcar_pcie *rcar,
return PCIBIOS_DEVICE_NOT_FOUND;
/* Clear errors */
- rcar_writel(rcar, rcar_readl(rcar, PCIEERRFR), PCIEERRFR);
+ rcar_writel(rcar, PCIEERRFR, rcar_readl(rcar, PCIEERRFR));
/* Set the PIO address */
- rcar_writel(rcar, PCIE_CONF_BUS(bus->number) |
- PCIE_CONF_DEV(dev) | PCIE_CONF_FUNC(func) | reg, PCIECAR);
+ rcar_writel(rcar, PCIECAR, PCIE_CONF_BUS(bus->number) |
+ PCIE_CONF_DEV(dev) | PCIE_CONF_FUNC(func) | reg);
/* Enable the configuration access */
if (bus->parent->number == rcar->root_bus_nr)
- rcar_writel(rcar, CONFIG_SEND_ENABLE | TYPE0, PCIECCTLR);
+ rcar_writel(rcar, PCIECCTLR, CONFIG_SEND_ENABLE | TYPE0);
else
- rcar_writel(rcar, CONFIG_SEND_ENABLE | TYPE1, PCIECCTLR);
+ rcar_writel(rcar, PCIECCTLR, CONFIG_SEND_ENABLE | TYPE1);
/* Check for errors */
if (rcar_readl(rcar, PCIEERRFR) & UNSUPPORTED_REQUEST)
@@ -258,10 +258,10 @@ static int rcar_pcie_config_access(struct rcar_pcie *rcar,
if (access_type == RCAR_PCI_ACCESS_READ)
*data = rcar_readl(rcar, PCIECDR);
else
- rcar_writel(rcar, *data, PCIECDR);
+ rcar_writel(rcar, PCIECDR, *data);
/* Disable the configuration access */
- rcar_writel(rcar, 0, PCIECCTLR);
+ rcar_writel(rcar, PCIECCTLR, 0);
return PCIBIOS_SUCCESSFUL;
}
@@ -336,7 +336,7 @@ static void rcar_pcie_setup_window(int win, struct rcar_pcie *rcar,
resource_size_t res_start;
u32 mask;
- rcar_writel(rcar, 0x00000000, PCIEPTCTLR(win));
+ rcar_writel(rcar, PCIEPTCTLR(win), 0x00000000);
/*
* The PAMR mask is calculated in units of 128Bytes, which
@@ -344,22 +344,22 @@ static void rcar_pcie_setup_window(int win, struct rcar_pcie *rcar,
*/
size = resource_size(res);
mask = (roundup_pow_of_two(size) / SZ_128) - 1;
- rcar_writel(rcar, mask << 7, PCIEPAMR(win));
+ rcar_writel(rcar, PCIEPAMR(win), mask << 7);
if (res->flags & IORESOURCE_IO)
res_start = pci_pio_to_address(res->start);
else
res_start = res->start;
- rcar_writel(rcar, upper_32_bits(res_start), PCIEPAUR(win));
- rcar_writel(rcar, lower_32_bits(res_start) & ~0x7F, PCIEPALR(win));
+ rcar_writel(rcar, PCIEPAUR(win), upper_32_bits(res_start));
+ rcar_writel(rcar, PCIEPALR(win), lower_32_bits(res_start) & ~0x7F);
/* First resource is for IO */
mask = PAR_ENABLE;
if (res->flags & IORESOURCE_IO)
mask |= IO_SPACE;
- rcar_writel(rcar, mask, PCIEPTCTLR(win));
+ rcar_writel(rcar, PCIEPTCTLR(win), mask);
}
static int rcar_pcie_setup(struct list_head *resource, struct rcar_pcie *pci)
@@ -419,7 +419,7 @@ static void rcar_pcie_force_speedup(struct rcar_pcie *rcar)
/* Clear SPCHGFIN, SPCHGSUC, and SPCHGFAIL */
if (macsr & (SPCHGFIN | SPCHGSUC | SPCHGFAIL))
- rcar_writel(rcar, macsr, MACSR);
+ rcar_writel(rcar, MACSR, macsr);
/* Start link speed change */
rcar_rmw32(rcar, MACCTLR, SPEED_CHANGE, SPEED_CHANGE);
@@ -428,7 +428,7 @@ static void rcar_pcie_force_speedup(struct rcar_pcie *rcar)
macsr = rcar_readl(rcar, MACSR);
if (macsr & SPCHGFIN) {
/* Clear the interrupt bits */
- rcar_writel(rcar, macsr, MACSR);
+ rcar_writel(rcar, MACSR, macsr);
if (macsr & SPCHGFAIL)
dev_err(rcar->dev, "Speed change failed\n");
@@ -511,15 +511,15 @@ static void phy_write_reg(struct rcar_pcie *rcar,
((addr & 0xff) << ADR_POS);
/* Set write data */
- rcar_writel(rcar, data, H1_PCIEPHYDOUTR);
- rcar_writel(rcar, phyaddr, H1_PCIEPHYADRR);
+ rcar_writel(rcar, H1_PCIEPHYDOUTR, data);
+ rcar_writel(rcar, H1_PCIEPHYADRR, phyaddr);
/* Ignore errors as they will be dealt with if the data link is down */
phy_wait_for_ack(rcar);
/* Clear command */
- rcar_writel(rcar, 0, H1_PCIEPHYDOUTR);
- rcar_writel(rcar, 0, H1_PCIEPHYADRR);
+ rcar_writel(rcar, H1_PCIEPHYDOUTR, 0);
+ rcar_writel(rcar, H1_PCIEPHYADRR, 0);
/* Ignore errors as they will be dealt with if the data link is down */
phy_wait_for_ack(rcar);
@@ -544,17 +544,17 @@ static int rcar_pcie_hw_init(struct rcar_pcie *rcar)
int err;
/* Begin initialization */
- rcar_writel(rcar, 0, PCIETCTLR);
+ rcar_writel(rcar, PCIETCTLR, 0);
/* Set mode */
- rcar_writel(rcar, 1, PCIEMSR);
+ rcar_writel(rcar, PCIEMSR, 1);
/*
* Initial header for port config space is type 1, set the device
* class to match. Hardware takes care of propagating the IDSETR
* settings, so there is no need to bother with a quirk.
*/
- rcar_writel(rcar, PCI_CLASS_BRIDGE_PCI << 16, IDSETR1);
+ rcar_writel(rcar, IDSETR1, PCI_CLASS_BRIDGE_PCI << 16);
/*
* Setup Secondary Bus Number & Subordinate Bus Number, even though
@@ -585,10 +585,10 @@ static int rcar_pcie_hw_init(struct rcar_pcie *rcar)
/* Enable MSI */
if (IS_ENABLED(CONFIG_PCI_MSI))
- rcar_writel(rcar, 0x801f0000, PCIEMSITXR);
+ rcar_writel(rcar, PCIEMSITXR, 0x801f0000);
/* Finish initialization - establish a PCI Express link */
- rcar_writel(rcar, CFINIT, PCIETCTLR);
+ rcar_writel(rcar, PCIETCTLR, CFINIT);
/* This will timeout if we don't have a link. */
err = rcar_pcie_wait_for_dl(rcar);
@@ -641,16 +641,16 @@ static int rcar_pcie_hw_init_gen2(struct rcar_pcie *rcar)
* These settings come from the R-Car Series, 2nd Generation User's
* Manual, section 50.3.1 (2) Initialization of the physical layer.
*/
- rcar_writel(rcar, 0x000f0030, GEN2_PCIEPHYADDR);
- rcar_writel(rcar, 0x00381203, GEN2_PCIEPHYDATA);
- rcar_writel(rcar, 0x00000001, GEN2_PCIEPHYCTRL);
- rcar_writel(rcar, 0x00000006, GEN2_PCIEPHYCTRL);
+ rcar_writel(rcar, GEN2_PCIEPHYADDR, 0x000f0030);
+ rcar_writel(rcar, GEN2_PCIEPHYDATA, 0x00381203);
+ rcar_writel(rcar, GEN2_PCIEPHYCTRL, 0x00000001);
+ rcar_writel(rcar, GEN2_PCIEPHYCTRL, 0x00000006);
- rcar_writel(rcar, 0x000f0054, GEN2_PCIEPHYADDR);
+ rcar_writel(rcar, GEN2_PCIEPHYADDR, 0x000f0054);
/* The following value is for DC connection, no termination resistor */
- rcar_writel(rcar, 0x13802007, GEN2_PCIEPHYDATA);
- rcar_writel(rcar, 0x00000001, GEN2_PCIEPHYCTRL);
- rcar_writel(rcar, 0x00000006, GEN2_PCIEPHYCTRL);
+ rcar_writel(rcar, GEN2_PCIEPHYDATA, 0x13802007);
+ rcar_writel(rcar, GEN2_PCIEPHYCTRL, 0x00000001);
+ rcar_writel(rcar, GEN2_PCIEPHYCTRL, 0x00000006);
return rcar_pcie_hw_init(rcar);
}
@@ -708,7 +708,7 @@ static irqreturn_t rcar_pcie_msi_irq(int irq, void *data)
unsigned int irq;
/* clear the interrupt */
- rcar_writel(rcar, 1 << index, PCIEMSIFR);
+ rcar_writel(rcar, PCIEMSIFR, 1 << index);
irq = irq_find_mapping(msi->domain, index);
if (irq) {
@@ -884,11 +884,11 @@ static int rcar_pcie_enable_msi(struct rcar_pcie *rcar)
msi->pages = __get_free_pages(GFP_KERNEL, 0);
base = virt_to_phys((void *)msi->pages);
- rcar_writel(rcar, base | MSIFE, PCIEMSIALR);
- rcar_writel(rcar, 0, PCIEMSIAUR);
+ rcar_writel(rcar, PCIEMSIALR, base | MSIFE);
+ rcar_writel(rcar, PCIEMSIAUR, 0);
/* enable all MSI interrupts */
- rcar_writel(rcar, 0xffffffff, PCIEMSIIER);
+ rcar_writel(rcar, PCIEMSIIER, 0xffffffff);
return 0;
@@ -995,13 +995,13 @@ static int rcar_pcie_inbound_ranges(struct rcar_pcie *rcar,
* Set up 64-bit inbound regions as the range parser doesn't
* distinguish between 32 and 64-bit types.
*/
- rcar_writel(rcar, lower_32_bits(pci_addr), PCIEPRAR(idx));
- rcar_writel(rcar, lower_32_bits(cpu_addr), PCIELAR(idx));
- rcar_writel(rcar, lower_32_bits(mask) | flags, PCIELAMR(idx));
+ rcar_writel(rcar, PCIEPRAR(idx), lower_32_bits(pci_addr));
+ rcar_writel(rcar, PCIELAR(idx), lower_32_bits(cpu_addr));
+ rcar_writel(rcar, PCIELAMR(idx), lower_32_bits(mask) | flags);
- rcar_writel(rcar, upper_32_bits(pci_addr), PCIEPRAR(idx + 1));
- rcar_writel(rcar, upper_32_bits(cpu_addr), PCIELAR(idx + 1));
- rcar_writel(rcar, 0, PCIELAMR(idx + 1));
+ rcar_writel(rcar, PCIEPRAR(idx + 1), upper_32_bits(pci_addr));
+ rcar_writel(rcar, PCIELAR(idx + 1), upper_32_bits(cpu_addr));
+ rcar_writel(rcar, PCIELAMR(idx + 1), 0);
pci_addr += size;
cpu_addr += size;
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH 04/10] PCI: rcar: Add local struct device pointers
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
2016-10-07 16:24 ` [PATCH 02/10] PCI: rcar: Name private struct pointer "rcar" consistently Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 03/10] PCI: rcar: Swap order of rcar_writel() reg/val arguments Bjorn Helgaas
@ 2016-10-07 16:25 ` Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 05/10] PCI: rcar: Remove unused rcar_pcie_get_resources() platform_device arg Bjorn Helgaas
` (6 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Bjorn Helgaas @ 2016-10-07 16:25 UTC (permalink / raw)
To: Simon Horman; +Cc: linux-renesas-soc, linux-pci
Use a local "struct device *dev" for brevity and consistency with other
drivers. No functional change intended.
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
drivers/pci/host/pcie-rcar.c | 92 +++++++++++++++++++++---------------------
1 file changed, 47 insertions(+), 45 deletions(-)
diff --git a/drivers/pci/host/pcie-rcar.c b/drivers/pci/host/pcie-rcar.c
index cd777e8..c28ac93 100644
--- a/drivers/pci/host/pcie-rcar.c
+++ b/drivers/pci/host/pcie-rcar.c
@@ -395,6 +395,7 @@ static int rcar_pcie_setup(struct list_head *resource, struct rcar_pcie *pci)
static void rcar_pcie_force_speedup(struct rcar_pcie *rcar)
{
+ struct device *dev = rcar->dev;
unsigned int timeout = 1000;
u32 macsr;
@@ -402,7 +403,7 @@ static void rcar_pcie_force_speedup(struct rcar_pcie *rcar)
return;
if (rcar_readl(rcar, MACCTLR) & SPEED_CHANGE) {
- dev_err(rcar->dev, "Speed change already in progress\n");
+ dev_err(dev, "Speed change already in progress\n");
return;
}
@@ -431,7 +432,7 @@ static void rcar_pcie_force_speedup(struct rcar_pcie *rcar)
rcar_writel(rcar, MACSR, macsr);
if (macsr & SPCHGFAIL)
- dev_err(rcar->dev, "Speed change failed\n");
+ dev_err(dev, "Speed change failed\n");
goto done;
}
@@ -439,15 +440,16 @@ static void rcar_pcie_force_speedup(struct rcar_pcie *rcar)
msleep(1);
};
- dev_err(rcar->dev, "Speed change timed out\n");
+ dev_err(dev, "Speed change timed out\n");
done:
- dev_info(rcar->dev, "Current link speed is %s GT/s\n",
+ dev_info(dev, "Current link speed is %s GT/s\n",
(macsr & LINK_SPEED) == LINK_SPEED_5_0GTS ? "5" : "2.5");
}
static int rcar_pcie_enable(struct rcar_pcie *rcar)
{
+ struct device *dev = rcar->dev;
struct pci_bus *bus, *child;
LIST_HEAD(res);
@@ -459,14 +461,14 @@ static int rcar_pcie_enable(struct rcar_pcie *rcar)
pci_add_flags(PCI_REASSIGN_ALL_RSRC | PCI_REASSIGN_ALL_BUS);
if (IS_ENABLED(CONFIG_PCI_MSI))
- bus = pci_scan_root_bus_msi(rcar->dev, rcar->root_bus_nr,
+ bus = pci_scan_root_bus_msi(dev, rcar->root_bus_nr,
&rcar_pcie_ops, rcar, &res, &rcar->msi.chip);
else
- bus = pci_scan_root_bus(rcar->dev, rcar->root_bus_nr,
+ bus = pci_scan_root_bus(dev, rcar->root_bus_nr,
&rcar_pcie_ops, rcar, &res);
if (!bus) {
- dev_err(rcar->dev, "Scanning rootbus failed");
+ dev_err(dev, "Scanning rootbus failed");
return -ENODEV;
}
@@ -479,12 +481,12 @@ static int rcar_pcie_enable(struct rcar_pcie *rcar)
pcie_bus_configure_settings(child);
pci_bus_add_devices(bus);
-
return 0;
}
static int phy_wait_for_ack(struct rcar_pcie *rcar)
{
+ struct device *dev = rcar->dev;
unsigned int timeout = 100;
while (timeout--) {
@@ -494,8 +496,7 @@ static int phy_wait_for_ack(struct rcar_pcie *rcar)
udelay(100);
}
- dev_err(rcar->dev, "Access to PCIe phy timed out\n");
-
+ dev_err(dev, "Access to PCIe phy timed out\n");
return -ETIMEDOUT;
}
@@ -694,6 +695,7 @@ static void rcar_msi_free(struct rcar_msi *chip, unsigned long irq)
static irqreturn_t rcar_pcie_msi_irq(int irq, void *data)
{
struct rcar_pcie *rcar = data;
+ struct device *dev = rcar->dev;
struct rcar_msi *msi = &rcar->msi;
unsigned long reg;
@@ -715,10 +717,10 @@ static irqreturn_t rcar_pcie_msi_irq(int irq, void *data)
if (test_bit(index, msi->used))
generic_handle_irq(irq);
else
- dev_info(rcar->dev, "unhandled MSI\n");
+ dev_info(dev, "unhandled MSI\n");
} else {
/* Unknown MSI, just clear it */
- dev_dbg(rcar->dev, "unexpected MSI\n");
+ dev_dbg(dev, "unexpected MSI\n");
}
/* see if there's any more pending in this vector */
@@ -841,22 +843,22 @@ static const struct irq_domain_ops msi_domain_ops = {
static int rcar_pcie_enable_msi(struct rcar_pcie *rcar)
{
- struct platform_device *pdev = to_platform_device(rcar->dev);
+ struct device *dev = rcar->dev;
struct rcar_msi *msi = &rcar->msi;
unsigned long base;
int err, i;
mutex_init(&msi->lock);
- msi->chip.dev = rcar->dev;
+ msi->chip.dev = dev;
msi->chip.setup_irq = rcar_msi_setup_irq;
msi->chip.setup_irqs = rcar_msi_setup_irqs;
msi->chip.teardown_irq = rcar_msi_teardown_irq;
- msi->domain = irq_domain_add_linear(rcar->dev->of_node, INT_PCI_MSI_NR,
+ msi->domain = irq_domain_add_linear(dev->of_node, INT_PCI_MSI_NR,
&msi_domain_ops, &msi->chip);
if (!msi->domain) {
- dev_err(&pdev->dev, "failed to create IRQ domain\n");
+ dev_err(dev, "failed to create IRQ domain\n");
return -ENOMEM;
}
@@ -864,19 +866,19 @@ static int rcar_pcie_enable_msi(struct rcar_pcie *rcar)
irq_create_mapping(msi->domain, i);
/* Two irqs are for MSI, but they are also used for non-MSI irqs */
- err = devm_request_irq(&pdev->dev, msi->irq1, rcar_pcie_msi_irq,
+ err = devm_request_irq(dev, msi->irq1, rcar_pcie_msi_irq,
IRQF_SHARED | IRQF_NO_THREAD,
rcar_msi_irq_chip.name, rcar);
if (err < 0) {
- dev_err(&pdev->dev, "failed to request IRQ: %d\n", err);
+ dev_err(dev, "failed to request IRQ: %d\n", err);
goto err;
}
- err = devm_request_irq(&pdev->dev, msi->irq2, rcar_pcie_msi_irq,
+ err = devm_request_irq(dev, msi->irq2, rcar_pcie_msi_irq,
IRQF_SHARED | IRQF_NO_THREAD,
rcar_msi_irq_chip.name, rcar);
if (err < 0) {
- dev_err(&pdev->dev, "failed to request IRQ: %d\n", err);
+ dev_err(dev, "failed to request IRQ: %d\n", err);
goto err;
}
@@ -900,29 +902,30 @@ err:
static int rcar_pcie_get_resources(struct platform_device *pdev,
struct rcar_pcie *rcar)
{
+ struct device *dev = rcar->dev;
struct resource res;
int err, i;
- err = of_address_to_resource(pdev->dev.of_node, 0, &res);
+ err = of_address_to_resource(dev->of_node, 0, &res);
if (err)
return err;
- rcar->base = devm_ioremap_resource(&pdev->dev, &res);
+ rcar->base = devm_ioremap_resource(dev, &res);
if (IS_ERR(rcar->base))
return PTR_ERR(rcar->base);
- rcar->clk = devm_clk_get(&pdev->dev, "pcie");
+ rcar->clk = devm_clk_get(dev, "pcie");
if (IS_ERR(rcar->clk)) {
- dev_err(rcar->dev, "cannot get platform clock\n");
+ dev_err(dev, "cannot get platform clock\n");
return PTR_ERR(rcar->clk);
}
err = clk_prepare_enable(rcar->clk);
if (err)
return err;
- rcar->bus_clk = devm_clk_get(&pdev->dev, "pcie_bus");
+ rcar->bus_clk = devm_clk_get(dev, "pcie_bus");
if (IS_ERR(rcar->bus_clk)) {
- dev_err(rcar->dev, "cannot get pcie bus clock\n");
+ dev_err(dev, "cannot get pcie bus clock\n");
err = PTR_ERR(rcar->bus_clk);
goto fail_clk;
}
@@ -930,17 +933,17 @@ static int rcar_pcie_get_resources(struct platform_device *pdev,
if (err)
goto fail_clk;
- i = irq_of_parse_and_map(pdev->dev.of_node, 0);
+ i = irq_of_parse_and_map(dev->of_node, 0);
if (!i) {
- dev_err(rcar->dev, "cannot get platform resources for msi interrupt\n");
+ dev_err(dev, "cannot get platform resources for msi interrupt\n");
err = -ENOENT;
goto err_map_reg;
}
rcar->msi.irq1 = i;
- i = irq_of_parse_and_map(pdev->dev.of_node, 1);
+ i = irq_of_parse_and_map(dev->of_node, 1);
if (!i) {
- dev_err(rcar->dev, "cannot get platform resources for msi interrupt\n");
+ dev_err(dev, "cannot get platform resources for msi interrupt\n");
err = -ENOENT;
goto err_map_reg;
}
@@ -952,7 +955,6 @@ err_map_reg:
clk_disable_unprepare(rcar->bus_clk);
fail_clk:
clk_disable_unprepare(rcar->clk);
-
return err;
}
@@ -1113,17 +1115,18 @@ out_release_res:
static int rcar_pcie_probe(struct platform_device *pdev)
{
+ struct device *dev = &pdev->dev;
struct rcar_pcie *rcar;
unsigned int data;
const struct of_device_id *of_id;
int err;
int (*hw_init_fn)(struct rcar_pcie *);
- rcar = devm_kzalloc(&pdev->dev, sizeof(*rcar), GFP_KERNEL);
+ rcar = devm_kzalloc(dev, sizeof(*rcar), GFP_KERNEL);
if (!rcar)
return -ENOMEM;
- rcar->dev = &pdev->dev;
+ rcar->dev = dev;
platform_set_drvdata(pdev, rcar);
INIT_LIST_HEAD(&rcar->resources);
@@ -1132,42 +1135,41 @@ static int rcar_pcie_probe(struct platform_device *pdev)
err = rcar_pcie_get_resources(pdev, rcar);
if (err < 0) {
- dev_err(&pdev->dev, "failed to request resources: %d\n", err);
+ dev_err(dev, "failed to request resources: %d\n", err);
return err;
}
- err = rcar_pcie_parse_map_dma_ranges(rcar, pdev->dev.of_node);
+ err = rcar_pcie_parse_map_dma_ranges(rcar, dev->of_node);
if (err)
return err;
- of_id = of_match_device(rcar_pcie_of_match, rcar->dev);
+ of_id = of_match_device(rcar_pcie_of_match, dev);
if (!of_id || !of_id->data)
return -EINVAL;
hw_init_fn = of_id->data;
- pm_runtime_enable(rcar->dev);
- err = pm_runtime_get_sync(rcar->dev);
+ pm_runtime_enable(dev);
+ err = pm_runtime_get_sync(dev);
if (err < 0) {
- dev_err(rcar->dev, "pm_runtime_get_sync failed\n");
+ dev_err(dev, "pm_runtime_get_sync failed\n");
goto err_pm_disable;
}
/* Failure to get a link might just be that no cards are inserted */
err = hw_init_fn(rcar);
if (err) {
- dev_info(&pdev->dev, "PCIe link down\n");
+ dev_info(dev, "PCIe link down\n");
err = 0;
goto err_pm_put;
}
data = rcar_readl(rcar, MACSR);
- dev_info(&pdev->dev, "PCIe x%d: link up\n", (data >> 20) & 0x3f);
+ dev_info(dev, "PCIe x%d: link up\n", (data >> 20) & 0x3f);
if (IS_ENABLED(CONFIG_PCI_MSI)) {
err = rcar_pcie_enable_msi(rcar);
if (err < 0) {
- dev_err(&pdev->dev,
- "failed to enable MSI support: %d\n",
+ dev_err(dev, "failed to enable MSI support: %d\n",
err);
goto err_pm_put;
}
@@ -1180,10 +1182,10 @@ static int rcar_pcie_probe(struct platform_device *pdev)
return 0;
err_pm_put:
- pm_runtime_put(rcar->dev);
+ pm_runtime_put(dev);
err_pm_disable:
- pm_runtime_disable(rcar->dev);
+ pm_runtime_disable(dev);
return err;
}
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH 05/10] PCI: rcar: Remove unused rcar_pcie_get_resources() platform_device arg
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
` (2 preceding siblings ...)
2016-10-07 16:25 ` [PATCH 04/10] PCI: rcar: Add local struct device pointers Bjorn Helgaas
@ 2016-10-07 16:25 ` Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 06/10] PCI: rcar: Remove unused platform data Bjorn Helgaas
` (5 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Bjorn Helgaas @ 2016-10-07 16:25 UTC (permalink / raw)
To: Simon Horman; +Cc: linux-renesas-soc, linux-pci
rcar_pcie_get_resources() doesn't use the platform_device pointer passed to
it, so remove it. No functional change intended.
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
drivers/pci/host/pcie-rcar.c | 5 ++---
1 file changed, 2 insertions(+), 3 deletions(-)
diff --git a/drivers/pci/host/pcie-rcar.c b/drivers/pci/host/pcie-rcar.c
index c28ac93..5a8969f 100644
--- a/drivers/pci/host/pcie-rcar.c
+++ b/drivers/pci/host/pcie-rcar.c
@@ -899,8 +899,7 @@ err:
return err;
}
-static int rcar_pcie_get_resources(struct platform_device *pdev,
- struct rcar_pcie *rcar)
+static int rcar_pcie_get_resources(struct rcar_pcie *rcar)
{
struct device *dev = rcar->dev;
struct resource res;
@@ -1133,7 +1132,7 @@ static int rcar_pcie_probe(struct platform_device *pdev)
rcar_pcie_parse_request_of_pci_ranges(rcar);
- err = rcar_pcie_get_resources(pdev, rcar);
+ err = rcar_pcie_get_resources(rcar);
if (err < 0) {
dev_err(dev, "failed to request resources: %d\n", err);
return err;
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH 06/10] PCI: rcar: Remove unused platform data
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
` (3 preceding siblings ...)
2016-10-07 16:25 ` [PATCH 05/10] PCI: rcar: Remove unused rcar_pcie_get_resources() platform_device arg Bjorn Helgaas
@ 2016-10-07 16:25 ` Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 07/10] PCI: rcar: Remove DRV_NAME macro Bjorn Helgaas
` (4 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Bjorn Helgaas @ 2016-10-07 16:25 UTC (permalink / raw)
To: Simon Horman; +Cc: linux-renesas-soc, linux-pci
The rcar driver never uses the platform drvdata pointer, so don't bother
setting it. No functional change intended.
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
drivers/pci/host/pcie-rcar.c | 1 -
1 file changed, 1 deletion(-)
diff --git a/drivers/pci/host/pcie-rcar.c b/drivers/pci/host/pcie-rcar.c
index 5a8969f..02a90f4 100644
--- a/drivers/pci/host/pcie-rcar.c
+++ b/drivers/pci/host/pcie-rcar.c
@@ -1126,7 +1126,6 @@ static int rcar_pcie_probe(struct platform_device *pdev)
return -ENOMEM;
rcar->dev = dev;
- platform_set_drvdata(pdev, rcar);
INIT_LIST_HEAD(&rcar->resources);
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH 07/10] PCI: rcar: Remove DRV_NAME macro
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
` (4 preceding siblings ...)
2016-10-07 16:25 ` [PATCH 06/10] PCI: rcar: Remove unused platform data Bjorn Helgaas
@ 2016-10-07 16:25 ` Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 08/10] PCI: rcar-gen2: Name private struct pointer "rcar" consistently Bjorn Helgaas
` (3 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Bjorn Helgaas @ 2016-10-07 16:25 UTC (permalink / raw)
To: Simon Horman; +Cc: linux-renesas-soc, linux-pci
The DRV_NAME macro is only used once, so there's no real advantage to
having the macro at all. Remove it and use the "rcar-pcie" name directly
in the struct platform_driver. No functional change intended.
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
drivers/pci/host/pcie-rcar.c | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/drivers/pci/host/pcie-rcar.c b/drivers/pci/host/pcie-rcar.c
index 02a90f4..17a2595 100644
--- a/drivers/pci/host/pcie-rcar.c
+++ b/drivers/pci/host/pcie-rcar.c
@@ -31,8 +31,6 @@
#include <linux/pm_runtime.h>
#include <linux/slab.h>
-#define DRV_NAME "rcar-pcie"
-
#define PCIECAR 0x000010
#define PCIECCTLR 0x000018
#define CONFIG_SEND_ENABLE (1 << 31)
@@ -1189,7 +1187,7 @@ err_pm_disable:
static struct platform_driver rcar_pcie_driver = {
.driver = {
- .name = DRV_NAME,
+ .name = "rcar-pcie",
.of_match_table = rcar_pcie_of_match,
.suppress_bind_attrs = true,
},
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH 08/10] PCI: rcar-gen2: Name private struct pointer "rcar" consistently
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
` (5 preceding siblings ...)
2016-10-07 16:25 ` [PATCH 07/10] PCI: rcar: Remove DRV_NAME macro Bjorn Helgaas
@ 2016-10-07 16:25 ` Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 09/10] PCI: rcar-gen2: Add register accessors Bjorn Helgaas
` (2 subsequent siblings)
9 siblings, 0 replies; 11+ messages in thread
From: Bjorn Helgaas @ 2016-10-07 16:25 UTC (permalink / raw)
To: Simon Horman; +Cc: linux-renesas-soc, linux-pci
Rename struct rcar_pci_priv to rcar_pci, along the lines of other drivers.
Use a device-specific name, "rcar", for struct rcar_pci pointers
to hint that this is device-specific information. No functional change
intended.
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
drivers/pci/host/pci-rcar-gen2.c | 121 +++++++++++++++++++-------------------
1 file changed, 60 insertions(+), 61 deletions(-)
diff --git a/drivers/pci/host/pci-rcar-gen2.c b/drivers/pci/host/pci-rcar-gen2.c
index 597566f..cba27bc 100644
--- a/drivers/pci/host/pci-rcar-gen2.c
+++ b/drivers/pci/host/pci-rcar-gen2.c
@@ -95,7 +95,7 @@
#define RCAR_PCI_UNIT_REV_REG (RCAR_AHBPCI_PCICOM_OFFSET + 0x48)
-struct rcar_pci_priv {
+struct rcar_pci {
struct device *dev;
void __iomem *reg;
struct resource mem_res;
@@ -112,7 +112,7 @@ static void __iomem *rcar_pci_cfg_base(struct pci_bus *bus, unsigned int devfn,
int where)
{
struct pci_sys_data *sys = bus->sysdata;
- struct rcar_pci_priv *priv = sys->private_data;
+ struct rcar_pci *rcar = sys->private_data;
int slot, val;
if (sys->busnr != bus->number || PCI_FUNC(devfn))
@@ -130,20 +130,20 @@ static void __iomem *rcar_pci_cfg_base(struct pci_bus *bus, unsigned int devfn,
val = slot ? RCAR_AHBPCI_WIN1_DEVICE | RCAR_AHBPCI_WIN_CTR_CFG :
RCAR_AHBPCI_WIN1_HOST | RCAR_AHBPCI_WIN_CTR_CFG;
- iowrite32(val, priv->reg + RCAR_AHBPCI_WIN1_CTR_REG);
- return priv->reg + (slot >> 1) * 0x100 + where;
+ iowrite32(val, rcar->reg + RCAR_AHBPCI_WIN1_CTR_REG);
+ return rcar->reg + (slot >> 1) * 0x100 + where;
}
/* PCI interrupt mapping */
static int rcar_pci_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
{
struct pci_sys_data *sys = dev->bus->sysdata;
- struct rcar_pci_priv *priv = sys->private_data;
+ struct rcar_pci *rcar = sys->private_data;
int irq;
irq = of_irq_parse_and_map_pci(dev, slot, pin);
if (!irq)
- irq = priv->irq;
+ irq = rcar->irq;
return irq;
}
@@ -153,54 +153,54 @@ static int rcar_pci_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
static irqreturn_t rcar_pci_err_irq(int irq, void *pw)
{
- struct rcar_pci_priv *priv = pw;
- u32 status = ioread32(priv->reg + RCAR_PCI_INT_STATUS_REG);
+ struct rcar_pci *rcar = pw;
+ u32 status = ioread32(rcar->reg + RCAR_PCI_INT_STATUS_REG);
if (status & RCAR_PCI_INT_ALLERRORS) {
- dev_err(priv->dev, "error irq: status %08x\n", status);
+ dev_err(rcar->dev, "error irq: status %08x\n", status);
/* clear the error(s) */
iowrite32(status & RCAR_PCI_INT_ALLERRORS,
- priv->reg + RCAR_PCI_INT_STATUS_REG);
+ rcar->reg + RCAR_PCI_INT_STATUS_REG);
return IRQ_HANDLED;
}
return IRQ_NONE;
}
-static void rcar_pci_setup_errirq(struct rcar_pci_priv *priv)
+static void rcar_pci_setup_errirq(struct rcar_pci *rcar)
{
int ret;
u32 val;
- ret = devm_request_irq(priv->dev, priv->irq, rcar_pci_err_irq,
- IRQF_SHARED, "error irq", priv);
+ ret = devm_request_irq(rcar->dev, rcar->irq, rcar_pci_err_irq,
+ IRQF_SHARED, "error irq", rcar);
if (ret) {
- dev_err(priv->dev, "cannot claim IRQ for error handling\n");
+ dev_err(rcar->dev, "cannot claim IRQ for error handling\n");
return;
}
- val = ioread32(priv->reg + RCAR_PCI_INT_ENABLE_REG);
+ val = ioread32(rcar->reg + RCAR_PCI_INT_ENABLE_REG);
val |= RCAR_PCI_INT_ALLERRORS;
- iowrite32(val, priv->reg + RCAR_PCI_INT_ENABLE_REG);
+ iowrite32(val, rcar->reg + RCAR_PCI_INT_ENABLE_REG);
}
#else
-static inline void rcar_pci_setup_errirq(struct rcar_pci_priv *priv) { }
+static inline void rcar_pci_setup_errirq(struct rcar_pci *rcar) { }
#endif
/* PCI host controller setup */
static int rcar_pci_setup(int nr, struct pci_sys_data *sys)
{
- struct rcar_pci_priv *priv = sys->private_data;
- void __iomem *reg = priv->reg;
+ struct rcar_pci *rcar = sys->private_data;
+ void __iomem *reg = rcar->reg;
u32 val;
int ret;
- pm_runtime_enable(priv->dev);
- pm_runtime_get_sync(priv->dev);
+ pm_runtime_enable(rcar->dev);
+ pm_runtime_get_sync(rcar->dev);
val = ioread32(reg + RCAR_PCI_UNIT_REV_REG);
- dev_info(priv->dev, "PCI: bus%u revision %x\n", sys->busnr, val);
+ dev_info(rcar->dev, "PCI: bus%u revision %x\n", sys->busnr, val);
/* Disable Direct Power Down State and assert reset */
val = ioread32(reg + RCAR_USBCTR_REG) & ~RCAR_USBCTR_DIRPD;
@@ -213,7 +213,7 @@ static int rcar_pci_setup(int nr, struct pci_sys_data *sys)
RCAR_USBCTR_USBH_RST | RCAR_USBCTR_PLL_RST);
/* Setup PCIAHB window1 size */
- switch (priv->window_size) {
+ switch (rcar->window_size) {
case SZ_2G:
val |= RCAR_USBCTR_PCIAHB_WIN1_2G;
break;
@@ -225,8 +225,8 @@ static int rcar_pci_setup(int nr, struct pci_sys_data *sys)
break;
default:
pr_warn("unknown window size %ld - defaulting to 256M\n",
- priv->window_size);
- priv->window_size = SZ_256M;
+ rcar->window_size);
+ rcar->window_size = SZ_256M;
/* fall-through */
case SZ_256M:
val |= RCAR_USBCTR_PCIAHB_WIN1_256M;
@@ -244,21 +244,21 @@ static int rcar_pci_setup(int nr, struct pci_sys_data *sys)
iowrite32(val, reg + RCAR_PCI_ARBITER_CTR_REG);
/* PCI-AHB mapping */
- iowrite32(priv->window_addr | RCAR_PCIAHB_PREFETCH16,
+ iowrite32(rcar->window_addr | RCAR_PCIAHB_PREFETCH16,
reg + RCAR_PCIAHB_WIN1_CTR_REG);
/* AHB-PCI mapping: OHCI/EHCI registers */
- val = priv->mem_res.start | RCAR_AHBPCI_WIN_CTR_MEM;
+ val = rcar->mem_res.start | RCAR_AHBPCI_WIN_CTR_MEM;
iowrite32(val, reg + RCAR_AHBPCI_WIN2_CTR_REG);
/* Enable AHB-PCI bridge PCI configuration access */
iowrite32(RCAR_AHBPCI_WIN1_HOST | RCAR_AHBPCI_WIN_CTR_CFG,
reg + RCAR_AHBPCI_WIN1_CTR_REG);
/* Set PCI-AHB Window1 address */
- iowrite32(priv->window_pci | PCI_BASE_ADDRESS_MEM_PREFETCH,
+ iowrite32(rcar->window_pci | PCI_BASE_ADDRESS_MEM_PREFETCH,
reg + PCI_BASE_ADDRESS_1);
/* Set AHB-PCI bridge PCI communication area address */
- val = priv->cfg_res->start + RCAR_AHBPCI_PCICOM_OFFSET;
+ val = rcar->cfg_res->start + RCAR_AHBPCI_PCICOM_OFFSET;
iowrite32(val, reg + PCI_BASE_ADDRESS_0);
val = ioread32(reg + PCI_COMMAND);
@@ -270,17 +270,17 @@ static int rcar_pci_setup(int nr, struct pci_sys_data *sys)
iowrite32(RCAR_PCI_INT_A | RCAR_PCI_INT_B | RCAR_PCI_INT_PME,
reg + RCAR_PCI_INT_ENABLE_REG);
- if (priv->irq > 0)
- rcar_pci_setup_errirq(priv);
+ if (rcar->irq > 0)
+ rcar_pci_setup_errirq(rcar);
/* Add PCI resources */
- pci_add_resource(&sys->resources, &priv->mem_res);
- ret = devm_request_pci_bus_resources(priv->dev, &sys->resources);
+ pci_add_resource(&sys->resources, &rcar->mem_res);
+ ret = devm_request_pci_bus_resources(rcar->dev, &sys->resources);
if (ret < 0)
return ret;
/* Setup bus number based on platform device id / of bus-range */
- sys->busnr = priv->busnr;
+ sys->busnr = rcar->busnr;
return 1;
}
@@ -308,7 +308,7 @@ static int pci_dma_range_parser_init(struct of_pci_range_parser *parser,
return 0;
}
-static int rcar_pci_parse_map_dma_ranges(struct rcar_pci_priv *pci,
+static int rcar_pci_parse_map_dma_ranges(struct rcar_pci *rcar,
struct device_node *np)
{
struct of_pci_range range;
@@ -325,20 +325,20 @@ static int rcar_pci_parse_map_dma_ranges(struct rcar_pci_priv *pci,
if (index)
return -EINVAL;
- pci->window_addr = (unsigned long)range.cpu_addr;
- pci->window_pci = (unsigned long)range.pci_addr;
- pci->window_size = (unsigned long)range.size;
+ rcar->window_addr = (unsigned long)range.cpu_addr;
+ rcar->window_pci = (unsigned long)range.pci_addr;
+ rcar->window_size = (unsigned long)range.size;
/* Catch HW limitations */
if (!(range.flags & IORESOURCE_PREFETCH)) {
- dev_err(pci->dev, "window must be prefetchable\n");
+ dev_err(rcar->dev, "window must be prefetchable\n");
return -EINVAL;
}
- if (pci->window_addr) {
- u32 lowaddr = 1 << (ffs(pci->window_addr) - 1);
+ if (rcar->window_addr) {
+ u32 lowaddr = 1 << (ffs(rcar->window_addr) - 1);
- if (lowaddr < pci->window_size) {
- dev_err(pci->dev, "invalid window size/addr\n");
+ if (lowaddr < rcar->window_size) {
+ dev_err(rcar->dev, "invalid window size/addr\n");
return -EINVAL;
}
}
@@ -351,7 +351,7 @@ static int rcar_pci_parse_map_dma_ranges(struct rcar_pci_priv *pci,
static int rcar_pci_probe(struct platform_device *pdev)
{
struct resource *cfg_res, *mem_res;
- struct rcar_pci_priv *priv;
+ struct rcar_pci *rcar;
void __iomem *reg;
struct hw_pci hw;
void *hw_private[1];
@@ -368,27 +368,26 @@ static int rcar_pci_probe(struct platform_device *pdev)
if (mem_res->start & 0xFFFF)
return -EINVAL;
- priv = devm_kzalloc(&pdev->dev,
- sizeof(struct rcar_pci_priv), GFP_KERNEL);
- if (!priv)
+ rcar = devm_kzalloc(&pdev->dev, sizeof(*rcar), GFP_KERNEL);
+ if (!rcar)
return -ENOMEM;
- priv->mem_res = *mem_res;
- priv->cfg_res = cfg_res;
+ rcar->mem_res = *mem_res;
+ rcar->cfg_res = cfg_res;
- priv->irq = platform_get_irq(pdev, 0);
- priv->reg = reg;
- priv->dev = &pdev->dev;
+ rcar->irq = platform_get_irq(pdev, 0);
+ rcar->reg = reg;
+ rcar->dev = &pdev->dev;
- if (priv->irq < 0) {
+ if (rcar->irq < 0) {
dev_err(&pdev->dev, "no valid irq found\n");
- return priv->irq;
+ return rcar->irq;
}
/* default window addr and size if not specified in DT */
- priv->window_addr = 0x40000000;
- priv->window_pci = 0x40000000;
- priv->window_size = SZ_1G;
+ rcar->window_addr = 0x40000000;
+ rcar->window_pci = 0x40000000;
+ rcar->window_size = SZ_1G;
if (pdev->dev.of_node) {
struct resource busnr;
@@ -400,20 +399,20 @@ static int rcar_pci_probe(struct platform_device *pdev)
return ret;
}
- priv->busnr = busnr.start;
+ rcar->busnr = busnr.start;
if (busnr.end != busnr.start)
dev_warn(&pdev->dev, "only one bus number supported\n");
- ret = rcar_pci_parse_map_dma_ranges(priv, pdev->dev.of_node);
+ ret = rcar_pci_parse_map_dma_ranges(rcar, pdev->dev.of_node);
if (ret < 0) {
dev_err(&pdev->dev, "failed to parse dma-range\n");
return ret;
}
} else {
- priv->busnr = pdev->id;
+ rcar->busnr = pdev->id;
}
- hw_private[0] = priv;
+ hw_private[0] = rcar;
memset(&hw, 0, sizeof(hw));
hw.nr_controllers = ARRAY_SIZE(hw_private);
hw.io_optional = 1;
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH 09/10] PCI: rcar-gen2: Add register accessors
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
` (6 preceding siblings ...)
2016-10-07 16:25 ` [PATCH 08/10] PCI: rcar-gen2: Name private struct pointer "rcar" consistently Bjorn Helgaas
@ 2016-10-07 16:25 ` Bjorn Helgaas
2016-10-07 16:26 ` [PATCH 10/10] PCI: rcar-gen2: Add local struct device pointers Bjorn Helgaas
2016-10-08 2:37 ` [PATCH 01/10] PCI: rcar: Rename accessors Simon Horman
9 siblings, 0 replies; 11+ messages in thread
From: Bjorn Helgaas @ 2016-10-07 16:25 UTC (permalink / raw)
To: Simon Horman; +Cc: linux-renesas-soc, linux-pci
Add device-specific register accessors for consistency across host drivers.
No functional change intended.
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
drivers/pci/host/pci-rcar-gen2.c | 61 ++++++++++++++++++++++----------------
1 file changed, 35 insertions(+), 26 deletions(-)
diff --git a/drivers/pci/host/pci-rcar-gen2.c b/drivers/pci/host/pci-rcar-gen2.c
index cba27bc..b210ec0 100644
--- a/drivers/pci/host/pci-rcar-gen2.c
+++ b/drivers/pci/host/pci-rcar-gen2.c
@@ -107,6 +107,16 @@ struct rcar_pci {
unsigned long window_pci;
};
+static u32 rcar_readl(struct rcar_pci *rcar, u32 offset)
+{
+ return ioread32(rcar->reg + offset);
+}
+
+static void rcar_writel(struct rcar_pci *rcar, u32 offset, u32 val)
+{
+ iowrite32(val, rcar->reg + offset);
+}
+
/* PCI configuration space operations */
static void __iomem *rcar_pci_cfg_base(struct pci_bus *bus, unsigned int devfn,
int where)
@@ -130,7 +140,7 @@ static void __iomem *rcar_pci_cfg_base(struct pci_bus *bus, unsigned int devfn,
val = slot ? RCAR_AHBPCI_WIN1_DEVICE | RCAR_AHBPCI_WIN_CTR_CFG :
RCAR_AHBPCI_WIN1_HOST | RCAR_AHBPCI_WIN_CTR_CFG;
- iowrite32(val, rcar->reg + RCAR_AHBPCI_WIN1_CTR_REG);
+ rcar_writel(rcar, RCAR_AHBPCI_WIN1_CTR_REG, val);
return rcar->reg + (slot >> 1) * 0x100 + where;
}
@@ -154,14 +164,14 @@ static int rcar_pci_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
static irqreturn_t rcar_pci_err_irq(int irq, void *pw)
{
struct rcar_pci *rcar = pw;
- u32 status = ioread32(rcar->reg + RCAR_PCI_INT_STATUS_REG);
+ u32 status = rcar_readl(rcar, RCAR_PCI_INT_STATUS_REG);
if (status & RCAR_PCI_INT_ALLERRORS) {
dev_err(rcar->dev, "error irq: status %08x\n", status);
/* clear the error(s) */
- iowrite32(status & RCAR_PCI_INT_ALLERRORS,
- rcar->reg + RCAR_PCI_INT_STATUS_REG);
+ rcar_writel(rcar, RCAR_PCI_INT_STATUS_REG,
+ status & RCAR_PCI_INT_ALLERRORS);
return IRQ_HANDLED;
}
@@ -180,9 +190,9 @@ static void rcar_pci_setup_errirq(struct rcar_pci *rcar)
return;
}
- val = ioread32(rcar->reg + RCAR_PCI_INT_ENABLE_REG);
+ val = rcar_readl(rcar, RCAR_PCI_INT_ENABLE_REG);
val |= RCAR_PCI_INT_ALLERRORS;
- iowrite32(val, rcar->reg + RCAR_PCI_INT_ENABLE_REG);
+ rcar_writel(rcar, RCAR_PCI_INT_ENABLE_REG, val);
}
#else
static inline void rcar_pci_setup_errirq(struct rcar_pci *rcar) { }
@@ -192,20 +202,19 @@ static inline void rcar_pci_setup_errirq(struct rcar_pci *rcar) { }
static int rcar_pci_setup(int nr, struct pci_sys_data *sys)
{
struct rcar_pci *rcar = sys->private_data;
- void __iomem *reg = rcar->reg;
u32 val;
int ret;
pm_runtime_enable(rcar->dev);
pm_runtime_get_sync(rcar->dev);
- val = ioread32(reg + RCAR_PCI_UNIT_REV_REG);
+ val = rcar_readl(rcar, RCAR_PCI_UNIT_REV_REG);
dev_info(rcar->dev, "PCI: bus%u revision %x\n", sys->busnr, val);
/* Disable Direct Power Down State and assert reset */
- val = ioread32(reg + RCAR_USBCTR_REG) & ~RCAR_USBCTR_DIRPD;
+ val = rcar_readl(rcar, RCAR_USBCTR_REG) & ~RCAR_USBCTR_DIRPD;
val |= RCAR_USBCTR_USBH_RST | RCAR_USBCTR_PLL_RST;
- iowrite32(val, reg + RCAR_USBCTR_REG);
+ rcar_writel(rcar, RCAR_USBCTR_REG, val);
udelay(4);
/* De-assert reset and reset PCIAHB window1 size */
@@ -232,43 +241,43 @@ static int rcar_pci_setup(int nr, struct pci_sys_data *sys)
val |= RCAR_USBCTR_PCIAHB_WIN1_256M;
break;
}
- iowrite32(val, reg + RCAR_USBCTR_REG);
+ rcar_writel(rcar, RCAR_USBCTR_REG, val);
/* Configure AHB master and slave modes */
- iowrite32(RCAR_AHB_BUS_MODE, reg + RCAR_AHB_BUS_CTR_REG);
+ rcar_writel(rcar, RCAR_AHB_BUS_CTR_REG, RCAR_AHB_BUS_MODE);
/* Configure PCI arbiter */
- val = ioread32(reg + RCAR_PCI_ARBITER_CTR_REG);
+ val = rcar_readl(rcar, RCAR_PCI_ARBITER_CTR_REG);
val |= RCAR_PCI_ARBITER_PCIREQ0 | RCAR_PCI_ARBITER_PCIREQ1 |
RCAR_PCI_ARBITER_PCIBP_MODE;
- iowrite32(val, reg + RCAR_PCI_ARBITER_CTR_REG);
+ rcar_writel(rcar, RCAR_PCI_ARBITER_CTR_REG, val);
/* PCI-AHB mapping */
- iowrite32(rcar->window_addr | RCAR_PCIAHB_PREFETCH16,
- reg + RCAR_PCIAHB_WIN1_CTR_REG);
+ rcar_writel(rcar, RCAR_PCIAHB_WIN1_CTR_REG,
+ rcar->window_addr | RCAR_PCIAHB_PREFETCH16);
/* AHB-PCI mapping: OHCI/EHCI registers */
val = rcar->mem_res.start | RCAR_AHBPCI_WIN_CTR_MEM;
- iowrite32(val, reg + RCAR_AHBPCI_WIN2_CTR_REG);
+ rcar_writel(rcar, RCAR_AHBPCI_WIN2_CTR_REG, val);
/* Enable AHB-PCI bridge PCI configuration access */
- iowrite32(RCAR_AHBPCI_WIN1_HOST | RCAR_AHBPCI_WIN_CTR_CFG,
- reg + RCAR_AHBPCI_WIN1_CTR_REG);
+ rcar_writel(rcar, RCAR_AHBPCI_WIN1_CTR_REG,
+ RCAR_AHBPCI_WIN1_HOST | RCAR_AHBPCI_WIN_CTR_CFG);
/* Set PCI-AHB Window1 address */
- iowrite32(rcar->window_pci | PCI_BASE_ADDRESS_MEM_PREFETCH,
- reg + PCI_BASE_ADDRESS_1);
+ rcar_writel(rcar, PCI_BASE_ADDRESS_1,
+ rcar->window_pci | PCI_BASE_ADDRESS_MEM_PREFETCH);
/* Set AHB-PCI bridge PCI communication area address */
val = rcar->cfg_res->start + RCAR_AHBPCI_PCICOM_OFFSET;
- iowrite32(val, reg + PCI_BASE_ADDRESS_0);
+ rcar_writel(rcar, PCI_BASE_ADDRESS_0, val);
- val = ioread32(reg + PCI_COMMAND);
+ val = rcar_readl(rcar, PCI_COMMAND);
val |= PCI_COMMAND_SERR | PCI_COMMAND_PARITY |
PCI_COMMAND_MEMORY | PCI_COMMAND_MASTER;
- iowrite32(val, reg + PCI_COMMAND);
+ rcar_writel(rcar, PCI_COMMAND, val);
/* Enable PCI interrupts */
- iowrite32(RCAR_PCI_INT_A | RCAR_PCI_INT_B | RCAR_PCI_INT_PME,
- reg + RCAR_PCI_INT_ENABLE_REG);
+ rcar_writel(rcar, RCAR_PCI_INT_ENABLE_REG,
+ RCAR_PCI_INT_A | RCAR_PCI_INT_B | RCAR_PCI_INT_PME);
if (rcar->irq > 0)
rcar_pci_setup_errirq(rcar);
^ permalink raw reply related [flat|nested] 11+ messages in thread
* [PATCH 10/10] PCI: rcar-gen2: Add local struct device pointers
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
` (7 preceding siblings ...)
2016-10-07 16:25 ` [PATCH 09/10] PCI: rcar-gen2: Add register accessors Bjorn Helgaas
@ 2016-10-07 16:26 ` Bjorn Helgaas
2016-10-08 2:37 ` [PATCH 01/10] PCI: rcar: Rename accessors Simon Horman
9 siblings, 0 replies; 11+ messages in thread
From: Bjorn Helgaas @ 2016-10-07 16:26 UTC (permalink / raw)
To: Simon Horman; +Cc: linux-renesas-soc, linux-pci
Use a local "struct device *dev" for brevity and consistency with other
drivers. No functional change intended.
Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
---
drivers/pci/host/pci-rcar-gen2.c | 47 +++++++++++++++++++++-----------------
1 file changed, 26 insertions(+), 21 deletions(-)
diff --git a/drivers/pci/host/pci-rcar-gen2.c b/drivers/pci/host/pci-rcar-gen2.c
index b210ec0..97f15b0 100644
--- a/drivers/pci/host/pci-rcar-gen2.c
+++ b/drivers/pci/host/pci-rcar-gen2.c
@@ -164,10 +164,11 @@ static int rcar_pci_map_irq(const struct pci_dev *dev, u8 slot, u8 pin)
static irqreturn_t rcar_pci_err_irq(int irq, void *pw)
{
struct rcar_pci *rcar = pw;
+ struct device *dev = rcar->dev;
u32 status = rcar_readl(rcar, RCAR_PCI_INT_STATUS_REG);
if (status & RCAR_PCI_INT_ALLERRORS) {
- dev_err(rcar->dev, "error irq: status %08x\n", status);
+ dev_err(dev, "error irq: status %08x\n", status);
/* clear the error(s) */
rcar_writel(rcar, RCAR_PCI_INT_STATUS_REG,
@@ -180,13 +181,14 @@ static irqreturn_t rcar_pci_err_irq(int irq, void *pw)
static void rcar_pci_setup_errirq(struct rcar_pci *rcar)
{
+ struct device *dev = rcar->dev;
int ret;
u32 val;
- ret = devm_request_irq(rcar->dev, rcar->irq, rcar_pci_err_irq,
+ ret = devm_request_irq(dev, rcar->irq, rcar_pci_err_irq,
IRQF_SHARED, "error irq", rcar);
if (ret) {
- dev_err(rcar->dev, "cannot claim IRQ for error handling\n");
+ dev_err(dev, "cannot claim IRQ for error handling\n");
return;
}
@@ -202,14 +204,15 @@ static inline void rcar_pci_setup_errirq(struct rcar_pci *rcar) { }
static int rcar_pci_setup(int nr, struct pci_sys_data *sys)
{
struct rcar_pci *rcar = sys->private_data;
+ struct device *dev = rcar->dev;
u32 val;
int ret;
- pm_runtime_enable(rcar->dev);
- pm_runtime_get_sync(rcar->dev);
+ pm_runtime_enable(dev);
+ pm_runtime_get_sync(dev);
val = rcar_readl(rcar, RCAR_PCI_UNIT_REV_REG);
- dev_info(rcar->dev, "PCI: bus%u revision %x\n", sys->busnr, val);
+ dev_info(dev, "PCI: bus%u revision %x\n", sys->busnr, val);
/* Disable Direct Power Down State and assert reset */
val = rcar_readl(rcar, RCAR_USBCTR_REG) & ~RCAR_USBCTR_DIRPD;
@@ -284,7 +287,7 @@ static int rcar_pci_setup(int nr, struct pci_sys_data *sys)
/* Add PCI resources */
pci_add_resource(&sys->resources, &rcar->mem_res);
- ret = devm_request_pci_bus_resources(rcar->dev, &sys->resources);
+ ret = devm_request_pci_bus_resources(dev, &sys->resources);
if (ret < 0)
return ret;
@@ -320,6 +323,7 @@ static int pci_dma_range_parser_init(struct of_pci_range_parser *parser,
static int rcar_pci_parse_map_dma_ranges(struct rcar_pci *rcar,
struct device_node *np)
{
+ struct device *dev = rcar->dev;
struct of_pci_range range;
struct of_pci_range_parser parser;
int index = 0;
@@ -340,14 +344,14 @@ static int rcar_pci_parse_map_dma_ranges(struct rcar_pci *rcar,
/* Catch HW limitations */
if (!(range.flags & IORESOURCE_PREFETCH)) {
- dev_err(rcar->dev, "window must be prefetchable\n");
+ dev_err(dev, "window must be prefetchable\n");
return -EINVAL;
}
if (rcar->window_addr) {
u32 lowaddr = 1 << (ffs(rcar->window_addr) - 1);
if (lowaddr < rcar->window_size) {
- dev_err(rcar->dev, "invalid window size/addr\n");
+ dev_err(dev, "invalid window size/addr\n");
return -EINVAL;
}
}
@@ -359,14 +363,15 @@ static int rcar_pci_parse_map_dma_ranges(struct rcar_pci *rcar,
static int rcar_pci_probe(struct platform_device *pdev)
{
- struct resource *cfg_res, *mem_res;
+ struct device *dev = &pdev->dev;
struct rcar_pci *rcar;
+ struct resource *cfg_res, *mem_res;
void __iomem *reg;
struct hw_pci hw;
void *hw_private[1];
cfg_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- reg = devm_ioremap_resource(&pdev->dev, cfg_res);
+ reg = devm_ioremap_resource(dev, cfg_res);
if (IS_ERR(reg))
return PTR_ERR(reg);
@@ -377,7 +382,7 @@ static int rcar_pci_probe(struct platform_device *pdev)
if (mem_res->start & 0xFFFF)
return -EINVAL;
- rcar = devm_kzalloc(&pdev->dev, sizeof(*rcar), GFP_KERNEL);
+ rcar = devm_kzalloc(dev, sizeof(*rcar), GFP_KERNEL);
if (!rcar)
return -ENOMEM;
@@ -386,10 +391,10 @@ static int rcar_pci_probe(struct platform_device *pdev)
rcar->irq = platform_get_irq(pdev, 0);
rcar->reg = reg;
- rcar->dev = &pdev->dev;
+ rcar->dev = dev;
if (rcar->irq < 0) {
- dev_err(&pdev->dev, "no valid irq found\n");
+ dev_err(dev, "no valid irq found\n");
return rcar->irq;
}
@@ -398,23 +403,23 @@ static int rcar_pci_probe(struct platform_device *pdev)
rcar->window_pci = 0x40000000;
rcar->window_size = SZ_1G;
- if (pdev->dev.of_node) {
+ if (dev->of_node) {
struct resource busnr;
int ret;
- ret = of_pci_parse_bus_range(pdev->dev.of_node, &busnr);
+ ret = of_pci_parse_bus_range(dev->of_node, &busnr);
if (ret < 0) {
- dev_err(&pdev->dev, "failed to parse bus-range\n");
+ dev_err(dev, "failed to parse bus-range\n");
return ret;
}
rcar->busnr = busnr.start;
if (busnr.end != busnr.start)
- dev_warn(&pdev->dev, "only one bus number supported\n");
+ dev_warn(dev, "only one bus number supported\n");
- ret = rcar_pci_parse_map_dma_ranges(rcar, pdev->dev.of_node);
+ ret = rcar_pci_parse_map_dma_ranges(rcar, dev->of_node);
if (ret < 0) {
- dev_err(&pdev->dev, "failed to parse dma-range\n");
+ dev_err(dev, "failed to parse dma-range\n");
return ret;
}
} else {
@@ -429,7 +434,7 @@ static int rcar_pci_probe(struct platform_device *pdev)
hw.map_irq = rcar_pci_map_irq;
hw.ops = &rcar_pci_ops;
hw.setup = rcar_pci_setup;
- pci_common_init_dev(&pdev->dev, &hw);
+ pci_common_init_dev(dev, &hw);
return 0;
}
^ permalink raw reply related [flat|nested] 11+ messages in thread
* Re: [PATCH 01/10] PCI: rcar: Rename accessors
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
` (8 preceding siblings ...)
2016-10-07 16:26 ` [PATCH 10/10] PCI: rcar-gen2: Add local struct device pointers Bjorn Helgaas
@ 2016-10-08 2:37 ` Simon Horman
9 siblings, 0 replies; 11+ messages in thread
From: Simon Horman @ 2016-10-08 2:37 UTC (permalink / raw)
To: Bjorn Helgaas; +Cc: linux-renesas-soc, linux-pci
On Fri, Oct 07, 2016 at 11:24:46AM -0500, Bjorn Helgaas wrote:
> Rename rcar_pci_read_reg() to rcar_readl() and rcar_pci_write_reg() to
> rcar_writel() for consistency with other drivers. No functional change
> intended.
>
> Signed-off-by: Bjorn Helgaas <bhelgaas@google.com>
I am fine with this entire series.
Acked-by: Simon Horman <horms+renesas@verge.net.au>
> ---
> drivers/pci/host/pcie-rcar.c | 142 ++++++++++++++++++++----------------------
> 1 file changed, 68 insertions(+), 74 deletions(-)
>
> diff --git a/drivers/pci/host/pcie-rcar.c b/drivers/pci/host/pcie-rcar.c
> index e06b1d3..b6899c8 100644
> --- a/drivers/pci/host/pcie-rcar.c
> +++ b/drivers/pci/host/pcie-rcar.c
> @@ -152,16 +152,15 @@ struct rcar_pcie {
> struct rcar_msi msi;
> };
>
> -static void rcar_pci_write_reg(struct rcar_pcie *pcie, unsigned long val,
> - unsigned long reg)
> +static unsigned long rcar_readl(struct rcar_pcie *pcie, unsigned long reg)
> {
> - writel(val, pcie->base + reg);
> + return readl(pcie->base + reg);
> }
>
> -static unsigned long rcar_pci_read_reg(struct rcar_pcie *pcie,
> - unsigned long reg)
> +static void rcar_writel(struct rcar_pcie *pcie, unsigned long val,
> + unsigned long reg)
> {
> - return readl(pcie->base + reg);
> + writel(val, pcie->base + reg);
> }
The diff might have been a bit easier on the eyes if rcar_pci_write_reg()
was after rcar_pci_read_reg()
^ permalink raw reply [flat|nested] 11+ messages in thread
end of thread, other threads:[~2016-10-08 20:46 UTC | newest]
Thread overview: 11+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2016-10-07 16:24 [PATCH 01/10] PCI: rcar: Rename accessors Bjorn Helgaas
2016-10-07 16:24 ` [PATCH 02/10] PCI: rcar: Name private struct pointer "rcar" consistently Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 03/10] PCI: rcar: Swap order of rcar_writel() reg/val arguments Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 04/10] PCI: rcar: Add local struct device pointers Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 05/10] PCI: rcar: Remove unused rcar_pcie_get_resources() platform_device arg Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 06/10] PCI: rcar: Remove unused platform data Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 07/10] PCI: rcar: Remove DRV_NAME macro Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 08/10] PCI: rcar-gen2: Name private struct pointer "rcar" consistently Bjorn Helgaas
2016-10-07 16:25 ` [PATCH 09/10] PCI: rcar-gen2: Add register accessors Bjorn Helgaas
2016-10-07 16:26 ` [PATCH 10/10] PCI: rcar-gen2: Add local struct device pointers Bjorn Helgaas
2016-10-08 2:37 ` [PATCH 01/10] PCI: rcar: Rename accessors Simon Horman
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.