drivers/media/video/saa7164/saa7164-fw.c

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