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

   1 /*
   2  *  Driver for the NXP SAA7164 PCIe bridge
   3  *
   4  *  Copyright (c) 2010-2015 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 #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 static 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 static 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 static int saa7164_downloadimage(struct saa7164_dev *dev, u8 *src, u32 srcsize,
  75                                  u32 dlflags, u8 __iomem *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_toio(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_toio(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 }