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