ifdef CONFIG_TARGET_ramips_mt7621
XHCI_MODULES += xhci-mtk
endif
+ifdef CONFIG_TARGET_apm821xx_nand
+ XHCI_MODULES += xhci-pci-renesas
+endif
XHCI_FILES := $(wildcard $(patsubst %,$(LINUX_DIR)/drivers/usb/host/%.ko,$(XHCI_MODULES)))
XHCI_AUTOLOAD := $(patsubst $(LINUX_DIR)/drivers/usb/host/%.ko,%,$(XHCI_FILES))
CONFIG_USB_XHCI_PCI \
CONFIG_USB_XHCI_PLATFORM \
CONFIG_USB_XHCI_MTK \
+ CONFIG_USB_XHCI_PCI_RENESAS \
CONFIG_USB_XHCI_HCD_DEBUGGING=n
FILES:= \
$(XHCI_FILES)
--- /dev/null
+From 9448f23ccd2f6ba782768f92c04fa62cac295f50 Mon Sep 17 00:00:00 2001
+From: Vinod Koul <vkoul@kernel.org>
+Date: Mon, 13 Jan 2020 14:10:01 +0530
+Subject: [PATCH 100/104] usb: xhci: export few functions
+
+Export the xhci_pci_setup(), xhci_pci_probe() xhci_pci_remove(),
+xhci_pci_suspend() and xhci_pci_resume() functions as they would be used
+by renesas-xhci driver.
+
+Signed-off-by: Vinod Koul <vkoul@kernel.org>
+Signed-off-by: Christian Lamparter <chunkeey@gmail.com> [5.4 backport]
+---
+ drivers/usb/host/xhci-pci.c | 18 +++++++++++-------
+ drivers/usb/host/xhci-pci.h | 18 ++++++++++++++++++
+ 2 files changed, 29 insertions(+), 7 deletions(-)
+ create mode 100644 drivers/usb/host/xhci-pci.h
+
+--- a/drivers/usb/host/xhci-pci.c
++++ b/drivers/usb/host/xhci-pci.c
+@@ -15,6 +15,7 @@
+
+ #include "xhci.h"
+ #include "xhci-trace.h"
++#include "xhci-pci.h"
+
+ #define SSIC_PORT_NUM 2
+ #define SSIC_PORT_CFG2 0x880c
+@@ -60,8 +61,6 @@ static const char hcd_name[] = "xhci_hcd
+
+ static struct hc_driver __read_mostly xhci_pci_hc_driver;
+
+-static int xhci_pci_setup(struct usb_hcd *hcd);
+-
+ static const struct xhci_driver_overrides xhci_pci_overrides __initconst = {
+ .reset = xhci_pci_setup,
+ };
+@@ -282,7 +281,7 @@ static void xhci_pme_acpi_rtd3_enable(st
+ #endif /* CONFIG_ACPI */
+
+ /* called during probe() after chip reset completes */
+-static int xhci_pci_setup(struct usb_hcd *hcd)
++int xhci_pci_setup(struct usb_hcd *hcd)
+ {
+ struct xhci_hcd *xhci;
+ struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
+@@ -307,12 +306,13 @@ static int xhci_pci_setup(struct usb_hcd
+ /* Find any debug ports */
+ return xhci_pci_reinit(xhci, pdev);
+ }
++EXPORT_SYMBOL_GPL(xhci_pci_setup);
+
+ /*
+ * We need to register our own PCI probe function (instead of the USB core's
+ * function) in order to create a second roothub under xHCI.
+ */
+-static int xhci_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
++int xhci_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
+ {
+ int retval;
+ struct xhci_hcd *xhci;
+@@ -378,8 +378,9 @@ put_runtime_pm:
+ pm_runtime_put_noidle(&dev->dev);
+ return retval;
+ }
++EXPORT_SYMBOL_GPL(xhci_pci_probe);
+
+-static void xhci_pci_remove(struct pci_dev *dev)
++void xhci_pci_remove(struct pci_dev *dev)
+ {
+ struct xhci_hcd *xhci;
+
+@@ -401,6 +402,7 @@ static void xhci_pci_remove(struct pci_d
+
+ usb_hcd_pci_remove(dev);
+ }
++EXPORT_SYMBOL_GPL(xhci_pci_remove);
+
+ #ifdef CONFIG_PM
+ /*
+@@ -457,7 +459,7 @@ static void xhci_pme_quirk(struct usb_hc
+ readl(reg);
+ }
+
+-static int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
++int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup)
+ {
+ struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+ struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
+@@ -482,8 +484,9 @@ static int xhci_pci_suspend(struct usb_h
+
+ return ret;
+ }
++EXPORT_SYMBOL_GPL(xhci_pci_suspend);
+
+-static int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
++int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated)
+ {
+ struct xhci_hcd *xhci = hcd_to_xhci(hcd);
+ struct pci_dev *pdev = to_pci_dev(hcd->self.controller);
+@@ -531,6 +534,7 @@ static void xhci_pci_shutdown(struct usb
+ if (xhci->quirks & XHCI_SPURIOUS_WAKEUP)
+ pci_set_power_state(pdev, PCI_D3hot);
+ }
++EXPORT_SYMBOL_GPL(xhci_pci_resume);
+ #endif /* CONFIG_PM */
+
+ /*-------------------------------------------------------------------------*/
+--- /dev/null
++++ b/drivers/usb/host/xhci-pci.h
+@@ -0,0 +1,18 @@
++/* SPDX-License-Identifier: GPL-2.0 */
++/* Copyright (C) 2008 Intel Corp. */
++
++#ifndef XHCI_PCI_H
++#define XHCI_PCI_H
++
++int xhci_pci_setup(struct usb_hcd *hcd);
++
++int xhci_pci_probe(struct pci_dev *pdev,
++ const struct pci_device_id *id);
++
++void xhci_pci_remove(struct pci_dev *dev);
++
++int xhci_pci_suspend(struct usb_hcd *hcd, bool do_wakeup);
++
++int xhci_pci_resume(struct usb_hcd *hcd, bool hibernated);
++
++#endif
--- /dev/null
+From 9dc92708f091bb931aff2e32aa2da1020fabd2a1 Mon Sep 17 00:00:00 2001
+From: Christian Lamparter <chunkeey@googlemail.com>
+Date: Mon, 13 Jan 2020 14:10:02 +0530
+Subject: [PATCH 101/104] usb: renesas-xhci: Add the renesas xhci driver
+
+This add a new driver for renesas xhci which is basically a firmware
+loader for uPD720201 and uPD720202 w/o ROM. It uses xhci-pci driver for
+most of the work.
+
+This is added in Makefile before the xhci-pci driver so that it first
+get probed for renesas devices before the xhci-pci driver has a chance
+to claim any device.
+
+This patch adds a firmware loader for the uPD720201K8-711-BAC-A
+and uPD720202K8-711-BAA-A variant. Both of these chips are listed
+in Renesas' R19UH0078EJ0500 Rev.5.00 "User's Manual: Hardware" as
+devices which need the firmware loader on page 2 in order to
+work as they "do not support the External ROM".
+
+The "Firmware Download Sequence" is describe in chapter
+"7.1 FW Download Interface" R19UH0078EJ0500 Rev.5.00 page 131.
+
+The firmware "K2013080.mem" is available from a USB3.0 Host to
+PCIe Adapter (PP2U-E card) "Firmware download" archive. An
+alternative version can be sourced from Netgear's WNDR4700 GPL
+archives.
+
+The release notes of the PP2U-E's "Firmware Download" ver 2.0.1.3
+(2012-06-15) state that the firmware is for the following devices:
+ - uPD720201 ES 2.0 sample whose revision ID is 2.
+ - uPD720201 ES 2.1 sample & CS sample & Mass product, ID is 3.
+ - uPD720202 ES 2.0 sample & CS sample & Mass product, ID is 2.
+
+Cc: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
+Signed-off-by: Christian Lamparter <chunkeey@googlemail.com>
+Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>
+[vkoul: fixed comments:
+ used macros for timeout count and delay
+ removed renesas_fw_alive_check
+ cleaned renesas_fw_callback
+ removed recurion for renesas_fw_download
+ added MODULE_FIRMWARE
+ add register defines and field names
+ move to a separate driver]
+Signed-off-by: Vinod Koul <vkoul@kernel.org>
+Signed-off-by: Christian Lamparter <chunkeey@gmail.com> [5.4 backport]
+---
+ drivers/usb/host/Kconfig | 9 +
+ drivers/usb/host/Makefile | 1 +
+ drivers/usb/host/xhci-pci-renesas.c | 557 ++++++++++++++++++++++++++++
+ 3 files changed, 567 insertions(+)
+ create mode 100644 drivers/usb/host/xhci-pci-renesas.c
+
+--- a/drivers/usb/host/Kconfig
++++ b/drivers/usb/host/Kconfig
+@@ -42,6 +42,15 @@ config USB_XHCI_PCI
+ depends on USB_PCI
+ default y
+
++config USB_XHCI_PCI_RENESAS
++ tristate "Renesas USB XHCI Driver"
++ depends on USB_XHCI_PCI
++ ---help---
++ Say 'Y' to enable the support for renesas USB XHCI Driver if
++ you have such a device. These devices need additional firmware,
++ make sure that is available.
++ If unsure, say 'N'.
++
+ config USB_XHCI_PLATFORM
+ tristate "Generic xHCI driver for a platform device"
+ select USB_XHCI_RCAR if ARCH_RENESAS
+--- a/drivers/usb/host/Makefile
++++ b/drivers/usb/host/Makefile
+@@ -70,6 +70,7 @@ obj-$(CONFIG_USB_OHCI_HCD_DAVINCI) += oh
+ obj-$(CONFIG_USB_UHCI_HCD) += uhci-hcd.o
+ obj-$(CONFIG_USB_FHCI_HCD) += fhci.o
+ obj-$(CONFIG_USB_XHCI_HCD) += xhci-hcd.o
++obj-$(CONFIG_USB_XHCI_PCI_RENESAS) += xhci-pci-renesas.o
+ obj-$(CONFIG_USB_XHCI_PCI) += xhci-pci.o
+ obj-$(CONFIG_USB_XHCI_PLATFORM) += xhci-plat-hcd.o
+ obj-$(CONFIG_USB_XHCI_HISTB) += xhci-histb.o
+--- /dev/null
++++ b/drivers/usb/host/xhci-pci-renesas.c
+@@ -0,0 +1,557 @@
++// SPDX-License-Identifier: GPL-2.0
++/* Copyright (C) 2019-2020 Linaro Limited */
++
++#include <linux/acpi.h>
++#include <linux/firmware.h>
++#include <linux/module.h>
++#include <linux/pci.h>
++#include <linux/slab.h>
++#include <linux/unaligned/access_ok.h>
++
++#include "xhci.h"
++#include "xhci-trace.h"
++#include "xhci-pci.h"
++
++#define RENESAS_FW_VERSION 0x6C
++#define RENESAS_ROM_CONFIG 0xF0
++#define RENESAS_FW_STATUS 0xF4
++#define RENESAS_FW_STATUS_MSB 0xF5
++#define RENESAS_ROM_STATUS 0xF6
++#define RENESAS_ROM_STATUS_MSB 0xF7
++#define RENESAS_DATA0 0xF8
++#define RENESAS_DATA1 0xFC
++
++#define RENESAS_FW_VERSION_FIELD GENMASK(23, 7)
++#define RENESAS_FW_VERSION_OFFSET 8
++
++#define RENESAS_FW_STATUS_DOWNLOAD_ENABLE BIT(0)
++#define RENESAS_FW_STATUS_LOCK BIT(1)
++#define RENESAS_FW_STATUS_RESULT GENMASK(6, 4)
++ #define RENESAS_FW_STATUS_INVALID 0
++ #define RENESAS_FW_STATUS_SUCCESS BIT(4)
++ #define RENESAS_FW_STATUS_ERROR BIT(5)
++#define RENESAS_FW_STATUS_SET_DATA0 BIT(8)
++#define RENESAS_FW_STATUS_SET_DATA1 BIT(9)
++
++#define RENESAS_RETRY 10000
++#define RENESAS_DELAY 10
++
++static struct hc_driver __read_mostly xhci_pci_hc_driver;
++
++static const struct xhci_driver_overrides xhci_pci_overrides __initconst = {
++ .reset = xhci_pci_setup,
++};
++
++static const struct renesas_fw_entry {
++ const char *firmware_name;
++ u16 device;
++ u8 revision;
++ u16 expected_version;
++} renesas_fw_table[] = {
++ /*
++ * Only the uPD720201K8-711-BAC-A or uPD720202K8-711-BAA-A
++ * are listed in R19UH0078EJ0500 Rev.5.00 as devices which
++ * need the software loader.
++ *
++ * PP2U/ReleaseNote_USB3-201-202-FW.txt:
++ *
++ * Note: This firmware is for the following devices.
++ * - uPD720201 ES 2.0 sample whose revision ID is 2.
++ * - uPD720201 ES 2.1 sample & CS sample & Mass product, ID is 3.
++ * - uPD720202 ES 2.0 sample & CS sample & Mass product, ID is 2.
++ */
++ { "K2013080.mem", 0x0014, 0x02, 0x2013 },
++ { "K2013080.mem", 0x0014, 0x03, 0x2013 },
++ { "K2013080.mem", 0x0015, 0x02, 0x2013 },
++};
++
++MODULE_FIRMWARE("K2013080.mem");
++
++static const struct renesas_fw_entry *renesas_needs_fw_dl(struct pci_dev *dev)
++{
++ const struct renesas_fw_entry *entry;
++ size_t i;
++
++ /* This loader will only work with a RENESAS device. */
++ if (!(dev->vendor == PCI_VENDOR_ID_RENESAS))
++ return NULL;
++
++ for (i = 0; i < ARRAY_SIZE(renesas_fw_table); i++) {
++ entry = &renesas_fw_table[i];
++ if (entry->device == dev->device &&
++ entry->revision == dev->revision)
++ return entry;
++ }
++
++ return NULL;
++}
++
++static int renesas_fw_download_image(struct pci_dev *dev,
++ const u32 *fw,
++ size_t step)
++{
++ size_t i;
++ int err;
++ u8 fw_status;
++ bool data0_or_data1;
++
++ /*
++ * The hardware does alternate between two 32-bit pages.
++ * (This is because each row of the firmware is 8 bytes).
++ *
++ * for even steps we use DATA0, for odd steps DATA1.
++ */
++ data0_or_data1 = (step & 1) == 1;
++
++ /* step+1. Read "Set DATAX" and confirm it is cleared. */
++ for (i = 0; i < RENESAS_RETRY; i++) {
++ err = pci_read_config_byte(dev, RENESAS_FW_STATUS_MSB,
++ &fw_status);
++ if (err)
++ return pcibios_err_to_errno(err);
++ if (!(fw_status & BIT(data0_or_data1)))
++ break;
++
++ udelay(RENESAS_DELAY);
++ }
++ if (i == RENESAS_RETRY)
++ return -ETIMEDOUT;
++
++ /*
++ * step+2. Write FW data to "DATAX".
++ * "LSB is left" => force little endian
++ */
++ err = pci_write_config_dword(dev, data0_or_data1 ?
++ RENESAS_DATA1 : RENESAS_DATA0,
++ (__force u32)cpu_to_le32(fw[step]));
++ if (err)
++ return pcibios_err_to_errno(err);
++
++ udelay(100);
++
++ /* step+3. Set "Set DATAX". */
++ err = pci_write_config_byte(dev, RENESAS_FW_STATUS_MSB,
++ BIT(data0_or_data1));
++ if (err)
++ return pcibios_err_to_errno(err);
++
++ return 0;
++}
++
++static int renesas_fw_verify(struct pci_dev *dev,
++ const void *fw_data,
++ size_t length)
++{
++ const struct renesas_fw_entry *entry = renesas_needs_fw_dl(dev);
++ u16 fw_version_pointer;
++ u16 fw_version;
++
++ if (!entry)
++ return -EINVAL;
++
++ /*
++ * The Firmware's Data Format is describe in
++ * "6.3 Data Format" R19UH0078EJ0500 Rev.5.00 page 124
++ */
++
++ /*
++ * The bootrom chips of the big brother have sizes up to 64k, let's
++ * assume that's the biggest the firmware can get.
++ */
++ if (length < 0x1000 || length >= 0x10000) {
++ dev_err(&dev->dev, "firmware is size %zd is not (4k - 64k).",
++ length);
++ return -EINVAL;
++ }
++
++ /* The First 2 bytes are fixed value (55aa). "LSB on Left" */
++ if (get_unaligned_le16(fw_data) != 0x55aa) {
++ dev_err(&dev->dev, "no valid firmware header found.");
++ return -EINVAL;
++ }
++
++ /* verify the firmware version position and print it. */
++ fw_version_pointer = get_unaligned_le16(fw_data + 4);
++ if (fw_version_pointer + 2 >= length) {
++ dev_err(&dev->dev,
++ "firmware version pointer is outside of the firmware image.");
++ return -EINVAL;
++ }
++
++ fw_version = get_unaligned_le16(fw_data + fw_version_pointer);
++ dev_dbg(&dev->dev, "got firmware version: %02x.", fw_version);
++
++ if (fw_version != entry->expected_version) {
++ dev_err(&dev->dev,
++ "firmware version mismatch, expected version: %02x.",
++ entry->expected_version);
++ return -EINVAL;
++ }
++
++ return 0;
++}
++
++static int renesas_fw_check_running(struct pci_dev *pdev)
++{
++ int err;
++ u8 fw_state;
++
++ /*
++ * Test if the device is actually needing the firmware. As most
++ * BIOSes will initialize the device for us. If the device is
++ * initialized.
++ */
++ err = pci_read_config_byte(pdev, RENESAS_FW_STATUS, &fw_state);
++ if (err)
++ return pcibios_err_to_errno(err);
++
++ /*
++ * Check if "FW Download Lock" is locked. If it is and the FW is
++ * ready we can simply continue. If the FW is not ready, we have
++ * to give up.
++ */
++ if (fw_state & RENESAS_FW_STATUS_LOCK) {
++ dev_dbg(&pdev->dev, "FW Download Lock is engaged.");
++
++ if (fw_state & RENESAS_FW_STATUS_SUCCESS)
++ return 0;
++
++ dev_err(&pdev->dev,
++ "FW Download Lock is set and FW is not ready. Giving Up.");
++ return -EIO;
++ }
++
++ /*
++ * Check if "FW Download Enable" is set. If someone (us?) tampered
++ * with it and it can't be resetted, we have to give up too... and
++ * ask for a forgiveness and a reboot.
++ */
++ if (fw_state & RENESAS_FW_STATUS_DOWNLOAD_ENABLE) {
++ dev_err(&pdev->dev,
++ "FW Download Enable is stale. Giving Up (poweroff/reboot needed).");
++ return -EIO;
++ }
++
++ /* Otherwise, Check the "Result Code" Bits (6:4) and act accordingly */
++ switch (fw_state & RENESAS_FW_STATUS_RESULT) {
++ case 0: /* No result yet */
++ dev_dbg(&pdev->dev, "FW is not ready/loaded yet.");
++
++ /* tell the caller, that this device needs the firmware. */
++ return 1;
++
++ case RENESAS_FW_STATUS_SUCCESS: /* Success, device should be working. */
++ dev_dbg(&pdev->dev, "FW is ready.");
++ return 0;
++
++ case RENESAS_FW_STATUS_ERROR: /* Error State */
++ dev_err(&pdev->dev,
++ "hardware is in an error state. Giving up (poweroff/reboot needed).");
++ return -ENODEV;
++
++ default: /* All other states are marked as "Reserved states" */
++ dev_err(&pdev->dev,
++ "hardware is in an invalid state %lx. Giving up (poweroff/reboot needed).",
++ (fw_state & RENESAS_FW_STATUS_RESULT) >> 4);
++ return -EINVAL;
++ }
++}
++
++static int renesas_fw_download(struct pci_dev *pdev,
++ const struct firmware *fw)
++{
++ const u32 *fw_data = (const u32 *)fw->data;
++ size_t i;
++ int err;
++ u8 fw_status;
++
++ /*
++ * For more information and the big picture: please look at the
++ * "Firmware Download Sequence" in "7.1 FW Download Interface"
++ * of R19UH0078EJ0500 Rev.5.00 page 131
++ */
++
++ /*
++ * 0. Set "FW Download Enable" bit in the
++ * "FW Download Control & Status Register" at 0xF4
++ */
++ err = pci_write_config_byte(pdev, RENESAS_FW_STATUS,
++ RENESAS_FW_STATUS_DOWNLOAD_ENABLE);
++ if (err)
++ return pcibios_err_to_errno(err);
++
++ /* 1 - 10 follow one step after the other. */
++ for (i = 0; i < fw->size / 4; i++) {
++ err = renesas_fw_download_image(pdev, fw_data, i);
++ if (err) {
++ dev_err(&pdev->dev,
++ "Firmware Download Step %zd failed at position %zd bytes with (%d).",
++ i, i * 4, err);
++ return err;
++ }
++ }
++
++ /*
++ * This sequence continues until the last data is written to
++ * "DATA0" or "DATA1". Naturally, we wait until "SET DATA0/1"
++ * is cleared by the hardware beforehand.
++ */
++ for (i = 0; i < RENESAS_RETRY; i++) {
++ err = pci_read_config_byte(pdev, RENESAS_FW_STATUS_MSB,
++ &fw_status);
++ if (err)
++ return pcibios_err_to_errno(err);
++ if (!(fw_status & (BIT(0) | BIT(1))))
++ break;
++
++ udelay(RENESAS_DELAY);
++ }
++ if (i == RENESAS_RETRY)
++ dev_warn(&pdev->dev, "Final Firmware Download step timed out.");
++
++ /*
++ * 11. After finishing writing the last data of FW, the
++ * System Software must clear "FW Download Enable"
++ */
++ err = pci_write_config_byte(pdev, RENESAS_FW_STATUS, 0);
++ if (err)
++ return pcibios_err_to_errno(err);
++
++ /* 12. Read "Result Code" and confirm it is good. */
++ for (i = 0; i < RENESAS_RETRY; i++) {
++ err = pci_read_config_byte(pdev, RENESAS_FW_STATUS, &fw_status);
++ if (err)
++ return pcibios_err_to_errno(err);
++ if (fw_status & RENESAS_FW_STATUS_SUCCESS)
++ break;
++
++ udelay(RENESAS_DELAY);
++ }
++ if (i == RENESAS_RETRY) {
++ /* Timed out / Error - let's see if we can fix this */
++ err = renesas_fw_check_running(pdev);
++ switch (err) {
++ case 0: /*
++ * we shouldn't end up here.
++ * maybe it took a little bit longer.
++ * But all should be well?
++ */
++ break;
++
++ case 1: /* (No result yet! */
++ return -ETIMEDOUT;
++
++ default:
++ return err;
++ }
++ }
++ /*
++ * Optional last step: Engage Firmware Lock
++ *
++ * err = pci_write_config_byte(pdev, 0xF4, BIT(2));
++ * if (err)
++ * return pcibios_err_to_errno(err);
++ */
++
++ return 0;
++}
++
++struct renesas_fw_ctx {
++ struct pci_dev *pdev;
++ const struct pci_device_id *id;
++ bool resume;
++ const struct renesas_fw_entry *entry;
++};
++
++static void renesas_fw_callback(const struct firmware *fw,
++ void *context)
++{
++ struct renesas_fw_ctx *ctx = context;
++ struct pci_dev *pdev = ctx->pdev;
++ struct device *parent = pdev->dev.parent;
++ int err;
++
++ if (!fw) {
++ dev_err(&pdev->dev, "firmware failed to load\n");
++
++ goto cleanup;
++ }
++
++ err = renesas_fw_verify(pdev, fw->data, fw->size);
++ if (err)
++ goto cleanup;
++
++ err = renesas_fw_download(pdev, fw);
++ release_firmware(fw);
++ if (err) {
++ dev_err(&pdev->dev, "firmware failed to download (%d).", err);
++ goto cleanup;
++ }
++
++ if (ctx->resume)
++ return;
++
++ err = xhci_pci_probe(pdev, ctx->id);
++ if (!err) {
++ /* everything worked */
++ devm_kfree(&pdev->dev, ctx);
++ return;
++ }
++
++cleanup:
++ /* in case of an error - fall through */
++ dev_info(&pdev->dev, "Unloading driver");
++
++ if (parent)
++ device_lock(parent);
++
++ device_release_driver(&pdev->dev);
++
++ if (parent)
++ device_unlock(parent);
++
++ pci_dev_put(pdev);
++}
++
++static int renesas_fw_alive_check(struct pci_dev *pdev)
++{
++ const struct renesas_fw_entry *entry;
++
++ /* check if we have a eligible RENESAS' uPD720201/2 w/o FW. */
++ entry = renesas_needs_fw_dl(pdev);
++ if (!entry)
++ return 0;
++
++ return renesas_fw_check_running(pdev);
++}
++
++static int renesas_fw_download_to_hw(struct pci_dev *pdev,
++ const struct pci_device_id *id,
++ bool do_resume)
++{
++ const struct renesas_fw_entry *entry;
++ struct renesas_fw_ctx *ctx;
++ int err;
++
++ /* check if we have a eligible RENESAS' uPD720201/2 w/o FW. */
++ entry = renesas_needs_fw_dl(pdev);
++ if (!entry)
++ return 0;
++
++ err = renesas_fw_check_running(pdev);
++ /* Continue ahead, if the firmware is already running. */
++ if (err == 0)
++ return 0;
++
++ if (err != 1)
++ return err;
++
++ ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
++ if (!ctx)
++ return -ENOMEM;
++ ctx->pdev = pdev;
++ ctx->resume = do_resume;
++ ctx->id = id;
++ ctx->entry = entry;
++
++ pci_dev_get(pdev);
++ err = request_firmware_nowait(THIS_MODULE, 1, entry->firmware_name,
++ &pdev->dev, GFP_KERNEL,
++ ctx, renesas_fw_callback);
++ if (err) {
++ pci_dev_put(pdev);
++ return err;
++ }
++
++ /*
++ * The renesas_fw_callback() callback will continue the probe
++ * process, once it aquires the firmware.
++ */
++ return 1;
++}
++
++static int renesas_xhci_pci_probe(struct pci_dev *dev,
++ const struct pci_device_id *id)
++{
++ int retval;
++
++ /*
++ * Check if this device is a RENESAS uPD720201/2 device.
++ * Otherwise, we can continue with xhci_pci_probe as usual.
++ */
++ retval = renesas_fw_download_to_hw(dev, id, false);
++ switch (retval) {
++ case 0:
++ break;
++
++ case 1: /* let it load the firmware and recontinue the probe. */
++ return 0;
++
++ default:
++ return retval;
++ };
++
++ return xhci_pci_probe(dev, id);
++}
++
++static void renesas_xhci_pci_remove(struct pci_dev *dev)
++{
++ if (renesas_fw_alive_check(dev)) {
++ /*
++ * bail out early, if this was a renesas device w/o FW.
++ * Else we might hit the NMI watchdog in xhci_handsake
++ * during xhci_reset as part of the driver's unloading.
++ * which we forced in the renesas_fw_callback().
++ */
++ return;
++ }
++
++ xhci_pci_remove(dev);
++}
++
++static const struct pci_device_id pci_ids[] = {
++ { PCI_DEVICE(0x1912, 0x0014),
++ .driver_data = (unsigned long)&xhci_pci_hc_driver,
++ },
++ { PCI_DEVICE(0x1912, 0x0015),
++ .driver_data = (unsigned long)&xhci_pci_hc_driver,
++ },
++ { /* sentinal */ }
++};
++MODULE_DEVICE_TABLE(pci, pci_ids);
++
++static struct pci_driver renesas_xhci_pci_driver = {
++ .name = "renesas xhci",
++ .id_table = pci_ids,
++
++ .probe = renesas_xhci_pci_probe,
++ .remove = renesas_xhci_pci_remove,
++ /* suspend and resume implemented later */
++
++ .shutdown = usb_hcd_pci_shutdown,
++#ifdef CONFIG_PM
++ .driver = {
++ .pm = &usb_hcd_pci_pm_ops
++ },
++#endif
++};
++
++static int __init xhci_pci_init(void)
++{
++ xhci_init_driver(&xhci_pci_hc_driver, &xhci_pci_overrides);
++#ifdef CONFIG_PM
++ xhci_pci_hc_driver.pci_suspend = xhci_pci_suspend;
++ xhci_pci_hc_driver.pci_resume = xhci_pci_resume;
++#endif
++ return pci_register_driver(&renesas_xhci_pci_driver);
++}
++module_init(xhci_pci_init);
++
++static void __exit xhci_pci_exit(void)
++{
++ pci_unregister_driver(&renesas_xhci_pci_driver);
++}
++module_exit(xhci_pci_exit);
++
++MODULE_DESCRIPTION("xHCI PCI Host Controller Driver");
++MODULE_LICENSE("GPL");
--- /dev/null
+From f2abef3e6b43da99351372f2e1a4c6073a0bdfcf Mon Sep 17 00:00:00 2001
+From: Vinod Koul <vkoul@kernel.org>
+Date: Mon, 13 Jan 2020 14:10:03 +0530
+Subject: [PATCH 102/104] usb: renesas-xhci: Add ROM loader for uPD720201
+
+uPD720201 supports ROM and allows software to program the ROM and boot
+from it. Add support for detecting if ROM is present, if so load the ROM
+if not programmed earlier.
+
+Signed-off-by: Vinod Koul <vkoul@kernel.org>
+Cc: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
+Cc: Christian Lamparter <chunkeey@googlemail.com>
+Signed-off-by: Christian Lamparter <chunkeey@gmail.com> [5.4 backport]
+---
+ drivers/usb/host/xhci-pci-renesas.c | 352 ++++++++++++++++++++++++++++
+ 1 file changed, 352 insertions(+)
+
+--- a/drivers/usb/host/xhci-pci-renesas.c
++++ b/drivers/usb/host/xhci-pci-renesas.c
+@@ -33,6 +33,20 @@
+ #define RENESAS_FW_STATUS_SET_DATA0 BIT(8)
+ #define RENESAS_FW_STATUS_SET_DATA1 BIT(9)
+
++#define RENESAS_ROM_STATUS_ACCESS BIT(0)
++#define RENESAS_ROM_STATUS_ERASE BIT(1)
++#define RENESAS_ROM_STATUS_RELOAD BIT(2)
++#define RENESAS_ROM_STATUS_RESULT GENMASK(6, 4)
++ #define RENESAS_ROM_STATUS_INVALID 0
++ #define RENESAS_ROM_STATUS_SUCCESS BIT(4)
++ #define RENESAS_ROM_STATUS_ERROR BIT(5)
++#define RENESAS_ROM_STATUS_SET_DATA0 BIT(8)
++#define RENESAS_ROM_STATUS_SET_DATA1 BIT(9)
++#define RENESAS_ROM_STATUS_ROM_EXISTS BIT(15)
++
++#define RENESAS_ROM_ERASE_MAGIC 0x5A65726F
++#define RENESAS_ROM_WRITE_MAGIC 0x53524F4D
++
+ #define RENESAS_RETRY 10000
+ #define RENESAS_DELAY 10
+
+@@ -190,12 +204,81 @@ static int renesas_fw_verify(struct pci_
+
+ return 0;
+ }
++static int renesas_check_rom_state(struct pci_dev *pdev)
++{
++ const struct renesas_fw_entry *entry;
++ u16 rom_state;
++ u32 version;
++ bool valid_version = false;
++ int err, i;
++
++ /* check FW version */
++ err = pci_read_config_dword(pdev, RENESAS_FW_VERSION, &version);
++ if (err)
++ return pcibios_err_to_errno(err);
++
++ version &= RENESAS_FW_VERSION_FIELD;
++ version = version >> RENESAS_FW_VERSION_OFFSET;
++ dev_dbg(&pdev->dev, "Found FW version loaded is %x\n", version);
++
++ /* treat version in renesas_fw_table as correct ones */
++ for (i = 0; i < ARRAY_SIZE(renesas_fw_table); i++) {
++ entry = &renesas_fw_table[i];
++ if (version == entry->expected_version) {
++ dev_dbg(&pdev->dev, "Detected valid ROM version..\n");
++ valid_version = true;
++ }
++ }
++ if (valid_version == false)
++ dev_dbg(&pdev->dev, "Didn't find valid ROM version\n");
++
++ /*
++ * Test if ROM is present and loaded, if so we can skip everything
++ */
++ err = pci_read_config_word(pdev, RENESAS_ROM_STATUS, &rom_state);
++ if (err)
++ return pcibios_err_to_errno(err);
++
++ if (rom_state & BIT(15)) {
++ /* ROM exists */
++ dev_dbg(&pdev->dev, "ROM exists\n");
++
++ /* Check the "Result Code" Bits (6:4) and act accordingly */
++ switch (rom_state & RENESAS_ROM_STATUS_RESULT) {
++ case RENESAS_ROM_STATUS_SUCCESS:
++ dev_dbg(&pdev->dev, "Success ROM load...");
++ /* we have valid version and status so success */
++ if (valid_version)
++ return 0;
++ break;
++
++ case RENESAS_ROM_STATUS_INVALID: /* No result yet */
++ dev_dbg(&pdev->dev, "No result as it is ROM...");
++ /* we have valid version and status so success */
++ if (valid_version)
++ return 0;
++ break;
++
++ case RENESAS_ROM_STATUS_ERROR: /* Error State */
++ default: /* All other states are marked as "Reserved states" */
++ dev_err(&pdev->dev, "Invalid ROM..");
++ break;
++ }
++ }
++
++ return -EIO;
++}
+
+ static int renesas_fw_check_running(struct pci_dev *pdev)
+ {
+ int err;
+ u8 fw_state;
+
++ /* Check if device has ROM and loaded, if so skip everything */
++ err = renesas_check_rom_state(pdev);
++ if (!err)
++ return err;
++
+ /*
+ * Test if the device is actually needing the firmware. As most
+ * BIOSes will initialize the device for us. If the device is
+@@ -363,12 +446,261 @@ struct renesas_fw_ctx {
+ const struct renesas_fw_entry *entry;
+ };
+
++static bool renesas_check_rom(struct pci_dev *pdev)
++{
++ u16 rom_status;
++ int retval;
++
++ /* 1. Check if external ROM exists */
++ retval = pci_read_config_word(pdev, RENESAS_ROM_STATUS, &rom_status);
++ if (retval)
++ return false;
++
++ rom_status &= RENESAS_ROM_STATUS_ROM_EXISTS;
++ if (rom_status) {
++ dev_dbg(&pdev->dev, "External ROM exists\n");
++ return true; /* External ROM exists */
++ }
++
++ return false;
++}
++
++static void renesas_rom_erase(struct pci_dev *pdev)
++{
++ int retval, i;
++ u8 status;
++
++ dev_dbg(&pdev->dev, "Performing ROM Erase...\n");
++ retval = pci_write_config_dword(pdev, RENESAS_DATA0,
++ RENESAS_ROM_ERASE_MAGIC);
++ if (retval) {
++ dev_err(&pdev->dev, "ROM erase, magic word write failed: %d\n",
++ pcibios_err_to_errno(retval));
++ return;
++ }
++
++ retval = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
++ if (retval) {
++ dev_err(&pdev->dev, "ROM status read failed: %d\n",
++ pcibios_err_to_errno(retval));
++ return;
++ }
++ status |= RENESAS_ROM_STATUS_ERASE;
++ retval = pci_write_config_byte(pdev, RENESAS_ROM_STATUS, status);
++ if (retval) {
++ dev_err(&pdev->dev, "ROM erase set word write failed\n");
++ return;
++ }
++
++ /* sleep a bit while ROM is erased */
++ msleep(20);
++
++ for (i = 0; i < RENESAS_RETRY; i++) {
++ retval = pci_read_config_byte(pdev, RENESAS_ROM_STATUS,
++ &status);
++ status &= RENESAS_ROM_STATUS_ERASE;
++ if (!status)
++ break;
++
++ mdelay(RENESAS_DELAY);
++ }
++
++ if (i == RENESAS_RETRY)
++ dev_dbg(&pdev->dev, "Chip erase timedout: %x\n", status);
++
++ dev_dbg(&pdev->dev, "ROM Erase... Done success\n");
++}
++
++static bool renesas_download_rom(struct pci_dev *pdev,
++ const u32 *fw, size_t step)
++{
++ bool data0_or_data1;
++ u8 fw_status;
++ size_t i;
++ int err;
++
++ /*
++ * The hardware does alternate between two 32-bit pages.
++ * (This is because each row of the firmware is 8 bytes).
++ *
++ * for even steps we use DATA0, for odd steps DATA1.
++ */
++ data0_or_data1 = (step & 1) == 1;
++
++ /* Read "Set DATAX" and confirm it is cleared. */
++ for (i = 0; i < RENESAS_RETRY; i++) {
++ err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS_MSB,
++ &fw_status);
++ if (err) {
++ dev_err(&pdev->dev, "Read ROM Status failed: %d\n",
++ pcibios_err_to_errno(err));
++ return false;
++ }
++ if (!(fw_status & BIT(data0_or_data1)))
++ break;
++
++ udelay(RENESAS_DELAY);
++ }
++ if (i == RENESAS_RETRY) {
++ dev_err(&pdev->dev, "Timeout for Set DATAX step: %zd\n", step);
++ return false;
++ }
++
++ /*
++ * Write FW data to "DATAX".
++ * "LSB is left" => force little endian
++ */
++ err = pci_write_config_dword(pdev, data0_or_data1 ?
++ RENESAS_DATA1 : RENESAS_DATA0,
++ (__force u32)cpu_to_le32(fw[step]));
++ if (err) {
++ dev_err(&pdev->dev, "Write to DATAX failed: %d\n",
++ pcibios_err_to_errno(err));
++ return false;
++ }
++
++ udelay(100);
++
++ /* Set "Set DATAX". */
++ err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS_MSB,
++ BIT(data0_or_data1));
++ if (err) {
++ dev_err(&pdev->dev, "Write config for DATAX failed: %d\n",
++ pcibios_err_to_errno(err));
++ return false;
++ }
++
++ return true;
++}
++
++static bool renesas_setup_rom(struct pci_dev *pdev, const struct firmware *fw)
++{
++ const u32 *fw_data = (const u32 *)fw->data;
++ int err, i;
++ u8 status;
++
++ /* 2. Write magic word to Data0 */
++ err = pci_write_config_dword(pdev, RENESAS_DATA0,
++ RENESAS_ROM_WRITE_MAGIC);
++ if (err)
++ return false;
++
++ /* 3. Set External ROM access */
++ err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS,
++ RENESAS_ROM_STATUS_ACCESS);
++ if (err)
++ goto remove_bypass;
++
++ /* 4. Check the result */
++ err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
++ if (err)
++ goto remove_bypass;
++ status &= GENMASK(6, 4);
++ if (status) {
++ dev_err(&pdev->dev,
++ "setting external rom failed: %x\n", status);
++ goto remove_bypass;
++ }
++
++ /* 5 to 16 Write FW to DATA0/1 while checking SetData0/1 */
++ for (i = 0; i < fw->size / 4; i++) {
++ err = renesas_download_rom(pdev, fw_data, i);
++ if (!err) {
++ dev_err(&pdev->dev,
++ "ROM Download Step %d failed at position %d bytes\n",
++ i, i * 4);
++ goto remove_bypass;
++ }
++ }
++
++ /*
++ * wait till DATA0/1 is cleared
++ */
++ for (i = 0; i < RENESAS_RETRY; i++) {
++ err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS_MSB,
++ &status);
++ if (err)
++ goto remove_bypass;
++ if (!(status & (BIT(0) | BIT(1))))
++ break;
++
++ udelay(RENESAS_DELAY);
++ }
++ if (i == RENESAS_RETRY) {
++ dev_err(&pdev->dev, "Final Firmware ROM Download step timed out\n");
++ goto remove_bypass;
++ }
++
++ /* 17. Remove bypass */
++ err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS, 0);
++ if (err)
++ return false;
++
++ udelay(10);
++
++ /* 18. check result */
++ for (i = 0; i < RENESAS_RETRY; i++) {
++ err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
++ if (err) {
++ dev_err(&pdev->dev, "Read ROM status failed:%d\n",
++ pcibios_err_to_errno(err));
++ return false;
++ }
++ status &= RENESAS_ROM_STATUS_RESULT;
++ if (status == RENESAS_ROM_STATUS_SUCCESS) {
++ dev_dbg(&pdev->dev, "Download ROM success\n");
++ break;
++ }
++ udelay(RENESAS_DELAY);
++ }
++ if (i == RENESAS_RETRY) { /* Timed out */
++ dev_err(&pdev->dev,
++ "Download to external ROM TO: %x\n", status);
++ return false;
++ }
++
++ dev_dbg(&pdev->dev, "Download to external ROM scuceeded\n");
++
++ /* Last step set Reload */
++ err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS,
++ RENESAS_ROM_STATUS_RELOAD);
++ if (err) {
++ dev_err(&pdev->dev, "Set ROM execute failed: %d\n",
++ pcibios_err_to_errno(err));
++ return false;
++ }
++
++ /*
++ * wait till Reload is cleared
++ */
++ for (i = 0; i < RENESAS_RETRY; i++) {
++ err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
++ if (err)
++ return false;
++ if (!(status & RENESAS_ROM_STATUS_RELOAD))
++ break;
++
++ udelay(RENESAS_DELAY);
++ }
++ if (i == RENESAS_RETRY) {
++ dev_err(&pdev->dev, "ROM Exec timed out: %x\n", status);
++ return false;
++ }
++
++ return true;
++
++remove_bypass:
++ pci_write_config_byte(pdev, RENESAS_ROM_STATUS, 0);
++ return false;
++}
++
+ static void renesas_fw_callback(const struct firmware *fw,
+ void *context)
+ {
+ struct renesas_fw_ctx *ctx = context;
+ struct pci_dev *pdev = ctx->pdev;
+ struct device *parent = pdev->dev.parent;
++ bool rom;
+ int err;
+
+ if (!fw) {
+@@ -381,6 +713,25 @@ static void renesas_fw_callback(const st
+ if (err)
+ goto cleanup;
+
++ /* Check if the device has external ROM */
++ rom = renesas_check_rom(pdev);
++ if (rom) {
++ /* perfrom chip erase first */
++ renesas_rom_erase(pdev);
++
++ /* lets try loading fw on ROM first */
++ rom = renesas_setup_rom(pdev, fw);
++ if (!rom) {
++ dev_err(&pdev->dev,
++ "ROM load failed, falling back on FW load\n");
++ } else {
++ dev_dbg(&pdev->dev, "ROM load done..\n");
++
++ release_firmware(fw);
++ goto do_probe;
++ }
++ }
++
+ err = renesas_fw_download(pdev, fw);
+ release_firmware(fw);
+ if (err) {
+@@ -388,6 +739,7 @@ static void renesas_fw_callback(const st
+ goto cleanup;
+ }
+
++do_probe:
+ if (ctx->resume)
+ return;
+
--- /dev/null
+From 9c57fab28892fdb73c12b4a066318676d2e73ff0 Mon Sep 17 00:00:00 2001
+From: Vinod Koul <vkoul@kernel.org>
+Date: Mon, 13 Jan 2020 14:10:04 +0530
+Subject: [PATCH 103/104] usb: renesas-xhci: allow multiple firmware versions
+
+Allow multiple firmware file versions in table and load them in
+increasing order as we find them in the file system.
+
+Signed-off-by: Vinod Koul <vkoul@kernel.org>
+Cc: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
+Cc: Christian Lamparter <chunkeey@googlemail.com>
+Signed-off-by: Christian Lamparter <chunkeey@gmail.com> [5.4 backport]
+---
+ drivers/usb/host/xhci-pci-renesas.c | 45 +++++++++++++++++++++++++++--
+ 1 file changed, 43 insertions(+), 2 deletions(-)
+
+--- a/drivers/usb/host/xhci-pci-renesas.c
++++ b/drivers/usb/host/xhci-pci-renesas.c
+@@ -73,13 +73,20 @@ static const struct renesas_fw_entry {
+ * - uPD720201 ES 2.0 sample whose revision ID is 2.
+ * - uPD720201 ES 2.1 sample & CS sample & Mass product, ID is 3.
+ * - uPD720202 ES 2.0 sample & CS sample & Mass product, ID is 2.
++ *
++ * Entry expected_version should be kept in decreasing order for a
++ * chip, so that driver will pick latest version and if that fails
++ * then next one will be picked
+ */
+ { "K2013080.mem", 0x0014, 0x02, 0x2013 },
++ { "K2026090.mem", 0x0014, 0x03, 0x2026 },
+ { "K2013080.mem", 0x0014, 0x03, 0x2013 },
++ { "K2026090.mem", 0x0015, 0x02, 0x2026 },
+ { "K2013080.mem", 0x0015, 0x02, 0x2013 },
+ };
+
+ MODULE_FIRMWARE("K2013080.mem");
++MODULE_FIRMWARE("K2026090.mem");
+
+ static const struct renesas_fw_entry *renesas_needs_fw_dl(struct pci_dev *dev)
+ {
+@@ -100,6 +107,24 @@ static const struct renesas_fw_entry *re
+ return NULL;
+ }
+
++static const struct
++renesas_fw_entry *renesas_get_next_entry(struct pci_dev *dev,
++ const struct renesas_fw_entry *entry)
++{
++ const struct renesas_fw_entry *next_entry;
++ size_t i;
++
++ for (i = 0; i < ARRAY_SIZE(renesas_fw_table); i++) {
++ next_entry = &renesas_fw_table[i];
++ if (next_entry->device == dev->device &&
++ next_entry->revision == dev->revision &&
++ next_entry->expected_version < entry->expected_version)
++ return next_entry;
++ }
++
++ return NULL;
++}
++
+ static int renesas_fw_download_image(struct pci_dev *dev,
+ const u32 *fw,
+ size_t step)
+@@ -700,13 +725,29 @@ static void renesas_fw_callback(const st
+ struct renesas_fw_ctx *ctx = context;
+ struct pci_dev *pdev = ctx->pdev;
+ struct device *parent = pdev->dev.parent;
++ const struct renesas_fw_entry *next_entry;
+ bool rom;
+ int err;
+
+ if (!fw) {
+ dev_err(&pdev->dev, "firmware failed to load\n");
+-
+- goto cleanup;
++ /*
++ * we didn't find firmware, check if we have another
++ * entry for this device
++ */
++ next_entry = renesas_get_next_entry(ctx->pdev, ctx->entry);
++ if (next_entry) {
++ ctx->entry = next_entry;
++ dev_dbg(&pdev->dev, "Found next entry, requesting: %s\n",
++ next_entry->firmware_name);
++ request_firmware_nowait(THIS_MODULE, 1,
++ next_entry->firmware_name,
++ &pdev->dev, GFP_KERNEL,
++ ctx, renesas_fw_callback);
++ return;
++ } else {
++ goto cleanup;
++ }
+ }
+
+ err = renesas_fw_verify(pdev, fw->data, fw->size);
--- /dev/null
+From d6e220fb600a6b1f73155b541aa9826ec75d4559 Mon Sep 17 00:00:00 2001
+From: Vinod Koul <vkoul@kernel.org>
+Date: Mon, 13 Jan 2020 14:10:05 +0530
+Subject: [PATCH 104/104] usb: xhci: provide a debugfs hook for erasing rom
+
+run "echo 1 > /sys/kernel/debug/renesas-usb/rom_erase" to erase firmware
+when driver is loaded.
+
+Subsequent init of driver shall reload the firmware
+
+Signed-off-by: Vinod Koul <vkoul@kernel.org>
+Signed-off-by: Christian Lamparter <chunkeey@gmail.com> [5.4 backport]
+---
+ drivers/usb/host/xhci-pci-renesas.c | 35 +++++++++++++++++++++++++++++
+ 1 file changed, 35 insertions(+)
+
+--- a/drivers/usb/host/xhci-pci-renesas.c
++++ b/drivers/usb/host/xhci-pci-renesas.c
+@@ -2,6 +2,7 @@
+ /* Copyright (C) 2019-2020 Linaro Limited */
+
+ #include <linux/acpi.h>
++#include <linux/debugfs.h>
+ #include <linux/firmware.h>
+ #include <linux/module.h>
+ #include <linux/pci.h>
+@@ -229,6 +230,9 @@ static int renesas_fw_verify(struct pci_
+
+ return 0;
+ }
++
++static void debugfs_init(struct pci_dev *pdev);
++
+ static int renesas_check_rom_state(struct pci_dev *pdev)
+ {
+ const struct renesas_fw_entry *entry;
+@@ -252,6 +256,7 @@ static int renesas_check_rom_state(struc
+ if (version == entry->expected_version) {
+ dev_dbg(&pdev->dev, "Detected valid ROM version..\n");
+ valid_version = true;
++ debugfs_init(pdev);
+ }
+ }
+ if (valid_version == false)
+@@ -536,6 +541,34 @@ static void renesas_rom_erase(struct pci
+ dev_dbg(&pdev->dev, "ROM Erase... Done success\n");
+ }
+
++static int debugfs_rom_erase(void *data, u64 value)
++{
++ struct pci_dev *pdev = data;
++
++ if (value == 1) {
++ dev_dbg(&pdev->dev, "Userspace requested ROM erase\n");
++ renesas_rom_erase(pdev);
++ return 0;
++ }
++ return -EINVAL;
++}
++DEFINE_DEBUGFS_ATTRIBUTE(rom_erase_ops, NULL, debugfs_rom_erase, "%llu\n");
++
++static struct dentry *debugfs_root;
++
++static void debugfs_init(struct pci_dev *pdev)
++{
++ debugfs_root = debugfs_create_dir("renesas-usb", NULL);
++
++ debugfs_create_file("rom_erase", 0200, debugfs_root,
++ pdev, &rom_erase_ops);
++}
++
++static void debugfs_exit(void)
++{
++ debugfs_remove_recursive(debugfs_root);
++}
++
+ static bool renesas_download_rom(struct pci_dev *pdev,
+ const u32 *fw, size_t step)
+ {
+@@ -889,6 +922,8 @@ static int renesas_xhci_pci_probe(struct
+
+ static void renesas_xhci_pci_remove(struct pci_dev *dev)
+ {
++ debugfs_exit();
++
+ if (renesas_fw_alive_check(dev)) {
+ /*
+ * bail out early, if this was a renesas device w/o FW.
+++ /dev/null
-Subject: [PATCH v2 1/5] usb: xhci: add firmware loader for uPD720201 and uPD720202 w/o ROM
-Date: Fri, 21 Jun 2019 14:29:09 +0530
-Message-Id: <20190621085913.8722-2-vkoul@kernel.org>
-From: Christian Lamparter <chunkeey@googlemail.com>
-
-This patch adds a firmware loader for the uPD720201K8-711-BAC-A
-and uPD720202K8-711-BAA-A variant. Both of these chips are listed
-in Renesas' R19UH0078EJ0500 Rev.5.00 "User's Manual: Hardware" as
-devices which need the firmware loader on page 2 in order to
-work as they "do not support the External ROM".
-
-The "Firmware Download Sequence" is describe in chapter
-"7.1 FW Download Interface" R19UH0078EJ0500 Rev.5.00 page 131.
-
-The firmware "K2013080.mem" is available from a USB3.0 Host to
-PCIe Adapter (PP2U-E card) "Firmware download" archive. An
-alternative version can be sourced from Netgear's WNDR4700 GPL
-archives.
-
-The release notes of the PP2U-E's "Firmware Download" ver 2.0.1.3
-(2012-06-15) state that the firmware is for the following devices:
- - uPD720201 ES 2.0 sample whose revision ID is 2.
- - uPD720201 ES 2.1 sample & CS sample & Mass product, ID is 3.
- - uPD720202 ES 2.0 sample & CS sample & Mass product, ID is 2.
-
-Cc: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
-Signed-off-by: Christian Lamparter <chunkeey@googlemail.com>
-Signed-off-by: Bjorn Andersson <bjorn.andersson@linaro.org>
-[vkoul: fixed comments:
- used macros for timeout count and delay
- removed renesas_fw_alive_check
- cleaned renesas_fw_callback
- removed recurion for renesas_fw_download
- added MODULE_FIRMWARE]
-Signed-off-by: Vinod Koul <vkoul@kernel.org>
----
- drivers/usb/host/xhci-pci.c | 458 ++++++++++++++++++++++++++++++++++++
- 1 file changed, 458 insertions(+)
-
---- a/drivers/usb/host/xhci-pci.c
-+++ b/drivers/usb/host/xhci-pci.c
-@@ -12,6 +12,8 @@
- #include <linux/slab.h>
- #include <linux/module.h>
- #include <linux/acpi.h>
-+#include <linux/firmware.h>
-+#include <linux/unaligned/access_ok.h>
-
- #include "xhci.h"
- #include "xhci-trace.h"
-@@ -57,6 +59,44 @@
- #define PCI_DEVICE_ID_AMD_PROMONTORYA_1 0x43bc
- #define PCI_DEVICE_ID_ASMEDIA_1042A_XHCI 0x1142
-
-+#define RENESAS_FW_VERSION 0x6C
-+#define RENESAS_ROM_CONFIG 0xF0
-+#define RENESAS_FW_STATUS 0xF4
-+#define RENESAS_FW_STATUS_MSB 0xF5
-+#define RENESAS_ROM_STATUS 0xF6
-+#define RENESAS_ROM_STATUS_MSB 0xF7
-+#define RENESAS_DATA0 0xF8
-+#define RENESAS_DATA1 0xFC
-+
-+#define RENESAS_FW_VERSION_FIELD GENMASK(23, 7)
-+#define RENESAS_FW_VERSION_OFFSET 8
-+
-+#define RENESAS_FW_STATUS_DOWNLOAD_ENABLE BIT(0)
-+#define RENESAS_FW_STATUS_LOCK BIT(1)
-+#define RENESAS_FW_STATUS_RESULT GENMASK(6, 4)
-+ #define RENESAS_FW_STATUS_INVALID 0
-+ #define RENESAS_FW_STATUS_SUCCESS BIT(4)
-+ #define RENESAS_FW_STATUS_ERROR BIT(5)
-+#define RENESAS_FW_STATUS_SET_DATA0 BIT(8)
-+#define RENESAS_FW_STATUS_SET_DATA1 BIT(9)
-+
-+#define RENESAS_ROM_STATUS_ACCESS BIT(0)
-+#define RENESAS_ROM_STATUS_ERASE BIT(1)
-+#define RENESAS_ROM_STATUS_RELOAD BIT(2)
-+#define RENESAS_ROM_STATUS_RESULT GENMASK(6, 4)
-+ #define RENESAS_ROM_STATUS_INVALID 0
-+ #define RENESAS_ROM_STATUS_SUCCESS BIT(4)
-+ #define RENESAS_ROM_STATUS_ERROR BIT(5)
-+#define RENESAS_ROM_STATUS_SET_DATA0 BIT(8)
-+#define RENESAS_ROM_STATUS_SET_DATA1 BIT(9)
-+#define RENESAS_ROM_STATUS_ROM_EXISTS BIT(15)
-+
-+#define RENESAS_ROM_ERASE_MAGIC 0x5A65726F
-+#define RENESAS_ROM_WRITE_MAGIC 0x53524F4D
-+
-+#define RENESAS_RETRY 1000
-+#define RENESAS_DELAY 10
-+
- static const char hcd_name[] = "xhci_hcd";
-
- static struct hc_driver __read_mostly xhci_pci_hc_driver;
-@@ -284,6 +324,873 @@ static void xhci_pme_acpi_rtd3_enable(st
- static void xhci_pme_acpi_rtd3_enable(struct pci_dev *dev) { }
- #endif /* CONFIG_ACPI */
-
-+static const struct renesas_fw_entry {
-+ const char *firmware_name;
-+ u16 device;
-+ u8 revision;
-+ u16 expected_version;
-+} renesas_fw_table[] = {
-+ /*
-+ * Only the uPD720201K8-711-BAC-A or uPD720202K8-711-BAA-A
-+ * are listed in R19UH0078EJ0500 Rev.5.00 as devices which
-+ * need the software loader.
-+ *
-+ * PP2U/ReleaseNote_USB3-201-202-FW.txt:
-+ *
-+ * Note: This firmware is for the following devices.
-+ * - uPD720201 ES 2.0 sample whose revision ID is 2.
-+ * - uPD720201 ES 2.1 sample & CS sample & Mass product, ID is 3.
-+ * - uPD720202 ES 2.0 sample & CS sample & Mass product, ID is 2.
-+ *
-+ * Entry expected_version should be kept in increasing order for a
-+ * chip, so that driver will pick first version and if that fails
-+ * then next one will be picked
-+ */
-+ { "K2013080.mem", 0x0014, 0x02, 0x2013 },
-+ { "K2013080.mem", 0x0014, 0x03, 0x2013 },
-+ { "K2026090.mem", 0x0014, 0x03, 0x2026 },
-+ { "K2013080.mem", 0x0015, 0x02, 0x2013 },
-+ { "K2026090.mem", 0x0015, 0x02, 0x2026 },
-+};
-+
-+MODULE_FIRMWARE("K2013080.mem");
-+MODULE_FIRMWARE("K2026090.mem");
-+
-+static const struct renesas_fw_entry *renesas_needs_fw_dl(struct pci_dev *dev)
-+{
-+ const struct renesas_fw_entry *entry;
-+ size_t i;
-+
-+ /* This loader will only work with a RENESAS device. */
-+ if (!(dev->vendor == PCI_VENDOR_ID_RENESAS))
-+ return NULL;
-+
-+ for (i = 0; i < ARRAY_SIZE(renesas_fw_table); i++) {
-+ entry = &renesas_fw_table[i];
-+ if (entry->device == dev->device &&
-+ entry->revision == dev->revision)
-+ return entry;
-+ }
-+
-+ return NULL;
-+}
-+
-+static const struct
-+renesas_fw_entry *renesas_get_next_entry(struct pci_dev *dev,
-+ const struct renesas_fw_entry *entry)
-+{
-+ const struct renesas_fw_entry *next_entry;
-+ size_t i;
-+
-+ for (i = 0; i < ARRAY_SIZE(renesas_fw_table); i++) {
-+ next_entry = &renesas_fw_table[i];
-+ if (next_entry->device == dev->device &&
-+ next_entry->revision == dev->revision &&
-+ next_entry->expected_version > entry->expected_version)
-+ return next_entry;
-+ }
-+
-+ return NULL;
-+}
-+
-+static int renesas_fw_download_image(struct pci_dev *dev,
-+ const u32 *fw,
-+ size_t step)
-+{
-+ size_t i;
-+ int err;
-+ u8 fw_status;
-+ bool data0_or_data1;
-+
-+ /*
-+ * The hardware does alternate between two 32-bit pages.
-+ * (This is because each row of the firmware is 8 bytes).
-+ *
-+ * for even steps we use DATA0, for odd steps DATA1.
-+ */
-+ data0_or_data1 = (step & 1) == 1;
-+
-+ /* step+1. Read "Set DATAX" and confirm it is cleared. */
-+ for (i = 0; i < RENESAS_RETRY; i++) {
-+ err = pci_read_config_byte(dev, RENESAS_FW_STATUS_MSB,
-+ &fw_status);
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+ if (!(fw_status & BIT(data0_or_data1)))
-+ break;
-+
-+ udelay(RENESAS_DELAY);
-+ }
-+ if (i == RENESAS_RETRY)
-+ return -ETIMEDOUT;
-+
-+ /*
-+ * step+2. Write FW data to "DATAX".
-+ * "LSB is left" => force little endian
-+ */
-+ err = pci_write_config_dword(dev, data0_or_data1 ?
-+ RENESAS_DATA1 : RENESAS_DATA0,
-+ (__force u32)cpu_to_le32(fw[step]));
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+
-+ udelay(100);
-+
-+ /* step+3. Set "Set DATAX". */
-+ err = pci_write_config_byte(dev, RENESAS_FW_STATUS_MSB,
-+ BIT(data0_or_data1));
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+
-+ return 0;
-+}
-+
-+static int renesas_fw_verify(struct pci_dev *dev,
-+ const void *fw_data,
-+ size_t length)
-+{
-+ const struct renesas_fw_entry *entry = renesas_needs_fw_dl(dev);
-+ u16 fw_version_pointer;
-+ u16 fw_version;
-+
-+ if (!entry)
-+ return -EINVAL;
-+
-+ /*
-+ * The Firmware's Data Format is describe in
-+ * "6.3 Data Format" R19UH0078EJ0500 Rev.5.00 page 124
-+ */
-+
-+ /* "Each row is 8 bytes". => firmware size must be a multiple of 8. */
-+ if (length % 8 != 0)
-+ dev_warn(&dev->dev, "firmware size is not a multiple of 8.");
-+
-+ /*
-+ * The bootrom chips of the big brother have sizes up to 64k, let's
-+ * assume that's the biggest the firmware can get.
-+ */
-+ if (length < 0x1000 || length >= 0x10000) {
-+ dev_err(&dev->dev, "firmware is size %zd is not (4k - 64k).",
-+ length);
-+ return -EINVAL;
-+ }
-+
-+ /* The First 2 bytes are fixed value (55aa). "LSB on Left" */
-+ if (get_unaligned_le16(fw_data) != 0x55aa) {
-+ dev_err(&dev->dev, "no valid firmware header found.");
-+ return -EINVAL;
-+ }
-+
-+ /* verify the firmware version position and print it. */
-+ fw_version_pointer = get_unaligned_le16(fw_data + 4);
-+ if (fw_version_pointer + 2 >= length) {
-+ dev_err(&dev->dev,
-+ "firmware version pointer is outside of the firmware image.");
-+ return -EINVAL;
-+ }
-+
-+ fw_version = get_unaligned_le16(fw_data + fw_version_pointer);
-+ dev_dbg(&dev->dev, "got firmware version: %02x.", fw_version);
-+
-+ if (fw_version != entry->expected_version) {
-+ dev_err(&dev->dev,
-+ "firmware version mismatch, expected version: %02x.",
-+ entry->expected_version);
-+ return -EINVAL;
-+ }
-+
-+ return 0;
-+}
-+
-+static int renesas_check_rom_state(struct pci_dev *pdev)
-+{
-+ const struct renesas_fw_entry *entry;
-+ u16 rom_state;
-+ u32 version;
-+ bool valid_version = false;
-+ int err, i;
-+
-+ /* check FW version */
-+ err = pci_read_config_dword(pdev, RENESAS_FW_VERSION, &version);
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+
-+ version &= RENESAS_FW_VERSION_FIELD;
-+ version = version >> RENESAS_FW_VERSION_OFFSET;
-+ dev_dbg(&pdev->dev, "Found FW version loaded is %x\n", version);
-+
-+ /* treat version in renesas_fw_table as correct ones */
-+ for (i = 0; i < ARRAY_SIZE(renesas_fw_table); i++) {
-+ entry = &renesas_fw_table[i];
-+ if (version == entry->expected_version) {
-+ dev_dbg(&pdev->dev, "Detected valid ROM version..\n");
-+ valid_version = true;
-+ }
-+ }
-+
-+ /*
-+ * Test if ROM is present and loaded, if so we can skip everything
-+ */
-+ err = pci_read_config_word(pdev, RENESAS_ROM_STATUS, &rom_state);
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+
-+ if (rom_state & BIT(15)) {
-+ /* ROM exists */
-+ dev_dbg(&pdev->dev, "ROM exists\n");
-+
-+ /* Check the "Result Code" Bits (6:4) and act accordingly */
-+ switch (rom_state & RENESAS_ROM_STATUS_RESULT) {
-+ case RENESAS_ROM_STATUS_SUCCESS:
-+ dev_dbg(&pdev->dev, "Success ROM load...");
-+ /* we have valid version and status so success */
-+ if (valid_version)
-+ return 0;
-+ break;
-+
-+ case RENESAS_ROM_STATUS_INVALID: /* No result yet */
-+ dev_dbg(&pdev->dev, "No result as it is ROM...");
-+ /* we have valid version and status so success */
-+ if (valid_version)
-+ return 0;
-+ break;
-+
-+ case RENESAS_ROM_STATUS_ERROR: /* Error State */
-+ default: /* All other states are marked as "Reserved states" */
-+ dev_err(&pdev->dev, "Invalid ROM..");
-+ break;
-+ }
-+ }
-+
-+ return -EIO;
-+}
-+
-+static int renesas_fw_check_running(struct pci_dev *pdev)
-+{
-+ int err;
-+ u8 fw_state;
-+
-+ /* Check if device has ROM and loaded, if so skip everything */
-+ err = renesas_check_rom_state(pdev);
-+ if (!err)
-+ return err;
-+
-+ /*
-+ * Test if the device is actually needing the firmware. As most
-+ * BIOSes will initialize the device for us. If the device is
-+ * initialized.
-+ */
-+ err = pci_read_config_byte(pdev, RENESAS_FW_STATUS, &fw_state);
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+
-+ /*
-+ * Check if "FW Download Lock" is locked. If it is and the FW is
-+ * ready we can simply continue. If the FW is not ready, we have
-+ * to give up.
-+ */
-+ if (fw_state & RENESAS_FW_STATUS_LOCK) {
-+ dev_dbg(&pdev->dev, "FW Download Lock is engaged.");
-+
-+ if (fw_state & RENESAS_FW_STATUS_SUCCESS)
-+ return 0;
-+
-+ dev_err(&pdev->dev,
-+ "FW Download Lock is set and FW is not ready. Giving Up.");
-+ return -EIO;
-+ }
-+
-+ /*
-+ * Check if "FW Download Enable" is set. If someone (us?) tampered
-+ * with it and it can't be resetted, we have to give up too... and
-+ * ask for a forgiveness and a reboot.
-+ */
-+ if (fw_state & RENESAS_FW_STATUS_DOWNLOAD_ENABLE) {
-+ dev_err(&pdev->dev,
-+ "FW Download Enable is stale. Giving Up (poweroff/reboot needed).");
-+ return -EIO;
-+ }
-+
-+ /* Otherwise, Check the "Result Code" Bits (6:4) and act accordingly */
-+ switch (fw_state & RENESAS_FW_STATUS_RESULT) {
-+ case 0: /* No result yet */
-+ dev_dbg(&pdev->dev, "FW is not ready/loaded yet.");
-+
-+ /* tell the caller, that this device needs the firmware. */
-+ return 1;
-+
-+ case RENESAS_FW_STATUS_SUCCESS: /* Success, device should be working. */
-+ dev_dbg(&pdev->dev, "FW is ready.");
-+ return 0;
-+
-+ case RENESAS_FW_STATUS_ERROR: /* Error State */
-+ dev_err(&pdev->dev,
-+ "hardware is in an error state. Giving up (poweroff/reboot needed).");
-+ return -ENODEV;
-+
-+ default: /* All other states are marked as "Reserved states" */
-+ dev_err(&pdev->dev,
-+ "hardware is in an invalid state %lx. Giving up (poweroff/reboot needed).",
-+ (fw_state & RENESAS_FW_STATUS_RESULT) >> 4);
-+ return -EINVAL;
-+ }
-+}
-+
-+static int renesas_fw_download(struct pci_dev *pdev,
-+ const struct firmware *fw)
-+{
-+ const u32 *fw_data = (const u32 *)fw->data;
-+ size_t i;
-+ int err;
-+ u8 fw_status;
-+
-+ /*
-+ * For more information and the big picture: please look at the
-+ * "Firmware Download Sequence" in "7.1 FW Download Interface"
-+ * of R19UH0078EJ0500 Rev.5.00 page 131
-+ */
-+
-+ /*
-+ * 0. Set "FW Download Enable" bit in the
-+ * "FW Download Control & Status Register" at 0xF4
-+ */
-+ err = pci_write_config_byte(pdev, RENESAS_FW_STATUS,
-+ RENESAS_FW_STATUS_DOWNLOAD_ENABLE);
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+
-+ /* 1 - 10 follow one step after the other. */
-+ for (i = 0; i < fw->size / 4; i++) {
-+ err = renesas_fw_download_image(pdev, fw_data, i);
-+ if (err) {
-+ dev_err(&pdev->dev,
-+ "Firmware Download Step %zd failed at position %zd bytes with (%d).",
-+ i, i * 4, err);
-+ return err;
-+ }
-+ }
-+
-+ /*
-+ * This sequence continues until the last data is written to
-+ * "DATA0" or "DATA1". Naturally, we wait until "SET DATA0/1"
-+ * is cleared by the hardware beforehand.
-+ */
-+ for (i = 0; i < RENESAS_RETRY; i++) {
-+ err = pci_read_config_byte(pdev, RENESAS_FW_STATUS_MSB,
-+ &fw_status);
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+ if (!(fw_status & (BIT(0) | BIT(1))))
-+ break;
-+
-+ udelay(RENESAS_DELAY);
-+ }
-+ if (i == RENESAS_RETRY)
-+ dev_warn(&pdev->dev, "Final Firmware Download step timed out.");
-+
-+ /*
-+ * 11. After finishing writing the last data of FW, the
-+ * System Software must clear "FW Download Enable"
-+ */
-+ err = pci_write_config_byte(pdev, RENESAS_FW_STATUS, 0);
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+
-+ /* 12. Read "Result Code" and confirm it is good. */
-+ for (i = 0; i < RENESAS_RETRY; i++) {
-+ err = pci_read_config_byte(pdev, RENESAS_FW_STATUS, &fw_status);
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+ if (fw_status & RENESAS_FW_STATUS_SUCCESS)
-+ break;
-+
-+ udelay(RENESAS_DELAY);
-+ }
-+ if (i == RENESAS_RETRY) {
-+ /* Timed out / Error - let's see if we can fix this */
-+ err = renesas_fw_check_running(pdev);
-+ switch (err) {
-+ case 0: /*
-+ * we shouldn't end up here.
-+ * maybe it took a little bit longer.
-+ * But all should be well?
-+ */
-+ break;
-+
-+ case 1: /* (No result yet! */
-+ return -ETIMEDOUT;
-+
-+ default:
-+ return err;
-+ }
-+ }
-+ /*
-+ * Optional last step: Engage Firmware Lock
-+ *
-+ * err = pci_write_config_byte(pdev, 0xF4, BIT(2));
-+ * if (err)
-+ * return pcibios_err_to_errno(err);
-+ */
-+
-+ return 0;
-+}
-+
-+struct renesas_fw_ctx {
-+ struct pci_dev *pdev;
-+ const struct pci_device_id *id;
-+ bool resume;
-+ const struct renesas_fw_entry *entry;
-+};
-+
-+static int xhci_pci_probe(struct pci_dev *pdev,
-+ const struct pci_device_id *id);
-+
-+static bool renesas_check_rom(struct pci_dev *pdev)
-+{
-+ u16 rom_status;
-+ int retval;
-+
-+ /* 1. Check if external ROM exists */
-+ retval = pci_read_config_word(pdev, RENESAS_ROM_STATUS, &rom_status);
-+ if (retval)
-+ return false;
-+
-+ rom_status &= RENESAS_ROM_STATUS_ROM_EXISTS;
-+ if (rom_status) {
-+ dev_dbg(&pdev->dev, "External ROM exists\n");
-+ return true; /* External ROM exists */
-+ }
-+
-+ return false;
-+}
-+
-+static void renesas_rom_erase(struct pci_dev *pdev)
-+{
-+ int retval, i;
-+ u8 status;
-+
-+ dev_dbg(&pdev->dev, "Performing ROM Erase...\n");
-+ retval = pci_write_config_dword(pdev, RENESAS_DATA0,
-+ RENESAS_ROM_ERASE_MAGIC);
-+ if (retval) {
-+ dev_err(&pdev->dev, "ROM erase, magic word write failed: %d\n",
-+ pcibios_err_to_errno(retval));
-+ return;
-+ }
-+
-+ retval = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
-+ if (retval) {
-+ dev_err(&pdev->dev, "ROM status read failed: %d\n",
-+ pcibios_err_to_errno(retval));
-+ return;
-+ }
-+ status |= RENESAS_ROM_STATUS_ERASE;
-+ retval = pci_write_config_byte(pdev, RENESAS_ROM_STATUS, status);
-+ if (retval) {
-+ dev_err(&pdev->dev, "ROM erase set word write failed\n");
-+ return;
-+ }
-+
-+ /* sleep a bit while ROM is erased */
-+ msleep(20);
-+
-+ for (i = 0; i < RENESAS_RETRY; i++) {
-+ retval = pci_read_config_byte(pdev, RENESAS_ROM_STATUS,
-+ &status);
-+ status &= RENESAS_ROM_STATUS_ERASE;
-+ if (!status)
-+ break;
-+
-+ mdelay(RENESAS_DELAY);
-+ }
-+
-+ if (i == RENESAS_RETRY)
-+ dev_dbg(&pdev->dev, "Chip erase timedout: %x\n", status);
-+
-+ dev_dbg(&pdev->dev, "ROM Erase... Done success\n");
-+}
-+
-+static bool renesas_download_rom(struct pci_dev *pdev,
-+ const u32 *fw, size_t step)
-+{
-+ bool data0_or_data1;
-+ u8 fw_status;
-+ size_t i;
-+ int err;
-+
-+ /*
-+ * The hardware does alternate between two 32-bit pages.
-+ * (This is because each row of the firmware is 8 bytes).
-+ *
-+ * for even steps we use DATA0, for odd steps DATA1.
-+ */
-+ data0_or_data1 = (step & 1) == 1;
-+
-+ /* Read "Set DATAX" and confirm it is cleared. */
-+ for (i = 0; i < RENESAS_RETRY; i++) {
-+ err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS_MSB,
-+ &fw_status);
-+ if (err) {
-+ dev_err(&pdev->dev, "Read ROM Status failed: %d\n",
-+ pcibios_err_to_errno(err));
-+ return false;
-+ }
-+ if (!(fw_status & BIT(data0_or_data1)))
-+ break;
-+
-+ udelay(RENESAS_DELAY);
-+ }
-+ if (i == RENESAS_RETRY) {
-+ dev_err(&pdev->dev, "Timeout for Set DATAX step: %zd\n", step);
-+ return false;
-+ }
-+
-+ /*
-+ * Write FW data to "DATAX".
-+ * "LSB is left" => force little endian
-+ */
-+ err = pci_write_config_dword(pdev, data0_or_data1 ?
-+ RENESAS_DATA1 : RENESAS_DATA0,
-+ (__force u32)cpu_to_le32(fw[step]));
-+ if (err) {
-+ dev_err(&pdev->dev, "Write to DATAX failed: %d\n",
-+ pcibios_err_to_errno(err));
-+ return false;
-+ }
-+
-+ udelay(100);
-+
-+ /* Set "Set DATAX". */
-+ err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS_MSB,
-+ BIT(data0_or_data1));
-+ if (err) {
-+ dev_err(&pdev->dev, "Write config for DATAX failed: %d\n",
-+ pcibios_err_to_errno(err));
-+ return false;
-+ }
-+
-+ return true;
-+}
-+
-+static bool renesas_setup_rom(struct pci_dev *pdev, const struct firmware *fw)
-+{
-+ const u32 *fw_data = (const u32 *)fw->data;
-+ int err, i;
-+ u8 status;
-+
-+ /* 2. Write magic word to Data0 */
-+ err = pci_write_config_dword(pdev, RENESAS_DATA0,
-+ RENESAS_ROM_WRITE_MAGIC);
-+ if (err)
-+ return false;
-+
-+ /* 3. Set External ROM access */
-+ err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS,
-+ RENESAS_ROM_STATUS_ACCESS);
-+ if (err)
-+ goto remove_bypass;
-+
-+ /* 4. Check the result */
-+ err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
-+ if (err)
-+ goto remove_bypass;
-+ status &= GENMASK(6, 4);
-+ if (status) {
-+ dev_err(&pdev->dev,
-+ "setting external rom failed: %x\n", status);
-+ goto remove_bypass;
-+ }
-+
-+ /* 5 to 16 Write FW to DATA0/1 while checking SetData0/1 */
-+ for (i = 0; i < fw->size / 4; i++) {
-+ err = renesas_download_rom(pdev, fw_data, i);
-+ if (!err) {
-+ dev_err(&pdev->dev,
-+ "ROM Download Step %d failed at position %d bytes\n",
-+ i, i * 4);
-+ goto remove_bypass;
-+ }
-+ }
-+
-+ /*
-+ * wait till DATA0/1 is cleared
-+ */
-+ for (i = 0; i < RENESAS_RETRY; i++) {
-+ err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS_MSB,
-+ &status);
-+ if (err)
-+ goto remove_bypass;
-+ if (!(status & (BIT(0) | BIT(1))))
-+ break;
-+
-+ udelay(RENESAS_DELAY);
-+ }
-+ if (i == RENESAS_RETRY) {
-+ dev_err(&pdev->dev, "Final Firmware ROM Download step timed out\n");
-+ goto remove_bypass;
-+ }
-+
-+ /* 17. Remove bypass */
-+ err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS, 0);
-+ if (err)
-+ return false;
-+
-+ udelay(10);
-+
-+ /* 18. check result */
-+ for (i = 0; i < RENESAS_RETRY; i++) {
-+ err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
-+ if (err) {
-+ dev_err(&pdev->dev, "Read ROM status failed:%d\n",
-+ pcibios_err_to_errno(err));
-+ return false;
-+ }
-+ status &= RENESAS_ROM_STATUS_RESULT;
-+ if (status == RENESAS_ROM_STATUS_SUCCESS) {
-+ dev_dbg(&pdev->dev, "Download ROM success\n");
-+ break;
-+ }
-+ udelay(RENESAS_DELAY);
-+ }
-+ if (i == RENESAS_RETRY) { /* Timed out */
-+ dev_err(&pdev->dev,
-+ "Download to external ROM TO: %x\n", status);
-+ return false;
-+ }
-+
-+ dev_dbg(&pdev->dev, "Download to external ROM scuceeded\n");
-+
-+ /* Last step set Reload */
-+ err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS,
-+ RENESAS_ROM_STATUS_RELOAD);
-+ if (err) {
-+ dev_err(&pdev->dev, "Set ROM execute failed: %d\n",
-+ pcibios_err_to_errno(err));
-+ return false;
-+ }
-+
-+ /*
-+ * wait till Reload is cleared
-+ */
-+ for (i = 0; i < RENESAS_RETRY; i++) {
-+ err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
-+ if (err)
-+ return false;
-+ if (!(status & RENESAS_ROM_STATUS_RELOAD))
-+ break;
-+
-+ udelay(RENESAS_DELAY);
-+ }
-+ if (i == RENESAS_RETRY) {
-+ dev_err(&pdev->dev, "ROM Exec timed out: %x\n", status);
-+ return false;
-+ }
-+
-+ return true;
-+
-+remove_bypass:
-+ pci_write_config_byte(pdev, RENESAS_ROM_STATUS, 0);
-+ return false;
-+}
-+
-+static void renesas_fw_callback(const struct firmware *fw,
-+ void *context)
-+{
-+ struct renesas_fw_ctx *ctx = context;
-+ struct pci_dev *pdev = ctx->pdev;
-+ struct device *parent = pdev->dev.parent;
-+ const struct renesas_fw_entry *next_entry;
-+ bool rom;
-+ int err;
-+
-+ if (!fw) {
-+ dev_err(&pdev->dev, "firmware failed to load\n");
-+ /*
-+ * we didn't find firmware, check if we have another
-+ * entry for this device
-+ */
-+ next_entry = renesas_get_next_entry(ctx->pdev, ctx->entry);
-+ if (next_entry) {
-+ ctx->entry = next_entry;
-+ dev_dbg(&pdev->dev, "Found next entry, requesting: %s\n",
-+ next_entry->firmware_name);
-+ request_firmware_nowait(THIS_MODULE, 1,
-+ next_entry->firmware_name,
-+ &pdev->dev, GFP_KERNEL,
-+ ctx, renesas_fw_callback);
-+ return;
-+ } else {
-+ goto cleanup;
-+ }
-+ }
-+
-+ err = renesas_fw_verify(pdev, fw->data, fw->size);
-+ if (err)
-+ goto cleanup;
-+
-+ /* Check if the device has external ROM */
-+ rom = renesas_check_rom(pdev);
-+ if (rom) {
-+ /* perfrom chip erase first */
-+ renesas_rom_erase(pdev);
-+
-+ /* lets try loading fw on ROM first */
-+ rom = renesas_setup_rom(pdev, fw);
-+ if (!rom) {
-+ dev_err(&pdev->dev,
-+ "ROM load failed, falling back on FW load\n");
-+ } else {
-+ dev_dbg(&pdev->dev, "ROM load done..\n");
-+
-+ release_firmware(fw);
-+ goto do_probe;
-+ }
-+ }
-+
-+ err = renesas_fw_download(pdev, fw);
-+ release_firmware(fw);
-+ if (err) {
-+ dev_err(&pdev->dev, "firmware failed to download (%d).", err);
-+ goto cleanup;
-+ }
-+
-+do_probe:
-+ if (ctx->resume)
-+ return;
-+
-+ err = xhci_pci_probe(pdev, ctx->id);
-+ if (!err) {
-+ /* everything worked */
-+ devm_kfree(&pdev->dev, ctx);
-+ return;
-+ }
-+
-+cleanup:
-+ /* in case of an error - fall through */
-+ dev_info(&pdev->dev, "Unloading driver");
-+
-+ if (parent)
-+ device_lock(parent);
-+
-+ device_release_driver(&pdev->dev);
-+
-+ if (parent)
-+ device_unlock(parent);
-+
-+ pci_dev_put(pdev);
-+}
-+
-+static int renesas_fw_alive_check(struct pci_dev *pdev)
-+{
-+ const struct renesas_fw_entry *entry;
-+
-+ /* check if we have a eligible RENESAS' uPD720201/2 w/o FW. */
-+ entry = renesas_needs_fw_dl(pdev);
-+ if (!entry)
-+ return 0;
-+
-+ return renesas_fw_check_running(pdev);
-+}
-+
-+static int renesas_fw_download_to_hw(struct pci_dev *pdev,
-+ const struct pci_device_id *id,
-+ bool do_resume)
-+{
-+ const struct renesas_fw_entry *entry;
-+ struct renesas_fw_ctx *ctx;
-+ int err;
-+
-+ /* check if we have a eligible RENESAS' uPD720201/2 w/o FW. */
-+ entry = renesas_needs_fw_dl(pdev);
-+ if (!entry)
-+ return 0;
-+
-+ err = renesas_fw_check_running(pdev);
-+ /* Continue ahead, if the firmware is already running. */
-+ if (err == 0)
-+ return 0;
-+
-+ if (err != 1)
-+ return err;
-+
-+ ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL);
-+ if (!ctx)
-+ return -ENOMEM;
-+ ctx->pdev = pdev;
-+ ctx->resume = do_resume;
-+ ctx->id = id;
-+ ctx->entry = entry;
-+
-+ pci_dev_get(pdev);
-+ err = request_firmware_nowait(THIS_MODULE, 1, entry->firmware_name,
-+ &pdev->dev, GFP_KERNEL,
-+ ctx, renesas_fw_callback);
-+ if (err) {
-+ pci_dev_put(pdev);
-+ return err;
-+ }
-+
-+ /*
-+ * The renesas_fw_callback() callback will continue the probe
-+ * process, once it aquires the firmware.
-+ */
-+ return 1;
-+}
-+
-+static int renesas_check_if_fw_dl_is_needed(struct pci_dev *pdev)
-+{
-+ int err;
-+ u8 fw_state;
-+
-+ /*
-+ * Only the uPD720201K8-711-BAC-A or uPD720202K8-711-BAA-A
-+ * are listed in R19UH0078EJ0500 Rev.5.00 as devices which
-+ * need a firmware in order to work.
-+ *
-+ * - uPD720202 ES 2.0 sample & CS sample & Mass product, ID is 2.
-+ * - uPD720201 ES 2.0 sample whose revision ID is 2.
-+ * - uPD720201 ES 2.1 sample & CS sample & Mass product, ID is 3.
-+ */
-+ if (!((pdev->vendor == PCI_VENDOR_ID_RENESAS) &&
-+ ((pdev->device == 0x0015 && pdev->revision == 0x02) ||
-+ (pdev->device == 0x0014 &&
-+ (pdev->revision == 0x02 || pdev->revision == 0x03)))))
-+ return 0;
-+
-+ /* Check if device has ROM and loaded, if so skip everything */
-+ err = renesas_check_rom_state(pdev);
-+ if (!err)
-+ return err;
-+
-+ /*
-+ * Test if the firmware was uploaded and is running.
-+ * As most BIOSes will initialize the device for us.
-+ */
-+ err = pci_read_config_byte(pdev, RENESAS_FW_STATUS, &fw_state);
-+ if (err)
-+ return pcibios_err_to_errno(err);
-+
-+ /* Check the "Result Code" Bits (6:4) and act accordingly */
-+ switch (fw_state & RENESAS_FW_STATUS_RESULT) {
-+ case 0: /* No result yet */
-+ dev_err(&pdev->dev, "FW is not ready/loaded yet.");
-+ return -ENODEV;
-+
-+ case RENESAS_FW_STATUS_SUCCESS:
-+ dev_dbg(&pdev->dev, "FW is ready.");
-+ return 0;
-+
-+ case RENESAS_FW_STATUS_ERROR:
-+ dev_err(&pdev->dev, "HW is in an error state.");
-+ return -ENODEV;
-+
-+ default: /* All other states are marked as "Reserved states" */
-+ dev_err(&pdev->dev, "HW is in an invalid state (%x).",
-+ (fw_state & 0x70) >> 4);
-+ return -EINVAL;
-+ }
-+}
-+
- /* called during probe() after chip reset completes */
- static int xhci_pci_setup(struct usb_hcd *hcd)
- {
-@@ -325,6 +1232,27 @@ static int xhci_pci_probe(struct pci_dev
- struct hc_driver *driver;
- struct usb_hcd *hcd;
-
-+ /*
-+ * Check if this device is a RENESAS uPD720201/2 device.
-+ * Otherwise, we can continue with xhci_pci_probe as usual.
-+ */
-+ retval = renesas_fw_download_to_hw(dev, id, false);
-+ switch (retval) {
-+ case 0:
-+ break;
-+
-+ case 1: /* let it load the firmware and recontinue the probe. */
-+ return 0;
-+
-+ default:
-+ return retval;
-+ };
-+
-+ /* Check if this device is a RENESAS uPD720201/2 device. */
-+ retval = renesas_check_if_fw_dl_is_needed(dev);
-+ if (retval)
-+ return retval;
-+
- driver = (struct hc_driver *)id->driver_data;
-
- /* Prevent runtime suspending between USB-2 and USB-3 initialization */
-@@ -386,6 +1314,16 @@ static void xhci_pci_remove(struct pci_d
- {
- struct xhci_hcd *xhci;
-
-+ if (renesas_fw_alive_check(dev)) {
-+ /*
-+ * bail out early, if this was a renesas device w/o FW.
-+ * Else we might hit the NMI watchdog in xhci_handsake
-+ * during xhci_reset as part of the driver's unloading.
-+ * which we forced in the renesas_fw_callback().
-+ */
-+ return;
-+ }
-+
- xhci = hcd_to_xhci(pci_get_drvdata(dev));
- xhci->xhc_state |= XHCI_STATE_REMOVING;
-
-@@ -513,6 +1451,11 @@ static int xhci_pci_resume(struct usb_hc
- if (pdev->vendor == PCI_VENDOR_ID_INTEL)
- usb_enable_intel_xhci_ports(pdev);
-
-+ /* Check if this device is a RENESAS uPD720201/2 device. */
-+ retval = renesas_check_if_fw_dl_is_needed(pdev);
-+ if (retval)
-+ return retval;
-+
- if (xhci->quirks & XHCI_SSIC_PORT_UNUSED)
- xhci_ssic_port_unused_quirk(hcd, false);
-
--- /dev/null
+From 4fe1b3064755ff890bfa69547dc1b2a99005af61 Mon Sep 17 00:00:00 2001
+From: Christian Lamparter <chunkeey@googlemail.com>
+Date: Wed, 8 Jun 2016 00:14:57 +0200
+Subject: [PATCH] usb: xhci: handle uPD720201 and uPD720202 w/o ROM
+
+This patch adds a firmware check for the uPD720201K8-711-BAC-A
+and uPD720202K8-711-BAA-A variant. Both of these chips are listed
+in Renesas' R19UH0078EJ0500 Rev.5.00 "User's Manual: Hardware" as
+devices which need a firmware in order to work as they do not have
+support to load the firmware from an external ROM.
+
+Currently, the xhci-pci driver is unable to initialize the hcd in
+this case. Instead it will wait for 30 seconds and cause a timeout
+in xhci_handshake() and fails.
+
+[ 5.116990] xhci_hcd 0000:45:00.0: new USB bus registered ...
+[ 32.335215] xhci_hcd 0000:45:00.0: can't setup: -110
+[ 32.340179] xhci_hcd 0000:45:00.0: USB bus 2 deregistered
+[ 32.345587] xhci_hcd 0000:45:00.0: init 0000:45:00.0 fail, -110
+[ 32.351496] xhci_hcd: probe of 0000:45:00.0 failed with error -110
+
+Cc: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
+Signed-off-by: Christian Lamparter <chunkeey@gmail.com>
+Signed-off-by: Christian Lamparter <chunkeey@gmail.com>
+---
+ drivers/usb/host/xhci-pci.c | 59 +++++++++++++++++++++++++++++++++++++
+ 1 file changed, 59 insertions(+)
+
+--- a/drivers/usb/host/xhci-pci.c
++++ b/drivers/usb/host/xhci-pci.c
+@@ -280,6 +280,55 @@ static void xhci_pme_acpi_rtd3_enable(st
+ static void xhci_pme_acpi_rtd3_enable(struct pci_dev *dev) { }
+ #endif /* CONFIG_ACPI */
+
++static int renesas_check_if_fw_dl_is_needed(struct pci_dev *pdev)
++{
++ int err;
++ u8 fw_state;
++
++ /*
++ * Only the uPD720201K8-711-BAC-A or uPD720202K8-711-BAA-A
++ * are listed in R19UH0078EJ0500 Rev.5.00 as devices which
++ * need a firmware in order to work.
++ *
++ * - uPD720202 ES 2.0 sample & CS sample & Mass product, ID is 2.
++ * - uPD720201 ES 2.0 sample whose revision ID is 2.
++ * - uPD720201 ES 2.1 sample & CS sample & Mass product, ID is 3.
++ */
++ if (!((pdev->vendor == PCI_VENDOR_ID_RENESAS) &&
++ ((pdev->device == 0x0015 && pdev->revision == 0x02) ||
++ (pdev->device == 0x0014 &&
++ (pdev->revision == 0x02 || pdev->revision == 0x03)))))
++ return 0;
++
++ /*
++ * Test if the firmware was uploaded and is running.
++ * As most BIOSes will initialize the device for us.
++ */
++ err = pci_read_config_byte(pdev, 0xf4, &fw_state);
++ if (err)
++ return pcibios_err_to_errno(err);
++
++ /* Check the "Result Code" Bits (6:4) and act accordingly */
++ switch (fw_state & 0x70) {
++ case 0: /* No result yet */
++ dev_err(&pdev->dev, "FW is not ready/loaded yet.");
++ return -ENODEV;
++
++ case BIT(4): /* Success, device should be working. */
++ dev_dbg(&pdev->dev, "FW is ready.");
++ return 0;
++
++ case BIT(5): /* Error State */
++ dev_err(&pdev->dev, "HW is in an error state.");
++ return -ENODEV;
++
++ default: /* All other states are marked as "Reserved states" */
++ dev_err(&pdev->dev, "HW is in an invalid state (%x).",
++ (fw_state & 0x70) >> 4);
++ return -EINVAL;
++ }
++}
++
+ /* called during probe() after chip reset completes */
+ int xhci_pci_setup(struct usb_hcd *hcd)
+ {
+@@ -319,6 +368,11 @@ int xhci_pci_probe(struct pci_dev *dev,
+ struct hc_driver *driver;
+ struct usb_hcd *hcd;
+
++ /* Check if this device is a RENESAS uPD720201/2 device. */
++ retval = renesas_check_if_fw_dl_is_needed(dev);
++ if (retval)
++ return retval;
++
+ driver = (struct hc_driver *)id->driver_data;
+
+ /* Prevent runtime suspending between USB-2 and USB-3 initialization */
+@@ -513,6 +567,11 @@ int xhci_pci_resume(struct usb_hcd *hcd,
+ if (pdev->vendor == PCI_VENDOR_ID_INTEL)
+ usb_enable_intel_xhci_ports(pdev);
+
++ /* Check if this device is a RENESAS uPD720201/2 device. */
++ retval = renesas_check_if_fw_dl_is_needed(pdev);
++ if (retval)
++ return retval;
++
+ if (xhci->quirks & XHCI_SSIC_PORT_UNUSED)
+ xhci_ssic_port_unused_quirk(hcd, false);
+
projects / openwrt / staging / chunkeey.git / commitdiff