treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / media / pci / saa7164 / saa7164-fw.c
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 }