Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /* Copyright (C) 2019-2020 Linaro Limited */
0003 
0004 #include <linux/acpi.h>
0005 #include <linux/firmware.h>
0006 #include <linux/module.h>
0007 #include <linux/pci.h>
0008 #include <linux/slab.h>
0009 #include <asm/unaligned.h>
0010 
0011 #include "xhci.h"
0012 #include "xhci-trace.h"
0013 #include "xhci-pci.h"
0014 
0015 #define RENESAS_FW_VERSION              0x6C
0016 #define RENESAS_ROM_CONFIG              0xF0
0017 #define RENESAS_FW_STATUS               0xF4
0018 #define RENESAS_FW_STATUS_MSB               0xF5
0019 #define RENESAS_ROM_STATUS              0xF6
0020 #define RENESAS_ROM_STATUS_MSB              0xF7
0021 #define RENESAS_DATA0                   0xF8
0022 #define RENESAS_DATA1                   0xFC
0023 
0024 #define RENESAS_FW_VERSION_FIELD            GENMASK(23, 7)
0025 #define RENESAS_FW_VERSION_OFFSET           8
0026 
0027 #define RENESAS_FW_STATUS_DOWNLOAD_ENABLE       BIT(0)
0028 #define RENESAS_FW_STATUS_LOCK              BIT(1)
0029 #define RENESAS_FW_STATUS_RESULT            GENMASK(6, 4)
0030   #define RENESAS_FW_STATUS_INVALID         0
0031   #define RENESAS_FW_STATUS_SUCCESS         BIT(4)
0032   #define RENESAS_FW_STATUS_ERROR           BIT(5)
0033 #define RENESAS_FW_STATUS_SET_DATA0         BIT(8)
0034 #define RENESAS_FW_STATUS_SET_DATA1         BIT(9)
0035 
0036 #define RENESAS_ROM_STATUS_ACCESS           BIT(0)
0037 #define RENESAS_ROM_STATUS_ERASE            BIT(1)
0038 #define RENESAS_ROM_STATUS_RELOAD           BIT(2)
0039 #define RENESAS_ROM_STATUS_RESULT           GENMASK(6, 4)
0040   #define RENESAS_ROM_STATUS_NO_RESULT          0
0041   #define RENESAS_ROM_STATUS_SUCCESS            BIT(4)
0042   #define RENESAS_ROM_STATUS_ERROR          BIT(5)
0043 #define RENESAS_ROM_STATUS_SET_DATA0            BIT(8)
0044 #define RENESAS_ROM_STATUS_SET_DATA1            BIT(9)
0045 #define RENESAS_ROM_STATUS_ROM_EXISTS           BIT(15)
0046 
0047 #define RENESAS_ROM_ERASE_MAGIC             0x5A65726F
0048 #define RENESAS_ROM_WRITE_MAGIC             0x53524F4D
0049 
0050 #define RENESAS_RETRY   10000
0051 #define RENESAS_DELAY   10
0052 
0053 static int renesas_fw_download_image(struct pci_dev *dev,
0054                      const u32 *fw, size_t step, bool rom)
0055 {
0056     size_t i;
0057     int err;
0058     u8 fw_status;
0059     bool data0_or_data1;
0060     u32 status_reg;
0061 
0062     if (rom)
0063         status_reg = RENESAS_ROM_STATUS_MSB;
0064     else
0065         status_reg = RENESAS_FW_STATUS_MSB;
0066 
0067     /*
0068      * The hardware does alternate between two 32-bit pages.
0069      * (This is because each row of the firmware is 8 bytes).
0070      *
0071      * for even steps we use DATA0, for odd steps DATA1.
0072      */
0073     data0_or_data1 = (step & 1) == 1;
0074 
0075     /* step+1. Read "Set DATAX" and confirm it is cleared. */
0076     for (i = 0; i < RENESAS_RETRY; i++) {
0077         err = pci_read_config_byte(dev, status_reg, &fw_status);
0078         if (err) {
0079             dev_err(&dev->dev, "Read Status failed: %d\n",
0080                 pcibios_err_to_errno(err));
0081             return pcibios_err_to_errno(err);
0082         }
0083         if (!(fw_status & BIT(data0_or_data1)))
0084             break;
0085 
0086         udelay(RENESAS_DELAY);
0087     }
0088     if (i == RENESAS_RETRY) {
0089         dev_err(&dev->dev, "Timeout for Set DATAX step: %zd\n", step);
0090         return -ETIMEDOUT;
0091     }
0092 
0093     /*
0094      * step+2. Write FW data to "DATAX".
0095      * "LSB is left" => force little endian
0096      */
0097     err = pci_write_config_dword(dev, data0_or_data1 ?
0098                      RENESAS_DATA1 : RENESAS_DATA0,
0099                      (__force u32)cpu_to_le32(fw[step]));
0100     if (err) {
0101         dev_err(&dev->dev, "Write to DATAX failed: %d\n",
0102             pcibios_err_to_errno(err));
0103         return pcibios_err_to_errno(err);
0104     }
0105 
0106     udelay(100);
0107 
0108     /* step+3. Set "Set DATAX". */
0109     err = pci_write_config_byte(dev, status_reg, BIT(data0_or_data1));
0110     if (err) {
0111         dev_err(&dev->dev, "Write config for DATAX failed: %d\n",
0112             pcibios_err_to_errno(err));
0113         return pcibios_err_to_errno(err);
0114     }
0115 
0116     return 0;
0117 }
0118 
0119 static int renesas_fw_verify(const void *fw_data,
0120                  size_t length)
0121 {
0122     u16 fw_version_pointer;
0123 
0124     /*
0125      * The Firmware's Data Format is describe in
0126      * "6.3 Data Format" R19UH0078EJ0500 Rev.5.00 page 124
0127      */
0128 
0129     /*
0130      * The bootrom chips of the big brother have sizes up to 64k, let's
0131      * assume that's the biggest the firmware can get.
0132      */
0133     if (length < 0x1000 || length >= 0x10000) {
0134         pr_err("firmware is size %zd is not (4k - 64k).",
0135             length);
0136         return -EINVAL;
0137     }
0138 
0139     /* The First 2 bytes are fixed value (55aa). "LSB on Left" */
0140     if (get_unaligned_le16(fw_data) != 0x55aa) {
0141         pr_err("no valid firmware header found.");
0142         return -EINVAL;
0143     }
0144 
0145     /* verify the firmware version position and print it. */
0146     fw_version_pointer = get_unaligned_le16(fw_data + 4);
0147     if (fw_version_pointer + 2 >= length) {
0148         pr_err("fw ver pointer is outside of the firmware image");
0149         return -EINVAL;
0150     }
0151 
0152     return 0;
0153 }
0154 
0155 static bool renesas_check_rom(struct pci_dev *pdev)
0156 {
0157     u16 rom_status;
0158     int retval;
0159 
0160     /* Check if external ROM exists */
0161     retval = pci_read_config_word(pdev, RENESAS_ROM_STATUS, &rom_status);
0162     if (retval)
0163         return false;
0164 
0165     rom_status &= RENESAS_ROM_STATUS_ROM_EXISTS;
0166     if (rom_status) {
0167         dev_dbg(&pdev->dev, "External ROM exists\n");
0168         return true; /* External ROM exists */
0169     }
0170 
0171     return false;
0172 }
0173 
0174 static int renesas_check_rom_state(struct pci_dev *pdev)
0175 {
0176     u16 rom_state;
0177     u32 version;
0178     int err;
0179 
0180     /* check FW version */
0181     err = pci_read_config_dword(pdev, RENESAS_FW_VERSION, &version);
0182     if (err)
0183         return pcibios_err_to_errno(err);
0184 
0185     version &= RENESAS_FW_VERSION_FIELD;
0186     version = version >> RENESAS_FW_VERSION_OFFSET;
0187     dev_dbg(&pdev->dev, "Found ROM version: %x\n", version);
0188 
0189     /*
0190      * Test if ROM is present and loaded, if so we can skip everything
0191      */
0192     err = pci_read_config_word(pdev, RENESAS_ROM_STATUS, &rom_state);
0193     if (err)
0194         return pcibios_err_to_errno(err);
0195 
0196     if (rom_state & RENESAS_ROM_STATUS_ROM_EXISTS) {
0197         /* ROM exists */
0198         dev_dbg(&pdev->dev, "ROM exists\n");
0199 
0200         /* Check the "Result Code" Bits (6:4) and act accordingly */
0201         switch (rom_state & RENESAS_ROM_STATUS_RESULT) {
0202         case RENESAS_ROM_STATUS_SUCCESS:
0203             return 0;
0204 
0205         case RENESAS_ROM_STATUS_NO_RESULT: /* No result yet */
0206             dev_dbg(&pdev->dev, "Unknown ROM status ...\n");
0207             return -ENOENT;
0208 
0209         case RENESAS_ROM_STATUS_ERROR: /* Error State */
0210         default: /* All other states are marked as "Reserved states" */
0211             dev_err(&pdev->dev, "Invalid ROM..");
0212             break;
0213         }
0214     }
0215 
0216     return -EIO;
0217 }
0218 
0219 static int renesas_fw_check_running(struct pci_dev *pdev)
0220 {
0221     u8 fw_state;
0222     int err;
0223 
0224     /*
0225      * Test if the device is actually needing the firmware. As most
0226      * BIOSes will initialize the device for us. If the device is
0227      * initialized.
0228      */
0229     err = pci_read_config_byte(pdev, RENESAS_FW_STATUS, &fw_state);
0230     if (err)
0231         return pcibios_err_to_errno(err);
0232 
0233     /*
0234      * Check if "FW Download Lock" is locked. If it is and the FW is
0235      * ready we can simply continue. If the FW is not ready, we have
0236      * to give up.
0237      */
0238     if (fw_state & RENESAS_FW_STATUS_LOCK) {
0239         dev_dbg(&pdev->dev, "FW Download Lock is engaged.");
0240 
0241         if (fw_state & RENESAS_FW_STATUS_SUCCESS)
0242             return 0;
0243 
0244         dev_err(&pdev->dev,
0245             "FW Download Lock is set and FW is not ready. Giving Up.");
0246         return -EIO;
0247     }
0248 
0249     /*
0250      * Check if "FW Download Enable" is set. If someone (us?) tampered
0251      * with it and it can't be reset, we have to give up too... and
0252      * ask for a forgiveness and a reboot.
0253      */
0254     if (fw_state & RENESAS_FW_STATUS_DOWNLOAD_ENABLE) {
0255         dev_err(&pdev->dev,
0256             "FW Download Enable is stale. Giving Up (poweroff/reboot needed).");
0257         return -EIO;
0258     }
0259 
0260     /* Otherwise, Check the "Result Code" Bits (6:4) and act accordingly */
0261     switch (fw_state & RENESAS_FW_STATUS_RESULT) {
0262     case 0: /* No result yet */
0263         dev_dbg(&pdev->dev, "FW is not ready/loaded yet.");
0264 
0265         /* tell the caller, that this device needs the firmware. */
0266         return 1;
0267 
0268     case RENESAS_FW_STATUS_SUCCESS: /* Success, device should be working. */
0269         dev_dbg(&pdev->dev, "FW is ready.");
0270         return 0;
0271 
0272     case RENESAS_FW_STATUS_ERROR: /* Error State */
0273         dev_err(&pdev->dev,
0274             "hardware is in an error state. Giving up (poweroff/reboot needed).");
0275         return -ENODEV;
0276 
0277     default: /* All other states are marked as "Reserved states" */
0278         dev_err(&pdev->dev,
0279             "hardware is in an invalid state %lx. Giving up (poweroff/reboot needed).",
0280             (fw_state & RENESAS_FW_STATUS_RESULT) >> 4);
0281         return -EINVAL;
0282     }
0283 }
0284 
0285 static int renesas_fw_download(struct pci_dev *pdev,
0286                    const struct firmware *fw)
0287 {
0288     const u32 *fw_data = (const u32 *)fw->data;
0289     size_t i;
0290     int err;
0291     u8 fw_status;
0292 
0293     /*
0294      * For more information and the big picture: please look at the
0295      * "Firmware Download Sequence" in "7.1 FW Download Interface"
0296      * of R19UH0078EJ0500 Rev.5.00 page 131
0297      */
0298 
0299     /*
0300      * 0. Set "FW Download Enable" bit in the
0301      * "FW Download Control & Status Register" at 0xF4
0302      */
0303     err = pci_write_config_byte(pdev, RENESAS_FW_STATUS,
0304                     RENESAS_FW_STATUS_DOWNLOAD_ENABLE);
0305     if (err)
0306         return pcibios_err_to_errno(err);
0307 
0308     /* 1 - 10 follow one step after the other. */
0309     for (i = 0; i < fw->size / 4; i++) {
0310         err = renesas_fw_download_image(pdev, fw_data, i, false);
0311         if (err) {
0312             dev_err(&pdev->dev,
0313                 "Firmware Download Step %zd failed at position %zd bytes with (%d).",
0314                 i, i * 4, err);
0315             return err;
0316         }
0317     }
0318 
0319     /*
0320      * This sequence continues until the last data is written to
0321      * "DATA0" or "DATA1". Naturally, we wait until "SET DATA0/1"
0322      * is cleared by the hardware beforehand.
0323      */
0324     for (i = 0; i < RENESAS_RETRY; i++) {
0325         err = pci_read_config_byte(pdev, RENESAS_FW_STATUS_MSB,
0326                        &fw_status);
0327         if (err)
0328             return pcibios_err_to_errno(err);
0329         if (!(fw_status & (BIT(0) | BIT(1))))
0330             break;
0331 
0332         udelay(RENESAS_DELAY);
0333     }
0334     if (i == RENESAS_RETRY)
0335         dev_warn(&pdev->dev, "Final Firmware Download step timed out.");
0336 
0337     /*
0338      * 11. After finishing writing the last data of FW, the
0339      * System Software must clear "FW Download Enable"
0340      */
0341     err = pci_write_config_byte(pdev, RENESAS_FW_STATUS, 0);
0342     if (err)
0343         return pcibios_err_to_errno(err);
0344 
0345     /* 12. Read "Result Code" and confirm it is good. */
0346     for (i = 0; i < RENESAS_RETRY; i++) {
0347         err = pci_read_config_byte(pdev, RENESAS_FW_STATUS, &fw_status);
0348         if (err)
0349             return pcibios_err_to_errno(err);
0350         if (fw_status & RENESAS_FW_STATUS_SUCCESS)
0351             break;
0352 
0353         udelay(RENESAS_DELAY);
0354     }
0355     if (i == RENESAS_RETRY) {
0356         /* Timed out / Error - let's see if we can fix this */
0357         err = renesas_fw_check_running(pdev);
0358         switch (err) {
0359         case 0: /*
0360              * we shouldn't end up here.
0361              * maybe it took a little bit longer.
0362              * But all should be well?
0363              */
0364             break;
0365 
0366         case 1: /* (No result yet! */
0367             dev_err(&pdev->dev, "FW Load timedout");
0368             return -ETIMEDOUT;
0369 
0370         default:
0371             return err;
0372         }
0373     }
0374 
0375     return 0;
0376 }
0377 
0378 static void renesas_rom_erase(struct pci_dev *pdev)
0379 {
0380     int retval, i;
0381     u8 status;
0382 
0383     dev_dbg(&pdev->dev, "Performing ROM Erase...\n");
0384     retval = pci_write_config_dword(pdev, RENESAS_DATA0,
0385                     RENESAS_ROM_ERASE_MAGIC);
0386     if (retval) {
0387         dev_err(&pdev->dev, "ROM erase, magic word write failed: %d\n",
0388             pcibios_err_to_errno(retval));
0389         return;
0390     }
0391 
0392     retval = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
0393     if (retval) {
0394         dev_err(&pdev->dev, "ROM status read failed: %d\n",
0395             pcibios_err_to_errno(retval));
0396         return;
0397     }
0398     status |= RENESAS_ROM_STATUS_ERASE;
0399     retval = pci_write_config_byte(pdev, RENESAS_ROM_STATUS, status);
0400     if (retval) {
0401         dev_err(&pdev->dev, "ROM erase set word write failed\n");
0402         return;
0403     }
0404 
0405     /* sleep a bit while ROM is erased */
0406     msleep(20);
0407 
0408     for (i = 0; i < RENESAS_RETRY; i++) {
0409         retval = pci_read_config_byte(pdev, RENESAS_ROM_STATUS,
0410                           &status);
0411         status &= RENESAS_ROM_STATUS_ERASE;
0412         if (!status)
0413             break;
0414 
0415         mdelay(RENESAS_DELAY);
0416     }
0417 
0418     if (i == RENESAS_RETRY)
0419         dev_dbg(&pdev->dev, "Chip erase timedout: %x\n", status);
0420 
0421     dev_dbg(&pdev->dev, "ROM Erase... Done success\n");
0422 }
0423 
0424 static bool renesas_setup_rom(struct pci_dev *pdev, const struct firmware *fw)
0425 {
0426     const u32 *fw_data = (const u32 *)fw->data;
0427     int err, i;
0428     u8 status;
0429 
0430     /* 2. Write magic word to Data0 */
0431     err = pci_write_config_dword(pdev, RENESAS_DATA0,
0432                      RENESAS_ROM_WRITE_MAGIC);
0433     if (err)
0434         return false;
0435 
0436     /* 3. Set External ROM access */
0437     err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS,
0438                     RENESAS_ROM_STATUS_ACCESS);
0439     if (err)
0440         goto remove_bypass;
0441 
0442     /* 4. Check the result */
0443     err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
0444     if (err)
0445         goto remove_bypass;
0446     status &= GENMASK(6, 4);
0447     if (status) {
0448         dev_err(&pdev->dev,
0449             "setting external rom failed: %x\n", status);
0450         goto remove_bypass;
0451     }
0452 
0453     /* 5 to 16 Write FW to DATA0/1 while checking SetData0/1 */
0454     for (i = 0; i < fw->size / 4; i++) {
0455         err = renesas_fw_download_image(pdev, fw_data, i, true);
0456         if (err) {
0457             dev_err(&pdev->dev,
0458                 "ROM Download Step %d failed at position %d bytes with (%d)\n",
0459                  i, i * 4, err);
0460             goto remove_bypass;
0461         }
0462     }
0463 
0464     /*
0465      * wait till DATA0/1 is cleared
0466      */
0467     for (i = 0; i < RENESAS_RETRY; i++) {
0468         err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS_MSB,
0469                        &status);
0470         if (err)
0471             goto remove_bypass;
0472         if (!(status & (BIT(0) | BIT(1))))
0473             break;
0474 
0475         udelay(RENESAS_DELAY);
0476     }
0477     if (i == RENESAS_RETRY) {
0478         dev_err(&pdev->dev, "Final Firmware ROM Download step timed out\n");
0479         goto remove_bypass;
0480     }
0481 
0482     /* 17. Remove bypass */
0483     err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS, 0);
0484     if (err)
0485         return false;
0486 
0487     udelay(10);
0488 
0489     /* 18. check result */
0490     for (i = 0; i < RENESAS_RETRY; i++) {
0491         err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
0492         if (err) {
0493             dev_err(&pdev->dev, "Read ROM status failed:%d\n",
0494                 pcibios_err_to_errno(err));
0495             return false;
0496         }
0497         status &= RENESAS_ROM_STATUS_RESULT;
0498         if (status ==  RENESAS_ROM_STATUS_SUCCESS) {
0499             dev_dbg(&pdev->dev, "Download ROM success\n");
0500             break;
0501         }
0502         udelay(RENESAS_DELAY);
0503     }
0504     if (i == RENESAS_RETRY) { /* Timed out */
0505         dev_err(&pdev->dev,
0506             "Download to external ROM TO: %x\n", status);
0507         return false;
0508     }
0509 
0510     dev_dbg(&pdev->dev, "Download to external ROM succeeded\n");
0511 
0512     /* Last step set Reload */
0513     err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS,
0514                     RENESAS_ROM_STATUS_RELOAD);
0515     if (err) {
0516         dev_err(&pdev->dev, "Set ROM execute failed: %d\n",
0517             pcibios_err_to_errno(err));
0518         return false;
0519     }
0520 
0521     /*
0522      * wait till Reload is cleared
0523      */
0524     for (i = 0; i < RENESAS_RETRY; i++) {
0525         err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
0526         if (err)
0527             return false;
0528         if (!(status & RENESAS_ROM_STATUS_RELOAD))
0529             break;
0530 
0531         udelay(RENESAS_DELAY);
0532     }
0533     if (i == RENESAS_RETRY) {
0534         dev_err(&pdev->dev, "ROM Exec timed out: %x\n", status);
0535         return false;
0536     }
0537 
0538     return true;
0539 
0540 remove_bypass:
0541     pci_write_config_byte(pdev, RENESAS_ROM_STATUS, 0);
0542     return false;
0543 }
0544 
0545 static int renesas_load_fw(struct pci_dev *pdev, const struct firmware *fw)
0546 {
0547     int err = 0;
0548     bool rom;
0549 
0550     /* Check if the device has external ROM */
0551     rom = renesas_check_rom(pdev);
0552     if (rom) {
0553         /* perform chip erase first */
0554         renesas_rom_erase(pdev);
0555 
0556         /* lets try loading fw on ROM first */
0557         rom = renesas_setup_rom(pdev, fw);
0558         if (!rom) {
0559             dev_dbg(&pdev->dev,
0560                 "ROM load failed, falling back on FW load\n");
0561         } else {
0562             dev_dbg(&pdev->dev,
0563                 "ROM load success\n");
0564             goto exit;
0565         }
0566     }
0567 
0568     err = renesas_fw_download(pdev, fw);
0569 
0570 exit:
0571     if (err)
0572         dev_err(&pdev->dev, "firmware failed to download (%d).", err);
0573     return err;
0574 }
0575 
0576 int renesas_xhci_check_request_fw(struct pci_dev *pdev,
0577                   const struct pci_device_id *id)
0578 {
0579     struct xhci_driver_data *driver_data =
0580             (struct xhci_driver_data *)id->driver_data;
0581     const char *fw_name = driver_data->firmware;
0582     const struct firmware *fw;
0583     bool has_rom;
0584     int err;
0585 
0586     /* Check if device has ROM and loaded, if so skip everything */
0587     has_rom = renesas_check_rom(pdev);
0588     if (has_rom) {
0589         err = renesas_check_rom_state(pdev);
0590         if (!err)
0591             return 0;
0592         else if (err != -ENOENT)
0593             has_rom = false;
0594     }
0595 
0596     err = renesas_fw_check_running(pdev);
0597     /* Continue ahead, if the firmware is already running. */
0598     if (!err)
0599         return 0;
0600 
0601     /* no firmware interface available */
0602     if (err != 1)
0603         return has_rom ? 0 : err;
0604 
0605     pci_dev_get(pdev);
0606     err = firmware_request_nowarn(&fw, fw_name, &pdev->dev);
0607     pci_dev_put(pdev);
0608     if (err) {
0609         if (has_rom) {
0610             dev_info(&pdev->dev, "failed to load firmware %s, fallback to ROM\n",
0611                  fw_name);
0612             return 0;
0613         }
0614         dev_err(&pdev->dev, "failed to load firmware %s: %d\n",
0615             fw_name, err);
0616         return err;
0617     }
0618 
0619     err = renesas_fw_verify(fw->data, fw->size);
0620     if (err)
0621         goto exit;
0622 
0623     err = renesas_load_fw(pdev, fw);
0624 exit:
0625     release_firmware(fw);
0626     return err;
0627 }
0628 EXPORT_SYMBOL_GPL(renesas_xhci_check_request_fw);
0629 
0630 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!