property/normal_mode.c

   1 #include "normal_mode.h"
   2 #include "calibration_detect.h"
   3 #include <mmc.h>
   4 #include <fat.h>
   5 #include <asm/arch/sprd_reg.h>
   6 #ifdef CONFIG_ARCH_SCX35L       //only for sharkL branch modem boot process
   7 #include <asm/arch/cp_boot.h>
   8 #endif
   9 #if defined(CONFIG_OF_LIBFDT)
  10 #include <libfdt.h>
  11 #include <fdt_support.h>
  12 #endif
  13
  14 #ifdef CONFIG_TIZEN
  15 #include "tizen_misc.h"
  16 #endif
  17
  18 #include <common.h>
  19 DECLARE_GLOBAL_DATA_PTR;
  20
  21 //#define SPRD_BM_UBOOT_SET
  22 #define FACTORY_PART "prodnv"
  23 #define CMDLINE_BUF_SIZE        (1024)
  24
  25 unsigned spl_data_buf[0x2000] __attribute__ ((aligned(4))) = {
  26 0};
  27
  28 unsigned harsh_data_buf[8] __attribute__ ((aligned(4))) = {
  29 0};
  30
  31 void *spl_data = spl_data_buf;
  32 void *harsh_data = harsh_data_buf;
  33 unsigned char raw_header[8192];
  34 const int SP09_MAX_PHASE_BUFF_SIZE = sizeof(SP09_PHASE_CHECK_T);
  35 unsigned int g_charger_mode = 0;
  36 unsigned int g_recovery_mode = 0;
  37 char serial_number_to_transfer[SP09_MAX_SN_LEN];
  38
  39 void sipc_addr_reset(void);
  40 extern int charger_connected(void);
  41 extern void power_down_devices(unsigned pd_cmd);
  42 #if (defined CONFIG_SC8810) || (defined CONFIG_SC8825) || (defined CONFIG_SC8830) || (defined CONFIG_SC9630)
  43 extern void MMU_DisableIDCM(void);
  44 #endif
  45 extern uint32_t load_lcd_id_to_kernel(void);
  46 extern int get_dram_cs_number(void);
  47 extern int get_dram_cs0_size(void);
  48 extern bool is_calibration_by_uart(void);
  49 extern unsigned int get_fgu_vol(void);
  50 extern unsigned int get_fgu_cur(void);
  51 extern void modem_entry(void);
  52 #ifdef CONFIG_EMMC_BOOT
  53 extern void Emmc_DisSdClk(void);
  54 #endif
  55 extern int fdt_fixup_adc_calibration_data(void *fdt);
  56 extern int fdt_fixup_boot_ram_log(void *fdt);
  57 extern int fdt_fixup_chosen_bootargs_board_private(void *fdt, const char *boot_mode);
  58 extern int do_fs_file_read(char *mpart, char *filenm, void *buf, int len);
  59 extern int do_raw_data_read(char *part, u32 size, u32 off, char *buf);
  60 #ifdef CONFIG_TIZEN
  61 extern uint8_t *load_mtp_offset_to_kernel(void);
  62 extern uint8_t load_elvss_offset_to_kernel(void);
  63 extern uint8_t *load_hbm_offset_to_kernel(void);
  64 extern void sprdchg_start_charge(void);
  65 extern int thor_save_env(char *str);
  66 extern void tizen_get_emmc_serial_number(unsigned int *uid);
  67 extern int load_nvitem(void);
  68 extern int load_modem_data(void);
  69 extern int load_dsp_data(void);
  70 #endif
  71
  72 extern void *lcd_base;
  73 #ifdef CONFIG_OF_LIBFDT
  74 static char boot_cmd[64];
  75 #endif
  76
  77 #ifdef SPRD_BM_UBOOT_SET
  78 /**
  79  *      sprd_bm_set_uboot_reg - set uboot bus monitor reg
  80  *      How to use this interface.:
  81  *      1. set the channel config you want to monitor the mem, e.g, channel 0-9, bm_cnt=0, bm_cnt<10.
  82  *      2. set the addr range, e.g 80000000-90000000,
  83  *              0x30040008 + bm_cnt * 0x10000) = 0x80000000;
  84  *              0x3004000C + bm_cnt * 0x10000) = 0x90000000;
  85  *      3. if you want mask the addr, just like the following code.
  86  *      4. please do not change others reg.
  87  *      5. if you make this config active, you must disable the bus monitor in kernel side.
  88  */
  89 static void sprd_bm_set_uboot_reg(void)
  90 {
  91         u8 bm_cnt;
  92         for (bm_cnt = 0; bm_cnt < 10; bm_cnt++) {
  93                 //if((bm_cnt == 5)||(bm_cnt == 6))//||(bm_cnt == 0)||(bm_cnt == 1)||(bm_cnt == 3))
  94                 //      continue;
  95                 *(volatile u32 *)(0x30040000 + bm_cnt * 0x10000) = 0x20000001;
  96                 *(volatile u32 *)(0x30040000 + bm_cnt * 0x10000) = 0x10000001;
  97                 *(volatile u32 *)(0x30040004 + bm_cnt * 0x10000) = 0x00000003;
  98                 *(volatile u32 *)(0x30040008 + bm_cnt * 0x10000) = 0x00620000;
  99                 *(volatile u32 *)(0x3004000c + bm_cnt * 0x10000) = 0x077ffffc;
 100                 *(volatile u32 *)(0x30040010 + bm_cnt * 0x10000) = 0xC0000000;
 101                 *(volatile u32 *)(0x30040014 + bm_cnt * 0x10000) = 0x0FFFFFFF;
 102                 *(volatile u32 *)(0x30040018 + bm_cnt * 0x10000) = 0x0FFFFFFF;
 103                 *(volatile u32 *)(0x3004001c + bm_cnt * 0x10000) = 0x00000000;
 104                 *(volatile u32 *)(0x30040020 + bm_cnt * 0x10000) = 0x00000000;
 105                 *(volatile u32 *)(0x30040024 + bm_cnt * 0x10000) = 0x00000000;
 106                 *(volatile u32 *)(0x30040028 + bm_cnt * 0x10000) = 0x00000000;
 107                 *(volatile u32 *)(0x3004002c + bm_cnt * 0x10000) = 0x00000000;
 108                 *(volatile u32 *)(0x30040030 + bm_cnt * 0x10000) = 0x00000000;
 109                 *(volatile u32 *)(0x30040034 + bm_cnt * 0x10000) = 0x00000000;
 110                 *(volatile u32 *)(0x30040038 + bm_cnt * 0x10000) = 0x00000000;
 111                 *(volatile u32 *)(0x3004003c + bm_cnt * 0x10000) = 0x00000000;
 112                 *(volatile u32 *)(0x30040040 + bm_cnt * 0x10000) = 0x00000000;
 113         }
 114 }
 115 #endif
 116
 117 unsigned short calc_checksum(unsigned char *dat, unsigned long len)
 118 {
 119         unsigned short num = 0;
 120         unsigned long chkSum = 0;
 121         while (len > 1) {
 122                 num = (unsigned short)(*dat);
 123                 dat++;
 124                 num |= (((unsigned short)(*dat)) << 8);
 125                 dat++;
 126                 chkSum += (unsigned long)num;
 127                 len -= 2;
 128         }
 129         if (len) {
 130                 chkSum += *dat;
 131         }
 132         chkSum = (chkSum >> 16) + (chkSum & 0xffff);
 133         chkSum += (chkSum >> 16);
 134         return (~chkSum);
 135 }
 136
 137 unsigned char _chkNVEcc(uint8_t * buf, uint32_t size, uint32_t checksum)
 138 {
 139         uint16_t crc;
 140
 141         crc = calc_checksum(buf, size);
 142         debugf("_chkNVEcc calcout 0x%x, org 0x%x\n", crc, checksum);
 143         return (crc == (uint16_t) checksum);
 144 }
 145
 146 #ifdef CONFIG_SECURE_BOOT
 147 //#define PRIMPUKPATH "/dev/block/mmcblk0boot0"
 148 //#define PRIMPUKSTART 512
 149 //#define PRIMPUKLEN 260
 150 void fdt_secureboot_param(fdt_blob)
 151 {
 152
 153         char *buf = NULL;
 154         int str_len = 0;
 155         buf = malloc(CMDLINE_BUF_SIZE);
 156         memset(buf, 0, CMDLINE_BUF_SIZE);
 157
 158 #ifdef PRIMPUKPATH
 159         str_len = strlen(buf);
 160         sprintf(&buf[str_len], " primpukpath=%s", PRIMPUKPATH); //"/dev/block/mmcblk0boot0");
 161         str_len = strlen(buf);
 162         buf[str_len] = '\0';
 163 #endif
 164 #ifdef PRIMPUKSTART
 165         str_len = strlen(buf);
 166         sprintf(&buf[str_len], " primpukstart=%d", PRIMPUKSTART);       //512);
 167         str_len = strlen(buf);
 168         buf[str_len] = '\0';
 169 #endif
 170 #ifdef PRIMPUKLEN
 171         str_len = strlen(buf);
 172         sprintf(&buf[str_len], " primpuklen=%d", PRIMPUKLEN);   //260);
 173         str_len = strlen(buf);
 174         buf[str_len] = '\0';
 175 #endif
 176         /*hash write by pc tool,but the hash value calculated by u-boot */
 177         /*if rom secure enable,do not need cal spl hash and pass to kernel */
 178         if (!secureboot_enabled()) {
 179
 180         int ret = get_spl_hash(harsh_data);
 181         if (ret) {
 182                 str_len = strlen(buf);
 183                 sprintf(&buf[str_len], " securesha1=%08x%08x%08x%08x%08x", *(uint32_t *) harsh_data, *(uint32_t *) (harsh_data + 4),
 184                         *(uint32_t *) (harsh_data + 8), *(uint32_t *) (harsh_data + 12), *(uint32_t *) (harsh_data + 16));
 185                 str_len = strlen(buf);
 186                 buf[str_len] = '\0';
 187         }
 188 }
 189         fdt_chosen_bootargs_append(fdt_blob, buf, 1);
 190 }
 191 #endif
 192
 193 #ifdef CONFIG_TIZEN
 194 int fdt_fixup_for_tizen(void *fdt)
 195 {
 196         char buf[1024];
 197         unsigned char uid[16];
 198         int ret, nodeoffset, str_len;
 199         char *ptr = buf;
 200         char *s;
 201         unsigned int val;
 202
 203         /* Tizen default cmdline: mem */
 204         ptr += sprintf(ptr, CMDLINE_DEFAULT_TIZEN " ");
 205
 206 #ifdef CONFIG_RAMDISK_BOOT
 207         if (g_recovery_mode)
 208                         ptr += sprintf(ptr, " bootmode=recovery");
 209
 210         ptr += sprintf(ptr, " root=/dev/ram0 rw initrd=0x%x,%dM",
 211                                 RAMDISK_ADR, RAMDISK_SIZE_MB);
 212 #else
 213         val = tizen_get_part_num(PARTS_ROOTFS);
 214         ptr += sprintf(ptr, " root=/dev/mmcblk0p%d ro rootfstype=ext4 rootwait", val);
 215         ptr += sprintf(ptr, " initrd=0x%x,0x%x", RAMDISK_ADR, 0);
 216 #endif
 217
 218         ptr += sprintf(ptr, " lcd_id=ID%06x", load_lcd_id_to_kernel());
 219         ptr += sprintf(ptr, " lcd_base=%x", CONFIG_FB_RAM_BASE);
 220
 221         ptr += sprintf(ptr, " mtp_offset=%s", (char *)load_mtp_offset_to_kernel());
 222         ptr += sprintf(ptr, " elvss_offset=0x%x", load_elvss_offset_to_kernel());
 223         ptr += sprintf(ptr, " hbm_offset=%s", (char *)load_hbm_offset_to_kernel());
 224
 225         ptr += sprintf(ptr, " wfixnv=0x%x,0x%x", WFIXNV_ADR, FIXNV_SIZE);
 226         ptr += sprintf(ptr, " wruntimenv=0x%x,0x%x", WRUNTIMENV_ADR, RUNTIMENV_SIZE);
 227
 228         switch (check_pm_status()) {
 229         case PM_STATE_LPM:
 230                 ptr += sprintf(ptr, " systemd.unit=charging-mode.target");
 231                 /* Write Charger state */
 232                 *(volatile unsigned int *)0xFC8 = 0x03;
 233                 sprdchg_start_charge();
 234                 break;
 235         case PM_STATE_NORMAL:
 236         default:
 237                 if (!g_recovery_mode) {
 238 #ifdef CONFIG_RAMDISK_BOOT
 239                         ptr += sprintf(ptr, " bootmode=ramdisk");
 240 #else
 241                         ptr += sprintf(ptr, " bootmode=normal");
 242 #endif
 243                 }
 244         }
 245         thor_save_env("normal");
 246
 247         s = getenv("hw_revision");
 248         if (s != NULL)
 249                 val = (u32) simple_strtoul(s, NULL, 10);
 250         else
 251                 val = 0;
 252         ptr += sprintf(ptr, " hw_revision=%d", val);
 253
 254         s = getenv("muic_rustproof");
 255         if (s != NULL)
 256                 val = (u32) simple_strtoul(s, NULL, 10);
 257         else
 258                 val = 0;
 259         ptr += sprintf(ptr, " muic_rustproof=%d", val);
 260
 261         s = getenv("dbg_level");
 262         if (s && (*s == 'a')) {
 263                 ptr += sprintf(ptr, " sec_debug.enable=1");
 264                 ptr += sprintf(ptr, " sec_debug.enable_user=0");
 265         } else if (s && (*s == 'h')) {
 266                 ptr += sprintf(ptr, " sec_debug.enable=1");
 267                 ptr += sprintf(ptr, " sec_debug.enable_user=1");
 268         } else if (s && (*s == 'm')) {
 269                 ptr += sprintf(ptr, " sec_debug.enable=1");
 270                 ptr += sprintf(ptr, " sec_debug.enable_user=0");
 271         } else {
 272                 ptr += sprintf(ptr, " sec_debug.enable=0");
 273                 ptr += sprintf(ptr, " sec_debug.enable_user=0");
 274         }
 275
 276         if (tizen_get_jig_state() == 2 || tizen_board_key_scan() == 0x81) {
 277                 s = getenv("console");
 278                 if (s && (*s == 'o'))
 279                         ptr += sprintf(ptr, " console=ttyS1,115200n8 loglevel=7");
 280                 else
 281                         ptr += sprintf(ptr, " console=ram loglevel=0");
 282         } else {
 283                         ptr += sprintf(ptr, " console=ram loglevel=0");
 284         }
 285
 286         s = getenv("sec_log");
 287         if (s && (*s == 'o')) {
 288                 s = getenv("sec_log_addr");
 289                 if (s) {
 290                         val = (u32) simple_strtoul(s, NULL, 16);
 291                         ptr += sprintf(ptr, " sec_log=0x%x@0x%x", SEC_LOG_LENGTH, val);
 292                 }
 293         }
 294
 295         ptr += sprintf(ptr, " bootloader.ver=%s", CONFIG_BOOTLOADER_VER);
 296
 297         s = getenv("emmc_checksum");
 298         if (s != NULL)
 299                 val = (u32) simple_strtoul(s, NULL, 10);
 300         else
 301                 val = 0;
 302
 303         ptr += sprintf(ptr, " tizenboot.emmc_checksum=%d", val);
 304
 305         ptr += sprintf(ptr, " mem_cs=%d, mem_cs0_sz=%08x",get_dram_cs_number(), get_dram_cs0_size());
 306
 307         /* TODO: connie, cordon */
 308         /* connie, cordon */
 309         /* toss ddi value for sysscope */
 310         //      set_system_info(CONFIG_MODEL_NAME, CONFIG_OPERATOR, CONFIG_REGION, VT_SPRD, 16);
 311         //      ptr += sprintf(ptr, " connie=%s", get_conniecmdline_value());
 312         //      ptr += sprintf(ptr, " cordon=%s", get_ddicmdline_value());
 313
 314         tizen_get_emmc_serial_number((unsigned int *)uid);
 315         ptr += sprintf(ptr, " tizenboot.serialno=%x%08x",
 316                         *(unsigned int *)(uid + 8), *(unsigned int *)(uid + 12));
 317
 318         /* if is uart calibraton, remove ttys1 console */
 319         if (is_calibration_by_uart())
 320                 val = 1;
 321         else
 322                 val = 0;
 323
 324         ptr += sprintf(ptr, " calmode=%d", is_calibration_by_uart());
 325         ptr += sprintf(ptr, " fgu_init=%d,%d", get_fgu_vol(), get_fgu_cur());
 326
 327         str_len = strlen(buf);
 328         buf[str_len] = '\0';
 329
 330         nodeoffset = fdt_path_offset (fdt, "/chosen");
 331         ret = fdt_setprop_string(fdt, nodeoffset, "bootargs", buf);
 332         return ret;
 333 }
 334 #endif
 335
 336 /*FDT_ADD_SIZE used to describe the size of the new bootargs items*/
 337 /*include lcd id, lcd base, etc*/
 338 #define FDT_ADD_SIZE (1024)
 339 static int start_linux(void)
 340 {
 341         void (*theKernel) (int zero, int arch, u32 params);
 342         u32 machine_type;
 343         u8 *fdt_blob;
 344         u32 fdt_size;
 345         int err;
 346
 347         machine_type = machine_arch_type;       /* get machine type */
 348         machine_type = 2014;    /* get machine type */
 349         theKernel = (void (*)(int, int, u32))KERNEL_ADR;        /* set the kernel address */
 350 #if !(defined(CONFIG_SC8830) || defined(CONFIG_SC9630))
 351         *(volatile u32 *)0x84001000 = 'j';
 352         *(volatile u32 *)0x84001000 = 'm';
 353         *(volatile u32 *)0x84001000 = 'p';
 354 #endif
 355
 356 #ifdef CONFIG_OF_LIBFDT
 357         fdt_blob = (u8 *) DT_ADR;
 358         if (fdt_check_header(fdt_blob) != 0) {
 359                 printk("image is not a fdt\n");
 360         }
 361         fdt_size = fdt_totalsize(fdt_blob);
 362
 363         err = fdt_open_into(fdt_blob, fdt_blob, fdt_size + FDT_ADD_SIZE);
 364         if (err != 0) {
 365                 printf("libfdt fdt_open_into(): %s\n", fdt_strerror(err));
 366         }
 367
 368 #ifdef CONFIG_TIZEN
 369         load_nvitem();
 370         load_modem_data();
 371         load_dsp_data();
 372
 373         sipc_addr_reset();
 374         modem_entry();
 375
 376         fdt_fixup_for_tizen(fdt_blob);
 377 #ifdef CONFIG_EMMC_BOOT
 378         Emmc_DisSdClk();
 379 #endif
 380
 381         theKernel(0, machine_type, (unsigned long)fdt_blob);
 382         while (1);
 383 #endif  /* CONFIG_TIZEN */
 384
 385         fdt_fixup_lcdid(fdt_blob);
 386         fdt_fixup_lcdbase(fdt_blob);
 387         fdt_fixup_calibration_parameter(fdt_blob);
 388         fdt_fixup_serialno(fdt_blob);
 389         fdt_fixup_adc_calibration_data(fdt_blob);
 390         fdt_fixup_dram_training(fdt_blob);
 391         fdt_fixup_ddr_size(fdt_blob);
 392 #ifdef CONFIG_SECURE_BOOT
 393         fdt_secureboot_param(fdt_blob);
 394 #endif
 395 #ifndef CONFIG_EMMC_BOOT
 396         fdt_fixup_mtd(fdt_blob);
 397 #endif
 398         debugf("start_linux boot_cmd: %s\n", boot_cmd);
 399         fdt_fixup_boot_mode(fdt_blob, boot_cmd);
 400         fdt_fixup_boot_ram_log(fdt_blob);
 401         fdt_fixup_chosen_bootargs_board_private(fdt_blob, boot_cmd);
 402 #ifdef SPRD_BM_UBOOT_SET
 403         sprd_bm_set_uboot_reg();
 404 #endif
 405         // start modem CP
 406         modem_entry();
 407 #ifdef CONFIG_EMMC_BOOT
 408         Emmc_DisSdClk();
 409 #endif
 410         theKernel(0, machine_type, (unsigned long)fdt_blob);
 411 #else   /* CONFIG_OF_LIBFDT */
 412         // start modem CP
 413         modem_entry();
 414 #ifdef CONFIG_EMMC_BOOT
 415         Emmc_DisSdClk();
 416 #endif
 417         theKernel(0, machine_type, DT_ADR);     /* jump to kernel with register set */
 418 #endif
 419
 420         while (1);
 421         return 0;
 422 }
 423
 424 void set_recovery_mode(unsigned int recovery_mode)
 425 {
 426         g_recovery_mode = recovery_mode;
 427 }
 428
 429 void lcd_display_logo(int backlight_set, ulong bmp_img, size_t size)
 430 {
 431 #ifdef CONFIG_SPLASH_SCREEN
 432         extern int lcd_display_bitmap(ulong bmp_image, int x, int y);
 433         extern void lcd_display(void);
 434         extern void *lcd_base;
 435         extern void Dcache_CleanRegion(unsigned int addr, unsigned int length);
 436         extern void set_backlight(uint32_t value);
 437         if (backlight_set == BACKLIGHT_ON) {
 438                 lcd_display_bitmap((ulong) bmp_img, 0, 0);
 439 #if defined(CONFIG_SC8810) || defined(CONFIG_SC8825) || defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
 440                 Dcache_CleanRegion((unsigned int)(lcd_base), size << 1);        //Size is to large.
 441 #endif
 442                 lcd_display();
 443 #ifdef CONFIG_SC8830_LVDS
 444                 mdelay(50);     //LiWei add
 445 #endif
 446                 mdelay(50);
 447                 set_backlight(255);
 448         } else {
 449                 memset(lcd_base, 0, size);
 450 #if defined(CONFIG_SC8810) || defined(CONFIG_SC8825) || defined(CONFIG_SC8830) || defined(CONFIG_SC9630)
 451                 Dcache_CleanRegion((unsigned int)(lcd_base), size << 1);        //Size is to large.
 452 #endif
 453                 lcd_display();
 454         }
 455 #endif
 456 }
 457
 458 int is_factorymode(void)
 459 {
 460         char factorymode_falg[8] = { 0 };
 461         int ret = 0;
 462
 463         if (do_fs_file_read(FACTORY_PART, "/factorymode.file", factorymode_falg, 8))
 464                 return 0;
 465         debugf("Checking factorymode :  factorymode_falg = %s \n", factorymode_falg);
 466         if (!strcmp(factorymode_falg, "1"))
 467                 ret = 1;
 468         else
 469                 ret = 0;
 470         debugf("Checking factorymode :  ret = %d \n", ret);
 471         return ret;
 472 }
 473
 474 char *get_product_sn(void)
 475 {
 476         SP09_PHASE_CHECK_T phase_check;
 477
 478         memset(serial_number_to_transfer, 0x0, SP09_MAX_SN_LEN);
 479
 480         strcpy(serial_number_to_transfer, "0123456789ABCDEF");
 481         if (do_raw_data_read(PRODUCTINFO_FILE_PATITION, sizeof(phase_check), 0, (char *)&phase_check)) {
 482                 debugf("%s: read miscdata error.\n", __func__);
 483                 return serial_number_to_transfer;
 484         }
 485
 486         if ((phase_check.Magic == SP09_SPPH_MAGIC_NUMBER) && strlen(phase_check.SN1)) {
 487                 memcpy(serial_number_to_transfer, phase_check.SN1, SP09_MAX_SN_LEN);
 488         }
 489
 490         return serial_number_to_transfer;
 491 }
 492
 493 #ifdef CONFIG_OF_LIBFDT
 494 static char *set_boot_mode(char *cmdline)
 495 {
 496         char *boot_mode_p = NULL;
 497
 498         memset(boot_cmd, 0, 64);
 499         boot_mode_p = strstr(cmdline, "androidboot");
 500         if (boot_mode_p) {
 501                 if (strlen(boot_mode_p) > 64) {
 502                         debugf("boot mode too long\n");
 503                         return NULL;
 504                 }
 505                 strcpy(boot_cmd, boot_mode_p);
 506         }
 507         debugf("CONFIG_OF_LIBFDT cmdline %s boot_cmd %s\n", cmdline, boot_cmd);
 508         return boot_cmd;
 509 }
 510
 511 int cmdline_lte_mode(char *buf, int str_len)
 512 {
 513         int offset = str_len;
 514 #ifdef CONFIG_SUPPORT_TDLTE
 515         offset += sprintf(buf + offset, " ltemode=tcsfb");
 516 #elif defined CONFIG_SUPPORT_WLTE
 517         offset += sprintf(buf + offset, " ltemode=fcsfb");
 518 #elif defined CONFIG_SUPPORT_LTE
 519         offset += sprintf(buf + offset, " ltemode=lcsfb");
 520 #endif
 521         return offset;
 522 }
 523
 524 #else
 525
 526 #ifndef CONFIG_FPGA
 527 int cmdline_fixup_lcd(char *buf, int str_len)
 528 {
 529         extern uint32_t load_lcd_id_to_kernel();
 530         uint32_t lcd_id;
 531         int offset;
 532
 533         offset = str_len;
 534         lcd_id = load_lcd_id_to_kernel();
 535         //add lcd id
 536         if (lcd_id) {
 537                 offset += sprintf(buf + offset, " lcd_id=ID");
 538                 offset += sprintf(buf + offset, "%x", lcd_id);
 539         }
 540         if (lcd_base != NULL) {
 541                 //add lcd frame buffer base, length should be lcd w*h*2(RGB565)
 542                 offset += sprintf(buf + offset, " lcd_base=");
 543                 offset += sprintf(buf + offset, "%x", lcd_base);
 544         }
 545
 546         return offset;
 547 }
 548 #endif
 549
 550 #ifdef USB_PHY_TUNE_VALUE
 551 int cmdline_fixup_usb_phy_tune(char *buf, int str_len)
 552 {
 553         /*transfer this value to kernel usb_hw.c */
 554         int offset = str_len;
 555
 556         offset += sprintf(buf + offset, " usb_phy_tune=");
 557         offset += sprintf(buf + offset, "%x", USB_PHY_TUNE_VALUE);
 558         //buf[offset] = '\0';
 559
 560         return offset;
 561 }
 562 #endif
 563 int cmdline_fixup_factorymode(char *buf, int str_len)
 564 {
 565         int offset = str_len;
 566
 567         if (1 == is_factorymode()) {
 568                 offset += sprintf(buf + offset, " factory=1");
 569         }
 570
 571         return offset;
 572 }
 573
 574 #if defined( CONFIG_AP_ADC_CALIBRATION)||defined(CONFIG_SC8830)||defined(CONFIG_SC9630)||(defined(CONFIG_SC8825) && (!(BOOT_NATIVE_LINUX)))
 575 int cmdline_fixup_adc_data(char *buf, int str_len)
 576 {
 577         extern int read_adc_calibration_data(char *buffer, int size);
 578         extern void CHG_SetADCCalTbl(unsigned int *adc_data);
 579         int offset = str_len;
 580         unsigned int *adc_data;
 581
 582         adc_data = malloc(64);
 583         if (adc_data) {
 584                 memset(adc_data, 0, 64);
 585                 if (0 < read_adc_calibration_data(adc_data, 48)) {
 586                         if (((adc_data[2] & 0xffff) < 4500) && ((adc_data[2] & 0xffff) > 3000) &&
 587                             ((adc_data[3] & 0xffff) < 4500) && ((adc_data[3] & 0xffff) > 3000)) {
 588                                 offset += sprintf(buf + offset, " adc_cal=%d,%d", adc_data[2], adc_data[3]);
 589                         }
 590                         /*just after fgu adc calibration,and no aux adc calibration,need save fgu adc parameters */
 591                         if ((0x00000002 == adc_data[10]) && (0x00000002 & adc_data[11])) {
 592                                 offset += sprintf(buf + offset, " fgu_cal=%d,%d,%d", adc_data[4], adc_data[5], adc_data[6]);
 593                         }
 594 #if (defined(CONFIG_SC8825) && (!(BOOT_NATIVE_LINUX)))
 595                         CHG_SetADCCalTbl(adc_data);
 596                         DCDC_Cal_ArmCore();
 597 #endif
 598                 }
 599                 free(adc_data);
 600         }
 601
 602         return offset;
 603 }
 604 #endif
 605
 606 int cmdline_fixup_harsh_data(char *buf, int str_len)
 607 {
 608         int offset = str_len;
 609
 610         if (0 != read_spldata()) {
 611                 debugf("read_spldata failed\n");
 612                 free(buf);
 613                 return 0;
 614         }
 615         if (harsh_data == NULL) {
 616                 debugf("harsh_data malloc failed\n");
 617                 free(buf);
 618                 return 0;
 619         }
 620         debugf("spl_data adr 0x%x harsh_data adr 0x%x\n", spl_data, harsh_data);
 621         if (cal_md5(spl_data, CONFIG_SPL_LOAD_LEN, harsh_data)) {
 622                 offset += sprintf(buf + offset, " securemd5=%08x%08x%08x%08x", *(uint32_t *) harsh_data, *(uint32_t *) (harsh_data + 4),
 623                                   *(uint32_t *) (harsh_data + 8), *(uint32_t *) (harsh_data + 12));
 624         }
 625         return offset;
 626 }
 627
 628 int cmdline_fixup_serialno(char *buf, int str_len)
 629 {
 630         int offset;
 631         char *sn = get_product_sn();
 632
 633         offset = str_len;
 634         offset += sprintf(buf + offset, " androidboot.serialno=%s", sn ? sn : "0123456789ABCDEF");
 635
 636         return offset;
 637 }
 638
 639 #if defined(CONFIG_SC8830) || (defined CONFIG_SC9630)
 640 int cmdline_fixup_fgu(char *buf, int str_len)
 641 {
 642         extern unsigned int fgu_cur;
 643         extern unsigned int fgu_vol;
 644         int offset;
 645
 646         offset = str_len;
 647         offset += sprintf(buf + offset, " fgu_init=%d,%d", fgu_vol, fgu_cur);
 648
 649         return offset;
 650 }
 651 #endif
 652
 653 int cmdline_fixup_apct_param(char *buf, int str_len)
 654 {
 655         extern long long lcd_init_time;
 656         extern long long load_image_time;
 657         int offset;
 658
 659         offset = str_len;
 660         offset += sprintf(buf + offset, " lcd_init=%lld", lcd_init_time);
 661         offset += sprintf(buf + offset, " load_image=%lld", load_image_time);
 662         offset += sprintf(buf + offset, " pl_t=%lld", get_ticks());
 663
 664         return offset;
 665 }
 666 #endif
 667
 668 void cmdline_set_cp_cmdline(char *buf, int str_len)
 669 {
 670         char *nv_info;
 671 #ifdef CONFIG_SUPPORT_TD
 672         nv_info = (char *)(((volatile u32 *)CALIBRATION_FLAG));
 673         sprintf(nv_info, buf);
 674         nv_info[str_len] = '\0';
 675         debugf("nv_info:[%08lx]%s \n", (unsigned long)nv_info, nv_info);
 676 #endif
 677 #ifdef CONFIG_SUPPORT_W
 678         nv_info = (char *)((volatile u32 *)CALIBRATION_FLAG_WCDMA);
 679         sprintf(nv_info, buf);
 680         nv_info[str_len] = '\0';
 681         debugf("nv_info:[%08lx]%s \n", (unsigned long)nv_info, nv_info);
 682 #endif
 683 #ifdef CONFIG_SC9630
 684 #ifdef  CONFIG_CP0_ARM0_BOOT
 685         nv_info = (char *)(((volatile u32 *)CALIBRATION_FLAG_CP0));
 686         sprintf(nv_info, buf);
 687         nv_info[str_len] = '\0';
 688         debugf("nv_info:[%08lx]%s \n", (unsigned long)nv_info, nv_info);
 689 #endif
 690         nv_info = (char *)(((volatile u32 *)CALIBRATION_FLAG_CP1));
 691         sprintf(nv_info, buf);
 692         nv_info[str_len] = '\0';
 693         debugf("nv_info:[%08lx]%s \n", (unsigned long)nv_info, nv_info);
 694 #endif
 695 }
 696
 697 int creat_cmdline(char *cmdline, boot_img_hdr * hdr)
 698 {
 699         char *buf;
 700         int offset = 0;
 701
 702         if (cmdline == NULL) {
 703                 return -1;
 704         }
 705         buf = malloc(CMDLINE_BUF_SIZE);
 706         memset(buf, 0, CMDLINE_BUF_SIZE);
 707
 708 #ifdef CONFIG_OF_LIBFDT
 709         if (set_boot_mode(cmdline)) {
 710                 if (cmdline && cmdline[0]) {
 711                         offset += sprintf(buf, " %s", cmdline);
 712                 }
 713 #ifdef CONFIG_AP_VERSION
 714                 offset += sprintf(buf + offset, " apv=\"%s\"", CONFIG_AP_VERSION);
 715 #endif
 716                 offset = cmdline_lte_mode(buf, offset);
 717                 cmdline_set_cp_cmdline(buf, offset);
 718                 if (buf != NULL) {
 719                         free(buf);
 720                 }
 721                 return 0;
 722         } else {
 723                 if (buf != NULL) {
 724                         free(buf);
 725                 }
 726                 return -1;
 727         }
 728 #else
 729
 730 //      if (hdr) {
 731 //              offset += sprintf(buf, "initrd=0x%x,0x%x", RAMDISK_ADR, hdr->ramdisk_size);
 732 //      }
 733 /* preset loop_per_jiffy */
 734 #ifdef CONFIG_LOOP_PER_JIFFY
 735         offset += sprintf(buf + offset, " lpj=%d", CONFIG_LOOP_PER_JIFFY);
 736 #endif
 737 #ifdef CONFIG_AP_VERSION
 738         offset += sprintf(buf + offset, " apv=\"%s\"", CONFIG_AP_VERSION);
 739 #endif
 740         if (cmdline && cmdline[0]) {
 741                 offset += sprintf(buf + offset, " %s", cmdline);
 742         }
 743 #ifndef CONFIG_FPGA
 744         offset = cmdline_fixup_lcd(buf, offset);
 745 #endif
 746 #ifdef USB_PHY_TUNE_VALUE
 747         offset = cmdline_fixup_usb_phy_tune(buf, offset);
 748 #endif
 749         offset = cmdline_fixup_factorymode(buf, offset);
 750         offset += sprintf(buf + offset, " no_console_suspend");
 751 #ifdef CONFIG_RAM_CONSOLE
 752 /* Fill ram log base address and size to cmdline.
 753 It will be used when assigning reserve memory in kernel and dump ram log*/
 754         offset += sprintf(buf + offset, " boot_ram_log=%#010x,%#x", CONFIG_RAM_CONSOLE_START, CONFIG_RAM_CONSOLE_SIZE);
 755 #endif
 756         offset = cmdline_fixup_serialno(buf, offset);
 757         ret = cmdline_fixup_harsh_data(buf, offset);
 758         if (ret) {
 759                 offset = ret;
 760         } else {
 761                 return -1;
 762         }
 763 #if defined(CONFIG_AP_ADC_CALIBRATION)||defined(CONFIG_SC8830) || defined(CONFIG_SC9630) || (defined(CONFIG_SC8825) && (!(BOOT_NATIVE_LINUX)))
 764         offset = cmdline_fixup_adc_data(buf, offset);
 765 #if defined(CONFIG_SC8830)
 766         offset = cmdline_fixup_fgu(buf, offset);
 767 #endif
 768         offset = cmdline_fixup_apct_param(buf, offset);
 769 #endif
 770         cmdline_set_cp_cmdline(buf, offset);
 771
 772         debugf("cmdline_len = %d \n pass cmdline: %s \n", strlen(buf), buf);
 773         creat_atags(VLX_TAG_ADDR, buf, NULL, 0);
 774
 775         if (buf != NULL) {
 776                 free(buf);
 777         }
 778         return 0;
 779 #endif
 780 }
 781
 782 void vlx_entry()
 783 {
 784         /*down the device if charger disconnect during calibration detect. */
 785         if (g_charger_mode && !charger_connected()) {
 786                 g_charger_mode = 0;
 787                 power_down_devices(0);
 788                 while (1) ;
 789         }
 790 #if !(defined CONFIG_SC8810 || defined CONFIG_TIGER || defined CONFIG_SC8830) || (defined CONFIG_SC9630)
 791         MMU_InvalideICACHEALL();
 792 #endif
 793
 794 #if (defined CONFIG_SC8810) || (defined CONFIG_SC8825) || (defined CONFIG_SC8830) || (defined CONFIG_SC9630)
 795         MMU_DisableIDCM();
 796 #endif
 797
 798 #ifdef REBOOT_FUNCTION_INUBOOT
 799         reboot_func();
 800 #endif
 801
 802 #if BOOT_NATIVE_LINUX
 803         start_linux();
 804 #else
 805         void (*entry) (void) = (void *)VMJALUNA_ADR;
 806         entry();
 807 #endif
 808 }
 809
 810 void normal_mode(void)
 811 {
 812 #if defined (CONFIG_SC8810) || defined (CONFIG_SC8825) || defined (CONFIG_SC8830) || (defined CONFIG_SC9630)
 813         //MMU_Init(CONFIG_MMU_TABLE_ADDR);
 814         vibrator_hw_init();
 815 #endif
 816         set_vibrator(1);
 817
 818 #ifndef UART_CONSOLE_SUPPORT
 819 #ifdef CONFIG_SC7710G2
 820         extern int serial1_SwitchToModem(void);
 821         serial1_SwitchToModem();
 822 #endif
 823 #endif
 824
 825 #if BOOT_NATIVE_LINUX
 826         vlx_nand_boot(BOOT_PART, CONFIG_BOOTARGS, BACKLIGHT_ON);
 827 #else
 828         vlx_nand_boot(BOOT_PART, NULL, BACKLIGHT_ON);
 829 #endif
 830
 831 }
 832 void calibration_mode(void)
 833 {
 834         debugf("calibration_mode\n");
 835 #if defined(BOOT_NATIVE_LINUX_MODEM)
 836         vlx_nand_boot(RECOVERY_PART,calibration_cmd_buf, BACKLIGHT_OFF);
 837 #else
 838         vlx_nand_boot(BOOT_PART, calibration_cmd_buf, BACKLIGHT_OFF);
 839 #endif
 840 }
 841 void autotest_mode(void)
 842 {
 843         debugf("autotest_mode\n");
 844         vlx_nand_boot(BOOT_PART, calibration_cmd_buf, BACKLIGHT_OFF);
 845 }
 846
 847 void special_mode(void)
 848 {
 849         debugf("special_mode\n");
 850 #if BOOT_NATIVE_LINUX
 851         vlx_nand_boot(BOOT_PART, CONFIG_BOOTARGS " androidboot.mode=special", BACKLIGHT_OFF);
 852 #else
 853         vlx_nand_boot(BOOT_PART, "androidboot.mode=special", BACKLIGHT_OFF);
 854 #endif
 855
 856 }
 857
 858 void iq_mode(void)
 859 {
 860         debugf("iq_mode\n");
 861 #if BOOT_NATIVE_LINUX
 862         vlx_nand_boot(BOOT_PART, CONFIG_BOOTARGS " androidboot.mode=iq", BACKLIGHT_OFF);
 863 #else
 864         vlx_nand_boot(BOOT_PART, " androidboot.mode=iq", BACKLIGHT_OFF);
 865 #endif
 866
 867 }
 868
 869 #ifdef CONFIG_GENERIC_MMC
 870 #define MODEM_MEMORY_NAME "modem_memory.log"
 871 #define MODEM_MEMORY_SIZE  (22 * 1024 * 1024)
 872 #ifdef CONFIG_SC8810
 873 #define MODEM_MEMORY_ADDR 0
 874 #elif defined (CONFIG_SC8825) || defined (CONFIG_TIGER) || defined(CONFIG_SC8830) || (defined CONFIG_SC9630)
 875 #define MODEM_MEMORY_ADDR 0x80000000
 876 #endif
 877 #endif
 878 void watchdog_mode(void)
 879 {
 880         debugf("watchdog_mode\n");
 881 #if BOOT_NATIVE_LINUX
 882         vlx_nand_boot(BOOT_PART, CONFIG_BOOTARGS " androidboot.mode=wdgreboot", BACKLIGHT_OFF);
 883 #else
 884         vlx_nand_boot(BOOT_PART, "androidboot.mode=wdgreboot", BACKLIGHT_OFF);
 885 #endif
 886 }
 887
 888 void unknow_reboot_mode(void)
 889 {
 890         debugf("unknow_reboot_mode\n");
 891 #if BOOT_NATIVE_LINUX
 892         vlx_nand_boot(BOOT_PART, CONFIG_BOOTARGS " androidboot.mode=unknowreboot", BACKLIGHT_OFF);
 893 #else
 894         vlx_nand_boot(BOOT_PART, "androidboot.mode=unknowreboot", BACKLIGHT_OFF);
 895 #endif
 896 }
 897
 898 void panic_reboot_mode(void)
 899 {
 900         debugf("%s\n", __func__);
 901 #if BOOT_NATIVE_LINUX
 902         vlx_nand_boot(BOOT_PART, CONFIG_BOOTARGS " androidboot.mode=panic", BACKLIGHT_OFF);
 903 #else
 904         vlx_nand_boot(BOOT_PART, "androidboot.mode=panic", BACKLIGHT_OFF);
 905 #endif
 906 }
 907
 908 #if BOOT_NATIVE_LINUX_MODEM
 909
 910 void sipc_addr_reset(void)
 911 {
 912 #ifdef CONFIG_SC8825
 913         memset((void *)SIPC_APCP_START_ADDR, 0x0, SIPC_APCP_RESET_ADDR_SIZE);
 914 #elif defined (CONFIG_SC8830)
 915 #if defined(CONFIG_SUPPORT_TD) || defined(CONFIG_SC9620OPENPHONE) || defined(CONFIG_SC9620FPGA)
 916         memset((void *)SIPC_TD_APCP_START_ADDR, 0x0, SIPC_APCP_RESET_ADDR_SIZE);
 917
 918 #elif defined(CONFIG_SUPPORT_W)
 919
 920         memset((void *)SIPC_WCDMA_APCP_START_ADDR, 0x0, SIPC_APCP_RESET_ADDR_SIZE);
 921 #else
 922 #ifndef CONFIG_NOT_BOOT_TD_MODEM
 923         memset((void *)SIPC_TD_APCP_START_ADDR, 0x0, SIPC_APCP_RESET_ADDR_SIZE);
 924 #endif
 925 #ifndef CONFIG_NOT_BOOT_W_MODEM
 926         memset((void *)SIPC_WCDMA_APCP_START_ADDR, 0x0, SIPC_APCP_RESET_ADDR_SIZE);
 927 #endif
 928 #endif
 929 #ifdef CONFIG_SP8830WCN
 930         memset((void *)SIPC_WCN_APCP_START_ADDR, 0x0, SIPC_APCP_RESET_ADDR_SIZE);
 931 #endif
 932 #endif
 933
 934 #ifdef CONFIG_SC9630
 935 #ifdef CONFIG_CP0_ARM0_BOOT
 936         memset((void *)SIPC_GGE_APCP_START_ADDR, 0x0, SIPC_APCP_RESET_ADDR_SIZE);
 937 #endif
 938         memset((void *)SIPC_LTE_APCP_START_ADDR, 0x0, SIPC_APCP_RESET_ADDR_SIZE);
 939         memset((void *)SIPC_PMIC_APCP_START_ADDR, 0x0, SIPC_APCP_RESET_ADDR_SIZE);
 940 #endif
 941
 942 }
 943
 944 #endif