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 }
614