1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (C) 2019-2020 Linaro Limited */
4 #include <linux/acpi.h>
5 #include <linux/firmware.h>
6 #include <linux/module.h>
8 #include <linux/slab.h>
9 #include <asm/unaligned.h>
12 #include "xhci-trace.h"
15 #define RENESAS_FW_VERSION 0x6C
16 #define RENESAS_ROM_CONFIG 0xF0
17 #define RENESAS_FW_STATUS 0xF4
18 #define RENESAS_FW_STATUS_MSB 0xF5
19 #define RENESAS_ROM_STATUS 0xF6
20 #define RENESAS_ROM_STATUS_MSB 0xF7
21 #define RENESAS_DATA0 0xF8
22 #define RENESAS_DATA1 0xFC
24 #define RENESAS_FW_VERSION_FIELD GENMASK(23, 7)
25 #define RENESAS_FW_VERSION_OFFSET 8
27 #define RENESAS_FW_STATUS_DOWNLOAD_ENABLE BIT(0)
28 #define RENESAS_FW_STATUS_LOCK BIT(1)
29 #define RENESAS_FW_STATUS_RESULT GENMASK(6, 4)
30 #define RENESAS_FW_STATUS_INVALID 0
31 #define RENESAS_FW_STATUS_SUCCESS BIT(4)
32 #define RENESAS_FW_STATUS_ERROR BIT(5)
33 #define RENESAS_FW_STATUS_SET_DATA0 BIT(8)
34 #define RENESAS_FW_STATUS_SET_DATA1 BIT(9)
36 #define RENESAS_ROM_STATUS_ACCESS BIT(0)
37 #define RENESAS_ROM_STATUS_ERASE BIT(1)
38 #define RENESAS_ROM_STATUS_RELOAD BIT(2)
39 #define RENESAS_ROM_STATUS_RESULT GENMASK(6, 4)
40 #define RENESAS_ROM_STATUS_NO_RESULT 0
41 #define RENESAS_ROM_STATUS_SUCCESS BIT(4)
42 #define RENESAS_ROM_STATUS_ERROR BIT(5)
43 #define RENESAS_ROM_STATUS_SET_DATA0 BIT(8)
44 #define RENESAS_ROM_STATUS_SET_DATA1 BIT(9)
45 #define RENESAS_ROM_STATUS_ROM_EXISTS BIT(15)
47 #define RENESAS_ROM_ERASE_MAGIC 0x5A65726F
48 #define RENESAS_ROM_WRITE_MAGIC 0x53524F4D
50 #define RENESAS_RETRY 10000
51 #define RENESAS_DELAY 10
53 static int renesas_fw_download_image(struct pci_dev *dev,
54 const u32 *fw, size_t step, bool rom)
63 status_reg = RENESAS_ROM_STATUS_MSB;
65 status_reg = RENESAS_FW_STATUS_MSB;
68 * The hardware does alternate between two 32-bit pages.
69 * (This is because each row of the firmware is 8 bytes).
71 * for even steps we use DATA0, for odd steps DATA1.
73 data0_or_data1 = (step & 1) == 1;
75 /* step+1. Read "Set DATAX" and confirm it is cleared. */
76 for (i = 0; i < RENESAS_RETRY; i++) {
77 err = pci_read_config_byte(dev, status_reg, &fw_status);
79 dev_err(&dev->dev, "Read Status failed: %d\n",
80 pcibios_err_to_errno(err));
81 return pcibios_err_to_errno(err);
83 if (!(fw_status & BIT(data0_or_data1)))
86 udelay(RENESAS_DELAY);
88 if (i == RENESAS_RETRY) {
89 dev_err(&dev->dev, "Timeout for Set DATAX step: %zd\n", step);
94 * step+2. Write FW data to "DATAX".
95 * "LSB is left" => force little endian
97 err = pci_write_config_dword(dev, data0_or_data1 ?
98 RENESAS_DATA1 : RENESAS_DATA0,
99 (__force u32)cpu_to_le32(fw[step]));
101 dev_err(&dev->dev, "Write to DATAX failed: %d\n",
102 pcibios_err_to_errno(err));
103 return pcibios_err_to_errno(err);
108 /* step+3. Set "Set DATAX". */
109 err = pci_write_config_byte(dev, status_reg, BIT(data0_or_data1));
111 dev_err(&dev->dev, "Write config for DATAX failed: %d\n",
112 pcibios_err_to_errno(err));
113 return pcibios_err_to_errno(err);
119 static int renesas_fw_verify(const void *fw_data,
122 u16 fw_version_pointer;
126 * The Firmware's Data Format is describe in
127 * "6.3 Data Format" R19UH0078EJ0500 Rev.5.00 page 124
131 * The bootrom chips of the big brother have sizes up to 64k, let's
132 * assume that's the biggest the firmware can get.
134 if (length < 0x1000 || length >= 0x10000) {
135 pr_err("firmware is size %zd is not (4k - 64k).",
140 /* The First 2 bytes are fixed value (55aa). "LSB on Left" */
141 if (get_unaligned_le16(fw_data) != 0x55aa) {
142 pr_err("no valid firmware header found.");
146 /* verify the firmware version position and print it. */
147 fw_version_pointer = get_unaligned_le16(fw_data + 4);
148 if (fw_version_pointer + 2 >= length) {
149 pr_err("fw ver pointer is outside of the firmware image");
153 fw_version = get_unaligned_le16(fw_data + fw_version_pointer);
154 pr_err("got firmware version: %02x.", fw_version);
159 static bool renesas_check_rom(struct pci_dev *pdev)
164 /* Check if external ROM exists */
165 retval = pci_read_config_word(pdev, RENESAS_ROM_STATUS, &rom_status);
169 rom_status &= RENESAS_ROM_STATUS_ROM_EXISTS;
171 dev_dbg(&pdev->dev, "External ROM exists\n");
172 return true; /* External ROM exists */
178 static int renesas_check_rom_state(struct pci_dev *pdev)
184 /* check FW version */
185 err = pci_read_config_dword(pdev, RENESAS_FW_VERSION, &version);
187 return pcibios_err_to_errno(err);
189 version &= RENESAS_FW_VERSION_FIELD;
190 version = version >> RENESAS_FW_VERSION_OFFSET;
191 dev_dbg(&pdev->dev, "Found ROM version: %x\n", version);
194 * Test if ROM is present and loaded, if so we can skip everything
196 err = pci_read_config_word(pdev, RENESAS_ROM_STATUS, &rom_state);
198 return pcibios_err_to_errno(err);
200 if (rom_state & BIT(15)) {
202 dev_dbg(&pdev->dev, "ROM exists\n");
204 /* Check the "Result Code" Bits (6:4) and act accordingly */
205 switch (rom_state & RENESAS_ROM_STATUS_RESULT) {
206 case RENESAS_ROM_STATUS_SUCCESS:
209 case RENESAS_ROM_STATUS_NO_RESULT: /* No result yet */
210 dev_dbg(&pdev->dev, "Unknown ROM status ...\n");
213 case RENESAS_ROM_STATUS_ERROR: /* Error State */
214 default: /* All other states are marked as "Reserved states" */
215 dev_err(&pdev->dev, "Invalid ROM..");
223 static int renesas_fw_check_running(struct pci_dev *pdev)
229 * Test if the device is actually needing the firmware. As most
230 * BIOSes will initialize the device for us. If the device is
233 err = pci_read_config_byte(pdev, RENESAS_FW_STATUS, &fw_state);
235 return pcibios_err_to_errno(err);
238 * Check if "FW Download Lock" is locked. If it is and the FW is
239 * ready we can simply continue. If the FW is not ready, we have
242 if (fw_state & RENESAS_FW_STATUS_LOCK) {
243 dev_dbg(&pdev->dev, "FW Download Lock is engaged.");
245 if (fw_state & RENESAS_FW_STATUS_SUCCESS)
249 "FW Download Lock is set and FW is not ready. Giving Up.");
254 * Check if "FW Download Enable" is set. If someone (us?) tampered
255 * with it and it can't be reset, we have to give up too... and
256 * ask for a forgiveness and a reboot.
258 if (fw_state & RENESAS_FW_STATUS_DOWNLOAD_ENABLE) {
260 "FW Download Enable is stale. Giving Up (poweroff/reboot needed).");
264 /* Otherwise, Check the "Result Code" Bits (6:4) and act accordingly */
265 switch (fw_state & RENESAS_FW_STATUS_RESULT) {
266 case 0: /* No result yet */
267 dev_dbg(&pdev->dev, "FW is not ready/loaded yet.");
269 /* tell the caller, that this device needs the firmware. */
272 case RENESAS_FW_STATUS_SUCCESS: /* Success, device should be working. */
273 dev_dbg(&pdev->dev, "FW is ready.");
276 case RENESAS_FW_STATUS_ERROR: /* Error State */
278 "hardware is in an error state. Giving up (poweroff/reboot needed).");
281 default: /* All other states are marked as "Reserved states" */
283 "hardware is in an invalid state %lx. Giving up (poweroff/reboot needed).",
284 (fw_state & RENESAS_FW_STATUS_RESULT) >> 4);
289 static int renesas_fw_download(struct pci_dev *pdev,
290 const struct firmware *fw)
292 const u32 *fw_data = (const u32 *)fw->data;
298 * For more information and the big picture: please look at the
299 * "Firmware Download Sequence" in "7.1 FW Download Interface"
300 * of R19UH0078EJ0500 Rev.5.00 page 131
304 * 0. Set "FW Download Enable" bit in the
305 * "FW Download Control & Status Register" at 0xF4
307 err = pci_write_config_byte(pdev, RENESAS_FW_STATUS,
308 RENESAS_FW_STATUS_DOWNLOAD_ENABLE);
310 return pcibios_err_to_errno(err);
312 /* 1 - 10 follow one step after the other. */
313 for (i = 0; i < fw->size / 4; i++) {
314 err = renesas_fw_download_image(pdev, fw_data, i, false);
317 "Firmware Download Step %zd failed at position %zd bytes with (%d).",
324 * This sequence continues until the last data is written to
325 * "DATA0" or "DATA1". Naturally, we wait until "SET DATA0/1"
326 * is cleared by the hardware beforehand.
328 for (i = 0; i < RENESAS_RETRY; i++) {
329 err = pci_read_config_byte(pdev, RENESAS_FW_STATUS_MSB,
332 return pcibios_err_to_errno(err);
333 if (!(fw_status & (BIT(0) | BIT(1))))
336 udelay(RENESAS_DELAY);
338 if (i == RENESAS_RETRY)
339 dev_warn(&pdev->dev, "Final Firmware Download step timed out.");
342 * 11. After finishing writing the last data of FW, the
343 * System Software must clear "FW Download Enable"
345 err = pci_write_config_byte(pdev, RENESAS_FW_STATUS, 0);
347 return pcibios_err_to_errno(err);
349 /* 12. Read "Result Code" and confirm it is good. */
350 for (i = 0; i < RENESAS_RETRY; i++) {
351 err = pci_read_config_byte(pdev, RENESAS_FW_STATUS, &fw_status);
353 return pcibios_err_to_errno(err);
354 if (fw_status & RENESAS_FW_STATUS_SUCCESS)
357 udelay(RENESAS_DELAY);
359 if (i == RENESAS_RETRY) {
360 /* Timed out / Error - let's see if we can fix this */
361 err = renesas_fw_check_running(pdev);
364 * we shouldn't end up here.
365 * maybe it took a little bit longer.
366 * But all should be well?
370 case 1: /* (No result yet! */
371 dev_err(&pdev->dev, "FW Load timedout");
382 static void renesas_rom_erase(struct pci_dev *pdev)
387 dev_dbg(&pdev->dev, "Performing ROM Erase...\n");
388 retval = pci_write_config_dword(pdev, RENESAS_DATA0,
389 RENESAS_ROM_ERASE_MAGIC);
391 dev_err(&pdev->dev, "ROM erase, magic word write failed: %d\n",
392 pcibios_err_to_errno(retval));
396 retval = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
398 dev_err(&pdev->dev, "ROM status read failed: %d\n",
399 pcibios_err_to_errno(retval));
402 status |= RENESAS_ROM_STATUS_ERASE;
403 retval = pci_write_config_byte(pdev, RENESAS_ROM_STATUS, status);
405 dev_err(&pdev->dev, "ROM erase set word write failed\n");
409 /* sleep a bit while ROM is erased */
412 for (i = 0; i < RENESAS_RETRY; i++) {
413 retval = pci_read_config_byte(pdev, RENESAS_ROM_STATUS,
415 status &= RENESAS_ROM_STATUS_ERASE;
419 mdelay(RENESAS_DELAY);
422 if (i == RENESAS_RETRY)
423 dev_dbg(&pdev->dev, "Chip erase timedout: %x\n", status);
425 dev_dbg(&pdev->dev, "ROM Erase... Done success\n");
428 static bool renesas_setup_rom(struct pci_dev *pdev, const struct firmware *fw)
430 const u32 *fw_data = (const u32 *)fw->data;
434 /* 2. Write magic word to Data0 */
435 err = pci_write_config_dword(pdev, RENESAS_DATA0,
436 RENESAS_ROM_WRITE_MAGIC);
440 /* 3. Set External ROM access */
441 err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS,
442 RENESAS_ROM_STATUS_ACCESS);
446 /* 4. Check the result */
447 err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
450 status &= GENMASK(6, 4);
453 "setting external rom failed: %x\n", status);
457 /* 5 to 16 Write FW to DATA0/1 while checking SetData0/1 */
458 for (i = 0; i < fw->size / 4; i++) {
459 err = renesas_fw_download_image(pdev, fw_data, i, true);
462 "ROM Download Step %d failed at position %d bytes with (%d)\n",
469 * wait till DATA0/1 is cleared
471 for (i = 0; i < RENESAS_RETRY; i++) {
472 err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS_MSB,
476 if (!(status & (BIT(0) | BIT(1))))
479 udelay(RENESAS_DELAY);
481 if (i == RENESAS_RETRY) {
482 dev_err(&pdev->dev, "Final Firmware ROM Download step timed out\n");
486 /* 17. Remove bypass */
487 err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS, 0);
493 /* 18. check result */
494 for (i = 0; i < RENESAS_RETRY; i++) {
495 err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
497 dev_err(&pdev->dev, "Read ROM status failed:%d\n",
498 pcibios_err_to_errno(err));
501 status &= RENESAS_ROM_STATUS_RESULT;
502 if (status == RENESAS_ROM_STATUS_SUCCESS) {
503 dev_dbg(&pdev->dev, "Download ROM success\n");
506 udelay(RENESAS_DELAY);
508 if (i == RENESAS_RETRY) { /* Timed out */
510 "Download to external ROM TO: %x\n", status);
514 dev_dbg(&pdev->dev, "Download to external ROM succeeded\n");
516 /* Last step set Reload */
517 err = pci_write_config_byte(pdev, RENESAS_ROM_STATUS,
518 RENESAS_ROM_STATUS_RELOAD);
520 dev_err(&pdev->dev, "Set ROM execute failed: %d\n",
521 pcibios_err_to_errno(err));
526 * wait till Reload is cleared
528 for (i = 0; i < RENESAS_RETRY; i++) {
529 err = pci_read_config_byte(pdev, RENESAS_ROM_STATUS, &status);
532 if (!(status & RENESAS_ROM_STATUS_RELOAD))
535 udelay(RENESAS_DELAY);
537 if (i == RENESAS_RETRY) {
538 dev_err(&pdev->dev, "ROM Exec timed out: %x\n", status);
545 pci_write_config_byte(pdev, RENESAS_ROM_STATUS, 0);
549 static int renesas_load_fw(struct pci_dev *pdev, const struct firmware *fw)
554 /* Check if the device has external ROM */
555 rom = renesas_check_rom(pdev);
557 /* perform chip erase first */
558 renesas_rom_erase(pdev);
560 /* lets try loading fw on ROM first */
561 rom = renesas_setup_rom(pdev, fw);
564 "ROM load failed, falling back on FW load\n");
567 "ROM load success\n");
572 err = renesas_fw_download(pdev, fw);
576 dev_err(&pdev->dev, "firmware failed to download (%d).", err);
580 int renesas_xhci_check_request_fw(struct pci_dev *pdev,
581 const struct pci_device_id *id)
583 struct xhci_driver_data *driver_data =
584 (struct xhci_driver_data *)id->driver_data;
585 const char *fw_name = driver_data->firmware;
586 const struct firmware *fw;
590 /* Check if device has ROM and loaded, if so skip everything */
591 has_rom = renesas_check_rom(pdev);
593 err = renesas_check_rom_state(pdev);
596 else if (err != -ENOENT)
600 err = renesas_fw_check_running(pdev);
601 /* Continue ahead, if the firmware is already running. */
605 /* no firmware interface available */
607 return has_rom ? 0 : err;
610 err = firmware_reject_nowarn(&fw, fw_name, &pdev->dev);
614 dev_info(&pdev->dev, "failed to load firmware %s, fallback to ROM\n",
618 dev_err(&pdev->dev, "failed to load firmware %s: %d\n",
623 err = renesas_fw_verify(fw->data, fw->size);
627 err = renesas_load_fw(pdev, fw);
629 release_firmware(fw);
632 EXPORT_SYMBOL_GPL(renesas_xhci_check_request_fw);
634 void renesas_xhci_pci_exit(struct pci_dev *dev)
637 EXPORT_SYMBOL_GPL(renesas_xhci_pci_exit);
639 MODULE_LICENSE("GPL v2");