?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / media / pci / saa7164 / saa7164-fw.c
blob363689484c54a32d6892e78d808c72713d58f536
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Driver for the NXP SAA7164 PCIe bridge
4 *
5 * Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
6 */
7
8 #include <linux/firmware.h>
9 #include <linux/slab.h>
10
11 #include "saa7164.h"
12
13 #define SAA7164_REV2_FIRMWARE "NXP7164-2010-03-10.1.fw"
14 #define SAA7164_REV2_FIRMWARE_SIZE 4019072
15
16 #define SAA7164_REV3_FIRMWARE "NXP7164-2010-03-10.1.fw"
17 #define SAA7164_REV3_FIRMWARE_SIZE 4019072
18
19 struct fw_header {
20 u32 firmwaresize;
21 u32 bslsize;
22 u32 reserved;
23 u32 version;
24 };
25
26 static int saa7164_dl_wait_ack(struct saa7164_dev *dev, u32 reg)
27 {
28 u32 timeout = SAA_DEVICE_TIMEOUT;
29 while ((saa7164_readl(reg) & 0x01) == 0) {
30 timeout -= 10;
31 if (timeout == 0) {
32 printk(KERN_ERR "%s() timeout (no d/l ack)\n",
33 __func__);
34 return -EBUSY;
35 }
36 msleep(100);
37 }
38
39 return 0;
40 }
41
42 static int saa7164_dl_wait_clr(struct saa7164_dev *dev, u32 reg)
43 {
44 u32 timeout = SAA_DEVICE_TIMEOUT;
45 while (saa7164_readl(reg) & 0x01) {
46 timeout -= 10;
47 if (timeout == 0) {
48 printk(KERN_ERR "%s() timeout (no d/l clr)\n",
49 __func__);
50 return -EBUSY;
51 }
52 msleep(100);
53 }
54
55 return 0;
56 }
57
58 /* TODO: move dlflags into dev-> and change to write/readl/b */
59 /* TODO: Excessive levels of debug */
60 static int saa7164_downloadimage(struct saa7164_dev *dev, u8 *src, u32 srcsize,
61 u32 dlflags, u8 __iomem *dst, u32 dstsize)
62 {
63 u32 reg, timeout, offset;
64 u8 *srcbuf = NULL;
65 int ret;
66
67 u32 dlflag = dlflags;
68 u32 dlflag_ack = dlflag + 4;
69 u32 drflag = dlflag_ack + 4;
70 u32 drflag_ack = drflag + 4;
71 u32 bleflag = drflag_ack + 4;
72
73 dprintk(DBGLVL_FW,
74 "%s(image=%p, size=%d, flags=0x%x, dst=%p, dstsize=0x%x)\n",
75 __func__, src, srcsize, dlflags, dst, dstsize);
76
77 if ((src == NULL) || (dst == NULL)) {
78 ret = -EIO;
79 goto out;
80 }
81
82 srcbuf = kzalloc(4 * 1048576, GFP_KERNEL);
83 if (NULL == srcbuf) {
84 ret = -ENOMEM;
85 goto out;
86 }
87
88 if (srcsize > (4*1048576)) {
89 ret = -ENOMEM;
90 goto out;
91 }
92
93 memcpy(srcbuf, src, srcsize);
94
95 dprintk(DBGLVL_FW, "%s() dlflag = 0x%x\n", __func__, dlflag);
96 dprintk(DBGLVL_FW, "%s() dlflag_ack = 0x%x\n", __func__, dlflag_ack);
97 dprintk(DBGLVL_FW, "%s() drflag = 0x%x\n", __func__, drflag);
98 dprintk(DBGLVL_FW, "%s() drflag_ack = 0x%x\n", __func__, drflag_ack);
99 dprintk(DBGLVL_FW, "%s() bleflag = 0x%x\n", __func__, bleflag);
100
101 reg = saa7164_readl(dlflag);
102 dprintk(DBGLVL_FW, "%s() dlflag (0x%x)= 0x%x\n", __func__, dlflag, reg);
103 if (reg == 1)
104 dprintk(DBGLVL_FW,
105 "%s() Download flag already set, please reboot\n",
106 __func__);
107
108 /* Indicate download start */
109 saa7164_writel(dlflag, 1);
110 ret = saa7164_dl_wait_ack(dev, dlflag_ack);
111 if (ret < 0)
112 goto out;
113
114 /* Ack download start, then wait for wait */
115 saa7164_writel(dlflag, 0);
116 ret = saa7164_dl_wait_clr(dev, dlflag_ack);
117 if (ret < 0)
118 goto out;
119
120 /* Deal with the raw firmware, in the appropriate chunk size */
121 for (offset = 0; srcsize > dstsize;
122 srcsize -= dstsize, offset += dstsize) {
123
124 dprintk(DBGLVL_FW, "%s() memcpy %d\n", __func__, dstsize);
125 memcpy_toio(dst, srcbuf + offset, dstsize);
126
127 /* Flag the data as ready */
128 saa7164_writel(drflag, 1);
129 ret = saa7164_dl_wait_ack(dev, drflag_ack);
130 if (ret < 0)
131 goto out;
132
133 /* Wait for indication data was received */
134 saa7164_writel(drflag, 0);
135 ret = saa7164_dl_wait_clr(dev, drflag_ack);
136 if (ret < 0)
137 goto out;
138
139 }
140
141 dprintk(DBGLVL_FW, "%s() memcpy(l) %d\n", __func__, dstsize);
142 /* Write last block to the device */
143 memcpy_toio(dst, srcbuf+offset, srcsize);
144
145 /* Flag the data as ready */
146 saa7164_writel(drflag, 1);
147 ret = saa7164_dl_wait_ack(dev, drflag_ack);
148 if (ret < 0)
149 goto out;
150
151 saa7164_writel(drflag, 0);
152 timeout = 0;
153 while (saa7164_readl(bleflag) != SAA_DEVICE_IMAGE_BOOTING) {
154 if (saa7164_readl(bleflag) & SAA_DEVICE_IMAGE_CORRUPT) {
155 printk(KERN_ERR "%s() image corrupt\n", __func__);
156 ret = -EBUSY;
157 goto out;
158 }
159
160 if (saa7164_readl(bleflag) & SAA_DEVICE_MEMORY_CORRUPT) {
161 printk(KERN_ERR "%s() device memory corrupt\n",
162 __func__);
163 ret = -EBUSY;
164 goto out;
165 }
166
167 msleep(10); /* Checkpatch throws a < 20ms warning */
168 if (timeout++ > 60)
169 break;
170 }
171
172 printk(KERN_INFO "%s() Image downloaded, booting...\n", __func__);
173
174 ret = saa7164_dl_wait_clr(dev, drflag_ack);
175 if (ret < 0)
176 goto out;
177
178 printk(KERN_INFO "%s() Image booted successfully.\n", __func__);
179 ret = 0;
180
181 out:
182 kfree(srcbuf);
183 return ret;
184 }
185
186 /* TODO: Excessive debug */
187 /* Load the firmware. Optionally it can be in ROM or newer versions
188 * can be on disk, saving the expense of the ROM hardware. */
189 int saa7164_downloadfirmware(struct saa7164_dev *dev)
190 {
191 /* u32 second_timeout = 60 * SAA_DEVICE_TIMEOUT; */
192 u32 tmp, filesize, version, err_flags, first_timeout, fwlength;
193 u32 second_timeout, updatebootloader = 1, bootloadersize = 0;
194 const struct firmware *fw = NULL;
195 struct fw_header *hdr, *boothdr = NULL, *fwhdr;
196 u32 bootloaderversion = 0, fwloadersize;
197 u8 *bootloaderoffset = NULL, *fwloaderoffset;
198 char *fwname;
199 int ret;
200
201 dprintk(DBGLVL_FW, "%s()\n", __func__);
202
203 if (saa7164_boards[dev->board].chiprev == SAA7164_CHIP_REV2) {
204 fwname = SAA7164_REV2_FIRMWARE;
205 fwlength = SAA7164_REV2_FIRMWARE_SIZE;
206 } else {
207 fwname = SAA7164_REV3_FIRMWARE;
208 fwlength = SAA7164_REV3_FIRMWARE_SIZE;
209 }
210
211 version = saa7164_getcurrentfirmwareversion(dev);
212
213 if (version == 0x00) {
214
215 second_timeout = 100;
216 first_timeout = 100;
217 err_flags = saa7164_readl(SAA_BOOTLOADERERROR_FLAGS);
218 dprintk(DBGLVL_FW, "%s() err_flags = %x\n",
219 __func__, err_flags);
220
221 while (err_flags != SAA_DEVICE_IMAGE_BOOTING) {
222 dprintk(DBGLVL_FW, "%s() err_flags = %x\n",
223 __func__, err_flags);
224 msleep(10); /* Checkpatch throws a < 20ms warning */
225
226 if (err_flags & SAA_DEVICE_IMAGE_CORRUPT) {
227 printk(KERN_ERR "%s() firmware corrupt\n",
228 __func__);
229 break;
230 }
231 if (err_flags & SAA_DEVICE_MEMORY_CORRUPT) {
232 printk(KERN_ERR "%s() device memory corrupt\n",
233 __func__);
234 break;
235 }
236 if (err_flags & SAA_DEVICE_NO_IMAGE) {
237 printk(KERN_ERR "%s() no first image\n",
238 __func__);
239 break;
240 }
241 if (err_flags & SAA_DEVICE_IMAGE_SEARCHING) {
242 first_timeout -= 10;
243 if (first_timeout == 0) {
244 printk(KERN_ERR
245 "%s() no first image\n",
246 __func__);
247 break;
248 }
249 } else if (err_flags & SAA_DEVICE_IMAGE_LOADING) {
250 second_timeout -= 10;
251 if (second_timeout == 0) {
252 printk(KERN_ERR
253 "%s() FW load time exceeded\n",
254 __func__);
255 break;
256 }
257 } else {
258 second_timeout -= 10;
259 if (second_timeout == 0) {
260 printk(KERN_ERR
261 "%s() Unknown bootloader flags 0x%x\n",
262 __func__, err_flags);
263 break;
264 }
265 }
266
267 err_flags = saa7164_readl(SAA_BOOTLOADERERROR_FLAGS);
268 } /* While != Booting */
269
270 if (err_flags == SAA_DEVICE_IMAGE_BOOTING) {
271 dprintk(DBGLVL_FW, "%s() Loader 1 has loaded.\n",
272 __func__);
273 first_timeout = SAA_DEVICE_TIMEOUT;
274 second_timeout = 60 * SAA_DEVICE_TIMEOUT;
275 second_timeout = 100;
276
277 err_flags = saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS);
278 dprintk(DBGLVL_FW, "%s() err_flags2 = %x\n",
279 __func__, err_flags);
280 while (err_flags != SAA_DEVICE_IMAGE_BOOTING) {
281 dprintk(DBGLVL_FW, "%s() err_flags2 = %x\n",
282 __func__, err_flags);
283 msleep(10); /* Checkpatch throws a < 20ms warning */
284
285 if (err_flags & SAA_DEVICE_IMAGE_CORRUPT) {
286 printk(KERN_ERR
287 "%s() firmware corrupt\n",
288 __func__);
289 break;
290 }
291 if (err_flags & SAA_DEVICE_MEMORY_CORRUPT) {
292 printk(KERN_ERR
293 "%s() device memory corrupt\n",
294 __func__);
295 break;
296 }
297 if (err_flags & SAA_DEVICE_NO_IMAGE) {
298 printk(KERN_ERR "%s() no second image\n",
299 __func__);
300 break;
301 }
302 if (err_flags & SAA_DEVICE_IMAGE_SEARCHING) {
303 first_timeout -= 10;
304 if (first_timeout == 0) {
305 printk(KERN_ERR
306 "%s() no second image\n",
307 __func__);
308 break;
309 }
310 } else if (err_flags &
311 SAA_DEVICE_IMAGE_LOADING) {
312 second_timeout -= 10;
313 if (second_timeout == 0) {
314 printk(KERN_ERR
315 "%s() FW load time exceeded\n",
316 __func__);
317 break;
318 }
319 } else {
320 second_timeout -= 10;
321 if (second_timeout == 0) {
322 printk(KERN_ERR
323 "%s() Unknown bootloader flags 0x%x\n",
324 __func__, err_flags);
325 break;
326 }
327 }
328
329 err_flags =
330 saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS);
331 } /* err_flags != SAA_DEVICE_IMAGE_BOOTING */
332
333 dprintk(DBGLVL_FW, "%s() Loader flags 1:0x%x 2:0x%x.\n",
334 __func__,
335 saa7164_readl(SAA_BOOTLOADERERROR_FLAGS),
336 saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS));
337
338 } /* err_flags == SAA_DEVICE_IMAGE_BOOTING */
339
340 /* It's possible for both firmwares to have booted,
341 * but that doesn't mean they've finished booting yet.
342 */
343 if ((saa7164_readl(SAA_BOOTLOADERERROR_FLAGS) ==
344 SAA_DEVICE_IMAGE_BOOTING) &&
345 (saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS) ==
346 SAA_DEVICE_IMAGE_BOOTING)) {
347
348
349 dprintk(DBGLVL_FW, "%s() Loader 2 has loaded.\n",
350 __func__);
351
352 first_timeout = SAA_DEVICE_TIMEOUT;
353 while (first_timeout) {
354 msleep(10); /* Checkpatch throws a < 20ms warning */
355
356 version =
357 saa7164_getcurrentfirmwareversion(dev);
358 if (version) {
359 dprintk(DBGLVL_FW,
360 "%s() All f/w loaded successfully\n",
361 __func__);
362 break;
363 } else {
364 first_timeout -= 10;
365 if (first_timeout == 0) {
366 printk(KERN_ERR
367 "%s() FW did not boot\n",
368 __func__);
369 break;
370 }
371 }
372 }
373 }
374 version = saa7164_getcurrentfirmwareversion(dev);
375 } /* version == 0 */
376
377 /* Has the firmware really booted? */
378 if ((saa7164_readl(SAA_BOOTLOADERERROR_FLAGS) ==
379 SAA_DEVICE_IMAGE_BOOTING) &&
380 (saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS) ==
381 SAA_DEVICE_IMAGE_BOOTING) && (version == 0)) {
382
383 printk(KERN_ERR
384 "%s() The firmware hung, probably bad firmware\n",
385 __func__);
386
387 /* Tell the second stage loader we have a deadlock */
388 saa7164_writel(SAA_DEVICE_DEADLOCK_DETECTED_OFFSET,
389 SAA_DEVICE_DEADLOCK_DETECTED);
390
391 saa7164_getfirmwarestatus(dev);
392
393 return -ENOMEM;
394 }
395
396 dprintk(DBGLVL_FW, "Device has Firmware Version %d.%d.%d.%d\n",
397 (version & 0x0000fc00) >> 10,
398 (version & 0x000003e0) >> 5,
399 (version & 0x0000001f),
400 (version & 0xffff0000) >> 16);
401
402 /* Load the firmware from the disk if required */
403 if (version == 0) {
404
405 printk(KERN_INFO "%s() Waiting for firmware upload (%s)\n",
406 __func__, fwname);
407
408 ret = request_firmware(&fw, fwname, &dev->pci->dev);
409 if (ret) {
410 printk(KERN_ERR "%s() Upload failed. (file not found?)\n",
411 __func__);
412 return -ENOMEM;
413 }
414
415 printk(KERN_INFO "%s() firmware read %zu bytes.\n",
416 __func__, fw->size);
417
418 if (fw->size != fwlength) {
419 printk(KERN_ERR "saa7164: firmware incorrect size %zu != %u\n",
420 fw->size, fwlength);
421 ret = -ENOMEM;
422 goto out;
423 }
424
425 printk(KERN_INFO "%s() firmware loaded.\n", __func__);
426
427 hdr = (struct fw_header *)fw->data;
428 printk(KERN_INFO "Firmware file header part 1:\n");
429 printk(KERN_INFO " .FirmwareSize = 0x%x\n", hdr->firmwaresize);
430 printk(KERN_INFO " .BSLSize = 0x%x\n", hdr->bslsize);
431 printk(KERN_INFO " .Reserved = 0x%x\n", hdr->reserved);
432 printk(KERN_INFO " .Version = 0x%x\n", hdr->version);
433
434 /* Retrieve bootloader if reqd */
435 if ((hdr->firmwaresize == 0) && (hdr->bslsize == 0))
436 /* Second bootloader in the firmware file */
437 filesize = hdr->reserved * 16;
438 else
439 filesize = (hdr->firmwaresize + hdr->bslsize) *
440 16 + sizeof(struct fw_header);
441
442 printk(KERN_INFO "%s() SecBootLoader.FileSize = %d\n",
443 __func__, filesize);
444
445 /* Get bootloader (if reqd) and firmware header */
446 if ((hdr->firmwaresize == 0) && (hdr->bslsize == 0)) {
447 /* Second boot loader is required */
448
449 /* Get the loader header */
450 boothdr = (struct fw_header *)(fw->data +
451 sizeof(struct fw_header));
452
453 bootloaderversion =
454 saa7164_readl(SAA_DEVICE_2ND_VERSION);
455 dprintk(DBGLVL_FW, "Onboard BootLoader:\n");
456 dprintk(DBGLVL_FW, "->Flag 0x%x\n",
457 saa7164_readl(SAA_BOOTLOADERERROR_FLAGS));
458 dprintk(DBGLVL_FW, "->Ack 0x%x\n",
459 saa7164_readl(SAA_DATAREADY_FLAG_ACK));
460 dprintk(DBGLVL_FW, "->FW Version 0x%x\n", version);
461 dprintk(DBGLVL_FW, "->Loader Version 0x%x\n",
462 bootloaderversion);
463
464 if ((saa7164_readl(SAA_BOOTLOADERERROR_FLAGS) ==
465 0x03) && (saa7164_readl(SAA_DATAREADY_FLAG_ACK)
466 == 0x00) && (version == 0x00)) {
467
468 dprintk(DBGLVL_FW, "BootLoader version in rom %d.%d.%d.%d\n",
469 (bootloaderversion & 0x0000fc00) >> 10,
470 (bootloaderversion & 0x000003e0) >> 5,
471 (bootloaderversion & 0x0000001f),
472 (bootloaderversion & 0xffff0000) >> 16
473 );
474 dprintk(DBGLVL_FW, "BootLoader version in file %d.%d.%d.%d\n",
475 (boothdr->version & 0x0000fc00) >> 10,
476 (boothdr->version & 0x000003e0) >> 5,
477 (boothdr->version & 0x0000001f),
478 (boothdr->version & 0xffff0000) >> 16
479 );
480
481 if (bootloaderversion == boothdr->version)
482 updatebootloader = 0;
483 }
484
485 /* Calculate offset to firmware header */
486 tmp = (boothdr->firmwaresize + boothdr->bslsize) * 16 +
487 (sizeof(struct fw_header) +
488 sizeof(struct fw_header));
489
490 fwhdr = (struct fw_header *)(fw->data+tmp);
491 } else {
492 /* No second boot loader */
493 fwhdr = hdr;
494 }
495
496 dprintk(DBGLVL_FW, "Firmware version in file %d.%d.%d.%d\n",
497 (fwhdr->version & 0x0000fc00) >> 10,
498 (fwhdr->version & 0x000003e0) >> 5,
499 (fwhdr->version & 0x0000001f),
500 (fwhdr->version & 0xffff0000) >> 16
501 );
502
503 if (version == fwhdr->version) {
504 /* No download, firmware already on board */
505 ret = 0;
506 goto out;
507 }
508
509 if ((hdr->firmwaresize == 0) && (hdr->bslsize == 0)) {
510 if (updatebootloader) {
511 /* Get ready to upload the bootloader */
512 bootloadersize = (boothdr->firmwaresize +
513 boothdr->bslsize) * 16 +
514 sizeof(struct fw_header);
515
516 bootloaderoffset = (u8 *)(fw->data +
517 sizeof(struct fw_header));
518
519 dprintk(DBGLVL_FW, "bootloader d/l starts.\n");
520 printk(KERN_INFO "%s() FirmwareSize = 0x%x\n",
521 __func__, boothdr->firmwaresize);
522 printk(KERN_INFO "%s() BSLSize = 0x%x\n",
523 __func__, boothdr->bslsize);
524 printk(KERN_INFO "%s() Reserved = 0x%x\n",
525 __func__, boothdr->reserved);
526 printk(KERN_INFO "%s() Version = 0x%x\n",
527 __func__, boothdr->version);
528 ret = saa7164_downloadimage(
529 dev,
530 bootloaderoffset,
531 bootloadersize,
532 SAA_DOWNLOAD_FLAGS,
533 dev->bmmio + SAA_DEVICE_DOWNLOAD_OFFSET,
534 SAA_DEVICE_BUFFERBLOCKSIZE);
535 if (ret < 0) {
536 printk(KERN_ERR
537 "bootloader d/l has failed\n");
538 goto out;
539 }
540 dprintk(DBGLVL_FW,
541 "bootloader download complete.\n");
542
543 }
544
545 printk(KERN_ERR "starting firmware download(2)\n");
546 bootloadersize = (boothdr->firmwaresize +
547 boothdr->bslsize) * 16 +
548 sizeof(struct fw_header);
549
550 bootloaderoffset =
551 (u8 *)(fw->data + sizeof(struct fw_header));
552
553 fwloaderoffset = bootloaderoffset + bootloadersize;
554
555 /* TODO: fix this bounds overrun here with old f/ws */
556 fwloadersize = (fwhdr->firmwaresize + fwhdr->bslsize) *
557 16 + sizeof(struct fw_header);
558
559 ret = saa7164_downloadimage(
560 dev,
561 fwloaderoffset,
562 fwloadersize,
563 SAA_DEVICE_2ND_DOWNLOADFLAG_OFFSET,
564 dev->bmmio + SAA_DEVICE_2ND_DOWNLOAD_OFFSET,
565 SAA_DEVICE_2ND_BUFFERBLOCKSIZE);
566 if (ret < 0) {
567 printk(KERN_ERR "firmware download failed\n");
568 goto out;
569 }
570 printk(KERN_ERR "firmware download complete.\n");
571
572 } else {
573
574 /* No bootloader update reqd, download firmware only */
575 printk(KERN_ERR "starting firmware download(3)\n");
576
577 ret = saa7164_downloadimage(
578 dev,
579 (u8 *)fw->data,
580 fw->size,
581 SAA_DOWNLOAD_FLAGS,
582 dev->bmmio + SAA_DEVICE_DOWNLOAD_OFFSET,
583 SAA_DEVICE_BUFFERBLOCKSIZE);
584 if (ret < 0) {
585 printk(KERN_ERR "firmware download failed\n");
586 goto out;
587 }
588 printk(KERN_ERR "firmware download complete.\n");
589 }
590 }
591
592 dev->firmwareloaded = 1;
593 ret = 0;
594
595 out:
596 release_firmware(fw);
597 return ret;
598 }
Linux with added FPC-III support