[openwrt/openwrt.git] / target / linux / apm821xx / patches-4.9 / 801-usb-xhci-add-firmware-loader-for-uPD720201-and-uPD72.patch

From 419992bae5aaa4e06402e0b7c79fcf7bcb6b4764 Mon Sep 17 00:00:00 2001
From: Christian Lamparter <chunkeey@googlemail.com>
Date: Thu, 2 Jun 2016 00:48:46 +0200
Subject: [PATCH] usb: xhci: add firmware loader for uPD720201 and uPD720202
 w/o ROM

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.

If someone from Renesas is listening: It would be great, if these
firmwares could be added to linux-firmware.git.

Cc: Yoshihiro Shimoda <yoshihiro.shimoda.uh@renesas.com>
Signed-off-by: Christian Lamparter <chunkeey@googlemail.com>
---
 drivers/usb/host/xhci-pci.c | 492 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 492 insertions(+)

--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -24,6 +24,8 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/acpi.h>
+#include <linux/firmware.h>
+#include <asm/unaligned.h>
 
 #include "xhci.h"
 #include "xhci-trace.h"
@@ -224,6 +226,458 @@ 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.
+        */
+       { "K2013080.mem", 0x0014, 0x02, 0x2013 },
+       { "K2013080.mem", 0x0014, 0x03, 0x2013 },
+       { "K2013080.mem", 0x0015, 0x02, 0x2013 },
+};
+
+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 < 10000; i++) {
+               err = pci_read_config_byte(dev, 0xF5, &fw_status);
+               if (err)
+                       return pcibios_err_to_errno(err);
+               if (!(fw_status & BIT(data0_or_data1)))
+                       break;
+
+               udelay(1);
+       }
+       if (i == 10000)
+               return -ETIMEDOUT;
+
+       /*
+        * step+2. Write FW data to "DATAX".
+        * "LSB is left" => force little endian
+        */
+       err = pci_write_config_dword(dev, data0_or_data1 ? 0xFC : 0xF8,
+                                    (__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, 0xF5, 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_err(&dev->dev, "firmware size is not a multipe of 8.");
+               return -EINVAL;
+       }
+
+       /*
+        * 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, 0xF4, &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 & BIT(1)) {
+               dev_dbg(&pdev->dev, "FW Download Lock is engaged.");
+
+               if (fw_state & BIT(4))
+                       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 & BIT(0)) {
+               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 & 0x70)) {
+       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 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, "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 %x. Giving up (poweroff/reboot needed).",
+                       (fw_state & 0x70) >> 4);
+               return -EINVAL;
+       }
+}
+
+static int renesas_hw_check_run_stop_busy(struct pci_dev *pdev)
+{
+#if 0
+       u32 val;
+
+       /*
+        * 7.1.3 Note 3: "... must not set 'FW Download Enable' when
+        * 'RUN/STOP' of USBCMD Register is set"
+        */
+       val = readl(hcd->regs + 0x20);
+       if (val & BIT(0)) {
+               dev_err(&pdev->dev, "hardware is busy and can't receive a FW.");
+               return -EBUSY;
+       }
+#endif
+       return 0;
+}
+
+static int renesas_fw_download(struct pci_dev *pdev,
+       const struct firmware *fw, unsigned int retry_counter)
+{
+       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
+        */
+       err = renesas_hw_check_run_stop_busy(pdev);
+       if (err)
+               return err;
+
+       /*
+        * 0. Set "FW Download Enable" bit in the
+        * "FW Download Control & Status Register" at 0xF4
+        */
+       err = pci_write_config_byte(pdev, 0xF4, BIT(0));
+       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 < 10000; i++) {
+               err = pci_read_config_byte(pdev, 0xF5, &fw_status);
+               if (err)
+                       return pcibios_err_to_errno(err);
+               if (!(fw_status & (BIT(0) | BIT(1))))
+                       break;
+
+               udelay(1);
+       }
+       if (i == 10000)
+               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, 0xF4, 0);
+       if (err)
+               return pcibios_err_to_errno(err);
+
+       /* 12. Read "Result Code" and confirm it is good. */
+       for (i = 0; i < 10000; i++) {
+               err = pci_read_config_byte(pdev, 0xF4, &fw_status);
+               if (err)
+                       return pcibios_err_to_errno(err);
+               if (fw_status & BIT(4))
+                       break;
+
+               udelay(1);
+       }
+       if (i == 10000) {
+               /* 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? - we can try to retry) */
+                       if (retry_counter < 10) {
+                               retry_counter++;
+                               dev_warn(&pdev->dev, "Retry Firmware download: %d try.",
+                                         retry_counter);
+                               return renesas_fw_download(pdev, fw,
+                                                          retry_counter);
+                       }
+                       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;
+};
+
+static int xhci_pci_probe(struct pci_dev *pdev,
+                         const struct pci_device_id *id);
+
+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 = -ENOENT;
+
+       if (fw) {
+               err = renesas_fw_verify(pdev, fw->data, fw->size);
+               if (!err) {
+                       err = renesas_fw_download(pdev, fw, 0);
+                       release_firmware(fw);
+                       if (!err) {
+                               if (ctx->resume)
+                                       return;
+
+                               err = xhci_pci_probe(pdev, ctx->id);
+                               if (!err) {
+                                       /* everything worked */
+                                       devm_kfree(&pdev->dev, ctx);
+                                       return;
+                               }
+
+                               /* in case of an error - fall through */
+                       } else {
+                               dev_err(&pdev->dev, "firmware failed to download (%d).",
+                                       err);
+                       }
+               }
+       } else {
+               dev_err(&pdev->dev, "firmware failed to load (%d).", err);
+       }
+
+       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;
+       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);
+       /* Also go ahead, if the firmware is running */
+       if (err == 0)
+               return 0;
+
+       /* At this point, we can be sure that the FW isn't ready. */
+       return err;
+}
+
+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;
+
+       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;
+}
+
 /* called during probe() after chip reset completes */
 static int xhci_pci_setup(struct usb_hcd *hcd)
 {
@@ -263,6 +717,22 @@ 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;
+       };
+
        driver = (struct hc_driver *)id->driver_data;
 
        /* Prevent runtime suspending between USB-2 and USB-3 initialization */
@@ -320,6 +790,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;
        if (xhci->shared_hcd) {