diff options
Diffstat (limited to 'drivers/media/video/saa7164/saa7164-fw.c')
-rw-r--r-- | drivers/media/video/saa7164/saa7164-fw.c | 613 |
1 files changed, 613 insertions, 0 deletions
diff --git a/drivers/media/video/saa7164/saa7164-fw.c b/drivers/media/video/saa7164/saa7164-fw.c new file mode 100644 index 00000000000..a266bf0169e --- /dev/null +++ b/drivers/media/video/saa7164/saa7164-fw.c | |||
@@ -0,0 +1,613 @@ | |||
1 | /* | ||
2 | * Driver for the NXP SAA7164 PCIe bridge | ||
3 | * | ||
4 | * Copyright (c) 2010 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 | 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 | 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 | int saa7164_downloadimage(struct saa7164_dev *dev, u8 *src, u32 srcsize, | ||
75 | u32 dlflags, u8 *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(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(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 | } | ||