7 typedef unsigned char u8;
8 typedef unsigned short u16;
9 typedef unsigned int u32;
10 #define array_size(x) (sizeof(x) / sizeof(x[0]))
13 unsigned short vendor;
14 unsigned short product;
17 { 0x03eb, 0x202a, "16MX+U Game Device" },
18 { 0x03eb, 0x202b, "32MX+U Game Device" },
19 { 0x03eb, 0x202c, "16MX+US Game Device" },
20 { 0x03eb, 0x202d, "32MX+UF Game Device" },
25 #define IO_BLK_SIZE 0x2000 /* 8K */
26 #define IO_RAM_BLK_SIZE 256
28 #define CMD_ATM_READY 0x22
29 #define CMD_SEC_GET_NAME 'G' /* filename r/w */
30 #define CMD_SEC_PUT_NAME 'P'
31 #define CMD_SEC_DEVID 'L' /* read flash device ID */
32 #define CMD_SEC_ERASE 'E'
33 #define CMD_SEC_READY 'C' /* is flash ready? */
34 #define CMD_SEC_READ 'R'
35 #define CMD_SEC_WRITE 'W'
36 #define CMD_SEC_RAM_READ 'D' /* not implemented? */
37 #define CMD_SEC_RAM_WRITE 'U'
38 #define CMD_SEC_COMPAT '$' /* set RAM mode */
41 #define CTL_DATA_BUS 0x55
42 #define CTL_ADDR_BUS 0xAA
44 #define W_COUNTER 0xA0
45 #define W_CNT_WRITE 0x01
46 #define W_CNT_READ 0x00
48 #define FILENAME_ROM0 0
49 #define FILENAME_ROM1 1
50 #define FILENAME_RAM 2
52 /* windows app sets to 0x80 on init
53 * checkboxes use 0x41 0x42 0x43 (?)
54 * r,w Ram/ROM uses 0x23/0x21
56 #define C_RAM_OFF 0x21 /* RAM always off */
57 #define C_RAM_SWITCH 0x22 /* RAM switched by game */
72 u8 addrb2; /* most significant (BE) */
75 u8 param; /* 64 byte usb packets for i/o */
109 static const page_table_t p_AM29LV320DB[] =
111 { 0x000000, 0x00ffff, 0x002000 },
112 { 0x010000, 0x3fffff, 0x010000 },
113 { 0x000000, 0x000000, 0x000000 },
116 static const page_table_t p_AM29LV320DT[] =
118 { 0x000000, 0x3effff, 0x010000 },
119 { 0x3f0000, 0x3fffff, 0x002000 },
120 { 0x000000, 0x000000, 0x000000 },
123 static const page_table_t p_2x_16[] =
125 { 0x000000, 0x003fff, 0x004000 },
126 { 0x004000, 0x007fff, 0x002000 },
127 { 0x008000, 0x00ffff, 0x008000 },
128 { 0x010000, 0x1fffff, 0x010000 },
129 { 0x200000, 0x203fff, 0x004000 },
130 { 0x204000, 0x207fff, 0x002000 },
131 { 0x208000, 0x20ffff, 0x008000 },
132 { 0x210000, 0x3fffff, 0x010000 },
133 { 0x000000, 0x000000, 0x000000 },
136 /*****************************************************************************/
138 static void prepare_cmd(dev_cmd_t *dev_cmd, u8 cmd)
140 memset(dev_cmd, 0, sizeof(*dev_cmd));
142 memcpy(dev_cmd->magic, "USBC", 4);
143 dev_cmd->magic2 = 0x67; /* MySCSICommand, EXCOMMAND */
144 dev_cmd->mx_cmd = cmd;
147 static int write_data(struct usb_dev_handle *dev, void *data, int len)
149 int ret = usb_bulk_write(dev, 0x03, data, len, 2000);
151 fprintf(stderr, "failed to write:\n");
152 fprintf(stderr, "%s (%d)\n", usb_strerror(), ret);
153 } else if (ret != len)
154 printf("write_cmd: wrote only %d of %d bytes\n", ret, len);
159 static int write_cmd(struct usb_dev_handle *dev, dev_cmd_t *cmd)
161 return write_data(dev, cmd, sizeof(*cmd));
164 static int read_data(struct usb_dev_handle *dev, void *buff, int size)
166 int ret = usb_bulk_read(dev, 0x82, buff, size, 2000);
168 fprintf(stderr, "failed to read:\n");
169 fprintf(stderr, "%s (%d)\n", usb_strerror(), ret);
172 else if (ret != size)
173 printf("read_data: read only %d of %d bytes\n", ret, size);
178 static int read_info(struct usb_dev_handle *device, u8 ctl_id, dev_info_t *info)
183 prepare_cmd(&cmd, CMD_ATM_READY);
184 cmd.dev_info.which_device = ctl_id;
185 memset(info, 0, sizeof(*info));
187 ret = write_cmd(device, &cmd);
191 ret = read_data(device, info, sizeof(*info));
198 static void printf_info(dev_info_t *info)
200 printf(" firmware version: %X.%X.%X%c\n", info->firmware_ver[0],
201 info->firmware_ver[1], info->firmware_ver[2], info->firmware_ver[3]);
202 printf(" bootloader version: %X.%X.%X%c\n", info->bootloader_ver[0],
203 info->bootloader_ver[1], info->bootloader_ver[2], info->bootloader_ver[3]);
204 info->names[sizeof(info->names) - 1] = 0;
205 printf(" device name: %s\n", info->names);
208 static void print_progress(u32 done, u32 total)
212 printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b");
213 printf("\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"); /* 20 */
214 printf("\b\b\b\b\b\b");
215 printf("%06x/%06x |", done, total);
218 for (i = step; i <= total; i += step)
219 printf("%c", done >= i ? '=' : '-');
220 printf("| %3d%%", done * 100 / total);
224 static int read_filename(struct usb_dev_handle *dev, char *dst, int len, u8 which)
230 prepare_cmd(&cmd, CMD_SEC_GET_NAME);
231 cmd.filename.which = which;
232 memset(buff, 0, sizeof(buff));
234 ret = write_cmd(dev, &cmd);
238 ret = read_data(dev, buff, 64);
242 strncpy(dst, buff, len);
248 static int write_filename(struct usb_dev_handle *dev, const char *fname, u8 which)
257 strncpy(buff, fname, len);
260 prepare_cmd(&cmd, CMD_SEC_PUT_NAME);
261 cmd.filename.which = which;
263 ret = write_cmd(dev, &cmd);
267 return write_data(dev, buff, len + 1);
270 static int read_erase_counter(struct usb_dev_handle *dev, u32 *val)
272 dev_info_t dummy_info;
277 /* must perform dummy info read here,
278 * or else device hangs after close (firmware bug?) */
279 ret = read_info(dev, CTL_DATA_BUS, &dummy_info);
283 prepare_cmd(&cmd, CMD_ATM_READY);
284 cmd.write_cnt.cmd = W_COUNTER;
285 cmd.write_cnt.action = W_CNT_READ;
287 ret = write_cmd(dev, &cmd);
291 ret = read_data(dev, buff, sizeof(buff));
299 static int read_flash_rom_id(struct usb_dev_handle *dev, int is_second, u32 *val)
305 prepare_cmd(&cmd, CMD_SEC_DEVID);
306 cmd.rom_id.which = is_second ? 0x10 : 0;
307 cmd.rom_id.dev_id = 0;
309 ret = write_cmd(dev, &cmd);
313 ret = read_data(dev, buff, sizeof(buff));
317 *val = *(u16 *)buff << 16;
319 cmd.rom_id.dev_id = 1;
320 ret = write_cmd(dev, &cmd);
324 ret = read_data(dev, buff, sizeof(buff));
328 *val |= *(u16 *)buff;
332 static const page_table_t *get_page_table(u32 rom_id)
336 return p_AM29LV320DB;
338 return p_AM29LV320DT;
343 fprintf(stderr, "unrecognized ROM id: %08x\n", rom_id);
349 static int get_page_size(const page_table_t *table, u32 addr, u32 *size)
351 const page_table_t *t;
353 for (t = table; t->end_addr != 0; t++) {
354 if (addr >= t->start_addr && addr <= t->end_addr) {
355 *size = t->page_size;
360 if (addr == t[-1].end_addr + 1)
361 return 1; /* no more */
363 fprintf(stderr, "get_page_size: failed on addr %06x\n", addr);
367 static int set_ram_mode(struct usb_dev_handle *dev, u8 mode)
373 prepare_cmd(&cmd, CMD_SEC_COMPAT);
375 cmd.mode.which = mode;
377 ret = write_cmd(dev, &cmd);
381 ret = read_data(dev, buff, sizeof(buff));
385 fprintf(stderr, "warning: failed to set RAM mode\n");
390 * - bytes must be multiple of 64
391 * - bytes must be less than 16k
392 * - must perform even number of reads, or dev hangs on exit (firmware bug?) */
393 static int rw_dev_block(struct usb_dev_handle *dev, u32 addr, void *buffer, int bytes, int mx_cmd)
398 prepare_cmd(&cmd, mx_cmd);
399 if (mx_cmd == CMD_SEC_WRITE || mx_cmd == CMD_SEC_RAM_WRITE)
401 cmd.rom_rw.addrb2 = addr >> (16 + 1);
402 cmd.rom_rw.addrb1 = addr >> (8 + 1);
403 cmd.rom_rw.addrb0 = addr >> 1;
404 cmd.rom_rw.param = bytes / 64;
405 if (mx_cmd == CMD_SEC_WRITE || mx_cmd == CMD_SEC_RAM_WRITE)
406 cmd.rom_rw.param2 = 1; /* ? */
408 ret = write_cmd(dev, &cmd);
414 if (mx_cmd == CMD_SEC_WRITE || mx_cmd == CMD_SEC_RAM_WRITE)
415 ret = write_data(dev, buffer, bytes);
417 ret = read_data(dev, buffer, bytes);
422 fprintf(stderr, "rw_dev_block warning: done only %d/%d bytes\n", ret, bytes);
427 static int read_write_rom(struct usb_dev_handle *dev, u32 addr, void *buffer, int bytes, int is_write)
429 int mx_cmd = is_write ? CMD_SEC_WRITE : CMD_SEC_READ;
430 int total_bytes = bytes;
436 fprintf(stderr, "read_write_rom: can't handle odd address %06x, "
437 "LSb will be ignored\n", addr);
439 fprintf(stderr, "read_write_rom: byte count must be multiple of 64, "
440 "last %d bytes will not be handled\n", bytes & 63);
442 set_ram_mode(dev, C_RAM_OFF);
444 printf("%s flash ROM...\n", is_write ? "writing to" : "reading");
446 /* do i/o in blocks */
447 for (count = 0; bytes >= IO_BLK_SIZE; count++) {
448 print_progress(buff - (u8 *)buffer, total_bytes);
450 ret = rw_dev_block(dev, addr, buff, IO_BLK_SIZE, mx_cmd);
455 bytes -= IO_BLK_SIZE;
457 print_progress(buff - (u8 *)buffer, total_bytes);
461 ret = rw_dev_block(dev, addr, buff, bytes, mx_cmd);
463 print_progress(total_bytes, total_bytes);
467 /* work around rw_dev_block() limitation 3 (works for reads only?) */
468 rw_dev_block(dev, 0, dummy, sizeof(dummy), 0);
474 static int read_write_ram(struct usb_dev_handle *dev, void *buffer, int bytes, int is_write)
476 int mx_cmd = is_write ? CMD_SEC_RAM_WRITE : CMD_SEC_READ;
477 int total_bytes = bytes;
482 if (bytes % IO_RAM_BLK_SIZE)
483 fprintf(stderr, "read_write_ram: byte count must be multiple of %d, "
484 "last %d bytes will not be handled\n", IO_RAM_BLK_SIZE,
485 bytes % IO_RAM_BLK_SIZE);
487 set_ram_mode(dev, C_RAM_ON);
489 printf("%s RAM...\n", is_write ? "writing to" : "reading");
491 /* do i/o in blocks */
492 while (bytes >= IO_RAM_BLK_SIZE) {
493 print_progress(buff - (u8 *)buffer, total_bytes);
495 ret = rw_dev_block(dev, addr, buff, IO_RAM_BLK_SIZE, mx_cmd);
498 buff += IO_RAM_BLK_SIZE;
499 addr += IO_RAM_BLK_SIZE;
500 bytes -= IO_RAM_BLK_SIZE;
502 print_progress(buff - (u8 *)buffer, total_bytes);
509 static int increment_erase_cnt(struct usb_dev_handle *dev)
516 ret = read_erase_counter(dev, &cnt);
520 if (cnt == (u32)-1) {
521 fprintf(stderr, "flash erase counter maxed out!\n");
522 fprintf(stderr, "(wow, did you really erase so many times?)\n");
528 prepare_cmd(&cmd, CMD_ATM_READY);
529 cmd.write_cnt.cmd = W_COUNTER;
530 cmd.write_cnt.action = W_CNT_WRITE;
531 cmd.write_cnt.b3 = cnt >> 24;
532 cmd.write_cnt.b2 = cnt >> 16;
533 cmd.write_cnt.b1 = cnt >> 8;
534 cmd.write_cnt.b0 = cnt;
536 ret = write_cmd(dev, &cmd);
540 ret = read_data(dev, buff, sizeof(buff));
547 static int erase_page(struct usb_dev_handle *dev, u32 addr, int whole)
553 prepare_cmd(&cmd, CMD_SEC_ERASE);
555 cmd.rom_rw.addrb2 = addr >> (16 + 1);
556 cmd.rom_rw.addrb1 = addr >> (8 + 1);
557 cmd.rom_rw.addrb0 = addr >> 1;
558 cmd.rom_rw.param = whole ? 0x10 : 0;
560 ret = write_cmd(dev, &cmd);
564 ret = read_data(dev, buff, sizeof(buff));
568 prepare_cmd(&cmd, CMD_SEC_READY);
569 cmd.rom_rw.addrb2 = addr >> (16 + 1);
570 cmd.rom_rw.addrb1 = addr >> (8 + 1);
571 cmd.rom_rw.addrb0 = addr >> 1;
573 for (i = 0; i < 100; i++) {
574 ret = write_cmd(dev, &cmd);
578 ret = read_data(dev, buff, sizeof(buff));
582 if (ret > 4 && buff[4] == 1)
585 usleep((whole ? 600 : 20) * 1000);
589 fprintf(stderr, "\ntimeout waiting for erase to complete\n");
596 static int erase_seq(struct usb_dev_handle *dev, u32 size)
598 const page_table_t *table;
599 u32 addr, page_size = 0;
600 u32 rom0_id, rom1_id;
603 ret = read_flash_rom_id(dev, 0, &rom0_id);
607 ret = read_flash_rom_id(dev, 1, &rom1_id);
611 if (rom0_id != rom1_id)
612 fprintf(stderr, "Warning: flash ROM ids differ: %08x %08x\n",
615 table = get_page_table(rom0_id);
619 printf("erasing flash...\n");
621 ret = increment_erase_cnt(dev);
623 fprintf(stderr, "warning: coun't increase erase counter\n");
625 for (addr = 0, count = 0; addr < size; addr += page_size, count++) {
626 print_progress(addr, size);
628 ret = erase_page(dev, addr, 0);
632 ret = get_page_size(table, addr, &page_size);
639 /* must submit even number of erase commands (fw bug?) */
640 erase_page(dev, 0, 0);
642 print_progress(addr, size);
648 static int erase_all(struct usb_dev_handle *dev, u32 size)
652 printf("erasing flash0...");
655 ret = increment_erase_cnt(dev);
657 fprintf(stderr, "warning: couldn't increase erase counter\n");
659 ret = erase_page(dev, 0xaaa, 1);
663 if (size > 0x200000) {
665 printf("erasing flash1...");
668 ret = erase_page(dev, 0x200aaa, 1);
675 static int print_device_info(struct usb_dev_handle *dev)
677 u32 counter, rom0_id, rom1_id;
681 printf("data bus controller:\n");
682 ret = read_info(dev, CTL_DATA_BUS, &info);
687 printf("address bus controller:\n");
688 ret = read_info(dev, CTL_ADDR_BUS, &info);
693 ret = read_erase_counter(dev, &counter);
696 printf("flash erase count: %u\n", counter);
698 ret = read_flash_rom_id(dev, 0, &rom0_id);
701 printf("flash rom0 id: %08x\n", rom0_id);
703 ret = read_flash_rom_id(dev, 1, &rom1_id);
706 printf("flash rom1 id: %08x\n", rom1_id);
711 static int print_game_info(struct usb_dev_handle *dev)
716 ret = read_filename(dev, fname, sizeof(fname), FILENAME_ROM0);
719 printf("ROM filename: %s\n", fname);
721 ret = read_filename(dev, fname, sizeof(fname), FILENAME_RAM);
724 printf("SRAM filename: %s\n", fname);
729 static int read_file(const char *fname, void **buff_out, int *size, int limit)
735 file = fopen(fname, "rb");
737 fprintf(stderr, "can't open file: %s\n", fname);
741 fseek(file, 0, SEEK_END);
742 file_size = ftell(file);
743 fseek(file, 0, SEEK_SET);
744 if (file_size > limit)
745 fprintf(stderr, "warning: input file \"%s\" too large\n", fname);
747 fprintf(stderr, "bad/empty file: %s\n", fname);
751 data = malloc(file_size);
753 fprintf(stderr, "low memory\n");
757 ret = fread(data, 1, file_size, file);
758 if (ret != file_size) {
759 fprintf(stderr, "failed to read file: %s", fname);
774 static int write_file(const char *fname, void *buff, int size)
779 file = fopen(fname, "wb");
781 fprintf(stderr, "can't open for writing: %s\n", fname);
785 ret = fwrite(buff, 1, size, file);
787 fprintf(stderr, "write failed to %s", fname);
790 printf("saved to %s.\n", fname);
796 static usb_dev_handle *get_device(void)
798 struct usb_dev_handle *handle;
799 struct usb_device *dev;
803 ret = usb_find_busses();
805 fprintf(stderr, "Can't find USB busses\n");
809 ret = usb_find_devices();
811 fprintf(stderr, "Can't find USB devices\n");
815 bus = usb_get_busses();
816 for (; bus; bus = bus->next)
818 for (dev = bus->devices; dev; dev = dev->next)
820 for (i = 0; i < array_size(g_devices); i++)
822 if (dev->descriptor.idVendor == g_devices[i].vendor &&
823 dev->descriptor.idProduct == g_devices[i].product)
829 fprintf(stderr, "device not found.\n");
833 printf("found %s.\n", g_devices[i].name);
835 handle = usb_open(dev);
836 if (handle == NULL) {
837 fprintf(stderr, "failed to open device:\n");
838 fprintf(stderr, "%s\n", usb_strerror());
842 ret = usb_set_configuration(handle, 1);
844 fprintf(stderr, "couldn't set configuration for /*/bus/usb/%s/%s:\n",
845 bus->dirname, dev->filename);
846 fprintf(stderr, "%s (%d)\n", usb_strerror(), ret);
850 ret = usb_claim_interface(handle, 0);
852 fprintf(stderr, "couldn't claim /*/bus/usb/%s/%s:\n",
853 bus->dirname, dev->filename);
854 fprintf(stderr, "%s (%d)\n", usb_strerror(), ret);
861 static void release_device(struct usb_dev_handle *device)
863 usb_release_interface(device, 0);
867 static void usage(const char *app_name)
869 printf("Flasher tool for MX game devices\n"
870 "written by Grazvydas \"notaz\" Ignotas\n");
871 printf("v" VERSION " (" __DATE__ ")\n\n");
873 "%s [-i] [-g] [-e] [-r [file]] [-w <file>] ...\n"
874 " -i print some info about connected device\n"
875 " -g print some info about game ROM inside device\n"
876 " -e[1] erase whole flash ROM in device, '1' uses different erase method\n"
877 " -f skip file check\n"
878 " -r [file] copy game image from device to file; can autodetect filename\n"
879 " -w <file> write file to device; also does erase\n"
880 " -sr [file] read save RAM to file\n"
881 " -sw <file> write save RAM file to device\n"
882 " -sc clear save RAM\n"
883 " -v with -w or -sw: verify written file\n",
887 int main(int argc, char *argv[])
889 char *r_fname = NULL, *w_fname = NULL, *sr_fname = NULL, *sw_fname = NULL;
890 void *r_fdata = NULL, *w_fdata = NULL, *sr_fdata = NULL, *sw_fdata = NULL;
891 int do_read_ram = 0, do_clear_ram = 0, do_verify = 0, do_check = 1;
892 int pr_dev_info = 0, pr_rom_info = 0, do_read = 0;
893 int erase_method = 0, do_erase_size = 0;
894 int w_fsize = 0, sw_fsize = 0;
895 struct usb_dev_handle *device;
899 for (i = 1; i < argc; i++)
901 if (argv[i][0] != '-')
904 switch (argv[i][1]) {
912 do_erase_size = 0x400000;
913 if (argv[i][2] == '1')
924 if (argv[i+1] && argv[i+1][0] != '-')
928 if (argv[i+1] && argv[i+1][0] != '-')
934 switch (argv[i][2]) {
937 if (argv[i+1] && argv[i+1][0] != '-')
938 sr_fname = argv[++i];
941 if (argv[i+1] && argv[i+1][0] != '-')
942 sw_fname = argv[++i];
959 if (i <= 1 || i < argc) {
965 if (w_fname != NULL) {
966 /* check extension */
967 ret = strlen(w_fname);
968 if (do_check && (w_fname[ret - 4] == '.' || w_fname[ret - 3] == '.' ||
969 w_fname[ret - 2] == '.') &&
970 strcasecmp(&w_fname[ret - 4], ".gen") != 0 &&
971 strcasecmp(&w_fname[ret - 4], ".bin") != 0) {
972 fprintf(stderr, "\"%s\" doesn't look like a game ROM, aborting "
973 "(use -f to disable this check)\n", w_fname);
977 ret = read_file(w_fname, &w_fdata, &w_fsize, 0x400000);
981 if (do_erase_size < w_fsize)
982 do_erase_size = w_fsize;
984 if (sw_fname != NULL) {
985 ret = read_file(sw_fname, &sw_fdata, &sw_fsize, 0x8000);
989 if (sw_fdata != NULL || do_clear_ram) {
990 if (sw_fsize < 0x8000) {
991 sw_fdata = realloc(sw_fdata, 0x8000);
992 if (sw_fdata == NULL) {
993 fprintf(stderr, "low mem\n");
996 memset((u8 *)sw_fdata + sw_fsize, 0, 0x8000 - sw_fsize);
1000 if (w_fname == NULL && sw_fname == NULL && do_verify) {
1001 fprintf(stderr, "warning: -w or -sw not specified, -v ignored.\n");
1008 device = get_device();
1014 ret = print_device_info(device);
1020 ret = print_game_info(device);
1026 if (do_erase_size != 0) {
1028 ret = erase_all(device, do_erase_size);
1030 ret = erase_seq(device, do_erase_size);
1036 if (w_fdata != NULL) {
1039 ret = read_write_rom(device, 0, w_fdata, w_fsize, 1);
1043 p = strrchr(w_fname, '/');
1044 p = (p == NULL) ? w_fname : p + 1;
1046 ret = write_filename(device, p, FILENAME_ROM0);
1048 fprintf(stderr, "warning: failed to save ROM filename\n");
1052 if (sw_fdata != NULL) {
1055 ret = read_write_ram(device, sw_fdata, sw_fsize, 1);
1059 memset(fname_buff, 0, sizeof(fname_buff));
1061 if (sw_fname != NULL) {
1062 p = strrchr(sw_fname, '/');
1063 p = (p == NULL) ? sw_fname : p + 1;
1064 } else if (w_fname != NULL) {
1065 t = strrchr(w_fname, '/');
1066 t = (t == NULL) ? w_fname : t + 1;
1068 strncpy(fname_buff, t, sizeof(fname_buff));
1069 fname_buff[sizeof(fname_buff) - 1] = 0;
1070 ret = strlen(fname_buff);
1071 if (ret > 4 && fname_buff[ret - 4] == '.')
1072 strcpy(&fname_buff[ret - 4], ".srm");
1075 ret = write_filename(device, p, FILENAME_RAM);
1077 fprintf(stderr, "warning: failed to save RAM filename\n");
1081 if (do_read && r_fname == NULL) {
1082 ret = read_filename(device, fname_buff, sizeof(fname_buff), FILENAME_ROM0);
1085 r_fname = fname_buff;
1086 if (r_fname[0] == 0)
1087 r_fname = "rom.gen";
1090 if (r_fname != NULL || do_verify) {
1091 r_fdata = malloc(0x400000);
1092 if (r_fdata == NULL) {
1093 fprintf(stderr, "low mem\n");
1097 ret = read_write_rom(device, 0, r_fdata, 0x400000, 0);
1102 if (r_fname != NULL)
1103 write_file(r_fname, r_fdata, 0x400000);
1106 if (do_read_ram && sr_fname == NULL) {
1107 ret = read_filename(device, fname_buff, sizeof(fname_buff), FILENAME_RAM);
1110 sr_fname = fname_buff;
1111 if (sr_fname[0] == 0)
1112 sr_fname = "rom.srm";
1115 if (sr_fname != NULL || do_verify) {
1116 sr_fdata = malloc(0x8000);
1117 if (sr_fdata == NULL) {
1118 fprintf(stderr, "low mem\n");
1122 ret = read_write_ram(device, sr_fdata, 0x8000, 0);
1127 if (sr_fname != NULL)
1128 write_file(sr_fname, sr_fdata, 0x8000);
1131 if (do_verify && w_fdata != NULL && r_fdata != NULL) {
1132 ret = memcmp(w_fdata, r_fdata, w_fsize);
1134 printf("flash verification passed.\n");
1136 printf("flash verification FAILED!\n");
1139 if (do_verify && sw_fdata != NULL && sr_fdata != NULL) {
1140 ret = memcmp(sw_fdata, sr_fdata, 0x8000);
1142 printf("RAM verification passed.\n");
1144 printf("RAM verification FAILED!\n");
1148 set_ram_mode(device, w_fsize > 0x200000 ? C_RAM_SWITCH : C_RAM_ON);
1150 printf("all done.\n");
1154 if (w_fdata != NULL)
1156 if (r_fdata != NULL)
1159 release_device(device);