OpenIPC
/
firmware
mirror of https://github.com/OpenIPC/firmware.git
1
0
Fork 0
Code Activity
firmware/br-ext-chip-allwinner/board/v83x/kernel/patches/00000-drivers_pci_host_pcie...

1135 lines
30 KiB
Diff
Raw Blame History

diff -drupN a/drivers/pci/host/pcie-sunxi-plat.c b/drivers/pci/host/pcie-sunxi-plat.c
--- a/drivers/pci/host/pcie-sunxi-plat.c 1970-01-01 03:00:00.000000000 +0300
+++ b/drivers/pci/host/pcie-sunxi-plat.c 2022-06-12 05:28:14.000000000 +0300
@@ -0,0 +1,1130 @@
+/*
+ * PCIe RC driver for Allwinner Core
+ *
+ * Copyright (C) 2016 Allwinner Co., Ltd.
+ *
+ * Author: wangjx <wangjx@allwinnertech.com>
+ * ysn <yangshounan@allwinnertech.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/of_gpio.h>
+#include <linux/pci.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
+#include <linux/resource.h>
+#include <linux/signal.h>
+#include <linux/types.h>
+#include <linux/sunxi-gpio.h>
+
+#include "pcie-designware.h"
+
+#define PCIE_LINK_WIDTH_SPEED_CONTROL 0x80C
+#define PORT_LOGIC_SPEED_CHANGE (0x1 << 17)
+#define PORT_LOGIC_LINK_WIDTH_MASK (0x1ff << 8)
+
+#define USER_DEFINED_REGISTER_LIST 0x1000
+#define PCIE_LTSSM_ENABLE 0x00
+#define PCIE_INT_PENDING 0x18
+#define PCIE_AWMISC_INF0_CTRL 0x30
+#define PCIE_ARMISC_INF0_CTRL 0X34
+#define PCIE_LINK_STATUS 0X43C
+#define PCIE_PHY_CFG 0x800
+#define SYS_CLK 0
+#define PAD_CLK 1
+#define RDLH_LINK_UP (1<<1)
+#define SMLH_LINK_UP (1<<0)
+#define PCIE_LINK_TRAINING (1<<0)
+#define PCIE_LINK_UP_MASK (0x3<<16)
+#define LINK_WAIT_MAX_RETRIES 10
+#define LINK_WAIT_USLEEP_MIN 90000
+#define LINK_WAIT_USLEEP_MAX 100000
+
+#define PCIE_LINK_WIDTH_SPEED_CONTROL 0x80C
+#define PORT_LOGIC_SPEED_CHANGE (0x1 << 17)
+#define LINK_CONTROL2_LINK_STATUS2 0xa0
+#define PCIE_MSI_ADDR_LO 0x820
+#define PCIE_MSI_ADDR_HI 0x824
+#define PCIE_MSI_INTR0_ENABLE 0x828
+#define PCIE_MSI_INTR0_MASK 0x82C
+#define PCIE_MSI_INTR0_STATUS 0x830
+
+#define PCIE_ATU_VIEWPORT 0x900
+#define PCIE_ATU_REGION_INBOUND (0x1 << 31)
+#define PCIE_ATU_REGION_OUTBOUND (0x0 << 31)
+#define PCIE_ATU_REGION_INDEX2 (0x2 << 0)
+#define PCIE_ATU_REGION_INDEX1 (0x1 << 0)
+#define PCIE_ATU_REGION_INDEX0 (0x0 << 0)
+#define PCIE_ATU_CR1 0x904
+#define PCIE_ATU_TYPE_MEM (0x0 << 0)
+#define PCIE_ATU_TYPE_IO (0x2 << 0)
+#define PCIE_ATU_TYPE_CFG0 (0x4 << 0)
+#define PCIE_ATU_TYPE_CFG1 (0x5 << 0)
+#define PCIE_ATU_CR2 0x908
+#define PCIE_ATU_ENABLE (0x1 << 31)
+#define PCIE_ATU_BAR_MODE_ENABLE (0x1 << 30)
+#define PCIE_ATU_LOWER_BASE 0x90C
+#define PCIE_ATU_UPPER_BASE 0x910
+#define PCIE_ATU_LIMIT 0x914
+#define PCIE_ATU_LOWER_TARGET 0x918
+#define PCIE_ATU_BUS(x) (((x) & 0xff) << 24)
+#define PCIE_ATU_DEV(x) (((x) & 0x1f) << 19)
+#define PCIE_ATU_FUNC(x) (((x) & 0x7) << 16)
+#define PCIE_ATU_UPPER_TARGET 0x91C
+
+#define PCIE_MISC_CONTROL_1_CFG 0x8bc
+#define PCIE_ADDR_PAGE_CFG 0x1020
+#define PCIE_AWMISC_CTRL 0x1030
+#define PCIE_ARMISC_CTRL 0x1034
+#define PCIE_PAGE 0x10000
+#define PCIE_ADDRESS_ALIGNING (~0x3)
+#define PCIE_HIGH_16 16
+#define PCIE_BAR_NUM 6
+#define PCIE_IO_FLAGS 0x1
+#define PCIE_BAR_REG 0x4
+#define PCIE_HIGH16_MASK 0xffff0000
+#define PCIE_LOW16_MASK 0x0000ffff
+#define PCIE_INTERRUPT_LINE_MASK 0xffff00ff
+#define PCIE_INTERRUPT_LINE_ENABLE 0x00000100
+#define PCIE_PRIMARY_BUS_MASK 0xff000000
+#define PCIE_PRIMARY_BUS_ENABLE 0x00010100
+#define PCIE_MEMORY_MASK 0xfff00000
+
+void __iomem *dbi_base;
+static void __iomem *mem_base_start;
+
+enum gpio_type {
+ PCIE_REST = 0,
+ PCIE_POWER,
+ PCIE_REG,
+ MAX_GPIO_NUM,
+};
+
+enum power_type {
+ PCIE_VDD = 0,
+ PCIE_VCC,
+ PCIE_VCC_SLOT,
+ MAX_POWER_NUM,
+};
+
+struct power {
+ struct regulator *pmic;
+ int power_vol;
+ char power_str[32];
+};
+
+struct sunxi_pcie {
+ struct device dev;
+ void __iomem *dbi_base;
+ void __iomem *app_base;
+ int link_irq;
+ int msi_irq;
+ int speed_gen;
+ struct pcie_port pp;
+ struct clk *pcie_ref;
+ struct clk *pcie_axi;
+ struct clk *pcie_aux;
+ struct clk *pcie_bus;
+ struct clk *pcie_power;
+ struct clk *pcie_rst;
+ int iodvdd;
+#ifdef CONFIG_PM
+ u32 msi_enable;
+ u32 buffer[16];
+#endif
+ struct gpio_config gpio[MAX_GPIO_NUM];
+ struct power power[MAX_POWER_NUM];
+};
+#define to_sunxi_pcie(x) container_of((x), struct sunxi_pcie, pp)
+
+static inline u32 sunxi_pcie_readl(struct sunxi_pcie *pcie, u32 offset)
+{
+ return readl(pcie->app_base + offset);
+}
+
+static inline void sunxi_pcie_writel(u32 val, struct sunxi_pcie *pcie, u32 offset)
+{
+ writel(val, pcie->app_base + offset);
+}
+
+static inline void sunxi_pcie_writel_rcl(struct pcie_port *pp, u32 val, u32 reg)
+{
+ writel(val, pp->dbi_base + reg);
+}
+
+static inline u32 sunxi_pcie_readl_rcl(struct pcie_port *pp, u32 reg)
+{
+ return readl(pp->dbi_base + reg);
+}
+
+static int sunxi_pcie_cfg_read(void __iomem *addr, int size, u32 *val)
+{
+ if ((uintptr_t)addr & (size - 1)) {
+ *val = 0;
+ return PCIBIOS_BAD_REGISTER_NUMBER;
+ }
+
+ if (size == 4)
+ *val = readl(addr);
+ else if (size == 2)
+ *val = readw(addr);
+ else if (size == 1)
+ *val = readb(addr);
+ else {
+ *val = 0;
+ return PCIBIOS_BAD_REGISTER_NUMBER;
+ }
+
+ return PCIBIOS_SUCCESSFUL;
+}
+
+static int sunxi_pcie_cfg_write(void __iomem *addr, int size, u32 val)
+{
+ if ((uintptr_t)addr & (size - 1))
+ return PCIBIOS_BAD_REGISTER_NUMBER;
+
+ if (size == 4)
+ writel(val, addr);
+ else if (size == 2)
+ writew(val, addr);
+ else if (size == 1)
+ writeb(val, addr);
+ else
+ return PCIBIOS_BAD_REGISTER_NUMBER;
+
+ return PCIBIOS_SUCCESSFUL;
+}
+
+
+static void sunxi_pcie_clk_clect(struct pcie_port *pp, char on)
+{
+ struct sunxi_pcie *pcie = to_sunxi_pcie(pp);
+ u32 val;
+
+ val = sunxi_pcie_readl(pcie, PCIE_PHY_CFG);
+ if (on)
+ val |= 0x1<<31;
+ else
+ val &= ~(0x1<<31);
+ sunxi_pcie_writel(val, pcie, PCIE_PHY_CFG);
+}
+
+static void sunxi_pcie_ltssm_enable(struct pcie_port *pp)
+{
+ struct sunxi_pcie *pcie = to_sunxi_pcie(pp);
+ u32 val;
+
+ val = sunxi_pcie_readl(pcie, PCIE_LTSSM_ENABLE);
+ val |= PCIE_LINK_TRAINING;
+ sunxi_pcie_writel(val, pcie, PCIE_LTSSM_ENABLE);
+}
+
+static void sunxi_pcie_irqpending(struct pcie_port *pp)
+{
+ struct sunxi_pcie *pcie = to_sunxi_pcie(pp);
+ u32 val;
+
+ val = sunxi_pcie_readl(pcie, PCIE_INT_PENDING);
+ val &= ~(0x3<<16);
+ sunxi_pcie_writel(val, pcie, PCIE_INT_PENDING);
+}
+
+static void sunxi_pcie_phy_cfg(struct sunxi_pcie *pcie, int enable)
+{
+ u32 val;
+
+ val = sunxi_pcie_readl(pcie, PCIE_PHY_CFG);
+ if (enable)
+ val |= 0x1<<0;
+ else
+ val &= ~(0x1<<0);
+ sunxi_pcie_writel(val, pcie, PCIE_PHY_CFG);
+}
+
+static void sunxi_pcie_irqmask(struct pcie_port *pp)
+{
+ struct sunxi_pcie *pcie = to_sunxi_pcie(pp);
+ u32 val;
+
+ val = sunxi_pcie_readl(pcie, PCIE_INT_PENDING);
+ val |= 0x3<<16;
+ sunxi_pcie_writel(val, pcie, PCIE_INT_PENDING);
+}
+
+static void sunxi_pcie_ltssm_disable(struct pcie_port *pp)
+{
+ struct sunxi_pcie *pcie = to_sunxi_pcie(pp);
+ u32 val;
+
+ val = sunxi_pcie_readl(pcie, PCIE_LTSSM_ENABLE);
+ val &= ~PCIE_LINK_TRAINING;
+ sunxi_pcie_writel(val, pcie, PCIE_LTSSM_ENABLE);
+}
+
+static int sunxi_pcie_wait_for_speed_change(struct pcie_port *pp)
+{
+ u32 tmp;
+ unsigned int retries;
+
+ for (retries = 0; retries < 200; retries++) {
+ tmp = sunxi_pcie_readl_rcl(pp, PCIE_LINK_WIDTH_SPEED_CONTROL);
+ /* Test if the speed change finished. */
+ if (!(tmp & PORT_LOGIC_SPEED_CHANGE))
+ return 0;
+ usleep_range(100, 1000);
+ }
+
+ dev_err(pp->dev, "Speed change timeout\n");
+ return -EINVAL;
+}
+
+int sunxi_pcie_wait_for_link(struct pcie_port *pp)
+{
+ int retries;
+ /* check if the link is up or not */
+ for (retries = 0; retries < LINK_WAIT_MAX_RETRIES; retries++) {
+ if (dw_pcie_link_up(pp)) {
+ dev_info(pp->dev, "link up\n");
+ return 0;
+ }
+ usleep_range(LINK_WAIT_USLEEP_MIN, LINK_WAIT_USLEEP_MAX);
+ }
+
+ dev_err(pp->dev, "phy link never came up\n");
+
+ return -ETIMEDOUT;
+}
+
+static int sunxi_pcie_establish_link(struct pcie_port *pp)
+{
+ if (dw_pcie_link_up(pp)) {
+ dev_err(pp->dev, "link is already up\n");
+ return 0;
+ }
+ sunxi_pcie_ltssm_enable(pp);
+ sunxi_pcie_wait_for_link(pp);
+
+ return 1;
+}
+
+static int sunxi_pcie_link_up_status(struct pcie_port *pp)
+{
+ u32 rc;
+ int ret;
+ struct sunxi_pcie *pcie = to_sunxi_pcie(pp);
+
+ rc = sunxi_pcie_readl(pcie, PCIE_LINK_STATUS);
+ if ((rc&RDLH_LINK_UP) && (rc&SMLH_LINK_UP))
+ ret = 1;
+ else
+ ret = 0;
+
+ return ret;
+}
+
+static int sunxi_pcie_speed_chang(struct pcie_port *pp, int gen)
+{
+ int val;
+ int ret;
+
+ val = sunxi_pcie_readl_rcl(pp, LINK_CONTROL2_LINK_STATUS2);
+ val &= ~0xf;
+ val |= gen;
+ sunxi_pcie_writel_rcl(pp, val, LINK_CONTROL2_LINK_STATUS2);
+
+ val = sunxi_pcie_readl_rcl(pp, PCIE_LINK_WIDTH_SPEED_CONTROL);
+ val &= ~PORT_LOGIC_SPEED_CHANGE;
+ sunxi_pcie_writel_rcl(pp, val, PCIE_LINK_WIDTH_SPEED_CONTROL);
+
+ val = sunxi_pcie_readl_rcl(pp, PCIE_LINK_WIDTH_SPEED_CONTROL);
+ val |= PORT_LOGIC_SPEED_CHANGE;
+ sunxi_pcie_writel_rcl(pp, val, PCIE_LINK_WIDTH_SPEED_CONTROL);
+
+ ret = sunxi_pcie_wait_for_speed_change(pp);
+ if (!ret)
+ dev_info(pp->dev, "PCI-e speed of Gen%d\n", gen);
+ else
+ dev_info(pp->dev, "PCI-e speed of Gen1\n");
+
+ return 0;
+}
+
+static int sunxi_pcie_regulator_bypass(struct pcie_port *pp)
+{
+ struct sunxi_pcie *pcie = to_sunxi_pcie(pp);
+ int ret;
+
+ ret = clk_prepare_enable(pcie->pcie_rst);
+ if (ret) {
+ dev_err(pp->dev, "unable to enable pcie_rst clock\n");
+ goto err_pcie_rst;
+ }
+ usleep_range(1000, 2000);
+
+ if (pcie->iodvdd < 2000)
+ sunxi_pcie_phy_cfg(pcie, 1);
+ else
+ sunxi_pcie_phy_cfg(pcie, 0);
+
+ usleep_range(1000, 2000);
+ ret = clk_prepare_enable(pcie->pcie_power);
+ if (ret) {
+ dev_err(pp->dev, "unable to enable pcie_power clock\n");
+ goto err_pcie_power;
+ }
+
+ return 0;
+
+err_pcie_power:
+ clk_disable_unprepare(pcie->pcie_rst);
+err_pcie_rst:
+ return ret;
+}
+
+static int sunxi_pcie_clk_setup(struct pcie_port *pp)
+{
+ struct sunxi_pcie *pcie = to_sunxi_pcie(pp);
+ int ret;
+
+#ifndef CONFIG_PCIE_SUNXI_EXTERNAL_CLOCK
+ ret = clk_prepare_enable(pcie->pcie_ref);
+ if (ret) {
+ dev_err(pp->dev, "unable to enable pcie_ref clock\n");
+ goto err_pcie_ref;
+ }
+#endif
+ ret = clk_prepare_enable(pcie->pcie_axi);
+ if (ret) {
+ dev_err(pp->dev, "unable to enable pcie_axi clock\n");
+ goto err_pcie_axi;
+ }
+
+ ret = clk_prepare_enable(pcie->pcie_aux);
+ if (ret) {
+ dev_err(pp->dev, "unable to enable pcie_aux clock\n");
+ goto err_pcie_aux;
+ }
+
+ ret = clk_prepare_enable(pcie->pcie_bus);
+ if (ret) {
+ dev_err(pp->dev, "unable to enable pcie_bus clock\n");
+ goto err_pcie_bus;
+ }
+
+ return 0;
+
+err_pcie_bus:
+ clk_disable_unprepare(pcie->pcie_aux);
+err_pcie_aux:
+ clk_disable_unprepare(pcie->pcie_axi);
+err_pcie_axi:
+#ifndef CONFIG_PCIE_SUNXI_EXTERNAL_CLOCK
+ clk_disable_unprepare(pcie->pcie_ref);
+err_pcie_ref:
+#endif
+ return ret;
+}
+
+static void sunxi_pcie_clk_exit(struct pcie_port *pp)
+{
+ struct sunxi_pcie *pcie = to_sunxi_pcie(pp);
+
+#ifndef CONFIG_PCIE_SUNXI_EXTERNAL_CLOCK
+ clk_disable_unprepare(pcie->pcie_ref);
+#endif
+ clk_disable_unprepare(pcie->pcie_axi);
+ clk_disable_unprepare(pcie->pcie_aux);
+ clk_disable_unprepare(pcie->pcie_bus);
+ clk_disable_unprepare(pcie->pcie_rst);
+ clk_disable_unprepare(pcie->pcie_power);
+}
+
+static irqreturn_t sunxi_plat_pcie_msi_irq_handler(int irq, void *arg)
+{
+ struct pcie_port *pp = (struct pcie_port *)arg;
+
+ return dw_handle_msi_irq(pp);
+}
+
+static irqreturn_t sunxi_plat_pcie_linkup_handler(int irq, void *arg)
+{
+ struct pcie_port *pp = (struct pcie_port *)arg;
+
+ sunxi_pcie_irqpending(pp);
+
+ return IRQ_HANDLED;
+}
+
+static int sunxi_get_gpio_info(struct device_node *node, const char *name,
+ struct gpio_config *gc, struct sunxi_pcie *sunxi_pcie)
+{
+ int gnum;
+
+ gnum = of_get_named_gpio_flags(node, name, 0, (enum of_gpio_flags *)gc);
+ if (!gpio_is_valid(gnum)) {
+ gc->gpio = 0xFFFFFFF0;
+ dev_err(&sunxi_pcie->dev, "get %s from device_tree failed\n", name);
+ return -EINVAL;
+ }
+
+ return 0;
+
+}
+static int sunxi_pcie_gpio_request(struct sunxi_pcie *sunxi_pcie)
+{
+ int i;
+ struct gpio_config *gc = NULL;
+
+ for (i = 0; i < MAX_GPIO_NUM; i++) {
+ gc = &sunxi_pcie->gpio[i];
+ if (gc == NULL || gc->gpio == 0xFFFFFFF0)
+ continue;
+ if (gpio_request(gc->gpio, NULL) < 0) {
+ dev_err(&sunxi_pcie->dev, "gpio%d request failed!\n", gc->gpio);
+ continue;
+ }
+ dev_info(&sunxi_pcie->dev, "gpio%d request success!\n", gc->gpio);
+ }
+
+ return 0;
+}
+
+static int sunxi_pcie_gpio_output(struct sunxi_pcie *sunxi_pcie,
+ enum gpio_type gpio_id, int val)
+{
+ struct gpio_config *gc = NULL;
+
+ gc = &sunxi_pcie->gpio[gpio_id];
+ if (gc == NULL || gc->gpio == 0xFFFFFFF0)
+ return -1;
+ if (val) {
+ if (0 != gpio_direction_output(gc->gpio, 1)) {
+ dev_err(&sunxi_pcie->dev, "gpio%d set 0 err!", gc->gpio);
+ return -1;
+ }
+ } else {
+ if (0 != gpio_direction_output(gc->gpio, 0)) {
+ dev_err(&sunxi_pcie->dev, "gpio%d set 0 err!", gc->gpio);
+ return -1;
+ }
+ }
+
+ return 0;
+}
+static int sunxi_pcie_gpio_reset(struct platform_device *pdev, struct sunxi_pcie *sunxi_pcie)
+{
+ struct device_node *np = pdev->dev.of_node;
+
+ sunxi_get_gpio_info(np, "pcie_power", &sunxi_pcie->gpio[PCIE_POWER], sunxi_pcie);
+ sunxi_get_gpio_info(np, "pcie_rest", &sunxi_pcie->gpio[PCIE_REST], sunxi_pcie);
+ sunxi_get_gpio_info(np, "pcie_reg", &sunxi_pcie->gpio[PCIE_REG], sunxi_pcie);
+ sunxi_pcie_gpio_request(sunxi_pcie);
+
+ sunxi_pcie_gpio_output(sunxi_pcie, PCIE_POWER, 1);
+ usleep_range(1000, 1100);
+ sunxi_pcie_gpio_output(sunxi_pcie, PCIE_REST, 1);
+ usleep_range(1000, 1100);
+ sunxi_pcie_gpio_output(sunxi_pcie, PCIE_REST, 0);
+ usleep_range(1000, 1100);
+ sunxi_pcie_gpio_output(sunxi_pcie, PCIE_REST, 1);
+ usleep_range(1000, 1100);
+ sunxi_pcie_gpio_output(sunxi_pcie, PCIE_REG, 1);
+
+ return 0;
+}
+
+static int get_value_string(struct device_node *np, const char *name,
+ char *string)
+{
+ int ret;
+ const char *const_str;
+
+ ret = of_property_read_string(np, name, &const_str);
+ if (ret) {
+ strcpy(string, "");
+ pr_err("fetch %s from device_tree failed\n", name);
+ return -EINVAL;
+ }
+ strcpy(string, const_str);
+ pr_debug("%s = %s\n", name, string);
+ return 0;
+}
+
+static int get_value_int(struct device_node *np, const char *name,
+ u32 *value)
+{
+ int ret;
+
+ ret = of_property_read_u32(np, name, value);
+ if (ret) {
+ *value = 0;
+ pr_err("fetch %s from device_tree failed\n", name);
+ }
+ pr_debug("%s = %x\n", name, *value);
+
+ return 0;
+}
+
+static int sunxi_get_power_info(struct device_node *node, struct sunxi_pcie *sunxi_pcie, enum power_type type)
+{
+ struct power *power = NULL;
+
+ switch (type) {
+ case PCIE_VDD:
+ power = &sunxi_pcie->power[PCIE_VDD];
+ get_value_string(node, "pcie_vdd", power->power_str);
+ get_value_int(node, "pcie_vdd_vol", &power->power_vol);
+ break;
+ case PCIE_VCC:
+ power = &sunxi_pcie->power[PCIE_VCC];
+ get_value_string(node, "pcie_vcc", power->power_str);
+ get_value_int(node, "pcie_vcc_vol", &power->power_vol);
+ break;
+ case PCIE_VCC_SLOT:
+ power = &sunxi_pcie->power[PCIE_VCC_SLOT];
+ get_value_string(node, "pcie_vcc_slot", power->power_str);
+ get_value_int(node, "pcie_vcc_slot_vol", &power->power_vol);
+ break;
+ default:
+ return -1;
+ }
+
+ return 0;
+}
+static int sunxi_pcie_set_pmu(struct sunxi_pcie *sunxi_pcie, enum power_type pmic_ch, int on)
+{
+ int ret = 0;
+ struct power *power = NULL;
+
+ power = &sunxi_pcie->power[pmic_ch];
+ if (on) {
+ if (power[pmic_ch].pmic
+ && regulator_is_enabled(power->pmic)) {
+ pr_debug("regulator_is already enabled\n");
+ } else {
+ if (strcmp(power->power_str, "")) {
+ power->pmic = regulator_get(NULL, power->power_str);
+ if (IS_ERR_OR_NULL(power->pmic)) {
+ pr_err("get regulator %s error!\n",
+ power->power_str);
+ power->pmic = NULL;
+ return -1;
+ }
+ } else {
+ power->pmic = NULL;
+ return 0;
+ }
+ }
+ ret = regulator_set_voltage(power->pmic, power->power_vol, power->power_vol);
+ pr_info("set regulator %s = %d,return %x\n",
+ power->power_str, power->power_vol, ret);
+ ret = regulator_enable(power->pmic);
+
+ } else {
+ if (power->pmic == NULL)
+ return 0;
+ ret = regulator_disable(power->pmic);
+ if (!regulator_is_enabled(power->pmic)) {
+ pr_info("regulator_is already disabled\n");
+ regulator_put(power->pmic);
+ power->pmic = NULL;
+ }
+ }
+
+ return ret;
+}
+
+static int sunxi_pcie_get_clk(struct platform_device *pdev, struct sunxi_pcie *sunxi_pcie)
+{
+ struct device_node *node = pdev->dev.of_node;
+
+ sunxi_pcie->pcie_ref = of_clk_get(node, 0);
+ if (IS_ERR_OR_NULL(sunxi_pcie->pcie_ref)) {
+ dev_err(&pdev->dev, "%s:get pcie ref clk failed\n", __func__);
+ return -1;
+ }
+
+ sunxi_pcie->pcie_axi = of_clk_get(node, 1);
+ if (IS_ERR_OR_NULL(sunxi_pcie->pcie_axi)) {
+ dev_err(&pdev->dev, "%s:get pcie axi clk failed\n", __func__);
+ return -1;
+ }
+
+ sunxi_pcie->pcie_aux = of_clk_get(node, 2);
+ if (IS_ERR_OR_NULL(sunxi_pcie->pcie_aux)) {
+ dev_err(&pdev->dev, "%s:get pcie aux clk failed\n", __func__);
+ return -1;
+ }
+
+ sunxi_pcie->pcie_bus = of_clk_get(node, 3);
+ if (IS_ERR_OR_NULL(sunxi_pcie->pcie_bus)) {
+ dev_err(&pdev->dev, "%s:get pcie bus clk failed\n", __func__);
+ return -1;
+ }
+ sunxi_pcie->pcie_power = of_clk_get(node, 4);
+ if (IS_ERR_OR_NULL(sunxi_pcie->pcie_power)) {
+ dev_err(&pdev->dev, "%s:get pcie power clk failed\n", __func__);
+ return -1;
+ }
+ sunxi_pcie->pcie_rst = of_clk_get(node, 5);
+ if (IS_ERR_OR_NULL(sunxi_pcie->pcie_rst)) {
+ dev_err(&pdev->dev, "%s:get pcie reset clk failed\n", __func__);
+ return -1;
+ }
+
+ return 0;
+}
+
+#ifdef CONFIG_ARCH_SUN50IW6
+spinlock_t cut_page_reg_spinlock = __SPIN_LOCK_UNLOCKED(cut_page_reg_spinlock);
+struct pci_page sunxi_pcie_bus_cutpage_config(struct pci_dev *dev, int barnum, u32 bar_base, unsigned long offset)
+{
+ u32 cutpage;
+ struct pci_page sunxi_page;
+ unsigned long size;
+
+ size = pci_resource_len(dev, barnum);
+ sunxi_page.mem_base = mem_base_start;
+ bar_base = bar_base & PCIE_HIGH16_MASK;
+ sunxi_page.offset = offset & PCIE_LOW16_MASK;
+ cutpage = bar_base + (((size - 1) & offset) & PCIE_HIGH16_MASK);
+ writel(cutpage >> PCIE_HIGH_16, dbi_base + PCIE_ADDR_PAGE_CFG);
+
+ return sunxi_page;
+}
+EXPORT_SYMBOL(sunxi_pcie_bus_cutpage_config);
+
+struct pci_page sunxi_pcie_device_cutpage_config(u32 bar_base, unsigned long offset)
+{
+ u32 cutpage;
+ struct pci_page sunxi_page;
+
+ sunxi_page.mem_base = mem_base_start;
+ bar_base = bar_base & PCIE_HIGH16_MASK;
+ sunxi_page.offset = offset & PCIE_LOW16_MASK;
+ cutpage = bar_base + (offset & PCIE_HIGH16_MASK);
+ writel(cutpage >> PCIE_HIGH_16, dbi_base + PCIE_ADDR_PAGE_CFG);
+
+ return sunxi_page;
+}
+EXPORT_SYMBOL(sunxi_pcie_device_cutpage_config);
+
+int sunxi_pcie_cutpage_base(u32 bar_base)
+{
+ writel(bar_base >> PCIE_HIGH_16, dbi_base + PCIE_ADDR_PAGE_CFG);
+
+ return 0;
+}
+EXPORT_SYMBOL(sunxi_pcie_cutpage_base);
+
+unsigned long sunxi_pcie_cutpage_spin_lock(void)
+{
+ unsigned long flags = 0;
+
+ spin_lock_irqsave(&cut_page_reg_spinlock, flags);
+
+ return flags;
+}
+EXPORT_SYMBOL(sunxi_pcie_cutpage_spin_lock);
+
+void sunxi_pcie_cutpage_spin_unlock(unsigned long flags)
+{
+ spin_unlock_irqrestore(&cut_page_reg_spinlock, flags);
+}
+EXPORT_SYMBOL(sunxi_pcie_cutpage_spin_unlock);
+#endif
+
+static void sunxi_pcie_prog_outbound_atu(struct pcie_port *pp, int index,
+ int type, u64 cpu_addr, u64 pci_addr, u32 size)
+{
+ dw_pcie_writel_rc(pp, PCIE_ATU_VIEWPORT,
+ PCIE_ATU_REGION_OUTBOUND | index);
+ dw_pcie_writel_rc(pp, PCIE_ATU_LOWER_BASE,
+ lower_32_bits(cpu_addr));
+ dw_pcie_writel_rc(pp, PCIE_ATU_UPPER_BASE,
+ upper_32_bits(cpu_addr));
+ dw_pcie_writel_rc(pp, PCIE_ATU_LIMIT,
+ lower_32_bits(cpu_addr + size - 1));
+ dw_pcie_writel_rc(pp, PCIE_ATU_LOWER_TARGET,
+ lower_32_bits(pci_addr));
+ dw_pcie_writel_rc(pp, PCIE_ATU_UPPER_TARGET,
+ upper_32_bits(pci_addr));
+ dw_pcie_writel_rc(pp, PCIE_ATU_CR1, type);
+ dw_pcie_writel_rc(pp, PCIE_ATU_CR2, PCIE_ATU_ENABLE);
+}
+
+static int sunxi_pcie_rd_other_conf(struct pcie_port *pp, struct pci_bus *bus,
+ u32 devfn, int where, int size, u32 *val)
+{
+ int ret, type, i;
+ u32 busdev, cfg_size;
+ u64 cpu_addr;
+ void __iomem *va_cfg_base;
+ int pcie_page, mem_base;
+ unsigned long flags = 0;
+
+ busdev = PCIE_ATU_BUS(bus->number) | PCIE_ATU_DEV(PCI_SLOT(devfn)) |
+ PCIE_ATU_FUNC(PCI_FUNC(devfn));
+
+ if (bus->parent->number == pp->root_bus_nr) {
+ type = PCIE_ATU_TYPE_CFG0;
+ cpu_addr = pp->cfg0_base;
+ cfg_size = pp->cfg0_size;
+ va_cfg_base = pp->va_cfg0_base;
+ } else {
+ type = PCIE_ATU_TYPE_CFG1;
+ cpu_addr = pp->cfg1_base;
+ cfg_size = pp->cfg1_size;
+ va_cfg_base = pp->va_cfg1_base;
+ }
+
+ flags = sunxi_pcie_cutpage_spin_lock();
+
+ sunxi_pcie_writel_rcl(pp, pp->cfg0_base >> PCIE_HIGH_16, PCIE_ADDR_PAGE_CFG);
+ sunxi_pcie_prog_outbound_atu(pp, PCIE_ATU_REGION_INDEX1,
+ type, cpu_addr,
+ busdev, cfg_size);
+ ret = sunxi_pcie_cfg_read(va_cfg_base + where, size, val);
+ for (i = 0; i < PCIE_BAR_NUM; i++) {
+ pcie_page = readl(pp->va_cfg0_base + PCI_BASE_ADDRESS_0 + i * PCIE_BAR_REG);
+ mem_base = readl(pp->dbi_base + PCI_MEMORY_BASE);
+ if (((pcie_page >> MEM_BASE_LEN) & MEM_BASE_MASK)
+ == (mem_base & MEM_BASE_MASK))
+ break;
+ }
+ sunxi_pcie_writel_rcl(pp, pcie_page >> PCIE_HIGH_16, PCIE_ADDR_PAGE_CFG);
+
+ sunxi_pcie_prog_outbound_atu(pp, PCIE_ATU_REGION_INDEX0,
+ PCIE_ATU_TYPE_MEM, pp->mem_base,
+ pp->mem_bus_addr, pp->mem_size);
+
+ sunxi_pcie_cutpage_spin_unlock(flags);
+
+ return ret;
+}
+
+static int sunxi_pcie_wr_other_conf(struct pcie_port *pp, struct pci_bus *bus,
+ unsigned int devfn, int where, int size, u32 val)
+{
+ int ret, type, i;
+ u32 busdev, cfg_size;
+ u64 cpu_addr;
+ void __iomem *va_cfg_base;
+ int pcie_page, mem_base;
+ unsigned long flags = 0;
+
+ busdev = PCIE_ATU_BUS(bus->number) | PCIE_ATU_DEV(PCI_SLOT(devfn)) |
+ PCIE_ATU_FUNC(PCI_FUNC(devfn));
+
+ if (bus->parent->number == pp->root_bus_nr) {
+ type = PCIE_ATU_TYPE_CFG0;
+ cpu_addr = pp->cfg0_base;
+ cfg_size = pp->cfg0_size;
+ va_cfg_base = pp->va_cfg0_base;
+ } else {
+ type = PCIE_ATU_TYPE_CFG1;
+ cpu_addr = pp->cfg1_base;
+ cfg_size = pp->cfg1_size;
+ va_cfg_base = pp->va_cfg1_base;
+ }
+
+ flags = sunxi_pcie_cutpage_spin_lock();
+
+ sunxi_pcie_writel_rcl(pp, pp->cfg0_base >> PCIE_HIGH_16, PCIE_ADDR_PAGE_CFG);
+ sunxi_pcie_prog_outbound_atu(pp, PCIE_ATU_REGION_INDEX1,
+ type, cpu_addr,
+ busdev, cfg_size);
+ ret = sunxi_pcie_cfg_write(va_cfg_base + where, size, val);
+ for (i = 0; i < PCIE_BAR_NUM; i++) {
+ pcie_page = readl(pp->va_cfg0_base + PCI_BASE_ADDRESS_0 + i * PCIE_BAR_REG);
+ mem_base = readl(pp->dbi_base + PCI_MEMORY_BASE);
+ if (((pcie_page >> MEM_BASE_LEN) & MEM_BASE_MASK)
+ == (mem_base & MEM_BASE_MASK))
+ break;
+ }
+ sunxi_pcie_writel_rcl(pp, pcie_page >> PCIE_HIGH_16, PCIE_ADDR_PAGE_CFG);
+
+ sunxi_pcie_prog_outbound_atu(pp, PCIE_ATU_REGION_INDEX0,
+ PCIE_ATU_TYPE_MEM, pp->mem_base,
+ pp->mem_bus_addr, pp->mem_size);
+
+ sunxi_pcie_cutpage_spin_unlock(flags);
+
+ return ret;
+}
+
+static void sunxi_plat_pcie_host_init(struct pcie_port *pp)
+{
+ struct sunxi_pcie *pcie = to_sunxi_pcie(pp);
+
+ sunxi_pcie_ltssm_disable(pp);
+ sunxi_pcie_clk_clect(pp, PAD_CLK);
+
+ dw_pcie_setup_rc(pp);
+
+ sunxi_pcie_establish_link(pp);
+ if (IS_ENABLED(CONFIG_PCI_MSI))
+ dw_pcie_msi_init(pp);
+ sunxi_pcie_speed_chang(pp, pcie->speed_gen);
+}
+
+static struct pcie_host_ops sunxi_plat_pcie_host_ops = {
+ .link_up = sunxi_pcie_link_up_status,
+ .host_init = sunxi_plat_pcie_host_init,
+ .rd_other_conf = sunxi_pcie_rd_other_conf,
+ .wr_other_conf = sunxi_pcie_wr_other_conf,
+};
+
+static int sunxi_plat_add_pcie_port(struct pcie_port *pp,
+ struct platform_device *pdev)
+{
+ int ret;
+
+ if (IS_ENABLED(CONFIG_PCI_MSI)) {
+ pp->msi_irq = platform_get_irq(pdev, 0);
+ if (pp->msi_irq < 0)
+ return pp->msi_irq;
+
+ ret = devm_request_irq(&pdev->dev, pp->msi_irq,
+ sunxi_plat_pcie_msi_irq_handler,
+ IRQF_SHARED, "sunxi-plat-pcie-msi", pp);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to request MSI IRQ\n");
+ return ret;
+ }
+ }
+
+ pp->root_bus_nr = -1;
+ pp->ops = &sunxi_plat_pcie_host_ops;
+
+ ret = dw_pcie_host_init(pp);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to initialize host\n");
+ return ret;
+ }
+ dbi_base = pp->dbi_base;
+ mem_base_start = pp->va_cfg0_base;
+
+ return 0;
+}
+
+static int sunxi_plat_pcie_probe(struct platform_device *pdev)
+{
+ struct sunxi_pcie *sunxi_pcie;
+ struct pcie_port *pp;
+ struct resource *res; /* Resource from DT */
+ int ret, i;
+
+ sunxi_pcie = devm_kzalloc(&pdev->dev, sizeof(*sunxi_pcie),
+ GFP_KERNEL);
+ if (!sunxi_pcie)
+ return -ENOMEM;
+
+ pp = &sunxi_pcie->pp;
+ pp->dev = &pdev->dev;
+ sunxi_pcie->dev = pdev->dev;
+
+ res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+ if (!res)
+ return -ENODEV;
+
+ sunxi_pcie->dbi_base = devm_ioremap_resource(&pdev->dev, res);
+ if (IS_ERR(sunxi_pcie->dbi_base))
+ return PTR_ERR(sunxi_pcie->dbi_base);
+
+ pp->dbi_base = sunxi_pcie->dbi_base;
+ sunxi_pcie->app_base = sunxi_pcie->dbi_base + USER_DEFINED_REGISTER_LIST;
+ sunxi_pcie_get_clk(pdev, sunxi_pcie);
+
+ ret = of_property_read_u32(pdev->dev.of_node, "pcie_speed_gen", &sunxi_pcie->speed_gen);
+ if (ret) {
+ dev_info(&pdev->dev, "get speed Gen failed\n");
+ sunxi_pcie->speed_gen = 0x1;
+ }
+ ret = of_property_read_u32(pdev->dev.of_node, "pcie_iodvdd", &sunxi_pcie->iodvdd);
+ if (ret) {
+ dev_info(&pdev->dev, "get iodvdd failed\n");
+ sunxi_pcie->iodvdd = 1800;
+ }
+ for (i = 0; i < MAX_POWER_NUM; i++)
+ sunxi_get_power_info(pdev->dev.of_node, sunxi_pcie, i);
+
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VDD, 1);
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VCC, 1);
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VCC_SLOT, 1);
+ if (sunxi_pcie_clk_setup(pp))
+ return -1;
+
+ if (sunxi_pcie_regulator_bypass(pp))
+ return -1;
+
+ sunxi_pcie_irqmask(pp);
+ sunxi_pcie->link_irq = platform_get_irq(pdev, 1);
+ ret = devm_request_irq(&pdev->dev, sunxi_pcie->link_irq,
+ sunxi_plat_pcie_linkup_handler,
+ IRQF_SHARED, "sunxi-pcie-linkup", pp);
+ if (ret) {
+ dev_err(&pdev->dev, "failed to request linkup IRQ\n");
+ return ret;
+ }
+ sunxi_pcie_gpio_reset(pdev, sunxi_pcie);
+ ret = sunxi_plat_add_pcie_port(pp, pdev);
+ if (ret < 0)
+ return ret;
+
+ platform_set_drvdata(pdev, sunxi_pcie);
+
+ return 0;
+}
+
+static int sunxi_plat_pcie_remove(struct platform_device *pdev)
+{
+ struct sunxi_pcie *sunxi_pcie = platform_get_drvdata(pdev);
+ struct pcie_port *pp = &sunxi_pcie->pp;
+
+ sunxi_pcie_clk_exit(pp);
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VDD, 0);
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VCC, 0);
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VCC_SLOT, 0);
+
+ return 0;
+}
+
+#ifdef CONFIG_PM
+static int sunxi_pcie_hw_init(struct sunxi_pcie *sunxi_pcie)
+{
+ struct pcie_port *pp = &sunxi_pcie->pp;
+ int val, i;
+
+ if (sunxi_pcie_clk_setup(pp))
+ return -1;
+
+ if (sunxi_pcie_regulator_bypass(pp))
+ return -1;
+
+ usleep_range(100, 1000);
+ sunxi_pcie_ltssm_disable(pp);
+ sunxi_pcie_clk_clect(pp, PAD_CLK);
+
+ dw_pcie_setup_rc(pp);
+ sunxi_pcie_ltssm_enable(pp);
+ if (IS_ENABLED(CONFIG_PCI_MSI)) {
+ u64 msi_target;
+
+ msi_target = virt_to_phys((void *)pp->msi_data);
+
+ /* program the msi_data */
+ sunxi_pcie_writel_rcl(pp, (u32)(msi_target & 0xffffffff), PCIE_MSI_ADDR_LO);
+ sunxi_pcie_writel_rcl(pp, (u32)(msi_target >> 32 & 0xffffffff), PCIE_MSI_ADDR_HI);
+ }
+
+ val = sunxi_pcie_readl_rcl(pp, LINK_CONTROL2_LINK_STATUS2);
+ val &= ~0xf;
+ val |= sunxi_pcie->speed_gen;
+ sunxi_pcie_writel_rcl(pp, val, LINK_CONTROL2_LINK_STATUS2);
+
+ val = sunxi_pcie_readl_rcl(pp, PCIE_LINK_WIDTH_SPEED_CONTROL);
+ val &= ~PORT_LOGIC_SPEED_CHANGE;
+ sunxi_pcie_writel_rcl(pp, val, PCIE_LINK_WIDTH_SPEED_CONTROL);
+
+ val = sunxi_pcie_readl_rcl(pp, PCIE_LINK_WIDTH_SPEED_CONTROL);
+ val |= PORT_LOGIC_SPEED_CHANGE;
+ sunxi_pcie_writel_rcl(pp, val, PCIE_LINK_WIDTH_SPEED_CONTROL);
+
+ for (i = 0; i < 16; i++)
+ sunxi_pcie_writel_rcl(pp, sunxi_pcie->buffer[i], i * 4);
+
+ sunxi_pcie_writel_rcl(pp, sunxi_pcie->msi_enable, PCIE_MSI_INTR0_ENABLE);
+
+ return 0;
+}
+
+static int sunxi_pcie_hw_exit(struct sunxi_pcie *sunxi_pcie)
+{
+ struct pcie_port *pp = &sunxi_pcie->pp;
+ int i;
+
+ for (i = 0; i < 16; i++)
+ sunxi_pcie->buffer[i] = sunxi_pcie_readl_rcl(pp, i * 4);
+
+ sunxi_pcie->msi_enable = sunxi_pcie_readl_rcl(pp, PCIE_MSI_INTR0_ENABLE);
+ sunxi_pcie_clk_exit(pp);
+
+ return 0;
+}
+
+static int sunxi_pcie_suspend(struct device *dev)
+{
+ struct platform_device *pdev = to_platform_device(dev);
+ struct sunxi_pcie *sunxi_pcie = platform_get_drvdata(pdev);
+
+ sunxi_pcie_hw_exit(sunxi_pcie);
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VDD, 0);
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VCC, 0);
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VCC_SLOT, 0);
+
+ return 0;
+}
+
+static int sunxi_pcie_resume(struct device *dev)
+{
+ struct platform_device *pdev = to_platform_device(dev);
+ struct sunxi_pcie *sunxi_pcie = platform_get_drvdata(pdev);
+
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VDD, 1);
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VCC, 1);
+ sunxi_pcie_set_pmu(sunxi_pcie, PCIE_VCC_SLOT, 1);
+
+ sunxi_pcie_hw_init(sunxi_pcie);
+
+ return 0;
+}
+static const struct dev_pm_ops sunxi_pcie_pm_ops = {
+ .suspend_noirq = sunxi_pcie_suspend,
+ .resume_noirq = sunxi_pcie_resume,
+};
+#define SUNXI_PCIE_PM_OPS (&sunxi_pcie_pm_ops)
+#else
+#define SUNXI_PCIE_PM_OPS NULL
+#endif /* CONFIG_PM */
+
+static const struct of_device_id sunxi_plat_pcie_of_match[] = {
+ { .compatible = "allwinner,sun50i-pcie", },
+ {},
+};
+MODULE_DEVICE_TABLE(of, sunxi_plat_pcie_of_match);
+
+static struct platform_driver sunxi_plat_pcie_driver = {
+ .driver = {
+ .name = "sunxi-pcie",
+ .owner = THIS_MODULE,
+ .of_match_table = sunxi_plat_pcie_of_match,
+ .pm = SUNXI_PCIE_PM_OPS,
+ },
+ .remove = sunxi_plat_pcie_remove,
+ .probe = sunxi_plat_pcie_probe,
+};
+
+static int __init sunxi_pcie_init(void)
+{
+ return platform_driver_register(&sunxi_plat_pcie_driver);
+}
+
+static void __exit sunxi_pcie_exit(void)
+{
+ platform_driver_unregister(&sunxi_plat_pcie_driver);
+}
+fs_initcall(sunxi_pcie_init);
+module_exit(sunxi_pcie_exit);
+
+MODULE_AUTHOR("wangjx <wangjx@allwinnertech.com>");
+MODULE_DESCRIPTION("Allwinner PCIe host controller glue platform driver");
+MODULE_LICENSE("GPL v2");
View Git Blame Copy Permalink