board/ait/cam_enc_4xx/cam_enc_4xx.c

   1 /*
   2  * Copyright (C) 2009 Texas Instruments Incorporated
   3  *
   4  * Copyright (C) 2011
   5  * Heiko Schocher, DENX Software Engineering, hs@denx.de.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  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 <common.h>
  23 #include <errno.h>
  24 #include <hush.h>
  25 #include <linux/mtd/nand.h>
  26 #include <nand.h>
  27 #include <miiphy.h>
  28 #include <netdev.h>
  29 #include <asm/io.h>
  30 #include <asm/arch/hardware.h>
  31 #include <asm/arch/nand_defs.h>
  32 #include <asm/arch/davinci_misc.h>
  33 #ifdef CONFIG_DAVINCI_MMC
  34 #include <mmc.h>
  35 #include <asm/arch/sdmmc_defs.h>
  36 #endif
  37
  38 DECLARE_GLOBAL_DATA_PTR;
  39
  40 #ifndef CONFIG_SPL_BUILD
  41 static struct davinci_timer *timer =
  42         (struct davinci_timer *)DAVINCI_TIMER3_BASE;
  43
  44 static unsigned long get_timer_val(void)
  45 {
  46         unsigned long now = readl(&timer->tim34);
  47
  48         return now;
  49 }
  50
  51 static int timer_running(void)
  52 {
  53         return readl(&timer->tcr) &
  54                 (DV_TIMER_TCR_ENAMODE_MASK << DV_TIMER_TCR_ENAMODE34_SHIFT);
  55 }
  56
  57 static void stop_timer(void)
  58 {
  59         writel(0x0, &timer->tcr);
  60         return;
  61 }
  62
  63 int checkboard(void)
  64 {
  65         printf("Board: AIT CAM ENC 4XX\n");
  66         return 0;
  67 }
  68
  69 int board_init(void)
  70 {
  71         gd->bd->bi_boot_params = PHYS_SDRAM_1 + 0x100;
  72
  73         return 0;
  74 }
  75
  76 #ifdef CONFIG_DRIVER_TI_EMAC
  77 static int cam_enc_4xx_check_network(void)
  78 {
  79         char *s;
  80
  81         s = getenv("ethaddr");
  82         if (!s)
  83                 return -EINVAL;
  84
  85         if (!is_valid_ether_addr((const u8 *)s))
  86                 return -EINVAL;
  87
  88         s = getenv("ipaddr");
  89         if (!s)
  90                 return -EINVAL;
  91
  92         s = getenv("netmask");
  93         if (!s)
  94                 return -EINVAL;
  95
  96         s = getenv("serverip");
  97         if (!s)
  98                 return -EINVAL;
  99
 100         s = getenv("gatewayip");
 101         if (!s)
 102                 return -EINVAL;
 103
 104         return 0;
 105 }
 106 int board_eth_init(bd_t *bis)
 107 {
 108         int ret;
 109
 110         ret = cam_enc_4xx_check_network();
 111         if (ret)
 112                 return ret;
 113
 114         davinci_emac_initialize();
 115
 116         return 0;
 117 }
 118 #endif
 119
 120 #ifdef CONFIG_NAND_DAVINCI
 121 static int
 122 davinci_std_read_page_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
 123                                    uint8_t *buf, int page)
 124 {
 125         struct nand_chip *this = mtd->priv;
 126         int i, eccsize = chip->ecc.size;
 127         int eccbytes = chip->ecc.bytes;
 128         int eccsteps = chip->ecc.steps;
 129         uint8_t *p = buf;
 130         uint8_t *oob = chip->oob_poi;
 131
 132         chip->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
 133
 134         chip->read_buf(mtd, oob, mtd->oobsize);
 135
 136         chip->cmdfunc(mtd, NAND_CMD_READ0, 0x0, page & this->pagemask);
 137
 138
 139         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
 140                 int stat;
 141
 142                 chip->ecc.hwctl(mtd, NAND_ECC_READ);
 143                 chip->read_buf(mtd, p, eccsize);
 144                 chip->ecc.hwctl(mtd, NAND_ECC_READSYN);
 145
 146                 if (chip->ecc.prepad)
 147                         oob += chip->ecc.prepad;
 148
 149                 stat = chip->ecc.correct(mtd, p, oob, NULL);
 150
 151                 if (stat == -1)
 152                         mtd->ecc_stats.failed++;
 153                 else
 154                         mtd->ecc_stats.corrected += stat;
 155
 156                 oob += eccbytes;
 157
 158                 if (chip->ecc.postpad)
 159                         oob += chip->ecc.postpad;
 160         }
 161
 162         /* Calculate remaining oob bytes */
 163         i = mtd->oobsize - (oob - chip->oob_poi);
 164         if (i)
 165                 chip->read_buf(mtd, oob, i);
 166
 167         return 0;
 168 }
 169
 170 static void davinci_std_write_page_syndrome(struct mtd_info *mtd,
 171                                     struct nand_chip *chip, const uint8_t *buf)
 172 {
 173         unsigned char davinci_ecc_buf[NAND_MAX_OOBSIZE];
 174         struct nand_chip *this = mtd->priv;
 175         int i, eccsize = chip->ecc.size;
 176         int eccbytes = chip->ecc.bytes;
 177         int eccsteps = chip->ecc.steps;
 178         int chunk = chip->ecc.bytes + chip->ecc.prepad + chip->ecc.postpad;
 179         int offset = 0;
 180         const uint8_t *p = buf;
 181         uint8_t *oob = chip->oob_poi;
 182
 183         for (i = 0; eccsteps; eccsteps--, i += eccbytes, p += eccsize) {
 184                 chip->ecc.hwctl(mtd, NAND_ECC_WRITE);
 185                 chip->write_buf(mtd, p, eccsize);
 186
 187                 /* Calculate ECC without prepad */
 188                 chip->ecc.calculate(mtd, p, oob + chip->ecc.prepad);
 189
 190                 if (chip->ecc.prepad) {
 191                         offset = (chip->ecc.steps - eccsteps) * chunk;
 192                         memcpy(&davinci_ecc_buf[offset], oob, chip->ecc.prepad);
 193                         oob += chip->ecc.prepad;
 194                 }
 195
 196                 offset = ((chip->ecc.steps - eccsteps) * chunk) +
 197                                 chip->ecc.prepad;
 198                 memcpy(&davinci_ecc_buf[offset], oob, eccbytes);
 199                 oob += eccbytes;
 200
 201                 if (chip->ecc.postpad) {
 202                         offset = ((chip->ecc.steps - eccsteps) * chunk) +
 203                                         chip->ecc.prepad + eccbytes;
 204                         memcpy(&davinci_ecc_buf[offset], oob,
 205                                 chip->ecc.postpad);
 206                         oob += chip->ecc.postpad;
 207                 }
 208         }
 209
 210         /*
 211          * Write the sparebytes into the page once
 212          * all eccsteps have been covered
 213          */
 214         for (i = 0; i < mtd->oobsize; i++)
 215                 writeb(davinci_ecc_buf[i], this->IO_ADDR_W);
 216
 217         /* Calculate remaining oob bytes */
 218         i = mtd->oobsize - (oob - chip->oob_poi);
 219         if (i)
 220                 chip->write_buf(mtd, oob, i);
 221 }
 222
 223 static int davinci_std_write_oob_syndrome(struct mtd_info *mtd,
 224                                    struct nand_chip *chip, int page)
 225 {
 226         int pos, status = 0;
 227         const uint8_t *bufpoi = chip->oob_poi;
 228
 229         pos = mtd->writesize;
 230
 231         chip->cmdfunc(mtd, NAND_CMD_SEQIN, pos, page);
 232
 233         chip->write_buf(mtd, bufpoi, mtd->oobsize);
 234
 235         chip->cmdfunc(mtd, NAND_CMD_PAGEPROG, -1, -1);
 236         status = chip->waitfunc(mtd, chip);
 237
 238         return status & NAND_STATUS_FAIL ? -1 : 0;
 239 }
 240
 241 static int davinci_std_read_oob_syndrome(struct mtd_info *mtd,
 242         struct nand_chip *chip, int page, int sndcmd)
 243 {
 244         struct nand_chip *this = mtd->priv;
 245         uint8_t *buf = chip->oob_poi;
 246         uint8_t *bufpoi = buf;
 247
 248         chip->cmdfunc(mtd, NAND_CMD_READOOB, 0x0, page & this->pagemask);
 249
 250         chip->read_buf(mtd, bufpoi, mtd->oobsize);
 251
 252         return 1;
 253 }
 254
 255 static void nand_dm365evm_select_chip(struct mtd_info *mtd, int chip)
 256 {
 257         struct nand_chip        *this = mtd->priv;
 258         unsigned long           wbase = (unsigned long) this->IO_ADDR_W;
 259         unsigned long           rbase = (unsigned long) this->IO_ADDR_R;
 260
 261         if (chip == 1) {
 262                 __set_bit(14, &wbase);
 263                 __set_bit(14, &rbase);
 264         } else {
 265                 __clear_bit(14, &wbase);
 266                 __clear_bit(14, &rbase);
 267         }
 268         this->IO_ADDR_W = (void *)wbase;
 269         this->IO_ADDR_R = (void *)rbase;
 270 }
 271
 272 int board_nand_init(struct nand_chip *nand)
 273 {
 274         davinci_nand_init(nand);
 275         nand->select_chip = nand_dm365evm_select_chip;
 276
 277         return 0;
 278 }
 279
 280 struct nand_ecc_ctrl org_ecc;
 281 static int notsaved = 1;
 282
 283 static int nand_switch_hw_func(int mode)
 284 {
 285         struct nand_chip *nand;
 286         struct mtd_info *mtd;
 287
 288         if (nand_curr_device < 0 ||
 289             nand_curr_device >= CONFIG_SYS_MAX_NAND_DEVICE ||
 290             !nand_info[nand_curr_device].name) {
 291                 printf("Error: Can't switch hw functions," \
 292                         " no devices available\n");
 293                 return -1;
 294         }
 295
 296         mtd = &nand_info[nand_curr_device];
 297         nand = mtd->priv;
 298
 299         if (mode == 0) {
 300                 if (notsaved == 0) {
 301                         printf("switching to uboot hw functions.\n");
 302                         memcpy(&nand->ecc, &org_ecc,
 303                                 sizeof(struct nand_ecc_ctrl));
 304                 }
 305         } else {
 306                 /* RBL */
 307                 printf("switching to RBL hw functions.\n");
 308                 if (notsaved == 1) {
 309                         memcpy(&org_ecc, &nand->ecc,
 310                                 sizeof(struct nand_ecc_ctrl));
 311                         notsaved = 0;
 312                 }
 313                 nand->ecc.mode = NAND_ECC_HW_SYNDROME;
 314                 nand->ecc.prepad = 6;
 315                 nand->ecc.read_page = davinci_std_read_page_syndrome;
 316                 nand->ecc.write_page = davinci_std_write_page_syndrome;
 317                 nand->ecc.read_oob = davinci_std_read_oob_syndrome;
 318                 nand->ecc.write_oob = davinci_std_write_oob_syndrome;
 319         }
 320         return mode;
 321 }
 322
 323 static int hwmode;
 324
 325 static int do_switch_ecc(cmd_tbl_t *cmdtp, int flag, int argc,
 326                 char *const argv[])
 327 {
 328         if (argc != 2)
 329                 goto usage;
 330         if (strncmp(argv[1], "rbl", 2) == 0)
 331                 hwmode = nand_switch_hw_func(1);
 332         else if (strncmp(argv[1], "uboot", 2) == 0)
 333                 hwmode = nand_switch_hw_func(0);
 334         else
 335                 goto usage;
 336
 337         return 0;
 338
 339 usage:
 340         printf("Usage: nandrbl %s\n", cmdtp->usage);
 341         return 1;
 342 }
 343
 344 U_BOOT_CMD(
 345         nandrbl, 2, 1,  do_switch_ecc,
 346         "switch between rbl/uboot NAND ECC calculation algorithm",
 347         "[rbl/uboot] - Switch between rbl/uboot NAND ECC algorithm"
 348 );
 349
 350
 351 #endif /* #ifdef CONFIG_NAND_DAVINCI */
 352
 353 #ifdef CONFIG_DAVINCI_MMC
 354 static struct davinci_mmc mmc_sd0 = {
 355         .reg_base       = (struct davinci_mmc_regs *)DAVINCI_MMC_SD0_BASE,
 356         .input_clk      = 121500000,
 357         .host_caps      = MMC_MODE_4BIT,
 358         .voltages       = MMC_VDD_32_33 | MMC_VDD_33_34,
 359         .version        = MMC_CTLR_VERSION_2,
 360 };
 361
 362 int board_mmc_init(bd_t *bis)
 363 {
 364         int err;
 365
 366         /* Add slot-0 to mmc subsystem */
 367         err = davinci_mmc_init(bis, &mmc_sd0);
 368
 369         return err;
 370 }
 371 #endif
 372
 373 int board_late_init(void)
 374 {
 375         struct davinci_gpio *gpio = davinci_gpio_bank45;
 376
 377         /* 24MHz InputClock / 15 prediv -> 1.6 MHz timer running */
 378         while ((get_timer_val() < CONFIG_AIT_TIMER_TIMEOUT) &&
 379                 timer_running())
 380                 ;
 381
 382         /* 1 sec reached -> stop timer, clear all LED */
 383         stop_timer();
 384         clrbits_le32(&gpio->out_data, CONFIG_CAM_ENC_LED_MASK);
 385         return 0;
 386 }
 387
 388 void reset_phy(void)
 389 {
 390         char *name = "GENERIC @ 0x00";
 391
 392         /* reset the phy */
 393         miiphy_reset(name, 0x0);
 394 }
 395
 396 #else /* #ifndef CONFIG_SPL_BUILD */
 397 static void cam_enc_4xx_set_all_led(void)
 398 {
 399         struct davinci_gpio *gpio = davinci_gpio_bank45;
 400
 401         setbits_le32(&gpio->out_data, CONFIG_CAM_ENC_LED_MASK);
 402 }
 403
 404 /*
 405  * TIMER 0 is used for tick
 406  */
 407 static struct davinci_timer *timer =
 408         (struct davinci_timer *)DAVINCI_TIMER3_BASE;
 409
 410 #define TIMER_LOAD_VAL  0xffffffff
 411 #define TIM_CLK_DIV     16
 412
 413 static int cam_enc_4xx_timer_init(void)
 414 {
 415         /* We are using timer34 in unchained 32-bit mode, full speed */
 416         writel(0x0, &timer->tcr);
 417         writel(0x0, &timer->tgcr);
 418         writel(0x06 | ((TIM_CLK_DIV - 1) << 8), &timer->tgcr);
 419         writel(0x0, &timer->tim34);
 420         writel(TIMER_LOAD_VAL, &timer->prd34);
 421         writel(2 << 22, &timer->tcr);
 422         return 0;
 423 }
 424
 425 void board_gpio_init(void)
 426 {
 427         struct davinci_gpio *gpio;
 428
 429         cam_enc_4xx_set_all_led();
 430         cam_enc_4xx_timer_init();
 431         gpio = davinci_gpio_bank01;
 432         clrbits_le32(&gpio->dir, ~0xfdfffffe);
 433         /* clear LED D14 = GPIO25 */
 434         clrbits_le32(&gpio->out_data, 0x02000000);
 435         gpio = davinci_gpio_bank23;
 436         clrbits_le32(&gpio->dir, ~0x5ff0afef);
 437         /* set GPIO61 to 1 -> intern UART0 as Console */
 438         setbits_le32(&gpio->out_data, 0x20000000);
 439         /*
 440          * PHY out of reset GIO 50 = 1
 441          * NAND WP off GIO 51 = 1
 442          */
 443         setbits_le32(&gpio->out_data, 0x000c0004);
 444         gpio = davinci_gpio_bank45;
 445         clrbits_le32(&gpio->dir, ~(0xdb2fffff) | CONFIG_CAM_ENC_LED_MASK);
 446         /*
 447          * clear LED:
 448          * D17 = GPIO86
 449          * D11 = GPIO87
 450          * GPIO88
 451          * GPIO89
 452          * D13 = GPIO90
 453          * GPIO91
 454          */
 455         clrbits_le32(&gpio->out_data, CONFIG_CAM_ENC_LED_MASK);
 456         gpio = davinci_gpio_bank67;
 457         clrbits_le32(&gpio->dir, ~0x000007ff);
 458 }
 459
 460 /*
 461  * functions for the post memory test.
 462  */
 463 int arch_memory_test_prepare(u32 *vstart, u32 *size, phys_addr_t *phys_offset)
 464 {
 465         *vstart = CONFIG_SYS_SDRAM_BASE;
 466         *size = PHYS_SDRAM_1_SIZE;
 467         *phys_offset = 0;
 468         return 0;
 469 }
 470
 471 void arch_memory_failure_handle(void)
 472 {
 473         cam_enc_4xx_set_all_led();
 474         puts("mem failure\n");
 475         while (1)
 476                 ;
 477 }
 478 #endif
 479 #if defined(CONFIG_MENU)
 480 #include "menu.h"
 481
 482 #define MENU_EXIT               -1
 483 #define MENU_EXIT_BOOTCMD       -2
 484 #define MENU_STAY               0
 485 #define MENU_MAIN               1
 486 #define MENU_UPDATE             2
 487 #define MENU_NETWORK            3
 488 #define MENU_LOAD               4
 489
 490 static int menu_start;
 491
 492 #define FIT_SUBTYPE_UNKNOWN             0
 493 #define FIT_SUBTYPE_UBL_HEADER          1
 494 #define FIT_SUBTYPE_SPL_IMAGE           2
 495 #define FIT_SUBTYPE_UBOOT_IMAGE         3
 496 #define FIT_SUBTYPE_DF_ENV_IMAGE        4
 497 #define FIT_SUBTYPE_RAMDISK_IMAGE       5
 498
 499 struct fit_images_info {
 500         u_int8_t type;
 501         int subtype;
 502         char desc[200];
 503         const void *data;
 504         size_t size;
 505 };
 506
 507 static struct fit_images_info imgs[10];
 508
 509 struct menu_display {
 510         char    title[50];
 511         int     timeout; /* in sec */
 512         int     id; /* MENU_* */
 513         char    **menulist;
 514         int (*menu_evaluate)(char *choice);
 515 };
 516
 517 char *menu_main[] = {
 518         "(1) Boot",
 519         "(2) Update Software",
 520         "(3) Reset to default setting and boot",
 521         "(4) Enter U-Boot console",
 522         NULL
 523 };
 524
 525 char *menu_update[] = {
 526         "(1) Network settings",
 527         "(2) load image",
 528         "(3) back to main",
 529         NULL
 530 };
 531
 532 char *menu_load[] = {
 533         "(1) install image",
 534         "(2) cancel",
 535         NULL
 536 };
 537
 538 char *menu_network[] = {
 539         "(1) ipaddr   ",
 540         "(2) netmask  ",
 541         "(3) serverip ",
 542         "(4) gatewayip",
 543         "(5) tftp image name",
 544         "(6) back to update software",
 545         NULL
 546 };
 547
 548 static void ait_menu_print(void *data)
 549 {
 550         printf("%s\n", (char *)data);
 551         return;
 552 }
 553
 554 static char *menu_handle(struct menu_display *display)
 555 {
 556         struct menu *m;
 557         int i;
 558         void *choice = NULL;
 559         char key[2];
 560         int ret;
 561         char *s;
 562         char temp[6][200];
 563
 564         m = menu_create(display->title, display->timeout, 1, ait_menu_print,
 565                         NULL, NULL);
 566
 567         for (i = 0; display->menulist[i]; i++) {
 568                 sprintf(key, "%d", i + 1);
 569                 if (display->id == MENU_NETWORK) {
 570                         switch (i) {
 571                         case 0:
 572                                 s = getenv("ipaddr");
 573                                 break;
 574                         case 1:
 575                                 s = getenv("netmask");
 576                                 break;
 577                         case 2:
 578                                 s = getenv("serverip");
 579                                 break;
 580                         case 3:
 581                                 s = getenv("gatewayip");
 582                                 break;
 583                         case 4:
 584                                 s = getenv("img_file");
 585                                 break;
 586                         default:
 587                                 s = NULL;
 588                                 break;
 589                         }
 590                         if (s) {
 591                                 sprintf(temp[i], "%s: %s",
 592                                         display->menulist[i], s);
 593                                 ret = menu_item_add(m, key, temp[i]);
 594                         } else {
 595                                 ret = menu_item_add(m, key,
 596                                         display->menulist[i]);
 597                         }
 598                 } else {
 599                         ret = menu_item_add(m, key, display->menulist[i]);
 600                 }
 601
 602                 if (ret != 1) {
 603                         printf("failed to add item!");
 604                         menu_destroy(m);
 605                         return NULL;
 606                 }
 607         }
 608         sprintf(key, "%d", 1);
 609         menu_default_set(m, key);
 610
 611         if (menu_get_choice(m, &choice) != 1)
 612                 debug("Problem picking a choice!\n");
 613
 614         menu_destroy(m);
 615
 616         return choice;
 617 }
 618
 619 static int ait_menu_show(struct menu_display *display, int bootdelay)
 620 {
 621         int end = MENU_STAY;
 622         char *choice;
 623
 624         if ((menu_start == 0) && (display->id == MENU_MAIN))
 625                 display->timeout = bootdelay;
 626         else
 627                 display->timeout = 0;
 628
 629         while (end == MENU_STAY) {
 630                 choice = menu_handle(display);
 631                 if (choice)
 632                         end = display->menu_evaluate(choice);
 633
 634                 if (end == display->id)
 635                         end = MENU_STAY;
 636                 if (display->id == MENU_MAIN) {
 637                         if (menu_start == 0)
 638                                 end = MENU_EXIT_BOOTCMD;
 639                         else
 640                                 display->timeout = 0;
 641                 }
 642         }
 643         return end;
 644 }
 645
 646 static int ait_writeublheader(void)
 647 {
 648         char s[20];
 649         unsigned long i;
 650         int ret;
 651
 652         for (i = CONFIG_SYS_NAND_BLOCK_SIZE;
 653                 i < CONFIG_SYS_NAND_U_BOOT_OFFS;
 654                 i += CONFIG_SYS_NAND_BLOCK_SIZE) {
 655                 sprintf(s, "%lx", i);
 656                 ret = setenv("header_addr", s);
 657                 if (ret == 0)
 658                         ret = run_command("run img_writeheader", 0);
 659                 if (ret != 0)
 660                         break;
 661         }
 662         return ret;
 663 }
 664
 665 static int ait_menu_install_images(void)
 666 {
 667         int ret = 0;
 668         int count = 0;
 669         char s[100];
 670         char *t;
 671
 672         /*
 673          * possible image types:
 674          * FIT_SUBTYPE_UNKNOWN
 675          * FIT_SUBTYPE_UBL_HEADER
 676          * FIT_SUBTYPE_SPL_IMAGE
 677          * FIT_SUBTYPE_UBOOT_IMAGE
 678          * FIT_SUBTYPE_DF_ENV_IMAGE
 679          * FIT_SUBTYPE_RAMDISK_IMAGE
 680          *
 681          * use Envvariables:
 682          * img_addr_r: image start addr
 683          * header_addr: addr where to write to UBL header
 684          * img_writeheader: write ubl header to nand
 685          * img_writespl: write spl to nand
 686          * img_writeuboot: write uboot to nand
 687          * img_writedfenv: write default environment to ubi volume
 688          * img_volume: which ubi volume should be updated with img_writeramdisk
 689          * filesize: size of data for updating ubi volume
 690          * img_writeramdisk: write ramdisk to ubi volume
 691          */
 692
 693         while (imgs[count].type != IH_TYPE_INVALID) {
 694                 printf("Installing %s\n",
 695                         genimg_get_type_name(imgs[count].type));
 696                 sprintf(s, "%p", imgs[count].data);
 697                 setenv("img_addr_r", s);
 698                 sprintf(s, "%lx", (unsigned long)imgs[count].size);
 699                 setenv("filesize", s);
 700                 switch (imgs[count].subtype) {
 701                 case FIT_SUBTYPE_DF_ENV_IMAGE:
 702                         ret = run_command("run img_writedfenv", 0);
 703                         break;
 704                 case FIT_SUBTYPE_RAMDISK_IMAGE:
 705                         t = getenv("img_volume");
 706                         if (!t) {
 707                                 ret = setenv("img_volume", "rootfs1");
 708                         } else {
 709                                 /* switch to other volume */
 710                                 if (strncmp(t, "rootfs1", 7) == 0)
 711                                         ret = setenv("img_volume", "rootfs2");
 712                                 else
 713                                         ret = setenv("img_volume", "rootfs1");
 714                         }
 715                         if (ret != 0)
 716                                 break;
 717
 718                         ret = run_command("run img_writeramdisk", 0);
 719                         break;
 720                 case FIT_SUBTYPE_SPL_IMAGE:
 721                         ret = run_command("run img_writespl", 0);
 722                         break;
 723                 case FIT_SUBTYPE_UBL_HEADER:
 724                         ret = ait_writeublheader();
 725                         break;
 726                 case FIT_SUBTYPE_UBOOT_IMAGE:
 727                         ret = run_command("run img_writeuboot", 0);
 728                         break;
 729                 default:
 730                         /* not supported type */
 731                         break;
 732                 }
 733                 count++;
 734         }
 735         /* now save dvn_* and img_volume env vars to new values */
 736         if (ret == 0) {
 737                 t = getenv("x_dvn_boot_vers");
 738                 if (t)
 739                         setenv("dvn_boot_vers", t);
 740
 741                 t = getenv("x_dvn_app_vers");
 742                 if (t)
 743                         setenv("dvn_boot_vers", t);
 744
 745                 setenv("x_dvn_boot_vers", NULL);
 746                 setenv("x_dvn_app_vers", NULL);
 747                 ret = run_command("run savenewvers", 0);
 748         }
 749
 750         return ret;
 751 }
 752
 753 static int ait_menu_evaluate_load(char *choice)
 754 {
 755         if (!choice)
 756                 return -1;
 757
 758         switch (choice[1]) {
 759         case '1':
 760                 /* install image */
 761                 ait_menu_install_images();
 762                 break;
 763         case '2':
 764                 /* cancel, back to main */
 765                 setenv("x_dvn_boot_vers", NULL);
 766                 setenv("x_dvn_app_vers", NULL);
 767                 break;
 768         }
 769
 770         return MENU_MAIN;
 771 }
 772
 773 struct menu_display ait_load = {
 774         .title = "AIT load image",
 775         .timeout = 0,
 776         .id = MENU_LOAD,
 777         .menulist = menu_load,
 778         .menu_evaluate = ait_menu_evaluate_load,
 779 };
 780
 781 static void ait_menu_read_env(char *name)
 782 {
 783         char output[CONFIG_SYS_CBSIZE];
 784         char cbuf[CONFIG_SYS_CBSIZE];
 785         int readret;
 786         int ret;
 787
 788         sprintf(output, "%s old: %s value: ", name, getenv(name));
 789         memset(cbuf, 0, CONFIG_SYS_CBSIZE);
 790         readret = readline_into_buffer(output, cbuf, 0);
 791
 792         if (readret >= 0) {
 793                 ret = setenv(name, cbuf);
 794                 if (ret) {
 795                         printf("Error setting %s\n", name);
 796                         return;
 797                 }
 798         }
 799         return;
 800 }
 801
 802 static int ait_menu_evaluate_network(char *choice)
 803 {
 804         if (!choice)
 805                 return MENU_MAIN;
 806
 807         switch (choice[1]) {
 808         case '1':
 809                 ait_menu_read_env("ipaddr");
 810                 break;
 811         case '2':
 812                 ait_menu_read_env("netmask");
 813                 break;
 814         case '3':
 815                 ait_menu_read_env("serverip");
 816                 break;
 817         case '4':
 818                 ait_menu_read_env("gatewayip");
 819                 break;
 820         case '5':
 821                 ait_menu_read_env("img_file");
 822                 break;
 823         case '6':
 824                 return MENU_UPDATE;
 825                 break;
 826         }
 827
 828         return MENU_STAY;
 829 }
 830
 831 struct menu_display ait_network = {
 832         .title = "AIT network settings",
 833         .timeout = 0,
 834         .id = MENU_NETWORK,
 835         .menulist = menu_network,
 836         .menu_evaluate = ait_menu_evaluate_network,
 837 };
 838
 839 static int fit_get_subtype(const void *fit, int noffset, char **subtype)
 840 {
 841         int len;
 842
 843         *subtype = (char *)fdt_getprop(fit, noffset, "subtype", &len);
 844         if (*subtype == NULL)
 845                 return -1;
 846
 847         return 0;
 848 }
 849
 850 static int ait_subtype_nr(char *subtype)
 851 {
 852         int ret = FIT_SUBTYPE_UNKNOWN;
 853
 854         if (!strncmp("ublheader", subtype, strlen("ublheader")))
 855                 return FIT_SUBTYPE_UBL_HEADER;
 856         if (!strncmp("splimage", subtype, strlen("splimage")))
 857                 return FIT_SUBTYPE_SPL_IMAGE;
 858         if (!strncmp("ubootimage", subtype, strlen("ubootimage")))
 859                 return FIT_SUBTYPE_UBOOT_IMAGE;
 860         if (!strncmp("dfenvimage", subtype, strlen("dfenvimage")))
 861                 return FIT_SUBTYPE_DF_ENV_IMAGE;
 862
 863         return ret;
 864 }
 865
 866 static int ait_menu_check_image(void)
 867 {
 868         char *s;
 869         unsigned long fit_addr;
 870         void *addr;
 871         int format;
 872         char *desc;
 873         char *subtype;
 874         int images_noffset;
 875         int noffset;
 876         int ndepth;
 877         int count = 0;
 878         int ret;
 879         int i;
 880         int found_uboot = -1;
 881         int found_ramdisk = -1;
 882
 883         memset(imgs, 0, sizeof(imgs));
 884         s = getenv("fit_addr_r");
 885         fit_addr = s ? (unsigned long)simple_strtol(s, NULL, 16) : \
 886                         CONFIG_BOARD_IMG_ADDR_R;
 887
 888         addr = (void *)fit_addr;
 889         /* check if it is a FIT image */
 890         format = genimg_get_format(addr);
 891         if (format != IMAGE_FORMAT_FIT)
 892                 return -EINVAL;
 893
 894         if (!fit_check_format(addr))
 895                 return -EINVAL;
 896
 897         /* print the FIT description */
 898         ret = fit_get_desc(addr, 0, &desc);
 899         printf("FIT description: ");
 900         if (ret)
 901                 printf("unavailable\n");
 902         else
 903                 printf("%s\n", desc);
 904
 905         /* find images */
 906         images_noffset = fdt_path_offset(addr, FIT_IMAGES_PATH);
 907         if (images_noffset < 0) {
 908                 printf("Can't find images parent node '%s' (%s)\n",
 909                         FIT_IMAGES_PATH, fdt_strerror(images_noffset));
 910                 return -EINVAL;
 911         }
 912
 913         /* Process its subnodes, print out component images details */
 914         for (ndepth = 0, count = 0,
 915                 noffset = fdt_next_node(addr, images_noffset, &ndepth);
 916                 (noffset >= 0) && (ndepth > 0);
 917                 noffset = fdt_next_node(addr, noffset, &ndepth)) {
 918                 if (ndepth == 1) {
 919                         /*
 920                          * Direct child node of the images parent node,
 921                          * i.e. component image node.
 922                          */
 923                         printf("Image %u (%s)\n", count,
 924                                         fit_get_name(addr, noffset, NULL));
 925
 926                         fit_image_print(addr, noffset, "");
 927
 928                         fit_image_get_type(addr, noffset,
 929                                 &imgs[count].type);
 930                         /* Mandatory properties */
 931                         ret = fit_get_desc(addr, noffset, &desc);
 932                         printf("Description:  ");
 933                         if (ret)
 934                                 printf("unavailable\n");
 935                         else
 936                                 printf("%s\n", desc);
 937
 938                         ret = fit_get_subtype(addr, noffset, &subtype);
 939                         printf("Subtype:  ");
 940                         if (ret) {
 941                                 printf("unavailable\n");
 942                         } else {
 943                                 imgs[count].subtype = ait_subtype_nr(subtype);
 944                                 printf("%s %d\n", subtype,
 945                                         imgs[count].subtype);
 946                         }
 947
 948                         sprintf(imgs[count].desc, "%s", desc);
 949
 950                         ret = fit_image_get_data(addr, noffset,
 951                                 &imgs[count].data,
 952                                 &imgs[count].size);
 953
 954                         printf("Data Size:    ");
 955                         if (ret)
 956                                 printf("unavailable\n");
 957                         else
 958                                 genimg_print_size(imgs[count].size);
 959                         printf("Data @ %p\n", imgs[count].data);
 960                         count++;
 961                 }
 962         }
 963
 964         for (i = 0; i < count; i++) {
 965                 if (imgs[i].subtype == FIT_SUBTYPE_UBOOT_IMAGE)
 966                         found_uboot = i;
 967                 if (imgs[i].type == IH_TYPE_RAMDISK) {
 968                         found_ramdisk = i;
 969                         imgs[i].subtype = FIT_SUBTYPE_RAMDISK_IMAGE;
 970                 }
 971         }
 972
 973         /* dvn_* env var update, if the FIT descriptors are different */
 974         if (found_uboot >= 0) {
 975                 s = getenv("dvn_boot_vers");
 976                 if (s) {
 977                         ret = strcmp(s, imgs[found_uboot].desc);
 978                         if (ret != 0) {
 979                                 setenv("x_dvn_boot_vers",
 980                                         imgs[found_uboot].desc);
 981                         } else {
 982                                 found_uboot = -1;
 983                                 printf("no new uboot version\n");
 984                         }
 985                 } else {
 986                         setenv("dvn_boot_vers", imgs[found_uboot].desc);
 987                 }
 988         }
 989         if (found_ramdisk >= 0) {
 990                 s = getenv("dvn_app_vers");
 991                 if (s) {
 992                         ret = strcmp(s, imgs[found_ramdisk].desc);
 993                         if (ret != 0) {
 994                                 setenv("x_dvn_app_vers",
 995                                         imgs[found_ramdisk].desc);
 996                         } else {
 997                                 found_ramdisk = -1;
 998                                 printf("no new ramdisk version\n");
 999                         }
1000                 } else {
1001                         setenv("dvn_app_vers", imgs[found_ramdisk].desc);
1002                 }
1003         }
1004         if ((found_uboot == -1) && (found_ramdisk == -1))
1005                 return -EINVAL;
1006
1007         return 0;
1008 }
1009
1010 static int ait_menu_evaluate_update(char *choice)
1011 {
1012         int ret;
1013
1014         if (!choice)
1015                 return MENU_MAIN;
1016
1017         switch (choice[1]) {
1018         case '1':
1019                 return ait_menu_show(&ait_network, 0);
1020                 break;
1021         case '2':
1022                 /* load image */
1023                 ret = run_command("run load_img", 0);
1024                 printf("ret: %d\n", ret);
1025                 if (ret)
1026                         return MENU_UPDATE;
1027
1028                 ret = ait_menu_check_image();
1029                 if (ret)
1030                         return MENU_UPDATE;
1031
1032                 return ait_menu_show(&ait_load, 0);
1033                 break;
1034         case '3':
1035                 return MENU_MAIN;
1036                 break;
1037
1038         }
1039
1040         return MENU_MAIN;
1041 }
1042
1043 struct menu_display ait_update = {
1044         .title = "AIT Update Software",
1045         .timeout = 0,
1046         .id = MENU_UPDATE,
1047         .menulist = menu_update,
1048         .menu_evaluate = ait_menu_evaluate_update,
1049 };
1050
1051 static int ait_menu_evaluate_main(char *choice)
1052 {
1053         if (!choice)
1054                 return MENU_STAY;
1055
1056         menu_start = 1;
1057         switch (choice[1]) {
1058         case '1':
1059                 /* run bootcmd */
1060                 return MENU_EXIT_BOOTCMD;
1061                 break;
1062         case '2':
1063                 return ait_menu_show(&ait_update, 0);
1064                 break;
1065         case '3':
1066                 /* reset to default settings */
1067                 setenv("app_reset", "yes");
1068                 return MENU_EXIT_BOOTCMD;
1069                 break;
1070         case '4':
1071                 /* u-boot shell */
1072                 return MENU_EXIT;
1073                 break;
1074         }
1075
1076         return MENU_EXIT;
1077 }
1078
1079 struct menu_display ait_main = {
1080         .title = "AIT Main",
1081         .timeout = CONFIG_BOOTDELAY,
1082         .id = MENU_MAIN,
1083         .menulist = menu_main,
1084         .menu_evaluate = ait_menu_evaluate_main,
1085 };
1086
1087 int menu_show(int bootdelay)
1088 {
1089         int ret;
1090
1091         run_command("run saveparms", 0);
1092         ret = ait_menu_show(&ait_main, bootdelay);
1093         run_command("run restoreparms", 0);
1094
1095         if (ret == MENU_EXIT_BOOTCMD)
1096                 return 0;
1097
1098         return MENU_EXIT;
1099 }
1100
1101 void menu_display_statusline(struct menu *m)
1102 {
1103         char *s1, *s2;
1104
1105         s1 = getenv("x_dvn_boot_vers");
1106         if (!s1)
1107                 s1 = getenv("dvn_boot_vers");
1108
1109         s2 = getenv("x_dvn_app_vers");
1110         if (!s2)
1111                 s2 = getenv("dvn_app_vers");
1112
1113         printf("State: dvn_boot_vers: %s dvn_app_vers: %s\n", s1, s2);
1114         return;
1115 }
1116 #endif