2 * USB Downloader for SAMSUNG Platform
4 * Copyright (C) 2007-2008 Samsung Electronics
5 * Minkyu Kang <mk7.kang@samsung.com>
11 #include <asm/errno.h>
14 /* version of USB Downloader Application */
15 #define APP_VERSION "1.4.1"
20 #ifdef CONFIG_CMD_MTDPARTS
21 #include <jffs2/load_kernel.h>
22 static struct part_info *parts[16];
25 static const char pszMe[] = "usbd: ";
27 static struct usbd_ops usbd_ops;
29 static unsigned int part_id;
30 static unsigned int write_part = 0;
31 static unsigned long fs_offset = 0x0;
33 #ifdef CONFIG_USE_YAFFS
34 static unsigned int yaffs_len = 0;
35 static unsigned char yaffs_data[2112];
36 #define YAFFS_PAGE 2112
39 #define NAND_PAGE_SIZE 2048
41 static unsigned long down_ram_addr;
45 /* cpu/${CPU} dependent */
46 extern void do_reset(void);
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[]);
52 int mtdparts_init(void);
53 int find_dev_and_part(const char*, struct mtd_device**, u8*, struct part_info**);
55 /* common/cmd_jffs2.c */
56 extern struct list_head devices;
58 static u8 count_mtdparts(void)
60 struct list_head *dentry, *pentry;
61 struct mtd_device *dev;
64 list_for_each(dentry, &devices) {
65 dev = list_entry(dentry, struct mtd_device, link);
67 /* list partitions for given device */
68 list_for_each(pentry, &dev->parts)
76 static int check_ubi_mode(void)
81 env_ubifs = getenv("ubi");
82 ubi_mode = !strcmp(env_ubifs, "enabled");
87 #define check_ubi_mode() 0
90 #ifdef CONFIG_MTD_PARTITIONS
91 static int get_part_info(void)
93 struct mtd_device *dev;
101 #if defined(CONFIG_CMD_NAND)
102 sprintf(nand_name, "nand0");
103 #elif defined(CONFIG_CMD_ONENAND)
104 sprintf(nand_name, "onenand0");
106 printf("Configure your NAND sub-system\n");
113 ubi_mode = check_ubi_mode();
115 part_num = count_mtdparts();
116 for (i = 0; i < part_num; i++) {
117 sprintf(part_name, "%s,%d", nand_name, i);
119 if (find_dev_and_part(part_name, &dev, &out_partnum, &parts[i]))
126 static int get_part_id(char *name)
128 int nparts = count_mtdparts();
131 for (i = 0; i < nparts; i++) {
132 if (strcmp(parts[i]->name, name) == 0)
136 printf("Error: Unknown partition -> %s\n", name);
140 static int get_part_info(void)
142 printf("Error: Can't get patition information\n");
146 static int get_part_id(char *name)
152 static void boot_cmd(char *addr)
154 char *argv[] = { "bootm", addr };
155 do_bootm(NULL, 0, 2, argv);
158 static void run_cmd(char *cmd)
160 char *argv[] = { "run", cmd };
161 do_run(NULL, 0, 2, argv);
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[]);
170 /* NAND erase and write using nand command */
171 static int nand_cmd(int type, char *p1, char *p2, char *p3)
175 int (*nand_func) (cmd_tbl_t *, int, int, char **);
177 #if defined(CONFIG_CMD_NAND)
178 sprintf(nand_name, "nand");
180 #elif defined(CONFIG_CMD_ONENAND)
181 sprintf(nand_name, "onenand");
182 nand_func = do_onenand;
184 printf("Configure your NAND sub-system\n");
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],
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],
201 ret = nand_func(NULL, 0, 5, argv);
205 printf("Error: NAND Command\n");
210 #ifdef CONFIG_CMD_UBI
211 int do_ubi(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
213 int ubi_cmd(int part, char *p1, char *p2, char *p3)
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);
238 #ifdef CONFIG_CMD_MMC
241 extern int do_mmcops(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
243 static int mmc_cmd(int ops, char *p1, char *p2, char *p3)
248 char *argv[] = {"mmc", "write", "0", p1, p2, p3};
249 ret = do_mmcops(NULL, 0, 6, argv);
251 char *argv[] = {"mmc", "read", "0", p1, p2, p3};
252 ret = do_mmcops(NULL, 0, 6, argv);
258 static unsigned int cur_blk_offset;
259 static unsigned int cur_part_size;
260 static unsigned int cur_partition;
262 static unsigned int mmc_parts;
263 static unsigned int mmc_part_write;
265 struct partition_info {
269 } __attribute__((packed));
271 struct partition_header {
272 u8 fat32head[16]; /* RFSHEAD identifier */
273 struct partition_info partition[4];
274 u8 res[448]; /* reserved */
275 } __attribute__((packed));
277 struct partition_table {
284 } __attribute__((packed));
288 struct partition_table partition[4];
290 } __attribute__((packed));
292 #define MBR_OFFSET 0x10
294 struct partition_header part_info;
295 struct mbr_table mbr_info;
297 static int write_mmc_partition(struct usbd_ops *usbd, u32 *ram_addr, u32 len)
300 char offset[12], length[12], ramaddr[12];
306 if (cur_part_size > len) {
307 blocks = len / usbd->mmc_blk;
310 blocks = cur_part_size / usbd->mmc_blk;
311 ret = len - cur_part_size;
314 if (len % usbd->mmc_blk)
317 loop = blocks / usbd->mmc_max;
318 if (blocks % usbd->mmc_max)
321 for (i = 0; i < loop; i++) {
323 cnt = blocks % usbd->mmc_max;
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);
335 cur_blk_offset += cnt;
337 *ram_addr += (cnt * usbd->mmc_blk);
343 static int write_file_mmc(struct usbd_ops *usbd, char *ramaddr, u32 len,
344 char *offset, char *length)
350 ram_addr = (u32)down_ram_addr;
352 if (cur_blk_offset == 0) {
354 struct mbr_table *mbr;
356 memcpy(&part_info, (void *)ram_addr,
357 sizeof(struct partition_header));
359 ram_addr += sizeof(struct partition_header);
360 len -= sizeof(struct partition_header);
361 mbr = (struct mbr_table*)ram_addr;
363 /* modify sectors of p1 */
364 mbr->partition[0].num_sectors = usbd->mmc_total -
366 mbr->partition[1].num_sectors +
367 mbr->partition[2].num_sectors +
368 mbr->partition[3].num_sectors);
370 /* modify lba_begin of p2 and p3 and p4 */
371 for (i = 1; i < 4; i++) {
373 if (part_info.partition[i].size == 0)
376 mbr->partition[i].lba_begin =
377 mbr->partition[i - 1].lba_begin +
378 mbr->partition[i - 1].num_sectors;
382 memcpy(&mbr_info, mbr, sizeof(struct mbr_table));
384 printf("Total Size: 0x%08x #parts %d\n",
385 (unsigned int)usbd->mmc_total, mmc_parts);
386 for (i = 0; i < mmc_parts; i++) {
387 printf("p%d\t0x%08x\t0x%08x\n", i + 1,
388 mbr_info.partition[i].lba_begin,
389 mbr_info.partition[i].num_sectors);
393 sprintf(length, "%x", MBR_OFFSET);
394 sprintf(offset, "%x", 0);
395 sprintf(ramaddr, "0x%x", (u32)ram_addr);
396 ret = mmc_cmd(OPS_WRITE, ramaddr, offset, length);
398 ram_addr += (MBR_OFFSET * usbd->mmc_blk);
399 len -= (MBR_OFFSET * usbd->mmc_blk);
401 cur_blk_offset = MBR_OFFSET;
403 cur_part_size = part_info.partition[0].size;
405 /* modify p1's total sector */
406 bs = (boot_sector *)ram_addr;
407 bs->total_sect = mbr_info.partition[0].num_sectors;
409 printf("\nWrite Partition %d.. %d blocks\n",
411 part_info.partition[cur_partition].size /
415 for (i = cur_partition; i < mmc_parts; i++) {
416 ret = write_mmc_partition(usbd, &ram_addr, len);
419 cur_part_size -= len;
424 part_info.partition[cur_partition].size;
426 mbr_info.partition[cur_partition].lba_begin;
433 printf("\nWrite Partition %d.. %d blocks\n",
435 part_info.partition[cur_partition].size /
443 static int write_file_mmc_part(struct usbd_ops *usbd, char *ramaddr, u32 len,
444 char *offset, char *length)
450 ram_addr = (u32)down_ram_addr;
452 if (cur_blk_offset == 0) {
454 sprintf(length, "%x", MBR_OFFSET);
455 sprintf(offset, "%x", 0);
456 sprintf(ramaddr, "0x%x", (u32)&mbr_info);
457 ret = mmc_cmd(OPS_READ, ramaddr, offset, length);
459 for (i = 0; i < 4; i++) {
460 printf("p%d\t0x%08x\t0x%08x\n", i + 1,
461 mbr_info.partition[i].lba_begin,
462 mbr_info.partition[i].num_sectors);
465 cur_blk_offset = (unsigned int)
466 mbr_info.partition[mmc_part_write - 1].lba_begin;
467 cur_partition = mmc_part_write - 1;
468 cur_part_size = (unsigned int)len;
470 if (mmc_part_write == 1) {
471 ram_addr += sizeof(boot_sector);
472 cur_blk_offset += sizeof(boot_sector) / usbd->mmc_blk;
473 len -= sizeof(boot_sector);
477 printf("\nWrite Partition %d.. %d blocks\n",
479 len / (int)usbd->mmc_blk);
481 write_mmc_partition(usbd, &ram_addr, len);
487 static int write_file_system(char *ramaddr, ulong len, char *offset,
488 char *length, int part_num, int ubi_update)
490 #ifdef CONFIG_USE_YAFFS
496 #ifdef CONFIG_CMD_UBI
499 sprintf(length, "0x%x", (uint)len);
500 ret = ubi_cmd(part_id, ramaddr, length, "cont");
505 /* Erase entire partition at the first writing */
506 if (write_part == 0 && ubi_update == 0) {
507 sprintf(offset, "0x%x", (uint)parts[part_num]->offset);
508 sprintf(length, "0x%x", (uint)parts[part_num]->size);
509 nand_cmd(0, offset, length, NULL);
512 #ifdef CONFIG_USE_YAFFS
513 /* if using yaffs, wirte size must be 2112*X
514 * so, must have to realloc, and writing */
515 if (!strcmp("yaffs", getenv(parts[part_num]->name))) {
518 memcpy((void *)down_ram_addr, yaffs_data, yaffs_len);
520 actual_len = len + yaffs_len;
521 yaffs_len = actual_len % YAFFS_PAGE;
522 len = actual_len - yaffs_len;
524 memset(yaffs_data, 0x00, YAFFS_PAGE);
525 memcpy(yaffs_data, (char *)down_ram_addr + len, yaffs_len);
529 sprintf(offset, "0x%x", (uint)(parts[part_num]->offset + fs_offset));
530 sprintf(length, "0x%x", (uint)len);
532 #ifdef CONFIG_USE_YAFFS
534 ret = nand_cmd(2, ramaddr, offset, length);
536 ret = nand_cmd(1, ramaddr, offset, length);
538 if (!strcmp("yaffs", getenv(parts[part_num]->name)))
539 fs_offset += len / YAFFS_PAGE * NAND_PAGE_SIZE;
545 ret = nand_cmd(1, ramaddr, offset, length);
551 /* Parsing received data packet and Process data */
552 static int process_data(struct usbd_ops *usbd)
554 ulong cmd = 0, arg = 0, len = 0, flag = 0;
555 char offset[12], length[12], ramaddr[12];
557 unsigned int blocks = 0;
563 sprintf(ramaddr, "0x%x", (uint) down_ram_addr);
566 cmd = *((ulong *) usbd->rx_data + 0);
567 arg = *((ulong *) usbd->rx_data + 1);
568 len = *((ulong *) usbd->rx_data + 2);
569 flag = *((ulong *) usbd->rx_data + 3);
571 /* Reset tx buffer */
572 memset(usbd->tx_data, 0, sizeof(usbd->tx_data));
574 ubi_mode = check_ubi_mode();
577 case COMMAND_DOWNLOAD_IMAGE:
578 printf("\nCOMMAND_DOWNLOAD_IMAGE\n");
580 #ifdef CONFIG_USE_YAFFS
581 usbd->recv_setup((char *)down_ram_addr + yaffs_len, (int)len);
582 printf("Download to 0x%08x, %d bytes\n",
583 (uint)down_ram_addr + yaffs_len, (int)len);
585 usbd->recv_setup((char *)down_ram_addr, (int)len);
586 printf("Download to 0x%08x, %d bytes\n",
587 (uint)down_ram_addr, (int)len);
590 usbd->send_data(usbd->tx_data, usbd->tx_len);
592 /* Receive image by using dma */
593 recvlen = usbd->recv_data();
595 printf("Error: wrong image size -> %d/%d\n",
596 (int)recvlen, (int)len);
598 /* Retry this commad */
599 *((ulong *) usbd->tx_data) = STATUS_RETRY;
601 *((ulong *) usbd->tx_data) = STATUS_DONE;
603 usbd->send_data(usbd->tx_data, usbd->tx_len);
606 /* Report partition info */
607 case COMMAND_PARTITION_SYNC:
610 #ifdef CONFIG_CMD_UBI
612 if (part_id == RAMDISK_PART_ID ||
613 part_id == FILESYSTEM_PART_ID ||
614 part_id == FILESYSTEM2_PART_ID) {
615 /* change to yaffs style */
619 if (part_id == FILESYSTEM3_PART_ID) {
620 /* change ubi style */
626 if (part_id == FILESYSTEM3_PART_ID)
627 part_id = get_part_id("UBI");
628 else if (part_id == MODEM_PART_ID)
629 part_id = get_part_id("modem");
634 printf("COMMAND_PARTITION_SYNC - Part%d\n", part_id);
636 blocks = parts[part_id]->size / 1024 / 128;
637 printf("COMMAND_PARTITION_SYNC - Part%d, %d blocks\n",
640 *((ulong *) usbd->tx_data) = blocks;
641 usbd->send_data(usbd->tx_data, usbd->tx_len);
644 case COMMAND_WRITE_PART_0:
646 printf("COMMAND_WRITE_PART_0\n");
649 case COMMAND_WRITE_PART_1:
650 printf("COMMAND_WRITE_PART_BOOT\n");
651 part_id = get_part_id("bootloader");
655 case COMMAND_WRITE_PART_2:
656 case COMMAND_ERASE_PARAMETER:
657 printf("COMMAND_PARAMETER - not support!\n");
660 case COMMAND_WRITE_PART_3:
661 printf("COMMAND_WRITE_KERNEL\n");
662 part_id = get_part_id("kernel");
663 img_type = IMG_KERNEL;
666 case COMMAND_WRITE_PART_4:
667 printf("COMMAND_WRITE_ROOTFS\n");
668 part_id = get_part_id("Root");
669 img_type = IMG_FILESYSTEM;
673 case COMMAND_WRITE_PART_5:
674 printf("COMMAND_WRITE_FACTORYFS\n");
675 part_id = get_part_id("Fact");
676 img_type = IMG_FILESYSTEM;
680 case COMMAND_WRITE_PART_6:
681 printf("COMMAND_WRITE_DATAFS\n");
682 part_id = get_part_id("Data");
683 img_type = IMG_FILESYSTEM;
687 case COMMAND_WRITE_PART_7:
688 printf("COMMAND_WRITE_UBI\n");
689 part_id = get_part_id("UBI");
690 img_type = IMG_FILESYSTEM;
692 /* someday, it will be deleted */
696 case COMMAND_WRITE_PART_8:
697 printf("COMMAND_WRITE_MODEM\n");
698 part_id = get_part_id("modem");
699 img_type = IMG_MODEM;
702 case COMMAND_WRITE_PART_9:
703 printf("COMMAND_WRITE_MMC\n");
705 mmc_part_write = arg;
708 case COMMAND_WRITE_UBI_INFO:
709 printf("COMMAND_WRITE_UBI_INFO\n");
712 #ifdef CONFIG_CMD_UBI
714 sprintf(length, "0x%x", (uint)len);
715 ret = ubi_cmd(part_id, ramaddr, length, "begin");
718 printf("Error: Not UBI mode\n");
722 *((ulong *) usbd->tx_data) = ret;
723 /* Write image success -> Report status */
724 usbd->send_data(usbd->tx_data, usbd->tx_len);
727 /* Download complete -> reset */
728 case COMMAND_RESET_PDA:
729 printf("\nDownload finished and Auto reset!\nWait........\n");
738 case COMMAND_RESET_USB:
739 printf("\nError is occured!(maybe previous step)->\
740 Turn off and restart!\n");
746 case COMMAND_RAM_BOOT:
751 case COMMAND_RAMDISK_MODE:
752 printf("COMMAND_RAMDISK_MODE\n");
753 #ifdef CONFIG_RAMDISK_ADDR
755 down_ram_addr = usbd->ram_addr;
757 down_ram_addr = CONFIG_RAMDISK_ADDR;
763 #ifdef CONFIG_DOWN_PHONE
764 case COMMAND_DOWN_PHONE:
765 printf("COMMAND_RESET_PHONE\n");
769 *((ulong *) usbd->tx_data) = STATUS_DONE;
770 usbd->send_data(usbd->tx_data, usbd->tx_len);
773 case COMMAND_CHANGE_USB:
774 printf("COMMAND_CHANGE_USB\n");
784 case COMMAND_CSA_CLEAR:
785 printf("COMMAND_CSA_CLEAR\n");
786 part_id = get_part_id("csa");
787 img_type = IMG_MODEM;
790 case COMMAND_PROGRESS:
791 if (usbd->set_progress)
792 usbd->set_progress(arg);
796 printf("Error: Unknown command -> (%d)\n", (int)cmd);
800 /* Erase and Write to NAND */
803 #ifdef CONFIG_S5PC1XX
804 /* Workaround: for prevent revision mismatch */
805 if (cpu_is_s5pc110() && (down_mode != MODE_FORCE)) {
807 long *img_header = (long *)down_ram_addr;
809 if (*img_header == 0xea000012)
812 if (img_rev != s5pc1xx_get_cpu_rev()) {
813 printf("CPU revision mismatch!\n");
814 *((ulong *) usbd->tx_data) = STATUS_ERROR;
815 usbd->send_data(usbd->tx_data, usbd->tx_len);
820 #if defined(CONFIG_ENV_IS_IN_NAND) || defined(CONFIG_ENV_IS_IN_ONENAND)
821 /* Erase the environment also when write bootloader */
824 param_id = get_part_id("params");
826 if (param_id == -1) {
827 sprintf(offset, "%x", CONFIG_ENV_OFFSET);
828 sprintf(length, "%x", CONFIG_ENV_SIZE);
830 sprintf(offset, "%x", parts[param_id]->offset);
831 sprintf(length, "%x", parts[param_id]->size);
833 nand_cmd(0, offset, length, NULL);
836 /* Fall through for write bootloader */
838 sprintf(offset, "%x", parts[part_id]->offset);
839 sprintf(length, "%x", parts[part_id]->size);
842 nand_cmd(0, offset, length, NULL);
844 sprintf(length, "%x", (unsigned int) len);
845 ret = nand_cmd(1, ramaddr, offset, length);
850 ret = write_file_system(ramaddr, len, offset, length,
851 part_id, ubi_update);
855 sprintf(offset, "%x", parts[part_id]->offset);
856 sprintf(length, "%x", parts[part_id]->size);
859 nand_cmd(0, offset, length, NULL);
861 /* Write : arg (0 Modem) / (1 CSA) */
863 sprintf(length, "%x", (unsigned int) len);
864 ret = nand_cmd(1, ramaddr, offset, length);
868 #ifdef CONFIG_CMD_MMC
871 ret = write_file_mmc_part(usbd, ramaddr,
872 len, offset, length);
874 ret = write_file_mmc(usbd, ramaddr,
875 len, offset, length);
885 /* Retry this commad */
886 *((ulong *) usbd->tx_data) = STATUS_RETRY;
887 usbd->send_data(usbd->tx_data, usbd->tx_len);
890 *((ulong *) usbd->tx_data) = STATUS_DONE;
892 /* Write image success -> Report status */
893 usbd->send_data(usbd->tx_data, usbd->tx_len);
897 /* Reset write count for another image */
901 #ifdef CONFIG_USE_YAFFS
909 static const char *recv_key = "SAMSUNG";
910 static const char *tx_key = "MPL";
912 int do_usbd_down(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
914 struct usbd_ops *usbd;
918 down_mode = simple_strtoul(argv[1], NULL, 10);
920 down_mode = MODE_NORMAL;
922 printf("USB Downloader v%s\n", APP_VERSION);
924 /* get partition info */
925 err = get_part_info();
929 /* interface setting */
930 usbd = usbd_set_interface(&usbd_ops);
931 down_ram_addr = usbd->ram_addr;
933 /* init the usb controller */
936 /* receive setting */
937 usbd->recv_setup(usbd->rx_data, usbd->rx_len);
939 /* detect the download request from Host PC */
940 if (usbd->recv_data()) {
941 if (strncmp(usbd->rx_data, recv_key, strlen(recv_key)) == 0) {
942 printf("Download request from the Host PC\n");
945 strcpy(usbd->tx_data, tx_key);
946 usbd->send_data(usbd->tx_data, usbd->tx_len);
948 printf("No download request from the Host PC!! 1\n");
952 printf("No download request from the Host PC!!\n");
956 printf("Receive the packet\n");
958 /* receive the data from Host PC */
960 usbd->recv_setup(usbd->rx_data, usbd->rx_len);
962 if (usbd->recv_data()) {
963 if (process_data(usbd) == 0)
971 U_BOOT_CMD(usbdown, CONFIG_SYS_MAXARGS, 1, do_usbd_down,
972 "Initialize USB device and Run USB Downloader (specific)",
974 "usbdown mode - specific mode (0: NORAML, 1: FORCE)\n"