1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* Copyright (C) 2019-2020 Linaro Limited */ |
3 | |
4 | #include <linux/acpi.h> |
5 | #include <linux/firmware.h> |
6 | #include <linux/module.h> |
7 | #include <linux/pci.h> |
8 | #include <linux/slab.h> |
9 | #include <asm/unaligned.h> |
10 | |
11 | #include "xhci.h" |
12 | #include "xhci-trace.h" |
13 | #include "xhci-pci.h" |
14 | |
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 |
23 | |
24 | #define RENESAS_FW_VERSION_FIELD GENMASK(23, 7) |
25 | #define RENESAS_FW_VERSION_OFFSET 8 |
26 | |
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) |
35 | |
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) |
46 | |
47 | #define RENESAS_ROM_ERASE_MAGIC 0x5A65726F |
48 | #define RENESAS_ROM_WRITE_MAGIC 0x53524F4D |
49 | |
50 | #define RENESAS_RETRY 10000 |
51 | #define RENESAS_DELAY 10 |
52 | |
53 | static int renesas_fw_download_image(struct pci_dev *dev, |
54 | const u32 *fw, size_t step, bool rom) |
55 | { |
56 | size_t i; |
57 | int err; |
58 | u8 fw_status; |
59 | bool data0_or_data1; |
60 | u32 status_reg; |
61 | |
62 | if (rom) |
63 | status_reg = RENESAS_ROM_STATUS_MSB; |
64 | else |
65 | status_reg = RENESAS_FW_STATUS_MSB; |
66 | |
67 | /* |
68 | * The hardware does alternate between two 32-bit pages. |
69 | * (This is because each row of the firmware is 8 bytes). |
70 | * |
71 | * for even steps we use DATA0, for odd steps DATA1. |
72 | */ |
73 | data0_or_data1 = (step & 1) == 1; |
74 | |
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, where: status_reg, val: &fw_status); |
78 | if (err) { |
79 | dev_err(&dev->dev, "Read Status failed: %d\n" , |
80 | pcibios_err_to_errno(err)); |
81 | return pcibios_err_to_errno(err); |
82 | } |
83 | if (!(fw_status & BIT(data0_or_data1))) |
84 | break; |
85 | |
86 | udelay(RENESAS_DELAY); |
87 | } |
88 | if (i == RENESAS_RETRY) { |
89 | dev_err(&dev->dev, "Timeout for Set DATAX step: %zd\n" , step); |
90 | return -ETIMEDOUT; |
91 | } |
92 | |
93 | /* |
94 | * step+2. Write FW data to "DATAX". |
95 | * "LSB is left" => force little endian |
96 | */ |
97 | err = pci_write_config_dword(dev, where: data0_or_data1 ? |
98 | RENESAS_DATA1 : RENESAS_DATA0, |
99 | val: (__force u32)cpu_to_le32(fw[step])); |
100 | if (err) { |
101 | dev_err(&dev->dev, "Write to DATAX failed: %d\n" , |
102 | pcibios_err_to_errno(err)); |
103 | return pcibios_err_to_errno(err); |
104 | } |
105 | |
106 | udelay(100); |
107 | |
108 | /* step+3. Set "Set DATAX". */ |
109 | err = pci_write_config_byte(dev, where: status_reg, BIT(data0_or_data1)); |
110 | if (err) { |
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); |
114 | } |
115 | |
116 | return 0; |
117 | } |
118 | |
119 | static int renesas_fw_verify(const void *fw_data, |
120 | size_t length) |
121 | { |
122 | u16 fw_version_pointer; |
123 | |
124 | /* |
125 | * The Firmware's Data Format is describe in |
126 | * "6.3 Data Format" R19UH0078EJ0500 Rev.5.00 page 124 |
127 | */ |
128 | |
129 | /* |
130 | * The bootrom chips of the big brother have sizes up to 64k, let's |
131 | * assume that's the biggest the firmware can get. |
132 | */ |
133 | if (length < 0x1000 || length >= 0x10000) { |
134 | pr_err("firmware is size %zd is not (4k - 64k)." , |
135 | length); |
136 | return -EINVAL; |
137 | } |
138 | |
139 | /* The First 2 bytes are fixed value (55aa). "LSB on Left" */ |
140 | if (get_unaligned_le16(p: fw_data) != 0x55aa) { |
141 | pr_err("no valid firmware header found." ); |
142 | return -EINVAL; |
143 | } |
144 | |
145 | /* verify the firmware version position and print it. */ |
146 | fw_version_pointer = get_unaligned_le16(p: fw_data + 4); |
147 | if (fw_version_pointer + 2 >= length) { |
148 | pr_err("fw ver pointer is outside of the firmware image" ); |
149 | return -EINVAL; |
150 | } |
151 | |
152 | return 0; |
153 | } |
154 | |
155 | static bool renesas_check_rom(struct pci_dev *pdev) |
156 | { |
157 | u16 rom_status; |
158 | int retval; |
159 | |
160 | /* Check if external ROM exists */ |
161 | retval = pci_read_config_word(dev: pdev, RENESAS_ROM_STATUS, val: &rom_status); |
162 | if (retval) |
163 | return false; |
164 | |
165 | rom_status &= RENESAS_ROM_STATUS_ROM_EXISTS; |
166 | if (rom_status) { |
167 | dev_dbg(&pdev->dev, "External ROM exists\n" ); |
168 | return true; /* External ROM exists */ |
169 | } |
170 | |
171 | return false; |
172 | } |
173 | |
174 | static int renesas_check_rom_state(struct pci_dev *pdev) |
175 | { |
176 | u16 rom_state; |
177 | u32 version; |
178 | int err; |
179 | |
180 | /* check FW version */ |
181 | err = pci_read_config_dword(dev: pdev, RENESAS_FW_VERSION, val: &version); |
182 | if (err) |
183 | return pcibios_err_to_errno(err); |
184 | |
185 | version &= RENESAS_FW_VERSION_FIELD; |
186 | version = version >> RENESAS_FW_VERSION_OFFSET; |
187 | dev_dbg(&pdev->dev, "Found ROM version: %x\n" , version); |
188 | |
189 | /* |
190 | * Test if ROM is present and loaded, if so we can skip everything |
191 | */ |
192 | err = pci_read_config_word(dev: pdev, RENESAS_ROM_STATUS, val: &rom_state); |
193 | if (err) |
194 | return pcibios_err_to_errno(err); |
195 | |
196 | if (rom_state & RENESAS_ROM_STATUS_ROM_EXISTS) { |
197 | /* ROM exists */ |
198 | dev_dbg(&pdev->dev, "ROM exists\n" ); |
199 | |
200 | /* Check the "Result Code" Bits (6:4) and act accordingly */ |
201 | switch (rom_state & RENESAS_ROM_STATUS_RESULT) { |
202 | case RENESAS_ROM_STATUS_SUCCESS: |
203 | return 0; |
204 | |
205 | case RENESAS_ROM_STATUS_NO_RESULT: /* No result yet */ |
206 | dev_dbg(&pdev->dev, "Unknown ROM status ...\n" ); |
207 | return -ENOENT; |
208 | |
209 | case RENESAS_ROM_STATUS_ERROR: /* Error State */ |
210 | default: /* All other states are marked as "Reserved states" */ |
211 | dev_err(&pdev->dev, "Invalid ROM.." ); |
212 | break; |
213 | } |
214 | } |
215 | |
216 | return -EIO; |
217 | } |
218 | |
219 | static int renesas_fw_check_running(struct pci_dev *pdev) |
220 | { |
221 | u8 fw_state; |
222 | int err; |
223 | |
224 | /* |
225 | * Test if the device is actually needing the firmware. As most |
226 | * BIOSes will initialize the device for us. If the device is |
227 | * initialized. |
228 | */ |
229 | err = pci_read_config_byte(dev: pdev, RENESAS_FW_STATUS, val: &fw_state); |
230 | if (err) |
231 | return pcibios_err_to_errno(err); |
232 | |
233 | /* |
234 | * Check if "FW Download Lock" is locked. If it is and the FW is |
235 | * ready we can simply continue. If the FW is not ready, we have |
236 | * to give up. |
237 | */ |
238 | if (fw_state & RENESAS_FW_STATUS_LOCK) { |
239 | dev_dbg(&pdev->dev, "FW Download Lock is engaged." ); |
240 | |
241 | if (fw_state & RENESAS_FW_STATUS_SUCCESS) |
242 | return 0; |
243 | |
244 | dev_err(&pdev->dev, |
245 | "FW Download Lock is set and FW is not ready. Giving Up." ); |
246 | return -EIO; |
247 | } |
248 | |
249 | /* |
250 | * Check if "FW Download Enable" is set. If someone (us?) tampered |
251 | * with it and it can't be reset, we have to give up too... and |
252 | * ask for a forgiveness and a reboot. |
253 | */ |
254 | if (fw_state & RENESAS_FW_STATUS_DOWNLOAD_ENABLE) { |
255 | dev_err(&pdev->dev, |
256 | "FW Download Enable is stale. Giving Up (poweroff/reboot needed)." ); |
257 | return -EIO; |
258 | } |
259 | |
260 | /* Otherwise, Check the "Result Code" Bits (6:4) and act accordingly */ |
261 | switch (fw_state & RENESAS_FW_STATUS_RESULT) { |
262 | case 0: /* No result yet */ |
263 | dev_dbg(&pdev->dev, "FW is not ready/loaded yet." ); |
264 | |
265 | /* tell the caller, that this device needs the firmware. */ |
266 | return 1; |
267 | |
268 | case RENESAS_FW_STATUS_SUCCESS: /* Success, device should be working. */ |
269 | dev_dbg(&pdev->dev, "FW is ready." ); |
270 | return 0; |
271 | |
272 | case RENESAS_FW_STATUS_ERROR: /* Error State */ |
273 | dev_err(&pdev->dev, |
274 | "hardware is in an error state. Giving up (poweroff/reboot needed)." ); |
275 | return -ENODEV; |
276 | |
277 | default: /* All other states are marked as "Reserved states" */ |
278 | dev_err(&pdev->dev, |
279 | "hardware is in an invalid state %lx. Giving up (poweroff/reboot needed)." , |
280 | (fw_state & RENESAS_FW_STATUS_RESULT) >> 4); |
281 | return -EINVAL; |
282 | } |
283 | } |
284 | |
285 | static int renesas_fw_download(struct pci_dev *pdev, |
286 | const struct firmware *fw) |
287 | { |
288 | const u32 *fw_data = (const u32 *)fw->data; |
289 | size_t i; |
290 | int err; |
291 | u8 fw_status; |
292 | |
293 | /* |
294 | * For more information and the big picture: please look at the |
295 | * "Firmware Download Sequence" in "7.1 FW Download Interface" |
296 | * of R19UH0078EJ0500 Rev.5.00 page 131 |
297 | */ |
298 | |
299 | /* |
300 | * 0. Set "FW Download Enable" bit in the |
301 | * "FW Download Control & Status Register" at 0xF4 |
302 | */ |
303 | err = pci_write_config_byte(dev: pdev, RENESAS_FW_STATUS, |
304 | RENESAS_FW_STATUS_DOWNLOAD_ENABLE); |
305 | if (err) |
306 | return pcibios_err_to_errno(err); |
307 | |
308 | /* 1 - 10 follow one step after the other. */ |
309 | for (i = 0; i < fw->size / 4; i++) { |
310 | err = renesas_fw_download_image(dev: pdev, fw: fw_data, step: i, rom: false); |
311 | if (err) { |
312 | dev_err(&pdev->dev, |
313 | "Firmware Download Step %zd failed at position %zd bytes with (%d)." , |
314 | i, i * 4, err); |
315 | return err; |
316 | } |
317 | } |
318 | |
319 | /* |
320 | * This sequence continues until the last data is written to |
321 | * "DATA0" or "DATA1". Naturally, we wait until "SET DATA0/1" |
322 | * is cleared by the hardware beforehand. |
323 | */ |
324 | for (i = 0; i < RENESAS_RETRY; i++) { |
325 | err = pci_read_config_byte(dev: pdev, RENESAS_FW_STATUS_MSB, |
326 | val: &fw_status); |
327 | if (err) |
328 | return pcibios_err_to_errno(err); |
329 | if (!(fw_status & (BIT(0) | BIT(1)))) |
330 | break; |
331 | |
332 | udelay(RENESAS_DELAY); |
333 | } |
334 | if (i == RENESAS_RETRY) |
335 | dev_warn(&pdev->dev, "Final Firmware Download step timed out." ); |
336 | |
337 | /* |
338 | * 11. After finishing writing the last data of FW, the |
339 | * System Software must clear "FW Download Enable" |
340 | */ |
341 | err = pci_write_config_byte(dev: pdev, RENESAS_FW_STATUS, val: 0); |
342 | if (err) |
343 | return pcibios_err_to_errno(err); |
344 | |
345 | /* 12. Read "Result Code" and confirm it is good. */ |
346 | for (i = 0; i < RENESAS_RETRY; i++) { |
347 | err = pci_read_config_byte(dev: pdev, RENESAS_FW_STATUS, val: &fw_status); |
348 | if (err) |
349 | return pcibios_err_to_errno(err); |
350 | if (fw_status & RENESAS_FW_STATUS_SUCCESS) |
351 | break; |
352 | |
353 | udelay(RENESAS_DELAY); |
354 | } |
355 | if (i == RENESAS_RETRY) { |
356 | /* Timed out / Error - let's see if we can fix this */ |
357 | err = renesas_fw_check_running(pdev); |
358 | switch (err) { |
359 | case 0: /* |
360 | * we shouldn't end up here. |
361 | * maybe it took a little bit longer. |
362 | * But all should be well? |
363 | */ |
364 | break; |
365 | |
366 | case 1: /* (No result yet! */ |
367 | dev_err(&pdev->dev, "FW Load timedout" ); |
368 | return -ETIMEDOUT; |
369 | |
370 | default: |
371 | return err; |
372 | } |
373 | } |
374 | |
375 | return 0; |
376 | } |
377 | |
378 | static void renesas_rom_erase(struct pci_dev *pdev) |
379 | { |
380 | int retval, i; |
381 | u8 status; |
382 | |
383 | dev_dbg(&pdev->dev, "Performing ROM Erase...\n" ); |
384 | retval = pci_write_config_dword(dev: pdev, RENESAS_DATA0, |
385 | RENESAS_ROM_ERASE_MAGIC); |
386 | if (retval) { |
387 | dev_err(&pdev->dev, "ROM erase, magic word write failed: %d\n" , |
388 | pcibios_err_to_errno(retval)); |
389 | return; |
390 | } |
391 | |
392 | retval = pci_read_config_byte(dev: pdev, RENESAS_ROM_STATUS, val: &status); |
393 | if (retval) { |
394 | dev_err(&pdev->dev, "ROM status read failed: %d\n" , |
395 | pcibios_err_to_errno(retval)); |
396 | return; |
397 | } |
398 | status |= RENESAS_ROM_STATUS_ERASE; |
399 | retval = pci_write_config_byte(dev: pdev, RENESAS_ROM_STATUS, val: status); |
400 | if (retval) { |
401 | dev_err(&pdev->dev, "ROM erase set word write failed\n" ); |
402 | return; |
403 | } |
404 | |
405 | /* sleep a bit while ROM is erased */ |
406 | msleep(msecs: 20); |
407 | |
408 | for (i = 0; i < RENESAS_RETRY; i++) { |
409 | retval = pci_read_config_byte(dev: pdev, RENESAS_ROM_STATUS, |
410 | val: &status); |
411 | status &= RENESAS_ROM_STATUS_ERASE; |
412 | if (!status) |
413 | break; |
414 | |
415 | mdelay(RENESAS_DELAY); |
416 | } |
417 | |
418 | if (i == RENESAS_RETRY) |
419 | dev_dbg(&pdev->dev, "Chip erase timedout: %x\n" , status); |
420 | |
421 | dev_dbg(&pdev->dev, "ROM Erase... Done success\n" ); |
422 | } |
423 | |
424 | static bool renesas_setup_rom(struct pci_dev *pdev, const struct firmware *fw) |
425 | { |
426 | const u32 *fw_data = (const u32 *)fw->data; |
427 | int err, i; |
428 | u8 status; |
429 | |
430 | /* 2. Write magic word to Data0 */ |
431 | err = pci_write_config_dword(dev: pdev, RENESAS_DATA0, |
432 | RENESAS_ROM_WRITE_MAGIC); |
433 | if (err) |
434 | return false; |
435 | |
436 | /* 3. Set External ROM access */ |
437 | err = pci_write_config_byte(dev: pdev, RENESAS_ROM_STATUS, |
438 | RENESAS_ROM_STATUS_ACCESS); |
439 | if (err) |
440 | goto remove_bypass; |
441 | |
442 | /* 4. Check the result */ |
443 | err = pci_read_config_byte(dev: pdev, RENESAS_ROM_STATUS, val: &status); |
444 | if (err) |
445 | goto remove_bypass; |
446 | status &= GENMASK(6, 4); |
447 | if (status) { |
448 | dev_err(&pdev->dev, |
449 | "setting external rom failed: %x\n" , status); |
450 | goto remove_bypass; |
451 | } |
452 | |
453 | /* 5 to 16 Write FW to DATA0/1 while checking SetData0/1 */ |
454 | for (i = 0; i < fw->size / 4; i++) { |
455 | err = renesas_fw_download_image(dev: pdev, fw: fw_data, step: i, rom: true); |
456 | if (err) { |
457 | dev_err(&pdev->dev, |
458 | "ROM Download Step %d failed at position %d bytes with (%d)\n" , |
459 | i, i * 4, err); |
460 | goto remove_bypass; |
461 | } |
462 | } |
463 | |
464 | /* |
465 | * wait till DATA0/1 is cleared |
466 | */ |
467 | for (i = 0; i < RENESAS_RETRY; i++) { |
468 | err = pci_read_config_byte(dev: pdev, RENESAS_ROM_STATUS_MSB, |
469 | val: &status); |
470 | if (err) |
471 | goto remove_bypass; |
472 | if (!(status & (BIT(0) | BIT(1)))) |
473 | break; |
474 | |
475 | udelay(RENESAS_DELAY); |
476 | } |
477 | if (i == RENESAS_RETRY) { |
478 | dev_err(&pdev->dev, "Final Firmware ROM Download step timed out\n" ); |
479 | goto remove_bypass; |
480 | } |
481 | |
482 | /* 17. Remove bypass */ |
483 | err = pci_write_config_byte(dev: pdev, RENESAS_ROM_STATUS, val: 0); |
484 | if (err) |
485 | return false; |
486 | |
487 | udelay(10); |
488 | |
489 | /* 18. check result */ |
490 | for (i = 0; i < RENESAS_RETRY; i++) { |
491 | err = pci_read_config_byte(dev: pdev, RENESAS_ROM_STATUS, val: &status); |
492 | if (err) { |
493 | dev_err(&pdev->dev, "Read ROM status failed:%d\n" , |
494 | pcibios_err_to_errno(err)); |
495 | return false; |
496 | } |
497 | status &= RENESAS_ROM_STATUS_RESULT; |
498 | if (status == RENESAS_ROM_STATUS_SUCCESS) { |
499 | dev_dbg(&pdev->dev, "Download ROM success\n" ); |
500 | break; |
501 | } |
502 | udelay(RENESAS_DELAY); |
503 | } |
504 | if (i == RENESAS_RETRY) { /* Timed out */ |
505 | dev_err(&pdev->dev, |
506 | "Download to external ROM TO: %x\n" , status); |
507 | return false; |
508 | } |
509 | |
510 | dev_dbg(&pdev->dev, "Download to external ROM succeeded\n" ); |
511 | |
512 | /* Last step set Reload */ |
513 | err = pci_write_config_byte(dev: pdev, RENESAS_ROM_STATUS, |
514 | RENESAS_ROM_STATUS_RELOAD); |
515 | if (err) { |
516 | dev_err(&pdev->dev, "Set ROM execute failed: %d\n" , |
517 | pcibios_err_to_errno(err)); |
518 | return false; |
519 | } |
520 | |
521 | /* |
522 | * wait till Reload is cleared |
523 | */ |
524 | for (i = 0; i < RENESAS_RETRY; i++) { |
525 | err = pci_read_config_byte(dev: pdev, RENESAS_ROM_STATUS, val: &status); |
526 | if (err) |
527 | return false; |
528 | if (!(status & RENESAS_ROM_STATUS_RELOAD)) |
529 | break; |
530 | |
531 | udelay(RENESAS_DELAY); |
532 | } |
533 | if (i == RENESAS_RETRY) { |
534 | dev_err(&pdev->dev, "ROM Exec timed out: %x\n" , status); |
535 | return false; |
536 | } |
537 | |
538 | return true; |
539 | |
540 | remove_bypass: |
541 | pci_write_config_byte(dev: pdev, RENESAS_ROM_STATUS, val: 0); |
542 | return false; |
543 | } |
544 | |
545 | static int renesas_load_fw(struct pci_dev *pdev, const struct firmware *fw) |
546 | { |
547 | int err = 0; |
548 | bool rom; |
549 | |
550 | /* Check if the device has external ROM */ |
551 | rom = renesas_check_rom(pdev); |
552 | if (rom) { |
553 | /* perform chip erase first */ |
554 | renesas_rom_erase(pdev); |
555 | |
556 | /* lets try loading fw on ROM first */ |
557 | rom = renesas_setup_rom(pdev, fw); |
558 | if (!rom) { |
559 | dev_dbg(&pdev->dev, |
560 | "ROM load failed, falling back on FW load\n" ); |
561 | } else { |
562 | dev_dbg(&pdev->dev, |
563 | "ROM load success\n" ); |
564 | goto exit; |
565 | } |
566 | } |
567 | |
568 | err = renesas_fw_download(pdev, fw); |
569 | |
570 | exit: |
571 | if (err) |
572 | dev_err(&pdev->dev, "firmware failed to download (%d)." , err); |
573 | return err; |
574 | } |
575 | |
576 | int renesas_xhci_check_request_fw(struct pci_dev *pdev, |
577 | const struct pci_device_id *id) |
578 | { |
579 | struct xhci_driver_data *driver_data = |
580 | (struct xhci_driver_data *)id->driver_data; |
581 | const char *fw_name = driver_data->firmware; |
582 | const struct firmware *fw; |
583 | bool has_rom; |
584 | int err; |
585 | |
586 | /* Check if device has ROM and loaded, if so skip everything */ |
587 | has_rom = renesas_check_rom(pdev); |
588 | if (has_rom) { |
589 | err = renesas_check_rom_state(pdev); |
590 | if (!err) |
591 | return 0; |
592 | else if (err != -ENOENT) |
593 | has_rom = false; |
594 | } |
595 | |
596 | err = renesas_fw_check_running(pdev); |
597 | /* Continue ahead, if the firmware is already running. */ |
598 | if (!err) |
599 | return 0; |
600 | |
601 | /* no firmware interface available */ |
602 | if (err != 1) |
603 | return has_rom ? 0 : err; |
604 | |
605 | pci_dev_get(dev: pdev); |
606 | err = firmware_request_nowarn(fw: &fw, name: fw_name, device: &pdev->dev); |
607 | pci_dev_put(dev: pdev); |
608 | if (err) { |
609 | if (has_rom) { |
610 | dev_info(&pdev->dev, "failed to load firmware %s, fallback to ROM\n" , |
611 | fw_name); |
612 | return 0; |
613 | } |
614 | dev_err(&pdev->dev, "failed to load firmware %s: %d\n" , |
615 | fw_name, err); |
616 | return err; |
617 | } |
618 | |
619 | err = renesas_fw_verify(fw_data: fw->data, length: fw->size); |
620 | if (err) |
621 | goto exit; |
622 | |
623 | err = renesas_load_fw(pdev, fw); |
624 | exit: |
625 | release_firmware(fw); |
626 | return err; |
627 | } |
628 | EXPORT_SYMBOL_GPL(renesas_xhci_check_request_fw); |
629 | |
630 | MODULE_LICENSE("GPL v2" ); |
631 | |