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