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.4.1"
  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 static const char pszMe[] = "usbd: ";
  26
  27 static struct usbd_ops usbd_ops;
  28
  29 static unsigned int part_id;
  30 static unsigned int write_part = 0;
  31 static unsigned long fs_offset = 0x0;
  32
  33 #ifdef CONFIG_USE_YAFFS
  34 static unsigned int yaffs_len = 0;
  35 static unsigned char yaffs_data[2112];
  36 #define YAFFS_PAGE 2112
  37 #endif
  38
  39 #define NAND_PAGE_SIZE 2048
  40
  41 static unsigned long down_ram_addr;
  42
  43 static int down_mode;
  44
  45 /* cpu/${CPU} dependent */
  46 extern void do_reset(void);
  47
  48 /* common commands */
  49 extern int do_bootm(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
  50 extern int do_run(cmd_tbl_t * cmdtp, int flag, int argc, char *argv[]);
  51
  52 int mtdparts_init(void);
  53 int find_dev_and_part(const char*, struct mtd_device**, u8*, struct part_info**);
  54
  55 /* common/cmd_jffs2.c */
  56 extern struct list_head devices;
  57
  58 static u8 count_mtdparts(void)
  59 {
  60         struct list_head *dentry, *pentry;
  61         struct mtd_device *dev;
  62         u8 part_num = 0;
  63
  64         list_for_each(dentry, &devices) {
  65                 dev = list_entry(dentry, struct mtd_device, link);
  66
  67                 /* list partitions for given device */
  68                 list_for_each(pentry, &dev->parts)
  69                         part_num++;
  70         }
  71
  72         return part_num;
  73 }
  74
  75 #ifdef CONFIG_CMD_UBI
  76 static int check_ubi_mode(void)
  77 {
  78         char *env_ubifs;
  79         int ubi_mode;
  80
  81         env_ubifs = getenv("ubi");
  82         ubi_mode = !strcmp(env_ubifs, "enabled");
  83
  84         return ubi_mode;
  85 }
  86 #else
  87 #define check_ubi_mode()                0
  88 #endif
  89
  90 #ifdef CONFIG_MTD_PARTITIONS
  91 static int get_part_info(void)
  92 {
  93         struct mtd_device *dev;
  94         u8 out_partnum;
  95         char part_name[12];
  96         char nand_name[12];
  97         int i;
  98         int part_num;
  99         int ubi_mode = 0;
 100
 101 #if defined(CONFIG_CMD_NAND)
 102         sprintf(nand_name, "nand0");
 103 #elif defined(CONFIG_CMD_ONENAND)
 104         sprintf(nand_name, "onenand0");
 105 #else
 106         printf("Configure your NAND sub-system\n");
 107         return 0;
 108 #endif
 109
 110         if (mtdparts_init())
 111                 return 0;
 112
 113         ubi_mode = check_ubi_mode();
 114
 115         part_num = count_mtdparts();
 116         for (i = 0; i < part_num; i++) {
 117                 sprintf(part_name, "%s,%d", nand_name, i);
 118
 119                 if (find_dev_and_part(part_name, &dev, &out_partnum, &parts[i]))
 120                         return -EINVAL;
 121         }
 122
 123         return 0;
 124 }
 125
 126 static int get_part_id(char *name)
 127 {
 128         int nparts = count_mtdparts();
 129         int i;
 130
 131         for (i = 0; i < nparts; i++) {
 132                 if (strcmp(parts[i]->name, name) == 0)
 133                         return i;
 134         }
 135
 136         printf("Error: Unknown partition -> %s\n", name);
 137         return -1;
 138 }
 139 #else
 140 static int get_part_info(void)
 141 {
 142         printf("Error: Can't get patition information\n");
 143         return -EINVAL;
 144 }
 145
 146 static int get_part_id(char *name)
 147 {
 148         return 0;
 149 }
 150 #endif
 151
 152 static void boot_cmd(char *addr)
 153 {
 154         char *argv[] = { "bootm", addr };
 155         do_bootm(NULL, 0, 2, argv);
 156 }
 157
 158 static void run_cmd(char *cmd)
 159 {
 160         char *argv[] = { "run", cmd };
 161         do_run(NULL, 0, 2, argv);
 162 }
 163
 164 #if defined(CONFIG_CMD_NAND)
 165 extern int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
 166 #elif defined(CONFIG_CMD_ONENAND)
 167 extern int do_onenand(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
 168 #endif
 169
 170 /* NAND erase and write using nand command */
 171 static int nand_cmd(int type, char *p1, char *p2, char *p3)
 172 {
 173         int ret = 1;
 174         char nand_name[12];
 175         int (*nand_func) (cmd_tbl_t *, int, int, char **);
 176
 177 #if defined(CONFIG_CMD_NAND)
 178         sprintf(nand_name, "nand");
 179         nand_func = do_nand;
 180 #elif defined(CONFIG_CMD_ONENAND)
 181         sprintf(nand_name, "onenand");
 182         nand_func = do_onenand;
 183 #else
 184         printf("Configure your NAND sub-system\n");
 185         return 0;
 186 #endif
 187
 188         if (type == 0) {
 189                 char *argv[] = {nand_name, "erase", p1, p2};
 190                 printf("%s %s %s %s\n", argv[0], argv[1], argv[2], argv[3]);
 191                 ret = nand_func(NULL, 0, 4, argv);
 192         } else if (type == 1) {
 193                 char *argv[] = {nand_name, "write", p1, p2, p3};
 194                 printf("%s %s %s %s %s\n", argv[0], argv[1], argv[2],
 195                                 argv[3], argv[4]);
 196                 ret = nand_func(NULL, 0, 5, argv);
 197         } else if (type == 2) {
 198                 char *argv[] = {nand_name, "write.yaffs", p1, p2, p3};
 199                 printf("%s %s %s %s %s\n", argv[0], argv[1], argv[2],
 200                                 argv[3], argv[4]);
 201                 ret = nand_func(NULL, 0, 5, argv);
 202         }
 203
 204         if (ret)
 205                 printf("Error: NAND Command\n");
 206
 207         return ret;
 208 }
 209
 210 #ifdef CONFIG_CMD_UBI
 211 int do_ubi(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
 212
 213 int ubi_cmd(int part, char *p1, char *p2, char *p3)
 214 {
 215         int ret = 1;
 216
 217         if (part == RAMDISK_PART_ID) {
 218                 char *argv[] = {"ubi", "write", p1, "rootfs.cramfs", p2, p3};
 219                 printf("%s %s %s %s %s %s\n", argv[0], argv[1], argv[2],
 220                                 argv[3], argv[4], argv[5]);
 221                 ret = do_ubi(NULL, 0, 6, argv);
 222         } else if (part == FILESYSTEM_PART_ID) {
 223                 char *argv[] = {"ubi", "write", p1, "factoryfs.cramfs", p2, p3};
 224                 printf("%s %s %s %s %s %s\n", argv[0], argv[1], argv[2],
 225                                 argv[3], argv[4], argv[5]);
 226                 ret = do_ubi(NULL, 0, 6, argv);
 227         } else if (part == FILESYSTEM2_PART_ID) {
 228                 char *argv[] = {"ubi", "write", p1, "datafs.ubifs", p2, p3};
 229                 printf("%s %s %s %s %s %s\n", argv[0], argv[1], argv[2],
 230                                 argv[3], argv[4], argv[5]);
 231                 ret = do_ubi(NULL, 0, 6, argv);
 232         }
 233
 234         return ret;
 235 }
 236 #endif
 237
 238 #ifdef CONFIG_CMD_MMC
 239 #include <fat.h>
 240
 241 extern int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
 242
 243 static int mmc_cmd(int ops, char *p1, char *p2, char *p3)
 244 {
 245         int ret;
 246
 247         if (ops) {
 248                 char *argv[] = {"mmc", "write", "0", p1, p2, p3};
 249                 ret = do_mmcops(NULL, 0, 6, argv);
 250         } else {
 251                 char *argv[] = {"mmc", "read", "0", p1, p2, p3};
 252                 ret = do_mmcops(NULL, 0, 6, argv);
 253         }
 254
 255         return ret;
 256 }
 257
 258 static unsigned int cur_blk_offset;
 259 static unsigned int cur_part_size;
 260 static unsigned int cur_partition;
 261
 262 static unsigned int mmc_parts;
 263 static unsigned int mmc_part_write;
 264
 265 struct partition_info {
 266         u32 size;
 267         u32 checksum;
 268         u32 res;
 269 } __attribute__((packed));
 270
 271 struct partition_header {
 272         u8                      fat32head[16];  /* RFSHEAD identifier */
 273         struct partition_info   partition[4];
 274         u8                      res[448];       /* reserved */
 275 } __attribute__((packed));
 276
 277 struct partition_table {
 278         u8      boot_flag;
 279         u8      chs_begin[3];
 280         u8      type_code;
 281         u8      chs_end[3];
 282         u32     lba_begin;
 283         u32     num_sectors;
 284 } __attribute__((packed));
 285
 286 struct mbr_table {
 287         u8                      boot_code[446];
 288         struct partition_table  partition[4];
 289         u16                     signature;
 290 } __attribute__((packed));
 291
 292 #define MBR_OFFSET      0x10
 293
 294 struct partition_header part_info;
 295 struct mbr_table mbr_info;
 296
 297 static int write_mmc_partition(struct usbd_ops *usbd, u32 *ram_addr, u32 len)
 298 {
 299         unsigned int blocks;
 300         char offset[12], length[12], ramaddr[12];
 301         int i;
 302         int loop;
 303         u32 cnt;
 304         int ret;
 305
 306         if (cur_part_size > len) {
 307                 blocks = len / usbd->mmc_blk;
 308                 ret = -1;
 309         } else {
 310                 blocks = cur_part_size / usbd->mmc_blk;
 311                 ret = len - cur_part_size;
 312         }
 313
 314         if (len % usbd->mmc_blk)
 315                 blocks++;
 316
 317         loop = blocks / usbd->mmc_max;
 318         if (blocks % usbd->mmc_max)
 319                 loop++;
 320
 321         for (i = 0; i < loop; i++) {
 322                 if (i == 0) {
 323                         cnt = blocks % usbd->mmc_max;
 324                         if (cnt == 0)
 325                                 cnt = usbd->mmc_max;
 326                 } else {
 327                         cnt = usbd->mmc_max;
 328                 }
 329
 330                 sprintf(length, "%x", cnt);
 331                 sprintf(offset, "%x", cur_blk_offset);
 332                 sprintf(ramaddr, "0x%x", *ram_addr);
 333                 mmc_cmd(OPS_WRITE, ramaddr, offset, length);
 334
 335                 cur_blk_offset += cnt;
 336
 337                 *ram_addr += (cnt * usbd->mmc_blk);
 338         }
 339
 340         return ret;
 341 }
 342
 343 static int write_file_mmc(struct usbd_ops *usbd, char *ramaddr, u32 len,
 344                 char *offset, char *length)
 345 {
 346         u32 ram_addr;
 347         int i;
 348         int ret;
 349
 350         ram_addr = (u32)down_ram_addr;
 351
 352         if (cur_blk_offset == 0) {
 353                 boot_sector *bs;
 354                 struct mbr_table *mbr;
 355
 356                 memcpy(&part_info, (void *)ram_addr,
 357                                 sizeof(struct partition_header));
 358
 359                 ram_addr += sizeof(struct partition_header);
 360                 len -= sizeof(struct partition_header);
 361                 mbr = (struct mbr_table*)ram_addr;
 362
 363                 /* modify sectors of p1 */
 364                 mbr->partition[0].num_sectors = usbd->mmc_total -
 365                                 (MBR_OFFSET +
 366                                 mbr->partition[1].num_sectors +
 367                                 mbr->partition[2].num_sectors +
 368                                 mbr->partition[3].num_sectors);
 369
 370                 mmc_parts++;
 371
 372                 /* modify lba_begin of p2 and p3 and p4 */
 373                 for (i = 1; i < 4; i++) {
 374                         if (part_info.partition[i].size == 0)
 375                                 break;
 376
 377                         mmc_parts++;
 378                         mbr->partition[i].lba_begin =
 379                                 mbr->partition[i - 1].lba_begin +
 380                                 mbr->partition[i - 1].num_sectors;
 381                 }
 382
 383                 /* copy MBR */
 384                 memcpy(&mbr_info, mbr, sizeof(struct mbr_table));
 385
 386                 printf("Total Size: 0x%08x #parts %d\n",
 387                                 (unsigned int)usbd->mmc_total, mmc_parts);
 388                 for (i = 0; i < mmc_parts; i++) {
 389                         printf("p%d\t0x%08x\t0x%08x\n", i + 1,
 390                                 mbr_info.partition[i].lba_begin,
 391                                 mbr_info.partition[i].num_sectors);
 392                 }
 393
 394                 /* write MBR */
 395                 sprintf(length, "%x", MBR_OFFSET);
 396                 sprintf(offset, "%x", 0);
 397                 sprintf(ramaddr, "0x%x", (u32)ram_addr);
 398                 ret = mmc_cmd(OPS_WRITE, ramaddr, offset, length);
 399
 400                 ram_addr += (MBR_OFFSET * usbd->mmc_blk);
 401                 len -= (MBR_OFFSET * usbd->mmc_blk);
 402
 403                 cur_blk_offset = MBR_OFFSET;
 404                 cur_partition = 0;
 405                 cur_part_size = part_info.partition[0].size;
 406
 407                 /* modify p1's total sector */
 408                 bs = (boot_sector *)ram_addr;
 409                 bs->total_sect = mbr_info.partition[0].num_sectors;
 410
 411                 printf("\nWrite Partition %d.. %d blocks\n",
 412                         cur_partition + 1,
 413                         part_info.partition[cur_partition].size /
 414                         (int)usbd->mmc_blk);
 415         }
 416
 417         for (i = cur_partition; i < mmc_parts; i++) {
 418                 ret = write_mmc_partition(usbd, &ram_addr, len);
 419
 420                 if (ret < 0) {
 421                         cur_part_size -= len;
 422                         break;
 423                 } else {
 424                         cur_partition++;
 425                         cur_part_size =
 426                                 part_info.partition[cur_partition].size;
 427                         cur_blk_offset =
 428                                 mbr_info.partition[cur_partition].lba_begin;
 429
 430                         if (ret == 0)
 431                                 break;
 432                         else
 433                                 len = ret;
 434
 435                         printf("\nWrite Partition %d.. %d blocks\n",
 436                                 cur_partition + 1,
 437                                 part_info.partition[cur_partition].size /
 438                                 (int)usbd->mmc_blk);
 439                 }
 440         }
 441
 442         return 0;
 443 }
 444
 445 static int write_file_mmc_part(struct usbd_ops *usbd, char *ramaddr, u32 len,
 446                 char *offset, char *length)
 447 {
 448         u32 ram_addr;
 449         int ret;
 450         int i;
 451
 452         ram_addr = (u32)down_ram_addr;
 453
 454         if (cur_blk_offset == 0) {
 455                 /* read MBR */
 456                 sprintf(length, "%x", MBR_OFFSET);
 457                 sprintf(offset, "%x", 0);
 458                 sprintf(ramaddr, "0x%x", (u32)&mbr_info);
 459                 ret = mmc_cmd(OPS_READ, ramaddr, offset, length);
 460
 461                 for (i = 0; i < 4; i++) {
 462                         printf("p%d\t0x%08x\t0x%08x\n", i + 1,
 463                                 mbr_info.partition[i].lba_begin,
 464                                 mbr_info.partition[i].num_sectors);
 465                 }
 466
 467                 cur_blk_offset = (unsigned int)
 468                         mbr_info.partition[mmc_part_write - 1].lba_begin;
 469                 cur_partition = mmc_part_write - 1;
 470                 cur_part_size = (unsigned int)len;
 471
 472                 if (mmc_part_write == 1) {
 473                         ram_addr += sizeof(boot_sector);
 474                         cur_blk_offset += sizeof(boot_sector) / usbd->mmc_blk;
 475                         len -= sizeof(boot_sector);
 476                 }
 477         }
 478
 479         printf("\nWrite Partition %d.. %d blocks\n",
 480                 cur_partition + 1,
 481                 len / (int)usbd->mmc_blk);
 482
 483         write_mmc_partition(usbd, &ram_addr, len);
 484
 485         return 0;
 486 }
 487 #endif
 488
 489 static int write_file_system(char *ramaddr, ulong len, char *offset,
 490                 char *length, int part_num, int ubi_update)
 491 {
 492 #ifdef CONFIG_USE_YAFFS
 493         int actual_len = 0;
 494         int yaffs_write = 0;
 495 #endif
 496         int ret = 0;
 497
 498 #ifdef CONFIG_CMD_UBI
 499         /* UBI Update */
 500         if (ubi_update) {
 501                 sprintf(length, "0x%x", (uint)len);
 502                 ret = ubi_cmd(part_id, ramaddr, length, "cont");
 503                 return ret;
 504         }
 505 #endif
 506
 507         /* Erase entire partition at the first writing */
 508         if (write_part == 0 && ubi_update == 0) {
 509                 sprintf(offset, "0x%x", (uint)parts[part_num]->offset);
 510                 sprintf(length, "0x%x", (uint)parts[part_num]->size);
 511                 nand_cmd(0, offset, length, NULL);
 512         }
 513
 514 #ifdef CONFIG_USE_YAFFS
 515         /* if using yaffs, wirte size must be 2112*X
 516          * so, must have to realloc, and writing */
 517         if (!strcmp("yaffs", getenv(parts[part_num]->name))) {
 518                 yaffs_write = 1;
 519
 520                 memcpy((void *)down_ram_addr, yaffs_data, yaffs_len);
 521
 522                 actual_len = len + yaffs_len;
 523                 yaffs_len = actual_len % YAFFS_PAGE;
 524                 len = actual_len - yaffs_len;
 525
 526                 memset(yaffs_data, 0x00, YAFFS_PAGE);
 527                 memcpy(yaffs_data, (char *)down_ram_addr + len, yaffs_len);
 528         }
 529 #endif
 530
 531         sprintf(offset, "0x%x", (uint)(parts[part_num]->offset + fs_offset));
 532         sprintf(length, "0x%x", (uint)len);
 533
 534 #ifdef CONFIG_USE_YAFFS
 535         if (yaffs_write)
 536                 ret = nand_cmd(2, ramaddr, offset, length);
 537         else
 538                 ret = nand_cmd(1, ramaddr, offset, length);
 539
 540         if (!strcmp("yaffs", getenv(parts[part_num]->name)))
 541                 fs_offset += len / YAFFS_PAGE * NAND_PAGE_SIZE;
 542         else
 543                 fs_offset += len;
 544
 545 #else
 546         fs_offset += len;
 547         ret = nand_cmd(1, ramaddr, offset, length);
 548 #endif
 549
 550         return ret;
 551 }
 552
 553 /* Parsing received data packet and Process data */
 554 static int process_data(struct usbd_ops *usbd)
 555 {
 556         ulong cmd = 0, arg = 0, len = 0, flag = 0;
 557         char offset[12], length[12], ramaddr[12];
 558         int recvlen = 0;
 559         unsigned int blocks = 0;
 560         int ret = 0;
 561         int ubi_update = 0;
 562         int ubi_mode = 0;
 563         int img_type;
 564
 565         sprintf(ramaddr, "0x%x", (uint) down_ram_addr);
 566
 567         /* Parse command */
 568         cmd  = *((ulong *) usbd->rx_data + 0);
 569         arg  = *((ulong *) usbd->rx_data + 1);
 570         len  = *((ulong *) usbd->rx_data + 2);
 571         flag = *((ulong *) usbd->rx_data + 3);
 572
 573         /* Reset tx buffer */
 574         memset(usbd->tx_data, 0, sizeof(usbd->tx_data));
 575
 576         ubi_mode = check_ubi_mode();
 577
 578         switch (cmd) {
 579         case COMMAND_DOWNLOAD_IMAGE:
 580                 printf("\nCOMMAND_DOWNLOAD_IMAGE\n");
 581
 582 #ifdef CONFIG_USE_YAFFS
 583                 usbd->recv_setup((char *)down_ram_addr + yaffs_len, (int)len);
 584                 printf("Download to 0x%08x, %d bytes\n",
 585                                 (uint)down_ram_addr + yaffs_len, (int)len);
 586 #else
 587                 usbd->recv_setup((char *)down_ram_addr, (int)len);
 588                 printf("Download to 0x%08x, %d bytes\n",
 589                                 (uint)down_ram_addr, (int)len);
 590 #endif
 591                 /* response */
 592                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 593
 594                 /* Receive image by using dma */
 595                 recvlen = usbd->recv_data();
 596                 if (recvlen < len) {
 597                         printf("Error: wrong image size -> %d/%d\n",
 598                                         (int)recvlen, (int)len);
 599
 600                         /* Retry this commad */
 601                         *((ulong *) usbd->tx_data) = STATUS_RETRY;
 602                 } else
 603                         *((ulong *) usbd->tx_data) = STATUS_DONE;
 604
 605                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 606                 return 1;
 607
 608         /* Report partition info */
 609         case COMMAND_PARTITION_SYNC:
 610                 part_id = arg;
 611
 612 #ifdef CONFIG_CMD_UBI
 613                 if (ubi_mode) {
 614                         if (part_id == RAMDISK_PART_ID ||
 615                             part_id == FILESYSTEM_PART_ID ||
 616                             part_id == FILESYSTEM2_PART_ID) {
 617                                 /* change to yaffs style */
 618                                 get_part_info();
 619                         }
 620                 } else {
 621                         if (part_id == FILESYSTEM3_PART_ID) {
 622                                 /* change ubi style */
 623                                 get_part_info();
 624                         }
 625                 }
 626 #endif
 627
 628                 if (part_id == FILESYSTEM3_PART_ID)
 629                         part_id = get_part_id("UBI");
 630                 else if (part_id == MODEM_PART_ID)
 631                         part_id = get_part_id("modem");
 632                 else if (part_id == KERNEL_PART_ID)
 633                         part_id = get_part_id("kernel");
 634 #ifdef CONFIG_MIRAGE
 635                 if (part_id)
 636                         part_id--;
 637 #endif
 638                 printf("COMMAND_PARTITION_SYNC - Part%d\n", part_id);
 639
 640                 blocks = parts[part_id]->size / 1024 / 128;
 641                 printf("COMMAND_PARTITION_SYNC - Part%d, %d blocks\n",
 642                                 part_id, blocks);
 643
 644                 *((ulong *) usbd->tx_data) = blocks;
 645                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 646                 return 1;
 647
 648         case COMMAND_WRITE_PART_0:
 649                 /* Do nothing */
 650                 printf("COMMAND_WRITE_PART_0\n");
 651                 return 1;
 652
 653         case COMMAND_WRITE_PART_1:
 654                 printf("COMMAND_WRITE_PART_BOOT\n");
 655                 part_id = get_part_id("bootloader");
 656                 img_type = IMG_BOOT;
 657                 break;
 658
 659         case COMMAND_WRITE_PART_2:
 660         case COMMAND_ERASE_PARAMETER:
 661                 printf("COMMAND_PARAMETER - not support!\n");
 662                 break;
 663
 664         case COMMAND_WRITE_PART_3:
 665                 printf("COMMAND_WRITE_KERNEL\n");
 666                 part_id = get_part_id("kernel");
 667                 img_type = IMG_KERNEL;
 668                 break;
 669
 670         case COMMAND_WRITE_PART_4:
 671                 printf("COMMAND_WRITE_ROOTFS\n");
 672                 part_id = get_part_id("Root");
 673                 img_type = IMG_FILESYSTEM;
 674                 ubi_update = arg;
 675                 break;
 676
 677         case COMMAND_WRITE_PART_5:
 678                 printf("COMMAND_WRITE_FACTORYFS\n");
 679                 part_id = get_part_id("Fact");
 680                 img_type = IMG_FILESYSTEM;
 681                 ubi_update = arg;
 682                 break;
 683
 684         case COMMAND_WRITE_PART_6:
 685                 printf("COMMAND_WRITE_DATAFS\n");
 686                 part_id = get_part_id("Data");
 687                 img_type = IMG_FILESYSTEM;
 688                 ubi_update = arg;
 689                 break;
 690
 691         case COMMAND_WRITE_PART_7:
 692                 printf("COMMAND_WRITE_UBI\n");
 693                 part_id = get_part_id("UBI");
 694                 img_type = IMG_FILESYSTEM;
 695                 ubi_update = 0;
 696                 /* someday, it will be deleted */
 697                 get_part_info();
 698                 break;
 699
 700         case COMMAND_WRITE_PART_8:
 701                 printf("COMMAND_WRITE_MODEM\n");
 702                 part_id = get_part_id("modem");
 703                 img_type = IMG_MODEM;
 704                 break;
 705
 706         case COMMAND_WRITE_PART_9:
 707                 printf("COMMAND_WRITE_MMC\n");
 708                 img_type = IMG_MMC;
 709                 mmc_part_write = arg;
 710                 break;
 711
 712         case COMMAND_WRITE_UBI_INFO:
 713                 printf("COMMAND_WRITE_UBI_INFO\n");
 714
 715                 if (ubi_mode) {
 716 #ifdef CONFIG_CMD_UBI
 717                         part_id = arg-1;
 718                         sprintf(length, "0x%x", (uint)len);
 719                         ret = ubi_cmd(part_id, ramaddr, length, "begin");
 720                 } else {
 721 #endif
 722                         printf("Error: Not UBI mode\n");
 723                         ret = 1;
 724                 }
 725
 726                 *((ulong *) usbd->tx_data) = ret;
 727                 /* Write image success -> Report status */
 728                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 729
 730                 return !ret;
 731         /* Download complete -> reset */
 732         case COMMAND_RESET_PDA:
 733                 printf("\nDownload finished and Auto reset!\nWait........\n");
 734
 735                 /* Stop USB */
 736                 usbd->usb_stop();
 737
 738                 do_reset();
 739                 return 0;
 740
 741         /* Error */
 742         case COMMAND_RESET_USB:
 743                 printf("\nError is occured!(maybe previous step)->\
 744                                 Turn off and restart!\n");
 745
 746                 /* Stop USB */
 747                 usbd->usb_stop();
 748                 return 0;
 749
 750         case COMMAND_RAM_BOOT:
 751                 usbd->usb_stop();
 752                 boot_cmd(ramaddr);
 753                 return 0;
 754
 755         case COMMAND_RAMDISK_MODE:
 756                 printf("COMMAND_RAMDISK_MODE\n");
 757 #ifdef CONFIG_RAMDISK_ADDR
 758                 if (arg) {
 759                         down_ram_addr = usbd->ram_addr;
 760                 } else {
 761                         down_ram_addr = CONFIG_RAMDISK_ADDR;
 762                         run_cmd("ramboot");
 763                 }
 764 #endif
 765                 return 1;
 766
 767 #ifdef CONFIG_DOWN_PHONE
 768         case COMMAND_DOWN_PHONE:
 769                 printf("COMMAND_RESET_PHONE\n");
 770
 771                 usbd_phone_down();
 772
 773                 *((ulong *) usbd->tx_data) = STATUS_DONE;
 774                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 775                 return 1;
 776
 777         case COMMAND_CHANGE_USB:
 778                 printf("COMMAND_CHANGE_USB\n");
 779
 780                 /* Stop USB */
 781                 usbd->usb_stop();
 782
 783                 usbd_path_change();
 784
 785                 do_reset();
 786                 return 0;
 787 #endif
 788         case COMMAND_CSA_CLEAR:
 789                 printf("COMMAND_CSA_CLEAR\n");
 790                 part_id = get_part_id("csa");
 791                 img_type = IMG_MODEM;
 792                 break;
 793
 794         case COMMAND_PROGRESS:
 795                 if (usbd->set_progress)
 796                         usbd->set_progress(arg);
 797                 return 1;
 798
 799         default:
 800                 printf("Error: Unknown command -> (%d)\n", (int)cmd);
 801                 return 1;
 802         }
 803
 804         /* Erase and Write to NAND */
 805         switch (img_type) {
 806         case IMG_BOOT:
 807 #ifdef CONFIG_S5PC1XX
 808                 /* Workaround: for prevent revision mismatch */
 809                 if (cpu_is_s5pc110() && (down_mode != MODE_FORCE)) {
 810                         int img_rev = 1;
 811                         long *img_header = (long *)down_ram_addr;
 812
 813                         if (*img_header == 0xea000012)
 814                                 img_rev = 0;
 815
 816                         if (img_rev != s5pc1xx_get_cpu_rev()) {
 817                                 printf("CPU revision mismatch!\n");
 818                                 *((ulong *) usbd->tx_data) = STATUS_ERROR;
 819                                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 820                                 return 0;
 821                         }
 822                 }
 823 #endif
 824 #if defined(CONFIG_ENV_IS_IN_NAND) || defined(CONFIG_ENV_IS_IN_ONENAND)
 825                 /* Erase the environment also when write bootloader */
 826                 {
 827                         int param_id;
 828                         param_id = get_part_id("params");
 829
 830                         if (param_id == -1) {
 831                                 sprintf(offset, "%x", CONFIG_ENV_OFFSET);
 832                                 sprintf(length, "%x", CONFIG_ENV_SIZE);
 833                         } else {
 834                                 sprintf(offset, "%x", parts[param_id]->offset);
 835                                 sprintf(length, "%x", parts[param_id]->size);
 836                         }
 837                         nand_cmd(0, offset, length, NULL);
 838                 }
 839 #endif
 840                 /* Fall through for write bootloader */
 841         case IMG_KERNEL:
 842                 sprintf(offset, "%x", parts[part_id]->offset);
 843                 sprintf(length, "%x", parts[part_id]->size);
 844
 845                 /* Erase */
 846                 nand_cmd(0, offset, length, NULL);
 847                 /* Write */
 848                 sprintf(length, "%x", (unsigned int) len);
 849                 ret = nand_cmd(1, ramaddr, offset, length);
 850                 break;
 851
 852         /* File Systems */
 853         case IMG_FILESYSTEM:
 854                 ret = write_file_system(ramaddr, len, offset, length,
 855                                 part_id, ubi_update);
 856                 break;
 857
 858         case IMG_MODEM:
 859                 sprintf(offset, "%x", parts[part_id]->offset);
 860                 sprintf(length, "%x", parts[part_id]->size);
 861
 862                 /* Erase */
 863                 nand_cmd(0, offset, length, NULL);
 864
 865                 /* Write : arg (0 Modem) / (1 CSA) */
 866                 if (!arg) {
 867                         sprintf(length, "%x", (unsigned int) len);
 868                         ret = nand_cmd(1, ramaddr, offset, length);
 869                 }
 870                 break;
 871
 872 #ifdef CONFIG_CMD_MMC
 873         case IMG_MMC:
 874                 if (mmc_part_write)
 875                         ret = write_file_mmc_part(usbd, ramaddr,
 876                                                 len, offset, length);
 877                 else
 878                         ret = write_file_mmc(usbd, ramaddr,
 879                                                 len, offset, length);
 880                 break;
 881 #endif
 882
 883         default:
 884                 /* Retry? */
 885                 write_part--;
 886         }
 887
 888         if (ret) {
 889                 /* Retry this commad */
 890                 *((ulong *) usbd->tx_data) = STATUS_RETRY;
 891                 usbd->send_data(usbd->tx_data, usbd->tx_len);
 892                 return 1;
 893         } else
 894                 *((ulong *) usbd->tx_data) = STATUS_DONE;
 895
 896         /* Write image success -> Report status */
 897         usbd->send_data(usbd->tx_data, usbd->tx_len);
 898
 899         write_part++;
 900
 901         /* Reset write count for another image */
 902         if (flag) {
 903                 write_part = 0;
 904                 fs_offset = 0;
 905 #ifdef CONFIG_USE_YAFFS
 906                 yaffs_len = 0;
 907 #endif
 908         }
 909
 910         return 1;
 911 }
 912
 913 static const char *recv_key = "SAMSUNG";
 914 static const char *tx_key = "MPL";
 915
 916 int do_usbd_down(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 917 {
 918         struct usbd_ops *usbd;
 919         int err;
 920
 921         if (argc > 1)
 922                 down_mode = simple_strtoul(argv[1], NULL, 10);
 923         else
 924                 down_mode = MODE_NORMAL;
 925
 926         printf("USB Downloader v%s\n", APP_VERSION);
 927
 928         /* get partition info */
 929         err = get_part_info();
 930         if (err)
 931                 return err;
 932
 933         /* interface setting */
 934         usbd = usbd_set_interface(&usbd_ops);
 935         down_ram_addr = usbd->ram_addr;
 936
 937         /* init the usb controller */
 938         usbd->usb_init();
 939
 940         /* receive setting */
 941         usbd->recv_setup(usbd->rx_data, usbd->rx_len);
 942
 943         /* detect the download request from Host PC */
 944         if (usbd->recv_data()) {
 945                 if (strncmp(usbd->rx_data, recv_key, strlen(recv_key)) == 0) {
 946                         printf("Download request from the Host PC\n");
 947                         msleep(30);
 948
 949                         strcpy(usbd->tx_data, tx_key);
 950                         usbd->send_data(usbd->tx_data, usbd->tx_len);
 951                 } else {
 952                         printf("No download request from the Host PC!! 1\n");
 953                         return 0;
 954                 }
 955         } else {
 956                 printf("No download request from the Host PC!!\n");
 957                 return 0;
 958         }
 959
 960         printf("Receive the packet\n");
 961
 962         /* receive the data from Host PC */
 963         while (1) {
 964                 usbd->recv_setup(usbd->rx_data, usbd->rx_len);
 965
 966                 if (usbd->recv_data()) {
 967                         if (process_data(usbd) == 0)
 968                                 return 0;
 969                 }
 970         }
 971
 972         return 0;
 973 }
 974
 975 U_BOOT_CMD(usbdown, CONFIG_SYS_MAXARGS, 1, do_usbd_down,
 976         "Initialize USB device and Run USB Downloader (specific)",
 977         "- normal mode\n"
 978         "usbdown mode - specific mode (0: NORAML, 1: FORCE)\n"
 979 );