mtd: spi: Correct parameters for s25fs512s flash

[u-boot] / drivers / pci / pci_tegra.c

diff --git a/drivers/pci/pci_tegra.c b/drivers/pci/pci_tegra.c
index cb5cf8b043bd91198766e2269185eb59dcf1a8be..56c08585e6da54ae841af86b743f1e127cb80bd0 100644 (file)
--- a/drivers/pci/pci_tegra.c
+++ b/drivers/pci/pci_tegra.c
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0
 /*
  * Copyright (c) 2010, CompuLab, Ltd.
  * Author: Mike Rapoport <mike@compulab.co.il>
@@ -6,8 +7,6 @@
  * Copyright (c) 2008-2009, NVIDIA Corporation.
  *
  * Copyright (c) 2013-2014, NVIDIA Corporation.
- *
- * SPDX-License-Identifier:    GPL-2.0
  */
 
 #define pr_fmt(fmt) "tegra-pcie: " fmt
@@ -18,6 +17,7 @@
 #include <errno.h>
 #include <malloc.h>
 #include <pci.h>
+#include <pci_tegra.h>
 #include <power-domain.h>
 #include <reset.h>
 
@@ -43,8 +43,6 @@
  * use the new standard APIs, with no ifdefs.
  */
 
-DECLARE_GLOBAL_DATA_PTR;
-
 #define AFI_AXI_BAR0_SZ        0x00
 #define AFI_AXI_BAR1_SZ        0x04
 #define AFI_AXI_BAR2_SZ        0x08
