common/cmd_usbd.c

   1 /*
   2  * USB Downloader for SAMSUNG Platform
   3  *
   4  * Copyright (C) 2007-2008 Samsung Electronics
   5  * Minkyu Kang <mk7.kang@samsung.com>
   6  *
   7  */
   8
   9 #include <common.h>
  10 #include <usbd.h>
  11 #include <asm/errno.h>
  12 #include <malloc.h>
  13
  14 /* version of USB Downloader Application */
  15 #define APP_VERSION     "1.5.3"
  16
  17 #define OPS_READ        0
  18 #define OPS_WRITE       1
  19
  20 #ifdef CONFIG_CMD_MTDPARTS
  21 #include <jffs2/load_kernel.h>
  22 static struct part_info *parts[16];
  23 #endif
  24
  25 #ifdef CONFIG_UBIFS_MK
  26 #include <mkfs.ubifs.h>
  27 #endif
  28
  29 #ifdef CONFIG_UBINIZE
  30 #include <ubinize.h>
  31 #endif
  32
  33 static const char pszMe[] = "usbd: ";
  34
  35 static struct usbd_ops usbd_ops;
  36
  37 static unsigned int part_id;
  38 static unsigned int write_part = 0;
  39 static unsigned long fs_offset = 0x0;
  40
  41 #ifdef CONFIG_USE_YAFFS
  42 static unsigned int yaffs_len = 0;
  43 static unsigned char yaffs_data[2112];
  44 #define YAFFS_PAGE 2112
  45 #endif
  46
  47 #define NAND_PAGE_SIZE 2048
  48
  49 static unsigned long down_ram_addr;
  50
  51 static int down_mode;
  52
  53 /* cpu/${CPU} dependent */
  54 extern void do_reset(void);
  55
  56 /* common commands */
  57 extern int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
  58 extern int do_run(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[]);
  59
  60 int mtdparts_init(void);
  61 int find_dev_and_part(const char*, struct mtd_device**, u8*, struct part_info**);
  62
  63 /* common/cmd_jffs2.c */
  64 extern struct list_head devices;
  65
  66 static u8 count_mtdparts(void)
  67 {
  68         struct list_head *dentry, *pentry;
  69         struct mtd_device *dev;
  70         u8 part_num = 0;
  71
  72         list_for_each(dentry, &devices) {
  73                 dev = list_entry(dentry, struct mtd_device, link);
  74
  75                 /* list partitions for given device */
  76                 list_for_each(pentry, &dev->parts)
  77                         part_num++;
  78         }
  79
  80         return part_num;
  81 }
  82
  83 #ifdef CONFIG_CMD_UBI
  84 static int check_ubi_mode(void)
  85 {
  86         char *env_ubifs;
  87         int ubi_mode;
  88
  89         env_ubifs = getenv("ubi");
  90         ubi_mode = !strcmp(env_ubifs, "enabled");
  91
  92         return ubi_mode;
  93 }
  94 #else
  95 #define check_ubi_mode()                0
  96 #endif
  97
  98 #ifdef CONFIG_MTD_PARTITIONS
  99 static int get_part_info(void)
 100 {
 101         struct mtd_device *dev;
 102         u8 out_partnum;
 103         char part_name[12];
 104         char nand_name[12];
 105         int i;
 106         int part_num;
 107         int ubi_mode = 0;
 108
 109 #if defined(CONFIG_CMD_NAND)
 110         sprintf(nand_name, "nand0");
 111 #elif defined(CONFIG_CMD_ONENAND)
 112         sprintf(nand_name, "onenand0");
 113 #else
 114         printf("Configure your NAND sub-system\n");
 115         return 0;
 116 #endif
 117
 118         if (mtdparts_init())
 119                 return 0;
 120
 121         ubi_mode = check_ubi_mode();
 122
 123         part_num = count_mtdparts();
 124         for (i = 0; i < part_num; i++) {
 125                 sprintf(part_name, "%s,%d", nand_name, i);
 126
 127                 if (find_dev_and_part(part_name, &dev, &out_partnum, &parts[i]))
 128                         return -EINVAL;
 129         }
 130
 131         return 0;
 132 }
 133
 134 static int get_part_id(char *name)
 135 {
 136         int nparts = count_mtdparts();
 137         int i;
 138
 139         for (i = 0; i < nparts; i++) {
 140                 if (strcmp(parts[i]->name, name) == 0)
 141                         return i;
 142         }
 143
 144         printf("Error: Unknown partition -> %s\n", name);
 145         return -1;
 146 }
 147 #else
 148 static int get_part_info(void)
 149 {
 150         printf("Error: Can't get patition information\n");
 151         return -EINVAL;
 152 }
 153
 154 static int get_part_id(char *name)
 155 {
 156         return 0;
 157 }
 158 #endif
 159
 160 static void boot_cmd(char *addr)
 161 {
 162         char *argv[] = { "bootm", addr };
 163         do_bootm(NULL, 0, 2, argv);
 164 }
 165
 166 static void run_cmd(char *cmd)
 167 {
 168         char *argv[] = { "run", cmd };
 169         do_run(NULL, 0, 2, argv);
 170 }
 171
 172 #if defined(CONFIG_CMD_NAND)
 173 extern int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
 174 #elif defined(CONFIG_CMD_ONENAND)
 175 extern int do_onenand(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
 176 #endif
 177
 178 /* NAND erase and write using nand command */
 179 static int nand_cmd(int type, char *p1, char *p2, char *p3)
 180 {
 181         int ret = 1;
 182         char nand_name[12];
 183         int (*nand_func) (cmd_tbl_t *, int, int, char **);
 184
 185 #if defined(CONFIG_CMD_NAND)
 186         sprintf(nand_name, "nand");
 187         nand_func = do_nand;
 188 #elif defined(CONFIG_CMD_ONENAND)
 189         sprintf(nand_name, "onenand");
 190         nand_func = do_onenand;
 191 #else
 192         printf("Configure your NAND sub-system\n");
 193         return 0;
 194 #endif
 195
 196         if (type == 0) {
 197                 char *argv[] = {nand_name, "erase", p1, p2};
 198                 printf("%s %s %s %s\n", argv[0], argv[1], argv[2], argv[3]);
 199                 ret = nand_func(NULL, 0, 4, argv);
 200         } else if (type == 1) {
 201                 char *argv[] = {nand_name, "write", p1, p2, p3};
 202                 printf("%s %s %s %s %s\n", argv[0], argv[1], argv[2],
 203                                 argv[3], argv[4]);
 204                 ret = nand_func(NULL, 0, 5, argv);
 205         } else if (type == 2) {
 206                 char *argv[] = {nand_name, "write.yaffs", p1, p2, p3};
 207                 printf("%s %s %s %s %s\n", argv[0], argv[1], argv[2],
 208                                 argv[3], argv[4]);
 209                 ret = nand_func(NULL, 0, 5, argv);
 210         } else if (type == 3) {
 211                 char *argv[] = {nand_name, "lock", p1, p2};
 212                 printf("%s %s %s %s\n", argv[0], argv[1], argv[2], argv[3]);
 213                 ret = nand_func(NULL, 0, 4, argv);
 214         }
 215
 216         if (ret)
 217                 printf("Error: NAND Command\n");
 218
 219         return ret;
 220 }
 221
 222 #ifdef CONFIG_CMD_UBI
 223 int do_ubi(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
 224
 225 int ubi_cmd(int part, char *p1, char *p2, char *p3)
 226 {
 227         int ret = 1;
 228
 229         if (part == RAMDISK_PART_ID) {
 230                 char *argv[] = {"ubi", "write", p1, "rootfs.cramfs", p2, p3};
 231                 printf("%s %s %s %s %s %s\n", argv[0], argv[1], argv[2],
 232                                 argv[3], argv[4], argv[5]);
 233                 ret = do_ubi(NULL, 0, 6, argv);
 234         } else if (part == FILESYSTEM_PART_ID) {
 235                 char *argv[] = {"ubi", "write", p1, "factoryfs.cramfs", p2, p3};
 236                 printf("%s %s %s %s %s %s\n", argv[0], argv[1], argv[2],
 237                                 argv[3], argv[4], argv[5]);
 238                 ret = do_ubi(NULL, 0, 6, argv);
 239         } else if (part == FILESYSTEM2_PART_ID) {
 240                 char *argv[] = {"ubi", "write", p1, "datafs.ubifs", p2, p3};
 241                 printf("%s %s %s %s %s %s\n", argv[0], argv[1], argv[2],
 242                                 argv[3], argv[4], argv[5]);
 243                 ret = do_ubi(NULL, 0, 6, argv);
 244         }
 245
 246         return ret;
 247 }
 248 #endif
 249
 250 #ifdef CONFIG_CMD_MMC
 251 #include <fat.h>
 252
 253 extern int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
 254
 255 static int mmc_cmd(int ops, char *p1, char *p2, char *p3)
 256 {
 257         int ret;
 258
 259         if (ops) {
 260                 char *argv[] = {"mmc", "write", "0", p1, p2, p3};
 261                 ret = do_mmcops(NULL, 0, 6, argv);
 262         } else {
 263                 char *argv[] = {"mmc", "read", "0", p1, p2, p3};
 264                 ret = do_mmcops(NULL, 0, 6, argv);
 265         }
 266
 267         return ret;
 268 }
 269
 270 #define NORMAL_PARTITION        0
 271 #define EXTEND_PARTITION        1
 272
 273 #define EXTEND_PART_TYPE        5
 274
 275 #define EXTEND_MAX_PART         32
 276
 277 static unsigned int cur_blk_offset;
 278 static unsigned int cur_part_size;
 279 static unsigned int cur_part;
 280
 281 static unsigned int mmc_parts;
 282 static unsigned int mmc_part_write;
 283
 284 static u8 part_mode = 0;
 285
 286 struct partition_info {
 287         u32 size;
 288         u32 checksum;
 289         u32 res;
 290 } __attribute__((packed));
 291
 292 struct partition_header {
 293         u8                      fat32head[16];  /* RFSHEAD identifier */
 294         struct partition_info   partition[EXTEND_MAX_PART];
 295         u8                      res[112];       /* only data (without MBR) */
 296 } __attribute__((packed));
 297
 298 struct partition_table {
 299         u8      boot_flag;
 300         u8      chs_begin[3];
 301         u8      type_code;
 302         u8      chs_end[3];
 303         u32     lba_begin;
 304         u32     num_sectors;
 305 } __attribute__((packed));
 306
 307 struct mbr_table {
 308         u8                      boot_code[446];
 309         struct partition_table  partition[4];
 310         u16                     signature;
 311 } __attribute__((packed));
 312
 313 struct mul_partition_info {
 314         u32 lba_begin;          /* absolute address from 0 block */
 315         u32 num_sectors;
 316 } __attribute__((packed));
 317
 318 #define MBR_OFFSET      0x10
 319
 320 struct partition_header part_info;
 321 struct mbr_table mbr_info;
 322 struct mul_partition_info mul_info[EXTEND_MAX_PART];
 323
 324 static int write_mmc_partition(struct usbd_ops *usbd, u32 *ram_addr, u32 len)
 325 {
 326         unsigned int blocks;
 327         char offset[12], length[12], ramaddr[12];
 328         int i;
 329         int loop;
 330         u32 cnt;
 331         int ret;
 332
 333         if (cur_part_size > len) {
 334                 blocks = len / usbd->mmc_blk;
 335                 ret = -1;
 336         } else {
 337                 blocks = cur_part_size / usbd->mmc_blk;
 338                 ret = len - cur_part_size;
 339         }
 340
 341         if (len % usbd->mmc_blk)
 342                 blocks++;
 343
 344         loop = blocks / usbd->mmc_max;
 345         if (blocks % usbd->mmc_max)
 346                 loop++;
 347
 348         for (i = 0; i < loop; i++) {
 349                 if (i == 0) {
 350                         cnt = blocks % usbd->mmc_max;
 351                         if (cnt == 0)
 352                                 cnt = usbd->mmc_max;
 353                 } else {
 354                         cnt = usbd->mmc_max;
 355                 }
 356
 357                 sprintf(length, "%x", cnt);
 358                 sprintf(offset, "%x", cur_blk_offset);
 359                 sprintf(ramaddr, "0x%x", *ram_addr);
 360                 mmc_cmd(OPS_WRITE, ramaddr, offset, length);
 361
 362                 cur_blk_offset += cnt;
 363
 364                 *ram_addr += (cnt * usbd->mmc_blk);
 365         }
 366
 367         return ret;
 368 }
 369
 370 static int write_file_mmc(struct usbd_ops *usbd, char *ramaddr, u32 len,
 371                 char *offset, char *length)
 372 {
 373         u32 ram_addr;
 374         int i;
 375         int ret;
 376         struct mbr_table *mbr;
 377
 378         if (!usbd->mmc_total) {
 379                 printf("MMC is not supported!\n");
 380                 return 0;
 381         }
 382
 383         ram_addr = (u32)down_ram_addr;
 384
 385         if (cur_blk_offset == 0) {
 386                 boot_sector *bs;
 387                 u32 mbr_blk_size;
 388
 389                 memcpy(&part_info, (void *)ram_addr,
 390                                 sizeof(struct partition_header));
 391
 392                 ram_addr += sizeof(struct partition_header);
 393                 len -= sizeof(struct partition_header);
 394                 mbr = (struct mbr_table*)ram_addr;
 395                 mbr_blk_size = mbr->partition[0].lba_begin;
 396
 397                 if (mbr->partition[0].type_code != EXTEND_PART_TYPE) {
 398                         part_mode = NORMAL_PARTITION;
 399
 400                         /* modify sectors of p1 */
 401                         mbr->partition[0].num_sectors = usbd->mmc_total -
 402                                         (mbr_blk_size +
 403                                         mbr->partition[1].num_sectors +
 404                                         mbr->partition[2].num_sectors +
 405                                         mbr->partition[3].num_sectors);
 406
 407                         mmc_parts++;
 408
 409                         /* modify lba_begin of p2 and p3 and p4 */
 410                         for (i = 1; i < 4; i++) {
 411                                 if (part_info.partition[i].size == 0)
 412                                         break;
 413
 414                                 mmc_parts++;
 415                                 mbr->partition[i].lba_begin =
 416                                         mbr->partition[i - 1].lba_begin +
 417                                         mbr->partition[i - 1].num_sectors;
 418                         }
 419
 420                         /* copy MBR */
 421                         memcpy(&mbr_info, mbr, sizeof(struct mbr_table));
 422
 423                         printf("Total Size: 0x%08x #parts %d\n",
 424                                         (unsigned int)usbd->mmc_total,
 425                                         mmc_parts);
 426                         for (i = 0; i < mmc_parts; i++) {
 427                                 printf("p%d\t0x%08x\t0x%08x\n", i + 1,
 428                                         mbr_info.partition[i].lba_begin,
 429                                         mbr_info.partition[i].num_sectors);
 430                         }
 431
 432                         /* write MBR */
 433                         sprintf(length, "%x", mbr_blk_size);
 434                         sprintf(offset, "%x", 0);
 435                         sprintf(ramaddr, "0x%x", (u32)ram_addr);
 436                         ret = mmc_cmd(OPS_WRITE, ramaddr, offset, length);
 437
 438                         ram_addr += mbr_blk_size * usbd->mmc_blk;
 439                         len -= mbr_blk_size * usbd->mmc_blk;
 440
 441                         cur_blk_offset = mbr_blk_size;
 442                         cur_part = 0;
 443                         cur_part_size = part_info.partition[0].size;
 444
 445                         /* modify p1's total sector */
 446                         bs = (boot_sector *)ram_addr;
 447                         bs->total_sect = mbr_info.partition[0].num_sectors;
 448
 449                         printf("\nWrite Partition %d.. %d blocks\n",
 450                                 cur_part + 1,
 451                                 part_info.partition[cur_part].size /
 452                                 (int)usbd->mmc_blk);
 453                 } else {
 454                         part_mode = EXTEND_PARTITION;
 455
 456                         for (i = 0; i < EXTEND_MAX_PART; i++) {
 457                                 if (part_info.partition[i].size == 0)
 458                                         break;
 459                                 mmc_parts++;
 460                         }
 461
 462                         if (mmc_parts == 0)
 463                                 return -1;
 464                         else
 465                                 printf("found %d partitions\n", mmc_parts);
 466
 467                         /* build partition table */
 468
 469                         mul_info[0].num_sectors =
 470                                 usbd->mmc_total - mbr_blk_size;
 471                         for (i = 1; i < mmc_parts; i++) {
 472                                 mul_info[i].num_sectors =
 473                                         part_info.partition[i].res +
 474                                         mbr_blk_size; /* add MBR */
 475                         }
 476
 477                         for (i = 1; i < mmc_parts; i++) {
 478                                 mul_info[0].num_sectors -=
 479                                         mul_info[i].num_sectors;
 480                         }
 481
 482                         mul_info[0].lba_begin = mbr_blk_size;
 483                         for (i = 1; i < mmc_parts; i++) {
 484                                 mul_info[i].lba_begin =
 485                                         mul_info[i-1].lba_begin +
 486                                         mul_info[i-1].num_sectors;
 487                         }
 488
 489                         /* modify MBR of extended partition: p1 */
 490                         mbr->partition[0].num_sectors =
 491                                 usbd->mmc_total - mbr_blk_size;
 492
 493                         /* modify MBR of first logical partition: p5 */
 494                         mbr = (struct mbr_table *)
 495                                 (ram_addr + mbr_blk_size * usbd->mmc_blk);
 496
 497                         mbr->partition[0].num_sectors =
 498                                 mul_info[0].num_sectors - mbr_blk_size;
 499                         mbr->partition[1].lba_begin =
 500                                 mul_info[1].lba_begin - mbr_blk_size;
 501
 502                         /* modify BPB data of p5 */
 503                         bs = (boot_sector *)
 504                                 ((u32)mbr + mbr_blk_size * usbd->mmc_blk);
 505                         memset(&bs->sectors, 0, 2);
 506                         bs->total_sect = mbr->partition[0].num_sectors;
 507
 508                         printf("Total Size: 0x%08x #parts %d\n",
 509                                         (unsigned int)usbd->mmc_total,
 510                                         mmc_parts);
 511                         for (i = 0; i < mmc_parts; i++) {
 512                                 printf("p%d\t0x%08x\t0x%08x\n", i + 1,
 513                                         mul_info[i].lba_begin,
 514                                         mul_info[i].num_sectors);
 515                         }
 516
 517                         cur_blk_offset = 0;
 518                         cur_part = 0;
 519                         cur_part_size = part_info.partition[0].size;
 520
 521                         printf("\nWrite Partition %d.. %d blocks\n",
 522                                 cur_part + 1,
 523                                 part_info.partition[cur_part].size /
 524                                 (int)usbd->mmc_blk);
 525                 }
 526         }
 527
 528         for (i = cur_part; i < mmc_parts; i++) {
 529                 ret = write_mmc_partition(usbd, &ram_addr, len);
 530
 531                 if (ret < 0) {
 532                         cur_part_size -= len;
 533                         break;
 534                 } else {
 535                         cur_part++;
 536                         cur_part_size =
 537                                 part_info.partition[cur_part].size;
 538
 539                         if (part_mode == NORMAL_PARTITION) {
 540                                 cur_blk_offset =
 541                                         mbr_info.partition[cur_part].lba_begin;
 542                         } else {
 543                                 cur_blk_offset =
 544                                         mul_info[cur_part].lba_begin;
 545                                 /* modify MBR */
 546                                 if (cur_part < mmc_parts) {
 547                                         mbr = (struct mbr_table *)ram_addr;
 548                                         mbr->partition[1].lba_begin =
 549                                                 mul_info[cur_part+1].lba_begin -
 550                                                 mbr->partition[0].lba_begin;
 551                                 }
 552                         }
 553
 554                         if (ret == 0)
 555                                 break;
 556                         else
 557                                 len = ret;
 558
 559                         printf("\nWrite Partition %d.. %d blocks\n",
 560                                 cur_part + 1,
 561                                 part_info.partition[cur_part].size /
 562                                 (int)usbd->mmc_blk);
 563                 }
 564         }
 565
 566         return 0;
 567 }
 568
 569 static int write_file_mmc_part(struct usbd_ops *usbd, char *ramaddr, u32 len,
 570                 char *offset, char *length)
 571 {
 572         u32 ram_addr;
 573         u32 ofs;
 574         int i;
 575         struct mbr_table *mbr;
 576         u32 mbr_blk_size;
 577
 578         ram_addr = (u32)down_ram_addr;
 579         mbr = &mbr_info;
 580
 581         if (cur_blk_offset == 0) {
 582                 /* read MBR */
 583                 sprintf(length, "%x", (unsigned int)
 584                         (sizeof(struct mbr_table)/usbd->mmc_blk));
 585                 sprintf(offset, "%x", 0);
 586                 sprintf(ramaddr, "0x%x", (u32)mbr);
 587                 mmc_cmd(OPS_READ, ramaddr, offset, length);
 588
 589                 mbr_blk_size = mbr->partition[0].lba_begin;
 590
 591                 if (mbr->partition[0].type_code != EXTEND_PART_TYPE) {
 592                         part_mode = NORMAL_PARTITION;
 593
 594                         for (i = 0; i < 4; i++) {
 595                                 printf("p%d\t0x%08x\t0x%08x\n", i + 1,
 596                                         mbr_info.partition[i].lba_begin,
 597                                         mbr_info.partition[i].num_sectors);
 598                         }
 599
 600                         cur_blk_offset =
 601                                 mbr->partition[mmc_part_write - 1].lba_begin;
 602                         cur_part = mmc_part_write - 1;
 603                         cur_part_size =
 604                                 usbd->mmc_blk *
 605                                 mbr->partition[mmc_part_write - 1].num_sectors;
 606
 607                         if (mmc_part_write == 1) {
 608                                 ram_addr += sizeof(struct mbr_table);
 609                                 cur_blk_offset += sizeof(struct mbr_table) /
 610                                         usbd->mmc_blk;
 611                                 len -= sizeof(struct mbr_table);
 612                         }
 613                 } else {
 614                         part_mode = EXTEND_PARTITION;
 615
 616                         for (i = 1; i < mmc_part_write; i++) {
 617                                 ofs = mbr->partition[0].lba_begin +
 618                                         mbr->partition[1].lba_begin;
 619                                 printf("P%d start blk: 0x%x, size: 0x%x\n", i,
 620                                         ofs, mbr->partition[1].num_sectors);
 621                                 sprintf(length, "%x", (unsigned int)
 622                                         (sizeof(struct mbr_table) /
 623                                         usbd->mmc_blk));
 624                                 sprintf(offset, "%x", ofs);
 625                                 sprintf(ramaddr, "0x%x", (u32)mbr);
 626                                 mmc_cmd(OPS_READ, ramaddr, offset, length);
 627                         }
 628
 629                         ofs = mbr->partition[0].lba_begin +
 630                                 mbr->partition[1].lba_begin;
 631                         printf("P%d start blk: 0x%x, size: 0x%x\n", i,
 632                                 ofs, mbr->partition[1].num_sectors);
 633
 634                         ofs += mbr_blk_size; /* skip MBR */
 635                         cur_blk_offset = ofs;
 636                         cur_part = mmc_part_write - 1;
 637                         cur_part_size =
 638                                 usbd->mmc_blk *
 639                                 mbr->partition[1].num_sectors;
 640
 641                         if (mmc_part_write == 1) {
 642                                 boot_sector *bs;
 643                                 u32 total_sect;
 644                                 u8 *tmp;
 645                                 /* modify BPB data of p1 */
 646                                 sprintf(length, "%x", (unsigned int)
 647                                         (sizeof(struct mbr_table) /
 648                                         usbd->mmc_blk));
 649                                 sprintf(offset, "%x", cur_blk_offset);
 650                                 sprintf(ramaddr, "0x%x", (u32)mbr);
 651                                 mmc_cmd(OPS_READ, ramaddr, offset, length);
 652
 653                                 bs = (boot_sector *)mbr;
 654                                 total_sect = bs->total_sect;
 655
 656                                 bs = (boot_sector *)ram_addr;
 657                                 memset(&bs->sectors, 0, 2);
 658                                 bs->total_sect = total_sect;
 659                         }
 660                 }
 661         }
 662
 663         printf("\nWrite Partition %d.. %d blocks\n",
 664                 cur_part + 1,
 665                 len / (int)usbd->mmc_blk);
 666
 667         write_mmc_partition(usbd, &ram_addr, len);
 668
 669         return 0;
 670 }
 671 #endif
 672
 673 static int write_file_system(char *ramaddr, ulong len, char *offset,
 674                 char *length, int part_num, int ubi_update)
 675 {
 676 #ifdef CONFIG_USE_YAFFS
 677         int actual_len = 0;
 678         int yaffs_write = 0;
 679 #endif
 680         int ret = 0;
 681
 682 #ifdef CONFIG_CMD_UBI
 683         /* UBI Update */
 684         if (ubi_update) {
 685                 sprintf(length, "0x%x", (uint)len);
 686                 ret = ubi_cmd(part_id, ramaddr, length, "cont");
 687                 return ret;
 688         }
 689 #endif
 690
 691         /* Erase entire partition at the first writing */
 692         if (write_part == 0 && ubi_update == 0) {
 693                 sprintf(offset, "0x%x", (uint)parts[part_num]->offset);
 694                 sprintf(length, "0x%x", (uint)parts[part_num]->size);
 695                 nand_cmd(0, offset, length, NULL);
 696         }
 697
 698 #ifdef CONFIG_USE_YAFFS
 699         /* if using yaffs, wirte size must be 2112*X
 700          * so, must have to realloc, and writing */
 701         if (!strcmp("yaffs", getenv(parts[part_num]->name))) {
 702                 yaffs_write = 1;
 703
 704                 memcpy((void *)down_ram_addr, yaffs_data, yaffs_len);
 705
 706                 actual_len = len + yaffs_len;
 707                 yaffs_len = actual_len % YAFFS_PAGE;
 708                 len = actual_len - yaffs_len;
 709
 710                 memset(yaffs_data, 0x00, YAFFS_PAGE);
 711                 memcpy(yaffs_data, (char *)down_ram_addr + len, yaffs_len);
 712         }
 713 #endif
 714
 715         sprintf(offset, "0x%x", (uint)(parts[part_num]->offset + fs_offset));
 716         sprintf(length, "0x%x", (uint)len);
 717
 718 #ifdef CONFIG_USE_YAFFS
 719         if (yaffs_write)
 720                 ret = nand_cmd(2, ramaddr, offset, length);
 721         else
 722                 ret = nand_cmd(1, ramaddr, offset, length);
 723
 724         if (!strcmp("yaffs", getenv(parts[part_num]->name)))
 725                 fs_offset += len / YAFFS_PAGE * NAND_PAGE_SIZE;
 726         else
 727                 fs_offset += len;
 728
 729 #else
 730         fs_offset += len;
 731         ret = nand_cmd(1, ramaddr, offset, length);
 732 #endif
 733
 734         return ret;
 735 }
 736
 737 static int qboot_erase = 0;
 738
 739 /* Erase the qboot */
 740 static void erase_qboot_area(void)
 741 {
 742         char offset[12], length[12];
 743         int qboot_id;
 744
 745         if (qboot_erase)
 746                 return;
 747
 748         qboot_id = get_part_id("qboot");
 749
 750         if (qboot_id != -1) {
 751                 printf("\nCOMMAND_ERASE_QBOOT\n");
 752                 sprintf(offset, "%x", parts[qboot_id]->offset);
 753                 sprintf(length, "%x", parts[qboot_id]->size);
 754                 nand_cmd(0, offset, length, NULL);
 755                 qboot_erase = 1;
 756         }
 757 }
 758
 759 /* Parsing received data packet and Process data */
 760 static int process_data(struct usbd_ops *usbd)
 761 {
 762         ulong cmd = 0, arg = 0, ofs = 0, len = 0, flag = 0;
 763         char offset[12], length[12], ramaddr[12];
 764         int recvlen = 0;
 765         unsigned int blocks = 0;
 766         int ret = 0;
 767         int ubi_update = 0;
 768         int ubi_mode = 0;
 769         int img_type;
 770
 771         sprintf(ramaddr, "0x%x", (uint) down_ram_addr);
 772
 773         /* Parse command */
 774         cmd  = *((ulong *) usbd->rx_data + 0);
 775         arg  = *((ulong *) usbd->rx_data + 1);
 776         len  = *((ulong *) usbd->rx_data + 2);
 777         flag = *((ulong *) usbd->rx_data + 3);
 778
 779         /* Reset tx buffer */
 780         memset(usbd->tx_data, 0, sizeof(usbd->tx_data));
 781
 782         ubi_mode = check_ubi_mode();
 783
 784         switch (cmd) {
 785         case COMMAND_DOWNLOAD_IMAGE:
 786                 printf("\nCOMMAND_DOWNLOAD_IMAGE\n");
 787
 788 #ifdef CONFIG_USE_YAFFS
 789                 usbd->recv_setup((char *)down_ram_addr + yaffs_len, (int)len);
 790                 printf("Download to 0x%08x, %d bytes\n",
 791                                 (uint)down_ram_addr + yaffs_len, (int)len);
 792 #else
 793                 if (arg)
 794                         down_ram_addr = usbd->ram_addr + 0x1000000;
 795                 else
 796                         down_ram_addr = usbd->ram_addr;
 797
 798                 usbd->recv_setup((char *)down_ram_addr, (int)len);
 799                 printf("Download to 0x%08x, %d bytes\n",
 800                                 (uint)down_ram_addr, (int)len);
 801 #endif
 802                 /* response */
 803                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 804
 805                 /* Receive image by using dma */
 806                 recvlen = usbd->recv_data();
 807                 if (recvlen < len) {
 808                         printf("Error: wrong image size -> %d/%d\n",
 809                                         (int)recvlen, (int)len);
 810
 811                         /* Retry this commad */
 812                         *((ulong *) usbd->tx_data) = STATUS_RETRY;
 813                 } else
 814                         *((ulong *) usbd->tx_data) = STATUS_DONE;
 815
 816                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 817                 return 1;
 818
 819         /* Report partition info */
 820         case COMMAND_PARTITION_SYNC:
 821                 part_id = arg;
 822
 823 #ifdef CONFIG_CMD_UBI
 824                 if (ubi_mode) {
 825                         if (part_id == RAMDISK_PART_ID ||
 826                             part_id == FILESYSTEM_PART_ID ||
 827                             part_id == FILESYSTEM2_PART_ID) {
 828                                 /* change to yaffs style */
 829                                 get_part_info();
 830                         }
 831                 } else {
 832                         if (part_id == FILESYSTEM3_PART_ID) {
 833                                 /* change ubi style */
 834                                 get_part_info();
 835                         }
 836                 }
 837 #endif
 838
 839                 if (part_id == FILESYSTEM3_PART_ID)
 840                         part_id = get_part_id("UBI");
 841                 else if (part_id == MODEM_PART_ID)
 842                         part_id = get_part_id("modem");
 843                 else if (part_id == KERNEL_PART_ID)
 844                         part_id = get_part_id("kernel");
 845                 else if (part_id == BOOT_PART_ID)
 846                         part_id = get_part_id("bootloader");
 847 #ifdef CONFIG_MIRAGE
 848                 if (part_id)
 849                         part_id--;
 850 #endif
 851                 printf("COMMAND_PARTITION_SYNC - Part%d\n", part_id);
 852
 853                 blocks = parts[part_id]->size / 1024 / 128;
 854                 printf("COMMAND_PARTITION_SYNC - Part%d, %d blocks\n",
 855                                 part_id, blocks);
 856
 857                 *((ulong *) usbd->tx_data) = blocks;
 858                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 859                 return 1;
 860
 861         case COMMAND_WRITE_PART_0:
 862                 /* Do nothing */
 863                 printf("COMMAND_WRITE_PART_0\n");
 864                 return 1;
 865
 866         case COMMAND_WRITE_PART_1:
 867                 printf("COMMAND_WRITE_PART_BOOT\n");
 868                 part_id = get_part_id("bootloader");
 869                 img_type = IMG_BOOT;
 870                 break;
 871
 872         case COMMAND_WRITE_PART_2:
 873         case COMMAND_ERASE_PARAMETER:
 874                 printf("COMMAND_PARAMETER - not support!\n");
 875                 break;
 876
 877         case COMMAND_WRITE_PART_3:
 878                 printf("COMMAND_WRITE_KERNEL\n");
 879                 part_id = get_part_id("kernel");
 880                 img_type = IMG_KERNEL;
 881                 break;
 882
 883         case COMMAND_WRITE_PART_4:
 884                 printf("COMMAND_WRITE_ROOTFS\n");
 885                 part_id = get_part_id("Root");
 886                 img_type = IMG_FILESYSTEM;
 887                 ubi_update = arg;
 888                 break;
 889
 890         case COMMAND_WRITE_PART_5:
 891                 printf("COMMAND_WRITE_FACTORYFS\n");
 892                 part_id = get_part_id("Fact");
 893                 img_type = IMG_FILESYSTEM;
 894                 ubi_update = arg;
 895                 break;
 896
 897         case COMMAND_WRITE_PART_6:
 898                 printf("COMMAND_WRITE_DATAFS\n");
 899                 part_id = get_part_id("Data");
 900                 img_type = IMG_FILESYSTEM;
 901                 ubi_update = arg;
 902                 break;
 903
 904         case COMMAND_WRITE_PART_7:
 905                 printf("COMMAND_WRITE_UBI\n");
 906                 part_id = get_part_id("UBI");
 907                 img_type = IMG_FILESYSTEM;
 908                 ubi_update = 0;
 909                 /* someday, it will be deleted */
 910                 get_part_info();
 911                 break;
 912
 913         case COMMAND_WRITE_PART_8:
 914                 printf("COMMAND_WRITE_MODEM\n");
 915                 part_id = get_part_id("modem");
 916                 img_type = IMG_MODEM;
 917                 break;
 918
 919 #ifdef CONFIG_CMD_MMC
 920         case COMMAND_WRITE_PART_9:
 921                 printf("COMMAND_WRITE_MMC\n");
 922                 img_type = IMG_MMC;
 923                 mmc_part_write = arg;
 924                 break;
 925 #endif
 926
 927         case COMMAND_WRITE_UBI_INFO:
 928                 printf("COMMAND_WRITE_UBI_INFO\n");
 929
 930                 if (ubi_mode) {
 931 #ifdef CONFIG_CMD_UBI
 932                         part_id = arg-1;
 933                         sprintf(length, "0x%x", (uint)len);
 934                         ret = ubi_cmd(part_id, ramaddr, length, "begin");
 935                 } else {
 936 #endif
 937                         printf("Error: Not UBI mode\n");
 938                         ret = 1;
 939                 }
 940
 941                 *((ulong *) usbd->tx_data) = ret;
 942                 /* Write image success -> Report status */
 943                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 944
 945                 return !ret;
 946         /* Download complete -> reset */
 947         case COMMAND_RESET_PDA:
 948                 printf("\nDownload finished and Auto reset!\nWait........\n");
 949
 950                 /* Stop USB */
 951                 usbd->usb_stop();
 952
 953                 if (usbd->cpu_reset)
 954                         usbd->cpu_reset();
 955                 else
 956                         do_reset();
 957
 958                 return 0;
 959
 960         /* Error */
 961         case COMMAND_RESET_USB:
 962                 printf("\nError is occured!(maybe previous step)->\
 963                                 Turn off and restart!\n");
 964
 965                 /* Stop USB */
 966                 usbd->usb_stop();
 967                 return 0;
 968
 969         case COMMAND_RAM_BOOT:
 970                 usbd->usb_stop();
 971                 boot_cmd(ramaddr);
 972                 return 0;
 973
 974         case COMMAND_RAMDISK_MODE:
 975                 printf("COMMAND_RAMDISK_MODE\n");
 976 #ifdef CONFIG_RAMDISK_ADDR
 977                 if (arg) {
 978                         down_ram_addr = usbd->ram_addr;
 979                 } else {
 980                         down_ram_addr = CONFIG_RAMDISK_ADDR;
 981                         run_cmd("ramboot");
 982                 }
 983 #endif
 984                 return 1;
 985
 986 #ifdef CONFIG_DOWN_PHONE
 987         case COMMAND_DOWN_PHONE:
 988                 printf("COMMAND_RESET_PHONE\n");
 989
 990                 usbd_phone_down();
 991
 992                 *((ulong *) usbd->tx_data) = STATUS_DONE;
 993                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 994                 return 1;
 995
 996         case COMMAND_CHANGE_USB:
 997                 printf("COMMAND_CHANGE_USB\n");
 998
 999                 /* Stop USB */
1000                 usbd->usb_stop();
1001
1002                 usbd_path_change();
1003
1004                 do_reset();
1005                 return 0;
1006 #endif
1007         case COMMAND_CSA_CLEAR:
1008                 printf("COMMAND_CSA_CLEAR\n");
1009                 part_id = get_part_id("csa");
1010                 img_type = IMG_MODEM;
1011                 break;
1012
1013         case COMMAND_PROGRESS:
1014                 if (usbd->set_progress)
1015                         usbd->set_progress(arg);
1016                 return 1;
1017
1018         default:
1019                 printf("Error: Unknown command -> (%d)\n", (int)cmd);
1020                 return 1;
1021         }
1022
1023         /* Erase and Write to NAND */
1024         switch (img_type) {
1025         case IMG_BOOT:
1026                 ofs = parts[part_id]->offset;
1027 #ifdef CONFIG_S5PC1XX
1028                 /* Workaround: for prevent revision mismatch */
1029                 if (cpu_is_s5pc110() && (down_mode != MODE_FORCE)) {
1030                         int img_rev = 1;
1031                         long *img_header = (long *)down_ram_addr;
1032
1033                         if (*img_header == 0xea000012)
1034                                 img_rev = 0;
1035                         else if (*(img_header + 0x400) == 0xea000012)
1036                                 img_rev = 2;
1037
1038                         if (img_rev != s5p_get_cpu_rev()) {
1039                                 printf("CPU revision mismatch!\n"
1040                                         "bootloader is %s%s\n"
1041                                         "download image is %s%s\n",
1042                                         s5p_get_cpu_rev() ? "EVT1" : "EVT0",
1043                                         s5p_get_cpu_rev() == 2 ? "-Fused" : "",
1044                                         img_rev ? "EVT1" : "EVT0",
1045                                         img_rev == 2 ? "-Fused" : "");
1046                                 *((ulong *) usbd->tx_data) = STATUS_ERROR;
1047                                 usbd->send_data(usbd->tx_data, usbd->tx_len);
1048                                 return 0;
1049                         }
1050                 }
1051 #endif
1052 #ifdef CONFIG_SBOOT
1053                 /* Only u-boot.bin is allowed */
1054                 {
1055                         long *img_header = (long *)down_ram_addr;
1056
1057                         if (*img_header != 0xea000018) {
1058                                 printf("\n!!! ERROR !!!\n"
1059                                         "Please download the u-boot.bin.\n"
1060                                         "Other images are not allowed.\n\n");
1061                                 *((ulong *) usbd->tx_data) = STATUS_ERROR;
1062                                 usbd->send_data(usbd->tx_data, usbd->tx_len);
1063                                 return 0;
1064                         }
1065                 }
1066 #endif
1067 #if defined(CONFIG_ENV_IS_IN_NAND) || defined(CONFIG_ENV_IS_IN_ONENAND)
1068                 /* Erase the environment also when write bootloader */
1069                 {
1070                         int param_id;
1071                         param_id = get_part_id("params");
1072
1073                         if (param_id == -1) {
1074                                 sprintf(offset, "%x", CONFIG_ENV_ADDR);
1075                                 sprintf(length, "%x", CONFIG_ENV_SIZE);
1076                         } else {
1077                                 sprintf(offset, "%x", parts[param_id]->offset);
1078                                 sprintf(length, "%x", parts[param_id]->size);
1079                         }
1080                         nand_cmd(0, offset, length, NULL);
1081                 }
1082 #endif
1083                 sprintf(offset, "%x", (uint)ofs);
1084                 if (ofs != 0)
1085                         sprintf(length, "%x", parts[part_id]->size - (uint)ofs);
1086                 else
1087                         sprintf(length, "%x", parts[part_id]->size);
1088
1089                 /* Erase */
1090                 nand_cmd(0, offset, length, NULL);
1091                 /* Write */
1092                 sprintf(length, "%x", (unsigned int) len);
1093                 ret = nand_cmd(1, ramaddr, offset, length);
1094                 break;
1095
1096         case IMG_KERNEL:
1097                 sprintf(offset, "%x", parts[part_id]->offset);
1098                 sprintf(length, "%x", parts[part_id]->size);
1099
1100                 /* Erase */
1101                 nand_cmd(0, offset, length, NULL);
1102                 /* Write */
1103                 sprintf(length, "%x", (unsigned int) len);
1104                 ret = nand_cmd(1, ramaddr, offset, length);
1105
1106                 erase_qboot_area();
1107                 break;
1108
1109         /* File Systems */
1110         case IMG_FILESYSTEM:
1111                 ret = write_file_system(ramaddr, len, offset, length,
1112                                 part_id, ubi_update);
1113
1114                 erase_qboot_area();
1115                 break;
1116
1117         case IMG_MODEM:
1118                 sprintf(offset, "%x", parts[part_id]->offset);
1119                 sprintf(length, "%x", parts[part_id]->size);
1120
1121                 /* Erase */
1122                 if (!arg)
1123                         nand_cmd(0, offset, length, NULL);
1124                 else
1125                         printf("CSA Clear will be skipped temporary\n");
1126
1127                 /* Check ubi image, 0x23494255 is UBI# */
1128                 {
1129                         long *img_header = (long *)down_ram_addr;
1130
1131                         if (*img_header == 0x23494255)
1132                                 goto ubi_img;
1133                 }
1134
1135 #ifdef CONFIG_UBIFS_MK
1136                 void *dest_addr = (void *) down_ram_addr + 0xc00000;
1137                 void *src_addr = (void *) down_ram_addr;
1138                 int leb_size, max_leb_cnt, mkfs_min_io_size;
1139                 unsigned long ubifs_dest_size, ubi_dest_size;
1140 #ifdef CONFIG_S5PC110
1141                 mkfs_min_io_size = 4096;
1142                 leb_size = 248 * 1024;
1143                 max_leb_cnt = 4096;
1144 #elif CONFIG_S5PC210
1145                 mkfs_min_io_size = 2048;
1146                 leb_size = 126 * 1024;
1147                 max_leb_cnt = 4096;
1148 #endif
1149                 printf("Start making ubifs\n");
1150                 ret = mkfs(src_addr, len, dest_addr, &ubifs_dest_size,
1151                            mkfs_min_io_size, leb_size, max_leb_cnt);
1152                 if (ret) {
1153                         printf("Error : making ubifs failed\n");
1154                         goto out;
1155                 }
1156                 printf("Complete making ubifs\n");
1157 #endif
1158
1159 #ifdef CONFIG_UBINIZE
1160                 int peb_size, ubi_min_io_size, subpage_size, vid_hdr_offs;
1161 #ifdef CONFIG_S5PC110
1162                 ubi_min_io_size = 4096;
1163                 peb_size = 256 * 1024;
1164                 subpage_size = 4096;
1165                 vid_hdr_offs = 0;
1166 #elif CONFIG_S5PC210
1167                 ubi_min_io_size = 2048;
1168                 peb_size = 128 * 1024;
1169                 subpage_size = 512;
1170                 vid_hdr_offs = 512;
1171 #endif
1172                 printf("Start ubinizing\n");
1173                 ret = ubinize(dest_addr, ubifs_dest_size,
1174                               src_addr, &ubi_dest_size,
1175                               peb_size, ubi_min_io_size,
1176                               subpage_size, vid_hdr_offs);
1177                 if (ret) {
1178                         printf("Error : ubinizing failed\n");
1179                         goto out;
1180                 }
1181                 printf("Complete ubinizing\n");
1182
1183                 len = (unsigned int) ubi_dest_size;
1184 #endif
1185
1186 ubi_img:
1187                 /* Write : arg (0 Modem) / (1 CSA) */
1188                 if (!arg) {
1189                         sprintf(length, "%x", (unsigned int) len);
1190                         ret = nand_cmd(1, ramaddr, offset, length);
1191                 }
1192 out:
1193                 break;
1194
1195 #ifdef CONFIG_CMD_MMC
1196         case IMG_MMC:
1197
1198                 if (mmc_part_write)
1199                         ret = write_file_mmc_part(usbd, ramaddr,
1200                                                 len, offset, length);
1201                 else
1202                         ret = write_file_mmc(usbd, ramaddr,
1203                                                 len, offset, length);
1204
1205                 erase_qboot_area();
1206                 break;
1207 #endif
1208
1209         default:
1210                 /* Retry? */
1211                 write_part--;
1212         }
1213
1214         if (ret) {
1215                 /* Retry this commad */
1216                 *((ulong *) usbd->tx_data) = STATUS_RETRY;
1217                 usbd->send_data(usbd->tx_data, usbd->tx_len);
1218                 return 1;
1219         } else
1220                 *((ulong *) usbd->tx_data) = STATUS_DONE;
1221
1222         /* Write image success -> Report status */
1223         usbd->send_data(usbd->tx_data, usbd->tx_len);
1224
1225         write_part++;
1226
1227         /* Reset write count for another image */
1228         if (flag) {
1229                 write_part = 0;
1230                 fs_offset = 0;
1231 #ifdef CONFIG_USE_YAFFS
1232                 yaffs_len = 0;
1233 #endif
1234         }
1235
1236         return 1;
1237 }
1238
1239 static const char *recv_key = "SAMSUNG";
1240 static const char *tx_key = "MPL";
1241
1242 int do_usbd_down(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
1243 {
1244         struct usbd_ops *usbd;
1245         int err;
1246
1247         if (argc > 1)
1248                 down_mode = simple_strtoul(argv[1], NULL, 10);
1249         else
1250                 down_mode = MODE_NORMAL;
1251
1252         printf("USB Downloader v%s\n", APP_VERSION);
1253
1254         /* get partition info */
1255         err = get_part_info();
1256         if (err)
1257                 return err;
1258
1259         /* interface setting */
1260         usbd = usbd_set_interface(&usbd_ops);
1261         down_ram_addr = usbd->ram_addr;
1262
1263         /* init the usb controller */
1264         if (!usbd->usb_init()) {
1265                 usbd->down_cancel();
1266                 return 0;
1267         }
1268
1269         /* receive setting */
1270         usbd->recv_setup(usbd->rx_data, usbd->rx_len);
1271
1272         /* detect the download request from Host PC */
1273         if (usbd->recv_data()) {
1274                 if (strncmp(usbd->rx_data, recv_key, strlen(recv_key)) == 0) {
1275                         printf("Download request from the Host PC\n");
1276                         msleep(30);
1277
1278                         strcpy(usbd->tx_data, tx_key);
1279                         usbd->send_data(usbd->tx_data, usbd->tx_len);
1280                 } else {
1281                         printf("No download request from the Host PC!! 1\n");
1282                         return 0;
1283                 }
1284         } else {
1285                 usbd->down_cancel();
1286                 return 0;
1287         }
1288
1289         usbd->down_start();
1290         printf("Receive the packet\n");
1291
1292         /* receive the data from Host PC */
1293         while (1) {
1294                 usbd->recv_setup(usbd->rx_data, usbd->rx_len);
1295
1296                 if (usbd->recv_data()) {
1297                         if (process_data(usbd) == 0)
1298                                 return 0;
1299                 }
1300         }
1301
1302         return 0;
1303 }
1304
1305 U_BOOT_CMD(usbdown, CONFIG_SYS_MAXARGS, 1, do_usbd_down,
1306         "Initialize USB device and Run USB Downloader (specific)",
1307         "- normal mode\n"
1308         "usbdown mode - specific mode (0: NORAML, 1: FORCE)"
1309 );