Quelle  xhci-pci-renesas.c   Sprache: C

// 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.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_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_NO_RESULT   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   50000 /* 50000 * RENESAS_DELAY ~= 500ms */
#define RENESAS_CHIP_ERASE_RETRY 500000 /* 500000 * RENESAS_DELAY ~= 5s */
#define RENESAS_DELAY   10

#define RENESAS_FW_NAME "renesas_usb_fw.mem"

static int renesas_fw_download_image(struct pci_dev *dev,
         const u32 *fw, size_t step, bool rom)
{
 size_t i;
 int err;
 u8 fw_status;
 bool data0_or_data1;
 u32 status_reg;

 if (rom)
  status_reg = RENESAS_ROM_STATUS_MSB;
 else
  status_reg = RENESAS_FW_STATUS_MSB;

 /*
 * 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, status_reg, &fw_status);
  if (err) {
   dev_err(&dev->dev, "Read Status failed: %d\n",
    pcibios_err_to_errno(err));
   return pcibios_err_to_errno(err);
  }
  if (!(fw_status & BIT(data0_or_data1)))
   break;

  udelay(RENESAS_DELAY);
 }
 if (i == RENESAS_RETRY) {
  dev_err(&dev->dev, "Timeout for Set DATAX step: %zd\n", step);
  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) {
  dev_err(&dev->dev, "Write to DATAX failed: %d\n",
   pcibios_err_to_errno(err));
  return pcibios_err_to_errno(err);
 }

 udelay(100);

 /* step+3. Set "Set DATAX". */
 err = pci_write_config_byte(dev, status_reg, BIT(data0_or_data1));
 if (err) {
  dev_err(&dev->dev, "Write config for DATAX failed: %d\n",
   pcibios_err_to_errno(err));
  return pcibios_err_to_errno(err);
 }

 return 0;
}

static int renesas_fw_verify(const void *fw_data,
        size_t length)
{
 u16 fw_version_pointer;

 /*
 * 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) {
  pr_err("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) {
  pr_err("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) {
  pr_err("fw ver pointer is outside of the firmware image");
  return -EINVAL;
 }

 return 0;
}

static bool renesas_check_rom(struct pci_dev *pdev)
{
 u16 rom_status;
 int retval;

 /* 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 int renesas_check_rom_state(struct pci_dev *pdev)
{
 u16 rom_state;
 u32 version;
 int err;

 /* 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 ROM version: %x\n", version);

 /*
 * 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 & RENESAS_ROM_STATUS_ROM_EXISTS) {
  /* 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:
   return 0;

  case RENESAS_ROM_STATUS_NO_RESULT: /* No result yet */
   dev_dbg(&pdev->dev, "Unknown ROM status ...\n");
   return -ENOENT;

  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)
{
 u8 fw_state;
 int 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 reset, 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, false);
  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! */
   dev_err(&pdev->dev, "FW Load timedout");
   return -ETIMEDOUT;

  default:
   return err;
  }
 }

 return 0;
}

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_CHIP_ERASE_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_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_fw_download_image(pdev, fw_data, i, true);
  if (err) {
   dev_err(&pdev->dev,
    "ROM Download Step %d failed at position %d bytes with (%d)\n",
     i, i * 4, err);
   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 succeeded\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 int renesas_load_fw(struct pci_dev *pdev, const struct firmware *fw)
{
 int err = 0;
 bool rom;

 /* Check if the device has external ROM */
 rom = renesas_check_rom(pdev);
 if (rom) {
  /* perform chip erase first */
  renesas_rom_erase(pdev);

  /* lets try loading fw on ROM first */
  rom = renesas_setup_rom(pdev, fw);
  if (!rom) {
   dev_dbg(&pdev->dev,
    "ROM load failed, falling back on FW load\n");
  } else {
   dev_dbg(&pdev->dev,
    "ROM load success\n");
   goto exit;
  }
 }

 err = renesas_fw_download(pdev, fw);

exit:
 if (err)
  dev_err(&pdev->dev, "firmware failed to download (%d).", err);
 return err;
}

static int renesas_xhci_check_request_fw(struct pci_dev *pdev,
      const struct pci_device_id *id)
{
 const char fw_name[] = RENESAS_FW_NAME;
 const struct firmware *fw;
 bool has_rom;
 int err;

 /* Check if device has ROM and loaded, if so skip everything */
 has_rom = renesas_check_rom(pdev);
 if (has_rom) {
  err = renesas_check_rom_state(pdev);
  if (!err)
   return 0;
  else if (err != -ENOENT)
   has_rom = false;
 }

 err = renesas_fw_check_running(pdev);
 /* Continue ahead, if the firmware is already running. */
 if (!err)
  return 0;

 /* no firmware interface available */
 if (err != 1)
  return has_rom ? 0 : err;

 pci_dev_get(pdev);
 err = firmware_request_nowarn(&fw, fw_name, &pdev->dev);
 pci_dev_put(pdev);
 if (err) {
  if (has_rom) {
   dev_info(&pdev->dev, "failed to load firmware %s, fallback to ROM\n",
     fw_name);
   return 0;
  }
  dev_err(&pdev->dev, "failed to load firmware %s: %d\n",
   fw_name, err);
  return err;
 }

 err = renesas_fw_verify(fw->data, fw->size);
 if (err)
  goto exit;

 err = renesas_load_fw(pdev, fw);
exit:
 release_firmware(fw);
 return err;
}

static int
xhci_pci_renesas_probe(struct pci_dev *dev, const struct pci_device_id *id)
{
 int retval;

 retval = renesas_xhci_check_request_fw(dev, id);
 if (retval)
  return retval;

 return xhci_pci_common_probe(dev, id);
}

static const struct pci_device_id pci_ids[] = {
 { PCI_DEVICE(PCI_VENDOR_ID_RENESAS, 0x0014) },
 { PCI_DEVICE(PCI_VENDOR_ID_RENESAS, 0x0015) },
 { /* end: all zeroes */ }
};
MODULE_DEVICE_TABLE(pci, pci_ids);

static struct pci_driver xhci_renesas_pci_driver = {
 .name =  "xhci-pci-renesas",
 .id_table = pci_ids,

 .probe = xhci_pci_renesas_probe,
 .remove = xhci_pci_remove,

 .shutdown =  usb_hcd_pci_shutdown,
 .driver = {
  .pm = pm_ptr(&usb_hcd_pci_pm_ops),
 },
};
module_pci_driver(xhci_renesas_pci_driver);

MODULE_DESCRIPTION("Renesas xHCI PCI Host Controller Driver");
MODULE_FIRMWARE(RENESAS_FW_NAME);
MODULE_IMPORT_NS("xhci");
MODULE_LICENSE("GPL v2");