@@ -218,8 +216,6 @@ struct tegra_pcie_soc {
 };
 
 struct tegra_pcie {
-       struct pci_controller hose;
-
        struct resource pads;
        struct resource afi;
        struct resource cs;
@@ -371,7 +367,7 @@ static int tegra_pcie_port_parse_dt(ofnode node, struct tegra_pcie_port *port)
 
        addr = ofnode_get_property(node, "assigned-addresses", &len);
        if (!addr) {
-               error("property \"assigned-addresses\" not found");
+               pr_err("property \"assigned-addresses\" not found");
                return -FDT_ERR_NOTFOUND;
        }
 
@@ -462,7 +458,7 @@ static int tegra_pcie_parse_port_info(ofnode node, uint *index, uint *lanes)
 
        err = ofnode_read_u32_default(node, "nvidia,num-lanes", -1);
        if (err < 0) {
-               error("failed to parse \"nvidia,num-lanes\" property");
+               pr_err("failed to parse \"nvidia,num-lanes\" property");
                return err;
        }
 
@@ -470,7 +466,7 @@ static int tegra_pcie_parse_port_info(ofnode node, uint *index, uint *lanes)
 
        err = ofnode_read_pci_addr(node, 0, "reg", &addr);
        if (err < 0) {
-               error("failed to parse \"reg\" property");
+               pr_err("failed to parse \"reg\" property");
                return err;
        }
 
@@ -493,25 +489,25 @@ static int tegra_pcie_parse_dt(struct udevice *dev, enum tegra_pci_id id,
 
        err = dev_read_resource(dev, 0, &pcie->pads);
        if (err < 0) {
-               error("resource \"pads\" not found");
+               pr_err("resource \"pads\" not found");
                return err;
        }
 
        err = dev_read_resource(dev, 1, &pcie->afi);
        if (err < 0) {
-               error("resource \"afi\" not found");
+               pr_err("resource \"afi\" not found");
                return err;
        }
 
        err = dev_read_resource(dev, 2, &pcie->cs);
        if (err < 0) {
-               error("resource \"cs\" not found");
+               pr_err("resource \"cs\" not found");
                return err;
        }
 
        err = tegra_pcie_board_init();
        if (err < 0) {
-               error("tegra_pcie_board_init() failed: err=%d", err);
+               pr_err("tegra_pcie_board_init() failed: err=%d", err);
                return err;
        }
 
@@ -520,7 +516,7 @@ static int tegra_pcie_parse_dt(struct udevice *dev, enum tegra_pci_id id,
        if (pcie->phy) {
                err = tegra_xusb_phy_prepare(pcie->phy);
                if (err < 0) {
-                       error("failed to prepare PHY: %d", err);
+                       pr_err("failed to prepare PHY: %d", err);
                        return err;
                }
        }
@@ -532,7 +528,7 @@ static int tegra_pcie_parse_dt(struct udevice *dev, enum tegra_pci_id id,
 
                err = tegra_pcie_parse_port_info(subnode, &index, &num_lanes);
                if (err < 0) {
-                       error("failed to obtain root port info");
+                       pr_err("failed to obtain root port info");
                        continue;
                }
 
@@ -562,7 +558,7 @@ static int tegra_pcie_parse_dt(struct udevice *dev, enum tegra_pci_id id,
        err = tegra_pcie_get_xbar_config(dev_ofnode(dev), lanes, id,
                                         &pcie->xbar);
        if (err < 0) {
-               error("invalid lane configuration");
+               pr_err("invalid lane configuration");
                return err;
        }
 
@@ -576,31 +572,31 @@ static int tegra_pcie_power_on(struct tegra_pcie *pcie)
 
        ret = power_domain_on(&pcie->pwrdom);
        if (ret) {
-               error("power_domain_on() failed: %d\n", ret);
+               pr_err("power_domain_on() failed: %d\n", ret);
                return ret;
        }
 
        ret = clk_enable(&pcie->clk_afi);
        if (ret) {
-               error("clk_enable(afi) failed: %d\n", ret);
+               pr_err("clk_enable(afi) failed: %d\n", ret);
                return ret;
        }
 
        ret = clk_enable(&pcie->clk_pex);
        if (ret) {
-               error("clk_enable(pex) failed: %d\n", ret);
+               pr_err("clk_enable(pex) failed: %d\n", ret);
                return ret;
        }
 
        ret = reset_deassert(&pcie->reset_afi);
        if (ret) {
-               error("reset_deassert(afi) failed: %d\n", ret);
+               pr_err("reset_deassert(afi) failed: %d\n", ret);
                return ret;
        }
 
        ret = reset_deassert(&pcie->reset_pex);
        if (ret) {
-               error("reset_deassert(pex) failed: %d\n", ret);
+               pr_err("reset_deassert(pex) failed: %d\n", ret);
                return ret;
        }
 
@@ -620,14 +616,14 @@ static int tegra_pcie_power_on(struct tegra_pcie *pcie)
 
        err = tegra_powergate_power_off(TEGRA_POWERGATE_PCIE);
        if (err < 0) {
-               error("failed to power off PCIe partition: %d", err);
+               pr_err("failed to power off PCIe partition: %d", err);
                return err;
        }
 
        err = tegra_powergate_sequence_power_up(TEGRA_POWERGATE_PCIE,
                                                PERIPH_ID_PCIE);
        if (err < 0) {
-               error("failed to power up PCIe partition: %d", err);
+               pr_err("failed to power up PCIe partition: %d", err);
                return err;
        }
 
@@ -647,7 +643,7 @@ static int tegra_pcie_power_on(struct tegra_pcie *pcie)
 
        err = tegra_plle_enable();
        if (err < 0) {
-               error("failed to enable PLLE: %d\n", err);
+               pr_err("failed to enable PLLE: %d\n", err);
                return err;
        }
 
@@ -707,7 +703,7 @@ static int tegra_pcie_phy_enable(struct tegra_pcie *pcie)
        /* wait for the PLL to lock */
        err = tegra_pcie_pll_wait(pcie, 500);
        if (err < 0) {
-               error("PLL failed to lock: %d", err);
+               pr_err("PLL failed to lock: %d", err);
                return err;
        }
 
@@ -771,7 +767,7 @@ static int tegra_pcie_enable_controller(struct tegra_pcie *pcie)
                err = tegra_pcie_phy_enable(pcie);
 
        if (err < 0) {
-               error("failed to power on PHY: %d\n", err);
+               pr_err("failed to power on PHY: %d\n", err);
                return err;
        }
 #endif
@@ -780,7 +776,7 @@ static int tegra_pcie_enable_controller(struct tegra_pcie *pcie)
 #ifdef CONFIG_TEGRA186
        err = reset_deassert(&pcie->reset_pcie_x);
        if (err) {
-               error("reset_deassert(pcie_x) failed: %d\n", err);
+               pr_err("reset_deassert(pcie_x) failed: %d\n", err);
                return err;
        }
 #else
@@ -893,7 +889,7 @@ static unsigned long tegra_pcie_port_get_pex_ctrl(struct tegra_pcie_port *port)
        return ret;
 }
 
-static void tegra_pcie_port_reset(struct tegra_pcie_port *port)
+void tegra_pcie_port_reset(struct tegra_pcie_port *port)
 {
        unsigned long ctrl = tegra_pcie_port_get_pex_ctrl(port);
        unsigned long value;
@@ -910,6 +906,16 @@ static void tegra_pcie_port_reset(struct tegra_pcie_port *port)
        afi_writel(port->pcie, value, ctrl);
 }
 
+int tegra_pcie_port_index_of_port(struct tegra_pcie_port *port)
+{
+       return port->index;
+}
+
+void __weak tegra_pcie_board_port_reset(struct tegra_pcie_port *port)
+{
+       tegra_pcie_port_reset(port);
+}
+
 static void tegra_pcie_port_enable(struct tegra_pcie_port *port)
 {
        struct tegra_pcie *pcie = port->pcie;
@@ -928,7 +934,7 @@ static void tegra_pcie_port_enable(struct tegra_pcie_port *port)
 
        afi_writel(pcie, value, ctrl);
 
-       tegra_pcie_port_reset(port);
+       tegra_pcie_board_port_reset(port);
 
        if (soc->force_pca_enable) {
                value = rp_readl(port, RP_VEND_CTL2);
@@ -979,7 +985,7 @@ static bool tegra_pcie_port_check_link(struct tegra_pcie_port *port)
                } while (--timeout);
 
 retry:
-               tegra_pcie_port_reset(port);
+               tegra_pcie_board_port_reset(port);
        } while (--retries);
 
        return false;
@@ -1145,25 +1151,25 @@ static int pci_tegra_probe(struct udevice *dev)
 
        err = tegra_pcie_power_on(pcie);
        if (err < 0) {
-               error("failed to power on");
+               pr_err("failed to power on");
                return err;
        }
 
        err = tegra_pcie_enable_controller(pcie);
        if (err < 0) {
-               error("failed to enable controller");
+               pr_err("failed to enable controller");
                return err;
        }
 
        err = tegra_pcie_setup_translations(dev);
        if (err < 0) {
-               error("failed to decode ranges");
+               pr_err("failed to decode ranges");
                return err;
        }
 
        err = tegra_pcie_enable(pcie);
        if (err < 0) {
-               error("failed to enable PCIe");
+               pr_err("failed to enable PCIe");
                return err;
        }