Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  Driver for the NXP SAA7164 PCIe bridge
0004  *
0005  *  Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
0006  */
0007 
0008 #include <linux/firmware.h>
0009 #include <linux/slab.h>
0010 
0011 #include "saa7164.h"
0012 
0013 #define SAA7164_REV2_FIRMWARE       "NXP7164-2010-03-10.1.fw"
0014 #define SAA7164_REV2_FIRMWARE_SIZE  4019072
0015 
0016 #define SAA7164_REV3_FIRMWARE       "NXP7164-2010-03-10.1.fw"
0017 #define SAA7164_REV3_FIRMWARE_SIZE  4019072
0018 
0019 struct fw_header {
0020     u32 firmwaresize;
0021     u32 bslsize;
0022     u32 reserved;
0023     u32 version;
0024 };
0025 
0026 static int saa7164_dl_wait_ack(struct saa7164_dev *dev, u32 reg)
0027 {
0028     u32 timeout = SAA_DEVICE_TIMEOUT;
0029     while ((saa7164_readl(reg) & 0x01) == 0) {
0030         timeout -= 10;
0031         if (timeout == 0) {
0032             printk(KERN_ERR "%s() timeout (no d/l ack)\n",
0033                 __func__);
0034             return -EBUSY;
0035         }
0036         msleep(100);
0037     }
0038 
0039     return 0;
0040 }
0041 
0042 static int saa7164_dl_wait_clr(struct saa7164_dev *dev, u32 reg)
0043 {
0044     u32 timeout = SAA_DEVICE_TIMEOUT;
0045     while (saa7164_readl(reg) & 0x01) {
0046         timeout -= 10;
0047         if (timeout == 0) {
0048             printk(KERN_ERR "%s() timeout (no d/l clr)\n",
0049                 __func__);
0050             return -EBUSY;
0051         }
0052         msleep(100);
0053     }
0054 
0055     return 0;
0056 }
0057 
0058 /* TODO: move dlflags into dev-> and change to write/readl/b */
0059 /* TODO: Excessive levels of debug */
0060 static int saa7164_downloadimage(struct saa7164_dev *dev, u8 *src, u32 srcsize,
0061                  u32 dlflags, u8 __iomem *dst, u32 dstsize)
0062 {
0063     u32 reg, timeout, offset;
0064     u8 *srcbuf = NULL;
0065     int ret;
0066 
0067     u32 dlflag = dlflags;
0068     u32 dlflag_ack = dlflag + 4;
0069     u32 drflag = dlflag_ack + 4;
0070     u32 drflag_ack = drflag + 4;
0071     u32 bleflag = drflag_ack + 4;
0072 
0073     dprintk(DBGLVL_FW,
0074         "%s(image=%p, size=%d, flags=0x%x, dst=%p, dstsize=0x%x)\n",
0075         __func__, src, srcsize, dlflags, dst, dstsize);
0076 
0077     if ((src == NULL) || (dst == NULL)) {
0078         ret = -EIO;
0079         goto out;
0080     }
0081 
0082     srcbuf = kzalloc(4 * 1048576, GFP_KERNEL);
0083     if (NULL == srcbuf) {
0084         ret = -ENOMEM;
0085         goto out;
0086     }
0087 
0088     if (srcsize > (4*1048576)) {
0089         ret = -ENOMEM;
0090         goto out;
0091     }
0092 
0093     memcpy(srcbuf, src, srcsize);
0094 
0095     dprintk(DBGLVL_FW, "%s() dlflag = 0x%x\n", __func__, dlflag);
0096     dprintk(DBGLVL_FW, "%s() dlflag_ack = 0x%x\n", __func__, dlflag_ack);
0097     dprintk(DBGLVL_FW, "%s() drflag = 0x%x\n", __func__, drflag);
0098     dprintk(DBGLVL_FW, "%s() drflag_ack = 0x%x\n", __func__, drflag_ack);
0099     dprintk(DBGLVL_FW, "%s() bleflag = 0x%x\n", __func__, bleflag);
0100 
0101     reg = saa7164_readl(dlflag);
0102     dprintk(DBGLVL_FW, "%s() dlflag (0x%x)= 0x%x\n", __func__, dlflag, reg);
0103     if (reg == 1)
0104         dprintk(DBGLVL_FW,
0105             "%s() Download flag already set, please reboot\n",
0106             __func__);
0107 
0108     /* Indicate download start */
0109     saa7164_writel(dlflag, 1);
0110     ret = saa7164_dl_wait_ack(dev, dlflag_ack);
0111     if (ret < 0)
0112         goto out;
0113 
0114     /* Ack download start, then wait for wait */
0115     saa7164_writel(dlflag, 0);
0116     ret = saa7164_dl_wait_clr(dev, dlflag_ack);
0117     if (ret < 0)
0118         goto out;
0119 
0120     /* Deal with the raw firmware, in the appropriate chunk size */
0121     for (offset = 0; srcsize > dstsize;
0122         srcsize -= dstsize, offset += dstsize) {
0123 
0124         dprintk(DBGLVL_FW, "%s() memcpy %d\n", __func__, dstsize);
0125         memcpy_toio(dst, srcbuf + offset, dstsize);
0126 
0127         /* Flag the data as ready */
0128         saa7164_writel(drflag, 1);
0129         ret = saa7164_dl_wait_ack(dev, drflag_ack);
0130         if (ret < 0)
0131             goto out;
0132 
0133         /* Wait for indication data was received */
0134         saa7164_writel(drflag, 0);
0135         ret = saa7164_dl_wait_clr(dev, drflag_ack);
0136         if (ret < 0)
0137             goto out;
0138 
0139     }
0140 
0141     dprintk(DBGLVL_FW, "%s() memcpy(l) %d\n", __func__, dstsize);
0142     /* Write last block to the device */
0143     memcpy_toio(dst, srcbuf+offset, srcsize);
0144 
0145     /* Flag the data as ready */
0146     saa7164_writel(drflag, 1);
0147     ret = saa7164_dl_wait_ack(dev, drflag_ack);
0148     if (ret < 0)
0149         goto out;
0150 
0151     saa7164_writel(drflag, 0);
0152     timeout = 0;
0153     while (saa7164_readl(bleflag) != SAA_DEVICE_IMAGE_BOOTING) {
0154         if (saa7164_readl(bleflag) & SAA_DEVICE_IMAGE_CORRUPT) {
0155             printk(KERN_ERR "%s() image corrupt\n", __func__);
0156             ret = -EBUSY;
0157             goto out;
0158         }
0159 
0160         if (saa7164_readl(bleflag) & SAA_DEVICE_MEMORY_CORRUPT) {
0161             printk(KERN_ERR "%s() device memory corrupt\n",
0162                 __func__);
0163             ret = -EBUSY;
0164             goto out;
0165         }
0166 
0167         msleep(10); /* Checkpatch throws a < 20ms warning */
0168         if (timeout++ > 60)
0169             break;
0170     }
0171 
0172     printk(KERN_INFO "%s() Image downloaded, booting...\n", __func__);
0173 
0174     ret = saa7164_dl_wait_clr(dev, drflag_ack);
0175     if (ret < 0)
0176         goto out;
0177 
0178     printk(KERN_INFO "%s() Image booted successfully.\n", __func__);
0179     ret = 0;
0180 
0181 out:
0182     kfree(srcbuf);
0183     return ret;
0184 }
0185 
0186 /* TODO: Excessive debug */
0187 /* Load the firmware. Optionally it can be in ROM or newer versions
0188  * can be on disk, saving the expense of the ROM hardware. */
0189 int saa7164_downloadfirmware(struct saa7164_dev *dev)
0190 {
0191     /* u32 second_timeout = 60 * SAA_DEVICE_TIMEOUT; */
0192     u32 tmp, filesize, version, err_flags, first_timeout, fwlength;
0193     u32 second_timeout, updatebootloader = 1, bootloadersize = 0;
0194     const struct firmware *fw = NULL;
0195     struct fw_header *hdr, *boothdr = NULL, *fwhdr;
0196     u32 bootloaderversion = 0, fwloadersize;
0197     u8 *bootloaderoffset = NULL, *fwloaderoffset;
0198     char *fwname;
0199     int ret;
0200 
0201     dprintk(DBGLVL_FW, "%s()\n", __func__);
0202 
0203     if (saa7164_boards[dev->board].chiprev == SAA7164_CHIP_REV2) {
0204         fwname = SAA7164_REV2_FIRMWARE;
0205         fwlength = SAA7164_REV2_FIRMWARE_SIZE;
0206     } else {
0207         fwname = SAA7164_REV3_FIRMWARE;
0208         fwlength = SAA7164_REV3_FIRMWARE_SIZE;
0209     }
0210 
0211     version = saa7164_getcurrentfirmwareversion(dev);
0212 
0213     if (version == 0x00) {
0214 
0215         second_timeout = 100;
0216         first_timeout = 100;
0217         err_flags = saa7164_readl(SAA_BOOTLOADERERROR_FLAGS);
0218         dprintk(DBGLVL_FW, "%s() err_flags = %x\n",
0219             __func__, err_flags);
0220 
0221         while (err_flags != SAA_DEVICE_IMAGE_BOOTING) {
0222             dprintk(DBGLVL_FW, "%s() err_flags = %x\n",
0223                 __func__, err_flags);
0224             msleep(10); /* Checkpatch throws a < 20ms warning */
0225 
0226             if (err_flags & SAA_DEVICE_IMAGE_CORRUPT) {
0227                 printk(KERN_ERR "%s() firmware corrupt\n",
0228                     __func__);
0229                 break;
0230             }
0231             if (err_flags & SAA_DEVICE_MEMORY_CORRUPT) {
0232                 printk(KERN_ERR "%s() device memory corrupt\n",
0233                     __func__);
0234                 break;
0235             }
0236             if (err_flags & SAA_DEVICE_NO_IMAGE) {
0237                 printk(KERN_ERR "%s() no first image\n",
0238                 __func__);
0239                 break;
0240             }
0241             if (err_flags & SAA_DEVICE_IMAGE_SEARCHING) {
0242                 first_timeout -= 10;
0243                 if (first_timeout == 0) {
0244                     printk(KERN_ERR
0245                         "%s() no first image\n",
0246                         __func__);
0247                     break;
0248                 }
0249             } else if (err_flags & SAA_DEVICE_IMAGE_LOADING) {
0250                 second_timeout -= 10;
0251                 if (second_timeout == 0) {
0252                     printk(KERN_ERR
0253                     "%s() FW load time exceeded\n",
0254                         __func__);
0255                     break;
0256                 }
0257             } else {
0258                 second_timeout -= 10;
0259                 if (second_timeout == 0) {
0260                     printk(KERN_ERR
0261                     "%s() Unknown bootloader flags 0x%x\n",
0262                         __func__, err_flags);
0263                     break;
0264                 }
0265             }
0266 
0267             err_flags = saa7164_readl(SAA_BOOTLOADERERROR_FLAGS);
0268         } /* While != Booting */
0269 
0270         if (err_flags == SAA_DEVICE_IMAGE_BOOTING) {
0271             dprintk(DBGLVL_FW, "%s() Loader 1 has loaded.\n",
0272                 __func__);
0273             first_timeout = SAA_DEVICE_TIMEOUT;
0274             second_timeout = 60 * SAA_DEVICE_TIMEOUT;
0275             second_timeout = 100;
0276 
0277             err_flags = saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS);
0278             dprintk(DBGLVL_FW, "%s() err_flags2 = %x\n",
0279                 __func__, err_flags);
0280             while (err_flags != SAA_DEVICE_IMAGE_BOOTING) {
0281                 dprintk(DBGLVL_FW, "%s() err_flags2 = %x\n",
0282                     __func__, err_flags);
0283                 msleep(10); /* Checkpatch throws a < 20ms warning */
0284 
0285                 if (err_flags & SAA_DEVICE_IMAGE_CORRUPT) {
0286                     printk(KERN_ERR
0287                         "%s() firmware corrupt\n",
0288                         __func__);
0289                     break;
0290                 }
0291                 if (err_flags & SAA_DEVICE_MEMORY_CORRUPT) {
0292                     printk(KERN_ERR
0293                         "%s() device memory corrupt\n",
0294                         __func__);
0295                     break;
0296                 }
0297                 if (err_flags & SAA_DEVICE_NO_IMAGE) {
0298                     printk(KERN_ERR "%s() no second image\n",
0299                         __func__);
0300                     break;
0301                 }
0302                 if (err_flags & SAA_DEVICE_IMAGE_SEARCHING) {
0303                     first_timeout -= 10;
0304                     if (first_timeout == 0) {
0305                         printk(KERN_ERR
0306                         "%s() no second image\n",
0307                             __func__);
0308                         break;
0309                     }
0310                 } else if (err_flags &
0311                     SAA_DEVICE_IMAGE_LOADING) {
0312                     second_timeout -= 10;
0313                     if (second_timeout == 0) {
0314                         printk(KERN_ERR
0315                         "%s() FW load time exceeded\n",
0316                             __func__);
0317                         break;
0318                     }
0319                 } else {
0320                     second_timeout -= 10;
0321                     if (second_timeout == 0) {
0322                         printk(KERN_ERR
0323                     "%s() Unknown bootloader flags 0x%x\n",
0324                             __func__, err_flags);
0325                         break;
0326                     }
0327                 }
0328 
0329                 err_flags =
0330                 saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS);
0331             } /* err_flags != SAA_DEVICE_IMAGE_BOOTING */
0332 
0333             dprintk(DBGLVL_FW, "%s() Loader flags 1:0x%x 2:0x%x.\n",
0334                 __func__,
0335                 saa7164_readl(SAA_BOOTLOADERERROR_FLAGS),
0336                 saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS));
0337 
0338         } /* err_flags == SAA_DEVICE_IMAGE_BOOTING */
0339 
0340         /* It's possible for both firmwares to have booted,
0341          * but that doesn't mean they've finished booting yet.
0342          */
0343         if ((saa7164_readl(SAA_BOOTLOADERERROR_FLAGS) ==
0344             SAA_DEVICE_IMAGE_BOOTING) &&
0345             (saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS) ==
0346             SAA_DEVICE_IMAGE_BOOTING)) {
0347 
0348 
0349             dprintk(DBGLVL_FW, "%s() Loader 2 has loaded.\n",
0350                 __func__);
0351 
0352             first_timeout = SAA_DEVICE_TIMEOUT;
0353             while (first_timeout) {
0354                 msleep(10); /* Checkpatch throws a < 20ms warning */
0355 
0356                 version =
0357                     saa7164_getcurrentfirmwareversion(dev);
0358                 if (version) {
0359                     dprintk(DBGLVL_FW,
0360                     "%s() All f/w loaded successfully\n",
0361                         __func__);
0362                     break;
0363                 } else {
0364                     first_timeout -= 10;
0365                     if (first_timeout == 0) {
0366                         printk(KERN_ERR
0367                         "%s() FW did not boot\n",
0368                             __func__);
0369                         break;
0370                     }
0371                 }
0372             }
0373         }
0374         version = saa7164_getcurrentfirmwareversion(dev);
0375     } /* version == 0 */
0376 
0377     /* Has the firmware really booted? */
0378     if ((saa7164_readl(SAA_BOOTLOADERERROR_FLAGS) ==
0379         SAA_DEVICE_IMAGE_BOOTING) &&
0380         (saa7164_readl(SAA_SECONDSTAGEERROR_FLAGS) ==
0381         SAA_DEVICE_IMAGE_BOOTING) && (version == 0)) {
0382 
0383         printk(KERN_ERR
0384             "%s() The firmware hung, probably bad firmware\n",
0385             __func__);
0386 
0387         /* Tell the second stage loader we have a deadlock */
0388         saa7164_writel(SAA_DEVICE_DEADLOCK_DETECTED_OFFSET,
0389             SAA_DEVICE_DEADLOCK_DETECTED);
0390 
0391         saa7164_getfirmwarestatus(dev);
0392 
0393         return -ENOMEM;
0394     }
0395 
0396     dprintk(DBGLVL_FW, "Device has Firmware Version %d.%d.%d.%d\n",
0397         (version & 0x0000fc00) >> 10,
0398         (version & 0x000003e0) >> 5,
0399         (version & 0x0000001f),
0400         (version & 0xffff0000) >> 16);
0401 
0402     /* Load the firmware from the disk if required */
0403     if (version == 0) {
0404 
0405         printk(KERN_INFO "%s() Waiting for firmware upload (%s)\n",
0406             __func__, fwname);
0407 
0408         ret = request_firmware(&fw, fwname, &dev->pci->dev);
0409         if (ret) {
0410             printk(KERN_ERR "%s() Upload failed. (file not found?)\n",
0411                    __func__);
0412             return -ENOMEM;
0413         }
0414 
0415         printk(KERN_INFO "%s() firmware read %zu bytes.\n",
0416             __func__, fw->size);
0417 
0418         if (fw->size != fwlength) {
0419             printk(KERN_ERR "saa7164: firmware incorrect size %zu != %u\n",
0420                 fw->size, fwlength);
0421             ret = -ENOMEM;
0422             goto out;
0423         }
0424 
0425         printk(KERN_INFO "%s() firmware loaded.\n", __func__);
0426 
0427         hdr = (struct fw_header *)fw->data;
0428         printk(KERN_INFO "Firmware file header part 1:\n");
0429         printk(KERN_INFO " .FirmwareSize = 0x%x\n", hdr->firmwaresize);
0430         printk(KERN_INFO " .BSLSize = 0x%x\n", hdr->bslsize);
0431         printk(KERN_INFO " .Reserved = 0x%x\n", hdr->reserved);
0432         printk(KERN_INFO " .Version = 0x%x\n", hdr->version);
0433 
0434         /* Retrieve bootloader if reqd */
0435         if ((hdr->firmwaresize == 0) && (hdr->bslsize == 0))
0436             /* Second bootloader in the firmware file */
0437             filesize = hdr->reserved * 16;
0438         else
0439             filesize = (hdr->firmwaresize + hdr->bslsize) *
0440                 16 + sizeof(struct fw_header);
0441 
0442         printk(KERN_INFO "%s() SecBootLoader.FileSize = %d\n",
0443             __func__, filesize);
0444 
0445         /* Get bootloader (if reqd) and firmware header */
0446         if ((hdr->firmwaresize == 0) && (hdr->bslsize == 0)) {
0447             /* Second boot loader is required */
0448 
0449             /* Get the loader header */
0450             boothdr = (struct fw_header *)(fw->data +
0451                 sizeof(struct fw_header));
0452 
0453             bootloaderversion =
0454                 saa7164_readl(SAA_DEVICE_2ND_VERSION);
0455             dprintk(DBGLVL_FW, "Onboard BootLoader:\n");
0456             dprintk(DBGLVL_FW, "->Flag 0x%x\n",
0457                 saa7164_readl(SAA_BOOTLOADERERROR_FLAGS));
0458             dprintk(DBGLVL_FW, "->Ack 0x%x\n",
0459                 saa7164_readl(SAA_DATAREADY_FLAG_ACK));
0460             dprintk(DBGLVL_FW, "->FW Version 0x%x\n", version);
0461             dprintk(DBGLVL_FW, "->Loader Version 0x%x\n",
0462                 bootloaderversion);
0463 
0464             if ((saa7164_readl(SAA_BOOTLOADERERROR_FLAGS) ==
0465                 0x03) && (saa7164_readl(SAA_DATAREADY_FLAG_ACK)
0466                 == 0x00) && (version == 0x00)) {
0467 
0468                 dprintk(DBGLVL_FW, "BootLoader version in  rom %d.%d.%d.%d\n",
0469                     (bootloaderversion & 0x0000fc00) >> 10,
0470                     (bootloaderversion & 0x000003e0) >> 5,
0471                     (bootloaderversion & 0x0000001f),
0472                     (bootloaderversion & 0xffff0000) >> 16
0473                     );
0474                 dprintk(DBGLVL_FW, "BootLoader version in file %d.%d.%d.%d\n",
0475                     (boothdr->version & 0x0000fc00) >> 10,
0476                     (boothdr->version & 0x000003e0) >> 5,
0477                     (boothdr->version & 0x0000001f),
0478                     (boothdr->version & 0xffff0000) >> 16
0479                     );
0480 
0481                 if (bootloaderversion == boothdr->version)
0482                     updatebootloader = 0;
0483             }
0484 
0485             /* Calculate offset to firmware header */
0486             tmp = (boothdr->firmwaresize + boothdr->bslsize) * 16 +
0487                 (sizeof(struct fw_header) +
0488                 sizeof(struct fw_header));
0489 
0490             fwhdr = (struct fw_header *)(fw->data+tmp);
0491         } else {
0492             /* No second boot loader */
0493             fwhdr = hdr;
0494         }
0495 
0496         dprintk(DBGLVL_FW, "Firmware version in file %d.%d.%d.%d\n",
0497             (fwhdr->version & 0x0000fc00) >> 10,
0498             (fwhdr->version & 0x000003e0) >> 5,
0499             (fwhdr->version & 0x0000001f),
0500             (fwhdr->version & 0xffff0000) >> 16
0501             );
0502 
0503         if (version == fwhdr->version) {
0504             /* No download, firmware already on board */
0505             ret = 0;
0506             goto out;
0507         }
0508 
0509         if ((hdr->firmwaresize == 0) && (hdr->bslsize == 0)) {
0510             if (updatebootloader) {
0511                 /* Get ready to upload the bootloader */
0512                 bootloadersize = (boothdr->firmwaresize +
0513                     boothdr->bslsize) * 16 +
0514                     sizeof(struct fw_header);
0515 
0516                 bootloaderoffset = (u8 *)(fw->data +
0517                     sizeof(struct fw_header));
0518 
0519                 dprintk(DBGLVL_FW, "bootloader d/l starts.\n");
0520                 printk(KERN_INFO "%s() FirmwareSize = 0x%x\n",
0521                     __func__, boothdr->firmwaresize);
0522                 printk(KERN_INFO "%s() BSLSize = 0x%x\n",
0523                     __func__, boothdr->bslsize);
0524                 printk(KERN_INFO "%s() Reserved = 0x%x\n",
0525                     __func__, boothdr->reserved);
0526                 printk(KERN_INFO "%s() Version = 0x%x\n",
0527                     __func__, boothdr->version);
0528                 ret = saa7164_downloadimage(
0529                     dev,
0530                     bootloaderoffset,
0531                     bootloadersize,
0532                     SAA_DOWNLOAD_FLAGS,
0533                     dev->bmmio + SAA_DEVICE_DOWNLOAD_OFFSET,
0534                     SAA_DEVICE_BUFFERBLOCKSIZE);
0535                 if (ret < 0) {
0536                     printk(KERN_ERR
0537                         "bootloader d/l has failed\n");
0538                     goto out;
0539                 }
0540                 dprintk(DBGLVL_FW,
0541                     "bootloader download complete.\n");
0542 
0543             }
0544 
0545             printk(KERN_ERR "starting firmware download(2)\n");
0546             bootloadersize = (boothdr->firmwaresize +
0547                 boothdr->bslsize) * 16 +
0548                 sizeof(struct fw_header);
0549 
0550             bootloaderoffset =
0551                 (u8 *)(fw->data + sizeof(struct fw_header));
0552 
0553             fwloaderoffset = bootloaderoffset + bootloadersize;
0554 
0555             /* TODO: fix this bounds overrun here with old f/ws */
0556             fwloadersize = (fwhdr->firmwaresize + fwhdr->bslsize) *
0557                 16 + sizeof(struct fw_header);
0558 
0559             ret = saa7164_downloadimage(
0560                 dev,
0561                 fwloaderoffset,
0562                 fwloadersize,
0563                 SAA_DEVICE_2ND_DOWNLOADFLAG_OFFSET,
0564                 dev->bmmio + SAA_DEVICE_2ND_DOWNLOAD_OFFSET,
0565                 SAA_DEVICE_2ND_BUFFERBLOCKSIZE);
0566             if (ret < 0) {
0567                 printk(KERN_ERR "firmware download failed\n");
0568                 goto out;
0569             }
0570             printk(KERN_ERR "firmware download complete.\n");
0571 
0572         } else {
0573 
0574             /* No bootloader update reqd, download firmware only */
0575             printk(KERN_ERR "starting firmware download(3)\n");
0576 
0577             ret = saa7164_downloadimage(
0578                 dev,
0579                 (u8 *)fw->data,
0580                 fw->size,
0581                 SAA_DOWNLOAD_FLAGS,
0582                 dev->bmmio + SAA_DEVICE_DOWNLOAD_OFFSET,
0583                 SAA_DEVICE_BUFFERBLOCKSIZE);
0584             if (ret < 0) {
0585                 printk(KERN_ERR "firmware download failed\n");
0586                 goto out;
0587             }
0588             printk(KERN_ERR "firmware download complete.\n");
0589         }
0590     }
0591 
0592     dev->firmwareloaded = 1;
0593     ret = 0;
0594 
0595 out:
0596     release_firmware(fw);
0597     return ret;
0598 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!