1 #include "normal_mode.h"
3 #ifdef CONFIG_OF_LIBFDT
7 #define KERNL_PAGE_SIZE 2048
9 #ifdef CONFIG_SUPPORT_TD
10 static vol_image_required_t s_boot_image_TD_table[]={
11 {"tdfixnv1","tdfixnv2",FIXNV_SIZE,TDFIXNV_ADR,IMG_RAW},
12 {"tdruntimenv1","tdruntimenv2",RUNTIMENV_SIZE,TDRUNTIMENV_ADR,IMG_RAW},
13 {"tdmodem",NULL,TDMODEM_SIZE,TDMODEM_ADR,IMG_RAW},
14 {"tddsp",NULL,TDDSP_SIZE,TDDSP_ADR,IMG_RAW},
15 {NULL,NULL,0,0,IMG_MAX}
19 #ifdef CONFIG_SUPPORT_W
20 static vol_image_required_t s_boot_image_W_table[]={
21 {"wfixnv1","wfixnv2",FIXNV_SIZE,WFIXNV_ADR,IMG_RAW},
22 {"wruntimenv1","wruntimenv2",RUNTIMENV_SIZE,WRUNTIMENV_ADR,IMG_RAW},
23 {"wdsp",NULL,WDSP_SIZE,WDSP_ADR,IMG_RAW},
24 {"wmodem",NULL,WMODEM_SIZE,WMODEM_ADR,IMG_RAW},
25 {NULL,NULL,0,0,IMG_MAX}
29 #ifdef CONFIG_SUPPORT_WIFI
30 static vol_image_required_t s_boot_image_WIFI_table[]={
31 {"wcnfixnv1","wcnfixnv2",FIXNV_SIZE,WCNFIXNV_ADR,IMG_RAW},
32 {"wcnruntimenv1","wcnruntimenv2",RUNTIMENV_SIZE,WCNRUNTIMENV_ADR,IMG_RAW},
33 {"wcnmodem",NULL,WCNMODEM_SIZE,WCNMODEM_ADR,IMG_RAW},
34 {NULL,NULL,0,0,IMG_MAX}
38 static vol_image_required_t* s_boot_image_table[]={
39 #ifdef CONFIG_SUPPORT_TD
40 s_boot_image_TD_table,
43 #ifdef CONFIG_SUPPORT_W
47 #ifdef CONFIG_SUPPORT_WIFI
48 s_boot_image_WIFI_table,
55 long long load_image_time = 0;
57 int read_logoimg(char *bmp_img,size_t size)
65 struct mtd_device *dev;
66 struct part_info *part;
69 struct mtd_info *nand;
70 int size = CONFIG_SPL_LOAD_LEN;
72 int ret = find_dev_and_part(SPL_PART, &dev, &pnum, &part);
74 printf("No partition named %s\n", SPL_PART);
76 } else if (dev->id->type != MTD_DEV_TYPE_NAND) {
77 printf("Partition %s not a NAND device\n", SPL_PART);
81 nand = &nand_info[dev->id->num];
83 ret = nand_read_offset_ret(nand, off, &size, (void*)spl_data, &off);
85 printf("spl nand read error %d\n", ret);
92 int uboot_ubi_read(struct ubi_volume_desc *desc, char *buf,
95 int err, lnum, off, len, tbuf_size, i = 0;
96 size_t count_save = size;
98 unsigned long long tmp;
99 struct ubi_volume *vol = NULL;
100 struct ubi_device *ubi = NULL;
101 loff_t offp = offset;
104 ubi = desc->vol->ubi;
106 printf("read %i bytes from volume %d to %x(buf address)\n",
107 (int) size, vol->vol_id, (unsigned)buf);
113 if (vol->upd_marker) {
114 printf("damaged volume, update marker is set");
117 if (offp == vol->used_bytes)
121 printf("Read [%lu] bytes\n", (unsigned long) vol->used_bytes);
122 size = vol->used_bytes;
126 printf("read from corrupted volume %d", vol->vol_id);
127 if (offp + size > vol->used_bytes)
128 count_save = size = vol->used_bytes - offp;
130 tbuf_size = vol->usable_leb_size;
131 if (size < tbuf_size)
132 tbuf_size = ALIGN(size, ubi->min_io_size);
133 tbuf = malloc(tbuf_size);
138 len = size > tbuf_size ? tbuf_size : size;
141 off = do_div(tmp, vol->usable_leb_size);
144 if (off + len >= vol->usable_leb_size)
145 len = vol->usable_leb_size - off;
147 err = ubi_eba_read_leb(ubi, vol, lnum, tbuf, off, len, 0);
149 printf("read err %x\n", err);
153 if (off == vol->usable_leb_size) {
155 off -= vol->usable_leb_size;
161 memcpy(buf, tbuf, len);
164 len = size > tbuf_size ? tbuf_size : size;
168 return err ? err : count_save - size;
172 attach ubi device to given mtdpart, and return the new
175 static int _boot_ubi_attach_mtd(const char *mtdpart)
177 struct mtd_device *dev;
178 struct part_info *part;
179 struct mtd_info *mtd;
180 struct mtd_partition mtd_part;
185 ret = find_dev_and_part(mtdpart, &dev, &pnum, &part);
187 printf("--->main partition %s miss<---\n",mtdpart);
190 if(dev->id->type != MTD_DEV_TYPE_NAND){
191 printf("mtd dev %s not a nand device!\n",mtdpart);
194 sprintf(mtd_dev, "%s%d", MTD_DEV_TYPE(dev->id->type), dev->id->num);
195 mtd = get_mtd_device_nm(mtd_dev);
197 memset(&mtd_part, 0, sizeof(mtd_part));
198 mtd_part.name = mtdpart;
199 mtd_part.size = part->size;
200 mtd_part.offset = part->offset;
201 add_mtd_partitions(mtd, &mtd_part, 1);
202 mtd = get_mtd_device_nm(mtdpart);
204 ret = ubi_attach_mtd_dev(mtd, UBI_DEV_NUM_AUTO, 0);
206 printf("--->ubi attach mtd %s failed<---\n",mtdpart);
212 Function for displaying logo.
214 static void _boot_display_logo(int ubidev, char *part, int backlight_set)
217 struct ubi_volume_desc *vol;
219 #ifdef CONFIG_LCD_720P
224 unsigned char * bmp_img = malloc(size);
226 printf("%s: malloc for splash image failed!\n",__FUNCTION__);
229 vol = ubi_open_volume_nm(ubidev, part, UBI_READONLY);
231 printf("cannot open \"%s\", error %d",
232 part, (int)PTR_ERR(vol));
236 if(size != uboot_ubi_read(vol, bmp_img, 0, size)) {
238 uint32_t writesize = vol->vol->ubi->mtd->writesize;
239 printf("%s: read logo partition failed, retry page by page.\n",__FUNCTION__);
240 for(nr = 0; nr < size; nr += writesize) {
241 uboot_ubi_read(vol, bmp_img + nr, nr, MIN(writesize,size - nr));
245 ubi_close_volume(vol);
247 lcd_display_logo(backlight_set,(ulong)bmp_img,size);
253 static void _boot_check_and_load_nv(int ubidev, char*vol, char *bakvol, char *addr, int size)
258 int len = size + NV_HEAD_LEN;
259 struct ubi_volume_desc *vol_desc;
260 struct ubi_volume_desc *bakvol_desc;
264 printf("%s malloc buf failed.\n",__func__);
267 bakbuf = malloc(len);
269 printf("%s malloc bakbuf failed.\n",__func__);
273 vol_desc = ubi_open_volume_nm(ubidev, vol, UBI_READWRITE);
274 if (IS_ERR(vol_desc)){
275 printf("cannot open \"%s\", error %d\n",vol, (int)PTR_ERR(vol_desc));
278 if(len == uboot_ubi_read(vol_desc, buf, 0, len)) {
279 header = (nv_header_t *)buf;
280 if(NV_HEAD_MAGIC == header->magic){
281 if(_chkNVEcc(buf+NV_HEAD_LEN, header->len,header->checksum))
285 printf("%s: ubi vol %s read failed!\n",__func__,vol);
288 bakvol_desc = ubi_open_volume_nm(ubidev, bakvol, UBI_READWRITE);
289 if (IS_ERR(bakvol_desc)){
290 printf("cannot open \"%s\", error %d\n",bakvol, (int)PTR_ERR(bakvol_desc));
293 if(len == uboot_ubi_read(bakvol_desc, bakbuf, 0, len)) {
294 header = (nv_header_t *)bakbuf;
295 if(NV_HEAD_MAGIC == header->magic){
296 if(_chkNVEcc(bakbuf+NV_HEAD_LEN, header->len,header->checksum))
300 printf("%s: ubi vol %s read failed!\n",__func__,bakvol);
303 if (!IS_ERR(vol_desc))
304 ubi_close_volume(vol_desc);
305 if (!IS_ERR(vol_desc))
306 ubi_close_volume(bakvol_desc);
310 printf("vol %s:both org and bak are damaged!\n",vol);
311 memset(addr, 0, size);
314 printf("vol %s:bak is damaged!\n",vol);
315 memcpy(addr,buf+NV_HEAD_LEN,size);
316 do_raw_data_write(bakvol, len, len, 0, buf);
319 printf("vol %s:org is damaged!\n",vol);
320 memcpy(addr,bakbuf+NV_HEAD_LEN,size);
321 do_raw_data_write(vol, len, len, 0, bakbuf);
324 printf("vol %s:both org and bak are ok!\n",vol);
325 memcpy(addr,buf+NV_HEAD_LEN,size);
328 printf("%s status error!\n",__func__);
338 static void _boot_load_required_image(int ubidev, vol_image_required_t info)
340 struct ubi_volume_desc *vol;
341 if(IMG_RAW == info.fs_type){
342 if(NULL != info.bak_vol){
343 _boot_check_and_load_nv(ubidev, info.vol, info.bak_vol, info.mem_addr, info.size);
345 vol = ubi_open_volume_nm(ubidev, info.vol, UBI_READWRITE);
347 printf("cannot open \"%s\", error %d",
348 info.vol, (int)PTR_ERR(vol));
351 if(info.size != uboot_ubi_read(vol, info.mem_addr, 0, info.size)){
353 uint32_t writesize = vol->vol->ubi->mtd->writesize;
354 printf("%s: ubi vol %s read failed,retry page by page.\n",__FUNCTION__,info.vol);
355 for(nr = 0; nr < info.size; nr += writesize) {
356 uboot_ubi_read(vol, info.mem_addr + nr, nr, MIN(writesize,info.size - nr));
359 ubi_close_volume(vol);
364 printf("image type not support now,,,do it later\n");
369 static int _boot_load_kernel_ramdisk_image(int ubidev, char *part, void *header, void *kaddr, void *rdaddr)
371 boot_img_hdr *hdr = (boot_img_hdr*)header;
372 struct ubi_volume_desc *vol;
373 unsigned int size,remain;
376 unsigned int dt_img_adr;
378 vol = ubi_open_volume_nm(ubidev, part, UBI_READONLY);
380 printf("cannot open \"%s\", error %d",
381 part, (int)PTR_ERR(vol));
385 //image header read and check
388 size = vol->vol->ubi->mtd->writesize;
389 ret = uboot_ubi_read(vol, (char*)hdr, offset, MIN(size,8192));
390 if(ret != MIN(size,8192)){
391 printf("%s: ubi vol %s read failed,error %d.give up boot!\n",__FUNCTION__,part,ret);
394 if(memcmp(hdr->magic, BOOT_MAGIC, BOOT_MAGIC_SIZE)){
397 printf("bad boot image header, give up boot!!!!\n");
400 if(size<hdr->page_size){
401 printf("size<hdr->page_size,read hdr again!\n");
402 //hdr buf len is 8192, so can't read more than it
403 ret = uboot_ubi_read(vol, (char*)hdr, offset, MIN(hdr->page_size,8192));
404 if(ret != MIN(hdr->page_size,8192)){
405 printf("%s: ubi vol %s read all hdr failed,error %d.give up boot!\n",__FUNCTION__,part,ret);
410 #ifdef CONFIG_OF_LIBFDT
411 //load kernel image to certain addr
412 offset = hdr->page_size;
413 size = hdr->kernel_size;
414 ret = uboot_ubi_read(vol, (char*)kaddr, offset, size);
416 printf("%s: kernel image read failed,error %d.give up boot!\n",__FUNCTION__,ret);
420 //load radmdisk image
421 offset = (offset +size+hdr->page_size-1)&~(hdr->page_size-1);
422 size = hdr->ramdisk_size;
423 ret = uboot_ubi_read(vol, (char*)rdaddr, offset, size);
425 printf("%s: ramdisk image read failed,error %d.give up boot!\n",__FUNCTION__,ret);
430 offset = (offset +size+hdr->page_size-1)&~(hdr->page_size-1);
432 dt_img_adr = RAMDISK_ADR - size - hdr->page_size;
434 printf("dt size error\n");
437 ret = uboot_ubi_read(vol, (char*)dt_img_adr, offset, size);
440 printf("%s:dt read error! offset:0x%x,size:0x%x,dt_img_adr:0x%x\n",__FUNCTION__,offset,size,dt_img_adr);
443 if (load_dtb((int)DT_ADR,(void*)dt_img_adr)){
444 printf("%s:dt load error!\n",__FUNCTION__);
448 //load kernel image to certain addr
449 offset = hdr->page_size;
450 size = hdr->kernel_size;
451 ret = uboot_ubi_read(vol, (char*)kaddr, offset, size);
453 printf("%s: kernel image read failed,error %d.give up boot!\n",__FUNCTION__,ret);
457 //load radmdisk image
458 offset = (offset +size+hdr->page_size-1)&~(hdr->page_size-1);
459 size = hdr->ramdisk_size;
460 ret = uboot_ubi_read(vol, (char*)rdaddr, offset, size);
462 printf("%s: ramdisk image read failed,error %d.give up boot!\n",__FUNCTION__,ret);
466 #ifdef CONFIG_SDRAMDISK
468 int sd_ramdisk_size = 0;
470 size = WDSP_ADR - RAMDISK_ADR;
472 size = TDDSP_ADR - RAMDISK_ADR;
475 sd_ramdisk_size = load_sd_ramdisk((uint8*)RAMDISK_ADR,size);
476 if (sd_ramdisk_size >0)
477 hdr->ramdisk_size = sd_ramdisk_size;
480 ubi_close_volume(vol);
484 int nand_ubi_dev_init(void)
487 static int initialized=0;
488 static int dev_num=-1;
491 //init mtd & ubi devices
492 ret = mtdparts_init();
494 printf("mtdparts init error...\n");
499 printf("ubi init error...\n");
502 //ubi attach mtd dev, and get the new ubi dev num
503 dev_num = _boot_ubi_attach_mtd(UBIPAC_PART);
510 void vlx_nand_boot(char * kernel_pname, char * cmdline, int backlight_set)
512 struct ubi_volume_desc *vol;
513 boot_img_hdr *hdr = (void *)raw_header;
517 long long start = get_ticks();
520 //init mtd ubi module and attach mtd dev
521 ubi_dev_num = nand_ubi_dev_init();
523 //dev num can't be a negative
524 printf("boot failed...\n");
528 #ifdef CONFIG_SPLASH_SCREEN
529 _boot_display_logo(ubi_dev_num, LOGO_PART, backlight_set);
530 performance_debug("7:");
534 //load required image which config in table
536 while(s_boot_image_table[i]){
538 while(s_boot_image_table[i][j].vol){
539 _boot_load_required_image(ubi_dev_num, s_boot_image_table[i][j]);
544 performance_debug("8:");
546 ret = _boot_load_kernel_ramdisk_image(ubi_dev_num, kernel_pname, hdr, KERNEL_ADR, RAMDISK_ADR);
547 performance_debug("9:");
549 printf("boot: load kernel error!\n");
553 load_image_time = get_ticks() - start;
554 if(creat_cmdline(cmdline,hdr)){
555 debugf("creat_cmdline failed\n");
558 performance_debug("10:");
559 #if BOOT_NATIVE_LINUX_MODEM