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