
u-boot.elf:     file format elf32-littlearm
u-boot.elf
architecture: arm, flags 0x00000112:
EXEC_P, HAS_SYMS, D_PAGED
start address 0x03f00000

Program Header:
    LOAD off    0x00008000 vaddr 0x03f00000 paddr 0x03f00000 align 2**15
         filesz 0x0006a6a0 memsz 0x000a30cc flags rwx
private flags = 2: [APCS-32] [has entry point]

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         0001a6f0  03f00000  03f00000  00008000  2**5
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .glue_7       00000000  03f1a6f0  03f1a6f0  000226f0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  2 .glue_7t      00000000  03f1a6f0  03f1a6f0  000226f0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  3 .rodata       00005cfc  03f1a6f0  03f1a6f0  000226f0  2**2
                  CONTENTS, ALLOC, LOAD, READONLY, DATA
  4 .data         00049e04  03f203ec  03f203ec  000283ec  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  5 .u_boot_cmd   000004b0  03f6a1f0  03f6a1f0  000721f0  2**2
                  CONTENTS, ALLOC, LOAD, DATA
  6 .bss          00038a2c  03f6a6a0  03f6a6a0  000726a0  2**2
                  ALLOC
  7 .stab         00037a1c  00000000  00000000  000726a0  2**2
                  CONTENTS, READONLY, DEBUGGING
  8 .stabstr      00015c38  00000000  00000000  000aa0bc  2**0
                  CONTENTS, READONLY, DEBUGGING
  9 .comment      0000090d  00000000  00000000  000bfcf4  2**0
                  CONTENTS, READONLY
SYMBOL TABLE:
03f00000 l    d  .text	00000000 
03f1a6f0 l    d  .glue_7	00000000 
03f1a6f0 l    d  .glue_7t	00000000 
03f1a6f0 l    d  .rodata	00000000 
03f203ec l    d  .data	00000000 
03f6a1f0 l    d  .u_boot_cmd	00000000 
03f6a6a0 l    d  .bss	00000000 
00000000 l    d  .stab	00000000 
00000000 l    d  .stabstr	00000000 
00000000 l    d  .comment	00000000 
00000000 l    d  *ABS*	00000000 
00000000 l    d  *ABS*	00000000 
00000000 l    d  *ABS*	00000000 
00000000 l    df *ABS*	00000000 /src/1.0.1/svn.gp2x.com/gp2x/tag/bootloader/1.0.1/cpu/arm920t/start.S
00000000 l    df *ABS*	00000000 /src/1.0.1/svn.gp2x.com/gp2x/tag/bootloader/1.0.1/include/version.h
00000000 l    df *ABS*	00000000 /src/1.0.1/svn.gp2x.com/gp2x/tag/bootloader/1.0.1/cpu/arm920t/start.S
00000000 l    df *ABS*	00000000 /src/1.0.1/svn.gp2x.com/gp2x/tag/bootloader/1.0.1/include/config.h
00000000 l    df *ABS*	00000000 /src/1.0.1/svn.gp2x.com/gp2x/tag/bootloader/1.0.1/include/configs/mmsp2dtk.h
00000000 l    df *ABS*	00000000 /src/1.0.1/svn.gp2x.com/gp2x/tag/bootloader/1.0.1/include/cmd_confdefs.h
00000000 l    df *ABS*	00000000 /src/1.0.1/svn.gp2x.com/gp2x/tag/bootloader/1.0.1/include/configs/mmsp2dtk.h
00000000 l    df *ABS*	00000000 /src/1.0.1/svn.gp2x.com/gp2x/tag/bootloader/1.0.1/include/config.h
00000000 l    df *ABS*	00000000 /src/1.0.1/svn.gp2x.com/gp2x/tag/bootloader/1.0.1/cpu/arm920t/start.S
03f00078 l       .text	00000000 reset
03f00020 l       .text	00000000 _undefined_instruction
03f00024 l       .text	00000000 _software_interrupt
03f00028 l       .text	00000000 _prefetch_abort
03f0002c l       .text	00000000 _data_abort
03f00030 l       .text	00000000 _not_used
03f00034 l       .text	00000000 _irq
03f00038 l       .text	00000000 _fiq
03f001c0 l       .text	00000000 undefined_instruction
03f00220 l       .text	00000000 software_interrupt
03f00280 l       .text	00000000 prefetch_abort
03f002e0 l       .text	00000000 data_abort
03f00340 l       .text	00000000 not_used
03f003a0 l       .text	00000000 irq
03f00400 l       .text	00000000 fiq
03f00040 l       .text	00000000 _TEXT_BASE
03f00054 l       .text	00000000 NFDATA
03f00058 l       .text	00000000 NFCMD
03f0005c l       .text	00000000 NFADDR
03f00060 l       .text	00000000 MEMCFGW
03f00064 l       .text	00000000 MEMNANDCTRLW
03f00068 l       .text	00000000 MEMNANDTIMEW
03f0006c l       .text	00000000 BL_BASE
03f00070 l       .text	00000000 NAND_BASE
03f00074 l       .text	00000000 NAND_TOP
03f0016c l       .text	00000000 nand_relocate
03f000cc l       .text	00000000 read_command
03f00110 l       .text	00000000 wait_ready
03f0013c l       .text	00000000 get_page
03f00168 l       .text	00000000 _real_boot_loader
03f00184 l       .text	00000000 cpu_init_crit
03f00180 l       .text	00000000 _start_armboot
00000000 l    df *ABS*	00000000 interrupts.c
03f6a6a4 l       .bss	00000000 lastdec
03f6a6a0 l       .bss	00000000 timestamp
00000000 l    df *ABS*	00000000 board.c
03f203f0 l     O .data	00000004 mem_malloc_start
03f203f4 l     O .data	00000004 mem_malloc_end
03f203f8 l     O .data	00000004 mem_malloc_brk
03f009e4 l     F .text	00000048 mem_malloc_init
03f00a84 l     F .text	00000068 init_baudrate
03f00aec l     F .text	00000058 display_banner
03f00b44 l     F .text	00000068 display_dram_config
03f00bac l     F .text	00000030 display_flash_config
00000000 l    df *ABS*	00000000 net.c
03f01984 l     F .text	000000a0 net_check_prereq
03f6c584 l       .bss	00000000 timeHandler
03f6c588 l       .bss	00000000 timeStart
03f6c58c l       .bss	00000000 timeDelta
03f01284 l     F .text	00000020 startAgainTimeout
03f012a4 l     F .text	00000010 startAgainHandler
03f6c580 l       .bss	00000000 packetHandler
00000000 l    df *ABS*	00000000 tftp.c
03f01dd8 l     F .text	000001bc TftpSend
03f6cbe0 l       .bss	00000000 TftpState
03f6cbf4 l       .bss	00000000 tftp_filename
03f6cbd8 l       .bss	00000000 TftpBlock
03f6cbcc l       .bss	00000000 TftpServerPort
03f6cbd0 l       .bss	00000000 TftpOurPort
03f01f94 l     F .text	00000264 TftpHandler
03f6cbdc l       .bss	00000000 TftpLastBlock
03f021f8 l     F .text	00000064 TftpTimeout
03f6cbd4 l       .bss	00000000 TftpTimeoutCount
03f6cbe4 l       .bss	00000000 default_filename
00000000 l    df *ABS*	00000000 bootp.c
03f024c8 l     F .text	000000a4 BootpCheckPkt
03f0256c l     F .text	00000090 BootpCopyNetParams
03f025fc l     F .text	0000003c truncate_sz
03f02638 l     F .text	0000021c BootpVendorFieldProcess
03f02854 l     F .text	00000070 BootpVendorProcess
03f028c4 l     F .text	000000a4 BootpHandler
03f02968 l     F .text	00000050 BootpTimeout
03f029b8 l     F .text	00000084 BootpExtended
00000000 l    df *ABS*	00000000 rarp.c
03f02c38 l     F .text	00000014 RarpHandler
03f02c4c l     F .text	00000050 RarpTimeout
00000000 l    df *ABS*	00000000 cs8900.c
03f02da8 l     F .text	00000064 get_reg_init_bus
03f02e0c l     F .text	00000024 get_reg
03f02e30 l     F .text	0000002c put_reg
03f02e5c l     F .text	00000068 eth_reset
03f03348 l     F .text	00000024 cs8900_e2prom_ready
00000000 l    df *ABS*	00000000 main.c
03f204c8 l     O .data	00000004 erase_seq
03f204cc l     O .data	00000009 tab_seq
03f204dc l     O .data	00000100 lastcommand.45
03f03ab4 l     F .text	000000f8 delete_char
03f03bac l     F .text	000000a4 parse_line
03f03c50 l     F .text	000001bc process_macros
00000000 l    df *ABS*	00000000 cmd_autoscript.c
00000000 l    df *ABS*	00000000 cmd_bdinfo.c
03f043dc l     F .text	00000024 print_num
00000000 l    df *ABS*	00000000 cmd_boot.c
00000000 l    df *ABS*	00000000 cmd_bootm.c
03f04a54 l     F .text	00000130 do_bootm_netbsd
03f05380 l     F .text	00000038 do_bootm_rtems
03f053b8 l     F .text	00000060 do_bootm_vxworks
03f05418 l     F .text	00000060 do_bootm_qnxelf
03f04c20 l     F .text	0000014c image_info
03f04d6c l     F .text	00000014 do_imls
03f04f38 l     F .text	000002a4 print_type
03f051dc l     F .text	00000020 zalloc
03f051fc l     F .text	00000018 zfree
00000000 l    df *ABS*	00000000 cmd_cache.c
03f05598 l     F .text	0000004c on_off
00000000 l    df *ABS*	00000000 cmd_console.c
00000000 l    df *ABS*	00000000 cmd_date.c
03f057e4 l     F .text	00000064 cnvrt2
00000000 l    df *ABS*	00000000 cmd_elf.c
00000000 l    df *ABS*	00000000 cmd_fat.c
00000000 l    df *ABS*	00000000 cmd_flash.c
03f061f8 l     F .text	00000168 abbrev_spec
03f06360 l     F .text	0000001c flash_fill_sect_ranges
00000000 l    df *ABS*	00000000 cmd_load.c
03f205fc l     O .data	00000004 do_echo
03f06910 l     F .text	000001b8 load_serial
03f06ac8 l     F .text	000000e8 read_record
03f06d28 l     F .text	00000098 load_serial_bin
03f070dc l     F .text	00000044 set_kerm_bin_mode
03f07470 l     F .text	00000280 k_recv
03f6cd78 l       .bss	00000000 a_b
03f06f98 l     F .text	00000044 bin_data_init
03f6cd98 l       .bss	00000000 os_data_state
03f6cdac l       .bss	00000000 bin_start_address
03f6cda4 l       .bss	00000000 os_data_addr
03f06fdc l     F .text	00000058 os_data_save
03f6cd9c l       .bss	00000000 os_data_state_saved
03f6cda0 l       .bss	00000000 os_data_count_saved
03f6cda8 l       .bss	00000000 os_data_addr_saved
03f07034 l     F .text	00000058 os_data_restore
03f0708c l     F .text	00000050 bin_data_char
03f6cdb0 l       .bss	00000000 k_data_escape
03f6cdb4 l       .bss	00000000 k_data_escape_saved
00000000 l    df *ABS*	00000000 cmd_loadub.c
03f20600 l     O .data	00000004 loadub_first_flag
03f0770c l     F .text	000001e4 loadub_common
03f6cdd0 l       .bss	00000000 loadub_filename
00000000 l    df *ABS*	00000000 cmd_mem.c
03f20608 l     O .data	00000004 base_address
03f0838c l     F .text	000001a8 mod_mem
00000000 l    df *ABS*	00000000 cmd_misc.c
00000000 l    df *ABS*	00000000 cmd_mmc.c
00000000 l    df *ABS*	00000000 cmd_nand.c
03f2060c l     O .data	000001c8 nand_flash_ids
03f20848 l     O .data	00000004 curr_device
03f086a4 l     F .text	00000134 nand_write_page_yaffs
03f0b5b8 l     F .text	00000024 NanD_Command
03f0974c l     F .text	0000006c NanD_OnlyAddress
03f0969c l     F .text	00000040 NanD_WaitReady
03f087d8 l     F .text	00000228 nand_write_yaffs
03f095f0 l     F .text	000000ac nand_print
03f09340 l     F .text	00000068 nand_print_bad
03f0a47c l     F .text	00000128 nand_read_oob
03f0a5a4 l     F .text	00000244 nand_write_oob
03f093a8 l     F .text	00000248 nand_rw
03f0a9b0 l     F .text	00000200 nand_erase
03f09c48 l     F .text	00000398 nand_read_ecc
03f0a2a0 l     F .text	000001dc nand_write_ecc
03f096dc l     F .text	00000070 NanD_Address
03f097b8 l     F .text	00000240 NanD_IdentChip
03f099f8 l     F .text	00000184 NanD_ScanChips
03f09b7c l     F .text	000000cc NanD_ReadBuf
03f0adb8 l     F .text	000000a4 nand_calculate_ecc
03f0ae5c l     F .text	000001b8 nand_correct_data
03f09fe0 l     F .text	000002c0 nand_write_page
03f2084c l     O .data	0000000c clean_marker.141
03f1e505 l     O .rodata	00000100 nand_ecc_precalc_table
03f0acf8 l     F .text	000000c0 nand_trans_result
03f0b014 l     F .text	00000160 nand_read_without_ecc
03f0b174 l     F .text	000000bc nand_write_page_without_ecc
03f0b230 l     F .text	000001c8 nand_write_without_ecc
03f0b3f8 l     F .text	000000dc nand_rw_without_ecc
00000000 l    df *ABS*	00000000 cmd_net.c
03f0b798 l     F .text	00000194 netboot_common
03f0b630 l     F .text	00000168 netboot_update_env
00000000 l    df *ABS*	00000000 cmd_nvedit.c
03f1e7ec l     O .rodata	00000014 baudrate_table
03f0c1f0 l     F .text	0000007c envmatch
00000000 l    df *ABS*	00000000 command.c
00000000 l    df *ABS*	00000000 console.c
03f0c590 l     F .text	000000c0 console_setfile
03f20858 l     O .data	00000004 ctrlc_disabled
03f2085c l     O .data	00000004 ctrlc_was_pressed
00000000 l    df *ABS*	00000000 devices.c
03f0cbe4 l     F .text	0000007c drv_system_init
00000000 l    df *ABS*	00000000 dlmalloc.c
03f2087c l     O .data	00000408 av_
03f20c84 l     O .data	00000004 trim_threshold
03f20c88 l     O .data	00000004 top_pad
03f20c8c l     O .data	00000004 n_mmaps_max
03f20c90 l     O .data	00000004 mmap_threshold
03f20c94 l     O .data	00000004 sbrk_base
03f20c98 l     O .data	00000004 max_sbrked_mem
03f20c9c l     O .data	00000004 max_total_mem
03f20ca0 l     O .data	00000028 current_mallinfo
03f20cc8 l     O .data	00000004 mmapped_mem
03f0cd3c l     F .text	000001d4 malloc_extend_top
00000000 l    df *ABS*	00000000 env_common.c
03f0de48 l     F .text	00000034 env_get_char_init
00000000 l    df *ABS*	00000000 env_nand.c
00000000 l    df *ABS*	00000000 exports.c
03f0e07c l     F .text	00000010 dummy
00000000 l    df *ABS*	00000000 flash.c
00000000 l    df *ABS*	00000000 lists.c
03f0e630 l     F .text	000000cc ExpandListSpace
00000000 l    df *ABS*	00000000 s_record.c
03f0ecd0 l     F .text	00000040 hex2_bin
03f0ec84 l     F .text	0000004c hex1_bin
00000000 l    df *ABS*	00000000 cmd_brp.c
00000000 l    df *ABS*	00000000 crc32.c
03f1f1e8 l     O .rodata	00000400 crc_table
00000000 l    df *ABS*	00000000 display_options.c
00000000 l    df *ABS*	00000000 string.c
00000000 l    df *ABS*	00000000 vsprintf.c
03f0f838 l     F .text	00000054 skip_atoi
03f0f88c l     F .text	000002c0 number
00000000 l    df *ABS*	00000000 zlib.c
03f107a8 l     F .text	000000dc inflate_blocks_reset
03f11808 l     F .text	00000050 inflate_blocks_free
03f10884 l     F .text	000000a4 inflate_blocks_new
03f10928 l     F .text	00000ee0 inflate_blocks
03f11994 l     F .text	00000030 inflate_packet_flush
03f11858 l     F .text	0000013c inflate_addhistory
03f20dd0 l     O .data	00000044 inflate_mask
03f20e14 l     O .data	0000004c border
03f12d14 l     F .text	00000028 inflate_codes_free
03f123f4 l     F .text	00000048 inflate_trees_free
03f121b4 l     F .text	00000240 inflate_trees_fixed
03f1243c l     F .text	00000058 inflate_codes_new
03f12d3c l     F .text	00000190 inflate_flush
03f11fd0 l     F .text	0000007c inflate_trees_bits
03f1204c l     F .text	00000128 inflate_trees_dynamic
03f12494 l     F .text	00000880 inflate_codes
03f20e60 l     O .data	0000007c cplens
03f20edc l     O .data	0000007c cplext
03f20f58 l     O .data	00000078 cpdist
03f20fd0 l     O .data	00000078 cpdext
03f119c4 l     F .text	0000060c huft_build
03f21048 l     O .data	00000004 fixed_lock
03f2104c l     O .data	00000004 fixed_built
03f21050 l     O .data	00000004 fixed_left
03f12174 l     F .text	00000030 falloc
03f6ce64 l       .bss	00000000 fixed_mem
03f121a4 l     F .text	00000010 ffree
03f6def4 l       .bss	00000000 fixed_bl
03f6defc l       .bss	00000000 fixed_tl
03f6def8 l       .bss	00000000 fixed_bd
03f6df00 l       .bss	00000000 fixed_td
03f12ecc l     F .text	00000398 inflate_fast
00000000 l    df *ABS*	00000000 ctype.c
00000000 l    df *ABS*	00000000 libgcc1.S
03f13468 l       .text	00000000 Ldiv0
03f13460 l       .text	00000000 Lgot_result
03f133f8 l       .text	00000000 Loop1
03f1340c l       .text	00000000 Lbignum
03f13420 l       .text	00000000 Loop3
00000000 l    df *ABS*	00000000 libgcc1.S
03f1351c l       .text	00000000 Ldiv0
03f1348c l       .text	00000000 Loop1
03f134a0 l       .text	00000000 Lbignum
03f134b4 l       .text	00000000 Loop3
00000000 l    df *ABS*	00000000 libgcc1.S
00000000 l    df *ABS*	00000000 /usr/local/arm-dev/lib/gcc-lib/arm-linux/2.95.3/../../../../arm-linux/sys-include/asm/unistd.h
00000000 l    df *ABS*	00000000 libgcc1.S
00000000 l       *ABS*	00000000 *ABS*
00000000 l    df *ABS*	00000000 mmsp2dtk.c
00000000 l    df *ABS*	00000000 flash.c
03f13e90 l     F .text	0000013c write_hword
00000000 l    df *ABS*	00000000 sd.c
03f72f08 l       .bss	00000000 mmc_dev
00000000 l    df *ABS*	00000000 logo.c
00000000 l    df *ABS*	00000000 serial.c
00000000 l    df *ABS*	00000000 cpu.c
03f164d4 l     F .text	00000014 read_p15_c1
03f164e8 l     F .text	00000018 write_p15_c1
03f16500 l     F .text	00000034 cp_delay
00000000 l    df *ABS*	00000000 speed.c
03f1667c l     F .text	0000006c get_PLLCLK
00000000 l    df *ABS*	00000000 usb_device.c
03f1fd10 l     O .rodata	00000004 descStr0
03f1fd14 l     O .rodata	00000016 descStr1
03f1fd2a l     O .rodata	0000002c descStr2
03f6a120 l     O .data	00000082 descStr3
03f72fb0 l       .bss	00000000 ep0SubState.138
00000000 l    df *ABS*	00000000 armlinux.c
00000000 l    df *ABS*	00000000 cache.c
00000000 l    df *ABS*	00000000 fat.c
03f1829c l     F .text	00000038 downcase
03f6a1b4 l     O .data	00000004 cur_dev
03f6a1b8 l     O .data	00000004 part_offset
03f6a1bc l     O .data	00000004 cur_part
03f1846c l     F .text	00000044 dirdelim
03f184b0 l     F .text	00000044 compare_sign
03f184f4 l     F .text	000000d0 get_name
03f185c4 l     F .text	000001c0 get_fatent
03f18784 l     F .text	000000a0 get_cluster
03f18824 l     F .text	00000250 get_contents
03f18a74 l     F .text	000000c8 slot2str
03f18b3c l     F .text	0000019c get_vfatname
03f18cd8 l     F .text	00000040 mkcksum
03f18d18 l     F .text	000002ec get_dentfromdir
03f19004 l     F .text	000000fc read_bootsectandvi
03f19100 l     F .text	000006b4 do_fat_read
00000000 l    df *ABS*	00000000 part.c
03f19b98 l     F .text	000000bc print_part_header
00000000 l    df *ABS*	00000000 part_dos.c
03f19c9c l     F .text	000000c0 print_one_part
03f19d5c l     F .text	00000050 test_block_type
03f19e08 l     F .text	000001bc print_partition_extended
03f19fc4 l     F .text	000002e4 get_partition_info_extended
00000000 l    df *ABS*	00000000 date.c
03f6a1c0 l     O .data	00000030 month_days
00000000 l    df *ABS*	00000000 mmsp20_rtc.c
00000000 l    df *ABS*	00000000 libgcc1.S
03f1a6e0 l       .text	00000000 Ldiv0
03f1a6d0 l       .text	00000000 Lgot_result
03f1a668 l       .text	00000000 Loop1
03f1a67c l       .text	00000000 Lbignum
03f1a690 l       .text	00000000 Loop3
03f6ce54 g     O .bss	00000004 dp_last_size
03f6cc04 g     O .bss	00000100 console_buffer
03f0e254 g     F .text	00000198 flash_write
03f15234 g     F .text	0000004c DPC_UTIL_DATA_INV
03f04d80 g     F .text	000001b8 print_image_hdr
03f0f0c8 g     F .text	00000028 strcpy
03f0004c g       .text	00000000 _armboot_end
03f137e0 g     F .text	0000002c dram_init
03f0ca40 g     F .text	000001a4 console_init_r
03f14a78 g     F .text	00000154 SD_Read
03f16f48 g     F .text	00000138 Ep3Handler
03f01dc0 g     F .text	00000018 getenv_IPaddr
03f0f668 g     F .text	00000030 memscan
03f080e0 g     F .text	0000004c do_mem_base
03f6a1f0 g     O *ABS*	00000000 __u_boot_cmd_start
03f6a208 g     O .u_boot_cmd	00000018 __u_boot_cmd_bdinfo
03f730ac g     O .bss	00000008 descEndpt0
03f04b84 g     F .text	0000002c do_bootd
03f04400 g     F .text	00000090 do_go
03f6a310 g     O .u_boot_cmd	00000018 __u_boot_cmd_date
03f15f40 g     F .text	000001a8 MLC_Util_RGB
03f1aa0c g     O .rodata	00000026 version_string
03f055e4 g     F .text	000000e8 do_coninfo
03f01a24 g     F .text	00000030 NetCksumOk
03f6cbc8 g     O .bss	00000004 NetArpWaitTry
03f17e5c g     F .text	00000038 RdPktEp0
03f72fb4 g     O .bss	00000004 tempDownloadAddress
03f17f5c g     F .text	00000038 RdPktEp3
03f076f0 g     F .text	0000001c do_loadub
03f16564 g     F .text	00000030 cleanup_before_linux
03f6c598 g     O .bss	00000004 NetArpWaitPacketMAC
03f6a250 g     O .u_boot_cmd	00000018 __u_boot_cmd_bootm
03f0c844 g     F .text	00000034 printf
03f0e564 g     F .text	00000028 DisposeHandle
03f0fb4c g     F .text	000004f0 vsprintf
03f01300 g     F .text	0000004c NetSetTimeout
03f01c48 g     F .text	00000060 copy_filename
03f03e0c g     F .text	000001f0 run_command
03f72f04 g     O .bss	00000000 flash_info
03f17124 g     F .text	00000074 PrepareEp1Fifo
03f6a430 g     O .u_boot_cmd	00000018 __u_boot_cmd_md
03f07120 g     F .text	00000030 k_data_init
03f14bcc g     F .text	0000018c SD_Write
03f007fc g     F .text	0000001c set_timer
03f06e88 g     F .text	00000038 s1_sendpacket
03f6a6b0 g     O .bss	00000006 NetOurEther
03f0c980 g     F .text	000000a4 console_assign
03f6a6a0 g     O *ABS*	00000000 armboot_end_data
03f20604 g     O .data	00000004 dp_last_length
03f16618 g     F .text	00000024 dcache_enable
03f6df04 g     O .bss	00001000 scratch
03f07c1c g     F .text	000000e0 do_mem_mw
03f17bb0 g     F .text	0000001c PrintEp0Pkt
03f15d1c g     F .text	000000dc MLC_RGB_SetCoord
03f05214 g     F .text	0000016c gunzip
03f0f5bc g     F .text	00000068 memmove
03f6a6b8 g     O .bss	00000004 NetOurIP
03f0721c g     F .text	00000254 handle_send_packet
03f73038 g     O .bss	00000004 ep0State
03f0c294 g     F .text	00000088 do_echo
03f0e050 g     F .text	0000002c env_relocate_spec
03f16534 g     F .text	00000030 cpu_init
03f03ffc g     F .text	0000008c do_run
03f0e784 g     F .text	00000014 ListDispose
03f0e7b0 g     F .text	00000158 ListInsertItems
03f6a4a8 g     O .u_boot_cmd	00000018 __u_boot_cmd_cmp
03f6a550 g     O .u_boot_cmd	00000018 __u_boot_cmd_nand
03f0f808 g     F .text	00000030 simple_strtol
03f05a3c g     F .text	000000b0 do_bootelf
03f73058 g     O .bss	00000004 totalDmaCount
03f14df8 g     F .text	000000a4 DPC_SetHSyncParm
03f00db0 g     F .text	00000020 hang
03f146e8 g     F .text	00000390 SD_card_init
03f01ca8 g     F .text	00000064 ip_to_string
03f1a308 g     F .text	00000114 GregorianDay
03f72fb8 g     O .bss	00000040 ep3Buf
03f0c05c g     F .text	00000084 getenv
03f6a6bc g     O .bss	00000004 NetServerIP
03f00f14 g     F .text	0000008c ArpTimeoutCheck
03f030b4 g     F .text	00000028 eth_halt
03f73070 g     O .bss	00000001 endpoint1_status
03f16240 g     F .text	00000078 show_logo
03f72fac g     O .bss	00000004 MLC_REG
03f007b8 g     F .text	00000014 reset_timer
03f0637c g     F .text	00000044 do_flinfo
03f7303c g     O .bss	00000004 ep0SubState
03f014b4 g     F .text	000004d0 NetReceive
03f6a2e0 g     O .u_boot_cmd	00000018 __u_boot_cmd_dcache
03f6a6a8 g     O .bss	00000004 monitor_flash_len
03f1027c g     F .text	000003d4 inflate
03f6a298 g     O .u_boot_cmd	00000018 __u_boot_cmd_iminfo
03f1394c g     F .text	00000058 nand_init
03f0ed10 g     F .text	00000160 do_brp
03f73080 g     O .bss	00000014 descDev
03f6a280 g     O .u_boot_cmd	00000018 __u_boot_cmd_bootd
03f10184 g     F .text	000000e0 inflateInit2
03f08534 g     F .text	000000c0 do_mem_crc
03f6a478 g     O .u_boot_cmd	00000018 __u_boot_cmd_mw
03f0e764 g     F .text	00000020 ListSetAllocationPolicy
03f171fc g     F .text	00000020 PrintEpiPkt
03f6a4f0 g     O .u_boot_cmd	00000018 __u_boot_cmd_loop
03f07bf0 g     F .text	0000002c do_mem_nm
03f02c9c g     F .text	0000010c RarpRequest
03f17bcc g     F .text	00000150 InitDescriptorTable
03f05aec g     F .text	000001b0 do_bootvx
03f0c784 g     F .text	0000002c getc
03f0e9bc g     F .text	00000018 ListGetItemSize
03f1458c g     F .text	000000a0 Card_sel_desel
03f00704 g     F .text	0000002c do_fiq
03f0f588 g     F .text	00000034 memcpy
03f6ce60 g     O .bss	00000004 ___strtok
03f05e48 g     F .text	0000019c do_fat_fsload
03f16cd8 g     F .text	0000017c init_usb_regs
03f73060 g     O .bss	00000001 AlterSetting
03f0b614 g     F .text	0000001c do_rarpb
03f6c5a0 g     O .bss	00000004 NetArpWaitTxPacketSize
03f0e12c g     F .text	00000114 flash_protect
03f6c594 g     O .bss	00000004 NetArpWaitReplyIP
03f6a640 g     O .u_boot_cmd	00000018 __u_boot_cmd_echo
03f20dc8 g     O .data	00000004 env_name_spec
03f03890 g     F .text	00000224 readline
03f1828c g     F .text	00000010 flush_cache
03f6a6c0 g     O .bss	00000010 NetRxPackets
03f6c59c g     O .bss	00000004 NetArpWaitTxPacket
03f00048 g       .text	00000000 _armboot_end_data
03f1a2dc g     F .text	0000002c get_partition_info_dos
03f6a3a0 g     O .u_boot_cmd	00000018 __u_boot_cmd_flinfo
03f0c810 g     F .text	00000034 puts
03f6a1b0 g     O .data	00000001 Configuration
03f0c96c g     F .text	00000014 dbg
03f07bc4 g     F .text	0000002c do_mem_mm
03f13a70 g     F .text	0000003c usbd_en
03f08fec g     F .text	0000029c do_nandboot
03f0cf10 g     F .text	00000450 malloc
03f20430 g     O .data	00000020 NetOurNISDomain
03f204b8 g     O .data	00000006 NetBcastAddr
03f133e0 g     F .text	00000098 __udivsi3
03f1676c g     F .text	00000018 get_PCLK
03f0bb04 g     F .text	000004d4 _do_setenv
03f73068 g     O .bss	00000001 interface_status
03f169b0 g     F .text	00000108 usbd_recv
03f203fc g     O .data	00000028 init_sequence
03f0075c g     F .text	0000005c interrupt_init
03f17d1c g     F .text	00000014 ConfigUsbd
03f6a4d8 g     O .u_boot_cmd	00000018 __u_boot_cmd_base
03f0c650 g     F .text	00000034 serial_printf
03f7306c g     O .bss	00000001 endpoint0_status
03f1a610 g     F .text	00000010 rtc_set
03f13c58 g     F .text	00000238 flash_erase
03f6a268 g     O .u_boot_cmd	00000018 __u_boot_cmd_boot
03f05508 g     F .text	00000090 do_dcache
03f00628 g     F .text	0000002c do_undefined_instruction
03f6a670 g     O .u_boot_cmd	00000018 __u_boot_cmd_question_mark
03f203ec g     O .data	00000004 timer_load_val
03f6c590 g     O .bss	00000004 NetArpWaitPacketIP
03f01d0c g     F .text	0000008c string_to_ip
03f00bdc g     F .text	000001d4 start_armboot
03f004e8 g     F .text	00000140 show_regs
03f0717c g     F .text	0000002c k_data_restore
03f00730 g     F .text	0000002c do_irq
03f20ccc g     O .data	00000004 env_get_char
03f139f8 g     F .text	00000038 pullup_en
03f07eb0 g     F .text	00000230 do_mem_cp
03f6a388 g     O .u_boot_cmd	00000018 __u_boot_cmd_fatinfo
03f21180 g     O .data	00000004 CardBusWidth
03f0e024 g     F .text	0000002c saveenv
03f6a1b1 g     O .data	00000001 Selfpwr
03f1636c g     F .text	0000008c serial_setbrg
03f730cc g     O .bss	00010000 get_vfatname_block
03f6a2b0 g     O .u_boot_cmd	00000018 __u_boot_cmd_imls
03f0db50 g     F .text	00000028 pvalloc
03f730bc g     O .bss	00000004 ConfigSet
03f00050 g       .text	00000000 _armboot_real_end
03f14538 g     F .text	00000054 SetBus
03f009cc g     F .text	00000018 get_tbclk
03f03410 g     F .text	00000480 main_loop
03f0e9a4 g     F .text	00000018 ListGetDataPtr
03f170f4 g     F .text	00000030 ClearEp3OutPktReady
03f6a6dc g     O .bss	00000004 NetState
03f6cbfc g     O .bss	00000004 BootpTry
03f15df8 g     F .text	00000034 MLC_RGB_SetAddress
03f01360 g     F .text	00000154 NetSendUDPPacket
03f0a96c g     F .text	00000044 nand_erase_func
03f01d98 g     F .text	00000028 print_IPaddr
03f02ec4 g     F .text	000001f0 cs8900_get_enetaddr
03f0c6b4 g     F .text	00000030 ftstc
03f06f2c g     F .text	0000006c send_nack
03f205dc g     O .data	00000004 load_addr
03f06104 g     F .text	000000f4 do_fat_fsinfo
03f13b00 g     F .text	00000014 flash_init
03f15280 g     F .text	000005b0 DPC_InitHardware
03f6a6e0 g     O .bss	00000080 BootFile
03f06bb0 g     F .text	00000178 do_load_serial_bin
03f0df78 g     F .text	00000018 env_get_char_spec
03f0c0e0 g     F .text	000000dc getenv_r
03f204d8 g     O .data	00000004 g_filesize
03f08254 g     F .text	00000138 do_mem_mtest
03f6ce50 g     O .bss	00000004 dp_last_addr
03f730c0 g     O .bss	00000004 InterfaceGet
03f007cc g     F .text	00000030 get_timer
03f10650 g     F .text	00000034 inflateIncomp
03f6cd70 g     O .bss	00000001 his_pad_char
03f08674 g     F .text	00000030 do_mmc
03f20dcc g     O .data	00000004 env_ptr
03f01aac g     F .text	00000050 NetSetEther
03f14668 g     F .text	00000020 mmc_write
03f6a400 g     O .u_boot_cmd	00000018 __u_boot_cmd_loadb
03f17f24 g     F .text	00000038 WrPktEp2
03f6a5b0 g     O .u_boot_cmd	00000018 __u_boot_cmd_rarpboot
03f0b92c g     F .text	000001d8 do_printenv
03f6a598 g     O .u_boot_cmd	00000018 __u_boot_cmd_tftpboot
03f73064 g     O .bss	00000001 device_status
03f0f2f8 g     F .text	0000004c strnlen
03f204b2 g     O .data	00000006 NetServerEther
03f008a8 g     F .text	00000038 reset_timer_masked
03f0a8ac g     F .text	000000c0 nand_write_func
03f165b4 g     F .text	00000024 icache_enable
03f00044 g       .text	00000000 _armboot_start
03f6a610 g     O .u_boot_cmd	00000018 __u_boot_cmd_run
03f0e4fc g     F .text	00000068 NewHandle
03f17198 g     F .text	00000064 Ep1Handler
03f6a688 g     O .u_boot_cmd	00000018 __u_boot_cmd_brp
03f0e5a0 g     F .text	00000090 SetHandleSize
03f0f288 g     F .text	00000040 strrchr
03f0db78 g     F .text	000000dc calloc
03f15e2c g     F .text	00000038 MLC_RGB_SetColorKey
03f6a520 g     O .u_boot_cmd	00000018 __u_boot_cmd_sleep
03f6a448 g     O .u_boot_cmd	00000018 __u_boot_cmd_mm
03f6cd44 g     O .bss	00000004 os_data_count
03f0dd48 g     F .text	00000050 malloc_usable_size
03f14d7c g     F .text	00000040 PMR_SetDispClk
03f6a628 g     O .u_boot_cmd	00000018 __u_boot_cmd_version
03f1513c g     F .text	000000f8 DPC_UTIL_HVSYNC_GPX320240
03f0e798 g     F .text	00000018 ListInsertItem
03f16594 g     F .text	00000020 do_reset
03f001ac g       .text	00000000 setup_async
03f6cc00 g     O .bss	00000004 RarpTry
03f13b14 g     F .text	00000144 flash_print_info
03f07cfc g     F .text	000001b4 do_mem_cmp
03f6ce5c g     O .bss	00000004 mm_last_size
03f6cd90 g     O .bss	00000004 os_data_init
03f6a5f8 g     O .u_boot_cmd	00000018 __u_boot_cmd_saveenv
03f0c748 g     F .text	0000003c fprintf
03f1a620 g     F .text	00000020 rtc_reset
03f0c7b0 g     F .text	0000002c tstc
03f17f94 g     F .text	00000038 RdPktEp4
03f20424 g     O .data	00000004 NetOurSubnetMask
03f204b0 g     O .data	00000002 NetBootFileSize
03f21054 g     O .data	00000004 zlib_version
03f20cd0 g     O .data	00000000 default_environment
03f13264 g     F .text	0000017c adler32
03f0f124 g     F .text	00000040 strcat
03f0a7e8 g     F .text	000000c4 nand_write_jffs2_func
03f13478 g     F .text	000000b4 __umodsi3
03f6a2f8 g     O .u_boot_cmd	00000018 __u_boot_cmd_coninfo
03f0c878 g     F .text	00000034 vprintf
03f0e58c g     F .text	00000014 GetHandleSize
03f6ce58 g     O .bss	00000004 mm_last_addr
03f15878 g     F .text	00000308 MLC_RGB_MixMux
03f73094 g     O .bss	0000000c descConf
03f142f8 g     F .text	00000060 Chk_BUSYend
03f06530 g     F .text	00000080 flash_sect_erase
03f146a8 g     F .text	00000018 mmc_init
03f0deac g     F .text	00000034 env_get_addr
03f2117c g     O .data	00000004 CardSize
03f6a3e8 g     O .u_boot_cmd	00000018 __u_boot_cmd_loads
03f00fa0 g     F .text	000002e4 NetLoop
03f73048 g     O .bss	00000004 downloadAddress
03f6a1f0 g     O .u_boot_cmd	00000018 __u_boot_cmd_autoscr
03f16480 g     F .text	00000020 serial_tstc
03f6a6d8 g     O .bss	00000004 NetIPID
03f0c4e8 g     F .text	000000a8 find_cmd
03f21184 g     O .data	00000004 mmc_init_once
03f065b0 g     F .text	000001d0 do_protect
03f04490 g     F .text	000005c4 do_bootm
03f6a1a8 g     O .data	00000004 download_run
03f05c9c g     F .text	0000005c valid_elf_image
03f15c08 g     F .text	00000114 MLC_RGB_SetActivate
03f14430 g     F .text	0000007c Chk_MMC_OCR
03f6a2c8 g     O .u_boot_cmd	00000018 __u_boot_cmd_icache
03f0f704 g     F .text	00000040 memchr
03f071a8 g     F .text	00000074 k_data_char
03f72fa8 g     O .bss	00000004 pGPIO_REG
03f0ee70 g     F .text	00000104 crc32
03f004c4 g     F .text	00000024 bad_mode
03fa30cc g     O *ABS*	00000000 armboot_end
03f6a4c0 g     O .u_boot_cmd	00000018 __u_boot_cmd_crc32
03f008e0 g     F .text	0000007c get_timer_masked
03f00dd0 g     F .text	00000144 ArpRequest
03f6a580 g     O .u_boot_cmd	00000018 __u_boot_cmd_bootp
03f72fa0 g     O .bss	00000004 pPMR_REG
03f13a30 g     F .text	00000040 pullup_dis
03f1a560 g     F .text	000000a0 mktime
03f00000 g       .text	00000000 _start
03f19938 g     F .text	00000040 file_fat_read
03f6cdcc g     O .bss	00000004 send_ptr
03f0f698 g     F .text	0000006c strstr
03f1a2a8 g     F .text	00000034 print_part_dos
03f73040 g     O .bss	00000004 cmd_offset
03f16444 g     F .text	0000003c serial_putc
03f162b8 g     F .text	000000b4 show_Firmware
03f085f4 g     F .text	00000080 do_sleep
03f063c0 g     F .text	00000170 do_flerase
03f0f1f4 g     F .text	00000054 strncmp
03f0ef74 g     F .text	00000028 display_options
03f20450 g     O .data	00000020 NetOurHostName
03f6a568 g     O .u_boot_cmd	00000018 __u_boot_cmd_nboot
03f19978 g     F .text	000001cc dev_print
03f06780 g     F .text	000000a4 flash_sect_protect
03f205e0 g     O .data	0000001c weekdays
03f6a6a0 g     O *ABS*	00000000 __u_boot_cmd_end
03f0f0f0 g     F .text	00000034 strncpy
03f00818 g     F .text	00000090 udelay
03f0bfd8 g     F .text	00000040 setenv
03f0c8ac g     F .text	00000060 ctrlc
03f0b530 g     F .text	00000088 nand_env_write
03f19dac g     F .text	0000005c test_part_dos
03f1685c g     F .text	00000154 show_MMSP2_CLK
03f15f0c g     F .text	00000034 MLC_RGBOn
03f6cbf8 g     O .bss	00000004 BootpID
03f0d58c g     F .text	00000484 realloc
03f078f0 g     F .text	00000080 cmd_get_data_size
03f0095c g     F .text	00000054 udelay_masked
03f1005c g     F .text	0000004c panic
03f73044 g     O .bss	00000001 Rwuen
03f6a6d0 g     O .bss	00000004 NetRxPkt
03f0dee0 g     F .text	00000098 env_relocate
03f6a3b8 g     O .u_boot_cmd	00000018 __u_boot_cmd_erase
03f0f550 g     F .text	00000038 bcopy
03f0b4d4 g     F .text	0000005c nand_env_read
03f0f458 g     F .text	00000088 strtok
03f100a8 g     F .text	00000068 inflateReset
03f0f624 g     F .text	00000044 memcmp
03f0dc68 g     F .text	000000e0 malloc_trim
03f73050 g     O .bss	00000004 downloadFileSize
03f00460 g       .text	00000000 reset_cpu
03f166e8 g     F .text	00000034 get_FCLK
03f19918 g     F .text	00000020 file_fat_ls
03f6a418 g     O .u_boot_cmd	00000018 __u_boot_cmd_loadub
03f0f164 g     F .text	00000054 strncat
03f6cd48 g     O .bss	00000020 os_data_header
03f0ef9c g     F .text	000000a4 print_size
03f13548 g     F .text	00000298 board_init
03f10684 g     F .text	00000124 inflateSync
03f14298 g     F .text	00000060 Chk_DATend
03f042a0 g     F .text	00000048 do_autoscript
03f20428 g     O .data	00000004 NetOurGatewayIP
03f21078 g     O .data	00000100 _ctype
03f6a460 g     O .u_boot_cmd	00000018 __u_boot_cmd_nm
03f0cc60 g     F .text	0000002c device_register
03f6a5c8 g     O .u_boot_cmd	00000018 __u_boot_cmd_printenv
03f00a2c g     F .text	00000058 sbrk
03f0f344 g     F .text	00000048 strdup
03f17fcc g     F .text	000002c0 do_bootm_linux
03f204be g     O .data	00000006 NetEtherNullAddr
03f73074 g     O .bss	00000001 endpoint3_status
03f14160 g     F .text	00000018 mmc_get_dev
03f0ccfc g     F .text	00000040 malloc_bin_reloc
03f16ab8 g     F .text	00000220 WaitDownload
03f01a54 g     F .text	00000058 NetCksum
03f150c0 g     F .text	0000007c DPC_UTIL_HVSYNC
03f0de10 g     F .text	00000038 env_crc_update
03f0f520 g     F .text	00000030 memset
03f72f68 g     O .bss	00000004 isMMC
03f6a1ac g     O .data	00000004 err
03f01afc g     F .text	0000014c NetSetIP
03f042e8 g     F .text	000000f4 do_bdinfo
03f0812c g     F .text	00000128 do_mem_loop
03f14f4c g     F .text	00000174 DPC_SetDEParm
03f17080 g     F .text	00000020 PrintEpoPkt
03f1352c g     F .text	0000001c __div0
03f0e9d4 g     F .text	00000018 ListNumItems
03f06e44 g     F .text	00000044 chk1
03f72f9c g     O .bss	00000004 Rx_buffer1
03f20860 g     O .data	00000004 devlist
03f730b4 g     O .bss	00000008 descEndpt1
03f0dd98 g     F .text	00000078 mallopt
03f144ac g     F .text	0000008c Chk_SD_OCR
03f6cd94 g     O .bss	00000004 os_data_char
03f05fe4 g     F .text	00000120 do_fat_ls
03f0336c g     F .text	00000040 cs8900_e2prom_read
03f167e4 g     F .text	00000078 get_UART1_CLK
03f59588 g     O .data	00010b96 imgFirmware
03f20864 g     O .data	0000000c stdio_devices
03f16e54 g     F .text	0000002c InitUsbd
03f0df90 g     F .text	00000094 env_init
03f1380c g     F .text	0000011c SD_FS
03f0c7dc g     F .text	00000034 putc
03f1a640 g     F .text	000000b0 __divsi3
03f15854 g     F .text	00000024 MLC_Initialize
03f730c4 g     O .bss	00000008 StatusGet
03f00680 g     F .text	0000002c do_prefetch_abort
03f17e94 g     F .text	00000038 WrPktEp0
03f146c0 g     F .text	00000028 mmc2info
03f0f1b8 g     F .text	0000003c strcmp
03f19c54 g     F .text	00000048 print_part
03f163f8 g     F .text	00000020 serial_init
03f21058 g     O .data	00000020 z_errmsg
03f13aec g     F .text	00000014 display_Firmware
03f6a238 g     O .u_boot_cmd	00000018 __u_boot_cmd_reset
03f0c90c g     F .text	00000024 disable_ctrlc
03f165d8 g     F .text	00000024 icache_disable
03f05e10 g     F .text	00000038 get_dev
03f6c5a4 g     O .bss	00000620 NetArpWaitPacketBuf
03f033ac g     F .text	00000064 cs8900_e2prom_write
03f14390 g     F .text	00000050 CMD55
03f15b80 g     F .text	00000088 MLC_RGB_SetScale
03f09288 g     F .text	000000b8 check_block
03f0abb0 g     F .text	00000148 nand_probe
03f0c684 g     F .text	00000030 fgetc
03f0da10 g     F .text	00000124 memalign
03f1003c g     F .text	00000020 sprintf
03f170a0 g     F .text	00000054 RdPktEp3_CheckSum
03f07150 g     F .text	0000002c k_data_save
03f13928 g     F .text	00000024 board_late_init
03f17eec g     F .text	00000038 WrPktEp1
03f031b4 g     F .text	0000009c eth_rx
03f17d30 g     F .text	0000012c ReconfigUsbd
03f0b5f8 g     F .text	0000001c do_tftpb
03f20870 g     O .data	0000000c stdio_names
03f07970 g     F .text	00000254 do_mem_md
03f72ff8 g     O .bss	00000040 ep1Buf
03f0c1bc g     F .text	00000034 do_saveenv
03f164a0 g     F .text	00000034 serial_puts
03f04088 g     F .text	00000218 autoscript
03f0e960 g     F .text	00000044 ListGetPtrToItem
03f0e6fc g     F .text	00000068 ListCreate
03f0f4e0 g     F .text	00000040 strsep
03f0dc54 g     F .text	00000014 cfree
03f0c930 g     F .text	0000001c had_ctrlc
03f009b0 g     F .text	0000001c get_ticks
03f1462c g     F .text	0000003c mmc_bread
03f0c31c g     F .text	000001cc do_help
03f004b0 g     F .text	00000014 disable_interrupts
03f0c018 g     F .text	00000044 do_setenv
03f6a3d0 g     O .u_boot_cmd	00000018 __u_boot_cmd_protect
03f14178 g     F .text	00000120 Chk_CMDend
03f6cd68 g     O .bss	00000001 his_eol
03f0db34 g     F .text	0000001c valloc
03f6cd04 g     O .bss	00000040 header
03f6a6d4 g     O .bss	00000004 NetRxPktLen
03f006d8 g     F .text	0000002c do_not_used
03f05478 g     F .text	00000090 do_icache
03f0f040 g     F .text	00000088 strnicmp
03f0c6e4 g     F .text	00000034 fputc
03f0e0a0 g     F .text	0000008c jumptable_init
03f204c4 g     O .data	00000004 NetTxPacket
03f207f4 g     O .data	00000054 nand_dev_desc
03f012b4 g     F .text	00000030 NetStartAgain
03f0ccd8 g     F .text	00000024 devices_done
03f06e0c g     F .text	00000038 ktrans
03f6a358 g     O .u_boot_cmd	00000018 __u_boot_cmd_fatload
03f14688 g     F .text	00000020 mmc_read
03f0cc8c g     F .text	0000004c devices_init
03f207d4 g     O .data	00000020 oob_config
03f0f744 g     F .text	000000c4 simple_strtoul
03f6a538 g     O .u_boot_cmd	00000018 __u_boot_cmd_mmcinit
03f0e240 g     F .text	00000014 addr2info
03f0ca24 g     F .text	0000001c console_init_f
03f006ac g     F .text	0000002c do_data_abort
03f830cc g     O .bss	00010000 get_dentfromdir_block
03f6cd74 g     O .bss	00000001 his_quote
03f6a6ac g     O .bss	00000004 NetBootFileXferSize
03f6a370 g     O .u_boot_cmd	00000018 __u_boot_cmd_fatls
03f16754 g     F .text	00000018 get_BCLK
03f012e4 g     F .text	0000001c NetSetHandler
03f73054 g     O .bss	00000002 checkSum
03f030dc g     F .text	000000d8 eth_init
03f06dc0 g     F .text	0000004c send_pad
03f16660 g     F .text	0000001c dcache_status
03f0c94c g     F .text	00000020 clear_ctrlc
03f056cc g     F .text	00000118 do_date
03f2042c g     O .data	00000004 NetOurDNSIP
03f16784 g     F .text	00000030 get_UCLK
03f0e3ec g     F .text	00000110 flash_perror
03f6a508 g     O .u_boot_cmd	00000018 __u_boot_cmd_mtest
03f00654 g     F .text	0000002c do_software_interrupt
03f0b5dc g     F .text	0000001c do_bootp
03f0e9ec g     F .text	00000298 srec_decode
03f21178 g     O .data	00000004 RCA
03f14d58 g     F .text	00000024 PMR_Initialize
03f16418 g     F .text	0000002c serial_getc
03f21188 g     O .data	00038400 gp2xlogo
03f6a340 g     O .u_boot_cmd	00000018 __u_boot_cmd_bootvx
03f160e8 g     F .text	00000158 init_lcd
03f16e80 g     F .text	000000c8 IsrUsbd
03f0e08c g     F .text	00000014 get_version
03f14358 g     F .text	00000038 CMD0
03f0de7c g     F .text	00000030 env_get_char_memory
03f1671c g     F .text	00000038 get_DCLK
03f05cf8 g     F .text	00000118 load_elf_image
03f17ecc g     F .text	00000020 WrByteEp0
03f930cc g     O .bss	00010000 do_fat_read_block
03f6a220 g     O .u_boot_cmd	00000018 __u_boot_cmd_go
03f13ad8 g     F .text	00000014 display_logo
03f05848 g     F .text	000001f4 mk_date
03f0c26c g     F .text	00000028 do_version
03f6a490 g     O .u_boot_cmd	00000018 __u_boot_cmd_cp
03f139a4 g     F .text	00000054 ChangeUPllValue
03f0f38c g     F .text	00000078 strspn
03f0134c g     F .text	00000014 NetSendPacket
03f730a0 g     O .bss	0000000c descIf
03f14dbc g     F .text	0000003c DPC_SetFrameSize
03f197b4 g     F .text	00000164 file_fat_detectfs
03f6ef04 g     O .bss	00004000 scratch1
03f0f2c8 g     F .text	00000030 strlen
03f182d4 g     F .text	00000064 disk_read
03f14e9c g     F .text	000000b0 DPC_SetVSyncParm
03f6a760 g     O .bss	00001e20 PktBuf
03f10264 g     F .text	00000018 inflateInit
03f6cdb8 g     O .bss	00000014 send_parms
03f1a41c g     F .text	00000144 to_tm
03f6a658 g     O .u_boot_cmd	00000018 __u_boot_cmd_help
03f02a3c g     F .text	000001fc BootpRequest
03f143e0 g     F .text	00000050 CMD9
03f19b68 g     F .text	00000030 get_partition_info
03f7305c g     O .bss	00000004 isUsbdSetConfiguration
03f08a00 g     F .text	000005ec do_nand
03f0f248 g     F .text	00000040 strchr
03f06ec0 g     F .text	0000006c send_ack
03f004a0 g     F .text	00000010 enable_interrupts
03f7304c g     O .bss	00000004 downPt
03f73078 g     O .bss	00000008 descSetup
03f18338 g     F .text	00000134 fat_register_device
03f0c718 g     F .text	00000030 fputs
03f165fc g     F .text	0000001c icache_status
03f10110 g     F .text	00000074 inflateEnd
03f13aac g     F .text	0000002c usbd_dis
03f15e64 g     F .text	000000a8 MLC_RGB_SetBPP
03f03250 g     F .text	000000f8 eth_send
03f20470 g     O .data	00000040 NetOurRootPath
03f72fa4 g     O .bss	00000004 DPC
03f6cd6c g     O .bss	00000004 his_pad_count
03f1663c g     F .text	00000024 dcache_disable
03f0225c g     F .text	0000026c TftpStart
03f0e908 g     F .text	00000058 ListGetItems
03f1a600 g     F .text	00000010 rtc_get
03f6a5e0 g     O .u_boot_cmd	00000018 __u_boot_cmd_setenv
03f72f6c g     O .bss	00000030 csd
03f167b4 g     F .text	00000030 get_ACLK
03f15830 g     F .text	00000024 DPC_Initialize
03f6a328 g     O .u_boot_cmd	00000018 __u_boot_cmd_bootelf
03f06824 g     F .text	000000ec do_load_serial
03f19b44 g     F .text	00000024 init_part
03f04bb0 g     F .text	00000070 do_iminfo
03f0f404 g     F .text	00000054 strpbrk
03f6a1a4 g     O .data	00000004 transferIndex
03f13fcc g     F .text	00000194 write_buff
03f1721c g     F .text	00000994 Ep0Handler
03f0d360 g     F .text	0000022c free
03f6cbc4 g     O .bss	00000004 NetArpWaitTimerStart


Disassembly of section .text:

03f00000 <_start>:
 3f00000:	ea00001c 	b	3f00078 <reset>
 3f00004:	e59ff014 	ldr	r15, [pc, #14]	; 3f00020 <_undefined_instruction>
 3f00008:	e59ff014 	ldr	r15, [pc, #14]	; 3f00024 <_software_interrupt>
 3f0000c:	e59ff014 	ldr	r15, [pc, #14]	; 3f00028 <_prefetch_abort>
 3f00010:	e59ff014 	ldr	r15, [pc, #14]	; 3f0002c <_data_abort>
 3f00014:	e59ff014 	ldr	r15, [pc, #14]	; 3f00030 <_not_used>
 3f00018:	e59ff014 	ldr	r15, [pc, #14]	; 3f00034 <_irq>
 3f0001c:	e59ff014 	ldr	r15, [pc, #14]	; 3f00038 <_fiq>

03f00020 <_undefined_instruction>:
 3f00020:	03f001c0 	mvneqs	r0, #48	; 0x30

03f00024 <_software_interrupt>:
 3f00024:	03f00220 	mvneqs	r0, #2	; 0x2

03f00028 <_prefetch_abort>:
 3f00028:	03f00280 	mvneqs	r0, #8	; 0x8

03f0002c <_data_abort>:
 3f0002c:	03f002e0 	mvneqs	r0, #14	; 0xe

03f00030 <_not_used>:
 3f00030:	03f00340 	mvneqs	r0, #1	; 0x1

03f00034 <_irq>:
 3f00034:	03f003a0 	mvneqs	r0, #-2147483646	; 0x80000002

03f00038 <_fiq>:
 3f00038:	03f00400 	mvneqs	r0, #0	; 0x0
 3f0003c:	deadbeef 	cdple	14, 10, cr11, cr13, cr15, {7}

03f00040 <_TEXT_BASE>:
 3f00040:	03f00000 	mvneqs	r0, #0	; 0x0

03f00044 <_armboot_start>:
 3f00044:	03f00000 	mvneqs	r0, #0	; 0x0

03f00048 <_armboot_end_data>:
 3f00048:	03f6a6a0 	mvneqs	r10, #167772160	; 0xa000000

03f0004c <_armboot_end>:
 3f0004c:	03fa30cc 	mvneqs	r3, #204	; 0xcc

03f00050 <_armboot_real_end>:
 3f00050:	0badc0de 	bleq	2a703d0 <*ABS*+0x2a703d0>

03f00054 <NFDATA>:
 3f00054:	9c000000 	stcls	0, cr0, [r0]

03f00058 <NFCMD>:
 3f00058:	9c000010 	stcls	0, cr0, [r0], -#64

03f0005c <NFADDR>:
 3f0005c:	9c000018 	stcls	0, cr0, [r0], -#96

03f00060 <MEMCFGW>:
 3f00060:	c0003a00 	andgt	r3, r0, r0, lsl #20

03f00064 <MEMNANDCTRLW>:
 3f00064:	c0003a3a 	andgt	r3, r0, r10, lsr r10

03f00068 <MEMNANDTIMEW>:
 3f00068:	c0003a3c 	andgt	r3, r0, r12, lsr r10

03f0006c <BL_BASE>:
 3f0006c:	03f00000 	mvneqs	r0, #0	; 0x0

03f00070 <NAND_BASE>:
 3f00070:	00000000 	andeq	r0, r0, r0

03f00074 <NAND_TOP>:
 3f00074:	00080000 	andeq	r0, r8, r0

03f00078 <reset>:
 3f00078:	e10f0000 	mrs	r0, CPSR
 3f0007c:	e3c0001f 	bic	r0, r0, #31	; 0x1f
 3f00080:	e38000d3 	orr	r0, r0, #211	; 0xd3
 3f00084:	e129f000 	msr	CPSR_fc, r0
 3f00088:	e59f03f0 	ldr	r0, [pc, #3f0]	; 3f00480 <reset_cpu+0x20>
 3f0008c:	e3a01000 	mov	r1, #0	; 0x0
 3f00090:	e5801000 	str	r1, [r0]
 3f00094:	e3e01000 	mvn	r1, #0	; 0x0
 3f00098:	e59f03e4 	ldr	r0, [pc, #3e4]	; 3f00484 <reset_cpu+0x24>
 3f0009c:	e5801000 	str	r1, [r0]
 3f000a0:	ea000031 	b	3f0016c <nand_relocate>
 3f000a4:	e51f1044 	ldr	r1, [pc, #ffffffbc]	; 3f00068 <MEMNANDTIMEW>
 3f000a8:	e2000000 	and	r0, r0, #0	; 0x0
 3f000ac:	e2800c07 	add	r0, r0, #1792	; 0x700
 3f000b0:	e28000f0 	add	r0, r0, #240	; 0xf0
 3f000b4:	e2800008 	add	r0, r0, #8	; 0x8
 3f000b8:	e1c100b0 	strh	r0, [r1]
 3f000bc:	e51f1064 	ldr	r1, [pc, #ffffff9c]	; 3f00060 <MEMCFGW>
 3f000c0:	e51f505c 	ldr	r5, [pc, #ffffffa4]	; 3f0006c <BL_BASE>
 3f000c4:	e51f605c 	ldr	r6, [pc, #ffffffa4]	; 3f00070 <NAND_BASE>
 3f000c8:	e51f905c 	ldr	r9, [pc, #ffffffa4]	; 3f00074 <NAND_TOP>

03f000cc <read_command>:
 3f000cc:	e51f1070 	ldr	r1, [pc, #ffffff90]	; 3f00064 <MEMNANDCTRLW>
 3f000d0:	e1d100b0 	ldrh	r0, [r1]
 3f000d4:	e3800080 	orr	r0, r0, #128	; 0x80
 3f000d8:	e3800902 	orr	r0, r0, #32768	; 0x8000
 3f000dc:	e1c100b0 	strh	r0, [r1]
 3f000e0:	e51f1090 	ldr	r1, [pc, #ffffff70]	; 3f00058 <NFCMD>
 3f000e4:	e3a00000 	mov	r0, #0	; 0x0
 3f000e8:	e5c10000 	strb	r0, [r1]
 3f000ec:	e51f1098 	ldr	r1, [pc, #ffffff68]	; 3f0005c <NFADDR>
 3f000f0:	e1a00006 	mov	r0, r6
 3f000f4:	e5c10000 	strb	r0, [r1]
 3f000f8:	e1a004a6 	mov	r0, r6, lsr #9
 3f000fc:	e5c10000 	strb	r0, [r1]
 3f00100:	e1a008a6 	mov	r0, r6, lsr #17
 3f00104:	e5c10000 	strb	r0, [r1]
 3f00108:	e1a00ca6 	mov	r0, r6, lsr #25
 3f0010c:	e5c10000 	strb	r0, [r1]

03f00110 <wait_ready>:
 3f00110:	e51f10b4 	ldr	r1, [pc, #ffffff4c]	; 3f00064 <MEMNANDCTRLW>
 3f00114:	e1d100b0 	ldrh	r0, [r1]
 3f00118:	e2000902 	and	r0, r0, #32768	; 0x8000
 3f0011c:	e3500902 	cmp	r0, #32768	; 0x8000
 3f00120:	1afffffa 	bne	3f00110 <wait_ready>
 3f00124:	e2022000 	and	r2, r2, #0	; 0x0
 3f00128:	e2422080 	sub	r2, r2, #128	; 0x80
 3f0012c:	e2422001 	sub	r2, r2, #1	; 0x1
 3f00130:	e0000002 	and	r0, r0, r2
 3f00134:	e1c100b0 	strh	r0, [r1]
 3f00138:	e2088000 	and	r8, r8, #0	; 0x0

03f0013c <get_page>:
 3f0013c:	e51f10f0 	ldr	r1, [pc, #ffffff10]	; 3f00054 <NFDATA>
 3f00140:	e5910000 	ldr	r0, [r1]
 3f00144:	e5850000 	str	r0, [r5]
 3f00148:	e2888004 	add	r8, r8, #4	; 0x4
 3f0014c:	e2855004 	add	r5, r5, #4	; 0x4
 3f00150:	e3580c02 	cmp	r8, #512	; 0x200
 3f00154:	1afffff8 	bne	3f0013c <get_page>
 3f00158:	e2866c02 	add	r6, r6, #512	; 0x200
 3f0015c:	e1560009 	cmp	r6, r9
 3f00160:	daffffd9 	ble	3f000cc <read_command>
 3f00164:	e51ff004 	ldr	r15, [pc, #fffffffc]	; 3f00168 <_real_boot_loader>

03f00168 <_real_boot_loader>:
 3f00168:	03f0016c 	mvneqs	r0, #27	; 0x1b

03f0016c <nand_relocate>:
 3f0016c:	eb000004 	bl	3f00184 <cpu_init_crit>
 3f00170:	e51f012c 	ldr	r0, [pc, #fffffed4]	; 3f0004c <_armboot_end>
 3f00174:	e2800802 	add	r0, r0, #131072	; 0x20000
 3f00178:	e240d00c 	sub	r13, r0, #12	; 0xc
 3f0017c:	e51ff004 	ldr	r15, [pc, #fffffffc]	; 3f00180 <_start_armboot>

03f00180 <_start_armboot>:
 3f00180:	03f00bdc 	mvneqs	r0, #225280	; 0x37000

03f00184 <cpu_init_crit>:
 3f00184:	e3a00000 	mov	r0, #0	; 0x0
 3f00188:	ee070f17 	mcr	15, 0, r0, cr7, cr7, {0}
 3f0018c:	ee080f17 	mcr	15, 0, r0, cr8, cr7, {0}
 3f00190:	ee110f10 	mrc	15, 0, r0, cr1, cr0, {0}
 3f00194:	e3c00c23 	bic	r0, r0, #8960	; 0x2300
 3f00198:	e3c00087 	bic	r0, r0, #135	; 0x87
 3f0019c:	e3800002 	orr	r0, r0, #2	; 0x2
 3f001a0:	e3800a01 	orr	r0, r0, #4096	; 0x1000
 3f001a4:	ee010f10 	mcr	15, 0, r0, cr1, cr0, {0}
 3f001a8:	e1a0f00e 	mov	r15, r14

03f001ac <setup_async>:
 3f001ac:	ee111f10 	mrc	15, 0, r1, cr1, cr0, {0}
 3f001b0:	e3811103 	orr	r1, r1, #-1073741824	; 0xc0000000
 3f001b4:	e3811078 	orr	r1, r1, #120	; 0x78
 3f001b8:	ee011f10 	mcr	15, 0, r1, cr1, cr0, {0}
 3f001bc:	e1a0f00e 	mov	r15, r14

03f001c0 <undefined_instruction>:
 3f001c0:	e51fd17c 	ldr	r13, [pc, #fffffe84]	; 3f0004c <_armboot_end>
 3f001c4:	e28dd802 	add	r13, r13, #131072	; 0x20000
 3f001c8:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f001cc:	e58de000 	str	r14, [r13]
 3f001d0:	e14fe000 	mrs	r14, SPSR
 3f001d4:	e58de004 	str	r14, [r13, #4]
 3f001d8:	e3a0d013 	mov	r13, #19	; 0x13
 3f001dc:	e169f00d 	msr	SPSR_fc, r13
 3f001e0:	e1a0e00f 	mov	r14, r15
 3f001e4:	e1b0f00e 	movs	r15, r14
 3f001e8:	e24dd048 	sub	r13, r13, #72	; 0x48
 3f001ec:	e88d1fff 	stmia	r13, {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12}
 3f001f0:	e51f21ac 	ldr	r2, [pc, #fffffe54]	; 3f0004c <_armboot_end>
 3f001f4:	e2822802 	add	r2, r2, #131072	; 0x20000
 3f001f8:	e2422008 	sub	r2, r2, #8	; 0x8
 3f001fc:	e892000c 	ldmia	r2, {r2, r3}
 3f00200:	e28d0048 	add	r0, r13, #72	; 0x48
 3f00204:	e28d5034 	add	r5, r13, #52	; 0x34
 3f00208:	e1a0100e 	mov	r1, r14
 3f0020c:	e885000f 	stmia	r5, {r0, r1, r2, r3}
 3f00210:	e1a0000d 	mov	r0, r13
 3f00214:	eb000103 	bl	3f00628 <do_undefined_instruction>
	...

03f00220 <software_interrupt>:
 3f00220:	e51fd1dc 	ldr	r13, [pc, #fffffe24]	; 3f0004c <_armboot_end>
 3f00224:	e28dd802 	add	r13, r13, #131072	; 0x20000
 3f00228:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f0022c:	e58de000 	str	r14, [r13]
 3f00230:	e14fe000 	mrs	r14, SPSR
 3f00234:	e58de004 	str	r14, [r13, #4]
 3f00238:	e3a0d013 	mov	r13, #19	; 0x13
 3f0023c:	e169f00d 	msr	SPSR_fc, r13
 3f00240:	e1a0e00f 	mov	r14, r15
 3f00244:	e1b0f00e 	movs	r15, r14
 3f00248:	e24dd048 	sub	r13, r13, #72	; 0x48
 3f0024c:	e88d1fff 	stmia	r13, {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12}
 3f00250:	e51f220c 	ldr	r2, [pc, #fffffdf4]	; 3f0004c <_armboot_end>
 3f00254:	e2822802 	add	r2, r2, #131072	; 0x20000
 3f00258:	e2422008 	sub	r2, r2, #8	; 0x8
 3f0025c:	e892000c 	ldmia	r2, {r2, r3}
 3f00260:	e28d0048 	add	r0, r13, #72	; 0x48
 3f00264:	e28d5034 	add	r5, r13, #52	; 0x34
 3f00268:	e1a0100e 	mov	r1, r14
 3f0026c:	e885000f 	stmia	r5, {r0, r1, r2, r3}
 3f00270:	e1a0000d 	mov	r0, r13
 3f00274:	eb0000f6 	bl	3f00654 <do_software_interrupt>
	...

03f00280 <prefetch_abort>:
 3f00280:	e51fd23c 	ldr	r13, [pc, #fffffdc4]	; 3f0004c <_armboot_end>
 3f00284:	e28dd802 	add	r13, r13, #131072	; 0x20000
 3f00288:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f0028c:	e58de000 	str	r14, [r13]
 3f00290:	e14fe000 	mrs	r14, SPSR
 3f00294:	e58de004 	str	r14, [r13, #4]
 3f00298:	e3a0d013 	mov	r13, #19	; 0x13
 3f0029c:	e169f00d 	msr	SPSR_fc, r13
 3f002a0:	e1a0e00f 	mov	r14, r15
 3f002a4:	e1b0f00e 	movs	r15, r14
 3f002a8:	e24dd048 	sub	r13, r13, #72	; 0x48
 3f002ac:	e88d1fff 	stmia	r13, {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12}
 3f002b0:	e51f226c 	ldr	r2, [pc, #fffffd94]	; 3f0004c <_armboot_end>
 3f002b4:	e2822802 	add	r2, r2, #131072	; 0x20000
 3f002b8:	e2422008 	sub	r2, r2, #8	; 0x8
 3f002bc:	e892000c 	ldmia	r2, {r2, r3}
 3f002c0:	e28d0048 	add	r0, r13, #72	; 0x48
 3f002c4:	e28d5034 	add	r5, r13, #52	; 0x34
 3f002c8:	e1a0100e 	mov	r1, r14
 3f002cc:	e885000f 	stmia	r5, {r0, r1, r2, r3}
 3f002d0:	e1a0000d 	mov	r0, r13
 3f002d4:	eb0000e9 	bl	3f00680 <do_prefetch_abort>
	...

03f002e0 <data_abort>:
 3f002e0:	e51fd29c 	ldr	r13, [pc, #fffffd64]	; 3f0004c <_armboot_end>
 3f002e4:	e28dd802 	add	r13, r13, #131072	; 0x20000
 3f002e8:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f002ec:	e58de000 	str	r14, [r13]
 3f002f0:	e14fe000 	mrs	r14, SPSR
 3f002f4:	e58de004 	str	r14, [r13, #4]
 3f002f8:	e3a0d013 	mov	r13, #19	; 0x13
 3f002fc:	e169f00d 	msr	SPSR_fc, r13
 3f00300:	e1a0e00f 	mov	r14, r15
 3f00304:	e1b0f00e 	movs	r15, r14
 3f00308:	e24dd048 	sub	r13, r13, #72	; 0x48
 3f0030c:	e88d1fff 	stmia	r13, {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12}
 3f00310:	e51f22cc 	ldr	r2, [pc, #fffffd34]	; 3f0004c <_armboot_end>
 3f00314:	e2822802 	add	r2, r2, #131072	; 0x20000
 3f00318:	e2422008 	sub	r2, r2, #8	; 0x8
 3f0031c:	e892000c 	ldmia	r2, {r2, r3}
 3f00320:	e28d0048 	add	r0, r13, #72	; 0x48
 3f00324:	e28d5034 	add	r5, r13, #52	; 0x34
 3f00328:	e1a0100e 	mov	r1, r14
 3f0032c:	e885000f 	stmia	r5, {r0, r1, r2, r3}
 3f00330:	e1a0000d 	mov	r0, r13
 3f00334:	eb0000dc 	bl	3f006ac <do_data_abort>
	...

03f00340 <not_used>:
 3f00340:	e51fd2fc 	ldr	r13, [pc, #fffffd04]	; 3f0004c <_armboot_end>
 3f00344:	e28dd802 	add	r13, r13, #131072	; 0x20000
 3f00348:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f0034c:	e58de000 	str	r14, [r13]
 3f00350:	e14fe000 	mrs	r14, SPSR
 3f00354:	e58de004 	str	r14, [r13, #4]
 3f00358:	e3a0d013 	mov	r13, #19	; 0x13
 3f0035c:	e169f00d 	msr	SPSR_fc, r13
 3f00360:	e1a0e00f 	mov	r14, r15
 3f00364:	e1b0f00e 	movs	r15, r14
 3f00368:	e24dd048 	sub	r13, r13, #72	; 0x48
 3f0036c:	e88d1fff 	stmia	r13, {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12}
 3f00370:	e51f232c 	ldr	r2, [pc, #fffffcd4]	; 3f0004c <_armboot_end>
 3f00374:	e2822802 	add	r2, r2, #131072	; 0x20000
 3f00378:	e2422008 	sub	r2, r2, #8	; 0x8
 3f0037c:	e892000c 	ldmia	r2, {r2, r3}
 3f00380:	e28d0048 	add	r0, r13, #72	; 0x48
 3f00384:	e28d5034 	add	r5, r13, #52	; 0x34
 3f00388:	e1a0100e 	mov	r1, r14
 3f0038c:	e885000f 	stmia	r5, {r0, r1, r2, r3}
 3f00390:	e1a0000d 	mov	r0, r13
 3f00394:	eb0000cf 	bl	3f006d8 <do_not_used>
	...

03f003a0 <irq>:
 3f003a0:	e51fd35c 	ldr	r13, [pc, #fffffca4]	; 3f0004c <_armboot_end>
 3f003a4:	e28dd802 	add	r13, r13, #131072	; 0x20000
 3f003a8:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f003ac:	e58de000 	str	r14, [r13]
 3f003b0:	e14fe000 	mrs	r14, SPSR
 3f003b4:	e58de004 	str	r14, [r13, #4]
 3f003b8:	e3a0d013 	mov	r13, #19	; 0x13
 3f003bc:	e169f00d 	msr	SPSR_fc, r13
 3f003c0:	e1a0e00f 	mov	r14, r15
 3f003c4:	e1b0f00e 	movs	r15, r14
 3f003c8:	e24dd048 	sub	r13, r13, #72	; 0x48
 3f003cc:	e88d1fff 	stmia	r13, {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12}
 3f003d0:	e51f238c 	ldr	r2, [pc, #fffffc74]	; 3f0004c <_armboot_end>
 3f003d4:	e2822802 	add	r2, r2, #131072	; 0x20000
 3f003d8:	e2422008 	sub	r2, r2, #8	; 0x8
 3f003dc:	e892000c 	ldmia	r2, {r2, r3}
 3f003e0:	e28d0048 	add	r0, r13, #72	; 0x48
 3f003e4:	e28d5034 	add	r5, r13, #52	; 0x34
 3f003e8:	e1a0100e 	mov	r1, r14
 3f003ec:	e885000f 	stmia	r5, {r0, r1, r2, r3}
 3f003f0:	e1a0000d 	mov	r0, r13
 3f003f4:	eb0000cd 	bl	3f00730 <do_irq>
	...

03f00400 <fiq>:
 3f00400:	e51fd3bc 	ldr	r13, [pc, #fffffc44]	; 3f0004c <_armboot_end>
 3f00404:	e28dd802 	add	r13, r13, #131072	; 0x20000
 3f00408:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f0040c:	e58de000 	str	r14, [r13]
 3f00410:	e14fe000 	mrs	r14, SPSR
 3f00414:	e58de004 	str	r14, [r13, #4]
 3f00418:	e3a0d013 	mov	r13, #19	; 0x13
 3f0041c:	e169f00d 	msr	SPSR_fc, r13
 3f00420:	e1a0e00f 	mov	r14, r15
 3f00424:	e1b0f00e 	movs	r15, r14
 3f00428:	e24dd048 	sub	r13, r13, #72	; 0x48
 3f0042c:	e88d1fff 	stmia	r13, {r0, r1, r2, r3, r4, r5, r6, r7, r8, r9, r10, r11, r12}
 3f00430:	e51f23ec 	ldr	r2, [pc, #fffffc14]	; 3f0004c <_armboot_end>
 3f00434:	e2822802 	add	r2, r2, #131072	; 0x20000
 3f00438:	e2422008 	sub	r2, r2, #8	; 0x8
 3f0043c:	e892000c 	ldmia	r2, {r2, r3}
 3f00440:	e28d0048 	add	r0, r13, #72	; 0x48
 3f00444:	e28d5034 	add	r5, r13, #52	; 0x34
 3f00448:	e1a0100e 	mov	r1, r14
 3f0044c:	e885000f 	stmia	r5, {r0, r1, r2, r3}
 3f00450:	e1a0000d 	mov	r0, r13
 3f00454:	eb0000aa 	bl	3f00704 <do_fiq>
	...

03f00460 <reset_cpu>:
 3f00460:	e3a0c000 	mov	r12, #0	; 0x0
 3f00464:	ee07cf17 	mcr	15, 0, r12, cr7, cr7, {0}
 3f00468:	ee08cf17 	mcr	15, 0, r12, cr8, cr7, {0}
 3f0046c:	ee11cf10 	mrc	15, 0, r12, cr1, cr0, {0}
 3f00470:	e3ccc00f 	bic	r12, r12, #15	; 0xf
 3f00474:	e3cccc21 	bic	r12, r12, #8448	; 0x2100
 3f00478:	ee01cf10 	mcr	15, 0, r12, cr1, cr0, {0}
 3f0047c:	e1a0f000 	mov	r15, r0
 3f00480:	c0000a14 	andgt	r0, r0, r4, lsl r10
 3f00484:	c0000808 	andgt	r0, r0, r8, lsl #16
 3f00488:	e1a00000 	nop			(mov r0,r0)
 3f0048c:	e1a00000 	nop			(mov r0,r0)
 3f00490:	e1a00000 	nop			(mov r0,r0)
 3f00494:	e1a00000 	nop			(mov r0,r0)
 3f00498:	e1a00000 	nop			(mov r0,r0)
 3f0049c:	e1a00000 	nop			(mov r0,r0)

03f004a0 <enable_interrupts>:
 3f004a0:	e1a0c00d 	mov	r12, r13
 3f004a4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f004a8:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f004ac:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f004b0 <disable_interrupts>:
 3f004b0:	e1a0c00d 	mov	r12, r13
 3f004b4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f004b8:	e24cb004 	sub	r11, r12, #4	; 0x4
	return;
}
int disable_interrupts (void)
{
	return 0;
 3f004bc:	e3a00000 	mov	r0, #0	; 0x0
 3f004c0:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f004c4 <bad_mode>:
 3f004c4:	e1a0c00d 	mov	r12, r13
 3f004c8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}
#endif


void bad_mode (void)
{
	panic ("Resetting CPU ...\n");
 3f004cc:	e59f0010 	ldr	r0, [pc, #10]	; 3f004e4 <bad_mode+0x20>
 3f004d0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f004d4:	eb003ee0 	bl	3f1005c <panic>
	reset_cpu (0);
 3f004d8:	e3a00000 	mov	r0, #0	; 0x0
 3f004dc:	ebffffdf 	bl	3f00460 <reset_cpu>
 3f004e0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f004e4:	03f1a6f0 	mvneqs	r10, #251658240	; 0xf000000

03f004e8 <show_regs>:
 3f004e8:	e1a0c00d 	mov	r12, r13
 3f004ec:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f004f0:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void show_regs (struct pt_regs *regs)
{
 3f004f4:	e1a04000 	mov	r4, r0
	unsigned long flags;
	const char *processor_modes[] = {
 3f004f8:	e24b6098 	sub	r6, r11, #152	; 0x98
 3f004fc:	e1a00006 	mov	r0, r6
 3f00500:	e3a02080 	mov	r2, #128	; 0x80
 3f00504:	e59f10f0 	ldr	r1, [pc, #f0]	; 3f005fc <show_regs+0x114>
 3f00508:	e24dd088 	sub	r13, r13, #136	; 0x88
 3f0050c:	eb003c1d 	bl	3f0f588 <memcpy>
	"USER_26",	"FIQ_26",	"IRQ_26",	"SVC_26",
	"UK4_26",	"UK5_26",	"UK6_26",	"UK7_26",
	"UK8_26",	"UK9_26",	"UK10_26",	"UK11_26",
	"UK12_26",	"UK13_26",	"UK14_26",	"UK15_26",
	"USER_32",	"FIQ_32",	"IRQ_32",	"SVC_32",
	"UK4_32",	"UK5_32",	"UK6_32",	"ABT_32",
	"UK8_32",	"UK9_32",	"UK10_32",	"UND_32",
	"UK12_32",	"UK13_32",	"UK14_32",	"SYS_32",
	};

	flags = condition_codes (regs);

	printf ("pc : [<%08lx>]    lr : [<%08lx>]\n"
 3f00510:	e5943030 	ldr	r3, [r4, #48]
 3f00514:	e59f00e4 	ldr	r0, [pc, #e4]	; 3f00600 <show_regs+0x118>
 3f00518:	e58d3000 	str	r3, [r13]
 3f0051c:	e5943034 	ldr	r3, [r4, #52]
 3f00520:	e594103c 	ldr	r1, [r4, #60]
 3f00524:	e594c02c 	ldr	r12, [r4, #44]
 3f00528:	e5942038 	ldr	r2, [r4, #56]
 3f0052c:	e58dc004 	str	r12, [r13, #4]
 3f00530:	e5945040 	ldr	r5, [r4, #64]
 3f00534:	eb0030c2 	bl	3f0c844 <printf>
		"sp : %08lx  ip : %08lx  fp : %08lx\n",
		instruction_pointer (regs),
		regs->ARM_lr, regs->ARM_sp, regs->ARM_ip, regs->ARM_fp);
	printf ("r10: %08lx  r9 : %08lx  r8 : %08lx\n",
 3f00538:	e59f00c4 	ldr	r0, [pc, #c4]	; 3f00604 <show_regs+0x11c>
 3f0053c:	e5941028 	ldr	r1, [r4, #40]
 3f00540:	e5942024 	ldr	r2, [r4, #36]
 3f00544:	e5943020 	ldr	r3, [r4, #32]
 3f00548:	eb0030bd 	bl	3f0c844 <printf>
		regs->ARM_r10, regs->ARM_r9, regs->ARM_r8);
	printf ("r7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n",
 3f0054c:	e59f00b4 	ldr	r0, [pc, #b4]	; 3f00608 <show_regs+0x120>
 3f00550:	e594101c 	ldr	r1, [r4, #28]
 3f00554:	e5942018 	ldr	r2, [r4, #24]
 3f00558:	e594c010 	ldr	r12, [r4, #16]
 3f0055c:	e5943014 	ldr	r3, [r4, #20]
 3f00560:	e58dc000 	str	r12, [r13]
 3f00564:	eb0030b6 	bl	3f0c844 <printf>
		regs->ARM_r7, regs->ARM_r6, regs->ARM_r5, regs->ARM_r4);
	printf ("r3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n",
 3f00568:	e59f009c 	ldr	r0, [pc, #9c]	; 3f0060c <show_regs+0x124>
 3f0056c:	e594100c 	ldr	r1, [r4, #12]
 3f00570:	e5942008 	ldr	r2, [r4, #8]
 3f00574:	e594c000 	ldr	r12, [r4]
 3f00578:	e5943004 	ldr	r3, [r4, #4]
 3f0057c:	e58dc000 	str	r12, [r13]
 3f00580:	eb0030af 	bl	3f0c844 <printf>
		regs->ARM_r3, regs->ARM_r2, regs->ARM_r1, regs->ARM_r0);
	printf ("Flags: %c%c%c%c",
 3f00584:	e3150101 	tst	r5, #1073741824	; 0x40000000
 3f00588:	03a0207a 	moveq	r2, #122	; 0x7a
 3f0058c:	13a0205a 	movne	r2, #90	; 0x5a
 3f00590:	e3150202 	tst	r5, #536870912	; 0x20000000
 3f00594:	03a03063 	moveq	r3, #99	; 0x63
 3f00598:	13a03043 	movne	r3, #67	; 0x43
 3f0059c:	e3150201 	tst	r5, #268435456	; 0x10000000
 3f005a0:	03a0c076 	moveq	r12, #118	; 0x76
 3f005a4:	13a0c056 	movne	r12, #86	; 0x56
 3f005a8:	e3550000 	cmp	r5, #0	; 0x0
 3f005ac:	e59f005c 	ldr	r0, [pc, #5c]	; 3f00610 <show_regs+0x128>
 3f005b0:	a3a0106e 	movge	r1, #110	; 0x6e
 3f005b4:	b3a0104e 	movlt	r1, #78	; 0x4e
 3f005b8:	e58dc000 	str	r12, [r13]
 3f005bc:	eb0030a0 	bl	3f0c844 <printf>
		flags & CC_N_BIT ? 'N' : 'n',
		flags & CC_Z_BIT ? 'Z' : 'z',
		flags & CC_C_BIT ? 'C' : 'c', flags & CC_V_BIT ? 'V' : 'v');
	printf ("  IRQs %s  FIQs %s  Mode %s%s\n",
 3f005c0:	e59f104c 	ldr	r1, [pc, #4c]	; 3f00614 <show_regs+0x12c>
 3f005c4:	e5943040 	ldr	r3, [r4, #64]
 3f005c8:	e59f0048 	ldr	r0, [pc, #48]	; 3f00618 <show_regs+0x130>
 3f005cc:	e59f2048 	ldr	r2, [pc, #48]	; 3f0061c <show_regs+0x134>
 3f005d0:	e59fc048 	ldr	r12, [pc, #48]	; 3f00620 <show_regs+0x138>
 3f005d4:	e3130080 	tst	r3, #128	; 0x80
 3f005d8:	e1a0e001 	mov	r14, r1
 3f005dc:	01a01002 	moveq	r1, r2
 3f005e0:	e3130040 	tst	r3, #64	; 0x40
 3f005e4:	e203301f 	and	r3, r3, #31	; 0x1f
 3f005e8:	e7963103 	ldr	r3, [r6, r3, lsl #2]
 3f005ec:	11a0200e 	movne	r2, r14
 3f005f0:	e58dc000 	str	r12, [r13]
 3f005f4:	eb003092 	bl	3f0c844 <printf>
 3f005f8:	ea000009 	b	3f00624 <show_regs+0x13c>
 3f005fc:	03f1a804 	mvneqs	r10, #262144	; 0x40000
 3f00600:	03f1a884 	mvneqs	r10, #8650752	; 0x840000
 3f00604:	03f1a8cc 	mvneqs	r10, #13369344	; 0xcc0000
 3f00608:	03f1a8f0 	mvneqs	r10, #15728640	; 0xf00000
 3f0060c:	03f1a920 	mvneqs	r10, #524288	; 0x80000
 3f00610:	03f1a950 	mvneqs	r10, #1310720	; 0x140000
 3f00614:	03f1a984 	mvneqs	r10, #2162688	; 0x210000
 3f00618:	03f1a960 	mvneqs	r10, #1572864	; 0x180000
 3f0061c:	03f1a980 	mvneqs	r10, #2097152	; 0x200000
 3f00620:	03f1a988 	mvneqs	r10, #2228224	; 0x220000
		interrupts_enabled (regs) ? "on" : "off",
		fast_interrupts_enabled (regs) ? "on" : "off",
		processor_modes[processor_mode (regs)],
		thumb_mode (regs) ? " (T)" : "");
}
 3f00624:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f00628 <do_undefined_instruction>:
 3f00628:	e1a0c00d 	mov	r12, r13
 3f0062c:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}

void do_undefined_instruction (struct pt_regs *pt_regs)
{
 3f00630:	e1a04000 	mov	r4, r0
	printf ("undefined instruction\n");
 3f00634:	e59f0014 	ldr	r0, [pc, #14]	; 3f00650 <do_undefined_instruction+0x28>
 3f00638:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0063c:	eb003080 	bl	3f0c844 <printf>
	show_regs (pt_regs);
 3f00640:	e1a00004 	mov	r0, r4
 3f00644:	ebffffa7 	bl	3f004e8 <show_regs>
	bad_mode ();
 3f00648:	ebffff9d 	bl	3f004c4 <bad_mode>
 3f0064c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f00650:	03f1a98c 	mvneqs	r10, #2293760	; 0x230000

03f00654 <do_software_interrupt>:
 3f00654:	e1a0c00d 	mov	r12, r13
 3f00658:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
}

void do_software_interrupt (struct pt_regs *pt_regs)
{
 3f0065c:	e1a04000 	mov	r4, r0
	printf ("software interrupt\n");
 3f00660:	e59f0014 	ldr	r0, [pc, #14]	; 3f0067c <do_software_interrupt+0x28>
 3f00664:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f00668:	eb003075 	bl	3f0c844 <printf>
	show_regs (pt_regs);
 3f0066c:	e1a00004 	mov	r0, r4
 3f00670:	ebffff9c 	bl	3f004e8 <show_regs>
	bad_mode ();
 3f00674:	ebffff92 	bl	3f004c4 <bad_mode>
 3f00678:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f0067c:	03f1a9a4 	mvneqs	r10, #2686976	; 0x290000

03f00680 <do_prefetch_abort>:
 3f00680:	e1a0c00d 	mov	r12, r13
 3f00684:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
}

void do_prefetch_abort (struct pt_regs *pt_regs)
{
 3f00688:	e1a04000 	mov	r4, r0
	printf ("prefetch abort\n");
 3f0068c:	e59f0014 	ldr	r0, [pc, #14]	; 3f006a8 <do_prefetch_abort+0x28>
 3f00690:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f00694:	eb00306a 	bl	3f0c844 <printf>
	show_regs (pt_regs);
 3f00698:	e1a00004 	mov	r0, r4
 3f0069c:	ebffff91 	bl	3f004e8 <show_regs>
	bad_mode ();
 3f006a0:	ebffff87 	bl	3f004c4 <bad_mode>
 3f006a4:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f006a8:	03f1a9b8 	mvneqs	r10, #3014656	; 0x2e0000

03f006ac <do_data_abort>:
 3f006ac:	e1a0c00d 	mov	r12, r13
 3f006b0:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
}

void do_data_abort (struct pt_regs *pt_regs)
{
 3f006b4:	e1a04000 	mov	r4, r0
	printf ("data abort\n");
 3f006b8:	e59f0014 	ldr	r0, [pc, #14]	; 3f006d4 <do_data_abort+0x28>
 3f006bc:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f006c0:	eb00305f 	bl	3f0c844 <printf>
	show_regs (pt_regs);
 3f006c4:	e1a00004 	mov	r0, r4
 3f006c8:	ebffff86 	bl	3f004e8 <show_regs>
	bad_mode ();
 3f006cc:	ebffff7c 	bl	3f004c4 <bad_mode>
 3f006d0:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f006d4:	03f1a9c8 	mvneqs	r10, #3276800	; 0x320000

03f006d8 <do_not_used>:
 3f006d8:	e1a0c00d 	mov	r12, r13
 3f006dc:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
}

void do_not_used (struct pt_regs *pt_regs)
{
 3f006e0:	e1a04000 	mov	r4, r0
	printf ("not used\n");
 3f006e4:	e59f0014 	ldr	r0, [pc, #14]	; 3f00700 <do_not_used+0x28>
 3f006e8:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f006ec:	eb003054 	bl	3f0c844 <printf>
	show_regs (pt_regs);
 3f006f0:	e1a00004 	mov	r0, r4
 3f006f4:	ebffff7b 	bl	3f004e8 <show_regs>
	bad_mode ();
 3f006f8:	ebffff71 	bl	3f004c4 <bad_mode>
 3f006fc:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f00700:	03f1a9d4 	mvneqs	r10, #3473408	; 0x350000

03f00704 <do_fiq>:
 3f00704:	e1a0c00d 	mov	r12, r13
 3f00708:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
}

void do_fiq (struct pt_regs *pt_regs)
{
 3f0070c:	e1a04000 	mov	r4, r0
	printf ("fast interrupt request\n");
 3f00710:	e59f0014 	ldr	r0, [pc, #14]	; 3f0072c <do_fiq+0x28>
 3f00714:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f00718:	eb003049 	bl	3f0c844 <printf>
	show_regs (pt_regs);
 3f0071c:	e1a00004 	mov	r0, r4
 3f00720:	ebffff70 	bl	3f004e8 <show_regs>
	bad_mode ();
 3f00724:	ebffff66 	bl	3f004c4 <bad_mode>
 3f00728:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f0072c:	03f1a9e0 	mvneqs	r10, #3670016	; 0x380000

03f00730 <do_irq>:
 3f00730:	e1a0c00d 	mov	r12, r13
 3f00734:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
}

void do_irq (struct pt_regs *pt_regs)
{
 3f00738:	e1a04000 	mov	r4, r0
	printf ("interrupt request\n");
 3f0073c:	e59f0014 	ldr	r0, [pc, #14]	; 3f00758 <do_irq+0x28>
 3f00740:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f00744:	eb00303e 	bl	3f0c844 <printf>
	show_regs (pt_regs);
 3f00748:	e1a00004 	mov	r0, r4
 3f0074c:	ebffff65 	bl	3f004e8 <show_regs>
	bad_mode ();
 3f00750:	ebffff5b 	bl	3f004c4 <bad_mode>
 3f00754:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f00758:	03f1a9f8 	mvneqs	r10, #4063232	; 0x3e0000

03f0075c <interrupt_init>:
 3f0075c:	e1a0c00d 	mov	r12, r13
 3f00760:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}


static ulong timestamp;
static ulong lastdec;

#if defined(CONFIG_MMSP20)

/* timer configration */
int interrupt_init (void)
{
	MMSP20_TIMER_WATCHDOG * const timers = MMSP20_GetBase_TIMERS();

	/* */
	/* */
	if (timer_load_val == 0)
 3f00764:	e59f203c 	ldr	r2, [pc, #3c]	; 3f007a8 <interrupt_init+0x4c>
 3f00768:	e5923000 	ldr	r3, [r2]
 3f0076c:	e24cb004 	sub	r11, r12, #4	; 0x4
	return (MMSP20_UART * const)MMSP20_UART_BASE;
}
static inline MMSP20_TIMER_WATCHDOG * const MMSP20_GetBase_TIMERS(void)
{
	return (MMSP20_TIMER_WATCHDOG * const)MMSP20_TIMER_WATCHDOG_BASE;
 3f00770:	e59f0034 	ldr	r0, [pc, #34]	; 3f007ac <interrupt_init+0x50>
 3f00774:	e3530000 	cmp	r3, #0	; 0x0
	{
		/* 10ms configration */
		timer_load_val = 0x12000;
 3f00778:	03a03a12 	moveq	r3, #73728	; 0x12000
 3f0077c:	05823000 	streq	r3, [r2]
	}
	/* 10ms timer configration */
	lastdec = timer_load_val;
 3f00780:	e59f1028 	ldr	r1, [pc, #28]	; 3f007b0 <interrupt_init+0x54>
 3f00784:	e5922000 	ldr	r2, [r2]
	/* Timer stop */
	timers->TCONTROL = (timers->TCONTROL & ~0x01) | 0x01;
 3f00788:	e1d031b4 	ldrh	r3, [r0, #20]
 3f0078c:	e5812000 	str	r2, [r1]
 3f00790:	e3833001 	orr	r3, r3, #1	; 0x1
 3f00794:	e1c031b4 	strh	r3, [r0, #20]
	timestamp = 0;
 3f00798:	e3a00000 	mov	r0, #0	; 0x0
 3f0079c:	e59f3010 	ldr	r3, [pc, #10]	; 3f007b4 <interrupt_init+0x58>
 3f007a0:	e5830000 	str	r0, [r3]
	return (0);
}
 3f007a4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f007a8:	03f203ec 	mvneqs	r0, #-1342177277	; 0xb0000003
 3f007ac:	c0000a00 	andgt	r0, r0, r0, lsl #20
 3f007b0:	03f6a6a4 	mvneqs	r10, #171966464	; 0xa400000
 3f007b4:	03f6a6a0 	mvneqs	r10, #167772160	; 0xa000000

03f007b8 <reset_timer>:
 3f007b8:	e1a0c00d 	mov	r12, r13
 3f007bc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f007c0:	e24cb004 	sub	r11, r12, #4	; 0x4

#else
int interrupt_init (void)
{
	S3C24X0_TIMERS * const timers = S3C24X0_GetBase_TIMERS();

	/* use PWM Timer 4 because it has no output */
	/* prescaler for Timer 4 is 16 */
	timers->TCFG0 = 0x0f00;
	if (timer_load_val == 0)
	{
		/*
		 * for 10 ms clock period @ PCLK with 4 bit divider = 1/2
		 * (default) and prescaler = 16. Should be 10390
		 * @33.25MHz and 15625 @ 50 MHz
		 */
		timer_load_val = get_PCLK()/(2 * 16 * 100);
	}
	/* load value for 10 ms timeout */
	lastdec = timers->TCNTB4 = timer_load_val;
	/* auto load, manual update of Timer 4 */
	timers->TCON = (timers->TCON & ~0x0700000) | 0x600000;
	/* auto load, start Timer 4 */
	timers->TCON = (timers->TCON & ~0x0700000) | 0x500000;
	timestamp = 0;

	return (0);
}
#endif
/*
 * timer without interrupts
 */

void reset_timer (void)
{
	reset_timer_masked ();
 3f007c4:	eb000037 	bl	3f008a8 <reset_timer_masked>
 3f007c8:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f007cc <get_timer>:
 3f007cc:	e1a0c00d 	mov	r12, r13
 3f007d0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f007d4:	e24cb004 	sub	r11, r12, #4	; 0x4
	return (MMSP20_UART * const)MMSP20_UART_BASE;
}
static inline MMSP20_TIMER_WATCHDOG * const MMSP20_GetBase_TIMERS(void)
{
	return (MMSP20_TIMER_WATCHDOG * const)MMSP20_TIMER_WATCHDOG_BASE;
 3f007d8:	e59f3018 	ldr	r3, [pc, #18]	; 3f007f8 <get_timer+0x2c>
}
#if defined (CONFIG_MMSP20)
ulong get_timer (ulong base)
{
	ulong now = READ_TIMER();
	
	while(base) base-- ;
 3f007dc:	e3500000 	cmp	r0, #0	; 0x0
 3f007e0:	e5933000 	ldr	r3, [r3]
 3f007e4:	0a000001 	beq	3f007f0 <get_timer+0x24>
 3f007e8:	e2500001 	subs	r0, r0, #1	; 0x1
 3f007ec:	1afffffd 	bne	3f007e8 <get_timer+0x1c>

	return now;
 3f007f0:	e1a00003 	mov	r0, r3
}
 3f007f4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f007f8:	c0000a00 	andgt	r0, r0, r0, lsl #20

03f007fc <set_timer>:
 3f007fc:	e1a0c00d 	mov	r12, r13
 3f00800:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
#else
ulong get_timer (ulong base)
{
	return get_timer_masked () - base;
}
#endif
void set_timer (ulong t)
{
	timestamp = t;
 3f00804:	e59f3008 	ldr	r3, [pc, #8]	; 3f00814 <set_timer+0x18>
 3f00808:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0080c:	e5830000 	str	r0, [r3]
 3f00810:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f00814:	03f6a6a0 	mvneqs	r10, #167772160	; 0xa000000

03f00818 <udelay>:
 3f00818:	e1a0c00d 	mov	r12, r13
 3f0081c:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f00820:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void udelay (unsigned long usec)
{
	ulong tmo;


#if defined (CONFIG_MMSP20)
	ulong ReadTime;	

/* 	printf("%lu usec\n", usec);	*/
	
	if (usec < 10) usec = 10;
 3f00824:	e3500009 	cmp	r0, #9	; 0x9
 3f00828:	81a04000 	movhi	r4, r0
 3f0082c:	93a0400a 	movls	r4, #10	; 0xa

	tmo = get_timer(10) + ((usec / 10) * 29);
 3f00830:	e3a0000a 	mov	r0, #10	; 0xa
 3f00834:	ebffffe4 	bl	3f007cc <get_timer>
 3f00838:	e59f3064 	ldr	r3, [pc, #64]	; 3f008a4 <udelay+0x8c>
 3f0083c:	e0832394 	umull	r2, r3, r4, r3
 3f00840:	e1a031a3 	mov	r3, r3, lsr #3
 3f00844:	e0632183 	rsb	r2, r3, r3, lsl #3
 3f00848:	e0833102 	add	r3, r3, r2, lsl #2
 3f0084c:	e0804003 	add	r4, r0, r3

	if (ReadTime < tmo)
 3f00850:	e1550004 	cmp	r5, r4
 3f00854:	2a000004 	bcs	3f0086c <udelay+0x54>
		while (get_timer(10) < tmo);
 3f00858:	e3a0000a 	mov	r0, #10	; 0xa
 3f0085c:	ebffffda 	bl	3f007cc <get_timer>
 3f00860:	e1500004 	cmp	r0, r4
 3f00864:	3afffffb 	bcc	3f00858 <udelay+0x40>
 3f00868:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
	else  {
	   while (get_timer(10) < 0xffffffff && get_timer(10) > (tmo + 73728));
 3f0086c:	e3a0000a 	mov	r0, #10	; 0xa
 3f00870:	ebffffd5 	bl	3f007cc <get_timer>
 3f00874:	e3700002 	cmn	r0, #2	; 0x2
 3f00878:	8a000004 	bhi	3f00890 <udelay+0x78>
 3f0087c:	e3a0000a 	mov	r0, #10	; 0xa
 3f00880:	ebffffd1 	bl	3f007cc <get_timer>
 3f00884:	e2843a12 	add	r3, r4, #73728	; 0x12000
 3f00888:	e1500003 	cmp	r0, r3
 3f0088c:	8afffff6 	bhi	3f0086c <udelay+0x54>
	   while (get_timer(10) < tmo);
 3f00890:	e3a0000a 	mov	r0, #10	; 0xa
 3f00894:	ebffffcc 	bl	3f007cc <get_timer>
 3f00898:	e1500004 	cmp	r0, r4
 3f0089c:	3afffffb 	bcc	3f00890 <udelay+0x78>
	}
#else
	tmo = usec / 1000;
	tmo *= (timer_load_val * 100);
	tmo /= 1000;

	tmo += get_timer (0);

	while (get_timer_masked () < tmo)
		/*NOP*/;
#endif
}
 3f008a0:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f008a4:	cccccccd 	stcgtl	12, cr12, [r12], #820

03f008a8 <reset_timer_masked>:
 3f008a8:	e1a0c00d 	mov	r12, r13
 3f008ac:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

void reset_timer_masked (void)
{
	/* reset time */
	lastdec = READ_TIMER();
	timestamp = 0;
 3f008b0:	e59f201c 	ldr	r2, [pc, #1c]	; 3f008d4 <reset_timer_masked+0x2c>
 3f008b4:	e3a03000 	mov	r3, #0	; 0x0
 3f008b8:	e5823000 	str	r3, [r2]
	return (MMSP20_UART * const)MMSP20_UART_BASE;
}
static inline MMSP20_TIMER_WATCHDOG * const MMSP20_GetBase_TIMERS(void)
{
	return (MMSP20_TIMER_WATCHDOG * const)MMSP20_TIMER_WATCHDOG_BASE;
 3f008bc:	e59f3014 	ldr	r3, [pc, #14]	; 3f008d8 <reset_timer_masked+0x30>
 3f008c0:	e5932000 	ldr	r2, [r3]
 3f008c4:	e59f3010 	ldr	r3, [pc, #10]	; 3f008dc <reset_timer_masked+0x34>
 3f008c8:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f008cc:	e5832000 	str	r2, [r3]
}
 3f008d0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f008d4:	03f6a6a0 	mvneqs	r10, #167772160	; 0xa000000
 3f008d8:	c0000a00 	andgt	r0, r0, r0, lsl #20
 3f008dc:	03f6a6a4 	mvneqs	r10, #171966464	; 0xa400000

03f008e0 <get_timer_masked>:
 3f008e0:	e1a0c00d 	mov	r12, r13
 3f008e4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_UART * const)MMSP20_UART_BASE;
}
static inline MMSP20_TIMER_WATCHDOG * const MMSP20_GetBase_TIMERS(void)
{
	return (MMSP20_TIMER_WATCHDOG * const)MMSP20_TIMER_WATCHDOG_BASE;
 3f008e8:	e59f305c 	ldr	r3, [pc, #5c]	; 3f0094c <get_timer_masked+0x6c>

ulong get_timer_masked (void)
{
	ulong now = READ_TIMER();

	if (lastdec >= now) {
 3f008ec:	e59fe05c 	ldr	r14, [pc, #5c]	; 3f00950 <get_timer_masked+0x70>
 3f008f0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f008f4:	e593c000 	ldr	r12, [r3]
 3f008f8:	e59e0000 	ldr	r0, [r14]
 3f008fc:	e150000c 	cmp	r0, r12
 3f00900:	3a000005 	bcc	3f0091c <get_timer_masked+0x3c>
		/* normal mode */
		timestamp += lastdec - now;
 3f00904:	e59f3048 	ldr	r3, [pc, #48]	; 3f00954 <get_timer_masked+0x74>
 3f00908:	e5932000 	ldr	r2, [r3]
 3f0090c:	e06c1000 	rsb	r1, r12, r0
 3f00910:	e0822001 	add	r2, r2, r1
 3f00914:	e5832000 	str	r2, [r3]
	} else {
 3f00918:	ea000007 	b	3f0093c <get_timer_masked+0x5c>
		/* we have an overflow ... */
		timestamp += lastdec + timer_load_val - now;
 3f0091c:	e59f3034 	ldr	r3, [pc, #34]	; 3f00958 <get_timer_masked+0x78>
 3f00920:	e59f102c 	ldr	r1, [pc, #2c]	; 3f00954 <get_timer_masked+0x74>
 3f00924:	e5932000 	ldr	r2, [r3]
 3f00928:	e5913000 	ldr	r3, [r1]
 3f0092c:	e0802002 	add	r2, r0, r2
 3f00930:	e06c2002 	rsb	r2, r12, r2
 3f00934:	e0833002 	add	r3, r3, r2
 3f00938:	e5813000 	str	r3, [r1]
	}
	lastdec = now;
 3f0093c:	e58ec000 	str	r12, [r14]
	return timestamp;
 3f00940:	e59f300c 	ldr	r3, [pc, #c]	; 3f00954 <get_timer_masked+0x74>
 3f00944:	e5930000 	ldr	r0, [r3]
}
 3f00948:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0094c:	c0000a00 	andgt	r0, r0, r0, lsl #20
 3f00950:	03f6a6a4 	mvneqs	r10, #171966464	; 0xa400000
 3f00954:	03f6a6a0 	mvneqs	r10, #167772160	; 0xa000000
 3f00958:	03f203ec 	mvneqs	r0, #-1342177277	; 0xb0000003

03f0095c <udelay_masked>:

void udelay_masked (unsigned long usec)
{
	ulong tmo;

	tmo = usec / 1000;
 3f0095c:	e59f1044 	ldr	r1, [pc, #44]	; 3f009a8 <udelay_masked+0x4c>
 3f00960:	e0832091 	umull	r2, r3, r1, r0
 3f00964:	e1a0c00d 	mov	r12, r13
 3f00968:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
	tmo *= (timer_load_val * 100);
 3f0096c:	e59f2038 	ldr	r2, [pc, #38]	; 3f009ac <udelay_masked+0x50>
 3f00970:	e5922000 	ldr	r2, [r2]
 3f00974:	e1a04323 	mov	r4, r3, lsr #6
 3f00978:	e0843104 	add	r3, r4, r4, lsl #2
 3f0097c:	e0833103 	add	r3, r3, r3, lsl #2
 3f00980:	e1a03103 	mov	r3, r3, lsl #2
 3f00984:	e0040392 	mul	r4, r2, r3
	tmo /= 1000;
 3f00988:	e0832491 	umull	r2, r3, r1, r4
 3f0098c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f00990:	e1a04323 	mov	r4, r3, lsr #6

	reset_timer_masked ();
 3f00994:	ebffffc3 	bl	3f008a8 <reset_timer_masked>

	while (get_timer_masked () < tmo)
 3f00998:	ebffffd0 	bl	3f008e0 <get_timer_masked>
 3f0099c:	e1500004 	cmp	r0, r4
 3f009a0:	3afffffc 	bcc	3f00998 <udelay_masked+0x3c>
		/*NOP*/;
}
 3f009a4:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f009a8:	10624dd3 	ldrned	r4, [r2], -#211
 3f009ac:	03f203ec 	mvneqs	r0, #-1342177277	; 0xb0000003

03f009b0 <get_ticks>:
 3f009b0:	e1a0c00d 	mov	r12, r13
 3f009b4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f009b8:	e24cb004 	sub	r11, r12, #4	; 0x4

/*
 * This function is derived from PowerPC code (read timebase as long long).
 * On ARM it just returns the timer value.
 */
unsigned long long get_ticks(void)
{
	return get_timer(0);
 3f009bc:	e3a00000 	mov	r0, #0	; 0x0
 3f009c0:	ebffff81 	bl	3f007cc <get_timer>
 3f009c4:	e3a01000 	mov	r1, #0	; 0x0
 3f009c8:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f009cc <get_tbclk>:
 3f009cc:	e1a0c00d 	mov	r12, r13
 3f009d0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f009d4:	e24cb004 	sub	r11, r12, #4	; 0x4
}

/*
 * This function is derived from PowerPC code (timebase clock frequency).
 * On ARM it returns the number of timer ticks per second.
 */
ulong get_tbclk (void)
{
	ulong tbclk;

#if defined(CONFIG_SMDK2400) || defined(CONFIG_TRAB) 
	tbclk = timer_load_val * 100;
#elif defined(CONFIG_SMDK2410) || defined(CONFIG_VCMA9) || defined(CONFIG_EPLAY) || defined(CONFIG_MMSP2DTK)
	tbclk = CFG_HZ;
#else
#	error "tbclk not configured"
#endif

	return tbclk;
 3f009d8:	e59f0000 	ldr	r0, [pc, #0]	; 3f009e0 <get_tbclk+0x14>
}
 3f009dc:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f009e0:	00708000 	rsbeqs	r8, r0, r0

03f009e4 <mem_malloc_init>:
 3f009e4:	e1a0c00d 	mov	r12, r13
 3f009e8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
//[*]----------------------------------------------------------------------------------------------------[*]
static
void mem_malloc_init (ulong dest_addr)
{
	mem_malloc_start = dest_addr;
 3f009ec:	e59f202c 	ldr	r2, [pc, #2c]	; 3f00a20 <mem_malloc_init+0x3c>
 3f009f0:	e24cb004 	sub	r11, r12, #4	; 0x4
	mem_malloc_end = dest_addr + CFG_MALLOC_LEN;
 3f009f4:	e59f1028 	ldr	r1, [pc, #28]	; 3f00a24 <mem_malloc_init+0x40>
 3f009f8:	e1a03000 	mov	r3, r0
 3f009fc:	e5823000 	str	r3, [r2]
 3f00a00:	e2832909 	add	r2, r3, #147456	; 0x24000
 3f00a04:	e5812000 	str	r2, [r1]
	mem_malloc_brk = mem_malloc_start;
 3f00a08:	e59f1018 	ldr	r1, [pc, #18]	; 3f00a28 <mem_malloc_init+0x44>

	memset ((void *) mem_malloc_start, 0,
 3f00a0c:	e0602002 	rsb	r2, r0, r2
 3f00a10:	e5813000 	str	r3, [r1]
 3f00a14:	e3a01000 	mov	r1, #0	; 0x0
 3f00a18:	eb003ac0 	bl	3f0f520 <memset>
 3f00a1c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f00a20:	03f203f0 	mvneqs	r0, #-1073741821	; 0xc0000003
 3f00a24:	03f203f4 	mvneqs	r0, #-805306365	; 0xd0000003
 3f00a28:	03f203f8 	mvneqs	r0, #-536870909	; 0xe0000003

03f00a2c <sbrk>:
 3f00a2c:	e1a0c00d 	mov	r12, r13
 3f00a30:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f00a34:	e24cb004 	sub	r11, r12, #4	; 0x4
			mem_malloc_end - mem_malloc_start);
}
//[*]----------------------------------------------------------------------------------------------------[*]
void *sbrk (ptrdiff_t increment)
{
	ulong old = mem_malloc_brk;
 3f00a38:	e59fc038 	ldr	r12, [pc, #38]	; 3f00a78 <sbrk+0x4c>
	ulong new = old + increment;

	if ((new < mem_malloc_start) || (new > mem_malloc_end)) {
 3f00a3c:	e59f3038 	ldr	r3, [pc, #38]	; 3f00a7c <sbrk+0x50>
 3f00a40:	e59c1000 	ldr	r1, [r12]
 3f00a44:	e5933000 	ldr	r3, [r3]
 3f00a48:	e0812000 	add	r2, r1, r0
 3f00a4c:	e1520003 	cmp	r2, r3
 3f00a50:	3a000003 	bcc	3f00a64 <sbrk+0x38>
 3f00a54:	e59f3024 	ldr	r3, [pc, #24]	; 3f00a80 <sbrk+0x54>
 3f00a58:	e5933000 	ldr	r3, [r3]
 3f00a5c:	e1520003 	cmp	r2, r3
 3f00a60:	9a000001 	bls	3f00a6c <sbrk+0x40>
		return (NULL);
 3f00a64:	e3a00000 	mov	r0, #0	; 0x0
 3f00a68:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	}
	mem_malloc_brk = new;

	return ((void *) old);
 3f00a6c:	e1a00001 	mov	r0, r1
 3f00a70:	e58c2000 	str	r2, [r12]
}
 3f00a74:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f00a78:	03f203f8 	mvneqs	r0, #-536870909	; 0xe0000003
 3f00a7c:	03f203f0 	mvneqs	r0, #-1073741821	; 0xc0000003
 3f00a80:	03f203f4 	mvneqs	r0, #-805306365	; 0xd0000003

03f00a84 <init_baudrate>:
 3f00a84:	e1a0c00d 	mov	r12, r13
 3f00a88:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f00a8c:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
/************************************************************************
 * Init Utilities							*
 ************************************************************************
 * Some of this code should be moved into the core functions,
 * or dropped completely,
 * but let's get it working (again) first...
 */
//[*]----------------------------------------------------------------------------------------------------[*]
static int init_baudrate (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	uchar tmp[64];	/* long enough for environment variables */
	int i = getenv_r ("baudrate", tmp, sizeof (tmp));
 3f00a90:	e24b4054 	sub	r4, r11, #84	; 0x54
 3f00a94:	e1a01004 	mov	r1, r4
 3f00a98:	e3a02040 	mov	r2, #64	; 0x40
 3f00a9c:	e59f0024 	ldr	r0, [pc, #24]	; 3f00ac8 <init_baudrate+0x44>
 3f00aa0:	e24dd040 	sub	r13, r13, #64	; 0x40
 3f00aa4:	eb002d8d 	bl	3f0c0e0 <getenv_r>
	gd->bd->bi_baudrate = gd->baudrate = (i > 0)
 3f00aa8:	e3500000 	cmp	r0, #0	; 0x0
 3f00aac:	e5985000 	ldr	r5, [r8]
 3f00ab0:	da000005 	ble	3f00acc <init_baudrate+0x48>
 3f00ab4:	e1a00004 	mov	r0, r4
 3f00ab8:	e3a01000 	mov	r1, #0	; 0x0
 3f00abc:	e3a0200a 	mov	r2, #10	; 0xa
 3f00ac0:	eb003b1f 	bl	3f0f744 <simple_strtoul>
 3f00ac4:	ea000001 	b	3f00ad0 <init_baudrate+0x4c>
 3f00ac8:	03f1aa34 	mvneqs	r10, #212992	; 0x34000
 3f00acc:	e59f0010 	ldr	r0, [pc, #10]	; 3f00ae4 <init_baudrate+0x60>
 3f00ad0:	e5880008 	str	r0, [r8, #8]
 3f00ad4:	e5983008 	ldr	r3, [r8, #8]
			? (int) simple_strtoul (tmp, NULL, 10)
			: CONFIG_BAUDRATE;

	return (0);
 3f00ad8:	e3a00000 	mov	r0, #0	; 0x0
 3f00adc:	e5853000 	str	r3, [r5]
 3f00ae0:	ea000000 	b	3f00ae8 <init_baudrate+0x64>
 3f00ae4:	0001c200 	andeq	r12, r1, r0, lsl #4
}
 3f00ae8:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f00aec <display_banner>:
 3f00aec:	e1a0c00d 	mov	r12, r13
 3f00af0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
//[*]----------------------------------------------------------------------------------------------------[*]
static int display_banner (void)
{
#ifdef CONFIG_SILENT_CONSOLE
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->flags & GD_FLG_SILENT)
		return (0);
#endif

	printf ("\n\n%s\n\n", version_string);
 3f00af4:	e59f0030 	ldr	r0, [pc, #30]	; 3f00b2c <display_banner+0x40>
 3f00af8:	e59f1030 	ldr	r1, [pc, #30]	; 3f00b30 <display_banner+0x44>
 3f00afc:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f00b00:	eb002f4f 	bl	3f0c844 <printf>
	printf ("U-Boot code: %08lX -> %08lX  BSS: -> %08lX\n",
 3f00b04:	e59f0028 	ldr	r0, [pc, #28]	; 3f00b34 <display_banner+0x48>
 3f00b08:	e59f3028 	ldr	r3, [pc, #28]	; 3f00b38 <display_banner+0x4c>
 3f00b0c:	e59fc028 	ldr	r12, [pc, #28]	; 3f00b3c <display_banner+0x50>
 3f00b10:	e5931000 	ldr	r1, [r3]
 3f00b14:	e59f3024 	ldr	r3, [pc, #24]	; 3f00b40 <display_banner+0x54>
 3f00b18:	e5932000 	ldr	r2, [r3]
 3f00b1c:	e59c3000 	ldr	r3, [r12]
 3f00b20:	eb002f47 	bl	3f0c844 <printf>
		_armboot_start, _armboot_end_data, _armboot_end);
#ifdef CONFIG_MODEM_SUPPORT
	puts ("Modem Support enabled\n");
#endif
#ifdef CONFIG_USE_IRQ
	printf ("IRQ Stack: %08lx\n", IRQ_STACK_START);
	printf ("FIQ Stack: %08lx\n", FIQ_STACK_START);
#endif

#ifdef CONFIG_MMSP20
//	show_MMSP2_CLK();
#endif

	return (0);
 3f00b24:	e3a00000 	mov	r0, #0	; 0x0
 3f00b28:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f00b2c:	03f1aa40 	mvneqs	r10, #262144	; 0x40000
 3f00b30:	03f1aa0c 	mvneqs	r10, #49152	; 0xc000
 3f00b34:	03f1aa48 	mvneqs	r10, #294912	; 0x48000
 3f00b38:	03f00044 	mvneqs	r0, #68	; 0x44
 3f00b3c:	03f0004c 	mvneqs	r0, #76	; 0x4c
 3f00b40:	03f00048 	mvneqs	r0, #72	; 0x48

03f00b44 <display_dram_config>:
 3f00b44:	e1a0c00d 	mov	r12, r13
 3f00b48:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f00b4c:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * WARNING: this code looks "cleaner" than the PowerPC version, but
 * has the disadvantage that you either get nothing, or everything.
 * On PowerPC, you might see "DRAM: " before the system hangs - which
 * gives a simple yet clear indication which part of the
 * initialization if failing.
 */
//[*]----------------------------------------------------------------------------------------------------[*]
static int display_dram_config (void)
{
	DECLARE_GLOBAL_DATA_PTR;
	int i;

#ifdef CONFIG_SILENT_CONSOLE
	if (gd->flags & GD_FLG_SILENT)
		return (0);
#endif

	puts ("DRAM Configuration:\n");
 3f00b50:	e59f0048 	ldr	r0, [pc, #48]	; 3f00ba0 <display_dram_config+0x5c>

	for(i=0; i<CONFIG_NR_DRAM_BANKS; i++) {
 3f00b54:	e3a05000 	mov	r5, #0	; 0x0
 3f00b58:	eb002f2c 	bl	3f0c810 <puts>
		printf ("Bank #%d: %08lx ", i, gd->bd->bi_dram[i].start);
 3f00b5c:	e5983000 	ldr	r3, [r8]
 3f00b60:	e1a04185 	mov	r4, r5, lsl #3
 3f00b64:	e59f0038 	ldr	r0, [pc, #38]	; 3f00ba4 <display_dram_config+0x60>
 3f00b68:	e283301c 	add	r3, r3, #28	; 0x1c
 3f00b6c:	e7932004 	ldr	r2, [r3, r4]
 3f00b70:	e1a01005 	mov	r1, r5
 3f00b74:	eb002f32 	bl	3f0c844 <printf>
		print_size (gd->bd->bi_dram[i].size, "\n");
 3f00b78:	e5983000 	ldr	r3, [r8]
 3f00b7c:	e59f1024 	ldr	r1, [pc, #24]	; 3f00ba8 <display_dram_config+0x64>
 3f00b80:	e2833020 	add	r3, r3, #32	; 0x20
 3f00b84:	e7930004 	ldr	r0, [r3, r4]
 3f00b88:	e2855001 	add	r5, r5, #1	; 0x1
 3f00b8c:	eb003902 	bl	3f0ef9c <print_size>
 3f00b90:	e3550000 	cmp	r5, #0	; 0x0
 3f00b94:	dafffff0 	ble	3f00b5c <display_dram_config+0x18>
	}

	return (0);
 3f00b98:	e3a00000 	mov	r0, #0	; 0x0
}
 3f00b9c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f00ba0:	03f1aa74 	mvneqs	r10, #475136	; 0x74000
 3f00ba4:	03f1aa8c 	mvneqs	r10, #573440	; 0x8c000
 3f00ba8:	03f1aaa0 	mvneqs	r10, #655360	; 0xa0000

03f00bac <display_flash_config>:
 3f00bac:	e1a0c00d 	mov	r12, r13
 3f00bb0:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
//[*]----------------------------------------------------------------------------------------------------[*]
static void display_flash_config (ulong size)
{
 3f00bb4:	e1a04000 	mov	r4, r0
#ifdef CONFIG_SILENT_CONSOLE
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->flags & GD_FLG_SILENT)
		return;
#endif
	puts ("Flash: ");
 3f00bb8:	e59f0014 	ldr	r0, [pc, #14]	; 3f00bd4 <display_flash_config+0x28>
 3f00bbc:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f00bc0:	eb002f12 	bl	3f0c810 <puts>
	print_size (size, "\n");
 3f00bc4:	e59f100c 	ldr	r1, [pc, #c]	; 3f00bd8 <display_flash_config+0x2c>
 3f00bc8:	e1a00004 	mov	r0, r4
 3f00bcc:	eb0038f2 	bl	3f0ef9c <print_size>
 3f00bd0:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f00bd4:	03f1aaa4 	mvneqs	r10, #671744	; 0xa4000
 3f00bd8:	03f1aaa0 	mvneqs	r10, #655360	; 0xa0000

03f00bdc <start_armboot>:
 3f00bdc:	e1a0c00d 	mov	r12, r13
 3f00be0:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f00be4:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * Breath some life into the board...
 *
 * Initialize a serial port as console, and carry out some hardware
 * tests.
 *
 * The first part of initialization is running from Flash memory;
 * its main purpose is to initialize the RAM so that we
 * can relocate the monitor code to RAM.
 */

/*
 * All attempts to come up with a "common" initialization sequence
 * that works for all boards and architectures failed: some of the
 * requirements are just _too_ different. To get rid of the resulting
 * mess of board dependend #ifdef'ed code we now make the whole
 * initialization sequence configurable to the user.
 *
 * The requirements for any new initalization function is simple: it
 * receives a pointer to the "global data" structure as it's only
 * argument, and returns an integer return code, where 0 means
 * "continue" and != 0 means "fatal error, hang the system".
 */
//[*]----------------------------------------------------------------------------------------------------[*]
typedef int (init_fnc_t) (void);
//[*]----------------------------------------------------------------------------------------------------[*]
init_fnc_t *init_sequence[] = {
	cpu_init,		/* basic cpu dependent setup */
	board_init,		/* basic board dependent setup */
	interrupt_init,		/* set up exceptions */
#if !defined(CFG_ENV_IS_IN_NAND)
	env_init,		/* initialize environment */
#endif
	init_baudrate,		/* initialze baudrate settings */
	serial_init,		/* serial communications setup */
	console_init_f,		/* stage 1 init of console */
	display_banner,		/* say that we are here */
	dram_init,		/* configure available RAM banks */
	display_dram_config,
#if defined(CONFIG_VCMA9)
	checkboard,
#endif
	NULL,
};
//[*]----------------------------------------------------------------------------------------------------[*]
void start_armboot (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	ulong size;
	volatile gd_t gd_data;
	volatile bd_t bd_data;
	init_fnc_t **init_fnc_ptr;
	char *s;
#if defined(CONFIG_VFD)
	unsigned long addr;
#endif

	/* Pointer is writable since we allocated a register for it */
	gd = &gd_data;
 3f00be8:	e24b803c 	sub	r8, r11, #60	; 0x3c

	memset ((void *)gd, 0, sizeof (gd_t));
 3f00bec:	e1a00008 	mov	r0, r8
 3f00bf0:	e3a01000 	mov	r1, #0	; 0x0
 3f00bf4:	e3a02024 	mov	r2, #36	; 0x24
 3f00bf8:	e24dd08c 	sub	r13, r13, #140	; 0x8c
 3f00bfc:	eb003a47 	bl	3f0f520 <memset>

	gd->bd = &bd_data;
 3f00c00:	e24b3060 	sub	r3, r11, #96	; 0x60
 3f00c04:	e5883000 	str	r3, [r8]

	memset (gd->bd, 0, sizeof (bd_t));
 3f00c08:	e3a01000 	mov	r1, #0	; 0x0
 3f00c0c:	e5980000 	ldr	r0, [r8]
 3f00c10:	e3a02024 	mov	r2, #36	; 0x24

	monitor_flash_len = _armboot_end_data - _armboot_start;

	for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
 3f00c14:	e59f4160 	ldr	r4, [pc, #160]	; 3f00d7c <start_armboot+0x1a0>
 3f00c18:	eb003a40 	bl	3f0f520 <memset>
 3f00c1c:	e59f315c 	ldr	r3, [pc, #15c]	; 3f00d80 <start_armboot+0x1a4>
 3f00c20:	e59f115c 	ldr	r1, [pc, #15c]	; 3f00d84 <start_armboot+0x1a8>
 3f00c24:	e5942000 	ldr	r2, [r4]
 3f00c28:	e5933000 	ldr	r3, [r3]
 3f00c2c:	e5911000 	ldr	r1, [r1]
 3f00c30:	e3520000 	cmp	r2, #0	; 0x0
 3f00c34:	e59f214c 	ldr	r2, [pc, #14c]	; 3f00d88 <start_armboot+0x1ac>
 3f00c38:	e0613003 	rsb	r3, r1, r3
 3f00c3c:	e5823000 	str	r3, [r2]
 3f00c40:	0a000007 	beq	3f00c64 <start_armboot+0x88>
//		printf("init[%x]\n",init_fnc_ptr);
		if ((*init_fnc_ptr)() != 0) {
 3f00c44:	e1a0e00f 	mov	r14, r15
 3f00c48:	e594f000 	ldr	r15, [r4]
 3f00c4c:	e3500000 	cmp	r0, #0	; 0x0
 3f00c50:	0a000000 	beq	3f00c58 <start_armboot+0x7c>
			hang ();
 3f00c54:	eb000055 	bl	3f00db0 <hang>
 3f00c58:	e5b43004 	ldr	r3, [r4, #4]!
 3f00c5c:	e3530000 	cmp	r3, #0	; 0x0
 3f00c60:	1afffff7 	bne	3f00c44 <start_armboot+0x68>
		}
	}

	/* configure available FLASH banks */
	size = flash_init ();
 3f00c64:	eb004ba5 	bl	3f13b00 <flash_init>
	display_flash_config (size);
 3f00c68:	ebffffcf 	bl	3f00bac <display_flash_config>

#ifdef CONFIG_VFD
#  ifndef PAGE_SIZE
#   define PAGE_SIZE 4096
#  endif
	/*
	 * reserve memory for VFD display (always full pages)
	 */
	/* armboot_real_end is defined in the board-specific linker script */
	addr = (_armboot_real_end + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
	size = vfd_setmem (addr);
	gd->fb_base = addr;
	/* round to the next page boundary */
	addr += size;
	addr = (addr + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
	mem_malloc_init (addr);
#else
	/* armboot_real_end is defined in the board-specific linker script */
	mem_malloc_init (_armboot_real_end);
 3f00c6c:	e59f3118 	ldr	r3, [pc, #118]	; 3f00d8c <start_armboot+0x1b0>
 3f00c70:	e5930000 	ldr	r0, [r3]
 3f00c74:	ebffff5a 	bl	3f009e4 <mem_malloc_init>
#endif /* CONFIG_VFD */

#if (CONFIG_COMMANDS & CFG_CMD_NAND)
	puts ("NAND:");
 3f00c78:	e59f0110 	ldr	r0, [pc, #110]	; 3f00d90 <start_armboot+0x1b4>
 3f00c7c:	eb002ee3 	bl	3f0c810 <puts>
	nand_init();		/* go init the NAND */
 3f00c80:	eb004b31 	bl	3f1394c <nand_init>
#if defined(CFG_ENV_IS_IN_NAND)
	env_init();		/* initialize environment */
 3f00c84:	eb0034c1 	bl	3f0df90 <env_init>
#endif
#endif

#ifdef CONFIG_HAS_DATAFLASH
	AT91F_DataflashInit();
	dataflash_print_info();
#endif

	/* initialize environment */
	env_relocate ();
 3f00c88:	eb003494 	bl	3f0dee0 <env_relocate>

#ifdef CONFIG_VFD
	/* must do this after the framebuffer is allocated */
	drv_vfd_init();
#endif

	/* IP Address */
	bd_data.bi_ip_addr = getenv_IPaddr ("ipaddr");
 3f00c8c:	e59f0100 	ldr	r0, [pc, #100]	; 3f00d94 <start_armboot+0x1b8>

	/* MAC Address */
	{
		int i;
		ulong reg;
		char *s, *e;
		uchar tmp[64];

		i = getenv_r ("ethaddr", tmp, sizeof (tmp));
		s = (i > 0) ? tmp : NULL;

		for (reg = 0; reg < 6; ++reg) {
 3f00c90:	e3a06000 	mov	r6, #0	; 0x0
 3f00c94:	eb000449 	bl	3f01dc0 <getenv_IPaddr>
 3f00c98:	e24b40a0 	sub	r4, r11, #160	; 0xa0
 3f00c9c:	e1a01004 	mov	r1, r4
 3f00ca0:	e1a03000 	mov	r3, r0
 3f00ca4:	e59f00ec 	ldr	r0, [pc, #ec]	; 3f00d98 <start_armboot+0x1bc>
 3f00ca8:	e3a02040 	mov	r2, #64	; 0x40
 3f00cac:	e50b305c 	str	r3, [r11, -#92]
 3f00cb0:	eb002d0a 	bl	3f0c0e0 <getenv_r>
 3f00cb4:	e1500006 	cmp	r0, r6
 3f00cb8:	d1a04006 	movle	r4, r6
			bd_data.bi_enetaddr[reg] = s ? simple_strtoul (s, &e, 16) : 0;
 3f00cbc:	e3540000 	cmp	r4, #0	; 0x0
 3f00cc0:	e24b5058 	sub	r5, r11, #88	; 0x58
 3f00cc4:	0a000004 	beq	3f00cdc <start_armboot+0x100>
 3f00cc8:	e1a00004 	mov	r0, r4
 3f00ccc:	e24b10a4 	sub	r1, r11, #164	; 0xa4
 3f00cd0:	e3a02010 	mov	r2, #16	; 0x10
 3f00cd4:	eb003a9a 	bl	3f0f744 <simple_strtoul>
 3f00cd8:	ea000000 	b	3f00ce0 <start_armboot+0x104>
 3f00cdc:	e1a00004 	mov	r0, r4
			if (s)
 3f00ce0:	e3540000 	cmp	r4, #0	; 0x0
 3f00ce4:	e7c50006 	strb	r0, [r5, r6]
 3f00ce8:	0a000004 	beq	3f00d00 <start_armboot+0x124>
				s = (*e) ? e + 1 : e;
 3f00cec:	e51b20a4 	ldr	r2, [r11, -#164]
 3f00cf0:	e5d23000 	ldrb	r3, [r2]
 3f00cf4:	e3530000 	cmp	r3, #0	; 0x0
 3f00cf8:	01a04002 	moveq	r4, r2
 3f00cfc:	12824001 	addne	r4, r2, #1	; 0x1
 3f00d00:	e2866001 	add	r6, r6, #1	; 0x1
 3f00d04:	e3560005 	cmp	r6, #5	; 0x5
 3f00d08:	9affffeb 	bls	3f00cbc <start_armboot+0xe0>
		}
	}

	devices_init ();	/* get the devices list going. */
 3f00d0c:	eb002fde 	bl	3f0cc8c <devices_init>

	jumptable_init ();
 3f00d10:	eb0034e2 	bl	3f0e0a0 <jumptable_init>

	console_init_r ();	/* fully init console as a device */
 3f00d14:	eb002f49 	bl	3f0ca40 <console_init_r>

#if defined(CONFIG_MISC_INIT_R)
	/* miscellaneous platform dependent initialisations */
	misc_init_r ();
#endif

	/* enable exceptions */
	enable_interrupts ();
 3f00d18:	ebfffde0 	bl	3f004a0 <enable_interrupts>

#ifdef CONFIG_DRIVER_CS8900
	cs8900_get_enetaddr (gd->bd->bi_enetaddr);
 3f00d1c:	e5980000 	ldr	r0, [r8]
 3f00d20:	e2800008 	add	r0, r0, #8	; 0x8
 3f00d24:	eb000866 	bl	3f02ec4 <cs8900_get_enetaddr>
#endif

#ifdef CONFIG_DRIVER_SMC91111
	if (getenv ("ethaddr")) {
		smc_set_mac_addr(gd->bd->bi_enetaddr);
	}
#endif

#ifdef CONFIG_DRIVER_LAN91C96
	if (getenv ("ethaddr")) {
		smc_set_mac_addr(gd->bd->bi_enetaddr);
	}
	/* eth_hw_init(); */
#endif /* CONFIG_DRIVER_LAN91C96 */

	/* Initialize from environment */
	if ((s = getenv ("loadaddr")) != NULL) {
 3f00d28:	e59f006c 	ldr	r0, [pc, #6c]	; 3f00d9c <start_armboot+0x1c0>
 3f00d2c:	eb002cca 	bl	3f0c05c <getenv>
 3f00d30:	e3500000 	cmp	r0, #0	; 0x0
 3f00d34:	0a000004 	beq	3f00d4c <start_armboot+0x170>
		load_addr = simple_strtoul (s, NULL, 16);
 3f00d38:	e3a01000 	mov	r1, #0	; 0x0
 3f00d3c:	e3a02010 	mov	r2, #16	; 0x10
 3f00d40:	eb003a7f 	bl	3f0f744 <simple_strtoul>
 3f00d44:	e59f3054 	ldr	r3, [pc, #54]	; 3f00da0 <start_armboot+0x1c4>
 3f00d48:	e5830000 	str	r0, [r3]
	}
#if (CONFIG_COMMANDS & CFG_CMD_NET)
	if ((s = getenv ("bootfile")) != NULL) {
 3f00d4c:	e59f0050 	ldr	r0, [pc, #50]	; 3f00da4 <start_armboot+0x1c8>
 3f00d50:	eb002cc1 	bl	3f0c05c <getenv>
 3f00d54:	e3500000 	cmp	r0, #0	; 0x0
 3f00d58:	0a000003 	beq	3f00d6c <start_armboot+0x190>
		copy_filename (BootFile, s, sizeof (BootFile));
 3f00d5c:	e1a01000 	mov	r1, r0
 3f00d60:	e59f0040 	ldr	r0, [pc, #40]	; 3f00da8 <start_armboot+0x1cc>
 3f00d64:	e3a02080 	mov	r2, #128	; 0x80
 3f00d68:	eb0003b6 	bl	3f01c48 <copy_filename>
	}
#endif	/* CFG_CMD_NET */

#ifdef BOARD_POST_INIT
	board_post_init ();
#endif
	
	display_logo();
 3f00d6c:	eb004b59 	bl	3f13ad8 <display_logo>
	
	board_late_init();
 3f00d70:	eb004aec 	bl	3f13928 <board_late_init>
	
	/* main_loop() can return to retry autoboot, if so just run it again. */
	for (;;) {
		main_loop ();
 3f00d74:	eb0009a5 	bl	3f03410 <main_loop>
 3f00d78:	eafffffd 	b	3f00d74 <start_armboot+0x198>
 3f00d7c:	03f203fc 	mvneqs	r0, #-268435453	; 0xf0000003
 3f00d80:	03f00048 	mvneqs	r0, #72	; 0x48
 3f00d84:	03f00044 	mvneqs	r0, #68	; 0x44
 3f00d88:	03f6a6a8 	mvneqs	r10, #176160768	; 0xa800000
 3f00d8c:	03f00050 	mvneqs	r0, #80	; 0x50
 3f00d90:	03f1aaac 	mvneqs	r10, #704512	; 0xac000
 3f00d94:	03f1aab4 	mvneqs	r10, #737280	; 0xb4000
 3f00d98:	03f1aabc 	mvneqs	r10, #770048	; 0xbc000
 3f00d9c:	03f1aac4 	mvneqs	r10, #802816	; 0xc4000
 3f00da0:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
 3f00da4:	03f1aad0 	mvneqs	r10, #851968	; 0xd0000
 3f00da8:	03f6a6e0 	mvneqs	r10, #234881024	; 0xe000000
	}

	/* NOTREACHED - no way out of command loop except booting */
}
 3f00dac:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f00db0 <hang>:
 3f00db0:	e1a0c00d 	mov	r12, r13
 3f00db4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
//[*]----------------------------------------------------------------------------------------------------[*]
void hang (void)
{
	puts ("### ERROR ### Please RESET the board ###\n");
 3f00db8:	e59f0008 	ldr	r0, [pc, #8]	; 3f00dc8 <hang+0x18>
 3f00dbc:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f00dc0:	eb002e92 	bl	3f0c810 <puts>
	for (;;);
 3f00dc4:	eafffffe 	b	3f00dc4 <hang+0x14>
 3f00dc8:	03f1aadc 	mvneqs	r10, #901120	; 0xdc000
 3f00dcc:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f00dd0 <ArpRequest>:
 3f00dd0:	e1a0c00d 	mov	r12, r13
 3f00dd4:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}

#ifdef ET_DEBUG
	printf("ARP broadcast %d\n", NetArpWaitTry);
#endif
	pkt = NetTxPacket;
 3f00dd8:	e59fa0d0 	ldr	r10, [pc, #d0]	; 3f00eb0 <ArpRequest+0xe0>

	NetSetEther(pkt, NetBcastAddr, PROT_ARP);
 3f00ddc:	e59f10d0 	ldr	r1, [pc, #d0]	; 3f00eb4 <ArpRequest+0xe4>
 3f00de0:	e59a4000 	ldr	r4, [r10]
 3f00de4:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f00de8:	e59f20c8 	ldr	r2, [pc, #c8]	; 3f00eb8 <ArpRequest+0xe8>
 3f00dec:	e1a00004 	mov	r0, r4
 3f00df0:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f00df4:	eb00032c 	bl	3f01aac <NetSetEther>
	pkt += ETHER_HDR_SIZE;
 3f00df8:	e284500e 	add	r5, r4, #14	; 0xe

	arp = (ARP_t *)pkt;

	arp->ar_hrd = htons(ARP_ETHER);
	arp->ar_pro = htons(PROT_IP);
 3f00dfc:	e3a03008 	mov	r3, #8	; 0x8
 3f00e00:	e1c530b2 	strh	r3, [r5, #2]
 3f00e04:	e3a03c01 	mov	r3, #256	; 0x100
 3f00e08:	e1c530b0 	strh	r3, [r5]
	arp->ar_hln = 6;
 3f00e0c:	e3a02006 	mov	r2, #6	; 0x6
 3f00e10:	e5c52004 	strb	r2, [r5, #4]
	arp->ar_pln = 4;
 3f00e14:	e3a04004 	mov	r4, #4	; 0x4
 3f00e18:	e5c54005 	strb	r4, [r5, #5]
	arp->ar_op  = htons(ARPOP_REQUEST);

	memcpy (&arp->ar_data[0], NetOurEther, 6);	/* source ET addr	*/
 3f00e1c:	e2856008 	add	r6, r5, #8	; 0x8
 3f00e20:	e59f1094 	ldr	r1, [pc, #94]	; 3f00ebc <ArpRequest+0xec>
 3f00e24:	e1a00006 	mov	r0, r6
 3f00e28:	e1c530b6 	strh	r3, [r5, #6]
 3f00e2c:	eb0039d5 	bl	3f0f588 <memcpy>

/* write IP *in network byteorder* */
static inline void NetWriteIP(void *to, IPaddr_t ip)
{
	memcpy(to, (void*)&ip, sizeof(ip));
 3f00e30:	e285000e 	add	r0, r5, #14	; 0xe
 3f00e34:	e59f7084 	ldr	r7, [pc, #84]	; 3f00ec0 <ArpRequest+0xf0>
 3f00e38:	e24b1024 	sub	r1, r11, #36	; 0x24
 3f00e3c:	e5973000 	ldr	r3, [r7]
 3f00e40:	e1a02004 	mov	r2, r4
 3f00e44:	e50b3024 	str	r3, [r11, -#36]
 3f00e48:	eb0039ce 	bl	3f0f588 <memcpy>
	NetWriteIP((uchar*)&arp->ar_data[6], NetOurIP);	/* source IP addr	*/
	for (i=10; i<16; ++i) {
 3f00e4c:	e3a0200a 	mov	r2, #10	; 0xa
		arp->ar_data[i] = 0;			/* dest ET addr = 0	*/
 3f00e50:	e3a03000 	mov	r3, #0	; 0x0
 3f00e54:	e7c63002 	strb	r3, [r6, r2]
 3f00e58:	e2822001 	add	r2, r2, #1	; 0x1
 3f00e5c:	e352000f 	cmp	r2, #15	; 0xf
 3f00e60:	dafffffa 	ble	3f00e50 <ArpRequest+0x80>
	}

	if((NetArpWaitPacketIP & NetOurSubnetMask) != (NetOurIP & NetOurSubnetMask)) {
 3f00e64:	e59f3058 	ldr	r3, [pc, #58]	; 3f00ec4 <ArpRequest+0xf4>
 3f00e68:	e59f2058 	ldr	r2, [pc, #58]	; 3f00ec8 <ArpRequest+0xf8>
 3f00e6c:	e5930000 	ldr	r0, [r3]
 3f00e70:	e5922000 	ldr	r2, [r2]
 3f00e74:	e5973000 	ldr	r3, [r7]
 3f00e78:	e0001002 	and	r1, r0, r2
 3f00e7c:	e0033002 	and	r3, r3, r2
 3f00e80:	e1510003 	cmp	r1, r3
 3f00e84:	0a000013 	beq	3f00ed8 <ArpRequest+0x108>
	    if (NetOurGatewayIP == 0) {
 3f00e88:	e59f403c 	ldr	r4, [pc, #3c]	; 3f00ecc <ArpRequest+0xfc>
 3f00e8c:	e5943000 	ldr	r3, [r4]
 3f00e90:	e3530000 	cmp	r3, #0	; 0x0
 3f00e94:	1a000001 	bne	3f00ea0 <ArpRequest+0xd0>
		puts ("## Warning: gatewayip needed but not set\n");
 3f00e98:	e59f0030 	ldr	r0, [pc, #30]	; 3f00ed0 <ArpRequest+0x100>
 3f00e9c:	eb002e5b 	bl	3f0c810 <puts>
	    }
	    NetArpWaitReplyIP = NetOurGatewayIP;
 3f00ea0:	e59f202c 	ldr	r2, [pc, #2c]	; 3f00ed4 <ArpRequest+0x104>
 3f00ea4:	e5943000 	ldr	r3, [r4]
 3f00ea8:	e5823000 	str	r3, [r2]
	} else
 3f00eac:	ea00000b 	b	3f00ee0 <ArpRequest+0x110>
 3f00eb0:	03f204c4 	mvneqs	r0, #-1006632960	; 0xc4000000
 3f00eb4:	03f204b8 	mvneqs	r0, #-1207959552	; 0xb8000000
 3f00eb8:	00000806 	andeq	r0, r0, r6, lsl #16
 3f00ebc:	03f6a6b0 	mvneqs	r10, #184549376	; 0xb000000
 3f00ec0:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
 3f00ec4:	03f6c590 	mvneqs	r12, #603979776	; 0x24000000
 3f00ec8:	03f20424 	mvneqs	r0, #603979776	; 0x24000000
 3f00ecc:	03f20428 	mvneqs	r0, #671088640	; 0x28000000
 3f00ed0:	03f1ab08 	mvneqs	r10, #8192	; 0x2000
 3f00ed4:	03f6c594 	mvneqs	r12, #620756992	; 0x25000000
	    NetArpWaitReplyIP = NetArpWaitPacketIP;
 3f00ed8:	e59f302c 	ldr	r3, [pc, #2c]	; 3f00f0c <ArpRequest+0x13c>
 3f00edc:	e5830000 	str	r0, [r3]

/* write IP *in network byteorder* */
static inline void NetWriteIP(void *to, IPaddr_t ip)
{
	memcpy(to, (void*)&ip, sizeof(ip));
 3f00ee0:	e2850018 	add	r0, r5, #24	; 0x18
 3f00ee4:	e59f3020 	ldr	r3, [pc, #20]	; 3f00f0c <ArpRequest+0x13c>
 3f00ee8:	e24b1028 	sub	r1, r11, #40	; 0x28
 3f00eec:	e5933000 	ldr	r3, [r3]
 3f00ef0:	e3a02004 	mov	r2, #4	; 0x4
 3f00ef4:	e50b3028 	str	r3, [r11, -#40]
 3f00ef8:	eb0039a2 	bl	3f0f588 <memcpy>

	NetWriteIP((uchar*)&arp->ar_data[16], NetArpWaitReplyIP);
	(void) eth_send(NetTxPacket, ETHER_HDR_SIZE + ARP_HDR_SIZE);
 3f00efc:	e59a0000 	ldr	r0, [r10]
 3f00f00:	e3a0102a 	mov	r1, #42	; 0x2a
 3f00f04:	eb0008d1 	bl	3f03250 <eth_send>
 3f00f08:	ea000000 	b	3f00f10 <ArpRequest+0x140>
 3f00f0c:	03f6c594 	mvneqs	r12, #620756992	; 0x25000000
}
 3f00f10:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f00f14 <ArpTimeoutCheck>:
 3f00f14:	e1a0c00d 	mov	r12, r13
 3f00f18:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}

void ArpTimeoutCheck(void)
{
	ulong t;

	if (!NetArpWaitPacketIP)
 3f00f1c:	e59f3068 	ldr	r3, [pc, #68]	; 3f00f8c <ArpTimeoutCheck+0x78>
 3f00f20:	e5933000 	ldr	r3, [r3]
 3f00f24:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f00f28:	e3530000 	cmp	r3, #0	; 0x0
 3f00f2c:	091ba810 	ldmeqdb	r11, {r4, r11, r13, r15}
		return;

	t = get_timer(0);
 3f00f30:	e3a00000 	mov	r0, #0	; 0x0
 3f00f34:	ebfffe24 	bl	3f007cc <get_timer>

	/* check for arp timeout */
	if ((t - NetArpWaitTimerStart) > ARP_TIMEOUT * CFG_HZ) {
 3f00f38:	e59f1050 	ldr	r1, [pc, #50]	; 3f00f90 <ArpTimeoutCheck+0x7c>
 3f00f3c:	e5913000 	ldr	r3, [r1]
 3f00f40:	e59f204c 	ldr	r2, [pc, #4c]	; 3f00f94 <ArpTimeoutCheck+0x80>
 3f00f44:	e0633000 	rsb	r3, r3, r0
 3f00f48:	e1530002 	cmp	r3, r2
 3f00f4c:	991ba810 	ldmlsdb	r11, {r4, r11, r13, r15}
		NetArpWaitTry++;
 3f00f50:	e59f4040 	ldr	r4, [pc, #40]	; 3f00f98 <ArpTimeoutCheck+0x84>
 3f00f54:	e5943000 	ldr	r3, [r4]
 3f00f58:	e2833001 	add	r3, r3, #1	; 0x1

		if (NetArpWaitTry >= ARP_TIMEOUT_COUNT) {
 3f00f5c:	e3530004 	cmp	r3, #4	; 0x4
 3f00f60:	e5843000 	str	r3, [r4]
 3f00f64:	da000005 	ble	3f00f80 <ArpTimeoutCheck+0x6c>
			puts ("\nARP Retry count exceeded; starting again\n");
 3f00f68:	e59f002c 	ldr	r0, [pc, #2c]	; 3f00f9c <ArpTimeoutCheck+0x88>
 3f00f6c:	eb002e27 	bl	3f0c810 <puts>
			NetArpWaitTry = 0;
 3f00f70:	e3a03000 	mov	r3, #0	; 0x0
 3f00f74:	e5843000 	str	r3, [r4]
			NetStartAgain();
 3f00f78:	eb0000cd 	bl	3f012b4 <NetStartAgain>
		} else {
 3f00f7c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
			NetArpWaitTimerStart = t;
 3f00f80:	e5810000 	str	r0, [r1]
			ArpRequest();
 3f00f84:	ebffff91 	bl	3f00dd0 <ArpRequest>
		}
	}
}
 3f00f88:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f00f8c:	03f6c590 	mvneqs	r12, #603979776	; 0x24000000
 3f00f90:	03f6cbc4 	mvneqs	r12, #200704	; 0x31000
 3f00f94:	02328000 	eoreqs	r8, r2, #0	; 0x0
 3f00f98:	03f6cbc8 	mvneqs	r12, #204800	; 0x32000
 3f00f9c:	03f1ab34 	mvneqs	r10, #53248	; 0xd000

03f00fa0 <NetLoop>:
 3f00fa0:	e1a0c00d 	mov	r12, r13
 3f00fa4:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}

/**********************************************************************/
/*
 *	Main network processing loop.
 */

int
NetLoop(proto_t protocol)
{
	DECLARE_GLOBAL_DATA_PTR;

	bd_t *bd = gd->bd;

#ifdef CONFIG_NET_MULTI
	NetRestarted = 0;
	NetDevExists = 0;
#endif

	/* XXX problem with bss workaround */
	NetArpWaitPacketMAC = NULL;
 3f00fa8:	e59f325c 	ldr	r3, [pc, #25c]	; 3f0120c <NetLoop+0x26c>
 3f00fac:	e24cb004 	sub	r11, r12, #4	; 0x4
	NetArpWaitTxPacket = NULL;
 3f00fb0:	e59fc258 	ldr	r12, [pc, #258]	; 3f01210 <NetLoop+0x270>
	NetArpWaitPacketIP = 0;
	NetArpWaitReplyIP = 0;
	NetArpWaitTxPacket = NULL;
	NetTxPacket = NULL;
 3f00fb4:	e59fe258 	ldr	r14, [pc, #258]	; 3f01214 <NetLoop+0x274>
 3f00fb8:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f00fbc:	e5987000 	ldr	r7, [r8]
 3f00fc0:	e3a02000 	mov	r2, #0	; 0x0
 3f00fc4:	e5832000 	str	r2, [r3]
 3f00fc8:	e59f3248 	ldr	r3, [pc, #248]	; 3f01218 <NetLoop+0x278>
 3f00fcc:	e5832000 	str	r2, [r3]
 3f00fd0:	e59f3244 	ldr	r3, [pc, #244]	; 3f0121c <NetLoop+0x27c>
 3f00fd4:	e1a06000 	mov	r6, r0
 3f00fd8:	e5832000 	str	r2, [r3]

	if (!NetTxPacket) {
		int	i;

		/*
		 *	Setup packet buffers, aligned correctly.
		 */
		NetTxPacket = &PktBuf[0] + (PKTALIGN - 1);
		NetTxPacket -= (ulong)NetTxPacket % PKTALIGN;
		for (i = 0; i < PKTBUFSRX; i++) {
 3f00fdc:	e1a01002 	mov	r1, r2
 3f00fe0:	e59f3238 	ldr	r3, [pc, #238]	; 3f01220 <NetLoop+0x280>
 3f00fe4:	e3a00c06 	mov	r0, #1536	; 0x600
 3f00fe8:	e58c2000 	str	r2, [r12]
 3f00fec:	e203201f 	and	r2, r3, #31	; 0x1f
 3f00ff0:	e0623003 	rsb	r3, r2, r3
 3f00ff4:	e58e3000 	str	r3, [r14]
			NetRxPackets[i] = NetTxPacket + (i+1)*PKTSIZE_ALIGN;
 3f00ff8:	e59e3000 	ldr	r3, [r14]
 3f00ffc:	e59f2220 	ldr	r2, [pc, #220]	; 3f01224 <NetLoop+0x284>
 3f01000:	e0833000 	add	r3, r3, r0
 3f01004:	e2800c06 	add	r0, r0, #1536	; 0x600
 3f01008:	e7823101 	str	r3, [r2, r1, lsl #2]
 3f0100c:	e2811001 	add	r1, r1, #1	; 0x1
 3f01010:	e3510003 	cmp	r1, #3	; 0x3
 3f01014:	dafffff7 	ble	3f00ff8 <NetLoop+0x58>
		}

	}

	if (!NetArpWaitTxPacket) {
 3f01018:	e59c1000 	ldr	r1, [r12]
 3f0101c:	e3510000 	cmp	r1, #0	; 0x0
 3f01020:	1a000005 	bne	3f0103c <NetLoop+0x9c>
		NetArpWaitTxPacket = &NetArpWaitPacketBuf[0] + (PKTALIGN - 1);
 3f01024:	e59f31fc 	ldr	r3, [pc, #1fc]	; 3f01228 <NetLoop+0x288>
		NetArpWaitTxPacket -= (ulong)NetArpWaitTxPacket % PKTALIGN;
 3f01028:	e203201f 	and	r2, r3, #31	; 0x1f
 3f0102c:	e0623003 	rsb	r3, r2, r3
 3f01030:	e58c3000 	str	r3, [r12]
		NetArpWaitTxPacketSize = 0;
 3f01034:	e59f31f0 	ldr	r3, [pc, #1f0]	; 3f0122c <NetLoop+0x28c>
 3f01038:	e5831000 	str	r1, [r3]
	}

	eth_halt();
 3f0103c:	eb00081c 	bl	3f030b4 <eth_halt>
	if(eth_init(bd) < 0)
 3f01040:	e1a00007 	mov	r0, r7
 3f01044:	eb000824 	bl	3f030dc <eth_init>
 3f01048:	e3500000 	cmp	r0, #0	; 0x0
 3f0104c:	ba00008a 	blt	3f0127c <NetLoop+0x2dc>
	    return(-1);

restart:
#ifdef CONFIG_NET_MULTI
	memcpy (NetOurEther, eth_get_dev()->enetaddr, 6);
#else
	memcpy (NetOurEther, bd->bi_enetaddr, 6);
 3f01050:	e2871008 	add	r1, r7, #8	; 0x8
 3f01054:	e59f01d4 	ldr	r0, [pc, #1d4]	; 3f01230 <NetLoop+0x290>
 3f01058:	e3a02006 	mov	r2, #6	; 0x6
 3f0105c:	eb003949 	bl	3f0f588 <memcpy>
#endif

	NetState = NETLOOP_CONTINUE;

	/*
	 *	Start the ball rolling with the given start function.  From
	 *	here on, this code is a state machine driven by received
	 *	packets and timer events.
	 */

	switch (protocol) {
 3f01060:	e3560001 	cmp	r6, #1	; 0x1
 3f01064:	e59fa1c8 	ldr	r10, [pc, #1c8]	; 3f01234 <NetLoop+0x294>
 3f01068:	e3a03001 	mov	r3, #1	; 0x1
 3f0106c:	e58a3000 	str	r3, [r10]
 3f01070:	9a000012 	bls	3f010c0 <NetLoop+0x120>
 3f01074:	e3560003 	cmp	r6, #3	; 0x3
 3f01078:	1a000015 	bne	3f010d4 <NetLoop+0x134>

/* copy IP */
static inline void NetCopyIP(void *to, void *from)
{
	memcpy(to, from, sizeof(IPaddr_t));
 3f0107c:	e2871004 	add	r1, r7, #4	; 0x4
 3f01080:	e59f01b0 	ldr	r0, [pc, #1b0]	; 3f01238 <NetLoop+0x298>
 3f01084:	e3a02004 	mov	r2, #4	; 0x4
 3f01088:	eb00393e 	bl	3f0f588 <memcpy>
#if (CONFIG_COMMANDS & CFG_CMD_PING)
	case PING:
#endif
	case TFTP:
		NetCopyIP(&NetOurIP, &bd->bi_ip_addr);
		NetOurGatewayIP = getenv_IPaddr ("gatewayip");
 3f0108c:	e59f01a8 	ldr	r0, [pc, #1a8]	; 3f0123c <NetLoop+0x29c>
 3f01090:	eb00034a 	bl	3f01dc0 <getenv_IPaddr>
 3f01094:	e59f31a4 	ldr	r3, [pc, #1a4]	; 3f01240 <NetLoop+0x2a0>
 3f01098:	e5830000 	str	r0, [r3]
		NetOurSubnetMask= getenv_IPaddr ("netmask");
 3f0109c:	e59f01a0 	ldr	r0, [pc, #1a0]	; 3f01244 <NetLoop+0x2a4>
 3f010a0:	eb000346 	bl	3f01dc0 <getenv_IPaddr>
 3f010a4:	e59f319c 	ldr	r3, [pc, #19c]	; 3f01248 <NetLoop+0x2a8>
 3f010a8:	e5830000 	str	r0, [r3]

		switch (protocol) {
		case TFTP:
			NetServerIP = getenv_IPaddr ("serverip");
 3f010ac:	e59f0198 	ldr	r0, [pc, #198]	; 3f0124c <NetLoop+0x2ac>
 3f010b0:	eb000342 	bl	3f01dc0 <getenv_IPaddr>
 3f010b4:	e59f3194 	ldr	r3, [pc, #194]	; 3f01250 <NetLoop+0x2b0>
 3f010b8:	e5830000 	str	r0, [r3]
			break;
#if (CONFIG_COMMANDS & CFG_CMD_PING)
		case PING:
			/* nothing */
			break;
#endif
		default:
			break;
		}

		break;
 3f010bc:	ea000004 	b	3f010d4 <NetLoop+0x134>
	case BOOTP:
	case RARP:
		/*
		 * initialize our IP addr to 0 in order to accept ANY
		 * IP addr assigned to us by the BOOTP / RARP server
		 */
		NetOurIP = 0;
 3f010c0:	e59f3170 	ldr	r3, [pc, #170]	; 3f01238 <NetLoop+0x298>
 3f010c4:	e3a02000 	mov	r2, #0	; 0x0
 3f010c8:	e5832000 	str	r2, [r3]
		NetServerIP = 0;
 3f010cc:	e59f317c 	ldr	r3, [pc, #17c]	; 3f01250 <NetLoop+0x2b0>
 3f010d0:	e5832000 	str	r2, [r3]
		break;
	default:
		break;
	}

	switch (net_check_prereq (protocol)) {
 3f010d4:	e1a00006 	mov	r0, r6
 3f010d8:	eb000229 	bl	3f01984 <net_check_prereq>
 3f010dc:	e3500000 	cmp	r0, #0	; 0x0
 3f010e0:	0a000002 	beq	3f010f0 <NetLoop+0x150>
 3f010e4:	e3500001 	cmp	r0, #1	; 0x1
 3f010e8:	1a000011 	bne	3f01134 <NetLoop+0x194>
	case 1:
		/* network not configured */
		return (-1);
 3f010ec:	ea000062 	b	3f0127c <NetLoop+0x2dc>

#ifdef CONFIG_NET_MULTI
	case 2:
		/* network device not configured */
		break;
#endif /* CONFIG_NET_MULTI */

	case 0:
#ifdef CONFIG_NET_MULTI
		NetDevExists = 1;
#endif
		switch (protocol) {
 3f010f0:	e3560001 	cmp	r6, #1	; 0x1
 3f010f4:	0a000008 	beq	3f0111c <NetLoop+0x17c>
 3f010f8:	3a000003 	bcc	3f0110c <NetLoop+0x16c>
 3f010fc:	e3560003 	cmp	r6, #3	; 0x3
 3f01100:	1a000008 	bne	3f01128 <NetLoop+0x188>
		case TFTP:
			/* always use ARP to get server ethernet address */
			TftpStart();
 3f01104:	eb000454 	bl	3f0225c <TftpStart>
			break;
 3f01108:	ea000006 	b	3f01128 <NetLoop+0x188>

#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
		case DHCP:
			/* Start with a clean slate... */
			NetOurIP = 0;
			NetServerIP = 0;
			DhcpRequest();		/* Basically same as BOOTP */
			break;
#endif /* CFG_CMD_DHCP */

		case BOOTP:
			BootpTry = 0;
 3f0110c:	e59f3140 	ldr	r3, [pc, #140]	; 3f01254 <NetLoop+0x2b4>
 3f01110:	e5830000 	str	r0, [r3]
			BootpRequest ();
 3f01114:	eb000648 	bl	3f02a3c <BootpRequest>
			break;
 3f01118:	ea000002 	b	3f01128 <NetLoop+0x188>

		case RARP:
			RarpTry = 0;
 3f0111c:	e59f3134 	ldr	r3, [pc, #134]	; 3f01258 <NetLoop+0x2b8>
 3f01120:	e5830000 	str	r0, [r3]
			RarpRequest ();
 3f01124:	eb0006dc 	bl	3f02c9c <RarpRequest>
			break;
#if (CONFIG_COMMANDS & CFG_CMD_PING)
		case PING:
			PingStart();
			break;
#endif
		default:
			break;
		}

		NetBootFileXferSize = 0;
 3f01128:	e59f212c 	ldr	r2, [pc, #12c]	; 3f0125c <NetLoop+0x2bc>
 3f0112c:	e3a03000 	mov	r3, #0	; 0x0
 3f01130:	e5823000 	str	r3, [r2]
		break;
	}

#if defined(CONFIG_MII) || (CONFIG_COMMANDS & CFG_CMD_MII)
#if defined(CFG_FAULT_ECHO_LINK_DOWN) && defined(CONFIG_STATUS_LED) && defined(STATUS_LED_RED)
	/*
	 * Echo the inverted link state to the fault LED.
	 */
	if(miiphy_link(CFG_FAULT_MII_ADDR)) {
		status_led_set (STATUS_LED_RED, STATUS_LED_OFF);
	} else {
		status_led_set (STATUS_LED_RED, STATUS_LED_ON);
	}
#endif /* CFG_FAULT_ECHO_LINK_DOWN, ... */
#endif /* CONFIG_MII, ... */

	/*
	 *	Main packet reception loop.  Loop receiving packets until
	 *	someone sets `NetQuit'.
	 */
	for (;;) {
		WATCHDOG_RESET();
#ifdef CONFIG_SHOW_ACTIVITY
		{
			extern void show_activity(int arg);
			show_activity(1);
		}
#endif
		/*
		 *	Check the ethernet for a new packet.  The ethernet
		 *	receive routine will process it.
		 */
			eth_rx();
 3f01134:	eb00081e 	bl	3f031b4 <eth_rx>

		/*
		 *	Abort if ctrl-c was pressed.
		 */
		if (ctrlc()) {
 3f01138:	eb002ddb 	bl	3f0c8ac <ctrlc>
 3f0113c:	e2505000 	subs	r5, r0, #0	; 0x0
 3f01140:	0a000003 	beq	3f01154 <NetLoop+0x1b4>
			eth_halt();
 3f01144:	eb0007da 	bl	3f030b4 <eth_halt>
			printf("\nAbort\n");
 3f01148:	e59f0110 	ldr	r0, [pc, #110]	; 3f01260 <NetLoop+0x2c0>
 3f0114c:	eb002dbc 	bl	3f0c844 <printf>
			return (-1);
 3f01150:	ea000049 	b	3f0127c <NetLoop+0x2dc>
		}

		ArpTimeoutCheck();

		/*
		 *	Check for a timeout, and run the timeout handler
		 *	if we have one.
		 */
		if (timeHandler && ((get_timer(0) - timeStart) > timeDelta)) {
 3f01154:	e59f4108 	ldr	r4, [pc, #108]	; 3f01264 <NetLoop+0x2c4>
 3f01158:	ebffff6d 	bl	3f00f14 <ArpTimeoutCheck>
 3f0115c:	e5943000 	ldr	r3, [r4]
 3f01160:	e3530000 	cmp	r3, #0	; 0x0
 3f01164:	0a00000c 	beq	3f0119c <NetLoop+0x1fc>
 3f01168:	e1a00005 	mov	r0, r5
 3f0116c:	ebfffd96 	bl	3f007cc <get_timer>
 3f01170:	e59f30f0 	ldr	r3, [pc, #f0]	; 3f01268 <NetLoop+0x2c8>
 3f01174:	e59f20f0 	ldr	r2, [pc, #f0]	; 3f0126c <NetLoop+0x2cc>
 3f01178:	e5933000 	ldr	r3, [r3]
 3f0117c:	e5922000 	ldr	r2, [r2]
 3f01180:	e0630000 	rsb	r0, r3, r0
 3f01184:	e1500002 	cmp	r0, r2
 3f01188:	9a000003 	bls	3f0119c <NetLoop+0x1fc>
			thand_f *x;

#if defined(CONFIG_MII) || (CONFIG_COMMANDS & CFG_CMD_MII)
#if defined(CFG_FAULT_ECHO_LINK_DOWN) && defined(CONFIG_STATUS_LED) && defined(STATUS_LED_RED)
			/*
			 * Echo the inverted link state to the fault LED.
			 */
			if(miiphy_link(CFG_FAULT_MII_ADDR)) {
				status_led_set (STATUS_LED_RED, STATUS_LED_OFF);
			} else {
				status_led_set (STATUS_LED_RED, STATUS_LED_ON);
			}
#endif /* CFG_FAULT_ECHO_LINK_DOWN, ... */
#endif /* CONFIG_MII, ... */
			x = timeHandler;
 3f0118c:	e5943000 	ldr	r3, [r4]
			timeHandler = (thand_f *)0;
 3f01190:	e5845000 	str	r5, [r4]
			(*x)();
 3f01194:	e1a0e00f 	mov	r14, r15
 3f01198:	e1a0f003 	mov	r15, r3
		}


		switch (NetState) {
 3f0119c:	e59a3000 	ldr	r3, [r10]
 3f011a0:	e3530003 	cmp	r3, #3	; 0x3
 3f011a4:	0a000006 	beq	3f011c4 <NetLoop+0x224>
 3f011a8:	ca000002 	bgt	3f011b8 <NetLoop+0x218>
 3f011ac:	e3530002 	cmp	r3, #2	; 0x2
 3f011b0:	0affffa6 	beq	3f01050 <NetLoop+0xb0>
 3f011b4:	eaffffde 	b	3f01134 <NetLoop+0x194>
 3f011b8:	e3530004 	cmp	r3, #4	; 0x4
 3f011bc:	0a00002e 	beq	3f0127c <NetLoop+0x2dc>
 3f011c0:	eaffffdb 	b	3f01134 <NetLoop+0x194>

		case NETLOOP_RESTART:
#ifdef CONFIG_NET_MULTI
			NetRestarted = 1;
#endif
			goto restart;

		case NETLOOP_SUCCESS:
			if (NetBootFileXferSize > 0) {
 3f011c4:	e59f5090 	ldr	r5, [pc, #90]	; 3f0125c <NetLoop+0x2bc>
 3f011c8:	e5951000 	ldr	r1, [r5]
 3f011cc:	e3510000 	cmp	r1, #0	; 0x0
 3f011d0:	0a00000a 	beq	3f01200 <NetLoop+0x260>
				char buf[10];
				printf("Bytes transferred = %ld (%lx hex)\n",
 3f011d4:	e59f0094 	ldr	r0, [pc, #94]	; 3f01270 <NetLoop+0x2d0>
 3f011d8:	e1a02001 	mov	r2, r1
 3f011dc:	eb002d98 	bl	3f0c844 <printf>
					NetBootFileXferSize,
					NetBootFileXferSize);
				sprintf(buf, "%lx", NetBootFileXferSize);
 3f011e0:	e59f108c 	ldr	r1, [pc, #8c]	; 3f01274 <NetLoop+0x2d4>
 3f011e4:	e24b402c 	sub	r4, r11, #44	; 0x2c
 3f011e8:	e5952000 	ldr	r2, [r5]
 3f011ec:	e1a00004 	mov	r0, r4
 3f011f0:	eb003b91 	bl	3f1003c <sprintf>
				setenv("filesize", buf);
 3f011f4:	e59f007c 	ldr	r0, [pc, #7c]	; 3f01278 <NetLoop+0x2d8>
 3f011f8:	e1a01004 	mov	r1, r4
 3f011fc:	eb002b75 	bl	3f0bfd8 <setenv>
			}
			eth_halt();
 3f01200:	eb0007ab 	bl	3f030b4 <eth_halt>
			return NetBootFileXferSize;
 3f01204:	e5950000 	ldr	r0, [r5]
 3f01208:	ea00001c 	b	3f01280 <NetLoop+0x2e0>
 3f0120c:	03f6c598 	mvneqs	r12, #637534208	; 0x26000000
 3f01210:	03f6c59c 	mvneqs	r12, #654311424	; 0x27000000
 3f01214:	03f204c4 	mvneqs	r0, #-1006632960	; 0xc4000000
 3f01218:	03f6c590 	mvneqs	r12, #603979776	; 0x24000000
 3f0121c:	03f6c594 	mvneqs	r12, #620756992	; 0x25000000
 3f01220:	03f6a77f 	mvneqs	r10, #33292288	; 0x1fc0000
 3f01224:	03f6a6c0 	mvneqs	r10, #201326592	; 0xc000000
 3f01228:	03f6c5c3 	mvneqs	r12, #817889280	; 0x30c00000
 3f0122c:	03f6c5a0 	mvneqs	r12, #671088640	; 0x28000000
 3f01230:	03f6a6b0 	mvneqs	r10, #184549376	; 0xb000000
 3f01234:	03f6a6dc 	mvneqs	r10, #230686720	; 0xdc00000
 3f01238:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
 3f0123c:	03f1ab60 	mvneqs	r10, #98304	; 0x18000
 3f01240:	03f20428 	mvneqs	r0, #671088640	; 0x28000000
 3f01244:	03f1ab6c 	mvneqs	r10, #110592	; 0x1b000
 3f01248:	03f20424 	mvneqs	r0, #603979776	; 0x24000000
 3f0124c:	03f1ab74 	mvneqs	r10, #118784	; 0x1d000
 3f01250:	03f6a6bc 	mvneqs	r10, #197132288	; 0xbc00000
 3f01254:	03f6cbfc 	mvneqs	r12, #258048	; 0x3f000
 3f01258:	03f6cc00 	mvneqs	r12, #0	; 0x0
 3f0125c:	03f6a6ac 	mvneqs	r10, #180355072	; 0xac00000
 3f01260:	03f1ab80 	mvneqs	r10, #131072	; 0x20000
 3f01264:	03f6c584 	mvneqs	r12, #553648128	; 0x21000000
 3f01268:	03f6c588 	mvneqs	r12, #570425344	; 0x22000000
 3f0126c:	03f6c58c 	mvneqs	r12, #587202560	; 0x23000000
 3f01270:	03f1ab88 	mvneqs	r10, #139264	; 0x22000
 3f01274:	03f1abac 	mvneqs	r10, #176128	; 0x2b000
 3f01278:	03f1abb0 	mvneqs	r10, #180224	; 0x2c000

		case NETLOOP_FAIL:
			return (-1);
 3f0127c:	e3e00000 	mvn	r0, #0	; 0x0
		}
	}
}
 3f01280:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f01284 <startAgainTimeout>:
 3f01284:	e1a0c00d 	mov	r12, r13
 3f01288:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0128c:	e24cb004 	sub	r11, r12, #4	; 0x4

/**********************************************************************/

static void
startAgainTimeout(void)
{
	NetState = NETLOOP_RESTART;
 3f01290:	e59f2008 	ldr	r2, [pc, #8]	; 3f012a0 <startAgainTimeout+0x1c>
 3f01294:	e3a03002 	mov	r3, #2	; 0x2
 3f01298:	e5823000 	str	r3, [r2]
 3f0129c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f012a0:	03f6a6dc 	mvneqs	r10, #230686720	; 0xdc00000

03f012a4 <startAgainHandler>:
 3f012a4:	e1a0c00d 	mov	r12, r13
 3f012a8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f012ac:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f012b0:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f012b4 <NetStartAgain>:
 3f012b4:	e1a0c00d 	mov	r12, r13
 3f012b8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

static void
startAgainHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len)
{
	/* Totally ignore the packet */
}

void
NetStartAgain(void)
{
#ifndef CONFIG_NET_MULTI
	NetSetTimeout(10 * CFG_HZ, startAgainTimeout);
 3f012bc:	e59f0014 	ldr	r0, [pc, #14]	; 3f012d8 <NetStartAgain+0x24>
 3f012c0:	e59f1014 	ldr	r1, [pc, #14]	; 3f012dc <NetStartAgain+0x28>
 3f012c4:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f012c8:	eb00000c 	bl	3f01300 <NetSetTimeout>
	NetSetHandler(startAgainHandler);
 3f012cc:	e59f000c 	ldr	r0, [pc, #c]	; 3f012e0 <NetStartAgain+0x2c>
 3f012d0:	eb000003 	bl	3f012e4 <NetSetHandler>
 3f012d4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f012d8:	04650000 	streqbt	r0, [r5]
 3f012dc:	03f01284 	mvneqs	r1, #1073741832	; 0x40000008
 3f012e0:	03f012a4 	mvneqs	r1, #1073741834	; 0x4000000a

03f012e4 <NetSetHandler>:
 3f012e4:	e1a0c00d 	mov	r12, r13
 3f012e8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
#else
	DECLARE_GLOBAL_DATA_PTR;

	eth_halt();
	eth_try_another(!NetRestarted);
	eth_init(gd->bd);
	if (NetRestartWrap)
	{
		NetRestartWrap = 0;
		if (NetDevExists)
		{
			NetSetTimeout(10 * CFG_HZ, startAgainTimeout);
			NetSetHandler(startAgainHandler);
		}
		else
		{
			NetState = NETLOOP_FAIL;
		}
	}
	else
	{
		NetState = NETLOOP_RESTART;
	}
#endif
}

/**********************************************************************/
/*
 *	Miscelaneous bits.
 */

void
NetSetHandler(rxhand_f * f)
{
	packetHandler = f;
 3f012ec:	e59f3008 	ldr	r3, [pc, #8]	; 3f012fc <NetSetHandler+0x18>
 3f012f0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f012f4:	e5830000 	str	r0, [r3]
 3f012f8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f012fc:	03f6c580 	mvneqs	r12, #536870912	; 0x20000000

03f01300 <NetSetTimeout>:
 3f01300:	e1a0c00d 	mov	r12, r13
 3f01304:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f01308:	e24cb004 	sub	r11, r12, #4	; 0x4
}


void
NetSetTimeout(int iv, thand_f * f)
{
	if (iv == 0) {
 3f0130c:	e2504000 	subs	r4, r0, #0	; 0x0
		timeHandler = (thand_f *)0;
 3f01310:	059f3028 	ldreq	r3, [pc, #28]	; 3f01340 <NetSetTimeout+0x40>
 3f01314:	05834000 	streq	r4, [r3]
	} else {
 3f01318:	091ba810 	ldmeqdb	r11, {r4, r11, r13, r15}
		timeHandler = f;
 3f0131c:	e59f301c 	ldr	r3, [pc, #1c]	; 3f01340 <NetSetTimeout+0x40>
		timeStart = get_timer(0);
 3f01320:	e3a00000 	mov	r0, #0	; 0x0
 3f01324:	e5831000 	str	r1, [r3]
 3f01328:	ebfffd27 	bl	3f007cc <get_timer>
 3f0132c:	e59f3010 	ldr	r3, [pc, #10]	; 3f01344 <NetSetTimeout+0x44>
 3f01330:	e5830000 	str	r0, [r3]
		timeDelta = iv;
 3f01334:	e59f300c 	ldr	r3, [pc, #c]	; 3f01348 <NetSetTimeout+0x48>
 3f01338:	e5834000 	str	r4, [r3]
	}
 3f0133c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f01340:	03f6c584 	mvneqs	r12, #553648128	; 0x21000000
 3f01344:	03f6c588 	mvneqs	r12, #570425344	; 0x22000000
 3f01348:	03f6c58c 	mvneqs	r12, #587202560	; 0x23000000

03f0134c <NetSendPacket>:
 3f0134c:	e1a0c00d 	mov	r12, r13
 3f01350:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f01354:	e24cb004 	sub	r11, r12, #4	; 0x4
}


void
NetSendPacket(volatile uchar * pkt, int len)
{
	(void) eth_send(pkt, len);
 3f01358:	eb0007bc 	bl	3f03250 <eth_send>
 3f0135c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f01360 <NetSendUDPPacket>:
 3f01360:	e1a0c00d 	mov	r12, r13
 3f01364:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f01368:	e24cb004 	sub	r11, r12, #4	; 0x4
}

int
NetSendUDPPacket(uchar *ether, IPaddr_t dest, int dport, int sport, int len)
{
	/* convert to new style broadcast */
	if (dest == 0)
 3f0136c:	e3510000 	cmp	r1, #0	; 0x0
 3f01370:	e1a09002 	mov	r9, r2
		dest = 0xFFFFFFFF;

	/* if broadcast, make the ether address a broadcast and don't do ARP */
	if (dest == 0xFFFFFFFF)
		ether = NetBcastAddr;

	/* if MAC address was not discovered yet, save the packet and do an ARP request */
	if (memcmp(ether, NetEtherNullAddr, 6) == 0) {
 3f01374:	e3a02006 	mov	r2, #6	; 0x6
 3f01378:	11a06001 	movne	r6, r1
 3f0137c:	03e06000 	mvneq	r6, #0	; 0x0
 3f01380:	e3760001 	cmn	r6, #1	; 0x1
 3f01384:	e59fc06c 	ldr	r12, [pc, #6c]	; 3f013f8 <NetSendUDPPacket+0x98>
 3f01388:	e1a0a003 	mov	r10, r3
 3f0138c:	e59f1068 	ldr	r1, [pc, #68]	; 3f013fc <NetSendUDPPacket+0x9c>
 3f01390:	11a05000 	movne	r5, r0
 3f01394:	01a0500c 	moveq	r5, r12
 3f01398:	e1a00005 	mov	r0, r5
 3f0139c:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f013a0:	e59b7004 	ldr	r7, [r11, #4]
 3f013a4:	eb00389e 	bl	3f0f624 <memcmp>
 3f013a8:	e3500000 	cmp	r0, #0	; 0x0
 3f013ac:	e50b0028 	str	r0, [r11, -#40]
 3f013b0:	0a000013 	beq	3f01404 <NetSendUDPPacket+0xa4>

#ifdef ET_DEBUG
		printf("sending ARP for %08lx\n", dest);
#endif

		NetArpWaitPacketIP = dest;
		NetArpWaitPacketMAC = ether;
		NetSetEther (NetArpWaitTxPacket, NetArpWaitPacketMAC, PROT_IP);
		NetSetIP (NetArpWaitTxPacket + ETHER_HDR_SIZE, dest, dport, sport, len);
		memcpy(NetArpWaitTxPacket + ETHER_HDR_SIZE + IP_HDR_SIZE,
			(uchar *)NetTxPacket + ETHER_HDR_SIZE + IP_HDR_SIZE, len);

		/* size of the waiting packet */
		NetArpWaitTxPacketSize = ETHER_HDR_SIZE + IP_HDR_SIZE + len;

		/* and do the ARP request */
		NetArpWaitTry = 1;
		NetArpWaitTimerStart = get_timer(0);
		ArpRequest();
		return 1;	/* waiting */
	}

#ifdef ET_DEBUG
	printf("sending UDP to %08lx/%02x:%02x:%02x:%02x:%02x:%02x\n",
			dest, ether[0], ether[1], ether[2], ether[3], ether[4], ether[5]);
#endif

	NetSetEther (NetTxPacket, ether, PROT_IP);
 3f013b4:	e59f4044 	ldr	r4, [pc, #44]	; 3f01400 <NetSendUDPPacket+0xa0>
 3f013b8:	e1a01005 	mov	r1, r5
 3f013bc:	e5940000 	ldr	r0, [r4]
 3f013c0:	e3a02b02 	mov	r2, #2048	; 0x800
 3f013c4:	eb0001b8 	bl	3f01aac <NetSetEther>
	NetSetIP (NetTxPacket + ETHER_HDR_SIZE, dest, dport, sport, len);
 3f013c8:	e1a01006 	mov	r1, r6
 3f013cc:	e1a02009 	mov	r2, r9
 3f013d0:	e5940000 	ldr	r0, [r4]
 3f013d4:	e1a0300a 	mov	r3, r10
 3f013d8:	e58d7000 	str	r7, [r13]
 3f013dc:	e280000e 	add	r0, r0, #14	; 0xe
 3f013e0:	eb0001c5 	bl	3f01afc <NetSetIP>
	(void) eth_send(NetTxPacket, ETHER_HDR_SIZE + IP_HDR_SIZE + len);
 3f013e4:	e5940000 	ldr	r0, [r4]
 3f013e8:	e287102a 	add	r1, r7, #42	; 0x2a
 3f013ec:	eb000797 	bl	3f03250 <eth_send>

	return 0;	/* transmited */
 3f013f0:	e3a00000 	mov	r0, #0	; 0x0
 3f013f4:	ea000025 	b	3f01490 <NetSendUDPPacket+0x130>
 3f013f8:	03f204b8 	mvneqs	r0, #-1207959552	; 0xb8000000
 3f013fc:	03f204be 	mvneqs	r0, #-1107296256	; 0xbe000000
 3f01400:	03f204c4 	mvneqs	r0, #-1006632960	; 0xc4000000
 3f01404:	e59f3088 	ldr	r3, [pc, #88]	; 3f01494 <NetSendUDPPacket+0x134>
 3f01408:	e59f4088 	ldr	r4, [pc, #88]	; 3f01498 <NetSendUDPPacket+0x138>
 3f0140c:	e5836000 	str	r6, [r3]
 3f01410:	e59f3084 	ldr	r3, [pc, #84]	; 3f0149c <NetSendUDPPacket+0x13c>
 3f01414:	e1a01005 	mov	r1, r5
 3f01418:	e5940000 	ldr	r0, [r4]
 3f0141c:	e3a02b02 	mov	r2, #2048	; 0x800
 3f01420:	e5835000 	str	r5, [r3]
 3f01424:	eb0001a0 	bl	3f01aac <NetSetEther>
 3f01428:	e1a01006 	mov	r1, r6
 3f0142c:	e1a02009 	mov	r2, r9
 3f01430:	e5940000 	ldr	r0, [r4]
 3f01434:	e1a0300a 	mov	r3, r10
 3f01438:	e58d7000 	str	r7, [r13]
 3f0143c:	e280000e 	add	r0, r0, #14	; 0xe
 3f01440:	eb0001ad 	bl	3f01afc <NetSetIP>
 3f01444:	e5940000 	ldr	r0, [r4]
 3f01448:	e59f3050 	ldr	r3, [pc, #50]	; 3f014a0 <NetSendUDPPacket+0x140>
 3f0144c:	e1a02007 	mov	r2, r7
 3f01450:	e5931000 	ldr	r1, [r3]
 3f01454:	e280002a 	add	r0, r0, #42	; 0x2a
 3f01458:	e281102a 	add	r1, r1, #42	; 0x2a
 3f0145c:	eb003849 	bl	3f0f588 <memcpy>
 3f01460:	e59f203c 	ldr	r2, [pc, #3c]	; 3f014a4 <NetSendUDPPacket+0x144>
 3f01464:	e287302a 	add	r3, r7, #42	; 0x2a
 3f01468:	e5823000 	str	r3, [r2]
 3f0146c:	e51b0028 	ldr	r0, [r11, -#40]
 3f01470:	e59f3030 	ldr	r3, [pc, #30]	; 3f014a8 <NetSendUDPPacket+0x148>
 3f01474:	e3a04001 	mov	r4, #1	; 0x1
 3f01478:	e5834000 	str	r4, [r3]
 3f0147c:	ebfffcd2 	bl	3f007cc <get_timer>
 3f01480:	e59f3024 	ldr	r3, [pc, #24]	; 3f014ac <NetSendUDPPacket+0x14c>
 3f01484:	e5830000 	str	r0, [r3]
 3f01488:	ebfffe50 	bl	3f00dd0 <ArpRequest>
 3f0148c:	e1a00004 	mov	r0, r4
 3f01490:	ea000006 	b	3f014b0 <NetSendUDPPacket+0x150>
 3f01494:	03f6c590 	mvneqs	r12, #603979776	; 0x24000000
 3f01498:	03f6c59c 	mvneqs	r12, #654311424	; 0x27000000
 3f0149c:	03f6c598 	mvneqs	r12, #637534208	; 0x26000000
 3f014a0:	03f204c4 	mvneqs	r0, #-1006632960	; 0xc4000000
 3f014a4:	03f6c5a0 	mvneqs	r12, #671088640	; 0x28000000
 3f014a8:	03f6cbc8 	mvneqs	r12, #204800	; 0x32000
 3f014ac:	03f6cbc4 	mvneqs	r12, #200704	; 0x31000
 3f014b0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f014b4 <NetReceive>:
 3f014b4:	e1a0c00d 	mov	r12, r13
 3f014b8:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
}

#if (CONFIG_COMMANDS & CFG_CMD_PING)
static ushort PingSeqNo;

int PingSend(void)
{
	static uchar mac[6];
	volatile IP_t *ip;
	volatile ushort *s;

	/* XXX always send arp request */

	memcpy(mac, NetEtherNullAddr, 6);

#ifdef ET_DEBUG
	printf("sending ARP for %08lx\n", NetPingIP);
#endif

	NetArpWaitPacketIP = NetPingIP;
	NetArpWaitPacketMAC = mac;

	NetSetEther(NetArpWaitTxPacket, mac, PROT_IP);

	ip = (volatile IP_t *)(NetArpWaitTxPacket + ETHER_HDR_SIZE);

	/*
	 *	Construct an IP and ICMP header.  (need to set no fragment bit - XXX)
	 */
	ip->ip_hl_v  = 0x45;		/* IP_HDR_SIZE / 4 (not including UDP) */
	ip->ip_tos   = 0;
	ip->ip_len   = htons(IP_HDR_SIZE_NO_UDP + 8);
	ip->ip_id    = htons(NetIPID++);
	ip->ip_off   = htons(0x4000);	/* No fragmentation */
	ip->ip_ttl   = 255;
	ip->ip_p     = 0x01;		/* ICMP */
	ip->ip_sum   = 0;
	NetCopyIP((void*)&ip->ip_src, &NetOurIP); /* already in network byte order */
	NetCopyIP((void*)&ip->ip_dst, &NetPingIP);	   /* - "" - */
	ip->ip_sum   = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2);

	s = &ip->udp_src;		/* XXX ICMP starts here */
	s[0] = htons(0x0800);		/* echo-request, code */
	s[1] = 0;			/* checksum */
	s[2] = 0; 			/* identifier */
	s[3] = htons(PingSeqNo++);	/* sequence number */
	s[1] = ~NetCksum((uchar *)s, 8/2);

	/* size of the waiting packet */
	NetArpWaitTxPacketSize = ETHER_HDR_SIZE + IP_HDR_SIZE_NO_UDP + 8;

	/* and do the ARP request */
	NetArpWaitTry = 1;
	NetArpWaitTimerStart = get_timer(0);
	ArpRequest();
	return 1;	/* waiting */
}

static void
PingTimeout (void)
{
	eth_halt();
	NetState = NETLOOP_FAIL;	/* we did not get the reply */
}

static void
PingHandler (uchar * pkt, unsigned dest, unsigned src, unsigned len)
{
	IPaddr_t tmp;
	volatile IP_t *ip = (volatile IP_t *)pkt;

	tmp = NetReadIP((void *)&ip->ip_src);
	if (tmp != NetPingIP)
		return;

	NetState = NETLOOP_SUCCESS;
}

static void PingStart(void)
{
	NetSetTimeout (10 * CFG_HZ, PingTimeout);
	NetSetHandler (PingHandler);

	PingSend();
}

#endif

void
NetReceive(volatile uchar * pkt, int len)
{
 3f014bc:	e1a07000 	mov	r7, r0
	Ethernet_t *et;
	IP_t	*ip;
	ARP_t	*arp;
	IPaddr_t tmp;
	int	x;

	NetRxPkt = pkt;
 3f014c0:	e59f3388 	ldr	r3, [pc, #388]	; 3f01850 <NetReceive+0x39c>
 3f014c4:	e24dd010 	sub	r13, r13, #16	; 0x10
 3f014c8:	e5837000 	str	r7, [r3]
	NetRxPktLen = len;
 3f014cc:	e59f3380 	ldr	r3, [pc, #380]	; 3f01854 <NetReceive+0x3a0>
 3f014d0:	e1a04001 	mov	r4, r1
 3f014d4:	e5834000 	str	r4, [r3]
	et = (Ethernet_t *)pkt;

	x = ntohs(et->et_protlen);
 3f014d8:	e1d720bc 	ldrh	r2, [r7, #12]
 3f014dc:	e24cb004 	sub	r11, r12, #4	; 0x4


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f014e0:	e1a03422 	mov	r3, r2, lsr #8
 3f014e4:	e1a03803 	mov	r3, r3, lsl #16
 3f014e8:	e1833c02 	orr	r3, r3, r2, lsl #24

	if (x < 1514) {
 3f014ec:	e59f2364 	ldr	r2, [pc, #364]	; 3f01858 <NetReceive+0x3a4>
 3f014f0:	e1a05823 	mov	r5, r3, lsr #16
 3f014f4:	e1550002 	cmp	r5, r2
 3f014f8:	ca000007 	bgt	3f0151c <NetReceive+0x68>
		/*
		 *	Got a 802 packet.  Check the other protocol field.
		 */
		x = ntohs(et->et_prot);
		ip = (IP_t *)(pkt + E802_HDR_SIZE);
 3f014fc:	e2876016 	add	r6, r7, #22	; 0x16
 3f01500:	e1d721b4 	ldrh	r2, [r7, #20]
		len -= E802_HDR_SIZE;
 3f01504:	e2444016 	sub	r4, r4, #22	; 0x16


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01508:	e1a03422 	mov	r3, r2, lsr #8
 3f0150c:	e1a03803 	mov	r3, r3, lsl #16
 3f01510:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01514:	e1a05823 	mov	r5, r3, lsr #16
	} else {
 3f01518:	ea000001 	b	3f01524 <NetReceive+0x70>
		ip = (IP_t *)(pkt + ETHER_HDR_SIZE);
 3f0151c:	e287600e 	add	r6, r7, #14	; 0xe
		len -= ETHER_HDR_SIZE;
 3f01520:	e244400e 	sub	r4, r4, #14	; 0xe
	}

#ifdef ET_DEBUG
	printf("Receive from protocol 0x%x\n", x);
#endif

	switch (x) {
 3f01524:	e59f3330 	ldr	r3, [pc, #330]	; 3f0185c <NetReceive+0x3a8>
 3f01528:	e1550003 	cmp	r5, r3
 3f0152c:	0a000007 	beq	3f01550 <NetReceive+0x9c>
 3f01530:	ca000002 	bgt	3f01540 <NetReceive+0x8c>
 3f01534:	e3550b02 	cmp	r5, #2048	; 0x800
 3f01538:	0a0000a6 	beq	3f017d8 <NetReceive+0x324>
 3f0153c:	ea00010f 	b	3f01980 <NetReceive+0x4cc>
 3f01540:	e59f3318 	ldr	r3, [pc, #318]	; 3f01860 <NetReceive+0x3ac>
 3f01544:	e1550003 	cmp	r5, r3
 3f01548:	0a00006d 	beq	3f01704 <NetReceive+0x250>
 3f0154c:	ea00010b 	b	3f01980 <NetReceive+0x4cc>

	case PROT_ARP:
		/*
		 * We have to deal with two types of ARP packets:
		 * - REQUEST packets will be answered by sending  our
		 *   IP address - if we know it.
		 * - REPLY packates are expected only after we asked
		 *   for the TFTP server's or the gateway's ethernet
		 *   address; so if we receive such a packet, we set
		 *   the server ethernet address
		 */
#ifdef ET_DEBUG
		printf("Got ARP\n");
#endif
		arp = (ARP_t *)ip;
		if (len < ARP_HDR_SIZE) {
 3f01550:	e354001b 	cmp	r4, #27	; 0x1b
 3f01554:	da00006c 	ble	3f0170c <NetReceive+0x258>
			printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
			return;
		}
		if (ntohs(arp->ar_hrd) != ARP_ETHER) {
 3f01558:	e1d620b0 	ldrh	r2, [r6]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f0155c:	e1a03422 	mov	r3, r2, lsr #8
 3f01560:	e1a03803 	mov	r3, r3, lsl #16
 3f01564:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01568:	e3530801 	cmp	r3, #65536	; 0x10000
 3f0156c:	1a000103 	bne	3f01980 <NetReceive+0x4cc>
			return;
		}
		if (ntohs(arp->ar_pro) != PROT_IP) {
 3f01570:	e1d620b2 	ldrh	r2, [r6, #2]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01574:	e1a03422 	mov	r3, r2, lsr #8
 3f01578:	e1a03803 	mov	r3, r3, lsl #16
 3f0157c:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01580:	e3530302 	cmp	r3, #134217728	; 0x8000000
 3f01584:	1a0000fd 	bne	3f01980 <NetReceive+0x4cc>
			return;
		}
		if (arp->ar_hln != 6) {
 3f01588:	e5d69004 	ldrb	r9, [r6, #4]
 3f0158c:	e3590006 	cmp	r9, #6	; 0x6
 3f01590:	1a0000fa 	bne	3f01980 <NetReceive+0x4cc>
			return;
		}
		if (arp->ar_pln != 4) {
 3f01594:	e5d6a005 	ldrb	r10, [r6, #5]
 3f01598:	e35a0004 	cmp	r10, #4	; 0x4
 3f0159c:	1a0000f7 	bne	3f01980 <NetReceive+0x4cc>
			return;
		}

		if (NetOurIP == 0) {
 3f015a0:	e59f12bc 	ldr	r1, [pc, #2bc]	; 3f01864 <NetReceive+0x3b0>
 3f015a4:	e5913000 	ldr	r3, [r1]
 3f015a8:	e3530000 	cmp	r3, #0	; 0x0
 3f015ac:	0a0000f3 	beq	3f01980 <NetReceive+0x4cc>
/* return IP *in network byteorder* */
static inline IPaddr_t NetReadIP(void *from)
{
	IPaddr_t ip;
	memcpy((void*)&ip, from, sizeof(ip));
 3f015b0:	e24b0028 	sub	r0, r11, #40	; 0x28
 3f015b4:	e2862018 	add	r2, r6, #24	; 0x18
 3f015b8:	e1a01002 	mov	r1, r2
 3f015bc:	e50b2034 	str	r2, [r11, -#52]
 3f015c0:	e1a0200a 	mov	r2, r10
 3f015c4:	eb0037ef 	bl	3f0f588 <memcpy>
			return;
		}

		if (NetReadIP(&arp->ar_data[16]) != NetOurIP) {
 3f015c8:	e59f1294 	ldr	r1, [pc, #294]	; 3f01864 <NetReceive+0x3b0>
static inline IPaddr_t NetReadIP(void *from)
{
	IPaddr_t ip;
	memcpy((void*)&ip, from, sizeof(ip));
	return ip;
 3f015cc:	e51b2028 	ldr	r2, [r11, -#40]
 3f015d0:	e5913000 	ldr	r3, [r1]
 3f015d4:	e1520003 	cmp	r2, r3
 3f015d8:	1a0000e8 	bne	3f01980 <NetReceive+0x4cc>
			return;
		}

		switch (ntohs(arp->ar_op)) {
 3f015dc:	e1d620b6 	ldrh	r2, [r6, #6]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f015e0:	e1a03422 	mov	r3, r2, lsr #8
 3f015e4:	e1a03803 	mov	r3, r3, lsl #16
		case ARPOP_REQUEST:		/* reply with our IP address	*/
#ifdef ET_DEBUG
			printf("Got ARP REQUEST, return our IP\n");
#endif
			NetSetEther((uchar *)et, et->et_src, PROT_ARP);
			arp->ar_op = htons(ARPOP_REPLY);
			memcpy   (&arp->ar_data[10], &arp->ar_data[0], 6);
			NetCopyIP(&arp->ar_data[16], &arp->ar_data[6]);
			memcpy   (&arp->ar_data[ 0], NetOurEther, 6);
			NetCopyIP(&arp->ar_data[ 6], &NetOurIP);
			(void) eth_send((uchar *)et, ((uchar *)arp-pkt) + ARP_HDR_SIZE);
			return;

		case ARPOP_REPLY:		/* arp reply */
			/* are we waiting for a reply */
			if (!NetArpWaitPacketIP || !NetArpWaitPacketMAC)
				break;
#ifdef ET_DEBUG
			printf("Got ARP REPLY, set server/gtwy eth addr (%02x:%02x:%02x:%02x:%02x:%02x)\n",
				arp->ar_data[0], arp->ar_data[1],
				arp->ar_data[2], arp->ar_data[3],
				arp->ar_data[4], arp->ar_data[5]);
#endif

			tmp = NetReadIP(&arp->ar_data[6]);

			/* matched waiting packet's address */
			if (tmp == NetArpWaitReplyIP) {
#ifdef ET_DEBUG
				printf("Got it\n");
#endif
				/* save address for later use */
				memcpy(NetArpWaitPacketMAC, &arp->ar_data[0], 6);

				/* modify header, and transmit it */
				memcpy(((Ethernet_t *)NetArpWaitTxPacket)->et_dest, NetArpWaitPacketMAC, 6);
				(void) eth_send(NetArpWaitTxPacket, NetArpWaitTxPacketSize);

				/* no arp request pending now */
				NetArpWaitPacketIP = 0;
				NetArpWaitTxPacketSize = 0;
				NetArpWaitPacketMAC = NULL;

			}
			return;
		default:
#ifdef ET_DEBUG
			printf("Unexpected ARP opcode 0x%x\n", ntohs(arp->ar_op));
#endif
			return;
		}
 3f015e8:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f015ec:	e1a03823 	mov	r3, r3, lsr #16
 3f015f0:	e3530001 	cmp	r3, #1	; 0x1
 3f015f4:	0a000002 	beq	3f01604 <NetReceive+0x150>
 3f015f8:	e3530002 	cmp	r3, #2	; 0x2
 3f015fc:	0a00001d 	beq	3f01678 <NetReceive+0x1c4>
 3f01600:	ea0000de 	b	3f01980 <NetReceive+0x4cc>
 3f01604:	e1a00007 	mov	r0, r7
 3f01608:	e2871006 	add	r1, r7, #6	; 0x6
 3f0160c:	e1a02005 	mov	r2, r5
 3f01610:	eb000125 	bl	3f01aac <NetSetEther>
 3f01614:	e3a02c02 	mov	r2, #512	; 0x200
 3f01618:	e2860012 	add	r0, r6, #18	; 0x12
 3f0161c:	e2865008 	add	r5, r6, #8	; 0x8
 3f01620:	e1a01005 	mov	r1, r5
 3f01624:	e1c620b6 	strh	r2, [r6, #6]
 3f01628:	e1a02009 	mov	r2, r9
 3f0162c:	eb0037d5 	bl	3f0f588 <memcpy>
}

/* copy IP */
static inline void NetCopyIP(void *to, void *from)
{
 3f01630:	e286400e 	add	r4, r6, #14	; 0xe
	memcpy(to, from, sizeof(IPaddr_t));
 3f01634:	e1a01004 	mov	r1, r4
 3f01638:	e51b0034 	ldr	r0, [r11, -#52]
 3f0163c:	e1a0200a 	mov	r2, r10
 3f01640:	eb0037d0 	bl	3f0f588 <memcpy>
 3f01644:	e1a00005 	mov	r0, r5
 3f01648:	e59f1218 	ldr	r1, [pc, #218]	; 3f01868 <NetReceive+0x3b4>
 3f0164c:	e1a02009 	mov	r2, r9
 3f01650:	eb0037cc 	bl	3f0f588 <memcpy>

/* copy IP */
static inline void NetCopyIP(void *to, void *from)
{
	memcpy(to, from, sizeof(IPaddr_t));
 3f01654:	e1a00004 	mov	r0, r4
 3f01658:	e59f1204 	ldr	r1, [pc, #204]	; 3f01864 <NetReceive+0x3b0>
 3f0165c:	e1a0200a 	mov	r2, r10
 3f01660:	eb0037c8 	bl	3f0f588 <memcpy>
 3f01664:	e1a00007 	mov	r0, r7
 3f01668:	e0671006 	rsb	r1, r7, r6
 3f0166c:	e281101c 	add	r1, r1, #28	; 0x1c
 3f01670:	eb0006f6 	bl	3f03250 <eth_send>
 3f01674:	ea0000c1 	b	3f01980 <NetReceive+0x4cc>
 3f01678:	e59f71ec 	ldr	r7, [pc, #1ec]	; 3f0186c <NetReceive+0x3b8>
 3f0167c:	e5973000 	ldr	r3, [r7]
 3f01680:	e3530000 	cmp	r3, #0	; 0x0
 3f01684:	0a00001e 	beq	3f01704 <NetReceive+0x250>
 3f01688:	e59f51e0 	ldr	r5, [pc, #1e0]	; 3f01870 <NetReceive+0x3bc>
 3f0168c:	e5953000 	ldr	r3, [r5]
 3f01690:	e3530000 	cmp	r3, #0	; 0x0
 3f01694:	0a00001a 	beq	3f01704 <NetReceive+0x250>
/* return IP *in network byteorder* */
static inline IPaddr_t NetReadIP(void *from)
{
	IPaddr_t ip;
	memcpy((void*)&ip, from, sizeof(ip));
 3f01698:	e24b002c 	sub	r0, r11, #44	; 0x2c
 3f0169c:	e286100e 	add	r1, r6, #14	; 0xe
 3f016a0:	e1a0200a 	mov	r2, r10
 3f016a4:	eb0037b7 	bl	3f0f588 <memcpy>
 3f016a8:	e59f31c4 	ldr	r3, [pc, #1c4]	; 3f01874 <NetReceive+0x3c0>
static inline IPaddr_t NetReadIP(void *from)
{
	IPaddr_t ip;
	memcpy((void*)&ip, from, sizeof(ip));
	return ip;
 3f016ac:	e51b202c 	ldr	r2, [r11, -#44]
 3f016b0:	e5933000 	ldr	r3, [r3]
 3f016b4:	e1520003 	cmp	r2, r3
 3f016b8:	1a0000b0 	bne	3f01980 <NetReceive+0x4cc>
 3f016bc:	e2861008 	add	r1, r6, #8	; 0x8
 3f016c0:	e5950000 	ldr	r0, [r5]
 3f016c4:	e1a02009 	mov	r2, r9
 3f016c8:	e59f41a8 	ldr	r4, [pc, #1a8]	; 3f01878 <NetReceive+0x3c4>
 3f016cc:	eb0037ad 	bl	3f0f588 <memcpy>
 3f016d0:	e5940000 	ldr	r0, [r4]
 3f016d4:	e5951000 	ldr	r1, [r5]
 3f016d8:	e1a02009 	mov	r2, r9
 3f016dc:	eb0037a9 	bl	3f0f588 <memcpy>
 3f016e0:	e5940000 	ldr	r0, [r4]
 3f016e4:	e59f4190 	ldr	r4, [pc, #190]	; 3f0187c <NetReceive+0x3c8>
 3f016e8:	e5941000 	ldr	r1, [r4]
 3f016ec:	eb0006d7 	bl	3f03250 <eth_send>
 3f016f0:	e3a03000 	mov	r3, #0	; 0x0
 3f016f4:	e5873000 	str	r3, [r7]
 3f016f8:	e5843000 	str	r3, [r4]
 3f016fc:	e5853000 	str	r3, [r5]
 3f01700:	ea00009e 	b	3f01980 <NetReceive+0x4cc>

	case PROT_RARP:
#ifdef ET_DEBUG
		printf("Got RARP\n");
#endif
		arp = (ARP_t *)ip;
		if (len < ARP_HDR_SIZE) {
 3f01704:	e354001b 	cmp	r4, #27	; 0x1b
 3f01708:	ca000004 	bgt	3f01720 <NetReceive+0x26c>
			printf("bad length %d < %d\n", len, ARP_HDR_SIZE);
 3f0170c:	e1a01004 	mov	r1, r4
 3f01710:	e59f0168 	ldr	r0, [pc, #168]	; 3f01880 <NetReceive+0x3cc>
 3f01714:	e3a0201c 	mov	r2, #28	; 0x1c
 3f01718:	eb002c49 	bl	3f0c844 <printf>
			return;
 3f0171c:	ea000097 	b	3f01980 <NetReceive+0x4cc>
		}

		if ((ntohs(arp->ar_op) != RARPOP_REPLY) ||
 3f01720:	e1d620b6 	ldrh	r2, [r6, #6]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01724:	e1a03422 	mov	r3, r2, lsr #8
 3f01728:	e1a03803 	mov	r3, r3, lsl #16
			(ntohs(arp->ar_hrd) != ARP_ETHER)   ||
			(ntohs(arp->ar_pro) != PROT_IP)     ||
			(arp->ar_hln != 6) || (arp->ar_pln != 4)) {
 3f0172c:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01730:	e1a04823 	mov	r4, r3, lsr #16
 3f01734:	e3540004 	cmp	r4, #4	; 0x4
 3f01738:	1a00000f 	bne	3f0177c <NetReceive+0x2c8>
 3f0173c:	e1d620b0 	ldrh	r2, [r6]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01740:	e1a03422 	mov	r3, r2, lsr #8
 3f01744:	e1a03803 	mov	r3, r3, lsl #16
 3f01748:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f0174c:	e3530801 	cmp	r3, #65536	; 0x10000
 3f01750:	1a000009 	bne	3f0177c <NetReceive+0x2c8>
 3f01754:	e1d620b2 	ldrh	r2, [r6, #2]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01758:	e1a03422 	mov	r3, r2, lsr #8
 3f0175c:	e1a03803 	mov	r3, r3, lsl #16
 3f01760:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01764:	e3530302 	cmp	r3, #134217728	; 0x8000000
 3f01768:	1a000003 	bne	3f0177c <NetReceive+0x2c8>
 3f0176c:	e59f2110 	ldr	r2, [pc, #110]	; 3f01884 <NetReceive+0x3d0>
 3f01770:	e1d630b4 	ldrh	r3, [r6, #4]
 3f01774:	e1530002 	cmp	r3, r2
 3f01778:	0a000002 	beq	3f01788 <NetReceive+0x2d4>

			printf("invalid RARP header\n");
 3f0177c:	e59f0104 	ldr	r0, [pc, #104]	; 3f01888 <NetReceive+0x3d4>
 3f01780:	eb002c2f 	bl	3f0c844 <printf>
		} else {
 3f01784:	ea00007d 	b	3f01980 <NetReceive+0x4cc>

/* copy IP */
static inline void NetCopyIP(void *to, void *from)
{
	memcpy(to, from, sizeof(IPaddr_t));
 3f01788:	e2861018 	add	r1, r6, #24	; 0x18
 3f0178c:	e59f00d0 	ldr	r0, [pc, #d0]	; 3f01864 <NetReceive+0x3b0>
 3f01790:	e1a02004 	mov	r2, r4
 3f01794:	eb00377b 	bl	3f0f588 <memcpy>
 3f01798:	e286100e 	add	r1, r6, #14	; 0xe
 3f0179c:	e59f00e8 	ldr	r0, [pc, #e8]	; 3f0188c <NetReceive+0x3d8>
 3f017a0:	e1a02004 	mov	r2, r4
 3f017a4:	eb003777 	bl	3f0f588 <memcpy>
			NetCopyIP(&NetOurIP,    &arp->ar_data[16]);
			NetCopyIP(&NetServerIP, &arp->ar_data[ 6]);
			memcpy (NetServerEther, &arp->ar_data[ 0], 6);
 3f017a8:	e2861008 	add	r1, r6, #8	; 0x8
 3f017ac:	e59f00dc 	ldr	r0, [pc, #dc]	; 3f01890 <NetReceive+0x3dc>
 3f017b0:	e3a02006 	mov	r2, #6	; 0x6
 3f017b4:	eb003773 	bl	3f0f588 <memcpy>

			(*packetHandler)(0,0,0,0);
 3f017b8:	e3a00000 	mov	r0, #0	; 0x0
 3f017bc:	e1a01000 	mov	r1, r0
 3f017c0:	e1a02000 	mov	r2, r0
 3f017c4:	e59fc0c8 	ldr	r12, [pc, #c8]	; 3f01894 <NetReceive+0x3e0>
 3f017c8:	e1a03000 	mov	r3, r0
 3f017cc:	e1a0e00f 	mov	r14, r15
 3f017d0:	e59cf000 	ldr	r15, [r12]
		}
		break;
 3f017d4:	ea000069 	b	3f01980 <NetReceive+0x4cc>

	case PROT_IP:
#ifdef ET_DEBUG
		printf("Got IP\n");
#endif
		if (len < IP_HDR_SIZE) {
 3f017d8:	e354001b 	cmp	r4, #27	; 0x1b
 3f017dc:	9a000067 	bls	3f01980 <NetReceive+0x4cc>
			debug ("len bad %d < %d\n", len, IP_HDR_SIZE);
			return;
		}
		if (len < ntohs(ip->ip_len)) {
 3f017e0:	e1d620b2 	ldrh	r2, [r6, #2]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f017e4:	e1a03422 	mov	r3, r2, lsr #8
 3f017e8:	e1a03803 	mov	r3, r3, lsl #16
 3f017ec:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f017f0:	e1a02823 	mov	r2, r3, lsr #16
 3f017f4:	e1540002 	cmp	r4, r2
 3f017f8:	aa000003 	bge	3f0180c <NetReceive+0x358>
			printf("len bad %d < %d\n", len, ntohs(ip->ip_len));
 3f017fc:	e59f0094 	ldr	r0, [pc, #94]	; 3f01898 <NetReceive+0x3e4>
 3f01800:	e1a01004 	mov	r1, r4
 3f01804:	eb002c0e 	bl	3f0c844 <printf>
			return;
 3f01808:	ea00005c 	b	3f01980 <NetReceive+0x4cc>
		}
		len = ntohs(ip->ip_len);
#ifdef ET_DEBUG
		printf("len=%d, v=%02x\n", len, ip->ip_hl_v & 0xff);
#endif
		if ((ip->ip_hl_v & 0xf0) != 0x40) {
 3f0180c:	e5d63000 	ldrb	r3, [r6]
 3f01810:	e20330f0 	and	r3, r3, #240	; 0xf0
 3f01814:	e3530040 	cmp	r3, #64	; 0x40
 3f01818:	1a000058 	bne	3f01980 <NetReceive+0x4cc>
			return;
		}
		if (ip->ip_off & htons(0x1fff)) { /* Can't deal w/ fragments */
 3f0181c:	e59f3078 	ldr	r3, [pc, #78]	; 3f0189c <NetReceive+0x3e8>
 3f01820:	e1d620b6 	ldrh	r2, [r6, #6]
 3f01824:	e0023003 	and	r3, r2, r3
 3f01828:	e3530000 	cmp	r3, #0	; 0x0
 3f0182c:	1a000053 	bne	3f01980 <NetReceive+0x4cc>
			return;
		}
		if (!NetCksumOk((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2)) {
 3f01830:	e1a00006 	mov	r0, r6
 3f01834:	e3a0100a 	mov	r1, #10	; 0xa
 3f01838:	eb000079 	bl	3f01a24 <NetCksumOk>
 3f0183c:	e3500000 	cmp	r0, #0	; 0x0
 3f01840:	1a000017 	bne	3f018a4 <NetReceive+0x3f0>
			printf("checksum bad\n");
 3f01844:	e59f0054 	ldr	r0, [pc, #54]	; 3f018a0 <NetReceive+0x3ec>
 3f01848:	eb002bfd 	bl	3f0c844 <printf>
			return;
 3f0184c:	ea00004b 	b	3f01980 <NetReceive+0x4cc>
 3f01850:	03f6a6d0 	mvneqs	r10, #218103808	; 0xd000000
 3f01854:	03f6a6d4 	mvneqs	r10, #222298112	; 0xd400000
 3f01858:	000005e9 	andeq	r0, r0, r9, ror #11
 3f0185c:	00000806 	andeq	r0, r0, r6, lsl #16
 3f01860:	00008035 	andeq	r8, r0, r5, lsr r0
 3f01864:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
 3f01868:	03f6a6b0 	mvneqs	r10, #184549376	; 0xb000000
 3f0186c:	03f6c590 	mvneqs	r12, #603979776	; 0x24000000
 3f01870:	03f6c598 	mvneqs	r12, #637534208	; 0x26000000
 3f01874:	03f6c594 	mvneqs	r12, #620756992	; 0x25000000
 3f01878:	03f6c59c 	mvneqs	r12, #654311424	; 0x27000000
 3f0187c:	03f6c5a0 	mvneqs	r12, #671088640	; 0x28000000
 3f01880:	03f1abbc 	mvneqs	r10, #192512	; 0x2f000
 3f01884:	00000406 	andeq	r0, r0, r6, lsl #8
 3f01888:	03f1abd0 	mvneqs	r10, #212992	; 0x34000
 3f0188c:	03f6a6bc 	mvneqs	r10, #197132288	; 0xbc00000
 3f01890:	03f204b2 	mvneqs	r0, #-1308622848	; 0xb2000000
 3f01894:	03f6c580 	mvneqs	r12, #536870912	; 0x20000000
 3f01898:	03f1abe8 	mvneqs	r10, #237568	; 0x3a000
 3f0189c:	0000ff1f 	andeq	r15, r0, r15, lsl r15
 3f018a0:	03f1abfc 	mvneqs	r10, #258048	; 0x3f000
/* return IP *in network byteorder* */
static inline IPaddr_t NetReadIP(void *from)
{
	IPaddr_t ip;
	memcpy((void*)&ip, from, sizeof(ip));
 3f018a4:	e24b0030 	sub	r0, r11, #48	; 0x30
 3f018a8:	e2861010 	add	r1, r6, #16	; 0x10
 3f018ac:	e3a02004 	mov	r2, #4	; 0x4
 3f018b0:	eb003734 	bl	3f0f588 <memcpy>
		}
		tmp = NetReadIP(&ip->ip_dst);
		if (NetOurIP && tmp != NetOurIP && tmp != 0xFFFFFFFF) {
 3f018b4:	e59f305c 	ldr	r3, [pc, #5c]	; 3f01918 <NetReceive+0x464>
 3f018b8:	e5933000 	ldr	r3, [r3]
static inline IPaddr_t NetReadIP(void *from)
{
	IPaddr_t ip;
	memcpy((void*)&ip, from, sizeof(ip));
	return ip;
 3f018bc:	e51b2030 	ldr	r2, [r11, -#48]
 3f018c0:	e3530000 	cmp	r3, #0	; 0x0
 3f018c4:	0a000002 	beq	3f018d4 <NetReceive+0x420>
 3f018c8:	e1520003 	cmp	r2, r3
 3f018cc:	13720001 	cmnne	r2, #1	; 0x1
 3f018d0:	1a00002a 	bne	3f01980 <NetReceive+0x4cc>
			return;
		}
		/*
		 * watch for ICMP host redirects
		 *
		 * There is no real handler code (yet). We just watch
		 * for ICMP host redirect messages. In case anybody
		 * sees these messages: please contact me
		 * (wd@denx.de), or - even better - send me the
		 * necessary fixes :-)
		 *
		 * Note: in all cases where I have seen this so far
		 * it was a problem with the router configuration,
		 * for instance when a router was configured in the
		 * BOOTP reply, but the TFTP server was on the same
		 * subnet. So this is probably a warning that your
		 * configuration might be wrong. But I'm not really
		 * sure if there aren't any other situations.
		 */
		if (ip->ip_p == IPPROTO_ICMP) {
 3f018d4:	e5d63009 	ldrb	r3, [r6, #9]
 3f018d8:	e3530001 	cmp	r3, #1	; 0x1
 3f018dc:	1a00000f 	bne	3f01920 <NetReceive+0x46c>
			ICMP_t *icmph = (ICMP_t *)&(ip->udp_src);

			switch (icmph->type) {
 3f018e0:	e5d63014 	ldrb	r3, [r6, #20]
 3f018e4:	e2864014 	add	r4, r6, #20	; 0x14
 3f018e8:	e3530005 	cmp	r3, #5	; 0x5
 3f018ec:	1a000023 	bne	3f01980 <NetReceive+0x4cc>
			case ICMP_REDIRECT:
			if (icmph->code != ICMP_REDIR_HOST)
 3f018f0:	e5d43001 	ldrb	r3, [r4, #1]
 3f018f4:	e3530001 	cmp	r3, #1	; 0x1
 3f018f8:	1a000020 	bne	3f01980 <NetReceive+0x4cc>
				return;
			puts (" ICMP Host Redirect to ");
 3f018fc:	e59f0018 	ldr	r0, [pc, #18]	; 3f0191c <NetReceive+0x468>
 3f01900:	eb002bc2 	bl	3f0c810 <puts>
			print_IPaddr(icmph->un.gateway);
 3f01904:	e5940004 	ldr	r0, [r4, #4]
 3f01908:	eb000122 	bl	3f01d98 <print_IPaddr>
			putc(' ');
 3f0190c:	e3a00020 	mov	r0, #32	; 0x20
 3f01910:	eb002bb1 	bl	3f0c7dc <putc>
				break;
#if (CONFIG_COMMANDS & CFG_CMD_PING)
			case ICMP_ECHO_REPLY:
				/*
				 *	IP header OK.  Pass the packet to the current handler.
				 */
				/* XXX point to ip packet */
				(*packetHandler)((uchar *)ip, 0, 0, 0);
				break;
#endif
			default:
				return;
			}
		} else if (ip->ip_p != IPPROTO_UDP) {	/* Only UDP packets */
 3f01914:	ea000003 	b	3f01928 <NetReceive+0x474>
 3f01918:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
 3f0191c:	03f1ac0c 	mvneqs	r10, #3072	; 0xc00
 3f01920:	e3530011 	cmp	r3, #17	; 0x11
 3f01924:	1a000015 	bne	3f01980 <NetReceive+0x4cc>
			return;
		}

		/*
		 *	IP header OK.  Pass the packet to the current handler.
		 */
		(*packetHandler)((uchar *)ip +IP_HDR_SIZE,
 3f01928:	e1d631b6 	ldrh	r3, [r6, #22]
						ntohs(ip->udp_dst),
						ntohs(ip->udp_src),
						ntohs(ip->udp_len) - 8);
 3f0192c:	e286001c 	add	r0, r6, #28	; 0x1c
 3f01930:	e1d6c1b8 	ldrh	r12, [r6, #24]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01934:	e1a01423 	mov	r1, r3, lsr #8
 3f01938:	e1a01801 	mov	r1, r1, lsl #16
 3f0193c:	e1811c03 	orr	r1, r1, r3, lsl #24
 3f01940:	e1d631b4 	ldrh	r3, [r6, #20]
 3f01944:	e1a01821 	mov	r1, r1, lsr #16


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01948:	e1a02423 	mov	r2, r3, lsr #8
 3f0194c:	e1a02802 	mov	r2, r2, lsl #16
 3f01950:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f01954:	e1a02822 	mov	r2, r2, lsr #16


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01958:	e1a0342c 	mov	r3, r12, lsr #8
 3f0195c:	e1a03803 	mov	r3, r3, lsl #16
 3f01960:	e1833c0c 	orr	r3, r3, r12, lsl #24
 3f01964:	e1a03823 	mov	r3, r3, lsr #16
 3f01968:	e59fc00c 	ldr	r12, [pc, #c]	; 3f0197c <NetReceive+0x4c8>
 3f0196c:	e2433008 	sub	r3, r3, #8	; 0x8
 3f01970:	e1a0e00f 	mov	r14, r15
 3f01974:	e59cf000 	ldr	r15, [r12]
 3f01978:	ea000000 	b	3f01980 <NetReceive+0x4cc>
 3f0197c:	03f6c580 	mvneqs	r12, #536870912	; 0x20000000

		break;
	}
}
 3f01980:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f01984 <net_check_prereq>:
 3f01984:	e1a0c00d 	mov	r12, r13
 3f01988:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0198c:	e24cb004 	sub	r11, r12, #4	; 0x4


/**********************************************************************/

static int net_check_prereq (proto_t protocol)
{
	switch (protocol) {
 3f01990:	e3500004 	cmp	r0, #4	; 0x4
 3f01994:	979ff100 	ldrls	r15, [r15, r0, lsl #2]
 3f01998:	ea000018 	b	3f01a00 <net_check_prereq+0x7c>
 3f0199c:	03f019e4 	mvneqs	r1, #3735552	; 0x390000
 3f019a0:	03f019e4 	mvneqs	r1, #3735552	; 0x390000
 3f019a4:	03f01a00 	mvneqs	r1, #0	; 0x0
 3f019a8:	03f019b0 	mvneqs	r1, #2883584	; 0x2c0000
 3f019ac:	03f019e4 	mvneqs	r1, #3735552	; 0x390000
			/* Fall through */
#if (CONFIG_COMMANDS & CFG_CMD_PING)
	case PING:
			if (NetPingIP == 0) {
				puts ("*** ERROR: ping address not given\n");
				return (1);
			}
			goto common;
#endif
	case TFTP:
			if (NetServerIP == 0) {
 3f019b0:	e59f3050 	ldr	r3, [pc, #50]	; 3f01a08 <net_check_prereq+0x84>
 3f019b4:	e5933000 	ldr	r3, [r3]
 3f019b8:	e3530000 	cmp	r3, #0	; 0x0
 3f019bc:	1a000003 	bne	3f019d0 <net_check_prereq+0x4c>
				puts ("*** ERROR: `serverip' not set\n");
 3f019c0:	e59f0044 	ldr	r0, [pc, #44]	; 3f01a0c <net_check_prereq+0x88>
 3f019c4:	eb002b91 	bl	3f0c810 <puts>
				return (1);
 3f019c8:	e3a00001 	mov	r0, #1	; 0x1
 3f019cc:	e91ba800 	ldmdb	r11, {r11, r13, r15}
			}

#if (CONFIG_COMMANDS & CFG_CMD_PING)
		common:
#endif

			if (NetOurIP == 0) {
 3f019d0:	e59f3038 	ldr	r3, [pc, #38]	; 3f01a10 <net_check_prereq+0x8c>
 3f019d4:	e5933000 	ldr	r3, [r3]
 3f019d8:	e3530000 	cmp	r3, #0	; 0x0
				puts ("*** ERROR: `ipaddr' not set\n");
 3f019dc:	e59f0030 	ldr	r0, [pc, #30]	; 3f01a14 <net_check_prereq+0x90>
 3f019e0:	0afffff7 	beq	3f019c4 <net_check_prereq+0x40>
				return (1);
			}
			/* Fall through */

	case DHCP:
	case RARP:
	case BOOTP:
			if (memcmp(NetOurEther, "\0\0\0\0\0\0", 6) == 0) {
 3f019e4:	e59f002c 	ldr	r0, [pc, #2c]	; 3f01a18 <net_check_prereq+0x94>
 3f019e8:	e59f102c 	ldr	r1, [pc, #2c]	; 3f01a1c <net_check_prereq+0x98>
 3f019ec:	e3a02006 	mov	r2, #6	; 0x6
 3f019f0:	eb00370b 	bl	3f0f624 <memcmp>
 3f019f4:	e3500000 	cmp	r0, #0	; 0x0
#ifdef CONFIG_NET_MULTI
			    extern int eth_get_dev_index (void);
			    int num = eth_get_dev_index();

			    switch (num) {
			    case -1:
				puts ("*** ERROR: No ethernet found.\n");
				return (1);
			    case 0:
				puts ("*** ERROR: `ethaddr' not set\n");
				break;
			    default:
				printf ("*** ERROR: `eth%daddr' not set\n",
					num);
				break;
			    }

			    NetStartAgain ();
			    return (2);
#else
			    puts ("*** ERROR: `ethaddr' not set\n");
 3f019f8:	e59f0020 	ldr	r0, [pc, #20]	; 3f01a20 <net_check_prereq+0x9c>
 3f019fc:	0afffff0 	beq	3f019c4 <net_check_prereq+0x40>
			    return (1);
#endif
			}
			/* Fall through */
		default:
			return(0);
 3f01a00:	e3a00000 	mov	r0, #0	; 0x0
 3f01a04:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f01a08:	03f6a6bc 	mvneqs	r10, #197132288	; 0xbc00000
 3f01a0c:	03f1ac24 	mvneqs	r10, #9216	; 0x2400
 3f01a10:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
 3f01a14:	03f1ac44 	mvneqs	r10, #17408	; 0x4400
 3f01a18:	03f6a6b0 	mvneqs	r10, #184549376	; 0xb000000
 3f01a1c:	03f1ac64 	mvneqs	r10, #25600	; 0x6400
 3f01a20:	03f1ac6c 	mvneqs	r10, #27648	; 0x6c00

03f01a24 <NetCksumOk>:
 3f01a24:	e1a0c00d 	mov	r12, r13
 3f01a28:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f01a2c:	e24cb004 	sub	r11, r12, #4	; 0x4
	}
	return (0);	/* OK */
}
/**********************************************************************/

int
NetCksumOk(uchar * ptr, int len)
{
	return !((NetCksum(ptr, len) + 1) & 0xfffe);
 3f01a30:	eb000007 	bl	3f01a54 <NetCksum>
 3f01a34:	e59f3014 	ldr	r3, [pc, #14]	; 3f01a50 <NetCksumOk+0x2c>
 3f01a38:	e2800001 	add	r0, r0, #1	; 0x1
 3f01a3c:	e0003003 	and	r3, r0, r3
 3f01a40:	e3530000 	cmp	r3, #0	; 0x0
 3f01a44:	13a00000 	movne	r0, #0	; 0x0
 3f01a48:	03a00001 	moveq	r0, #1	; 0x1
 3f01a4c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f01a50:	0000fffe 	streqd	r15, [r0], -r14

03f01a54 <NetCksum>:
 3f01a54:	e1a0c00d 	mov	r12, r13
 3f01a58:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f01a5c:	e24cb004 	sub	r11, r12, #4	; 0x4
}


unsigned
NetCksum(uchar * ptr, int len)
{
	ulong	xsum;

	xsum = 0;
 3f01a60:	e3a0c000 	mov	r12, #0	; 0x0
	while (len-- > 0)
 3f01a64:	e1a03001 	mov	r3, r1
 3f01a68:	e2411001 	sub	r1, r1, #1	; 0x1
 3f01a6c:	e153000c 	cmp	r3, r12
 3f01a70:	da000005 	ble	3f01a8c <NetCksum+0x38>
		xsum += *((ushort *)ptr)++;
 3f01a74:	e1a02001 	mov	r2, r1
 3f01a78:	e2411001 	sub	r1, r1, #1	; 0x1
 3f01a7c:	e0d030b2 	ldrh	r3, [r0], #2
 3f01a80:	e3520000 	cmp	r2, #0	; 0x0
 3f01a84:	e08cc003 	add	r12, r12, r3
 3f01a88:	cafffff9 	bgt	3f01a74 <NetCksum+0x20>
	xsum = (xsum & 0xffff) + (xsum >> 16);
 3f01a8c:	e59f0014 	ldr	r0, [pc, #14]	; 3f01aa8 <NetCksum+0x54>
 3f01a90:	e00c3000 	and	r3, r12, r0
 3f01a94:	e083c82c 	add	r12, r3, r12, lsr #16
	xsum = (xsum & 0xffff) + (xsum >> 16);
 3f01a98:	e00c3000 	and	r3, r12, r0
 3f01a9c:	e083c82c 	add	r12, r3, r12, lsr #16
	return (xsum & 0xffff);
 3f01aa0:	e00c0000 	and	r0, r12, r0
}
 3f01aa4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f01aa8:	0000ffff 	streqd	r15, [r0], -r15

03f01aac <NetSetEther>:
 3f01aac:	e1a0c00d 	mov	r12, r13
 3f01ab0:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f01ab4:	e24cb004 	sub	r11, r12, #4	; 0x4


void
NetSetEther(volatile uchar * xet, uchar * addr, uint prot)
{
 3f01ab8:	e1a05000 	mov	r5, r0
 3f01abc:	e1a04002 	mov	r4, r2
	Ethernet_t *et = (Ethernet_t *)xet;

	memcpy (et->et_dest, addr, 6);
 3f01ac0:	e3a02006 	mov	r2, #6	; 0x6
 3f01ac4:	eb0036af 	bl	3f0f588 <memcpy>
	memcpy (et->et_src, NetOurEther, 6);
 3f01ac8:	e2850006 	add	r0, r5, #6	; 0x6
 3f01acc:	e59f1024 	ldr	r1, [pc, #24]	; 3f01af8 <NetSetEther+0x4c>
 3f01ad0:	e3a02006 	mov	r2, #6	; 0x6
 3f01ad4:	eb0036ab 	bl	3f0f588 <memcpy>
	et->et_protlen = htons(prot);
 3f01ad8:	e1a04804 	mov	r4, r4, lsl #16
 3f01adc:	e1a04824 	mov	r4, r4, lsr #16


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01ae0:	e1a03424 	mov	r3, r4, lsr #8
 3f01ae4:	e1a03803 	mov	r3, r3, lsl #16
 3f01ae8:	e1833c04 	orr	r3, r3, r4, lsl #24
 3f01aec:	e1a03823 	mov	r3, r3, lsr #16
 3f01af0:	e1c530bc 	strh	r3, [r5, #12]
}
 3f01af4:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f01af8:	03f6a6b0 	mvneqs	r10, #184549376	; 0xb000000

03f01afc <NetSetIP>:
 3f01afc:	e1a0c00d 	mov	r12, r13
 3f01b00:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f01b04:	e24cb004 	sub	r11, r12, #4	; 0x4


void
NetSetIP(volatile uchar * xip, IPaddr_t dest, int dport, int sport, int len)
{
 3f01b08:	e1a05000 	mov	r5, r0
 3f01b0c:	e1a0a002 	mov	r10, r2
 3f01b10:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f01b14:	e59b6004 	ldr	r6, [r11, #4]
 3f01b18:	e1a07003 	mov	r7, r3
 3f01b1c:	e50b1024 	str	r1, [r11, -#36]
	volatile IP_t *ip = (IP_t *)xip;

	/*
	 *	If the data is an odd number of bytes, zero the
	 *	byte after the last byte so that the checksum
	 *	will work.
	 */
	if (len & 1)
 3f01b20:	e3160001 	tst	r6, #1	; 0x1
		xip[IP_HDR_SIZE + len] = 0;
 3f01b24:	13a0101c 	movne	r1, #28	; 0x1c
 3f01b28:	10862005 	addne	r2, r6, r5
 3f01b2c:	13a03000 	movne	r3, #0	; 0x0
 3f01b30:	17c23001 	strneb	r3, [r2, r1]

	/*
	 *	Construct an IP and UDP header.
			(need to set no fragment bit - XXX)
	 */
	ip->ip_hl_v  = 0x45;		/* IP_HDR_SIZE / 4 (not including UDP) */
 3f01b34:	e3a03045 	mov	r3, #69	; 0x45
	ip->ip_tos   = 0;
 3f01b38:	e3a04000 	mov	r4, #0	; 0x0
	ip->ip_len   = htons(IP_HDR_SIZE + len);
 3f01b3c:	e286201c 	add	r2, r6, #28	; 0x1c
 3f01b40:	e1a02802 	mov	r2, r2, lsl #16
 3f01b44:	e1a02822 	mov	r2, r2, lsr #16
 3f01b48:	e5c53000 	strb	r3, [r5]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01b4c:	e1a03422 	mov	r3, r2, lsr #8
 3f01b50:	e1a03803 	mov	r3, r3, lsl #16
 3f01b54:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01b58:	e5c54001 	strb	r4, [r5, #1]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01b5c:	e1a03823 	mov	r3, r3, lsr #16
 3f01b60:	e1c530b2 	strh	r3, [r5, #2]
	ip->ip_id    = htons(NetIPID++);
 3f01b64:	e59f20d0 	ldr	r2, [pc, #d0]	; 3f01c3c <NetSetIP+0x140>

/* copy IP */
static inline void NetCopyIP(void *to, void *from)
{
	memcpy(to, from, sizeof(IPaddr_t));
 3f01b68:	e59f10d0 	ldr	r1, [pc, #d0]	; 3f01c40 <NetSetIP+0x144>
 3f01b6c:	e5923000 	ldr	r3, [r2]
 3f01b70:	e1d200b0 	ldrh	r0, [r2]
#endif /* OPTIMIZE */


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
 3f01b74:	e2833001 	add	r3, r3, #1	; 0x1
 3f01b78:	e5823000 	str	r3, [r2]
	return __arch__swab16(x);
 3f01b7c:	e1a03420 	mov	r3, r0, lsr #8
 3f01b80:	e1a03803 	mov	r3, r3, lsl #16
 3f01b84:	e1833c00 	orr	r3, r3, r0, lsl #24
 3f01b88:	e1a03823 	mov	r3, r3, lsr #16
 3f01b8c:	e1c530b4 	strh	r3, [r5, #4]
	ip->ip_off   = htons(0x4000);	/* No fragmentation */
 3f01b90:	e3a03040 	mov	r3, #64	; 0x40
 3f01b94:	e1c530b6 	strh	r3, [r5, #6]
	ip->ip_ttl   = 255;
 3f01b98:	e28330bf 	add	r3, r3, #191	; 0xbf
 3f01b9c:	e5c53008 	strb	r3, [r5, #8]
	ip->ip_p     = 17;		/* UDP */
 3f01ba0:	e24330ee 	sub	r3, r3, #238	; 0xee
 3f01ba4:	e5c53009 	strb	r3, [r5, #9]

/* copy IP */
static inline void NetCopyIP(void *to, void *from)
{
	memcpy(to, from, sizeof(IPaddr_t));
 3f01ba8:	e285000c 	add	r0, r5, #12	; 0xc
	ip->ip_sum   = 0;
 3f01bac:	e1c540ba 	strh	r4, [r5, #10]

/* copy IP */
static inline void NetCopyIP(void *to, void *from)
{
	memcpy(to, from, sizeof(IPaddr_t));
 3f01bb0:	e3a02004 	mov	r2, #4	; 0x4
 3f01bb4:	eb003673 	bl	3f0f588 <memcpy>
 3f01bb8:	e2850010 	add	r0, r5, #16	; 0x10
 3f01bbc:	e24b1024 	sub	r1, r11, #36	; 0x24
 3f01bc0:	e3a02004 	mov	r2, #4	; 0x4
 3f01bc4:	eb00366f 	bl	3f0f588 <memcpy>
	NetCopyIP((void*)&ip->ip_src, &NetOurIP); /* already in network byte order */
	NetCopyIP((void*)&ip->ip_dst, &dest);	   /* - "" - */
	ip->udp_src  = htons(sport);
 3f01bc8:	e1a02807 	mov	r2, r7, lsl #16
 3f01bcc:	e1a02822 	mov	r2, r2, lsr #16


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01bd0:	e1a03422 	mov	r3, r2, lsr #8
 3f01bd4:	e1a03803 	mov	r3, r3, lsl #16
 3f01bd8:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01bdc:	e1a03823 	mov	r3, r3, lsr #16
	ip->udp_dst  = htons(dport);
 3f01be0:	e1a0280a 	mov	r2, r10, lsl #16
 3f01be4:	e1a02822 	mov	r2, r2, lsr #16
 3f01be8:	e1c531b4 	strh	r3, [r5, #20]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01bec:	e1a03422 	mov	r3, r2, lsr #8
 3f01bf0:	e1a03803 	mov	r3, r3, lsl #16
 3f01bf4:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01bf8:	e1a03823 	mov	r3, r3, lsr #16
	ip->udp_len  = htons(8 + len);
 3f01bfc:	e2862008 	add	r2, r6, #8	; 0x8
 3f01c00:	e1a02802 	mov	r2, r2, lsl #16
 3f01c04:	e1a02822 	mov	r2, r2, lsr #16
 3f01c08:	e1c531b6 	strh	r3, [r5, #22]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01c0c:	e1a03422 	mov	r3, r2, lsr #8
 3f01c10:	e1a03803 	mov	r3, r3, lsl #16
 3f01c14:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01c18:	e1a03823 	mov	r3, r3, lsr #16
 3f01c1c:	e1c531b8 	strh	r3, [r5, #24]
	ip->udp_xsum = 0;
	ip->ip_sum   = ~NetCksum((uchar *)ip, IP_HDR_SIZE_NO_UDP / 2);
 3f01c20:	e1a00005 	mov	r0, r5
 3f01c24:	e1c541ba 	strh	r4, [r5, #26]
 3f01c28:	e3a0100a 	mov	r1, #10	; 0xa
 3f01c2c:	ebffff88 	bl	3f01a54 <NetCksum>
 3f01c30:	e1e00000 	mvn	r0, r0
 3f01c34:	e1c500ba 	strh	r0, [r5, #10]
 3f01c38:	ea000001 	b	3f01c44 <NetSetIP+0x148>
 3f01c3c:	03f6a6d8 	mvneqs	r10, #226492416	; 0xd800000
 3f01c40:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
}
 3f01c44:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f01c48 <copy_filename>:
 3f01c48:	e1a0c00d 	mov	r12, r13
 3f01c4c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

void copy_filename (uchar *dst, uchar *src, int size)
{
	if (*src && (*src == '"')) {
 3f01c50:	e5d13000 	ldrb	r3, [r1]
 3f01c54:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f01c58:	e3530022 	cmp	r3, #34	; 0x22
		++src;
 3f01c5c:	02811001 	addeq	r1, r1, #1	; 0x1
		--size;
 3f01c60:	02422001 	subeq	r2, r2, #1	; 0x1
	}

	while ((--size > 0) && *src && (*src != '"')) {
 3f01c64:	e2422001 	sub	r2, r2, #1	; 0x1
 3f01c68:	e3520000 	cmp	r2, #0	; 0x0
 3f01c6c:	ea000003 	b	3f01c80 <copy_filename+0x38>
		*dst++ = *src++;
 3f01c70:	e2811001 	add	r1, r1, #1	; 0x1
	}
 3f01c74:	e2422001 	sub	r2, r2, #1	; 0x1
 3f01c78:	e3520000 	cmp	r2, #0	; 0x0
 3f01c7c:	e4c0c001 	strb	r12, [r0], #1
 3f01c80:	da000005 	ble	3f01c9c <copy_filename+0x54>
 3f01c84:	e5d1c000 	ldrb	r12, [r1]
 3f01c88:	e20c30ff 	and	r3, r12, #255	; 0xff
 3f01c8c:	e3530000 	cmp	r3, #0	; 0x0
 3f01c90:	0a000001 	beq	3f01c9c <copy_filename+0x54>
 3f01c94:	e3530022 	cmp	r3, #34	; 0x22
 3f01c98:	1afffff4 	bne	3f01c70 <copy_filename+0x28>
	*dst = '\0';
 3f01c9c:	e3a03000 	mov	r3, #0	; 0x0
 3f01ca0:	e5c03000 	strb	r3, [r0]
 3f01ca4:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f01ca8 <ip_to_string>:
 3f01ca8:	e1a0c00d 	mov	r12, r13
 3f01cac:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f01cb0:	e24cb004 	sub	r11, r12, #4	; 0x4
}

#endif /* CFG_CMD_NET */

void ip_to_string (IPaddr_t x, char *s)
{
 3f01cb4:	e1a0c000 	mov	r12, r0
    x = ntohl(x);
    sprintf (s,"%d.%d.%d.%d",
 3f01cb8:	e1a00001 	mov	r0, r1
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f01cbc:	e20c2cff 	and	r2, r12, #65280	; 0xff00
 3f01cc0:	e1a02402 	mov	r2, r2, lsl #8
 3f01cc4:	e1822c0c 	orr	r2, r2, r12, lsl #24
 3f01cc8:	e20c38ff 	and	r3, r12, #16711680	; 0xff0000
 3f01ccc:	e1822423 	orr	r2, r2, r3, lsr #8
 3f01cd0:	e1822c2c 	orr	r2, r2, r12, lsr #24
 3f01cd4:	e1a03422 	mov	r3, r2, lsr #8
 3f01cd8:	e20330ff 	and	r3, r3, #255	; 0xff
 3f01cdc:	e59f1020 	ldr	r1, [pc, #20]	; 3f01d04 <ip_to_string+0x5c>
 3f01ce0:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f01ce4:	e58d3000 	str	r3, [r13]
 3f01ce8:	e20230ff 	and	r3, r2, #255	; 0xff
 3f01cec:	e58d3004 	str	r3, [r13, #4]
 3f01cf0:	e1a03822 	mov	r3, r2, lsr #16
 3f01cf4:	e1a02c22 	mov	r2, r2, lsr #24
 3f01cf8:	e20330ff 	and	r3, r3, #255	; 0xff
 3f01cfc:	eb0038ce 	bl	3f1003c <sprintf>
 3f01d00:	ea000000 	b	3f01d08 <ip_to_string+0x60>
 3f01d04:	03f1ac8c 	mvneqs	r10, #35840	; 0x8c00
	(int)((x >> 24) & 0xff),
	(int)((x >> 16) & 0xff),
	(int)((x >>  8) & 0xff),
	(int)((x >>  0) & 0xff)
    );
}
 3f01d08:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f01d0c <string_to_ip>:
 3f01d0c:	e1a0c00d 	mov	r12, r13
 3f01d10:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f01d14:	e24cb004 	sub	r11, r12, #4	; 0x4

IPaddr_t string_to_ip(char *s)
{
	IPaddr_t addr;
	char *e;
	int i;

	if (s == NULL)
 3f01d18:	e2504000 	subs	r4, r0, #0	; 0x0
 3f01d1c:	e24dd004 	sub	r13, r13, #4	; 0x4
		return(0);
 3f01d20:	01a00004 	moveq	r0, r4
 3f01d24:	0a00001a 	beq	3f01d94 <string_to_ip+0x88>

	for (addr=0, i=0; i<4; ++i) {
 3f01d28:	e3a05000 	mov	r5, #0	; 0x0
 3f01d2c:	e3a06003 	mov	r6, #3	; 0x3
		ulong val = s ? simple_strtoul(s, &e, 10) : 0;
 3f01d30:	e3540000 	cmp	r4, #0	; 0x0
 3f01d34:	0a000004 	beq	3f01d4c <string_to_ip+0x40>
 3f01d38:	e1a00004 	mov	r0, r4
 3f01d3c:	e24b101c 	sub	r1, r11, #28	; 0x1c
 3f01d40:	e3a0200a 	mov	r2, #10	; 0xa
 3f01d44:	eb00367e 	bl	3f0f744 <simple_strtoul>
 3f01d48:	ea000000 	b	3f01d50 <string_to_ip+0x44>
 3f01d4c:	e1a00004 	mov	r0, r4
		addr <<= 8;
		addr |= (val & 0xFF);
 3f01d50:	e20030ff 	and	r3, r0, #255	; 0xff
 3f01d54:	e1835405 	orr	r5, r3, r5, lsl #8
		if (s) {
 3f01d58:	e3540000 	cmp	r4, #0	; 0x0
 3f01d5c:	0a000004 	beq	3f01d74 <string_to_ip+0x68>
			s = (*e) ? e+1 : e;
 3f01d60:	e51b201c 	ldr	r2, [r11, -#28]
 3f01d64:	e5d23000 	ldrb	r3, [r2]
 3f01d68:	e3530000 	cmp	r3, #0	; 0x0
 3f01d6c:	01a04002 	moveq	r4, r2
 3f01d70:	12824001 	addne	r4, r2, #1	; 0x1
 3f01d74:	e2566001 	subs	r6, r6, #1	; 0x1
 3f01d78:	5affffec 	bpl	3f01d30 <string_to_ip+0x24>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f01d7c:	e2050cff 	and	r0, r5, #65280	; 0xff00
 3f01d80:	e1a00400 	mov	r0, r0, lsl #8
 3f01d84:	e1800c05 	orr	r0, r0, r5, lsl #24
 3f01d88:	e20538ff 	and	r3, r5, #16711680	; 0xff0000
 3f01d8c:	e1800423 	orr	r0, r0, r3, lsr #8
		}
	}

	return (htonl(addr));
 3f01d90:	e1800c25 	orr	r0, r0, r5, lsr #24
}
 3f01d94:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f01d98 <print_IPaddr>:
 3f01d98:	e1a0c00d 	mov	r12, r13
 3f01d9c:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f01da0:	e24cb004 	sub	r11, r12, #4	; 0x4

void print_IPaddr (IPaddr_t x)
{
    char tmp[16];

    ip_to_string(x, tmp);
 3f01da4:	e24b4020 	sub	r4, r11, #32	; 0x20
 3f01da8:	e1a01004 	mov	r1, r4
 3f01dac:	e24dd010 	sub	r13, r13, #16	; 0x10
 3f01db0:	ebffffbc 	bl	3f01ca8 <ip_to_string>

    puts(tmp);
 3f01db4:	e1a00004 	mov	r0, r4
 3f01db8:	eb002a94 	bl	3f0c810 <puts>
}
 3f01dbc:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f01dc0 <getenv_IPaddr>:
 3f01dc0:	e1a0c00d 	mov	r12, r13
 3f01dc4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f01dc8:	e24cb004 	sub	r11, r12, #4	; 0x4

IPaddr_t getenv_IPaddr (char *var)
{
	return (string_to_ip(getenv(var)));
 3f01dcc:	eb0028a2 	bl	3f0c05c <getenv>
 3f01dd0:	ebffffcd 	bl	3f01d0c <string_to_ip>
 3f01dd4:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f01dd8 <TftpSend>:
 3f01dd8:	e1a0c00d 	mov	r12, r13
 3f01ddc:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
	/*
	 *	We will always be sending some sort of packet, so
	 *	cobble together the packet headers now.
	 */
	pkt = NetTxPacket + ETHER_HDR_SIZE + IP_HDR_SIZE;
 3f01de0:	e59f3118 	ldr	r3, [pc, #118]	; 3f01f00 <TftpSend+0x128>
 3f01de4:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f01de8:	e5932000 	ldr	r2, [r3]
 3f01dec:	e24cb004 	sub	r11, r12, #4	; 0x4

	switch (TftpState) {
 3f01df0:	e59f310c 	ldr	r3, [pc, #10c]	; 3f01f04 <TftpSend+0x12c>
 3f01df4:	e3a00000 	mov	r0, #0	; 0x0
 3f01df8:	e5933000 	ldr	r3, [r3]
 3f01dfc:	e282502a 	add	r5, r2, #42	; 0x2a
 3f01e00:	e2433001 	sub	r3, r3, #1	; 0x1
 3f01e04:	e3530004 	cmp	r3, #4	; 0x4
 3f01e08:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f01e0c:	ea000050 	b	3f01f54 <TftpSend+0x17c>
 3f01e10:	03f01e24 	mvneqs	r1, #576	; 0x240
 3f01e14:	03f01e98 	mvneqs	r1, #2432	; 0x980
 3f01e18:	03f01ed4 	mvneqs	r1, #3392	; 0xd40
 3f01e1c:	03f01f20 	mvneqs	r1, #128	; 0x80
 3f01e20:	03f01e98 	mvneqs	r1, #2432	; 0x980

	case STATE_RRQ:
		xp = pkt;
 3f01e24:	e1a06005 	mov	r6, r5
		*((ushort *)pkt)++ = htons(TFTP_RRQ);
		strcpy ((char *)pkt, tftp_filename);
 3f01e28:	e59f40d8 	ldr	r4, [pc, #d8]	; 3f01f08 <TftpSend+0x130>
 3f01e2c:	e3a02c01 	mov	r2, #256	; 0x100
 3f01e30:	e1c620b0 	strh	r2, [r6]
 3f01e34:	e2855002 	add	r5, r5, #2	; 0x2
 3f01e38:	e5941000 	ldr	r1, [r4]
 3f01e3c:	e1a00005 	mov	r0, r5
 3f01e40:	eb0034a0 	bl	3f0f0c8 <strcpy>
		pkt += strlen(tftp_filename) + 1;
 3f01e44:	e5940000 	ldr	r0, [r4]
 3f01e48:	eb00351e 	bl	3f0f2c8 <strlen>
 3f01e4c:	e2800001 	add	r0, r0, #1	; 0x1
 3f01e50:	e0855000 	add	r5, r5, r0
		strcpy ((char *)pkt, "octet");
 3f01e54:	e1a00005 	mov	r0, r5
 3f01e58:	e59f10ac 	ldr	r1, [pc, #ac]	; 3f01f0c <TftpSend+0x134>
		pkt += 5 /*strlen("octet")*/ + 1;
 3f01e5c:	e2855006 	add	r5, r5, #6	; 0x6
 3f01e60:	eb003498 	bl	3f0f0c8 <strcpy>
		strcpy ((char *)pkt, "timeout");
 3f01e64:	e1a00005 	mov	r0, r5
 3f01e68:	e59f10a0 	ldr	r1, [pc, #a0]	; 3f01f10 <TftpSend+0x138>
		pkt += 7 /*strlen("timeout")*/ + 1;
 3f01e6c:	e2855008 	add	r5, r5, #8	; 0x8
 3f01e70:	eb003494 	bl	3f0f0c8 <strcpy>
		sprintf((char *)pkt, "%d", TIMEOUT);
 3f01e74:	e1a00005 	mov	r0, r5
 3f01e78:	e59f1094 	ldr	r1, [pc, #94]	; 3f01f14 <TftpSend+0x13c>
 3f01e7c:	e3a02005 	mov	r2, #5	; 0x5
 3f01e80:	eb00386d 	bl	3f1003c <sprintf>
#ifdef ET_DEBUG
		printf("send option \"timeout %s\"\n", (char *)pkt);
#endif
		pkt += strlen((char *)pkt) + 1;
 3f01e84:	e1a00005 	mov	r0, r5
 3f01e88:	eb00350e 	bl	3f0f2c8 <strlen>
 3f01e8c:	e2800001 	add	r0, r0, #1	; 0x1
 3f01e90:	e0855000 	add	r5, r5, r0
		len = pkt - xp;
		break;
 3f01e94:	ea00002d 	b	3f01f50 <TftpSend+0x178>

	case STATE_DATA:
	case STATE_OACK:
		xp = pkt;
 3f01e98:	e1a06005 	mov	r6, r5
		*((ushort *)pkt)++ = htons(TFTP_ACK);
 3f01e9c:	e2855002 	add	r5, r5, #2	; 0x2
 3f01ea0:	e3a03b01 	mov	r3, #1024	; 0x400
 3f01ea4:	e1c630b0 	strh	r3, [r6]
		*((ushort *)pkt)++ = htons(TftpBlock);
 3f01ea8:	e1a01005 	mov	r1, r5
 3f01eac:	e59f3064 	ldr	r3, [pc, #64]	; 3f01f18 <TftpSend+0x140>
 3f01eb0:	e2855002 	add	r5, r5, #2	; 0x2
 3f01eb4:	e1d320b0 	ldrh	r2, [r3]
		len = pkt - xp;
 3f01eb8:	e0660005 	rsb	r0, r6, r5


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01ebc:	e1a03422 	mov	r3, r2, lsr #8
 3f01ec0:	e1a03803 	mov	r3, r3, lsl #16
 3f01ec4:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01ec8:	e1a03823 	mov	r3, r3, lsr #16
 3f01ecc:	e1c130b0 	strh	r3, [r1]
		break;
 3f01ed0:	ea00001f 	b	3f01f54 <TftpSend+0x17c>

	case STATE_TOO_LARGE:
		xp = pkt;
 3f01ed4:	e1a06005 	mov	r6, r5
		*((ushort *)pkt)++ = htons(TFTP_ERROR);
 3f01ed8:	e2855002 	add	r5, r5, #2	; 0x2
 3f01edc:	e3a02c05 	mov	r2, #1280	; 0x500
		*((ushort *)pkt)++ = htons(3);
 3f01ee0:	e1a03005 	mov	r3, r5
 3f01ee4:	e2855002 	add	r5, r5, #2	; 0x2
 3f01ee8:	e1c620b0 	strh	r2, [r6]
 3f01eec:	e3a02c03 	mov	r2, #768	; 0x300
		strcpy ((char *)pkt, "File too large");
 3f01ef0:	e1a00005 	mov	r0, r5
 3f01ef4:	e59f1020 	ldr	r1, [pc, #20]	; 3f01f1c <TftpSend+0x144>
		pkt += 14 /*strlen("File too large")*/ + 1;
 3f01ef8:	e285500f 	add	r5, r5, #15	; 0xf
		len = pkt - xp;
		break;
 3f01efc:	ea000011 	b	3f01f48 <TftpSend+0x170>
 3f01f00:	03f204c4 	mvneqs	r0, #-1006632960	; 0xc4000000
 3f01f04:	03f6cbe0 	mvneqs	r12, #229376	; 0x38000
 3f01f08:	03f6cbf4 	mvneqs	r12, #249856	; 0x3d000
 3f01f0c:	03f1ac98 	mvneqs	r10, #38912	; 0x9800
 3f01f10:	03f1aca0 	mvneqs	r10, #40960	; 0xa000
 3f01f14:	03f1aca8 	mvneqs	r10, #43008	; 0xa800
 3f01f18:	03f6cbd8 	mvneqs	r12, #221184	; 0x36000
 3f01f1c:	03f1acac 	mvneqs	r10, #44032	; 0xac00

	case STATE_BAD_MAGIC:
		xp = pkt;
 3f01f20:	e1a06005 	mov	r6, r5
		*((ushort *)pkt)++ = htons(TFTP_ERROR);
 3f01f24:	e2855002 	add	r5, r5, #2	; 0x2
 3f01f28:	e3a03c05 	mov	r3, #1280	; 0x500
 3f01f2c:	e1c630b0 	strh	r3, [r6]
		*((ushort *)pkt)++ = htons(2);
 3f01f30:	e1a03005 	mov	r3, r5
 3f01f34:	e2855002 	add	r5, r5, #2	; 0x2
 3f01f38:	e3a02c02 	mov	r2, #512	; 0x200
		strcpy ((char *)pkt, "File has bad magic");
 3f01f3c:	e1a00005 	mov	r0, r5
 3f01f40:	e59f1034 	ldr	r1, [pc, #34]	; 3f01f7c <TftpSend+0x1a4>
		pkt += 18 /*strlen("File has bad magic")*/ + 1;
 3f01f44:	e2855013 	add	r5, r5, #19	; 0x13
 3f01f48:	e1c320b0 	strh	r2, [r3]
 3f01f4c:	eb00345d 	bl	3f0f0c8 <strcpy>
		len = pkt - xp;
 3f01f50:	e0660005 	rsb	r0, r6, r5
		break;
	}

	NetSendUDPPacket(NetServerEther, NetServerIP, TftpServerPort, TftpOurPort, len);
 3f01f54:	e58d0000 	str	r0, [r13]
 3f01f58:	e59f0020 	ldr	r0, [pc, #20]	; 3f01f80 <TftpSend+0x1a8>
 3f01f5c:	e59f3020 	ldr	r3, [pc, #20]	; 3f01f84 <TftpSend+0x1ac>
 3f01f60:	e59f2020 	ldr	r2, [pc, #20]	; 3f01f88 <TftpSend+0x1b0>
 3f01f64:	e5931000 	ldr	r1, [r3]
 3f01f68:	e59f301c 	ldr	r3, [pc, #1c]	; 3f01f8c <TftpSend+0x1b4>
 3f01f6c:	e5922000 	ldr	r2, [r2]
 3f01f70:	e5933000 	ldr	r3, [r3]
 3f01f74:	ebfffcf9 	bl	3f01360 <NetSendUDPPacket>
 3f01f78:	ea000004 	b	3f01f90 <TftpSend+0x1b8>
 3f01f7c:	03f1acbc 	mvneqs	r10, #48128	; 0xbc00
 3f01f80:	03f204b2 	mvneqs	r0, #-1308622848	; 0xb2000000
 3f01f84:	03f6a6bc 	mvneqs	r10, #197132288	; 0xbc00000
 3f01f88:	03f6cbcc 	mvneqs	r12, #208896	; 0x33000
 3f01f8c:	03f6cbd0 	mvneqs	r12, #212992	; 0x34000
}
 3f01f90:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f01f94 <TftpHandler>:
 3f01f94:	e1a0c00d 	mov	r12, r13
 3f01f98:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f01f9c:	e24cb004 	sub	r11, r12, #4	; 0x4


static void
TftpHandler (uchar * pkt, unsigned dest, unsigned src, unsigned len)
{
 3f01fa0:	e1a04000 	mov	r4, r0
	ushort proto;

	if (dest != TftpOurPort) {
 3f01fa4:	e59fc208 	ldr	r12, [pc, #208]	; 3f021b4 <TftpHandler+0x220>
 3f01fa8:	e1a05003 	mov	r5, r3
 3f01fac:	e59c0000 	ldr	r0, [r12]
 3f01fb0:	e1a06002 	mov	r6, r2
 3f01fb4:	e1510000 	cmp	r1, r0
 3f01fb8:	191bacf0 	ldmnedb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
		return;
	}
	if (TftpState != STATE_RRQ && src != TftpServerPort) {
 3f01fbc:	e59f71f4 	ldr	r7, [pc, #1f4]	; 3f021b8 <TftpHandler+0x224>
 3f01fc0:	e5973000 	ldr	r3, [r7]
 3f01fc4:	e3530001 	cmp	r3, #1	; 0x1
 3f01fc8:	0a000003 	beq	3f01fdc <TftpHandler+0x48>
 3f01fcc:	e59f31e8 	ldr	r3, [pc, #1e8]	; 3f021bc <TftpHandler+0x228>
 3f01fd0:	e5933000 	ldr	r3, [r3]
 3f01fd4:	e1560003 	cmp	r6, r3
 3f01fd8:	191bacf0 	ldmnedb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
		return;
	}

	if (len < 2) {
 3f01fdc:	e3550001 	cmp	r5, #1	; 0x1
 3f01fe0:	991bacf0 	ldmlsdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
		return;
	}
	len -= 2;
	/* warning: don't use increment (++) in ntohs() macros!! */
	proto = *((ushort *)pkt)++;
 3f01fe4:	e0d420b2 	ldrh	r2, [r4], #2
 3f01fe8:	e2455002 	sub	r5, r5, #2	; 0x2


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f01fec:	e1a03422 	mov	r3, r2, lsr #8
 3f01ff0:	e1a03803 	mov	r3, r3, lsl #16
	switch (ntohs(proto)) {

	case TFTP_RRQ:
	case TFTP_WRQ:
	case TFTP_ACK:
		break;
	default:
		break;

	case TFTP_OACK:
#ifdef ET_DEBUG
		printf("Got OACK: %s %s\n", pkt, pkt+strlen(pkt)+1);
#endif
		TftpState = STATE_OACK;
		TftpServerPort = src;
		TftpSend (); /* Send ACK */
		break;
	case TFTP_DATA:
		if (len < 2)
			return;
		len -= 2;
		TftpBlock = ntohs(*(ushort *)pkt);
		if (((TftpBlock - 1) % 10) == 0) {
			putc ('#');
		} else if ((TftpBlock % (10 * HASHES_PER_LINE)) == 0) {
			puts ("\n\t ");
		}

#ifdef ET_DEBUG
		if (TftpState == STATE_RRQ) {
			printf("Server did not acknowledge timeout option!\n");
		}
#endif

		if (TftpState == STATE_RRQ || TftpState == STATE_OACK) {
			TftpState = STATE_DATA;
			TftpServerPort = src;
			TftpLastBlock = 0;

			if (TftpBlock != 1) {	/* Assertion */
				printf ("\nTFTP error: "
					"First block is not block 1 (%d)\n"
					"Starting again\n\n",
					TftpBlock);
				NetStartAgain ();
				break;
			}
		}

		if (TftpBlock == TftpLastBlock) {
			/*
			 *	Same block again; ignore it.
			 */
			break;
		}

		TftpLastBlock = TftpBlock;
		NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);

		store_block (TftpBlock - 1, pkt + 2, len);

		/*
		 *	Acknoledge the block just received, which will prompt
		 *	the server for the next one.
		 */
		TftpSend ();

		if (len < 512) {
			/*
			 *	We received the whole thing.  Try to
			 *	run it.
			 */
			puts ("\ndone\n");
			NetState = NETLOOP_SUCCESS;
		}
		break;

	case TFTP_ERROR:
		printf ("\nTFTP error: '%s' (%d)\n",
					pkt + 2, ntohs(*(ushort *)pkt));
		puts ("Starting again\n\n");
		NetStartAgain ();
		break;
	}
 3f01ff4:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f01ff8:	e1a03823 	mov	r3, r3, lsr #16
 3f01ffc:	e2433001 	sub	r3, r3, #1	; 0x1
 3f02000:	e3530005 	cmp	r3, #5	; 0x5
 3f02004:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f02008:	ea000005 	b	3f02024 <TftpHandler+0x90>
 3f0200c:	03f021b0 	mvneqs	r2, #44	; 0x2c
 3f02010:	03f021b0 	mvneqs	r2, #44	; 0x2c
 3f02014:	03f02040 	mvneqs	r2, #64	; 0x40
 3f02018:	03f021b0 	mvneqs	r2, #44	; 0x2c
 3f0201c:	03f02184 	mvneqs	r2, #33	; 0x21
 3f02020:	03f02028 	mvneqs	r2, #40	; 0x28
 3f02024:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f02028:	e3a03005 	mov	r3, #5	; 0x5
 3f0202c:	e5873000 	str	r3, [r7]
 3f02030:	e59f3184 	ldr	r3, [pc, #184]	; 3f021bc <TftpHandler+0x228>
 3f02034:	e5836000 	str	r6, [r3]
 3f02038:	ebffff66 	bl	3f01dd8 <TftpSend>
 3f0203c:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f02040:	e3550001 	cmp	r5, #1	; 0x1
 3f02044:	991bacf0 	ldmlsdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f02048:	e1d420b0 	ldrh	r2, [r4]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f0204c:	e1a03422 	mov	r3, r2, lsr #8
 3f02050:	e1a03803 	mov	r3, r3, lsl #16
 3f02054:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f02058:	e1a00823 	mov	r0, r3, lsr #16
 3f0205c:	e59f315c 	ldr	r3, [pc, #15c]	; 3f021c0 <TftpHandler+0x22c>
 3f02060:	e2401001 	sub	r1, r0, #1	; 0x1
 3f02064:	e0832391 	umull	r2, r3, r1, r3
 3f02068:	e59f2154 	ldr	r2, [pc, #154]	; 3f021c4 <TftpHandler+0x230>
 3f0206c:	e2455002 	sub	r5, r5, #2	; 0x2
 3f02070:	e1a0a002 	mov	r10, r2
 3f02074:	e5820000 	str	r0, [r2]
 3f02078:	e1a031a3 	mov	r3, r3, lsr #3
 3f0207c:	e0833103 	add	r3, r3, r3, lsl #2
 3f02080:	e1510083 	cmp	r1, r3, lsl #1
 3f02084:	1a000002 	bne	3f02094 <TftpHandler+0x100>
 3f02088:	e3a00023 	mov	r0, #35	; 0x23
 3f0208c:	eb0029d2 	bl	3f0c7dc <putc>
 3f02090:	ea000008 	b	3f020b8 <TftpHandler+0x124>
 3f02094:	e59f312c 	ldr	r3, [pc, #12c]	; 3f021c8 <TftpHandler+0x234>
 3f02098:	e0832390 	umull	r2, r3, r0, r3
 3f0209c:	e1a034a3 	mov	r3, r3, lsr #9
 3f020a0:	e0833103 	add	r3, r3, r3, lsl #2
 3f020a4:	e0833303 	add	r3, r3, r3, lsl #6
 3f020a8:	e1500083 	cmp	r0, r3, lsl #1
 3f020ac:	1a000001 	bne	3f020b8 <TftpHandler+0x124>
 3f020b0:	e59f0114 	ldr	r0, [pc, #114]	; 3f021cc <TftpHandler+0x238>
 3f020b4:	eb0029d5 	bl	3f0c810 <puts>
 3f020b8:	e5973000 	ldr	r3, [r7]
 3f020bc:	e3530005 	cmp	r3, #5	; 0x5
 3f020c0:	13530001 	cmpne	r3, #1	; 0x1
 3f020c4:	1a00000d 	bne	3f02100 <TftpHandler+0x16c>
 3f020c8:	e3a03002 	mov	r3, #2	; 0x2
 3f020cc:	e5873000 	str	r3, [r7]
 3f020d0:	e59f30e4 	ldr	r3, [pc, #e4]	; 3f021bc <TftpHandler+0x228>
 3f020d4:	e59f20f4 	ldr	r2, [pc, #f4]	; 3f021d0 <TftpHandler+0x23c>
 3f020d8:	e59a1000 	ldr	r1, [r10]
 3f020dc:	e5836000 	str	r6, [r3]
 3f020e0:	e3a03000 	mov	r3, #0	; 0x0
 3f020e4:	e5823000 	str	r3, [r2]
 3f020e8:	e3510001 	cmp	r1, #1	; 0x1
 3f020ec:	0a000003 	beq	3f02100 <TftpHandler+0x16c>
 3f020f0:	e59f00dc 	ldr	r0, [pc, #dc]	; 3f021d4 <TftpHandler+0x240>
 3f020f4:	eb0029d2 	bl	3f0c844 <printf>
 3f020f8:	ebfffc6d 	bl	3f012b4 <NetStartAgain>
 3f020fc:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f02100:	e59f60bc 	ldr	r6, [pc, #bc]	; 3f021c4 <TftpHandler+0x230>
 3f02104:	e59fc0c4 	ldr	r12, [pc, #c4]	; 3f021d0 <TftpHandler+0x23c>
 3f02108:	e5962000 	ldr	r2, [r6]
 3f0210c:	e59c3000 	ldr	r3, [r12]
 3f02110:	e1520003 	cmp	r2, r3
 3f02114:	091bacf0 	ldmeqdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f02118:	e59f00b8 	ldr	r0, [pc, #b8]	; 3f021d8 <TftpHandler+0x244>
 3f0211c:	e59f10b8 	ldr	r1, [pc, #b8]	; 3f021dc <TftpHandler+0x248>
 3f02120:	e58c2000 	str	r2, [r12]
 3f02124:	ebfffc75 	bl	3f01300 <NetSetTimeout>
 3f02128:	e2841002 	add	r1, r4, #2	; 0x2
 3f0212c:	e5963000 	ldr	r3, [r6]
 3f02130:	e1a02005 	mov	r2, r5
 3f02134:	e59f00a4 	ldr	r0, [pc, #a4]	; 3f021e0 <TftpHandler+0x24c>
 3f02138:	e2433001 	sub	r3, r3, #1	; 0x1
 3f0213c:	e1a03483 	mov	r3, r3, lsl #9
 3f02140:	e5900000 	ldr	r0, [r0]
 3f02144:	e0834005 	add	r4, r3, r5
 3f02148:	e0800003 	add	r0, r0, r3
 3f0214c:	eb00350d 	bl	3f0f588 <memcpy>
 3f02150:	e59f208c 	ldr	r2, [pc, #8c]	; 3f021e4 <TftpHandler+0x250>
 3f02154:	e5923000 	ldr	r3, [r2]
 3f02158:	e1530004 	cmp	r3, r4
 3f0215c:	35824000 	strcc	r4, [r2]
 3f02160:	ebffff1c 	bl	3f01dd8 <TftpSend>
 3f02164:	e3550c02 	cmp	r5, #512	; 0x200
 3f02168:	291bacf0 	ldmcsdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f0216c:	e59f0074 	ldr	r0, [pc, #74]	; 3f021e8 <TftpHandler+0x254>
 3f02170:	eb0029a6 	bl	3f0c810 <puts>
 3f02174:	e59f2070 	ldr	r2, [pc, #70]	; 3f021ec <TftpHandler+0x258>
 3f02178:	e3a03003 	mov	r3, #3	; 0x3
 3f0217c:	e5823000 	str	r3, [r2]
 3f02180:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f02184:	e0d430b2 	ldrh	r3, [r4], #2
 3f02188:	e59f0060 	ldr	r0, [pc, #60]	; 3f021f0 <TftpHandler+0x25c>
 3f0218c:	e1a01004 	mov	r1, r4


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f02190:	e1a02423 	mov	r2, r3, lsr #8
 3f02194:	e1a02802 	mov	r2, r2, lsl #16
 3f02198:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f0219c:	e1a02822 	mov	r2, r2, lsr #16
 3f021a0:	eb0029a7 	bl	3f0c844 <printf>
 3f021a4:	e59f0048 	ldr	r0, [pc, #48]	; 3f021f4 <TftpHandler+0x260>
 3f021a8:	eb002998 	bl	3f0c810 <puts>
 3f021ac:	ebfffc40 	bl	3f012b4 <NetStartAgain>
}
 3f021b0:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f021b4:	03f6cbd0 	mvneqs	r12, #212992	; 0x34000
 3f021b8:	03f6cbe0 	mvneqs	r12, #229376	; 0x38000
 3f021bc:	03f6cbcc 	mvneqs	r12, #208896	; 0x33000
 3f021c0:	cccccccd 	stcgtl	12, cr12, [r12], #820
 3f021c4:	03f6cbd8 	mvneqs	r12, #221184	; 0x36000
 3f021c8:	c9a633fd 	stmgtib	r6!, {r0, r2, r3, r4, r5, r6, r7, r8, r9, r12, r13}
 3f021cc:	03f1acd0 	mvneqs	r10, #53248	; 0xd000
 3f021d0:	03f6cbdc 	mvneqs	r12, #225280	; 0x37000
 3f021d4:	03f1acd4 	mvneqs	r10, #54272	; 0xd400
 3f021d8:	02328000 	eoreqs	r8, r2, #0	; 0x0
 3f021dc:	03f021f8 	mvneqs	r2, #62	; 0x3e
 3f021e0:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
 3f021e4:	03f6a6ac 	mvneqs	r10, #180355072	; 0xac00000
 3f021e8:	03f1ad14 	mvneqs	r10, #1280	; 0x500
 3f021ec:	03f6a6dc 	mvneqs	r10, #230686720	; 0xdc00000
 3f021f0:	03f1ad1c 	mvneqs	r10, #1792	; 0x700
 3f021f4:	03f1ad34 	mvneqs	r10, #3328	; 0xd00

03f021f8 <TftpTimeout>:
 3f021f8:	e1a0c00d 	mov	r12, r13
 3f021fc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}


static void
TftpTimeout (void)
{
	if (++TftpTimeoutCount > TIMEOUT_COUNT) {
 3f02200:	e59f2040 	ldr	r2, [pc, #40]	; 3f02248 <TftpTimeout+0x50>
 3f02204:	e5923000 	ldr	r3, [r2]
 3f02208:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0220c:	e2833001 	add	r3, r3, #1	; 0x1
 3f02210:	e353000a 	cmp	r3, #10	; 0xa
 3f02214:	e5823000 	str	r3, [r2]
 3f02218:	da000003 	ble	3f0222c <TftpTimeout+0x34>
		puts ("\nRetry count exceeded; starting again\n");
 3f0221c:	e59f0028 	ldr	r0, [pc, #28]	; 3f0224c <TftpTimeout+0x54>
 3f02220:	eb00297a 	bl	3f0c810 <puts>
		NetStartAgain ();
 3f02224:	ebfffc22 	bl	3f012b4 <NetStartAgain>
	} else {
 3f02228:	e91ba800 	ldmdb	r11, {r11, r13, r15}
		puts ("T ");
 3f0222c:	e59f001c 	ldr	r0, [pc, #1c]	; 3f02250 <TftpTimeout+0x58>
 3f02230:	eb002976 	bl	3f0c810 <puts>
		NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);
 3f02234:	e59f0018 	ldr	r0, [pc, #18]	; 3f02254 <TftpTimeout+0x5c>
 3f02238:	e59f1018 	ldr	r1, [pc, #18]	; 3f02258 <TftpTimeout+0x60>
 3f0223c:	ebfffc2f 	bl	3f01300 <NetSetTimeout>
		TftpSend ();
 3f02240:	ebfffee4 	bl	3f01dd8 <TftpSend>
	}
 3f02244:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f02248:	03f6cbd4 	mvneqs	r12, #217088	; 0x35000
 3f0224c:	03f1ad48 	mvneqs	r10, #4608	; 0x1200
 3f02250:	03f1ad70 	mvneqs	r10, #7168	; 0x1c00
 3f02254:	02328000 	eoreqs	r8, r2, #0	; 0x0
 3f02258:	03f021f8 	mvneqs	r2, #62	; 0x3e

03f0225c <TftpStart>:
 3f0225c:	e1a0c00d 	mov	r12, r13
 3f02260:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
}


void
TftpStart (void)
{
	if (BootFile[0] == '\0') {
 3f02264:	e59f2078 	ldr	r2, [pc, #78]	; 3f022e4 <TftpStart+0x88>
 3f02268:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f0226c:	e5d23000 	ldrb	r3, [r2]
 3f02270:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f02274:	e3530000 	cmp	r3, #0	; 0x0
 3f02278:	1a00001f 	bne	3f022fc <TftpStart+0xa0>
		IPaddr_t OurIP = ntohl(NetOurIP);

		sprintf(default_filename, "%02lX%02lX%02lX%02lX.img",
 3f0227c:	e59f1064 	ldr	r1, [pc, #64]	; 3f022e8 <TftpStart+0x8c>
 3f02280:	e59f3064 	ldr	r3, [pc, #64]	; 3f022ec <TftpStart+0x90>
 3f02284:	e59f4064 	ldr	r4, [pc, #64]	; 3f022f0 <TftpStart+0x94>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f02288:	e593c000 	ldr	r12, [r3]
 3f0228c:	e1a00004 	mov	r0, r4
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f02290:	e20c3cff 	and	r3, r12, #65280	; 0xff00
 3f02294:	e1a03403 	mov	r3, r3, lsl #8
 3f02298:	e1833c0c 	orr	r3, r3, r12, lsl #24
 3f0229c:	e20c28ff 	and	r2, r12, #16711680	; 0xff0000
 3f022a0:	e1833422 	orr	r3, r3, r2, lsr #8
 3f022a4:	e1833c2c 	orr	r3, r3, r12, lsr #24
 3f022a8:	e20320ff 	and	r2, r3, #255	; 0xff
 3f022ac:	e1a0c823 	mov	r12, r3, lsr #16
 3f022b0:	e20cc0ff 	and	r12, r12, #255	; 0xff
 3f022b4:	e58dc000 	str	r12, [r13]
 3f022b8:	e1a0cc23 	mov	r12, r3, lsr #24
 3f022bc:	e1a03423 	mov	r3, r3, lsr #8
 3f022c0:	e20330ff 	and	r3, r3, #255	; 0xff
 3f022c4:	e58dc004 	str	r12, [r13, #4]
 3f022c8:	eb00375b 	bl	3f1003c <sprintf>
			OurIP & 0xFF,
			(OurIP >>  8) & 0xFF,
			(OurIP >> 16) & 0xFF,
			(OurIP >> 24) & 0xFF	);
		tftp_filename = default_filename;

		printf ("*** Warning: no boot file name; using '%s'\n",
 3f022cc:	e59f0020 	ldr	r0, [pc, #20]	; 3f022f4 <TftpStart+0x98>
 3f022d0:	e59f3020 	ldr	r3, [pc, #20]	; 3f022f8 <TftpStart+0x9c>
 3f022d4:	e1a01004 	mov	r1, r4
 3f022d8:	e5834000 	str	r4, [r3]
 3f022dc:	eb002958 	bl	3f0c844 <printf>
			tftp_filename);
	} else {
 3f022e0:	ea000007 	b	3f02304 <TftpStart+0xa8>
 3f022e4:	03f6a6e0 	mvneqs	r10, #234881024	; 0xe000000
 3f022e8:	03f1ad74 	mvneqs	r10, #7424	; 0x1d00
 3f022ec:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
 3f022f0:	03f6cbe4 	mvneqs	r12, #233472	; 0x39000
 3f022f4:	03f1ad90 	mvneqs	r10, #9216	; 0x2400
 3f022f8:	03f6cbf4 	mvneqs	r12, #249856	; 0x3d000
		tftp_filename = BootFile;
 3f022fc:	e59f315c 	ldr	r3, [pc, #15c]	; 3f02460 <TftpStart+0x204>
 3f02300:	e5832000 	str	r2, [r3]
	}

	puts ("TFTP from server ");	print_IPaddr (NetServerIP);
 3f02304:	e59f0158 	ldr	r0, [pc, #158]	; 3f02464 <TftpStart+0x208>
 3f02308:	e59f6158 	ldr	r6, [pc, #158]	; 3f02468 <TftpStart+0x20c>
 3f0230c:	eb00293f 	bl	3f0c810 <puts>
 3f02310:	e5960000 	ldr	r0, [r6]
 3f02314:	ebfffe9f 	bl	3f01d98 <print_IPaddr>
	puts ("; our IP address is ");	print_IPaddr (NetOurIP);
 3f02318:	e59f014c 	ldr	r0, [pc, #14c]	; 3f0246c <TftpStart+0x210>
 3f0231c:	e59f414c 	ldr	r4, [pc, #14c]	; 3f02470 <TftpStart+0x214>
 3f02320:	eb00293a 	bl	3f0c810 <puts>
 3f02324:	e5940000 	ldr	r0, [r4]

	/* Check if we need to send across this subnet */
	if (NetOurGatewayIP && NetOurSubnetMask) {
 3f02328:	e59f5144 	ldr	r5, [pc, #144]	; 3f02474 <TftpStart+0x218>
 3f0232c:	ebfffe99 	bl	3f01d98 <print_IPaddr>
 3f02330:	e5953000 	ldr	r3, [r5]
 3f02334:	e3530000 	cmp	r3, #0	; 0x0
 3f02338:	0a00000d 	beq	3f02374 <TftpStart+0x118>
 3f0233c:	e59f3134 	ldr	r3, [pc, #134]	; 3f02478 <TftpStart+0x21c>
 3f02340:	e5930000 	ldr	r0, [r3]
 3f02344:	e3500000 	cmp	r0, #0	; 0x0
 3f02348:	0a000009 	beq	3f02374 <TftpStart+0x118>
	    IPaddr_t OurNet 	= NetOurIP    & NetOurSubnetMask;
 3f0234c:	e5942000 	ldr	r2, [r4]
	    IPaddr_t ServerNet 	= NetServerIP & NetOurSubnetMask;
 3f02350:	e5963000 	ldr	r3, [r6]
 3f02354:	e0022000 	and	r2, r2, r0
 3f02358:	e0033000 	and	r3, r3, r0

	    if (OurNet != ServerNet) {
 3f0235c:	e1520003 	cmp	r2, r3
 3f02360:	0a000003 	beq	3f02374 <TftpStart+0x118>
		puts ("; sending through gateway ");
 3f02364:	e59f0110 	ldr	r0, [pc, #110]	; 3f0247c <TftpStart+0x220>
 3f02368:	eb002928 	bl	3f0c810 <puts>
		print_IPaddr (NetOurGatewayIP) ;
 3f0236c:	e5950000 	ldr	r0, [r5]
 3f02370:	ebfffe88 	bl	3f01d98 <print_IPaddr>
	    }
	}
	putc ('\n');
 3f02374:	e3a0000a 	mov	r0, #10	; 0xa
 3f02378:	eb002917 	bl	3f0c7dc <putc>

	printf ("Filename '%s'.", tftp_filename);
 3f0237c:	e59f30dc 	ldr	r3, [pc, #dc]	; 3f02460 <TftpStart+0x204>
 3f02380:	e59f00f8 	ldr	r0, [pc, #f8]	; 3f02480 <TftpStart+0x224>
 3f02384:	e5931000 	ldr	r1, [r3]

	if (NetBootFileSize) {
 3f02388:	e59f40f4 	ldr	r4, [pc, #f4]	; 3f02484 <TftpStart+0x228>
 3f0238c:	eb00292c 	bl	3f0c844 <printf>
 3f02390:	e1d430b0 	ldrh	r3, [r4]
 3f02394:	e3530000 	cmp	r3, #0	; 0x0
 3f02398:	0a000007 	beq	3f023bc <TftpStart+0x160>
		printf (" Size is 0x%x Bytes = ", NetBootFileSize<<9);
 3f0239c:	e1a01003 	mov	r1, r3
 3f023a0:	e59f00e0 	ldr	r0, [pc, #e0]	; 3f02488 <TftpStart+0x22c>
 3f023a4:	e1a01481 	mov	r1, r1, lsl #9
 3f023a8:	eb002925 	bl	3f0c844 <printf>
		print_size (NetBootFileSize<<9, "");
 3f023ac:	e1d400b0 	ldrh	r0, [r4]
 3f023b0:	e59f10d4 	ldr	r1, [pc, #d4]	; 3f0248c <TftpStart+0x230>
 3f023b4:	e1a00480 	mov	r0, r0, lsl #9
 3f023b8:	eb0032f7 	bl	3f0ef9c <print_size>
	}

	putc ('\n');
 3f023bc:	e3a0000a 	mov	r0, #10	; 0xa
 3f023c0:	eb002905 	bl	3f0c7dc <putc>

	printf ("Load address: 0x%lx\n", load_addr);
 3f023c4:	e59f30c4 	ldr	r3, [pc, #c4]	; 3f02490 <TftpStart+0x234>
 3f023c8:	e59f00c4 	ldr	r0, [pc, #c4]	; 3f02494 <TftpStart+0x238>
 3f023cc:	e5931000 	ldr	r1, [r3]
 3f023d0:	eb00291b 	bl	3f0c844 <printf>

	puts ("Loading: *\b");
 3f023d4:	e59f00bc 	ldr	r0, [pc, #bc]	; 3f02498 <TftpStart+0x23c>
 3f023d8:	eb00290c 	bl	3f0c810 <puts>

	NetSetTimeout (TIMEOUT * CFG_HZ, TftpTimeout);
 3f023dc:	e59f00b8 	ldr	r0, [pc, #b8]	; 3f0249c <TftpStart+0x240>
 3f023e0:	e59f10b8 	ldr	r1, [pc, #b8]	; 3f024a0 <TftpStart+0x244>
 3f023e4:	ebfffbc5 	bl	3f01300 <NetSetTimeout>
	NetSetHandler (TftpHandler);
 3f023e8:	e59f00b4 	ldr	r0, [pc, #b4]	; 3f024a4 <TftpStart+0x248>
 3f023ec:	ebfffbbc 	bl	3f012e4 <NetSetHandler>

	TftpServerPort = WELL_KNOWN_PORT;
 3f023f0:	e59f20b0 	ldr	r2, [pc, #b0]	; 3f024a8 <TftpStart+0x24c>
 3f023f4:	e3a03045 	mov	r3, #69	; 0x45
 3f023f8:	e5823000 	str	r3, [r2]
	TftpTimeoutCount = 0;
 3f023fc:	e59f30a8 	ldr	r3, [pc, #a8]	; 3f024ac <TftpStart+0x250>
 3f02400:	e3a04000 	mov	r4, #0	; 0x0
	TftpState = STATE_RRQ;
 3f02404:	e59f20a4 	ldr	r2, [pc, #a4]	; 3f024b0 <TftpStart+0x254>
	TftpOurPort = 1024 + (get_timer(0) % 3072);
 3f02408:	e1a00004 	mov	r0, r4
 3f0240c:	e5834000 	str	r4, [r3]
 3f02410:	e3a03001 	mov	r3, #1	; 0x1
 3f02414:	e5823000 	str	r3, [r2]
 3f02418:	ebfff8eb 	bl	3f007cc <get_timer>
 3f0241c:	e59f3090 	ldr	r3, [pc, #90]	; 3f024b4 <TftpStart+0x258>
 3f02420:	e1a0c000 	mov	r12, r0
 3f02424:	e083239c 	umull	r2, r3, r12, r3
	TftpBlock = 0;

	/* zero out server ether in case the server ip has changed */
	memset(NetServerEther, 0, 6);
 3f02428:	e59f0088 	ldr	r0, [pc, #88]	; 3f024b8 <TftpStart+0x25c>
 3f0242c:	e1a01004 	mov	r1, r4
 3f02430:	e59fe084 	ldr	r14, [pc, #84]	; 3f024bc <TftpStart+0x260>
 3f02434:	e3a02006 	mov	r2, #6	; 0x6
 3f02438:	e58e4000 	str	r4, [r14]
 3f0243c:	e1a035a3 	mov	r3, r3, lsr #11
 3f02440:	e0833083 	add	r3, r3, r3, lsl #1
 3f02444:	e04cc503 	sub	r12, r12, r3, lsl #10
 3f02448:	e59f3070 	ldr	r3, [pc, #70]	; 3f024c0 <TftpStart+0x264>
 3f0244c:	e28ccb01 	add	r12, r12, #1024	; 0x400
 3f02450:	e583c000 	str	r12, [r3]
 3f02454:	eb003431 	bl	3f0f520 <memset>

	TftpSend ();
 3f02458:	ebfffe5e 	bl	3f01dd8 <TftpSend>
 3f0245c:	ea000018 	b	3f024c4 <TftpStart+0x268>
 3f02460:	03f6cbf4 	mvneqs	r12, #249856	; 0x3d000
 3f02464:	03f1adbc 	mvneqs	r10, #12032	; 0x2f00
 3f02468:	03f6a6bc 	mvneqs	r10, #197132288	; 0xbc00000
 3f0246c:	03f1add0 	mvneqs	r10, #13312	; 0x3400
 3f02470:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
 3f02474:	03f20428 	mvneqs	r0, #671088640	; 0x28000000
 3f02478:	03f20424 	mvneqs	r0, #603979776	; 0x24000000
 3f0247c:	03f1ade8 	mvneqs	r10, #14848	; 0x3a00
 3f02480:	03f1ae04 	mvneqs	r10, #64	; 0x40
 3f02484:	03f204b0 	mvneqs	r0, #-1342177280	; 0xb0000000
 3f02488:	03f1ae14 	mvneqs	r10, #320	; 0x140
 3f0248c:	03f1ae2c 	mvneqs	r10, #704	; 0x2c0
 3f02490:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
 3f02494:	03f1ae30 	mvneqs	r10, #768	; 0x300
 3f02498:	03f1ae48 	mvneqs	r10, #1152	; 0x480
 3f0249c:	02328000 	eoreqs	r8, r2, #0	; 0x0
 3f024a0:	03f021f8 	mvneqs	r2, #62	; 0x3e
 3f024a4:	03f01f94 	mvneqs	r1, #592	; 0x250
 3f024a8:	03f6cbcc 	mvneqs	r12, #208896	; 0x33000
 3f024ac:	03f6cbd4 	mvneqs	r12, #217088	; 0x35000
 3f024b0:	03f6cbe0 	mvneqs	r12, #229376	; 0x38000
 3f024b4:	aaaaaaab 	bge	29acf68 <*ABS*+0x29acf68>
 3f024b8:	03f204b2 	mvneqs	r0, #-1308622848	; 0xb2000000
 3f024bc:	03f6cbd8 	mvneqs	r12, #221184	; 0x36000
 3f024c0:	03f6cbd0 	mvneqs	r12, #212992	; 0x34000
}
 3f024c4:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f024c8 <BootpCheckPkt>:
 3f024c8:	e1a0c00d 	mov	r12, r13
 3f024cc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f024d0:	e24cb004 	sub	r11, r12, #4	; 0x4
{
	Bootp_t *bp = (Bootp_t *) pkt;
	int retval = 0;

	if (dest != PORT_BOOTPC || src != PORT_BOOTPS)
 3f024d4:	e3520043 	cmp	r2, #67	; 0x43
 3f024d8:	03510044 	cmpeq	r1, #68	; 0x44
 3f024dc:	e1a01000 	mov	r1, r0
 3f024e0:	e24dd004 	sub	r13, r13, #4	; 0x4
		retval = -1;
 3f024e4:	13e00000 	mvnne	r0, #0	; 0x0
 3f024e8:	1a00001c 	bne	3f02560 <BootpCheckPkt+0x98>
	else if (len < sizeof (Bootp_t) - OPT_SIZE)
 3f024ec:	e35300eb 	cmp	r3, #235	; 0xeb
		retval = -2;
 3f024f0:	93e00001 	mvnls	r0, #1	; 0x1
 3f024f4:	9a000019 	bls	3f02560 <BootpCheckPkt+0x98>
	else if (bp->bp_op != OP_BOOTREQUEST &&
 3f024f8:	e5d12000 	ldrb	r2, [r1]
 3f024fc:	e2423001 	sub	r3, r2, #1	; 0x1
 3f02500:	e3520005 	cmp	r2, #5	; 0x5
 3f02504:	13530001 	cmpne	r3, #1	; 0x1
 3f02508:	9a000002 	bls	3f02518 <BootpCheckPkt+0x50>
 3f0250c:	e3520006 	cmp	r2, #6	; 0x6
	    bp->bp_op != OP_BOOTREPLY &&
	    bp->bp_op != DHCP_OFFER &&
	    bp->bp_op != DHCP_ACK &&
	    bp->bp_op != DHCP_NAK ) {
		retval = -3;
 3f02510:	13e00002 	mvnne	r0, #2	; 0x2
	}
 3f02514:	1a000011 	bne	3f02560 <BootpCheckPkt+0x98>
	else if (bp->bp_htype != HWT_ETHER)
 3f02518:	e5d13001 	ldrb	r3, [r1, #1]
 3f0251c:	e3530001 	cmp	r3, #1	; 0x1
		retval = -4;
 3f02520:	13e00003 	mvnne	r0, #3	; 0x3
 3f02524:	1a00000d 	bne	3f02560 <BootpCheckPkt+0x98>
	else if (bp->bp_hlen != HWL_ETHER)
 3f02528:	e5d13002 	ldrb	r3, [r1, #2]
 3f0252c:	e3530006 	cmp	r3, #6	; 0x6
		retval = -5;
 3f02530:	e3e00004 	mvn	r0, #4	; 0x4
 3f02534:	1a000009 	bne	3f02560 <BootpCheckPkt+0x98>
/* return ulong *in network byteorder* */
static inline ulong NetReadLong(ulong *from)
{
	ulong l;
	memcpy((void*)&l, (void*)from, sizeof(l));
 3f02538:	e24b0010 	sub	r0, r11, #16	; 0x10
 3f0253c:	e2811004 	add	r1, r1, #4	; 0x4
 3f02540:	e3a02004 	mov	r2, #4	; 0x4
 3f02544:	eb00340f 	bl	3f0f588 <memcpy>
	else if (NetReadLong((ulong*)&bp->bp_id) != BootpID) {
 3f02548:	e59f3014 	ldr	r3, [pc, #14]	; 3f02564 <BootpCheckPkt+0x9c>
static inline ulong NetReadLong(ulong *from)
{
	ulong l;
	memcpy((void*)&l, (void*)from, sizeof(l));
	return l;
 3f0254c:	e51b2010 	ldr	r2, [r11, -#16]
 3f02550:	e5933000 	ldr	r3, [r3]
 3f02554:	e1520003 	cmp	r2, r3
 3f02558:	03a00000 	moveq	r0, #0	; 0x0
 3f0255c:	13e00005 	mvnne	r0, #5	; 0x5
		retval = -6;
	}
 3f02560:	ea000000 	b	3f02568 <BootpCheckPkt+0xa0>
 3f02564:	03f6cbf8 	mvneqs	r12, #253952	; 0x3e000

	debug ("Filtering pkt = %d\n", retval);

	return retval;
}
 3f02568:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0256c <BootpCopyNetParams>:
 3f0256c:	e1a0c00d 	mov	r12, r13
 3f02570:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f02574:	e24cb004 	sub	r11, r12, #4	; 0x4

/*
 * Copy parameters of interest from BOOTP_REPLY/DHCP_OFFER packet
 */
static void BootpCopyNetParams(Bootp_t *bp)
{
 3f02578:	e1a04000 	mov	r4, r0

/* copy IP */
static inline void NetCopyIP(void *to, void *from)
{
	memcpy(to, from, sizeof(IPaddr_t));
 3f0257c:	e2841010 	add	r1, r4, #16	; 0x10
 3f02580:	e59f005c 	ldr	r0, [pc, #5c]	; 3f025e4 <BootpCopyNetParams+0x78>
 3f02584:	e3a02004 	mov	r2, #4	; 0x4
 3f02588:	eb0033fe 	bl	3f0f588 <memcpy>
 3f0258c:	e2841014 	add	r1, r4, #20	; 0x14
 3f02590:	e59f0050 	ldr	r0, [pc, #50]	; 3f025e8 <BootpCopyNetParams+0x7c>
 3f02594:	e3a02004 	mov	r2, #4	; 0x4
 3f02598:	eb0033fa 	bl	3f0f588 <memcpy>
	NetCopyIP(&NetOurIP, &bp->bp_yiaddr);
	NetCopyIP(&NetServerIP, &bp->bp_siaddr);
	memcpy (NetServerEther, ((Ethernet_t *)NetRxPkt)->et_src, 6);
 3f0259c:	e59f3048 	ldr	r3, [pc, #48]	; 3f025ec <BootpCopyNetParams+0x80>
 3f025a0:	e59f0048 	ldr	r0, [pc, #48]	; 3f025f0 <BootpCopyNetParams+0x84>
 3f025a4:	e5931000 	ldr	r1, [r3]
 3f025a8:	e3a02006 	mov	r2, #6	; 0x6
	copy_filename (BootFile, bp->bp_file, sizeof(BootFile));
 3f025ac:	e59f5040 	ldr	r5, [pc, #40]	; 3f025f4 <BootpCopyNetParams+0x88>
 3f025b0:	e0811002 	add	r1, r1, r2
 3f025b4:	eb0033f3 	bl	3f0f588 <memcpy>
 3f025b8:	e1a00005 	mov	r0, r5
 3f025bc:	e284106c 	add	r1, r4, #108	; 0x6c
 3f025c0:	e3a02080 	mov	r2, #128	; 0x80
 3f025c4:	ebfffd9f 	bl	3f01c48 <copy_filename>

	debug ("Bootfile: %s\n", BootFile);

	/* Propagate to environment:
	 * don't delete exising entry when BOOTP / DHCP reply does
	 * not contain a new value
	 */
	if (*BootFile) {
 3f025c8:	e5d53000 	ldrb	r3, [r5]
 3f025cc:	e3530000 	cmp	r3, #0	; 0x0
 3f025d0:	091ba830 	ldmeqdb	r11, {r4, r5, r11, r13, r15}
		setenv ("bootfile", BootFile);
 3f025d4:	e59f001c 	ldr	r0, [pc, #1c]	; 3f025f8 <BootpCopyNetParams+0x8c>
 3f025d8:	e1a01005 	mov	r1, r5
 3f025dc:	eb00267d 	bl	3f0bfd8 <setenv>
	}
}
 3f025e0:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f025e4:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
 3f025e8:	03f6a6bc 	mvneqs	r10, #197132288	; 0xbc00000
 3f025ec:	03f6a6d0 	mvneqs	r10, #218103808	; 0xd000000
 3f025f0:	03f204b2 	mvneqs	r0, #-1308622848	; 0xb2000000
 3f025f4:	03f6a6e0 	mvneqs	r10, #234881024	; 0xe000000
 3f025f8:	03f1ae54 	mvneqs	r10, #1344	; 0x540

03f025fc <truncate_sz>:
 3f025fc:	e1a0c00d 	mov	r12, r13
 3f02600:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f02604:	e24cb004 	sub	r11, r12, #4	; 0x4

static int truncate_sz (const char *name, int maxlen, int curlen)
{
 3f02608:	e1a03000 	mov	r3, r0
 3f0260c:	e1a04001 	mov	r4, r1
	if (curlen >= maxlen) {
 3f02610:	e1520004 	cmp	r2, r4
 3f02614:	ba000004 	blt	3f0262c <truncate_sz+0x30>
		printf("*** WARNING: %s is too long (%d - max: %d) - truncated\n",
 3f02618:	e1a01003 	mov	r1, r3
 3f0261c:	e59f0010 	ldr	r0, [pc, #10]	; 3f02634 <truncate_sz+0x38>
 3f02620:	e1a03004 	mov	r3, r4
 3f02624:	eb002886 	bl	3f0c844 <printf>
			name, curlen, maxlen);
		curlen = maxlen - 1;
 3f02628:	e2442001 	sub	r2, r4, #1	; 0x1
	}
	return (curlen);
 3f0262c:	e1a00002 	mov	r0, r2
 3f02630:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f02634:	03f1ae60 	mvneqs	r10, #1536	; 0x600

03f02638 <BootpVendorFieldProcess>:
 3f02638:	e1a0c00d 	mov	r12, r13
 3f0263c:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f02640:	e24cb004 	sub	r11, r12, #4	; 0x4
}

#if !(CONFIG_COMMANDS & CFG_CMD_DHCP)

static void BootpVendorFieldProcess(u8 *ext)
{
    int size = *(ext+1) ;

    debug_ext ("[BOOTP] Processing extension %d... (%d bytes)\n", *ext, *(ext+1));

    NetBootFileSize = 0;
 3f02644:	e59fc1e0 	ldr	r12, [pc, #1e0]	; 3f0282c <BootpVendorFieldProcess+0x1f4>
 3f02648:	e1a05000 	mov	r5, r0
 3f0264c:	e5d54001 	ldrb	r4, [r5, #1]
 3f02650:	e3a03000 	mov	r3, #0	; 0x0
 3f02654:	e1cc30b0 	strh	r3, [r12]

    switch (*ext) {
 3f02658:	e5d53000 	ldrb	r3, [r5]
 3f0265c:	e2433001 	sub	r3, r3, #1	; 0x1
 3f02660:	e353002a 	cmp	r3, #42	; 0x2a
 3f02664:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f02668:	ea00006e 	b	3f02828 <BootpVendorFieldProcess+0x1f0>
 3f0266c:	03f02718 	mvneqs	r2, #6291456	; 0x600000
 3f02670:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02674:	03f02738 	mvneqs	r2, #14680064	; 0xe00000
 3f02678:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f0267c:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02680:	03f02740 	mvneqs	r2, #16777216	; 0x1000000
 3f02684:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02688:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f0268c:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02690:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02694:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02698:	03f02748 	mvneqs	r2, #18874368	; 0x1200000
 3f0269c:	03f02784 	mvneqs	r2, #34603008	; 0x2100000
 3f026a0:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026a4:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026a8:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026ac:	03f027d4 	mvneqs	r2, #55574528	; 0x3500000
 3f026b0:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026b4:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026b8:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026bc:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026c0:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026c4:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026c8:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026cc:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026d0:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026d4:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026d8:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026dc:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026e0:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026e4:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026e8:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026ec:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026f0:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026f4:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026f8:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f026fc:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02700:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02704:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02708:	03f027f0 	mvneqs	r2, #62914560	; 0x3c00000
 3f0270c:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02710:	03f02828 	mvneqs	r2, #2621440	; 0x280000
 3f02714:	03f02828 	mvneqs	r2, #2621440	; 0x280000
    /* Fixed length fields */
	case 1:		/* Subnet mask					*/
		if (NetOurSubnetMask == 0)
 3f02718:	e59f0110 	ldr	r0, [pc, #110]	; 3f02830 <BootpVendorFieldProcess+0x1f8>
 3f0271c:	e5903000 	ldr	r3, [r0]
 3f02720:	e3530000 	cmp	r3, #0	; 0x0
 3f02724:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}

/* copy IP */
static inline void NetCopyIP(void *to, void *from)
{
	memcpy(to, from, sizeof(IPaddr_t));
 3f02728:	e2851002 	add	r1, r5, #2	; 0x2
 3f0272c:	e3a02004 	mov	r2, #4	; 0x4
 3f02730:	eb003394 	bl	3f0f588 <memcpy>
			NetCopyIP(&NetOurSubnetMask, (IPaddr_t*)(ext+2));
		break;
 3f02734:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	case 2:		/* Time offset - Not yet supported		*/
		break;
    /* Variable length fields */
	case 3:		/* Gateways list				*/
		if (NetOurGatewayIP == 0) {
 3f02738:	e59f00f4 	ldr	r0, [pc, #f4]	; 3f02834 <BootpVendorFieldProcess+0x1fc>
			NetCopyIP(&NetOurGatewayIP, (IPaddr_t*)(ext+2));
		}
		break;
 3f0273c:	eafffff6 	b	3f0271c <BootpVendorFieldProcess+0xe4>
	case 4:		/* Time server - Not yet supported		*/
		break;
	case 5:		/* IEN-116 name server - Not yet supported	*/
		break;
	case 6:
		if (NetOurDNSIP == 0) {
 3f02740:	e59f00f0 	ldr	r0, [pc, #f0]	; 3f02838 <BootpVendorFieldProcess+0x200>
			NetCopyIP(&NetOurDNSIP, (IPaddr_t*)(ext+2));
		}
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS2)
		if ((NetOurDNS2IP == 0) && (size > 4)) {
			NetCopyIP(&NetOurDNS2IP, (IPaddr_t*)(ext+2+4));
		}
#endif
		break;
 3f02744:	eafffff4 	b	3f0271c <BootpVendorFieldProcess+0xe4>
	case 7:		/* Log server - Not yet supported		*/
		break;
	case 8:		/* Cookie/Quote server - Not yet supported	*/
		break;
	case 9:		/* LPR server - Not yet supported		*/
		break;
	case 10:	/* Impress server - Not yet supported		*/
		break;
	case 11:	/* RPL server - Not yet supported		*/
		break;
	case 12:	/* Host name					*/
		if (NetOurHostName[0] == 0) {
 3f02748:	e59f60ec 	ldr	r6, [pc, #ec]	; 3f0283c <BootpVendorFieldProcess+0x204>
 3f0274c:	e5d67000 	ldrb	r7, [r6]
 3f02750:	e3570000 	cmp	r7, #0	; 0x0
 3f02754:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}
		    size = truncate_sz("Host Name", sizeof(NetOurHostName), size);
 3f02758:	e3a01020 	mov	r1, #32	; 0x20
 3f0275c:	e59f00dc 	ldr	r0, [pc, #dc]	; 3f02840 <BootpVendorFieldProcess+0x208>
 3f02760:	e1a02004 	mov	r2, r4
 3f02764:	ebffffa4 	bl	3f025fc <truncate_sz>
 3f02768:	e1a04000 	mov	r4, r0
		    memcpy(&NetOurHostName, ext+2, size);
 3f0276c:	e1a00006 	mov	r0, r6
 3f02770:	e2851002 	add	r1, r5, #2	; 0x2
 3f02774:	e1a02004 	mov	r2, r4
 3f02778:	eb003382 	bl	3f0f588 <memcpy>
		    NetOurHostName[size] = 0 ;
 3f0277c:	e7c67004 	strb	r7, [r6, r4]
		}
		break;
 3f02780:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	case 13:	/* Boot file size				*/
		if (size == 2)
 3f02784:	e3540002 	cmp	r4, #2	; 0x2
 3f02788:	1a000006 	bne	3f027a8 <BootpVendorFieldProcess+0x170>
			NetBootFileSize = ntohs(*(ushort*)(ext+2));
 3f0278c:	e1d520b2 	ldrh	r2, [r5, #2]


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f02790:	e1a03422 	mov	r3, r2, lsr #8
 3f02794:	e1a03803 	mov	r3, r3, lsl #16
 3f02798:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f0279c:	e1a03823 	mov	r3, r3, lsr #16
 3f027a0:	e1cc30b0 	strh	r3, [r12]
 3f027a4:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
		else if (size == 4)
 3f027a8:	e3540004 	cmp	r4, #4	; 0x4
 3f027ac:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f027b0:	e5953002 	ldr	r3, [r5, #2]
	return __arch__swab32(x);
 3f027b4:	e2032cff 	and	r2, r3, #65280	; 0xff00
 3f027b8:	e1a02402 	mov	r2, r2, lsl #8
 3f027bc:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f027c0:	e20318ff 	and	r1, r3, #16711680	; 0xff0000
 3f027c4:	e1822421 	orr	r2, r2, r1, lsr #8
 3f027c8:	e1822c23 	orr	r2, r2, r3, lsr #24
			NetBootFileSize = ntohl(*(ulong*)(ext+2));
 3f027cc:	e1cc20b0 	strh	r2, [r12]
		break;
 3f027d0:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	case 14:	/* Merit dump file - Not yet supported		*/
		break;
	case 15:	/* Domain name - Not yet supported		*/
		break;
	case 16:	/* Swap server - Not yet supported		*/
		break;
	case 17:	/* Root path					*/
		if (NetOurRootPath[0] == 0) {
 3f027d4:	e59f6068 	ldr	r6, [pc, #68]	; 3f02844 <BootpVendorFieldProcess+0x20c>
 3f027d8:	e5d67000 	ldrb	r7, [r6]
 3f027dc:	e3570000 	cmp	r7, #0	; 0x0
 3f027e0:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}
		    size = truncate_sz("Root Path", sizeof(NetOurRootPath), size);
 3f027e4:	e3a01040 	mov	r1, #64	; 0x40
 3f027e8:	e59f0058 	ldr	r0, [pc, #58]	; 3f02848 <BootpVendorFieldProcess+0x210>
		    memcpy(&NetOurRootPath, ext+2, size);
		    NetOurRootPath[size] = 0 ;
		}
		break;
 3f027ec:	eaffffdb 	b	3f02760 <BootpVendorFieldProcess+0x128>
	case 18:	/* Extension path - Not yet supported		*/
		/*
		 * This can be used to send the information of the
		 * vendor area in another file that the client can
		 * access via TFTP.
		 */
		break;
    /* IP host layer fields */
	case 40:	/* NIS Domain name				*/
		if (NetOurNISDomain[0] == 0) {
 3f027f0:	e59f6054 	ldr	r6, [pc, #54]	; 3f0284c <BootpVendorFieldProcess+0x214>
 3f027f4:	e5d67000 	ldrb	r7, [r6]
 3f027f8:	e3570000 	cmp	r7, #0	; 0x0
 3f027fc:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}
		    size = truncate_sz ("NIS Domain Name",
 3f02800:	e3a01020 	mov	r1, #32	; 0x20
 3f02804:	e59f0044 	ldr	r0, [pc, #44]	; 3f02850 <BootpVendorFieldProcess+0x218>
 3f02808:	e1a02004 	mov	r2, r4
 3f0280c:	ebffff7a 	bl	3f025fc <truncate_sz>
 3f02810:	e1a04000 	mov	r4, r0
					sizeof(NetOurNISDomain),
					size);
		    memcpy(&NetOurNISDomain, ext+2, size);
 3f02814:	e1a00006 	mov	r0, r6
 3f02818:	e2851002 	add	r1, r5, #2	; 0x2
 3f0281c:	e1a02004 	mov	r2, r4
 3f02820:	eb003358 	bl	3f0f588 <memcpy>
		    NetOurNISDomain[size] = 0 ;
 3f02824:	e7c67004 	strb	r7, [r6, r4]
		}
		break;
    /* Application layer fields */
	case 43:	/* Vendor specific info - Not yet supported	*/
		/*
		 * Binary information to exchange specific
		 * product information.
		 */
		break;
    /* Reserved (custom) fields (128..254) */
    }
}
 3f02828:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0282c:	03f204b0 	mvneqs	r0, #-1342177280	; 0xb0000000
 3f02830:	03f20424 	mvneqs	r0, #603979776	; 0x24000000
 3f02834:	03f20428 	mvneqs	r0, #671088640	; 0x28000000
 3f02838:	03f2042c 	mvneqs	r0, #738197504	; 0x2c000000
 3f0283c:	03f20450 	mvneqs	r0, #1342177280	; 0x50000000
 3f02840:	03f1ae98 	mvneqs	r10, #2432	; 0x980
 3f02844:	03f20470 	mvneqs	r0, #1879048192	; 0x70000000
 3f02848:	03f1aea4 	mvneqs	r10, #2624	; 0xa40
 3f0284c:	03f20430 	mvneqs	r0, #805306368	; 0x30000000
 3f02850:	03f1aeb0 	mvneqs	r10, #2816	; 0xb00

03f02854 <BootpVendorProcess>:
 3f02854:	e1a0c00d 	mov	r12, r13
 3f02858:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0285c:	e24cb004 	sub	r11, r12, #4	; 0x4

static void BootpVendorProcess(u8 *ext, int size)
{
 3f02860:	e1a04000 	mov	r4, r0
    u8 *end = ext + size ;
 3f02864:	e0845001 	add	r5, r4, r1

    debug_ext ("[BOOTP] Checking extension (%d bytes)...\n", size);

    while ((ext < end) && (*ext != 0xff)) {
 3f02868:	e1540005 	cmp	r4, r5
 3f0286c:	291ba830 	ldmcsdb	r11, {r4, r5, r11, r13, r15}
 3f02870:	e5d42000 	ldrb	r2, [r4]
 3f02874:	e20230ff 	and	r3, r2, #255	; 0xff
 3f02878:	e35300ff 	cmp	r3, #255	; 0xff
 3f0287c:	091ba830 	ldmeqdb	r11, {r4, r5, r11, r13, r15}
	if (*ext == 0) {
 3f02880:	e3520000 	cmp	r2, #0	; 0x0
	    ext ++ ;
 3f02884:	02844001 	addeq	r4, r4, #1	; 0x1
	} else {
 3f02888:	0a000006 	beq	3f028a8 <BootpVendorProcess+0x54>
		u8 *opt = ext ;
		ext += ext[1] + 2 ;
 3f0288c:	e5d43001 	ldrb	r3, [r4, #1]
 3f02890:	e1a00004 	mov	r0, r4
 3f02894:	e2833002 	add	r3, r3, #2	; 0x2
 3f02898:	e0844003 	add	r4, r4, r3
		if (ext <= end)
 3f0289c:	e1540005 	cmp	r4, r5
 3f028a0:	8a000000 	bhi	3f028a8 <BootpVendorProcess+0x54>
		    BootpVendorFieldProcess (opt) ;
 3f028a4:	ebffff63 	bl	3f02638 <BootpVendorFieldProcess>
	}
    }
 3f028a8:	e1540005 	cmp	r4, r5
 3f028ac:	291ba830 	ldmcsdb	r11, {r4, r5, r11, r13, r15}
 3f028b0:	e5d42000 	ldrb	r2, [r4]
 3f028b4:	e20230ff 	and	r3, r2, #255	; 0xff
 3f028b8:	e35300ff 	cmp	r3, #255	; 0xff
 3f028bc:	1affffef 	bne	3f02880 <BootpVendorProcess+0x2c>

#ifdef DEBUG_BOOTP_EXT
    printf("[BOOTP] Received fields: \n");
    if (NetOurSubnetMask) {
	puts ("NetOurSubnetMask	: ");
	print_IPaddr (NetOurSubnetMask);
	putc('\n');
    }

    if (NetOurGatewayIP) {
	puts ("NetOurGatewayIP	: ");
	print_IPaddr (NetOurGatewayIP);
	putc('\n');
    }

    if (NetBootFileSize) {
	printf("NetBootFileSize : %d\n", NetBootFileSize);
    }

    if (NetOurHostName[0]) {
	printf("NetOurHostName  : %s\n", NetOurHostName);
    }

    if (NetOurRootPath[0]) {
	printf("NetOurRootPath  : %s\n", NetOurRootPath);
    }

    if (NetOurNISDomain[0]) {
	printf("NetOurNISDomain : %s\n", NetOurNISDomain);
    }

    if (NetBootFileSize) {
	printf("NetBootFileSize: %d\n", NetBootFileSize);
    }
#endif	/* DEBUG_BOOTP_EXT */
}
 3f028c0:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f028c4 <BootpHandler>:
 3f028c4:	e1a0c00d 	mov	r12, r13
 3f028c8:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f028cc:	e24cb004 	sub	r11, r12, #4	; 0x4

/*
 *	Handle a BOOTP received packet.
 */
static void
BootpHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len)
{
 3f028d0:	e1a04000 	mov	r4, r0
 3f028d4:	e1a05003 	mov	r5, r3
	Bootp_t *bp;
	char	*s;

	debug ("got BOOTP packet (src=%d, dst=%d, len=%d want_len=%d)\n",
		src, dest, len, sizeof (Bootp_t));

	bp = (Bootp_t *)pkt;

	if (BootpCheckPkt(pkt, dest, src, len))	/* Filter out pkts we don't want */
 3f028d8:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f028dc:	ebfffef9 	bl	3f024c8 <BootpCheckPkt>
 3f028e0:	e2506000 	subs	r6, r0, #0	; 0x0
 3f028e4:	1a00001e 	bne	3f02964 <BootpHandler+0xa0>
		return;

	/*
	 *	Got a good BOOTP reply.  Copy the data into our variables.
	 */
#ifdef CONFIG_STATUS_LED
	status_led_set (STATUS_LED_BOOT, STATUS_LED_OFF);
#endif

	BootpCopyNetParams(bp);		/* Store net parameters from reply */
 3f028e8:	e1a00004 	mov	r0, r4
 3f028ec:	ebffff1e 	bl	3f0256c <BootpCopyNetParams>
/* return ulong *in network byteorder* */
static inline ulong NetReadLong(ulong *from)
{
	ulong l;
	memcpy((void*)&l, (void*)from, sizeof(l));
 3f028f0:	e24b001c 	sub	r0, r11, #28	; 0x1c
 3f028f4:	e28410ec 	add	r1, r4, #236	; 0xec
 3f028f8:	e3a02004 	mov	r2, #4	; 0x4
 3f028fc:	eb003321 	bl	3f0f588 <memcpy>
	return l;
 3f02900:	e51b201c 	ldr	r2, [r11, -#28]

	/* Retrieve extended information (we must parse the vendor area) */
	if (NetReadLong((ulong*)&bp->bp_vend[0]) == htonl(BOOTP_VENDOR_MAGIC))
 3f02904:	e59f3048 	ldr	r3, [pc, #48]	; 3f02954 <BootpHandler+0x90>
 3f02908:	e1520003 	cmp	r2, r3
 3f0290c:	1a000002 	bne	3f0291c <BootpHandler+0x58>
		BootpVendorProcess(&bp->bp_vend[4], len);
 3f02910:	e28400f0 	add	r0, r4, #240	; 0xf0
 3f02914:	e1a01005 	mov	r1, r5
 3f02918:	ebffffcd 	bl	3f02854 <BootpVendorProcess>

	NetSetTimeout(0, (thand_f *)0);
 3f0291c:	e1a00006 	mov	r0, r6
 3f02920:	e1a01000 	mov	r1, r0
 3f02924:	ebfffa75 	bl	3f01300 <NetSetTimeout>

	debug ("Got good BOOTP\n");

	if (((s = getenv("autoload")) != NULL) && (*s == 'n')) {
 3f02928:	e59f0028 	ldr	r0, [pc, #28]	; 3f02958 <BootpHandler+0x94>
 3f0292c:	eb0025ca 	bl	3f0c05c <getenv>
 3f02930:	e3500000 	cmp	r0, #0	; 0x0
 3f02934:	0a000009 	beq	3f02960 <BootpHandler+0x9c>
 3f02938:	e5d03000 	ldrb	r3, [r0]
 3f0293c:	e353006e 	cmp	r3, #110	; 0x6e
 3f02940:	1a000006 	bne	3f02960 <BootpHandler+0x9c>
		/*
		 * Just use BOOTP to configure system;
		 * Do not use TFTP to load the bootfile.
		 */
		NetState = NETLOOP_SUCCESS;
 3f02944:	e59f2010 	ldr	r2, [pc, #10]	; 3f0295c <BootpHandler+0x98>
 3f02948:	e3a03003 	mov	r3, #3	; 0x3
 3f0294c:	e5823000 	str	r3, [r2]
		return;
 3f02950:	ea000003 	b	3f02964 <BootpHandler+0xa0>
 3f02954:	63538263 	cmpvs	r3, #805306374	; 0x30000006
 3f02958:	03f1aec0 	mvneqs	r10, #3072	; 0xc00
 3f0295c:	03f6a6dc 	mvneqs	r10, #230686720	; 0xdc00000
	}

	TftpStart();
 3f02960:	ebfffe3d 	bl	3f0225c <TftpStart>
}
 3f02964:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f02968 <BootpTimeout>:
 3f02968:	e1a0c00d 	mov	r12, r13
 3f0296c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
#endif	/* !CFG_CMD_DHCP */

/*
 *	Timeout on BOOTP/DHCP request.
 */
static void
BootpTimeout(void)
{
	if (BootpTry >= TIMEOUT_COUNT) {
 3f02970:	e59f3030 	ldr	r3, [pc, #30]	; 3f029a8 <BootpTimeout+0x40>
 3f02974:	e5933000 	ldr	r3, [r3]
 3f02978:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0297c:	e3530004 	cmp	r3, #4	; 0x4
 3f02980:	da000003 	ble	3f02994 <BootpTimeout+0x2c>
		puts ("\nRetry count exceeded; starting again\n");
 3f02984:	e59f0020 	ldr	r0, [pc, #20]	; 3f029ac <BootpTimeout+0x44>
 3f02988:	eb0027a0 	bl	3f0c810 <puts>
		NetStartAgain ();
 3f0298c:	ebfffa48 	bl	3f012b4 <NetStartAgain>
	} else {
 3f02990:	e91ba800 	ldmdb	r11, {r11, r13, r15}
		NetSetTimeout (TIMEOUT * CFG_HZ, BootpTimeout);
 3f02994:	e59f0014 	ldr	r0, [pc, #14]	; 3f029b0 <BootpTimeout+0x48>
 3f02998:	e59f1014 	ldr	r1, [pc, #14]	; 3f029b4 <BootpTimeout+0x4c>
 3f0299c:	ebfffa57 	bl	3f01300 <NetSetTimeout>
		BootpRequest ();
 3f029a0:	eb000025 	bl	3f02a3c <BootpRequest>
	}
 3f029a4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f029a8:	03f6cbfc 	mvneqs	r12, #258048	; 0x3f000
 3f029ac:	03f1aecc 	mvneqs	r10, #3264	; 0xcc0
 3f029b0:	02328000 	eoreqs	r8, r2, #0	; 0x0
 3f029b4:	03f02968 	mvneqs	r2, #1703936	; 0x1a0000

03f029b8 <BootpExtended>:
 3f029b8:	e1a0c00d 	mov	r12, r13
 3f029bc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

/*
 *	Initialize BOOTP extension fields in the request.
 */
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
static int DhcpExtended(u8 *e, int message_type, IPaddr_t ServerID, IPaddr_t RequestedIP)
{
    u8 *start = e ;
    u8 *cnt;
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_VENDOREX)
    u8 *x;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_SEND_HOSTNAME)
    uchar *hostname;
#endif

    *e++ =  99;		/* RFC1048 Magic Cookie */
    *e++ = 130;
    *e++ =  83;
    *e++ =  99;

    *e++ = 53;		/* DHCP Message Type */
    *e++ = 1;
    *e++ = message_type;

    *e++ = 57;		/* Maximum DHCP Message Size */
    *e++ = 2;
    *e++ = (576-312+OPT_SIZE) >> 8;
    *e++ = (576-312+OPT_SIZE) & 0xff;

    if ( ServerID ) {
	    int tmp = ntohl(ServerID);

	    *e++ = 54;	/* ServerID */
	    *e++ = 4;
	    *e++ = tmp >> 24;
	    *e++ = tmp >> 16;
	    *e++ = tmp >> 8;
	    *e++ = tmp & 0xff;
    }

    if ( RequestedIP ) {
	    int tmp = ntohl(RequestedIP);

	    *e++ = 50;	/* Requested IP */
	    *e++ = 4;
	    *e++ = tmp >> 24;
	    *e++ = tmp >> 16;
	    *e++ = tmp >> 8;
	    *e++ = tmp & 0xff;
    }

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_SEND_HOSTNAME)
    if ( (hostname = getenv("hostname")) ) {
	    int hostnamelen = strlen(hostname);
	    *e++ = 12;        /* Hostname */
	    *e++ = hostnamelen;
	    memcpy(e,hostname,hostnamelen);
	    e += hostnamelen;
    }
#endif

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_VENDOREX)
    if ((x = dhcp_vendorex_prep (e)))
	return x - start ;
#endif

    *e++ = 55;		/* Parameter Request List */
    cnt  = e++;		/* Pointer to count of requested items */
    *cnt = 0;
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_SUBNETMASK)
    *e++ = 1;		/* Subnet Mask */
    *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_GATEWAY)
    *e++ = 3;		/* Router Option */
    *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS)
    *e++ = 6;		/* DNS Server(s) */
    *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_HOSTNAME)
    *e++ = 12;		/* Hostname */
    *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTFILESIZE)
    *e++ = 13;		/* Boot File Size */
    *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTPATH)
    *e++ = 17;		/* Boot path */
    *cnt += 1;
#endif
#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_NISDOMAIN)
    *e++ = 40;		/* NIS Domain name request */
    *cnt += 1;
#endif
    *e++ = 255;		/* End of the list */

    /* Pad to minimal length */
#ifdef	CONFIG_DHCP_MIN_EXT_LEN
    while ((e - start) <= CONFIG_DHCP_MIN_EXT_LEN)
	*e++ = 0;
#endif

    return e - start ;
}

#else	/* CFG_CMD_DHCP */
/*
 *	Warning: no field size check - change CONFIG_BOOTP_MASK at your own risk!
 */
static int BootpExtended (u8 *e)
{
    u8 *start = e ;
 3f029c0:	e1a01000 	mov	r1, r0

    *e++ =  99;		/* RFC1048 Magic Cookie */
 3f029c4:	e3a02063 	mov	r2, #99	; 0x63
 3f029c8:	e4c02001 	strb	r2, [r0], #1
    *e++ = 130;
 3f029cc:	e3a03082 	mov	r3, #130	; 0x82
 3f029d0:	e4c03001 	strb	r3, [r0], #1
    *e++ =  83;
 3f029d4:	e243302f 	sub	r3, r3, #47	; 0x2f
 3f029d8:	e4c03001 	strb	r3, [r0], #1
    *e++ =  99;
 3f029dc:	e4c02001 	strb	r2, [r0], #1

#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
    *e++ = 53;		/* DHCP Message Type */
    *e++ = 1;
    *e++ = DHCP_DISCOVER;

    *e++ = 57;		/* Maximum DHCP Message Size */
    *e++ = 2;
    *e++ = (576-312+OPT_SIZE) >> 16;
    *e++ = (576-312+OPT_SIZE) & 0xff;
#endif	/* CFG_CMD_DHCP */

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_SUBNETMASK)
    *e++ =  1;		/* Subnet mask request */
 3f029e0:	e2433052 	sub	r3, r3, #82	; 0x52
 3f029e4:	e4c03001 	strb	r3, [r0], #1
    *e++ =  4;
 3f029e8:	e242205f 	sub	r2, r2, #95	; 0x5f
 3f029ec:	e4c02001 	strb	r2, [r0], #1
     e  +=  4;
#endif

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_GATEWAY)
    *e++ =  3;		/* Default gateway request */
 3f029f0:	e2833002 	add	r3, r3, #2	; 0x2
 3f029f4:	e0800002 	add	r0, r0, r2
 3f029f8:	e4c03001 	strb	r3, [r0], #1
    *e++ =  4;
 3f029fc:	e4c02001 	strb	r2, [r0], #1
     e  +=  4;
#endif

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS)
    *e++ =  6;		/* Domain Name Server */
    *e++ =  4;
     e  +=  4;
#endif

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_HOSTNAME)
    *e++ = 12;		/* Host name request */
 3f02a00:	e2833009 	add	r3, r3, #9	; 0x9
 3f02a04:	e0800002 	add	r0, r0, r2
 3f02a08:	e4c03001 	strb	r3, [r0], #1
    *e++ = 32;
 3f02a0c:	e282201c 	add	r2, r2, #28	; 0x1c
 3f02a10:	e4c02001 	strb	r2, [r0], #1
     e  += 32;
#endif

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTFILESIZE)
    *e++ = 13;		/* Boot file size */
    *e++ =  2;
     e  +=  2;
#endif

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_BOOTPATH)
    *e++ = 17;		/* Boot path */
 3f02a14:	e2833005 	add	r3, r3, #5	; 0x5
 3f02a18:	e0800002 	add	r0, r0, r2
 3f02a1c:	e4c03001 	strb	r3, [r0], #1
    *e++ = 32;
 3f02a20:	e4c02001 	strb	r2, [r0], #1
     e  += 32;
#endif

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_NISDOMAIN)
    *e++ = 40;		/* NIS Domain name request */
    *e++ = 32;
     e  += 32;
#endif

    *e++ = 255;		/* End of the list */
 3f02a24:	e28330ee 	add	r3, r3, #238	; 0xee
 3f02a28:	e0800002 	add	r0, r0, r2
 3f02a2c:	e4c03001 	strb	r3, [r0], #1
 3f02a30:	e24cb004 	sub	r11, r12, #4	; 0x4

    return e - start ;
 3f02a34:	e0610000 	rsb	r0, r1, r0
}
 3f02a38:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f02a3c <BootpRequest>:
 3f02a3c:	e1a0c00d 	mov	r12, r13
 3f02a40:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
#endif	/* CFG_CMD_DHCP */

void
BootpRequest (void)
{
	volatile uchar *pkt, *iphdr;
	Bootp_t *bp;
	int ext_len, pktlen, iplen;

#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
	dhcp_state = INIT;
#endif

#ifdef CONFIG_BOOTP_RANDOM_DELAY		/* Random BOOTP delay */
	unsigned char bi_enetaddr[6];
	int   reg;
	char  *e,*s;
	uchar tmp[64];
	ulong tst1, tst2, sum, m_mask, m_value = 0;

	if (BootpTry ==0) {
		/* get our mac */
		reg = getenv_r ("ethaddr", tmp, sizeof(tmp));
		s = (reg > 0) ? tmp : NULL;

		for (reg=0; reg<6; ++reg) {
			bi_enetaddr[reg] = s ? simple_strtoul(s, &e, 16) : 0;
			if (s) {
				s = (*e) ? e+1 : e;
			}
		}
#ifdef DEBUG
		printf("BootpRequest => Our Mac: ");
		for (reg=0; reg<6; reg++) {
			printf ("%x%c",
				bi_enetaddr[reg],
				reg==5 ? '\n' : ':');
		}
#endif /* DEBUG */

		/* Mac-Manipulation 2 get seed1 */
		tst1=0;
		tst2=0;
		for (reg=2; reg<6; reg++) {
			tst1 = tst1 << 8;
			tst1 = tst1 | bi_enetaddr[reg];
		}
		for (reg=0; reg<2; reg++) {
			tst2 = tst2 | bi_enetaddr[reg];
			tst2 = tst2 << 8;
		}

		seed1 = tst1^tst2;

		/* Mirror seed1*/
		m_mask=0x1;
		for (reg=1;reg<=32;reg++) {
			m_value |= (m_mask & seed1);
			seed1 = seed1 >> 1;
			m_value = m_value << 1;
		}
		seed1 = m_value;
		seed2 = 0xB78D0945;
	}

	/* Random Number Generator */

	for (reg=0;reg<=0;reg++) {
		sum = seed1 + seed2;
		if (sum < seed1 || sum < seed2)
			sum++;
		seed2 = seed1;
		seed1 = sum;

		if (BootpTry<=2) {	/* Start with max 1024 * 1ms */
			sum = sum >> (22-BootpTry);
		} else {		/*After 3rd BOOTP request max 8192 * 1ms */
			sum = sum >> 19;
		}
	}

	printf ("Random delay: %ld ms...\n", sum);
	for (reg=0; reg <sum; reg++) {
		udelay(1000); /*Wait 1ms*/
	}
#endif	/* CONFIG_BOOTP_RANDOM_DELAY */

	printf("BOOTP broadcast %d\n", ++BootpTry);
 3f02a44:	e59f31b8 	ldr	r3, [pc, #1b8]	; 3f02c04 <BootpRequest+0x1c8>
 3f02a48:	e59f01b8 	ldr	r0, [pc, #1b8]	; 3f02c08 <BootpRequest+0x1cc>
 3f02a4c:	e24dd014 	sub	r13, r13, #20	; 0x14
 3f02a50:	e5931000 	ldr	r1, [r3]
 3f02a54:	e24cb004 	sub	r11, r12, #4	; 0x4
	pkt = NetTxPacket;
 3f02a58:	e59fa1ac 	ldr	r10, [pc, #1ac]	; 3f02c0c <BootpRequest+0x1d0>
 3f02a5c:	e2811001 	add	r1, r1, #1	; 0x1
 3f02a60:	e5831000 	str	r1, [r3]
 3f02a64:	eb002776 	bl	3f0c844 <printf>
 3f02a68:	e59a4000 	ldr	r4, [r10]
	memset ((void*)pkt, 0, PKTSIZE);
 3f02a6c:	e3a01000 	mov	r1, #0	; 0x0
 3f02a70:	e59f2198 	ldr	r2, [pc, #198]	; 3f02c10 <BootpRequest+0x1d4>
 3f02a74:	e1a00004 	mov	r0, r4
 3f02a78:	eb0032a8 	bl	3f0f520 <memset>

	NetSetEther(pkt, NetBcastAddr, PROT_IP);
 3f02a7c:	e1a00004 	mov	r0, r4
 3f02a80:	e59f118c 	ldr	r1, [pc, #18c]	; 3f02c14 <BootpRequest+0x1d8>
 3f02a84:	e3a02b02 	mov	r2, #2048	; 0x800
 3f02a88:	ebfffc07 	bl	3f01aac <NetSetEther>
	pkt += ETHER_HDR_SIZE;
 3f02a8c:	e284400e 	add	r4, r4, #14	; 0xe

	/*
	 * Next line results in incorrect packet size being transmitted, resulting
	 * in errors in some DHCP servers, reporting missing bytes.  Size must be
	 * set in packet header after extension length has been determined.
	 * C. Hallinan, DS4.COM, Inc.
	 */
	/* NetSetIP(pkt, 0xFFFFFFFFL, PORT_BOOTPS, PORT_BOOTPC, sizeof (Bootp_t)); */
	iphdr = pkt;	/* We need this later for NetSetIP() */
	pkt += IP_HDR_SIZE;

	bp = (Bootp_t *)pkt;
	bp->bp_op = OP_BOOTREQUEST;
 3f02a90:	e3a03001 	mov	r3, #1	; 0x1
 3f02a94:	e284501c 	add	r5, r4, #28	; 0x1c
 3f02a98:	e5c4301c 	strb	r3, [r4, #28]
	bp->bp_htype = HWT_ETHER;
	bp->bp_hlen = HWL_ETHER;
 3f02a9c:	e3a07006 	mov	r7, #6	; 0x6
 3f02aa0:	e5c57002 	strb	r7, [r5, #2]
	bp->bp_hops = 0;
 3f02aa4:	e3a06000 	mov	r6, #0	; 0x0
 3f02aa8:	e5c56003 	strb	r6, [r5, #3]
	bp->bp_secs = htons(get_timer(0) / CFG_HZ);
 3f02aac:	e1a00006 	mov	r0, r6
 3f02ab0:	e5c53001 	strb	r3, [r5, #1]
 3f02ab4:	ebfff744 	bl	3f007cc <get_timer>
 3f02ab8:	e59f3158 	ldr	r3, [pc, #158]	; 3f02c18 <BootpRequest+0x1dc>
 3f02abc:	e0802093 	umull	r2, r0, r3, r0

/* write IP *in network byteorder* */
static inline void NetWriteIP(void *to, IPaddr_t ip)
{
	memcpy(to, (void*)&ip, sizeof(ip));
 3f02ac0:	e24b1024 	sub	r1, r11, #36	; 0x24
 3f02ac4:	e3a02004 	mov	r2, #4	; 0x4
 3f02ac8:	e1a00b20 	mov	r0, r0, lsr #22


extern __inline__ __const__ __u16 __fswab16(__u16 x)
{
	return __arch__swab16(x);
 3f02acc:	e1a03420 	mov	r3, r0, lsr #8
 3f02ad0:	e1a03803 	mov	r3, r3, lsl #16
 3f02ad4:	e1833c00 	orr	r3, r3, r0, lsl #24
 3f02ad8:	e1a03823 	mov	r3, r3, lsr #16
 3f02adc:	e1c530b8 	strh	r3, [r5, #8]

/* write IP *in network byteorder* */
static inline void NetWriteIP(void *to, IPaddr_t ip)
{
	memcpy(to, (void*)&ip, sizeof(ip));
 3f02ae0:	e2840028 	add	r0, r4, #40	; 0x28
 3f02ae4:	e50b6024 	str	r6, [r11, -#36]
 3f02ae8:	eb0032a6 	bl	3f0f588 <memcpy>
 3f02aec:	e284002c 	add	r0, r4, #44	; 0x2c
 3f02af0:	e24b1028 	sub	r1, r11, #40	; 0x28
 3f02af4:	e3a02004 	mov	r2, #4	; 0x4
 3f02af8:	e50b6028 	str	r6, [r11, -#40]
 3f02afc:	eb0032a1 	bl	3f0f588 <memcpy>
 3f02b00:	e2840030 	add	r0, r4, #48	; 0x30
 3f02b04:	e24b102c 	sub	r1, r11, #44	; 0x2c
 3f02b08:	e3a02004 	mov	r2, #4	; 0x4
 3f02b0c:	e50b602c 	str	r6, [r11, -#44]
 3f02b10:	eb00329c 	bl	3f0f588 <memcpy>
 3f02b14:	e2840034 	add	r0, r4, #52	; 0x34
 3f02b18:	e24b1030 	sub	r1, r11, #48	; 0x30
 3f02b1c:	e3a02004 	mov	r2, #4	; 0x4
 3f02b20:	e50b6030 	str	r6, [r11, -#48]
 3f02b24:	eb003297 	bl	3f0f588 <memcpy>
	NetWriteIP(&bp->bp_ciaddr, 0);
	NetWriteIP(&bp->bp_yiaddr, 0);
	NetWriteIP(&bp->bp_siaddr, 0);
	NetWriteIP(&bp->bp_giaddr, 0);
	memcpy (bp->bp_chaddr, NetOurEther, 6);
 3f02b28:	e2840038 	add	r0, r4, #56	; 0x38
 3f02b2c:	e59f50e8 	ldr	r5, [pc, #e8]	; 3f02c1c <BootpRequest+0x1e0>
 3f02b30:	e1a02007 	mov	r2, r7
 3f02b34:	e1a01005 	mov	r1, r5
 3f02b38:	eb003292 	bl	3f0f588 <memcpy>
	copy_filename (bp->bp_file, BootFile, sizeof(bp->bp_file));
 3f02b3c:	e2840088 	add	r0, r4, #136	; 0x88
 3f02b40:	e59f10d8 	ldr	r1, [pc, #d8]	; 3f02c20 <BootpRequest+0x1e4>
 3f02b44:	e3a02080 	mov	r2, #128	; 0x80
 3f02b48:	ebfffc3e 	bl	3f01c48 <copy_filename>

	/* Request additional information from the BOOTP/DHCP server */
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
	ext_len = DhcpExtended(bp->bp_vend, DHCP_DISCOVER, 0, 0);
#else
	ext_len = BootpExtended(bp->bp_vend);
 3f02b4c:	e2840f42 	add	r0, r4, #264	; 0x108
 3f02b50:	ebffff98 	bl	3f029b8 <BootpExtended>
#endif	/* CFG_CMD_DHCP */

	/*
	 *	Bootp ID is the lower 4 bytes of our ethernet address
	 *	plus the current time in HZ.
	 */
	BootpID = ((ulong)NetOurEther[2] << 24)
 3f02b54:	e5d53003 	ldrb	r3, [r5, #3]
 3f02b58:	e1a07000 	mov	r7, r0
 3f02b5c:	e5d52002 	ldrb	r2, [r5, #2]
		| ((ulong)NetOurEther[3] << 16)
		| ((ulong)NetOurEther[4] << 8)
		| (ulong)NetOurEther[5];
	BootpID += get_timer(0);
 3f02b60:	e1a00006 	mov	r0, r6
 3f02b64:	e5d51004 	ldrb	r1, [r5, #4]
 3f02b68:	e1a03803 	mov	r3, r3, lsl #16
 3f02b6c:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f02b70:	e5d52005 	ldrb	r2, [r5, #5]
 3f02b74:	e1833401 	orr	r3, r3, r1, lsl #8
 3f02b78:	e59f50a4 	ldr	r5, [pc, #a4]	; 3f02c24 <BootpRequest+0x1e8>
 3f02b7c:	e1833002 	orr	r3, r3, r2
 3f02b80:	e5853000 	str	r3, [r5]
 3f02b84:	ebfff710 	bl	3f007cc <get_timer>

/* copy ulong */
static inline void NetCopyLong(ulong *to, ulong *from)
{
	memcpy((void*)to, (void*)from, sizeof(ulong));
 3f02b88:	e1a01005 	mov	r1, r5
 3f02b8c:	e595e000 	ldr	r14, [r5]

/* copy ulong */
static inline void NetCopyLong(ulong *to, ulong *from)
{
	memcpy((void*)to, (void*)from, sizeof(ulong));
 3f02b90:	e3a02004 	mov	r2, #4	; 0x4
 3f02b94:	e08ee000 	add	r14, r14, r0

/* copy ulong */
static inline void NetCopyLong(ulong *to, ulong *from)
{
	memcpy((void*)to, (void*)from, sizeof(ulong));
 3f02b98:	e2840020 	add	r0, r4, #32	; 0x20
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f02b9c:	e20e3cff 	and	r3, r14, #65280	; 0xff00
 3f02ba0:	e1a03403 	mov	r3, r3, lsl #8
 3f02ba4:	e1833c0e 	orr	r3, r3, r14, lsl #24
 3f02ba8:	e20ec8ff 	and	r12, r14, #16711680	; 0xff0000
 3f02bac:	e183342c 	orr	r3, r3, r12, lsr #8
 3f02bb0:	e1833c2e 	orr	r3, r3, r14, lsr #24
	BootpID  = htonl(BootpID);
 3f02bb4:	e5853000 	str	r3, [r5]

/* copy ulong */
static inline void NetCopyLong(ulong *to, ulong *from)
{
	memcpy((void*)to, (void*)from, sizeof(ulong));
 3f02bb8:	eb003272 	bl	3f0f588 <memcpy>
	NetCopyLong(&bp->bp_id, &BootpID);

	/*
	 * Calculate proper packet lengths taking into account the
	 * variable size of the options field
	 */
	pktlen = BOOTP_SIZE - sizeof(bp->bp_vend) + ext_len;
	iplen = BOOTP_HDR_SIZE - sizeof(bp->bp_vend) + ext_len;
	NetSetIP(iphdr, 0xFFFFFFFFL, PORT_BOOTPS, PORT_BOOTPC, iplen);
 3f02bbc:	e1a00004 	mov	r0, r4
 3f02bc0:	e3e01000 	mvn	r1, #0	; 0x0
 3f02bc4:	e3a02043 	mov	r2, #67	; 0x43
 3f02bc8:	e28730ec 	add	r3, r7, #236	; 0xec
 3f02bcc:	e58d3000 	str	r3, [r13]
 3f02bd0:	e3a03044 	mov	r3, #68	; 0x44
 3f02bd4:	ebfffbc8 	bl	3f01afc <NetSetIP>
	NetSetTimeout(SELECT_TIMEOUT * CFG_HZ, BootpTimeout);
 3f02bd8:	e59f0048 	ldr	r0, [pc, #48]	; 3f02c28 <BootpRequest+0x1ec>
 3f02bdc:	e59f1048 	ldr	r1, [pc, #48]	; 3f02c2c <BootpRequest+0x1f0>
 3f02be0:	e2877f45 	add	r7, r7, #276	; 0x114
 3f02be4:	ebfff9c5 	bl	3f01300 <NetSetTimeout>

#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
	dhcp_state = SELECTING;
	NetSetHandler(DhcpHandler);
#else
	NetSetHandler(BootpHandler);
 3f02be8:	e59f0040 	ldr	r0, [pc, #40]	; 3f02c30 <BootpRequest+0x1f4>
 3f02bec:	e2877002 	add	r7, r7, #2	; 0x2
 3f02bf0:	ebfff9bb 	bl	3f012e4 <NetSetHandler>
#endif	/* CFG_CMD_DHCP */
	NetSendPacket(NetTxPacket, pktlen);
 3f02bf4:	e59a0000 	ldr	r0, [r10]
 3f02bf8:	e1a01007 	mov	r1, r7
 3f02bfc:	ebfff9d2 	bl	3f0134c <NetSendPacket>
 3f02c00:	ea00000b 	b	3f02c34 <BootpRequest+0x1f8>
 3f02c04:	03f6cbfc 	mvneqs	r12, #258048	; 0x3f000
 3f02c08:	03f1aef4 	mvneqs	r10, #3904	; 0xf40
 3f02c0c:	03f204c4 	mvneqs	r0, #-1006632960	; 0xc4000000
 3f02c10:	000005ee 	andeq	r0, r0, r14, ror #11
 3f02c14:	03f204b8 	mvneqs	r0, #-1207959552	; 0xb8000000
 3f02c18:	91a2b3c5 	movls	r11, r5, asr #7
 3f02c1c:	03f6a6b0 	mvneqs	r10, #184549376	; 0xb000000
 3f02c20:	03f6a6e0 	mvneqs	r10, #234881024	; 0xe000000
 3f02c24:	03f6cbf8 	mvneqs	r12, #253952	; 0x3e000
 3f02c28:	01518000 	cmpeq	r1, r0
 3f02c2c:	03f02968 	mvneqs	r2, #1703936	; 0x1a0000
 3f02c30:	03f028c4 	mvneqs	r2, #12845056	; 0xc40000
}
 3f02c34:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f02c38 <RarpHandler>:
 3f02c38:	e1a0c00d 	mov	r12, r13
 3f02c3c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f02c40:	e24cb004 	sub	r11, r12, #4	; 0x4
{
#ifdef	DEBUG
	printf("Got good RARP\n");
#endif
	TftpStart ();
 3f02c44:	ebfffd84 	bl	3f0225c <TftpStart>
 3f02c48:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f02c4c <RarpTimeout>:
 3f02c4c:	e1a0c00d 	mov	r12, r13
 3f02c50:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}


/*
 *	Timeout on BOOTP request.
 */
static void
RarpTimeout(void)
{
	if (RarpTry >= TIMEOUT_COUNT) {
 3f02c54:	e59f3030 	ldr	r3, [pc, #30]	; 3f02c8c <RarpTimeout+0x40>
 3f02c58:	e5933000 	ldr	r3, [r3]
 3f02c5c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f02c60:	e3530004 	cmp	r3, #4	; 0x4
 3f02c64:	da000003 	ble	3f02c78 <RarpTimeout+0x2c>
		puts ("\nRetry count exceeded; starting again\n");
 3f02c68:	e59f0020 	ldr	r0, [pc, #20]	; 3f02c90 <RarpTimeout+0x44>
 3f02c6c:	eb0026e7 	bl	3f0c810 <puts>
		NetStartAgain ();
 3f02c70:	ebfff98f 	bl	3f012b4 <NetStartAgain>
	} else {
 3f02c74:	e91ba800 	ldmdb	r11, {r11, r13, r15}
		NetSetTimeout (TIMEOUT * CFG_HZ, RarpTimeout);
 3f02c78:	e59f0014 	ldr	r0, [pc, #14]	; 3f02c94 <RarpTimeout+0x48>
 3f02c7c:	e59f1014 	ldr	r1, [pc, #14]	; 3f02c98 <RarpTimeout+0x4c>
 3f02c80:	ebfff99e 	bl	3f01300 <NetSetTimeout>
		RarpRequest ();
 3f02c84:	eb000004 	bl	3f02c9c <RarpRequest>
	}
 3f02c88:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f02c8c:	03f6cc00 	mvneqs	r12, #0	; 0x0
 3f02c90:	03f1af08 	mvneqs	r10, #32	; 0x20
 3f02c94:	02328000 	eoreqs	r8, r2, #0	; 0x0
 3f02c98:	03f02c4c 	mvneqs	r2, #19456	; 0x4c00

03f02c9c <RarpRequest>:
 3f02c9c:	e1a0c00d 	mov	r12, r13
 3f02ca0:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
}


void
RarpRequest (void)
{
	int i;
	volatile uchar *pkt;
	ARP_t *	rarp;

	printf("RARP broadcast %d\n", ++RarpTry);
 3f02ca4:	e59f20d4 	ldr	r2, [pc, #d4]	; 3f02d80 <RarpRequest+0xe4>
 3f02ca8:	e5923000 	ldr	r3, [r2]
 3f02cac:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f02cb0:	e59f00cc 	ldr	r0, [pc, #cc]	; 3f02d84 <RarpRequest+0xe8>
 3f02cb4:	e2833001 	add	r3, r3, #1	; 0x1
 3f02cb8:	e1a01003 	mov	r1, r3
 3f02cbc:	e5823000 	str	r3, [r2]
 3f02cc0:	eb0026df 	bl	3f0c844 <printf>
	pkt = NetTxPacket;
 3f02cc4:	e59f90bc 	ldr	r9, [pc, #bc]	; 3f02d88 <RarpRequest+0xec>

	NetSetEther(pkt, NetBcastAddr, PROT_RARP);
 3f02cc8:	e59f10bc 	ldr	r1, [pc, #bc]	; 3f02d8c <RarpRequest+0xf0>
 3f02ccc:	e5994000 	ldr	r4, [r9]
 3f02cd0:	e59f20b8 	ldr	r2, [pc, #b8]	; 3f02d90 <RarpRequest+0xf4>
 3f02cd4:	e1a00004 	mov	r0, r4
 3f02cd8:	ebfffb73 	bl	3f01aac <NetSetEther>
	pkt += ETHER_HDR_SIZE;
 3f02cdc:	e284400e 	add	r4, r4, #14	; 0xe

	rarp = (ARP_t *)pkt;

	rarp->ar_hrd = htons (ARP_ETHER);
 3f02ce0:	e3a03c01 	mov	r3, #256	; 0x100
 3f02ce4:	e1c430b0 	strh	r3, [r4]
	rarp->ar_pro = htons (PROT_IP);
 3f02ce8:	e3a03008 	mov	r3, #8	; 0x8
 3f02cec:	e1c430b2 	strh	r3, [r4, #2]
	rarp->ar_hln = 6;
	rarp->ar_pln = 4;
	rarp->ar_op  = htons (RARPOP_REQUEST);
 3f02cf0:	e3a03c03 	mov	r3, #768	; 0x300
	memcpy (&rarp->ar_data[0],  NetOurEther, 6);	/* source ET addr */
 3f02cf4:	e284a008 	add	r10, r4, #8	; 0x8
 3f02cf8:	e1a0000a 	mov	r0, r10
 3f02cfc:	e1c430b6 	strh	r3, [r4, #6]
 3f02d00:	e3a05006 	mov	r5, #6	; 0x6
 3f02d04:	e59f7088 	ldr	r7, [pc, #88]	; 3f02d94 <RarpRequest+0xf8>
 3f02d08:	e3a06004 	mov	r6, #4	; 0x4
 3f02d0c:	e5c45004 	strb	r5, [r4, #4]
 3f02d10:	e1a02005 	mov	r2, r5
 3f02d14:	e5c46005 	strb	r6, [r4, #5]
 3f02d18:	e1a01007 	mov	r1, r7
 3f02d1c:	eb003219 	bl	3f0f588 <memcpy>
	memcpy (&rarp->ar_data[6],  &NetOurIP,   4);	/* source IP addr */
 3f02d20:	e284000e 	add	r0, r4, #14	; 0xe
 3f02d24:	e59f106c 	ldr	r1, [pc, #6c]	; 3f02d98 <RarpRequest+0xfc>
 3f02d28:	e1a02006 	mov	r2, r6
 3f02d2c:	eb003215 	bl	3f0f588 <memcpy>
	memcpy (&rarp->ar_data[10], NetOurEther, 6);	/* dest ET addr = source ET addr ??*/
 3f02d30:	e2840012 	add	r0, r4, #18	; 0x12
 3f02d34:	e1a01007 	mov	r1, r7
 3f02d38:	e1a02005 	mov	r2, r5
 3f02d3c:	eb003211 	bl	3f0f588 <memcpy>
	/* dest. IP addr set to broadcast */
	for (i = 0; i <= 3; i++) {
 3f02d40:	e3a01000 	mov	r1, #0	; 0x0
		rarp->ar_data[16 + i] = 0xff;
 3f02d44:	e2812010 	add	r2, r1, #16	; 0x10
 3f02d48:	e2811001 	add	r1, r1, #1	; 0x1
 3f02d4c:	e3a030ff 	mov	r3, #255	; 0xff
 3f02d50:	e3510003 	cmp	r1, #3	; 0x3
 3f02d54:	e7ca3002 	strb	r3, [r10, r2]
 3f02d58:	dafffff9 	ble	3f02d44 <RarpRequest+0xa8>
	}

	NetSendPacket(NetTxPacket, ETHER_HDR_SIZE + ARP_HDR_SIZE);
 3f02d5c:	e5990000 	ldr	r0, [r9]
 3f02d60:	e3a0102a 	mov	r1, #42	; 0x2a
 3f02d64:	ebfff978 	bl	3f0134c <NetSendPacket>

	NetSetTimeout(TIMEOUT * CFG_HZ, RarpTimeout);
 3f02d68:	e59f002c 	ldr	r0, [pc, #2c]	; 3f02d9c <RarpRequest+0x100>
 3f02d6c:	e59f102c 	ldr	r1, [pc, #2c]	; 3f02da0 <RarpRequest+0x104>
 3f02d70:	ebfff962 	bl	3f01300 <NetSetTimeout>
	NetSetHandler(RarpHandler);
 3f02d74:	e59f0028 	ldr	r0, [pc, #28]	; 3f02da4 <RarpRequest+0x108>
 3f02d78:	ebfff959 	bl	3f012e4 <NetSetHandler>
}
 3f02d7c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f02d80:	03f6cc00 	mvneqs	r12, #0	; 0x0
 3f02d84:	03f1af30 	mvneqs	r10, #192	; 0xc0
 3f02d88:	03f204c4 	mvneqs	r0, #-1006632960	; 0xc4000000
 3f02d8c:	03f204b8 	mvneqs	r0, #-1207959552	; 0xb8000000
 3f02d90:	00008035 	andeq	r8, r0, r5, lsr r0
 3f02d94:	03f6a6b0 	mvneqs	r10, #184549376	; 0xb000000
 3f02d98:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
 3f02d9c:	02328000 	eoreqs	r8, r2, #0	; 0x0
 3f02da0:	03f02c4c 	mvneqs	r2, #19456	; 0x4c00
 3f02da4:	03f02c38 	mvneqs	r2, #14336	; 0x3800

03f02da8 <get_reg_init_bus>:
 3f02da8:	e1a0c00d 	mov	r12, r13
 3f02dac:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
{
	/* force 16 bit busmode */
	volatile unsigned char c;

	c = CS8900_BUS16_0;
 3f02db0:	e59f2044 	ldr	r2, [pc, #44]	; 3f02dfc <get_reg_init_bus+0x54>
	c = CS8900_BUS16_1;
 3f02db4:	e59f1044 	ldr	r1, [pc, #44]	; 3f02e00 <get_reg_init_bus+0x58>
 3f02db8:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f02dbc:	e5d23000 	ldrb	r3, [r2]
 3f02dc0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f02dc4:	e54b300d 	strb	r3, [r11, -#13]
 3f02dc8:	e5d13000 	ldrb	r3, [r1]
 3f02dcc:	e54b300d 	strb	r3, [r11, -#13]
	c = CS8900_BUS16_0;
 3f02dd0:	e5d23000 	ldrb	r3, [r2]
 3f02dd4:	e54b300d 	strb	r3, [r11, -#13]
	c = CS8900_BUS16_1;
 3f02dd8:	e5d13000 	ldrb	r3, [r1]
 3f02ddc:	e54b300d 	strb	r3, [r11, -#13]
	c = CS8900_BUS16_0;
 3f02de0:	e5d23000 	ldrb	r3, [r2]
 3f02de4:	e54b300d 	strb	r3, [r11, -#13]

	CS8900_PPTR = regno;
 3f02de8:	e59f3014 	ldr	r3, [pc, #14]	; 3f02e04 <get_reg_init_bus+0x5c>
 3f02dec:	e1c300b0 	strh	r0, [r3]
	return (unsigned short) CS8900_PDATA;
 3f02df0:	e2833002 	add	r3, r3, #2	; 0x2
 3f02df4:	e1d300b0 	ldrh	r0, [r3]
 3f02df8:	ea000002 	b	3f02e08 <get_reg_init_bus+0x60>
 3f02dfc:	84000300 	strhi	r0, [r0], -#768
 3f02e00:	84000301 	strhi	r0, [r0], -#769
 3f02e04:	8400030a 	strhi	r0, [r0], -#778
}
 3f02e08:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f02e0c <get_reg>:
 3f02e0c:	e1a0c00d 	mov	r12, r13
 3f02e10:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
#endif

static unsigned short get_reg (int regno)
{
	CS8900_PPTR = regno;
 3f02e14:	e59f3010 	ldr	r3, [pc, #10]	; 3f02e2c <get_reg+0x20>
 3f02e18:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f02e1c:	e1c300b0 	strh	r0, [r3]
	return (unsigned short) CS8900_PDATA;
 3f02e20:	e2833002 	add	r3, r3, #2	; 0x2
 3f02e24:	e1d300b0 	ldrh	r0, [r3]
 3f02e28:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f02e2c:	8400030a 	strhi	r0, [r0], -#778

03f02e30 <put_reg>:
 3f02e30:	e1a0c00d 	mov	r12, r13
 3f02e34:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f02e38:	e24cb004 	sub	r11, r12, #4	; 0x4
}


static void put_reg (int regno, unsigned short val)
{
 3f02e3c:	e1a01801 	mov	r1, r1, lsl #16
	CS8900_PPTR = regno;
 3f02e40:	e59f3010 	ldr	r3, [pc, #10]	; 3f02e58 <put_reg+0x28>
 3f02e44:	e1a01821 	mov	r1, r1, lsr #16
 3f02e48:	e1c300b0 	strh	r0, [r3]
	CS8900_PDATA = val;
 3f02e4c:	e2833002 	add	r3, r3, #2	; 0x2
 3f02e50:	e1c310b0 	strh	r1, [r3]
 3f02e54:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f02e58:	8400030a 	strhi	r0, [r0], -#778

03f02e5c <eth_reset>:
 3f02e5c:	e1a0c00d 	mov	r12, r13
 3f02e60:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f02e64:	e24cb004 	sub	r11, r12, #4	; 0x4
}

static void eth_reset (void)
{
	int tmo;
	unsigned short us;

	/* reset NIC */
	put_reg (PP_SelfCTL, get_reg (PP_SelfCTL) | PP_SelfCTL_Reset);
 3f02e68:	e3a00f45 	mov	r0, #276	; 0x114
 3f02e6c:	ebffffe6 	bl	3f02e0c <get_reg>
 3f02e70:	e3801040 	orr	r1, r0, #64	; 0x40
 3f02e74:	e3a00f45 	mov	r0, #276	; 0x114
 3f02e78:	e1a01801 	mov	r1, r1, lsl #16
 3f02e7c:	e1a01821 	mov	r1, r1, lsr #16
 3f02e80:	ebffffea 	bl	3f02e30 <put_reg>

	/* wait for 200ms */
	udelay (200000);
 3f02e84:	e59f0030 	ldr	r0, [pc, #30]	; 3f02ebc <eth_reset+0x60>
 3f02e88:	ebfff662 	bl	3f00818 <udelay>
	/* Wait until the chip is reset */

	tmo = get_timer (0) + 1 * CFG_HZ;
 3f02e8c:	e3a00000 	mov	r0, #0	; 0x0
 3f02e90:	ebfff64d 	bl	3f007cc <get_timer>
 3f02e94:	e2804607 	add	r4, r0, #7340032	; 0x700000
 3f02e98:	e2844902 	add	r4, r4, #32768	; 0x8000
	while ((((us = get_reg_init_bus (PP_SelfSTAT)) & PP_SelfSTAT_InitD) == 0)
		   && tmo < get_timer (0))
 3f02e9c:	e59f001c 	ldr	r0, [pc, #1c]	; 3f02ec0 <eth_reset+0x64>
 3f02ea0:	ebffffc0 	bl	3f02da8 <get_reg_init_bus>
 3f02ea4:	e2100080 	ands	r0, r0, #128	; 0x80
 3f02ea8:	191ba810 	ldmnedb	r11, {r4, r11, r13, r15}
 3f02eac:	ebfff646 	bl	3f007cc <get_timer>
 3f02eb0:	e1540000 	cmp	r4, r0
 3f02eb4:	3afffff8 	bcc	3f02e9c <eth_reset+0x40>
		/*NOP*/;
}
 3f02eb8:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f02ebc:	00030d40 	andeq	r0, r3, r0, asr #26
 3f02ec0:	00000136 	andeq	r0, r0, r6, lsr r1

03f02ec4 <cs8900_get_enetaddr>:
 3f02ec4:	e1a0c00d 	mov	r12, r13
 3f02ec8:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f02ecc:	e24cb004 	sub	r11, r12, #4	; 0x4

void cs8900_get_enetaddr (uchar * addr)
{
	int i;
	unsigned char env_enetaddr[6];
	char *tmp = getenv ("ethaddr");
	char *end;

	for (i=0; i<6; i++) {
 3f02ed0:	e3a06000 	mov	r6, #0	; 0x0
 3f02ed4:	e1a05000 	mov	r5, r0
 3f02ed8:	e59f002c 	ldr	r0, [pc, #2c]	; 3f02f0c <cs8900_get_enetaddr+0x48>
 3f02edc:	e24dd030 	sub	r13, r13, #48	; 0x30
 3f02ee0:	eb00245d 	bl	3f0c05c <getenv>
 3f02ee4:	e1a0a000 	mov	r10, r0
		env_enetaddr[i] = tmp ? simple_strtoul(tmp, &end, 16) : 0;
 3f02ee8:	e35a0000 	cmp	r10, #0	; 0x0
 3f02eec:	e24b902c 	sub	r9, r11, #44	; 0x2c
 3f02ef0:	0a000006 	beq	3f02f10 <cs8900_get_enetaddr+0x4c>
 3f02ef4:	e1a0000a 	mov	r0, r10
 3f02ef8:	e24b1044 	sub	r1, r11, #68	; 0x44
 3f02efc:	e3a02010 	mov	r2, #16	; 0x10
 3f02f00:	eb00320f 	bl	3f0f744 <simple_strtoul>
 3f02f04:	e7c90006 	strb	r0, [r9, r6]
 3f02f08:	ea000001 	b	3f02f14 <cs8900_get_enetaddr+0x50>
 3f02f0c:	03f1af44 	mvneqs	r10, #272	; 0x110
 3f02f10:	e7c9a006 	strb	r10, [r9, r6]
		if (tmp)
 3f02f14:	e35a0000 	cmp	r10, #0	; 0x0
 3f02f18:	0a000004 	beq	3f02f30 <cs8900_get_enetaddr+0x6c>
			tmp = (*end) ? end+1 : end;
 3f02f1c:	e51b2044 	ldr	r2, [r11, -#68]
 3f02f20:	e5d23000 	ldrb	r3, [r2]
 3f02f24:	e3530000 	cmp	r3, #0	; 0x0
 3f02f28:	01a0a002 	moveq	r10, r2
 3f02f2c:	1282a001 	addne	r10, r2, #1	; 0x1
 3f02f30:	e2866001 	add	r6, r6, #1	; 0x1
 3f02f34:	e3560005 	cmp	r6, #5	; 0x5
 3f02f38:	daffffea 	ble	3f02ee8 <cs8900_get_enetaddr+0x24>
	}

	/* verify chip id */
	if (get_reg_init_bus (PP_ChipID) != 0x630e)
 3f02f3c:	e3a00000 	mov	r0, #0	; 0x0
 3f02f40:	ebffff98 	bl	3f02da8 <get_reg_init_bus>
 3f02f44:	e59f3144 	ldr	r3, [pc, #144]	; 3f03090 <cs8900_get_enetaddr+0x1cc>
 3f02f48:	e1a00800 	mov	r0, r0, lsl #16
 3f02f4c:	e1530820 	cmp	r3, r0, lsr #16
 3f02f50:	1a000056 	bne	3f030b0 <cs8900_get_enetaddr+0x1ec>
		return;
	eth_reset ();
 3f02f54:	ebffffc0 	bl	3f02e5c <eth_reset>
	if ((get_reg (PP_SelfST) & (PP_SelfSTAT_EEPROM | PP_SelfSTAT_EEPROM_OK)) ==
 3f02f58:	e59f0134 	ldr	r0, [pc, #134]	; 3f03094 <cs8900_get_enetaddr+0x1d0>
 3f02f5c:	ebffffaa 	bl	3f02e0c <get_reg>
 3f02f60:	e2000c06 	and	r0, r0, #1536	; 0x600
 3f02f64:	e3500c06 	cmp	r0, #1536	; 0x600
 3f02f68:	1a000050 	bne	3f030b0 <cs8900_get_enetaddr+0x1ec>
			(PP_SelfSTAT_EEPROM | PP_SelfSTAT_EEPROM_OK)) {

		/* Load the MAC from EEPROM */
		for (i = 0; i < 6 / 2; i++) {
 3f02f6c:	e3a06000 	mov	r6, #0	; 0x0
 3f02f70:	e1a04005 	mov	r4, r5
 3f02f74:	e3a07f56 	mov	r7, #344	; 0x158
			unsigned int Addr;

			Addr = get_reg (PP_IA + i * 2);
 3f02f78:	e1a00007 	mov	r0, r7
 3f02f7c:	ebffffa2 	bl	3f02e0c <get_reg>
			addr[i * 2] = Addr & 0xFF;
 3f02f80:	e7c50086 	strb	r0, [r5, r6, lsl #1]
			addr[i * 2 + 1] = Addr >> 8;
 3f02f84:	e1a00420 	mov	r0, r0, lsr #8
 3f02f88:	e5c40001 	strb	r0, [r4, #1]
 3f02f8c:	e2844002 	add	r4, r4, #2	; 0x2
 3f02f90:	e2877002 	add	r7, r7, #2	; 0x2
 3f02f94:	e2866001 	add	r6, r6, #1	; 0x1
 3f02f98:	e3560002 	cmp	r6, #2	; 0x2
 3f02f9c:	dafffff5 	ble	3f02f78 <cs8900_get_enetaddr+0xb4>
		}

		if (memcmp(env_enetaddr, "\0\0\0\0\0\0", 6) != 0 &&
 3f02fa0:	e1a00009 	mov	r0, r9
 3f02fa4:	e59f10ec 	ldr	r1, [pc, #ec]	; 3f03098 <cs8900_get_enetaddr+0x1d4>
 3f02fa8:	e3a02006 	mov	r2, #6	; 0x6
 3f02fac:	eb00319c 	bl	3f0f624 <memcmp>
 3f02fb0:	e3500000 	cmp	r0, #0	; 0x0
 3f02fb4:	0a000021 	beq	3f03040 <cs8900_get_enetaddr+0x17c>
 3f02fb8:	e1a00009 	mov	r0, r9
 3f02fbc:	e1a01005 	mov	r1, r5
 3f02fc0:	e3a02006 	mov	r2, #6	; 0x6
 3f02fc4:	eb003196 	bl	3f0f624 <memcmp>
 3f02fc8:	e3500000 	cmp	r0, #0	; 0x0
 3f02fcc:	0a00001b 	beq	3f03040 <cs8900_get_enetaddr+0x17c>
		    memcmp(env_enetaddr, addr, 6) != 0) {
			printf ("\nWarning: MAC addresses don't match:\n");
 3f02fd0:	e59f00c4 	ldr	r0, [pc, #c4]	; 3f0309c <cs8900_get_enetaddr+0x1d8>
 3f02fd4:	eb00261a 	bl	3f0c844 <printf>
			printf ("\tHW MAC address:  "
 3f02fd8:	e5d53003 	ldrb	r3, [r5, #3]
 3f02fdc:	e59f00bc 	ldr	r0, [pc, #bc]	; 3f030a0 <cs8900_get_enetaddr+0x1dc>
 3f02fe0:	e58d3000 	str	r3, [r13]
 3f02fe4:	e5d53004 	ldrb	r3, [r5, #4]
 3f02fe8:	e58d3004 	str	r3, [r13, #4]
 3f02fec:	e5d53002 	ldrb	r3, [r5, #2]
 3f02ff0:	e5d51000 	ldrb	r1, [r5]
 3f02ff4:	e5d5c005 	ldrb	r12, [r5, #5]
 3f02ff8:	e5d52001 	ldrb	r2, [r5, #1]
 3f02ffc:	e58dc008 	str	r12, [r13, #8]
 3f03000:	eb00260f 	bl	3f0c844 <printf>
				"%02X:%02X:%02X:%02X:%02X:%02X\n",
				addr[0], addr[1],
				addr[2], addr[3],
				addr[4], addr[5] );
			printf ("\t\"ethaddr\" value: "
 3f03004:	e55b3029 	ldrb	r3, [r11, -#41]
 3f03008:	e59f0094 	ldr	r0, [pc, #94]	; 3f030a4 <cs8900_get_enetaddr+0x1e0>
 3f0300c:	e58d3000 	str	r3, [r13]
 3f03010:	e55b3028 	ldrb	r3, [r11, -#40]
 3f03014:	e58d3004 	str	r3, [r13, #4]
 3f03018:	e55b302a 	ldrb	r3, [r11, -#42]
 3f0301c:	e55b102c 	ldrb	r1, [r11, -#44]
 3f03020:	e55bc027 	ldrb	r12, [r11, -#39]
 3f03024:	e55b202b 	ldrb	r2, [r11, -#43]
 3f03028:	e58dc008 	str	r12, [r13, #8]
 3f0302c:	eb002604 	bl	3f0c844 <printf>
				"%02X:%02X:%02X:%02X:%02X:%02X\n",
				env_enetaddr[0], env_enetaddr[1],
				env_enetaddr[2], env_enetaddr[3],
				env_enetaddr[4], env_enetaddr[5]) ;
			debug ("### Set MAC addr from environment\n");
			memcpy (addr, env_enetaddr, 6);
 3f03030:	e1a00005 	mov	r0, r5
 3f03034:	e1a01009 	mov	r1, r9
 3f03038:	e3a02006 	mov	r2, #6	; 0x6
 3f0303c:	eb003151 	bl	3f0f588 <memcpy>
		}
		if (!tmp) {
 3f03040:	e35a0000 	cmp	r10, #0	; 0x0
 3f03044:	1a000019 	bne	3f030b0 <cs8900_get_enetaddr+0x1ec>
			char ethaddr[20];
			sprintf (ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X",
 3f03048:	e5d53002 	ldrb	r3, [r5, #2]
 3f0304c:	e59f1054 	ldr	r1, [pc, #54]	; 3f030a8 <cs8900_get_enetaddr+0x1e4>
 3f03050:	e58d3000 	str	r3, [r13]
 3f03054:	e5d53003 	ldrb	r3, [r5, #3]
 3f03058:	e58d3004 	str	r3, [r13, #4]
 3f0305c:	e5d53004 	ldrb	r3, [r5, #4]
 3f03060:	e58d3008 	str	r3, [r13, #8]
 3f03064:	e5d53001 	ldrb	r3, [r5, #1]
 3f03068:	e5d52000 	ldrb	r2, [r5]
 3f0306c:	e24b4040 	sub	r4, r11, #64	; 0x40
 3f03070:	e5d5c005 	ldrb	r12, [r5, #5]
 3f03074:	e1a00004 	mov	r0, r4
 3f03078:	e58dc00c 	str	r12, [r13, #12]
 3f0307c:	eb0033ee 	bl	3f1003c <sprintf>
				 addr[0], addr[1],
				 addr[2], addr[3],
				 addr[4], addr[5]) ;
			debug ("### Set environment from HW MAC addr = \"%s\"\n",				ethaddr);
			setenv ("ethaddr", ethaddr);
 3f03080:	e59f0024 	ldr	r0, [pc, #24]	; 3f030ac <cs8900_get_enetaddr+0x1e8>
 3f03084:	e1a01004 	mov	r1, r4
 3f03088:	eb0023d2 	bl	3f0bfd8 <setenv>
 3f0308c:	ea000007 	b	3f030b0 <cs8900_get_enetaddr+0x1ec>
 3f03090:	0000630e 	andeq	r6, r0, r14, lsl #6
 3f03094:	00000136 	andeq	r0, r0, r6, lsr r1
 3f03098:	03f1af4c 	mvneqs	r10, #304	; 0x130
 3f0309c:	03f1af54 	mvneqs	r10, #336	; 0x150
 3f030a0:	03f1af7c 	mvneqs	r10, #496	; 0x1f0
 3f030a4:	03f1afb0 	mvneqs	r10, #704	; 0x2c0
 3f030a8:	03f1afe4 	mvneqs	r10, #912	; 0x390
 3f030ac:	03f1af44 	mvneqs	r10, #272	; 0x110
		}

	}
}
 3f030b0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f030b4 <eth_halt>:
 3f030b4:	e1a0c00d 	mov	r12, r13
 3f030b8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f030bc:	e24cb004 	sub	r11, r12, #4	; 0x4

void eth_halt (void)
{
	/* disable transmitter/receiver mode */
	put_reg (PP_LineCTL, 0);
 3f030c0:	e59f0010 	ldr	r0, [pc, #10]	; 3f030d8 <eth_halt+0x24>
 3f030c4:	e3a01000 	mov	r1, #0	; 0x0
 3f030c8:	ebffff58 	bl	3f02e30 <put_reg>

	/* "shutdown" to show ChipID or kernel wouldn't find he cs8900 ... */
	get_reg_init_bus (PP_ChipID);
 3f030cc:	e3a00000 	mov	r0, #0	; 0x0
 3f030d0:	ebffff34 	bl	3f02da8 <get_reg_init_bus>
 3f030d4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f030d8:	00000112 	andeq	r0, r0, r2, lsl r1

03f030dc <eth_init>:
 3f030dc:	e1a0c00d 	mov	r12, r13
 3f030e0:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f030e4:	e24cb004 	sub	r11, r12, #4	; 0x4
}

int eth_init (bd_t * bd)
{
 3f030e8:	e1a04000 	mov	r4, r0

	if (get_reg_init_bus (PP_ChipID) != 0x630e) {
 3f030ec:	e3a00000 	mov	r0, #0	; 0x0
 3f030f0:	ebffff2c 	bl	3f02da8 <get_reg_init_bus>
 3f030f4:	e59f309c 	ldr	r3, [pc, #9c]	; 3f03198 <eth_init+0xbc>
 3f030f8:	e1a00800 	mov	r0, r0, lsl #16
 3f030fc:	e1530820 	cmp	r3, r0, lsr #16
 3f03100:	1a000020 	bne	3f03188 <eth_init+0xac>
		printf ("CS8900 Ethernet chip not found?!\n");
		return 0;
	}

	eth_reset ();
 3f03104:	ebffff54 	bl	3f02e5c <eth_reset>
	/* set the ethernet address */
	put_reg (PP_IA + 0, bd->bi_enetaddr[0] | (bd->bi_enetaddr[1] << 8));
 3f03108:	e5d43008 	ldrb	r3, [r4, #8]
 3f0310c:	e5d41009 	ldrb	r1, [r4, #9]
 3f03110:	e3a00f56 	mov	r0, #344	; 0x158
 3f03114:	e1831401 	orr	r1, r3, r1, lsl #8
 3f03118:	ebffff44 	bl	3f02e30 <put_reg>
	put_reg (PP_IA + 2, bd->bi_enetaddr[2] | (bd->bi_enetaddr[3] << 8));
 3f0311c:	e5d4300a 	ldrb	r3, [r4, #10]
 3f03120:	e5d4100b 	ldrb	r1, [r4, #11]
 3f03124:	e59f0070 	ldr	r0, [pc, #70]	; 3f0319c <eth_init+0xc0>
 3f03128:	e1831401 	orr	r1, r3, r1, lsl #8
 3f0312c:	ebffff3f 	bl	3f02e30 <put_reg>
	put_reg (PP_IA + 4, bd->bi_enetaddr[4] | (bd->bi_enetaddr[5] << 8));
 3f03130:	e5d4300c 	ldrb	r3, [r4, #12]
 3f03134:	e5d4100d 	ldrb	r1, [r4, #13]
 3f03138:	e3a00f57 	mov	r0, #348	; 0x15c
 3f0313c:	e1831401 	orr	r1, r3, r1, lsl #8
 3f03140:	ebffff3a 	bl	3f02e30 <put_reg>

	/* receive only error free packets addressed to this card */
	put_reg (PP_RxCTL, PP_RxCTL_IA | PP_RxCTL_Broadcast | PP_RxCTL_RxOK);
 3f03144:	e3a00f41 	mov	r0, #260	; 0x104
 3f03148:	e3a01c0d 	mov	r1, #3328	; 0xd00
 3f0314c:	ebffff37 	bl	3f02e30 <put_reg>

	/* do not generate any interrupts on receive operations */
	put_reg (PP_RxCFG, 0);
 3f03150:	e59f0048 	ldr	r0, [pc, #48]	; 3f031a0 <eth_init+0xc4>
 3f03154:	e3a01000 	mov	r1, #0	; 0x0
 3f03158:	ebffff34 	bl	3f02e30 <put_reg>

	/* do not generate any interrupts on transmit operations */
	put_reg (PP_TxCFG, 0);
 3f0315c:	e59f0040 	ldr	r0, [pc, #40]	; 3f031a4 <eth_init+0xc8>
 3f03160:	e3a01000 	mov	r1, #0	; 0x0
 3f03164:	ebffff31 	bl	3f02e30 <put_reg>

	/* do not generate any interrupts on buffer operations */
	put_reg (PP_BufCFG, 0);
 3f03168:	e59f0038 	ldr	r0, [pc, #38]	; 3f031a8 <eth_init+0xcc>
 3f0316c:	e3a01000 	mov	r1, #0	; 0x0
 3f03170:	ebffff2e 	bl	3f02e30 <put_reg>

	/* enable transmitter/receiver mode */
	put_reg (PP_LineCTL, PP_LineCTL_Rx | PP_LineCTL_Tx);
 3f03174:	e59f0030 	ldr	r0, [pc, #30]	; 3f031ac <eth_init+0xd0>
 3f03178:	e3a010c0 	mov	r1, #192	; 0xc0
 3f0317c:	ebffff2b 	bl	3f02e30 <put_reg>

	return 0;
 3f03180:	e3a00000 	mov	r0, #0	; 0x0
 3f03184:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f03188:	e59f0020 	ldr	r0, [pc, #20]	; 3f031b0 <eth_init+0xd4>
 3f0318c:	eb0025ac 	bl	3f0c844 <printf>
 3f03190:	e3a00000 	mov	r0, #0	; 0x0
 3f03194:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f03198:	0000630e 	andeq	r6, r0, r14, lsl #6
 3f0319c:	0000015a 	andeq	r0, r0, r10, asr r1
 3f031a0:	00000102 	andeq	r0, r0, r2, lsl #2
 3f031a4:	00000106 	andeq	r0, r0, r6, lsl #2
 3f031a8:	0000010a 	andeq	r0, r0, r10, lsl #2
 3f031ac:	00000112 	andeq	r0, r0, r2, lsl r1
 3f031b0:	03f1b004 	mvneqs	r11, #4	; 0x4

03f031b4 <eth_rx>:
 3f031b4:	e1a0c00d 	mov	r12, r13
 3f031b8:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f031bc:	e24cb004 	sub	r11, r12, #4	; 0x4
}

/* Get a data block via Ethernet */
extern int eth_rx (void)
{
	int i;
	unsigned short rxlen;
	unsigned short *addr;
	unsigned short status;

	status = get_reg (PP_RER);
 3f031c0:	e3a00f49 	mov	r0, #292	; 0x124
 3f031c4:	ebffff10 	bl	3f02e0c <get_reg>

	if ((status & PP_RER_RxOK) == 0)
 3f031c8:	e2100c01 	ands	r0, r0, #256	; 0x100
 3f031cc:	091ba830 	ldmeqdb	r11, {r4, r5, r11, r13, r15}
		return 0;

	status = CS8900_RTDATA;		/* stat */
 3f031d0:	e59f306c 	ldr	r3, [pc, #6c]	; 3f03244 <eth_rx+0x90>
 3f031d4:	e1d320b0 	ldrh	r2, [r3]
	rxlen = CS8900_RTDATA;		/* len */
 3f031d8:	e1d330b0 	ldrh	r3, [r3]
 3f031dc:	e1a05803 	mov	r5, r3, lsl #16
 3f031e0:	e1a04825 	mov	r4, r5, lsr #16

	if (rxlen > PKTSIZE_ALIGN + PKTALIGN)
 3f031e4:	e3540e62 	cmp	r4, #1568	; 0x620
 3f031e8:	9a000001 	bls	3f031f4 <eth_rx+0x40>
		printf ("packet too big!\n");
 3f031ec:	e59f0054 	ldr	r0, [pc, #54]	; 3f03248 <eth_rx+0x94>
 3f031f0:	eb002593 	bl	3f0c844 <printf>

	for (addr = (unsigned short *) NetRxPackets[0], i = rxlen >> 1; i > 0;
 3f031f4:	e1a028a5 	mov	r2, r5, lsr #17
 3f031f8:	e59f004c 	ldr	r0, [pc, #4c]	; 3f0324c <eth_rx+0x98>
 3f031fc:	e3520000 	cmp	r2, #0	; 0x0
 3f03200:	e5901000 	ldr	r1, [r0]
 3f03204:	da000005 	ble	3f03220 <eth_rx+0x6c>
		 i--)
		*addr++ = CS8900_RTDATA;
 3f03208:	e59f3034 	ldr	r3, [pc, #34]	; 3f03244 <eth_rx+0x90>
 3f0320c:	e2422001 	sub	r2, r2, #1	; 0x1
 3f03210:	e1d330b0 	ldrh	r3, [r3]
 3f03214:	e3520000 	cmp	r2, #0	; 0x0
 3f03218:	e0c130b2 	strh	r3, [r1], #2
 3f0321c:	cafffff9 	bgt	3f03208 <eth_rx+0x54>
	if (rxlen & 1)
 3f03220:	e3140001 	tst	r4, #1	; 0x1
		*addr++ = CS8900_RTDATA;
 3f03224:	159f3018 	ldrne	r3, [pc, #18]	; 3f03244 <eth_rx+0x90>
 3f03228:	11d330b0 	ldrneh	r3, [r3]
 3f0322c:	11c130b0 	strneh	r3, [r1]

	/* Pass the packet up to the protocol layers. */
	NetReceive (NetRxPackets[0], rxlen);
 3f03230:	e5900000 	ldr	r0, [r0]
 3f03234:	e1a01004 	mov	r1, r4
 3f03238:	ebfff89d 	bl	3f014b4 <NetReceive>

	return rxlen;
 3f0323c:	e1a00004 	mov	r0, r4
}
 3f03240:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f03244:	84000300 	strhi	r0, [r0], -#768
 3f03248:	03f1b028 	mvneqs	r11, #40	; 0x28
 3f0324c:	03f6a6c0 	mvneqs	r10, #201326592	; 0xc000000

03f03250 <eth_send>:
 3f03250:	e1a0c00d 	mov	r12, r13
 3f03254:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f03258:	e24cb004 	sub	r11, r12, #4	; 0x4

/* Send a data block via Ethernet. */
extern int eth_send (volatile void *packet, int length)
{
 3f0325c:	e1a06000 	mov	r6, r0
 3f03260:	e1a05001 	mov	r5, r1
	volatile unsigned short *addr;
	int tmo;
	unsigned short s;

retry:
	/* initiate a transmit sequence */
	CS8900_TxCMD = PP_TxCmd_TxStart_Full;
 3f03264:	e3a020c0 	mov	r2, #192	; 0xc0
 3f03268:	e59f30c4 	ldr	r3, [pc, #c4]	; 3f03334 <eth_send+0xe4>
	CS8900_TxLEN = length;

	/* Test to see if the chip has allocated memory for the packet */
	if ((get_reg (PP_BusSTAT) & PP_BusSTAT_TxRDY) == 0) {
 3f0326c:	e3a00f4e 	mov	r0, #312	; 0x138
 3f03270:	e1c320b0 	strh	r2, [r3]
 3f03274:	e2833002 	add	r3, r3, #2	; 0x2
 3f03278:	e1c350b0 	strh	r5, [r3]
 3f0327c:	ebfffee2 	bl	3f02e0c <get_reg>
 3f03280:	e2104c01 	ands	r4, r0, #256	; 0x100
 3f03284:	1a00000b 	bne	3f032b8 <eth_send+0x68>
		/* Oops... this should not happen! */
		printf ("cs: unable to send packet; retrying...\n");
 3f03288:	e59f00a8 	ldr	r0, [pc, #a8]	; 3f03338 <eth_send+0xe8>
 3f0328c:	eb00256c 	bl	3f0c844 <printf>
		for (tmo = get_timer (0) + 5 * CFG_HZ; get_timer (0) < tmo;)
 3f03290:	e1a00004 	mov	r0, r4
 3f03294:	ebfff54c 	bl	3f007cc <get_timer>
 3f03298:	e2804623 	add	r4, r0, #36700160	; 0x2300000
 3f0329c:	e284490a 	add	r4, r4, #163840	; 0x28000
 3f032a0:	e3a00000 	mov	r0, #0	; 0x0
 3f032a4:	ebfff548 	bl	3f007cc <get_timer>
 3f032a8:	e1500004 	cmp	r0, r4
 3f032ac:	3afffffb 	bcc	3f032a0 <eth_send+0x50>
			/*NOP*/;
		eth_reset ();
 3f032b0:	ebfffee9 	bl	3f02e5c <eth_reset>
		goto retry;
 3f032b4:	eaffffea 	b	3f03264 <eth_send+0x14>
	}

	/* Write the contents of the packet */
	/* assume even number of bytes */
	for (addr = packet; length > 0; length -= 2)
 3f032b8:	e1a00006 	mov	r0, r6
 3f032bc:	e3550000 	cmp	r5, #0	; 0x0
 3f032c0:	da000005 	ble	3f032dc <eth_send+0x8c>
		CS8900_RTDATA = *addr++;
 3f032c4:	e59f2070 	ldr	r2, [pc, #70]	; 3f0333c <eth_send+0xec>
 3f032c8:	e2455002 	sub	r5, r5, #2	; 0x2
 3f032cc:	e0d030b2 	ldrh	r3, [r0], #2
 3f032d0:	e3550000 	cmp	r5, #0	; 0x0
 3f032d4:	e1c230b0 	strh	r3, [r2]
 3f032d8:	cafffff9 	bgt	3f032c4 <eth_send+0x74>

	/* wait for transfer to succeed */
	tmo = get_timer (0) + 5 * CFG_HZ;
 3f032dc:	e3a00000 	mov	r0, #0	; 0x0
 3f032e0:	ebfff539 	bl	3f007cc <get_timer>
 3f032e4:	e2804623 	add	r4, r0, #36700160	; 0x2300000
 3f032e8:	e284490a 	add	r4, r4, #163840	; 0x28000
	while ((s = get_reg (PP_TER) & ~0x1F) == 0) {
		if (get_timer (0) >= tmo)
			break;
	}
 3f032ec:	e3a00f4a 	mov	r0, #296	; 0x128
 3f032f0:	e59f5048 	ldr	r5, [pc, #48]	; 3f03340 <eth_send+0xf0>
 3f032f4:	ebfffec4 	bl	3f02e0c <get_reg>
 3f032f8:	e0005005 	and	r5, r0, r5
 3f032fc:	e3550000 	cmp	r5, #0	; 0x0
 3f03300:	1a000003 	bne	3f03314 <eth_send+0xc4>
 3f03304:	e1a00005 	mov	r0, r5
 3f03308:	ebfff52f 	bl	3f007cc <get_timer>
 3f0330c:	e1500004 	cmp	r0, r4
 3f03310:	3afffff5 	bcc	3f032ec <eth_send+0x9c>

	/* nothing */ ;
	if ((s & (PP_TER_CRS | PP_TER_TxOK)) != PP_TER_TxOK) {
 3f03314:	e2053d05 	and	r3, r5, #320	; 0x140
 3f03318:	e3530c01 	cmp	r3, #256	; 0x100
 3f0331c:	0a000002 	beq	3f0332c <eth_send+0xdc>
		printf ("\ntransmission error %#x\n", s);
 3f03320:	e59f001c 	ldr	r0, [pc, #1c]	; 3f03344 <eth_send+0xf4>
 3f03324:	e1a01005 	mov	r1, r5
 3f03328:	eb002545 	bl	3f0c844 <printf>
	}

	return 0;
 3f0332c:	e3a00000 	mov	r0, #0	; 0x0
}
 3f03330:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f03334:	84000304 	strhi	r0, [r0], -#772
 3f03338:	03f1b03c 	mvneqs	r11, #60	; 0x3c
 3f0333c:	84000300 	strhi	r0, [r0], -#768
 3f03340:	0000ffe0 	andeq	r15, r0, r0, ror #31
 3f03344:	03f1b064 	mvneqs	r11, #100	; 0x64

03f03348 <cs8900_e2prom_ready>:
 3f03348:	e1a0c00d 	mov	r12, r13
 3f0334c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f03350:	e24cb004 	sub	r11, r12, #4	; 0x4

static void cs8900_e2prom_ready(void)
{
	while(get_reg(PP_SelfST) & SI_BUSY);
 3f03354:	e59f000c 	ldr	r0, [pc, #c]	; 3f03368 <cs8900_e2prom_ready+0x20>
 3f03358:	ebfffeab 	bl	3f02e0c <get_reg>
 3f0335c:	e3100c01 	tst	r0, #256	; 0x100
 3f03360:	1afffffb 	bne	3f03354 <cs8900_e2prom_ready+0xc>
 3f03364:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f03368:	00000136 	andeq	r0, r0, r6, lsr r1

03f0336c <cs8900_e2prom_read>:
 3f0336c:	e1a0c00d 	mov	r12, r13
 3f03370:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f03374:	e24cb004 	sub	r11, r12, #4	; 0x4
}

/***********************************************************/
/* read a 16-bit word out of the EEPROM                    */
/***********************************************************/

int cs8900_e2prom_read(unsigned char addr, unsigned short *value)
{
 3f03378:	e1a04000 	mov	r4, r0
 3f0337c:	e1a05001 	mov	r5, r1
 3f03380:	e20440ff 	and	r4, r4, #255	; 0xff
	cs8900_e2prom_ready();
 3f03384:	ebffffef 	bl	3f03348 <cs8900_e2prom_ready>
	put_reg(PP_EECMD, EEPROM_READ_CMD | addr);
 3f03388:	e3a00040 	mov	r0, #64	; 0x40
 3f0338c:	e3841c02 	orr	r1, r4, #512	; 0x200
 3f03390:	ebfffea6 	bl	3f02e30 <put_reg>
	cs8900_e2prom_ready();
 3f03394:	ebffffeb 	bl	3f03348 <cs8900_e2prom_ready>
	*value = get_reg(PP_EEData);
 3f03398:	e3a00042 	mov	r0, #66	; 0x42
 3f0339c:	ebfffe9a 	bl	3f02e0c <get_reg>
 3f033a0:	e1c500b0 	strh	r0, [r5]

	return 0;
 3f033a4:	e3a00000 	mov	r0, #0	; 0x0
 3f033a8:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f033ac <cs8900_e2prom_write>:
 3f033ac:	e1a0c00d 	mov	r12, r13
 3f033b0:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f033b4:	e24cb004 	sub	r11, r12, #4	; 0x4
}


/***********************************************************/
/* write a 16-bit word into the EEPROM                     */
/***********************************************************/

int cs8900_e2prom_write(unsigned char addr, unsigned short value)
{
 3f033b8:	e1a05000 	mov	r5, r0
 3f033bc:	e20550ff 	and	r5, r5, #255	; 0xff
 3f033c0:	e1a04801 	mov	r4, r1, lsl #16
 3f033c4:	e1a04824 	mov	r4, r4, lsr #16
	cs8900_e2prom_ready();
 3f033c8:	ebffffde 	bl	3f03348 <cs8900_e2prom_ready>
	put_reg(PP_EECMD, EEPROM_WRITE_EN);
 3f033cc:	e3a00040 	mov	r0, #64	; 0x40
 3f033d0:	e3a010f0 	mov	r1, #240	; 0xf0
 3f033d4:	ebfffe95 	bl	3f02e30 <put_reg>
	cs8900_e2prom_ready();
 3f033d8:	ebffffda 	bl	3f03348 <cs8900_e2prom_ready>
	put_reg(PP_EEData, value);
 3f033dc:	e3a00042 	mov	r0, #66	; 0x42
 3f033e0:	e1a01004 	mov	r1, r4
 3f033e4:	ebfffe91 	bl	3f02e30 <put_reg>
	put_reg(PP_EECMD, EEPROM_WRITE_CMD | addr);
 3f033e8:	e3a00040 	mov	r0, #64	; 0x40
 3f033ec:	e3851c01 	orr	r1, r5, #256	; 0x100
 3f033f0:	ebfffe8e 	bl	3f02e30 <put_reg>
	cs8900_e2prom_ready();
 3f033f4:	ebffffd3 	bl	3f03348 <cs8900_e2prom_ready>
	put_reg(PP_EECMD, EEPROM_WRITE_DIS);
 3f033f8:	e3a00040 	mov	r0, #64	; 0x40
 3f033fc:	e3a01000 	mov	r1, #0	; 0x0
 3f03400:	ebfffe8a 	bl	3f02e30 <put_reg>
	cs8900_e2prom_ready();
 3f03404:	ebffffcf 	bl	3f03348 <cs8900_e2prom_ready>

	return 0;
 3f03408:	e3a00000 	mov	r0, #0	; 0x0
 3f0340c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f03410 <main_loop>:
 3f03410:	e1a0c00d 	mov	r12, r13
 3f03414:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f03418:	e24cb004 	sub	r11, r12, #4	; 0x4
{
#ifndef CFG_HUSH_PARSER
	static char lastcommand[CFG_CBSIZE] = { 0, };
	int len;
	int rc = 1;
 3f0341c:	e3a02001 	mov	r2, #1	; 0x1
	int flag;
#endif

#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
	char *s;
	int bootdelay;
#endif
#ifdef CONFIG_PREBOOT
	char *p;
#endif
#ifdef CONFIG_BOOTCOUNT_LIMIT
	unsigned long bootcount = 0;
	unsigned long bootlimit = 0;
	char *bcs;
	char bcs_set[16];
#endif /* CONFIG_BOOTCOUNT_LIMIT */

#if defined(CONFIG_VFD) && defined(VFD_TEST_LOGO)
	ulong bmp = 0;		/* default bitmap */
	extern int trab_vfd (ulong bitmap);

#ifdef CONFIG_MODEM_SUPPORT
	if (do_mdm_init)
		bmp = 1;	/* alternate bitmap */
#endif
	trab_vfd (bmp);
#endif	/* CONFIG_VFD && VFD_TEST_LOGO */

#ifdef CONFIG_BOOTCOUNT_LIMIT
	bootcount = bootcount_load();
	bootcount++;
	bootcount_store (bootcount);
	sprintf (bcs_set, "%lu", bootcount);
	setenv ("bootcount", bcs_set);
	bcs = getenv ("bootlimit");
	bootlimit = bcs ? simple_strtoul (bcs, NULL, 10) : 0;
#endif /* CONFIG_BOOTCOUNT_LIMIT */

#ifdef CONFIG_MODEM_SUPPORT
	debug ("DEBUG: main_loop:   do_mdm_init=%d\n", do_mdm_init);
	if (do_mdm_init) {
		uchar *str = strdup(getenv("mdm_cmd"));
		setenv ("preboot", str);  /* set or delete definition */
		if (str != NULL)
			free (str);
		mdm_init(); /* wait for modem connection */
	}
#endif  /* CONFIG_MODEM_SUPPORT */

#ifdef CONFIG_VERSION_VARIABLE
	{
		extern char version_string[];

		setenv ("ver", version_string);  /* set version variable */
	}
#endif /* CONFIG_VERSION_VARIABLE */

#ifdef CFG_HUSH_PARSER
	u_boot_hush_start ();
#endif

#ifdef CONFIG_PREBOOT
	if ((p = getenv ("preboot")) != NULL) {
# ifdef CONFIG_AUTOBOOT_KEYED
		int prev = disable_ctrlc(1);	/* disable Control C checking */
# endif

# ifndef CFG_HUSH_PARSER
		run_command (p, 0);
# else
		parse_string_outer(p, FLAG_PARSE_SEMICOLON |
				    FLAG_EXIT_FROM_LOOP);
# endif

# ifdef CONFIG_AUTOBOOT_KEYED
		disable_ctrlc(prev);	/* restore Control C checking */
# endif
	}
#endif /* CONFIG_PREBOOT */



#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
	s = getenv ("bootdelay");
 3f03420:	e59f03c4 	ldr	r0, [pc, #3c4]	; 3f037ec <main_loop+0x3dc>
 3f03424:	e24dd048 	sub	r13, r13, #72	; 0x48
 3f03428:	e50b2064 	str	r2, [r11, -#100]
 3f0342c:	eb00230a 	bl	3f0c05c <getenv>
	bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;
 3f03430:	e2507000 	subs	r7, r0, #0	; 0x0
 3f03434:	0a000005 	beq	3f03450 <main_loop+0x40>
 3f03438:	e1a00007 	mov	r0, r7
 3f0343c:	e3a01000 	mov	r1, #0	; 0x0
 3f03440:	e3a0200a 	mov	r2, #10	; 0xa
 3f03444:	eb0030ef 	bl	3f0f808 <simple_strtol>
 3f03448:	e50b0068 	str	r0, [r11, -#104]
 3f0344c:	ea000000 	b	3f03454 <main_loop+0x44>
 3f03450:	e50b7068 	str	r7, [r11, -#104]

	debug ("### main_loop entered: bootdelay=%d\n\n", bootdelay);

# ifdef CONFIG_BOOT_RETRY_TIME
	init_cmd_timeout ();
# endif	/* CONFIG_BOOT_RETRY_TIME */


#ifdef CONFIG_BOOTCOUNT_LIMIT
	if (bootlimit && (bootcount > bootlimit)) 
	{
		printf ("Warning: Bootlimit (%u) exceeded. Using altbootcmd.\n", (unsigned)bootlimit);
		s = getenv ("altbootcmd");
	}
	else
#endif /* CONFIG_BOOTCOUNT_LIMIT */
	{
		s = getenv ("bootcmd");
 3f03454:	e59f0394 	ldr	r0, [pc, #394]	; 3f037f0 <main_loop+0x3e0>
 3f03458:	eb0022ff 	bl	3f0c05c <getenv>
		
	
	// SD ī尡 ִ ˻Ѵ.
	// 1̸ SD ִ .
	if(mmc_init_once == 1)
 3f0345c:	e59f3390 	ldr	r3, [pc, #390]	; 3f037f4 <main_loop+0x3e4>
 3f03460:	e5936000 	ldr	r6, [r3]
 3f03464:	e1a07000 	mov	r7, r0
 3f03468:	e3560001 	cmp	r6, #1	; 0x1
 3f0346c:	1a00009b 	bne	3f036e0 <main_loop+0x2d0>
	{
		int size = 0;
		char *gp2xbootimg[] 	= { "fatload", "mmc", "0", "0x1000000", "gp2xboot.img"		};
 3f03470:	e59fe380 	ldr	r14, [pc, #380]	; 3f037f8 <main_loop+0x3e8>
 3f03474:	e8be000f 	ldmia	r14!, {r0, r1, r2, r3}
 3f03478:	e24bc038 	sub	r12, r11, #56	; 0x38
 3f0347c:	e8ac000f 	stmia	r12!, {r0, r1, r2, r3}
		char *gp2xkernelimg[] 	= { "fatload", "mmc", "0", "0x1000000", "gp2xkernel.img"	};
 3f03480:	e59f4374 	ldr	r4, [pc, #374]	; 3f037fc <main_loop+0x3ec>
 3f03484:	e8b4000f 	ldmia	r4!, {r0, r1, r2, r3}
 3f03488:	e59ee000 	ldr	r14, [r14]
 3f0348c:	e24ba04c 	sub	r10, r11, #76	; 0x4c
 3f03490:	e58ce000 	str	r14, [r12]
 3f03494:	e1a0c00a 	mov	r12, r10
 3f03498:	e8ac000f 	stmia	r12!, {r0, r1, r2, r3}
 3f0349c:	e5944000 	ldr	r4, [r4]
		char *gp2xfileimg[] 	= { "fatload", "mmc", "0", "0x1000000", "gp2xfile.img"		};
 3f034a0:	e59fe358 	ldr	r14, [pc, #358]	; 3f03800 <main_loop+0x3f0>
 3f034a4:	e8be000f 	ldmia	r14!, {r0, r1, r2, r3}
 3f034a8:	e58c4000 	str	r4, [r12]
 3f034ac:	e24bc060 	sub	r12, r11, #96	; 0x60
 3f034b0:	e50bc06c 	str	r12, [r11, -#108]
 3f034b4:	e8ac000f 	stmia	r12!, {r0, r1, r2, r3}
 3f034b8:	e59e3000 	ldr	r3, [r14]
		unsigned char bShowLogo = 0; 
		

		printf("UPDATE ...\n");
 3f034bc:	e59f0340 	ldr	r0, [pc, #340]	; 3f03804 <main_loop+0x3f4>
 3f034c0:	e58c3000 	str	r3, [r12]
 3f034c4:	eb0024de 	bl	3f0c844 <printf>

		printf("BOOT UPDATE ----------------------------\n");
 3f034c8:	e59f0338 	ldr	r0, [pc, #338]	; 3f03808 <main_loop+0x3f8>
 3f034cc:	e3a05000 	mov	r5, #0	; 0x0
 3f034d0:	eb0024db 	bl	3f0c844 <printf>
		// uboot.img  ִ ã´.
		size = do_fat_fsload(NULL, 0, 5, gp2xbootimg);
 3f034d4:	e1a00005 	mov	r0, r5
 3f034d8:	e1a01005 	mov	r1, r5
 3f034dc:	e3a02005 	mov	r2, #5	; 0x5
 3f034e0:	e24b3038 	sub	r3, r11, #56	; 0x38
 3f034e4:	eb000a57 	bl	3f05e48 <do_fat_fsload>
		printf("1 : g_filesize %x\n", g_filesize);
 3f034e8:	e59f931c 	ldr	r9, [pc, #31c]	; 3f0380c <main_loop+0x3fc>
 3f034ec:	e1a04000 	mov	r4, r0
 3f034f0:	e59f0318 	ldr	r0, [pc, #318]	; 3f03810 <main_loop+0x400>
 3f034f4:	e5991000 	ldr	r1, [r9]
 3f034f8:	eb0024d1 	bl	3f0c844 <printf>
		if(size != -1)
 3f034fc:	e3740001 	cmn	r4, #1	; 0x1
 3f03500:	0a000017 	beq	3f03564 <main_loop+0x154>
		{
			// uboot ã Ʈ Ѵ.
			int ret_gp2xboot_erase = 0;
			int ret_gp2xboot_write = 0;
			ulong length = 0x4000 * ((size/0x4000)+1);		// 0x4000   ̰ 1ؼ ϸ 0x4000  ȴ.
 3f03504:	e2843dff 	add	r3, r4, #16320	; 0x3fc0
 3f03508:	e283303f 	add	r3, r3, #63	; 0x3f
			printf("gp2xboot.img Update %d 0x%x \n", size, length);
 3f0350c:	e1a01004 	mov	r1, r4
 3f03510:	e1540005 	cmp	r4, r5
 3f03514:	a1a03744 	movge	r3, r4, asr #14
 3f03518:	b1a03743 	movlt	r3, r3, asr #14
 3f0351c:	e2833001 	add	r3, r3, #1	; 0x1
 3f03520:	e1a04703 	mov	r4, r3, lsl #14
 3f03524:	e1a02004 	mov	r2, r4
 3f03528:	e59f02e4 	ldr	r0, [pc, #2e4]	; 3f03814 <main_loop+0x404>
			
			if(bShowLogo == 0)
			{
				bShowLogo = 1;
 3f0352c:	e1a05006 	mov	r5, r6
 3f03530:	eb0024c3 	bl	3f0c844 <printf>
				display_Firmware();
 3f03534:	eb00416c 	bl	3f13aec <display_Firmware>
			}
			
			do
			{
				do 
				{
					ret_gp2xboot_erase = nand_erase_func(0, length);
 3f03538:	e3a00000 	mov	r0, #0	; 0x0
 3f0353c:	e1a01004 	mov	r1, r4
 3f03540:	eb001d09 	bl	3f0a96c <nand_erase_func>
				}
				while(ret_gp2xboot_erase);		// 0̸  ̴.
 3f03544:	e2501000 	subs	r1, r0, #0	; 0x0
 3f03548:	1afffffa 	bne	3f03538 <main_loop+0x128>

				ret_gp2xboot_write = nand_write_func(0x1000000, 0, length);
 3f0354c:	e3a00401 	mov	r0, #16777216	; 0x1000000
 3f03550:	e1a02004 	mov	r2, r4
 3f03554:	eb001cd4 	bl	3f0a8ac <nand_write_func>
			}while(ret_gp2xboot_write);	// 0̸  ̴.
 3f03558:	e3500000 	cmp	r0, #0	; 0x0
 3f0355c:	1afffff5 	bne	3f03538 <main_loop+0x128>
			
			//do_nand(NULL, 0, 4, gp2xbootimg_erase);
			//do_nand(NULL, 0, 4, gp2xbootimg_write);
		}
 3f03560:	ea000001 	b	3f0356c <main_loop+0x15c>
		else
		{
			printf("gp2xboot.img not found\n");
 3f03564:	e59f02ac 	ldr	r0, [pc, #2ac]	; 3f03818 <main_loop+0x408>
 3f03568:	eb0024b5 	bl	3f0c844 <printf>
		}
		
		printf("KERNEL UPDATE ----------------------------\n");
 3f0356c:	e59f02a8 	ldr	r0, [pc, #2a8]	; 3f0381c <main_loop+0x40c>
 3f03570:	eb0024b3 	bl	3f0c844 <printf>
		size = -1;
		size = do_fat_fsload(NULL, 0, 5, gp2xkernelimg);
 3f03574:	e3a00000 	mov	r0, #0	; 0x0
 3f03578:	e1a01000 	mov	r1, r0
 3f0357c:	e3a02005 	mov	r2, #5	; 0x5
 3f03580:	e1a0300a 	mov	r3, r10
 3f03584:	eb000a2f 	bl	3f05e48 <do_fat_fsload>
 3f03588:	e1a04000 	mov	r4, r0
		printf("2 : g_filesize %x\n", g_filesize);
 3f0358c:	e59f028c 	ldr	r0, [pc, #28c]	; 3f03820 <main_loop+0x410>
 3f03590:	e5991000 	ldr	r1, [r9]
 3f03594:	eb0024aa 	bl	3f0c844 <printf>
		if(size != -1)
 3f03598:	e3740001 	cmn	r4, #1	; 0x1
 3f0359c:	0a000019 	beq	3f03608 <main_loop+0x1f8>
		{
			// kernel ã Ʈ Ѵ.
			int ret_gp2xkernel_erase = 0;
			int ret_gp2xkernel_write = 0;
			ulong length = 0x4000 * ((size/0x4000)+1);		// 0x4000   ̰ 1ؼ ϸ 0x4000  ȴ.
 3f035a0:	e2843dff 	add	r3, r4, #16320	; 0x3fc0
 3f035a4:	e283303f 	add	r3, r3, #63	; 0x3f
 3f035a8:	e2541000 	subs	r1, r4, #0	; 0x0
 3f035ac:	a1a03744 	movge	r3, r4, asr #14
 3f035b0:	b1a03743 	movlt	r3, r3, asr #14
 3f035b4:	e2833001 	add	r3, r3, #1	; 0x1
 3f035b8:	e1a04703 	mov	r4, r3, lsl #14
			printf("gp2xkernel.img Update %d 0x%x \n", size, length);
 3f035bc:	e59f0260 	ldr	r0, [pc, #260]	; 3f03824 <main_loop+0x414>
 3f035c0:	e1a02004 	mov	r2, r4
 3f035c4:	eb00249e 	bl	3f0c844 <printf>

			if(bShowLogo == 0)
 3f035c8:	e3550000 	cmp	r5, #0	; 0x0
 3f035cc:	1a000001 	bne	3f035d8 <main_loop+0x1c8>
			{
				bShowLogo = 1;
 3f035d0:	e3a05001 	mov	r5, #1	; 0x1
				display_Firmware();
 3f035d4:	eb004144 	bl	3f13aec <display_Firmware>
			}

			do
			{
				do 
				{
					ret_gp2xkernel_erase = nand_erase_func(0x80000, length);
 3f035d8:	e3a00702 	mov	r0, #524288	; 0x80000
 3f035dc:	e1a01004 	mov	r1, r4
 3f035e0:	eb001ce1 	bl	3f0a96c <nand_erase_func>
				}
				while(ret_gp2xkernel_erase);		// 0̸  ̴.
 3f035e4:	e3500000 	cmp	r0, #0	; 0x0
 3f035e8:	1afffffa 	bne	3f035d8 <main_loop+0x1c8>

				ret_gp2xkernel_write = nand_write_func(0x1000000, 0x80000, length);
 3f035ec:	e3a00401 	mov	r0, #16777216	; 0x1000000
 3f035f0:	e3a01702 	mov	r1, #524288	; 0x80000
 3f035f4:	e1a02004 	mov	r2, r4
 3f035f8:	eb001cab 	bl	3f0a8ac <nand_write_func>
			}while(ret_gp2xkernel_write);	// 0̸  ̴.
 3f035fc:	e3500000 	cmp	r0, #0	; 0x0
 3f03600:	1afffff4 	bne	3f035d8 <main_loop+0x1c8>
			//do_nand(NULL, 0, 4, gp2xbootimg_erase);
			//do_nand(NULL, 0, 4, gp2xbootimg_write);
		}
 3f03604:	ea000001 	b	3f03610 <main_loop+0x200>
		else
		{
			printf("gp2xkernel.img not found\n");
 3f03608:	e59f0218 	ldr	r0, [pc, #218]	; 3f03828 <main_loop+0x418>
 3f0360c:	eb00248c 	bl	3f0c844 <printf>
		}

		printf("FILE UPDATE ----------------------------\n");
 3f03610:	e59f0214 	ldr	r0, [pc, #214]	; 3f0382c <main_loop+0x41c>
 3f03614:	eb00248a 	bl	3f0c844 <printf>
		size = -1;
		size = do_fat_fsload(NULL, 0, 5, gp2xfileimg);
 3f03618:	e3a00000 	mov	r0, #0	; 0x0
 3f0361c:	e1a01000 	mov	r1, r0
 3f03620:	e51b306c 	ldr	r3, [r11, -#108]
 3f03624:	e3a02005 	mov	r2, #5	; 0x5
 3f03628:	eb000a06 	bl	3f05e48 <do_fat_fsload>
 3f0362c:	e1a04000 	mov	r4, r0
		printf("3 : g_filesize %x\n", g_filesize);
 3f03630:	e59f01f8 	ldr	r0, [pc, #1f8]	; 3f03830 <main_loop+0x420>
 3f03634:	e5991000 	ldr	r1, [r9]
 3f03638:	eb002481 	bl	3f0c844 <printf>
		if(size != -1)
 3f0363c:	e3740001 	cmn	r4, #1	; 0x1
 3f03640:	0a000024 	beq	3f036d8 <main_loop+0x2c8>
		{
			// disk file ã Ʈ Ѵ.
			int ret_gp2xfile_erase = 0;
			int ret_gp2xfile_write = 0;
			ulong length = 0x4000 * ((size/0x4000)+1);		// 0x4000   ̰ 1ؼ ϸ 0x4000  ȴ.
 3f03644:	e2843dff 	add	r3, r4, #16320	; 0x3fc0
 3f03648:	e283303f 	add	r3, r3, #63	; 0x3f
 3f0364c:	e2541000 	subs	r1, r4, #0	; 0x0
 3f03650:	a1a03744 	movge	r3, r4, asr #14
 3f03654:	b1a03743 	movlt	r3, r3, asr #14
 3f03658:	e2833001 	add	r3, r3, #1	; 0x1
 3f0365c:	e1a04703 	mov	r4, r3, lsl #14
			printf("gp2xfile.img Update %d 0x%x \n", size, length);
 3f03660:	e59f01cc 	ldr	r0, [pc, #1cc]	; 3f03834 <main_loop+0x424>
 3f03664:	e1a02004 	mov	r2, r4
 3f03668:	eb002475 	bl	3f0c844 <printf>

			if(bShowLogo == 0)
 3f0366c:	e3550000 	cmp	r5, #0	; 0x0
 3f03670:	1a000000 	bne	3f03678 <main_loop+0x268>
			{
				bShowLogo = 1;
				display_Firmware();
 3f03674:	eb00411c 	bl	3f13aec <display_Firmware>
			}
			
			do
			{
				do 
				{
					//ret_gp2xfile_erase = nand_erase_func(0x240000, (0x100000*50)-0x240000);
					ret_gp2xfile_erase = nand_erase_func(0x240000, 0x3200000);
 3f03678:	e3a00709 	mov	r0, #2359296	; 0x240000
 3f0367c:	e3a01632 	mov	r1, #52428800	; 0x3200000
 3f03680:	eb001cb9 	bl	3f0a96c <nand_erase_func>
				}
				while(ret_gp2xfile_erase);		// 0̸  ̴.
 3f03684:	e3500000 	cmp	r0, #0	; 0x0
 3f03688:	1afffffa 	bne	3f03678 <main_loop+0x268>

				ret_gp2xfile_write = nand_write_jffs2_func(0x1000000, 0x240000, length);
 3f0368c:	e3a00401 	mov	r0, #16777216	; 0x1000000
 3f03690:	e3a01709 	mov	r1, #2359296	; 0x240000
 3f03694:	e1a02004 	mov	r2, r4
 3f03698:	eb001c52 	bl	3f0a7e8 <nand_write_jffs2_func>
				if(ret_gp2xfile_write)	ret_gp2xfile_write = nand_write_jffs2_func(0x1000000, 0x240000, length);
 3f0369c:	e3500000 	cmp	r0, #0	; 0x0
 3f036a0:	0a000003 	beq	3f036b4 <main_loop+0x2a4>
 3f036a4:	e3a00401 	mov	r0, #16777216	; 0x1000000
 3f036a8:	e3a01709 	mov	r1, #2359296	; 0x240000
 3f036ac:	e1a02004 	mov	r2, r4
 3f036b0:	eb001c4c 	bl	3f0a7e8 <nand_write_jffs2_func>
				if(ret_gp2xfile_write)	ret_gp2xfile_write = nand_write_jffs2_func(0x1000000, 0x240000, length);
 3f036b4:	e3500000 	cmp	r0, #0	; 0x0
 3f036b8:	0a000003 	beq	3f036cc <main_loop+0x2bc>
 3f036bc:	e3a00401 	mov	r0, #16777216	; 0x1000000
 3f036c0:	e3a01709 	mov	r1, #2359296	; 0x240000
 3f036c4:	e1a02004 	mov	r2, r4
 3f036c8:	eb001c46 	bl	3f0a7e8 <nand_write_jffs2_func>
			}while(ret_gp2xfile_write);	// 0̸  ̴.
 3f036cc:	e3500000 	cmp	r0, #0	; 0x0
 3f036d0:	1affffe8 	bne	3f03678 <main_loop+0x268>

			//do_nand(NULL, 0, 4, gp2xbootimg_erase);
			//do_nand(NULL, 0, 4, gp2xbootimg_write);
		}
 3f036d4:	ea000001 	b	3f036e0 <main_loop+0x2d0>
		else
		{
			printf("gp2xfile.img not found\n");
 3f036d8:	e59f0158 	ldr	r0, [pc, #158]	; 3f03838 <main_loop+0x428>
 3f036dc:	eb002458 	bl	3f0c844 <printf>
		}
	}
	}
	
		

	printf("### main_loop: bootcmd=\"%s\"\n", s ? s : "<UNDEFINED>");
 3f036e0:	e59f1154 	ldr	r1, [pc, #154]	; 3f0383c <main_loop+0x42c>
 3f036e4:	e3570000 	cmp	r7, #0	; 0x0
 3f036e8:	e59f0150 	ldr	r0, [pc, #150]	; 3f03840 <main_loop+0x430>
 3f036ec:	11a01007 	movne	r1, r7
 3f036f0:	eb002453 	bl	3f0c844 <printf>
	debug ("### main_loop: bootcmd=\"%s\"\n", s ? s : "<UNDEFINED>");

	if(bootdelay >= 0 && s && !abortboot (bootdelay)) 
 3f036f4:	e51b2068 	ldr	r2, [r11, -#104]
 3f036f8:	e2573000 	subs	r3, r7, #0	; 0x0
 3f036fc:	13a03001 	movne	r3, #1	; 0x1
 3f03700:	e3520000 	cmp	r2, #0	; 0x0
 3f03704:	b3a03000 	movlt	r3, #0	; 0x0
 3f03708:	e3530000 	cmp	r3, #0	; 0x0
 3f0370c:	0a000026 	beq	3f037ac <main_loop+0x39c>
 3f03710:	e1a04002 	mov	r4, r2
 3f03714:	e3a06000 	mov	r6, #0	; 0x0
 3f03718:	e59f0124 	ldr	r0, [pc, #124]	; 3f03844 <main_loop+0x434>
 3f0371c:	e1a01004 	mov	r1, r4
 3f03720:	eb002447 	bl	3f0c844 <printf>
 3f03724:	e1540006 	cmp	r4, r6
 3f03728:	da000018 	ble	3f03790 <main_loop+0x380>
 3f0372c:	e2444001 	sub	r4, r4, #1	; 0x1
 3f03730:	e3a05000 	mov	r5, #0	; 0x0
 3f03734:	ea000002 	b	3f03744 <main_loop+0x334>
 3f03738:	e59f0108 	ldr	r0, [pc, #108]	; 3f03848 <main_loop+0x438>
 3f0373c:	e2855001 	add	r5, r5, #1	; 0x1
 3f03740:	ebfff434 	bl	3f00818 <udelay>
 3f03744:	e3550063 	cmp	r5, #99	; 0x63
 3f03748:	d2263001 	eorle	r3, r6, #1	; 0x1
 3f0374c:	c3a03000 	movgt	r3, #0	; 0x0
 3f03750:	e3530000 	cmp	r3, #0	; 0x0
 3f03754:	0a000005 	beq	3f03770 <main_loop+0x360>
 3f03758:	eb002414 	bl	3f0c7b0 <tstc>
 3f0375c:	e3500000 	cmp	r0, #0	; 0x0
 3f03760:	0afffff4 	beq	3f03738 <main_loop+0x328>
 3f03764:	e3a06001 	mov	r6, #1	; 0x1
 3f03768:	e3a04000 	mov	r4, #0	; 0x0
 3f0376c:	eb002404 	bl	3f0c784 <getc>
 3f03770:	e59f00d4 	ldr	r0, [pc, #d4]	; 3f0384c <main_loop+0x43c>
 3f03774:	e1a01004 	mov	r1, r4
 3f03778:	eb002431 	bl	3f0c844 <printf>
 3f0377c:	e3540000 	cmp	r4, #0	; 0x0
 3f03780:	c2263001 	eorgt	r3, r6, #1	; 0x1
 3f03784:	d3a03000 	movle	r3, #0	; 0x0
 3f03788:	e3530000 	cmp	r3, #0	; 0x0
 3f0378c:	1affffe6 	bne	3f0372c <main_loop+0x31c>
 3f03790:	e3a0000a 	mov	r0, #10	; 0xa
 3f03794:	eb002410 	bl	3f0c7dc <putc>
 3f03798:	e3560000 	cmp	r6, #0	; 0x0
 3f0379c:	1a000002 	bne	3f037ac <main_loop+0x39c>
	{
# ifdef CONFIG_AUTOBOOT_KEYED
		int prev = disable_ctrlc(1);	/* disable Control C checking */
# endif

		// ⼭ bootcmd ȴ.
# ifndef CFG_HUSH_PARSER
		run_command (s, 0);
 3f037a0:	e1a00007 	mov	r0, r7
 3f037a4:	e1a01006 	mov	r1, r6
 3f037a8:	eb000197 	bl	3f03e0c <run_command>
# else
		parse_string_outer(s, FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP);
# endif

# ifdef CONFIG_AUTOBOOT_KEYED
		disable_ctrlc(prev);	/* restore Control C checking */
# endif
	}

# ifdef CONFIG_MENUKEY
	if (menukey == CONFIG_MENUKEY) 
	{
	    s = getenv("menucmd");
	    if (s) 
	    {
# ifndef CFG_HUSH_PARSER
		run_command (s, bd, 0);
# else
		parse_string_outer(s, FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP);
# endif
	    }
	}
#endif /* CONFIG_MENUKEY */
#endif	/* CONFIG_BOOTDELAY */

#ifdef CONFIG_AMIGAONEG3SE
	{
	    extern void video_banner(void);
	    video_banner();
	}
#endif

	/*
	 * Main Loop for Monitor Command Processing
	 */
#ifdef CFG_HUSH_PARSER
	parse_file_outer();
	/* This point is never reached */
	for (;;);
#else
	for (;;) {
#ifdef CONFIG_BOOT_RETRY_TIME
		if (rc >= 0) {
			/* Saw enough of a valid command to
			 * restart the timeout.
			 */
			reset_cmd_timeout();
		}
#endif
		// ⼭ Ŀǵ带 Է ޴´.
		len = readline (CFG_PROMPT);
 3f037ac:	e59f009c 	ldr	r0, [pc, #9c]	; 3f03850 <main_loop+0x440>

		flag = 0;	/* assume no special flags for now */
 3f037b0:	e3a04000 	mov	r4, #0	; 0x0
 3f037b4:	eb000035 	bl	3f03890 <readline>
		if (len > 0)
 3f037b8:	e2505000 	subs	r5, r0, #0	; 0x0
 3f037bc:	da000003 	ble	3f037d0 <main_loop+0x3c0>
			strcpy (lastcommand, console_buffer);
 3f037c0:	e59f008c 	ldr	r0, [pc, #8c]	; 3f03854 <main_loop+0x444>
 3f037c4:	e59f108c 	ldr	r1, [pc, #8c]	; 3f03858 <main_loop+0x448>
 3f037c8:	eb002e3e 	bl	3f0f0c8 <strcpy>
 3f037cc:	ea000001 	b	3f037d8 <main_loop+0x3c8>
		else if (len == 0)
 3f037d0:	03844001 	orreq	r4, r4, #1	; 0x1
 3f037d4:	13a04000 	movne	r4, #0	; 0x0
			flag |= CMD_FLAG_REPEAT;
#ifdef CONFIG_BOOT_RETRY_TIME
		else if (len == -2) {
			/* -2 means timed out, retry autoboot
			 */
			printf("\nTimed out waiting for command\n");
# ifdef CONFIG_RESET_TO_RETRY
			/* Reinit board to run initialization code again */
			do_reset (NULL, 0, 0, NULL);
# else
			return;		/* retry autoboot */
# endif
		}
#endif

		if (len == -1)
 3f037d8:	e3750001 	cmn	r5, #1	; 0x1
 3f037dc:	1a00001f 	bne	3f03860 <main_loop+0x450>
			printf ("<INTERRUPT>\n");
 3f037e0:	e59f0074 	ldr	r0, [pc, #74]	; 3f0385c <main_loop+0x44c>
 3f037e4:	eb002416 	bl	3f0c844 <printf>
 3f037e8:	ea000020 	b	3f03870 <main_loop+0x460>
 3f037ec:	03f1b0ac 	mvneqs	r11, #172	; 0xac
 3f037f0:	03f1b0b8 	mvneqs	r11, #184	; 0xb8
 3f037f4:	03f21184 	mvneqs	r1, #33	; 0x21
 3f037f8:	03f1b0ec 	mvneqs	r11, #236	; 0xec
 3f037fc:	03f1b110 	mvneqs	r11, #4	; 0x4
 3f03800:	03f1b134 	mvneqs	r11, #13	; 0xd
 3f03804:	03f1b148 	mvneqs	r11, #18	; 0x12
 3f03808:	03f1b154 	mvneqs	r11, #21	; 0x15
 3f0380c:	03f204d8 	mvneqs	r0, #-671088640	; 0xd8000000
 3f03810:	03f1b180 	mvneqs	r11, #32	; 0x20
 3f03814:	03f1b194 	mvneqs	r11, #37	; 0x25
 3f03818:	03f1b1b4 	mvneqs	r11, #45	; 0x2d
 3f0381c:	03f1b1cc 	mvneqs	r11, #51	; 0x33
 3f03820:	03f1b1f8 	mvneqs	r11, #62	; 0x3e
 3f03824:	03f1b20c 	mvneqs	r11, #-1073741824	; 0xc0000000
 3f03828:	03f1b22c 	mvneqs	r11, #-1073741822	; 0xc0000002
 3f0382c:	03f1b248 	mvneqs	r11, #-2147483644	; 0x80000004
 3f03830:	03f1b274 	mvneqs	r11, #1073741831	; 0x40000007
 3f03834:	03f1b288 	mvneqs	r11, #-2147483640	; 0x80000008
 3f03838:	03f1b2a8 	mvneqs	r11, #-2147483638	; 0x8000000a
 3f0383c:	03f1b2e0 	mvneqs	r11, #14	; 0xe
 3f03840:	03f1b2c0 	mvneqs	r11, #12	; 0xc
 3f03844:	03f1b080 	mvneqs	r11, #128	; 0x80
 3f03848:	00002710 	andeq	r2, r0, r0, lsl r7
 3f0384c:	03f1b0a4 	mvneqs	r11, #164	; 0xa4
 3f03850:	03f1b2ec 	mvneqs	r11, #-1073741810	; 0xc000000e
 3f03854:	03f204dc 	mvneqs	r0, #-603979776	; 0xdc000000
 3f03858:	03f6cc04 	mvneqs	r12, #1024	; 0x400
 3f0385c:	03f1b2f4 	mvneqs	r11, #1073741839	; 0x4000000f
		else
			rc = run_command (lastcommand, flag);
 3f03860:	e59f0020 	ldr	r0, [pc, #20]	; 3f03888 <main_loop+0x478>
 3f03864:	e1a01004 	mov	r1, r4
 3f03868:	eb000167 	bl	3f03e0c <run_command>
 3f0386c:	e50b0064 	str	r0, [r11, -#100]

		if (rc <= 0) {
 3f03870:	e51b3064 	ldr	r3, [r11, -#100]
 3f03874:	e3530000 	cmp	r3, #0	; 0x0
			/* invalid command or not repeatable, forget it */
			lastcommand[0] = 0;
 3f03878:	d59f2008 	ldrle	r2, [pc, #8]	; 3f03888 <main_loop+0x478>
 3f0387c:	d3a03000 	movle	r3, #0	; 0x0
 3f03880:	d5c23000 	strleb	r3, [r2]
 3f03884:	eaffffc8 	b	3f037ac <main_loop+0x39c>
 3f03888:	03f204dc 	mvneqs	r0, #-603979776	; 0xdc000000
		}
	}
#endif /*CFG_HUSH_PARSER*/
}
 3f0388c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f03890 <readline>:
 3f03890:	e1a0c00d 	mov	r12, r13
 3f03894:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f03898:	e24cb004 	sub	r11, r12, #4	; 0x4

#ifdef CONFIG_BOOT_RETRY_TIME
/***************************************************************************
 * initialise command line timeout
 */
void init_cmd_timeout(void)
{
	char *s = getenv ("bootretry");

	if (s != NULL)
		retry_time = (int)simple_strtoul(s, NULL, 10);
	else
		retry_time =  CONFIG_BOOT_RETRY_TIME;

	if (retry_time >= 0 && retry_time < CONFIG_BOOT_RETRY_MIN)
		retry_time = CONFIG_BOOT_RETRY_MIN;
}

/***************************************************************************
 * reset command line timeout to retry_time seconds
 */
void reset_cmd_timeout(void)
{
	endtime = endtick(retry_time);
}
#endif

/****************************************************************************/

/*
 * Prompt for input and read a line.
 * If  CONFIG_BOOT_RETRY_TIME is defined and retry_time >= 0,
 * time out when time goes past endtime (timebase time in ticks).
 * Return:	number of read characters
 *		-1 if break
 *		-2 if timed out
 */
int readline (const char *const prompt)
{
	char   *p = console_buffer;
	int	n = 0;				/* buffer index		*/
 3f0389c:	e3a03000 	mov	r3, #0	; 0x0
	int	plen = 0;			/* prompt length	*/
 3f038a0:	e1a06003 	mov	r6, r3
	int	col;				/* output column cnt	*/
	char	c;

	/* print prompt */
	if (prompt) {
 3f038a4:	e2504000 	subs	r4, r0, #0	; 0x0
 3f038a8:	e59f71f0 	ldr	r7, [pc, #1f0]	; 3f03aa0 <readline+0x210>
 3f038ac:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f038b0:	e50b3028 	str	r3, [r11, -#40]
 3f038b4:	0a000004 	beq	3f038cc <readline+0x3c>
		plen = strlen (prompt);
 3f038b8:	e1a00004 	mov	r0, r4
 3f038bc:	eb002e81 	bl	3f0f2c8 <strlen>
 3f038c0:	e1a06000 	mov	r6, r0
		puts (prompt);
 3f038c4:	e1a00004 	mov	r0, r4
 3f038c8:	eb0023d0 	bl	3f0c810 <puts>
	}
	col = plen;
 3f038cc:	e50b6024 	str	r6, [r11, -#36]

	for (;;) {
#ifdef CONFIG_BOOT_RETRY_TIME
		while (!tstc()) {	/* while no incoming data */
			if (retry_time >= 0 && get_ticks() > endtime)
				return (-2);	/* timed out */
		}
#endif
		WATCHDOG_RESET();		/* Trigger watchdog, if needed */

#ifdef CONFIG_SHOW_ACTIVITY
		while (!tstc()) {
			extern void show_activity(int arg);
			show_activity(0);
		}
#endif
		c = getc();
 3f038d0:	eb0023ab 	bl	3f0c784 <getc>
 3f038d4:	e20040ff 	and	r4, r0, #255	; 0xff

		/*
		 * Special character handling
		 */
		switch (c) {
 3f038d8:	e354000d 	cmp	r4, #13	; 0xd
 3f038dc:	0a000012 	beq	3f0392c <readline+0x9c>
 3f038e0:	ca000008 	bgt	3f03908 <readline+0x78>
 3f038e4:	e3540008 	cmp	r4, #8	; 0x8
 3f038e8:	0a000047 	beq	3f03a0c <readline+0x17c>
 3f038ec:	ca000002 	bgt	3f038fc <readline+0x6c>
 3f038f0:	e3540003 	cmp	r4, #3	; 0x3
 3f038f4:	0a000013 	beq	3f03948 <readline+0xb8>
 3f038f8:	ea00004b 	b	3f03a2c <readline+0x19c>
 3f038fc:	e354000a 	cmp	r4, #10	; 0xa
 3f03900:	0a000009 	beq	3f0392c <readline+0x9c>
 3f03904:	ea000048 	b	3f03a2c <readline+0x19c>
 3f03908:	e3540017 	cmp	r4, #23	; 0x17
 3f0390c:	0a000020 	beq	3f03994 <readline+0x104>
 3f03910:	ca000002 	bgt	3f03920 <readline+0x90>
 3f03914:	e3540015 	cmp	r4, #21	; 0x15
 3f03918:	0a00000f 	beq	3f0395c <readline+0xcc>
 3f0391c:	ea000042 	b	3f03a2c <readline+0x19c>
 3f03920:	e354007f 	cmp	r4, #127	; 0x7f
 3f03924:	0a000038 	beq	3f03a0c <readline+0x17c>
 3f03928:	ea00003f 	b	3f03a2c <readline+0x19c>
		case '\r':				/* Enter		*/
		case '\n':
			*p = '\0';
			puts ("\r\n");
 3f0392c:	e59f0170 	ldr	r0, [pc, #170]	; 3f03aa4 <readline+0x214>
 3f03930:	e3a03000 	mov	r3, #0	; 0x0
 3f03934:	e5c73000 	strb	r3, [r7]
 3f03938:	eb0023b4 	bl	3f0c810 <puts>
			return (p - console_buffer);
 3f0393c:	e59f015c 	ldr	r0, [pc, #15c]	; 3f03aa0 <readline+0x210>
 3f03940:	e0600007 	rsb	r0, r0, r7
 3f03944:	ea000059 	b	3f03ab0 <readline+0x220>

		case 0x03:				/* ^C - break		*/
			console_buffer[0] = '\0';	/* discard input */
			return (-1);
 3f03948:	e3e00000 	mvn	r0, #0	; 0x0
 3f0394c:	e59f214c 	ldr	r2, [pc, #14c]	; 3f03aa0 <readline+0x210>
 3f03950:	e3a03000 	mov	r3, #0	; 0x0
 3f03954:	e5c23000 	strb	r3, [r2]
 3f03958:	ea000054 	b	3f03ab0 <readline+0x220>

		case 0x15:				/* ^U - erase line	*/
			while (col > plen) {
 3f0395c:	e51b3024 	ldr	r3, [r11, -#36]
 3f03960:	e1530006 	cmp	r3, r6
 3f03964:	da000006 	ble	3f03984 <readline+0xf4>
				puts (erase_seq);
 3f03968:	e59f0138 	ldr	r0, [pc, #138]	; 3f03aa8 <readline+0x218>
 3f0396c:	eb0023a7 	bl	3f0c810 <puts>
				--col;
 3f03970:	e51b3024 	ldr	r3, [r11, -#36]
 3f03974:	e2433001 	sub	r3, r3, #1	; 0x1
			}
 3f03978:	e1530006 	cmp	r3, r6
 3f0397c:	e50b3024 	str	r3, [r11, -#36]
 3f03980:	cafffff8 	bgt	3f03968 <readline+0xd8>
			p = console_buffer;
 3f03984:	e59f7114 	ldr	r7, [pc, #114]	; 3f03aa0 <readline+0x210>
			n = 0;
 3f03988:	e3a03000 	mov	r3, #0	; 0x0
 3f0398c:	e50b3028 	str	r3, [r11, -#40]
			continue;
 3f03990:	eaffffce 	b	3f038d0 <readline+0x40>

		case 0x17:				/* ^W - erase word 	*/
			p=delete_char(console_buffer, p, &col, &n, plen);
 3f03994:	e1a01007 	mov	r1, r7
 3f03998:	e24b5024 	sub	r5, r11, #36	; 0x24
 3f0399c:	e1a02005 	mov	r2, r5
 3f039a0:	e24b4028 	sub	r4, r11, #40	; 0x28
 3f039a4:	e59fa0f4 	ldr	r10, [pc, #f4]	; 3f03aa0 <readline+0x210>
 3f039a8:	e1a03004 	mov	r3, r4
 3f039ac:	e58d6000 	str	r6, [r13]
 3f039b0:	e1a0000a 	mov	r0, r10
 3f039b4:	eb00003e 	bl	3f03ab4 <delete_char>
			while ((n > 0) && (*p != ' ')) {
 3f039b8:	e51b3028 	ldr	r3, [r11, -#40]
 3f039bc:	e1a07000 	mov	r7, r0
 3f039c0:	e3530000 	cmp	r3, #0	; 0x0
 3f039c4:	daffffc1 	ble	3f038d0 <readline+0x40>
 3f039c8:	e5d73000 	ldrb	r3, [r7]
 3f039cc:	e3530020 	cmp	r3, #32	; 0x20
 3f039d0:	0affffbe 	beq	3f038d0 <readline+0x40>
				p=delete_char(console_buffer, p, &col, &n, plen);
 3f039d4:	e1a0000a 	mov	r0, r10
 3f039d8:	e1a01007 	mov	r1, r7
 3f039dc:	e1a02005 	mov	r2, r5
 3f039e0:	e1a03004 	mov	r3, r4
 3f039e4:	e58d6000 	str	r6, [r13]
 3f039e8:	eb000031 	bl	3f03ab4 <delete_char>
			}
 3f039ec:	e51b3028 	ldr	r3, [r11, -#40]
 3f039f0:	e1a07000 	mov	r7, r0
 3f039f4:	e3530000 	cmp	r3, #0	; 0x0
 3f039f8:	daffffb4 	ble	3f038d0 <readline+0x40>
 3f039fc:	e5d73000 	ldrb	r3, [r7]
 3f03a00:	e3530020 	cmp	r3, #32	; 0x20
 3f03a04:	1afffff2 	bne	3f039d4 <readline+0x144>
			continue;
 3f03a08:	eaffffb0 	b	3f038d0 <readline+0x40>

		case 0x08:				/* ^H  - backspace	*/
		case 0x7F:				/* DEL - backspace	*/
			p=delete_char(console_buffer, p, &col, &n, plen);
 3f03a0c:	e1a01007 	mov	r1, r7
 3f03a10:	e24b2024 	sub	r2, r11, #36	; 0x24
 3f03a14:	e59f0084 	ldr	r0, [pc, #84]	; 3f03aa0 <readline+0x210>
 3f03a18:	e24b3028 	sub	r3, r11, #40	; 0x28
 3f03a1c:	e58d6000 	str	r6, [r13]
 3f03a20:	eb000023 	bl	3f03ab4 <delete_char>
 3f03a24:	e1a07000 	mov	r7, r0
			continue;
 3f03a28:	eaffffa8 	b	3f038d0 <readline+0x40>

		default:
			/*
			 * Must be a normal character then
			 */
			if (n < CFG_CBSIZE-2) {
 3f03a2c:	e51b3028 	ldr	r3, [r11, -#40]
 3f03a30:	e35300fd 	cmp	r3, #253	; 0xfd
 3f03a34:	ca000016 	bgt	3f03a94 <readline+0x204>
				if (c == '\t') {	/* expand TABs		*/
 3f03a38:	e3540009 	cmp	r4, #9	; 0x9
 3f03a3c:	1a00000a 	bne	3f03a6c <readline+0x1dc>
					puts (tab_seq+(col&07));
 3f03a40:	e51b0024 	ldr	r0, [r11, -#36]
 3f03a44:	e59f3060 	ldr	r3, [pc, #60]	; 3f03aac <readline+0x21c>
 3f03a48:	e2000007 	and	r0, r0, #7	; 0x7
 3f03a4c:	e0800003 	add	r0, r0, r3
 3f03a50:	eb00236e 	bl	3f0c810 <puts>
					col += 8 - (col&07);
 3f03a54:	e51b3024 	ldr	r3, [r11, -#36]
 3f03a58:	e2832008 	add	r2, r3, #8	; 0x8
 3f03a5c:	e2033007 	and	r3, r3, #7	; 0x7
 3f03a60:	e0632002 	rsb	r2, r3, r2
 3f03a64:	e50b2024 	str	r2, [r11, -#36]
				} else {
 3f03a68:	ea000004 	b	3f03a80 <readline+0x1f0>
					++col;		/* echo input		*/
 3f03a6c:	e51b3024 	ldr	r3, [r11, -#36]
					putc (c);
 3f03a70:	e1a00004 	mov	r0, r4
 3f03a74:	e2833001 	add	r3, r3, #1	; 0x1
 3f03a78:	e50b3024 	str	r3, [r11, -#36]
 3f03a7c:	eb002356 	bl	3f0c7dc <putc>
				}
				*p++ = c;
 3f03a80:	e4c74001 	strb	r4, [r7], #1
				++n;
 3f03a84:	e51b3028 	ldr	r3, [r11, -#40]
 3f03a88:	e2833001 	add	r3, r3, #1	; 0x1
 3f03a8c:	e50b3028 	str	r3, [r11, -#40]
			} else {			/* Buffer full		*/
 3f03a90:	eaffff8e 	b	3f038d0 <readline+0x40>
				putc ('\a');
 3f03a94:	e3a00007 	mov	r0, #7	; 0x7
 3f03a98:	eb00234f 	bl	3f0c7dc <putc>
 3f03a9c:	eaffff8b 	b	3f038d0 <readline+0x40>
 3f03aa0:	03f6cc04 	mvneqs	r12, #1024	; 0x400
 3f03aa4:	03f1b304 	mvneqs	r11, #268435456	; 0x10000000
 3f03aa8:	03f204c8 	mvneqs	r0, #-939524096	; 0xc8000000
 3f03aac:	03f204cc 	mvneqs	r0, #-872415232	; 0xcc000000
			}
		}
	}
}
 3f03ab0:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f03ab4 <delete_char>:
 3f03ab4:	e1a0c00d 	mov	r12, r13
 3f03ab8:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f03abc:	e24cb004 	sub	r11, r12, #4	; 0x4

/****************************************************************************/

static char * delete_char (char *buffer, char *p, int *colp, int *np, int plen)
{
 3f03ac0:	e1a07003 	mov	r7, r3
 3f03ac4:	e1a06001 	mov	r6, r1
 3f03ac8:	e1a05000 	mov	r5, r0
	char *s;

	if (*np == 0) {
 3f03acc:	e5973000 	ldr	r3, [r7]
 3f03ad0:	e1a04002 	mov	r4, r2
 3f03ad4:	e59ba004 	ldr	r10, [r11, #4]
 3f03ad8:	e3530000 	cmp	r3, #0	; 0x0
		return (p);
 3f03adc:	01a00006 	moveq	r0, r6
 3f03ae0:	091bacf0 	ldmeqdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
	}

	if (*(--p) == '\t') {			/* will retype the whole line	*/
 3f03ae4:	e5763001 	ldrb	r3, [r6, -#1]!
 3f03ae8:	e3530009 	cmp	r3, #9	; 0x9
 3f03aec:	1a000022 	bne	3f03b7c <delete_char+0xc8>
		while (*colp > plen) {
 3f03af0:	e5943000 	ldr	r3, [r4]
 3f03af4:	e153000a 	cmp	r3, r10
 3f03af8:	da000006 	ble	3f03b18 <delete_char+0x64>
			puts (erase_seq);
 3f03afc:	e59f00a0 	ldr	r0, [pc, #a0]	; 3f03ba4 <delete_char+0xf0>
 3f03b00:	eb002342 	bl	3f0c810 <puts>
			(*colp)--;
 3f03b04:	e5943000 	ldr	r3, [r4]
 3f03b08:	e2433001 	sub	r3, r3, #1	; 0x1
		}
 3f03b0c:	e153000a 	cmp	r3, r10
 3f03b10:	e5843000 	str	r3, [r4]
 3f03b14:	cafffff8 	bgt	3f03afc <delete_char+0x48>
		for (s=buffer; s<p; ++s) {
 3f03b18:	e1550006 	cmp	r5, r6
 3f03b1c:	2a00001b 	bcs	3f03b90 <delete_char+0xdc>
			if (*s == '\t') {
 3f03b20:	e5d53000 	ldrb	r3, [r5]
 3f03b24:	e3530009 	cmp	r3, #9	; 0x9
 3f03b28:	1a00000a 	bne	3f03b58 <delete_char+0xa4>
				puts (tab_seq+((*colp) & 07));
 3f03b2c:	e5940000 	ldr	r0, [r4]
 3f03b30:	e59f3070 	ldr	r3, [pc, #70]	; 3f03ba8 <delete_char+0xf4>
 3f03b34:	e2000007 	and	r0, r0, #7	; 0x7
 3f03b38:	e0800003 	add	r0, r0, r3
 3f03b3c:	eb002333 	bl	3f0c810 <puts>
				*colp += 8 - ((*colp) & 07);
 3f03b40:	e5943000 	ldr	r3, [r4]
 3f03b44:	e2832008 	add	r2, r3, #8	; 0x8
 3f03b48:	e2033007 	and	r3, r3, #7	; 0x7
 3f03b4c:	e0632002 	rsb	r2, r3, r2
 3f03b50:	e5842000 	str	r2, [r4]
			} else {
 3f03b54:	ea000004 	b	3f03b6c <delete_char+0xb8>
				++(*colp);
 3f03b58:	e5943000 	ldr	r3, [r4]
 3f03b5c:	e2833001 	add	r3, r3, #1	; 0x1
 3f03b60:	e5843000 	str	r3, [r4]
				putc (*s);
 3f03b64:	e5d50000 	ldrb	r0, [r5]
 3f03b68:	eb00231b 	bl	3f0c7dc <putc>
 3f03b6c:	e2855001 	add	r5, r5, #1	; 0x1
 3f03b70:	e1550006 	cmp	r5, r6
 3f03b74:	3affffe9 	bcc	3f03b20 <delete_char+0x6c>
			}
		}
	} else {
 3f03b78:	ea000004 	b	3f03b90 <delete_char+0xdc>
		puts (erase_seq);
 3f03b7c:	e59f0020 	ldr	r0, [pc, #20]	; 3f03ba4 <delete_char+0xf0>
 3f03b80:	eb002322 	bl	3f0c810 <puts>
		(*colp)--;
 3f03b84:	e5943000 	ldr	r3, [r4]
 3f03b88:	e2433001 	sub	r3, r3, #1	; 0x1
 3f03b8c:	e5843000 	str	r3, [r4]
	}
	(*np)--;
 3f03b90:	e5973000 	ldr	r3, [r7]
	return (p);
 3f03b94:	e1a00006 	mov	r0, r6
 3f03b98:	e2433001 	sub	r3, r3, #1	; 0x1
 3f03b9c:	e5873000 	str	r3, [r7]
}
 3f03ba0:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f03ba4:	03f204c8 	mvneqs	r0, #-939524096	; 0xc8000000
 3f03ba8:	03f204cc 	mvneqs	r0, #-872415232	; 0xcc000000

03f03bac <parse_line>:
 3f03bac:	e1a0c00d 	mov	r12, r13
 3f03bb0:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f03bb4:	e24cb004 	sub	r11, r12, #4	; 0x4

/****************************************************************************/

int parse_line (char *line, char *argv[])
{
	int nargs = 0;
 3f03bb8:	e3a04000 	mov	r4, #0	; 0x0

#ifdef DEBUG_PARSER
	printf ("parse_line: \"%s\"\n", line);
#endif
	while (nargs < CFG_MAXARGS) {

		/* skip any white space */
		while ((*line == ' ') || (*line == '\t')) {
 3f03bbc:	e5d03000 	ldrb	r3, [r0]
 3f03bc0:	e3530009 	cmp	r3, #9	; 0x9
 3f03bc4:	13530020 	cmpne	r3, #32	; 0x20
 3f03bc8:	1a000003 	bne	3f03bdc <parse_line+0x30>
			++line;
		}
 3f03bcc:	e5f03001 	ldrb	r3, [r0, #1]!
 3f03bd0:	e3530009 	cmp	r3, #9	; 0x9
 3f03bd4:	13530020 	cmpne	r3, #32	; 0x20
 3f03bd8:	0afffffb 	beq	3f03bcc <parse_line+0x20>

		if (*line == '\0') {	/* end of line, no more args	*/
 3f03bdc:	e5d03000 	ldrb	r3, [r0]
 3f03be0:	e3530000 	cmp	r3, #0	; 0x0
 3f03be4:	1a000002 	bne	3f03bf4 <parse_line+0x48>
			argv[nargs] = NULL;
#ifdef DEBUG_PARSER
		printf ("parse_line: nargs=%d\n", nargs);
#endif
			return (nargs);
 3f03be8:	e1a00004 	mov	r0, r4
 3f03bec:	e7813104 	str	r3, [r1, r4, lsl #2]
 3f03bf0:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
		}

		argv[nargs++] = line;	/* begin of argument string	*/
 3f03bf4:	e7810104 	str	r0, [r1, r4, lsl #2]

		/* find end of string */
		while (*line && (*line != ' ') && (*line != '\t')) {
 3f03bf8:	e5d03000 	ldrb	r3, [r0]
 3f03bfc:	e2844001 	add	r4, r4, #1	; 0x1
 3f03c00:	ea000000 	b	3f03c08 <parse_line+0x5c>
			++line;
		}
 3f03c04:	e5f03001 	ldrb	r3, [r0, #1]!
 3f03c08:	e3530000 	cmp	r3, #0	; 0x0
 3f03c0c:	13530020 	cmpne	r3, #32	; 0x20
 3f03c10:	0a000001 	beq	3f03c1c <parse_line+0x70>
 3f03c14:	e3530009 	cmp	r3, #9	; 0x9
 3f03c18:	1afffff9 	bne	3f03c04 <parse_line+0x58>

		if (*line == '\0') {	/* end of line, no more args	*/
 3f03c1c:	e5d03000 	ldrb	r3, [r0]
 3f03c20:	e3530000 	cmp	r3, #0	; 0x0
 3f03c24:	0affffef 	beq	3f03be8 <parse_line+0x3c>
			argv[nargs] = NULL;
#ifdef DEBUG_PARSER
		printf ("parse_line: nargs=%d\n", nargs);
#endif
			return (nargs);
		}

		*line++ = '\0';		/* terminate current arg	 */
	}
 3f03c28:	e354000f 	cmp	r4, #15	; 0xf
 3f03c2c:	e3a03000 	mov	r3, #0	; 0x0
 3f03c30:	e4c03001 	strb	r3, [r0], #1
 3f03c34:	daffffe0 	ble	3f03bbc <parse_line+0x10>

	printf ("** Too many args (max. %d) **\n", CFG_MAXARGS);
 3f03c38:	e59f000c 	ldr	r0, [pc, #c]	; 3f03c4c <parse_line+0xa0>
 3f03c3c:	e3a01010 	mov	r1, #16	; 0x10
 3f03c40:	eb0022ff 	bl	3f0c844 <printf>

#ifdef DEBUG_PARSER
	printf ("parse_line: nargs=%d\n", nargs);
#endif
	return (nargs);
 3f03c44:	e1a00004 	mov	r0, r4
}
 3f03c48:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f03c4c:	03f1b308 	mvneqs	r11, #536870912	; 0x20000000

03f03c50 <process_macros>:
 3f03c50:	e1a0c00d 	mov	r12, r13
 3f03c54:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f03c58:	e24cb004 	sub	r11, r12, #4	; 0x4

/****************************************************************************/

static void process_macros (const char *input, char *output)
{
 3f03c5c:	e1a0a000 	mov	r10, r0
 3f03c60:	e1a07001 	mov	r7, r1
	char c, prev;
	const char *varname_start = NULL;
 3f03c64:	e3a09000 	mov	r9, #0	; 0x0
	int inputcnt  = strlen (input);
 3f03c68:	e24ddc01 	sub	r13, r13, #256	; 0x100
 3f03c6c:	eb002d95 	bl	3f0f2c8 <strlen>
 3f03c70:	e1a06000 	mov	r6, r0
	int outputcnt = CFG_CBSIZE;
 3f03c74:	e3a05c01 	mov	r5, #256	; 0x100
	int state = 0;	/* 0 = waiting for '$'	*/
 3f03c78:	e1a02009 	mov	r2, r9
			/* 1 = waiting for '('	*/
			/* 2 = waiting for ')'	*/
			/* 3 = waiting for '''  */
#ifdef DEBUG_PARSER
	char *output_start = output;

	printf ("[PROCESS_MACROS] INPUT len %d: \"%s\"\n", strlen(input), input);
#endif

	prev = '\0';			/* previous character	*/
 3f03c7c:	e1a01002 	mov	r1, r2

	while (inputcnt && outputcnt) {
 3f03c80:	ea00004d 	b	3f03dbc <process_macros+0x16c>
	    c = *input++;
	    inputcnt--;

	    if (state!=3) {
	    /* remove one level of escape characters */
	    if ((c == '\\') && (prev != '\\')) {
		if (inputcnt-- == 0)
			break;
		prev = c;
 3f03c84:	e1a02004 	mov	r2, r4
		c = *input++;
 3f03c88:	e4da4001 	ldrb	r4, [r10], #1
	    }
	    }

	    switch (state) {
 3f03c8c:	e3510003 	cmp	r1, #3	; 0x3
 3f03c90:	979ff101 	ldrls	r15, [r15, r1, lsl #2]
 3f03c94:	ea000047 	b	3f03db8 <process_macros+0x168>
 3f03c98:	03f03ca8 	mvneqs	r3, #43008	; 0xa800
 3f03c9c:	03f03ce4 	mvneqs	r3, #58368	; 0xe400
 3f03ca0:	03f03d0c 	mvneqs	r3, #768	; 0x300
 3f03ca4:	03f03d90 	mvneqs	r3, #9216	; 0x2400
	    case 0:			/* Waiting for (unescaped) $	*/
		if ((c == '\'') && (prev != '\\')) {
 3f03ca8:	e252305c 	subs	r3, r2, #92	; 0x5c
 3f03cac:	13a03001 	movne	r3, #1	; 0x1
 3f03cb0:	e3540027 	cmp	r4, #39	; 0x27
 3f03cb4:	13a03000 	movne	r3, #0	; 0x0
 3f03cb8:	e3530000 	cmp	r3, #0	; 0x0
			state = 3;
 3f03cbc:	13a01003 	movne	r1, #3	; 0x3
			break;
 3f03cc0:	1a00003c 	bne	3f03db8 <process_macros+0x168>
		}
		if ((c == '$') && (prev != '\\')) {
 3f03cc4:	e252305c 	subs	r3, r2, #92	; 0x5c
 3f03cc8:	13a03001 	movne	r3, #1	; 0x1
 3f03ccc:	e3540024 	cmp	r4, #36	; 0x24
 3f03cd0:	13a03000 	movne	r3, #0	; 0x0
 3f03cd4:	e3530000 	cmp	r3, #0	; 0x0
 3f03cd8:	0a000034 	beq	3f03db0 <process_macros+0x160>
			state++;
 3f03cdc:	e2811001 	add	r1, r1, #1	; 0x1
		} else {
 3f03ce0:	ea000034 	b	3f03db8 <process_macros+0x168>
			*(output++) = c;
			outputcnt--;
		}
		break;
	    case 1:			/* Waiting for (	*/
		if (c == '(') {
 3f03ce4:	e3540028 	cmp	r4, #40	; 0x28
			state++;
 3f03ce8:	02811001 	addeq	r1, r1, #1	; 0x1
			varname_start = input;
 3f03cec:	01a0900a 	moveq	r9, r10
		} else {
 3f03cf0:	0a000030 	beq	3f03db8 <process_macros+0x168>
			state = 0;
 3f03cf4:	e3a01000 	mov	r1, #0	; 0x0
			*(output++) = '$';
			outputcnt--;

			if (outputcnt) {
 3f03cf8:	e2555001 	subs	r5, r5, #1	; 0x1
 3f03cfc:	e3a03024 	mov	r3, #36	; 0x24
 3f03d00:	e4c73001 	strb	r3, [r7], #1
 3f03d04:	0a00002b 	beq	3f03db8 <process_macros+0x168>
				*(output++) = c;
				outputcnt--;
			}
		}
		break;
 3f03d08:	ea000028 	b	3f03db0 <process_macros+0x160>
	    case 2:			/* Waiting for )	*/
		if (c == ')') {
 3f03d0c:	e3540029 	cmp	r4, #41	; 0x29
 3f03d10:	1a000028 	bne	3f03db8 <process_macros+0x168>
			int i;
			char envname[CFG_CBSIZE], *envval;
			int envcnt = input-varname_start-1; /* Varname # of chars */

			/* Get the varname */
			for (i = 0; i < envcnt; i++) {
 3f03d14:	e3a01000 	mov	r1, #0	; 0x0
 3f03d18:	e069300a 	rsb	r3, r9, r10
 3f03d1c:	e2430001 	sub	r0, r3, #1	; 0x1
 3f03d20:	e1510000 	cmp	r1, r0
 3f03d24:	aa000005 	bge	3f03d40 <process_macros+0xf0>
				envname[i] = varname_start[i];
 3f03d28:	e7d92001 	ldrb	r2, [r9, r1]
 3f03d2c:	e24b3f49 	sub	r3, r11, #292	; 0x124
 3f03d30:	e7c32001 	strb	r2, [r3, r1]
 3f03d34:	e2811001 	add	r1, r1, #1	; 0x1
 3f03d38:	e1510000 	cmp	r1, r0
 3f03d3c:	bafffff9 	blt	3f03d28 <process_macros+0xd8>
			}
			envname[i] = 0;
 3f03d40:	e24b2f49 	sub	r2, r11, #292	; 0x124

			/* Get its value */
			envval = getenv (envname);
 3f03d44:	e1a00002 	mov	r0, r2
 3f03d48:	e3a03000 	mov	r3, #0	; 0x0
 3f03d4c:	e7c23001 	strb	r3, [r2, r1]
 3f03d50:	eb0020c1 	bl	3f0c05c <getenv>

			/* Copy into the line if it exists */
			if (envval != NULL)
 3f03d54:	e3500000 	cmp	r0, #0	; 0x0
 3f03d58:	0a000012 	beq	3f03da8 <process_macros+0x158>
				while ((*envval) && outputcnt) {
 3f03d5c:	e5d02000 	ldrb	r2, [r0]
 3f03d60:	e3520000 	cmp	r2, #0	; 0x0
 3f03d64:	13550000 	cmpne	r5, #0	; 0x0
 3f03d68:	0a00000e 	beq	3f03da8 <process_macros+0x158>
					*(output++) = *(envval++);
 3f03d6c:	e4c72001 	strb	r2, [r7], #1
					outputcnt--;
				}
 3f03d70:	e2555001 	subs	r5, r5, #1	; 0x1
 3f03d74:	e5f02001 	ldrb	r2, [r0, #1]!
 3f03d78:	03a03000 	moveq	r3, #0	; 0x0
 3f03d7c:	13a03001 	movne	r3, #1	; 0x1
 3f03d80:	e3530000 	cmp	r3, #0	; 0x0
 3f03d84:	13520000 	cmpne	r2, #0	; 0x0
 3f03d88:	1afffff7 	bne	3f03d6c <process_macros+0x11c>
			/* Look for another '$' */
			state = 0;
		}
		break;
 3f03d8c:	ea000005 	b	3f03da8 <process_macros+0x158>
	    case 3:			/* Waiting for '	*/
		if ((c == '\'') && (prev != '\\')) {
 3f03d90:	e252305c 	subs	r3, r2, #92	; 0x5c
 3f03d94:	13a03001 	movne	r3, #1	; 0x1
 3f03d98:	e3540027 	cmp	r4, #39	; 0x27
 3f03d9c:	13a03000 	movne	r3, #0	; 0x0
 3f03da0:	e3530000 	cmp	r3, #0	; 0x0
 3f03da4:	0a000001 	beq	3f03db0 <process_macros+0x160>
			state = 0;
 3f03da8:	e3a01000 	mov	r1, #0	; 0x0
		} else {
 3f03dac:	ea000001 	b	3f03db8 <process_macros+0x168>
			*(output++) = c;
			outputcnt--;
 3f03db0:	e2455001 	sub	r5, r5, #1	; 0x1
 3f03db4:	e4c74001 	strb	r4, [r7], #1
		}
		break;
	    }
	    prev = c;
 3f03db8:	e1a02004 	mov	r2, r4
	}
 3f03dbc:	e3560000 	cmp	r6, #0	; 0x0
 3f03dc0:	13550000 	cmpne	r5, #0	; 0x0
 3f03dc4:	0a00000c 	beq	3f03dfc <process_macros+0x1ac>
 3f03dc8:	e2466001 	sub	r6, r6, #1	; 0x1
 3f03dcc:	e3510003 	cmp	r1, #3	; 0x3
 3f03dd0:	e4da4001 	ldrb	r4, [r10], #1
 3f03dd4:	0affffac 	beq	3f03c8c <process_macros+0x3c>
 3f03dd8:	e252305c 	subs	r3, r2, #92	; 0x5c
 3f03ddc:	13a03001 	movne	r3, #1	; 0x1
 3f03de0:	e354005c 	cmp	r4, #92	; 0x5c
 3f03de4:	13a03000 	movne	r3, #0	; 0x0
 3f03de8:	e3530000 	cmp	r3, #0	; 0x0
 3f03dec:	0affffa6 	beq	3f03c8c <process_macros+0x3c>
 3f03df0:	e2466001 	sub	r6, r6, #1	; 0x1
 3f03df4:	e3760001 	cmn	r6, #1	; 0x1
 3f03df8:	1affffa1 	bne	3f03c84 <process_macros+0x34>

	if (outputcnt)
 3f03dfc:	e3550000 	cmp	r5, #0	; 0x0
		*output = 0;
 3f03e00:	13a03000 	movne	r3, #0	; 0x0
 3f03e04:	15c73000 	strneb	r3, [r7]

#ifdef DEBUG_PARSER
	printf ("[PROCESS_MACROS] OUTPUT len %d: \"%s\"\n",
		strlen(output_start), output_start);
#endif
}
 3f03e08:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f03e0c <run_command>:
 3f03e0c:	e1a0c00d 	mov	r12, r13
 3f03e10:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f03e14:	e24cb004 	sub	r11, r12, #4	; 0x4

/****************************************************************************
 * returns:
 *	1  - command executed, repeatable
 *	0  - command executed but not repeatable, interrupted commands are
 *	     always considered not repeatable
 *	-1 - not executed (unrecognized, bootd recursion or too many args)
 *           (If cmd is NULL or "" or longer than CFG_CBSIZE-1 it is
 *           considered unrecognized)
 *
 * WARNING:
 *
 * We must create a temporary copy of the command since the command we get
 * may be the result from getenv(), which returns a pointer directly to
 * the environment data, which may change magicly when the command we run
 * creates or modifies environment variables (like "bootp" does).
 */

int run_command (const char *cmd, int flag)
{
 3f03e18:	e1a09001 	mov	r9, r1
	cmd_tbl_t *cmdtp;
	char cmdbuf[CFG_CBSIZE];	/* working copy of cmd		*/
	char *token;			/* start of token in cmdbuf	*/
	char *sep;			/* end of token (separator) in cmdbuf */
	char finaltoken[CFG_CBSIZE];
	char *str = cmdbuf;
 3f03e1c:	e24b5f49 	sub	r5, r11, #292	; 0x124
	char *argv[CFG_MAXARGS + 1];	/* NULL terminated	*/
	int argc, inquotes;
	int repeatable = 1;
 3f03e20:	e3a02001 	mov	r2, #1	; 0x1
	int rc = 0;
 3f03e24:	e3a0a000 	mov	r10, #0	; 0x0
 3f03e28:	e1a04000 	mov	r4, r0
 3f03e2c:	e24ddf92 	sub	r13, r13, #584	; 0x248
 3f03e30:	e50b226c 	str	r2, [r11, -#620]

#ifdef DEBUG_PARSER
	printf ("[RUN_COMMAND] cmd[%p]=\"", cmd);
	puts (cmd ? cmd : "NULL");	/* use puts - string may be loooong */
	puts ("\"\n");
#endif

	clear_ctrlc();		/* forget any previous Control C */
 3f03e34:	eb0022c4 	bl	3f0c94c <clear_ctrlc>

	if (!cmd || !*cmd) {
 3f03e38:	e154000a 	cmp	r4, r10
 3f03e3c:	0a000008 	beq	3f03e64 <run_command+0x58>
 3f03e40:	e5d43000 	ldrb	r3, [r4]
 3f03e44:	e153000a 	cmp	r3, r10
 3f03e48:	0a000005 	beq	3f03e64 <run_command+0x58>
		return -1;	/* empty command */
	}

	if (strlen(cmd) >= CFG_CBSIZE) {
 3f03e4c:	e1a00004 	mov	r0, r4
 3f03e50:	eb002d1c 	bl	3f0f2c8 <strlen>
 3f03e54:	e35000ff 	cmp	r0, #255	; 0xff
 3f03e58:	9a000005 	bls	3f03e74 <run_command+0x68>
		puts ("## Command too long!\n");
 3f03e5c:	e59f0128 	ldr	r0, [pc, #128]	; 3f03f8c <run_command+0x180>
 3f03e60:	eb00226a 	bl	3f0c810 <puts>
		return -1;
 3f03e64:	e3e00000 	mvn	r0, #0	; 0x0
 3f03e68:	ea000062 	b	3f03ff8 <run_command+0x1ec>
	}

	strcpy (cmdbuf, cmd);

	/* Process separators and check for invalid
	 * repeatable commands
	 */

#ifdef DEBUG_PARSER
	printf ("[PROCESS_SEPARATORS] %s\n", cmd);
#endif
	while (*str) {

		/*
		 * Find separator, or string end
		 * Allow simple escape of ';' by writing "\;"
		 */
		for (inquotes = 0, sep = str; *sep; sep++) {
			if ((*sep=='\'') &&
			    (*(sep-1) != '\\'))
				inquotes=!inquotes;

			if (!inquotes &&
			    (*sep == ';') &&	/* separator		*/
			    ( sep != str) &&	/* past string start	*/
			    (*(sep-1) != '\\'))	/* and NOT escaped	*/
				break;
		}

		/*
		 * Limit the token to data between separators
		 */
		token = str;
		if (*sep) {
			str = sep + 1;	/* start of command for next pass */
			*sep = '\0';
		}
		else
			str = sep;	/* no more commands for next pass */
#ifdef DEBUG_PARSER
		printf ("token: \"%s\"\n", token);
#endif

		/* find macros in this token and replace them */
		process_macros (token, finaltoken);

		/* Extract arguments */
		argc = parse_line (finaltoken, argv);

		/* Look up command in command table */
		if ((cmdtp = find_cmd(argv[0])) == NULL) {
			printf ("Unknown command '%s' - try 'help'\n", argv[0]);
			rc = -1;	/* give up after bad command */
			continue;
		}

		/* found - check max args */
		if (argc > cmdtp->maxargs) {
			printf ("Usage:\n%s\n", cmdtp->usage);
			rc = -1;
			continue;
		}

#if (CONFIG_COMMANDS & CFG_CMD_BOOTD)
		/* avoid "bootd" recursion */
		if (cmdtp->cmd == do_bootd) {
#ifdef DEBUG_PARSER
			printf ("[%s]\n", finaltoken);
#endif
			if (flag & CMD_FLAG_BOOTD) {
				printf ("'bootd' recursion detected\n");
				rc = -1;
				continue;
			}
			else
				flag |= CMD_FLAG_BOOTD;
		}
#endif	/* CFG_CMD_BOOTD */

		/* OK - call function to do the command */
		if ((cmdtp->cmd) (cmdtp, flag, argc, argv) != 0) {
			rc = -1;
		}

		repeatable &= cmdtp->repeatable;

		/* Did the user stop this? */
		if (had_ctrlc ())
			return 0;	/* if stopped then not repeatable */
 3f03e6c:	e3a00000 	mov	r0, #0	; 0x0
 3f03e70:	ea000060 	b	3f03ff8 <run_command+0x1ec>
 3f03e74:	e1a00005 	mov	r0, r5
 3f03e78:	e1a01004 	mov	r1, r4
 3f03e7c:	eb002c91 	bl	3f0f0c8 <strcpy>
 3f03e80:	e55b3124 	ldrb	r3, [r11, -#292]
 3f03e84:	e3530000 	cmp	r3, #0	; 0x0
 3f03e88:	0a000057 	beq	3f03fec <run_command+0x1e0>
 3f03e8c:	e3a00000 	mov	r0, #0	; 0x0
 3f03e90:	e5d53000 	ldrb	r3, [r5]
 3f03e94:	e1a02005 	mov	r2, r5
 3f03e98:	e1530000 	cmp	r3, r0
 3f03e9c:	0a000013 	beq	3f03ef0 <run_command+0xe4>
 3f03ea0:	e5d21000 	ldrb	r1, [r2]
 3f03ea4:	e3510027 	cmp	r1, #39	; 0x27
 3f03ea8:	1a000002 	bne	3f03eb8 <run_command+0xac>
 3f03eac:	e5523001 	ldrb	r3, [r2, -#1]
 3f03eb0:	e353005c 	cmp	r3, #92	; 0x5c
 3f03eb4:	12200001 	eorne	r0, r0, #1	; 0x1
 3f03eb8:	e3500000 	cmp	r0, #0	; 0x0
 3f03ebc:	1a000008 	bne	3f03ee4 <run_command+0xd8>
 3f03ec0:	e0523005 	subs	r3, r2, r5
 3f03ec4:	13a03001 	movne	r3, #1	; 0x1
 3f03ec8:	e351003b 	cmp	r1, #59	; 0x3b
 3f03ecc:	13a03000 	movne	r3, #0	; 0x0
 3f03ed0:	e3530000 	cmp	r3, #0	; 0x0
 3f03ed4:	0a000002 	beq	3f03ee4 <run_command+0xd8>
 3f03ed8:	e5523001 	ldrb	r3, [r2, -#1]
 3f03edc:	e353005c 	cmp	r3, #92	; 0x5c
 3f03ee0:	1a000002 	bne	3f03ef0 <run_command+0xe4>
 3f03ee4:	e5f23001 	ldrb	r3, [r2, #1]!
 3f03ee8:	e3530000 	cmp	r3, #0	; 0x0
 3f03eec:	1affffeb 	bne	3f03ea0 <run_command+0x94>
 3f03ef0:	e5d23000 	ldrb	r3, [r2]
 3f03ef4:	e1a00005 	mov	r0, r5
 3f03ef8:	e3530000 	cmp	r3, #0	; 0x0
 3f03efc:	12825001 	addne	r5, r2, #1	; 0x1
 3f03f00:	13a03000 	movne	r3, #0	; 0x0
 3f03f04:	15c23000 	strneb	r3, [r2]
 3f03f08:	01a05002 	moveq	r5, r2
 3f03f0c:	e24b4f89 	sub	r4, r11, #548	; 0x224
 3f03f10:	e1a01004 	mov	r1, r4
 3f03f14:	ebffff4d 	bl	3f03c50 <process_macros>
 3f03f18:	e1a00004 	mov	r0, r4
 3f03f1c:	e24b7f9a 	sub	r7, r11, #616	; 0x268
 3f03f20:	e1a01007 	mov	r1, r7
 3f03f24:	ebffff20 	bl	3f03bac <parse_line>
 3f03f28:	e1a06000 	mov	r6, r0
 3f03f2c:	e51b0268 	ldr	r0, [r11, -#616]
 3f03f30:	eb00216c 	bl	3f0c4e8 <find_cmd>
 3f03f34:	e2504000 	subs	r4, r0, #0	; 0x0
 3f03f38:	059f0050 	ldreq	r0, [pc, #50]	; 3f03f90 <run_command+0x184>
 3f03f3c:	051b1268 	ldreq	r1, [r11, -#616]
 3f03f40:	0a000004 	beq	3f03f58 <run_command+0x14c>
 3f03f44:	e5943004 	ldr	r3, [r4, #4]
 3f03f48:	e1560003 	cmp	r6, r3
 3f03f4c:	da000004 	ble	3f03f64 <run_command+0x158>
 3f03f50:	e59f003c 	ldr	r0, [pc, #3c]	; 3f03f94 <run_command+0x188>
 3f03f54:	e5941010 	ldr	r1, [r4, #16]
 3f03f58:	e3e0a000 	mvn	r10, #0	; 0x0
 3f03f5c:	eb002238 	bl	3f0c844 <printf>
 3f03f60:	ea00001e 	b	3f03fe0 <run_command+0x1d4>
 3f03f64:	e594c00c 	ldr	r12, [r4, #12]
 3f03f68:	e59f3028 	ldr	r3, [pc, #28]	; 3f03f98 <run_command+0x18c>
 3f03f6c:	e15c0003 	cmp	r12, r3
 3f03f70:	1a00000b 	bne	3f03fa4 <run_command+0x198>
 3f03f74:	e3190002 	tst	r9, #2	; 0x2
 3f03f78:	0a000008 	beq	3f03fa0 <run_command+0x194>
 3f03f7c:	e59f0018 	ldr	r0, [pc, #18]	; 3f03f9c <run_command+0x190>
 3f03f80:	e3e0a000 	mvn	r10, #0	; 0x0
 3f03f84:	eb00222e 	bl	3f0c844 <printf>
 3f03f88:	ea000014 	b	3f03fe0 <run_command+0x1d4>
 3f03f8c:	03f1b328 	mvneqs	r11, #-1610612736	; 0xa0000000
 3f03f90:	03f1b340 	mvneqs	r11, #1	; 0x1
 3f03f94:	03f1b364 	mvneqs	r11, #-1879048191	; 0x90000001
 3f03f98:	03f04b84 	mvneqs	r4, #135168	; 0x21000
 3f03f9c:	03f1b370 	mvneqs	r11, #-1073741823	; 0xc0000001
 3f03fa0:	e3899002 	orr	r9, r9, #2	; 0x2
 3f03fa4:	e1a00004 	mov	r0, r4
 3f03fa8:	e1a01009 	mov	r1, r9
 3f03fac:	e1a02006 	mov	r2, r6
 3f03fb0:	e1a03007 	mov	r3, r7
 3f03fb4:	e1a0e00f 	mov	r14, r15
 3f03fb8:	e1a0f00c 	mov	r15, r12
 3f03fbc:	e5943008 	ldr	r3, [r4, #8]
 3f03fc0:	e3500000 	cmp	r0, #0	; 0x0
 3f03fc4:	e51b226c 	ldr	r2, [r11, -#620]
 3f03fc8:	13e0a000 	mvnne	r10, #0	; 0x0
 3f03fcc:	e0022003 	and	r2, r2, r3
 3f03fd0:	e50b226c 	str	r2, [r11, -#620]
 3f03fd4:	eb002255 	bl	3f0c930 <had_ctrlc>
 3f03fd8:	e3500000 	cmp	r0, #0	; 0x0
 3f03fdc:	1affffa2 	bne	3f03e6c <run_command+0x60>
	}
 3f03fe0:	e5d53000 	ldrb	r3, [r5]
 3f03fe4:	e3530000 	cmp	r3, #0	; 0x0
 3f03fe8:	1affffa7 	bne	3f03e8c <run_command+0x80>

	return rc ? rc : repeatable;
 3f03fec:	e51b026c 	ldr	r0, [r11, -#620]
 3f03ff0:	e35a0000 	cmp	r10, #0	; 0x0
 3f03ff4:	11a0000a 	movne	r0, r10
}
 3f03ff8:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f03ffc <do_run>:
 3f03ffc:	e1a0c00d 	mov	r12, r13
 3f04000:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f04004:	e24cb004 	sub	r11, r12, #4	; 0x4

/****************************************************************************/

#if (CONFIG_COMMANDS & CFG_CMD_RUN)
int do_run (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
{
 3f04008:	e1a05002 	mov	r5, r2
	int i;

	if (argc < 2) {
 3f0400c:	e3550001 	cmp	r5, #1	; 0x1
 3f04010:	e1a02000 	mov	r2, r0
 3f04014:	e1a07001 	mov	r7, r1
 3f04018:	e1a06003 	mov	r6, r3
 3f0401c:	ca000007 	bgt	3f04040 <do_run+0x44>
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f04020:	e59f0058 	ldr	r0, [pc, #58]	; 3f04080 <do_run+0x84>
 3f04024:	e5921010 	ldr	r1, [r2, #16]
 3f04028:	eb002205 	bl	3f0c844 <printf>
		return 1;
 3f0402c:	e3a00001 	mov	r0, #1	; 0x1
 3f04030:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	}

	for (i=1; i<argc; ++i) {
		char *arg;

		if ((arg = getenv (argv[i])) == NULL) {
			printf ("## Error: \"%s\" not defined\n", argv[i]);
 3f04034:	e59f0048 	ldr	r0, [pc, #48]	; 3f04084 <do_run+0x88>
 3f04038:	e7961104 	ldr	r1, [r6, r4, lsl #2]
			return 1;
 3f0403c:	eafffff9 	b	3f04028 <do_run+0x2c>
 3f04040:	e3a04001 	mov	r4, #1	; 0x1
 3f04044:	e1540005 	cmp	r4, r5
 3f04048:	aa00000a 	bge	3f04078 <do_run+0x7c>
 3f0404c:	e7960104 	ldr	r0, [r6, r4, lsl #2]
 3f04050:	eb002001 	bl	3f0c05c <getenv>
 3f04054:	e3500000 	cmp	r0, #0	; 0x0
 3f04058:	0afffff5 	beq	3f04034 <do_run+0x38>
		}
#ifndef CFG_HUSH_PARSER
		if (run_command (arg, flag) == -1)
 3f0405c:	e1a01007 	mov	r1, r7
 3f04060:	ebffff69 	bl	3f03e0c <run_command>
 3f04064:	e3700001 	cmn	r0, #1	; 0x1
 3f04068:	0affffef 	beq	3f0402c <do_run+0x30>
 3f0406c:	e2844001 	add	r4, r4, #1	; 0x1
 3f04070:	e1540005 	cmp	r4, r5
 3f04074:	bafffff4 	blt	3f0404c <do_run+0x50>
			return 1;
#else
		if (parse_string_outer(arg,
		    FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP) != 0)
			return 1;
#endif
	}
	return 0;
 3f04078:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0407c:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f04080:	03f1b364 	mvneqs	r11, #-1879048191	; 0x90000001
 3f04084:	03f1b38c 	mvneqs	r11, #805306370	; 0x30000002

03f04088 <autoscript>:
 3f04088:	e1a0c00d 	mov	r12, r13
 3f0408c:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f04090:	e24cb004 	sub	r11, r12, #4	; 0x4
	ulong crc, data, len;
	image_header_t *hdr = &header;
	ulong *len_ptr;
	char *cmd;
	int rcode = 0;
 3f04094:	e3a09000 	mov	r9, #0	; 0x0
 3f04098:	e1a0a000 	mov	r10, r0
	int verify;

	cmd = getenv ("verify");
 3f0409c:	e59f01dc 	ldr	r0, [pc, #1dc]	; 3f04280 <autoscript+0x1f8>
	verify = (cmd && (*cmd == 'n')) ? 0 : 1;
 3f040a0:	e1a06009 	mov	r6, r9
 3f040a4:	eb001fec 	bl	3f0c05c <getenv>
 3f040a8:	e2505000 	subs	r5, r0, #0	; 0x0
 3f040ac:	e59f71d0 	ldr	r7, [pc, #1d0]	; 3f04284 <autoscript+0x1fc>
 3f040b0:	0a000002 	beq	3f040c0 <autoscript+0x38>
 3f040b4:	e5d53000 	ldrb	r3, [r5]
 3f040b8:	e353006e 	cmp	r3, #110	; 0x6e
 3f040bc:	0a000000 	beq	3f040c4 <autoscript+0x3c>
 3f040c0:	e3a06001 	mov	r6, #1	; 0x1


	memmove (hdr, (char *)addr, sizeof(image_header_t));
 3f040c4:	e1a00007 	mov	r0, r7
 3f040c8:	e1a0100a 	mov	r1, r10
 3f040cc:	e3a02040 	mov	r2, #64	; 0x40
 3f040d0:	eb002d39 	bl	3f0f5bc <memmove>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f040d4:	e5971000 	ldr	r1, [r7]

	if (ntohl(hdr->ih_magic) != IH_MAGIC) {
 3f040d8:	e3a05000 	mov	r5, #0	; 0x0
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f040dc:	e2013cff 	and	r3, r1, #65280	; 0xff00
 3f040e0:	e1a03403 	mov	r3, r3, lsl #8
 3f040e4:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f040e8:	e20128ff 	and	r2, r1, #16711680	; 0xff0000
 3f040ec:	e1833422 	orr	r3, r3, r2, lsr #8
 3f040f0:	e59f2190 	ldr	r2, [pc, #190]	; 3f04288 <autoscript+0x200>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f040f4:	e1833c21 	orr	r3, r3, r1, lsr #24
 3f040f8:	e1530002 	cmp	r3, r2
 3f040fc:	0a000003 	beq	3f04110 <autoscript+0x88>
		printf ("Bad magic number\n");
 3f04100:	e59f0184 	ldr	r0, [pc, #184]	; 3f0428c <autoscript+0x204>
 3f04104:	eb0021ce 	bl	3f0c844 <printf>
		return 1;
 3f04108:	e3a00001 	mov	r0, #1	; 0x1
 3f0410c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
	}

	crc = ntohl(hdr->ih_hcrc);
	hdr->ih_hcrc = 0;
 3f04110:	e1a03005 	mov	r3, r5
	len = sizeof (image_header_t);
	data = (ulong)hdr;
	if (crc32(0, (char *)data, len) != crc) {
 3f04114:	e1a00003 	mov	r0, r3
 3f04118:	e1a01007 	mov	r1, r7
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f0411c:	e597c004 	ldr	r12, [r7, #4]
 3f04120:	e3a02040 	mov	r2, #64	; 0x40
 3f04124:	e5873004 	str	r3, [r7, #4]
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04128:	e20c4cff 	and	r4, r12, #65280	; 0xff00
 3f0412c:	e1a04404 	mov	r4, r4, lsl #8
 3f04130:	e1844c0c 	orr	r4, r4, r12, lsl #24
 3f04134:	e20c38ff 	and	r3, r12, #16711680	; 0xff0000
 3f04138:	e1844423 	orr	r4, r4, r3, lsr #8
 3f0413c:	e1844c2c 	orr	r4, r4, r12, lsr #24
 3f04140:	eb002b4a 	bl	3f0ee70 <crc32>
 3f04144:	e1500004 	cmp	r0, r4
 3f04148:	0a000003 	beq	3f0415c <autoscript+0xd4>
		printf ("Bad header crc\n");
 3f0414c:	e59f013c 	ldr	r0, [pc, #13c]	; 3f04290 <autoscript+0x208>
 3f04150:	eb0021bb 	bl	3f0c844 <printf>
		return 1;
 3f04154:	e3a00001 	mov	r0, #1	; 0x1
 3f04158:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
	}

	data = addr + sizeof(image_header_t);
	len = ntohl(hdr->ih_size);

	if (verify) {
 3f0415c:	e3560000 	cmp	r6, #0	; 0x0
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04160:	e597300c 	ldr	r3, [r7, #12]
 3f04164:	e28a4040 	add	r4, r10, #64	; 0x40
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04168:	e2032cff 	and	r2, r3, #65280	; 0xff00
 3f0416c:	e1a02402 	mov	r2, r2, lsl #8
 3f04170:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f04174:	e20318ff 	and	r1, r3, #16711680	; 0xff0000
 3f04178:	e1822421 	orr	r2, r2, r1, lsr #8
 3f0417c:	e1826c23 	orr	r6, r2, r3, lsr #24
 3f04180:	0a00000d 	beq	3f041bc <autoscript+0x134>
		if (crc32(0, (char *)data, len) != ntohl(hdr->ih_dcrc)) {
 3f04184:	e1a00005 	mov	r0, r5
 3f04188:	e1a01004 	mov	r1, r4
 3f0418c:	e1a02006 	mov	r2, r6
 3f04190:	eb002b36 	bl	3f0ee70 <crc32>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04194:	e5973018 	ldr	r3, [r7, #24]
	return __arch__swab32(x);
 3f04198:	e2032cff 	and	r2, r3, #65280	; 0xff00
 3f0419c:	e1a02402 	mov	r2, r2, lsl #8
 3f041a0:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f041a4:	e20318ff 	and	r1, r3, #16711680	; 0xff0000
 3f041a8:	e1822421 	orr	r2, r2, r1, lsr #8
 3f041ac:	e1822c23 	orr	r2, r2, r3, lsr #24
 3f041b0:	e1500002 	cmp	r0, r2
			printf ("Bad data crc\n");
 3f041b4:	159f00d8 	ldrne	r0, [pc, #d8]	; 3f04294 <autoscript+0x20c>
			return 1;
 3f041b8:	1affffe4 	bne	3f04150 <autoscript+0xc8>
		}
	}

	if (hdr->ih_type != IH_TYPE_SCRIPT) {
 3f041bc:	e5d7301e 	ldrb	r3, [r7, #30]
 3f041c0:	e3530006 	cmp	r3, #6	; 0x6
		printf ("Bad image type\n");
 3f041c4:	159f00cc 	ldrne	r0, [pc, #cc]	; 3f04298 <autoscript+0x210>
		return 1;
 3f041c8:	1affffe0 	bne	3f04150 <autoscript+0xc8>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f041cc:	e5943000 	ldr	r3, [r4]
	return __arch__swab32(x);
 3f041d0:	e2032cff 	and	r2, r3, #65280	; 0xff00
 3f041d4:	e1a02402 	mov	r2, r2, lsl #8
 3f041d8:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f041dc:	e20318ff 	and	r1, r3, #16711680	; 0xff0000
 3f041e0:	e1822421 	orr	r2, r2, r1, lsr #8
	}

	/* get length of script */
	len_ptr = (ulong *)data;

	if ((len = ntohl(*len_ptr)) == 0) {
 3f041e4:	e1926c23 	orrs	r6, r2, r3, lsr #24
		printf ("Empty Script\n");
 3f041e8:	e59f00ac 	ldr	r0, [pc, #ac]	; 3f0429c <autoscript+0x214>
 3f041ec:	0affffd7 	beq	3f04150 <autoscript+0xc8>
		return 1;
	}

	debug ("** Script length: %ld\n", len);

	if ((cmd = malloc (len + 1)) == NULL) {
 3f041f0:	e2860001 	add	r0, r6, #1	; 0x1
 3f041f4:	eb002345 	bl	3f0cf10 <malloc>
 3f041f8:	e2505000 	subs	r5, r0, #0	; 0x0
		return 1;
 3f041fc:	03a00001 	moveq	r0, #1	; 0x1
 3f04200:	091baef0 	ldmeqdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
	}

	while (*len_ptr++);
 3f04204:	e4947004 	ldr	r7, [r4], #4
 3f04208:	e3570000 	cmp	r7, #0	; 0x0
 3f0420c:	1afffffc 	bne	3f04204 <autoscript+0x17c>

	/* make sure cmd is null terminated */
	memmove (cmd, (char *)len_ptr, len);
 3f04210:	e1a00005 	mov	r0, r5
 3f04214:	e1a01004 	mov	r1, r4
 3f04218:	e1a02006 	mov	r2, r6
 3f0421c:	eb002ce6 	bl	3f0f5bc <memmove>
	*(cmd + len) = 0;

#ifdef CFG_HUSH_PARSER /*?? */
	rcode = parse_string_outer (cmd, FLAG_PARSE_SEMICOLON);
#else
	{
		char *line = cmd;
 3f04220:	e1a00005 	mov	r0, r5
		char *next = cmd;
 3f04224:	e1a04005 	mov	r4, r5
 3f04228:	e7c57006 	strb	r7, [r5, r6]

		/*
		 * break into individual lines,
		 * and execute each line;
		 * terminate on error.
		 */
		while (*next) {
 3f0422c:	ea000001 	b	3f04238 <autoscript+0x1b0>
			if (*next == '\n') {
				*next = '\0';
				/* run only non-empty commands */
				if ((next - line) > 1) {
					debug ("** exec: \"%s\"\n",
						line);
					if (run_command (line, 0) < 0) {
						rcode = 1;
						break;
					}
				}
				line = next + 1;
 3f04230:	e2840001 	add	r0, r4, #1	; 0x1
			}
			++next;
 3f04234:	e2844001 	add	r4, r4, #1	; 0x1
		}
 3f04238:	e5d43000 	ldrb	r3, [r4]
 3f0423c:	e3530000 	cmp	r3, #0	; 0x0
 3f04240:	0a00000a 	beq	3f04270 <autoscript+0x1e8>
 3f04244:	e353000a 	cmp	r3, #10	; 0xa
 3f04248:	1afffff9 	bne	3f04234 <autoscript+0x1ac>
 3f0424c:	e0603004 	rsb	r3, r0, r4
 3f04250:	e3530001 	cmp	r3, #1	; 0x1
 3f04254:	e3a01000 	mov	r1, #0	; 0x0
 3f04258:	e5c41000 	strb	r1, [r4]
 3f0425c:	dafffff3 	ble	3f04230 <autoscript+0x1a8>
 3f04260:	ebfffee9 	bl	3f03e0c <run_command>
 3f04264:	e3500000 	cmp	r0, #0	; 0x0
 3f04268:	aafffff0 	bge	3f04230 <autoscript+0x1a8>
 3f0426c:	e3a09001 	mov	r9, #1	; 0x1
	}
#endif
	free (cmd);
 3f04270:	e1a00005 	mov	r0, r5
 3f04274:	eb002439 	bl	3f0d360 <free>
	return rcode;
 3f04278:	e1a00009 	mov	r0, r9
}
 3f0427c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f04280:	03f1b3a8 	mvneqs	r11, #-1610612734	; 0xa0000002
 3f04284:	03f6cd04 	mvneqs	r12, #256	; 0x100
 3f04288:	27051956 	undefined
 3f0428c:	03f1b3b0 	mvneqs	r11, #-1073741822	; 0xc0000002
 3f04290:	03f1b3c4 	mvneqs	r11, #268435459	; 0x10000003
 3f04294:	03f1b3d4 	mvneqs	r11, #1342177283	; 0x50000003
 3f04298:	03f1b3e4 	mvneqs	r11, #-1879048189	; 0x90000003
 3f0429c:	03f1b3f4 	mvneqs	r11, #-805306365	; 0xd0000003

03f042a0 <do_autoscript>:
 3f042a0:	e1a0c00d 	mov	r12, r13
 3f042a4:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f042a8:	e24cb004 	sub	r11, r12, #4	; 0x4

#endif	/* CONFIG_AUTOSCRIPT || CFG_CMD_AUTOSCRIPT */
/**************************************************/
#if (CONFIG_COMMANDS & CFG_CMD_AUTOSCRIPT)
int
do_autoscript (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	ulong addr;
	int rcode;

	if (argc < 2) {
 3f042ac:	e3520001 	cmp	r2, #1	; 0x1
		addr = CFG_LOAD_ADDR;
 3f042b0:	d3a04401 	movle	r4, #16777216	; 0x1000000
	} else {
 3f042b4:	da000004 	ble	3f042cc <do_autoscript+0x2c>
		addr = simple_strtoul (argv[1],0,16);
 3f042b8:	e3a01000 	mov	r1, #0	; 0x0
 3f042bc:	e5930004 	ldr	r0, [r3, #4]
 3f042c0:	e3a02010 	mov	r2, #16	; 0x10
 3f042c4:	eb002d1e 	bl	3f0f744 <simple_strtoul>
 3f042c8:	e1a04000 	mov	r4, r0
	}

	printf ("## Executing script at %08lx\n",addr);
 3f042cc:	e59f0010 	ldr	r0, [pc, #10]	; 3f042e4 <do_autoscript+0x44>
 3f042d0:	e1a01004 	mov	r1, r4
 3f042d4:	eb00215a 	bl	3f0c844 <printf>
	rcode = autoscript (addr);
 3f042d8:	e1a00004 	mov	r0, r4
 3f042dc:	ebffff69 	bl	3f04088 <autoscript>
	return rcode;
}
 3f042e0:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f042e4:	03f1b404 	mvneqs	r11, #67108864	; 0x4000000

03f042e8 <do_bdinfo>:
 3f042e8:	e1a0c00d 	mov	r12, r13
 3f042ec:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
{
	DECLARE_GLOBAL_DATA_PTR;

	int i;
	bd_t *bd = gd->bd;
 3f042f0:	e5986000 	ldr	r6, [r8]

	print_num ("arch_number",	bd->bi_arch_number);
 3f042f4:	e59f00b8 	ldr	r0, [pc, #b8]	; 3f043b4 <do_bdinfo+0xcc>
 3f042f8:	e5961014 	ldr	r1, [r6, #20]
 3f042fc:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f04300:	eb000035 	bl	3f043dc <print_num>
	print_num ("env_t",		(ulong)bd->bi_env);
 3f04304:	e59f00ac 	ldr	r0, [pc, #ac]	; 3f043b8 <do_bdinfo+0xd0>
 3f04308:	e5961010 	ldr	r1, [r6, #16]
 3f0430c:	eb000032 	bl	3f043dc <print_num>
	print_num ("boot_params",	(ulong)bd->bi_boot_params);
 3f04310:	e59f00a4 	ldr	r0, [pc, #a4]	; 3f043bc <do_bdinfo+0xd4>
 3f04314:	e5961018 	ldr	r1, [r6, #24]

	for (i=0; i<CONFIG_NR_DRAM_BANKS; ++i) {
 3f04318:	e3a05000 	mov	r5, #0	; 0x0
 3f0431c:	eb00002e 	bl	3f043dc <print_num>
		print_num("DRAM bank",	i);
 3f04320:	e59f0098 	ldr	r0, [pc, #98]	; 3f043c0 <do_bdinfo+0xd8>
 3f04324:	e1a01005 	mov	r1, r5
 3f04328:	eb00002b 	bl	3f043dc <print_num>
		print_num("-> start",	bd->bi_dram[i].start);
 3f0432c:	e1a04185 	mov	r4, r5, lsl #3
 3f04330:	e59f008c 	ldr	r0, [pc, #8c]	; 3f043c4 <do_bdinfo+0xdc>
 3f04334:	e286301c 	add	r3, r6, #28	; 0x1c
 3f04338:	e7931004 	ldr	r1, [r3, r4]
 3f0433c:	eb000026 	bl	3f043dc <print_num>
		print_num("-> size",	bd->bi_dram[i].size);
 3f04340:	e59f0080 	ldr	r0, [pc, #80]	; 3f043c8 <do_bdinfo+0xe0>
 3f04344:	e2863020 	add	r3, r6, #32	; 0x20
 3f04348:	e7931004 	ldr	r1, [r3, r4]
 3f0434c:	e2855001 	add	r5, r5, #1	; 0x1
 3f04350:	eb000021 	bl	3f043dc <print_num>
 3f04354:	e3550000 	cmp	r5, #0	; 0x0
 3f04358:	dafffff0 	ble	3f04320 <do_bdinfo+0x38>
	}

	printf ("ethaddr     =");
 3f0435c:	e59f0068 	ldr	r0, [pc, #68]	; 3f043cc <do_bdinfo+0xe4>
	for (i=0; i<6; ++i) {
 3f04360:	e3a05000 	mov	r5, #0	; 0x0
 3f04364:	eb002136 	bl	3f0c844 <printf>
		printf ("%c%02X", i ? ':' : ' ', bd->bi_enetaddr[i]);
 3f04368:	e3550000 	cmp	r5, #0	; 0x0
 3f0436c:	03a01020 	moveq	r1, #32	; 0x20
 3f04370:	13a0103a 	movne	r1, #58	; 0x3a
 3f04374:	e59f0054 	ldr	r0, [pc, #54]	; 3f043d0 <do_bdinfo+0xe8>
 3f04378:	e2863008 	add	r3, r6, #8	; 0x8
 3f0437c:	e7d32005 	ldrb	r2, [r3, r5]
 3f04380:	e2855001 	add	r5, r5, #1	; 0x1
 3f04384:	eb00212e 	bl	3f0c844 <printf>
 3f04388:	e3550005 	cmp	r5, #5	; 0x5
 3f0438c:	dafffff5 	ble	3f04368 <do_bdinfo+0x80>
	}
	printf ("\n"
 3f04390:	e59f003c 	ldr	r0, [pc, #3c]	; 3f043d4 <do_bdinfo+0xec>
 3f04394:	eb00212a 	bl	3f0c844 <printf>
		"ip_addr     = ");
	print_IPaddr (bd->bi_ip_addr);
 3f04398:	e5960004 	ldr	r0, [r6, #4]
 3f0439c:	ebfff67d 	bl	3f01d98 <print_IPaddr>
	printf ("\n"
 3f043a0:	e59f0030 	ldr	r0, [pc, #30]	; 3f043d8 <do_bdinfo+0xf0>
 3f043a4:	e5961000 	ldr	r1, [r6]
 3f043a8:	eb002125 	bl	3f0c844 <printf>
		"baudrate    = %d bps\n", bd->bi_baudrate);

	return 0;
 3f043ac:	e3a00000 	mov	r0, #0	; 0x0
}
 3f043b0:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f043b4:	03f1b4a0 	mvneqs	r11, #-1610612736	; 0xa0000000
 3f043b8:	03f1b4ac 	mvneqs	r11, #-1409286144	; 0xac000000
 3f043bc:	03f1b4b4 	mvneqs	r11, #-1275068416	; 0xb4000000
 3f043c0:	03f1b4c0 	mvneqs	r11, #-1073741824	; 0xc0000000
 3f043c4:	03f1b4cc 	mvneqs	r11, #-872415232	; 0xcc000000
 3f043c8:	03f1b4d8 	mvneqs	r11, #-671088640	; 0xd8000000
 3f043cc:	03f1b4e0 	mvneqs	r11, #-536870912	; 0xe0000000
 3f043d0:	03f1b4f0 	mvneqs	r11, #-268435456	; 0xf0000000
 3f043d4:	03f1b4f8 	mvneqs	r11, #-134217728	; 0xf8000000
 3f043d8:	03f1b508 	mvneqs	r11, #33554432	; 0x2000000

03f043dc <print_num>:
 3f043dc:	e1a0c00d 	mov	r12, r13
 3f043e0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

#endif /* CONFIG_ARM XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX */

static void print_num(const char *name, ulong value)
{
 3f043e4:	e1a02001 	mov	r2, r1
	printf ("%-12s= 0x%08lX\n", name, value);
 3f043e8:	e1a01000 	mov	r1, r0
 3f043ec:	e59f0008 	ldr	r0, [pc, #8]	; 3f043fc <print_num+0x20>
 3f043f0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f043f4:	eb002112 	bl	3f0c844 <printf>
 3f043f8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f043fc:	03f1b520 	mvneqs	r11, #134217728	; 0x8000000

03f04400 <do_go>:
 3f04400:	e1a0c00d 	mov	r12, r13
 3f04404:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f04408:	e24cb004 	sub	r11, r12, #4	; 0x4

/* -------------------------------------------------------------------- */

int do_go (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f0440c:	e1a05002 	mov	r5, r2
 3f04410:	e1a06003 	mov	r6, r3
#if defined(CONFIG_I386)
	DECLARE_GLOBAL_DATA_PTR;
#endif
	ulong	addr, rc;
	int     rcode = 0;
 3f04414:	e3a04000 	mov	r4, #0	; 0x0
 3f04418:	e1a03000 	mov	r3, r0

	if (argc < 2) {
 3f0441c:	e3550001 	cmp	r5, #1	; 0x1
 3f04420:	da000012 	ble	3f04470 <do_go+0x70>
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
	}

	addr = simple_strtoul(argv[1], NULL, 16);
 3f04424:	e1a01004 	mov	r1, r4
 3f04428:	e5b60004 	ldr	r0, [r6, #4]!
 3f0442c:	e3a02010 	mov	r2, #16	; 0x10
 3f04430:	eb002cc3 	bl	3f0f744 <simple_strtoul>
 3f04434:	e1a04000 	mov	r4, r0

	printf ("## Starting application at 0x%08lX ...\n", addr);
 3f04438:	e59f0044 	ldr	r0, [pc, #44]	; 3f04484 <do_go+0x84>
 3f0443c:	e1a01004 	mov	r1, r4
 3f04440:	eb0020ff 	bl	3f0c844 <printf>

	/*
	 * pass address parameter as argv[0] (aka command name),
	 * and all remaining args
	 */
#if defined(CONFIG_I386)
	/*
	 * x86 does not use a dedicated register to pass the pointer
	 * to the global_data
	 */
	argv[0] = (char *)gd;
#endif
#if !defined(CONFIG_NIOS)
	rc = ((ulong (*)(int, char *[]))addr) (--argc, &argv[1]);
 3f04444:	e2450001 	sub	r0, r5, #1	; 0x1
 3f04448:	e1a01006 	mov	r1, r6
 3f0444c:	e1a0e00f 	mov	r14, r15
 3f04450:	e1a0f004 	mov	r15, r4
#else
	/*
	 * Nios function pointers are address >> 1
	 */
	rc = ((ulong (*)(int, char *[]))(addr>>1)) (--argc, &argv[1]);
#endif
	if (rc != 0) rcode = 1;
 3f04454:	e1a01000 	mov	r1, r0

	printf ("## Application terminated, rc = 0x%lX\n", rc);
 3f04458:	e59f0028 	ldr	r0, [pc, #28]	; 3f04488 <do_go+0x88>
 3f0445c:	e2514000 	subs	r4, r1, #0	; 0x0
 3f04460:	13a04001 	movne	r4, #1	; 0x1
 3f04464:	eb0020f6 	bl	3f0c844 <printf>
	return rcode;
 3f04468:	e1a00004 	mov	r0, r4
 3f0446c:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f04470:	e59f0014 	ldr	r0, [pc, #14]	; 3f0448c <do_go+0x8c>
 3f04474:	e5931010 	ldr	r1, [r3, #16]
 3f04478:	eb0020f1 	bl	3f0c844 <printf>
 3f0447c:	e3a00001 	mov	r0, #1	; 0x1
}
 3f04480:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f04484:	03f1b56c 	mvneqs	r11, #452984832	; 0x1b000000
 3f04488:	03f1b594 	mvneqs	r11, #620756992	; 0x25000000
 3f0448c:	03f1b560 	mvneqs	r11, #402653184	; 0x18000000

03f04490 <do_bootm>:
 3f04490:	e1a0c00d 	mov	r12, r13
 3f04494:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f04498:	e24cb004 	sub	r11, r12, #4	; 0x4
	int	(*appl)(int, char *[]);
	image_header_t *hdr = &header;

	s = getenv ("verify");
	verify = (s && (*s == 'n')) ? 0 : 1;
 3f0449c:	e3a0c000 	mov	r12, #0	; 0x0
 3f044a0:	e24dd044 	sub	r13, r13, #68	; 0x44
 3f044a4:	e50bc058 	str	r12, [r11, -#88]
 3f044a8:	e50b004c 	str	r0, [r11, -#76]
 3f044ac:	e59f03c8 	ldr	r0, [pc, #3c8]	; 3f0487c <do_bootm+0x3ec>
 3f044b0:	e50b1050 	str	r1, [r11, -#80]
 3f044b4:	e1a0a002 	mov	r10, r2
 3f044b8:	e50b3054 	str	r3, [r11, -#84]
 3f044bc:	eb001ee6 	bl	3f0c05c <getenv>
 3f044c0:	e3500000 	cmp	r0, #0	; 0x0
 3f044c4:	e59f73b4 	ldr	r7, [pc, #3b4]	; 3f04880 <do_bootm+0x3f0>
 3f044c8:	0a000002 	beq	3f044d8 <do_bootm+0x48>
 3f044cc:	e5d03000 	ldrb	r3, [r0]
 3f044d0:	e353006e 	cmp	r3, #110	; 0x6e
 3f044d4:	0a000001 	beq	3f044e0 <do_bootm+0x50>
 3f044d8:	e3a01001 	mov	r1, #1	; 0x1
 3f044dc:	e50b1058 	str	r1, [r11, -#88]

	if (argc < 2) {
 3f044e0:	e35a0001 	cmp	r10, #1	; 0x1
		addr = load_addr;
 3f044e4:	d59f3398 	ldrle	r3, [pc, #398]	; 3f04884 <do_bootm+0x3f4>
 3f044e8:	d5936000 	ldrle	r6, [r3]
	} else {
 3f044ec:	da000005 	ble	3f04508 <do_bootm+0x78>
		addr = simple_strtoul(argv[1], NULL, 16);
 3f044f0:	e51b2054 	ldr	r2, [r11, -#84]
 3f044f4:	e3a01000 	mov	r1, #0	; 0x0
 3f044f8:	e5920004 	ldr	r0, [r2, #4]
 3f044fc:	e3a02010 	mov	r2, #16	; 0x10
 3f04500:	eb002c8f 	bl	3f0f744 <simple_strtoul>
 3f04504:	e1a06000 	mov	r6, r0
	}

	SHOW_BOOT_PROGRESS (1);
	printf ("## Booting image at %08lx ...\n", addr);
 3f04508:	e59f0378 	ldr	r0, [pc, #378]	; 3f04888 <do_bootm+0x3f8>
 3f0450c:	e1a01006 	mov	r1, r6
 3f04510:	eb0020cb 	bl	3f0c844 <printf>

	/* Copy header so we can blank CRC field for re-calculation */
#ifdef CONFIG_HAS_DATAFLASH
	if (addr_dataflash(addr)){
		read_dataflash(addr, sizeof(image_header_t), (char *)&header);
	} else
#endif
	memmove (&header, (char *)addr, sizeof(image_header_t));
 3f04514:	e1a00007 	mov	r0, r7
 3f04518:	e1a01006 	mov	r1, r6
 3f0451c:	e3a02040 	mov	r2, #64	; 0x40
 3f04520:	eb002c25 	bl	3f0f5bc <memmove>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04524:	e5971000 	ldr	r1, [r7]

	if (ntohl(hdr->ih_magic) != IH_MAGIC) {
 3f04528:	e3a05000 	mov	r5, #0	; 0x0
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f0452c:	e2013cff 	and	r3, r1, #65280	; 0xff00
 3f04530:	e1a03403 	mov	r3, r3, lsl #8
 3f04534:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f04538:	e20128ff 	and	r2, r1, #16711680	; 0xff0000
 3f0453c:	e1833422 	orr	r3, r3, r2, lsr #8
 3f04540:	e59f2344 	ldr	r2, [pc, #344]	; 3f0488c <do_bootm+0x3fc>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04544:	e1833c21 	orr	r3, r3, r1, lsr #24
 3f04548:	e1530002 	cmp	r3, r2
 3f0454c:	0a000002 	beq	3f0455c <do_bootm+0xcc>
#ifdef __I386__	/* correct image format not implemented yet - fake it */
		if (fake_header(hdr, (void*)addr, -1) != NULL) {
			/* to compensate for the addition below */
			addr -= sizeof(image_header_t);
			/* turnof verify,
			 * fake_header() does not fake the data crc
			 */
			verify = 0;
		} else
#endif	/* __I386__ */
	    {
		printf ("Bad Magic Number\n");
 3f04550:	e59f0338 	ldr	r0, [pc, #338]	; 3f04890 <do_bootm+0x400>
 3f04554:	eb0020ba 	bl	3f0c844 <printf>
		SHOW_BOOT_PROGRESS (-1);
		return 1;
 3f04558:	ea00013b 	b	3f04a4c <do_bootm+0x5bc>
	    }
	}
	SHOW_BOOT_PROGRESS (2);

	data = (ulong)&header;
	len  = sizeof(image_header_t);

	checksum = ntohl(hdr->ih_hcrc);
	hdr->ih_hcrc = 0;
 3f0455c:	e1a03005 	mov	r3, r5
 3f04560:	e3a02040 	mov	r2, #64	; 0x40
 3f04564:	e50b2048 	str	r2, [r11, -#72]

	if (crc32 (0, (char *)data, len) != checksum) {
 3f04568:	e1a00003 	mov	r0, r3
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f0456c:	e597c004 	ldr	r12, [r7, #4]
 3f04570:	e1a01007 	mov	r1, r7
 3f04574:	e5873004 	str	r3, [r7, #4]
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04578:	e20c4cff 	and	r4, r12, #65280	; 0xff00
 3f0457c:	e1a04404 	mov	r4, r4, lsl #8
 3f04580:	e1844c0c 	orr	r4, r4, r12, lsl #24
 3f04584:	e20c38ff 	and	r3, r12, #16711680	; 0xff0000
 3f04588:	e1844423 	orr	r4, r4, r3, lsr #8
 3f0458c:	e1844c2c 	orr	r4, r4, r12, lsr #24
 3f04590:	eb002a36 	bl	3f0ee70 <crc32>
 3f04594:	e1500004 	cmp	r0, r4
 3f04598:	0a000002 	beq	3f045a8 <do_bootm+0x118>
		printf ("Bad Header Checksum\n");
 3f0459c:	e59f02f0 	ldr	r0, [pc, #2f0]	; 3f04894 <do_bootm+0x404>
 3f045a0:	eb0020a7 	bl	3f0c844 <printf>
		SHOW_BOOT_PROGRESS (-2);
		return 1;
 3f045a4:	ea000128 	b	3f04a4c <do_bootm+0x5bc>
	}
	SHOW_BOOT_PROGRESS (3);

	/* for multi-file images we need the data part, too */
	print_image_hdr ((image_header_t *)addr);
 3f045a8:	e1a00006 	mov	r0, r6
 3f045ac:	eb0001f3 	bl	3f04d80 <print_image_hdr>

	data = addr + sizeof(image_header_t);
	len  = ntohl(hdr->ih_size);

#ifdef CONFIG_HAS_DATAFLASH
	if (addr_dataflash(addr)){
		read_dataflash(data, len, (char *)CFG_LOAD_ADDR);
		data = CFG_LOAD_ADDR;
	}
#endif

	if (verify) {
 3f045b0:	e51bc058 	ldr	r12, [r11, -#88]
 3f045b4:	e2864040 	add	r4, r6, #64	; 0x40
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f045b8:	e597300c 	ldr	r3, [r7, #12]
 3f045bc:	e35c0000 	cmp	r12, #0	; 0x0
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f045c0:	e2032cff 	and	r2, r3, #65280	; 0xff00
 3f045c4:	e1a02402 	mov	r2, r2, lsl #8
 3f045c8:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f045cc:	e20318ff 	and	r1, r3, #16711680	; 0xff0000
 3f045d0:	e1822421 	orr	r2, r2, r1, lsr #8
 3f045d4:	e1822c23 	orr	r2, r2, r3, lsr #24
 3f045d8:	e50b2048 	str	r2, [r11, -#72]
 3f045dc:	0a000013 	beq	3f04630 <do_bootm+0x1a0>
		printf ("   Verifying Checksum ... ");
 3f045e0:	e59f02b0 	ldr	r0, [pc, #2b0]	; 3f04898 <do_bootm+0x408>
 3f045e4:	eb002096 	bl	3f0c844 <printf>
		if (crc32 (0, (char *)data, len) != ntohl(hdr->ih_dcrc)) {
 3f045e8:	e1a00005 	mov	r0, r5
 3f045ec:	e51b2048 	ldr	r2, [r11, -#72]
 3f045f0:	e1a01004 	mov	r1, r4
 3f045f4:	eb002a1d 	bl	3f0ee70 <crc32>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f045f8:	e5973018 	ldr	r3, [r7, #24]
	return __arch__swab32(x);
 3f045fc:	e2032cff 	and	r2, r3, #65280	; 0xff00
 3f04600:	e1a02402 	mov	r2, r2, lsl #8
 3f04604:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f04608:	e20318ff 	and	r1, r3, #16711680	; 0xff0000
 3f0460c:	e1822421 	orr	r2, r2, r1, lsr #8
 3f04610:	e1822c23 	orr	r2, r2, r3, lsr #24
 3f04614:	e1500002 	cmp	r0, r2
 3f04618:	0a000002 	beq	3f04628 <do_bootm+0x198>
			printf ("Bad Data CRC\n");
 3f0461c:	e59f0278 	ldr	r0, [pc, #278]	; 3f0489c <do_bootm+0x40c>
 3f04620:	eb002087 	bl	3f0c844 <printf>
			SHOW_BOOT_PROGRESS (-3);
			return 1;
 3f04624:	ea000108 	b	3f04a4c <do_bootm+0x5bc>
		}
		printf ("OK\n");
 3f04628:	e59f0270 	ldr	r0, [pc, #270]	; 3f048a0 <do_bootm+0x410>
 3f0462c:	eb002084 	bl	3f0c844 <printf>
	}
	SHOW_BOOT_PROGRESS (4);

	len_ptr = (ulong *)data;

#if defined(__PPC__)
	if (hdr->ih_arch != IH_CPU_PPC)
#elif defined(__ARM__)
	if (hdr->ih_arch != IH_CPU_ARM)
 3f04630:	e5d7301d 	ldrb	r3, [r7, #29]
 3f04634:	e1a05004 	mov	r5, r4
 3f04638:	e3530002 	cmp	r3, #2	; 0x2
 3f0463c:	0a000003 	beq	3f04650 <do_bootm+0x1c0>
#elif defined(__I386__)
	if (hdr->ih_arch != IH_CPU_I386)
#elif defined(__mips__)
	if (hdr->ih_arch != IH_CPU_MIPS)
#elif defined(__nios__)
	if (hdr->ih_arch != IH_CPU_NIOS)
#else
# error Unknown CPU type
#endif
	{
		printf ("Unsupported Architecture 0x%x\n", hdr->ih_arch);
 3f04640:	e59f025c 	ldr	r0, [pc, #25c]	; 3f048a4 <do_bootm+0x414>
 3f04644:	e1a01003 	mov	r1, r3
 3f04648:	eb00207d 	bl	3f0c844 <printf>
		SHOW_BOOT_PROGRESS (-4);
		return 1;
 3f0464c:	ea0000fe 	b	3f04a4c <do_bootm+0x5bc>
	}
	SHOW_BOOT_PROGRESS (5);

	switch (hdr->ih_type) {
 3f04650:	e5d7301e 	ldrb	r3, [r7, #30]
 3f04654:	e3530002 	cmp	r3, #2	; 0x2
 3f04658:	0a000011 	beq	3f046a4 <do_bootm+0x214>
 3f0465c:	ca000002 	bgt	3f0466c <do_bootm+0x1dc>
 3f04660:	e3530001 	cmp	r3, #1	; 0x1
 3f04664:	0a000003 	beq	3f04678 <do_bootm+0x1e8>
 3f04668:	ea000025 	b	3f04704 <do_bootm+0x274>
 3f0466c:	e3530004 	cmp	r3, #4	; 0x4
 3f04670:	0a00000e 	beq	3f046b0 <do_bootm+0x220>
 3f04674:	ea000022 	b	3f04704 <do_bootm+0x274>
	case IH_TYPE_STANDALONE:
		name = "Standalone Application";
 3f04678:	e59f1228 	ldr	r1, [pc, #228]	; 3f048a8 <do_bootm+0x418>
		/* A second argument overwrites the load address */
		if (argc > 2) {
 3f0467c:	e35a0002 	cmp	r10, #2	; 0x2
 3f04680:	e50b105c 	str	r1, [r11, -#92]
 3f04684:	da000023 	ble	3f04718 <do_bootm+0x288>
			hdr->ih_load = simple_strtoul(argv[2], NULL, 16);
 3f04688:	e51b2054 	ldr	r2, [r11, -#84]
 3f0468c:	e3a01000 	mov	r1, #0	; 0x0
 3f04690:	e5920008 	ldr	r0, [r2, #8]
 3f04694:	e3a02010 	mov	r2, #16	; 0x10
 3f04698:	eb002c29 	bl	3f0f744 <simple_strtoul>
 3f0469c:	e5870010 	str	r0, [r7, #16]
		}
		break;
 3f046a0:	ea00001c 	b	3f04718 <do_bootm+0x288>
	case IH_TYPE_KERNEL:
		name = "Kernel Image";
 3f046a4:	e59f3200 	ldr	r3, [pc, #200]	; 3f048ac <do_bootm+0x41c>
 3f046a8:	e50b305c 	str	r3, [r11, -#92]
		break;
 3f046ac:	ea000019 	b	3f04718 <do_bootm+0x288>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f046b0:	e5951000 	ldr	r1, [r5]
	case IH_TYPE_MULTI:	
		name = "Multi-File Image";
 3f046b4:	e59fc1f4 	ldr	r12, [pc, #1f4]	; 3f048b0 <do_bootm+0x420>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f046b8:	e2013cff 	and	r3, r1, #65280	; 0xff00
 3f046bc:	e1a03403 	mov	r3, r3, lsl #8
 3f046c0:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f046c4:	e20128ff 	and	r2, r1, #16711680	; 0xff0000
 3f046c8:	e1833422 	orr	r3, r3, r2, lsr #8
 3f046cc:	e1833c21 	orr	r3, r3, r1, lsr #24
 3f046d0:	e50b3048 	str	r3, [r11, -#72]
		len  = ntohl(len_ptr[0]);
		/* OS kernel is always the first image */
		data += 8; /* kernel_len + terminator */
 3f046d4:	e2854008 	add	r4, r5, #8	; 0x8
		for (i=1; len_ptr[i]; ++i)
 3f046d8:	e5953004 	ldr	r3, [r5, #4]
 3f046dc:	e3a02001 	mov	r2, #1	; 0x1
 3f046e0:	e50bc05c 	str	r12, [r11, -#92]
 3f046e4:	e3530000 	cmp	r3, #0	; 0x0
 3f046e8:	0a00000a 	beq	3f04718 <do_bootm+0x288>
 3f046ec:	e2822001 	add	r2, r2, #1	; 0x1
 3f046f0:	e7953102 	ldr	r3, [r5, r2, lsl #2]
			data += 4;
 3f046f4:	e2844004 	add	r4, r4, #4	; 0x4
 3f046f8:	e3530000 	cmp	r3, #0	; 0x0
 3f046fc:	1afffffa 	bne	3f046ec <do_bootm+0x25c>
		break;
 3f04700:	ea000004 	b	3f04718 <do_bootm+0x288>
	default: printf ("Wrong Image Type for %s command\n", cmdtp->name);
 3f04704:	e51b204c 	ldr	r2, [r11, -#76]
 3f04708:	e59f01a4 	ldr	r0, [pc, #1a4]	; 3f048b4 <do_bootm+0x424>
 3f0470c:	e5921000 	ldr	r1, [r2]
 3f04710:	eb00204b 	bl	3f0c844 <printf>
		SHOW_BOOT_PROGRESS (-5);
		return 1;
 3f04714:	ea0000cc 	b	3f04a4c <do_bootm+0x5bc>
	}
	SHOW_BOOT_PROGRESS (6);

	/*
	 * We have reached the point of no return: we are going to
	 * overwrite all exception vector code, so we cannot easily
	 * recover from any failures any more...
	 */

	iflag = disable_interrupts();
 3f04718:	ebffef64 	bl	3f004b0 <disable_interrupts>

#ifdef CONFIG_AMIGAONEG3SE
	/*
	 * We've possible left the caches enabled during
	 * bios emulation, so turn them off again
	 */
	icache_disable();
	invalidate_l1_instruction_cache();
	flush_data_cache();
	dcache_disable();
#endif

	switch (hdr->ih_comp) {
 3f0471c:	e5d7301f 	ldrb	r3, [r7, #31]
 3f04720:	e1a09000 	mov	r9, r0
 3f04724:	e3530000 	cmp	r3, #0	; 0x0
 3f04728:	0a000002 	beq	3f04738 <do_bootm+0x2a8>
 3f0472c:	e3530001 	cmp	r3, #1	; 0x1
 3f04730:	0a000011 	beq	3f0477c <do_bootm+0x2ec>
 3f04734:	ea000028 	b	3f047dc <do_bootm+0x34c>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04738:	e5973010 	ldr	r3, [r7, #16]
	return __arch__swab32(x);
 3f0473c:	e2032cff 	and	r2, r3, #65280	; 0xff00
 3f04740:	e1a02402 	mov	r2, r2, lsl #8
 3f04744:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f04748:	e20318ff 	and	r1, r3, #16711680	; 0xff0000
 3f0474c:	e1822421 	orr	r2, r2, r1, lsr #8
 3f04750:	e1820c23 	orr	r0, r2, r3, lsr #24
	case IH_COMP_NONE:
		if(ntohl(hdr->ih_load) == addr) {
 3f04754:	e1500006 	cmp	r0, r6
 3f04758:	1a000003 	bne	3f0476c <do_bootm+0x2dc>
			printf ("   XIP %s ... ", name);
 3f0475c:	e59f0154 	ldr	r0, [pc, #154]	; 3f048b8 <do_bootm+0x428>
 3f04760:	e51b105c 	ldr	r1, [r11, -#92]
 3f04764:	eb002036 	bl	3f0c844 <printf>
		} else {
 3f04768:	ea000022 	b	3f047f8 <do_bootm+0x368>
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
			size_t l = len;
			void *to = (void *)ntohl(hdr->ih_load);
			void *from = (void *)data;

			printf ("   Loading %s ... ", name);

			while (l > 0) {
				size_t tail = (l > CHUNKSZ) ? CHUNKSZ : l;
				WATCHDOG_RESET();
				memmove (to, from, tail);
				to += tail;
				from += tail;
				l -= tail;
			}
#else	/* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
			memmove ((void *) ntohl(hdr->ih_load), (uchar *)data, len);
 3f0476c:	e51b2048 	ldr	r2, [r11, -#72]
 3f04770:	e1a01004 	mov	r1, r4
 3f04774:	eb002b90 	bl	3f0f5bc <memmove>
#endif	/* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
		}
		break;
 3f04778:	ea00001e 	b	3f047f8 <do_bootm+0x368>
	case IH_COMP_GZIP:
		printf ("   Uncompressing %s ... ", name);
 3f0477c:	e59f0138 	ldr	r0, [pc, #138]	; 3f048bc <do_bootm+0x42c>
 3f04780:	e51b105c 	ldr	r1, [r11, -#92]
 3f04784:	eb00202e 	bl	3f0c844 <printf>
		if (gunzip ((void *)ntohl(hdr->ih_load), unc_len,
			    (uchar *)data, (int *)&len) != 0) {
 3f04788:	e3a01501 	mov	r1, #4194304	; 0x400000
 3f0478c:	e1a02004 	mov	r2, r4
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04790:	e597c010 	ldr	r12, [r7, #16]
 3f04794:	e24b3048 	sub	r3, r11, #72	; 0x48
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04798:	e20c0cff 	and	r0, r12, #65280	; 0xff00
 3f0479c:	e1a00400 	mov	r0, r0, lsl #8
 3f047a0:	e1800c0c 	orr	r0, r0, r12, lsl #24
 3f047a4:	e20ce8ff 	and	r14, r12, #16711680	; 0xff0000
 3f047a8:	e180042e 	orr	r0, r0, r14, lsr #8
 3f047ac:	e1800c2c 	orr	r0, r0, r12, lsr #24
 3f047b0:	eb000297 	bl	3f05214 <gunzip>
 3f047b4:	e3500000 	cmp	r0, #0	; 0x0
 3f047b8:	0a00000e 	beq	3f047f8 <do_bootm+0x368>
			printf ("GUNZIP ERROR - must RESET board to recover\n");
 3f047bc:	e59f00fc 	ldr	r0, [pc, #fc]	; 3f048c0 <do_bootm+0x430>
 3f047c0:	eb00201f 	bl	3f0c844 <printf>
			SHOW_BOOT_PROGRESS (-6);
			do_reset (cmdtp, flag, argc, argv);
 3f047c4:	e51b004c 	ldr	r0, [r11, -#76]
 3f047c8:	e51b1050 	ldr	r1, [r11, -#80]
 3f047cc:	e51b3054 	ldr	r3, [r11, -#84]
 3f047d0:	e1a0200a 	mov	r2, r10
 3f047d4:	eb00476e 	bl	3f16594 <do_reset>
		}
		break;
 3f047d8:	ea000006 	b	3f047f8 <do_bootm+0x368>
#ifdef CONFIG_BZIP2
	case IH_COMP_BZIP2:
		printf ("   Uncompressing %s ... ", name);
		i = BZ2_bzBuffToBuffDecompress ((char*)ntohl(hdr->ih_load),
						&unc_len, (char *)data, len, 0, 0);
		if (i != BZ_OK) {
			printf ("BUNZIP2 ERROR %d - must RESET board to recover\n", i);
			SHOW_BOOT_PROGRESS (-6);
			udelay(100000);
			do_reset (cmdtp, flag, argc, argv);
		}
		break;
#endif /* CONFIG_BZIP2 */
	default:
		if (iflag)
 3f047dc:	e3590000 	cmp	r9, #0	; 0x0
 3f047e0:	0a000000 	beq	3f047e8 <do_bootm+0x358>
			enable_interrupts();
 3f047e4:	ebffef2d 	bl	3f004a0 <enable_interrupts>
		printf ("Unimplemented compression type %d\n", hdr->ih_comp);
 3f047e8:	e59f00d4 	ldr	r0, [pc, #d4]	; 3f048c4 <do_bootm+0x434>
 3f047ec:	e5d7101f 	ldrb	r1, [r7, #31]
 3f047f0:	eb002013 	bl	3f0c844 <printf>
		SHOW_BOOT_PROGRESS (-7);
		return 1;
 3f047f4:	ea000094 	b	3f04a4c <do_bootm+0x5bc>
	}
	printf ("OK\n");
 3f047f8:	e59f00a0 	ldr	r0, [pc, #a0]	; 3f048a0 <do_bootm+0x410>
 3f047fc:	eb002010 	bl	3f0c844 <printf>
	SHOW_BOOT_PROGRESS (7);

	switch (hdr->ih_type) {
 3f04800:	e5d7301e 	ldrb	r3, [r7, #30]
 3f04804:	e3530002 	cmp	r3, #2	; 0x2
 3f04808:	0a000047 	beq	3f0492c <do_bootm+0x49c>
 3f0480c:	ca000002 	bgt	3f0481c <do_bootm+0x38c>
 3f04810:	e3530001 	cmp	r3, #1	; 0x1
 3f04814:	0a000003 	beq	3f04828 <do_bootm+0x398>
 3f04818:	ea00003c 	b	3f04910 <do_bootm+0x480>
 3f0481c:	e3530004 	cmp	r3, #4	; 0x4
 3f04820:	0a000041 	beq	3f0492c <do_bootm+0x49c>
 3f04824:	ea000039 	b	3f04910 <do_bootm+0x480>
	case IH_TYPE_STANDALONE:
		if (iflag)
 3f04828:	e3590000 	cmp	r9, #0	; 0x0
 3f0482c:	0a000000 	beq	3f04834 <do_bootm+0x3a4>
			enable_interrupts();
 3f04830:	ebffef1a 	bl	3f004a0 <enable_interrupts>

		/* load (and uncompress), but don't start if "autostart"
		 * is set to "no"
		 */
		if (((s = getenv("autostart")) != NULL) && (strcmp(s,"no") == 0)) {
 3f04834:	e59f008c 	ldr	r0, [pc, #8c]	; 3f048c8 <do_bootm+0x438>
 3f04838:	eb001e07 	bl	3f0c05c <getenv>
 3f0483c:	e3500000 	cmp	r0, #0	; 0x0
 3f04840:	0a000024 	beq	3f048d8 <do_bootm+0x448>
 3f04844:	e59f1080 	ldr	r1, [pc, #80]	; 3f048cc <do_bootm+0x43c>
 3f04848:	eb002a5a 	bl	3f0f1b8 <strcmp>
 3f0484c:	e2505000 	subs	r5, r0, #0	; 0x0
 3f04850:	1a000020 	bne	3f048d8 <do_bootm+0x448>
			char buf[32];
			sprintf(buf, "%lX", len);
 3f04854:	e59f1074 	ldr	r1, [pc, #74]	; 3f048d0 <do_bootm+0x440>
 3f04858:	e24b4044 	sub	r4, r11, #68	; 0x44
 3f0485c:	e51b2048 	ldr	r2, [r11, -#72]
 3f04860:	e1a00004 	mov	r0, r4
 3f04864:	eb002df4 	bl	3f1003c <sprintf>
			setenv("filesize", buf);
 3f04868:	e59f0064 	ldr	r0, [pc, #64]	; 3f048d4 <do_bootm+0x444>
 3f0486c:	e1a01004 	mov	r1, r4
 3f04870:	eb001dd8 	bl	3f0bfd8 <setenv>
			return 0;
 3f04874:	e3a00000 	mov	r0, #0	; 0x0
 3f04878:	ea000074 	b	3f04a50 <do_bootm+0x5c0>
 3f0487c:	03f1b678 	mvneqs	r11, #125829120	; 0x7800000
 3f04880:	03f6cd04 	mvneqs	r12, #256	; 0x100
 3f04884:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
 3f04888:	03f1b680 	mvneqs	r11, #134217728	; 0x8000000
 3f0488c:	27051956 	undefined
 3f04890:	03f1b6a0 	mvneqs	r11, #167772160	; 0xa000000
 3f04894:	03f1b6b4 	mvneqs	r11, #188743680	; 0xb400000
 3f04898:	03f1b6cc 	mvneqs	r11, #213909504	; 0xcc00000
 3f0489c:	03f1b6e8 	mvneqs	r11, #243269632	; 0xe800000
 3f048a0:	03f1b6f8 	mvneqs	r11, #260046848	; 0xf800000
 3f048a4:	03f1b6fc 	mvneqs	r11, #264241152	; 0xfc00000
 3f048a8:	03f1b71c 	mvneqs	r11, #7340032	; 0x700000
 3f048ac:	03f1b734 	mvneqs	r11, #13631488	; 0xd00000
 3f048b0:	03f1b744 	mvneqs	r11, #17825792	; 0x1100000
 3f048b4:	03f1b758 	mvneqs	r11, #23068672	; 0x1600000
 3f048b8:	03f1b77c 	mvneqs	r11, #32505856	; 0x1f00000
 3f048bc:	03f1b78c 	mvneqs	r11, #36700160	; 0x2300000
 3f048c0:	03f1b7a8 	mvneqs	r11, #44040192	; 0x2a00000
 3f048c4:	03f1b7d4 	mvneqs	r11, #55574528	; 0x3500000
 3f048c8:	03f1b7f8 	mvneqs	r11, #65011712	; 0x3e00000
 3f048cc:	03f1b804 	mvneqs	r11, #262144	; 0x40000
 3f048d0:	03f1b808 	mvneqs	r11, #524288	; 0x80000
 3f048d4:	03f1b80c 	mvneqs	r11, #786432	; 0xc0000
		}
		appl = (int (*)(int, char *[]))ntohl(hdr->ih_ep);
		(*appl)(argc-1, &argv[1]);
 3f048d8:	e51bc054 	ldr	r12, [r11, -#84]
 3f048dc:	e24a0001 	sub	r0, r10, #1	; 0x1
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f048e0:	e5973014 	ldr	r3, [r7, #20]
 3f048e4:	e28c1004 	add	r1, r12, #4	; 0x4
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f048e8:	e2032cff 	and	r2, r3, #65280	; 0xff00
 3f048ec:	e1a02402 	mov	r2, r2, lsl #8
 3f048f0:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f048f4:	e203c8ff 	and	r12, r3, #16711680	; 0xff0000
 3f048f8:	e182242c 	orr	r2, r2, r12, lsr #8
 3f048fc:	e1822c23 	orr	r2, r2, r3, lsr #24
 3f04900:	e1a0e00f 	mov	r14, r15
 3f04904:	e1a0f002 	mov	r15, r2
		return 0;
 3f04908:	e3a00000 	mov	r0, #0	; 0x0
 3f0490c:	ea00004f 	b	3f04a50 <do_bootm+0x5c0>
	case IH_TYPE_KERNEL:
	case IH_TYPE_MULTI:
		/* handled below */
		break;
	default:
		if (iflag)
 3f04910:	e3590000 	cmp	r9, #0	; 0x0
 3f04914:	0a000000 	beq	3f0491c <do_bootm+0x48c>
			enable_interrupts();
 3f04918:	ebffeee0 	bl	3f004a0 <enable_interrupts>
		printf ("Can't boot image type %d\n", hdr->ih_type);
 3f0491c:	e59f0100 	ldr	r0, [pc, #100]	; 3f04a24 <do_bootm+0x594>
 3f04920:	e5d7101e 	ldrb	r1, [r7, #30]
 3f04924:	eb001fc6 	bl	3f0c844 <printf>
		SHOW_BOOT_PROGRESS (-8);
		return 1;
 3f04928:	ea000047 	b	3f04a4c <do_bootm+0x5bc>
	}
	SHOW_BOOT_PROGRESS (8);

	switch (hdr->ih_os) {
 3f0492c:	e5d7301c 	ldrb	r3, [r7, #28]
 3f04930:	e2433002 	sub	r3, r3, #2	; 0x2
 3f04934:	e3530010 	cmp	r3, #16	; 0x10
 3f04938:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f0493c:	ea000010 	b	3f04984 <do_bootm+0x4f4>
 3f04940:	03f049ac 	mvneqs	r4, #2818048	; 0x2b0000
 3f04944:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f04948:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f0494c:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f04950:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f04954:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f04958:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f0495c:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f04960:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f04964:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f04968:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f0496c:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f04970:	03f049fc 	mvneqs	r4, #4128768	; 0x3f0000
 3f04974:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f04978:	03f04a28 	mvneqs	r4, #163840	; 0x28000
 3f0497c:	03f04984 	mvneqs	r4, #2162688	; 0x210000
 3f04980:	03f049d4 	mvneqs	r4, #3473408	; 0x350000
	default:			/* handled by (original) Linux case */
	case IH_OS_LINUX:
#ifdef CONFIG_SILENT_CONSOLE
	    fixup_silent_linux();
#endif
	    do_bootm_linux  (cmdtp, flag, argc, argv,
 3f04984:	e51b004c 	ldr	r0, [r11, -#76]
 3f04988:	e51b1050 	ldr	r1, [r11, -#80]
 3f0498c:	e58d6000 	str	r6, [r13]
 3f04990:	e58d5004 	str	r5, [r13, #4]
 3f04994:	e51b3054 	ldr	r3, [r11, -#84]
 3f04998:	e51bc058 	ldr	r12, [r11, -#88]
 3f0499c:	e1a0200a 	mov	r2, r10
 3f049a0:	e58dc008 	str	r12, [r13, #8]
 3f049a4:	eb004d88 	bl	3f17fcc <do_bootm_linux>
			     addr, len_ptr, verify);
	    break;
 3f049a8:	ea000027 	b	3f04a4c <do_bootm+0x5bc>
	case IH_OS_NETBSD:
	    do_bootm_netbsd (cmdtp, flag, argc, argv,
 3f049ac:	e51b004c 	ldr	r0, [r11, -#76]
 3f049b0:	e51b1050 	ldr	r1, [r11, -#80]
 3f049b4:	e58d6000 	str	r6, [r13]
 3f049b8:	e58d5004 	str	r5, [r13, #4]
 3f049bc:	e51b3054 	ldr	r3, [r11, -#84]
 3f049c0:	e51bc058 	ldr	r12, [r11, -#88]
 3f049c4:	e1a0200a 	mov	r2, r10
 3f049c8:	e58dc008 	str	r12, [r13, #8]
 3f049cc:	eb000020 	bl	3f04a54 <do_bootm_netbsd>
			     addr, len_ptr, verify);
	    break;
 3f049d0:	ea00001d 	b	3f04a4c <do_bootm+0x5bc>

#ifdef CONFIG_LYNXKDI
	case IH_OS_LYNXOS:
	    do_bootm_lynxkdi (cmdtp, flag, argc, argv,
			     addr, len_ptr, verify);
	    break;
#endif

	case IH_OS_RTEMS:
	    do_bootm_rtems (cmdtp, flag, argc, argv,
 3f049d4:	e51b004c 	ldr	r0, [r11, -#76]
 3f049d8:	e51b1050 	ldr	r1, [r11, -#80]
 3f049dc:	e58d6000 	str	r6, [r13]
 3f049e0:	e58d5004 	str	r5, [r13, #4]
 3f049e4:	e51b3054 	ldr	r3, [r11, -#84]
 3f049e8:	e51bc058 	ldr	r12, [r11, -#88]
 3f049ec:	e1a0200a 	mov	r2, r10
 3f049f0:	e58dc008 	str	r12, [r13, #8]
 3f049f4:	eb000261 	bl	3f05380 <do_bootm_rtems>
			     addr, len_ptr, verify);
	    break;
 3f049f8:	ea000013 	b	3f04a4c <do_bootm+0x5bc>

#if (CONFIG_COMMANDS & CFG_CMD_ELF)
	case IH_OS_VXWORKS:
	    do_bootm_vxworks (cmdtp, flag, argc, argv,
 3f049fc:	e51b004c 	ldr	r0, [r11, -#76]
 3f04a00:	e51b1050 	ldr	r1, [r11, -#80]
 3f04a04:	e58d6000 	str	r6, [r13]
 3f04a08:	e58d5004 	str	r5, [r13, #4]
 3f04a0c:	e51b3054 	ldr	r3, [r11, -#84]
 3f04a10:	e51bc058 	ldr	r12, [r11, -#88]
 3f04a14:	e1a0200a 	mov	r2, r10
 3f04a18:	e58dc008 	str	r12, [r13, #8]
 3f04a1c:	eb000265 	bl	3f053b8 <do_bootm_vxworks>
			      addr, len_ptr, verify);
	    break;
 3f04a20:	ea000009 	b	3f04a4c <do_bootm+0x5bc>
 3f04a24:	03f1b818 	mvneqs	r11, #1572864	; 0x180000
	case IH_OS_QNX:
	    do_bootm_qnxelf (cmdtp, flag, argc, argv,
 3f04a28:	e51b004c 	ldr	r0, [r11, -#76]
 3f04a2c:	e51b1050 	ldr	r1, [r11, -#80]
 3f04a30:	e58d6000 	str	r6, [r13]
 3f04a34:	e58d5004 	str	r5, [r13, #4]
 3f04a38:	e51b3054 	ldr	r3, [r11, -#84]
 3f04a3c:	e51bc058 	ldr	r12, [r11, -#88]
 3f04a40:	e1a0200a 	mov	r2, r10
 3f04a44:	e58dc008 	str	r12, [r13, #8]
 3f04a48:	eb000272 	bl	3f05418 <do_bootm_qnxelf>
			      addr, len_ptr, verify);
	    break;
#endif /* CFG_CMD_ELF */
#ifdef CONFIG_ARTOS
	case IH_OS_ARTOS:
	    do_bootm_artos  (cmdtp, flag, argc, argv,
			     addr, len_ptr, verify);
	    break;
#endif
	}

	SHOW_BOOT_PROGRESS (-9);
#ifdef DEBUG
	printf ("\n## Control returned to monitor - resetting...\n");
	do_reset (cmdtp, flag, argc, argv);
#endif
	return 1;
 3f04a4c:	e3a00001 	mov	r0, #1	; 0x1
}
 3f04a50:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f04a54 <do_bootm_netbsd>:
 3f04a54:	e1a0c00d 	mov	r12, r13
 3f04a58:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f04a5c:	e24cb004 	sub	r11, r12, #4	; 0x4

U_BOOT_CMD(
 	bootm,	CFG_MAXARGS,	1,	do_bootm,
 	"bootm   - boot application image from memory\n",
 	"[addr [arg ...]]\n    - boot application image stored in memory\n"
 	"        passing arguments 'arg ...'; when booting a Linux kernel,\n"
 	"        'arg' can be the address of an initrd image\n"
);

#ifdef CONFIG_SILENT_CONSOLE
static void
fixup_silent_linux ()
{
	DECLARE_GLOBAL_DATA_PTR;
	char buf[256], *start, *end;
	char *cmdline = getenv ("bootargs");

	/* Only fix cmdline when requested */
	if (!(gd->flags & GD_FLG_SILENT))
		return;

	debug ("before silent fix-up: %s\n", cmdline);
	if (cmdline) {
		if ((start = strstr (cmdline, "console=")) != NULL) {
			end = strchr (start, ' ');
			strncpy (buf, cmdline, (start - cmdline + 8));
			if (end)
				strcpy (buf + (start - cmdline + 8), end);
			else
				buf[start - cmdline + 8] = '\0';
		} else {
			strcpy (buf, cmdline);
			strcat (buf, " console=");
		}
	} else {
		strcpy (buf, "console=");
	}

	setenv ("bootargs", buf);
	debug ("after silent fix-up: %s\n", buf);
}
#endif /* CONFIG_SILENT_CONSOLE */

#ifdef CONFIG_PPC
static void
do_bootm_linux (cmd_tbl_t *cmdtp, int flag,
		int	argc, char *argv[],
		ulong	addr,
		ulong	*len_ptr,
		int	verify)
{
	DECLARE_GLOBAL_DATA_PTR;

	ulong	sp;
	ulong	len, checksum;
	ulong	initrd_start, initrd_end;
	ulong	cmd_start, cmd_end;
	ulong	initrd_high;
	ulong	data;
	int	initrd_copy_to_ram = 1;
	char    *cmdline;
	char	*s;
	bd_t	*kbd;
	void	(*kernel)(bd_t *, ulong, ulong, ulong, ulong);
	image_header_t *hdr = &header;

	if ((s = getenv ("initrd_high")) != NULL) {
		/* a value of "no" or a similar string will act like 0,
		 * turning the "load high" feature off. This is intentional.
		 */
		initrd_high = simple_strtoul(s, NULL, 16);
		if (initrd_high == ~0)
			initrd_copy_to_ram = 0;
	} else {	/* not set, no restrictions to load high */
		initrd_high = ~0;
	}

#ifdef CONFIG_LOGBUFFER
	kbd=gd->bd;
	/* Prevent initrd from overwriting logbuffer */
	if (initrd_high < (kbd->bi_memsize-LOGBUFF_LEN-LOGBUFF_OVERHEAD))
		initrd_high = kbd->bi_memsize-LOGBUFF_LEN-LOGBUFF_OVERHEAD;
	debug ("## Logbuffer at 0x%08lX ", kbd->bi_memsize-LOGBUFF_LEN);
#endif

	/*
	 * Booting a (Linux) kernel image
	 *
	 * Allocate space for command line and board info - the
	 * address should be as high as possible within the reach of
	 * the kernel (see CFG_BOOTMAPSZ settings), but in unused
	 * memory, which means far enough below the current stack
	 * pointer.
	 */

	asm( "mr %0,1": "=r"(sp) : );

	debug ("## Current stack ends at 0x%08lX ", sp);

	sp -= 2048;		/* just to be sure */
	if (sp > CFG_BOOTMAPSZ)
		sp = CFG_BOOTMAPSZ;
	sp &= ~0xF;

	debug ("=> set upper limit to 0x%08lX\n", sp);

	cmdline = (char *)((sp - CFG_BARGSIZE) & ~0xF);
	kbd = (bd_t *)(((ulong)cmdline - sizeof(bd_t)) & ~0xF);

	if ((s = getenv("bootargs")) == NULL)
		s = "";

	strcpy (cmdline, s);

	cmd_start    = (ulong)&cmdline[0];
	cmd_end      = cmd_start + strlen(cmdline);

	*kbd = *(gd->bd);

#ifdef	DEBUG
	printf ("## cmdline at 0x%08lX ... 0x%08lX\n", cmd_start, cmd_end);

	do_bdinfo (NULL, 0, 0, NULL);
#endif

	if ((s = getenv ("clocks_in_mhz")) != NULL) {
		/* convert all clock information to MHz */
		kbd->bi_intfreq /= 1000000L;
		kbd->bi_busfreq /= 1000000L;
#if defined(CONFIG_8260) || defined(CONFIG_MPC8560)
		kbd->bi_cpmfreq /= 1000000L;
		kbd->bi_brgfreq /= 1000000L;
		kbd->bi_sccfreq /= 1000000L;
		kbd->bi_vco     /= 1000000L;
#endif /* CONFIG_8260 */
#if defined(CONFIG_MPC5XXXX)
		kbd->bi_ipbfreq /= 1000000L;
		kbd->bi_pcifreq /= 1000000L;
#endif /* CONFIG_MPC5XXXX */
	}

	kernel = (void (*)(bd_t *, ulong, ulong, ulong, ulong))hdr->ih_ep;

	/*
	 * Check if there is an initrd image
	 */
	if (argc >= 3) {
		SHOW_BOOT_PROGRESS (9);

		addr = simple_strtoul(argv[2], NULL, 16);

		printf ("## Loading RAMDisk Image at %08lx ...\n", addr);

		/* Copy header so we can blank CRC field for re-calculation */
		memmove (&header, (char *)addr, sizeof(image_header_t));

		if (hdr->ih_magic  != IH_MAGIC) {
			printf ("Bad Magic Number\n");
			SHOW_BOOT_PROGRESS (-10);
			do_reset (cmdtp, flag, argc, argv);
		}

		data = (ulong)&header;
		len  = sizeof(image_header_t);

		checksum = hdr->ih_hcrc;
		hdr->ih_hcrc = 0;

		if (crc32 (0, (char *)data, len) != checksum) {
			printf ("Bad Header Checksum\n");
			SHOW_BOOT_PROGRESS (-11);
			do_reset (cmdtp, flag, argc, argv);
		}

		SHOW_BOOT_PROGRESS (10);

		print_image_hdr (hdr);

		data = addr + sizeof(image_header_t);
		len  = hdr->ih_size;

		if (verify) {
			ulong csum = 0;
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
			ulong cdata = data, edata = cdata + len;
#endif	/* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */

			printf ("   Verifying Checksum ... ");

#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)

			while (cdata < edata) {
				ulong chunk = edata - cdata;

				if (chunk > CHUNKSZ)
					chunk = CHUNKSZ;
				csum = crc32 (csum, (char *)cdata, chunk);
				cdata += chunk;

				WATCHDOG_RESET();
			}
#else	/* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
			csum = crc32 (0, (char *)data, len);
#endif	/* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */

			if (csum != hdr->ih_dcrc) {
				printf ("Bad Data CRC\n");
				SHOW_BOOT_PROGRESS (-12);
				do_reset (cmdtp, flag, argc, argv);
			}
			printf ("OK\n");
		}

		SHOW_BOOT_PROGRESS (11);

		if ((hdr->ih_os   != IH_OS_LINUX)	||
		    (hdr->ih_arch != IH_CPU_PPC)	||
		    (hdr->ih_type != IH_TYPE_RAMDISK)	) {
			printf ("No Linux PPC Ramdisk Image\n");
			SHOW_BOOT_PROGRESS (-13);
			do_reset (cmdtp, flag, argc, argv);
		}

		/*
		 * Now check if we have a multifile image
		 */
	} else if ((hdr->ih_type==IH_TYPE_MULTI) && (len_ptr[1])) {
		u_long tail    = ntohl(len_ptr[0]) % 4;
		int i;

		SHOW_BOOT_PROGRESS (13);

		/* skip kernel length and terminator */
		data = (ulong)(&len_ptr[2]);
		/* skip any additional image length fields */
		for (i=1; len_ptr[i]; ++i)
			data += 4;
		/* add kernel length, and align */
		data += ntohl(len_ptr[0]);
		if (tail) {
			data += 4 - tail;
		}

		len   = ntohl(len_ptr[1]);

	} else {
		/*
		 * no initrd image
		 */
		SHOW_BOOT_PROGRESS (14);

		len = data = 0;
	}

	if (!data) {
		debug ("No initrd\n");
	}

	if (data) {
	    if (!initrd_copy_to_ram) {	/* zero-copy ramdisk support */
		initrd_start = data;
		initrd_end = initrd_start + len;
	    } else {
		initrd_start  = (ulong)kbd - len;
		initrd_start &= ~(4096 - 1);	/* align on page */

		if (initrd_high) {
			ulong nsp;

			/*
			 * the inital ramdisk does not need to be within
			 * CFG_BOOTMAPSZ as it is not accessed until after
			 * the mm system is initialised.
			 *
			 * do the stack bottom calculation again and see if
			 * the initrd will fit just below the monitor stack
			 * bottom without overwriting the area allocated
			 * above for command line args and board info.
			 */
			asm( "mr %0,1": "=r"(nsp) : );
			nsp -= 2048;		/* just to be sure */
			nsp &= ~0xF;
			if (nsp > initrd_high)	/* limit as specified */
				nsp = initrd_high;
			nsp -= len;
			nsp &= ~(4096 - 1);	/* align on page */
			if (nsp >= sp)
				initrd_start = nsp;
		}

		SHOW_BOOT_PROGRESS (12);

		debug ("## initrd at 0x%08lX ... 0x%08lX (len=%ld=0x%lX)\n",
			data, data + len - 1, len, len);

		initrd_end    = initrd_start + len;
		printf ("   Loading Ramdisk to %08lx, end %08lx ... ",
			initrd_start, initrd_end);
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
		{
			size_t l = len;
			void *to = (void *)initrd_start;
			void *from = (void *)data;

			while (l > 0) {
				size_t tail = (l > CHUNKSZ) ? CHUNKSZ : l;
				WATCHDOG_RESET();
				memmove (to, from, tail);
				to += tail;
				from += tail;
				l -= tail;
			}
		}
#else	/* !(CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG) */
		memmove ((void *)initrd_start, (void *)data, len);
#endif	/* CONFIG_HW_WATCHDOG || CONFIG_WATCHDOG */
		printf ("OK\n");
	    }
	} else {
		initrd_start = 0;
		initrd_end = 0;
	}


	debug ("## Transferring control to Linux (at address %08lx) ...\n",
		(ulong)kernel);

	SHOW_BOOT_PROGRESS (15);

#if defined(CFG_INIT_RAM_LOCK) && !defined(CONFIG_E500)
	unlock_ram_in_cache();
#endif
	/*
	 * Linux Kernel Parameters:
	 *   r3: ptr to board info data
	 *   r4: initrd_start or 0 if no initrd
	 *   r5: initrd_end - unused if r4 is 0
	 *   r6: Start of command line string
	 *   r7: End   of command line string
	 */
	(*kernel) (kbd, initrd_start, initrd_end, cmd_start, cmd_end);
}
#endif /* CONFIG_PPC */

static void
do_bootm_netbsd (cmd_tbl_t *cmdtp, int flag,
		int	argc, char *argv[],
		ulong	addr,
		ulong	*len_ptr,
		int	verify)
{
 3f04a60:	e1a07002 	mov	r7, r2
 3f04a64:	e1a0a003 	mov	r10, r3
	DECLARE_GLOBAL_DATA_PTR;

	image_header_t *hdr = &header;

	void	(*loader)(bd_t *, image_header_t *, char *, char *);
	image_header_t *img_addr;
	char     *consdev;
	char     *cmdline;


	/*
	 * Booting a (NetBSD) kernel image
	 *
	 * This process is pretty similar to a standalone application:
	 * The (first part of an multi-) image must be a stage-2 loader,
	 * which in turn is responsible for loading & invoking the actual
	 * kernel.  The only differences are the parameters being passed:
	 * besides the board info strucure, the loader expects a command
	 * line, the name of the console device, and (optionally) the
	 * address of the original image header.
	 */

	img_addr = 0;
	if ((hdr->ih_type==IH_TYPE_MULTI) && (len_ptr[1]))
 3f04a68:	e59f00b8 	ldr	r0, [pc, #b8]	; 3f04b28 <do_bootm_netbsd+0xd4>
 3f04a6c:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f04a70:	e5d0101e 	ldrb	r1, [r0, #30]
 3f04a74:	e3a00000 	mov	r0, #0	; 0x0
 3f04a78:	e50b0028 	str	r0, [r11, -#40]
 3f04a7c:	e3510004 	cmp	r1, #4	; 0x4
 3f04a80:	1a000005 	bne	3f04a9c <do_bootm_netbsd+0x48>
 3f04a84:	e59b3008 	ldr	r3, [r11, #8]
 3f04a88:	e5932004 	ldr	r2, [r3, #4]
 3f04a8c:	e59b3004 	ldr	r3, [r11, #4]
 3f04a90:	e1520000 	cmp	r2, r0
 3f04a94:	01a03000 	moveq	r3, r0
 3f04a98:	e50b3028 	str	r3, [r11, -#40]
		img_addr = (image_header_t *) addr;


	consdev = "";
#if   defined (CONFIG_8xx_CONS_SMC1)
	consdev = "smc1";
#elif defined (CONFIG_8xx_CONS_SMC2)
	consdev = "smc2";
#elif defined (CONFIG_8xx_CONS_SCC2)
	consdev = "scc2";
#elif defined (CONFIG_8xx_CONS_SCC3)
	consdev = "scc3";
#endif

	if (argc > 2) {
 3f04a9c:	e3570002 	cmp	r7, #2	; 0x2
 3f04aa0:	e59f9084 	ldr	r9, [pc, #84]	; 3f04b2c <do_bootm_netbsd+0xd8>
 3f04aa4:	da000021 	ble	3f04b30 <do_bootm_netbsd+0xdc>
		ulong len;
		int   i;

		for (i=2, len=0 ; i<argc ; i+=1)
 3f04aa8:	e3a04002 	mov	r4, #2	; 0x2
 3f04aac:	e3a05000 	mov	r5, #0	; 0x0
 3f04ab0:	e1540007 	cmp	r4, r7
 3f04ab4:	aa000006 	bge	3f04ad4 <do_bootm_netbsd+0x80>
			len += strlen (argv[i]) + 1;
 3f04ab8:	e79a0104 	ldr	r0, [r10, r4, lsl #2]
 3f04abc:	e2844001 	add	r4, r4, #1	; 0x1
 3f04ac0:	eb002a00 	bl	3f0f2c8 <strlen>
 3f04ac4:	e2853001 	add	r3, r5, #1	; 0x1
 3f04ac8:	e0835000 	add	r5, r3, r0
 3f04acc:	e1540007 	cmp	r4, r7
 3f04ad0:	bafffff8 	blt	3f04ab8 <do_bootm_netbsd+0x64>
		cmdline = malloc (len);
 3f04ad4:	e1a00005 	mov	r0, r5
 3f04ad8:	eb00210c 	bl	3f0cf10 <malloc>
 3f04adc:	e1a06000 	mov	r6, r0

		for (i=2, len=0 ; i<argc ; i+=1) {
 3f04ae0:	e3a04002 	mov	r4, #2	; 0x2
 3f04ae4:	e3a05000 	mov	r5, #0	; 0x0
 3f04ae8:	e1540007 	cmp	r4, r7
 3f04aec:	aa000014 	bge	3f04b44 <do_bootm_netbsd+0xf0>
			if (i > 2)
 3f04af0:	e3540002 	cmp	r4, #2	; 0x2
				cmdline[len++] = ' ';
 3f04af4:	c3a03020 	movgt	r3, #32	; 0x20
 3f04af8:	c7c63005 	strgtb	r3, [r6, r5]
 3f04afc:	c2855001 	addgt	r5, r5, #1	; 0x1
			strcpy (&cmdline[len], argv[i]);
 3f04b00:	e79a1104 	ldr	r1, [r10, r4, lsl #2]
 3f04b04:	e0860005 	add	r0, r6, r5
 3f04b08:	eb00296e 	bl	3f0f0c8 <strcpy>
			len += strlen (argv[i]);
 3f04b0c:	e79a0104 	ldr	r0, [r10, r4, lsl #2]
 3f04b10:	e2844001 	add	r4, r4, #1	; 0x1
 3f04b14:	eb0029eb 	bl	3f0f2c8 <strlen>
 3f04b18:	e0855000 	add	r5, r5, r0
 3f04b1c:	e1540007 	cmp	r4, r7
 3f04b20:	bafffff2 	blt	3f04af0 <do_bootm_netbsd+0x9c>
		}
	} else if ((cmdline = getenv("bootargs")) == NULL) {
 3f04b24:	ea000006 	b	3f04b44 <do_bootm_netbsd+0xf0>
 3f04b28:	03f6cd04 	mvneqs	r12, #256	; 0x100
 3f04b2c:	03f1b924 	mvneqs	r11, #589824	; 0x90000
 3f04b30:	e59f003c 	ldr	r0, [pc, #3c]	; 3f04b74 <do_bootm_netbsd+0x120>
 3f04b34:	eb001d48 	bl	3f0c05c <getenv>
 3f04b38:	e3500000 	cmp	r0, #0	; 0x0
 3f04b3c:	11a06000 	movne	r6, r0
 3f04b40:	01a06009 	moveq	r6, r9
		cmdline = "";
	}

	loader = (void (*)(bd_t *, image_header_t *, char *, char *)) hdr->ih_ep;
 3f04b44:	e59f302c 	ldr	r3, [pc, #2c]	; 3f04b78 <do_bootm_netbsd+0x124>
 3f04b48:	e5934014 	ldr	r4, [r3, #20]

	printf ("## Transferring control to NetBSD stage-2 loader (at address %08lx) ...\n",
 3f04b4c:	e59f0028 	ldr	r0, [pc, #28]	; 3f04b7c <do_bootm_netbsd+0x128>
 3f04b50:	e1a01004 	mov	r1, r4
 3f04b54:	eb001f3a 	bl	3f0c844 <printf>
		(ulong)loader);

	SHOW_BOOT_PROGRESS (15);

	/*
	 * NetBSD Stage-2 Loader Parameters:
	 *   r3: ptr to board info data
	 *   r4: image address
	 *   r5: console device
	 *   r6: boot args string
	 */
	(*loader) (gd->bd, img_addr, consdev, cmdline);
 3f04b58:	e5980000 	ldr	r0, [r8]
 3f04b5c:	e1a02009 	mov	r2, r9
 3f04b60:	e51b1028 	ldr	r1, [r11, -#40]
 3f04b64:	e1a03006 	mov	r3, r6
 3f04b68:	e1a0e00f 	mov	r14, r15
 3f04b6c:	e1a0f004 	mov	r15, r4
 3f04b70:	ea000002 	b	3f04b80 <do_bootm_netbsd+0x12c>
 3f04b74:	03f1b928 	mvneqs	r11, #655360	; 0xa0000
 3f04b78:	03f6cd04 	mvneqs	r12, #256	; 0x100
 3f04b7c:	03f1b934 	mvneqs	r11, #851968	; 0xd0000
}
 3f04b80:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f04b84 <do_bootd>:
 3f04b84:	e1a0c00d 	mov	r12, r13
 3f04b88:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f04b8c:	e24cb004 	sub	r11, r12, #4	; 0x4

#if defined(CONFIG_ARTOS) && defined(CONFIG_PPC)

/* Function that returns a character from the environment */
extern uchar (*env_get_char)(int);

static void
do_bootm_artos (cmd_tbl_t *cmdtp, int flag,
		int	argc, char *argv[],
		ulong	addr,
		ulong	*len_ptr,
		int	verify)
{
	DECLARE_GLOBAL_DATA_PTR;
	ulong top;
	char *s, *cmdline;
	char **fwenv, **ss;
	int i, j, nxt, len, envno, envsz;
	bd_t *kbd;
	void (*entry)(bd_t *bd, char *cmdline, char **fwenv, ulong top);
	image_header_t *hdr = &header;

	/*
	 * Booting an ARTOS kernel image + application
	 */

	/* this used to be the top of memory, but was wrong... */
#ifdef CONFIG_PPC
	/* get stack pointer */
	asm volatile ("mr %0,1" : "=r"(top) );
#endif
	debug ("## Current stack ends at 0x%08lX ", top);

	top -= 2048;		/* just to be sure */
	if (top > CFG_BOOTMAPSZ)
		top = CFG_BOOTMAPSZ;
	top &= ~0xF;

	debug ("=> set upper limit to 0x%08lX\n", top);

	/* first check the artos specific boot args, then the linux args*/
	if ((s = getenv("abootargs")) == NULL && (s = getenv("bootargs")) == NULL)
		s = "";

	/* get length of cmdline, and place it */
	len = strlen(s);
	top = (top - (len + 1)) & ~0xF;
	cmdline = (char *)top;
	debug ("## cmdline at 0x%08lX ", top);
	strcpy(cmdline, s);

	/* copy bdinfo */
	top = (top - sizeof(bd_t)) & ~0xF;
	debug ("## bd at 0x%08lX ", top);
	kbd = (bd_t *)top;
	memcpy(kbd, gd->bd, sizeof(bd_t));

	/* first find number of env entries, and their size */
	envno = 0;
	envsz = 0;
	for (i = 0; env_get_char(i) != '\0'; i = nxt + 1) {
		for (nxt = i; env_get_char(nxt) != '\0'; ++nxt)
			;
		envno++;
		envsz += (nxt - i) + 1;	/* plus trailing zero */
	}
	envno++;	/* plus the terminating zero */
	debug ("## %u envvars total size %u ", envno, envsz);

	top = (top - sizeof(char **)*envno) & ~0xF;
	fwenv = (char **)top;
	debug ("## fwenv at 0x%08lX ", top);

	top = (top - envsz) & ~0xF;
	s = (char *)top;
	ss = fwenv;

	/* now copy them */
	for (i = 0; env_get_char(i) != '\0'; i = nxt + 1) {
		for (nxt = i; env_get_char(nxt) != '\0'; ++nxt)
			;
		*ss++ = s;
		for (j = i; j < nxt; ++j)
			*s++ = env_get_char(j);
		*s++ = '\0';
	}
	*ss++ = NULL;	/* terminate */

	entry = (void (*)(bd_t *, char *, char **, ulong))ntohl(hdr->ih_ep);
	(*entry)(kbd, cmdline, fwenv, top);
}
#endif


#if (CONFIG_COMMANDS & CFG_CMD_BOOTD)
int do_bootd (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	int rcode = 0;
#ifndef CFG_HUSH_PARSER
	if (run_command (getenv ("bootcmd"), flag) < 0) rcode = 1;
 3f04b90:	e59f0014 	ldr	r0, [pc, #14]	; 3f04bac <do_bootd+0x28>
 3f04b94:	e1a04001 	mov	r4, r1
 3f04b98:	eb001d2f 	bl	3f0c05c <getenv>
 3f04b9c:	e1a01004 	mov	r1, r4
 3f04ba0:	ebfffc99 	bl	3f03e0c <run_command>
#else
	if (parse_string_outer(getenv("bootcmd"),
		FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP) != 0 ) rcode = 1;
#endif
	return rcode;
 3f04ba4:	e1a00fa0 	mov	r0, r0, lsr #31
}
 3f04ba8:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f04bac:	03f1b980 	mvneqs	r11, #2097152	; 0x200000

03f04bb0 <do_iminfo>:
 3f04bb0:	e1a0c00d 	mov	r12, r13
 3f04bb4:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f04bb8:	e24cb004 	sub	r11, r12, #4	; 0x4

U_BOOT_CMD(
 	boot,	1,	1,	do_bootd,
 	"boot    - boot default, i.e., run 'bootcmd'\n",
	NULL
);

/* keep old command name "bootd" for backward compatibility */
U_BOOT_CMD(
 	bootd, 1,	1,	do_bootd,
 	"bootd   - boot default, i.e., run 'bootcmd'\n",
	NULL
);

#endif

#if (CONFIG_COMMANDS & CFG_CMD_IMI)
int do_iminfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	int	arg;
	ulong	addr;
	int     rcode=0;
 3f04bbc:	e3a06000 	mov	r6, #0	; 0x0
 3f04bc0:	e1a04002 	mov	r4, r2

	if (argc < 2) {
 3f04bc4:	e3540001 	cmp	r4, #1	; 0x1
 3f04bc8:	e1a07003 	mov	r7, r3
 3f04bcc:	ca000003 	bgt	3f04be0 <do_iminfo+0x30>
		return image_info (load_addr);
 3f04bd0:	e59f3044 	ldr	r3, [pc, #44]	; 3f04c1c <do_iminfo+0x6c>
 3f04bd4:	e5930000 	ldr	r0, [r3]
 3f04bd8:	eb000010 	bl	3f04c20 <image_info>
 3f04bdc:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	}

	for (arg=1; arg <argc; ++arg) {
 3f04be0:	e3a05001 	mov	r5, #1	; 0x1
 3f04be4:	e1550004 	cmp	r5, r4
 3f04be8:	aa000009 	bge	3f04c14 <do_iminfo+0x64>
		addr = simple_strtoul(argv[arg], NULL, 16);
 3f04bec:	e7970105 	ldr	r0, [r7, r5, lsl #2]
 3f04bf0:	e2855001 	add	r5, r5, #1	; 0x1
 3f04bf4:	e3a01000 	mov	r1, #0	; 0x0
 3f04bf8:	e3a02010 	mov	r2, #16	; 0x10
 3f04bfc:	eb002ad0 	bl	3f0f744 <simple_strtoul>
		if (image_info (addr) != 0) rcode = 1;
 3f04c00:	eb000006 	bl	3f04c20 <image_info>
 3f04c04:	e3500000 	cmp	r0, #0	; 0x0
 3f04c08:	13a06001 	movne	r6, #1	; 0x1
 3f04c0c:	e1550004 	cmp	r5, r4
 3f04c10:	bafffff5 	blt	3f04bec <do_iminfo+0x3c>
	}
	return rcode;
 3f04c14:	e1a00006 	mov	r0, r6
}
 3f04c18:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f04c1c:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000

03f04c20 <image_info>:
 3f04c20:	e1a0c00d 	mov	r12, r13
 3f04c24:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f04c28:	e24cb004 	sub	r11, r12, #4	; 0x4

static int image_info (ulong addr)
{
 3f04c2c:	e1a06000 	mov	r6, r0
	ulong	data, len, checksum;
	image_header_t *hdr = &header;

	printf ("\n## Checking Image at %08lx ...\n", addr);
 3f04c30:	e59f0114 	ldr	r0, [pc, #114]	; 3f04d4c <image_info+0x12c>
 3f04c34:	e1a01006 	mov	r1, r6
 3f04c38:	e59f5110 	ldr	r5, [pc, #110]	; 3f04d50 <image_info+0x130>
 3f04c3c:	eb001f00 	bl	3f0c844 <printf>

	/* Copy header so we can blank CRC field for re-calculation */
	memmove (&header, (char *)addr, sizeof(image_header_t));
 3f04c40:	e1a00005 	mov	r0, r5
 3f04c44:	e1a01006 	mov	r1, r6
 3f04c48:	e3a02040 	mov	r2, #64	; 0x40
 3f04c4c:	eb002a5a 	bl	3f0f5bc <memmove>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04c50:	e5951000 	ldr	r1, [r5]

	if (ntohl(hdr->ih_magic) != IH_MAGIC) {
 3f04c54:	e3a07000 	mov	r7, #0	; 0x0
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04c58:	e2013cff 	and	r3, r1, #65280	; 0xff00
 3f04c5c:	e1a03403 	mov	r3, r3, lsl #8
 3f04c60:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f04c64:	e20128ff 	and	r2, r1, #16711680	; 0xff0000
 3f04c68:	e1833422 	orr	r3, r3, r2, lsr #8
 3f04c6c:	e59f20e0 	ldr	r2, [pc, #e0]	; 3f04d54 <image_info+0x134>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04c70:	e1833c21 	orr	r3, r3, r1, lsr #24
 3f04c74:	e1530002 	cmp	r3, r2
 3f04c78:	0a000003 	beq	3f04c8c <image_info+0x6c>
		printf ("   Bad Magic Number\n");
 3f04c7c:	e59f00d4 	ldr	r0, [pc, #d4]	; 3f04d58 <image_info+0x138>
 3f04c80:	eb001eef 	bl	3f0c844 <printf>
		return 1;
 3f04c84:	e3a00001 	mov	r0, #1	; 0x1
 3f04c88:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	}

	data = (ulong)&header;
	len  = sizeof(image_header_t);

	checksum = ntohl(hdr->ih_hcrc);
	hdr->ih_hcrc = 0;
 3f04c8c:	e1a03007 	mov	r3, r7

	if (crc32 (0, (char *)data, len) != checksum) {
 3f04c90:	e1a00003 	mov	r0, r3
 3f04c94:	e1a01005 	mov	r1, r5
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04c98:	e595c004 	ldr	r12, [r5, #4]
 3f04c9c:	e3a02040 	mov	r2, #64	; 0x40
 3f04ca0:	e5853004 	str	r3, [r5, #4]
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04ca4:	e20c4cff 	and	r4, r12, #65280	; 0xff00
 3f04ca8:	e1a04404 	mov	r4, r4, lsl #8
 3f04cac:	e1844c0c 	orr	r4, r4, r12, lsl #24
 3f04cb0:	e20c38ff 	and	r3, r12, #16711680	; 0xff0000
 3f04cb4:	e1844423 	orr	r4, r4, r3, lsr #8
 3f04cb8:	e1844c2c 	orr	r4, r4, r12, lsr #24
 3f04cbc:	eb00286b 	bl	3f0ee70 <crc32>
 3f04cc0:	e1500004 	cmp	r0, r4
 3f04cc4:	0a000003 	beq	3f04cd8 <image_info+0xb8>
		printf ("   Bad Header Checksum\n");
 3f04cc8:	e59f008c 	ldr	r0, [pc, #8c]	; 3f04d5c <image_info+0x13c>
 3f04ccc:	eb001edc 	bl	3f0c844 <printf>
		return 1;
 3f04cd0:	e3a00001 	mov	r0, #1	; 0x1
 3f04cd4:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	}

	/* for multi-file images we need the data part, too */
	print_image_hdr ((image_header_t *)addr);
 3f04cd8:	e1a00006 	mov	r0, r6
 3f04cdc:	eb000027 	bl	3f04d80 <print_image_hdr>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04ce0:	e595100c 	ldr	r1, [r5, #12]

	data = addr + sizeof(image_header_t);
	len  = ntohl(hdr->ih_size);

	printf ("   Verifying Checksum ... ");
 3f04ce4:	e59f0074 	ldr	r0, [pc, #74]	; 3f04d60 <image_info+0x140>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04ce8:	e2013cff 	and	r3, r1, #65280	; 0xff00
 3f04cec:	e1a03403 	mov	r3, r3, lsl #8
 3f04cf0:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f04cf4:	e20128ff 	and	r2, r1, #16711680	; 0xff0000
 3f04cf8:	e1833422 	orr	r3, r3, r2, lsr #8
 3f04cfc:	e1834c21 	orr	r4, r3, r1, lsr #24
 3f04d00:	eb001ecf 	bl	3f0c844 <printf>
	if (crc32 (0, (char *)data, len) != ntohl(hdr->ih_dcrc)) {
 3f04d04:	e1a00007 	mov	r0, r7
 3f04d08:	e2861040 	add	r1, r6, #64	; 0x40
 3f04d0c:	e1a02004 	mov	r2, r4
 3f04d10:	eb002856 	bl	3f0ee70 <crc32>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04d14:	e5951018 	ldr	r1, [r5, #24]
	return __arch__swab32(x);
 3f04d18:	e2013cff 	and	r3, r1, #65280	; 0xff00
 3f04d1c:	e1a03403 	mov	r3, r3, lsl #8
 3f04d20:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f04d24:	e20128ff 	and	r2, r1, #16711680	; 0xff0000
 3f04d28:	e1833422 	orr	r3, r3, r2, lsr #8
 3f04d2c:	e1833c21 	orr	r3, r3, r1, lsr #24
 3f04d30:	e1500003 	cmp	r0, r3
		printf ("   Bad Data CRC\n");
 3f04d34:	e59f0028 	ldr	r0, [pc, #28]	; 3f04d64 <image_info+0x144>
 3f04d38:	1affffe3 	bne	3f04ccc <image_info+0xac>
		return 1;
	}
	printf ("OK\n");
 3f04d3c:	e59f0024 	ldr	r0, [pc, #24]	; 3f04d68 <image_info+0x148>
 3f04d40:	eb001ebf 	bl	3f0c844 <printf>
	return 0;
 3f04d44:	e1a00007 	mov	r0, r7
}
 3f04d48:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f04d4c:	03f1b9f8 	mvneqs	r11, #4063232	; 0x3e0000
 3f04d50:	03f6cd04 	mvneqs	r12, #256	; 0x100
 3f04d54:	27051956 	undefined
 3f04d58:	03f1ba1c 	mvneqs	r11, #114688	; 0x1c000
 3f04d5c:	03f1ba34 	mvneqs	r11, #212992	; 0x34000
 3f04d60:	03f1b6cc 	mvneqs	r11, #213909504	; 0xcc00000
 3f04d64:	03f1ba4c 	mvneqs	r11, #311296	; 0x4c000
 3f04d68:	03f1b6f8 	mvneqs	r11, #260046848	; 0xf800000

03f04d6c <do_imls>:
 3f04d6c:	e1a0c00d 	mov	r12, r13
 3f04d70:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f04d74:	e24cb004 	sub	r11, r12, #4	; 0x4

U_BOOT_CMD(
	iminfo,	CFG_MAXARGS,	1,	do_iminfo,
	"iminfo  - print header information for application image\n",
	"addr [addr ...]\n"
	"    - print header information for application image starting at\n"
	"      address 'addr' in memory; this includes verification of the\n"
	"      image contents (magic number, header and payload checksums)\n"
);

#endif	/* CFG_CMD_IMI */

#if (CONFIG_COMMANDS & CFG_CMD_IMLS)
/*-----------------------------------------------------------------------
 * List all images found in flash.
 */
int do_imls (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	flash_info_t *info;
	int i, j;
	image_header_t *hdr;
	ulong checksum;

	for (i=0, info=&flash_info[0]; i<CFG_MAX_FLASH_BANKS; ++i, ++info) {
		if (info->flash_id == FLASH_UNKNOWN)
			goto next_bank;
		for (j=0; j<CFG_MAX_FLASH_SECT; ++j) {

			if (!(hdr=(image_header_t *)info->start[j]) ||
			    (ntohl(hdr->ih_magic) != IH_MAGIC))
				goto next_sector;

			/* Copy header so we can blank CRC field for re-calculation */
			memmove (&header, (char *)hdr, sizeof(image_header_t));

			checksum = ntohl(header.ih_hcrc);
			header.ih_hcrc = 0;

			if (crc32 (0, (char *)&header, sizeof(image_header_t))
			    != checksum)
				goto next_sector;

			printf ("Image at %08lX:\n", (ulong)hdr);
			print_image_hdr( hdr );
			putc ('\n');
next_sector:		;
		}
next_bank:	;
	}

	return (0);
 3f04d78:	e3a00000 	mov	r0, #0	; 0x0
}
 3f04d7c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f04d80 <print_image_hdr>:
 3f04d80:	e1a0c00d 	mov	r12, r13
 3f04d84:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f04d88:	e24cb004 	sub	r11, r12, #4	; 0x4

U_BOOT_CMD(
	imls,	1,		1,	do_imls,
	"imls    - list all images found in flash\n",
	"\n"
	"    - Prints information about all images found at sector\n"
	"      boundaries in flash.\n"
);
#endif	/* CFG_CMD_IMLS */

void
print_image_hdr (image_header_t *hdr)
{
#if (CONFIG_COMMANDS & CFG_CMD_DATE) || defined(CONFIG_TIMESTAMP)
	time_t timestamp = (time_t)ntohl(hdr->ih_time);
	struct rtc_time tm;
#endif

	printf ("   Image Name:   %.*s\n", IH_NMLEN, hdr->ih_name);
 3f04d8c:	e3a01020 	mov	r1, #32	; 0x20
 3f04d90:	e1a05000 	mov	r5, r0
 3f04d94:	e24dd030 	sub	r13, r13, #48	; 0x30
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04d98:	e595c008 	ldr	r12, [r5, #8]
 3f04d9c:	e0852001 	add	r2, r5, r1
 3f04da0:	e59f0124 	ldr	r0, [pc, #124]	; 3f04ecc <print_image_hdr+0x14c>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04da4:	e20c4cff 	and	r4, r12, #65280	; 0xff00
 3f04da8:	e1a04404 	mov	r4, r4, lsl #8
 3f04dac:	e1844c0c 	orr	r4, r4, r12, lsl #24
 3f04db0:	e20c38ff 	and	r3, r12, #16711680	; 0xff0000
 3f04db4:	e1844423 	orr	r4, r4, r3, lsr #8
 3f04db8:	e1844c2c 	orr	r4, r4, r12, lsr #24
 3f04dbc:	eb001ea0 	bl	3f0c844 <printf>
#if (CONFIG_COMMANDS & CFG_CMD_DATE) || defined(CONFIG_TIMESTAMP)
	to_tm (timestamp, &tm);
 3f04dc0:	e1a00004 	mov	r0, r4
 3f04dc4:	e24b1040 	sub	r1, r11, #64	; 0x40
 3f04dc8:	eb005593 	bl	3f1a41c <to_tm>
	printf ("   Created:      %4d-%02d-%02d  %2d:%02d:%02d UTC\n",
 3f04dcc:	e51b3038 	ldr	r3, [r11, -#56]
 3f04dd0:	e59f00f8 	ldr	r0, [pc, #f8]	; 3f04ed0 <print_image_hdr+0x150>
 3f04dd4:	e58d3000 	str	r3, [r13]
 3f04dd8:	e51b303c 	ldr	r3, [r11, -#60]
 3f04ddc:	e58d3004 	str	r3, [r13, #4]
 3f04de0:	e51b102c 	ldr	r1, [r11, -#44]
 3f04de4:	e51b2030 	ldr	r2, [r11, -#48]
 3f04de8:	e51bc040 	ldr	r12, [r11, -#64]
 3f04dec:	e51b3034 	ldr	r3, [r11, -#52]
 3f04df0:	e58dc008 	str	r12, [r13, #8]
 3f04df4:	eb001e92 	bl	3f0c844 <printf>
		tm.tm_year, tm.tm_mon, tm.tm_mday,
		tm.tm_hour, tm.tm_min, tm.tm_sec);
#endif	/* CFG_CMD_DATE, CONFIG_TIMESTAMP */
	printf ("   Image Type:   "); print_type(hdr); printf ("\n");
 3f04df8:	e59f00d4 	ldr	r0, [pc, #d4]	; 3f04ed4 <print_image_hdr+0x154>
 3f04dfc:	eb001e90 	bl	3f0c844 <printf>
 3f04e00:	e1a00005 	mov	r0, r5
 3f04e04:	e59f40cc 	ldr	r4, [pc, #cc]	; 3f04ed8 <print_image_hdr+0x158>
 3f04e08:	eb00004a 	bl	3f04f38 <print_type>
 3f04e0c:	e1a00004 	mov	r0, r4
 3f04e10:	eb001e8b 	bl	3f0c844 <printf>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04e14:	e595200c 	ldr	r2, [r5, #12]
	printf ("   Data Size:    %d Bytes = ", ntohl(hdr->ih_size));
 3f04e18:	e59f00bc 	ldr	r0, [pc, #bc]	; 3f04edc <print_image_hdr+0x15c>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04e1c:	e2021cff 	and	r1, r2, #65280	; 0xff00
 3f04e20:	e1a01401 	mov	r1, r1, lsl #8
 3f04e24:	e1811c02 	orr	r1, r1, r2, lsl #24
 3f04e28:	e20238ff 	and	r3, r2, #16711680	; 0xff0000
 3f04e2c:	e1811423 	orr	r1, r1, r3, lsr #8
 3f04e30:	e1811c22 	orr	r1, r1, r2, lsr #24
 3f04e34:	eb001e82 	bl	3f0c844 <printf>
	print_size (ntohl(hdr->ih_size), "\n");
 3f04e38:	e1a07004 	mov	r7, r4
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04e3c:	e595200c 	ldr	r2, [r5, #12]
 3f04e40:	e1a01007 	mov	r1, r7
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04e44:	e2020cff 	and	r0, r2, #65280	; 0xff00
 3f04e48:	e1a00400 	mov	r0, r0, lsl #8
 3f04e4c:	e1800c02 	orr	r0, r0, r2, lsl #24
 3f04e50:	e20238ff 	and	r3, r2, #16711680	; 0xff0000
 3f04e54:	e1800423 	orr	r0, r0, r3, lsr #8
 3f04e58:	e1800c22 	orr	r0, r0, r2, lsr #24
 3f04e5c:	eb00284e 	bl	3f0ef9c <print_size>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04e60:	e5952010 	ldr	r2, [r5, #16]
	printf ("   Load Address: %08x\n", ntohl(hdr->ih_load));
 3f04e64:	e59f0074 	ldr	r0, [pc, #74]	; 3f04ee0 <print_image_hdr+0x160>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04e68:	e2021cff 	and	r1, r2, #65280	; 0xff00
 3f04e6c:	e1a01401 	mov	r1, r1, lsl #8
 3f04e70:	e1811c02 	orr	r1, r1, r2, lsl #24
 3f04e74:	e20238ff 	and	r3, r2, #16711680	; 0xff0000
 3f04e78:	e1811423 	orr	r1, r1, r3, lsr #8
 3f04e7c:	e1811c22 	orr	r1, r1, r2, lsr #24
 3f04e80:	eb001e6f 	bl	3f0c844 <printf>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04e84:	e5952014 	ldr	r2, [r5, #20]
	printf ("   Entry Point:  %08x\n", ntohl(hdr->ih_ep));
 3f04e88:	e59f0054 	ldr	r0, [pc, #54]	; 3f04ee4 <print_image_hdr+0x164>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04e8c:	e2021cff 	and	r1, r2, #65280	; 0xff00
 3f04e90:	e1a01401 	mov	r1, r1, lsl #8
 3f04e94:	e1811c02 	orr	r1, r1, r2, lsl #24
 3f04e98:	e20238ff 	and	r3, r2, #16711680	; 0xff0000
 3f04e9c:	e1811423 	orr	r1, r1, r3, lsr #8
 3f04ea0:	e1811c22 	orr	r1, r1, r2, lsr #24
 3f04ea4:	eb001e66 	bl	3f0c844 <printf>

	if (hdr->ih_type == IH_TYPE_MULTI) {
 3f04ea8:	e5d5301e 	ldrb	r3, [r5, #30]
 3f04eac:	e3530004 	cmp	r3, #4	; 0x4
 3f04eb0:	1a00001f 	bne	3f04f34 <print_image_hdr+0x1b4>
		int i;
		ulong len;
		ulong *len_ptr = (ulong *)((ulong)hdr + sizeof(image_header_t));

		printf ("   Contents:\n");
 3f04eb4:	e59f002c 	ldr	r0, [pc, #2c]	; 3f04ee8 <print_image_hdr+0x168>
 3f04eb8:	e2856040 	add	r6, r5, #64	; 0x40
 3f04ebc:	eb001e60 	bl	3f0c844 <printf>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04ec0:	e5953040 	ldr	r3, [r5, #64]
		for (i=0; (len = ntohl(*len_ptr)); ++i, ++len_ptr) {
 3f04ec4:	e3a05000 	mov	r5, #0	; 0x0
 3f04ec8:	ea000010 	b	3f04f10 <print_image_hdr+0x190>
 3f04ecc:	03f1bc1c 	mvneqs	r11, #7168	; 0x1c00
 3f04ed0:	03f1bc34 	mvneqs	r11, #13312	; 0x3400
 3f04ed4:	03f1bc68 	mvneqs	r11, #26624	; 0x6800
 3f04ed8:	03f1bc7c 	mvneqs	r11, #31744	; 0x7c00
 3f04edc:	03f1bc80 	mvneqs	r11, #32768	; 0x8000
 3f04ee0:	03f1bca0 	mvneqs	r11, #40960	; 0xa000
 3f04ee4:	03f1bcb8 	mvneqs	r11, #47104	; 0xb800
 3f04ee8:	03f1bcd0 	mvneqs	r11, #53248	; 0xd000
			printf ("   Image %d: %8ld Bytes = ", i, len);
 3f04eec:	e1a01005 	mov	r1, r5
 3f04ef0:	e59f0034 	ldr	r0, [pc, #34]	; 3f04f2c <print_image_hdr+0x1ac>
 3f04ef4:	e1a02004 	mov	r2, r4
 3f04ef8:	eb001e51 	bl	3f0c844 <printf>
			print_size (len, "\n");
 3f04efc:	e1a00004 	mov	r0, r4
 3f04f00:	e1a01007 	mov	r1, r7
 3f04f04:	eb002824 	bl	3f0ef9c <print_size>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f04f08:	e5b63004 	ldr	r3, [r6, #4]!
 3f04f0c:	e2855001 	add	r5, r5, #1	; 0x1
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f04f10:	e2032cff 	and	r2, r3, #65280	; 0xff00
 3f04f14:	e1a02402 	mov	r2, r2, lsl #8
 3f04f18:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f04f1c:	e20318ff 	and	r1, r3, #16711680	; 0xff0000
 3f04f20:	e1822421 	orr	r2, r2, r1, lsr #8
 3f04f24:	e1924c23 	orrs	r4, r2, r3, lsr #24
 3f04f28:	ea000000 	b	3f04f30 <print_image_hdr+0x1b0>
 3f04f2c:	03f1bce0 	mvneqs	r11, #57344	; 0xe000
 3f04f30:	1affffed 	bne	3f04eec <print_image_hdr+0x16c>
		}
	}
}
 3f04f34:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}

03f04f38 <print_type>:
 3f04f38:	e1a0c00d 	mov	r12, r13
 3f04f3c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f04f40:	e24dd004 	sub	r13, r13, #4	; 0x4


static void
print_type (image_header_t *hdr)
{
	char *os, *arch, *type, *comp;

	switch (hdr->ih_os) {
 3f04f44:	e5d0301c 	ldrb	r3, [r0, #28]
 3f04f48:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f04f4c:	e3530012 	cmp	r3, #18	; 0x12
 3f04f50:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f04f54:	ea000020 	b	3f04fdc <print_type+0xa4>
 3f04f58:	03f04fa4 	mvneqs	r4, #656	; 0x290
 3f04f5c:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f60:	03f04fac 	mvneqs	r4, #688	; 0x2b0
 3f04f64:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f68:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f6c:	03f04fb4 	mvneqs	r4, #720	; 0x2d0
 3f04f70:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f74:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f78:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f7c:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f80:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f84:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f88:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f8c:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f90:	03f04fbc 	mvneqs	r4, #752	; 0x2f0
 3f04f94:	03f04fdc 	mvneqs	r4, #880	; 0x370
 3f04f98:	03f04fc4 	mvneqs	r4, #784	; 0x310
 3f04f9c:	03f04fcc 	mvneqs	r4, #816	; 0x330
 3f04fa0:	03f04fd4 	mvneqs	r4, #848	; 0x350
	case IH_OS_INVALID:	os = "Invalid OS";		break;
 3f04fa4:	e59f218c 	ldr	r2, [pc, #18c]	; 3f05138 <print_type+0x200>
 3f04fa8:	ea00000c 	b	3f04fe0 <print_type+0xa8>
	case IH_OS_NETBSD:	os = "NetBSD";			break;
 3f04fac:	e59f2188 	ldr	r2, [pc, #188]	; 3f0513c <print_type+0x204>
 3f04fb0:	ea00000a 	b	3f04fe0 <print_type+0xa8>
	case IH_OS_LINUX:	os = "Linux";			break;
 3f04fb4:	e59f2184 	ldr	r2, [pc, #184]	; 3f05140 <print_type+0x208>
 3f04fb8:	ea000008 	b	3f04fe0 <print_type+0xa8>
	case IH_OS_VXWORKS:	os = "VxWorks";			break;
 3f04fbc:	e59f2180 	ldr	r2, [pc, #180]	; 3f05144 <print_type+0x20c>
 3f04fc0:	ea000006 	b	3f04fe0 <print_type+0xa8>
	case IH_OS_QNX:		os = "QNX";			break;
 3f04fc4:	e59f217c 	ldr	r2, [pc, #17c]	; 3f05148 <print_type+0x210>
 3f04fc8:	ea000004 	b	3f04fe0 <print_type+0xa8>
	case IH_OS_U_BOOT:	os = "U-Boot";			break;
 3f04fcc:	e59f2178 	ldr	r2, [pc, #178]	; 3f0514c <print_type+0x214>
 3f04fd0:	ea000002 	b	3f04fe0 <print_type+0xa8>
	case IH_OS_RTEMS:	os = "RTEMS";			break;
 3f04fd4:	e59f2174 	ldr	r2, [pc, #174]	; 3f05150 <print_type+0x218>
 3f04fd8:	ea000000 	b	3f04fe0 <print_type+0xa8>
#ifdef CONFIG_ARTOS
	case IH_OS_ARTOS:	os = "ARTOS";			break;
#endif
#ifdef CONFIG_LYNXKDI
	case IH_OS_LYNXOS:	os = "LynxOS";			break;
#endif
	default:		os = "Unknown OS";		break;
 3f04fdc:	e59f2170 	ldr	r2, [pc, #170]	; 3f05154 <print_type+0x21c>
	}

	switch (hdr->ih_arch) {
 3f04fe0:	e5d0301d 	ldrb	r3, [r0, #29]
 3f04fe4:	e353000c 	cmp	r3, #12	; 0xc
 3f04fe8:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f04fec:	ea000026 	b	3f0508c <print_type+0x154>
 3f04ff0:	03f05024 	mvneqs	r5, #36	; 0x24
 3f04ff4:	03f0502c 	mvneqs	r5, #44	; 0x2c
 3f04ff8:	03f05034 	mvneqs	r5, #52	; 0x34
 3f04ffc:	03f0503c 	mvneqs	r5, #60	; 0x3c
 3f05000:	03f05044 	mvneqs	r5, #68	; 0x44
 3f05004:	03f0504c 	mvneqs	r5, #76	; 0x4c
 3f05008:	03f05054 	mvneqs	r5, #84	; 0x54
 3f0500c:	03f0505c 	mvneqs	r5, #92	; 0x5c
 3f05010:	03f05064 	mvneqs	r5, #100	; 0x64
 3f05014:	03f0506c 	mvneqs	r5, #108	; 0x6c
 3f05018:	03f05074 	mvneqs	r5, #116	; 0x74
 3f0501c:	03f0507c 	mvneqs	r5, #124	; 0x7c
 3f05020:	03f05084 	mvneqs	r5, #132	; 0x84
	case IH_CPU_INVALID:	arch = "Invalid CPU";		break;
 3f05024:	e59f112c 	ldr	r1, [pc, #12c]	; 3f05158 <print_type+0x220>
 3f05028:	ea000018 	b	3f05090 <print_type+0x158>
	case IH_CPU_ALPHA:	arch = "Alpha";			break;
 3f0502c:	e59f1128 	ldr	r1, [pc, #128]	; 3f0515c <print_type+0x224>
 3f05030:	ea000016 	b	3f05090 <print_type+0x158>
	case IH_CPU_ARM:	arch = "ARM";			break;
 3f05034:	e59f1124 	ldr	r1, [pc, #124]	; 3f05160 <print_type+0x228>
 3f05038:	ea000014 	b	3f05090 <print_type+0x158>
	case IH_CPU_I386:	arch = "Intel x86";		break;
 3f0503c:	e59f1120 	ldr	r1, [pc, #120]	; 3f05164 <print_type+0x22c>
 3f05040:	ea000012 	b	3f05090 <print_type+0x158>
	case IH_CPU_IA64:	arch = "IA64";			break;
 3f05044:	e59f111c 	ldr	r1, [pc, #11c]	; 3f05168 <print_type+0x230>
 3f05048:	ea000010 	b	3f05090 <print_type+0x158>
	case IH_CPU_MIPS:	arch = "MIPS";			break;
 3f0504c:	e59f1118 	ldr	r1, [pc, #118]	; 3f0516c <print_type+0x234>
 3f05050:	ea00000e 	b	3f05090 <print_type+0x158>
	case IH_CPU_MIPS64:	arch = "MIPS 64 Bit";		break;
 3f05054:	e59f1114 	ldr	r1, [pc, #114]	; 3f05170 <print_type+0x238>
 3f05058:	ea00000c 	b	3f05090 <print_type+0x158>
	case IH_CPU_PPC:	arch = "PowerPC";		break;
 3f0505c:	e59f1110 	ldr	r1, [pc, #110]	; 3f05174 <print_type+0x23c>
 3f05060:	ea00000a 	b	3f05090 <print_type+0x158>
	case IH_CPU_S390:	arch = "IBM S390";		break;
 3f05064:	e59f110c 	ldr	r1, [pc, #10c]	; 3f05178 <print_type+0x240>
 3f05068:	ea000008 	b	3f05090 <print_type+0x158>
	case IH_CPU_SH:		arch = "SuperH";		break;
 3f0506c:	e59f1108 	ldr	r1, [pc, #108]	; 3f0517c <print_type+0x244>
 3f05070:	ea000006 	b	3f05090 <print_type+0x158>
	case IH_CPU_SPARC:	arch = "SPARC";			break;
 3f05074:	e59f1104 	ldr	r1, [pc, #104]	; 3f05180 <print_type+0x248>
 3f05078:	ea000004 	b	3f05090 <print_type+0x158>
	case IH_CPU_SPARC64:	arch = "SPARC 64 Bit";		break;
 3f0507c:	e59f1100 	ldr	r1, [pc, #100]	; 3f05184 <print_type+0x24c>
 3f05080:	ea000002 	b	3f05090 <print_type+0x158>
	case IH_CPU_M68K:	arch = "M68K"; 			break;
 3f05084:	e59f10fc 	ldr	r1, [pc, #fc]	; 3f05188 <print_type+0x250>
 3f05088:	ea000000 	b	3f05090 <print_type+0x158>
	default:		arch = "Unknown Architecture";	break;
 3f0508c:	e59f10f8 	ldr	r1, [pc, #f8]	; 3f0518c <print_type+0x254>
	}

	switch (hdr->ih_type) {
 3f05090:	e5d0301e 	ldrb	r3, [r0, #30]
 3f05094:	e3530006 	cmp	r3, #6	; 0x6
 3f05098:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f0509c:	ea000014 	b	3f050f4 <print_type+0x1bc>
 3f050a0:	03f050bc 	mvneqs	r5, #188	; 0xbc
 3f050a4:	03f050c4 	mvneqs	r5, #196	; 0xc4
 3f050a8:	03f050cc 	mvneqs	r5, #204	; 0xcc
 3f050ac:	03f050d4 	mvneqs	r5, #212	; 0xd4
 3f050b0:	03f050dc 	mvneqs	r5, #220	; 0xdc
 3f050b4:	03f050e4 	mvneqs	r5, #228	; 0xe4
 3f050b8:	03f050ec 	mvneqs	r5, #236	; 0xec
	case IH_TYPE_INVALID:	type = "Invalid Image";		break;
 3f050bc:	e59f30cc 	ldr	r3, [pc, #cc]	; 3f05190 <print_type+0x258>
 3f050c0:	ea00000c 	b	3f050f8 <print_type+0x1c0>
	case IH_TYPE_STANDALONE:type = "Standalone Program";	break;
 3f050c4:	e59f30c8 	ldr	r3, [pc, #c8]	; 3f05194 <print_type+0x25c>
 3f050c8:	ea00000a 	b	3f050f8 <print_type+0x1c0>
	case IH_TYPE_KERNEL:	type = "Kernel Image";		break;
 3f050cc:	e59f30c4 	ldr	r3, [pc, #c4]	; 3f05198 <print_type+0x260>
 3f050d0:	ea000008 	b	3f050f8 <print_type+0x1c0>
	case IH_TYPE_RAMDISK:	type = "RAMDisk Image";		break;
 3f050d4:	e59f30c0 	ldr	r3, [pc, #c0]	; 3f0519c <print_type+0x264>
 3f050d8:	ea000006 	b	3f050f8 <print_type+0x1c0>
	case IH_TYPE_MULTI:	type = "Multi-File Image";	break;
 3f050dc:	e59f30bc 	ldr	r3, [pc, #bc]	; 3f051a0 <print_type+0x268>
 3f050e0:	ea000004 	b	3f050f8 <print_type+0x1c0>
	case IH_TYPE_FIRMWARE:	type = "Firmware";		break;
 3f050e4:	e59f30b8 	ldr	r3, [pc, #b8]	; 3f051a4 <print_type+0x26c>
 3f050e8:	ea000002 	b	3f050f8 <print_type+0x1c0>
	case IH_TYPE_SCRIPT:	type = "Script";		break;
 3f050ec:	e59f30b4 	ldr	r3, [pc, #b4]	; 3f051a8 <print_type+0x270>
 3f050f0:	ea000000 	b	3f050f8 <print_type+0x1c0>
	default:		type = "Unknown Image";		break;
 3f050f4:	e59f30b0 	ldr	r3, [pc, #b0]	; 3f051ac <print_type+0x274>
	}

	switch (hdr->ih_comp) {
 3f050f8:	e5d0001f 	ldrb	r0, [r0, #31]
 3f050fc:	e3500001 	cmp	r0, #1	; 0x1
 3f05100:	0a000008 	beq	3f05128 <print_type+0x1f0>
 3f05104:	ca000002 	bgt	3f05114 <print_type+0x1dc>
 3f05108:	e3500000 	cmp	r0, #0	; 0x0
 3f0510c:	0a000003 	beq	3f05120 <print_type+0x1e8>
 3f05110:	ea000029 	b	3f051bc <print_type+0x284>
 3f05114:	e3500002 	cmp	r0, #2	; 0x2
 3f05118:	0a000004 	beq	3f05130 <print_type+0x1f8>
 3f0511c:	ea000026 	b	3f051bc <print_type+0x284>
	case IH_COMP_NONE:	comp = "uncompressed";		break;
 3f05120:	e59f0088 	ldr	r0, [pc, #88]	; 3f051b0 <print_type+0x278>
 3f05124:	ea000025 	b	3f051c0 <print_type+0x288>
	case IH_COMP_GZIP:	comp = "gzip compressed";	break;
 3f05128:	e59f0084 	ldr	r0, [pc, #84]	; 3f051b4 <print_type+0x27c>
 3f0512c:	ea000023 	b	3f051c0 <print_type+0x288>
	case IH_COMP_BZIP2:	comp = "bzip2 compressed";	break;
 3f05130:	e59f0080 	ldr	r0, [pc, #80]	; 3f051b8 <print_type+0x280>
 3f05134:	ea000021 	b	3f051c0 <print_type+0x288>
 3f05138:	03f1bcfc 	mvneqs	r11, #64512	; 0xfc00
 3f0513c:	03f1bd08 	mvneqs	r11, #512	; 0x200
 3f05140:	03f1bd10 	mvneqs	r11, #1024	; 0x400
 3f05144:	03f1bd18 	mvneqs	r11, #1536	; 0x600
 3f05148:	03f1bd20 	mvneqs	r11, #2048	; 0x800
 3f0514c:	03f1bd24 	mvneqs	r11, #2304	; 0x900
 3f05150:	03f1bd2c 	mvneqs	r11, #2816	; 0xb00
 3f05154:	03f1bd34 	mvneqs	r11, #3328	; 0xd00
 3f05158:	03f1bd40 	mvneqs	r11, #4096	; 0x1000
 3f0515c:	03f1bd4c 	mvneqs	r11, #4864	; 0x1300
 3f05160:	03f1bd54 	mvneqs	r11, #5376	; 0x1500
 3f05164:	03f1bd58 	mvneqs	r11, #5632	; 0x1600
 3f05168:	03f1bd64 	mvneqs	r11, #6400	; 0x1900
 3f0516c:	03f1bd6c 	mvneqs	r11, #6912	; 0x1b00
 3f05170:	03f1bd74 	mvneqs	r11, #7424	; 0x1d00
 3f05174:	03f1bd80 	mvneqs	r11, #8192	; 0x2000
 3f05178:	03f1bd88 	mvneqs	r11, #8704	; 0x2200
 3f0517c:	03f1bd94 	mvneqs	r11, #9472	; 0x2500
 3f05180:	03f1bd9c 	mvneqs	r11, #9984	; 0x2700
 3f05184:	03f1bda4 	mvneqs	r11, #10496	; 0x2900
 3f05188:	03f1bdb4 	mvneqs	r11, #11520	; 0x2d00
 3f0518c:	03f1bdbc 	mvneqs	r11, #12032	; 0x2f00
 3f05190:	03f1bdd4 	mvneqs	r11, #13568	; 0x3500
 3f05194:	03f1bde4 	mvneqs	r11, #14592	; 0x3900
 3f05198:	03f1b734 	mvneqs	r11, #13631488	; 0xd00000
 3f0519c:	03f1bdf8 	mvneqs	r11, #15872	; 0x3e00
 3f051a0:	03f1b744 	mvneqs	r11, #17825792	; 0x1100000
 3f051a4:	03f1be08 	mvneqs	r11, #128	; 0x80
 3f051a8:	03f1be14 	mvneqs	r11, #320	; 0x140
 3f051ac:	03f1be1c 	mvneqs	r11, #448	; 0x1c0
 3f051b0:	03f1be2c 	mvneqs	r11, #704	; 0x2c0
 3f051b4:	03f1be3c 	mvneqs	r11, #960	; 0x3c0
 3f051b8:	03f1be4c 	mvneqs	r11, #1216	; 0x4c0
	default:		comp = "unknown compression";	break;
 3f051bc:	e59f000c 	ldr	r0, [pc, #c]	; 3f051d0 <print_type+0x298>
	}

	printf ("%s %s %s (%s)", arch, os, type, comp);
 3f051c0:	e58d0000 	str	r0, [r13]
 3f051c4:	e59f0008 	ldr	r0, [pc, #8]	; 3f051d4 <print_type+0x29c>
 3f051c8:	eb001d9d 	bl	3f0c844 <printf>
 3f051cc:	ea000001 	b	3f051d8 <print_type+0x2a0>
 3f051d0:	03f1be60 	mvneqs	r11, #1536	; 0x600
 3f051d4:	03f1be74 	mvneqs	r11, #1856	; 0x740
}
 3f051d8:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f051dc <zalloc>:

#define	ZALLOC_ALIGNMENT	16

static void *zalloc(void *x, unsigned items, unsigned size)
{
	void *p;

	size *= items;
 3f051dc:	e0000291 	mul	r0, r1, r2
 3f051e0:	e1a0c00d 	mov	r12, r13
 3f051e4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f051e8:	e24cb004 	sub	r11, r12, #4	; 0x4
	size = (size + ZALLOC_ALIGNMENT - 1) & ~(ZALLOC_ALIGNMENT - 1);
 3f051ec:	e280000f 	add	r0, r0, #15	; 0xf

	p = malloc (size);
 3f051f0:	e3c0000f 	bic	r0, r0, #15	; 0xf
 3f051f4:	eb001f45 	bl	3f0cf10 <malloc>

	return (p);
}
 3f051f8:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f051fc <zfree>:
 3f051fc:	e1a0c00d 	mov	r12, r13
 3f05200:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f05204:	e24cb004 	sub	r11, r12, #4	; 0x4

static void zfree(void *x, void *addr, unsigned nb)
{
	free (addr);
 3f05208:	e1a00001 	mov	r0, r1
 3f0520c:	eb002053 	bl	3f0d360 <free>
 3f05210:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f05214 <gunzip>:
 3f05214:	e1a0c00d 	mov	r12, r13
 3f05218:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0521c:	e24cb004 	sub	r11, r12, #4	; 0x4
}

#define HEAD_CRC	2
#define EXTRA_FIELD	4
#define ORIG_NAME	8
#define COMMENT		0x10
#define RESERVED	0xe0

#define DEFLATED	8

int gunzip(void *dst, int dstlen, unsigned char *src, int *lenp)
{
 3f05220:	e1a04002 	mov	r4, r2
	z_stream s;
	int r, i, flags;

	/* skip header */
	i = 10;
 3f05224:	e3a0500a 	mov	r5, #10	; 0xa
 3f05228:	e24dd038 	sub	r13, r13, #56	; 0x38
	flags = src[3];
	if (src[2] != DEFLATED || (flags & RESERVED) != 0) {
 3f0522c:	e5d42002 	ldrb	r2, [r4, #2]
 3f05230:	e1a0a000 	mov	r10, r0
 3f05234:	e50b105c 	str	r1, [r11, -#92]
 3f05238:	e1a07003 	mov	r7, r3
 3f0523c:	e5d41003 	ldrb	r1, [r4, #3]
 3f05240:	e3520008 	cmp	r2, #8	; 0x8
 3f05244:	1a000001 	bne	3f05250 <gunzip+0x3c>
 3f05248:	e31100e0 	tst	r1, #224	; 0xe0
 3f0524c:	0a000002 	beq	3f0525c <gunzip+0x48>
		printf ("Error: Bad gzipped data\n");
 3f05250:	e59f00fc 	ldr	r0, [pc, #fc]	; 3f05354 <gunzip+0x140>
 3f05254:	eb001d7a 	bl	3f0c844 <printf>
		return (-1);
 3f05258:	ea000044 	b	3f05370 <gunzip+0x15c>
	}
	if ((flags & EXTRA_FIELD) != 0)
 3f0525c:	e3110004 	tst	r1, #4	; 0x4
		i = 12 + src[10] + (src[11] << 8);
 3f05260:	15d4300b 	ldrneb	r3, [r4, #11]
 3f05264:	15d4200a 	ldrneb	r2, [r4, #10]
 3f05268:	11a03403 	movne	r3, r3, lsl #8
 3f0526c:	1283300c 	addne	r3, r3, #12	; 0xc
 3f05270:	10825003 	addne	r5, r2, r3
	if ((flags & ORIG_NAME) != 0)
 3f05274:	e3110008 	tst	r1, #8	; 0x8
 3f05278:	0a000003 	beq	3f0528c <gunzip+0x78>
		while (src[i++] != 0)
 3f0527c:	e7d43005 	ldrb	r3, [r4, r5]
 3f05280:	e2855001 	add	r5, r5, #1	; 0x1
 3f05284:	e3530000 	cmp	r3, #0	; 0x0
 3f05288:	1afffffb 	bne	3f0527c <gunzip+0x68>
			;
	if ((flags & COMMENT) != 0)
 3f0528c:	e3110010 	tst	r1, #16	; 0x10
 3f05290:	0a000003 	beq	3f052a4 <gunzip+0x90>
		while (src[i++] != 0)
 3f05294:	e7d43005 	ldrb	r3, [r4, r5]
 3f05298:	e2855001 	add	r5, r5, #1	; 0x1
 3f0529c:	e3530000 	cmp	r3, #0	; 0x0
 3f052a0:	1afffffb 	bne	3f05294 <gunzip+0x80>
			;
	if ((flags & HEAD_CRC) != 0)
		i += 2;
 3f052a4:	e2013002 	and	r3, r1, #2	; 0x2
	if (i >= *lenp) {
 3f052a8:	e5972000 	ldr	r2, [r7]
 3f052ac:	e0835005 	add	r5, r3, r5
 3f052b0:	e1550002 	cmp	r5, r2
 3f052b4:	ba000002 	blt	3f052c4 <gunzip+0xb0>
		printf ("Error: gunzip out of data in header\n");
 3f052b8:	e59f0098 	ldr	r0, [pc, #98]	; 3f05358 <gunzip+0x144>
 3f052bc:	eb001d60 	bl	3f0c844 <printf>
		return (-1);
 3f052c0:	ea00002a 	b	3f05370 <gunzip+0x15c>
	}

	s.zalloc = zalloc;
	s.zfree = zfree;
#if defined(CONFIG_HW_WATCHDOG) || defined(CONFIG_WATCHDOG)
	s.outcb = (cb_func)WATCHDOG_RESET;
#else
	s.outcb = Z_NULL;
 3f052c4:	e3a09000 	mov	r9, #0	; 0x0
 3f052c8:	e50b9028 	str	r9, [r11, -#40]
 3f052cc:	e59f3088 	ldr	r3, [pc, #88]	; 3f0535c <gunzip+0x148>
#endif	/* CONFIG_HW_WATCHDOG */

	r = inflateInit2(&s, -MAX_WBITS);
 3f052d0:	e24b6058 	sub	r6, r11, #88	; 0x58
 3f052d4:	e50b3038 	str	r3, [r11, -#56]
 3f052d8:	e1a00006 	mov	r0, r6
 3f052dc:	e59f307c 	ldr	r3, [pc, #7c]	; 3f05360 <gunzip+0x14c>
 3f052e0:	e3e0100e 	mvn	r1, #14	; 0xe
 3f052e4:	e50b3034 	str	r3, [r11, -#52]
 3f052e8:	eb002ba5 	bl	3f10184 <inflateInit2>
	if (r != Z_OK) {
 3f052ec:	e2501000 	subs	r1, r0, #0	; 0x0
 3f052f0:	0a000002 	beq	3f05300 <gunzip+0xec>
		printf ("Error: inflateInit2() returned %d\n", r);
 3f052f4:	e59f0068 	ldr	r0, [pc, #68]	; 3f05364 <gunzip+0x150>
 3f052f8:	eb001d51 	bl	3f0c844 <printf>
		return (-1);
 3f052fc:	ea00001b 	b	3f05370 <gunzip+0x15c>
	}
	s.next_in = src + i;
 3f05300:	e0843005 	add	r3, r4, r5
 3f05304:	e50b3058 	str	r3, [r11, -#88]
	s.avail_in = *lenp - i;
	s.next_out = dst;
 3f05308:	e50ba04c 	str	r10, [r11, -#76]
	s.avail_out = dstlen;
 3f0530c:	e51b205c 	ldr	r2, [r11, -#92]
	r = inflate(&s, Z_FINISH);
 3f05310:	e1a00006 	mov	r0, r6
 3f05314:	e5973000 	ldr	r3, [r7]
 3f05318:	e3a01004 	mov	r1, #4	; 0x4
 3f0531c:	e50b2048 	str	r2, [r11, -#72]
 3f05320:	e0653003 	rsb	r3, r5, r3
 3f05324:	e50b3054 	str	r3, [r11, -#84]
 3f05328:	eb002bd3 	bl	3f1027c <inflate>
 3f0532c:	e1a01000 	mov	r1, r0
	if (r != Z_OK && r != Z_STREAM_END) {
 3f05330:	e3510001 	cmp	r1, #1	; 0x1
 3f05334:	8a00000b 	bhi	3f05368 <gunzip+0x154>
		printf ("Error: inflate() returned %d\n", r);
		return (-1);
	}
	*lenp = s.next_out - (unsigned char *) dst;
 3f05338:	e51b304c 	ldr	r3, [r11, -#76]
	inflateEnd(&s);
 3f0533c:	e1a00006 	mov	r0, r6
 3f05340:	e06a3003 	rsb	r3, r10, r3
 3f05344:	e5873000 	str	r3, [r7]
 3f05348:	eb002b70 	bl	3f10110 <inflateEnd>

	return (0);
 3f0534c:	e1a00009 	mov	r0, r9
 3f05350:	ea000007 	b	3f05374 <gunzip+0x160>
 3f05354:	03f1be84 	mvneqs	r11, #2112	; 0x840
 3f05358:	03f1bea0 	mvneqs	r11, #2560	; 0xa00
 3f0535c:	03f051dc 	mvneqs	r5, #55	; 0x37
 3f05360:	03f051fc 	mvneqs	r5, #63	; 0x3f
 3f05364:	03f1bec8 	mvneqs	r11, #3200	; 0xc80
 3f05368:	e59f0008 	ldr	r0, [pc, #8]	; 3f05378 <gunzip+0x164>
 3f0536c:	eb001d34 	bl	3f0c844 <printf>
 3f05370:	e3e00000 	mvn	r0, #0	; 0x0
 3f05374:	ea000000 	b	3f0537c <gunzip+0x168>
 3f05378:	03f1beec 	mvneqs	r11, #3776	; 0xec0
}
 3f0537c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f05380 <do_bootm_rtems>:
 3f05380:	e1a0c00d 	mov	r12, r13
 3f05384:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}

#ifdef CONFIG_BZIP2
void bz_internal_error(int errcode)
{
	printf ("BZIP2 internal error %d\n", errcode);
}
#endif /* CONFIG_BZIP2 */

static void
do_bootm_rtems (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
		ulong addr, ulong *len_ptr, int verify)
{
	DECLARE_GLOBAL_DATA_PTR;
	image_header_t *hdr = &header;
 3f05388:	e59f3020 	ldr	r3, [pc, #20]	; 3f053b0 <do_bootm_rtems+0x30>
	void	(*entry_point)(bd_t *);

	entry_point = (void (*)(bd_t *)) hdr->ih_ep;
 3f0538c:	e5934014 	ldr	r4, [r3, #20]
 3f05390:	e24cb004 	sub	r11, r12, #4	; 0x4

	printf ("## Transferring control to RTEMS (at address %08lx) ...\n",
 3f05394:	e59f0018 	ldr	r0, [pc, #18]	; 3f053b4 <do_bootm_rtems+0x34>
 3f05398:	e1a01004 	mov	r1, r4
 3f0539c:	eb001d28 	bl	3f0c844 <printf>
		(ulong)entry_point);

	SHOW_BOOT_PROGRESS (15);

	/*
	 * RTEMS Parameters:
	 *   r3: ptr to board info data
	 */

	(*entry_point ) ( gd->bd );
 3f053a0:	e5980000 	ldr	r0, [r8]
 3f053a4:	e1a0e00f 	mov	r14, r15
 3f053a8:	e1a0f004 	mov	r15, r4
}
 3f053ac:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f053b0:	03f6cd04 	mvneqs	r12, #256	; 0x100
 3f053b4:	03f1bf0c 	mvneqs	r11, #48	; 0x30

03f053b8 <do_bootm_vxworks>:
 3f053b8:	e1a0c00d 	mov	r12, r13
 3f053bc:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f053c0:	e24cb004 	sub	r11, r12, #4	; 0x4

#if (CONFIG_COMMANDS & CFG_CMD_ELF)
static void
do_bootm_vxworks (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
		  ulong addr, ulong *len_ptr, int verify)
{
 3f053c4:	e1a05000 	mov	r5, r0
	image_header_t *hdr = &header;
	char str[80];

	sprintf(str, "%x", hdr->ih_ep); /* write entry-point into string */
 3f053c8:	e59f1038 	ldr	r1, [pc, #38]	; 3f05408 <do_bootm_vxworks+0x50>
 3f053cc:	e24b4064 	sub	r4, r11, #100	; 0x64
 3f053d0:	e59f3034 	ldr	r3, [pc, #34]	; 3f0540c <do_bootm_vxworks+0x54>
 3f053d4:	e24dd050 	sub	r13, r13, #80	; 0x50
 3f053d8:	e5932014 	ldr	r2, [r3, #20]
 3f053dc:	e1a00004 	mov	r0, r4
 3f053e0:	eb002b15 	bl	3f1003c <sprintf>
	setenv("loadaddr", str);
 3f053e4:	e59f0024 	ldr	r0, [pc, #24]	; 3f05410 <do_bootm_vxworks+0x58>
 3f053e8:	e1a01004 	mov	r1, r4
 3f053ec:	eb001af9 	bl	3f0bfd8 <setenv>
	do_bootvx(cmdtp, 0, 0, NULL);
 3f053f0:	e1a00005 	mov	r0, r5
 3f053f4:	e3a01000 	mov	r1, #0	; 0x0
 3f053f8:	e1a02001 	mov	r2, r1
 3f053fc:	e1a03001 	mov	r3, r1
 3f05400:	eb0001b9 	bl	3f05aec <do_bootvx>
 3f05404:	ea000002 	b	3f05414 <do_bootm_vxworks+0x5c>
 3f05408:	03f1bf48 	mvneqs	r11, #288	; 0x120
 3f0540c:	03f6cd04 	mvneqs	r12, #256	; 0x100
 3f05410:	03f1bf4c 	mvneqs	r11, #304	; 0x130
}
 3f05414:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f05418 <do_bootm_qnxelf>:
 3f05418:	e1a0c00d 	mov	r12, r13
 3f0541c:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f05420:	e24cb004 	sub	r11, r12, #4	; 0x4

static void
do_bootm_qnxelf (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[],
		 ulong addr, ulong *len_ptr, int verify)
{
 3f05424:	e1a06000 	mov	r6, r0
	image_header_t *hdr = &header;
	char *local_args[2];
	char str[16];

	sprintf(str, "%x", hdr->ih_ep); /* write entry-point into string */
 3f05428:	e24b4028 	sub	r4, r11, #40	; 0x28
 3f0542c:	e59f1038 	ldr	r1, [pc, #38]	; 3f0546c <do_bootm_qnxelf+0x54>
 3f05430:	e1a00004 	mov	r0, r4
 3f05434:	e59f2034 	ldr	r2, [pc, #34]	; 3f05470 <do_bootm_qnxelf+0x58>
 3f05438:	e24dd018 	sub	r13, r13, #24	; 0x18
 3f0543c:	e5922014 	ldr	r2, [r2, #20]
 3f05440:	e1a05003 	mov	r5, r3
 3f05444:	eb002afc 	bl	3f1003c <sprintf>
	local_args[0] = argv[0];
	local_args[1] = str;	/* and provide it via the arguments */
	do_bootelf(cmdtp, 0, 2, local_args);
 3f05448:	e1a00006 	mov	r0, r6
 3f0544c:	e50b402c 	str	r4, [r11, -#44]
 3f05450:	e3a01000 	mov	r1, #0	; 0x0
 3f05454:	e5953000 	ldr	r3, [r5]
 3f05458:	e3a02002 	mov	r2, #2	; 0x2
 3f0545c:	e50b3030 	str	r3, [r11, -#48]
 3f05460:	e24b3030 	sub	r3, r11, #48	; 0x30
 3f05464:	eb000174 	bl	3f05a3c <do_bootelf>
 3f05468:	ea000001 	b	3f05474 <do_bootm_qnxelf+0x5c>
 3f0546c:	03f1bf48 	mvneqs	r11, #288	; 0x120
 3f05470:	03f6cd04 	mvneqs	r12, #256	; 0x100
}
 3f05474:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f05478 <do_icache>:
 3f05478:	e1a0c00d 	mov	r12, r13
 3f0547c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f05480:	e24cb004 	sub	r11, r12, #4	; 0x4
static int on_off (const char *);

int do_icache ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	switch (argc) {
 3f05484:	e3520001 	cmp	r2, #1	; 0x1
 3f05488:	e1a01000 	mov	r1, r0
 3f0548c:	0a00000b 	beq	3f054c0 <do_icache+0x48>
 3f05490:	e3520002 	cmp	r2, #2	; 0x2
 3f05494:	1a000012 	bne	3f054e4 <do_icache+0x6c>
	case 2:			/* on / off	*/
		switch (on_off(argv[1])) {
 3f05498:	e5930004 	ldr	r0, [r3, #4]
 3f0549c:	eb00003d 	bl	3f05598 <on_off>
 3f054a0:	e3500000 	cmp	r0, #0	; 0x0
 3f054a4:	0a000002 	beq	3f054b4 <do_icache+0x3c>
 3f054a8:	e3500001 	cmp	r0, #1	; 0x1
 3f054ac:	0a000002 	beq	3f054bc <do_icache+0x44>
 3f054b0:	ea000002 	b	3f054c0 <do_icache+0x48>
#if 0	/* prevented by varargs handling; FALLTROUGH is harmless, too */
		default: printf ("Usage:\n%s\n", cmdtp->usage);
			return;
#endif
		case 0:	icache_disable();
 3f054b4:	eb004447 	bl	3f165d8 <icache_disable>
			break;
 3f054b8:	ea000000 	b	3f054c0 <do_icache+0x48>
		case 1:	icache_enable ();
 3f054bc:	eb00443c 	bl	3f165b4 <icache_enable>
			break;
		}
		/* FALL TROUGH */
	case 1:			/* get status */
		printf ("Instruction Cache is %s\n",
 3f054c0:	eb00444d 	bl	3f165fc <icache_status>
 3f054c4:	e59f102c 	ldr	r1, [pc, #2c]	; 3f054f8 <do_icache+0x80>
 3f054c8:	e59f302c 	ldr	r3, [pc, #2c]	; 3f054fc <do_icache+0x84>
 3f054cc:	e3500000 	cmp	r0, #0	; 0x0
 3f054d0:	e59f0028 	ldr	r0, [pc, #28]	; 3f05500 <do_icache+0x88>
 3f054d4:	11a01003 	movne	r1, r3
 3f054d8:	eb001cd9 	bl	3f0c844 <printf>
			icache_status() ? "ON" : "OFF");
		return 0;
 3f054dc:	e3a00000 	mov	r0, #0	; 0x0
 3f054e0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	default:
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f054e4:	e59f0018 	ldr	r0, [pc, #18]	; 3f05504 <do_icache+0x8c>
 3f054e8:	e5911010 	ldr	r1, [r1, #16]
 3f054ec:	eb001cd4 	bl	3f0c844 <printf>
		return 1;
 3f054f0:	e3a00001 	mov	r0, #1	; 0x1
 3f054f4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f054f8:	03f1bf78 	mvneqs	r11, #480	; 0x1e0
 3f054fc:	03f1bf74 	mvneqs	r11, #464	; 0x1d0
 3f05500:	03f1bf58 	mvneqs	r11, #352	; 0x160
 3f05504:	03f1bf7c 	mvneqs	r11, #496	; 0x1f0

03f05508 <do_dcache>:
 3f05508:	e1a0c00d 	mov	r12, r13
 3f0550c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f05510:	e24cb004 	sub	r11, r12, #4	; 0x4
	}
	return 0;
}

int do_dcache ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	switch (argc) {
 3f05514:	e3520001 	cmp	r2, #1	; 0x1
 3f05518:	e1a01000 	mov	r1, r0
 3f0551c:	0a00000b 	beq	3f05550 <do_dcache+0x48>
 3f05520:	e3520002 	cmp	r2, #2	; 0x2
 3f05524:	1a000012 	bne	3f05574 <do_dcache+0x6c>
	case 2:			/* on / off	*/
		switch (on_off(argv[1])) {
 3f05528:	e5930004 	ldr	r0, [r3, #4]
 3f0552c:	eb000019 	bl	3f05598 <on_off>
 3f05530:	e3500000 	cmp	r0, #0	; 0x0
 3f05534:	0a000002 	beq	3f05544 <do_dcache+0x3c>
 3f05538:	e3500001 	cmp	r0, #1	; 0x1
 3f0553c:	0a000002 	beq	3f0554c <do_dcache+0x44>
 3f05540:	ea000002 	b	3f05550 <do_dcache+0x48>
#if 0	/* prevented by varargs handling; FALLTROUGH is harmless, too */
		default: printf ("Usage:\n%s\n", cmdtp->usage);
			return;
#endif
		case 0:	dcache_disable();
 3f05544:	eb00443c 	bl	3f1663c <dcache_disable>
			break;
 3f05548:	ea000000 	b	3f05550 <do_dcache+0x48>
		case 1:	dcache_enable ();
 3f0554c:	eb004431 	bl	3f16618 <dcache_enable>
			break;
		}
		/* FALL TROUGH */
	case 1:			/* get status */
		printf ("Data (writethrough) Cache is %s\n",
 3f05550:	eb004442 	bl	3f16660 <dcache_status>
 3f05554:	e59f102c 	ldr	r1, [pc, #2c]	; 3f05588 <do_dcache+0x80>
 3f05558:	e59f302c 	ldr	r3, [pc, #2c]	; 3f0558c <do_dcache+0x84>
 3f0555c:	e3500000 	cmp	r0, #0	; 0x0
 3f05560:	e59f0028 	ldr	r0, [pc, #28]	; 3f05590 <do_dcache+0x88>
 3f05564:	11a01003 	movne	r1, r3
 3f05568:	eb001cb5 	bl	3f0c844 <printf>
			dcache_status() ? "ON" : "OFF");
		return 0;
 3f0556c:	e3a00000 	mov	r0, #0	; 0x0
 3f05570:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	default:
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f05574:	e59f0018 	ldr	r0, [pc, #18]	; 3f05594 <do_dcache+0x8c>
 3f05578:	e5911010 	ldr	r1, [r1, #16]
 3f0557c:	eb001cb0 	bl	3f0c844 <printf>
		return 1;
 3f05580:	e3a00001 	mov	r0, #1	; 0x1
 3f05584:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f05588:	03f1bf78 	mvneqs	r11, #480	; 0x1e0
 3f0558c:	03f1bf74 	mvneqs	r11, #464	; 0x1d0
 3f05590:	03f1bf88 	mvneqs	r11, #544	; 0x220
 3f05594:	03f1bf7c 	mvneqs	r11, #496	; 0x1f0

03f05598 <on_off>:
 3f05598:	e1a0c00d 	mov	r12, r13
 3f0559c:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f055a0:	e24cb004 	sub	r11, r12, #4	; 0x4
	}
	return 0;

}

static int on_off (const char *s)
{
 3f055a4:	e1a04000 	mov	r4, r0
	if (strcmp(s, "on") == 0) {
 3f055a8:	e59f102c 	ldr	r1, [pc, #2c]	; 3f055dc <on_off+0x44>
 3f055ac:	eb002701 	bl	3f0f1b8 <strcmp>
 3f055b0:	e3500000 	cmp	r0, #0	; 0x0
 3f055b4:	0a000006 	beq	3f055d4 <on_off+0x3c>
 3f055b8:	e59f1020 	ldr	r1, [pc, #20]	; 3f055e0 <on_off+0x48>
 3f055bc:	e1a00004 	mov	r0, r4
 3f055c0:	eb0026fc 	bl	3f0f1b8 <strcmp>
 3f055c4:	e3500000 	cmp	r0, #0	; 0x0
		return (1);
	} else if (strcmp(s, "off") == 0) {
 3f055c8:	03a00000 	moveq	r0, #0	; 0x0
 3f055cc:	13e00000 	mvnne	r0, #0	; 0x0
		return (0);
	}
	return (-1);
 3f055d0:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f055d4:	e3a00001 	mov	r0, #1	; 0x1
 3f055d8:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f055dc:	03f1bfac 	mvneqs	r11, #688	; 0x2b0
 3f055e0:	03f1bfb0 	mvneqs	r11, #704	; 0x2c0

03f055e4 <do_coninfo>:
 3f055e4:	e1a0c00d 	mov	r12, r13
 3f055e8:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f055ec:	e24cb004 	sub	r11, r12, #4	; 0x4
	/* Scan for valid output and input devices */

	printf ("List of available devices:\n");

	for (i = 1; i <= ListNumItems (devlist); i++) {
 3f055f0:	e3a06001 	mov	r6, #1	; 0x1
 3f055f4:	e59f0008 	ldr	r0, [pc, #8]	; 3f05604 <do_coninfo+0x20>
 3f055f8:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f055fc:	eb001c90 	bl	3f0c844 <printf>
 3f05600:	ea000024 	b	3f05698 <do_coninfo+0xb4>
 3f05604:	03f1c094 	mvneqs	r12, #148	; 0x94
		device_t *dev = ListGetPtrToItem (devlist, i);
 3f05608:	e5940000 	ldr	r0, [r4]
 3f0560c:	e1a01006 	mov	r1, r6
 3f05610:	eb0024d2 	bl	3f0e960 <ListGetPtrToItem>
 3f05614:	e1a04000 	mov	r4, r0

		printf ("%-8s %08x %c%c%c ",
 3f05618:	e5942000 	ldr	r2, [r4]
 3f0561c:	e3120001 	tst	r2, #1	; 0x1
 3f05620:	03a0302e 	moveq	r3, #46	; 0x2e
 3f05624:	13a03049 	movne	r3, #73	; 0x49
 3f05628:	e58d3000 	str	r3, [r13]
			dev->name,
			dev->flags,
			(dev->flags & DEV_FLAGS_SYSTEM) ? 'S' : '.',
			(dev->flags & DEV_FLAGS_INPUT) ? 'I' : '.',
			(dev->flags & DEV_FLAGS_OUTPUT) ? 'O' : '.');

		for (l = 0; l < MAX_FILES; l++) {
 3f0562c:	e3a05000 	mov	r5, #0	; 0x0
 3f05630:	e5943000 	ldr	r3, [r4]
 3f05634:	e2841008 	add	r1, r4, #8	; 0x8
 3f05638:	e59f0074 	ldr	r0, [pc, #74]	; 3f056b4 <do_coninfo+0xd0>
 3f0563c:	e3130002 	tst	r3, #2	; 0x2
 3f05640:	03a0302e 	moveq	r3, #46	; 0x2e
 3f05644:	13a0304f 	movne	r3, #79	; 0x4f
 3f05648:	e1520005 	cmp	r2, r5
 3f0564c:	e58d3004 	str	r3, [r13, #4]
 3f05650:	a3a0302e 	movge	r3, #46	; 0x2e
 3f05654:	b3a03053 	movlt	r3, #83	; 0x53
 3f05658:	eb001c79 	bl	3f0c844 <printf>
			if (stdio_devices[l] == dev) {
 3f0565c:	e59f3054 	ldr	r3, [pc, #54]	; 3f056b8 <do_coninfo+0xd4>
 3f05660:	e1a02105 	mov	r2, r5, lsl #2
 3f05664:	e7933002 	ldr	r3, [r3, r2]
 3f05668:	e1530004 	cmp	r3, r4
 3f0566c:	1a000003 	bne	3f05680 <do_coninfo+0x9c>
				printf ("%s ", stdio_names[l]);
 3f05670:	e59f3044 	ldr	r3, [pc, #44]	; 3f056bc <do_coninfo+0xd8>
 3f05674:	e59f0044 	ldr	r0, [pc, #44]	; 3f056c0 <do_coninfo+0xdc>
 3f05678:	e7931002 	ldr	r1, [r3, r2]
 3f0567c:	eb001c70 	bl	3f0c844 <printf>
 3f05680:	e2855001 	add	r5, r5, #1	; 0x1
 3f05684:	e3550002 	cmp	r5, #2	; 0x2
 3f05688:	dafffff3 	ble	3f0565c <do_coninfo+0x78>
			}
		}
		putc ('\n');
 3f0568c:	e3a0000a 	mov	r0, #10	; 0xa
 3f05690:	eb001c51 	bl	3f0c7dc <putc>
 3f05694:	e2866001 	add	r6, r6, #1	; 0x1
 3f05698:	e59f4024 	ldr	r4, [pc, #24]	; 3f056c4 <do_coninfo+0xe0>
 3f0569c:	e5940000 	ldr	r0, [r4]
 3f056a0:	eb0024cb 	bl	3f0e9d4 <ListNumItems>
 3f056a4:	e1560000 	cmp	r6, r0
 3f056a8:	daffffd6 	ble	3f05608 <do_coninfo+0x24>
	}
	return 0;
 3f056ac:	e3a00000 	mov	r0, #0	; 0x0
 3f056b0:	ea000004 	b	3f056c8 <do_coninfo+0xe4>
 3f056b4:	03f1c0b0 	mvneqs	r12, #176	; 0xb0
 3f056b8:	03f20864 	mvneqs	r0, #6553600	; 0x640000
 3f056bc:	03f20870 	mvneqs	r0, #7340032	; 0x700000
 3f056c0:	03f1c0c4 	mvneqs	r12, #196	; 0xc4
 3f056c4:	03f20860 	mvneqs	r0, #6291456	; 0x600000
}
 3f056c8:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f056cc <do_date>:
 3f056cc:	e1a0c00d 	mov	r12, r13
 3f056d0:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f056d4:	e24cb004 	sub	r11, r12, #4	; 0x4
	DECLARE_GLOBAL_DATA_PTR;
	struct rtc_time tm;
	int rcode = 0;

	switch (argc) {
 3f056d8:	e3520001 	cmp	r2, #1	; 0x1
 3f056dc:	e1a01000 	mov	r1, r0
 3f056e0:	e1a05003 	mov	r5, r3
 3f056e4:	e24dd034 	sub	r13, r13, #52	; 0x34
 3f056e8:	0a000017 	beq	3f0574c <do_date+0x80>
 3f056ec:	e3520002 	cmp	r2, #2	; 0x2
 3f056f0:	1a000034 	bne	3f057c8 <do_date+0xfc>
	case 2:			/* set date & time */
		if (strcmp(argv[1],"reset") == 0) {
 3f056f4:	e5950004 	ldr	r0, [r5, #4]
 3f056f8:	e59f10b0 	ldr	r1, [pc, #b0]	; 3f057b0 <do_date+0xe4>
 3f056fc:	eb0026ad 	bl	3f0f1b8 <strcmp>
 3f05700:	e3500000 	cmp	r0, #0	; 0x0
 3f05704:	1a000003 	bne	3f05718 <do_date+0x4c>
			printf ("Reset RTC...\n");
 3f05708:	e59f00a4 	ldr	r0, [pc, #a4]	; 3f057b4 <do_date+0xe8>
 3f0570c:	eb001c4c 	bl	3f0c844 <printf>
			rtc_reset ();
 3f05710:	eb0053c2 	bl	3f1a620 <rtc_reset>
		} else {
 3f05714:	ea00000c 	b	3f0574c <do_date+0x80>
			/* initialize tm with current time */
			rtc_get (&tm);
 3f05718:	e24b4038 	sub	r4, r11, #56	; 0x38
 3f0571c:	e1a00004 	mov	r0, r4
 3f05720:	eb0053b6 	bl	3f1a600 <rtc_get>
			/* insert new date & time */
			if (mk_date (argv[1], &tm) != 0) {
 3f05724:	e5950004 	ldr	r0, [r5, #4]
 3f05728:	e1a01004 	mov	r1, r4
 3f0572c:	eb000045 	bl	3f05848 <mk_date>
 3f05730:	e3500000 	cmp	r0, #0	; 0x0
 3f05734:	0a000002 	beq	3f05744 <do_date+0x78>
				printf ("## Bad date format\n");
 3f05738:	e59f0078 	ldr	r0, [pc, #78]	; 3f057b8 <do_date+0xec>
 3f0573c:	eb001c40 	bl	3f0c844 <printf>
				return 1;
 3f05740:	ea000023 	b	3f057d4 <do_date+0x108>
			}
			/* and write to RTC */
			rtc_set (&tm);
 3f05744:	e1a00004 	mov	r0, r4
 3f05748:	eb0053b0 	bl	3f1a610 <rtc_set>
		}
		/* FALL TROUGH */
	case 1:			/* get date & time */
		rtc_get (&tm);
 3f0574c:	e24b0038 	sub	r0, r11, #56	; 0x38
 3f05750:	eb0053aa 	bl	3f1a600 <rtc_get>

		printf ("Date: %4d-%02d-%02d (%sday)    Time: %2d:%02d:%02d\n",
 3f05754:	e24b1024 	sub	r1, r11, #36	; 0x24
 3f05758:	e8910006 	ldmia	r1, {r1, r2}
 3f0575c:	e24bc02c 	sub	r12, r11, #44	; 0x2c
 3f05760:	e89c5000 	ldmia	r12, {r12, r14}
 3f05764:	e3520006 	cmp	r2, #6	; 0x6
 3f05768:	959f304c 	ldrls	r3, [pc, #4c]	; 3f057bc <do_date+0xf0>
 3f0576c:	97932102 	ldrls	r2, [r3, r2, lsl #2]
 3f05770:	95983010 	ldrls	r3, [r8, #16]
 3f05774:	90822003 	addls	r2, r2, r3
 3f05778:	859f2040 	ldrhi	r2, [pc, #40]	; 3f057c0 <do_date+0xf4>
 3f0577c:	e58d2000 	str	r2, [r13]
 3f05780:	e51b3030 	ldr	r3, [r11, -#48]
 3f05784:	e59f0038 	ldr	r0, [pc, #38]	; 3f057c4 <do_date+0xf8>
 3f05788:	e58d3004 	str	r3, [r13, #4]
 3f0578c:	e51b3034 	ldr	r3, [r11, -#52]
 3f05790:	e58d3008 	str	r3, [r13, #8]
 3f05794:	e51b3038 	ldr	r3, [r11, -#56]
 3f05798:	e1a0200e 	mov	r2, r14
 3f0579c:	e58d300c 	str	r3, [r13, #12]
 3f057a0:	e1a0300c 	mov	r3, r12
 3f057a4:	eb001c26 	bl	3f0c844 <printf>
			tm.tm_year, tm.tm_mon, tm.tm_mday,
			(tm.tm_wday<0 || tm.tm_wday>6) ?
				"unknown " : RELOC(weekdays[tm.tm_wday]),
			tm.tm_hour, tm.tm_min, tm.tm_sec);

		return 0;
 3f057a8:	e3a00000 	mov	r0, #0	; 0x0
 3f057ac:	ea000009 	b	3f057d8 <do_date+0x10c>
 3f057b0:	03f1c134 	mvneqs	r12, #13	; 0xd
 3f057b4:	03f1c13c 	mvneqs	r12, #15	; 0xf
 3f057b8:	03f1c14c 	mvneqs	r12, #19	; 0x13
 3f057bc:	03f205e0 	mvneqs	r0, #939524096	; 0x38000000
 3f057c0:	03f1c194 	mvneqs	r12, #37	; 0x25
 3f057c4:	03f1c160 	mvneqs	r12, #24	; 0x18
	default:
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f057c8:	e59f000c 	ldr	r0, [pc, #c]	; 3f057dc <do_date+0x110>
 3f057cc:	e5911010 	ldr	r1, [r1, #16]
 3f057d0:	eb001c1b 	bl	3f0c844 <printf>
		rcode = 1;
	}
	return rcode;
 3f057d4:	e3a00001 	mov	r0, #1	; 0x1
 3f057d8:	ea000000 	b	3f057e0 <do_date+0x114>
 3f057dc:	03f1c1a0 	mvneqs	r12, #40	; 0x28
}
 3f057e0:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f057e4 <cnvrt2>:
 3f057e4:	e1a0c00d 	mov	r12, r13
 3f057e8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f057ec:	e24cb004 	sub	r11, r12, #4	; 0x4

/*
 * simple conversion of two-digit string with error checking
 */
static int cnvrt2 (char *str, int *valp)
{
 3f057f0:	e1a0c000 	mov	r12, r0
	int val;

	if ((*str < '0') || (*str > '9'))
 3f057f4:	e5dc3000 	ldrb	r3, [r12]
 3f057f8:	e2433030 	sub	r3, r3, #48	; 0x30
 3f057fc:	e3530009 	cmp	r3, #9	; 0x9
		return (-1);
 3f05800:	83e00000 	mvnhi	r0, #0	; 0x0
 3f05804:	891ba800 	ldmhidb	r11, {r11, r13, r15}

	val = *str - '0';
 3f05808:	e5dc2000 	ldrb	r2, [r12]

	++str;

	if ((*str < '0') || (*str > '9'))
 3f0580c:	e5fc3001 	ldrb	r3, [r12, #1]!
 3f05810:	e2433030 	sub	r3, r3, #48	; 0x30
 3f05814:	e3530009 	cmp	r3, #9	; 0x9
 3f05818:	e2422030 	sub	r2, r2, #48	; 0x30
 3f0581c:	8a000007 	bhi	3f05840 <cnvrt2+0x5c>
		return (-1);

	*valp = 10 * val + (*str - '0');

	return (0);
 3f05820:	e3a00000 	mov	r0, #0	; 0x0
 3f05824:	e0823102 	add	r3, r2, r2, lsl #2
 3f05828:	e1a03083 	mov	r3, r3, lsl #1
 3f0582c:	e5dc2000 	ldrb	r2, [r12]
 3f05830:	e2433030 	sub	r3, r3, #48	; 0x30
 3f05834:	e0833002 	add	r3, r3, r2
 3f05838:	e5813000 	str	r3, [r1]
 3f0583c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f05840:	e3e00000 	mvn	r0, #0	; 0x0
}
 3f05844:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f05848 <mk_date>:
 3f05848:	e1a0c00d 	mov	r12, r13
 3f0584c:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f05850:	e24cb004 	sub	r11, r12, #4	; 0x4

/*
 * Convert date string: MMDDhhmm[[CC]YY][.ss]
 *
 * Some basic checking for valid values is done, but this will not catch
 * all possible error conditions.
 */
int mk_date (char *datestr, struct rtc_time *tmp)
{
 3f05854:	e1a06000 	mov	r6, r0
 3f05858:	e1a07001 	mov	r7, r1
	int len, val;
	char *ptr;

	ptr = strchr (datestr,'.');
 3f0585c:	e3a0102e 	mov	r1, #46	; 0x2e
 3f05860:	e24dd014 	sub	r13, r13, #20	; 0x14
 3f05864:	eb002677 	bl	3f0f248 <strchr>
 3f05868:	e1a04000 	mov	r4, r0
	len = strlen (datestr);
 3f0586c:	e1a00006 	mov	r0, r6
 3f05870:	eb002694 	bl	3f0f2c8 <strlen>
 3f05874:	e1a05000 	mov	r5, r0

	/* Set seconds */
	if (ptr) {
 3f05878:	e3540000 	cmp	r4, #0	; 0x0
 3f0587c:	0a000011 	beq	3f058c8 <mk_date+0x80>
		int sec;

		*ptr++ = '\0';
 3f05880:	e3a03000 	mov	r3, #0	; 0x0
 3f05884:	e4c43001 	strb	r3, [r4], #1
		if ((len - (ptr - datestr)) != 2)
			return (-1);
 3f05888:	e3e00000 	mvn	r0, #0	; 0x0
 3f0588c:	e0663004 	rsb	r3, r6, r4
 3f05890:	e0633005 	rsb	r3, r3, r5
 3f05894:	e3530002 	cmp	r3, #2	; 0x2
 3f05898:	1a000066 	bne	3f05a38 <mk_date+0x1f0>

		len = strlen (datestr);
 3f0589c:	e1a00006 	mov	r0, r6
 3f058a0:	eb002688 	bl	3f0f2c8 <strlen>
 3f058a4:	e1a05000 	mov	r5, r0

		if (cnvrt2 (ptr, &sec))
 3f058a8:	e1a00004 	mov	r0, r4
 3f058ac:	e24b1020 	sub	r1, r11, #32	; 0x20
 3f058b0:	ebffffcb 	bl	3f057e4 <cnvrt2>
 3f058b4:	e3500000 	cmp	r0, #0	; 0x0
 3f058b8:	1a00005d 	bne	3f05a34 <mk_date+0x1ec>
			return (-1);

		tmp->tm_sec = sec;
 3f058bc:	e51b3020 	ldr	r3, [r11, -#32]
 3f058c0:	e5873000 	str	r3, [r7]
	} else {
 3f058c4:	ea000000 	b	3f058cc <mk_date+0x84>
		tmp->tm_sec = 0;
 3f058c8:	e5874000 	str	r4, [r7]
	}

	if (len == 12) {		/* MMDDhhmmCCYY	*/
 3f058cc:	e355000c 	cmp	r5, #12	; 0xc
 3f058d0:	1a00000d 	bne	3f0590c <mk_date+0xc4>
		int year, century;

		if (cnvrt2 (datestr+ 8, &century) ||
 3f058d4:	e2860008 	add	r0, r6, #8	; 0x8
 3f058d8:	e24b1024 	sub	r1, r11, #36	; 0x24
 3f058dc:	ebffffc0 	bl	3f057e4 <cnvrt2>
 3f058e0:	e3500000 	cmp	r0, #0	; 0x0
 3f058e4:	1a000052 	bne	3f05a34 <mk_date+0x1ec>
 3f058e8:	e286000a 	add	r0, r6, #10	; 0xa
 3f058ec:	e24b1028 	sub	r1, r11, #40	; 0x28
 3f058f0:	ebffffbb 	bl	3f057e4 <cnvrt2>
 3f058f4:	e3500000 	cmp	r0, #0	; 0x0
 3f058f8:	1a00004d 	bne	3f05a34 <mk_date+0x1ec>
		    cnvrt2 (datestr+10, &year) ) {
			return (-1);
		}
		tmp->tm_year = 100 * century + year;
 3f058fc:	e24b2028 	sub	r2, r11, #40	; 0x28
 3f05900:	e892000c 	ldmia	r2, {r2, r3}
 3f05904:	e0833103 	add	r3, r3, r3, lsl #2
	} else if (len == 10) {		/* MMDDhhmmYY	*/
 3f05908:	ea00000d 	b	3f05944 <mk_date+0xfc>
 3f0590c:	e355000a 	cmp	r5, #10	; 0xa
 3f05910:	1a00000e 	bne	3f05950 <mk_date+0x108>
		int year, century;

		century = tmp->tm_year / 100;
 3f05914:	e5973014 	ldr	r3, [r7, #20]
 3f05918:	e59f2110 	ldr	r2, [pc, #110]	; 3f05a30 <mk_date+0x1e8>
 3f0591c:	e0c21293 	smull	r1, r2, r3, r2
		if (cnvrt2 (datestr+ 8, &year))
 3f05920:	e2860008 	add	r0, r6, #8	; 0x8
 3f05924:	e24b102c 	sub	r1, r11, #44	; 0x2c
 3f05928:	e1a03fc3 	mov	r3, r3, asr #31
 3f0592c:	e06342c2 	rsb	r4, r3, r2, asr #5
 3f05930:	ebffffab 	bl	3f057e4 <cnvrt2>
 3f05934:	e3500000 	cmp	r0, #0	; 0x0
 3f05938:	1a00003d 	bne	3f05a34 <mk_date+0x1ec>
			return (-1);
		tmp->tm_year = 100 * century + year;
 3f0593c:	e0843104 	add	r3, r4, r4, lsl #2
 3f05940:	e51b202c 	ldr	r2, [r11, -#44]
 3f05944:	e0833103 	add	r3, r3, r3, lsl #2
 3f05948:	e0822103 	add	r2, r2, r3, lsl #2
 3f0594c:	e5872014 	str	r2, [r7, #20]
	}

	switch (len) {
 3f05950:	e355000a 	cmp	r5, #10	; 0xa
 3f05954:	0a000005 	beq	3f05970 <mk_date+0x128>
 3f05958:	ca000002 	bgt	3f05968 <mk_date+0x120>
 3f0595c:	e3550008 	cmp	r5, #8	; 0x8
 3f05960:	0a000002 	beq	3f05970 <mk_date+0x128>
 3f05964:	ea000032 	b	3f05a34 <mk_date+0x1ec>
 3f05968:	e355000c 	cmp	r5, #12	; 0xc
 3f0596c:	1a000030 	bne	3f05a34 <mk_date+0x1ec>
	case 8:			/* MMDDhhmm	*/
		/* fall thru */
	case 10:		/* MMDDhhmmYY	*/
		/* fall thru */
	case 12:		/* MMDDhhmmCCYY	*/
		if (cnvrt2 (datestr+0, &val) ||
 3f05970:	e1a00006 	mov	r0, r6
 3f05974:	e24b4030 	sub	r4, r11, #48	; 0x30
 3f05978:	e1a01004 	mov	r1, r4
 3f0597c:	ebffff98 	bl	3f057e4 <cnvrt2>
 3f05980:	e3500000 	cmp	r0, #0	; 0x0
 3f05984:	1a00002a 	bne	3f05a34 <mk_date+0x1ec>
 3f05988:	e51b3030 	ldr	r3, [r11, -#48]
 3f0598c:	e353000c 	cmp	r3, #12	; 0xc
 3f05990:	ca000027 	bgt	3f05a34 <mk_date+0x1ec>
		    val > 12) {
			break;
		}
		tmp->tm_mon  = val;
		if (cnvrt2 (datestr+2, &val) ||
 3f05994:	e2860002 	add	r0, r6, #2	; 0x2
 3f05998:	e1a01004 	mov	r1, r4
 3f0599c:	e5873010 	str	r3, [r7, #16]
 3f059a0:	ebffff8f 	bl	3f057e4 <cnvrt2>
 3f059a4:	e3500000 	cmp	r0, #0	; 0x0
 3f059a8:	1a000021 	bne	3f05a34 <mk_date+0x1ec>
 3f059ac:	e5973010 	ldr	r3, [r7, #16]
 3f059b0:	e3530002 	cmp	r3, #2	; 0x2
 3f059b4:	1a000002 	bne	3f059c4 <mk_date+0x17c>
 3f059b8:	e51b3030 	ldr	r3, [r11, -#48]
 3f059bc:	e353001d 	cmp	r3, #29	; 0x1d
 3f059c0:	ea000001 	b	3f059cc <mk_date+0x184>
 3f059c4:	e51b3030 	ldr	r3, [r11, -#48]
 3f059c8:	e353001f 	cmp	r3, #31	; 0x1f
 3f059cc:	ca000018 	bgt	3f05a34 <mk_date+0x1ec>
		    val > ((tmp->tm_mon==2) ? 29 : 31)) {
			break;
		}
		tmp->tm_mday = val;

		if (cnvrt2 (datestr+4, &val) ||
 3f059d0:	e2860004 	add	r0, r6, #4	; 0x4
 3f059d4:	e51b3030 	ldr	r3, [r11, -#48]
 3f059d8:	e1a01004 	mov	r1, r4
 3f059dc:	e587300c 	str	r3, [r7, #12]
 3f059e0:	ebffff7f 	bl	3f057e4 <cnvrt2>
 3f059e4:	e3500000 	cmp	r0, #0	; 0x0
 3f059e8:	1a000011 	bne	3f05a34 <mk_date+0x1ec>
 3f059ec:	e51b3030 	ldr	r3, [r11, -#48]
 3f059f0:	e3530017 	cmp	r3, #23	; 0x17
 3f059f4:	ca00000e 	bgt	3f05a34 <mk_date+0x1ec>
		    val > 23) {
			break;
		}
		tmp->tm_hour = val;

		if (cnvrt2 (datestr+6, &val) ||
 3f059f8:	e2860006 	add	r0, r6, #6	; 0x6
 3f059fc:	e1a01004 	mov	r1, r4
 3f05a00:	e5873008 	str	r3, [r7, #8]
 3f05a04:	ebffff76 	bl	3f057e4 <cnvrt2>
 3f05a08:	e2504000 	subs	r4, r0, #0	; 0x0
 3f05a0c:	1a000008 	bne	3f05a34 <mk_date+0x1ec>
 3f05a10:	e51b3030 	ldr	r3, [r11, -#48]
 3f05a14:	e353003b 	cmp	r3, #59	; 0x3b
 3f05a18:	ca000005 	bgt	3f05a34 <mk_date+0x1ec>
		    val > 59) {
			break;
		}
		tmp->tm_min  = val;

		/* calculate day of week */
		GregorianDay (tmp);
 3f05a1c:	e1a00007 	mov	r0, r7
 3f05a20:	e5873004 	str	r3, [r7, #4]
 3f05a24:	eb005237 	bl	3f1a308 <GregorianDay>

		return (0);
 3f05a28:	e1a00004 	mov	r0, r4
 3f05a2c:	ea000001 	b	3f05a38 <mk_date+0x1f0>
 3f05a30:	51eb851f 	mvnpl	r8, r15, lsl r5
	default:
		break;
	}

	return (-1);
 3f05a34:	e3e00000 	mvn	r0, #0	; 0x0
}
 3f05a38:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}

03f05a3c <do_bootelf>:
 3f05a3c:	e1a0c00d 	mov	r12, r13
 3f05a40:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f05a44:	e24cb004 	sub	r11, r12, #4	; 0x4
/* ======================================================================
 * Interpreter command to boot an arbitrary ELF image from memory.
 * ====================================================================== */
int do_bootelf (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f05a48:	e1a06002 	mov	r6, r2
	unsigned long addr;		/* Address of the ELF image     */
	unsigned long rc;		/* Return value from user code  */

	/* -------------------------------------------------- */
	int rcode = 0;
 3f05a4c:	e3a04000 	mov	r4, #0	; 0x0

	if (argc < 2)
 3f05a50:	e3560001 	cmp	r6, #1	; 0x1
 3f05a54:	e1a05003 	mov	r5, r3
		addr = load_addr;
 3f05a58:	d59f3080 	ldrle	r3, [pc, #80]	; 3f05ae0 <do_bootelf+0xa4>
 3f05a5c:	d5934000 	ldrle	r4, [r3]
 3f05a60:	da000004 	ble	3f05a78 <do_bootelf+0x3c>
	else
		addr = simple_strtoul (argv[1], NULL, 16);
 3f05a64:	e1a01004 	mov	r1, r4
 3f05a68:	e5950004 	ldr	r0, [r5, #4]
 3f05a6c:	e3a02010 	mov	r2, #16	; 0x10
 3f05a70:	eb002733 	bl	3f0f744 <simple_strtoul>
 3f05a74:	e1a04000 	mov	r4, r0

	if (!valid_elf_image (addr))
 3f05a78:	e1a00004 	mov	r0, r4
 3f05a7c:	eb000086 	bl	3f05c9c <valid_elf_image>
 3f05a80:	e3500000 	cmp	r0, #0	; 0x0
		return 1;
 3f05a84:	e3a00001 	mov	r0, #1	; 0x1
 3f05a88:	091ba870 	ldmeqdb	r11, {r4, r5, r6, r11, r13, r15}

	addr = load_elf_image (addr);
 3f05a8c:	e1a00004 	mov	r0, r4
 3f05a90:	eb000098 	bl	3f05cf8 <load_elf_image>
 3f05a94:	e1a04000 	mov	r4, r0

	printf ("## Starting application at 0x%08lx ...\n", addr);
 3f05a98:	e59f0044 	ldr	r0, [pc, #44]	; 3f05ae4 <do_bootelf+0xa8>
 3f05a9c:	e1a01004 	mov	r1, r4
 3f05aa0:	eb001b67 	bl	3f0c844 <printf>

	/*
	 * QNX images require the data cache is disabled.
	 * Data cache is already flushed, so just turn it off.
	 */
	if (dcache_status ())
 3f05aa4:	eb0042ed 	bl	3f16660 <dcache_status>
 3f05aa8:	e3500000 	cmp	r0, #0	; 0x0
 3f05aac:	0a000000 	beq	3f05ab4 <do_bootelf+0x78>
		dcache_disable ();
 3f05ab0:	eb0042e1 	bl	3f1663c <dcache_disable>

	/*
	 * pass address parameter as argv[0] (aka command name),
	 * and all remaining args
	 */
	rc = ((ulong (*)(int, char *[])) addr) (--argc, &argv[1]);
 3f05ab4:	e2460001 	sub	r0, r6, #1	; 0x1
 3f05ab8:	e2851004 	add	r1, r5, #4	; 0x4
 3f05abc:	e1a0e00f 	mov	r14, r15
 3f05ac0:	e1a0f004 	mov	r15, r4
	if (rc != 0)
 3f05ac4:	e1a01000 	mov	r1, r0
		rcode = 1;

	printf ("## Application terminated, rc = 0x%lx\n", rc);
 3f05ac8:	e59f0018 	ldr	r0, [pc, #18]	; 3f05ae8 <do_bootelf+0xac>
 3f05acc:	e2514000 	subs	r4, r1, #0	; 0x0
 3f05ad0:	13a04001 	movne	r4, #1	; 0x1
 3f05ad4:	eb001b5a 	bl	3f0c844 <printf>
	return rcode;
 3f05ad8:	e1a00004 	mov	r0, r4
}
 3f05adc:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f05ae0:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
 3f05ae4:	03f1c288 	mvneqs	r12, #-2147483640	; 0x80000008
 3f05ae8:	03f1c2b0 	mvneqs	r12, #11	; 0xb

03f05aec <do_bootvx>:
 3f05aec:	e1a0c00d 	mov	r12, r13
 3f05af0:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f05af4:	e24cb004 	sub	r11, r12, #4	; 0x4

/* ======================================================================
 * Interpreter command to boot VxWorks from a memory image.  The image can
 * be either an ELF image or a raw binary.  Will attempt to setup the
 * bootline and other parameters correctly.
 * ====================================================================== */
int do_bootvx ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f05af8:	e1a04002 	mov	r4, r2
#if defined(CONFIG_WALNUT405)	|| \
    defined(CONFIG_CPCI405)	|| \
    defined(CONFIG_OCRTC)	|| \
    defined(CONFIG_ORSG)
	DECLARE_GLOBAL_DATA_PTR;
#endif

	unsigned long addr;		/* Address of image            */
	unsigned long bootaddr;		/* Address to put the bootline */
	char *bootline;			/* Text of the bootline        */
	char *tmp;			/* Temporary char pointer      */

#if defined(CONFIG_4xx) || defined(CONFIG_IOP480)
	char build_buf[80];		/* Buffer for building the bootline */
#endif
	/* -------------------------------------------------- */

	/*
	 * Check the loadaddr variable.
	 * If we don't know where the image is then we're done.
	 */

	if ((tmp = getenv ("loadaddr")) != NULL) {
 3f05afc:	e59f0168 	ldr	r0, [pc, #168]	; 3f05c6c <do_bootvx+0x180>
 3f05b00:	e1a06003 	mov	r6, r3
 3f05b04:	eb001954 	bl	3f0c05c <getenv>
 3f05b08:	e3500000 	cmp	r0, #0	; 0x0
 3f05b0c:	1a000003 	bne	3f05b20 <do_bootvx+0x34>
		addr = simple_strtoul (tmp, NULL, 16);
	} else {
		printf ("No load address provided\n");
 3f05b10:	e59f0158 	ldr	r0, [pc, #158]	; 3f05c70 <do_bootvx+0x184>
 3f05b14:	eb001b4a 	bl	3f0c844 <printf>
		return 1;
 3f05b18:	e3a00001 	mov	r0, #1	; 0x1
 3f05b1c:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f05b20:	e3a01000 	mov	r1, #0	; 0x0
 3f05b24:	e3a02010 	mov	r2, #16	; 0x10
 3f05b28:	eb002705 	bl	3f0f744 <simple_strtoul>
 3f05b2c:	e1a05000 	mov	r5, r0
	}

#if (CONFIG_COMMANDS & CFG_CMD_NET)
	/* Check to see if we need to tftp the image ourselves before starting */

	if ((argc == 2) && (strcmp (argv[1], "tftp") == 0)) {
 3f05b30:	e3540002 	cmp	r4, #2	; 0x2
 3f05b34:	1a00000c 	bne	3f05b6c <do_bootvx+0x80>
 3f05b38:	e5960004 	ldr	r0, [r6, #4]
 3f05b3c:	e59f1130 	ldr	r1, [pc, #130]	; 3f05c74 <do_bootvx+0x188>
 3f05b40:	eb00259c 	bl	3f0f1b8 <strcmp>
 3f05b44:	e3500000 	cmp	r0, #0	; 0x0
 3f05b48:	1a000007 	bne	3f05b6c <do_bootvx+0x80>
		if (NetLoop (TFTP) <= 0)
 3f05b4c:	e3a00003 	mov	r0, #3	; 0x3
 3f05b50:	ebffed12 	bl	3f00fa0 <NetLoop>
 3f05b54:	e3500000 	cmp	r0, #0	; 0x0
			return 1;
 3f05b58:	e3a00001 	mov	r0, #1	; 0x1
 3f05b5c:	d91ba870 	ldmledb	r11, {r4, r5, r6, r11, r13, r15}
		printf ("Automatic boot of VxWorks image at address 0x%08lx ... \n", addr);
 3f05b60:	e59f0110 	ldr	r0, [pc, #110]	; 3f05c78 <do_bootvx+0x18c>
 3f05b64:	e1a01005 	mov	r1, r5
 3f05b68:	eb001b35 	bl	3f0c844 <printf>
	}
#endif

	/* This should equate
	 * to NV_RAM_ADRS + NV_BOOT_OFFSET + NV_ENET_OFFSET
	 * from the VxWorks BSP header files.
	 * This will vary from board to board
	 */

#if defined(CONFIG_WALNUT405)
	tmp = (char *) CFG_NVRAM_BASE_ADDR + 0x500;
	memcpy ((char *) tmp, (char *) &gd->bd->bi_enetaddr[3], 3);
#elif defined(CONFIG_CPCI405)
	tmp = (char *) CFG_NVRAM_BASE_ADDR + CFG_NVRAM_VXWORKS_OFFS;
	memcpy ((char *) tmp, (char *) &gd->bd->bi_enetaddr[0], 6);
#elif defined(CONFIG_OCRTC) || defined(CONFIG_ORSG)
	tmp = (char *) CFG_ETHERNET_MAC_ADDR;
	memcpy ((char *) tmp, (char *) &gd->bd->bi_enetaddr[0], 6);
#else
	printf ("## Ethernet MAC address not copied to NV RAM\n");
 3f05b6c:	e59f0108 	ldr	r0, [pc, #108]	; 3f05c7c <do_bootvx+0x190>
 3f05b70:	eb001b33 	bl	3f0c844 <printf>
#endif

	/*
	 * Use bootaddr to find the location in memory that VxWorks
	 * will look for the bootline string. The default value for
	 * PowerPC is LOCAL_MEM_LOCAL_ADRS + BOOT_LINE_OFFSET which
	 * defaults to 0x4200
	 */

	if ((tmp = getenv ("bootaddr")) == NULL)
 3f05b74:	e59f0104 	ldr	r0, [pc, #104]	; 3f05c80 <do_bootvx+0x194>
 3f05b78:	eb001937 	bl	3f0c05c <getenv>
 3f05b7c:	e3500000 	cmp	r0, #0	; 0x0
		bootaddr = 0x4200;
 3f05b80:	03a06c42 	moveq	r6, #16896	; 0x4200
 3f05b84:	0a000003 	beq	3f05b98 <do_bootvx+0xac>
	else
		bootaddr = simple_strtoul (tmp, NULL, 16);
 3f05b88:	e3a01000 	mov	r1, #0	; 0x0
 3f05b8c:	e3a02010 	mov	r2, #16	; 0x10
 3f05b90:	eb0026eb 	bl	3f0f744 <simple_strtoul>
 3f05b94:	e1a06000 	mov	r6, r0

	/*
	 * Check to see if the bootline is defined in the 'bootargs'
	 * parameter. If it is not defined, we may be able to
	 * construct the info
	 */

	if ((bootline = getenv ("bootargs")) != NULL) {
 3f05b98:	e59f00e4 	ldr	r0, [pc, #e4]	; 3f05c84 <do_bootvx+0x198>
 3f05b9c:	eb00192e 	bl	3f0c05c <getenv>
 3f05ba0:	e2504000 	subs	r4, r0, #0	; 0x0
 3f05ba4:	0a000017 	beq	3f05c08 <do_bootvx+0x11c>
		memcpy ((void *) bootaddr, bootline, MAX(strlen(bootline), 255));
 3f05ba8:	e1a00004 	mov	r0, r4
 3f05bac:	eb0025c5 	bl	3f0f2c8 <strlen>
 3f05bb0:	e35000ff 	cmp	r0, #255	; 0xff
 3f05bb4:	9a000003 	bls	3f05bc8 <do_bootvx+0xdc>
 3f05bb8:	e1a00004 	mov	r0, r4
 3f05bbc:	eb0025c1 	bl	3f0f2c8 <strlen>
 3f05bc0:	e1a02000 	mov	r2, r0
 3f05bc4:	ea000000 	b	3f05bcc <do_bootvx+0xe0>
 3f05bc8:	e3a020ff 	mov	r2, #255	; 0xff
 3f05bcc:	e1a00006 	mov	r0, r6
 3f05bd0:	e1a01004 	mov	r1, r4
 3f05bd4:	eb00266b 	bl	3f0f588 <memcpy>
		flush_cache (bootaddr, MAX(strlen(bootline), 255));
 3f05bd8:	e1a00004 	mov	r0, r4
 3f05bdc:	eb0025b9 	bl	3f0f2c8 <strlen>
 3f05be0:	e35000ff 	cmp	r0, #255	; 0xff
 3f05be4:	9a000003 	bls	3f05bf8 <do_bootvx+0x10c>
 3f05be8:	e1a00004 	mov	r0, r4
 3f05bec:	eb0025b5 	bl	3f0f2c8 <strlen>
 3f05bf0:	e1a01000 	mov	r1, r0
 3f05bf4:	ea000000 	b	3f05bfc <do_bootvx+0x110>
 3f05bf8:	e3a010ff 	mov	r1, #255	; 0xff
 3f05bfc:	e1a00006 	mov	r0, r6
 3f05c00:	eb0049a1 	bl	3f1828c <flush_cache>
	} else {
 3f05c04:	ea000001 	b	3f05c10 <do_bootvx+0x124>
#if defined(CONFIG_4xx)
		sprintf (build_buf, "ibmEmac(0,0)");

		if ((tmp = getenv ("hostname")) != NULL) {
			sprintf (&build_buf[strlen (build_buf - 1)],
				"host:%s ", tmp);
		} else {
			sprintf (&build_buf[strlen (build_buf - 1)],
				": ");
		}

		if ((tmp = getenv ("ipaddr")) != NULL) {
			sprintf (&build_buf[strlen (build_buf - 1)],
				"e=%s ", tmp);
		}
		memcpy ((void *)bootaddr, build_buf, MAX(strlen(build_buf), 255));
		flush_cache (bootaddr, MAX(strlen(build_buf), 255));
#elif defined(CONFIG_IOP480)
		sprintf (build_buf, "dc(0,0)");

		if ((tmp = getenv ("hostname")) != NULL) {
			sprintf (&build_buf[strlen (build_buf - 1)],
				"host:%s ", tmp);
		} else {
			sprintf (&build_buf[strlen (build_buf - 1)],
				": ");
		}

		if ((tmp = getenv ("ipaddr")) != NULL) {
			sprintf (&build_buf[strlen (build_buf - 1)],
				"e=%s ", tmp);
		}
		memcpy ((void *) bootaddr, build_buf, MAX(strlen(build_buf), 255));
		flush_cache (bootaddr, MAX(strlen(build_buf), 255));
#else

		/*
		 * I'm not sure what the device should be for other
		 * PPC flavors, the hostname and ipaddr should be ok
		 * to just copy
		 */

		printf ("No bootargs defined\n");
 3f05c08:	e59f0078 	ldr	r0, [pc, #78]	; 3f05c88 <do_bootvx+0x19c>
		return 1;
 3f05c0c:	eaffffc0 	b	3f05b14 <do_bootvx+0x28>
#endif
	}

	/*
	 * If the data at the load address is an elf image, then
	 * treat it like an elf image. Otherwise, assume that it is a
	 * binary image
	 */

	if (valid_elf_image (addr)) {
 3f05c10:	e1a00005 	mov	r0, r5
 3f05c14:	eb000020 	bl	3f05c9c <valid_elf_image>
 3f05c18:	e3500000 	cmp	r0, #0	; 0x0
 3f05c1c:	0a000003 	beq	3f05c30 <do_bootvx+0x144>
		addr = load_elf_image (addr);
 3f05c20:	e1a00005 	mov	r0, r5
 3f05c24:	eb000033 	bl	3f05cf8 <load_elf_image>
 3f05c28:	e1a05000 	mov	r5, r0
	} else {
 3f05c2c:	ea000001 	b	3f05c38 <do_bootvx+0x14c>
		printf ("## Not an ELF image, assuming binary\n");
 3f05c30:	e59f0054 	ldr	r0, [pc, #54]	; 3f05c8c <do_bootvx+0x1a0>
 3f05c34:	eb001b02 	bl	3f0c844 <printf>
		/* leave addr as load_addr */
	}

	printf ("## Using bootline (@ 0x%lx): %s\n", bootaddr,
 3f05c38:	e1a01006 	mov	r1, r6
 3f05c3c:	e59f004c 	ldr	r0, [pc, #4c]	; 3f05c90 <do_bootvx+0x1a4>
 3f05c40:	e1a02001 	mov	r2, r1
 3f05c44:	eb001afe 	bl	3f0c844 <printf>
			(char *) bootaddr);
	printf ("## Starting vxWorks at 0x%08lx ...\n", addr);
 3f05c48:	e59f0044 	ldr	r0, [pc, #44]	; 3f05c94 <do_bootvx+0x1a8>
 3f05c4c:	e1a01005 	mov	r1, r5
 3f05c50:	eb001afb 	bl	3f0c844 <printf>

	((void (*)(void)) addr) ();
 3f05c54:	e1a0e00f 	mov	r14, r15
 3f05c58:	e1a0f005 	mov	r15, r5

	printf ("## vxWorks terminated\n");
 3f05c5c:	e59f0034 	ldr	r0, [pc, #34]	; 3f05c98 <do_bootvx+0x1ac>
 3f05c60:	eb001af7 	bl	3f0c844 <printf>
	return 1;
 3f05c64:	e3a00001 	mov	r0, #1	; 0x1
}
 3f05c68:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f05c6c:	03f1c2d8 	mvneqs	r12, #-2147483635	; 0x8000000d
 3f05c70:	03f1c2e4 	mvneqs	r12, #1073741838	; 0x4000000e
 3f05c74:	03f1c300 	mvneqs	r12, #0	; 0x0
 3f05c78:	03f1c308 	mvneqs	r12, #536870912	; 0x20000000
 3f05c7c:	03f1c344 	mvneqs	r12, #268435457	; 0x10000001
 3f05c80:	03f1c374 	mvneqs	r12, #-805306367	; 0xd0000001
 3f05c84:	03f1c380 	mvneqs	r12, #2	; 0x2
 3f05c88:	03f1c38c 	mvneqs	r12, #805306370	; 0x30000002
 3f05c8c:	03f1c3a4 	mvneqs	r12, #-1879048190	; 0x90000002
 3f05c90:	03f1c3cc 	mvneqs	r12, #805306371	; 0x30000003
 3f05c94:	03f1c3f0 	mvneqs	r12, #-1073741821	; 0xc0000003
 3f05c98:	03f1c414 	mvneqs	r12, #335544320	; 0x14000000

03f05c9c <valid_elf_image>:
 3f05c9c:	e1a0c00d 	mov	r12, r13
 3f05ca0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

/* ======================================================================
 * Determine if a valid ELF image exists at the given memory location.
 * First looks at the ELF header magic field, the makes sure that it is
 * executable and makes sure that it is for a PowerPC.
 * ====================================================================== */
int valid_elf_image (unsigned long addr)
{
	Elf32_Ehdr *ehdr;		/* Elf header structure pointer */

	/* -------------------------------------------------- */

	ehdr = (Elf32_Ehdr *) addr;

	if (!IS_ELF (*ehdr)) {
 3f05ca4:	e59f3040 	ldr	r3, [pc, #40]	; 3f05cec <valid_elf_image+0x50>
 3f05ca8:	e1a01000 	mov	r1, r0
 3f05cac:	e5912000 	ldr	r2, [r1]
 3f05cb0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f05cb4:	e1520003 	cmp	r2, r3
 3f05cb8:	0a000003 	beq	3f05ccc <valid_elf_image+0x30>
		printf ("## No elf image at address 0x%08lx\n", addr);
 3f05cbc:	e59f002c 	ldr	r0, [pc, #2c]	; 3f05cf0 <valid_elf_image+0x54>
 3f05cc0:	eb001adf 	bl	3f0c844 <printf>
		return 0;
 3f05cc4:	e3a00000 	mov	r0, #0	; 0x0
 3f05cc8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	}

	if (ehdr->e_type != ET_EXEC) {
 3f05ccc:	e1d131b0 	ldrh	r3, [r1, #16]
 3f05cd0:	e3530002 	cmp	r3, #2	; 0x2
		printf ("## Not a 32-bit elf image at address 0x%08lx\n",
			addr);
		return 0;
	}

#if 0
	if (ehdr->e_machine != EM_PPC) {
		printf ("## Not a PowerPC elf image at address 0x%08lx\n",
			addr);
		return 0;
	}
#endif

	return 1;
 3f05cd4:	e3a00001 	mov	r0, #1	; 0x1
 3f05cd8:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
 3f05cdc:	e59f0010 	ldr	r0, [pc, #10]	; 3f05cf4 <valid_elf_image+0x58>
 3f05ce0:	eb001ad7 	bl	3f0c844 <printf>
 3f05ce4:	e3a00000 	mov	r0, #0	; 0x0
}
 3f05ce8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f05cec:	464c457f 	undefined
 3f05cf0:	03f1c42c 	mvneqs	r12, #738197504	; 0x2c000000
 3f05cf4:	03f1c450 	mvneqs	r12, #1342177280	; 0x50000000

03f05cf8 <load_elf_image>:
 3f05cf8:	e1a0c00d 	mov	r12, r13
 3f05cfc:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}


/* ======================================================================
 * A very simple elf loader, assumes the image is valid, returns the
 * entry point address.
 * ====================================================================== */
unsigned long load_elf_image (unsigned long addr)
{
 3f05d00:	e1a05000 	mov	r5, r0
 3f05d04:	e24dd004 	sub	r13, r13, #4	; 0x4
	Elf32_Ehdr *ehdr;		/* Elf header structure pointer     */
	Elf32_Shdr *shdr;		/* Section header structure pointer */
	unsigned char *strtab = 0;	/* String table pointer             */
	unsigned char *image;		/* Binary image pointer             */
	int i;				/* Loop counter                     */

	/* -------------------------------------------------- */

	ehdr = (Elf32_Ehdr *) addr;

	/* Find the section header string table for output info */
	shdr = (Elf32_Shdr *) (addr + ehdr->e_shoff +
 3f05d08:	e5953020 	ldr	r3, [r5, #32]
 3f05d0c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f05d10:	e1d523b2 	ldrh	r2, [r5, #50]
 3f05d14:	e0853003 	add	r3, r5, r3
 3f05d18:	e0822102 	add	r2, r2, r2, lsl #2
 3f05d1c:	e0834182 	add	r4, r3, r2, lsl #3
			       (ehdr->e_shstrndx * sizeof (Elf32_Shdr)));

	if (shdr->sh_type == SHT_STRTAB)
 3f05d20:	e5943004 	ldr	r3, [r4, #4]
 3f05d24:	e3a0a000 	mov	r10, #0	; 0x0
 3f05d28:	e3530003 	cmp	r3, #3	; 0x3
		strtab = (unsigned char *) (addr + shdr->sh_offset);
 3f05d2c:	05943010 	ldreq	r3, [r4, #16]
 3f05d30:	0085a003 	addeq	r10, r5, r3

	/* Load each appropriate section */
	for (i = 0; i < ehdr->e_shnum; ++i) {
 3f05d34:	e1d533b0 	ldrh	r3, [r5, #48]
 3f05d38:	e3a06000 	mov	r6, #0	; 0x0
 3f05d3c:	e1560003 	cmp	r6, r3
 3f05d40:	aa000030 	bge	3f05e08 <load_elf_image+0x110>
 3f05d44:	e1a07006 	mov	r7, r6
		shdr = (Elf32_Shdr *) (addr + ehdr->e_shoff +
 3f05d48:	e5953020 	ldr	r3, [r5, #32]
 3f05d4c:	e0852003 	add	r2, r5, r3
 3f05d50:	e0824007 	add	r4, r2, r7
				       (i * sizeof (Elf32_Shdr)));

		if (!(shdr->sh_flags & SHF_ALLOC)
 3f05d54:	e5943008 	ldr	r3, [r4, #8]
 3f05d58:	e3130002 	tst	r3, #2	; 0x2
 3f05d5c:	0a000024 	beq	3f05df4 <load_elf_image+0xfc>
 3f05d60:	e594e00c 	ldr	r14, [r4, #12]
 3f05d64:	e35e0000 	cmp	r14, #0	; 0x0
 3f05d68:	0a000021 	beq	3f05df4 <load_elf_image+0xfc>
 3f05d6c:	e5941014 	ldr	r1, [r4, #20]
 3f05d70:	e3510000 	cmp	r1, #0	; 0x0
 3f05d74:	0a00001e 	beq	3f05df4 <load_elf_image+0xfc>
		   || shdr->sh_addr == 0 || shdr->sh_size == 0) {
			continue;
		}

		if (strtab) {
 3f05d78:	e35a0000 	cmp	r10, #0	; 0x0
 3f05d7c:	0a00000a 	beq	3f05dac <load_elf_image+0xb4>
			printf ("%sing %s @ 0x%08lx (%ld bytes)\n",
 3f05d80:	e59fc044 	ldr	r12, [pc, #44]	; 3f05dcc <load_elf_image+0xd4>
 3f05d84:	e5943004 	ldr	r3, [r4, #4]
 3f05d88:	e7922007 	ldr	r2, [r2, r7]
 3f05d8c:	e58d1000 	str	r1, [r13]
 3f05d90:	e59f1038 	ldr	r1, [pc, #38]	; 3f05dd0 <load_elf_image+0xd8>
 3f05d94:	e59f0038 	ldr	r0, [pc, #38]	; 3f05dd4 <load_elf_image+0xdc>
 3f05d98:	e3530008 	cmp	r3, #8	; 0x8
 3f05d9c:	11a0100c 	movne	r1, r12
 3f05da0:	e08a2002 	add	r2, r10, r2
 3f05da4:	e1a0300e 	mov	r3, r14
 3f05da8:	eb001aa5 	bl	3f0c844 <printf>
				(shdr->sh_type == SHT_NOBITS) ?
					"Clear" : "Load",
				&strtab[shdr->sh_name],
				(unsigned long) shdr->sh_addr,
				(long) shdr->sh_size);
		}

		if (shdr->sh_type == SHT_NOBITS) {
 3f05dac:	e5943004 	ldr	r3, [r4, #4]
 3f05db0:	e3530008 	cmp	r3, #8	; 0x8
 3f05db4:	1a000007 	bne	3f05dd8 <load_elf_image+0xe0>
			memset ((void *)shdr->sh_addr, 0, shdr->sh_size);
 3f05db8:	e594000c 	ldr	r0, [r4, #12]
 3f05dbc:	e5942014 	ldr	r2, [r4, #20]
 3f05dc0:	e3a01000 	mov	r1, #0	; 0x0
 3f05dc4:	eb0025d5 	bl	3f0f520 <memset>
		} else {
 3f05dc8:	ea000006 	b	3f05de8 <load_elf_image+0xf0>
 3f05dcc:	03f1c4a8 	mvneqs	r12, #-1476395008	; 0xa8000000
 3f05dd0:	03f1c4a0 	mvneqs	r12, #-1610612736	; 0xa0000000
 3f05dd4:	03f1c480 	mvneqs	r12, #-2147483648	; 0x80000000
			image = (unsigned char *) addr + shdr->sh_offset;
			memcpy ((void *) shdr->sh_addr,
 3f05dd8:	e284000c 	add	r0, r4, #12	; 0xc
 3f05ddc:	e8900007 	ldmia	r0, {r0, r1, r2}
 3f05de0:	e0851001 	add	r1, r5, r1
 3f05de4:	eb0025e7 	bl	3f0f588 <memcpy>
				(const void *) image,
				shdr->sh_size);
		}
		flush_cache (shdr->sh_addr, shdr->sh_size);
 3f05de8:	e594000c 	ldr	r0, [r4, #12]
 3f05dec:	e5941014 	ldr	r1, [r4, #20]
 3f05df0:	eb004925 	bl	3f1828c <flush_cache>
 3f05df4:	e2877028 	add	r7, r7, #40	; 0x28
 3f05df8:	e1d533b0 	ldrh	r3, [r5, #48]
 3f05dfc:	e2866001 	add	r6, r6, #1	; 0x1
 3f05e00:	e1560003 	cmp	r6, r3
 3f05e04:	baffffcf 	blt	3f05d48 <load_elf_image+0x50>
	}

	return ehdr->e_entry;
 3f05e08:	e5950018 	ldr	r0, [r5, #24]
}
 3f05e0c:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f05e10 <get_dev>:
 3f05e10:	e1a0c00d 	mov	r12, r13
 3f05e14:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f05e18:	e24cb004 	sub	r11, r12, #4	; 0x4
#include <fat.h>


block_dev_desc_t *get_dev (char* ifname, int dev)
{
 3f05e1c:	e1a04001 	mov	r4, r1
#if (CONFIG_COMMANDS & CFG_CMD_IDE)
	if (strncmp(ifname,"ide",3)==0) {
		extern block_dev_desc_t * ide_get_dev(int dev);
		return(ide_get_dev(dev));
	}
#endif
#if (CONFIG_COMMANDS & CFG_CMD_SCSI)
	if (strncmp(ifname,"scsi",4)==0) {
		extern block_dev_desc_t * scsi_get_dev(int dev);
		return(scsi_get_dev(dev));
	}
#endif
#if ((CONFIG_COMMANDS & CFG_CMD_USB) && defined(CONFIG_USB_STORAGE))
	if (strncmp(ifname,"usb",3)==0) {
		extern block_dev_desc_t * usb_stor_get_dev(int dev);
		return(usb_stor_get_dev(dev));
	}
#endif
#if defined(CONFIG_MMC)
	if (strncmp(ifname,"mmc",3)==0) {
 3f05e20:	e59f101c 	ldr	r1, [pc, #1c]	; 3f05e44 <get_dev+0x34>
 3f05e24:	e3a02003 	mov	r2, #3	; 0x3
 3f05e28:	eb0024f1 	bl	3f0f1f4 <strncmp>
 3f05e2c:	e3500000 	cmp	r0, #0	; 0x0
		extern block_dev_desc_t *  mmc_get_dev(int dev);
		return(mmc_get_dev(dev));
	}
#endif
	return NULL;
 3f05e30:	e3a00000 	mov	r0, #0	; 0x0
 3f05e34:	191ba810 	ldmnedb	r11, {r4, r11, r13, r15}
 3f05e38:	e1a00004 	mov	r0, r4
 3f05e3c:	eb0038c7 	bl	3f14160 <mmc_get_dev>
}
 3f05e40:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f05e44:	03f1c578 	mvneqs	r12, #503316480	; 0x1e000000

03f05e48 <do_fat_fsload>:
 3f05e48:	e1a0c00d 	mov	r12, r13
 3f05e4c:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f05e50:	e24cb004 	sub	r11, r12, #4	; 0x4


int do_fat_fsload(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	long size;
	unsigned long offset;
	unsigned long count;
	char buf [12];
	block_dev_desc_t *dev_desc = NULL;
 3f05e54:	e3a0a000 	mov	r10, #0	; 0x0
	int dev = 0;
	int part = 1;
 3f05e58:	e3a07001 	mov	r7, #1	; 0x1
 3f05e5c:	e1a06002 	mov	r6, r2
	char *ep;

	if(argc < 5) 
 3f05e60:	e3560004 	cmp	r6, #4	; 0x4
 3f05e64:	e1a05003 	mov	r5, r3
 3f05e68:	e24dd014 	sub	r13, r13, #20	; 0x14
 3f05e6c:	ca000003 	bgt	3f05e80 <do_fat_fsload+0x38>
	{
		printf ("usage: fatload <interface> <dev[:part]> <addr> <filename> [bytes]\n");
 3f05e70:	e59f0114 	ldr	r0, [pc, #114]	; 3f05f8c <do_fat_fsload+0x144>
 3f05e74:	eb001a72 	bl	3f0c844 <printf>
		return (0);
 3f05e78:	e1a0000a 	mov	r0, r10
 3f05e7c:	ea000053 	b	3f05fd0 <do_fat_fsload+0x188>
	}
	dev = (int)simple_strtoul (argv[2], &ep, 16);
 3f05e80:	e24b1030 	sub	r1, r11, #48	; 0x30
 3f05e84:	e5950008 	ldr	r0, [r5, #8]
 3f05e88:	e3a02010 	mov	r2, #16	; 0x10
 3f05e8c:	eb00262c 	bl	3f0f744 <simple_strtoul>
 3f05e90:	e1a0a000 	mov	r10, r0
	dev_desc = get_dev(argv[1], dev);
 3f05e94:	e5950004 	ldr	r0, [r5, #4]
 3f05e98:	e1a0100a 	mov	r1, r10
 3f05e9c:	ebffffdb 	bl	3f05e10 <get_dev>

	if(dev_desc == NULL) 
 3f05ea0:	e2504000 	subs	r4, r0, #0	; 0x0
	{
		puts ("\n** Invalid boot device **\n");
 3f05ea4:	059f00e4 	ldreq	r0, [pc, #e4]	; 3f05f90 <do_fat_fsload+0x148>
		return 1;
 3f05ea8:	0a000006 	beq	3f05ec8 <do_fat_fsload+0x80>
	}
	if(*ep) 
 3f05eac:	e51b3030 	ldr	r3, [r11, -#48]
 3f05eb0:	e5d32000 	ldrb	r2, [r3]
 3f05eb4:	e3520000 	cmp	r2, #0	; 0x0
 3f05eb8:	0a00000c 	beq	3f05ef0 <do_fat_fsload+0xa8>
	{
		if (*ep != ':') 
 3f05ebc:	e352003a 	cmp	r2, #58	; 0x3a
 3f05ec0:	0a000003 	beq	3f05ed4 <do_fat_fsload+0x8c>
		{
			puts ("\n** Invalid boot device, use `dev[:part]' **\n");
 3f05ec4:	e59f00c8 	ldr	r0, [pc, #c8]	; 3f05f94 <do_fat_fsload+0x14c>
 3f05ec8:	eb001a50 	bl	3f0c810 <puts>
			return 1;
 3f05ecc:	e3a00001 	mov	r0, #1	; 0x1
 3f05ed0:	ea00003e 	b	3f05fd0 <do_fat_fsload+0x188>
		}
		part = (int)simple_strtoul(++ep, NULL, 16);
 3f05ed4:	e2833001 	add	r3, r3, #1	; 0x1
 3f05ed8:	e1a00003 	mov	r0, r3
 3f05edc:	e3a01000 	mov	r1, #0	; 0x0
 3f05ee0:	e3a02010 	mov	r2, #16	; 0x10
 3f05ee4:	e50b3030 	str	r3, [r11, -#48]
 3f05ee8:	eb002615 	bl	3f0f744 <simple_strtoul>
 3f05eec:	e1a07000 	mov	r7, r0
	}

	if(fat_register_device(dev_desc, part)!=0) 
 3f05ef0:	e1a00004 	mov	r0, r4
 3f05ef4:	e1a01007 	mov	r1, r7
 3f05ef8:	eb00490e 	bl	3f18338 <fat_register_device>
 3f05efc:	e2504000 	subs	r4, r0, #0	; 0x0
 3f05f00:	0a000006 	beq	3f05f20 <do_fat_fsload+0xd8>
	{
		printf ("\n** Unable to use %s %d:%d for fatload **\n",argv[1],dev,part);
 3f05f04:	e59f008c 	ldr	r0, [pc, #8c]	; 3f05f98 <do_fat_fsload+0x150>
 3f05f08:	e1a0200a 	mov	r2, r10
 3f05f0c:	e5951004 	ldr	r1, [r5, #4]
 3f05f10:	e1a03007 	mov	r3, r7
 3f05f14:	eb001a4a 	bl	3f0c844 <printf>
		return 1;
 3f05f18:	e3a00001 	mov	r0, #1	; 0x1
 3f05f1c:	ea00002b 	b	3f05fd0 <do_fat_fsload+0x188>
	}

	offset = simple_strtoul(argv[3], NULL, 16);
 3f05f20:	e1a01004 	mov	r1, r4
 3f05f24:	e595000c 	ldr	r0, [r5, #12]
 3f05f28:	e3a02010 	mov	r2, #16	; 0x10
 3f05f2c:	eb002604 	bl	3f0f744 <simple_strtoul>

	if (argc == 6)	count = simple_strtoul (argv[5], NULL, 16);
 3f05f30:	e3560006 	cmp	r6, #6	; 0x6
 3f05f34:	e1a06000 	mov	r6, r0
 3f05f38:	1a000005 	bne	3f05f54 <do_fat_fsload+0x10c>
 3f05f3c:	e1a01004 	mov	r1, r4
 3f05f40:	e5950014 	ldr	r0, [r5, #20]
 3f05f44:	e3a02010 	mov	r2, #16	; 0x10
 3f05f48:	eb0025fd 	bl	3f0f744 <simple_strtoul>
 3f05f4c:	e1a02000 	mov	r2, r0
 3f05f50:	ea000000 	b	3f05f58 <do_fat_fsload+0x110>
	else			count = 0;
 3f05f54:	e1a02004 	mov	r2, r4

	size = file_fat_read(argv[4], (unsigned char*)offset, count);
 3f05f58:	e5950010 	ldr	r0, [r5, #16]
 3f05f5c:	e1a01006 	mov	r1, r6
 3f05f60:	eb004e74 	bl	3f19938 <file_fat_read>
 3f05f64:	e1a06000 	mov	r6, r0

	if(size == -1) 
 3f05f68:	e3760001 	cmn	r6, #1	; 0x1
 3f05f6c:	1a00000b 	bne	3f05fa0 <do_fat_fsload+0x158>
	{
		printf("\n** Unable to read \"%s\" from %s %d:%d **\n",argv[4],argv[1],dev,part);
 3f05f70:	e58d7000 	str	r7, [r13]
 3f05f74:	e59f0020 	ldr	r0, [pc, #20]	; 3f05f9c <do_fat_fsload+0x154>
 3f05f78:	e5951010 	ldr	r1, [r5, #16]
 3f05f7c:	e5952004 	ldr	r2, [r5, #4]
 3f05f80:	e1a0300a 	mov	r3, r10
 3f05f84:	eb001a2e 	bl	3f0c844 <printf>
	} 
 3f05f88:	ea00000f 	b	3f05fcc <do_fat_fsload+0x184>
 3f05f8c:	03f1c57c 	mvneqs	r12, #520093696	; 0x1f000000
 3f05f90:	03f1c5c0 	mvneqs	r12, #805306368	; 0x30000000
 3f05f94:	03f1c5dc 	mvneqs	r12, #922746880	; 0x37000000
 3f05f98:	03f1c60c 	mvneqs	r12, #12582912	; 0xc00000
 3f05f9c:	03f1c638 	mvneqs	r12, #58720256	; 0x3800000
	else 
	{
		printf ("\n%ld bytes read\n", size);
 3f05fa0:	e59f002c 	ldr	r0, [pc, #2c]	; 3f05fd4 <do_fat_fsload+0x18c>
 3f05fa4:	e1a01006 	mov	r1, r6
 3f05fa8:	eb001a25 	bl	3f0c844 <printf>

		sprintf(buf, "%lX", size);
 3f05fac:	e24b402c 	sub	r4, r11, #44	; 0x2c
 3f05fb0:	e1a00004 	mov	r0, r4
 3f05fb4:	e59f101c 	ldr	r1, [pc, #1c]	; 3f05fd8 <do_fat_fsload+0x190>
 3f05fb8:	e1a02006 	mov	r2, r6
 3f05fbc:	eb00281e 	bl	3f1003c <sprintf>
		setenv("filesize", buf);
 3f05fc0:	e59f0014 	ldr	r0, [pc, #14]	; 3f05fdc <do_fat_fsload+0x194>
 3f05fc4:	e1a01004 	mov	r1, r4
 3f05fc8:	eb001802 	bl	3f0bfd8 <setenv>
	}

	return size;
 3f05fcc:	e1a00006 	mov	r0, r6
 3f05fd0:	ea000002 	b	3f05fe0 <do_fat_fsload+0x198>
 3f05fd4:	03f1c664 	mvneqs	r12, #104857600	; 0x6400000
 3f05fd8:	03f1c678 	mvneqs	r12, #125829120	; 0x7800000
 3f05fdc:	03f1c67c 	mvneqs	r12, #130023424	; 0x7c00000
}
 3f05fe0:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f05fe4 <do_fat_ls>:
 3f05fe4:	e1a0c00d 	mov	r12, r13
 3f05fe8:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f05fec:	e24cb004 	sub	r11, r12, #4	; 0x4


U_BOOT_CMD(
	fatload,	6,	0,	do_fat_fsload,
	"fatload - load binary file from a dos filesystem\n",
	"<interface> <dev[:part]>  <addr> <filename> [bytes]\n"
	"    - load binary file 'filename' from 'dev' on 'interface'\n"
	"      to address 'addr' from dos filesystem\n"
);

int do_fat_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	char *filename = "/";
	int ret;
	int dev = 0;
 3f05ff0:	e3a06000 	mov	r6, #0	; 0x0
	int part = 1;
 3f05ff4:	e3a05001 	mov	r5, #1	; 0x1
 3f05ff8:	e1a0a002 	mov	r10, r2
	char *ep;
	block_dev_desc_t *dev_desc=NULL;

	if(argc < 3) 
 3f05ffc:	e35a0002 	cmp	r10, #2	; 0x2
 3f06000:	e1a04003 	mov	r4, r3
 3f06004:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f06008:	ca000003 	bgt	3f0601c <do_fat_ls+0x38>
	{
		printf ("usage: fatls <interface> <dev[:part]> [directory]\n");
 3f0600c:	e59f00a8 	ldr	r0, [pc, #a8]	; 3f060bc <do_fat_ls+0xd8>
 3f06010:	eb001a0b 	bl	3f0c844 <printf>
		return (0);
 3f06014:	e1a00006 	mov	r0, r6
 3f06018:	ea000035 	b	3f060f4 <do_fat_ls+0x110>
	}
	dev = (int)simple_strtoul (argv[2], &ep, 16);
 3f0601c:	e24b1024 	sub	r1, r11, #36	; 0x24
 3f06020:	e5940008 	ldr	r0, [r4, #8]
 3f06024:	e3a02010 	mov	r2, #16	; 0x10
 3f06028:	eb0025c5 	bl	3f0f744 <simple_strtoul>
 3f0602c:	e1a06000 	mov	r6, r0
	dev_desc=get_dev(argv[1],dev);
 3f06030:	e5940004 	ldr	r0, [r4, #4]
 3f06034:	e1a01006 	mov	r1, r6
 3f06038:	ebffff74 	bl	3f05e10 <get_dev>
	if(dev_desc == NULL) 
 3f0603c:	e2507000 	subs	r7, r0, #0	; 0x0
	{
		puts ("\n** Invalid boot device **\n");
 3f06040:	059f0078 	ldreq	r0, [pc, #78]	; 3f060c0 <do_fat_ls+0xdc>
		return 1;
 3f06044:	0a000006 	beq	3f06064 <do_fat_ls+0x80>
	}
	if(*ep) 
 3f06048:	e51b3024 	ldr	r3, [r11, -#36]
 3f0604c:	e5d32000 	ldrb	r2, [r3]
 3f06050:	e3520000 	cmp	r2, #0	; 0x0
 3f06054:	0a00000c 	beq	3f0608c <do_fat_ls+0xa8>
	{
		if (*ep != ':') 
 3f06058:	e352003a 	cmp	r2, #58	; 0x3a
 3f0605c:	0a000003 	beq	3f06070 <do_fat_ls+0x8c>
		{
			puts ("\n** Invalid boot device, use `dev[:part]' **\n");
 3f06060:	e59f005c 	ldr	r0, [pc, #5c]	; 3f060c4 <do_fat_ls+0xe0>
 3f06064:	eb0019e9 	bl	3f0c810 <puts>
			return 1;
 3f06068:	e3a00001 	mov	r0, #1	; 0x1
 3f0606c:	ea000020 	b	3f060f4 <do_fat_ls+0x110>
		}
		part = (int)simple_strtoul(++ep, NULL, 16);
 3f06070:	e2833001 	add	r3, r3, #1	; 0x1
 3f06074:	e1a00003 	mov	r0, r3
 3f06078:	e3a01000 	mov	r1, #0	; 0x0
 3f0607c:	e3a02010 	mov	r2, #16	; 0x10
 3f06080:	e50b3024 	str	r3, [r11, -#36]
 3f06084:	eb0025ae 	bl	3f0f744 <simple_strtoul>
 3f06088:	e1a05000 	mov	r5, r0
	}
	if(fat_register_device(dev_desc,part)!=0) 
 3f0608c:	e1a00007 	mov	r0, r7
 3f06090:	e1a01005 	mov	r1, r5
 3f06094:	eb0048a7 	bl	3f18338 <fat_register_device>
 3f06098:	e3500000 	cmp	r0, #0	; 0x0
 3f0609c:	0a00000a 	beq	3f060cc <do_fat_ls+0xe8>
	{
		printf ("\n** Unable to use %s %d:%d for fatls **\n",argv[1],dev,part);
 3f060a0:	e59f0020 	ldr	r0, [pc, #20]	; 3f060c8 <do_fat_ls+0xe4>
 3f060a4:	e1a02006 	mov	r2, r6
 3f060a8:	e5941004 	ldr	r1, [r4, #4]
 3f060ac:	e1a03005 	mov	r3, r5
 3f060b0:	eb0019e3 	bl	3f0c844 <printf>
		return 1;
 3f060b4:	e3a00001 	mov	r0, #1	; 0x1
 3f060b8:	ea00000d 	b	3f060f4 <do_fat_ls+0x110>
 3f060bc:	03f1c768 	mvneqs	r12, #27262976	; 0x1a00000
 3f060c0:	03f1c5c0 	mvneqs	r12, #805306368	; 0x30000000
 3f060c4:	03f1c5dc 	mvneqs	r12, #922746880	; 0x37000000
 3f060c8:	03f1c79c 	mvneqs	r12, #40894464	; 0x2700000
	}
	if(argc == 4)	ret = file_fat_ls(argv[3]);
 3f060cc:	e35a0004 	cmp	r10, #4	; 0x4
	else			ret = file_fat_ls(filename);
 3f060d0:	e59f0020 	ldr	r0, [pc, #20]	; 3f060f8 <do_fat_ls+0x114>
 3f060d4:	0594000c 	ldreq	r0, [r4, #12]
 3f060d8:	eb004e0e 	bl	3f19918 <file_fat_ls>
 3f060dc:	e1a04000 	mov	r4, r0

	if(ret!=0)	printf("No Fat FS detected\n");
 3f060e0:	e3540000 	cmp	r4, #0	; 0x0
 3f060e4:	0a000001 	beq	3f060f0 <do_fat_ls+0x10c>
 3f060e8:	e59f000c 	ldr	r0, [pc, #c]	; 3f060fc <do_fat_ls+0x118>
 3f060ec:	eb0019d4 	bl	3f0c844 <printf>
	
	return (ret);
 3f060f0:	e1a00004 	mov	r0, r4
 3f060f4:	ea000001 	b	3f06100 <do_fat_ls+0x11c>
 3f060f8:	03f1c764 	mvneqs	r12, #26214400	; 0x1900000
 3f060fc:	03f1c7c8 	mvneqs	r12, #52428800	; 0x3200000
}
 3f06100:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f06104 <do_fat_fsinfo>:
 3f06104:	e1a0c00d 	mov	r12, r13
 3f06108:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f0610c:	e24cb004 	sub	r11, r12, #4	; 0x4

U_BOOT_CMD(
	fatls,	4,	1,	do_fat_ls,
	"fatls   - list files in a directory (default /)\n",
	"<interface> <dev[:part]> [directory]\n"
	"    - list files from 'dev' on 'interface' in a 'directory'\n"
);

int do_fat_fsinfo (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	int dev=0;
 3f06110:	e3a06000 	mov	r6, #0	; 0x0
	int part=1;
 3f06114:	e3a05001 	mov	r5, #1	; 0x1
	char *ep;
	block_dev_desc_t *dev_desc=NULL;

	if (argc < 2) {
 3f06118:	e1520005 	cmp	r2, r5
 3f0611c:	e1a04003 	mov	r4, r3
 3f06120:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f06124:	ca000003 	bgt	3f06138 <do_fat_fsinfo+0x34>
		printf ("usage: fatinfo <interface> <dev[:part]>\n");
 3f06128:	e59f0098 	ldr	r0, [pc, #98]	; 3f061c8 <do_fat_fsinfo+0xc4>
 3f0612c:	eb0019c4 	bl	3f0c844 <printf>
		return (0);
 3f06130:	e1a00006 	mov	r0, r6
 3f06134:	ea00002c 	b	3f061ec <do_fat_fsinfo+0xe8>
	}
	dev = (int)simple_strtoul (argv[2], &ep, 16);
 3f06138:	e24b1020 	sub	r1, r11, #32	; 0x20
 3f0613c:	e5940008 	ldr	r0, [r4, #8]
 3f06140:	e3a02010 	mov	r2, #16	; 0x10
 3f06144:	eb00257e 	bl	3f0f744 <simple_strtoul>
 3f06148:	e1a06000 	mov	r6, r0
	dev_desc=get_dev(argv[1],dev);
 3f0614c:	e5940004 	ldr	r0, [r4, #4]
 3f06150:	e1a01006 	mov	r1, r6
 3f06154:	ebffff2d 	bl	3f05e10 <get_dev>
	if (dev_desc==NULL) {
 3f06158:	e2507000 	subs	r7, r0, #0	; 0x0
 3f0615c:	1a000002 	bne	3f0616c <do_fat_fsinfo+0x68>
		puts ("\n** Invalid boot device **\n");
 3f06160:	e59f0064 	ldr	r0, [pc, #64]	; 3f061cc <do_fat_fsinfo+0xc8>
 3f06164:	eb0019a9 	bl	3f0c810 <puts>
		return 1;
 3f06168:	ea00001e 	b	3f061e8 <do_fat_fsinfo+0xe4>
	}
	if (*ep) {
 3f0616c:	e51b3020 	ldr	r3, [r11, -#32]
 3f06170:	e5d32000 	ldrb	r2, [r3]
 3f06174:	e3520000 	cmp	r2, #0	; 0x0
 3f06178:	0a00000b 	beq	3f061ac <do_fat_fsinfo+0xa8>
		if (*ep != ':') {
 3f0617c:	e352003a 	cmp	r2, #58	; 0x3a
 3f06180:	0a000002 	beq	3f06190 <do_fat_fsinfo+0x8c>
			puts ("\n** Invalid boot device, use `dev[:part]' **\n");
 3f06184:	e59f0044 	ldr	r0, [pc, #44]	; 3f061d0 <do_fat_fsinfo+0xcc>
 3f06188:	eb0019a0 	bl	3f0c810 <puts>
			return 1;
 3f0618c:	ea000015 	b	3f061e8 <do_fat_fsinfo+0xe4>
		}
		part = (int)simple_strtoul(++ep, NULL, 16);
 3f06190:	e2833001 	add	r3, r3, #1	; 0x1
 3f06194:	e1a00003 	mov	r0, r3
 3f06198:	e3a01000 	mov	r1, #0	; 0x0
 3f0619c:	e3a02010 	mov	r2, #16	; 0x10
 3f061a0:	e50b3020 	str	r3, [r11, -#32]
 3f061a4:	eb002566 	bl	3f0f744 <simple_strtoul>
 3f061a8:	e1a05000 	mov	r5, r0
	}
	if (fat_register_device(dev_desc,part)!=0) {
 3f061ac:	e1a00007 	mov	r0, r7
 3f061b0:	e1a01005 	mov	r1, r5
 3f061b4:	eb00485f 	bl	3f18338 <fat_register_device>
 3f061b8:	e3500000 	cmp	r0, #0	; 0x0
 3f061bc:	1a000004 	bne	3f061d4 <do_fat_fsinfo+0xd0>
		printf ("\n** Unable to use %s %d:%d for fatinfo **\n",argv[1],dev,part);
		return 1;
	}
	return (file_fat_detectfs ());
 3f061c0:	eb004d7b 	bl	3f197b4 <file_fat_detectfs>
 3f061c4:	ea000008 	b	3f061ec <do_fat_fsinfo+0xe8>
 3f061c8:	03f1c87c 	mvneqs	r12, #8126464	; 0x7c0000
 3f061cc:	03f1c5c0 	mvneqs	r12, #805306368	; 0x30000000
 3f061d0:	03f1c5dc 	mvneqs	r12, #922746880	; 0x37000000
 3f061d4:	e59f0014 	ldr	r0, [pc, #14]	; 3f061f0 <do_fat_fsinfo+0xec>
 3f061d8:	e1a02006 	mov	r2, r6
 3f061dc:	e5941004 	ldr	r1, [r4, #4]
 3f061e0:	e1a03005 	mov	r3, r5
 3f061e4:	eb001996 	bl	3f0c844 <printf>
 3f061e8:	e3a00001 	mov	r0, #1	; 0x1
 3f061ec:	ea000000 	b	3f061f4 <do_fat_fsinfo+0xf0>
 3f061f0:	03f1c8a8 	mvneqs	r12, #11010048	; 0xa80000
}
 3f061f4:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}

03f061f8 <abbrev_spec>:
 3f061f8:	e1a0c00d 	mov	r12, r13
 3f061fc:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f06200:	e24cb004 	sub	r11, r12, #4	; 0x4
 *			  or an invalid flash bank.
 */
static int
abbrev_spec (char *str, flash_info_t ** pinfo, int *psf, int *psl)
{
 3f06204:	e1a04000 	mov	r4, r0
 3f06208:	e1a09002 	mov	r9, r2
 3f0620c:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f06210:	e50b102c 	str	r1, [r11, -#44]
	flash_info_t *fp;
	int bank, first, last;
	char *p, *ep;

	if ((p = strchr (str, ':')) == NULL)
 3f06214:	e3a0103a 	mov	r1, #58	; 0x3a
 3f06218:	e50b3030 	str	r3, [r11, -#48]
 3f0621c:	eb002409 	bl	3f0f248 <strchr>
 3f06220:	e2505000 	subs	r5, r0, #0	; 0x0
		return 0;
 3f06224:	01a00005 	moveq	r0, r5
 3f06228:	0a00004b 	beq	3f0635c <abbrev_spec+0x164>
	*p++ = '\0';

	bank = simple_strtoul (str, &ep, 10);
 3f0622c:	e1a00004 	mov	r0, r4
 3f06230:	e24b7028 	sub	r7, r11, #40	; 0x28
 3f06234:	e1a01007 	mov	r1, r7
 3f06238:	e3a0200a 	mov	r2, #10	; 0xa
 3f0623c:	e3a03000 	mov	r3, #0	; 0x0
 3f06240:	e4c53001 	strb	r3, [r5], #1
 3f06244:	eb00253e 	bl	3f0f744 <simple_strtoul>
	if (ep == str || *ep != '\0' ||
 3f06248:	e51b3028 	ldr	r3, [r11, -#40]
 3f0624c:	e1530004 	cmp	r3, r4
 3f06250:	0a000036 	beq	3f06330 <abbrev_spec+0x138>
 3f06254:	e5d32000 	ldrb	r2, [r3]
 3f06258:	e3500000 	cmp	r0, #0	; 0x0
 3f0625c:	c3a03000 	movgt	r3, #0	; 0x0
 3f06260:	d3a03001 	movle	r3, #1	; 0x1
 3f06264:	e3520000 	cmp	r2, #0	; 0x0
 3f06268:	01a0a003 	moveq	r10, r3
 3f0626c:	13a0a001 	movne	r10, #1	; 0x1
 3f06270:	e35a0000 	cmp	r10, #0	; 0x0
 3f06274:	1a00002d 	bne	3f06330 <abbrev_spec+0x138>
 3f06278:	e3500000 	cmp	r0, #0	; 0x0
 3f0627c:	ca00002b 	bgt	3f06330 <abbrev_spec+0x138>
 3f06280:	e59f20b0 	ldr	r2, [pc, #b0]	; 3f06338 <abbrev_spec+0x140>
 3f06284:	e0803100 	add	r3, r0, r0, lsl #2
 3f06288:	e0826103 	add	r6, r2, r3, lsl #2
 3f0628c:	e5962008 	ldr	r2, [r6, #8]
 3f06290:	e59f30a4 	ldr	r3, [pc, #a4]	; 3f0633c <abbrev_spec+0x144>
 3f06294:	e1520003 	cmp	r2, r3
 3f06298:	0a000024 	beq	3f06330 <abbrev_spec+0x138>
		bank < 1 || bank > CFG_MAX_FLASH_BANKS ||
		(fp = &flash_info[bank - 1])->flash_id == FLASH_UNKNOWN)
		return -1;

	str = p;
 3f0629c:	e1a04005 	mov	r4, r5
	if ((p = strchr (str, '-')) != NULL)
 3f062a0:	e1a00004 	mov	r0, r4
 3f062a4:	e3a0102d 	mov	r1, #45	; 0x2d
 3f062a8:	eb0023e6 	bl	3f0f248 <strchr>
 3f062ac:	e2505000 	subs	r5, r0, #0	; 0x0
		*p++ = '\0';
 3f062b0:	14c5a001 	strneb	r10, [r5], #1

	first = simple_strtoul (str, &ep, 10);
 3f062b4:	e1a00004 	mov	r0, r4
 3f062b8:	e1a01007 	mov	r1, r7
 3f062bc:	e3a0200a 	mov	r2, #10	; 0xa
 3f062c0:	eb00251f 	bl	3f0f744 <simple_strtoul>
	if (ep == str || *ep != '\0' || first >= fp->sector_count)
 3f062c4:	e51b3028 	ldr	r3, [r11, -#40]
 3f062c8:	e1530004 	cmp	r3, r4
 3f062cc:	e1a04000 	mov	r4, r0
 3f062d0:	0a000016 	beq	3f06330 <abbrev_spec+0x138>
 3f062d4:	e5d33000 	ldrb	r3, [r3]
 3f062d8:	e3530000 	cmp	r3, #0	; 0x0
 3f062dc:	1a000013 	bne	3f06330 <abbrev_spec+0x138>
 3f062e0:	e1d630b4 	ldrh	r3, [r6, #4]
 3f062e4:	e1540003 	cmp	r4, r3
 3f062e8:	aa000010 	bge	3f06330 <abbrev_spec+0x138>
		return -1;

	if (p != NULL) {
 3f062ec:	e3550000 	cmp	r5, #0	; 0x0
 3f062f0:	0a000012 	beq	3f06340 <abbrev_spec+0x148>
		last = simple_strtoul (p, &ep, 10);
 3f062f4:	e1a00005 	mov	r0, r5
 3f062f8:	e1a01007 	mov	r1, r7
 3f062fc:	e3a0200a 	mov	r2, #10	; 0xa
 3f06300:	eb00250f 	bl	3f0f744 <simple_strtoul>
		if (ep == p || *ep != '\0' ||
 3f06304:	e51b3028 	ldr	r3, [r11, -#40]
 3f06308:	e1a02000 	mov	r2, r0
 3f0630c:	e1530005 	cmp	r3, r5
 3f06310:	0a000006 	beq	3f06330 <abbrev_spec+0x138>
 3f06314:	e5d33000 	ldrb	r3, [r3]
 3f06318:	e1520004 	cmp	r2, r4
 3f0631c:	a3530000 	cmpge	r3, #0	; 0x0
 3f06320:	1a000002 	bne	3f06330 <abbrev_spec+0x138>
 3f06324:	e1d630b4 	ldrh	r3, [r6, #4]
 3f06328:	e1520003 	cmp	r2, r3
 3f0632c:	ba000004 	blt	3f06344 <abbrev_spec+0x14c>
			last < first || last >= fp->sector_count)
			return -1;
 3f06330:	e3e00000 	mvn	r0, #0	; 0x0
 3f06334:	ea000008 	b	3f0635c <abbrev_spec+0x164>
 3f06338:	03f72ef0 	mvneqs	r2, #3840	; 0xf00
 3f0633c:	0000ffff 	streqd	r15, [r0], -r15
	} else {
		last = first;
 3f06340:	e1a02004 	mov	r2, r4
	}

	*pinfo = fp;
 3f06344:	e51b302c 	ldr	r3, [r11, -#44]
 3f06348:	e5836000 	str	r6, [r3]
	*psf = first;
 3f0634c:	e5894000 	str	r4, [r9]
	*psl = last;
 3f06350:	e51b3030 	ldr	r3, [r11, -#48]

	return 1;
 3f06354:	e3a00001 	mov	r0, #1	; 0x1
 3f06358:	e5832000 	str	r2, [r3]
}
 3f0635c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f06360 <flash_fill_sect_ranges>:
 3f06360:	e1a0c00d 	mov	r12, r13
 3f06364:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f06368:	e24cb004 	sub	r11, r12, #4	; 0x4

static int
flash_fill_sect_ranges (ulong addr_first, ulong addr_last,
			int *s_first, int *s_last,
			int *s_count )
{
 3f0636c:	e59b3004 	ldr	r3, [r11, #4]
	flash_info_t *info;
	ulong bank;
	int rcode = 0;
 3f06370:	e3a00000 	mov	r0, #0	; 0x0

	*s_count = 0;
 3f06374:	e5830000 	str	r0, [r3]

	for (bank=0; bank < CFG_MAX_FLASH_BANKS; ++bank) {
		s_first[bank] = -1;	/* first sector to erase	*/
		s_last [bank] = -1;	/* last  sector to erase	*/
	}

	for (bank=0,info=&flash_info[0];
	     (bank < CFG_MAX_FLASH_BANKS) && (addr_first <= addr_last);
	     ++bank, ++info) {
		ulong b_end;
		int sect;
		short s_end;

		if (info->flash_id == FLASH_UNKNOWN) {
			continue;
		}

		b_end = info->start[0] + info->size - 1;	/* bank end addr */
		s_end = info->sector_count - 1;			/* last sector   */


		for (sect=0; sect < info->sector_count; ++sect) {
			ulong end;	/* last address in current sect	*/

			end = (sect == s_end) ? b_end : info->start[sect + 1] - 1;

			if (addr_first > end)
				continue;
			if (addr_last < info->start[sect])
				continue;

			if (addr_first == info->start[sect]) {
				s_first[bank] = sect;
			}
			if (addr_last  == end) {
				s_last[bank]  = sect;
			}
		}
		if (s_first[bank] >= 0) {
			if (s_last[bank] < 0) {
				if (addr_last > b_end) {
					s_last[bank] = s_end;
				} else {
					printf ("Error: end address"
						" not on sector boundary\n");
					rcode = 1;
					break;
				}
			}
			if (s_last[bank] < s_first[bank]) {
				printf ("Error: end sector"
					" precedes start sector\n");
				rcode = 1;
				break;
			}
			sect = s_last[bank];
			addr_first = (sect == s_end) ? b_end + 1: info->start[sect + 1];
			(*s_count) += s_last[bank] - s_first[bank] + 1;
		} else if (s_last[bank] >= 0) {
			printf("Error: cannot span across banks when they are"
			       " mapped in reverse order\n");
			rcode = 1;
			break;
		}
	}

	return rcode;
}
 3f06378:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0637c <do_flinfo>:
 3f0637c:	e1a0c00d 	mov	r12, r13
 3f06380:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f06384:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_flinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	ulong bank;

#ifdef CONFIG_HAS_DATAFLASH
	dataflash_print_info();
#endif

	if (argc == 1) {	/* print info for all FLASH banks */
 3f06388:	e3520001 	cmp	r2, #1	; 0x1
 3f0638c:	0a000008 	beq	3f063b4 <do_flinfo+0x38>
		for (bank=0; bank <CFG_MAX_FLASH_BANKS; ++bank) {
			printf ("\nBank # %ld: ", bank+1);

			flash_print_info (&flash_info[bank]);
		}
		return 0;
	}

	bank = simple_strtoul(argv[1], NULL, 16);
 3f06390:	e3a01000 	mov	r1, #0	; 0x0
 3f06394:	e5930004 	ldr	r0, [r3, #4]
 3f06398:	e3a02010 	mov	r2, #16	; 0x10
 3f0639c:	eb0024e8 	bl	3f0f744 <simple_strtoul>
	if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
		printf ("Only FLASH Banks # 1 ... # %d supported\n",
 3f063a0:	e59f0014 	ldr	r0, [pc, #14]	; 3f063bc <do_flinfo+0x40>
 3f063a4:	e3a01000 	mov	r1, #0	; 0x0
 3f063a8:	eb001925 	bl	3f0c844 <printf>
			CFG_MAX_FLASH_BANKS);
		return 1;
 3f063ac:	e3a00001 	mov	r0, #1	; 0x1
 3f063b0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f063b4:	e3a00000 	mov	r0, #0	; 0x0
	}
	printf ("\nBank # %ld: ", bank);
	flash_print_info (&flash_info[bank-1]);
	return 0;
}
 3f063b8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f063bc:	03f1ca1c 	mvneqs	r12, #114688	; 0x1c000

03f063c0 <do_flerase>:
 3f063c0:	e1a0c00d 	mov	r12, r13
 3f063c4:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f063c8:	e24cb004 	sub	r11, r12, #4	; 0x4
int do_flerase (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f063cc:	e1a07002 	mov	r7, r2
	flash_info_t *info;
	ulong bank, addr_first, addr_last;
	int n, sect_first, sect_last;
	int rcode = 0;

	if (argc < 2) {
 3f063d0:	e3570001 	cmp	r7, #1	; 0x1
 3f063d4:	e1a06000 	mov	r6, r0
 3f063d8:	e1a04003 	mov	r4, r3
 3f063dc:	e3a0a000 	mov	r10, #0	; 0x0
 3f063e0:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f063e4:	ca000003 	bgt	3f063f8 <do_flerase+0x38>
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f063e8:	e59f0108 	ldr	r0, [pc, #108]	; 3f064f8 <do_flerase+0x138>
 3f063ec:	e5961010 	ldr	r1, [r6, #16]
 3f063f0:	eb001913 	bl	3f0c844 <printf>
		return 1;
 3f063f4:	ea000049 	b	3f06520 <do_flerase+0x160>
	}

	if (strcmp(argv[1], "all") == 0) {
 3f063f8:	e5940004 	ldr	r0, [r4, #4]
 3f063fc:	e59f10f8 	ldr	r1, [pc, #f8]	; 3f064fc <do_flerase+0x13c>
 3f06400:	eb00236c 	bl	3f0f1b8 <strcmp>
 3f06404:	e3500000 	cmp	r0, #0	; 0x0
 3f06408:	0a000045 	beq	3f06524 <do_flerase+0x164>
		for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank) {
			printf ("Erase Flash Bank # %ld ", bank);
			info = &flash_info[bank-1];
			rcode = flash_erase (info, 0, info->sector_count-1);
		}
		return rcode;
	}

	if ((n = abbrev_spec(argv[1], &info, &sect_first, &sect_last)) != 0) {
 3f0640c:	e24b1024 	sub	r1, r11, #36	; 0x24
 3f06410:	e24b2028 	sub	r2, r11, #40	; 0x28
 3f06414:	e5940004 	ldr	r0, [r4, #4]
 3f06418:	e24b302c 	sub	r3, r11, #44	; 0x2c
 3f0641c:	ebffff75 	bl	3f061f8 <abbrev_spec>
 3f06420:	e2505000 	subs	r5, r0, #0	; 0x0
 3f06424:	0a000016 	beq	3f06484 <do_flerase+0xc4>
		if (n < 0) {
 3f06428:	aa000002 	bge	3f06438 <do_flerase+0x78>
			printf("Bad sector specification\n");
 3f0642c:	e59f00cc 	ldr	r0, [pc, #cc]	; 3f06500 <do_flerase+0x140>
 3f06430:	eb001903 	bl	3f0c844 <printf>
			return 1;
 3f06434:	ea000039 	b	3f06520 <do_flerase+0x160>
		}
		printf ("Erase Flash Sectors %d-%d in Bank # %d ",
 3f06438:	e59f00c4 	ldr	r0, [pc, #c4]	; 3f06504 <do_flerase+0x144>
 3f0643c:	e24b1028 	sub	r1, r11, #40	; 0x28
 3f06440:	e891000a 	ldmia	r1, {r1, r3}
 3f06444:	e59fc0bc 	ldr	r12, [pc, #bc]	; 3f06508 <do_flerase+0x148>
 3f06448:	e51b202c 	ldr	r2, [r11, -#44]
 3f0644c:	e06c3003 	rsb	r3, r12, r3
 3f06450:	e083c083 	add	r12, r3, r3, lsl #1
 3f06454:	e08cc20c 	add	r12, r12, r12, lsl #4
 3f06458:	e08cc40c 	add	r12, r12, r12, lsl #8
 3f0645c:	e08cc80c 	add	r12, r12, r12, lsl #16
 3f06460:	e083310c 	add	r3, r3, r12, lsl #2
 3f06464:	e1a03143 	mov	r3, r3, asr #2
 3f06468:	e2833001 	add	r3, r3, #1	; 0x1
 3f0646c:	eb0018f4 	bl	3f0c844 <printf>
			sect_first, sect_last, (info-flash_info)+1);
		rcode = flash_erase(info, sect_first, sect_last);
 3f06470:	e51b0024 	ldr	r0, [r11, -#36]
 3f06474:	e51b1028 	ldr	r1, [r11, -#40]
 3f06478:	e51b202c 	ldr	r2, [r11, -#44]
 3f0647c:	eb0035f5 	bl	3f13c58 <flash_erase>
		return rcode;
 3f06480:	ea000027 	b	3f06524 <do_flerase+0x164>
	}

	if (argc != 3) {
 3f06484:	e3570003 	cmp	r7, #3	; 0x3
 3f06488:	1a000021 	bne	3f06514 <do_flerase+0x154>
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
	}

	if (strcmp(argv[1], "bank") == 0) {
 3f0648c:	e5940004 	ldr	r0, [r4, #4]
 3f06490:	e59f1074 	ldr	r1, [pc, #74]	; 3f0650c <do_flerase+0x14c>
 3f06494:	eb002347 	bl	3f0f1b8 <strcmp>
 3f06498:	e3500000 	cmp	r0, #0	; 0x0
 3f0649c:	1a000006 	bne	3f064bc <do_flerase+0xfc>
		bank = simple_strtoul(argv[2], NULL, 16);
 3f064a0:	e1a0100a 	mov	r1, r10
 3f064a4:	e5940008 	ldr	r0, [r4, #8]
 3f064a8:	e3a02010 	mov	r2, #16	; 0x10
 3f064ac:	eb0024a4 	bl	3f0f744 <simple_strtoul>
		if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
			printf ("Only FLASH Banks # 1 ... # %d supported\n",
 3f064b0:	e59f0058 	ldr	r0, [pc, #58]	; 3f06510 <do_flerase+0x150>
 3f064b4:	e1a0100a 	mov	r1, r10
				CFG_MAX_FLASH_BANKS);
			return 1;
 3f064b8:	ea000017 	b	3f0651c <do_flerase+0x15c>
		}
		printf ("Erase Flash Bank # %ld ", bank);
		info = &flash_info[bank-1];
		rcode = flash_erase (info, 0, info->sector_count-1);
		return rcode;
	}

	addr_first = simple_strtoul(argv[1], NULL, 16);
 3f064bc:	e1a01005 	mov	r1, r5
 3f064c0:	e5940004 	ldr	r0, [r4, #4]
 3f064c4:	e3a02010 	mov	r2, #16	; 0x10
 3f064c8:	eb00249d 	bl	3f0f744 <simple_strtoul>
	addr_last  = simple_strtoul(argv[2], NULL, 16);
 3f064cc:	e1a01005 	mov	r1, r5
 3f064d0:	e1a05000 	mov	r5, r0
 3f064d4:	e5940008 	ldr	r0, [r4, #8]
 3f064d8:	e3a02010 	mov	r2, #16	; 0x10
 3f064dc:	eb002498 	bl	3f0f744 <simple_strtoul>
 3f064e0:	e1a01000 	mov	r1, r0

	if (addr_first >= addr_last) {
 3f064e4:	e1550001 	cmp	r5, r1
 3f064e8:	2a000009 	bcs	3f06514 <do_flerase+0x154>
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
	}

	rcode = flash_sect_erase(addr_first, addr_last);
 3f064ec:	e1a00005 	mov	r0, r5
 3f064f0:	eb00000e 	bl	3f06530 <flash_sect_erase>
	return rcode;
 3f064f4:	ea00000a 	b	3f06524 <do_flerase+0x164>
 3f064f8:	03f1ca48 	mvneqs	r12, #294912	; 0x48000
 3f064fc:	03f1ca54 	mvneqs	r12, #344064	; 0x54000
 3f06500:	03f1ca70 	mvneqs	r12, #458752	; 0x70000
 3f06504:	03f1ca8c 	mvneqs	r12, #573440	; 0x8c000
 3f06508:	03f72f04 	mvneqs	r2, #16	; 0x10
 3f0650c:	03f1cab4 	mvneqs	r12, #737280	; 0xb4000
 3f06510:	03f1ca1c 	mvneqs	r12, #114688	; 0x1c000
 3f06514:	e59f000c 	ldr	r0, [pc, #c]	; 3f06528 <do_flerase+0x168>
 3f06518:	e5961010 	ldr	r1, [r6, #16]
 3f0651c:	eb0018c8 	bl	3f0c844 <printf>
 3f06520:	e3a00001 	mov	r0, #1	; 0x1
 3f06524:	ea000000 	b	3f0652c <do_flerase+0x16c>
 3f06528:	03f1ca48 	mvneqs	r12, #294912	; 0x48000
}
 3f0652c:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f06530 <flash_sect_erase>:
 3f06530:	e1a0c00d 	mov	r12, r13
 3f06534:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f06538:	e24cb004 	sub	r11, r12, #4	; 0x4

int flash_sect_erase (ulong addr_first, ulong addr_last)
{
	flash_info_t *info;
	ulong bank;
	int s_first[CFG_MAX_FLASH_BANKS], s_last[CFG_MAX_FLASH_BANKS];
	int erased = 0;
	int planned;
	int rcode = 0;

	rcode = flash_fill_sect_ranges (addr_first, addr_last,
 3f0653c:	e24b3014 	sub	r3, r11, #20	; 0x14
 3f06540:	e24b2010 	sub	r2, r11, #16	; 0x10
 3f06544:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f06548:	e58d3000 	str	r3, [r13]
 3f0654c:	e1a03002 	mov	r3, r2
 3f06550:	ebffff82 	bl	3f06360 <flash_fill_sect_ranges>
					s_first, s_last, &planned );

	if (planned && (rcode == 0)) {
 3f06554:	e1a04000 	mov	r4, r0
 3f06558:	e51b2014 	ldr	r2, [r11, -#20]
 3f0655c:	e3540000 	cmp	r4, #0	; 0x0
 3f06560:	13a03000 	movne	r3, #0	; 0x0
 3f06564:	03a03001 	moveq	r3, #1	; 0x1
 3f06568:	e3520000 	cmp	r2, #0	; 0x0
 3f0656c:	03a03000 	moveq	r3, #0	; 0x0
 3f06570:	e3530000 	cmp	r3, #0	; 0x0
 3f06574:	0a000004 	beq	3f0658c <flash_sect_erase+0x5c>
		for (bank=0,info=&flash_info[0];
		     (bank < CFG_MAX_FLASH_BANKS) && (rcode == 0);
		     ++bank, ++info) {
			if (s_first[bank]>=0) {
				erased += s_last[bank] - s_first[bank] + 1;
				debug ("Erase Flash from 0x%08lx to 0x%08lx "
					"in Bank # %ld ",
					info->start[s_first[bank]],
					(s_last[bank] == info->sector_count) ?
						info->start[0] + info->size - 1:
						info->start[s_last[bank]+1] - 1,
					bank+1);
				rcode = flash_erase (info, s_first[bank], s_last[bank]);
			}
		}
		printf ("Erased %d sectors\n", erased);
 3f06578:	e59f0008 	ldr	r0, [pc, #8]	; 3f06588 <flash_sect_erase+0x58>
 3f0657c:	e3a01000 	mov	r1, #0	; 0x0
 3f06580:	eb0018af 	bl	3f0c844 <printf>
	} else if (rcode == 0) {
 3f06584:	ea000005 	b	3f065a0 <flash_sect_erase+0x70>
 3f06588:	03f1cabc 	mvneqs	r12, #770048	; 0xbc000
 3f0658c:	e3540000 	cmp	r4, #0	; 0x0
 3f06590:	1a000002 	bne	3f065a0 <flash_sect_erase+0x70>
		printf ("Error: start and/or end address"
 3f06594:	e59f000c 	ldr	r0, [pc, #c]	; 3f065a8 <flash_sect_erase+0x78>
			" not on sector boundary\n");
		rcode = 1;
 3f06598:	e3a04001 	mov	r4, #1	; 0x1
 3f0659c:	eb0018a8 	bl	3f0c844 <printf>
	}
	return rcode;
 3f065a0:	e1a00004 	mov	r0, r4
 3f065a4:	ea000000 	b	3f065ac <flash_sect_erase+0x7c>
 3f065a8:	03f1cad0 	mvneqs	r12, #851968	; 0xd0000
}
 3f065ac:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f065b0 <do_protect>:
 3f065b0:	e1a0c00d 	mov	r12, r13
 3f065b4:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f065b8:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_protect (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f065bc:	e1a07002 	mov	r7, r2
	flash_info_t *info;
	ulong bank, addr_first, addr_last;
	int i, p, n, sect_first, sect_last;
	int rcode = 0;

	if (argc < 3) {
 3f065c0:	e3570002 	cmp	r7, #2	; 0x2
 3f065c4:	e1a06000 	mov	r6, r0
 3f065c8:	e1a04003 	mov	r4, r3
 3f065cc:	e24dd010 	sub	r13, r13, #16	; 0x10
 3f065d0:	da000063 	ble	3f06764 <do_protect+0x1b4>
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
	}

	if (strcmp(argv[1], "off") == 0) {
 3f065d4:	e5940004 	ldr	r0, [r4, #4]
 3f065d8:	e59f115c 	ldr	r1, [pc, #15c]	; 3f0673c <do_protect+0x18c>
 3f065dc:	eb0022f5 	bl	3f0f1b8 <strcmp>
 3f065e0:	e3500000 	cmp	r0, #0	; 0x0
		p = 0;
 3f065e4:	03a0a000 	moveq	r10, #0	; 0x0
	} else if (strcmp(argv[1], "on") == 0) {
 3f065e8:	0a000005 	beq	3f06604 <do_protect+0x54>
 3f065ec:	e5940004 	ldr	r0, [r4, #4]
 3f065f0:	e59f1148 	ldr	r1, [pc, #148]	; 3f06740 <do_protect+0x190>
 3f065f4:	eb0022ef 	bl	3f0f1b8 <strcmp>
 3f065f8:	e3500000 	cmp	r0, #0	; 0x0
 3f065fc:	1a000058 	bne	3f06764 <do_protect+0x1b4>
		p = 1;
 3f06600:	e3a0a001 	mov	r10, #1	; 0x1
	} else {
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
	}

	if (strcmp(argv[2], "all") == 0) {
 3f06604:	e5940008 	ldr	r0, [r4, #8]
 3f06608:	e59f1134 	ldr	r1, [pc, #134]	; 3f06744 <do_protect+0x194>
 3f0660c:	eb0022e9 	bl	3f0f1b8 <strcmp>
 3f06610:	e3500000 	cmp	r0, #0	; 0x0
 3f06614:	0a000056 	beq	3f06774 <do_protect+0x1c4>
		for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank) {
			info = &flash_info[bank-1];
			if (info->flash_id == FLASH_UNKNOWN) {
				continue;
			}
			printf ("%sProtect Flash Bank # %ld\n",
				p ? "" : "Un-", bank);

			for (i=0; i<info->sector_count; ++i) {
#if defined(CFG_FLASH_PROTECTION)
				if (flash_real_protect(info, i, p))
					rcode = 1;
				putc ('.');
#else
				info->protect[i] = p;
#endif	/* CFG_FLASH_PROTECTION */
			}
		}

#if defined(CFG_FLASH_PROTECTION)
		if (!rcode) puts (" done\n");
#endif	/* CFG_FLASH_PROTECTION */

		return rcode;
	}

	if ((n = abbrev_spec(argv[2], &info, &sect_first, &sect_last)) != 0) {
 3f06618:	e24b1024 	sub	r1, r11, #36	; 0x24
 3f0661c:	e24b2028 	sub	r2, r11, #40	; 0x28
 3f06620:	e5940008 	ldr	r0, [r4, #8]
 3f06624:	e24b302c 	sub	r3, r11, #44	; 0x2c
 3f06628:	ebfffef2 	bl	3f061f8 <abbrev_spec>
 3f0662c:	e2505000 	subs	r5, r0, #0	; 0x0
 3f06630:	0a000023 	beq	3f066c4 <do_protect+0x114>
		if (n < 0) {
 3f06634:	aa000002 	bge	3f06644 <do_protect+0x94>
			printf("Bad sector specification\n");
 3f06638:	e59f0108 	ldr	r0, [pc, #108]	; 3f06748 <do_protect+0x198>
 3f0663c:	eb001880 	bl	3f0c844 <printf>
			return 1;
 3f06640:	ea00004a 	b	3f06770 <do_protect+0x1c0>
		}
		printf("%sProtect Flash Sectors %d-%d in Bank # %d\n",
 3f06644:	e59fc100 	ldr	r12, [pc, #100]	; 3f0674c <do_protect+0x19c>
 3f06648:	e59f0100 	ldr	r0, [pc, #100]	; 3f06750 <do_protect+0x1a0>
 3f0664c:	e59f1100 	ldr	r1, [pc, #100]	; 3f06754 <do_protect+0x1a4>
 3f06650:	e51b2028 	ldr	r2, [r11, -#40]
 3f06654:	e35a0000 	cmp	r10, #0	; 0x0
 3f06658:	e51be024 	ldr	r14, [r11, -#36]
 3f0665c:	01a0100c 	moveq	r1, r12
 3f06660:	e59fc0f0 	ldr	r12, [pc, #f0]	; 3f06758 <do_protect+0x1a8>
 3f06664:	e51b302c 	ldr	r3, [r11, -#44]
 3f06668:	e06ce00e 	rsb	r14, r12, r14
 3f0666c:	e08ec08e 	add	r12, r14, r14, lsl #1
 3f06670:	e08cc20c 	add	r12, r12, r12, lsl #4
 3f06674:	e08cc40c 	add	r12, r12, r12, lsl #8
 3f06678:	e08cc80c 	add	r12, r12, r12, lsl #16
 3f0667c:	e08ee10c 	add	r14, r14, r12, lsl #2
 3f06680:	e1a0e14e 	mov	r14, r14, asr #2
 3f06684:	e28ee001 	add	r14, r14, #1	; 0x1
 3f06688:	e58de000 	str	r14, [r13]
 3f0668c:	eb00186c 	bl	3f0c844 <printf>
			p ? "" : "Un-", sect_first, sect_last,
			(info-flash_info)+1);
		for (i = sect_first; i <= sect_last; i++) {
 3f06690:	e51b2028 	ldr	r2, [r11, -#40]
 3f06694:	e51b302c 	ldr	r3, [r11, -#44]
 3f06698:	e1520003 	cmp	r2, r3
 3f0669c:	ca000006 	bgt	3f066bc <do_protect+0x10c>
#if defined(CFG_FLASH_PROTECTION)
			if (flash_real_protect(info, i, p))
				rcode =  1;
			putc ('.');
#else
			info->protect[i] = p;
 3f066a0:	e51b3024 	ldr	r3, [r11, -#36]
 3f066a4:	e2833010 	add	r3, r3, #16	; 0x10
 3f066a8:	e7c3a002 	strb	r10, [r3, r2]
 3f066ac:	e51b302c 	ldr	r3, [r11, -#44]
 3f066b0:	e2822001 	add	r2, r2, #1	; 0x1
 3f066b4:	e1520003 	cmp	r2, r3
 3f066b8:	dafffff8 	ble	3f066a0 <do_protect+0xf0>
#endif	/* CFG_FLASH_PROTECTION */
		}

#if defined(CFG_FLASH_PROTECTION)
		if (!rcode) puts (" done\n");
#endif	/* CFG_FLASH_PROTECTION */

		return rcode;
 3f066bc:	e3a00000 	mov	r0, #0	; 0x0
 3f066c0:	ea00002b 	b	3f06774 <do_protect+0x1c4>
	}

	if (argc != 4) {
 3f066c4:	e3570004 	cmp	r7, #4	; 0x4
 3f066c8:	1a000025 	bne	3f06764 <do_protect+0x1b4>
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
	}

	if (strcmp(argv[2], "bank") == 0) {
 3f066cc:	e5940008 	ldr	r0, [r4, #8]
 3f066d0:	e59f1084 	ldr	r1, [pc, #84]	; 3f0675c <do_protect+0x1ac>
 3f066d4:	eb0022b7 	bl	3f0f1b8 <strcmp>
 3f066d8:	e3500000 	cmp	r0, #0	; 0x0
 3f066dc:	1a000006 	bne	3f066fc <do_protect+0x14c>
		bank = simple_strtoul(argv[3], NULL, 16);
 3f066e0:	e1a01005 	mov	r1, r5
 3f066e4:	e594000c 	ldr	r0, [r4, #12]
 3f066e8:	e3a02010 	mov	r2, #16	; 0x10
 3f066ec:	eb002414 	bl	3f0f744 <simple_strtoul>
		if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
			printf ("Only FLASH Banks # 1 ... # %d supported\n",
 3f066f0:	e59f0068 	ldr	r0, [pc, #68]	; 3f06760 <do_protect+0x1b0>
 3f066f4:	e1a01005 	mov	r1, r5
				CFG_MAX_FLASH_BANKS);
			return 1;
 3f066f8:	ea00001b 	b	3f0676c <do_protect+0x1bc>
		}
		printf ("%sProtect Flash Bank # %ld\n",
			p ? "" : "Un-", bank);
		info = &flash_info[bank-1];

		if (info->flash_id == FLASH_UNKNOWN) {
			printf ("missing or unknown FLASH type\n");
			return 1;
		}
		for (i=0; i<info->sector_count; ++i) {
#if defined(CFG_FLASH_PROTECTION)
			if (flash_real_protect(info, i, p))
				rcode =  1;
			putc ('.');
#else
			info->protect[i] = p;
#endif	/* CFG_FLASH_PROTECTION */
		}

#if defined(CFG_FLASH_PROTECTION)
		if (!rcode) puts (" done\n");
#endif	/* CFG_FLASH_PROTECTION */

		return rcode;
	}

	addr_first = simple_strtoul(argv[2], NULL, 16);
 3f066fc:	e1a01005 	mov	r1, r5
 3f06700:	e5940008 	ldr	r0, [r4, #8]
 3f06704:	e3a02010 	mov	r2, #16	; 0x10
 3f06708:	eb00240d 	bl	3f0f744 <simple_strtoul>
	addr_last  = simple_strtoul(argv[3], NULL, 16);
 3f0670c:	e1a01005 	mov	r1, r5
 3f06710:	e1a05000 	mov	r5, r0
 3f06714:	e594000c 	ldr	r0, [r4, #12]
 3f06718:	e3a02010 	mov	r2, #16	; 0x10
 3f0671c:	eb002408 	bl	3f0f744 <simple_strtoul>
 3f06720:	e1a02000 	mov	r2, r0

	if (addr_first >= addr_last) {
 3f06724:	e1550002 	cmp	r5, r2
 3f06728:	2a00000d 	bcs	3f06764 <do_protect+0x1b4>
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
	}
	rcode = flash_sect_protect (p, addr_first, addr_last);
 3f0672c:	e1a0000a 	mov	r0, r10
 3f06730:	e1a01005 	mov	r1, r5
 3f06734:	eb000011 	bl	3f06780 <flash_sect_protect>
	return rcode;
 3f06738:	ea00000d 	b	3f06774 <do_protect+0x1c4>
 3f0673c:	03f1cb08 	mvneqs	r12, #8192	; 0x2000
 3f06740:	03f1cb0c 	mvneqs	r12, #12288	; 0x3000
 3f06744:	03f1ca54 	mvneqs	r12, #344064	; 0x54000
 3f06748:	03f1ca70 	mvneqs	r12, #458752	; 0x70000
 3f0674c:	03f1cb30 	mvneqs	r12, #49152	; 0xc000
 3f06750:	03f1cb34 	mvneqs	r12, #53248	; 0xd000
 3f06754:	03f1cb2c 	mvneqs	r12, #45056	; 0xb000
 3f06758:	03f72f04 	mvneqs	r2, #16	; 0x10
 3f0675c:	03f1cab4 	mvneqs	r12, #737280	; 0xb4000
 3f06760:	03f1ca1c 	mvneqs	r12, #114688	; 0x1c000
 3f06764:	e59f000c 	ldr	r0, [pc, #c]	; 3f06778 <do_protect+0x1c8>
 3f06768:	e5961010 	ldr	r1, [r6, #16]
 3f0676c:	eb001834 	bl	3f0c844 <printf>
 3f06770:	e3a00001 	mov	r0, #1	; 0x1
 3f06774:	ea000000 	b	3f0677c <do_protect+0x1cc>
 3f06778:	03f1ca48 	mvneqs	r12, #294912	; 0x48000
}
 3f0677c:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f06780 <flash_sect_protect>:
 3f06780:	e1a0c00d 	mov	r12, r13
 3f06784:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f06788:	e24cb004 	sub	r11, r12, #4	; 0x4


int flash_sect_protect (int p, ulong addr_first, ulong addr_last)
{
 3f0678c:	e1a05000 	mov	r5, r0
	flash_info_t *info;
	ulong bank;
	int s_first[CFG_MAX_FLASH_BANKS], s_last[CFG_MAX_FLASH_BANKS];
	int protected, i;
	int planned;
	int rcode;

	rcode = flash_fill_sect_ranges( addr_first, addr_last, s_first, s_last, &planned );
 3f06790:	e1a00001 	mov	r0, r1
 3f06794:	e1a01002 	mov	r1, r2
 3f06798:	e24b2014 	sub	r2, r11, #20	; 0x14
 3f0679c:	e24b3018 	sub	r3, r11, #24	; 0x18
 3f067a0:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f067a4:	e58d3000 	str	r3, [r13]
 3f067a8:	e1a03002 	mov	r3, r2
 3f067ac:	ebfffeeb 	bl	3f06360 <flash_fill_sect_ranges>

	protected = 0;

	if (planned && (rcode == 0)) {
 3f067b0:	e1a04000 	mov	r4, r0
 3f067b4:	e51b2018 	ldr	r2, [r11, -#24]
 3f067b8:	e3540000 	cmp	r4, #0	; 0x0
 3f067bc:	13a03000 	movne	r3, #0	; 0x0
 3f067c0:	03a03001 	moveq	r3, #1	; 0x1
 3f067c4:	e3520000 	cmp	r2, #0	; 0x0
 3f067c8:	03a03000 	moveq	r3, #0	; 0x0
 3f067cc:	e3530000 	cmp	r3, #0	; 0x0
 3f067d0:	0a00000a 	beq	3f06800 <flash_sect_protect+0x80>
		for (bank=0,info=&flash_info[0]; bank < CFG_MAX_FLASH_BANKS; ++bank, ++info) {
			if (info->flash_id == FLASH_UNKNOWN) {
				continue;
			}

			if (s_first[bank]>=0 && s_first[bank]<=s_last[bank]) {
				debug ("Protecting sectors %d..%d in bank %ld\n",
					s_first[bank], s_last[bank], bank+1);
				protected += s_last[bank] - s_first[bank] + 1;
				for (i=s_first[bank]; i<=s_last[bank]; ++i) {
#if defined(CFG_FLASH_PROTECTION)
					if (flash_real_protect(info, i, p))
						rcode = 1;
					putc ('.');
#else
					info->protect[i] = p;
#endif	/* CFG_FLASH_PROTECTION */
				}
			}
#if defined(CFG_FLASH_PROTECTION)
			if (!rcode) putc ('\n');
#endif	/* CFG_FLASH_PROTECTION */
		}

		printf ("%sProtected %d sectors\n",
 3f067d4:	e59f3018 	ldr	r3, [pc, #18]	; 3f067f4 <flash_sect_protect+0x74>
 3f067d8:	e59f1018 	ldr	r1, [pc, #18]	; 3f067f8 <flash_sect_protect+0x78>
 3f067dc:	e3a02000 	mov	r2, #0	; 0x0
 3f067e0:	e59f0014 	ldr	r0, [pc, #14]	; 3f067fc <flash_sect_protect+0x7c>
 3f067e4:	e1550002 	cmp	r5, r2
 3f067e8:	01a01003 	moveq	r1, r3
 3f067ec:	eb001814 	bl	3f0c844 <printf>
			p ? "" : "Un-", protected);
	} else if (rcode == 0) {
 3f067f0:	ea000007 	b	3f06814 <flash_sect_protect+0x94>
 3f067f4:	03f1cb30 	mvneqs	r12, #49152	; 0xc000
 3f067f8:	03f1cb2c 	mvneqs	r12, #45056	; 0xb000
 3f067fc:	03f1cb80 	mvneqs	r12, #131072	; 0x20000
 3f06800:	e3540000 	cmp	r4, #0	; 0x0
 3f06804:	1a000002 	bne	3f06814 <flash_sect_protect+0x94>
		printf ("Error: start and/or end address"
 3f06808:	e59f000c 	ldr	r0, [pc, #c]	; 3f0681c <flash_sect_protect+0x9c>
			" not on sector boundary\n");
		rcode = 1;
 3f0680c:	e3a04001 	mov	r4, #1	; 0x1
 3f06810:	eb00180b 	bl	3f0c844 <printf>
	}
	return rcode;
 3f06814:	e1a00004 	mov	r0, r4
 3f06818:	ea000000 	b	3f06820 <flash_sect_protect+0xa0>
 3f0681c:	03f1cad0 	mvneqs	r12, #851968	; 0xd0000
}
 3f06820:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f06824 <do_load_serial>:
 3f06824:	e1a0c00d 	mov	r12, r13
 3f06828:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f0682c:	e24cb004 	sub	r11, r12, #4	; 0x4

#if (CONFIG_COMMANDS & CFG_CMD_LOADS)
int do_load_serial (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	ulong offset = 0;
 3f06830:	e3a06000 	mov	r6, #0	; 0x0
	ulong addr;
	int i;
	char *env_echo;
	int rcode = 0;
 3f06834:	e1a07006 	mov	r7, r6
 3f06838:	e1a04002 	mov	r4, r2
#ifdef	CFG_LOADS_BAUD_CHANGE
	DECLARE_GLOBAL_DATA_PTR;
	int load_baudrate, current_baudrate;

	load_baudrate = current_baudrate = gd->baudrate;
#endif

	if (((env_echo = getenv("loads_echo")) != NULL) && (*env_echo == '1')) {
 3f0683c:	e59f00b4 	ldr	r0, [pc, #b4]	; 3f068f8 <do_load_serial+0xd4>
 3f06840:	e1a05003 	mov	r5, r3
 3f06844:	eb001604 	bl	3f0c05c <getenv>
 3f06848:	e3500000 	cmp	r0, #0	; 0x0
 3f0684c:	0a000004 	beq	3f06864 <do_load_serial+0x40>
 3f06850:	e5d03000 	ldrb	r3, [r0]
 3f06854:	e3530031 	cmp	r3, #49	; 0x31
		do_echo = 1;
 3f06858:	059f209c 	ldreq	r2, [pc, #9c]	; 3f068fc <do_load_serial+0xd8>
 3f0685c:	03a03001 	moveq	r3, #1	; 0x1
	} else {
 3f06860:	0a000001 	beq	3f0686c <do_load_serial+0x48>
		do_echo = 0;
 3f06864:	e59f2090 	ldr	r2, [pc, #90]	; 3f068fc <do_load_serial+0xd8>
 3f06868:	e3a03000 	mov	r3, #0	; 0x0
 3f0686c:	e5823000 	str	r3, [r2]
	}

#ifdef	CFG_LOADS_BAUD_CHANGE
	if (argc >= 2) {
		offset = simple_strtoul(argv[1], NULL, 16);
	}
	if (argc == 3) {
		load_baudrate = (int)simple_strtoul(argv[2], NULL, 10);

		/* default to current baudrate */
		if (load_baudrate == 0)
			load_baudrate = current_baudrate;
	}
	if (load_baudrate != current_baudrate) {
		printf ("## Switch baudrate to %d bps and press ENTER ...\n",
			load_baudrate);
		udelay(50000);
		gd->baudrate = load_baudrate;
		serial_setbrg ();
		udelay(50000);
		for (;;) {
			if (getc() == '\r')
				break;
		}
	}
#else	/* ! CFG_LOADS_BAUD_CHANGE */
	if (argc == 2) {
 3f06870:	e3540002 	cmp	r4, #2	; 0x2
 3f06874:	1a000004 	bne	3f0688c <do_load_serial+0x68>
		offset = simple_strtoul(argv[1], NULL, 16);
 3f06878:	e3a01000 	mov	r1, #0	; 0x0
 3f0687c:	e5950004 	ldr	r0, [r5, #4]
 3f06880:	e3a02010 	mov	r2, #16	; 0x10
 3f06884:	eb0023ae 	bl	3f0f744 <simple_strtoul>
 3f06888:	e1a07000 	mov	r7, r0
	}
#endif	/* CFG_LOADS_BAUD_CHANGE */

	printf ("## Ready for S-Record download ...\n");
 3f0688c:	e59f006c 	ldr	r0, [pc, #6c]	; 3f06900 <do_load_serial+0xdc>

	addr = load_serial (offset);

	/*
	 * Gather any trailing characters (for instance, the ^D which
	 * is sent by 'cu' after sending a file), and give the
	 * box some time (100 * 1 ms)
	 */
	for (i=0; i<100; ++i) {
 3f06890:	e3a05063 	mov	r5, #99	; 0x63
 3f06894:	eb0017ea 	bl	3f0c844 <printf>
 3f06898:	e1a00007 	mov	r0, r7
 3f0689c:	eb00001b 	bl	3f06910 <load_serial>
 3f068a0:	e1a04000 	mov	r4, r0
		if (serial_tstc()) {
 3f068a4:	eb003ef5 	bl	3f16480 <serial_tstc>
 3f068a8:	e3500000 	cmp	r0, #0	; 0x0
 3f068ac:	0a000000 	beq	3f068b4 <do_load_serial+0x90>
			(void) serial_getc();
 3f068b0:	eb003ed8 	bl	3f16418 <serial_getc>
		}
		udelay(1000);
 3f068b4:	e3a00ffa 	mov	r0, #1000	; 0x3e8
 3f068b8:	ebffe7d6 	bl	3f00818 <udelay>
 3f068bc:	e2555001 	subs	r5, r5, #1	; 0x1
 3f068c0:	5afffff7 	bpl	3f068a4 <do_load_serial+0x80>
	}

	if (addr == ~0) {
 3f068c4:	e3740001 	cmn	r4, #1	; 0x1
 3f068c8:	1a000003 	bne	3f068dc <do_load_serial+0xb8>
		printf ("## S-Record download aborted\n");
 3f068cc:	e59f0030 	ldr	r0, [pc, #30]	; 3f06904 <do_load_serial+0xe0>
		rcode = 1;
 3f068d0:	e3a06001 	mov	r6, #1	; 0x1
 3f068d4:	eb0017da 	bl	3f0c844 <printf>
	} else {
 3f068d8:	ea000004 	b	3f068f0 <do_load_serial+0xcc>
		printf ("## Start Addr      = 0x%08lX\n", addr);
 3f068dc:	e59f0024 	ldr	r0, [pc, #24]	; 3f06908 <do_load_serial+0xe4>
 3f068e0:	e1a01004 	mov	r1, r4
 3f068e4:	eb0017d6 	bl	3f0c844 <printf>
		load_addr = addr;
 3f068e8:	e59f301c 	ldr	r3, [pc, #1c]	; 3f0690c <do_load_serial+0xe8>
 3f068ec:	e5834000 	str	r4, [r3]
	}

#ifdef	CFG_LOADS_BAUD_CHANGE
	if (load_baudrate != current_baudrate) {
		printf ("## Switch baudrate to %d bps and press ESC ...\n",
			current_baudrate);
		udelay (50000);
		gd->baudrate = current_baudrate;
		serial_setbrg ();
		udelay (50000);
		for (;;) {
			if (getc() == 0x1B) /* ESC */
				break;
		}
	}
#endif
	return rcode;
 3f068f0:	e1a00006 	mov	r0, r6
}
 3f068f4:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f068f8:	03f1cf54 	mvneqs	r12, #336	; 0x150
 3f068fc:	03f205fc 	mvneqs	r0, #1056964608	; 0x3f000000
 3f06900:	03f1cf60 	mvneqs	r12, #384	; 0x180
 3f06904:	03f1cf84 	mvneqs	r12, #528	; 0x210
 3f06908:	03f1cfa4 	mvneqs	r12, #656	; 0x290
 3f0690c:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000

03f06910 <load_serial>:
 3f06910:	e1a0c00d 	mov	r12, r13
 3f06914:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f06918:	e24cb004 	sub	r11, r12, #4	; 0x4

static ulong
load_serial (ulong offset)
{
	char	record[SREC_MAXRECLEN + 1];	/* buffer for one S-Record	*/
	char	binbuf[SREC_MAXBINLEN];		/* buffer for binary data	*/
	int	binlen;				/* no. of data bytes in S-Rec.	*/
	int	type;				/* return code for record type	*/
	ulong	addr;				/* load address from S-Record	*/
	ulong	size;				/* number of bytes transferred	*/
	char	buf[32];
	ulong	store_addr;
	ulong	start_addr = ~0;
 3f0691c:	e3e0a000 	mvn	r10, #0	; 0x0
	ulong	end_addr   =  0;
 3f06920:	e3a06000 	mov	r6, #0	; 0x0
	int	line_count =  0;
 3f06924:	e1a07006 	mov	r7, r6
 3f06928:	e1a09000 	mov	r9, r0
 3f0692c:	e24ddfcd 	sub	r13, r13, #820	; 0x334

	while (read_record(record, SREC_MAXRECLEN + 1) >= 0) {
 3f06930:	ea000058 	b	3f06a98 <load_serial+0x188>
		type = srec_decode (record, &binlen, &addr, binbuf);
 3f06934:	e1a00005 	mov	r0, r5
 3f06938:	e24b1e35 	sub	r1, r11, #848	; 0x350
 3f0693c:	e24b2fd5 	sub	r2, r11, #852	; 0x354
 3f06940:	e24b4fcb 	sub	r4, r11, #812	; 0x32c
 3f06944:	e1a03004 	mov	r3, r4
 3f06948:	eb002027 	bl	3f0e9ec <srec_decode>

		if (type < 0) {
 3f0694c:	e3500000 	cmp	r0, #0	; 0x0
 3f06950:	ba000056 	blt	3f06ab0 <load_serial+0x1a0>
			return (~0);		/* Invalid S-Record		*/
		}

		switch (type) {
 3f06954:	e3500009 	cmp	r0, #9	; 0x9
 3f06958:	979ff100 	ldrls	r15, [r15, r0, lsl #2]
 3f0695c:	ea00003e 	b	3f06a5c <load_serial+0x14c>
 3f06960:	03f06a5c 	mvneqs	r6, #376832	; 0x5c000
 3f06964:	03f06988 	mvneqs	r6, #2228224	; 0x220000
 3f06968:	03f06988 	mvneqs	r6, #2228224	; 0x220000
 3f0696c:	03f06988 	mvneqs	r6, #2228224	; 0x220000
 3f06970:	03f06a5c 	mvneqs	r6, #376832	; 0x5c000
 3f06974:	03f06a5c 	mvneqs	r6, #376832	; 0x5c000
 3f06978:	03f06a5c 	mvneqs	r6, #376832	; 0x5c000
 3f0697c:	03f069f0 	mvneqs	r6, #3932160	; 0x3c0000
 3f06980:	03f069f0 	mvneqs	r6, #3932160	; 0x3c0000
 3f06984:	03f069f0 	mvneqs	r6, #3932160	; 0x3c0000
		case SREC_DATA2:
		case SREC_DATA3:
		case SREC_DATA4:
		    store_addr = addr + offset;
 3f06988:	e51b3354 	ldr	r3, [r11, -#852]
 3f0698c:	e0835009 	add	r5, r3, r9
#ifndef CFG_NO_FLASH
		    if (addr2info(store_addr)) {
 3f06990:	e1a00005 	mov	r0, r5
 3f06994:	eb001e29 	bl	3f0e240 <addr2info>
 3f06998:	e3500000 	cmp	r0, #0	; 0x0
 3f0699c:	0a000007 	beq	3f069c0 <load_serial+0xb0>
			int rc;

			rc = flash_write((uchar *)binbuf,store_addr,binlen);
 3f069a0:	e1a00004 	mov	r0, r4
 3f069a4:	e51b2350 	ldr	r2, [r11, -#848]
 3f069a8:	e1a01005 	mov	r1, r5
 3f069ac:	eb001e28 	bl	3f0e254 <flash_write>
			if (rc != 0) {
 3f069b0:	e3500000 	cmp	r0, #0	; 0x0
 3f069b4:	0a000005 	beq	3f069d0 <load_serial+0xc0>
				flash_perror (rc);
 3f069b8:	eb001e8b 	bl	3f0e3ec <flash_perror>
				return (~0);
 3f069bc:	ea00003b 	b	3f06ab0 <load_serial+0x1a0>
			}
		    } else
#endif
		    {
			memcpy ((char *)(store_addr), binbuf, binlen);
 3f069c0:	e1a00005 	mov	r0, r5
 3f069c4:	e51b2350 	ldr	r2, [r11, -#848]
 3f069c8:	e1a01004 	mov	r1, r4
 3f069cc:	eb0022ed 	bl	3f0f588 <memcpy>
		    }
		    if ((store_addr) < start_addr)
			start_addr = store_addr;
		    if ((store_addr + binlen - 1) > end_addr)
 3f069d0:	e51b3350 	ldr	r3, [r11, -#848]
 3f069d4:	e155000a 	cmp	r5, r10
 3f069d8:	31a0a005 	movcc	r10, r5
 3f069dc:	e0853003 	add	r3, r5, r3
 3f069e0:	e2433001 	sub	r3, r3, #1	; 0x1
 3f069e4:	e1530007 	cmp	r3, r7
 3f069e8:	21a07003 	movcs	r7, r3
			end_addr = store_addr + binlen - 1;
		    break;
 3f069ec:	ea00001a 	b	3f06a5c <load_serial+0x14c>
		case SREC_END2:
		case SREC_END3:
		case SREC_END4:
		    udelay (10000);
 3f069f0:	e59f0054 	ldr	r0, [pc, #54]	; 3f06a4c <load_serial+0x13c>
 3f069f4:	ebffe787 	bl	3f00818 <udelay>
		    size = end_addr - start_addr + 1;
		    printf ("\n"
 3f069f8:	e1a0100a 	mov	r1, r10
 3f069fc:	e1a02007 	mov	r2, r7
 3f06a00:	e06a4007 	rsb	r4, r10, r7
 3f06a04:	e2844001 	add	r4, r4, #1	; 0x1
 3f06a08:	e59f0040 	ldr	r0, [pc, #40]	; 3f06a50 <load_serial+0x140>
 3f06a0c:	e1a03004 	mov	r3, r4
 3f06a10:	e58d4000 	str	r4, [r13]
 3f06a14:	eb00178a 	bl	3f0c844 <printf>
			    "## First Load Addr = 0x%08lX\n"
			    "## Last  Load Addr = 0x%08lX\n"
			    "## Total Size      = 0x%08lX = %ld Bytes\n",
			    start_addr, end_addr, size, size
		    );
		    flush_cache (addr, size);
 3f06a18:	e51b0354 	ldr	r0, [r11, -#852]
 3f06a1c:	e1a01004 	mov	r1, r4
 3f06a20:	eb004619 	bl	3f1828c <flush_cache>
		    sprintf(buf, "%lX", size);
 3f06a24:	e24b5fd3 	sub	r5, r11, #844	; 0x34c
 3f06a28:	e1a00005 	mov	r0, r5
 3f06a2c:	e59f1020 	ldr	r1, [pc, #20]	; 3f06a54 <load_serial+0x144>
 3f06a30:	e1a02004 	mov	r2, r4
 3f06a34:	eb002580 	bl	3f1003c <sprintf>
		    setenv("filesize", buf);
 3f06a38:	e59f0018 	ldr	r0, [pc, #18]	; 3f06a58 <load_serial+0x148>
 3f06a3c:	e1a01005 	mov	r1, r5
 3f06a40:	eb001564 	bl	3f0bfd8 <setenv>
		    return (addr);
 3f06a44:	e51b0354 	ldr	r0, [r11, -#852]
 3f06a48:	ea000019 	b	3f06ab4 <load_serial+0x1a4>
 3f06a4c:	00002710 	andeq	r2, r0, r0, lsl r7
 3f06a50:	03f1cfc4 	mvneqs	r12, #784	; 0x310
 3f06a54:	03f1d02c 	mvneqs	r13, #44	; 0x2c
 3f06a58:	03f1d030 	mvneqs	r13, #48	; 0x30
		case SREC_START:
		    break;
		default:
		    break;
		}
		if (!do_echo) {	/* print a '.' every 100 lines */
 3f06a5c:	e59f3054 	ldr	r3, [pc, #54]	; 3f06ab8 <load_serial+0x1a8>
 3f06a60:	e5933000 	ldr	r3, [r3]
 3f06a64:	e3530000 	cmp	r3, #0	; 0x0
 3f06a68:	1a00000a 	bne	3f06a98 <load_serial+0x188>
			if ((++line_count % 100) == 0)
 3f06a6c:	e59f3048 	ldr	r3, [pc, #48]	; 3f06abc <load_serial+0x1ac>
 3f06a70:	e2866001 	add	r6, r6, #1	; 0x1
 3f06a74:	e0c21693 	smull	r1, r2, r3, r6
 3f06a78:	e1a03fc6 	mov	r3, r6, asr #31
 3f06a7c:	e06332c2 	rsb	r3, r3, r2, asr #5
 3f06a80:	e0833103 	add	r3, r3, r3, lsl #2
 3f06a84:	e0833103 	add	r3, r3, r3, lsl #2
 3f06a88:	e1560103 	cmp	r6, r3, lsl #2
 3f06a8c:	1a000001 	bne	3f06a98 <load_serial+0x188>
				putc ('.');
 3f06a90:	e3a0002e 	mov	r0, #46	; 0x2e
 3f06a94:	eb001750 	bl	3f0c7dc <putc>
		}
	}
 3f06a98:	e24b5f8b 	sub	r5, r11, #556	; 0x22c
 3f06a9c:	e59f101c 	ldr	r1, [pc, #1c]	; 3f06ac0 <load_serial+0x1b0>
 3f06aa0:	e1a00005 	mov	r0, r5
 3f06aa4:	eb000007 	bl	3f06ac8 <read_record>
 3f06aa8:	e3500000 	cmp	r0, #0	; 0x0
 3f06aac:	aaffffa0 	bge	3f06934 <load_serial+0x24>

	return (~0);			/* Download aborted		*/
 3f06ab0:	e3e00000 	mvn	r0, #0	; 0x0
 3f06ab4:	ea000002 	b	3f06ac4 <load_serial+0x1b4>
 3f06ab8:	03f205fc 	mvneqs	r0, #1056964608	; 0x3f000000
 3f06abc:	51eb851f 	mvnpl	r8, r15, lsl r5
 3f06ac0:	00000205 	andeq	r0, r0, r5, lsl #4
}
 3f06ac4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f06ac8 <read_record>:
 3f06ac8:	e1a0c00d 	mov	r12, r13
 3f06acc:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f06ad0:	e24cb004 	sub	r11, r12, #4	; 0x4

static int
read_record (char *buf, ulong len)
{
 3f06ad4:	e1a06000 	mov	r6, r0
	DECLARE_GLOBAL_DATA_PTR;
	char *p;
	char c;

	--len;	/* always leave room for terminating '\0' byte */

	for (p=buf; p < buf+len; ++p) {
 3f06ad8:	e1a05006 	mov	r5, r6
 3f06adc:	e2411001 	sub	r1, r1, #1	; 0x1
 3f06ae0:	e0867001 	add	r7, r6, r1
 3f06ae4:	e1560007 	cmp	r6, r7
 3f06ae8:	2a00002a 	bcs	3f06b98 <read_record+0xd0>
		c = serial_getc();		/* read character		*/
 3f06aec:	eb003e49 	bl	3f16418 <serial_getc>
		if (do_echo)
 3f06af0:	e59f30b0 	ldr	r3, [pc, #b0]	; 3f06ba8 <read_record+0xe0>
 3f06af4:	e5933000 	ldr	r3, [r3]
 3f06af8:	e20040ff 	and	r4, r0, #255	; 0xff
 3f06afc:	e3530000 	cmp	r3, #0	; 0x0
 3f06b00:	0a000001 	beq	3f06b0c <read_record+0x44>
			serial_putc (c);	/* ... and echo it		*/
 3f06b04:	e1a00004 	mov	r0, r4
 3f06b08:	eb003e4d 	bl	3f16444 <serial_putc>

		switch (c) {
 3f06b0c:	e354000d 	cmp	r4, #13	; 0xd
 3f06b10:	979ff104 	ldrls	r15, [r15, r4, lsl #2]
 3f06b14:	ea000011 	b	3f06b60 <read_record+0x98>
 3f06b18:	03f06b84 	mvneqs	r6, #135168	; 0x21000
 3f06b1c:	03f06b60 	mvneqs	r6, #98304	; 0x18000
 3f06b20:	03f06b60 	mvneqs	r6, #98304	; 0x18000
 3f06b24:	03f06b84 	mvneqs	r6, #135168	; 0x21000
 3f06b28:	03f06b60 	mvneqs	r6, #98304	; 0x18000
 3f06b2c:	03f06b60 	mvneqs	r6, #98304	; 0x18000
 3f06b30:	03f06b60 	mvneqs	r6, #98304	; 0x18000
 3f06b34:	03f06b60 	mvneqs	r6, #98304	; 0x18000
 3f06b38:	03f06b60 	mvneqs	r6, #98304	; 0x18000
 3f06b3c:	03f06b60 	mvneqs	r6, #98304	; 0x18000
 3f06b40:	03f06b50 	mvneqs	r6, #81920	; 0x14000
 3f06b44:	03f06b60 	mvneqs	r6, #98304	; 0x18000
 3f06b48:	03f06b60 	mvneqs	r6, #98304	; 0x18000
 3f06b4c:	03f06b50 	mvneqs	r6, #81920	; 0x14000
		case '\r':
		case '\n':
			*p = '\0';
			return (p - buf);
 3f06b50:	e0660005 	rsb	r0, r6, r5
 3f06b54:	e3a03000 	mov	r3, #0	; 0x0
 3f06b58:	e5c53000 	strb	r3, [r5]
 3f06b5c:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
		case '\0':
		case 0x03:			/* ^C - Control C		*/
			return (-1);
		default:
			*p = c;
 3f06b60:	e5c54000 	strb	r4, [r5]
		}

	    /* Check for the console hangup (if any different from serial) */
	    if (gd->jt[XF_getc] != serial_getc) {
 3f06b64:	e5983020 	ldr	r3, [r8, #32]
 3f06b68:	e5932004 	ldr	r2, [r3, #4]
 3f06b6c:	e59f3038 	ldr	r3, [pc, #38]	; 3f06bac <read_record+0xe4>
 3f06b70:	e1520003 	cmp	r2, r3
 3f06b74:	0a000004 	beq	3f06b8c <read_record+0xc4>
		if (ctrlc()) {
 3f06b78:	eb00174b 	bl	3f0c8ac <ctrlc>
 3f06b7c:	e3500000 	cmp	r0, #0	; 0x0
 3f06b80:	0a000001 	beq	3f06b8c <read_record+0xc4>
		    return (-1);
 3f06b84:	e3e00000 	mvn	r0, #0	; 0x0
 3f06b88:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f06b8c:	e2855001 	add	r5, r5, #1	; 0x1
 3f06b90:	e1550007 	cmp	r5, r7
 3f06b94:	3affffd4 	bcc	3f06aec <read_record+0x24>
		}
	    }
	}

	/* line too long - truncate */
	*p = '\0';
	return (p - buf);
 3f06b98:	e0660005 	rsb	r0, r6, r5
 3f06b9c:	e3a03000 	mov	r3, #0	; 0x0
 3f06ba0:	e5c53000 	strb	r3, [r5]
}
 3f06ba4:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f06ba8:	03f205fc 	mvneqs	r0, #1056964608	; 0x3f000000
 3f06bac:	03f16418 	mvneqs	r6, #402653184	; 0x18000000

03f06bb0 <do_load_serial_bin>:
 3f06bb0:	e1a0c00d 	mov	r12, r13
 3f06bb4:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f06bb8:	e24cb004 	sub	r11, r12, #4	; 0x4

#if (CONFIG_COMMANDS & CFG_CMD_SAVES)

int do_save_serial (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	ulong offset = 0;
	ulong size   = 0;
#ifdef	CFG_LOADS_BAUD_CHANGE
	DECLARE_GLOBAL_DATA_PTR;
	int save_baudrate, current_baudrate;

	save_baudrate = current_baudrate = gd->baudrate;
#endif

	if (argc >= 2) {
		offset = simple_strtoul(argv[1], NULL, 16);
	}
#ifdef	CFG_LOADS_BAUD_CHANGE
	if (argc >= 3) {
		size = simple_strtoul(argv[2], NULL, 16);
	}
	if (argc == 4) {
		save_baudrate = (int)simple_strtoul(argv[3], NULL, 10);

		/* default to current baudrate */
		if (save_baudrate == 0)
			save_baudrate = current_baudrate;
	}
	if (save_baudrate != current_baudrate) {
		printf ("## Switch baudrate to %d bps and press ENTER ...\n",
			save_baudrate);
		udelay(50000);
		gd->baudrate = save_baudrate;
		serial_setbrg ();
		udelay(50000);
		for (;;) {
			if (getc() == '\r')
				break;
		}
	}
#else	/* ! CFG_LOADS_BAUD_CHANGE */
	if (argc == 3) {
		size = simple_strtoul(argv[2], NULL, 16);
	}
#endif	/* CFG_LOADS_BAUD_CHANGE */

	printf ("## Ready for S-Record upload, press ENTER to proceed ...\n");
	for (;;) {
		if (getc() == '\r')
			break;
	}
	if(save_serial (offset, size)) {
		printf ("## S-Record upload aborted\n");
	} else {
		printf ("## S-Record upload complete\n");
	}
#ifdef	CFG_LOADS_BAUD_CHANGE
	if (save_baudrate != current_baudrate) {
		printf ("## Switch baudrate to %d bps and press ESC ...\n",
			(int)current_baudrate);
		udelay (50000);
		gd->baudrate = current_baudrate;
		serial_setbrg ();
		udelay (50000);
		for (;;) {
			if (getc() == 0x1B) /* ESC */
				break;
		}
	}
#endif
	return 0;
}

#define SREC3_START				"S0030000FC\n"
#define SREC3_FORMAT			"S3%02X%08lX%s%02X\n"
#define SREC3_END				"S70500000000FA\n"
#define SREC_BYTES_PER_RECORD	16

static int save_serial (ulong address, ulong count)
{
	int i, c, reclen, checksum, length;
	char *hex = "0123456789ABCDEF";
	char	record[2*SREC_BYTES_PER_RECORD+16];	/* buffer for one S-Record	*/
	char	data[2*SREC_BYTES_PER_RECORD+1];	/* buffer for hex data	*/

	reclen = 0;
	checksum  = 0;

	if(write_record(SREC3_START))			/* write the header */
		return (-1);
	do {
		if(count) {						/* collect hex data in the buffer  */
			c = *(volatile uchar*)(address + reclen);	/* get one byte    */
			checksum += c;							/* accumulate checksum */
			data[2*reclen]   = hex[(c>>4)&0x0f];
			data[2*reclen+1] = hex[c & 0x0f];
			data[2*reclen+2] = '\0';
			++reclen;
			--count;
		}
		if(reclen == SREC_BYTES_PER_RECORD || count == 0) {
			/* enough data collected for one record: dump it */
			if(reclen) {	/* build & write a data record: */
				/* address + data + checksum */
				length = 4 + reclen + 1;

				/* accumulate length bytes into checksum */
				for(i = 0; i < 2; i++)
					checksum += (length >> (8*i)) & 0xff;

				/* accumulate address bytes into checksum: */
				for(i = 0; i < 4; i++)
					checksum += (address >> (8*i)) & 0xff;

				/* make proper checksum byte: */
				checksum = ~checksum & 0xff;

				/* output one record: */
				sprintf(record, SREC3_FORMAT, length, address, data, checksum);
				if(write_record(record))
					return (-1);
			}
			address  += reclen;  /* increment address */
			checksum  = 0;
			reclen    = 0;
		}
	}
	while(count);
	if(write_record(SREC3_END))	/* write the final record */
		return (-1);
	return(0);
}

static int
write_record (char *buf)
{
	char c;

	while((c = *buf++))
		serial_putc(c);

	/* Check for the console hangup (if any different from serial) */

	if (ctrlc()) {
	    return (-1);
	}
	return (0);
}
# endif /* CFG_CMD_SAVES */

#endif	/* CFG_CMD_LOADS */


#if (CONFIG_COMMANDS & CFG_CMD_LOADB)  /* loadb command (load binary) included */

#define XON_CHAR        17
#define XOFF_CHAR       19
#define START_CHAR      0x01
#define ETX_CHAR	0x03
#define END_CHAR        0x0D
#define SPACE           0x20
#define K_ESCAPE        0x23
#define SEND_TYPE       'S'
#define DATA_TYPE       'D'
#define ACK_TYPE        'Y'
#define NACK_TYPE       'N'
#define BREAK_TYPE      'B'
#define tochar(x) ((char) (((x) + SPACE) & 0xff))
#define untochar(x) ((int) (((x) - SPACE) & 0xff))

extern int os_data_count;
extern int os_data_header[8];

static void set_kerm_bin_mode(unsigned long *);
static int k_recv(void);
static ulong load_serial_bin (ulong offset);


char his_eol;        /* character he needs at end of packet */
int  his_pad_count;  /* number of pad chars he needs */
char his_pad_char;   /* pad chars he needs */
char his_quote;      /* quote chars he'll use */

int do_load_serial_bin (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	DECLARE_GLOBAL_DATA_PTR;

	ulong offset = 0;
 3f06bbc:	e3a09000 	mov	r9, #0	; 0x0
	ulong addr;
	int load_baudrate, current_baudrate;
	int rcode = 0;
	char *s;

	/* pre-set offset from CFG_LOAD_ADDR */
	offset = CFG_LOAD_ADDR;
 3f06bc0:	e3a0a401 	mov	r10, #16777216	; 0x1000000
 3f06bc4:	e1a04002 	mov	r4, r2

	/* pre-set offset from $loadaddr */
	if ((s = getenv("loadaddr")) != NULL) {
 3f06bc8:	e59f0138 	ldr	r0, [pc, #138]	; 3f06d08 <do_load_serial_bin+0x158>
 3f06bcc:	e1a07003 	mov	r7, r3
 3f06bd0:	eb001521 	bl	3f0c05c <getenv>
 3f06bd4:	e3500000 	cmp	r0, #0	; 0x0
 3f06bd8:	0a000003 	beq	3f06bec <do_load_serial_bin+0x3c>
		offset = simple_strtoul(s, NULL, 16);
 3f06bdc:	e1a01009 	mov	r1, r9
 3f06be0:	e3a02010 	mov	r2, #16	; 0x10
 3f06be4:	eb0022d6 	bl	3f0f744 <simple_strtoul>
 3f06be8:	e1a0a000 	mov	r10, r0
	}

	load_baudrate = current_baudrate = gd->baudrate;
 3f06bec:	e5986008 	ldr	r6, [r8, #8]

	if (argc >= 2) {
 3f06bf0:	e3540001 	cmp	r4, #1	; 0x1
 3f06bf4:	e1a05006 	mov	r5, r6
 3f06bf8:	da000004 	ble	3f06c10 <do_load_serial_bin+0x60>
		offset = simple_strtoul(argv[1], NULL, 16);
 3f06bfc:	e1a01009 	mov	r1, r9
 3f06c00:	e5970004 	ldr	r0, [r7, #4]
 3f06c04:	e3a02010 	mov	r2, #16	; 0x10
 3f06c08:	eb0022cd 	bl	3f0f744 <simple_strtoul>
 3f06c0c:	e1a0a000 	mov	r10, r0
	}
	if (argc == 3) {
 3f06c10:	e3540003 	cmp	r4, #3	; 0x3
 3f06c14:	1a000006 	bne	3f06c34 <do_load_serial_bin+0x84>
		load_baudrate = (int)simple_strtoul(argv[2], NULL, 10);
 3f06c18:	e1a01009 	mov	r1, r9
 3f06c1c:	e5970008 	ldr	r0, [r7, #8]
 3f06c20:	e3a0200a 	mov	r2, #10	; 0xa
 3f06c24:	eb0022c6 	bl	3f0f744 <simple_strtoul>

		/* default to current baudrate */
		if (load_baudrate == 0)
 3f06c28:	e3500000 	cmp	r0, #0	; 0x0
 3f06c2c:	11a05000 	movne	r5, r0
 3f06c30:	01a05006 	moveq	r5, r6
			load_baudrate = current_baudrate;
	}

	if (load_baudrate != current_baudrate) {
 3f06c34:	e1550006 	cmp	r5, r6
 3f06c38:	0a00000c 	beq	3f06c70 <do_load_serial_bin+0xc0>
		printf ("## Switch baudrate to %d bps and press ENTER ...\n",
 3f06c3c:	e59f00c8 	ldr	r0, [pc, #c8]	; 3f06d0c <do_load_serial_bin+0x15c>
 3f06c40:	e1a01005 	mov	r1, r5
			load_baudrate);
		udelay(50000);
 3f06c44:	e59f40c4 	ldr	r4, [pc, #c4]	; 3f06d10 <do_load_serial_bin+0x160>
 3f06c48:	eb0016fd 	bl	3f0c844 <printf>
 3f06c4c:	e1a00004 	mov	r0, r4
 3f06c50:	ebffe6f0 	bl	3f00818 <udelay>
		gd->baudrate = load_baudrate;
 3f06c54:	e5885008 	str	r5, [r8, #8]
		serial_setbrg ();
 3f06c58:	eb003dc3 	bl	3f1636c <serial_setbrg>
		udelay(50000);
 3f06c5c:	e1a00004 	mov	r0, r4
 3f06c60:	ebffe6ec 	bl	3f00818 <udelay>
		for (;;) {
			if (getc() == '\r')
 3f06c64:	eb0016c6 	bl	3f0c784 <getc>
 3f06c68:	e350000d 	cmp	r0, #13	; 0xd
 3f06c6c:	1afffffc 	bne	3f06c64 <do_load_serial_bin+0xb4>
				break;
		}
	}

	printf ("## Ready for binary (kermit) download "
 3f06c70:	e1a0100a 	mov	r1, r10
 3f06c74:	e59f0098 	ldr	r0, [pc, #98]	; 3f06d14 <do_load_serial_bin+0x164>
 3f06c78:	e1a02005 	mov	r2, r5
 3f06c7c:	eb0016f0 	bl	3f0c844 <printf>
		"to 0x%08lX at %d bps...\n",
		offset,
		load_baudrate);
	addr = load_serial_bin (offset);
 3f06c80:	e1a0000a 	mov	r0, r10
 3f06c84:	eb000027 	bl	3f06d28 <load_serial_bin>
 3f06c88:	e1a04000 	mov	r4, r0

	if (addr == ~0) {
 3f06c8c:	e3740001 	cmn	r4, #1	; 0x1
 3f06c90:	1a000006 	bne	3f06cb0 <do_load_serial_bin+0x100>
		load_addr = 0;
		printf ("## Binary (kermit) download aborted\n");
 3f06c94:	e59f007c 	ldr	r0, [pc, #7c]	; 3f06d18 <do_load_serial_bin+0x168>
		rcode = 1;
 3f06c98:	e3a09001 	mov	r9, #1	; 0x1
 3f06c9c:	e59f2078 	ldr	r2, [pc, #78]	; 3f06d1c <do_load_serial_bin+0x16c>
 3f06ca0:	e3a03000 	mov	r3, #0	; 0x0
 3f06ca4:	e5823000 	str	r3, [r2]
 3f06ca8:	eb0016e5 	bl	3f0c844 <printf>
	} else {
 3f06cac:	ea000004 	b	3f06cc4 <do_load_serial_bin+0x114>
		printf ("## Start Addr      = 0x%08lX\n", addr);
 3f06cb0:	e59f0068 	ldr	r0, [pc, #68]	; 3f06d20 <do_load_serial_bin+0x170>
 3f06cb4:	e1a01004 	mov	r1, r4
 3f06cb8:	eb0016e1 	bl	3f0c844 <printf>
		load_addr = addr;
 3f06cbc:	e59f3058 	ldr	r3, [pc, #58]	; 3f06d1c <do_load_serial_bin+0x16c>
 3f06cc0:	e5834000 	str	r4, [r3]
	}

	if (load_baudrate != current_baudrate) {
 3f06cc4:	e1550006 	cmp	r5, r6
 3f06cc8:	0a00000c 	beq	3f06d00 <do_load_serial_bin+0x150>
		printf ("## Switch baudrate to %d bps and press ESC ...\n",
 3f06ccc:	e59f0050 	ldr	r0, [pc, #50]	; 3f06d24 <do_load_serial_bin+0x174>
 3f06cd0:	e1a01006 	mov	r1, r6
			current_baudrate);
		udelay (50000);
 3f06cd4:	e59f4034 	ldr	r4, [pc, #34]	; 3f06d10 <do_load_serial_bin+0x160>
 3f06cd8:	eb0016d9 	bl	3f0c844 <printf>
 3f06cdc:	e1a00004 	mov	r0, r4
 3f06ce0:	ebffe6cc 	bl	3f00818 <udelay>
		gd->baudrate = current_baudrate;
 3f06ce4:	e5886008 	str	r6, [r8, #8]
		serial_setbrg ();
 3f06ce8:	eb003d9f 	bl	3f1636c <serial_setbrg>
		udelay (50000);
 3f06cec:	e1a00004 	mov	r0, r4
 3f06cf0:	ebffe6c8 	bl	3f00818 <udelay>
		for (;;) {
			if (getc() == 0x1B) /* ESC */
 3f06cf4:	eb0016a2 	bl	3f0c784 <getc>
 3f06cf8:	e350001b 	cmp	r0, #27	; 0x1b
 3f06cfc:	1afffffc 	bne	3f06cf4 <do_load_serial_bin+0x144>
				break;
		}
	}

#ifdef CONFIG_AUTOSCRIPT
	if (load_addr) {
		char *s;

		if (((s = getenv("autoscript")) != NULL) && (strcmp(s,"yes") == 0)) {
			printf("Running autoscript at addr 0x%08lX ...\n", load_addr);
			rcode = autoscript (load_addr);
		}
	}
#endif
	return rcode;
 3f06d00:	e1a00009 	mov	r0, r9
}
 3f06d04:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f06d08:	03f1d03c 	mvneqs	r13, #60	; 0x3c
 3f06d0c:	03f1d048 	mvneqs	r13, #72	; 0x48
 3f06d10:	0000c350 	andeq	r12, r0, r0, asr r3
 3f06d14:	03f1d07c 	mvneqs	r13, #124	; 0x7c
 3f06d18:	03f1d0bc 	mvneqs	r13, #188	; 0xbc
 3f06d1c:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
 3f06d20:	03f1cfa4 	mvneqs	r12, #656	; 0x290
 3f06d24:	03f1d0e4 	mvneqs	r13, #228	; 0xe4

03f06d28 <load_serial_bin>:
 3f06d28:	e1a0c00d 	mov	r12, r13
 3f06d2c:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f06d30:	e24cb004 	sub	r11, r12, #4	; 0x4


static ulong load_serial_bin (ulong offset)
{
 3f06d34:	e1a06000 	mov	r6, r0
	int size, i;
	char buf[32];

	set_kerm_bin_mode ((ulong *) offset);
 3f06d38:	e24dd020 	sub	r13, r13, #32	; 0x20
 3f06d3c:	eb0000e6 	bl	3f070dc <set_kerm_bin_mode>
	size = k_recv ();
 3f06d40:	eb0001ca 	bl	3f07470 <k_recv>
 3f06d44:	e1a05000 	mov	r5, r0

	/*
	 * Gather any trailing characters (for instance, the ^D which
	 * is sent by 'cu' after sending a file), and give the
	 * box some time (100 * 1 ms)
	 */
	for (i=0; i<100; ++i) {
 3f06d48:	e3a04063 	mov	r4, #99	; 0x63
		if (serial_tstc()) {
 3f06d4c:	eb003dcb 	bl	3f16480 <serial_tstc>
 3f06d50:	e3500000 	cmp	r0, #0	; 0x0
 3f06d54:	0a000000 	beq	3f06d5c <load_serial_bin+0x34>
			(void) serial_getc();
 3f06d58:	eb003dae 	bl	3f16418 <serial_getc>
		}
		udelay(1000);
 3f06d5c:	e3a00ffa 	mov	r0, #1000	; 0x3e8
 3f06d60:	ebffe6ac 	bl	3f00818 <udelay>
 3f06d64:	e2544001 	subs	r4, r4, #1	; 0x1
 3f06d68:	5afffff7 	bpl	3f06d4c <load_serial_bin+0x24>
	}

	flush_cache (offset, size);
 3f06d6c:	e1a00006 	mov	r0, r6
 3f06d70:	e1a01005 	mov	r1, r5
 3f06d74:	eb004544 	bl	3f1828c <flush_cache>

	printf("## Total Size      = 0x%08x = %d Bytes\n", size, size);
 3f06d78:	e1a01005 	mov	r1, r5
 3f06d7c:	e59f002c 	ldr	r0, [pc, #2c]	; 3f06db0 <load_serial_bin+0x88>
 3f06d80:	e1a02005 	mov	r2, r5
 3f06d84:	eb0016ae 	bl	3f0c844 <printf>
	sprintf(buf, "%X", size);
 3f06d88:	e24b4038 	sub	r4, r11, #56	; 0x38
 3f06d8c:	e1a00004 	mov	r0, r4
 3f06d90:	e59f101c 	ldr	r1, [pc, #1c]	; 3f06db4 <load_serial_bin+0x8c>
 3f06d94:	e1a02005 	mov	r2, r5
 3f06d98:	eb0024a7 	bl	3f1003c <sprintf>
	setenv("filesize", buf);
 3f06d9c:	e59f0014 	ldr	r0, [pc, #14]	; 3f06db8 <load_serial_bin+0x90>
 3f06da0:	e1a01004 	mov	r1, r4
 3f06da4:	eb00148b 	bl	3f0bfd8 <setenv>

	return offset;
 3f06da8:	e1a00006 	mov	r0, r6
 3f06dac:	ea000002 	b	3f06dbc <load_serial_bin+0x94>
 3f06db0:	03f1d114 	mvneqs	r13, #5	; 0x5
 3f06db4:	03f1d13c 	mvneqs	r13, #15	; 0xf
 3f06db8:	03f1d030 	mvneqs	r13, #48	; 0x30
}
 3f06dbc:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f06dc0 <send_pad>:
 3f06dc0:	e1a0c00d 	mov	r12, r13
 3f06dc4:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}

void send_pad (void)
{
	int count = his_pad_count;
 3f06dc8:	e59f3034 	ldr	r3, [pc, #34]	; 3f06e04 <send_pad+0x44>
 3f06dcc:	e5934000 	ldr	r4, [r3]
 3f06dd0:	e24cb004 	sub	r11, r12, #4	; 0x4

	while (count-- > 0)
 3f06dd4:	e1a03004 	mov	r3, r4
 3f06dd8:	e2444001 	sub	r4, r4, #1	; 0x1
 3f06ddc:	e3530000 	cmp	r3, #0	; 0x0
 3f06de0:	d91ba810 	ldmledb	r11, {r4, r11, r13, r15}
		serial_putc (his_pad_char);
 3f06de4:	e59f301c 	ldr	r3, [pc, #1c]	; 3f06e08 <send_pad+0x48>
 3f06de8:	e5d30000 	ldrb	r0, [r3]
 3f06dec:	eb003d94 	bl	3f16444 <serial_putc>
 3f06df0:	e1a03004 	mov	r3, r4
 3f06df4:	e2444001 	sub	r4, r4, #1	; 0x1
 3f06df8:	e3530000 	cmp	r3, #0	; 0x0
 3f06dfc:	cafffff8 	bgt	3f06de4 <send_pad+0x24>
}
 3f06e00:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f06e04:	03f6cd6c 	mvneqs	r12, #6912	; 0x1b00
 3f06e08:	03f6cd70 	mvneqs	r12, #7168	; 0x1c00

03f06e0c <ktrans>:
 3f06e0c:	e1a0c00d 	mov	r12, r13
 3f06e10:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f06e14:	e24cb004 	sub	r11, r12, #4	; 0x4

/* converts escaped kermit char to binary char */
char ktrans (char in)
{
	if ((in & 0x60) == 0x40) {
 3f06e18:	e2003060 	and	r3, r0, #96	; 0x60
 3f06e1c:	e3530040 	cmp	r3, #64	; 0x40
 3f06e20:	e20020ff 	and	r2, r0, #255	; 0xff
		return (char) (in & ~0x40);
 3f06e24:	020000bf 	andeq	r0, r0, #191	; 0xbf
 3f06e28:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
	} else if ((in & 0x7f) == 0x3f) {
 3f06e2c:	e200307f 	and	r3, r0, #127	; 0x7f
 3f06e30:	e353003f 	cmp	r3, #63	; 0x3f
		return (char) (in | 0x40);
	} else
		return in;
 3f06e34:	11a00002 	movne	r0, r2
 3f06e38:	191ba800 	ldmnedb	r11, {r11, r13, r15}
 3f06e3c:	e3820040 	orr	r0, r2, #64	; 0x40
 3f06e40:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f06e44 <chk1>:
 3f06e44:	e1a0c00d 	mov	r12, r13
 3f06e48:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f06e4c:	e24cb004 	sub	r11, r12, #4	; 0x4
}

int chk1 (char *buffer)
{
	int total = 0;

	while (*buffer) {
 3f06e50:	e5d03000 	ldrb	r3, [r0]
 3f06e54:	e3a01000 	mov	r1, #0	; 0x0
 3f06e58:	e1530001 	cmp	r3, r1
 3f06e5c:	0a000004 	beq	3f06e74 <chk1+0x30>
		total += *buffer++;
 3f06e60:	e5d03000 	ldrb	r3, [r0]
	}
 3f06e64:	e5f02001 	ldrb	r2, [r0, #1]!
 3f06e68:	e0811003 	add	r1, r1, r3
 3f06e6c:	e3520000 	cmp	r2, #0	; 0x0
 3f06e70:	1afffffa 	bne	3f06e60 <chk1+0x1c>
	return (int) ((total + ((total >> 6) & 0x03)) & 0x3f);
 3f06e74:	e1a00341 	mov	r0, r1, asr #6
 3f06e78:	e2000003 	and	r0, r0, #3	; 0x3
 3f06e7c:	e0810000 	add	r0, r1, r0
 3f06e80:	e200003f 	and	r0, r0, #63	; 0x3f
}
 3f06e84:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f06e88 <s1_sendpacket>:
 3f06e88:	e1a0c00d 	mov	r12, r13
 3f06e8c:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f06e90:	e24cb004 	sub	r11, r12, #4	; 0x4

void s1_sendpacket (char *packet)
{
 3f06e94:	e1a04000 	mov	r4, r0
	send_pad ();
 3f06e98:	ebffffc8 	bl	3f06dc0 <send_pad>
	while (*packet) {
 3f06e9c:	e5d43000 	ldrb	r3, [r4]
 3f06ea0:	e3530000 	cmp	r3, #0	; 0x0
 3f06ea4:	091ba810 	ldmeqdb	r11, {r4, r11, r13, r15}
		serial_putc (*packet++);
 3f06ea8:	e5d40000 	ldrb	r0, [r4]
 3f06eac:	eb003d64 	bl	3f16444 <serial_putc>
	}
 3f06eb0:	e5f43001 	ldrb	r3, [r4, #1]!
 3f06eb4:	e3530000 	cmp	r3, #0	; 0x0
 3f06eb8:	1afffffa 	bne	3f06ea8 <s1_sendpacket+0x20>
 3f06ebc:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f06ec0 <send_ack>:
 3f06ec0:	e1a0c00d 	mov	r12, r13
 3f06ec4:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f06ec8:	e24cb004 	sub	r11, r12, #4	; 0x4
}

static char a_b[24];
void send_ack (int n)
{
	a_b[0] = START_CHAR;
 3f06ecc:	e3a03001 	mov	r3, #1	; 0x1
 3f06ed0:	e59f404c 	ldr	r4, [pc, #4c]	; 3f06f24 <send_ack+0x64>
	a_b[1] = tochar (3);
	a_b[2] = tochar (n);
	a_b[3] = ACK_TYPE;
	a_b[4] = '\0';
 3f06ed4:	e3a05000 	mov	r5, #0	; 0x0
 3f06ed8:	e5c43000 	strb	r3, [r4]
 3f06edc:	e2833022 	add	r3, r3, #34	; 0x22
 3f06ee0:	e5c43001 	strb	r3, [r4, #1]
 3f06ee4:	e2803020 	add	r3, r0, #32	; 0x20
 3f06ee8:	e5c43002 	strb	r3, [r4, #2]
 3f06eec:	e3a03059 	mov	r3, #89	; 0x59
 3f06ef0:	e5c43003 	strb	r3, [r4, #3]
	a_b[4] = tochar (chk1 (&a_b[1]));
 3f06ef4:	e2840001 	add	r0, r4, #1	; 0x1
 3f06ef8:	e5c45004 	strb	r5, [r4, #4]
 3f06efc:	ebffffd0 	bl	3f06e44 <chk1>
 3f06f00:	e2800020 	add	r0, r0, #32	; 0x20
 3f06f04:	e5c40004 	strb	r0, [r4, #4]
	a_b[5] = his_eol;
	a_b[6] = '\0';
 3f06f08:	e5c45006 	strb	r5, [r4, #6]
 3f06f0c:	e59f3014 	ldr	r3, [pc, #14]	; 3f06f28 <send_ack+0x68>
 3f06f10:	e5d33000 	ldrb	r3, [r3]
	s1_sendpacket (a_b);
 3f06f14:	e1a00004 	mov	r0, r4
 3f06f18:	e5c43005 	strb	r3, [r4, #5]
 3f06f1c:	ebffffd9 	bl	3f06e88 <s1_sendpacket>
 3f06f20:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f06f24:	03f6cd78 	mvneqs	r12, #7680	; 0x1e00
 3f06f28:	03f6cd68 	mvneqs	r12, #6656	; 0x1a00

03f06f2c <send_nack>:
 3f06f2c:	e1a0c00d 	mov	r12, r13
 3f06f30:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f06f34:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void send_nack (int n)
{
	a_b[0] = START_CHAR;
 3f06f38:	e3a03001 	mov	r3, #1	; 0x1
 3f06f3c:	e59f404c 	ldr	r4, [pc, #4c]	; 3f06f90 <send_nack+0x64>
	a_b[1] = tochar (3);
	a_b[2] = tochar (n);
	a_b[3] = NACK_TYPE;
	a_b[4] = '\0';
 3f06f40:	e3a05000 	mov	r5, #0	; 0x0
 3f06f44:	e5c43000 	strb	r3, [r4]
 3f06f48:	e2833022 	add	r3, r3, #34	; 0x22
 3f06f4c:	e5c43001 	strb	r3, [r4, #1]
 3f06f50:	e2803020 	add	r3, r0, #32	; 0x20
 3f06f54:	e5c43002 	strb	r3, [r4, #2]
 3f06f58:	e3a0304e 	mov	r3, #78	; 0x4e
 3f06f5c:	e5c43003 	strb	r3, [r4, #3]
	a_b[4] = tochar (chk1 (&a_b[1]));
 3f06f60:	e2840001 	add	r0, r4, #1	; 0x1
 3f06f64:	e5c45004 	strb	r5, [r4, #4]
 3f06f68:	ebffffb5 	bl	3f06e44 <chk1>
 3f06f6c:	e2800020 	add	r0, r0, #32	; 0x20
 3f06f70:	e5c40004 	strb	r0, [r4, #4]
	a_b[5] = his_eol;
	a_b[6] = '\0';
 3f06f74:	e5c45006 	strb	r5, [r4, #6]
 3f06f78:	e59f3014 	ldr	r3, [pc, #14]	; 3f06f94 <send_nack+0x68>
 3f06f7c:	e5d33000 	ldrb	r3, [r3]
	s1_sendpacket (a_b);
 3f06f80:	e1a00004 	mov	r0, r4
 3f06f84:	e5c43005 	strb	r3, [r4, #5]
 3f06f88:	ebffffbe 	bl	3f06e88 <s1_sendpacket>
 3f06f8c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f06f90:	03f6cd78 	mvneqs	r12, #7680	; 0x1e00
 3f06f94:	03f6cd68 	mvneqs	r12, #6656	; 0x1a00

03f06f98 <bin_data_init>:
 3f06f98:	e1a0c00d 	mov	r12, r13
 3f06f9c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}


/* os_data_* takes an OS Open image and puts it into memory, and
   puts the boot header in an array named os_data_header

   if image is binary, no header is stored in os_data_header.
*/
void (*os_data_init) (void);
void (*os_data_char) (char new_char);
static int os_data_state, os_data_state_saved;
int os_data_count;
static int os_data_count_saved;
static char *os_data_addr, *os_data_addr_saved;
static char *bin_start_address;
int os_data_header[8];
static void bin_data_init (void)
{
	os_data_state = 0;
 3f06fa0:	e59f3024 	ldr	r3, [pc, #24]	; 3f06fcc <bin_data_init+0x34>
 3f06fa4:	e3a02000 	mov	r2, #0	; 0x0
 3f06fa8:	e5832000 	str	r2, [r3]
	os_data_count = 0;
 3f06fac:	e59f301c 	ldr	r3, [pc, #1c]	; 3f06fd0 <bin_data_init+0x38>
 3f06fb0:	e5832000 	str	r2, [r3]
	os_data_addr = bin_start_address;
 3f06fb4:	e59f3018 	ldr	r3, [pc, #18]	; 3f06fd4 <bin_data_init+0x3c>
 3f06fb8:	e59f2018 	ldr	r2, [pc, #18]	; 3f06fd8 <bin_data_init+0x40>
 3f06fbc:	e5933000 	ldr	r3, [r3]
 3f06fc0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f06fc4:	e5823000 	str	r3, [r2]
 3f06fc8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f06fcc:	03f6cd98 	mvneqs	r12, #9728	; 0x2600
 3f06fd0:	03f6cd44 	mvneqs	r12, #4352	; 0x1100
 3f06fd4:	03f6cdac 	mvneqs	r12, #11008	; 0x2b00
 3f06fd8:	03f6cda4 	mvneqs	r12, #10496	; 0x2900

03f06fdc <os_data_save>:
 3f06fdc:	e1a0c00d 	mov	r12, r13
 3f06fe0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}
static void os_data_save (void)
{
	os_data_state_saved = os_data_state;
 3f06fe4:	e59f3030 	ldr	r3, [pc, #30]	; 3f0701c <os_data_save+0x40>
 3f06fe8:	e59f2030 	ldr	r2, [pc, #30]	; 3f07020 <os_data_save+0x44>
 3f06fec:	e5933000 	ldr	r3, [r3]
 3f06ff0:	e5823000 	str	r3, [r2]
	os_data_count_saved = os_data_count;
 3f06ff4:	e59f3028 	ldr	r3, [pc, #28]	; 3f07024 <os_data_save+0x48>
 3f06ff8:	e59f2028 	ldr	r2, [pc, #28]	; 3f07028 <os_data_save+0x4c>
 3f06ffc:	e5933000 	ldr	r3, [r3]
 3f07000:	e5823000 	str	r3, [r2]
	os_data_addr_saved = os_data_addr;
 3f07004:	e59f3020 	ldr	r3, [pc, #20]	; 3f0702c <os_data_save+0x50>
 3f07008:	e59f2020 	ldr	r2, [pc, #20]	; 3f07030 <os_data_save+0x54>
 3f0700c:	e5933000 	ldr	r3, [r3]
 3f07010:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f07014:	e5823000 	str	r3, [r2]
 3f07018:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0701c:	03f6cd98 	mvneqs	r12, #9728	; 0x2600
 3f07020:	03f6cd9c 	mvneqs	r12, #9984	; 0x2700
 3f07024:	03f6cd44 	mvneqs	r12, #4352	; 0x1100
 3f07028:	03f6cda0 	mvneqs	r12, #10240	; 0x2800
 3f0702c:	03f6cda4 	mvneqs	r12, #10496	; 0x2900
 3f07030:	03f6cda8 	mvneqs	r12, #10752	; 0x2a00

03f07034 <os_data_restore>:
 3f07034:	e1a0c00d 	mov	r12, r13
 3f07038:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}
static void os_data_restore (void)
{
	os_data_state = os_data_state_saved;
 3f0703c:	e59f3030 	ldr	r3, [pc, #30]	; 3f07074 <os_data_restore+0x40>
 3f07040:	e59f2030 	ldr	r2, [pc, #30]	; 3f07078 <os_data_restore+0x44>
 3f07044:	e5933000 	ldr	r3, [r3]
 3f07048:	e5823000 	str	r3, [r2]
	os_data_count = os_data_count_saved;
 3f0704c:	e59f3028 	ldr	r3, [pc, #28]	; 3f0707c <os_data_restore+0x48>
 3f07050:	e59f2028 	ldr	r2, [pc, #28]	; 3f07080 <os_data_restore+0x4c>
 3f07054:	e5933000 	ldr	r3, [r3]
 3f07058:	e5823000 	str	r3, [r2]
	os_data_addr = os_data_addr_saved;
 3f0705c:	e59f3020 	ldr	r3, [pc, #20]	; 3f07084 <os_data_restore+0x50>
 3f07060:	e59f2020 	ldr	r2, [pc, #20]	; 3f07088 <os_data_restore+0x54>
 3f07064:	e5933000 	ldr	r3, [r3]
 3f07068:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0706c:	e5823000 	str	r3, [r2]
 3f07070:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f07074:	03f6cd9c 	mvneqs	r12, #9984	; 0x2700
 3f07078:	03f6cd98 	mvneqs	r12, #9728	; 0x2600
 3f0707c:	03f6cda0 	mvneqs	r12, #10240	; 0x2800
 3f07080:	03f6cd44 	mvneqs	r12, #4352	; 0x1100
 3f07084:	03f6cda8 	mvneqs	r12, #10752	; 0x2a00
 3f07088:	03f6cda4 	mvneqs	r12, #10496	; 0x2900

03f0708c <bin_data_char>:
 3f0708c:	e1a0c00d 	mov	r12, r13
 3f07090:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}
static void bin_data_char (char new_char)
{
	switch (os_data_state) {
 3f07094:	e59f3034 	ldr	r3, [pc, #34]	; 3f070d0 <bin_data_char+0x44>
 3f07098:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0709c:	e5933000 	ldr	r3, [r3]
 3f070a0:	e20010ff 	and	r1, r0, #255	; 0xff
 3f070a4:	e3530000 	cmp	r3, #0	; 0x0
 3f070a8:	191ba800 	ldmnedb	r11, {r11, r13, r15}
	case 0:					/* data */
		*os_data_addr++ = new_char;
 3f070ac:	e59f0020 	ldr	r0, [pc, #20]	; 3f070d4 <bin_data_char+0x48>
 3f070b0:	e5902000 	ldr	r2, [r0]
 3f070b4:	e4c21001 	strb	r1, [r2], #1
		--os_data_count;
 3f070b8:	e59f1018 	ldr	r1, [pc, #18]	; 3f070d8 <bin_data_char+0x4c>
 3f070bc:	e5913000 	ldr	r3, [r1]
 3f070c0:	e5802000 	str	r2, [r0]
 3f070c4:	e2433001 	sub	r3, r3, #1	; 0x1
 3f070c8:	e5813000 	str	r3, [r1]
		break;
	}
 3f070cc:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f070d0:	03f6cd98 	mvneqs	r12, #9728	; 0x2600
 3f070d4:	03f6cda4 	mvneqs	r12, #10496	; 0x2900
 3f070d8:	03f6cd44 	mvneqs	r12, #4352	; 0x1100

03f070dc <set_kerm_bin_mode>:
 3f070dc:	e1a0c00d 	mov	r12, r13
 3f070e0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}
static void set_kerm_bin_mode (unsigned long *addr)
{
	bin_start_address = (char *) addr;
 3f070e4:	e59f3020 	ldr	r3, [pc, #20]	; 3f0710c <set_kerm_bin_mode+0x30>
	os_data_init = bin_data_init;
 3f070e8:	e59f2020 	ldr	r2, [pc, #20]	; 3f07110 <set_kerm_bin_mode+0x34>
 3f070ec:	e5830000 	str	r0, [r3]
 3f070f0:	e59f301c 	ldr	r3, [pc, #1c]	; 3f07114 <set_kerm_bin_mode+0x38>
 3f070f4:	e5823000 	str	r3, [r2]
	os_data_char = bin_data_char;
 3f070f8:	e59f2018 	ldr	r2, [pc, #18]	; 3f07118 <set_kerm_bin_mode+0x3c>
 3f070fc:	e59f3018 	ldr	r3, [pc, #18]	; 3f0711c <set_kerm_bin_mode+0x40>
 3f07100:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f07104:	e5823000 	str	r3, [r2]
 3f07108:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0710c:	03f6cdac 	mvneqs	r12, #11008	; 0x2b00
 3f07110:	03f6cd90 	mvneqs	r12, #9216	; 0x2400
 3f07114:	03f06f98 	mvneqs	r6, #608	; 0x260
 3f07118:	03f6cd94 	mvneqs	r12, #9472	; 0x2500
 3f0711c:	03f0708c 	mvneqs	r7, #140	; 0x8c

03f07120 <k_data_init>:
 3f07120:	e1a0c00d 	mov	r12, r13
 3f07124:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}


/* k_data_* simply handles the kermit escape translations */
static int k_data_escape, k_data_escape_saved;
void k_data_init (void)
{
	k_data_escape = 0;
 3f07128:	e59f3018 	ldr	r3, [pc, #18]	; 3f07148 <k_data_init+0x28>
 3f0712c:	e24cb004 	sub	r11, r12, #4	; 0x4
	os_data_init ();
 3f07130:	e59f1014 	ldr	r1, [pc, #14]	; 3f0714c <k_data_init+0x2c>
 3f07134:	e3a02000 	mov	r2, #0	; 0x0
 3f07138:	e5832000 	str	r2, [r3]
 3f0713c:	e1a0e00f 	mov	r14, r15
 3f07140:	e591f000 	ldr	r15, [r1]
 3f07144:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f07148:	03f6cdb0 	mvneqs	r12, #11264	; 0x2c00
 3f0714c:	03f6cd90 	mvneqs	r12, #9216	; 0x2400

03f07150 <k_data_save>:
 3f07150:	e1a0c00d 	mov	r12, r13
 3f07154:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}
void k_data_save (void)
{
	k_data_escape_saved = k_data_escape;
 3f07158:	e59f3014 	ldr	r3, [pc, #14]	; 3f07174 <k_data_save+0x24>
 3f0715c:	e59f2014 	ldr	r2, [pc, #14]	; 3f07178 <k_data_save+0x28>
 3f07160:	e5933000 	ldr	r3, [r3]
 3f07164:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f07168:	e5823000 	str	r3, [r2]
	os_data_save ();
 3f0716c:	ebffff9a 	bl	3f06fdc <os_data_save>
 3f07170:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f07174:	03f6cdb0 	mvneqs	r12, #11264	; 0x2c00
 3f07178:	03f6cdb4 	mvneqs	r12, #11520	; 0x2d00

03f0717c <k_data_restore>:
 3f0717c:	e1a0c00d 	mov	r12, r13
 3f07180:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}
void k_data_restore (void)
{
	k_data_escape = k_data_escape_saved;
 3f07184:	e59f3014 	ldr	r3, [pc, #14]	; 3f071a0 <k_data_restore+0x24>
 3f07188:	e59f2014 	ldr	r2, [pc, #14]	; 3f071a4 <k_data_restore+0x28>
 3f0718c:	e5933000 	ldr	r3, [r3]
 3f07190:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f07194:	e5823000 	str	r3, [r2]
	os_data_restore ();
 3f07198:	ebffffa5 	bl	3f07034 <os_data_restore>
 3f0719c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f071a0:	03f6cdb4 	mvneqs	r12, #11520	; 0x2d00
 3f071a4:	03f6cdb0 	mvneqs	r12, #11264	; 0x2c00

03f071a8 <k_data_char>:
 3f071a8:	e1a0c00d 	mov	r12, r13
 3f071ac:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
}
void k_data_char (char new_char)
{
	if (k_data_escape) {
 3f071b0:	e59f4058 	ldr	r4, [pc, #58]	; 3f07210 <k_data_char+0x68>
 3f071b4:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f071b8:	e5943000 	ldr	r3, [r4]
 3f071bc:	e20000ff 	and	r0, r0, #255	; 0xff
 3f071c0:	e3530000 	cmp	r3, #0	; 0x0
 3f071c4:	0a000007 	beq	3f071e8 <k_data_char+0x40>
		/* last char was escape - translate this character */
		os_data_char (ktrans (new_char));
 3f071c8:	ebffff0f 	bl	3f06e0c <ktrans>
 3f071cc:	e59f3040 	ldr	r3, [pc, #40]	; 3f07214 <k_data_char+0x6c>
 3f071d0:	e20000ff 	and	r0, r0, #255	; 0xff
 3f071d4:	e1a0e00f 	mov	r14, r15
 3f071d8:	e593f000 	ldr	r15, [r3]
		k_data_escape = 0;
 3f071dc:	e3a03000 	mov	r3, #0	; 0x0
 3f071e0:	e5843000 	str	r3, [r4]
	} else {
 3f071e4:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
		if (new_char == his_quote) {
 3f071e8:	e59f3028 	ldr	r3, [pc, #28]	; 3f07218 <k_data_char+0x70>
 3f071ec:	e5d33000 	ldrb	r3, [r3]
 3f071f0:	e1500003 	cmp	r0, r3
			/* this char is escape - remember */
			k_data_escape = 1;
 3f071f4:	03a03001 	moveq	r3, #1	; 0x1
 3f071f8:	05843000 	streq	r3, [r4]
		} else {
 3f071fc:	091ba810 	ldmeqdb	r11, {r4, r11, r13, r15}
			/* otherwise send this char as-is */
			os_data_char (new_char);
 3f07200:	e59f300c 	ldr	r3, [pc, #c]	; 3f07214 <k_data_char+0x6c>
 3f07204:	e1a0e00f 	mov	r14, r15
 3f07208:	e593f000 	ldr	r15, [r3]
		}
	}
 3f0720c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f07210:	03f6cdb0 	mvneqs	r12, #11264	; 0x2c00
 3f07214:	03f6cd94 	mvneqs	r12, #9472	; 0x2500
 3f07218:	03f6cd74 	mvneqs	r12, #7424	; 0x1d00

03f0721c <handle_send_packet>:
 3f0721c:	e1a0c00d 	mov	r12, r13
 3f07220:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
}

#define SEND_DATA_SIZE  20
char send_parms[SEND_DATA_SIZE];
char *send_ptr;

/* handle_send_packet interprits the protocol info and builds and
   sends an appropriate ack for what we can do */
void handle_send_packet (int n)
{
	int length = 3;
	int bytes;

	/* initialize some protocol parameters */
	his_eol = END_CHAR;		/* default end of line character */
 3f07224:	e59f2224 	ldr	r2, [pc, #224]	; 3f07450 <handle_send_packet+0x234>
 3f07228:	e24cb004 	sub	r11, r12, #4	; 0x4
	his_pad_count = 0;
 3f0722c:	e59fc220 	ldr	r12, [pc, #220]	; 3f07454 <handle_send_packet+0x238>
	his_pad_char = '\0';
 3f07230:	e59f9220 	ldr	r9, [pc, #220]	; 3f07458 <handle_send_packet+0x23c>
	his_quote = K_ESCAPE;

	/* ignore last character if it filled the buffer */
	if (send_ptr == &send_parms[SEND_DATA_SIZE - 1])
 3f07234:	e59f1220 	ldr	r1, [pc, #220]	; 3f0745c <handle_send_packet+0x240>
 3f07238:	e3a0300d 	mov	r3, #13	; 0xd
 3f0723c:	e59f421c 	ldr	r4, [pc, #21c]	; 3f07460 <handle_send_packet+0x244>
 3f07240:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f07244:	e5c23000 	strb	r3, [r2]
 3f07248:	e3a03000 	mov	r3, #0	; 0x0
 3f0724c:	e58c3000 	str	r3, [r12]
 3f07250:	e5c93000 	strb	r3, [r9]
 3f07254:	e59f2208 	ldr	r2, [pc, #208]	; 3f07464 <handle_send_packet+0x248>
 3f07258:	e5913000 	ldr	r3, [r1]
 3f0725c:	e3a0e023 	mov	r14, #35	; 0x23
 3f07260:	e5c4e000 	strb	r14, [r4]
 3f07264:	e3a06003 	mov	r6, #3	; 0x3
 3f07268:	e50b0028 	str	r0, [r11, -#40]
 3f0726c:	e1530002 	cmp	r3, r2
		--send_ptr;
 3f07270:	02423001 	subeq	r3, r2, #1	; 0x1
 3f07274:	05813000 	streq	r3, [r1]
	bytes = send_ptr - send_parms;	/* how many bytes we'll process */
 3f07278:	e5913000 	ldr	r3, [r1]
 3f0727c:	e2427013 	sub	r7, r2, #19	; 0x13
 3f07280:	e0674003 	rsb	r4, r7, r3
	do {
		if (bytes-- <= 0)
 3f07284:	e1a03004 	mov	r3, r4
 3f07288:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0728c:	e3530000 	cmp	r3, #0	; 0x0
 3f07290:	da000054 	ble	3f073e8 <handle_send_packet+0x1cc>
			break;
		/* handle MAXL - max length */
		/* ignore what he says - most I'll take (here) is 94 */
		a_b[++length] = tochar (94);
 3f07294:	e3a06004 	mov	r6, #4	; 0x4
		if (bytes-- <= 0)
 3f07298:	e1a03004 	mov	r3, r4
 3f0729c:	e2444001 	sub	r4, r4, #1	; 0x1
 3f072a0:	e3530000 	cmp	r3, #0	; 0x0
 3f072a4:	e59f51bc 	ldr	r5, [pc, #1bc]	; 3f07468 <handle_send_packet+0x24c>
 3f072a8:	e3a0a07e 	mov	r10, #126	; 0x7e
 3f072ac:	e7c5a006 	strb	r10, [r5, r6]
 3f072b0:	da00004c 	ble	3f073e8 <handle_send_packet+0x1cc>
			break;
		/* handle TIME - time you should wait for my packets */
		/* ignore what he says - don't wait for my ack longer than 1 second */
		a_b[++length] = tochar (1);
 3f072b4:	e2866001 	add	r6, r6, #1	; 0x1
		if (bytes-- <= 0)
 3f072b8:	e1a03004 	mov	r3, r4
 3f072bc:	e2444001 	sub	r4, r4, #1	; 0x1
 3f072c0:	e3530000 	cmp	r3, #0	; 0x0
 3f072c4:	e3a03021 	mov	r3, #33	; 0x21
 3f072c8:	e7c53006 	strb	r3, [r5, r6]
 3f072cc:	da000045 	ble	3f073e8 <handle_send_packet+0x1cc>
			break;
		/* handle NPAD - number of pad chars I need */
		/* remember what he says - I need none */
		his_pad_count = untochar (send_parms[2]);
		a_b[++length] = tochar (0);
 3f072d0:	e2866001 	add	r6, r6, #1	; 0x1
		if (bytes-- <= 0)
 3f072d4:	e1a03004 	mov	r3, r4
 3f072d8:	e2444001 	sub	r4, r4, #1	; 0x1
 3f072dc:	e3530000 	cmp	r3, #0	; 0x0
 3f072e0:	e5d73002 	ldrb	r3, [r7, #2]
 3f072e4:	e3a02020 	mov	r2, #32	; 0x20
 3f072e8:	e7c52006 	strb	r2, [r5, r6]
 3f072ec:	e2433020 	sub	r3, r3, #32	; 0x20
 3f072f0:	e20330ff 	and	r3, r3, #255	; 0xff
 3f072f4:	e58c3000 	str	r3, [r12]
 3f072f8:	da00003a 	ble	3f073e8 <handle_send_packet+0x1cc>
			break;
		/* handle PADC - pad chars I need */
		/* remember what he says - I need none */
		his_pad_char = ktrans (send_parms[3]);
 3f072fc:	e5d70003 	ldrb	r0, [r7, #3]
		a_b[++length] = 0x40;	/* He should ignore this */
 3f07300:	e2866001 	add	r6, r6, #1	; 0x1
 3f07304:	ebfffec0 	bl	3f06e0c <ktrans>
		if (bytes-- <= 0)
 3f07308:	e1a03004 	mov	r3, r4
 3f0730c:	e2444001 	sub	r4, r4, #1	; 0x1
 3f07310:	e3530000 	cmp	r3, #0	; 0x0
 3f07314:	e5c90000 	strb	r0, [r9]
 3f07318:	e3a03040 	mov	r3, #64	; 0x40
 3f0731c:	e7c53006 	strb	r3, [r5, r6]
 3f07320:	da000030 	ble	3f073e8 <handle_send_packet+0x1cc>
			break;
		/* handle EOL - end of line he needs */
		/* remember what he says - I need CR */
		his_eol = untochar (send_parms[4]);
		a_b[++length] = tochar (END_CHAR);
 3f07324:	e2866001 	add	r6, r6, #1	; 0x1
		if (bytes-- <= 0)
 3f07328:	e1a03004 	mov	r3, r4
 3f0732c:	e3530000 	cmp	r3, #0	; 0x0
 3f07330:	e5d73004 	ldrb	r3, [r7, #4]
 3f07334:	e3a0202d 	mov	r2, #45	; 0x2d
 3f07338:	e7c52006 	strb	r2, [r5, r6]
 3f0733c:	e2444001 	sub	r4, r4, #1	; 0x1
 3f07340:	e59fe108 	ldr	r14, [pc, #108]	; 3f07450 <handle_send_packet+0x234>
 3f07344:	e2433020 	sub	r3, r3, #32	; 0x20
 3f07348:	e5ce3000 	strb	r3, [r14]
 3f0734c:	da000025 	ble	3f073e8 <handle_send_packet+0x1cc>
			break;
		/* handle QCTL - quote control char he'll use */
		/* remember what he says - I'll use '#' */
		his_quote = send_parms[5];
		a_b[++length] = '#';
 3f07350:	e2866001 	add	r6, r6, #1	; 0x1
 3f07354:	e3a02023 	mov	r2, #35	; 0x23
 3f07358:	e7c52006 	strb	r2, [r5, r6]
		if (bytes-- <= 0)
 3f0735c:	e1a02004 	mov	r2, r4
 3f07360:	e59fe0f8 	ldr	r14, [pc, #f8]	; 3f07460 <handle_send_packet+0x244>
 3f07364:	e2444001 	sub	r4, r4, #1	; 0x1
 3f07368:	e5d73005 	ldrb	r3, [r7, #5]
 3f0736c:	e3520000 	cmp	r2, #0	; 0x0
 3f07370:	e5ce3000 	strb	r3, [r14]
 3f07374:	da00001b 	ble	3f073e8 <handle_send_packet+0x1cc>
			break;
		/* handle QBIN - 8-th bit prefixing */
		/* ignore what he says - I refuse */
		a_b[++length] = 'N';
 3f07378:	e2866001 	add	r6, r6, #1	; 0x1
		if (bytes-- <= 0)
 3f0737c:	e1a03004 	mov	r3, r4
 3f07380:	e2444001 	sub	r4, r4, #1	; 0x1
 3f07384:	e3530000 	cmp	r3, #0	; 0x0
 3f07388:	e3a0204e 	mov	r2, #78	; 0x4e
 3f0738c:	e7c52006 	strb	r2, [r5, r6]
 3f07390:	da000014 	ble	3f073e8 <handle_send_packet+0x1cc>
			break;
		/* handle CHKT - the clock check type */
		/* ignore what he says - I do type 1 (for now) */
		a_b[++length] = '1';
 3f07394:	e2866001 	add	r6, r6, #1	; 0x1
		if (bytes-- <= 0)
 3f07398:	e1a03004 	mov	r3, r4
 3f0739c:	e2444001 	sub	r4, r4, #1	; 0x1
 3f073a0:	e3530000 	cmp	r3, #0	; 0x0
 3f073a4:	e3a03031 	mov	r3, #49	; 0x31
 3f073a8:	e7c53006 	strb	r3, [r5, r6]
 3f073ac:	da00000d 	ble	3f073e8 <handle_send_packet+0x1cc>
			break;
		/* handle REPT - the repeat prefix */
		/* ignore what he says - I refuse (for now) */
		a_b[++length] = 'N';
 3f073b0:	e2866001 	add	r6, r6, #1	; 0x1
		if (bytes-- <= 0)
 3f073b4:	e3540000 	cmp	r4, #0	; 0x0
 3f073b8:	e7c52006 	strb	r2, [r5, r6]
 3f073bc:	da000009 	ble	3f073e8 <handle_send_packet+0x1cc>
			break;
		/* handle CAPAS - the capabilities mask */
		/* ignore what he says - I only do long packets - I don't do windows */
		a_b[++length] = tochar (2);	/* only long packets */
 3f073c0:	e3a0600d 	mov	r6, #13	; 0xd
 3f073c4:	e243300f 	sub	r3, r3, #15	; 0xf
 3f073c8:	e7c53006 	strb	r3, [r5, r6]
		a_b[++length] = tochar (0);	/* no windows */
 3f073cc:	e2866001 	add	r6, r6, #1	; 0x1
 3f073d0:	e3a02020 	mov	r2, #32	; 0x20
 3f073d4:	e7c52006 	strb	r2, [r5, r6]
		a_b[++length] = tochar (94);	/* large packet msb */
 3f073d8:	e2866001 	add	r6, r6, #1	; 0x1
 3f073dc:	e7c5a006 	strb	r10, [r5, r6]
		a_b[++length] = tochar (94);	/* large packet lsb */
 3f073e0:	e2866001 	add	r6, r6, #1	; 0x1
 3f073e4:	e7c5a006 	strb	r10, [r5, r6]
	} while (0);

	a_b[0] = START_CHAR;
 3f073e8:	e59f4078 	ldr	r4, [pc, #78]	; 3f07468 <handle_send_packet+0x24c>
 3f073ec:	e3a03001 	mov	r3, #1	; 0x1
 3f073f0:	e5c43000 	strb	r3, [r4]
	a_b[1] = tochar (length);
 3f073f4:	e2862020 	add	r2, r6, #32	; 0x20
 3f073f8:	e5c42001 	strb	r2, [r4, #1]
	a_b[2] = tochar (n);
	a_b[3] = ACK_TYPE;
	a_b[++length] = '\0';
 3f073fc:	e2866001 	add	r6, r6, #1	; 0x1
 3f07400:	e51be028 	ldr	r14, [r11, -#40]
	a_b[length] = tochar (chk1 (&a_b[1]));
 3f07404:	e0840003 	add	r0, r4, r3
 3f07408:	e28e3020 	add	r3, r14, #32	; 0x20
 3f0740c:	e5c43002 	strb	r3, [r4, #2]
 3f07410:	e3a03059 	mov	r3, #89	; 0x59
 3f07414:	e5c43003 	strb	r3, [r4, #3]
 3f07418:	e3a05000 	mov	r5, #0	; 0x0
 3f0741c:	e7c45006 	strb	r5, [r4, r6]
 3f07420:	ebfffe87 	bl	3f06e44 <chk1>
 3f07424:	e2800020 	add	r0, r0, #32	; 0x20
 3f07428:	e7c40006 	strb	r0, [r4, r6]
	a_b[++length] = his_eol;
 3f0742c:	e59f301c 	ldr	r3, [pc, #1c]	; 3f07450 <handle_send_packet+0x234>
 3f07430:	e2866001 	add	r6, r6, #1	; 0x1
 3f07434:	e5d33000 	ldrb	r3, [r3]
	a_b[++length] = '\0';
	s1_sendpacket (a_b);
 3f07438:	e1a00004 	mov	r0, r4
 3f0743c:	e7c43006 	strb	r3, [r4, r6]
 3f07440:	e2866001 	add	r6, r6, #1	; 0x1
 3f07444:	e7c45006 	strb	r5, [r4, r6]
 3f07448:	ebfffe8e 	bl	3f06e88 <s1_sendpacket>
 3f0744c:	ea000006 	b	3f0746c <handle_send_packet+0x250>
 3f07450:	03f6cd68 	mvneqs	r12, #6656	; 0x1a00
 3f07454:	03f6cd6c 	mvneqs	r12, #6912	; 0x1b00
 3f07458:	03f6cd70 	mvneqs	r12, #7168	; 0x1c00
 3f0745c:	03f6cdcc 	mvneqs	r12, #13056	; 0x3300
 3f07460:	03f6cd74 	mvneqs	r12, #7424	; 0x1d00
 3f07464:	03f6cdcb 	mvneqs	r12, #12992	; 0x32c0
 3f07468:	03f6cd78 	mvneqs	r12, #7680	; 0x1e00
}
 3f0746c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f07470 <k_recv>:
 3f07470:	e1a0c00d 	mov	r12, r13
 3f07474:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}

/* k_recv receives a OS Open image file over kermit line */
static int k_recv (void)
{
	char new_char;
	char k_state, k_state_saved;
	int sum;
	int done;
	int length;
	int n, last_n;
	int z = 0;
	int len_lo, len_hi;

	/* initialize some protocol parameters */
	his_eol = END_CHAR;		/* default end of line character */
 3f07478:	e3a0300d 	mov	r3, #13	; 0xd
 3f0747c:	e59f2214 	ldr	r2, [pc, #214]	; 3f07698 <k_recv+0x228>
 3f07480:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f07484:	e5c23000 	strb	r3, [r2]
	his_pad_count = 0;
 3f07488:	e59f220c 	ldr	r2, [pc, #20c]	; 3f0769c <k_recv+0x22c>
 3f0748c:	e243300d 	sub	r3, r3, #13	; 0xd
 3f07490:	e5823000 	str	r3, [r2]
 3f07494:	e24cb004 	sub	r11, r12, #4	; 0x4
	his_pad_char = '\0';
 3f07498:	e59f2200 	ldr	r2, [pc, #200]	; 3f076a0 <k_recv+0x230>
	his_quote = K_ESCAPE;

	/* initialize the k_recv and k_data state machine */
	done = 0;
 3f0749c:	e1a09003 	mov	r9, r3
 3f074a0:	e5c23000 	strb	r3, [r2]
	k_state = 0;
	k_data_init ();
	k_state_saved = k_state;
	k_data_save ();
	n = 0;				/* just to get rid of a warning */
	last_n = -1;
 3f074a4:	e2433001 	sub	r3, r3, #1	; 0x1
 3f074a8:	e50b3028 	str	r3, [r11, -#40]
 3f074ac:	e1a07009 	mov	r7, r9
 3f074b0:	e59f21ec 	ldr	r2, [pc, #1ec]	; 3f076a4 <k_recv+0x234>
 3f074b4:	e2833024 	add	r3, r3, #36	; 0x24
 3f074b8:	e5c23000 	strb	r3, [r2]
 3f074bc:	ebffff17 	bl	3f07120 <k_data_init>
 3f074c0:	ebffff22 	bl	3f07150 <k_data_save>

	/* expect this "type" sequence (but don't check):
	   S: send initiate
	   F: file header
	   D: data (multiple)
	   Z: end of file
	   B: break transmission
	 */

	/* enter main loop */
	while (!done) {
		/* set the send packet pointer to begining of send packet parms */
		send_ptr = send_parms;
 3f074c4:	e59fa1dc 	ldr	r10, [pc, #1dc]	; 3f076a8 <k_recv+0x238>
 3f074c8:	e59f31dc 	ldr	r3, [pc, #1dc]	; 3f076ac <k_recv+0x23c>
 3f074cc:	e58a3000 	str	r3, [r10]

		/* With each packet, start summing the bytes starting with the length.
		   Save the current sequence number.
		   Note the type of the packet.
		   If a character less than SPACE (0x20) is received - error.
		 */

#if 0
		/* OLD CODE, Prior to checking sequence numbers */
		/* first have all state machines save current states */
		k_state_saved = k_state;
		k_data_save ();
#endif

		/* get a packet */
		/* wait for the starting character or ^C */
		for (;;) {
			switch (serial_getc ()) {
 3f074d0:	eb003bd0 	bl	3f16418 <serial_getc>
 3f074d4:	e3500001 	cmp	r0, #1	; 0x1
 3f074d8:	0a000003 	beq	3f074ec <k_recv+0x7c>
 3f074dc:	e3500003 	cmp	r0, #3	; 0x3
 3f074e0:	1afffffa 	bne	3f074d0 <k_recv+0x60>
			case START_CHAR:	/* start packet */
				goto START;
			case ETX_CHAR:		/* ^C waiting for packet */
				return (0);
 3f074e4:	e3a00000 	mov	r0, #0	; 0x0
 3f074e8:	ea00007c 	b	3f076e0 <k_recv+0x270>
			default:
				;
			}
		}
START:
		/* get length of packet */
		sum = 0;
		new_char = serial_getc ();
 3f074ec:	eb003bc9 	bl	3f16418 <serial_getc>
 3f074f0:	e20020ff 	and	r2, r0, #255	; 0xff
		if ((new_char & 0xE0) == 0)
 3f074f4:	e31000e0 	tst	r0, #224	; 0xe0
 3f074f8:	e1a05002 	mov	r5, r2
 3f074fc:	0a00005c 	beq	3f07674 <k_recv+0x204>
			goto packet_error;
		sum += new_char & 0xff;
		length = untochar (new_char);
 3f07500:	e2423020 	sub	r3, r2, #32	; 0x20
 3f07504:	e20340ff 	and	r4, r3, #255	; 0xff
		/* get sequence number */
		new_char = serial_getc ();
 3f07508:	eb003bc2 	bl	3f16418 <serial_getc>
 3f0750c:	e20020ff 	and	r2, r0, #255	; 0xff
		if ((new_char & 0xE0) == 0)
 3f07510:	e31000e0 	tst	r0, #224	; 0xe0
 3f07514:	0a000056 	beq	3f07674 <k_recv+0x204>
			goto packet_error;
		sum += new_char & 0xff;
 3f07518:	e0855002 	add	r5, r5, r2
		n = untochar (new_char);
 3f0751c:	e2423020 	sub	r3, r2, #32	; 0x20
 3f07520:	e20370ff 	and	r7, r3, #255	; 0xff
		--length;

		/* NEW CODE - check sequence numbers for retried packets */
		/* Note - this new code assumes that the sequence number is correctly
		 * received.  Handling an invalid sequence number adds another layer
		 * of complexity that may not be needed - yet!  At this time, I'm hoping
		 * that I don't need to buffer the incoming data packets and can write
		 * the data into memory in real time.
		 */
		if (n == last_n) {
 3f07524:	e51b3028 	ldr	r3, [r11, -#40]
 3f07528:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0752c:	e1570003 	cmp	r7, r3
 3f07530:	1a000001 	bne	3f0753c <k_recv+0xcc>
			/* same sequence number, restore the previous state */
			k_state = k_state_saved;
			k_data_restore ();
 3f07534:	ebffff10 	bl	3f0717c <k_data_restore>
		} else {
 3f07538:	ea000001 	b	3f07544 <k_recv+0xd4>
			/* new sequence number, checkpoint the download */
			last_n = n;
 3f0753c:	e50b7028 	str	r7, [r11, -#40]
			k_state_saved = k_state;
			k_data_save ();
 3f07540:	ebffff02 	bl	3f07150 <k_data_save>
		}
		/* END NEW CODE */

		/* get packet type */
		new_char = serial_getc ();
 3f07544:	eb003bb3 	bl	3f16418 <serial_getc>
 3f07548:	e20020ff 	and	r2, r0, #255	; 0xff
		if ((new_char & 0xE0) == 0)
 3f0754c:	e31000e0 	tst	r0, #224	; 0xe0
 3f07550:	0a000047 	beq	3f07674 <k_recv+0x204>
			goto packet_error;
		sum += new_char & 0xff;
 3f07554:	e0855002 	add	r5, r5, r2
		k_state = new_char;
		--length;
 3f07558:	e2444001 	sub	r4, r4, #1	; 0x1
		/* check for extended length */
		if (length == -2) {
 3f0755c:	e3740002 	cmn	r4, #2	; 0x2
 3f07560:	e1a06002 	mov	r6, r2
 3f07564:	1a000031 	bne	3f07630 <k_recv+0x1c0>
			/* (length byte was 0, decremented twice) */
			/* get the two length bytes */
			new_char = serial_getc ();
 3f07568:	eb003baa 	bl	3f16418 <serial_getc>
 3f0756c:	e20020ff 	and	r2, r0, #255	; 0xff
			if ((new_char & 0xE0) == 0)
 3f07570:	e31000e0 	tst	r0, #224	; 0xe0
 3f07574:	0a00003e 	beq	3f07674 <k_recv+0x204>
				goto packet_error;
			sum += new_char & 0xff;
 3f07578:	e0855002 	add	r5, r5, r2
			len_hi = untochar (new_char);
 3f0757c:	e2423020 	sub	r3, r2, #32	; 0x20
 3f07580:	e20340ff 	and	r4, r3, #255	; 0xff
			new_char = serial_getc ();
 3f07584:	eb003ba3 	bl	3f16418 <serial_getc>
 3f07588:	e20020ff 	and	r2, r0, #255	; 0xff
			if ((new_char & 0xE0) == 0)
 3f0758c:	e31000e0 	tst	r0, #224	; 0xe0
 3f07590:	0a000037 	beq	3f07674 <k_recv+0x204>
				goto packet_error;
			sum += new_char & 0xff;
 3f07594:	e0855002 	add	r5, r5, r2
			len_lo = untochar (new_char);
 3f07598:	e2423020 	sub	r3, r2, #32	; 0x20
 3f0759c:	e20330ff 	and	r3, r3, #255	; 0xff
			length = len_hi * 95 + len_lo;
 3f075a0:	e0842084 	add	r2, r4, r4, lsl #1
 3f075a4:	e0642282 	rsb	r2, r4, r2, lsl #5
 3f075a8:	e0824003 	add	r4, r2, r3
			/* check header checksum */
			new_char = serial_getc ();
 3f075ac:	eb003b99 	bl	3f16418 <serial_getc>
 3f075b0:	e20020ff 	and	r2, r0, #255	; 0xff
			if ((new_char & 0xE0) == 0)
 3f075b4:	e31000e0 	tst	r0, #224	; 0xe0
 3f075b8:	0a00002d 	beq	3f07674 <k_recv+0x204>
				goto packet_error;
			if (new_char != tochar ((sum + ((sum >> 6) & 0x03)) & 0x3f))
 3f075bc:	e1a03345 	mov	r3, r5, asr #6
 3f075c0:	e2033003 	and	r3, r3, #3	; 0x3
 3f075c4:	e0853003 	add	r3, r5, r3
 3f075c8:	e203303f 	and	r3, r3, #63	; 0x3f
 3f075cc:	e2833020 	add	r3, r3, #32	; 0x20
 3f075d0:	e1520003 	cmp	r2, r3
 3f075d4:	1a000026 	bne	3f07674 <k_recv+0x204>
				goto packet_error;
			sum += new_char & 0xff;
 3f075d8:	e0855002 	add	r5, r5, r2
/* --length; */ /* new length includes only data and block check to come */
		}
		/* bring in rest of packet */
		while (length > 1) {
 3f075dc:	ea000013 	b	3f07630 <k_recv+0x1c0>
			new_char = serial_getc ();
 3f075e0:	eb003b8c 	bl	3f16418 <serial_getc>
 3f075e4:	e20020ff 	and	r2, r0, #255	; 0xff
			if ((new_char & 0xE0) == 0)
 3f075e8:	e31000e0 	tst	r0, #224	; 0xe0
 3f075ec:	0a000020 	beq	3f07674 <k_recv+0x204>
				goto packet_error;
			sum += new_char & 0xff;
 3f075f0:	e0855002 	add	r5, r5, r2
			--length;
 3f075f4:	e2444001 	sub	r4, r4, #1	; 0x1
			if (k_state == DATA_TYPE) {
 3f075f8:	e3560044 	cmp	r6, #68	; 0x44
 3f075fc:	1a000002 	bne	3f0760c <k_recv+0x19c>
				/* pass on the data if this is a data packet */
				k_data_char (new_char);
 3f07600:	e1a00002 	mov	r0, r2
 3f07604:	ebfffee7 	bl	3f071a8 <k_data_char>
			} else if (k_state == SEND_TYPE) {
 3f07608:	ea000008 	b	3f07630 <k_recv+0x1c0>
 3f0760c:	e3560053 	cmp	r6, #83	; 0x53
 3f07610:	1a000006 	bne	3f07630 <k_recv+0x1c0>
				/* save send pack in buffer as is */
				*send_ptr++ = new_char;
 3f07614:	e59a1000 	ldr	r1, [r10]
				/* if too much data, back off the pointer */
				if (send_ptr >= &send_parms[SEND_DATA_SIZE])
 3f07618:	e59f3090 	ldr	r3, [pc, #90]	; 3f076b0 <k_recv+0x240>
 3f0761c:	e4c12001 	strb	r2, [r1], #1
 3f07620:	e1510003 	cmp	r1, r3
 3f07624:	e58a1000 	str	r1, [r10]
					--send_ptr;
 3f07628:	22413001 	subcs	r3, r1, #1	; 0x1
 3f0762c:	258a3000 	strcs	r3, [r10]
			}
		}
 3f07630:	e3540001 	cmp	r4, #1	; 0x1
 3f07634:	caffffe9 	bgt	3f075e0 <k_recv+0x170>
		/* get and validate checksum character */
		new_char = serial_getc ();
 3f07638:	eb003b76 	bl	3f16418 <serial_getc>
 3f0763c:	e20020ff 	and	r2, r0, #255	; 0xff
		if ((new_char & 0xE0) == 0)
 3f07640:	e31000e0 	tst	r0, #224	; 0xe0
 3f07644:	0a00000a 	beq	3f07674 <k_recv+0x204>
			goto packet_error;
		if (new_char != tochar ((sum + ((sum >> 6) & 0x03)) & 0x3f))
 3f07648:	e1a03345 	mov	r3, r5, asr #6
 3f0764c:	e2033003 	and	r3, r3, #3	; 0x3
 3f07650:	e0853003 	add	r3, r5, r3
 3f07654:	e203303f 	and	r3, r3, #63	; 0x3f
 3f07658:	e2833020 	add	r3, r3, #32	; 0x20
 3f0765c:	e1520003 	cmp	r2, r3
 3f07660:	1a000003 	bne	3f07674 <k_recv+0x204>
			goto packet_error;
		/* get END_CHAR */
		new_char = serial_getc ();
 3f07664:	eb003b6b 	bl	3f16418 <serial_getc>
 3f07668:	e20020ff 	and	r2, r0, #255	; 0xff
		if (new_char != END_CHAR) {
 3f0766c:	e352000d 	cmp	r2, #13	; 0xd
 3f07670:	0a000003 	beq	3f07684 <k_recv+0x214>
		  packet_error:
			/* restore state machines */
			k_state = k_state_saved;
			k_data_restore ();
 3f07674:	ebfffec0 	bl	3f0717c <k_data_restore>
			/* send a negative acknowledge packet in */
			send_nack (n);
 3f07678:	e1a00007 	mov	r0, r7
 3f0767c:	ebfffe2a 	bl	3f06f2c <send_nack>
		} else if (k_state == SEND_TYPE) {
 3f07680:	ea00000f 	b	3f076c4 <k_recv+0x254>
 3f07684:	e3560053 	cmp	r6, #83	; 0x53
 3f07688:	1a000009 	bne	3f076b4 <k_recv+0x244>
			/* crack the protocol parms, build an appropriate ack packet */
			handle_send_packet (n);
 3f0768c:	e1a00007 	mov	r0, r7
 3f07690:	ebfffee1 	bl	3f0721c <handle_send_packet>
		} else {
 3f07694:	ea00000a 	b	3f076c4 <k_recv+0x254>
 3f07698:	03f6cd68 	mvneqs	r12, #6656	; 0x1a00
 3f0769c:	03f6cd6c 	mvneqs	r12, #6912	; 0x1b00
 3f076a0:	03f6cd70 	mvneqs	r12, #7168	; 0x1c00
 3f076a4:	03f6cd74 	mvneqs	r12, #7424	; 0x1d00
 3f076a8:	03f6cdcc 	mvneqs	r12, #13056	; 0x3300
 3f076ac:	03f6cdb8 	mvneqs	r12, #11776	; 0x2e00
 3f076b0:	03f6cdcc 	mvneqs	r12, #13056	; 0x3300
			/* send simple acknowledge packet in */
			send_ack (n);
 3f076b4:	e1a00007 	mov	r0, r7
 3f076b8:	ebfffe00 	bl	3f06ec0 <send_ack>
			/* quit if end of transmission */
			if (k_state == BREAK_TYPE)
 3f076bc:	e3560042 	cmp	r6, #66	; 0x42
 3f076c0:	03a09001 	moveq	r9, #1	; 0x1
				done = 1;
		}
		++z;
	}
 3f076c4:	e3590000 	cmp	r9, #0	; 0x0
 3f076c8:	0affff7d 	beq	3f074c4 <k_recv+0x54>
	return ((ulong) os_data_addr - (ulong) bin_start_address);
 3f076cc:	e59f3010 	ldr	r3, [pc, #10]	; 3f076e4 <k_recv+0x274>
 3f076d0:	e59f2010 	ldr	r2, [pc, #10]	; 3f076e8 <k_recv+0x278>
 3f076d4:	e5933000 	ldr	r3, [r3]
 3f076d8:	e5920000 	ldr	r0, [r2]
 3f076dc:	e0600003 	rsb	r0, r0, r3
 3f076e0:	ea000001 	b	3f076ec <k_recv+0x27c>
 3f076e4:	03f6cda4 	mvneqs	r12, #10496	; 0x2900
 3f076e8:	03f6cdac 	mvneqs	r12, #11008	; 0x2b00
}
 3f076ec:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f076f0 <do_loadub>:
 3f076f0:	e1a0c00d 	mov	r12, r13
 3f076f4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f076f8:	e24cb004 	sub	r11, r12, #4	; 0x4
static int loadub_common (cmd_tbl_t *, int , char *[]);

int do_loadub (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	return loadub_common (cmdtp, argc, argv);
 3f076fc:	e1a01002 	mov	r1, r2
 3f07700:	e1a02003 	mov	r2, r3
 3f07704:	eb000000 	bl	3f0770c <loadub_common>
 3f07708:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0770c <loadub_common>:
 3f0770c:	e1a0c00d 	mov	r12, r13
 3f07710:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f07714:	e24cb004 	sub	r11, r12, #4	; 0x4
}

U_BOOT_CMD(
	loadub,	3,	1,	do_loadub,
	"loadub  - boot image via usb using usbdnw\n",
	"[loadAddress] [bootfilename]\n"
);

static int
loadub_common (cmd_tbl_t *cmdtp, int argc, char *argv[])
{
	char *s;
	int   rcode = 0;
 3f07718:	e3a0a000 	mov	r10, #0	; 0x0
 3f0771c:	e1a09000 	mov	r9, r0
 3f07720:	e1a04001 	mov	r4, r1
	int   size;

	if(loadub_first_flag) {
 3f07724:	e59f5130 	ldr	r5, [pc, #130]	; 3f0785c <loadub_common+0x150>
 3f07728:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f0772c:	e5953000 	ldr	r3, [r5]
 3f07730:	e1a07002 	mov	r7, r2
 3f07734:	e153000a 	cmp	r3, r10
 3f07738:	0a000008 	beq	3f07760 <loadub_common+0x54>
		/* pre-set filename */
		if ((s = getenv("bootfile")) != NULL) {
 3f0773c:	e59f011c 	ldr	r0, [pc, #11c]	; 3f07860 <loadub_common+0x154>
 3f07740:	eb001245 	bl	3f0c05c <getenv>
 3f07744:	e3500000 	cmp	r0, #0	; 0x0
 3f07748:	0a000004 	beq	3f07760 <loadub_common+0x54>
			copy_filename (loadub_filename, s, sizeof (loadub_filename));
 3f0774c:	e1a01000 	mov	r1, r0
 3f07750:	e59f010c 	ldr	r0, [pc, #10c]	; 3f07864 <loadub_common+0x158>
 3f07754:	e3a02080 	mov	r2, #128	; 0x80
 3f07758:	ebffe93a 	bl	3f01c48 <copy_filename>
			loadub_first_flag = 0;
 3f0775c:	e585a000 	str	r10, [r5]
		}
	}

	/* pre-set load_addr */
	if ((s = getenv("loadaddr")) != NULL) {
 3f07760:	e59f0100 	ldr	r0, [pc, #100]	; 3f07868 <loadub_common+0x15c>
 3f07764:	eb00123c 	bl	3f0c05c <getenv>
 3f07768:	e3500000 	cmp	r0, #0	; 0x0
 3f0776c:	0a000004 	beq	3f07784 <loadub_common+0x78>
		load_addr = simple_strtoul(s, NULL, 16);
 3f07770:	e3a01000 	mov	r1, #0	; 0x0
 3f07774:	e3a02010 	mov	r2, #16	; 0x10
 3f07778:	eb001ff1 	bl	3f0f744 <simple_strtoul>
 3f0777c:	e59f30e8 	ldr	r3, [pc, #e8]	; 3f0786c <loadub_common+0x160>
 3f07780:	e5830000 	str	r0, [r3]
	}

	switch (argc) {
 3f07784:	e3540002 	cmp	r4, #2	; 0x2
 3f07788:	0a000006 	beq	3f077a8 <loadub_common+0x9c>
 3f0778c:	ca000002 	bgt	3f0779c <loadub_common+0x90>
 3f07790:	e3540001 	cmp	r4, #1	; 0x1
 3f07794:	0a00001f 	beq	3f07818 <loadub_common+0x10c>
 3f07798:	ea000019 	b	3f07804 <loadub_common+0xf8>
 3f0779c:	e3540003 	cmp	r4, #3	; 0x3
 3f077a0:	0a00000c 	beq	3f077d8 <loadub_common+0xcc>
 3f077a4:	ea000016 	b	3f07804 <loadub_common+0xf8>
	case 1:
		break;

	case 2:	/* only one arg - accept two forms:
		 * just load address, or just boot file name.
		 * The latter form must be written "filename" here.
		 */
		if (argv[1][0] == '"') {	/* just boot filename */
 3f077a8:	e5970004 	ldr	r0, [r7, #4]
 3f077ac:	e5d03000 	ldrb	r3, [r0]
 3f077b0:	e3530022 	cmp	r3, #34	; 0x22
			copy_filename (loadub_filename, argv[1], sizeof(loadub_filename));
 3f077b4:	01a01000 	moveq	r1, r0
 3f077b8:	059f00a4 	ldreq	r0, [pc, #a4]	; 3f07864 <loadub_common+0x158>
		} else {			/* load address	*/
 3f077bc:	0a00000d 	beq	3f077f8 <loadub_common+0xec>
			load_addr = simple_strtoul(argv[1], NULL, 16);
 3f077c0:	e3a01000 	mov	r1, #0	; 0x0
 3f077c4:	e3a02010 	mov	r2, #16	; 0x10
 3f077c8:	eb001fdd 	bl	3f0f744 <simple_strtoul>
 3f077cc:	e59f3098 	ldr	r3, [pc, #98]	; 3f0786c <loadub_common+0x160>
 3f077d0:	e5830000 	str	r0, [r3]
		}
		break;
 3f077d4:	ea00000f 	b	3f07818 <loadub_common+0x10c>

	case 3:	load_addr = simple_strtoul(argv[1], NULL, 16);
 3f077d8:	e3a01000 	mov	r1, #0	; 0x0
 3f077dc:	e5970004 	ldr	r0, [r7, #4]
 3f077e0:	e3a02010 	mov	r2, #16	; 0x10
 3f077e4:	eb001fd6 	bl	3f0f744 <simple_strtoul>
 3f077e8:	e59f307c 	ldr	r3, [pc, #7c]	; 3f0786c <loadub_common+0x160>
 3f077ec:	e5830000 	str	r0, [r3]
		copy_filename (loadub_filename, argv[2], sizeof(loadub_filename));
 3f077f0:	e59f006c 	ldr	r0, [pc, #6c]	; 3f07864 <loadub_common+0x158>
 3f077f4:	e5971008 	ldr	r1, [r7, #8]
 3f077f8:	e3a02080 	mov	r2, #128	; 0x80
 3f077fc:	ebffe911 	bl	3f01c48 <copy_filename>

		break;
 3f07800:	ea000004 	b	3f07818 <loadub_common+0x10c>

	default: printf ("Usage:\n%s\n", cmdtp->usage);
 3f07804:	e59f0064 	ldr	r0, [pc, #64]	; 3f07870 <loadub_common+0x164>
 3f07808:	e5991010 	ldr	r1, [r9, #16]
 3f0780c:	eb00140c 	bl	3f0c844 <printf>
		return 1;
 3f07810:	e3a00001 	mov	r0, #1	; 0x1
 3f07814:	ea000030 	b	3f078dc <loadub_common+0x1d0>
	}

	printf("Filename: %s\n", loadub_filename);
 3f07818:	e59f4044 	ldr	r4, [pc, #44]	; 3f07864 <loadub_common+0x158>
 3f0781c:	e59f0050 	ldr	r0, [pc, #50]	; 3f07874 <loadub_common+0x168>
 3f07820:	e1a01004 	mov	r1, r4
 3f07824:	eb001406 	bl	3f0c844 <printf>
	printf("Load address: 0x%x\n", load_addr);
 3f07828:	e59f603c 	ldr	r6, [pc, #3c]	; 3f0786c <loadub_common+0x160>
 3f0782c:	e59f0044 	ldr	r0, [pc, #44]	; 3f07878 <loadub_common+0x16c>
 3f07830:	e5961000 	ldr	r1, [r6]
 3f07834:	eb001402 	bl	3f0c844 <printf>
	if ((size = usbd_recv(load_addr, loadub_filename)) < 0)
 3f07838:	e5960000 	ldr	r0, [r6]
 3f0783c:	e1a01004 	mov	r1, r4
 3f07840:	eb003c5a 	bl	3f169b0 <usbd_recv>
 3f07844:	e2501000 	subs	r1, r0, #0	; 0x0
		return 1;
 3f07848:	b3a00001 	movlt	r0, #1	; 0x1
 3f0784c:	ba000022 	blt	3f078dc <loadub_common+0x1d0>

	/* done if no file was loaded (no errors though) */
	if (size == 0)
 3f07850:	1a000009 	bne	3f0787c <loadub_common+0x170>
		return 0;
 3f07854:	e1a00001 	mov	r0, r1
 3f07858:	ea00001f 	b	3f078dc <loadub_common+0x1d0>
 3f0785c:	03f20600 	mvneqs	r0, #0	; 0x0
 3f07860:	03f1d2b8 	mvneqs	r13, #-2147483637	; 0x8000000b
 3f07864:	03f6cdd0 	mvneqs	r12, #13312	; 0x3400
 3f07868:	03f1d2c4 	mvneqs	r13, #1073741836	; 0x4000000c
 3f0786c:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
 3f07870:	03f1d2d0 	mvneqs	r13, #13	; 0xd
 3f07874:	03f1d2dc 	mvneqs	r13, #-1073741811	; 0xc000000d
 3f07878:	03f1d2ec 	mvneqs	r13, #-1073741810	; 0xc000000e

	/* flush cache */
	flush_cache(load_addr, size);
 3f0787c:	e5960000 	ldr	r0, [r6]
 3f07880:	eb004281 	bl	3f1828c <flush_cache>

	/* Loading ok, check if we should attempt an auto-start */
	if (((s = getenv("autostart")) != NULL) && (strcmp(s,"yes") == 0)) {
 3f07884:	e59f0054 	ldr	r0, [pc, #54]	; 3f078e0 <loadub_common+0x1d4>
 3f07888:	eb0011f3 	bl	3f0c05c <getenv>
 3f0788c:	e3500000 	cmp	r0, #0	; 0x0
 3f07890:	0a000010 	beq	3f078d8 <loadub_common+0x1cc>
 3f07894:	e59f1048 	ldr	r1, [pc, #48]	; 3f078e4 <loadub_common+0x1d8>
 3f07898:	eb001e46 	bl	3f0f1b8 <strcmp>
 3f0789c:	e2505000 	subs	r5, r0, #0	; 0x0
 3f078a0:	1a00000c 	bne	3f078d8 <loadub_common+0x1cc>
		char *local_args[2];
		local_args[0] = argv[0];
		local_args[1] = NULL;
 3f078a4:	e50b5028 	str	r5, [r11, -#40]

		printf ("Automatic boot of image at addr 0x%08lX ...\n",
 3f078a8:	e59f0038 	ldr	r0, [pc, #38]	; 3f078e8 <loadub_common+0x1dc>
 3f078ac:	e5961000 	ldr	r1, [r6]
 3f078b0:	e5973000 	ldr	r3, [r7]
 3f078b4:	e24b402c 	sub	r4, r11, #44	; 0x2c
 3f078b8:	e50b302c 	str	r3, [r11, -#44]
 3f078bc:	eb0013e0 	bl	3f0c844 <printf>
			load_addr);
		rcode = do_bootm (cmdtp, 0, 1, local_args);
 3f078c0:	e1a00009 	mov	r0, r9
 3f078c4:	e1a01005 	mov	r1, r5
 3f078c8:	e3a02001 	mov	r2, #1	; 0x1
 3f078cc:	e1a03004 	mov	r3, r4
 3f078d0:	ebfff2ee 	bl	3f04490 <do_bootm>
 3f078d4:	e1a0a000 	mov	r10, r0
	}

#ifdef CONFIG_AUTOSCRIPT
	if (((s = getenv("autoscript")) != NULL) && (strcmp(s,"yes") == 0)) {
		printf("Running autoscript at addr 0x%08lX ...\n", load_addr);
		rcode = autoscript (load_addr);
	}
#endif
	return rcode;
 3f078d8:	e1a0000a 	mov	r0, r10
 3f078dc:	ea000002 	b	3f078ec <loadub_common+0x1e0>
 3f078e0:	03f1d300 	mvneqs	r13, #0	; 0x0
 3f078e4:	03f1d30c 	mvneqs	r13, #805306368	; 0x30000000
 3f078e8:	03f1d310 	mvneqs	r13, #1073741824	; 0x40000000
}
 3f078ec:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f078f0 <cmd_get_data_size>:
 3f078f0:	e1a0c00d 	mov	r12, r13
 3f078f4:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f078f8:	e24cb004 	sub	r11, r12, #4	; 0x4
			CFG_CMD_I2C	| \
			CFG_CMD_PCI	| \
			CMD_CMD_PORTIO	) )
int cmd_get_data_size(char* arg, int default_size)
{
 3f078fc:	e1a04000 	mov	r4, r0
 3f07900:	e1a05001 	mov	r5, r1
	/* Check for a size specification .b, .w or .l.
	 */
	int len = strlen(arg);
 3f07904:	eb001e6f 	bl	3f0f2c8 <strlen>
	if (len > 2 && arg[len-2] == '.') {
 3f07908:	e3500002 	cmp	r0, #2	; 0x2
 3f0790c:	da000015 	ble	3f07968 <cmd_get_data_size+0x78>
 3f07910:	e0800004 	add	r0, r0, r4
 3f07914:	e5503002 	ldrb	r3, [r0, -#2]
 3f07918:	e353002e 	cmp	r3, #46	; 0x2e
 3f0791c:	1a000011 	bne	3f07968 <cmd_get_data_size+0x78>
		switch(arg[len-1]) {
 3f07920:	e5500001 	ldrb	r0, [r0, -#1]
 3f07924:	e350006c 	cmp	r0, #108	; 0x6c
 3f07928:	0a00000a 	beq	3f07958 <cmd_get_data_size+0x68>
 3f0792c:	ca000002 	bgt	3f0793c <cmd_get_data_size+0x4c>
 3f07930:	e3500062 	cmp	r0, #98	; 0x62
 3f07934:	0a000003 	beq	3f07948 <cmd_get_data_size+0x58>
 3f07938:	ea000008 	b	3f07960 <cmd_get_data_size+0x70>
 3f0793c:	e3500077 	cmp	r0, #119	; 0x77
 3f07940:	0a000002 	beq	3f07950 <cmd_get_data_size+0x60>
 3f07944:	ea000005 	b	3f07960 <cmd_get_data_size+0x70>
		case 'b':
			return 1;
 3f07948:	e3a00001 	mov	r0, #1	; 0x1
 3f0794c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
		case 'w':
			return 2;
 3f07950:	e3a00002 	mov	r0, #2	; 0x2
 3f07954:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
		case 'l':
			return 4;
 3f07958:	e3a00004 	mov	r0, #4	; 0x4
 3f0795c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
		default:
			return -1;
 3f07960:	e3e00000 	mvn	r0, #0	; 0x0
 3f07964:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
		}
	}
	return default_size;
 3f07968:	e1a00005 	mov	r0, r5
}
 3f0796c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f07970 <do_mem_md>:
 3f07970:	e1a0c00d 	mov	r12, r13
 3f07974:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f07978:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#if (CONFIG_COMMANDS & CFG_CMD_MEMORY)

#ifdef	CMD_MEM_DEBUG
#define	PRINTF(fmt,args...)	printf (fmt ,##args)
#else
#define PRINTF(fmt,args...)
#endif

static int mod_mem(cmd_tbl_t *, int, int, int, char *[]);

/* Display values from last command.
 * Memory modify remembered values are different from display memory.
 */
uint	dp_last_addr, dp_last_size;
uint	dp_last_length = 0x40;
uint	mm_last_addr, mm_last_size;

static	ulong	base_address = 0;

/* Memory Display
 *
 * Syntax:
 *	md{.b, .w, .l} {addr} {len}
 */
#define DISP_LINE_LEN	16
int do_mem_md ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	ulong	addr, length;
	ulong	i, nbytes, linebytes;
	u_char	*cp;
	int	size;
	int rc = 0;

	/* We use the last specified parameters, unless new ones are
	 * entered.
	 */
	addr = dp_last_addr;
 3f0797c:	e59fc19c 	ldr	r12, [pc, #19c]	; 3f07b20 <do_mem_md+0x1b0>
 3f07980:	e1a06002 	mov	r6, r2
	size = dp_last_size;
	length = dp_last_length;
 3f07984:	e59f2198 	ldr	r2, [pc, #198]	; 3f07b24 <do_mem_md+0x1b4>
 3f07988:	e24dd024 	sub	r13, r13, #36	; 0x24
 3f0798c:	e59c5000 	ldr	r5, [r12]
 3f07990:	e3a0c000 	mov	r12, #0	; 0x0
 3f07994:	e50bc03c 	str	r12, [r11, -#60]
 3f07998:	e59fc188 	ldr	r12, [pc, #188]	; 3f07b28 <do_mem_md+0x1b8>
 3f0799c:	e59c7000 	ldr	r7, [r12]

	if (argc < 2) {
 3f079a0:	e3560001 	cmp	r6, #1	; 0x1
 3f079a4:	e5922000 	ldr	r2, [r2]
 3f079a8:	e1a04003 	mov	r4, r3
 3f079ac:	e50b2038 	str	r2, [r11, -#56]
 3f079b0:	e1a02000 	mov	r2, r0
 3f079b4:	ca000004 	bgt	3f079cc <do_mem_md+0x5c>
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f079b8:	e59f016c 	ldr	r0, [pc, #16c]	; 3f07b2c <do_mem_md+0x1bc>
 3f079bc:	e5921010 	ldr	r1, [r2, #16]
 3f079c0:	eb00139f 	bl	3f0c844 <printf>
		return 1;
 3f079c4:	e3a00001 	mov	r0, #1	; 0x1
 3f079c8:	ea000076 	b	3f07ba8 <do_mem_md+0x238>
	}

	if ((flag & CMD_FLAG_REPEAT) == 0) {
 3f079cc:	e3110001 	tst	r1, #1	; 0x1
 3f079d0:	1a000017 	bne	3f07a34 <do_mem_md+0xc4>
		/* New command specified.  Check for a size specification.
		 * Defaults to long if no or incorrect specification.
		 */
		if ((size = cmd_get_data_size(argv[0], 4)) < 0)
 3f079d4:	e5940000 	ldr	r0, [r4]
 3f079d8:	e3a01004 	mov	r1, #4	; 0x4
 3f079dc:	ebffffc3 	bl	3f078f0 <cmd_get_data_size>
 3f079e0:	e2507000 	subs	r7, r0, #0	; 0x0
 3f079e4:	aa000004 	bge	3f079fc <do_mem_md+0x8c>
			return 1;
 3f079e8:	e3a00001 	mov	r0, #1	; 0x1
 3f079ec:	ea00006d 	b	3f07ba8 <do_mem_md+0x238>

		/* Address is specified since argc > 1
		*/
		addr = simple_strtoul(argv[1], NULL, 16);
		addr += base_address;

		/* If another parameter, it is the length to display.
		 * Length is the number of objects, not number of bytes.
		 */
		if (argc > 2)
			length = simple_strtoul(argv[2], NULL, 16);
	}

	/* Print the lines.
	 *
	 * We buffer all read data, so we can make sure data is read only
	 * once, and all accesses are with the specified bus width.
	 */
	nbytes = length * size;
	do {
		char	linebuf[DISP_LINE_LEN];
		uint	*uip = (uint   *)linebuf;
		ushort	*usp = (ushort *)linebuf;
		u_char	*ucp = (u_char *)linebuf;

		printf("%08lx:", addr);
		linebytes = (nbytes>DISP_LINE_LEN)?DISP_LINE_LEN:nbytes;

#ifdef CONFIG_HAS_DATAFLASH
		if (read_dataflash(addr, (linebytes/size)*size, linebuf) != -1){

			for (i=0; i<linebytes; i+= size) {
				if (size == 4) {
					printf(" %08x", *uip++);
				} else if (size == 2) {
					printf(" %04x", *usp++);
				} else {
					printf(" %02x", *ucp++);
				}
				addr += size;
			}

		} else {	/* addr does not correspond to DataFlash */
#endif
		for (i=0; i<linebytes; i+= size) {
			if (size == 4) {
				printf(" %08x", (*uip++ = *((uint *)addr)));
			} else if (size == 2) {
				printf(" %04x", (*usp++ = *((ushort *)addr)));
			} else {
				printf(" %02x", (*ucp++ = *((u_char *)addr)));
			}
			addr += size;
		}
#ifdef CONFIG_HAS_DATAFLASH
		}
#endif
		printf("    ");
		cp = linebuf;
		for (i=0; i<linebytes; i++) {
			if ((*cp < 0x20) || (*cp > 0x7e))
				printf(".");
			else
				printf("%c", *cp);
			cp++;
		}
		printf("\n");
		nbytes -= linebytes;
		if (ctrlc()) {
			rc = 1;
 3f079f0:	e3a03001 	mov	r3, #1	; 0x1
 3f079f4:	e50b303c 	str	r3, [r11, -#60]
			break;
 3f079f8:	ea000062 	b	3f07b88 <do_mem_md+0x218>
 3f079fc:	e51b103c 	ldr	r1, [r11, -#60]
 3f07a00:	e5940004 	ldr	r0, [r4, #4]
 3f07a04:	e3a02010 	mov	r2, #16	; 0x10
 3f07a08:	eb001f4d 	bl	3f0f744 <simple_strtoul>
 3f07a0c:	e59f311c 	ldr	r3, [pc, #11c]	; 3f07b30 <do_mem_md+0x1c0>
 3f07a10:	e5933000 	ldr	r3, [r3]
 3f07a14:	e3560002 	cmp	r6, #2	; 0x2
 3f07a18:	e0805003 	add	r5, r0, r3
 3f07a1c:	da000004 	ble	3f07a34 <do_mem_md+0xc4>
 3f07a20:	e51b103c 	ldr	r1, [r11, -#60]
 3f07a24:	e5940008 	ldr	r0, [r4, #8]
 3f07a28:	e3a02010 	mov	r2, #16	; 0x10
 3f07a2c:	eb001f44 	bl	3f0f744 <simple_strtoul>
 3f07a30:	e50b0038 	str	r0, [r11, -#56]
 3f07a34:	e51b9038 	ldr	r9, [r11, -#56]
 3f07a38:	e0090997 	mul	r9, r7, r9
 3f07a3c:	e24b4034 	sub	r4, r11, #52	; 0x34
 3f07a40:	e50b4044 	str	r4, [r11, -#68]
 3f07a44:	e50b4040 	str	r4, [r11, -#64]
 3f07a48:	e1a01005 	mov	r1, r5
 3f07a4c:	e59f00e0 	ldr	r0, [pc, #e0]	; 3f07b34 <do_mem_md+0x1c4>
 3f07a50:	e3a06000 	mov	r6, #0	; 0x0
 3f07a54:	e50b4048 	str	r4, [r11, -#72]
 3f07a58:	eb001379 	bl	3f0c844 <printf>
 3f07a5c:	e3590010 	cmp	r9, #16	; 0x10
 3f07a60:	31a0a009 	movcc	r10, r9
 3f07a64:	23a0a010 	movcs	r10, #16	; 0x10
 3f07a68:	e156000a 	cmp	r6, r10
 3f07a6c:	2a00001f 	bcs	3f07af0 <do_mem_md+0x180>
 3f07a70:	e3570004 	cmp	r7, #4	; 0x4
 3f07a74:	1a000007 	bne	3f07a98 <do_mem_md+0x128>
 3f07a78:	e5953000 	ldr	r3, [r5]
 3f07a7c:	e51bc040 	ldr	r12, [r11, -#64]
 3f07a80:	e59f00b0 	ldr	r0, [pc, #b0]	; 3f07b38 <do_mem_md+0x1c8>
 3f07a84:	e48c3004 	str	r3, [r12], #4
 3f07a88:	e1a01003 	mov	r1, r3
 3f07a8c:	e50bc040 	str	r12, [r11, -#64]
 3f07a90:	eb00136b 	bl	3f0c844 <printf>
 3f07a94:	ea000011 	b	3f07ae0 <do_mem_md+0x170>
 3f07a98:	e3570002 	cmp	r7, #2	; 0x2
 3f07a9c:	1a000008 	bne	3f07ac4 <do_mem_md+0x154>
 3f07aa0:	e1d530b0 	ldrh	r3, [r5]
 3f07aa4:	e59f0090 	ldr	r0, [pc, #90]	; 3f07b3c <do_mem_md+0x1cc>
 3f07aa8:	e51b2044 	ldr	r2, [r11, -#68]
 3f07aac:	e1a01803 	mov	r1, r3, lsl #16
 3f07ab0:	e0c230b2 	strh	r3, [r2], #2
 3f07ab4:	e1a01821 	mov	r1, r1, lsr #16
 3f07ab8:	e50b2044 	str	r2, [r11, -#68]
 3f07abc:	eb001360 	bl	3f0c844 <printf>
 3f07ac0:	ea000006 	b	3f07ae0 <do_mem_md+0x170>
 3f07ac4:	e5d53000 	ldrb	r3, [r5]
 3f07ac8:	e51bc048 	ldr	r12, [r11, -#72]
 3f07acc:	e59f006c 	ldr	r0, [pc, #6c]	; 3f07b40 <do_mem_md+0x1d0>
 3f07ad0:	e4cc3001 	strb	r3, [r12], #1
 3f07ad4:	e20310ff 	and	r1, r3, #255	; 0xff
 3f07ad8:	e50bc048 	str	r12, [r11, -#72]
 3f07adc:	eb001358 	bl	3f0c844 <printf>
 3f07ae0:	e0855007 	add	r5, r5, r7
 3f07ae4:	e0866007 	add	r6, r6, r7
 3f07ae8:	e156000a 	cmp	r6, r10
 3f07aec:	3affffdf 	bcc	3f07a70 <do_mem_md+0x100>
 3f07af0:	e59f004c 	ldr	r0, [pc, #4c]	; 3f07b44 <do_mem_md+0x1d4>
 3f07af4:	e3a06000 	mov	r6, #0	; 0x0
 3f07af8:	eb001351 	bl	3f0c844 <printf>
 3f07afc:	e156000a 	cmp	r6, r10
 3f07b00:	2a000018 	bcs	3f07b68 <do_mem_md+0x1f8>
 3f07b04:	e5d43000 	ldrb	r3, [r4]
 3f07b08:	e2433020 	sub	r3, r3, #32	; 0x20
 3f07b0c:	e353005e 	cmp	r3, #94	; 0x5e
 3f07b10:	9a00000d 	bls	3f07b4c <do_mem_md+0x1dc>
 3f07b14:	e59f002c 	ldr	r0, [pc, #2c]	; 3f07b48 <do_mem_md+0x1d8>
 3f07b18:	eb001349 	bl	3f0c844 <printf>
 3f07b1c:	ea00000d 	b	3f07b58 <do_mem_md+0x1e8>
 3f07b20:	03f6ce50 	mvneqs	r12, #1280	; 0x500
 3f07b24:	03f20604 	mvneqs	r0, #4194304	; 0x400000
 3f07b28:	03f6ce54 	mvneqs	r12, #1344	; 0x540
 3f07b2c:	03f1d340 	mvneqs	r13, #1	; 0x1
 3f07b30:	03f20608 	mvneqs	r0, #8388608	; 0x800000
 3f07b34:	03f1d34c 	mvneqs	r13, #805306369	; 0x30000001
 3f07b38:	03f1d354 	mvneqs	r13, #1342177281	; 0x50000001
 3f07b3c:	03f1d35c 	mvneqs	r13, #1879048193	; 0x70000001
 3f07b40:	03f1d364 	mvneqs	r13, #-1879048191	; 0x90000001
 3f07b44:	03f1d36c 	mvneqs	r13, #-1342177279	; 0xb0000001
 3f07b48:	03f1d374 	mvneqs	r13, #-805306367	; 0xd0000001
 3f07b4c:	e59f0058 	ldr	r0, [pc, #58]	; 3f07bac <do_mem_md+0x23c>
 3f07b50:	e5d41000 	ldrb	r1, [r4]
 3f07b54:	eb00133a 	bl	3f0c844 <printf>
 3f07b58:	e2844001 	add	r4, r4, #1	; 0x1
 3f07b5c:	e2866001 	add	r6, r6, #1	; 0x1
 3f07b60:	e156000a 	cmp	r6, r10
 3f07b64:	3affffe6 	bcc	3f07b04 <do_mem_md+0x194>
 3f07b68:	e59f0040 	ldr	r0, [pc, #40]	; 3f07bb0 <do_mem_md+0x240>
 3f07b6c:	e06a9009 	rsb	r9, r10, r9
 3f07b70:	eb001333 	bl	3f0c844 <printf>
 3f07b74:	eb00134c 	bl	3f0c8ac <ctrlc>
 3f07b78:	e3500000 	cmp	r0, #0	; 0x0
 3f07b7c:	1affff9b 	bne	3f079f0 <do_mem_md+0x80>
		}
	} while (nbytes > 0);
 3f07b80:	e3590000 	cmp	r9, #0	; 0x0
 3f07b84:	1affffac 	bne	3f07a3c <do_mem_md+0xcc>

	dp_last_addr = addr;
 3f07b88:	e59f2024 	ldr	r2, [pc, #24]	; 3f07bb4 <do_mem_md+0x244>
	dp_last_length = length;
 3f07b8c:	e59f3024 	ldr	r3, [pc, #24]	; 3f07bb8 <do_mem_md+0x248>
 3f07b90:	e5825000 	str	r5, [r2]
 3f07b94:	e51bc038 	ldr	r12, [r11, -#56]
	dp_last_size = size;
 3f07b98:	e59f201c 	ldr	r2, [pc, #1c]	; 3f07bbc <do_mem_md+0x24c>
 3f07b9c:	e583c000 	str	r12, [r3]
	return (rc);
 3f07ba0:	e51b003c 	ldr	r0, [r11, -#60]
 3f07ba4:	e5827000 	str	r7, [r2]
 3f07ba8:	ea000004 	b	3f07bc0 <do_mem_md+0x250>
 3f07bac:	03f1d378 	mvneqs	r13, #-536870911	; 0xe0000001
 3f07bb0:	03f1d37c 	mvneqs	r13, #-268435455	; 0xf0000001
 3f07bb4:	03f6ce50 	mvneqs	r12, #1280	; 0x500
 3f07bb8:	03f20604 	mvneqs	r0, #4194304	; 0x400000
 3f07bbc:	03f6ce54 	mvneqs	r12, #1344	; 0x540
}
 3f07bc0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f07bc4 <do_mem_mm>:
 3f07bc4:	e1a0c00d 	mov	r12, r13
 3f07bc8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f07bcc:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_mem_mm ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f07bd0:	e1a0c001 	mov	r12, r1
	return mod_mem (cmdtp, 1, flag, argc, argv);
 3f07bd4:	e3a01001 	mov	r1, #1	; 0x1
 3f07bd8:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f07bdc:	e58d3000 	str	r3, [r13]
 3f07be0:	e1a03002 	mov	r3, r2
 3f07be4:	e1a0200c 	mov	r2, r12
 3f07be8:	eb0001e7 	bl	3f0838c <mod_mem>
 3f07bec:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f07bf0 <do_mem_nm>:
 3f07bf0:	e1a0c00d 	mov	r12, r13
 3f07bf4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f07bf8:	e24cb004 	sub	r11, r12, #4	; 0x4
}
int do_mem_nm ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f07bfc:	e1a0c001 	mov	r12, r1
	return mod_mem (cmdtp, 0, flag, argc, argv);
 3f07c00:	e3a01000 	mov	r1, #0	; 0x0
 3f07c04:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f07c08:	e58d3000 	str	r3, [r13]
 3f07c0c:	e1a03002 	mov	r3, r2
 3f07c10:	e1a0200c 	mov	r2, r12
 3f07c14:	eb0001dc 	bl	3f0838c <mod_mem>
 3f07c18:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f07c1c <do_mem_mw>:
 3f07c1c:	e1a0c00d 	mov	r12, r13
 3f07c20:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f07c24:	e24cb004 	sub	r11, r12, #4	; 0x4
}

int do_mem_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f07c28:	e1a06002 	mov	r6, r2
	ulong	addr, writeval, count;
	int	size;

	if ((argc < 3) || (argc > 4)) {
 3f07c2c:	e2462003 	sub	r2, r6, #3	; 0x3
 3f07c30:	e3520001 	cmp	r2, #1	; 0x1
 3f07c34:	e1a02000 	mov	r2, r0
 3f07c38:	e1a04003 	mov	r4, r3
 3f07c3c:	9a000004 	bls	3f07c54 <do_mem_mw+0x38>
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f07c40:	e59f00ac 	ldr	r0, [pc, #ac]	; 3f07cf4 <do_mem_mw+0xd8>
 3f07c44:	e5921010 	ldr	r1, [r2, #16]
 3f07c48:	eb0012fd 	bl	3f0c844 <printf>
		return 1;
 3f07c4c:	e3a00001 	mov	r0, #1	; 0x1
 3f07c50:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	}

	/* Check for size specification.
	*/
	if ((size = cmd_get_data_size(argv[0], 4)) < 1)
 3f07c54:	e5940000 	ldr	r0, [r4]
 3f07c58:	e3a01004 	mov	r1, #4	; 0x4
 3f07c5c:	ebffff23 	bl	3f078f0 <cmd_get_data_size>
 3f07c60:	e2507000 	subs	r7, r0, #0	; 0x0
		return 1;
 3f07c64:	d3a00001 	movle	r0, #1	; 0x1
 3f07c68:	d91ba8f0 	ldmledb	r11, {r4, r5, r6, r7, r11, r13, r15}

	/* Address is specified since argc > 1
	*/
	addr = simple_strtoul(argv[1], NULL, 16);
 3f07c6c:	e3a01000 	mov	r1, #0	; 0x0
 3f07c70:	e5940004 	ldr	r0, [r4, #4]
 3f07c74:	e3a02010 	mov	r2, #16	; 0x10
 3f07c78:	eb001eb1 	bl	3f0f744 <simple_strtoul>
	addr += base_address;
 3f07c7c:	e59f3074 	ldr	r3, [pc, #74]	; 3f07cf8 <do_mem_mw+0xdc>
 3f07c80:	e5933000 	ldr	r3, [r3]

	/* Get the value to write.
	*/
	writeval = simple_strtoul(argv[2], NULL, 16);
 3f07c84:	e3a01000 	mov	r1, #0	; 0x0
 3f07c88:	e0805003 	add	r5, r0, r3
 3f07c8c:	e5940008 	ldr	r0, [r4, #8]
 3f07c90:	e3a02010 	mov	r2, #16	; 0x10
 3f07c94:	eb001eaa 	bl	3f0f744 <simple_strtoul>

	/* Count ? */
	if (argc == 4) {
 3f07c98:	e3560004 	cmp	r6, #4	; 0x4
 3f07c9c:	e1a06000 	mov	r6, r0
 3f07ca0:	1a000004 	bne	3f07cb8 <do_mem_mw+0x9c>
		count = simple_strtoul(argv[3], NULL, 16);
 3f07ca4:	e3a01000 	mov	r1, #0	; 0x0
 3f07ca8:	e594000c 	ldr	r0, [r4, #12]
 3f07cac:	e3a02010 	mov	r2, #16	; 0x10
 3f07cb0:	eb001ea3 	bl	3f0f744 <simple_strtoul>
	} else {
 3f07cb4:	ea000008 	b	3f07cdc <do_mem_mw+0xc0>
		count = 1;
 3f07cb8:	e3a00001 	mov	r0, #1	; 0x1
	}

	while (count-- > 0) {
 3f07cbc:	ea000006 	b	3f07cdc <do_mem_mw+0xc0>
		if (size == 4)
 3f07cc0:	e3570004 	cmp	r7, #4	; 0x4
			*((ulong  *)addr) = (ulong )writeval;
 3f07cc4:	05856000 	streq	r6, [r5]
 3f07cc8:	0a000002 	beq	3f07cd8 <do_mem_mw+0xbc>
		else if (size == 2)
 3f07ccc:	e3570002 	cmp	r7, #2	; 0x2
			*((ushort *)addr) = (ushort)writeval;
 3f07cd0:	01c560b0 	streqh	r6, [r5]
		else
			*((u_char *)addr) = (u_char)writeval;
 3f07cd4:	15c56000 	strneb	r6, [r5]
		addr += size;
 3f07cd8:	e0855007 	add	r5, r5, r7
	}
 3f07cdc:	e1a03000 	mov	r3, r0
 3f07ce0:	e2400001 	sub	r0, r0, #1	; 0x1
 3f07ce4:	e3530000 	cmp	r3, #0	; 0x0
 3f07ce8:	1afffff4 	bne	3f07cc0 <do_mem_mw+0xa4>
	return 0;
 3f07cec:	e3a00000 	mov	r0, #0	; 0x0
}
 3f07cf0:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f07cf4:	03f1d340 	mvneqs	r13, #1	; 0x1
 3f07cf8:	03f20608 	mvneqs	r0, #8388608	; 0x800000

03f07cfc <do_mem_cmp>:
 3f07cfc:	e1a0c00d 	mov	r12, r13
 3f07d00:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f07d04:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_mem_cmp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	ulong	addr1, addr2, count, ngood;
	int	size;
	int     rcode = 0;
 3f07d08:	e3a0a000 	mov	r10, #0	; 0x0
 3f07d0c:	e1a01002 	mov	r1, r2

	if (argc != 4) {
 3f07d10:	e3510004 	cmp	r1, #4	; 0x4
 3f07d14:	e1a02000 	mov	r2, r0
 3f07d18:	e1a06003 	mov	r6, r3
 3f07d1c:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f07d20:	0a000004 	beq	3f07d38 <do_mem_cmp+0x3c>
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f07d24:	e59f012c 	ldr	r0, [pc, #12c]	; 3f07e58 <do_mem_cmp+0x15c>
 3f07d28:	e5921010 	ldr	r1, [r2, #16]
 3f07d2c:	eb0012c4 	bl	3f0c844 <printf>
		return 1;
 3f07d30:	e3a00001 	mov	r0, #1	; 0x1
 3f07d34:	ea000057 	b	3f07e98 <do_mem_cmp+0x19c>
	}

	/* Check for size specification.
	*/
	if ((size = cmd_get_data_size(argv[0], 4)) < 0)
 3f07d38:	e5960000 	ldr	r0, [r6]
 3f07d3c:	ebfffeeb 	bl	3f078f0 <cmd_get_data_size>
 3f07d40:	e2507000 	subs	r7, r0, #0	; 0x0
 3f07d44:	aa000005 	bge	3f07d60 <do_mem_cmp+0x64>
		return 1;
 3f07d48:	e3a00001 	mov	r0, #1	; 0x1
 3f07d4c:	ea000051 	b	3f07e98 <do_mem_cmp+0x19c>

	addr1 = simple_strtoul(argv[1], NULL, 16);
	addr1 += base_address;

	addr2 = simple_strtoul(argv[2], NULL, 16);
	addr2 += base_address;

	count = simple_strtoul(argv[3], NULL, 16);

#ifdef CONFIG_HAS_DATAFLASH
	if (addr_dataflash(addr1) | addr_dataflash(addr2)){
		printf("Comparison with DataFlash space not supported.\n\r");
		return 0;
	}
#endif

	ngood = 0;

	while (count-- > 0) {
		if (size == 4) {
			ulong word1 = *(ulong *)addr1;
			ulong word2 = *(ulong *)addr2;
			if (word1 != word2) {
				printf("word at 0x%08lx (0x%08lx) "
					"!= word at 0x%08lx (0x%08lx)\n",
					addr1, word1, addr2, word2);
				rcode = 1;
				break;
			}
		}
		else if (size == 2) {
			ushort hword1 = *(ushort *)addr1;
			ushort hword2 = *(ushort *)addr2;
			if (hword1 != hword2) {
				printf("halfword at 0x%08lx (0x%04x) "
					"!= halfword at 0x%08lx (0x%04x)\n",
					addr1, hword1, addr2, hword2);
				rcode = 1;
				break;
			}
		}
		else {
			u_char byte1 = *(u_char *)addr1;
			u_char byte2 = *(u_char *)addr2;
			if (byte1 != byte2) {
				printf("byte at 0x%08lx (0x%02x) "
 3f07d50:	e1a01005 	mov	r1, r5
 3f07d54:	e1a03004 	mov	r3, r4
 3f07d58:	e59f00fc 	ldr	r0, [pc, #fc]	; 3f07e5c <do_mem_cmp+0x160>
					"!= byte at 0x%08lx (0x%02x)\n",
					addr1, byte1, addr2, byte2);
				rcode = 1;
				break;
 3f07d5c:	ea00001b 	b	3f07dd0 <do_mem_cmp+0xd4>
 3f07d60:	e1a0100a 	mov	r1, r10
 3f07d64:	e3a02010 	mov	r2, #16	; 0x10
 3f07d68:	e5960004 	ldr	r0, [r6, #4]
 3f07d6c:	e1a0900a 	mov	r9, r10
 3f07d70:	e59f40e8 	ldr	r4, [pc, #e8]	; 3f07e60 <do_mem_cmp+0x164>
 3f07d74:	eb001e72 	bl	3f0f744 <simple_strtoul>
 3f07d78:	e5943000 	ldr	r3, [r4]
 3f07d7c:	e1a0100a 	mov	r1, r10
 3f07d80:	e0805003 	add	r5, r0, r3
 3f07d84:	e5960008 	ldr	r0, [r6, #8]
 3f07d88:	e3a02010 	mov	r2, #16	; 0x10
 3f07d8c:	eb001e6c 	bl	3f0f744 <simple_strtoul>
 3f07d90:	e5943000 	ldr	r3, [r4]
 3f07d94:	e1a0100a 	mov	r1, r10
 3f07d98:	e0804003 	add	r4, r0, r3
 3f07d9c:	e596000c 	ldr	r0, [r6, #12]
 3f07da0:	e3a02010 	mov	r2, #16	; 0x10
 3f07da4:	eb001e66 	bl	3f0f744 <simple_strtoul>
 3f07da8:	ea000013 	b	3f07dfc <do_mem_cmp+0x100>
 3f07dac:	e3570002 	cmp	r7, #2	; 0x2
 3f07db0:	1a00000a 	bne	3f07de0 <do_mem_cmp+0xe4>
 3f07db4:	e1d520b0 	ldrh	r2, [r5]
 3f07db8:	e1d4c0b0 	ldrh	r12, [r4]
 3f07dbc:	e152000c 	cmp	r2, r12
 3f07dc0:	0a00000a 	beq	3f07df0 <do_mem_cmp+0xf4>
 3f07dc4:	e1a01005 	mov	r1, r5
 3f07dc8:	e1a03004 	mov	r3, r4
 3f07dcc:	e59f0090 	ldr	r0, [pc, #90]	; 3f07e64 <do_mem_cmp+0x168>
 3f07dd0:	e3a0a001 	mov	r10, #1	; 0x1
 3f07dd4:	e58dc000 	str	r12, [r13]
 3f07dd8:	eb001299 	bl	3f0c844 <printf>
 3f07ddc:	ea000016 	b	3f07e3c <do_mem_cmp+0x140>
 3f07de0:	e5d52000 	ldrb	r2, [r5]
 3f07de4:	e5d4c000 	ldrb	r12, [r4]
 3f07de8:	e152000c 	cmp	r2, r12
 3f07dec:	1affffd7 	bne	3f07d50 <do_mem_cmp+0x54>
			}
		}
		ngood++;
 3f07df0:	e2899001 	add	r9, r9, #1	; 0x1
		addr1 += size;
 3f07df4:	e0855007 	add	r5, r5, r7
		addr2 += size;
 3f07df8:	e0844007 	add	r4, r4, r7
	}
 3f07dfc:	e1a03000 	mov	r3, r0
 3f07e00:	e2400001 	sub	r0, r0, #1	; 0x1
 3f07e04:	e3530000 	cmp	r3, #0	; 0x0
 3f07e08:	0a00000b 	beq	3f07e3c <do_mem_cmp+0x140>
 3f07e0c:	e3570004 	cmp	r7, #4	; 0x4
 3f07e10:	1affffe5 	bne	3f07dac <do_mem_cmp+0xb0>
 3f07e14:	e5952000 	ldr	r2, [r5]
 3f07e18:	e594c000 	ldr	r12, [r4]
 3f07e1c:	e152000c 	cmp	r2, r12
 3f07e20:	0afffff2 	beq	3f07df0 <do_mem_cmp+0xf4>
 3f07e24:	e1a01005 	mov	r1, r5
 3f07e28:	e1a03004 	mov	r3, r4
 3f07e2c:	e59f0034 	ldr	r0, [pc, #34]	; 3f07e68 <do_mem_cmp+0x16c>
 3f07e30:	e3a0a001 	mov	r10, #1	; 0x1
 3f07e34:	e58dc000 	str	r12, [r13]
 3f07e38:	eb001281 	bl	3f0c844 <printf>

	printf("Total of %ld %s%s were the same\n",
 3f07e3c:	e3570004 	cmp	r7, #4	; 0x4
 3f07e40:	0a00000b 	beq	3f07e74 <do_mem_cmp+0x178>
 3f07e44:	e59f2020 	ldr	r2, [pc, #20]	; 3f07e6c <do_mem_cmp+0x170>
 3f07e48:	e59f3020 	ldr	r3, [pc, #20]	; 3f07e70 <do_mem_cmp+0x174>
 3f07e4c:	e3570002 	cmp	r7, #2	; 0x2
 3f07e50:	01a02003 	moveq	r2, r3
 3f07e54:	ea000007 	b	3f07e78 <do_mem_cmp+0x17c>
 3f07e58:	03f1d340 	mvneqs	r13, #1	; 0x1
 3f07e5c:	03f1d3f8 	mvneqs	r13, #-536870909	; 0xe0000003
 3f07e60:	03f20608 	mvneqs	r0, #8388608	; 0x800000
 3f07e64:	03f1d3b8 	mvneqs	r13, #-536870910	; 0xe0000002
 3f07e68:	03f1d380 	mvneqs	r13, #2	; 0x2
 3f07e6c:	03f1d460 	mvneqs	r13, #1610612736	; 0x60000000
 3f07e70:	03f1d454 	mvneqs	r13, #1409286144	; 0x54000000
 3f07e74:	e59f2020 	ldr	r2, [pc, #20]	; 3f07e9c <do_mem_cmp+0x1a0>
 3f07e78:	e59fc020 	ldr	r12, [pc, #20]	; 3f07ea0 <do_mem_cmp+0x1a4>
 3f07e7c:	e1a01009 	mov	r1, r9
 3f07e80:	e59f301c 	ldr	r3, [pc, #1c]	; 3f07ea4 <do_mem_cmp+0x1a8>
 3f07e84:	e3510001 	cmp	r1, #1	; 0x1
 3f07e88:	e59f0018 	ldr	r0, [pc, #18]	; 3f07ea8 <do_mem_cmp+0x1ac>
 3f07e8c:	11a0300c 	movne	r3, r12
 3f07e90:	eb00126b 	bl	3f0c844 <printf>
		ngood, size == 4 ? "word" : size == 2 ? "halfword" : "byte",
		ngood == 1 ? "" : "s");
	return rcode;
 3f07e94:	e1a0000a 	mov	r0, r10
 3f07e98:	ea000003 	b	3f07eac <do_mem_cmp+0x1b0>
 3f07e9c:	03f1d468 	mvneqs	r13, #1744830464	; 0x68000000
 3f07ea0:	03f1d474 	mvneqs	r13, #1946157056	; 0x74000000
 3f07ea4:	03f1d470 	mvneqs	r13, #1879048192	; 0x70000000
 3f07ea8:	03f1d430 	mvneqs	r13, #805306368	; 0x30000000
}
 3f07eac:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f07eb0 <do_mem_cp>:
 3f07eb0:	e1a0c00d 	mov	r12, r13
 3f07eb4:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f07eb8:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f07ebc:	e1a01002 	mov	r1, r2
	ulong	addr, dest, count;
	int	size;

	if (argc != 4) {
 3f07ec0:	e3510004 	cmp	r1, #4	; 0x4
 3f07ec4:	e1a02000 	mov	r2, r0
 3f07ec8:	e1a07003 	mov	r7, r3
 3f07ecc:	0a000004 	beq	3f07ee4 <do_mem_cp+0x34>
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f07ed0:	e59f01d4 	ldr	r0, [pc, #1d4]	; 3f080ac <do_mem_cp+0x1fc>
 3f07ed4:	e5921010 	ldr	r1, [r2, #16]
 3f07ed8:	eb001259 	bl	3f0c844 <printf>
		return 1;
 3f07edc:	e3a00001 	mov	r0, #1	; 0x1
 3f07ee0:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
	}

	/* Check for size specification.
	*/
	if ((size = cmd_get_data_size(argv[0], 4)) < 0)
 3f07ee4:	e5970000 	ldr	r0, [r7]
 3f07ee8:	ebfffe80 	bl	3f078f0 <cmd_get_data_size>
 3f07eec:	e250a000 	subs	r10, r0, #0	; 0x0
		return 1;
 3f07ef0:	b3a00001 	movlt	r0, #1	; 0x1
 3f07ef4:	b91bacf0 	ldmltdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

	addr = simple_strtoul(argv[1], NULL, 16);
 3f07ef8:	e3a01000 	mov	r1, #0	; 0x0
 3f07efc:	e5970004 	ldr	r0, [r7, #4]
 3f07f00:	e3a02010 	mov	r2, #16	; 0x10
	addr += base_address;
 3f07f04:	e59f41a4 	ldr	r4, [pc, #1a4]	; 3f080b0 <do_mem_cp+0x200>
 3f07f08:	eb001e0d 	bl	3f0f744 <simple_strtoul>
 3f07f0c:	e5943000 	ldr	r3, [r4]

	dest = simple_strtoul(argv[2], NULL, 16);
 3f07f10:	e3a01000 	mov	r1, #0	; 0x0
 3f07f14:	e0806003 	add	r6, r0, r3
 3f07f18:	e5970008 	ldr	r0, [r7, #8]
 3f07f1c:	e3a02010 	mov	r2, #16	; 0x10
 3f07f20:	eb001e07 	bl	3f0f744 <simple_strtoul>
	dest += base_address;
 3f07f24:	e5943000 	ldr	r3, [r4]

	count = simple_strtoul(argv[3], NULL, 16);
 3f07f28:	e3a01000 	mov	r1, #0	; 0x0
 3f07f2c:	e0805003 	add	r5, r0, r3
 3f07f30:	e597000c 	ldr	r0, [r7, #12]
 3f07f34:	e3a02010 	mov	r2, #16	; 0x10
 3f07f38:	eb001e01 	bl	3f0f744 <simple_strtoul>

	if (count == 0) {
 3f07f3c:	e2504000 	subs	r4, r0, #0	; 0x0
 3f07f40:	1a000003 	bne	3f07f54 <do_mem_cp+0xa4>
		puts ("Zero length ???\n");
 3f07f44:	e59f0168 	ldr	r0, [pc, #168]	; 3f080b4 <do_mem_cp+0x204>
 3f07f48:	eb001230 	bl	3f0c810 <puts>
		return 1;
 3f07f4c:	e3a00001 	mov	r0, #1	; 0x1
 3f07f50:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
	}

#ifndef CFG_NO_FLASH
	/* check if we are copying to Flash */
	if ( (addr2info(dest) != NULL)
 3f07f54:	e1a00005 	mov	r0, r5
 3f07f58:	eb0018b8 	bl	3f0e240 <addr2info>
 3f07f5c:	e3500000 	cmp	r0, #0	; 0x0
 3f07f60:	0a00000f 	beq	3f07fa4 <do_mem_cp+0xf4>
#ifdef CONFIG_HAS_DATAFLASH
	   && (!addr_dataflash(addr))
#endif
	   ) {
		int rc;

		printf ("Copy to Flash... ");
 3f07f64:	e59f014c 	ldr	r0, [pc, #14c]	; 3f080b8 <do_mem_cp+0x208>
 3f07f68:	eb001235 	bl	3f0c844 <printf>

		rc = flash_write ((uchar *)addr, dest, count*size);
 3f07f6c:	e002049a 	mul	r2, r10, r4
 3f07f70:	e1a00006 	mov	r0, r6
 3f07f74:	e1a01005 	mov	r1, r5
 3f07f78:	eb0018b5 	bl	3f0e254 <flash_write>
		if (rc != 0) {
 3f07f7c:	e2504000 	subs	r4, r0, #0	; 0x0
 3f07f80:	0a000003 	beq	3f07f94 <do_mem_cp+0xe4>
			flash_perror (rc);
 3f07f84:	e1a00004 	mov	r0, r4
 3f07f88:	eb001917 	bl	3f0e3ec <flash_perror>
			return (1);
 3f07f8c:	e3a00001 	mov	r0, #1	; 0x1
 3f07f90:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
		}
		puts ("done\n");
 3f07f94:	e59f0120 	ldr	r0, [pc, #120]	; 3f080bc <do_mem_cp+0x20c>
 3f07f98:	eb00121c 	bl	3f0c810 <puts>
		return 0;
 3f07f9c:	e1a00004 	mov	r0, r4
 3f07fa0:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
	}
#endif

#if (CONFIG_COMMANDS & CFG_CMD_MMC)
	if (mmc2info(dest)) {
 3f07fa4:	e1a00005 	mov	r0, r5
 3f07fa8:	eb0031c4 	bl	3f146c0 <mmc2info>
 3f07fac:	e3500000 	cmp	r0, #0	; 0x0
 3f07fb0:	0a000016 	beq	3f08010 <do_mem_cp+0x160>
		int rc;

		printf ("Copy to MMC... ");
 3f07fb4:	e59f0104 	ldr	r0, [pc, #104]	; 3f080c0 <do_mem_cp+0x210>
 3f07fb8:	eb001221 	bl	3f0c844 <printf>
		switch (rc = mmc_write ((uchar *)addr, dest, count*size)) {
 3f07fbc:	e002049a 	mul	r2, r10, r4
 3f07fc0:	e1a00006 	mov	r0, r6
 3f07fc4:	e1a01005 	mov	r1, r5
 3f07fc8:	eb0031a6 	bl	3f14668 <mmc_write>
 3f07fcc:	e1a03000 	mov	r3, r0
 3f07fd0:	e3730001 	cmn	r3, #1	; 0x1
 3f07fd4:	0a000005 	beq	3f07ff0 <do_mem_cp+0x140>
 3f07fd8:	e3530000 	cmp	r3, #0	; 0x0
 3f07fdc:	1a000005 	bne	3f07ff8 <do_mem_cp+0x148>
		case 0:
			printf ("\n");
 3f07fe0:	e59f00dc 	ldr	r0, [pc, #dc]	; 3f080c4 <do_mem_cp+0x214>
 3f07fe4:	eb001216 	bl	3f0c844 <printf>
			return 1;
 3f07fe8:	e3a00001 	mov	r0, #1	; 0x1
 3f07fec:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
		case -1:
			printf("failed\n");
 3f07ff0:	e59f00d0 	ldr	r0, [pc, #d0]	; 3f080c8 <do_mem_cp+0x218>
			return 1;
 3f07ff4:	eafffffa 	b	3f07fe4 <do_mem_cp+0x134>
		default:
			printf ("%s[%d] FIXME: rc=%d\n",__FILE__,__LINE__,rc);
 3f07ff8:	e59f00cc 	ldr	r0, [pc, #cc]	; 3f080cc <do_mem_cp+0x21c>
 3f07ffc:	e59f10cc 	ldr	r1, [pc, #cc]	; 3f080d0 <do_mem_cp+0x220>
 3f08000:	e59f20cc 	ldr	r2, [pc, #cc]	; 3f080d4 <do_mem_cp+0x224>
 3f08004:	eb00120e 	bl	3f0c844 <printf>
			return 1;
 3f08008:	e3a00001 	mov	r0, #1	; 0x1
 3f0800c:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
		}
		puts ("done\n");
		return 0;
	}

	if (mmc2info(addr)) {
 3f08010:	e1a00006 	mov	r0, r6
 3f08014:	eb0031a9 	bl	3f146c0 <mmc2info>
 3f08018:	e3500000 	cmp	r0, #0	; 0x0
 3f0801c:	0a000011 	beq	3f08068 <do_mem_cp+0x1b8>
		int rc;

		printf ("Copy from MMC... ");
 3f08020:	e59f00b0 	ldr	r0, [pc, #b0]	; 3f080d8 <do_mem_cp+0x228>
 3f08024:	eb001206 	bl	3f0c844 <printf>
		switch (rc = mmc_read (addr, (uchar *)dest, count*size)) {
 3f08028:	e002049a 	mul	r2, r10, r4
 3f0802c:	e1a00006 	mov	r0, r6
 3f08030:	e1a01005 	mov	r1, r5
 3f08034:	eb003193 	bl	3f14688 <mmc_read>
 3f08038:	e1a03000 	mov	r3, r0
 3f0803c:	e3730001 	cmn	r3, #1	; 0x1
 3f08040:	0a000002 	beq	3f08050 <do_mem_cp+0x1a0>
 3f08044:	e3530000 	cmp	r3, #0	; 0x0
 3f08048:	1a000002 	bne	3f08058 <do_mem_cp+0x1a8>
		case 0:
			printf ("\n");
			return 1;
 3f0804c:	eaffffe3 	b	3f07fe0 <do_mem_cp+0x130>
		case -1:
			printf("failed\n");
 3f08050:	e59f0070 	ldr	r0, [pc, #70]	; 3f080c8 <do_mem_cp+0x218>
			return 1;
 3f08054:	eaffffe2 	b	3f07fe4 <do_mem_cp+0x134>
		default:
			printf ("%s[%d] FIXME: rc=%d\n",__FILE__,__LINE__,rc);
 3f08058:	e59f006c 	ldr	r0, [pc, #6c]	; 3f080cc <do_mem_cp+0x21c>
 3f0805c:	e59f106c 	ldr	r1, [pc, #6c]	; 3f080d0 <do_mem_cp+0x220>
 3f08060:	e59f2074 	ldr	r2, [pc, #74]	; 3f080dc <do_mem_cp+0x22c>
			return 1;
 3f08064:	eaffffe6 	b	3f08004 <do_mem_cp+0x154>
		}
		puts ("done\n");
		return 0;
	}
#endif

#ifdef CONFIG_HAS_DATAFLASH
	/* Check if we are copying from RAM or Flash to DataFlash */
	if (addr_dataflash(dest) && !addr_dataflash(addr)){
		int rc;

		printf ("Copy to DataFlash... ");

		rc = write_dataflash (dest, addr, count*size);

		if (rc != 1) {
			dataflash_perror (rc);
			return (1);
		}
		puts ("done\n");
		return 0;
	}

	/* Check if we are copying from DataFlash to RAM */
	if (addr_dataflash(addr) && !addr_dataflash(dest) && (addr2info(dest)==NULL) ){
		read_dataflash(addr, count * size, (char *) dest);
		return 0;
	}

	if (addr_dataflash(addr) && addr_dataflash(dest)){
		printf("Unsupported combination of source/destination.\n\r");
		return 1;
	}
#endif

	while (count-- > 0) {
 3f08068:	e2444001 	sub	r4, r4, #1	; 0x1
		if (size == 4)
 3f0806c:	e35a0004 	cmp	r10, #4	; 0x4
			*((ulong  *)dest) = *((ulong  *)addr);
 3f08070:	05963000 	ldreq	r3, [r6]
 3f08074:	05853000 	streq	r3, [r5]
 3f08078:	0a000004 	beq	3f08090 <do_mem_cp+0x1e0>
		else if (size == 2)
 3f0807c:	e35a0002 	cmp	r10, #2	; 0x2
			*((ushort *)dest) = *((ushort *)addr);
 3f08080:	01d630b0 	ldreqh	r3, [r6]
 3f08084:	01c530b0 	streqh	r3, [r5]
		else
			*((u_char *)dest) = *((u_char *)addr);
 3f08088:	15d63000 	ldrneb	r3, [r6]
 3f0808c:	15c53000 	strneb	r3, [r5]
		addr += size;
 3f08090:	e086600a 	add	r6, r6, r10
		dest += size;
 3f08094:	e085500a 	add	r5, r5, r10
	}
 3f08098:	e1a00004 	mov	r0, r4
 3f0809c:	e2444001 	sub	r4, r4, #1	; 0x1
 3f080a0:	e3500000 	cmp	r0, #0	; 0x0
 3f080a4:	1afffff0 	bne	3f0806c <do_mem_cp+0x1bc>
	return 0;
}
 3f080a8:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f080ac:	03f1d340 	mvneqs	r13, #1	; 0x1
 3f080b0:	03f20608 	mvneqs	r0, #8388608	; 0x800000
 3f080b4:	03f1d478 	mvneqs	r13, #2013265920	; 0x78000000
 3f080b8:	03f1d48c 	mvneqs	r13, #-1946157056	; 0x8c000000
 3f080bc:	03f1d4a0 	mvneqs	r13, #-1610612736	; 0xa0000000
 3f080c0:	03f1d4a8 	mvneqs	r13, #-1476395008	; 0xa8000000
 3f080c4:	03f1d37c 	mvneqs	r13, #-268435455	; 0xf0000001
 3f080c8:	03f1d4b8 	mvneqs	r13, #-1207959552	; 0xb8000000
 3f080cc:	03f1d4c0 	mvneqs	r13, #-1073741824	; 0xc0000000
 3f080d0:	03f1d4d8 	mvneqs	r13, #-671088640	; 0xd8000000
 3f080d4:	00000183 	andeq	r0, r0, r3, lsl #3
 3f080d8:	03f1d4e4 	mvneqs	r13, #-469762048	; 0xe4000000
 3f080dc:	00000196 	muleq	r0, r6, r1

03f080e0 <do_mem_base>:
 3f080e0:	e1a0c00d 	mov	r12, r13
 3f080e4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f080e8:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_mem_base (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	if (argc > 1) {
 3f080ec:	e3520001 	cmp	r2, #1	; 0x1
 3f080f0:	da000005 	ble	3f0810c <do_mem_base+0x2c>
		/* Set new base address.
		*/
		base_address = simple_strtoul(argv[1], NULL, 16);
 3f080f4:	e3a01000 	mov	r1, #0	; 0x0
 3f080f8:	e5930004 	ldr	r0, [r3, #4]
 3f080fc:	e3a02010 	mov	r2, #16	; 0x10
 3f08100:	eb001d8f 	bl	3f0f744 <simple_strtoul>
 3f08104:	e59f3018 	ldr	r3, [pc, #18]	; 3f08124 <do_mem_base+0x44>
 3f08108:	e5830000 	str	r0, [r3]
	}
	/* Print the current base address.
	*/
	printf("Base Address: 0x%08lx\n", base_address);
 3f0810c:	e59f3010 	ldr	r3, [pc, #10]	; 3f08124 <do_mem_base+0x44>
 3f08110:	e59f0010 	ldr	r0, [pc, #10]	; 3f08128 <do_mem_base+0x48>
 3f08114:	e5931000 	ldr	r1, [r3]
 3f08118:	eb0011c9 	bl	3f0c844 <printf>
	return 0;
 3f0811c:	e3a00000 	mov	r0, #0	; 0x0
 3f08120:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f08124:	03f20608 	mvneqs	r0, #8388608	; 0x800000
 3f08128:	03f1d4f8 	mvneqs	r13, #-134217728	; 0xf8000000

03f0812c <do_mem_loop>:
 3f0812c:	e1a0c00d 	mov	r12, r13
 3f08130:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f08134:	e24cb004 	sub	r11, r12, #4	; 0x4
}

int do_mem_loop (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	ulong	addr, length, i, junk;
	int	size;
	volatile uint	*longp;
	volatile ushort *shortp;
	volatile u_char	*cp;

	if (argc < 3) {
 3f08138:	e3520002 	cmp	r2, #2	; 0x2
 3f0813c:	e1a02000 	mov	r2, r0
 3f08140:	e1a04003 	mov	r4, r3
 3f08144:	ca000004 	bgt	3f0815c <do_mem_loop+0x30>
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f08148:	e59f0100 	ldr	r0, [pc, #100]	; 3f08250 <do_mem_loop+0x124>
 3f0814c:	e5921010 	ldr	r1, [r2, #16]
 3f08150:	eb0011bb 	bl	3f0c844 <printf>
		return 1;
 3f08154:	e3a00001 	mov	r0, #1	; 0x1
 3f08158:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
	}

	/* Check for a size spefication.
	 * Defaults to long if no or incorrect specification.
	 */
	if ((size = cmd_get_data_size(argv[0], 4)) < 0)
 3f0815c:	e5940000 	ldr	r0, [r4]
 3f08160:	e3a01004 	mov	r1, #4	; 0x4
 3f08164:	ebfffde1 	bl	3f078f0 <cmd_get_data_size>
 3f08168:	e2505000 	subs	r5, r0, #0	; 0x0
		return 1;
 3f0816c:	b3a00001 	movlt	r0, #1	; 0x1
 3f08170:	b91ba870 	ldmltdb	r11, {r4, r5, r6, r11, r13, r15}

	/* Address is always specified.
	*/
	addr = simple_strtoul(argv[1], NULL, 16);
 3f08174:	e3a01000 	mov	r1, #0	; 0x0
 3f08178:	e5940004 	ldr	r0, [r4, #4]
 3f0817c:	e3a02010 	mov	r2, #16	; 0x10
 3f08180:	eb001d6f 	bl	3f0f744 <simple_strtoul>

	/* Length is the number of objects, not number of bytes.
	*/
	length = simple_strtoul(argv[2], NULL, 16);
 3f08184:	e3a01000 	mov	r1, #0	; 0x0
 3f08188:	e1a06000 	mov	r6, r0
 3f0818c:	e5940008 	ldr	r0, [r4, #8]
 3f08190:	e3a02010 	mov	r2, #16	; 0x10
 3f08194:	eb001d6a 	bl	3f0f744 <simple_strtoul>

	/* We want to optimize the loops to run as fast as possible.
	 * If we have only one object, just run infinite loops.
	 */
	if (length == 1) {
 3f08198:	e3500001 	cmp	r0, #1	; 0x1
 3f0819c:	1a000009 	bne	3f081c8 <do_mem_loop+0x9c>
		if (size == 4) {
 3f081a0:	e3550004 	cmp	r5, #4	; 0x4
 3f081a4:	1a000001 	bne	3f081b0 <do_mem_loop+0x84>
			longp = (uint *)addr;
			for (;;)
				i = *longp;
 3f081a8:	e5962000 	ldr	r2, [r6]
 3f081ac:	eafffffd 	b	3f081a8 <do_mem_loop+0x7c>
		}
		if (size == 2) {
 3f081b0:	e3550002 	cmp	r5, #2	; 0x2
 3f081b4:	1a000001 	bne	3f081c0 <do_mem_loop+0x94>
			shortp = (ushort *)addr;
			for (;;)
				i = *shortp;
 3f081b8:	e1d630b0 	ldrh	r3, [r6]
 3f081bc:	eafffffd 	b	3f081b8 <do_mem_loop+0x8c>
		}
		cp = (u_char *)addr;
		for (;;)
			i = *cp;
 3f081c0:	e5d63000 	ldrb	r3, [r6]
 3f081c4:	eafffffd 	b	3f081c0 <do_mem_loop+0x94>
	}

	if (size == 4) {
 3f081c8:	e3550004 	cmp	r5, #4	; 0x4
 3f081cc:	1a000009 	bne	3f081f8 <do_mem_loop+0xcc>
		for (;;) {
			longp = (uint *)addr;
 3f081d0:	e1a01006 	mov	r1, r6
			i = length;
			while (i-- > 0)
 3f081d4:	e2402001 	sub	r2, r0, #1	; 0x1
 3f081d8:	e3500000 	cmp	r0, #0	; 0x0
 3f081dc:	0afffffb 	beq	3f081d0 <do_mem_loop+0xa4>
				junk = *longp++;
 3f081e0:	e1a03002 	mov	r3, r2
 3f081e4:	e2422001 	sub	r2, r2, #1	; 0x1
 3f081e8:	e3530000 	cmp	r3, #0	; 0x0
 3f081ec:	e4913004 	ldr	r3, [r1], #4
 3f081f0:	1afffffa 	bne	3f081e0 <do_mem_loop+0xb4>
 3f081f4:	eafffff5 	b	3f081d0 <do_mem_loop+0xa4>
		}
	}
	if (size == 2) {
 3f081f8:	e3550002 	cmp	r5, #2	; 0x2
 3f081fc:	1a000009 	bne	3f08228 <do_mem_loop+0xfc>
		for (;;) {
			shortp = (ushort *)addr;
 3f08200:	e1a01006 	mov	r1, r6
			i = length;
			while (i-- > 0)
 3f08204:	e2402001 	sub	r2, r0, #1	; 0x1
 3f08208:	e3500000 	cmp	r0, #0	; 0x0
 3f0820c:	0afffffb 	beq	3f08200 <do_mem_loop+0xd4>
				junk = *shortp++;
 3f08210:	e1a03002 	mov	r3, r2
 3f08214:	e2422001 	sub	r2, r2, #1	; 0x1
 3f08218:	e3530000 	cmp	r3, #0	; 0x0
 3f0821c:	e0d130b2 	ldrh	r3, [r1], #2
 3f08220:	1afffffa 	bne	3f08210 <do_mem_loop+0xe4>
 3f08224:	eafffff5 	b	3f08200 <do_mem_loop+0xd4>
		}
	}
	for (;;) {
		cp = (u_char *)addr;
 3f08228:	e1a01006 	mov	r1, r6
		i = length;
		while (i-- > 0)
 3f0822c:	e2402001 	sub	r2, r0, #1	; 0x1
 3f08230:	e3500000 	cmp	r0, #0	; 0x0
 3f08234:	0afffffb 	beq	3f08228 <do_mem_loop+0xfc>
			junk = *cp++;
 3f08238:	e1a03002 	mov	r3, r2
 3f0823c:	e2422001 	sub	r2, r2, #1	; 0x1
 3f08240:	e3530000 	cmp	r3, #0	; 0x0
 3f08244:	e4d13001 	ldrb	r3, [r1], #1
 3f08248:	1afffffa 	bne	3f08238 <do_mem_loop+0x10c>
 3f0824c:	eafffff5 	b	3f08228 <do_mem_loop+0xfc>
 3f08250:	03f1d340 	mvneqs	r13, #1	; 0x1

03f08254 <do_mem_mtest>:
 3f08254:	e1a0c00d 	mov	r12, r13
 3f08258:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0825c:	e24cb004 	sub	r11, r12, #4	; 0x4
	}
}

/*
 * Perform a memory test. A more complete alternative test can be
 * configured using CFG_ALT_MEMTEST. The complete test loops until
 * interrupted by ctrl-c or by a failure of one of the sub-tests.
 */
int do_mem_mtest (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f08260:	e1a04002 	mov	r4, r2
	vu_long	*addr, *start, *end;
	ulong	val;
	ulong	readback;

#if defined(CFG_ALT_MEMTEST)
	vu_long	addr_mask;
	vu_long	offset;
	vu_long	test_offset;
	vu_long	pattern;
	vu_long	temp;
	vu_long	anti_pattern;
	vu_long	num_words;
#if defined(CFG_MEMTEST_SCRATCH)
	vu_long *dummy = (vu_long*)CFG_MEMTEST_SCRATCH;
#else
	vu_long *dummy = NULL;
#endif
	int	j;
	int iterations = 1;

	static const ulong bitpattern[] = {
		0x00000001,	/* single bit */
		0x00000003,	/* two adjacent bits */
		0x00000007,	/* three adjacent bits */
		0x0000000F,	/* four adjacent bits */
		0x00000005,	/* two non-adjacent bits */
		0x00000015,	/* three non-adjacent bits */
		0x00000055,	/* four non-adjacent bits */
		0xaaaaaaaa,	/* alternating 1/0 */
	};
#else
	ulong	incr;
	ulong	pattern;
	int     rcode = 0;
#endif

	if (argc > 1) {
 3f08264:	e3540001 	cmp	r4, #1	; 0x1
 3f08268:	e1a05003 	mov	r5, r3
 3f0826c:	da000005 	ble	3f08288 <do_mem_mtest+0x34>
		start = (ulong *)simple_strtoul(argv[1], NULL, 16);
 3f08270:	e3a01000 	mov	r1, #0	; 0x0
 3f08274:	e5950004 	ldr	r0, [r5, #4]
 3f08278:	e3a02010 	mov	r2, #16	; 0x10
 3f0827c:	eb001d30 	bl	3f0f744 <simple_strtoul>
 3f08280:	e1a0a000 	mov	r10, r0
	} else {
 3f08284:	ea000000 	b	3f0828c <do_mem_mtest+0x38>
		start = (ulong *)CFG_MEMTEST_START;
 3f08288:	e3a0a601 	mov	r10, #1048576	; 0x100000
	}

	if (argc > 2) {
 3f0828c:	e3540002 	cmp	r4, #2	; 0x2
 3f08290:	da000005 	ble	3f082ac <do_mem_mtest+0x58>
		end = (ulong *)simple_strtoul(argv[2], NULL, 16);
 3f08294:	e3a01000 	mov	r1, #0	; 0x0
 3f08298:	e5950008 	ldr	r0, [r5, #8]
 3f0829c:	e3a02010 	mov	r2, #16	; 0x10
 3f082a0:	eb001d27 	bl	3f0f744 <simple_strtoul>
 3f082a4:	e1a07000 	mov	r7, r0
	} else {
 3f082a8:	ea000000 	b	3f082b0 <do_mem_mtest+0x5c>
		end = (ulong *)(CFG_MEMTEST_END);
 3f082ac:	e3a0763e 	mov	r7, #65011712	; 0x3e00000
	}

	if (argc > 3) {
 3f082b0:	e3540003 	cmp	r4, #3	; 0x3
 3f082b4:	da000005 	ble	3f082d0 <do_mem_mtest+0x7c>
		pattern = (ulong)simple_strtoul(argv[3], NULL, 16);
 3f082b8:	e3a01000 	mov	r1, #0	; 0x0
 3f082bc:	e595000c 	ldr	r0, [r5, #12]
 3f082c0:	e3a02010 	mov	r2, #16	; 0x10
 3f082c4:	eb001d1e 	bl	3f0f744 <simple_strtoul>
 3f082c8:	e1a06000 	mov	r6, r0
	} else {
 3f082cc:	ea000000 	b	3f082d4 <do_mem_mtest+0x80>
		pattern = 0;
 3f082d0:	e3a06000 	mov	r6, #0	; 0x0
	}

#if defined(CFG_ALT_MEMTEST)
	printf ("Testing %08x ... %08x:\n", (uint)start, (uint)end);
	PRINTF("%s:%d: start 0x%p end 0x%p\n",
		__FUNCTION__, __LINE__, start, end);

	for (;;) {
		if (ctrlc()) {
			putc ('\n');
			return 1;
		}

		printf("Iteration: %6d\r", iterations);
		PRINTF("Iteration: %6d\n", iterations);
		iterations++;

		/*
		 * Data line test: write a pattern to the first
		 * location, write the 1's complement to a 'parking'
		 * address (changes the state of the data bus so a
		 * floating bus doen't give a false OK), and then
		 * read the value back. Note that we read it back
		 * into a variable because the next time we read it,
		 * it might be right (been there, tough to explain to
		 * the quality guys why it prints a failure when the
		 * "is" and "should be" are obviously the same in the
		 * error message).
		 *
		 * Rather than exhaustively testing, we test some
		 * patterns by shifting '1' bits through a field of
		 * '0's and '0' bits through a field of '1's (i.e.
		 * pattern and ~pattern).
		 */
		addr = start;
		for (j = 0; j < sizeof(bitpattern)/sizeof(bitpattern[0]); j++) {
		    val = bitpattern[j];
		    for(; val != 0; val <<= 1) {
			*addr  = val;
			*dummy  = ~val; /* clear the test data off of the bus */
			readback = *addr;
			if(readback != val) {
			     printf ("FAILURE (data line): "
				"expected %08lx, actual %08lx\n",
					  val, readback);
			}
			*addr  = ~val;
			*dummy  = val;
			readback = *addr;
			if(readback != ~val) {
			    printf ("FAILURE (data line): "
				"Is %08lx, should be %08lx\n",
					val, readback);
			}
		    }
		}

		/*
		 * Based on code whose Original Author and Copyright
		 * information follows: Copyright (c) 1998 by Michael
		 * Barr. This software is placed into the public
		 * domain and may be used for any purpose. However,
		 * this notice must not be changed or removed and no
		 * warranty is either expressed or implied by its
		 * publication or distribution.
		 */

		/*
		 * Address line test
		 *
		 * Description: Test the address bus wiring in a
		 *              memory region by performing a walking
		 *              1's test on the relevant bits of the
		 *              address and checking for aliasing.
		 *              This test will find single-bit
		 *              address failures such as stuck -high,
		 *              stuck-low, and shorted pins. The base
		 *              address and size of the region are
		 *              selected by the caller.
		 *
		 * Notes:	For best results, the selected base
		 *              address should have enough LSB 0's to
		 *              guarantee single address bit changes.
		 *              For example, to test a 64-Kbyte
		 *              region, select a base address on a
		 *              64-Kbyte boundary. Also, select the
		 *              region size as a power-of-two if at
		 *              all possible.
		 *
		 * Returns:     0 if the test succeeds, 1 if the test fails.
		 *
		 * ## NOTE ##	Be sure to specify start and end
		 *              addresses such that addr_mask has
		 *              lots of bits set. For example an
		 *              address range of 01000000 02000000 is
		 *              bad while a range of 01000000
		 *              01ffffff is perfect.
		 */
		addr_mask = ((ulong)end - (ulong)start)/sizeof(vu_long);
		pattern = (vu_long) 0xaaaaaaaa;
		anti_pattern = (vu_long) 0x55555555;

		PRINTF("%s:%d: addr mask = 0x%.8lx\n",
			__FUNCTION__, __LINE__,
			addr_mask);
		/*
		 * Write the default pattern at each of the
		 * power-of-two offsets.
		 */
		for (offset = 1; (offset & addr_mask) != 0; offset <<= 1) {
			start[offset] = pattern;
		}

		/*
		 * Check for address bits stuck high.
		 */
		test_offset = 0;
		start[test_offset] = anti_pattern;

		for (offset = 1; (offset & addr_mask) != 0; offset <<= 1) {
		    temp = start[offset];
		    if (temp != pattern) {
			printf ("\nFAILURE: Address bit stuck high @ 0x%.8lx:"
				" expected 0x%.8lx, actual 0x%.8lx\n",
				(ulong)&start[offset], pattern, temp);
			return 1;
		    }
		}
		start[test_offset] = pattern;

		/*
		 * Check for addr bits stuck low or shorted.
		 */
		for (test_offset = 1; (test_offset & addr_mask) != 0; test_offset <<= 1) {
		    start[test_offset] = anti_pattern;

		    for (offset = 1; (offset & addr_mask) != 0; offset <<= 1) {
			temp = start[offset];
			if ((temp != pattern) && (offset != test_offset)) {
			    printf ("\nFAILURE: Address bit stuck low or shorted @"
				" 0x%.8lx: expected 0x%.8lx, actual 0x%.8lx\n",
				(ulong)&start[offset], pattern, temp);
			    return 1;
			}
		    }
		    start[test_offset] = pattern;
		}

		/*
		 * Description: Test the integrity of a physical
		 *		memory device by performing an
		 *		increment/decrement test over the
		 *		entire region. In the process every
		 *		storage bit in the device is tested
		 *		as a zero and a one. The base address
		 *		and the size of the region are
		 *		selected by the caller.
		 *
		 * Returns:     0 if the test succeeds, 1 if the test fails.
		 */
		num_words = ((ulong)end - (ulong)start)/sizeof(vu_long) + 1;

		/*
		 * Fill memory with a known pattern.
		 */
		for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
			start[offset] = pattern;
		}

		/*
		 * Check each location and invert it for the second pass.
		 */
		for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
		    temp = start[offset];
		    if (temp != pattern) {
			printf ("\nFAILURE (read/write) @ 0x%.8lx:"
				" expected 0x%.8lx, actual 0x%.8lx)\n",
				(ulong)&start[offset], pattern, temp);
			return 1;
		    }

		    anti_pattern = ~pattern;
		    start[offset] = anti_pattern;
		}

		/*
		 * Check each location for the inverted pattern and zero it.
		 */
		for (pattern = 1, offset = 0; offset < num_words; pattern++, offset++) {
		    anti_pattern = ~pattern;
		    temp = start[offset];
		    if (temp != anti_pattern) {
			printf ("\nFAILURE (read/write): @ 0x%.8lx:"
				" expected 0x%.8lx, actual 0x%.8lx)\n",
				(ulong)&start[offset], anti_pattern, temp);
			return 1;
		    }
		    start[offset] = 0;
		}
	}

#else /* The original, quickie test */
	incr = 1;
 3f082d4:	e3a09001 	mov	r9, #1	; 0x1
	for (;;) {
		if (ctrlc()) {
 3f082d8:	eb001173 	bl	3f0c8ac <ctrlc>
 3f082dc:	e3500000 	cmp	r0, #0	; 0x0
 3f082e0:	0a000003 	beq	3f082f4 <do_mem_mtest+0xa0>
			putc ('\n');
 3f082e4:	e3a0000a 	mov	r0, #10	; 0xa
 3f082e8:	eb00113b 	bl	3f0c7dc <putc>
			return 1;
 3f082ec:	e3a00001 	mov	r0, #1	; 0x1
 3f082f0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
		}

		printf ("\rPattern %08lX  Writing..."
 3f082f4:	e1a01006 	mov	r1, r6
 3f082f8:	e59f007c 	ldr	r0, [pc, #7c]	; 3f0837c <do_mem_mtest+0x128>
			"%12s"
			"\b\b\b\b\b\b\b\b\b\b",
			pattern, "");

		for (addr=start,val=pattern; addr<end; addr++) {
 3f082fc:	e1a0400a 	mov	r4, r10
 3f08300:	e59f2078 	ldr	r2, [pc, #78]	; 3f08380 <do_mem_mtest+0x12c>
 3f08304:	e1a05006 	mov	r5, r6
 3f08308:	eb00114d 	bl	3f0c844 <printf>
 3f0830c:	e1540007 	cmp	r4, r7
 3f08310:	2a000003 	bcs	3f08324 <do_mem_mtest+0xd0>
			*addr = val;
 3f08314:	e4845004 	str	r5, [r4], #4
			val  += incr;
 3f08318:	e0855009 	add	r5, r5, r9
 3f0831c:	e1540007 	cmp	r4, r7
 3f08320:	3afffffb 	bcc	3f08314 <do_mem_mtest+0xc0>
		}

		printf("Reading...");

		for (addr=start,val=pattern; addr<end; addr++) {
 3f08324:	e1a0400a 	mov	r4, r10
 3f08328:	e59f0054 	ldr	r0, [pc, #54]	; 3f08384 <do_mem_mtest+0x130>
 3f0832c:	e1a05006 	mov	r5, r6
 3f08330:	eb001143 	bl	3f0c844 <printf>
 3f08334:	e1540007 	cmp	r4, r7
 3f08338:	2a00000a 	bcs	3f08368 <do_mem_mtest+0x114>
			readback = *addr;
 3f0833c:	e5942000 	ldr	r2, [r4]
			if (readback != val) {
 3f08340:	e1520005 	cmp	r2, r5
 3f08344:	0a000003 	beq	3f08358 <do_mem_mtest+0x104>
				printf ("\nMem error @ 0x%08X: "
 3f08348:	e1a01004 	mov	r1, r4
 3f0834c:	e59f0034 	ldr	r0, [pc, #34]	; 3f08388 <do_mem_mtest+0x134>
 3f08350:	e1a03005 	mov	r3, r5
 3f08354:	eb00113a 	bl	3f0c844 <printf>
					"found %08lX, expected %08lX\n",
					(uint)addr, readback, val);
				rcode = 1;
			}
			val += incr;
 3f08358:	e0855009 	add	r5, r5, r9
 3f0835c:	e2844004 	add	r4, r4, #4	; 0x4
 3f08360:	e1540007 	cmp	r4, r7
 3f08364:	3afffff4 	bcc	3f0833c <do_mem_mtest+0xe8>
		}

		/*
		 * Flip the pattern each time to make lots of zeros and
		 * then, the next time, lots of ones.  We decrement
		 * the "negative" patterns and increment the "positive"
		 * patterns to preserve this feature.
		 */
		if(pattern & 0x80000000) {
 3f08368:	e3560000 	cmp	r6, #0	; 0x0
			pattern = -pattern;	/* complement & increment */
 3f0836c:	b2666000 	rsblt	r6, r6, #0	; 0x0
		}
		else {
			pattern = ~pattern;
 3f08370:	a1e06006 	mvnge	r6, r6
		}
		incr = -incr;
 3f08374:	e2699000 	rsb	r9, r9, #0	; 0x0
 3f08378:	eaffffd6 	b	3f082d8 <do_mem_mtest+0x84>
 3f0837c:	03f1d510 	mvneqs	r13, #67108864	; 0x4000000
 3f08380:	03f1d470 	mvneqs	r13, #1879048192	; 0x70000000
 3f08384:	03f1d53c 	mvneqs	r13, #251658240	; 0xf000000
 3f08388:	03f1d548 	mvneqs	r13, #301989888	; 0x12000000

03f0838c <mod_mem>:
 3f0838c:	e1a0c00d 	mov	r12, r13
 3f08390:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f08394:	e24cb004 	sub	r11, r12, #4	; 0x4
	}
	return rcode;
#endif
}


/* Modify memory.
 *
 * Syntax:
 *	mm{.b, .w, .l} {addr}
 *	nm{.b, .w, .l} {addr}
 */
static int
mod_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char *argv[])
{
	ulong	addr, i;
	int	nbytes, size;
	extern char console_buffer[];

	if (argc != 2) {
 3f08398:	e3530002 	cmp	r3, #2	; 0x2
 3f0839c:	e1a03000 	mov	r3, r0
 3f083a0:	e1a0a001 	mov	r10, r1
 3f083a4:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f083a8:	e59b7004 	ldr	r7, [r11, #4]
 3f083ac:	0a000004 	beq	3f083c4 <mod_mem+0x38>
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f083b0:	e59f0120 	ldr	r0, [pc, #120]	; 3f084d8 <mod_mem+0x14c>
 3f083b4:	e5931010 	ldr	r1, [r3, #16]
 3f083b8:	eb001121 	bl	3f0c844 <printf>
		return 1;
 3f083bc:	e3a00001 	mov	r0, #1	; 0x1
 3f083c0:	ea000058 	b	3f08528 <mod_mem+0x19c>
	}

#ifdef CONFIG_BOOT_RETRY_TIME
	reset_cmd_timeout();	/* got a good command to get here */
#endif
	/* We use the last specified parameters, unless new ones are
	 * entered.
	 */
	addr = mm_last_addr;
 3f083c4:	e59f9110 	ldr	r9, [pc, #110]	; 3f084dc <mod_mem+0x150>
	size = mm_last_size;
 3f083c8:	e59f3110 	ldr	r3, [pc, #110]	; 3f084e0 <mod_mem+0x154>
 3f083cc:	e5995000 	ldr	r5, [r9]

	if ((flag & CMD_FLAG_REPEAT) == 0) {
 3f083d0:	e2124001 	ands	r4, r2, #1	; 0x1
 3f083d4:	e5936000 	ldr	r6, [r3]
 3f083d8:	1a00000c 	bne	3f08410 <mod_mem+0x84>
		/* New command specified.  Check for a size specification.
		 * Defaults to long if no or incorrect specification.
		 */
		if ((size = cmd_get_data_size(argv[0], 4)) < 0)
 3f083dc:	e5970000 	ldr	r0, [r7]
 3f083e0:	e3a01004 	mov	r1, #4	; 0x4
 3f083e4:	ebfffd41 	bl	3f078f0 <cmd_get_data_size>
 3f083e8:	e2506000 	subs	r6, r0, #0	; 0x0
			return 1;
 3f083ec:	b3a00001 	movlt	r0, #1	; 0x1
 3f083f0:	ba00004c 	blt	3f08528 <mod_mem+0x19c>

		/* Address is specified since argc > 1
		*/
		addr = simple_strtoul(argv[1], NULL, 16);
 3f083f4:	e1a01004 	mov	r1, r4
 3f083f8:	e5970004 	ldr	r0, [r7, #4]
 3f083fc:	e3a02010 	mov	r2, #16	; 0x10
 3f08400:	eb001ccf 	bl	3f0f744 <simple_strtoul>
		addr += base_address;
 3f08404:	e59f30d8 	ldr	r3, [pc, #d8]	; 3f084e4 <mod_mem+0x158>
 3f08408:	e5933000 	ldr	r3, [r3]
 3f0840c:	e0805003 	add	r5, r0, r3
	}

#ifdef CONFIG_HAS_DATAFLASH
	if (addr_dataflash(addr)){
		printf("Can't modify DataFlash in place. Use cp instead.\n\r");
		return 0;
	}
#endif

	/* Print the address, followed by value.  Then accept input for
	 * the next value.  A non-converted value exits.
	 */
	do {
		printf("%08lx:", addr);
 3f08410:	e59f00d0 	ldr	r0, [pc, #d0]	; 3f084e8 <mod_mem+0x15c>
 3f08414:	e1a01005 	mov	r1, r5
 3f08418:	eb001109 	bl	3f0c844 <printf>
		if (size == 4)
 3f0841c:	e3560004 	cmp	r6, #4	; 0x4
 3f08420:	1a000003 	bne	3f08434 <mod_mem+0xa8>
			printf(" %08x", *((uint   *)addr));
 3f08424:	e59f00c0 	ldr	r0, [pc, #c0]	; 3f084ec <mod_mem+0x160>
 3f08428:	e5951000 	ldr	r1, [r5]
 3f0842c:	eb001104 	bl	3f0c844 <printf>
 3f08430:	ea000008 	b	3f08458 <mod_mem+0xcc>
		else if (size == 2)
 3f08434:	e3560002 	cmp	r6, #2	; 0x2
 3f08438:	1a000003 	bne	3f0844c <mod_mem+0xc0>
			printf(" %04x", *((ushort *)addr));
 3f0843c:	e59f00ac 	ldr	r0, [pc, #ac]	; 3f084f0 <mod_mem+0x164>
 3f08440:	e1d510b0 	ldrh	r1, [r5]
 3f08444:	eb0010fe 	bl	3f0c844 <printf>
 3f08448:	ea000002 	b	3f08458 <mod_mem+0xcc>
		else
			printf(" %02x", *((u_char *)addr));
 3f0844c:	e59f00a0 	ldr	r0, [pc, #a0]	; 3f084f4 <mod_mem+0x168>
 3f08450:	e5d51000 	ldrb	r1, [r5]
 3f08454:	eb0010fa 	bl	3f0c844 <printf>

		nbytes = readline (" ? ");
 3f08458:	e59f0098 	ldr	r0, [pc, #98]	; 3f084f8 <mod_mem+0x16c>
 3f0845c:	ebffed0b 	bl	3f03890 <readline>
		if (nbytes == 0 || (nbytes == 1 && console_buffer[0] == '-')) {
 3f08460:	e2502000 	subs	r2, r0, #0	; 0x0
 3f08464:	0a000005 	beq	3f08480 <mod_mem+0xf4>
 3f08468:	e3520001 	cmp	r2, #1	; 0x1
 3f0846c:	1a00000a 	bne	3f0849c <mod_mem+0x110>
 3f08470:	e59f3084 	ldr	r3, [pc, #84]	; 3f084fc <mod_mem+0x170>
 3f08474:	e5d33000 	ldrb	r3, [r3]
 3f08478:	e353002d 	cmp	r3, #45	; 0x2d
 3f0847c:	1a000006 	bne	3f0849c <mod_mem+0x110>
			/* <CR> pressed as only input, don't modify current
			 * location and move to next. "-" pressed will go back.
			 */
			if (incrflag)
 3f08480:	e35a0000 	cmp	r10, #0	; 0x0
 3f08484:	0a000002 	beq	3f08494 <mod_mem+0x108>
				addr += nbytes ? -size : size;
 3f08488:	e3520000 	cmp	r2, #0	; 0x0
 3f0848c:	10665005 	rsbne	r5, r6, r5
 3f08490:	00855006 	addeq	r5, r5, r6
			nbytes = 1;
 3f08494:	e3a02001 	mov	r2, #1	; 0x1
#ifdef CONFIG_BOOT_RETRY_TIME
			reset_cmd_timeout(); /* good enough to not time out */
#endif
		}
 3f08498:	ea00001c 	b	3f08510 <mod_mem+0x184>
#ifdef CONFIG_BOOT_RETRY_TIME
		else if (nbytes == -2) {
			break;	/* timed out, exit the command	*/
		}
#endif
		else {
			char *endp;
			i = simple_strtoul(console_buffer, &endp, 16);
 3f0849c:	e24b1028 	sub	r1, r11, #40	; 0x28
 3f084a0:	e59f4054 	ldr	r4, [pc, #54]	; 3f084fc <mod_mem+0x170>
 3f084a4:	e3a02010 	mov	r2, #16	; 0x10
 3f084a8:	e1a00004 	mov	r0, r4
 3f084ac:	eb001ca4 	bl	3f0f744 <simple_strtoul>
			nbytes = endp - console_buffer;
 3f084b0:	e51b3028 	ldr	r3, [r11, -#40]
			if (nbytes) {
 3f084b4:	e0532004 	subs	r2, r3, r4
 3f084b8:	0a000014 	beq	3f08510 <mod_mem+0x184>
#ifdef CONFIG_BOOT_RETRY_TIME
				/* good enough to not time out
				 */
				reset_cmd_timeout();
#endif
				if (size == 4)
 3f084bc:	e3560004 	cmp	r6, #4	; 0x4
					*((uint   *)addr) = i;
 3f084c0:	05850000 	streq	r0, [r5]
 3f084c4:	0a00000e 	beq	3f08504 <mod_mem+0x178>
				else if (size == 2)
 3f084c8:	e3560002 	cmp	r6, #2	; 0x2
 3f084cc:	1a00000b 	bne	3f08500 <mod_mem+0x174>
					*((ushort *)addr) = i;
 3f084d0:	e1c500b0 	strh	r0, [r5]
 3f084d4:	ea00000a 	b	3f08504 <mod_mem+0x178>
 3f084d8:	03f1d340 	mvneqs	r13, #1	; 0x1
 3f084dc:	03f6ce58 	mvneqs	r12, #1408	; 0x580
 3f084e0:	03f6ce5c 	mvneqs	r12, #1472	; 0x5c0
 3f084e4:	03f20608 	mvneqs	r0, #8388608	; 0x800000
 3f084e8:	03f1d34c 	mvneqs	r13, #805306369	; 0x30000001
 3f084ec:	03f1d354 	mvneqs	r13, #1342177281	; 0x50000001
 3f084f0:	03f1d35c 	mvneqs	r13, #1879048193	; 0x70000001
 3f084f4:	03f1d364 	mvneqs	r13, #-1879048191	; 0x90000001
 3f084f8:	03f1d57c 	mvneqs	r13, #520093696	; 0x1f000000
 3f084fc:	03f6cc04 	mvneqs	r12, #1024	; 0x400
				else
					*((u_char *)addr) = i;
 3f08500:	e5c50000 	strb	r0, [r5]
				if (incrflag)
					addr += size;
 3f08504:	e0853006 	add	r3, r5, r6
 3f08508:	e35a0000 	cmp	r10, #0	; 0x0
 3f0850c:	11a05003 	movne	r5, r3
			}
		}
	} while (nbytes);
 3f08510:	e3520000 	cmp	r2, #0	; 0x0
 3f08514:	1affffbd 	bne	3f08410 <mod_mem+0x84>

	mm_last_addr = addr;
 3f08518:	e5895000 	str	r5, [r9]
	mm_last_size = size;
 3f0851c:	e59f3008 	ldr	r3, [pc, #8]	; 3f0852c <mod_mem+0x1a0>
	return 0;
 3f08520:	e1a00002 	mov	r0, r2
 3f08524:	e5836000 	str	r6, [r3]
 3f08528:	ea000000 	b	3f08530 <mod_mem+0x1a4>
 3f0852c:	03f6ce5c 	mvneqs	r12, #1472	; 0x5c0
}
 3f08530:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f08534 <do_mem_crc>:
 3f08534:	e1a0c00d 	mov	r12, r13
 3f08538:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f0853c:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_mem_crc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f08540:	e1a07002 	mov	r7, r2
	ulong addr, length;
	ulong crc;
	ulong *ptr;

	if (argc < 3) {
 3f08544:	e3570002 	cmp	r7, #2	; 0x2
 3f08548:	e1a02000 	mov	r2, r0
 3f0854c:	e1a06003 	mov	r6, r3
 3f08550:	ca000004 	bgt	3f08568 <do_mem_crc+0x34>
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f08554:	e59f008c 	ldr	r0, [pc, #8c]	; 3f085e8 <do_mem_crc+0xb4>
 3f08558:	e5921010 	ldr	r1, [r2, #16]
 3f0855c:	eb0010b8 	bl	3f0c844 <printf>
		return 1;
 3f08560:	e3a00001 	mov	r0, #1	; 0x1
 3f08564:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	}

	addr = simple_strtoul (argv[1], NULL, 16);
 3f08568:	e3a01000 	mov	r1, #0	; 0x0
 3f0856c:	e5960004 	ldr	r0, [r6, #4]
 3f08570:	e3a02010 	mov	r2, #16	; 0x10
 3f08574:	eb001c72 	bl	3f0f744 <simple_strtoul>
	addr += base_address;
 3f08578:	e59f306c 	ldr	r3, [pc, #6c]	; 3f085ec <do_mem_crc+0xb8>
 3f0857c:	e5933000 	ldr	r3, [r3]

	length = simple_strtoul (argv[2], NULL, 16);
 3f08580:	e3a01000 	mov	r1, #0	; 0x0
 3f08584:	e0804003 	add	r4, r0, r3
 3f08588:	e5960008 	ldr	r0, [r6, #8]
 3f0858c:	e3a02010 	mov	r2, #16	; 0x10
 3f08590:	eb001c6b 	bl	3f0f744 <simple_strtoul>
 3f08594:	e1a05000 	mov	r5, r0

	crc = crc32 (0, (const uchar *) addr, length);
 3f08598:	e3a00000 	mov	r0, #0	; 0x0
 3f0859c:	e1a01004 	mov	r1, r4
 3f085a0:	e1a02005 	mov	r2, r5
 3f085a4:	eb001a31 	bl	3f0ee70 <crc32>

	printf ("CRC32 for %08lx ... %08lx ==> %08lx\n",
 3f085a8:	e1a01004 	mov	r1, r4
 3f085ac:	e0844005 	add	r4, r4, r5
 3f085b0:	e2442001 	sub	r2, r4, #1	; 0x1
 3f085b4:	e1a04000 	mov	r4, r0
 3f085b8:	e59f0030 	ldr	r0, [pc, #30]	; 3f085f0 <do_mem_crc+0xbc>
 3f085bc:	e1a03004 	mov	r3, r4
 3f085c0:	eb00109f 	bl	3f0c844 <printf>
			addr, addr + length - 1, crc);

	if (argc > 3) {
 3f085c4:	e3570003 	cmp	r7, #3	; 0x3
 3f085c8:	da000004 	ble	3f085e0 <do_mem_crc+0xac>
		ptr = (ulong *) simple_strtoul (argv[3], NULL, 16);
 3f085cc:	e3a01000 	mov	r1, #0	; 0x0
 3f085d0:	e596000c 	ldr	r0, [r6, #12]
 3f085d4:	e3a02010 	mov	r2, #16	; 0x10
 3f085d8:	eb001c59 	bl	3f0f744 <simple_strtoul>
		*ptr = crc;
 3f085dc:	e5804000 	str	r4, [r0]
	}

	return 0;
 3f085e0:	e3a00000 	mov	r0, #0	; 0x0
}
 3f085e4:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f085e8:	03f1d340 	mvneqs	r13, #1	; 0x1
 3f085ec:	03f20608 	mvneqs	r0, #8388608	; 0x800000
 3f085f0:	03f1d580 	mvneqs	r13, #536870912	; 0x20000000

03f085f4 <do_sleep>:
 3f085f4:	e1a0c00d 	mov	r12, r13
 3f085f8:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f085fc:	e24cb004 	sub	r11, r12, #4	; 0x4
int do_sleep (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	ulong delay;

	if (argc != 2) {
 3f08600:	e3520002 	cmp	r2, #2	; 0x2
 3f08604:	e1a02000 	mov	r2, r0
 3f08608:	0a000004 	beq	3f08620 <do_sleep+0x2c>
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f0860c:	e59f005c 	ldr	r0, [pc, #5c]	; 3f08670 <do_sleep+0x7c>
 3f08610:	e5921010 	ldr	r1, [r2, #16]
 3f08614:	eb00108a 	bl	3f0c844 <printf>
		return 1;
 3f08618:	e3a00001 	mov	r0, #1	; 0x1
 3f0861c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
	}

	delay = simple_strtoul(argv[1], NULL, 10);
 3f08620:	e3a01000 	mov	r1, #0	; 0x0
 3f08624:	e5930004 	ldr	r0, [r3, #4]
 3f08628:	e3a0200a 	mov	r2, #10	; 0xa
 3f0862c:	eb001c44 	bl	3f0f744 <simple_strtoul>

	while (delay) {
 3f08630:	e2504000 	subs	r4, r0, #0	; 0x0
 3f08634:	0a00000b 	beq	3f08668 <do_sleep+0x74>
		int i;
		for (i=0; i<1000; ++i) {
 3f08638:	e3a05000 	mov	r5, #0	; 0x0
			if (ctrlc ()) {
 3f0863c:	eb00109a 	bl	3f0c8ac <ctrlc>
 3f08640:	e3500000 	cmp	r0, #0	; 0x0
				return (-1);
 3f08644:	e3e00000 	mvn	r0, #0	; 0x0
 3f08648:	191ba830 	ldmnedb	r11, {r4, r5, r11, r13, r15}
			}
			udelay (1000);
 3f0864c:	e3a00ffa 	mov	r0, #1000	; 0x3e8
 3f08650:	ebffe070 	bl	3f00818 <udelay>
 3f08654:	e2855001 	add	r5, r5, #1	; 0x1
 3f08658:	e3550ffa 	cmp	r5, #1000	; 0x3e8
 3f0865c:	bafffff6 	blt	3f0863c <do_sleep+0x48>
		}
		--delay;
	}
 3f08660:	e2544001 	subs	r4, r4, #1	; 0x1
 3f08664:	1afffff3 	bne	3f08638 <do_sleep+0x44>
	return 0;
 3f08668:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0866c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f08670:	03f1d9e0 	mvneqs	r13, #3670016	; 0x380000

03f08674 <do_mmc>:
 3f08674:	e1a0c00d 	mov	r12, r13
 3f08678:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0867c:	e24cb004 	sub	r11, r12, #4	; 0x4
#include <mmc.h>

int do_mmc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	if (mmc_init (1) != 0) {
 3f08680:	e3a00001 	mov	r0, #1	; 0x1
 3f08684:	eb003007 	bl	3f146a8 <mmc_init>
 3f08688:	e3500000 	cmp	r0, #0	; 0x0
 3f0868c:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
		printf ("No MMC card found\n");
 3f08690:	e59f0008 	ldr	r0, [pc, #8]	; 3f086a0 <do_mmc+0x2c>
 3f08694:	eb00106a 	bl	3f0c844 <printf>
		return 1;
 3f08698:	e3a00001 	mov	r0, #1	; 0x1
 3f0869c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f086a0:	03f1da5c 	mvneqs	r13, #376832	; 0x5c000

03f086a4 <nand_write_page_yaffs>:
 3f086a4:	e1a0c00d 	mov	r12, r13
 3f086a8:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f086ac:	e24cb004 	sub	r11, r12, #4	; 0x4
        int i;
        unsigned long nandptr = nand->IO_ADDR;

        /* Prepad for partial page programming !!! */
        for (i = 0; i < col; i++)
 3f086b0:	e3a0c000 	mov	r12, #0	; 0x0
 3f086b4:	e1a05002 	mov	r5, r2
 3f086b8:	e15c0005 	cmp	r12, r5
 3f086bc:	e1a04000 	mov	r4, r0
 3f086c0:	e1a06001 	mov	r6, r1
 3f086c4:	e1a01003 	mov	r1, r3
 3f086c8:	aa000005 	bge	3f086e4 <nand_write_page_yaffs+0x40>
                nand->data_buf[i] = 0xff;
 3f086cc:	e5942004 	ldr	r2, [r4, #4]
 3f086d0:	e3a030ff 	mov	r3, #255	; 0xff
 3f086d4:	e7c2300c 	strb	r3, [r2, r12]
 3f086d8:	e28cc001 	add	r12, r12, #1	; 0x1
 3f086dc:	e15c0005 	cmp	r12, r5
 3f086e0:	bafffff9 	blt	3f086cc <nand_write_page_yaffs+0x28>

        /* Postpad for partial page programming !!! oob is already padded */
        for (i = last; i < nand->oobblock; i++)
 3f086e4:	e5943048 	ldr	r3, [r4, #72]
 3f086e8:	e1a0c001 	mov	r12, r1
 3f086ec:	e15c0003 	cmp	r12, r3
 3f086f0:	2a000006 	bcs	3f08710 <nand_write_page_yaffs+0x6c>
                nand->data_buf[i] = 0xff;
 3f086f4:	e5943004 	ldr	r3, [r4, #4]
 3f086f8:	e3a020ff 	mov	r2, #255	; 0xff
 3f086fc:	e7c3200c 	strb	r2, [r3, r12]
 3f08700:	e5943048 	ldr	r3, [r4, #72]
 3f08704:	e28cc001 	add	r12, r12, #1	; 0x1
 3f08708:	e15c0003 	cmp	r12, r3
 3f0870c:	3afffff8 	bcc	3f086f4 <nand_write_page_yaffs+0x50>

        /* Send command to begin auto page programming */
        NanD_Command(nand, NAND_CMD_READ0);
 3f08710:	e1a00004 	mov	r0, r4
 3f08714:	e3a01000 	mov	r1, #0	; 0x0
 3f08718:	eb000ba6 	bl	3f0b5b8 <NanD_Command>
        NanD_Command(nand, NAND_CMD_SEQIN);
 3f0871c:	e1a00004 	mov	r0, r4
 3f08720:	e3a01080 	mov	r1, #128	; 0x80
 3f08724:	eb000ba3 	bl	3f0b5b8 <NanD_Command>
#ifdef CONFIG_MMSP20
	NanD_OnlyAddress(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
 3f08728:	e1a00004 	mov	r0, r4
 3f0872c:	e5942000 	ldr	r2, [r4]
 3f08730:	e3a01003 	mov	r1, #3	; 0x3
 3f08734:	e0852216 	add	r2, r5, r6, lsl r2
 3f08738:	eb000403 	bl	3f0974c <NanD_OnlyAddress>
#else
        NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
#endif

        /* Write out complete page of data */
        for (i = 0; i < (nand->oobblock + nand->oobsize); i++)
 3f0873c:	e2842048 	add	r2, r4, #72	; 0x48
 3f08740:	e892000c 	ldmia	r2, {r2, r3}
 3f08744:	e0823003 	add	r3, r2, r3
 3f08748:	e3a0c000 	mov	r12, #0	; 0x0
 3f0874c:	e15c0003 	cmp	r12, r3
 3f08750:	2a000009 	bcs	3f0877c <nand_write_page_yaffs+0xd8>
                WRITE_NAND(nand->data_buf[i], nand->IO_ADDR);
 3f08754:	e5943004 	ldr	r3, [r4, #4]
 3f08758:	e7d3200c 	ldrb	r2, [r3, r12]
 3f0875c:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f08760:	e5c32000 	strb	r2, [r3]
 3f08764:	e2842048 	add	r2, r4, #72	; 0x48
 3f08768:	e892000c 	ldmia	r2, {r2, r3}
 3f0876c:	e0823003 	add	r3, r2, r3
 3f08770:	e28cc001 	add	r12, r12, #1	; 0x1
 3f08774:	e15c0003 	cmp	r12, r3
 3f08778:	3afffff5 	bcc	3f08754 <nand_write_page_yaffs+0xb0>

        /* Send command to actually program the data */
        NanD_Command(nand, NAND_CMD_PAGEPROG);
 3f0877c:	e1a00004 	mov	r0, r4
 3f08780:	e3a01010 	mov	r1, #16	; 0x10
 3f08784:	eb000b8b 	bl	3f0b5b8 <NanD_Command>
#ifdef CONFIG_MMSP20
       	NanD_WaitReady(nand, 0);
 3f08788:	e1a00004 	mov	r0, r4
 3f0878c:	e3a01000 	mov	r1, #0	; 0x0
 3f08790:	eb0003c1 	bl	3f0969c <NanD_WaitReady>
#endif

	udelay(300); 
 3f08794:	e3a00f4b 	mov	r0, #300	; 0x12c
 3f08798:	ebffe01e 	bl	3f00818 <udelay>

        NanD_Command(nand, NAND_CMD_STATUS);
 3f0879c:	e1a00004 	mov	r0, r4
 3f087a0:	e3a01070 	mov	r1, #112	; 0x70
 3f087a4:	eb000b83 	bl	3f0b5b8 <NanD_Command>
#ifdef NAND_NO_RB
        { u_char ret_val;

          do{
                ret_val = READ_NAND(nandptr);   /* wait till ready */
          } while((ret_val & 0x40) != 0x40);
        }
#endif
        /* See if device thinks it succeeded */
        if (READ_NAND(nand->IO_ADDR) & 0x01) {
 3f087a8:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f087ac:	e5d33000 	ldrb	r3, [r3]
 3f087b0:	e2130001 	ands	r0, r3, #1	; 0x1
 3f087b4:	091ba870 	ldmeqdb	r11, {r4, r5, r6, r11, r13, r15}
                printf ("%s: Failed write, page 0x%08x, ", __FUNCTION__, page);
 3f087b8:	e59f0010 	ldr	r0, [pc, #10]	; 3f087d0 <nand_write_page_yaffs+0x12c>
 3f087bc:	e59f1010 	ldr	r1, [pc, #10]	; 3f087d4 <nand_write_page_yaffs+0x130>
 3f087c0:	e1a02006 	mov	r2, r6
 3f087c4:	eb00101e 	bl	3f0c844 <printf>
                return -1;
 3f087c8:	e3e00000 	mvn	r0, #0	; 0x0
        }

#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
        /*
         * The NAND device assumes that it is always writing to
         * a cleanly erased page. Hence, it performs its internal
         * write verification only on bits that transitioned from
         * 1 to 0. The device does NOT verify the whole page on a
         * byte by byte basis. It is possible that the page was
         * not completely erased or the page is becoming unusable
         * due to wear. The read with ECC would catch the error
         * later when the ECC page check fails, but we would rather
         * catch it early in the page write stage. Better to write
         * no data than invalid data.
         */

        /* Send command to read back the page */
        if (col < nand->eccsize)
                NanD_Command(nand, NAND_CMD_READ0);
        else
                NanD_Command(nand, NAND_CMD_READ1);
        NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);

	udelay(9);

        /* Loop through and verify the data */
        for (i = col; i < last; i++) {
               if (nand->data_buf[i] != readb (nand->IO_ADDR)) {
                        printf ("%s: Failed write verify, page 0x%08x ", __FUNCTION__, page);
                        return -1;
                }
        }
#endif
        return 0;
}
 3f087cc:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f087d0:	03f1dbf4 	mvneqs	r13, #249856	; 0x3d000
 3f087d4:	03f1dc14 	mvneqs	r13, #5120	; 0x1400

03f087d8 <nand_write_yaffs>:
 3f087d8:	e1a0c00d 	mov	r12, r13
 3f087dc:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f087e0:	e24cb004 	sub	r11, r12, #4	; 0x4

static int nand_write_yaffs (struct nand_chip* nand, size_t to, size_t len,
                           size_t * retlen, const u_char * buf, u_char * ecc_code)
{
 3f087e4:	e1a05000 	mov	r5, r0
        int i, page, col, cnt, ret = 0;
 3f087e8:	e3a0c000 	mov	r12, #0	; 0x0
 3f087ec:	e24dd010 	sub	r13, r13, #16	; 0x10
	int pages_per_block = (nand->erasesize) / (nand->oobblock);
 3f087f0:	e5950028 	ldr	r0, [r5, #40]
 3f087f4:	e1a04001 	mov	r4, r1
 3f087f8:	e50bc028 	str	r12, [r11, -#40]
 3f087fc:	e1a07002 	mov	r7, r2
 3f08800:	e595a048 	ldr	r10, [r5, #72]
 3f08804:	e1a06003 	mov	r6, r3
 3f08808:	e1a0100a 	mov	r1, r10
 3f0880c:	eb002af3 	bl	3f133e0 <__udivsi3>

        /* Do not allow write past end of device */
        if ((to + len) > nand->totlen) {
 3f08810:	e5952044 	ldr	r2, [r5, #68]
 3f08814:	e0843007 	add	r3, r4, r7
 3f08818:	e50b002c 	str	r0, [r11, -#44]
 3f0881c:	e1530002 	cmp	r3, r2
 3f08820:	9a000004 	bls	3f08838 <nand_write_yaffs+0x60>
                printf ("%s: Attempt to write past end of page\n", __FUNCTION__);
 3f08824:	e59f0100 	ldr	r0, [pc, #100]	; 3f0892c <nand_write_yaffs+0x154>
 3f08828:	e59f1100 	ldr	r1, [pc, #100]	; 3f08930 <nand_write_yaffs+0x158>
 3f0882c:	eb001004 	bl	3f0c844 <printf>
                return -1;
 3f08830:	e3e00000 	mvn	r0, #0	; 0x0
 3f08834:	ea00006e 	b	3f089f4 <nand_write_yaffs+0x21c>
        }

        /* Shift to get page */
        page = ((int) to) >> nand->page_shift;
 3f08838:	e5952000 	ldr	r2, [r5]

        /* Get the starting column */
        col = to & (nand->oobblock - 1);
 3f0883c:	e24a3001 	sub	r3, r10, #1	; 0x1

        /* Initialize return length value */
        *retlen = 0;
 3f08840:	e51b1028 	ldr	r1, [r11, -#40]
 3f08844:	e004a003 	and	r10, r4, r3
 3f08848:	e5861000 	str	r1, [r6]
 3f0884c:	e1a09254 	mov	r9, r4, asr r2

        /* Select the NAND device */
#ifdef CONFIG_OMAP1510
        archflashwp(0,0);
#endif
        NAND_ENABLE_CE(nand);  /* set pin low */
 3f08850:	e59f20dc 	ldr	r2, [pc, #dc]	; 3f08934 <nand_write_yaffs+0x15c>
 3f08854:	e1d230b0 	ldrh	r3, [r2]
 3f08858:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0885c:	e1c230b0 	strh	r3, [r2]
 3f08860:	e1d230b0 	ldrh	r3, [r2]
 3f08864:	e3833080 	orr	r3, r3, #128	; 0x80
 3f08868:	e1c230b0 	strh	r3, [r2]

        /* Check the WP bit */
        NanD_Command(nand, NAND_CMD_STATUS);
 3f0886c:	e1a00005 	mov	r0, r5
 3f08870:	e3a01070 	mov	r1, #112	; 0x70
 3f08874:	eb000b4f 	bl	3f0b5b8 <NanD_Command>
        if (!(READ_NAND(nand->IO_ADDR) & 0x80)) {
 3f08878:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f0887c:	e5d33000 	ldrb	r3, [r3]
 3f08880:	e3130080 	tst	r3, #128	; 0x80
 3f08884:	1a000005 	bne	3f088a0 <nand_write_yaffs+0xc8>
                printf ("%s: Device is write protected!!!\n", __FUNCTION__);
 3f08888:	e59f00a8 	ldr	r0, [pc, #a8]	; 3f08938 <nand_write_yaffs+0x160>
 3f0888c:	e59f109c 	ldr	r1, [pc, #9c]	; 3f08930 <nand_write_yaffs+0x158>
                ret = -1;
 3f08890:	e3e02000 	mvn	r2, #0	; 0x0
 3f08894:	e50b2028 	str	r2, [r11, -#40]
 3f08898:	eb000fe9 	bl	3f0c844 <printf>
                goto out;
 3f0889c:	ea00004a 	b	3f089cc <nand_write_yaffs+0x1f4>
        }

        /* Loop until all data is written */
	/* yaffs image contains oob_data ( size : 16 Bytes in each page ) 
	   so additional length should be checked.  */
        while (*retlen < len + (pages_per_block << 4)) {
 3f088a0:	e51b302c 	ldr	r3, [r11, -#44]
 3f088a4:	e1a03203 	mov	r3, r3, lsl #4
 3f088a8:	e50b3030 	str	r3, [r11, -#48]
 3f088ac:	e5962000 	ldr	r2, [r6]
 3f088b0:	e0873003 	add	r3, r7, r3
 3f088b4:	e1520003 	cmp	r2, r3
 3f088b8:	2a000042 	bcs	3f089c8 <nand_write_yaffs+0x1f0>

                /* Invalidate cache, if we write to this page */
                if (nand->cache_page == page)
 3f088bc:	e595300c 	ldr	r3, [r5, #12]
 3f088c0:	e1530009 	cmp	r3, r9
                        nand->cache_page = -1;
 3f088c4:	03e03000 	mvneq	r3, #0	; 0x0
 3f088c8:	0585300c 	streq	r3, [r5, #12]

                /* Write data into buffer */
                if ((col + len) >= nand->oobblock)
 3f088cc:	e5952048 	ldr	r2, [r5, #72]
 3f088d0:	e08a3007 	add	r3, r10, r7
 3f088d4:	e1530002 	cmp	r3, r2
 3f088d8:	3a000017 	bcc	3f0893c <nand_write_yaffs+0x164>

		/* write including oob_data in yaffs image */
                        for (i = col, cnt = 0; i < nand->oobblock + nand->oobsize; i++, cnt++)
 3f088dc:	e1a0c00a 	mov	r12, r10
 3f088e0:	e595304c 	ldr	r3, [r5, #76]
 3f088e4:	e3a04000 	mov	r4, #0	; 0x0
 3f088e8:	e0823003 	add	r3, r2, r3
 3f088ec:	e15a0003 	cmp	r10, r3
 3f088f0:	2a000021 	bcs	3f0897c <nand_write_yaffs+0x1a4>
                                nand->data_buf[i] = buf[(*retlen + cnt)];
 3f088f4:	e5963000 	ldr	r3, [r6]
 3f088f8:	e5952004 	ldr	r2, [r5, #4]
 3f088fc:	e59b1004 	ldr	r1, [r11, #4]
 3f08900:	e0833004 	add	r3, r3, r4
 3f08904:	e7d13003 	ldrb	r3, [r1, r3]
 3f08908:	e7c2300c 	strb	r3, [r2, r12]
 3f0890c:	e2844001 	add	r4, r4, #1	; 0x1
 3f08910:	e2852048 	add	r2, r5, #72	; 0x48
 3f08914:	e892000c 	ldmia	r2, {r2, r3}
 3f08918:	e0823003 	add	r3, r2, r3
 3f0891c:	e28cc001 	add	r12, r12, #1	; 0x1
 3f08920:	e15c0003 	cmp	r12, r3
 3f08924:	3afffff2 	bcc	3f088f4 <nand_write_yaffs+0x11c>
 3f08928:	ea000013 	b	3f0897c <nand_write_yaffs+0x1a4>
 3f0892c:	03f1dc2c 	mvneqs	r13, #11264	; 0x2c00
 3f08930:	03f1dc54 	mvneqs	r13, #21504	; 0x5400
 3f08934:	c0003a3a 	andgt	r3, r0, r10, lsr r10
 3f08938:	03f1dc68 	mvneqs	r13, #26624	; 0x6800
                else
                        for (i = col, cnt = 0; cnt < (len - *retlen); i++, cnt++)
 3f0893c:	e1a0c00a 	mov	r12, r10
 3f08940:	e5961000 	ldr	r1, [r6]
 3f08944:	e3a04000 	mov	r4, #0	; 0x0
 3f08948:	e1570001 	cmp	r7, r1
 3f0894c:	0a00000a 	beq	3f0897c <nand_write_yaffs+0x1a4>
                                nand->data_buf[i] = buf[(*retlen + cnt)];
 3f08950:	e0813004 	add	r3, r1, r4
 3f08954:	e59b1004 	ldr	r1, [r11, #4]
 3f08958:	e5952004 	ldr	r2, [r5, #4]
 3f0895c:	e7d13003 	ldrb	r3, [r1, r3]
 3f08960:	e7c2300c 	strb	r3, [r2, r12]
 3f08964:	e2844001 	add	r4, r4, #1	; 0x1
 3f08968:	e5961000 	ldr	r1, [r6]
 3f0896c:	e28cc001 	add	r12, r12, #1	; 0x1
 3f08970:	e0613007 	rsb	r3, r1, r7
 3f08974:	e1540003 	cmp	r4, r3
 3f08978:	3afffff4 	bcc	3f08950 <nand_write_yaffs+0x178>

                /* We use the same function for write and writev !) */
                ret = nand_write_page_yaffs (nand, page, col, i, NULL);
 3f0897c:	e1a00005 	mov	r0, r5
 3f08980:	e1a01009 	mov	r1, r9
 3f08984:	e3a03000 	mov	r3, #0	; 0x0
 3f08988:	e1a0200a 	mov	r2, r10
 3f0898c:	e58d3000 	str	r3, [r13]
 3f08990:	e1a0300c 	mov	r3, r12
 3f08994:	ebffff42 	bl	3f086a4 <nand_write_page_yaffs>

                if (ret)
 3f08998:	e3500000 	cmp	r0, #0	; 0x0
 3f0899c:	e50b0028 	str	r0, [r11, -#40]
 3f089a0:	1a000009 	bne	3f089cc <nand_write_yaffs+0x1f4>
                        goto out;

                /* Next data start at page boundary */
                col = 0;
 3f089a4:	e1a0a000 	mov	r10, r0

                /* Update written bytes count */
                *retlen += cnt;
 3f089a8:	e5963000 	ldr	r3, [r6]

                /* Increment page address */
                page++;
 3f089ac:	e2899001 	add	r9, r9, #1	; 0x1
        }
 3f089b0:	e51bc030 	ldr	r12, [r11, -#48]
 3f089b4:	e0833004 	add	r3, r3, r4
 3f089b8:	e087200c 	add	r2, r7, r12
 3f089bc:	e1530002 	cmp	r3, r2
 3f089c0:	e5863000 	str	r3, [r6]
 3f089c4:	3affffbc 	bcc	3f088bc <nand_write_yaffs+0xe4>

        /* Return happy */
        *retlen = len;
 3f089c8:	e5867000 	str	r7, [r6]

out:
        /* De-select the NAND device */
        NAND_DISABLE_CE(nand);  /* set pin high */
 3f089cc:	e59f3024 	ldr	r3, [pc, #24]	; 3f089f8 <nand_write_yaffs+0x220>
 3f089d0:	e1d320b0 	ldrh	r2, [r3]
 3f089d4:	e3c22080 	bic	r2, r2, #128	; 0x80
 3f089d8:	e1a02802 	mov	r2, r2, lsl #16
 3f089dc:	e1a02822 	mov	r2, r2, lsr #16
 3f089e0:	e1c320b0 	strh	r2, [r3]
 3f089e4:	e1d320b0 	ldrh	r2, [r3]
 3f089e8:	e3822902 	orr	r2, r2, #32768	; 0x8000
 3f089ec:	e1c320b0 	strh	r2, [r3]
#ifdef CONFIG_OMAP1510
        archflashwp(0,1);
#endif
        return ret;
 3f089f0:	e51b0028 	ldr	r0, [r11, -#40]
 3f089f4:	ea000000 	b	3f089fc <nand_write_yaffs+0x224>
 3f089f8:	c0003a3a 	andgt	r3, r0, r10, lsr r10
}
 3f089fc:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f08a00 <do_nand>:
 3f08a00:	e1a0c00d 	mov	r12, r13
 3f08a04:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f08a08:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_nand(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f08a0c:	e1a09000 	mov	r9, r0
 3f08a10:	e1a07002 	mov	r7, r2
 3f08a14:	e1a04003 	mov	r4, r3
 3f08a18:	e24dd010 	sub	r13, r13, #16	; 0x10
    int rcode = 0;

    switch (argc) 
 3f08a1c:	e3570003 	cmp	r7, #3	; 0x3
 3f08a20:	979ff107 	ldrls	r15, [r15, r7, lsl #2]
 3f08a24:	ea000084 	b	3f08c3c <do_nand+0x23c>
 3f08a28:	03f08fd0 	mvneqs	r8, #832	; 0x340
 3f08a2c:	03f08fd0 	mvneqs	r8, #832	; 0x340
 3f08a30:	03f08a38 	mvneqs	r8, #229376	; 0x38000
 3f08a34:	03f08b50 	mvneqs	r8, #81920	; 0x14000
    {
    case 0:
    case 1:
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
    case 2:
		if(strcmp(argv[1],"info") == 0) 
 3f08a38:	e5940004 	ldr	r0, [r4, #4]
 3f08a3c:	e59f13a4 	ldr	r1, [pc, #3a4]	; 3f08de8 <do_nand+0x3e8>
 3f08a40:	eb0019dc 	bl	3f0f1b8 <strcmp>
 3f08a44:	e2505000 	subs	r5, r0, #0	; 0x0
 3f08a48:	1a000012 	bne	3f08a98 <do_nand+0x98>
		{
			int i;
	
			putc ('\n');
 3f08a4c:	e3a0000a 	mov	r0, #10	; 0xa
 3f08a50:	eb000f61 	bl	3f0c7dc <putc>
	
			for (i=0; i<CFG_MAX_NAND_DEVICE; ++i) 
 3f08a54:	e1a06005 	mov	r6, r5
			{
				if(nand_dev_desc[i].ChipID == NAND_ChipID_UNKNOWN)
 3f08a58:	e59f338c 	ldr	r3, [pc, #38c]	; 3f08dec <do_nand+0x3ec>
 3f08a5c:	e0864003 	add	r4, r6, r3
 3f08a60:	e5d43018 	ldrb	r3, [r4, #24]
 3f08a64:	e3530000 	cmp	r3, #0	; 0x0
 3f08a68:	0a000004 	beq	3f08a80 <do_nand+0x80>
					continue; /* list only known devices */
				printf ("Device %d: ", i);
 3f08a6c:	e59f037c 	ldr	r0, [pc, #37c]	; 3f08df0 <do_nand+0x3f0>
 3f08a70:	e1a01005 	mov	r1, r5
 3f08a74:	eb000f72 	bl	3f0c844 <printf>
				nand_print(&nand_dev_desc[i]);
 3f08a78:	e1a00004 	mov	r0, r4
 3f08a7c:	eb0002db 	bl	3f095f0 <nand_print>
 3f08a80:	e2866054 	add	r6, r6, #84	; 0x54
 3f08a84:	e2855001 	add	r5, r5, #1	; 0x1
 3f08a88:	e3550000 	cmp	r5, #0	; 0x0
 3f08a8c:	dafffff1 	ble	3f08a58 <do_nand+0x58>
			}
			return 0;
 3f08a90:	e3a00000 	mov	r0, #0	; 0x0
 3f08a94:	ea000151 	b	3f08fe0 <do_nand+0x5e0>
	
		} 
		else if (strcmp(argv[1], "device") == 0) 
 3f08a98:	e5940004 	ldr	r0, [r4, #4]
 3f08a9c:	e59f1350 	ldr	r1, [pc, #350]	; 3f08df4 <do_nand+0x3f4>
 3f08aa0:	eb0019c4 	bl	3f0f1b8 <strcmp>
 3f08aa4:	e3500000 	cmp	r0, #0	; 0x0
 3f08aa8:	1a000011 	bne	3f08af4 <do_nand+0xf4>
		{
			if ((curr_device < 0) || (curr_device >= CFG_MAX_NAND_DEVICE)) 
 3f08aac:	e59f5344 	ldr	r5, [pc, #344]	; 3f08df8 <do_nand+0x3f8>
 3f08ab0:	e5954000 	ldr	r4, [r5]
 3f08ab4:	e3540000 	cmp	r4, #0	; 0x0
 3f08ab8:	0a000002 	beq	3f08ac8 <do_nand+0xc8>
			{
				puts ("\nno devices available\n");
 3f08abc:	e59f0338 	ldr	r0, [pc, #338]	; 3f08dfc <do_nand+0x3fc>
 3f08ac0:	eb000f52 	bl	3f0c810 <puts>
				return 1;
 3f08ac4:	ea000144 	b	3f08fdc <do_nand+0x5dc>
			}
			printf ("\nDevice %d: ", curr_device);
 3f08ac8:	e59f0330 	ldr	r0, [pc, #330]	; 3f08e00 <do_nand+0x400>
 3f08acc:	e1a01004 	mov	r1, r4
 3f08ad0:	eb000f5b 	bl	3f0c844 <printf>
			nand_print(&nand_dev_desc[curr_device]);
 3f08ad4:	e5950000 	ldr	r0, [r5]
 3f08ad8:	e59f330c 	ldr	r3, [pc, #30c]	; 3f08dec <do_nand+0x3ec>
 3f08adc:	e0800080 	add	r0, r0, r0, lsl #1
 3f08ae0:	e0600180 	rsb	r0, r0, r0, lsl #3
 3f08ae4:	e0830100 	add	r0, r3, r0, lsl #2
 3f08ae8:	eb0002c0 	bl	3f095f0 <nand_print>
			return 0;
 3f08aec:	e3a00000 	mov	r0, #0	; 0x0
 3f08af0:	ea00013a 	b	3f08fe0 <do_nand+0x5e0>
	
		} 
		else if (strcmp(argv[1], "bad") == 0) 
 3f08af4:	e5940004 	ldr	r0, [r4, #4]
 3f08af8:	e59f1304 	ldr	r1, [pc, #304]	; 3f08e04 <do_nand+0x404>
 3f08afc:	eb0019ad 	bl	3f0f1b8 <strcmp>
 3f08b00:	e3500000 	cmp	r0, #0	; 0x0
 3f08b04:	1a000131 	bne	3f08fd0 <do_nand+0x5d0>
		{
			if ((curr_device < 0) || (curr_device >= CFG_MAX_NAND_DEVICE)) 
 3f08b08:	e59f52e8 	ldr	r5, [pc, #2e8]	; 3f08df8 <do_nand+0x3f8>
 3f08b0c:	e5954000 	ldr	r4, [r5]
 3f08b10:	e3540000 	cmp	r4, #0	; 0x0
 3f08b14:	0a000002 	beq	3f08b24 <do_nand+0x124>
			{
				puts ("\nno devices available\n");
 3f08b18:	e59f02dc 	ldr	r0, [pc, #2dc]	; 3f08dfc <do_nand+0x3fc>
 3f08b1c:	eb000f3b 	bl	3f0c810 <puts>
				return 1;
 3f08b20:	ea00012d 	b	3f08fdc <do_nand+0x5dc>
			}
			printf ("\nDevice %d bad blocks:\n", curr_device);
 3f08b24:	e59f02dc 	ldr	r0, [pc, #2dc]	; 3f08e08 <do_nand+0x408>
 3f08b28:	e1a01004 	mov	r1, r4
 3f08b2c:	eb000f44 	bl	3f0c844 <printf>
			nand_print_bad(&nand_dev_desc[curr_device]);
 3f08b30:	e5950000 	ldr	r0, [r5]
 3f08b34:	e59f32b0 	ldr	r3, [pc, #2b0]	; 3f08dec <do_nand+0x3ec>
 3f08b38:	e0800080 	add	r0, r0, r0, lsl #1
 3f08b3c:	e0600180 	rsb	r0, r0, r0, lsl #3
 3f08b40:	e0830100 	add	r0, r3, r0, lsl #2
 3f08b44:	eb0001fd 	bl	3f09340 <nand_print_bad>
			return 0;
 3f08b48:	e3a00000 	mov	r0, #0	; 0x0
 3f08b4c:	ea000123 	b	3f08fe0 <do_nand+0x5e0>
	
		}
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
    case 3:
		if(strcmp(argv[1], "device") == 0) 
 3f08b50:	e5940004 	ldr	r0, [r4, #4]
 3f08b54:	e59f1298 	ldr	r1, [pc, #298]	; 3f08df4 <do_nand+0x3f4>
 3f08b58:	eb001996 	bl	3f0f1b8 <strcmp>
 3f08b5c:	e2506000 	subs	r6, r0, #0	; 0x0
 3f08b60:	1a00001b 	bne	3f08bd4 <do_nand+0x1d4>
		{
			int dev = (int)simple_strtoul(argv[2], NULL, 10);
 3f08b64:	e1a01006 	mov	r1, r6
 3f08b68:	e5940008 	ldr	r0, [r4, #8]
 3f08b6c:	e3a0200a 	mov	r2, #10	; 0xa
 3f08b70:	eb001af3 	bl	3f0f744 <simple_strtoul>
 3f08b74:	e1a05000 	mov	r5, r0
	
			printf ("\nDevice %d: ", dev);
 3f08b78:	e59f0280 	ldr	r0, [pc, #280]	; 3f08e00 <do_nand+0x400>
 3f08b7c:	e1a01005 	mov	r1, r5
 3f08b80:	eb000f2f 	bl	3f0c844 <printf>
			if(dev >= CFG_MAX_NAND_DEVICE) 
 3f08b84:	e3550000 	cmp	r5, #0	; 0x0
 3f08b88:	da000002 	ble	3f08b98 <do_nand+0x198>
			{
				puts ("unknown device\n");
 3f08b8c:	e59f0278 	ldr	r0, [pc, #278]	; 3f08e0c <do_nand+0x40c>
 3f08b90:	eb000f1e 	bl	3f0c810 <puts>
				return 1;
 3f08b94:	ea000110 	b	3f08fdc <do_nand+0x5dc>
			}
			nand_print(&nand_dev_desc[dev]);
 3f08b98:	e0853085 	add	r3, r5, r5, lsl #1
 3f08b9c:	e59f4248 	ldr	r4, [pc, #248]	; 3f08dec <do_nand+0x3ec>
 3f08ba0:	e0633183 	rsb	r3, r3, r3, lsl #3
 3f08ba4:	e0844103 	add	r4, r4, r3, lsl #2
 3f08ba8:	e1a00004 	mov	r0, r4
 3f08bac:	eb00028f 	bl	3f095f0 <nand_print>
			/*nand_print (dev);*/
	
			if(nand_dev_desc[dev].ChipID == NAND_ChipID_UNKNOWN) 
 3f08bb0:	e5d43018 	ldrb	r3, [r4, #24]
 3f08bb4:	e3530000 	cmp	r3, #0	; 0x0
 3f08bb8:	0a000107 	beq	3f08fdc <do_nand+0x5dc>
			{
				return 1;
			}
	
			curr_device = dev;
 3f08bbc:	e59f3234 	ldr	r3, [pc, #234]	; 3f08df8 <do_nand+0x3f8>
	
			puts ("... is now current device\n");
 3f08bc0:	e59f0248 	ldr	r0, [pc, #248]	; 3f08e10 <do_nand+0x410>
 3f08bc4:	e5835000 	str	r5, [r3]
 3f08bc8:	eb000f10 	bl	3f0c810 <puts>
	
			return 0;
 3f08bcc:	e3a00000 	mov	r0, #0	; 0x0
 3f08bd0:	ea000102 	b	3f08fe0 <do_nand+0x5e0>
		}
		else if(strcmp(argv[1], "erase") == 0 && strcmp(argv[2], "clean") == 0) 
 3f08bd4:	e5940004 	ldr	r0, [r4, #4]
 3f08bd8:	e59f1234 	ldr	r1, [pc, #234]	; 3f08e14 <do_nand+0x414>
 3f08bdc:	eb001975 	bl	3f0f1b8 <strcmp>
 3f08be0:	e3500000 	cmp	r0, #0	; 0x0
 3f08be4:	1a0000f9 	bne	3f08fd0 <do_nand+0x5d0>
 3f08be8:	e5940008 	ldr	r0, [r4, #8]
 3f08bec:	e59f1224 	ldr	r1, [pc, #224]	; 3f08e18 <do_nand+0x418>
 3f08bf0:	eb001970 	bl	3f0f1b8 <strcmp>
 3f08bf4:	e2506000 	subs	r6, r0, #0	; 0x0
 3f08bf8:	1a0000f4 	bne	3f08fd0 <do_nand+0x5d0>
		{
			struct nand_chip* nand = &nand_dev_desc[curr_device];
 3f08bfc:	e59f31f4 	ldr	r3, [pc, #1f4]	; 3f08df8 <do_nand+0x3f8>
 3f08c00:	e5931000 	ldr	r1, [r3]
 3f08c04:	e59f41e0 	ldr	r4, [pc, #1e0]	; 3f08dec <do_nand+0x3ec>
 3f08c08:	e0813081 	add	r3, r1, r1, lsl #1
 3f08c0c:	e0633183 	rsb	r3, r3, r3, lsl #3
 3f08c10:	e0844103 	add	r4, r4, r3, lsl #2
			ulong off = 0;
			ulong size = nand->totlen;
 3f08c14:	e5945044 	ldr	r5, [r4, #68]
			int ret;
	
			//printf ("\nNAND erase: device %d offset %ld, size %ld ... ",
			printf("\nNAND erase: device %d offset 0x%x, size 0x%x ... ", curr_device, off, size);
 3f08c18:	e1a02006 	mov	r2, r6
 3f08c1c:	e59f01f8 	ldr	r0, [pc, #1f8]	; 3f08e1c <do_nand+0x41c>
 3f08c20:	e1a03005 	mov	r3, r5
 3f08c24:	eb000f06 	bl	3f0c844 <printf>
	
			ret = nand_erase (nand, off, size, 1);
 3f08c28:	e1a00004 	mov	r0, r4
 3f08c2c:	e1a01006 	mov	r1, r6
 3f08c30:	e1a02005 	mov	r2, r5
 3f08c34:	e3a03001 	mov	r3, #1	; 0x1
	
			printf("%s\n", ret ? "ERROR" : "OK");
	
			return ret;
 3f08c38:	ea0000cd 	b	3f08f74 <do_nand+0x574>
		}
	
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
    default:
		/* at least 4 args */
	
		if (strncmp(argv[1], "read", 4) == 0 || strncmp(argv[1], "write", 5) == 0) 
 3f08c3c:	e5940004 	ldr	r0, [r4, #4]
 3f08c40:	e59f11d8 	ldr	r1, [pc, #1d8]	; 3f08e20 <do_nand+0x420>
 3f08c44:	e3a02004 	mov	r2, #4	; 0x4
 3f08c48:	eb001969 	bl	3f0f1f4 <strncmp>
 3f08c4c:	e3500000 	cmp	r0, #0	; 0x0
 3f08c50:	0a000005 	beq	3f08c6c <do_nand+0x26c>
 3f08c54:	e5940004 	ldr	r0, [r4, #4]
 3f08c58:	e59f11c4 	ldr	r1, [pc, #1c4]	; 3f08e24 <do_nand+0x424>
 3f08c5c:	e3a02005 	mov	r2, #5	; 0x5
 3f08c60:	eb001963 	bl	3f0f1f4 <strncmp>
 3f08c64:	e3500000 	cmp	r0, #0	; 0x0
 3f08c68:	1a000099 	bne	3f08ed4 <do_nand+0x4d4>
		{
			ulong addr = simple_strtoul(argv[2], NULL, 16);
 3f08c6c:	e3a01000 	mov	r1, #0	; 0x0
 3f08c70:	e5940008 	ldr	r0, [r4, #8]
 3f08c74:	e3a02010 	mov	r2, #16	; 0x10
 3f08c78:	eb001ab1 	bl	3f0f744 <simple_strtoul>
 3f08c7c:	e50b002c 	str	r0, [r11, -#44]
			ulong off  = simple_strtoul(argv[3], NULL, 16);
 3f08c80:	e3a01000 	mov	r1, #0	; 0x0
 3f08c84:	e594000c 	ldr	r0, [r4, #12]
 3f08c88:	e3a02010 	mov	r2, #16	; 0x10
 3f08c8c:	eb001aac 	bl	3f0f744 <simple_strtoul>
			ulong size = simple_strtoul(argv[4], NULL, 16);
 3f08c90:	e3a01000 	mov	r1, #0	; 0x0
 3f08c94:	e1a07000 	mov	r7, r0
 3f08c98:	e5940010 	ldr	r0, [r4, #16]
 3f08c9c:	e3a02010 	mov	r2, #16	; 0x10
 3f08ca0:	eb001aa7 	bl	3f0f744 <simple_strtoul>
			int cmd    = (strncmp(argv[1], "read", 4) == 0) ? NANDRW_READ : NANDRW_WRITE;
 3f08ca4:	e59f1174 	ldr	r1, [pc, #174]	; 3f08e20 <do_nand+0x420>
 3f08ca8:	e1a0a000 	mov	r10, r0
 3f08cac:	e5940004 	ldr	r0, [r4, #4]
 3f08cb0:	e3a02004 	mov	r2, #4	; 0x4
 3f08cb4:	eb00194e 	bl	3f0f1f4 <strncmp>
 3f08cb8:	e3500000 	cmp	r0, #0	; 0x0
 3f08cbc:	13a06000 	movne	r6, #0	; 0x0
 3f08cc0:	03a06001 	moveq	r6, #1	; 0x1
			int ret, total;
			char* cmdtail = strchr(argv[1], '.');
 3f08cc4:	e5940004 	ldr	r0, [r4, #4]
 3f08cc8:	e3a0102e 	mov	r1, #46	; 0x2e
 3f08ccc:	eb00195d 	bl	3f0f248 <strchr>
	
			if (cmdtail && !strncmp(cmdtail, ".oob", 2)) 
 3f08cd0:	e2504000 	subs	r4, r0, #0	; 0x0
 3f08cd4:	0a000023 	beq	3f08d68 <do_nand+0x368>
 3f08cd8:	e1a00004 	mov	r0, r4
 3f08cdc:	e59f1144 	ldr	r1, [pc, #144]	; 3f08e28 <do_nand+0x428>
 3f08ce0:	e3a02002 	mov	r2, #2	; 0x2
 3f08ce4:	eb001942 	bl	3f0f1f4 <strncmp>
 3f08ce8:	e3500000 	cmp	r0, #0	; 0x0
 3f08cec:	1a00001d 	bne	3f08d68 <do_nand+0x368>
			{
				/* read out-of-band data */
				if (cmd & NANDRW_READ) {
 3f08cf0:	e3560000 	cmp	r6, #0	; 0x0
 3f08cf4:	0a00000c 	beq	3f08d2c <do_nand+0x32c>
					ret = nand_read_oob(nand_dev_desc + curr_device,
 3f08cf8:	e59f30f8 	ldr	r3, [pc, #f8]	; 3f08df8 <do_nand+0x3f8>
 3f08cfc:	e51bc02c 	ldr	r12, [r11, -#44]
 3f08d00:	e1a01007 	mov	r1, r7
 3f08d04:	e5930000 	ldr	r0, [r3]
 3f08d08:	e1a0200a 	mov	r2, r10
 3f08d0c:	e58dc000 	str	r12, [r13]
 3f08d10:	e24b3028 	sub	r3, r11, #40	; 0x28
 3f08d14:	e59fc0d0 	ldr	r12, [pc, #d0]	; 3f08dec <do_nand+0x3ec>
 3f08d18:	e0800080 	add	r0, r0, r0, lsl #1
 3f08d1c:	e0600180 	rsb	r0, r0, r0, lsl #3
 3f08d20:	e08c0100 	add	r0, r12, r0, lsl #2
 3f08d24:	eb0005d4 	bl	3f0a47c <nand_read_oob>
							    off, size, &total,
							    (u_char*)addr);
				}
 3f08d28:	ea00000b 	b	3f08d5c <do_nand+0x35c>
				else 
				{
					ret = nand_write_oob(nand_dev_desc + curr_device,
 3f08d2c:	e59f30c4 	ldr	r3, [pc, #c4]	; 3f08df8 <do_nand+0x3f8>
 3f08d30:	e51bc02c 	ldr	r12, [r11, -#44]
 3f08d34:	e1a01007 	mov	r1, r7
 3f08d38:	e5930000 	ldr	r0, [r3]
 3f08d3c:	e1a0200a 	mov	r2, r10
 3f08d40:	e58dc000 	str	r12, [r13]
 3f08d44:	e24b3028 	sub	r3, r11, #40	; 0x28
 3f08d48:	e59fc09c 	ldr	r12, [pc, #9c]	; 3f08dec <do_nand+0x3ec>
 3f08d4c:	e0800080 	add	r0, r0, r0, lsl #1
 3f08d50:	e0600180 	rsb	r0, r0, r0, lsl #3
 3f08d54:	e08c0100 	add	r0, r12, r0, lsl #2
 3f08d58:	eb000611 	bl	3f0a5a4 <nand_write_oob>
 3f08d5c:	e1a04000 	mov	r4, r0
							     off, size, &total,
							     (u_char*)addr);
				}
				return ret;
 3f08d60:	e1a00004 	mov	r0, r4
 3f08d64:	ea00009d 	b	3f08fe0 <do_nand+0x5e0>
			}
			else if (cmdtail && !strncmp(cmdtail, ".jffs2", 2))
 3f08d68:	e3540000 	cmp	r4, #0	; 0x0
 3f08d6c:	0a000006 	beq	3f08d8c <do_nand+0x38c>
 3f08d70:	e1a00004 	mov	r0, r4
 3f08d74:	e59f10b0 	ldr	r1, [pc, #b0]	; 3f08e2c <do_nand+0x42c>
 3f08d78:	e3a02002 	mov	r2, #2	; 0x2
 3f08d7c:	eb00191c 	bl	3f0f1f4 <strncmp>
 3f08d80:	e3500000 	cmp	r0, #0	; 0x0
				cmd |= NANDRW_JFFS2;	/* skip bad blocks */
 3f08d84:	03866002 	orreq	r6, r6, #2	; 0x2
 3f08d88:	0a00002c 	beq	3f08e40 <do_nand+0x440>
			else if (cmdtail && !strncmp(cmdtail, ".jffs2s", 2)) {
 3f08d8c:	e3540000 	cmp	r4, #0	; 0x0
 3f08d90:	0a00000a 	beq	3f08dc0 <do_nand+0x3c0>
 3f08d94:	e1a00004 	mov	r0, r4
 3f08d98:	e59f1090 	ldr	r1, [pc, #90]	; 3f08e30 <do_nand+0x430>
 3f08d9c:	e3a02002 	mov	r2, #2	; 0x2
 3f08da0:	eb001913 	bl	3f0f1f4 <strncmp>
 3f08da4:	e3500000 	cmp	r0, #0	; 0x0
 3f08da8:	1a000004 	bne	3f08dc0 <do_nand+0x3c0>
				cmd |= NANDRW_JFFS2;	/* skip bad blocks (on read too) */
 3f08dac:	e3866002 	orr	r6, r6, #2	; 0x2
				if (cmd & NANDRW_READ)
 3f08db0:	e3160001 	tst	r6, #1	; 0x1
					cmd |= NANDRW_JFFS2_SKIP;	/* skip bad blocks (on read too) */
 3f08db4:	e3863004 	orr	r3, r6, #4	; 0x4
 3f08db8:	11a06003 	movne	r6, r3
			}
 3f08dbc:	ea00001f 	b	3f08e40 <do_nand+0x440>
	                else if (cmdtail && !strncmp(cmdtail, ".yaffs", 2))
 3f08dc0:	e3540000 	cmp	r4, #0	; 0x0
 3f08dc4:	0a00001b 	beq	3f08e38 <do_nand+0x438>
 3f08dc8:	e1a00004 	mov	r0, r4
 3f08dcc:	e59f1060 	ldr	r1, [pc, #60]	; 3f08e34 <do_nand+0x434>
 3f08dd0:	e3a02002 	mov	r2, #2	; 0x2
 3f08dd4:	eb001906 	bl	3f0f1f4 <strncmp>
 3f08dd8:	e3500000 	cmp	r0, #0	; 0x0
 3f08ddc:	1a000015 	bne	3f08e38 <do_nand+0x438>
	                        cmd |= NANDRW_YAFFS;   
 3f08de0:	e3866008 	orr	r6, r6, #8	; 0x8
 3f08de4:	ea000015 	b	3f08e40 <do_nand+0x440>
 3f08de8:	03f1dc98 	mvneqs	r13, #38912	; 0x9800
 3f08dec:	03f207f4 	mvneqs	r0, #63963136	; 0x3d00000
 3f08df0:	03f1dca0 	mvneqs	r13, #40960	; 0xa000
 3f08df4:	03f1dcac 	mvneqs	r13, #44032	; 0xac00
 3f08df8:	03f20848 	mvneqs	r0, #4718592	; 0x480000
 3f08dfc:	03f1dcb4 	mvneqs	r13, #46080	; 0xb400
 3f08e00:	03f1dccc 	mvneqs	r13, #52224	; 0xcc00
 3f08e04:	03f1dcdc 	mvneqs	r13, #56320	; 0xdc00
 3f08e08:	03f1dce0 	mvneqs	r13, #57344	; 0xe000
 3f08e0c:	03f1dcf8 	mvneqs	r13, #63488	; 0xf800
 3f08e10:	03f1dd08 	mvneqs	r13, #512	; 0x200
 3f08e14:	03f1dd24 	mvneqs	r13, #2304	; 0x900
 3f08e18:	03f1dd2c 	mvneqs	r13, #2816	; 0xb00
 3f08e1c:	03f1dd34 	mvneqs	r13, #3328	; 0xd00
 3f08e20:	03f1dd78 	mvneqs	r13, #7680	; 0x1e00
 3f08e24:	03f1dd80 	mvneqs	r13, #8192	; 0x2000
 3f08e28:	03f1dd88 	mvneqs	r13, #8704	; 0x2200
 3f08e2c:	03f1dd90 	mvneqs	r13, #9216	; 0x2400
 3f08e30:	03f1dd98 	mvneqs	r13, #9728	; 0x2600
 3f08e34:	03f1dda0 	mvneqs	r13, #10240	; 0x2800
#ifdef SXNI855T
			/* need ".e" same as ".j" for compatibility with older units */
			else if (cmdtail && !strcmp(cmdtail, ".e"))
				cmd |= NANDRW_JFFS2;	/* skip bad blocks */
#endif
			else if (cmdtail) {
 3f08e38:	e3540000 	cmp	r4, #0	; 0x0
 3f08e3c:	1a000063 	bne	3f08fd0 <do_nand+0x5d0>
				printf ("Usage:\n%s\n", cmdtp->usage);
				return 1;
			}
	
	//		printf ("\nNAND %s: device %d offset %ld, size %ld ... ",
			printf ("\nNAND %s: device %d offset 0x%x, size 0x%x ... ",
 3f08e40:	e59f1154 	ldr	r1, [pc, #154]	; 3f08f9c <do_nand+0x59c>
 3f08e44:	e58da000 	str	r10, [r13]
 3f08e48:	e59f0150 	ldr	r0, [pc, #150]	; 3f08fa0 <do_nand+0x5a0>
 3f08e4c:	e59f4150 	ldr	r4, [pc, #150]	; 3f08fa4 <do_nand+0x5a4>
 3f08e50:	e1a03007 	mov	r3, r7
 3f08e54:	e59fc14c 	ldr	r12, [pc, #14c]	; 3f08fa8 <do_nand+0x5a8>
 3f08e58:	e2165001 	ands	r5, r6, #1	; 0x1
 3f08e5c:	e5942000 	ldr	r2, [r4]
 3f08e60:	11a0100c 	movne	r1, r12
 3f08e64:	eb000e76 	bl	3f0c844 <printf>
				(cmd & NANDRW_READ) ? "read" : "write",
				curr_device, off, size);
	
			ret = nand_rw(nand_dev_desc + curr_device, cmd, off, size,
 3f08e68:	e24b3028 	sub	r3, r11, #40	; 0x28
 3f08e6c:	e58d3000 	str	r3, [r13]
 3f08e70:	e51bc02c 	ldr	r12, [r11, -#44]
 3f08e74:	e1a01006 	mov	r1, r6
 3f08e78:	e5940000 	ldr	r0, [r4]
 3f08e7c:	e1a02007 	mov	r2, r7
 3f08e80:	e58dc004 	str	r12, [r13, #4]
 3f08e84:	e1a0300a 	mov	r3, r10
 3f08e88:	e59fc11c 	ldr	r12, [pc, #11c]	; 3f08fac <do_nand+0x5ac>
 3f08e8c:	e0800080 	add	r0, r0, r0, lsl #1
 3f08e90:	e0600180 	rsb	r0, r0, r0, lsl #3
 3f08e94:	e08c0100 	add	r0, r12, r0, lsl #2
 3f08e98:	eb000142 	bl	3f093a8 <nand_rw>
				     &total, (u_char*)addr);
	
			printf (" %d bytes %s: %s\n", total,
 3f08e9c:	e59f210c 	ldr	r2, [pc, #10c]	; 3f08fb0 <do_nand+0x5b0>
 3f08ea0:	e59f310c 	ldr	r3, [pc, #10c]	; 3f08fb4 <do_nand+0x5b4>
 3f08ea4:	e1a04000 	mov	r4, r0
 3f08ea8:	e59f0108 	ldr	r0, [pc, #108]	; 3f08fb8 <do_nand+0x5b8>
 3f08eac:	e59fc108 	ldr	r12, [pc, #108]	; 3f08fbc <do_nand+0x5bc>
 3f08eb0:	e3540000 	cmp	r4, #0	; 0x0
 3f08eb4:	e51b1028 	ldr	r1, [r11, -#40]
 3f08eb8:	11a0300c 	movne	r3, r12
 3f08ebc:	e59fc0e4 	ldr	r12, [pc, #e4]	; 3f08fa8 <do_nand+0x5a8>
 3f08ec0:	e3550000 	cmp	r5, #0	; 0x0
 3f08ec4:	11a0200c 	movne	r2, r12
 3f08ec8:	eb000e5d 	bl	3f0c844 <printf>
				(cmd & NANDRW_READ) ? "read" : "written",
				ret ? "ERROR" : "OK");
	
			return ret;
 3f08ecc:	e1a00004 	mov	r0, r4
 3f08ed0:	ea000042 	b	3f08fe0 <do_nand+0x5e0>
		} else if (strcmp(argv[1],"erase") == 0 &&
 3f08ed4:	e5940004 	ldr	r0, [r4, #4]
 3f08ed8:	e59f10e0 	ldr	r1, [pc, #e0]	; 3f08fc0 <do_nand+0x5c0>
 3f08edc:	eb0018b5 	bl	3f0f1b8 <strcmp>
 3f08ee0:	e2505000 	subs	r5, r0, #0	; 0x0
 3f08ee4:	1a000039 	bne	3f08fd0 <do_nand+0x5d0>
 3f08ee8:	e3570004 	cmp	r7, #4	; 0x4
 3f08eec:	0a000004 	beq	3f08f04 <do_nand+0x504>
 3f08ef0:	e59f00cc 	ldr	r0, [pc, #cc]	; 3f08fc4 <do_nand+0x5c4>
 3f08ef4:	e5941008 	ldr	r1, [r4, #8]
 3f08ef8:	eb0018ae 	bl	3f0f1b8 <strcmp>
 3f08efc:	e3500000 	cmp	r0, #0	; 0x0
 3f08f00:	1a000032 	bne	3f08fd0 <do_nand+0x5d0>
			   (argc == 4 || strcmp("clean", argv[2]) == 0)) {
			int clean = argc == 5;
			ulong off = simple_strtoul(argv[2 + clean], NULL, 16);
 3f08f04:	e1a01005 	mov	r1, r5
 3f08f08:	e3570005 	cmp	r7, #5	; 0x5
 3f08f0c:	13a07000 	movne	r7, #0	; 0x0
 3f08f10:	03a07001 	moveq	r7, #1	; 0x1
 3f08f14:	e0844107 	add	r4, r4, r7, lsl #2
 3f08f18:	e5940008 	ldr	r0, [r4, #8]
 3f08f1c:	e3a02010 	mov	r2, #16	; 0x10
 3f08f20:	eb001a07 	bl	3f0f744 <simple_strtoul>
			ulong size = simple_strtoul(argv[3 + clean], NULL, 16);
 3f08f24:	e1a01005 	mov	r1, r5
 3f08f28:	e1a06000 	mov	r6, r0
 3f08f2c:	e594000c 	ldr	r0, [r4, #12]
 3f08f30:	e3a02010 	mov	r2, #16	; 0x10
 3f08f34:	eb001a02 	bl	3f0f744 <simple_strtoul>
 3f08f38:	e1a05000 	mov	r5, r0
			int ret;
	
	//		printf ("\nNAND erase: device %d offset %ld, size %ld ... ",
			printf ("\nNAND erase: device %d offset 0x%x, size 0x%x ... ",
 3f08f3c:	e59f0084 	ldr	r0, [pc, #84]	; 3f08fc8 <do_nand+0x5c8>
 3f08f40:	e59f405c 	ldr	r4, [pc, #5c]	; 3f08fa4 <do_nand+0x5a4>
 3f08f44:	e1a02006 	mov	r2, r6
 3f08f48:	e5941000 	ldr	r1, [r4]
 3f08f4c:	e1a03005 	mov	r3, r5
 3f08f50:	eb000e3b 	bl	3f0c844 <printf>
				curr_device, off, size);
	
			ret = nand_erase (nand_dev_desc + curr_device, off, size, clean);
 3f08f54:	e1a01006 	mov	r1, r6
 3f08f58:	e1a02005 	mov	r2, r5
 3f08f5c:	e5940000 	ldr	r0, [r4]
 3f08f60:	e1a03007 	mov	r3, r7
 3f08f64:	e59fc040 	ldr	r12, [pc, #40]	; 3f08fac <do_nand+0x5ac>
 3f08f68:	e0800080 	add	r0, r0, r0, lsl #1
 3f08f6c:	e0600180 	rsb	r0, r0, r0, lsl #3
 3f08f70:	e08c0100 	add	r0, r12, r0, lsl #2
 3f08f74:	eb00068d 	bl	3f0a9b0 <nand_erase>
	
			printf("%s\n", ret ? "ERROR" : "OK");
 3f08f78:	e59f1034 	ldr	r1, [pc, #34]	; 3f08fb4 <do_nand+0x5b4>
 3f08f7c:	e1a04000 	mov	r4, r0
 3f08f80:	e59f3034 	ldr	r3, [pc, #34]	; 3f08fbc <do_nand+0x5bc>
 3f08f84:	e3540000 	cmp	r4, #0	; 0x0
 3f08f88:	e59f003c 	ldr	r0, [pc, #3c]	; 3f08fcc <do_nand+0x5cc>
 3f08f8c:	11a01003 	movne	r1, r3
 3f08f90:	eb000e2b 	bl	3f0c844 <printf>
	
			return ret;
 3f08f94:	e1a00004 	mov	r0, r4
 3f08f98:	ea000010 	b	3f08fe0 <do_nand+0x5e0>
 3f08f9c:	03f1dd80 	mvneqs	r13, #8192	; 0x2000
 3f08fa0:	03f1dda8 	mvneqs	r13, #10752	; 0x2a00
 3f08fa4:	03f20848 	mvneqs	r0, #4718592	; 0x480000
 3f08fa8:	03f1dd78 	mvneqs	r13, #7680	; 0x1e00
 3f08fac:	03f207f4 	mvneqs	r0, #63963136	; 0x3d00000
 3f08fb0:	03f1ddec 	mvneqs	r13, #15104	; 0x3b00
 3f08fb4:	03f1dd74 	mvneqs	r13, #7424	; 0x1d00
 3f08fb8:	03f1ddd8 	mvneqs	r13, #13824	; 0x3600
 3f08fbc:	03f1dd6c 	mvneqs	r13, #6912	; 0x1b00
 3f08fc0:	03f1dd24 	mvneqs	r13, #2304	; 0x900
 3f08fc4:	03f1dd2c 	mvneqs	r13, #2816	; 0xb00
 3f08fc8:	03f1dd34 	mvneqs	r13, #3328	; 0xd00
 3f08fcc:	03f1dd68 	mvneqs	r13, #6656	; 0x1a00
		} else {
			printf ("Usage:\n%s\n", cmdtp->usage);
 3f08fd0:	e59f000c 	ldr	r0, [pc, #c]	; 3f08fe4 <do_nand+0x5e4>
 3f08fd4:	e5991010 	ldr	r1, [r9, #16]
 3f08fd8:	eb000e19 	bl	3f0c844 <printf>
			rcode = 1;
		}
	
		return rcode;
 3f08fdc:	e3a00001 	mov	r0, #1	; 0x1
 3f08fe0:	ea000000 	b	3f08fe8 <do_nand+0x5e8>
 3f08fe4:	03f1dc8c 	mvneqs	r13, #35840	; 0x8c00
    }
}
 3f08fe8:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f08fec <do_nandboot>:
 3f08fec:	e1a0c00d 	mov	r12, r13
 3f08ff0:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f08ff4:	e24cb004 	sub	r11, r12, #4	; 0x4

U_BOOT_CMD(
	nand,	5,	1,	do_nand,
	"nand    - NAND sub-system\n",
	"info  - show available NAND devices\n"
	"nand device [dev] - show or set current device\n"
	"nand read[.jffs2[s]]  addr off size\n"
	"nand write[.jffs2] addr off size - read/write `size' bytes starting\n"
	"    at offset `off' to/from memory address `addr'\n"
	"nand erase [clean] [off size] - erase `size' bytes from\n"
	"    offset `off' (entire device if not specified)\n"
	"nand bad - show bad blocks\n"
	"nand read.oob addr off size - read out-of-band data\n"
	"nand write.oob addr off size - read out-of-band data\n"
);

int do_nandboot (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	char *boot_device = NULL;
 3f08ff8:	e3a09000 	mov	r9, #0	; 0x0
 3f08ffc:	e1a06003 	mov	r6, r3
 3f09000:	e24dd01c 	sub	r13, r13, #28	; 0x1c
	char *ep;
	int dev;
	ulong cnt;
	ulong addr;
	ulong offset = 0;
	image_header_t *hdr;
	int rcode = 0;
 3f09004:	e50b9038 	str	r9, [r11, -#56]
	switch (argc) {
 3f09008:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0900c:	e50b0034 	str	r0, [r11, -#52]
 3f09010:	e3520003 	cmp	r2, #3	; 0x3
 3f09014:	979ff102 	ldrls	r15, [r15, r2, lsl #2]
 3f09018:	ea000022 	b	3f090a8 <do_nandboot+0xbc>
 3f0901c:	03f0902c 	mvneqs	r9, #44	; 0x2c
 3f09020:	03f09038 	mvneqs	r9, #56	; 0x38
 3f09024:	03f0905c 	mvneqs	r9, #92	; 0x5c
 3f09028:	03f09078 	mvneqs	r9, #120	; 0x78
	case 1:
		addr = CFG_LOAD_ADDR;
		boot_device = getenv ("bootdevice");
 3f0902c:	e59f01b0 	ldr	r0, [pc, #1b0]	; 3f091e4 <do_nandboot+0x1f8>
 3f09030:	e3a07401 	mov	r7, #16777216	; 0x1000000
		break;
 3f09034:	ea000005 	b	3f09050 <do_nandboot+0x64>
	case 2:
		addr = simple_strtoul(argv[1], NULL, 16);
 3f09038:	e3a01000 	mov	r1, #0	; 0x0
 3f0903c:	e5960004 	ldr	r0, [r6, #4]
 3f09040:	e3a02010 	mov	r2, #16	; 0x10
 3f09044:	eb0019be 	bl	3f0f744 <simple_strtoul>
 3f09048:	e1a07000 	mov	r7, r0
		boot_device = getenv ("bootdevice");
 3f0904c:	e59f0190 	ldr	r0, [pc, #190]	; 3f091e4 <do_nandboot+0x1f8>
 3f09050:	eb000c01 	bl	3f0c05c <getenv>
 3f09054:	e1a04000 	mov	r4, r0
		break;
 3f09058:	ea000016 	b	3f090b8 <do_nandboot+0xcc>
	case 3:
		addr = simple_strtoul(argv[1], NULL, 16);
 3f0905c:	e3a01000 	mov	r1, #0	; 0x0
 3f09060:	e5960004 	ldr	r0, [r6, #4]
 3f09064:	e3a02010 	mov	r2, #16	; 0x10
 3f09068:	eb0019b5 	bl	3f0f744 <simple_strtoul>
 3f0906c:	e1a07000 	mov	r7, r0
		boot_device = argv[2];
 3f09070:	e5964008 	ldr	r4, [r6, #8]
		break;
 3f09074:	ea00000f 	b	3f090b8 <do_nandboot+0xcc>
	case 4:
		addr = simple_strtoul(argv[1], NULL, 16);
 3f09078:	e3a01000 	mov	r1, #0	; 0x0
 3f0907c:	e5960004 	ldr	r0, [r6, #4]
 3f09080:	e3a02010 	mov	r2, #16	; 0x10
 3f09084:	eb0019ae 	bl	3f0f744 <simple_strtoul>
 3f09088:	e1a07000 	mov	r7, r0
		boot_device = argv[2];
		offset = simple_strtoul(argv[3], NULL, 16);
 3f0908c:	e3a01000 	mov	r1, #0	; 0x0
 3f09090:	e596000c 	ldr	r0, [r6, #12]
 3f09094:	e3a02010 	mov	r2, #16	; 0x10
 3f09098:	e5964008 	ldr	r4, [r6, #8]
 3f0909c:	eb0019a8 	bl	3f0f744 <simple_strtoul>
 3f090a0:	e1a09000 	mov	r9, r0
		break;
 3f090a4:	ea000003 	b	3f090b8 <do_nandboot+0xcc>
	default:
		printf ("Usage:\n%s\n", cmdtp->usage);
 3f090a8:	e51b2034 	ldr	r2, [r11, -#52]
 3f090ac:	e59f0134 	ldr	r0, [pc, #134]	; 3f091e8 <do_nandboot+0x1fc>
 3f090b0:	e5921010 	ldr	r1, [r2, #16]
		SHOW_BOOT_PROGRESS (-1);
		return 1;
 3f090b4:	ea000047 	b	3f091d8 <do_nandboot+0x1ec>
	}

	if (!boot_device) {
 3f090b8:	e3540000 	cmp	r4, #0	; 0x0
 3f090bc:	1a000003 	bne	3f090d0 <do_nandboot+0xe4>
		puts ("\n** No boot device **\n");
 3f090c0:	e59f0124 	ldr	r0, [pc, #124]	; 3f091ec <do_nandboot+0x200>
 3f090c4:	eb000dd1 	bl	3f0c810 <puts>
		SHOW_BOOT_PROGRESS (-1);
		return 1;
 3f090c8:	e3a00001 	mov	r0, #1	; 0x1
 3f090cc:	ea000067 	b	3f09270 <do_nandboot+0x284>
	}

	dev = simple_strtoul(boot_device, &ep, 16);
 3f090d0:	e1a00004 	mov	r0, r4
 3f090d4:	e24b1028 	sub	r1, r11, #40	; 0x28
 3f090d8:	e3a02010 	mov	r2, #16	; 0x10
 3f090dc:	eb001998 	bl	3f0f744 <simple_strtoul>

	if ((dev >= CFG_MAX_NAND_DEVICE) ||
 3f090e0:	e2505000 	subs	r5, r0, #0	; 0x0
 3f090e4:	ca000007 	bgt	3f09108 <do_nandboot+0x11c>
 3f090e8:	e0853085 	add	r3, r5, r5, lsl #1
 3f090ec:	e0633183 	rsb	r3, r3, r3, lsl #3
 3f090f0:	e59fe0f8 	ldr	r14, [pc, #f8]	; 3f091f0 <do_nandboot+0x204>
 3f090f4:	e1a0c103 	mov	r12, r3, lsl #2
 3f090f8:	e08c400e 	add	r4, r12, r14
 3f090fc:	e5d43018 	ldrb	r3, [r4, #24]
 3f09100:	e3530000 	cmp	r3, #0	; 0x0
 3f09104:	1a000001 	bne	3f09110 <do_nandboot+0x124>
	    (nand_dev_desc[dev].ChipID == NAND_ChipID_UNKNOWN)) {
		printf ("\n** Device %d not available\n", dev);
 3f09108:	e59f00e4 	ldr	r0, [pc, #e4]	; 3f091f4 <do_nandboot+0x208>
		SHOW_BOOT_PROGRESS (-1);
		return 1;
 3f0910c:	ea000030 	b	3f091d4 <do_nandboot+0x1e8>
	}

	printf ("\nLoading from device %d: %s at 0x%lx (offset 0x%lx)\n",
 3f09110:	e58d9000 	str	r9, [r13]
 3f09114:	e59f00dc 	ldr	r0, [pc, #dc]	; 3f091f8 <do_nandboot+0x20c>
 3f09118:	e28e3034 	add	r3, r14, #52	; 0x34
 3f0911c:	e793200c 	ldr	r2, [r3, r12]
 3f09120:	e28e3040 	add	r3, r14, #64	; 0x40
 3f09124:	e793300c 	ldr	r3, [r3, r12]
 3f09128:	e1a01005 	mov	r1, r5
 3f0912c:	eb000dc4 	bl	3f0c844 <printf>
		dev, nand_dev_desc[dev].name, nand_dev_desc[dev].IO_ADDR,
		offset);

	if (nand_rw (nand_dev_desc + dev, NANDRW_READ, offset,
 3f09130:	e1a00004 	mov	r0, r4
 3f09134:	e3a01001 	mov	r1, #1	; 0x1
 3f09138:	e1a02009 	mov	r2, r9
 3f0913c:	e3a03000 	mov	r3, #0	; 0x0
 3f09140:	e58d3000 	str	r3, [r13]
 3f09144:	e2833c02 	add	r3, r3, #512	; 0x200
 3f09148:	e58d7004 	str	r7, [r13, #4]
 3f0914c:	eb000095 	bl	3f093a8 <nand_rw>
 3f09150:	e250a000 	subs	r10, r0, #0	; 0x0
 3f09154:	1a00001d 	bne	3f091d0 <do_nandboot+0x1e4>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f09158:	e5971000 	ldr	r1, [r7]
	return __arch__swab32(x);
 3f0915c:	e2013cff 	and	r3, r1, #65280	; 0xff00
 3f09160:	e1a03403 	mov	r3, r3, lsl #8
 3f09164:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f09168:	e20128ff 	and	r2, r1, #16711680	; 0xff0000
 3f0916c:	e1833422 	orr	r3, r3, r2, lsr #8
		    SECTORSIZE, NULL, (u_char *)addr)) {
		printf ("** Read error on %d\n", dev);
		SHOW_BOOT_PROGRESS (-1);
		return 1;
	}

	hdr = (image_header_t *)addr;

	if (ntohl(hdr->ih_magic) == IH_MAGIC) {
 3f09170:	e59f2084 	ldr	r2, [pc, #84]	; 3f091fc <do_nandboot+0x210>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f09174:	e1833c21 	orr	r3, r3, r1, lsr #24
 3f09178:	e1530002 	cmp	r3, r2

		print_image_hdr (hdr);

		cnt = (ntohl(hdr->ih_size) + sizeof(image_header_t));
		cnt -= SECTORSIZE;
	} else {
		printf ("\n** Bad Magic Number 0x%x **\n", hdr->ih_magic);
 3f0917c:	e59f007c 	ldr	r0, [pc, #7c]	; 3f09200 <do_nandboot+0x214>
 3f09180:	1a000014 	bne	3f091d8 <do_nandboot+0x1ec>
 3f09184:	e1a00007 	mov	r0, r7
 3f09188:	ebffeefc 	bl	3f04d80 <print_image_hdr>
		SHOW_BOOT_PROGRESS (-1);
		return 1;
	}

	if (nand_rw (nand_dev_desc + dev, NANDRW_READ, offset + SECTORSIZE, cnt,
 3f0918c:	e1a00004 	mov	r0, r4
 3f09190:	e3a01001 	mov	r1, #1	; 0x1
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f09194:	e597e00c 	ldr	r14, [r7, #12]
 3f09198:	e2892c02 	add	r2, r9, #512	; 0x200
 3f0919c:	e58da000 	str	r10, [r13]
 3f091a0:	e2873c02 	add	r3, r7, #512	; 0x200
 3f091a4:	e58d3004 	str	r3, [r13, #4]
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f091a8:	e20e3cff 	and	r3, r14, #65280	; 0xff00
 3f091ac:	e1a03403 	mov	r3, r3, lsl #8
 3f091b0:	e1833c0e 	orr	r3, r3, r14, lsl #24
 3f091b4:	e20ec8ff 	and	r12, r14, #16711680	; 0xff0000
 3f091b8:	e183342c 	orr	r3, r3, r12, lsr #8
 3f091bc:	e1833c2e 	orr	r3, r3, r14, lsr #24
 3f091c0:	e2433d07 	sub	r3, r3, #448	; 0x1c0
 3f091c4:	eb000077 	bl	3f093a8 <nand_rw>
 3f091c8:	e3500000 	cmp	r0, #0	; 0x0
 3f091cc:	0a00000d 	beq	3f09208 <do_nandboot+0x21c>
		    NULL, (u_char *)(addr+SECTORSIZE))) {
		printf ("** Read error on %d\n", dev);
 3f091d0:	e59f002c 	ldr	r0, [pc, #2c]	; 3f09204 <do_nandboot+0x218>
 3f091d4:	e1a01005 	mov	r1, r5
 3f091d8:	eb000d99 	bl	3f0c844 <printf>
		SHOW_BOOT_PROGRESS (-1);
		return 1;
 3f091dc:	e3a00001 	mov	r0, #1	; 0x1
 3f091e0:	ea000022 	b	3f09270 <do_nandboot+0x284>
 3f091e4:	03f1dff4 	mvneqs	r13, #976	; 0x3d0
 3f091e8:	03f1dc8c 	mvneqs	r13, #35840	; 0x8c00
 3f091ec:	03f1e000 	mvneqs	r14, #0	; 0x0
 3f091f0:	03f207f4 	mvneqs	r0, #63963136	; 0x3d00000
 3f091f4:	03f1e018 	mvneqs	r14, #24	; 0x18
 3f091f8:	03f1e038 	mvneqs	r14, #56	; 0x38
 3f091fc:	27051956 	undefined
 3f09200:	03f1e088 	mvneqs	r14, #136	; 0x88
 3f09204:	03f1e070 	mvneqs	r14, #112	; 0x70
	}

	/* Loading ok, update default load address */
	load_addr = addr;
 3f09208:	e59f3064 	ldr	r3, [pc, #64]	; 3f09274 <do_nandboot+0x288>

	/* Check if we should attempt an auto-start */
	if (((ep = getenv("autostart")) != NULL) && (strcmp(ep,"yes") == 0)) {
 3f0920c:	e59f0064 	ldr	r0, [pc, #64]	; 3f09278 <do_nandboot+0x28c>
 3f09210:	e5837000 	str	r7, [r3]
 3f09214:	eb000b90 	bl	3f0c05c <getenv>
 3f09218:	e3500000 	cmp	r0, #0	; 0x0
 3f0921c:	e50b0028 	str	r0, [r11, -#40]
 3f09220:	0a000011 	beq	3f0926c <do_nandboot+0x280>
 3f09224:	e59f1050 	ldr	r1, [pc, #50]	; 3f0927c <do_nandboot+0x290>
 3f09228:	eb0017e2 	bl	3f0f1b8 <strcmp>
 3f0922c:	e2505000 	subs	r5, r0, #0	; 0x0
 3f09230:	1a00000d 	bne	3f0926c <do_nandboot+0x280>
		char *local_args[2];
		extern int do_bootm (cmd_tbl_t *, int, int, char *[]);

		local_args[0] = argv[0];
		local_args[1] = NULL;
 3f09234:	e50b502c 	str	r5, [r11, -#44]

		printf ("Automatic boot of image at addr 0x%08lx ...\n", addr);
 3f09238:	e59f0040 	ldr	r0, [pc, #40]	; 3f09280 <do_nandboot+0x294>
 3f0923c:	e1a01007 	mov	r1, r7
 3f09240:	e5963000 	ldr	r3, [r6]

		do_bootm (cmdtp, 0, 1, local_args);
		rcode = 1;
 3f09244:	e3a02001 	mov	r2, #1	; 0x1
 3f09248:	e50b2038 	str	r2, [r11, -#56]
 3f0924c:	e24b4030 	sub	r4, r11, #48	; 0x30
 3f09250:	e50b3030 	str	r3, [r11, -#48]
 3f09254:	eb000d7a 	bl	3f0c844 <printf>
 3f09258:	e1a01005 	mov	r1, r5
 3f0925c:	e3a02001 	mov	r2, #1	; 0x1
 3f09260:	e51b0034 	ldr	r0, [r11, -#52]
 3f09264:	e1a03004 	mov	r3, r4
 3f09268:	ebffec88 	bl	3f04490 <do_bootm>
	}
	return rcode;
 3f0926c:	e51b0038 	ldr	r0, [r11, -#56]
 3f09270:	ea000003 	b	3f09284 <do_nandboot+0x298>
 3f09274:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
 3f09278:	03f1e0a8 	mvneqs	r14, #168	; 0xa8
 3f0927c:	03f1e0b4 	mvneqs	r14, #180	; 0xb4
 3f09280:	03f1e0b8 	mvneqs	r14, #184	; 0xb8
}
 3f09284:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f09288 <check_block>:
 3f09288:	e1a0c00d 	mov	r12, r13
 3f0928c:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}

U_BOOT_CMD(
	nboot,	4,	1,	do_nandboot,
	"nboot   - boot from NAND device\n",
	"loadAddr dev\n"
);

/* returns 0 if block containing pos is OK:
 *		valid erase block and
 *		not marked bad, or no bad mark position is specified
 * returns 1 if marked bad or otherwise invalid
 */
int check_block(struct nand_chip* nand, unsigned long pos)
{
 3f09290:	e1a04000 	mov	r4, r0
 3f09294:	e24dd00c 	sub	r13, r13, #12	; 0xc
	int retlen;
	uint8_t oob_data;
	int page0 = pos & (-nand->erasesize);
	int page1 = page0 + nand->oobblock;
	int badpos = oob_config.badblock_pos;

	dprintf("check_block_0\n");
	if (pos >= nand->totlen)
 3f09298:	e5942044 	ldr	r2, [r4, #68]
 3f0929c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f092a0:	e5943028 	ldr	r3, [r4, #40]
 3f092a4:	e1510002 	cmp	r1, r2
 3f092a8:	e2633000 	rsb	r3, r3, #0	; 0x0
 3f092ac:	e5942048 	ldr	r2, [r4, #72]
 3f092b0:	e0011003 	and	r1, r1, r3
 3f092b4:	e59f307c 	ldr	r3, [pc, #7c]	; 3f09338 <check_block+0xb0>
 3f092b8:	e081a002 	add	r10, r1, r2
 3f092bc:	e5935018 	ldr	r5, [r3, #24]
 3f092c0:	2a00001a 	bcs	3f09330 <check_block+0xa8>
		return 1;

	dprintf("check_block_1\n");
	if (badpos < 0)
 3f092c4:	e3550000 	cmp	r5, #0	; 0x0
		return 0;	/* no way to check, assume OK */
 3f092c8:	e3a00000 	mov	r0, #0	; 0x0
 3f092cc:	ba000018 	blt	3f09334 <check_block+0xac>

	dprintf("check_block_2\n");
	/* Note - bad block marker can be on first or second page */
	if (nand_read_oob(nand, page0 + badpos, 1, &retlen, &oob_data) ||
 3f092d0:	e1a00004 	mov	r0, r4
 3f092d4:	e0811005 	add	r1, r1, r5
 3f092d8:	e3a02001 	mov	r2, #1	; 0x1
 3f092dc:	e24b7028 	sub	r7, r11, #40	; 0x28
 3f092e0:	e1a03007 	mov	r3, r7
 3f092e4:	e24b6021 	sub	r6, r11, #33	; 0x21
 3f092e8:	e58d6000 	str	r6, [r13]
 3f092ec:	eb000462 	bl	3f0a47c <nand_read_oob>
 3f092f0:	e3500000 	cmp	r0, #0	; 0x0
 3f092f4:	1a00000d 	bne	3f09330 <check_block+0xa8>
 3f092f8:	e55b3021 	ldrb	r3, [r11, -#33]
 3f092fc:	e35300ff 	cmp	r3, #255	; 0xff
 3f09300:	1a00000a 	bne	3f09330 <check_block+0xa8>
 3f09304:	e1a00004 	mov	r0, r4
 3f09308:	e08a1005 	add	r1, r10, r5
 3f0930c:	e3a02001 	mov	r2, #1	; 0x1
 3f09310:	e1a03007 	mov	r3, r7
 3f09314:	e58d6000 	str	r6, [r13]
 3f09318:	eb000457 	bl	3f0a47c <nand_read_oob>
 3f0931c:	e3500000 	cmp	r0, #0	; 0x0
 3f09320:	1a000002 	bne	3f09330 <check_block+0xa8>
 3f09324:	e55b3021 	ldrb	r3, [r11, -#33]
 3f09328:	e35300ff 	cmp	r3, #255	; 0xff
 3f0932c:	0a000000 	beq	3f09334 <check_block+0xac>
	    oob_data != 0xff ||
	    nand_read_oob(nand, page1 + badpos, 1, &retlen, &oob_data) ||
	    oob_data != 0xff)
		return 1;
 3f09330:	e3a00001 	mov	r0, #1	; 0x1

	dprintf("check_block_3\n");
	return 0;
 3f09334:	ea000000 	b	3f0933c <check_block+0xb4>
 3f09338:	03f207d4 	mvneqs	r0, #55574528	; 0x3500000
}
 3f0933c:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f09340 <nand_print_bad>:
 3f09340:	e1a0c00d 	mov	r12, r13
 3f09344:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f09348:	e24cb004 	sub	r11, r12, #4	; 0x4

/* print bad blocks in NAND flash */
static void nand_print_bad(struct nand_chip* nand)
{
 3f0934c:	e1a04000 	mov	r4, r0
	unsigned long pos;

	for (pos = 0; pos < nand->totlen; pos += nand->erasesize) {
 3f09350:	e5943044 	ldr	r3, [r4, #68]
 3f09354:	e3a05000 	mov	r5, #0	; 0x0
 3f09358:	e1550003 	cmp	r5, r3
 3f0935c:	2a00000c 	bcs	3f09394 <nand_print_bad+0x54>
		if (check_block(nand, pos))
 3f09360:	e1a00004 	mov	r0, r4
 3f09364:	e1a01005 	mov	r1, r5
 3f09368:	ebffffc6 	bl	3f09288 <check_block>
 3f0936c:	e3500000 	cmp	r0, #0	; 0x0
 3f09370:	0a000002 	beq	3f09380 <nand_print_bad+0x40>
			printf(" 0x%8.8lx\n", pos);
 3f09374:	e59f0024 	ldr	r0, [pc, #24]	; 3f093a0 <nand_print_bad+0x60>
 3f09378:	e1a01005 	mov	r1, r5
 3f0937c:	eb000d30 	bl	3f0c844 <printf>
 3f09380:	e5943028 	ldr	r3, [r4, #40]
 3f09384:	e5942044 	ldr	r2, [r4, #68]
 3f09388:	e0855003 	add	r5, r5, r3
 3f0938c:	e1550002 	cmp	r5, r2
 3f09390:	3afffff2 	bcc	3f09360 <nand_print_bad+0x20>
	}
	puts("\n");
 3f09394:	e59f0008 	ldr	r0, [pc, #8]	; 3f093a4 <nand_print_bad+0x64>
 3f09398:	eb000d1c 	bl	3f0c810 <puts>
}
 3f0939c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f093a0:	03f1e124 	mvneqs	r14, #9	; 0x9
 3f093a4:	03f1e130 	mvneqs	r14, #12	; 0xc

03f093a8 <nand_rw>:
 3f093a8:	e1a0c00d 	mov	r12, r13
 3f093ac:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f093b0:	e24cb004 	sub	r11, r12, #4	; 0x4

/* cmd: 0: NANDRW_WRITE			write, fail on bad block
 *	1: NANDRW_READ			read, fail on bad block
 *	2: NANDRW_WRITE | NANDRW_JFFS2	write, skip bad blocks
 *	3: NANDRW_READ | NANDRW_JFFS2	read, data all 0xff for bad blocks
 *      7: NANDRW_READ | NANDRW_JFFS2 | NANDRW_JFFS2_SKIP read, skip bad blocks
 *      8: NANDRW_WRITE | NANDRW_YAFFS	write, yaffs // hwjang
 */
static int nand_rw (struct nand_chip* nand, int cmd,
	    size_t start, size_t len,
	    size_t * retlen, u_char * buf)
{
 3f093b4:	e1a04002 	mov	r4, r2
	int ret = 0, n, total = 0;
 3f093b8:	e3a02000 	mov	r2, #0	; 0x0
 3f093bc:	e24dd02c 	sub	r13, r13, #44	; 0x2c
 3f093c0:	e50b2038 	str	r2, [r11, -#56]
 3f093c4:	e50b203c 	str	r2, [r11, -#60]
 3f093c8:	e50b0034 	str	r0, [r11, -#52]
 3f093cc:	e59b9008 	ldr	r9, [r11, #8]
	char eccbuf[6];
	/* eblk (once set) is the start of the erase block containing the
	 * data being processed.
	 */
	unsigned long eblk = ~0;	/* force mismatch on first pass */
	unsigned long erasesize = nand->erasesize;
	unsigned long a;

	int pages_per_block = (nand->erasesize) / (nand->oobblock);
 3f093d0:	e51b2034 	ldr	r2, [r11, -#52]
 3f093d4:	e1a05003 	mov	r5, r3
 3f093d8:	e5907028 	ldr	r7, [r0, #40]
 3f093dc:	e3e03000 	mvn	r3, #0	; 0x0
 3f093e0:	e50b3040 	str	r3, [r11, -#64]
 3f093e4:	e1a0a001 	mov	r10, r1
 3f093e8:	e5926048 	ldr	r6, [r2, #72]
 3f093ec:	e1a00007 	mov	r0, r7
 3f093f0:	e1a01006 	mov	r1, r6
 3f093f4:	eb0027f9 	bl	3f133e0 <__udivsi3>
 3f093f8:	e50b0044 	str	r0, [r11, -#68]

	if (cmd & NANDRW_YAFFS)
 3f093fc:	e21a3008 	ands	r3, r10, #8	; 0x8
 3f09400:	e50b3048 	str	r3, [r11, -#72]
 3f09404:	0a000071 	beq	3f095d0 <nand_rw+0x228>
        {
		// len passed is yaffs image size (including oob_data).
		// modified to size except oob_data to work properly in u-boot
		int num_pages_yaffs = len / (nand->oobblock + nand->oobsize);
 3f09408:	e51b2034 	ldr	r2, [r11, -#52]
 3f0940c:	e592104c 	ldr	r1, [r2, #76]
 3f09410:	e1a00005 	mov	r0, r5
 3f09414:	e0861001 	add	r1, r6, r1
 3f09418:	eb0027f0 	bl	3f133e0 <__udivsi3>
		len = num_pages_yaffs << nand->page_shift;
 3f0941c:	e51b2034 	ldr	r2, [r11, -#52]
 3f09420:	e5923000 	ldr	r3, [r2]
 3f09424:	e1a05310 	mov	r5, r0, lsl r3
	}

        dprintf("nand_rw_0\n");
	while (len) {
 3f09428:	ea000068 	b	3f095d0 <nand_rw+0x228>
		if ((start & (-erasesize)) != eblk) {
 3f0942c:	e2673000 	rsb	r3, r7, #0	; 0x0
 3f09430:	e0046003 	and	r6, r4, r3
 3f09434:	e51b3040 	ldr	r3, [r11, -#64]
 3f09438:	e1560003 	cmp	r6, r3
 3f0943c:	0a000023 	beq	3f094d0 <nand_rw+0x128>
			/* have crossed into new erase block, deal with
			 * it if it is sure marked bad.
			 */
			eblk = start & (-erasesize); /* start of block */
 3f09440:	e50b6040 	str	r6, [r11, -#64]
			if (check_block(nand, eblk)) {
 3f09444:	e51b0034 	ldr	r0, [r11, -#52]
 3f09448:	e1a01006 	mov	r1, r6
 3f0944c:	ebffff8d 	bl	3f09288 <check_block>
 3f09450:	e3500000 	cmp	r0, #0	; 0x0
 3f09454:	0a00001d 	beq	3f094d0 <nand_rw+0x128>
				if (cmd == (NANDRW_READ | NANDRW_JFFS2)) {
 3f09458:	e35a0003 	cmp	r10, #3	; 0x3
 3f0945c:	1a000011 	bne	3f094a8 <nand_rw+0x100>
					while (len > 0 &&
					       start - eblk < erasesize) {
 3f09460:	e3550000 	cmp	r5, #0	; 0x0
 3f09464:	0a000059 	beq	3f095d0 <nand_rw+0x228>
 3f09468:	e51b2040 	ldr	r2, [r11, -#64]
 3f0946c:	e0623004 	rsb	r3, r2, r4
 3f09470:	e1530007 	cmp	r3, r7
 3f09474:	2a000055 	bcs	3f095d0 <nand_rw+0x228>
						*(buf++) = 0xff;
						++start;
 3f09478:	e2844001 	add	r4, r4, #1	; 0x1
						++total;
 3f0947c:	e51b303c 	ldr	r3, [r11, -#60]
 3f09480:	e2555001 	subs	r5, r5, #1	; 0x1
 3f09484:	e2833001 	add	r3, r3, #1	; 0x1
 3f09488:	e50b303c 	str	r3, [r11, -#60]
 3f0948c:	e3a030ff 	mov	r3, #255	; 0xff
 3f09490:	e4c93001 	strb	r3, [r9], #1
 3f09494:	0a00004d 	beq	3f095d0 <nand_rw+0x228>
 3f09498:	e0663004 	rsb	r3, r6, r4
 3f0949c:	e1530007 	cmp	r3, r7
 3f094a0:	3afffff4 	bcc	3f09478 <nand_rw+0xd0>
						--len;
					}
					continue;
 3f094a4:	ea000049 	b	3f095d0 <nand_rw+0x228>
				}
				else if (cmd == (NANDRW_READ | NANDRW_JFFS2 | NANDRW_JFFS2_SKIP)) {
 3f094a8:	e35a0007 	cmp	r10, #7	; 0x7
 3f094ac:	0a000002 	beq	3f094bc <nand_rw+0x114>
					start += erasesize;
					continue;
				}
				else if ((cmd == (NANDRW_WRITE | NANDRW_JFFS2)) || (cmd == (NANDRW_WRITE | NANDRW_YAFFS))) {
 3f094b0:	e35a0008 	cmp	r10, #8	; 0x8
 3f094b4:	135a0002 	cmpne	r10, #2	; 0x2
 3f094b8:	1a000001 	bne	3f094c4 <nand_rw+0x11c>
					/* skip bad block */
					start += erasesize;
 3f094bc:	e0844007 	add	r4, r4, r7
					continue;
 3f094c0:	ea000042 	b	3f095d0 <nand_rw+0x228>
				}
				else {
					ret = 1;
 3f094c4:	e3a02001 	mov	r2, #1	; 0x1
 3f094c8:	e50b2038 	str	r2, [r11, -#56]
					break;
 3f094cc:	ea000041 	b	3f095d8 <nand_rw+0x230>
				}
			}
		}
		/* The ECC will not be calculated correctly if
		   less than 512 is written or read */
		/* Is request at least 512 bytes AND it starts on a proper boundry */
		if((start != ROUND_DOWN(start, 0x200)) || (len < 0x200))
 3f094d0:	e3c43f7f 	bic	r3, r4, #508	; 0x1fc
 3f094d4:	e3c33003 	bic	r3, r3, #3	; 0x3
 3f094d8:	e3550c02 	cmp	r5, #512	; 0x200
 3f094dc:	21540003 	cmpcs	r4, r3
 3f094e0:	0a000001 	beq	3f094ec <nand_rw+0x144>
			printf("Warning block writes should be at least 512 bytes and start on a 512 byte boundry\n");
 3f094e4:	e59f0084 	ldr	r0, [pc, #84]	; 3f09570 <nand_rw+0x1c8>
 3f094e8:	eb000cd5 	bl	3f0c844 <printf>

	        dprintf("nand_rw_1\n");
		if (cmd & NANDRW_READ)
 3f094ec:	e21ac001 	ands	r12, r10, #1	; 0x1
 3f094f0:	0a00000c 	beq	3f09528 <nand_rw+0x180>
                {
		        dprintf("nand_rw_2\n");
			ret = nand_read_ecc(nand, start,
					   min(len, eblk + erasesize - start),
 3f094f4:	e51b0034 	ldr	r0, [r11, -#52]
 3f094f8:	e51b3040 	ldr	r3, [r11, -#64]
 3f094fc:	e1a01004 	mov	r1, r4
 3f09500:	e58d9000 	str	r9, [r13]
 3f09504:	e24bc02c 	sub	r12, r11, #44	; 0x2c
 3f09508:	e58dc004 	str	r12, [r13, #4]
 3f0950c:	e0832007 	add	r2, r3, r7
 3f09510:	e0642002 	rsb	r2, r4, r2
 3f09514:	e1520005 	cmp	r2, r5
 3f09518:	21a02005 	movcs	r2, r5
 3f0951c:	e24b3030 	sub	r3, r11, #48	; 0x30
 3f09520:	eb0001c8 	bl	3f09c48 <nand_read_ecc>
					   &n, (u_char*)buf, eccbuf);
                }
 3f09524:	ea00001e 	b	3f095a4 <nand_rw+0x1fc>
		else if (cmd & NANDRW_YAFFS)
 3f09528:	e51b2048 	ldr	r2, [r11, -#72]
 3f0952c:	e3520000 	cmp	r2, #0	; 0x0
 3f09530:	0a00000f 	beq	3f09574 <nand_rw+0x1cc>
		{
		       ret = nand_write_yaffs (nand, start,
                                          min(len, eblk + erasesize - start),
 3f09534:	e51b0034 	ldr	r0, [r11, -#52]
 3f09538:	e51b3040 	ldr	r3, [r11, -#64]
 3f0953c:	e58d9000 	str	r9, [r13]
 3f09540:	e1a01004 	mov	r1, r4
 3f09544:	e58dc004 	str	r12, [r13, #4]
 3f09548:	e0832007 	add	r2, r3, r7
 3f0954c:	e0642002 	rsb	r2, r4, r2
 3f09550:	e1520005 	cmp	r2, r5
 3f09554:	21a02005 	movcs	r2, r5
 3f09558:	e24b3030 	sub	r3, r11, #48	; 0x30
 3f0955c:	ebfffc9d 	bl	3f087d8 <nand_write_yaffs>
                                          &n, (u_char*)buf, NULL);

		/* yaffs image contains oob_data ( size : 16 Bytes in each page )
		   so buf pointer should be increased to point at data_buf of the next block. */
		buf += (pages_per_block << 4);
 3f09560:	e51b2044 	ldr	r2, [r11, -#68]
 3f09564:	e50b0038 	str	r0, [r11, -#56]
 3f09568:	e0899202 	add	r9, r9, r2, lsl #4
		}
 3f0956c:	ea00000d 	b	3f095a8 <nand_rw+0x200>
 3f09570:	03f1e134 	mvneqs	r14, #13	; 0xd
		else
                {
		        dprintf("nand_rw_3\n");                
			ret = nand_write_ecc(nand, start,
					    min(len, eblk + erasesize - start),
 3f09574:	e51b0034 	ldr	r0, [r11, -#52]
 3f09578:	e51b3040 	ldr	r3, [r11, -#64]
 3f0957c:	e1a01004 	mov	r1, r4
 3f09580:	e58d9000 	str	r9, [r13]
 3f09584:	e24bc02c 	sub	r12, r11, #44	; 0x2c
 3f09588:	e58dc004 	str	r12, [r13, #4]
 3f0958c:	e0832007 	add	r2, r3, r7
 3f09590:	e0642002 	rsb	r2, r4, r2
 3f09594:	e1520005 	cmp	r2, r5
 3f09598:	21a02005 	movcs	r2, r5
 3f0959c:	e24b3030 	sub	r3, r11, #48	; 0x30
 3f095a0:	eb00033e 	bl	3f0a2a0 <nand_write_ecc>
 3f095a4:	e50b0038 	str	r0, [r11, -#56]
					    &n, (u_char*)buf, eccbuf);
                }

		if (ret)
 3f095a8:	e51b2038 	ldr	r2, [r11, -#56]
 3f095ac:	e3520000 	cmp	r2, #0	; 0x0
 3f095b0:	1a000008 	bne	3f095d8 <nand_rw+0x230>
			break;

		start  += n;
 3f095b4:	e51b3030 	ldr	r3, [r11, -#48]
		buf   += n;
		total += n;
 3f095b8:	e51b203c 	ldr	r2, [r11, -#60]
 3f095bc:	e0844003 	add	r4, r4, r3
 3f095c0:	e0899003 	add	r9, r9, r3
 3f095c4:	e0822003 	add	r2, r2, r3
		len   -= n;
 3f095c8:	e0635005 	rsb	r5, r3, r5
 3f095cc:	e50b203c 	str	r2, [r11, -#60]
	}
 3f095d0:	e3550000 	cmp	r5, #0	; 0x0
 3f095d4:	1affff94 	bne	3f0942c <nand_rw+0x84>
	if (retlen)
 3f095d8:	e59b3004 	ldr	r3, [r11, #4]
 3f095dc:	e3530000 	cmp	r3, #0	; 0x0
		*retlen = total;
 3f095e0:	151b203c 	ldrne	r2, [r11, -#60]
 3f095e4:	15832000 	strne	r2, [r3]

	return ret;
 3f095e8:	e51b0038 	ldr	r0, [r11, -#56]
}
 3f095ec:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f095f0 <nand_print>:
 3f095f0:	e1a0c00d 	mov	r12, r13
 3f095f4:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}

static void nand_print(struct nand_chip *nand)
{
 3f095f8:	e1a04000 	mov	r4, r0
 3f095fc:	e24dd010 	sub	r13, r13, #16	; 0x10
	if (nand->numchips > 1) {
 3f09600:	e594e038 	ldr	r14, [r4, #56]
 3f09604:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f09608:	e35e0001 	cmp	r14, #1	; 0x1
 3f0960c:	da000013 	ble	3f09660 <nand_print+0x70>
		printf("%s at 0x%lx,\n"
 3f09610:	e59f0044 	ldr	r0, [pc, #44]	; 3f0965c <nand_print+0x6c>
 3f09614:	e2842020 	add	r2, r4, #32	; 0x20
 3f09618:	e892000c 	ldmia	r2, {r2, r3}
 3f0961c:	e2422014 	sub	r2, r2, #20	; 0x14
 3f09620:	e58d3000 	str	r3, [r13]
 3f09624:	e3a03001 	mov	r3, #1	; 0x1
 3f09628:	e1a03213 	mov	r3, r3, lsl r2
 3f0962c:	e58d3004 	str	r3, [r13, #4]
 3f09630:	e5941034 	ldr	r1, [r4, #52]
 3f09634:	e2842040 	add	r2, r4, #64	; 0x40
 3f09638:	e892000c 	ldmia	r2, {r2, r3}
 3f0963c:	e594c028 	ldr	r12, [r4, #40]
 3f09640:	e1a03a23 	mov	r3, r3, lsr #20
 3f09644:	e1a0c52c 	mov	r12, r12, lsr #10
 3f09648:	e58d3008 	str	r3, [r13, #8]
 3f0964c:	e1a0300e 	mov	r3, r14
 3f09650:	e58dc00c 	str	r12, [r13, #12]
 3f09654:	eb000c7a 	bl	3f0c844 <printf>
		       "\t  %d chips %s, size %d MB, \n"
		       "\t  total size %ld MB, sector size %ld kB\n",
		       nand->name, nand->IO_ADDR, nand->numchips,
		       nand->chips_name, 1 << (nand->chipshift - 20),
		       nand->totlen >> 20, nand->erasesize >> 10);
	}
 3f09658:	ea00000e 	b	3f09698 <nand_print+0xa8>
 3f0965c:	03f1e188 	mvneqs	r14, #34	; 0x22
	else {
		printf("%s at 0x%lx (", nand->chips_name, nand->IO_ADDR);
 3f09660:	e59f0024 	ldr	r0, [pc, #24]	; 3f0968c <nand_print+0x9c>
 3f09664:	e5941024 	ldr	r1, [r4, #36]
 3f09668:	e5942040 	ldr	r2, [r4, #64]
 3f0966c:	eb000c74 	bl	3f0c844 <printf>
		print_size(nand->totlen, ", ");
 3f09670:	e5940044 	ldr	r0, [r4, #68]
 3f09674:	e59f1014 	ldr	r1, [pc, #14]	; 3f09690 <nand_print+0xa0>
 3f09678:	eb001647 	bl	3f0ef9c <print_size>
		print_size(nand->erasesize, " sector)\n");
 3f0967c:	e5940028 	ldr	r0, [r4, #40]
 3f09680:	e59f100c 	ldr	r1, [pc, #c]	; 3f09694 <nand_print+0xa4>
 3f09684:	eb001644 	bl	3f0ef9c <print_size>
 3f09688:	ea000002 	b	3f09698 <nand_print+0xa8>
 3f0968c:	03f1e1dc 	mvneqs	r14, #55	; 0x37
 3f09690:	03f1e1ec 	mvneqs	r14, #59	; 0x3b
 3f09694:	03f1e1f0 	mvneqs	r14, #60	; 0x3c
	}
 3f09698:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f0969c <NanD_WaitReady>:
 3f0969c:	e1a0c00d 	mov	r12, r13
 3f096a0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f096a4:	e24cb004 	sub	r11, r12, #4	; 0x4
}

/* ------------------------------------------------------------------------- */

static int NanD_WaitReady(struct nand_chip *nand, int ale_wait)
{
	/* This is inline, to optimise the common case, where it's ready instantly */
	int ret = 0;

#ifdef NAND_NO_RB	/* in config file, shorter delays currently wrap accesses */
	if(ale_wait)
		NAND_WAIT_READY(nand);	/* do the worst case 25us wait */
	else
		udelay(10);
#else	/* has functional r/b signal */
        dprintf("NanD_WaitReady 1 \n");
	NAND_WAIT_READY(nand);
 3f096a8:	e59f3028 	ldr	r3, [pc, #28]	; 3f096d8 <NanD_WaitReady+0x3c>
 3f096ac:	e1d330b0 	ldrh	r3, [r3]
 3f096b0:	e2033902 	and	r3, r3, #32768	; 0x8000
 3f096b4:	e3530000 	cmp	r3, #0	; 0x0
 3f096b8:	13a03902 	movne	r3, #32768	; 0x8000
 3f096bc:	03a03000 	moveq	r3, #0	; 0x0
 3f096c0:	e3530000 	cmp	r3, #0	; 0x0
 3f096c4:	0afffff7 	beq	3f096a8 <NanD_WaitReady+0xc>
        udelay(1000);
 3f096c8:	e3a00ffa 	mov	r0, #1000	; 0x3e8
 3f096cc:	ebffdc51 	bl	3f00818 <udelay>
#endif
	return ret;
 3f096d0:	e3a00000 	mov	r0, #0	; 0x0
}
 3f096d4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f096d8:	c0003a3a 	andgt	r3, r0, r10, lsr r10

03f096dc <NanD_Address>:
 3f096dc:	e1a0c00d 	mov	r12, r13
 3f096e0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f096e4:	e24cb004 	sub	r11, r12, #4	; 0x4

/* NanD_Command: Send a flash command to the flash chip */

static inline int NanD_Command(struct nand_chip *nand, unsigned char command)
{
	unsigned long nandptr = nand->IO_ADDR;

	/* Assert the CLE (Command Latch Enable) line to the flash chip */
	NAND_CTL_SETCLE(nandptr);

	/* Send the command */
	WRITE_NAND_COMMAND(command, nandptr);

	/* Lower the CLE line */
	NAND_CTL_CLRCLE(nandptr);

#ifdef NAND_NO_RB
	if(command == NAND_CMD_RESET){
		u_char ret_val;
		NanD_Command(nand, NAND_CMD_STATUS);
		do{
			ret_val = READ_NAND(nandptr);/* wait till ready */
		} while((ret_val & 0x40) != 0x40);
	}
#endif
#ifdef CONFIG_MMSP20 
        return 0;
#else
	return NanD_WaitReady(nand, 0);
#endif
}

/* NanD_Address: Set the current address for the flash chip */

// NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
static int NanD_Address(struct nand_chip *nand, int numbytes, unsigned long ofs)
{
 3f096e8:	e1a0c002 	mov	r12, r2
	unsigned long nandptr;
	int i;

	nandptr = nand->IO_ADDR;

	/* Assert the ALE (Address Latch Enable) line to the flash chip */
	NAND_CTL_SETALE(nandptr);

	/* Send the address */
	/* Devices with 256-byte page are addressed as:
	 * Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
	 * there is no device on the market with page256
	 * and more than 24 bits.
	 * Devices with 512-byte page are addressed as:
	 * Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
	 * 25-31 is sent only if the chip support it.
	 * bit 8 changes the read command to be sent
	 * (NAND_CMD_READ0 or NAND_CMD_READ1).
	 */

        /* NanD_Address(nand, ADDR_COLUMN, 0); read id  addressing */
	if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE)
 3f096ec:	e3510003 	cmp	r1, #3	; 0x3
 3f096f0:	13510001 	cmpne	r1, #1	; 0x1
        {
        	//printf("nand_addressing 0: 0x%02x\n", ofs);
		WRITE_NAND_ADDRESS(ofs, nandptr);
 3f096f4:	059f304c 	ldreq	r3, [pc, #4c]	; 3f09748 <NanD_Address+0x6c>
 3f096f8:	05c3c000 	streqb	r12, [r3]
        }

        // udelay(10000);
        // dprintf("nandaddress_0 ofs: %x, page_shift: %d, pageadrlen: %d\n", ofs, nand->page_shift, nand->pageadrlen);
	ofs = ofs >> nand->page_shift;

	if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE)
 3f096fc:	e2413002 	sub	r3, r1, #2	; 0x2
 3f09700:	e5902000 	ldr	r2, [r0]
 3f09704:	e3530001 	cmp	r3, #1	; 0x1
 3f09708:	e1a0c23c 	mov	r12, r12, lsr r2
 3f0970c:	8a00000a 	bhi	3f0973c <NanD_Address+0x60>
        {
		for (i = 0; i < nand->pageadrlen; i++, ofs = ofs >> 8)
 3f09710:	e5d0303d 	ldrb	r3, [r0, #61]
 3f09714:	e3a02000 	mov	r2, #0	; 0x0
 3f09718:	e1520003 	cmp	r2, r3
 3f0971c:	aa000006 	bge	3f0973c <NanD_Address+0x60>
                {
                        //printf("nand_addressing 1: 0x%02x\n", ofs);
			WRITE_NAND_ADDRESS(ofs, nandptr);
 3f09720:	e59f3020 	ldr	r3, [pc, #20]	; 3f09748 <NanD_Address+0x6c>
 3f09724:	e5c3c000 	strb	r12, [r3]
 3f09728:	e2822001 	add	r2, r2, #1	; 0x1
 3f0972c:	e5d0303d 	ldrb	r3, [r0, #61]
 3f09730:	e1a0c42c 	mov	r12, r12, lsr #8
 3f09734:	e1520003 	cmp	r2, r3
 3f09738:	bafffff8 	blt	3f09720 <NanD_Address+0x44>
                }
        }

	/* Lower the ALE line */
	NAND_CTL_CLRALE(nandptr);

	/* Wait for the chip to respond */
	return NanD_WaitReady(nand, 1);
 3f0973c:	e3a01001 	mov	r1, #1	; 0x1
 3f09740:	ebffffd5 	bl	3f0969c <NanD_WaitReady>
}
 3f09744:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f09748:	9c000018 	stcls	0, cr0, [r0], -#96

03f0974c <NanD_OnlyAddress>:
 3f0974c:	e1a0c00d 	mov	r12, r13
 3f09750:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f09754:	e24cb004 	sub	r11, r12, #4	; 0x4

#ifdef CONFIG_MMSP20
static int NanD_OnlyAddress(struct nand_chip *nand, int numbytes, unsigned long ofs)
{
 3f09758:	e1a0c002 	mov	r12, r2
	unsigned long nandptr;
	int i;

	nandptr = nand->IO_ADDR;

	/* Assert the ALE (Address Latch Enable) line to the flash chip */
	NAND_CTL_SETALE(nandptr);

	/* Send the address */
	/* Devices with 256-byte page are addressed as:
	 * Column (bits 0-7), Page (bits 8-15, 16-23, 24-31)
	 * there is no device on the market with page256
	 * and more than 24 bits.
	 * Devices with 512-byte page are addressed as:
	 * Column (bits 0-7), Page (bits 9-16, 17-24, 25-31)
	 * 25-31 is sent only if the chip support it.
	 * bit 8 changes the read command to be sent
	 * (NAND_CMD_READ0 or NAND_CMD_READ1).
	 */

        /* NanD_Address(nand, ADDR_COLUMN, 0); read id  addressing */
	if (numbytes == ADDR_COLUMN || numbytes == ADDR_COLUMN_PAGE)
 3f0975c:	e3510003 	cmp	r1, #3	; 0x3
 3f09760:	13510001 	cmpne	r1, #1	; 0x1
        {
        	//printf("nand_addressing 0: 0x%02x\n", ofs);
		WRITE_NAND_ADDRESS(ofs, nandptr);
 3f09764:	059f3048 	ldreq	r3, [pc, #48]	; 3f097b4 <NanD_OnlyAddress+0x68>
 3f09768:	05c3c000 	streqb	r12, [r3]
        }

        dprintf("nand-onlyaddress_0 ofs: %x, page_shift: %d, pageadrlen: %d\n", ofs, nand->page_shift, nand->pageadrlen);
	ofs = ofs >> nand->page_shift;

	if (numbytes == ADDR_PAGE || numbytes == ADDR_COLUMN_PAGE)
 3f0976c:	e2413002 	sub	r3, r1, #2	; 0x2
 3f09770:	e5902000 	ldr	r2, [r0]
 3f09774:	e3530001 	cmp	r3, #1	; 0x1
 3f09778:	e1a0c23c 	mov	r12, r12, lsr r2
 3f0977c:	8a00000a 	bhi	3f097ac <NanD_OnlyAddress+0x60>
        {
		for (i = 0; i < nand->pageadrlen; i++, ofs = ofs >> 8)
 3f09780:	e5d0303d 	ldrb	r3, [r0, #61]
 3f09784:	e3a02000 	mov	r2, #0	; 0x0
 3f09788:	e1520003 	cmp	r2, r3
 3f0978c:	aa000006 	bge	3f097ac <NanD_OnlyAddress+0x60>
                {
                        //printf("nand_addressing 1: 0x%02x\n", ofs);
			WRITE_NAND_ADDRESS(ofs, nandptr);
 3f09790:	e59f301c 	ldr	r3, [pc, #1c]	; 3f097b4 <NanD_OnlyAddress+0x68>
 3f09794:	e5c3c000 	strb	r12, [r3]
 3f09798:	e2822001 	add	r2, r2, #1	; 0x1
 3f0979c:	e5d0303d 	ldrb	r3, [r0, #61]
 3f097a0:	e1a0c42c 	mov	r12, r12, lsr #8
 3f097a4:	e1520003 	cmp	r2, r3
 3f097a8:	bafffff8 	blt	3f09790 <NanD_OnlyAddress+0x44>
                }
        }

	/* Lower the ALE line */
	NAND_CTL_CLRALE(nandptr);


	/* Wait for the chip to respond */
	return 0;
 3f097ac:	e3a00000 	mov	r0, #0	; 0x0
}
 3f097b0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f097b4:	9c000018 	stcls	0, cr0, [r0], -#96

03f097b8 <NanD_IdentChip>:
 3f097b8:	e1a0c00d 	mov	r12, r13
 3f097bc:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f097c0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f097c4:	e24dd008 	sub	r13, r13, #8	; 0x8
#endif


/* NanD_SelectChip: Select a given flash chip within the current floor */
static inline int NanD_SelectChip(struct nand_chip *nand, int chip)
{
	/* Wait for it to be ready */
	return NanD_WaitReady(nand, 0);
}

/* NanD_IdentChip: Identify a given NAND chip given {floor,chip} */
static int NanD_IdentChip(struct nand_chip *nand, int floor, int chip)
{
 3f097c8:	e50b1028 	str	r1, [r11, -#40]
 3f097cc:	e50b202c 	str	r2, [r11, -#44]
 3f097d0:	e1a07000 	mov	r7, r0
	int mfr, id, i;

	dprintf("NanD_IdentChip 0\n");
	NAND_ENABLE_CE(nand);  /* set pin low */
 3f097d4:	e59f41d0 	ldr	r4, [pc, #1d0]	; 3f099ac <NanD_IdentChip+0x1f4>
 3f097d8:	e1d430b0 	ldrh	r3, [r4]
 3f097dc:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f097e0:	e1c430b0 	strh	r3, [r4]
 3f097e4:	e1d430b0 	ldrh	r3, [r4]
 3f097e8:	e3833080 	orr	r3, r3, #128	; 0x80
 3f097ec:	e1c430b0 	strh	r3, [r4]
 3f097f0:	e3a030ff 	mov	r3, #255	; 0xff
 3f097f4:	e59f51b4 	ldr	r5, [pc, #1b4]	; 3f099b0 <NanD_IdentChip+0x1f8>
 3f097f8:	e5c53000 	strb	r3, [r5]
 3f097fc:	e3a09000 	mov	r9, #0	; 0x0
	/* Reset the chip */
	if (NanD_Command(nand, NAND_CMD_RESET)) {
#ifdef NAND_DEBUG
		printf("NanD_Command (reset) for %d,%d returned true\n",
		       floor, chip);
#endif
		NAND_DISABLE_CE(nand);  /* set pin high */
		return 0;
	}

        #if 1
        NanD_WaitReady(nand, 0);
 3f09800:	e1a01009 	mov	r1, r9
 3f09804:	ebffffa4 	bl	3f0969c <NanD_WaitReady>
        NAND_DISABLE_CE(0);
 3f09808:	e1d430b0 	ldrh	r3, [r4]
 3f0980c:	e3e06080 	mvn	r6, #128	; 0x80
 3f09810:	e0033006 	and	r3, r3, r6
 3f09814:	e1c430b0 	strh	r3, [r4]
 3f09818:	e1d430b0 	ldrh	r3, [r4]
 3f0981c:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f09820:	e1c430b0 	strh	r3, [r4]
	NAND_ENABLE_CE(nand);  /* set pin low */
 3f09824:	e1d430b0 	ldrh	r3, [r4]
 3f09828:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0982c:	e1c430b0 	strh	r3, [r4]
 3f09830:	e1d430b0 	ldrh	r3, [r4]
 3f09834:	e3833080 	orr	r3, r3, #128	; 0x80
 3f09838:	e1c430b0 	strh	r3, [r4]
 3f0983c:	e3a03090 	mov	r3, #144	; 0x90
 3f09840:	e5c53000 	strb	r3, [r5]
        #endif

	dprintf("NanD_IdentChip 1\n");
	/* Read the NAND chip ID: 1. Send ReadID command */
	if (NanD_Command(nand, NAND_CMD_READID)) {
#ifdef NAND_DEBUG
		printf("NanD_Command (ReadID) for %d,%d returned true\n",
		       floor, chip);
#endif
		NAND_DISABLE_CE(nand);  /* set pin high */
		return 0;
	}

	dprintf("NanD_IdentChip 2\n");
	/* Read the NAND chip ID: 2. Send address byte zero */
#ifdef CONFIG_MMSP20
	NanD_OnlyAddress(nand, ADDR_COLUMN, 0);
 3f09844:	e1a00007 	mov	r0, r7
 3f09848:	e3a01001 	mov	r1, #1	; 0x1
 3f0984c:	e1a02009 	mov	r2, r9
 3f09850:	ebffffbd 	bl	3f0974c <NanD_OnlyAddress>
#else
	NanD_Address(nand, ADDR_COLUMN, 0);
#endif

	/* Read the manufacturer and device id codes from the device */

	dprintf("NanD_IdentChip 3, \n");
	mfr = READ_NAND(nand->IO_ADDR);
 3f09854:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f09858:	e5d32000 	ldrb	r2, [r3]

	id = READ_NAND(nand->IO_ADDR);
 3f0985c:	e5d33000 	ldrb	r3, [r3]
 3f09860:	e20250ff 	and	r5, r2, #255	; 0xff
 3f09864:	e203a0ff 	and	r10, r3, #255	; 0xff

	NAND_DISABLE_CE(nand);  /* set pin high */
 3f09868:	e1d430b0 	ldrh	r3, [r4]
 3f0986c:	e0033006 	and	r3, r3, r6
 3f09870:	e1c430b0 	strh	r3, [r4]
 3f09874:	e1d430b0 	ldrh	r3, [r4]
 3f09878:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0987c:	e1c430b0 	strh	r3, [r4]
	/* No response - return failure */
	if (mfr == 0xff || mfr == 0) {
 3f09880:	e1550009 	cmp	r5, r9
 3f09884:	135500ff 	cmpne	r5, #255	; 0xff
 3f09888:	1a000004 	bne	3f098a0 <NanD_IdentChip+0xe8>
#ifdef NAND_DEBUG
		printf("NanD_Command (ReadID) got %d %d\n", mfr, id);
 3f0988c:	e1a01005 	mov	r1, r5
 3f09890:	e59f011c 	ldr	r0, [pc, #11c]	; 3f099b4 <NanD_IdentChip+0x1fc>
 3f09894:	e1a0200a 	mov	r2, r10
 3f09898:	eb000be9 	bl	3f0c844 <printf>
#endif
		return 0;
 3f0989c:	ea000051 	b	3f099e8 <NanD_IdentChip+0x230>
	}

	/* Check it's the same as the first chip we identified.
	 * M-Systems say that any given nand_chip device should only
	 * contain _one_ type of flash part, although that's not a
	 * hardware restriction. */
	if (nand->mfr) {
 3f098a0:	e597302c 	ldr	r3, [r7, #44]
 3f098a4:	e3530000 	cmp	r3, #0	; 0x0
 3f098a8:	0a000009 	beq	3f098d4 <NanD_IdentChip+0x11c>
		if (nand->mfr == mfr && nand->id == id)
 3f098ac:	e1530005 	cmp	r3, r5
 3f098b0:	1a000003 	bne	3f098c4 <NanD_IdentChip+0x10c>
 3f098b4:	e5973030 	ldr	r3, [r7, #48]
 3f098b8:	e153000a 	cmp	r3, r10
			return 1;	/* This is another the same the first */
 3f098bc:	03a00001 	moveq	r0, #1	; 0x1
 3f098c0:	0a000049 	beq	3f099ec <NanD_IdentChip+0x234>
		else
			printf("Flash chip at floor %d, chip %d is different:\n",
 3f098c4:	e51b1028 	ldr	r1, [r11, -#40]
 3f098c8:	e59f00e8 	ldr	r0, [pc, #e8]	; 3f099b8 <NanD_IdentChip+0x200>
 3f098cc:	e51b202c 	ldr	r2, [r11, -#44]
 3f098d0:	eb000bdb 	bl	3f0c844 <printf>
			       floor, chip);
	}

	/* Print and store the manufacturer and ID codes. */
	for (i = 0; nand_flash_ids[i].name != NULL; i++) {
 3f098d4:	e59f20e0 	ldr	r2, [pc, #e0]	; 3f099bc <NanD_IdentChip+0x204>
 3f098d8:	e3a01000 	mov	r1, #0	; 0x0
 3f098dc:	e7923001 	ldr	r3, [r2, r1]
 3f098e0:	e1a06002 	mov	r6, r2
 3f098e4:	e1530001 	cmp	r3, r1
 3f098e8:	0a00003a 	beq	3f099d8 <NanD_IdentChip+0x220>
 3f098ec:	e1a04001 	mov	r4, r1
 3f098f0:	e1a09002 	mov	r9, r2
		if (mfr == nand_flash_ids[i].manufacture_id &&
 3f098f4:	e2863004 	add	r3, r6, #4	; 0x4
 3f098f8:	e7933004 	ldr	r3, [r3, r4]
 3f098fc:	e1550003 	cmp	r5, r3
 3f09900:	1a00002f 	bne	3f099c4 <NanD_IdentChip+0x20c>
 3f09904:	e2863008 	add	r3, r6, #8	; 0x8
 3f09908:	e7933004 	ldr	r3, [r3, r4]
 3f0990c:	e15a0003 	cmp	r10, r3
 3f09910:	1a00002b 	bne	3f099c4 <NanD_IdentChip+0x20c>
		    id == nand_flash_ids[i].model_id) {
#ifdef NAND_DEBUG
			printf("Flash chip found:\n\t Manufacturer ID: 0x%2.2X, "
 3f09914:	e59f00a4 	ldr	r0, [pc, #a4]	; 3f099c0 <NanD_IdentChip+0x208>
 3f09918:	e1a01005 	mov	r1, r5
 3f0991c:	e7943006 	ldr	r3, [r4, r6]
 3f09920:	e1a0200a 	mov	r2, r10
 3f09924:	eb000bc6 	bl	3f0c844 <printf>
			       "Chip ID: 0x%2.2X (%s)\n", mfr, id,
			       nand_flash_ids[i].name);
#endif
			if (!nand->mfr) {
 3f09928:	e597302c 	ldr	r3, [r7, #44]
 3f0992c:	e3530000 	cmp	r3, #0	; 0x0
 3f09930:	1a00002c 	bne	3f099e8 <NanD_IdentChip+0x230>
				nand->mfr = mfr;
 3f09934:	e587502c 	str	r5, [r7, #44]
				nand->id = id;
 3f09938:	e587a030 	str	r10, [r7, #48]
				nand->chipshift =
 3f0993c:	e286300c 	add	r3, r6, #12	; 0xc
 3f09940:	e7933004 	ldr	r3, [r3, r4]
 3f09944:	e5873020 	str	r3, [r7, #32]
				    nand_flash_ids[i].chipshift;
				nand->page256 = nand_flash_ids[i].page256;
 3f09948:	e3a01010 	mov	r1, #16	; 0x10
 3f0994c:	e7d93001 	ldrb	r3, [r9, r1]
				nand->eccsize = 256;
 3f09950:	e3a02c01 	mov	r2, #256	; 0x100
 3f09954:	e5872050 	str	r2, [r7, #80]
				if (nand->page256) {
 3f09958:	e31300ff 	tst	r3, #255	; 0xff
 3f0995c:	e5c7303c 	strb	r3, [r7, #60]
					nand->oobblock = 256;
 3f09960:	15872048 	strne	r2, [r7, #72]
					nand->oobsize = 8;
 3f09964:	13a03008 	movne	r3, #8	; 0x8
 3f09968:	1587304c 	strne	r3, [r7, #76]
					nand->page_shift = 8;
				} else {
					nand->oobblock = 512;
 3f0996c:	03a03c02 	moveq	r3, #512	; 0x200
 3f09970:	05873048 	streq	r3, [r7, #72]
					nand->oobsize = 16;
 3f09974:	0587104c 	streq	r1, [r7, #76]
					nand->page_shift = 9;
 3f09978:	03a03009 	moveq	r3, #9	; 0x9
 3f0997c:	e5873000 	str	r3, [r7]
				}
				nand->pageadrlen =
 3f09980:	e59f2034 	ldr	r2, [pc, #34]	; 3f099bc <NanD_IdentChip+0x204>
 3f09984:	e0843002 	add	r3, r4, r2
 3f09988:	e5d33011 	ldrb	r3, [r3, #17]
 3f0998c:	e5c7303d 	strb	r3, [r7, #61]
				    nand_flash_ids[i].pageadrlen;
				nand->erasesize =
 3f09990:	e2823014 	add	r3, r2, #20	; 0x14
 3f09994:	e7933004 	ldr	r3, [r3, r4]
 3f09998:	e5873028 	str	r3, [r7, #40]
				    nand_flash_ids[i].erasesize;
				nand->chips_name =
 3f0999c:	e7923004 	ldr	r3, [r2, r4]
				    nand_flash_ids[i].name;
				return 1;
 3f099a0:	e3a00001 	mov	r0, #1	; 0x1
 3f099a4:	e5873024 	str	r3, [r7, #36]
 3f099a8:	ea00000f 	b	3f099ec <NanD_IdentChip+0x234>
 3f099ac:	c0003a3a 	andgt	r3, r0, r10, lsr r10
 3f099b0:	9c000010 	stcls	0, cr0, [r0], -#64
 3f099b4:	03f1e25c 	mvneqs	r14, #-1073741819	; 0xc0000005
 3f099b8:	03f1e280 	mvneqs	r14, #8	; 0x8
 3f099bc:	03f2060c 	mvneqs	r0, #12582912	; 0xc00000
 3f099c0:	03f1e2b0 	mvneqs	r14, #11	; 0xb
 3f099c4:	e2844018 	add	r4, r4, #24	; 0x18
 3f099c8:	e7963004 	ldr	r3, [r6, r4]
 3f099cc:	e2899018 	add	r9, r9, #24	; 0x18
 3f099d0:	e3530000 	cmp	r3, #0	; 0x0
 3f099d4:	1affffc6 	bne	3f098f4 <NanD_IdentChip+0x13c>
			}
			return 0;
		}
	}


#ifdef NAND_DEBUG
	/* We haven't fully identified the chip. Print as much as we know. */
	printf("Unknown flash chip found: %2.2X %2.2X\n",
 3f099d8:	e1a0100a 	mov	r1, r10
 3f099dc:	e59f000c 	ldr	r0, [pc, #c]	; 3f099f0 <NanD_IdentChip+0x238>
 3f099e0:	e1a02005 	mov	r2, r5
 3f099e4:	eb000b96 	bl	3f0c844 <printf>
	       id, mfr);
#endif

	return 0;
 3f099e8:	e3a00000 	mov	r0, #0	; 0x0
 3f099ec:	ea000000 	b	3f099f4 <NanD_IdentChip+0x23c>
 3f099f0:	03f1e2f8 	mvneqs	r14, #-2147483633	; 0x8000000f
}
 3f099f4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f099f8 <NanD_ScanChips>:
 3f099f8:	e1a0c00d 	mov	r12, r13
 3f099fc:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f09a00:	e24cb004 	sub	r11, r12, #4	; 0x4

/* NanD_ScanChips: Find all NAND chips present in a nand_chip, and identify them */

static void NanD_ScanChips(struct nand_chip *nand)
{
	int floor, chip;
	int numchips[NAND_MAX_FLOORS];
	int maxchips = NAND_MAX_CHIPS;
	int ret = 1;
 3f09a04:	e3a09001 	mov	r9, #1	; 0x1
 3f09a08:	e1a04000 	mov	r4, r0

	nand->numchips = 0;
 3f09a0c:	e3a03000 	mov	r3, #0	; 0x0
 3f09a10:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f09a14:	e5843038 	str	r3, [r4, #56]
	nand->mfr = 0;
	nand->id = 0;


	/* For each floor, find the number of valid chips it contains */
	for (floor = 0; floor < NAND_MAX_FLOORS; floor++)
 3f09a18:	e1a07003 	mov	r7, r3
 3f09a1c:	e584302c 	str	r3, [r4, #44]
 3f09a20:	e1a0a007 	mov	r10, r7
 3f09a24:	e5843030 	str	r3, [r4, #48]
        {
		ret = 1;
		numchips[floor] = 0;
 3f09a28:	e3a03000 	mov	r3, #0	; 0x0
		for (chip = 0; chip < maxchips && ret != 0; chip++)
 3f09a2c:	e1a06003 	mov	r6, r3
 3f09a30:	e1560009 	cmp	r6, r9
 3f09a34:	e24b5028 	sub	r5, r11, #40	; 0x28
 3f09a38:	e78a3005 	str	r3, [r10, r5]
 3f09a3c:	aa00000f 	bge	3f09a80 <NanD_ScanChips+0x88>
                {

			//dprintf("NanD_ScanChips 2\n");
			ret = NanD_IdentChip(nand, floor, chip);
 3f09a40:	e1a00004 	mov	r0, r4
 3f09a44:	e1a01007 	mov	r1, r7
 3f09a48:	e1a02006 	mov	r2, r6
 3f09a4c:	ebffff59 	bl	3f097b8 <NanD_IdentChip>
			if (ret) {
 3f09a50:	e3500000 	cmp	r0, #0	; 0x0
 3f09a54:	0a000005 	beq	3f09a70 <NanD_ScanChips+0x78>
				numchips[floor]++;
 3f09a58:	e79a3005 	ldr	r3, [r10, r5]
				nand->numchips++;
 3f09a5c:	e5942038 	ldr	r2, [r4, #56]
 3f09a60:	e2833001 	add	r3, r3, #1	; 0x1
 3f09a64:	e78a3005 	str	r3, [r10, r5]
 3f09a68:	e2822001 	add	r2, r2, #1	; 0x1
 3f09a6c:	e5842038 	str	r2, [r4, #56]
 3f09a70:	e2866001 	add	r6, r6, #1	; 0x1
 3f09a74:	e3500000 	cmp	r0, #0	; 0x0
 3f09a78:	11560009 	cmpne	r6, r9
 3f09a7c:	baffffef 	blt	3f09a40 <NanD_ScanChips+0x48>
 3f09a80:	e28aa004 	add	r10, r10, #4	; 0x4
 3f09a84:	e2877001 	add	r7, r7, #1	; 0x1
 3f09a88:	e3570000 	cmp	r7, #0	; 0x0
 3f09a8c:	daffffe5 	ble	3f09a28 <NanD_ScanChips+0x30>
			}
		}
	}

	/* If there are none at all that we recognise, bail */
	if (!nand->numchips) {
 3f09a90:	e5943038 	ldr	r3, [r4, #56]
 3f09a94:	e3530000 	cmp	r3, #0	; 0x0
 3f09a98:	1a000002 	bne	3f09aa8 <NanD_ScanChips+0xb0>
#ifdef NAND_DEBUG
		puts ("No NAND flash chips recognised.\n");
 3f09a9c:	e59f0028 	ldr	r0, [pc, #28]	; 3f09acc <NanD_ScanChips+0xd4>
 3f09aa0:	eb000b5a 	bl	3f0c810 <puts>
#endif
		return;
 3f09aa4:	ea000033 	b	3f09b78 <NanD_ScanChips+0x180>
	}

	/* Allocate an array to hold the information for each chip */
	nand->chips = malloc(sizeof(struct Nand) * nand->numchips);
 3f09aa8:	e0830083 	add	r0, r3, r3, lsl #1
 3f09aac:	e1a00100 	mov	r0, r0, lsl #2
 3f09ab0:	eb000d16 	bl	3f0cf10 <malloc>
	if (!nand->chips) {
 3f09ab4:	e3500000 	cmp	r0, #0	; 0x0
 3f09ab8:	e584001c 	str	r0, [r4, #28]
 3f09abc:	1a000004 	bne	3f09ad4 <NanD_ScanChips+0xdc>
		puts ("No memory for allocating chip info structures\n");
 3f09ac0:	e59f0008 	ldr	r0, [pc, #8]	; 3f09ad0 <NanD_ScanChips+0xd8>
 3f09ac4:	eb000b51 	bl	3f0c810 <puts>
		return;
 3f09ac8:	ea00002a 	b	3f09b78 <NanD_ScanChips+0x180>
 3f09acc:	03f1e320 	mvneqs	r14, #-2147483648	; 0x80000000
 3f09ad0:	03f1e344 	mvneqs	r14, #268435457	; 0x10000001
	}

	ret = 0;
 3f09ad4:	e3a07000 	mov	r7, #0	; 0x0

	/* Fill out the chip array with {floor, chipno} for each
	 * detected chip in the device. */
	for (floor = 0; floor < NAND_MAX_FLOORS; floor++) {
 3f09ad8:	e1a00007 	mov	r0, r7
		for (chip = 0; chip < numchips[floor]; chip++) {
 3f09adc:	e1a0e107 	mov	r14, r7, lsl #2
 3f09ae0:	e24bc028 	sub	r12, r11, #40	; 0x28
 3f09ae4:	e79e300c 	ldr	r3, [r14, r12]
 3f09ae8:	e3a06000 	mov	r6, #0	; 0x0
 3f09aec:	e1560003 	cmp	r6, r3
 3f09af0:	aa000013 	bge	3f09b44 <NanD_ScanChips+0x14c>
 3f09af4:	e1a01000 	mov	r1, r0
			nand->chips[ret].floor = floor;
 3f09af8:	e594301c 	ldr	r3, [r4, #28]
 3f09afc:	e7c17003 	strb	r7, [r1, r3]
			nand->chips[ret].chip = chip;
 3f09b00:	e594301c 	ldr	r3, [r4, #28]
 3f09b04:	e0813003 	add	r3, r1, r3
 3f09b08:	e5c36001 	strb	r6, [r3, #1]
			nand->chips[ret].curadr = 0;
 3f09b0c:	e594301c 	ldr	r3, [r4, #28]
 3f09b10:	e3a02000 	mov	r2, #0	; 0x0
 3f09b14:	e0813003 	add	r3, r1, r3
 3f09b18:	e5832004 	str	r2, [r3, #4]
			nand->chips[ret].curmode = 0x50;
			ret++;
 3f09b1c:	e280000c 	add	r0, r0, #12	; 0xc
 3f09b20:	e594301c 	ldr	r3, [r4, #28]
 3f09b24:	e2822050 	add	r2, r2, #80	; 0x50
 3f09b28:	e0813003 	add	r3, r1, r3
 3f09b2c:	e5c32008 	strb	r2, [r3, #8]
 3f09b30:	e2866001 	add	r6, r6, #1	; 0x1
 3f09b34:	e79e300c 	ldr	r3, [r14, r12]
 3f09b38:	e281100c 	add	r1, r1, #12	; 0xc
 3f09b3c:	e1560003 	cmp	r6, r3
 3f09b40:	baffffec 	blt	3f09af8 <NanD_ScanChips+0x100>
 3f09b44:	e2877001 	add	r7, r7, #1	; 0x1
 3f09b48:	e3570000 	cmp	r7, #0	; 0x0
 3f09b4c:	daffffe2 	ble	3f09adc <NanD_ScanChips+0xe4>
		}
	}

	/* Calculate and print the total size of the device */
	nand->totlen = nand->numchips * (1 << nand->chipshift);

#ifdef NAND_DEBUG
	printf("%d flash chips found. Total nand_chip size: %ld MB\n",
 3f09b50:	e59f001c 	ldr	r0, [pc, #1c]	; 3f09b74 <NanD_ScanChips+0x17c>
 3f09b54:	e5943038 	ldr	r3, [r4, #56]
 3f09b58:	e5942020 	ldr	r2, [r4, #32]
 3f09b5c:	e1a01003 	mov	r1, r3
 3f09b60:	e1a03213 	mov	r3, r3, lsl r2
 3f09b64:	e1a02a23 	mov	r2, r3, lsr #20
 3f09b68:	e5843044 	str	r3, [r4, #68]
 3f09b6c:	eb000b34 	bl	3f0c844 <printf>
 3f09b70:	ea000000 	b	3f09b78 <NanD_ScanChips+0x180>
 3f09b74:	03f1e374 	mvneqs	r14, #-805306367	; 0xd0000001
	       nand->numchips, nand->totlen >> 20);
#endif
}
 3f09b78:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f09b7c <NanD_ReadBuf>:
 3f09b7c:	e1a0c00d 	mov	r12, r13
 3f09b80:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f09b84:	e24cb004 	sub	r11, r12, #4	; 0x4

/* we need to be fast here, 1 us per read translates to 1 second per meg */
static void NanD_ReadBuf(struct nand_chip *nand, u_char *data_buf, int cntr)
{
 3f09b88:	e1a00002 	mov	r0, r2
	unsigned long nandptr = nand->IO_ADDR;

	while (cntr >= 16) {
 3f09b8c:	e350000f 	cmp	r0, #15	; 0xf
 3f09b90:	da000023 	ble	3f09c24 <NanD_ReadBuf+0xa8>
		*data_buf++ = READ_NAND(nandptr);
 3f09b94:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f09b98:	e5d32000 	ldrb	r2, [r3]
 3f09b9c:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09ba0:	e5d32000 	ldrb	r2, [r3]
 3f09ba4:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09ba8:	e5d32000 	ldrb	r2, [r3]
 3f09bac:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09bb0:	e5d32000 	ldrb	r2, [r3]
 3f09bb4:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09bb8:	e5d32000 	ldrb	r2, [r3]
 3f09bbc:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09bc0:	e5d32000 	ldrb	r2, [r3]
 3f09bc4:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09bc8:	e5d32000 	ldrb	r2, [r3]
 3f09bcc:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09bd0:	e5d32000 	ldrb	r2, [r3]
 3f09bd4:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09bd8:	e5d32000 	ldrb	r2, [r3]
 3f09bdc:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09be0:	e5d32000 	ldrb	r2, [r3]
 3f09be4:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09be8:	e5d32000 	ldrb	r2, [r3]
 3f09bec:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09bf0:	e5d32000 	ldrb	r2, [r3]
 3f09bf4:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09bf8:	e5d32000 	ldrb	r2, [r3]
 3f09bfc:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09c00:	e5d32000 	ldrb	r2, [r3]
 3f09c04:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
 3f09c08:	e5d32000 	ldrb	r2, [r3]
 3f09c0c:	e4c12001 	strb	r2, [r1], #1
		*data_buf++ = READ_NAND(nandptr);
		cntr -= 16;
 3f09c10:	e2400010 	sub	r0, r0, #16	; 0x10
 3f09c14:	e5d33000 	ldrb	r3, [r3]
	}
 3f09c18:	e350000f 	cmp	r0, #15	; 0xf
 3f09c1c:	e4c13001 	strb	r3, [r1], #1
 3f09c20:	caffffdb 	bgt	3f09b94 <NanD_ReadBuf+0x18>

	while (cntr > 0) {
 3f09c24:	e3500000 	cmp	r0, #0	; 0x0
 3f09c28:	d91ba800 	ldmledb	r11, {r11, r13, r15}
		*data_buf++ = READ_NAND(nandptr);
		cntr--;
 3f09c2c:	e2400001 	sub	r0, r0, #1	; 0x1
 3f09c30:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f09c34:	e5d33000 	ldrb	r3, [r3]
	}
 3f09c38:	e3500000 	cmp	r0, #0	; 0x0
 3f09c3c:	e4c13001 	strb	r3, [r1], #1
 3f09c40:	cafffff9 	bgt	3f09c2c <NanD_ReadBuf+0xb0>
}
 3f09c44:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f09c48 <nand_read_ecc>:
 3f09c48:	e1a0c00d 	mov	r12, r13
 3f09c4c:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f09c50:	e24cb004 	sub	r11, r12, #4	; 0x4

/*
 * NAND read with ECC
 */
static int nand_read_ecc(struct nand_chip *nand, size_t start, size_t len,
		 size_t * retlen, u_char *buf, u_char *ecc_code)
{
	int col, page;
	int ecc_status = 0;
 3f09c54:	e3a0c000 	mov	r12, #0	; 0x0
 3f09c58:	e1a05000 	mov	r5, r0
 3f09c5c:	e24dd014 	sub	r13, r13, #20	; 0x14
 3f09c60:	e50bc030 	str	r12, [r11, -#48]
 3f09c64:	e1a0a002 	mov	r10, r2
#ifdef CONFIG_MTD_NAND_ECC
	int j;
	int ecc_failed = 0;
 3f09c68:	e50bc034 	str	r12, [r11, -#52]
	u_char *data_poi;
	u_char ecc_calc[6];
#endif

	/* Do not allow reads past end of device */
	if ((start + len) > nand->totlen) {
 3f09c6c:	e081200a 	add	r2, r1, r10
 3f09c70:	e5950044 	ldr	r0, [r5, #68]
 3f09c74:	e1a06003 	mov	r6, r3
 3f09c78:	e1520000 	cmp	r2, r0
 3f09c7c:	9a000009 	bls	3f09ca8 <nand_read_ecc+0x60>
		printf ("%s: Attempt read beyond end of device %x %x %x\n", __FUNCTION__, (uint) start, (uint) len, (uint) nand->totlen);
 3f09c80:	e58d0000 	str	r0, [r13]
 3f09c84:	e59f028c 	ldr	r0, [pc, #28c]	; 3f09f18 <nand_read_ecc+0x2d0>
 3f09c88:	e1a02001 	mov	r2, r1
 3f09c8c:	e59f1288 	ldr	r1, [pc, #288]	; 3f09f1c <nand_read_ecc+0x2d4>
 3f09c90:	e1a0300a 	mov	r3, r10
 3f09c94:	eb000aea 	bl	3f0c844 <printf>
		*retlen = 0;
 3f09c98:	e51b1030 	ldr	r1, [r11, -#48]
		return -1;
 3f09c9c:	e3e00000 	mvn	r0, #0	; 0x0
 3f09ca0:	e5861000 	str	r1, [r6]
 3f09ca4:	ea0000ca 	b	3f09fd4 <nand_read_ecc+0x38c>
	}

	/* First we calculate the starting page */
	/*page = shr(start, nand->page_shift);*/
	page = start >> nand->page_shift;
 3f09ca8:	e5952000 	ldr	r2, [r5]
	// dprintf("nand_read_ecc_0, page: %x, pg_shift: %x\n", page, nand->page_shift);

	/* Get raw starting column */
	col = start & (nand->oobblock - 1);
 3f09cac:	e5953048 	ldr	r3, [r5, #72]

	/* Initialize return value */
	*retlen = 0;
 3f09cb0:	e51bc030 	ldr	r12, [r11, -#48]
 3f09cb4:	e1a07231 	mov	r7, r1, lsr r2
 3f09cb8:	e2433001 	sub	r3, r3, #1	; 0x1
 3f09cbc:	e586c000 	str	r12, [r6]
 3f09cc0:	e0019003 	and	r9, r1, r3
	// dprintf("nand_read_ecc_1, col: %x\n", col);

	/* Select the NAND device */
	NAND_ENABLE_CE(nand);  /* set pin low */
 3f09cc4:	e59f2254 	ldr	r2, [pc, #254]	; 3f09f20 <nand_read_ecc+0x2d8>
 3f09cc8:	e1d230b0 	ldrh	r3, [r2]
 3f09ccc:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f09cd0:	e1c230b0 	strh	r3, [r2]
 3f09cd4:	e1d230b0 	ldrh	r3, [r2]
 3f09cd8:	e3833080 	orr	r3, r3, #128	; 0x80
 3f09cdc:	e1c230b0 	strh	r3, [r2]

	/* Loop until all data read */
	while (*retlen < len) {
 3f09ce0:	e5963000 	ldr	r3, [r6]
 3f09ce4:	e153000a 	cmp	r3, r10
 3f09ce8:	2a0000ac 	bcs	3f09fa0 <nand_read_ecc+0x358>


#ifdef CONFIG_MTD_NAND_ECC

		/* Do we have this page in cache ? */
		if (nand->cache_page == page)
 3f09cec:	e595300c 	ldr	r3, [r5, #12]
 3f09cf0:	e1530007 	cmp	r3, r7
 3f09cf4:	0a000077 	beq	3f09ed8 <nand_read_ecc+0x290>
 3f09cf8:	e3a04000 	mov	r4, #0	; 0x0
 3f09cfc:	e59f3220 	ldr	r3, [pc, #220]	; 3f09f24 <nand_read_ecc+0x2dc>
 3f09d00:	e5c34000 	strb	r4, [r3]
			goto readdata;
		/* Send the read command */
		NanD_Command(nand, NAND_CMD_READ0);
		// dprintf("nand_read_ecc_2, addressing\n");
		NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
 3f09d04:	e5952000 	ldr	r2, [r5]
 3f09d08:	e3a01003 	mov	r1, #3	; 0x3
 3f09d0c:	e1a00005 	mov	r0, r5
 3f09d10:	e0892217 	add	r2, r9, r7, lsl r2
 3f09d14:	ebfffe70 	bl	3f096dc <NanD_Address>
		// dprintf("nand_read_ecc_3, readbuf\n");
		udelay(9);
 3f09d18:	e3a00009 	mov	r0, #9	; 0x9
 3f09d1c:	ebffdabd 	bl	3f00818 <udelay>

		/* Read in a page + oob data */
		NanD_ReadBuf(nand, nand->data_buf, nand->oobblock + nand->oobsize);
 3f09d20:	e5951004 	ldr	r1, [r5, #4]
 3f09d24:	e2850048 	add	r0, r5, #72	; 0x48
 3f09d28:	e8900005 	ldmia	r0, {r0, r2}
 3f09d2c:	e0802002 	add	r2, r0, r2
 3f09d30:	e1a00005 	mov	r0, r5
 3f09d34:	ebffff90 	bl	3f09b7c <NanD_ReadBuf>
		// dprintf("nand_read_ecc_4, readbuf\n");

		/* copy data into cache, for read out of cache and if ecc fails */
		if (nand->data_cache)
 3f09d38:	e5950008 	ldr	r0, [r5, #8]
 3f09d3c:	e1500004 	cmp	r0, r4
 3f09d40:	0a000004 	beq	3f09d58 <nand_read_ecc+0x110>
			memcpy (nand->data_cache, nand->data_buf, nand->oobblock + nand->oobsize);
 3f09d44:	e5951004 	ldr	r1, [r5, #4]
 3f09d48:	e2853048 	add	r3, r5, #72	; 0x48
 3f09d4c:	e893000c 	ldmia	r3, {r2, r3}
 3f09d50:	e0822003 	add	r2, r2, r3
 3f09d54:	eb00160b 	bl	3f0f588 <memcpy>

		/* Pick the ECC bytes out of the oob data */
		for (j = 0; j < 6; j++)
 3f09d58:	e1a00004 	mov	r0, r4
			ecc_code[j] = nand->data_buf[(nand->oobblock + oob_config.ecc_pos[j])];
 3f09d5c:	e59fc1c4 	ldr	r12, [pc, #1c4]	; 3f09f28 <nand_read_ecc+0x2e0>
 3f09d60:	e5953048 	ldr	r3, [r5, #72]
 3f09d64:	e79c2100 	ldr	r2, [r12, r0, lsl #2]
 3f09d68:	e5951004 	ldr	r1, [r5, #4]
 3f09d6c:	e0833002 	add	r3, r3, r2
 3f09d70:	e7d13003 	ldrb	r3, [r1, r3]
 3f09d74:	e59b1008 	ldr	r1, [r11, #8]
 3f09d78:	e7c13000 	strb	r3, [r1, r0]
 3f09d7c:	e2800001 	add	r0, r0, #1	; 0x1
 3f09d80:	e3500005 	cmp	r0, #5	; 0x5
 3f09d84:	dafffff4 	ble	3f09d5c <nand_read_ecc+0x114>

		/* Calculate the ECC and verify it */
		/* If block was not written with ECC, skip ECC */
		if (oob_config.eccvalid_pos != -1 &&
 3f09d88:	e59c201c 	ldr	r2, [r12, #28]
 3f09d8c:	e3720001 	cmn	r2, #1	; 0x1
 3f09d90:	0a000022 	beq	3f09e20 <nand_read_ecc+0x1d8>
 3f09d94:	e5953048 	ldr	r3, [r5, #72]
 3f09d98:	e5950004 	ldr	r0, [r5, #4]
 3f09d9c:	e0833002 	add	r3, r3, r2
 3f09da0:	e7d03003 	ldrb	r3, [r0, r3]
 3f09da4:	e203300f 	and	r3, r3, #15	; 0xf
 3f09da8:	e353000f 	cmp	r3, #15	; 0xf
 3f09dac:	0a00001b 	beq	3f09e20 <nand_read_ecc+0x1d8>
		    (nand->data_buf[nand->oobblock + oob_config.eccvalid_pos] & 0x0f) != 0x0f) {

			nand_calculate_ecc (&nand->data_buf[0], &ecc_calc[0]);
 3f09db0:	e24b402c 	sub	r4, r11, #44	; 0x2c
 3f09db4:	e1a01004 	mov	r1, r4
 3f09db8:	eb0003fe 	bl	3f0adb8 <nand_calculate_ecc>
			switch (nand_correct_data (&nand->data_buf[0], &ecc_code[0], &ecc_calc[0])) {
 3f09dbc:	e59b1008 	ldr	r1, [r11, #8]
 3f09dc0:	e5950004 	ldr	r0, [r5, #4]
 3f09dc4:	e1a02004 	mov	r2, r4
 3f09dc8:	eb000423 	bl	3f0ae5c <nand_correct_data>
 3f09dcc:	e3700001 	cmn	r0, #1	; 0x1
 3f09dd0:	1a000007 	bne	3f09df4 <nand_read_ecc+0x1ac>
			case -1:
				printf ("%s: Failed ECC read, page 0x%08x\n", __FUNCTION__, page);
 3f09dd4:	e59f0150 	ldr	r0, [pc, #150]	; 3f09f2c <nand_read_ecc+0x2e4>
				ecc_failed++;
 3f09dd8:	e51b3034 	ldr	r3, [r11, -#52]
 3f09ddc:	e1a02007 	mov	r2, r7
 3f09de0:	e59f1134 	ldr	r1, [pc, #134]	; 3f09f1c <nand_read_ecc+0x2d4>
 3f09de4:	e2833001 	add	r3, r3, #1	; 0x1
 3f09de8:	e50b3034 	str	r3, [r11, -#52]
 3f09dec:	eb000a94 	bl	3f0c844 <printf>
				break;
 3f09df0:	ea00000a 	b	3f09e20 <nand_read_ecc+0x1d8>
 3f09df4:	ba000009 	blt	3f09e20 <nand_read_ecc+0x1d8>
 3f09df8:	e3500002 	cmp	r0, #2	; 0x2
 3f09dfc:	ca000007 	bgt	3f09e20 <nand_read_ecc+0x1d8>
 3f09e00:	e3500001 	cmp	r0, #1	; 0x1
 3f09e04:	ba000005 	blt	3f09e20 <nand_read_ecc+0x1d8>
			case 1:
			case 2:	/* transfer ECC corrected data to cache */
				if (nand->data_cache)
 3f09e08:	e5950008 	ldr	r0, [r5, #8]
 3f09e0c:	e3500000 	cmp	r0, #0	; 0x0
 3f09e10:	0a000002 	beq	3f09e20 <nand_read_ecc+0x1d8>
					memcpy (nand->data_cache, nand->data_buf, 256);
 3f09e14:	e5951004 	ldr	r1, [r5, #4]
 3f09e18:	e3a02c01 	mov	r2, #256	; 0x100
 3f09e1c:	eb0015d9 	bl	3f0f588 <memcpy>
				break;
			}
		}

		if (oob_config.eccvalid_pos != -1 &&
 3f09e20:	e59fc100 	ldr	r12, [pc, #100]	; 3f09f28 <nand_read_ecc+0x2e0>
 3f09e24:	e59c201c 	ldr	r2, [r12, #28]
 3f09e28:	e3720001 	cmn	r2, #1	; 0x1
 3f09e2c:	0a000029 	beq	3f09ed8 <nand_read_ecc+0x290>
 3f09e30:	e5953048 	ldr	r3, [r5, #72]
 3f09e34:	e3530c02 	cmp	r3, #512	; 0x200
 3f09e38:	1a000026 	bne	3f09ed8 <nand_read_ecc+0x290>
 3f09e3c:	e5950004 	ldr	r0, [r5, #4]
 3f09e40:	e0823003 	add	r3, r2, r3
 3f09e44:	e7d03003 	ldrb	r3, [r0, r3]
 3f09e48:	e20330f0 	and	r3, r3, #240	; 0xf0
 3f09e4c:	e35300f0 	cmp	r3, #240	; 0xf0
 3f09e50:	0a000020 	beq	3f09ed8 <nand_read_ecc+0x290>
		    nand->oobblock == 512 && (nand->data_buf[nand->oobblock + oob_config.eccvalid_pos] & 0xf0) != 0xf0) {

			nand_calculate_ecc (&nand->data_buf[256], &ecc_calc[3]);
 3f09e54:	e2800c01 	add	r0, r0, #256	; 0x100
 3f09e58:	e24b4029 	sub	r4, r11, #41	; 0x29
 3f09e5c:	e1a01004 	mov	r1, r4
 3f09e60:	eb0003d4 	bl	3f0adb8 <nand_calculate_ecc>
			switch (nand_correct_data (&nand->data_buf[256], &ecc_code[3], &ecc_calc[3])) {
 3f09e64:	e59b0008 	ldr	r0, [r11, #8]
 3f09e68:	e2801003 	add	r1, r0, #3	; 0x3
 3f09e6c:	e5950004 	ldr	r0, [r5, #4]
 3f09e70:	e1a02004 	mov	r2, r4
 3f09e74:	e2800c01 	add	r0, r0, #256	; 0x100
 3f09e78:	eb0003f7 	bl	3f0ae5c <nand_correct_data>
 3f09e7c:	e3700001 	cmn	r0, #1	; 0x1
 3f09e80:	1a000007 	bne	3f09ea4 <nand_read_ecc+0x25c>
			case -1:
				printf ("%s: Failed ECC read, page 0x%08x\n", __FUNCTION__, page);
 3f09e84:	e59f00a0 	ldr	r0, [pc, #a0]	; 3f09f2c <nand_read_ecc+0x2e4>
				ecc_failed++;
 3f09e88:	e51b3034 	ldr	r3, [r11, -#52]
 3f09e8c:	e1a02007 	mov	r2, r7
 3f09e90:	e59f1084 	ldr	r1, [pc, #84]	; 3f09f1c <nand_read_ecc+0x2d4>
 3f09e94:	e2833001 	add	r3, r3, #1	; 0x1
 3f09e98:	e50b3034 	str	r3, [r11, -#52]
 3f09e9c:	eb000a68 	bl	3f0c844 <printf>
				break;
 3f09ea0:	ea00000c 	b	3f09ed8 <nand_read_ecc+0x290>
 3f09ea4:	ba00000b 	blt	3f09ed8 <nand_read_ecc+0x290>
 3f09ea8:	e3500002 	cmp	r0, #2	; 0x2
 3f09eac:	ca000009 	bgt	3f09ed8 <nand_read_ecc+0x290>
 3f09eb0:	e3500001 	cmp	r0, #1	; 0x1
 3f09eb4:	ba000007 	blt	3f09ed8 <nand_read_ecc+0x290>
			case 1:
			case 2:	/* transfer ECC corrected data to cache */
				if (nand->data_cache)
 3f09eb8:	e5950008 	ldr	r0, [r5, #8]
 3f09ebc:	e3500000 	cmp	r0, #0	; 0x0
 3f09ec0:	0a000004 	beq	3f09ed8 <nand_read_ecc+0x290>
					memcpy (&nand->data_cache[256], &nand->data_buf[256], 256);
 3f09ec4:	e2800c01 	add	r0, r0, #256	; 0x100
 3f09ec8:	e5951004 	ldr	r1, [r5, #4]
 3f09ecc:	e3a02c01 	mov	r2, #256	; 0x100
 3f09ed0:	e0811002 	add	r1, r1, r2
 3f09ed4:	eb0015ab 	bl	3f0f588 <memcpy>
				break;
			}
		}
readdata:
		/* Read the data from ECC data buffer into return buffer */
		data_poi = (nand->data_cache) ? nand->data_cache : nand->data_buf;
 3f09ed8:	e5951008 	ldr	r1, [r5, #8]
 3f09edc:	e3510000 	cmp	r1, #0	; 0x0
 3f09ee0:	05951004 	ldreq	r1, [r5, #4]
		data_poi += col;
		if ((*retlen + (nand->oobblock - col)) >= len) {
 3f09ee4:	e5953048 	ldr	r3, [r5, #72]
 3f09ee8:	e0811009 	add	r1, r1, r9
 3f09eec:	e596c000 	ldr	r12, [r6]
 3f09ef0:	e0692003 	rsb	r2, r9, r3
 3f09ef4:	e08c3002 	add	r3, r12, r2
 3f09ef8:	e153000a 	cmp	r3, r10
 3f09efc:	3a00000b 	bcc	3f09f30 <nand_read_ecc+0x2e8>
			memcpy (buf + *retlen, data_poi, len - *retlen);
 3f09f00:	e59b2004 	ldr	r2, [r11, #4]
 3f09f04:	e082000c 	add	r0, r2, r12
 3f09f08:	e06c200a 	rsb	r2, r12, r10
 3f09f0c:	eb00159d 	bl	3f0f588 <memcpy>
			*retlen = len;
 3f09f10:	e586a000 	str	r10, [r6]
		} else {
 3f09f14:	ea00000d 	b	3f09f50 <nand_read_ecc+0x308>
 3f09f18:	03f1e3a8 	mvneqs	r14, #-1610612734	; 0xa0000002
 3f09f1c:	03f1e3d8 	mvneqs	r14, #1610612739	; 0x60000003
 3f09f20:	c0003a3a 	andgt	r3, r0, r10, lsr r10
 3f09f24:	9c000010 	stcls	0, cr0, [r0], -#64
 3f09f28:	03f207d4 	mvneqs	r0, #55574528	; 0x3500000
 3f09f2c:	03f1e3e8 	mvneqs	r14, #-1610612733	; 0xa0000003
			memcpy (buf + *retlen, data_poi,  nand->oobblock - col);
 3f09f30:	e59b3004 	ldr	r3, [r11, #4]
 3f09f34:	e083000c 	add	r0, r3, r12
 3f09f38:	eb001592 	bl	3f0f588 <memcpy>
			*retlen += nand->oobblock - col;
 3f09f3c:	e5953048 	ldr	r3, [r5, #72]
 3f09f40:	e5962000 	ldr	r2, [r6]
 3f09f44:	e0693003 	rsb	r3, r9, r3
 3f09f48:	e0822003 	add	r2, r2, r3
 3f09f4c:	e5862000 	str	r2, [r6]
		}
		/* Set cache page address, invalidate, if ecc_failed */
		nand->cache_page = (nand->data_cache && !ecc_failed) ? page : -1;

		ecc_status += ecc_failed;
 3f09f50:	e24b0034 	sub	r0, r11, #52	; 0x34
 3f09f54:	e8901001 	ldmia	r0, {r0, r12}
 3f09f58:	e08cc000 	add	r12, r12, r0
 3f09f5c:	e50bc030 	str	r12, [r11, -#48]
		ecc_failed = 0;
 3f09f60:	e3a09000 	mov	r9, #0	; 0x0
 3f09f64:	e5952008 	ldr	r2, [r5, #8]
 3f09f68:	e1500009 	cmp	r0, r9
 3f09f6c:	13a03000 	movne	r3, #0	; 0x0
 3f09f70:	03a03001 	moveq	r3, #1	; 0x1
 3f09f74:	e1520009 	cmp	r2, r9
 3f09f78:	01a03009 	moveq	r3, r9
 3f09f7c:	e1530009 	cmp	r3, r9
 3f09f80:	11a03007 	movne	r3, r7
 3f09f84:	03e03000 	mvneq	r3, #0	; 0x0
 3f09f88:	e585300c 	str	r3, [r5, #12]

#else
		/* Send the read command */
		NanD_Command(nand, NAND_CMD_READ0);
		NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
		/* Read the data directly into the return buffer */
		if ((*retlen + (nand->oobblock - col)) >= len) {
			NanD_ReadBuf(nand, buf + *retlen, len - *retlen);
			*retlen = len;
			/* We're done */
			continue;
		} else {
			NanD_ReadBuf(nand, buf + *retlen, nand->oobblock - col);
			*retlen += nand->oobblock - col;
			}
#endif
		/* For subsequent reads align to page boundary. */
		col = 0;
 3f09f8c:	e50b9034 	str	r9, [r11, -#52]
		/* Increment page address */
		page++;
	}
 3f09f90:	e5963000 	ldr	r3, [r6]
 3f09f94:	e2877001 	add	r7, r7, #1	; 0x1
 3f09f98:	e153000a 	cmp	r3, r10
 3f09f9c:	3affff52 	bcc	3f09cec <nand_read_ecc+0xa4>

	/* De-select the NAND device */
	NAND_DISABLE_CE(nand);  /* set pin high */
 3f09fa0:	e59f3030 	ldr	r3, [pc, #30]	; 3f09fd8 <nand_read_ecc+0x390>
 3f09fa4:	e1d320b0 	ldrh	r2, [r3]
 3f09fa8:	e3c22080 	bic	r2, r2, #128	; 0x80
 3f09fac:	e1a02802 	mov	r2, r2, lsl #16
 3f09fb0:	e1a02822 	mov	r2, r2, lsr #16
 3f09fb4:	e1c320b0 	strh	r2, [r3]
 3f09fb8:	e1d320b0 	ldrh	r2, [r3]
 3f09fbc:	e3822902 	orr	r2, r2, #32768	; 0x8000
 3f09fc0:	e1c320b0 	strh	r2, [r3]

	/*
	 * Return success, if no ECC failures, else -EIO
	 * fs driver will take care of that, because
	 * retlen == desired len and result == -EIO
	 */
	return ecc_status ? -1 : 0;
 3f09fc4:	e51b1030 	ldr	r1, [r11, -#48]
 3f09fc8:	e3510000 	cmp	r1, #0	; 0x0
 3f09fcc:	13e00000 	mvnne	r0, #0	; 0x0
 3f09fd0:	03a00000 	moveq	r0, #0	; 0x0
 3f09fd4:	ea000000 	b	3f09fdc <nand_read_ecc+0x394>
 3f09fd8:	c0003a3a 	andgt	r3, r0, r10, lsr r10
}
 3f09fdc:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f09fe0 <nand_write_page>:
 3f09fe0:	e1a0c00d 	mov	r12, r13
 3f09fe4:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}

/*
 *	Nand_page_program function is used for write and writev !
 */
static int nand_write_page (struct nand_chip *nand,
			    int page, int col, int last, u_char * ecc_code)
{
 3f09fe8:	e1a05000 	mov	r5, r0
 3f09fec:	e24dd004 	sub	r13, r13, #4	; 0x4

	int i;
	unsigned long nandptr = nand->IO_ADDR;
#ifdef CONFIG_MTD_NAND_ECC
#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
	int ecc_bytes = (nand->oobblock == 512) ? 6 : 3;
#endif
#endif
	/* pad oob area */
	for (i = nand->oobblock; i < nand->oobblock + nand->oobsize; i++)
 3f09ff0:	e5954048 	ldr	r4, [r5, #72]
 3f09ff4:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f09ff8:	e285c048 	add	r12, r5, #72	; 0x48
 3f09ffc:	e89c1001 	ldmia	r12, {r0, r12}
 3f0a000:	e080000c 	add	r0, r0, r12
 3f0a004:	e1a07002 	mov	r7, r2
 3f0a008:	e50b1028 	str	r1, [r11, -#40]
 3f0a00c:	e1a0a003 	mov	r10, r3
 3f0a010:	e59b9004 	ldr	r9, [r11, #4]
 3f0a014:	e1540000 	cmp	r4, r0
 3f0a018:	2a000008 	bcs	3f0a040 <nand_write_page+0x60>
		nand->data_buf[i] = 0xff;
 3f0a01c:	e5953004 	ldr	r3, [r5, #4]
 3f0a020:	e3a020ff 	mov	r2, #255	; 0xff
 3f0a024:	e7c32004 	strb	r2, [r3, r4]
 3f0a028:	e2852048 	add	r2, r5, #72	; 0x48
 3f0a02c:	e892000c 	ldmia	r2, {r2, r3}
 3f0a030:	e0823003 	add	r3, r2, r3
 3f0a034:	e2844001 	add	r4, r4, #1	; 0x1
 3f0a038:	e1540003 	cmp	r4, r3
 3f0a03c:	3afffff6 	bcc	3f0a01c <nand_write_page+0x3c>

#ifdef CONFIG_MTD_NAND_ECC
	/* Zero out the ECC array */
	for (i = 0; i < 6; i++)
 3f0a040:	e3a04000 	mov	r4, #0	; 0x0
		ecc_code[i] = 0x00;
 3f0a044:	e3a06000 	mov	r6, #0	; 0x0
 3f0a048:	e7c96004 	strb	r6, [r9, r4]
 3f0a04c:	e2844001 	add	r4, r4, #1	; 0x1
 3f0a050:	e3540005 	cmp	r4, #5	; 0x5
 3f0a054:	dafffffa 	ble	3f0a044 <nand_write_page+0x64>

	/* Read back previous written data, if col > 0 */
	if (col) {
 3f0a058:	e1570006 	cmp	r7, r6
 3f0a05c:	0a000011 	beq	3f0a0a8 <nand_write_page+0xc8>
 3f0a060:	e59f3224 	ldr	r3, [pc, #224]	; 3f0a28c <nand_write_page+0x2ac>
 3f0a064:	e5c36000 	strb	r6, [r3]
		NanD_Command(nand, NAND_CMD_READ0);
		NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
 3f0a068:	e5952000 	ldr	r2, [r5]
 3f0a06c:	e3a01003 	mov	r1, #3	; 0x3
 3f0a070:	e51b3028 	ldr	r3, [r11, -#40]
 3f0a074:	e1a00005 	mov	r0, r5
 3f0a078:	e0872213 	add	r2, r7, r3, lsl r2
 3f0a07c:	ebfffd96 	bl	3f096dc <NanD_Address>
		for (i = 0; i < col; i++)
 3f0a080:	e1a04006 	mov	r4, r6
 3f0a084:	e1540007 	cmp	r4, r7
 3f0a088:	aa000006 	bge	3f0a0a8 <nand_write_page+0xc8>
			nand->data_buf[i] = READ_NAND (nandptr);
 3f0a08c:	e5953004 	ldr	r3, [r5, #4]
 3f0a090:	e3a02327 	mov	r2, #-1677721600	; 0x9c000000
 3f0a094:	e5d22000 	ldrb	r2, [r2]
 3f0a098:	e7c32004 	strb	r2, [r3, r4]
 3f0a09c:	e2844001 	add	r4, r4, #1	; 0x1
 3f0a0a0:	e1540007 	cmp	r4, r7
 3f0a0a4:	bafffff8 	blt	3f0a08c <nand_write_page+0xac>
	}

	/* Calculate and write the ECC if we have enough data */
	if ((col < nand->eccsize) && (last >= nand->eccsize)) {
 3f0a0a8:	e5953050 	ldr	r3, [r5, #80]
 3f0a0ac:	e1570003 	cmp	r7, r3
 3f0a0b0:	2a000016 	bcs	3f0a110 <nand_write_page+0x130>
 3f0a0b4:	e15a0003 	cmp	r10, r3
 3f0a0b8:	3a000014 	bcc	3f0a110 <nand_write_page+0x130>
		nand_calculate_ecc (&nand->data_buf[0], &(ecc_code[0]));
 3f0a0bc:	e5950004 	ldr	r0, [r5, #4]
 3f0a0c0:	e1a01009 	mov	r1, r9
 3f0a0c4:	eb00033b 	bl	3f0adb8 <nand_calculate_ecc>
		for (i = 0; i < 3; i++)
 3f0a0c8:	e3a04000 	mov	r4, #0	; 0x0
			nand->data_buf[(nand->oobblock + oob_config.ecc_pos[i])] = ecc_code[i];
 3f0a0cc:	e59fc1bc 	ldr	r12, [pc, #1bc]	; 3f0a290 <nand_write_page+0x2b0>
 3f0a0d0:	e7d90004 	ldrb	r0, [r9, r4]
 3f0a0d4:	e5953048 	ldr	r3, [r5, #72]
 3f0a0d8:	e5952004 	ldr	r2, [r5, #4]
 3f0a0dc:	e79c1104 	ldr	r1, [r12, r4, lsl #2]
 3f0a0e0:	e2844001 	add	r4, r4, #1	; 0x1
 3f0a0e4:	e3540002 	cmp	r4, #2	; 0x2
 3f0a0e8:	e0833001 	add	r3, r3, r1
 3f0a0ec:	e7c20003 	strb	r0, [r2, r3]
 3f0a0f0:	dafffff5 	ble	3f0a0cc <nand_write_page+0xec>
		if (oob_config.eccvalid_pos != -1)
 3f0a0f4:	e59c201c 	ldr	r2, [r12, #28]
 3f0a0f8:	e3720001 	cmn	r2, #1	; 0x1
			nand->data_buf[nand->oobblock + oob_config.eccvalid_pos] = 0xf0;
 3f0a0fc:	15953048 	ldrne	r3, [r5, #72]
 3f0a100:	15951004 	ldrne	r1, [r5, #4]
 3f0a104:	10833002 	addne	r3, r3, r2
 3f0a108:	13a020f0 	movne	r2, #240	; 0xf0
 3f0a10c:	17c12003 	strneb	r2, [r1, r3]
	}

	/* Calculate and write the second ECC if we have enough data */
	if ((nand->oobblock == 512) && (last == nand->oobblock)) {
 3f0a110:	e5953048 	ldr	r3, [r5, #72]
 3f0a114:	e3530c02 	cmp	r3, #512	; 0x200
 3f0a118:	1a000019 	bne	3f0a184 <nand_write_page+0x1a4>
 3f0a11c:	e15a0003 	cmp	r10, r3
 3f0a120:	1a000017 	bne	3f0a184 <nand_write_page+0x1a4>
		nand_calculate_ecc (&nand->data_buf[256], &(ecc_code[3]));
 3f0a124:	e5950004 	ldr	r0, [r5, #4]
 3f0a128:	e2891003 	add	r1, r9, #3	; 0x3
 3f0a12c:	e2800c01 	add	r0, r0, #256	; 0x100
 3f0a130:	eb000320 	bl	3f0adb8 <nand_calculate_ecc>
		for (i = 3; i < 6; i++)
 3f0a134:	e3a04003 	mov	r4, #3	; 0x3
			nand->data_buf[(nand->oobblock + oob_config.ecc_pos[i])] = ecc_code[i];
 3f0a138:	e59fc150 	ldr	r12, [pc, #150]	; 3f0a290 <nand_write_page+0x2b0>
 3f0a13c:	e7d90004 	ldrb	r0, [r9, r4]
 3f0a140:	e5953048 	ldr	r3, [r5, #72]
 3f0a144:	e5952004 	ldr	r2, [r5, #4]
 3f0a148:	e79c1104 	ldr	r1, [r12, r4, lsl #2]
 3f0a14c:	e2844001 	add	r4, r4, #1	; 0x1
 3f0a150:	e3540005 	cmp	r4, #5	; 0x5
 3f0a154:	e0833001 	add	r3, r3, r1
 3f0a158:	e7c20003 	strb	r0, [r2, r3]
 3f0a15c:	dafffff5 	ble	3f0a138 <nand_write_page+0x158>
		if (oob_config.eccvalid_pos != -1)
 3f0a160:	e59c201c 	ldr	r2, [r12, #28]
 3f0a164:	e3720001 	cmn	r2, #1	; 0x1
 3f0a168:	0a000005 	beq	3f0a184 <nand_write_page+0x1a4>
			nand->data_buf[nand->oobblock + oob_config.eccvalid_pos] &= 0x0f;
 3f0a16c:	e5953048 	ldr	r3, [r5, #72]
 3f0a170:	e5951004 	ldr	r1, [r5, #4]
 3f0a174:	e0833002 	add	r3, r3, r2
 3f0a178:	e7d12003 	ldrb	r2, [r1, r3]
 3f0a17c:	e202200f 	and	r2, r2, #15	; 0xf
 3f0a180:	e7c12003 	strb	r2, [r1, r3]
	}
#endif
	/* Prepad for partial page programming !!! */
	for (i = 0; i < col; i++)
 3f0a184:	e3a04000 	mov	r4, #0	; 0x0
 3f0a188:	e1540007 	cmp	r4, r7
 3f0a18c:	aa000005 	bge	3f0a1a8 <nand_write_page+0x1c8>
		nand->data_buf[i] = 0xff;
 3f0a190:	e5952004 	ldr	r2, [r5, #4]
 3f0a194:	e3a030ff 	mov	r3, #255	; 0xff
 3f0a198:	e7c23004 	strb	r3, [r2, r4]
 3f0a19c:	e2844001 	add	r4, r4, #1	; 0x1
 3f0a1a0:	e1540007 	cmp	r4, r7
 3f0a1a4:	bafffff9 	blt	3f0a190 <nand_write_page+0x1b0>

	/* Postpad for partial page programming !!! oob is already padded */
	for (i = last; i < nand->oobblock; i++)
 3f0a1a8:	e5953048 	ldr	r3, [r5, #72]
 3f0a1ac:	e1a0400a 	mov	r4, r10
 3f0a1b0:	e1540003 	cmp	r4, r3
 3f0a1b4:	2a000006 	bcs	3f0a1d4 <nand_write_page+0x1f4>
		nand->data_buf[i] = 0xff;
 3f0a1b8:	e5953004 	ldr	r3, [r5, #4]
 3f0a1bc:	e3a020ff 	mov	r2, #255	; 0xff
 3f0a1c0:	e7c32004 	strb	r2, [r3, r4]
 3f0a1c4:	e5953048 	ldr	r3, [r5, #72]
 3f0a1c8:	e2844001 	add	r4, r4, #1	; 0x1
 3f0a1cc:	e1540003 	cmp	r4, r3
 3f0a1d0:	3afffff8 	bcc	3f0a1b8 <nand_write_page+0x1d8>
 3f0a1d4:	e3a04000 	mov	r4, #0	; 0x0
 3f0a1d8:	e59f20ac 	ldr	r2, [pc, #ac]	; 3f0a28c <nand_write_page+0x2ac>
 3f0a1dc:	e5c24000 	strb	r4, [r2]
 3f0a1e0:	e3a03080 	mov	r3, #128	; 0x80
 3f0a1e4:	e5c23000 	strb	r3, [r2]

	/* Send command to begin auto page programming */
	NanD_Command(nand, NAND_CMD_READ0);
	NanD_Command(nand, NAND_CMD_SEQIN);
#ifdef CONFIG_MMSP20
	NanD_OnlyAddress(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
 3f0a1e8:	e5952000 	ldr	r2, [r5]
 3f0a1ec:	e3a01003 	mov	r1, #3	; 0x3
 3f0a1f0:	e51bc028 	ldr	r12, [r11, -#40]
 3f0a1f4:	e1a00005 	mov	r0, r5
 3f0a1f8:	e087221c 	add	r2, r7, r12, lsl r2
 3f0a1fc:	ebfffd52 	bl	3f0974c <NanD_OnlyAddress>
#else
	NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
#endif

	/* Write out complete page of data */
	for (i = 0; i < (nand->oobblock + nand->oobsize); i++)
 3f0a200:	e2852048 	add	r2, r5, #72	; 0x48
 3f0a204:	e892000c 	ldmia	r2, {r2, r3}
 3f0a208:	e0823003 	add	r3, r2, r3
 3f0a20c:	e1540003 	cmp	r4, r3
 3f0a210:	2a000009 	bcs	3f0a23c <nand_write_page+0x25c>
		WRITE_NAND(nand->data_buf[i], nand->IO_ADDR);
 3f0a214:	e5953004 	ldr	r3, [r5, #4]
 3f0a218:	e7d32004 	ldrb	r2, [r3, r4]
 3f0a21c:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f0a220:	e5c32000 	strb	r2, [r3]
 3f0a224:	e285c048 	add	r12, r5, #72	; 0x48
 3f0a228:	e89c1008 	ldmia	r12, {r3, r12}
 3f0a22c:	e083300c 	add	r3, r3, r12
 3f0a230:	e2844001 	add	r4, r4, #1	; 0x1
 3f0a234:	e1540003 	cmp	r4, r3
 3f0a238:	3afffff5 	bcc	3f0a214 <nand_write_page+0x234>
 3f0a23c:	e3a03010 	mov	r3, #16	; 0x10
 3f0a240:	e59f4044 	ldr	r4, [pc, #44]	; 3f0a28c <nand_write_page+0x2ac>
 3f0a244:	e5c43000 	strb	r3, [r4]

	/* Send command to actually program the data */
	NanD_Command(nand, NAND_CMD_PAGEPROG);
#ifdef CONFIG_MMSP20
       	NanD_WaitReady(nand, 0);
 3f0a248:	e1a00005 	mov	r0, r5
 3f0a24c:	e3a01000 	mov	r1, #0	; 0x0
 3f0a250:	ebfffd11 	bl	3f0969c <NanD_WaitReady>
#endif

	udelay(300);
 3f0a254:	e3a00f4b 	mov	r0, #300	; 0x12c
 3f0a258:	ebffd96e 	bl	3f00818 <udelay>
 3f0a25c:	e3a03070 	mov	r3, #112	; 0x70
 3f0a260:	e5c43000 	strb	r3, [r4]

	NanD_Command(nand, NAND_CMD_STATUS);
#ifdef NAND_NO_RB
	{ u_char ret_val;

	  do{
		ret_val = READ_NAND(nandptr);	/* wait till ready */
	  } while((ret_val & 0x40) != 0x40);
	}
#endif
	/* See if device thinks it succeeded */
	if (READ_NAND(nand->IO_ADDR) & 0x01) {
 3f0a264:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f0a268:	e5d33000 	ldrb	r3, [r3]
 3f0a26c:	e2130001 	ands	r0, r3, #1	; 0x1
 3f0a270:	0a000004 	beq	3f0a288 <nand_write_page+0x2a8>
		printf ("%s: Failed write, page 0x%08x, ", __FUNCTION__, page);
 3f0a274:	e59f0018 	ldr	r0, [pc, #18]	; 3f0a294 <nand_write_page+0x2b4>
 3f0a278:	e59f1018 	ldr	r1, [pc, #18]	; 3f0a298 <nand_write_page+0x2b8>
 3f0a27c:	e51b2028 	ldr	r2, [r11, -#40]
 3f0a280:	eb00096f 	bl	3f0c844 <printf>
		return -1;
 3f0a284:	e3e00000 	mvn	r0, #0	; 0x0
 3f0a288:	ea000003 	b	3f0a29c <nand_write_page+0x2bc>
 3f0a28c:	9c000010 	stcls	0, cr0, [r0], -#64
 3f0a290:	03f207d4 	mvneqs	r0, #55574528	; 0x3500000
 3f0a294:	03f1dbf4 	mvneqs	r13, #249856	; 0x3d000
 3f0a298:	03f1e40c 	mvneqs	r14, #201326592	; 0xc000000
	}

#ifdef CONFIG_MTD_NAND_VERIFY_WRITE
	/*
	 * The NAND device assumes that it is always writing to
	 * a cleanly erased page. Hence, it performs its internal
	 * write verification only on bits that transitioned from
	 * 1 to 0. The device does NOT verify the whole page on a
	 * byte by byte basis. It is possible that the page was
	 * not completely erased or the page is becoming unusable
	 * due to wear. The read with ECC would catch the error
	 * later when the ECC page check fails, but we would rather
	 * catch it early in the page write stage. Better to write
	 * no data than invalid data.
	 */

	/* Send command to read back the page */
	if (col < nand->eccsize)
		NanD_Command(nand, NAND_CMD_READ0);
	else
		NanD_Command(nand, NAND_CMD_READ1);
	NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);

	udelay(9);

	/* Loop through and verify the data */
	for (i = col; i < last; i++) {
		if (nand->data_buf[i] != readb (nand->IO_ADDR)) {
			printf ("%s: Failed write verify, page 0x%08x ", __FUNCTION__, page);
			return -1;
		}
	}

#ifdef CONFIG_MTD_NAND_ECC
	/*
	 * We also want to check that the ECC bytes wrote
	 * correctly for the same reasons stated above.
	 */
	NanD_Command(nand, NAND_CMD_READOOB);
	NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
	for (i = 0; i < nand->oobsize; i++)
		nand->data_buf[i] = readb (nand->IO_ADDR);
	for (i = 0; i < ecc_bytes; i++) {
		if ((nand->data_buf[(oob_config.ecc_pos[i])] != ecc_code[i]) && ecc_code[i]) {
			printf ("%s: Failed ECC write "
			       "verify, page 0x%08x, " "%6i bytes were succesful\n", __FUNCTION__, page, i);
			return -1;
		}
	}
#endif
#endif
	return 0;
}
 3f0a29c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0a2a0 <nand_write_ecc>:
 3f0a2a0:	e1a0c00d 	mov	r12, r13
 3f0a2a4:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0a2a8:	e24cb004 	sub	r11, r12, #4	; 0x4

static int nand_write_ecc (struct nand_chip* nand, size_t to, size_t len, size_t * retlen, const u_char * buf, u_char * ecc_code)
{
	int i, page, col, cnt, ret = 0;
 3f0a2ac:	e3a0c000 	mov	r12, #0	; 0x0
 3f0a2b0:	e1a05000 	mov	r5, r0
 3f0a2b4:	e1a00001 	mov	r0, r1
 3f0a2b8:	e1a07002 	mov	r7, r2

	/* Do not allow write past end of device */
	if ((to + len) > nand->totlen) {
 3f0a2bc:	e0802007 	add	r2, r0, r7
 3f0a2c0:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f0a2c4:	e5951044 	ldr	r1, [r5, #68]
 3f0a2c8:	e1a06003 	mov	r6, r3
 3f0a2cc:	e59b9004 	ldr	r9, [r11, #4]
 3f0a2d0:	e1520001 	cmp	r2, r1
 3f0a2d4:	9a000004 	bls	3f0a2ec <nand_write_ecc+0x4c>
		printf ("%s: Attempt to write past end of page\n", __FUNCTION__);
 3f0a2d8:	e59f00d4 	ldr	r0, [pc, #d4]	; 3f0a3b4 <nand_write_ecc+0x114>
 3f0a2dc:	e59f10d4 	ldr	r1, [pc, #d4]	; 3f0a3b8 <nand_write_ecc+0x118>
 3f0a2e0:	eb000957 	bl	3f0c844 <printf>
		return -1;
 3f0a2e4:	e3e00000 	mvn	r0, #0	; 0x0
 3f0a2e8:	ea000060 	b	3f0a470 <nand_write_ecc+0x1d0>
	}

	/* Shift to get page */
	page = ((int) to) >> nand->page_shift;
 3f0a2ec:	e5952000 	ldr	r2, [r5]

	/* Get the starting column */
	col = to & (nand->oobblock - 1);
 3f0a2f0:	e5953048 	ldr	r3, [r5, #72]

	/* Initialize return length value */
	*retlen = 0;
 3f0a2f4:	e586c000 	str	r12, [r6]
 3f0a2f8:	e1a0a250 	mov	r10, r0, asr r2
 3f0a2fc:	e2433001 	sub	r3, r3, #1	; 0x1
 3f0a300:	e000e003 	and	r14, r0, r3

	/* Select the NAND device */
#ifdef CONFIG_OMAP1510
	archflashwp(0,0);
#endif
    	NAND_ENABLE_CE(nand);  /* set pin low */
 3f0a304:	e59f20b0 	ldr	r2, [pc, #b0]	; 3f0a3bc <nand_write_ecc+0x11c>
 3f0a308:	e1d230b0 	ldrh	r3, [r2]
 3f0a30c:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0a310:	e1c230b0 	strh	r3, [r2]
 3f0a314:	e1d230b0 	ldrh	r3, [r2]
 3f0a318:	e3833080 	orr	r3, r3, #128	; 0x80
 3f0a31c:	e1c230b0 	strh	r3, [r2]
 3f0a320:	e3a02070 	mov	r2, #112	; 0x70
 3f0a324:	e59f3094 	ldr	r3, [pc, #94]	; 3f0a3c0 <nand_write_ecc+0x120>

	/* Check the WP bit */
	NanD_Command(nand, NAND_CMD_STATUS);
	if (!(READ_NAND(nand->IO_ADDR) & 0x80)) {
 3f0a328:	e4432010 	strb	r2, [r3], -#16
 3f0a32c:	e5d33000 	ldrb	r3, [r3]
 3f0a330:	e3130080 	tst	r3, #128	; 0x80
 3f0a334:	1a000004 	bne	3f0a34c <nand_write_ecc+0xac>
		printf ("%s: Device is write protected!!!\n", __FUNCTION__);
 3f0a338:	e59f0084 	ldr	r0, [pc, #84]	; 3f0a3c4 <nand_write_ecc+0x124>
 3f0a33c:	e59f1074 	ldr	r1, [pc, #74]	; 3f0a3b8 <nand_write_ecc+0x118>
 3f0a340:	eb00093f 	bl	3f0c844 <printf>
		ret = -1;
 3f0a344:	e3e0c000 	mvn	r12, #0	; 0x0
		goto out;
 3f0a348:	ea00003e 	b	3f0a448 <nand_write_ecc+0x1a8>
	}

	/* Loop until all data is written */
	while (*retlen < len) {
 3f0a34c:	e5963000 	ldr	r3, [r6]
 3f0a350:	e1530007 	cmp	r3, r7
 3f0a354:	2a00003a 	bcs	3f0a444 <nand_write_ecc+0x1a4>
		/* Invalidate cache, if we write to this page */
		if (nand->cache_page == page)
 3f0a358:	e595300c 	ldr	r3, [r5, #12]
 3f0a35c:	e153000a 	cmp	r3, r10
			nand->cache_page = -1;
 3f0a360:	03e03000 	mvneq	r3, #0	; 0x0
 3f0a364:	0585300c 	streq	r3, [r5, #12]

		/* Write data into buffer */
		if ((col + len) >= nand->oobblock)
 3f0a368:	e5952048 	ldr	r2, [r5, #72]
 3f0a36c:	e08e3007 	add	r3, r14, r7
 3f0a370:	e1530002 	cmp	r3, r2
 3f0a374:	3a000013 	bcc	3f0a3c8 <nand_write_ecc+0x128>
			for (i = col, cnt = 0; i < nand->oobblock; i++, cnt++)
 3f0a378:	e1a0c00e 	mov	r12, r14
 3f0a37c:	e3a04000 	mov	r4, #0	; 0x0
 3f0a380:	e15e0002 	cmp	r14, r2
 3f0a384:	2a00001e 	bcs	3f0a404 <nand_write_ecc+0x164>
				nand->data_buf[i] = buf[(*retlen + cnt)];
 3f0a388:	e5963000 	ldr	r3, [r6]
 3f0a38c:	e5952004 	ldr	r2, [r5, #4]
 3f0a390:	e0833004 	add	r3, r3, r4
 3f0a394:	e7d93003 	ldrb	r3, [r9, r3]
 3f0a398:	e7c2300c 	strb	r3, [r2, r12]
 3f0a39c:	e2844001 	add	r4, r4, #1	; 0x1
 3f0a3a0:	e5953048 	ldr	r3, [r5, #72]
 3f0a3a4:	e28cc001 	add	r12, r12, #1	; 0x1
 3f0a3a8:	e15c0003 	cmp	r12, r3
 3f0a3ac:	3afffff5 	bcc	3f0a388 <nand_write_ecc+0xe8>
 3f0a3b0:	ea000013 	b	3f0a404 <nand_write_ecc+0x164>
 3f0a3b4:	03f1dc2c 	mvneqs	r13, #11264	; 0x2c00
 3f0a3b8:	03f1e41c 	mvneqs	r14, #469762048	; 0x1c000000
 3f0a3bc:	c0003a3a 	andgt	r3, r0, r10, lsr r10
 3f0a3c0:	9c000010 	stcls	0, cr0, [r0], -#64
 3f0a3c4:	03f1dc68 	mvneqs	r13, #26624	; 0x6800
		else
			for (i = col, cnt = 0; cnt < (len - *retlen); i++, cnt++)
 3f0a3c8:	e1a0c00e 	mov	r12, r14
 3f0a3cc:	e5961000 	ldr	r1, [r6]
 3f0a3d0:	e3a04000 	mov	r4, #0	; 0x0
 3f0a3d4:	e1570001 	cmp	r7, r1
 3f0a3d8:	0a000009 	beq	3f0a404 <nand_write_ecc+0x164>
				nand->data_buf[i] = buf[(*retlen + cnt)];
 3f0a3dc:	e5952004 	ldr	r2, [r5, #4]
 3f0a3e0:	e0813004 	add	r3, r1, r4
 3f0a3e4:	e7d93003 	ldrb	r3, [r9, r3]
 3f0a3e8:	e7c2300c 	strb	r3, [r2, r12]
 3f0a3ec:	e2844001 	add	r4, r4, #1	; 0x1
 3f0a3f0:	e5961000 	ldr	r1, [r6]
 3f0a3f4:	e28cc001 	add	r12, r12, #1	; 0x1
 3f0a3f8:	e0613007 	rsb	r3, r1, r7
 3f0a3fc:	e1540003 	cmp	r4, r3
 3f0a400:	3afffff5 	bcc	3f0a3dc <nand_write_ecc+0x13c>

		/* We use the same function for write and writev !) */
		ret = nand_write_page (nand, page, col, i, ecc_code);
 3f0a404:	e1a00005 	mov	r0, r5
 3f0a408:	e1a0100a 	mov	r1, r10
 3f0a40c:	e59b3008 	ldr	r3, [r11, #8]
 3f0a410:	e1a0200e 	mov	r2, r14
 3f0a414:	e58d3000 	str	r3, [r13]
 3f0a418:	e1a0300c 	mov	r3, r12
 3f0a41c:	ebfffeef 	bl	3f09fe0 <nand_write_page>
		if (ret)
 3f0a420:	e250c000 	subs	r12, r0, #0	; 0x0
 3f0a424:	1a000007 	bne	3f0a448 <nand_write_ecc+0x1a8>
			goto out;

		/* Next data start at page boundary */
		col = 0;
 3f0a428:	e1a0e00c 	mov	r14, r12

		/* Update written bytes count */
		*retlen += cnt;
 3f0a42c:	e5963000 	ldr	r3, [r6]

		/* Increment page address */
		page++;
 3f0a430:	e28aa001 	add	r10, r10, #1	; 0x1
 3f0a434:	e0833004 	add	r3, r3, r4
	}
 3f0a438:	e1530007 	cmp	r3, r7
 3f0a43c:	e5863000 	str	r3, [r6]
 3f0a440:	3affffc4 	bcc	3f0a358 <nand_write_ecc+0xb8>

	/* Return happy */
	*retlen = len;
 3f0a444:	e5867000 	str	r7, [r6]

out:
	/* De-select the NAND device */
	NAND_DISABLE_CE(nand);  /* set pin high */
 3f0a448:	e59f3024 	ldr	r3, [pc, #24]	; 3f0a474 <nand_write_ecc+0x1d4>
 3f0a44c:	e1d320b0 	ldrh	r2, [r3]
 3f0a450:	e3c22080 	bic	r2, r2, #128	; 0x80
 3f0a454:	e1a02802 	mov	r2, r2, lsl #16
 3f0a458:	e1a02822 	mov	r2, r2, lsr #16
 3f0a45c:	e1c320b0 	strh	r2, [r3]
 3f0a460:	e1d320b0 	ldrh	r2, [r3]
 3f0a464:	e3822902 	orr	r2, r2, #32768	; 0x8000
 3f0a468:	e1c320b0 	strh	r2, [r3]
#ifdef CONFIG_OMAP1510
    	archflashwp(0,1);
#endif
	return ret;
 3f0a46c:	e1a0000c 	mov	r0, r12
 3f0a470:	ea000000 	b	3f0a478 <nand_write_ecc+0x1d8>
 3f0a474:	c0003a3a 	andgt	r3, r0, r10, lsr r10
}
 3f0a478:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0a47c <nand_read_oob>:
 3f0a47c:	e1a0c00d 	mov	r12, r13
 3f0a480:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0a484:	e24cb004 	sub	r11, r12, #4	; 0x4

/* read from the 16 bytes of oob data that correspond to a 512 byte
 * page or 2 256-byte pages.
 */
static int nand_read_oob(struct nand_chip* nand, size_t ofs, size_t len,
			 size_t * retlen, u_char * buf)
{
 3f0a488:	e1a04001 	mov	r4, r1
 3f0a48c:	e1a05000 	mov	r5, r0
	int len256 = 0;
	struct Nand *mychip;
	int ret = 0;
 3f0a490:	e3a07000 	mov	r7, #0	; 0x0
 3f0a494:	e24dd004 	sub	r13, r13, #4	; 0x4

	mychip = &nand->chips[ofs >> nand->chipshift];

	/* update address for 2M x 8bit devices. OOB starts on the second */
	/* page to maintain compatibility with nand_read_ecc. */
	if (nand->page256) {
 3f0a498:	e5d5103c 	ldrb	r1, [r5, #60]
 3f0a49c:	e1a06002 	mov	r6, r2
 3f0a4a0:	e50b3028 	str	r3, [r11, -#40]
 3f0a4a4:	e1510007 	cmp	r1, r7
 3f0a4a8:	0a000002 	beq	3f0a4b8 <nand_read_oob+0x3c>
		if (!(ofs & 0x8))
 3f0a4ac:	e3140008 	tst	r4, #8	; 0x8
			ofs += 0x100;
 3f0a4b0:	02844c01 	addeq	r4, r4, #256	; 0x100
		else
			ofs -= 0x8;
 3f0a4b4:	12444008 	subne	r4, r4, #8	; 0x8
	}
	dprintf("nand_read_oob_0\n");
	NAND_ENABLE_CE(nand);  /* set pin low */
 3f0a4b8:	e59f20d8 	ldr	r2, [pc, #d8]	; 3f0a598 <nand_read_oob+0x11c>
 3f0a4bc:	e1d230b0 	ldrh	r3, [r2]
 3f0a4c0:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0a4c4:	e1c230b0 	strh	r3, [r2]
 3f0a4c8:	e1d230b0 	ldrh	r3, [r2]
 3f0a4cc:	e3833080 	orr	r3, r3, #128	; 0x80
 3f0a4d0:	e1c230b0 	strh	r3, [r2]
 3f0a4d4:	e3a09050 	mov	r9, #80	; 0x50
 3f0a4d8:	e59fa0bc 	ldr	r10, [pc, #bc]	; 3f0a59c <nand_read_oob+0x120>
 3f0a4dc:	e5ca9000 	strb	r9, [r10]
	NanD_Command(nand, NAND_CMD_READOOB);
	NanD_Address(nand, ADDR_COLUMN_PAGE, ofs);
 3f0a4e0:	e1a00005 	mov	r0, r5
 3f0a4e4:	e3a01003 	mov	r1, #3	; 0x3
 3f0a4e8:	e1a02004 	mov	r2, r4
 3f0a4ec:	ebfffc7a 	bl	3f096dc <NanD_Address>

	dprintf("nand_read_oob_1\n");
	/* treat crossing 8-byte OOB data for 2M x 8bit devices */
	/* Note: datasheet says it should automaticaly wrap to the */
	/*       next OOB block, but it didn't work here. mf.      */
	if (nand->page256 && ofs + len > (ofs | 0x7) + 1) {
 3f0a4f0:	e5d5303c 	ldrb	r3, [r5, #60]
 3f0a4f4:	e3530000 	cmp	r3, #0	; 0x0
 3f0a4f8:	0a000010 	beq	3f0a540 <nand_read_oob+0xc4>
 3f0a4fc:	e0842006 	add	r2, r4, r6
 3f0a500:	e3841007 	orr	r1, r4, #7	; 0x7
 3f0a504:	e2813001 	add	r3, r1, #1	; 0x1
 3f0a508:	e1520003 	cmp	r2, r3
 3f0a50c:	9a00000b 	bls	3f0a540 <nand_read_oob+0xc4>
		len256 = (ofs | 0x7) + 1 - ofs;
 3f0a510:	e2443001 	sub	r3, r4, #1	; 0x1
 3f0a514:	e0637001 	rsb	r7, r3, r1
		NanD_ReadBuf(nand, buf, len256);
 3f0a518:	e1a00005 	mov	r0, r5
 3f0a51c:	e59b1004 	ldr	r1, [r11, #4]
 3f0a520:	e1a02007 	mov	r2, r7
 3f0a524:	ebfffd94 	bl	3f09b7c <NanD_ReadBuf>
 3f0a528:	e5ca9000 	strb	r9, [r10]

		NanD_Command(nand, NAND_CMD_READOOB);
		NanD_Address(nand, ADDR_COLUMN_PAGE, ofs & (~0x1ff));
 3f0a52c:	e1a00005 	mov	r0, r5
 3f0a530:	e3a01003 	mov	r1, #3	; 0x3
 3f0a534:	e3c42f7f 	bic	r2, r4, #508	; 0x1fc
 3f0a538:	e3c22003 	bic	r2, r2, #3	; 0x3
 3f0a53c:	ebfffc66 	bl	3f096dc <NanD_Address>
	}

	udelay(9);
 3f0a540:	e3a00009 	mov	r0, #9	; 0x9
 3f0a544:	ebffd8b3 	bl	3f00818 <udelay>

	dprintf("nand_read_oob_2\n");
	NanD_ReadBuf(nand, &buf[len256], len - len256);
 3f0a548:	e1a00005 	mov	r0, r5
 3f0a54c:	e59b3004 	ldr	r3, [r11, #4]
 3f0a550:	e0672006 	rsb	r2, r7, r6
 3f0a554:	e0831007 	add	r1, r3, r7
 3f0a558:	ebfffd87 	bl	3f09b7c <NanD_ReadBuf>

	*retlen = len;
 3f0a55c:	e51b3028 	ldr	r3, [r11, -#40]
	/* Reading the full OOB data drops us off of the end of the page,
	 * causing the flash device to go into busy mode, so we need
	 * to wait until ready 11.4.1 and Toshiba TC58256FT nands */

	ret = NanD_WaitReady(nand, 1);
 3f0a560:	e1a00005 	mov	r0, r5
 3f0a564:	e5836000 	str	r6, [r3]
 3f0a568:	e3a01001 	mov	r1, #1	; 0x1
 3f0a56c:	ebfffc4a 	bl	3f0969c <NanD_WaitReady>
	dprintf("nand_read_oob_3\n");
	NAND_DISABLE_CE(nand);  /* set pin high */
 3f0a570:	e59f3020 	ldr	r3, [pc, #20]	; 3f0a598 <nand_read_oob+0x11c>
 3f0a574:	e1d320b0 	ldrh	r2, [r3]
 3f0a578:	e3c22080 	bic	r2, r2, #128	; 0x80
 3f0a57c:	e1a02802 	mov	r2, r2, lsl #16
 3f0a580:	e1a02822 	mov	r2, r2, lsr #16
 3f0a584:	e1c320b0 	strh	r2, [r3]
 3f0a588:	e1d320b0 	ldrh	r2, [r3]
 3f0a58c:	e3822902 	orr	r2, r2, #32768	; 0x8000
 3f0a590:	e1c320b0 	strh	r2, [r3]
 3f0a594:	ea000001 	b	3f0a5a0 <nand_read_oob+0x124>
 3f0a598:	c0003a3a 	andgt	r3, r0, r10, lsr r10
 3f0a59c:	9c000010 	stcls	0, cr0, [r0], -#64

	return ret;

}
 3f0a5a0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0a5a4 <nand_write_oob>:
 3f0a5a4:	e1a0c00d 	mov	r12, r13
 3f0a5a8:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0a5ac:	e24cb004 	sub	r11, r12, #4	; 0x4

/* write to the 16 bytes of oob data that correspond to a 512 byte
 * page or 2 256-byte pages.
 */
static int nand_write_oob(struct nand_chip* nand, size_t ofs, size_t len,
		  size_t * retlen, const u_char * buf)
{
 3f0a5b0:	e1a04001 	mov	r4, r1
	int len256 = 0;
 3f0a5b4:	e3a0a000 	mov	r10, #0	; 0x0
 3f0a5b8:	e1a05000 	mov	r5, r0
 3f0a5bc:	e1a07002 	mov	r7, r2
 3f0a5c0:	e1a09003 	mov	r9, r3
	int i;
	unsigned long nandptr = nand->IO_ADDR;

	NAND_ENABLE_CE(nand);  /* set pin low to enable chip */
 3f0a5c4:	e59f2210 	ldr	r2, [pc, #210]	; 3f0a7dc <nand_write_oob+0x238>
 3f0a5c8:	e1d230b0 	ldrh	r3, [r2]
 3f0a5cc:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0a5d0:	e1c230b0 	strh	r3, [r2]
 3f0a5d4:	e1d230b0 	ldrh	r3, [r2]
 3f0a5d8:	e3833080 	orr	r3, r3, #128	; 0x80
 3f0a5dc:	e1c230b0 	strh	r3, [r2]
 3f0a5e0:	e3a030ff 	mov	r3, #255	; 0xff
 3f0a5e4:	e59f21f4 	ldr	r2, [pc, #1f4]	; 3f0a7e0 <nand_write_oob+0x23c>
 3f0a5e8:	e5c23000 	strb	r3, [r2]
 3f0a5ec:	e24330af 	sub	r3, r3, #175	; 0xaf
 3f0a5f0:	e5c23000 	strb	r3, [r2]

	/* Reset the chip */
	NanD_Command(nand, NAND_CMD_RESET);

	/* issue the Read2 command to set the pointer to the Spare Data Area. */
	NanD_Command(nand, NAND_CMD_READOOB);
	NanD_Address(nand, ADDR_COLUMN_PAGE, ofs);
 3f0a5f4:	e3a01003 	mov	r1, #3	; 0x3
 3f0a5f8:	e1a02004 	mov	r2, r4
 3f0a5fc:	ebfffc36 	bl	3f096dc <NanD_Address>

	/* update address for 2M x 8bit devices. OOB starts on the second */
	/* page to maintain compatibility with nand_read_ecc. */
	if (nand->page256) {
 3f0a600:	e5d5303c 	ldrb	r3, [r5, #60]
 3f0a604:	e153000a 	cmp	r3, r10
 3f0a608:	0a000002 	beq	3f0a618 <nand_write_oob+0x74>
		if (!(ofs & 0x8))
 3f0a60c:	e3140008 	tst	r4, #8	; 0x8
			ofs += 0x100;
 3f0a610:	02844c01 	addeq	r4, r4, #256	; 0x100
		else
			ofs -= 0x8;
 3f0a614:	12444008 	subne	r4, r4, #8	; 0x8
 3f0a618:	e3a03080 	mov	r3, #128	; 0x80
 3f0a61c:	e59f21bc 	ldr	r2, [pc, #1bc]	; 3f0a7e0 <nand_write_oob+0x23c>
 3f0a620:	e5c23000 	strb	r3, [r2]
	}

	/* issue the Serial Data In command to initial the Page Program process */
	NanD_Command(nand, NAND_CMD_SEQIN);
	NanD_Address(nand, ADDR_COLUMN_PAGE, ofs);
 3f0a624:	e1a00005 	mov	r0, r5
 3f0a628:	e3a01003 	mov	r1, #3	; 0x3
 3f0a62c:	e1a02004 	mov	r2, r4
 3f0a630:	ebfffc29 	bl	3f096dc <NanD_Address>

	/* treat crossing 8-byte OOB data for 2M x 8bit devices */
	/* Note: datasheet says it should automaticaly wrap to the */
	/*       next OOB block, but it didn't work here. mf.      */
	if (nand->page256 && ofs + len > (ofs | 0x7) + 1) {
 3f0a634:	e5d5303c 	ldrb	r3, [r5, #60]
 3f0a638:	e3530000 	cmp	r3, #0	; 0x0
 3f0a63c:	0a000034 	beq	3f0a714 <nand_write_oob+0x170>
 3f0a640:	e0842007 	add	r2, r4, r7
 3f0a644:	e3841007 	orr	r1, r4, #7	; 0x7
 3f0a648:	e2813001 	add	r3, r1, #1	; 0x1
 3f0a64c:	e1520003 	cmp	r2, r3
 3f0a650:	9a00002f 	bls	3f0a714 <nand_write_oob+0x170>
		len256 = (ofs | 0x7) + 1 - ofs;
 3f0a654:	e2443001 	sub	r3, r4, #1	; 0x1
 3f0a658:	e063a001 	rsb	r10, r3, r1
		for (i = 0; i < len256; i++)
 3f0a65c:	e3a01000 	mov	r1, #0	; 0x0
 3f0a660:	e151000a 	cmp	r1, r10
 3f0a664:	aa000006 	bge	3f0a684 <nand_write_oob+0xe0>
			WRITE_NAND(buf[i], nandptr);
 3f0a668:	e59b3004 	ldr	r3, [r11, #4]
 3f0a66c:	e7d32001 	ldrb	r2, [r3, r1]
 3f0a670:	e2811001 	add	r1, r1, #1	; 0x1
 3f0a674:	e151000a 	cmp	r1, r10
 3f0a678:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f0a67c:	e5c32000 	strb	r2, [r3]
 3f0a680:	bafffff8 	blt	3f0a668 <nand_write_oob+0xc4>
 3f0a684:	e3a03010 	mov	r3, #16	; 0x10
 3f0a688:	e59f6150 	ldr	r6, [pc, #150]	; 3f0a7e0 <nand_write_oob+0x23c>
 3f0a68c:	e5c63000 	strb	r3, [r6]

		NanD_Command(nand, NAND_CMD_PAGEPROG);
#ifdef CONFIG_MMSP20
	       	NanD_WaitReady(nand, 0);
 3f0a690:	e1a00005 	mov	r0, r5
 3f0a694:	e3a01000 	mov	r1, #0	; 0x0
 3f0a698:	ebfffbff 	bl	3f0969c <NanD_WaitReady>
#endif

		udelay(300); // hwjang
 3f0a69c:	e3a00f4b 	mov	r0, #300	; 0x12c
 3f0a6a0:	ebffd85c 	bl	3f00818 <udelay>
 3f0a6a4:	e3a03070 	mov	r3, #112	; 0x70
 3f0a6a8:	e5c63000 	strb	r3, [r6]

		NanD_Command(nand, NAND_CMD_STATUS);
#ifdef NAND_NO_RB
   		{ u_char ret_val;
    		  do{
		  	ret_val = READ_NAND(nandptr); /* wait till ready */
    		  }while((ret_val & 0x40) != 0x40);
		}
#endif
		if (READ_NAND(nandptr) & 1) {
 3f0a6ac:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f0a6b0:	e5d33000 	ldrb	r3, [r3]
 3f0a6b4:	e3130001 	tst	r3, #1	; 0x1
 3f0a6b8:	0a00000e 	beq	3f0a6f8 <nand_write_oob+0x154>
			puts ("Error programming oob data\n");
 3f0a6bc:	e59f0120 	ldr	r0, [pc, #120]	; 3f0a7e4 <nand_write_oob+0x240>
 3f0a6c0:	eb000852 	bl	3f0c810 <puts>
			/* There was an error */
			NAND_DISABLE_CE(nand);  /* set pin high */
 3f0a6c4:	e59f2110 	ldr	r2, [pc, #110]	; 3f0a7dc <nand_write_oob+0x238>
 3f0a6c8:	e1d230b0 	ldrh	r3, [r2]
 3f0a6cc:	e3c33080 	bic	r3, r3, #128	; 0x80
 3f0a6d0:	e1a03803 	mov	r3, r3, lsl #16
 3f0a6d4:	e1a03823 	mov	r3, r3, lsr #16
 3f0a6d8:	e1c230b0 	strh	r3, [r2]
 3f0a6dc:	e1d230b0 	ldrh	r3, [r2]
 3f0a6e0:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0a6e4:	e1c230b0 	strh	r3, [r2]
			*retlen = 0;
 3f0a6e8:	e3a03000 	mov	r3, #0	; 0x0
			return -1;
 3f0a6ec:	e3e00000 	mvn	r0, #0	; 0x0
 3f0a6f0:	e5893000 	str	r3, [r9]
 3f0a6f4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f0a6f8:	e3a03080 	mov	r3, #128	; 0x80
 3f0a6fc:	e5c63000 	strb	r3, [r6]
		}
		NanD_Command(nand, NAND_CMD_SEQIN);
		NanD_Address(nand, ADDR_COLUMN_PAGE, ofs & (~0x1ff));
 3f0a700:	e1a00005 	mov	r0, r5
 3f0a704:	e3a01003 	mov	r1, #3	; 0x3
 3f0a708:	e3c42f7f 	bic	r2, r4, #508	; 0x1fc
 3f0a70c:	e3c22003 	bic	r2, r2, #3	; 0x3
 3f0a710:	ebfffbf1 	bl	3f096dc <NanD_Address>
	}

	for (i = len256; i < len; i++)
 3f0a714:	e1a0100a 	mov	r1, r10
 3f0a718:	e1510007 	cmp	r1, r7
 3f0a71c:	2a000006 	bcs	3f0a73c <nand_write_oob+0x198>
		WRITE_NAND(buf[i], nandptr);
 3f0a720:	e59b3004 	ldr	r3, [r11, #4]
 3f0a724:	e7d32001 	ldrb	r2, [r3, r1]
 3f0a728:	e2811001 	add	r1, r1, #1	; 0x1
 3f0a72c:	e1510007 	cmp	r1, r7
 3f0a730:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f0a734:	e5c32000 	strb	r2, [r3]
 3f0a738:	3afffff8 	bcc	3f0a720 <nand_write_oob+0x17c>
 3f0a73c:	e3a03010 	mov	r3, #16	; 0x10
 3f0a740:	e59f4098 	ldr	r4, [pc, #98]	; 3f0a7e0 <nand_write_oob+0x23c>
 3f0a744:	e5c43000 	strb	r3, [r4]

	NanD_Command(nand, NAND_CMD_PAGEPROG);
#ifdef CONFIG_MMSP20
       	NanD_WaitReady(nand, 0);
 3f0a748:	e1a00005 	mov	r0, r5
 3f0a74c:	e3a01000 	mov	r1, #0	; 0x0
 3f0a750:	ebfffbd1 	bl	3f0969c <NanD_WaitReady>
#endif

        udelay(300); 
 3f0a754:	e3a00f4b 	mov	r0, #300	; 0x12c
 3f0a758:	ebffd82e 	bl	3f00818 <udelay>
 3f0a75c:	e3a03070 	mov	r3, #112	; 0x70
 3f0a760:	e5c43000 	strb	r3, [r4]

	NanD_Command(nand, NAND_CMD_STATUS);
#ifdef NAND_NO_RB
	{ u_char ret_val;
	  do{
		ret_val = READ_NAND(nandptr); /* wait till ready */
	  } while((ret_val & 0x40) != 0x40);
	}
#endif
	if (READ_NAND(nandptr) & 1) {
 3f0a764:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f0a768:	e5d33000 	ldrb	r3, [r3]
 3f0a76c:	e2130001 	ands	r0, r3, #1	; 0x1
 3f0a770:	1a00000a 	bne	3f0a7a0 <nand_write_oob+0x1fc>
		puts ("Error programming oob data\n");
		/* There was an error */
		NAND_DISABLE_CE(nand);  /* set pin high */
		*retlen = 0;
		return -1;
	}

	NAND_DISABLE_CE(nand);  /* set pin high */
 3f0a774:	e59f3060 	ldr	r3, [pc, #60]	; 3f0a7dc <nand_write_oob+0x238>
 3f0a778:	e1d320b0 	ldrh	r2, [r3]
 3f0a77c:	e3c22080 	bic	r2, r2, #128	; 0x80
 3f0a780:	e1a02802 	mov	r2, r2, lsl #16
 3f0a784:	e1a02822 	mov	r2, r2, lsr #16
 3f0a788:	e1c320b0 	strh	r2, [r3]
 3f0a78c:	e1d320b0 	ldrh	r2, [r3]
 3f0a790:	e3822902 	orr	r2, r2, #32768	; 0x8000
 3f0a794:	e1c320b0 	strh	r2, [r3]

	*retlen = len;
 3f0a798:	e5897000 	str	r7, [r9]
	return 0;
 3f0a79c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f0a7a0:	e59f003c 	ldr	r0, [pc, #3c]	; 3f0a7e4 <nand_write_oob+0x240>
 3f0a7a4:	eb000819 	bl	3f0c810 <puts>
 3f0a7a8:	e59f202c 	ldr	r2, [pc, #2c]	; 3f0a7dc <nand_write_oob+0x238>
 3f0a7ac:	e1d230b0 	ldrh	r3, [r2]
 3f0a7b0:	e3c33080 	bic	r3, r3, #128	; 0x80
 3f0a7b4:	e1a03803 	mov	r3, r3, lsl #16
 3f0a7b8:	e1a03823 	mov	r3, r3, lsr #16
 3f0a7bc:	e1c230b0 	strh	r3, [r2]
 3f0a7c0:	e1d230b0 	ldrh	r3, [r2]
 3f0a7c4:	e3e00000 	mvn	r0, #0	; 0x0
 3f0a7c8:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0a7cc:	e1c230b0 	strh	r3, [r2]
 3f0a7d0:	e3a03000 	mov	r3, #0	; 0x0
 3f0a7d4:	e5893000 	str	r3, [r9]

}
 3f0a7d8:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f0a7dc:	c0003a3a 	andgt	r3, r0, r10, lsr r10
 3f0a7e0:	9c000010 	stcls	0, cr0, [r0], -#64
 3f0a7e4:	03f1e42c 	mvneqs	r14, #738197504	; 0x2c000000

03f0a7e8 <nand_write_jffs2_func>:
 3f0a7e8:	e1a0c00d 	mov	r12, r13
 3f0a7ec:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f0a7f0:	e24cb004 	sub	r11, r12, #4	; 0x4

int nand_write_jffs2_func(ulong addrm, ulong ofs, ulong len)
{
	ulong addr 	= addrm;
	ulong off  	= ofs;
	ulong size 	= len;
	int cmd    	= NANDRW_WRITE;
 3f0a7f4:	e3a04000 	mov	r4, #0	; 0x0
 3f0a7f8:	e1a0a000 	mov	r10, r0
	int ret		= 0; 
	int total	= 0;
	
	cmd |= NANDRW_JFFS2;	/* skip bad blocks */
	
	printf ("\nNAND %s: device %d offset 0x%x, size 0x%x ... ", (cmd & NANDRW_READ) ? "read" : "write", curr_device, off, size);
 3f0a7fc:	e59f0084 	ldr	r0, [pc, #84]	; 3f0a888 <nand_write_jffs2_func+0xa0>
 3f0a800:	e1a07002 	mov	r7, r2
 3f0a804:	e59f6080 	ldr	r6, [pc, #80]	; 3f0a88c <nand_write_jffs2_func+0xa4>
 3f0a808:	e1a05001 	mov	r5, r1
 3f0a80c:	e59f107c 	ldr	r1, [pc, #7c]	; 3f0a890 <nand_write_jffs2_func+0xa8>
 3f0a810:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f0a814:	e50b4024 	str	r4, [r11, -#36]
 3f0a818:	e1a03005 	mov	r3, r5
 3f0a81c:	e5962000 	ldr	r2, [r6]
 3f0a820:	e3844002 	orr	r4, r4, #2	; 0x2
 3f0a824:	e58d7000 	str	r7, [r13]
 3f0a828:	eb000805 	bl	3f0c844 <printf>
	ret = nand_rw(nand_dev_desc + curr_device, cmd, off, size, &total, (u_char*)addr);
 3f0a82c:	e24b3024 	sub	r3, r11, #36	; 0x24
 3f0a830:	e58d3000 	str	r3, [r13]
 3f0a834:	e1a01004 	mov	r1, r4
 3f0a838:	e5960000 	ldr	r0, [r6]
 3f0a83c:	e1a02005 	mov	r2, r5
 3f0a840:	e58da004 	str	r10, [r13, #4]
 3f0a844:	e1a03007 	mov	r3, r7
 3f0a848:	e59fc044 	ldr	r12, [pc, #44]	; 3f0a894 <nand_write_jffs2_func+0xac>
 3f0a84c:	e0800080 	add	r0, r0, r0, lsl #1
 3f0a850:	e0600180 	rsb	r0, r0, r0, lsl #3
 3f0a854:	e08c0100 	add	r0, r12, r0, lsl #2
 3f0a858:	ebfffad2 	bl	3f093a8 <nand_rw>

	printf(" %d bytes %s: %s\n", total, (cmd & NANDRW_READ) ? "read" : "written", ret ? "ERROR" : "OK");
 3f0a85c:	e59f3034 	ldr	r3, [pc, #34]	; 3f0a898 <nand_write_jffs2_func+0xb0>
 3f0a860:	e1a04000 	mov	r4, r0
 3f0a864:	e59f0030 	ldr	r0, [pc, #30]	; 3f0a89c <nand_write_jffs2_func+0xb4>
 3f0a868:	e51b1024 	ldr	r1, [r11, -#36]
 3f0a86c:	e59fc02c 	ldr	r12, [pc, #2c]	; 3f0a8a0 <nand_write_jffs2_func+0xb8>
 3f0a870:	e3540000 	cmp	r4, #0	; 0x0
 3f0a874:	e59f2028 	ldr	r2, [pc, #28]	; 3f0a8a4 <nand_write_jffs2_func+0xbc>
 3f0a878:	11a0300c 	movne	r3, r12
 3f0a87c:	eb0007f0 	bl	3f0c844 <printf>

	return ret;
 3f0a880:	e1a00004 	mov	r0, r4
 3f0a884:	ea000007 	b	3f0a8a8 <nand_write_jffs2_func+0xc0>
 3f0a888:	03f1dda8 	mvneqs	r13, #10752	; 0x2a00
 3f0a88c:	03f20848 	mvneqs	r0, #4718592	; 0x480000
 3f0a890:	03f1dd80 	mvneqs	r13, #8192	; 0x2000
 3f0a894:	03f207f4 	mvneqs	r0, #63963136	; 0x3d00000
 3f0a898:	03f1dd74 	mvneqs	r13, #7424	; 0x1d00
 3f0a89c:	03f1ddd8 	mvneqs	r13, #13824	; 0x3600
 3f0a8a0:	03f1dd6c 	mvneqs	r13, #6912	; 0x1b00
 3f0a8a4:	03f1ddec 	mvneqs	r13, #15104	; 0x3b00
}
 3f0a8a8:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f0a8ac <nand_write_func>:
 3f0a8ac:	e1a0c00d 	mov	r12, r13
 3f0a8b0:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f0a8b4:	e24cb004 	sub	r11, r12, #4	; 0x4

int nand_write_func(ulong addrm, ulong ofs, ulong len)
{
 3f0a8b8:	e1a0a000 	mov	r10, r0
	ulong addr 	= addrm;
	ulong off  	= ofs;
	ulong size 	= len;
	int cmd    	= NANDRW_WRITE;
	int ret		= 0; 
	int total	= 0;
	
	printf ("\nNAND %s: device %d offset 0x%x, size 0x%x ... ", (cmd & NANDRW_READ) ? "read" : "write", curr_device, off, size);
 3f0a8bc:	e59f0084 	ldr	r0, [pc, #84]	; 3f0a948 <nand_write_func+0x9c>
 3f0a8c0:	e3a06000 	mov	r6, #0	; 0x0
 3f0a8c4:	e59f5080 	ldr	r5, [pc, #80]	; 3f0a94c <nand_write_func+0xa0>
 3f0a8c8:	e1a04001 	mov	r4, r1
 3f0a8cc:	e59f107c 	ldr	r1, [pc, #7c]	; 3f0a950 <nand_write_func+0xa4>
 3f0a8d0:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f0a8d4:	e50b6024 	str	r6, [r11, -#36]
 3f0a8d8:	e1a07002 	mov	r7, r2
 3f0a8dc:	e5952000 	ldr	r2, [r5]
 3f0a8e0:	e1a03004 	mov	r3, r4
 3f0a8e4:	e58d7000 	str	r7, [r13]
 3f0a8e8:	eb0007d5 	bl	3f0c844 <printf>
	ret = nand_rw(nand_dev_desc + curr_device, cmd, off, size, &total, (u_char*)addr);
 3f0a8ec:	e24b3024 	sub	r3, r11, #36	; 0x24
 3f0a8f0:	e58d3000 	str	r3, [r13]
 3f0a8f4:	e1a01006 	mov	r1, r6
 3f0a8f8:	e5950000 	ldr	r0, [r5]
 3f0a8fc:	e1a02004 	mov	r2, r4
 3f0a900:	e58da004 	str	r10, [r13, #4]
 3f0a904:	e1a03007 	mov	r3, r7
 3f0a908:	e59fc044 	ldr	r12, [pc, #44]	; 3f0a954 <nand_write_func+0xa8>
 3f0a90c:	e0800080 	add	r0, r0, r0, lsl #1
 3f0a910:	e0600180 	rsb	r0, r0, r0, lsl #3
 3f0a914:	e08c0100 	add	r0, r12, r0, lsl #2
 3f0a918:	ebfffaa2 	bl	3f093a8 <nand_rw>

	printf(" %d bytes %s: %s\n", total, (cmd & NANDRW_READ) ? "read" : "written", ret ? "ERROR" : "OK");
 3f0a91c:	e59f3034 	ldr	r3, [pc, #34]	; 3f0a958 <nand_write_func+0xac>
 3f0a920:	e1a04000 	mov	r4, r0
 3f0a924:	e59f0030 	ldr	r0, [pc, #30]	; 3f0a95c <nand_write_func+0xb0>
 3f0a928:	e51b1024 	ldr	r1, [r11, -#36]
 3f0a92c:	e59fc02c 	ldr	r12, [pc, #2c]	; 3f0a960 <nand_write_func+0xb4>
 3f0a930:	e1540006 	cmp	r4, r6
 3f0a934:	e59f2028 	ldr	r2, [pc, #28]	; 3f0a964 <nand_write_func+0xb8>
 3f0a938:	11a0300c 	movne	r3, r12
 3f0a93c:	eb0007c0 	bl	3f0c844 <printf>

	return ret;
 3f0a940:	e1a00004 	mov	r0, r4
 3f0a944:	ea000007 	b	3f0a968 <nand_write_func+0xbc>
 3f0a948:	03f1dda8 	mvneqs	r13, #10752	; 0x2a00
 3f0a94c:	03f20848 	mvneqs	r0, #4718592	; 0x480000
 3f0a950:	03f1dd80 	mvneqs	r13, #8192	; 0x2000
 3f0a954:	03f207f4 	mvneqs	r0, #63963136	; 0x3d00000
 3f0a958:	03f1dd74 	mvneqs	r13, #7424	; 0x1d00
 3f0a95c:	03f1ddd8 	mvneqs	r13, #13824	; 0x3600
 3f0a960:	03f1dd6c 	mvneqs	r13, #6912	; 0x1b00
 3f0a964:	03f1ddec 	mvneqs	r13, #15104	; 0x3b00
}
 3f0a968:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f0a96c <nand_erase_func>:
 3f0a96c:	e1a0c00d 	mov	r12, r13
 3f0a970:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0a974:	e24cb004 	sub	r11, r12, #4	; 0x4

int nand_erase_func(size_t ofs, size_t len)
{
 3f0a978:	e1a0c000 	mov	r12, r0
	return nand_erase(nand_dev_desc + curr_device, ofs, len, 0);
 3f0a97c:	e59f3024 	ldr	r3, [pc, #24]	; 3f0a9a8 <nand_erase_func+0x3c>
 3f0a980:	e1a02001 	mov	r2, r1
 3f0a984:	e5933000 	ldr	r3, [r3]
 3f0a988:	e1a0100c 	mov	r1, r12
 3f0a98c:	e59f0018 	ldr	r0, [pc, #18]	; 3f0a9ac <nand_erase_func+0x40>
 3f0a990:	e0833083 	add	r3, r3, r3, lsl #1
 3f0a994:	e0633183 	rsb	r3, r3, r3, lsl #3
 3f0a998:	e0800103 	add	r0, r0, r3, lsl #2
 3f0a99c:	e3a03000 	mov	r3, #0	; 0x0
 3f0a9a0:	eb000002 	bl	3f0a9b0 <nand_erase>
 3f0a9a4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0a9a8:	03f20848 	mvneqs	r0, #4718592	; 0x480000
 3f0a9ac:	03f207f4 	mvneqs	r0, #63963136	; 0x3d00000

03f0a9b0 <nand_erase>:
 3f0a9b0:	e1a0c00d 	mov	r12, r13
 3f0a9b4:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0a9b8:	e24cb004 	sub	r11, r12, #4	; 0x4
}

static int nand_erase(struct nand_chip* nand, size_t ofs, size_t len, int clean)
{
 3f0a9bc:	e1a06001 	mov	r6, r1
 3f0a9c0:	e1a07002 	mov	r7, r2
 3f0a9c4:	e1a05000 	mov	r5, r0
 3f0a9c8:	e24dd00c 	sub	r13, r13, #12	; 0xc
	/* This is defined as a structure so it will work on any system
	 * using native endian jffs2 (the default).
	 */
	static struct jffs2_unknown_node clean_marker = {
		JFFS2_MAGIC_BITMASK,
		JFFS2_NODETYPE_CLEANMARKER,
		8		/* 8 bytes in this node */
	};
	unsigned long nandptr;
	struct Nand *mychip;
	int ret = 0;
	
	if (ofs & (nand->erasesize-1) || len & (nand->erasesize-1)) {
 3f0a9cc:	e5951028 	ldr	r1, [r5, #40]
 3f0a9d0:	e3a09000 	mov	r9, #0	; 0x0
 3f0a9d4:	e50b302c 	str	r3, [r11, -#44]
 3f0a9d8:	e2412001 	sub	r2, r1, #1	; 0x1
 3f0a9dc:	e1160002 	tst	r6, r2
 3f0a9e0:	1a000001 	bne	3f0a9ec <nand_erase+0x3c>
 3f0a9e4:	e1170002 	tst	r7, r2
 3f0a9e8:	0a000003 	beq	3f0a9fc <nand_erase+0x4c>
		printf ("Offset and size must be sector aligned, erasesize = %d\n",
 3f0a9ec:	e59f0130 	ldr	r0, [pc, #130]	; 3f0ab24 <nand_erase+0x174>
 3f0a9f0:	eb000793 	bl	3f0c844 <printf>
			(int) nand->erasesize);
		return -1;
 3f0a9f4:	e3e00000 	mvn	r0, #0	; 0x0
 3f0a9f8:	ea000068 	b	3f0aba0 <nand_erase+0x1f0>
	}

	nandptr = nand->IO_ADDR;

	/* Select the NAND device */
#ifdef CONFIG_OMAP1510
	archflashwp(0,0);
#endif
        NAND_ENABLE_CE(nand);  /* set pin low */
 3f0a9fc:	e59f2124 	ldr	r2, [pc, #124]	; 3f0ab28 <nand_erase+0x178>
 3f0aa00:	e1d230b0 	ldrh	r3, [r2]
 3f0aa04:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0aa08:	e1c230b0 	strh	r3, [r2]
 3f0aa0c:	e1d230b0 	ldrh	r3, [r2]
 3f0aa10:	e3833080 	orr	r3, r3, #128	; 0x80
 3f0aa14:	e1c230b0 	strh	r3, [r2]
 3f0aa18:	e3a00070 	mov	r0, #112	; 0x70
 3f0aa1c:	e59f1108 	ldr	r1, [pc, #108]	; 3f0ab2c <nand_erase+0x17c>
 3f0aa20:	e5c10000 	strb	r0, [r1]

	/* Check the WP bit */
	NanD_Command(nand, NAND_CMD_STATUS);
	if (!(READ_NAND(nand->IO_ADDR) & 0x80)) {
 3f0aa24:	e3a02327 	mov	r2, #-1677721600	; 0x9c000000
 3f0aa28:	e5d23000 	ldrb	r3, [r2]
 3f0aa2c:	e3130080 	tst	r3, #128	; 0x80
 3f0aa30:	1a000003 	bne	3f0aa44 <nand_erase+0x94>
		printf ("nand_write_ecc: Device is write protected!!!\n");
 3f0aa34:	e59f00f4 	ldr	r0, [pc, #f4]	; 3f0ab30 <nand_erase+0x180>
		ret = -1;
 3f0aa38:	e3e09000 	mvn	r9, #0	; 0x0
 3f0aa3c:	eb000780 	bl	3f0c844 <printf>
		goto out;
 3f0aa40:	ea00004c 	b	3f0ab78 <nand_erase+0x1c8>
 3f0aa44:	e5c10000 	strb	r0, [r1]
	}

	/* Check the WP bit */
	NanD_Command(nand, NAND_CMD_STATUS);
	if (!(READ_NAND(nand->IO_ADDR) & 0x80)) {
 3f0aa48:	e5d23000 	ldrb	r3, [r2]
 3f0aa4c:	e3130080 	tst	r3, #128	; 0x80
 3f0aa50:	1a00000a 	bne	3f0aa80 <nand_erase+0xd0>
		printf ("%s: Device is write protected!!!\n", __FUNCTION__);
 3f0aa54:	e59f00d8 	ldr	r0, [pc, #d8]	; 3f0ab34 <nand_erase+0x184>
 3f0aa58:	e59f10d8 	ldr	r1, [pc, #d8]	; 3f0ab38 <nand_erase+0x188>
		ret = -1;
 3f0aa5c:	e3e09000 	mvn	r9, #0	; 0x0
 3f0aa60:	eb000777 	bl	3f0c844 <printf>
		goto out;
 3f0aa64:	ea000043 	b	3f0ab78 <nand_erase+0x1c8>
	}

	/* FIXME: Do nand in the background. Use timers or schedule_task() */
	while(len) {
		/*mychip = &nand->chips[shr(ofs, nand->chipshift)];*/
		mychip = &nand->chips[ofs >> nand->chipshift];

		/* always check for bad block first, genuine bad blocks
		 * should _never_  be erased.
		 */
		if (ALLOW_ERASE_BAD_DEBUG || !check_block(nand, ofs)) {
			/* Select the NAND device */
			NAND_ENABLE_CE(nand);  /* set pin low */

                        dprintf("erase_1\n");
			NanD_Command(nand, NAND_CMD_ERASE1);
#ifdef CONFIG_MMSP20
                        dprintf("erase_2_address-mmsp20\n");
			NanD_OnlyAddress(nand, ADDR_PAGE, ofs);
#else
			NanD_Address(nand, ADDR_PAGE, ofs);
#endif
                        dprintf("erase_3\n");
			NanD_Command(nand, NAND_CMD_ERASE2);

#ifdef CONFIG_MMSP20
                        NanD_WaitReady(nand, 0);
#endif
                        dprintf("erase_4\n");
			NanD_Command(nand, NAND_CMD_STATUS);

#ifdef NAND_NO_RB
			{ u_char ret_val;
			  do{
				ret_val = READ_NAND(nandptr); /* wait till ready */
			  } while((ret_val & 0x40) != 0x40);
			}
#endif
			if (READ_NAND(nandptr) & 1) {
				printf ("%s: Error erasing at 0x%lx\n",
 3f0aa68:	e59f00cc 	ldr	r0, [pc, #cc]	; 3f0ab3c <nand_erase+0x18c>
 3f0aa6c:	e1a02006 	mov	r2, r6
 3f0aa70:	e59f10c0 	ldr	r1, [pc, #c0]	; 3f0ab38 <nand_erase+0x188>
					__FUNCTION__, (long)ofs);
				/* There was an error */
				ret = -1;
 3f0aa74:	e3e09000 	mvn	r9, #0	; 0x0
 3f0aa78:	eb000771 	bl	3f0c844 <printf>
				goto out;
 3f0aa7c:	ea00003d 	b	3f0ab78 <nand_erase+0x1c8>
 3f0aa80:	e3570000 	cmp	r7, #0	; 0x0
 3f0aa84:	0a00003b 	beq	3f0ab78 <nand_erase+0x1c8>
 3f0aa88:	e1a00005 	mov	r0, r5
 3f0aa8c:	e1a01006 	mov	r1, r6
 3f0aa90:	ebfff9fc 	bl	3f09288 <check_block>
 3f0aa94:	e250a000 	subs	r10, r0, #0	; 0x0
 3f0aa98:	1a000032 	bne	3f0ab68 <nand_erase+0x1b8>
 3f0aa9c:	e59f2084 	ldr	r2, [pc, #84]	; 3f0ab28 <nand_erase+0x178>
 3f0aaa0:	e1d230b0 	ldrh	r3, [r2]
 3f0aaa4:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0aaa8:	e1c230b0 	strh	r3, [r2]
 3f0aaac:	e1d230b0 	ldrh	r3, [r2]
 3f0aab0:	e3833080 	orr	r3, r3, #128	; 0x80
 3f0aab4:	e1c230b0 	strh	r3, [r2]
 3f0aab8:	e3a03060 	mov	r3, #96	; 0x60
 3f0aabc:	e59f4068 	ldr	r4, [pc, #68]	; 3f0ab2c <nand_erase+0x17c>
 3f0aac0:	e5c43000 	strb	r3, [r4]
 3f0aac4:	e1a00005 	mov	r0, r5
 3f0aac8:	e3a01002 	mov	r1, #2	; 0x2
 3f0aacc:	e1a02006 	mov	r2, r6
 3f0aad0:	ebfffb1d 	bl	3f0974c <NanD_OnlyAddress>
 3f0aad4:	e3a030d0 	mov	r3, #208	; 0xd0
 3f0aad8:	e5c43000 	strb	r3, [r4]
 3f0aadc:	e1a00005 	mov	r0, r5
 3f0aae0:	e1a0100a 	mov	r1, r10
 3f0aae4:	ebfffaec 	bl	3f0969c <NanD_WaitReady>
 3f0aae8:	e3a03070 	mov	r3, #112	; 0x70
 3f0aaec:	e5c43000 	strb	r3, [r4]
 3f0aaf0:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f0aaf4:	e5d33000 	ldrb	r3, [r3]
 3f0aaf8:	e3130001 	tst	r3, #1	; 0x1
 3f0aafc:	1affffd9 	bne	3f0aa68 <nand_erase+0xb8>
			}
			if (clean) {
 3f0ab00:	e51b302c 	ldr	r3, [r11, -#44]
 3f0ab04:	e3530000 	cmp	r3, #0	; 0x0
 3f0ab08:	0a000016 	beq	3f0ab68 <nand_erase+0x1b8>
				int n;	/* return value not used */
				int p, l;

				/* clean marker position and size depend
				 * on the page size, since 256 byte pages
				 * only have 8 bytes of oob data
				 */
				if (nand->page256) {
 3f0ab0c:	e5d5303c 	ldrb	r3, [r5, #60]
 3f0ab10:	e3530000 	cmp	r3, #0	; 0x0
 3f0ab14:	0a000009 	beq	3f0ab40 <nand_erase+0x190>
					p = NAND_JFFS2_OOB8_FSDAPOS;
 3f0ab18:	e3a03006 	mov	r3, #6	; 0x6
					l = NAND_JFFS2_OOB8_FSDALEN;
 3f0ab1c:	e3a02002 	mov	r2, #2	; 0x2
				}
 3f0ab20:	ea000008 	b	3f0ab48 <nand_erase+0x198>
 3f0ab24:	03f1e448 	mvneqs	r14, #1207959552	; 0x48000000
 3f0ab28:	c0003a3a 	andgt	r3, r0, r10, lsr r10
 3f0ab2c:	9c000010 	stcls	0, cr0, [r0], -#64
 3f0ab30:	03f1e480 	mvneqs	r14, #-2147483648	; 0x80000000
 3f0ab34:	03f1dc68 	mvneqs	r13, #26624	; 0x6800
 3f0ab38:	03f1e4b0 	mvneqs	r14, #-1342177280	; 0xb0000000
 3f0ab3c:	03f1e4bc 	mvneqs	r14, #-1140850688	; 0xbc000000
				else {
					p = NAND_JFFS2_OOB16_FSDAPOS;
 3f0ab40:	e3a02008 	mov	r2, #8	; 0x8
					l = NAND_JFFS2_OOB16_FSDALEN;
 3f0ab44:	e1a03002 	mov	r3, r2
				}

				ret = nand_write_oob(nand, ofs + p, l, &n,
 3f0ab48:	e0861003 	add	r1, r6, r3
 3f0ab4c:	e59f3050 	ldr	r3, [pc, #50]	; 3f0aba4 <nand_erase+0x1f4>
 3f0ab50:	e1a00005 	mov	r0, r5
 3f0ab54:	e58d3000 	str	r3, [r13]
 3f0ab58:	e24b3028 	sub	r3, r11, #40	; 0x28
 3f0ab5c:	ebfffe90 	bl	3f0a5a4 <nand_write_oob>
						     (u_char *)&clean_marker);
				/* quit here if write failed */
				if (ret)
 3f0ab60:	e2509000 	subs	r9, r0, #0	; 0x0
 3f0ab64:	1a000003 	bne	3f0ab78 <nand_erase+0x1c8>
					goto out;
			}
		}
		ofs += nand->erasesize;
 3f0ab68:	e5953028 	ldr	r3, [r5, #40]
 3f0ab6c:	e0866003 	add	r6, r6, r3
		len -= nand->erasesize;
	}
 3f0ab70:	e0577003 	subs	r7, r7, r3
 3f0ab74:	1affffc3 	bne	3f0aa88 <nand_erase+0xd8>

out:
	/* De-select the NAND device */
	NAND_DISABLE_CE(nand);  /* set pin high */
 3f0ab78:	e59f3028 	ldr	r3, [pc, #28]	; 3f0aba8 <nand_erase+0x1f8>
 3f0ab7c:	e1d320b0 	ldrh	r2, [r3]
 3f0ab80:	e3c22080 	bic	r2, r2, #128	; 0x80
 3f0ab84:	e1a02802 	mov	r2, r2, lsl #16
 3f0ab88:	e1a02822 	mov	r2, r2, lsr #16
 3f0ab8c:	e1c320b0 	strh	r2, [r3]
 3f0ab90:	e1d320b0 	ldrh	r2, [r3]
 3f0ab94:	e3822902 	orr	r2, r2, #32768	; 0x8000
 3f0ab98:	e1c320b0 	strh	r2, [r3]
#ifdef CONFIG_OMAP1510
    	archflashwp(0,1);
#endif
	return ret;
 3f0ab9c:	e1a00009 	mov	r0, r9
 3f0aba0:	ea000001 	b	3f0abac <nand_erase+0x1fc>
 3f0aba4:	03f2084c 	mvneqs	r0, #4980736	; 0x4c0000
 3f0aba8:	c0003a3a 	andgt	r3, r0, r10, lsr r10
}
 3f0abac:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0abb0 <nand_probe>:
 3f0abb0:	e1a0c00d 	mov	r12, r13
 3f0abb4:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f0abb8:	e24cb004 	sub	r11, r12, #4	; 0x4

static inline int nandcheck(unsigned long potential, unsigned long physadr)
{
	return 0;
}

unsigned long nand_probe(unsigned long physadr)
{
	struct nand_chip *nand = NULL;
 3f0abbc:	e3a05000 	mov	r5, #0	; 0x0
	int i = 0, ChipID = 1;

#ifdef CONFIG_MTD_NAND_ECC_JFFS2
	oob_config.ecc_pos[0] = NAND_JFFS2_OOB_ECCPOS0;
 3f0abc0:	e59f2120 	ldr	r2, [pc, #120]	; 3f0ace8 <nand_probe+0x138>
 3f0abc4:	e3a07001 	mov	r7, #1	; 0x1
	oob_config.ecc_pos[1] = NAND_JFFS2_OOB_ECCPOS1;
	oob_config.ecc_pos[2] = NAND_JFFS2_OOB_ECCPOS2;
	oob_config.ecc_pos[3] = NAND_JFFS2_OOB_ECCPOS3;
	oob_config.ecc_pos[4] = NAND_JFFS2_OOB_ECCPOS4;
	oob_config.ecc_pos[5] = NAND_JFFS2_OOB_ECCPOS5;
	oob_config.eccvalid_pos = 4;
#else
	oob_config.ecc_pos[0] = NAND_NOOB_ECCPOS0;
	oob_config.ecc_pos[1] = NAND_NOOB_ECCPOS1;
	oob_config.ecc_pos[2] = NAND_NOOB_ECCPOS2;
	oob_config.ecc_pos[3] = NAND_NOOB_ECCPOS3;
	oob_config.ecc_pos[4] = NAND_NOOB_ECCPOS4;
	oob_config.ecc_pos[5] = NAND_NOOB_ECCPOS5;
	oob_config.eccvalid_pos = NAND_NOOB_ECCVPOS;
#endif
	oob_config.badblock_pos = 5;

	for (i=0; i<CFG_MAX_NAND_DEVICE; i++) {
		if (nand_dev_desc[i].ChipID == NAND_ChipID_UNKNOWN) {
 3f0abc8:	e59fe11c 	ldr	r14, [pc, #11c]	; 3f0acec <nand_probe+0x13c>
 3f0abcc:	e3a03002 	mov	r3, #2	; 0x2
 3f0abd0:	e5825000 	str	r5, [r2]
 3f0abd4:	e1a06005 	mov	r6, r5
 3f0abd8:	e5827004 	str	r7, [r2, #4]
 3f0abdc:	e1a0c005 	mov	r12, r5
 3f0abe0:	e5823008 	str	r3, [r2, #8]
 3f0abe4:	e0833007 	add	r3, r3, r7
 3f0abe8:	e582300c 	str	r3, [r2, #12]
 3f0abec:	e2833003 	add	r3, r3, #3	; 0x3
 3f0abf0:	e5823010 	str	r3, [r2, #16]
 3f0abf4:	e0833007 	add	r3, r3, r7
 3f0abf8:	e5823014 	str	r3, [r2, #20]
 3f0abfc:	e2433003 	sub	r3, r3, #3	; 0x3
 3f0ac00:	e582301c 	str	r3, [r2, #28]
 3f0ac04:	e1a04000 	mov	r4, r0
 3f0ac08:	e5de1018 	ldrb	r1, [r14, #24]
 3f0ac0c:	e0833007 	add	r3, r3, r7
 3f0ac10:	e5823018 	str	r3, [r2, #24]
 3f0ac14:	e1510005 	cmp	r1, r5
			nand = &nand_dev_desc[i];
 3f0ac18:	01a0500e 	moveq	r5, r14
			break;
 3f0ac1c:	0a000009 	beq	3f0ac48 <nand_probe+0x98>
 3f0ac20:	e28cc054 	add	r12, r12, #84	; 0x54
 3f0ac24:	e2866001 	add	r6, r6, #1	; 0x1
 3f0ac28:	e3560000 	cmp	r6, #0	; 0x0
 3f0ac2c:	ca000005 	bgt	3f0ac48 <nand_probe+0x98>
 3f0ac30:	e59f30b4 	ldr	r3, [pc, #b4]	; 3f0acec <nand_probe+0x13c>
 3f0ac34:	e08c2003 	add	r2, r12, r3
 3f0ac38:	e5d23018 	ldrb	r3, [r2, #24]
 3f0ac3c:	e3530000 	cmp	r3, #0	; 0x0
 3f0ac40:	1afffff6 	bne	3f0ac20 <nand_probe+0x70>
 3f0ac44:	e1a05002 	mov	r5, r2
		}
	}
	if (!nand)
 3f0ac48:	e3550000 	cmp	r5, #0	; 0x0
		return (0);
 3f0ac4c:	e3a00000 	mov	r0, #0	; 0x0
 3f0ac50:	091ba8f0 	ldmeqdb	r11, {r4, r5, r6, r7, r11, r13, r15}

	memset((char *)nand, 0, sizeof(struct nand_chip));
 3f0ac54:	e1a00005 	mov	r0, r5
 3f0ac58:	e3a01000 	mov	r1, #0	; 0x0
 3f0ac5c:	e3a02054 	mov	r2, #84	; 0x54
 3f0ac60:	eb00122e 	bl	3f0f520 <memset>

	//dprintf("nand_probe 1\n");
	nand->IO_ADDR = physadr;
	nand->cache_page = -1;  /* init the cache page */
	NanD_ScanChips(nand);
 3f0ac64:	e1a00005 	mov	r0, r5
 3f0ac68:	e5854040 	str	r4, [r5, #64]
 3f0ac6c:	e3e03000 	mvn	r3, #0	; 0x0
 3f0ac70:	e585300c 	str	r3, [r5, #12]
 3f0ac74:	ebfffb5f 	bl	3f099f8 <NanD_ScanChips>
	//dprintf("nand_probe 2\n");

	if (nand->totlen == 0) {
 3f0ac78:	e5954044 	ldr	r4, [r5, #68]
 3f0ac7c:	e3540000 	cmp	r4, #0	; 0x0
 3f0ac80:	1a000006 	bne	3f0aca0 <nand_probe+0xf0>
		/* no chips found, clean up and quit */
		memset((char *)nand, 0, sizeof(struct nand_chip));
 3f0ac84:	e1a00005 	mov	r0, r5
 3f0ac88:	e1a01004 	mov	r1, r4
 3f0ac8c:	e3a02054 	mov	r2, #84	; 0x54
 3f0ac90:	eb001222 	bl	3f0f520 <memset>
		nand->ChipID = NAND_ChipID_UNKNOWN;
		return (0);
 3f0ac94:	e1a00004 	mov	r0, r4
 3f0ac98:	e5c54018 	strb	r4, [r5, #24]
 3f0ac9c:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	}

	nand->ChipID = ChipID;
 3f0aca0:	e5c57018 	strb	r7, [r5, #24]
	if (curr_device == -1)
 3f0aca4:	e59f2044 	ldr	r2, [pc, #44]	; 3f0acf0 <nand_probe+0x140>
 3f0aca8:	e5923000 	ldr	r3, [r2]
 3f0acac:	e3730001 	cmn	r3, #1	; 0x1
		curr_device = i;
 3f0acb0:	05826000 	streq	r6, [r2]

	nand->data_buf = malloc (nand->oobblock + nand->oobsize);
 3f0acb4:	e2853048 	add	r3, r5, #72	; 0x48
 3f0acb8:	e8930009 	ldmia	r3, {r0, r3}
 3f0acbc:	e0800003 	add	r0, r0, r3
 3f0acc0:	eb000892 	bl	3f0cf10 <malloc>
 3f0acc4:	e1a04000 	mov	r4, r0
	if (!nand->data_buf) {
 3f0acc8:	e3540000 	cmp	r4, #0	; 0x0
 3f0accc:	e5854004 	str	r4, [r5, #4]
		puts ("Cannot allocate memory for data structures.\n");
		return (0);
	}

	return (nand->totlen);
 3f0acd0:	15950044 	ldrne	r0, [r5, #68]
 3f0acd4:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0acd8:	e59f0014 	ldr	r0, [pc, #14]	; 3f0acf4 <nand_probe+0x144>
 3f0acdc:	eb0006cb 	bl	3f0c810 <puts>
 3f0ace0:	e1a00004 	mov	r0, r4
}
 3f0ace4:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0ace8:	03f207d4 	mvneqs	r0, #55574528	; 0x3500000
 3f0acec:	03f207f4 	mvneqs	r0, #63963136	; 0x3d00000
 3f0acf0:	03f20848 	mvneqs	r0, #4718592	; 0x480000
 3f0acf4:	03f1e4d8 	mvneqs	r14, #-671088640	; 0xd8000000

03f0acf8 <nand_trans_result>:
 3f0acf8:	e1a0c00d 	mov	r12, r13
 3f0acfc:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f0ad00:	e24cb004 	sub	r11, r12, #4	; 0x4

#ifdef CONFIG_MTD_NAND_ECC
/*
 * Pre-calculated 256-way 1 byte column parity
 */
static const u_char nand_ecc_precalc_table[] = {
	0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00,
	0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f, 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
	0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c, 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
	0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59, 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
	0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
	0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
	0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
	0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
	0x6a, 0x3f, 0x3c, 0x69, 0x33, 0x66, 0x65, 0x30, 0x30, 0x65, 0x66, 0x33, 0x69, 0x3c, 0x3f, 0x6a,
	0x0f, 0x5a, 0x59, 0x0c, 0x56, 0x03, 0x00, 0x55, 0x55, 0x00, 0x03, 0x56, 0x0c, 0x59, 0x5a, 0x0f,
	0x0c, 0x59, 0x5a, 0x0f, 0x55, 0x00, 0x03, 0x56, 0x56, 0x03, 0x00, 0x55, 0x0f, 0x5a, 0x59, 0x0c,
	0x69, 0x3c, 0x3f, 0x6a, 0x30, 0x65, 0x66, 0x33, 0x33, 0x66, 0x65, 0x30, 0x6a, 0x3f, 0x3c, 0x69,
	0x03, 0x56, 0x55, 0x00, 0x5a, 0x0f, 0x0c, 0x59, 0x59, 0x0c, 0x0f, 0x5a, 0x00, 0x55, 0x56, 0x03,
	0x66, 0x33, 0x30, 0x65, 0x3f, 0x6a, 0x69, 0x3c, 0x3c, 0x69, 0x6a, 0x3f, 0x65, 0x30, 0x33, 0x66,
	0x65, 0x30, 0x33, 0x66, 0x3c, 0x69, 0x6a, 0x3f, 0x3f, 0x6a, 0x69, 0x3c, 0x66, 0x33, 0x30, 0x65,
	0x00, 0x55, 0x56, 0x03, 0x59, 0x0c, 0x0f, 0x5a, 0x5a, 0x0f, 0x0c, 0x59, 0x03, 0x56, 0x55, 0x00
};


/*
 * Creates non-inverted ECC code from line parity
 */
static void nand_trans_result(u_char reg2, u_char reg3,
	u_char *ecc_code)
{
 3f0ad04:	e1a06002 	mov	r6, r2
 3f0ad08:	e20050ff 	and	r5, r0, #255	; 0xff
 3f0ad0c:	e20140ff 	and	r4, r1, #255	; 0xff
	u_char a, b, i, tmp1, tmp2;

	/* Initialize variables */
	a = b = 0x80;
 3f0ad10:	e3a0e080 	mov	r14, #128	; 0x80
 3f0ad14:	e1a0c00e 	mov	r12, r14
	tmp1 = tmp2 = 0;
 3f0ad18:	e3a02000 	mov	r2, #0	; 0x0
 3f0ad1c:	e1a00002 	mov	r0, r2

	/* Calculate first ECC byte */
	for (i = 0; i < 4; i++) {
 3f0ad20:	e1a01002 	mov	r1, r2
		if (reg3 & a)		/* LP15,13,11,9 --> ecc_code[0] */
 3f0ad24:	e114000e 	tst	r4, r14
			tmp1 |= b;
 3f0ad28:	e180300c 	orr	r3, r0, r12
 3f0ad2c:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0ad30:	11a00003 	movne	r0, r3
		b >>= 1;
 3f0ad34:	e1a0c0ac 	mov	r12, r12, lsr #1
		if (reg2 & a)		/* LP14,12,10,8 --> ecc_code[0] */
 3f0ad38:	e115000e 	tst	r5, r14
			tmp1 |= b;
 3f0ad3c:	e180300c 	orr	r3, r0, r12
 3f0ad40:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0ad44:	11a00003 	movne	r0, r3
		b >>= 1;
 3f0ad48:	e1a030ac 	mov	r3, r12, lsr #1
 3f0ad4c:	e203c0ff 	and	r12, r3, #255	; 0xff
		a >>= 1;
 3f0ad50:	e1a0e0ae 	mov	r14, r14, lsr #1
 3f0ad54:	e2813001 	add	r3, r1, #1	; 0x1
 3f0ad58:	e20310ff 	and	r1, r3, #255	; 0xff
 3f0ad5c:	e3510003 	cmp	r1, #3	; 0x3
 3f0ad60:	9affffef 	bls	3f0ad24 <nand_trans_result+0x2c>
	}

	/* Calculate second ECC byte */
	b = 0x80;
 3f0ad64:	e3a0c080 	mov	r12, #128	; 0x80
	for (i = 0; i < 4; i++) {
 3f0ad68:	e3a01000 	mov	r1, #0	; 0x0
		if (reg3 & a)		/* LP7,5,3,1 --> ecc_code[1] */
 3f0ad6c:	e114000e 	tst	r4, r14
			tmp2 |= b;
 3f0ad70:	e182300c 	orr	r3, r2, r12
 3f0ad74:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0ad78:	11a02003 	movne	r2, r3
		b >>= 1;
 3f0ad7c:	e1a0c0ac 	mov	r12, r12, lsr #1
		if (reg2 & a)		/* LP6,4,2,0 --> ecc_code[1] */
 3f0ad80:	e115000e 	tst	r5, r14
			tmp2 |= b;
 3f0ad84:	e182300c 	orr	r3, r2, r12
 3f0ad88:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0ad8c:	11a02003 	movne	r2, r3
		b >>= 1;
 3f0ad90:	e1a030ac 	mov	r3, r12, lsr #1
 3f0ad94:	e203c0ff 	and	r12, r3, #255	; 0xff
		a >>= 1;
 3f0ad98:	e1a0e0ae 	mov	r14, r14, lsr #1
 3f0ad9c:	e2813001 	add	r3, r1, #1	; 0x1
 3f0ada0:	e20310ff 	and	r1, r3, #255	; 0xff
 3f0ada4:	e3510003 	cmp	r1, #3	; 0x3
 3f0ada8:	9affffef 	bls	3f0ad6c <nand_trans_result+0x74>
	}

	/* Store two of the ECC bytes */
	ecc_code[0] = tmp1;
 3f0adac:	e5c60000 	strb	r0, [r6]
	ecc_code[1] = tmp2;
 3f0adb0:	e5c62001 	strb	r2, [r6, #1]
}
 3f0adb4:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f0adb8 <nand_calculate_ecc>:
 3f0adb8:	e1a0c00d 	mov	r12, r13
 3f0adbc:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0adc0:	e24cb004 	sub	r11, r12, #4	; 0x4

/*
 * Calculate 3 byte ECC code for 256 byte block
 */
static void nand_calculate_ecc (const u_char *dat, u_char *ecc_code)
{
	u_char idx, reg1, reg3;
	int j;

	/* Initialize variables */
	reg1 = reg3 = 0;
 3f0adc4:	e3a05000 	mov	r5, #0	; 0x0
 3f0adc8:	e1a04001 	mov	r4, r1
	ecc_code[0] = ecc_code[1] = ecc_code[2] = 0;
 3f0adcc:	e5c45002 	strb	r5, [r4, #2]
 3f0add0:	e1a0e005 	mov	r14, r5
 3f0add4:	e5c45001 	strb	r5, [r4, #1]

	/* Build up column parity */
	for(j = 0; j < 256; j++) {
 3f0add8:	e1a0c005 	mov	r12, r5
 3f0addc:	e5c45000 	strb	r5, [r4]

		/* Get CP0 - CP5 from table */
		idx = nand_ecc_precalc_table[dat[j]];
 3f0ade0:	e59f1070 	ldr	r1, [pc, #70]	; 3f0ae58 <nand_calculate_ecc+0xa0>
		reg1 ^= idx;

		/* All bit XOR = 1 ? */
		if (idx & 0x40) {
			reg3 ^= (u_char) j;
 3f0ade4:	e02e300c 	eor	r3, r14, r12
 3f0ade8:	e7d0200c 	ldrb	r2, [r0, r12]
 3f0adec:	e28cc001 	add	r12, r12, #1	; 0x1
 3f0adf0:	e7d12002 	ldrb	r2, [r1, r2]
 3f0adf4:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0adf8:	e0251002 	eor	r1, r5, r2
 3f0adfc:	e20150ff 	and	r5, r1, #255	; 0xff
 3f0ae00:	e3120040 	tst	r2, #64	; 0x40
 3f0ae04:	11a0e003 	movne	r14, r3
 3f0ae08:	e35c00ff 	cmp	r12, #255	; 0xff
 3f0ae0c:	dafffff3 	ble	3f0ade0 <nand_calculate_ecc+0x28>
		}
	}

	/* Create non-inverted ECC code from line parity */
	nand_trans_result((reg1 & 0x40) ? ~reg3 : reg3, reg3, ecc_code);
 3f0ae10:	e3110040 	tst	r1, #64	; 0x40
 3f0ae14:	11e0300e 	mvnne	r3, r14
 3f0ae18:	120300ff 	andne	r0, r3, #255	; 0xff
 3f0ae1c:	01a0000e 	moveq	r0, r14
 3f0ae20:	e1a0100e 	mov	r1, r14
 3f0ae24:	e1a02004 	mov	r2, r4
 3f0ae28:	ebffffb2 	bl	3f0acf8 <nand_trans_result>

	/* Calculate final ECC code */
	ecc_code[0] = ~ecc_code[0];
	ecc_code[1] = ~ecc_code[1];
	ecc_code[2] = ((~reg1) << 2) | 0x03;
 3f0ae2c:	e1e03005 	mvn	r3, r5
 3f0ae30:	e1a03103 	mov	r3, r3, lsl #2
 3f0ae34:	e3833003 	orr	r3, r3, #3	; 0x3
 3f0ae38:	e5c43002 	strb	r3, [r4, #2]
 3f0ae3c:	e5d43000 	ldrb	r3, [r4]
 3f0ae40:	e5d42001 	ldrb	r2, [r4, #1]
 3f0ae44:	e1e03003 	mvn	r3, r3
 3f0ae48:	e5c43000 	strb	r3, [r4]
 3f0ae4c:	e1e02002 	mvn	r2, r2
 3f0ae50:	e5c42001 	strb	r2, [r4, #1]
}
 3f0ae54:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f0ae58:	03f1e505 	mvneqs	r14, #20971520	; 0x1400000

03f0ae5c <nand_correct_data>:
 3f0ae5c:	e1a0c00d 	mov	r12, r13
 3f0ae60:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}

/*
 * Detect and correct a 1 bit error for 256 byte block
 */
static int nand_correct_data (u_char *dat, u_char *read_ecc, u_char *calc_ecc)
{
 3f0ae64:	e1a07002 	mov	r7, r2
	u_char a, b, c, d1, d2, d3, add, bit, i;

	/* Do error detection */
	d1 = calc_ecc[0] ^ read_ecc[0];
 3f0ae68:	e5d7a000 	ldrb	r10, [r7]
 3f0ae6c:	e24cb004 	sub	r11, r12, #4	; 0x4
	d2 = calc_ecc[1] ^ read_ecc[1];
 3f0ae70:	e5d7c001 	ldrb	r12, [r7, #1]
 3f0ae74:	e1a06001 	mov	r6, r1
 3f0ae78:	e5d63000 	ldrb	r3, [r6]
 3f0ae7c:	e5d62001 	ldrb	r2, [r6, #1]
 3f0ae80:	e1a09000 	mov	r9, r0
	d3 = calc_ecc[2] ^ read_ecc[2];
 3f0ae84:	e5d71002 	ldrb	r1, [r7, #2]
 3f0ae88:	e023400a 	eor	r4, r3, r10
 3f0ae8c:	e5d63002 	ldrb	r3, [r6, #2]
 3f0ae90:	e022200c 	eor	r2, r2, r12
 3f0ae94:	e0235001 	eor	r5, r3, r1

	if ((d1 | d2 | d3) == 0) {
 3f0ae98:	e1843002 	orr	r3, r4, r2
 3f0ae9c:	e1950003 	orrs	r0, r5, r3
 3f0aea0:	091baef0 	ldmeqdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
		/* No errors */
		return 0;
	}
	else {
		a = (d1 ^ (d1 >> 1)) & 0x55;
 3f0aea4:	e02430a4 	eor	r3, r4, r4, lsr #1
 3f0aea8:	e203c055 	and	r12, r3, #85	; 0x55
		b = (d2 ^ (d2 >> 1)) & 0x55;
 3f0aeac:	e02230a2 	eor	r3, r2, r2, lsr #1
 3f0aeb0:	e2031055 	and	r1, r3, #85	; 0x55
		c = (d3 ^ (d3 >> 1)) & 0x54;
 3f0aeb4:	e02530a5 	eor	r3, r5, r5, lsr #1
 3f0aeb8:	e2030054 	and	r0, r3, #84	; 0x54

		/* Found and will correct single bit error in the data */
		if ((a == 0x55) && (b == 0x55) && (c == 0x54)) {
 3f0aebc:	e35c0055 	cmp	r12, #85	; 0x55
 3f0aec0:	03510055 	cmpeq	r1, #85	; 0x55
 3f0aec4:	1a00002f 	bne	3f0af88 <nand_correct_data+0x12c>
 3f0aec8:	e3500054 	cmp	r0, #84	; 0x54
 3f0aecc:	1a00002d 	bne	3f0af88 <nand_correct_data+0x12c>
			c = 0x80;
 3f0aed0:	e3a00080 	mov	r0, #128	; 0x80
			add = 0;
 3f0aed4:	e3a06000 	mov	r6, #0	; 0x0
			a = 0x80;
 3f0aed8:	e1a0c000 	mov	r12, r0
			for (i=0; i<4; i++) {
 3f0aedc:	e1a0e006 	mov	r14, r6
				if (d1 & c)
 3f0aee0:	e1140000 	tst	r4, r0
					add |= a;
 3f0aee4:	e186300c 	orr	r3, r6, r12
 3f0aee8:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0aeec:	11a06003 	movne	r6, r3
				c >>= 2;
 3f0aef0:	e1a00120 	mov	r0, r0, lsr #2
				a >>= 1;
 3f0aef4:	e1a0c0ac 	mov	r12, r12, lsr #1
 3f0aef8:	e28e3001 	add	r3, r14, #1	; 0x1
 3f0aefc:	e203e0ff 	and	r14, r3, #255	; 0xff
 3f0af00:	e35e0003 	cmp	r14, #3	; 0x3
 3f0af04:	9afffff5 	bls	3f0aee0 <nand_correct_data+0x84>
			}
			c = 0x80;
 3f0af08:	e3a00080 	mov	r0, #128	; 0x80
			for (i=0; i<4; i++) {
 3f0af0c:	e3a0e000 	mov	r14, #0	; 0x0
				if (d2 & c)
 3f0af10:	e1120000 	tst	r2, r0
					add |= a;
 3f0af14:	e186300c 	orr	r3, r6, r12
 3f0af18:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0af1c:	11a06003 	movne	r6, r3
				c >>= 2;
 3f0af20:	e1a00120 	mov	r0, r0, lsr #2
				a >>= 1;
 3f0af24:	e1a0c0ac 	mov	r12, r12, lsr #1
 3f0af28:	e28e3001 	add	r3, r14, #1	; 0x1
 3f0af2c:	e203e0ff 	and	r14, r3, #255	; 0xff
 3f0af30:	e35e0003 	cmp	r14, #3	; 0x3
 3f0af34:	9afffff5 	bls	3f0af10 <nand_correct_data+0xb4>
			}
			bit = 0;
 3f0af38:	e3a02000 	mov	r2, #0	; 0x0
			b = 0x04;
 3f0af3c:	e3a01004 	mov	r1, #4	; 0x4
			c = 0x80;
 3f0af40:	e3a00080 	mov	r0, #128	; 0x80
			for (i=0; i<3; i++) {
 3f0af44:	e1a0e002 	mov	r14, r2
				if (d3 & c)
 3f0af48:	e1150000 	tst	r5, r0
					bit |= b;
 3f0af4c:	e1823001 	orr	r3, r2, r1
 3f0af50:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0af54:	11a02003 	movne	r2, r3
				c >>= 2;
 3f0af58:	e1a00120 	mov	r0, r0, lsr #2
				b >>= 1;
 3f0af5c:	e1a010a1 	mov	r1, r1, lsr #1
 3f0af60:	e28e3001 	add	r3, r14, #1	; 0x1
 3f0af64:	e203e0ff 	and	r14, r3, #255	; 0xff
 3f0af68:	e35e0002 	cmp	r14, #2	; 0x2
 3f0af6c:	9afffff5 	bls	3f0af48 <nand_correct_data+0xec>
			}
			b = 0x01;
 3f0af70:	e3a01001 	mov	r1, #1	; 0x1
			a = dat[add];
 3f0af74:	e7d9c006 	ldrb	r12, [r9, r6]
			a ^= (b << bit);
			dat[add] = a;
			return 1;
 3f0af78:	e1a00001 	mov	r0, r1
 3f0af7c:	e02c3211 	eor	r3, r12, r1, lsl r2
 3f0af80:	e7c93006 	strb	r3, [r9, r6]
 3f0af84:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
		}
		else {
			i = 0;
 3f0af88:	e3a0e000 	mov	r14, #0	; 0x0
			while (d1) {
 3f0af8c:	e154000e 	cmp	r4, r14
 3f0af90:	0a000005 	beq	3f0afac <nand_correct_data+0x150>
				if (d1 & 0x01)
 3f0af94:	e3140001 	tst	r4, #1	; 0x1
					++i;
 3f0af98:	e28e3001 	add	r3, r14, #1	; 0x1
 3f0af9c:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0afa0:	11a0e003 	movne	r14, r3
				d1 >>= 1;
			}
 3f0afa4:	e1b040a4 	movs	r4, r4, lsr #1
 3f0afa8:	1afffff9 	bne	3f0af94 <nand_correct_data+0x138>
			while (d2) {
 3f0afac:	e3520000 	cmp	r2, #0	; 0x0
 3f0afb0:	0a000005 	beq	3f0afcc <nand_correct_data+0x170>
				if (d2 & 0x01)
 3f0afb4:	e3120001 	tst	r2, #1	; 0x1
					++i;
 3f0afb8:	e28e3001 	add	r3, r14, #1	; 0x1
 3f0afbc:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0afc0:	11a0e003 	movne	r14, r3
				d2 >>= 1;
			}
 3f0afc4:	e1b020a2 	movs	r2, r2, lsr #1
 3f0afc8:	1afffff9 	bne	3f0afb4 <nand_correct_data+0x158>
			while (d3) {
 3f0afcc:	e3550000 	cmp	r5, #0	; 0x0
 3f0afd0:	0a000005 	beq	3f0afec <nand_correct_data+0x190>
				if (d3 & 0x01)
 3f0afd4:	e3150001 	tst	r5, #1	; 0x1
					++i;
 3f0afd8:	e28e3001 	add	r3, r14, #1	; 0x1
 3f0afdc:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0afe0:	11a0e003 	movne	r14, r3
				d3 >>= 1;
			}
 3f0afe4:	e1b050a5 	movs	r5, r5, lsr #1
 3f0afe8:	1afffff9 	bne	3f0afd4 <nand_correct_data+0x178>
			if (i == 1) {
 3f0afec:	e35e0001 	cmp	r14, #1	; 0x1
				/* ECC Code Error Correction */
				read_ecc[0] = calc_ecc[0];
				read_ecc[1] = calc_ecc[1];
				read_ecc[2] = calc_ecc[2];
				return 2;
			}
			else {
				/* Uncorrectable Error */
				return -1;
 3f0aff0:	13e00000 	mvnne	r0, #0	; 0x0
 3f0aff4:	191baef0 	ldmnedb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f0aff8:	e5c6a000 	strb	r10, [r6]
 3f0affc:	e5d73001 	ldrb	r3, [r7, #1]
 3f0b000:	e5c63001 	strb	r3, [r6, #1]
 3f0b004:	e5d73002 	ldrb	r3, [r7, #2]
 3f0b008:	e3a00002 	mov	r0, #2	; 0x2
 3f0b00c:	e5c63002 	strb	r3, [r6, #2]
			}
		}
	}

	/* Should never happen */
	return -1;
}
 3f0b010:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0b014 <nand_read_without_ecc>:
 3f0b014:	e1a0c00d 	mov	r12, r13
 3f0b018:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0b01c:	e24cb004 	sub	r11, r12, #4	; 0x4

#endif

#ifdef CONFIG_JFFS2_NAND

int read_jffs2_nand(size_t start, size_t len,
		    size_t * retlen, u_char * buf, int nanddev)
{
	return nand_rw(nand_dev_desc + nanddev, NANDRW_READ | NANDRW_JFFS2,
		       start, len, retlen, buf);
}
#endif /* CONFIG_JFFS2_NAND */

#if defined(CFG_ENV_IS_IN_NAND) /* Environment is in NAND */

static int nand_read_without_ecc(struct nand_chip *nand, size_t start, size_t len,
		 size_t * retlen, u_char *buf)
{
 3f0b020:	e1a04000 	mov	r4, r0
 3f0b024:	e1a06002 	mov	r6, r2
	int col, page;
	int ecc_status = 0;

	/* Do not allow reads past end of device */
	if ((start + len) > nand->totlen) {
 3f0b028:	e0812006 	add	r2, r1, r6
 3f0b02c:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f0b030:	e5940044 	ldr	r0, [r4, #68]
 3f0b034:	e1a05003 	mov	r5, r3
 3f0b038:	e1520000 	cmp	r2, r0
 3f0b03c:	9a000009 	bls	3f0b068 <nand_read_without_ecc+0x54>
		printf ("%s: Attempt read beyond end of device %x %x %x\n", __FUNCTION__, (uint) start, (uint) len, (uint) nand->totlen);
 3f0b040:	e58d0000 	str	r0, [r13]
 3f0b044:	e59f00ac 	ldr	r0, [pc, #ac]	; 3f0b0f8 <nand_read_without_ecc+0xe4>
 3f0b048:	e1a02001 	mov	r2, r1
 3f0b04c:	e59f10a8 	ldr	r1, [pc, #a8]	; 3f0b0fc <nand_read_without_ecc+0xe8>
 3f0b050:	e1a03006 	mov	r3, r6
 3f0b054:	eb0005fa 	bl	3f0c844 <printf>
		*retlen = 0;
		return -1;
 3f0b058:	e3e00000 	mvn	r0, #0	; 0x0
 3f0b05c:	e3a03000 	mov	r3, #0	; 0x0
 3f0b060:	e5853000 	str	r3, [r5]
 3f0b064:	ea00003f 	b	3f0b168 <nand_read_without_ecc+0x154>
	}

	/* First we calculate the starting page */
	page = start >> nand->page_shift;
 3f0b068:	e5942000 	ldr	r2, [r4]

	/* Get raw starting column */
	col = start & (nand->oobblock - 1);
 3f0b06c:	e5943048 	ldr	r3, [r4, #72]

	/* Initialize return value */
	*retlen = 0;
 3f0b070:	e3a00000 	mov	r0, #0	; 0x0
 3f0b074:	e5850000 	str	r0, [r5]
 3f0b078:	e1a0a231 	mov	r10, r1, lsr r2
 3f0b07c:	e2433001 	sub	r3, r3, #1	; 0x1
 3f0b080:	e0017003 	and	r7, r1, r3

	/* Select the NAND device */
	NAND_ENABLE_CE(nand);  /* set pin low */
 3f0b084:	e59f2074 	ldr	r2, [pc, #74]	; 3f0b100 <nand_read_without_ecc+0xec>
 3f0b088:	e1d230b0 	ldrh	r3, [r2]
 3f0b08c:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0b090:	e1c230b0 	strh	r3, [r2]
 3f0b094:	e1d230b0 	ldrh	r3, [r2]
 3f0b098:	e3833080 	orr	r3, r3, #128	; 0x80
 3f0b09c:	e1c230b0 	strh	r3, [r2]

	/* Loop until all data read */
	while (*retlen < len) {
 3f0b0a0:	ea000023 	b	3f0b134 <nand_read_without_ecc+0x120>
 3f0b0a4:	e3a09000 	mov	r9, #0	; 0x0
 3f0b0a8:	e59f3054 	ldr	r3, [pc, #54]	; 3f0b104 <nand_read_without_ecc+0xf0>
 3f0b0ac:	e5c39000 	strb	r9, [r3]

		/* Send the read command */
		NanD_Command(nand, NAND_CMD_READ0);
		NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
 3f0b0b0:	e5942000 	ldr	r2, [r4]
 3f0b0b4:	e3a01003 	mov	r1, #3	; 0x3
 3f0b0b8:	e1a00004 	mov	r0, r4
 3f0b0bc:	e087221a 	add	r2, r7, r10, lsl r2
 3f0b0c0:	ebfff985 	bl	3f096dc <NanD_Address>
		/* Read the data directly into the return buffer */
		if ((*retlen + (nand->oobblock - col)) >= len) {
 3f0b0c4:	e5943048 	ldr	r3, [r4, #72]
 3f0b0c8:	e595c000 	ldr	r12, [r5]
 3f0b0cc:	e0672003 	rsb	r2, r7, r3
 3f0b0d0:	e08c3002 	add	r3, r12, r2
 3f0b0d4:	e1530006 	cmp	r3, r6
 3f0b0d8:	3a00000a 	bcc	3f0b108 <nand_read_without_ecc+0xf4>
			NanD_ReadBuf(nand, buf + *retlen, len - *retlen);
 3f0b0dc:	e1a00004 	mov	r0, r4
 3f0b0e0:	e59b3004 	ldr	r3, [r11, #4]
 3f0b0e4:	e06c2006 	rsb	r2, r12, r6
 3f0b0e8:	e083100c 	add	r1, r3, r12
 3f0b0ec:	ebfffaa2 	bl	3f09b7c <NanD_ReadBuf>
			*retlen = len;
 3f0b0f0:	e5856000 	str	r6, [r5]
			/* We're done */
			continue;
 3f0b0f4:	ea00000e 	b	3f0b134 <nand_read_without_ecc+0x120>
 3f0b0f8:	03f1e3a8 	mvneqs	r14, #-1610612734	; 0xa0000002
 3f0b0fc:	03f1e608 	mvneqs	r14, #8388608	; 0x800000
 3f0b100:	c0003a3a 	andgt	r3, r0, r10, lsr r10
 3f0b104:	9c000010 	stcls	0, cr0, [r0], -#64
		} else {
			NanD_ReadBuf(nand, buf + *retlen, nand->oobblock - col);
 3f0b108:	e59b3004 	ldr	r3, [r11, #4]
 3f0b10c:	e1a00004 	mov	r0, r4
 3f0b110:	e083100c 	add	r1, r3, r12
 3f0b114:	ebfffa98 	bl	3f09b7c <NanD_ReadBuf>
			*retlen += nand->oobblock - col;
 3f0b118:	e5942048 	ldr	r2, [r4, #72]
		}

		/* For subsequent reads align to page boundary. */
		col = 0;
		/* Increment page address */
		page++;
 3f0b11c:	e28aa001 	add	r10, r10, #1	; 0x1
 3f0b120:	e5953000 	ldr	r3, [r5]
 3f0b124:	e0672002 	rsb	r2, r7, r2
 3f0b128:	e1a07009 	mov	r7, r9
 3f0b12c:	e0833002 	add	r3, r3, r2
 3f0b130:	e5853000 	str	r3, [r5]
	}
 3f0b134:	e5953000 	ldr	r3, [r5]
 3f0b138:	e1530006 	cmp	r3, r6
 3f0b13c:	3affffd8 	bcc	3f0b0a4 <nand_read_without_ecc+0x90>

	/* De-select the NAND device */
	NAND_DISABLE_CE(nand);  /* set pin high */
 3f0b140:	e59f3024 	ldr	r3, [pc, #24]	; 3f0b16c <nand_read_without_ecc+0x158>
 3f0b144:	e1d320b0 	ldrh	r2, [r3]
 3f0b148:	e3c22080 	bic	r2, r2, #128	; 0x80
 3f0b14c:	e1a02802 	mov	r2, r2, lsl #16
 3f0b150:	e1a02822 	mov	r2, r2, lsr #16
 3f0b154:	e1c320b0 	strh	r2, [r3]
 3f0b158:	e1d320b0 	ldrh	r2, [r3]
 3f0b15c:	e3822902 	orr	r2, r2, #32768	; 0x8000
 3f0b160:	e1c320b0 	strh	r2, [r3]

	/*
	 * Return success, if no ECC failures, else -EIO
	 * fs driver will take care of that, because
	 * retlen == desired len and result == -EIO
	 */
	return ecc_status ? -1 : 0;
 3f0b164:	e3a00000 	mov	r0, #0	; 0x0
 3f0b168:	ea000000 	b	3f0b170 <nand_read_without_ecc+0x15c>
 3f0b16c:	c0003a3a 	andgt	r3, r0, r10, lsr r10
}
 3f0b170:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0b174 <nand_write_page_without_ecc>:
 3f0b174:	e1a0c00d 	mov	r12, r13
 3f0b178:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f0b17c:	e24cb004 	sub	r11, r12, #4	; 0x4

static int nand_write_page_without_ecc (struct nand_chip *nand,
			    int page, int col, int last)
{
 3f0b180:	e1a05000 	mov	r5, r0
 3f0b184:	e1a07001 	mov	r7, r1
 3f0b188:	e1a06003 	mov	r6, r3
 3f0b18c:	e3a04000 	mov	r4, #0	; 0x0
 3f0b190:	e59f108c 	ldr	r1, [pc, #8c]	; 3f0b224 <nand_write_page_without_ecc+0xb0>
 3f0b194:	e5c14000 	strb	r4, [r1]
 3f0b198:	e3a03080 	mov	r3, #128	; 0x80
 3f0b19c:	e5c13000 	strb	r3, [r1]

	int i;
	unsigned long nandptr = nand->IO_ADDR;

	/* Send command to begin auto page programming */
	NanD_Command(nand, NAND_CMD_READ0);
	NanD_Command(nand, NAND_CMD_SEQIN);
#ifdef CONFIG_MMSP20
	NanD_OnlyAddress(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
 3f0b1a0:	e5953000 	ldr	r3, [r5]
 3f0b1a4:	e3a01003 	mov	r1, #3	; 0x3
 3f0b1a8:	e0822317 	add	r2, r2, r7, lsl r3
 3f0b1ac:	ebfff966 	bl	3f0974c <NanD_OnlyAddress>
#else
	NanD_Address(nand, ADDR_COLUMN_PAGE, (page << nand->page_shift) + col);
#endif

	/* Write out complete page of data */
	for (i = 0; i < last; i++)
 3f0b1b0:	e1540006 	cmp	r4, r6
 3f0b1b4:	aa000006 	bge	3f0b1d4 <nand_write_page_without_ecc+0x60>
		WRITE_NAND(nand->data_buf[i], nand->IO_ADDR);
 3f0b1b8:	e5953004 	ldr	r3, [r5, #4]
 3f0b1bc:	e7d32004 	ldrb	r2, [r3, r4]
 3f0b1c0:	e2844001 	add	r4, r4, #1	; 0x1
 3f0b1c4:	e1540006 	cmp	r4, r6
 3f0b1c8:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f0b1cc:	e5c32000 	strb	r2, [r3]
 3f0b1d0:	bafffff8 	blt	3f0b1b8 <nand_write_page_without_ecc+0x44>
 3f0b1d4:	e3a03010 	mov	r3, #16	; 0x10
 3f0b1d8:	e59f4044 	ldr	r4, [pc, #44]	; 3f0b224 <nand_write_page_without_ecc+0xb0>
 3f0b1dc:	e5c43000 	strb	r3, [r4]

	/* Send command to actually program the data */
	NanD_Command(nand, NAND_CMD_PAGEPROG);
#ifdef CONFIG_MMSP20
       	NanD_WaitReady(nand, 0);
 3f0b1e0:	e1a00005 	mov	r0, r5
 3f0b1e4:	e3a01000 	mov	r1, #0	; 0x0
 3f0b1e8:	ebfff92b 	bl	3f0969c <NanD_WaitReady>
#endif

	udelay(300);
 3f0b1ec:	e3a00f4b 	mov	r0, #300	; 0x12c
 3f0b1f0:	ebffd588 	bl	3f00818 <udelay>
 3f0b1f4:	e3a03070 	mov	r3, #112	; 0x70
 3f0b1f8:	e5c43000 	strb	r3, [r4]

	NanD_Command(nand, NAND_CMD_STATUS);
#ifdef NAND_NO_RB
	{ u_char ret_val;

	  do{
		ret_val = READ_NAND(nandptr);	/* wait till ready */
	  } while((ret_val & 0x40) != 0x40);
	}
#endif
	/* See if device thinks it succeeded */
	if (READ_NAND(nand->IO_ADDR) & 0x01) {
 3f0b1fc:	e3a03327 	mov	r3, #-1677721600	; 0x9c000000
 3f0b200:	e5d33000 	ldrb	r3, [r3]
 3f0b204:	e2130001 	ands	r0, r3, #1	; 0x1
 3f0b208:	091ba8f0 	ldmeqdb	r11, {r4, r5, r6, r7, r11, r13, r15}
		printf ("%s: Failed write, page 0x%08x, ", __FUNCTION__, page);
 3f0b20c:	e59f0014 	ldr	r0, [pc, #14]	; 3f0b228 <nand_write_page_without_ecc+0xb4>
 3f0b210:	e59f1014 	ldr	r1, [pc, #14]	; 3f0b22c <nand_write_page_without_ecc+0xb8>
 3f0b214:	e1a02007 	mov	r2, r7
 3f0b218:	eb000589 	bl	3f0c844 <printf>
		return -1;
 3f0b21c:	e3e00000 	mvn	r0, #0	; 0x0
	}

	return 0;
}
 3f0b220:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0b224:	9c000010 	stcls	0, cr0, [r0], -#64
 3f0b228:	03f1dbf4 	mvneqs	r13, #249856	; 0x3d000
 3f0b22c:	03f1e620 	mvneqs	r14, #33554432	; 0x2000000

03f0b230 <nand_write_without_ecc>:
 3f0b230:	e1a0c00d 	mov	r12, r13
 3f0b234:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0b238:	e24cb004 	sub	r11, r12, #4	; 0x4

static int nand_write_without_ecc (struct nand_chip* nand, size_t to, size_t len,
			   size_t * retlen, const u_char * buf)
{
	int i, page, col, cnt, ret = 0;
 3f0b23c:	e3a0c000 	mov	r12, #0	; 0x0
 3f0b240:	e1a05000 	mov	r5, r0
 3f0b244:	e1a00001 	mov	r0, r1
 3f0b248:	e1a07002 	mov	r7, r2

	/* Do not allow write past end of device */
	if ((to + len) > nand->totlen) {
 3f0b24c:	e0802007 	add	r2, r0, r7
 3f0b250:	e5951044 	ldr	r1, [r5, #68]
 3f0b254:	e1a06003 	mov	r6, r3
 3f0b258:	e59b9004 	ldr	r9, [r11, #4]
 3f0b25c:	e1520001 	cmp	r2, r1
 3f0b260:	9a000004 	bls	3f0b278 <nand_write_without_ecc+0x48>
		printf ("%s: Attempt to write past end of page\n", __FUNCTION__);
 3f0b264:	e59f0178 	ldr	r0, [pc, #178]	; 3f0b3e4 <nand_write_without_ecc+0x1b4>
 3f0b268:	e59f1178 	ldr	r1, [pc, #178]	; 3f0b3e8 <nand_write_without_ecc+0x1b8>
 3f0b26c:	eb000574 	bl	3f0c844 <printf>
		return -1;
 3f0b270:	e3e00000 	mvn	r0, #0	; 0x0
 3f0b274:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
	}

	/* Shift to get page */
	page = ((int) to) >> nand->page_shift;
 3f0b278:	e5952000 	ldr	r2, [r5]

	/* Get the starting column */
	col = to & (nand->oobblock - 1);
 3f0b27c:	e5953048 	ldr	r3, [r5, #72]

	/* Initialize return length value */
	*retlen = 0;
 3f0b280:	e586c000 	str	r12, [r6]
 3f0b284:	e1a0a250 	mov	r10, r0, asr r2
 3f0b288:	e2433001 	sub	r3, r3, #1	; 0x1
 3f0b28c:	e000e003 	and	r14, r0, r3

	/* Select the NAND device */
    	NAND_ENABLE_CE(nand);  /* set pin low */
 3f0b290:	e59f2154 	ldr	r2, [pc, #154]	; 3f0b3ec <nand_write_without_ecc+0x1bc>
 3f0b294:	e1d230b0 	ldrh	r3, [r2]
 3f0b298:	e3833902 	orr	r3, r3, #32768	; 0x8000
 3f0b29c:	e1c230b0 	strh	r3, [r2]
 3f0b2a0:	e1d230b0 	ldrh	r3, [r2]
 3f0b2a4:	e3833080 	orr	r3, r3, #128	; 0x80
 3f0b2a8:	e1c230b0 	strh	r3, [r2]
 3f0b2ac:	e3a02070 	mov	r2, #112	; 0x70
 3f0b2b0:	e59f3138 	ldr	r3, [pc, #138]	; 3f0b3f0 <nand_write_without_ecc+0x1c0>

	/* Check the WP bit */
	NanD_Command(nand, NAND_CMD_STATUS);
	if (!(READ_NAND(nand->IO_ADDR) & 0x80)) {
 3f0b2b4:	e4432010 	strb	r2, [r3], -#16
 3f0b2b8:	e5d33000 	ldrb	r3, [r3]
 3f0b2bc:	e3130080 	tst	r3, #128	; 0x80
 3f0b2c0:	1a000004 	bne	3f0b2d8 <nand_write_without_ecc+0xa8>
		printf ("%s: Device is write protected!!!\n", __FUNCTION__);
 3f0b2c4:	e59f0128 	ldr	r0, [pc, #128]	; 3f0b3f4 <nand_write_without_ecc+0x1c4>
 3f0b2c8:	e59f1118 	ldr	r1, [pc, #118]	; 3f0b3e8 <nand_write_without_ecc+0x1b8>
 3f0b2cc:	eb00055c 	bl	3f0c844 <printf>
		ret = -1;
 3f0b2d0:	e3e0c000 	mvn	r12, #0	; 0x0
		goto out;
 3f0b2d4:	ea000037 	b	3f0b3b8 <nand_write_without_ecc+0x188>
	}

	/* Loop until all data is written */
	while (*retlen < len) {
 3f0b2d8:	e5963000 	ldr	r3, [r6]
 3f0b2dc:	e1530007 	cmp	r3, r7
 3f0b2e0:	2a000033 	bcs	3f0b3b4 <nand_write_without_ecc+0x184>
		/* Invalidate cache, if we write to this page */
		if (nand->cache_page == page)
 3f0b2e4:	e595300c 	ldr	r3, [r5, #12]
 3f0b2e8:	e153000a 	cmp	r3, r10
			nand->cache_page = -1;
 3f0b2ec:	03e03000 	mvneq	r3, #0	; 0x0
 3f0b2f0:	0585300c 	streq	r3, [r5, #12]

		/* Write data into buffer */
		if ((col + len) >= nand->oobblock) {
 3f0b2f4:	e5952048 	ldr	r2, [r5, #72]
 3f0b2f8:	e08e3007 	add	r3, r14, r7
 3f0b2fc:	e1530002 	cmp	r3, r2
 3f0b300:	3a00000e 	bcc	3f0b340 <nand_write_without_ecc+0x110>
			for (i = col, cnt = 0; i < nand->oobblock; i++, cnt++)
 3f0b304:	e1a0c00e 	mov	r12, r14
 3f0b308:	e3a04000 	mov	r4, #0	; 0x0
 3f0b30c:	e15e0002 	cmp	r14, r2
 3f0b310:	2a000019 	bcs	3f0b37c <nand_write_without_ecc+0x14c>
				nand->data_buf[i] = buf[(*retlen + cnt)];
 3f0b314:	e5963000 	ldr	r3, [r6]
 3f0b318:	e5952004 	ldr	r2, [r5, #4]
 3f0b31c:	e0833004 	add	r3, r3, r4
 3f0b320:	e7d93003 	ldrb	r3, [r9, r3]
 3f0b324:	e7c2300c 	strb	r3, [r2, r12]
 3f0b328:	e2844001 	add	r4, r4, #1	; 0x1
 3f0b32c:	e5953048 	ldr	r3, [r5, #72]
 3f0b330:	e28cc001 	add	r12, r12, #1	; 0x1
 3f0b334:	e15c0003 	cmp	r12, r3
 3f0b338:	3afffff5 	bcc	3f0b314 <nand_write_without_ecc+0xe4>
		}
 3f0b33c:	ea00000e 	b	3f0b37c <nand_write_without_ecc+0x14c>
		else {
			for (i = col, cnt = 0; cnt < (len - *retlen); i++, cnt++)
 3f0b340:	e1a0c00e 	mov	r12, r14
 3f0b344:	e5961000 	ldr	r1, [r6]
 3f0b348:	e3a04000 	mov	r4, #0	; 0x0
 3f0b34c:	e1570001 	cmp	r7, r1
 3f0b350:	0a000009 	beq	3f0b37c <nand_write_without_ecc+0x14c>
				nand->data_buf[i] = buf[(*retlen + cnt)];
 3f0b354:	e5952004 	ldr	r2, [r5, #4]
 3f0b358:	e0813004 	add	r3, r1, r4
 3f0b35c:	e7d93003 	ldrb	r3, [r9, r3]
 3f0b360:	e7c2300c 	strb	r3, [r2, r12]
 3f0b364:	e2844001 	add	r4, r4, #1	; 0x1
 3f0b368:	e5961000 	ldr	r1, [r6]
 3f0b36c:	e28cc001 	add	r12, r12, #1	; 0x1
 3f0b370:	e0613007 	rsb	r3, r1, r7
 3f0b374:	e1540003 	cmp	r4, r3
 3f0b378:	3afffff5 	bcc	3f0b354 <nand_write_without_ecc+0x124>
		}

		/* We use the same function for write and writev !) */
		ret = nand_write_page_without_ecc(nand, page, col, i);
 3f0b37c:	e1a00005 	mov	r0, r5
 3f0b380:	e1a0100a 	mov	r1, r10
 3f0b384:	e1a0200e 	mov	r2, r14
 3f0b388:	e1a0300c 	mov	r3, r12
 3f0b38c:	ebffff78 	bl	3f0b174 <nand_write_page_without_ecc>
		if (ret)
 3f0b390:	e250c000 	subs	r12, r0, #0	; 0x0
 3f0b394:	1a000007 	bne	3f0b3b8 <nand_write_without_ecc+0x188>
			goto out;

		/* Next data start at page boundary */
		col = 0;
 3f0b398:	e1a0e00c 	mov	r14, r12

		/* Update written bytes count */
		*retlen += cnt;
 3f0b39c:	e5963000 	ldr	r3, [r6]

		/* Increment page address */
		page++;
 3f0b3a0:	e28aa001 	add	r10, r10, #1	; 0x1
 3f0b3a4:	e0833004 	add	r3, r3, r4
	}
 3f0b3a8:	e1530007 	cmp	r3, r7
 3f0b3ac:	e5863000 	str	r3, [r6]
 3f0b3b0:	3affffcb 	bcc	3f0b2e4 <nand_write_without_ecc+0xb4>

	/* Return happy */
	*retlen = len;
 3f0b3b4:	e5867000 	str	r7, [r6]

out:
	/* De-select the NAND device */
	NAND_DISABLE_CE(nand);  /* set pin high */
 3f0b3b8:	e59f302c 	ldr	r3, [pc, #2c]	; 3f0b3ec <nand_write_without_ecc+0x1bc>
 3f0b3bc:	e1d320b0 	ldrh	r2, [r3]
 3f0b3c0:	e3c22080 	bic	r2, r2, #128	; 0x80
 3f0b3c4:	e1a02802 	mov	r2, r2, lsl #16
 3f0b3c8:	e1a02822 	mov	r2, r2, lsr #16
 3f0b3cc:	e1c320b0 	strh	r2, [r3]
 3f0b3d0:	e1d320b0 	ldrh	r2, [r3]
 3f0b3d4:	e3822902 	orr	r2, r2, #32768	; 0x8000
 3f0b3d8:	e1c320b0 	strh	r2, [r3]
	return ret;
 3f0b3dc:	e1a0000c 	mov	r0, r12
}
 3f0b3e0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f0b3e4:	03f1dc2c 	mvneqs	r13, #11264	; 0x2c00
 3f0b3e8:	03f1e63c 	mvneqs	r14, #62914560	; 0x3c00000
 3f0b3ec:	c0003a3a 	andgt	r3, r0, r10, lsr r10
 3f0b3f0:	9c000010 	stcls	0, cr0, [r0], -#64
 3f0b3f4:	03f1dc68 	mvneqs	r13, #26624	; 0x6800

03f0b3f8 <nand_rw_without_ecc>:
 3f0b3f8:	e1a0c00d 	mov	r12, r13
 3f0b3fc:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0b400:	e24cb004 	sub	r11, r12, #4	; 0x4

static int nand_rw_without_ecc(struct nand_chip* nand, int cmd,
	    size_t start, size_t len,
	    size_t * retlen, u_char * buf)
{
 3f0b404:	e1a04002 	mov	r4, r2
	int ret = 0, n, total = 0;
 3f0b408:	e3a02000 	mov	r2, #0	; 0x0
 3f0b40c:	e24dd018 	sub	r13, r13, #24	; 0x18
 3f0b410:	e50b2038 	str	r2, [r11, -#56]
	char eccbuf[6];
	unsigned long eblk = ~0;	/* force mismatch on first pass */
 3f0b414:	e3e09000 	mvn	r9, #0	; 0x0
 3f0b418:	e59b6008 	ldr	r6, [r11, #8]
	unsigned long erasesize = nand->erasesize;
	unsigned long a;

	int pages_per_block = (nand->erasesize) / (nand->oobblock);

        dprintf("nand_rw_0\n");
	while (len) {
 3f0b41c:	e2535000 	subs	r5, r3, #0	; 0x0
 3f0b420:	e50b1034 	str	r1, [r11, -#52]
 3f0b424:	e1a0a000 	mov	r10, r0
 3f0b428:	e59a7028 	ldr	r7, [r10, #40]
 3f0b42c:	0a000022 	beq	3f0b4bc <nand_rw_without_ecc+0xc4>
		if ((start & (-erasesize)) != eblk) {
 3f0b430:	e2673000 	rsb	r3, r7, #0	; 0x0
			eblk = start & (-erasesize); /* start of block */
		}

		if (cmd & NANDRW_READ)
 3f0b434:	e51b1034 	ldr	r1, [r11, -#52]
 3f0b438:	e0049003 	and	r9, r4, r3
 3f0b43c:	e3110001 	tst	r1, #1	; 0x1
 3f0b440:	0a000009 	beq	3f0b46c <nand_rw_without_ecc+0x74>
                {
		        dprintf("nand_rw_2\n");
			ret = nand_read_without_ecc(nand, start,
					   min(len, eblk + erasesize - start),
 3f0b444:	e1a0000a 	mov	r0, r10
 3f0b448:	e1a01004 	mov	r1, r4
 3f0b44c:	e0892007 	add	r2, r9, r7
 3f0b450:	e0642002 	rsb	r2, r4, r2
 3f0b454:	e1520005 	cmp	r2, r5
 3f0b458:	21a02005 	movcs	r2, r5
 3f0b45c:	e24b3030 	sub	r3, r11, #48	; 0x30
 3f0b460:	e58d6000 	str	r6, [r13]
 3f0b464:	ebfffeea 	bl	3f0b014 <nand_read_without_ecc>
					   &n, (u_char*)buf);
                }
 3f0b468:	ea000008 	b	3f0b490 <nand_rw_without_ecc+0x98>
		else
                {
		        dprintf("nand_rw_3\n");                
			ret = nand_write_without_ecc(nand, start,
					    min(len, eblk + erasesize - start),
 3f0b46c:	e1a0000a 	mov	r0, r10
 3f0b470:	e1a01004 	mov	r1, r4
 3f0b474:	e0892007 	add	r2, r9, r7
 3f0b478:	e0642002 	rsb	r2, r4, r2
 3f0b47c:	e1520005 	cmp	r2, r5
 3f0b480:	21a02005 	movcs	r2, r5
 3f0b484:	e24b3030 	sub	r3, r11, #48	; 0x30
 3f0b488:	e58d6000 	str	r6, [r13]
 3f0b48c:	ebffff67 	bl	3f0b230 <nand_write_without_ecc>
 3f0b490:	e1a02000 	mov	r2, r0
					    &n, (u_char*)buf);
                }

		if (ret)
 3f0b494:	e3520000 	cmp	r2, #0	; 0x0
 3f0b498:	1a000007 	bne	3f0b4bc <nand_rw_without_ecc+0xc4>
			break;

		start  += n;
 3f0b49c:	e51b3030 	ldr	r3, [r11, -#48]
		buf   += n;
		total += n;
 3f0b4a0:	e51b1038 	ldr	r1, [r11, -#56]
 3f0b4a4:	e0844003 	add	r4, r4, r3
 3f0b4a8:	e0866003 	add	r6, r6, r3
 3f0b4ac:	e0811003 	add	r1, r1, r3
		len   -= n;
	}
 3f0b4b0:	e0555003 	subs	r5, r5, r3
 3f0b4b4:	e50b1038 	str	r1, [r11, -#56]
 3f0b4b8:	1affffdc 	bne	3f0b430 <nand_rw_without_ecc+0x38>

	if (retlen)
 3f0b4bc:	e59b3004 	ldr	r3, [r11, #4]
 3f0b4c0:	e3530000 	cmp	r3, #0	; 0x0
		*retlen = total;
 3f0b4c4:	151b1038 	ldrne	r1, [r11, -#56]
 3f0b4c8:	15831000 	strne	r1, [r3]

	return ret;
 3f0b4cc:	e1a00002 	mov	r0, r2
}
 3f0b4d0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0b4d4 <nand_env_read>:
 3f0b4d4:	e1a0c00d 	mov	r12, r13
 3f0b4d8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0b4dc:	e24cb004 	sub	r11, r12, #4	; 0x4

/* cmd: 0: NANDRW_WRITE			write, fail on bad block
 *	1: NANDRW_READ			read, fail on bad block
 */
int nand_env_read(size_t start, size_t len, u_char *buf)
{
	int ret;
	int total = 0;
 3f0b4e0:	e3a03000 	mov	r3, #0	; 0x0
 3f0b4e4:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f0b4e8:	e50b3010 	str	r3, [r11, -#16]
	ret = nand_rw_without_ecc(nand_dev_desc+curr_device, NANDRW_READ, start, len, &total, buf);
 3f0b4ec:	e24b3010 	sub	r3, r11, #16	; 0x10
 3f0b4f0:	e58d3000 	str	r3, [r13]
 3f0b4f4:	e58d2004 	str	r2, [r13, #4]
 3f0b4f8:	e59f3024 	ldr	r3, [pc, #24]	; 3f0b524 <nand_env_read+0x50>
 3f0b4fc:	e5933000 	ldr	r3, [r3]
 3f0b500:	e1a02000 	mov	r2, r0
 3f0b504:	e59f001c 	ldr	r0, [pc, #1c]	; 3f0b528 <nand_env_read+0x54>
 3f0b508:	e0833083 	add	r3, r3, r3, lsl #1
 3f0b50c:	e0633183 	rsb	r3, r3, r3, lsl #3
 3f0b510:	e0800103 	add	r0, r0, r3, lsl #2
 3f0b514:	e1a03001 	mov	r3, r1
 3f0b518:	e3a01001 	mov	r1, #1	; 0x1
 3f0b51c:	ebffffb5 	bl	3f0b3f8 <nand_rw_without_ecc>
 3f0b520:	ea000001 	b	3f0b52c <nand_env_read+0x58>
 3f0b524:	03f20848 	mvneqs	r0, #4718592	; 0x480000
 3f0b528:	03f207f4 	mvneqs	r0, #63963136	; 0x3d00000
	return ret;
}
 3f0b52c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0b530 <nand_env_write>:
 3f0b530:	e1a0c00d 	mov	r12, r13
 3f0b534:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0b538:	e24cb004 	sub	r11, r12, #4	; 0x4

int nand_env_write(size_t start, size_t len, u_char *buf)
{
 3f0b53c:	e1a07000 	mov	r7, r0
 3f0b540:	e1a09001 	mov	r9, r1
	int ret;
	int total = 0;
	ret = nand_erase(nand_dev_desc + curr_device, start, CFG_ENV_SIZE, 0);
 3f0b544:	e1a01007 	mov	r1, r7
 3f0b548:	e1a0a002 	mov	r10, r2
 3f0b54c:	e3a02901 	mov	r2, #16384	; 0x4000
 3f0b550:	e59f6054 	ldr	r6, [pc, #54]	; 3f0b5ac <nand_env_write+0x7c>
 3f0b554:	e3a04000 	mov	r4, #0	; 0x0
 3f0b558:	e5960000 	ldr	r0, [r6]
 3f0b55c:	e1a03004 	mov	r3, r4
 3f0b560:	e59f5048 	ldr	r5, [pc, #48]	; 3f0b5b0 <nand_env_write+0x80>
 3f0b564:	e0800080 	add	r0, r0, r0, lsl #1
 3f0b568:	e0600180 	rsb	r0, r0, r0, lsl #3
 3f0b56c:	e0850100 	add	r0, r5, r0, lsl #2
 3f0b570:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f0b574:	e50b4028 	str	r4, [r11, -#40]
 3f0b578:	ebfffd0c 	bl	3f0a9b0 <nand_erase>
	ret = nand_rw_without_ecc(nand_dev_desc+curr_device, NANDRW_WRITE, start, len, &total, buf);
 3f0b57c:	e1a01004 	mov	r1, r4
 3f0b580:	e24b3028 	sub	r3, r11, #40	; 0x28
 3f0b584:	e58d3000 	str	r3, [r13]
 3f0b588:	e1a02007 	mov	r2, r7
 3f0b58c:	e5960000 	ldr	r0, [r6]
 3f0b590:	e1a03009 	mov	r3, r9
 3f0b594:	e58da004 	str	r10, [r13, #4]
 3f0b598:	e0800080 	add	r0, r0, r0, lsl #1
 3f0b59c:	e0600180 	rsb	r0, r0, r0, lsl #3
 3f0b5a0:	e0850100 	add	r0, r5, r0, lsl #2
 3f0b5a4:	ebffff93 	bl	3f0b3f8 <nand_rw_without_ecc>
 3f0b5a8:	ea000001 	b	3f0b5b4 <nand_env_write+0x84>
 3f0b5ac:	03f20848 	mvneqs	r0, #4718592	; 0x480000
 3f0b5b0:	03f207f4 	mvneqs	r0, #63963136	; 0x3d00000
	return ret;
}
 3f0b5b4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0b5b8 <NanD_Command>:
 3f0b5b8:	e1a0c00d 	mov	r12, r13
 3f0b5bc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0b5c0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0b5c4:	e20110ff 	and	r1, r1, #255	; 0xff
 3f0b5c8:	e59f3008 	ldr	r3, [pc, #8]	; 3f0b5d8 <NanD_Command+0x20>
 3f0b5cc:	e5c31000 	strb	r1, [r3]
 3f0b5d0:	e3a00000 	mov	r0, #0	; 0x0
 3f0b5d4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0b5d8:	9c000010 	stcls	0, cr0, [r0], -#64

03f0b5dc <do_bootp>:
 3f0b5dc:	e1a0c00d 	mov	r12, r13
 3f0b5e0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0b5e4:	e24cb004 	sub	r11, r12, #4	; 0x4

static int netboot_common (int, cmd_tbl_t *, int , char *[]);

int do_bootp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f0b5e8:	e1a01000 	mov	r1, r0
	return netboot_common (BOOTP, cmdtp, argc, argv);
 3f0b5ec:	e3a00000 	mov	r0, #0	; 0x0
 3f0b5f0:	eb000068 	bl	3f0b798 <netboot_common>
 3f0b5f4:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0b5f8 <do_tftpb>:
 3f0b5f8:	e1a0c00d 	mov	r12, r13
 3f0b5fc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0b600:	e24cb004 	sub	r11, r12, #4	; 0x4
}

U_BOOT_CMD(
	bootp,	3,	1,	do_bootp,
	"bootp   - boot image via network using BootP/TFTP protocol\n",
	"[loadAddress] [bootfilename]\n"
);

int do_tftpb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f0b604:	e1a01000 	mov	r1, r0
	return netboot_common (TFTP, cmdtp, argc, argv);
 3f0b608:	e3a00003 	mov	r0, #3	; 0x3
 3f0b60c:	eb000061 	bl	3f0b798 <netboot_common>
 3f0b610:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0b614 <do_rarpb>:
 3f0b614:	e1a0c00d 	mov	r12, r13
 3f0b618:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0b61c:	e24cb004 	sub	r11, r12, #4	; 0x4
}

U_BOOT_CMD(
	tftpboot,	3,	1,	do_tftpb,
	"tftpboot- boot image via network using TFTP protocol\n",
	"[loadAddress] [bootfilename]\n"
);

int do_rarpb (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f0b620:	e1a01000 	mov	r1, r0
	return netboot_common (RARP, cmdtp, argc, argv);
 3f0b624:	e3a00001 	mov	r0, #1	; 0x1
 3f0b628:	eb00005a 	bl	3f0b798 <netboot_common>
 3f0b62c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0b630 <netboot_update_env>:
 3f0b630:	e1a0c00d 	mov	r12, r13
 3f0b634:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
}

U_BOOT_CMD(
	rarpboot,	3,	1,	do_rarpb,
	"rarpboot- boot image via network using RARP/TFTP protocol\n",
	"[loadAddress] [bootfilename]\n"
);

#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
int do_dhcp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	return netboot_common(DHCP, cmdtp, argc, argv);
}

U_BOOT_CMD(
	dhcp,	3,	1,	do_dhcp,
	"dhcp    - invoke DHCP client to obtain IP/boot params\n",
	"\n"
);
#endif	/* CFG_CMD_DHCP */

static void netboot_update_env(void)
{
    char tmp[16] ;

    if (NetOurGatewayIP) {
 3f0b638:	e59f3114 	ldr	r3, [pc, #114]	; 3f0b754 <netboot_update_env+0x124>
 3f0b63c:	e24dd010 	sub	r13, r13, #16	; 0x10
 3f0b640:	e5930000 	ldr	r0, [r3]
 3f0b644:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0b648:	e3500000 	cmp	r0, #0	; 0x0
 3f0b64c:	0a000005 	beq	3f0b668 <netboot_update_env+0x38>
	ip_to_string (NetOurGatewayIP, tmp);
 3f0b650:	e24b4020 	sub	r4, r11, #32	; 0x20
 3f0b654:	e1a01004 	mov	r1, r4
 3f0b658:	ebffd992 	bl	3f01ca8 <ip_to_string>
	setenv("gatewayip", tmp);
 3f0b65c:	e59f00f4 	ldr	r0, [pc, #f4]	; 3f0b758 <netboot_update_env+0x128>
 3f0b660:	e1a01004 	mov	r1, r4
 3f0b664:	eb00025b 	bl	3f0bfd8 <setenv>
    }

    if (NetOurSubnetMask) {
 3f0b668:	e59f30ec 	ldr	r3, [pc, #ec]	; 3f0b75c <netboot_update_env+0x12c>
 3f0b66c:	e5930000 	ldr	r0, [r3]
 3f0b670:	e3500000 	cmp	r0, #0	; 0x0
 3f0b674:	0a000005 	beq	3f0b690 <netboot_update_env+0x60>
	ip_to_string (NetOurSubnetMask, tmp);
 3f0b678:	e24b4020 	sub	r4, r11, #32	; 0x20
 3f0b67c:	e1a01004 	mov	r1, r4
 3f0b680:	ebffd988 	bl	3f01ca8 <ip_to_string>
	setenv("netmask", tmp);
 3f0b684:	e59f00d4 	ldr	r0, [pc, #d4]	; 3f0b760 <netboot_update_env+0x130>
 3f0b688:	e1a01004 	mov	r1, r4
 3f0b68c:	eb000251 	bl	3f0bfd8 <setenv>
    }

    if (NetOurHostName[0])
 3f0b690:	e59f10cc 	ldr	r1, [pc, #cc]	; 3f0b764 <netboot_update_env+0x134>
 3f0b694:	e5d13000 	ldrb	r3, [r1]
 3f0b698:	e3530000 	cmp	r3, #0	; 0x0
 3f0b69c:	0a000001 	beq	3f0b6a8 <netboot_update_env+0x78>
	setenv("hostname", NetOurHostName);
 3f0b6a0:	e59f00c0 	ldr	r0, [pc, #c0]	; 3f0b768 <netboot_update_env+0x138>
 3f0b6a4:	eb00024b 	bl	3f0bfd8 <setenv>

    if (NetOurRootPath[0])
 3f0b6a8:	e59f10bc 	ldr	r1, [pc, #bc]	; 3f0b76c <netboot_update_env+0x13c>
 3f0b6ac:	e5d13000 	ldrb	r3, [r1]
 3f0b6b0:	e3530000 	cmp	r3, #0	; 0x0
 3f0b6b4:	0a000001 	beq	3f0b6c0 <netboot_update_env+0x90>
	setenv("rootpath", NetOurRootPath);
 3f0b6b8:	e59f00b0 	ldr	r0, [pc, #b0]	; 3f0b770 <netboot_update_env+0x140>
 3f0b6bc:	eb000245 	bl	3f0bfd8 <setenv>

    if (NetOurIP) {
 3f0b6c0:	e59f30ac 	ldr	r3, [pc, #ac]	; 3f0b774 <netboot_update_env+0x144>
 3f0b6c4:	e5930000 	ldr	r0, [r3]
 3f0b6c8:	e3500000 	cmp	r0, #0	; 0x0
 3f0b6cc:	0a000005 	beq	3f0b6e8 <netboot_update_env+0xb8>
	ip_to_string (NetOurIP, tmp);
 3f0b6d0:	e24b4020 	sub	r4, r11, #32	; 0x20
 3f0b6d4:	e1a01004 	mov	r1, r4
 3f0b6d8:	ebffd972 	bl	3f01ca8 <ip_to_string>
	setenv("ipaddr", tmp);
 3f0b6dc:	e59f0094 	ldr	r0, [pc, #94]	; 3f0b778 <netboot_update_env+0x148>
 3f0b6e0:	e1a01004 	mov	r1, r4
 3f0b6e4:	eb00023b 	bl	3f0bfd8 <setenv>
    }

    if (NetServerIP) {
 3f0b6e8:	e59f308c 	ldr	r3, [pc, #8c]	; 3f0b77c <netboot_update_env+0x14c>
 3f0b6ec:	e5930000 	ldr	r0, [r3]
 3f0b6f0:	e3500000 	cmp	r0, #0	; 0x0
 3f0b6f4:	0a000005 	beq	3f0b710 <netboot_update_env+0xe0>
	ip_to_string (NetServerIP, tmp);
 3f0b6f8:	e24b4020 	sub	r4, r11, #32	; 0x20
 3f0b6fc:	e1a01004 	mov	r1, r4
 3f0b700:	ebffd968 	bl	3f01ca8 <ip_to_string>
	setenv("serverip", tmp);
 3f0b704:	e59f0074 	ldr	r0, [pc, #74]	; 3f0b780 <netboot_update_env+0x150>
 3f0b708:	e1a01004 	mov	r1, r4
 3f0b70c:	eb000231 	bl	3f0bfd8 <setenv>
    }

    if (NetOurDNSIP) {
 3f0b710:	e59f306c 	ldr	r3, [pc, #6c]	; 3f0b784 <netboot_update_env+0x154>
 3f0b714:	e5930000 	ldr	r0, [r3]
 3f0b718:	e3500000 	cmp	r0, #0	; 0x0
 3f0b71c:	0a000005 	beq	3f0b738 <netboot_update_env+0x108>
	ip_to_string (NetOurDNSIP, tmp);
 3f0b720:	e24b4020 	sub	r4, r11, #32	; 0x20
 3f0b724:	e1a01004 	mov	r1, r4
 3f0b728:	ebffd95e 	bl	3f01ca8 <ip_to_string>
	setenv("dnsip", tmp);
 3f0b72c:	e59f0054 	ldr	r0, [pc, #54]	; 3f0b788 <netboot_update_env+0x158>
 3f0b730:	e1a01004 	mov	r1, r4
 3f0b734:	eb000227 	bl	3f0bfd8 <setenv>
    }

#if (CONFIG_BOOTP_MASK & CONFIG_BOOTP_DNS2)
    if (NetOurDNS2IP) {
	    ip_to_string (NetOurDNS2IP, tmp);
	    setenv("dnsip2", tmp);
    }
#endif

    if (NetOurNISDomain[0])
 3f0b738:	e59f104c 	ldr	r1, [pc, #4c]	; 3f0b78c <netboot_update_env+0x15c>
 3f0b73c:	e5d13000 	ldrb	r3, [r1]
 3f0b740:	e3530000 	cmp	r3, #0	; 0x0
 3f0b744:	0a000012 	beq	3f0b794 <netboot_update_env+0x164>
	setenv("domain", NetOurNISDomain);
 3f0b748:	e59f0040 	ldr	r0, [pc, #40]	; 3f0b790 <netboot_update_env+0x160>
 3f0b74c:	eb000221 	bl	3f0bfd8 <setenv>
 3f0b750:	ea00000f 	b	3f0b794 <netboot_update_env+0x164>
 3f0b754:	03f20428 	mvneqs	r0, #671088640	; 0x28000000
 3f0b758:	03f1e744 	mvneqs	r14, #17825792	; 0x1100000
 3f0b75c:	03f20424 	mvneqs	r0, #603979776	; 0x24000000
 3f0b760:	03f1e750 	mvneqs	r14, #20971520	; 0x1400000
 3f0b764:	03f20450 	mvneqs	r0, #1342177280	; 0x50000000
 3f0b768:	03f1e758 	mvneqs	r14, #23068672	; 0x1600000
 3f0b76c:	03f20470 	mvneqs	r0, #1879048192	; 0x70000000
 3f0b770:	03f1e764 	mvneqs	r14, #26214400	; 0x1900000
 3f0b774:	03f6a6b8 	mvneqs	r10, #192937984	; 0xb800000
 3f0b778:	03f1e770 	mvneqs	r14, #29360128	; 0x1c00000
 3f0b77c:	03f6a6bc 	mvneqs	r10, #197132288	; 0xbc00000
 3f0b780:	03f1e778 	mvneqs	r14, #31457280	; 0x1e00000
 3f0b784:	03f2042c 	mvneqs	r0, #738197504	; 0x2c000000
 3f0b788:	03f1e784 	mvneqs	r14, #34603008	; 0x2100000
 3f0b78c:	03f20430 	mvneqs	r0, #805306368	; 0x30000000
 3f0b790:	03f1e78c 	mvneqs	r14, #36700160	; 0x2300000

}
 3f0b794:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f0b798 <netboot_common>:
 3f0b798:	e1a0c00d 	mov	r12, r13
 3f0b79c:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0b7a0:	e24cb004 	sub	r11, r12, #4	; 0x4
static int
netboot_common (int proto, cmd_tbl_t *cmdtp, int argc, char *argv[])
{
	char *s;
	int   rcode = 0;
 3f0b7a4:	e3a0a000 	mov	r10, #0	; 0x0
 3f0b7a8:	e1a05000 	mov	r5, r0
 3f0b7ac:	e1a09001 	mov	r9, r1
 3f0b7b0:	e1a04002 	mov	r4, r2
 3f0b7b4:	e1a06003 	mov	r6, r3
	int   size;

	/* pre-set load_addr */
	if ((s = getenv("loadaddr")) != NULL) {
 3f0b7b8:	e59f00dc 	ldr	r0, [pc, #dc]	; 3f0b89c <netboot_common+0x104>
 3f0b7bc:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f0b7c0:	eb000225 	bl	3f0c05c <getenv>
 3f0b7c4:	e3500000 	cmp	r0, #0	; 0x0
 3f0b7c8:	0a000004 	beq	3f0b7e0 <netboot_common+0x48>
		load_addr = simple_strtoul(s, NULL, 16);
 3f0b7cc:	e1a0100a 	mov	r1, r10
 3f0b7d0:	e3a02010 	mov	r2, #16	; 0x10
 3f0b7d4:	eb000fda 	bl	3f0f744 <simple_strtoul>
 3f0b7d8:	e59f30c0 	ldr	r3, [pc, #c0]	; 3f0b8a0 <netboot_common+0x108>
 3f0b7dc:	e5830000 	str	r0, [r3]
	}

	switch (argc) {
 3f0b7e0:	e3540002 	cmp	r4, #2	; 0x2
 3f0b7e4:	0a000006 	beq	3f0b804 <netboot_common+0x6c>
 3f0b7e8:	ca000002 	bgt	3f0b7f8 <netboot_common+0x60>
 3f0b7ec:	e3540001 	cmp	r4, #1	; 0x1
 3f0b7f0:	0a00001f 	beq	3f0b874 <netboot_common+0xdc>
 3f0b7f4:	ea000019 	b	3f0b860 <netboot_common+0xc8>
 3f0b7f8:	e3540003 	cmp	r4, #3	; 0x3
 3f0b7fc:	0a00000c 	beq	3f0b834 <netboot_common+0x9c>
 3f0b800:	ea000016 	b	3f0b860 <netboot_common+0xc8>
	case 1:
		break;

	case 2:	/* only one arg - accept two forms:
		 * just load address, or just boot file name.
		 * The latter form must be written "filename" here.
		 */
		if (argv[1][0] == '"') {	/* just boot filename */
 3f0b804:	e5960004 	ldr	r0, [r6, #4]
 3f0b808:	e5d03000 	ldrb	r3, [r0]
 3f0b80c:	e3530022 	cmp	r3, #34	; 0x22
			copy_filename (BootFile, argv[1], sizeof(BootFile));
 3f0b810:	01a01000 	moveq	r1, r0
 3f0b814:	059f0088 	ldreq	r0, [pc, #88]	; 3f0b8a4 <netboot_common+0x10c>
		} else {			/* load address	*/
 3f0b818:	0a00000d 	beq	3f0b854 <netboot_common+0xbc>
			load_addr = simple_strtoul(argv[1], NULL, 16);
 3f0b81c:	e1a0100a 	mov	r1, r10
 3f0b820:	e3a02010 	mov	r2, #16	; 0x10
 3f0b824:	eb000fc6 	bl	3f0f744 <simple_strtoul>
 3f0b828:	e59f3070 	ldr	r3, [pc, #70]	; 3f0b8a0 <netboot_common+0x108>
 3f0b82c:	e5830000 	str	r0, [r3]
		}
		break;
 3f0b830:	ea00000f 	b	3f0b874 <netboot_common+0xdc>

	case 3:	load_addr = simple_strtoul(argv[1], NULL, 16);
 3f0b834:	e1a0100a 	mov	r1, r10
 3f0b838:	e5960004 	ldr	r0, [r6, #4]
 3f0b83c:	e3a02010 	mov	r2, #16	; 0x10
 3f0b840:	eb000fbf 	bl	3f0f744 <simple_strtoul>
 3f0b844:	e59f3054 	ldr	r3, [pc, #54]	; 3f0b8a0 <netboot_common+0x108>
 3f0b848:	e5830000 	str	r0, [r3]
		copy_filename (BootFile, argv[2], sizeof(BootFile));
 3f0b84c:	e59f0050 	ldr	r0, [pc, #50]	; 3f0b8a4 <netboot_common+0x10c>
 3f0b850:	e5961008 	ldr	r1, [r6, #8]
 3f0b854:	e3a02080 	mov	r2, #128	; 0x80
 3f0b858:	ebffd8fa 	bl	3f01c48 <copy_filename>

		break;
 3f0b85c:	ea000004 	b	3f0b874 <netboot_common+0xdc>

	default: printf ("Usage:\n%s\n", cmdtp->usage);
 3f0b860:	e59f0040 	ldr	r0, [pc, #40]	; 3f0b8a8 <netboot_common+0x110>
 3f0b864:	e5991010 	ldr	r1, [r9, #16]
 3f0b868:	eb0003f5 	bl	3f0c844 <printf>
		return 1;
 3f0b86c:	e3a00001 	mov	r0, #1	; 0x1
 3f0b870:	ea000027 	b	3f0b914 <netboot_common+0x17c>
	}

	if ((size = NetLoop(proto)) < 0)
 3f0b874:	e1a00005 	mov	r0, r5
 3f0b878:	ebffd5c8 	bl	3f00fa0 <NetLoop>
 3f0b87c:	e2504000 	subs	r4, r0, #0	; 0x0
		return 1;
 3f0b880:	b3a00001 	movlt	r0, #1	; 0x1
 3f0b884:	ba000022 	blt	3f0b914 <netboot_common+0x17c>

	/* NetLoop ok, update environment */
	netboot_update_env();
 3f0b888:	ebffff68 	bl	3f0b630 <netboot_update_env>

	/* done if no file was loaded (no errors though) */
	if (size == 0)
 3f0b88c:	e3540000 	cmp	r4, #0	; 0x0
 3f0b890:	1a000005 	bne	3f0b8ac <netboot_common+0x114>
		return 0;
 3f0b894:	e1a00004 	mov	r0, r4
 3f0b898:	ea00001d 	b	3f0b914 <netboot_common+0x17c>
 3f0b89c:	03f1e794 	mvneqs	r14, #38797312	; 0x2500000
 3f0b8a0:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
 3f0b8a4:	03f6a6e0 	mvneqs	r10, #234881024	; 0xe000000
 3f0b8a8:	03f1e7a0 	mvneqs	r14, #41943040	; 0x2800000

	/* flush cache */
	flush_cache(load_addr, size);
 3f0b8ac:	e59f7064 	ldr	r7, [pc, #64]	; 3f0b918 <netboot_common+0x180>
 3f0b8b0:	e5970000 	ldr	r0, [r7]
 3f0b8b4:	e1a01004 	mov	r1, r4
 3f0b8b8:	eb003273 	bl	3f1828c <flush_cache>

	/* Loading ok, check if we should attempt an auto-start */
	if (((s = getenv("autostart")) != NULL) && (strcmp(s,"yes") == 0)) {
 3f0b8bc:	e59f0058 	ldr	r0, [pc, #58]	; 3f0b91c <netboot_common+0x184>
 3f0b8c0:	eb0001e5 	bl	3f0c05c <getenv>
 3f0b8c4:	e3500000 	cmp	r0, #0	; 0x0
 3f0b8c8:	0a000010 	beq	3f0b910 <netboot_common+0x178>
 3f0b8cc:	e59f104c 	ldr	r1, [pc, #4c]	; 3f0b920 <netboot_common+0x188>
 3f0b8d0:	eb000e38 	bl	3f0f1b8 <strcmp>
 3f0b8d4:	e2505000 	subs	r5, r0, #0	; 0x0
 3f0b8d8:	1a00000c 	bne	3f0b910 <netboot_common+0x178>
		char *local_args[2];
		local_args[0] = argv[0];
		local_args[1] = NULL;
 3f0b8dc:	e50b5028 	str	r5, [r11, -#40]

		printf ("Automatic boot of image at addr 0x%08lX ...\n",
 3f0b8e0:	e59f003c 	ldr	r0, [pc, #3c]	; 3f0b924 <netboot_common+0x18c>
 3f0b8e4:	e5971000 	ldr	r1, [r7]
 3f0b8e8:	e5963000 	ldr	r3, [r6]
 3f0b8ec:	e24b402c 	sub	r4, r11, #44	; 0x2c
 3f0b8f0:	e50b302c 	str	r3, [r11, -#44]
 3f0b8f4:	eb0003d2 	bl	3f0c844 <printf>
			load_addr);
		rcode = do_bootm (cmdtp, 0, 1, local_args);
 3f0b8f8:	e1a00009 	mov	r0, r9
 3f0b8fc:	e1a01005 	mov	r1, r5
 3f0b900:	e3a02001 	mov	r2, #1	; 0x1
 3f0b904:	e1a03004 	mov	r3, r4
 3f0b908:	ebffe2e0 	bl	3f04490 <do_bootm>
 3f0b90c:	e1a0a000 	mov	r10, r0
	}

#ifdef CONFIG_AUTOSCRIPT
	if (((s = getenv("autoscript")) != NULL) && (strcmp(s,"yes") == 0)) {
		printf("Running autoscript at addr 0x%08lX ...\n", load_addr);
		rcode = autoscript (load_addr);
	}
#endif
	return rcode;
 3f0b910:	e1a0000a 	mov	r0, r10
 3f0b914:	ea000003 	b	3f0b928 <netboot_common+0x190>
 3f0b918:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
 3f0b91c:	03f1e7ac 	mvneqs	r14, #45088768	; 0x2b00000
 3f0b920:	03f1e7b8 	mvneqs	r14, #48234496	; 0x2e00000
 3f0b924:	03f1e7bc 	mvneqs	r14, #49283072	; 0x2f00000
}
 3f0b928:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0b92c <do_printenv>:
 3f0b92c:	e1a0c00d 	mov	r12, r13
 3f0b930:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0b934:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_printenv (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	int i, j, k, nxt;
	int rcode = 0;
 3f0b938:	e3a01000 	mov	r1, #0	; 0x0
 3f0b93c:	e1a09002 	mov	r9, r2
 3f0b940:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f0b944:	e50b102c 	str	r1, [r11, -#44]

	if (argc == 1) {		/* Print all env variables	*/
 3f0b948:	e3590001 	cmp	r9, #1	; 0x1
 3f0b94c:	e50b3028 	str	r3, [r11, -#40]
 3f0b950:	1a00002a 	bne	3f0ba00 <do_printenv+0xd4>
		for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
 3f0b954:	e1a07001 	mov	r7, r1
 3f0b958:	ea000018 	b	3f0b9c0 <do_printenv+0x94>
			for (nxt=i; env_get_char(nxt) != '\0'; ++nxt)
 3f0b95c:	e1a05007 	mov	r5, r7
 3f0b960:	ea000000 	b	3f0b968 <do_printenv+0x3c>
 3f0b964:	e2855001 	add	r5, r5, #1	; 0x1
 3f0b968:	e1a00005 	mov	r0, r5
 3f0b96c:	e1a0e00f 	mov	r14, r15
 3f0b970:	e596f000 	ldr	r15, [r6]
 3f0b974:	e31000ff 	tst	r0, #255	; 0xff
 3f0b978:	1afffff9 	bne	3f0b964 <do_printenv+0x38>
				;
			for (k=i; k<nxt; ++k)
 3f0b97c:	e1a04007 	mov	r4, r7
 3f0b980:	e1540005 	cmp	r4, r5
 3f0b984:	aa000007 	bge	3f0b9a8 <do_printenv+0x7c>
				putc(env_get_char(k));
 3f0b988:	e1a00004 	mov	r0, r4
 3f0b98c:	e1a0e00f 	mov	r14, r15
 3f0b990:	e596f000 	ldr	r15, [r6]
 3f0b994:	e20000ff 	and	r0, r0, #255	; 0xff
 3f0b998:	eb00038f 	bl	3f0c7dc <putc>
 3f0b99c:	e2844001 	add	r4, r4, #1	; 0x1
 3f0b9a0:	e1540005 	cmp	r4, r5
 3f0b9a4:	bafffff7 	blt	3f0b988 <do_printenv+0x5c>
			putc  ('\n');
 3f0b9a8:	e3a0000a 	mov	r0, #10	; 0xa
 3f0b9ac:	eb00038a 	bl	3f0c7dc <putc>

			if (ctrlc()) {
 3f0b9b0:	eb0003bd 	bl	3f0c8ac <ctrlc>
 3f0b9b4:	e3500000 	cmp	r0, #0	; 0x0
 3f0b9b8:	1a00000c 	bne	3f0b9f0 <do_printenv+0xc4>
 3f0b9bc:	e2857001 	add	r7, r5, #1	; 0x1
 3f0b9c0:	e59f60d0 	ldr	r6, [pc, #d0]	; 3f0ba98 <do_printenv+0x16c>
 3f0b9c4:	e1a00007 	mov	r0, r7
 3f0b9c8:	e1a0e00f 	mov	r14, r15
 3f0b9cc:	e596f000 	ldr	r15, [r6]
 3f0b9d0:	e21040ff 	ands	r4, r0, #255	; 0xff
 3f0b9d4:	1affffe0 	bne	3f0b95c <do_printenv+0x30>
				puts ("\n ** Abort\n");
				return 1;
			}
		}

		printf("\nEnvironment size: %d/%d bytes\n", i, ENV_SIZE);
 3f0b9d8:	e59f00bc 	ldr	r0, [pc, #bc]	; 3f0ba9c <do_printenv+0x170>
 3f0b9dc:	e59f20bc 	ldr	r2, [pc, #bc]	; 3f0baa0 <do_printenv+0x174>
 3f0b9e0:	e1a01007 	mov	r1, r7
 3f0b9e4:	eb000396 	bl	3f0c844 <printf>

		return 0;
 3f0b9e8:	e1a00004 	mov	r0, r4
 3f0b9ec:	ea000040 	b	3f0baf4 <do_printenv+0x1c8>
 3f0b9f0:	e59f00ac 	ldr	r0, [pc, #ac]	; 3f0baa4 <do_printenv+0x178>
 3f0b9f4:	eb000385 	bl	3f0c810 <puts>
 3f0b9f8:	e3a00001 	mov	r0, #1	; 0x1
 3f0b9fc:	ea00003c 	b	3f0baf4 <do_printenv+0x1c8>
	}

	for (i=1; i<argc; ++i) {	/* print single env variables	*/
 3f0ba00:	e3a07001 	mov	r7, #1	; 0x1
 3f0ba04:	e1570009 	cmp	r7, r9
 3f0ba08:	aa000038 	bge	3f0baf0 <do_printenv+0x1c4>
		char *name = argv[i];
 3f0ba0c:	e51b3028 	ldr	r3, [r11, -#40]

		k = -1;
 3f0ba10:	e3e04000 	mvn	r4, #0	; 0x0
 3f0ba14:	e793a107 	ldr	r10, [r3, r7, lsl #2]

		for (j=0; env_get_char(j) != '\0'; j=nxt+1) {
 3f0ba18:	e3a06000 	mov	r6, #0	; 0x0
 3f0ba1c:	ea000022 	b	3f0baac <do_printenv+0x180>

			for (nxt=j; env_get_char(nxt) != '\0'; ++nxt)
 3f0ba20:	e1a05006 	mov	r5, r6
 3f0ba24:	ea000000 	b	3f0ba2c <do_printenv+0x100>
 3f0ba28:	e2855001 	add	r5, r5, #1	; 0x1
 3f0ba2c:	e59f1064 	ldr	r1, [pc, #64]	; 3f0ba98 <do_printenv+0x16c>
 3f0ba30:	e1a00005 	mov	r0, r5
 3f0ba34:	e1a0e00f 	mov	r14, r15
 3f0ba38:	e591f000 	ldr	r15, [r1]
 3f0ba3c:	e31000ff 	tst	r0, #255	; 0xff
 3f0ba40:	1afffff8 	bne	3f0ba28 <do_printenv+0xfc>
				;
			k = envmatch(name, j);
 3f0ba44:	e1a0000a 	mov	r0, r10
 3f0ba48:	e1a01006 	mov	r1, r6
 3f0ba4c:	eb0001e7 	bl	3f0c1f0 <envmatch>
			if (k < 0) {
 3f0ba50:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0ba54:	ba000013 	blt	3f0baa8 <do_printenv+0x17c>
				continue;
			}
			puts (name);
 3f0ba58:	e1a0000a 	mov	r0, r10
 3f0ba5c:	eb00036b 	bl	3f0c810 <puts>
			putc ('=');
 3f0ba60:	e3a0003d 	mov	r0, #61	; 0x3d
			while (k < nxt)
 3f0ba64:	ea000005 	b	3f0ba80 <do_printenv+0x154>
				putc(env_get_char(k++));
 3f0ba68:	e1a00004 	mov	r0, r4
 3f0ba6c:	e59f3024 	ldr	r3, [pc, #24]	; 3f0ba98 <do_printenv+0x16c>
 3f0ba70:	e2844001 	add	r4, r4, #1	; 0x1
 3f0ba74:	e1a0e00f 	mov	r14, r15
 3f0ba78:	e593f000 	ldr	r15, [r3]
 3f0ba7c:	e20000ff 	and	r0, r0, #255	; 0xff
 3f0ba80:	eb000355 	bl	3f0c7dc <putc>
 3f0ba84:	e1540005 	cmp	r4, r5
 3f0ba88:	bafffff6 	blt	3f0ba68 <do_printenv+0x13c>
			putc ('\n');
 3f0ba8c:	e3a0000a 	mov	r0, #10	; 0xa
 3f0ba90:	eb000351 	bl	3f0c7dc <putc>
			break;
 3f0ba94:	ea00000a 	b	3f0bac4 <do_printenv+0x198>
 3f0ba98:	03f20ccc 	mvneqs	r0, #52224	; 0xcc00
 3f0ba9c:	03f1e80c 	mvneqs	r14, #786432	; 0xc0000
 3f0baa0:	00003ffc 	streqd	r3, [r0], -r12
 3f0baa4:	03f1e800 	mvneqs	r14, #0	; 0x0
 3f0baa8:	e2856001 	add	r6, r5, #1	; 0x1
 3f0baac:	e59f1044 	ldr	r1, [pc, #44]	; 3f0baf8 <do_printenv+0x1cc>
 3f0bab0:	e1a00006 	mov	r0, r6
 3f0bab4:	e1a0e00f 	mov	r14, r15
 3f0bab8:	e591f000 	ldr	r15, [r1]
 3f0babc:	e31000ff 	tst	r0, #255	; 0xff
 3f0bac0:	1affffd6 	bne	3f0ba20 <do_printenv+0xf4>
		}
		if (k < 0) {
 3f0bac4:	e3540000 	cmp	r4, #0	; 0x0
 3f0bac8:	aa000005 	bge	3f0bae4 <do_printenv+0x1b8>
			printf ("## Error: \"%s\" not defined\n", name);
			rcode ++;
 3f0bacc:	e51b302c 	ldr	r3, [r11, -#44]
 3f0bad0:	e1a0100a 	mov	r1, r10
 3f0bad4:	e59f0020 	ldr	r0, [pc, #20]	; 3f0bafc <do_printenv+0x1d0>
 3f0bad8:	e2833001 	add	r3, r3, #1	; 0x1
 3f0badc:	e50b302c 	str	r3, [r11, -#44]
 3f0bae0:	eb000357 	bl	3f0c844 <printf>
 3f0bae4:	e2877001 	add	r7, r7, #1	; 0x1
 3f0bae8:	e1570009 	cmp	r7, r9
 3f0baec:	baffffc6 	blt	3f0ba0c <do_printenv+0xe0>
		}
	}
	return rcode;
 3f0baf0:	e51b002c 	ldr	r0, [r11, -#44]
 3f0baf4:	ea000001 	b	3f0bb00 <do_printenv+0x1d4>
 3f0baf8:	03f20ccc 	mvneqs	r0, #52224	; 0xcc00
 3f0bafc:	03f1e82c 	mvneqs	r14, #2883584	; 0x2c0000
}
 3f0bb00:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0bb04 <_do_setenv>:
 3f0bb04:	e1a0c00d 	mov	r12, r13
 3f0bb08:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0bb0c:	e24cb004 	sub	r11, r12, #4	; 0x4

/************************************************************************
 * Set a new environment variable,
 * or replace or delete an existing one.
 *
 * This function will ONLY work with a in-RAM copy of the environment
 */

int _do_setenv (int flag, int argc, char *argv[])
{
	DECLARE_GLOBAL_DATA_PTR;

	int   i, len, oldval;
	int   console = -1;
 3f0bb10:	e3e04000 	mvn	r4, #0	; 0x0
	uchar *env, *nxt = NULL;
 3f0bb14:	e3a09000 	mov	r9, #0	; 0x0
 3f0bb18:	e24dd014 	sub	r13, r13, #20	; 0x14
 3f0bb1c:	e50b1030 	str	r1, [r11, -#48]
 3f0bb20:	e1a07002 	mov	r7, r2
	uchar *name;
	bd_t *bd = gd->bd;
 3f0bb24:	e5982000 	ldr	r2, [r8]

	uchar *env_data = env_get_addr(0);
 3f0bb28:	e1a00009 	mov	r0, r9
 3f0bb2c:	e50b2034 	str	r2, [r11, -#52]
 3f0bb30:	eb0008dd 	bl	3f0deac <env_get_addr>

	if (!env_data)	/* need copy in RAM */
 3f0bb34:	e3500000 	cmp	r0, #0	; 0x0
 3f0bb38:	e50b0038 	str	r0, [r11, -#56]
 3f0bb3c:	0a00009c 	beq	3f0bdb4 <_do_setenv+0x2b0>
		return 1;

	name = argv[1];

	/*
	 * search if variable with this name already exists
	 */
	oldval = -1;
	for (env=env_data; *env; env=nxt+1) {
 3f0bb40:	e51b6038 	ldr	r6, [r11, -#56]
 3f0bb44:	e5d63000 	ldrb	r3, [r6]
 3f0bb48:	e1a00004 	mov	r0, r4
 3f0bb4c:	e597a004 	ldr	r10, [r7, #4]
 3f0bb50:	e3530000 	cmp	r3, #0	; 0x0
 3f0bb54:	0a000010 	beq	3f0bb9c <_do_setenv+0x98>
		for (nxt=env; *nxt; ++nxt)
 3f0bb58:	e5d63000 	ldrb	r3, [r6]
 3f0bb5c:	e1a09006 	mov	r9, r6
 3f0bb60:	e3530000 	cmp	r3, #0	; 0x0
 3f0bb64:	0a000002 	beq	3f0bb74 <_do_setenv+0x70>
 3f0bb68:	e5f93001 	ldrb	r3, [r9, #1]!
 3f0bb6c:	e3530000 	cmp	r3, #0	; 0x0
 3f0bb70:	1afffffc 	bne	3f0bb68 <_do_setenv+0x64>
			;
		if ((oldval = envmatch(name, env-env_data)) >= 0)
 3f0bb74:	e51b3038 	ldr	r3, [r11, -#56]
 3f0bb78:	e1a0000a 	mov	r0, r10
 3f0bb7c:	e0631006 	rsb	r1, r3, r6
 3f0bb80:	eb00019a 	bl	3f0c1f0 <envmatch>
 3f0bb84:	e3500000 	cmp	r0, #0	; 0x0
 3f0bb88:	aa000003 	bge	3f0bb9c <_do_setenv+0x98>
 3f0bb8c:	e1a06009 	mov	r6, r9
 3f0bb90:	e5f63001 	ldrb	r3, [r6, #1]!
 3f0bb94:	e3530000 	cmp	r3, #0	; 0x0
 3f0bb98:	1affffee 	bne	3f0bb58 <_do_setenv+0x54>
			break;
	}

	/*
	 * Delete any existing definition
	 */
	if (oldval >= 0) {
 3f0bb9c:	e3500000 	cmp	r0, #0	; 0x0
 3f0bba0:	ba000057 	blt	3f0bd04 <_do_setenv+0x200>
#ifndef CONFIG_ENV_OVERWRITE

		/*
		 * Ethernet Address and serial# can be set only once,
		 * ver is readonly.
		 */
		if ( (strcmp (name, "serial#") == 0) ||
		    ((strcmp (name, "ethaddr") == 0)
#if defined(CONFIG_OVERWRITE_ETHADDR_ONCE) && defined(CONFIG_ETHADDR)
		     && (strcmp (env_get_addr(oldval),MK_STR(CONFIG_ETHADDR)) != 0)
#endif	/* CONFIG_OVERWRITE_ETHADDR_ONCE && CONFIG_ETHADDR */
		    ) ) {
			printf ("Can't overwrite \"%s\"\n", name);
			return 1;
		}
#endif

		/* Check for console redirection */
		if (strcmp(name,"stdin") == 0) {
 3f0bba4:	e59f13c0 	ldr	r1, [pc, #3c0]	; 3f0bf6c <_do_setenv+0x468>
 3f0bba8:	e1a0000a 	mov	r0, r10
 3f0bbac:	eb000d81 	bl	3f0f1b8 <strcmp>
 3f0bbb0:	e3500000 	cmp	r0, #0	; 0x0
			console = stdin;
 3f0bbb4:	01a04000 	moveq	r4, r0
		} else if (strcmp(name,"stdout") == 0) {
 3f0bbb8:	0a00000b 	beq	3f0bbec <_do_setenv+0xe8>
 3f0bbbc:	e59f13ac 	ldr	r1, [pc, #3ac]	; 3f0bf70 <_do_setenv+0x46c>
 3f0bbc0:	e1a0000a 	mov	r0, r10
 3f0bbc4:	eb000d7b 	bl	3f0f1b8 <strcmp>
 3f0bbc8:	e3500000 	cmp	r0, #0	; 0x0
			console = stdout;
 3f0bbcc:	03a04001 	moveq	r4, #1	; 0x1
		} else if (strcmp(name,"stderr") == 0) {
 3f0bbd0:	0a000005 	beq	3f0bbec <_do_setenv+0xe8>
 3f0bbd4:	e59f1398 	ldr	r1, [pc, #398]	; 3f0bf74 <_do_setenv+0x470>
 3f0bbd8:	e1a0000a 	mov	r0, r10
 3f0bbdc:	eb000d75 	bl	3f0f1b8 <strcmp>
 3f0bbe0:	e3500000 	cmp	r0, #0	; 0x0
 3f0bbe4:	13e04000 	mvnne	r4, #0	; 0x0
 3f0bbe8:	03a04002 	moveq	r4, #2	; 0x2
			console = stderr;
		}

		if (console != -1) {
 3f0bbec:	e3740001 	cmn	r4, #1	; 0x1
 3f0bbf0:	0a000008 	beq	3f0bc18 <_do_setenv+0x114>
			if (argc < 3) {		/* Cannot delete it! */
 3f0bbf4:	e51b2030 	ldr	r2, [r11, -#48]
 3f0bbf8:	e3520002 	cmp	r2, #2	; 0x2
				printf("Can't delete \"%s\"\n", name);
 3f0bbfc:	d59f0374 	ldrle	r0, [pc, #374]	; 3f0bf78 <_do_setenv+0x474>
				return 1;
 3f0bc00:	da000069 	ble	3f0bdac <_do_setenv+0x2a8>
			}

			/* Try assigning specified device */
			if (console_assign (console, argv[2]) < 0)
 3f0bc04:	e5971008 	ldr	r1, [r7, #8]
 3f0bc08:	e1a00004 	mov	r0, r4
 3f0bc0c:	eb00035b 	bl	3f0c980 <console_assign>
 3f0bc10:	e3500000 	cmp	r0, #0	; 0x0
 3f0bc14:	ba000066 	blt	3f0bdb4 <_do_setenv+0x2b0>
				return 1;
		}

		/*
		 * Switch to new baudrate if new baudrate is supported
		 */
		if (strcmp(argv[1],"baudrate") == 0) {
 3f0bc18:	e5970004 	ldr	r0, [r7, #4]
 3f0bc1c:	e59f1358 	ldr	r1, [pc, #358]	; 3f0bf7c <_do_setenv+0x478>
 3f0bc20:	eb000d64 	bl	3f0f1b8 <strcmp>
 3f0bc24:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0bc28:	1a000020 	bne	3f0bcb0 <_do_setenv+0x1ac>
			int baudrate = simple_strtoul(argv[2], NULL, 10);
 3f0bc2c:	e1a01004 	mov	r1, r4
 3f0bc30:	e5970008 	ldr	r0, [r7, #8]
 3f0bc34:	e3a0200a 	mov	r2, #10	; 0xa
 3f0bc38:	eb000ec1 	bl	3f0f744 <simple_strtoul>
			int i;
			for (i=0; i<N_BAUDRATES; ++i) {
				if (baudrate == baudrate_table[i])
 3f0bc3c:	e59f233c 	ldr	r2, [pc, #33c]	; 3f0bf80 <_do_setenv+0x47c>
 3f0bc40:	e1a01004 	mov	r1, r4
 3f0bc44:	e7923001 	ldr	r3, [r2, r1]
 3f0bc48:	e1a05000 	mov	r5, r0
 3f0bc4c:	e1550003 	cmp	r5, r3
 3f0bc50:	0a000005 	beq	3f0bc6c <_do_setenv+0x168>
 3f0bc54:	e2811001 	add	r1, r1, #1	; 0x1
 3f0bc58:	e3510004 	cmp	r1, #4	; 0x4
 3f0bc5c:	8a000002 	bhi	3f0bc6c <_do_setenv+0x168>
 3f0bc60:	e7923101 	ldr	r3, [r2, r1, lsl #2]
 3f0bc64:	e1550003 	cmp	r5, r3
 3f0bc68:	1afffff9 	bne	3f0bc54 <_do_setenv+0x150>
					break;
			}
			if (i == N_BAUDRATES) {
 3f0bc6c:	e3510005 	cmp	r1, #5	; 0x5
				printf ("## Baudrate %d bps not supported\n",
 3f0bc70:	059f030c 	ldreq	r0, [pc, #30c]	; 3f0bf84 <_do_setenv+0x480>
 3f0bc74:	01a01005 	moveq	r1, r5
					baudrate);
				return 1;
 3f0bc78:	0a00004c 	beq	3f0bdb0 <_do_setenv+0x2ac>
			}
			printf ("## Switch baudrate to %d bps and press ENTER ...\n",
 3f0bc7c:	e59f0304 	ldr	r0, [pc, #304]	; 3f0bf88 <_do_setenv+0x484>
 3f0bc80:	e1a01005 	mov	r1, r5
				baudrate);
			udelay(50000);
 3f0bc84:	e59f4300 	ldr	r4, [pc, #300]	; 3f0bf8c <_do_setenv+0x488>
 3f0bc88:	eb0002ed 	bl	3f0c844 <printf>
 3f0bc8c:	e1a00004 	mov	r0, r4
 3f0bc90:	ebffd2e0 	bl	3f00818 <udelay>
			gd->baudrate = baudrate;
 3f0bc94:	e5885008 	str	r5, [r8, #8]
#ifdef CONFIG_PPC
			gd->bd->bi_baudrate = baudrate;
#endif

			serial_setbrg ();
 3f0bc98:	eb0029b3 	bl	3f1636c <serial_setbrg>
			udelay(50000);
 3f0bc9c:	e1a00004 	mov	r0, r4
 3f0bca0:	ebffd2dc 	bl	3f00818 <udelay>
			for (;;) {
				if (getc() == '\r')
 3f0bca4:	eb0002b6 	bl	3f0c784 <getc>
 3f0bca8:	e350000d 	cmp	r0, #13	; 0xd
 3f0bcac:	1afffffc 	bne	3f0bca4 <_do_setenv+0x1a0>
				      break;
			}
		}

		if (*++nxt == '\0') {
 3f0bcb0:	e5f93001 	ldrb	r3, [r9, #1]!
 3f0bcb4:	e20320ff 	and	r2, r3, #255	; 0xff
 3f0bcb8:	e3520000 	cmp	r2, #0	; 0x0
 3f0bcbc:	1a000005 	bne	3f0bcd8 <_do_setenv+0x1d4>
			if (env > env_data) {
 3f0bcc0:	e51b3038 	ldr	r3, [r11, -#56]
 3f0bcc4:	e1560003 	cmp	r6, r3
				env--;
 3f0bcc8:	82466001 	subhi	r6, r6, #1	; 0x1
			} else {
 3f0bccc:	8a00000a 	bhi	3f0bcfc <_do_setenv+0x1f8>
				*env = '\0';
 3f0bcd0:	e5c62000 	strb	r2, [r6]
			}
		} else {
 3f0bcd4:	ea000008 	b	3f0bcfc <_do_setenv+0x1f8>
			for (;;) {
				*env = *nxt++;
 3f0bcd8:	e2899001 	add	r9, r9, #1	; 0x1
 3f0bcdc:	e5c63000 	strb	r3, [r6]
 3f0bce0:	e4d93001 	ldrb	r3, [r9], #1
				if ((*env == '\0') && (*nxt == '\0'))
 3f0bce4:	e31300ff 	tst	r3, #255	; 0xff
 3f0bce8:	e5e63001 	strb	r3, [r6, #1]!
 3f0bcec:	1afffffb 	bne	3f0bce0 <_do_setenv+0x1dc>
 3f0bcf0:	e5d93000 	ldrb	r3, [r9]
 3f0bcf4:	e3530000 	cmp	r3, #0	; 0x0
 3f0bcf8:	1afffff8 	bne	3f0bce0 <_do_setenv+0x1dc>
					break;
				++env;
			}
		}
		*++env = '\0';
 3f0bcfc:	e3a03000 	mov	r3, #0	; 0x0
 3f0bd00:	e5c63001 	strb	r3, [r6, #1]
	}

#ifdef CONFIG_NET_MULTI
	if (strncmp(name, "eth", 3) == 0) {
		char *end;
		int   num = simple_strtoul(name+3, &end, 10);

		if (strcmp(end, "addr") == 0) {
			eth_set_enetaddr(num, argv[2]);
		}
	}
#endif


	/* Delete only ? */
	if ((argc < 3) || argv[2] == NULL) {
 3f0bd04:	e51b2030 	ldr	r2, [r11, -#48]
 3f0bd08:	e3520002 	cmp	r2, #2	; 0x2
 3f0bd0c:	da000002 	ble	3f0bd1c <_do_setenv+0x218>
 3f0bd10:	e5973008 	ldr	r3, [r7, #8]
 3f0bd14:	e3530000 	cmp	r3, #0	; 0x0
 3f0bd18:	1a000001 	bne	3f0bd24 <_do_setenv+0x220>
		env_crc_update ();
 3f0bd1c:	eb00083b 	bl	3f0de10 <env_crc_update>
		return 0;
 3f0bd20:	ea0000a7 	b	3f0bfc4 <_do_setenv+0x4c0>
	}

	/*
	 * Append new definition at the end
	 */
	for (env=env_data; *env || *(env+1); ++env)
 3f0bd24:	e51b6038 	ldr	r6, [r11, -#56]
 3f0bd28:	e5d63000 	ldrb	r3, [r6]
 3f0bd2c:	ea000000 	b	3f0bd34 <_do_setenv+0x230>
 3f0bd30:	e5f63001 	ldrb	r3, [r6, #1]!
 3f0bd34:	e3530000 	cmp	r3, #0	; 0x0
 3f0bd38:	1afffffc 	bne	3f0bd30 <_do_setenv+0x22c>
 3f0bd3c:	e5d63001 	ldrb	r3, [r6, #1]
 3f0bd40:	e3530000 	cmp	r3, #0	; 0x0
 3f0bd44:	1afffff9 	bne	3f0bd30 <_do_setenv+0x22c>
		;
	if (env > env_data)
 3f0bd48:	e51b3038 	ldr	r3, [r11, -#56]
		++env;
	/*
	 * Overflow when:
	 * "name" + "=" + "val" +"\0\0"  > ENV_SIZE - (env-env_data)
	 */
	len = strlen(name) + 2;
 3f0bd4c:	e1a0000a 	mov	r0, r10
 3f0bd50:	e1560003 	cmp	r6, r3
 3f0bd54:	82866001 	addhi	r6, r6, #1	; 0x1
 3f0bd58:	eb000d5a 	bl	3f0f2c8 <strlen>
 3f0bd5c:	e2804002 	add	r4, r0, #2	; 0x2
	/* add '=' for first arg, ' ' for all others */
	for (i=2; i<argc; ++i) {
 3f0bd60:	e51b2030 	ldr	r2, [r11, -#48]
 3f0bd64:	e3a05002 	mov	r5, #2	; 0x2
 3f0bd68:	e1550002 	cmp	r5, r2
 3f0bd6c:	aa000007 	bge	3f0bd90 <_do_setenv+0x28c>
		len += strlen(argv[i]) + 1;
 3f0bd70:	e7970105 	ldr	r0, [r7, r5, lsl #2]
 3f0bd74:	eb000d53 	bl	3f0f2c8 <strlen>
 3f0bd78:	e2843001 	add	r3, r4, #1	; 0x1
 3f0bd7c:	e0834000 	add	r4, r3, r0
 3f0bd80:	e51b3030 	ldr	r3, [r11, -#48]
 3f0bd84:	e2855001 	add	r5, r5, #1	; 0x1
 3f0bd88:	e1550003 	cmp	r5, r3
 3f0bd8c:	bafffff7 	blt	3f0bd70 <_do_setenv+0x26c>
	}
	if (len > (&env_data[ENV_SIZE]-env)) {
 3f0bd90:	e2463dff 	sub	r3, r6, #16320	; 0x3fc0
 3f0bd94:	e51b2038 	ldr	r2, [r11, -#56]
 3f0bd98:	e243303c 	sub	r3, r3, #60	; 0x3c
 3f0bd9c:	e0633002 	rsb	r3, r3, r2
 3f0bda0:	e1540003 	cmp	r4, r3
 3f0bda4:	da000004 	ble	3f0bdbc <_do_setenv+0x2b8>
		printf ("## Error: environment overflow, \"%s\" deleted\n", name);
 3f0bda8:	e59f01e0 	ldr	r0, [pc, #1e0]	; 3f0bf90 <_do_setenv+0x48c>
 3f0bdac:	e1a0100a 	mov	r1, r10
 3f0bdb0:	eb0002a3 	bl	3f0c844 <printf>
		return 1;
 3f0bdb4:	e3a00001 	mov	r0, #1	; 0x1
 3f0bdb8:	ea000082 	b	3f0bfc8 <_do_setenv+0x4c4>
	}
	while ((*env = *name++) != '\0')
 3f0bdbc:	e4da3001 	ldrb	r3, [r10], #1
 3f0bdc0:	e31300ff 	tst	r3, #255	; 0xff
 3f0bdc4:	e5c63000 	strb	r3, [r6]
 3f0bdc8:	0a000003 	beq	3f0bddc <_do_setenv+0x2d8>
		env++;
 3f0bdcc:	e4da3001 	ldrb	r3, [r10], #1
 3f0bdd0:	e31300ff 	tst	r3, #255	; 0xff
 3f0bdd4:	e5e63001 	strb	r3, [r6, #1]!
 3f0bdd8:	1afffffb 	bne	3f0bdcc <_do_setenv+0x2c8>
	for (i=2; i<argc; ++i) {
 3f0bddc:	e51b3030 	ldr	r3, [r11, -#48]
 3f0bde0:	e3a05002 	mov	r5, #2	; 0x2
 3f0bde4:	e1550003 	cmp	r5, r3
 3f0bde8:	aa00000c 	bge	3f0be20 <_do_setenv+0x31c>
		char *val = argv[i];

		*env = (i==2) ? '=' : ' ';
 3f0bdec:	e3550002 	cmp	r5, #2	; 0x2
 3f0bdf0:	e7972105 	ldr	r2, [r7, r5, lsl #2]
 3f0bdf4:	e3a03020 	mov	r3, #32	; 0x20
 3f0bdf8:	03a0303d 	moveq	r3, #61	; 0x3d
 3f0bdfc:	e5c63000 	strb	r3, [r6]
		while ((*++env = *val++) != '\0')
 3f0be00:	e4d23001 	ldrb	r3, [r2], #1
 3f0be04:	e31300ff 	tst	r3, #255	; 0xff
 3f0be08:	e5e63001 	strb	r3, [r6, #1]!
 3f0be0c:	1afffffb 	bne	3f0be00 <_do_setenv+0x2fc>
 3f0be10:	e51b2030 	ldr	r2, [r11, -#48]
 3f0be14:	e2855001 	add	r5, r5, #1	; 0x1
 3f0be18:	e1550002 	cmp	r5, r2
 3f0be1c:	bafffff2 	blt	3f0bdec <_do_setenv+0x2e8>
			;
	}

	/* end is marked with double '\0' */
	*++env = '\0';
 3f0be20:	e3a05000 	mov	r5, #0	; 0x0
 3f0be24:	e5c65001 	strb	r5, [r6, #1]

	/* Update CRC */
	env_crc_update ();
 3f0be28:	eb0007f8 	bl	3f0de10 <env_crc_update>

	/*
	 * Some variables should be updated when the corresponding
	 * entry in the enviornment is changed
	 */

	if (strcmp(argv[1],"ethaddr") == 0) {
 3f0be2c:	e5970004 	ldr	r0, [r7, #4]
 3f0be30:	e59f115c 	ldr	r1, [pc, #15c]	; 3f0bf94 <_do_setenv+0x490>
 3f0be34:	eb000cdf 	bl	3f0f1b8 <strcmp>
 3f0be38:	e3500000 	cmp	r0, #0	; 0x0
 3f0be3c:	1a000017 	bne	3f0bea0 <_do_setenv+0x39c>
		char *s = argv[2];	/* always use only one arg */
		char *e;
		for (i=0; i<6; ++i) {
 3f0be40:	e1a05000 	mov	r5, r0
 3f0be44:	e5974008 	ldr	r4, [r7, #8]
			bd->bi_enetaddr[i] = s ? simple_strtoul(s, &e, 16) : 0;
 3f0be48:	e51b3034 	ldr	r3, [r11, -#52]
 3f0be4c:	e3540000 	cmp	r4, #0	; 0x0
 3f0be50:	e2836008 	add	r6, r3, #8	; 0x8
 3f0be54:	0a000005 	beq	3f0be70 <_do_setenv+0x36c>
 3f0be58:	e1a00004 	mov	r0, r4
 3f0be5c:	e24b1028 	sub	r1, r11, #40	; 0x28
 3f0be60:	e3a02010 	mov	r2, #16	; 0x10
 3f0be64:	eb000e36 	bl	3f0f744 <simple_strtoul>
 3f0be68:	e7c60005 	strb	r0, [r6, r5]
 3f0be6c:	ea000000 	b	3f0be74 <_do_setenv+0x370>
 3f0be70:	e7c64005 	strb	r4, [r6, r5]
			if (s) s = (*e) ? e+1 : e;
 3f0be74:	e3540000 	cmp	r4, #0	; 0x0
 3f0be78:	0a000004 	beq	3f0be90 <_do_setenv+0x38c>
 3f0be7c:	e51b2028 	ldr	r2, [r11, -#40]
 3f0be80:	e5d23000 	ldrb	r3, [r2]
 3f0be84:	e3530000 	cmp	r3, #0	; 0x0
 3f0be88:	01a04002 	moveq	r4, r2
 3f0be8c:	12824001 	addne	r4, r2, #1	; 0x1
 3f0be90:	e2855001 	add	r5, r5, #1	; 0x1
 3f0be94:	e3550005 	cmp	r5, #5	; 0x5
 3f0be98:	daffffea 	ble	3f0be48 <_do_setenv+0x344>
		}
#ifdef CONFIG_NET_MULTI
		eth_set_enetaddr(0, argv[2]);
#endif
		return 0;
 3f0be9c:	ea000048 	b	3f0bfc4 <_do_setenv+0x4c0>
	}

	if (strcmp(argv[1],"ipaddr") == 0) {
 3f0bea0:	e5970004 	ldr	r0, [r7, #4]
 3f0bea4:	e59f10ec 	ldr	r1, [pc, #ec]	; 3f0bf98 <_do_setenv+0x494>
 3f0bea8:	eb000cc2 	bl	3f0f1b8 <strcmp>
 3f0beac:	e3500000 	cmp	r0, #0	; 0x0
 3f0beb0:	1a000021 	bne	3f0bf3c <_do_setenv+0x438>
		char *s = argv[2];	/* always use only one arg */
 3f0beb4:	e5974008 	ldr	r4, [r7, #8]
		char *e;
		unsigned long addr;
		bd->bi_ip_addr = 0;
		for (addr=0, i=0; i<4; ++i) {
 3f0beb8:	e1a06000 	mov	r6, r0
 3f0bebc:	e51b2034 	ldr	r2, [r11, -#52]
 3f0bec0:	e3a05003 	mov	r5, #3	; 0x3
 3f0bec4:	e5820004 	str	r0, [r2, #4]
			ulong val = s ? simple_strtoul(s, &e, 10) : 0;
 3f0bec8:	e3540000 	cmp	r4, #0	; 0x0
 3f0becc:	0a000004 	beq	3f0bee4 <_do_setenv+0x3e0>
 3f0bed0:	e1a00004 	mov	r0, r4
 3f0bed4:	e24b102c 	sub	r1, r11, #44	; 0x2c
 3f0bed8:	e3a0200a 	mov	r2, #10	; 0xa
 3f0bedc:	eb000e18 	bl	3f0f744 <simple_strtoul>
 3f0bee0:	ea000000 	b	3f0bee8 <_do_setenv+0x3e4>
 3f0bee4:	e1a00004 	mov	r0, r4
			addr <<= 8;
			addr  |= (val & 0xFF);
 3f0bee8:	e20030ff 	and	r3, r0, #255	; 0xff
 3f0beec:	e1836406 	orr	r6, r3, r6, lsl #8
			if (s) s = (*e) ? e+1 : e;
 3f0bef0:	e3540000 	cmp	r4, #0	; 0x0
 3f0bef4:	0a000004 	beq	3f0bf0c <_do_setenv+0x408>
 3f0bef8:	e51b202c 	ldr	r2, [r11, -#44]
 3f0befc:	e5d23000 	ldrb	r3, [r2]
 3f0bf00:	e3530000 	cmp	r3, #0	; 0x0
 3f0bf04:	01a04002 	moveq	r4, r2
 3f0bf08:	12824001 	addne	r4, r2, #1	; 0x1
 3f0bf0c:	e2555001 	subs	r5, r5, #1	; 0x1
 3f0bf10:	5affffec 	bpl	3f0bec8 <_do_setenv+0x3c4>
		}
		bd->bi_ip_addr = htonl(addr);
		return 0;
 3f0bf14:	e3a00000 	mov	r0, #0	; 0x0
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f0bf18:	e2063cff 	and	r3, r6, #65280	; 0xff00
 3f0bf1c:	e1a03403 	mov	r3, r3, lsl #8
 3f0bf20:	e1833c06 	orr	r3, r3, r6, lsl #24
 3f0bf24:	e20628ff 	and	r2, r6, #16711680	; 0xff0000
 3f0bf28:	e1833422 	orr	r3, r3, r2, lsr #8
 3f0bf2c:	e51b2034 	ldr	r2, [r11, -#52]
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f0bf30:	e1833c26 	orr	r3, r3, r6, lsr #24
 3f0bf34:	e5823004 	str	r3, [r2, #4]
 3f0bf38:	ea000022 	b	3f0bfc8 <_do_setenv+0x4c4>
	}
	if (strcmp(argv[1],"loadaddr") == 0) {
 3f0bf3c:	e5970004 	ldr	r0, [r7, #4]
 3f0bf40:	e59f1054 	ldr	r1, [pc, #54]	; 3f0bf9c <_do_setenv+0x498>
 3f0bf44:	eb000c9b 	bl	3f0f1b8 <strcmp>
 3f0bf48:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0bf4c:	1a000014 	bne	3f0bfa4 <_do_setenv+0x4a0>
		load_addr = simple_strtoul(argv[2], NULL, 16);
 3f0bf50:	e1a01004 	mov	r1, r4
 3f0bf54:	e5970008 	ldr	r0, [r7, #8]
 3f0bf58:	e3a02010 	mov	r2, #16	; 0x10
 3f0bf5c:	eb000df8 	bl	3f0f744 <simple_strtoul>
 3f0bf60:	e59f3038 	ldr	r3, [pc, #38]	; 3f0bfa0 <_do_setenv+0x49c>
 3f0bf64:	e5830000 	str	r0, [r3]
		return 0;
 3f0bf68:	ea000015 	b	3f0bfc4 <_do_setenv+0x4c0>
 3f0bf6c:	03f1e848 	mvneqs	r14, #4718592	; 0x480000
 3f0bf70:	03f1e850 	mvneqs	r14, #5242880	; 0x500000
 3f0bf74:	03f1e858 	mvneqs	r14, #5767168	; 0x580000
 3f0bf78:	03f1e860 	mvneqs	r14, #6291456	; 0x600000
 3f0bf7c:	03f1e874 	mvneqs	r14, #7602176	; 0x740000
 3f0bf80:	03f1e7ec 	mvneqs	r14, #61865984	; 0x3b00000
 3f0bf84:	03f1e880 	mvneqs	r14, #8388608	; 0x800000
 3f0bf88:	03f1e8a4 	mvneqs	r14, #10747904	; 0xa40000
 3f0bf8c:	0000c350 	andeq	r12, r0, r0, asr r3
 3f0bf90:	03f1e8d8 	mvneqs	r14, #14155776	; 0xd80000
 3f0bf94:	03f1e908 	mvneqs	r14, #131072	; 0x20000
 3f0bf98:	03f1e910 	mvneqs	r14, #262144	; 0x40000
 3f0bf9c:	03f1e918 	mvneqs	r14, #393216	; 0x60000
 3f0bfa0:	03f205dc 	mvneqs	r0, #922746880	; 0x37000000
	}
#if (CONFIG_COMMANDS & CFG_CMD_NET)
	if (strcmp(argv[1],"bootfile") == 0) {
 3f0bfa4:	e5970004 	ldr	r0, [r7, #4]
 3f0bfa8:	e59f101c 	ldr	r1, [pc, #1c]	; 3f0bfcc <_do_setenv+0x4c8>
 3f0bfac:	eb000c81 	bl	3f0f1b8 <strcmp>
 3f0bfb0:	e2504000 	subs	r4, r0, #0	; 0x0
		copy_filename (BootFile, argv[2], sizeof(BootFile));
 3f0bfb4:	059f0014 	ldreq	r0, [pc, #14]	; 3f0bfd0 <_do_setenv+0x4cc>
 3f0bfb8:	05971008 	ldreq	r1, [r7, #8]
 3f0bfbc:	03a02080 	moveq	r2, #128	; 0x80
 3f0bfc0:	0bffd720 	bleq	3f01c48 <copy_filename>
		return 0;
 3f0bfc4:	e3a00000 	mov	r0, #0	; 0x0
 3f0bfc8:	ea000001 	b	3f0bfd4 <_do_setenv+0x4d0>
 3f0bfcc:	03f1e924 	mvneqs	r14, #589824	; 0x90000
 3f0bfd0:	03f6a6e0 	mvneqs	r10, #234881024	; 0xe000000
	}
#endif	/* CFG_CMD_NET */

#ifdef CONFIG_AMIGAONEG3SE
	if (strcmp(argv[1], "vga_fg_color") == 0 ||
	    strcmp(argv[1], "vga_bg_color") == 0 ) {
		extern void video_set_color(unsigned char attr);
		extern unsigned char video_get_attr(void);

		video_set_color(video_get_attr());
		return 0;
	}
#endif	/* CONFIG_AMIGAONEG3SE */

	return 0;
}
 3f0bfd4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0bfd8 <setenv>:
 3f0bfd8:	e1a0c00d 	mov	r12, r13
 3f0bfdc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0bfe0:	e24cb004 	sub	r11, r12, #4	; 0x4

void setenv (char *varname, char *varvalue)
{
	char *argv[4] = { "setenv", varname, varvalue, NULL };
 3f0bfe4:	e59f3024 	ldr	r3, [pc, #24]	; 3f0c010 <setenv+0x38>
 3f0bfe8:	e24dd010 	sub	r13, r13, #16	; 0x10
 3f0bfec:	e50b0018 	str	r0, [r11, -#24]
	_do_setenv (0, 3, argv);
 3f0bff0:	e24b201c 	sub	r2, r11, #28	; 0x1c
 3f0bff4:	e50b1014 	str	r1, [r11, -#20]
 3f0bff8:	e3a00000 	mov	r0, #0	; 0x0
 3f0bffc:	e50b0010 	str	r0, [r11, -#16]
 3f0c000:	e3a01003 	mov	r1, #3	; 0x3
 3f0c004:	e50b301c 	str	r3, [r11, -#28]
 3f0c008:	ebfffebd 	bl	3f0bb04 <_do_setenv>
 3f0c00c:	ea000000 	b	3f0c014 <setenv+0x3c>
 3f0c010:	03f1e930 	mvneqs	r14, #786432	; 0xc0000
}
 3f0c014:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0c018 <do_setenv>:
 3f0c018:	e1a0c00d 	mov	r12, r13
 3f0c01c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0c020:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_setenv ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f0c024:	e1a0c000 	mov	r12, r0
 3f0c028:	e1a00001 	mov	r0, r1
 3f0c02c:	e1a01002 	mov	r1, r2
 3f0c030:	e1a02003 	mov	r2, r3
	if (argc < 2) {
 3f0c034:	e3510001 	cmp	r1, #1	; 0x1
 3f0c038:	da000001 	ble	3f0c044 <do_setenv+0x2c>
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
	}

	return _do_setenv (flag, argc, argv);
 3f0c03c:	ebfffeb0 	bl	3f0bb04 <_do_setenv>
 3f0c040:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c044:	e59f000c 	ldr	r0, [pc, #c]	; 3f0c058 <do_setenv+0x40>
 3f0c048:	e59c1010 	ldr	r1, [r12, #16]
 3f0c04c:	eb0001fc 	bl	3f0c844 <printf>
 3f0c050:	e3a00001 	mov	r0, #1	; 0x1
 3f0c054:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c058:	03f1e938 	mvneqs	r14, #917504	; 0xe0000

03f0c05c <getenv>:
 3f0c05c:	e1a0c00d 	mov	r12, r13
 3f0c060:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f0c064:	e24cb004 	sub	r11, r12, #4	; 0x4
}

/************************************************************************
 * Prompt for environment variable
 */

#if (CONFIG_COMMANDS & CFG_CMD_ASKENV)
int do_askenv ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	extern char console_buffer[CFG_CBSIZE];
	char message[CFG_CBSIZE];
	int size = CFG_CBSIZE - 1;
	int len;
	char *local_args[4];

	local_args[0] = argv[0];
	local_args[1] = argv[1];
	local_args[2] = NULL;
	local_args[3] = NULL;

	if (argc < 2) {
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;
	}
	/* Check the syntax */
	switch (argc) {
	case 1:
		printf ("Usage:\n%s\n", cmdtp->usage);
		return 1;

	case 2:		/* askenv envname */
		sprintf (message, "Please enter '%s':", argv[1]);
		break;

	case 3:		/* askenv envname size */
		sprintf (message, "Please enter '%s':", argv[1]);
		size = simple_strtoul (argv[2], NULL, 10);
		break;

	default:	/* askenv envname message1 ... messagen size */
	    {
		int i;
		int pos = 0;

		for (i = 2; i < argc - 1; i++) {
			if (pos) {
				message[pos++] = ' ';
			}
			strcpy (message+pos, argv[i]);
			pos += strlen(argv[i]);
		}
		message[pos] = '\0';
		size = simple_strtoul (argv[argc - 1], NULL, 10);
	    }
		break;
	}

	if (size >= CFG_CBSIZE)
		size = CFG_CBSIZE - 1;

	if (size <= 0)
		return 1;

	/* prompt for input */
	len = readline (message);

	if (size < len)
		console_buffer[size] = '\0';

	len = 2;
	if (console_buffer[0] != '\0') {
		local_args[2] = console_buffer;
		len = 3;
	}

	/* Continue calling setenv code */
	return _do_setenv (flag, len, local_args);
}
#endif	/* CFG_CMD_ASKENV */

/************************************************************************
 * Look up variable from environment,
 * return address of storage for that variable,
 * or NULL if not found
 */

char *getenv (uchar *name)
{
	int i, nxt;

	WATCHDOG_RESET();

	for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
 3f0c068:	e3a05000 	mov	r5, #0	; 0x0
 3f0c06c:	e1a07000 	mov	r7, r0
 3f0c070:	ea000012 	b	3f0c0c0 <getenv+0x64>
		int val;

		for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) {
 3f0c074:	e1a04005 	mov	r4, r5
 3f0c078:	ea000003 	b	3f0c08c <getenv+0x30>
			if (nxt >= CFG_ENV_SIZE) {
 3f0c07c:	e3540901 	cmp	r4, #16384	; 0x4000
				return (NULL);
 3f0c080:	a3a00000 	movge	r0, #0	; 0x0
 3f0c084:	a91ba8f0 	ldmgedb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0c088:	e2844001 	add	r4, r4, #1	; 0x1
 3f0c08c:	e1a00004 	mov	r0, r4
 3f0c090:	e1a0e00f 	mov	r14, r15
 3f0c094:	e596f000 	ldr	r15, [r6]
 3f0c098:	e31000ff 	tst	r0, #255	; 0xff
 3f0c09c:	1afffff6 	bne	3f0c07c <getenv+0x20>
			}
		}
		if ((val=envmatch(name, i)) < 0)
 3f0c0a0:	e1a00007 	mov	r0, r7
 3f0c0a4:	e1a01005 	mov	r1, r5
 3f0c0a8:	eb000050 	bl	3f0c1f0 <envmatch>
 3f0c0ac:	e3500000 	cmp	r0, #0	; 0x0
 3f0c0b0:	ba000001 	blt	3f0c0bc <getenv+0x60>
			continue;
		return (env_get_addr(val));
 3f0c0b4:	eb00077c 	bl	3f0deac <env_get_addr>
 3f0c0b8:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0c0bc:	e2845001 	add	r5, r4, #1	; 0x1
 3f0c0c0:	e59f6014 	ldr	r6, [pc, #14]	; 3f0c0dc <getenv+0x80>
 3f0c0c4:	e1a00005 	mov	r0, r5
 3f0c0c8:	e1a0e00f 	mov	r14, r15
 3f0c0cc:	e596f000 	ldr	r15, [r6]
 3f0c0d0:	e21000ff 	ands	r0, r0, #255	; 0xff
 3f0c0d4:	1affffe6 	bne	3f0c074 <getenv+0x18>
	}

	return (NULL);
}
 3f0c0d8:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0c0dc:	03f20ccc 	mvneqs	r0, #52224	; 0xcc00

03f0c0e0 <getenv_r>:
 3f0c0e0:	e1a0c00d 	mov	r12, r13
 3f0c0e4:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0c0e8:	e24cb004 	sub	r11, r12, #4	; 0x4

int getenv_r (uchar *name, uchar *buf, unsigned len)
{
	int i, nxt;

	for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
 3f0c0ec:	e3a05000 	mov	r5, #0	; 0x0
 3f0c0f0:	e1a0a000 	mov	r10, r0
 3f0c0f4:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f0c0f8:	e50b1028 	str	r1, [r11, -#40]
 3f0c0fc:	e1a09002 	mov	r9, r2
 3f0c100:	ea000023 	b	3f0c194 <getenv_r+0xb4>
		int val, n;

		for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) {
 3f0c104:	e1a04005 	mov	r4, r5
 3f0c108:	ea000002 	b	3f0c118 <getenv_r+0x38>
			if (nxt >= CFG_ENV_SIZE) {
 3f0c10c:	e3540901 	cmp	r4, #16384	; 0x4000
 3f0c110:	aa000025 	bge	3f0c1ac <getenv_r+0xcc>
 3f0c114:	e2844001 	add	r4, r4, #1	; 0x1
 3f0c118:	e1a00004 	mov	r0, r4
 3f0c11c:	e1a0e00f 	mov	r14, r15
 3f0c120:	e597f000 	ldr	r15, [r7]
 3f0c124:	e21060ff 	ands	r6, r0, #255	; 0xff
 3f0c128:	1afffff7 	bne	3f0c10c <getenv_r+0x2c>
				return (-1);
			}
		}
		if ((val=envmatch(name, i)) < 0)
 3f0c12c:	e1a0000a 	mov	r0, r10
 3f0c130:	e1a01005 	mov	r1, r5
 3f0c134:	eb00002d 	bl	3f0c1f0 <envmatch>
 3f0c138:	e2505000 	subs	r5, r0, #0	; 0x0
 3f0c13c:	ba000013 	blt	3f0c190 <getenv_r+0xb0>
			continue;
		/* found; copy out */
		n = 0;
 3f0c140:	e1a04006 	mov	r4, r6
		while ((len > n++) && (*buf++ = env_get_char(val++)) != '\0')
 3f0c144:	e1a03004 	mov	r3, r4
 3f0c148:	e2844001 	add	r4, r4, #1	; 0x1
 3f0c14c:	e1590003 	cmp	r9, r3
 3f0c150:	9a000008 	bls	3f0c178 <getenv_r+0x98>
 3f0c154:	e1a00005 	mov	r0, r5
 3f0c158:	e1a0e00f 	mov	r14, r15
 3f0c15c:	e597f000 	ldr	r15, [r7]
 3f0c160:	e51b2028 	ldr	r2, [r11, -#40]
 3f0c164:	e2855001 	add	r5, r5, #1	; 0x1
 3f0c168:	e4c20001 	strb	r0, [r2], #1
 3f0c16c:	e31000ff 	tst	r0, #255	; 0xff
 3f0c170:	e50b2028 	str	r2, [r11, -#40]
 3f0c174:	1afffff2 	bne	3f0c144 <getenv_r+0x64>
			;
		if (len == n)
 3f0c178:	e1590004 	cmp	r9, r4
			*buf = '\0';
 3f0c17c:	051b2028 	ldreq	r2, [r11, -#40]
 3f0c180:	03a03000 	moveq	r3, #0	; 0x0
 3f0c184:	05c23000 	streqb	r3, [r2]
		return (n);
 3f0c188:	e1a00004 	mov	r0, r4
 3f0c18c:	ea000007 	b	3f0c1b0 <getenv_r+0xd0>
 3f0c190:	e2845001 	add	r5, r4, #1	; 0x1
 3f0c194:	e59f7018 	ldr	r7, [pc, #18]	; 3f0c1b4 <getenv_r+0xd4>
 3f0c198:	e1a00005 	mov	r0, r5
 3f0c19c:	e1a0e00f 	mov	r14, r15
 3f0c1a0:	e597f000 	ldr	r15, [r7]
 3f0c1a4:	e31000ff 	tst	r0, #255	; 0xff
 3f0c1a8:	1affffd5 	bne	3f0c104 <getenv_r+0x24>
	}
	return (-1);
 3f0c1ac:	e3e00000 	mvn	r0, #0	; 0x0
 3f0c1b0:	ea000000 	b	3f0c1b8 <getenv_r+0xd8>
 3f0c1b4:	03f20ccc 	mvneqs	r0, #52224	; 0xcc00
}
 3f0c1b8:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0c1bc <do_saveenv>:
 3f0c1bc:	e1a0c00d 	mov	r12, r13
 3f0c1c0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

#if defined(CFG_ENV_IS_IN_NVRAM) || defined(CFG_ENV_IS_IN_EEPROM) || \
    ((CONFIG_COMMANDS & (CFG_CMD_ENV|CFG_CMD_FLASH)) == \
      (CFG_CMD_ENV|CFG_CMD_FLASH))
int do_saveenv (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	extern char * env_name_spec;

	printf ("Saving Environment to %s...\n", env_name_spec);
 3f0c1c4:	e59f301c 	ldr	r3, [pc, #1c]	; 3f0c1e8 <do_saveenv+0x2c>
 3f0c1c8:	e59f001c 	ldr	r0, [pc, #1c]	; 3f0c1ec <do_saveenv+0x30>
 3f0c1cc:	e5931000 	ldr	r1, [r3]
 3f0c1d0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0c1d4:	eb00019a 	bl	3f0c844 <printf>

	return (saveenv() ? 1 : 0);
 3f0c1d8:	eb000791 	bl	3f0e024 <saveenv>
 3f0c1dc:	e2500000 	subs	r0, r0, #0	; 0x0
 3f0c1e0:	13a00001 	movne	r0, #1	; 0x1
}
 3f0c1e4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c1e8:	03f20dc8 	mvneqs	r0, #12800	; 0x3200
 3f0c1ec:	03f1e944 	mvneqs	r14, #1114112	; 0x110000

03f0c1f0 <envmatch>:
 3f0c1f0:	e1a0c00d 	mov	r12, r13
 3f0c1f4:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f0c1f8:	e24cb004 	sub	r11, r12, #4	; 0x4


#endif


/************************************************************************
 * Match a name / name=value pair
 *
 * s1 is either a simple 'name', or a 'name=value' pair.
 * i2 is the environment index for a 'name2=value2' pair.
 * If the names match, return the index for the value2, else NULL.
 */

static int
envmatch (uchar *s1, int i2)
{
 3f0c1fc:	e1a05000 	mov	r5, r0
 3f0c200:	e1a04001 	mov	r4, r1

	while (*s1 == env_get_char(i2++))
 3f0c204:	ea000003 	b	3f0c218 <envmatch+0x28>
		if (*s1++ == '=')
 3f0c208:	e2855001 	add	r5, r5, #1	; 0x1
 3f0c20c:	e353003d 	cmp	r3, #61	; 0x3d
			return(i2);
 3f0c210:	01a00004 	moveq	r0, r4
 3f0c214:	091ba870 	ldmeqdb	r11, {r4, r5, r6, r11, r13, r15}
 3f0c218:	e1a00004 	mov	r0, r4
 3f0c21c:	e59f6044 	ldr	r6, [pc, #44]	; 3f0c268 <envmatch+0x78>
 3f0c220:	e2844001 	add	r4, r4, #1	; 0x1
 3f0c224:	e1a0e00f 	mov	r14, r15
 3f0c228:	e596f000 	ldr	r15, [r6]
 3f0c22c:	e5d53000 	ldrb	r3, [r5]
 3f0c230:	e20000ff 	and	r0, r0, #255	; 0xff
 3f0c234:	e1530000 	cmp	r3, r0
 3f0c238:	0afffff2 	beq	3f0c208 <envmatch+0x18>
	if (*s1 == '\0' && env_get_char(i2-1) == '=')
 3f0c23c:	e3530000 	cmp	r3, #0	; 0x0
 3f0c240:	1a000006 	bne	3f0c260 <envmatch+0x70>
 3f0c244:	e2440001 	sub	r0, r4, #1	; 0x1
 3f0c248:	e1a0e00f 	mov	r14, r15
 3f0c24c:	e596f000 	ldr	r15, [r6]
 3f0c250:	e20000ff 	and	r0, r0, #255	; 0xff
 3f0c254:	e350003d 	cmp	r0, #61	; 0x3d
		return(i2);
 3f0c258:	e1a00004 	mov	r0, r4
 3f0c25c:	091ba870 	ldmeqdb	r11, {r4, r5, r6, r11, r13, r15}
	return(-1);
 3f0c260:	e3e00000 	mvn	r0, #0	; 0x0
 3f0c264:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f0c268:	03f20ccc 	mvneqs	r0, #52224	; 0xcc00

03f0c26c <do_version>:
 3f0c26c:	e1a0c00d 	mov	r12, r13
 3f0c270:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
int
do_version (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	extern char version_string[];
	printf ("\n%s\n", version_string);
 3f0c274:	e59f0010 	ldr	r0, [pc, #10]	; 3f0c28c <do_version+0x20>
 3f0c278:	e59f1010 	ldr	r1, [pc, #10]	; 3f0c290 <do_version+0x24>
 3f0c27c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0c280:	eb00016f 	bl	3f0c844 <printf>
	return 0;
 3f0c284:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0c288:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c28c:	03f1eb78 	mvneqs	r14, #122880	; 0x1e000
 3f0c290:	03f1aa0c 	mvneqs	r10, #49152	; 0xc000

03f0c294 <do_echo>:
 3f0c294:	e1a0c00d 	mov	r12, r13
 3f0c298:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f0c29c:	e24cb004 	sub	r11, r12, #4	; 0x4

U_BOOT_CMD(
	version,	1,		1,	do_version,
 	"version - print monitor version\n",
	NULL
);

int
do_echo (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	int i, putnl = 1;
 3f0c2a0:	e3a06001 	mov	r6, #1	; 0x1

	for (i = 1; i < argc; i++) {
 3f0c2a4:	e1a05006 	mov	r5, r6
 3f0c2a8:	e1a07002 	mov	r7, r2
 3f0c2ac:	e1560007 	cmp	r6, r7
 3f0c2b0:	e1a0a003 	mov	r10, r3
 3f0c2b4:	aa000012 	bge	3f0c304 <do_echo+0x70>
		char *p = argv[i], c;

		if (i > 1)
 3f0c2b8:	e3550001 	cmp	r5, #1	; 0x1
 3f0c2bc:	e79a4105 	ldr	r4, [r10, r5, lsl #2]
 3f0c2c0:	da000009 	ble	3f0c2ec <do_echo+0x58>
			putc(' ');
 3f0c2c4:	e3a00020 	mov	r0, #32	; 0x20
		while ((c = *p++) != '\0') {
 3f0c2c8:	ea000006 	b	3f0c2e8 <do_echo+0x54>
			if (c == '\\' && *p == 'c') {
 3f0c2cc:	e350005c 	cmp	r0, #92	; 0x5c
 3f0c2d0:	1a000004 	bne	3f0c2e8 <do_echo+0x54>
 3f0c2d4:	e5d43000 	ldrb	r3, [r4]
 3f0c2d8:	e3530063 	cmp	r3, #99	; 0x63
				putnl = 0;
 3f0c2dc:	03a06000 	moveq	r6, #0	; 0x0
				p++;
 3f0c2e0:	02844001 	addeq	r4, r4, #1	; 0x1
			} else {
 3f0c2e4:	0a000000 	beq	3f0c2ec <do_echo+0x58>
				putc(c);
 3f0c2e8:	eb00013b 	bl	3f0c7dc <putc>
			}
		}
 3f0c2ec:	e4d40001 	ldrb	r0, [r4], #1
 3f0c2f0:	e3500000 	cmp	r0, #0	; 0x0
 3f0c2f4:	1afffff4 	bne	3f0c2cc <do_echo+0x38>
 3f0c2f8:	e2855001 	add	r5, r5, #1	; 0x1
 3f0c2fc:	e1550007 	cmp	r5, r7
 3f0c300:	baffffec 	blt	3f0c2b8 <do_echo+0x24>
	}

	if (putnl)
 3f0c304:	e3560000 	cmp	r6, #0	; 0x0
 3f0c308:	0a000001 	beq	3f0c314 <do_echo+0x80>
		putc('\n');
 3f0c30c:	e3a0000a 	mov	r0, #10	; 0xa
 3f0c310:	eb000131 	bl	3f0c7dc <putc>
	return 0;
 3f0c314:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0c318:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f0c31c <do_help>:
 3f0c31c:	e1a0c00d 	mov	r12, r13
 3f0c320:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0c324:	e24cb004 	sub	r11, r12, #4	; 0x4

U_BOOT_CMD(
	echo,	CFG_MAXARGS,	1,	do_echo,
 	"echo    - echo args to console\n",
 	"[args..]\n"
	"    - echo args to console; \\c suppresses newline\n"
);

/*
 * Use puts() instead of printf() to avoid printf buffer overflow
 * for long help messages
 */
int do_help (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
{
	int i;
	int rcode = 0;
 3f0c328:	e3a07000 	mov	r7, #0	; 0x0
 3f0c32c:	e1a05002 	mov	r5, r2

	if (argc == 1) {	/*show list of commands */
 3f0c330:	e3550001 	cmp	r5, #1	; 0x1
 3f0c334:	e1a0a003 	mov	r10, r3
 3f0c338:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f0c33c:	1a000045 	bne	3f0c458 <do_help+0x13c>

		int cmd_items = &__u_boot_cmd_end -
 3f0c340:	e59f2168 	ldr	r2, [pc, #168]	; 3f0c4b0 <do_help+0x194>
 3f0c344:	e59f1168 	ldr	r1, [pc, #168]	; 3f0c4b4 <do_help+0x198>
				&__u_boot_cmd_start;	/* pointer arith! */
		cmd_tbl_t *cmd_array[cmd_items];
		int i, j, swaps;

		/* Make array of commands from .uboot_cmd section */
		cmdtp = &__u_boot_cmd_start;
		for (i = 0; i < cmd_items; i++) {
 3f0c348:	e1a06007 	mov	r6, r7
 3f0c34c:	e0612002 	rsb	r2, r1, r2
 3f0c350:	e0823102 	add	r3, r2, r2, lsl #2
 3f0c354:	e0833203 	add	r3, r3, r3, lsl #4
 3f0c358:	e0833403 	add	r3, r3, r3, lsl #8
 3f0c35c:	e0833803 	add	r3, r3, r3, lsl #16
 3f0c360:	e0822083 	add	r2, r2, r3, lsl #1
 3f0c364:	e1a091c2 	mov	r9, r2, asr #3
 3f0c368:	e1a03289 	mov	r3, r9, lsl #5
 3f0c36c:	e04dd1a3 	sub	r13, r13, r3, lsr #3
 3f0c370:	e1a04001 	mov	r4, r1
 3f0c374:	e1560009 	cmp	r6, r9
 3f0c378:	e1a0700d 	mov	r7, r13
 3f0c37c:	aa000004 	bge	3f0c394 <do_help+0x78>
			cmd_array[i] = cmdtp++;
 3f0c380:	e7874106 	str	r4, [r7, r6, lsl #2]
 3f0c384:	e2844018 	add	r4, r4, #24	; 0x18
 3f0c388:	e2866001 	add	r6, r6, #1	; 0x1
 3f0c38c:	e1560009 	cmp	r6, r9
 3f0c390:	bafffffa 	blt	3f0c380 <do_help+0x64>
		}

		/* Sort command list (trivial bubble sort) */
		for (i = cmd_items - 1; i > 0; --i) {
 3f0c394:	e2496001 	sub	r6, r9, #1	; 0x1
 3f0c398:	e3560000 	cmp	r6, #0	; 0x0
 3f0c39c:	da00001a 	ble	3f0c40c <do_help+0xf0>
			swaps = 0;
 3f0c3a0:	e3a0a000 	mov	r10, #0	; 0x0
			for (j = 0; j < i; ++j) {
 3f0c3a4:	e1a0200a 	mov	r2, r10
 3f0c3a8:	e15a0006 	cmp	r10, r6
 3f0c3ac:	aa000011 	bge	3f0c3f8 <do_help+0xdc>
				if (strcmp (cmd_array[j]->name,
 3f0c3b0:	e1a05102 	mov	r5, r2, lsl #2
 3f0c3b4:	e7973005 	ldr	r3, [r7, r5]
 3f0c3b8:	e5930000 	ldr	r0, [r3]
 3f0c3bc:	e2822001 	add	r2, r2, #1	; 0x1
 3f0c3c0:	e50b2028 	str	r2, [r11, -#40]
 3f0c3c4:	e1a04102 	mov	r4, r2, lsl #2
 3f0c3c8:	e7973004 	ldr	r3, [r7, r4]
 3f0c3cc:	e5931000 	ldr	r1, [r3]
 3f0c3d0:	eb000b78 	bl	3f0f1b8 <strcmp>
 3f0c3d4:	e3500000 	cmp	r0, #0	; 0x0
					    cmd_array[j + 1]->name) > 0) {
					cmd_tbl_t *tmp;
					tmp = cmd_array[j];
					cmd_array[j] = cmd_array[j + 1];
 3f0c3d8:	c7973004 	ldrgt	r3, [r7, r4]
 3f0c3dc:	c7972005 	ldrgt	r2, [r7, r5]
 3f0c3e0:	c7873005 	strgt	r3, [r7, r5]
					cmd_array[j + 1] = tmp;
					++swaps;
 3f0c3e4:	c28aa001 	addgt	r10, r10, #1	; 0x1
 3f0c3e8:	c7872004 	strgt	r2, [r7, r4]
 3f0c3ec:	e51b2028 	ldr	r2, [r11, -#40]
 3f0c3f0:	e1520006 	cmp	r2, r6
 3f0c3f4:	baffffed 	blt	3f0c3b0 <do_help+0x94>
				}
			}
			if (!swaps)
 3f0c3f8:	e35a0000 	cmp	r10, #0	; 0x0
 3f0c3fc:	0a000002 	beq	3f0c40c <do_help+0xf0>
 3f0c400:	e2466001 	sub	r6, r6, #1	; 0x1
 3f0c404:	e3560000 	cmp	r6, #0	; 0x0
 3f0c408:	caffffe4 	bgt	3f0c3a0 <do_help+0x84>
				break;
		}

		/* print short help (usage) */
		for (i = 0; i < cmd_items; i++) {
 3f0c40c:	e3a06000 	mov	r6, #0	; 0x0
 3f0c410:	e1560009 	cmp	r6, r9
 3f0c414:	aa00000b 	bge	3f0c448 <do_help+0x12c>
			const char *usage = cmd_array[i]->usage;
 3f0c418:	e7973106 	ldr	r3, [r7, r6, lsl #2]
 3f0c41c:	e5934010 	ldr	r4, [r3, #16]

			/* allow user abort */
			if (ctrlc ())
 3f0c420:	eb000121 	bl	3f0c8ac <ctrlc>
 3f0c424:	e3500000 	cmp	r0, #0	; 0x0
 3f0c428:	1a000008 	bne	3f0c450 <do_help+0x134>
				return 1;
			if (usage == NULL)
 3f0c42c:	e3540000 	cmp	r4, #0	; 0x0
 3f0c430:	0a000001 	beq	3f0c43c <do_help+0x120>
				continue;
			puts (usage);
 3f0c434:	e1a00004 	mov	r0, r4
 3f0c438:	eb0000f4 	bl	3f0c810 <puts>
 3f0c43c:	e2866001 	add	r6, r6, #1	; 0x1
 3f0c440:	e1560009 	cmp	r6, r9
 3f0c444:	bafffff3 	blt	3f0c418 <do_help+0xfc>
		}
		return 0;
 3f0c448:	e3a00000 	mov	r0, #0	; 0x0
 3f0c44c:	ea000022 	b	3f0c4dc <do_help+0x1c0>
 3f0c450:	e3a00001 	mov	r0, #1	; 0x1
 3f0c454:	ea000020 	b	3f0c4dc <do_help+0x1c0>
	}
	/*
	 * command help (long version)
	 */
	for (i = 1; i < argc; ++i) {
 3f0c458:	e3a06001 	mov	r6, #1	; 0x1
 3f0c45c:	e1560005 	cmp	r6, r5
 3f0c460:	aa00001c 	bge	3f0c4d8 <do_help+0x1bc>
		if ((cmdtp = find_cmd (argv[i])) != NULL) {
 3f0c464:	e79a0106 	ldr	r0, [r10, r6, lsl #2]
 3f0c468:	eb00001e 	bl	3f0c4e8 <find_cmd>
 3f0c46c:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0c470:	0a000011 	beq	3f0c4bc <do_help+0x1a0>
#ifdef	CFG_LONGHELP
			/* found - print (long) help info */
			puts (cmdtp->name);
 3f0c474:	e5940000 	ldr	r0, [r4]
 3f0c478:	eb0000e4 	bl	3f0c810 <puts>
			putc (' ');
 3f0c47c:	e3a00020 	mov	r0, #32	; 0x20
 3f0c480:	eb0000d5 	bl	3f0c7dc <putc>
			if (cmdtp->help) {
 3f0c484:	e5940014 	ldr	r0, [r4, #20]
 3f0c488:	e3500000 	cmp	r0, #0	; 0x0
 3f0c48c:	0a000001 	beq	3f0c498 <do_help+0x17c>
				puts (cmdtp->help);
 3f0c490:	eb0000de 	bl	3f0c810 <puts>
			} else {
 3f0c494:	ea000002 	b	3f0c4a4 <do_help+0x188>
				puts ("- No help available.\n");
 3f0c498:	e59f0018 	ldr	r0, [pc, #18]	; 3f0c4b8 <do_help+0x19c>
				rcode = 1;
 3f0c49c:	e3a07001 	mov	r7, #1	; 0x1
 3f0c4a0:	eb0000da 	bl	3f0c810 <puts>
			}
			putc ('\n');
 3f0c4a4:	e3a0000a 	mov	r0, #10	; 0xa
 3f0c4a8:	eb0000cb 	bl	3f0c7dc <putc>
#else	/* no long help available */
			if (cmdtp->usage)
				puts (cmdtp->usage);
#endif	/* CFG_LONGHELP */
		} else {
 3f0c4ac:	ea000006 	b	3f0c4cc <do_help+0x1b0>
 3f0c4b0:	03f6a6a0 	mvneqs	r10, #167772160	; 0xa000000
 3f0c4b4:	03f6a1f0 	mvneqs	r10, #60	; 0x3c
 3f0c4b8:	03f1ec10 	mvneqs	r14, #4096	; 0x1000
			printf ("Unknown command '%s' - try 'help'"
 3f0c4bc:	e59f001c 	ldr	r0, [pc, #1c]	; 3f0c4e0 <do_help+0x1c4>
 3f0c4c0:	e79a1106 	ldr	r1, [r10, r6, lsl #2]
				" without arguments for list of all"
				" known commands\n\n", argv[i]
					);
			rcode = 1;
 3f0c4c4:	e3a07001 	mov	r7, #1	; 0x1
 3f0c4c8:	eb0000dd 	bl	3f0c844 <printf>
 3f0c4cc:	e2866001 	add	r6, r6, #1	; 0x1
 3f0c4d0:	e1560005 	cmp	r6, r5
 3f0c4d4:	baffffe2 	blt	3f0c464 <do_help+0x148>
		}
	}
	return rcode;
 3f0c4d8:	e1a00007 	mov	r0, r7
 3f0c4dc:	ea000000 	b	3f0c4e4 <do_help+0x1c8>
 3f0c4e0:	03f1ec28 	mvneqs	r14, #10240	; 0x2800
}
 3f0c4e4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0c4e8 <find_cmd>:
 3f0c4e8:	e1a0c00d 	mov	r12, r13
 3f0c4ec:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0c4f0:	e24cb004 	sub	r11, r12, #4	; 0x4


U_BOOT_CMD(
	help,	CFG_MAXARGS,	1,	do_help,
 	"help    - print online help\n",
 	"[command ...]\n"
 	"    - show help information (for 'command')\n"
 	"'help' prints online help for the monitor commands.\n\n"
 	"Without arguments, it prints a short usage message for all commands.\n\n"
 	"To get detailed help information for specific commands you can type\n"
  "'help' with one or more command names as arguments.\n"
);

/* This do not ust the U_BOOT_CMD macro as ? can't be used in symbol names */
#ifdef  CFG_LONGHELP
cmd_tbl_t __u_boot_cmd_question_mark Struct_Section = {
	"?",	CFG_MAXARGS,	1,	do_help,
 	"?       - alias for 'help'\n",
	NULL
};
#else
cmd_tbl_t __u_boot_cmd_question_mark Struct_Section = {
	"?",	CFG_MAXARGS,	1,	do_help,
 	"?       - alias for 'help'\n"
};
#endif /* CFG_LONGHELP */

/***************************************************************************
 * find command table entry for a command
 */
cmd_tbl_t *find_cmd (const char *cmd)
{
	cmd_tbl_t *cmdtp;
	cmd_tbl_t *cmdtp_temp = &__u_boot_cmd_start;	/*Init value */
	const char *p;
	int len;
	int n_found = 0;
 3f0c4f4:	e3a0a000 	mov	r10, #0	; 0x0
 3f0c4f8:	e1a06000 	mov	r6, r0

	/*
	 * Some commands allow length modifiers (like "cp.b");
	 * compare command name only until first dot.
	 */
	len = ((p = strchr(cmd, '.')) == NULL) ? strlen (cmd) : (p - cmd);
 3f0c4fc:	e3a0102e 	mov	r1, #46	; 0x2e
 3f0c500:	eb000b50 	bl	3f0f248 <strchr>
 3f0c504:	e3500000 	cmp	r0, #0	; 0x0
 3f0c508:	e59f7078 	ldr	r7, [pc, #78]	; 3f0c588 <find_cmd+0xa0>
 3f0c50c:	1a000005 	bne	3f0c528 <find_cmd+0x40>
 3f0c510:	e1a00006 	mov	r0, r6
 3f0c514:	eb000b6b 	bl	3f0f2c8 <strlen>
 3f0c518:	e1a05000 	mov	r5, r0
 3f0c51c:	ea000002 	b	3f0c52c <find_cmd+0x44>

	for (cmdtp = &__u_boot_cmd_start;
	     cmdtp != &__u_boot_cmd_end;
	     cmdtp++) {
		if (strncmp (cmd, cmdtp->name, len) == 0) {
			if (len == strlen (cmdtp->name))
				return cmdtp;	/* full match */
 3f0c520:	e1a00004 	mov	r0, r4
 3f0c524:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f0c528:	e0665000 	rsb	r5, r6, r0
 3f0c52c:	e59f9058 	ldr	r9, [pc, #58]	; 3f0c58c <find_cmd+0xa4>
 3f0c530:	e1a04007 	mov	r4, r7
 3f0c534:	e1570009 	cmp	r7, r9
 3f0c538:	0a00000e 	beq	3f0c578 <find_cmd+0x90>
 3f0c53c:	e1a00006 	mov	r0, r6
 3f0c540:	e5941000 	ldr	r1, [r4]
 3f0c544:	e1a02005 	mov	r2, r5
 3f0c548:	eb000b29 	bl	3f0f1f4 <strncmp>
 3f0c54c:	e3500000 	cmp	r0, #0	; 0x0
 3f0c550:	1a000005 	bne	3f0c56c <find_cmd+0x84>
 3f0c554:	e5940000 	ldr	r0, [r4]
 3f0c558:	eb000b5a 	bl	3f0f2c8 <strlen>
 3f0c55c:	e1550000 	cmp	r5, r0
 3f0c560:	0affffee 	beq	3f0c520 <find_cmd+0x38>

			cmdtp_temp = cmdtp;	/* abbreviated command ? */
 3f0c564:	e1a07004 	mov	r7, r4
			n_found++;
 3f0c568:	e28aa001 	add	r10, r10, #1	; 0x1
 3f0c56c:	e2844018 	add	r4, r4, #24	; 0x18
 3f0c570:	e1540009 	cmp	r4, r9
 3f0c574:	1afffff0 	bne	3f0c53c <find_cmd+0x54>
		}
	}
	if (n_found == 1) {			/* exactly one match */
 3f0c578:	e35a0001 	cmp	r10, #1	; 0x1
 3f0c57c:	01a00007 	moveq	r0, r7
 3f0c580:	13a00000 	movne	r0, #0	; 0x0
		return cmdtp_temp;
	}

	return NULL;	/* not found or ambiguous command */
}
 3f0c584:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f0c588:	03f6a1f0 	mvneqs	r10, #60	; 0x3c
 3f0c58c:	03f6a6a0 	mvneqs	r10, #167772160	; 0xa000000

03f0c590 <console_setfile>:
 3f0c590:	e1a0c00d 	mov	r12, r13
 3f0c594:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0c598:	e24cb004 	sub	r11, r12, #4	; 0x4

static int console_setfile (int file, device_t * dev)
{
	DECLARE_GLOBAL_DATA_PTR;
	int error = 0;
 3f0c59c:	e3a0c000 	mov	r12, #0	; 0x0
 3f0c5a0:	e1a04000 	mov	r4, r0

	if (dev == NULL)
 3f0c5a4:	e2515000 	subs	r5, r1, #0	; 0x0
		return -1;
 3f0c5a8:	03e00000 	mvneq	r0, #0	; 0x0
 3f0c5ac:	091ba830 	ldmeqdb	r11, {r4, r5, r11, r13, r15}

	switch (file) {
 3f0c5b0:	e3540002 	cmp	r4, #2	; 0x2
 3f0c5b4:	ca000020 	bgt	3f0c63c <console_setfile+0xac>
 3f0c5b8:	e3540000 	cmp	r4, #0	; 0x0
 3f0c5bc:	ba00001e 	blt	3f0c63c <console_setfile+0xac>
	case stdin:
	case stdout:
	case stderr:
		/* Start new device */
		if (dev->start) {
 3f0c5c0:	e5953010 	ldr	r3, [r5, #16]
 3f0c5c4:	e3530000 	cmp	r3, #0	; 0x0
 3f0c5c8:	0a000003 	beq	3f0c5dc <console_setfile+0x4c>
			error = dev->start ();
 3f0c5cc:	e1a0e00f 	mov	r14, r15
 3f0c5d0:	e1a0f003 	mov	r15, r3
			/* If it's not started dont use it */
			if (error < 0)
 3f0c5d4:	e250c000 	subs	r12, r0, #0	; 0x0
 3f0c5d8:	ba000018 	blt	3f0c640 <console_setfile+0xb0>
				break;
		}

		/* Assign the new device (leaving the existing one started) */
		stdio_devices[file] = dev;
 3f0c5dc:	e59f3064 	ldr	r3, [pc, #64]	; 3f0c648 <console_setfile+0xb8>

		/*
		 * Update monitor functions
		 * (to use the console stuff by other applications)
		 */
		switch (file) {
 3f0c5e0:	e3540000 	cmp	r4, #0	; 0x0
 3f0c5e4:	e7835104 	str	r5, [r3, r4, lsl #2]
 3f0c5e8:	0a000002 	beq	3f0c5f8 <console_setfile+0x68>
 3f0c5ec:	e3540001 	cmp	r4, #1	; 0x1
 3f0c5f0:	0a000007 	beq	3f0c614 <console_setfile+0x84>
 3f0c5f4:	ea000011 	b	3f0c640 <console_setfile+0xb0>
		case stdin:
			gd->jt[XF_getc] = dev->getc;
 3f0c5f8:	e5982020 	ldr	r2, [r8, #32]
 3f0c5fc:	e5953024 	ldr	r3, [r5, #36]
 3f0c600:	e5823004 	str	r3, [r2, #4]
			gd->jt[XF_tstc] = dev->tstc;
 3f0c604:	e5982020 	ldr	r2, [r8, #32]
 3f0c608:	e5953020 	ldr	r3, [r5, #32]
 3f0c60c:	e5823008 	str	r3, [r2, #8]
			break;
 3f0c610:	ea00000a 	b	3f0c640 <console_setfile+0xb0>
		case stdout:
			gd->jt[XF_putc] = dev->putc;
 3f0c614:	e5982020 	ldr	r2, [r8, #32]
 3f0c618:	e5953018 	ldr	r3, [r5, #24]
 3f0c61c:	e582300c 	str	r3, [r2, #12]
			gd->jt[XF_puts] = dev->puts;
 3f0c620:	e5982020 	ldr	r2, [r8, #32]
 3f0c624:	e595301c 	ldr	r3, [r5, #28]
 3f0c628:	e5823010 	str	r3, [r2, #16]
			gd->jt[XF_printf] = printf;
 3f0c62c:	e59f3018 	ldr	r3, [pc, #18]	; 3f0c64c <console_setfile+0xbc>
 3f0c630:	e5982020 	ldr	r2, [r8, #32]
 3f0c634:	e5823014 	str	r3, [r2, #20]
			break;
		}
		break;
 3f0c638:	ea000000 	b	3f0c640 <console_setfile+0xb0>

	default:		/* Invalid file ID */
		error = -1;
 3f0c63c:	e3e0c000 	mvn	r12, #0	; 0x0
	}
	return error;
 3f0c640:	e1a0000c 	mov	r0, r12
}
 3f0c644:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f0c648:	03f20864 	mvneqs	r0, #6553600	; 0x640000
 3f0c64c:	03f0c844 	mvneqs	r12, #4456448	; 0x440000

03f0c650 <serial_printf>:
 3f0c650:	e1a0c00d 	mov	r12, r13
 3f0c654:	e92d000f 	stmdb	r13!, {r0, r1, r2, r3}
 3f0c658:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f0c65c:	e24cb014 	sub	r11, r12, #20	; 0x14

/** U-Boot INITIAL CONSOLE-NOT COMPATIBLE FUNCTIONS *************************/

void serial_printf (const char *fmt, ...)
{
	va_list args;
	uint i;
	char printbuffer[CFG_PBSIZE];

	va_start (args, fmt);

	/* For this to work, printbuffer must be larger than
	 * anything we ever want to print.
	 */
	i = vsprintf (printbuffer, fmt, args);
 3f0c660:	e24b4f4a 	sub	r4, r11, #296	; 0x128
 3f0c664:	e1a00004 	mov	r0, r4
 3f0c668:	e24ddf46 	sub	r13, r13, #280	; 0x118
 3f0c66c:	e59b1004 	ldr	r1, [r11, #4]
 3f0c670:	e28b2008 	add	r2, r11, #8	; 0x8
 3f0c674:	eb000d34 	bl	3f0fb4c <vsprintf>
	va_end (args);

	serial_puts (printbuffer);
 3f0c678:	e1a00004 	mov	r0, r4
 3f0c67c:	eb002787 	bl	3f164a0 <serial_puts>
}
 3f0c680:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f0c684 <fgetc>:
 3f0c684:	e1a0c00d 	mov	r12, r13
 3f0c688:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0c68c:	e24cb004 	sub	r11, r12, #4	; 0x4

int fgetc (int file)
{
	if (file < MAX_FILES)
 3f0c690:	e3500002 	cmp	r0, #2	; 0x2
		return stdio_devices[file]->getc ();

	return -1;
 3f0c694:	c3e00000 	mvngt	r0, #0	; 0x0
 3f0c698:	c91ba800 	ldmgtdb	r11, {r11, r13, r15}
 3f0c69c:	e59f300c 	ldr	r3, [pc, #c]	; 3f0c6b0 <fgetc+0x2c>
 3f0c6a0:	e7933100 	ldr	r3, [r3, r0, lsl #2]
 3f0c6a4:	e1a0e00f 	mov	r14, r15
 3f0c6a8:	e593f024 	ldr	r15, [r3, #36]
 3f0c6ac:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c6b0:	03f20864 	mvneqs	r0, #6553600	; 0x640000

03f0c6b4 <ftstc>:
 3f0c6b4:	e1a0c00d 	mov	r12, r13
 3f0c6b8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0c6bc:	e24cb004 	sub	r11, r12, #4	; 0x4
}

int ftstc (int file)
{
	if (file < MAX_FILES)
 3f0c6c0:	e3500002 	cmp	r0, #2	; 0x2
		return stdio_devices[file]->tstc ();

	return -1;
 3f0c6c4:	c3e00000 	mvngt	r0, #0	; 0x0
 3f0c6c8:	c91ba800 	ldmgtdb	r11, {r11, r13, r15}
 3f0c6cc:	e59f300c 	ldr	r3, [pc, #c]	; 3f0c6e0 <ftstc+0x2c>
 3f0c6d0:	e7933100 	ldr	r3, [r3, r0, lsl #2]
 3f0c6d4:	e1a0e00f 	mov	r14, r15
 3f0c6d8:	e593f020 	ldr	r15, [r3, #32]
 3f0c6dc:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c6e0:	03f20864 	mvneqs	r0, #6553600	; 0x640000

03f0c6e4 <fputc>:
 3f0c6e4:	e1a0c00d 	mov	r12, r13
 3f0c6e8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0c6ec:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void fputc (int file, const char c)
{
 3f0c6f0:	e20110ff 	and	r1, r1, #255	; 0xff
	if (file < MAX_FILES)
 3f0c6f4:	e3500002 	cmp	r0, #2	; 0x2
 3f0c6f8:	c91ba800 	ldmgtdb	r11, {r11, r13, r15}
		stdio_devices[file]->putc (c);
 3f0c6fc:	e59f3010 	ldr	r3, [pc, #10]	; 3f0c714 <fputc+0x30>
 3f0c700:	e7933100 	ldr	r3, [r3, r0, lsl #2]
 3f0c704:	e1a00001 	mov	r0, r1
 3f0c708:	e1a0e00f 	mov	r14, r15
 3f0c70c:	e593f018 	ldr	r15, [r3, #24]
 3f0c710:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c714:	03f20864 	mvneqs	r0, #6553600	; 0x640000

03f0c718 <fputs>:
 3f0c718:	e1a0c00d 	mov	r12, r13
 3f0c71c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0c720:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void fputs (int file, const char *s)
{
	if (file < MAX_FILES)
 3f0c724:	e3500002 	cmp	r0, #2	; 0x2
 3f0c728:	c91ba800 	ldmgtdb	r11, {r11, r13, r15}
		stdio_devices[file]->puts (s);
 3f0c72c:	e59f3010 	ldr	r3, [pc, #10]	; 3f0c744 <fputs+0x2c>
 3f0c730:	e7933100 	ldr	r3, [r3, r0, lsl #2]
 3f0c734:	e1a00001 	mov	r0, r1
 3f0c738:	e1a0e00f 	mov	r14, r15
 3f0c73c:	e593f01c 	ldr	r15, [r3, #28]
 3f0c740:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c744:	03f20864 	mvneqs	r0, #6553600	; 0x640000

03f0c748 <fprintf>:
 3f0c748:	e1a0c00d 	mov	r12, r13
 3f0c74c:	e92d000e 	stmdb	r13!, {r1, r2, r3}
 3f0c750:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0c754:	e24cb010 	sub	r11, r12, #16	; 0x10
}

void fprintf (int file, const char *fmt, ...)
{
 3f0c758:	e1a05000 	mov	r5, r0
	va_list args;
	uint i;
	char printbuffer[CFG_PBSIZE];

	va_start (args, fmt);

	/* For this to work, printbuffer must be larger than
	 * anything we ever want to print.
	 */
	i = vsprintf (printbuffer, fmt, args);
 3f0c75c:	e24b4f4b 	sub	r4, r11, #300	; 0x12c
 3f0c760:	e1a00004 	mov	r0, r4
 3f0c764:	e24ddf46 	sub	r13, r13, #280	; 0x118
 3f0c768:	e59b1004 	ldr	r1, [r11, #4]
 3f0c76c:	e28b2008 	add	r2, r11, #8	; 0x8
 3f0c770:	eb000cf5 	bl	3f0fb4c <vsprintf>
	va_end (args);

	/* Send to desired file */
	fputs (file, printbuffer);
 3f0c774:	e1a00005 	mov	r0, r5
 3f0c778:	e1a01004 	mov	r1, r4
 3f0c77c:	ebffffe5 	bl	3f0c718 <fputs>
}
 3f0c780:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f0c784 <getc>:
 3f0c784:	e1a0c00d 	mov	r12, r13
 3f0c788:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

/** U-Boot INITIAL CONSOLE-COMPATIBLE FUNCTION *****************************/

int getc (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->flags & GD_FLG_DEVINIT) {
 3f0c78c:	e5983004 	ldr	r3, [r8, #4]
 3f0c790:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0c794:	e3130002 	tst	r3, #2	; 0x2
 3f0c798:	1a000001 	bne	3f0c7a4 <getc+0x20>
		/* Get from the standard input */
		return fgetc (stdin);
	}

	/* Send directly to the handler */
	return serial_getc ();
 3f0c79c:	eb00271d 	bl	3f16418 <serial_getc>
 3f0c7a0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c7a4:	e3a00000 	mov	r0, #0	; 0x0
 3f0c7a8:	ebffffb5 	bl	3f0c684 <fgetc>
}
 3f0c7ac:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0c7b0 <tstc>:
 3f0c7b0:	e1a0c00d 	mov	r12, r13
 3f0c7b4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

int tstc (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->flags & GD_FLG_DEVINIT) {
 3f0c7b8:	e5983004 	ldr	r3, [r8, #4]
 3f0c7bc:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0c7c0:	e3130002 	tst	r3, #2	; 0x2
 3f0c7c4:	1a000001 	bne	3f0c7d0 <tstc+0x20>
		/* Test the standard input */
		return ftstc (stdin);
	}

	/* Send directly to the handler */
	return serial_tstc ();
 3f0c7c8:	eb00272c 	bl	3f16480 <serial_tstc>
 3f0c7cc:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c7d0:	e3a00000 	mov	r0, #0	; 0x0
 3f0c7d4:	ebffffb6 	bl	3f0c6b4 <ftstc>
}
 3f0c7d8:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0c7dc <putc>:
 3f0c7dc:	e1a0c00d 	mov	r12, r13
 3f0c7e0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0c7e4:	e24cb004 	sub	r11, r12, #4	; 0x4

void putc (const char c)
{
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->flags & GD_FLG_DEVINIT) {
 3f0c7e8:	e5983004 	ldr	r3, [r8, #4]
 3f0c7ec:	e20010ff 	and	r1, r0, #255	; 0xff
 3f0c7f0:	e3130002 	tst	r3, #2	; 0x2
 3f0c7f4:	0a000002 	beq	3f0c804 <putc+0x28>
		/* Send to the standard output */
		fputc (stdout, c);
 3f0c7f8:	e3a00001 	mov	r0, #1	; 0x1
 3f0c7fc:	ebffffb8 	bl	3f0c6e4 <fputc>
	} else {
 3f0c800:	e91ba800 	ldmdb	r11, {r11, r13, r15}
		/* Send directly to the handler */
		serial_putc (c);
 3f0c804:	e1a00001 	mov	r0, r1
 3f0c808:	eb00270d 	bl	3f16444 <serial_putc>
	}
}
 3f0c80c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0c810 <puts>:
 3f0c810:	e1a0c00d 	mov	r12, r13
 3f0c814:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0c818:	e24cb004 	sub	r11, r12, #4	; 0x4

void puts (const char *s)
{
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->flags & GD_FLG_DEVINIT) {
 3f0c81c:	e5983004 	ldr	r3, [r8, #4]
 3f0c820:	e1a01000 	mov	r1, r0
 3f0c824:	e3130002 	tst	r3, #2	; 0x2
 3f0c828:	0a000002 	beq	3f0c838 <puts+0x28>
		/* Send to the standard output */
		fputs (stdout, s);
 3f0c82c:	e3a00001 	mov	r0, #1	; 0x1
 3f0c830:	ebffffb8 	bl	3f0c718 <fputs>
	} else {
 3f0c834:	e91ba800 	ldmdb	r11, {r11, r13, r15}
		/* Send directly to the handler */
		serial_puts (s);
 3f0c838:	e1a00001 	mov	r0, r1
 3f0c83c:	eb002717 	bl	3f164a0 <serial_puts>
	}
}
 3f0c840:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0c844 <printf>:
 3f0c844:	e1a0c00d 	mov	r12, r13
 3f0c848:	e92d000f 	stmdb	r13!, {r0, r1, r2, r3}
 3f0c84c:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f0c850:	e24cb014 	sub	r11, r12, #20	; 0x14

void printf (const char *fmt, ...)
{
	va_list args;
	uint i;
	char printbuffer[CFG_PBSIZE];

	va_start (args, fmt);

	/* For this to work, printbuffer must be larger than
	 * anything we ever want to print.
	 */
	i = vsprintf (printbuffer, fmt, args);
 3f0c854:	e24b4f4a 	sub	r4, r11, #296	; 0x128
 3f0c858:	e1a00004 	mov	r0, r4
 3f0c85c:	e24ddf46 	sub	r13, r13, #280	; 0x118
 3f0c860:	e59b1004 	ldr	r1, [r11, #4]
 3f0c864:	e28b2008 	add	r2, r11, #8	; 0x8
 3f0c868:	eb000cb7 	bl	3f0fb4c <vsprintf>
	va_end (args);

	/* Print the string */
	puts (printbuffer);
 3f0c86c:	e1a00004 	mov	r0, r4
 3f0c870:	ebffffe6 	bl	3f0c810 <puts>
}
 3f0c874:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f0c878 <vprintf>:
 3f0c878:	e1a0c00d 	mov	r12, r13
 3f0c87c:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f0c880:	e24cb004 	sub	r11, r12, #4	; 0x4

void vprintf (const char *fmt, va_list args)
{
 3f0c884:	e1a03000 	mov	r3, r0
	uint i;
	char printbuffer[CFG_PBSIZE];

	/* For this to work, printbuffer must be larger than
	 * anything we ever want to print.
	 */
	i = vsprintf (printbuffer, fmt, args);
 3f0c888:	e24b4f4a 	sub	r4, r11, #296	; 0x128
 3f0c88c:	e1a00004 	mov	r0, r4
 3f0c890:	e1a02001 	mov	r2, r1
 3f0c894:	e1a01003 	mov	r1, r3
 3f0c898:	e24ddf46 	sub	r13, r13, #280	; 0x118
 3f0c89c:	eb000caa 	bl	3f0fb4c <vsprintf>

	/* Print the string */
	puts (printbuffer);
 3f0c8a0:	e1a00004 	mov	r0, r4
 3f0c8a4:	ebffffd9 	bl	3f0c810 <puts>
}
 3f0c8a8:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f0c8ac <ctrlc>:
 3f0c8ac:	e1a0c00d 	mov	r12, r13
 3f0c8b0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

/* test if ctrl-c was pressed */
static int ctrlc_disabled = 0;	/* see disable_ctrl() */
static int ctrlc_was_pressed = 0;
int ctrlc (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	if (!ctrlc_disabled && gd->have_console) {
 3f0c8b4:	e59f3048 	ldr	r3, [pc, #48]	; 3f0c904 <ctrlc+0x58>
 3f0c8b8:	e5933000 	ldr	r3, [r3]
 3f0c8bc:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0c8c0:	e3530000 	cmp	r3, #0	; 0x0
 3f0c8c4:	1a00000c 	bne	3f0c8fc <ctrlc+0x50>
 3f0c8c8:	e598300c 	ldr	r3, [r8, #12]
 3f0c8cc:	e3530000 	cmp	r3, #0	; 0x0
 3f0c8d0:	0a000009 	beq	3f0c8fc <ctrlc+0x50>
		if (tstc ()) {
 3f0c8d4:	ebffffb5 	bl	3f0c7b0 <tstc>
 3f0c8d8:	e3500000 	cmp	r0, #0	; 0x0
 3f0c8dc:	0a000006 	beq	3f0c8fc <ctrlc+0x50>
			switch (getc ()) {
 3f0c8e0:	ebffffa7 	bl	3f0c784 <getc>
 3f0c8e4:	e3500003 	cmp	r0, #3	; 0x3
			case 0x03:		/* ^C - Control C */
				ctrlc_was_pressed = 1;
 3f0c8e8:	03a03001 	moveq	r3, #1	; 0x1
 3f0c8ec:	059f2014 	ldreq	r2, [pc, #14]	; 3f0c908 <ctrlc+0x5c>
				return 1;
 3f0c8f0:	01a00003 	moveq	r0, r3
 3f0c8f4:	05823000 	streq	r3, [r2]
 3f0c8f8:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
			default:
				break;
			}
		}
	}
	return 0;
 3f0c8fc:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0c900:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c904:	03f20858 	mvneqs	r0, #5767168	; 0x580000
 3f0c908:	03f2085c 	mvneqs	r0, #6029312	; 0x5c0000

03f0c90c <disable_ctrlc>:
 3f0c90c:	e1a0c00d 	mov	r12, r13
 3f0c910:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

/* pass 1 to disable ctrlc() checking, 0 to enable.
 * returns previous state
 */
int disable_ctrlc (int disable)
{
	int prev = ctrlc_disabled;	/* save previous state */
 3f0c914:	e59f3010 	ldr	r3, [pc, #10]	; 3f0c92c <disable_ctrlc+0x20>
 3f0c918:	e5932000 	ldr	r2, [r3]
 3f0c91c:	e24cb004 	sub	r11, r12, #4	; 0x4

	ctrlc_disabled = disable;
 3f0c920:	e5830000 	str	r0, [r3]
	return prev;
 3f0c924:	e1a00002 	mov	r0, r2
}
 3f0c928:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c92c:	03f20858 	mvneqs	r0, #5767168	; 0x580000

03f0c930 <had_ctrlc>:
 3f0c930:	e1a0c00d 	mov	r12, r13
 3f0c934:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

int had_ctrlc (void)
{
	return ctrlc_was_pressed;
 3f0c938:	e59f3008 	ldr	r3, [pc, #8]	; 3f0c948 <had_ctrlc+0x18>
 3f0c93c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0c940:	e5930000 	ldr	r0, [r3]
 3f0c944:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c948:	03f2085c 	mvneqs	r0, #6029312	; 0x5c0000

03f0c94c <clear_ctrlc>:
 3f0c94c:	e1a0c00d 	mov	r12, r13
 3f0c950:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0c954:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void clear_ctrlc (void)
{
	ctrlc_was_pressed = 0;
 3f0c958:	e59f2008 	ldr	r2, [pc, #8]	; 3f0c968 <clear_ctrlc+0x1c>
 3f0c95c:	e3a03000 	mov	r3, #0	; 0x0
 3f0c960:	e5823000 	str	r3, [r2]
 3f0c964:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0c968:	03f2085c 	mvneqs	r0, #6029312	; 0x5c0000

03f0c96c <dbg>:
 3f0c96c:	e1a0c00d 	mov	r12, r13
 3f0c970:	e92d000f 	stmdb	r13!, {r0, r1, r2, r3}
 3f0c974:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0c978:	e24cb014 	sub	r11, r12, #20	; 0x14
 3f0c97c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0c980 <console_assign>:
 3f0c980:	e1a0c00d 	mov	r12, r13
 3f0c984:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f0c988:	e24cb004 	sub	r11, r12, #4	; 0x4
}

#ifdef CONFIG_MODEM_SUPPORT_DEBUG
char	screen[1024];
char *cursor = screen;
int once = 0;
inline void dbg(const char *fmt, ...)
{
	va_list	args;
	uint	i;
	char	printbuffer[CFG_PBSIZE];

	if (!once) {
		memset(screen, 0, sizeof(screen));
		once++;
	}

	va_start(args, fmt);

	/* For this to work, printbuffer must be larger than
	 * anything we ever want to print.
	 */
	i = vsprintf(printbuffer, fmt, args);
	va_end(args);

	if ((screen + sizeof(screen) - 1 - cursor) < strlen(printbuffer)+1) {
		memset(screen, 0, sizeof(screen));
		cursor = screen;
	}
	sprintf(cursor, printbuffer);
	cursor += strlen(printbuffer);

}
#else
inline void dbg(const char *fmt, ...)
{
}
#endif

/** U-Boot INIT FUNCTIONS *************************************************/

int console_assign (int file, char *devname)
{
 3f0c98c:	e1a07001 	mov	r7, r1
	int flag, i;

	/* Check for valid file */
	switch (file) {
 3f0c990:	e2506000 	subs	r6, r0, #0	; 0x0
	case stdin:
		flag = DEV_FLAGS_INPUT;
 3f0c994:	03a0a001 	moveq	r10, #1	; 0x1
		break;
 3f0c998:	0a000008 	beq	3f0c9c0 <console_assign+0x40>
 3f0c99c:	ba000015 	blt	3f0c9f8 <console_assign+0x78>
 3f0c9a0:	e3560002 	cmp	r6, #2	; 0x2
 3f0c9a4:	ca000013 	bgt	3f0c9f8 <console_assign+0x78>
	case stdout:
	case stderr:
		flag = DEV_FLAGS_OUTPUT;
 3f0c9a8:	e3a0a002 	mov	r10, #2	; 0x2
		break;
 3f0c9ac:	ea000003 	b	3f0c9c0 <console_assign+0x40>
	default:
		return -1;
	}

	/* Check for valid device name */

	for (i = 1; i <= ListNumItems (devlist); i++) {
		device_t *dev = ListGetPtrToItem (devlist, i);

		if (strcmp (devname, dev->name) == 0) {
			if (dev->flags & flag)
				return console_setfile (file, dev);
 3f0c9b0:	e1a00006 	mov	r0, r6
 3f0c9b4:	e1a01004 	mov	r1, r4
 3f0c9b8:	ebfffef4 	bl	3f0c590 <console_setfile>
 3f0c9bc:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f0c9c0:	e3a05001 	mov	r5, #1	; 0x1
 3f0c9c4:	ea00000e 	b	3f0ca04 <console_assign+0x84>
 3f0c9c8:	e5940000 	ldr	r0, [r4]
 3f0c9cc:	e1a01005 	mov	r1, r5
 3f0c9d0:	eb0007e2 	bl	3f0e960 <ListGetPtrToItem>
 3f0c9d4:	e1a04000 	mov	r4, r0
 3f0c9d8:	e1a00007 	mov	r0, r7
 3f0c9dc:	e2841008 	add	r1, r4, #8	; 0x8
 3f0c9e0:	eb0009f4 	bl	3f0f1b8 <strcmp>
 3f0c9e4:	e3500000 	cmp	r0, #0	; 0x0
 3f0c9e8:	1a000004 	bne	3f0ca00 <console_assign+0x80>
 3f0c9ec:	e5943000 	ldr	r3, [r4]
 3f0c9f0:	e113000a 	tst	r3, r10
 3f0c9f4:	1affffed 	bne	3f0c9b0 <console_assign+0x30>

			return -1;
 3f0c9f8:	e3e00000 	mvn	r0, #0	; 0x0
 3f0c9fc:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f0ca00:	e2855001 	add	r5, r5, #1	; 0x1
 3f0ca04:	e59f4014 	ldr	r4, [pc, #14]	; 3f0ca20 <console_assign+0xa0>
 3f0ca08:	e5940000 	ldr	r0, [r4]
 3f0ca0c:	eb0007f0 	bl	3f0e9d4 <ListNumItems>
 3f0ca10:	e1550000 	cmp	r5, r0
 3f0ca14:	daffffeb 	ble	3f0c9c8 <console_assign+0x48>
		}
	}

	return -1;
 3f0ca18:	e3e00000 	mvn	r0, #0	; 0x0
}
 3f0ca1c:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f0ca20:	03f20860 	mvneqs	r0, #6291456	; 0x600000

03f0ca24 <console_init_f>:
 3f0ca24:	e1a0c00d 	mov	r12, r13
 3f0ca28:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0ca2c:	e24cb004 	sub	r11, r12, #4	; 0x4

/* Called before relocation - use serial functions */
int console_init_f (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	gd->have_console = 1;
 3f0ca30:	e3a03001 	mov	r3, #1	; 0x1

#ifdef CONFIG_SILENT_CONSOLE
	if (getenv("silent") != NULL)
		gd->flags |= GD_FLG_SILENT;
#endif

	return (0);
 3f0ca34:	e3a00000 	mov	r0, #0	; 0x0
 3f0ca38:	e588300c 	str	r3, [r8, #12]
}
 3f0ca3c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0ca40 <console_init_r>:
 3f0ca40:	e1a0c00d 	mov	r12, r13
 3f0ca44:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f0ca48:	e24cb004 	sub	r11, r12, #4	; 0x4

#if defined(CFG_CONSOLE_IS_IN_ENV) || defined(CONFIG_SPLASH_SCREEN) || defined(CONFIG_SILENT_CONSOLE)
/* search a device */
device_t *search_device (int flags, char *name)
{
	int i, items;
	device_t *dev = NULL;

	items = ListNumItems (devlist);
	if (name == NULL)
		return dev;

	for (i = 1; i <= items; i++) {
		dev = ListGetPtrToItem (devlist, i);
		if ((dev->flags & flags) && (strcmp (name, dev->name) == 0)) {
			break;
		}
	}
	return dev;
}
#endif /* CFG_CONSOLE_IS_IN_ENV || CONFIG_SPLASH_SCREEN */

#ifdef CFG_CONSOLE_IS_IN_ENV
/* Called after the relocation - use desired console functions */
int console_init_r (void)
{
	DECLARE_GLOBAL_DATA_PTR;
	char *stdinname, *stdoutname, *stderrname;
	device_t *inputdev = NULL, *outputdev = NULL, *errdev = NULL;

	/* set default handlers at first */
	gd->jt[XF_getc] = serial_getc;
	gd->jt[XF_tstc] = serial_tstc;
	gd->jt[XF_putc] = serial_putc;
	gd->jt[XF_puts] = serial_puts;
	gd->jt[XF_printf] = serial_printf;

	/* stdin stdout and stderr are in environment */
	/* scan for it */
	stdinname  = getenv ("stdin");
	stdoutname = getenv ("stdout");
	stderrname = getenv ("stderr");

	if (overwrite_console () == 0) { /* if not overwritten by config switch */
		inputdev  = search_device (DEV_FLAGS_INPUT,  stdinname);
		outputdev = search_device (DEV_FLAGS_OUTPUT, stdoutname);
		errdev    = search_device (DEV_FLAGS_OUTPUT, stderrname);
	}
	/* if the devices are overwritten or not found, use default device */
	if (inputdev == NULL) {
		inputdev  = search_device (DEV_FLAGS_INPUT,  "serial");
	}
	if (outputdev == NULL) {
		outputdev = search_device (DEV_FLAGS_OUTPUT, "serial");
	}
	if (errdev == NULL) {
		errdev    = search_device (DEV_FLAGS_OUTPUT, "serial");
	}
	/* Initializes output console first */
	if (outputdev != NULL) {
		console_setfile (stdout, outputdev);
	}
	if (errdev != NULL) {
		console_setfile (stderr, errdev);
	}
	if (inputdev != NULL) {
		console_setfile (stdin, inputdev);
	}

	gd->flags |= GD_FLG_DEVINIT;	/* device initialization completed */

#ifndef CFG_CONSOLE_INFO_QUIET
	/* Print information */
	printf ("In:    ");
	if (stdio_devices[stdin] == NULL) {
		printf ("No input devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stdin]->name);
	}

	printf ("Out:   ");
	if (stdio_devices[stdout] == NULL) {
		printf ("No output devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stdout]->name);
	}

	printf ("Err:   ");
	if (stdio_devices[stderr] == NULL) {
		printf ("No error devices available!\n");
	} else {
		printf ("%s\n", stdio_devices[stderr]->name);
	}
#endif /* CFG_CONSOLE_INFO_QUIET */

#ifdef CFG_CONSOLE_ENV_OVERWRITE
	/* set the environment variables (will overwrite previous env settings) */
	for (i = 0; i < 3; i++) {
		setenv (stdio_names[i], stdio_devices[i]->name);
	}
#endif /*  CFG_CONSOLE_ENV_OVERWRITE */

#if 0
	/* If nothing usable installed, use only the initial console */
	if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
		return (0);
#endif
	return (0);
}

#else /* CFG_CONSOLE_IS_IN_ENV */

/* Called after the relocation - use desired console functions */
int console_init_r (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	device_t *inputdev = NULL, *outputdev = NULL;
 3f0ca4c:	e3a06000 	mov	r6, #0	; 0x0
	int i, items = ListNumItems (devlist);
 3f0ca50:	e59fa164 	ldr	r10, [pc, #164]	; 3f0cbbc <console_init_r+0x17c>
 3f0ca54:	e1a05006 	mov	r5, r6
 3f0ca58:	e59a0000 	ldr	r0, [r10]

#ifdef CONFIG_SPLASH_SCREEN
	/* suppress all output if splash screen is enabled and we have
	   a bmp to display                                            */
	if (getenv("splashimage") != NULL)
		outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
#endif

#ifdef CONFIG_SILENT_CONSOLE
	/* Suppress all output if "silent" mode requested		*/
	if (gd->flags & GD_FLG_SILENT)
		outputdev = search_device (DEV_FLAGS_OUTPUT, "nulldev");
#endif

	/* Scan devices looking for input and output devices */
	for (i = 1;
 3f0ca5c:	e3a04001 	mov	r4, #1	; 0x1
 3f0ca60:	eb0007db 	bl	3f0e9d4 <ListNumItems>
 3f0ca64:	e1a07000 	mov	r7, r0
	     (i <= items) && ((inputdev == NULL) || (outputdev == NULL));
 3f0ca68:	e1540007 	cmp	r4, r7
 3f0ca6c:	ca000014 	bgt	3f0cac4 <console_init_r+0x84>
	     i++
	    ) {
		device_t *dev = ListGetPtrToItem (devlist, i);
 3f0ca70:	e59a0000 	ldr	r0, [r10]
 3f0ca74:	e1a01004 	mov	r1, r4
 3f0ca78:	eb0007b8 	bl	3f0e960 <ListGetPtrToItem>
 3f0ca7c:	e2844001 	add	r4, r4, #1	; 0x1

		if ((dev->flags & DEV_FLAGS_INPUT) && (inputdev == NULL)) {
 3f0ca80:	e5903000 	ldr	r3, [r0]
 3f0ca84:	e3560000 	cmp	r6, #0	; 0x0
 3f0ca88:	02032001 	andeq	r2, r3, #1	; 0x1
 3f0ca8c:	13a02000 	movne	r2, #0	; 0x0
 3f0ca90:	e3520000 	cmp	r2, #0	; 0x0
 3f0ca94:	11a06000 	movne	r6, r0
			inputdev = dev;
		}
		if ((dev->flags & DEV_FLAGS_OUTPUT) && (outputdev == NULL)) {
 3f0ca98:	e1a030a3 	mov	r3, r3, lsr #1
 3f0ca9c:	e3550000 	cmp	r5, #0	; 0x0
 3f0caa0:	02033001 	andeq	r3, r3, #1	; 0x1
 3f0caa4:	13a03000 	movne	r3, #0	; 0x0
 3f0caa8:	e3530000 	cmp	r3, #0	; 0x0
 3f0caac:	11a05000 	movne	r5, r0
 3f0cab0:	e1540007 	cmp	r4, r7
 3f0cab4:	ca000002 	bgt	3f0cac4 <console_init_r+0x84>
 3f0cab8:	e3550000 	cmp	r5, #0	; 0x0
 3f0cabc:	13560000 	cmpne	r6, #0	; 0x0
 3f0cac0:	0affffea 	beq	3f0ca70 <console_init_r+0x30>
			outputdev = dev;
		}
	}

	/* Initializes output console first */
	if (outputdev != NULL) {
 3f0cac4:	e3550000 	cmp	r5, #0	; 0x0
 3f0cac8:	0a000005 	beq	3f0cae4 <console_init_r+0xa4>
		console_setfile (stdout, outputdev);
 3f0cacc:	e3a00001 	mov	r0, #1	; 0x1
 3f0cad0:	e1a01005 	mov	r1, r5
 3f0cad4:	ebfffead 	bl	3f0c590 <console_setfile>
		console_setfile (stderr, outputdev);
 3f0cad8:	e3a00002 	mov	r0, #2	; 0x2
 3f0cadc:	e1a01005 	mov	r1, r5
 3f0cae0:	ebfffeaa 	bl	3f0c590 <console_setfile>
	}

	/* Initializes input console */
	if (inputdev != NULL) {
 3f0cae4:	e3560000 	cmp	r6, #0	; 0x0
 3f0cae8:	0a000002 	beq	3f0caf8 <console_init_r+0xb8>
		console_setfile (stdin, inputdev);
 3f0caec:	e3a00000 	mov	r0, #0	; 0x0
 3f0caf0:	e1a01006 	mov	r1, r6
 3f0caf4:	ebfffea5 	bl	3f0c590 <console_setfile>
	}

	gd->flags |= GD_FLG_DEVINIT;	/* device initialization completed */
 3f0caf8:	e5983004 	ldr	r3, [r8, #4]

#ifndef CFG_CONSOLE_INFO_QUIET
	/* Print information */
	printf ("In:    ");
 3f0cafc:	e59f00bc 	ldr	r0, [pc, #bc]	; 3f0cbc0 <console_init_r+0x180>
	if (stdio_devices[stdin] == NULL) {
 3f0cb00:	e59f50bc 	ldr	r5, [pc, #bc]	; 3f0cbc4 <console_init_r+0x184>
 3f0cb04:	e3833002 	orr	r3, r3, #2	; 0x2
 3f0cb08:	e5883004 	str	r3, [r8, #4]
 3f0cb0c:	ebffff4c 	bl	3f0c844 <printf>
 3f0cb10:	e5951000 	ldr	r1, [r5]
 3f0cb14:	e3510000 	cmp	r1, #0	; 0x0
 3f0cb18:	1a000002 	bne	3f0cb28 <console_init_r+0xe8>
		printf ("No input devices available!\n");
 3f0cb1c:	e59f00a4 	ldr	r0, [pc, #a4]	; 3f0cbc8 <console_init_r+0x188>
 3f0cb20:	ebffff47 	bl	3f0c844 <printf>
	} else {
 3f0cb24:	ea000002 	b	3f0cb34 <console_init_r+0xf4>
		printf ("%s\n", stdio_devices[stdin]->name);
 3f0cb28:	e59f009c 	ldr	r0, [pc, #9c]	; 3f0cbcc <console_init_r+0x18c>
 3f0cb2c:	e2811008 	add	r1, r1, #8	; 0x8
 3f0cb30:	ebffff43 	bl	3f0c844 <printf>
	}

	printf ("Out:   ");
 3f0cb34:	e59f0094 	ldr	r0, [pc, #94]	; 3f0cbd0 <console_init_r+0x190>
 3f0cb38:	ebffff41 	bl	3f0c844 <printf>
	if (stdio_devices[stdout] == NULL) {
 3f0cb3c:	e5951004 	ldr	r1, [r5, #4]
 3f0cb40:	e3510000 	cmp	r1, #0	; 0x0
 3f0cb44:	1a000002 	bne	3f0cb54 <console_init_r+0x114>
		printf ("No output devices available!\n");
 3f0cb48:	e59f0084 	ldr	r0, [pc, #84]	; 3f0cbd4 <console_init_r+0x194>
 3f0cb4c:	ebffff3c 	bl	3f0c844 <printf>
	} else {
 3f0cb50:	ea000002 	b	3f0cb60 <console_init_r+0x120>
		printf ("%s\n", stdio_devices[stdout]->name);
 3f0cb54:	e59f0070 	ldr	r0, [pc, #70]	; 3f0cbcc <console_init_r+0x18c>
 3f0cb58:	e2811008 	add	r1, r1, #8	; 0x8
 3f0cb5c:	ebffff38 	bl	3f0c844 <printf>
	}

	printf ("Err:   ");
 3f0cb60:	e59f0070 	ldr	r0, [pc, #70]	; 3f0cbd8 <console_init_r+0x198>
 3f0cb64:	ebffff36 	bl	3f0c844 <printf>
	if (stdio_devices[stderr] == NULL) {
 3f0cb68:	e5951008 	ldr	r1, [r5, #8]
 3f0cb6c:	e3510000 	cmp	r1, #0	; 0x0
 3f0cb70:	1a000002 	bne	3f0cb80 <console_init_r+0x140>
		printf ("No error devices available!\n");
 3f0cb74:	e59f0060 	ldr	r0, [pc, #60]	; 3f0cbdc <console_init_r+0x19c>
 3f0cb78:	ebffff31 	bl	3f0c844 <printf>
	} else {
 3f0cb7c:	ea000002 	b	3f0cb8c <console_init_r+0x14c>
		printf ("%s\n", stdio_devices[stderr]->name);
 3f0cb80:	e59f0044 	ldr	r0, [pc, #44]	; 3f0cbcc <console_init_r+0x18c>
 3f0cb84:	e2811008 	add	r1, r1, #8	; 0x8
 3f0cb88:	ebffff2d 	bl	3f0c844 <printf>
	}
#endif /* CFG_CONSOLE_INFO_QUIET */

	/* Setting environment variables */
	for (i = 0; i < 3; i++) {
 3f0cb8c:	e3a04000 	mov	r4, #0	; 0x0
		setenv (stdio_names[i], stdio_devices[i]->name);
 3f0cb90:	e59f3048 	ldr	r3, [pc, #48]	; 3f0cbe0 <console_init_r+0x1a0>
 3f0cb94:	e1a02104 	mov	r2, r4, lsl #2
 3f0cb98:	e7951002 	ldr	r1, [r5, r2]
 3f0cb9c:	e2844001 	add	r4, r4, #1	; 0x1
 3f0cba0:	e7930002 	ldr	r0, [r3, r2]
 3f0cba4:	e2811008 	add	r1, r1, #8	; 0x8
 3f0cba8:	ebfffd0a 	bl	3f0bfd8 <setenv>
 3f0cbac:	e3540002 	cmp	r4, #2	; 0x2
 3f0cbb0:	dafffff6 	ble	3f0cb90 <console_init_r+0x150>
	}

#if 0
	/* If nothing usable installed, use only the initial console */
	if ((stdio_devices[stdin] == NULL) && (stdio_devices[stdout] == NULL))
		return (0);
#endif

	return (0);
 3f0cbb4:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0cbb8:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f0cbbc:	03f20860 	mvneqs	r0, #6291456	; 0x600000
 3f0cbc0:	03f1edf8 	mvneqs	r14, #15872	; 0x3e00
 3f0cbc4:	03f20864 	mvneqs	r0, #6553600	; 0x640000
 3f0cbc8:	03f1ee00 	mvneqs	r14, #0	; 0x0
 3f0cbcc:	03f1ee20 	mvneqs	r14, #512	; 0x200
 3f0cbd0:	03f1ee24 	mvneqs	r14, #576	; 0x240
 3f0cbd4:	03f1ee2c 	mvneqs	r14, #704	; 0x2c0
 3f0cbd8:	03f1ee4c 	mvneqs	r14, #1216	; 0x4c0
 3f0cbdc:	03f1ee54 	mvneqs	r14, #1344	; 0x540
 3f0cbe0:	03f20870 	mvneqs	r0, #7340032	; 0x700000

03f0cbe4 <drv_system_init>:
 3f0cbe4:	e1a0c00d 	mov	r12, r13
 3f0cbe8:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f0cbec:	e24cb004 	sub	r11, r12, #4	; 0x4
static void drv_system_init (void)
{
	device_t dev;

	memset (&dev, 0, sizeof (dev));
 3f0cbf0:	e24b403c 	sub	r4, r11, #60	; 0x3c
 3f0cbf4:	e1a00004 	mov	r0, r4
 3f0cbf8:	e3a01000 	mov	r1, #0	; 0x0
 3f0cbfc:	e3a0202c 	mov	r2, #44	; 0x2c
 3f0cc00:	e24dd02c 	sub	r13, r13, #44	; 0x2c
 3f0cc04:	eb000a45 	bl	3f0f520 <memset>

	strcpy (dev.name, "serial");
 3f0cc08:	e59f1038 	ldr	r1, [pc, #38]	; 3f0cc48 <drv_system_init+0x64>
 3f0cc0c:	e24b0034 	sub	r0, r11, #52	; 0x34
 3f0cc10:	eb00092c 	bl	3f0f0c8 <strcpy>
	dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
 3f0cc14:	e3a0310e 	mov	r3, #-2147483645	; 0x80000003
 3f0cc18:	e50b303c 	str	r3, [r11, -#60]
#if CONFIG_SERIAL_SOFTWARE_FIFO
	dev.putc = serial_buffered_putc;
	dev.puts = serial_buffered_puts;
	dev.getc = serial_buffered_getc;
	dev.tstc = serial_buffered_tstc;
#else
	dev.putc = serial_putc;
 3f0cc1c:	e59f3028 	ldr	r3, [pc, #28]	; 3f0cc4c <drv_system_init+0x68>
 3f0cc20:	e50b3024 	str	r3, [r11, -#36]
	dev.puts = serial_puts;
 3f0cc24:	e59f3024 	ldr	r3, [pc, #24]	; 3f0cc50 <drv_system_init+0x6c>
 3f0cc28:	e50b3020 	str	r3, [r11, -#32]
	dev.getc = serial_getc;
 3f0cc2c:	e59f3020 	ldr	r3, [pc, #20]	; 3f0cc54 <drv_system_init+0x70>
 3f0cc30:	e50b3018 	str	r3, [r11, -#24]
	dev.tstc = serial_tstc;
 3f0cc34:	e59f301c 	ldr	r3, [pc, #1c]	; 3f0cc58 <drv_system_init+0x74>
#endif

	device_register (&dev);
 3f0cc38:	e1a00004 	mov	r0, r4
 3f0cc3c:	e50b301c 	str	r3, [r11, -#28]
 3f0cc40:	eb000006 	bl	3f0cc60 <device_register>
 3f0cc44:	ea000004 	b	3f0cc5c <drv_system_init+0x78>
 3f0cc48:	03f1ee8c 	mvneqs	r14, #2240	; 0x8c0
 3f0cc4c:	03f16444 	mvneqs	r6, #1140850688	; 0x44000000
 3f0cc50:	03f164a0 	mvneqs	r6, #-1610612736	; 0xa0000000
 3f0cc54:	03f16418 	mvneqs	r6, #402653184	; 0x18000000
 3f0cc58:	03f16480 	mvneqs	r6, #-2147483648	; 0x80000000

#ifdef CFG_DEVICE_NULLDEV
	memset (&dev, 0, sizeof (dev));

	strcpy (dev.name, "nulldev");
	dev.flags = DEV_FLAGS_OUTPUT | DEV_FLAGS_INPUT | DEV_FLAGS_SYSTEM;
	dev.putc = nulldev_putc;
	dev.puts = nulldev_puts;
	dev.getc = nulldev_input;
	dev.tstc = nulldev_input;

	device_register (&dev);
#endif
}
 3f0cc5c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f0cc60 <device_register>:
 3f0cc60:	e1a0c00d 	mov	r12, r13
 3f0cc64:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0cc68:	e24cb004 	sub	r11, r12, #4	; 0x4

/**************************************************************************
 * DEVICES
 **************************************************************************
 */

int device_register (device_t * dev)
{
	ListInsertItem (devlist, dev, LIST_END);
 3f0cc6c:	e59f3014 	ldr	r3, [pc, #14]	; 3f0cc88 <device_register+0x28>
 3f0cc70:	e1a01000 	mov	r1, r0
 3f0cc74:	e5930000 	ldr	r0, [r3]
 3f0cc78:	e3a02000 	mov	r2, #0	; 0x0
 3f0cc7c:	eb0006c5 	bl	3f0e798 <ListInsertItem>
	return 0;
 3f0cc80:	e3a00000 	mov	r0, #0	; 0x0
 3f0cc84:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0cc88:	03f20860 	mvneqs	r0, #6291456	; 0x600000

03f0cc8c <devices_init>:
 3f0cc8c:	e1a0c00d 	mov	r12, r13
 3f0cc90:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0cc94:	e24cb004 	sub	r11, r12, #4	; 0x4
}

/* deregister the device "devname".
 * returns 0 if success, -1 if device is assigned and 1 if devname not found
 */
#ifdef	CFG_DEVICE_DEREGISTER
int device_deregister(char *devname)
{
	int i,l,dev_index;
	device_t *dev = NULL;
	char temp_names[3][8];

	dev_index=-1;
	for (i=1; i<=ListNumItems(devlist); i++) {
		dev = ListGetPtrToItem (devlist, i);
		if(strcmp(dev->name,devname)==0) {
			dev_index=i;
			break;
		}
	}
	if(dev_index<0) /* device not found */
		return 0;
	/* get stdio devices (ListRemoveItem changes the dev list) */
	for (l=0 ; l< MAX_FILES; l++) {
		if (stdio_devices[l] == dev) {
			/* Device is assigned -> report error */
			return -1;
		}
		memcpy (&temp_names[l][0],
			stdio_devices[l]->name,
			sizeof(stdio_devices[l]->name));
	}
	ListRemoveItem(devlist,NULL,dev_index);
	/* reassign Device list */
	for (i=1; i<=ListNumItems(devlist); i++) {
		dev = ListGetPtrToItem (devlist, i);
		for (l=0 ; l< MAX_FILES; l++) {
			if(strcmp(dev->name,temp_names[l])==0) {
				stdio_devices[l] = dev;
			}
		}
	}
	return 0;
}
#endif	/* CFG_DEVICE_DEREGISTER */

int devices_init (void)
{
#ifndef CONFIG_ARM     /* already relocated for current ARM implementation */
	DECLARE_GLOBAL_DATA_PTR;

	ulong relocation_offset = gd->reloc_off;
	int i;

	/* relocate device name pointers */
	for (i = 0; i < (sizeof (stdio_names) / sizeof (char *)); ++i) {
		stdio_names[i] = (char *) (((ulong) stdio_names[i]) +
						relocation_offset);
	}
#endif

	/* Initialize the list */
	devlist = ListCreate (sizeof (device_t));
 3f0cc98:	e3a0002c 	mov	r0, #44	; 0x2c
 3f0cc9c:	eb000696 	bl	3f0e6fc <ListCreate>
 3f0cca0:	e59f3028 	ldr	r3, [pc, #28]	; 3f0ccd0 <devices_init+0x44>

	if (devlist == NULL) {
 3f0cca4:	e3500000 	cmp	r0, #0	; 0x0
 3f0cca8:	e5830000 	str	r0, [r3]
 3f0ccac:	0a000002 	beq	3f0ccbc <devices_init+0x30>
		eputs ("Cannot initialize the list of devices!\n");
		return -1;
	}
#if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C)
	i2c_init (CFG_I2C_SPEED, CFG_I2C_SLAVE);
#endif
#ifdef CONFIG_LCD
	drv_lcd_init ();
#endif
#if defined(CONFIG_VIDEO) || defined(CONFIG_CFB_CONSOLE)
	drv_video_init ();
#endif
#ifdef CONFIG_KEYBOARD
	drv_keyboard_init ();
#endif
#ifdef CONFIG_LOGBUFFER
	drv_logbuff_init ();
#endif
	drv_system_init ();
 3f0ccb0:	ebffffcb 	bl	3f0cbe4 <drv_system_init>

	return (0);
 3f0ccb4:	e3a00000 	mov	r0, #0	; 0x0
 3f0ccb8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0ccbc:	e59f1010 	ldr	r1, [pc, #10]	; 3f0ccd4 <devices_init+0x48>
 3f0ccc0:	e3a00002 	mov	r0, #2	; 0x2
 3f0ccc4:	ebfffe93 	bl	3f0c718 <fputs>
 3f0ccc8:	e3e00000 	mvn	r0, #0	; 0x0
 3f0cccc:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0ccd0:	03f20860 	mvneqs	r0, #6291456	; 0x600000
 3f0ccd4:	03f1ee94 	mvneqs	r14, #2368	; 0x940

03f0ccd8 <devices_done>:
 3f0ccd8:	e1a0c00d 	mov	r12, r13
 3f0ccdc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

int devices_done (void)
{
	ListDispose (devlist);
 3f0cce0:	e59f3010 	ldr	r3, [pc, #10]	; 3f0ccf8 <devices_done+0x20>
 3f0cce4:	e5930000 	ldr	r0, [r3]
 3f0cce8:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0ccec:	eb0006a4 	bl	3f0e784 <ListDispose>

	return 0;
 3f0ccf0:	e3a00000 	mov	r0, #0	; 0x0
 3f0ccf4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0ccf8:	03f20860 	mvneqs	r0, #6291456	; 0x600000

03f0ccfc <malloc_bin_reloc>:
 3f0ccfc:	e1a0c00d 	mov	r12, r13
 3f0cd00:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0cd04:	e24cb004 	sub	r11, r12, #4	; 0x4
void malloc_bin_reloc (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	unsigned long *p = (unsigned long *)(&av_[2]);
 3f0cd08:	e59f0024 	ldr	r0, [pc, #24]	; 3f0cd34 <malloc_bin_reloc+0x38>
	int i;
	for (i=2; i<(sizeof(av_)/sizeof(mbinptr)); ++i) {
 3f0cd0c:	e3a01002 	mov	r1, #2	; 0x2
 3f0cd10:	e59fc020 	ldr	r12, [pc, #20]	; 3f0cd38 <malloc_bin_reloc+0x3c>
		*p++ += gd->reloc_off;
 3f0cd14:	e5903000 	ldr	r3, [r0]
 3f0cd18:	e2811001 	add	r1, r1, #1	; 0x1
 3f0cd1c:	e5982010 	ldr	r2, [r8, #16]
 3f0cd20:	e151000c 	cmp	r1, r12
 3f0cd24:	e0833002 	add	r3, r3, r2
 3f0cd28:	e4803004 	str	r3, [r0], #4
 3f0cd2c:	9afffff8 	bls	3f0cd14 <malloc_bin_reloc+0x18>
	}
}
 3f0cd30:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0cd34:	03f20884 	mvneqs	r0, #8650752	; 0x840000
 3f0cd38:	00000101 	andeq	r0, r0, r1, lsl #2

03f0cd3c <malloc_extend_top>:
 3f0cd3c:	e1a0c00d 	mov	r12, r13
 3f0cd40:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}


/* field-extraction macros */

#define first(b) ((b)->fd)
#define last(b)  ((b)->bk)

/*
  Indexing into bins
*/

#define bin_index(sz)                                                          \
(((((unsigned long)(sz)) >> 9) ==    0) ?       (((unsigned long)(sz)) >>  3): \
 ((((unsigned long)(sz)) >> 9) <=    4) ?  56 + (((unsigned long)(sz)) >>  6): \
 ((((unsigned long)(sz)) >> 9) <=   20) ?  91 + (((unsigned long)(sz)) >>  9): \
 ((((unsigned long)(sz)) >> 9) <=   84) ? 110 + (((unsigned long)(sz)) >> 12): \
 ((((unsigned long)(sz)) >> 9) <=  340) ? 119 + (((unsigned long)(sz)) >> 15): \
 ((((unsigned long)(sz)) >> 9) <= 1364) ? 124 + (((unsigned long)(sz)) >> 18): \
					  126)
/*
  bins for chunks < 512 are all spaced 8 bytes apart, and hold
  identically sized chunks. This is exploited in malloc.
*/

#define MAX_SMALLBIN         63
#define MAX_SMALLBIN_SIZE   512
#define SMALLBIN_WIDTH        8

#define smallbin_index(sz)  (((unsigned long)(sz)) >> 3)

/*
   Requests are `small' if both the corresponding and the next bin are small
*/

#define is_small_request(nb) (nb < MAX_SMALLBIN_SIZE - SMALLBIN_WIDTH)



/*
    To help compensate for the large number of bins, a one-level index
    structure is used for bin-by-bin searching.  `binblocks' is a
    one-word bitvector recording whether groups of BINBLOCKWIDTH bins
    have any (possibly) non-empty bins, so they can be skipped over
    all at once during during traversals. The bits are NOT always
    cleared as soon as all bins in a block are empty, but instead only
    when all are noticed to be empty during traversal in malloc.
*/

#define BINBLOCKWIDTH     4   /* bins per block */

#define binblocks      (bin_at(0)->size) /* bitvector of nonempty blocks */

/* bin<->block macros */

#define idx2binblock(ix)    ((unsigned)1 << (ix / BINBLOCKWIDTH))
#define mark_binblock(ii)   (binblocks |= idx2binblock(ii))
#define clear_binblock(ii)  (binblocks &= ~(idx2binblock(ii)))





/*  Other static bookkeeping data */

/* variables holding tunable values */

static unsigned long trim_threshold   = DEFAULT_TRIM_THRESHOLD;
static unsigned long top_pad          = DEFAULT_TOP_PAD;
static unsigned int  n_mmaps_max      = DEFAULT_MMAP_MAX;
static unsigned long mmap_threshold   = DEFAULT_MMAP_THRESHOLD;

/* The first value returned from sbrk */
static char* sbrk_base = (char*)(-1);

/* The maximum memory obtained from system via sbrk */
static unsigned long max_sbrked_mem = 0;

/* The maximum via either sbrk or mmap */
static unsigned long max_total_mem = 0;

/* internal working copy of mallinfo */
static struct mallinfo current_mallinfo = {  0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

/* The total memory obtained from system via sbrk */
#define sbrked_mem  (current_mallinfo.arena)

/* Tracking mmaps */

#if 0
static unsigned int n_mmaps = 0;
#endif	/* 0 */
static unsigned long mmapped_mem = 0;
#if HAVE_MMAP
static unsigned int max_n_mmaps = 0;
static unsigned long max_mmapped_mem = 0;
#endif



/*
  Debugging support
*/

#ifdef DEBUG


/*
  These routines make a number of assertions about the states
  of data structures that should be true at all times. If any
  are not true, it's very likely that a user program has somehow
  trashed memory. (It's also possible that there is a coding error
  in malloc. In which case, please report it!)
*/

#if __STD_C
static void do_check_chunk(mchunkptr p)
#else
static void do_check_chunk(p) mchunkptr p;
#endif
{
#if 0	/* causes warnings because assert() is off */
  INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
#endif	/* 0 */

  /* No checkable chunk is mmapped */
  assert(!chunk_is_mmapped(p));

  /* Check for legal address ... */
  assert((char*)p >= sbrk_base);
  if (p != top)
    assert((char*)p + sz <= (char*)top);
  else
    assert((char*)p + sz <= sbrk_base + sbrked_mem);

}


#if __STD_C
static void do_check_free_chunk(mchunkptr p)
#else
static void do_check_free_chunk(p) mchunkptr p;
#endif
{
  INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
#if 0	/* causes warnings because assert() is off */
  mchunkptr next = chunk_at_offset(p, sz);
#endif	/* 0 */

  do_check_chunk(p);

  /* Check whether it claims to be free ... */
  assert(!inuse(p));

  /* Unless a special marker, must have OK fields */
  if ((long)sz >= (long)MINSIZE)
  {
    assert((sz & MALLOC_ALIGN_MASK) == 0);
    assert(aligned_OK(chunk2mem(p)));
    /* ... matching footer field */
    assert(next->prev_size == sz);
    /* ... and is fully consolidated */
    assert(prev_inuse(p));
    assert (next == top || inuse(next));

    /* ... and has minimally sane links */
    assert(p->fd->bk == p);
    assert(p->bk->fd == p);
  }
  else /* markers are always of size SIZE_SZ */
    assert(sz == SIZE_SZ);
}

#if __STD_C
static void do_check_inuse_chunk(mchunkptr p)
#else
static void do_check_inuse_chunk(p) mchunkptr p;
#endif
{
  mchunkptr next = next_chunk(p);
  do_check_chunk(p);

  /* Check whether it claims to be in use ... */
  assert(inuse(p));

  /* ... and is surrounded by OK chunks.
    Since more things can be checked with free chunks than inuse ones,
    if an inuse chunk borders them and debug is on, it's worth doing them.
  */
  if (!prev_inuse(p))
  {
    mchunkptr prv = prev_chunk(p);
    assert(next_chunk(prv) == p);
    do_check_free_chunk(prv);
  }
  if (next == top)
  {
    assert(prev_inuse(next));
    assert(chunksize(next) >= MINSIZE);
  }
  else if (!inuse(next))
    do_check_free_chunk(next);

}

#if __STD_C
static void do_check_malloced_chunk(mchunkptr p, INTERNAL_SIZE_T s)
#else
static void do_check_malloced_chunk(p, s) mchunkptr p; INTERNAL_SIZE_T s;
#endif
{
#if 0	/* causes warnings because assert() is off */
  INTERNAL_SIZE_T sz = p->size & ~PREV_INUSE;
  long room = sz - s;
#endif	/* 0 */

  do_check_inuse_chunk(p);

  /* Legal size ... */
  assert((long)sz >= (long)MINSIZE);
  assert((sz & MALLOC_ALIGN_MASK) == 0);
  assert(room >= 0);
  assert(room < (long)MINSIZE);

  /* ... and alignment */
  assert(aligned_OK(chunk2mem(p)));


  /* ... and was allocated at front of an available chunk */
  assert(prev_inuse(p));

}


#define check_free_chunk(P)  do_check_free_chunk(P)
#define check_inuse_chunk(P) do_check_inuse_chunk(P)
#define check_chunk(P) do_check_chunk(P)
#define check_malloced_chunk(P,N) do_check_malloced_chunk(P,N)
#else
#define check_free_chunk(P)
#define check_inuse_chunk(P)
#define check_chunk(P)
#define check_malloced_chunk(P,N)
#endif



/*
  Macro-based internal utilities
*/


/*
  Linking chunks in bin lists.
  Call these only with variables, not arbitrary expressions, as arguments.
*/

/*
  Place chunk p of size s in its bin, in size order,
  putting it ahead of others of same size.
*/


#define frontlink(P, S, IDX, BK, FD)                                          \
{                                                                             \
  if (S < MAX_SMALLBIN_SIZE)                                                  \
  {                                                                           \
    IDX = smallbin_index(S);                                                  \
    mark_binblock(IDX);                                                       \
    BK = bin_at(IDX);                                                         \
    FD = BK->fd;                                                              \
    P->bk = BK;                                                               \
    P->fd = FD;                                                               \
    FD->bk = BK->fd = P;                                                      \
  }                                                                           \
  else                                                                        \
  {                                                                           \
    IDX = bin_index(S);                                                       \
    BK = bin_at(IDX);                                                         \
    FD = BK->fd;                                                              \
    if (FD == BK) mark_binblock(IDX);                                         \
    else                                                                      \
    {                                                                         \
      while (FD != BK && S < chunksize(FD)) FD = FD->fd;                      \
      BK = FD->bk;                                                            \
    }                                                                         \
    P->bk = BK;                                                               \
    P->fd = FD;                                                               \
    FD->bk = BK->fd = P;                                                      \
  }                                                                           \
}


/* take a chunk off a list */

#define unlink(P, BK, FD)                                                     \
{                                                                             \
  BK = P->bk;                                                                 \
  FD = P->fd;                                                                 \
  FD->bk = BK;                                                                \
  BK->fd = FD;                                                                \
}                                                                             \

/* Place p as the last remainder */

#define link_last_remainder(P)                                                \
{                                                                             \
  last_remainder->fd = last_remainder->bk =  P;                               \
  P->fd = P->bk = last_remainder;                                             \
}

/* Clear the last_remainder bin */

#define clear_last_remainder \
  (last_remainder->fd = last_remainder->bk = last_remainder)





/* Routines dealing with mmap(). */

#if HAVE_MMAP

#if __STD_C
static mchunkptr mmap_chunk(size_t size)
#else
static mchunkptr mmap_chunk(size) size_t size;
#endif
{
  size_t page_mask = malloc_getpagesize - 1;
  mchunkptr p;

#ifndef MAP_ANONYMOUS
  static int fd = -1;
#endif

  if(n_mmaps >= n_mmaps_max) return 0; /* too many regions */

  /* For mmapped chunks, the overhead is one SIZE_SZ unit larger, because
   * there is no following chunk whose prev_size field could be used.
   */
  size = (size + SIZE_SZ + page_mask) & ~page_mask;

#ifdef MAP_ANONYMOUS
  p = (mchunkptr)mmap(0, size, PROT_READ|PROT_WRITE,
		      MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
#else /* !MAP_ANONYMOUS */
  if (fd < 0)
  {
    fd = open("/dev/zero", O_RDWR);
    if(fd < 0) return 0;
  }
  p = (mchunkptr)mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
#endif

  if(p == (mchunkptr)-1) return 0;

  n_mmaps++;
  if (n_mmaps > max_n_mmaps) max_n_mmaps = n_mmaps;

  /* We demand that eight bytes into a page must be 8-byte aligned. */
  assert(aligned_OK(chunk2mem(p)));

  /* The offset to the start of the mmapped region is stored
   * in the prev_size field of the chunk; normally it is zero,
   * but that can be changed in memalign().
   */
  p->prev_size = 0;
  set_head(p, size|IS_MMAPPED);

  mmapped_mem += size;
  if ((unsigned long)mmapped_mem > (unsigned long)max_mmapped_mem)
    max_mmapped_mem = mmapped_mem;
  if ((unsigned long)(mmapped_mem + sbrked_mem) > (unsigned long)max_total_mem)
    max_total_mem = mmapped_mem + sbrked_mem;
  return p;
}

#if __STD_C
static void munmap_chunk(mchunkptr p)
#else
static void munmap_chunk(p) mchunkptr p;
#endif
{
  INTERNAL_SIZE_T size = chunksize(p);
  int ret;

  assert (chunk_is_mmapped(p));
  assert(! ((char*)p >= sbrk_base && (char*)p < sbrk_base + sbrked_mem));
  assert((n_mmaps > 0));
  assert(((p->prev_size + size) & (malloc_getpagesize-1)) == 0);

  n_mmaps--;
  mmapped_mem -= (size + p->prev_size);

  ret = munmap((char *)p - p->prev_size, size + p->prev_size);

  /* munmap returns non-zero on failure */
  assert(ret == 0);
}

#if HAVE_MREMAP

#if __STD_C
static mchunkptr mremap_chunk(mchunkptr p, size_t new_size)
#else
static mchunkptr mremap_chunk(p, new_size) mchunkptr p; size_t new_size;
#endif
{
  size_t page_mask = malloc_getpagesize - 1;
  INTERNAL_SIZE_T offset = p->prev_size;
  INTERNAL_SIZE_T size = chunksize(p);
  char *cp;

  assert (chunk_is_mmapped(p));
  assert(! ((char*)p >= sbrk_base && (char*)p < sbrk_base + sbrked_mem));
  assert((n_mmaps > 0));
  assert(((size + offset) & (malloc_getpagesize-1)) == 0);

  /* Note the extra SIZE_SZ overhead as in mmap_chunk(). */
  new_size = (new_size + offset + SIZE_SZ + page_mask) & ~page_mask;

  cp = (char *)mremap((char *)p - offset, size + offset, new_size, 1);

  if (cp == (char *)-1) return 0;

  p = (mchunkptr)(cp + offset);

  assert(aligned_OK(chunk2mem(p)));

  assert((p->prev_size == offset));
  set_head(p, (new_size - offset)|IS_MMAPPED);

  mmapped_mem -= size + offset;
  mmapped_mem += new_size;
  if ((unsigned long)mmapped_mem > (unsigned long)max_mmapped_mem)
    max_mmapped_mem = mmapped_mem;
  if ((unsigned long)(mmapped_mem + sbrked_mem) > (unsigned long)max_total_mem)
    max_total_mem = mmapped_mem + sbrked_mem;
  return p;
}

#endif /* HAVE_MREMAP */

#endif /* HAVE_MMAP */




/*
  Extend the top-most chunk by obtaining memory from system.
  Main interface to sbrk (but see also malloc_trim).
*/

#if __STD_C
static void malloc_extend_top(INTERNAL_SIZE_T nb)
#else
static void malloc_extend_top(nb) INTERNAL_SIZE_T nb;
#endif
{
  char*     brk;                  /* return value from sbrk */
  INTERNAL_SIZE_T front_misalign; /* unusable bytes at front of sbrked space */
  INTERNAL_SIZE_T correction;     /* bytes for 2nd sbrk call */
  char*     new_brk;              /* return of 2nd sbrk call */
  INTERNAL_SIZE_T top_size;       /* new size of top chunk */

  mchunkptr old_top     = top;  /* Record state of old top */
  INTERNAL_SIZE_T old_top_size = chunksize(old_top);
  char*     old_end      = (char*)(chunk_at_offset(old_top, old_top_size));

  /* Pad request with top_pad plus minimal overhead */

  INTERNAL_SIZE_T    sbrk_size     = nb + top_pad + MINSIZE;
 3f0cd44:	e59f31a8 	ldr	r3, [pc, #1a8]	; 3f0cef4 <malloc_extend_top+0x1b8>
 3f0cd48:	e59f11a8 	ldr	r1, [pc, #1a8]	; 3f0cef8 <malloc_extend_top+0x1bc>
 3f0cd4c:	e5933000 	ldr	r3, [r3]
 3f0cd50:	e591a008 	ldr	r10, [r1, #8]
 3f0cd54:	e0800003 	add	r0, r0, r3
  unsigned long pagesz    = malloc_getpagesize;

  /* If not the first time through, round to preserve page boundary */
  /* Otherwise, we need to correct to a page size below anyway. */
  /* (We also correct below if an intervening foreign sbrk call.) */

  if (sbrk_base != (char*)(-1))
 3f0cd58:	e59f319c 	ldr	r3, [pc, #19c]	; 3f0cefc <malloc_extend_top+0x1c0>
 3f0cd5c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0cd60:	e5932000 	ldr	r2, [r3]
 3f0cd64:	e2806010 	add	r6, r0, #16	; 0x10
 3f0cd68:	e59a3004 	ldr	r3, [r10, #4]
 3f0cd6c:	e3720001 	cmn	r2, #1	; 0x1
 3f0cd70:	e3c37003 	bic	r7, r3, #3	; 0x3
 3f0cd74:	e08a4007 	add	r4, r10, r7
    sbrk_size = (sbrk_size + (pagesz - 1)) & ~(pagesz - 1);
 3f0cd78:	12803a01 	addne	r3, r0, #4096	; 0x1000
 3f0cd7c:	1283300f 	addne	r3, r3, #15	; 0xf
 3f0cd80:	13c36eff 	bicne	r6, r3, #4080	; 0xff0
 3f0cd84:	13c6600f 	bicne	r6, r6, #15	; 0xf

  brk = (char*)(MORECORE (sbrk_size));
 3f0cd88:	e1a00006 	mov	r0, r6
 3f0cd8c:	ebffcf26 	bl	3f00a2c <sbrk>
 3f0cd90:	e1a05000 	mov	r5, r0

  /* Fail if sbrk failed or if a foreign sbrk call killed our space */
  if (brk == (char*)(MORECORE_FAILURE) ||
 3f0cd94:	e3750001 	cmn	r5, #1	; 0x1
 3f0cd98:	091baef0 	ldmeqdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f0cd9c:	e1550004 	cmp	r5, r4
 3f0cda0:	2a000002 	bcs	3f0cdb0 <malloc_extend_top+0x74>
 3f0cda4:	e59f114c 	ldr	r1, [pc, #14c]	; 3f0cef8 <malloc_extend_top+0x1bc>
 3f0cda8:	e15a0001 	cmp	r10, r1
 3f0cdac:	191baef0 	ldmnedb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
      (brk < old_end && old_top != initial_top))
    return;

  sbrked_mem += sbrk_size;
 3f0cdb0:	e59f9148 	ldr	r9, [pc, #148]	; 3f0cf00 <malloc_extend_top+0x1c4>
 3f0cdb4:	e5993000 	ldr	r3, [r9]

  if (brk == old_end) /* can just add bytes to current top */
 3f0cdb8:	e1550004 	cmp	r5, r4
 3f0cdbc:	e0832006 	add	r2, r3, r6
 3f0cdc0:	e5892000 	str	r2, [r9]
 3f0cdc4:	1a000005 	bne	3f0cde0 <malloc_extend_top+0xa4>
  {
    top_size = sbrk_size + old_top_size;
    set_head(top, top_size | PREV_INUSE);
 3f0cdc8:	e59f3128 	ldr	r3, [pc, #128]	; 3f0cef8 <malloc_extend_top+0x1bc>
 3f0cdcc:	e0860007 	add	r0, r6, r7
 3f0cdd0:	e5932008 	ldr	r2, [r3, #8]
 3f0cdd4:	e3803001 	orr	r3, r0, #1	; 0x1
 3f0cdd8:	e5823004 	str	r3, [r2, #4]
  }
 3f0cddc:	ea000036 	b	3f0cebc <malloc_extend_top+0x180>
  else
  {
    if (sbrk_base == (char*)(-1))  /* First time through. Record base */
 3f0cde0:	e59f1114 	ldr	r1, [pc, #114]	; 3f0cefc <malloc_extend_top+0x1c0>
 3f0cde4:	e5913000 	ldr	r3, [r1]
 3f0cde8:	e3730001 	cmn	r3, #1	; 0x1
      sbrk_base = brk;
 3f0cdec:	05815000 	streq	r5, [r1]
    else  /* Someone else called sbrk().  Count those bytes as sbrked_mem. */
      sbrked_mem += brk - (char*)old_end;
 3f0cdf0:	10643005 	rsbne	r3, r4, r5
 3f0cdf4:	10823003 	addne	r3, r2, r3
 3f0cdf8:	15893000 	strne	r3, [r9]

    /* Guarantee alignment of first new chunk made from this space */
    front_misalign = (unsigned long)chunk2mem(brk) & MALLOC_ALIGN_MASK;
 3f0cdfc:	e2853008 	add	r3, r5, #8	; 0x8
    if (front_misalign > 0)
 3f0ce00:	e2130007 	ands	r0, r3, #7	; 0x7
    {
      correction = (MALLOC_ALIGNMENT) - front_misalign;
 3f0ce04:	12604008 	rsbne	r4, r0, #8	; 0x8
      brk += correction;
 3f0ce08:	10855004 	addne	r5, r5, r4
    }
    else
      correction = 0;
 3f0ce0c:	01a04000 	moveq	r4, r0

    /* Guarantee the next brk will be at a page boundary */

    correction += ((((unsigned long)(brk + sbrk_size))+(pagesz-1)) &
 3f0ce10:	e0852006 	add	r2, r5, r6
 3f0ce14:	e2823eff 	add	r3, r2, #4080	; 0xff0
 3f0ce18:	e283300f 	add	r3, r3, #15	; 0xf
 3f0ce1c:	e3c33eff 	bic	r3, r3, #4080	; 0xff0
 3f0ce20:	e3c3300f 	bic	r3, r3, #15	; 0xf
 3f0ce24:	e0623003 	rsb	r3, r2, r3
 3f0ce28:	e0844003 	add	r4, r4, r3
		   ~(pagesz - 1)) - ((unsigned long)(brk + sbrk_size));

    /* Allocate correction */
    new_brk = (char*)(MORECORE (correction));
 3f0ce2c:	e1a00004 	mov	r0, r4
 3f0ce30:	ebffcefd 	bl	3f00a2c <sbrk>
    if (new_brk == (char*)(MORECORE_FAILURE)) return;
 3f0ce34:	e3700001 	cmn	r0, #1	; 0x1
 3f0ce38:	091baef0 	ldmeqdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

    sbrked_mem += correction;

    top = (mchunkptr)brk;
    top_size = new_brk - brk + correction;
 3f0ce3c:	e0653000 	rsb	r3, r5, r0
    set_head(top, top_size | PREV_INUSE);

    if (old_top != initial_top)
 3f0ce40:	e59f20b0 	ldr	r2, [pc, #b0]	; 3f0cef8 <malloc_extend_top+0x1bc>
 3f0ce44:	e0830004 	add	r0, r3, r4
 3f0ce48:	e5993000 	ldr	r3, [r9]
 3f0ce4c:	e15a0002 	cmp	r10, r2
 3f0ce50:	e5825008 	str	r5, [r2, #8]
 3f0ce54:	e0833004 	add	r3, r3, r4
 3f0ce58:	e5893000 	str	r3, [r9]
 3f0ce5c:	e3803001 	orr	r3, r0, #1	; 0x1
 3f0ce60:	e5853004 	str	r3, [r5, #4]
 3f0ce64:	0a000014 	beq	3f0cebc <malloc_extend_top+0x180>
    {

      /* There must have been an intervening foreign sbrk call. */
      /* A double fencepost is necessary to prevent consolidation */

      /* If not enough space to do this, then user did something very wrong */
      if (old_top_size < MINSIZE)
 3f0ce68:	e357000f 	cmp	r7, #15	; 0xf
      {
	set_head(top, PREV_INUSE); /* will force null return from malloc */
 3f0ce6c:	95922008 	ldrls	r2, [r2, #8]
 3f0ce70:	93a03001 	movls	r3, #1	; 0x1
 3f0ce74:	95823004 	strls	r3, [r2, #4]
	return;
 3f0ce78:	991baef0 	ldmlsdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
      }

      /* Also keep size a multiple of MALLOC_ALIGNMENT */
      old_top_size = (old_top_size - 3*SIZE_SZ) & ~MALLOC_ALIGN_MASK;
 3f0ce7c:	e247300c 	sub	r3, r7, #12	; 0xc
 3f0ce80:	e3c37007 	bic	r7, r3, #7	; 0x7
      set_head_size(old_top, old_top_size);
      chunk_at_offset(old_top, old_top_size          )->size =
	SIZE_SZ|PREV_INUSE;
      chunk_at_offset(old_top, old_top_size + SIZE_SZ)->size =
	SIZE_SZ|PREV_INUSE;
      /* If possible, release the rest. */
      if (old_top_size >= MINSIZE)
 3f0ce84:	e357000f 	cmp	r7, #15	; 0xf
 3f0ce88:	e3a01004 	mov	r1, #4	; 0x4
 3f0ce8c:	e59a3004 	ldr	r3, [r10, #4]
 3f0ce90:	e3a02005 	mov	r2, #5	; 0x5
 3f0ce94:	e2033001 	and	r3, r3, #1	; 0x1
 3f0ce98:	e1833007 	orr	r3, r3, r7
 3f0ce9c:	e58a3004 	str	r3, [r10, #4]
 3f0cea0:	e08a3007 	add	r3, r10, r7
 3f0cea4:	e7832001 	str	r2, [r3, r1]
 3f0cea8:	e0833001 	add	r3, r3, r1
 3f0ceac:	e5832004 	str	r2, [r3, #4]
 3f0ceb0:	9a000001 	bls	3f0cebc <malloc_extend_top+0x180>
	fREe(chunk2mem(old_top));
 3f0ceb4:	e28a0008 	add	r0, r10, #8	; 0x8
 3f0ceb8:	eb000128 	bl	3f0d360 <free>
    }
  }

  if ((unsigned long)sbrked_mem > (unsigned long)max_sbrked_mem)
 3f0cebc:	e59f303c 	ldr	r3, [pc, #3c]	; 3f0cf00 <malloc_extend_top+0x1c4>
 3f0cec0:	e59f203c 	ldr	r2, [pc, #3c]	; 3f0cf04 <malloc_extend_top+0x1c8>
 3f0cec4:	e5931000 	ldr	r1, [r3]
 3f0cec8:	e5923000 	ldr	r3, [r2]
 3f0cecc:	e1510003 	cmp	r1, r3
    max_sbrked_mem = sbrked_mem;
 3f0ced0:	85821000 	strhi	r1, [r2]
  if ((unsigned long)(mmapped_mem + sbrked_mem) > (unsigned long)max_total_mem)
 3f0ced4:	e59f302c 	ldr	r3, [pc, #2c]	; 3f0cf08 <malloc_extend_top+0x1cc>
 3f0ced8:	e59f002c 	ldr	r0, [pc, #2c]	; 3f0cf0c <malloc_extend_top+0x1d0>
 3f0cedc:	e5933000 	ldr	r3, [r3]
 3f0cee0:	e5902000 	ldr	r2, [r0]
 3f0cee4:	e0833001 	add	r3, r3, r1
 3f0cee8:	e1530002 	cmp	r3, r2
    max_total_mem = mmapped_mem + sbrked_mem;
 3f0ceec:	85803000 	strhi	r3, [r0]

  /* We always land on a page boundary */
  assert(((unsigned long)((char*)top + top_size) & (pagesz - 1)) == 0);
}
 3f0cef0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f0cef4:	03f20c88 	mvneqs	r0, #34816	; 0x8800
 3f0cef8:	03f2087c 	mvneqs	r0, #8126464	; 0x7c0000
 3f0cefc:	03f20c94 	mvneqs	r0, #37888	; 0x9400
 3f0cf00:	03f20ca0 	mvneqs	r0, #40960	; 0xa000
 3f0cf04:	03f20c98 	mvneqs	r0, #38912	; 0x9800
 3f0cf08:	03f20cc8 	mvneqs	r0, #51200	; 0xc800
 3f0cf0c:	03f20c9c 	mvneqs	r0, #39936	; 0x9c00

03f0cf10 <malloc>:
 3f0cf10:	e1a0c00d 	mov	r12, r13
 3f0cf14:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0cf18:	e24cb004 	sub	r11, r12, #4	; 0x4




/* Main public routines */


/*
  Malloc Algorthim:

    The requested size is first converted into a usable form, `nb'.
    This currently means to add 4 bytes overhead plus possibly more to
    obtain 8-byte alignment and/or to obtain a size of at least
    MINSIZE (currently 16 bytes), the smallest allocatable size.
    (All fits are considered `exact' if they are within MINSIZE bytes.)

    From there, the first successful of the following steps is taken:

      1. The bin corresponding to the request size is scanned, and if
	 a chunk of exactly the right size is found, it is taken.

      2. The most recently remaindered chunk is used if it is big
	 enough.  This is a form of (roving) first fit, used only in
	 the absence of exact fits. Runs of consecutive requests use
	 the remainder of the chunk used for the previous such request
	 whenever possible. This limited use of a first-fit style
	 allocation strategy tends to give contiguous chunks
	 coextensive lifetimes, which improves locality and can reduce
	 fragmentation in the long run.

      3. Other bins are scanned in increasing size order, using a
	 chunk big enough to fulfill the request, and splitting off
	 any remainder.  This search is strictly by best-fit; i.e.,
	 the smallest (with ties going to approximately the least
	 recently used) chunk that fits is selected.

      4. If large enough, the chunk bordering the end of memory
	 (`top') is split off. (This use of `top' is in accord with
	 the best-fit search rule.  In effect, `top' is treated as
	 larger (and thus less well fitting) than any other available
	 chunk since it can be extended to be as large as necessary
	 (up to system limitations).

      5. If the request size meets the mmap threshold and the
	 system supports mmap, and there are few enough currently
	 allocated mmapped regions, and a call to mmap succeeds,
	 the request is allocated via direct memory mapping.

      6. Otherwise, the top of memory is extended by
	 obtaining more space from the system (normally using sbrk,
	 but definable to anything else via the MORECORE macro).
	 Memory is gathered from the system (in system page-sized
	 units) in a way that allows chunks obtained across different
	 sbrk calls to be consolidated, but does not require
	 contiguous memory. Thus, it should be safe to intersperse
	 mallocs with other sbrk calls.


      All allocations are made from the the `lowest' part of any found
      chunk. (The implementation invariant is that prev_inuse is
      always true of any allocated chunk; i.e., that each allocated
      chunk borders either a previously allocated and still in-use chunk,
      or the base of its memory arena.)

*/

#if __STD_C
Void_t* mALLOc(size_t bytes)
#else
Void_t* mALLOc(bytes) size_t bytes;
#endif
{
  mchunkptr victim;                  /* inspected/selected chunk */
  INTERNAL_SIZE_T victim_size;       /* its size */
  int       idx;                     /* index for bin traversal */
  mbinptr   bin;                     /* associated bin */
  mchunkptr remainder;               /* remainder from a split */
  long      remainder_size;          /* its size */
  int       remainder_index;         /* its bin index */
  unsigned long block;               /* block traverser bit */
  int       startidx;                /* first bin of a traversed block */
  mchunkptr fwd;                     /* misc temp for linking */
  mchunkptr bck;                     /* misc temp for linking */
  mbinptr q;                         /* misc temp */

  INTERNAL_SIZE_T nb;

  if ((long)bytes < 0) return 0;
 3f0cf1c:	e3500000 	cmp	r0, #0	; 0x0
 3f0cf20:	ba0000e9 	blt	3f0d2cc <malloc+0x3bc>

  nb = request2size(bytes);  /* padded request size; */
 3f0cf24:	e280200b 	add	r2, r0, #11	; 0xb
 3f0cf28:	e3c23007 	bic	r3, r2, #7	; 0x7
 3f0cf2c:	e3520016 	cmp	r2, #22	; 0x16
 3f0cf30:	c1a0a003 	movgt	r10, r3
 3f0cf34:	d3a0a010 	movle	r10, #16	; 0x10

  /* Check for exact match in a bin */

  if (is_small_request(nb))  /* Faster version for small requests */
 3f0cf38:	e35a0f7e 	cmp	r10, #504	; 0x1f8
 3f0cf3c:	2a000015 	bcs	3f0cf98 <malloc+0x88>
  {
    idx = smallbin_index(nb);

    /* No traversal or size check necessary for small bins.  */

    q = bin_at(idx);
 3f0cf40:	e59f338c 	ldr	r3, [pc, #38c]	; 3f0d2d4 <malloc+0x3c4>
 3f0cf44:	e1a061aa 	mov	r6, r10, lsr #3
 3f0cf48:	e083c186 	add	r12, r3, r6, lsl #3
    victim = last(q);
 3f0cf4c:	e59c400c 	ldr	r4, [r12, #12]

    /* Also scan the next one, since it would have a remainder < MINSIZE */
    if (victim == q)
 3f0cf50:	e154000c 	cmp	r4, r12
    {
      q = next_bin(q);
 3f0cf54:	0284c008 	addeq	r12, r4, #8	; 0x8
      victim = last(q);
 3f0cf58:	059c400c 	ldreq	r4, [r12, #12]
    }
    if (victim != q)
 3f0cf5c:	e154000c 	cmp	r4, r12
 3f0cf60:	0a00000a 	beq	3f0cf90 <malloc+0x80>
    {
      victim_size = chunksize(victim);
 3f0cf64:	e9945008 	ldmib	r4, {r3, r12, r14}
      unlink(victim, bck, fwd);
      set_inuse_bit_at_offset(victim, victim_size);
 3f0cf68:	e3a01004 	mov	r1, #4	; 0x4
 3f0cf6c:	e58ce00c 	str	r14, [r12, #12]
 3f0cf70:	e3c30003 	bic	r0, r3, #3	; 0x3
 3f0cf74:	e58ec008 	str	r12, [r14, #8]
 3f0cf78:	e0842000 	add	r2, r4, r0
 3f0cf7c:	e7923001 	ldr	r3, [r2, r1]
      check_malloced_chunk(victim, nb);
      return chunk2mem(victim);
 3f0cf80:	e2840008 	add	r0, r4, #8	; 0x8
 3f0cf84:	e3833001 	orr	r3, r3, #1	; 0x1
 3f0cf88:	e7823001 	str	r3, [r2, r1]
 3f0cf8c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
    }

    idx += 2; /* Set for bin scan below. We've already scanned 2 bins. */
 3f0cf90:	e2866002 	add	r6, r6, #2	; 0x2

  }
 3f0cf94:	ea000026 	b	3f0d034 <malloc+0x124>
  else
  {
    idx = bin_index(nb);
 3f0cf98:	e1b024aa 	movs	r2, r10, lsr #9
 3f0cf9c:	01a061aa 	moveq	r6, r10, lsr #3
 3f0cfa0:	0a000013 	beq	3f0cff4 <malloc+0xe4>
 3f0cfa4:	e3520004 	cmp	r2, #4	; 0x4
 3f0cfa8:	91a0332a 	movls	r3, r10, lsr #6
 3f0cfac:	92836038 	addls	r6, r3, #56	; 0x38
 3f0cfb0:	9a00000f 	bls	3f0cff4 <malloc+0xe4>
 3f0cfb4:	e3520014 	cmp	r2, #20	; 0x14
 3f0cfb8:	9282605b 	addls	r6, r2, #91	; 0x5b
 3f0cfbc:	9a00000c 	bls	3f0cff4 <malloc+0xe4>
 3f0cfc0:	e3520054 	cmp	r2, #84	; 0x54
 3f0cfc4:	91a0362a 	movls	r3, r10, lsr #12
 3f0cfc8:	9283606e 	addls	r6, r3, #110	; 0x6e
 3f0cfcc:	9a000008 	bls	3f0cff4 <malloc+0xe4>
 3f0cfd0:	e3520f55 	cmp	r2, #340	; 0x154
 3f0cfd4:	91a037aa 	movls	r3, r10, lsr #15
 3f0cfd8:	92836077 	addls	r6, r3, #119	; 0x77
 3f0cfdc:	9a000004 	bls	3f0cff4 <malloc+0xe4>
 3f0cfe0:	e59f32f0 	ldr	r3, [pc, #2f0]	; 3f0d2d8 <malloc+0x3c8>
 3f0cfe4:	e1520003 	cmp	r2, r3
 3f0cfe8:	91a0392a 	movls	r3, r10, lsr #18
 3f0cfec:	9283607c 	addls	r6, r3, #124	; 0x7c
 3f0cff0:	83a0607e 	movhi	r6, #126	; 0x7e
    bin = bin_at(idx);
 3f0cff4:	e59f32d8 	ldr	r3, [pc, #2d8]	; 3f0d2d4 <malloc+0x3c4>
 3f0cff8:	e083e186 	add	r14, r3, r6, lsl #3

    for (victim = last(bin); victim != bin; victim = victim->bk)
 3f0cffc:	e59e400c 	ldr	r4, [r14, #12]
    {
      victim_size = chunksize(victim);
      remainder_size = victim_size - nb;

      if (remainder_size >= (long)MINSIZE) /* too big */
      {
	--idx; /* adjust to rescan below after checking last remainder */
	break;
 3f0d000:	ea000002 	b	3f0d010 <malloc+0x100>
      }

      else if (remainder_size >= 0) /* exact fit */
 3f0d004:	e3510000 	cmp	r1, #0	; 0x0
 3f0d008:	aa0000b4 	bge	3f0d2e0 <malloc+0x3d0>
 3f0d00c:	e594400c 	ldr	r4, [r4, #12]
 3f0d010:	e154000e 	cmp	r4, r14
 3f0d014:	0a000005 	beq	3f0d030 <malloc+0x120>
 3f0d018:	e5943004 	ldr	r3, [r4, #4]
 3f0d01c:	e3c30003 	bic	r0, r3, #3	; 0x3
 3f0d020:	e06a1000 	rsb	r1, r10, r0
 3f0d024:	e351000f 	cmp	r1, #15	; 0xf
 3f0d028:	dafffff5 	ble	3f0d004 <malloc+0xf4>
 3f0d02c:	e2466001 	sub	r6, r6, #1	; 0x1
      {
	unlink(victim, bck, fwd);
	set_inuse_bit_at_offset(victim, victim_size);
	check_malloced_chunk(victim, nb);
	return chunk2mem(victim);
      }
    }

    ++idx;
 3f0d030:	e2866001 	add	r6, r6, #1	; 0x1

  }

  /* Try to use the last split-off remainder */

  if ( (victim = last_remainder->fd) != last_remainder)
 3f0d034:	e59f92a0 	ldr	r9, [pc, #2a0]	; 3f0d2dc <malloc+0x3cc>
 3f0d038:	e5994008 	ldr	r4, [r9, #8]
 3f0d03c:	e1540009 	cmp	r4, r9
 3f0d040:	0a00004f 	beq	3f0d184 <malloc+0x274>
  {
    victim_size = chunksize(victim);
 3f0d044:	e5943004 	ldr	r3, [r4, #4]
 3f0d048:	e3c30003 	bic	r0, r3, #3	; 0x3
    remainder_size = victim_size - nb;
 3f0d04c:	e06a1000 	rsb	r1, r10, r0

    if (remainder_size >= (long)MINSIZE) /* re-split */
 3f0d050:	e351000f 	cmp	r1, #15	; 0xf
 3f0d054:	da00000b 	ble	3f0d088 <malloc+0x178>
    {
      remainder = chunk_at_offset(victim, nb);
      set_head(victim, nb | PREV_INUSE);
 3f0d058:	e38a3001 	orr	r3, r10, #1	; 0x1
 3f0d05c:	e5843004 	str	r3, [r4, #4]
 3f0d060:	e084200a 	add	r2, r4, r10
      link_last_remainder(remainder);
 3f0d064:	e589200c 	str	r2, [r9, #12]
 3f0d068:	e5892008 	str	r2, [r9, #8]
 3f0d06c:	e582900c 	str	r9, [r2, #12]
 3f0d070:	e5829008 	str	r9, [r2, #8]
      set_head(remainder, remainder_size | PREV_INUSE);
 3f0d074:	e3813001 	orr	r3, r1, #1	; 0x1
 3f0d078:	e5823004 	str	r3, [r2, #4]
      set_foot(remainder, remainder_size);
      check_malloced_chunk(victim, nb);
      return chunk2mem(victim);
 3f0d07c:	e2840008 	add	r0, r4, #8	; 0x8
 3f0d080:	e7821001 	str	r1, [r2, r1]
 3f0d084:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
    }

    clear_last_remainder;
 3f0d088:	e589900c 	str	r9, [r9, #12]

    if (remainder_size >= 0)  /* exhaust */
 3f0d08c:	e3510000 	cmp	r1, #0	; 0x0
 3f0d090:	e5899008 	str	r9, [r9, #8]
    {
      set_inuse_bit_at_offset(victim, victim_size);
 3f0d094:	a3a01004 	movge	r1, #4	; 0x4
      check_malloced_chunk(victim, nb);
      return chunk2mem(victim);
 3f0d098:	aaffffb6 	bge	3f0cf78 <malloc+0x68>
    }

    /* Else place in bin */

    frontlink(victim, victim_size, remainder_index, bck, fwd);
 3f0d09c:	e3500c02 	cmp	r0, #512	; 0x200
 3f0d0a0:	2a000009 	bcs	3f0d0cc <malloc+0x1bc>
 3f0d0a4:	e1a051a0 	mov	r5, r0, lsr #3
 3f0d0a8:	e2491008 	sub	r1, r9, #8	; 0x8
 3f0d0ac:	e1a00125 	mov	r0, r5, lsr #2
 3f0d0b0:	e5913004 	ldr	r3, [r1, #4]
 3f0d0b4:	e3a02001 	mov	r2, #1	; 0x1
 3f0d0b8:	e1833012 	orr	r3, r3, r2, lsl r0
 3f0d0bc:	e5813004 	str	r3, [r1, #4]
 3f0d0c0:	e081e185 	add	r14, r1, r5, lsl #3
 3f0d0c4:	e59ec008 	ldr	r12, [r14, #8]
 3f0d0c8:	ea000029 	b	3f0d174 <malloc+0x264>
 3f0d0cc:	e1b024a0 	movs	r2, r0, lsr #9
 3f0d0d0:	01a051a0 	moveq	r5, r0, lsr #3
 3f0d0d4:	0a000013 	beq	3f0d128 <malloc+0x218>
 3f0d0d8:	e3520004 	cmp	r2, #4	; 0x4
 3f0d0dc:	91a03320 	movls	r3, r0, lsr #6
 3f0d0e0:	92835038 	addls	r5, r3, #56	; 0x38
 3f0d0e4:	9a00000f 	bls	3f0d128 <malloc+0x218>
 3f0d0e8:	e3520014 	cmp	r2, #20	; 0x14
 3f0d0ec:	9282505b 	addls	r5, r2, #91	; 0x5b
 3f0d0f0:	9a00000c 	bls	3f0d128 <malloc+0x218>
 3f0d0f4:	e3520054 	cmp	r2, #84	; 0x54
 3f0d0f8:	91a03620 	movls	r3, r0, lsr #12
 3f0d0fc:	9283506e 	addls	r5, r3, #110	; 0x6e
 3f0d100:	9a000008 	bls	3f0d128 <malloc+0x218>
 3f0d104:	e3520f55 	cmp	r2, #340	; 0x154
 3f0d108:	91a037a0 	movls	r3, r0, lsr #15
 3f0d10c:	92835077 	addls	r5, r3, #119	; 0x77
 3f0d110:	9a000004 	bls	3f0d128 <malloc+0x218>
 3f0d114:	e59f31bc 	ldr	r3, [pc, #1bc]	; 3f0d2d8 <malloc+0x3c8>
 3f0d118:	e1520003 	cmp	r2, r3
 3f0d11c:	91a03920 	movls	r3, r0, lsr #18
 3f0d120:	9283507c 	addls	r5, r3, #124	; 0x7c
 3f0d124:	83a0507e 	movhi	r5, #126	; 0x7e
 3f0d128:	e59f71a4 	ldr	r7, [pc, #1a4]	; 3f0d2d4 <malloc+0x3c4>
 3f0d12c:	e087e185 	add	r14, r7, r5, lsl #3
 3f0d130:	e59ec008 	ldr	r12, [r14, #8]
 3f0d134:	e15c000e 	cmp	r12, r14
 3f0d138:	1a000008 	bne	3f0d160 <malloc+0x250>
 3f0d13c:	e1a03125 	mov	r3, r5, lsr #2
 3f0d140:	e5972004 	ldr	r2, [r7, #4]
 3f0d144:	e3a01001 	mov	r1, #1	; 0x1
 3f0d148:	e1822311 	orr	r2, r2, r1, lsl r3
 3f0d14c:	e5872004 	str	r2, [r7, #4]
 3f0d150:	ea000007 	b	3f0d174 <malloc+0x264>
 3f0d154:	e59cc008 	ldr	r12, [r12, #8]
 3f0d158:	e15c000e 	cmp	r12, r14
 3f0d15c:	0a000003 	beq	3f0d170 <malloc+0x260>
 3f0d160:	e59c3004 	ldr	r3, [r12, #4]
 3f0d164:	e3c33003 	bic	r3, r3, #3	; 0x3
 3f0d168:	e1500003 	cmp	r0, r3
 3f0d16c:	3afffff8 	bcc	3f0d154 <malloc+0x244>
 3f0d170:	e59ce00c 	ldr	r14, [r12, #12]
 3f0d174:	e584e00c 	str	r14, [r4, #12]
 3f0d178:	e584c008 	str	r12, [r4, #8]
 3f0d17c:	e58e4008 	str	r4, [r14, #8]
 3f0d180:	e58c400c 	str	r4, [r12, #12]
  }

  /*
     If there are any possibly nonempty big-enough blocks,
     search for best fitting chunk by scanning bins in blockwidth units.
  */

  if ( (block = idx2binblock(idx)) <= binblocks)
 3f0d184:	e3560000 	cmp	r6, #0	; 0x0
 3f0d188:	b2863003 	addlt	r3, r6, #3	; 0x3
 3f0d18c:	a1a03006 	movge	r3, r6
 3f0d190:	e1a03143 	mov	r3, r3, asr #2
 3f0d194:	e59f2138 	ldr	r2, [pc, #138]	; 3f0d2d4 <malloc+0x3c4>
 3f0d198:	e3a01001 	mov	r1, #1	; 0x1
 3f0d19c:	e5920004 	ldr	r0, [r2, #4]
 3f0d1a0:	e1a02311 	mov	r2, r1, lsl r3
 3f0d1a4:	e1520000 	cmp	r2, r0
 3f0d1a8:	8a000038 	bhi	3f0d290 <malloc+0x380>
  {

    /* Get to the first marked block */

    if ( (block & binblocks) == 0)
 3f0d1ac:	e1120000 	tst	r2, r0
 3f0d1b0:	1a000008 	bne	3f0d1d8 <malloc+0x2c8>
    {
      /* force to an even block boundary */
      idx = (idx & ~(BINBLOCKWIDTH - 1)) + BINBLOCKWIDTH;
 3f0d1b4:	e3c63003 	bic	r3, r6, #3	; 0x3
 3f0d1b8:	e2836004 	add	r6, r3, #4	; 0x4
      block <<= 1;
 3f0d1bc:	e1a02112 	mov	r2, r2, lsl r1
      while ((block & binblocks) == 0)
 3f0d1c0:	e1120000 	tst	r2, r0
 3f0d1c4:	1a000003 	bne	3f0d1d8 <malloc+0x2c8>
      {
	idx += BINBLOCKWIDTH;
 3f0d1c8:	e2866004 	add	r6, r6, #4	; 0x4
	block <<= 1;
 3f0d1cc:	e1a02082 	mov	r2, r2, lsl #1
      }
 3f0d1d0:	e1120000 	tst	r2, r0
 3f0d1d4:	0afffffb 	beq	3f0d1c8 <malloc+0x2b8>
    }

    /* For each possibly nonempty block ... */
    for (;;)
    {
      startidx = idx;          /* (track incomplete blocks) */
      q = bin = bin_at(idx);
 3f0d1d8:	e59f70f4 	ldr	r7, [pc, #f4]	; 3f0d2d4 <malloc+0x3c4>
 3f0d1dc:	e1a05006 	mov	r5, r6
 3f0d1e0:	e087c186 	add	r12, r7, r6, lsl #3
 3f0d1e4:	e1a0e00c 	mov	r14, r12

      /* For each bin in this block ... */
      do
      {
	/* Find and use first big enough chunk ... */

	for (victim = last(bin); victim != bin; victim = victim->bk)
 3f0d1e8:	e59e400c 	ldr	r4, [r14, #12]
 3f0d1ec:	e154000e 	cmp	r4, r14
 3f0d1f0:	0a000009 	beq	3f0d21c <malloc+0x30c>
	{
	  victim_size = chunksize(victim);
 3f0d1f4:	e5943004 	ldr	r3, [r4, #4]
 3f0d1f8:	e3c30003 	bic	r0, r3, #3	; 0x3
	  remainder_size = victim_size - nb;
 3f0d1fc:	e06a1000 	rsb	r1, r10, r0

	  if (remainder_size >= (long)MINSIZE) /* split */
 3f0d200:	e351000f 	cmp	r1, #15	; 0xf
 3f0d204:	ca00003a 	bgt	3f0d2f4 <malloc+0x3e4>
	  {
	    remainder = chunk_at_offset(victim, nb);
	    set_head(victim, nb | PREV_INUSE);
	    unlink(victim, bck, fwd);
	    link_last_remainder(remainder);
	    set_head(remainder, remainder_size | PREV_INUSE);
	    set_foot(remainder, remainder_size);
	    check_malloced_chunk(victim, nb);
	    return chunk2mem(victim);
	  }

	  else if (remainder_size >= 0)  /* take */
 3f0d208:	e3510000 	cmp	r1, #0	; 0x0
 3f0d20c:	aa00003f 	bge	3f0d310 <malloc+0x400>
 3f0d210:	e594400c 	ldr	r4, [r4, #12]
 3f0d214:	e154000e 	cmp	r4, r14
 3f0d218:	1afffff5 	bne	3f0d1f4 <malloc+0x2e4>
	  {
	    set_inuse_bit_at_offset(victim, victim_size);
	    unlink(victim, bck, fwd);
	    check_malloced_chunk(victim, nb);
	    return chunk2mem(victim);
	  }

	}

       bin = next_bin(bin);
 3f0d21c:	e28ee008 	add	r14, r14, #8	; 0x8

      } while ((++idx & (BINBLOCKWIDTH - 1)) != 0);
 3f0d220:	e2866001 	add	r6, r6, #1	; 0x1
 3f0d224:	e3160003 	tst	r6, #3	; 0x3
 3f0d228:	1affffee 	bne	3f0d1e8 <malloc+0x2d8>

      /* Clear out the block bit. */

      do   /* Possibly backtrack to try to clear a partial block */
      {
	if ((startidx & (BINBLOCKWIDTH - 1)) == 0)
 3f0d22c:	e3150003 	tst	r5, #3	; 0x3
 3f0d230:	0a000012 	beq	3f0d280 <malloc+0x370>
	{
	  binblocks &= ~block;
	  break;
	}
	--startidx;
       q = prev_bin(q);
 3f0d234:	e24cc008 	sub	r12, r12, #8	; 0x8
      } while (first(q) == q);
 3f0d238:	e59c3008 	ldr	r3, [r12, #8]
 3f0d23c:	e2455001 	sub	r5, r5, #1	; 0x1
 3f0d240:	e153000c 	cmp	r3, r12
 3f0d244:	0afffff8 	beq	3f0d22c <malloc+0x31c>

      /* Get to the next possibly nonempty block */

      if ( (block <<= 1) <= binblocks && (block != 0) )
 3f0d248:	e59f3084 	ldr	r3, [pc, #84]	; 3f0d2d4 <malloc+0x3c4>
 3f0d24c:	e5933004 	ldr	r3, [r3, #4]
 3f0d250:	e1a02082 	mov	r2, r2, lsl #1
 3f0d254:	e1520003 	cmp	r2, r3
 3f0d258:	8a00000c 	bhi	3f0d290 <malloc+0x380>
 3f0d25c:	e3520000 	cmp	r2, #0	; 0x0
 3f0d260:	0a00000a 	beq	3f0d290 <malloc+0x380>
      {
	while ((block & binblocks) == 0)
 3f0d264:	e1120003 	tst	r2, r3
 3f0d268:	1affffda 	bne	3f0d1d8 <malloc+0x2c8>
	{
	  idx += BINBLOCKWIDTH;
 3f0d26c:	e2866004 	add	r6, r6, #4	; 0x4
	  block <<= 1;
 3f0d270:	e1a02082 	mov	r2, r2, lsl #1
	}
 3f0d274:	e1120003 	tst	r2, r3
 3f0d278:	0afffffb 	beq	3f0d26c <malloc+0x35c>
 3f0d27c:	eaffffd5 	b	3f0d1d8 <malloc+0x2c8>
 3f0d280:	e5973004 	ldr	r3, [r7, #4]
 3f0d284:	e1c33002 	bic	r3, r3, r2
 3f0d288:	e5873004 	str	r3, [r7, #4]
 3f0d28c:	eaffffed 	b	3f0d248 <malloc+0x338>
      }
      else
	break;
    }
  }


  /* Try to use top chunk */

  /* Require that there be a remainder, ensuring top always exists  */
  if ( (remainder_size = chunksize(top) - nb) < (long)MINSIZE)
 3f0d290:	e59f503c 	ldr	r5, [pc, #3c]	; 3f0d2d4 <malloc+0x3c4>
 3f0d294:	e5953008 	ldr	r3, [r5, #8]
 3f0d298:	e5933004 	ldr	r3, [r3, #4]
 3f0d29c:	e3c33003 	bic	r3, r3, #3	; 0x3
 3f0d2a0:	e06a1003 	rsb	r1, r10, r3
 3f0d2a4:	e351000f 	cmp	r1, #15	; 0xf
 3f0d2a8:	ca000023 	bgt	3f0d33c <malloc+0x42c>
  {

#if HAVE_MMAP
    /* If big and would otherwise need to extend, try to use mmap instead */
    if ((unsigned long)nb >= (unsigned long)mmap_threshold &&
	(victim = mmap_chunk(nb)) != 0)
      return chunk2mem(victim);
#endif

    /* Try to extend */
    malloc_extend_top(nb);
 3f0d2ac:	e1a0000a 	mov	r0, r10
 3f0d2b0:	ebfffea1 	bl	3f0cd3c <malloc_extend_top>
    if ( (remainder_size = chunksize(top) - nb) < (long)MINSIZE)
 3f0d2b4:	e5953008 	ldr	r3, [r5, #8]
 3f0d2b8:	e5933004 	ldr	r3, [r3, #4]
 3f0d2bc:	e3c33003 	bic	r3, r3, #3	; 0x3
 3f0d2c0:	e06a1003 	rsb	r1, r10, r3
 3f0d2c4:	e351000f 	cmp	r1, #15	; 0xf
 3f0d2c8:	ca00001b 	bgt	3f0d33c <malloc+0x42c>
      return 0; /* propagate failure */
 3f0d2cc:	e3a00000 	mov	r0, #0	; 0x0
 3f0d2d0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f0d2d4:	03f2087c 	mvneqs	r0, #8126464	; 0x7c0000
 3f0d2d8:	00000554 	andeq	r0, r0, r4, asr r5
 3f0d2dc:	03f20884 	mvneqs	r0, #8650752	; 0x840000
 3f0d2e0:	e284c008 	add	r12, r4, #8	; 0x8
 3f0d2e4:	e89c5000 	ldmia	r12, {r12, r14}
 3f0d2e8:	e58ce00c 	str	r14, [r12, #12]
 3f0d2ec:	e3a01004 	mov	r1, #4	; 0x4
 3f0d2f0:	eaffff1f 	b	3f0cf74 <malloc+0x64>
 3f0d2f4:	e284c008 	add	r12, r4, #8	; 0x8
 3f0d2f8:	e89c5000 	ldmia	r12, {r12, r14}
 3f0d2fc:	e38a3001 	orr	r3, r10, #1	; 0x1
 3f0d300:	e5843004 	str	r3, [r4, #4]
 3f0d304:	e58ce00c 	str	r14, [r12, #12]
 3f0d308:	e58ec008 	str	r12, [r14, #8]
 3f0d30c:	eaffff53 	b	3f0d060 <malloc+0x150>
 3f0d310:	e3a01004 	mov	r1, #4	; 0x4
 3f0d314:	e0842000 	add	r2, r4, r0
 3f0d318:	e7923001 	ldr	r3, [r2, r1]
 3f0d31c:	e3833001 	orr	r3, r3, #1	; 0x1
 3f0d320:	e7823001 	str	r3, [r2, r1]
 3f0d324:	e284c008 	add	r12, r4, #8	; 0x8
 3f0d328:	e89c5000 	ldmia	r12, {r12, r14}
 3f0d32c:	e58ce00c 	str	r14, [r12, #12]
 3f0d330:	e2840008 	add	r0, r4, #8	; 0x8
 3f0d334:	e58ec008 	str	r12, [r14, #8]
 3f0d338:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
  }

  victim = top;
 3f0d33c:	e5954008 	ldr	r4, [r5, #8]
  set_head(victim, nb | PREV_INUSE);
 3f0d340:	e38a3001 	orr	r3, r10, #1	; 0x1
  top = chunk_at_offset(victim, nb);
  set_head(top, remainder_size | PREV_INUSE);
  check_malloced_chunk(victim, nb);
  return chunk2mem(victim);
 3f0d344:	e2840008 	add	r0, r4, #8	; 0x8
 3f0d348:	e5843004 	str	r3, [r4, #4]
 3f0d34c:	e084200a 	add	r2, r4, r10
 3f0d350:	e5852008 	str	r2, [r5, #8]
 3f0d354:	e3813001 	orr	r3, r1, #1	; 0x1
 3f0d358:	e5823004 	str	r3, [r2, #4]

}
 3f0d35c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0d360 <free>:
 3f0d360:	e1a0c00d 	mov	r12, r13
 3f0d364:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f0d368:	e24cb004 	sub	r11, r12, #4	; 0x4




/*

  free() algorithm :

    cases:

       1. free(0) has no effect.

       2. If the chunk was allocated via mmap, it is release via munmap().

       3. If a returned chunk borders the current high end of memory,
	  it is consolidated into the top, and if the total unused
	  topmost memory exceeds the trim threshold, malloc_trim is
	  called.

       4. Other chunks are consolidated as they arrive, and
	  placed in corresponding bins. (This includes the case of
	  consolidating with the current `last_remainder').

*/


#if __STD_C
void fREe(Void_t* mem)
#else
void fREe(mem) Void_t* mem;
#endif
{
  mchunkptr p;         /* chunk corresponding to mem */
  INTERNAL_SIZE_T hd;  /* its head field */
  INTERNAL_SIZE_T sz;  /* its size */
  int       idx;       /* its bin index */
  mchunkptr next;      /* next contiguous chunk */
  INTERNAL_SIZE_T nextsz; /* its size */
  INTERNAL_SIZE_T prevsz; /* size of previous contiguous chunk */
  mchunkptr bck;       /* misc temp for linking */
  mchunkptr fwd;       /* misc temp for linking */
  int       islr;      /* track whether merging with last_remainder */

  if (mem == 0)                              /* free(0) has no effect */
 3f0d36c:	e3500000 	cmp	r0, #0	; 0x0
 3f0d370:	091bacf0 	ldmeqdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
    return;

  p = mem2chunk(mem);
 3f0d374:	e2404008 	sub	r4, r0, #8	; 0x8
  hd = p->size;
 3f0d378:	e594c004 	ldr	r12, [r4, #4]

#if HAVE_MMAP
  if (hd & IS_MMAPPED)                       /* release mmapped memory. */
  {
    munmap_chunk(p);
    return;
  }
#endif

  check_inuse_chunk(p);

  sz = hd & ~PREV_INUSE;
  next = chunk_at_offset(p, sz);
  nextsz = chunksize(next);

  if (next == top)                            /* merge with top */
 3f0d37c:	e59fa1f4 	ldr	r10, [pc, #1f4]	; 3f0d578 <free+0x218>
 3f0d380:	e3cc1001 	bic	r1, r12, #1	; 0x1
 3f0d384:	e59a2008 	ldr	r2, [r10, #8]
 3f0d388:	e0845001 	add	r5, r4, r1
 3f0d38c:	e5953004 	ldr	r3, [r5, #4]
 3f0d390:	e1550002 	cmp	r5, r2
 3f0d394:	e3c36003 	bic	r6, r3, #3	; 0x3
 3f0d398:	1a000014 	bne	3f0d3f0 <free+0x90>
  {
    sz += nextsz;
 3f0d39c:	e0811006 	add	r1, r1, r6

    if (!(hd & PREV_INUSE))                    /* consolidate backward */
 3f0d3a0:	e31c0001 	tst	r12, #1	; 0x1
 3f0d3a4:	1a000006 	bne	3f0d3c4 <free+0x64>
    {
      prevsz = p->prev_size;
 3f0d3a8:	e5100008 	ldr	r0, [r0, -#8]
      p = chunk_at_offset(p, -((long) prevsz));
 3f0d3ac:	e0604004 	rsb	r4, r0, r4
      sz += prevsz;
      unlink(p, bck, fwd);
 3f0d3b0:	e284c008 	add	r12, r4, #8	; 0x8
 3f0d3b4:	e89c5000 	ldmia	r12, {r12, r14}
 3f0d3b8:	e58ce00c 	str	r14, [r12, #12]
 3f0d3bc:	e0811000 	add	r1, r1, r0
 3f0d3c0:	e58ec008 	str	r12, [r14, #8]
    }

    set_head(p, sz | PREV_INUSE);
 3f0d3c4:	e3813001 	orr	r3, r1, #1	; 0x1
 3f0d3c8:	e5843004 	str	r3, [r4, #4]
    top = p;
    if ((unsigned long)(sz) >= (unsigned long)trim_threshold)
 3f0d3cc:	e59f31a8 	ldr	r3, [pc, #1a8]	; 3f0d57c <free+0x21c>
 3f0d3d0:	e5933000 	ldr	r3, [r3]
 3f0d3d4:	e58a4008 	str	r4, [r10, #8]
 3f0d3d8:	e1510003 	cmp	r1, r3
 3f0d3dc:	391bacf0 	ldmccdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
      malloc_trim(top_pad);
 3f0d3e0:	e59f3198 	ldr	r3, [pc, #198]	; 3f0d580 <free+0x220>
 3f0d3e4:	e5930000 	ldr	r0, [r3]
 3f0d3e8:	eb00021e 	bl	3f0dc68 <malloc_trim>
    return;
 3f0d3ec:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
  }

  set_head(next, nextsz);                    /* clear inuse bit */

  islr = 0;
 3f0d3f0:	e3a07000 	mov	r7, #0	; 0x0

  if (!(hd & PREV_INUSE))                    /* consolidate backward */
 3f0d3f4:	e31c0001 	tst	r12, #1	; 0x1
 3f0d3f8:	e5856004 	str	r6, [r5, #4]
 3f0d3fc:	1a00000a 	bne	3f0d42c <free+0xcc>
  {
    prevsz = p->prev_size;
 3f0d400:	e5100008 	ldr	r0, [r0, -#8]
    p = chunk_at_offset(p, -((long) prevsz));
    sz += prevsz;

    if (p->fd == last_remainder)             /* keep as last_remainder */
 3f0d404:	e28a3008 	add	r3, r10, #8	; 0x8
 3f0d408:	e0604004 	rsb	r4, r0, r4
 3f0d40c:	e5942008 	ldr	r2, [r4, #8]
 3f0d410:	e0811000 	add	r1, r1, r0
 3f0d414:	e1520003 	cmp	r2, r3
      islr = 1;
 3f0d418:	02877001 	addeq	r7, r7, #1	; 0x1
    else
      unlink(p, bck, fwd);
 3f0d41c:	1594e00c 	ldrne	r14, [r4, #12]
 3f0d420:	11a0c002 	movne	r12, r2
 3f0d424:	158ce00c 	strne	r14, [r12, #12]
 3f0d428:	158ec008 	strne	r12, [r14, #8]
  }

  if (!(inuse_bit_at_offset(next, nextsz)))   /* consolidate forward */
 3f0d42c:	e0853006 	add	r3, r5, r6
 3f0d430:	e5933004 	ldr	r3, [r3, #4]
 3f0d434:	e3130001 	tst	r3, #1	; 0x1
 3f0d438:	1a000010 	bne	3f0d480 <free+0x120>
  {
    sz += nextsz;
 3f0d43c:	e0811006 	add	r1, r1, r6

    if (!islr && next->fd == last_remainder)  /* re-insert last_remainder */
 3f0d440:	e3570000 	cmp	r7, #0	; 0x0
 3f0d444:	1a000009 	bne	3f0d470 <free+0x110>
 3f0d448:	e5952008 	ldr	r2, [r5, #8]
 3f0d44c:	e59f3130 	ldr	r3, [pc, #130]	; 3f0d584 <free+0x224>
 3f0d450:	e1520003 	cmp	r2, r3
 3f0d454:	1a000005 	bne	3f0d470 <free+0x110>
    {
      islr = 1;
      link_last_remainder(p);
 3f0d458:	e582400c 	str	r4, [r2, #12]
 3f0d45c:	e5824008 	str	r4, [r2, #8]
 3f0d460:	e584200c 	str	r2, [r4, #12]
 3f0d464:	e3a07001 	mov	r7, #1	; 0x1
 3f0d468:	e5842008 	str	r2, [r4, #8]
    }
 3f0d46c:	ea000003 	b	3f0d480 <free+0x120>
    else
      unlink(next, bck, fwd);
 3f0d470:	e285c008 	add	r12, r5, #8	; 0x8
 3f0d474:	e89c5000 	ldmia	r12, {r12, r14}
 3f0d478:	e58ce00c 	str	r14, [r12, #12]
 3f0d47c:	e58ec008 	str	r12, [r14, #8]
  }


  set_head(p, sz | PREV_INUSE);
 3f0d480:	e3813001 	orr	r3, r1, #1	; 0x1
 3f0d484:	e5843004 	str	r3, [r4, #4]
  set_foot(p, sz);
  if (!islr)
 3f0d488:	e3570000 	cmp	r7, #0	; 0x0
 3f0d48c:	e7841001 	str	r1, [r4, r1]
 3f0d490:	191bacf0 	ldmnedb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
    frontlink(p, sz, idx, bck, fwd);
 3f0d494:	e3510c02 	cmp	r1, #512	; 0x200
 3f0d498:	2a00000c 	bcs	3f0d4d0 <free+0x170>
 3f0d49c:	e1a001a1 	mov	r0, r1, lsr #3
 3f0d4a0:	e1a03120 	mov	r3, r0, lsr #2
 3f0d4a4:	e59a2004 	ldr	r2, [r10, #4]
 3f0d4a8:	e3a01001 	mov	r1, #1	; 0x1
 3f0d4ac:	e1822311 	orr	r2, r2, r1, lsl r3
 3f0d4b0:	e58a2004 	str	r2, [r10, #4]
 3f0d4b4:	e08ae180 	add	r14, r10, r0, lsl #3
 3f0d4b8:	e59ec008 	ldr	r12, [r14, #8]
 3f0d4bc:	e584e00c 	str	r14, [r4, #12]
 3f0d4c0:	e584c008 	str	r12, [r4, #8]
 3f0d4c4:	e58e4008 	str	r4, [r14, #8]
 3f0d4c8:	e58c400c 	str	r4, [r12, #12]
 3f0d4cc:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f0d4d0:	e1b024a1 	movs	r2, r1, lsr #9
 3f0d4d4:	01a001a1 	moveq	r0, r1, lsr #3
 3f0d4d8:	0a000013 	beq	3f0d52c <free+0x1cc>
 3f0d4dc:	e3520004 	cmp	r2, #4	; 0x4
 3f0d4e0:	91a03321 	movls	r3, r1, lsr #6
 3f0d4e4:	92830038 	addls	r0, r3, #56	; 0x38
 3f0d4e8:	9a00000f 	bls	3f0d52c <free+0x1cc>
 3f0d4ec:	e3520014 	cmp	r2, #20	; 0x14
 3f0d4f0:	9282005b 	addls	r0, r2, #91	; 0x5b
 3f0d4f4:	9a00000c 	bls	3f0d52c <free+0x1cc>
 3f0d4f8:	e3520054 	cmp	r2, #84	; 0x54
 3f0d4fc:	91a03621 	movls	r3, r1, lsr #12
 3f0d500:	9283006e 	addls	r0, r3, #110	; 0x6e
 3f0d504:	9a000008 	bls	3f0d52c <free+0x1cc>
 3f0d508:	e3520f55 	cmp	r2, #340	; 0x154
 3f0d50c:	91a037a1 	movls	r3, r1, lsr #15
 3f0d510:	92830077 	addls	r0, r3, #119	; 0x77
 3f0d514:	9a000004 	bls	3f0d52c <free+0x1cc>
 3f0d518:	e59f3068 	ldr	r3, [pc, #68]	; 3f0d588 <free+0x228>
 3f0d51c:	e1520003 	cmp	r2, r3
 3f0d520:	91a03921 	movls	r3, r1, lsr #18
 3f0d524:	9283007c 	addls	r0, r3, #124	; 0x7c
 3f0d528:	83a0007e 	movhi	r0, #126	; 0x7e
 3f0d52c:	e08ae180 	add	r14, r10, r0, lsl #3
 3f0d530:	e59ec008 	ldr	r12, [r14, #8]
 3f0d534:	e15c000e 	cmp	r12, r14
 3f0d538:	1a000008 	bne	3f0d560 <free+0x200>
 3f0d53c:	e1a03120 	mov	r3, r0, lsr #2
 3f0d540:	e59a2004 	ldr	r2, [r10, #4]
 3f0d544:	e3a01001 	mov	r1, #1	; 0x1
 3f0d548:	e1822311 	orr	r2, r2, r1, lsl r3
 3f0d54c:	e58a2004 	str	r2, [r10, #4]
 3f0d550:	eaffffd9 	b	3f0d4bc <free+0x15c>
 3f0d554:	e59cc008 	ldr	r12, [r12, #8]
 3f0d558:	e15c000e 	cmp	r12, r14
 3f0d55c:	0a000003 	beq	3f0d570 <free+0x210>
 3f0d560:	e59c3004 	ldr	r3, [r12, #4]
 3f0d564:	e3c33003 	bic	r3, r3, #3	; 0x3
 3f0d568:	e1510003 	cmp	r1, r3
 3f0d56c:	3afffff8 	bcc	3f0d554 <free+0x1f4>
 3f0d570:	e59ce00c 	ldr	r14, [r12, #12]
}
 3f0d574:	eaffffd0 	b	3f0d4bc <free+0x15c>
 3f0d578:	03f2087c 	mvneqs	r0, #8126464	; 0x7c0000
 3f0d57c:	03f20c84 	mvneqs	r0, #33792	; 0x8400
 3f0d580:	03f20c88 	mvneqs	r0, #34816	; 0x8800
 3f0d584:	03f20884 	mvneqs	r0, #8650752	; 0x840000
 3f0d588:	00000554 	andeq	r0, r0, r4, asr r5

03f0d58c <realloc>:
 3f0d58c:	e1a0c00d 	mov	r12, r13
 3f0d590:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0d594:	e24cb004 	sub	r11, r12, #4	; 0x4





/*

  Realloc algorithm:

    Chunks that were obtained via mmap cannot be extended or shrunk
    unless HAVE_MREMAP is defined, in which case mremap is used.
    Otherwise, if their reallocation is for additional space, they are
    copied.  If for less, they are just left alone.

    Otherwise, if the reallocation is for additional space, and the
    chunk can be extended, it is, else a malloc-copy-free sequence is
    taken.  There are several different ways that a chunk could be
    extended. All are tried:

       * Extending forward into following adjacent free chunk.
       * Shifting backwards, joining preceding adjacent space
       * Both shifting backwards and extending forward.
       * Extending into newly sbrked space

    Unless the #define REALLOC_ZERO_BYTES_FREES is set, realloc with a
    size argument of zero (re)allocates a minimum-sized chunk.

    If the reallocation is for less space, and the new request is for
    a `small' (<512 bytes) size, then the newly unused space is lopped
    off and freed.

    The old unix realloc convention of allowing the last-free'd chunk
    to be used as an argument to realloc is no longer supported.
    I don't know of any programs still relying on this feature,
    and allowing it would also allow too many other incorrect
    usages of realloc to be sensible.


*/


#if __STD_C
Void_t* rEALLOc(Void_t* oldmem, size_t bytes)
#else
Void_t* rEALLOc(oldmem, bytes) Void_t* oldmem; size_t bytes;
#endif
{
 3f0d598:	e1a07000 	mov	r7, r0
  INTERNAL_SIZE_T    nb;      /* padded request size */

  mchunkptr oldp;             /* chunk corresponding to oldmem */
  INTERNAL_SIZE_T    oldsize; /* its size */

  mchunkptr newp;             /* chunk to return */
  INTERNAL_SIZE_T    newsize; /* its size */
  Void_t*   newmem;           /* corresponding user mem */

  mchunkptr next;             /* next contiguous chunk after oldp */
  INTERNAL_SIZE_T  nextsize;  /* its size */

  mchunkptr prev;             /* previous contiguous chunk before oldp */
  INTERNAL_SIZE_T  prevsize;  /* its size */

  mchunkptr remainder;        /* holds split off extra space from newp */
  INTERNAL_SIZE_T  remainder_size;   /* its size */

  mchunkptr bck;              /* misc temp for linking */
  mchunkptr fwd;              /* misc temp for linking */

#ifdef REALLOC_ZERO_BYTES_FREES
  if (bytes == 0) { fREe(oldmem); return 0; }
#endif

  if ((long)bytes < 0) return 0;
 3f0d59c:	e2510000 	subs	r0, r1, #0	; 0x0
 3f0d5a0:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f0d5a4:	ba0000c9 	blt	3f0d8d0 <realloc+0x344>

  /* realloc of null is supposed to be same as malloc */
  if (oldmem == 0) return mALLOc(bytes);
 3f0d5a8:	e3570000 	cmp	r7, #0	; 0x0
 3f0d5ac:	1a000001 	bne	3f0d5b8 <realloc+0x2c>
 3f0d5b0:	ebfffe56 	bl	3f0cf10 <malloc>
 3f0d5b4:	ea000114 	b	3f0da0c <realloc+0x480>

  newp    = oldp    = mem2chunk(oldmem);
 3f0d5b8:	e2474008 	sub	r4, r7, #8	; 0x8
  newsize = oldsize = chunksize(oldp);


  nb = request2size(bytes);
 3f0d5bc:	e280200b 	add	r2, r0, #11	; 0xb
 3f0d5c0:	e3520016 	cmp	r2, #22	; 0x16
 3f0d5c4:	e5943004 	ldr	r3, [r4, #4]
 3f0d5c8:	e1a01004 	mov	r1, r4
 3f0d5cc:	e3c36003 	bic	r6, r3, #3	; 0x3
 3f0d5d0:	e3c23007 	bic	r3, r2, #7	; 0x7
 3f0d5d4:	c1a09003 	movgt	r9, r3
 3f0d5d8:	d3a09010 	movle	r9, #16	; 0x10

#if HAVE_MMAP
  if (chunk_is_mmapped(oldp))
  {
#if HAVE_MREMAP
    newp = mremap_chunk(oldp, nb);
    if(newp) return chunk2mem(newp);
#endif
    /* Note the extra SIZE_SZ overhead. */
    if(oldsize - SIZE_SZ >= nb) return oldmem; /* do nothing */
    /* Must alloc, copy, free. */
    newmem = mALLOc(bytes);
    if (newmem == 0) return 0; /* propagate failure */
    MALLOC_COPY(newmem, oldmem, oldsize - 2*SIZE_SZ);
    munmap_chunk(oldp);
    return newmem;
  }
#endif

  check_inuse_chunk(oldp);

  if ((long)(oldsize) < (long)(nb))
 3f0d5dc:	e1560009 	cmp	r6, r9
 3f0d5e0:	e1a0a006 	mov	r10, r6
 3f0d5e4:	aa0000ec 	bge	3f0d99c <realloc+0x410>
  {

    /* Try expanding forward */

    next = chunk_at_offset(oldp, oldsize);
    if (next == top || !inuse(next))
 3f0d5e8:	e59f33a8 	ldr	r3, [pc, #3a8]	; 3f0d998 <realloc+0x40c>
 3f0d5ec:	e5932008 	ldr	r2, [r3, #8]
 3f0d5f0:	e084c006 	add	r12, r4, r6
 3f0d5f4:	e15c0002 	cmp	r12, r2
 3f0d5f8:	0a000005 	beq	3f0d614 <realloc+0x88>
 3f0d5fc:	e59c3004 	ldr	r3, [r12, #4]
 3f0d600:	e3c33001 	bic	r3, r3, #1	; 0x1
 3f0d604:	e08c3003 	add	r3, r12, r3
 3f0d608:	e5933004 	ldr	r3, [r3, #4]
 3f0d60c:	e3130001 	tst	r3, #1	; 0x1
 3f0d610:	1a00001c 	bne	3f0d688 <realloc+0xfc>
    {
      nextsize = chunksize(next);
 3f0d614:	e59c3004 	ldr	r3, [r12, #4]

      /* Forward into top only if a remainder */
      if (next == top)
 3f0d618:	e15c0002 	cmp	r12, r2
 3f0d61c:	e3c3e003 	bic	r14, r3, #3	; 0x3
 3f0d620:	1a00000f 	bne	3f0d664 <realloc+0xd8>
      {
	if ((long)(nextsize + newsize) >= (long)(nb + MINSIZE))
 3f0d624:	e08e2006 	add	r2, r14, r6
 3f0d628:	e2893010 	add	r3, r9, #16	; 0x10
 3f0d62c:	e1520003 	cmp	r2, r3
 3f0d630:	ba000016 	blt	3f0d690 <realloc+0x104>
	{
	  newsize += nextsize;
	  top = chunk_at_offset(oldp, nb);
 3f0d634:	e0843009 	add	r3, r4, r9
 3f0d638:	e59f1358 	ldr	r1, [pc, #358]	; 3f0d998 <realloc+0x40c>
	  set_head(top, (newsize - nb) | PREV_INUSE);
 3f0d63c:	e0692002 	rsb	r2, r9, r2
 3f0d640:	e5813008 	str	r3, [r1, #8]
 3f0d644:	e3822001 	orr	r2, r2, #1	; 0x1
 3f0d648:	e5832004 	str	r2, [r3, #4]
	  set_head_size(oldp, nb);
 3f0d64c:	e5943004 	ldr	r3, [r4, #4]
	  return chunk2mem(oldp);
 3f0d650:	e1a00007 	mov	r0, r7
 3f0d654:	e2033001 	and	r3, r3, #1	; 0x1
 3f0d658:	e1833009 	orr	r3, r3, r9
 3f0d65c:	e5843004 	str	r3, [r4, #4]
 3f0d660:	ea0000e9 	b	3f0da0c <realloc+0x480>
	}
      }

      /* Forward into next chunk */
      else if (((long)(nextsize + newsize) >= (long)(nb)))
 3f0d664:	e08e2006 	add	r2, r14, r6
 3f0d668:	e1520009 	cmp	r2, r9
 3f0d66c:	ba000007 	blt	3f0d690 <realloc+0x104>
      {
	unlink(next, bck, fwd);
 3f0d670:	e59c100c 	ldr	r1, [r12, #12]
 3f0d674:	e59c3008 	ldr	r3, [r12, #8]
 3f0d678:	e583100c 	str	r1, [r3, #12]
	newsize  += nextsize;
 3f0d67c:	e1a06002 	mov	r6, r2
 3f0d680:	e5813008 	str	r3, [r1, #8]
	goto split;
 3f0d684:	ea0000c4 	b	3f0d99c <realloc+0x410>
      }
    }
    else
    {
      next = 0;
 3f0d688:	e3a0c000 	mov	r12, #0	; 0x0
      nextsize = 0;
 3f0d68c:	e1a0e00c 	mov	r14, r12
    }

    /* Try shifting backwards. */

    if (!prev_inuse(oldp))
 3f0d690:	e5913004 	ldr	r3, [r1, #4]
 3f0d694:	e3130001 	tst	r3, #1	; 0x1
 3f0d698:	1a000087 	bne	3f0d8bc <realloc+0x330>
    {
      prev = prev_chunk(oldp);
 3f0d69c:	e5913000 	ldr	r3, [r1]
 3f0d6a0:	e0636001 	rsb	r6, r3, r1
      prevsize = chunksize(prev);
 3f0d6a4:	e5963004 	ldr	r3, [r6, #4]

      /* try forward + backward first to save a later consolidation */

      if (next != 0)
 3f0d6a8:	e35c0000 	cmp	r12, #0	; 0x0
 3f0d6ac:	e3c34003 	bic	r4, r3, #3	; 0x3
 3f0d6b0:	0a000050 	beq	3f0d7f8 <realloc+0x26c>
      {
	/* into top */
	if (next == top)
 3f0d6b4:	e59f22dc 	ldr	r2, [pc, #2dc]	; 3f0d998 <realloc+0x40c>
 3f0d6b8:	e5923008 	ldr	r3, [r2, #8]
 3f0d6bc:	e15c0003 	cmp	r12, r3
 3f0d6c0:	1a00003d 	bne	3f0d7bc <realloc+0x230>
	{
	  if ((long)(nextsize + prevsize + newsize) >= (long)(nb + MINSIZE))
 3f0d6c4:	e08e3004 	add	r3, r14, r4
 3f0d6c8:	e083300a 	add	r3, r3, r10
 3f0d6cc:	e50b3028 	str	r3, [r11, -#40]
 3f0d6d0:	e51b2028 	ldr	r2, [r11, -#40]
 3f0d6d4:	e2893010 	add	r3, r9, #16	; 0x10
 3f0d6d8:	e1520003 	cmp	r2, r3
 3f0d6dc:	ba000045 	blt	3f0d7f8 <realloc+0x26c>
	  {
	    unlink(prev, bck, fwd);
 3f0d6e0:	e596100c 	ldr	r1, [r6, #12]
 3f0d6e4:	e5963008 	ldr	r3, [r6, #8]
	    newp = prev;
 3f0d6e8:	e1a04006 	mov	r4, r6
 3f0d6ec:	e583100c 	str	r1, [r3, #12]
	    newsize += prevsize + nextsize;
	    newmem = chunk2mem(newp);
 3f0d6f0:	e2845008 	add	r5, r4, #8	; 0x8
 3f0d6f4:	e5813008 	str	r3, [r1, #8]
	    MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ);
 3f0d6f8:	e24a2004 	sub	r2, r10, #4	; 0x4
 3f0d6fc:	e3520024 	cmp	r2, #36	; 0x24
 3f0d700:	8a00001d 	bhi	3f0d77c <realloc+0x1f0>
 3f0d704:	e1a0c007 	mov	r12, r7
 3f0d708:	e1a01005 	mov	r1, r5
 3f0d70c:	e3520013 	cmp	r2, #19	; 0x13
 3f0d710:	9a000012 	bls	3f0d760 <realloc+0x1d4>
 3f0d714:	e49c3004 	ldr	r3, [r12], #4
 3f0d718:	e2841010 	add	r1, r4, #16	; 0x10
 3f0d71c:	e5843008 	str	r3, [r4, #8]
 3f0d720:	e352001b 	cmp	r2, #27	; 0x1b
 3f0d724:	e5973004 	ldr	r3, [r7, #4]
 3f0d728:	e28cc004 	add	r12, r12, #4	; 0x4
 3f0d72c:	e584300c 	str	r3, [r4, #12]
 3f0d730:	9a00000a 	bls	3f0d760 <realloc+0x1d4>
 3f0d734:	e49c3004 	ldr	r3, [r12], #4
 3f0d738:	e5843010 	str	r3, [r4, #16]
 3f0d73c:	e2841018 	add	r1, r4, #24	; 0x18
 3f0d740:	e49c3004 	ldr	r3, [r12], #4
 3f0d744:	e3520023 	cmp	r2, #35	; 0x23
 3f0d748:	e5843014 	str	r3, [r4, #20]
 3f0d74c:	849c3004 	ldrhi	r3, [r12], #4
 3f0d750:	85843018 	strhi	r3, [r4, #24]
 3f0d754:	849c3004 	ldrhi	r3, [r12], #4
 3f0d758:	82841020 	addhi	r1, r4, #32	; 0x20
 3f0d75c:	8584301c 	strhi	r3, [r4, #28]
 3f0d760:	e49c3004 	ldr	r3, [r12], #4
 3f0d764:	e4813004 	str	r3, [r1], #4
 3f0d768:	e49c3004 	ldr	r3, [r12], #4
 3f0d76c:	e4813004 	str	r3, [r1], #4
 3f0d770:	e59c3000 	ldr	r3, [r12]
 3f0d774:	e5813000 	str	r3, [r1]
 3f0d778:	ea000002 	b	3f0d788 <realloc+0x1fc>
 3f0d77c:	e1a00005 	mov	r0, r5
 3f0d780:	e1a01007 	mov	r1, r7
 3f0d784:	eb00077f 	bl	3f0f588 <memcpy>
	    top = chunk_at_offset(newp, nb);
 3f0d788:	e59f1208 	ldr	r1, [pc, #208]	; 3f0d998 <realloc+0x40c>
 3f0d78c:	e0863009 	add	r3, r6, r9
 3f0d790:	e5813008 	str	r3, [r1, #8]
	    set_head(top, (newsize - nb) | PREV_INUSE);
 3f0d794:	e51b1028 	ldr	r1, [r11, -#40]
 3f0d798:	e0692001 	rsb	r2, r9, r1
 3f0d79c:	e3822001 	orr	r2, r2, #1	; 0x1
 3f0d7a0:	e5832004 	str	r2, [r3, #4]
	    set_head_size(newp, nb);
 3f0d7a4:	e5963004 	ldr	r3, [r6, #4]
	    return newmem;
 3f0d7a8:	e1a00005 	mov	r0, r5
 3f0d7ac:	e2033001 	and	r3, r3, #1	; 0x1
 3f0d7b0:	e1833009 	orr	r3, r3, r9
 3f0d7b4:	e5863004 	str	r3, [r6, #4]
 3f0d7b8:	ea000093 	b	3f0da0c <realloc+0x480>
	  }
	}

	/* into next chunk */
	else if (((long)(nextsize + prevsize + newsize) >= (long)(nb)))
 3f0d7bc:	e08e3004 	add	r3, r14, r4
 3f0d7c0:	e083200a 	add	r2, r3, r10
 3f0d7c4:	e1520009 	cmp	r2, r9
 3f0d7c8:	ba00000a 	blt	3f0d7f8 <realloc+0x26c>
	{
	  unlink(next, bck, fwd);
 3f0d7cc:	e59c100c 	ldr	r1, [r12, #12]
 3f0d7d0:	e59c3008 	ldr	r3, [r12, #8]
 3f0d7d4:	e583100c 	str	r1, [r3, #12]
 3f0d7d8:	e5813008 	str	r3, [r1, #8]
	  unlink(prev, bck, fwd);
 3f0d7dc:	e596100c 	ldr	r1, [r6, #12]
	  newp = prev;
 3f0d7e0:	e1a04006 	mov	r4, r6
 3f0d7e4:	e5963008 	ldr	r3, [r6, #8]
	  newsize += nextsize + prevsize;
	  newmem = chunk2mem(newp);
 3f0d7e8:	e2845008 	add	r5, r4, #8	; 0x8
 3f0d7ec:	e583100c 	str	r1, [r3, #12]
 3f0d7f0:	e1a06002 	mov	r6, r2
	  MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ);
 3f0d7f4:	ea00000a 	b	3f0d824 <realloc+0x298>
	  goto split;
	}
      }

      /* backward only */
      if (prev != 0 && (long)(prevsize + newsize) >= (long)nb)
 3f0d7f8:	e3560000 	cmp	r6, #0	; 0x0
 3f0d7fc:	0a00002e 	beq	3f0d8bc <realloc+0x330>
 3f0d800:	e084200a 	add	r2, r4, r10
 3f0d804:	e1520009 	cmp	r2, r9
 3f0d808:	ba00002b 	blt	3f0d8bc <realloc+0x330>
      {
	unlink(prev, bck, fwd);
 3f0d80c:	e596100c 	ldr	r1, [r6, #12]
	newp = prev;
 3f0d810:	e1a04006 	mov	r4, r6
 3f0d814:	e5963008 	ldr	r3, [r6, #8]
	newsize += prevsize;
 3f0d818:	e1a06002 	mov	r6, r2
 3f0d81c:	e583100c 	str	r1, [r3, #12]
	newmem = chunk2mem(newp);
 3f0d820:	e2845008 	add	r5, r4, #8	; 0x8
 3f0d824:	e5813008 	str	r3, [r1, #8]
	MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ);
 3f0d828:	e24a2004 	sub	r2, r10, #4	; 0x4
 3f0d82c:	e3520024 	cmp	r2, #36	; 0x24
 3f0d830:	8a00001d 	bhi	3f0d8ac <realloc+0x320>
 3f0d834:	e1a0c007 	mov	r12, r7
 3f0d838:	e1a00005 	mov	r0, r5
 3f0d83c:	e3520013 	cmp	r2, #19	; 0x13
 3f0d840:	9a000012 	bls	3f0d890 <realloc+0x304>
 3f0d844:	e49c3004 	ldr	r3, [r12], #4
 3f0d848:	e2840010 	add	r0, r4, #16	; 0x10
 3f0d84c:	e5843008 	str	r3, [r4, #8]
 3f0d850:	e352001b 	cmp	r2, #27	; 0x1b
 3f0d854:	e5973004 	ldr	r3, [r7, #4]
 3f0d858:	e28cc004 	add	r12, r12, #4	; 0x4
 3f0d85c:	e584300c 	str	r3, [r4, #12]
 3f0d860:	9a00000a 	bls	3f0d890 <realloc+0x304>
 3f0d864:	e49c3004 	ldr	r3, [r12], #4
 3f0d868:	e5843010 	str	r3, [r4, #16]
 3f0d86c:	e2840018 	add	r0, r4, #24	; 0x18
 3f0d870:	e49c3004 	ldr	r3, [r12], #4
 3f0d874:	e3520023 	cmp	r2, #35	; 0x23
 3f0d878:	e5843014 	str	r3, [r4, #20]
 3f0d87c:	849c3004 	ldrhi	r3, [r12], #4
 3f0d880:	85843018 	strhi	r3, [r4, #24]
 3f0d884:	849c3004 	ldrhi	r3, [r12], #4
 3f0d888:	82840020 	addhi	r0, r4, #32	; 0x20
 3f0d88c:	8584301c 	strhi	r3, [r4, #28]
 3f0d890:	e49c3004 	ldr	r3, [r12], #4
 3f0d894:	e4803004 	str	r3, [r0], #4
 3f0d898:	e49c3004 	ldr	r3, [r12], #4
 3f0d89c:	e4803004 	str	r3, [r0], #4
 3f0d8a0:	e59c3000 	ldr	r3, [r12]
 3f0d8a4:	e5803000 	str	r3, [r0]
 3f0d8a8:	ea00003b 	b	3f0d99c <realloc+0x410>
 3f0d8ac:	e1a00005 	mov	r0, r5
 3f0d8b0:	e1a01007 	mov	r1, r7
 3f0d8b4:	eb000733 	bl	3f0f588 <memcpy>
	goto split;
 3f0d8b8:	ea000037 	b	3f0d99c <realloc+0x410>
      }
    }

    /* Must allocate */

    newmem = mALLOc (bytes);
 3f0d8bc:	e50b102c 	str	r1, [r11, -#44]
 3f0d8c0:	ebfffd92 	bl	3f0cf10 <malloc>

    if (newmem == 0)  /* propagate failure */
 3f0d8c4:	e2505000 	subs	r5, r0, #0	; 0x0
 3f0d8c8:	e51b102c 	ldr	r1, [r11, -#44]
 3f0d8cc:	1a000001 	bne	3f0d8d8 <realloc+0x34c>
      return 0;
 3f0d8d0:	e3a00000 	mov	r0, #0	; 0x0
 3f0d8d4:	ea00004c 	b	3f0da0c <realloc+0x480>

    /* Avoid copy if newp is next chunk after oldp. */
    /* (This can only happen when new chunk is sbrk'ed.) */

    if ( (newp = mem2chunk(newmem)) == next_chunk(oldp))
 3f0d8d8:	e5913004 	ldr	r3, [r1, #4]
 3f0d8dc:	e2454008 	sub	r4, r5, #8	; 0x8
 3f0d8e0:	e3c33001 	bic	r3, r3, #1	; 0x1
 3f0d8e4:	e0813003 	add	r3, r1, r3
 3f0d8e8:	e1540003 	cmp	r4, r3
    {
      newsize += chunksize(newp);
 3f0d8ec:	05943004 	ldreq	r3, [r4, #4]
      newp = oldp;
 3f0d8f0:	01a04001 	moveq	r4, r1
 3f0d8f4:	03c33003 	biceq	r3, r3, #3	; 0x3
 3f0d8f8:	008a6003 	addeq	r6, r10, r3
      goto split;
 3f0d8fc:	0a000026 	beq	3f0d99c <realloc+0x410>
    }

    /* Otherwise copy, free, and exit */
    MALLOC_COPY(newmem, oldmem, oldsize - SIZE_SZ);
 3f0d900:	e24a2004 	sub	r2, r10, #4	; 0x4
 3f0d904:	e3520024 	cmp	r2, #36	; 0x24
 3f0d908:	8a00001b 	bhi	3f0d97c <realloc+0x3f0>
 3f0d90c:	e1a00007 	mov	r0, r7
 3f0d910:	e1a01005 	mov	r1, r5
 3f0d914:	e3520013 	cmp	r2, #19	; 0x13
 3f0d918:	9a000010 	bls	3f0d960 <realloc+0x3d4>
 3f0d91c:	e4903004 	ldr	r3, [r0], #4
 3f0d920:	e352001b 	cmp	r2, #27	; 0x1b
 3f0d924:	e4813004 	str	r3, [r1], #4
 3f0d928:	e2800004 	add	r0, r0, #4	; 0x4
 3f0d92c:	e5973004 	ldr	r3, [r7, #4]
 3f0d930:	e2811004 	add	r1, r1, #4	; 0x4
 3f0d934:	e5853004 	str	r3, [r5, #4]
 3f0d938:	9a000008 	bls	3f0d960 <realloc+0x3d4>
 3f0d93c:	e4903004 	ldr	r3, [r0], #4
 3f0d940:	e4813004 	str	r3, [r1], #4
 3f0d944:	e4903004 	ldr	r3, [r0], #4
 3f0d948:	e3520023 	cmp	r2, #35	; 0x23
 3f0d94c:	e4813004 	str	r3, [r1], #4
 3f0d950:	84903004 	ldrhi	r3, [r0], #4
 3f0d954:	84813004 	strhi	r3, [r1], #4
 3f0d958:	84903004 	ldrhi	r3, [r0], #4
 3f0d95c:	84813004 	strhi	r3, [r1], #4
 3f0d960:	e4903004 	ldr	r3, [r0], #4
 3f0d964:	e4813004 	str	r3, [r1], #4
 3f0d968:	e4903004 	ldr	r3, [r0], #4
 3f0d96c:	e4813004 	str	r3, [r1], #4
 3f0d970:	e5903000 	ldr	r3, [r0]
 3f0d974:	e5813000 	str	r3, [r1]
 3f0d978:	ea000002 	b	3f0d988 <realloc+0x3fc>
 3f0d97c:	e1a00005 	mov	r0, r5
 3f0d980:	e1a01007 	mov	r1, r7
 3f0d984:	eb0006ff 	bl	3f0f588 <memcpy>
    fREe(oldmem);
 3f0d988:	e1a00007 	mov	r0, r7
 3f0d98c:	ebfffe73 	bl	3f0d360 <free>
    return newmem;
 3f0d990:	e1a00005 	mov	r0, r5
 3f0d994:	ea00001c 	b	3f0da0c <realloc+0x480>
 3f0d998:	03f2087c 	mvneqs	r0, #8126464	; 0x7c0000
  }


 split:  /* split off extra room in old or expanded chunk */

  if (newsize - nb >= MINSIZE) /* split off remainder */
 3f0d99c:	e0692006 	rsb	r2, r9, r6
 3f0d9a0:	e352000f 	cmp	r2, #15	; 0xf
 3f0d9a4:	9a00000e 	bls	3f0d9e4 <realloc+0x458>
  {
    remainder = chunk_at_offset(newp, nb);
 3f0d9a8:	e0840009 	add	r0, r4, r9
    remainder_size = newsize - nb;
    set_head_size(newp, nb);
 3f0d9ac:	e5943004 	ldr	r3, [r4, #4]
    set_head(remainder, remainder_size | PREV_INUSE);
    set_inuse_bit_at_offset(remainder, remainder_size);
 3f0d9b0:	e3a01004 	mov	r1, #4	; 0x4
 3f0d9b4:	e2033001 	and	r3, r3, #1	; 0x1
 3f0d9b8:	e1833009 	orr	r3, r3, r9
 3f0d9bc:	e5843004 	str	r3, [r4, #4]
 3f0d9c0:	e3823001 	orr	r3, r2, #1	; 0x1
 3f0d9c4:	e5803004 	str	r3, [r0, #4]
 3f0d9c8:	e0802002 	add	r2, r0, r2
 3f0d9cc:	e7923001 	ldr	r3, [r2, r1]
    fREe(chunk2mem(remainder)); /* let free() deal with it */
 3f0d9d0:	e2800008 	add	r0, r0, #8	; 0x8
 3f0d9d4:	e3833001 	orr	r3, r3, #1	; 0x1
 3f0d9d8:	e7823001 	str	r3, [r2, r1]
 3f0d9dc:	ebfffe5f 	bl	3f0d360 <free>
  }
 3f0d9e0:	ea000008 	b	3f0da08 <realloc+0x47c>
  else
  {
    set_head_size(newp, newsize);
 3f0d9e4:	e5943004 	ldr	r3, [r4, #4]
    set_inuse_bit_at_offset(newp, newsize);
 3f0d9e8:	e3a01004 	mov	r1, #4	; 0x4
 3f0d9ec:	e2033001 	and	r3, r3, #1	; 0x1
 3f0d9f0:	e1833006 	orr	r3, r3, r6
 3f0d9f4:	e5843004 	str	r3, [r4, #4]
 3f0d9f8:	e0842006 	add	r2, r4, r6
 3f0d9fc:	e7923001 	ldr	r3, [r2, r1]
 3f0da00:	e3833001 	orr	r3, r3, #1	; 0x1
 3f0da04:	e7823001 	str	r3, [r2, r1]
  }

  check_inuse_chunk(newp);
  return chunk2mem(newp);
 3f0da08:	e2840008 	add	r0, r4, #8	; 0x8
}
 3f0da0c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0da10 <memalign>:
 3f0da10:	e1a0c00d 	mov	r12, r13
 3f0da14:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f0da18:	e24cb004 	sub	r11, r12, #4	; 0x4




/*

  memalign algorithm:

    memalign requests more than enough space from malloc, finds a spot
    within that chunk that meets the alignment request, and then
    possibly frees the leading and trailing space.

    The alignment argument must be a power of two. This property is not
    checked by memalign, so misuse may result in random runtime errors.

    8-byte alignment is guaranteed by normal malloc calls, so don't
    bother calling memalign with an argument of 8 or less.

    Overreliance on memalign is a sure way to fragment space.

*/


#if __STD_C
Void_t* mEMALIGn(size_t alignment, size_t bytes)
#else
Void_t* mEMALIGn(alignment, bytes) size_t alignment; size_t bytes;
#endif
{
 3f0da1c:	e1a05000 	mov	r5, r0
  INTERNAL_SIZE_T    nb;      /* padded  request size */
  char*     m;                /* memory returned by malloc call */
  mchunkptr p;                /* corresponding chunk */
  char*     brk;              /* alignment point within p */
  mchunkptr newp;             /* chunk to return */
  INTERNAL_SIZE_T  newsize;   /* its size */
  INTERNAL_SIZE_T  leadsize;  /* leading space befor alignment point */
  mchunkptr remainder;        /* spare room at end to split off */
  long      remainder_size;   /* its size */

  if ((long)bytes < 0) return 0;
 3f0da20:	e2510000 	subs	r0, r1, #0	; 0x0
 3f0da24:	aa000001 	bge	3f0da30 <memalign+0x20>
 3f0da28:	e3a00000 	mov	r0, #0	; 0x0
 3f0da2c:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

  /* If need less alignment than we give anyway, just relay to malloc */

  if (alignment <= MALLOC_ALIGNMENT) return mALLOc(bytes);
 3f0da30:	e3550008 	cmp	r5, #8	; 0x8
 3f0da34:	8a000001 	bhi	3f0da40 <memalign+0x30>
 3f0da38:	ebfffd34 	bl	3f0cf10 <malloc>
 3f0da3c:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

  /* Otherwise, ensure that it is at least a minimum chunk size */

  if (alignment <  MINSIZE) alignment = MINSIZE;
 3f0da40:	e355000f 	cmp	r5, #15	; 0xf
 3f0da44:	93a05010 	movls	r5, #16	; 0x10

  /* Call malloc with worst case padding to hit alignment. */

  nb = request2size(bytes);
 3f0da48:	e280300b 	add	r3, r0, #11	; 0xb
 3f0da4c:	e3c32007 	bic	r2, r3, #7	; 0x7
 3f0da50:	e3530016 	cmp	r3, #22	; 0x16
 3f0da54:	c1a0a002 	movgt	r10, r2
 3f0da58:	d3a0a010 	movle	r10, #16	; 0x10
  m  = (char*)(mALLOc(nb + alignment + MINSIZE));
 3f0da5c:	e08a0005 	add	r0, r10, r5
 3f0da60:	e2800010 	add	r0, r0, #16	; 0x10
 3f0da64:	ebfffd29 	bl	3f0cf10 <malloc>

  if (m == 0) return 0; /* propagate failure */
 3f0da68:	e2507000 	subs	r7, r0, #0	; 0x0
 3f0da6c:	0affffed 	beq	3f0da28 <memalign+0x18>

  p = mem2chunk(m);
 3f0da70:	e2476008 	sub	r6, r7, #8	; 0x8

  if ((((unsigned long)(m)) % alignment) == 0) /* aligned */
 3f0da74:	e1a00007 	mov	r0, r7
 3f0da78:	e1a01005 	mov	r1, r5
 3f0da7c:	eb00167d 	bl	3f13478 <__umodsi3>
 3f0da80:	e3500000 	cmp	r0, #0	; 0x0
 3f0da84:	0a00001a 	beq	3f0daf4 <memalign+0xe4>
  {
#if HAVE_MMAP
    if(chunk_is_mmapped(p))
      return chunk2mem(p); /* nothing more to do */
#endif
  }
  else /* misaligned */
  {
    /*
      Find an aligned spot inside chunk.
      Since we need to give back leading space in a chunk of at
      least MINSIZE, if the first calculation places us at
      a spot with less than MINSIZE leader, we can move to the
      next aligned spot -- we've allocated enough total room so that
      this is always possible.
    */

    brk = (char*)mem2chunk(((unsigned long)(m + alignment - 1)) & -((signed) alignment));
 3f0da88:	e0874005 	add	r4, r7, r5
 3f0da8c:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0da90:	e2653000 	rsb	r3, r5, #0	; 0x0
 3f0da94:	e0044003 	and	r4, r4, r3
 3f0da98:	e2444008 	sub	r4, r4, #8	; 0x8
    if ((long)(brk - (char*)(p)) < MINSIZE) brk = brk + alignment;
 3f0da9c:	e0662004 	rsb	r2, r6, r4
 3f0daa0:	e0843005 	add	r3, r4, r5
 3f0daa4:	e352000f 	cmp	r2, #15	; 0xf
 3f0daa8:	91a04003 	movls	r4, r3

    newp = (mchunkptr)brk;
    leadsize = brk - (char*)(p);
 3f0daac:	e066c004 	rsb	r12, r6, r4
    newsize = chunksize(p) - leadsize;
 3f0dab0:	e5962004 	ldr	r2, [r6, #4]

#if HAVE_MMAP
    if(chunk_is_mmapped(p))
    {
      newp->prev_size = p->prev_size + leadsize;
      set_head(newp, newsize|IS_MMAPPED);
      return chunk2mem(newp);
    }
#endif

    /* give back leader, use the rest */

    set_head(newp, newsize | PREV_INUSE);
    set_inuse_bit_at_offset(newp, newsize);
 3f0dab4:	e3a01004 	mov	r1, #4	; 0x4
 3f0dab8:	e3c22003 	bic	r2, r2, #3	; 0x3
 3f0dabc:	e06c2002 	rsb	r2, r12, r2
 3f0dac0:	e3823001 	orr	r3, r2, #1	; 0x1
 3f0dac4:	e5843004 	str	r3, [r4, #4]
 3f0dac8:	e0842002 	add	r2, r4, r2
 3f0dacc:	e7923001 	ldr	r3, [r2, r1]
 3f0dad0:	e3833001 	orr	r3, r3, #1	; 0x1
 3f0dad4:	e7823001 	str	r3, [r2, r1]
    set_head_size(p, leadsize);
 3f0dad8:	e5963004 	ldr	r3, [r6, #4]
    fREe(chunk2mem(p));
 3f0dadc:	e1a00007 	mov	r0, r7
 3f0dae0:	e2033001 	and	r3, r3, #1	; 0x1
 3f0dae4:	e183300c 	orr	r3, r3, r12
 3f0dae8:	e5863004 	str	r3, [r6, #4]
 3f0daec:	ebfffe1b 	bl	3f0d360 <free>
    p = newp;
 3f0daf0:	e1a06004 	mov	r6, r4

    assert (newsize >= nb && (((unsigned long)(chunk2mem(p))) % alignment) == 0);
  }

  /* Also give back spare room at the end */

  remainder_size = chunksize(p) - nb;
 3f0daf4:	e5963004 	ldr	r3, [r6, #4]
 3f0daf8:	e3c33003 	bic	r3, r3, #3	; 0x3
 3f0dafc:	e06a3003 	rsb	r3, r10, r3

  if (remainder_size >= (long)MINSIZE)
 3f0db00:	e353000f 	cmp	r3, #15	; 0xf
 3f0db04:	da000008 	ble	3f0db2c <memalign+0x11c>
  {
    remainder = chunk_at_offset(p, nb);
 3f0db08:	e086000a 	add	r0, r6, r10
    set_head(remainder, remainder_size | PREV_INUSE);
 3f0db0c:	e3833001 	orr	r3, r3, #1	; 0x1
 3f0db10:	e5803004 	str	r3, [r0, #4]
    set_head_size(p, nb);
 3f0db14:	e5963004 	ldr	r3, [r6, #4]
    fREe(chunk2mem(remainder));
 3f0db18:	e2800008 	add	r0, r0, #8	; 0x8
 3f0db1c:	e2033001 	and	r3, r3, #1	; 0x1
 3f0db20:	e183300a 	orr	r3, r3, r10
 3f0db24:	e5863004 	str	r3, [r6, #4]
 3f0db28:	ebfffe0c 	bl	3f0d360 <free>
  }

  check_inuse_chunk(p);
  return chunk2mem(p);
 3f0db2c:	e2860008 	add	r0, r6, #8	; 0x8

}
 3f0db30:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f0db34 <valloc>:
 3f0db34:	e1a0c00d 	mov	r12, r13
 3f0db38:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0db3c:	e24cb004 	sub	r11, r12, #4	; 0x4




/*
    valloc just invokes memalign with alignment argument equal
    to the page size of the system (or as near to this as can
    be figured out from all the includes/defines above.)
*/

#if __STD_C
Void_t* vALLOc(size_t bytes)
#else
Void_t* vALLOc(bytes) size_t bytes;
#endif
{
 3f0db40:	e1a01000 	mov	r1, r0
  return mEMALIGn (malloc_getpagesize, bytes);
 3f0db44:	e3a00a01 	mov	r0, #4096	; 0x1000
 3f0db48:	ebffffb0 	bl	3f0da10 <memalign>
 3f0db4c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0db50 <pvalloc>:
 3f0db50:	e1a0c00d 	mov	r12, r13
 3f0db54:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0db58:	e24cb004 	sub	r11, r12, #4	; 0x4
}

/*
  pvalloc just invokes valloc for the nearest pagesize
  that will accommodate request
*/


#if __STD_C
Void_t* pvALLOc(size_t bytes)
#else
Void_t* pvALLOc(bytes) size_t bytes;
#endif
{
  size_t pagesize = malloc_getpagesize;
  return mEMALIGn (pagesize, (bytes + pagesize - 1) & ~(pagesize - 1));
 3f0db5c:	e2801eff 	add	r1, r0, #4080	; 0xff0
 3f0db60:	e281100f 	add	r1, r1, #15	; 0xf
 3f0db64:	e3a00a01 	mov	r0, #4096	; 0x1000
 3f0db68:	e3c11eff 	bic	r1, r1, #4080	; 0xff0
 3f0db6c:	e3c1100f 	bic	r1, r1, #15	; 0xf
 3f0db70:	ebffffa6 	bl	3f0da10 <memalign>
}
 3f0db74:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0db78 <calloc>:
 3f0db78:	e1a0c00d 	mov	r12, r13
 3f0db7c:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}

/*

  calloc calls malloc, then zeroes out the allocated chunk.

*/

#if __STD_C
Void_t* cALLOc(size_t n, size_t elem_size)
#else
Void_t* cALLOc(n, elem_size) size_t n; size_t elem_size;
#endif
{
 3f0db80:	e1a04000 	mov	r4, r0
  mchunkptr p;
  INTERNAL_SIZE_T csz;

  INTERNAL_SIZE_T sz = n * elem_size;


  /* check if expand_top called, in which case don't need to clear */
#if MORECORE_CLEARS
  mchunkptr oldtop = top;
  INTERNAL_SIZE_T oldtopsize = chunksize(top);
#endif
  Void_t* mem = mALLOc (sz);
 3f0db84:	e0000491 	mul	r0, r1, r4
 3f0db88:	e59f30c0 	ldr	r3, [pc, #c0]	; 3f0dc50 <calloc+0xd8>
 3f0db8c:	e5936008 	ldr	r6, [r3, #8]
 3f0db90:	e5963004 	ldr	r3, [r6, #4]
 3f0db94:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0db98:	e3c35003 	bic	r5, r3, #3	; 0x3
 3f0db9c:	ebfffcdb 	bl	3f0cf10 <malloc>

  if ((long)n < 0) return 0;
 3f0dba0:	e3540000 	cmp	r4, #0	; 0x0
 3f0dba4:	e1a04000 	mov	r4, r0
 3f0dba8:	aa000001 	bge	3f0dbb4 <calloc+0x3c>
 3f0dbac:	e3a00000 	mov	r0, #0	; 0x0
 3f0dbb0:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

  if (mem == 0)
 3f0dbb4:	e3540000 	cmp	r4, #0	; 0x0
 3f0dbb8:	0afffffb 	beq	3f0dbac <calloc+0x34>
    return 0;
  else
  {
    p = mem2chunk(mem);
 3f0dbbc:	e2441008 	sub	r1, r4, #8	; 0x8

    /* Two optional cases in which clearing not necessary */


#if HAVE_MMAP
    if (chunk_is_mmapped(p)) return mem;
#endif

    csz = chunksize(p);
 3f0dbc0:	e5912004 	ldr	r2, [r1, #4]
 3f0dbc4:	e3c22003 	bic	r2, r2, #3	; 0x3

#if MORECORE_CLEARS
    if (p == oldtop && csz > oldtopsize)
 3f0dbc8:	e1520005 	cmp	r2, r5
 3f0dbcc:	93a03000 	movls	r3, #0	; 0x0
 3f0dbd0:	83a03001 	movhi	r3, #1	; 0x1
 3f0dbd4:	e1510006 	cmp	r1, r6
 3f0dbd8:	13a03000 	movne	r3, #0	; 0x0
 3f0dbdc:	e3530000 	cmp	r3, #0	; 0x0
 3f0dbe0:	11a02005 	movne	r2, r5
    {
      /* clear only the bytes from non-freshly-sbrked memory */
      csz = oldtopsize;
    }
#endif

    MALLOC_ZERO(mem, csz - SIZE_SZ);
 3f0dbe4:	e2422004 	sub	r2, r2, #4	; 0x4
 3f0dbe8:	e3520024 	cmp	r2, #36	; 0x24
 3f0dbec:	8a000012 	bhi	3f0dc3c <calloc+0xc4>
 3f0dbf0:	e1a01004 	mov	r1, r4
 3f0dbf4:	e3520013 	cmp	r2, #19	; 0x13
 3f0dbf8:	9a00000a 	bls	3f0dc28 <calloc+0xb0>
 3f0dbfc:	e3a03000 	mov	r3, #0	; 0x0
 3f0dc00:	e4813004 	str	r3, [r1], #4
 3f0dc04:	e352001b 	cmp	r2, #27	; 0x1b
 3f0dc08:	e5843004 	str	r3, [r4, #4]
 3f0dc0c:	e2811004 	add	r1, r1, #4	; 0x4
 3f0dc10:	9a000004 	bls	3f0dc28 <calloc+0xb0>
 3f0dc14:	e4813004 	str	r3, [r1], #4
 3f0dc18:	e3520023 	cmp	r2, #35	; 0x23
 3f0dc1c:	e4813004 	str	r3, [r1], #4
 3f0dc20:	84813004 	strhi	r3, [r1], #4
 3f0dc24:	84813004 	strhi	r3, [r1], #4
 3f0dc28:	e3a03000 	mov	r3, #0	; 0x0
 3f0dc2c:	e4813004 	str	r3, [r1], #4
 3f0dc30:	e4813004 	str	r3, [r1], #4
 3f0dc34:	e5813000 	str	r3, [r1]
 3f0dc38:	ea000002 	b	3f0dc48 <calloc+0xd0>
 3f0dc3c:	e1a00004 	mov	r0, r4
 3f0dc40:	e3a01000 	mov	r1, #0	; 0x0
 3f0dc44:	eb000635 	bl	3f0f520 <memset>
    return mem;
 3f0dc48:	e1a00004 	mov	r0, r4
  }
}
 3f0dc4c:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f0dc50:	03f2087c 	mvneqs	r0, #8126464	; 0x7c0000

03f0dc54 <cfree>:
 3f0dc54:	e1a0c00d 	mov	r12, r13
 3f0dc58:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0dc5c:	e24cb004 	sub	r11, r12, #4	; 0x4

/*

  cfree just calls free. It is needed/defined on some systems
  that pair it with calloc, presumably for odd historical reasons.

*/

#if !defined(INTERNAL_LINUX_C_LIB) || !defined(__ELF__)
#if __STD_C
void cfree(Void_t *mem)
#else
void cfree(mem) Void_t *mem;
#endif
{
  fREe(mem);
 3f0dc60:	ebfffdbe 	bl	3f0d360 <free>
 3f0dc64:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0dc68 <malloc_trim>:
 3f0dc68:	e1a0c00d 	mov	r12, r13
 3f0dc6c:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
}
#endif



/*

    Malloc_trim gives memory back to the system (via negative
    arguments to sbrk) if there is unused memory at the `high' end of
    the malloc pool. You can call this after freeing large blocks of
    memory to potentially reduce the system-level memory requirements
    of a program. However, it cannot guarantee to reduce memory. Under
    some allocation patterns, some large free blocks of memory will be
    locked between two used chunks, so they cannot be given back to
    the system.

    The `pad' argument to malloc_trim represents the amount of free
    trailing space to leave untrimmed. If this argument is zero,
    only the minimum amount of memory to maintain internal data
    structures will be left (one page or less). Non-zero arguments
    can be supplied to maintain enough trailing space to service
    future expected allocations without having to re-obtain memory
    from the system.

    Malloc_trim returns 1 if it actually released any memory, else 0.

*/

#if __STD_C
int malloc_trim(size_t pad)
#else
int malloc_trim(pad) size_t pad;
#endif
{
  long  top_size;        /* Amount of top-most memory */
  long  extra;           /* Amount to release */
  char* current_brk;     /* address returned by pre-check sbrk call */
  char* new_brk;         /* address returned by negative sbrk call */

  unsigned long pagesz = malloc_getpagesize;

  top_size = chunksize(top);
 3f0dc70:	e59f70c4 	ldr	r7, [pc, #c4]	; 3f0dd3c <malloc_trim+0xd4>
 3f0dc74:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0dc78:	e5973008 	ldr	r3, [r7, #8]
  extra = ((top_size - pad - MINSIZE + (pagesz-1)) / pagesz - 1) * pagesz;
 3f0dc7c:	e3a04a01 	mov	r4, #4096	; 0x1000
 3f0dc80:	e5933004 	ldr	r3, [r3, #4]
 3f0dc84:	e1a01004 	mov	r1, r4
 3f0dc88:	e3c36003 	bic	r6, r3, #3	; 0x3
 3f0dc8c:	e0600006 	rsb	r0, r0, r6
 3f0dc90:	e2800efe 	add	r0, r0, #4064	; 0xfe0
 3f0dc94:	e280000f 	add	r0, r0, #15	; 0xf
 3f0dc98:	eb0015d0 	bl	3f133e0 <__udivsi3>
 3f0dc9c:	e2400001 	sub	r0, r0, #1	; 0x1
 3f0dca0:	e1a05600 	mov	r5, r0, lsl #12

  if (extra < (long)pagesz)  /* Not enough memory to release */
 3f0dca4:	e1550004 	cmp	r5, r4
    return 0;
 3f0dca8:	e3a00000 	mov	r0, #0	; 0x0
 3f0dcac:	b91ba8f0 	ldmltdb	r11, {r4, r5, r6, r7, r11, r13, r15}

  else
  {
    /* Test to make sure no one else called sbrk */
    current_brk = (char*)(MORECORE (0));
 3f0dcb0:	ebffcb5d 	bl	3f00a2c <sbrk>
    if (current_brk != (char*)(top) + top_size)
 3f0dcb4:	e5973008 	ldr	r3, [r7, #8]
 3f0dcb8:	e0833006 	add	r3, r3, r6
 3f0dcbc:	e1500003 	cmp	r0, r3
      return 0;     /* Apparently we don't own memory; must fail */
 3f0dcc0:	e3a00000 	mov	r0, #0	; 0x0
 3f0dcc4:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}

    else
    {
      new_brk = (char*)(MORECORE (-extra));
 3f0dcc8:	e2650000 	rsb	r0, r5, #0	; 0x0
 3f0dccc:	ebffcb56 	bl	3f00a2c <sbrk>

      if (new_brk == (char*)(MORECORE_FAILURE)) /* sbrk failed? */
 3f0dcd0:	e3700001 	cmn	r0, #1	; 0x1
 3f0dcd4:	1a00000e 	bne	3f0dd14 <malloc_trim+0xac>
      {
	/* Try to figure out what we have */
	current_brk = (char*)(MORECORE (0));
 3f0dcd8:	e3a00000 	mov	r0, #0	; 0x0
 3f0dcdc:	ebffcb52 	bl	3f00a2c <sbrk>
	top_size = current_brk - (char*)top;
 3f0dce0:	e5971008 	ldr	r1, [r7, #8]
 3f0dce4:	e0616000 	rsb	r6, r1, r0
	if (top_size >= (long)MINSIZE) /* if not, we are very very dead! */
 3f0dce8:	e356000f 	cmp	r6, #15	; 0xf
 3f0dcec:	da000006 	ble	3f0dd0c <malloc_trim+0xa4>
	{
	  sbrked_mem = current_brk - sbrk_base;
 3f0dcf0:	e59f3048 	ldr	r3, [pc, #48]	; 3f0dd40 <malloc_trim+0xd8>
 3f0dcf4:	e5933000 	ldr	r3, [r3]
 3f0dcf8:	e59f2044 	ldr	r2, [pc, #44]	; 3f0dd44 <malloc_trim+0xdc>
 3f0dcfc:	e0633000 	rsb	r3, r3, r0
 3f0dd00:	e5823000 	str	r3, [r2]
	  set_head(top, top_size | PREV_INUSE);
 3f0dd04:	e3863001 	orr	r3, r6, #1	; 0x1
 3f0dd08:	e5813004 	str	r3, [r1, #4]
	}
	check_chunk(top);
	return 0;
 3f0dd0c:	e3a00000 	mov	r0, #0	; 0x0
 3f0dd10:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
      }

      else
      {
	/* Success. Adjust top accordingly. */
	set_head(top, (top_size - extra) | PREV_INUSE);
 3f0dd14:	e0653006 	rsb	r3, r5, r6
 3f0dd18:	e5972008 	ldr	r2, [r7, #8]
 3f0dd1c:	e3833001 	orr	r3, r3, #1	; 0x1
 3f0dd20:	e5823004 	str	r3, [r2, #4]
	sbrked_mem -= extra;
 3f0dd24:	e59f2018 	ldr	r2, [pc, #18]	; 3f0dd44 <malloc_trim+0xdc>
 3f0dd28:	e5923000 	ldr	r3, [r2]
	check_chunk(top);
	return 1;
 3f0dd2c:	e3a00001 	mov	r0, #1	; 0x1
 3f0dd30:	e0653003 	rsb	r3, r5, r3
 3f0dd34:	e5823000 	str	r3, [r2]
      }
    }
  }
}
 3f0dd38:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0dd3c:	03f2087c 	mvneqs	r0, #8126464	; 0x7c0000
 3f0dd40:	03f20c94 	mvneqs	r0, #37888	; 0x9400
 3f0dd44:	03f20ca0 	mvneqs	r0, #40960	; 0xa000

03f0dd48 <malloc_usable_size>:
 3f0dd48:	e1a0c00d 	mov	r12, r13
 3f0dd4c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0dd50:	e24cb004 	sub	r11, r12, #4	; 0x4



/*
  malloc_usable_size:

    This routine tells you how many bytes you can actually use in an
    allocated chunk, which may be more than you requested (although
    often not). You can use this many bytes without worrying about
    overwriting other allocated objects. Not a particularly great
    programming practice, but still sometimes useful.

*/

#if __STD_C
size_t malloc_usable_size(Void_t* mem)
#else
size_t malloc_usable_size(mem) Void_t* mem;
#endif
{
  mchunkptr p;
  if (mem == 0)
 3f0dd54:	e3500000 	cmp	r0, #0	; 0x0
 3f0dd58:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
    return 0;
  else
  {
    p = mem2chunk(mem);
 3f0dd5c:	e2402008 	sub	r2, r0, #8	; 0x8
    if(!chunk_is_mmapped(p))
 3f0dd60:	e5920004 	ldr	r0, [r2, #4]
 3f0dd64:	e3100002 	tst	r0, #2	; 0x2
 3f0dd68:	1a000007 	bne	3f0dd8c <malloc_usable_size+0x44>
    {
      if (!inuse(p)) return 0;
 3f0dd6c:	e3c03001 	bic	r3, r0, #1	; 0x1
 3f0dd70:	e0823003 	add	r3, r2, r3
 3f0dd74:	e5933004 	ldr	r3, [r3, #4]
 3f0dd78:	e2133001 	ands	r3, r3, #1	; 0x1
 3f0dd7c:	01a00003 	moveq	r0, r3
      check_inuse_chunk(p);
      return chunksize(p) - SIZE_SZ;
 3f0dd80:	13c00003 	bicne	r0, r0, #3	; 0x3
 3f0dd84:	12400004 	subne	r0, r0, #4	; 0x4
 3f0dd88:	e91ba800 	ldmdb	r11, {r11, r13, r15}
    }
    return chunksize(p) - 2*SIZE_SZ;
 3f0dd8c:	e3c00003 	bic	r0, r0, #3	; 0x3
 3f0dd90:	e2400008 	sub	r0, r0, #8	; 0x8
  }
}
 3f0dd94:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0dd98 <mallopt>:
 3f0dd98:	e1a0c00d 	mov	r12, r13
 3f0dd9c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0dda0:	e24cb004 	sub	r11, r12, #4	; 0x4




/* Utility to update current_mallinfo for malloc_stats and mallinfo() */

#if 0
static void malloc_update_mallinfo()
{
  int i;
  mbinptr b;
  mchunkptr p;
#ifdef DEBUG
  mchunkptr q;
#endif

  INTERNAL_SIZE_T avail = chunksize(top);
  int   navail = ((long)(avail) >= (long)MINSIZE)? 1 : 0;

  for (i = 1; i < NAV; ++i)
  {
    b = bin_at(i);
    for (p = last(b); p != b; p = p->bk)
    {
#ifdef DEBUG
      check_free_chunk(p);
      for (q = next_chunk(p);
	   q < top && inuse(q) && (long)(chunksize(q)) >= (long)MINSIZE;
	   q = next_chunk(q))
	check_inuse_chunk(q);
#endif
      avail += chunksize(p);
      navail++;
    }
  }

  current_mallinfo.ordblks = navail;
  current_mallinfo.uordblks = sbrked_mem - avail;
  current_mallinfo.fordblks = avail;
  current_mallinfo.hblks = n_mmaps;
  current_mallinfo.hblkhd = mmapped_mem;
  current_mallinfo.keepcost = chunksize(top);

}
#endif	/* 0 */



/*

  malloc_stats:

    Prints on the amount of space obtain from the system (both
    via sbrk and mmap), the maximum amount (which may be more than
    current if malloc_trim and/or munmap got called), the maximum
    number of simultaneous mmap regions used, and the current number
    of bytes allocated via malloc (or realloc, etc) but not yet
    freed. (Note that this is the number of bytes allocated, not the
    number requested. It will be larger than the number requested
    because of alignment and bookkeeping overhead.)

*/

#if 0
void malloc_stats()
{
  malloc_update_mallinfo();
  printf("max system bytes = %10u\n",
	  (unsigned int)(max_total_mem));
  printf("system bytes     = %10u\n",
	  (unsigned int)(sbrked_mem + mmapped_mem));
  printf("in use bytes     = %10u\n",
	  (unsigned int)(current_mallinfo.uordblks + mmapped_mem));
#if HAVE_MMAP
  printf("max mmap regions = %10u\n",
	  (unsigned int)max_n_mmaps);
#endif
}
#endif	/* 0 */

/*
  mallinfo returns a copy of updated current mallinfo.
*/

#if 0
struct mallinfo mALLINFo()
{
  malloc_update_mallinfo();
  return current_mallinfo;
}
#endif	/* 0 */




/*
  mallopt:

    mallopt is the general SVID/XPG interface to tunable parameters.
    The format is to provide a (parameter-number, parameter-value) pair.
    mallopt then sets the corresponding parameter to the argument
    value if it can (i.e., so long as the value is meaningful),
    and returns 1 if successful else 0.

    See descriptions of tunable parameters above.

*/

#if __STD_C
int mALLOPt(int param_number, int value)
#else
int mALLOPt(param_number, value) int param_number; int value;
#endif
{
  switch(param_number)
 3f0dda4:	e2800004 	add	r0, r0, #4	; 0x4
 3f0dda8:	e3500003 	cmp	r0, #3	; 0x3
 3f0ddac:	979ff100 	ldrls	r15, [r15, r0, lsl #2]
 3f0ddb0:	ea000010 	b	3f0ddf8 <mallopt+0x60>
 3f0ddb4:	03f0dde4 	mvneqs	r13, #14592	; 0x3900
 3f0ddb8:	03f0dddc 	mvneqs	r13, #14080	; 0x3700
 3f0ddbc:	03f0ddd4 	mvneqs	r13, #13568	; 0x3500
 3f0ddc0:	03f0ddc4 	mvneqs	r13, #12544	; 0x3100
  {
    case M_TRIM_THRESHOLD:
      trim_threshold = value; return 1;
 3f0ddc4:	e59f3034 	ldr	r3, [pc, #34]	; 3f0de00 <mallopt+0x68>
 3f0ddc8:	e3a00001 	mov	r0, #1	; 0x1
 3f0ddcc:	e5831000 	str	r1, [r3]
 3f0ddd0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
    case M_TOP_PAD:
      top_pad = value; return 1;
 3f0ddd4:	e59f3028 	ldr	r3, [pc, #28]	; 3f0de04 <mallopt+0x6c>
 3f0ddd8:	eafffffa 	b	3f0ddc8 <mallopt+0x30>
    case M_MMAP_THRESHOLD:
      mmap_threshold = value; return 1;
 3f0dddc:	e59f3024 	ldr	r3, [pc, #24]	; 3f0de08 <mallopt+0x70>
 3f0dde0:	eafffff8 	b	3f0ddc8 <mallopt+0x30>
    case M_MMAP_MAX:
#if HAVE_MMAP
      n_mmaps_max = value; return 1;
#else
      if (value != 0) return 0; else  n_mmaps_max = value; return 1;
 3f0dde4:	e3510000 	cmp	r1, #0	; 0x0
 3f0dde8:	13a00000 	movne	r0, #0	; 0x0
 3f0ddec:	191ba800 	ldmnedb	r11, {r11, r13, r15}
 3f0ddf0:	e59f3014 	ldr	r3, [pc, #14]	; 3f0de0c <mallopt+0x74>
 3f0ddf4:	eafffff3 	b	3f0ddc8 <mallopt+0x30>
#endif

    default:
      return 0;
 3f0ddf8:	e3a00000 	mov	r0, #0	; 0x0
 3f0ddfc:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0de00:	03f20c84 	mvneqs	r0, #33792	; 0x8400
 3f0de04:	03f20c88 	mvneqs	r0, #34816	; 0x8800
 3f0de08:	03f20c90 	mvneqs	r0, #36864	; 0x9000
 3f0de0c:	03f20c8c 	mvneqs	r0, #35840	; 0x8c00

03f0de10 <env_crc_update>:
 3f0de10:	e1a0c00d 	mov	r12, r13
 3f0de14:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}


void env_crc_update (void)
{
	env_ptr->crc = crc32(0, env_ptr->data, ENV_SIZE);
 3f0de18:	e59f4020 	ldr	r4, [pc, #20]	; 3f0de40 <env_crc_update+0x30>
 3f0de1c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0de20:	e5941000 	ldr	r1, [r4]
 3f0de24:	e3a00000 	mov	r0, #0	; 0x0
 3f0de28:	e59f2014 	ldr	r2, [pc, #14]	; 3f0de44 <env_crc_update+0x34>
 3f0de2c:	e2811004 	add	r1, r1, #4	; 0x4
 3f0de30:	eb00040e 	bl	3f0ee70 <crc32>
 3f0de34:	e5943000 	ldr	r3, [r4]
 3f0de38:	e5830000 	str	r0, [r3]
 3f0de3c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f0de40:	03f20dcc 	mvneqs	r0, #13056	; 0x3300
 3f0de44:	00003ffc 	streqd	r3, [r0], -r12

03f0de48 <env_get_char_init>:
 3f0de48:	e1a0c00d 	mov	r12, r13
 3f0de4c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

static uchar env_get_char_init (int index)
{
	DECLARE_GLOBAL_DATA_PTR;
	uchar c;

	/* if crc was bad, use the default environment */
	if (gd->env_valid)
 3f0de50:	e5983018 	ldr	r3, [r8, #24]
 3f0de54:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0de58:	e3530000 	cmp	r3, #0	; 0x0
 3f0de5c:	0a000002 	beq	3f0de6c <env_get_char_init+0x24>
	{
		c = env_get_char_spec(index);
 3f0de60:	eb000044 	bl	3f0df78 <env_get_char_spec>
 3f0de64:	e20000ff 	and	r0, r0, #255	; 0xff
	} else {
 3f0de68:	e91ba800 	ldmdb	r11, {r11, r13, r15}
		c = default_environment[index];
 3f0de6c:	e59f3004 	ldr	r3, [pc, #4]	; 3f0de78 <env_get_char_init+0x30>
 3f0de70:	e7d30000 	ldrb	r0, [r3, r0]
	}

	return (c);
}
 3f0de74:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0de78:	03f20cd0 	mvneqs	r0, #53248	; 0xd000

03f0de7c <env_get_char_memory>:
 3f0de7c:	e1a0c00d 	mov	r12, r13
 3f0de80:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

#ifdef CONFIG_AMIGAONEG3SE
uchar env_get_char_memory (int index)
{
	DECLARE_GLOBAL_DATA_PTR;
	uchar retval;
	enable_nvram();
	if (gd->env_valid) {
		retval = ( *((uchar *)(gd->env_addr + index)) );
	} else {
		retval = ( default_environment[index] );
	}
	disable_nvram();
	return retval;
}
#else
uchar env_get_char_memory (int index)
{
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->env_valid) {
 3f0de84:	e5983018 	ldr	r3, [r8, #24]
 3f0de88:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0de8c:	e3530000 	cmp	r3, #0	; 0x0
		return ( *((uchar *)(gd->env_addr + index)) );
	} else {
		return ( default_environment[index] );
 3f0de90:	059f3010 	ldreq	r3, [pc, #10]	; 3f0dea8 <env_get_char_memory+0x2c>
 3f0de94:	07d30000 	ldreqb	r0, [r3, r0]
 3f0de98:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
 3f0de9c:	e5983014 	ldr	r3, [r8, #20]
 3f0dea0:	e7d30000 	ldrb	r0, [r3, r0]
	}
}
 3f0dea4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0dea8:	03f20cd0 	mvneqs	r0, #53248	; 0xd000

03f0deac <env_get_addr>:
 3f0deac:	e1a0c00d 	mov	r12, r13
 3f0deb0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0deb4:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

uchar *env_get_addr (int index)
{
	DECLARE_GLOBAL_DATA_PTR;

	if (gd->env_valid) {
 3f0deb8:	e5983018 	ldr	r3, [r8, #24]
 3f0debc:	e1a02000 	mov	r2, r0
 3f0dec0:	e3530000 	cmp	r3, #0	; 0x0
		return ( ((uchar *)(gd->env_addr + index)) );
	} else {
		return (&default_environment[index]);
 3f0dec4:	059f0010 	ldreq	r0, [pc, #10]	; 3f0dedc <env_get_addr+0x30>
 3f0dec8:	00820000 	addeq	r0, r2, r0
 3f0decc:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
 3f0ded0:	e5980014 	ldr	r0, [r8, #20]
 3f0ded4:	e0800002 	add	r0, r0, r2
	}
}
 3f0ded8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0dedc:	03f20cd0 	mvneqs	r0, #53248	; 0xd000

03f0dee0 <env_relocate>:
 3f0dee0:	e1a0c00d 	mov	r12, r13
 3f0dee4:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0dee8:	e24cb004 	sub	r11, r12, #4	; 0x4

void env_relocate (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	DEBUGF ("%s[%d] offset = 0x%lx\n", __FUNCTION__,__LINE__,
		gd->reloc_off);

#ifdef CONFIG_AMIGAONEG3SE
	enable_nvram();
#endif

#ifdef ENV_IS_EMBEDDED
	/*
	 * The environment buffer is embedded with the text segment,
	 * just relocate the environment pointer
	 */
	env_ptr = (env_t *)((ulong)env_ptr + gd->reloc_off);
	DEBUGF ("%s[%d] embedded ENV at %p\n", __FUNCTION__,__LINE__,env_ptr);
#else
	/*
	 * We must allocate a buffer for the environment
	 */
	env_ptr = (env_t *)malloc (CFG_ENV_SIZE);
 3f0deec:	e3a00901 	mov	r0, #16384	; 0x4000
 3f0def0:	e59f506c 	ldr	r5, [pc, #6c]	; 3f0df64 <env_relocate+0x84>
 3f0def4:	ebfffc05 	bl	3f0cf10 <malloc>
	DEBUGF ("%s[%d] malloced ENV at %p\n", __FUNCTION__,__LINE__,env_ptr);
#endif

	/*
	 * After relocation to RAM, we can always use the "memory" functions
	 */
	env_get_char = env_get_char_memory;
 3f0def8:	e59f2068 	ldr	r2, [pc, #68]	; 3f0df68 <env_relocate+0x88>
 3f0defc:	e59f3068 	ldr	r3, [pc, #68]	; 3f0df6c <env_relocate+0x8c>
 3f0df00:	e5850000 	str	r0, [r5]
 3f0df04:	e5823000 	str	r3, [r2]

	if (gd->env_valid == 0) {
 3f0df08:	e5984018 	ldr	r4, [r8, #24]
 3f0df0c:	e3540000 	cmp	r4, #0	; 0x0
 3f0df10:	1a00000e 	bne	3f0df50 <env_relocate+0x70>
#if defined(CONFIG_GTH)	|| defined(CFG_ENV_IS_NOWHERE)	/* Environment not changable */
		puts ("Using default environment\n\n");
#else
		puts ("*** Warning - bad CRC, using default environment\n\n");
 3f0df14:	e59f0054 	ldr	r0, [pc, #54]	; 3f0df70 <env_relocate+0x90>
 3f0df18:	ebfffa3c 	bl	3f0c810 <puts>
		SHOW_BOOT_PROGRESS (-1);
#endif

		if (sizeof(default_environment) > ENV_SIZE)
		{
			puts ("*** Error - default environment is too large\n\n");
			return;
		}

		memset (env_ptr, 0, sizeof(env_t));
 3f0df1c:	e1a01004 	mov	r1, r4
 3f0df20:	e5950000 	ldr	r0, [r5]
 3f0df24:	e3a02901 	mov	r2, #16384	; 0x4000
 3f0df28:	eb00057c 	bl	3f0f520 <memset>
		memcpy (env_ptr->data,
 3f0df2c:	e5950000 	ldr	r0, [r5]
 3f0df30:	e3a020f7 	mov	r2, #247	; 0xf7
 3f0df34:	e59f1038 	ldr	r1, [pc, #38]	; 3f0df74 <env_relocate+0x94>
 3f0df38:	e2800004 	add	r0, r0, #4	; 0x4
 3f0df3c:	eb000591 	bl	3f0f588 <memcpy>
			default_environment,
			sizeof(default_environment));
#ifdef CFG_REDUNDAND_ENVIRONMENT
		env_ptr->flags = 0xFF;
#endif
		env_crc_update ();
 3f0df40:	ebffffb2 	bl	3f0de10 <env_crc_update>
		gd->env_valid = 1;
 3f0df44:	e3a03001 	mov	r3, #1	; 0x1
 3f0df48:	e5883018 	str	r3, [r8, #24]
	}
 3f0df4c:	ea000000 	b	3f0df54 <env_relocate+0x74>
	else {
		env_relocate_spec ();
 3f0df50:	eb00003e 	bl	3f0e050 <env_relocate_spec>
	}
	gd->env_addr = (ulong)&(env_ptr->data);
 3f0df54:	e5953000 	ldr	r3, [r5]
 3f0df58:	e2833004 	add	r3, r3, #4	; 0x4
 3f0df5c:	e5883014 	str	r3, [r8, #20]

#ifdef CONFIG_AMIGAONEG3SE
	disable_nvram();
#endif
}
 3f0df60:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f0df64:	03f20dcc 	mvneqs	r0, #13056	; 0x3300
 3f0df68:	03f20ccc 	mvneqs	r0, #52224	; 0xcc00
 3f0df6c:	03f0de7c 	mvneqs	r13, #1984	; 0x7c0
 3f0df70:	03f1eebc 	mvneqs	r14, #3008	; 0xbc0
 3f0df74:	03f20cd0 	mvneqs	r0, #53248	; 0xd000

03f0df78 <env_get_char_spec>:
 3f0df78:	e1a0c00d 	mov	r12, r13
 3f0df7c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

uchar env_get_char_spec (int index)
{
	DECLARE_GLOBAL_DATA_PTR;
	return ( *((uchar *)(gd->env_addr + index)) );
 3f0df80:	e5983014 	ldr	r3, [r8, #20]
 3f0df84:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0df88:	e7d30000 	ldrb	r0, [r3, r0]
}
 3f0df8c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0df90 <env_init>:
 3f0df90:	e1a0c00d 	mov	r12, r13
 3f0df94:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0df98:	e24cb004 	sub	r11, r12, #4	; 0x4

int  env_init(void)
{
	DECLARE_GLOBAL_DATA_PTR;

	/* read environment from NAND */
	memset (env_ptr,0,CFG_ENV_SIZE);
 3f0df9c:	e59f4070 	ldr	r4, [pc, #70]	; 3f0e014 <env_init+0x84>
 3f0dfa0:	e3a01000 	mov	r1, #0	; 0x0
 3f0dfa4:	e5940000 	ldr	r0, [r4]
 3f0dfa8:	e3a02901 	mov	r2, #16384	; 0x4000
 3f0dfac:	eb00055b 	bl	3f0f520 <memset>
	nand_env_read(CFG_ENV_ADDR,ENV_SIZE,(u_char *)env_ptr);
 3f0dfb0:	e59f5060 	ldr	r5, [pc, #60]	; 3f0e018 <env_init+0x88>
 3f0dfb4:	e3a00807 	mov	r0, #458752	; 0x70000
 3f0dfb8:	e5942000 	ldr	r2, [r4]
 3f0dfbc:	e1a01005 	mov	r1, r5
 3f0dfc0:	ebfff543 	bl	3f0b4d4 <nand_env_read>
	printf("Get Environment from NAND offset 0x%x ... \n",CFG_ENV_ADDR);
 3f0dfc4:	e59f0050 	ldr	r0, [pc, #50]	; 3f0e01c <env_init+0x8c>
 3f0dfc8:	e3a01807 	mov	r1, #458752	; 0x70000
 3f0dfcc:	ebfffa1c 	bl	3f0c844 <printf>

	if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
 3f0dfd0:	e3a00000 	mov	r0, #0	; 0x0
 3f0dfd4:	e5941000 	ldr	r1, [r4]
 3f0dfd8:	e1a02005 	mov	r2, r5
 3f0dfdc:	e2811004 	add	r1, r1, #4	; 0x4
 3f0dfe0:	eb0003a2 	bl	3f0ee70 <crc32>
 3f0dfe4:	e5944000 	ldr	r4, [r4]
 3f0dfe8:	e5943000 	ldr	r3, [r4]
 3f0dfec:	e1500003 	cmp	r0, r3
		gd->env_addr  = (ulong)&(env_ptr->data);
 3f0dff0:	02843004 	addeq	r3, r4, #4	; 0x4
 3f0dff4:	05883014 	streq	r3, [r8, #20]
		gd->env_valid = 1;
 3f0dff8:	03a03001 	moveq	r3, #1	; 0x1
	} else {
		gd->env_addr  = (ulong)&default_environment[0];
 3f0dffc:	159f301c 	ldrne	r3, [pc, #1c]	; 3f0e020 <env_init+0x90>
 3f0e000:	15883014 	strne	r3, [r8, #20]
		gd->env_valid = 0;
 3f0e004:	13a03000 	movne	r3, #0	; 0x0
 3f0e008:	e5883018 	str	r3, [r8, #24]
	}

	return (0);
 3f0e00c:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0e010:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f0e014:	03f20dcc 	mvneqs	r0, #13056	; 0x3300
 3f0e018:	00003ffc 	streqd	r3, [r0], -r12
 3f0e01c:	03f1ef28 	mvneqs	r14, #160	; 0xa0
 3f0e020:	03f20cd0 	mvneqs	r0, #53248	; 0xd000

03f0e024 <saveenv>:
 3f0e024:	e1a0c00d 	mov	r12, r13
 3f0e028:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

#ifdef CMD_SAVEENV
int saveenv(void)
{
	return nand_env_write(CFG_ENV_ADDR,ENV_SIZE,(u_char *)env_ptr);
 3f0e02c:	e59f3014 	ldr	r3, [pc, #14]	; 3f0e048 <saveenv+0x24>
 3f0e030:	e59f1014 	ldr	r1, [pc, #14]	; 3f0e04c <saveenv+0x28>
 3f0e034:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0e038:	e5932000 	ldr	r2, [r3]
 3f0e03c:	e3a00807 	mov	r0, #458752	; 0x70000
 3f0e040:	ebfff53a 	bl	3f0b530 <nand_env_write>
 3f0e044:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0e048:	03f20dcc 	mvneqs	r0, #13056	; 0x3300
 3f0e04c:	00003ffc 	streqd	r3, [r0], -r12

03f0e050 <env_relocate_spec>:
 3f0e050:	e1a0c00d 	mov	r12, r13
 3f0e054:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

#endif /* CMD_SAVEENV */

void env_relocate_spec (void)
{
	/* read environment from NAND */
	nand_env_read(CFG_ENV_ADDR,ENV_SIZE,(u_char *)env_ptr);
 3f0e058:	e59f3014 	ldr	r3, [pc, #14]	; 3f0e074 <env_relocate_spec+0x24>
 3f0e05c:	e59f1014 	ldr	r1, [pc, #14]	; 3f0e078 <env_relocate_spec+0x28>
 3f0e060:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0e064:	e5932000 	ldr	r2, [r3]
 3f0e068:	e3a00807 	mov	r0, #458752	; 0x70000
 3f0e06c:	ebfff518 	bl	3f0b4d4 <nand_env_read>
 3f0e070:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0e074:	03f20dcc 	mvneqs	r0, #13056	; 0x3300
 3f0e078:	00003ffc 	streqd	r3, [r0], -r12

03f0e07c <dummy>:
 3f0e07c:	e1a0c00d 	mov	r12, r13
 3f0e080:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0e084:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0e088:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e08c <get_version>:
 3f0e08c:	e1a0c00d 	mov	r12, r13
 3f0e090:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0e094:	e24cb004 	sub	r11, r12, #4	; 0x4
}

unsigned long get_version(void)
{
	return XF_VERSION;
 3f0e098:	e3a00002 	mov	r0, #2	; 0x2
 3f0e09c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e0a0 <jumptable_init>:
 3f0e0a0:	e1a0c00d 	mov	r12, r13
 3f0e0a4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0e0a8:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void jumptable_init (void)
{
	DECLARE_GLOBAL_DATA_PTR;
	int i;

	gd->jt = (void **) malloc (XF_MAX * sizeof (void *));
 3f0e0ac:	e3a00038 	mov	r0, #56	; 0x38
 3f0e0b0:	ebfffb96 	bl	3f0cf10 <malloc>
	for (i = 0; i < XF_MAX; i++)
 3f0e0b4:	e3a01000 	mov	r1, #0	; 0x0
 3f0e0b8:	e5880020 	str	r0, [r8, #32]
		gd->jt[i] = (void *) dummy;
 3f0e0bc:	e5982020 	ldr	r2, [r8, #32]
 3f0e0c0:	e59f304c 	ldr	r3, [pc, #4c]	; 3f0e114 <jumptable_init+0x74>
 3f0e0c4:	e7823101 	str	r3, [r2, r1, lsl #2]
 3f0e0c8:	e2811001 	add	r1, r1, #1	; 0x1
 3f0e0cc:	e351000d 	cmp	r1, #13	; 0xd
 3f0e0d0:	dafffff9 	ble	3f0e0bc <jumptable_init+0x1c>

	gd->jt[XF_get_version] = (void *) get_version;
 3f0e0d4:	e5982020 	ldr	r2, [r8, #32]
 3f0e0d8:	e59f3038 	ldr	r3, [pc, #38]	; 3f0e118 <jumptable_init+0x78>
 3f0e0dc:	e5823000 	str	r3, [r2]
	gd->jt[XF_malloc] = (void *) malloc;
 3f0e0e0:	e59f3034 	ldr	r3, [pc, #34]	; 3f0e11c <jumptable_init+0x7c>
 3f0e0e4:	e5982020 	ldr	r2, [r8, #32]
 3f0e0e8:	e5823020 	str	r3, [r2, #32]
	gd->jt[XF_free] = (void *) free;
 3f0e0ec:	e59f302c 	ldr	r3, [pc, #2c]	; 3f0e120 <jumptable_init+0x80>
 3f0e0f0:	e5982020 	ldr	r2, [r8, #32]
 3f0e0f4:	e5823024 	str	r3, [r2, #36]
	gd->jt[XF_get_timer] = (void *)get_timer;
 3f0e0f8:	e59f3024 	ldr	r3, [pc, #24]	; 3f0e124 <jumptable_init+0x84>
 3f0e0fc:	e5982020 	ldr	r2, [r8, #32]
 3f0e100:	e582302c 	str	r3, [r2, #44]
	gd->jt[XF_udelay] = (void *)udelay;
 3f0e104:	e59f301c 	ldr	r3, [pc, #1c]	; 3f0e128 <jumptable_init+0x88>
 3f0e108:	e5982020 	ldr	r2, [r8, #32]
 3f0e10c:	e5823028 	str	r3, [r2, #40]
#if defined(CONFIG_I386) || defined(CONFIG_PPC)
	gd->jt[XF_install_hdlr] = (void *) irq_install_handler;
	gd->jt[XF_free_hdlr] = (void *) irq_free_handler;
#endif	/* I386 || PPC */
#if (CONFIG_COMMANDS & CFG_CMD_I2C)
	gd->jt[XF_i2c_write] = (void *) i2c_write;
	gd->jt[XF_i2c_read] = (void *) i2c_read;
#endif	/* CFG_CMD_I2C */
}
 3f0e110:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0e114:	03f0e07c 	mvneqs	r14, #124	; 0x7c
 3f0e118:	03f0e08c 	mvneqs	r14, #140	; 0x8c
 3f0e11c:	03f0cf10 	mvneqs	r12, #64	; 0x40
 3f0e120:	03f0d360 	mvneqs	r13, #-2147483647	; 0x80000001
 3f0e124:	03f007cc 	mvneqs	r0, #53477376	; 0x3300000
 3f0e128:	03f00818 	mvneqs	r0, #1572864	; 0x180000

03f0e12c <flash_protect>:
 3f0e12c:	e1a0c00d 	mov	r12, r13
 3f0e130:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f0e134:	e24cb004 	sub	r11, r12, #4	; 0x4
 * If necessary you have to map the second bank at lower addresses.
 */
void
flash_protect (int flag, ulong from, ulong to, flash_info_t *info)
{
 3f0e138:	e1a0e003 	mov	r14, r3
 3f0e13c:	e1a07000 	mov	r7, r0
 3f0e140:	e1a05001 	mov	r5, r1
	ulong b_end = info->start[0] + info->size - 1;	/* bank end address */
	short s_end = info->sector_count - 1;	/* index of last sector */
 3f0e144:	e1dec0b4 	ldrh	r12, [r14, #4]
 3f0e148:	e1a04002 	mov	r4, r2
	int i;

	/* Do nothing if input data is bad. */
	if (info->sector_count == 0 || info->size == 0 || to < from) {
 3f0e14c:	e35c0000 	cmp	r12, #0	; 0x0
 3f0e150:	e24cc001 	sub	r12, r12, #1	; 0x1
 3f0e154:	e59e000c 	ldr	r0, [r14, #12]
 3f0e158:	e1a0c80c 	mov	r12, r12, lsl #16
 3f0e15c:	e59e1000 	ldr	r1, [r14]
 3f0e160:	e1a0c82c 	mov	r12, r12, lsr #16
 3f0e164:	e0803001 	add	r3, r0, r1
 3f0e168:	e2436001 	sub	r6, r3, #1	; 0x1
 3f0e16c:	091ba8f0 	ldmeqdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0e170:	e1540005 	cmp	r4, r5
 3f0e174:	23a03000 	movcs	r3, #0	; 0x0
 3f0e178:	33a03001 	movcc	r3, #1	; 0x1
 3f0e17c:	e3510000 	cmp	r1, #0	; 0x0
 3f0e180:	03a03001 	moveq	r3, #1	; 0x1
 3f0e184:	e3530000 	cmp	r3, #0	; 0x0
 3f0e188:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}
		return;
	}

	/* There is nothing to do if we have no data about the flash
	 * or the protect range and flash range don't overlap.
	 */
	if (info->flash_id == FLASH_UNKNOWN ||
 3f0e18c:	e59e2008 	ldr	r2, [r14, #8]
 3f0e190:	e59f30a4 	ldr	r3, [pc, #a4]	; 3f0e23c <flash_protect+0x110>
 3f0e194:	e1520003 	cmp	r2, r3
 3f0e198:	091ba8f0 	ldmeqdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0e19c:	e1550006 	cmp	r5, r6
 3f0e1a0:	93a03000 	movls	r3, #0	; 0x0
 3f0e1a4:	83a03001 	movhi	r3, #1	; 0x1
 3f0e1a8:	e1540000 	cmp	r4, r0
 3f0e1ac:	21a02003 	movcs	r2, r3
 3f0e1b0:	33a02001 	movcc	r2, #1	; 0x1
 3f0e1b4:	e3520000 	cmp	r2, #0	; 0x0
 3f0e1b8:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}
	    to < info->start[0] || from > b_end) {
		return;
	}

	for (i=0; i<info->sector_count; ++i) {
 3f0e1bc:	e1de30b4 	ldrh	r3, [r14, #4]
 3f0e1c0:	e1a01002 	mov	r1, r2
 3f0e1c4:	e1510003 	cmp	r1, r3
 3f0e1c8:	a91ba8f0 	ldmgedb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0e1cc:	e3a00004 	mov	r0, #4	; 0x4
		ulong end;		/* last address in current sect	*/

		end = (i == s_end) ? b_end : info->start[i + 1] - 1;
 3f0e1d0:	e1a0380c 	mov	r3, r12, lsl #16
 3f0e1d4:	e1510843 	cmp	r1, r3, asr #16
 3f0e1d8:	128e300c 	addne	r3, r14, #12	; 0xc
 3f0e1dc:	17933000 	ldrne	r3, [r3, r0]
 3f0e1e0:	12433001 	subne	r3, r3, #1	; 0x1
 3f0e1e4:	01a03006 	moveq	r3, r6

		/* Update protection if any part of the sector
		 * is in the specified range.
		 */
		if (from <= end && to >= info->start[i]) {
 3f0e1e8:	e1550003 	cmp	r5, r3
 3f0e1ec:	8a00000c 	bhi	3f0e224 <flash_protect+0xf8>
 3f0e1f0:	e28e300c 	add	r3, r14, #12	; 0xc
 3f0e1f4:	e7933101 	ldr	r3, [r3, r1, lsl #2]
 3f0e1f8:	e1540003 	cmp	r4, r3
 3f0e1fc:	3a000008 	bcc	3f0e224 <flash_protect+0xf8>
			if (flag & FLAG_PROTECT_CLEAR) {
 3f0e200:	e3170002 	tst	r7, #2	; 0x2
#if defined(CFG_FLASH_PROTECTION)
				flash_real_protect(info, i, 0);
#else
				info->protect[i] = 0;
 3f0e204:	128e2010 	addne	r2, r14, #16	; 0x10
 3f0e208:	13a03000 	movne	r3, #0	; 0x0
#endif	/* CFG_FLASH_PROTECTION */
			}
 3f0e20c:	1a000003 	bne	3f0e220 <flash_protect+0xf4>
			else if (flag & FLAG_PROTECT_SET) {
 3f0e210:	e3170001 	tst	r7, #1	; 0x1
 3f0e214:	0a000002 	beq	3f0e224 <flash_protect+0xf8>
#if defined(CFG_FLASH_PROTECTION)
				flash_real_protect(info, i, 1);
#else
				info->protect[i] = 1;
 3f0e218:	e28e2010 	add	r2, r14, #16	; 0x10
 3f0e21c:	e3a03001 	mov	r3, #1	; 0x1
 3f0e220:	e7c23001 	strb	r3, [r2, r1]
 3f0e224:	e2800004 	add	r0, r0, #4	; 0x4
 3f0e228:	e1de30b4 	ldrh	r3, [r14, #4]
 3f0e22c:	e2811001 	add	r1, r1, #1	; 0x1
 3f0e230:	e1510003 	cmp	r1, r3
 3f0e234:	baffffe5 	blt	3f0e1d0 <flash_protect+0xa4>
#endif	/* CFG_FLASH_PROTECTION */
			}
		}
	}
}
 3f0e238:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f0e23c:	0000ffff 	streqd	r15, [r0], -r15

03f0e240 <addr2info>:
 3f0e240:	e1a0c00d 	mov	r12, r13
 3f0e244:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0e248:	e24cb004 	sub	r11, r12, #4	; 0x4

/*-----------------------------------------------------------------------
 */

flash_info_t *
addr2info (ulong addr)
{
#ifndef CONFIG_SPD823TS
	flash_info_t *info;
	int i;

	for (i=0, info=&flash_info[0]; i<CFG_MAX_FLASH_BANKS; ++i, ++info) {
		if (info->flash_id != FLASH_UNKNOWN &&
		    addr >= info->start[0] &&
		    /* WARNING - The '- 1' is needed if the flash
		     * is at the end of the address space, since
		     * info->start[0] + info->size wraps back to 0.
		     * Please don't change this unless you understand this.
		     */
		    addr <= info->start[0] + info->size - 1) {
			return (info);
		}
	}
#endif /* CONFIG_SPD823TS */

	return (NULL);
 3f0e24c:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0e250:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e254 <flash_write>:
 3f0e254:	e1a0c00d 	mov	r12, r13
 3f0e258:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0e25c:	e24cb004 	sub	r11, r12, #4	; 0x4

/*-----------------------------------------------------------------------
 * Copy memory to flash.
 * Make sure all target addresses are within Flash bounds,
 * and no protected sectors are hit.
 * Returns:
 * ERR_OK          0 - OK
 * ERR_TIMOUT      1 - write timeout
 * ERR_NOT_ERASED  2 - Flash not erased
 * ERR_PROTECTED   4 - target range includes protected sectors
 * ERR_INVAL       8 - target address not in Flash memory
 * ERR_ALIGN       16 - target address not aligned on boundary
 *			(only some targets require alignment)
 */
int
flash_write (uchar *src, ulong addr, ulong cnt)
{
 3f0e260:	e1a09000 	mov	r9, r0
 3f0e264:	e1a07001 	mov	r7, r1
 3f0e268:	e1a06002 	mov	r6, r2
#ifdef CONFIG_SPD823TS
	return (ERR_TIMOUT);	/* any other error codes are possible as well */
#else
	int i;
	ulong         end        = addr + cnt - 1;
	flash_info_t *info_first = addr2info (addr);
 3f0e26c:	e1a00007 	mov	r0, r7
 3f0e270:	e0873006 	add	r3, r7, r6
 3f0e274:	e2433001 	sub	r3, r3, #1	; 0x1
 3f0e278:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f0e27c:	e50b3028 	str	r3, [r11, -#40]
 3f0e280:	ebffffee 	bl	3f0e240 <addr2info>
 3f0e284:	e1a04000 	mov	r4, r0
	flash_info_t *info_last  = addr2info (end );
 3f0e288:	e51b0028 	ldr	r0, [r11, -#40]
 3f0e28c:	ebffffeb 	bl	3f0e240 <addr2info>
	flash_info_t *info;

	if (cnt == 0) {
 3f0e290:	e3560000 	cmp	r6, #0	; 0x0
 3f0e294:	e1a0a000 	mov	r10, r0
 3f0e298:	0a000051 	beq	3f0e3e4 <flash_write+0x190>
		return (ERR_OK);
	}

	if (!info_first || !info_last) {
 3f0e29c:	e35a0000 	cmp	r10, #0	; 0x0
 3f0e2a0:	13540000 	cmpne	r4, #0	; 0x0
 3f0e2a4:	1a000003 	bne	3f0e2b8 <flash_write+0x64>
		return (ERR_INVAL);
 3f0e2a8:	e3a00008 	mov	r0, #8	; 0x8
 3f0e2ac:	ea00004d 	b	3f0e3e8 <flash_write+0x194>
	}

	for (info = info_first; info <= info_last; ++info) {
		ulong b_end = info->start[0] + info->size;	/* bank end addr */
		short s_end = info->sector_count - 1;
		for (i=0; i<info->sector_count; ++i) {
			ulong e_addr = (i == s_end) ? b_end : info->start[i + 1];

			if ((end >= info->start[i]) && (addr < e_addr) &&
			    (info->protect[i] != 0) ) {
				return (ERR_PROTECTED);
 3f0e2b0:	e3a00004 	mov	r0, #4	; 0x4
			}
		}
	}

	/* finally write data to flash */
	for (info = info_first; info <= info_last && cnt>0; ++info) {
		ulong len;

		len = info->start[0] + info->size - addr;
		if (len > cnt)
			len = cnt;
		if ((i = write_buff(info, src, addr, len)) != 0) {
			return (i);
 3f0e2b4:	ea00004b 	b	3f0e3e8 <flash_write+0x194>
 3f0e2b8:	e1a05004 	mov	r5, r4
 3f0e2bc:	e155000a 	cmp	r5, r10
 3f0e2c0:	8a000028 	bhi	3f0e368 <flash_write+0x114>
 3f0e2c4:	e595100c 	ldr	r1, [r5, #12]
 3f0e2c8:	e1d530b4 	ldrh	r3, [r5, #4]
 3f0e2cc:	e3a00000 	mov	r0, #0	; 0x0
 3f0e2d0:	e50b3030 	str	r3, [r11, -#48]
 3f0e2d4:	e1500003 	cmp	r0, r3
 3f0e2d8:	e1d530b4 	ldrh	r3, [r5, #4]
 3f0e2dc:	e2433001 	sub	r3, r3, #1	; 0x1
 3f0e2e0:	e5952000 	ldr	r2, [r5]
 3f0e2e4:	e1a03803 	mov	r3, r3, lsl #16
 3f0e2e8:	e0811002 	add	r1, r1, r2
 3f0e2ec:	e50b102c 	str	r1, [r11, -#44]
 3f0e2f0:	e1a01823 	mov	r1, r3, lsr #16
 3f0e2f4:	aa000018 	bge	3f0e35c <flash_write+0x108>
 3f0e2f8:	e3a0e004 	mov	r14, #4	; 0x4
 3f0e2fc:	e1a03801 	mov	r3, r1, lsl #16
 3f0e300:	e1500843 	cmp	r0, r3, asr #16
 3f0e304:	1285300c 	addne	r3, r5, #12	; 0xc
 3f0e308:	1793c00e 	ldrne	r12, [r3, r14]
 3f0e30c:	051bc02c 	ldreq	r12, [r11, -#44]
 3f0e310:	e285300c 	add	r3, r5, #12	; 0xc
 3f0e314:	e7932100 	ldr	r2, [r3, r0, lsl #2]
 3f0e318:	e157000c 	cmp	r7, r12
 3f0e31c:	23a03000 	movcs	r3, #0	; 0x0
 3f0e320:	33a03001 	movcc	r3, #1	; 0x1
 3f0e324:	e51bc028 	ldr	r12, [r11, -#40]
 3f0e328:	e15c0002 	cmp	r12, r2
 3f0e32c:	33a03000 	movcc	r3, #0	; 0x0
 3f0e330:	e3530000 	cmp	r3, #0	; 0x0
 3f0e334:	0a000003 	beq	3f0e348 <flash_write+0xf4>
 3f0e338:	e2853010 	add	r3, r5, #16	; 0x10
 3f0e33c:	e7d33000 	ldrb	r3, [r3, r0]
 3f0e340:	e3530000 	cmp	r3, #0	; 0x0
 3f0e344:	1affffd9 	bne	3f0e2b0 <flash_write+0x5c>
 3f0e348:	e28ee004 	add	r14, r14, #4	; 0x4
 3f0e34c:	e51b3030 	ldr	r3, [r11, -#48]
 3f0e350:	e2800001 	add	r0, r0, #1	; 0x1
 3f0e354:	e1500003 	cmp	r0, r3
 3f0e358:	baffffe7 	blt	3f0e2fc <flash_write+0xa8>
 3f0e35c:	e2855014 	add	r5, r5, #20	; 0x14
 3f0e360:	e155000a 	cmp	r5, r10
 3f0e364:	9affffd6 	bls	3f0e2c4 <flash_write+0x70>
 3f0e368:	e1a05004 	mov	r5, r4
 3f0e36c:	e2563000 	subs	r3, r6, #0	; 0x0
 3f0e370:	13a03001 	movne	r3, #1	; 0x1
 3f0e374:	e155000a 	cmp	r5, r10
 3f0e378:	83a03000 	movhi	r3, #0	; 0x0
 3f0e37c:	e3530000 	cmp	r3, #0	; 0x0
 3f0e380:	0a000017 	beq	3f0e3e4 <flash_write+0x190>
 3f0e384:	e595300c 	ldr	r3, [r5, #12]
 3f0e388:	e1a00005 	mov	r0, r5
 3f0e38c:	e5952000 	ldr	r2, [r5]
 3f0e390:	e1a01009 	mov	r1, r9
 3f0e394:	e0833002 	add	r3, r3, r2
 3f0e398:	e0674003 	rsb	r4, r7, r3
 3f0e39c:	e1540006 	cmp	r4, r6
 3f0e3a0:	21a04006 	movcs	r4, r6
 3f0e3a4:	e1a02007 	mov	r2, r7
 3f0e3a8:	e1a03004 	mov	r3, r4
 3f0e3ac:	eb001706 	bl	3f13fcc <write_buff>
 3f0e3b0:	e3500000 	cmp	r0, #0	; 0x0
 3f0e3b4:	1a00000b 	bne	3f0e3e8 <flash_write+0x194>
		}
		cnt  -= len;
		addr += len;
 3f0e3b8:	e0877004 	add	r7, r7, r4
		src  += len;
 3f0e3bc:	e0899004 	add	r9, r9, r4
 3f0e3c0:	e2855014 	add	r5, r5, #20	; 0x14
 3f0e3c4:	e155000a 	cmp	r5, r10
 3f0e3c8:	83a02000 	movhi	r2, #0	; 0x0
 3f0e3cc:	93a02001 	movls	r2, #1	; 0x1
 3f0e3d0:	e0566004 	subs	r6, r6, r4
 3f0e3d4:	03a03000 	moveq	r3, #0	; 0x0
 3f0e3d8:	13a03001 	movne	r3, #1	; 0x1
 3f0e3dc:	e1120003 	tst	r2, r3
 3f0e3e0:	1affffe7 	bne	3f0e384 <flash_write+0x130>
	}
	return (ERR_OK);
 3f0e3e4:	e3a00000 	mov	r0, #0	; 0x0
#endif /* CONFIG_SPD823TS */
}
 3f0e3e8:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0e3ec <flash_perror>:
 3f0e3ec:	e1a0c00d 	mov	r12, r13
 3f0e3f0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0e3f4:	e24cb004 	sub	r11, r12, #4	; 0x4

/*-----------------------------------------------------------------------
 */

void flash_perror (int err)
{
 3f0e3f8:	e1a03000 	mov	r3, r0
	switch (err) {
 3f0e3fc:	e3530008 	cmp	r3, #8	; 0x8
 3f0e400:	0a00001f 	beq	3f0e484 <flash_perror+0x98>
 3f0e404:	ca00000a 	bgt	3f0e434 <flash_perror+0x48>
 3f0e408:	e3530001 	cmp	r3, #1	; 0x1
 3f0e40c:	0a000013 	beq	3f0e460 <flash_perror+0x74>
 3f0e410:	ca000002 	bgt	3f0e420 <flash_perror+0x34>
 3f0e414:	e3530000 	cmp	r3, #0	; 0x0
 3f0e418:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
 3f0e41c:	ea000027 	b	3f0e4c0 <flash_perror+0xd4>
 3f0e420:	e3530002 	cmp	r3, #2	; 0x2
 3f0e424:	0a000010 	beq	3f0e46c <flash_perror+0x80>
 3f0e428:	e3530004 	cmp	r3, #4	; 0x4
 3f0e42c:	0a000011 	beq	3f0e478 <flash_perror+0x8c>
 3f0e430:	ea000022 	b	3f0e4c0 <flash_perror+0xd4>
 3f0e434:	e3530020 	cmp	r3, #32	; 0x20
 3f0e438:	0a000017 	beq	3f0e49c <flash_perror+0xb0>
 3f0e43c:	ca000002 	bgt	3f0e44c <flash_perror+0x60>
 3f0e440:	e3530010 	cmp	r3, #16	; 0x10
 3f0e444:	0a000011 	beq	3f0e490 <flash_perror+0xa4>
 3f0e448:	ea00001c 	b	3f0e4c0 <flash_perror+0xd4>
 3f0e44c:	e3530040 	cmp	r3, #64	; 0x40
 3f0e450:	0a000014 	beq	3f0e4a8 <flash_perror+0xbc>
 3f0e454:	e3530080 	cmp	r3, #128	; 0x80
 3f0e458:	0a000015 	beq	3f0e4b4 <flash_perror+0xc8>
 3f0e45c:	ea000017 	b	3f0e4c0 <flash_perror+0xd4>
	case ERR_OK:
		break;
	case ERR_TIMOUT:
		puts ("Timeout writing to Flash\n");
 3f0e460:	e59f006c 	ldr	r0, [pc, #6c]	; 3f0e4d4 <flash_perror+0xe8>
 3f0e464:	ebfff8e9 	bl	3f0c810 <puts>
		break;
 3f0e468:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	case ERR_NOT_ERASED:
		puts ("Flash not Erased\n");
 3f0e46c:	e59f0064 	ldr	r0, [pc, #64]	; 3f0e4d8 <flash_perror+0xec>
 3f0e470:	ebfff8e6 	bl	3f0c810 <puts>
		break;
 3f0e474:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	case ERR_PROTECTED:
		puts ("Can't write to protected Flash sectors\n");
 3f0e478:	e59f005c 	ldr	r0, [pc, #5c]	; 3f0e4dc <flash_perror+0xf0>
 3f0e47c:	ebfff8e3 	bl	3f0c810 <puts>
		break;
 3f0e480:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	case ERR_INVAL:
		puts ("Outside available Flash\n");
 3f0e484:	e59f0054 	ldr	r0, [pc, #54]	; 3f0e4e0 <flash_perror+0xf4>
 3f0e488:	ebfff8e0 	bl	3f0c810 <puts>
		break;
 3f0e48c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	case ERR_ALIGN:
		puts ("Start and/or end address not on sector boundary\n");
 3f0e490:	e59f004c 	ldr	r0, [pc, #4c]	; 3f0e4e4 <flash_perror+0xf8>
 3f0e494:	ebfff8dd 	bl	3f0c810 <puts>
		break;
 3f0e498:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	case ERR_UNKNOWN_FLASH_VENDOR:
		puts ("Unknown Vendor of Flash\n");
 3f0e49c:	e59f0044 	ldr	r0, [pc, #44]	; 3f0e4e8 <flash_perror+0xfc>
 3f0e4a0:	ebfff8da 	bl	3f0c810 <puts>
		break;
 3f0e4a4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	case ERR_UNKNOWN_FLASH_TYPE:
		puts ("Unknown Type of Flash\n");
 3f0e4a8:	e59f003c 	ldr	r0, [pc, #3c]	; 3f0e4ec <flash_perror+0x100>
 3f0e4ac:	ebfff8d7 	bl	3f0c810 <puts>
		break;
 3f0e4b0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	case ERR_PROG_ERROR:
		puts ("General Flash Programming Error\n");
 3f0e4b4:	e59f0034 	ldr	r0, [pc, #34]	; 3f0e4f0 <flash_perror+0x104>
 3f0e4b8:	ebfff8d4 	bl	3f0c810 <puts>
		break;
 3f0e4bc:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	default:
		printf ("%s[%d] FIXME: rc=%d\n", __FILE__, __LINE__, err);
 3f0e4c0:	e59f002c 	ldr	r0, [pc, #2c]	; 3f0e4f4 <flash_perror+0x108>
 3f0e4c4:	e59f102c 	ldr	r1, [pc, #2c]	; 3f0e4f8 <flash_perror+0x10c>
 3f0e4c8:	e3a020d4 	mov	r2, #212	; 0xd4
 3f0e4cc:	ebfff8dc 	bl	3f0c844 <printf>
		break;
	}
 3f0e4d0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0e4d4:	03f1ef54 	mvneqs	r14, #336	; 0x150
 3f0e4d8:	03f1ef70 	mvneqs	r14, #448	; 0x1c0
 3f0e4dc:	03f1ef84 	mvneqs	r14, #528	; 0x210
 3f0e4e0:	03f1efac 	mvneqs	r14, #688	; 0x2b0
 3f0e4e4:	03f1efc8 	mvneqs	r14, #800	; 0x320
 3f0e4e8:	03f1effc 	mvneqs	r14, #1008	; 0x3f0
 3f0e4ec:	03f1f018 	mvneqs	r15, #24	; 0x18
 3f0e4f0:	03f1f030 	mvneqs	r15, #48	; 0x30
 3f0e4f4:	03f1f054 	mvneqs	r15, #84	; 0x54
 3f0e4f8:	03f1f06c 	mvneqs	r15, #108	; 0x6c

03f0e4fc <NewHandle>:
 3f0e4fc:	e1a0c00d 	mov	r12, r13
 3f0e500:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f0e504:	e24cb004 	sub	r11, r12, #4	; 0x4

/********************************************************************/

Handle NewHandle (unsigned int numBytes)
{
 3f0e508:	e1a06000 	mov	r6, r0
	void *memPtr;
	HandleRecord *hanPtr;

	memPtr = calloc (numBytes, 1);
 3f0e50c:	ebfffa7f 	bl	3f0cf10 <malloc>
 3f0e510:	e1a05000 	mov	r5, r0
	hanPtr = (HandleRecord *) calloc (sizeof (HandleRecord), 1);
 3f0e514:	e3a00008 	mov	r0, #8	; 0x8
 3f0e518:	ebfffa7c 	bl	3f0cf10 <malloc>
	if (hanPtr && (memPtr || numBytes == 0)) {
 3f0e51c:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0e520:	0a000009 	beq	3f0e54c <NewHandle+0x50>
 3f0e524:	e3560000 	cmp	r6, #0	; 0x0
 3f0e528:	13a03000 	movne	r3, #0	; 0x0
 3f0e52c:	03a03001 	moveq	r3, #1	; 0x1
 3f0e530:	e3550000 	cmp	r5, #0	; 0x0
 3f0e534:	13a03001 	movne	r3, #1	; 0x1
 3f0e538:	e3530000 	cmp	r3, #0	; 0x0
		hanPtr->ptr = memPtr;
 3f0e53c:	15845000 	strne	r5, [r4]
		hanPtr->size = numBytes;
		return (Handle) hanPtr;
 3f0e540:	11a00004 	movne	r0, r4
 3f0e544:	15846004 	strne	r6, [r4, #4]
 3f0e548:	191ba870 	ldmnedb	r11, {r4, r5, r6, r11, r13, r15}
	} else {
		free (memPtr);
 3f0e54c:	e1a00005 	mov	r0, r5
 3f0e550:	ebfffb82 	bl	3f0d360 <free>
		free (hanPtr);
 3f0e554:	e1a00004 	mov	r0, r4
 3f0e558:	ebfffb80 	bl	3f0d360 <free>
		return NULL;
 3f0e55c:	e3a00000 	mov	r0, #0	; 0x0
	}
}
 3f0e560:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f0e564 <DisposeHandle>:
 3f0e564:	e1a0c00d 	mov	r12, r13
 3f0e568:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f0e56c:	e24cb004 	sub	r11, r12, #4	; 0x4
/********************************************************************/

void DisposeHandle (Handle handle)
{
	if (handle) {
 3f0e570:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0e574:	091ba810 	ldmeqdb	r11, {r4, r11, r13, r15}
		free (*handle);
 3f0e578:	e5940000 	ldr	r0, [r4]
 3f0e57c:	ebfffb77 	bl	3f0d360 <free>
		free ((void *) handle);
 3f0e580:	e1a00004 	mov	r0, r4
 3f0e584:	ebfffb75 	bl	3f0d360 <free>
	}
 3f0e588:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f0e58c <GetHandleSize>:
 3f0e58c:	e1a0c00d 	mov	r12, r13
 3f0e590:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0e594:	e24cb004 	sub	r11, r12, #4	; 0x4
}
/********************************************************************/

unsigned int GetHandleSize (Handle handle)
{
	return ((HandleRecord *) handle)->size;
 3f0e598:	e5900004 	ldr	r0, [r0, #4]
 3f0e59c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e5a0 <SetHandleSize>:
 3f0e5a0:	e1a0c00d 	mov	r12, r13
 3f0e5a4:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f0e5a8:	e24cb004 	sub	r11, r12, #4	; 0x4
}
/********************************************************************/

int SetHandleSize (Handle handle, unsigned int newSize)
{
 3f0e5ac:	e1a05000 	mov	r5, r0
	HandleRecord *hanRecPtr = (HandleRecord *) handle;
	void *newPtr, *oldPtr;
	unsigned int oldSize;


	oldPtr = hanRecPtr->ptr;
	oldSize = hanRecPtr->size;
 3f0e5b0:	e5956004 	ldr	r6, [r5, #4]
 3f0e5b4:	e1a04001 	mov	r4, r1

	if (oldSize == newSize)
 3f0e5b8:	e1560004 	cmp	r6, r4
 3f0e5bc:	e5950000 	ldr	r0, [r5]
 3f0e5c0:	1a000001 	bne	3f0e5cc <SetHandleSize+0x2c>
		return 1;
 3f0e5c4:	e3a00001 	mov	r0, #1	; 0x1
 3f0e5c8:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

	if (oldPtr == NULL) {
 3f0e5cc:	e3500000 	cmp	r0, #0	; 0x0
 3f0e5d0:	1a000002 	bne	3f0e5e0 <SetHandleSize+0x40>
		newPtr = malloc (newSize);
 3f0e5d4:	e1a00004 	mov	r0, r4
 3f0e5d8:	ebfffa4c 	bl	3f0cf10 <malloc>
	} else {
 3f0e5dc:	ea000001 	b	3f0e5e8 <SetHandleSize+0x48>
		newPtr = realloc (oldPtr, newSize);
 3f0e5e0:	e1a01004 	mov	r1, r4
 3f0e5e4:	ebfffbe8 	bl	3f0d58c <realloc>
	}
	if (newPtr || (newSize == 0)) {
 3f0e5e8:	e3540000 	cmp	r4, #0	; 0x0
 3f0e5ec:	13a03000 	movne	r3, #0	; 0x0
 3f0e5f0:	03a03001 	moveq	r3, #1	; 0x1
 3f0e5f4:	e3500000 	cmp	r0, #0	; 0x0
 3f0e5f8:	13a03001 	movne	r3, #1	; 0x1
 3f0e5fc:	e3530000 	cmp	r3, #0	; 0x0
 3f0e600:	0a000008 	beq	3f0e628 <SetHandleSize+0x88>
		hanRecPtr->ptr = newPtr;
 3f0e604:	e5850000 	str	r0, [r5]
		hanRecPtr->size = newSize;
		if (newSize > oldSize)
 3f0e608:	e1540006 	cmp	r4, r6
 3f0e60c:	e5854004 	str	r4, [r5, #4]
 3f0e610:	9affffeb 	bls	3f0e5c4 <SetHandleSize+0x24>
			memset ((char *) newPtr + oldSize, 0, newSize - oldSize);
 3f0e614:	e0800006 	add	r0, r0, r6
 3f0e618:	e3a01000 	mov	r1, #0	; 0x0
 3f0e61c:	e0662004 	rsb	r2, r6, r4
 3f0e620:	eb0003be 	bl	3f0f520 <memset>
		return 1;
 3f0e624:	eaffffe6 	b	3f0e5c4 <SetHandleSize+0x24>
	} else
		return 0;
 3f0e628:	e1a00003 	mov	r0, r3
}
 3f0e62c:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f0e630 <ExpandListSpace>:
 3f0e630:	e1a0c00d 	mov	r12, r13
 3f0e634:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0e638:	e24cb004 	sub	r11, r12, #4	; 0x4

#ifdef	CFG_ALL_LIST_FUNCTIONS

/*  Used to compare list elements by their raw data contents */
static int ListMemBlockCmp (void *a, void *b, int size)
{
	return memcmp (a, b, size);
}

/***************************************************************************/

/*
 * Binary search numElements of size elementSize in array for a match
 * to the. item. Return the index of the element that matches
 * (0 - numElements - 1). If no match is found return the -i-1 where
 * i is the index (0 - numElements) where the item should be placed.
 * (*theCmp)(a,b) should return <0 if a<b, 0 if a==b, >0 if a>b.
 *
 * This function is like the C-Library function bsearch() except that
 * this function returns the index where the item should be placed if
 * it is not found.
 */
int BinSearch ( void *array, int numElements, int elementSize,
		void *itemPtr, CompareFunction compareFunction)
{
	int low, high, mid, cmp;
	void *arrayItemPtr;

	for (low = 0, high = numElements - 1, mid = 0, cmp = -1; low <= high;) {
		mid = (low + high) >> 1;

		arrayItemPtr = (void *) (((char *) array) + (mid * elementSize));
		cmp = compareFunction
			? compareFunction (itemPtr, arrayItemPtr)
			: ListMemBlockCmp (itemPtr, arrayItemPtr, elementSize);
		if (cmp == 0) {
			return mid;
		} else if (cmp < 0) {
			high = mid - 1;
		} else {
			low = mid + 1;
		}
	}
	if (cmp > 0)
		mid++;

	return -mid - 1;
}

#endif	/* CFG_ALL_LIST_FUNCTIONS */

/*******************************************************************************/

/*
 * If numNewItems == 0 then expand the list by the number of items
 * indicated by its allocation policy.
 * If numNewItems > 0 then expand the list by exactly the number of
 * items indicated.
 * If numNewItems < 0 then expand the list by the absolute value of
 * numNewItems plus the number of items indicated by its allocation
 * policy.
 * Returns 1 for success, 0 if out of memory
*/
static int ExpandListSpace (list_t list, int numNewItems)
{
	if (numNewItems == 0) {
 3f0e63c:	e2514000 	subs	r4, r1, #0	; 0x0
 3f0e640:	e1a05000 	mov	r5, r0
 3f0e644:	1a00000d 	bne	3f0e680 <ExpandListSpace+0x50>
		numNewItems = NUMITEMSPERALLOC (list);
 3f0e648:	e5951000 	ldr	r1, [r5]
 3f0e64c:	e5913004 	ldr	r3, [r1, #4]
 3f0e650:	e591200c 	ldr	r2, [r1, #12]
 3f0e654:	e2833064 	add	r3, r3, #100	; 0x64
 3f0e658:	e0030392 	mul	r3, r2, r3
 3f0e65c:	e59f2094 	ldr	r2, [pc, #94]	; 3f0e6f8 <ExpandListSpace+0xc8>
 3f0e660:	e0c0c392 	smull	r12, r0, r2, r3
 3f0e664:	e1a03fc3 	mov	r3, r3, asr #31
 3f0e668:	e5912008 	ldr	r2, [r1, #8]
 3f0e66c:	e06332c0 	rsb	r3, r3, r0, asr #5
 3f0e670:	e1520003 	cmp	r2, r3
 3f0e674:	a1a04002 	movge	r4, r2
 3f0e678:	b1a04003 	movlt	r4, r3
	} else if (numNewItems < 0) {
 3f0e67c:	ea00000d 	b	3f0e6b8 <ExpandListSpace+0x88>
 3f0e680:	aa00000c 	bge	3f0e6b8 <ExpandListSpace+0x88>
		numNewItems = (-numNewItems) + NUMITEMSPERALLOC (list);
 3f0e684:	e5951000 	ldr	r1, [r5]
 3f0e688:	e5913004 	ldr	r3, [r1, #4]
 3f0e68c:	e591200c 	ldr	r2, [r1, #12]
 3f0e690:	e2833064 	add	r3, r3, #100	; 0x64
 3f0e694:	e0030392 	mul	r3, r2, r3
 3f0e698:	e59f2058 	ldr	r2, [pc, #58]	; 3f0e6f8 <ExpandListSpace+0xc8>
 3f0e69c:	e0c0c392 	smull	r12, r0, r2, r3
 3f0e6a0:	e1a03fc3 	mov	r3, r3, asr #31
 3f0e6a4:	e5912008 	ldr	r2, [r1, #8]
 3f0e6a8:	e06332c0 	rsb	r3, r3, r0, asr #5
 3f0e6ac:	e1520003 	cmp	r2, r3
 3f0e6b0:	a0644002 	rsbge	r4, r4, r2
 3f0e6b4:	b0644003 	rsblt	r4, r4, r3
	}

	if (SetHandleSize ((Handle) list,
 3f0e6b8:	e5952000 	ldr	r2, [r5]
 3f0e6bc:	e592300c 	ldr	r3, [r2, #12]
 3f0e6c0:	e5922010 	ldr	r2, [r2, #16]
 3f0e6c4:	e0833004 	add	r3, r3, r4
 3f0e6c8:	e0010392 	mul	r1, r2, r3
 3f0e6cc:	e1a00005 	mov	r0, r5
 3f0e6d0:	e281101c 	add	r1, r1, #28	; 0x1c
 3f0e6d4:	ebffffb1 	bl	3f0e5a0 <SetHandleSize>
 3f0e6d8:	e3500000 	cmp	r0, #0	; 0x0
 3f0e6dc:	091ba830 	ldmeqdb	r11, {r4, r5, r11, r13, r15}
			   sizeof (ListStruct) +
			   ((*list)->listSize +
			   numNewItems) * (*list)->itemSize)) {
		(*list)->listSize += numNewItems;
 3f0e6e0:	e5952000 	ldr	r2, [r5]
 3f0e6e4:	e592300c 	ldr	r3, [r2, #12]
		return 1;
 3f0e6e8:	e3a00001 	mov	r0, #1	; 0x1
 3f0e6ec:	e0833004 	add	r3, r3, r4
 3f0e6f0:	e582300c 	str	r3, [r2, #12]
 3f0e6f4:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f0e6f8:	51eb851f 	mvnpl	r8, r15, lsl r5

03f0e6fc <ListCreate>:
 3f0e6fc:	e1a0c00d 	mov	r12, r13
 3f0e700:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f0e704:	e24cb004 	sub	r11, r12, #4	; 0x4
	} else {
		return 0;
	}
}

/*******************************/

#ifdef	CFG_ALL_LIST_FUNCTIONS

/*
 * This function reallocate the list, minus any currently unused
 * portion of its allotted memory.
 */
void ListCompact (list_t list)
{

	if (!SetHandleSize ((Handle) list,
			    sizeof (ListStruct) +
			    (*list)->numItems * (*list)->itemSize)) {
		return;
	}

	(*list)->listSize = (*list)->numItems;
}

#endif	/* CFG_ALL_LIST_FUNCTIONS */

/*******************************/

list_t ListCreate (int elementSize)
{
 3f0e708:	e1a04000 	mov	r4, r0
	list_t list;

	list = (list_t) (NewHandle (sizeof (ListStruct)));  /* create empty list */
 3f0e70c:	e3a0001c 	mov	r0, #28	; 0x1c
 3f0e710:	ebffff79 	bl	3f0e4fc <NewHandle>
	if (list) {
 3f0e714:	e3500000 	cmp	r0, #0	; 0x0
 3f0e718:	091ba810 	ldmeqdb	r11, {r4, r11, r13, r15}
		(*list)->signature = LIST_SIGNATURE;
 3f0e71c:	e5902000 	ldr	r2, [r0]
 3f0e720:	e59f3038 	ldr	r3, [pc, #38]	; 3f0e760 <ListCreate+0x64>
 3f0e724:	e5823000 	str	r3, [r2]
		(*list)->numItems = 0;
 3f0e728:	e5903000 	ldr	r3, [r0]
 3f0e72c:	e3a02000 	mov	r2, #0	; 0x0
 3f0e730:	e5832014 	str	r2, [r3, #20]
		(*list)->listSize = 0;
 3f0e734:	e5903000 	ldr	r3, [r0]
 3f0e738:	e583200c 	str	r2, [r3, #12]
		(*list)->itemSize = elementSize;
 3f0e73c:	e5903000 	ldr	r3, [r0]
 3f0e740:	e5834010 	str	r4, [r3, #16]
		(*list)->percentIncrease = kDefaultAllocationPercentIncrease;
 3f0e744:	e5902000 	ldr	r2, [r0]
 3f0e748:	e3a0300a 	mov	r3, #10	; 0xa
 3f0e74c:	e5823004 	str	r3, [r2, #4]
		(*list)->minNumItemsIncrease =
 3f0e750:	e5902000 	ldr	r2, [r0]
 3f0e754:	e2433006 	sub	r3, r3, #6	; 0x6
 3f0e758:	e5823008 	str	r3, [r2, #8]
				kDefaultAllocationminNumItemsIncrease;
	}

	return list;
}
 3f0e75c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f0e760:	4c495354 	mcrrmi	3, 5, r5, r9, cr4

03f0e764 <ListSetAllocationPolicy>:
 3f0e764:	e1a0c00d 	mov	r12, r13
 3f0e768:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

/*******************************/

void ListSetAllocationPolicy (list_t list, int minItemsPerAlloc,
			      int percentIncreasePerAlloc)
{
	(*list)->percentIncrease = percentIncreasePerAlloc;
 3f0e76c:	e5903000 	ldr	r3, [r0]
 3f0e770:	e5832004 	str	r2, [r3, #4]
	(*list)->minNumItemsIncrease = minItemsPerAlloc;
 3f0e774:	e5903000 	ldr	r3, [r0]
 3f0e778:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0e77c:	e5831008 	str	r1, [r3, #8]
 3f0e780:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e784 <ListDispose>:
 3f0e784:	e1a0c00d 	mov	r12, r13
 3f0e788:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0e78c:	e24cb004 	sub	r11, r12, #4	; 0x4
}

/*******************************/

void ListDispose (list_t list)
{
	DisposeHandle ((Handle) list);
 3f0e790:	ebffff73 	bl	3f0e564 <DisposeHandle>
 3f0e794:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e798 <ListInsertItem>:
 3f0e798:	e1a0c00d 	mov	r12, r13
 3f0e79c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0e7a0:	e24cb004 	sub	r11, r12, #4	; 0x4
}
/*******************************/

#ifdef	CFG_ALL_LIST_FUNCTIONS

void ListDisposePtrList (list_t list)
{
	int index;
	int numItems;

	if (list) {
		numItems = ListNumItems (list);

		for (index = 1; index <= numItems; index++)
			free (*(void **) ListGetPtrToItem (list, index));

		ListDispose (list);
	}
}

/*******************************/

/*
 * keeps memory, resets the number of items to 0
 */
void ListClear (list_t list)
{
	if (!list)
		return;
	(*list)->numItems = 0;
}

/*******************************/

/*
 * copy is only as large as necessary
 */
list_t ListCopy (list_t originalList)
{
	list_t tempList = NULL;
	int numItems;

	if (!originalList)
		return NULL;

	tempList = ListCreate ((*originalList)->itemSize);
	if (tempList) {
		numItems = ListNumItems (originalList);

		if (!SetHandleSize ((Handle) tempList,
				    sizeof (ListStruct) +
				    numItems * (*tempList)->itemSize)) {
			ListDispose (tempList);
			return NULL;
		}

		(*tempList)->numItems = (*originalList)->numItems;
		(*tempList)->listSize = (*originalList)->numItems;
		(*tempList)->itemSize = (*originalList)->itemSize;
		(*tempList)->percentIncrease = (*originalList)->percentIncrease;
		(*tempList)->minNumItemsIncrease =
				(*originalList)->minNumItemsIncrease;

		memcpy (ITEMPTR (tempList, 0), ITEMPTR (originalList, 0),
				numItems * (*tempList)->itemSize);
	}

	return tempList;
}

/********************************/

/*
 * list1 = list1 + list2
 */
int ListAppend (list_t list1, list_t list2)
{
	int numItemsL1, numItemsL2;

	if (!list2)
		return 1;

	if (!list1)
		return 0;
	if ((*list1)->itemSize != (*list2)->itemSize)
		return 0;

	numItemsL1 = ListNumItems (list1);
	numItemsL2 = ListNumItems (list2);

	if (numItemsL2 == 0)
		return 1;

	if (!SetHandleSize ((Handle) list1,
			    sizeof (ListStruct) + (numItemsL1 + numItemsL2) *
					(*list1)->itemSize)) {
		return 0;
	}

	(*list1)->numItems = numItemsL1 + numItemsL2;
	(*list1)->listSize = numItemsL1 + numItemsL2;

	memmove (ITEMPTR (list1, numItemsL1),
		 ITEMPTR (list2, 0),
		 numItemsL2 * (*list2)->itemSize);

	return 1;
}

#endif	/* CFG_ALL_LIST_FUNCTIONS */

/*******************************/

/*
 * returns 1 if the item is inserted, returns 0 if out of memory or
 * bad arguments were passed.
 */
int ListInsertItem (list_t list, void *ptrToItem, int itemPosition)
{
	return ListInsertItems (list, ptrToItem, itemPosition, 1);
 3f0e7a4:	e3a03001 	mov	r3, #1	; 0x1
 3f0e7a8:	eb000000 	bl	3f0e7b0 <ListInsertItems>
 3f0e7ac:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e7b0 <ListInsertItems>:
 3f0e7b0:	e1a0c00d 	mov	r12, r13
 3f0e7b4:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f0e7b8:	e24cb004 	sub	r11, r12, #4	; 0x4
}

/*******************************/

int ListInsertItems (list_t list, void *ptrToItems, int firstItemPosition,
		     int numItemsToInsert)
{
 3f0e7bc:	e1a05000 	mov	r5, r0
 3f0e7c0:	e1a04002 	mov	r4, r2
	int numItems = (*list)->numItems;
 3f0e7c4:	e5950000 	ldr	r0, [r5]
 3f0e7c8:	e1a0a001 	mov	r10, r1
 3f0e7cc:	e5906014 	ldr	r6, [r0, #20]
 3f0e7d0:	e1a07003 	mov	r7, r3

	if (firstItemPosition == numItems + 1)
 3f0e7d4:	e2862001 	add	r2, r6, #1	; 0x1
 3f0e7d8:	e1540002 	cmp	r4, r2
 3f0e7dc:	0a000003 	beq	3f0e7f0 <ListInsertItems+0x40>
		firstItemPosition = LIST_END;
	else if (firstItemPosition > numItems)
 3f0e7e0:	e1540006 	cmp	r4, r6
 3f0e7e4:	da000002 	ble	3f0e7f4 <ListInsertItems+0x44>
		return 0;
 3f0e7e8:	e3a00000 	mov	r0, #0	; 0x0
 3f0e7ec:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f0e7f0:	e3a04000 	mov	r4, #0	; 0x0

	if ((*list)->numItems >= (*list)->listSize) {
 3f0e7f4:	e5902014 	ldr	r2, [r0, #20]
 3f0e7f8:	e590300c 	ldr	r3, [r0, #12]
 3f0e7fc:	e1520003 	cmp	r2, r3
 3f0e800:	ba000004 	blt	3f0e818 <ListInsertItems+0x68>
		if (!ExpandListSpace (list, -numItemsToInsert))
 3f0e804:	e1a00005 	mov	r0, r5
 3f0e808:	e2671000 	rsb	r1, r7, #0	; 0x0
 3f0e80c:	ebffff87 	bl	3f0e630 <ExpandListSpace>
 3f0e810:	e3500000 	cmp	r0, #0	; 0x0
 3f0e814:	091bacf0 	ldmeqdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
			return 0;
	}

	if (firstItemPosition == LIST_START) {
 3f0e818:	e3740001 	cmn	r4, #1	; 0x1
 3f0e81c:	1a000001 	bne	3f0e828 <ListInsertItems+0x78>
		if (numItems == 0) {
 3f0e820:	e2564000 	subs	r4, r6, #0	; 0x0
 3f0e824:	13a04001 	movne	r4, #1	; 0x1
			/* special case for empty list */
			firstItemPosition = LIST_END;
		} else {
			firstItemPosition = 1;
		}
	}

	if (firstItemPosition == LIST_END) {	/* add at the end of the list */
 3f0e828:	e3540000 	cmp	r4, #0	; 0x0
 3f0e82c:	1a00000e 	bne	3f0e86c <ListInsertItems+0xbc>
		if (ptrToItems)
 3f0e830:	e35a0000 	cmp	r10, #0	; 0x0
 3f0e834:	0a000008 	beq	3f0e85c <ListInsertItems+0xac>
			memcpy (ITEMPTR (list, numItems), ptrToItems,
 3f0e838:	e5950000 	ldr	r0, [r5]
 3f0e83c:	e5902010 	ldr	r2, [r0, #16]
 3f0e840:	e0030296 	mul	r3, r6, r2
 3f0e844:	e0020297 	mul	r2, r7, r2
 3f0e848:	e1a0100a 	mov	r1, r10
 3f0e84c:	e2833018 	add	r3, r3, #24	; 0x18
 3f0e850:	e0800003 	add	r0, r0, r3
 3f0e854:	eb00034b 	bl	3f0f588 <memcpy>
 3f0e858:	ea000024 	b	3f0e8f0 <ListInsertItems+0x140>
					(*list)->itemSize * numItemsToInsert);
		else
			memset (ITEMPTR (list, numItems), 0,
 3f0e85c:	e5950000 	ldr	r0, [r5]
 3f0e860:	e5902010 	ldr	r2, [r0, #16]
 3f0e864:	e0030296 	mul	r3, r6, r2
					(*list)->itemSize * numItemsToInsert);

		(*list)->numItems += numItemsToInsert;
	} else {					/* move part of list up to make room for new item */
 3f0e868:	ea00001b 	b	3f0e8dc <ListInsertItems+0x12c>
		memmove (ITEMPTR (list, firstItemPosition - 1 + numItemsToInsert),
 3f0e86c:	e595c000 	ldr	r12, [r5]
 3f0e870:	e2473001 	sub	r3, r7, #1	; 0x1
 3f0e874:	e59c2010 	ldr	r2, [r12, #16]
 3f0e878:	e0843003 	add	r3, r4, r3
 3f0e87c:	e0000293 	mul	r0, r3, r2
 3f0e880:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0e884:	e0010294 	mul	r1, r4, r2
 3f0e888:	e0643006 	rsb	r3, r4, r6
 3f0e88c:	e0020293 	mul	r2, r3, r2
 3f0e890:	e2800018 	add	r0, r0, #24	; 0x18
 3f0e894:	e08c0000 	add	r0, r12, r0
 3f0e898:	e2811018 	add	r1, r1, #24	; 0x18
 3f0e89c:	e08c1001 	add	r1, r12, r1
 3f0e8a0:	eb000345 	bl	3f0f5bc <memmove>
			 ITEMPTR (list, firstItemPosition - 1),
			 (numItems + 1 - firstItemPosition) * (*list)->itemSize);

		if (ptrToItems)
 3f0e8a4:	e35a0000 	cmp	r10, #0	; 0x0
 3f0e8a8:	0a000008 	beq	3f0e8d0 <ListInsertItems+0x120>
			memmove (ITEMPTR (list, firstItemPosition - 1), ptrToItems,
 3f0e8ac:	e5950000 	ldr	r0, [r5]
 3f0e8b0:	e5902010 	ldr	r2, [r0, #16]
 3f0e8b4:	e0030294 	mul	r3, r4, r2
 3f0e8b8:	e0020297 	mul	r2, r7, r2
 3f0e8bc:	e1a0100a 	mov	r1, r10
 3f0e8c0:	e2833018 	add	r3, r3, #24	; 0x18
 3f0e8c4:	e0800003 	add	r0, r0, r3
 3f0e8c8:	eb00033b 	bl	3f0f5bc <memmove>
 3f0e8cc:	ea000007 	b	3f0e8f0 <ListInsertItems+0x140>
					 (*list)->itemSize * numItemsToInsert);
		else
			memset (ITEMPTR (list, firstItemPosition - 1), 0,
 3f0e8d0:	e5950000 	ldr	r0, [r5]
 3f0e8d4:	e5902010 	ldr	r2, [r0, #16]
 3f0e8d8:	e0030294 	mul	r3, r4, r2
 3f0e8dc:	e0020297 	mul	r2, r7, r2
 3f0e8e0:	e1a0100a 	mov	r1, r10
 3f0e8e4:	e2833018 	add	r3, r3, #24	; 0x18
 3f0e8e8:	e0800003 	add	r0, r0, r3
 3f0e8ec:	eb00030b 	bl	3f0f520 <memset>
					(*list)->itemSize * numItemsToInsert);

		(*list)->numItems += numItemsToInsert;
 3f0e8f0:	e5952000 	ldr	r2, [r5]
 3f0e8f4:	e5923014 	ldr	r3, [r2, #20]
 3f0e8f8:	e0833007 	add	r3, r3, r7
 3f0e8fc:	e5823014 	str	r3, [r2, #20]
	}

	return 1;
 3f0e900:	e3a00001 	mov	r0, #1	; 0x1
}
 3f0e904:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f0e908 <ListGetItems>:
 3f0e908:	e1a0c00d 	mov	r12, r13
 3f0e90c:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0e910:	e24cb004 	sub	r11, r12, #4	; 0x4

#ifdef CFG_ALL_LIST_FUNCTIONS

/*******************************/

int ListEqual (list_t list1, list_t list2)
{
	if (list1 == list2)
		return 1;

	if (list1 == NULL || list2 == NULL)
		return 0;

	if ((*list1)->itemSize == (*list1)->itemSize) {
	    if ((*list1)->numItems == (*list2)->numItems) {
		return (memcmp (ITEMPTR (list1, 0), ITEMPTR (list2, 0),
				(*list1)->itemSize * (*list1)->numItems) == 0);
	    }
	}

	return 0;
}

/*******************************/

/*
 * The item pointed to by ptrToItem is copied over the current item
 * at itemPosition
 */
void ListReplaceItem (list_t list, void *ptrToItem, int itemPosition)
{
	ListReplaceItems (list, ptrToItem, itemPosition, 1);
}

/*******************************/

/*
 * The item pointed to by ptrToItems is copied over the current item
 * at itemPosition
 */
void ListReplaceItems ( list_t list, void *ptrToItems,
			int firstItemPosition, int numItemsToReplace)
{

	if (firstItemPosition == LIST_END)
		firstItemPosition = (*list)->numItems;
	else if (firstItemPosition == LIST_START)
		firstItemPosition = 1;

	memmove (ITEMPTR (list, firstItemPosition - 1), ptrToItems,
			 (*list)->itemSize * numItemsToReplace);
}

/*******************************/

void ListGetItem (list_t list, void *itemDestination, int itemPosition)
{
	ListGetItems (list, itemDestination, itemPosition, 1);
}

#endif	/* CFG_ALL_LIST_FUNCTIONS */

/*******************************/

#if defined(CFG_ALL_LIST_FUNCTIONS) || defined(CFG_DEVICE_DEREGISTER)

void ListRemoveItem (list_t list, void *itemDestination, int itemPosition)
{
	ListRemoveItems (list, itemDestination, itemPosition, 1);
}

/*******************************/

void ListRemoveItems (list_t list, void *itemsDestination,
		      int firstItemPosition, int numItemsToRemove)
{
	int firstItemAfterChunk, numToMove;

	if (firstItemPosition == LIST_START)
		firstItemPosition = 1;
	else if (firstItemPosition == LIST_END)
		firstItemPosition = (*list)->numItems;

	if (itemsDestination != NULL)
		memcpy (itemsDestination, ITEMPTR (list, firstItemPosition - 1),
				(*list)->itemSize * numItemsToRemove);

	firstItemAfterChunk = firstItemPosition + numItemsToRemove;
	numToMove = (*list)->numItems - (firstItemAfterChunk - 1);

	if (numToMove > 0) {
		/*
		 * move part of list down to cover hole left by removed item
		 */
		memmove (ITEMPTR (list, firstItemPosition - 1),
				 ITEMPTR (list, firstItemAfterChunk - 1),
				 (*list)->itemSize * numToMove);
	}

	(*list)->numItems -= numItemsToRemove;
}
#endif	/* CFG_ALL_LIST_FUNCTIONS || CFG_DEVICE_DEREGISTER */

/*******************************/

void ListGetItems (list_t list, void *itemsDestination,
		   int firstItemPosition, int numItemsToGet)
{
 3f0e914:	e1a0e002 	mov	r14, r2

	if (firstItemPosition == LIST_START)
 3f0e918:	e37e0001 	cmn	r14, #1	; 0x1
 3f0e91c:	e1a05001 	mov	r5, r1
 3f0e920:	e1a04003 	mov	r4, r3
		firstItemPosition = 1;
 3f0e924:	03a0e001 	moveq	r14, #1	; 0x1
 3f0e928:	0a000002 	beq	3f0e938 <ListGetItems+0x30>
	else if (firstItemPosition == LIST_END)
 3f0e92c:	e35e0000 	cmp	r14, #0	; 0x0
		firstItemPosition = (*list)->numItems;
 3f0e930:	05903000 	ldreq	r3, [r0]
 3f0e934:	0593e014 	ldreq	r14, [r3, #20]

	memcpy (itemsDestination,
 3f0e938:	e590c000 	ldr	r12, [r0]
 3f0e93c:	e59c2010 	ldr	r2, [r12, #16]
 3f0e940:	e24e3001 	sub	r3, r14, #1	; 0x1
 3f0e944:	e0010293 	mul	r1, r3, r2
 3f0e948:	e0020294 	mul	r2, r4, r2
 3f0e94c:	e1a00005 	mov	r0, r5
 3f0e950:	e2811018 	add	r1, r1, #24	; 0x18
 3f0e954:	e08c1001 	add	r1, r12, r1
 3f0e958:	eb00030a 	bl	3f0f588 <memcpy>
 3f0e95c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f0e960 <ListGetPtrToItem>:
 3f0e960:	e1a0c00d 	mov	r12, r13
 3f0e964:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0e968:	e24cb004 	sub	r11, r12, #4	; 0x4
		ITEMPTR (list, firstItemPosition - 1),
		(*list)->itemSize * numItemsToGet);
}

/*******************************/

/*
 * Returns a pointer to the item at itemPosition. returns null if an
 * errors occurred.
 */
void *ListGetPtrToItem (list_t list, int itemPosition)
{
 3f0e96c:	e1a03001 	mov	r3, r1
	if (itemPosition == LIST_START)
 3f0e970:	e3730001 	cmn	r3, #1	; 0x1
		itemPosition = 1;
 3f0e974:	03a03001 	moveq	r3, #1	; 0x1
 3f0e978:	0a000002 	beq	3f0e988 <ListGetPtrToItem+0x28>
	else if (itemPosition == LIST_END)
 3f0e97c:	e3530000 	cmp	r3, #0	; 0x0
		itemPosition = (*list)->numItems;
 3f0e980:	05903000 	ldreq	r3, [r0]
 3f0e984:	05933014 	ldreq	r3, [r3, #20]

	return ITEMPTR (list, itemPosition - 1);
 3f0e988:	e5901000 	ldr	r1, [r0]
 3f0e98c:	e5912010 	ldr	r2, [r1, #16]
 3f0e990:	e2433001 	sub	r3, r3, #1	; 0x1
 3f0e994:	e0000293 	mul	r0, r3, r2
 3f0e998:	e2800018 	add	r0, r0, #24	; 0x18
 3f0e99c:	e0810000 	add	r0, r1, r0
 3f0e9a0:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e9a4 <ListGetDataPtr>:
 3f0e9a4:	e1a0c00d 	mov	r12, r13
 3f0e9a8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

/*******************************/

/*
 * returns a pointer the lists data (abstraction violation for
 * optimization)
 */
void *ListGetDataPtr (list_t list)
{
	return &((*list)->itemList[0]);
 3f0e9ac:	e5900000 	ldr	r0, [r0]
 3f0e9b0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0e9b4:	e2800018 	add	r0, r0, #24	; 0x18
 3f0e9b8:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e9bc <ListGetItemSize>:
 3f0e9bc:	e1a0c00d 	mov	r12, r13
 3f0e9c0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

/********************************/

#ifdef	CFG_ALL_LIST_FUNCTIONS

int ListApplyToEach (list_t list, int ascending,
		     ListApplicationFunc funcToApply,
		     void *callbackData)
{
	int result = 0, index;

	if (!list || !funcToApply)
		goto Error;

	if (ascending) {
		for (index = 1; index <= ListNumItems (list); index++) {
			result = funcToApply (index,
					      ListGetPtrToItem (list, index),
					      callbackData);
			if (result < 0)
				goto Error;
		}
	} else {
		for (index = ListNumItems (list);
		     index > 0 && index <= ListNumItems (list);
		     index--) {
			result = funcToApply (index,
					      ListGetPtrToItem (list, index),
					      callbackData);
			if (result < 0)
				goto Error;
		}
	}

Error:
	return result;
}

#endif /* CFG_ALL_LIST_FUNCTIONS */

/********************************/

int ListGetItemSize (list_t list)
{
	return (*list)->itemSize;
 3f0e9c4:	e5903000 	ldr	r3, [r0]
 3f0e9c8:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0e9cc:	e5930010 	ldr	r0, [r3, #16]
 3f0e9d0:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e9d4 <ListNumItems>:
 3f0e9d4:	e1a0c00d 	mov	r12, r13
 3f0e9d8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

/********************************/

int ListNumItems (list_t list)
{
	return (*list)->numItems;
 3f0e9dc:	e5903000 	ldr	r3, [r0]
 3f0e9e0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0e9e4:	e5930014 	ldr	r0, [r3, #20]
 3f0e9e8:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0e9ec <srec_decode>:
 3f0e9ec:	e1a0c00d 	mov	r12, r13
 3f0e9f0:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0e9f4:	e24cb004 	sub	r11, r12, #4	; 0x4
static int hex1_bin (char  c);
static int hex2_bin (char *s);

int srec_decode (char *input, int *count, ulong *addr, char *data)
{
 3f0e9f8:	e1a05000 	mov	r5, r0
 3f0e9fc:	e1a06001 	mov	r6, r1
 3f0ea00:	e24dd004 	sub	r13, r13, #4	; 0x4
	int	i;
	int	v;				/* conversion buffer	*/
	int	srec_type;			/* S-Record type	*/
	unsigned char chksum;			/* buffer for checksum	*/

	chksum = 0;

	/* skip anything before 'S', and the 'S' itself.
	 * Return error if not found
	 */

	for (; *input; ++input) {
 3f0ea04:	e5d50000 	ldrb	r0, [r5]
 3f0ea08:	e1a07002 	mov	r7, r2
 3f0ea0c:	e50b3028 	str	r3, [r11, -#40]
 3f0ea10:	e3500000 	cmp	r0, #0	; 0x0
 3f0ea14:	0a000008 	beq	3f0ea3c <srec_decode+0x50>
		if (*input == 'S') {		/* skip 'S' */
 3f0ea18:	e3500053 	cmp	r0, #83	; 0x53
			++input;
			break;
 3f0ea1c:	ea000004 	b	3f0ea34 <srec_decode+0x48>
 3f0ea20:	e5f53001 	ldrb	r3, [r5, #1]!
 3f0ea24:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0ea28:	e3530000 	cmp	r3, #0	; 0x0
 3f0ea2c:	0a000002 	beq	3f0ea3c <srec_decode+0x50>
 3f0ea30:	e3530053 	cmp	r3, #83	; 0x53
 3f0ea34:	1afffff9 	bne	3f0ea20 <srec_decode+0x34>
 3f0ea38:	e2855001 	add	r5, r5, #1	; 0x1
		}
	}
	if (*input == '\0') {			/* no more data?	*/
 3f0ea3c:	e5d53000 	ldrb	r3, [r5]
 3f0ea40:	e3530000 	cmp	r3, #0	; 0x0
		return (SREC_EMPTY);
 3f0ea44:	03a0000a 	moveq	r0, #10	; 0xa
 3f0ea48:	0a00008c 	beq	3f0ec80 <srec_decode+0x294>
	}

	v = *input++;				/* record type		*/
 3f0ea4c:	e4d54001 	ldrb	r4, [r5], #1

	if ((*count = hex2_bin(input)) < 0) {
 3f0ea50:	e1a00005 	mov	r0, r5
 3f0ea54:	eb00009d 	bl	3f0ecd0 <hex2_bin>
 3f0ea58:	e3500000 	cmp	r0, #0	; 0x0
 3f0ea5c:	e5860000 	str	r0, [r6]
 3f0ea60:	ba000085 	blt	3f0ec7c <srec_decode+0x290>
		return (SREC_E_NOSREC);
	}

	chksum += *count;
	input  += 2;
 3f0ea64:	e2855002 	add	r5, r5, #2	; 0x2

	switch (v) {				/* record type		*/
 3f0ea68:	e2440030 	sub	r0, r4, #48	; 0x30
 3f0ea6c:	e5d6a000 	ldrb	r10, [r6]
 3f0ea70:	e3500009 	cmp	r0, #9	; 0x9
 3f0ea74:	979ff100 	ldrls	r15, [r15, r0, lsl #2]
 3f0ea78:	ea000028 	b	3f0eb20 <srec_decode+0x134>
 3f0ea7c:	03f0eaa4 	mvneqs	r14, #671744	; 0xa4000
 3f0ea80:	03f0eab0 	mvneqs	r14, #720896	; 0xb0000
 3f0ea84:	03f0eabc 	mvneqs	r14, #770048	; 0xbc000
 3f0ea88:	03f0eac8 	mvneqs	r14, #819200	; 0xc8000
 3f0ea8c:	03f0ec04 	mvneqs	r14, #1024	; 0x400
 3f0ea90:	03f0ead4 	mvneqs	r14, #868352	; 0xd4000
 3f0ea94:	03f0ec04 	mvneqs	r14, #1024	; 0x400
 3f0ea98:	03f0eae4 	mvneqs	r14, #933888	; 0xe4000
 3f0ea9c:	03f0eaf8 	mvneqs	r14, #1015808	; 0xf8000
 3f0eaa0:	03f0eb0c 	mvneqs	r14, #12288	; 0x3000

	case '0':				/* start record		*/
		srec_type = SREC_START;		/* 2 byte addr field	*/
		*count   -= 3;			/* - checksum and addr	*/
 3f0eaa4:	e5963000 	ldr	r3, [r6]
 3f0eaa8:	e3a09000 	mov	r9, #0	; 0x0
		break;
 3f0eaac:	ea000018 	b	3f0eb14 <srec_decode+0x128>
	case '1':
		srec_type = SREC_DATA2;		/* 2 byte addr field	*/
		*count   -= 3;			/* - checksum and addr	*/
 3f0eab0:	e5963000 	ldr	r3, [r6]
 3f0eab4:	e3a09001 	mov	r9, #1	; 0x1
		break;
 3f0eab8:	ea000015 	b	3f0eb14 <srec_decode+0x128>
	case '2':
		srec_type = SREC_DATA3;		/* 3 byte addr field	*/
		*count   -= 4;			/* - checksum and addr	*/
 3f0eabc:	e5963000 	ldr	r3, [r6]
 3f0eac0:	e3a09002 	mov	r9, #2	; 0x2
		break;
 3f0eac4:	ea00000d 	b	3f0eb00 <srec_decode+0x114>
	case '3':				/* data record with a	*/
		srec_type = SREC_DATA4;		/* 4 byte addr field	*/
		*count   -= 5;			/* - checksum and addr	*/
 3f0eac8:	e5963000 	ldr	r3, [r6]
 3f0eacc:	e3a09003 	mov	r9, #3	; 0x3
		break;
 3f0ead0:	ea000005 	b	3f0eaec <srec_decode+0x100>
/***	case '4'  ***/
	case '5':			/* count record, addr field contains */
		srec_type = SREC_COUNT;	/* a 2 byte record counter	*/
 3f0ead4:	e3a09005 	mov	r9, #5	; 0x5
		*count    = 0;			/* no data		*/
 3f0ead8:	e3a03000 	mov	r3, #0	; 0x0
 3f0eadc:	e5863000 	str	r3, [r6]
		break;
 3f0eae0:	ea00000f 	b	3f0eb24 <srec_decode+0x138>
/***	case '6' -- not used  ***/
	case '7':				/* end record with a	*/
		srec_type = SREC_END4;		/* 4 byte addr field	*/
		*count   -= 5;			/* - checksum and addr	*/
 3f0eae4:	e5963000 	ldr	r3, [r6]
 3f0eae8:	e3a09007 	mov	r9, #7	; 0x7
 3f0eaec:	e2433005 	sub	r3, r3, #5	; 0x5
 3f0eaf0:	e5863000 	str	r3, [r6]
		break;
 3f0eaf4:	ea00000a 	b	3f0eb24 <srec_decode+0x138>
	case '8':				/* end record with a	*/
		srec_type = SREC_END3;		/* 3 byte addr field	*/
		*count   -= 4;			/* - checksum and addr	*/
 3f0eaf8:	e5963000 	ldr	r3, [r6]
 3f0eafc:	e3a09008 	mov	r9, #8	; 0x8
 3f0eb00:	e2433004 	sub	r3, r3, #4	; 0x4
 3f0eb04:	e5863000 	str	r3, [r6]
		break;
 3f0eb08:	ea000005 	b	3f0eb24 <srec_decode+0x138>
	case '9':				/* end record with a	*/
		srec_type = SREC_END2;		/* 2 byte addr field	*/
		*count   -= 3;			/* - checksum and addr	*/
 3f0eb0c:	e5963000 	ldr	r3, [r6]
 3f0eb10:	e3a09009 	mov	r9, #9	; 0x9
 3f0eb14:	e2433003 	sub	r3, r3, #3	; 0x3
 3f0eb18:	e5863000 	str	r3, [r6]
		break;
 3f0eb1c:	ea000000 	b	3f0eb24 <srec_decode+0x138>
	default:
		return (SREC_E_BADTYPE);
 3f0eb20:	ea000037 	b	3f0ec04 <srec_decode+0x218>
	}

	/* read address field */
	*addr = 0;
 3f0eb24:	e3a03000 	mov	r3, #0	; 0x0
 3f0eb28:	e5873000 	str	r3, [r7]

	switch (v) {
 3f0eb2c:	e3500009 	cmp	r0, #9	; 0x9
 3f0eb30:	979ff100 	ldrls	r15, [r15, r0, lsl #2]
 3f0eb34:	ea000032 	b	3f0ec04 <srec_decode+0x218>
 3f0eb38:	03f0ebb0 	mvneqs	r14, #180224	; 0x2c000
 3f0eb3c:	03f0ebb0 	mvneqs	r14, #180224	; 0x2c000
 3f0eb40:	03f0eb88 	mvneqs	r14, #139264	; 0x22000
 3f0eb44:	03f0eb60 	mvneqs	r14, #98304	; 0x18000
 3f0eb48:	03f0ec04 	mvneqs	r14, #1024	; 0x400
 3f0eb4c:	03f0ebb0 	mvneqs	r14, #180224	; 0x2c000
 3f0eb50:	03f0ec04 	mvneqs	r14, #1024	; 0x400
 3f0eb54:	03f0eb60 	mvneqs	r14, #98304	; 0x18000
 3f0eb58:	03f0eb88 	mvneqs	r14, #139264	; 0x22000
 3f0eb5c:	03f0ebb0 	mvneqs	r14, #180224	; 0x2c000
	case '3':				/* 4 byte addr field	*/
	case '7':
		if ((v = hex2_bin(input)) < 0) {
 3f0eb60:	e1a00005 	mov	r0, r5
 3f0eb64:	eb000059 	bl	3f0ecd0 <hex2_bin>
 3f0eb68:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0eb6c:	ba000042 	blt	3f0ec7c <srec_decode+0x290>
			return (SREC_E_NOSREC);
		}
		*addr  += v;
		chksum += v;
 3f0eb70:	e08a3004 	add	r3, r10, r4
 3f0eb74:	e203a0ff 	and	r10, r3, #255	; 0xff
 3f0eb78:	e5973000 	ldr	r3, [r7]
		input  += 2;
 3f0eb7c:	e2855002 	add	r5, r5, #2	; 0x2
 3f0eb80:	e0833004 	add	r3, r3, r4
 3f0eb84:	e5873000 	str	r3, [r7]
		/* FALL THRU */
	case '2':				/* 3 byte addr field	*/
	case '8':
		if ((v = hex2_bin(input)) < 0) {
 3f0eb88:	e1a00005 	mov	r0, r5
 3f0eb8c:	eb00004f 	bl	3f0ecd0 <hex2_bin>
 3f0eb90:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0eb94:	ba000038 	blt	3f0ec7c <srec_decode+0x290>
			return (SREC_E_NOSREC);
		}
		*addr <<= 8;
		*addr  += v;
		chksum += v;
 3f0eb98:	e08a3004 	add	r3, r10, r4
 3f0eb9c:	e203a0ff 	and	r10, r3, #255	; 0xff
 3f0eba0:	e5973000 	ldr	r3, [r7]
		input  += 2;
 3f0eba4:	e2855002 	add	r5, r5, #2	; 0x2
 3f0eba8:	e0843403 	add	r3, r4, r3, lsl #8
 3f0ebac:	e5873000 	str	r3, [r7]
		/* FALL THRU */
	case '0':				/* 2 byte addr field	*/
	case '1':
	case '5':
	case '9':
		if ((v = hex2_bin(input)) < 0) {
 3f0ebb0:	e1a00005 	mov	r0, r5
 3f0ebb4:	eb000045 	bl	3f0ecd0 <hex2_bin>
 3f0ebb8:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0ebbc:	ba00002e 	blt	3f0ec7c <srec_decode+0x290>
			return (SREC_E_NOSREC);
		}
		*addr <<= 8;
		*addr  += v;
		chksum += v;
 3f0ebc0:	e08a3004 	add	r3, r10, r4
 3f0ebc4:	e203a0ff 	and	r10, r3, #255	; 0xff
		input  += 2;
 3f0ebc8:	e2855002 	add	r5, r5, #2	; 0x2
 3f0ebcc:	e5973000 	ldr	r3, [r7]

		if ((v = hex2_bin(input)) < 0) {
 3f0ebd0:	e1a00005 	mov	r0, r5
 3f0ebd4:	e0843403 	add	r3, r4, r3, lsl #8
 3f0ebd8:	e5873000 	str	r3, [r7]
 3f0ebdc:	eb00003b 	bl	3f0ecd0 <hex2_bin>
 3f0ebe0:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0ebe4:	ba000024 	blt	3f0ec7c <srec_decode+0x290>
			return (SREC_E_NOSREC);
		}
		*addr <<= 8;
		*addr  += v;
		chksum += v;
 3f0ebe8:	e08a3004 	add	r3, r10, r4
 3f0ebec:	e203a0ff 	and	r10, r3, #255	; 0xff
 3f0ebf0:	e5973000 	ldr	r3, [r7]
		input  += 2;
 3f0ebf4:	e2855002 	add	r5, r5, #2	; 0x2
 3f0ebf8:	e0843403 	add	r3, r4, r3, lsl #8
 3f0ebfc:	e5873000 	str	r3, [r7]

		break;
 3f0ec00:	ea000001 	b	3f0ec0c <srec_decode+0x220>
	default:
		return (SREC_E_BADTYPE);
 3f0ec04:	e3e00000 	mvn	r0, #0	; 0x0
 3f0ec08:	ea00001c 	b	3f0ec80 <srec_decode+0x294>
	}

	/* convert data and calculate checksum */
	for (i=0; i < *count; ++i) {
 3f0ec0c:	e5963000 	ldr	r3, [r6]
 3f0ec10:	e3a07000 	mov	r7, #0	; 0x0
 3f0ec14:	e1570003 	cmp	r7, r3
 3f0ec18:	aa00000c 	bge	3f0ec50 <srec_decode+0x264>
		if ((v = hex2_bin(input)) < 0) {
 3f0ec1c:	e1a00005 	mov	r0, r5
 3f0ec20:	eb00002a 	bl	3f0ecd0 <hex2_bin>
 3f0ec24:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0ec28:	ba000013 	blt	3f0ec7c <srec_decode+0x290>
			return (SREC_E_NOSREC);
		}
		data[i] = v;
		chksum += v;
 3f0ec2c:	e08a3004 	add	r3, r10, r4
 3f0ec30:	e203a0ff 	and	r10, r3, #255	; 0xff
 3f0ec34:	e51b3028 	ldr	r3, [r11, -#40]
 3f0ec38:	e7c34007 	strb	r4, [r3, r7]
		input  += 2;
 3f0ec3c:	e2855002 	add	r5, r5, #2	; 0x2
 3f0ec40:	e5963000 	ldr	r3, [r6]
 3f0ec44:	e2877001 	add	r7, r7, #1	; 0x1
 3f0ec48:	e1570003 	cmp	r7, r3
 3f0ec4c:	bafffff2 	blt	3f0ec1c <srec_decode+0x230>
	}

	/* read anc check checksum */
	if ((v = hex2_bin(input)) < 0) {
 3f0ec50:	e1a00005 	mov	r0, r5
 3f0ec54:	eb00001d 	bl	3f0ecd0 <hex2_bin>
 3f0ec58:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0ec5c:	ba000006 	blt	3f0ec7c <srec_decode+0x290>
		return (SREC_E_NOSREC);
	}

	if ((unsigned char)v != (unsigned char)~chksum) {
 3f0ec60:	e1e0300a 	mvn	r3, r10
 3f0ec64:	e20420ff 	and	r2, r4, #255	; 0xff
 3f0ec68:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0ec6c:	e1520003 	cmp	r2, r3
 3f0ec70:	01a00009 	moveq	r0, r9
 3f0ec74:	13e00002 	mvnne	r0, #2	; 0x2
		return (SREC_E_BADCHKS);
	}

	return (srec_type);
 3f0ec78:	ea000000 	b	3f0ec80 <srec_decode+0x294>
 3f0ec7c:	e3e00001 	mvn	r0, #1	; 0x1
}
 3f0ec80:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0ec84 <hex1_bin>:
 3f0ec84:	e1a0c00d 	mov	r12, r13
 3f0ec88:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0ec8c:	e24cb004 	sub	r11, r12, #4	; 0x4

static int hex1_bin (char c)
{
 3f0ec90:	e20000ff 	and	r0, r0, #255	; 0xff
	if (c >= '0' && c <= '9')
 3f0ec94:	e2402030 	sub	r2, r0, #48	; 0x30
 3f0ec98:	e20230ff 	and	r3, r2, #255	; 0xff
 3f0ec9c:	e3530009 	cmp	r3, #9	; 0x9
		return (c - '0');
 3f0eca0:	91a00002 	movls	r0, r2
 3f0eca4:	991ba800 	ldmlsdb	r11, {r11, r13, r15}
	if (c >= 'a' && c <= 'f')
 3f0eca8:	e2403061 	sub	r3, r0, #97	; 0x61
 3f0ecac:	e3530005 	cmp	r3, #5	; 0x5
		return (c + 10 - 'a');
 3f0ecb0:	92400057 	subls	r0, r0, #87	; 0x57
 3f0ecb4:	991ba800 	ldmlsdb	r11, {r11, r13, r15}
	if (c >= 'A' && c <= 'F')
 3f0ecb8:	e2403041 	sub	r3, r0, #65	; 0x41
 3f0ecbc:	e3530005 	cmp	r3, #5	; 0x5
		return (c + 10 - 'A');
	return (-1);
 3f0ecc0:	83e00000 	mvnhi	r0, #0	; 0x0
 3f0ecc4:	891ba800 	ldmhidb	r11, {r11, r13, r15}
 3f0ecc8:	e2400037 	sub	r0, r0, #55	; 0x37
 3f0eccc:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0ecd0 <hex2_bin>:
 3f0ecd0:	e1a0c00d 	mov	r12, r13
 3f0ecd4:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
}

static int hex2_bin (char *s)
{
 3f0ecd8:	e1a04000 	mov	r4, r0
	int i, j;

	if ((i = hex1_bin(*s++)) < 0) {
 3f0ecdc:	e4d40001 	ldrb	r0, [r4], #1
 3f0ece0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0ece4:	ebffffe6 	bl	3f0ec84 <hex1_bin>
 3f0ece8:	e2505000 	subs	r5, r0, #0	; 0x0
		return (-1);
 3f0ecec:	e3e00000 	mvn	r0, #0	; 0x0
 3f0ecf0:	b91ba830 	ldmltdb	r11, {r4, r5, r11, r13, r15}
	}
	if ((j = hex1_bin(*s)) < 0) {
 3f0ecf4:	e5d40000 	ldrb	r0, [r4]
 3f0ecf8:	ebffffe1 	bl	3f0ec84 <hex1_bin>
 3f0ecfc:	e3500000 	cmp	r0, #0	; 0x0
		return (-1);
	}

	return ((i<<4) + j);
 3f0ed00:	a0800205 	addge	r0, r0, r5, lsl #4
 3f0ed04:	a91ba830 	ldmgedb	r11, {r4, r5, r11, r13, r15}
 3f0ed08:	e3e00000 	mvn	r0, #0	; 0x0
}
 3f0ed0c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f0ed10 <do_brp>:
 3f0ed10:	e1a0c00d 	mov	r12, r13
 3f0ed14:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f0ed18:	e24cb004 	sub	r11, r12, #4	; 0x4
#include <asm/processor.h>
#include <asm/io.h>

int do_brp(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
 3f0ed1c:	e1a06002 	mov	r6, r2
        int rc = 1;
        char buffer[100];

        if (argc  > 2)
 3f0ed20:	e3560002 	cmp	r6, #2	; 0x2
 3f0ed24:	e1a02000 	mov	r2, r0
 3f0ed28:	e1a05001 	mov	r5, r1
 3f0ed2c:	e1a07003 	mov	r7, r3
 3f0ed30:	e24dd064 	sub	r13, r13, #100	; 0x64
 3f0ed34:	da000005 	ble	3f0ed50 <do_brp+0x40>
        {
                printf ("Usage:\n%s\n", cmdtp->usage);
 3f0ed38:	e59f000c 	ldr	r0, [pc, #c]	; 3f0ed4c <do_brp+0x3c>
 3f0ed3c:	e5921010 	ldr	r1, [r2, #16]
 3f0ed40:	ebfff6bf 	bl	3f0c844 <printf>
                return 1;
 3f0ed44:	e3a00001 	mov	r0, #1	; 0x1
 3f0ed48:	ea00003d 	b	3f0ee44 <do_brp+0x134>
 3f0ed4c:	03f1f074 	mvneqs	r15, #116	; 0x74
        }
        #if 1
        if (argc < 2)
 3f0ed50:	e3560001 	cmp	r6, #1	; 0x1
 3f0ed54:	ca00001a 	bgt	3f0edc4 <do_brp+0xb4>
        {
            printf("tftp 03000000 uImage\n");
 3f0ed58:	e59f00e8 	ldr	r0, [pc, #e8]	; 3f0ee48 <do_brp+0x138>
 3f0ed5c:	ebfff6b8 	bl	3f0c844 <printf>
            sprintf (buffer,"tftp 03000000 uImage ");
 3f0ed60:	e24b4080 	sub	r4, r11, #128	; 0x80
 3f0ed64:	e59f10e0 	ldr	r1, [pc, #e0]	; 3f0ee4c <do_brp+0x13c>
 3f0ed68:	e1a00004 	mov	r0, r4
 3f0ed6c:	eb0004b2 	bl	3f1003c <sprintf>
            rc = run_command(buffer, flag);
 3f0ed70:	e1a00004 	mov	r0, r4
 3f0ed74:	e1a01005 	mov	r1, r5
 3f0ed78:	ebffd423 	bl	3f03e0c <run_command>

            if ( rc >= 0 )
 3f0ed7c:	e3500000 	cmp	r0, #0	; 0x0
 3f0ed80:	ba00000f 	blt	3f0edc4 <do_brp+0xb4>
            {
                printf("correct u-boot image!!!\n");
 3f0ed84:	e59f00c4 	ldr	r0, [pc, #c4]	; 3f0ee50 <do_brp+0x140>
 3f0ed88:	ebfff6ad 	bl	3f0c844 <printf>
                run_command("nand erase 00040000 20000", flag);                
 3f0ed8c:	e59f00c0 	ldr	r0, [pc, #c0]	; 3f0ee54 <do_brp+0x144>
 3f0ed90:	e1a01005 	mov	r1, r5
 3f0ed94:	ebffd41c 	bl	3f03e0c <run_command>
                sprintf (buffer,"nand write 03000000 00040000 %s ",getenv("filesize"));
 3f0ed98:	e59f00b8 	ldr	r0, [pc, #b8]	; 3f0ee58 <do_brp+0x148>
 3f0ed9c:	ebfff4ae 	bl	3f0c05c <getenv>
 3f0eda0:	e1a02000 	mov	r2, r0
 3f0eda4:	e59f10b0 	ldr	r1, [pc, #b0]	; 3f0ee5c <do_brp+0x14c>
 3f0eda8:	e1a00004 	mov	r0, r4
 3f0edac:	eb0004a2 	bl	3f1003c <sprintf>
                run_command(buffer, flag);
 3f0edb0:	e1a00004 	mov	r0, r4
 3f0edb4:	e1a01005 	mov	r1, r5
 3f0edb8:	ebffd413 	bl	3f03e0c <run_command>
                printf("\nNow! - Power switch turn off & on~~~\n");
 3f0edbc:	e59f009c 	ldr	r0, [pc, #9c]	; 3f0ee60 <do_brp+0x150>
 3f0edc0:	ebfff69f 	bl	3f0c844 <printf>
            }
        }

        if (argc == 2)
 3f0edc4:	e3560002 	cmp	r6, #2	; 0x2
 3f0edc8:	1a00001c 	bne	3f0ee40 <do_brp+0x130>
        {
            printf("tftp 03000000 %s\n",argv[1]);	
 3f0edcc:	e59f0090 	ldr	r0, [pc, #90]	; 3f0ee64 <do_brp+0x154>
 3f0edd0:	e5971004 	ldr	r1, [r7, #4]
 3f0edd4:	ebfff69a 	bl	3f0c844 <printf>
            sprintf (buffer,"tftp 03000000 %s ",argv[1]);
 3f0edd8:	e59f1088 	ldr	r1, [pc, #88]	; 3f0ee68 <do_brp+0x158>
 3f0eddc:	e24b4080 	sub	r4, r11, #128	; 0x80
 3f0ede0:	e5972004 	ldr	r2, [r7, #4]
 3f0ede4:	e1a00004 	mov	r0, r4
 3f0ede8:	eb000493 	bl	3f1003c <sprintf>
            rc = run_command(buffer, flag);
 3f0edec:	e1a00004 	mov	r0, r4
 3f0edf0:	e1a01005 	mov	r1, r5
 3f0edf4:	ebffd404 	bl	3f03e0c <run_command>

            if ( rc >= 0 )
 3f0edf8:	e3500000 	cmp	r0, #0	; 0x0
 3f0edfc:	ba00000f 	blt	3f0ee40 <do_brp+0x130>
            {
                printf("correct u-boot image!!!\n");
 3f0ee00:	e59f0048 	ldr	r0, [pc, #48]	; 3f0ee50 <do_brp+0x140>
 3f0ee04:	ebfff68e 	bl	3f0c844 <printf>
                run_command("nand erase 00040000 20000", flag);                
 3f0ee08:	e59f0044 	ldr	r0, [pc, #44]	; 3f0ee54 <do_brp+0x144>
 3f0ee0c:	e1a01005 	mov	r1, r5
 3f0ee10:	ebffd3fd 	bl	3f03e0c <run_command>
                sprintf (buffer,"nand write 03000000 00040000 %s ",getenv("filesize"));
 3f0ee14:	e59f003c 	ldr	r0, [pc, #3c]	; 3f0ee58 <do_brp+0x148>
 3f0ee18:	ebfff48f 	bl	3f0c05c <getenv>
 3f0ee1c:	e1a02000 	mov	r2, r0
 3f0ee20:	e59f1034 	ldr	r1, [pc, #34]	; 3f0ee5c <do_brp+0x14c>
 3f0ee24:	e1a00004 	mov	r0, r4
 3f0ee28:	eb000483 	bl	3f1003c <sprintf>
                run_command(buffer, flag);
 3f0ee2c:	e1a00004 	mov	r0, r4
 3f0ee30:	e1a01005 	mov	r1, r5
 3f0ee34:	ebffd3f4 	bl	3f03e0c <run_command>
                printf("\nNow! - Power switch turn off & on~~~\n");
 3f0ee38:	e59f0020 	ldr	r0, [pc, #20]	; 3f0ee60 <do_brp+0x150>
 3f0ee3c:	ebfff680 	bl	3f0c844 <printf>
            }
        }
        #else /* write test address for the debug purpose, from 30000 with size 20000 */
        if (argc < 2)
        {
            printf("tftp 03000000 uImage\n");
            sprintf (buffer,"tftp 03000000 uImage ");
            rc = run_command(buffer, flag);

            if ( rc >= 0 )
            {
                printf("correct u-boot image!!!\n");
                run_command("nand erase 00030000 20000", flag);                
                sprintf (buffer,"nand write 03000000 00030000 %s ",getenv("filesize"));
                run_command(buffer, flag);
                printf("\nNow! - Power switch turn off & on~~~\n");
            }
        }

        if (argc == 2)
        {
            printf("tftp 03000000 %s\n",argv[1]);	
            sprintf (buffer,"tftp 03000000 %s ",argv[1]);
            rc = run_command(buffer, flag);

            if ( rc >= 0 )
            {
                printf("correct u-boot image!!!\n");
                run_command("nand erase 00030000 20000", flag);                
                sprintf (buffer,"nand write 03000000 00030000 %s ",getenv("filesize"));
                run_command(buffer, flag);
                printf("\nNow! - Power switch turn off & on~~~\n");
            }
        }
        #endif

        return 0;
 3f0ee40:	e3a00000 	mov	r0, #0	; 0x0
 3f0ee44:	ea000008 	b	3f0ee6c <do_brp+0x15c>
 3f0ee48:	03f1f080 	mvneqs	r15, #128	; 0x80
 3f0ee4c:	03f1f098 	mvneqs	r15, #152	; 0x98
 3f0ee50:	03f1f0b0 	mvneqs	r15, #176	; 0xb0
 3f0ee54:	03f1f0cc 	mvneqs	r15, #204	; 0xcc
 3f0ee58:	03f1f10c 	mvneqs	r15, #3	; 0x3
 3f0ee5c:	03f1f0e8 	mvneqs	r15, #232	; 0xe8
 3f0ee60:	03f1f118 	mvneqs	r15, #6	; 0x6
 3f0ee64:	03f1f140 	mvneqs	r15, #16	; 0x10
 3f0ee68:	03f1f154 	mvneqs	r15, #21	; 0x15
}
 3f0ee6c:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}

03f0ee70 <crc32>:
 3f0ee70:	e1a0c00d 	mov	r12, r13
 3f0ee74:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0ee78:	e24cb004 	sub	r11, r12, #4	; 0x4
uLong ZEXPORT crc32(crc, buf, len)
    uLong crc;
    const Bytef *buf;
    uInt len;
{
 3f0ee7c:	e1a0c001 	mov	r12, r1
 3f0ee80:	e1a0e002 	mov	r14, r2
#ifdef DYNAMIC_CRC_TABLE
    if (crc_table_empty)
      make_crc_table();
#endif
    crc = crc ^ 0xffffffffL;
 3f0ee84:	e1e00000 	mvn	r0, r0
    while (len >= 8)
 3f0ee88:	e35e0007 	cmp	r14, #7	; 0x7
 3f0ee8c:	9a00002b 	bls	3f0ef40 <crc32+0xd0>
    {
      DO8(buf);
 3f0ee90:	e4dc3001 	ldrb	r3, [r12], #1
 3f0ee94:	e59f10d4 	ldr	r1, [pc, #d4]	; 3f0ef70 <crc32+0x100>
 3f0ee98:	e0203003 	eor	r3, r0, r3
 3f0ee9c:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0eea0:	e7912103 	ldr	r2, [r1, r3, lsl #2]
 3f0eea4:	e4dc3001 	ldrb	r3, [r12], #1
 3f0eea8:	e0220420 	eor	r0, r2, r0, lsr #8
 3f0eeac:	e0203003 	eor	r3, r0, r3
 3f0eeb0:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0eeb4:	e7912103 	ldr	r2, [r1, r3, lsl #2]
 3f0eeb8:	e4dc3001 	ldrb	r3, [r12], #1
 3f0eebc:	e0220420 	eor	r0, r2, r0, lsr #8
 3f0eec0:	e0203003 	eor	r3, r0, r3
 3f0eec4:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0eec8:	e7912103 	ldr	r2, [r1, r3, lsl #2]
 3f0eecc:	e4dc3001 	ldrb	r3, [r12], #1
 3f0eed0:	e0220420 	eor	r0, r2, r0, lsr #8
 3f0eed4:	e0203003 	eor	r3, r0, r3
 3f0eed8:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0eedc:	e7912103 	ldr	r2, [r1, r3, lsl #2]
 3f0eee0:	e4dc3001 	ldrb	r3, [r12], #1
 3f0eee4:	e0220420 	eor	r0, r2, r0, lsr #8
 3f0eee8:	e0203003 	eor	r3, r0, r3
 3f0eeec:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0eef0:	e7912103 	ldr	r2, [r1, r3, lsl #2]
 3f0eef4:	e4dc3001 	ldrb	r3, [r12], #1
 3f0eef8:	e0220420 	eor	r0, r2, r0, lsr #8
 3f0eefc:	e0203003 	eor	r3, r0, r3
 3f0ef00:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0ef04:	e7912103 	ldr	r2, [r1, r3, lsl #2]
 3f0ef08:	e4dc3001 	ldrb	r3, [r12], #1
 3f0ef0c:	e0220420 	eor	r0, r2, r0, lsr #8
 3f0ef10:	e0203003 	eor	r3, r0, r3
 3f0ef14:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0ef18:	e7912103 	ldr	r2, [r1, r3, lsl #2]
      len -= 8;
 3f0ef1c:	e24ee008 	sub	r14, r14, #8	; 0x8
 3f0ef20:	e4dc3001 	ldrb	r3, [r12], #1
 3f0ef24:	e0220420 	eor	r0, r2, r0, lsr #8
 3f0ef28:	e0203003 	eor	r3, r0, r3
 3f0ef2c:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0ef30:	e7913103 	ldr	r3, [r1, r3, lsl #2]
    }
 3f0ef34:	e35e0007 	cmp	r14, #7	; 0x7
 3f0ef38:	e0230420 	eor	r0, r3, r0, lsr #8
 3f0ef3c:	8affffd3 	bhi	3f0ee90 <crc32+0x20>
    if (len) do {
 3f0ef40:	e35e0000 	cmp	r14, #0	; 0x0
 3f0ef44:	0a000007 	beq	3f0ef68 <crc32+0xf8>
      DO1(buf);
 3f0ef48:	e4dc3001 	ldrb	r3, [r12], #1
 3f0ef4c:	e59f201c 	ldr	r2, [pc, #1c]	; 3f0ef70 <crc32+0x100>
 3f0ef50:	e0203003 	eor	r3, r0, r3
 3f0ef54:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0ef58:	e7923103 	ldr	r3, [r2, r3, lsl #2]
    } while (--len);
 3f0ef5c:	e25ee001 	subs	r14, r14, #1	; 0x1
 3f0ef60:	e0230420 	eor	r0, r3, r0, lsr #8
 3f0ef64:	1afffff7 	bne	3f0ef48 <crc32+0xd8>
    return crc ^ 0xffffffffL;
 3f0ef68:	e1e00000 	mvn	r0, r0
 3f0ef6c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0ef70:	03f1f1e8 	mvneqs	r15, #58	; 0x3a

03f0ef74 <display_options>:
 3f0ef74:	e1a0c00d 	mov	r12, r13
 3f0ef78:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

#if defined(BUILD_TAG)
	printf ("\n\n%s, Build: %s\n\n", version_string, BUILD_TAG);
#else
	printf ("\n\n%s\n\n", version_string);
 3f0ef7c:	e59f0010 	ldr	r0, [pc, #10]	; 3f0ef94 <display_options+0x20>
 3f0ef80:	e59f1010 	ldr	r1, [pc, #10]	; 3f0ef98 <display_options+0x24>
 3f0ef84:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0ef88:	ebfff62d 	bl	3f0c844 <printf>
#endif
	return 0;
 3f0ef8c:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0ef90:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0ef94:	03f1f5e8 	mvneqs	r15, #973078528	; 0x3a000000
 3f0ef98:	03f1aa0c 	mvneqs	r10, #49152	; 0xc000

03f0ef9c <print_size>:
 3f0ef9c:	e1a0c00d 	mov	r12, r13
 3f0efa0:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f0efa4:	e24cb004 	sub	r11, r12, #4	; 0x4

/*
 * print sizes as "xxx kB", "xxx.y kB", "xxx MB" or "xxx.y MB" as needed;
 * allow for optional trailing string (like "\n")
 */
void print_size (ulong size, const char *s)
{
	ulong m, n;
	ulong d = 1 << 20;		/* 1 MB */
 3f0efa8:	e3a06601 	mov	r6, #1048576	; 0x100000
	char  c = 'M';
 3f0efac:	e3a0a04d 	mov	r10, #77	; 0x4d
 3f0efb0:	e1a04000 	mov	r4, r0

	if (size < d) {			/* print in kB */
 3f0efb4:	e1540006 	cmp	r4, r6
 3f0efb8:	e1a07001 	mov	r7, r1
		c = 'k';
 3f0efbc:	328aa01e 	addcc	r10, r10, #30	; 0x1e
		d = 1 << 10;
 3f0efc0:	33a06b01 	movcc	r6, #1024	; 0x400
	}

	n = size / d;
 3f0efc4:	e1a00004 	mov	r0, r4
 3f0efc8:	e1a01006 	mov	r1, r6
 3f0efcc:	eb001103 	bl	3f133e0 <__udivsi3>
 3f0efd0:	e1a05000 	mov	r5, r0

	m = (10 * (size - (n * d)) + (d / 2) ) / d;
 3f0efd4:	e0000596 	mul	r0, r6, r5
 3f0efd8:	e1a01006 	mov	r1, r6
 3f0efdc:	e1a030a6 	mov	r3, r6, lsr #1
 3f0efe0:	e0600004 	rsb	r0, r0, r4
 3f0efe4:	e0800100 	add	r0, r0, r0, lsl #2
 3f0efe8:	e0830080 	add	r0, r3, r0, lsl #1
 3f0efec:	eb0010fb 	bl	3f133e0 <__udivsi3>
 3f0eff0:	e1a04000 	mov	r4, r0

	if (m >= 10) {
 3f0eff4:	e3540009 	cmp	r4, #9	; 0x9
		m -= 10;
 3f0eff8:	8244400a 	subhi	r4, r4, #10	; 0xa
		n += 1;
 3f0effc:	82855001 	addhi	r5, r5, #1	; 0x1
	}

	printf ("%2ld", n);
 3f0f000:	e59f002c 	ldr	r0, [pc, #2c]	; 3f0f034 <print_size+0x98>
 3f0f004:	e1a01005 	mov	r1, r5
 3f0f008:	ebfff60d 	bl	3f0c844 <printf>
	if (m) {
 3f0f00c:	e3540000 	cmp	r4, #0	; 0x0
 3f0f010:	0a000002 	beq	3f0f020 <print_size+0x84>
		printf (".%ld", m);
 3f0f014:	e59f001c 	ldr	r0, [pc, #1c]	; 3f0f038 <print_size+0x9c>
 3f0f018:	e1a01004 	mov	r1, r4
 3f0f01c:	ebfff608 	bl	3f0c844 <printf>
	}
	printf (" %cB%s", c, s);
 3f0f020:	e1a0100a 	mov	r1, r10
 3f0f024:	e59f0010 	ldr	r0, [pc, #10]	; 3f0f03c <print_size+0xa0>
 3f0f028:	e1a02007 	mov	r2, r7
 3f0f02c:	ebfff604 	bl	3f0c844 <printf>
}
 3f0f030:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f0f034:	03f1f5f0 	mvneqs	r15, #1006632960	; 0x3c000000
 3f0f038:	03f1f5f8 	mvneqs	r15, #1040187392	; 0x3e000000
 3f0f03c:	03f1f600 	mvneqs	r15, #0	; 0x0

03f0f040 <strnicmp>:
 3f0f040:	e1a0c00d 	mov	r12, r13
 3f0f044:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f0f048:	e24cb004 	sub	r11, r12, #4	; 0x4
 * @s2: The other string
 * @len: the maximum number of characters to compare
 */
int strnicmp(const char *s1, const char *s2, size_t len)
{
 3f0f04c:	e1a04000 	mov	r4, r0
	/* Yes, Virginia, it had better be unsigned */
	unsigned char c1, c2;

	c1 = 0;	c2 = 0;
 3f0f050:	e3a00000 	mov	r0, #0	; 0x0
 3f0f054:	e1a0c000 	mov	r12, r0
	if (len) {
 3f0f058:	e252e000 	subs	r14, r2, #0	; 0x0
 3f0f05c:	0a000016 	beq	3f0f0bc <strnicmp+0x7c>
		do {
			c1 = *s1; c2 = *s2;
 3f0f060:	e4d40001 	ldrb	r0, [r4], #1
 3f0f064:	e4d1c001 	ldrb	r12, [r1], #1
			s1++; s2++;
			if (!c1)
 3f0f068:	e3500000 	cmp	r0, #0	; 0x0
 3f0f06c:	0a000012 	beq	3f0f0bc <strnicmp+0x7c>
				break;
			if (!c2)
 3f0f070:	e35c0000 	cmp	r12, #0	; 0x0
 3f0f074:	0a000010 	beq	3f0f0bc <strnicmp+0x7c>
				break;
			if (c1 == c2)
 3f0f078:	e150000c 	cmp	r0, r12
 3f0f07c:	0a00000c 	beq	3f0f0b4 <strnicmp+0x74>
#define toascii(c) (((unsigned char)(c))&0x7f)

static inline unsigned char __tolower(unsigned char c)
{
	if (isupper(c))
 3f0f080:	e59f203c 	ldr	r2, [pc, #3c]	; 3f0f0c4 <strnicmp+0x84>
 3f0f084:	e7d23000 	ldrb	r3, [r2, r0]
 3f0f088:	e7d2200c 	ldrb	r2, [r2, r12]
 3f0f08c:	e3130001 	tst	r3, #1	; 0x1
		c -= 'A'-'a';
 3f0f090:	e2803020 	add	r3, r0, #32	; 0x20
 3f0f094:	e20330ff 	and	r3, r3, #255	; 0xff
				continue;
			c1 = tolower(c1);
 3f0f098:	11a00003 	movne	r0, r3
#define toascii(c) (((unsigned char)(c))&0x7f)

static inline unsigned char __tolower(unsigned char c)
{
	if (isupper(c))
 3f0f09c:	e3120001 	tst	r2, #1	; 0x1
		c -= 'A'-'a';
 3f0f0a0:	e28c3020 	add	r3, r12, #32	; 0x20
 3f0f0a4:	e20330ff 	and	r3, r3, #255	; 0xff
			c2 = tolower(c2);
 3f0f0a8:	11a0c003 	movne	r12, r3
			if (c1 != c2)
 3f0f0ac:	e150000c 	cmp	r0, r12
 3f0f0b0:	1a000001 	bne	3f0f0bc <strnicmp+0x7c>
				break;
		} while (--len);
 3f0f0b4:	e25ee001 	subs	r14, r14, #1	; 0x1
 3f0f0b8:	1affffe8 	bne	3f0f060 <strnicmp+0x20>
	}
	return (int)c1 - (int)c2;
 3f0f0bc:	e06c0000 	rsb	r0, r12, r0
}
 3f0f0c0:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f0f0c4:	03f21078 	mvneqs	r1, #120	; 0x78

03f0f0c8 <strcpy>:
 3f0f0c8:	e1a0c00d 	mov	r12, r13
 3f0f0cc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f0d0:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

char * ___strtok;

#ifndef __HAVE_ARCH_STRCPY
/**
 * strcpy - Copy a %NUL terminated string
 * @dest: Where to copy the string to
 * @src: Where to copy the string from
 */
char * strcpy(char * dest,const char *src)
{
	char *tmp = dest;
 3f0f0d4:	e1a02000 	mov	r2, r0

	while ((*dest++ = *src++) != '\0')
 3f0f0d8:	e4d13001 	ldrb	r3, [r1], #1
 3f0f0dc:	e31300ff 	tst	r3, #255	; 0xff
 3f0f0e0:	e4c03001 	strb	r3, [r0], #1
 3f0f0e4:	1afffffb 	bne	3f0f0d8 <strcpy+0x10>
		/* nothing */;
	return tmp;
 3f0f0e8:	e1a00002 	mov	r0, r2
}
 3f0f0ec:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f0f0 <strncpy>:
 3f0f0f0:	e1a0c00d 	mov	r12, r13
 3f0f0f4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f0f8:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRNCPY
/**
 * strncpy - Copy a length-limited, %NUL-terminated string
 * @dest: Where to copy the string to
 * @src: Where to copy the string from
 * @count: The maximum number of bytes to copy
 *
 * Note that unlike userspace strncpy, this does not %NUL-pad the buffer.
 * However, the result is not %NUL-terminated if the source exceeds
 * @count bytes.
 */
char * strncpy(char * dest,const char *src,size_t count)
{
	char *tmp = dest;
 3f0f0fc:	e1a0c000 	mov	r12, r0

	while (count-- && (*dest++ = *src++) != '\0')
 3f0f100:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f104:	e3720001 	cmn	r2, #1	; 0x1
 3f0f108:	0a000003 	beq	3f0f11c <strncpy+0x2c>
 3f0f10c:	e4d13001 	ldrb	r3, [r1], #1
 3f0f110:	e31300ff 	tst	r3, #255	; 0xff
 3f0f114:	e4c03001 	strb	r3, [r0], #1
 3f0f118:	1afffff8 	bne	3f0f100 <strncpy+0x10>
		/* nothing */;

	return tmp;
 3f0f11c:	e1a0000c 	mov	r0, r12
}
 3f0f120:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f124 <strcat>:
 3f0f124:	e1a0c00d 	mov	r12, r13
 3f0f128:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
#endif

#ifndef __HAVE_ARCH_STRCAT
/**
 * strcat - Append one %NUL-terminated string to another
 * @dest: The string to be appended to
 * @src: The string to append to it
 */
char * strcat(char * dest, const char * src)
{
	char *tmp = dest;
 3f0f12c:	e1a02000 	mov	r2, r0

	while (*dest)
 3f0f130:	e5d23000 	ldrb	r3, [r2]
 3f0f134:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0f138:	e3530000 	cmp	r3, #0	; 0x0
 3f0f13c:	0a000002 	beq	3f0f14c <strcat+0x28>
		dest++;
 3f0f140:	e5f03001 	ldrb	r3, [r0, #1]!
 3f0f144:	e3530000 	cmp	r3, #0	; 0x0
 3f0f148:	1afffffc 	bne	3f0f140 <strcat+0x1c>
	while ((*dest++ = *src++) != '\0')
 3f0f14c:	e4d13001 	ldrb	r3, [r1], #1
 3f0f150:	e31300ff 	tst	r3, #255	; 0xff
 3f0f154:	e4c03001 	strb	r3, [r0], #1
 3f0f158:	1afffffb 	bne	3f0f14c <strcat+0x28>
		;

	return tmp;
 3f0f15c:	e1a00002 	mov	r0, r2
}
 3f0f160:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f164 <strncat>:
 3f0f164:	e1a0c00d 	mov	r12, r13
 3f0f168:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f16c:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRNCAT
/**
 * strncat - Append a length-limited, %NUL-terminated string to another
 * @dest: The string to be appended to
 * @src: The string to append to it
 * @count: The maximum numbers of bytes to copy
 *
 * Note that in contrast to strncpy, strncat ensures the result is
 * terminated.
 */
char * strncat(char *dest, const char *src, size_t count)
{
	char *tmp = dest;

	if (count) {
 3f0f170:	e3520000 	cmp	r2, #0	; 0x0
 3f0f174:	e1a0c000 	mov	r12, r0
 3f0f178:	0a00000c 	beq	3f0f1b0 <strncat+0x4c>
		while (*dest)
 3f0f17c:	e5dc3000 	ldrb	r3, [r12]
 3f0f180:	e3530000 	cmp	r3, #0	; 0x0
 3f0f184:	0a000002 	beq	3f0f194 <strncat+0x30>
			dest++;
 3f0f188:	e5f03001 	ldrb	r3, [r0, #1]!
 3f0f18c:	e3530000 	cmp	r3, #0	; 0x0
 3f0f190:	1afffffc 	bne	3f0f188 <strncat+0x24>
		while ((*dest++ = *src++)) {
			if (--count == 0) {
				*dest = '\0';
				break;
			}
		}
 3f0f194:	e4d13001 	ldrb	r3, [r1], #1
 3f0f198:	e31300ff 	tst	r3, #255	; 0xff
 3f0f19c:	e4c03001 	strb	r3, [r0], #1
 3f0f1a0:	0a000002 	beq	3f0f1b0 <strncat+0x4c>
 3f0f1a4:	e2522001 	subs	r2, r2, #1	; 0x1
 3f0f1a8:	1afffff9 	bne	3f0f194 <strncat+0x30>
 3f0f1ac:	e5c02000 	strb	r2, [r0]
	}

	return tmp;
 3f0f1b0:	e1a0000c 	mov	r0, r12
}
 3f0f1b4:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f1b8 <strcmp>:
 3f0f1b8:	e1a0c00d 	mov	r12, r13
 3f0f1bc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f1c0:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRCMP
/**
 * strcmp - Compare two strings
 * @cs: One string
 * @ct: Another string
 */
int strcmp(const char * cs,const char * ct)
{
	register signed char __res;

	while (1) {
		if ((__res = *cs - *ct++) != 0 || !*cs++)
 3f0f1c4:	e5d02000 	ldrb	r2, [r0]
 3f0f1c8:	e4d13001 	ldrb	r3, [r1], #1
 3f0f1cc:	e0633002 	rsb	r3, r3, r2
 3f0f1d0:	e1b0cc03 	movs	r12, r3, lsl #24
 3f0f1d4:	e20330ff 	and	r3, r3, #255	; 0xff
 3f0f1d8:	1a000002 	bne	3f0f1e8 <strcmp+0x30>
 3f0f1dc:	e2800001 	add	r0, r0, #1	; 0x1
 3f0f1e0:	e3520000 	cmp	r2, #0	; 0x0
 3f0f1e4:	1afffff6 	bne	3f0f1c4 <strcmp+0xc>
			break;
	}

	return __res;
 3f0f1e8:	e1a00c03 	mov	r0, r3, lsl #24
 3f0f1ec:	e1a00c40 	mov	r0, r0, asr #24
}
 3f0f1f0:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f1f4 <strncmp>:
 3f0f1f4:	e1a0c00d 	mov	r12, r13
 3f0f1f8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f1fc:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRNCMP
/**
 * strncmp - Compare two length-limited strings
 * @cs: One string
 * @ct: Another string
 * @count: The maximum number of bytes to compare
 */
int strncmp(const char * cs,const char * ct,size_t count)
{
	register signed char __res = 0;
 3f0f200:	e3a0e000 	mov	r14, #0	; 0x0

	while (count) {
 3f0f204:	e3520000 	cmp	r2, #0	; 0x0
 3f0f208:	0a00000b 	beq	3f0f23c <strncmp+0x48>
		if ((__res = *cs - *ct++) != 0 || !*cs++)
 3f0f20c:	ea000001 	b	3f0f218 <strncmp+0x24>
			break;
		count--;
	}
 3f0f210:	e2522001 	subs	r2, r2, #1	; 0x1
 3f0f214:	0a000008 	beq	3f0f23c <strncmp+0x48>
 3f0f218:	e5d0c000 	ldrb	r12, [r0]
 3f0f21c:	e4d13001 	ldrb	r3, [r1], #1
 3f0f220:	e063300c 	rsb	r3, r3, r12
 3f0f224:	e203e0ff 	and	r14, r3, #255	; 0xff
 3f0f228:	e1b03c03 	movs	r3, r3, lsl #24
 3f0f22c:	1a000002 	bne	3f0f23c <strncmp+0x48>
 3f0f230:	e2800001 	add	r0, r0, #1	; 0x1
 3f0f234:	e35c0000 	cmp	r12, #0	; 0x0
 3f0f238:	1afffff4 	bne	3f0f210 <strncmp+0x1c>

	return __res;
 3f0f23c:	e1a00c0e 	mov	r0, r14, lsl #24
 3f0f240:	e1a00c40 	mov	r0, r0, asr #24
}
 3f0f244:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f248 <strchr>:
 3f0f248:	e1a0c00d 	mov	r12, r13
 3f0f24c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f250:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRCHR
/**
 * strchr - Find the first occurrence of a character in a string
 * @s: The string to be searched
 * @c: The character to search for
 */
char * strchr(const char * s, int c)
{
 3f0f254:	e1a03000 	mov	r3, r0
	for(; *s != (char) c; ++s)
 3f0f258:	e5d30000 	ldrb	r0, [r3]
 3f0f25c:	e20110ff 	and	r1, r1, #255	; 0xff
 3f0f260:	e1500001 	cmp	r0, r1
 3f0f264:	0a000005 	beq	3f0f280 <strchr+0x38>
		if (*s == '\0')
 3f0f268:	e20000ff 	and	r0, r0, #255	; 0xff
 3f0f26c:	e3500000 	cmp	r0, #0	; 0x0
 3f0f270:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
 3f0f274:	e5f30001 	ldrb	r0, [r3, #1]!
 3f0f278:	e1500001 	cmp	r0, r1
 3f0f27c:	1afffff9 	bne	3f0f268 <strchr+0x20>
			return NULL;
	return (char *) s;
 3f0f280:	e1a00003 	mov	r0, r3
 3f0f284:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f288 <strrchr>:
 3f0f288:	e1a0c00d 	mov	r12, r13
 3f0f28c:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0f290:	e24cb004 	sub	r11, r12, #4	; 0x4
}
#endif

#ifndef __HAVE_ARCH_STRRCHR
/**
 * strrchr - Find the last occurrence of a character in a string
 * @s: The string to be searched
 * @c: The character to search for
 */
char * strrchr(const char * s, int c)
{
 3f0f294:	e1a04000 	mov	r4, r0
 3f0f298:	e1a05001 	mov	r5, r1
       const char *p = s + strlen(s);
 3f0f29c:	eb000009 	bl	3f0f2c8 <strlen>
 3f0f2a0:	e0840000 	add	r0, r4, r0
       do {
	   if (*p == (char)c)
 3f0f2a4:	e5d02000 	ldrb	r2, [r0]
 3f0f2a8:	e20530ff 	and	r3, r5, #255	; 0xff
 3f0f2ac:	e1520003 	cmp	r2, r3
 3f0f2b0:	091ba830 	ldmeqdb	r11, {r4, r5, r11, r13, r15}
 3f0f2b4:	e2400001 	sub	r0, r0, #1	; 0x1
 3f0f2b8:	e1500004 	cmp	r0, r4
 3f0f2bc:	2afffff8 	bcs	3f0f2a4 <strrchr+0x1c>
	       return (char *)p;
       } while (--p >= s);
       return NULL;
 3f0f2c0:	e3a00000 	mov	r0, #0	; 0x0
 3f0f2c4:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f0f2c8 <strlen>:
 3f0f2c8:	e1a0c00d 	mov	r12, r13
 3f0f2cc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f2d0:	e24cb004 	sub	r11, r12, #4	; 0x4
}
#endif

#ifndef __HAVE_ARCH_STRLEN
/**
 * strlen - Find the length of a string
 * @s: The string to be sized
 */
size_t strlen(const char * s)
{
	const char *sc;

	for (sc = s; *sc != '\0'; ++sc)
 3f0f2d4:	e5d03000 	ldrb	r3, [r0]
 3f0f2d8:	e1a02000 	mov	r2, r0
 3f0f2dc:	e3530000 	cmp	r3, #0	; 0x0
 3f0f2e0:	0a000002 	beq	3f0f2f0 <strlen+0x28>
 3f0f2e4:	e5f23001 	ldrb	r3, [r2, #1]!
 3f0f2e8:	e3530000 	cmp	r3, #0	; 0x0
 3f0f2ec:	1afffffc 	bne	3f0f2e4 <strlen+0x1c>
		/* nothing */;
	return sc - s;
 3f0f2f0:	e0600002 	rsb	r0, r0, r2
}
 3f0f2f4:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f2f8 <strnlen>:
 3f0f2f8:	e1a0c00d 	mov	r12, r13
 3f0f2fc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f300:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRNLEN
/**
 * strnlen - Find the length of a length-limited string
 * @s: The string to be sized
 * @count: The maximum number of bytes to search
 */
size_t strnlen(const char * s, size_t count)
{
 3f0f304:	e1a02000 	mov	r2, r0
	const char *sc;

	for (sc = s; count-- && *sc != '\0'; ++sc)
 3f0f308:	e2411001 	sub	r1, r1, #1	; 0x1
 3f0f30c:	e3710001 	cmn	r1, #1	; 0x1
 3f0f310:	0a000009 	beq	3f0f33c <strnlen+0x44>
 3f0f314:	e5d23000 	ldrb	r3, [r2]
 3f0f318:	e3530000 	cmp	r3, #0	; 0x0
 3f0f31c:	0a000006 	beq	3f0f33c <strnlen+0x44>
 3f0f320:	e2800001 	add	r0, r0, #1	; 0x1
 3f0f324:	e2411001 	sub	r1, r1, #1	; 0x1
 3f0f328:	e3710001 	cmn	r1, #1	; 0x1
 3f0f32c:	0a000002 	beq	3f0f33c <strnlen+0x44>
 3f0f330:	e5d03000 	ldrb	r3, [r0]
 3f0f334:	e3530000 	cmp	r3, #0	; 0x0
 3f0f338:	1afffff8 	bne	3f0f320 <strnlen+0x28>
		/* nothing */;
	return sc - s;
 3f0f33c:	e0620000 	rsb	r0, r2, r0
}
 3f0f340:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f344 <strdup>:
 3f0f344:	e1a0c00d 	mov	r12, r13
 3f0f348:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0f34c:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRDUP
char * strdup(const char *s)
{
	char *new;

	if ((s == NULL)	||
 3f0f350:	e2505000 	subs	r5, r0, #0	; 0x0
 3f0f354:	0a000005 	beq	3f0f370 <strdup+0x2c>
 3f0f358:	e1a00005 	mov	r0, r5
 3f0f35c:	ebffffd9 	bl	3f0f2c8 <strlen>
 3f0f360:	e2800001 	add	r0, r0, #1	; 0x1
 3f0f364:	ebfff6e9 	bl	3f0cf10 <malloc>
 3f0f368:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0f36c:	1a000001 	bne	3f0f378 <strdup+0x34>
	    ((new = malloc (strlen(s) + 1)) == NULL) ) {
		return NULL;
 3f0f370:	e3a00000 	mov	r0, #0	; 0x0
 3f0f374:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
	}

	strcpy (new, s);
 3f0f378:	e1a00004 	mov	r0, r4
 3f0f37c:	e1a01005 	mov	r1, r5
 3f0f380:	ebffff50 	bl	3f0f0c8 <strcpy>
	return new;
 3f0f384:	e1a00004 	mov	r0, r4
}
 3f0f388:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f0f38c <strspn>:
 3f0f38c:	e1a0c00d 	mov	r12, r13
 3f0f390:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f394:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRSPN
/**
 * strspn - Calculate the length of the initial substring of @s which only
 * 	contain letters in @accept
 * @s: The string to be searched
 * @accept: The string to search for
 */
size_t strspn(const char *s, const char *accept)
{
	const char *p;
	const char *a;
	size_t count = 0;

	for (p = s; *p != '\0'; ++p) {
 3f0f398:	e5d02000 	ldrb	r2, [r0]
 3f0f39c:	e3a0e000 	mov	r14, #0	; 0x0
 3f0f3a0:	e152000e 	cmp	r2, r14
 3f0f3a4:	0a000014 	beq	3f0f3fc <strspn+0x70>
		for (a = accept; *a != '\0'; ++a) {
 3f0f3a8:	e1a0c001 	mov	r12, r1
 3f0f3ac:	e5dc3000 	ldrb	r3, [r12]
 3f0f3b0:	e3530000 	cmp	r3, #0	; 0x0
 3f0f3b4:	0a000008 	beq	3f0f3dc <strspn+0x50>
			if (*p == *a)
 3f0f3b8:	e1520003 	cmp	r2, r3
 3f0f3bc:	0a000006 	beq	3f0f3dc <strspn+0x50>
 3f0f3c0:	e5fc3001 	ldrb	r3, [r12, #1]!
 3f0f3c4:	e20320ff 	and	r2, r3, #255	; 0xff
 3f0f3c8:	e3520000 	cmp	r2, #0	; 0x0
 3f0f3cc:	0a000002 	beq	3f0f3dc <strspn+0x50>
 3f0f3d0:	e5d03000 	ldrb	r3, [r0]
 3f0f3d4:	e1530002 	cmp	r3, r2
 3f0f3d8:	1afffff8 	bne	3f0f3c0 <strspn+0x34>
				break;
		}
		if (*a == '\0')
 3f0f3dc:	e5dc3000 	ldrb	r3, [r12]
 3f0f3e0:	e3530000 	cmp	r3, #0	; 0x0
			return count;
 3f0f3e4:	01a0000e 	moveq	r0, r14
 3f0f3e8:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
 3f0f3ec:	e5f02001 	ldrb	r2, [r0, #1]!
		++count;
 3f0f3f0:	e28ee001 	add	r14, r14, #1	; 0x1
 3f0f3f4:	e3520000 	cmp	r2, #0	; 0x0
 3f0f3f8:	1affffea 	bne	3f0f3a8 <strspn+0x1c>
	}

	return count;
 3f0f3fc:	e1a0000e 	mov	r0, r14
}
 3f0f400:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f404 <strpbrk>:
 3f0f404:	e1a0c00d 	mov	r12, r13
 3f0f408:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
#endif

#ifndef __HAVE_ARCH_STRPBRK
/**
 * strpbrk - Find the first occurrence of a set of characters
 * @cs: The string to be searched
 * @ct: The characters to search for
 */
char * strpbrk(const char * cs,const char * ct)
{
	const char *sc1,*sc2;

	for( sc1 = cs; *sc1 != '\0'; ++sc1) {
 3f0f40c:	e5d03000 	ldrb	r3, [r0]
 3f0f410:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0f414:	e3530000 	cmp	r3, #0	; 0x0
 3f0f418:	0a00000c 	beq	3f0f450 <strpbrk+0x4c>
		for( sc2 = ct; *sc2 != '\0'; ++sc2) {
 3f0f41c:	e1a0c001 	mov	r12, r1
 3f0f420:	e5dc2000 	ldrb	r2, [r12]
 3f0f424:	e3520000 	cmp	r2, #0	; 0x0
 3f0f428:	0a000005 	beq	3f0f444 <strpbrk+0x40>
			if (*sc1 == *sc2)
 3f0f42c:	e5d03000 	ldrb	r3, [r0]
 3f0f430:	e1530002 	cmp	r3, r2
 3f0f434:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
 3f0f438:	e5fc2001 	ldrb	r2, [r12, #1]!
 3f0f43c:	e3520000 	cmp	r2, #0	; 0x0
 3f0f440:	1afffff9 	bne	3f0f42c <strpbrk+0x28>
 3f0f444:	e5f03001 	ldrb	r3, [r0, #1]!
 3f0f448:	e3530000 	cmp	r3, #0	; 0x0
 3f0f44c:	1afffff2 	bne	3f0f41c <strpbrk+0x18>
				return (char *) sc1;
		}
	}
	return NULL;
 3f0f450:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0f454:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f458 <strtok>:
 3f0f458:	e1a0c00d 	mov	r12, r13
 3f0f45c:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0f460:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRTOK
/**
 * strtok - Split a string into tokens
 * @s: The string to be searched
 * @ct: The characters to search for
 *
 * WARNING: strtok is deprecated, use strsep instead.
 */
char * strtok(char * s,const char * ct)
{
	char *sbegin, *send;

	sbegin  = s ? s : ___strtok;
 3f0f464:	e2504000 	subs	r4, r0, #0	; 0x0
 3f0f468:	e1a05001 	mov	r5, r1
 3f0f46c:	059f3068 	ldreq	r3, [pc, #68]	; 3f0f4dc <strtok+0x84>
 3f0f470:	05934000 	ldreq	r4, [r3]
	if (!sbegin) {
 3f0f474:	e3540000 	cmp	r4, #0	; 0x0
		return NULL;
 3f0f478:	e3a00000 	mov	r0, #0	; 0x0
 3f0f47c:	091ba830 	ldmeqdb	r11, {r4, r5, r11, r13, r15}
	}
	sbegin += strspn(sbegin,ct);
 3f0f480:	e1a00004 	mov	r0, r4
 3f0f484:	e1a01005 	mov	r1, r5
 3f0f488:	ebffffbf 	bl	3f0f38c <strspn>
	if (*sbegin == '\0') {
 3f0f48c:	e7f43000 	ldrb	r3, [r4, r0]!
 3f0f490:	e20320ff 	and	r2, r3, #255	; 0xff
 3f0f494:	e3520000 	cmp	r2, #0	; 0x0
		___strtok = NULL;
 3f0f498:	059f303c 	ldreq	r3, [pc, #3c]	; 3f0f4dc <strtok+0x84>
		return( NULL );
 3f0f49c:	01a00002 	moveq	r0, r2
 3f0f4a0:	05832000 	streq	r2, [r3]
 3f0f4a4:	091ba830 	ldmeqdb	r11, {r4, r5, r11, r13, r15}
	}
	send = strpbrk( sbegin, ct);
 3f0f4a8:	e1a00004 	mov	r0, r4
 3f0f4ac:	e1a01005 	mov	r1, r5
 3f0f4b0:	ebffffd3 	bl	3f0f404 <strpbrk>
	if (send && *send != '\0')
 3f0f4b4:	e2502000 	subs	r2, r0, #0	; 0x0
 3f0f4b8:	0a000003 	beq	3f0f4cc <strtok+0x74>
 3f0f4bc:	e5d23000 	ldrb	r3, [r2]
 3f0f4c0:	e3530000 	cmp	r3, #0	; 0x0
		*send++ = '\0';
 3f0f4c4:	13a03000 	movne	r3, #0	; 0x0
 3f0f4c8:	14c23001 	strneb	r3, [r2], #1
	___strtok = send;
 3f0f4cc:	e59f3008 	ldr	r3, [pc, #8]	; 3f0f4dc <strtok+0x84>
	return (sbegin);
 3f0f4d0:	e1a00004 	mov	r0, r4
 3f0f4d4:	e5832000 	str	r2, [r3]
}
 3f0f4d8:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f0f4dc:	03f6ce60 	mvneqs	r12, #1536	; 0x600

03f0f4e0 <strsep>:
 3f0f4e0:	e1a0c00d 	mov	r12, r13
 3f0f4e4:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0f4e8:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRSEP
/**
 * strsep - Split a string into tokens
 * @s: The string to be searched
 * @ct: The characters to search for
 *
 * strsep() updates @s to point after the token, ready for the next call.
 *
 * It returns empty tokens, too, behaving exactly like the libc function
 * of that name. In fact, it was stolen from glibc2 and de-fancy-fied.
 * Same semantics, slimmer shape. ;)
 */
char * strsep(char **s, const char *ct)
{
 3f0f4ec:	e1a05000 	mov	r5, r0
	char *sbegin = *s, *end;
 3f0f4f0:	e5954000 	ldr	r4, [r5]

	if (sbegin == NULL)
		return NULL;
 3f0f4f4:	e3a00000 	mov	r0, #0	; 0x0
 3f0f4f8:	e1540000 	cmp	r4, r0
 3f0f4fc:	091ba830 	ldmeqdb	r11, {r4, r5, r11, r13, r15}

	end = strpbrk(sbegin, ct);
 3f0f500:	e1a00004 	mov	r0, r4
 3f0f504:	ebffffbe 	bl	3f0f404 <strpbrk>
	if (end)
 3f0f508:	e2502000 	subs	r2, r0, #0	; 0x0
		*end++ = '\0';
 3f0f50c:	13a03000 	movne	r3, #0	; 0x0
 3f0f510:	14c23001 	strneb	r3, [r2], #1
	*s = end;

	return sbegin;
 3f0f514:	e1a00004 	mov	r0, r4
 3f0f518:	e5852000 	str	r2, [r5]
}
 3f0f51c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f0f520 <memset>:
 3f0f520:	e1a0c00d 	mov	r12, r13
 3f0f524:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f528:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_MEMSET
/**
 * memset - Fill a region of memory with the given value
 * @s: Pointer to the start of the area.
 * @c: The byte to fill the area with
 * @count: The size of the area.
 *
 * Do not use memset() to access IO space, use memset_io() instead.
 */
void * memset(void * s,int c,size_t count)
{
	char *xs = (char *) s;
 3f0f52c:	e1a03000 	mov	r3, r0

	while (count--)
 3f0f530:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f534:	e3720001 	cmn	r2, #1	; 0x1
 3f0f538:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
		*xs++ = c;
 3f0f53c:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f540:	e3720001 	cmn	r2, #1	; 0x1
 3f0f544:	e4c31001 	strb	r1, [r3], #1
 3f0f548:	1afffffb 	bne	3f0f53c <memset+0x1c>

	return s;
}
 3f0f54c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f550 <bcopy>:
 3f0f550:	e1a0c00d 	mov	r12, r13
 3f0f554:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f558:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_BCOPY
/**
 * bcopy - Copy one area of memory to another
 * @src: Where to copy from
 * @dest: Where to copy to
 * @count: The size of the area.
 *
 * Note that this is the same as memcpy(), with the arguments reversed.
 * memcpy() is the standard, bcopy() is a legacy BSD function.
 *
 * You should not use this function to access IO space, use memcpy_toio()
 * or memcpy_fromio() instead.
 */
char * bcopy(const char * src, char * dest, int count)
{
 3f0f55c:	e1a0c000 	mov	r12, r0
 3f0f560:	e1a00001 	mov	r0, r1
	char *tmp = dest;

	while (count--)
 3f0f564:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f568:	e3720001 	cmn	r2, #1	; 0x1
 3f0f56c:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
		*tmp++ = *src++;
 3f0f570:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f574:	e4dc3001 	ldrb	r3, [r12], #1
 3f0f578:	e3720001 	cmn	r2, #1	; 0x1
 3f0f57c:	e4c13001 	strb	r3, [r1], #1
 3f0f580:	1afffffa 	bne	3f0f570 <bcopy+0x20>

	return dest;
}
 3f0f584:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f588 <memcpy>:
 3f0f588:	e1a0c00d 	mov	r12, r13
 3f0f58c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f590:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_MEMCPY
/**
 * memcpy - Copy one area of memory to another
 * @dest: Where to copy to
 * @src: Where to copy from
 * @count: The size of the area.
 *
 * You should not use this function to access IO space, use memcpy_toio()
 * or memcpy_fromio() instead.
 */
void * memcpy(void * dest,const void *src,size_t count)
{
	char *tmp = (char *) dest, *s = (char *) src;
 3f0f594:	e1a0c000 	mov	r12, r0

	while (count--)
 3f0f598:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f59c:	e3720001 	cmn	r2, #1	; 0x1
 3f0f5a0:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
		*tmp++ = *s++;
 3f0f5a4:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f5a8:	e4d13001 	ldrb	r3, [r1], #1
 3f0f5ac:	e3720001 	cmn	r2, #1	; 0x1
 3f0f5b0:	e4cc3001 	strb	r3, [r12], #1
 3f0f5b4:	1afffffa 	bne	3f0f5a4 <memcpy+0x1c>

	return dest;
}
 3f0f5b8:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f5bc <memmove>:
 3f0f5bc:	e1a0c00d 	mov	r12, r13
 3f0f5c0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f5c4:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_MEMMOVE
/**
 * memmove - Copy one area of memory to another
 * @dest: Where to copy to
 * @src: Where to copy from
 * @count: The size of the area.
 *
 * Unlike memcpy(), memmove() copes with overlapping areas.
 */
void * memmove(void * dest,const void *src,size_t count)
{
	char *tmp, *s;

	if (dest <= src) {
 3f0f5c8:	e1500001 	cmp	r0, r1
 3f0f5cc:	8a000009 	bhi	3f0f5f8 <memmove+0x3c>
		tmp = (char *) dest;
 3f0f5d0:	e1a0c000 	mov	r12, r0
		s = (char *) src;
		while (count--)
 3f0f5d4:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f5d8:	e3720001 	cmn	r2, #1	; 0x1
 3f0f5dc:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
			*tmp++ = *s++;
 3f0f5e0:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f5e4:	e4d13001 	ldrb	r3, [r1], #1
 3f0f5e8:	e3720001 	cmn	r2, #1	; 0x1
 3f0f5ec:	e4cc3001 	strb	r3, [r12], #1
 3f0f5f0:	1afffffa 	bne	3f0f5e0 <memmove+0x24>
		}
 3f0f5f4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else {
		tmp = (char *) dest + count;
 3f0f5f8:	e080c002 	add	r12, r0, r2
		s = (char *) src + count;
 3f0f5fc:	e0811002 	add	r1, r1, r2
		while (count--)
 3f0f600:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f604:	e3720001 	cmn	r2, #1	; 0x1
 3f0f608:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
			*--tmp = *--s;
 3f0f60c:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0f610:	e5713001 	ldrb	r3, [r1, -#1]!
 3f0f614:	e3720001 	cmn	r2, #1	; 0x1
 3f0f618:	e56c3001 	strb	r3, [r12, -#1]!
 3f0f61c:	1afffffa 	bne	3f0f60c <memmove+0x50>
		}

	return dest;
}
 3f0f620:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f624 <memcmp>:
 3f0f624:	e1a0c00d 	mov	r12, r13
 3f0f628:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f62c:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_MEMCMP
/**
 * memcmp - Compare two areas of memory
 * @cs: One area of memory
 * @ct: Another area of memory
 * @count: The size of the area.
 */
int memcmp(const void * cs,const void * ct,size_t count)
{
	const unsigned char *su1, *su2;
	int res = 0;
 3f0f630:	e3a03000 	mov	r3, #0	; 0x0

	for( su1 = cs, su2 = ct; 0 < count; ++su1, ++su2, count--)
 3f0f634:	e252c000 	subs	r12, r2, #0	; 0x0
 3f0f638:	0a000008 	beq	3f0f660 <memcmp+0x3c>
		if ((res = *su1 - *su2) != 0)
 3f0f63c:	ea000003 	b	3f0f650 <memcmp+0x2c>
 3f0f640:	e2800001 	add	r0, r0, #1	; 0x1
 3f0f644:	e2811001 	add	r1, r1, #1	; 0x1
 3f0f648:	e25cc001 	subs	r12, r12, #1	; 0x1
 3f0f64c:	0a000003 	beq	3f0f660 <memcmp+0x3c>
 3f0f650:	e5d02000 	ldrb	r2, [r0]
 3f0f654:	e5d13000 	ldrb	r3, [r1]
 3f0f658:	e0523003 	subs	r3, r2, r3
 3f0f65c:	0afffff7 	beq	3f0f640 <memcmp+0x1c>
			break;
	return res;
 3f0f660:	e1a00003 	mov	r0, r3
}
 3f0f664:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f668 <memscan>:
 3f0f668:	e1a0c00d 	mov	r12, r13
 3f0f66c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f670:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_MEMSCAN
/**
 * memscan - Find a character in an area of memory.
 * @addr: The memory area
 * @c: The byte to search for
 * @size: The size of the area.
 *
 * returns the address of the first occurrence of @c, or 1 byte past
 * the area if @c is not found
 */
void * memscan(void * addr, int c, size_t size)
{
	unsigned char * p = (unsigned char *) addr;

	while (size) {
 3f0f674:	e3520000 	cmp	r2, #0	; 0x0
 3f0f678:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
		if (*p == c)
 3f0f67c:	e5d03000 	ldrb	r3, [r0]
 3f0f680:	e1530001 	cmp	r3, r1
 3f0f684:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
			return (void *) p;
		p++;
 3f0f688:	e2800001 	add	r0, r0, #1	; 0x1
		size--;
	}
 3f0f68c:	e2522001 	subs	r2, r2, #1	; 0x1
 3f0f690:	1afffff9 	bne	3f0f67c <memscan+0x14>
	return (void *) p;
}
 3f0f694:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f698 <strstr>:
 3f0f698:	e1a0c00d 	mov	r12, r13
 3f0f69c:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f0f6a0:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_STRSTR
/**
 * strstr - Find the first substring in a %NUL terminated string
 * @s1: The string to be searched
 * @s2: The string to search for
 */
char * strstr(const char * s1,const char * s2)
{
 3f0f6a4:	e1a05000 	mov	r5, r0
 3f0f6a8:	e1a07001 	mov	r7, r1
	int l1, l2;

	l2 = strlen(s2);
 3f0f6ac:	e1a00007 	mov	r0, r7
 3f0f6b0:	ebffff04 	bl	3f0f2c8 <strlen>
	if (!l2)
 3f0f6b4:	e2506000 	subs	r6, r0, #0	; 0x0
		return (char *) s1;
 3f0f6b8:	e1a00005 	mov	r0, r5
 3f0f6bc:	091ba8f0 	ldmeqdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	l1 = strlen(s1);
 3f0f6c0:	ebffff00 	bl	3f0f2c8 <strlen>
 3f0f6c4:	e1a04000 	mov	r4, r0
	while (l1 >= l2) {
 3f0f6c8:	e1540006 	cmp	r4, r6
 3f0f6cc:	ba00000a 	blt	3f0f6fc <strstr+0x64>
		l1--;
 3f0f6d0:	e2444001 	sub	r4, r4, #1	; 0x1
		if (!memcmp(s1,s2,l2))
 3f0f6d4:	e1a00005 	mov	r0, r5
 3f0f6d8:	e1a01007 	mov	r1, r7
 3f0f6dc:	e1a02006 	mov	r2, r6
 3f0f6e0:	ebffffcf 	bl	3f0f624 <memcmp>
 3f0f6e4:	e3500000 	cmp	r0, #0	; 0x0
			return (char *) s1;
 3f0f6e8:	01a00005 	moveq	r0, r5
 3f0f6ec:	091ba8f0 	ldmeqdb	r11, {r4, r5, r6, r7, r11, r13, r15}
		s1++;
 3f0f6f0:	e2855001 	add	r5, r5, #1	; 0x1
	}
 3f0f6f4:	e1540006 	cmp	r4, r6
 3f0f6f8:	aafffff4 	bge	3f0f6d0 <strstr+0x38>
	return NULL;
 3f0f6fc:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0f700:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}

03f0f704 <memchr>:
 3f0f704:	e1a0c00d 	mov	r12, r13
 3f0f708:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f70c:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif

#ifndef __HAVE_ARCH_MEMCHR
/**
 * memchr - Find a character in an area of memory.
 * @s: The memory area
 * @c: The byte to search for
 * @n: The size of the area.
 *
 * returns the address of the first occurrence of @c, or %NULL
 * if @c is not found
 */
void *memchr(const void *s, int c, size_t n)
{
	const unsigned char *p = s;
	while (n-- != 0) {
 3f0f710:	e242c001 	sub	r12, r2, #1	; 0x1
 3f0f714:	e37c0001 	cmn	r12, #1	; 0x1
 3f0f718:	0a000007 	beq	3f0f73c <memchr+0x38>
		if ((unsigned char)c == *p++) {
 3f0f71c:	e4d02001 	ldrb	r2, [r0], #1
 3f0f720:	e20130ff 	and	r3, r1, #255	; 0xff
 3f0f724:	e1530002 	cmp	r3, r2
			return (void *)(p-1);
 3f0f728:	02400001 	subeq	r0, r0, #1	; 0x1
 3f0f72c:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
		}
	}
 3f0f730:	e24cc001 	sub	r12, r12, #1	; 0x1
 3f0f734:	e37c0001 	cmn	r12, #1	; 0x1
 3f0f738:	1afffff7 	bne	3f0f71c <memchr+0x18>
	return NULL;
 3f0f73c:	e3a00000 	mov	r0, #0	; 0x0
}
 3f0f740:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f744 <simple_strtoul>:
 3f0f744:	e1a0c00d 	mov	r12, r13
 3f0f748:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f0f74c:	e24cb004 	sub	r11, r12, #4	; 0x4
extern int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
#endif

unsigned long simple_strtoul(const char *cp,char **endp,unsigned int base)
{
 3f0f750:	e1a0e002 	mov	r14, r2
	unsigned long result = 0,value;
 3f0f754:	e3a04000 	mov	r4, #0	; 0x0

	if (*cp == '0') {
 3f0f758:	e5d03000 	ldrb	r3, [r0]
 3f0f75c:	e1a05001 	mov	r5, r1
 3f0f760:	e3530030 	cmp	r3, #48	; 0x30
 3f0f764:	1a00000b 	bne	3f0f798 <simple_strtoul+0x54>
		cp++;
		if ((*cp == 'x') && isxdigit(cp[1])) {
 3f0f768:	e5f03001 	ldrb	r3, [r0, #1]!
 3f0f76c:	e3530078 	cmp	r3, #120	; 0x78
 3f0f770:	1a000006 	bne	3f0f790 <simple_strtoul+0x4c>
 3f0f774:	e59f2088 	ldr	r2, [pc, #88]	; 3f0f804 <simple_strtoul+0xc0>
 3f0f778:	e5d03001 	ldrb	r3, [r0, #1]
 3f0f77c:	e7d23003 	ldrb	r3, [r2, r3]
 3f0f780:	e2033044 	and	r3, r3, #68	; 0x44
 3f0f784:	e1530004 	cmp	r3, r4
			base = 16;
 3f0f788:	13a0e010 	movne	r14, #16	; 0x10
			cp++;
 3f0f78c:	12800001 	addne	r0, r0, #1	; 0x1
		}
		if (!base) {
 3f0f790:	e35e0000 	cmp	r14, #0	; 0x0
 3f0f794:	03a0e008 	moveq	r14, #8	; 0x8
			base = 8;
		}
	}
	if (!base) {
		base = 10;
	}
	while (isxdigit(*cp) && (value = isdigit(*cp) ? *cp-'0' : (islower(*cp)
	    ? toupper(*cp) : *cp)-'A'+10) < base) {
 3f0f798:	e5d02000 	ldrb	r2, [r0]
 3f0f79c:	e59f1060 	ldr	r1, [pc, #60]	; 3f0f804 <simple_strtoul+0xc0>
 3f0f7a0:	e35e0000 	cmp	r14, #0	; 0x0
 3f0f7a4:	e7d13002 	ldrb	r3, [r1, r2]
 3f0f7a8:	03a0e00a 	moveq	r14, #10	; 0xa
 3f0f7ac:	ea00000d 	b	3f0f7e8 <simple_strtoul+0xa4>
 3f0f7b0:	e7d13002 	ldrb	r3, [r1, r2]
 3f0f7b4:	e3130004 	tst	r3, #4	; 0x4
 3f0f7b8:	1242c030 	subne	r12, r2, #48	; 0x30
 3f0f7bc:	1a000004 	bne	3f0f7d4 <simple_strtoul+0x90>
 3f0f7c0:	e3130002 	tst	r3, #2	; 0x2

static inline unsigned char __toupper(unsigned char c)
{
	if (islower(c))
		c -= 'a'-'A';
 3f0f7c4:	12423020 	subne	r3, r2, #32	; 0x20
 3f0f7c8:	120330ff 	andne	r3, r3, #255	; 0xff
 3f0f7cc:	1243c037 	subne	r12, r3, #55	; 0x37
 3f0f7d0:	0242c037 	subeq	r12, r2, #55	; 0x37
 3f0f7d4:	e15c000e 	cmp	r12, r14
 3f0f7d8:	2a000005 	bcs	3f0f7f4 <simple_strtoul+0xb0>
 3f0f7dc:	e5f02001 	ldrb	r2, [r0, #1]!
 3f0f7e0:	e7d13002 	ldrb	r3, [r1, r2]
		result = result*base + value;
 3f0f7e4:	e024c49e 	mla	r4, r14, r4, r12
 3f0f7e8:	e2033044 	and	r3, r3, #68	; 0x44
 3f0f7ec:	e3530000 	cmp	r3, #0	; 0x0
 3f0f7f0:	1affffee 	bne	3f0f7b0 <simple_strtoul+0x6c>
		cp++;
	}
	if (endp)
 3f0f7f4:	e3550000 	cmp	r5, #0	; 0x0
		*endp = (char *)cp;
 3f0f7f8:	15850000 	strne	r0, [r5]
	return result;
 3f0f7fc:	e1a00004 	mov	r0, r4
}
 3f0f800:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f0f804:	03f21078 	mvneqs	r1, #120	; 0x78

03f0f808 <simple_strtol>:
 3f0f808:	e1a0c00d 	mov	r12, r13
 3f0f80c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

long simple_strtol(const char *cp,char **endp,unsigned int base)
{
	if(*cp=='-')
 3f0f810:	e5d03000 	ldrb	r3, [r0]
 3f0f814:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f0f818:	e353002d 	cmp	r3, #45	; 0x2d
 3f0f81c:	0a000001 	beq	3f0f828 <simple_strtol+0x20>
		return -simple_strtoul(cp+1,endp,base);
	return simple_strtoul(cp,endp,base);
 3f0f820:	ebffffc7 	bl	3f0f744 <simple_strtoul>
 3f0f824:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f0f828:	e2800001 	add	r0, r0, #1	; 0x1
 3f0f82c:	ebffffc4 	bl	3f0f744 <simple_strtoul>
 3f0f830:	e2600000 	rsb	r0, r0, #0	; 0x0
 3f0f834:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f838 <skip_atoi>:
 3f0f838:	e1a0c00d 	mov	r12, r13
 3f0f83c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f0f840:	e24cb004 	sub	r11, r12, #4	; 0x4
}

/* we use this so that we can do without the ctype library */
#define is_digit(c)	((c) >= '0' && (c) <= '9')

static int skip_atoi(const char **s)
{
 3f0f844:	e1a0c000 	mov	r12, r0
	int i=0;

	while (is_digit(**s))
 3f0f848:	e59c1000 	ldr	r1, [r12]
 3f0f84c:	e5d13000 	ldrb	r3, [r1]
 3f0f850:	e3a00000 	mov	r0, #0	; 0x0
 3f0f854:	e2433030 	sub	r3, r3, #48	; 0x30
 3f0f858:	e3530009 	cmp	r3, #9	; 0x9
 3f0f85c:	891ba800 	ldmhidb	r11, {r11, r13, r15}
		i = i*10 + *((*s)++) - '0';
 3f0f860:	e4d12001 	ldrb	r2, [r1], #1
 3f0f864:	e1a03001 	mov	r3, r1
 3f0f868:	e58c3000 	str	r3, [r12]
 3f0f86c:	e0803100 	add	r3, r0, r0, lsl #2
 3f0f870:	e0822083 	add	r2, r2, r3, lsl #1
 3f0f874:	e5d13000 	ldrb	r3, [r1]
 3f0f878:	e2420030 	sub	r0, r2, #48	; 0x30
 3f0f87c:	e2433030 	sub	r3, r3, #48	; 0x30
 3f0f880:	e3530009 	cmp	r3, #9	; 0x9
 3f0f884:	9afffff5 	bls	3f0f860 <skip_atoi+0x28>
	return i;
}
 3f0f888:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f0f88c <number>:
 3f0f88c:	e1a0c00d 	mov	r12, r13
 3f0f890:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0f894:	e24cb004 	sub	r11, r12, #4	; 0x4

#define ZEROPAD	1		/* pad with zero */
#define SIGN	2		/* unsigned/signed long */
#define PLUS	4		/* show plus */
#define SPACE	8		/* space if plus */
#define LEFT	16		/* left justified */
#define SPECIAL	32		/* 0x */
#define LARGE	64		/* use 'ABCDEF' instead of 'abcdef' */

#define do_div(n,base) ({ \
int __res; \
__res = ((unsigned long) n) % (unsigned) base; \
n = ((unsigned long) n) / (unsigned) base; \
__res; })

static char * number(char * str, long num, int base, int size, int precision
	,int type)
{
 3f0f898:	e1a0a001 	mov	r10, r1
	char c,sign,tmp[66];
	const char *digits="0123456789abcdefghijklmnopqrstuvwxyz";
 3f0f89c:	e59f1198 	ldr	r1, [pc, #198]	; 3f0fa3c <number+0x1b0>
 3f0f8a0:	e1a06003 	mov	r6, r3
	int i;

	if (type & LARGE)
		digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 3f0f8a4:	e59f3194 	ldr	r3, [pc, #194]	; 3f0fa40 <number+0x1b4>
 3f0f8a8:	e24dd05c 	sub	r13, r13, #92	; 0x5c
 3f0f8ac:	e59b7008 	ldr	r7, [r11, #8]
 3f0f8b0:	e1a09002 	mov	r9, r2
 3f0f8b4:	e50b006c 	str	r0, [r11, -#108]
 3f0f8b8:	e3170040 	tst	r7, #64	; 0x40
 3f0f8bc:	11a01003 	movne	r1, r3
	if (type & LEFT)
 3f0f8c0:	e3170010 	tst	r7, #16	; 0x10
		type &= ~ZEROPAD;
 3f0f8c4:	e3c73001 	bic	r3, r7, #1	; 0x1
 3f0f8c8:	11a07003 	movne	r7, r3
	if (base < 2 || base > 36)
 3f0f8cc:	e2493002 	sub	r3, r9, #2	; 0x2
 3f0f8d0:	e3530022 	cmp	r3, #34	; 0x22
 3f0f8d4:	e50b1078 	str	r1, [r11, -#120]
		return 0;
 3f0f8d8:	83a00000 	movhi	r0, #0	; 0x0
 3f0f8dc:	8a000099 	bhi	3f0fb48 <number+0x2bc>
	c = (type & ZEROPAD) ? '0' : ' ';
 3f0f8e0:	e3170001 	tst	r7, #1	; 0x1
	sign = 0;
 3f0f8e4:	e3a02000 	mov	r2, #0	; 0x0
 3f0f8e8:	03a03020 	moveq	r3, #32	; 0x20
 3f0f8ec:	13a03030 	movne	r3, #48	; 0x30
 3f0f8f0:	e50b2074 	str	r2, [r11, -#116]
	if (type & SIGN) {
 3f0f8f4:	e3170002 	tst	r7, #2	; 0x2
 3f0f8f8:	e50b3070 	str	r3, [r11, -#112]
 3f0f8fc:	0a00000e 	beq	3f0f93c <number+0xb0>
		if (num < 0) {
 3f0f900:	e15a0002 	cmp	r10, r2
			sign = '-';
 3f0f904:	b3a0c02d 	movlt	r12, #45	; 0x2d
			num = -num;
 3f0f908:	b26aa000 	rsblt	r10, r10, #0	; 0x0
			size--;
 3f0f90c:	b2466001 	sublt	r6, r6, #1	; 0x1
 3f0f910:	b50bc074 	strlt	r12, [r11, -#116]
		} else if (type & PLUS) {
 3f0f914:	ba000008 	blt	3f0f93c <number+0xb0>
 3f0f918:	e3170004 	tst	r7, #4	; 0x4
			sign = '+';
 3f0f91c:	13a0102b 	movne	r1, #43	; 0x2b
			size--;
 3f0f920:	12466001 	subne	r6, r6, #1	; 0x1
 3f0f924:	150b1074 	strne	r1, [r11, -#116]
		} else if (type & SPACE) {
 3f0f928:	1a000003 	bne	3f0f93c <number+0xb0>
 3f0f92c:	e3170008 	tst	r7, #8	; 0x8
			sign = ' ';
 3f0f930:	13a02020 	movne	r2, #32	; 0x20
			size--;
 3f0f934:	12466001 	subne	r6, r6, #1	; 0x1
 3f0f938:	150b2074 	strne	r2, [r11, -#116]
		}
	}
	if (type & SPECIAL) {
 3f0f93c:	e2173020 	ands	r3, r7, #32	; 0x20
 3f0f940:	e50b307c 	str	r3, [r11, -#124]
 3f0f944:	0a000004 	beq	3f0f95c <number+0xd0>
		if (base == 16)
 3f0f948:	e3590010 	cmp	r9, #16	; 0x10
			size -= 2;
 3f0f94c:	02466002 	subeq	r6, r6, #2	; 0x2
 3f0f950:	0a000001 	beq	3f0f95c <number+0xd0>
		else if (base == 8)
 3f0f954:	e3590008 	cmp	r9, #8	; 0x8
 3f0f958:	02466001 	subeq	r6, r6, #1	; 0x1
			size--;
	}
	i = 0;
 3f0f95c:	e3a0c000 	mov	r12, #0	; 0x0
	if (num == 0)
 3f0f960:	e15a000c 	cmp	r10, r12
		tmp[i++]='0';
 3f0f964:	028cc001 	addeq	r12, r12, #1	; 0x1
 3f0f968:	03a03030 	moveq	r3, #48	; 0x30
 3f0f96c:	054b3068 	streqb	r3, [r11, -#104]
 3f0f970:	0a00000f 	beq	3f0f9b4 <number+0x128>
	else while (num != 0)
		tmp[i++] = digits[do_div(num,base)];
 3f0f974:	e1a0000a 	mov	r0, r10
 3f0f978:	e1a01009 	mov	r1, r9
 3f0f97c:	e24b5068 	sub	r5, r11, #104	; 0x68
 3f0f980:	e50bc080 	str	r12, [r11, -#128]
 3f0f984:	eb000ebb 	bl	3f13478 <__umodsi3>
 3f0f988:	e1a04000 	mov	r4, r0
 3f0f98c:	e1a0000a 	mov	r0, r10
 3f0f990:	e1a01009 	mov	r1, r9
 3f0f994:	eb000e91 	bl	3f133e0 <__udivsi3>
 3f0f998:	e51b1078 	ldr	r1, [r11, -#120]
 3f0f99c:	e51bc080 	ldr	r12, [r11, -#128]
 3f0f9a0:	e7d13004 	ldrb	r3, [r1, r4]
 3f0f9a4:	e250a000 	subs	r10, r0, #0	; 0x0
 3f0f9a8:	e7c5300c 	strb	r3, [r5, r12]
 3f0f9ac:	e28cc001 	add	r12, r12, #1	; 0x1
 3f0f9b0:	1affffef 	bne	3f0f974 <number+0xe8>
	if (i > precision)
 3f0f9b4:	e59b2004 	ldr	r2, [r11, #4]
 3f0f9b8:	e15c0002 	cmp	r12, r2
 3f0f9bc:	a1a0200c 	movge	r2, r12
		precision = i;
	size -= precision;
 3f0f9c0:	e0626006 	rsb	r6, r2, r6
	if (!(type&(ZEROPAD+LEFT)))
 3f0f9c4:	e3170011 	tst	r7, #17	; 0x11
 3f0f9c8:	e58b2004 	str	r2, [r11, #4]
 3f0f9cc:	1a00000b 	bne	3f0fa00 <number+0x174>
		while(size-->0)
 3f0f9d0:	e1a03006 	mov	r3, r6
 3f0f9d4:	e2466001 	sub	r6, r6, #1	; 0x1
 3f0f9d8:	e3530000 	cmp	r3, #0	; 0x0
 3f0f9dc:	da000007 	ble	3f0fa00 <number+0x174>
			*str++ = ' ';
 3f0f9e0:	e1a03006 	mov	r3, r6
 3f0f9e4:	e3530000 	cmp	r3, #0	; 0x0
 3f0f9e8:	e51b106c 	ldr	r1, [r11, -#108]
 3f0f9ec:	e3a03020 	mov	r3, #32	; 0x20
 3f0f9f0:	e4c13001 	strb	r3, [r1], #1
 3f0f9f4:	e2466001 	sub	r6, r6, #1	; 0x1
 3f0f9f8:	e50b106c 	str	r1, [r11, -#108]
 3f0f9fc:	cafffff7 	bgt	3f0f9e0 <number+0x154>
	if (sign)
 3f0fa00:	e51b2074 	ldr	r2, [r11, -#116]
 3f0fa04:	e3520000 	cmp	r2, #0	; 0x0
		*str++ = sign;
 3f0fa08:	151b306c 	ldrne	r3, [r11, -#108]
 3f0fa0c:	14c32001 	strneb	r2, [r3], #1
 3f0fa10:	150b306c 	strne	r3, [r11, -#108]
	if (type & SPECIAL) {
 3f0fa14:	e51b107c 	ldr	r1, [r11, -#124]
 3f0fa18:	e3510000 	cmp	r1, #0	; 0x0
 3f0fa1c:	0a000011 	beq	3f0fa68 <number+0x1dc>
		if (base==8)
 3f0fa20:	e3590008 	cmp	r9, #8	; 0x8
 3f0fa24:	1a000006 	bne	3f0fa44 <number+0x1b8>
			*str++ = '0';
 3f0fa28:	e51b206c 	ldr	r2, [r11, -#108]
 3f0fa2c:	e3a03030 	mov	r3, #48	; 0x30
 3f0fa30:	e4c23001 	strb	r3, [r2], #1
 3f0fa34:	e50b206c 	str	r2, [r11, -#108]
 3f0fa38:	ea00000a 	b	3f0fa68 <number+0x1dc>
 3f0fa3c:	03f1f608 	mvneqs	r15, #8388608	; 0x800000
 3f0fa40:	03f1f630 	mvneqs	r15, #50331648	; 0x3000000
		else if (base==16) {
 3f0fa44:	e3590010 	cmp	r9, #16	; 0x10
 3f0fa48:	1a000006 	bne	3f0fa68 <number+0x1dc>
			*str++ = '0';
 3f0fa4c:	e51b106c 	ldr	r1, [r11, -#108]
 3f0fa50:	e3a03030 	mov	r3, #48	; 0x30
 3f0fa54:	e4c13001 	strb	r3, [r1], #1
			*str++ = digits[33];
 3f0fa58:	e51b2078 	ldr	r2, [r11, -#120]
 3f0fa5c:	e5d23021 	ldrb	r3, [r2, #33]
 3f0fa60:	e4c13001 	strb	r3, [r1], #1
 3f0fa64:	e50b106c 	str	r1, [r11, -#108]
		}
	}
	if (!(type & LEFT))
 3f0fa68:	e3170010 	tst	r7, #16	; 0x10
 3f0fa6c:	1a00000b 	bne	3f0faa0 <number+0x214>
		while (size-- > 0)
 3f0fa70:	e1a03006 	mov	r3, r6
 3f0fa74:	e2466001 	sub	r6, r6, #1	; 0x1
 3f0fa78:	e3530000 	cmp	r3, #0	; 0x0
 3f0fa7c:	da000007 	ble	3f0faa0 <number+0x214>
			*str++ = c;
 3f0fa80:	e1a03006 	mov	r3, r6
 3f0fa84:	e3530000 	cmp	r3, #0	; 0x0
 3f0fa88:	e24b1070 	sub	r1, r11, #112	; 0x70
 3f0fa8c:	e891000a 	ldmia	r1, {r1, r3}
 3f0fa90:	e4c31001 	strb	r1, [r3], #1
 3f0fa94:	e2466001 	sub	r6, r6, #1	; 0x1
 3f0fa98:	e50b306c 	str	r3, [r11, -#108]
 3f0fa9c:	cafffff7 	bgt	3f0fa80 <number+0x1f4>
	while (i < precision--)
 3f0faa0:	e59b3004 	ldr	r3, [r11, #4]
 3f0faa4:	e1a02003 	mov	r2, r3
 3f0faa8:	e2422001 	sub	r2, r2, #1	; 0x1
 3f0faac:	e15c0003 	cmp	r12, r3
 3f0fab0:	e58b2004 	str	r2, [r11, #4]
 3f0fab4:	aa000009 	bge	3f0fae0 <number+0x254>
		*str++ = '0';
 3f0fab8:	e59b3004 	ldr	r3, [r11, #4]
 3f0fabc:	e51b206c 	ldr	r2, [r11, -#108]
 3f0fac0:	e1a01003 	mov	r1, r3
 3f0fac4:	e2411001 	sub	r1, r1, #1	; 0x1
 3f0fac8:	e15c0003 	cmp	r12, r3
 3f0facc:	e58b1004 	str	r1, [r11, #4]
 3f0fad0:	e3a03030 	mov	r3, #48	; 0x30
 3f0fad4:	e4c23001 	strb	r3, [r2], #1
 3f0fad8:	e50b206c 	str	r2, [r11, -#108]
 3f0fadc:	bafffff5 	blt	3f0fab8 <number+0x22c>
	while (i-- > 0)
 3f0fae0:	e1a0300c 	mov	r3, r12
 3f0fae4:	e24cc001 	sub	r12, r12, #1	; 0x1
 3f0fae8:	e3530000 	cmp	r3, #0	; 0x0
 3f0faec:	da000008 	ble	3f0fb14 <number+0x288>
		*str++ = tmp[i];
 3f0faf0:	e24b3068 	sub	r3, r11, #104	; 0x68
 3f0faf4:	e7d3300c 	ldrb	r3, [r3, r12]
 3f0faf8:	e1a0200c 	mov	r2, r12
 3f0fafc:	e51b106c 	ldr	r1, [r11, -#108]
 3f0fb00:	e24cc001 	sub	r12, r12, #1	; 0x1
 3f0fb04:	e4c13001 	strb	r3, [r1], #1
 3f0fb08:	e3520000 	cmp	r2, #0	; 0x0
 3f0fb0c:	e50b106c 	str	r1, [r11, -#108]
 3f0fb10:	cafffff6 	bgt	3f0faf0 <number+0x264>
	while (size-- > 0)
 3f0fb14:	e1a03006 	mov	r3, r6
 3f0fb18:	e2466001 	sub	r6, r6, #1	; 0x1
 3f0fb1c:	e3530000 	cmp	r3, #0	; 0x0
 3f0fb20:	da000007 	ble	3f0fb44 <number+0x2b8>
		*str++ = ' ';
 3f0fb24:	e1a03006 	mov	r3, r6
 3f0fb28:	e3530000 	cmp	r3, #0	; 0x0
 3f0fb2c:	e51b206c 	ldr	r2, [r11, -#108]
 3f0fb30:	e3a03020 	mov	r3, #32	; 0x20
 3f0fb34:	e4c23001 	strb	r3, [r2], #1
 3f0fb38:	e2466001 	sub	r6, r6, #1	; 0x1
 3f0fb3c:	e50b206c 	str	r2, [r11, -#108]
 3f0fb40:	cafffff7 	bgt	3f0fb24 <number+0x298>
	return str;
 3f0fb44:	e51b006c 	ldr	r0, [r11, -#108]
}
 3f0fb48:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f0fb4c <vsprintf>:
 3f0fb4c:	e1a0c00d 	mov	r12, r13
 3f0fb50:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f0fb54:	e24cb004 	sub	r11, r12, #4	; 0x4

/* Forward decl. needed for IP address printing stuff... */
int sprintf(char * buf, const char *fmt, ...);

int vsprintf(char *buf, const char *fmt, va_list args)
{
 3f0fb58:	e1a0a002 	mov	r10, r2
	int len;
	unsigned long num;
	int i, base;
	char * str;
	const char *s;

	int flags;		/* flags to number() */

	int field_width;	/* width of output field */
	int precision;		/* min. # of digits for integers; max
				   number of chars for from string */
	int qualifier;		/* 'h', 'l', or 'L' for integer fields */

	for (str=buf ; *fmt ; ++fmt) {
 3f0fb5c:	e1a02001 	mov	r2, r1
 3f0fb60:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f0fb64:	e50b1028 	str	r1, [r11, -#40]
 3f0fb68:	e1a09000 	mov	r9, r0
 3f0fb6c:	e5d23000 	ldrb	r3, [r2]
 3f0fb70:	e1a07009 	mov	r7, r9
 3f0fb74:	e3530000 	cmp	r3, #0	; 0x0
 3f0fb78:	0a00012b 	beq	3f1002c <vsprintf+0x4e0>
		if (*fmt != '%') {
 3f0fb7c:	e5d21000 	ldrb	r1, [r2]
 3f0fb80:	e3510025 	cmp	r1, #37	; 0x25
			*str++ = *fmt;
 3f0fb84:	14c71001 	strneb	r1, [r7], #1
			continue;
 3f0fb88:	1a000121 	bne	3f10014 <vsprintf+0x4c8>
		}

		/* process flags */
		flags = 0;
 3f0fb8c:	e3a06000 	mov	r6, #0	; 0x0
		repeat:
			++fmt;		/* this also skips first '%' */
 3f0fb90:	e51b3028 	ldr	r3, [r11, -#40]
 3f0fb94:	e2832001 	add	r2, r3, #1	; 0x1
 3f0fb98:	e50b2028 	str	r2, [r11, -#40]
			switch (*fmt) {
 3f0fb9c:	e5d33001 	ldrb	r3, [r3, #1]
 3f0fba0:	e2433020 	sub	r3, r3, #32	; 0x20
 3f0fba4:	e3530010 	cmp	r3, #16	; 0x10
 3f0fba8:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f0fbac:	ea00001a 	b	3f0fc1c <vsprintf+0xd0>
 3f0fbb0:	03f0fc04 	mvneqs	r15, #1024	; 0x400
 3f0fbb4:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbb8:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbbc:	03f0fc0c 	mvneqs	r15, #3072	; 0xc00
 3f0fbc0:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbc4:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbc8:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbcc:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbd0:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbd4:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbd8:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbdc:	03f0fbfc 	mvneqs	r15, #258048	; 0x3f000
 3f0fbe0:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbe4:	03f0fbf4 	mvneqs	r15, #249856	; 0x3d000
 3f0fbe8:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbec:	03f0fc1c 	mvneqs	r15, #7168	; 0x1c00
 3f0fbf0:	03f0fc14 	mvneqs	r15, #5120	; 0x1400
				case '-': flags |= LEFT; goto repeat;
 3f0fbf4:	e3866010 	orr	r6, r6, #16	; 0x10
 3f0fbf8:	eaffffe4 	b	3f0fb90 <vsprintf+0x44>
				case '+': flags |= PLUS; goto repeat;
 3f0fbfc:	e3866004 	orr	r6, r6, #4	; 0x4
 3f0fc00:	eaffffe2 	b	3f0fb90 <vsprintf+0x44>
				case ' ': flags |= SPACE; goto repeat;
 3f0fc04:	e3866008 	orr	r6, r6, #8	; 0x8
 3f0fc08:	eaffffe0 	b	3f0fb90 <vsprintf+0x44>
				case '#': flags |= SPECIAL; goto repeat;
 3f0fc0c:	e3866020 	orr	r6, r6, #32	; 0x20
 3f0fc10:	eaffffde 	b	3f0fb90 <vsprintf+0x44>
				case '0': flags |= ZEROPAD; goto repeat;
 3f0fc14:	e3866001 	orr	r6, r6, #1	; 0x1
 3f0fc18:	eaffffdc 	b	3f0fb90 <vsprintf+0x44>
				}

		/* get field width */
		field_width = -1;
		if (is_digit(*fmt))
 3f0fc1c:	e5d21000 	ldrb	r1, [r2]
 3f0fc20:	e3e04000 	mvn	r4, #0	; 0x0
 3f0fc24:	e2413030 	sub	r3, r1, #48	; 0x30
 3f0fc28:	e3530009 	cmp	r3, #9	; 0x9
 3f0fc2c:	8a000003 	bhi	3f0fc40 <vsprintf+0xf4>
			field_width = skip_atoi(&fmt);
 3f0fc30:	e24b0028 	sub	r0, r11, #40	; 0x28
 3f0fc34:	ebfffeff 	bl	3f0f838 <skip_atoi>
 3f0fc38:	e1a04000 	mov	r4, r0
 3f0fc3c:	ea000008 	b	3f0fc64 <vsprintf+0x118>
		else if (*fmt == '*') {
 3f0fc40:	e20130ff 	and	r3, r1, #255	; 0xff
 3f0fc44:	e353002a 	cmp	r3, #42	; 0x2a
 3f0fc48:	1a000005 	bne	3f0fc64 <vsprintf+0x118>
			++fmt;
			/* it's the next argument */
			field_width = va_arg(args, int);
 3f0fc4c:	e49a4004 	ldr	r4, [r10], #4
 3f0fc50:	e2823001 	add	r3, r2, #1	; 0x1
 3f0fc54:	e50b3028 	str	r3, [r11, -#40]
			if (field_width < 0) {
 3f0fc58:	e3540000 	cmp	r4, #0	; 0x0
				field_width = -field_width;
 3f0fc5c:	b2644000 	rsblt	r4, r4, #0	; 0x0
				flags |= LEFT;
 3f0fc60:	b3866010 	orrlt	r6, r6, #16	; 0x10
			}
		}

		/* get the precision */
		precision = -1;
		if (*fmt == '.') {
 3f0fc64:	e51b2028 	ldr	r2, [r11, -#40]
 3f0fc68:	e5d23000 	ldrb	r3, [r2]
 3f0fc6c:	e3e0c000 	mvn	r12, #0	; 0x0
 3f0fc70:	e353002e 	cmp	r3, #46	; 0x2e
 3f0fc74:	1a000010 	bne	3f0fcbc <vsprintf+0x170>
			++fmt;
 3f0fc78:	e2821001 	add	r1, r2, #1	; 0x1
 3f0fc7c:	e50b1028 	str	r1, [r11, -#40]
			if (is_digit(*fmt))
 3f0fc80:	e5d22001 	ldrb	r2, [r2, #1]
 3f0fc84:	e2423030 	sub	r3, r2, #48	; 0x30
 3f0fc88:	e3530009 	cmp	r3, #9	; 0x9
 3f0fc8c:	8a000003 	bhi	3f0fca0 <vsprintf+0x154>
				precision = skip_atoi(&fmt);
 3f0fc90:	e24b0028 	sub	r0, r11, #40	; 0x28
 3f0fc94:	ebfffee7 	bl	3f0f838 <skip_atoi>
 3f0fc98:	e1a0c000 	mov	r12, r0
 3f0fc9c:	ea000004 	b	3f0fcb4 <vsprintf+0x168>
			else if (*fmt == '*') {
 3f0fca0:	e20230ff 	and	r3, r2, #255	; 0xff
 3f0fca4:	e353002a 	cmp	r3, #42	; 0x2a
				++fmt;
 3f0fca8:	02813001 	addeq	r3, r1, #1	; 0x1
 3f0fcac:	050b3028 	streq	r3, [r11, -#40]
				/* it's the next argument */
				precision = va_arg(args, int);
 3f0fcb0:	049ac004 	ldreq	r12, [r10], #4
			}
			if (precision < 0)
 3f0fcb4:	e35c0000 	cmp	r12, #0	; 0x0
 3f0fcb8:	b3a0c000 	movlt	r12, #0	; 0x0
				precision = 0;
		}

		/* get the conversion qualifier */
		qualifier = -1;
		if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
 3f0fcbc:	e51b2028 	ldr	r2, [r11, -#40]
 3f0fcc0:	e5d23000 	ldrb	r3, [r2]
 3f0fcc4:	e3e01000 	mvn	r1, #0	; 0x0
 3f0fcc8:	e353006c 	cmp	r3, #108	; 0x6c
 3f0fccc:	13530068 	cmpne	r3, #104	; 0x68
 3f0fcd0:	0a000001 	beq	3f0fcdc <vsprintf+0x190>
 3f0fcd4:	e353004c 	cmp	r3, #76	; 0x4c
 3f0fcd8:	1a000001 	bne	3f0fce4 <vsprintf+0x198>
			qualifier = *fmt;
 3f0fcdc:	e4d21001 	ldrb	r1, [r2], #1
			++fmt;
 3f0fce0:	e50b2028 	str	r2, [r11, -#40]
		}

		/* default base */
		base = 10;

		switch (*fmt) {
 3f0fce4:	e51b3028 	ldr	r3, [r11, -#40]
 3f0fce8:	e5d33000 	ldrb	r3, [r3]
 3f0fcec:	e3a0200a 	mov	r2, #10	; 0xa
 3f0fcf0:	e2433025 	sub	r3, r3, #37	; 0x25
 3f0fcf4:	e3530053 	cmp	r3, #83	; 0x53
 3f0fcf8:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f0fcfc:	ea0000a7 	b	3f0ffa0 <vsprintf+0x454>
 3f0fd00:	03f0ff78 	mvneqs	r15, #480	; 0x1e0
 3f0fd04:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd08:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd0c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd10:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd14:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd18:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd1c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd20:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd24:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd28:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd2c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd30:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd34:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd38:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd3c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd40:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd44:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd48:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd4c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd50:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd54:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd58:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd5c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd60:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd64:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd68:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd6c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd70:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd74:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd78:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd7c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd80:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd84:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd88:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd8c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd90:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd94:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd98:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fd9c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fda0:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fda4:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fda8:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdac:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdb0:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdb4:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdb8:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdbc:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdc0:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdc4:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdc8:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdcc:	03f0ff8c 	mvneqs	r15, #560	; 0x230
 3f0fdd0:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdd4:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdd8:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fddc:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fde0:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fde4:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fde8:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdec:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdf0:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdf4:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fdf8:	03f0fe50 	mvneqs	r15, #1280	; 0x500
 3f0fdfc:	03f0ff98 	mvneqs	r15, #608	; 0x260
 3f0fe00:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe04:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe08:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe0c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe10:	03f0ff98 	mvneqs	r15, #608	; 0x260
 3f0fe14:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe18:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe1c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe20:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe24:	03f0ff64 	mvneqs	r15, #400	; 0x190
 3f0fe28:	03f0ff84 	mvneqs	r15, #528	; 0x210
 3f0fe2c:	03f0ff44 	mvneqs	r15, #272	; 0x110
 3f0fe30:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe34:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe38:	03f0feb0 	mvneqs	r15, #2816	; 0xb00
 3f0fe3c:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe40:	03f0ffc8 	mvneqs	r15, #800	; 0x320
 3f0fe44:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe48:	03f0ffa0 	mvneqs	r15, #640	; 0x280
 3f0fe4c:	03f0ff90 	mvneqs	r15, #576	; 0x240
		case 'c':
			if (!(flags & LEFT))
 3f0fe50:	e3160010 	tst	r6, #16	; 0x10
 3f0fe54:	1a000007 	bne	3f0fe78 <vsprintf+0x32c>
				while (--field_width > 0)
 3f0fe58:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0fe5c:	e3540000 	cmp	r4, #0	; 0x0
 3f0fe60:	da000004 	ble	3f0fe78 <vsprintf+0x32c>
					*str++ = ' ';
 3f0fe64:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0fe68:	e3540000 	cmp	r4, #0	; 0x0
 3f0fe6c:	e3a03020 	mov	r3, #32	; 0x20
 3f0fe70:	e4c73001 	strb	r3, [r7], #1
 3f0fe74:	cafffffa 	bgt	3f0fe64 <vsprintf+0x318>
			*str++ = (unsigned char) va_arg(args, int);
 3f0fe78:	e28aa004 	add	r10, r10, #4	; 0x4
 3f0fe7c:	e1a02007 	mov	r2, r7
 3f0fe80:	e2877001 	add	r7, r7, #1	; 0x1
			while (--field_width > 0)
 3f0fe84:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0fe88:	e55a3004 	ldrb	r3, [r10, -#4]
 3f0fe8c:	e3540000 	cmp	r4, #0	; 0x0
 3f0fe90:	e5c23000 	strb	r3, [r2]
 3f0fe94:	da00005e 	ble	3f10014 <vsprintf+0x4c8>
				*str++ = ' ';
 3f0fe98:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0fe9c:	e3540000 	cmp	r4, #0	; 0x0
 3f0fea0:	e3a03020 	mov	r3, #32	; 0x20
 3f0fea4:	e4c73001 	strb	r3, [r7], #1
 3f0fea8:	cafffffa 	bgt	3f0fe98 <vsprintf+0x34c>
			continue;
 3f0feac:	ea000058 	b	3f10014 <vsprintf+0x4c8>

		case 's':
			s = va_arg(args, char *);
 3f0feb0:	e49a5004 	ldr	r5, [r10], #4
			if (!s)
				s = "<NULL>";

			len = strnlen(s, precision);
 3f0feb4:	e1a0100c 	mov	r1, r12
 3f0feb8:	e59f3130 	ldr	r3, [pc, #130]	; 3f0fff0 <vsprintf+0x4a4>
 3f0febc:	e3550000 	cmp	r5, #0	; 0x0
 3f0fec0:	01a05003 	moveq	r5, r3
 3f0fec4:	e1a00005 	mov	r0, r5
 3f0fec8:	ebfffd0a 	bl	3f0f2f8 <strnlen>

			if (!(flags & LEFT))
 3f0fecc:	e3160010 	tst	r6, #16	; 0x10
 3f0fed0:	1a000009 	bne	3f0fefc <vsprintf+0x3b0>
				while (len < field_width--)
 3f0fed4:	e1a03004 	mov	r3, r4
 3f0fed8:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0fedc:	e1500003 	cmp	r0, r3
 3f0fee0:	aa000005 	bge	3f0fefc <vsprintf+0x3b0>
					*str++ = ' ';
 3f0fee4:	e1a03004 	mov	r3, r4
 3f0fee8:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0feec:	e1500003 	cmp	r0, r3
 3f0fef0:	e3a03020 	mov	r3, #32	; 0x20
 3f0fef4:	e4c73001 	strb	r3, [r7], #1
 3f0fef8:	bafffff9 	blt	3f0fee4 <vsprintf+0x398>
			for (i = 0; i < len; ++i)
 3f0fefc:	e3500000 	cmp	r0, #0	; 0x0
 3f0ff00:	da000004 	ble	3f0ff18 <vsprintf+0x3cc>
 3f0ff04:	e1a02000 	mov	r2, r0
				*str++ = *s++;
 3f0ff08:	e4d53001 	ldrb	r3, [r5], #1
 3f0ff0c:	e2522001 	subs	r2, r2, #1	; 0x1
 3f0ff10:	e4c73001 	strb	r3, [r7], #1
 3f0ff14:	1afffffb 	bne	3f0ff08 <vsprintf+0x3bc>
			while (len < field_width--)
 3f0ff18:	e1a03004 	mov	r3, r4
 3f0ff1c:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0ff20:	e1500003 	cmp	r0, r3
 3f0ff24:	aa00003a 	bge	3f10014 <vsprintf+0x4c8>
				*str++ = ' ';
 3f0ff28:	e1a03004 	mov	r3, r4
 3f0ff2c:	e2444001 	sub	r4, r4, #1	; 0x1
 3f0ff30:	e1500003 	cmp	r0, r3
 3f0ff34:	e3a03020 	mov	r3, #32	; 0x20
 3f0ff38:	e4c73001 	strb	r3, [r7], #1
 3f0ff3c:	bafffff9 	blt	3f0ff28 <vsprintf+0x3dc>
			continue;
 3f0ff40:	ea000033 	b	3f10014 <vsprintf+0x4c8>

		case 'p':
			if (field_width == -1) {
 3f0ff44:	e3740001 	cmn	r4, #1	; 0x1
				field_width = 2*sizeof(void *);
 3f0ff48:	03a04008 	moveq	r4, #8	; 0x8
				flags |= ZEROPAD;
 3f0ff4c:	03866001 	orreq	r6, r6, #1	; 0x1
			}
			str = number(str,
 3f0ff50:	e1a00007 	mov	r0, r7
 3f0ff54:	e58dc000 	str	r12, [r13]
 3f0ff58:	e3a02010 	mov	r2, #16	; 0x10
 3f0ff5c:	e49a1004 	ldr	r1, [r10], #4
				(unsigned long) va_arg(args, void *), 16,
				field_width, precision, flags);
			continue;
 3f0ff60:	ea000027 	b	3f10004 <vsprintf+0x4b8>


		case 'n':
			if (qualifier == 'l') {
 3f0ff64:	e351006c 	cmp	r1, #108	; 0x6c
				long * ip = va_arg(args, long *);
				*ip = (str - buf);
			} else {
				int * ip = va_arg(args, int *);
 3f0ff68:	e49a2004 	ldr	r2, [r10], #4
				*ip = (str - buf);
 3f0ff6c:	e0693007 	rsb	r3, r9, r7
 3f0ff70:	e5823000 	str	r3, [r2]
			}
			continue;
 3f0ff74:	ea000026 	b	3f10014 <vsprintf+0x4c8>

		case '%':
			*str++ = '%';
 3f0ff78:	e3a03025 	mov	r3, #37	; 0x25
 3f0ff7c:	e4c73001 	strb	r3, [r7], #1
			continue;
 3f0ff80:	ea000023 	b	3f10014 <vsprintf+0x4c8>

		/* integer number formats - set up the flags and "break" */
		case 'o':
			base = 8;
 3f0ff84:	e3a02008 	mov	r2, #8	; 0x8
			break;
 3f0ff88:	ea00000e 	b	3f0ffc8 <vsprintf+0x47c>

		case 'X':
			flags |= LARGE;
 3f0ff8c:	e3866040 	orr	r6, r6, #64	; 0x40
		case 'x':
			base = 16;
 3f0ff90:	e3a02010 	mov	r2, #16	; 0x10
			break;
 3f0ff94:	ea00000b 	b	3f0ffc8 <vsprintf+0x47c>

		case 'd':
		case 'i':
			flags |= SIGN;
 3f0ff98:	e3866002 	orr	r6, r6, #2	; 0x2
		case 'u':
			break;
 3f0ff9c:	ea000009 	b	3f0ffc8 <vsprintf+0x47c>

		default:
			*str++ = '%';
 3f0ffa0:	e3a03025 	mov	r3, #37	; 0x25
 3f0ffa4:	e4c73001 	strb	r3, [r7], #1
			if (*fmt)
 3f0ffa8:	e51b3028 	ldr	r3, [r11, -#40]
 3f0ffac:	e5d32000 	ldrb	r2, [r3]
 3f0ffb0:	e3520000 	cmp	r2, #0	; 0x0
				*str++ = *fmt;
 3f0ffb4:	14c72001 	strneb	r2, [r7], #1
 3f0ffb8:	1a000015 	bne	3f10014 <vsprintf+0x4c8>
			else
				--fmt;
 3f0ffbc:	e2433001 	sub	r3, r3, #1	; 0x1
 3f0ffc0:	e50b3028 	str	r3, [r11, -#40]
			continue;
 3f0ffc4:	ea000012 	b	3f10014 <vsprintf+0x4c8>
		}
		if (qualifier == 'l')
 3f0ffc8:	e351006c 	cmp	r1, #108	; 0x6c
 3f0ffcc:	0a000009 	beq	3f0fff8 <vsprintf+0x4ac>
			num = va_arg(args, unsigned long);
		else if (qualifier == 'h') {
 3f0ffd0:	e3510068 	cmp	r1, #104	; 0x68
 3f0ffd4:	1a000006 	bne	3f0fff4 <vsprintf+0x4a8>
			num = (unsigned short) va_arg(args, int);
 3f0ffd8:	e28aa004 	add	r10, r10, #4	; 0x4
			if (flags & SIGN)
 3f0ffdc:	e3160002 	tst	r6, #2	; 0x2
 3f0ffe0:	e15a10b4 	ldrh	r1, [r10, -#4]
				num = (short) num;
 3f0ffe4:	11a03801 	movne	r3, r1, lsl #16
 3f0ffe8:	11a01843 	movne	r1, r3, asr #16
		} else if (flags & SIGN)
 3f0ffec:	ea000002 	b	3f0fffc <vsprintf+0x4b0>
 3f0fff0:	03f1f658 	mvneqs	r15, #92274688	; 0x5800000
 3f0fff4:	e3160002 	tst	r6, #2	; 0x2
			num = va_arg(args, int);
		else
			num = va_arg(args, unsigned int);
 3f0fff8:	e49a1004 	ldr	r1, [r10], #4
		str = number(str, num, base, field_width, precision, flags);
 3f0fffc:	e1a00007 	mov	r0, r7
 3f10000:	e58dc000 	str	r12, [r13]
 3f10004:	e1a03004 	mov	r3, r4
 3f10008:	e58d6004 	str	r6, [r13, #4]
 3f1000c:	ebfffe1e 	bl	3f0f88c <number>
 3f10010:	e1a07000 	mov	r7, r0
 3f10014:	e51b3028 	ldr	r3, [r11, -#40]
 3f10018:	e2832001 	add	r2, r3, #1	; 0x1
 3f1001c:	e50b2028 	str	r2, [r11, -#40]
 3f10020:	e5d33001 	ldrb	r3, [r3, #1]
 3f10024:	e3530000 	cmp	r3, #0	; 0x0
 3f10028:	1afffed3 	bne	3f0fb7c <vsprintf+0x30>
	}
	*str = '\0';
	return str-buf;
 3f1002c:	e0690007 	rsb	r0, r9, r7
 3f10030:	e3a03000 	mov	r3, #0	; 0x0
 3f10034:	e5c73000 	strb	r3, [r7]
}
 3f10038:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f1003c <sprintf>:
 3f1003c:	e1a0c00d 	mov	r12, r13
 3f10040:	e92d000e 	stmdb	r13!, {r1, r2, r3}
 3f10044:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f10048:	e24cb010 	sub	r11, r12, #16	; 0x10

int sprintf(char * buf, const char *fmt, ...)
{
	va_list args;
	int i;

	va_start(args, fmt);
	i=vsprintf(buf,fmt,args);
 3f1004c:	e59b1004 	ldr	r1, [r11, #4]
 3f10050:	e28b2008 	add	r2, r11, #8	; 0x8
 3f10054:	ebfffebc 	bl	3f0fb4c <vsprintf>
	va_end(args);
	return i;
}
 3f10058:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1005c <panic>:
 3f1005c:	e1a0c00d 	mov	r12, r13
 3f10060:	e92d000f 	stmdb	r13!, {r0, r1, r2, r3}
 3f10064:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f10068:	e24cb014 	sub	r11, r12, #20	; 0x14

void panic(const char *fmt, ...)
{
	va_list	args;
	va_start(args, fmt);
	vprintf(fmt, args);
 3f1006c:	e59b0004 	ldr	r0, [r11, #4]
 3f10070:	e28b1008 	add	r1, r11, #8	; 0x8
 3f10074:	ebfff1ff 	bl	3f0c878 <vprintf>
	putc('\n');
 3f10078:	e3a0000a 	mov	r0, #10	; 0xa
 3f1007c:	ebfff1d6 	bl	3f0c7dc <putc>
	va_end(args);
#if defined (CONFIG_PANIC_HANG)
	hang();
#else
	udelay (100000);	/* allow messages to go out */
 3f10080:	e59f0018 	ldr	r0, [pc, #18]	; 3f100a0 <panic+0x44>
 3f10084:	ebffc1e3 	bl	3f00818 <udelay>
	do_reset (NULL, 0, 0, NULL);
 3f10088:	e3a00000 	mov	r0, #0	; 0x0
 3f1008c:	e1a01000 	mov	r1, r0
 3f10090:	e1a02000 	mov	r2, r0
 3f10094:	e1a03000 	mov	r3, r0
 3f10098:	eb00193d 	bl	3f16594 <do_reset>
 3f1009c:	ea000000 	b	3f100a4 <panic+0x48>
 3f100a0:	000186a0 	andeq	r8, r1, r0, lsr #13
#endif
}
 3f100a4:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f100a8 <inflateReset>:
 3f100a8:	e1a0c00d 	mov	r12, r13
 3f100ac:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f100b0:	e24cb004 	sub	r11, r12, #4	; 0x4
z_stream *z;
{
  uLong c;

  if (z == Z_NULL || z->state == Z_NULL)
 3f100b4:	e2501000 	subs	r1, r0, #0	; 0x0
 3f100b8:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f100bc:	0a000002 	beq	3f100cc <inflateReset+0x24>
 3f100c0:	e591201c 	ldr	r2, [r1, #28]
 3f100c4:	e3520000 	cmp	r2, #0	; 0x0
 3f100c8:	1a000001 	bne	3f100d4 <inflateReset+0x2c>
    return Z_STREAM_ERROR;
 3f100cc:	e3e00001 	mvn	r0, #1	; 0x1
 3f100d0:	ea00000d 	b	3f1010c <inflateReset+0x64>
  z->total_in = z->total_out = 0;
 3f100d4:	e3a04000 	mov	r4, #0	; 0x0
 3f100d8:	e5814014 	str	r4, [r1, #20]
 3f100dc:	e5814008 	str	r4, [r1, #8]
  z->msg = Z_NULL;
 3f100e0:	e5814018 	str	r4, [r1, #24]
  z->state->mode = z->state->nowrap ? BLOCKS : METHOD;
 3f100e4:	e592300c 	ldr	r3, [r2, #12]
 3f100e8:	e1530004 	cmp	r3, r4
 3f100ec:	13a03002 	movne	r3, #2	; 0x2
 3f100f0:	01a03004 	moveq	r3, r4
 3f100f4:	e5823000 	str	r3, [r2]
  inflate_blocks_reset(z->state->blocks, z, &c);
 3f100f8:	e591301c 	ldr	r3, [r1, #28]
 3f100fc:	e5930014 	ldr	r0, [r3, #20]
 3f10100:	e24b2014 	sub	r2, r11, #20	; 0x14
 3f10104:	eb0001a7 	bl	3f107a8 <inflate_blocks_reset>
  Trace((stderr, "inflate: reset\n"));
  return Z_OK;
 3f10108:	e1a00004 	mov	r0, r4
}
 3f1010c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f10110 <inflateEnd>:
 3f10110:	e1a0c00d 	mov	r12, r13
 3f10114:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f10118:	e24cb004 	sub	r11, r12, #4	; 0x4


int inflateEnd(z)
z_stream *z;
{
  uLong c;

  if (z == Z_NULL || z->state == Z_NULL || z->zfree == Z_NULL)
 3f1011c:	e2504000 	subs	r4, r0, #0	; 0x0
 3f10120:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f10124:	0a000005 	beq	3f10140 <inflateEnd+0x30>
 3f10128:	e594001c 	ldr	r0, [r4, #28]
 3f1012c:	e3500000 	cmp	r0, #0	; 0x0
 3f10130:	0a000002 	beq	3f10140 <inflateEnd+0x30>
 3f10134:	e5943024 	ldr	r3, [r4, #36]
 3f10138:	e3530000 	cmp	r3, #0	; 0x0
 3f1013c:	1a000001 	bne	3f10148 <inflateEnd+0x38>
    return Z_STREAM_ERROR;
 3f10140:	e3e00001 	mvn	r0, #1	; 0x1
 3f10144:	ea00000d 	b	3f10180 <inflateEnd+0x70>
  if (z->state->blocks != Z_NULL)
 3f10148:	e5900014 	ldr	r0, [r0, #20]
 3f1014c:	e3500000 	cmp	r0, #0	; 0x0
 3f10150:	0a000002 	beq	3f10160 <inflateEnd+0x50>
    inflate_blocks_free(z->state->blocks, z, &c);
 3f10154:	e1a01004 	mov	r1, r4
 3f10158:	e24b2014 	sub	r2, r11, #20	; 0x14
 3f1015c:	eb0005a9 	bl	3f11808 <inflate_blocks_free>
  ZFREE(z, z->state, sizeof(struct internal_state));
 3f10160:	e5940028 	ldr	r0, [r4, #40]
 3f10164:	e594101c 	ldr	r1, [r4, #28]
 3f10168:	e3a02018 	mov	r2, #24	; 0x18
 3f1016c:	e1a0e00f 	mov	r14, r15
 3f10170:	e594f024 	ldr	r15, [r4, #36]
  z->state = Z_NULL;
 3f10174:	e3a03000 	mov	r3, #0	; 0x0
  Trace((stderr, "inflate: end\n"));
  return Z_OK;
 3f10178:	e1a00003 	mov	r0, r3
 3f1017c:	e584301c 	str	r3, [r4, #28]
}
 3f10180:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f10184 <inflateInit2>:
 3f10184:	e1a0c00d 	mov	r12, r13
 3f10188:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f1018c:	e24cb004 	sub	r11, r12, #4	; 0x4


int inflateInit2(z, w)
z_stream *z;
int w;
{
 3f10190:	e1a05001 	mov	r5, r1
  /* initialize state */
  if (z == Z_NULL)
 3f10194:	e2504000 	subs	r4, r0, #0	; 0x0
    return Z_STREAM_ERROR;
 3f10198:	03e00001 	mvneq	r0, #1	; 0x1
 3f1019c:	091ba870 	ldmeqdb	r11, {r4, r5, r6, r11, r13, r15}
/*  if (z->zalloc == Z_NULL) z->zalloc = zcalloc; */
/*  if (z->zfree == Z_NULL) z->zfree = zcfree; */
  if ((z->state = (struct internal_state FAR *)
 3f101a0:	e3a01001 	mov	r1, #1	; 0x1
 3f101a4:	e5940028 	ldr	r0, [r4, #40]
 3f101a8:	e3a02018 	mov	r2, #24	; 0x18
 3f101ac:	e1a0e00f 	mov	r14, r15
 3f101b0:	e594f020 	ldr	r15, [r4, #32]
 3f101b4:	e3500000 	cmp	r0, #0	; 0x0
 3f101b8:	e584001c 	str	r0, [r4, #28]
       ZALLOC(z,1,sizeof(struct internal_state))) == Z_NULL)
    return Z_MEM_ERROR;
 3f101bc:	03e00003 	mvneq	r0, #3	; 0x3
 3f101c0:	091ba870 	ldmeqdb	r11, {r4, r5, r6, r11, r13, r15}
  z->state->blocks = Z_NULL;
 3f101c4:	e3a06000 	mov	r6, #0	; 0x0
 3f101c8:	e5806014 	str	r6, [r0, #20]

  /* handle undocumented nowrap option (no zlib header or check) */
  z->state->nowrap = 0;
 3f101cc:	e594301c 	ldr	r3, [r4, #28]
  if (w < 0)
 3f101d0:	e1550006 	cmp	r5, r6
 3f101d4:	e583600c 	str	r6, [r3, #12]
  {
    w = - w;
 3f101d8:	b2655000 	rsblt	r5, r5, #0	; 0x0
    z->state->nowrap = 1;
 3f101dc:	b594201c 	ldrlt	r2, [r4, #28]
 3f101e0:	b3a03001 	movlt	r3, #1	; 0x1
 3f101e4:	b582300c 	strlt	r3, [r2, #12]
  }

  /* set window size */
  if (w < 8 || w > 15)
 3f101e8:	e2453008 	sub	r3, r5, #8	; 0x8
 3f101ec:	e3530007 	cmp	r3, #7	; 0x7
 3f101f0:	9a000003 	bls	3f10204 <inflateInit2+0x80>
  {
    inflateEnd(z);
 3f101f4:	e1a00004 	mov	r0, r4
 3f101f8:	ebffffc4 	bl	3f10110 <inflateEnd>
    return Z_STREAM_ERROR;
 3f101fc:	e3e00001 	mvn	r0, #1	; 0x1
 3f10200:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
  }
  z->state->wbits = (uInt)w;
 3f10204:	e594301c 	ldr	r3, [r4, #28]
 3f10208:	e5835010 	str	r5, [r3, #16]

  /* create inflate_blocks state */
  if ((z->state->blocks =
 3f1020c:	e1a00004 	mov	r0, r4
 3f10210:	e594301c 	ldr	r3, [r4, #28]
 3f10214:	e3a02001 	mov	r2, #1	; 0x1
 3f10218:	e593300c 	ldr	r3, [r3, #12]
 3f1021c:	e1a02512 	mov	r2, r2, lsl r5
 3f10220:	e59f1038 	ldr	r1, [pc, #38]	; 3f10260 <inflateInit2+0xdc>
 3f10224:	e3530000 	cmp	r3, #0	; 0x0
 3f10228:	13a01000 	movne	r1, #0	; 0x0
 3f1022c:	eb000194 	bl	3f10884 <inflate_blocks_new>
 3f10230:	e594301c 	ldr	r3, [r4, #28]
 3f10234:	e3500000 	cmp	r0, #0	; 0x0
 3f10238:	e5830014 	str	r0, [r3, #20]
 3f1023c:	0a000003 	beq	3f10250 <inflateInit2+0xcc>
       inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, 1 << w))
      == Z_NULL)
  {
    inflateEnd(z);
    return Z_MEM_ERROR;
  }
  Trace((stderr, "inflate: allocated\n"));

  /* reset state */
  inflateReset(z);
 3f10240:	e1a00004 	mov	r0, r4
 3f10244:	ebffff97 	bl	3f100a8 <inflateReset>
  return Z_OK;
 3f10248:	e1a00006 	mov	r0, r6
 3f1024c:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f10250:	e1a00004 	mov	r0, r4
 3f10254:	ebffffad 	bl	3f10110 <inflateEnd>
 3f10258:	e3e00003 	mvn	r0, #3	; 0x3
 3f1025c:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f10260:	03f13264 	mvneqs	r3, #1073741830	; 0x40000006

03f10264 <inflateInit>:
 3f10264:	e1a0c00d 	mov	r12, r13
 3f10268:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f1026c:	e24cb004 	sub	r11, r12, #4	; 0x4
}


int inflateInit(z)
z_stream *z;
{
  return inflateInit2(z, DEF_WBITS);
 3f10270:	e3a0100f 	mov	r1, #15	; 0xf
 3f10274:	ebffffc2 	bl	3f10184 <inflateInit2>
 3f10278:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1027c <inflate>:
 3f1027c:	e1a0c00d 	mov	r12, r13
 3f10280:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f10284:	e24cb004 	sub	r11, r12, #4	; 0x4
}


#define NEEDBYTE {if(z->avail_in==0)goto empty;r=Z_OK;}
#define NEXTBYTE (z->avail_in--,z->total_in++,*z->next_in++)

int inflate(z, f)
z_stream *z;
int f;
{
 3f10288:	e1a06001 	mov	r6, r1
  int r;
  uInt b;

  if (z == Z_NULL || z->next_in == Z_NULL)
 3f1028c:	e2504000 	subs	r4, r0, #0	; 0x0
 3f10290:	0a000002 	beq	3f102a0 <inflate+0x24>
 3f10294:	e5943000 	ldr	r3, [r4]
 3f10298:	e3530000 	cmp	r3, #0	; 0x0
 3f1029c:	1a000001 	bne	3f102a8 <inflate+0x2c>
    return Z_STREAM_ERROR;
 3f102a0:	e3e00001 	mvn	r0, #1	; 0x1
 3f102a4:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
  r = Z_BUF_ERROR;
 3f102a8:	e3e05004 	mvn	r5, #4	; 0x4
  while (1) switch (z->state->mode)
 3f102ac:	e594101c 	ldr	r1, [r4, #28]
 3f102b0:	e5913000 	ldr	r3, [r1]
 3f102b4:	e3530008 	cmp	r3, #8	; 0x8
 3f102b8:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f102bc:	ea0000ce 	b	3f105fc <inflate+0x380>
 3f102c0:	03f102e4 	mvneqs	r0, #1073741838	; 0x4000000e
 3f102c4:	03f10360 	mvneqs	r0, #-2147483647	; 0x80000001
 3f102c8:	03f103e8 	mvneqs	r0, #-1610612733	; 0xa0000003
 3f102cc:	03f10494 	mvneqs	r0, #-1811939328	; 0x94000000
 3f102d0:	03f104dc 	mvneqs	r0, #-603979776	; 0xdc000000
 3f102d4:	03f10528 	mvneqs	r0, #167772160	; 0xa000000
 3f102d8:	03f10574 	mvneqs	r0, #486539264	; 0x1d000000
 3f102dc:	03f105ec 	mvneqs	r0, #989855744	; 0x3b000000
 3f102e0:	03f105f4 	mvneqs	r0, #1023410176	; 0x3d000000
  {
    case METHOD:
      NEEDBYTE
 3f102e4:	e5943004 	ldr	r3, [r4, #4]
 3f102e8:	e3530000 	cmp	r3, #0	; 0x0
 3f102ec:	0a0000c3 	beq	3f10600 <inflate+0x384>
      if (((z->state->sub.method = NEXTBYTE) & 0xf) != DEFLATED)
 3f102f0:	e2433001 	sub	r3, r3, #1	; 0x1
 3f102f4:	e5843004 	str	r3, [r4, #4]
 3f102f8:	e5943008 	ldr	r3, [r4, #8]
 3f102fc:	e5942000 	ldr	r2, [r4]
 3f10300:	e2833001 	add	r3, r3, #1	; 0x1
 3f10304:	e5843008 	str	r3, [r4, #8]
 3f10308:	e4d23001 	ldrb	r3, [r2], #1
 3f1030c:	e3a05000 	mov	r5, #0	; 0x0
 3f10310:	e203000f 	and	r0, r3, #15	; 0xf
 3f10314:	e5813004 	str	r3, [r1, #4]
 3f10318:	e3500008 	cmp	r0, #8	; 0x8
 3f1031c:	e5842000 	str	r2, [r4]
      {
	z->state->mode = BAD;
 3f10320:	1594201c 	ldrne	r2, [r4, #28]
 3f10324:	13a03008 	movne	r3, #8	; 0x8
 3f10328:	15823000 	strne	r3, [r2]
	z->msg = "unknown compression method";
 3f1032c:	159f3304 	ldrne	r3, [pc, #304]	; 3f10638 <inflate+0x3bc>
	z->state->sub.marker = 5;       /* can't try inflateSync */
	break;
 3f10330:	1a0000a6 	bne	3f105d0 <inflate+0x354>
      }
      if ((z->state->sub.method >> 4) + 8 > z->state->wbits)
 3f10334:	e594101c 	ldr	r1, [r4, #28]
 3f10338:	e5913004 	ldr	r3, [r1, #4]
 3f1033c:	e5912010 	ldr	r2, [r1, #16]
 3f10340:	e1a03223 	mov	r3, r3, lsr #4
 3f10344:	e2833008 	add	r3, r3, #8	; 0x8
 3f10348:	e1530002 	cmp	r3, r2
      {
	z->state->mode = BAD;
	z->msg = "invalid window size";
 3f1034c:	859f32e8 	ldrhi	r3, [pc, #2e8]	; 3f1063c <inflate+0x3c0>
 3f10350:	85810000 	strhi	r0, [r1]
	z->state->sub.marker = 5;       /* can't try inflateSync */
	break;
 3f10354:	8a00009d 	bhi	3f105d0 <inflate+0x354>
      }
      z->state->mode = FLAG;
 3f10358:	e3a03001 	mov	r3, #1	; 0x1
 3f1035c:	e5813000 	str	r3, [r1]
    case FLAG:
      NEEDBYTE
 3f10360:	e5943004 	ldr	r3, [r4, #4]
 3f10364:	e3530000 	cmp	r3, #0	; 0x0
 3f10368:	0a0000a4 	beq	3f10600 <inflate+0x384>
      if ((b = NEXTBYTE) & 0x20)
 3f1036c:	e2433001 	sub	r3, r3, #1	; 0x1
 3f10370:	e5843004 	str	r3, [r4, #4]
 3f10374:	e5943008 	ldr	r3, [r4, #8]
 3f10378:	e5942000 	ldr	r2, [r4]
 3f1037c:	e2833001 	add	r3, r3, #1	; 0x1
 3f10380:	e5843008 	str	r3, [r4, #8]
 3f10384:	e4d2c001 	ldrb	r12, [r2], #1
 3f10388:	e3a05000 	mov	r5, #0	; 0x0
 3f1038c:	e31c0020 	tst	r12, #32	; 0x20
 3f10390:	e5842000 	str	r2, [r4]
      {
	z->state->mode = BAD;
 3f10394:	1594201c 	ldrne	r2, [r4, #28]
 3f10398:	13a03008 	movne	r3, #8	; 0x8
 3f1039c:	15823000 	strne	r3, [r2]
	z->msg = "invalid reserved bit";
 3f103a0:	159f3298 	ldrne	r3, [pc, #298]	; 3f10640 <inflate+0x3c4>
	z->state->sub.marker = 5;       /* can't try inflateSync */
	break;
 3f103a4:	1a000089 	bne	3f105d0 <inflate+0x354>
      }
      if (((z->state->sub.method << 8) + b) % 31)
 3f103a8:	e594001c 	ldr	r0, [r4, #28]
 3f103ac:	e5901004 	ldr	r1, [r0, #4]
 3f103b0:	e59f328c 	ldr	r3, [pc, #28c]	; 3f10644 <inflate+0x3c8>
 3f103b4:	e18c1401 	orr	r1, r12, r1, lsl #8
 3f103b8:	e0832391 	umull	r2, r3, r1, r3
 3f103bc:	e0632001 	rsb	r2, r3, r1
 3f103c0:	e08330a2 	add	r3, r3, r2, lsr #1
 3f103c4:	e1a03223 	mov	r3, r3, lsr #4
 3f103c8:	e0633283 	rsb	r3, r3, r3, lsl #5
 3f103cc:	e1510003 	cmp	r1, r3
      {
	z->state->mode = BAD;
 3f103d0:	13a03008 	movne	r3, #8	; 0x8
 3f103d4:	15803000 	strne	r3, [r0]
	z->msg = "incorrect header check";
 3f103d8:	159f3268 	ldrne	r3, [pc, #268]	; 3f10648 <inflate+0x3cc>
	z->state->sub.marker = 5;       /* can't try inflateSync */
	break;
 3f103dc:	1a00007b 	bne	3f105d0 <inflate+0x354>
      }
      Trace((stderr, "inflate: zlib header ok\n"));
      z->state->mode = BLOCKS;
 3f103e0:	e3a03002 	mov	r3, #2	; 0x2
 3f103e4:	e5803000 	str	r3, [r0]
    case BLOCKS:
      r = inflate_blocks(z->state->blocks, z, r);
 3f103e8:	e594301c 	ldr	r3, [r4, #28]
 3f103ec:	e1a01004 	mov	r1, r4
 3f103f0:	e5930014 	ldr	r0, [r3, #20]
 3f103f4:	e1a02005 	mov	r2, r5
 3f103f8:	eb00014a 	bl	3f10928 <inflate_blocks>
 3f103fc:	e1a05000 	mov	r5, r0
      if (f == Z_PACKET_FLUSH && z->avail_in == 0 && z->avail_out != 0)
 3f10400:	e3560005 	cmp	r6, #5	; 0x5
 3f10404:	1a000009 	bne	3f10430 <inflate+0x1b4>
 3f10408:	e5943004 	ldr	r3, [r4, #4]
 3f1040c:	e3530000 	cmp	r3, #0	; 0x0
 3f10410:	1a000006 	bne	3f10430 <inflate+0x1b4>
 3f10414:	e5943010 	ldr	r3, [r4, #16]
 3f10418:	e3530000 	cmp	r3, #0	; 0x0
 3f1041c:	0a000003 	beq	3f10430 <inflate+0x1b4>
	  r = inflate_packet_flush(z->state->blocks);
 3f10420:	e594301c 	ldr	r3, [r4, #28]
 3f10424:	e5930014 	ldr	r0, [r3, #20]
 3f10428:	eb000559 	bl	3f11994 <inflate_packet_flush>
 3f1042c:	e1a05000 	mov	r5, r0
      if (r == Z_DATA_ERROR)
 3f10430:	e3750003 	cmn	r5, #3	; 0x3
 3f10434:	1a000006 	bne	3f10454 <inflate+0x1d8>
      {
	z->state->mode = BAD;
 3f10438:	e594201c 	ldr	r2, [r4, #28]
 3f1043c:	e3a03008 	mov	r3, #8	; 0x8
 3f10440:	e5823000 	str	r3, [r2]
	z->state->sub.marker = 0;       /* can try inflateSync */
 3f10444:	e594201c 	ldr	r2, [r4, #28]
 3f10448:	e2433008 	sub	r3, r3, #8	; 0x8
 3f1044c:	e5823004 	str	r3, [r2, #4]
	break;
 3f10450:	eaffff95 	b	3f102ac <inflate+0x30>
      }
      if (r != Z_STREAM_END)
 3f10454:	e3550001 	cmp	r5, #1	; 0x1
 3f10458:	1a000072 	bne	3f10628 <inflate+0x3ac>
	return r;
      r = Z_OK;
      inflate_blocks_reset(z->state->blocks, z, &z->state->sub.check.was);
 3f1045c:	e594201c 	ldr	r2, [r4, #28]
 3f10460:	e1a01004 	mov	r1, r4
 3f10464:	e5920014 	ldr	r0, [r2, #20]
 3f10468:	e2822004 	add	r2, r2, #4	; 0x4
 3f1046c:	eb0000cd 	bl	3f107a8 <inflate_blocks_reset>
      if (z->state->nowrap)
 3f10470:	e594201c 	ldr	r2, [r4, #28]
 3f10474:	e592300c 	ldr	r3, [r2, #12]
 3f10478:	e3a05000 	mov	r5, #0	; 0x0
 3f1047c:	e1530005 	cmp	r3, r5
      {
	z->state->mode = DONE;
 3f10480:	13a03007 	movne	r3, #7	; 0x7
 3f10484:	15823000 	strne	r3, [r2]
	break;
 3f10488:	1affff87 	bne	3f102ac <inflate+0x30>
      }
      z->state->mode = CHECK4;
 3f1048c:	e3a03003 	mov	r3, #3	; 0x3
 3f10490:	e5823000 	str	r3, [r2]
    case CHECK4:
      NEEDBYTE
 3f10494:	e5943004 	ldr	r3, [r4, #4]
 3f10498:	e3530000 	cmp	r3, #0	; 0x0
 3f1049c:	0a000057 	beq	3f10600 <inflate+0x384>
      z->state->sub.check.need = (uLong)NEXTBYTE << 24;
 3f104a0:	e2433001 	sub	r3, r3, #1	; 0x1
 3f104a4:	e5843004 	str	r3, [r4, #4]
 3f104a8:	e5943008 	ldr	r3, [r4, #8]
 3f104ac:	e5941000 	ldr	r1, [r4]
 3f104b0:	e2833001 	add	r3, r3, #1	; 0x1
 3f104b4:	e5843008 	str	r3, [r4, #8]
 3f104b8:	e4d13001 	ldrb	r3, [r1], #1
 3f104bc:	e594201c 	ldr	r2, [r4, #28]
 3f104c0:	e1a03c03 	mov	r3, r3, lsl #24
 3f104c4:	e5823008 	str	r3, [r2, #8]
 3f104c8:	e5841000 	str	r1, [r4]
 3f104cc:	e3a05000 	mov	r5, #0	; 0x0
      z->state->mode = CHECK3;
 3f104d0:	e594201c 	ldr	r2, [r4, #28]
 3f104d4:	e3a03004 	mov	r3, #4	; 0x4
 3f104d8:	e5823000 	str	r3, [r2]
    case CHECK3:
      NEEDBYTE
 3f104dc:	e5943004 	ldr	r3, [r4, #4]
 3f104e0:	e3530000 	cmp	r3, #0	; 0x0
 3f104e4:	0a000045 	beq	3f10600 <inflate+0x384>
      z->state->sub.check.need += (uLong)NEXTBYTE << 16;
 3f104e8:	e2433001 	sub	r3, r3, #1	; 0x1
 3f104ec:	e5843004 	str	r3, [r4, #4]
 3f104f0:	e5943008 	ldr	r3, [r4, #8]
 3f104f4:	e5940000 	ldr	r0, [r4]
 3f104f8:	e594101c 	ldr	r1, [r4, #28]
 3f104fc:	e2833001 	add	r3, r3, #1	; 0x1
 3f10500:	e5843008 	str	r3, [r4, #8]
 3f10504:	e4d02001 	ldrb	r2, [r0], #1
 3f10508:	e5913008 	ldr	r3, [r1, #8]
 3f1050c:	e0833802 	add	r3, r3, r2, lsl #16
 3f10510:	e5813008 	str	r3, [r1, #8]
 3f10514:	e5840000 	str	r0, [r4]
 3f10518:	e3a05000 	mov	r5, #0	; 0x0
      z->state->mode = CHECK2;
 3f1051c:	e594201c 	ldr	r2, [r4, #28]
 3f10520:	e3a03005 	mov	r3, #5	; 0x5
 3f10524:	e5823000 	str	r3, [r2]
    case CHECK2:
      NEEDBYTE
 3f10528:	e5943004 	ldr	r3, [r4, #4]
 3f1052c:	e3530000 	cmp	r3, #0	; 0x0
 3f10530:	0a000032 	beq	3f10600 <inflate+0x384>
      z->state->sub.check.need += (uLong)NEXTBYTE << 8;
 3f10534:	e2433001 	sub	r3, r3, #1	; 0x1
 3f10538:	e5843004 	str	r3, [r4, #4]
 3f1053c:	e5943008 	ldr	r3, [r4, #8]
 3f10540:	e5940000 	ldr	r0, [r4]
 3f10544:	e594101c 	ldr	r1, [r4, #28]
 3f10548:	e2833001 	add	r3, r3, #1	; 0x1
 3f1054c:	e5843008 	str	r3, [r4, #8]
 3f10550:	e4d02001 	ldrb	r2, [r0], #1
 3f10554:	e5913008 	ldr	r3, [r1, #8]
 3f10558:	e0833402 	add	r3, r3, r2, lsl #8
 3f1055c:	e5813008 	str	r3, [r1, #8]
 3f10560:	e5840000 	str	r0, [r4]
 3f10564:	e3a05000 	mov	r5, #0	; 0x0
      z->state->mode = CHECK1;
 3f10568:	e594201c 	ldr	r2, [r4, #28]
 3f1056c:	e3a03006 	mov	r3, #6	; 0x6
 3f10570:	e5823000 	str	r3, [r2]
    case CHECK1:
      NEEDBYTE
 3f10574:	e5943004 	ldr	r3, [r4, #4]
 3f10578:	e3530000 	cmp	r3, #0	; 0x0
 3f1057c:	0a00001f 	beq	3f10600 <inflate+0x384>
      z->state->sub.check.need += (uLong)NEXTBYTE;
 3f10580:	e2433001 	sub	r3, r3, #1	; 0x1
 3f10584:	e5843004 	str	r3, [r4, #4]
 3f10588:	e5943008 	ldr	r3, [r4, #8]
 3f1058c:	e5940000 	ldr	r0, [r4]
 3f10590:	e594101c 	ldr	r1, [r4, #28]
 3f10594:	e2833001 	add	r3, r3, #1	; 0x1
 3f10598:	e5843008 	str	r3, [r4, #8]
 3f1059c:	e4d02001 	ldrb	r2, [r0], #1
 3f105a0:	e5913008 	ldr	r3, [r1, #8]
 3f105a4:	e0833002 	add	r3, r3, r2
 3f105a8:	e5813008 	str	r3, [r1, #8]
 3f105ac:	e5840000 	str	r0, [r4]

      if (z->state->sub.check.was != z->state->sub.check.need)
 3f105b0:	e594101c 	ldr	r1, [r4, #28]
 3f105b4:	e991000c 	ldmib	r1, {r2, r3}
 3f105b8:	e3a05000 	mov	r5, #0	; 0x0
 3f105bc:	e1520003 	cmp	r2, r3
 3f105c0:	0a000007 	beq	3f105e4 <inflate+0x368>
      {
	z->state->mode = BAD;
 3f105c4:	e3a03008 	mov	r3, #8	; 0x8
 3f105c8:	e5813000 	str	r3, [r1]
	z->msg = "incorrect data check";
 3f105cc:	e59f3078 	ldr	r3, [pc, #78]	; 3f1064c <inflate+0x3d0>
 3f105d0:	e5843018 	str	r3, [r4, #24]
	z->state->sub.marker = 5;       /* can't try inflateSync */
 3f105d4:	e594201c 	ldr	r2, [r4, #28]
 3f105d8:	e3a03005 	mov	r3, #5	; 0x5
 3f105dc:	e5823004 	str	r3, [r2, #4]
	break;
 3f105e0:	eaffff31 	b	3f102ac <inflate+0x30>
      }
      Trace((stderr, "inflate: zlib check ok\n"));
      z->state->mode = DONE;
 3f105e4:	e3a03007 	mov	r3, #7	; 0x7
 3f105e8:	e5813000 	str	r3, [r1]
    case DONE:
      return Z_STREAM_END;
 3f105ec:	e3a00001 	mov	r0, #1	; 0x1
 3f105f0:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
    case BAD:
      return Z_DATA_ERROR;
 3f105f4:	e3e00002 	mvn	r0, #2	; 0x2
 3f105f8:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
    default:
      return Z_STREAM_ERROR;
 3f105fc:	eaffff27 	b	3f102a0 <inflate+0x24>
  }

 empty:
  if (f != Z_PACKET_FLUSH)
 3f10600:	e3560005 	cmp	r6, #5	; 0x5
 3f10604:	1a000009 	bne	3f10630 <inflate+0x3b4>
    return r;
  z->state->mode = BAD;
 3f10608:	e594201c 	ldr	r2, [r4, #28]
 3f1060c:	e3a03008 	mov	r3, #8	; 0x8
 3f10610:	e5823000 	str	r3, [r2]
  z->state->sub.marker = 0;       /* can try inflateSync */
  return Z_DATA_ERROR;
 3f10614:	e3e00002 	mvn	r0, #2	; 0x2
 3f10618:	e594201c 	ldr	r2, [r4, #28]
 3f1061c:	e2433008 	sub	r3, r3, #8	; 0x8
 3f10620:	e5823004 	str	r3, [r2, #4]
 3f10624:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f10628:	e1a00005 	mov	r0, r5
 3f1062c:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f10630:	e1a00005 	mov	r0, r5
}
 3f10634:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f10638:	03f1f660 	mvneqs	r15, #100663296	; 0x6000000
 3f1063c:	03f1f67c 	mvneqs	r15, #130023424	; 0x7c00000
 3f10640:	03f1f690 	mvneqs	r15, #150994944	; 0x9000000
 3f10644:	08421085 	stmeqda	r2, {r0, r2, r7, r12}^
 3f10648:	03f1f6a8 	mvneqs	r15, #176160768	; 0xa800000
 3f1064c:	03f1f6c0 	mvneqs	r15, #201326592	; 0xc000000

03f10650 <inflateIncomp>:
 3f10650:	e1a0c00d 	mov	r12, r13
 3f10654:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

/*
 * This subroutine adds the data at next_in/avail_in to the output history
 * without performing any output.  The output buffer must be "caught up";
 * i.e. no pending output (hence s->read equals s->write), and the state must
 * be BLOCKS (i.e. we should be willing to see the start of a series of
 * BLOCKS).  On exit, the output will also be caught up, and the checksum
 * will have been updated if need be.
 */

int inflateIncomp(z)
z_stream *z;
{
 3f10658:	e1a01000 	mov	r1, r0
    if (z->state->mode != BLOCKS)
 3f1065c:	e591201c 	ldr	r2, [r1, #28]
 3f10660:	e5923000 	ldr	r3, [r2]
 3f10664:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f10668:	e3530002 	cmp	r3, #2	; 0x2
 3f1066c:	1a000002 	bne	3f1067c <inflateIncomp+0x2c>
	return Z_DATA_ERROR;
    return inflate_addhistory(z->state->blocks, z);
 3f10670:	e5920014 	ldr	r0, [r2, #20]
 3f10674:	eb000477 	bl	3f11858 <inflate_addhistory>
 3f10678:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f1067c:	e3e00002 	mvn	r0, #2	; 0x2
 3f10680:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f10684 <inflateSync>:
 3f10684:	e1a0c00d 	mov	r12, r13
 3f10688:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f1068c:	e24cb004 	sub	r11, r12, #4	; 0x4
}


int inflateSync(z)
z_stream *z;
{
  uInt n;       /* number of bytes to look at */
  Bytef *p;     /* pointer to bytes */
  uInt m;       /* number of marker bytes found in a row */
  uLong r, w;   /* temporaries to save total_in and total_out */

  /* set up */
  if (z == Z_NULL || z->state == Z_NULL)
 3f10690:	e2506000 	subs	r6, r0, #0	; 0x0
 3f10694:	0a000002 	beq	3f106a4 <inflateSync+0x20>
 3f10698:	e596201c 	ldr	r2, [r6, #28]
 3f1069c:	e3520000 	cmp	r2, #0	; 0x0
 3f106a0:	1a000001 	bne	3f106ac <inflateSync+0x28>
    return Z_STREAM_ERROR;
 3f106a4:	e3e00001 	mvn	r0, #1	; 0x1
 3f106a8:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
  if (z->state->mode != BAD)
 3f106ac:	e5923000 	ldr	r3, [r2]
 3f106b0:	e3530008 	cmp	r3, #8	; 0x8
  {
    z->state->mode = BAD;
 3f106b4:	13a03008 	movne	r3, #8	; 0x8
 3f106b8:	15823000 	strne	r3, [r2]
    z->state->sub.marker = 0;
 3f106bc:	1596201c 	ldrne	r2, [r6, #28]
 3f106c0:	12433008 	subne	r3, r3, #8	; 0x8
 3f106c4:	15823004 	strne	r3, [r2, #4]
  }
  if ((n = z->avail_in) == 0)
 3f106c8:	e596c004 	ldr	r12, [r6, #4]
 3f106cc:	e35c0000 	cmp	r12, #0	; 0x0
    return Z_BUF_ERROR;
 3f106d0:	03e00004 	mvneq	r0, #4	; 0x4
 3f106d4:	091ba870 	ldmeqdb	r11, {r4, r5, r6, r11, r13, r15}
  p = z->next_in;
  m = z->state->sub.marker;
 3f106d8:	e596301c 	ldr	r3, [r6, #28]
 3f106dc:	e5960000 	ldr	r0, [r6]
 3f106e0:	e5931004 	ldr	r1, [r3, #4]
 3f106e4:	e1a0e000 	mov	r14, r0

  /* search */
  while (n && m < 4)
 3f106e8:	e3510003 	cmp	r1, #3	; 0x3
 3f106ec:	8a000016 	bhi	3f1074c <inflateSync+0xc8>
  {
    if (*p == (Byte)(m < 2 ? 0 : 0xff))
 3f106f0:	e3510001 	cmp	r1, #1	; 0x1
 3f106f4:	e5d03000 	ldrb	r3, [r0]
 3f106f8:	9a000002 	bls	3f10708 <inflateSync+0x84>
 3f106fc:	e35300ff 	cmp	r3, #255	; 0xff
 3f10700:	0a000002 	beq	3f10710 <inflateSync+0x8c>
 3f10704:	ea000003 	b	3f10718 <inflateSync+0x94>
 3f10708:	e3530000 	cmp	r3, #0	; 0x0
 3f1070c:	1a000001 	bne	3f10718 <inflateSync+0x94>
      m++;
 3f10710:	e2811001 	add	r1, r1, #1	; 0x1
 3f10714:	ea000003 	b	3f10728 <inflateSync+0xa4>
    else if (*p)
 3f10718:	e5d03000 	ldrb	r3, [r0]
 3f1071c:	e3530000 	cmp	r3, #0	; 0x0
      m = 0;
 3f10720:	13a01000 	movne	r1, #0	; 0x0
    else
      m = 4 - m;
 3f10724:	02611004 	rsbeq	r1, r1, #4	; 0x4
    p++, n--;
 3f10728:	e2800001 	add	r0, r0, #1	; 0x1
  }
 3f1072c:	e25cc001 	subs	r12, r12, #1	; 0x1
 3f10730:	03a02000 	moveq	r2, #0	; 0x0
 3f10734:	13a02001 	movne	r2, #1	; 0x1
 3f10738:	e3510003 	cmp	r1, #3	; 0x3
 3f1073c:	83a03000 	movhi	r3, #0	; 0x0
 3f10740:	93a03001 	movls	r3, #1	; 0x1
 3f10744:	e1120003 	tst	r2, r3
 3f10748:	1affffe8 	bne	3f106f0 <inflateSync+0x6c>

  /* restore */
  z->total_in += p - z->next_in;
  z->next_in = p;
 3f1074c:	e5860000 	str	r0, [r6]
 3f10750:	e5963008 	ldr	r3, [r6, #8]
 3f10754:	e06e2000 	rsb	r2, r14, r0
  z->avail_in = n;
 3f10758:	e586c004 	str	r12, [r6, #4]
 3f1075c:	e0833002 	add	r3, r3, r2
 3f10760:	e5863008 	str	r3, [r6, #8]
  z->state->sub.marker = m;
 3f10764:	e596301c 	ldr	r3, [r6, #28]

  /* return no joy or set up to restart on a new block */
  if (m != 4)
 3f10768:	e3510004 	cmp	r1, #4	; 0x4
 3f1076c:	e5831004 	str	r1, [r3, #4]
 3f10770:	1a00000a 	bne	3f107a0 <inflateSync+0x11c>
    return Z_DATA_ERROR;
  r = z->total_in;  w = z->total_out;
 3f10774:	e5965008 	ldr	r5, [r6, #8]
  inflateReset(z);
 3f10778:	e1a00006 	mov	r0, r6
 3f1077c:	e5964014 	ldr	r4, [r6, #20]
 3f10780:	ebfffe48 	bl	3f100a8 <inflateReset>
  z->total_in = r;  z->total_out = w;
  z->state->mode = BLOCKS;
 3f10784:	e596201c 	ldr	r2, [r6, #28]
 3f10788:	e5865008 	str	r5, [r6, #8]
  return Z_OK;
 3f1078c:	e3a00000 	mov	r0, #0	; 0x0
 3f10790:	e5864014 	str	r4, [r6, #20]
 3f10794:	e3a03002 	mov	r3, #2	; 0x2
 3f10798:	e5823000 	str	r3, [r2]
 3f1079c:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f107a0:	e3e00002 	mvn	r0, #2	; 0x2
}
 3f107a4:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f107a8 <inflate_blocks_reset>:
 3f107a8:	e1a0c00d 	mov	r12, r13
 3f107ac:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f107b0:	e24cb004 	sub	r11, r12, #4	; 0x4

#undef NEEDBYTE
#undef NEXTBYTE

/*+++++*/
/* infutil.h -- types and macros common to blocks and codes
 * Copyright (C) 1995 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* WARNING: this file should *not* be used by applications. It is
   part of the implementation of the compression library and is
   subject to change. Applications should only use zlib.h.
 */

/* inflate blocks semi-private state */
struct inflate_blocks_state {

  /* mode */
  enum {
      TYPE,     /* get type bits (3, including end bit) */
      LENS,     /* get lengths for stored */
      STORED,   /* processing stored block */
      TABLE,    /* get table lengths */
      BTREE,    /* get bit lengths tree for a dynamic block */
      DTREE,    /* get length, distance trees for a dynamic block */
      CODES,    /* processing fixed or dynamic block */
      DRY,      /* output remaining window bytes */
      DONEB,     /* finished last block, done */
      BADB}      /* got a data error--stuck here */
    mode;               /* current inflate_block mode */

  /* mode dependent information */
  union {
    uInt left;          /* if STORED, bytes left to copy */
    struct {
      uInt table;               /* table lengths (14 bits) */
      uInt index;               /* index into blens (or border) */
      uIntf *blens;             /* bit lengths of codes */
      uInt bb;                  /* bit length tree depth */
      inflate_huft *tb;         /* bit length decoding tree */
      int nblens;		/* # elements allocated at blens */
    } trees;            /* if DTREE, decoding info for trees */
    struct {
      inflate_huft *tl, *td;    /* trees to free */
      inflate_codes_statef
	 *codes;
    } decode;           /* if CODES, current state */
  } sub;                /* submode */
  uInt last;            /* true if this block is the last block */

  /* mode independent information */
  uInt bitk;            /* bits in bit buffer */
  uLong bitb;           /* bit buffer */
  Bytef *window;        /* sliding window */
  Bytef *end;           /* one byte after sliding window */
  Bytef *read;          /* window read pointer */
  Bytef *write;         /* window write pointer */
  check_func checkfn;   /* check function */
  uLong check;          /* check on output */

};


/* defines for inflate input/output */
/*   update pointers and return */
#define UPDBITS {s->bitb=b;s->bitk=k;}
#define UPDIN {z->avail_in=n;z->total_in+=p-z->next_in;z->next_in=p;}
#define UPDOUT {s->write=q;}
#define UPDATE {UPDBITS UPDIN UPDOUT}
#define LEAVE {UPDATE return inflate_flush(s,z,r);}
/*   get bytes and bits */
#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;}
#define NEEDBYTE {if(n)r=Z_OK;else LEAVE}
#define NEXTBYTE (n--,*p++)
#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}}
#define DUMPBITS(j) {b>>=(j);k-=(j);}
/*   output bytes */
#define WAVAIL (q<s->read?s->read-q-1:s->end-q)
#define LOADOUT {q=s->write;m=WAVAIL;}
#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=WAVAIL;}}
#define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT}
#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;}
#define OUTBYTE(a) {*q++=(Byte)(a);m--;}
/*   load local pointers */
#define LOAD {LOADIN LOADOUT}

/*
 * The IBM 150 firmware munges the data right after _etext[].  This
 * protects it. -- Cort
 */
#if 0
local uInt protect_mask[] = {0, 0, 0, 0, 0, 0, 0, 0, 0 ,0 ,0 ,0};
#endif
/* And'ing with mask[n] masks the lower n bits */
local uInt inflate_mask[] = {
    0x0000,
    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
};

/* copy as much as possible from the sliding window to the output area */
local int inflate_flush OF((
    inflate_blocks_statef *,
    z_stream *,
    int));

/*+++++*/
/* inffast.h -- header to use inffast.c
 * Copyright (C) 1995 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* WARNING: this file should *not* be used by applications. It is
   part of the implementation of the compression library and is
   subject to change. Applications should only use zlib.h.
 */

local int inflate_fast OF((
    uInt,
    uInt,
    inflate_huft *,
    inflate_huft *,
    inflate_blocks_statef *,
    z_stream *));


/*+++++*/
/* infblock.c -- interpret and process block types to last block
 * Copyright (C) 1995 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* Table for deflate from PKZIP's appnote.txt. */
local uInt border[] = { /* Order of the bit length code lengths */
	16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};

/*
   Notes beyond the 1.93a appnote.txt:

   1. Distance pointers never point before the beginning of the output
      stream.
   2. Distance pointers can point back across blocks, up to 32k away.
   3. There is an implied maximum of 7 bits for the bit length table and
      15 bits for the actual data.
   4. If only one code exists, then it is encoded using one bit.  (Zero
      would be more efficient, but perhaps a little confusing.)  If two
      codes exist, they are coded using one bit each (0 and 1).
   5. There is no way of sending zero distance codes--a dummy must be
      sent if there are none.  (History: a pre 2.0 version of PKZIP would
      store blocks with no distance codes, but this was discovered to be
      too harsh a criterion.)  Valid only for 1.93a.  2.04c does allow
      zero distance codes, which is sent as one code of zero bits in
      length.
   6. There are up to 286 literal/length codes.  Code 256 represents the
      end-of-block.  Note however that the static length tree defines
      288 codes just to fill out the Huffman codes.  Codes 286 and 287
      cannot be used though, since there is no length base or extra bits
      defined for them.  Similarily, there are up to 30 distance codes.
      However, static trees define 32 codes (all 5 bits) to fill out the
      Huffman codes, but the last two had better not show up in the data.
   7. Unzip can check dynamic Huffman blocks for complete code sets.
      The exception is that a single code would not be complete (see #4).
   8. The five bits following the block type is really the number of
      literal codes sent minus 257.
   9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits
      (1+6+6).  Therefore, to output three times the length, you output
      three codes (1+1+1), whereas to output four times the same length,
      you only need two codes (1+3).  Hmm.
  10. In the tree reconstruction algorithm, Code = Code + Increment
      only if BitLength(i) is not zero.  (Pretty obvious.)
  11. Correction: 4 Bits: # of Bit Length codes - 4     (4 - 19)
  12. Note: length code 284 can represent 227-258, but length code 285
      really is 258.  The last length deserves its own, short code
      since it gets used a lot in very redundant files.  The length
      258 is special since 258 - 3 (the min match length) is 255.
  13. The literal/length and distance code bit lengths are read as a
      single stream of lengths.  It is possible (and advantageous) for
      a repeat code (16, 17, or 18) to go across the boundary between
      the two sets of lengths.
 */


local void inflate_blocks_reset(s, z, c)
inflate_blocks_statef *s;
z_stream *z;
uLongf *c;
{
 3f107b4:	e1a04000 	mov	r4, r0
  if (s->checkfn != Z_NULL)
 3f107b8:	e5943038 	ldr	r3, [r4, #56]
 3f107bc:	e1a06001 	mov	r6, r1
 3f107c0:	e3530000 	cmp	r3, #0	; 0x0
    *c = s->check;
 3f107c4:	1594303c 	ldrne	r3, [r4, #60]
 3f107c8:	15823000 	strne	r3, [r2]
  if (s->mode == BTREE || s->mode == DTREE)
 3f107cc:	e5943000 	ldr	r3, [r4]
 3f107d0:	e2433004 	sub	r3, r3, #4	; 0x4
 3f107d4:	e3530001 	cmp	r3, #1	; 0x1
 3f107d8:	8a000005 	bhi	3f107f4 <inflate_blocks_reset+0x4c>
    ZFREE(z, s->sub.trees.blens, s->sub.trees.nblens * sizeof(uInt));
 3f107dc:	e5960028 	ldr	r0, [r6, #40]
 3f107e0:	e5942018 	ldr	r2, [r4, #24]
 3f107e4:	e594100c 	ldr	r1, [r4, #12]
 3f107e8:	e1a02102 	mov	r2, r2, lsl #2
 3f107ec:	e1a0e00f 	mov	r14, r15
 3f107f0:	e596f024 	ldr	r15, [r6, #36]
  if (s->mode == CODES)
 3f107f4:	e5943000 	ldr	r3, [r4]
 3f107f8:	e3530006 	cmp	r3, #6	; 0x6
 3f107fc:	1a000008 	bne	3f10824 <inflate_blocks_reset+0x7c>
  {
    inflate_codes_free(s->sub.decode.codes, z);
 3f10800:	e594000c 	ldr	r0, [r4, #12]
 3f10804:	e1a01006 	mov	r1, r6
 3f10808:	eb000941 	bl	3f12d14 <inflate_codes_free>
    inflate_trees_free(s->sub.decode.td, z);
 3f1080c:	e5940008 	ldr	r0, [r4, #8]
 3f10810:	e1a01006 	mov	r1, r6
 3f10814:	eb0006f6 	bl	3f123f4 <inflate_trees_free>
    inflate_trees_free(s->sub.decode.tl, z);
 3f10818:	e5940004 	ldr	r0, [r4, #4]
 3f1081c:	e1a01006 	mov	r1, r6
 3f10820:	eb0006f3 	bl	3f123f4 <inflate_trees_free>
  }
  s->mode = TYPE;
 3f10824:	e3a05000 	mov	r5, #0	; 0x0
 3f10828:	e5845000 	str	r5, [r4]
  s->bitk = 0;
 3f1082c:	e5845020 	str	r5, [r4, #32]
  s->bitb = 0;
 3f10830:	e5845024 	str	r5, [r4, #36]
  s->read = s->write = s->window;
 3f10834:	e5943028 	ldr	r3, [r4, #40]
  if (s->checkfn != Z_NULL)
 3f10838:	e594c038 	ldr	r12, [r4, #56]
 3f1083c:	e5843034 	str	r3, [r4, #52]
 3f10840:	e15c0005 	cmp	r12, r5
 3f10844:	e5843030 	str	r3, [r4, #48]
 3f10848:	0a000005 	beq	3f10864 <inflate_blocks_reset+0xbc>
    s->check = (*s->checkfn)(0L, Z_NULL, 0);
 3f1084c:	e1a00005 	mov	r0, r5
 3f10850:	e1a01005 	mov	r1, r5
 3f10854:	e1a02005 	mov	r2, r5
 3f10858:	e1a0e00f 	mov	r14, r15
 3f1085c:	e1a0f00c 	mov	r15, r12
 3f10860:	e584003c 	str	r0, [r4, #60]
  if (z->outcb != Z_NULL)
 3f10864:	e5963030 	ldr	r3, [r6, #48]
 3f10868:	e3530000 	cmp	r3, #0	; 0x0
 3f1086c:	091ba870 	ldmeqdb	r11, {r4, r5, r6, r11, r13, r15}
    (*z->outcb)(Z_NULL, 0);
 3f10870:	e1a00005 	mov	r0, r5
 3f10874:	e1a01000 	mov	r1, r0
 3f10878:	e1a0e00f 	mov	r14, r15
 3f1087c:	e1a0f003 	mov	r15, r3
 3f10880:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f10884 <inflate_blocks_new>:
 3f10884:	e1a0c00d 	mov	r12, r13
 3f10888:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f1088c:	e24cb004 	sub	r11, r12, #4	; 0x4
  Trace((stderr, "inflate:   blocks reset\n"));
}


local inflate_blocks_statef *inflate_blocks_new(z, c, w)
z_stream *z;
check_func c;
uInt w;
{
 3f10890:	e1a0a001 	mov	r10, r1
  inflate_blocks_statef *s;

  if ((s = (inflate_blocks_statef *)ZALLOC
 3f10894:	e3a01001 	mov	r1, #1	; 0x1
 3f10898:	e1a05000 	mov	r5, r0
 3f1089c:	e1a07002 	mov	r7, r2
 3f108a0:	e5950028 	ldr	r0, [r5, #40]
 3f108a4:	e3a02040 	mov	r2, #64	; 0x40
 3f108a8:	e1a0e00f 	mov	r14, r15
 3f108ac:	e595f020 	ldr	r15, [r5, #32]
 3f108b0:	e2504000 	subs	r4, r0, #0	; 0x0
       (z,1,sizeof(struct inflate_blocks_state))) == Z_NULL)
    return s;
 3f108b4:	01a00004 	moveq	r0, r4
 3f108b8:	091bacf0 	ldmeqdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
  if ((s->window = (Bytef *)ZALLOC(z, 1, w)) == Z_NULL)
 3f108bc:	e3a01001 	mov	r1, #1	; 0x1
 3f108c0:	e5950028 	ldr	r0, [r5, #40]
 3f108c4:	e1a02007 	mov	r2, r7
 3f108c8:	e1a0e00f 	mov	r14, r15
 3f108cc:	e595f020 	ldr	r15, [r5, #32]
 3f108d0:	e1a06000 	mov	r6, r0
 3f108d4:	e3560000 	cmp	r6, #0	; 0x0
 3f108d8:	e5846028 	str	r6, [r4, #40]
 3f108dc:	0a00000a 	beq	3f1090c <inflate_blocks_new+0x88>
  {
    ZFREE(z, s, sizeof(struct inflate_blocks_state));
    return Z_NULL;
  }
  s->end = s->window + w;
  s->checkfn = c;
  s->mode = TYPE;
  Trace((stderr, "inflate:   blocks allocated\n"));
  inflate_blocks_reset(s, z, &s->check);
 3f108e0:	e1a00004 	mov	r0, r4
 3f108e4:	e1a01005 	mov	r1, r5
 3f108e8:	e0863007 	add	r3, r6, r7
 3f108ec:	e584302c 	str	r3, [r4, #44]
 3f108f0:	e284203c 	add	r2, r4, #60	; 0x3c
 3f108f4:	e584a038 	str	r10, [r4, #56]
 3f108f8:	e3a03000 	mov	r3, #0	; 0x0
 3f108fc:	e5843000 	str	r3, [r4]
 3f10900:	ebffffa8 	bl	3f107a8 <inflate_blocks_reset>
  return s;
 3f10904:	e1a00004 	mov	r0, r4
 3f10908:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f1090c:	e1a01004 	mov	r1, r4
 3f10910:	e5950028 	ldr	r0, [r5, #40]
 3f10914:	e3a02040 	mov	r2, #64	; 0x40
 3f10918:	e1a0e00f 	mov	r14, r15
 3f1091c:	e595f024 	ldr	r15, [r5, #36]
 3f10920:	e1a00006 	mov	r0, r6
}
 3f10924:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f10928 <inflate_blocks>:
 3f10928:	e1a0c00d 	mov	r12, r13
 3f1092c:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}


local int inflate_blocks(s, z, r)
inflate_blocks_statef *s;
z_stream *z;
int r;
{
 3f10930:	e1a06001 	mov	r6, r1
 3f10934:	e24dd040 	sub	r13, r13, #64	; 0x40
  uInt t;               /* temporary storage */
  uLong b;              /* bit buffer */
  uInt k;               /* bits in bit buffer */
  Bytef *p;             /* input data pointer */
  uInt n;               /* bytes available there */
  Bytef *q;             /* output window write pointer */
  uInt m;               /* bytes to end of window or read pointer */

  /* copy input/output information to locals (UPDATE macro restores) */
  LOAD
 3f10938:	e5961000 	ldr	r1, [r6]
 3f1093c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f10940:	e50b104c 	str	r1, [r11, -#76]
 3f10944:	e5963004 	ldr	r3, [r6, #4]
 3f10948:	e50b3050 	str	r3, [r11, -#80]
 3f1094c:	e1a05000 	mov	r5, r0
 3f10950:	e5959034 	ldr	r9, [r5, #52]
 3f10954:	e595a024 	ldr	r10, [r5, #36]
 3f10958:	e50b9054 	str	r9, [r11, -#84]
 3f1095c:	e5953030 	ldr	r3, [r5, #48]
 3f10960:	e50b2048 	str	r2, [r11, -#72]
 3f10964:	e1590003 	cmp	r9, r3
 3f10968:	e5957020 	ldr	r7, [r5, #32]
 3f1096c:	30693003 	rsbcc	r3, r9, r3
 3f10970:	32439001 	subcc	r9, r3, #1	; 0x1
 3f10974:	2595302c 	ldrcs	r3, [r5, #44]
 3f10978:	251b1054 	ldrcs	r1, [r11, -#84]
 3f1097c:	20619003 	rsbcs	r9, r1, r3

  /* process input based on current state */
  while (1) switch (s->mode)
 3f10980:	e5953000 	ldr	r3, [r5]
 3f10984:	e3530009 	cmp	r3, #9	; 0x9
 3f10988:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f1098c:	ea00038b 	b	3f117c0 <inflate_blocks+0xe98>
 3f10990:	03f109b8 	mvneqs	r0, #3014656	; 0x2e0000
 3f10994:	03f10b58 	mvneqs	r0, #90112	; 0x16000
 3f10998:	03f10c2c 	mvneqs	r0, #11264	; 0x2c00
 3f1099c:	03f10e04 	mvneqs	r0, #64	; 0x40
 3f109a0:	03f10f64 	mvneqs	r0, #400	; 0x190
 3f109a4:	03f1127c 	mvneqs	r1, #-1073741817	; 0xc0000007
 3f109a8:	03f1141c 	mvneqs	r1, #469762048	; 0x1c000000
 3f109ac:	03f1151c 	mvneqs	r1, #117440512	; 0x7000000
 3f109b0:	03f115a0 	mvneqs	r1, #671088640	; 0x28000000
 3f109b4:	03f115e4 	mvneqs	r1, #956301312	; 0x39000000
  {
    case TYPE:
      NEEDBITS(3)
 3f109b8:	e3570002 	cmp	r7, #2	; 0x2
 3f109bc:	8a00000d 	bhi	3f109f8 <inflate_blocks+0xd0>
 3f109c0:	e51b2050 	ldr	r2, [r11, -#80]
 3f109c4:	e3520000 	cmp	r2, #0	; 0x0
 3f109c8:	0a000316 	beq	3f11628 <inflate_blocks+0xd00>
 3f109cc:	e51b104c 	ldr	r1, [r11, -#76]
 3f109d0:	e3a03000 	mov	r3, #0	; 0x0
 3f109d4:	e50b3048 	str	r3, [r11, -#72]
 3f109d8:	e4d13001 	ldrb	r3, [r1], #1
 3f109dc:	e2422001 	sub	r2, r2, #1	; 0x1
 3f109e0:	e50b2050 	str	r2, [r11, -#80]
 3f109e4:	e18aa713 	orr	r10, r10, r3, lsl r7
 3f109e8:	e2877008 	add	r7, r7, #8	; 0x8
 3f109ec:	e3570002 	cmp	r7, #2	; 0x2
 3f109f0:	e50b104c 	str	r1, [r11, -#76]
 3f109f4:	9afffff1 	bls	3f109c0 <inflate_blocks+0x98>
      t = (uInt)b & 7;
 3f109f8:	e20a4007 	and	r4, r10, #7	; 0x7
      s->last = t & 1;
 3f109fc:	e20a3001 	and	r3, r10, #1	; 0x1
 3f10a00:	e585301c 	str	r3, [r5, #28]
      switch (t >> 1)
 3f10a04:	e1a030a4 	mov	r3, r4, lsr #1
 3f10a08:	e3530003 	cmp	r3, #3	; 0x3
 3f10a0c:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f10a10:	ea00004f 	b	3f10b54 <inflate_blocks+0x22c>
 3f10a14:	03f10a24 	mvneqs	r0, #147456	; 0x24000
 3f10a18:	03f10a44 	mvneqs	r0, #278528	; 0x44000
 3f10a1c:	03f10ae4 	mvneqs	r0, #933888	; 0xe4000
 3f10a20:	03f10af8 	mvneqs	r0, #1015808	; 0xf8000
      {
	case 0:                         /* stored */
	  Trace((stderr, "inflate:     stored block%s\n",
		 s->last ? " (last)" : ""));
	  DUMPBITS(3)
 3f10a24:	e1a0a1aa 	mov	r10, r10, lsr #3
 3f10a28:	e2477003 	sub	r7, r7, #3	; 0x3
	  t = k & 7;                    /* go to byte boundary */
 3f10a2c:	e2074007 	and	r4, r7, #7	; 0x7
	  DUMPBITS(t)
 3f10a30:	e1a0a43a 	mov	r10, r10, lsr r4
 3f10a34:	e0647007 	rsb	r7, r4, r7
	  s->mode = LENS;               /* get length of stored block */
 3f10a38:	e3a03001 	mov	r3, #1	; 0x1
 3f10a3c:	e5853000 	str	r3, [r5]
	  break;
 3f10a40:	eaffffce 	b	3f10980 <inflate_blocks+0x58>
	case 1:                         /* fixed */
	  Trace((stderr, "inflate:     fixed codes block%s\n",
		 s->last ? " (last)" : ""));
	  {
	    uInt bl, bd;
	    inflate_huft *tl, *td;

	    inflate_trees_fixed(&bl, &bd, &tl, &td);
 3f10a44:	e24b0028 	sub	r0, r11, #40	; 0x28
 3f10a48:	e24b102c 	sub	r1, r11, #44	; 0x2c
 3f10a4c:	e24b2030 	sub	r2, r11, #48	; 0x30
 3f10a50:	e24b3034 	sub	r3, r11, #52	; 0x34
 3f10a54:	eb0005d6 	bl	3f121b4 <inflate_trees_fixed>
	    s->sub.decode.codes = inflate_codes_new(bl, bd, tl, td, z);
 3f10a58:	e58d6000 	str	r6, [r13]
 3f10a5c:	e51b0028 	ldr	r0, [r11, -#40]
 3f10a60:	e51b102c 	ldr	r1, [r11, -#44]
 3f10a64:	e51b2030 	ldr	r2, [r11, -#48]
 3f10a68:	e51b3034 	ldr	r3, [r11, -#52]
 3f10a6c:	eb000672 	bl	3f1243c <inflate_codes_new>
	    if (s->sub.decode.codes == Z_NULL)
 3f10a70:	e3500000 	cmp	r0, #0	; 0x0
 3f10a74:	e585000c 	str	r0, [r5, #12]
 3f10a78:	1a000011 	bne	3f10ac4 <inflate_blocks+0x19c>
	    {
	      r = Z_MEM_ERROR;
	      LEAVE
 3f10a7c:	e585a024 	str	r10, [r5, #36]
 3f10a80:	e5857020 	str	r7, [r5, #32]
 3f10a84:	e51b2050 	ldr	r2, [r11, -#80]
 3f10a88:	e5862004 	str	r2, [r6, #4]
 3f10a8c:	e51b304c 	ldr	r3, [r11, -#76]
 3f10a90:	e5962000 	ldr	r2, [r6]
 3f10a94:	e5863000 	str	r3, [r6]
 3f10a98:	e51b904c 	ldr	r9, [r11, -#76]
 3f10a9c:	e5963008 	ldr	r3, [r6, #8]
 3f10aa0:	e0622009 	rsb	r2, r2, r9
 3f10aa4:	e0833002 	add	r3, r3, r2
 3f10aa8:	e5863008 	str	r3, [r6, #8]
 3f10aac:	e1a00005 	mov	r0, r5
 3f10ab0:	e51b2054 	ldr	r2, [r11, -#84]
 3f10ab4:	e1a01006 	mov	r1, r6
 3f10ab8:	e5852034 	str	r2, [r5, #52]
 3f10abc:	e3e02003 	mvn	r2, #3	; 0x3
 3f10ac0:	ea00034e 	b	3f11800 <inflate_blocks+0xed8>
	    }
	    s->sub.decode.tl = Z_NULL;  /* don't try to free these */
	    s->sub.decode.td = Z_NULL;
	  }
	  DUMPBITS(3)
 3f10ac4:	e1a0a1aa 	mov	r10, r10, lsr #3
 3f10ac8:	e3a03000 	mov	r3, #0	; 0x0
 3f10acc:	e5853004 	str	r3, [r5, #4]
 3f10ad0:	e2477003 	sub	r7, r7, #3	; 0x3
 3f10ad4:	e5853008 	str	r3, [r5, #8]
	  s->mode = CODES;
 3f10ad8:	e2833006 	add	r3, r3, #6	; 0x6
 3f10adc:	e5853000 	str	r3, [r5]
	  break;
 3f10ae0:	eaffffa6 	b	3f10980 <inflate_blocks+0x58>
	case 2:                         /* dynamic */
	  Trace((stderr, "inflate:     dynamic codes block%s\n",
		 s->last ? " (last)" : ""));
	  DUMPBITS(3)
 3f10ae4:	e1a0a1aa 	mov	r10, r10, lsr #3
 3f10ae8:	e2477003 	sub	r7, r7, #3	; 0x3
	  s->mode = TABLE;
 3f10aec:	e3a03003 	mov	r3, #3	; 0x3
 3f10af0:	e5853000 	str	r3, [r5]
	  break;
 3f10af4:	eaffffa1 	b	3f10980 <inflate_blocks+0x58>
	case 3:                         /* illegal */
	  DUMPBITS(3)
	  s->mode = BADB;
 3f10af8:	e3a03009 	mov	r3, #9	; 0x9
 3f10afc:	e5853000 	str	r3, [r5]
	  z->msg = "invalid block type";
 3f10b00:	e59f33bc 	ldr	r3, [pc, #3bc]	; 3f10ec4 <inflate_blocks+0x59c>
 3f10b04:	e5863018 	str	r3, [r6, #24]
 3f10b08:	e1a0a1aa 	mov	r10, r10, lsr #3
	  r = Z_DATA_ERROR;
	  LEAVE
 3f10b0c:	e585a024 	str	r10, [r5, #36]
 3f10b10:	e2477003 	sub	r7, r7, #3	; 0x3
 3f10b14:	e5857020 	str	r7, [r5, #32]
 3f10b18:	e51b3050 	ldr	r3, [r11, -#80]
 3f10b1c:	e5863004 	str	r3, [r6, #4]
 3f10b20:	e5962000 	ldr	r2, [r6]
 3f10b24:	e51b904c 	ldr	r9, [r11, -#76]
 3f10b28:	e5963008 	ldr	r3, [r6, #8]
 3f10b2c:	e0622009 	rsb	r2, r2, r9
 3f10b30:	e5869000 	str	r9, [r6]
 3f10b34:	e0833002 	add	r3, r3, r2
 3f10b38:	e5863008 	str	r3, [r6, #8]
 3f10b3c:	e1a00005 	mov	r0, r5
 3f10b40:	e51b2054 	ldr	r2, [r11, -#84]
 3f10b44:	e1a01006 	mov	r1, r6
 3f10b48:	e5852034 	str	r2, [r5, #52]
 3f10b4c:	e3e02002 	mvn	r2, #2	; 0x2
 3f10b50:	ea00032a 	b	3f11800 <inflate_blocks+0xed8>
      }
      break;
 3f10b54:	eaffff89 	b	3f10980 <inflate_blocks+0x58>
    case LENS:
      NEEDBITS(32)
 3f10b58:	e357001f 	cmp	r7, #31	; 0x1f
 3f10b5c:	8a00000e 	bhi	3f10b9c <inflate_blocks+0x274>
 3f10b60:	e51b3050 	ldr	r3, [r11, -#80]
 3f10b64:	e3530000 	cmp	r3, #0	; 0x0
 3f10b68:	0a0002bf 	beq	3f1166c <inflate_blocks+0xd44>
 3f10b6c:	e3a01000 	mov	r1, #0	; 0x0
 3f10b70:	e50b1048 	str	r1, [r11, -#72]
 3f10b74:	e24b1050 	sub	r1, r11, #80	; 0x50
 3f10b78:	e8910006 	ldmia	r1, {r1, r2}
 3f10b7c:	e4d23001 	ldrb	r3, [r2], #1
 3f10b80:	e2411001 	sub	r1, r1, #1	; 0x1
 3f10b84:	e50b1050 	str	r1, [r11, -#80]
 3f10b88:	e18aa713 	orr	r10, r10, r3, lsl r7
 3f10b8c:	e2877008 	add	r7, r7, #8	; 0x8
 3f10b90:	e357001f 	cmp	r7, #31	; 0x1f
 3f10b94:	e50b204c 	str	r2, [r11, -#76]
 3f10b98:	9afffff0 	bls	3f10b60 <inflate_blocks+0x238>
      if (((~b) >> 16) != (b & 0xffff))
 3f10b9c:	e1a0380a 	mov	r3, r10, lsl #16
 3f10ba0:	e1a03823 	mov	r3, r3, lsr #16
 3f10ba4:	e1e0200a 	mvn	r2, r10
 3f10ba8:	e1a02822 	mov	r2, r2, lsr #16
 3f10bac:	e1520003 	cmp	r2, r3
 3f10bb0:	0a000015 	beq	3f10c0c <inflate_blocks+0x2e4>
      {
	s->mode = BADB;
 3f10bb4:	e3a03009 	mov	r3, #9	; 0x9
 3f10bb8:	e5853000 	str	r3, [r5]
	z->msg = "invalid stored block lengths";
 3f10bbc:	e59f3304 	ldr	r3, [pc, #304]	; 3f10ec8 <inflate_blocks+0x5a0>
 3f10bc0:	e5863018 	str	r3, [r6, #24]
	r = Z_DATA_ERROR;
	LEAVE
 3f10bc4:	e585a024 	str	r10, [r5, #36]
 3f10bc8:	e5857020 	str	r7, [r5, #32]
 3f10bcc:	e51b2050 	ldr	r2, [r11, -#80]
 3f10bd0:	e5862004 	str	r2, [r6, #4]
 3f10bd4:	e51b304c 	ldr	r3, [r11, -#76]
 3f10bd8:	e5962000 	ldr	r2, [r6]
 3f10bdc:	e5863000 	str	r3, [r6]
 3f10be0:	e51b904c 	ldr	r9, [r11, -#76]
 3f10be4:	e5963008 	ldr	r3, [r6, #8]
 3f10be8:	e0622009 	rsb	r2, r2, r9
 3f10bec:	e0833002 	add	r3, r3, r2
 3f10bf0:	e5863008 	str	r3, [r6, #8]
 3f10bf4:	e1a00005 	mov	r0, r5
 3f10bf8:	e51b2054 	ldr	r2, [r11, -#84]
 3f10bfc:	e1a01006 	mov	r1, r6
 3f10c00:	e5852034 	str	r2, [r5, #52]
 3f10c04:	e3e02002 	mvn	r2, #2	; 0x2
 3f10c08:	ea0002fc 	b	3f11800 <inflate_blocks+0xed8>
      }
      s->sub.left = (uInt)b & 0xffff;
      b = k = 0;                      /* dump bits */
 3f10c0c:	e3a07000 	mov	r7, #0	; 0x0
 3f10c10:	e1a0a007 	mov	r10, r7
      Tracev((stderr, "inflate:       stored length %u\n", s->sub.left));
      s->mode = s->sub.left ? STORED : TYPE;
 3f10c14:	e1520007 	cmp	r2, r7
 3f10c18:	e5852004 	str	r2, [r5, #4]
 3f10c1c:	13a03002 	movne	r3, #2	; 0x2
 3f10c20:	01a03007 	moveq	r3, r7
 3f10c24:	e5853000 	str	r3, [r5]
      break;
 3f10c28:	eaffff54 	b	3f10980 <inflate_blocks+0x58>
    case STORED:
      if (n == 0)
 3f10c2c:	e51b3050 	ldr	r3, [r11, -#80]
 3f10c30:	e3530000 	cmp	r3, #0	; 0x0
 3f10c34:	1a00000f 	bne	3f10c78 <inflate_blocks+0x350>
	LEAVE
 3f10c38:	e585a024 	str	r10, [r5, #36]
 3f10c3c:	e5857020 	str	r7, [r5, #32]
 3f10c40:	e5863004 	str	r3, [r6, #4]
 3f10c44:	e51b904c 	ldr	r9, [r11, -#76]
 3f10c48:	e5962000 	ldr	r2, [r6]
 3f10c4c:	e5869000 	str	r9, [r6]
 3f10c50:	e5963008 	ldr	r3, [r6, #8]
 3f10c54:	e0622009 	rsb	r2, r2, r9
 3f10c58:	e0833002 	add	r3, r3, r2
 3f10c5c:	e5863008 	str	r3, [r6, #8]
 3f10c60:	e51b2054 	ldr	r2, [r11, -#84]
 3f10c64:	e5852034 	str	r2, [r5, #52]
 3f10c68:	e1a00005 	mov	r0, r5
 3f10c6c:	e51b2048 	ldr	r2, [r11, -#72]
 3f10c70:	e1a01006 	mov	r1, r6
 3f10c74:	ea0002e1 	b	3f11800 <inflate_blocks+0xed8>
      NEEDOUT
 3f10c78:	e3590000 	cmp	r9, #0	; 0x0
 3f10c7c:	1a00003f 	bne	3f10d80 <inflate_blocks+0x458>
 3f10c80:	e595102c 	ldr	r1, [r5, #44]
 3f10c84:	e51b3054 	ldr	r3, [r11, -#84]
 3f10c88:	e1530001 	cmp	r3, r1
 3f10c8c:	1a000009 	bne	3f10cb8 <inflate_blocks+0x390>
 3f10c90:	e5953030 	ldr	r3, [r5, #48]
 3f10c94:	e5952028 	ldr	r2, [r5, #40]
 3f10c98:	e1530002 	cmp	r3, r2
 3f10c9c:	0a000005 	beq	3f10cb8 <inflate_blocks+0x390>
 3f10ca0:	e50b2054 	str	r2, [r11, -#84]
 3f10ca4:	e1520003 	cmp	r2, r3
 3f10ca8:	30623003 	rsbcc	r3, r2, r3
 3f10cac:	32439001 	subcc	r9, r3, #1	; 0x1
 3f10cb0:	251b2054 	ldrcs	r2, [r11, -#84]
 3f10cb4:	20629001 	rsbcs	r9, r2, r1
 3f10cb8:	e3590000 	cmp	r9, #0	; 0x0
 3f10cbc:	1a00002f 	bne	3f10d80 <inflate_blocks+0x458>
 3f10cc0:	e51b3054 	ldr	r3, [r11, -#84]
 3f10cc4:	e5853034 	str	r3, [r5, #52]
 3f10cc8:	e1a00005 	mov	r0, r5
 3f10ccc:	e51b2048 	ldr	r2, [r11, -#72]
 3f10cd0:	e1a01006 	mov	r1, r6
 3f10cd4:	eb000818 	bl	3f12d3c <inflate_flush>
 3f10cd8:	e5959034 	ldr	r9, [r5, #52]
 3f10cdc:	e50b9054 	str	r9, [r11, -#84]
 3f10ce0:	e5952030 	ldr	r2, [r5, #48]
 3f10ce4:	e50b0048 	str	r0, [r11, -#72]
 3f10ce8:	e1590002 	cmp	r9, r2
 3f10cec:	30693002 	rsbcc	r3, r9, r2
 3f10cf0:	32439001 	subcc	r9, r3, #1	; 0x1
 3f10cf4:	2595302c 	ldrcs	r3, [r5, #44]
 3f10cf8:	251b1054 	ldrcs	r1, [r11, -#84]
 3f10cfc:	20619003 	rsbcs	r9, r1, r3
 3f10d00:	e595102c 	ldr	r1, [r5, #44]
 3f10d04:	e51b3054 	ldr	r3, [r11, -#84]
 3f10d08:	e1530001 	cmp	r3, r1
 3f10d0c:	1a000008 	bne	3f10d34 <inflate_blocks+0x40c>
 3f10d10:	e5953028 	ldr	r3, [r5, #40]
 3f10d14:	e1520003 	cmp	r2, r3
 3f10d18:	0a000005 	beq	3f10d34 <inflate_blocks+0x40c>
 3f10d1c:	e50b3054 	str	r3, [r11, -#84]
 3f10d20:	e1530002 	cmp	r3, r2
 3f10d24:	30633002 	rsbcc	r3, r3, r2
 3f10d28:	32439001 	subcc	r9, r3, #1	; 0x1
 3f10d2c:	251b2054 	ldrcs	r2, [r11, -#84]
 3f10d30:	20629001 	rsbcs	r9, r2, r1
 3f10d34:	e3590000 	cmp	r9, #0	; 0x0
 3f10d38:	1a000010 	bne	3f10d80 <inflate_blocks+0x458>
 3f10d3c:	e585a024 	str	r10, [r5, #36]
 3f10d40:	e5857020 	str	r7, [r5, #32]
 3f10d44:	e51b3050 	ldr	r3, [r11, -#80]
 3f10d48:	e5863004 	str	r3, [r6, #4]
 3f10d4c:	e5962000 	ldr	r2, [r6]
 3f10d50:	e51b904c 	ldr	r9, [r11, -#76]
 3f10d54:	e5963008 	ldr	r3, [r6, #8]
 3f10d58:	e0622009 	rsb	r2, r2, r9
 3f10d5c:	e5869000 	str	r9, [r6]
 3f10d60:	e0833002 	add	r3, r3, r2
 3f10d64:	e5863008 	str	r3, [r6, #8]
 3f10d68:	e51b2054 	ldr	r2, [r11, -#84]
 3f10d6c:	e5852034 	str	r2, [r5, #52]
 3f10d70:	e1a00005 	mov	r0, r5
 3f10d74:	e51b2048 	ldr	r2, [r11, -#72]
 3f10d78:	e1a01006 	mov	r1, r6
 3f10d7c:	ea00029f 	b	3f11800 <inflate_blocks+0xed8>
 3f10d80:	e3a03000 	mov	r3, #0	; 0x0
 3f10d84:	e50b3048 	str	r3, [r11, -#72]
      t = s->sub.left;
      if (t > n) t = n;
      if (t > m) t = m;
      zmemcpy(q, p, t);
 3f10d88:	e24b0054 	sub	r0, r11, #84	; 0x54
 3f10d8c:	e8900005 	ldmia	r0, {r0, r2}
 3f10d90:	e5954004 	ldr	r4, [r5, #4]
 3f10d94:	e51b104c 	ldr	r1, [r11, -#76]
 3f10d98:	e1540002 	cmp	r4, r2
 3f10d9c:	21a04002 	movcs	r4, r2
 3f10da0:	e1540009 	cmp	r4, r9
 3f10da4:	21a04009 	movcs	r4, r9
 3f10da8:	e1a02004 	mov	r2, r4
 3f10dac:	ebfff9f5 	bl	3f0f588 <memcpy>
      p += t;  n -= t;
 3f10db0:	e24b1050 	sub	r1, r11, #80	; 0x50
 3f10db4:	e891000a 	ldmia	r1, {r1, r3}
      q += t;  m -= t;
 3f10db8:	e51b2054 	ldr	r2, [r11, -#84]
 3f10dbc:	e0641001 	rsb	r1, r4, r1
 3f10dc0:	e50b1050 	str	r1, [r11, -#80]
 3f10dc4:	e0822004 	add	r2, r2, r4
 3f10dc8:	e50b2054 	str	r2, [r11, -#84]
 3f10dcc:	e0833004 	add	r3, r3, r4
 3f10dd0:	e50b304c 	str	r3, [r11, -#76]
      if ((s->sub.left -= t) != 0)
 3f10dd4:	e5953004 	ldr	r3, [r5, #4]
 3f10dd8:	e0649009 	rsb	r9, r4, r9
 3f10ddc:	e0643003 	rsb	r3, r4, r3
 3f10de0:	e3530000 	cmp	r3, #0	; 0x0
 3f10de4:	e5853004 	str	r3, [r5, #4]
 3f10de8:	1afffee4 	bne	3f10980 <inflate_blocks+0x58>
	break;
      Tracev((stderr, "inflate:       stored end, %lu total out\n",
	      z->total_out + (q >= s->read ? q - s->read :
	      (s->end - s->read) + (q - s->window))));
      s->mode = s->last ? DRY : TYPE;
 3f10dec:	e595301c 	ldr	r3, [r5, #28]
 3f10df0:	e3530000 	cmp	r3, #0	; 0x0
 3f10df4:	13a03007 	movne	r3, #7	; 0x7
 3f10df8:	03a03000 	moveq	r3, #0	; 0x0
 3f10dfc:	e5853000 	str	r3, [r5]
      break;
 3f10e00:	eafffede 	b	3f10980 <inflate_blocks+0x58>
    case TABLE:
      NEEDBITS(14)
 3f10e04:	e357000d 	cmp	r7, #13	; 0xd
 3f10e08:	8a00000e 	bhi	3f10e48 <inflate_blocks+0x520>
 3f10e0c:	e51b3050 	ldr	r3, [r11, -#80]
 3f10e10:	e3530000 	cmp	r3, #0	; 0x0
 3f10e14:	0a000225 	beq	3f116b0 <inflate_blocks+0xd88>
 3f10e18:	e3a09000 	mov	r9, #0	; 0x0
 3f10e1c:	e50b9048 	str	r9, [r11, -#72]
 3f10e20:	e51b104c 	ldr	r1, [r11, -#76]
 3f10e24:	e51b2050 	ldr	r2, [r11, -#80]
 3f10e28:	e4d13001 	ldrb	r3, [r1], #1
 3f10e2c:	e2422001 	sub	r2, r2, #1	; 0x1
 3f10e30:	e50b2050 	str	r2, [r11, -#80]
 3f10e34:	e18aa713 	orr	r10, r10, r3, lsl r7
 3f10e38:	e2877008 	add	r7, r7, #8	; 0x8
 3f10e3c:	e357000d 	cmp	r7, #13	; 0xd
 3f10e40:	e50b104c 	str	r1, [r11, -#76]
 3f10e44:	9afffff0 	bls	3f10e0c <inflate_blocks+0x4e4>
      s->sub.trees.table = t = (uInt)b & 0x3fff;
 3f10e48:	e1a0490a 	mov	r4, r10, lsl #18
 3f10e4c:	e1a04924 	mov	r4, r4, lsr #18
#ifndef PKZIP_BUG_WORKAROUND
      if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29)
 3f10e50:	e20a201f 	and	r2, r10, #31	; 0x1f
 3f10e54:	e352001d 	cmp	r2, #29	; 0x1d
 3f10e58:	e5854004 	str	r4, [r5, #4]
 3f10e5c:	8a000003 	bhi	3f10e70 <inflate_blocks+0x548>
 3f10e60:	e1a032a4 	mov	r3, r4, lsr #5
 3f10e64:	e203001f 	and	r0, r3, #31	; 0x1f
 3f10e68:	e350001d 	cmp	r0, #29	; 0x1d
 3f10e6c:	9a000017 	bls	3f10ed0 <inflate_blocks+0x5a8>
      {
	s->mode = BADB;
 3f10e70:	e3a03009 	mov	r3, #9	; 0x9
 3f10e74:	e5853000 	str	r3, [r5]
	z->msg = "too many length or distance symbols";
 3f10e78:	e59f304c 	ldr	r3, [pc, #4c]	; 3f10ecc <inflate_blocks+0x5a4>
 3f10e7c:	e5863018 	str	r3, [r6, #24]
	r = Z_DATA_ERROR;
	LEAVE
 3f10e80:	e585a024 	str	r10, [r5, #36]
 3f10e84:	e5857020 	str	r7, [r5, #32]
 3f10e88:	e51b3050 	ldr	r3, [r11, -#80]
 3f10e8c:	e5863004 	str	r3, [r6, #4]
 3f10e90:	e5962000 	ldr	r2, [r6]
 3f10e94:	e51b904c 	ldr	r9, [r11, -#76]
 3f10e98:	e5963008 	ldr	r3, [r6, #8]
 3f10e9c:	e0622009 	rsb	r2, r2, r9
 3f10ea0:	e5869000 	str	r9, [r6]
 3f10ea4:	e0833002 	add	r3, r3, r2
 3f10ea8:	e5863008 	str	r3, [r6, #8]
 3f10eac:	e1a00005 	mov	r0, r5
 3f10eb0:	e51b2054 	ldr	r2, [r11, -#84]
 3f10eb4:	e1a01006 	mov	r1, r6
 3f10eb8:	e5852034 	str	r2, [r5, #52]
 3f10ebc:	e3e02002 	mvn	r2, #2	; 0x2
 3f10ec0:	ea00024e 	b	3f11800 <inflate_blocks+0xed8>
 3f10ec4:	03f1f6d8 	mvneqs	r15, #226492416	; 0xd800000
 3f10ec8:	03f1f6ec 	mvneqs	r15, #247463936	; 0xec00000
 3f10ecc:	03f1f70c 	mvneqs	r15, #3145728	; 0x300000
      }
#endif
      t = 258 + (t & 0x1f) + ((t >> 5) & 0x1f);
 3f10ed0:	e2803c01 	add	r3, r0, #256	; 0x100
 3f10ed4:	e2833002 	add	r3, r3, #2	; 0x2
 3f10ed8:	e0824003 	add	r4, r2, r3
      if (t < 19)
 3f10edc:	e3540012 	cmp	r4, #18	; 0x12
 3f10ee0:	93a04013 	movls	r4, #19	; 0x13
	t = 19;
      if ((s->sub.trees.blens = (uIntf*)ZALLOC(z, t, sizeof(uInt))) == Z_NULL)
 3f10ee4:	e1a01004 	mov	r1, r4
 3f10ee8:	e5960028 	ldr	r0, [r6, #40]
 3f10eec:	e3a02004 	mov	r2, #4	; 0x4
 3f10ef0:	e1a0e00f 	mov	r14, r15
 3f10ef4:	e596f020 	ldr	r15, [r6, #32]
 3f10ef8:	e3500000 	cmp	r0, #0	; 0x0
 3f10efc:	e585000c 	str	r0, [r5, #12]
 3f10f00:	1a000010 	bne	3f10f48 <inflate_blocks+0x620>
      {
	r = Z_MEM_ERROR;
	LEAVE
 3f10f04:	e585a024 	str	r10, [r5, #36]
 3f10f08:	e5857020 	str	r7, [r5, #32]
 3f10f0c:	e51b3050 	ldr	r3, [r11, -#80]
 3f10f10:	e5863004 	str	r3, [r6, #4]
 3f10f14:	e5962000 	ldr	r2, [r6]
 3f10f18:	e51b904c 	ldr	r9, [r11, -#76]
 3f10f1c:	e5963008 	ldr	r3, [r6, #8]
 3f10f20:	e0622009 	rsb	r2, r2, r9
 3f10f24:	e5869000 	str	r9, [r6]
 3f10f28:	e0833002 	add	r3, r3, r2
 3f10f2c:	e5863008 	str	r3, [r6, #8]
 3f10f30:	e1a00005 	mov	r0, r5
 3f10f34:	e51b2054 	ldr	r2, [r11, -#84]
 3f10f38:	e1a01006 	mov	r1, r6
 3f10f3c:	e5852034 	str	r2, [r5, #52]
 3f10f40:	e3e02003 	mvn	r2, #3	; 0x3
 3f10f44:	ea00022d 	b	3f11800 <inflate_blocks+0xed8>
      }
      s->sub.trees.nblens = t;
      DUMPBITS(14)
 3f10f48:	e1a0a72a 	mov	r10, r10, lsr #14
 3f10f4c:	e247700e 	sub	r7, r7, #14	; 0xe
 3f10f50:	e5854018 	str	r4, [r5, #24]
      s->sub.trees.index = 0;
 3f10f54:	e3a03000 	mov	r3, #0	; 0x0
 3f10f58:	e5853008 	str	r3, [r5, #8]
      Tracev((stderr, "inflate:       table sizes ok\n"));
      s->mode = BTREE;
 3f10f5c:	e2833004 	add	r3, r3, #4	; 0x4
 3f10f60:	e5853000 	str	r3, [r5]
    case BTREE:
      while (s->sub.trees.index < 4 + (s->sub.trees.table >> 10))
 3f10f64:	e5953004 	ldr	r3, [r5, #4]
 3f10f68:	e5952008 	ldr	r2, [r5, #8]
 3f10f6c:	ea00001b 	b	3f10fe0 <inflate_blocks+0x6b8>
      {
	NEEDBITS(3)
 3f10f70:	e3570002 	cmp	r7, #2	; 0x2
 3f10f74:	8a00000e 	bhi	3f10fb4 <inflate_blocks+0x68c>
 3f10f78:	e51b3050 	ldr	r3, [r11, -#80]
 3f10f7c:	e3530000 	cmp	r3, #0	; 0x0
 3f10f80:	0a0001db 	beq	3f116f4 <inflate_blocks+0xdcc>
 3f10f84:	e3a09000 	mov	r9, #0	; 0x0
 3f10f88:	e50b9048 	str	r9, [r11, -#72]
 3f10f8c:	e51b104c 	ldr	r1, [r11, -#76]
 3f10f90:	e51b2050 	ldr	r2, [r11, -#80]
 3f10f94:	e4d13001 	ldrb	r3, [r1], #1
 3f10f98:	e2422001 	sub	r2, r2, #1	; 0x1
 3f10f9c:	e50b2050 	str	r2, [r11, -#80]
 3f10fa0:	e18aa713 	orr	r10, r10, r3, lsl r7
 3f10fa4:	e2877008 	add	r7, r7, #8	; 0x8
 3f10fa8:	e3570002 	cmp	r7, #2	; 0x2
 3f10fac:	e50b104c 	str	r1, [r11, -#76]
 3f10fb0:	9afffff0 	bls	3f10f78 <inflate_blocks+0x650>
	s->sub.trees.blens[border[s->sub.trees.index++]] = (uInt)b & 7;
 3f10fb4:	e5952008 	ldr	r2, [r5, #8]
 3f10fb8:	e59f33a0 	ldr	r3, [pc, #3a0]	; 3f11360 <inflate_blocks+0xa38>
 3f10fbc:	e7930102 	ldr	r0, [r3, r2, lsl #2]
 3f10fc0:	e20a1007 	and	r1, r10, #7	; 0x7
 3f10fc4:	e595300c 	ldr	r3, [r5, #12]
	DUMPBITS(3)
 3f10fc8:	e1a0a1aa 	mov	r10, r10, lsr #3
 3f10fcc:	e7831100 	str	r1, [r3, r0, lsl #2]
 3f10fd0:	e2477003 	sub	r7, r7, #3	; 0x3
      }
 3f10fd4:	e5953004 	ldr	r3, [r5, #4]
 3f10fd8:	e2822001 	add	r2, r2, #1	; 0x1
 3f10fdc:	e5852008 	str	r2, [r5, #8]
 3f10fe0:	e1a03523 	mov	r3, r3, lsr #10
 3f10fe4:	e2833004 	add	r3, r3, #4	; 0x4
 3f10fe8:	e1520003 	cmp	r2, r3
 3f10fec:	3affffdf 	bcc	3f10f70 <inflate_blocks+0x648>
      while (s->sub.trees.index < 19)
 3f10ff0:	e595c008 	ldr	r12, [r5, #8]
 3f10ff4:	e35c0012 	cmp	r12, #18	; 0x12
 3f10ff8:	8a000009 	bhi	3f11024 <inflate_blocks+0x6fc>
	s->sub.trees.blens[border[s->sub.trees.index++]] = 0;
 3f10ffc:	e59f335c 	ldr	r3, [pc, #35c]	; 3f11360 <inflate_blocks+0xa38>
 3f11000:	e595200c 	ldr	r2, [r5, #12]
 3f11004:	e28c0001 	add	r0, r12, #1	; 0x1
 3f11008:	e793110c 	ldr	r1, [r3, r12, lsl #2]
 3f1100c:	e1a0c000 	mov	r12, r0
 3f11010:	e3a03000 	mov	r3, #0	; 0x0
 3f11014:	e7823101 	str	r3, [r2, r1, lsl #2]
 3f11018:	e35c0012 	cmp	r12, #18	; 0x12
 3f1101c:	e5850008 	str	r0, [r5, #8]
 3f11020:	9afffff5 	bls	3f10ffc <inflate_blocks+0x6d4>
      s->sub.trees.bb = 7;
      t = inflate_trees_bits(s->sub.trees.blens, &s->sub.trees.bb,
 3f11024:	e2851010 	add	r1, r5, #16	; 0x10
 3f11028:	e2852014 	add	r2, r5, #20	; 0x14
 3f1102c:	e1a03006 	mov	r3, r6
 3f11030:	e595000c 	ldr	r0, [r5, #12]
 3f11034:	e3a0c007 	mov	r12, #7	; 0x7
 3f11038:	e585c010 	str	r12, [r5, #16]
 3f1103c:	eb0003e3 	bl	3f11fd0 <inflate_trees_bits>
			     &s->sub.trees.tb, z);
      if (t != Z_OK)
 3f11040:	e2504000 	subs	r4, r0, #0	; 0x0
 3f11044:	0a000014 	beq	3f1109c <inflate_blocks+0x774>
      {
	r = t;
 3f11048:	e50b4048 	str	r4, [r11, -#72]
	if (r == Z_DATA_ERROR)
 3f1104c:	e3740003 	cmn	r4, #3	; 0x3
	  s->mode = BADB;
 3f11050:	03a03009 	moveq	r3, #9	; 0x9
 3f11054:	05853000 	streq	r3, [r5]
	LEAVE
 3f11058:	e585a024 	str	r10, [r5, #36]
 3f1105c:	e5857020 	str	r7, [r5, #32]
 3f11060:	e51b3050 	ldr	r3, [r11, -#80]
 3f11064:	e5863004 	str	r3, [r6, #4]
 3f11068:	e5962000 	ldr	r2, [r6]
 3f1106c:	e51b904c 	ldr	r9, [r11, -#76]
 3f11070:	e5963008 	ldr	r3, [r6, #8]
 3f11074:	e0622009 	rsb	r2, r2, r9
 3f11078:	e5869000 	str	r9, [r6]
 3f1107c:	e0833002 	add	r3, r3, r2
 3f11080:	e5863008 	str	r3, [r6, #8]
 3f11084:	e51b2054 	ldr	r2, [r11, -#84]
 3f11088:	e5852034 	str	r2, [r5, #52]
 3f1108c:	e1a00005 	mov	r0, r5
 3f11090:	e51b2048 	ldr	r2, [r11, -#72]
 3f11094:	e1a01006 	mov	r1, r6
 3f11098:	ea0001d8 	b	3f11800 <inflate_blocks+0xed8>
      }
      s->sub.trees.index = 0;
 3f1109c:	e5854008 	str	r4, [r5, #8]
      Tracev((stderr, "inflate:       bits tree ok\n"));
      s->mode = DTREE;
 3f110a0:	e3a03005 	mov	r3, #5	; 0x5
 3f110a4:	e5853000 	str	r3, [r5]
    case DTREE:
      while (t = s->sub.trees.table,
	     s->sub.trees.index < 258 + (t & 0x1f) + ((t >> 5) & 0x1f))
 3f110a8:	ea000073 	b	3f1127c <inflate_blocks+0x954>
      {
	inflate_huft *h;
	uInt i, j, c;

	t = s->sub.trees.bb;
 3f110ac:	e5954010 	ldr	r4, [r5, #16]
	NEEDBITS(t)
 3f110b0:	e1570004 	cmp	r7, r4
 3f110b4:	2a00000e 	bcs	3f110f4 <inflate_blocks+0x7cc>
 3f110b8:	e51b3050 	ldr	r3, [r11, -#80]
 3f110bc:	e3530000 	cmp	r3, #0	; 0x0
 3f110c0:	0a00019c 	beq	3f11738 <inflate_blocks+0xe10>
 3f110c4:	e3a09000 	mov	r9, #0	; 0x0
 3f110c8:	e50b9048 	str	r9, [r11, -#72]
 3f110cc:	e51b104c 	ldr	r1, [r11, -#76]
 3f110d0:	e51b2050 	ldr	r2, [r11, -#80]
 3f110d4:	e4d13001 	ldrb	r3, [r1], #1
 3f110d8:	e2422001 	sub	r2, r2, #1	; 0x1
 3f110dc:	e50b2050 	str	r2, [r11, -#80]
 3f110e0:	e18aa713 	orr	r10, r10, r3, lsl r7
 3f110e4:	e2877008 	add	r7, r7, #8	; 0x8
 3f110e8:	e1570004 	cmp	r7, r4
 3f110ec:	e50b104c 	str	r1, [r11, -#76]
 3f110f0:	3afffff0 	bcc	3f110b8 <inflate_blocks+0x790>
	h = s->sub.trees.tb + ((uInt)b & inflate_mask[t]);
 3f110f4:	e59f1268 	ldr	r1, [pc, #268]	; 3f11364 <inflate_blocks+0xa3c>
 3f110f8:	e7913104 	ldr	r3, [r1, r4, lsl #2]
 3f110fc:	e5952014 	ldr	r2, [r5, #20]
 3f11100:	e00a3003 	and	r3, r10, r3
 3f11104:	e0822183 	add	r2, r2, r3, lsl #3
	t = h->word.what.Bits;
	c = h->more.Base;
 3f11108:	e592e004 	ldr	r14, [r2, #4]
 3f1110c:	e5d24001 	ldrb	r4, [r2, #1]
	if (c < 16)
 3f11110:	e35e000f 	cmp	r14, #15	; 0xf
 3f11114:	8a000007 	bhi	3f11138 <inflate_blocks+0x810>
	{
	  DUMPBITS(t)
	  s->sub.trees.blens[s->sub.trees.index++] = c;
 3f11118:	e5953008 	ldr	r3, [r5, #8]
 3f1111c:	e1a0a43a 	mov	r10, r10, lsr r4
 3f11120:	e595200c 	ldr	r2, [r5, #12]
 3f11124:	e0647007 	rsb	r7, r4, r7
 3f11128:	e782e103 	str	r14, [r2, r3, lsl #2]
 3f1112c:	e2833001 	add	r3, r3, #1	; 0x1
 3f11130:	e5853008 	str	r3, [r5, #8]
	}
 3f11134:	ea000050 	b	3f1127c <inflate_blocks+0x954>
	else /* c == 16..18 */
	{
	  i = c == 18 ? 7 : c - 14;
 3f11138:	e35e0012 	cmp	r14, #18	; 0x12
 3f1113c:	124e000e 	subne	r0, r14, #14	; 0xe
 3f11140:	03a00007 	moveq	r0, #7	; 0x7
	  j = c == 18 ? 11 : 3;
 3f11144:	13a0c003 	movne	r12, #3	; 0x3
 3f11148:	03a0c00b 	moveq	r12, #11	; 0xb
	  NEEDBITS(t + i)
 3f1114c:	e0842000 	add	r2, r4, r0
 3f11150:	e1570002 	cmp	r7, r2
 3f11154:	2a00000e 	bcs	3f11194 <inflate_blocks+0x86c>
 3f11158:	e51b3050 	ldr	r3, [r11, -#80]
 3f1115c:	e3530000 	cmp	r3, #0	; 0x0
 3f11160:	0a000185 	beq	3f1177c <inflate_blocks+0xe54>
 3f11164:	e3a09000 	mov	r9, #0	; 0x0
 3f11168:	e50b9048 	str	r9, [r11, -#72]
 3f1116c:	e51b904c 	ldr	r9, [r11, -#76]
 3f11170:	e4d93001 	ldrb	r3, [r9], #1
 3f11174:	e18aa713 	orr	r10, r10, r3, lsl r7
 3f11178:	e50b904c 	str	r9, [r11, -#76]
 3f1117c:	e2877008 	add	r7, r7, #8	; 0x8
 3f11180:	e51b9050 	ldr	r9, [r11, -#80]
 3f11184:	e1570002 	cmp	r7, r2
 3f11188:	e2499001 	sub	r9, r9, #1	; 0x1
 3f1118c:	e50b9050 	str	r9, [r11, -#80]
 3f11190:	3afffff0 	bcc	3f11158 <inflate_blocks+0x830>
	  DUMPBITS(t)
 3f11194:	e1a0a43a 	mov	r10, r10, lsr r4
 3f11198:	e0647007 	rsb	r7, r4, r7
	  j += (uInt)b & inflate_mask[i];
 3f1119c:	e7913100 	ldr	r3, [r1, r0, lsl #2]
	  DUMPBITS(i)
 3f111a0:	e0607007 	rsb	r7, r0, r7
	  i = s->sub.trees.index;
	  t = s->sub.trees.table;
 3f111a4:	e5954004 	ldr	r4, [r5, #4]
 3f111a8:	e00a3003 	and	r3, r10, r3
 3f111ac:	e08cc003 	add	r12, r12, r3
 3f111b0:	e1a0a03a 	mov	r10, r10, lsr r0
	  if (i + j > 258 + (t & 0x1f) + ((t >> 5) & 0x1f) ||
 3f111b4:	e1a022a4 	mov	r2, r4, lsr #5
 3f111b8:	e202201f 	and	r2, r2, #31	; 0x1f
 3f111bc:	e2822c01 	add	r2, r2, #256	; 0x100
 3f111c0:	e2822002 	add	r2, r2, #2	; 0x2
 3f111c4:	e204301f 	and	r3, r4, #31	; 0x1f
 3f111c8:	e5950008 	ldr	r0, [r5, #8]
 3f111cc:	e0833002 	add	r3, r3, r2
 3f111d0:	e080100c 	add	r1, r0, r12
 3f111d4:	e1510003 	cmp	r1, r3
 3f111d8:	8a000006 	bhi	3f111f8 <inflate_blocks+0x8d0>
 3f111dc:	e3500000 	cmp	r0, #0	; 0x0
 3f111e0:	13a03000 	movne	r3, #0	; 0x0
 3f111e4:	03a03001 	moveq	r3, #1	; 0x1
 3f111e8:	e35e0010 	cmp	r14, #16	; 0x10
 3f111ec:	13a03000 	movne	r3, #0	; 0x0
 3f111f0:	e3530000 	cmp	r3, #0	; 0x0
 3f111f4:	0a000015 	beq	3f11250 <inflate_blocks+0x928>
	      (c == 16 && i < 1))
	  {
	    s->mode = BADB;
 3f111f8:	e3a03009 	mov	r3, #9	; 0x9
 3f111fc:	e5853000 	str	r3, [r5]
	    z->msg = "invalid bit length repeat";
 3f11200:	e59f3160 	ldr	r3, [pc, #160]	; 3f11368 <inflate_blocks+0xa40>
 3f11204:	e5863018 	str	r3, [r6, #24]
	    r = Z_DATA_ERROR;
	    LEAVE
 3f11208:	e585a024 	str	r10, [r5, #36]
 3f1120c:	e5857020 	str	r7, [r5, #32]
 3f11210:	e51b1050 	ldr	r1, [r11, -#80]
 3f11214:	e5861004 	str	r1, [r6, #4]
 3f11218:	e51b304c 	ldr	r3, [r11, -#76]
 3f1121c:	e5962000 	ldr	r2, [r6]
 3f11220:	e5863000 	str	r3, [r6]
 3f11224:	e51b904c 	ldr	r9, [r11, -#76]
 3f11228:	e5963008 	ldr	r3, [r6, #8]
 3f1122c:	e0622009 	rsb	r2, r2, r9
 3f11230:	e0833002 	add	r3, r3, r2
 3f11234:	e5863008 	str	r3, [r6, #8]
 3f11238:	e1a00005 	mov	r0, r5
 3f1123c:	e51b2054 	ldr	r2, [r11, -#84]
 3f11240:	e1a01006 	mov	r1, r6
 3f11244:	e5852034 	str	r2, [r5, #52]
 3f11248:	e3e02002 	mvn	r2, #2	; 0x2
 3f1124c:	ea00016b 	b	3f11800 <inflate_blocks+0xed8>
	  }
	  c = c == 16 ? s->sub.trees.blens[i - 1] : 0;
 3f11250:	e35e0010 	cmp	r14, #16	; 0x10
 3f11254:	0595300c 	ldreq	r3, [r5, #12]
 3f11258:	00833100 	addeq	r3, r3, r0, lsl #2
 3f1125c:	05132004 	ldreq	r2, [r3, -#4]
 3f11260:	11a02003 	movne	r2, r3
	  do {
	    s->sub.trees.blens[i++] = c;
 3f11264:	e595300c 	ldr	r3, [r5, #12]
	  } while (--j);
 3f11268:	e25cc001 	subs	r12, r12, #1	; 0x1
 3f1126c:	e7832100 	str	r2, [r3, r0, lsl #2]
 3f11270:	e2800001 	add	r0, r0, #1	; 0x1
 3f11274:	1afffffa 	bne	3f11264 <inflate_blocks+0x93c>
	  s->sub.trees.index = i;
 3f11278:	e5850008 	str	r0, [r5, #8]
 3f1127c:	e5954004 	ldr	r4, [r5, #4]
 3f11280:	e5951008 	ldr	r1, [r5, #8]
 3f11284:	e1a032a4 	mov	r3, r4, lsr #5
 3f11288:	e203301f 	and	r3, r3, #31	; 0x1f
 3f1128c:	e2833c01 	add	r3, r3, #256	; 0x100
 3f11290:	e2833002 	add	r3, r3, #2	; 0x2
 3f11294:	e204201f 	and	r2, r4, #31	; 0x1f
 3f11298:	e0822003 	add	r2, r2, r3
 3f1129c:	e1510002 	cmp	r1, r2
 3f112a0:	3affff81 	bcc	3f110ac <inflate_blocks+0x784>
	}
      }
      inflate_trees_free(s->sub.trees.tb, z);
 3f112a4:	e5950014 	ldr	r0, [r5, #20]
 3f112a8:	e1a01006 	mov	r1, r6
 3f112ac:	eb000450 	bl	3f123f4 <inflate_trees_free>
      s->sub.trees.tb = Z_NULL;
 3f112b0:	e3a03000 	mov	r3, #0	; 0x0
 3f112b4:	e5853014 	str	r3, [r5, #20]
      {
	uInt bl, bd;
	inflate_huft *tl, *td;
	inflate_codes_statef *c;

	bl = 9;         /* must be <= 9 for lookahead assumptions */
 3f112b8:	e3a09009 	mov	r9, #9	; 0x9
 3f112bc:	e50b9038 	str	r9, [r11, -#56]
	bd = 6;         /* must be <= 9 for lookahead assumptions */
 3f112c0:	e2833006 	add	r3, r3, #6	; 0x6
 3f112c4:	e50b303c 	str	r3, [r11, -#60]
	t = s->sub.trees.table;
 3f112c8:	e5954004 	ldr	r4, [r5, #4]
	t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f),
 3f112cc:	e24b303c 	sub	r3, r11, #60	; 0x3c
 3f112d0:	e58d3000 	str	r3, [r13]
 3f112d4:	e24b3040 	sub	r3, r11, #64	; 0x40
 3f112d8:	e58d3004 	str	r3, [r13, #4]
 3f112dc:	e24b3044 	sub	r3, r11, #68	; 0x44
 3f112e0:	e58d3008 	str	r3, [r13, #8]
 3f112e4:	e24b3038 	sub	r3, r11, #56	; 0x38
 3f112e8:	e58d600c 	str	r6, [r13, #12]
 3f112ec:	e204001f 	and	r0, r4, #31	; 0x1f
 3f112f0:	e2800c01 	add	r0, r0, #256	; 0x100
 3f112f4:	e2800001 	add	r0, r0, #1	; 0x1
 3f112f8:	e1a012a4 	mov	r1, r4, lsr #5
 3f112fc:	e201101f 	and	r1, r1, #31	; 0x1f
 3f11300:	e595200c 	ldr	r2, [r5, #12]
 3f11304:	e2811001 	add	r1, r1, #1	; 0x1
 3f11308:	eb00034f 	bl	3f1204c <inflate_trees_dynamic>
				  s->sub.trees.blens, &bl, &bd, &tl, &td, z);
	if (t != Z_OK)
 3f1130c:	e2504000 	subs	r4, r0, #0	; 0x0
 3f11310:	0a000015 	beq	3f1136c <inflate_blocks+0xa44>
	{
	  if (t == (uInt)Z_DATA_ERROR)
 3f11314:	e3740003 	cmn	r4, #3	; 0x3
	    s->mode = BADB;
 3f11318:	05859000 	streq	r9, [r5]
	  r = t;
	  LEAVE
 3f1131c:	e585a024 	str	r10, [r5, #36]
 3f11320:	e5857020 	str	r7, [r5, #32]
 3f11324:	e51b9050 	ldr	r9, [r11, -#80]
 3f11328:	e5869004 	str	r9, [r6, #4]
 3f1132c:	e5962000 	ldr	r2, [r6]
 3f11330:	e51b104c 	ldr	r1, [r11, -#76]
 3f11334:	e5963008 	ldr	r3, [r6, #8]
 3f11338:	e0622001 	rsb	r2, r2, r1
 3f1133c:	e5861000 	str	r1, [r6]
 3f11340:	e0833002 	add	r3, r3, r2
 3f11344:	e5863008 	str	r3, [r6, #8]
 3f11348:	e1a00005 	mov	r0, r5
 3f1134c:	e51b2054 	ldr	r2, [r11, -#84]
 3f11350:	e1a01006 	mov	r1, r6
 3f11354:	e5852034 	str	r2, [r5, #52]
 3f11358:	e1a02004 	mov	r2, r4
 3f1135c:	ea000127 	b	3f11800 <inflate_blocks+0xed8>
 3f11360:	03f20e14 	mvneqs	r0, #320	; 0x140
 3f11364:	03f20dd0 	mvneqs	r0, #13312	; 0x3400
 3f11368:	03f1f730 	mvneqs	r15, #12582912	; 0xc00000
	}
	Tracev((stderr, "inflate:       trees ok\n"));
	if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL)
 3f1136c:	e58d6000 	str	r6, [r13]
 3f11370:	e51b0038 	ldr	r0, [r11, -#56]
 3f11374:	e51b103c 	ldr	r1, [r11, -#60]
 3f11378:	e51b2040 	ldr	r2, [r11, -#64]
 3f1137c:	e51b3044 	ldr	r3, [r11, -#68]
 3f11380:	eb00042d 	bl	3f1243c <inflate_codes_new>
 3f11384:	e2504000 	subs	r4, r0, #0	; 0x0
 3f11388:	1a000016 	bne	3f113e8 <inflate_blocks+0xac0>
	{
	  inflate_trees_free(td, z);
 3f1138c:	e51b0044 	ldr	r0, [r11, -#68]
 3f11390:	e1a01006 	mov	r1, r6
 3f11394:	eb000416 	bl	3f123f4 <inflate_trees_free>
	  inflate_trees_free(tl, z);
 3f11398:	e51b0040 	ldr	r0, [r11, -#64]
 3f1139c:	e1a01006 	mov	r1, r6
 3f113a0:	eb000413 	bl	3f123f4 <inflate_trees_free>
	  r = Z_MEM_ERROR;
	  LEAVE
 3f113a4:	e585a024 	str	r10, [r5, #36]
 3f113a8:	e5857020 	str	r7, [r5, #32]
 3f113ac:	e51b3050 	ldr	r3, [r11, -#80]
 3f113b0:	e5863004 	str	r3, [r6, #4]
 3f113b4:	e5962000 	ldr	r2, [r6]
 3f113b8:	e51b904c 	ldr	r9, [r11, -#76]
 3f113bc:	e5963008 	ldr	r3, [r6, #8]
 3f113c0:	e0622009 	rsb	r2, r2, r9
 3f113c4:	e5869000 	str	r9, [r6]
 3f113c8:	e0833002 	add	r3, r3, r2
 3f113cc:	e5863008 	str	r3, [r6, #8]
 3f113d0:	e1a00005 	mov	r0, r5
 3f113d4:	e51b2054 	ldr	r2, [r11, -#84]
 3f113d8:	e1a01006 	mov	r1, r6
 3f113dc:	e5852034 	str	r2, [r5, #52]
 3f113e0:	e3e02003 	mvn	r2, #3	; 0x3
 3f113e4:	ea000105 	b	3f11800 <inflate_blocks+0xed8>
	}
	ZFREE(z, s->sub.trees.blens, s->sub.trees.nblens * sizeof(uInt));
 3f113e8:	e5960028 	ldr	r0, [r6, #40]
 3f113ec:	e5952018 	ldr	r2, [r5, #24]
 3f113f0:	e595100c 	ldr	r1, [r5, #12]
 3f113f4:	e1a02102 	mov	r2, r2, lsl #2
 3f113f8:	e1a0e00f 	mov	r14, r15
 3f113fc:	e596f024 	ldr	r15, [r6, #36]
	s->sub.decode.codes = c;
 3f11400:	e585400c 	str	r4, [r5, #12]
	s->sub.decode.tl = tl;
	s->sub.decode.td = td;
      }
      s->mode = CODES;
 3f11404:	e3a03006 	mov	r3, #6	; 0x6
 3f11408:	e5853000 	str	r3, [r5]
 3f1140c:	e51b3040 	ldr	r3, [r11, -#64]
 3f11410:	e5853004 	str	r3, [r5, #4]
 3f11414:	e51b3044 	ldr	r3, [r11, -#68]
 3f11418:	e5853008 	str	r3, [r5, #8]
    case CODES:
      UPDATE
 3f1141c:	e585a024 	str	r10, [r5, #36]
 3f11420:	e5857020 	str	r7, [r5, #32]
 3f11424:	e51b9050 	ldr	r9, [r11, -#80]
 3f11428:	e5869004 	str	r9, [r6, #4]
 3f1142c:	e5962000 	ldr	r2, [r6]
 3f11430:	e51b104c 	ldr	r1, [r11, -#76]
 3f11434:	e5963008 	ldr	r3, [r6, #8]
 3f11438:	e0622001 	rsb	r2, r2, r1
 3f1143c:	e5861000 	str	r1, [r6]
 3f11440:	e0833002 	add	r3, r3, r2
 3f11444:	e5863008 	str	r3, [r6, #8]
 3f11448:	e51b2054 	ldr	r2, [r11, -#84]
 3f1144c:	e5852034 	str	r2, [r5, #52]
      if ((r = inflate_codes(s, z, r)) != Z_STREAM_END)
 3f11450:	e1a00005 	mov	r0, r5
 3f11454:	e51b2048 	ldr	r2, [r11, -#72]
 3f11458:	e1a01006 	mov	r1, r6
 3f1145c:	eb00040c 	bl	3f12494 <inflate_codes>
 3f11460:	e50b0048 	str	r0, [r11, -#72]
 3f11464:	e3500001 	cmp	r0, #1	; 0x1
	return inflate_flush(s, z, r);
 3f11468:	11a00005 	movne	r0, r5
 3f1146c:	151b2048 	ldrne	r2, [r11, -#72]
 3f11470:	11a01006 	movne	r1, r6
 3f11474:	1a0000e1 	bne	3f11800 <inflate_blocks+0xed8>
      r = Z_OK;
      inflate_codes_free(s->sub.decode.codes, z);
 3f11478:	e595000c 	ldr	r0, [r5, #12]
 3f1147c:	e1a01006 	mov	r1, r6
 3f11480:	eb000623 	bl	3f12d14 <inflate_codes_free>
      inflate_trees_free(s->sub.decode.td, z);
 3f11484:	e5950008 	ldr	r0, [r5, #8]
 3f11488:	e1a01006 	mov	r1, r6
 3f1148c:	eb0003d8 	bl	3f123f4 <inflate_trees_free>
      inflate_trees_free(s->sub.decode.tl, z);
 3f11490:	e5950004 	ldr	r0, [r5, #4]
 3f11494:	e1a01006 	mov	r1, r6
 3f11498:	eb0003d5 	bl	3f123f4 <inflate_trees_free>
      LOAD
 3f1149c:	e5963000 	ldr	r3, [r6]
 3f114a0:	e50b304c 	str	r3, [r11, -#76]
 3f114a4:	e5969004 	ldr	r9, [r6, #4]
 3f114a8:	e50b9050 	str	r9, [r11, -#80]
 3f114ac:	e5951034 	ldr	r1, [r5, #52]
 3f114b0:	e595a024 	ldr	r10, [r5, #36]
 3f114b4:	e50b1054 	str	r1, [r11, -#84]
 3f114b8:	e5953030 	ldr	r3, [r5, #48]
 3f114bc:	e3a02000 	mov	r2, #0	; 0x0
 3f114c0:	e50b2048 	str	r2, [r11, -#72]
 3f114c4:	e1510003 	cmp	r1, r3
 3f114c8:	e5957020 	ldr	r7, [r5, #32]
 3f114cc:	30613003 	rsbcc	r3, r1, r3
 3f114d0:	32439001 	subcc	r9, r3, #1	; 0x1
 3f114d4:	2595302c 	ldrcs	r3, [r5, #44]
 3f114d8:	251b1054 	ldrcs	r1, [r11, -#84]
 3f114dc:	20619003 	rsbcs	r9, r1, r3
      Tracev((stderr, "inflate:       codes end, %lu total out\n",
	      z->total_out + (q >= s->read ? q - s->read :
	      (s->end - s->read) + (q - s->window))));
      if (!s->last)
 3f114e0:	e595301c 	ldr	r3, [r5, #28]
 3f114e4:	e3530000 	cmp	r3, #0	; 0x0
      {
	s->mode = TYPE;
 3f114e8:	05853000 	streq	r3, [r5]
	break;
 3f114ec:	0afffd23 	beq	3f10980 <inflate_blocks+0x58>
      }
      if (k > 7)              /* return unused byte, if any */
 3f114f0:	e3570007 	cmp	r7, #7	; 0x7
 3f114f4:	9a000006 	bls	3f11514 <inflate_blocks+0xbec>
      {
	Assert(k < 16, "inflate_codes grabbed too many bytes")
	k -= 8;
	n++;
 3f114f8:	e51b2050 	ldr	r2, [r11, -#80]
 3f114fc:	e2477008 	sub	r7, r7, #8	; 0x8
	p--;                    /* can always return one */
 3f11500:	e51b304c 	ldr	r3, [r11, -#76]
 3f11504:	e2822001 	add	r2, r2, #1	; 0x1
 3f11508:	e50b2050 	str	r2, [r11, -#80]
 3f1150c:	e2433001 	sub	r3, r3, #1	; 0x1
 3f11510:	e50b304c 	str	r3, [r11, -#76]
      }
      s->mode = DRY;
 3f11514:	e3a03007 	mov	r3, #7	; 0x7
 3f11518:	e5853000 	str	r3, [r5]
    case DRY:
      FLUSH
 3f1151c:	e51b9054 	ldr	r9, [r11, -#84]
 3f11520:	e5859034 	str	r9, [r5, #52]
 3f11524:	e1a00005 	mov	r0, r5
 3f11528:	e51b2048 	ldr	r2, [r11, -#72]
 3f1152c:	e1a01006 	mov	r1, r6
 3f11530:	eb000601 	bl	3f12d3c <inflate_flush>
 3f11534:	e5951034 	ldr	r1, [r5, #52]
 3f11538:	e50b1054 	str	r1, [r11, -#84]
 3f1153c:	e5953030 	ldr	r3, [r5, #48]
 3f11540:	e50b0048 	str	r0, [r11, -#72]
 3f11544:	e1510003 	cmp	r1, r3
      if (s->read != s->write)
 3f11548:	e51b2054 	ldr	r2, [r11, -#84]
 3f1154c:	e1530002 	cmp	r3, r2
 3f11550:	0a000010 	beq	3f11598 <inflate_blocks+0xc70>
	LEAVE
 3f11554:	e585a024 	str	r10, [r5, #36]
 3f11558:	e5857020 	str	r7, [r5, #32]
 3f1155c:	e51b3050 	ldr	r3, [r11, -#80]
 3f11560:	e5863004 	str	r3, [r6, #4]
 3f11564:	e5962000 	ldr	r2, [r6]
 3f11568:	e51b904c 	ldr	r9, [r11, -#76]
 3f1156c:	e5963008 	ldr	r3, [r6, #8]
 3f11570:	e0622009 	rsb	r2, r2, r9
 3f11574:	e5869000 	str	r9, [r6]
 3f11578:	e0833002 	add	r3, r3, r2
 3f1157c:	e5863008 	str	r3, [r6, #8]
 3f11580:	e51b2054 	ldr	r2, [r11, -#84]
 3f11584:	e5852034 	str	r2, [r5, #52]
 3f11588:	e1a00005 	mov	r0, r5
 3f1158c:	e51b2048 	ldr	r2, [r11, -#72]
 3f11590:	e1a01006 	mov	r1, r6
 3f11594:	ea000099 	b	3f11800 <inflate_blocks+0xed8>
      s->mode = DONEB;
 3f11598:	e3a03008 	mov	r3, #8	; 0x8
 3f1159c:	e5853000 	str	r3, [r5]
    case DONEB:
      r = Z_STREAM_END;
      LEAVE
 3f115a0:	e585a024 	str	r10, [r5, #36]
 3f115a4:	e5857020 	str	r7, [r5, #32]
 3f115a8:	e51b3050 	ldr	r3, [r11, -#80]
 3f115ac:	e5863004 	str	r3, [r6, #4]
 3f115b0:	e5962000 	ldr	r2, [r6]
 3f115b4:	e51b904c 	ldr	r9, [r11, -#76]
 3f115b8:	e5963008 	ldr	r3, [r6, #8]
 3f115bc:	e0622009 	rsb	r2, r2, r9
 3f115c0:	e5869000 	str	r9, [r6]
 3f115c4:	e0833002 	add	r3, r3, r2
 3f115c8:	e5863008 	str	r3, [r6, #8]
 3f115cc:	e1a00005 	mov	r0, r5
 3f115d0:	e51b2054 	ldr	r2, [r11, -#84]
 3f115d4:	e1a01006 	mov	r1, r6
 3f115d8:	e5852034 	str	r2, [r5, #52]
 3f115dc:	e3a02001 	mov	r2, #1	; 0x1
 3f115e0:	ea000086 	b	3f11800 <inflate_blocks+0xed8>
    case BADB:
      r = Z_DATA_ERROR;
      LEAVE
 3f115e4:	e585a024 	str	r10, [r5, #36]
 3f115e8:	e5857020 	str	r7, [r5, #32]
 3f115ec:	e51b3050 	ldr	r3, [r11, -#80]
 3f115f0:	e5863004 	str	r3, [r6, #4]
 3f115f4:	e5962000 	ldr	r2, [r6]
 3f115f8:	e51b904c 	ldr	r9, [r11, -#76]
 3f115fc:	e5963008 	ldr	r3, [r6, #8]
 3f11600:	e0622009 	rsb	r2, r2, r9
 3f11604:	e5869000 	str	r9, [r6]
 3f11608:	e0833002 	add	r3, r3, r2
 3f1160c:	e5863008 	str	r3, [r6, #8]
 3f11610:	e1a00005 	mov	r0, r5
 3f11614:	e51b2054 	ldr	r2, [r11, -#84]
 3f11618:	e1a01006 	mov	r1, r6
 3f1161c:	e5852034 	str	r2, [r5, #52]
 3f11620:	e3e02002 	mvn	r2, #2	; 0x2
 3f11624:	ea000075 	b	3f11800 <inflate_blocks+0xed8>
 3f11628:	e585a024 	str	r10, [r5, #36]
 3f1162c:	e5857020 	str	r7, [r5, #32]
 3f11630:	e51b3050 	ldr	r3, [r11, -#80]
 3f11634:	e5863004 	str	r3, [r6, #4]
 3f11638:	e5962000 	ldr	r2, [r6]
 3f1163c:	e51b904c 	ldr	r9, [r11, -#76]
 3f11640:	e5963008 	ldr	r3, [r6, #8]
 3f11644:	e0622009 	rsb	r2, r2, r9
 3f11648:	e5869000 	str	r9, [r6]
 3f1164c:	e0833002 	add	r3, r3, r2
 3f11650:	e5863008 	str	r3, [r6, #8]
 3f11654:	e51b2054 	ldr	r2, [r11, -#84]
 3f11658:	e5852034 	str	r2, [r5, #52]
 3f1165c:	e1a00005 	mov	r0, r5
 3f11660:	e51b2048 	ldr	r2, [r11, -#72]
 3f11664:	e1a01006 	mov	r1, r6
 3f11668:	ea000064 	b	3f11800 <inflate_blocks+0xed8>
 3f1166c:	e585a024 	str	r10, [r5, #36]
 3f11670:	e5857020 	str	r7, [r5, #32]
 3f11674:	e51b3050 	ldr	r3, [r11, -#80]
 3f11678:	e5863004 	str	r3, [r6, #4]
 3f1167c:	e5962000 	ldr	r2, [r6]
 3f11680:	e51b904c 	ldr	r9, [r11, -#76]
 3f11684:	e5963008 	ldr	r3, [r6, #8]
 3f11688:	e0622009 	rsb	r2, r2, r9
 3f1168c:	e5869000 	str	r9, [r6]
 3f11690:	e0833002 	add	r3, r3, r2
 3f11694:	e5863008 	str	r3, [r6, #8]
 3f11698:	e51b2054 	ldr	r2, [r11, -#84]
 3f1169c:	e5852034 	str	r2, [r5, #52]
 3f116a0:	e1a00005 	mov	r0, r5
 3f116a4:	e51b2048 	ldr	r2, [r11, -#72]
 3f116a8:	e1a01006 	mov	r1, r6
 3f116ac:	ea000053 	b	3f11800 <inflate_blocks+0xed8>
 3f116b0:	e585a024 	str	r10, [r5, #36]
 3f116b4:	e5857020 	str	r7, [r5, #32]
 3f116b8:	e51b3050 	ldr	r3, [r11, -#80]
 3f116bc:	e5863004 	str	r3, [r6, #4]
 3f116c0:	e5962000 	ldr	r2, [r6]
 3f116c4:	e51b904c 	ldr	r9, [r11, -#76]
 3f116c8:	e5963008 	ldr	r3, [r6, #8]
 3f116cc:	e0622009 	rsb	r2, r2, r9
 3f116d0:	e5869000 	str	r9, [r6]
 3f116d4:	e0833002 	add	r3, r3, r2
 3f116d8:	e5863008 	str	r3, [r6, #8]
 3f116dc:	e51b2054 	ldr	r2, [r11, -#84]
 3f116e0:	e5852034 	str	r2, [r5, #52]
 3f116e4:	e1a00005 	mov	r0, r5
 3f116e8:	e51b2048 	ldr	r2, [r11, -#72]
 3f116ec:	e1a01006 	mov	r1, r6
 3f116f0:	ea000042 	b	3f11800 <inflate_blocks+0xed8>
 3f116f4:	e585a024 	str	r10, [r5, #36]
 3f116f8:	e5857020 	str	r7, [r5, #32]
 3f116fc:	e51b3050 	ldr	r3, [r11, -#80]
 3f11700:	e5863004 	str	r3, [r6, #4]
 3f11704:	e5962000 	ldr	r2, [r6]
 3f11708:	e51b904c 	ldr	r9, [r11, -#76]
 3f1170c:	e5963008 	ldr	r3, [r6, #8]
 3f11710:	e0622009 	rsb	r2, r2, r9
 3f11714:	e5869000 	str	r9, [r6]
 3f11718:	e0833002 	add	r3, r3, r2
 3f1171c:	e5863008 	str	r3, [r6, #8]
 3f11720:	e51b2054 	ldr	r2, [r11, -#84]
 3f11724:	e5852034 	str	r2, [r5, #52]
 3f11728:	e1a00005 	mov	r0, r5
 3f1172c:	e51b2048 	ldr	r2, [r11, -#72]
 3f11730:	e1a01006 	mov	r1, r6
 3f11734:	ea000031 	b	3f11800 <inflate_blocks+0xed8>
 3f11738:	e585a024 	str	r10, [r5, #36]
 3f1173c:	e5857020 	str	r7, [r5, #32]
 3f11740:	e51b3050 	ldr	r3, [r11, -#80]
 3f11744:	e5863004 	str	r3, [r6, #4]
 3f11748:	e5962000 	ldr	r2, [r6]
 3f1174c:	e51b904c 	ldr	r9, [r11, -#76]
 3f11750:	e5963008 	ldr	r3, [r6, #8]
 3f11754:	e0622009 	rsb	r2, r2, r9
 3f11758:	e5869000 	str	r9, [r6]
 3f1175c:	e0833002 	add	r3, r3, r2
 3f11760:	e5863008 	str	r3, [r6, #8]
 3f11764:	e51b2054 	ldr	r2, [r11, -#84]
 3f11768:	e5852034 	str	r2, [r5, #52]
 3f1176c:	e1a00005 	mov	r0, r5
 3f11770:	e51b2048 	ldr	r2, [r11, -#72]
 3f11774:	e1a01006 	mov	r1, r6
 3f11778:	ea000020 	b	3f11800 <inflate_blocks+0xed8>
 3f1177c:	e585a024 	str	r10, [r5, #36]
 3f11780:	e5857020 	str	r7, [r5, #32]
 3f11784:	e51b3050 	ldr	r3, [r11, -#80]
 3f11788:	e5863004 	str	r3, [r6, #4]
 3f1178c:	e5962000 	ldr	r2, [r6]
 3f11790:	e51b904c 	ldr	r9, [r11, -#76]
 3f11794:	e5963008 	ldr	r3, [r6, #8]
 3f11798:	e0622009 	rsb	r2, r2, r9
 3f1179c:	e5869000 	str	r9, [r6]
 3f117a0:	e0833002 	add	r3, r3, r2
 3f117a4:	e5863008 	str	r3, [r6, #8]
 3f117a8:	e51b2054 	ldr	r2, [r11, -#84]
 3f117ac:	e5852034 	str	r2, [r5, #52]
 3f117b0:	e1a00005 	mov	r0, r5
 3f117b4:	e51b2048 	ldr	r2, [r11, -#72]
 3f117b8:	e1a01006 	mov	r1, r6
 3f117bc:	ea00000f 	b	3f11800 <inflate_blocks+0xed8>
    default:
      r = Z_STREAM_ERROR;
      LEAVE
 3f117c0:	e585a024 	str	r10, [r5, #36]
 3f117c4:	e5857020 	str	r7, [r5, #32]
 3f117c8:	e51b3050 	ldr	r3, [r11, -#80]
 3f117cc:	e5863004 	str	r3, [r6, #4]
 3f117d0:	e5962000 	ldr	r2, [r6]
 3f117d4:	e51b904c 	ldr	r9, [r11, -#76]
 3f117d8:	e5963008 	ldr	r3, [r6, #8]
 3f117dc:	e0622009 	rsb	r2, r2, r9
 3f117e0:	e5869000 	str	r9, [r6]
 3f117e4:	e0833002 	add	r3, r3, r2
 3f117e8:	e5863008 	str	r3, [r6, #8]
 3f117ec:	e1a00005 	mov	r0, r5
 3f117f0:	e51b2054 	ldr	r2, [r11, -#84]
 3f117f4:	e1a01006 	mov	r1, r6
 3f117f8:	e5852034 	str	r2, [r5, #52]
 3f117fc:	e3e02001 	mvn	r2, #1	; 0x1
 3f11800:	eb00054d 	bl	3f12d3c <inflate_flush>
  }
}
 3f11804:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f11808 <inflate_blocks_free>:
 3f11808:	e1a0c00d 	mov	r12, r13
 3f1180c:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f11810:	e24cb004 	sub	r11, r12, #4	; 0x4


local int inflate_blocks_free(s, z, c)
inflate_blocks_statef *s;
z_stream *z;
uLongf *c;
{
 3f11814:	e1a04000 	mov	r4, r0
 3f11818:	e1a05001 	mov	r5, r1
  inflate_blocks_reset(s, z, c);
 3f1181c:	ebfffbe1 	bl	3f107a8 <inflate_blocks_reset>
  ZFREE(z, s->window, s->end - s->window);
 3f11820:	e5950028 	ldr	r0, [r5, #40]
 3f11824:	e5941028 	ldr	r1, [r4, #40]
 3f11828:	e284302c 	add	r3, r4, #44	; 0x2c
 3f1182c:	e813000c 	ldmda	r3, {r2, r3}
 3f11830:	e0432002 	sub	r2, r3, r2
 3f11834:	e1a0e00f 	mov	r14, r15
 3f11838:	e595f024 	ldr	r15, [r5, #36]
  ZFREE(z, s, sizeof(struct inflate_blocks_state));
 3f1183c:	e1a01004 	mov	r1, r4
 3f11840:	e5950028 	ldr	r0, [r5, #40]
 3f11844:	e3a02040 	mov	r2, #64	; 0x40
 3f11848:	e1a0e00f 	mov	r14, r15
 3f1184c:	e595f024 	ldr	r15, [r5, #36]
  Trace((stderr, "inflate:   blocks freed\n"));
  return Z_OK;
 3f11850:	e3a00000 	mov	r0, #0	; 0x0
 3f11854:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f11858 <inflate_addhistory>:
 3f11858:	e1a0c00d 	mov	r12, r13
 3f1185c:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
}

/*
 * This subroutine adds the data at next_in/avail_in to the output history
 * without performing any output.  The output buffer must be "caught up";
 * i.e. no pending output (hence s->read equals s->write), and the state must
 * be BLOCKS (i.e. we should be willing to see the start of a series of
 * BLOCKS).  On exit, the output will also be caught up, and the checksum
 * will have been updated if need be.
 */
local int inflate_addhistory(s, z)
inflate_blocks_statef *s;
z_stream *z;
{
 3f11860:	e1a04000 	mov	r4, r0
 3f11864:	e24dd00c 	sub	r13, r13, #12	; 0xc
    uLong b;              /* bit buffer */  /* NOT USED HERE */
    uInt k;               /* bits in bit buffer */ /* NOT USED HERE */
    uInt t;               /* temporary storage */
    Bytef *p;             /* input data pointer */
    uInt n;               /* bytes available there */
    Bytef *q;             /* output window write pointer */
    uInt m;               /* bytes to end of window or read pointer */

    if (s->read != s->write)
 3f11868:	e5940030 	ldr	r0, [r4, #48]
 3f1186c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f11870:	e5943034 	ldr	r3, [r4, #52]
 3f11874:	e1a07001 	mov	r7, r1
 3f11878:	e1500003 	cmp	r0, r3
	return Z_STREAM_ERROR;
 3f1187c:	13e00001 	mvnne	r0, #1	; 0x1
 3f11880:	1a000042 	bne	3f11990 <inflate_addhistory+0x138>
    if (s->mode != TYPE)
 3f11884:	e5943000 	ldr	r3, [r4]
 3f11888:	e3530000 	cmp	r3, #0	; 0x0
	return Z_DATA_ERROR;
 3f1188c:	13e00002 	mvnne	r0, #2	; 0x2
 3f11890:	1a00003e 	bne	3f11990 <inflate_addhistory+0x138>

    /* we're ready to rock */
    LOAD
 3f11894:	e5979000 	ldr	r9, [r7]
 3f11898:	e594302c 	ldr	r3, [r4, #44]
 3f1189c:	e1a06000 	mov	r6, r0
 3f118a0:	e597a004 	ldr	r10, [r7, #4]
 3f118a4:	e0663003 	rsb	r3, r6, r3
 3f118a8:	e50b3030 	str	r3, [r11, -#48]
 3f118ac:	e5943024 	ldr	r3, [r4, #36]
 3f118b0:	e50b3028 	str	r3, [r11, -#40]
 3f118b4:	e5943020 	ldr	r3, [r4, #32]
    /* while there is input ready, copy to output buffer, moving
     * pointers as needed.
     */
    while (n) {
 3f118b8:	e35a0000 	cmp	r10, #0	; 0x0
 3f118bc:	e50b302c 	str	r3, [r11, -#44]
 3f118c0:	0a000025 	beq	3f1195c <inflate_addhistory+0x104>
	t = n;  /* how many to do */
	/* is there room until end of buffer? */
	if (t > m) t = m;
 3f118c4:	e51b5030 	ldr	r5, [r11, -#48]
	/* update check information */
	if (s->checkfn != Z_NULL)
 3f118c8:	e5943038 	ldr	r3, [r4, #56]
 3f118cc:	e15a0005 	cmp	r10, r5
 3f118d0:	31a0500a 	movcc	r5, r10
 3f118d4:	e3530000 	cmp	r3, #0	; 0x0
 3f118d8:	0a000005 	beq	3f118f4 <inflate_addhistory+0x9c>
	    s->check = (*s->checkfn)(s->check, q, t);
 3f118dc:	e1a01006 	mov	r1, r6
 3f118e0:	e594003c 	ldr	r0, [r4, #60]
 3f118e4:	e1a02005 	mov	r2, r5
 3f118e8:	e1a0e00f 	mov	r14, r15
 3f118ec:	e1a0f003 	mov	r15, r3
 3f118f0:	e584003c 	str	r0, [r4, #60]
	/* output callback */
	if (z->outcb != Z_NULL)
 3f118f4:	e5973030 	ldr	r3, [r7, #48]
 3f118f8:	e3530000 	cmp	r3, #0	; 0x0
 3f118fc:	0a000003 	beq	3f11910 <inflate_addhistory+0xb8>
	    (*z->outcb)(q, t);
 3f11900:	e1a00006 	mov	r0, r6
 3f11904:	e1a01005 	mov	r1, r5
 3f11908:	e1a0e00f 	mov	r14, r15
 3f1190c:	e1a0f003 	mov	r15, r3
	zmemcpy(q, p, t);
 3f11910:	e1a00006 	mov	r0, r6
 3f11914:	e1a01009 	mov	r1, r9
 3f11918:	e1a02005 	mov	r2, r5
 3f1191c:	ebfff719 	bl	3f0f588 <memcpy>
	q += t;
	p += t;
	n -= t;
	z->total_out += t;
 3f11920:	e5973014 	ldr	r3, [r7, #20]
 3f11924:	e0866005 	add	r6, r6, r5
 3f11928:	e0833005 	add	r3, r3, r5
 3f1192c:	e5873014 	str	r3, [r7, #20]
 3f11930:	e0899005 	add	r9, r9, r5
	s->read = q;    /* drag read pointer forward */
/*      WRAP  */ 	/* expand WRAP macro by hand to handle s->read */
	if (q == s->end) {
 3f11934:	e594302c 	ldr	r3, [r4, #44]
 3f11938:	e065a00a 	rsb	r10, r5, r10
 3f1193c:	e5846030 	str	r6, [r4, #48]
 3f11940:	e1560003 	cmp	r6, r3
	    s->read = q = s->window;
 3f11944:	05946028 	ldreq	r6, [r4, #40]
	    m = WAVAIL;
 3f11948:	00663003 	rsbeq	r3, r6, r3
 3f1194c:	050b3030 	streq	r3, [r11, -#48]
 3f11950:	05846030 	streq	r6, [r4, #48]
	}
    }
 3f11954:	e35a0000 	cmp	r10, #0	; 0x0
 3f11958:	1affffd9 	bne	3f118c4 <inflate_addhistory+0x6c>
    UPDATE
 3f1195c:	e51b3028 	ldr	r3, [r11, -#40]
 3f11960:	e5843024 	str	r3, [r4, #36]
 3f11964:	e51b302c 	ldr	r3, [r11, -#44]
 3f11968:	e5843020 	str	r3, [r4, #32]
 3f1196c:	e587a004 	str	r10, [r7, #4]
 3f11970:	e5972000 	ldr	r2, [r7]
 3f11974:	e5879000 	str	r9, [r7]
 3f11978:	e5973008 	ldr	r3, [r7, #8]
 3f1197c:	e0622009 	rsb	r2, r2, r9
 3f11980:	e0833002 	add	r3, r3, r2
 3f11984:	e5873008 	str	r3, [r7, #8]
    return Z_OK;
 3f11988:	e3a00000 	mov	r0, #0	; 0x0
 3f1198c:	e5846034 	str	r6, [r4, #52]
}
 3f11990:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f11994 <inflate_packet_flush>:
 3f11994:	e1a0c00d 	mov	r12, r13
 3f11998:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}


/*
 * At the end of a Deflate-compressed PPP packet, we expect to have seen
 * a `stored' block type value but not the (zero) length bytes.
 */
local int inflate_packet_flush(s)
    inflate_blocks_statef *s;
{
 3f1199c:	e1a02000 	mov	r2, r0
    if (s->mode != LENS)
 3f119a0:	e5923000 	ldr	r3, [r2]
 3f119a4:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f119a8:	e3530001 	cmp	r3, #1	; 0x1
	return Z_DATA_ERROR;
    s->mode = TYPE;
 3f119ac:	03a03000 	moveq	r3, #0	; 0x0
    return Z_OK;
 3f119b0:	01a00003 	moveq	r0, r3
 3f119b4:	05823000 	streq	r3, [r2]
 3f119b8:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
 3f119bc:	e3e00002 	mvn	r0, #2	; 0x2
 3f119c0:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f119c4 <huft_build>:
 3f119c4:	e1a0c00d 	mov	r12, r13
 3f119c8:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f119cc:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f119d0:	e24dde57 	sub	r13, r13, #1392	; 0x570
 3f119d4:	e24dd00c 	sub	r13, r13, #12	; 0xc
}


/*+++++*/
/* inftrees.c -- generate Huffman trees for efficient decoding
 * Copyright (C) 1995 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* simplify the use of the inflate_huft type with some defines */
#define base more.Base
#define next more.Next
#define exop word.what.Exop
#define bits word.what.Bits


local int huft_build OF((
    uIntf *,            /* code lengths in bits */
    uInt,               /* number of codes */
    uInt,               /* number of "simple" codes */
    uIntf *,            /* list of base values for non-simple codes */
    uIntf *,            /* list of extra bits for non-simple codes */
    inflate_huft * FAR*,/* result: starting table */
    uIntf *,            /* maximum lookup bits (returns actual) */
    z_stream *));       /* for zalloc function */

local voidpf falloc OF((
    voidpf,             /* opaque pointer (not used) */
    uInt,               /* number of items */
    uInt));             /* size of item */

local void ffree OF((
    voidpf q,           /* opaque pointer (not used) */
    voidpf p,           /* what to free (not used) */
    uInt n));		/* number of bytes (not used) */

/* Tables for deflate from PKZIP's appnote.txt. */
local uInt cplens[] = { /* Copy lengths for literal codes 257..285 */
	3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
	35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0};
	/* actually lengths - 2; also see note #13 above about 258 */
local uInt cplext[] = { /* Extra bits for literal codes 257..285 */
	0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
	3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 192, 192}; /* 192==invalid */
local uInt cpdist[] = { /* Copy offsets for distance codes 0..29 */
	1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
	257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
	8193, 12289, 16385, 24577};
local uInt cpdext[] = { /* Extra bits for distance codes */
	0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
	7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
	12, 12, 13, 13};

/*
   Huffman code decoding is performed using a multi-level table lookup.
   The fastest way to decode is to simply build a lookup table whose
   size is determined by the longest code.  However, the time it takes
   to build this table can also be a factor if the data being decoded
   is not very long.  The most common codes are necessarily the
   shortest codes, so those codes dominate the decoding time, and hence
   the speed.  The idea is you can have a shorter table that decodes the
   shorter, more probable codes, and then point to subsidiary tables for
   the longer codes.  The time it costs to decode the longer codes is
   then traded against the time it takes to make longer tables.

   This results of this trade are in the variables lbits and dbits
   below.  lbits is the number of bits the first level table for literal/
   length codes can decode in one step, and dbits is the same thing for
   the distance codes.  Subsequent tables are also less than or equal to
   those sizes.  These values may be adjusted either when all of the
   codes are shorter than that, in which case the longest code length in
   bits is used, or when the shortest code is *longer* than the requested
   table size, in which case the length of the shortest code in bits is
   used.

   There are two different values for the two tables, since they code a
   different number of possibilities each.  The literal/length table
   codes 286 possible values, or in a flat code, a little over eight
   bits.  The distance table codes 30 possible values, or a little less
   than five bits, flat.  The optimum values for speed end up being
   about one bit more than those, so lbits is 8+1 and dbits is 5+1.
   The optimum values may differ though from machine to machine, and
   possibly even between compilers.  Your mileage may vary.
 */


/* If BMAX needs to be larger than 16, then h and x[] should be uLong. */
#define BMAX 15         /* maximum bit length of any code */
#define N_MAX 288       /* maximum number of codes in any set */

#ifdef DEBUG_ZLIB
  uInt inflate_hufts;
#endif

local int huft_build(b, n, s, d, e, t, m, zs)
uIntf *b;               /* code lengths in bits (all assumed <= BMAX) */
uInt n;                 /* number of codes (assumed <= N_MAX) */
uInt s;                 /* number of simple-valued codes (0..s-1) */
uIntf *d;               /* list of base values for non-simple codes */
uIntf *e;               /* list of extra bits for non-simple codes */
inflate_huft * FAR *t;  /* result: starting table */
uIntf *m;               /* maximum lookup bits, returns actual */
z_stream *zs;           /* for zalloc function */
/* Given a list of code lengths and a maximum table size, make a set of
   tables to decode that set of codes.  Return Z_OK on success, Z_BUF_ERROR
   if the given code set is incomplete (the tables are still built in this
   case), Z_DATA_ERROR if the input is invalid (all zero length codes or an
   over-subscribed set of lengths), or Z_MEM_ERROR if not enough memory. */
{
 3f119d8:	e59ba00c 	ldr	r10, [r11, #12]

  uInt a;                       /* counter for codes of length k */
  uInt c[BMAX+1];               /* bit length count table */
  uInt f;                       /* i repeats in table every f entries */
  int g;                        /* maximum code length */
  int h;                        /* table level */
  register uInt i;              /* counter, current code */
  register uInt j;              /* counter */
  register int k;               /* number of bits in current code */
  int l;                        /* bits per table (returned in m) */
  register uIntf *p;            /* pointer into c[], b[], or v[] */
  inflate_huft *q;              /* points to current table */
  struct inflate_huft_s r;      /* table entry for structure assignment */
  inflate_huft *u[BMAX];        /* table stack */
  uInt v[N_MAX];                /* values in order of bit length */
  register int w;               /* bits before this table == (l * h) */
  uInt x[BMAX+1];               /* bit offsets, then code stack */
  uIntf *xp;                    /* pointer into x */
  int y;                        /* number of dummy codes added */
  uInt z;                       /* number of entries in current table */


  /* Generate counts for each bit length */
  p = c;
#define C0 *p++ = 0;
#define C2 C0 C0 C0 C0
#define C4 C2 C2 C2 C2
  C4                            /* clear c[]--assume BMAX+1 is 16 */
 3f119dc:	e3a0c000 	mov	r12, #0	; 0x0
 3f119e0:	e50bc064 	str	r12, [r11, -#100]
 3f119e4:	e50bc060 	str	r12, [r11, -#96]
 3f119e8:	e50bc05c 	str	r12, [r11, -#92]
 3f119ec:	e50bc058 	str	r12, [r11, -#88]
 3f119f0:	e50bc054 	str	r12, [r11, -#84]
 3f119f4:	e50bc050 	str	r12, [r11, -#80]
 3f119f8:	e50bc04c 	str	r12, [r11, -#76]
 3f119fc:	e50bc048 	str	r12, [r11, -#72]
 3f11a00:	e50bc044 	str	r12, [r11, -#68]
 3f11a04:	e50bc040 	str	r12, [r11, -#64]
 3f11a08:	e50b2568 	str	r2, [r11, -#1384]
 3f11a0c:	e50bc03c 	str	r12, [r11, -#60]
 3f11a10:	e50b356c 	str	r3, [r11, -#1388]
 3f11a14:	e50bc038 	str	r12, [r11, -#56]
 3f11a18:	e50bc034 	str	r12, [r11, -#52]
 3f11a1c:	e24b2060 	sub	r2, r11, #96	; 0x60
 3f11a20:	e50b2598 	str	r2, [r11, -#1432]
 3f11a24:	e50bc030 	str	r12, [r11, -#48]
 3f11a28:	e50bc02c 	str	r12, [r11, -#44]
 3f11a2c:	e24be064 	sub	r14, r11, #100	; 0x64
 3f11a30:	e50b1564 	str	r1, [r11, -#1380]
  p = b;  i = n;
 3f11a34:	e1a09000 	mov	r9, r0
 3f11a38:	e50bc028 	str	r12, [r11, -#40]
 3f11a3c:	e1a05001 	mov	r5, r1
  do {
    c[*p++]++;                  /* assume all entries <= BMAX */
 3f11a40:	e4992004 	ldr	r2, [r9], #4
 3f11a44:	e1a02102 	mov	r2, r2, lsl #2
 3f11a48:	e79e3002 	ldr	r3, [r14, r2]
  } while (--i);
 3f11a4c:	e2555001 	subs	r5, r5, #1	; 0x1
 3f11a50:	e2833001 	add	r3, r3, #1	; 0x1
 3f11a54:	e78e3002 	str	r3, [r14, r2]
 3f11a58:	1afffff8 	bne	3f11a40 <huft_build+0x7c>
  if (c[0] == n)                /* null input--all zero length codes */
 3f11a5c:	e51b3064 	ldr	r3, [r11, -#100]
 3f11a60:	e51b4564 	ldr	r4, [r11, -#1380]
 3f11a64:	e1530004 	cmp	r3, r4
  {
    *t = (inflate_huft *)Z_NULL;
 3f11a68:	059bc008 	ldreq	r12, [r11, #8]
 3f11a6c:	058c5000 	streq	r5, [r12]
    *m = 0;
    return Z_OK;
 3f11a70:	01a00005 	moveq	r0, r5
 3f11a74:	058a5000 	streq	r5, [r10]
 3f11a78:	0a000153 	beq	3f11fcc <huft_build+0x608>
  }


  /* Find minimum and maximum length, bound *m by those */
  l = *m;
  for (j = 1; j <= BMAX; j++)
    if (c[j])
 3f11a7c:	e51b3060 	ldr	r3, [r11, -#96]
 3f11a80:	e3a04001 	mov	r4, #1	; 0x1
 3f11a84:	e59a1000 	ldr	r1, [r10]
 3f11a88:	e3530000 	cmp	r3, #0	; 0x0
 3f11a8c:	e50b1580 	str	r1, [r11, -#1408]
 3f11a90:	1a000005 	bne	3f11aac <huft_build+0xe8>
 3f11a94:	e2844001 	add	r4, r4, #1	; 0x1
 3f11a98:	e354000f 	cmp	r4, #15	; 0xf
 3f11a9c:	8a000002 	bhi	3f11aac <huft_build+0xe8>
 3f11aa0:	e79e3104 	ldr	r3, [r14, r4, lsl #2]
 3f11aa4:	e3530000 	cmp	r3, #0	; 0x0
 3f11aa8:	0afffff9 	beq	3f11a94 <huft_build+0xd0>
      break;
  k = j;                        /* minimum code length */
 3f11aac:	e50b457c 	str	r4, [r11, -#1404]
  if ((uInt)l < j)
 3f11ab0:	e51b2580 	ldr	r2, [r11, -#1408]
    l = j;
  for (i = BMAX; i; i--)
 3f11ab4:	e3a0500f 	mov	r5, #15	; 0xf
    if (c[i])
 3f11ab8:	e51b3028 	ldr	r3, [r11, -#40]
 3f11abc:	e1520004 	cmp	r2, r4
 3f11ac0:	31a02004 	movcc	r2, r4
 3f11ac4:	e3530000 	cmp	r3, #0	; 0x0
 3f11ac8:	e50b2580 	str	r2, [r11, -#1408]
 3f11acc:	1a000005 	bne	3f11ae8 <huft_build+0x124>
 3f11ad0:	e2555001 	subs	r5, r5, #1	; 0x1
 3f11ad4:	0a000003 	beq	3f11ae8 <huft_build+0x124>
 3f11ad8:	e24b3064 	sub	r3, r11, #100	; 0x64
 3f11adc:	e7933105 	ldr	r3, [r3, r5, lsl #2]
 3f11ae0:	e3530000 	cmp	r3, #0	; 0x0
 3f11ae4:	0afffff9 	beq	3f11ad0 <huft_build+0x10c>
      break;
  g = i;                        /* maximum code length */
 3f11ae8:	e50b5574 	str	r5, [r11, -#1396]
  if ((uInt)l > i)
 3f11aec:	e51b3580 	ldr	r3, [r11, -#1408]
 3f11af0:	e1530005 	cmp	r3, r5
 3f11af4:	21a03005 	movcs	r3, r5
 3f11af8:	e50b3580 	str	r3, [r11, -#1408]
    l = i;
  *m = l;


  /* Adjust last length count to fill out codes, if needed */
  for (y = 1 << j; j < i; j++, y <<= 1)
 3f11afc:	e3a03001 	mov	r3, #1	; 0x1
 3f11b00:	e1a03413 	mov	r3, r3, lsl r4
 3f11b04:	e50b3584 	str	r3, [r11, -#1412]
 3f11b08:	e51bc580 	ldr	r12, [r11, -#1408]
 3f11b0c:	e1540005 	cmp	r4, r5
 3f11b10:	e58ac000 	str	r12, [r10]
 3f11b14:	2a00000a 	bcs	3f11b44 <huft_build+0x180>
    if ((y -= c[j]) < 0)
 3f11b18:	e24b3064 	sub	r3, r11, #100	; 0x64
 3f11b1c:	e7933104 	ldr	r3, [r3, r4, lsl #2]
 3f11b20:	e51be584 	ldr	r14, [r11, -#1412]
 3f11b24:	e05ee003 	subs	r14, r14, r3
 3f11b28:	e50be584 	str	r14, [r11, -#1412]
 3f11b2c:	4a00000b 	bmi	3f11b60 <huft_build+0x19c>
 3f11b30:	e2844001 	add	r4, r4, #1	; 0x1
 3f11b34:	e1a0e08e 	mov	r14, r14, lsl #1
 3f11b38:	e1540005 	cmp	r4, r5
 3f11b3c:	e50be584 	str	r14, [r11, -#1412]
 3f11b40:	3afffff4 	bcc	3f11b18 <huft_build+0x154>
      return Z_DATA_ERROR;
  if ((y -= c[i]) < 0)
 3f11b44:	e1a0c105 	mov	r12, r5, lsl #2
 3f11b48:	e24b2064 	sub	r2, r11, #100	; 0x64
 3f11b4c:	e792300c 	ldr	r3, [r2, r12]
 3f11b50:	e51b1584 	ldr	r1, [r11, -#1412]
 3f11b54:	e0511003 	subs	r1, r1, r3
 3f11b58:	e50b1584 	str	r1, [r11, -#1412]
 3f11b5c:	5a000001 	bpl	3f11b68 <huft_build+0x1a4>
    return Z_DATA_ERROR;
 3f11b60:	e3e00002 	mvn	r0, #2	; 0x2
 3f11b64:	ea000118 	b	3f11fcc <huft_build+0x608>
  c[i] += y;


  /* Generate starting offsets into the value table for each length */
  x[1] = j = 0;
 3f11b68:	e3a04000 	mov	r4, #0	; 0x0
  p = c + 1;  xp = x + 2;
 3f11b6c:	e24b1e55 	sub	r1, r11, #1360	; 0x550
 3f11b70:	e2411004 	sub	r1, r1, #4	; 0x4
 3f11b74:	e51be584 	ldr	r14, [r11, -#1412]
 3f11b78:	e2411004 	sub	r1, r1, #4	; 0x4
 3f11b7c:	e51b9598 	ldr	r9, [r11, -#1432]
 3f11b80:	e083300e 	add	r3, r3, r14
 3f11b84:	e782300c 	str	r3, [r2, r12]
  while (--i) {                 /* note that i == g from above */
 3f11b88:	e2555001 	subs	r5, r5, #1	; 0x1
 3f11b8c:	e50b455c 	str	r4, [r11, -#1372]
 3f11b90:	0a000004 	beq	3f11ba8 <huft_build+0x1e4>
    *xp++ = (j += *p++);
 3f11b94:	e4993004 	ldr	r3, [r9], #4
  }
 3f11b98:	e2555001 	subs	r5, r5, #1	; 0x1
 3f11b9c:	e0844003 	add	r4, r4, r3
 3f11ba0:	e4814004 	str	r4, [r1], #4
 3f11ba4:	1afffffa 	bne	3f11b94 <huft_build+0x1d0>


  /* Make a table of values in order of bit lengths */
  p = b;  i = 0;
 3f11ba8:	e1a09000 	mov	r9, r0
 3f11bac:	e3a05000 	mov	r5, #0	; 0x0
  do {
    if ((j = *p++) != 0)
 3f11bb0:	e4994004 	ldr	r4, [r9], #4
 3f11bb4:	e3540000 	cmp	r4, #0	; 0x0
 3f11bb8:	0a00000a 	beq	3f11be8 <huft_build+0x224>
      v[x[j]++] = i;
 3f11bbc:	e24b1e55 	sub	r1, r11, #1360	; 0x550
 3f11bc0:	e2411004 	sub	r1, r1, #4	; 0x4
 3f11bc4:	e241100c 	sub	r1, r1, #12	; 0xc
 3f11bc8:	e24b2e51 	sub	r2, r11, #1296	; 0x510
 3f11bcc:	e2422004 	sub	r2, r2, #4	; 0x4
 3f11bd0:	e1a00104 	mov	r0, r4, lsl #2
 3f11bd4:	e7913000 	ldr	r3, [r1, r0]
 3f11bd8:	e242200c 	sub	r2, r2, #12	; 0xc
 3f11bdc:	e7825103 	str	r5, [r2, r3, lsl #2]
 3f11be0:	e2833001 	add	r3, r3, #1	; 0x1
 3f11be4:	e7813000 	str	r3, [r1, r0]
  } while (++i < n);
 3f11be8:	e51b0564 	ldr	r0, [r11, -#1380]
 3f11bec:	e2855001 	add	r5, r5, #1	; 0x1
 3f11bf0:	e1550000 	cmp	r5, r0
 3f11bf4:	3affffed 	bcc	3f11bb0 <huft_build+0x1ec>


  /* Generate the Huffman codes and for each, make the table entries */
  x[0] = i = 0;                 /* first Huffman code is zero */
  p = v;                        /* grab values in bit order */
  h = -1;                       /* no tables yet--level -1 */
 3f11bf8:	e3e01000 	mvn	r1, #0	; 0x0
 3f11bfc:	e50b1578 	str	r1, [r11, -#1400]
  w = -l;                       /* bits decoded == (l * h) */
 3f11c00:	e51b2580 	ldr	r2, [r11, -#1408]
 3f11c04:	e3a05000 	mov	r5, #0	; 0x0
  u[0] = (inflate_huft *)Z_NULL;        /* just to keep compilers happy */
  q = (inflate_huft *)Z_NULL;   /* ditto */
  z = 0;                        /* ditto */
 3f11c08:	e50b5588 	str	r5, [r11, -#1416]
 3f11c0c:	e24b9e51 	sub	r9, r11, #1296	; 0x510
 3f11c10:	e50b5560 	str	r5, [r11, -#1376]
 3f11c14:	e2499004 	sub	r9, r9, #4	; 0x4

  /* go through the bit lengths (k already is bits in shortest code) */
  for (; k <= g; k++)
 3f11c18:	e51b357c 	ldr	r3, [r11, -#1404]
 3f11c1c:	e249900c 	sub	r9, r9, #12	; 0xc
 3f11c20:	e51b4574 	ldr	r4, [r11, -#1396]
 3f11c24:	e1a00005 	mov	r0, r5
 3f11c28:	e50b50a0 	str	r5, [r11, -#160]
 3f11c2c:	e262c000 	rsb	r12, r2, #0	; 0x0
 3f11c30:	e1530004 	cmp	r3, r4
 3f11c34:	ca0000de 	bgt	3f11fb4 <huft_build+0x5f0>
  {
    a = c[k];
 3f11c38:	e51be57c 	ldr	r14, [r11, -#1404]
 3f11c3c:	e24b1064 	sub	r1, r11, #100	; 0x64
 3f11c40:	e50b1590 	str	r1, [r11, -#1424]
 3f11c44:	e1a0e10e 	mov	r14, r14, lsl #2
 3f11c48:	e50be58c 	str	r14, [r11, -#1420]
 3f11c4c:	e791200e 	ldr	r2, [r1, r14]
    while (a--)
 3f11c50:	e2422001 	sub	r2, r2, #1	; 0x1
 3f11c54:	e3720001 	cmn	r2, #1	; 0x1
 3f11c58:	e50b2570 	str	r2, [r11, -#1392]
 3f11c5c:	0a0000ce 	beq	3f11f9c <huft_build+0x5d8>
 3f11c60:	e51b3578 	ldr	r3, [r11, -#1400]
 3f11c64:	e1a03103 	mov	r3, r3, lsl #2
 3f11c68:	e50b359c 	str	r3, [r11, -#1436]
    {
      /* here i is the Huffman code of length k bits for value *p */
      /* make tables up to required level */
      while (k > w + l)
 3f11c6c:	e24b4d16 	sub	r4, r11, #1408	; 0x580
 3f11c70:	e8944010 	ldmia	r4, {r4, r14}
 3f11c74:	e08c4004 	add	r4, r12, r4
 3f11c78:	e15e0004 	cmp	r14, r4
 3f11c7c:	e50b4594 	str	r4, [r11, -#1428]
 3f11c80:	da00006c 	ble	3f11e38 <huft_build+0x474>
      {
	h++;
 3f11c84:	e51b059c 	ldr	r0, [r11, -#1436]
 3f11c88:	e51b1578 	ldr	r1, [r11, -#1400]
	w += l;                 /* previous table always l bits */
 3f11c8c:	e51bc594 	ldr	r12, [r11, -#1428]

	/* compute minimum size table less than or equal to l bits */
	z = (z = g - w) > (uInt)l ? l : z;      /* table size upper limit */
 3f11c90:	e51b2574 	ldr	r2, [r11, -#1396]
 3f11c94:	e24b3d16 	sub	r3, r11, #1408	; 0x580
 3f11c98:	e8934008 	ldmia	r3, {r3, r14}
 3f11c9c:	e2800004 	add	r0, r0, #4	; 0x4
 3f11ca0:	e2811001 	add	r1, r1, #1	; 0x1
 3f11ca4:	e06c2002 	rsb	r2, r12, r2
 3f11ca8:	e1520003 	cmp	r2, r3
 3f11cac:	21a02003 	movcs	r2, r3
 3f11cb0:	e50b059c 	str	r0, [r11, -#1436]
	if ((f = 1 << (j = k - w)) > a + 1)     /* try a k-w bit table */
 3f11cb4:	e06c400e 	rsb	r4, r12, r14
 3f11cb8:	e50b2588 	str	r2, [r11, -#1416]
 3f11cbc:	e3a03001 	mov	r3, #1	; 0x1
 3f11cc0:	e51b0570 	ldr	r0, [r11, -#1392]
 3f11cc4:	e1a02413 	mov	r2, r3, lsl r4
 3f11cc8:	e50b1578 	str	r1, [r11, -#1400]
 3f11ccc:	e0803003 	add	r3, r0, r3
 3f11cd0:	e1520003 	cmp	r2, r3
 3f11cd4:	9a000014 	bls	3f11d2c <huft_build+0x368>
	{                       /* too few codes for k-w bit table */
	  f -= a + 1;           /* deduct codes from patterns left */
 3f11cd8:	e2423001 	sub	r3, r2, #1	; 0x1
 3f11cdc:	e0602003 	rsb	r2, r0, r3
	  xp = c + k;
 3f11ce0:	e24b3e59 	sub	r3, r11, #1424	; 0x590
 3f11ce4:	e8934008 	ldmia	r3, {r3, r14}
	  if (j < z)
 3f11ce8:	e51b0588 	ldr	r0, [r11, -#1416]
 3f11cec:	e083100e 	add	r1, r3, r14
 3f11cf0:	e1540000 	cmp	r4, r0
 3f11cf4:	2a00000c 	bcs	3f11d2c <huft_build+0x368>
	    while (++j < z)     /* try smaller tables up to z bits */
 3f11cf8:	e2844001 	add	r4, r4, #1	; 0x1
 3f11cfc:	e1540000 	cmp	r4, r0
	    {
	      if ((f <<= 1) <= *++xp)
 3f11d00:	ea000004 	b	3f11d18 <huft_build+0x354>
		break;          /* enough codes to use up j bits */
	      f -= *xp;         /* else deduct codes from patterns */
	    }
 3f11d04:	e51be588 	ldr	r14, [r11, -#1416]
 3f11d08:	e2844001 	add	r4, r4, #1	; 0x1
 3f11d0c:	e5913000 	ldr	r3, [r1]
 3f11d10:	e154000e 	cmp	r4, r14
 3f11d14:	e0632002 	rsb	r2, r3, r2
 3f11d18:	2a000003 	bcs	3f11d2c <huft_build+0x368>
 3f11d1c:	e5b13004 	ldr	r3, [r1, #4]!
 3f11d20:	e1a02082 	mov	r2, r2, lsl #1
 3f11d24:	e1520003 	cmp	r2, r3
 3f11d28:	8afffff5 	bhi	3f11d04 <huft_build+0x340>
	}
	z = 1 << j;             /* table entries for j-bit table */
 3f11d2c:	e3a03001 	mov	r3, #1	; 0x1
 3f11d30:	e1a03413 	mov	r3, r3, lsl r4
 3f11d34:	e50b3588 	str	r3, [r11, -#1416]

	/* allocate and link in new table */
	if ((q = (inflate_huft *)ZALLOC
 3f11d38:	e59b2010 	ldr	r2, [r11, #16]
 3f11d3c:	e283a001 	add	r10, r3, #1	; 0x1
 3f11d40:	e59b3010 	ldr	r3, [r11, #16]
 3f11d44:	e1a0100a 	mov	r1, r10
 3f11d48:	e5920028 	ldr	r0, [r2, #40]
 3f11d4c:	e3a02008 	mov	r2, #8	; 0x8
 3f11d50:	e50bc5a0 	str	r12, [r11, -#1440]
 3f11d54:	e1a0e00f 	mov	r14, r15
 3f11d58:	e593f020 	ldr	r15, [r3, #32]
 3f11d5c:	e3500000 	cmp	r0, #0	; 0x0
 3f11d60:	e51bc5a0 	ldr	r12, [r11, -#1440]
 3f11d64:	1a000007 	bne	3f11d88 <huft_build+0x3c4>
	     (zs,z + 1,sizeof(inflate_huft))) == Z_NULL)
	{
	  if (h)
 3f11d68:	e51b4578 	ldr	r4, [r11, -#1400]
 3f11d6c:	e3540000 	cmp	r4, #0	; 0x0
 3f11d70:	0a000002 	beq	3f11d80 <huft_build+0x3bc>
	    inflate_trees_free(u[0], zs);
 3f11d74:	e51b00a0 	ldr	r0, [r11, -#160]
 3f11d78:	e59b1010 	ldr	r1, [r11, #16]
 3f11d7c:	eb00019c 	bl	3f123f4 <inflate_trees_free>
	  return Z_MEM_ERROR;   /* not enough memory */
 3f11d80:	e3e00003 	mvn	r0, #3	; 0x3
 3f11d84:	ea000090 	b	3f11fcc <huft_build+0x608>
	}
	q->word.Nalloc = z + 1;
 3f11d88:	e580a000 	str	r10, [r0]
#ifdef DEBUG_ZLIB
	inflate_hufts += z + 1;
#endif
	*t = q + 1;             /* link to list for huft_free() */
 3f11d8c:	e59be008 	ldr	r14, [r11, #8]
 3f11d90:	e2802008 	add	r2, r0, #8	; 0x8
 3f11d94:	e58e2000 	str	r2, [r14]
	*(t = &(q->next)) = Z_NULL;
 3f11d98:	e2801004 	add	r1, r0, #4	; 0x4
 3f11d9c:	e58b1008 	str	r1, [r11, #8]
 3f11da0:	e3a03000 	mov	r3, #0	; 0x0
 3f11da4:	e5803004 	str	r3, [r0, #4]
	u[h] = ++q;             /* table starts after link */
 3f11da8:	e1a00002 	mov	r0, r2

	/* connect to last table, if there is one */
	if (h)
 3f11dac:	e51b2578 	ldr	r2, [r11, -#1400]
 3f11db0:	e1520003 	cmp	r2, r3
 3f11db4:	e51b359c 	ldr	r3, [r11, -#1436]
 3f11db8:	e24be0a0 	sub	r14, r11, #160	; 0xa0
 3f11dbc:	e78e0003 	str	r0, [r14, r3]
 3f11dc0:	0a000015 	beq	3f11e1c <huft_build+0x458>
	{
	  x[h] = i;             /* save pattern for backing up */
 3f11dc4:	e24b1e55 	sub	r1, r11, #1360	; 0x550
	  r.bits = (Byte)l;     /* bits to dump before this table */
 3f11dc8:	e51b3580 	ldr	r3, [r11, -#1408]
 3f11dcc:	e2411004 	sub	r1, r1, #4	; 0x4
 3f11dd0:	e20320ff 	and	r2, r3, #255	; 0xff
 3f11dd4:	e3c63cff 	bic	r3, r6, #65280	; 0xff00
 3f11dd8:	e1836402 	orr	r6, r3, r2, lsl #8
	  r.exop = (Byte)j;     /* bits in this table */
 3f11ddc:	e20420ff 	and	r2, r4, #255	; 0xff
 3f11de0:	e51b459c 	ldr	r4, [r11, -#1436]
 3f11de4:	e241100c 	sub	r1, r1, #12	; 0xc
 3f11de8:	e7815004 	str	r5, [r1, r4]
 3f11dec:	e3c630ff 	bic	r3, r6, #255	; 0xff
	  r.next = q;           /* pointer to this table */
	  j = i >> (w - l);     /* (get around Turbo C bug) */
 3f11df0:	e51b1594 	ldr	r1, [r11, -#1428]
 3f11df4:	e1826003 	orr	r6, r2, r3
 3f11df8:	e51b3580 	ldr	r3, [r11, -#1408]
 3f11dfc:	e1a07000 	mov	r7, r0
	  u[h-1][j] = r;        /* connect to last table */
 3f11e00:	e51b4578 	ldr	r4, [r11, -#1400]
 3f11e04:	e0632001 	rsb	r2, r3, r1
 3f11e08:	e2443001 	sub	r3, r4, #1	; 0x1
 3f11e0c:	e79e3103 	ldr	r3, [r14, r3, lsl #2]
 3f11e10:	e1a04235 	mov	r4, r5, lsr r2
 3f11e14:	e0833184 	add	r3, r3, r4, lsl #3
 3f11e18:	e88300c0 	stmia	r3, {r6, r7}
	}
      }
 3f11e1c:	e51be594 	ldr	r14, [r11, -#1428]
 3f11e20:	e24b1d16 	sub	r1, r11, #1408	; 0x580
 3f11e24:	e8910006 	ldmia	r1, {r1, r2}
 3f11e28:	e08ee001 	add	r14, r14, r1
 3f11e2c:	e152000e 	cmp	r2, r14
 3f11e30:	e50be594 	str	r14, [r11, -#1428]
 3f11e34:	caffff92 	bgt	3f11c84 <huft_build+0x2c0>

      /* set up table entry in r */
      r.bits = (Byte)(k - w);
 3f11e38:	e51b357c 	ldr	r3, [r11, -#1404]
      if (p >= v + n)
 3f11e3c:	e51b4564 	ldr	r4, [r11, -#1380]
 3f11e40:	e06ce003 	rsb	r14, r12, r3
 3f11e44:	e20e20ff 	and	r2, r14, #255	; 0xff
 3f11e48:	e3c63cff 	bic	r3, r6, #65280	; 0xff00
 3f11e4c:	e1836402 	orr	r6, r3, r2, lsl #8
 3f11e50:	e24b3e51 	sub	r3, r11, #1296	; 0x510
 3f11e54:	e2433004 	sub	r3, r3, #4	; 0x4
 3f11e58:	e243300c 	sub	r3, r3, #12	; 0xc
 3f11e5c:	e0833104 	add	r3, r3, r4, lsl #2
 3f11e60:	e1590003 	cmp	r9, r3
	r.exop = 128 + 64;      /* out of values--invalid code */
 3f11e64:	23c6303f 	biccs	r3, r6, #63	; 0x3f
 3f11e68:	238360c0 	orrcs	r6, r3, #192	; 0xc0
 3f11e6c:	2a000016 	bcs	3f11ecc <huft_build+0x508>
      else if (*p < s)
 3f11e70:	e5992000 	ldr	r2, [r9]
 3f11e74:	e51b1568 	ldr	r1, [r11, -#1384]
 3f11e78:	e1520001 	cmp	r2, r1
 3f11e7c:	2a000007 	bcs	3f11ea0 <huft_build+0x4dc>
      {
	r.exop = (Byte)(*p < 256 ? 0 : 32 + 64);     /* 256 is end-of-block */
 3f11e80:	e35200ff 	cmp	r2, #255	; 0xff
 3f11e84:	e3a01000 	mov	r1, #0	; 0x0
 3f11e88:	83a01060 	movhi	r1, #96	; 0x60
 3f11e8c:	e3c630ff 	bic	r3, r6, #255	; 0xff
 3f11e90:	e1816003 	orr	r6, r1, r3
	r.base = *p++;          /* simple code is just the value */
 3f11e94:	e1a07002 	mov	r7, r2
 3f11e98:	e2899004 	add	r9, r9, #4	; 0x4
      }
 3f11e9c:	ea00000a 	b	3f11ecc <huft_build+0x508>
      else
      {
	r.exop = (Byte)e[*p - s] + 16 + 64; /* non-simple--look up in lists */
 3f11ea0:	e51b4568 	ldr	r4, [r11, -#1384]
 3f11ea4:	e59b1004 	ldr	r1, [r11, #4]
 3f11ea8:	e0643002 	rsb	r3, r4, r2
 3f11eac:	e7d12103 	ldrb	r2, [r1, r3, lsl #2]
 3f11eb0:	e3c610ff 	bic	r1, r6, #255	; 0xff
 3f11eb4:	e2822050 	add	r2, r2, #80	; 0x50
 3f11eb8:	e20220ff 	and	r2, r2, #255	; 0xff
 3f11ebc:	e1826001 	orr	r6, r2, r1
	r.base = d[*p++ - s];
 3f11ec0:	e51b256c 	ldr	r2, [r11, -#1388]
 3f11ec4:	e2899004 	add	r9, r9, #4	; 0x4
 3f11ec8:	e7927103 	ldr	r7, [r2, r3, lsl #2]
      }

      /* fill code-like entries with r */
      f = 1 << (k - w);
 3f11ecc:	e3a03001 	mov	r3, #1	; 0x1
 3f11ed0:	e1a02e13 	mov	r2, r3, lsl r14
      for (j = i >> w; j < z; j += f)
 3f11ed4:	e51b3588 	ldr	r3, [r11, -#1416]
 3f11ed8:	e1a04c35 	mov	r4, r5, lsr r12
 3f11edc:	e1540003 	cmp	r4, r3
 3f11ee0:	2a000006 	bcs	3f11f00 <huft_build+0x53c>
 3f11ee4:	e0803184 	add	r3, r0, r4, lsl #3
	q[j] = r;
 3f11ee8:	e88300c0 	stmia	r3, {r6, r7}
 3f11eec:	e0833182 	add	r3, r3, r2, lsl #3
 3f11ef0:	e51be588 	ldr	r14, [r11, -#1416]
 3f11ef4:	e0844002 	add	r4, r4, r2
 3f11ef8:	e154000e 	cmp	r4, r14
 3f11efc:	3afffff9 	bcc	3f11ee8 <huft_build+0x524>

      /* backwards increment the k-bit code i */
      for (j = 1 << (k - 1); i & j; j >>= 1)
 3f11f00:	e51b157c 	ldr	r1, [r11, -#1404]
 3f11f04:	e3a03001 	mov	r3, #1	; 0x1
 3f11f08:	e2412001 	sub	r2, r1, #1	; 0x1
 3f11f0c:	e1a04213 	mov	r4, r3, lsl r2
 3f11f10:	e1150004 	tst	r5, r4
 3f11f14:	0a000003 	beq	3f11f28 <huft_build+0x564>
	i ^= j;
 3f11f18:	e0255004 	eor	r5, r5, r4
 3f11f1c:	e1a040a4 	mov	r4, r4, lsr #1
 3f11f20:	e1150004 	tst	r5, r4
 3f11f24:	1afffffb 	bne	3f11f18 <huft_build+0x554>
      i ^= j;
 3f11f28:	e0255004 	eor	r5, r5, r4

      /* backup over finished tables */
      while ((i & ((1 << w) - 1)) != x[h])
 3f11f2c:	e24b1e55 	sub	r1, r11, #1360	; 0x550
 3f11f30:	e2411004 	sub	r1, r1, #4	; 0x4
 3f11f34:	e241100c 	sub	r1, r1, #12	; 0xc
 3f11f38:	e3a0e001 	mov	r14, #1	; 0x1
 3f11f3c:	e1a03c1e 	mov	r3, r14, lsl r12
 3f11f40:	e51b459c 	ldr	r4, [r11, -#1436]
 3f11f44:	e2433001 	sub	r3, r3, #1	; 0x1
 3f11f48:	e7912004 	ldr	r2, [r1, r4]
 3f11f4c:	ea00000a 	b	3f11f7c <huft_build+0x5b8>
      {
	h--;                    /* don't need to update q */
 3f11f50:	e51b259c 	ldr	r2, [r11, -#1436]
 3f11f54:	e51b3578 	ldr	r3, [r11, -#1400]
	w -= l;
 3f11f58:	e51b4580 	ldr	r4, [r11, -#1408]
 3f11f5c:	e2422004 	sub	r2, r2, #4	; 0x4
 3f11f60:	e2433001 	sub	r3, r3, #1	; 0x1
 3f11f64:	e064c00c 	rsb	r12, r4, r12
 3f11f68:	e50b3578 	str	r3, [r11, -#1400]
      }
 3f11f6c:	e1a03c1e 	mov	r3, r14, lsl r12
 3f11f70:	e50b259c 	str	r2, [r11, -#1436]
 3f11f74:	e2433001 	sub	r3, r3, #1	; 0x1
 3f11f78:	e7912002 	ldr	r2, [r1, r2]
 3f11f7c:	e0053003 	and	r3, r5, r3
 3f11f80:	e1530002 	cmp	r3, r2
 3f11f84:	1afffff1 	bne	3f11f50 <huft_build+0x58c>
    }
 3f11f88:	e51be570 	ldr	r14, [r11, -#1392]
 3f11f8c:	e24ee001 	sub	r14, r14, #1	; 0x1
 3f11f90:	e37e0001 	cmn	r14, #1	; 0x1
 3f11f94:	e50be570 	str	r14, [r11, -#1392]
 3f11f98:	1affff33 	bne	3f11c6c <huft_build+0x2a8>
 3f11f9c:	e51b157c 	ldr	r1, [r11, -#1404]
 3f11fa0:	e51b2574 	ldr	r2, [r11, -#1396]
 3f11fa4:	e2811001 	add	r1, r1, #1	; 0x1
 3f11fa8:	e1510002 	cmp	r1, r2
 3f11fac:	e50b157c 	str	r1, [r11, -#1404]
 3f11fb0:	daffff20 	ble	3f11c38 <huft_build+0x274>
  }


  /* Return Z_BUF_ERROR if we were given an incomplete table */
  return y != 0 && g != 1 ? Z_BUF_ERROR : Z_OK;
 3f11fb4:	e51b3584 	ldr	r3, [r11, -#1412]
 3f11fb8:	e51b4574 	ldr	r4, [r11, -#1396]
 3f11fbc:	e3530000 	cmp	r3, #0	; 0x0
 3f11fc0:	13540001 	cmpne	r4, #1	; 0x1
 3f11fc4:	13e00004 	mvnne	r0, #4	; 0x4
 3f11fc8:	03a00000 	moveq	r0, #0	; 0x0
}
 3f11fcc:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f11fd0 <inflate_trees_bits>:
 3f11fd0:	e1a0c00d 	mov	r12, r13
 3f11fd4:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f11fd8:	e24cb004 	sub	r11, r12, #4	; 0x4


local int inflate_trees_bits(c, bb, tb, z)
uIntf *c;               /* 19 code lengths */
uIntf *bb;              /* bits tree desired/actual depth */
inflate_huft * FAR *tb; /* bits tree result */
z_stream *z;            /* for zfree function */
{
  int r;

  r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, tb, bb, z);
 3f11fdc:	e3a0c000 	mov	r12, #0	; 0x0
 3f11fe0:	e1a05002 	mov	r5, r2
 3f11fe4:	e1a04003 	mov	r4, r3
 3f11fe8:	e24dd010 	sub	r13, r13, #16	; 0x10
 3f11fec:	e58d1008 	str	r1, [r13, #8]
 3f11ff0:	e1a0300c 	mov	r3, r12
 3f11ff4:	e58dc000 	str	r12, [r13]
 3f11ff8:	e3a01013 	mov	r1, #19	; 0x13
 3f11ffc:	e58d5004 	str	r5, [r13, #4]
 3f12000:	e1a02001 	mov	r2, r1
 3f12004:	e58d400c 	str	r4, [r13, #12]
 3f12008:	ebfffe6d 	bl	3f119c4 <huft_build>
  if (r == Z_DATA_ERROR)
 3f1200c:	e3700003 	cmn	r0, #3	; 0x3
 3f12010:	1a000002 	bne	3f12020 <inflate_trees_bits+0x50>
    z->msg = "oversubscribed dynamic bit lengths tree";
 3f12014:	e59f3000 	ldr	r3, [pc, #0]	; 3f1201c <inflate_trees_bits+0x4c>
 3f12018:	ea000007 	b	3f1203c <inflate_trees_bits+0x6c>
 3f1201c:	03f1f74c 	mvneqs	r15, #19922944	; 0x1300000
  else if (r == Z_BUF_ERROR)
 3f12020:	e3700005 	cmn	r0, #5	; 0x5
 3f12024:	1a000005 	bne	3f12040 <inflate_trees_bits+0x70>
  {
    inflate_trees_free(*tb, z);
 3f12028:	e5950000 	ldr	r0, [r5]
 3f1202c:	e1a01004 	mov	r1, r4
 3f12030:	eb0000ef 	bl	3f123f4 <inflate_trees_free>
    z->msg = "incomplete dynamic bit lengths tree";
 3f12034:	e59f3008 	ldr	r3, [pc, #8]	; 3f12044 <inflate_trees_bits+0x74>
    r = Z_DATA_ERROR;
 3f12038:	e3e00002 	mvn	r0, #2	; 0x2
 3f1203c:	e5843018 	str	r3, [r4, #24]
  }
 3f12040:	ea000000 	b	3f12048 <inflate_trees_bits+0x78>
 3f12044:	03f1f774 	mvneqs	r15, #30408704	; 0x1d00000
  return r;
}
 3f12048:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f1204c <inflate_trees_dynamic>:
 3f1204c:	e1a0c00d 	mov	r12, r13
 3f12050:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}


local int inflate_trees_dynamic(nl, nd, c, bl, bd, tl, td, z)
uInt nl;                /* number of literal/length codes */
uInt nd;                /* number of distance codes */
uIntf *c;               /* that many (total) code lengths */
uIntf *bl;              /* literal desired/actual bit depth */
uIntf *bd;              /* distance desired/actual bit depth */
inflate_huft * FAR *tl; /* literal/length tree result */
inflate_huft * FAR *td; /* distance tree result */
z_stream *z;            /* for zfree function */
{
 3f12054:	e1a0a002 	mov	r10, r2
  int r;

  /* build literal/length tree */
  if ((r = huft_build(c, nl, 257, cplens, cplext, tl, bl, z)) != Z_OK)
 3f12058:	e59f20b8 	ldr	r2, [pc, #b8]	; 3f12118 <inflate_trees_dynamic+0xcc>
 3f1205c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f12060:	e59fc0b4 	ldr	r12, [pc, #b4]	; 3f1211c <inflate_trees_dynamic+0xd0>
 3f12064:	e24dd010 	sub	r13, r13, #16	; 0x10
 3f12068:	e58d3008 	str	r3, [r13, #8]
 3f1206c:	e59f30ac 	ldr	r3, [pc, #ac]	; 3f12120 <inflate_trees_dynamic+0xd4>
 3f12070:	e58dc000 	str	r12, [r13]
 3f12074:	e1a06000 	mov	r6, r0
 3f12078:	e59b9008 	ldr	r9, [r11, #8]
 3f1207c:	e1a0000a 	mov	r0, r10
 3f12080:	e58d9004 	str	r9, [r13, #4]
 3f12084:	e1a07001 	mov	r7, r1
 3f12088:	e59b5010 	ldr	r5, [r11, #16]
 3f1208c:	e1a01006 	mov	r1, r6
 3f12090:	e58d500c 	str	r5, [r13, #12]
 3f12094:	ebfffe4a 	bl	3f119c4 <huft_build>
 3f12098:	e2504000 	subs	r4, r0, #0	; 0x0
 3f1209c:	0a00000b 	beq	3f120d0 <inflate_trees_dynamic+0x84>
  {
    if (r == Z_DATA_ERROR)
 3f120a0:	e3740003 	cmn	r4, #3	; 0x3
      z->msg = "oversubscribed literal/length tree";
 3f120a4:	059f3078 	ldreq	r3, [pc, #78]	; 3f12124 <inflate_trees_dynamic+0xd8>
 3f120a8:	0a000006 	beq	3f120c8 <inflate_trees_dynamic+0x7c>
    else if (r == Z_BUF_ERROR)
 3f120ac:	e3740005 	cmn	r4, #5	; 0x5
 3f120b0:	1a00002b 	bne	3f12164 <inflate_trees_dynamic+0x118>
    {
      inflate_trees_free(*tl, z);
 3f120b4:	e5990000 	ldr	r0, [r9]
 3f120b8:	e1a01005 	mov	r1, r5
 3f120bc:	eb0000cc 	bl	3f123f4 <inflate_trees_free>
      z->msg = "incomplete literal/length tree";
 3f120c0:	e59f3060 	ldr	r3, [pc, #60]	; 3f12128 <inflate_trees_dynamic+0xdc>
      r = Z_DATA_ERROR;
 3f120c4:	e3e04002 	mvn	r4, #2	; 0x2
 3f120c8:	e5853018 	str	r3, [r5, #24]
    }
    return r;
 3f120cc:	ea000024 	b	3f12164 <inflate_trees_dynamic+0x118>
  }

  /* build distance tree */
  if ((r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, z)) != Z_OK)
 3f120d0:	e59b300c 	ldr	r3, [r11, #12]
 3f120d4:	e59fc050 	ldr	r12, [pc, #50]	; 3f1212c <inflate_trees_dynamic+0xe0>
 3f120d8:	e58d3004 	str	r3, [r13, #4]
 3f120dc:	e59b3004 	ldr	r3, [r11, #4]
 3f120e0:	e58d500c 	str	r5, [r13, #12]
 3f120e4:	e08a0106 	add	r0, r10, r6, lsl #2
 3f120e8:	e58d3008 	str	r3, [r13, #8]
 3f120ec:	e1a01007 	mov	r1, r7
 3f120f0:	e59f3038 	ldr	r3, [pc, #38]	; 3f12130 <inflate_trees_dynamic+0xe4>
 3f120f4:	e1a02004 	mov	r2, r4
 3f120f8:	e58dc000 	str	r12, [r13]
 3f120fc:	ebfffe30 	bl	3f119c4 <huft_build>
 3f12100:	e2504000 	subs	r4, r0, #0	; 0x0
 3f12104:	0a000016 	beq	3f12164 <inflate_trees_dynamic+0x118>
  {
    if (r == Z_DATA_ERROR)
 3f12108:	e3740003 	cmn	r4, #3	; 0x3
 3f1210c:	1a000008 	bne	3f12134 <inflate_trees_dynamic+0xe8>
      z->msg = "oversubscribed literal/length tree";
 3f12110:	e59f300c 	ldr	r3, [pc, #c]	; 3f12124 <inflate_trees_dynamic+0xd8>
 3f12114:	ea00000e 	b	3f12154 <inflate_trees_dynamic+0x108>
 3f12118:	00000101 	andeq	r0, r0, r1, lsl #2
 3f1211c:	03f20edc 	mvneqs	r0, #3520	; 0xdc0
 3f12120:	03f20e60 	mvneqs	r0, #1536	; 0x600
 3f12124:	03f1f798 	mvneqs	r15, #39845888	; 0x2600000
 3f12128:	03f1f7bc 	mvneqs	r15, #49283072	; 0x2f00000
 3f1212c:	03f20fd0 	mvneqs	r0, #832	; 0x340
 3f12130:	03f20f58 	mvneqs	r0, #352	; 0x160
    else if (r == Z_BUF_ERROR) {
 3f12134:	e3740005 	cmn	r4, #5	; 0x5
 3f12138:	1a000006 	bne	3f12158 <inflate_trees_dynamic+0x10c>
#ifdef PKZIP_BUG_WORKAROUND
      r = Z_OK;
    }
#else
      inflate_trees_free(*td, z);
 3f1213c:	e59bc00c 	ldr	r12, [r11, #12]
 3f12140:	e59c0000 	ldr	r0, [r12]
 3f12144:	e1a01005 	mov	r1, r5
 3f12148:	eb0000a9 	bl	3f123f4 <inflate_trees_free>
      z->msg = "incomplete literal/length tree";
 3f1214c:	e59f3018 	ldr	r3, [pc, #18]	; 3f1216c <inflate_trees_dynamic+0x120>
      r = Z_DATA_ERROR;
 3f12150:	e3e04002 	mvn	r4, #2	; 0x2
 3f12154:	e5853018 	str	r3, [r5, #24]
    }
    inflate_trees_free(*tl, z);
 3f12158:	e5990000 	ldr	r0, [r9]
 3f1215c:	e1a01005 	mov	r1, r5
 3f12160:	eb0000a3 	bl	3f123f4 <inflate_trees_free>
    return r;
#endif
  }

  /* done */
  return Z_OK;
 3f12164:	e1a00004 	mov	r0, r4
 3f12168:	ea000000 	b	3f12170 <inflate_trees_dynamic+0x124>
 3f1216c:	03f1f7bc 	mvneqs	r15, #49283072	; 0x2f00000
}
 3f12170:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f12174 <falloc>:
 3f12174:	e1a0c00d 	mov	r12, r13
 3f12178:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}


/* build fixed tables only once--keep them here */
local int fixed_lock = 0;
local int fixed_built = 0;
#define FIXEDH 530      /* number of hufts used by fixed tables */
local uInt fixed_left = FIXEDH;
local inflate_huft fixed_mem[FIXEDH];
local uInt fixed_bl;
local uInt fixed_bd;
local inflate_huft *fixed_tl;
local inflate_huft *fixed_td;


local voidpf falloc(q, n, s)
voidpf q;        /* opaque pointer (not used) */
uInt n;         /* number of items */
uInt s;         /* size of item */
{
  Assert(s == sizeof(inflate_huft) && n <= fixed_left,
	 "inflate_trees falloc overflow");
  if (q) s++; /* to make some compilers happy */
  fixed_left -= n;
 3f1217c:	e59f3018 	ldr	r3, [pc, #18]	; 3f1219c <falloc+0x28>
 3f12180:	e5930000 	ldr	r0, [r3]
 3f12184:	e24cb004 	sub	r11, r12, #4	; 0x4
  return (voidpf)(fixed_mem + fixed_left);
 3f12188:	e59f2010 	ldr	r2, [pc, #10]	; 3f121a0 <falloc+0x2c>
 3f1218c:	e0610000 	rsb	r0, r1, r0
 3f12190:	e5830000 	str	r0, [r3]
 3f12194:	e0820180 	add	r0, r2, r0, lsl #3
 3f12198:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f1219c:	03f21050 	mvneqs	r1, #80	; 0x50
 3f121a0:	03f6ce64 	mvneqs	r12, #1600	; 0x640

03f121a4 <ffree>:
 3f121a4:	e1a0c00d 	mov	r12, r13
 3f121a8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f121ac:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f121b0:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f121b4 <inflate_trees_fixed>:
 3f121b4:	e1a0c00d 	mov	r12, r13
 3f121b8:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f121bc:	e24cb004 	sub	r11, r12, #4	; 0x4
}


local void ffree(q, p, n)
voidpf q;
voidpf p;
uInt n;
{
  Assert(0, "inflate_trees ffree called!");
  if (q) q = p; /* to make some compilers happy */
}


local int inflate_trees_fixed(bl, bd, tl, td)
uIntf *bl;               /* literal desired/actual bit depth */
uIntf *bd;               /* distance desired/actual bit depth */
inflate_huft * FAR *tl;  /* literal/length tree result */
inflate_huft * FAR *td;  /* distance tree result */
{
 3f121c0:	e1a06000 	mov	r6, r0
 3f121c4:	e1a07001 	mov	r7, r1
 3f121c8:	e1a0a002 	mov	r10, r2
  /* build fixed tables if not built already--lock out other instances */
  while (++fixed_lock > 1)
 3f121cc:	e59f51e0 	ldr	r5, [pc, #1e0]	; 3f123b4 <inflate_trees_fixed+0x200>
 3f121d0:	e1a09003 	mov	r9, r3
 3f121d4:	e595c000 	ldr	r12, [r5]
 3f121d8:	e1a0e005 	mov	r14, r5
 3f121dc:	e28cc001 	add	r12, r12, #1	; 0x1
 3f121e0:	e35c0001 	cmp	r12, #1	; 0x1
 3f121e4:	e585c000 	str	r12, [r5]
 3f121e8:	e24ddd13 	sub	r13, r13, #1216	; 0x4c0
 3f121ec:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f121f0:	da000006 	ble	3f12210 <inflate_trees_fixed+0x5c>
    fixed_lock--;
 3f121f4:	e59e3000 	ldr	r3, [r14]
 3f121f8:	e2432001 	sub	r2, r3, #1	; 0x1
 3f121fc:	e58e2000 	str	r2, [r14]
 3f12200:	e1a0200e 	mov	r2, r14
 3f12204:	e3530001 	cmp	r3, #1	; 0x1
 3f12208:	e5823000 	str	r3, [r2]
 3f1220c:	cafffff8 	bgt	3f121f4 <inflate_trees_fixed+0x40>
  if (!fixed_built)
 3f12210:	e59f31a0 	ldr	r3, [pc, #1a0]	; 3f123b8 <inflate_trees_fixed+0x204>
 3f12214:	e5932000 	ldr	r2, [r3]
 3f12218:	e3520000 	cmp	r2, #0	; 0x0
 3f1221c:	1a000053 	bne	3f12370 <inflate_trees_fixed+0x1bc>
  {
    int k;              /* temporary variable */
    unsigned c[288];    /* length list for huft_build */
    z_stream z;         /* for falloc function */

    /* set up fake z_stream for memory routines */
    z.zalloc = falloc;
 3f12220:	e59f3194 	ldr	r3, [pc, #194]	; 3f123bc <inflate_trees_fixed+0x208>
    z.zfree = ffree;
    z.opaque = Z_NULL;
 3f12224:	e50b24b0 	str	r2, [r11, -#1200]
 3f12228:	e50b34b8 	str	r3, [r11, -#1208]
 3f1222c:	e59f318c 	ldr	r3, [pc, #18c]	; 3f123c0 <inflate_trees_fixed+0x20c>

    /* literal table */
    for (k = 0; k < 144; k++)
 3f12230:	e1a01002 	mov	r1, r2
 3f12234:	e50b34b4 	str	r3, [r11, -#1204]
      c[k] = 8;
 3f12238:	e24b2e4a 	sub	r2, r11, #1184	; 0x4a0
 3f1223c:	e2422004 	sub	r2, r2, #4	; 0x4
 3f12240:	e3a03008 	mov	r3, #8	; 0x8
 3f12244:	e7823101 	str	r3, [r2, r1, lsl #2]
 3f12248:	e2811001 	add	r1, r1, #1	; 0x1
 3f1224c:	e351008f 	cmp	r1, #143	; 0x8f
 3f12250:	dafffff8 	ble	3f12238 <inflate_trees_fixed+0x84>
    for (; k < 256; k++)
 3f12254:	e35100ff 	cmp	r1, #255	; 0xff
 3f12258:	ca000004 	bgt	3f12270 <inflate_trees_fixed+0xbc>
      c[k] = 9;
 3f1225c:	e3a03009 	mov	r3, #9	; 0x9
 3f12260:	e7823101 	str	r3, [r2, r1, lsl #2]
 3f12264:	e2811001 	add	r1, r1, #1	; 0x1
 3f12268:	e35100ff 	cmp	r1, #255	; 0xff
 3f1226c:	dafffffa 	ble	3f1225c <inflate_trees_fixed+0xa8>
    for (; k < 280; k++)
 3f12270:	e59f014c 	ldr	r0, [pc, #14c]	; 3f123c4 <inflate_trees_fixed+0x210>
 3f12274:	e1510000 	cmp	r1, r0
 3f12278:	ca000006 	bgt	3f12298 <inflate_trees_fixed+0xe4>
      c[k] = 7;
 3f1227c:	e24b2e4a 	sub	r2, r11, #1184	; 0x4a0
 3f12280:	e2422004 	sub	r2, r2, #4	; 0x4
 3f12284:	e3a03007 	mov	r3, #7	; 0x7
 3f12288:	e7823101 	str	r3, [r2, r1, lsl #2]
 3f1228c:	e2811001 	add	r1, r1, #1	; 0x1
 3f12290:	e1510000 	cmp	r1, r0
 3f12294:	dafffff8 	ble	3f1227c <inflate_trees_fixed+0xc8>
    for (; k < 288; k++)
 3f12298:	e59f0128 	ldr	r0, [pc, #128]	; 3f123c8 <inflate_trees_fixed+0x214>
 3f1229c:	e1510000 	cmp	r1, r0
 3f122a0:	ca000006 	bgt	3f122c0 <inflate_trees_fixed+0x10c>
      c[k] = 8;
 3f122a4:	e24b2e4a 	sub	r2, r11, #1184	; 0x4a0
 3f122a8:	e2422004 	sub	r2, r2, #4	; 0x4
 3f122ac:	e3a03008 	mov	r3, #8	; 0x8
 3f122b0:	e7823101 	str	r3, [r2, r1, lsl #2]
 3f122b4:	e2811001 	add	r1, r1, #1	; 0x1
 3f122b8:	e1510000 	cmp	r1, r0
 3f122bc:	dafffff8 	ble	3f122a4 <inflate_trees_fixed+0xf0>
    fixed_bl = 7;
    huft_build(c, 288, 257, cplens, cplext, &fixed_tl, &fixed_bl, &z);
 3f122c0:	e24b3e4d 	sub	r3, r11, #1232	; 0x4d0
 3f122c4:	e2433004 	sub	r3, r3, #4	; 0x4
 3f122c8:	e2433004 	sub	r3, r3, #4	; 0x4
 3f122cc:	e58d300c 	str	r3, [r13, #12]
 3f122d0:	e59f20f4 	ldr	r2, [pc, #f4]	; 3f123cc <inflate_trees_fixed+0x218>
 3f122d4:	e59f30f4 	ldr	r3, [pc, #f4]	; 3f123d0 <inflate_trees_fixed+0x21c>
 3f122d8:	e59fc0f4 	ldr	r12, [pc, #f4]	; 3f123d4 <inflate_trees_fixed+0x220>
 3f122dc:	e3a01007 	mov	r1, #7	; 0x7
 3f122e0:	e58c1000 	str	r1, [r12]
 3f122e4:	e59f10ec 	ldr	r1, [pc, #ec]	; 3f123d8 <inflate_trees_fixed+0x224>
 3f122e8:	e58dc008 	str	r12, [r13, #8]
 3f122ec:	e24b4e4a 	sub	r4, r11, #1184	; 0x4a0
 3f122f0:	e58d1000 	str	r1, [r13]
 3f122f4:	e2444004 	sub	r4, r4, #4	; 0x4
 3f122f8:	e59f10dc 	ldr	r1, [pc, #dc]	; 3f123dc <inflate_trees_fixed+0x228>
 3f122fc:	e1a00004 	mov	r0, r4
 3f12300:	e58d1004 	str	r1, [r13, #4]
 3f12304:	e3a01e12 	mov	r1, #288	; 0x120
 3f12308:	ebfffdad 	bl	3f119c4 <huft_build>

    /* distance table */
    for (k = 0; k < 30; k++)
 3f1230c:	e3a01000 	mov	r1, #0	; 0x0
      c[k] = 5;
 3f12310:	e3a02005 	mov	r2, #5	; 0x5
 3f12314:	e7842101 	str	r2, [r4, r1, lsl #2]
 3f12318:	e2811001 	add	r1, r1, #1	; 0x1
 3f1231c:	e351001d 	cmp	r1, #29	; 0x1d
 3f12320:	dafffffa 	ble	3f12310 <inflate_trees_fixed+0x15c>
    fixed_bd = 5;
    huft_build(c, 30, 0, cpdist, cpdext, &fixed_td, &fixed_bd, &z);
 3f12324:	e24b3e4d 	sub	r3, r11, #1232	; 0x4d0
 3f12328:	e2433004 	sub	r3, r3, #4	; 0x4
 3f1232c:	e2433004 	sub	r3, r3, #4	; 0x4
 3f12330:	e58d300c 	str	r3, [r13, #12]
 3f12334:	e59fc0a4 	ldr	r12, [pc, #a4]	; 3f123e0 <inflate_trees_fixed+0x22c>
 3f12338:	e59f30a4 	ldr	r3, [pc, #a4]	; 3f123e4 <inflate_trees_fixed+0x230>
 3f1233c:	e58c2000 	str	r2, [r12]
 3f12340:	e59f20a0 	ldr	r2, [pc, #a0]	; 3f123e8 <inflate_trees_fixed+0x234>
 3f12344:	e58dc008 	str	r12, [r13, #8]
 3f12348:	e58d2000 	str	r2, [r13]
 3f1234c:	e1a00004 	mov	r0, r4
 3f12350:	e59f2094 	ldr	r2, [pc, #94]	; 3f123ec <inflate_trees_fixed+0x238>
 3f12354:	e3a0101e 	mov	r1, #30	; 0x1e
 3f12358:	e58d2004 	str	r2, [r13, #4]
 3f1235c:	e3a02000 	mov	r2, #0	; 0x0
 3f12360:	ebfffd97 	bl	3f119c4 <huft_build>

    /* done */
    fixed_built = 1;
 3f12364:	e59f204c 	ldr	r2, [pc, #4c]	; 3f123b8 <inflate_trees_fixed+0x204>
 3f12368:	e3a03001 	mov	r3, #1	; 0x1
 3f1236c:	e5823000 	str	r3, [r2]
  }
  fixed_lock--;
 3f12370:	e5953000 	ldr	r3, [r5]
 3f12374:	e2433001 	sub	r3, r3, #1	; 0x1
 3f12378:	e5853000 	str	r3, [r5]
  *bl = fixed_bl;
 3f1237c:	e59f3050 	ldr	r3, [pc, #50]	; 3f123d4 <inflate_trees_fixed+0x220>
 3f12380:	e5933000 	ldr	r3, [r3]
 3f12384:	e5863000 	str	r3, [r6]
  *bd = fixed_bd;
 3f12388:	e59f3050 	ldr	r3, [pc, #50]	; 3f123e0 <inflate_trees_fixed+0x22c>
 3f1238c:	e5933000 	ldr	r3, [r3]
 3f12390:	e5873000 	str	r3, [r7]
  *tl = fixed_tl;
 3f12394:	e59f3040 	ldr	r3, [pc, #40]	; 3f123dc <inflate_trees_fixed+0x228>
 3f12398:	e5933000 	ldr	r3, [r3]
 3f1239c:	e58a3000 	str	r3, [r10]
  *td = fixed_td;
 3f123a0:	e59f3044 	ldr	r3, [pc, #44]	; 3f123ec <inflate_trees_fixed+0x238>
 3f123a4:	e5933000 	ldr	r3, [r3]
  return Z_OK;
 3f123a8:	e3a00000 	mov	r0, #0	; 0x0
 3f123ac:	e5893000 	str	r3, [r9]
 3f123b0:	ea00000e 	b	3f123f0 <inflate_trees_fixed+0x23c>
 3f123b4:	03f21048 	mvneqs	r1, #72	; 0x48
 3f123b8:	03f2104c 	mvneqs	r1, #76	; 0x4c
 3f123bc:	03f12174 	mvneqs	r2, #29	; 0x1d
 3f123c0:	03f121a4 	mvneqs	r2, #41	; 0x29
 3f123c4:	00000117 	andeq	r0, r0, r7, lsl r1
 3f123c8:	0000011f 	andeq	r0, r0, r15, lsl r1
 3f123cc:	00000101 	andeq	r0, r0, r1, lsl #2
 3f123d0:	03f20e60 	mvneqs	r0, #1536	; 0x600
 3f123d4:	03f6def4 	mvneqs	r13, #3904	; 0xf40
 3f123d8:	03f20edc 	mvneqs	r0, #3520	; 0xdc0
 3f123dc:	03f6defc 	mvneqs	r13, #4032	; 0xfc0
 3f123e0:	03f6def8 	mvneqs	r13, #3968	; 0xf80
 3f123e4:	03f20f58 	mvneqs	r0, #352	; 0x160
 3f123e8:	03f20fd0 	mvneqs	r0, #832	; 0x340
 3f123ec:	03f6df00 	mvneqs	r13, #0	; 0x0
}
 3f123f0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f123f4 <inflate_trees_free>:
 3f123f4:	e1a0c00d 	mov	r12, r13
 3f123f8:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f123fc:	e24cb004 	sub	r11, r12, #4	; 0x4


local int inflate_trees_free(t, z)
inflate_huft *t;        /* table to free */
z_stream *z;            /* for zfree function */
/* Free the malloc'ed tables built by huft_build(), which makes a linked
   list of the tables it made, with the links in a dummy first entry of
   each table. */
{
  register inflate_huft *p, *q;

  /* Go through linked list, freeing from the malloced (t[-1]) address. */
  p = t;
  while (p != Z_NULL)
 3f12400:	e2504000 	subs	r4, r0, #0	; 0x0
 3f12404:	e1a05001 	mov	r5, r1
 3f12408:	0a000009 	beq	3f12434 <inflate_trees_free+0x40>
  {
    q = (--p)->next;
    ZFREE(z, p, p->word.Nalloc * sizeof(inflate_huft));
 3f1240c:	e5950028 	ldr	r0, [r5, #40]
 3f12410:	e2444008 	sub	r4, r4, #8	; 0x8
 3f12414:	e5942000 	ldr	r2, [r4]
 3f12418:	e1a01004 	mov	r1, r4
 3f1241c:	e5944004 	ldr	r4, [r4, #4]
 3f12420:	e1a02182 	mov	r2, r2, lsl #3
 3f12424:	e1a0e00f 	mov	r14, r15
 3f12428:	e595f024 	ldr	r15, [r5, #36]
    p = q;
  }
 3f1242c:	e3540000 	cmp	r4, #0	; 0x0
 3f12430:	1afffff5 	bne	3f1240c <inflate_trees_free+0x18>
  return Z_OK;
 3f12434:	e3a00000 	mov	r0, #0	; 0x0
}
 3f12438:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f1243c <inflate_codes_new>:
 3f1243c:	e1a0c00d 	mov	r12, r13
 3f12440:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f12444:	e24cb004 	sub	r11, r12, #4	; 0x4

/*+++++*/
/* infcodes.c -- process literals and length/distance pairs
 * Copyright (C) 1995 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* simplify the use of the inflate_huft type with some defines */
#define base more.Base
#define next more.Next
#define exop word.what.Exop
#define bits word.what.Bits

/* inflate codes private state */
struct inflate_codes_state {

  /* mode */
  enum {        /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
      START,    /* x: set up for LEN */
      LEN,      /* i: get length/literal/eob next */
      LENEXT,   /* i: getting length extra (have base) */
      DIST,     /* i: get distance next */
      DISTEXT,  /* i: getting distance extra */
      COPY,     /* o: copying bytes in window, waiting for space */
      LIT,      /* o: got literal, waiting for output space */
      WASH,     /* o: got eob, possibly still output waiting */
      END,      /* x: got eob and all data flushed */
      BADCODE}  /* x: got error */
    mode;               /* current inflate_codes mode */

  /* mode dependent information */
  uInt len;
  union {
    struct {
      inflate_huft *tree;       /* pointer into tree */
      uInt need;                /* bits needed */
    } code;             /* if LEN or DIST, where in tree */
    uInt lit;           /* if LIT, literal */
    struct {
      uInt get;                 /* bits to get for extra */
      uInt dist;                /* distance back to copy from */
    } copy;             /* if EXT or COPY, where and how much */
  } sub;                /* submode */

  /* mode independent information */
  Byte lbits;           /* ltree bits decoded per branch */
  Byte dbits;           /* dtree bits decoder per branch */
  inflate_huft *ltree;          /* literal/length/eob tree */
  inflate_huft *dtree;          /* distance tree */

};


local inflate_codes_statef *inflate_codes_new(bl, bd, tl, td, z)
uInt bl, bd;
inflate_huft *tl, *td;
z_stream *z;
{
 3f12448:	e1a07000 	mov	r7, r0
 3f1244c:	e1a04001 	mov	r4, r1
 3f12450:	e1a05002 	mov	r5, r2
 3f12454:	e1a06003 	mov	r6, r3
 3f12458:	e59bc004 	ldr	r12, [r11, #4]
  inflate_codes_statef *c;

  if ((c = (inflate_codes_statef *)
 3f1245c:	e3a01001 	mov	r1, #1	; 0x1
 3f12460:	e59c0028 	ldr	r0, [r12, #40]
 3f12464:	e3a0201c 	mov	r2, #28	; 0x1c
 3f12468:	e1a0e00f 	mov	r14, r15
 3f1246c:	e59cf020 	ldr	r15, [r12, #32]
 3f12470:	e3500000 	cmp	r0, #0	; 0x0
 3f12474:	091ba8f0 	ldmeqdb	r11, {r4, r5, r6, r7, r11, r13, r15}
       ZALLOC(z,1,sizeof(struct inflate_codes_state))) != Z_NULL)
  {
    c->mode = START;
 3f12478:	e3a03000 	mov	r3, #0	; 0x0
 3f1247c:	e5803000 	str	r3, [r0]
    c->lbits = (Byte)bl;
 3f12480:	e5c07010 	strb	r7, [r0, #16]
    c->dbits = (Byte)bd;
 3f12484:	e5c04011 	strb	r4, [r0, #17]
    c->ltree = tl;
 3f12488:	e5805014 	str	r5, [r0, #20]
    c->dtree = td;
 3f1248c:	e5806018 	str	r6, [r0, #24]
    Tracev((stderr, "inflate:       codes new\n"));
  }
  return c;
}
 3f12490:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}

03f12494 <inflate_codes>:
 3f12494:	e1a0c00d 	mov	r12, r13
 3f12498:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}


local int inflate_codes(s, z, r)
inflate_blocks_statef *s;
z_stream *z;
int r;
{
 3f1249c:	e1a05001 	mov	r5, r1
 3f124a0:	e24dd014 	sub	r13, r13, #20	; 0x14
  uInt j;               /* temporary storage */
  inflate_huft *t;      /* temporary pointer */
  uInt e;               /* extra bits or operation */
  uLong b;              /* bit buffer */
  uInt k;               /* bits in bit buffer */
  Bytef *p;             /* input data pointer */
  uInt n;               /* bytes available there */
  Bytef *q;             /* output window write pointer */
  uInt m;               /* bytes to end of window or read pointer */
  Bytef *f;             /* pointer to copy strings from */
  inflate_codes_statef *c = s->sub.decode.codes;  /* codes state */

  /* copy input/output information to locals (UPDATE macro restores) */
  LOAD
 3f124a4:	e5959000 	ldr	r9, [r5]
 3f124a8:	e5953004 	ldr	r3, [r5, #4]
 3f124ac:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f124b0:	e50b302c 	str	r3, [r11, -#44]
 3f124b4:	e1a04000 	mov	r4, r0
 3f124b8:	e5943030 	ldr	r3, [r4, #48]
 3f124bc:	e594a024 	ldr	r10, [r4, #36]
 3f124c0:	e594c034 	ldr	r12, [r4, #52]
 3f124c4:	e50b2028 	str	r2, [r11, -#40]
 3f124c8:	e5947020 	ldr	r7, [r4, #32]
 3f124cc:	e15c0003 	cmp	r12, r3
 3f124d0:	e594600c 	ldr	r6, [r4, #12]
 3f124d4:	306c3003 	rsbcc	r3, r12, r3
 3f124d8:	3243e001 	subcc	r14, r3, #1	; 0x1
 3f124dc:	2594302c 	ldrcs	r3, [r4, #44]
 3f124e0:	206ce003 	rsbcs	r14, r12, r3

  /* process input and output based on current state */
  while (1) switch (c->mode)
 3f124e4:	e5963000 	ldr	r3, [r6]
 3f124e8:	e3530009 	cmp	r3, #9	; 0x9
 3f124ec:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f124f0:	ea0001f7 	b	3f12cd4 <inflate_codes+0x840>
 3f124f4:	03f1251c 	mvneqs	r2, #117440512	; 0x7000000
 3f124f8:	03f125dc 	mvneqs	r2, #922746880	; 0x37000000
 3f124fc:	03f126e0 	mvneqs	r2, #234881024	; 0xe000000
 3f12500:	03f12754 	mvneqs	r2, #22020096	; 0x1500000
 3f12504:	03f1283c 	mvneqs	r2, #3932160	; 0x3c0000
 3f12508:	03f128a4 	mvneqs	r2, #10747904	; 0xa40000
 3f1250c:	03f129e4 	mvneqs	r2, #3735552	; 0x390000
 3f12510:	03f12ae0 	mvneqs	r2, #917504	; 0xe0000
 3f12514:	03f12b4c 	mvneqs	r2, #77824	; 0x13000
 3f12518:	03f12b84 	mvneqs	r2, #135168	; 0x21000
  {             /* waiting for "i:"=input, "o:"=output, "x:"=nothing */
    case START:         /* x: set up for LEN */
#ifndef SLOW
      if (m >= 258 && n >= 10)
 3f1251c:	e59f33a8 	ldr	r3, [pc, #3a8]	; 3f128cc <inflate_codes+0x438>
 3f12520:	e51b202c 	ldr	r2, [r11, -#44]
 3f12524:	e15e0003 	cmp	r14, r3
 3f12528:	83520009 	cmphi	r2, #9	; 0x9
 3f1252c:	9a000024 	bls	3f125c4 <inflate_codes+0x130>
      {
	UPDATE
 3f12530:	e584a024 	str	r10, [r4, #36]
 3f12534:	e5847020 	str	r7, [r4, #32]
 3f12538:	e5852004 	str	r2, [r5, #4]
 3f1253c:	e5952000 	ldr	r2, [r5]
 3f12540:	e5859000 	str	r9, [r5]
 3f12544:	e5953008 	ldr	r3, [r5, #8]
 3f12548:	e0622009 	rsb	r2, r2, r9
 3f1254c:	e0833002 	add	r3, r3, r2
 3f12550:	e5853008 	str	r3, [r5, #8]
 3f12554:	e584c034 	str	r12, [r4, #52]
	r = inflate_fast(c->lbits, c->dbits, c->ltree, c->dtree, s, z);
 3f12558:	e5d60010 	ldrb	r0, [r6, #16]
 3f1255c:	e5d61011 	ldrb	r1, [r6, #17]
 3f12560:	e2862014 	add	r2, r6, #20	; 0x14
 3f12564:	e892000c 	ldmia	r2, {r2, r3}
 3f12568:	e88d0030 	stmia	r13, {r4, r5}
 3f1256c:	eb000256 	bl	3f12ecc <inflate_fast>
	LOAD
 3f12570:	e5953004 	ldr	r3, [r5, #4]
 3f12574:	e5959000 	ldr	r9, [r5]
 3f12578:	e50b302c 	str	r3, [r11, -#44]
 3f1257c:	e5943030 	ldr	r3, [r4, #48]
 3f12580:	e594a024 	ldr	r10, [r4, #36]
 3f12584:	e594c034 	ldr	r12, [r4, #52]
 3f12588:	e50b0028 	str	r0, [r11, -#40]
 3f1258c:	e15c0003 	cmp	r12, r3
 3f12590:	e5947020 	ldr	r7, [r4, #32]
 3f12594:	306c3003 	rsbcc	r3, r12, r3
 3f12598:	3243e001 	subcc	r14, r3, #1	; 0x1
 3f1259c:	2594302c 	ldrcs	r3, [r4, #44]
 3f125a0:	206ce003 	rsbcs	r14, r12, r3
	if (r != Z_OK)
 3f125a4:	e51b2028 	ldr	r2, [r11, -#40]
 3f125a8:	e3520000 	cmp	r2, #0	; 0x0
 3f125ac:	0a000004 	beq	3f125c4 <inflate_codes+0x130>
	{
	  c->mode = r == Z_STREAM_END ? WASH : BADCODE;
 3f125b0:	e3520001 	cmp	r2, #1	; 0x1
 3f125b4:	13a03009 	movne	r3, #9	; 0x9
 3f125b8:	03a03007 	moveq	r3, #7	; 0x7
 3f125bc:	e5863000 	str	r3, [r6]
	  break;
 3f125c0:	eaffffc7 	b	3f124e4 <inflate_codes+0x50>
	}
      }
#endif /* !SLOW */
      c->sub.code.need = c->lbits;
      c->sub.code.tree = c->ltree;
      c->mode = LEN;
 3f125c4:	e3a03001 	mov	r3, #1	; 0x1
 3f125c8:	e5863000 	str	r3, [r6]
 3f125cc:	e5d63010 	ldrb	r3, [r6, #16]
 3f125d0:	e586300c 	str	r3, [r6, #12]
 3f125d4:	e5963014 	ldr	r3, [r6, #20]
 3f125d8:	e5863008 	str	r3, [r6, #8]
    case LEN:           /* i: get length/literal/eob next */
      j = c->sub.code.need;
 3f125dc:	e596000c 	ldr	r0, [r6, #12]
      NEEDBITS(j)
 3f125e0:	e1570000 	cmp	r7, r0
 3f125e4:	2a00000c 	bcs	3f1261c <inflate_codes+0x188>
 3f125e8:	e51b302c 	ldr	r3, [r11, -#44]
 3f125ec:	e3530000 	cmp	r3, #0	; 0x0
 3f125f0:	0a000171 	beq	3f12bbc <inflate_codes+0x728>
 3f125f4:	e3a02000 	mov	r2, #0	; 0x0
 3f125f8:	e50b2028 	str	r2, [r11, -#40]
 3f125fc:	e51b202c 	ldr	r2, [r11, -#44]
 3f12600:	e4d93001 	ldrb	r3, [r9], #1
 3f12604:	e2422001 	sub	r2, r2, #1	; 0x1
 3f12608:	e50b202c 	str	r2, [r11, -#44]
 3f1260c:	e18aa713 	orr	r10, r10, r3, lsl r7
 3f12610:	e2877008 	add	r7, r7, #8	; 0x8
 3f12614:	e1570000 	cmp	r7, r0
 3f12618:	3afffff2 	bcc	3f125e8 <inflate_codes+0x154>
      t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
 3f1261c:	e59f32ac 	ldr	r3, [pc, #2ac]	; 3f128d0 <inflate_codes+0x43c>
 3f12620:	e7933100 	ldr	r3, [r3, r0, lsl #2]
 3f12624:	e5961008 	ldr	r1, [r6, #8]
 3f12628:	e00a3003 	and	r3, r10, r3
 3f1262c:	e1a03183 	mov	r3, r3, lsl #3
 3f12630:	e0810003 	add	r0, r1, r3
      DUMPBITS(t->bits)
 3f12634:	e5d02001 	ldrb	r2, [r0, #1]
      e = (uInt)(t->exop);
 3f12638:	e7d13003 	ldrb	r3, [r1, r3]
 3f1263c:	e1a0a23a 	mov	r10, r10, lsr r2
 3f12640:	e0627007 	rsb	r7, r2, r7
      if (e == 0)               /* literal */
 3f12644:	e3530000 	cmp	r3, #0	; 0x0
      {
	c->sub.lit = t->base;
 3f12648:	05902004 	ldreq	r2, [r0, #4]
	Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
		 "inflate:         literal '%c'\n" :
		 "inflate:         literal 0x%02x\n", t->base));
	c->mode = LIT;
 3f1264c:	03a03006 	moveq	r3, #6	; 0x6
 3f12650:	05863000 	streq	r3, [r6]
 3f12654:	05862008 	streq	r2, [r6, #8]
	break;
 3f12658:	0affffa1 	beq	3f124e4 <inflate_codes+0x50>
      }
      if (e & 16)               /* length */
 3f1265c:	e3130010 	tst	r3, #16	; 0x10
 3f12660:	0a000006 	beq	3f12680 <inflate_codes+0x1ec>
      {
	c->sub.copy.get = e & 15;
 3f12664:	e203300f 	and	r3, r3, #15	; 0xf
 3f12668:	e5863008 	str	r3, [r6, #8]
	c->len = t->base;
 3f1266c:	e5902004 	ldr	r2, [r0, #4]
	c->mode = LENEXT;
 3f12670:	e3a03002 	mov	r3, #2	; 0x2
 3f12674:	e5863000 	str	r3, [r6]
 3f12678:	e5862004 	str	r2, [r6, #4]
	break;
 3f1267c:	eaffff98 	b	3f124e4 <inflate_codes+0x50>
      }
      if ((e & 64) == 0)        /* next table */
 3f12680:	e3130040 	tst	r3, #64	; 0x40
 3f12684:	0a000056 	beq	3f127e4 <inflate_codes+0x350>
      {
	c->sub.code.need = e;
	c->sub.code.tree = t->next;
	break;
      }
      if (e & 32)               /* end of block */
 3f12688:	e3130020 	tst	r3, #32	; 0x20
      {
	Tracevv((stderr, "inflate:         end of block\n"));
	c->mode = WASH;
 3f1268c:	13a03007 	movne	r3, #7	; 0x7
 3f12690:	15863000 	strne	r3, [r6]
	break;
 3f12694:	1affff92 	bne	3f124e4 <inflate_codes+0x50>
      }
      c->mode = BADCODE;        /* invalid code */
 3f12698:	e3a03009 	mov	r3, #9	; 0x9
 3f1269c:	e5863000 	str	r3, [r6]
      z->msg = "invalid literal/length code";
 3f126a0:	e59f322c 	ldr	r3, [pc, #22c]	; 3f128d4 <inflate_codes+0x440>
 3f126a4:	e5853018 	str	r3, [r5, #24]
      r = Z_DATA_ERROR;
      LEAVE
 3f126a8:	e584a024 	str	r10, [r4, #36]
 3f126ac:	e5847020 	str	r7, [r4, #32]
 3f126b0:	e51b302c 	ldr	r3, [r11, -#44]
 3f126b4:	e5853004 	str	r3, [r5, #4]
 3f126b8:	e5952000 	ldr	r2, [r5]
 3f126bc:	e1a00004 	mov	r0, r4
 3f126c0:	e5859000 	str	r9, [r5]
 3f126c4:	e1a01005 	mov	r1, r5
 3f126c8:	e5953008 	ldr	r3, [r5, #8]
 3f126cc:	e0622009 	rsb	r2, r2, r9
 3f126d0:	e0833002 	add	r3, r3, r2
 3f126d4:	e5853008 	str	r3, [r5, #8]
 3f126d8:	e3e02002 	mvn	r2, #2	; 0x2
 3f126dc:	ea000189 	b	3f12d08 <inflate_codes+0x874>
    case LENEXT:        /* i: getting length extra (have base) */
      j = c->sub.copy.get;
 3f126e0:	e5960008 	ldr	r0, [r6, #8]
      NEEDBITS(j)
 3f126e4:	e1570000 	cmp	r7, r0
 3f126e8:	2a00000b 	bcs	3f1271c <inflate_codes+0x288>
 3f126ec:	e51b202c 	ldr	r2, [r11, -#44]
 3f126f0:	e3520000 	cmp	r2, #0	; 0x0
 3f126f4:	0a00013e 	beq	3f12bf4 <inflate_codes+0x760>
 3f126f8:	e3a03000 	mov	r3, #0	; 0x0
 3f126fc:	e50b3028 	str	r3, [r11, -#40]
 3f12700:	e4d93001 	ldrb	r3, [r9], #1
 3f12704:	e2422001 	sub	r2, r2, #1	; 0x1
 3f12708:	e50b202c 	str	r2, [r11, -#44]
 3f1270c:	e18aa713 	orr	r10, r10, r3, lsl r7
 3f12710:	e2877008 	add	r7, r7, #8	; 0x8
 3f12714:	e1570000 	cmp	r7, r0
 3f12718:	3afffff3 	bcc	3f126ec <inflate_codes+0x258>
      c->len += (uInt)b & inflate_mask[j];
 3f1271c:	e59f31ac 	ldr	r3, [pc, #1ac]	; 3f128d0 <inflate_codes+0x43c>
      DUMPBITS(j)
      c->sub.code.need = c->dbits;
 3f12720:	e5d62011 	ldrb	r2, [r6, #17]
 3f12724:	e7931100 	ldr	r1, [r3, r0, lsl #2]
 3f12728:	e586200c 	str	r2, [r6, #12]
      c->sub.code.tree = c->dtree;
 3f1272c:	e5963018 	ldr	r3, [r6, #24]
 3f12730:	e0607007 	rsb	r7, r0, r7
 3f12734:	e5863008 	str	r3, [r6, #8]
      Tracevv((stderr, "inflate:         length %u\n", c->len));
      c->mode = DIST;
 3f12738:	e3a03003 	mov	r3, #3	; 0x3
 3f1273c:	e5863000 	str	r3, [r6]
 3f12740:	e00a1001 	and	r1, r10, r1
 3f12744:	e5963004 	ldr	r3, [r6, #4]
 3f12748:	e1a0a03a 	mov	r10, r10, lsr r0
 3f1274c:	e0833001 	add	r3, r3, r1
 3f12750:	e5863004 	str	r3, [r6, #4]
    case DIST:          /* i: get distance next */
      j = c->sub.code.need;
 3f12754:	e596000c 	ldr	r0, [r6, #12]
      NEEDBITS(j)
 3f12758:	e1570000 	cmp	r7, r0
 3f1275c:	2a00000b 	bcs	3f12790 <inflate_codes+0x2fc>
 3f12760:	e51b202c 	ldr	r2, [r11, -#44]
 3f12764:	e3520000 	cmp	r2, #0	; 0x0
 3f12768:	0a00012f 	beq	3f12c2c <inflate_codes+0x798>
 3f1276c:	e3a03000 	mov	r3, #0	; 0x0
 3f12770:	e50b3028 	str	r3, [r11, -#40]
 3f12774:	e4d93001 	ldrb	r3, [r9], #1
 3f12778:	e2422001 	sub	r2, r2, #1	; 0x1
 3f1277c:	e50b202c 	str	r2, [r11, -#44]
 3f12780:	e18aa713 	orr	r10, r10, r3, lsl r7
 3f12784:	e2877008 	add	r7, r7, #8	; 0x8
 3f12788:	e1570000 	cmp	r7, r0
 3f1278c:	3afffff3 	bcc	3f12760 <inflate_codes+0x2cc>
      t = c->sub.code.tree + ((uInt)b & inflate_mask[j]);
 3f12790:	e59f3138 	ldr	r3, [pc, #138]	; 3f128d0 <inflate_codes+0x43c>
 3f12794:	e7933100 	ldr	r3, [r3, r0, lsl #2]
 3f12798:	e5961008 	ldr	r1, [r6, #8]
 3f1279c:	e00a3003 	and	r3, r10, r3
 3f127a0:	e1a03183 	mov	r3, r3, lsl #3
 3f127a4:	e0810003 	add	r0, r1, r3
      DUMPBITS(t->bits)
 3f127a8:	e5d02001 	ldrb	r2, [r0, #1]
      e = (uInt)(t->exop);
 3f127ac:	e7d13003 	ldrb	r3, [r1, r3]
 3f127b0:	e1a0a23a 	mov	r10, r10, lsr r2
 3f127b4:	e0627007 	rsb	r7, r2, r7
      if (e & 16)               /* distance */
 3f127b8:	e3130010 	tst	r3, #16	; 0x10
 3f127bc:	0a000006 	beq	3f127dc <inflate_codes+0x348>
      {
	c->sub.copy.get = e & 15;
 3f127c0:	e203300f 	and	r3, r3, #15	; 0xf
 3f127c4:	e5863008 	str	r3, [r6, #8]
	c->sub.copy.dist = t->base;
 3f127c8:	e5902004 	ldr	r2, [r0, #4]
	c->mode = DISTEXT;
 3f127cc:	e3a03004 	mov	r3, #4	; 0x4
 3f127d0:	e5863000 	str	r3, [r6]
 3f127d4:	e586200c 	str	r2, [r6, #12]
	break;
 3f127d8:	eaffff41 	b	3f124e4 <inflate_codes+0x50>
      }
      if ((e & 64) == 0)        /* next table */
 3f127dc:	e3130040 	tst	r3, #64	; 0x40
 3f127e0:	1a000003 	bne	3f127f4 <inflate_codes+0x360>
      {
	c->sub.code.need = e;
 3f127e4:	e586300c 	str	r3, [r6, #12]
	c->sub.code.tree = t->next;
 3f127e8:	e5903004 	ldr	r3, [r0, #4]
 3f127ec:	e5863008 	str	r3, [r6, #8]
	break;
 3f127f0:	eaffff3b 	b	3f124e4 <inflate_codes+0x50>
      }
      c->mode = BADCODE;        /* invalid code */
 3f127f4:	e3a03009 	mov	r3, #9	; 0x9
 3f127f8:	e5863000 	str	r3, [r6]
      z->msg = "invalid distance code";
 3f127fc:	e59f30d4 	ldr	r3, [pc, #d4]	; 3f128d8 <inflate_codes+0x444>
 3f12800:	e5853018 	str	r3, [r5, #24]
      r = Z_DATA_ERROR;
      LEAVE
 3f12804:	e584a024 	str	r10, [r4, #36]
 3f12808:	e5847020 	str	r7, [r4, #32]
 3f1280c:	e51b202c 	ldr	r2, [r11, -#44]
 3f12810:	e5852004 	str	r2, [r5, #4]
 3f12814:	e5952000 	ldr	r2, [r5]
 3f12818:	e1a00004 	mov	r0, r4
 3f1281c:	e5859000 	str	r9, [r5]
 3f12820:	e1a01005 	mov	r1, r5
 3f12824:	e5953008 	ldr	r3, [r5, #8]
 3f12828:	e0622009 	rsb	r2, r2, r9
 3f1282c:	e0833002 	add	r3, r3, r2
 3f12830:	e5853008 	str	r3, [r5, #8]
 3f12834:	e3e02002 	mvn	r2, #2	; 0x2
 3f12838:	ea000132 	b	3f12d08 <inflate_codes+0x874>
    case DISTEXT:       /* i: getting distance extra */
      j = c->sub.copy.get;
 3f1283c:	e5960008 	ldr	r0, [r6, #8]
      NEEDBITS(j)
 3f12840:	e1570000 	cmp	r7, r0
 3f12844:	2a00000c 	bcs	3f1287c <inflate_codes+0x3e8>
 3f12848:	e51b302c 	ldr	r3, [r11, -#44]
 3f1284c:	e3530000 	cmp	r3, #0	; 0x0
 3f12850:	0a000103 	beq	3f12c64 <inflate_codes+0x7d0>
 3f12854:	e3a02000 	mov	r2, #0	; 0x0
 3f12858:	e50b2028 	str	r2, [r11, -#40]
 3f1285c:	e51b202c 	ldr	r2, [r11, -#44]
 3f12860:	e4d93001 	ldrb	r3, [r9], #1
 3f12864:	e2422001 	sub	r2, r2, #1	; 0x1
 3f12868:	e50b202c 	str	r2, [r11, -#44]
 3f1286c:	e18aa713 	orr	r10, r10, r3, lsl r7
 3f12870:	e2877008 	add	r7, r7, #8	; 0x8
 3f12874:	e1570000 	cmp	r7, r0
 3f12878:	3afffff2 	bcc	3f12848 <inflate_codes+0x3b4>
      c->sub.copy.dist += (uInt)b & inflate_mask[j];
 3f1287c:	e59f304c 	ldr	r3, [pc, #4c]	; 3f128d0 <inflate_codes+0x43c>
 3f12880:	e7932100 	ldr	r2, [r3, r0, lsl #2]
      DUMPBITS(j)
      Tracevv((stderr, "inflate:         distance %u\n", c->sub.copy.dist));
      c->mode = COPY;
 3f12884:	e3a03005 	mov	r3, #5	; 0x5
 3f12888:	e5863000 	str	r3, [r6]
 3f1288c:	e0607007 	rsb	r7, r0, r7
 3f12890:	e596300c 	ldr	r3, [r6, #12]
 3f12894:	e00a2002 	and	r2, r10, r2
 3f12898:	e1a0a03a 	mov	r10, r10, lsr r0
 3f1289c:	e0833002 	add	r3, r3, r2
 3f128a0:	e586300c 	str	r3, [r6, #12]
    case COPY:          /* o: copying bytes in window, waiting for space */
#ifndef __TURBOC__ /* Turbo C bug for following expression */
      f = (uInt)(q - s->window) < c->sub.copy.dist ?
 3f128a4:	e5943028 	ldr	r3, [r4, #40]
 3f128a8:	e596100c 	ldr	r1, [r6, #12]
 3f128ac:	e063300c 	rsb	r3, r3, r12
 3f128b0:	e1530001 	cmp	r3, r1
 3f128b4:	2a000008 	bcs	3f128dc <inflate_codes+0x448>
 3f128b8:	e594202c 	ldr	r2, [r4, #44]
 3f128bc:	e0633001 	rsb	r3, r3, r1
 3f128c0:	e0632002 	rsb	r2, r3, r2
 3f128c4:	e50b2030 	str	r2, [r11, -#48]
 3f128c8:	ea000005 	b	3f128e4 <inflate_codes+0x450>
 3f128cc:	00000101 	andeq	r0, r0, r1, lsl #2
 3f128d0:	03f20dd0 	mvneqs	r0, #13312	; 0x3400
 3f128d4:	03f1f7dc 	mvneqs	r15, #57671680	; 0x3700000
 3f128d8:	03f1f7f8 	mvneqs	r15, #65011712	; 0x3e00000
 3f128dc:	e061100c 	rsb	r1, r1, r12
 3f128e0:	e50b1030 	str	r1, [r11, -#48]
	  s->end - (c->sub.copy.dist - (q - s->window)) :
	  q - c->sub.copy.dist;
#else
      f = q - c->sub.copy.dist;
      if ((uInt)(q - s->window) < c->sub.copy.dist)
	f = s->end - (c->sub.copy.dist - (q - s->window));
#endif
      while (c->len)
 3f128e4:	e5963004 	ldr	r3, [r6, #4]
 3f128e8:	e3530000 	cmp	r3, #0	; 0x0
 3f128ec:	0a000039 	beq	3f129d8 <inflate_codes+0x544>
      {
	NEEDOUT
 3f128f0:	e35e0000 	cmp	r14, #0	; 0x0
 3f128f4:	1a000027 	bne	3f12998 <inflate_codes+0x504>
 3f128f8:	e594102c 	ldr	r1, [r4, #44]
 3f128fc:	e15c0001 	cmp	r12, r1
 3f12900:	1a000008 	bne	3f12928 <inflate_codes+0x494>
 3f12904:	e5943030 	ldr	r3, [r4, #48]
 3f12908:	e5942028 	ldr	r2, [r4, #40]
 3f1290c:	e1530002 	cmp	r3, r2
 3f12910:	0a000004 	beq	3f12928 <inflate_codes+0x494>
 3f12914:	e1a0c002 	mov	r12, r2
 3f12918:	e15c0003 	cmp	r12, r3
 3f1291c:	306c3003 	rsbcc	r3, r12, r3
 3f12920:	3243e001 	subcc	r14, r3, #1	; 0x1
 3f12924:	206ce001 	rsbcs	r14, r12, r1
 3f12928:	e35e0000 	cmp	r14, #0	; 0x0
 3f1292c:	1a000019 	bne	3f12998 <inflate_codes+0x504>
 3f12930:	e1a00004 	mov	r0, r4
 3f12934:	e51b2028 	ldr	r2, [r11, -#40]
 3f12938:	e1a01005 	mov	r1, r5
 3f1293c:	e584c034 	str	r12, [r4, #52]
 3f12940:	eb0000fd 	bl	3f12d3c <inflate_flush>
 3f12944:	e2842030 	add	r2, r4, #48	; 0x30
 3f12948:	e8921004 	ldmia	r2, {r2, r12}
 3f1294c:	e50b0028 	str	r0, [r11, -#40]
 3f12950:	e15c0002 	cmp	r12, r2
 3f12954:	306c3002 	rsbcc	r3, r12, r2
 3f12958:	3243e001 	subcc	r14, r3, #1	; 0x1
 3f1295c:	2594302c 	ldrcs	r3, [r4, #44]
 3f12960:	206ce003 	rsbcs	r14, r12, r3
 3f12964:	e594102c 	ldr	r1, [r4, #44]
 3f12968:	e15c0001 	cmp	r12, r1
 3f1296c:	1a000007 	bne	3f12990 <inflate_codes+0x4fc>
 3f12970:	e5943028 	ldr	r3, [r4, #40]
 3f12974:	e1520003 	cmp	r2, r3
 3f12978:	0a000004 	beq	3f12990 <inflate_codes+0x4fc>
 3f1297c:	e1a0c003 	mov	r12, r3
 3f12980:	e15c0002 	cmp	r12, r2
 3f12984:	306c3002 	rsbcc	r3, r12, r2
 3f12988:	3243e001 	subcc	r14, r3, #1	; 0x1
 3f1298c:	206ce001 	rsbcs	r14, r12, r1
 3f12990:	e35e0000 	cmp	r14, #0	; 0x0
 3f12994:	0a0000c0 	beq	3f12c9c <inflate_codes+0x808>
	OUTBYTE(*f++)
 3f12998:	e51b2030 	ldr	r2, [r11, -#48]
 3f1299c:	e4d23001 	ldrb	r3, [r2], #1
 3f129a0:	e50b2030 	str	r2, [r11, -#48]
 3f129a4:	e4cc3001 	strb	r3, [r12], #1
 3f129a8:	e3a03000 	mov	r3, #0	; 0x0
 3f129ac:	e50b3028 	str	r3, [r11, -#40]
	if (f == s->end)
 3f129b0:	e594302c 	ldr	r3, [r4, #44]
 3f129b4:	e24ee001 	sub	r14, r14, #1	; 0x1
 3f129b8:	e1520003 	cmp	r2, r3
	  f = s->window;
 3f129bc:	05942028 	ldreq	r2, [r4, #40]
 3f129c0:	050b2030 	streq	r2, [r11, -#48]
	c->len--;
 3f129c4:	e5963004 	ldr	r3, [r6, #4]
 3f129c8:	e2433001 	sub	r3, r3, #1	; 0x1
      }
 3f129cc:	e3530000 	cmp	r3, #0	; 0x0
 3f129d0:	e5863004 	str	r3, [r6, #4]
 3f129d4:	1affffc5 	bne	3f128f0 <inflate_codes+0x45c>
      c->mode = START;
 3f129d8:	e3a03000 	mov	r3, #0	; 0x0
 3f129dc:	e5863000 	str	r3, [r6]
      break;
 3f129e0:	eafffebf 	b	3f124e4 <inflate_codes+0x50>
    case LIT:           /* o: got literal, waiting for output space */
      NEEDOUT
 3f129e4:	e35e0000 	cmp	r14, #0	; 0x0
 3f129e8:	1a000035 	bne	3f12ac4 <inflate_codes+0x630>
 3f129ec:	e594102c 	ldr	r1, [r4, #44]
 3f129f0:	e15c0001 	cmp	r12, r1
 3f129f4:	1a000008 	bne	3f12a1c <inflate_codes+0x588>
 3f129f8:	e5943030 	ldr	r3, [r4, #48]
 3f129fc:	e5942028 	ldr	r2, [r4, #40]
 3f12a00:	e1530002 	cmp	r3, r2
 3f12a04:	0a000004 	beq	3f12a1c <inflate_codes+0x588>
 3f12a08:	e1a0c002 	mov	r12, r2
 3f12a0c:	e15c0003 	cmp	r12, r3
 3f12a10:	306c3003 	rsbcc	r3, r12, r3
 3f12a14:	3243e001 	subcc	r14, r3, #1	; 0x1
 3f12a18:	206ce001 	rsbcs	r14, r12, r1
 3f12a1c:	e35e0000 	cmp	r14, #0	; 0x0
 3f12a20:	1a000027 	bne	3f12ac4 <inflate_codes+0x630>
 3f12a24:	e1a00004 	mov	r0, r4
 3f12a28:	e51b2028 	ldr	r2, [r11, -#40]
 3f12a2c:	e1a01005 	mov	r1, r5
 3f12a30:	e584c034 	str	r12, [r4, #52]
 3f12a34:	eb0000c0 	bl	3f12d3c <inflate_flush>
 3f12a38:	e2842030 	add	r2, r4, #48	; 0x30
 3f12a3c:	e8921004 	ldmia	r2, {r2, r12}
 3f12a40:	e50b0028 	str	r0, [r11, -#40]
 3f12a44:	e15c0002 	cmp	r12, r2
 3f12a48:	306c3002 	rsbcc	r3, r12, r2
 3f12a4c:	3243e001 	subcc	r14, r3, #1	; 0x1
 3f12a50:	2594302c 	ldrcs	r3, [r4, #44]
 3f12a54:	206ce003 	rsbcs	r14, r12, r3
 3f12a58:	e594102c 	ldr	r1, [r4, #44]
 3f12a5c:	e15c0001 	cmp	r12, r1
 3f12a60:	1a000007 	bne	3f12a84 <inflate_codes+0x5f0>
 3f12a64:	e5943028 	ldr	r3, [r4, #40]
 3f12a68:	e1520003 	cmp	r2, r3
 3f12a6c:	0a000004 	beq	3f12a84 <inflate_codes+0x5f0>
 3f12a70:	e1a0c003 	mov	r12, r3
 3f12a74:	e15c0002 	cmp	r12, r2
 3f12a78:	306c3002 	rsbcc	r3, r12, r2
 3f12a7c:	3243e001 	subcc	r14, r3, #1	; 0x1
 3f12a80:	206ce001 	rsbcs	r14, r12, r1
 3f12a84:	e35e0000 	cmp	r14, #0	; 0x0
 3f12a88:	1a00000d 	bne	3f12ac4 <inflate_codes+0x630>
 3f12a8c:	e584a024 	str	r10, [r4, #36]
 3f12a90:	e5847020 	str	r7, [r4, #32]
 3f12a94:	e51b302c 	ldr	r3, [r11, -#44]
 3f12a98:	e5853004 	str	r3, [r5, #4]
 3f12a9c:	e5952000 	ldr	r2, [r5]
 3f12aa0:	e5859000 	str	r9, [r5]
 3f12aa4:	e5953008 	ldr	r3, [r5, #8]
 3f12aa8:	e0622009 	rsb	r2, r2, r9
 3f12aac:	e0833002 	add	r3, r3, r2
 3f12ab0:	e5853008 	str	r3, [r5, #8]
 3f12ab4:	e1a00004 	mov	r0, r4
 3f12ab8:	e51b2028 	ldr	r2, [r11, -#40]
 3f12abc:	e1a01005 	mov	r1, r5
 3f12ac0:	ea000090 	b	3f12d08 <inflate_codes+0x874>
      OUTBYTE(c->sub.lit)
 3f12ac4:	e5d63008 	ldrb	r3, [r6, #8]
 3f12ac8:	e3a02000 	mov	r2, #0	; 0x0
 3f12acc:	e50b2028 	str	r2, [r11, -#40]
 3f12ad0:	e4cc3001 	strb	r3, [r12], #1
 3f12ad4:	e24ee001 	sub	r14, r14, #1	; 0x1
      c->mode = START;
 3f12ad8:	e5862000 	str	r2, [r6]
      break;
 3f12adc:	eafffe80 	b	3f124e4 <inflate_codes+0x50>
    case WASH:          /* o: got eob, possibly more output */
      FLUSH
 3f12ae0:	e1a00004 	mov	r0, r4
 3f12ae4:	e51b2028 	ldr	r2, [r11, -#40]
 3f12ae8:	e1a01005 	mov	r1, r5
 3f12aec:	e584c034 	str	r12, [r4, #52]
 3f12af0:	eb000091 	bl	3f12d3c <inflate_flush>
 3f12af4:	e2843030 	add	r3, r4, #48	; 0x30
 3f12af8:	e8931008 	ldmia	r3, {r3, r12}
 3f12afc:	e50b0028 	str	r0, [r11, -#40]
 3f12b00:	e15c0003 	cmp	r12, r3
      if (s->read != s->write)
 3f12b04:	e153000c 	cmp	r3, r12
 3f12b08:	0a00000d 	beq	3f12b44 <inflate_codes+0x6b0>
	LEAVE
 3f12b0c:	e584a024 	str	r10, [r4, #36]
 3f12b10:	e5847020 	str	r7, [r4, #32]
 3f12b14:	e51b302c 	ldr	r3, [r11, -#44]
 3f12b18:	e5853004 	str	r3, [r5, #4]
 3f12b1c:	e5952000 	ldr	r2, [r5]
 3f12b20:	e5859000 	str	r9, [r5]
 3f12b24:	e5953008 	ldr	r3, [r5, #8]
 3f12b28:	e0622009 	rsb	r2, r2, r9
 3f12b2c:	e0833002 	add	r3, r3, r2
 3f12b30:	e5853008 	str	r3, [r5, #8]
 3f12b34:	e1a00004 	mov	r0, r4
 3f12b38:	e51b2028 	ldr	r2, [r11, -#40]
 3f12b3c:	e1a01005 	mov	r1, r5
 3f12b40:	ea000070 	b	3f12d08 <inflate_codes+0x874>
      c->mode = END;
 3f12b44:	e3a03008 	mov	r3, #8	; 0x8
 3f12b48:	e5863000 	str	r3, [r6]
    case END:
      r = Z_STREAM_END;
      LEAVE
 3f12b4c:	e584a024 	str	r10, [r4, #36]
 3f12b50:	e5847020 	str	r7, [r4, #32]
 3f12b54:	e51b202c 	ldr	r2, [r11, -#44]
 3f12b58:	e5852004 	str	r2, [r5, #4]
 3f12b5c:	e5952000 	ldr	r2, [r5]
 3f12b60:	e1a00004 	mov	r0, r4
 3f12b64:	e5859000 	str	r9, [r5]
 3f12b68:	e1a01005 	mov	r1, r5
 3f12b6c:	e5953008 	ldr	r3, [r5, #8]
 3f12b70:	e0622009 	rsb	r2, r2, r9
 3f12b74:	e0833002 	add	r3, r3, r2
 3f12b78:	e5853008 	str	r3, [r5, #8]
 3f12b7c:	e3a02001 	mov	r2, #1	; 0x1
 3f12b80:	ea000060 	b	3f12d08 <inflate_codes+0x874>
    case BADCODE:       /* x: got error */
      r = Z_DATA_ERROR;
      LEAVE
 3f12b84:	e584a024 	str	r10, [r4, #36]
 3f12b88:	e5847020 	str	r7, [r4, #32]
 3f12b8c:	e51b302c 	ldr	r3, [r11, -#44]
 3f12b90:	e5853004 	str	r3, [r5, #4]
 3f12b94:	e5952000 	ldr	r2, [r5]
 3f12b98:	e1a00004 	mov	r0, r4
 3f12b9c:	e5859000 	str	r9, [r5]
 3f12ba0:	e1a01005 	mov	r1, r5
 3f12ba4:	e5953008 	ldr	r3, [r5, #8]
 3f12ba8:	e0622009 	rsb	r2, r2, r9
 3f12bac:	e0833002 	add	r3, r3, r2
 3f12bb0:	e5853008 	str	r3, [r5, #8]
 3f12bb4:	e3e02002 	mvn	r2, #2	; 0x2
 3f12bb8:	ea000052 	b	3f12d08 <inflate_codes+0x874>
 3f12bbc:	e584a024 	str	r10, [r4, #36]
 3f12bc0:	e5847020 	str	r7, [r4, #32]
 3f12bc4:	e51b202c 	ldr	r2, [r11, -#44]
 3f12bc8:	e5852004 	str	r2, [r5, #4]
 3f12bcc:	e5952000 	ldr	r2, [r5]
 3f12bd0:	e5859000 	str	r9, [r5]
 3f12bd4:	e5953008 	ldr	r3, [r5, #8]
 3f12bd8:	e0622009 	rsb	r2, r2, r9
 3f12bdc:	e0833002 	add	r3, r3, r2
 3f12be0:	e5853008 	str	r3, [r5, #8]
 3f12be4:	e1a00004 	mov	r0, r4
 3f12be8:	e51b2028 	ldr	r2, [r11, -#40]
 3f12bec:	e1a01005 	mov	r1, r5
 3f12bf0:	ea000044 	b	3f12d08 <inflate_codes+0x874>
 3f12bf4:	e584a024 	str	r10, [r4, #36]
 3f12bf8:	e5847020 	str	r7, [r4, #32]
 3f12bfc:	e51b302c 	ldr	r3, [r11, -#44]
 3f12c00:	e5853004 	str	r3, [r5, #4]
 3f12c04:	e5952000 	ldr	r2, [r5]
 3f12c08:	e5859000 	str	r9, [r5]
 3f12c0c:	e5953008 	ldr	r3, [r5, #8]
 3f12c10:	e0622009 	rsb	r2, r2, r9
 3f12c14:	e0833002 	add	r3, r3, r2
 3f12c18:	e5853008 	str	r3, [r5, #8]
 3f12c1c:	e1a00004 	mov	r0, r4
 3f12c20:	e51b2028 	ldr	r2, [r11, -#40]
 3f12c24:	e1a01005 	mov	r1, r5
 3f12c28:	ea000036 	b	3f12d08 <inflate_codes+0x874>
 3f12c2c:	e584a024 	str	r10, [r4, #36]
 3f12c30:	e5847020 	str	r7, [r4, #32]
 3f12c34:	e51b202c 	ldr	r2, [r11, -#44]
 3f12c38:	e5852004 	str	r2, [r5, #4]
 3f12c3c:	e5952000 	ldr	r2, [r5]
 3f12c40:	e5859000 	str	r9, [r5]
 3f12c44:	e5953008 	ldr	r3, [r5, #8]
 3f12c48:	e0622009 	rsb	r2, r2, r9
 3f12c4c:	e0833002 	add	r3, r3, r2
 3f12c50:	e5853008 	str	r3, [r5, #8]
 3f12c54:	e1a00004 	mov	r0, r4
 3f12c58:	e51b2028 	ldr	r2, [r11, -#40]
 3f12c5c:	e1a01005 	mov	r1, r5
 3f12c60:	ea000028 	b	3f12d08 <inflate_codes+0x874>
 3f12c64:	e584a024 	str	r10, [r4, #36]
 3f12c68:	e5847020 	str	r7, [r4, #32]
 3f12c6c:	e51b302c 	ldr	r3, [r11, -#44]
 3f12c70:	e5853004 	str	r3, [r5, #4]
 3f12c74:	e5952000 	ldr	r2, [r5]
 3f12c78:	e5859000 	str	r9, [r5]
 3f12c7c:	e5953008 	ldr	r3, [r5, #8]
 3f12c80:	e0622009 	rsb	r2, r2, r9
 3f12c84:	e0833002 	add	r3, r3, r2
 3f12c88:	e5853008 	str	r3, [r5, #8]
 3f12c8c:	e1a00004 	mov	r0, r4
 3f12c90:	e51b2028 	ldr	r2, [r11, -#40]
 3f12c94:	e1a01005 	mov	r1, r5
 3f12c98:	ea00001a 	b	3f12d08 <inflate_codes+0x874>
 3f12c9c:	e584a024 	str	r10, [r4, #36]
 3f12ca0:	e5847020 	str	r7, [r4, #32]
 3f12ca4:	e51b202c 	ldr	r2, [r11, -#44]
 3f12ca8:	e5852004 	str	r2, [r5, #4]
 3f12cac:	e5952000 	ldr	r2, [r5]
 3f12cb0:	e5859000 	str	r9, [r5]
 3f12cb4:	e5953008 	ldr	r3, [r5, #8]
 3f12cb8:	e0622009 	rsb	r2, r2, r9
 3f12cbc:	e0833002 	add	r3, r3, r2
 3f12cc0:	e5853008 	str	r3, [r5, #8]
 3f12cc4:	e1a00004 	mov	r0, r4
 3f12cc8:	e51b2028 	ldr	r2, [r11, -#40]
 3f12ccc:	e1a01005 	mov	r1, r5
 3f12cd0:	ea00000c 	b	3f12d08 <inflate_codes+0x874>
    default:
      r = Z_STREAM_ERROR;
      LEAVE
 3f12cd4:	e584a024 	str	r10, [r4, #36]
 3f12cd8:	e5847020 	str	r7, [r4, #32]
 3f12cdc:	e51b302c 	ldr	r3, [r11, -#44]
 3f12ce0:	e5853004 	str	r3, [r5, #4]
 3f12ce4:	e5952000 	ldr	r2, [r5]
 3f12ce8:	e1a00004 	mov	r0, r4
 3f12cec:	e5859000 	str	r9, [r5]
 3f12cf0:	e1a01005 	mov	r1, r5
 3f12cf4:	e5953008 	ldr	r3, [r5, #8]
 3f12cf8:	e0622009 	rsb	r2, r2, r9
 3f12cfc:	e0833002 	add	r3, r3, r2
 3f12d00:	e5853008 	str	r3, [r5, #8]
 3f12d04:	e3e02001 	mvn	r2, #1	; 0x1
 3f12d08:	e584c034 	str	r12, [r4, #52]
 3f12d0c:	eb00000a 	bl	3f12d3c <inflate_flush>
  }
}
 3f12d10:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f12d14 <inflate_codes_free>:
 3f12d14:	e1a0c00d 	mov	r12, r13
 3f12d18:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f12d1c:	e24cb004 	sub	r11, r12, #4	; 0x4


local void inflate_codes_free(c, z)
inflate_codes_statef *c;
z_stream *z;
{
 3f12d20:	e1a03001 	mov	r3, r1
  ZFREE(z, c, sizeof(struct inflate_codes_state));
 3f12d24:	e1a01000 	mov	r1, r0
 3f12d28:	e5930028 	ldr	r0, [r3, #40]
 3f12d2c:	e3a0201c 	mov	r2, #28	; 0x1c
 3f12d30:	e1a0e00f 	mov	r14, r15
 3f12d34:	e593f024 	ldr	r15, [r3, #36]
 3f12d38:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f12d3c <inflate_flush>:
 3f12d3c:	e1a0c00d 	mov	r12, r13
 3f12d40:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f12d44:	e24cb004 	sub	r11, r12, #4	; 0x4
  Tracev((stderr, "inflate:       codes free\n"));
}

/*+++++*/
/* inflate_util.c -- data and routines common to blocks and codes
 * Copyright (C) 1995 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* copy as much as possible from the sliding window to the output area */
local int inflate_flush(s, z, r)
inflate_blocks_statef *s;
z_stream *z;
int r;
{
 3f12d48:	e1a06000 	mov	r6, r0
  uInt n;
  Bytef *p, *q;

  /* local copies of source and destination pointers */
  p = z->next_out;
  q = s->read;
 3f12d4c:	e5965030 	ldr	r5, [r6, #48]
 3f12d50:	e1a09002 	mov	r9, r2

  /* compute number of bytes to copy as far as end of window */
  n = (uInt)((q <= s->write ? s->write : s->end) - q);
 3f12d54:	e5962034 	ldr	r2, [r6, #52]
 3f12d58:	e1a07001 	mov	r7, r1
 3f12d5c:	e597a00c 	ldr	r10, [r7, #12]
 3f12d60:	e1550002 	cmp	r5, r2
 3f12d64:	90654002 	rsbls	r4, r5, r2
 3f12d68:	8596302c 	ldrhi	r3, [r6, #44]
 3f12d6c:	80654003 	rsbhi	r4, r5, r3
  if (n > z->avail_out) n = z->avail_out;
 3f12d70:	e5973010 	ldr	r3, [r7, #16]
  if (n && r == Z_BUF_ERROR) r = Z_OK;

  /* update counters */
  z->avail_out -= n;
  z->total_out += n;
 3f12d74:	e5972014 	ldr	r2, [r7, #20]
 3f12d78:	e1540003 	cmp	r4, r3
 3f12d7c:	21a04003 	movcs	r4, r3
 3f12d80:	e0643003 	rsb	r3, r4, r3
 3f12d84:	e0822004 	add	r2, r2, r4
 3f12d88:	e5873010 	str	r3, [r7, #16]
 3f12d8c:	e3790005 	cmn	r9, #5	; 0x5
 3f12d90:	13a03000 	movne	r3, #0	; 0x0
 3f12d94:	03a03001 	moveq	r3, #1	; 0x1
 3f12d98:	e3540000 	cmp	r4, #0	; 0x0
 3f12d9c:	03a03000 	moveq	r3, #0	; 0x0
 3f12da0:	e5872014 	str	r2, [r7, #20]
 3f12da4:	e3530000 	cmp	r3, #0	; 0x0

  /* update check information */
  if (s->checkfn != Z_NULL)
 3f12da8:	e596c038 	ldr	r12, [r6, #56]
 3f12dac:	13a09000 	movne	r9, #0	; 0x0
 3f12db0:	e35c0000 	cmp	r12, #0	; 0x0
 3f12db4:	0a000005 	beq	3f12dd0 <inflate_flush+0x94>
    s->check = (*s->checkfn)(s->check, q, n);
 3f12db8:	e1a01005 	mov	r1, r5
 3f12dbc:	e596003c 	ldr	r0, [r6, #60]
 3f12dc0:	e1a02004 	mov	r2, r4
 3f12dc4:	e1a0e00f 	mov	r14, r15
 3f12dc8:	e1a0f00c 	mov	r15, r12
 3f12dcc:	e586003c 	str	r0, [r6, #60]

  /* output callback */
  if (z->outcb != Z_NULL)
 3f12dd0:	e5973030 	ldr	r3, [r7, #48]
 3f12dd4:	e3530000 	cmp	r3, #0	; 0x0
 3f12dd8:	0a000003 	beq	3f12dec <inflate_flush+0xb0>
    (*z->outcb)(q, n);
 3f12ddc:	e1a00005 	mov	r0, r5
 3f12de0:	e1a01004 	mov	r1, r4
 3f12de4:	e1a0e00f 	mov	r14, r15
 3f12de8:	e1a0f003 	mov	r15, r3

  /* copy as far as end of window */
  zmemcpy(p, q, n);
 3f12dec:	e1a0000a 	mov	r0, r10
 3f12df0:	e1a01005 	mov	r1, r5
 3f12df4:	e1a02004 	mov	r2, r4
 3f12df8:	ebfff1e2 	bl	3f0f588 <memcpy>
  p += n;
 3f12dfc:	e08aa004 	add	r10, r10, r4
  q += n;

  /* see if more to copy at beginning of window */
  if (q == s->end)
 3f12e00:	e596202c 	ldr	r2, [r6, #44]
 3f12e04:	e0855004 	add	r5, r5, r4
 3f12e08:	e1550002 	cmp	r5, r2
 3f12e0c:	1a00002a 	bne	3f12ebc <inflate_flush+0x180>
  {
    /* wrap pointers */
    q = s->window;
    if (s->write == s->end)
 3f12e10:	e5963034 	ldr	r3, [r6, #52]
 3f12e14:	e5965028 	ldr	r5, [r6, #40]
 3f12e18:	e1530002 	cmp	r3, r2
      s->write = s->window;
 3f12e1c:	05865034 	streq	r5, [r6, #52]

    /* compute bytes to copy */
    n = (uInt)(s->write - q);
 3f12e20:	e5962034 	ldr	r2, [r6, #52]
    if (n > z->avail_out) n = z->avail_out;
 3f12e24:	e5973010 	ldr	r3, [r7, #16]
 3f12e28:	e0654002 	rsb	r4, r5, r2
 3f12e2c:	e1540003 	cmp	r4, r3
 3f12e30:	21a04003 	movcs	r4, r3
    if (n && r == Z_BUF_ERROR) r = Z_OK;

    /* update counters */
    z->avail_out -= n;
 3f12e34:	e0643003 	rsb	r3, r4, r3
 3f12e38:	e5873010 	str	r3, [r7, #16]
 3f12e3c:	e3790005 	cmn	r9, #5	; 0x5
 3f12e40:	13a03000 	movne	r3, #0	; 0x0
 3f12e44:	03a03001 	moveq	r3, #1	; 0x1
 3f12e48:	e3540000 	cmp	r4, #0	; 0x0
    z->total_out += n;
 3f12e4c:	e5972014 	ldr	r2, [r7, #20]
 3f12e50:	03a03000 	moveq	r3, #0	; 0x0
 3f12e54:	e0822004 	add	r2, r2, r4
 3f12e58:	e5872014 	str	r2, [r7, #20]
 3f12e5c:	e3530000 	cmp	r3, #0	; 0x0

    /* update check information */
    if (s->checkfn != Z_NULL)
 3f12e60:	e596c038 	ldr	r12, [r6, #56]
 3f12e64:	13a09000 	movne	r9, #0	; 0x0
 3f12e68:	e35c0000 	cmp	r12, #0	; 0x0
 3f12e6c:	0a000005 	beq	3f12e88 <inflate_flush+0x14c>
      s->check = (*s->checkfn)(s->check, q, n);
 3f12e70:	e1a01005 	mov	r1, r5
 3f12e74:	e596003c 	ldr	r0, [r6, #60]
 3f12e78:	e1a02004 	mov	r2, r4
 3f12e7c:	e1a0e00f 	mov	r14, r15
 3f12e80:	e1a0f00c 	mov	r15, r12
 3f12e84:	e586003c 	str	r0, [r6, #60]

    /* output callback */
    if (z->outcb != Z_NULL)
 3f12e88:	e5973030 	ldr	r3, [r7, #48]
 3f12e8c:	e3530000 	cmp	r3, #0	; 0x0
 3f12e90:	0a000003 	beq	3f12ea4 <inflate_flush+0x168>
	(*z->outcb)(q, n);
 3f12e94:	e1a00005 	mov	r0, r5
 3f12e98:	e1a01004 	mov	r1, r4
 3f12e9c:	e1a0e00f 	mov	r14, r15
 3f12ea0:	e1a0f003 	mov	r15, r3

    /* copy */
    zmemcpy(p, q, n);
 3f12ea4:	e1a0000a 	mov	r0, r10
 3f12ea8:	e1a01005 	mov	r1, r5
 3f12eac:	e1a02004 	mov	r2, r4
 3f12eb0:	ebfff1b4 	bl	3f0f588 <memcpy>
    p += n;
 3f12eb4:	e08aa004 	add	r10, r10, r4
    q += n;
 3f12eb8:	e0855004 	add	r5, r5, r4
  }

  /* update pointers */
  z->next_out = p;
 3f12ebc:	e587a00c 	str	r10, [r7, #12]
  s->read = q;

  /* done */
  return r;
 3f12ec0:	e1a00009 	mov	r0, r9
 3f12ec4:	e5865030 	str	r5, [r6, #48]
}
 3f12ec8:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f12ecc <inflate_fast>:
 3f12ecc:	e1a0c00d 	mov	r12, r13
 3f12ed0:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f12ed4:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f12ed8:	e24dd010 	sub	r13, r13, #16	; 0x10


/*+++++*/
/* inffast.c -- process literals and length/distance pairs fast
 * Copyright (C) 1995 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* simplify the use of the inflate_huft type with some defines */
#define base more.Base
#define next more.Next
#define exop word.what.Exop
#define bits word.what.Bits

/* macros for bit input with no checking and for returning unused bytes */
#define GRABBITS(j) {while(k<(j)){b|=((uLong)NEXTBYTE)<<k;k+=8;}}
#define UNGRAB {n+=(c=k>>3);p-=c;k&=7;}

/* Called with number of bytes left to write in window at least 258
   (the maximum string length) and number of input bytes available
   at least ten.  The ten bytes are six bytes for the longest length/
   distance pair plus four bytes for overloading the bit buffer. */

local int inflate_fast(bl, bd, tl, td, s, z)
uInt bl, bd;
inflate_huft *tl, *td;
inflate_blocks_statef *s;
z_stream *z;
{
  inflate_huft *t;      /* temporary pointer */
  uInt e;               /* extra bits or operation */
  uLong b;              /* bit buffer */
  uInt k;               /* bits in bit buffer */
  Bytef *p;             /* input data pointer */
  uInt n;               /* bytes available there */
  Bytef *q;             /* output window write pointer */
  uInt m;               /* bytes to end of window or read pointer */
  uInt ml;              /* mask for literal/length tree */
  uInt md;              /* mask for distance tree */
  uInt c;               /* bytes to copy */
  uInt d;               /* distance back to copy from */
  Bytef *r;             /* copy source pointer */

  /* load input, output, bit values */
  LOAD
 3f12edc:	e99b0600 	ldmib	r11, {r9, r10}
 3f12ee0:	e59a6000 	ldr	r6, [r10]
 3f12ee4:	e59a5004 	ldr	r5, [r10, #4]
 3f12ee8:	e5994024 	ldr	r4, [r9, #36]
 3f12eec:	e5997034 	ldr	r7, [r9, #52]
 3f12ef0:	e599c030 	ldr	r12, [r9, #48]
 3f12ef4:	e599e020 	ldr	r14, [r9, #32]
 3f12ef8:	e50b2028 	str	r2, [r11, -#40]
 3f12efc:	e50b302c 	str	r3, [r11, -#44]
 3f12f00:	e157000c 	cmp	r7, r12
 3f12f04:	2a000013 	bcs	3f12f58 <inflate_fast+0x8c>
 3f12f08:	e067300c 	rsb	r3, r7, r12
 3f12f0c:	e2439001 	sub	r9, r3, #1	; 0x1
 3f12f10:	ea000013 	b	3f12f64 <inflate_fast+0x98>

  /* initialize masks */
  ml = inflate_mask[bl];
  md = inflate_mask[bd];

  /* do until not enough input or output space for fast loop */
  do {                          /* assume called with m >= 258 && n >= 10 */
    /* get literal/length code */
    GRABBITS(20)                /* max bits for literal/length code */
    if ((e = (t = tl + ((uInt)b & ml))->exop) == 0)
    {
      DUMPBITS(t->bits)
      Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
		"inflate:         * literal '%c'\n" :
		"inflate:         * literal 0x%02x\n", t->base));
      *q++ = (Byte)t->base;
      m--;
      continue;
    }
    do {
      DUMPBITS(t->bits)
      if (e & 16)
      {
	/* get extra bits for length */
	e &= 15;
	c = t->base + ((uInt)b & inflate_mask[e]);
	DUMPBITS(e)
	Tracevv((stderr, "inflate:         * length %u\n", c));

	/* decode distance base of block to copy */
	GRABBITS(15);           /* max bits for distance code */
	e = (t = td + ((uInt)b & md))->exop;
	do {
	  DUMPBITS(t->bits)
	  if (e & 16)
	  {
	    /* get extra bits to add to distance base */
	    e &= 15;
	    GRABBITS(e)         /* get extra bits (up to 13) */
	    d = t->base + ((uInt)b & inflate_mask[e]);
	    DUMPBITS(e)
	    Tracevv((stderr, "inflate:         * distance %u\n", d));

	    /* do the copy */
	    m -= c;
	    if ((uInt)(q - s->window) >= d)     /* offset before dest */
	    {                                   /*  just copy */
	      r = q - d;
	      *q++ = *r++;  c--;        /* minimum count is three, */
	      *q++ = *r++;  c--;        /*  so unroll loop a little */
	    }
	    else                        /* else offset after destination */
	    {
	      e = d - (q - s->window);  /* bytes from offset to end */
	      r = s->end - e;           /* pointer to offset */
	      if (c > e)                /* if source crosses, */
	      {
		c -= e;                 /* copy to end of window */
		do {
		  *q++ = *r++;
		} while (--e);
		r = s->window;          /* copy rest from start of window */
	      }
	    }
	    do {                        /* copy all or what's left */
	      *q++ = *r++;
	    } while (--c);
	    break;
	  }
	  else if ((e & 64) == 0)
	    e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop;
	  else
	  {
	    z->msg = "invalid distance code";
	    UNGRAB
	    UPDATE
	    return Z_DATA_ERROR;
	  }
	} while (1);
	break;
      }
      if ((e & 64) == 0)
      {
	if ((e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop) == 0)
	{
	  DUMPBITS(t->bits)
	  Tracevv((stderr, t->base >= 0x20 && t->base < 0x7f ?
		    "inflate:         * literal '%c'\n" :
		    "inflate:         * literal 0x%02x\n", t->base));
	  *q++ = (Byte)t->base;
	  m--;
	  break;
	}
      }
      else if (e & 32)
      {
	Tracevv((stderr, "inflate:         * end of block\n"));
	UNGRAB
	UPDATE
 3f12f14:	e59bc004 	ldr	r12, [r11, #4]
 3f12f18:	e1a001ae 	mov	r0, r14, lsr #3
 3f12f1c:	e58c4024 	str	r4, [r12, #36]
 3f12f20:	e20ee007 	and	r14, r14, #7	; 0x7
 3f12f24:	e58ce020 	str	r14, [r12, #32]
 3f12f28:	e0855000 	add	r5, r5, r0
 3f12f2c:	e58a5004 	str	r5, [r10, #4]
 3f12f30:	e59a2000 	ldr	r2, [r10]
 3f12f34:	e0606006 	rsb	r6, r0, r6
 3f12f38:	e58a6000 	str	r6, [r10]
 3f12f3c:	e59a3008 	ldr	r3, [r10, #8]
 3f12f40:	e0622006 	rsb	r2, r2, r6
 3f12f44:	e0833002 	add	r3, r3, r2
 3f12f48:	e58a3008 	str	r3, [r10, #8]
	return Z_STREAM_END;
 3f12f4c:	e3a00001 	mov	r0, #1	; 0x1
 3f12f50:	e58c7034 	str	r7, [r12, #52]
 3f12f54:	ea0000bf 	b	3f13258 <inflate_fast+0x38c>
 3f12f58:	e59b2004 	ldr	r2, [r11, #4]
 3f12f5c:	e592302c 	ldr	r3, [r2, #44]
 3f12f60:	e0679003 	rsb	r9, r7, r3
 3f12f64:	e59f3278 	ldr	r3, [pc, #278]	; 3f131e4 <inflate_fast+0x318>
 3f12f68:	e7930100 	ldr	r0, [r3, r0, lsl #2]
 3f12f6c:	e50b0030 	str	r0, [r11, -#48]
 3f12f70:	e7931101 	ldr	r1, [r3, r1, lsl #2]
 3f12f74:	e50b1034 	str	r1, [r11, -#52]
 3f12f78:	ea000003 	b	3f12f8c <inflate_fast+0xc0>
 3f12f7c:	e4d63001 	ldrb	r3, [r6], #1
 3f12f80:	e2455001 	sub	r5, r5, #1	; 0x1
 3f12f84:	e1844e13 	orr	r4, r4, r3, lsl r14
 3f12f88:	e28ee008 	add	r14, r14, #8	; 0x8
 3f12f8c:	e35e0013 	cmp	r14, #19	; 0x13
 3f12f90:	9afffff9 	bls	3f12f7c <inflate_fast+0xb0>
 3f12f94:	e51bc030 	ldr	r12, [r11, -#48]
 3f12f98:	e51b2028 	ldr	r2, [r11, -#40]
 3f12f9c:	e004300c 	and	r3, r4, r12
 3f12fa0:	ea00006e 	b	3f13160 <inflate_fast+0x294>
 3f12fa4:	e5d13001 	ldrb	r3, [r1, #1]
 3f12fa8:	e31c0010 	tst	r12, #16	; 0x10
 3f12fac:	e1a04334 	mov	r4, r4, lsr r3
 3f12fb0:	e063e00e 	rsb	r14, r3, r14
 3f12fb4:	0a000063 	beq	3f13148 <inflate_fast+0x27c>
 3f12fb8:	e20cc00f 	and	r12, r12, #15	; 0xf
 3f12fbc:	e59f2220 	ldr	r2, [pc, #220]	; 3f131e4 <inflate_fast+0x318>
 3f12fc0:	e06ce00e 	rsb	r14, r12, r14
 3f12fc4:	e792310c 	ldr	r3, [r2, r12, lsl #2]
 3f12fc8:	e35e000e 	cmp	r14, #14	; 0xe
 3f12fcc:	e5912004 	ldr	r2, [r1, #4]
 3f12fd0:	e0043003 	and	r3, r4, r3
 3f12fd4:	e0820003 	add	r0, r2, r3
 3f12fd8:	e1a04c34 	mov	r4, r4, lsr r12
 3f12fdc:	8a000005 	bhi	3f12ff8 <inflate_fast+0x12c>
 3f12fe0:	e4d63001 	ldrb	r3, [r6], #1
 3f12fe4:	e2455001 	sub	r5, r5, #1	; 0x1
 3f12fe8:	e1844e13 	orr	r4, r4, r3, lsl r14
 3f12fec:	e28ee008 	add	r14, r14, #8	; 0x8
 3f12ff0:	e35e000e 	cmp	r14, #14	; 0xe
 3f12ff4:	9afffff9 	bls	3f12fe0 <inflate_fast+0x114>
 3f12ff8:	e51bc034 	ldr	r12, [r11, -#52]
 3f12ffc:	e51b202c 	ldr	r2, [r11, -#44]
 3f13000:	e004300c 	and	r3, r4, r12
 3f13004:	e1a03183 	mov	r3, r3, lsl #3
 3f13008:	e0821003 	add	r1, r2, r3
 3f1300c:	e7d2c003 	ldrb	r12, [r2, r3]
 3f13010:	e5d13001 	ldrb	r3, [r1, #1]
 3f13014:	e31c0010 	tst	r12, #16	; 0x10
 3f13018:	e1a04334 	mov	r4, r4, lsr r3
 3f1301c:	e063e00e 	rsb	r14, r3, r14
 3f13020:	0a00002e 	beq	3f130e0 <inflate_fast+0x214>
 3f13024:	e20cc00f 	and	r12, r12, #15	; 0xf
 3f13028:	e15e000c 	cmp	r14, r12
 3f1302c:	2a000005 	bcs	3f13048 <inflate_fast+0x17c>
 3f13030:	e4d63001 	ldrb	r3, [r6], #1
 3f13034:	e2455001 	sub	r5, r5, #1	; 0x1
 3f13038:	e1844e13 	orr	r4, r4, r3, lsl r14
 3f1303c:	e28ee008 	add	r14, r14, #8	; 0x8
 3f13040:	e15e000c 	cmp	r14, r12
 3f13044:	3afffff9 	bcc	3f13030 <inflate_fast+0x164>
 3f13048:	e59f3194 	ldr	r3, [pc, #194]	; 3f131e4 <inflate_fast+0x318>
 3f1304c:	e793310c 	ldr	r3, [r3, r12, lsl #2]
 3f13050:	e06ce00e 	rsb	r14, r12, r14
 3f13054:	e5911004 	ldr	r1, [r1, #4]
 3f13058:	e0043003 	and	r3, r4, r3
 3f1305c:	e1a04c34 	mov	r4, r4, lsr r12
 3f13060:	e59bc004 	ldr	r12, [r11, #4]
 3f13064:	e0609009 	rsb	r9, r0, r9
 3f13068:	e59c2028 	ldr	r2, [r12, #40]
 3f1306c:	e0811003 	add	r1, r1, r3
 3f13070:	e0622007 	rsb	r2, r2, r7
 3f13074:	e1520001 	cmp	r2, r1
 3f13078:	3a000006 	bcc	3f13098 <inflate_fast+0x1cc>
 3f1307c:	e0611007 	rsb	r1, r1, r7
 3f13080:	e4d13001 	ldrb	r3, [r1], #1
 3f13084:	e4c73001 	strb	r3, [r7], #1
 3f13088:	e4d13001 	ldrb	r3, [r1], #1
 3f1308c:	e2400002 	sub	r0, r0, #2	; 0x2
 3f13090:	e4c73001 	strb	r3, [r7], #1
 3f13094:	ea00000c 	b	3f130cc <inflate_fast+0x200>
 3f13098:	e062c001 	rsb	r12, r2, r1
 3f1309c:	e59b2004 	ldr	r2, [r11, #4]
 3f130a0:	e592302c 	ldr	r3, [r2, #44]
 3f130a4:	e150000c 	cmp	r0, r12
 3f130a8:	e06c1003 	rsb	r1, r12, r3
 3f130ac:	9a000006 	bls	3f130cc <inflate_fast+0x200>
 3f130b0:	e06c0000 	rsb	r0, r12, r0
 3f130b4:	e4d13001 	ldrb	r3, [r1], #1
 3f130b8:	e25cc001 	subs	r12, r12, #1	; 0x1
 3f130bc:	e4c73001 	strb	r3, [r7], #1
 3f130c0:	1afffffb 	bne	3f130b4 <inflate_fast+0x1e8>
 3f130c4:	e59b3004 	ldr	r3, [r11, #4]
 3f130c8:	e5931028 	ldr	r1, [r3, #40]
 3f130cc:	e4d13001 	ldrb	r3, [r1], #1
 3f130d0:	e2500001 	subs	r0, r0, #1	; 0x1
 3f130d4:	e4c73001 	strb	r3, [r7], #1
 3f130d8:	1afffffb 	bne	3f130cc <inflate_fast+0x200>
 3f130dc:	ea000043 	b	3f131f0 <inflate_fast+0x324>
 3f130e0:	e31c0040 	tst	r12, #64	; 0x40
 3f130e4:	059f20f8 	ldreq	r2, [pc, #f8]	; 3f131e4 <inflate_fast+0x318>
 3f130e8:	0792310c 	ldreq	r3, [r2, r12, lsl #2]
 3f130ec:	05912004 	ldreq	r2, [r1, #4]
 3f130f0:	00043003 	andeq	r3, r4, r3
 3f130f4:	0affffc2 	beq	3f13004 <inflate_fast+0x138>
 3f130f8:	e59f30e8 	ldr	r3, [pc, #e8]	; 3f131e8 <inflate_fast+0x31c>
 3f130fc:	e59b9004 	ldr	r9, [r11, #4]
 3f13100:	e58a3018 	str	r3, [r10, #24]
 3f13104:	e59b3004 	ldr	r3, [r11, #4]
 3f13108:	e1a001ae 	mov	r0, r14, lsr #3
 3f1310c:	e5834024 	str	r4, [r3, #36]
 3f13110:	e20ee007 	and	r14, r14, #7	; 0x7
 3f13114:	e583e020 	str	r14, [r3, #32]
 3f13118:	e0855000 	add	r5, r5, r0
 3f1311c:	e58a5004 	str	r5, [r10, #4]
 3f13120:	e59a2000 	ldr	r2, [r10]
 3f13124:	e0606006 	rsb	r6, r0, r6
 3f13128:	e58a6000 	str	r6, [r10]
 3f1312c:	e59a3008 	ldr	r3, [r10, #8]
 3f13130:	e0622006 	rsb	r2, r2, r6
 3f13134:	e0833002 	add	r3, r3, r2
 3f13138:	e58a3008 	str	r3, [r10, #8]
 3f1313c:	e3e00002 	mvn	r0, #2	; 0x2
 3f13140:	e5897034 	str	r7, [r9, #52]
 3f13144:	ea000043 	b	3f13258 <inflate_fast+0x38c>
 3f13148:	e31c0040 	tst	r12, #64	; 0x40
 3f1314c:	1a00000f 	bne	3f13190 <inflate_fast+0x2c4>
 3f13150:	e59f308c 	ldr	r3, [pc, #8c]	; 3f131e4 <inflate_fast+0x318>
 3f13154:	e793310c 	ldr	r3, [r3, r12, lsl #2]
 3f13158:	e5912004 	ldr	r2, [r1, #4]
 3f1315c:	e0043003 	and	r3, r4, r3
 3f13160:	e1a03183 	mov	r3, r3, lsl #3
 3f13164:	e7d2c003 	ldrb	r12, [r2, r3]
 3f13168:	e0821003 	add	r1, r2, r3
 3f1316c:	e35c0000 	cmp	r12, #0	; 0x0
 3f13170:	1affff8b 	bne	3f12fa4 <inflate_fast+0xd8>
 3f13174:	e5d12001 	ldrb	r2, [r1, #1]
 3f13178:	e2499001 	sub	r9, r9, #1	; 0x1
 3f1317c:	e5d13004 	ldrb	r3, [r1, #4]
 3f13180:	e1a04234 	mov	r4, r4, lsr r2
 3f13184:	e062e00e 	rsb	r14, r2, r14
 3f13188:	e4c73001 	strb	r3, [r7], #1
 3f1318c:	ea000017 	b	3f131f0 <inflate_fast+0x324>
 3f13190:	e31c0020 	tst	r12, #32	; 0x20
 3f13194:	1affff5e 	bne	3f12f14 <inflate_fast+0x48>
      }
      else
      {
	z->msg = "invalid literal/length code";
 3f13198:	e59f304c 	ldr	r3, [pc, #4c]	; 3f131ec <inflate_fast+0x320>
	UNGRAB
	UPDATE
 3f1319c:	e59bc004 	ldr	r12, [r11, #4]
 3f131a0:	e58a3018 	str	r3, [r10, #24]
 3f131a4:	e1a001ae 	mov	r0, r14, lsr #3
 3f131a8:	e58c4024 	str	r4, [r12, #36]
 3f131ac:	e20ee007 	and	r14, r14, #7	; 0x7
 3f131b0:	e58ce020 	str	r14, [r12, #32]
 3f131b4:	e0855000 	add	r5, r5, r0
 3f131b8:	e58a5004 	str	r5, [r10, #4]
 3f131bc:	e59a2000 	ldr	r2, [r10]
 3f131c0:	e0606006 	rsb	r6, r0, r6
 3f131c4:	e58a6000 	str	r6, [r10]
 3f131c8:	e59a3008 	ldr	r3, [r10, #8]
 3f131cc:	e0622006 	rsb	r2, r2, r6
 3f131d0:	e0833002 	add	r3, r3, r2
 3f131d4:	e58a3008 	str	r3, [r10, #8]
	return Z_DATA_ERROR;
 3f131d8:	e3e00002 	mvn	r0, #2	; 0x2
 3f131dc:	e58c7034 	str	r7, [r12, #52]
 3f131e0:	ea00001c 	b	3f13258 <inflate_fast+0x38c>
 3f131e4:	03f20dd0 	mvneqs	r0, #13312	; 0x3400
 3f131e8:	03f1f7f8 	mvneqs	r15, #65011712	; 0x3e00000
 3f131ec:	03f1f7dc 	mvneqs	r15, #57671680	; 0x3700000
      }
    } while (1);
  } while (m >= 258 && n >= 10);
 3f131f0:	e59f2064 	ldr	r2, [pc, #64]	; 3f1325c <inflate_fast+0x390>
 3f131f4:	e3550009 	cmp	r5, #9	; 0x9
 3f131f8:	93a03000 	movls	r3, #0	; 0x0
 3f131fc:	83a03001 	movhi	r3, #1	; 0x1
 3f13200:	e1590002 	cmp	r9, r2
 3f13204:	81a01003 	movhi	r1, r3
 3f13208:	93a01000 	movls	r1, #0	; 0x0
 3f1320c:	e3510000 	cmp	r1, #0	; 0x0
 3f13210:	1affff5d 	bne	3f12f8c <inflate_fast+0xc0>

  /* not enough input or output--restore pointers and return */
  UNGRAB
  UPDATE
 3f13214:	e59b2004 	ldr	r2, [r11, #4]
 3f13218:	e1a001ae 	mov	r0, r14, lsr #3
 3f1321c:	e5824024 	str	r4, [r2, #36]
 3f13220:	e20ee007 	and	r14, r14, #7	; 0x7
 3f13224:	e582e020 	str	r14, [r2, #32]
 3f13228:	e0855000 	add	r5, r5, r0
 3f1322c:	e58a5004 	str	r5, [r10, #4]
 3f13230:	e59a2000 	ldr	r2, [r10]
 3f13234:	e0606006 	rsb	r6, r0, r6
 3f13238:	e58a6000 	str	r6, [r10]
 3f1323c:	e59a3008 	ldr	r3, [r10, #8]
 3f13240:	e0622006 	rsb	r2, r2, r6
 3f13244:	e0833002 	add	r3, r3, r2
 3f13248:	e58a3008 	str	r3, [r10, #8]
 3f1324c:	e59b3004 	ldr	r3, [r11, #4]
  return Z_OK;
 3f13250:	e1a00001 	mov	r0, r1
 3f13254:	e5837034 	str	r7, [r3, #52]
 3f13258:	ea000000 	b	3f13260 <inflate_fast+0x394>
 3f1325c:	00000101 	andeq	r0, r0, r1, lsl #2
}
 3f13260:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f13264 <adler32>:
 3f13264:	e1a0c00d 	mov	r12, r13
 3f13268:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f1326c:	e24cb004 	sub	r11, r12, #4	; 0x4


/*+++++*/
/* zutil.c -- target dependent utility functions for the compression library
 * Copyright (C) 1995 Jean-loup Gailly.
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* From: zutil.c,v 1.8 1995/05/03 17:27:12 jloup Exp */

char *zlib_version = ZLIB_VERSION;

char *z_errmsg[] = {
"stream end",          /* Z_STREAM_END    1 */
"",                    /* Z_OK            0 */
"file error",          /* Z_ERRNO        (-1) */
"stream error",        /* Z_STREAM_ERROR (-2) */
"data error",          /* Z_DATA_ERROR   (-3) */
"insufficient memory", /* Z_MEM_ERROR    (-4) */
"buffer error",        /* Z_BUF_ERROR    (-5) */
""};


/*+++++*/
/* adler32.c -- compute the Adler-32 checksum of a data stream
 * Copyright (C) 1995 Mark Adler
 * For conditions of distribution and use, see copyright notice in zlib.h
 */

/* From: adler32.c,v 1.6 1995/05/03 17:27:08 jloup Exp */

#define BASE 65521L /* largest prime smaller than 65536 */
#define NMAX 5552
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */

#define DO1(buf)  {s1 += *buf++; s2 += s1;}
#define DO2(buf)  DO1(buf); DO1(buf);
#define DO4(buf)  DO2(buf); DO2(buf);
#define DO8(buf)  DO4(buf); DO4(buf);
#define DO16(buf) DO8(buf); DO8(buf);

/* ========================================================================= */
uLong adler32(adler, buf, len)
    uLong adler;
    Bytef *buf;
    uInt len;
{
 3f13270:	e1a04002 	mov	r4, r2
    unsigned long s1 = adler & 0xffff;
 3f13274:	e59f3158 	ldr	r3, [pc, #158]	; 3f133d4 <adler32+0x170>
    unsigned long s2 = (adler >> 16) & 0xffff;
    int k;

    if (buf == Z_NULL) return 1L;
 3f13278:	e251e000 	subs	r14, r1, #0	; 0x0
 3f1327c:	e000c003 	and	r12, r0, r3
 3f13280:	e0030820 	and	r0, r3, r0, lsr #16
 3f13284:	03a00001 	moveq	r0, #1	; 0x1
 3f13288:	091ba810 	ldmeqdb	r11, {r4, r11, r13, r15}

    while (len > 0) {
 3f1328c:	e3540000 	cmp	r4, #0	; 0x0
 3f13290:	0a00004d 	beq	3f133cc <adler32+0x168>
	k = len < NMAX ? len : NMAX;
 3f13294:	e59f313c 	ldr	r3, [pc, #13c]	; 3f133d8 <adler32+0x174>
 3f13298:	e1540003 	cmp	r4, r3
 3f1329c:	31a02004 	movcc	r2, r4
 3f132a0:	21a02003 	movcs	r2, r3
	len -= k;
 3f132a4:	e0624004 	rsb	r4, r2, r4
	while (k >= 16) {
 3f132a8:	e352000f 	cmp	r2, #15	; 0xf
 3f132ac:	da000032 	ble	3f1337c <adler32+0x118>
	    DO16(buf);
	    k -= 16;
 3f132b0:	e2422010 	sub	r2, r2, #16	; 0x10
 3f132b4:	e4de3001 	ldrb	r3, [r14], #1
	}
 3f132b8:	e352000f 	cmp	r2, #15	; 0xf
 3f132bc:	e08cc003 	add	r12, r12, r3
 3f132c0:	e4de3001 	ldrb	r3, [r14], #1
 3f132c4:	e080000c 	add	r0, r0, r12
 3f132c8:	e08cc003 	add	r12, r12, r3
 3f132cc:	e4de3001 	ldrb	r3, [r14], #1
 3f132d0:	e080000c 	add	r0, r0, r12
 3f132d4:	e08cc003 	add	r12, r12, r3
 3f132d8:	e4de3001 	ldrb	r3, [r14], #1
 3f132dc:	e080000c 	add	r0, r0, r12
 3f132e0:	e08cc003 	add	r12, r12, r3
 3f132e4:	e4de3001 	ldrb	r3, [r14], #1
 3f132e8:	e080000c 	add	r0, r0, r12
 3f132ec:	e08cc003 	add	r12, r12, r3
 3f132f0:	e4de3001 	ldrb	r3, [r14], #1
 3f132f4:	e080000c 	add	r0, r0, r12
 3f132f8:	e08cc003 	add	r12, r12, r3
 3f132fc:	e4de3001 	ldrb	r3, [r14], #1
 3f13300:	e080000c 	add	r0, r0, r12
 3f13304:	e08cc003 	add	r12, r12, r3
 3f13308:	e4de3001 	ldrb	r3, [r14], #1
 3f1330c:	e080000c 	add	r0, r0, r12
 3f13310:	e08cc003 	add	r12, r12, r3
 3f13314:	e4de3001 	ldrb	r3, [r14], #1
 3f13318:	e080000c 	add	r0, r0, r12
 3f1331c:	e08cc003 	add	r12, r12, r3
 3f13320:	e4de3001 	ldrb	r3, [r14], #1
 3f13324:	e080000c 	add	r0, r0, r12
 3f13328:	e08cc003 	add	r12, r12, r3
 3f1332c:	e4de3001 	ldrb	r3, [r14], #1
 3f13330:	e080000c 	add	r0, r0, r12
 3f13334:	e08cc003 	add	r12, r12, r3
 3f13338:	e4de3001 	ldrb	r3, [r14], #1
 3f1333c:	e080000c 	add	r0, r0, r12
 3f13340:	e08cc003 	add	r12, r12, r3
 3f13344:	e4de3001 	ldrb	r3, [r14], #1
 3f13348:	e080000c 	add	r0, r0, r12
 3f1334c:	e08cc003 	add	r12, r12, r3
 3f13350:	e4de3001 	ldrb	r3, [r14], #1
 3f13354:	e080000c 	add	r0, r0, r12
 3f13358:	e08cc003 	add	r12, r12, r3
 3f1335c:	e4de3001 	ldrb	r3, [r14], #1
 3f13360:	e080000c 	add	r0, r0, r12
 3f13364:	e08cc003 	add	r12, r12, r3
 3f13368:	e4de3001 	ldrb	r3, [r14], #1
 3f1336c:	e080000c 	add	r0, r0, r12
 3f13370:	e08cc003 	add	r12, r12, r3
 3f13374:	e080000c 	add	r0, r0, r12
 3f13378:	caffffcc 	bgt	3f132b0 <adler32+0x4c>
	if (k != 0) do {
 3f1337c:	e3520000 	cmp	r2, #0	; 0x0
 3f13380:	0a000004 	beq	3f13398 <adler32+0x134>
	    DO1(buf);
 3f13384:	e4de3001 	ldrb	r3, [r14], #1
	} while (--k);
 3f13388:	e2522001 	subs	r2, r2, #1	; 0x1
 3f1338c:	e08cc003 	add	r12, r12, r3
 3f13390:	e080000c 	add	r0, r0, r12
 3f13394:	1afffffa 	bne	3f13384 <adler32+0x120>
	s1 %= BASE;
 3f13398:	e59f203c 	ldr	r2, [pc, #3c]	; 3f133dc <adler32+0x178>
 3f1339c:	e0831c92 	umull	r1, r3, r2, r12
	s2 %= BASE;
 3f133a0:	e0821290 	umull	r1, r2, r0, r2
    }
 3f133a4:	e3540000 	cmp	r4, #0	; 0x0
 3f133a8:	e1a037a3 	mov	r3, r3, lsr #15
 3f133ac:	e0631603 	rsb	r1, r3, r3, lsl #12
 3f133b0:	e0833201 	add	r3, r3, r1, lsl #4
 3f133b4:	e063c00c 	rsb	r12, r3, r12
 3f133b8:	e1a027a2 	mov	r2, r2, lsr #15
 3f133bc:	e0623602 	rsb	r3, r2, r2, lsl #12
 3f133c0:	e0822203 	add	r2, r2, r3, lsl #4
 3f133c4:	e0620000 	rsb	r0, r2, r0
 3f133c8:	1affffb1 	bne	3f13294 <adler32+0x30>
    return (s2 << 16) | s1;
 3f133cc:	e18c0800 	orr	r0, r12, r0, lsl #16
}
 3f133d0:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f133d4:	0000ffff 	streqd	r15, [r0], -r15
 3f133d8:	000015b0 	streqh	r1, [r0], -r0
 3f133dc:	80078071 	andhi	r8, r7, r1, ror r0

03f133e0 <__udivsi3>:
 3f133e0:	e3510000 	cmp	r1, #0	; 0x0
 3f133e4:	0a00001f 	beq	3f13468 <Ldiv0>
 3f133e8:	e3a03001 	mov	r3, #1	; 0x1
 3f133ec:	e3a02000 	mov	r2, #0	; 0x0
 3f133f0:	e1500001 	cmp	r0, r1
 3f133f4:	3a000019 	bcc	3f13460 <Lgot_result>

03f133f8 <Loop1>:
 3f133f8:	e3510201 	cmp	r1, #268435456	; 0x10000000
 3f133fc:	31510000 	cmpcc	r1, r0
 3f13400:	31a01201 	movcc	r1, r1, lsl #4
 3f13404:	31a03203 	movcc	r3, r3, lsl #4
 3f13408:	3afffffa 	bcc	3f133f8 <Loop1>

03f1340c <Lbignum>:
 3f1340c:	e3510102 	cmp	r1, #-2147483648	; 0x80000000
 3f13410:	31510000 	cmpcc	r1, r0
 3f13414:	31a01081 	movcc	r1, r1, lsl #1
 3f13418:	31a03083 	movcc	r3, r3, lsl #1
 3f1341c:	3afffffa 	bcc	3f1340c <Lbignum>

03f13420 <Loop3>:
 3f13420:	e1500001 	cmp	r0, r1
 3f13424:	20400001 	subcs	r0, r0, r1
 3f13428:	21822003 	orrcs	r2, r2, r3
 3f1342c:	e15000a1 	cmp	r0, r1, lsr #1
 3f13430:	204000a1 	subcs	r0, r0, r1, lsr #1
 3f13434:	218220a3 	orrcs	r2, r2, r3, lsr #1
 3f13438:	e1500121 	cmp	r0, r1, lsr #2
 3f1343c:	20400121 	subcs	r0, r0, r1, lsr #2
 3f13440:	21822123 	orrcs	r2, r2, r3, lsr #2
 3f13444:	e15001a1 	cmp	r0, r1, lsr #3
 3f13448:	204001a1 	subcs	r0, r0, r1, lsr #3
 3f1344c:	218221a3 	orrcs	r2, r2, r3, lsr #3
 3f13450:	e3500000 	cmp	r0, #0	; 0x0
 3f13454:	11b03223 	movnes	r3, r3, lsr #4
 3f13458:	11a01221 	movne	r1, r1, lsr #4
 3f1345c:	1affffef 	bne	3f13420 <Loop3>

03f13460 <Lgot_result>:
 3f13460:	e1a00002 	mov	r0, r2
 3f13464:	e1a0f00e 	mov	r15, r14

03f13468 <Ldiv0>:
 3f13468:	e52de004 	str	r14, [r13, -#4]!
 3f1346c:	eb00002e 	bl	3f1352c <__div0>
 3f13470:	e3a00000 	mov	r0, #0	; 0x0
 3f13474:	e8bd8000 	ldmia	r13!, {r15}

03f13478 <__umodsi3>:
 3f13478:	e3510000 	cmp	r1, #0	; 0x0
 3f1347c:	0a000026 	beq	3f1351c <Ldiv0>
 3f13480:	e3a03001 	mov	r3, #1	; 0x1
 3f13484:	e1500001 	cmp	r0, r1
 3f13488:	31a0f00e 	movcc	r15, r14

03f1348c <Loop1>:
 3f1348c:	e3510201 	cmp	r1, #268435456	; 0x10000000
 3f13490:	31510000 	cmpcc	r1, r0
 3f13494:	31a01201 	movcc	r1, r1, lsl #4
 3f13498:	31a03203 	movcc	r3, r3, lsl #4
 3f1349c:	3afffffa 	bcc	3f1348c <Loop1>

03f134a0 <Lbignum>:
 3f134a0:	e3510102 	cmp	r1, #-2147483648	; 0x80000000
 3f134a4:	31510000 	cmpcc	r1, r0
 3f134a8:	31a01081 	movcc	r1, r1, lsl #1
 3f134ac:	31a03083 	movcc	r3, r3, lsl #1
 3f134b0:	3afffffa 	bcc	3f134a0 <Lbignum>

03f134b4 <Loop3>:
 3f134b4:	e3a02000 	mov	r2, #0	; 0x0
 3f134b8:	e1500001 	cmp	r0, r1
 3f134bc:	20400001 	subcs	r0, r0, r1
 3f134c0:	e15000a1 	cmp	r0, r1, lsr #1
 3f134c4:	204000a1 	subcs	r0, r0, r1, lsr #1
 3f134c8:	218220e3 	orrcs	r2, r2, r3, ror #1
 3f134cc:	e1500121 	cmp	r0, r1, lsr #2
 3f134d0:	20400121 	subcs	r0, r0, r1, lsr #2
 3f134d4:	21822163 	orrcs	r2, r2, r3, ror #2
 3f134d8:	e15001a1 	cmp	r0, r1, lsr #3
 3f134dc:	204001a1 	subcs	r0, r0, r1, lsr #3
 3f134e0:	218221e3 	orrcs	r2, r2, r3, ror #3
 3f134e4:	e1a0c003 	mov	r12, r3
 3f134e8:	e3500000 	cmp	r0, #0	; 0x0
 3f134ec:	11b03223 	movnes	r3, r3, lsr #4
 3f134f0:	11a01221 	movne	r1, r1, lsr #4
 3f134f4:	1affffee 	bne	3f134b4 <Loop3>
 3f134f8:	e212220e 	ands	r2, r2, #-536870912	; 0xe0000000
 3f134fc:	01a0f00e 	moveq	r15, r14
 3f13500:	e11201ec 	tst	r2, r12, ror #3
 3f13504:	108001a1 	addne	r0, r0, r1, lsr #3
 3f13508:	e112016c 	tst	r2, r12, ror #2
 3f1350c:	10800121 	addne	r0, r0, r1, lsr #2
 3f13510:	e11200ec 	tst	r2, r12, ror #1
 3f13514:	108000a1 	addne	r0, r0, r1, lsr #1
 3f13518:	e1a0f00e 	mov	r15, r14

03f1351c <Ldiv0>:
 3f1351c:	e52de004 	str	r14, [r13, -#4]!
 3f13520:	eb000001 	bl	3f1352c <__div0>
 3f13524:	e3a00000 	mov	r0, #0	; 0x0
 3f13528:	e8bd8000 	ldmia	r13!, {r15}

03f1352c <__div0>:
 3f1352c:	e92d4002 	stmdb	r13!, {r1, r14}
 3f13530:	ef900014 	swi	0x00900014
 3f13534:	e3700ffa 	cmn	r0, #1000	; 0x3e8
 3f13538:	28bd8002 	ldmcsia	r13!, {r1, r15}
 3f1353c:	e3a01008 	mov	r1, #8	; 0x8
 3f13540:	ef900025 	swi	0x00900025
 3f13544:	e8bd8002 	ldmia	r13!, {r1, r15}

03f13548 <board_init>:
 3f13548:	e1a0c00d 	mov	r12, r13
 3f1354c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f13550:	e59f225c 	ldr	r2, [pc, #25c]	; 3f137b4 <board_init+0x26c>
	MMSP20_RTC  * const rtc = MMSP20_GetBase_RTC();

	/* Configure clock and poower */
	/* configure FPLL */
	clk_power->FPLLSETVREG  = ((F_MDIV << 8) + (F_PDIV << 2) + F_SDIV);
 3f13554:	e59f325c 	ldr	r3, [pc, #25c]	; 3f137b8 <board_init+0x270>
	return (MMSP20_GPIO * const)MMSP20_GPIO_BASE;
}
static inline MMSP20_RTC * const MMSP20_GetBase_RTC(void)
{
	return (MMSP20_RTC * const)MMSP20_RTC_BASE;
 3f13558:	e59f125c 	ldr	r1, [pc, #25c]	; 3f137bc <board_init+0x274>
 3f1355c:	e1c231b0 	strh	r3, [r2, #16]
	/* configure UPLL */
	clk_power->UPLLSETVREG  = ((U_MDIV << 8) + (U_PDIV << 2) + U_SDIV);
 3f13560:	e59f3258 	ldr	r3, [pc, #258]	; 3f137c0 <board_init+0x278>
 3f13564:	e1c231b4 	strh	r3, [r2, #20]
	/* configure APLL */
	clk_power->APLLSETVREG  = ((A_MDIV << 8) + (A_PDIV << 2) + A_SDIV);
 3f13568:	e2433b32 	sub	r3, r3, #51200	; 0xc800
 3f1356c:	e1c231b8 	strh	r3, [r2, #24]

	/*APLL, UPLL operation*/
	rtc->CLKMGRREG = (rtc->CLKMGRREG & 0xfffC) + 0x3;
 3f13570:	e1d131b2 	ldrh	r3, [r1, #18]
 3f13574:	e3833003 	orr	r3, r3, #3	; 0x3
 3f13578:	e1c131b2 	strh	r3, [r1, #18]


#if 0
	clk_power->SYSCLKENREG &= (~PWMCLK);
//	clk_power->COMCLKENREG &= (((~COMMNICATION_CLK_MASK)|UART0CLK|I2CCLK)) & COMMNICATION_CLK_MASK;
	clk_power->VGCLKENREG  &= (~(ISPCLK|DECSSCLK)) & ALL_VIDEO_CLK_MASK;
	clk_power->ASCLKENREG  &= (~(CDROMCLK|IDECLK|MSTICKCLK|SPDIFOCLK|SPDIFICLK|I2SCLK)) &
								AUDDIO_STORAGE_CLK_MASK;
#else	
	//clk_power->SYSCLKENREG &= ~(ESYSCLK|ADCCLK|PWMCLK|FASTIOCLK|MEMCCLK|A940TCLK);
	//clk_power->SYSCLKENREG &= ~(ESYSCLK|ADCCLK|PWMCLK|FASTIOCLK|A940TCLK);
	clk_power->SYSCLKENREG &= ~(ESYSCLK|PWMCLK|FASTIOCLK|A940TCLK);
 3f1357c:	e1d230b4 	ldrh	r3, [r2, #4]
 3f13580:	e3c33b15 	bic	r3, r3, #21504	; 0x5400
 3f13584:	e3c33001 	bic	r3, r3, #1	; 0x1
 3f13588:	e1a03803 	mov	r3, r3, lsl #16
 3f1358c:	e1a03823 	mov	r3, r3, lsr #16
 3f13590:	e1c230b4 	strh	r3, [r2, #4]
	//clk_power->COMCLKENREG &= ~(SSPCLK|I2CCLK|UART3CLK|UART2CLK|UART1CLK|OWMCLK|UDCCLK|UHCCLK);
	clk_power->COMCLKENREG &= ~(SSPCLK|UART3CLK|UART2CLK|UART1CLK|OWMCLK|UDCCLK|UHCCLK);
 3f13594:	e1d230b8 	ldrh	r3, [r2, #8]
 3f13598:	e3c33fba 	bic	r3, r3, #744	; 0x2e8
 3f1359c:	e3c33003 	bic	r3, r3, #3	; 0x3
 3f135a0:	e1a03803 	mov	r3, r3, lsl #16
 3f135a4:	e1a03823 	mov	r3, r3, lsr #16
 3f135a8:	e1c230b8 	strh	r3, [r2, #8]
	clk_power->VGCLKENREG  &= ~(DBLKCLK|MPGIFCLK|DECSSCLK|MECLK|REFWCLK|RVLDCLK|QGMCLK|MPMCLK|PDFCLK
 3f135ac:	e1d230ba 	ldrh	r3, [r2, #10]
 3f135b0:	e24cb004 	sub	r11, r12, #4	; 0x4
}

static inline MMSP20_BANC_MEMCTL * const MMSP20_GetBaseC_MEMCTL(void)
{
	return (MMSP20_BANC_MEMCTL * const)MMSP20_BANC_MEMCTL_BASE;
 3f135b4:	e59fc208 	ldr	r12, [pc, #208]	; 3f137c4 <board_init+0x27c>
 3f135b8:	e2033001 	and	r3, r3, #1	; 0x1
 3f135bc:	e1c230ba 	strh	r3, [r2, #10]
								|HUFFCLK|VPCLKGOFF|VPTOPCLK|ISPCLK|GRPCLK|SCALECLK);
	clk_power->ASCLKENREG  &= ~(CDROMCLK|IDECLK|MSTICKCLK|SPDIFOCLK|SPDIFICLK|I2SCLK);
 3f135c0:	e1d230bc 	ldrh	r3, [r2, #12]
	return (MMSP20_TIMER_WATCHDOG * const)MMSP20_TIMER_WATCHDOG_BASE;
}
static inline MMSP20_GPIO * const MMSP20_GetBase_GPIO(void)
{
	return (MMSP20_GPIO * const)MMSP20_GPIO_BASE;
 3f135c4:	e2811e42 	add	r1, r1, #1056	; 0x420
 3f135c8:	e3c33c32 	bic	r3, r3, #12800	; 0x3200
 3f135cc:	e3c3300e 	bic	r3, r3, #14	; 0xe
 3f135d0:	e1a03803 	mov	r3, r3, lsl #16
 3f135d4:	e1a03823 	mov	r3, r3, lsr #16
 3f135d8:	e1c230bc 	strh	r3, [r2, #12]
#endif
	
	/* configure Debug port */
	clk_power->URTCSETREG[0] = ((DEBUG_SRC << 6) + (DEBUG_DIVIDE << 0));
 3f135dc:	e3a030c9 	mov	r3, #201	; 0xc9
 3f135e0:	e1c232b8 	strh	r3, [r2, #40]
	/* some delay between MPLL and UPLL */
	delay (4000);
 3f135e4:	e3a03efa 	mov	r3, #4000	; 0xfa0
 3f135e8:	e2533001 	subs	r3, r3, #1	; 0x1
 3f135ec:	1afffffd 	bne	3f135e8 <board_init+0xa0>

/* GPIO configuration */
	/*Set MCU BUS*/
	gpio->GPIOALTFNLOW['E'-'A'] = ((ALTFN1 << 14)+(ALTFN1 << 12)+(ALTFN1 << 10)+(ALTFN1 << 8)+(ALTFN1 << 6)+(ALTFN1 << 4)+(ALTFN1 << 2)+(ALTFN1));
 3f135f0:	e59f21d0 	ldr	r2, [pc, #1d0]	; 3f137c8 <board_init+0x280>
 3f135f4:	e1c120b8 	strh	r2, [r1, #8]
	gpio->GPIOALTFNHI['E'-'A'] = ((ALTFN1<<14)+(ALTFN1<<12)+(ALTFN1<<10)+(ALTFN1<<8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1));
 3f135f8:	e1c122b8 	strh	r2, [r1, #40]
	gpio->GPIOALTFNLOW['F'-'A'] = ((ALTFN1<<14)+(ALTFN1<<12)+(ALTFN1<<10)+(ALTFN1<<8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1));
 3f135fc:	e1c120ba 	strh	r2, [r1, #10]
	gpio->GPIOALTFNHI['F'-'A'] = ((gpio->GPIOALTFNHI['F'-'A'] & ~0x3F)+ (ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1));
 3f13600:	e1d132ba 	ldrh	r3, [r1, #42]
 3f13604:	e3e0003f 	mvn	r0, #63	; 0x3f
 3f13608:	e0033000 	and	r3, r3, r0
 3f1360c:	e283302a 	add	r3, r3, #42	; 0x2a
 3f13610:	e1c132ba 	strh	r3, [r1, #42]
	gpio->GPIOALTFNLOW['G'-'A'] = ((ALTFN1<<14)+(ALTFN1<<12)+(ALTFN1<<10)+(ALTFN1<<8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1));
 3f13614:	e1c120bc 	strh	r2, [r1, #12]
	gpio->GPIOALTFNHI['G'-'A'] = ((ALTFN1<<14)+(ALTFN1<<12)+(ALTFN1<<10)+(ALTFN1<<8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1));
 3f13618:	e1c122bc 	strh	r2, [r1, #44]
	
	/* Set Lcd BUS */
	gpio->GPIOALTFNHI['B'-'A'] = ((ALTFN1<< 14)+(ALTFN1<< 12)+(ALTFN1<< 10)+(ALTFN1<< 8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1<< 0));
 3f1361c:	e1c122b2 	strh	r2, [r1, #34]
	gpio->GPIOALTFNLOW['A'-'A'] = ((ALTFN1<< 14)+(ALTFN1<< 12)+(ALTFN1<< 10)+(ALTFN1<< 8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1<< 0));
 3f13620:	e1c120b0 	strh	r2, [r1]
	gpio->GPIOALTFNHI['A'-'A'] = ((ALTFN1<< 14)+(ALTFN1<< 12)+(ALTFN1<< 10)+(ALTFN1<< 8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1<< 0));
	
	/*Set MCU Con*/
	gpio->GPIOALTFNLOW['I'-'A'] = ((ALTFN1<<14)+(ALTFN1<<12)+(ALTFN1<<10)+(ALTFN1<<8)+(IO_IN<< 6)+(IO_IN<< 4)+(ALTFN1<< 2)+(ALTFN1));
 3f13624:	e59f31a0 	ldr	r3, [pc, #1a0]	; 3f137cc <board_init+0x284>
 3f13628:	e1c122b0 	strh	r2, [r1, #32]
 3f1362c:	e1c131b0 	strh	r3, [r1, #16]
	gpio->GPIOALTFNHI['I'-'A'] = ((gpio->GPIOALTFNHI['I'-'A'] & 0xC000)+(ALTFN1<<12)+(ALTFN1<<10)+(ALTFN1<<8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1));
 3f13630:	e1d133b0 	ldrh	r3, [r1, #48]
 3f13634:	e2033903 	and	r3, r3, #49152	; 0xc000
 3f13638:	e3833daa 	orr	r3, r3, #10880	; 0x2a80
 3f1363c:	e383302a 	orr	r3, r3, #42	; 0x2a
 3f13640:	e1c133b0 	strh	r3, [r1, #48]
	gpio->GPIOALTFNLOW['J'-'A'] = ((ALTFN1<<14)+(ALTFN1<<12)+(ALTFN1<<10)+(ALTFN1<<8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1));
	gpio->GPIOALTFNHI['J'-'A'] = ((IO_IN<<14)+(IO_OUT<<12)+(IO_OUT<<10)+(ALTFN1<<8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1));
 3f13644:	e59f3184 	ldr	r3, [pc, #184]	; 3f137d0 <board_init+0x288>
 3f13648:	e1c121b2 	strh	r2, [r1, #18]
 3f1364c:	e1c133b2 	strh	r3, [r1, #50]
	
	/*Set UART*/
	gpio->GPIOALTFNLOW['D'-'A'] = ((ALTFN1<<14)+(ALTFN1<<12)+(ALTFN1<<10)+(ALTFN1<<8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(gpio->GPIOALTFNLOW['D'-'A'] & 0x3));
 3f13650:	e1d130b6 	ldrh	r3, [r1, #6]
 3f13654:	e2422002 	sub	r2, r2, #2	; 0x2
 3f13658:	e2033003 	and	r3, r3, #3	; 0x3
 3f1365c:	e1832002 	orr	r2, r3, r2
 3f13660:	e1c120b6 	strh	r2, [r1, #6]
	gpio->GPIOALTFNHI['D'-'A'] = ((gpio->GPIOALTFNHI['D'-'A'] & ~0x3F)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1));
 3f13664:	e1d132b6 	ldrh	r3, [r1, #38]
 3f13668:	e0033000 	and	r3, r3, r0
 3f1366c:	e283302a 	add	r3, r3, #42	; 0x2a
 3f13670:	e1c132b6 	strh	r3, [r1, #38]

	/* Sleep is tv(low) or reset(lcd,tv) high & lcd sync on*/
	gpio->GPIOALTFNLOW['B'-'A'] = ((gpio->GPIOALTFNLOW['B'-'A'] & ~0xFFF0)+(ALTFN1<< 14)+(ALTFN1<< 12)+(ALTFN1<< 10)+(ALTFN1<< 8)+(IO_OUT<< 6)+(IO_OUT<< 4));
 3f13674:	e1d130b2 	ldrh	r3, [r1, #2]
 3f13678:	e59f2154 	ldr	r2, [pc, #154]	; 3f137d4 <board_init+0x28c>
 3f1367c:	e203300f 	and	r3, r3, #15	; 0xf
 3f13680:	e1832002 	orr	r2, r3, r2
 3f13684:	e1c120b2 	strh	r2, [r1, #2]
	
	/* lcd sync no pullup */
	gpio->GPIOPUENB['B'-'A'] = ((gpio->GPIOPUENB['B'-'A'] & ~0xF0));
 3f13688:	e1d13ab2 	ldrh	r3, [r1, #162]
 3f1368c:	e3c330f0 	bic	r3, r3, #240	; 0xf0
 3f13690:	e1a03803 	mov	r3, r3, lsl #16
 3f13694:	e1a03823 	mov	r3, r3, lsr #16
 3f13698:	e1c13ab2 	strh	r3, [r1, #162]
        	 
	/* TV sleep */
	gpio->GPIOOUT['B'-'A'] = ((gpio->GPIOOUT['B'-'A'] & ~0x08)| TV_SLEEP );		
 3f1369c:	e1d134b2 	ldrh	r3, [r1, #66]
 3f136a0:	e3c33008 	bic	r3, r3, #8	; 0x8
 3f136a4:	e1a03803 	mov	r3, r3, lsl #16
 3f136a8:	e1a03823 	mov	r3, r3, lsr #16
 3f136ac:	e3833004 	orr	r3, r3, #4	; 0x4
 3f136b0:	e1c134b2 	strh	r3, [r1, #66]

#if 1	
	/*Set Volatege GPIOH control (TV,LCD) */
	gpio->GPIOALTFNLOW['H'-'A'] = ((gpio->GPIOALTFNLOW['H'-'A'] & ~0x3FF)+(IO_OUT<< 8)+(IO_OUT<< 6)+(IO_OUT<< 4)+(IO_OUT<< 2)+(IO_OUT));		
 3f136b4:	e1d130be 	ldrh	r3, [r1, #14]
 3f136b8:	e2033b3f 	and	r3, r3, #64512	; 0xfc00
 3f136bc:	e3833f55 	orr	r3, r3, #340	; 0x154
 3f136c0:	e3833001 	orr	r3, r3, #1	; 0x1
 3f136c4:	e1c130be 	strh	r3, [r1, #14]

	/*LCD BACK OFF & LCD_VGH_OFF & BATT_FAULT_LED_OFF & TV_SLEEP& LCD_AVDD_ON */
	//gpio->GPIOOUT['H'-'A'] = ((gpio->GPIOOUT['H'-'A'] & ~0x1F)+ AVDD_5V + BATT_LED );
	gpio->GPIOOUT['H'-'A'] = ((gpio->GPIOOUT['H'-'A'] & ~0xF)+ AVDD_5V + BATT_LED );
	delay(10);	
 3f136c8:	e3a0200a 	mov	r2, #10	; 0xa
 3f136cc:	e1d134be 	ldrh	r3, [r1, #78]
 3f136d0:	e1a00002 	mov	r0, r2
 3f136d4:	e3c3300f 	bic	r3, r3, #15	; 0xf
 3f136d8:	e1a03803 	mov	r3, r3, lsl #16
 3f136dc:	e1a03823 	mov	r3, r3, lsr #16
 3f136e0:	e2833018 	add	r3, r3, #24	; 0x18
 3f136e4:	e1c134be 	strh	r3, [r1, #78]
 3f136e8:	e2500001 	subs	r0, r0, #1	; 0x1
 3f136ec:	1afffffd 	bne	3f136e8 <board_init+0x1a0>
#endif
	
	/* LCD_VGH_ON */
	gpio->GPIOOUT['H'-'A'] =gpio->GPIOOUT['H'-'A'] | LCD_VGH;
 3f136f0:	e1d134be 	ldrh	r3, [r1, #78]
 3f136f4:	e3833002 	orr	r3, r3, #2	; 0x2
 3f136f8:	e1c134be 	strh	r3, [r1, #78]
 3f136fc:	e2522001 	subs	r2, r2, #1	; 0x1
 3f13700:	1afffffd 	bne	3f136fc <board_init+0x1b4>
	delay(10);
				
	/* usb reset */
	gpio->GPIOALTFNLOW['D'-'A'] = 
 3f13704:	e1d130b6 	ldrh	r3, [r1, #6]
 3f13708:	e3c33c03 	bic	r3, r3, #768	; 0x300
 3f1370c:	e1a03803 	mov	r3, r3, lsl #16
 3f13710:	e1a03823 	mov	r3, r3, lsr #16
 3f13714:	e2833c01 	add	r3, r3, #256	; 0x100
 3f13718:	e1c130b6 	strh	r3, [r1, #6]
		((gpio->GPIOALTFNLOW['D'-'A'] & (~(3<<8)))
			+(IO_OUT<< 8));
#if 1
	gpio->GPIOOUT['D'-'A'] =
 3f1371c:	e1d134b6 	ldrh	r3, [r1, #70]
 3f13720:	e3c33010 	bic	r3, r3, #16	; 0x10
 3f13724:	e1a03803 	mov	r3, r3, lsl #16
 3f13728:	e1a03823 	mov	r3, r3, lsr #16
 3f1372c:	e1c134b6 	strh	r3, [r1, #70]
		((gpio->GPIOOUT['D'-'A'] & ~(1<<4)));		
#else
	gpio->GPIOOUT['D'-'A'] =
		((gpio->GPIOOUT['D'-'A'] & ~(1<<4))|(1<<4));		
#endif

	/* LCD reset */
	gpio->GPIOOUT['B'-'A']|=LCDTV_RESET;
 3f13730:	e1d134b2 	ldrh	r3, [r1, #66]
 3f13734:	e3833008 	orr	r3, r3, #8	; 0x8
 3f13738:	e1c134b2 	strh	r3, [r1, #66]
	/* LCD_BACK_LIGHT_ON */
	gpio->GPIOOUT['H'-'A']|=BACK_LIGHT;
 3f1373c:	e1d134be 	ldrh	r3, [r1, #78]
 3f13740:	e3833004 	orr	r3, r3, #4	; 0x4
 3f13744:	e1c134be 	strh	r3, [r1, #78]
	
	gpio->GPIOALTFNLOW['L'-'A'] = (gpio->GPIOALTFNLOW['L'-'A'] & 0xF000) + (ALTFN1<<10)+(ALTFN1<<8)+(ALTFN1<< 6)+(ALTFN1<< 4)+(ALTFN1<< 2)+(ALTFN1<< 0);
 3f13748:	e1d131b6 	ldrh	r3, [r1, #22]
 3f1374c:	e2033a0f 	and	r3, r3, #61440	; 0xf000
 3f13750:	e3833eaa 	orr	r3, r3, #2720	; 0xaa0
 3f13754:	e383300a 	orr	r3, r3, #10	; 0xa
 3f13758:	e1c131b6 	strh	r3, [r1, #22]
	
	gpio->GPIOPUENB['L'-'A'] |= 0x003F;
 3f1375c:	e1d13bb6 	ldrh	r3, [r1, #182]
 3f13760:	e383303f 	orr	r3, r3, #63	; 0x3f
 3f13764:	e1c13bb6 	strh	r3, [r1, #182]


	/* BUS Interface setup for CS8900(Bank1) Ethernet Interface */
	memctl->MEMCFGW &= ~(0x02);
 3f13768:	e1dc30b0 	ldrh	r3, [r12]
 3f1376c:	e3c33002 	bic	r3, r3, #2	; 0x2
 3f13770:	e1a03803 	mov	r3, r3, lsl #16
 3f13774:	e1a03823 	mov	r3, r3, lsr #16
 3f13778:	e1cc30b0 	strh	r3, [r12]
	memctl->MEMCFGW |= 0x02; // 16bit
 3f1377c:	e1dc30b0 	ldrh	r3, [r12]
 3f13780:	e3833002 	orr	r3, r3, #2	; 0x2
 3f13784:	e1cc30b0 	strh	r3, [r12]


	/* set up the I/O ports -> move nand bootstrap*/
	/* arch number of MMSP20-Board */
	gd->bd->bi_arch_number = 395;
 3f13788:	e59f3048 	ldr	r3, [pc, #48]	; 3f137d8 <board_init+0x290>
 3f1378c:	e5982000 	ldr	r2, [r8]
 3f13790:	e5823014 	str	r3, [r2, #20]

	/* adress of boot parameters */
	gd->bd->bi_boot_params = 0x00100100;
 3f13794:	e59f3040 	ldr	r3, [pc, #40]	; 3f137dc <board_init+0x294>
 3f13798:	e5982000 	ldr	r2, [r8]
 3f1379c:	e5823018 	str	r3, [r2, #24]

	icache_enable();
 3f137a0:	eb000b83 	bl	3f165b4 <icache_enable>
	dcache_enable();
 3f137a4:	eb000b9b 	bl	3f16618 <dcache_enable>

	setup_async();
 3f137a8:	ebffb27f 	bl	3f001ac <setup_async>

	return 0;
 3f137ac:	e3a00000 	mov	r0, #0	; 0x0
}
 3f137b0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f137b4:	c0000900 	andgt	r0, r0, r0, lsl #18
 3f137b8:	00004904 	andeq	r4, r0, r4, lsl #18
 3f137bc:	c0000c00 	andgt	r0, r0, r0, lsl #24
 3f137c0:	00006002 	andeq	r6, r0, r2
 3f137c4:	c0003a00 	andgt	r3, r0, r0, lsl #20
 3f137c8:	ffffaaaa 	swinv	0x00ffaaaa
 3f137cc:	ffffaa0a 	swinv	0x00ffaa0a
 3f137d0:	000016aa 	andeq	r1, r0, r10, lsr #13
 3f137d4:	ffffaa50 	swinv	0x00ffaa50
 3f137d8:	0000018b 	andeq	r0, r0, r11, lsl #3
 3f137dc:	00100100 	andeqs	r0, r0, r0, lsl #2

03f137e0 <dram_init>:
 3f137e0:	e1a0c00d 	mov	r12, r13
 3f137e4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f137e8:	e24cb004 	sub	r11, r12, #4	; 0x4

int dram_init (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	gd->bd->bi_dram[0].start = PHYS_SDRAM_1;
 3f137ec:	e5982000 	ldr	r2, [r8]
 3f137f0:	e3a03601 	mov	r3, #1048576	; 0x100000
 3f137f4:	e582301c 	str	r3, [r2, #28]
	gd->bd->bi_dram[0].size = PHYS_SDRAM_1_SIZE;
	
	return 0 ;
 3f137f8:	e3a00000 	mov	r0, #0	; 0x0
 3f137fc:	e5982000 	ldr	r2, [r8]
 3f13800:	e283363e 	add	r3, r3, #65011712	; 0x3e00000
 3f13804:	e5823020 	str	r3, [r2, #32]
}
 3f13808:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1380c <SD_FS>:
 3f1380c:	e1a0c00d 	mov	r12, r13
 3f13810:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f13814:	e24cb004 	sub	r11, r12, #4	; 0x4



unsigned char scratch[4096]; // buffer for SD read/write
unsigned int scratch1[4096]; // buffer for SD read/write
int SD_FS(void)  // Check Partition table
{
	int MBR_exist;
	int i;
	
	MBR_exist = 0;
 3f13818:	e3a05000 	mov	r5, #0	; 0x0
	SD_Read(scratch, 0 , 1);
 3f1381c:	e1a01005 	mov	r1, r5
 3f13820:	e59f40f0 	ldr	r4, [pc, #f0]	; 3f13918 <SD_FS+0x10c>
 3f13824:	e3a02001 	mov	r2, #1	; 0x1
 3f13828:	e1a00004 	mov	r0, r4
 3f1382c:	eb000491 	bl	3f14a78 <SD_Read>
	//printf("SD Read #0 done\n");	
#if 0 /* org */
	if(scratch[511]==0xAA && scratch[510]==0x55)
	{

//	    if((scratch[450] == 0x01) || (scratch[450] == 0x04) || (scratch[450] == 0x06) ||
//	       (scratch[450] == 0x0B) ||   /* FAT32 Partition */
//	       (scratch[450] == 0x0C) ||   /* FAT32 Partition */
//	       (scratch[450] == 0x55) )    /* FAT32 Partition */
//		       	MBR_exist=1;
	    if((scratch[450] == 0x0B) ||   /* FAT32 Partition */
	       (scratch[450] == 0x0C) ||   /* FAT32 Partition */
	       (scratch[450] == 0x55) )    /* FAT32 Partition */
	       {
		       	MBR_exist=1;
		   }
		   else
		   {
		       	MBR_exist=0;
				mmc_init_once = 0;
		   		printf("mmc_init_once %d\n", mmc_init_once);
		   }
	} 

	if(MBR_exist) 	printf("(with MBR)\n\n"); 
	else 			printf("(without MBR)\n\n");
#else /* shkim patch */
	if(scratch[511]==0xAA && scratch[510]==0x55)
 3f13830:	e5d431ff 	ldrb	r3, [r4, #511]
 3f13834:	e35300aa 	cmp	r3, #170	; 0xaa
 3f13838:	1a00002e 	bne	3f138f8 <SD_FS+0xec>
 3f1383c:	e5d431fe 	ldrb	r3, [r4, #510]
 3f13840:	e3530055 	cmp	r3, #85	; 0x55
 3f13844:	1a00002b 	bne	3f138f8 <SD_FS+0xec>
	{

	    if( (scratch[0x36] == 'F') && (scratch[0x37] == 'A') && (scratch[0x38] == 'T'))
 3f13848:	e5d43036 	ldrb	r3, [r4, #54]
 3f1384c:	e3530046 	cmp	r3, #70	; 0x46
 3f13850:	1a000005 	bne	3f1386c <SD_FS+0x60>
 3f13854:	e5d43037 	ldrb	r3, [r4, #55]
 3f13858:	e3530041 	cmp	r3, #65	; 0x41
 3f1385c:	1a000002 	bne	3f1386c <SD_FS+0x60>
 3f13860:	e5d43038 	ldrb	r3, [r4, #56]
 3f13864:	e3530054 	cmp	r3, #84	; 0x54
 3f13868:	0a00001a 	beq	3f138d8 <SD_FS+0xcc>
	    {
			/* PBR only for FAT16 */ 
			mmc_init_once = 1;
			/* Although NO MBR, we asume MBR exist */
		       	MBR_exist=1;
	    }
	    else if( (scratch[0x52] == 'F') && (scratch[0x53] == 'A') && (scratch[0x54] == 'T'))
 3f1386c:	e5d43052 	ldrb	r3, [r4, #82]
 3f13870:	e3530046 	cmp	r3, #70	; 0x46
 3f13874:	1a000005 	bne	3f13890 <SD_FS+0x84>
 3f13878:	e5d43053 	ldrb	r3, [r4, #83]
 3f1387c:	e3530041 	cmp	r3, #65	; 0x41
 3f13880:	1a000002 	bne	3f13890 <SD_FS+0x84>
 3f13884:	e5d43054 	ldrb	r3, [r4, #84]
 3f13888:	e3530054 	cmp	r3, #84	; 0x54
 3f1388c:	0a000011 	beq	3f138d8 <SD_FS+0xcc>
	    {
			/* PBR only for FAT32 */ 
			mmc_init_once = 1;
			/* Although NO MBR, we asume MBR exist */
		       	MBR_exist=1;
	    }
	    else if((scratch[450] == 0x01) || (scratch[450] == 0x04) || (scratch[450] == 0x06) ||
 3f13890:	e5d401c2 	ldrb	r0, [r4, #450]
 3f13894:	e3500004 	cmp	r0, #4	; 0x4
 3f13898:	13a03000 	movne	r3, #0	; 0x0
 3f1389c:	03a03001 	moveq	r3, #1	; 0x1
 3f138a0:	e3500001 	cmp	r0, #1	; 0x1
 3f138a4:	11a02003 	movne	r2, r3
 3f138a8:	03a02001 	moveq	r2, #1	; 0x1
 3f138ac:	e3520000 	cmp	r2, #0	; 0x0
 3f138b0:	1a000008 	bne	3f138d8 <SD_FS+0xcc>
 3f138b4:	e20000ff 	and	r0, r0, #255	; 0xff
 3f138b8:	e3500006 	cmp	r0, #6	; 0x6
 3f138bc:	0a000005 	beq	3f138d8 <SD_FS+0xcc>
 3f138c0:	e350000b 	cmp	r0, #11	; 0xb
 3f138c4:	0a000003 	beq	3f138d8 <SD_FS+0xcc>
 3f138c8:	e350000c 	cmp	r0, #12	; 0xc
 3f138cc:	0a000001 	beq	3f138d8 <SD_FS+0xcc>
 3f138d0:	e3500055 	cmp	r0, #85	; 0x55
 3f138d4:	1a000004 	bne	3f138ec <SD_FS+0xe0>
	       (scratch[450] == 0x0B) ||   /* FAT32 Partition */
	       (scratch[450] == 0x0C) ||   /* FAT32 Partition */
	       (scratch[450] == 0x55) )    /* FAT32 Partition */
	    {
			mmc_init_once = 1;
 3f138d8:	e3a03001 	mov	r3, #1	; 0x1
 3f138dc:	e59f2038 	ldr	r2, [pc, #38]	; 3f1391c <SD_FS+0x110>
		       	MBR_exist=1;
 3f138e0:	e1a05003 	mov	r5, r3
 3f138e4:	e5823000 	str	r3, [r2]
	    }
 3f138e8:	ea000002 	b	3f138f8 <SD_FS+0xec>
	    else
	    {
			mmc_init_once = 0;
 3f138ec:	e59f3028 	ldr	r3, [pc, #28]	; 3f1391c <SD_FS+0x110>
		       	MBR_exist=0;
 3f138f0:	e1a05002 	mov	r5, r2
 3f138f4:	e5832000 	str	r2, [r3]
	    }
	}

	if(MBR_exist) 	printf("(with MBR)\n\n"); 
 3f138f8:	e3550000 	cmp	r5, #0	; 0x0
 3f138fc:	0a000002 	beq	3f1390c <SD_FS+0x100>
 3f13900:	e59f0018 	ldr	r0, [pc, #18]	; 3f13920 <SD_FS+0x114>
 3f13904:	ebffe3ce 	bl	3f0c844 <printf>
 3f13908:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
	else		printf("(without MBR)\n\n");
 3f1390c:	e59f0010 	ldr	r0, [pc, #10]	; 3f13924 <SD_FS+0x118>
 3f13910:	ebffe3cb 	bl	3f0c844 <printf>

#endif

}
 3f13914:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f13918:	03f6df04 	mvneqs	r13, #16	; 0x10
 3f1391c:	03f21184 	mvneqs	r1, #33	; 0x21
 3f13920:	03f1f874 	mvneqs	r15, #7602176	; 0x740000
 3f13924:	03f1f884 	mvneqs	r15, #8650752	; 0x840000

03f13928 <board_late_init>:
 3f13928:	e1a0c00d 	mov	r12, r13
 3f1392c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f13930:	e24cb004 	sub	r11, r12, #4	; 0x4
   
int board_late_init(void)
{	
	if(!SD_card_init()) 
 3f13934:	eb00036b 	bl	3f146e8 <SD_card_init>
 3f13938:	e3500000 	cmp	r0, #0	; 0x0
 3f1393c:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
	{
		return 0; // No SD/MMC found !!
	}
	else
	{
		SD_FS(); // Check Master boot record !!
 3f13940:	ebffffb1 	bl	3f1380c <SD_FS>
	}

	//SD_FS(); // Check Master boot record !!

	return 1;
 3f13944:	e3a00001 	mov	r0, #1	; 0x1
 3f13948:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1394c <nand_init>:
 3f1394c:	e1a0c00d 	mov	r12, r13
 3f13950:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

static inline MMSP20_BANC_MEMCTL * const MMSP20_GetBaseC_MEMCTL(void)
{
	return (MMSP20_BANC_MEMCTL * const)MMSP20_BANC_MEMCTL_BASE;
 3f13954:	e59f203c 	ldr	r2, [pc, #3c]	; 3f13998 <nand_init+0x4c>
}

#if (CONFIG_COMMANDS & CFG_CMD_NAND)
extern ulong nand_probe (ulong physadr);
void nand_init (void)
{
	DECLARE_GLOBAL_DATA_PTR;

	MMSP20_BANC_MEMCTL * const  bankc;
	MMSP20_NAND        * const  nand;
	ulong totlen = 0;
 3f13958:	e3a03000 	mov	r3, #0	; 0x0

	DPRINTF("++[%s:%d]->%s():\n", __FILE__,__LINE__,__FUNCTION__);
	bankc = MMSP20_GetBaseC_MEMCTL();
	nand  = MMSP20_GetBase_NAND();

	//bankc->MEMCFGW = bankc->MEMCFGW & ~(0x80);  /* 8bit bandwidth,  bit 7, 0: 8bit, 1:16bit*/
	bankc->MEMNANDCTRLW = 0;
 3f1395c:	e1c233ba 	strh	r3, [r2, #58]
	bankc->MEMNANDTIMEW = 0x7f8;
 3f13960:	e59f3034 	ldr	r3, [pc, #34]	; 3f1399c <nand_init+0x50>
 3f13964:	e1c233bc 	strh	r3, [r2, #60]
 3f13968:	e24cb004 	sub	r11, r12, #4	; 0x4
	bankc->MEMNANDCTRLW &= (~NAND_INT_DETRnB);
 3f1396c:	e1d233ba 	ldrh	r3, [r2, #58]

	printf("Probing at 0x%.8x\n", NAND_MEM_BASE_ADDR);
 3f13970:	e3a01327 	mov	r1, #-1677721600	; 0x9c000000
 3f13974:	e59f0024 	ldr	r0, [pc, #24]	; 3f139a0 <nand_init+0x54>
 3f13978:	e3c33080 	bic	r3, r3, #128	; 0x80
 3f1397c:	e1a03803 	mov	r3, r3, lsl #16
 3f13980:	e1a03823 	mov	r3, r3, lsr #16
 3f13984:	e1c233ba 	strh	r3, [r2, #58]
 3f13988:	ebffe3ad 	bl	3f0c844 <printf>
	totlen= nand_probe(NAND_MEM_BASE_ADDR);
 3f1398c:	e3a00327 	mov	r0, #-1677721600	; 0x9c000000
 3f13990:	ebffdc86 	bl	3f0abb0 <nand_probe>
}
 3f13994:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f13998:	c0003a00 	andgt	r3, r0, r0, lsl #20
 3f1399c:	000007f8 	streqd	r0, [r0], -r8
 3f139a0:	03f1f894 	mvneqs	r15, #9699328	; 0x940000

03f139a4 <ChangeUPllValue>:
 3f139a4:	e1a0c00d 	mov	r12, r13
 3f139a8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f139ac:	e59f203c 	ldr	r2, [pc, #3c]	; 3f139f0 <ChangeUPllValue+0x4c>
#endif

// shkim add
#if (CONFIG_COMMANDS & CFG_CMD_LOADUB)

void ChangeUPllValue(int mdiv,int pdiv,int sdiv)
{
	MMSP20_CLOCK_POWER * const clk_power = MMSP20_GetBase_CLOCK_POWER();

	DPRINTF("++[%s:%d]->%s():\n", __FILE__,__LINE__,__FUNCTION__);
	/* configure UPLL */
	/*
		UPLL(MHz)= ((U_MDIV+8)*Fin) / ((U_PDIV+2) * 2^U_SDIV)
		Fin = 7.3728 MHz
	*/

	/* UCLK = 95.xxxMHz. It's default value. */
	/* U_MDIV=0x60 U_PDIV=0x0 U_SDIV=0x2 */
	//clk_power->UPLLSETVREG  = ((U_MDIV << 8) + (U_PDIV << 2) + U_SDIV);

	/* UCLK = 48 MHz */
	/* U_MDIV=0x60 U_PDIV=0x0 U_SDIV=0x3 */
	clk_power->UPLLSETVREG  = ((0x60 << 8) + (0 << 0x2) + 0x2);
 3f139b0:	e59f303c 	ldr	r3, [pc, #3c]	; 3f139f4 <ChangeUPllValue+0x50>
 3f139b4:	e1c231b4 	strh	r3, [r2, #20]
	clk_power->UIRMCSETREG=((clk_power->UIRMCSETREG)&~(0x3<<6)) | (0x2<<6); // UPLL_CLK
 3f139b8:	e1d232b0 	ldrh	r3, [r2, #32]
 3f139bc:	e3c330c0 	bic	r3, r3, #192	; 0xc0
 3f139c0:	e1a03803 	mov	r3, r3, lsl #16
 3f139c4:	e1a03823 	mov	r3, r3, lsr #16
 3f139c8:	e3833080 	orr	r3, r3, #128	; 0x80
 3f139cc:	e1c232b0 	strh	r3, [r2, #32]
	clk_power->UIRMCSETREG=((clk_power->UIRMCSETREG)&~(0x3f<<0)) | (0x1<<0); // devide set value
 3f139d0:	e1d232b0 	ldrh	r3, [r2, #32]
 3f139d4:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f139d8:	e3c3303f 	bic	r3, r3, #63	; 0x3f
 3f139dc:	e1a03803 	mov	r3, r3, lsl #16
 3f139e0:	e1a03823 	mov	r3, r3, lsr #16
 3f139e4:	e3833001 	orr	r3, r3, #1	; 0x1
 3f139e8:	e1c232b0 	strh	r3, [r2, #32]

	DPRINTF("++[%s:%d]->%s(): clk_power->PWMODEREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->PWMODEREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->CLKCHGSTREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->CLKCHGSTREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->SYSCLKENREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->SYSCLKENREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->COMCLKENREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->COMCLKENREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->VGCLKENREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->VGCLKENREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->ASCLKENREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->ASCLKENREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->FPLLSETVREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->FPLLSETVREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->FPLLVSETREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->FPLLVSETREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->UPLLSETVREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->UPLLSETVREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->UPLLVSETREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->UPLLVSETREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->APLLSETVREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->APLLSETVREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->APLLVSETREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->APLLVSETREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->SYSCSETREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->SYSCSETREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->ESYSCSETREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->ESYSCSETREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->UIRMCSETREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->UIRMCSETREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->AUDICSETREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->AUDICSETREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->DISPCSETREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->DISPCSETREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->IMAGCSETREG=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->IMAGCSETREG);
	DPRINTF("++[%s:%d]->%s(): clk_power->URTCSETREG[0]=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->URTCSETREG[0]);
	DPRINTF("++[%s:%d]->%s(): clk_power->URTCSETREG[1]=0x%x\n",__FILE__,__LINE__,__FUNCTION__,clk_power->URTCSETREG[1]);
}
 3f139ec:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f139f0:	c0000900 	andgt	r0, r0, r0, lsl #18
 3f139f4:	00006002 	andeq	r6, r0, r2

03f139f8 <pullup_en>:
 3f139f8:	e1a0c00d 	mov	r12, r13
 3f139fc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_TIMER_WATCHDOG * const)MMSP20_TIMER_WATCHDOG_BASE;
}
static inline MMSP20_GPIO * const MMSP20_GetBase_GPIO(void)
{
	return (MMSP20_GPIO * const)MMSP20_GPIO_BASE;
 3f13a00:	e59f3024 	ldr	r3, [pc, #24]	; 3f13a2c <pullup_en+0x34>

void pullup_en(void)
{
	MMSP20_GPIO * const gpio = MMSP20_GetBase_GPIO();

	DPRINTF("++[%s:%d]->%s():\n", __FILE__,__LINE__,__FUNCTION__);

	/* GPIOK7 output high */
	gpio->GPIOALTFNLOW['K'-'A'] = (gpio->GPIOALTFNLOW['K'-'A'] & ~(0x3<<14)) | (0x1<<14); 
 3f13a04:	e1d321b4 	ldrh	r2, [r3, #20]
 3f13a08:	e1a02902 	mov	r2, r2, lsl #18
 3f13a0c:	e1a02922 	mov	r2, r2, lsr #18
 3f13a10:	e3822901 	orr	r2, r2, #16384	; 0x4000
 3f13a14:	e1c321b4 	strh	r2, [r3, #20]
	gpio->GPIOOUT['K'-'A'] = gpio->GPIOOUT['K'-'A'] | (0x1<<7); 
 3f13a18:	e1d325b4 	ldrh	r2, [r3, #84]
 3f13a1c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f13a20:	e3822080 	orr	r2, r2, #128	; 0x80
 3f13a24:	e1c325b4 	strh	r2, [r3, #84]
}
 3f13a28:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f13a2c:	c0001020 	andgt	r1, r0, r0, lsr #32

03f13a30 <pullup_dis>:
 3f13a30:	e1a0c00d 	mov	r12, r13
 3f13a34:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_TIMER_WATCHDOG * const)MMSP20_TIMER_WATCHDOG_BASE;
}
static inline MMSP20_GPIO * const MMSP20_GetBase_GPIO(void)
{
	return (MMSP20_GPIO * const)MMSP20_GPIO_BASE;
 3f13a38:	e59f302c 	ldr	r3, [pc, #2c]	; 3f13a6c <pullup_dis+0x3c>

void pullup_dis(void)
{
	MMSP20_GPIO * const gpio = MMSP20_GetBase_GPIO();

	DPRINTF("++[%s:%d]->%s():\n", __FILE__,__LINE__,__FUNCTION__);

	/* GPIOK7 output low */
	gpio->GPIOALTFNLOW['K'-'A'] = (gpio->GPIOALTFNLOW['K'-'A'] & ~(0x3<<14)) | (0x1<<14); 
 3f13a3c:	e1d321b4 	ldrh	r2, [r3, #20]
 3f13a40:	e1a02902 	mov	r2, r2, lsl #18
 3f13a44:	e1a02922 	mov	r2, r2, lsr #18
 3f13a48:	e3822901 	orr	r2, r2, #16384	; 0x4000
 3f13a4c:	e1c321b4 	strh	r2, [r3, #20]
	gpio->GPIOOUT['K'-'A'] = gpio->GPIOOUT['K'-'A'] & ~(0x1<<7); 
 3f13a50:	e1d325b4 	ldrh	r2, [r3, #84]
 3f13a54:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f13a58:	e3c22080 	bic	r2, r2, #128	; 0x80
 3f13a5c:	e1a02802 	mov	r2, r2, lsl #16
 3f13a60:	e1a02822 	mov	r2, r2, lsr #16
 3f13a64:	e1c325b4 	strh	r2, [r3, #84]
}
 3f13a68:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f13a6c:	c0001020 	andgt	r1, r0, r0, lsr #32

03f13a70 <usbd_en>:
 3f13a70:	e1a0c00d 	mov	r12, r13
 3f13a74:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f13a78:	e59f2024 	ldr	r2, [pc, #24]	; 3f13aa4 <usbd_en+0x34>

void usbd_en(void)
{
	MMSP20_GPIO * const gpio = MMSP20_GetBase_GPIO();
	MMSP20_CLOCK_POWER * const clk_power = MMSP20_GetBase_CLOCK_POWER();

	DPRINTF("++[%s:%d]->%s():\n", __FILE__,__LINE__,__FUNCTION__);

	clk_power->COMCLKENREG=((clk_power->COMCLKENREG)&~(0x1<<1)) | (0x1<<1); // USB device clock enable
 3f13a7c:	e1d230b8 	ldrh	r3, [r2, #8]
	return (MMSP20_TIMER_WATCHDOG * const)MMSP20_TIMER_WATCHDOG_BASE;
}
static inline MMSP20_GPIO * const MMSP20_GetBase_GPIO(void)
{
	return (MMSP20_GPIO * const)MMSP20_GPIO_BASE;
 3f13a80:	e59f1020 	ldr	r1, [pc, #20]	; 3f13aa8 <usbd_en+0x38>
 3f13a84:	e3833002 	orr	r3, r3, #2	; 0x2
 3f13a88:	e1c230b8 	strh	r3, [r2, #8]
	gpio->GPIOPADSEL=((gpio->GPIOPADSEL)&~(1<<1)) | (1<<1); // USB PAD3 Type = USB Device
 3f13a8c:	e3a02c01 	mov	r2, #256	; 0x100
 3f13a90:	e19130b2 	ldrh	r3, [r1, r2]
 3f13a94:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f13a98:	e3833002 	orr	r3, r3, #2	; 0x2
 3f13a9c:	e18130b2 	strh	r3, [r1, r2]
}
 3f13aa0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f13aa4:	c0000900 	andgt	r0, r0, r0, lsl #18
 3f13aa8:	c0001020 	andgt	r1, r0, r0, lsr #32

03f13aac <usbd_dis>:
 3f13aac:	e1a0c00d 	mov	r12, r13
 3f13ab0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f13ab4:	e59f2018 	ldr	r2, [pc, #18]	; 3f13ad4 <usbd_dis+0x28>

void usbd_dis(void)
{
	MMSP20_CLOCK_POWER * const clk_power = MMSP20_GetBase_CLOCK_POWER();

	DPRINTF("++[%s:%d]->%s():\n", __FILE__,__LINE__,__FUNCTION__);

	clk_power->COMCLKENREG=((clk_power->COMCLKENREG)&~(0x1<<1)) | (0x0<<1); // USB device clock disable
 3f13ab8:	e1d230b8 	ldrh	r3, [r2, #8]
 3f13abc:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f13ac0:	e3c33002 	bic	r3, r3, #2	; 0x2
 3f13ac4:	e1a03803 	mov	r3, r3, lsl #16
 3f13ac8:	e1a03823 	mov	r3, r3, lsr #16
 3f13acc:	e1c230b8 	strh	r3, [r2, #8]
}
 3f13ad0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f13ad4:	c0000900 	andgt	r0, r0, r0, lsl #18

03f13ad8 <display_logo>:
 3f13ad8:	e1a0c00d 	mov	r12, r13
 3f13adc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f13ae0:	e24cb004 	sub	r11, r12, #4	; 0x4



void display_logo(void)
{
	show_logo();
 3f13ae4:	eb0009d5 	bl	3f16240 <show_logo>
 3f13ae8:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f13aec <display_Firmware>:
 3f13aec:	e1a0c00d 	mov	r12, r13
 3f13af0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f13af4:	e24cb004 	sub	r11, r12, #4	; 0x4
}


//  : ̽̾.
void display_Firmware(void)
{
	show_Firmware();
 3f13af8:	eb0009ee 	bl	3f162b8 <show_Firmware>
}
 3f13afc:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f13b00 <flash_init>:
 3f13b00:	e1a0c00d 	mov	r12, r13
 3f13b04:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f13b08:	e24cb004 	sub	r11, r12, #4	; 0x4
		  CFG_ENV_ADDR,
		  CFG_ENV_ADDR + CFG_ENV_SIZE - 1,
		  &flash_info[0]);
*/
    return size;
 3f13b0c:	e3a00000 	mov	r0, #0	; 0x0
}
 3f13b10:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f13b14 <flash_print_info>:
 3f13b14:	e1a0c00d 	mov	r12, r13
 3f13b18:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}

/*-----------------------------------------------------------------------
 */
void flash_print_info  (flash_info_t *info)
{
 3f13b1c:	e1a05000 	mov	r5, r0
    int i;

    switch (info->flash_id & FLASH_VENDMASK)
 3f13b20:	e5953008 	ldr	r3, [r5, #8]
 3f13b24:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f13b28:	e1a03823 	mov	r3, r3, lsr #16
 3f13b2c:	e1a03803 	mov	r3, r3, lsl #16
 3f13b30:	e3530801 	cmp	r3, #65536	; 0x10000
 3f13b34:	1a000002 	bne	3f13b44 <flash_print_info+0x30>
    {
    case (AMD_MANUFACT & FLASH_VENDMASK):
	printf("AMD: ");
 3f13b38:	e59f00e0 	ldr	r0, [pc, #e0]	; 3f13c20 <flash_print_info+0x10c>
 3f13b3c:	ebffe340 	bl	3f0c844 <printf>
	break;
 3f13b40:	ea000001 	b	3f13b4c <flash_print_info+0x38>
    default:
	printf("Unknown Vendor ");
 3f13b44:	e59f00d8 	ldr	r0, [pc, #d8]	; 3f13c24 <flash_print_info+0x110>
 3f13b48:	ebffe33d 	bl	3f0c844 <printf>
	break;
    }

    switch (info->flash_id & FLASH_TYPEMASK)
 3f13b4c:	e1d520b8 	ldrh	r2, [r5, #8]
 3f13b50:	e59f30d0 	ldr	r3, [pc, #d0]	; 3f13c28 <flash_print_info+0x114>
 3f13b54:	e1520003 	cmp	r2, r3
 3f13b58:	0a000005 	beq	3f13b74 <flash_print_info+0x60>
 3f13b5c:	e283305f 	add	r3, r3, #95	; 0x5f
 3f13b60:	e1520003 	cmp	r2, r3
 3f13b64:	1a000005 	bne	3f13b80 <flash_print_info+0x6c>
    {
    case (AMD_ID_LV400B & FLASH_TYPEMASK):
	printf("1x Amd29LV400BB (4Mbit)\n");
 3f13b68:	e59f00bc 	ldr	r0, [pc, #bc]	; 3f13c2c <flash_print_info+0x118>
 3f13b6c:	ebffe334 	bl	3f0c844 <printf>
	break;
 3f13b70:	ea000005 	b	3f13b8c <flash_print_info+0x78>
    case (AMD_ID_LV800B & FLASH_TYPEMASK):
	printf("1x Amd29LV800BB (8Mbit)\n");
 3f13b74:	e59f00b4 	ldr	r0, [pc, #b4]	; 3f13c30 <flash_print_info+0x11c>
 3f13b78:	ebffe331 	bl	3f0c844 <printf>
	break;
 3f13b7c:	ea000002 	b	3f13b8c <flash_print_info+0x78>
    default:
	printf("Unknown Chip Type\n");
 3f13b80:	e59f00ac 	ldr	r0, [pc, #ac]	; 3f13c34 <flash_print_info+0x120>
 3f13b84:	ebffe32e 	bl	3f0c844 <printf>
	goto Done;
 3f13b88:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
	break;
    }

    printf("  Size: %ld MB in %d Sectors\n",
 3f13b8c:	e59f00a4 	ldr	r0, [pc, #a4]	; 3f13c38 <flash_print_info+0x124>
 3f13b90:	e5951000 	ldr	r1, [r5]
 3f13b94:	e1d520b4 	ldrh	r2, [r5, #4]
 3f13b98:	e1a01a21 	mov	r1, r1, lsr #20
 3f13b9c:	ebffe328 	bl	3f0c844 <printf>
	   info->size >> 20, info->sector_count);

    printf("  Sector Start Addresses:");
 3f13ba0:	e59f0094 	ldr	r0, [pc, #94]	; 3f13c3c <flash_print_info+0x128>
 3f13ba4:	ebffe326 	bl	3f0c844 <printf>
    for (i = 0; i < info->sector_count; i++)
 3f13ba8:	e1d530b4 	ldrh	r3, [r5, #4]
 3f13bac:	e3a04000 	mov	r4, #0	; 0x0
 3f13bb0:	e1540003 	cmp	r4, r3
 3f13bb4:	aa000016 	bge	3f13c14 <flash_print_info+0x100>
    {
	if ((i % 5) == 0)
 3f13bb8:	e59f3080 	ldr	r3, [pc, #80]	; 3f13c40 <flash_print_info+0x12c>
 3f13bbc:	e0c21493 	smull	r1, r2, r3, r4
 3f13bc0:	e1a03fc4 	mov	r3, r4, asr #31
 3f13bc4:	e06330c2 	rsb	r3, r3, r2, asr #1
 3f13bc8:	e0833103 	add	r3, r3, r3, lsl #2
 3f13bcc:	e1540003 	cmp	r4, r3
 3f13bd0:	1a000001 	bne	3f13bdc <flash_print_info+0xc8>
	{
	    printf ("\n   ");
 3f13bd4:	e59f0068 	ldr	r0, [pc, #68]	; 3f13c44 <flash_print_info+0x130>
 3f13bd8:	ebffe319 	bl	3f0c844 <printf>
	}
	printf (" %08lX%s", info->start[i],
 3f13bdc:	e59fe064 	ldr	r14, [pc, #64]	; 3f13c48 <flash_print_info+0x134>
 3f13be0:	e59f0064 	ldr	r0, [pc, #64]	; 3f13c4c <flash_print_info+0x138>
 3f13be4:	e2853010 	add	r3, r5, #16	; 0x10
 3f13be8:	e7d3c004 	ldrb	r12, [r3, r4]
 3f13bec:	e59f205c 	ldr	r2, [pc, #5c]	; 3f13c50 <flash_print_info+0x13c>
 3f13bf0:	e285300c 	add	r3, r5, #12	; 0xc
 3f13bf4:	e7931104 	ldr	r1, [r3, r4, lsl #2]
 3f13bf8:	e35c0000 	cmp	r12, #0	; 0x0
 3f13bfc:	01a0200e 	moveq	r2, r14
 3f13c00:	ebffe30f 	bl	3f0c844 <printf>
 3f13c04:	e1d530b4 	ldrh	r3, [r5, #4]
 3f13c08:	e2844001 	add	r4, r4, #1	; 0x1
 3f13c0c:	e1540003 	cmp	r4, r3
 3f13c10:	baffffe8 	blt	3f13bb8 <flash_print_info+0xa4>
		info->protect[i] ? " (RO)" : "     ");
    }
    printf ("\n");
 3f13c14:	e59f0038 	ldr	r0, [pc, #38]	; 3f13c54 <flash_print_info+0x140>
 3f13c18:	ebffe309 	bl	3f0c844 <printf>

Done:
}

/*-----------------------------------------------------------------------
 */

int	flash_erase (flash_info_t *info, int s_first, int s_last)
 3f13c1c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f13c20:	03f1f8cc 	mvneqs	r15, #13369344	; 0xcc0000
 3f13c24:	03f1f8d4 	mvneqs	r15, #13893632	; 0xd40000
 3f13c28:	0000225b 	andeq	r2, r0, r11, asr r2
 3f13c2c:	03f1f8e4 	mvneqs	r15, #14942208	; 0xe40000
 3f13c30:	03f1f900 	mvneqs	r15, #0	; 0x0
 3f13c34:	03f1f91c 	mvneqs	r15, #458752	; 0x70000
 3f13c38:	03f1f930 	mvneqs	r15, #786432	; 0xc0000
 3f13c3c:	03f1f950 	mvneqs	r15, #1310720	; 0x140000
 3f13c40:	66666667 	strvsbt	r6, [r6], -r7, ror #12
 3f13c44:	03f1f96c 	mvneqs	r15, #1769472	; 0x1b0000
 3f13c48:	03f1f988 	mvneqs	r15, #2228224	; 0x220000
 3f13c4c:	03f1f974 	mvneqs	r15, #1900544	; 0x1d0000
 3f13c50:	03f1f980 	mvneqs	r15, #2097152	; 0x200000
 3f13c54:	03f1f990 	mvneqs	r15, #2359296	; 0x240000

03f13c58 <flash_erase>:
 3f13c58:	e1a0c00d 	mov	r12, r13
 3f13c5c:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f13c60:	e24cb004 	sub	r11, r12, #4	; 0x4
{
 3f13c64:	e1a0a000 	mov	r10, r0
    ushort result;
    int iflag, cflag, prot, sect;
    int rc = ERR_OK;
 3f13c68:	e3a0c000 	mov	r12, #0	; 0x0
 3f13c6c:	e1a04001 	mov	r4, r1
    int chip;

    /* first look for protection bits */

    if (info->flash_id == FLASH_UNKNOWN)
 3f13c70:	e59f318c 	ldr	r3, [pc, #18c]	; 3f13e04 <flash_erase+0x1ac>
 3f13c74:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f13c78:	e59a0008 	ldr	r0, [r10, #8]
 3f13c7c:	e1a07002 	mov	r7, r2
 3f13c80:	e50bc030 	str	r12, [r11, -#48]
 3f13c84:	e1500003 	cmp	r0, r3
	return ERR_UNKNOWN_FLASH_TYPE;
 3f13c88:	03a00040 	moveq	r0, #64	; 0x40
 3f13c8c:	0a00007a 	beq	3f13e7c <flash_erase+0x224>

    if ((s_first < 0) || (s_first > s_last)) {
 3f13c90:	e1540007 	cmp	r4, r7
 3f13c94:	c3a03001 	movgt	r3, #1	; 0x1
 3f13c98:	d1a03fa4 	movle	r3, r4, lsr #31
 3f13c9c:	e3530000 	cmp	r3, #0	; 0x0
	return ERR_INVAL;
 3f13ca0:	13a00008 	movne	r0, #8	; 0x8
 3f13ca4:	1a000074 	bne	3f13e7c <flash_erase+0x224>
    }

    if ((info->flash_id & FLASH_VENDMASK) !=
 3f13ca8:	e1a03820 	mov	r3, r0, lsr #16
 3f13cac:	e1a03803 	mov	r3, r3, lsl #16
 3f13cb0:	e3530801 	cmp	r3, #65536	; 0x10000
	(AMD_MANUFACT & FLASH_VENDMASK)) {
	return ERR_UNKNOWN_FLASH_VENDOR;
 3f13cb4:	13a00020 	movne	r0, #32	; 0x20
 3f13cb8:	1a00006f 	bne	3f13e7c <flash_erase+0x224>
    }

    prot = 0;
    for (sect=s_first; sect<=s_last; ++sect) {
 3f13cbc:	e1a05004 	mov	r5, r4
 3f13cc0:	e1550007 	cmp	r5, r7
 3f13cc4:	e51b2030 	ldr	r2, [r11, -#48]
 3f13cc8:	ca000006 	bgt	3f13ce8 <flash_erase+0x90>
	if (info->protect[sect]) {
 3f13ccc:	e28a3010 	add	r3, r10, #16	; 0x10
 3f13cd0:	e7d33005 	ldrb	r3, [r3, r5]
 3f13cd4:	e2855001 	add	r5, r5, #1	; 0x1
 3f13cd8:	e3530000 	cmp	r3, #0	; 0x0
 3f13cdc:	12822001 	addne	r2, r2, #1	; 0x1
 3f13ce0:	e1550007 	cmp	r5, r7
 3f13ce4:	dafffff8 	ble	3f13ccc <flash_erase+0x74>
	    prot++;
	}
    }
    if (prot)
 3f13ce8:	e3520000 	cmp	r2, #0	; 0x0
 3f13cec:	0a000007 	beq	3f13d10 <flash_erase+0xb8>
	return ERR_PROTECTED;
 3f13cf0:	e3a00004 	mov	r0, #4	; 0x4
 3f13cf4:	ea000060 	b	3f13e7c <flash_erase+0x224>

    /*
     * Disable interrupts which might cause a timeout
     * here. Remember that our exception vectors are
     * at address 0 in the flash, and we don't want a
     * (ticker) exception to happen while the flash
     * chip is in programming mode.
     */
    cflag = icache_status();
    icache_disable();
    iflag = disable_interrupts();

    /* Start erase on unprotected sectors */
    for (sect = s_first; sect<=s_last && !ctrlc(); sect++)
    {
	printf("Erasing sector %2d ... ", sect);

	/* arm simple, non interrupt dependent timer */
	reset_timer_masked();

	if (info->protect[sect] == 0)
	{	/* not protected */
	    vu_short *addr = (vu_short *)(info->start[sect]);

	    MEM_FLASH_ADDR1 = CMD_UNLOCK1;
	    MEM_FLASH_ADDR2 = CMD_UNLOCK2;
	    MEM_FLASH_ADDR1 = CMD_ERASE_SETUP;

	    MEM_FLASH_ADDR1 = CMD_UNLOCK1;
	    MEM_FLASH_ADDR2 = CMD_UNLOCK2;
	    *addr = CMD_ERASE_CONFIRM;

	    /* wait until flash is ready */
	    chip = 0;

	    do
	    {
		result = *addr;

		/* check timeout */
		if (get_timer_masked() > CFG_FLASH_ERASE_TOUT)
		{
		    MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
		    chip = TMO;
		    break;
		}

		if (!chip && (result & 0xFFFF) & BIT_ERASE_DONE)
			chip = READY;

		if (!chip && (result & 0xFFFF) & BIT_PROGRAM_ERROR)
			chip = ERR;

	    }  while (!chip);

	    MEM_FLASH_ADDR1 = CMD_READ_ARRAY;

	    if (chip == ERR)
	    {
		rc = ERR_PROG_ERROR;
 3f13cf8:	e3a03080 	mov	r3, #128	; 0x80
 3f13cfc:	e50b3030 	str	r3, [r11, -#48]
		goto outahere;
 3f13d00:	ea000052 	b	3f13e50 <flash_erase+0x1f8>
	    }
	    if (chip == TMO)
	    {
		rc = ERR_TIMOUT;
 3f13d04:	e3a0c001 	mov	r12, #1	; 0x1
 3f13d08:	e50bc030 	str	r12, [r11, -#48]
		goto outahere;
 3f13d0c:	ea00004f 	b	3f13e50 <flash_erase+0x1f8>
 3f13d10:	eb000a39 	bl	3f165fc <icache_status>
 3f13d14:	e50b002c 	str	r0, [r11, -#44]
 3f13d18:	eb000a2e 	bl	3f165d8 <icache_disable>
 3f13d1c:	ebffb1e3 	bl	3f004b0 <disable_interrupts>
 3f13d20:	e50b0028 	str	r0, [r11, -#40]
 3f13d24:	e1a05004 	mov	r5, r4
 3f13d28:	ea00003e 	b	3f13e28 <flash_erase+0x1d0>
 3f13d2c:	e3a04004 	mov	r4, #4	; 0x4
 3f13d30:	e59f20d0 	ldr	r2, [pc, #d0]	; 3f13e08 <flash_erase+0x1b0>
 3f13d34:	e3a030f0 	mov	r3, #240	; 0xf0
 3f13d38:	e1c230b0 	strh	r3, [r2]
 3f13d3c:	ea000026 	b	3f13ddc <flash_erase+0x184>
 3f13d40:	e59f00c4 	ldr	r0, [pc, #c4]	; 3f13e0c <flash_erase+0x1b4>
 3f13d44:	e1a01005 	mov	r1, r5
 3f13d48:	ebffe2bd 	bl	3f0c844 <printf>
 3f13d4c:	ebffb2d5 	bl	3f008a8 <reset_timer_masked>
 3f13d50:	e28a3010 	add	r3, r10, #16	; 0x10
 3f13d54:	e7d3e005 	ldrb	r14, [r3, r5]
 3f13d58:	e35e0000 	cmp	r14, #0	; 0x0
 3f13d5c:	1a00002e 	bne	3f13e1c <flash_erase+0x1c4>
 3f13d60:	e28a300c 	add	r3, r10, #12	; 0xc
 3f13d64:	e7939105 	ldr	r9, [r3, r5, lsl #2]
 3f13d68:	e59f2098 	ldr	r2, [pc, #98]	; 3f13e08 <flash_erase+0x1b0>
 3f13d6c:	e59fc09c 	ldr	r12, [pc, #9c]	; 3f13e10 <flash_erase+0x1b8>
 3f13d70:	e3a000aa 	mov	r0, #170	; 0xaa
 3f13d74:	e1c200b0 	strh	r0, [r2]
 3f13d78:	e3a01055 	mov	r1, #85	; 0x55
 3f13d7c:	e1cc10b0 	strh	r1, [r12]
 3f13d80:	e3a03080 	mov	r3, #128	; 0x80
 3f13d84:	e1c230b0 	strh	r3, [r2]
 3f13d88:	e1c200b0 	strh	r0, [r2]
 3f13d8c:	e1a0400e 	mov	r4, r14
 3f13d90:	e1cc10b0 	strh	r1, [r12]
 3f13d94:	e2433050 	sub	r3, r3, #80	; 0x50
 3f13d98:	e1c930b0 	strh	r3, [r9]
 3f13d9c:	e1d930b0 	ldrh	r3, [r9]
 3f13da0:	e1a06003 	mov	r6, r3
 3f13da4:	ebffb2cd 	bl	3f008e0 <get_timer_masked>
 3f13da8:	e59f3064 	ldr	r3, [pc, #64]	; 3f13e14 <flash_erase+0x1bc>
 3f13dac:	e1500003 	cmp	r0, r3
 3f13db0:	8affffdd 	bhi	3f13d2c <flash_erase+0xd4>
 3f13db4:	e3540000 	cmp	r4, #0	; 0x0
 3f13db8:	1a000001 	bne	3f13dc4 <flash_erase+0x16c>
 3f13dbc:	e3160080 	tst	r6, #128	; 0x80
 3f13dc0:	13a04001 	movne	r4, #1	; 0x1
 3f13dc4:	e3540000 	cmp	r4, #0	; 0x0
 3f13dc8:	1a000001 	bne	3f13dd4 <flash_erase+0x17c>
 3f13dcc:	e3160020 	tst	r6, #32	; 0x20
 3f13dd0:	13a04002 	movne	r4, #2	; 0x2
 3f13dd4:	e3540000 	cmp	r4, #0	; 0x0
 3f13dd8:	0affffef 	beq	3f13d9c <flash_erase+0x144>
 3f13ddc:	e3540002 	cmp	r4, #2	; 0x2
 3f13de0:	e59f2020 	ldr	r2, [pc, #20]	; 3f13e08 <flash_erase+0x1b0>
 3f13de4:	e3a030f0 	mov	r3, #240	; 0xf0
 3f13de8:	e1c230b0 	strh	r3, [r2]
 3f13dec:	0affffc1 	beq	3f13cf8 <flash_erase+0xa0>
 3f13df0:	e3540004 	cmp	r4, #4	; 0x4
 3f13df4:	0affffc2 	beq	3f13d04 <flash_erase+0xac>
	    }

	    printf("ok.\n");
 3f13df8:	e59f0018 	ldr	r0, [pc, #18]	; 3f13e18 <flash_erase+0x1c0>
 3f13dfc:	ebffe290 	bl	3f0c844 <printf>
	}
 3f13e00:	ea000007 	b	3f13e24 <flash_erase+0x1cc>
 3f13e04:	0000ffff 	streqd	r15, [r0], -r15
 3f13e08:	00000aaa 	andeq	r0, r0, r10, lsr #21
 3f13e0c:	03f1f994 	mvneqs	r15, #2424832	; 0x250000
 3f13e10:	00000554 	andeq	r0, r0, r4, asr r5
 3f13e14:	00708000 	rsbeqs	r8, r0, r0
 3f13e18:	03f1f9ac 	mvneqs	r15, #2818048	; 0x2b0000
	else /* it was protected */
	{
	    printf("protected!\n");
 3f13e1c:	e59f005c 	ldr	r0, [pc, #5c]	; 3f13e80 <flash_erase+0x228>
 3f13e20:	ebffe287 	bl	3f0c844 <printf>
 3f13e24:	e2855001 	add	r5, r5, #1	; 0x1
 3f13e28:	e1550007 	cmp	r5, r7
 3f13e2c:	ca000002 	bgt	3f13e3c <flash_erase+0x1e4>
 3f13e30:	ebffe29d 	bl	3f0c8ac <ctrlc>
 3f13e34:	e3500000 	cmp	r0, #0	; 0x0
 3f13e38:	0affffc0 	beq	3f13d40 <flash_erase+0xe8>
	}
    }

    if (ctrlc())
 3f13e3c:	ebffe29a 	bl	3f0c8ac <ctrlc>
 3f13e40:	e3500000 	cmp	r0, #0	; 0x0
 3f13e44:	0a000001 	beq	3f13e50 <flash_erase+0x1f8>
      printf("User Interrupt!\n");
 3f13e48:	e59f0034 	ldr	r0, [pc, #34]	; 3f13e84 <flash_erase+0x22c>
 3f13e4c:	ebffe27c 	bl	3f0c844 <printf>

outahere:
    /* allow flash to settle - wait 10 ms */
    udelay_masked(10000);
 3f13e50:	e59f0030 	ldr	r0, [pc, #30]	; 3f13e88 <flash_erase+0x230>
 3f13e54:	ebffb2c0 	bl	3f0095c <udelay_masked>

    if (iflag)
 3f13e58:	e51b3028 	ldr	r3, [r11, -#40]
 3f13e5c:	e3530000 	cmp	r3, #0	; 0x0
 3f13e60:	0a000000 	beq	3f13e68 <flash_erase+0x210>
      enable_interrupts();
 3f13e64:	ebffb18d 	bl	3f004a0 <enable_interrupts>

    if (cflag)
 3f13e68:	e51bc02c 	ldr	r12, [r11, -#44]
 3f13e6c:	e35c0000 	cmp	r12, #0	; 0x0
 3f13e70:	0a000000 	beq	3f13e78 <flash_erase+0x220>
      icache_enable();
 3f13e74:	eb0009ce 	bl	3f165b4 <icache_enable>

    return rc;
 3f13e78:	e51b0030 	ldr	r0, [r11, -#48]
 3f13e7c:	ea000002 	b	3f13e8c <flash_erase+0x234>
 3f13e80:	03f1f9b4 	mvneqs	r15, #2949120	; 0x2d0000
 3f13e84:	03f1f9c0 	mvneqs	r15, #3145728	; 0x300000
 3f13e88:	00002710 	andeq	r2, r0, r0, lsl r7
}
 3f13e8c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f13e90 <write_hword>:
 3f13e90:	e1a0c00d 	mov	r12, r13
 3f13e94:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f13e98:	e24cb004 	sub	r11, r12, #4	; 0x4

/*-----------------------------------------------------------------------
 * Copy memory to flash
 */

volatile static int write_hword (flash_info_t *info, ulong dest, ushort data)
{
    vu_short *addr = (vu_short *)dest;
    ushort result;
    int rc = ERR_OK;
 3f13e9c:	e3a0a000 	mov	r10, #0	; 0x0
 3f13ea0:	e1a05001 	mov	r5, r1
 3f13ea4:	e1a02802 	mov	r2, r2, lsl #16
 3f13ea8:	e24dd004 	sub	r13, r13, #4	; 0x4
    int cflag, iflag;
    int chip;

    /*
     * Check if Flash is (sufficiently) erased
     */
    result = *addr;
 3f13eac:	e1d530b0 	ldrh	r3, [r5]
    if ((result & data) != data)
 3f13eb0:	e1a06822 	mov	r6, r2, lsr #16
 3f13eb4:	e0033822 	and	r3, r3, r2, lsr #16
 3f13eb8:	e1530006 	cmp	r3, r6
 3f13ebc:	0a000003 	beq	3f13ed0 <write_hword+0x40>
	return ERR_NOT_ERASED;
 3f13ec0:	e3a00002 	mov	r0, #2	; 0x2
 3f13ec4:	ea00003b 	b	3f13fb8 <write_hword+0x128>


    /*
     * Disable interrupts which might cause a timeout
     * here. Remember that our exception vectors are
     * at address 0 in the flash, and we don't want a
     * (ticker) exception to happen while the flash
     * chip is in programming mode.
     */
    cflag = icache_status();
    icache_disable();
    iflag = disable_interrupts();

    MEM_FLASH_ADDR1 = CMD_UNLOCK1;
    MEM_FLASH_ADDR2 = CMD_UNLOCK2;
    MEM_FLASH_ADDR1 = CMD_UNLOCK_BYPASS;
    *addr = CMD_PROGRAM;
    *addr = data;

    /* arm simple, non interrupt dependent timer */
    reset_timer_masked();

    /* wait until flash is ready */
    chip = 0;
    do
    {
	result = *addr;

	/* check timeout */
	if (get_timer_masked() > CFG_FLASH_ERASE_TOUT)
	{
	    chip = ERR | TMO;
 3f13ec8:	e3a04006 	mov	r4, #6	; 0x6
	    break;
 3f13ecc:	ea000029 	b	3f13f78 <write_hword+0xe8>
 3f13ed0:	eb0009c9 	bl	3f165fc <icache_status>
 3f13ed4:	e50b0028 	str	r0, [r11, -#40]
 3f13ed8:	eb0009be 	bl	3f165d8 <icache_disable>
 3f13edc:	ebffb173 	bl	3f004b0 <disable_interrupts>
 3f13ee0:	e59f10d4 	ldr	r1, [pc, #d4]	; 3f13fbc <write_hword+0x12c>
 3f13ee4:	e59f20d4 	ldr	r2, [pc, #d4]	; 3f13fc0 <write_hword+0x130>
 3f13ee8:	e3a030aa 	mov	r3, #170	; 0xaa
 3f13eec:	e1c130b0 	strh	r3, [r1]
 3f13ef0:	e2433055 	sub	r3, r3, #85	; 0x55
 3f13ef4:	e1c230b0 	strh	r3, [r2]
 3f13ef8:	e2433035 	sub	r3, r3, #53	; 0x35
 3f13efc:	e1c130b0 	strh	r3, [r1]
 3f13f00:	e2833080 	add	r3, r3, #128	; 0x80
 3f13f04:	e1c530b0 	strh	r3, [r5]
 3f13f08:	e1a0400a 	mov	r4, r10
 3f13f0c:	e1c560b0 	strh	r6, [r5]
 3f13f10:	e1a09000 	mov	r9, r0
 3f13f14:	ebffb263 	bl	3f008a8 <reset_timer_masked>
 3f13f18:	e1d530b0 	ldrh	r3, [r5]
 3f13f1c:	e1a07003 	mov	r7, r3
 3f13f20:	ebffb26e 	bl	3f008e0 <get_timer_masked>
 3f13f24:	e59f3098 	ldr	r3, [pc, #98]	; 3f13fc4 <write_hword+0x134>
 3f13f28:	e1500003 	cmp	r0, r3
 3f13f2c:	8affffe5 	bhi	3f13ec8 <write_hword+0x38>
	}
	if (!chip && ((result & 0x80) == (data & 0x80)))
 3f13f30:	e3540000 	cmp	r4, #0	; 0x0
 3f13f34:	1a000003 	bne	3f13f48 <write_hword+0xb8>
 3f13f38:	e2072080 	and	r2, r7, #128	; 0x80
 3f13f3c:	e2063080 	and	r3, r6, #128	; 0x80
 3f13f40:	e1520003 	cmp	r2, r3
 3f13f44:	03a04001 	moveq	r4, #1	; 0x1
		chip = READY;

	if (!chip && ((result & 0xFFFF) & BIT_PROGRAM_ERROR))
 3f13f48:	e3540000 	cmp	r4, #0	; 0x0
 3f13f4c:	1a000007 	bne	3f13f70 <write_hword+0xe0>
 3f13f50:	e3170020 	tst	r7, #32	; 0x20
 3f13f54:	0a000005 	beq	3f13f70 <write_hword+0xe0>
	{
		result = *addr;
 3f13f58:	e1d530b0 	ldrh	r3, [r5]

		if ((result & 0x80) == (data & 0x80))
 3f13f5c:	e2062080 	and	r2, r6, #128	; 0x80
 3f13f60:	e2033080 	and	r3, r3, #128	; 0x80
 3f13f64:	e1530002 	cmp	r3, r2
 3f13f68:	13a04002 	movne	r4, #2	; 0x2
 3f13f6c:	03a04001 	moveq	r4, #1	; 0x1
			chip = READY;
		else
			chip = ERR;
	}

    }  while (!chip);
 3f13f70:	e3540000 	cmp	r4, #0	; 0x0
 3f13f74:	0affffe7 	beq	3f13f18 <write_hword+0x88>

    *addr = CMD_READ_ARRAY;

    if (chip == ERR || *addr != data)
 3f13f78:	e3540002 	cmp	r4, #2	; 0x2
 3f13f7c:	e3a030f0 	mov	r3, #240	; 0xf0
 3f13f80:	e1c530b0 	strh	r3, [r5]
 3f13f84:	0a000002 	beq	3f13f94 <write_hword+0x104>
 3f13f88:	e1d530b0 	ldrh	r3, [r5]
 3f13f8c:	e1530006 	cmp	r3, r6
 3f13f90:	0a000000 	beq	3f13f98 <write_hword+0x108>
	rc = ERR_PROG_ERROR;
 3f13f94:	e3a0a080 	mov	r10, #128	; 0x80

    if (iflag)
 3f13f98:	e3590000 	cmp	r9, #0	; 0x0
 3f13f9c:	0a000000 	beq	3f13fa4 <write_hword+0x114>
      enable_interrupts();
 3f13fa0:	ebffb13e 	bl	3f004a0 <enable_interrupts>

    if (cflag)
 3f13fa4:	e51b3028 	ldr	r3, [r11, -#40]
 3f13fa8:	e3530000 	cmp	r3, #0	; 0x0
 3f13fac:	0a000000 	beq	3f13fb4 <write_hword+0x124>
      icache_enable();
 3f13fb0:	eb00097f 	bl	3f165b4 <icache_enable>

    return rc;
 3f13fb4:	e1a0000a 	mov	r0, r10
 3f13fb8:	ea000002 	b	3f13fc8 <write_hword+0x138>
 3f13fbc:	00000aaa 	andeq	r0, r0, r10, lsr #21
 3f13fc0:	00000554 	andeq	r0, r0, r4, asr r5
 3f13fc4:	00708000 	rsbeqs	r8, r0, r0
}
 3f13fc8:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f13fcc <write_buff>:
 3f13fcc:	e1a0c00d 	mov	r12, r13
 3f13fd0:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f13fd4:	e24cb004 	sub	r11, r12, #4	; 0x4

/*-----------------------------------------------------------------------
 * Copy memory to flash.
 */

int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
{
 3f13fd8:	e1a06001 	mov	r6, r1
 3f13fdc:	e1a04003 	mov	r4, r3
    ulong cp, wp;
    int l;
    int i, rc;
    ushort data;

    wp = (addr & ~1);	/* get lower word aligned address */
 3f13fe0:	e3c25001 	bic	r5, r2, #1	; 0x1
 3f13fe4:	e1a07000 	mov	r7, r0

    /*
     * handle unaligned start bytes
     */
    if ((l = addr - wp) != 0) {
 3f13fe8:	e2122001 	ands	r2, r2, #1	; 0x1
 3f13fec:	0a000039 	beq	3f140d8 <write_buff+0x10c>
	data = 0;
 3f13ff0:	e3a0c000 	mov	r12, #0	; 0x0
	for (i=0, cp=wp; i<l; ++i, ++cp) {
 3f13ff4:	e1a0000c 	mov	r0, r12
 3f13ff8:	e1a0e005 	mov	r14, r5
 3f13ffc:	e15c0002 	cmp	r12, r2
 3f14000:	aa000006 	bge	3f14020 <write_buff+0x54>
 3f14004:	e1a00002 	mov	r0, r2
	    data = (data >> 8) | (*(uchar *)cp << 8);
 3f14008:	e4de3001 	ldrb	r3, [r14], #1
 3f1400c:	e2500001 	subs	r0, r0, #1	; 0x1
 3f14010:	e1a03403 	mov	r3, r3, lsl #8
 3f14014:	e183c42c 	orr	r12, r3, r12, lsr #8
 3f14018:	1afffffa 	bne	3f14008 <write_buff+0x3c>
 3f1401c:	e1a00002 	mov	r0, r2
	}
	for (; i<2 && cnt>0; ++i) {
 3f14020:	e2543000 	subs	r3, r4, #0	; 0x0
 3f14024:	13a03001 	movne	r3, #1	; 0x1
 3f14028:	e3500001 	cmp	r0, #1	; 0x1
 3f1402c:	c3a03000 	movgt	r3, #0	; 0x0
 3f14030:	e3530000 	cmp	r3, #0	; 0x0
 3f14034:	0a00000c 	beq	3f1406c <write_buff+0xa0>
	    data = (data >> 8) | (*src++ << 8);
	    --cnt;
	    ++cp;
 3f14038:	e28ee001 	add	r14, r14, #1	; 0x1
 3f1403c:	e2800001 	add	r0, r0, #1	; 0x1
 3f14040:	e3500001 	cmp	r0, #1	; 0x1
 3f14044:	c3a01000 	movgt	r1, #0	; 0x0
 3f14048:	d3a01001 	movle	r1, #1	; 0x1
 3f1404c:	e2544001 	subs	r4, r4, #1	; 0x1
 3f14050:	03a02000 	moveq	r2, #0	; 0x0
 3f14054:	13a02001 	movne	r2, #1	; 0x1
 3f14058:	e4d63001 	ldrb	r3, [r6], #1
 3f1405c:	e1110002 	tst	r1, r2
 3f14060:	e1a03403 	mov	r3, r3, lsl #8
 3f14064:	e183c42c 	orr	r12, r3, r12, lsr #8
 3f14068:	1afffff2 	bne	3f14038 <write_buff+0x6c>
	}
	for (; cnt==0 && i<2; ++i, ++cp) {
 3f1406c:	e3500001 	cmp	r0, #1	; 0x1
 3f14070:	d3540000 	cmple	r4, #0	; 0x0
 3f14074:	1a000006 	bne	3f14094 <write_buff+0xc8>
 3f14078:	e2800001 	add	r0, r0, #1	; 0x1
	    data = (data >> 8) | (*(uchar *)cp << 8);
 3f1407c:	e4de3001 	ldrb	r3, [r14], #1
 3f14080:	e3500001 	cmp	r0, #1	; 0x1
 3f14084:	d3540000 	cmple	r4, #0	; 0x0
 3f14088:	e1a03403 	mov	r3, r3, lsl #8
 3f1408c:	e183c42c 	orr	r12, r3, r12, lsr #8
 3f14090:	0afffff8 	beq	3f14078 <write_buff+0xac>
	}

	if ((rc = write_hword(info, wp, data)) != 0) {
 3f14094:	e1a00007 	mov	r0, r7
 3f14098:	e1a01005 	mov	r1, r5
 3f1409c:	e1a0200c 	mov	r2, r12
 3f140a0:	ebffff7a 	bl	3f13e90 <write_hword>
 3f140a4:	e3500000 	cmp	r0, #0	; 0x0
 3f140a8:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}
	    return (rc);
	}
	wp += 2;
 3f140ac:	e2855002 	add	r5, r5, #2	; 0x2
    }

    /*
     * handle word aligned part
     */
    while (cnt >= 2) {
 3f140b0:	ea000008 	b	3f140d8 <write_buff+0x10c>
	data = *((vu_short*)src);
	if ((rc = write_hword(info, wp, data)) != 0) {
 3f140b4:	e1a00007 	mov	r0, r7
 3f140b8:	e1d620b0 	ldrh	r2, [r6]
 3f140bc:	e1a01005 	mov	r1, r5
 3f140c0:	ebffff72 	bl	3f13e90 <write_hword>
 3f140c4:	e3500000 	cmp	r0, #0	; 0x0
 3f140c8:	191ba8f0 	ldmnedb	r11, {r4, r5, r6, r7, r11, r13, r15}
	    return (rc);
	}
	src += 2;
 3f140cc:	e2866002 	add	r6, r6, #2	; 0x2
	wp  += 2;
 3f140d0:	e2855002 	add	r5, r5, #2	; 0x2
	cnt -= 2;
 3f140d4:	e2444002 	sub	r4, r4, #2	; 0x2
    }
 3f140d8:	e3540001 	cmp	r4, #1	; 0x1
 3f140dc:	8afffff4 	bhi	3f140b4 <write_buff+0xe8>

    if (cnt == 0) {
 3f140e0:	e3540000 	cmp	r4, #0	; 0x0
	return ERR_OK;
 3f140e4:	01a00004 	moveq	r0, r4
 3f140e8:	091ba8f0 	ldmeqdb	r11, {r4, r5, r6, r7, r11, r13, r15}
    }

    /*
     * handle unaligned tail bytes
     */
    data = 0;
 3f140ec:	e3a0c000 	mov	r12, #0	; 0x0
    for (i=0, cp=wp; i<2 && cnt>0; ++i, ++cp) {
 3f140f0:	e1a0000c 	mov	r0, r12
 3f140f4:	e1a0e005 	mov	r14, r5
 3f140f8:	e2800001 	add	r0, r0, #1	; 0x1
 3f140fc:	e28ee001 	add	r14, r14, #1	; 0x1
 3f14100:	e3500001 	cmp	r0, #1	; 0x1
 3f14104:	c3a01000 	movgt	r1, #0	; 0x0
 3f14108:	d3a01001 	movle	r1, #1	; 0x1
 3f1410c:	e2544001 	subs	r4, r4, #1	; 0x1
 3f14110:	03a02000 	moveq	r2, #0	; 0x0
 3f14114:	13a02001 	movne	r2, #1	; 0x1
	data = (data >> 8) | (*src++ << 8);
 3f14118:	e4d63001 	ldrb	r3, [r6], #1
 3f1411c:	e1110002 	tst	r1, r2
 3f14120:	e1a03403 	mov	r3, r3, lsl #8
 3f14124:	e183c42c 	orr	r12, r3, r12, lsr #8
 3f14128:	1afffff2 	bne	3f140f8 <write_buff+0x12c>
	--cnt;
    }
    for (; i<2; ++i, ++cp) {
 3f1412c:	e3500001 	cmp	r0, #1	; 0x1
 3f14130:	ca000005 	bgt	3f1414c <write_buff+0x180>
 3f14134:	e2600002 	rsb	r0, r0, #2	; 0x2
	data = (data >> 8) | (*(uchar *)cp << 8);
 3f14138:	e4de3001 	ldrb	r3, [r14], #1
 3f1413c:	e2500001 	subs	r0, r0, #1	; 0x1
 3f14140:	e1a03403 	mov	r3, r3, lsl #8
 3f14144:	e183c42c 	orr	r12, r3, r12, lsr #8
 3f14148:	1afffffa 	bne	3f14138 <write_buff+0x16c>
    }

    return write_hword(info, wp, data);
 3f1414c:	e1a00007 	mov	r0, r7
 3f14150:	e1a01005 	mov	r1, r5
 3f14154:	e1a0200c 	mov	r2, r12
 3f14158:	ebffff4c 	bl	3f13e90 <write_hword>
}
 3f1415c:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}

03f14160 <mmc_get_dev>:
 3f14160:	e1a0c00d 	mov	r12, r13
 3f14164:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f14168:	e24cb004 	sub	r11, r12, #4	; 0x4
static block_dev_desc_t mmc_dev;
//[*]----------------------------------------------------------------------------------------------------[*]
block_dev_desc_t * mmc_get_dev(int dev)
{
	return ((block_dev_desc_t *)&mmc_dev);
 3f1416c:	e59f0000 	ldr	r0, [pc, #0]	; 3f14174 <mmc_get_dev+0x14>
 3f14170:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f14174:	03f72f08 	mvneqs	r2, #32	; 0x20

03f14178 <Chk_CMDend>:
 3f14178:	e1a0c00d 	mov	r12, r13
 3f1417c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f14180:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
int isMMC;	// 1:MMC, 0:SD
int RCA=0;	// Relative card address
unsigned int CardSize=0; // SD capacity in byte		 
//[*]----------------------------------------------------------------------------------------------------[*]
// CSD register, rwe == read/write/erase 
typedef struct 
{
	unsigned char csd;		/* CSD structure */
	unsigned char spec_vers;		/* Spec version, MMC only */
	struct 
	{
		unsigned char man;	/* time mantissa */
		unsigned char exp;	/* time exponent */
	} taac;			/* Data read access-time-1 */
	unsigned char nsac;		/* Data read access-time-2 in CLK cycle */
	struct 
	{
		unsigned char man;	/* rate mantissa */
		unsigned char exp;	/* rate exponent */
	} tran_speed;		/* Max. data transfer rate */
	unsigned short ccc;		/* Card command classes */
	unsigned char read_len;		/* Max. read data block length */
	unsigned char read_part;		/* Partial blocks for read allowed */
	unsigned char write_mis;		/* write block misalignment */
	unsigned char read_mis;		/* read block misalignment */
	unsigned char dsr;		/* DSR implemented */
	unsigned short  c_size;		/* Device size */
	unsigned char vcc_r_min;		/* Max. read current at Vcc min */
	unsigned char vcc_r_max;		/* Max. read current at Vcc max */
	unsigned char vcc_w_min;		/* Max. write current at Vcc min */
	unsigned char vcc_w_max;		/* Max. write current at Vcc max */
	unsigned char c_size_mult;	/* Device size multiplier */
	unsigned char er_size;		/* Erase sector size, MMC only */
	unsigned char er_grp_size;	/* Erase group size, MMC only */
	unsigned char wp_grp_size;	/* Write protect group size */
	unsigned char wp_grp_en;		/* Write protect group enable */
	unsigned char dflt_ecc;		/* Manufacturer default ECC, MMC only */
	unsigned char r2w_factor;	/* Write speed factor */
	unsigned char write_len;		/* Max. write data block length */
	unsigned char write_part;	/* Partial blocks for write allowed */
	unsigned char ffmt_grp;		/* File format group, rw */
	unsigned char copy;		/* Copy flag (OTP), rw */
	unsigned char perm_wp;		/* Permanent write protection, rw */
	unsigned char tmp_wp;		/* temporary write protection, rwe */
	unsigned char ffmt;		/* file format, rw */
	unsigned char ecc;		/* ECC, rwe, MMC only */

	/* SD only */
	unsigned char er_blk_en;		/* Erase single block enable, SD only */
	unsigned char er_sec_size;	/* Erase sector size, SD only */
} CSD_regs;
//[*]----------------------------------------------------------------------------------------------------[*]
int Chk_CMDend(int cmd, int be_resp)
{
	int volatile finish0;

	if(!be_resp)    // No response
 3f14184:	e3510000 	cmp	r1, #0	; 0x0
 3f14188:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f1418c:	1a00000a 	bne	3f141bc <Chk_CMDend+0x44>
	{
		finish0 = rSDICSTA;
		while((finish0&0x800) != 0x800)	// Check cmd end
		{
			finish0=rSDICSTA;
 3f14190:	e59f30b8 	ldr	r3, [pc, #b8]	; 3f14250 <Chk_CMDend+0xd8>
 3f14194:	e1d330b0 	ldrh	r3, [r3]
 3f14198:	e50b3010 	str	r3, [r11, -#16]
		}
 3f1419c:	e51b3010 	ldr	r3, [r11, -#16]
 3f141a0:	e3130b02 	tst	r3, #2048	; 0x800
 3f141a4:	0afffff9 	beq	3f14190 <Chk_CMDend+0x18>
		rSDICSTA = finish0;// Clear cmd end state
 3f141a8:	e59f20a0 	ldr	r2, [pc, #a0]	; 3f14250 <Chk_CMDend+0xd8>
 3f141ac:	e51b3010 	ldr	r3, [r11, -#16]

		return 1;
 3f141b0:	e3a00001 	mov	r0, #1	; 0x1
 3f141b4:	e1c230b0 	strh	r3, [r2]
 3f141b8:	ea000033 	b	3f1428c <Chk_CMDend+0x114>
	}
	else	// With response
	{
		finish0 = rSDICSTA;
		while( !( ((finish0&0x200)==0x200) | ((finish0&0x400)==0x400) ))    // Check cmd/rsp end
			finish0=rSDICSTA;
 3f141bc:	e59f308c 	ldr	r3, [pc, #8c]	; 3f14250 <Chk_CMDend+0xd8>
 3f141c0:	e1d330b0 	ldrh	r3, [r3]
 3f141c4:	e50b3010 	str	r3, [r11, -#16]
 3f141c8:	e51b2010 	ldr	r2, [r11, -#16]
 3f141cc:	e51b3010 	ldr	r3, [r11, -#16]
 3f141d0:	e1a024a2 	mov	r2, r2, lsr #9
 3f141d4:	e2222001 	eor	r2, r2, #1	; 0x1
 3f141d8:	e1a03523 	mov	r3, r3, lsr #10
 3f141dc:	e2233001 	eor	r3, r3, #1	; 0x1
 3f141e0:	e2033001 	and	r3, r3, #1	; 0x1
 3f141e4:	e3530000 	cmp	r3, #0	; 0x0
 3f141e8:	12023001 	andne	r3, r2, #1	; 0x1
 3f141ec:	03a03000 	moveq	r3, #0	; 0x0
 3f141f0:	e3530000 	cmp	r3, #0	; 0x0
 3f141f4:	1afffff0 	bne	3f141bc <Chk_CMDend+0x44>

		if((cmd==1) | (cmd==9) | (cmd==41))	// CRC no check, CMD9 is a long Resp. command.
 3f141f8:	e3500001 	cmp	r0, #1	; 0x1
 3f141fc:	13a02000 	movne	r2, #0	; 0x0
 3f14200:	03a02001 	moveq	r2, #1	; 0x1
 3f14204:	e3500029 	cmp	r0, #41	; 0x29
 3f14208:	13a03000 	movne	r3, #0	; 0x0
 3f1420c:	03a03001 	moveq	r3, #1	; 0x1
 3f14210:	e3500009 	cmp	r0, #9	; 0x9
 3f14214:	03a03001 	moveq	r3, #1	; 0x1
 3f14218:	e1920003 	orrs	r0, r2, r3
 3f1421c:	0a00000c 	beq	3f14254 <Chk_CMDend+0xdc>
		{
			if( (finish0&0xf00) != 0xa00 )  // Check error
 3f14220:	e51b3010 	ldr	r3, [r11, -#16]
 3f14224:	e2033c0f 	and	r3, r3, #3840	; 0xf00
 3f14228:	e3530c0a 	cmp	r3, #2560	; 0xa00
 3f1422c:	0a000012 	beq	3f1427c <Chk_CMDend+0x104>
			{
				rSDICSTA = finish0;   // Clear error state
 3f14230:	e59f3018 	ldr	r3, [pc, #18]	; 3f14250 <Chk_CMDend+0xd8>
 3f14234:	e51b2010 	ldr	r2, [r11, -#16]
 3f14238:	e1c320b0 	strh	r2, [r3]
				if(((finish0&0x400)==0x400))
 3f1423c:	e51b3010 	ldr	r3, [r11, -#16]
 3f14240:	e3130b01 	tst	r3, #1024	; 0x400
 3f14244:	0a00000c 	beq	3f1427c <Chk_CMDend+0x104>
					return 0;	// Timeout error
 3f14248:	e3a00000 	mov	r0, #0	; 0x0
 3f1424c:	ea00000e 	b	3f1428c <Chk_CMDend+0x114>
 3f14250:	c000150a 	andgt	r1, r0, r10, lsl #10
			}
			rSDICSTA = finish0;	// Clear cmd & rsp end state
		}
		else	// CRC check
		{
			if( (finish0&0x1f00) != 0xa00 )	// Check error
 3f14254:	e51b3010 	ldr	r3, [r11, -#16]
 3f14258:	e2033c1f 	and	r3, r3, #7936	; 0x1f00
 3f1425c:	e3530c0a 	cmp	r3, #2560	; 0xa00
 3f14260:	0a000005 	beq	3f1427c <Chk_CMDend+0x104>
			{				
				//printf("CMD%d:rSDICSTA=0x%x,rSDIRSP0=0x%x\n",cmd, rSDICSTA, rSDIRSP0);
				rSDICSTA = finish0;   // Clear error state
 3f14264:	e59f3024 	ldr	r3, [pc, #24]	; 3f14290 <Chk_CMDend+0x118>
 3f14268:	e51b2010 	ldr	r2, [r11, -#16]
 3f1426c:	e1c320b0 	strh	r2, [r3]

				if(((finish0&0x400)==0x400))
 3f14270:	e51b3010 	ldr	r3, [r11, -#16]
 3f14274:	e3130b01 	tst	r3, #1024	; 0x400
 3f14278:	1a000003 	bne	3f1428c <Chk_CMDend+0x114>
					return 0;	// Timeout error
			}
			rSDICSTA=finish0;
 3f1427c:	e59f200c 	ldr	r2, [pc, #c]	; 3f14290 <Chk_CMDend+0x118>
 3f14280:	e51b3010 	ldr	r3, [r11, -#16]
 3f14284:	e1c230b0 	strh	r3, [r2]
		}
		return 1;
 3f14288:	e3a00001 	mov	r0, #1	; 0x1
 3f1428c:	ea000000 	b	3f14294 <Chk_CMDend+0x11c>
 3f14290:	c000150a 	andgt	r1, r0, r10, lsl #10
	}
}
 3f14294:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f14298 <Chk_DATend>:
 3f14298:	e1a0c00d 	mov	r12, r13
 3f1429c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
//[*]----------------------------------------------------------------------------------------------------[*]
int Chk_DATend(void)
{
	int finish;

	finish = rSDIDSTA;
 3f142a0:	e59f3048 	ldr	r3, [pc, #48]	; 3f142f0 <Chk_DATend+0x58>
 3f142a4:	e1d330b0 	ldrh	r3, [r3]
 3f142a8:	e24cb004 	sub	r11, r12, #4	; 0x4
	while( !( ((finish&0x10)==0x10) | ((finish&0x20)==0x20) ))	
 3f142ac:	ea000001 	b	3f142b8 <Chk_DATend+0x20>
	{
		// Chek timeout or data end
		finish = rSDIDSTA;
 3f142b0:	e59f3038 	ldr	r3, [pc, #38]	; 3f142f0 <Chk_DATend+0x58>
 3f142b4:	e1d330b0 	ldrh	r3, [r3]
 3f142b8:	e1a01003 	mov	r1, r3
		//printf("DATA:finish=0x%x\n", finish);
	}
 3f142bc:	e3110030 	tst	r1, #48	; 0x30
 3f142c0:	0afffffa 	beq	3f142b0 <Chk_DATend+0x18>
	if( (finish&0xfc) != 0x10 )
 3f142c4:	e20130fc 	and	r3, r1, #252	; 0xfc
 3f142c8:	e3530010 	cmp	r3, #16	; 0x10
	{
		printf("DATA:finish=0x%x\n", finish); // Something wrong !!
		rSDIDSTA = 0xec;  // Clear error state
		return 0;
	}
	return 1;
 3f142cc:	e3a00001 	mov	r0, #1	; 0x1
 3f142d0:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
 3f142d4:	e59f0018 	ldr	r0, [pc, #18]	; 3f142f4 <Chk_DATend+0x5c>
 3f142d8:	ebffe159 	bl	3f0c844 <printf>
 3f142dc:	e3a00000 	mov	r0, #0	; 0x0
 3f142e0:	e59f2008 	ldr	r2, [pc, #8]	; 3f142f0 <Chk_DATend+0x58>
 3f142e4:	e3a030ec 	mov	r3, #236	; 0xec
 3f142e8:	e1c230b0 	strh	r3, [r2]
}
 3f142ec:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f142f0:	c0001528 	andgt	r1, r0, r8, lsr #10
 3f142f4:	03f1f9d4 	mvneqs	r15, #3473408	; 0x350000

03f142f8 <Chk_BUSYend>:
 3f142f8:	e1a0c00d 	mov	r12, r13
 3f142fc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
//[*]----------------------------------------------------------------------------------------------------[*]
int Chk_BUSYend(void)
{
	int finish;

	finish = rSDIDSTA;
 3f14300:	e59f3048 	ldr	r3, [pc, #48]	; 3f14350 <Chk_BUSYend+0x58>
 3f14304:	e1d330b0 	ldrh	r3, [r3]
 3f14308:	e24cb004 	sub	r11, r12, #4	; 0x4
	while( !( ((finish&0x08)==0x08) | ((finish&0x20)==0x20) ))
 3f1430c:	ea000001 	b	3f14318 <Chk_BUSYend+0x20>
		finish = rSDIDSTA;
 3f14310:	e59f3038 	ldr	r3, [pc, #38]	; 3f14350 <Chk_BUSYend+0x58>
 3f14314:	e1d330b0 	ldrh	r3, [r3]
 3f14318:	e1a01003 	mov	r1, r3
 3f1431c:	e3110028 	tst	r1, #40	; 0x28
 3f14320:	0afffffa 	beq	3f14310 <Chk_BUSYend+0x18>

	if( (finish&0xfc) != 0x08 )
 3f14324:	e20130fc 	and	r3, r1, #252	; 0xfc
 3f14328:	e3530008 	cmp	r3, #8	; 0x8
	{
		printf("BUSY:finish=0x%x\n", finish);
		rSDIDSTA = 0xf4;  //clear error state
		return 0;
	}
	return 1;
 3f1432c:	e3a00001 	mov	r0, #1	; 0x1
 3f14330:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
 3f14334:	e59f0018 	ldr	r0, [pc, #18]	; 3f14354 <Chk_BUSYend+0x5c>
 3f14338:	ebffe141 	bl	3f0c844 <printf>
 3f1433c:	e3a00000 	mov	r0, #0	; 0x0
 3f14340:	e59f2008 	ldr	r2, [pc, #8]	; 3f14350 <Chk_BUSYend+0x58>
 3f14344:	e3a030f4 	mov	r3, #244	; 0xf4
 3f14348:	e1c230b0 	strh	r3, [r2]
}
 3f1434c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f14350:	c0001528 	andgt	r1, r0, r8, lsr #10
 3f14354:	03f1f9e8 	mvneqs	r15, #3801088	; 0x3a0000

03f14358 <CMD0>:
 3f14358:	e1a0c00d 	mov	r12, r13
 3f1435c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f14360:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
void CMD0(void)
{
	//-- Make card idle state 
	rSDICARG = 0x0;	    // CMD0(stuff bit)
 3f14364:	e59f301c 	ldr	r3, [pc, #1c]	; 3f14388 <CMD0+0x30>
 3f14368:	e3a00000 	mov	r0, #0	; 0x0
	rSDICCON = (1<<8) | 0x40;   // No_resp, start, CMD0
 3f1436c:	e59f2018 	ldr	r2, [pc, #18]	; 3f1438c <CMD0+0x34>

	//-- Check end of CMD0
	Chk_CMDend(0, 0);
 3f14370:	e1a01000 	mov	r1, r0
 3f14374:	e5830000 	str	r0, [r3]
 3f14378:	e3a03d05 	mov	r3, #320	; 0x140
 3f1437c:	e1c230b0 	strh	r3, [r2]
 3f14380:	ebffff7c 	bl	3f14178 <Chk_CMDend>
 3f14384:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f14388:	c0001504 	andgt	r1, r0, r4, lsl #10
 3f1438c:	c0001508 	andgt	r1, r0, r8, lsl #10

03f14390 <CMD55>:
 3f14390:	e1a0c00d 	mov	r12, r13
 3f14394:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
//	rSDICSTA=0x800;	    // Clear cmd_end(no rsp)
}
//[*]----------------------------------------------------------------------------------------------------[*]
int CMD55(void)
{
	//--Make ACMD
	//rSDICARG=RCA<<16;			//CMD7(RCA,stuff bit)
	rSDICARG = (RCA<<16) & 0xffff0000;	// CMD7(RCA,stuff bit)
 3f14398:	e59f3034 	ldr	r3, [pc, #34]	; 3f143d4 <CMD55+0x44>
 3f1439c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f143a0:	e5933000 	ldr	r3, [r3]
	rSDICCON=(0x1<<9)|(0x1<<8)|0x77;	//sht_resp, wait_resp, start, CMD55

	//-- Check end of CMD55
	if(!Chk_CMDend(55, 1)) 
 3f143a4:	e3a00037 	mov	r0, #55	; 0x37
 3f143a8:	e59f2028 	ldr	r2, [pc, #28]	; 3f143d8 <CMD55+0x48>
 3f143ac:	e1a03803 	mov	r3, r3, lsl #16
 3f143b0:	e5823000 	str	r3, [r2]
 3f143b4:	e3a01001 	mov	r1, #1	; 0x1
 3f143b8:	e59f301c 	ldr	r3, [pc, #1c]	; 3f143dc <CMD55+0x4c>
 3f143bc:	e2822004 	add	r2, r2, #4	; 0x4
 3f143c0:	e1c230b0 	strh	r3, [r2]
 3f143c4:	ebffff6b 	bl	3f14178 <Chk_CMDend>
 3f143c8:	e2500000 	subs	r0, r0, #0	; 0x0
 3f143cc:	13a00001 	movne	r0, #1	; 0x1
 3f143d0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f143d4:	03f21178 	mvneqs	r1, #30	; 0x1e
 3f143d8:	c0001504 	andgt	r1, r0, r4, lsl #10
 3f143dc:	00000377 	andeq	r0, r0, r7, ror r3

03f143e0 <CMD9>:
 3f143e0:	e1a0c00d 	mov	r12, r13
 3f143e4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
		return 0;

	//rSDICSTA=0xa00;	// Clear cmd_end(with rsp)
	return 1;
}
//[*]----------------------------------------------------------------------------------------------------[*]
CSD_regs csd;
//[*]----------------------------------------------------------------------------------------------------[*]
int CMD9(void)//SEND_CSD
{
	rSDICARG = (RCA<<16) & 0xffff0000;	// CMD7(RCA,stuff bit)
 3f143e8:	e59f3034 	ldr	r3, [pc, #34]	; 3f14424 <CMD9+0x44>
 3f143ec:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f143f0:	e5933000 	ldr	r3, [r3]
	rSDICCON = (0x1<<10) | (0x1<<9) | (0x1<<8) | 0x49;	// long_resp, wait_resp, start, CMD9
	
    if(!Chk_CMDend(9, 1)) 
 3f143f4:	e3a00009 	mov	r0, #9	; 0x9
 3f143f8:	e59f2028 	ldr	r2, [pc, #28]	; 3f14428 <CMD9+0x48>
 3f143fc:	e1a03803 	mov	r3, r3, lsl #16
 3f14400:	e5823000 	str	r3, [r2]
 3f14404:	e3a01001 	mov	r1, #1	; 0x1
 3f14408:	e59f301c 	ldr	r3, [pc, #1c]	; 3f1442c <CMD9+0x4c>
 3f1440c:	e2822004 	add	r2, r2, #4	; 0x4
 3f14410:	e1c230b0 	strh	r3, [r2]
 3f14414:	ebffff57 	bl	3f14178 <Chk_CMDend>
 3f14418:	e2500000 	subs	r0, r0, #0	; 0x0
 3f1441c:	13a00001 	movne	r0, #1	; 0x1
 3f14420:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f14424:	03f21178 	mvneqs	r1, #30	; 0x1e
 3f14428:	c0001504 	andgt	r1, r0, r4, lsl #10
 3f1442c:	00000749 	andeq	r0, r0, r9, asr #14

03f14430 <Chk_MMC_OCR>:
 3f14430:	e1a0c00d 	mov	r12, r13
 3f14434:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f14438:	e24cb004 	sub	r11, r12, #4	; 0x4
		return 0;

    return 1;
}
//[*]----------------------------------------------------------------------------------------------------[*]
int Chk_MMC_OCR(void)
{
	int i;
	
    //-- Negotiate operating condition for MMC, it makes card ready state
    for(i=0;i<15;i++)
 3f1443c:	e3a04000 	mov	r4, #0	; 0x0
    {
    	rSDICARG=0xffc000;	    	    //CMD1(OCR:2.6V~3.6V)
 3f14440:	e59f2050 	ldr	r2, [pc, #50]	; 3f14498 <Chk_MMC_OCR+0x68>
 3f14444:	e59f3050 	ldr	r3, [pc, #50]	; 3f1449c <Chk_MMC_OCR+0x6c>
    	rSDICCON=(0x1<<9)|(0x1<<8)|0x41;    //sht_resp, wait_resp, start, CMD1

    	//-- Check end of CMD1
    	if(Chk_CMDend(1, 1) & (rSDIRSP0==0x80ffc000)) 
 3f14448:	e3a00001 	mov	r0, #1	; 0x1
 3f1444c:	e5823000 	str	r3, [r2]
 3f14450:	e1a01000 	mov	r1, r0
 3f14454:	e59f3044 	ldr	r3, [pc, #44]	; 3f144a0 <Chk_MMC_OCR+0x70>
 3f14458:	e2822004 	add	r2, r2, #4	; 0x4
 3f1445c:	e1c230b0 	strh	r3, [r2]
 3f14460:	ebffff44 	bl	3f14178 <Chk_CMDend>
 3f14464:	e59f3038 	ldr	r3, [pc, #38]	; 3f144a4 <Chk_MMC_OCR+0x74>
 3f14468:	e5932000 	ldr	r2, [r3]
 3f1446c:	e59f3034 	ldr	r3, [pc, #34]	; 3f144a8 <Chk_MMC_OCR+0x78>
 3f14470:	e1520003 	cmp	r2, r3
 3f14474:	1a000002 	bne	3f14484 <Chk_MMC_OCR+0x54>
 3f14478:	e3100001 	tst	r0, #1	; 0x1
		{
	    	//rSDICSTA=0xa00;	// Clear cmd_end(with rsp)
	    	return 1;	// Success
 3f1447c:	13a00001 	movne	r0, #1	; 0x1
 3f14480:	191ba810 	ldmnedb	r11, {r4, r11, r13, r15}
 3f14484:	e2844001 	add	r4, r4, #1	; 0x1
 3f14488:	e354000e 	cmp	r4, #14	; 0xe
 3f1448c:	daffffeb 	ble	3f14440 <Chk_MMC_OCR+0x10>
		}	
    }
    //rSDICSTA=0xa00;	// Clear cmd_end(with rsp)
    return 0;		// Fail
 3f14490:	e3a00000 	mov	r0, #0	; 0x0
}
 3f14494:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f14498:	c0001504 	andgt	r1, r0, r4, lsl #10
 3f1449c:	00ffc000 	rsceqs	r12, r15, r0
 3f144a0:	00000341 	andeq	r0, r0, r1, asr #6
 3f144a4:	c000150c 	andgt	r1, r0, r12, lsl #10
 3f144a8:	80ffc000 	rschis	r12, r15, r0

03f144ac <Chk_SD_OCR>:
 3f144ac:	e1a0c00d 	mov	r12, r13
 3f144b0:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f144b4:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
int Chk_SD_OCR(void)
{
    int i=0;
 3f144b8:	e3a04000 	mov	r4, #0	; 0x0

    //-- Negotiate operating condition for SD, it makes card ready state
//    for(i=0;i<15;i++)
    for(i=0;i<150;i++)
    {
//    	printf("SD i : %d\t", i);
    	CMD55();    // Make ACMD
 3f144bc:	ebffffb3 	bl	3f14390 <CMD55>

    	rSDICARG = 0x00ff8000;					// ACMD41(OCR:2.7V~3.6V)
 3f144c0:	e59f2058 	ldr	r2, [pc, #58]	; 3f14520 <Chk_SD_OCR+0x74>
 3f144c4:	e59f3058 	ldr	r3, [pc, #58]	; 3f14524 <Chk_SD_OCR+0x78>
    	rSDICCON = (0x1<<9) | (0x1<<8) | 0x69;	// sht_resp, wait_resp, start, ACMD41

		//-- Check end of ACMD41
	    if(Chk_CMDend(41, 1) & (rSDIRSP0==0x80ff8000)) 
 3f144c8:	e3a00029 	mov	r0, #41	; 0x29
 3f144cc:	e5823000 	str	r3, [r2]
 3f144d0:	e3a01001 	mov	r1, #1	; 0x1
 3f144d4:	e59f304c 	ldr	r3, [pc, #4c]	; 3f14528 <Chk_SD_OCR+0x7c>
 3f144d8:	e2822004 	add	r2, r2, #4	; 0x4
 3f144dc:	e1c230b0 	strh	r3, [r2]
 3f144e0:	ebffff24 	bl	3f14178 <Chk_CMDend>
 3f144e4:	e59f3040 	ldr	r3, [pc, #40]	; 3f1452c <Chk_SD_OCR+0x80>
 3f144e8:	e5932000 	ldr	r2, [r3]
 3f144ec:	e59f303c 	ldr	r3, [pc, #3c]	; 3f14530 <Chk_SD_OCR+0x84>
 3f144f0:	e1520003 	cmp	r2, r3
 3f144f4:	1a000002 	bne	3f14504 <Chk_SD_OCR+0x58>
 3f144f8:	e3100001 	tst	r0, #1	; 0x1
		{
		    //rSDICSTA=0xa00;	// Clear cmd_end(with rsp)
		    return 1;	// Success	    
 3f144fc:	e3a00001 	mov	r0, #1	; 0x1
 3f14500:	191ba810 	ldmnedb	r11, {r4, r11, r13, r15}
		}
		udelay(20000); // Wait Card power up status
 3f14504:	e59f0028 	ldr	r0, [pc, #28]	; 3f14534 <Chk_SD_OCR+0x88>
 3f14508:	e2844001 	add	r4, r4, #1	; 0x1
 3f1450c:	ebffb0c1 	bl	3f00818 <udelay>
 3f14510:	e3540095 	cmp	r4, #149	; 0x95
 3f14514:	daffffe8 	ble	3f144bc <Chk_SD_OCR+0x10>
    }
    //rSDICSTA=0xa00;	// Clear cmd_end(with rsp)
    return 0;		// Fail
 3f14518:	e3a00000 	mov	r0, #0	; 0x0
    
    
    /*
    	struct mmcsd_cmd  cmd;
retry_sd_ocr:
	// CMD55, make ACMD 
	slot->rca = 0;
	cmd.cmd = MMCSD_CMD55;
	cmd.arg = (slot->rca << 16) & 0xffff0000;
	cmd.res_type = MMCSD_RES_TYPE_R1;
	cmd.res_flag = 0;
	cmd.t_res = MMCSD_TIME_NCR_MAX;
	cmd.t_fin = MMCSD_TIME_NRC_MIN;
    slot->send_cmd(slot, &cmd);
	
	// ACMD41, SEND_OP_COND 
	cmd.cmd = MMCSD_ACMD41;
	slot->ocr = MMCSD_VDD_27_36;
	cmd.arg = slot->ocr;
	cmd.res_type = MMCSD_RES_TYPE_R1;
	cmd.res_flag = MMCSD_RES_FLAG_NOCRC;
	cmd.t_res = MMCSD_TIME_NCR_MAX;
	cmd.t_fin = MMCSD_TIME_NRC_MIN;
	slot->send_cmd(slot, &cmd);

	if(SDIRSP0 == 0x80ff8000) {
		mdelay(10);	// wait card power up status
		return 1;	//success
	} else
		goto retry_sd_ocr;
	return 0;		// fail
	*/
}
 3f1451c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f14520:	c0001504 	andgt	r1, r0, r4, lsl #10
 3f14524:	00ff8000 	rsceqs	r8, r15, r0
 3f14528:	00000369 	andeq	r0, r0, r9, ror #6
 3f1452c:	c000150c 	andgt	r1, r0, r12, lsl #10
 3f14530:	80ff8000 	rschis	r8, r15, r0
 3f14534:	00004e20 	andeq	r4, r0, r0, lsr #28

03f14538 <SetBus>:
 3f14538:	e1a0c00d 	mov	r12, r13
 3f1453c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f14540:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
int CardBusWidth = 0;
//[*]----------------------------------------------------------------------------------------------------[*]
void SetBus(void)
{
SET_BUS:
	CMD55();	// Make ACMD
 3f14544:	ebffff91 	bl	3f14390 <CMD55>
	//-- CMD6 implement
	rSDICARG = CardBusWidth<<1;	    	//Width 0: 1bit, 1: 4bit
 3f14548:	e59f3030 	ldr	r3, [pc, #30]	; 3f14580 <SetBus+0x48>
 3f1454c:	e5933000 	ldr	r3, [r3]
	rSDICCON=(0x1<<9)|(0x1<<8)|0x46;	//sht_resp, wait_resp, start, CMD55

	if(!Chk_CMDend(6, 1))   // ACMD6
 3f14550:	e3a00006 	mov	r0, #6	; 0x6
 3f14554:	e59f2028 	ldr	r2, [pc, #28]	; 3f14584 <SetBus+0x4c>
 3f14558:	e1a03083 	mov	r3, r3, lsl #1
 3f1455c:	e5823000 	str	r3, [r2]
 3f14560:	e3a01001 	mov	r1, #1	; 0x1
 3f14564:	e59f301c 	ldr	r3, [pc, #1c]	; 3f14588 <SetBus+0x50>
 3f14568:	e2822004 	add	r2, r2, #4	; 0x4
 3f1456c:	e1c230b0 	strh	r3, [r2]
 3f14570:	ebffff00 	bl	3f14178 <Chk_CMDend>
 3f14574:	e3500000 	cmp	r0, #0	; 0x0
 3f14578:	0afffff1 	beq	3f14544 <SetBus+0xc>
 3f1457c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f14580:	03f21180 	mvneqs	r1, #32	; 0x20
 3f14584:	c0001504 	andgt	r1, r0, r4, lsl #10
 3f14588:	00000346 	andeq	r0, r0, r6, asr #6

03f1458c <Card_sel_desel>:
 3f1458c:	e1a0c00d 	mov	r12, r13
 3f14590:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f14594:	e24cb004 	sub	r11, r12, #4	; 0x4
		goto SET_BUS;
	//rSDICSTA=0xa00;	    // Clear cmd_end(with rsp)
}
//[*]----------------------------------------------------------------------------------------------------[*]
void Card_sel_desel(char sel_desel)
{
	//-- Card select or deselect
	if(sel_desel)
 3f14598:	e31000ff 	tst	r0, #255	; 0xff
 3f1459c:	0a000011 	beq	3f145e8 <Card_sel_desel+0x5c>
	{
RECMDS7:
		rSDICARG = (RCA<<16) & 0xffff0000;	// CMD7(RCA,stuff bit)
 3f145a0:	e59f306c 	ldr	r3, [pc, #6c]	; 3f14614 <Card_sel_desel+0x88>
 3f145a4:	e5933000 	ldr	r3, [r3]
		rSDICCON= (0x1<<9)|(0x1<<8)|0x47;   // sht_resp, wait_resp, start, CMD7

		//-- Check end of CMD7
		if(!Chk_CMDend(7, 1))
 3f145a8:	e3a00007 	mov	r0, #7	; 0x7
 3f145ac:	e59f2064 	ldr	r2, [pc, #64]	; 3f14618 <Card_sel_desel+0x8c>
 3f145b0:	e1a03803 	mov	r3, r3, lsl #16
 3f145b4:	e5823000 	str	r3, [r2]
 3f145b8:	e3a01001 	mov	r1, #1	; 0x1
 3f145bc:	e59f3058 	ldr	r3, [pc, #58]	; 3f1461c <Card_sel_desel+0x90>
 3f145c0:	e2822004 	add	r2, r2, #4	; 0x4
 3f145c4:	e1c230b0 	strh	r3, [r2]
 3f145c8:	ebfffeea 	bl	3f14178 <Chk_CMDend>
 3f145cc:	e3500000 	cmp	r0, #0	; 0x0
 3f145d0:	0afffff2 	beq	3f145a0 <Card_sel_desel+0x14>
			goto RECMDS7;
		//rSDICSTA=0xa00;	// Clear cmd_end(with rsp)

		//--State(transfer) check
		if( rSDIRSP0 & (0x1e00!=0x800) )
 3f145d4:	e59f3044 	ldr	r3, [pc, #44]	; 3f14620 <Card_sel_desel+0x94>
 3f145d8:	e5933000 	ldr	r3, [r3]
 3f145dc:	e3130001 	tst	r3, #1	; 0x1
 3f145e0:	1affffee 	bne	3f145a0 <Card_sel_desel+0x14>
			goto RECMDS7;
	}
 3f145e4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else
	{
RECMDD7:
		rSDICARG=0<<16;		//CMD7(RCA,stuff bit)
 3f145e8:	e59f3028 	ldr	r3, [pc, #28]	; 3f14618 <Card_sel_desel+0x8c>
		rSDICCON=(0x1<<8)|0x47;	//no_resp, start, CMD7
 3f145ec:	e59f2030 	ldr	r2, [pc, #30]	; 3f14624 <Card_sel_desel+0x98>
 3f145f0:	e3a01000 	mov	r1, #0	; 0x0
 3f145f4:	e5831000 	str	r1, [r3]
 3f145f8:	e59f3028 	ldr	r3, [pc, #28]	; 3f14628 <Card_sel_desel+0x9c>

		//-- Check end of CMD7
		if(!Chk_CMDend(7, 0))
 3f145fc:	e3a00007 	mov	r0, #7	; 0x7
 3f14600:	e1c230b0 	strh	r3, [r2]
 3f14604:	ebfffedb 	bl	3f14178 <Chk_CMDend>
 3f14608:	e3500000 	cmp	r0, #0	; 0x0
 3f1460c:	0afffff5 	beq	3f145e8 <Card_sel_desel+0x5c>
			goto RECMDD7;
		//rSDICSTA=0x800;	// Clear cmd_end(no rsp)
	}
 3f14610:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f14614:	03f21178 	mvneqs	r1, #30	; 0x1e
 3f14618:	c0001504 	andgt	r1, r0, r4, lsl #10
 3f1461c:	00000347 	andeq	r0, r0, r7, asr #6
 3f14620:	c000150c 	andgt	r1, r0, r12, lsl #10
 3f14624:	c0001508 	andgt	r1, r0, r8, lsl #10
 3f14628:	00000147 	andeq	r0, r0, r7, asr #2

03f1462c <mmc_bread>:
 3f1462c:	e1a0c00d 	mov	r12, r13
 3f14630:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f14634:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void SD_Read(unsigned char * pucdata, unsigned long ulLBA, unsigned long ulSectors);
void SD_Write(unsigned char * pucdata, unsigned long ulLBA, unsigned long ulSectors);
unsigned int SD_card_init(void);
//[*]----------------------------------------------------------------------------------------------------[*]
ulong mmc_bread(int dev_num, ulong blknr, ulong blkcnt, ulong *dst)
{
 3f14638:	e1a00003 	mov	r0, r3
//	int mmc_block_size = MMC_BLOCK_SIZE;
//	ulong src = blknr * mmc_block_size + CFG_MMC_BASE;

	if(blkcnt==0)
 3f1463c:	e2524000 	subs	r4, r2, #0	; 0x0
 3f14640:	0a000003 	beq	3f14654 <mmc_bread+0x28>
	{
		printf("Why block_cnt == 0?? \n");
		return 0;
	}
//	mmc_read(src, (uchar *)dst, blkcnt*mmc_block_size);
//	printf("mmc_bread LBA=%d, Count=%d\n",blknr,blkcnt);
	SD_Read((uchar *)dst, blknr, blkcnt);
 3f14644:	e1a02004 	mov	r2, r4
 3f14648:	eb00010a 	bl	3f14a78 <SD_Read>
//	printf("mmc_bread end\n");	
	return blkcnt;
 3f1464c:	e1a00004 	mov	r0, r4
 3f14650:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f14654:	e59f0008 	ldr	r0, [pc, #8]	; 3f14664 <mmc_bread+0x38>
 3f14658:	ebffe079 	bl	3f0c844 <printf>
 3f1465c:	e1a00004 	mov	r0, r4
 3f14660:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f14664:	03f1f9fc 	mvneqs	r15, #4128768	; 0x3f0000

03f14668 <mmc_write>:
 3f14668:	e1a0c00d 	mov	r12, r13
 3f1466c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}
//[*]----------------------------------------------------------------------------------------------------[*]
int mmc_write(uchar *src, ulong dst, int size)
{
	printf("\nmmc_write should not be called !!!!\n");
 3f14670:	e59f000c 	ldr	r0, [pc, #c]	; 3f14684 <mmc_write+0x1c>
 3f14674:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f14678:	ebffe071 	bl	3f0c844 <printf>
	//SD_Write(
	return 0;
 3f1467c:	e3a00000 	mov	r0, #0	; 0x0
 3f14680:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f14684:	03f1fa14 	mvneqs	r15, #81920	; 0x14000

03f14688 <mmc_read>:
 3f14688:	e1a0c00d 	mov	r12, r13
 3f1468c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}
//[*]----------------------------------------------------------------------------------------------------[*]
int mmc_read(ulong src, uchar *dst, int size)
{
	printf("\nmmc_read should not be called !!!!\n");
 3f14690:	e59f000c 	ldr	r0, [pc, #c]	; 3f146a4 <mmc_read+0x1c>
 3f14694:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f14698:	ebffe069 	bl	3f0c844 <printf>
	//SD_Write(
	return 0;
 3f1469c:	e3a00000 	mov	r0, #0	; 0x0
 3f146a0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f146a4:	03f1fa3c 	mvneqs	r15, #245760	; 0x3c000

03f146a8 <mmc_init>:
 3f146a8:	e1a0c00d 	mov	r12, r13
 3f146ac:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f146b0:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
#define INICLK	400000
#define SDCLK	25000000	
#define MMCCLK	15000000	
//[*]----------------------------------------------------------------------------------------------------[*]
int mmc_init_once = 0;
//[*]----------------------------------------------------------------------------------------------------[*]
int mmc_init(int verbose)
{
	SD_card_init();
 3f146b4:	eb00000b 	bl	3f146e8 <SD_card_init>
	return 0;
 3f146b8:	e3a00000 	mov	r0, #0	; 0x0
 3f146bc:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f146c0 <mmc2info>:
 3f146c0:	e1a0c00d 	mov	r12, r13
 3f146c4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}
//[*]----------------------------------------------------------------------------------------------------[*]
#define CFG_MMC_BASE 0
//[*]----------------------------------------------------------------------------------------------------[*]
int mmc2info(ulong addr)
{
	/* FIXME hard codes to 32 MB device */
	if (addr >= CFG_MMC_BASE && addr < CFG_MMC_BASE + (CardSize/512))
 3f146c8:	e59f3014 	ldr	r3, [pc, #14]	; 3f146e4 <mmc2info+0x24>
 3f146cc:	e5933000 	ldr	r3, [r3]
 3f146d0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f146d4:	e15004a3 	cmp	r0, r3, lsr #9
 3f146d8:	33a00001 	movcc	r0, #1	; 0x1
 3f146dc:	23a00000 	movcs	r0, #0	; 0x0
 3f146e0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f146e4:	03f2117c 	mvneqs	r1, #31	; 0x1f

03f146e8 <SD_card_init>:
 3f146e8:	e1a0c00d 	mov	r12, r13
 3f146ec:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
	{
		return 1;
	}
	return 0;
}
//[*]----------------------------------------------------------------------------------------------------[*]
#define MMCSD_PCLK			50000000	// 50 MHz
#define MMCSD_MMC_NORCLK	8000000		//  8 MHz
#define MMCSD_SD_NORCLK		2000000		//  2 MHz
#define MMCSD_INICLK		400000		// 400 KHz
//[*]----------------------------------------------------------------------------------------------------[*]
unsigned int SD_card_init(void)
{
	int i;
	unsigned long pclk;

	if(mmc_init_once == 1) return 1;	// already done !!
 3f146f0:	e59f1300 	ldr	r1, [pc, #300]	; 3f149f8 <SD_card_init+0x310>
 3f146f4:	e5910000 	ldr	r0, [r1]
 3f146f8:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f146fc:	e3500001 	cmp	r0, #1	; 0x1
 3f14700:	091baef0 	ldmeqdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
	
	rSDIDCON = 0;
 3f14704:	e59f32f0 	ldr	r3, [pc, #2f0]	; 3f149fc <SD_card_init+0x314>
	rSDIPRE = 0;
 3f14708:	e59f22f0 	ldr	r2, [pc, #2f0]	; 3f14a00 <SD_card_init+0x318>
	rSDICARG = 0;
	rSDICCON = 0;
	rSDICSTA = 0xffff;
	rSDIBSIZE = 512;
	rSDICON = 0;
 3f1470c:	e59f52f0 	ldr	r5, [pc, #2f0]	; 3f14a04 <SD_card_init+0x31c>
	rSDIDSTA = 0xffff;
	rSDIFSTA = 0xffff;
	rSDIDAT = 0;
	rSDIIMSK = 0;
	rSDIDTIMERL = 0xffff;
 3f14710:	e59fa2f0 	ldr	r10, [pc, #2f0]	; 3f14a08 <SD_card_init+0x320>
 3f14714:	e3a04000 	mov	r4, #0	; 0x0
	rSDIDTIMERH = 0x001f;
 3f14718:	e59f92ec 	ldr	r9, [pc, #2ec]	; 3f14a0c <SD_card_init+0x324>
 3f1471c:	e3e06000 	mvn	r6, #0	; 0x0
 3f14720:	e5834000 	str	r4, [r3]
 3f14724:	e3a01c02 	mov	r1, #512	; 0x200
 3f14728:	e1c240b0 	strh	r4, [r2]
 3f1472c:	e243301c 	sub	r3, r3, #28	; 0x1c
 3f14730:	e4834004 	str	r4, [r3], #4
 3f14734:	e1c340b0 	strh	r4, [r3]
 3f14738:	e2833002 	add	r3, r3, #2	; 0x2
 3f1473c:	e1c360b0 	strh	r6, [r3]
 3f14740:	e2833014 	add	r3, r3, #20	; 0x14
 3f14744:	e1c310b0 	strh	r1, [r3]
 3f14748:	e1c540b0 	strh	r4, [r5]
 3f1474c:	e283300a 	add	r3, r3, #10	; 0xa
 3f14750:	e1c360b0 	strh	r6, [r3]
 3f14754:	e2833002 	add	r3, r3, #2	; 0x2
 3f14758:	e282202a 	add	r2, r2, #42	; 0x2a
 3f1475c:	e1c360b0 	strh	r6, [r3]
 3f14760:	e1a03004 	mov	r3, r4
 3f14764:	e5c23000 	strb	r3, [r2]
 3f14768:	e59f32a0 	ldr	r3, [pc, #2a0]	; 3f14a10 <SD_card_init+0x328>
 3f1476c:	e5834000 	str	r4, [r3]
 3f14770:	e1ca60b0 	strh	r6, [r10]
 3f14774:	e3a0701f 	mov	r7, #31	; 0x1f
 3f14778:	e1c970b0 	strh	r7, [r9]

	pclk = get_PCLK();
 3f1477c:	eb0007fa 	bl	3f1676c <get_PCLK>
	//printf("\nSystem Frequency is %dHz\n",pclk);

	//rSDIPRE = pclk/(INICLK)-1;	// 400KHz
	rSDIPRE = MMCSD_PCLK/(2*MMCSD_INICLK) -1;
 3f14780:	e59f2278 	ldr	r2, [pc, #278]	; 3f14a00 <SD_card_init+0x318>
 3f14784:	e3a0303d 	mov	r3, #61	; 0x3d
 3f14788:	e1c230b0 	strh	r3, [r2]
	//printf("\nInit. Frequency is %dHz\n",(pclk/(rSDIPRE+1)));

	rSDICON = (1<<4) | (1<<1) | 1;	// Type A, clk enable	(For Little Endian by Salamander)
 3f1478c:	e243302a 	sub	r3, r3, #42	; 0x2a
 3f14790:	e1c530b0 	strh	r3, [r5]
	
	//rSDIFSTA   = rSDIFSTA|(1<<16);	// FIFO reset
	rSDICON = rSDICON | (1<<1);		// FIFO reset
 3f14794:	e1d530b0 	ldrh	r3, [r5]
 3f14798:	e3833002 	orr	r3, r3, #2	; 0x2
 3f1479c:	e1c530b0 	strh	r3, [r5]
	rSDIBSIZE  = 0x200;			// 512byte(128word)
 3f147a0:	e59f326c 	ldr	r3, [pc, #26c]	; 3f14a14 <SD_card_init+0x32c>
 3f147a4:	e3a01c02 	mov	r1, #512	; 0x200
 3f147a8:	e1c310b0 	strh	r1, [r3]
	/* Set timeout count */
	rSDIDTIMERL = 0xffff;
 3f147ac:	e1ca60b0 	strh	r6, [r10]
 3f147b0:	e1a05000 	mov	r5, r0
	rSDIDTIMERH = 0x001f;
 3f147b4:	e1c970b0 	strh	r7, [r9]

	for(i=0;i<0x1000;i++)	// Wait 74SDCLK for MMC card
 3f147b8:	e2844001 	add	r4, r4, #1	; 0x1
 3f147bc:	e3540a01 	cmp	r4, #4096	; 0x1000
 3f147c0:	bafffffc 	blt	3f147b8 <SD_card_init+0xd0>
		;  

	CMD0();  // Goto idel state
 3f147c4:	ebfffee3 	bl	3f14358 <CMD0>

	//-- Check MMC card OCR
	if(Chk_MMC_OCR())
 3f147c8:	ebffff18 	bl	3f14430 <Chk_MMC_OCR>
 3f147cc:	e2504000 	subs	r4, r0, #0	; 0x0
 3f147d0:	0a000005 	beq	3f147ec <SD_card_init+0x104>
	{
		printf("\nMMC found.\n");
 3f147d4:	e59f023c 	ldr	r0, [pc, #23c]	; 3f14a18 <SD_card_init+0x330>
 3f147d8:	ebffe019 	bl	3f0c844 <printf>
		isMMC=1;
 3f147dc:	e59f2238 	ldr	r2, [pc, #238]	; 3f14a1c <SD_card_init+0x334>
 3f147e0:	e3a03001 	mov	r3, #1	; 0x1
 3f147e4:	e5823000 	str	r3, [r2]
		goto RECMD2;
 3f147e8:	ea00000a 	b	3f14818 <SD_card_init+0x130>
	}

	//printf("MMC check end!!\n");
	
	//-- Check SD card OCR
	if(Chk_SD_OCR()) 
 3f147ec:	ebffff2e 	bl	3f144ac <Chk_SD_OCR>
 3f147f0:	e3500000 	cmp	r0, #0	; 0x0
 3f147f4:	1a000003 	bne	3f14808 <SD_card_init+0x120>
	{
		isMMC=0;
		printf("\nSD found : ");
	}
	else
	{
		printf("\nSD Initialize fail..\n\n");
 3f147f8:	e59f0220 	ldr	r0, [pc, #220]	; 3f14a20 <SD_card_init+0x338>
 3f147fc:	ebffe010 	bl	3f0c844 <printf>
		return 0;
 3f14800:	e1a00004 	mov	r0, r4
 3f14804:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f14808:	e59f320c 	ldr	r3, [pc, #20c]	; 3f14a1c <SD_card_init+0x334>
 3f1480c:	e59f0210 	ldr	r0, [pc, #210]	; 3f14a24 <SD_card_init+0x33c>
 3f14810:	e5834000 	str	r4, [r3]
 3f14814:	ebffe00a 	bl	3f0c844 <printf>
	}

RECMD2:
	//-- Check attaced cards, it makes card identification state
	rSDICARG=0x0;   // CMD2(stuff bit)
 3f14818:	e3a03000 	mov	r3, #0	; 0x0
 3f1481c:	e59f2204 	ldr	r2, [pc, #204]	; 3f14a28 <SD_card_init+0x340>
	rSDICCON=(0x1<<10)|(0x1<<9)|(0x1<<8)|0x42; //lng_resp, wait_resp, start, CMD2

	//-- Check end of CMD2
	if(!Chk_CMDend(2, 1)) 
 3f14820:	e3a00002 	mov	r0, #2	; 0x2
 3f14824:	e5823000 	str	r3, [r2]
 3f14828:	e3a01001 	mov	r1, #1	; 0x1
 3f1482c:	e59f31f8 	ldr	r3, [pc, #1f8]	; 3f14a2c <SD_card_init+0x344>
 3f14830:	e2822004 	add	r2, r2, #4	; 0x4
 3f14834:	e1c230b0 	strh	r3, [r2]
 3f14838:	ebfffe4e 	bl	3f14178 <Chk_CMDend>
 3f1483c:	e3500000 	cmp	r0, #0	; 0x0
 3f14840:	0afffff4 	beq	3f14818 <SD_card_init+0x130>
		goto RECMD2;
	//rSDICSTA=0xa00;	// Clear cmd_end(with rsp)

	//printf("\nEnd id\n");


RECMD3:
	//--Send RCA
	rSDICARG = 0;	   	// CMD3(MMC:Set RCA, SD:Ask RCA-->SBZ)
 3f14844:	e3a03000 	mov	r3, #0	; 0x0
 3f14848:	e59f21d8 	ldr	r2, [pc, #1d8]	; 3f14a28 <SD_card_init+0x340>
	//rSDICARG = isMMC<<16;	   	// CMD3(MMC:Set RCA, SD:Ask RCA-->SBZ)
	rSDICCON = (0x1<<9)|(0x1<<8)|0x43;	// sht_resp, wait_resp, start, CMD3

	//-- Check end of CMD3
	if(!Chk_CMDend(3, 1)) 
 3f1484c:	e3a00003 	mov	r0, #3	; 0x3
 3f14850:	e5823000 	str	r3, [r2]
 3f14854:	e3a01001 	mov	r1, #1	; 0x1
 3f14858:	e59f31d0 	ldr	r3, [pc, #1d0]	; 3f14a30 <SD_card_init+0x348>
 3f1485c:	e2822004 	add	r2, r2, #4	; 0x4
 3f14860:	e1c230b0 	strh	r3, [r2]
 3f14864:	ebfffe43 	bl	3f14178 <Chk_CMDend>
 3f14868:	e3500000 	cmp	r0, #0	; 0x0
 3f1486c:	0afffff4 	beq	3f14844 <SD_card_init+0x15c>
		goto RECMD3;
 
	//rSDICSTA = 0xa00;	// Clear cmd_end(with rsp)

	//--Publish RCA
	if(isMMC) 
 3f14870:	e59f61a4 	ldr	r6, [pc, #1a4]	; 3f14a1c <SD_card_init+0x334>
 3f14874:	e5963000 	ldr	r3, [r6]
 3f14878:	e3530000 	cmp	r3, #0	; 0x0
 3f1487c:	0a000013 	beq	3f148d0 <SD_card_init+0x1e8>
	{
		RCA=1;
		rSDIPRE=(pclk/MMCCLK)-1;	
 3f14880:	e59f21ac 	ldr	r2, [pc, #1ac]	; 3f14a34 <SD_card_init+0x34c>
 3f14884:	e1a03325 	mov	r3, r5, lsr #6
 3f14888:	e0831392 	umull	r1, r3, r2, r3
 3f1488c:	e59fc1a4 	ldr	r12, [pc, #1a4]	; 3f14a38 <SD_card_init+0x350>
 3f14890:	e59f2168 	ldr	r2, [pc, #168]	; 3f14a00 <SD_card_init+0x318>
 3f14894:	e1a035a3 	mov	r3, r3, lsr #11
 3f14898:	e2433001 	sub	r3, r3, #1	; 0x1
 3f1489c:	e1c230b0 	strh	r3, [r2]
		printf("MMC Frequency is %dMHz\n", ((pclk/(rSDIPRE+1))/1000000));
 3f148a0:	e1a00005 	mov	r0, r5
 3f148a4:	e1d210b0 	ldrh	r1, [r2]
 3f148a8:	e3a03001 	mov	r3, #1	; 0x1
 3f148ac:	e58c3000 	str	r3, [r12]
 3f148b0:	e0811003 	add	r1, r1, r3
 3f148b4:	ebfffac9 	bl	3f133e0 <__udivsi3>
 3f148b8:	e59f317c 	ldr	r3, [pc, #17c]	; 3f14a3c <SD_card_init+0x354>
 3f148bc:	e0812093 	umull	r2, r1, r3, r0
 3f148c0:	e59f0178 	ldr	r0, [pc, #178]	; 3f14a40 <SD_card_init+0x358>
 3f148c4:	e1a01921 	mov	r1, r1, lsr #18
 3f148c8:	ebffdfdd 	bl	3f0c844 <printf>
	}
 3f148cc:	ea000012 	b	3f1491c <SD_card_init+0x234>
	else
	{
		RCA = ( rSDIRSP0 & 0xffff0000 )>>16;
		//rSDICARG = (RCA<<16) & 0xffff0000;	// CMD7(RCA,stuff bit)
		
		//printf("RCA=0x%x\n",RCA);
//		rSDIPRE=pclk/(SDCLK);	// Salamander pclk=66Mhz, prescaler = 2, SD_CLK = 22Mhz
		//rSDIPRE=3;  // test 16Mhz
		//printf("SD Frequency is %dMHz\n",(pclk/(rSDIPRE+1))/1000000);
		rSDIPRE = MMCSD_PCLK/(2*MMCSD_SD_NORCLK) -1;
		//rSDIPRE = pclk/(SDCLK+2);	// Salamander pclk=66Mhz, prescaler = 2, SD_CLK = 22Mhz
#if 0 /* org */
		printf("SD Frequency is %dMHz\n",(pclk/(rSDIPRE+1))/1000000);
#else /* shkim patch */
		printf("SD Frequency is %dMHz\n",(MMCSD_PCLK/(rSDIPRE+1))/(2*1000000));
 3f148d0:	e59f016c 	ldr	r0, [pc, #16c]	; 3f14a44 <SD_card_init+0x35c>
 3f148d4:	e59f316c 	ldr	r3, [pc, #16c]	; 3f14a48 <SD_card_init+0x360>
 3f148d8:	e59f1120 	ldr	r1, [pc, #120]	; 3f14a00 <SD_card_init+0x318>
 3f148dc:	e5932000 	ldr	r2, [r3]
 3f148e0:	e3a0300b 	mov	r3, #11	; 0xb
 3f148e4:	e1c130b0 	strh	r3, [r1]
 3f148e8:	e59f3148 	ldr	r3, [pc, #148]	; 3f14a38 <SD_card_init+0x350>
 3f148ec:	e1d110b0 	ldrh	r1, [r1]
 3f148f0:	e1a02822 	mov	r2, r2, lsr #16
 3f148f4:	e5832000 	str	r2, [r3]
 3f148f8:	e2811001 	add	r1, r1, #1	; 0x1
 3f148fc:	eb00174f 	bl	3f1a640 <__divsi3>
 3f14900:	e59f3134 	ldr	r3, [pc, #134]	; 3f14a3c <SD_card_init+0x354>
 3f14904:	e1a01000 	mov	r1, r0
 3f14908:	e0c32391 	smull	r2, r3, r1, r3
 3f1490c:	e59f0138 	ldr	r0, [pc, #138]	; 3f14a4c <SD_card_init+0x364>
 3f14910:	e1a01fc1 	mov	r1, r1, asr #31
 3f14914:	e06119c3 	rsb	r1, r1, r3, asr #19
 3f14918:	ebffdfc9 	bl	3f0c844 <printf>
#endif
	}	
	//--State(stand-by) check
	if( rSDIRSP0 & (0x1e00!=0x600) )  // CURRENT_STATE check
 3f1491c:	e59f3124 	ldr	r3, [pc, #124]	; 3f14a48 <SD_card_init+0x360>
 3f14920:	e5933000 	ldr	r3, [r3]
 3f14924:	e2134001 	ands	r4, r3, #1	; 0x1
 3f14928:	1affffc5 	bne	3f14844 <SD_card_init+0x15c>
		goto RECMD3;

	//printf("\nIn stand-by\n");

	Card_sel_desel(1);	// Select
 3f1492c:	e3a00001 	mov	r0, #1	; 0x1
 3f14930:	ebffff15 	bl	3f1458c <Card_sel_desel>

	if(!isMMC)
 3f14934:	e5963000 	ldr	r3, [r6]
 3f14938:	e3530000 	cmp	r3, #0	; 0x0
 3f1493c:	1a000004 	bne	3f14954 <SD_card_init+0x26c>
	{
		CardBusWidth=1;
 3f14940:	e59f2108 	ldr	r2, [pc, #108]	; 3f14a50 <SD_card_init+0x368>
 3f14944:	e3a03001 	mov	r3, #1	; 0x1
 3f14948:	e5823000 	str	r3, [r2]
		SetBus();	// For SD
 3f1494c:	ebfffef9 	bl	3f14538 <SetBus>
	}
 3f14950:	ea000002 	b	3f14960 <SD_card_init+0x278>
	else
	{
		CardBusWidth=0;
 3f14954:	e59f30f4 	ldr	r3, [pc, #f4]	; 3f14a50 <SD_card_init+0x368>
 3f14958:	e5834000 	str	r4, [r3]
		SetBus();	// For MMC
 3f1495c:	ebfffef5 	bl	3f14538 <SetBus>
	}

/*
	Card_sel_desel(0);	// DeSelect for IDLE

	if(!CMD9())
		printf("Get CSD fail!!!\n");

	Card_sel_desel(1);	// Select
*/

	{
		/* fill in device description */
		mmc_dev.if_type = IF_TYPE_MMC;
		mmc_dev.dev = 0;
		mmc_dev.lun = 0;
		mmc_dev.type = 0;
		/* FIXME fill in the correct size (is set to 32MByte) */
		mmc_dev.blksz = 512;
		//mmc_dev.lba = 0x10000;
		mmc_dev.lba = CardSize / 512;
		mmc_dev.part_type = PART_TYPE_DOS;
		/*
		sprintf(mmc_dev.vendor,"Man %02x%02x%02x Snr %02x%02x%02x",
				cid->id[0], cid->id[1], cid->id[2],
				cid->sn[0], cid->sn[1], cid->sn[2]);
		sprintf(mmc_dev.product,"%s",cid->name);
		sprintf(mmc_dev.revision,"%x %x",cid->hwrev, cid->fwrev);
		*/

		sprintf(mmc_dev.vendor,"Man aESOP1 Snr 123456");
 3f14960:	e59f10ec 	ldr	r1, [pc, #ec]	; 3f14a54 <SD_card_init+0x36c>
 3f14964:	e59f40ec 	ldr	r4, [pc, #ec]	; 3f14a58 <SD_card_init+0x370>
 3f14968:	e3a03006 	mov	r3, #6	; 0x6
 3f1496c:	e5843000 	str	r3, [r4]
 3f14970:	e3a05000 	mov	r5, #0	; 0x0
 3f14974:	e5845004 	str	r5, [r4, #4]
 3f14978:	e5c4500a 	strb	r5, [r4, #10]
 3f1497c:	e5c4500b 	strb	r5, [r4, #11]
 3f14980:	e3a03c02 	mov	r3, #512	; 0x200
 3f14984:	e5843010 	str	r3, [r4, #16]
 3f14988:	e59f30cc 	ldr	r3, [pc, #cc]	; 3f14a5c <SD_card_init+0x374>
 3f1498c:	e3a02002 	mov	r2, #2	; 0x2
 3f14990:	e5933000 	ldr	r3, [r3]
 3f14994:	e2840014 	add	r0, r4, #20	; 0x14
 3f14998:	e5c42008 	strb	r2, [r4, #8]
 3f1499c:	e1a034a3 	mov	r3, r3, lsr #9
 3f149a0:	e584300c 	str	r3, [r4, #12]
 3f149a4:	ebffeda4 	bl	3f1003c <sprintf>
		sprintf(mmc_dev.product,"%s","SDxxxMB");
 3f149a8:	e59f10b0 	ldr	r1, [pc, #b0]	; 3f14a60 <SD_card_init+0x378>
 3f149ac:	e59f20b0 	ldr	r2, [pc, #b0]	; 3f14a64 <SD_card_init+0x37c>
 3f149b0:	e284003c 	add	r0, r4, #60	; 0x3c
 3f149b4:	ebffeda0 	bl	3f1003c <sprintf>
		sprintf(mmc_dev.revision,"%x %x",0x123,0x456);
 3f149b8:	e59f10a8 	ldr	r1, [pc, #a8]	; 3f14a68 <SD_card_init+0x380>
 3f149bc:	e59f20a8 	ldr	r2, [pc, #a8]	; 3f14a6c <SD_card_init+0x384>
 3f149c0:	e59f30a8 	ldr	r3, [pc, #a8]	; 3f14a70 <SD_card_init+0x388>
 3f149c4:	e2840050 	add	r0, r4, #80	; 0x50
 3f149c8:	ebffed9b 	bl	3f1003c <sprintf>

		mmc_dev.removable = 0;
 3f149cc:	e5c45058 	strb	r5, [r4, #88]
		mmc_dev.block_read = mmc_bread;

		fat_register_device(&mmc_dev,1); /* partitions start counting with 1 */
 3f149d0:	e1a00004 	mov	r0, r4
 3f149d4:	e59f3098 	ldr	r3, [pc, #98]	; 3f14a74 <SD_card_init+0x38c>
 3f149d8:	e3a01001 	mov	r1, #1	; 0x1
 3f149dc:	e584305c 	str	r3, [r4, #92]
 3f149e0:	eb000e54 	bl	3f18338 <fat_register_device>

	}
	mmc_init_once = 1;
 3f149e4:	e3a03001 	mov	r3, #1	; 0x1
 3f149e8:	e59f1008 	ldr	r1, [pc, #8]	; 3f149f8 <SD_card_init+0x310>
	return 1;
 3f149ec:	e1a00003 	mov	r0, r3
 3f149f0:	e5813000 	str	r3, [r1]
}
 3f149f4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f149f8:	03f21184 	mvneqs	r1, #33	; 0x21
 3f149fc:	c0001520 	andgt	r1, r0, r0, lsr #10
 3f14a00:	c0001502 	andgt	r1, r0, r2, lsl #10
 3f14a04:	c0001500 	andgt	r1, r0, r0, lsl #10
 3f14a08:	c0001536 	andgt	r1, r0, r6, lsr r5
 3f14a0c:	c0001538 	andgt	r1, r0, r8, lsr r5
 3f14a10:	c0001530 	andgt	r1, r0, r0, lsr r5
 3f14a14:	c000151e 	andgt	r1, r0, r14, lsl r5
 3f14a18:	03f1fa64 	mvneqs	r15, #409600	; 0x64000
 3f14a1c:	03f72f68 	mvneqs	r2, #416	; 0x1a0
 3f14a20:	03f1fa84 	mvneqs	r15, #540672	; 0x84000
 3f14a24:	03f1fa74 	mvneqs	r15, #475136	; 0x74000
 3f14a28:	c0001504 	andgt	r1, r0, r4, lsl #10
 3f14a2c:	00000742 	andeq	r0, r0, r2, asr #14
 3f14a30:	00000343 	andeq	r0, r0, r3, asr #6
 3f14a34:	023ca98d 	eoreqs	r10, r12, #2310144	; 0x234000
 3f14a38:	03f21178 	mvneqs	r1, #30	; 0x1e
 3f14a3c:	431bde83 	tstmi	r11, #2096	; 0x830
 3f14a40:	03f1fa9c 	mvneqs	r15, #638976	; 0x9c000
 3f14a44:	02faf080 	rsceqs	r15, r10, #128	; 0x80
 3f14a48:	c000150c 	andgt	r1, r0, r12, lsl #10
 3f14a4c:	03f1fab4 	mvneqs	r15, #737280	; 0xb4000
 3f14a50:	03f21180 	mvneqs	r1, #32	; 0x20
 3f14a54:	03f1facc 	mvneqs	r15, #835584	; 0xcc000
 3f14a58:	03f72f08 	mvneqs	r2, #32	; 0x20
 3f14a5c:	03f2117c 	mvneqs	r1, #31	; 0x1f
 3f14a60:	03f1fae4 	mvneqs	r15, #933888	; 0xe4000
 3f14a64:	03f1fae8 	mvneqs	r15, #950272	; 0xe8000
 3f14a68:	03f1faf0 	mvneqs	r15, #983040	; 0xf0000
 3f14a6c:	00000123 	andeq	r0, r0, r3, lsr #2
 3f14a70:	00000456 	andeq	r0, r0, r6, asr r4
 3f14a74:	03f1462c 	mvneqs	r4, #46137344	; 0x2c00000

03f14a78 <SD_Read>:
 3f14a78:	e1a0c00d 	mov	r12, r13
 3f14a7c:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f14a80:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
unsigned char *Rx_buffer1;	//128[word]*16[blk]=8192[byte]
//[*]----------------------------------------------------------------------------------------------------[*]
void SD_Read(unsigned char *pucdata, unsigned long ulLBA, unsigned long ulSectors)
{

	int status, state, rd_cnt, total_word, kk;
	
	Rx_buffer1 = (unsigned char*)(pucdata);

	rd_cnt=0;
	kk = 0;

	rSDICON = rSDICON | (1<<1);		// FIFO reset
 3f14a84:	e59fc110 	ldr	r12, [pc, #110]	; 3f14b9c <SD_Read+0x124>
 3f14a88:	e59f6110 	ldr	r6, [pc, #110]	; 3f14ba0 <SD_Read+0x128>
 3f14a8c:	e1a04002 	mov	r4, r2

//	rSDIDCON=(2<<22)|(1<<19)|(1<<17)|(CardBusWidth<<16)|(1<<14)|(2<<12)|(ulSectors<<0);	//Salamander
	rSDIDCON = (1<<19) | (1<<17) | (CardBusWidth<<16) | (2<<12) | (ulSectors<<0);
 3f14a90:	e59f210c 	ldr	r2, [pc, #10c]	; 3f14ba4 <SD_Read+0x12c>
 3f14a94:	e1dc30b0 	ldrh	r3, [r12]
 3f14a98:	e5860000 	str	r0, [r6]
 3f14a9c:	e3833002 	orr	r3, r3, #2	; 0x2
 3f14aa0:	e1cc30b0 	strh	r3, [r12]
 3f14aa4:	e59f30fc 	ldr	r3, [pc, #fc]	; 3f14ba8 <SD_Read+0x130>
 3f14aa8:	e5930000 	ldr	r0, [r3]
 3f14aac:	e3843aa2 	orr	r3, r4, #663552	; 0xa2000
 3f14ab0:	e1833800 	orr	r3, r3, r0, lsl #16
 3f14ab4:	e5823000 	str	r3, [r2]
 3f14ab8:	e3a05000 	mov	r5, #0	; 0x0


	//Word Rx, Rx after cmd, blk, 4bit bus, Rx start, blk num, data start, data transmit mode

	rSDICARG=ulLBA*512;	// CMD17/18(addr)
 3f14abc:	e59f30e8 	ldr	r3, [pc, #e8]	; 3f14bac <SD_Read+0x134>
 3f14ac0:	e1a01481 	mov	r1, r1, lsl #9
 3f14ac4:	e5831000 	str	r1, [r3]
//	printf("rSDICARG :%x,ulLBA %x, ulLBA*512 %x\n", rSDICARG, ulLBA, ulLBA*512);
	//rSDICARG=0x0;	// CMD17/18(addr)

RERDCMD:
//	printf("RERCMD!!\n");
	if(ulSectors<2)	// SINGLE_READ
 3f14ac8:	e3540001 	cmp	r4, #1	; 0x1
	{
		//printf("SINGLE\n");
		rSDICCON = (0x1<<9)|(0x1<<8)|0x51;    // sht_resp, wait_resp, dat, start, CMD17
 3f14acc:	959f20dc 	ldrls	r2, [pc, #dc]	; 3f14bb0 <SD_Read+0x138>
		if(!Chk_CMDend(17, 1))	//-- Check end of CMD17
 3f14ad0:	93a00011 	movls	r0, #17	; 0x11
 3f14ad4:	959f30d8 	ldrls	r3, [pc, #d8]	; 3f14bb4 <SD_Read+0x13c>
			goto RERDCMD;
	}
	else	// MULTI_READ
	{
		//printf("MULTI\n");
		rSDICCON = (0x1<<9)|(0x1<<8)|0x52;    // sht_resp, wait_resp, dat, start, CMD18
 3f14ad8:	859f20d0 	ldrhi	r2, [pc, #d0]	; 3f14bb0 <SD_Read+0x138>
		if(!Chk_CMDend(18, 1))	//-- Check end of CMD18 
 3f14adc:	83a00012 	movhi	r0, #18	; 0x12
 3f14ae0:	859f30d0 	ldrhi	r3, [pc, #d0]	; 3f14bb8 <SD_Read+0x140>
 3f14ae4:	e3a01001 	mov	r1, #1	; 0x1
 3f14ae8:	e1c230b0 	strh	r3, [r2]
 3f14aec:	ebfffda1 	bl	3f14178 <Chk_CMDend>
 3f14af0:	e3500000 	cmp	r0, #0	; 0x0
 3f14af4:	0afffff3 	beq	3f14ac8 <SD_Read+0x50>
			goto RERDCMD;
	}
	//rSDICSTA=0xa00;			// Clear cmd_end(with rsp)

//	state = rSDICSTA;
//	rSDICSTA = state;	// Clear cmd_end(with rsp)	    
//	printf("\n Read CMD end\n");

	total_word = 128*ulSectors*4; 
 3f14af8:	e1a01484 	mov	r1, r4, lsl #9
	while(rd_cnt < total_word)
	{
//		for(kk=0; kk<1; kk++)	;	
		state = rSDIDSTA;
		if((state&0x20)==0x20) // Check timeout 
		{
			rSDIDSTA=(0x1<<0x5);  // Clear timeout flag
			//printf("\n[Time Out !!!] %d, state=%x  status=%x\n",rd_cnt,state,rSDIFSTA);
			//while(1);
			break;
 3f14afc:	ea000009 	b	3f14b28 <SD_Read+0xb0>
		}
		status = rSDIFSTA;
 3f14b00:	e59f30b4 	ldr	r3, [pc, #b4]	; 3f14bbc <SD_Read+0x144>
 3f14b04:	e1d330b0 	ldrh	r3, [r3]
		if( (status&0x1000) == 0x1000 )	// Is Rx data?
 3f14b08:	e3130a01 	tst	r3, #4096	; 0x1000
 3f14b0c:	0a000005 	beq	3f14b28 <SD_Read+0xb0>
		{
			*Rx_buffer1++=rSDIDAT;
 3f14b10:	e59f20a8 	ldr	r2, [pc, #a8]	; 3f14bc0 <SD_Read+0x148>
 3f14b14:	e5963000 	ldr	r3, [r6]
 3f14b18:	e5d22000 	ldrb	r2, [r2]
 3f14b1c:	e4c32001 	strb	r2, [r3], #1
			//printf("%02x ",Rx_buffer1[rd_cnt]);
			rd_cnt++;
 3f14b20:	e2855001 	add	r5, r5, #1	; 0x1
 3f14b24:	e5863000 	str	r3, [r6]
//			printf("%02x ", rd_cnt);
//			if(rd_cnt%8==0) printf("\n");			
		}
	}
 3f14b28:	e1550001 	cmp	r5, r1
 3f14b2c:	aa000005 	bge	3f14b48 <SD_Read+0xd0>
 3f14b30:	e59f208c 	ldr	r2, [pc, #8c]	; 3f14bc4 <SD_Read+0x14c>
 3f14b34:	e1d230b0 	ldrh	r3, [r2]
 3f14b38:	e3130020 	tst	r3, #32	; 0x20
 3f14b3c:	0affffef 	beq	3f14b00 <SD_Read+0x88>
 3f14b40:	e3a03020 	mov	r3, #32	; 0x20
 3f14b44:	e1c230b0 	strh	r3, [r2]

	//printf("\n After Read loop %d %d\n",rd_cnt, kk);		

	//-- Check end of DATA
	//printf("\n[Start Chk_DATend !!!]\n");
	if(!Chk_DATend()) 
 3f14b48:	ebfffdd2 	bl	3f14298 <Chk_DATend>
 3f14b4c:	e3500000 	cmp	r0, #0	; 0x0
 3f14b50:	1a000001 	bne	3f14b5c <SD_Read+0xe4>
		printf("dat error\n");
 3f14b54:	e59f006c 	ldr	r0, [pc, #6c]	; 3f14bc8 <SD_Read+0x150>
 3f14b58:	ebffdf39 	bl	3f0c844 <printf>

    rSDIDSTA = 0x10;	// Clear data Tx/Rx end

	//printf("\n[End Chk_DATend !!!]\n");

	if(ulSectors>1)
 3f14b5c:	e3540001 	cmp	r4, #1	; 0x1
 3f14b60:	e59f205c 	ldr	r2, [pc, #5c]	; 3f14bc4 <SD_Read+0x14c>
 3f14b64:	e3a03010 	mov	r3, #16	; 0x10
 3f14b68:	e1c230b0 	strh	r3, [r2]
 3f14b6c:	991ba870 	ldmlsdb	r11, {r4, r5, r6, r11, r13, r15}
	{
RERCMD12:
		//--Stop cmd(CMD12)
		rSDICARG=0x0;	    		//CMD12(stuff bit)
		rSDICCON=(0x1<<9)|(0x1<<8)|0x4c;	//sht_resp, wait_resp, start, CMD12

		//-- Check end of CMD12
		if(!Chk_CMDend(12, 1)) 
 3f14b70:	e3a0000c 	mov	r0, #12	; 0xc
 3f14b74:	e3a03000 	mov	r3, #0	; 0x0
 3f14b78:	e59f202c 	ldr	r2, [pc, #2c]	; 3f14bac <SD_Read+0x134>
 3f14b7c:	e3a01001 	mov	r1, #1	; 0x1
 3f14b80:	e4823004 	str	r3, [r2], #4
 3f14b84:	e2833fd3 	add	r3, r3, #844	; 0x34c
 3f14b88:	e1c230b0 	strh	r3, [r2]
 3f14b8c:	ebfffd79 	bl	3f14178 <Chk_CMDend>
 3f14b90:	e3500000 	cmp	r0, #0	; 0x0
 3f14b94:	0afffff5 	beq	3f14b70 <SD_Read+0xf8>
			goto RERCMD12;
		//rSDICSTA=0xa00;			// Clear cmd_end(with rsp)
	}
}
 3f14b98:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f14b9c:	c0001500 	andgt	r1, r0, r0, lsl #10
 3f14ba0:	03f72f9c 	mvneqs	r2, #624	; 0x270
 3f14ba4:	c0001520 	andgt	r1, r0, r0, lsr #10
 3f14ba8:	03f21180 	mvneqs	r1, #32	; 0x20
 3f14bac:	c0001504 	andgt	r1, r0, r4, lsl #10
 3f14bb0:	c0001508 	andgt	r1, r0, r8, lsl #10
 3f14bb4:	00000351 	andeq	r0, r0, r1, asr r3
 3f14bb8:	00000352 	andeq	r0, r0, r2, asr r3
 3f14bbc:	c000152a 	andgt	r1, r0, r10, lsr #10
 3f14bc0:	c000152c 	andgt	r1, r0, r12, lsr #10
 3f14bc4:	c0001528 	andgt	r1, r0, r8, lsr #10
 3f14bc8:	03f1faf8 	mvneqs	r15, #1015808	; 0xf8000

03f14bcc <SD_Write>:
 3f14bcc:	e1a0c00d 	mov	r12, r13
 3f14bd0:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f14bd4:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
void SD_Write(unsigned char * pucdata, unsigned long ulLBA, unsigned long ulSectors)
{
	int 			status, wt_cnt;
	unsigned int 	*Tx_buffer1;	//128[word]*16[blk]=8192[byte]

	Tx_buffer1 = (unsigned int *)(pucdata);
 3f14bd8:	e1a05000 	mov	r5, r0
 3f14bdc:	e1a07001 	mov	r7, r1

	wt_cnt=0;

	printf("### HERE WRITE\n");
 3f14be0:	e59f0140 	ldr	r0, [pc, #140]	; 3f14d28 <SD_Write+0x15c>
 3f14be4:	e1a04002 	mov	r4, r2
 3f14be8:	ebffdf15 	bl	3f0c844 <printf>

	//rSDIFSTA   = rSDIFSTA|(1<<16);	// FIFO reset
	rSDICON = rSDICON | (1<<1);		// FIFO reset
 3f14bec:	e59f2138 	ldr	r2, [pc, #138]	; 3f14d2c <SD_Write+0x160>
 3f14bf0:	e1d230b0 	ldrh	r3, [r2]
 3f14bf4:	e3833002 	orr	r3, r3, #2	; 0x2
 3f14bf8:	e1c230b0 	strh	r3, [r2]
 3f14bfc:	e3a06000 	mov	r6, #0	; 0x0

	rSDIDCON = (2<<22)|(1<<20)|(1<<17)|(CardBusWidth<<16)|(1<<14)|(3<<12)|(ulSectors<<0);	
 3f14c00:	e59f2128 	ldr	r2, [pc, #128]	; 3f14d30 <SD_Write+0x164>
 3f14c04:	e3843892 	orr	r3, r4, #9568256	; 0x920000
 3f14c08:	e5921000 	ldr	r1, [r2]
 3f14c0c:	e3833a07 	orr	r3, r3, #28672	; 0x7000
 3f14c10:	e59f211c 	ldr	r2, [pc, #11c]	; 3f14d34 <SD_Write+0x168>
 3f14c14:	e1833801 	orr	r3, r3, r1, lsl #16
		//Word Tx, Tx after rsp, blk, 4bit bus, Tx start, blk num

	rSDICARG = ulLBA*512;	    // CMD24/25(addr)
 3f14c18:	e402301c 	str	r3, [r2], -#28
 3f14c1c:	e1a03487 	mov	r3, r7, lsl #9
 3f14c20:	e5823000 	str	r3, [r2]

REWTCMD:
	if(ulSectors<2)	// SINGLE_WRITE
 3f14c24:	e3540001 	cmp	r4, #1	; 0x1
	{
		rSDICCON=(0x1<<9)|(0x1<<8)|0x58;	//sht_resp, wait_resp, dat, start, CMD24
		if(!Chk_CMDend(24, 1))	//-- Check end of CMD24
 3f14c28:	93a00018 	movls	r0, #24	; 0x18
 3f14c2c:	93a01001 	movls	r1, #1	; 0x1
 3f14c30:	959f2100 	ldrls	r2, [pc, #100]	; 3f14d38 <SD_Write+0x16c>
 3f14c34:	93a03fd6 	movls	r3, #856	; 0x358
			goto REWTCMD;
	}
	else	// MULTI_WRITE
	{
		rSDICCON = (0x1<<9)|(0x1<<8)|0x59;	//sht_resp, wait_resp, dat, start, CMD25
 3f14c38:	859f20f8 	ldrhi	r2, [pc, #f8]	; 3f14d38 <SD_Write+0x16c>
		if(!Chk_CMDend(25, 1))	//-- Check end of CMD25
 3f14c3c:	83a00019 	movhi	r0, #25	; 0x19
 3f14c40:	859f30f4 	ldrhi	r3, [pc, #f4]	; 3f14d3c <SD_Write+0x170>
 3f14c44:	83a01001 	movhi	r1, #1	; 0x1
 3f14c48:	e1c230b0 	strh	r3, [r2]
 3f14c4c:	ebfffd49 	bl	3f14178 <Chk_CMDend>
 3f14c50:	e3500000 	cmp	r0, #0	; 0x0
 3f14c54:	0afffff2 	beq	3f14c24 <SD_Write+0x58>
			goto REWTCMD;
	}

	rSDICSTA = 0xa00;	// Clear cmd_end(with rsp)

	while(wt_cnt<128*ulSectors)
 3f14c58:	e1a01384 	mov	r1, r4, lsl #7
 3f14c5c:	e1560001 	cmp	r6, r1
 3f14c60:	e59f20d8 	ldr	r2, [pc, #d8]	; 3f14d40 <SD_Write+0x174>
 3f14c64:	e3a03c0a 	mov	r3, #2560	; 0xa00
 3f14c68:	e1c230b0 	strh	r3, [r2]
 3f14c6c:	2a000008 	bcs	3f14c94 <SD_Write+0xc8>
	{
		status = rSDIFSTA;
 3f14c70:	e59f30cc 	ldr	r3, [pc, #cc]	; 3f14d44 <SD_Write+0x178>
 3f14c74:	e1d330b0 	ldrh	r3, [r3]
		if((status&0x2000)==0x2000)
 3f14c78:	e3130a02 	tst	r3, #8192	; 0x2000
		{
			rSDIDAT = *Tx_buffer1++;				
 3f14c7c:	14d52004 	ldrneb	r2, [r5], #4
 3f14c80:	159f30c0 	ldrne	r3, [pc, #c0]	; 3f14d48 <SD_Write+0x17c>
			wt_cnt++;
 3f14c84:	12866001 	addne	r6, r6, #1	; 0x1
 3f14c88:	15c32000 	strneb	r2, [r3]
//				printf("Block No.=%d, wt_cnt=%d\n",block,wt_cnt);
		}
	}
 3f14c8c:	e1560001 	cmp	r6, r1
 3f14c90:	3afffff6 	bcc	3f14c70 <SD_Write+0xa4>

	//-- Check end of DATA
	if(!Chk_DATend()) 
 3f14c94:	ebfffd7f 	bl	3f14298 <Chk_DATend>
 3f14c98:	e3500000 	cmp	r0, #0	; 0x0
 3f14c9c:	1a000001 	bne	3f14ca8 <SD_Write+0xdc>
		printf("dat error\n");
 3f14ca0:	e59f00a4 	ldr	r0, [pc, #a4]	; 3f14d4c <SD_Write+0x180>
 3f14ca4:	ebffdee6 	bl	3f0c844 <printf>

	rSDIDCON = rSDIDCON & ~(7<<12);		//Clear Data Transfer mode => no operation, Cleata Data Transfer start
 3f14ca8:	e59f2084 	ldr	r2, [pc, #84]	; 3f14d34 <SD_Write+0x168>
 3f14cac:	e5923000 	ldr	r3, [r2]
	rSDIDSTA = 0x10;	// Clear data Tx/Rx end

	if(ulSectors>1)
 3f14cb0:	e3540001 	cmp	r4, #1	; 0x1
 3f14cb4:	e3c33a07 	bic	r3, r3, #28672	; 0x7000
 3f14cb8:	e4823008 	str	r3, [r2], #8
 3f14cbc:	e3a03010 	mov	r3, #16	; 0x10
 3f14cc0:	e1c230b0 	strh	r3, [r2]
 3f14cc4:	991ba8f0 	ldmlsdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	{
		//--Stop cmd(CMD12)
REWCMD12:

		rSDIDCON = (1<<18)|(1<<17)|(0<<16)|(1<<14)|(1<<12)|(ulLBA<<0); 	
 3f14cc8:	e3873a65 	orr	r3, r7, #413696	; 0x65000

		rSDICARG = 0x0;	    		  //CMD12(stuff bit)
		rSDICCON = (0x1<<9)|(0x1<<8)|0x4c;    //sht_resp, wait_resp, start, CMD12

		//-- Check end of CMD12
		if(!Chk_CMDend(12, 1)) 
 3f14ccc:	e3a0000c 	mov	r0, #12	; 0xc
 3f14cd0:	e59f205c 	ldr	r2, [pc, #5c]	; 3f14d34 <SD_Write+0x168>
 3f14cd4:	e3a01001 	mov	r1, #1	; 0x1
 3f14cd8:	e402301c 	str	r3, [r2], -#28
 3f14cdc:	e3a03000 	mov	r3, #0	; 0x0
 3f14ce0:	e4823004 	str	r3, [r2], #4
 3f14ce4:	e2833fd3 	add	r3, r3, #844	; 0x34c
 3f14ce8:	e1c230b0 	strh	r3, [r2]
 3f14cec:	ebfffd21 	bl	3f14178 <Chk_CMDend>
 3f14cf0:	e3500000 	cmp	r0, #0	; 0x0
 3f14cf4:	0afffff3 	beq	3f14cc8 <SD_Write+0xfc>
			goto REWCMD12;
		rSDICSTA = 0xa00;	// Clear cmd_end(with rsp)
 3f14cf8:	e59f2040 	ldr	r2, [pc, #40]	; 3f14d40 <SD_Write+0x174>
 3f14cfc:	e3a03c0a 	mov	r3, #2560	; 0xa00
 3f14d00:	e1c230b0 	strh	r3, [r2]

		//-- Check end of DATA(with busy state)
		if(!Chk_BUSYend()) 
 3f14d04:	ebfffd7b 	bl	3f142f8 <Chk_BUSYend>
 3f14d08:	e3500000 	cmp	r0, #0	; 0x0
 3f14d0c:	1a000001 	bne	3f14d18 <SD_Write+0x14c>
			printf("Write error!\n");
 3f14d10:	e59f0038 	ldr	r0, [pc, #38]	; 3f14d50 <SD_Write+0x184>
 3f14d14:	ebffdeca 	bl	3f0c844 <printf>
		rSDIDSTA = 0x08;	//! Should be cleared by writing '1'.
 3f14d18:	e59f2034 	ldr	r2, [pc, #34]	; 3f14d54 <SD_Write+0x188>
 3f14d1c:	e3a03008 	mov	r3, #8	; 0x8
 3f14d20:	e1c230b0 	strh	r3, [r2]
	}
}
 3f14d24:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f14d28:	03f1fb04 	mvneqs	r15, #4096	; 0x1000
 3f14d2c:	c0001500 	andgt	r1, r0, r0, lsl #10
 3f14d30:	03f21180 	mvneqs	r1, #32	; 0x20
 3f14d34:	c0001520 	andgt	r1, r0, r0, lsr #10
 3f14d38:	c0001508 	andgt	r1, r0, r8, lsl #10
 3f14d3c:	00000359 	andeq	r0, r0, r9, asr r3
 3f14d40:	c000150a 	andgt	r1, r0, r10, lsl #10
 3f14d44:	c000152a 	andgt	r1, r0, r10, lsr #10
 3f14d48:	c000152c 	andgt	r1, r0, r12, lsr #10
 3f14d4c:	03f1faf8 	mvneqs	r15, #1015808	; 0xf8000
 3f14d50:	03f1fb14 	mvneqs	r15, #20480	; 0x5000
 3f14d54:	c0001528 	andgt	r1, r0, r8, lsr #10

03f14d58 <PMR_Initialize>:
 3f14d58:	e1a0c00d 	mov	r12, r13
 3f14d5c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f14d60:	e59f200c 	ldr	r2, [pc, #c]	; 3f14d74 <PMR_Initialize+0x1c>
MMSP20_MLC 			*MLC_REG;
//[*]----------------------------------------------------------------------------------------------------[*]
void PMR_Initialize()
{
	pPMR_REG = MMSP20_GetBase_CLOCK_POWER();
 3f14d64:	e59f300c 	ldr	r3, [pc, #c]	; 3f14d78 <PMR_Initialize+0x20>
 3f14d68:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f14d6c:	e5832000 	str	r2, [r3]
}
 3f14d70:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f14d74:	c0000900 	andgt	r0, r0, r0, lsl #18
 3f14d78:	03f72fa0 	mvneqs	r2, #640	; 0x280

03f14d7c <PMR_SetDispClk>:
 3f14d7c:	e1a0c00d 	mov	r12, r13
 3f14d80:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f14d84:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
void PMR_SetDispClk(tDispClkInfo *pDISPCLKINFO)
{
 3f14d88:	e1a04000 	mov	r4, r0
	PMR_Initialize();
 3f14d8c:	ebfffff1 	bl	3f14d58 <PMR_Initialize>
	
	pPMR_REG->DISPCSETREG = (pDISPCLKINFO->DISPCLK_SOURCE << 14) | (pDISPCLKINFO->DISPCLK_DIVIDER << 8) | (pDISPCLKINFO->DISPCLK_POL << 7);
 3f14d90:	e59f0020 	ldr	r0, [pc, #20]	; 3f14db8 <PMR_SetDispClk+0x3c>
 3f14d94:	e1d430b2 	ldrh	r3, [r4, #2]
 3f14d98:	e1d420b0 	ldrh	r2, [r4]
 3f14d9c:	e1d410b4 	ldrh	r1, [r4, #4]
 3f14da0:	e1a03403 	mov	r3, r3, lsl #8
 3f14da4:	e1833702 	orr	r3, r3, r2, lsl #14
 3f14da8:	e5902000 	ldr	r2, [r0]
 3f14dac:	e1833381 	orr	r3, r3, r1, lsl #7
 3f14db0:	e1c232b4 	strh	r3, [r2, #36]
 3f14db4:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f14db8:	03f72fa0 	mvneqs	r2, #640	; 0x280

03f14dbc <DPC_SetFrameSize>:
 3f14dbc:	e1a0c00d 	mov	r12, r13
 3f14dc0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f14dc4:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void DPC_SetFrameSize(U16 Width, U16 Height)
{
 3f14dc8:	e1a00800 	mov	r0, r0, lsl #16
 3f14dcc:	e1a00820 	mov	r0, r0, lsr #16
	DPC->DPC_X_MAX = Width - 1;
 3f14dd0:	e2400001 	sub	r0, r0, #1	; 0x1
 3f14dd4:	e59f3018 	ldr	r3, [pc, #18]	; 3f14df4 <DPC_SetFrameSize+0x38>
 3f14dd8:	e1a01801 	mov	r1, r1, lsl #16
 3f14ddc:	e5933000 	ldr	r3, [r3]
 3f14de0:	e1a01821 	mov	r1, r1, lsr #16
 3f14de4:	e1c301b6 	strh	r0, [r3, #22]
	DPC->DPC_Y_MAX = Height - 1;
 3f14de8:	e2411001 	sub	r1, r1, #1	; 0x1
 3f14dec:	e1c311b8 	strh	r1, [r3, #24]
 3f14df0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f14df4:	03f72fa4 	mvneqs	r2, #656	; 0x290

03f14df8 <DPC_SetHSyncParm>:
 3f14df8:	e1a0c00d 	mov	r12, r13
 3f14dfc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f14e00:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void DPC_SetHSyncParm(U16 HorSyncWidth, U16 HorFrontPorch, U16 HorBackPorch, CBOOL HorPolarity)
{
	// Horizontal Sync WIdth
	DPC->DPC_HS_WIDTH 	&= ~HSWID;
 3f14e04:	e59fc08c 	ldr	r12, [pc, #8c]	; 3f14e98 <DPC_SetHSyncParm+0xa0>
 3f14e08:	e1a00800 	mov	r0, r0, lsl #16
 3f14e0c:	e59ce000 	ldr	r14, [r12]
 3f14e10:	e1a00820 	mov	r0, r0, lsr #16
 3f14e14:	e1dec1ba 	ldrh	r12, [r14, #26]
	DPC->DPC_HS_WIDTH 	|= FInsrt(HorSyncWidth - 1,BF_HSWID);	// T2
 3f14e18:	e2400001 	sub	r0, r0, #1	; 0x1
 3f14e1c:	e20cccff 	and	r12, r12, #65280	; 0xff00
 3f14e20:	e1cec1ba 	strh	r12, [r14, #26]
 3f14e24:	e1a01801 	mov	r1, r1, lsl #16
 3f14e28:	e1dec1ba 	ldrh	r12, [r14, #26]
	DPC->DPC_HS_END 	= (HorFrontPorch/2) - 1;	// T7
 3f14e2c:	e1a018a1 	mov	r1, r1, lsr #17
 3f14e30:	e18cc000 	orr	r12, r12, r0
 3f14e34:	e1cec1ba 	strh	r12, [r14, #26]
 3f14e38:	e2411001 	sub	r1, r1, #1	; 0x1
 3f14e3c:	e1ce11be 	strh	r1, [r14, #30]
	DPC->DPC_HS_STR 	= (HorFrontPorch/2) + (HorFrontPorch%1) - 1; //T8
 3f14e40:	e1ce11bc 	strh	r1, [r14, #28]
 3f14e44:	e1a02802 	mov	r2, r2, lsl #16
	// Horizontal Back Porch
	DPC->DPC_DE &= ~DESTR;
 3f14e48:	e1de12b6 	ldrh	r1, [r14, #38]
	DPC->DPC_DE |= FInsrt((HorBackPorch - 1),BF_DESTR);
 3f14e4c:	e1a02622 	mov	r2, r2, lsr #12
 3f14e50:	e3c11eff 	bic	r1, r1, #4080	; 0xff0
 3f14e54:	e1a01801 	mov	r1, r1, lsl #16
 3f14e58:	e1a01821 	mov	r1, r1, lsr #16
 3f14e5c:	e1ce12b6 	strh	r1, [r14, #38]
 3f14e60:	e2422010 	sub	r2, r2, #16	; 0x10
 3f14e64:	e1de12b6 	ldrh	r1, [r14, #38]
	if(HorPolarity)	DPC->DPC_FPIPOL1 |= HSPOL;
 3f14e68:	e3530000 	cmp	r3, #0	; 0x0
 3f14e6c:	e1811002 	orr	r1, r1, r2
 3f14e70:	e1ce12b6 	strh	r1, [r14, #38]
 3f14e74:	11de30b4 	ldrneh	r3, [r14, #4]
 3f14e78:	13833002 	orrne	r3, r3, #2	; 0x2
 3f14e7c:	11ce30b4 	strneh	r3, [r14, #4]
	else			DPC->DPC_FPIPOL1 &= ~HSPOL; 
 3f14e80:	01de30b4 	ldreqh	r3, [r14, #4]
 3f14e84:	03c33002 	biceq	r3, r3, #2	; 0x2
 3f14e88:	01a03803 	moveq	r3, r3, lsl #16
 3f14e8c:	01a03823 	moveq	r3, r3, lsr #16
 3f14e90:	01ce30b4 	streqh	r3, [r14, #4]
 3f14e94:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f14e98:	03f72fa4 	mvneqs	r2, #656	; 0x290

03f14e9c <DPC_SetVSyncParm>:
 3f14e9c:	e1a0c00d 	mov	r12, r13
 3f14ea0:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f14ea4:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void DPC_SetVSyncParm(U16 VerSyncWidth, U16 VerFrontPorch, U16 VerBackPorch, CBOOL VerPolarity)
{
	DPC->DPC_V_SYNC &= ~VSWID;
 3f14ea8:	e59fc098 	ldr	r12, [pc, #98]	; 3f14f48 <DPC_SetVSyncParm+0xac>
 3f14eac:	e59c4000 	ldr	r4, [r12]
 3f14eb0:	e1d4c2b0 	ldrh	r12, [r4, #32]
 3f14eb4:	e1a00800 	mov	r0, r0, lsl #16
 3f14eb8:	e3ccc00f 	bic	r12, r12, #15	; 0xf
 3f14ebc:	e1a0c80c 	mov	r12, r12, lsl #16
 3f14ec0:	e1a0c82c 	mov	r12, r12, lsr #16
 3f14ec4:	e1c4c2b0 	strh	r12, [r4, #32]
 3f14ec8:	e1a00820 	mov	r0, r0, lsr #16
	DPC->DPC_V_SYNC |= FInsrt((VerSyncWidth-1),BF_VSWID);
 3f14ecc:	e1d4c2b0 	ldrh	r12, [r4, #32]
 3f14ed0:	e240e001 	sub	r14, r0, #1	; 0x1
 3f14ed4:	e18cc00e 	orr	r12, r12, r14
 3f14ed8:	e1c4c2b0 	strh	r12, [r4, #32]
	DPC->DPC_V_SYNC &= ~VSSTR;
 3f14edc:	e1d4c2b0 	ldrh	r12, [r4, #32]
 3f14ee0:	e20cc0ff 	and	r12, r12, #255	; 0xff
 3f14ee4:	e1c4c2b0 	strh	r12, [r4, #32]
 3f14ee8:	e1a01801 	mov	r1, r1, lsl #16
	DPC->DPC_V_SYNC |= FInsrt(VerFrontPorch,BF_VSSTR);
 3f14eec:	e1d4c2b0 	ldrh	r12, [r4, #32]
 3f14ef0:	e1a01821 	mov	r1, r1, lsr #16
 3f14ef4:	e18cc401 	orr	r12, r12, r1, lsl #8
 3f14ef8:	e1c4c2b0 	strh	r12, [r4, #32]
 3f14efc:	e1a02802 	mov	r2, r2, lsl #16
	DPC->DPC_V_END &= ~VSEND;
 3f14f00:	e1d4c2b2 	ldrh	r12, [r4, #34]
	DPC->DPC_V_END |= FInsrt(VerBackPorch+VerSyncWidth+VerFrontPorch-1,BF_VSEND);
 3f14f04:	e0800822 	add	r0, r0, r2, lsr #16
 3f14f08:	e20cccfe 	and	r12, r12, #65024	; 0xfe00
 3f14f0c:	e1c4c2b2 	strh	r12, [r4, #34]
 3f14f10:	e0811000 	add	r1, r1, r0
 3f14f14:	e1d422b2 	ldrh	r2, [r4, #34]
 3f14f18:	e2411001 	sub	r1, r1, #1	; 0x1
 3f14f1c:	e1822001 	orr	r2, r2, r1
 3f14f20:	e1c422b2 	strh	r2, [r4, #34]
	DPC->DPC_FPIPOL1 &= ~VSPOL;
 3f14f24:	e1d420b4 	ldrh	r2, [r4, #4]
 3f14f28:	e3c22001 	bic	r2, r2, #1	; 0x1
 3f14f2c:	e1a02802 	mov	r2, r2, lsl #16
 3f14f30:	e1a02822 	mov	r2, r2, lsr #16
 3f14f34:	e1c420b4 	strh	r2, [r4, #4]
	DPC->DPC_FPIPOL1 |= VerPolarity;	
 3f14f38:	e1d420b4 	ldrh	r2, [r4, #4]
 3f14f3c:	e1822003 	orr	r2, r2, r3
 3f14f40:	e1c420b4 	strh	r2, [r4, #4]
 3f14f44:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f14f48:	03f72fa4 	mvneqs	r2, #656	; 0x290

03f14f4c <DPC_SetDEParm>:
 3f14f4c:	e1a0c00d 	mov	r12, r13
 3f14f50:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f14f54:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void DPC_SetDEParm(U32 DEMode, U16 DEPulseWidth, U16 DEShift, CBOOL DEPolarity)
{
 3f14f58:	e1a0e003 	mov	r14, r3
 3f14f5c:	e1a01801 	mov	r1, r1, lsl #16
 3f14f60:	e1a0c821 	mov	r12, r1, lsr #16
 3f14f64:	e1a02802 	mov	r2, r2, lsl #16
 3f14f68:	e1a01822 	mov	r1, r2, lsr #16
	if(DEMode == DPC_DE_DE)
 3f14f6c:	e3500000 	cmp	r0, #0	; 0x0
 3f14f70:	1a000015 	bne	3f14fcc <DPC_SetDEParm+0x80>
	{
		DPC->DPC_DE &= ~DEPADCFG;
 3f14f74:	e59f3140 	ldr	r3, [pc, #140]	; 3f150bc <DPC_SetDEParm+0x170>
 3f14f78:	e5932000 	ldr	r2, [r3]
 3f14f7c:	e1d232b6 	ldrh	r3, [r2, #38]
 3f14f80:	e1a03903 	mov	r3, r3, lsl #18
 3f14f84:	e1a03923 	mov	r3, r3, lsr #18
 3f14f88:	e1c232b6 	strh	r3, [r2, #38]
		DPC->DPC_DE |= DEPIN_DE;
 3f14f8c:	e1d232b6 	ldrh	r3, [r2, #38]
 3f14f90:	e1c232b6 	strh	r3, [r2, #38]
		DPC->DPC_DE &= ~DEMOD;
 3f14f94:	e1d232b6 	ldrh	r3, [r2, #38]
 3f14f98:	e3c33a01 	bic	r3, r3, #4096	; 0x1000
 3f14f9c:	e1a03803 	mov	r3, r3, lsl #16
 3f14fa0:	e1a03823 	mov	r3, r3, lsr #16
 3f14fa4:	e1c232b6 	strh	r3, [r2, #38]
		DPC->DPC_DE &= ~DEWID;
 3f14fa8:	e1d232b6 	ldrh	r3, [r2, #38]
 3f14fac:	e3c3300f 	bic	r3, r3, #15	; 0xf
 3f14fb0:	e1a03803 	mov	r3, r3, lsl #16
 3f14fb4:	e1a03823 	mov	r3, r3, lsr #16
 3f14fb8:	e1c232b6 	strh	r3, [r2, #38]
		DPC->DPC_DE |= FInsrt(DEShift, BF_DEWID);
 3f14fbc:	e1d232b6 	ldrh	r3, [r2, #38]
 3f14fc0:	e1813003 	orr	r3, r1, r3
 3f14fc4:	e1c232b6 	strh	r3, [r2, #38]
	}
 3f14fc8:	ea00002b 	b	3f1507c <DPC_SetDEParm+0x130>
	else if(DEMode == DPC_DE_STH)
 3f14fcc:	e3500001 	cmp	r0, #1	; 0x1
 3f14fd0:	1a000013 	bne	3f15024 <DPC_SetDEParm+0xd8>
	{
		DPC->DPC_DE &= ~DEPADCFG;
 3f14fd4:	e59f30e0 	ldr	r3, [pc, #e0]	; 3f150bc <DPC_SetDEParm+0x170>
 3f14fd8:	e5932000 	ldr	r2, [r3]
 3f14fdc:	e1d232b6 	ldrh	r3, [r2, #38]
 3f14fe0:	e1a03903 	mov	r3, r3, lsl #18
 3f14fe4:	e1a03923 	mov	r3, r3, lsr #18
 3f14fe8:	e1c232b6 	strh	r3, [r2, #38]
		DPC->DPC_DE |= DEPIN_STH;
 3f14fec:	e1d232b6 	ldrh	r3, [r2, #38]
 3f14ff0:	e3833901 	orr	r3, r3, #16384	; 0x4000
 3f14ff4:	e1c232b6 	strh	r3, [r2, #38]
		DPC->DPC_DE &= ~DEMOD;
 3f14ff8:	e1d232b6 	ldrh	r3, [r2, #38]
 3f14ffc:	e3c33a01 	bic	r3, r3, #4096	; 0x1000
 3f15000:	e1a03803 	mov	r3, r3, lsl #16
 3f15004:	e1a03823 	mov	r3, r3, lsr #16
 3f15008:	e1c232b6 	strh	r3, [r2, #38]
		DPC->DPC_DE &= ~DEWID;
 3f1500c:	e1d232b6 	ldrh	r3, [r2, #38]
 3f15010:	e3c3300f 	bic	r3, r3, #15	; 0xf
 3f15014:	e1a03803 	mov	r3, r3, lsl #16
 3f15018:	e1a03823 	mov	r3, r3, lsr #16
 3f1501c:	e1c232b6 	strh	r3, [r2, #38]
	}
 3f15020:	ea000015 	b	3f1507c <DPC_SetDEParm+0x130>
	else if(DEMode == DPC_DE_PULSE)
 3f15024:	e3500002 	cmp	r0, #2	; 0x2
 3f15028:	1a000013 	bne	3f1507c <DPC_SetDEParm+0x130>
	{
		DPC->DPC_DE &= ~DEPADCFG;
 3f1502c:	e59f3088 	ldr	r3, [pc, #88]	; 3f150bc <DPC_SetDEParm+0x170>
 3f15030:	e5931000 	ldr	r1, [r3]
 3f15034:	e1d132b6 	ldrh	r3, [r1, #38]
 3f15038:	e1a03903 	mov	r3, r3, lsl #18
 3f1503c:	e1a03923 	mov	r3, r3, lsr #18
 3f15040:	e1c132b6 	strh	r3, [r1, #38]
		DPC->DPC_DE |= DEPIN_DE;
 3f15044:	e1d132b6 	ldrh	r3, [r1, #38]
 3f15048:	e1c132b6 	strh	r3, [r1, #38]
		DPC->DPC_DE |= DEMOD;
 3f1504c:	e1d132b6 	ldrh	r3, [r1, #38]
 3f15050:	e3833a01 	orr	r3, r3, #4096	; 0x1000
 3f15054:	e1c132b6 	strh	r3, [r1, #38]
		DPC->DPC_DE &= ~DEWID;
 3f15058:	e1d132b6 	ldrh	r3, [r1, #38]
 3f1505c:	e3c3300f 	bic	r3, r3, #15	; 0xf
 3f15060:	e1a03803 	mov	r3, r3, lsl #16
 3f15064:	e1a03823 	mov	r3, r3, lsr #16
 3f15068:	e1c132b6 	strh	r3, [r1, #38]
		DPC->DPC_DE |= FInsrt(DEPulseWidth-1, BF_DEWID);		
 3f1506c:	e1d132b6 	ldrh	r3, [r1, #38]
 3f15070:	e24c2001 	sub	r2, r12, #1	; 0x1
 3f15074:	e1833002 	orr	r3, r3, r2
 3f15078:	e1c132b6 	strh	r3, [r1, #38]
	}
	if(DEPolarity)	DPC->DPC_FPIPOL1 |= DEPOL;
 3f1507c:	e35e0000 	cmp	r14, #0	; 0x0
 3f15080:	0a000005 	beq	3f1509c <DPC_SetDEParm+0x150>
 3f15084:	e59f3030 	ldr	r3, [pc, #30]	; 3f150bc <DPC_SetDEParm+0x170>
 3f15088:	e5932000 	ldr	r2, [r3]
 3f1508c:	e1d230b4 	ldrh	r3, [r2, #4]
 3f15090:	e3833004 	orr	r3, r3, #4	; 0x4
 3f15094:	e1c230b4 	strh	r3, [r2, #4]
 3f15098:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else			DPC->DPC_FPIPOL1 &= ~DEPOL;
 3f1509c:	e59f3018 	ldr	r3, [pc, #18]	; 3f150bc <DPC_SetDEParm+0x170>
 3f150a0:	e5932000 	ldr	r2, [r3]
 3f150a4:	e1d230b4 	ldrh	r3, [r2, #4]
 3f150a8:	e3c33004 	bic	r3, r3, #4	; 0x4
 3f150ac:	e1a03803 	mov	r3, r3, lsl #16
 3f150b0:	e1a03823 	mov	r3, r3, lsr #16
 3f150b4:	e1c230b4 	strh	r3, [r2, #4]
 3f150b8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f150bc:	03f72fa4 	mvneqs	r2, #656	; 0x290

03f150c0 <DPC_UTIL_HVSYNC>:
 3f150c0:	e1a0c00d 	mov	r12, r13
 3f150c4:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f150c8:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void DPC_UTIL_HVSYNC(U8 DataType, U16 Width, U16 Height, U16 HorSyncWidth, U16 HorFrontPorch, U16 HorBackPorch, CBOOL HorPolarity, U16 VerSyncWidth, U16 VerFrontPorch, U16 VerBackPorch, CBOOL VerPolarity)
{
 3f150cc:	e1a01801 	mov	r1, r1, lsl #16
	DPC_SetFrameSize(Width, Height);
 3f150d0:	e1a00821 	mov	r0, r1, lsr #16
 3f150d4:	e1dba0b4 	ldrh	r10, [r11, #4]
 3f150d8:	e1a02802 	mov	r2, r2, lsl #16
 3f150dc:	e1db60b8 	ldrh	r6, [r11, #8]
 3f150e0:	e1a01822 	mov	r1, r2, lsr #16
 3f150e4:	e1db91b0 	ldrh	r9, [r11, #16]
 3f150e8:	e1a04803 	mov	r4, r3, lsl #16
 3f150ec:	e1db71b4 	ldrh	r7, [r11, #20]
 3f150f0:	e1a04824 	mov	r4, r4, lsr #16
 3f150f4:	e1db51b8 	ldrh	r5, [r11, #24]
 3f150f8:	ebffff2f 	bl	3f14dbc <DPC_SetFrameSize>
	DPC_SetHSyncParm(HorSyncWidth, HorFrontPorch, HorBackPorch, HorPolarity);
 3f150fc:	e1a00004 	mov	r0, r4
 3f15100:	e59b300c 	ldr	r3, [r11, #12]
 3f15104:	e1a0100a 	mov	r1, r10
 3f15108:	e1a02006 	mov	r2, r6
 3f1510c:	ebffff39 	bl	3f14df8 <DPC_SetHSyncParm>
	DPC_SetVSyncParm(VerSyncWidth, VerFrontPorch, VerBackPorch, VerPolarity);
 3f15110:	e1a00009 	mov	r0, r9
 3f15114:	e1a01007 	mov	r1, r7
 3f15118:	e59b301c 	ldr	r3, [r11, #28]
 3f1511c:	e1a02005 	mov	r2, r5
 3f15120:	ebffff5d 	bl	3f14e9c <DPC_SetVSyncParm>
	DPC_SetDEParm((U8)DPC_DE_DE, 0, 0, CFALSE );  
 3f15124:	e3a00000 	mov	r0, #0	; 0x0
 3f15128:	e1a01000 	mov	r1, r0
 3f1512c:	e1a02000 	mov	r2, r0
 3f15130:	e1a03000 	mov	r3, r0
 3f15134:	ebffff84 	bl	3f14f4c <DPC_SetDEParm>
 3f15138:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f1513c <DPC_UTIL_HVSYNC_GPX320240>:
 3f1513c:	e1a0c00d 	mov	r12, r13
 3f15140:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f15144:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void DPC_UTIL_HVSYNC_GPX320240
(
	U8  	DataType,
	U16 	Width,
	U16 	Height,
	U16 	HorSyncWidth,
	U16 	HorFrontPorch,
	U16 	HorBackPorch,
	CBOOL   HorPolarity,
	U16 	VerSyncWidth,
	U16 	VerFrontPorch,
	U16 	VerBackPorch,
	CBOOL   VerPolarity,
	CBOOL	ClkPolarity,
	CBOOL	DePolarity,
	CBOOL	DataPolarity
)
{
 3f15148:	e1a01801 	mov	r1, r1, lsl #16

	DPC_SetFrameSize ( Width, Height );
 3f1514c:	e1a00821 	mov	r0, r1, lsr #16
 3f15150:	e1dba0b4 	ldrh	r10, [r11, #4]
 3f15154:	e1a02802 	mov	r2, r2, lsl #16
 3f15158:	e1db60b8 	ldrh	r6, [r11, #8]
 3f1515c:	e1a01822 	mov	r1, r2, lsr #16
 3f15160:	e1db91b0 	ldrh	r9, [r11, #16]
 3f15164:	e1a04803 	mov	r4, r3, lsl #16
 3f15168:	e1db71b4 	ldrh	r7, [r11, #20]
 3f1516c:	e1a04824 	mov	r4, r4, lsr #16
 3f15170:	e1db51b8 	ldrh	r5, [r11, #24]
 3f15174:	ebffff10 	bl	3f14dbc <DPC_SetFrameSize>
	DPC_SetHSyncParm ( HorSyncWidth, HorFrontPorch, HorBackPorch, HorPolarity);
 3f15178:	e1a00004 	mov	r0, r4
 3f1517c:	e59b300c 	ldr	r3, [r11, #12]
 3f15180:	e1a0100a 	mov	r1, r10
 3f15184:	e1a02006 	mov	r2, r6
 3f15188:	ebffff1a 	bl	3f14df8 <DPC_SetHSyncParm>
	DPC_SetVSyncParm ( VerSyncWidth, VerFrontPorch, VerBackPorch, VerPolarity);
 3f1518c:	e1a00009 	mov	r0, r9
 3f15190:	e1a01007 	mov	r1, r7
 3f15194:	e59b301c 	ldr	r3, [r11, #28]
 3f15198:	e1a02005 	mov	r2, r5
 3f1519c:	ebffff3e 	bl	3f14e9c <DPC_SetVSyncParm>
	DPC_SetDEParm ( (U8)DPC_DE_DE, 0, 0, DePolarity );  
 3f151a0:	e3a00000 	mov	r0, #0	; 0x0
 3f151a4:	e1a01000 	mov	r1, r0
 3f151a8:	e59b3024 	ldr	r3, [r11, #36]
 3f151ac:	e1a02000 	mov	r2, r0
 3f151b0:	ebffff65 	bl	3f14f4c <DPC_SetDEParm>
	
	if(ClkPolarity)
 3f151b4:	e59b0020 	ldr	r0, [r11, #32]
 3f151b8:	e3500000 	cmp	r0, #0	; 0x0
		DPC->DPC_FPIPOL1 |= CHPOL;
 3f151bc:	159f306c 	ldrne	r3, [pc, #6c]	; 3f15230 <DPC_UTIL_HVSYNC_GPX320240+0xf4>
 3f151c0:	15932000 	ldrne	r2, [r3]
 3f151c4:	11d230b4 	ldrneh	r3, [r2, #4]
 3f151c8:	13833010 	orrne	r3, r3, #16	; 0x10
 3f151cc:	1a000005 	bne	3f151e8 <DPC_UTIL_HVSYNC_GPX320240+0xac>
	else
		DPC->DPC_FPIPOL1 &= ~CHPOL;
 3f151d0:	e59f3058 	ldr	r3, [pc, #58]	; 3f15230 <DPC_UTIL_HVSYNC_GPX320240+0xf4>
 3f151d4:	e5932000 	ldr	r2, [r3]
 3f151d8:	e1d230b4 	ldrh	r3, [r2, #4]
 3f151dc:	e3c33010 	bic	r3, r3, #16	; 0x10
 3f151e0:	e1a03803 	mov	r3, r3, lsl #16
 3f151e4:	e1a03823 	mov	r3, r3, lsr #16
 3f151e8:	e1c230b4 	strh	r3, [r2, #4]

	if(DataPolarity){
 3f151ec:	e59b3028 	ldr	r3, [r11, #40]
 3f151f0:	e3530000 	cmp	r3, #0	; 0x0
 3f151f4:	0a000006 	beq	3f15214 <DPC_UTIL_HVSYNC_GPX320240+0xd8>
		DPC->DPC_FPIPOL2 = DATA_FPIPOL2;
 3f151f8:	e59f3030 	ldr	r3, [pc, #30]	; 3f15230 <DPC_UTIL_HVSYNC_GPX320240+0xf4>
 3f151fc:	e5932000 	ldr	r2, [r3]
 3f15200:	e3e03000 	mvn	r3, #0	; 0x0
 3f15204:	e1c230b6 	strh	r3, [r2, #6]
		DPC->DPC_FPIPOL3 = DATA_FPIPOL3; 
 3f15208:	e2833c01 	add	r3, r3, #256	; 0x100
 3f1520c:	e1c230b8 	strh	r3, [r2, #8]
	}else{
 3f15210:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
		DPC->DPC_FPIPOL2 = ~DATA_FPIPOL2;
 3f15214:	e59f3014 	ldr	r3, [pc, #14]	; 3f15230 <DPC_UTIL_HVSYNC_GPX320240+0xf4>
 3f15218:	e59b0028 	ldr	r0, [r11, #40]
 3f1521c:	e5932000 	ldr	r2, [r3]
 3f15220:	e1c200b6 	strh	r0, [r2, #6]
		DPC->DPC_FPIPOL3 = ~DATA_FPIPOL3; 
 3f15224:	e3a03cff 	mov	r3, #65280	; 0xff00
 3f15228:	e1c230b8 	strh	r3, [r2, #8]
	}
 3f1522c:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f15230:	03f72fa4 	mvneqs	r2, #656	; 0x290

03f15234 <DPC_UTIL_DATA_INV>:
 3f15234:	e1a0c00d 	mov	r12, r13
 3f15238:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f1523c:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void DPC_UTIL_DATA_INV(CBOOL DataPolarity)
{
	if(DataPolarity){
 3f15240:	e3500000 	cmp	r0, #0	; 0x0
 3f15244:	0a000006 	beq	3f15264 <DPC_UTIL_DATA_INV+0x30>
		DPC->DPC_FPIPOL2 = DATA_FPIPOL2;
 3f15248:	e59f302c 	ldr	r3, [pc, #2c]	; 3f1527c <DPC_UTIL_DATA_INV+0x48>
 3f1524c:	e5932000 	ldr	r2, [r3]
 3f15250:	e3e03000 	mvn	r3, #0	; 0x0
 3f15254:	e1c230b6 	strh	r3, [r2, #6]
		DPC->DPC_FPIPOL3 = DATA_FPIPOL3; 
 3f15258:	e2833c01 	add	r3, r3, #256	; 0x100
 3f1525c:	e1c230b8 	strh	r3, [r2, #8]
	}else{
 3f15260:	e91ba800 	ldmdb	r11, {r11, r13, r15}
		DPC->DPC_FPIPOL2 = ~DATA_FPIPOL2;
 3f15264:	e59f3010 	ldr	r3, [pc, #10]	; 3f1527c <DPC_UTIL_DATA_INV+0x48>
 3f15268:	e5932000 	ldr	r2, [r3]
 3f1526c:	e1c200b6 	strh	r0, [r2, #6]
		DPC->DPC_FPIPOL3 = ~DATA_FPIPOL3; 
 3f15270:	e3a03cff 	mov	r3, #65280	; 0xff00
 3f15274:	e1c230b8 	strh	r3, [r2, #8]
	}
 3f15278:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f1527c:	03f72fa4 	mvneqs	r2, #656	; 0x290

03f15280 <DPC_InitHardware>:
 3f15280:	e1a0c00d 	mov	r12, r13
 3f15284:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
}



//[*]----------------------------------------------------------------------------------------------------[*]
void DPC_InitHardware
(
	DPC_OPER_MODE  	Mode,		
	U16  	IsInterlace,		// Prograssive or Interlace Mode.
	U16  	IsPALMode,          // It is only valid when DOT is YCbCr Mode
	U16  	IntEn,				// Interrupt Enable
	U16   	IntHSyncEdgePos,	// Interrupt Edge Position in HSYNC.
	U16   	IntVSyncEdgePos,	// Interrupt Edge Position in VSYNC.
	U16  	ClockSource			// Clock Configuration.
)
{
//	ds_printk("Display Output Mode = %d\n", Mode);
	
	DPC->DPC_CNTL &= ~DOT;
 3f15288:	e59f539c 	ldr	r5, [pc, #39c]	; 3f1562c <DPC_InitHardware+0x3ac>
 3f1528c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f15290:	e1db60b4 	ldrh	r6, [r11, #4]
 3f15294:	e1db70b8 	ldrh	r7, [r11, #8]
 3f15298:	e5954000 	ldr	r4, [r5]
 3f1529c:	e1a01801 	mov	r1, r1, lsl #16
 3f152a0:	e1d4c0b0 	ldrh	r12, [r4]
 3f152a4:	e1a01821 	mov	r1, r1, lsr #16
 3f152a8:	e1dba0bc 	ldrh	r10, [r11, #12]
 3f152ac:	e3ccc0c0 	bic	r12, r12, #192	; 0xc0
 3f152b0:	e1a0c80c 	mov	r12, r12, lsl #16
 3f152b4:	e1a0c82c 	mov	r12, r12, lsr #16
 3f152b8:	e1c4c0b0 	strh	r12, [r4]
	DPC->DPC_CNTL |= FInsrt((Mode>>2)&0x3, BF_DOT);	//(Mode<<4)&DOT;
 3f152bc:	e1a0c200 	mov	r12, r0, lsl #4
 3f152c0:	e1d4e0b0 	ldrh	r14, [r4]
 3f152c4:	e20cc0c0 	and	r12, r12, #192	; 0xc0
 3f152c8:	e18ee00c 	orr	r14, r14, r12
 3f152cc:	e1c4e0b0 	strh	r14, [r4]
 3f152d0:	e1a02802 	mov	r2, r2, lsl #16

	DPC->DPC_CNTL &= ~DOF;
 3f152d4:	e1d4c0b0 	ldrh	r12, [r4]
 3f152d8:	e1a02822 	mov	r2, r2, lsr #16
 3f152dc:	e3ccc006 	bic	r12, r12, #6	; 0x6
 3f152e0:	e1a0c80c 	mov	r12, r12, lsl #16
 3f152e4:	e1a0c82c 	mov	r12, r12, lsr #16
 3f152e8:	e1c4c0b0 	strh	r12, [r4]
 3f152ec:	e1a03803 	mov	r3, r3, lsl #16
	DPC->DPC_CNTL |= FInsrt(Mode&0x3, BF_DOF);	//(Mode<<1)&DOF;
 3f152f0:	e1d4c0b0 	ldrh	r12, [r4]
 3f152f4:	e200e003 	and	r14, r0, #3	; 0x3
 3f152f8:	e18cc08e 	orr	r12, r12, r14, lsl #1
 3f152fc:	e1c4c0b0 	strh	r12, [r4]
 3f15300:	e1a0c823 	mov	r12, r3, lsr #16

	switch(Mode) {
 3f15304:	e350000b 	cmp	r0, #11	; 0xb
 3f15308:	979ff100 	ldrls	r15, [r15, r0, lsl #2]
 3f1530c:	ea0000f5 	b	3f156e8 <DPC_InitHardware+0x468>
 3f15310:	03f15340 	mvneqs	r5, #1	; 0x1
 3f15314:	03f15340 	mvneqs	r5, #1	; 0x1
 3f15318:	03f15340 	mvneqs	r5, #1	; 0x1
 3f1531c:	03f15340 	mvneqs	r5, #1	; 0x1
 3f15320:	03f153f8 	mvneqs	r5, #-536870909	; 0xe0000003
 3f15324:	03f153f8 	mvneqs	r5, #-536870909	; 0xe0000003
 3f15328:	03f153f8 	mvneqs	r5, #-536870909	; 0xe0000003
 3f1532c:	03f153f8 	mvneqs	r5, #-536870909	; 0xe0000003
 3f15330:	03f154a8 	mvneqs	r5, #-1476395008	; 0xa8000000
 3f15334:	03f15574 	mvneqs	r5, #486539264	; 0x1d000000
 3f15338:	03f15574 	mvneqs	r5, #486539264	; 0x1d000000
 3f1533c:	03f15630 	mvneqs	r5, #50331648	; 0x3000000
	case DPC_RGB_444:
	case DPC_RGB_565:
	case DPC_RGB_666:
	case DPC_RGB_888:
		DPC->DPC_CLKCNTL 	&= ~CLK1SEL;
 3f15340:	e5952000 	ldr	r2, [r5]
 3f15344:	e1d234b8 	ldrh	r3, [r2, #72]
 3f15348:	e3c33002 	bic	r3, r3, #2	; 0x2
 3f1534c:	e1a03803 	mov	r3, r3, lsl #16
 3f15350:	e1a03823 	mov	r3, r3, lsr #16
 3f15354:	e1c234b8 	strh	r3, [r2, #72]
		DPC->DPC_CLKCNTL 	&= ~CLK2SEL;
 3f15358:	e1d234b8 	ldrh	r3, [r2, #72]
 3f1535c:	e3c33004 	bic	r3, r3, #4	; 0x4
 3f15360:	e1a03803 	mov	r3, r3, lsl #16
 3f15364:	e1a03823 	mov	r3, r3, lsr #16
 3f15368:	e1c234b8 	strh	r3, [r2, #72]
		DPC->DPC_CNTL 		&= ~CSYNC;
 3f1536c:	e1d230b0 	ldrh	r3, [r2]
 3f15370:	e3c33a02 	bic	r3, r3, #8192	; 0x2000
 3f15374:	e1a03803 	mov	r3, r3, lsl #16
 3f15378:	e1a03823 	mov	r3, r3, lsr #16
 3f1537c:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL 		&= ~PAL;
 3f15380:	e1d230b0 	ldrh	r3, [r2]
 3f15384:	e3c33a01 	bic	r3, r3, #4096	; 0x1000
 3f15388:	e1a03803 	mov	r3, r3, lsl #16
 3f1538c:	e1a03823 	mov	r3, r3, lsr #16
 3f15390:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL 		&= ~HDTV;
 3f15394:	e1d230b0 	ldrh	r3, [r2]
 3f15398:	e3c33b01 	bic	r3, r3, #1024	; 0x400
 3f1539c:	e1a03803 	mov	r3, r3, lsl #16
 3f153a0:	e1a03823 	mov	r3, r3, lsr #16
 3f153a4:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL 		&= ~ENC;
 3f153a8:	e1d230b0 	ldrh	r3, [r2]
 3f153ac:	e3c33c02 	bic	r3, r3, #512	; 0x200
 3f153b0:	e1a03803 	mov	r3, r3, lsl #16
 3f153b4:	e1a03823 	mov	r3, r3, lsr #16
 3f153b8:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL 		&= ~TVMODE;
 3f153bc:	e1d230b0 	ldrh	r3, [r2]
 3f153c0:	e3c33c01 	bic	r3, r3, #256	; 0x100
 3f153c4:	e1a03803 	mov	r3, r3, lsl #16
 3f153c8:	e1a03823 	mov	r3, r3, lsr #16
 3f153cc:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL 		&= ~SYNCCBCR;
 3f153d0:	e1d230b0 	ldrh	r3, [r2]
 3f153d4:	e3c33010 	bic	r3, r3, #16	; 0x10
 3f153d8:	e1a03803 	mov	r3, r3, lsl #16
 3f153dc:	e1a03823 	mov	r3, r3, lsr #16
 3f153e0:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL 		&= ~ESAVEN;
 3f153e4:	e1d230b0 	ldrh	r3, [r2]
 3f153e8:	e3c33008 	bic	r3, r3, #8	; 0x8
 3f153ec:	e1a03803 	mov	r3, r3, lsl #16
 3f153f0:	e1a03823 	mov	r3, r3, lsr #16
		break;
 3f153f4:	ea0000ba 	b	3f156e4 <DPC_InitHardware+0x464>
	case DPC_MRGB_555:
	case DPC_MRGB_565:
	case DPC_MRGB_888A:
	case DPC_MRGB_888B:
		DPC->DPC_CLKCNTL |= CLK1SEL;
 3f153f8:	e5952000 	ldr	r2, [r5]
 3f153fc:	e1d234b8 	ldrh	r3, [r2, #72]
 3f15400:	e3833002 	orr	r3, r3, #2	; 0x2
 3f15404:	e1c234b8 	strh	r3, [r2, #72]
		DPC->DPC_CLKCNTL &= ~CLK2SEL;
 3f15408:	e1d234b8 	ldrh	r3, [r2, #72]
 3f1540c:	e3c33004 	bic	r3, r3, #4	; 0x4
 3f15410:	e1a03803 	mov	r3, r3, lsl #16
 3f15414:	e1a03823 	mov	r3, r3, lsr #16
 3f15418:	e1c234b8 	strh	r3, [r2, #72]
		DPC->DPC_CNTL &= ~CSYNC;
 3f1541c:	e1d230b0 	ldrh	r3, [r2]
 3f15420:	e3c33a02 	bic	r3, r3, #8192	; 0x2000
 3f15424:	e1a03803 	mov	r3, r3, lsl #16
 3f15428:	e1a03823 	mov	r3, r3, lsr #16
 3f1542c:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~PAL;
 3f15430:	e1d230b0 	ldrh	r3, [r2]
 3f15434:	e3c33a01 	bic	r3, r3, #4096	; 0x1000
 3f15438:	e1a03803 	mov	r3, r3, lsl #16
 3f1543c:	e1a03823 	mov	r3, r3, lsr #16
 3f15440:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~HDTV;
 3f15444:	e1d230b0 	ldrh	r3, [r2]
 3f15448:	e3c33b01 	bic	r3, r3, #1024	; 0x400
 3f1544c:	e1a03803 	mov	r3, r3, lsl #16
 3f15450:	e1a03823 	mov	r3, r3, lsr #16
 3f15454:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~ENC;
 3f15458:	e1d230b0 	ldrh	r3, [r2]
 3f1545c:	e3c33c02 	bic	r3, r3, #512	; 0x200
 3f15460:	e1a03803 	mov	r3, r3, lsl #16
 3f15464:	e1a03823 	mov	r3, r3, lsr #16
 3f15468:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~TVMODE;
 3f1546c:	e1d230b0 	ldrh	r3, [r2]
 3f15470:	e3c33c01 	bic	r3, r3, #256	; 0x100
 3f15474:	e1a03803 	mov	r3, r3, lsl #16
 3f15478:	e1a03823 	mov	r3, r3, lsr #16
 3f1547c:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~SYNCCBCR;
 3f15480:	e1d230b0 	ldrh	r3, [r2]
 3f15484:	e3c33010 	bic	r3, r3, #16	; 0x10
 3f15488:	e1a03803 	mov	r3, r3, lsl #16
 3f1548c:	e1a03823 	mov	r3, r3, lsr #16
 3f15490:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~ESAVEN;
 3f15494:	e1d230b0 	ldrh	r3, [r2]
 3f15498:	e3c33008 	bic	r3, r3, #8	; 0x8
 3f1549c:	e1a03803 	mov	r3, r3, lsl #16
 3f154a0:	e1a03823 	mov	r3, r3, lsr #16
		break;
 3f154a4:	ea00008e 	b	3f156e4 <DPC_InitHardware+0x464>
	case DPC_YCBCR_CCIR656:
		DPC->DPC_CLKCNTL |= CLK1SEL;
 3f154a8:	e5952000 	ldr	r2, [r5]
 3f154ac:	e1d234b8 	ldrh	r3, [r2, #72]
 3f154b0:	e3833002 	orr	r3, r3, #2	; 0x2
 3f154b4:	e1c234b8 	strh	r3, [r2, #72]
		DPC->DPC_CLKCNTL &= ~CLK2SEL;
 3f154b8:	e1d234b8 	ldrh	r3, [r2, #72]
 3f154bc:	e3c33004 	bic	r3, r3, #4	; 0x4
 3f154c0:	e1a03803 	mov	r3, r3, lsl #16
 3f154c4:	e1a03823 	mov	r3, r3, lsr #16
 3f154c8:	e1c234b8 	strh	r3, [r2, #72]
		DPC->DPC_CNTL &= ~CSYNC;
 3f154cc:	e1d230b0 	ldrh	r3, [r2]
 3f154d0:	e3c33a02 	bic	r3, r3, #8192	; 0x2000
 3f154d4:	e1a03803 	mov	r3, r3, lsl #16
 3f154d8:	e1a03823 	mov	r3, r3, lsr #16
 3f154dc:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~PAL;
 3f154e0:	e1d230b0 	ldrh	r3, [r2]
 3f154e4:	e3c33a01 	bic	r3, r3, #4096	; 0x1000
 3f154e8:	e1a03803 	mov	r3, r3, lsl #16
 3f154ec:	e1a03823 	mov	r3, r3, lsr #16
 3f154f0:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~HDTV;
 3f154f4:	e1d230b0 	ldrh	r3, [r2]
 3f154f8:	e3c33b01 	bic	r3, r3, #1024	; 0x400
 3f154fc:	e1a03803 	mov	r3, r3, lsl #16
 3f15500:	e1a03823 	mov	r3, r3, lsr #16
 3f15504:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL |= ENC;
 3f15508:	e1d230b0 	ldrh	r3, [r2]
 3f1550c:	e3833c02 	orr	r3, r3, #512	; 0x200
 3f15510:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL |= TVMODE;
 3f15514:	e1d230b0 	ldrh	r3, [r2]
 3f15518:	e3833c01 	orr	r3, r3, #256	; 0x100
 3f1551c:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~SYNCCBCR;
 3f15520:	e1d230b0 	ldrh	r3, [r2]
 3f15524:	e3c33010 	bic	r3, r3, #16	; 0x10
 3f15528:	e1a03803 	mov	r3, r3, lsl #16
 3f1552c:	e1a03823 	mov	r3, r3, lsr #16
 3f15530:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL |= ESAVEN;
 3f15534:	e1d230b0 	ldrh	r3, [r2]
 3f15538:	e3833008 	orr	r3, r3, #8	; 0x8
 3f1553c:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_V_END |= NOSYMATVLINE;
 3f15540:	e1d232b2 	ldrh	r3, [r2, #34]
 3f15544:	e3833a01 	orr	r3, r3, #4096	; 0x1000
 3f15548:	e1c232b2 	strh	r3, [r2, #34]
		DPC->DPC_V_END |= NOSYMATVFLD;
 3f1554c:	e1d232b2 	ldrh	r3, [r2, #34]
 3f15550:	e3833a02 	orr	r3, r3, #8192	; 0x2000
 3f15554:	e1c232b2 	strh	r3, [r2, #34]
		DPC->DPC_V_SYNC |= VSFLDEN;
 3f15558:	e1d232b0 	ldrh	r3, [r2, #32]
 3f1555c:	e3833080 	orr	r3, r3, #128	; 0x80
 3f15560:	e1c232b0 	strh	r3, [r2, #32]
		DPC->DPC_V_SYNC |= VSFLDPOL;
 3f15564:	e1d232b0 	ldrh	r3, [r2, #32]
 3f15568:	e3833040 	orr	r3, r3, #64	; 0x40
 3f1556c:	e1c232b0 	strh	r3, [r2, #32]
		break;
 3f15570:	ea00005c 	b	3f156e8 <DPC_InitHardware+0x468>
	case DPC_YCBCR_CCIR601:
	case DPC_YCBCR_3x8:
		DPC->DPC_CLKCNTL &= ~CLK1SEL;
 3f15574:	e5950000 	ldr	r0, [r5]
 3f15578:	e1d034b8 	ldrh	r3, [r0, #72]
 3f1557c:	e3c33002 	bic	r3, r3, #2	; 0x2
 3f15580:	e1a03803 	mov	r3, r3, lsl #16
 3f15584:	e1a03823 	mov	r3, r3, lsr #16
 3f15588:	e1c034b8 	strh	r3, [r0, #72]
		DPC->DPC_CLKCNTL &= ~CLK2SEL;
 3f1558c:	e1d034b8 	ldrh	r3, [r0, #72]
 3f15590:	e3c33004 	bic	r3, r3, #4	; 0x4
 3f15594:	e1a03803 	mov	r3, r3, lsl #16
 3f15598:	e1a03823 	mov	r3, r3, lsr #16
 3f1559c:	e1c034b8 	strh	r3, [r0, #72]
		DPC->DPC_CNTL &= ~CSYNC;
 3f155a0:	e1d030b0 	ldrh	r3, [r0]
		if(IsPALMode)
 3f155a4:	e3520000 	cmp	r2, #0	; 0x0
 3f155a8:	e3c33a02 	bic	r3, r3, #8192	; 0x2000
 3f155ac:	e1a03803 	mov	r3, r3, lsl #16
 3f155b0:	e1a03823 	mov	r3, r3, lsr #16
 3f155b4:	e1c030b0 	strh	r3, [r0]
			DPC->DPC_CNTL |= PAL;
 3f155b8:	11d030b0 	ldrneh	r3, [r0]
 3f155bc:	13833a01 	orrne	r3, r3, #4096	; 0x1000
		else
			DPC->DPC_CNTL &= ~PAL;
 3f155c0:	01d030b0 	ldreqh	r3, [r0]
 3f155c4:	03c33a01 	biceq	r3, r3, #4096	; 0x1000
 3f155c8:	01a03803 	moveq	r3, r3, lsl #16
 3f155cc:	01a03823 	moveq	r3, r3, lsr #16
 3f155d0:	e1c030b0 	strh	r3, [r0]
		DPC->DPC_CNTL &= ~HDTV;
 3f155d4:	e5952000 	ldr	r2, [r5]
 3f155d8:	e1d230b0 	ldrh	r3, [r2]
 3f155dc:	e3c33b01 	bic	r3, r3, #1024	; 0x400
 3f155e0:	e1a03803 	mov	r3, r3, lsl #16
 3f155e4:	e1a03823 	mov	r3, r3, lsr #16
 3f155e8:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL |= ENC;
 3f155ec:	e1d230b0 	ldrh	r3, [r2]
 3f155f0:	e3833c02 	orr	r3, r3, #512	; 0x200
 3f155f4:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL |= TVMODE;
 3f155f8:	e1d230b0 	ldrh	r3, [r2]
 3f155fc:	e3833c01 	orr	r3, r3, #256	; 0x100
 3f15600:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~SYNCCBCR;
 3f15604:	e1d230b0 	ldrh	r3, [r2]
 3f15608:	e3c33010 	bic	r3, r3, #16	; 0x10
 3f1560c:	e1a03803 	mov	r3, r3, lsl #16
 3f15610:	e1a03823 	mov	r3, r3, lsr #16
 3f15614:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~ESAVEN;
 3f15618:	e1d230b0 	ldrh	r3, [r2]
 3f1561c:	e3c33008 	bic	r3, r3, #8	; 0x8
 3f15620:	e1a03803 	mov	r3, r3, lsl #16
 3f15624:	e1a03823 	mov	r3, r3, lsr #16
		break;
 3f15628:	ea00002d 	b	3f156e4 <DPC_InitHardware+0x464>
 3f1562c:	03f72fa4 	mvneqs	r2, #656	; 0x290
	case DPC_YCBCR_3x10:
		DPC->DPC_CLKCNTL &= ~CLK1SEL;
 3f15630:	e5950000 	ldr	r0, [r5]
 3f15634:	e1d034b8 	ldrh	r3, [r0, #72]
 3f15638:	e3c33002 	bic	r3, r3, #2	; 0x2
 3f1563c:	e1a03803 	mov	r3, r3, lsl #16
 3f15640:	e1a03823 	mov	r3, r3, lsr #16
 3f15644:	e1c034b8 	strh	r3, [r0, #72]
		DPC->DPC_CLKCNTL &= ~CLK2SEL;
 3f15648:	e1d034b8 	ldrh	r3, [r0, #72]
 3f1564c:	e3c33004 	bic	r3, r3, #4	; 0x4
 3f15650:	e1a03803 	mov	r3, r3, lsl #16
 3f15654:	e1a03823 	mov	r3, r3, lsr #16
 3f15658:	e1c034b8 	strh	r3, [r0, #72]
		DPC->DPC_CNTL &= ~CSYNC;
 3f1565c:	e1d030b0 	ldrh	r3, [r0]
		if(IsPALMode)
 3f15660:	e3520000 	cmp	r2, #0	; 0x0
 3f15664:	e3c33a02 	bic	r3, r3, #8192	; 0x2000
 3f15668:	e1a03803 	mov	r3, r3, lsl #16
 3f1566c:	e1a03823 	mov	r3, r3, lsr #16
 3f15670:	e1c030b0 	strh	r3, [r0]
			DPC->DPC_CNTL |= PAL;
 3f15674:	11d030b0 	ldrneh	r3, [r0]
 3f15678:	13833a01 	orrne	r3, r3, #4096	; 0x1000
		else
			DPC->DPC_CNTL &= ~PAL;
 3f1567c:	01d030b0 	ldreqh	r3, [r0]
 3f15680:	03c33a01 	biceq	r3, r3, #4096	; 0x1000
 3f15684:	01a03803 	moveq	r3, r3, lsl #16
 3f15688:	01a03823 	moveq	r3, r3, lsr #16
 3f1568c:	e1c030b0 	strh	r3, [r0]
		DPC->DPC_CNTL &= ~HDTV;
 3f15690:	e5952000 	ldr	r2, [r5]
 3f15694:	e1d230b0 	ldrh	r3, [r2]
 3f15698:	e3c33b01 	bic	r3, r3, #1024	; 0x400
 3f1569c:	e1a03803 	mov	r3, r3, lsl #16
 3f156a0:	e1a03823 	mov	r3, r3, lsr #16
 3f156a4:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL |= ENC;
 3f156a8:	e1d230b0 	ldrh	r3, [r2]
 3f156ac:	e3833c02 	orr	r3, r3, #512	; 0x200
 3f156b0:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~TVMODE;
 3f156b4:	e1d230b0 	ldrh	r3, [r2]
 3f156b8:	e3c33c01 	bic	r3, r3, #256	; 0x100
 3f156bc:	e1a03803 	mov	r3, r3, lsl #16
 3f156c0:	e1a03823 	mov	r3, r3, lsr #16
 3f156c4:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL &= ~SYNCCBCR;
 3f156c8:	e1d230b0 	ldrh	r3, [r2]
 3f156cc:	e3c33010 	bic	r3, r3, #16	; 0x10
 3f156d0:	e1a03803 	mov	r3, r3, lsl #16
 3f156d4:	e1a03823 	mov	r3, r3, lsr #16
 3f156d8:	e1c230b0 	strh	r3, [r2]
		DPC->DPC_CNTL |= ESAVEN;
 3f156dc:	e1d230b0 	ldrh	r3, [r2]
 3f156e0:	e3833008 	orr	r3, r3, #8	; 0x8
 3f156e4:	e1c230b0 	strh	r3, [r2]
		break;
	default:
		break;
	}

	if(IsInterlace)		DPC->DPC_CNTL |= INTERLACE;
 3f156e8:	e3510000 	cmp	r1, #0	; 0x0
 3f156ec:	159f3138 	ldrne	r3, [pc, #138]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f156f0:	15932000 	ldrne	r2, [r3]
 3f156f4:	11d230b0 	ldrneh	r3, [r2]
 3f156f8:	13833020 	orrne	r3, r3, #32	; 0x20
 3f156fc:	1a000005 	bne	3f15718 <DPC_InitHardware+0x498>
	else				DPC->DPC_CNTL &= ~INTERLACE;
 3f15700:	e59f3124 	ldr	r3, [pc, #124]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f15704:	e5932000 	ldr	r2, [r3]
 3f15708:	e1d230b0 	ldrh	r3, [r2]
 3f1570c:	e3c33020 	bic	r3, r3, #32	; 0x20
 3f15710:	e1a03803 	mov	r3, r3, lsl #16
 3f15714:	e1a03823 	mov	r3, r3, lsr #16
 3f15718:	e1c230b0 	strh	r3, [r2]
 	if((IntEn>>1)&1)	DPC->DPC_INTR |= VSINTEN;
 3f1571c:	e31c0002 	tst	r12, #2	; 0x2
 3f15720:	159f3104 	ldrne	r3, [pc, #104]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f15724:	15932000 	ldrne	r2, [r3]
 3f15728:	11d234b6 	ldrneh	r3, [r2, #70]
 3f1572c:	13833020 	orrne	r3, r3, #32	; 0x20
 3f15730:	1a000005 	bne	3f1574c <DPC_InitHardware+0x4cc>
	else				DPC->DPC_INTR &= ~VSINTEN;
 3f15734:	e59f30f0 	ldr	r3, [pc, #f0]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f15738:	e5932000 	ldr	r2, [r3]
 3f1573c:	e1d234b6 	ldrh	r3, [r2, #70]
 3f15740:	e3c33020 	bic	r3, r3, #32	; 0x20
 3f15744:	e1a03803 	mov	r3, r3, lsl #16
 3f15748:	e1a03823 	mov	r3, r3, lsr #16
 3f1574c:	e1c234b6 	strh	r3, [r2, #70]
	if(IntEn&0x1)		DPC->DPC_INTR |= HSINTEN;
 3f15750:	e31c0001 	tst	r12, #1	; 0x1
 3f15754:	159f30d0 	ldrne	r3, [pc, #d0]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f15758:	15932000 	ldrne	r2, [r3]
 3f1575c:	11d234b6 	ldrneh	r3, [r2, #70]
 3f15760:	13833010 	orrne	r3, r3, #16	; 0x10
 3f15764:	1a000005 	bne	3f15780 <DPC_InitHardware+0x500>
	else				DPC->DPC_INTR &= ~HSINTEN;
 3f15768:	e59f30bc 	ldr	r3, [pc, #bc]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f1576c:	e5932000 	ldr	r2, [r3]
 3f15770:	e1d234b6 	ldrh	r3, [r2, #70]
 3f15774:	e3c33010 	bic	r3, r3, #16	; 0x10
 3f15778:	e1a03803 	mov	r3, r3, lsl #16
 3f1577c:	e1a03823 	mov	r3, r3, lsr #16
 3f15780:	e1c234b6 	strh	r3, [r2, #70]
	if(IntHSyncEdgePos)	DPC->DPC_INTR |= HSINTEDGE;
 3f15784:	e3560000 	cmp	r6, #0	; 0x0
 3f15788:	159f309c 	ldrne	r3, [pc, #9c]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f1578c:	15932000 	ldrne	r2, [r3]
 3f15790:	11d234b6 	ldrneh	r3, [r2, #70]
 3f15794:	13833004 	orrne	r3, r3, #4	; 0x4
 3f15798:	1a000005 	bne	3f157b4 <DPC_InitHardware+0x534>
	else				DPC->DPC_INTR &= ~HSINTEDGE;
 3f1579c:	e59f3088 	ldr	r3, [pc, #88]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f157a0:	e5932000 	ldr	r2, [r3]
 3f157a4:	e1d234b6 	ldrh	r3, [r2, #70]
 3f157a8:	e3c33004 	bic	r3, r3, #4	; 0x4
 3f157ac:	e1a03803 	mov	r3, r3, lsl #16
 3f157b0:	e1a03823 	mov	r3, r3, lsr #16
 3f157b4:	e1c234b6 	strh	r3, [r2, #70]
	if(IntVSyncEdgePos)	DPC->DPC_INTR |= VSINTEDGE;
 3f157b8:	e3570000 	cmp	r7, #0	; 0x0
 3f157bc:	159f3068 	ldrne	r3, [pc, #68]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f157c0:	15932000 	ldrne	r2, [r3]
 3f157c4:	11d234b6 	ldrneh	r3, [r2, #70]
 3f157c8:	13833008 	orrne	r3, r3, #8	; 0x8
 3f157cc:	1a000005 	bne	3f157e8 <DPC_InitHardware+0x568>
	else				DPC->DPC_INTR &= ~VSINTEDGE;
 3f157d0:	e59f3054 	ldr	r3, [pc, #54]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f157d4:	e5932000 	ldr	r2, [r3]
 3f157d8:	e1d234b6 	ldrh	r3, [r2, #70]
 3f157dc:	e3c33008 	bic	r3, r3, #8	; 0x8
 3f157e0:	e1a03803 	mov	r3, r3, lsl #16
 3f157e4:	e1a03823 	mov	r3, r3, lsr #16
 3f157e8:	e1c234b6 	strh	r3, [r2, #70]

	DPC->DPC_CLKCNTL &= ~CLKSRC;
 3f157ec:	e59f3038 	ldr	r3, [pc, #38]	; 3f1582c <DPC_InitHardware+0x5ac>
 3f157f0:	e5932000 	ldr	r2, [r3]
 3f157f4:	e1d234b8 	ldrh	r3, [r2, #72]
 3f157f8:	e3c33018 	bic	r3, r3, #24	; 0x18
 3f157fc:	e1a03803 	mov	r3, r3, lsl #16
 3f15800:	e1a03823 	mov	r3, r3, lsr #16
 3f15804:	e1c234b8 	strh	r3, [r2, #72]
	DPC->DPC_CLKCNTL |= FInsrt(ClockSource, BF_CLKSRC);
 3f15808:	e1d234b8 	ldrh	r3, [r2, #72]
 3f1580c:	e183318a 	orr	r3, r3, r10, lsl #3
 3f15810:	e1c234b8 	strh	r3, [r2, #72]
	DPC->DPC_CNTL &= ~SLAVE;	//Master Mode 
 3f15814:	e1d230b0 	ldrh	r3, [r2]
 3f15818:	e3c33901 	bic	r3, r3, #16384	; 0x4000
 3f1581c:	e1a03803 	mov	r3, r3, lsl #16
 3f15820:	e1a03823 	mov	r3, r3, lsr #16
 3f15824:	e1c230b0 	strh	r3, [r2]
 3f15828:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f1582c:	03f72fa4 	mvneqs	r2, #656	; 0x290

03f15830 <DPC_Initialize>:
 3f15830:	e1a0c00d 	mov	r12, r13
 3f15834:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

static inline MMSP20_DPC * const MMSP20_GetBase_DPC(void)
{
	return (MMSP20_DPC * const)MMSP20_DPC_BASE;
 3f15838:	e59f200c 	ldr	r2, [pc, #c]	; 3f1584c <DPC_Initialize+0x1c>

	//ds_printk("<1> DPC_CNTL = 0x%02X\n", DPC->DPC_CNTL);
}
//[*]----------------------------------------------------------------------------------------------------[*]
//int do_bmpload_sub(unsigned char *, int, int, int);
//void DPC_InitHardware(DPC_OPER_MODE Mode, U16 IsInterlace, U16 IsPALMode, U16 IntEn, U16 IntHSyncEdgePos, U16 IntVSyncEdgePos, U16 ClockSource);
//[*]----------------------------------------------------------------------------------------------------[*]
#if 0
void GPIO_Initialize(void) 
{
	pGPIO_REG = MMSP20_GetBase_GPIO();
}
//[*]----------------------------------------------------------------------------------------------------[*]
void inline write_gpio_bit(unsigned int num, unsigned int val)
{
	unsigned short value;
	unsigned long bit_ofs = num & 0xf;

	GPIO_Initialize();
	
	value = pGPIO_REG->GPIOOUT[GRP_NUM(num)] & ~(1<<bit_ofs);
	value |= (val << bit_ofs);
	pGPIO_REG->GPIOOUT[GRP_NUM(num)] = value;	
}
//[*]----------------------------------------------------------------------------------------------------[*]
void _set_mmsp2_gpio_func(unsigned int addr_l, unsigned int addr_h, unsigned int pins, unsigned int bit, unsigned int func)
{
	unsigned short 	value_l 	= readw(addr_l);
	unsigned short 	value_h 	= readw(addr_h);
	unsigned int 	*addr_t 	= &addr_l;
	unsigned short 	*value_t 	= &value_l;
	unsigned int 	bitofs_t 	= bit * 2;

	value_l |= (value_h << pins);
	value_h >>= (16-pins);

	if(bit > 7) 
	{
		bitofs_t -= (8*2);
		addr_t = &addr_h;
		value_t = &value_h;
	}

	*value_t &= ~(0x3 << bitofs_t);
	*value_t |= ((func & 0x03) << bitofs_t);

	writew(*value_t, *addr_t);

	// verify 
//	BUG_ON(func != _get_mmsp2_gpio_func(addr_l, addr_h, pins, bit));
}
//[*]----------------------------------------------------------------------------------------------------[*]
void set_gpio_ctrl(unsigned int num, unsigned int func, unsigned int pu)
{
	unsigned long reg_offset = GRP_NUM(num);		//((0xf0 & num) >> 3);
    unsigned long addr_l, addr_h;
	unsigned long bit_ofs = (0x7 & num) * 2;    // 0,1,2,.. --> 0,2,4,6,...
	unsigned short temp;

	GPIO_Initialize();

    addr_l = &(pGPIO_REG->GPIOALTFNLOW[reg_offset]);  //io_p2v(0xc0001020 + reg_offset);
	addr_h = &(pGPIO_REG->GPIOALTFNHI[reg_offset]);   //io_p2v(0xc0001040 + reg_offset);

	_set_mmsp2_gpio_func(addr_l, addr_h, _pins_of_gpio[GRP_NUM(num)], num & 0xf, func);

	// GPIO Pullup
	addr_l = &(pGPIO_REG->GPIOPUENB[reg_offset]);		//io_p2v(0xc00010c0 + reg_offset);
	bit_ofs = num & 0xf;
	temp = readw(addr_l);   // PUENB

	if(pu == GPIOPU_NOSET)	return;

	temp &= ~(1 << bit_ofs);
	temp |= (pu << bit_ofs);

	writew(temp, addr_l);
}
#endif
//[*]----------------------------------------------------------------------------------------------------[*]
void DPC_Initialize( void )
{
	DPC = MMSP20_GetBase_DPC();
 3f1583c:	e59f300c 	ldr	r3, [pc, #c]	; 3f15850 <DPC_Initialize+0x20>
 3f15840:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f15844:	e5832000 	str	r2, [r3]
}
 3f15848:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f1584c:	c0002800 	andgt	r2, r0, r0, lsl #16
 3f15850:	03f72fa4 	mvneqs	r2, #656	; 0x290

03f15854 <MLC_Initialize>:
 3f15854:	e1a0c00d 	mov	r12, r13
 3f15858:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
}

static inline MMSP20_MLC * const MMSP20_GetBase_MLC(void)
{
	return (MMSP20_MLC * const)MMSP20_MLC_BASE;
 3f1585c:	e59f200c 	ldr	r2, [pc, #c]	; 3f15870 <MLC_Initialize+0x1c>
//[*]----------------------------------------------------------------------------------------------------[*]
void MLC_Initialize(	void )
{
	MLC_REG = MMSP20_GetBase_MLC();
 3f15860:	e59f300c 	ldr	r3, [pc, #c]	; 3f15874 <MLC_Initialize+0x20>
 3f15864:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f15868:	e5832000 	str	r2, [r3]
}
 3f1586c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f15870:	c0002880 	andgt	r2, r0, r0, lsl #17
 3f15874:	03f72fac 	mvneqs	r2, #688	; 0x2b0

03f15878 <MLC_RGB_MixMux>:
 3f15878:	e1a0c00d 	mov	r12, r13
 3f1587c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f15880:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
void MLC_RGB_MixMux(U8 rgnNum, U8 MixMux, U8 Alpha)
{
 3f15884:	e20110ff 	and	r1, r1, #255	; 0xff
 3f15888:	e202c0ff 	and	r12, r2, #255	; 0xff
	if ( rgnNum == MLC_RGB_RGN_1 )
 3f1588c:	e21000ff 	ands	r0, r0, #255	; 0xff
 3f15890:	1a000023 	bne	3f15924 <MLC_RGB_MixMux+0xac>
	{
		// MixMux
		if ( MixMux == MLC_RGB_MIXMUX_PRI )			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL1_MIXMUX ) | FInsrt(MLC_RGB_MIXMUX_PRI, BF_MLC_STL1_MIXMUX));	// [1:0] <= 0
 3f15894:	e3510000 	cmp	r1, #0	; 0x0
 3f15898:	1a000006 	bne	3f158b8 <MLC_RGB_MixMux+0x40>
 3f1589c:	e59f32d8 	ldr	r3, [pc, #2d8]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f158a0:	e5932000 	ldr	r2, [r3]
 3f158a4:	e1d235bc 	ldrh	r3, [r2, #92]
 3f158a8:	e3c33003 	bic	r3, r3, #3	; 0x3
 3f158ac:	e1a03803 	mov	r3, r3, lsl #16
 3f158b0:	e1a03823 	mov	r3, r3, lsr #16
 3f158b4:	ea000010 	b	3f158fc <MLC_RGB_MixMux+0x84>
		else if ( MixMux == MLC_RGB_MIXMUX_CKEY )	MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL1_MIXMUX ) | FInsrt(MLC_RGB_MIXMUX_CKEY, BF_MLC_STL1_MIXMUX));	// [1:0] <= 1
 3f158b8:	e3510001 	cmp	r1, #1	; 0x1
 3f158bc:	1a000007 	bne	3f158e0 <MLC_RGB_MixMux+0x68>
 3f158c0:	e59f32b4 	ldr	r3, [pc, #2b4]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f158c4:	e5932000 	ldr	r2, [r3]
 3f158c8:	e1d235bc 	ldrh	r3, [r2, #92]
 3f158cc:	e3c33003 	bic	r3, r3, #3	; 0x3
 3f158d0:	e1a03803 	mov	r3, r3, lsl #16
 3f158d4:	e1a03823 	mov	r3, r3, lsr #16
 3f158d8:	e3833001 	orr	r3, r3, #1	; 0x1
 3f158dc:	ea000006 	b	3f158fc <MLC_RGB_MixMux+0x84>
		else //if ( MixMux == MLC_RGB_MIXMUX_ALPHA )		
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL1_MIXMUX ) | FInsrt(MLC_RGB_MIXMUX_ALPHA, BF_MLC_STL1_MIXMUX));	// [1:0] <= 2
 3f158e0:	e59f3294 	ldr	r3, [pc, #294]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f158e4:	e5932000 	ldr	r2, [r3]
 3f158e8:	e1d235bc 	ldrh	r3, [r2, #92]
 3f158ec:	e3c33003 	bic	r3, r3, #3	; 0x3
 3f158f0:	e1a03803 	mov	r3, r3, lsl #16
 3f158f4:	e1a03823 	mov	r3, r3, lsr #16
 3f158f8:	e3833002 	orr	r3, r3, #2	; 0x2
 3f158fc:	e1c235bc 	strh	r3, [r2, #92]
		
		// Alpha 1	
		MLC_REG->RGB_ALPHA_L = (U16)(( MLC_REG->RGB_ALPHA_L & ~MLC_STL1_ALPHA ) | FInsrt(Alpha,BF_MLC_STL1_ALPHA));
 3f15900:	e59f3274 	ldr	r3, [pc, #274]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15904:	e5932000 	ldr	r2, [r3]
 3f15908:	e1d235be 	ldrh	r3, [r2, #94]
 3f1590c:	e3c3300f 	bic	r3, r3, #15	; 0xf
 3f15910:	e1a03803 	mov	r3, r3, lsl #16
 3f15914:	e1a03823 	mov	r3, r3, lsr #16
 3f15918:	e183300c 	orr	r3, r3, r12
 3f1591c:	e1c235be 	strh	r3, [r2, #94]
	}
 3f15920:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else if ( rgnNum == MLC_RGB_RGN_2 )
 3f15924:	e3500001 	cmp	r0, #1	; 0x1
 3f15928:	1a000023 	bne	3f159bc <MLC_RGB_MixMux+0x144>
	{
		// MixMux
		if ( MixMux == MLC_RGB_MIXMUX_PRI )				// [3:2] <= 0
 3f1592c:	e3510000 	cmp	r1, #0	; 0x0
 3f15930:	1a000006 	bne	3f15950 <MLC_RGB_MixMux+0xd8>
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL2_MIXMUX ) 
 3f15934:	e59f3240 	ldr	r3, [pc, #240]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15938:	e5932000 	ldr	r2, [r3]
 3f1593c:	e1d235bc 	ldrh	r3, [r2, #92]
 3f15940:	e3c3300c 	bic	r3, r3, #12	; 0xc
 3f15944:	e1a03803 	mov	r3, r3, lsl #16
 3f15948:	e1a03823 	mov	r3, r3, lsr #16
 3f1594c:	ea000010 	b	3f15994 <MLC_RGB_MixMux+0x11c>
			                                        | FInsrt(MLC_RGB_MIXMUX_PRI, BF_MLC_STL2_MIXMUX));
		else if ( MixMux == MLC_RGB_MIXMUX_CKEY )			// [3:2] <= 1
 3f15950:	e3510001 	cmp	r1, #1	; 0x1
 3f15954:	1a000007 	bne	3f15978 <MLC_RGB_MixMux+0x100>
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL2_MIXMUX ) 
 3f15958:	e59f321c 	ldr	r3, [pc, #21c]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f1595c:	e5932000 	ldr	r2, [r3]
 3f15960:	e1d235bc 	ldrh	r3, [r2, #92]
 3f15964:	e3c3300c 	bic	r3, r3, #12	; 0xc
 3f15968:	e1a03803 	mov	r3, r3, lsl #16
 3f1596c:	e1a03823 	mov	r3, r3, lsr #16
 3f15970:	e3833004 	orr	r3, r3, #4	; 0x4
 3f15974:	ea000006 	b	3f15994 <MLC_RGB_MixMux+0x11c>
			                                        | FInsrt(MLC_RGB_MIXMUX_CKEY, BF_MLC_STL2_MIXMUX));
		else //if ( MixMux == MLC_RGB_MIXMUX_ALPHA )		// [3:2] <= 2
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL2_MIXMUX ) 
 3f15978:	e59f31fc 	ldr	r3, [pc, #1fc]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f1597c:	e5932000 	ldr	r2, [r3]
 3f15980:	e1d235bc 	ldrh	r3, [r2, #92]
 3f15984:	e3c3300c 	bic	r3, r3, #12	; 0xc
 3f15988:	e1a03803 	mov	r3, r3, lsl #16
 3f1598c:	e1a03823 	mov	r3, r3, lsr #16
 3f15990:	e3833008 	orr	r3, r3, #8	; 0x8
 3f15994:	e1c235bc 	strh	r3, [r2, #92]
			                                        | FInsrt(MLC_RGB_MIXMUX_ALPHA, BF_MLC_STL2_MIXMUX));
		
		// Alpha 2	
		MLC_REG->RGB_ALPHA_L = (U16)(( MLC_REG->RGB_ALPHA_L & ~MLC_STL2_ALPHA ) | FInsrt(Alpha,BF_MLC_STL2_ALPHA));
 3f15998:	e59f31dc 	ldr	r3, [pc, #1dc]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f1599c:	e5932000 	ldr	r2, [r3]
 3f159a0:	e1d235be 	ldrh	r3, [r2, #94]
 3f159a4:	e3c330f0 	bic	r3, r3, #240	; 0xf0
 3f159a8:	e1a03803 	mov	r3, r3, lsl #16
 3f159ac:	e1a03823 	mov	r3, r3, lsr #16
 3f159b0:	e183320c 	orr	r3, r3, r12, lsl #4
 3f159b4:	e1c235be 	strh	r3, [r2, #94]
	}
 3f159b8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else if ( rgnNum == MLC_RGB_RGN_3 )
 3f159bc:	e3500002 	cmp	r0, #2	; 0x2
 3f159c0:	1a000023 	bne	3f15a54 <MLC_RGB_MixMux+0x1dc>
	{
		// MixMux
		if ( MixMux == MLC_RGB_MIXMUX_PRI )				// [5:4] <= 0
 3f159c4:	e3510000 	cmp	r1, #0	; 0x0
 3f159c8:	1a000006 	bne	3f159e8 <MLC_RGB_MixMux+0x170>
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL3_MIXMUX ) 
 3f159cc:	e59f31a8 	ldr	r3, [pc, #1a8]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f159d0:	e5932000 	ldr	r2, [r3]
 3f159d4:	e1d235bc 	ldrh	r3, [r2, #92]
 3f159d8:	e3c33030 	bic	r3, r3, #48	; 0x30
 3f159dc:	e1a03803 	mov	r3, r3, lsl #16
 3f159e0:	e1a03823 	mov	r3, r3, lsr #16
 3f159e4:	ea000010 	b	3f15a2c <MLC_RGB_MixMux+0x1b4>
			                                        | FInsrt(MLC_RGB_MIXMUX_PRI, BF_MLC_STL3_MIXMUX));
		else if ( MixMux == MLC_RGB_MIXMUX_CKEY )			// [5:4] <= 1
 3f159e8:	e3510001 	cmp	r1, #1	; 0x1
 3f159ec:	1a000007 	bne	3f15a10 <MLC_RGB_MixMux+0x198>
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL3_MIXMUX ) 
 3f159f0:	e59f3184 	ldr	r3, [pc, #184]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f159f4:	e5932000 	ldr	r2, [r3]
 3f159f8:	e1d235bc 	ldrh	r3, [r2, #92]
 3f159fc:	e3c33030 	bic	r3, r3, #48	; 0x30
 3f15a00:	e1a03803 	mov	r3, r3, lsl #16
 3f15a04:	e1a03823 	mov	r3, r3, lsr #16
 3f15a08:	e3833010 	orr	r3, r3, #16	; 0x10
 3f15a0c:	ea000006 	b	3f15a2c <MLC_RGB_MixMux+0x1b4>
			                                        | FInsrt(MLC_RGB_MIXMUX_CKEY, BF_MLC_STL3_MIXMUX));
		else //if ( MixMux == MLC_RGB_MIXMUX_ALPHA )		// [5:4] <= 2
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL3_MIXMUX ) 
 3f15a10:	e59f3164 	ldr	r3, [pc, #164]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15a14:	e5932000 	ldr	r2, [r3]
 3f15a18:	e1d235bc 	ldrh	r3, [r2, #92]
 3f15a1c:	e3c33030 	bic	r3, r3, #48	; 0x30
 3f15a20:	e1a03803 	mov	r3, r3, lsl #16
 3f15a24:	e1a03823 	mov	r3, r3, lsr #16
 3f15a28:	e3833020 	orr	r3, r3, #32	; 0x20
 3f15a2c:	e1c235bc 	strh	r3, [r2, #92]
			                                        | FInsrt(MLC_RGB_MIXMUX_ALPHA, BF_MLC_STL3_MIXMUX));
		
		// Alpha 3	
		MLC_REG->RGB_ALPHA_L = (U16)(( MLC_REG->RGB_ALPHA_L & ~MLC_STL3_ALPHA ) | FInsrt(Alpha,BF_MLC_STL3_ALPHA));
 3f15a30:	e59f3144 	ldr	r3, [pc, #144]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15a34:	e5932000 	ldr	r2, [r3]
 3f15a38:	e1d235be 	ldrh	r3, [r2, #94]
 3f15a3c:	e3c33c0f 	bic	r3, r3, #3840	; 0xf00
 3f15a40:	e1a03803 	mov	r3, r3, lsl #16
 3f15a44:	e1a03823 	mov	r3, r3, lsr #16
 3f15a48:	e183340c 	orr	r3, r3, r12, lsl #8
 3f15a4c:	e1c235be 	strh	r3, [r2, #94]
	}
 3f15a50:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else if ( rgnNum == MLC_RGB_RGN_4 )
 3f15a54:	e3500003 	cmp	r0, #3	; 0x3
 3f15a58:	1a000023 	bne	3f15aec <MLC_RGB_MixMux+0x274>
	{
		// MixMux
		if ( MixMux == MLC_RGB_MIXMUX_PRI )				// [7:6] <= 0
 3f15a5c:	e3510000 	cmp	r1, #0	; 0x0
 3f15a60:	1a000006 	bne	3f15a80 <MLC_RGB_MixMux+0x208>
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL4_MIXMUX ) 
 3f15a64:	e59f3110 	ldr	r3, [pc, #110]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15a68:	e5932000 	ldr	r2, [r3]
 3f15a6c:	e1d235bc 	ldrh	r3, [r2, #92]
 3f15a70:	e3c330c0 	bic	r3, r3, #192	; 0xc0
 3f15a74:	e1a03803 	mov	r3, r3, lsl #16
 3f15a78:	e1a03823 	mov	r3, r3, lsr #16
 3f15a7c:	ea000010 	b	3f15ac4 <MLC_RGB_MixMux+0x24c>
			                                        | FInsrt(MLC_RGB_MIXMUX_PRI, BF_MLC_STL4_MIXMUX));
		else if ( MixMux == MLC_RGB_MIXMUX_CKEY )			// [7:6] <= 1
 3f15a80:	e3510001 	cmp	r1, #1	; 0x1
 3f15a84:	1a000007 	bne	3f15aa8 <MLC_RGB_MixMux+0x230>
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL4_MIXMUX ) 
 3f15a88:	e59f30ec 	ldr	r3, [pc, #ec]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15a8c:	e5932000 	ldr	r2, [r3]
 3f15a90:	e1d235bc 	ldrh	r3, [r2, #92]
 3f15a94:	e3c330c0 	bic	r3, r3, #192	; 0xc0
 3f15a98:	e1a03803 	mov	r3, r3, lsl #16
 3f15a9c:	e1a03823 	mov	r3, r3, lsr #16
 3f15aa0:	e3833040 	orr	r3, r3, #64	; 0x40
 3f15aa4:	ea000006 	b	3f15ac4 <MLC_RGB_MixMux+0x24c>
			                                        | FInsrt(MLC_RGB_MIXMUX_CKEY, BF_MLC_STL4_MIXMUX));
		else //if ( MixMux == MLC_RGB_MIXMUX_ALPHA )		// [7:6] <= 2
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL4_MIXMUX ) 
 3f15aa8:	e59f30cc 	ldr	r3, [pc, #cc]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15aac:	e5932000 	ldr	r2, [r3]
 3f15ab0:	e1d235bc 	ldrh	r3, [r2, #92]
 3f15ab4:	e3c330c0 	bic	r3, r3, #192	; 0xc0
 3f15ab8:	e1a03803 	mov	r3, r3, lsl #16
 3f15abc:	e1a03823 	mov	r3, r3, lsr #16
 3f15ac0:	e3833080 	orr	r3, r3, #128	; 0x80
 3f15ac4:	e1c235bc 	strh	r3, [r2, #92]
			                                        | FInsrt(MLC_RGB_MIXMUX_ALPHA, BF_MLC_STL4_MIXMUX));
		
		// Alpha 4
		MLC_REG->RGB_ALPHA_H = (U16)(( MLC_REG->RGB_ALPHA_H & ~MLC_STL4_ALPHA ) | FInsrt(Alpha,BF_MLC_STL4_ALPHA));
 3f15ac8:	e59f30ac 	ldr	r3, [pc, #ac]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15acc:	e5932000 	ldr	r2, [r3]
 3f15ad0:	e1d236b0 	ldrh	r3, [r2, #96]
 3f15ad4:	e3c3300f 	bic	r3, r3, #15	; 0xf
 3f15ad8:	e1a03803 	mov	r3, r3, lsl #16
 3f15adc:	e1a03823 	mov	r3, r3, lsr #16
 3f15ae0:	e183300c 	orr	r3, r3, r12
 3f15ae4:	e1c236b0 	strh	r3, [r2, #96]
	}
 3f15ae8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else //if ( rgnNum == MLC_RGB_RGN_5 )
	{
		// MixMux
		if ( MixMux == MLC_RGB_MIXMUX_PRI )				// [9:8] <= 0
 3f15aec:	e3510000 	cmp	r1, #0	; 0x0
 3f15af0:	1a000006 	bne	3f15b10 <MLC_RGB_MixMux+0x298>
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL5_MIXMUX ) 
 3f15af4:	e59f3080 	ldr	r3, [pc, #80]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15af8:	e5932000 	ldr	r2, [r3]
 3f15afc:	e1d235bc 	ldrh	r3, [r2, #92]
 3f15b00:	e3c33c03 	bic	r3, r3, #768	; 0x300
 3f15b04:	e1a03803 	mov	r3, r3, lsl #16
 3f15b08:	e1a03823 	mov	r3, r3, lsr #16
 3f15b0c:	ea000010 	b	3f15b54 <MLC_RGB_MixMux+0x2dc>
			                                        | FInsrt(MLC_RGB_MIXMUX_PRI, BF_MLC_STL5_MIXMUX));
		else if ( MixMux == MLC_RGB_MIXMUX_CKEY )			// [9:8] <= 1
 3f15b10:	e3510001 	cmp	r1, #1	; 0x1
 3f15b14:	1a000007 	bne	3f15b38 <MLC_RGB_MixMux+0x2c0>
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL5_MIXMUX ) 
 3f15b18:	e59f305c 	ldr	r3, [pc, #5c]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15b1c:	e5932000 	ldr	r2, [r3]
 3f15b20:	e1d235bc 	ldrh	r3, [r2, #92]
 3f15b24:	e3c33c03 	bic	r3, r3, #768	; 0x300
 3f15b28:	e1a03803 	mov	r3, r3, lsl #16
 3f15b2c:	e1a03823 	mov	r3, r3, lsr #16
 3f15b30:	e3833c01 	orr	r3, r3, #256	; 0x100
 3f15b34:	ea000006 	b	3f15b54 <MLC_RGB_MixMux+0x2dc>
			                                        | FInsrt(MLC_RGB_MIXMUX_CKEY, BF_MLC_STL5_MIXMUX));
		else //if ( MixMux == MLC_RGB_MIXMUX_ALPHA )		// [9:8] <= 2
			MLC_REG->RGB_MIXMUX = (U16)(( MLC_REG->RGB_MIXMUX & ~MLC_STL5_MIXMUX ) 
 3f15b38:	e59f303c 	ldr	r3, [pc, #3c]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15b3c:	e5932000 	ldr	r2, [r3]
 3f15b40:	e1d235bc 	ldrh	r3, [r2, #92]
 3f15b44:	e3c33c03 	bic	r3, r3, #768	; 0x300
 3f15b48:	e1a03803 	mov	r3, r3, lsl #16
 3f15b4c:	e1a03823 	mov	r3, r3, lsr #16
 3f15b50:	e3833c02 	orr	r3, r3, #512	; 0x200
 3f15b54:	e1c235bc 	strh	r3, [r2, #92]
			                                        | FInsrt(MLC_RGB_MIXMUX_ALPHA, BF_MLC_STL5_MIXMUX));
		
		// Alpha 5
		MLC_REG->RGB_ALPHA_H = (U16)(( MLC_REG->RGB_ALPHA_H & ~MLC_STL5_ALPHA ) | FInsrt(Alpha,BF_MLC_STL5_ALPHA));
 3f15b58:	e59f301c 	ldr	r3, [pc, #1c]	; 3f15b7c <MLC_RGB_MixMux+0x304>
 3f15b5c:	e5932000 	ldr	r2, [r3]
 3f15b60:	e1d236b0 	ldrh	r3, [r2, #96]
 3f15b64:	e3c330f0 	bic	r3, r3, #240	; 0xf0
 3f15b68:	e1a03803 	mov	r3, r3, lsl #16
 3f15b6c:	e1a03823 	mov	r3, r3, lsr #16
 3f15b70:	e183320c 	orr	r3, r3, r12, lsl #4
 3f15b74:	e1c236b0 	strh	r3, [r2, #96]
	}
 3f15b78:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f15b7c:	03f72fac 	mvneqs	r2, #688	; 0x2b0

03f15b80 <MLC_RGB_SetScale>:
 3f15b80:	e1a0c00d 	mov	r12, r13
 3f15b84:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f15b88:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void MLC_RGB_SetScale(U16 SrcPixWidth, U16 SrcPixHeight, U16 SrcStride, U16 DestPixWidth, U16 DestPixHeight)
{
 3f15b8c:	e1a00800 	mov	r0, r0, lsl #16
 3f15b90:	e1a00820 	mov	r0, r0, lsr #16
 3f15b94:	e1a01801 	mov	r1, r1, lsl #16
 3f15b98:	e1a06821 	mov	r6, r1, lsr #16
 3f15b9c:	e1a02802 	mov	r2, r2, lsl #16
 3f15ba0:	e1a07822 	mov	r7, r2, lsr #16
 3f15ba4:	e1a03803 	mov	r3, r3, lsl #16
	U32	hScale, vScale;

	if(DestPixWidth)	hScale = (U32) ( ( SrcPixWidth * 1024 ) / DestPixWidth );
 3f15ba8:	e1b01823 	movs	r1, r3, lsr #16
 3f15bac:	e1db40b4 	ldrh	r4, [r11, #4]
 3f15bb0:	0a000003 	beq	3f15bc4 <MLC_RGB_SetScale+0x44>
 3f15bb4:	e1a00500 	mov	r0, r0, lsl #10
 3f15bb8:	eb0012a0 	bl	3f1a640 <__divsi3>
 3f15bbc:	e1a05000 	mov	r5, r0
 3f15bc0:	ea000000 	b	3f15bc8 <MLC_RGB_SetScale+0x48>
	else				hScale = 0;
 3f15bc4:	e1a05001 	mov	r5, r1
	if (DestPixHeight)	vScale = (U32) ( ( SrcPixHeight * SrcStride ) / DestPixHeight );
 3f15bc8:	e3540000 	cmp	r4, #0	; 0x0
 3f15bcc:	0a000003 	beq	3f15be0 <MLC_RGB_SetScale+0x60>
 3f15bd0:	e0000697 	mul	r0, r7, r6
 3f15bd4:	e1a01004 	mov	r1, r4
 3f15bd8:	eb001298 	bl	3f1a640 <__divsi3>
 3f15bdc:	ea000000 	b	3f15be4 <MLC_RGB_SetScale+0x64>
	else				vScale = 0;
 3f15be0:	e1a00004 	mov	r0, r4
		
	MLC_REG->RGB_HSC = (U16)(hScale & 0xffff);
 3f15be4:	e59f3018 	ldr	r3, [pc, #18]	; 3f15c04 <MLC_RGB_SetScale+0x84>
 3f15be8:	e5933000 	ldr	r3, [r3]
 3f15bec:	e1c358b6 	strh	r5, [r3, #134]
	MLC_REG->RGB_VSC_L = (U16)(vScale & 0xffff);
 3f15bf0:	e1c308b8 	strh	r0, [r3, #136]
	MLC_REG->RGB_VSC_H = (U16)(vScale >> 16);
 3f15bf4:	e1a02820 	mov	r2, r0, lsr #16
 3f15bf8:	e1c328ba 	strh	r2, [r3, #138]
	MLC_REG->RGB_HW = (U16)(SrcStride);
 3f15bfc:	e1c378bc 	strh	r7, [r3, #140]
}
 3f15c00:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f15c04:	03f72fac 	mvneqs	r2, #688	; 0x2b0

03f15c08 <MLC_RGB_SetActivate>:
 3f15c08:	e1a0c00d 	mov	r12, r13
 3f15c0c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f15c10:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
void MLC_RGB_SetActivate(U8 rgnNum, U8 Activate)
{	
	U16	Act;
	
	// Activate
	if ( Activate == MLC_RGB_RGN_ACT )	Act = 0x1;
 3f15c14:	e31100ff 	tst	r1, #255	; 0xff
 3f15c18:	13a01000 	movne	r1, #0	; 0x0
 3f15c1c:	03a01001 	moveq	r1, #1	; 0x1
	else								Act = 0x0;	// if ( Activate == MLC_RGB_RGN_DISACT )
		
	if ( rgnNum == MLC_RGB_RGN_1 )
 3f15c20:	e21000ff 	ands	r0, r0, #255	; 0xff
 3f15c24:	1a00000a 	bne	3f15c54 <MLC_RGB_SetActivate+0x4c>
	{
		MLC_REG->RGB_CNTL = (U16)(( MLC_REG->RGB_CNTL & ~MLC_STL1ACT ) | (Act<<0) | 0xaa);
 3f15c28:	e59f30e8 	ldr	r3, [pc, #e8]	; 3f15d18 <MLC_RGB_SetActivate+0x110>
 3f15c2c:	e5932000 	ldr	r2, [r3]
 3f15c30:	e1d235ba 	ldrh	r3, [r2, #90]
 3f15c34:	e3510000 	cmp	r1, #0	; 0x0
 3f15c38:	e3c33001 	bic	r3, r3, #1	; 0x1
 3f15c3c:	e1a03803 	mov	r3, r3, lsl #16
 3f15c40:	e1a03823 	mov	r3, r3, lsr #16
 3f15c44:	138330ab 	orrne	r3, r3, #171	; 0xab
 3f15c48:	038330aa 	orreq	r3, r3, #170	; 0xaa
 3f15c4c:	e1c235ba 	strh	r3, [r2, #90]
	}
 3f15c50:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else if ( rgnNum == MLC_RGB_RGN_2 )
 3f15c54:	e3500001 	cmp	r0, #1	; 0x1
 3f15c58:	1a00000a 	bne	3f15c88 <MLC_RGB_SetActivate+0x80>
	{
		MLC_REG->RGB_CNTL = (U16)(( MLC_REG->RGB_CNTL & ~MLC_STL2ACT ) | (Act<<2) | 0xaa);
 3f15c5c:	e59f30b4 	ldr	r3, [pc, #b4]	; 3f15d18 <MLC_RGB_SetActivate+0x110>
 3f15c60:	e5932000 	ldr	r2, [r3]
 3f15c64:	e1d235ba 	ldrh	r3, [r2, #90]
 3f15c68:	e3510000 	cmp	r1, #0	; 0x0
 3f15c6c:	e3c33004 	bic	r3, r3, #4	; 0x4
 3f15c70:	e1a03803 	mov	r3, r3, lsl #16
 3f15c74:	e1a03823 	mov	r3, r3, lsr #16
 3f15c78:	138330ae 	orrne	r3, r3, #174	; 0xae
 3f15c7c:	038330aa 	orreq	r3, r3, #170	; 0xaa
 3f15c80:	e1c235ba 	strh	r3, [r2, #90]
	}
 3f15c84:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else if ( rgnNum == MLC_RGB_RGN_3 )
 3f15c88:	e3500002 	cmp	r0, #2	; 0x2
 3f15c8c:	1a00000a 	bne	3f15cbc <MLC_RGB_SetActivate+0xb4>
	{
		MLC_REG->RGB_CNTL = (U16)(( MLC_REG->RGB_CNTL & ~MLC_STL3ACT ) | (Act<<4) | 0xaa);
 3f15c90:	e59f3080 	ldr	r3, [pc, #80]	; 3f15d18 <MLC_RGB_SetActivate+0x110>
 3f15c94:	e5932000 	ldr	r2, [r3]
 3f15c98:	e1d235ba 	ldrh	r3, [r2, #90]
 3f15c9c:	e3510000 	cmp	r1, #0	; 0x0
 3f15ca0:	e3c33010 	bic	r3, r3, #16	; 0x10
 3f15ca4:	e1a03803 	mov	r3, r3, lsl #16
 3f15ca8:	e1a03823 	mov	r3, r3, lsr #16
 3f15cac:	138330ba 	orrne	r3, r3, #186	; 0xba
 3f15cb0:	038330aa 	orreq	r3, r3, #170	; 0xaa
 3f15cb4:	e1c235ba 	strh	r3, [r2, #90]
	}
 3f15cb8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else if ( rgnNum == MLC_RGB_RGN_4 )
 3f15cbc:	e3500003 	cmp	r0, #3	; 0x3
 3f15cc0:	1a00000a 	bne	3f15cf0 <MLC_RGB_SetActivate+0xe8>
	{
		MLC_REG->RGB_CNTL = (U16)(( MLC_REG->RGB_CNTL & ~MLC_STL4ACT ) | (Act<<6) | 0xaa);
 3f15cc4:	e59f304c 	ldr	r3, [pc, #4c]	; 3f15d18 <MLC_RGB_SetActivate+0x110>
 3f15cc8:	e5932000 	ldr	r2, [r3]
 3f15ccc:	e1d235ba 	ldrh	r3, [r2, #90]
 3f15cd0:	e3510000 	cmp	r1, #0	; 0x0
 3f15cd4:	e3c33040 	bic	r3, r3, #64	; 0x40
 3f15cd8:	e1a03803 	mov	r3, r3, lsl #16
 3f15cdc:	e1a03823 	mov	r3, r3, lsr #16
 3f15ce0:	138330ea 	orrne	r3, r3, #234	; 0xea
 3f15ce4:	038330aa 	orreq	r3, r3, #170	; 0xaa
 3f15ce8:	e1c235ba 	strh	r3, [r2, #90]
	}
 3f15cec:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else	// if ( rgnNum == MLC_RGB_RGN_5 )
	{
		MLC_REG->RGB_CNTL = (U16)(( MLC_REG->RGB_CNTL & ~MLC_STL5ACT ) | (Act<<8) | 0xaa);
 3f15cf0:	e59f3020 	ldr	r3, [pc, #20]	; 3f15d18 <MLC_RGB_SetActivate+0x110>
 3f15cf4:	e5932000 	ldr	r2, [r3]
 3f15cf8:	e1d235ba 	ldrh	r3, [r2, #90]
 3f15cfc:	e3c33c01 	bic	r3, r3, #256	; 0x100
 3f15d00:	e1a03803 	mov	r3, r3, lsl #16
 3f15d04:	e1a03823 	mov	r3, r3, lsr #16
 3f15d08:	e1833401 	orr	r3, r3, r1, lsl #8
 3f15d0c:	e38330aa 	orr	r3, r3, #170	; 0xaa
 3f15d10:	e1c235ba 	strh	r3, [r2, #90]
	}
}
 3f15d14:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f15d18:	03f72fac 	mvneqs	r2, #688	; 0x2b0

03f15d1c <MLC_RGB_SetCoord>:
 3f15d1c:	e1a0c00d 	mov	r12, r13
 3f15d20:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f15d24:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
void MLC_RGB_SetCoord(U8 rgnNum,	U16 StarX, U16 EndX, U16 StartY, U16 EndY)
{
 3f15d28:	e1a01801 	mov	r1, r1, lsl #16
 3f15d2c:	e1a01821 	mov	r1, r1, lsr #16
 3f15d30:	e1a02802 	mov	r2, r2, lsl #16
 3f15d34:	e1a0c822 	mov	r12, r2, lsr #16
 3f15d38:	e1a03803 	mov	r3, r3, lsl #16
 3f15d3c:	e1a0e823 	mov	r14, r3, lsr #16
	if ( rgnNum == MLC_RGB_RGN_1 )
 3f15d40:	e21000ff 	ands	r0, r0, #255	; 0xff
 3f15d44:	e1db40b4 	ldrh	r4, [r11, #4]
 3f15d48:	1a000008 	bne	3f15d70 <MLC_RGB_SetCoord+0x54>
	{
		MLC_REG->RGB1_STX = StarX;
 3f15d4c:	e59f30a0 	ldr	r3, [pc, #a0]	; 3f15df4 <MLC_RGB_SetCoord+0xd8>
 3f15d50:	e5932000 	ldr	r2, [r3]
 3f15d54:	e1c216b2 	strh	r1, [r2, #98]
		MLC_REG->RGB1_ENDX = EndX - 1;
 3f15d58:	e24c3001 	sub	r3, r12, #1	; 0x1
 3f15d5c:	e1c236b4 	strh	r3, [r2, #100]
		MLC_REG->RGB1_STY = StartY;
 3f15d60:	e1c2e6b6 	strh	r14, [r2, #102]
		MLC_REG->RGB1_ENDY = EndY - 1;
 3f15d64:	e2443001 	sub	r3, r4, #1	; 0x1
 3f15d68:	e1c236b8 	strh	r3, [r2, #104]
	}
 3f15d6c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
	else if ( rgnNum == MLC_RGB_RGN_2 )
 3f15d70:	e3500001 	cmp	r0, #1	; 0x1
 3f15d74:	1a000008 	bne	3f15d9c <MLC_RGB_SetCoord+0x80>
	{
		MLC_REG->RGB2_STX = StarX;
 3f15d78:	e59f3074 	ldr	r3, [pc, #74]	; 3f15df4 <MLC_RGB_SetCoord+0xd8>
 3f15d7c:	e5932000 	ldr	r2, [r3]
 3f15d80:	e1c216ba 	strh	r1, [r2, #106]
		MLC_REG->RGB2_ENDX = EndX - 1;
 3f15d84:	e24c3001 	sub	r3, r12, #1	; 0x1
 3f15d88:	e1c236bc 	strh	r3, [r2, #108]
		MLC_REG->RGB2_STY = StartY;
 3f15d8c:	e1c2e6be 	strh	r14, [r2, #110]
		MLC_REG->RGB2_ENDY = EndY - 1;
 3f15d90:	e2443001 	sub	r3, r4, #1	; 0x1
 3f15d94:	e1c237b0 	strh	r3, [r2, #112]
	}
 3f15d98:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
	else if ( rgnNum == MLC_RGB_RGN_3 )
 3f15d9c:	e3500002 	cmp	r0, #2	; 0x2
 3f15da0:	1a000008 	bne	3f15dc8 <MLC_RGB_SetCoord+0xac>
	{
		MLC_REG->RGB3_STX = StarX;
 3f15da4:	e59f3048 	ldr	r3, [pc, #48]	; 3f15df4 <MLC_RGB_SetCoord+0xd8>
 3f15da8:	e5932000 	ldr	r2, [r3]
 3f15dac:	e1c217b2 	strh	r1, [r2, #114]
		MLC_REG->RGB3_ENDX = EndX - 1;
 3f15db0:	e24c3001 	sub	r3, r12, #1	; 0x1
 3f15db4:	e1c237b4 	strh	r3, [r2, #116]
		MLC_REG->RGB3_STY = StartY;
 3f15db8:	e1c2e7b6 	strh	r14, [r2, #118]
		MLC_REG->RGB3_ENDY = EndY - 1;
 3f15dbc:	e2443001 	sub	r3, r4, #1	; 0x1
 3f15dc0:	e1c237b8 	strh	r3, [r2, #120]
	}
 3f15dc4:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
	else if ( rgnNum == MLC_RGB_RGN_4 )
 3f15dc8:	e3500003 	cmp	r0, #3	; 0x3
 3f15dcc:	191ba810 	ldmnedb	r11, {r4, r11, r13, r15}
	{
		MLC_REG->RGB4_STX = StarX;
 3f15dd0:	e59f301c 	ldr	r3, [pc, #1c]	; 3f15df4 <MLC_RGB_SetCoord+0xd8>
 3f15dd4:	e5932000 	ldr	r2, [r3]
 3f15dd8:	e1c217ba 	strh	r1, [r2, #122]
		MLC_REG->RGB4_ENDX = EndX - 1;
 3f15ddc:	e24c3001 	sub	r3, r12, #1	; 0x1
 3f15de0:	e1c237bc 	strh	r3, [r2, #124]
		MLC_REG->RGB4_STY = StartY;
 3f15de4:	e1c2e7be 	strh	r14, [r2, #126]
		MLC_REG->RGB4_ENDY = EndY - 1;
 3f15de8:	e2443001 	sub	r3, r4, #1	; 0x1
 3f15dec:	e1c238b0 	strh	r3, [r2, #128]
	}
 3f15df0:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f15df4:	03f72fac 	mvneqs	r2, #688	; 0x2b0

03f15df8 <MLC_RGB_SetAddress>:
 3f15df8:	e1a0c00d 	mov	r12, r13
 3f15dfc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	else	// if ( rgnNum == MLC_RGB_RGN_5 )
	{
		//ds_printk("rgb_region_number_error?\n");		
	}
}
//[*]----------------------------------------------------------------------------------------------------[*]
void MLC_RGB_SetAddress	(U32 OddAddr, U32 EvenAddr)
{
	MLC_REG->RGB_OADR_L = (U16)(OddAddr & 0xffff);
 3f15e00:	e59f3020 	ldr	r3, [pc, #20]	; 3f15e28 <MLC_RGB_SetAddress+0x30>
 3f15e04:	e5933000 	ldr	r3, [r3]
 3f15e08:	e1c308be 	strh	r0, [r3, #142]
	MLC_REG->RGB_OADR_H = (U16)(OddAddr >> 16);
 3f15e0c:	e1a00820 	mov	r0, r0, lsr #16
 3f15e10:	e1c309b0 	strh	r0, [r3, #144]
 3f15e14:	e24cb004 	sub	r11, r12, #4	; 0x4
	MLC_REG->RGB_EADR_L = (U16)(EvenAddr & 0xffff);
 3f15e18:	e1c319b2 	strh	r1, [r3, #146]
	MLC_REG->RGB_EADR_H = (U16)(EvenAddr >> 16);
 3f15e1c:	e1a01821 	mov	r1, r1, lsr #16
 3f15e20:	e1c319b4 	strh	r1, [r3, #148]
 3f15e24:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f15e28:	03f72fac 	mvneqs	r2, #688	; 0x2b0

03f15e2c <MLC_RGB_SetColorKey>:
 3f15e2c:	e1a0c00d 	mov	r12, r13
 3f15e30:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f15e34:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void MLC_RGB_SetColorKey(U8 rColorKey, U8 gColorKey, U8 bColorKey)
{
 3f15e38:	e20000ff 	and	r0, r0, #255	; 0xff
 3f15e3c:	e1a01401 	mov	r1, r1, lsl #8
	MLC_REG->RGB_CKEY_R = (U16)(rColorKey);
 3f15e40:	e59f3018 	ldr	r3, [pc, #18]	; 3f15e60 <MLC_RGB_SetColorKey+0x34>
 3f15e44:	e20220ff 	and	r2, r2, #255	; 0xff
 3f15e48:	e5933000 	ldr	r3, [r3]
	MLC_REG->RGB_CKEY_GB = (U16)FInsrt(gColorKey, BF_MLC_STL_CKEYG) | (U16)(bColorKey);
 3f15e4c:	e2011cff 	and	r1, r1, #65280	; 0xff00
 3f15e50:	e1c308b4 	strh	r0, [r3, #132]
 3f15e54:	e1811002 	orr	r1, r1, r2
 3f15e58:	e1c318b2 	strh	r1, [r3, #130]
 3f15e5c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f15e60:	03f72fac 	mvneqs	r2, #688	; 0x2b0

03f15e64 <MLC_RGB_SetBPP>:
 3f15e64:	e1a0c00d 	mov	r12, r13
 3f15e68:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f15e6c:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void MLC_RGB_SetBPP(U8 BPP)
{
	// BPP
	
	if(BPP == MLC_RGB_4BPP)			MLC_REG->RGB_CNTL = (U16)(( MLC_REG->RGB_CNTL & ~MLC_STL_BPP ) | FInsrt(MLC_RGB_4BPP, BF_MLC_STL_BPP));	// [10:9] <= 0
 3f15e70:	e21000ff 	ands	r0, r0, #255	; 0xff
 3f15e74:	1a000007 	bne	3f15e98 <MLC_RGB_SetBPP+0x34>
 3f15e78:	e59f3088 	ldr	r3, [pc, #88]	; 3f15f08 <MLC_RGB_SetBPP+0xa4>
 3f15e7c:	e5932000 	ldr	r2, [r3]
 3f15e80:	e1d235ba 	ldrh	r3, [r2, #90]
 3f15e84:	e3c33c06 	bic	r3, r3, #1536	; 0x600
 3f15e88:	e1a03803 	mov	r3, r3, lsl #16
 3f15e8c:	e1a03823 	mov	r3, r3, lsr #16
 3f15e90:	e1c235ba 	strh	r3, [r2, #90]
 3f15e94:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else if(BPP == MLC_RGB_8BPP)	MLC_REG->RGB_CNTL = (U16)(( MLC_REG->RGB_CNTL & ~MLC_STL_BPP ) | FInsrt(MLC_RGB_8BPP, BF_MLC_STL_BPP));	// [10:9] <= 1
 3f15e98:	e3500001 	cmp	r0, #1	; 0x1
 3f15e9c:	1a000008 	bne	3f15ec4 <MLC_RGB_SetBPP+0x60>
 3f15ea0:	e59f3060 	ldr	r3, [pc, #60]	; 3f15f08 <MLC_RGB_SetBPP+0xa4>
 3f15ea4:	e5932000 	ldr	r2, [r3]
 3f15ea8:	e1d235ba 	ldrh	r3, [r2, #90]
 3f15eac:	e3c33c06 	bic	r3, r3, #1536	; 0x600
 3f15eb0:	e1a03803 	mov	r3, r3, lsl #16
 3f15eb4:	e1a03823 	mov	r3, r3, lsr #16
 3f15eb8:	e3833c02 	orr	r3, r3, #512	; 0x200
 3f15ebc:	e1c235ba 	strh	r3, [r2, #90]
 3f15ec0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else if(BPP == MLC_RGB_16BPP)	MLC_REG->RGB_CNTL = (U16)(( MLC_REG->RGB_CNTL & ~MLC_STL_BPP ) | FInsrt(MLC_RGB_16BPP, BF_MLC_STL_BPP));	// [10:9] <= 2
 3f15ec4:	e3500002 	cmp	r0, #2	; 0x2
 3f15ec8:	1a000008 	bne	3f15ef0 <MLC_RGB_SetBPP+0x8c>
 3f15ecc:	e59f3034 	ldr	r3, [pc, #34]	; 3f15f08 <MLC_RGB_SetBPP+0xa4>
 3f15ed0:	e5932000 	ldr	r2, [r3]
 3f15ed4:	e1d235ba 	ldrh	r3, [r2, #90]
 3f15ed8:	e3c33c06 	bic	r3, r3, #1536	; 0x600
 3f15edc:	e1a03803 	mov	r3, r3, lsl #16
 3f15ee0:	e1a03823 	mov	r3, r3, lsr #16
 3f15ee4:	e3833b01 	orr	r3, r3, #1024	; 0x400
 3f15ee8:	e1c235ba 	strh	r3, [r2, #90]
 3f15eec:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	else 							MLC_REG->RGB_CNTL = (U16)(( MLC_REG->RGB_CNTL & ~MLC_STL_BPP ) | FInsrt(MLC_RGB_24BPP, BF_MLC_STL_BPP));	// [10:9] <= 3
 3f15ef0:	e59f3010 	ldr	r3, [pc, #10]	; 3f15f08 <MLC_RGB_SetBPP+0xa4>
 3f15ef4:	e5932000 	ldr	r2, [r3]
 3f15ef8:	e1d235ba 	ldrh	r3, [r2, #90]
 3f15efc:	e3833c06 	orr	r3, r3, #1536	; 0x600
 3f15f00:	e1c235ba 	strh	r3, [r2, #90]
 3f15f04:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f15f08:	03f72fac 	mvneqs	r2, #688	; 0x2b0

03f15f0c <MLC_RGBOn>:
 3f15f0c:	e1a0c00d 	mov	r12, r13
 3f15f10:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f15f14:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
void MLC_RGBOn (U8 RegionNr)
{
	MLC_REG->OVLAY_CNTR = (U16)(MLC_REG->OVLAY_CNTR | (1<<(RegionNr+2)));
 3f15f18:	e59f301c 	ldr	r3, [pc, #1c]	; 3f15f3c <MLC_RGBOn+0x30>
 3f15f1c:	e20000ff 	and	r0, r0, #255	; 0xff
 3f15f20:	e5931000 	ldr	r1, [r3]
 3f15f24:	e2800002 	add	r0, r0, #2	; 0x2
 3f15f28:	e1d130b0 	ldrh	r3, [r1]
 3f15f2c:	e3a02001 	mov	r2, #1	; 0x1
 3f15f30:	e1833012 	orr	r3, r3, r2, lsl r0
 3f15f34:	e1c130b0 	strh	r3, [r1]
 3f15f38:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f15f3c:	03f72fac 	mvneqs	r2, #688	; 0x2b0

03f15f40 <MLC_Util_RGB>:
 3f15f40:	e1a0c00d 	mov	r12, r13
 3f15f44:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f15f48:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f15f4c:	e24dd030 	sub	r13, r13, #48	; 0x30
	//ds_printk("OVLAY_CNTR = 0x%04x\n", MLC_REG->OVLAY_CNTR);	
}
//[*]----------------------------------------------------------------------------------------------------[*]
void MLC_Util_RGB
(
	U8	RGBRegionNO, 	//MLC_RGB_RGN_1 ~ MLC_RGB_RGN_5
	U8	bpp,			// MLC_RGB_4BPP, MLC_RGB_8BPP, MLC_RGB_16BPP, MLC_RGB_24BPP
	U8	AlphaCkey,		// MLC_RGB_MIXMUX_PRI, MLC_RGB_MIXMUX_CKEY, MLC_RGB_MIXMUX_ALPHA
	U8	AlphaValue,		// 0 ~ 15
	U8	CkeyR, U8 CkeyG, U8 CkeyB,
	U16	StartX, U16 StartY, U16 EndX, U16 EndY,
	U16 SrcWidth, U16 SrcHeight, U16 DstWidth, U16 DstHeight, U16 Stride,
	U32 addr
)
{
 3f15f50:	e59bc014 	ldr	r12, [r11, #20]
 3f15f54:	e59be01c 	ldr	r14, [r11, #28]
 3f15f58:	e59b6024 	ldr	r6, [r11, #36]
 3f15f5c:	e1a04001 	mov	r4, r1
 3f15f60:	e59b102c 	ldr	r1, [r11, #44]
 3f15f64:	e50b3028 	str	r3, [r11, -#40]
 3f15f68:	e5db3004 	ldrb	r3, [r11, #4]
 3f15f6c:	e5db700c 	ldrb	r7, [r11, #12]
 3f15f70:	e50b302c 	str	r3, [r11, -#44]
 3f15f74:	e5db3008 	ldrb	r3, [r11, #8]
 3f15f78:	e1a0c80c 	mov	r12, r12, lsl #16
 3f15f7c:	e50bc038 	str	r12, [r11, -#56]
 3f15f80:	e1dbc1b8 	ldrh	r12, [r11, #24]
 3f15f84:	e1a0e80e 	mov	r14, r14, lsl #16
 3f15f88:	e50be040 	str	r14, [r11, -#64]
 3f15f8c:	e1dbe2b0 	ldrh	r14, [r11, #32]
 3f15f90:	e1a01801 	mov	r1, r1, lsl #16
 3f15f94:	e50b104c 	str	r1, [r11, -#76]
 3f15f98:	e50b3030 	str	r3, [r11, -#48]
 3f15f9c:	e1db31b0 	ldrh	r3, [r11, #16]
 3f15fa0:	e50bc03c 	str	r12, [r11, -#60]
 3f15fa4:	e50be044 	str	r14, [r11, -#68]
 3f15fa8:	e1a05002 	mov	r5, r2
 3f15fac:	e1dbc3b0 	ldrh	r12, [r11, #48]
 3f15fb0:	e20090ff 	and	r9, r0, #255	; 0xff
 3f15fb4:	e50b3034 	str	r3, [r11, -#52]
 3f15fb8:	e20440ff 	and	r4, r4, #255	; 0xff
 3f15fbc:	e1db32b8 	ldrh	r3, [r11, #40]
 3f15fc0:	e20550ff 	and	r5, r5, #255	; 0xff
 3f15fc4:	e50bc050 	str	r12, [r11, -#80]
 3f15fc8:	e1a0a806 	mov	r10, r6, lsl #16
 3f15fcc:	e50b3048 	str	r3, [r11, -#72]
	U8	Interlace;		// 0:Progressive, 1:Interlace

	DPC_Initialize();
 3f15fd0:	ebfffe16 	bl	3f15830 <DPC_Initialize>
	
	if(DPC->DPC_CNTL & INTERLACE)		Interlace = 1;		// Interlace mode
 3f15fd4:	e59f3098 	ldr	r3, [pc, #98]	; 3f16074 <MLC_Util_RGB+0x134>
 3f15fd8:	e5933000 	ldr	r3, [r3]
 3f15fdc:	e1d330b0 	ldrh	r3, [r3]
 3f15fe0:	e3130020 	tst	r3, #32	; 0x20
 3f15fe4:	03a06000 	moveq	r6, #0	; 0x0
 3f15fe8:	13a06001 	movne	r6, #1	; 0x1
	else								Interlace = 0;		// Not Interlace mode

	MLC_Initialize();
 3f15fec:	ebfffe18 	bl	3f15854 <MLC_Initialize>
	
	MLC_RGB_SetBPP( bpp );
 3f15ff0:	e1a00004 	mov	r0, r4
 3f15ff4:	ebffff9a 	bl	3f15e64 <MLC_RGB_SetBPP>
	MLC_RGB_SetColorKey(CkeyR, CkeyG, CkeyB);
 3f15ff8:	e51b002c 	ldr	r0, [r11, -#44]
 3f15ffc:	e51b1030 	ldr	r1, [r11, -#48]
 3f16000:	e1a02007 	mov	r2, r7
 3f16004:	ebffff88 	bl	3f15e2c <MLC_RGB_SetColorKey>

	MLC_RGB_MixMux(RGBRegionNO, AlphaCkey, AlphaValue & 0xf);
 3f16008:	e1a00009 	mov	r0, r9
 3f1600c:	e51be028 	ldr	r14, [r11, -#40]
 3f16010:	e1a01005 	mov	r1, r5
 3f16014:	e20e200f 	and	r2, r14, #15	; 0xf
 3f16018:	ebfffe16 	bl	3f15878 <MLC_RGB_MixMux>
 3f1601c:	e51b3038 	ldr	r3, [r11, -#56]

	if(Interlace == 0) 
 3f16020:	e3560000 	cmp	r6, #0	; 0x0
 3f16024:	e51bc040 	ldr	r12, [r11, -#64]
 3f16028:	e1a0482a 	mov	r4, r10, lsr #16
 3f1602c:	e51be04c 	ldr	r14, [r11, -#76]
 3f16030:	e1a06823 	mov	r6, r3, lsr #16
 3f16034:	e1a0782c 	mov	r7, r12, lsr #16
 3f16038:	e1a0582e 	mov	r5, r14, lsr #16
 3f1603c:	1a00000d 	bne	3f16078 <MLC_Util_RGB+0x138>
	{
		MLC_RGB_SetScale(SrcWidth, SrcHeight, Stride, DstWidth, DstHeight);
 3f16040:	e51b0044 	ldr	r0, [r11, -#68]
 3f16044:	e51b2050 	ldr	r2, [r11, -#80]
 3f16048:	e51b3048 	ldr	r3, [r11, -#72]
 3f1604c:	e1a01004 	mov	r1, r4
 3f16050:	e58d5000 	str	r5, [r13]
 3f16054:	ebfffec9 	bl	3f15b80 <MLC_RGB_SetScale>
		MLC_RGB_SetCoord(RGBRegionNO, StartX, EndX, StartY, EndY);
 3f16058:	e51b1034 	ldr	r1, [r11, -#52]
 3f1605c:	e1a00009 	mov	r0, r9
 3f16060:	e51b203c 	ldr	r2, [r11, -#60]
 3f16064:	e1a03006 	mov	r3, r6
 3f16068:	e58d7000 	str	r7, [r13]
 3f1606c:	ebffff2a 	bl	3f15d1c <MLC_RGB_SetCoord>
	}
 3f16070:	ea000013 	b	3f160c4 <MLC_Util_RGB+0x184>
 3f16074:	03f72fa4 	mvneqs	r2, #656	; 0x290
	else	// if(Interlace == 1)  
	{	
		MLC_RGB_SetScale(SrcWidth, SrcHeight/2, 2*Stride, DstWidth, DstHeight/2);
 3f16078:	e51b0044 	ldr	r0, [r11, -#68]
 3f1607c:	e51b3050 	ldr	r3, [r11, -#80]
 3f16080:	e1a018aa 	mov	r1, r10, lsr #17
 3f16084:	e51be04c 	ldr	r14, [r11, -#76]
 3f16088:	e1a02883 	mov	r2, r3, lsl #17
 3f1608c:	e1a02822 	mov	r2, r2, lsr #16
 3f16090:	e51b3048 	ldr	r3, [r11, -#72]
 3f16094:	e1a0c8ae 	mov	r12, r14, lsr #17
 3f16098:	e58dc000 	str	r12, [r13]
 3f1609c:	ebfffeb7 	bl	3f15b80 <MLC_RGB_SetScale>
		MLC_RGB_SetCoord(RGBRegionNO, StartX, EndX, StartY/2, EndY/2);
 3f160a0:	e51b1034 	ldr	r1, [r11, -#52]
 3f160a4:	e24b203c 	sub	r2, r11, #60	; 0x3c
 3f160a8:	e8921004 	ldmia	r2, {r2, r12}
 3f160ac:	e1a00009 	mov	r0, r9
 3f160b0:	e51be040 	ldr	r14, [r11, -#64]
 3f160b4:	e1a038ac 	mov	r3, r12, lsr #17
 3f160b8:	e1a0c8ae 	mov	r12, r14, lsr #17
 3f160bc:	e58dc000 	str	r12, [r13]
 3f160c0:	ebffff15 	bl	3f15d1c <MLC_RGB_SetCoord>
	}
	
	MLC_RGB_SetActivate(RGBRegionNO, MLC_RGB_RGN_ACT);
 3f160c4:	e1a00009 	mov	r0, r9
 3f160c8:	e3a01000 	mov	r1, #0	; 0x0
 3f160cc:	ebfffecd 	bl	3f15c08 <MLC_RGB_SetActivate>
	MLC_RGB_SetAddress(addr, addr);
 3f160d0:	e59b0034 	ldr	r0, [r11, #52]
 3f160d4:	e1a01000 	mov	r1, r0
 3f160d8:	ebffff46 	bl	3f15df8 <MLC_RGB_SetAddress>
	MLC_RGBOn(RGBRegionNO);	
 3f160dc:	e1a00009 	mov	r0, r9
 3f160e0:	ebffff89 	bl	3f15f0c <MLC_RGBOn>
}
 3f160e4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f160e8 <init_lcd>:
 3f160e8:	e1a0c00d 	mov	r12, r13
 3f160ec:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f160f0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f160f4:	e24dd030 	sub	r13, r13, #48	; 0x30
//[*]----------------------------------------------------------------------------------------------------[*]
void init_lcd(void)
{
	tDispClkInfo ClkInfo;

    MLC_Initialize();
 3f160f8:	ebfffdd5 	bl	3f15854 <MLC_Initialize>
	DPC_Initialize();
 3f160fc:	ebfffdcb 	bl	3f15830 <DPC_Initialize>

    ClkInfo.DISPCLK_SOURCE  = 1;	// Use PLL Clock.
    ClkInfo.DISPCLK_DIVIDER = 32;	// 7;  //37;    //38;	//N=199.0656MHz / 5.23MHz = 38 @240x320 LCD	// 8;  // 25 Mhz @640x480 LCD
 3f16100:	e59f212c 	ldr	r2, [pc, #12c]	; 3f16234 <init_lcd+0x14c>
    ClkInfo.DISPCLK_POL = 0;     	// No Inversion..
 3f16104:	e15b31b6 	ldrh	r3, [r11, -#22]

    PMR_SetDispClk(&ClkInfo);
 3f16108:	e24b001c 	sub	r0, r11, #28	; 0x1c
 3f1610c:	e50b201c 	str	r2, [r11, -#28]
 3f16110:	e1a03803 	mov	r3, r3, lsl #16
 3f16114:	e50b3018 	str	r3, [r11, -#24]
 3f16118:	ebfffb17 	bl	3f14d7c <PMR_SetDispClk>

    DPC_InitHardware(DPC_RGB_666, CFALSE, CFALSE,CFALSE, 0, 0, DPC_USE_PLLCLK);
 3f1611c:	e3a05002 	mov	r5, #2	; 0x2
 3f16120:	e1a00005 	mov	r0, r5
 3f16124:	e3a04000 	mov	r4, #0	; 0x0
 3f16128:	e1a01004 	mov	r1, r4
 3f1612c:	e58d4000 	str	r4, [r13]
 3f16130:	e1a02004 	mov	r2, r4
 3f16134:	e58d4004 	str	r4, [r13, #4]
 3f16138:	e1a03004 	mov	r3, r4
 3f1613c:	e58d5008 	str	r5, [r13, #8]
 3f16140:	ebfffc4e 	bl	3f15280 <DPC_InitHardware>

#if 0   
    DPC_UTIL_HVSYNC_GPX320240(DPC_RGB_666, LCD_WIDTH, LCD_HEIGHT,30, 20, 38, CFALSE,4, 15, 4,CFALSE 
								,CTRUE,CFALSE,CTRUE); 
#endif
    
    DPC_UTIL_HVSYNC_GPX320240(DPC_RGB_666, LCD_WIDTH,LCD_HEIGHT,30, 20, 38, CFALSE,4, 4, 15,CFALSE 
 3f16144:	e3a03014 	mov	r3, #20	; 0x14
 3f16148:	e58d3000 	str	r3, [r13]
 3f1614c:	e2833012 	add	r3, r3, #18	; 0x12
 3f16150:	e98d0018 	stmib	r13, {r3, r4}
 3f16154:	e2433022 	sub	r3, r3, #34	; 0x22
 3f16158:	e58d300c 	str	r3, [r13, #12]
 3f1615c:	e1a00005 	mov	r0, r5
 3f16160:	e58d3010 	str	r3, [r13, #16]
 3f16164:	e283300b 	add	r3, r3, #11	; 0xb
 3f16168:	e58d3014 	str	r3, [r13, #20]
 3f1616c:	e3a01d05 	mov	r1, #320	; 0x140
 3f16170:	e58d4018 	str	r4, [r13, #24]
 3f16174:	e3a0c001 	mov	r12, #1	; 0x1
 3f16178:	e58dc01c 	str	r12, [r13, #28]
 3f1617c:	e3a020f0 	mov	r2, #240	; 0xf0
 3f16180:	e58d4020 	str	r4, [r13, #32]
 3f16184:	e283300f 	add	r3, r3, #15	; 0xf
 3f16188:	e58dc024 	str	r12, [r13, #36]
 3f1618c:	ebfffbea 	bl	3f1513c <DPC_UTIL_HVSYNC_GPX320240>
								,CTRUE,CFALSE,CTRUE); 
								
    MLC_RGB_SetBPP(MLC_RGB_16BPP);
 3f16190:	e1a00005 	mov	r0, r5
 3f16194:	ebffff32 	bl	3f15e64 <MLC_RGB_SetBPP>
	MLC_RGB_SetColorKey(0xff, 0xff, 0xff);
 3f16198:	e3a000ff 	mov	r0, #255	; 0xff
 3f1619c:	e1a01000 	mov	r1, r0
 3f161a0:	e1a02000 	mov	r2, r0
 3f161a4:	ebffff20 	bl	3f15e2c <MLC_RGB_SetColorKey>
	MLC_RGB_MixMux(MLC_RGB_RGN_1, MLC_RGB_MIXMUX_PRI, 0x8 & 0xf);
 3f161a8:	e1a00004 	mov	r0, r4
 3f161ac:	e1a01004 	mov	r1, r4
 3f161b0:	e3a02008 	mov	r2, #8	; 0x8
 3f161b4:	ebfffdaf 	bl	3f15878 <MLC_RGB_MixMux>
	MLC_RGB_SetScale(LCD_WIDTH, LCD_HEIGHT, LCD_WIDTH*2, LCD_WIDTH, LCD_HEIGHT);
 3f161b8:	e3a00d05 	mov	r0, #320	; 0x140
 3f161bc:	e28550ee 	add	r5, r5, #238	; 0xee
 3f161c0:	e1a01005 	mov	r1, r5
 3f161c4:	e3a02d0a 	mov	r2, #640	; 0x280
 3f161c8:	e1a03000 	mov	r3, r0
 3f161cc:	e58d5000 	str	r5, [r13]
 3f161d0:	ebfffe6a 	bl	3f15b80 <MLC_RGB_SetScale>
	MLC_RGB_SetActivate(MLC_RGB_RGN_1, MLC_RGB_RGN_ACT);
 3f161d4:	e1a00004 	mov	r0, r4
 3f161d8:	e1a01004 	mov	r1, r4
 3f161dc:	ebfffe89 	bl	3f15c08 <MLC_RGB_SetActivate>
	MLC_RGB_SetCoord(MLC_RGB_RGN_1, PLANE_X_OFFSET, PLANE_X_OFFSET+PLANE_X_WIDTH, PLANE_Y_OFFSET, PLANE_Y_OFFSET+PLANE_Y_HEIGHT);
 3f161e0:	e1a00004 	mov	r0, r4
 3f161e4:	e1a01004 	mov	r1, r4
 3f161e8:	e3a02d05 	mov	r2, #320	; 0x140
 3f161ec:	e1a03004 	mov	r3, r4
 3f161f0:	e58d5000 	str	r5, [r13]
 3f161f4:	ebfffec8 	bl	3f15d1c <MLC_RGB_SetCoord>
	MLC_RGB_SetAddress((unsigned long)PA_FB0_BASE, (unsigned long)PA_FB0_BASE);
 3f161f8:	e3a00631 	mov	r0, #51380224	; 0x3100000
 3f161fc:	e1a01000 	mov	r1, r0
 3f16200:	ebfffefc 	bl	3f15df8 <MLC_RGB_SetAddress>
	MLC_RGBOn(MLC_RGB_RGN_1);
 3f16204:	e1a00004 	mov	r0, r4
 3f16208:	ebffff3f 	bl	3f15f0c <MLC_RGBOn>
	
	DPC->DPC_FPIATV1 = 0xffff;
 3f1620c:	e59f3024 	ldr	r3, [pc, #24]	; 3f16238 <init_lcd+0x150>
 3f16210:	e5932000 	ldr	r2, [r3]
 3f16214:	e3e03000 	mvn	r3, #0	; 0x0
 3f16218:	e1c230ba 	strh	r3, [r2, #10]
	DPC->DPC_FPIATV2 = 0xffff;
 3f1621c:	e1c230bc 	strh	r3, [r2, #12]
	DPC->DPC_FPIATV3 = 0xffff;
 3f16220:	e1c230be 	strh	r3, [r2, #14]
	DPC->DPC_CNTL |= ENB;
 3f16224:	e1d230b0 	ldrh	r3, [r2]
 3f16228:	e3833001 	orr	r3, r3, #1	; 0x1
 3f1622c:	e1c230b0 	strh	r3, [r2]
 3f16230:	ea000001 	b	3f1623c <init_lcd+0x154>
 3f16234:	00200001 	eoreq	r0, r0, r1
 3f16238:	03f72fa4 	mvneqs	r2, #656	; 0x290
	
	return;
}
 3f1623c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f16240 <show_logo>:
 3f16240:	e1a0c00d 	mov	r12, r13
 3f16244:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f16248:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
void show_logo(void)
{
	int x = 0;
 3f1624c:	e3a06000 	mov	r6, #0	; 0x0
	int y = 0;
	int i=0;
 3f16250:	e1a04006 	mov	r4, r6
	unsigned char r,g,b;
	unsigned char *fbaddr = (unsigned char*)PA_FB0_BASE;
 3f16254:	e3a05631 	mov	r5, #51380224	; 0x3100000
	
	
	init_lcd();
 3f16258:	ebffffa2 	bl	3f160e8 <init_lcd>
	
	for(y=0; y<240; y++) 
	{
		for(x=0; x<320; x++) 
 3f1625c:	e3a0cd05 	mov	r12, #320	; 0x140
		{
			
			r = gp2xlogo[i++];
 3f16260:	e59f304c 	ldr	r3, [pc, #4c]	; 3f162b4 <show_logo+0x74>
 3f16264:	e25cc001 	subs	r12, r12, #1	; 0x1
 3f16268:	e7d32004 	ldrb	r2, [r3, r4]
 3f1626c:	e2844001 	add	r4, r4, #1	; 0x1
			g = gp2xlogo[i++];
 3f16270:	e7d30004 	ldrb	r0, [r3, r4]
 3f16274:	e2844001 	add	r4, r4, #1	; 0x1
			b = gp2xlogo[i++];
 3f16278:	e7d33004 	ldrb	r3, [r3, r4]
 3f1627c:	e2844001 	add	r4, r4, #1	; 0x1
			
			fbaddr[0] = ((g & 0x1c) << 3) | ((b & 0xf8) >> 3);
 3f16280:	e200101c 	and	r1, r0, #28	; 0x1c
 3f16284:	e1a031a3 	mov	r3, r3, lsr #3
 3f16288:	e1833181 	orr	r3, r3, r1, lsl #3
			fbaddr[1] = (r & 0xf8) | (g & 0xe0) >> 5;
 3f1628c:	e20220f8 	and	r2, r2, #248	; 0xf8
 3f16290:	e5c53000 	strb	r3, [r5]
 3f16294:	e18222a0 	orr	r2, r2, r0, lsr #5
 3f16298:	e5c52001 	strb	r2, [r5, #1]
			fbaddr += 2;
 3f1629c:	e2855002 	add	r5, r5, #2	; 0x2
 3f162a0:	1affffee 	bne	3f16260 <show_logo+0x20>
 3f162a4:	e2866001 	add	r6, r6, #1	; 0x1
 3f162a8:	e35600ef 	cmp	r6, #239	; 0xef
 3f162ac:	daffffea 	ble	3f1625c <show_logo+0x1c>
		}
	}
}
 3f162b0:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f162b4:	03f21188 	mvneqs	r1, #34	; 0x22

03f162b8 <show_Firmware>:
 3f162b8:	e1a0c00d 	mov	r12, r13
 3f162bc:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f162c0:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
void show_Firmware(void)
{
	int x = 0;
 3f162c4:	e3a06000 	mov	r6, #0	; 0x0
	int y = 0;
	int i = 0;
 3f162c8:	e1a04006 	mov	r4, r6
	
	// 233x98
	int img_x = (320-233)/2;
	int img_y = (240-98)/2;
	
	unsigned char r,g,b;
	unsigned char *fbaddr = (unsigned char*)PA_FB0_BASE;
 3f162cc:	e3a05631 	mov	r5, #51380224	; 0x3100000
 3f162d0:	e3a0a02b 	mov	r10, #43	; 0x2b
 3f162d4:	e3a07047 	mov	r7, #71	; 0x47
	
	
	init_lcd();
 3f162d8:	ebffff82 	bl	3f160e8 <init_lcd>
	
	for(y=0; y<240; y++) 
	{
		for(x=0; x<320; x++) 
 3f162dc:	e3a0c000 	mov	r12, #0	; 0x0
		{
			//imgFirmware
			if((img_x<x && x<=img_x+233) && (img_y<y && y<=img_y+98))
 3f162e0:	e15a000c 	cmp	r10, r12
 3f162e4:	aa000014 	bge	3f1633c <show_Firmware+0x84>
 3f162e8:	e35c0f45 	cmp	r12, #276	; 0x114
 3f162ec:	ca000012 	bgt	3f1633c <show_Firmware+0x84>
 3f162f0:	e1570006 	cmp	r7, r6
 3f162f4:	aa000010 	bge	3f1633c <show_Firmware+0x84>
 3f162f8:	e35600a9 	cmp	r6, #169	; 0xa9
 3f162fc:	ca00000e 	bgt	3f1633c <show_Firmware+0x84>
			{
				r = imgFirmware[i++];
 3f16300:	e59f3060 	ldr	r3, [pc, #60]	; 3f16368 <show_Firmware+0xb0>
 3f16304:	e7d32004 	ldrb	r2, [r3, r4]
 3f16308:	e2844001 	add	r4, r4, #1	; 0x1
				g = imgFirmware[i++];
 3f1630c:	e7d30004 	ldrb	r0, [r3, r4]
 3f16310:	e2844001 	add	r4, r4, #1	; 0x1
				b = imgFirmware[i++];
 3f16314:	e7d33004 	ldrb	r3, [r3, r4]
 3f16318:	e2844001 	add	r4, r4, #1	; 0x1
				
				fbaddr[0] = ((g & 0x1c) << 3) | ((b & 0xf8) >> 3);
 3f1631c:	e200101c 	and	r1, r0, #28	; 0x1c
 3f16320:	e1a031a3 	mov	r3, r3, lsr #3
 3f16324:	e1833181 	orr	r3, r3, r1, lsl #3
				fbaddr[1] = (r & 0xf8) | (g & 0xe0) >> 5;
 3f16328:	e20220f8 	and	r2, r2, #248	; 0xf8
 3f1632c:	e5c53000 	strb	r3, [r5]
 3f16330:	e18222a0 	orr	r2, r2, r0, lsr #5
 3f16334:	e5c52001 	strb	r2, [r5, #1]
				fbaddr += 2;
			}
 3f16338:	ea000002 	b	3f16348 <show_Firmware+0x90>
			else
			{
				fbaddr[0] = fbaddr[1] = 0x00;
 3f1633c:	e3a03000 	mov	r3, #0	; 0x0
 3f16340:	e5c53001 	strb	r3, [r5, #1]
 3f16344:	e5c53000 	strb	r3, [r5]
				fbaddr += 2;
 3f16348:	e2855002 	add	r5, r5, #2	; 0x2
 3f1634c:	e28cc001 	add	r12, r12, #1	; 0x1
 3f16350:	e35c0d05 	cmp	r12, #320	; 0x140
 3f16354:	baffffe1 	blt	3f162e0 <show_Firmware+0x28>
 3f16358:	e2866001 	add	r6, r6, #1	; 0x1
 3f1635c:	e35600ef 	cmp	r6, #239	; 0xef
 3f16360:	daffffdd 	ble	3f162dc <show_Firmware+0x24>
			}
		}
	}
}
 3f16364:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f16368:	03f59588 	mvneqs	r9, #570425344	; 0x22000000

03f1636c <serial_setbrg>:
 3f1636c:	e1a0c00d 	mov	r12, r13
 3f16370:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
	int i;
	unsigned int reg = 0;
	
//	gd->baudrate=CONFIG_BAUDRATE;
	gd->baudrate= 115200;
 3f16374:	e59f3074 	ldr	r3, [pc, #74]	; 3f163f0 <serial_setbrg+0x84>
 3f16378:	e5883008 	str	r3, [r8, #8]
 3f1637c:	e24cb004 	sub	r11, r12, #4	; 0x4

/*	reg = get_UART1_CLK() / (16 * gd->baudrate) - 1; */
/*	reg = 0x2f; 19200*/
	reg = ((14745600/(gd->baudrate*16))-1);
 3f16380:	e5981008 	ldr	r1, [r8, #8]
 3f16384:	e3a008e1 	mov	r0, #14745600	; 0xe10000
	return (MMSP20_NAND * const)MMSP20_NAND_BASE;
}
static inline MMSP20_UART * const MMSP20_GetBase_UART(void)
{
	return (MMSP20_UART * const)MMSP20_UART_BASE;
 3f16388:	e59f4064 	ldr	r4, [pc, #64]	; 3f163f4 <serial_setbrg+0x88>
 3f1638c:	e1a01201 	mov	r1, r1, lsl #4
 3f16390:	ebfff412 	bl	3f133e0 <__udivsi3>

	uart->MMSP20_UART_NR[UART_NR].LCON = 
 3f16394:	e1d430b0 	ldrh	r3, [r4]
 3f16398:	e3c3307c 	bic	r3, r3, #124	; 0x7c
 3f1639c:	e1a03803 	mov	r3, r3, lsl #16
 3f163a0:	e1a03823 	mov	r3, r3, lsr #16
 3f163a4:	e3833003 	orr	r3, r3, #3	; 0x3
 3f163a8:	e1c430b0 	strh	r3, [r4]
		( uart->MMSP20_UART_NR[UART_NR].LCON & ~0x007C) | 0x0003;
	uart->MMSP20_UART_NR[UART_NR].UCON =
 3f163ac:	e1d430b2 	ldrh	r3, [r4, #2]
 3f163b0:	e2033b3f 	and	r3, r3, #64512	; 0xfc00
 3f163b4:	e38330c5 	orr	r3, r3, #197	; 0xc5
 3f163b8:	e1c430b2 	strh	r3, [r4, #2]
		( uart->MMSP20_UART_NR[UART_NR].UCON & ~0x03FF) | 0x00C5;
	uart->MMSP20_UART_NR[UART_NR].FCON =
 3f163bc:	e1d430b4 	ldrh	r3, [r4, #4]
 3f163c0:	e2033cff 	and	r3, r3, #65280	; 0xff00
 3f163c4:	e3833001 	orr	r3, r3, #1	; 0x1
 3f163c8:	e1c430b4 	strh	r3, [r4, #4]
		( uart->MMSP20_UART_NR[UART_NR].FCON & ~0x00FF) | 0x0001;
	uart->MMSP20_UART_NR[UART_NR].MCON = 
 3f163cc:	e1d430b6 	ldrh	r3, [r4, #6]
		( uart->MMSP20_UART_NR[UART_NR].MCON & ~0x00FF);
	uart->MMSP20_UART_NR[UART_NR].BRD = reg;
	
	for(i = 0 ; i < 100 ; i++);
 3f163d0:	e3a02063 	mov	r2, #99	; 0x63
 3f163d4:	e2033cff 	and	r3, r3, #65280	; 0xff00
 3f163d8:	e1c430b6 	strh	r3, [r4, #6]
 3f163dc:	e2400001 	sub	r0, r0, #1	; 0x1
 3f163e0:	e1c401b4 	strh	r0, [r4, #20]
 3f163e4:	e2522001 	subs	r2, r2, #1	; 0x1
 3f163e8:	5afffffd 	bpl	3f163e4 <serial_setbrg+0x78>
}
 3f163ec:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f163f0:	0001c200 	andeq	r12, r1, r0, lsl #4
 3f163f4:	c0001200 	andgt	r1, r0, r0, lsl #4

03f163f8 <serial_init>:
 3f163f8:	e1a0c00d 	mov	r12, r13
 3f163fc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f16400:	e24cb004 	sub	r11, r12, #4	; 0x4


#else
void serial_setbrg (void)
{
	DECLARE_GLOBAL_DATA_PTR;
	S3C24X0_UART * const uart = S3C24X0_GetBase_UART(UART_NR);
	int i;
	unsigned int reg = 0;

	/* value is calculated so : (int)(PCLK/16./baudrate) -1 */
	reg = get_PCLK() / (16 * gd->baudrate) - 1;

	/* FIFO enable, Tx/Rx FIFO clear */
	uart->UFCON = 0x07;
	uart->UMCON = 0x0;
	/* Normal,No parity,1 stop,8 bit */
	uart->ULCON = 0x3;
	/*
	 * tx=level,rx=edge,disable timeout int.,enable rx error int.,
	 * normal,interrupt or polling
	 */
	uart->UCON = 0x245;
	uart->UBRDIV = reg;

#ifdef CONFIG_HWFLOW
	uart->UMCON = 0x1; /* RTS up */
#endif
	for (i = 0; i < 100; i++);
}
#endif
/*
 * Initialise the serial port with the given baudrate. The settings
 * are always 8 data bits, no parity, 1 stop bit, no start bits.
 *
 */
int serial_init (void)
{
	serial_setbrg ();
 3f16404:	ebffffd8 	bl	3f1636c <serial_setbrg>
	serial_putc ('\n');
 3f16408:	e3a0000a 	mov	r0, #10	; 0xa
 3f1640c:	eb00000c 	bl	3f16444 <serial_putc>
	return (0);
 3f16410:	e3a00000 	mov	r0, #0	; 0x0
 3f16414:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f16418 <serial_getc>:
 3f16418:	e1a0c00d 	mov	r12, r13
 3f1641c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f16420:	e24cb004 	sub	r11, r12, #4	; 0x4
	return (MMSP20_NAND * const)MMSP20_NAND_BASE;
}
static inline MMSP20_UART * const MMSP20_GetBase_UART(void)
{
	return (MMSP20_UART * const)MMSP20_UART_BASE;
 3f16424:	e59f2014 	ldr	r2, [pc, #14]	; 3f16440 <serial_getc+0x28>
}

/*
 * Read a single byte from the serial port. Returns 1 on success, 0
 * otherwise. When the function is succesfull, the character read is
 * written into its argument c.
 */
int serial_getc (void)
{
#if defined(CONFIG_MMSP20)
	MMSP20_UART * const uart = MMSP20_GetBase_UART();
	
	while (!(uart->MMSP20_UART_NR[UART_NR].TRSTATUS & 0x1));
 3f16428:	e1d230b8 	ldrh	r3, [r2, #8]
 3f1642c:	e3130001 	tst	r3, #1	; 0x1
 3f16430:	0afffffc 	beq	3f16428 <serial_getc+0x10>
	
	return uart->MMSP20_UART_NR[UART_NR].RHB & 0xFF;	
 3f16434:	e1d201b2 	ldrh	r0, [r2, #18]
 3f16438:	e20000ff 	and	r0, r0, #255	; 0xff
#else
	S3C24X0_UART * const uart = S3C24X0_GetBase_UART(UART_NR);

	/* wait for character to arrive */
	while (!(uart->UTRSTAT & 0x1));

	return uart->URXH & 0xff;
#endif
}
 3f1643c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f16440:	c0001200 	andgt	r1, r0, r0, lsl #4

03f16444 <serial_putc>:
 3f16444:	e1a0c00d 	mov	r12, r13
 3f16448:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f1644c:	e24cb004 	sub	r11, r12, #4	; 0x4

#ifdef CONFIG_HWFLOW
static int hwflow = 0; /* turned off by default */
int hwflow_onoff(int on)
{
	switch(on) {
	case 0:
	default:
		break; /* return current */
	case 1:
		hwflow = 1; /* turn on */
		break;
	case -1:
		hwflow = 0; /* turn off */
		break;
	}
	return hwflow;
}
#endif

#ifdef CONFIG_MODEM_SUPPORT
static int be_quiet = 0;
void disable_putc(void)
{
	be_quiet = 1;
}

void enable_putc(void)
{
	be_quiet = 0;
}
#endif


/*
 * Output a single byte to the serial port.
 */

#if defined (CONFIG_MMSP20)
void serial_putc (const char c)
{
 3f16450:	e20000ff 	and	r0, r0, #255	; 0xff
	return (MMSP20_NAND * const)MMSP20_NAND_BASE;
}
static inline MMSP20_UART * const MMSP20_GetBase_UART(void)
{
	return (MMSP20_UART * const)MMSP20_UART_BASE;
 3f16454:	e59f2020 	ldr	r2, [pc, #20]	; 3f1647c <serial_putc+0x38>
	MMSP20_UART * const uart = MMSP20_GetBase_UART();

	while(!(uart->MMSP20_UART_NR[UART_NR].TRSTATUS & 0x02));
 3f16458:	e1d230b8 	ldrh	r3, [r2, #8]
 3f1645c:	e3130002 	tst	r3, #2	; 0x2
 3f16460:	0afffffc 	beq	3f16458 <serial_putc+0x14>

	uart->MMSP20_UART_NR[UART_NR].THB = c;

	if (c == '\n')
 3f16464:	e350000a 	cmp	r0, #10	; 0xa
 3f16468:	e1c201b0 	strh	r0, [r2, #16]
 3f1646c:	191ba800 	ldmnedb	r11, {r11, r13, r15}
		serial_putc('\r');
 3f16470:	e3a0000d 	mov	r0, #13	; 0xd
 3f16474:	ebfffff2 	bl	3f16444 <serial_putc>
}
 3f16478:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f1647c:	c0001200 	andgt	r1, r0, r0, lsl #4

03f16480 <serial_tstc>:
 3f16480:	e1a0c00d 	mov	r12, r13
 3f16484:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_NAND * const)MMSP20_NAND_BASE;
}
static inline MMSP20_UART * const MMSP20_GetBase_UART(void)
{
	return (MMSP20_UART * const)MMSP20_UART_BASE;
 3f16488:	e59f300c 	ldr	r3, [pc, #c]	; 3f1649c <serial_tstc+0x1c>
#else
void serial_putc (const char c)
{
	S3C24X0_UART * const uart = S3C24X0_GetBase_UART(UART_NR);
#ifdef CONFIG_MODEM_SUPPORT
	if (be_quiet)
		return;
#endif

	/* wait for room in the tx FIFO */
	while (!(uart->UTRSTAT & 0x2));

#ifdef CONFIG_HWFLOW
	/* Wait for CTS up */
	while(hwflow && !(uart->UMSTAT & 0x1))
		;
#endif

	uart->UTXH = c;

	/* If \n, also do \r */
	if (c == '\n')
		serial_putc ('\r');
}
#endif
/*
 * Test whether a character is in the RX buffer
 */
int serial_tstc (void)
{
#if defined (CONFIG_MMSP20)
	MMSP20_UART * const uart = MMSP20_GetBase_UART();

	return uart->MMSP20_UART_NR[UART_NR].TRSTATUS & 0x1;
 3f1648c:	e1d300b8 	ldrh	r0, [r3, #8]
 3f16490:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f16494:	e2000001 	and	r0, r0, #1	; 0x1
#else
	S3C24X0_UART * const uart = S3C24X0_GetBase_UART(UART_NR);

	return uart->UTRSTAT & 0x1;
#endif
}
 3f16498:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f1649c:	c0001200 	andgt	r1, r0, r0, lsl #4

03f164a0 <serial_puts>:
 3f164a0:	e1a0c00d 	mov	r12, r13
 3f164a4:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}

void
serial_puts (const char *s)
{
 3f164a8:	e1a04000 	mov	r4, r0
	while (*s) {
 3f164ac:	e5d43000 	ldrb	r3, [r4]
 3f164b0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f164b4:	e3530000 	cmp	r3, #0	; 0x0
 3f164b8:	091ba810 	ldmeqdb	r11, {r4, r11, r13, r15}
		serial_putc (*s++);
 3f164bc:	e5d40000 	ldrb	r0, [r4]
 3f164c0:	ebffffdf 	bl	3f16444 <serial_putc>
	}
 3f164c4:	e5f43001 	ldrb	r3, [r4, #1]!
 3f164c8:	e3530000 	cmp	r3, #0	; 0x0
 3f164cc:	1afffffa 	bne	3f164bc <serial_puts+0x1c>
 3f164d0:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f164d4 <read_p15_c1>:
 3f164d4:	e1a0c00d 	mov	r12, r13
 3f164d8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f164dc:	e24cb004 	sub	r11, r12, #4	; 0x4

#ifdef MMU_DEBUG
	printf ("p15/c1 is = %08lx\n", value);
#endif
	return value;
 3f164e0:	ee110f10 	mrc	15, 0, r0, cr1, cr0, {0}
}
 3f164e4:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f164e8 <write_p15_c1>:
 3f164e8:	e1a0c00d 	mov	r12, r13
 3f164ec:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f164f0:	e24cb004 	sub	r11, r12, #4	; 0x4

/* write to co-processor 15, register #1 (control register) */
static void write_p15_c1 (unsigned long value)
{
#ifdef MMU_DEBUG
	printf ("write %08lx to p15/c1\n", value);
#endif
	__asm__ __volatile__(
 3f164f4:	ee010f10 	mcr	15, 0, r0, cr1, cr0, {0}
		"mcr     p15, 0, %0, c1, c0, 0   @ write it back\n"
		:
		: "r" (value)
		: "memory");

	read_p15_c1 ();
 3f164f8:	ebfffff5 	bl	3f164d4 <read_p15_c1>
 3f164fc:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f16500 <cp_delay>:
 3f16500:	e1a0c00d 	mov	r12, r13
 3f16504:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f16508:	e24cb004 	sub	r11, r12, #4	; 0x4
}

static void cp_delay (void)
{
	volatile int i;

	/* copro seems to need some delay between reading and writing */
	for (i = 0; i < 100; i++);
 3f1650c:	e3a03000 	mov	r3, #0	; 0x0
 3f16510:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f16514:	ea000001 	b	3f16520 <cp_delay+0x20>
 3f16518:	e51b3010 	ldr	r3, [r11, -#16]
 3f1651c:	e2833001 	add	r3, r3, #1	; 0x1
 3f16520:	e50b3010 	str	r3, [r11, -#16]
 3f16524:	e51b3010 	ldr	r3, [r11, -#16]
 3f16528:	e3530063 	cmp	r3, #99	; 0x63
 3f1652c:	dafffff9 	ble	3f16518 <cp_delay+0x18>
}
 3f16530:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f16534 <cpu_init>:
 3f16534:	e1a0c00d 	mov	r12, r13
 3f16538:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

/* See also ARM Ref. Man. */
#define C1_MMU		(1<<0)		/* mmu off/on */
#define C1_ALIGN	(1<<1)		/* alignment faults off/on */
#define C1_DC		(1<<2)		/* dcache off/on */
#define C1_BIG_ENDIAN	(1<<7)	/* big endian off/on */
#define C1_SYS_PROT	(1<<8)		/* system protection */
#define C1_ROM_PROT	(1<<9)		/* ROM protection */
#define C1_IC		(1<<12)		/* icache off/on */
#define C1_HIGH_VECTORS	(1<<13)	/* location of vectors: low/high addresses */
#define RESERVED_1	(0xf << 3)	/* must be 111b for R/W */

int cpu_init (void)
{
	/*
	 * setup up stack if necessary
	 */
#ifdef CONFIG_USE_IRQ
	IRQ_STACK_START = _armboot_end +
			CONFIG_STACKSIZE + CONFIG_STACKSIZE_IRQ - 4;
	FIQ_STACK_START = IRQ_STACK_START + CONFIG_STACKSIZE_FIQ;
	_armboot_real_end = FIQ_STACK_START + 4;
#else
	_armboot_real_end = _armboot_end + CONFIG_STACKSIZE;
 3f1653c:	e59f3018 	ldr	r3, [pc, #18]	; 3f1655c <cpu_init+0x28>
 3f16540:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f16544:	e5933000 	ldr	r3, [r3]
#endif	/* CONFIG_USE_IRQ */
	return (0);
 3f16548:	e3a00000 	mov	r0, #0	; 0x0
 3f1654c:	e59f200c 	ldr	r2, [pc, #c]	; 3f16560 <cpu_init+0x2c>
 3f16550:	e2833802 	add	r3, r3, #131072	; 0x20000
 3f16554:	e5823000 	str	r3, [r2]
 3f16558:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f1655c:	03f0004c 	mvneqs	r0, #76	; 0x4c
 3f16560:	03f00050 	mvneqs	r0, #80	; 0x50

03f16564 <cleanup_before_linux>:
 3f16564:	e1a0c00d 	mov	r12, r13
 3f16568:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f1656c:	e24cb004 	sub	r11, r12, #4	; 0x4
}

int cleanup_before_linux (void)
{
	/*
	 * this function is called just before we call linux
	 * it prepares the processor for linux
	 *
	 * we turn off caches etc ...
	 */

	unsigned long i;

	disable_interrupts ();
 3f16570:	ebffa7ce 	bl	3f004b0 <disable_interrupts>

	/* turn off I/D-cache */
	asm ("mrc p15, 0, %0, c1, c0, 0":"=r" (i));
 3f16574:	ee113f10 	mrc	15, 0, r3, cr1, cr0, {0}
	i &= ~(C1_DC | C1_IC);
 3f16578:	e3c33a01 	bic	r3, r3, #4096	; 0x1000
 3f1657c:	e3c33004 	bic	r3, r3, #4	; 0x4
	asm ("mcr p15, 0, %0, c1, c0, 0": :"r" (i));
 3f16580:	ee013f10 	mcr	15, 0, r3, cr1, cr0, {0}

	/* flush I/D-cache */
	i = 0;
 3f16584:	e3a03000 	mov	r3, #0	; 0x0
	asm ("mcr p15, 0, %0, c7, c7, 0": :"r" (i));
 3f16588:	ee073f17 	mcr	15, 0, r3, cr7, cr7, {0}
	return (0);
 3f1658c:	e3a00000 	mov	r0, #0	; 0x0
}
 3f16590:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f16594 <do_reset>:
 3f16594:	e1a0c00d 	mov	r12, r13
 3f16598:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f1659c:	e24cb004 	sub	r11, r12, #4	; 0x4

int do_reset (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	extern void reset_cpu (ulong addr);

	disable_interrupts ();
 3f165a0:	ebffa7c2 	bl	3f004b0 <disable_interrupts>
	reset_cpu (0);
 3f165a4:	e3a00000 	mov	r0, #0	; 0x0
 3f165a8:	ebffa7ac 	bl	3f00460 <reset_cpu>
	/*NOTREACHED*/
	return (0);
 3f165ac:	e3a00000 	mov	r0, #0	; 0x0
}
 3f165b0:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f165b4 <icache_enable>:
 3f165b4:	e1a0c00d 	mov	r12, r13
 3f165b8:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f165bc:	e24cb004 	sub	r11, r12, #4	; 0x4

void icache_enable (void)
{
	ulong reg;

	reg = read_p15_c1 ();
 3f165c0:	ebffffc3 	bl	3f164d4 <read_p15_c1>
 3f165c4:	e1a04000 	mov	r4, r0
	cp_delay ();
 3f165c8:	ebffffcc 	bl	3f16500 <cp_delay>
	write_p15_c1 (reg | C1_IC);
 3f165cc:	e3840a01 	orr	r0, r4, #4096	; 0x1000
 3f165d0:	ebffffc4 	bl	3f164e8 <write_p15_c1>
}
 3f165d4:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f165d8 <icache_disable>:
 3f165d8:	e1a0c00d 	mov	r12, r13
 3f165dc:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f165e0:	e24cb004 	sub	r11, r12, #4	; 0x4

void icache_disable (void)
{
	ulong reg;

	reg = read_p15_c1 ();
 3f165e4:	ebffffba 	bl	3f164d4 <read_p15_c1>
 3f165e8:	e1a04000 	mov	r4, r0
	cp_delay ();
 3f165ec:	ebffffc3 	bl	3f16500 <cp_delay>
	write_p15_c1 (reg & ~C1_IC);
 3f165f0:	e3c40a01 	bic	r0, r4, #4096	; 0x1000
 3f165f4:	ebffffbb 	bl	3f164e8 <write_p15_c1>
}
 3f165f8:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f165fc <icache_status>:
 3f165fc:	e1a0c00d 	mov	r12, r13
 3f16600:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f16604:	e24cb004 	sub	r11, r12, #4	; 0x4

int icache_status (void)
{
	return (read_p15_c1 () & C1_IC) != 0;
 3f16608:	ebffffb1 	bl	3f164d4 <read_p15_c1>
 3f1660c:	e1a00620 	mov	r0, r0, lsr #12
 3f16610:	e2000001 	and	r0, r0, #1	; 0x1
 3f16614:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f16618 <dcache_enable>:
 3f16618:	e1a0c00d 	mov	r12, r13
 3f1661c:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f16620:	e24cb004 	sub	r11, r12, #4	; 0x4
}

#ifdef USE_920T_MMU
/* It makes no sense to use the dcache if the MMU is not enabled */
void dcache_enable (void)
{
	ulong reg;

	reg = read_p15_c1 ();
 3f16624:	ebffffaa 	bl	3f164d4 <read_p15_c1>
 3f16628:	e1a04000 	mov	r4, r0
	cp_delay ();
 3f1662c:	ebffffb3 	bl	3f16500 <cp_delay>
	write_p15_c1 (reg | C1_DC);
 3f16630:	e3840004 	orr	r0, r4, #4	; 0x4
 3f16634:	ebffffab 	bl	3f164e8 <write_p15_c1>
}
 3f16638:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f1663c <dcache_disable>:
 3f1663c:	e1a0c00d 	mov	r12, r13
 3f16640:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f16644:	e24cb004 	sub	r11, r12, #4	; 0x4

void dcache_disable (void)
{
	ulong reg;

	reg = read_p15_c1 ();
 3f16648:	ebffffa1 	bl	3f164d4 <read_p15_c1>
 3f1664c:	e1a04000 	mov	r4, r0
	cp_delay ();
 3f16650:	ebffffaa 	bl	3f16500 <cp_delay>
	reg &= ~C1_DC;
	write_p15_c1 (reg);
 3f16654:	e3c40004 	bic	r0, r4, #4	; 0x4
 3f16658:	ebffffa2 	bl	3f164e8 <write_p15_c1>
}
 3f1665c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f16660 <dcache_status>:
 3f16660:	e1a0c00d 	mov	r12, r13
 3f16664:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f16668:	e24cb004 	sub	r11, r12, #4	; 0x4

int dcache_status (void)
{
	return (read_p15_c1 () & C1_DC) != 0;
 3f1666c:	ebffff98 	bl	3f164d4 <read_p15_c1>
 3f16670:	e1a00120 	mov	r0, r0, lsr #2
 3f16674:	e2000001 	and	r0, r0, #1	; 0x1
 3f16678:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1667c <get_PLLCLK>:
 3f1667c:	e1a0c00d 	mov	r12, r13
 3f16680:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f16684:	e24cb004 	sub	r11, r12, #4	; 0x4
    ulong r,m,p,s;
    ulong i;

	
    if (pllreg == FPLL)
 3f16688:	e3500000 	cmp	r0, #0	; 0x0
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f1668c:	e59f3050 	ldr	r3, [pc, #50]	; 3f166e4 <get_PLLCLK+0x68>
	r = clk_power->FPLLVSETREG;   
 3f16690:	01d331b2 	ldreqh	r3, [r3, #18]
 3f16694:	0a000006 	beq	3f166b4 <get_PLLCLK+0x38>
    else if (pllreg == UPLL)
 3f16698:	e3500001 	cmp	r0, #1	; 0x1
	r = clk_power->UPLLVSETREG;
 3f1669c:	01d331b6 	ldreqh	r3, [r3, #22]
 3f166a0:	0a000003 	beq	3f166b4 <get_PLLCLK+0x38>
    else if (pllreg == APLL)
 3f166a4:	e3500002 	cmp	r0, #2	; 0x2
	r = clk_power->APLLVSETREG;
 3f166a8:	01d331ba 	ldreqh	r3, [r3, #26]
 3f166ac:	0a000000 	beq	3f166b4 <get_PLLCLK+0x38>
    else 
	hang();
 3f166b0:	ebffa9be 	bl	3f00db0 <hang>

    m = ((r & 0xFF00) >> 8) + 8;   	/* m = MDIV + * */
 3f166b4:	e1a00423 	mov	r0, r3, lsr #8
 3f166b8:	e2800008 	add	r0, r0, #8	; 0x8
    p = ((r & 0xFC) >> 3) + 1;		/* p = PDIV + 2 */
    s = r & 0x03;			/* s = s */

    return ((CONFIG_SYS_CLK_FREQ * m) / (p << s));
 3f166bc:	e0600200 	rsb	r0, r0, r0, lsl #4
 3f166c0:	e0600200 	rsb	r0, r0, r0, lsl #4
 3f166c4:	e1a00780 	mov	r0, r0, lsl #15
 3f166c8:	e20310fc 	and	r1, r3, #252	; 0xfc
 3f166cc:	e1a011a1 	mov	r1, r1, lsr #3
 3f166d0:	e2811001 	add	r1, r1, #1	; 0x1
 3f166d4:	e2033003 	and	r3, r3, #3	; 0x3
 3f166d8:	e1a01311 	mov	r1, r1, lsl r3
 3f166dc:	ebfff33f 	bl	3f133e0 <__udivsi3>
}
 3f166e0:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f166e4:	c0000900 	andgt	r0, r0, r0, lsl #18

03f166e8 <get_FCLK>:
 3f166e8:	e1a0c00d 	mov	r12, r13
 3f166ec:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f166f0:	e59f3020 	ldr	r3, [pc, #20]	; 3f16718 <get_FCLK+0x30>
 3f166f4:	e24cb004 	sub	r11, r12, #4	; 0x4

ulong get_FCLK(void)
{
   	MMSP20_CLOCK_POWER * const clk_power = MMSP20_GetBase_CLOCK_POWER();
    	ulong i;
	
	i = clk_power->SYSCSETREG;
 3f166f8:	e1d341bc 	ldrh	r4, [r3, #28]
	i = (i & 0x07) + 1;
	return ( get_PLLCLK(FPLL) / i );
 3f166fc:	e3a00000 	mov	r0, #0	; 0x0
 3f16700:	e2044007 	and	r4, r4, #7	; 0x7
 3f16704:	e2844001 	add	r4, r4, #1	; 0x1
 3f16708:	ebffffdb 	bl	3f1667c <get_PLLCLK>
 3f1670c:	e1a01004 	mov	r1, r4
 3f16710:	ebfff332 	bl	3f133e0 <__udivsi3>
}
 3f16714:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f16718:	c0000900 	andgt	r0, r0, r0, lsl #18

03f1671c <get_DCLK>:
 3f1671c:	e1a0c00d 	mov	r12, r13
 3f16720:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f16724:	e59f3024 	ldr	r3, [pc, #24]	; 3f16750 <get_DCLK+0x34>
 3f16728:	e24cb004 	sub	r11, r12, #4	; 0x4
ulong get_DCLK(void)
{
   	MMSP20_CLOCK_POWER * const clk_power = MMSP20_GetBase_CLOCK_POWER();
    	ulong i;
	
	i = clk_power->SYSCSETREG;
 3f1672c:	e1d341bc 	ldrh	r4, [r3, #28]
	i = ((i >> 6) & 0x07) + 1;
	return ( get_PLLCLK(FPLL) / i );
 3f16730:	e3a00000 	mov	r0, #0	; 0x0
 3f16734:	e1a04324 	mov	r4, r4, lsr #6
 3f16738:	e2044007 	and	r4, r4, #7	; 0x7
 3f1673c:	e2844001 	add	r4, r4, #1	; 0x1
 3f16740:	ebffffcd 	bl	3f1667c <get_PLLCLK>
 3f16744:	e1a01004 	mov	r1, r4
 3f16748:	ebfff324 	bl	3f133e0 <__udivsi3>
}
 3f1674c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f16750:	c0000900 	andgt	r0, r0, r0, lsl #18

03f16754 <get_BCLK>:
 3f16754:	e1a0c00d 	mov	r12, r13
 3f16758:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f1675c:	e24cb004 	sub	r11, r12, #4	; 0x4
/* BCLK is DCLK * 1/2 */
ulong get_BCLK(void)
{
	return ( get_DCLK() / 2 );
 3f16760:	ebffffed 	bl	3f1671c <get_DCLK>
 3f16764:	e1a000a0 	mov	r0, r0, lsr #1
 3f16768:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1676c <get_PCLK>:
 3f1676c:	e1a0c00d 	mov	r12, r13
 3f16770:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f16774:	e24cb004 	sub	r11, r12, #4	; 0x4
}
/* BCLK is DCLK * 1/4 */
ulong get_PCLK(void)
{
	return (get_DCLK() / 4);
 3f16778:	ebffffe7 	bl	3f1671c <get_DCLK>
 3f1677c:	e1a00120 	mov	r0, r0, lsr #2
 3f16780:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f16784 <get_UCLK>:
 3f16784:	e1a0c00d 	mov	r12, r13
 3f16788:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f1678c:	e59f301c 	ldr	r3, [pc, #1c]	; 3f167b0 <get_UCLK+0x2c>
 3f16790:	e24cb004 	sub	r11, r12, #4	; 0x4
}
ulong get_UCLK(void)
{
   	MMSP20_CLOCK_POWER * const clk_power = MMSP20_GetBase_CLOCK_POWER();
    	ulong i;
	
	i = clk_power->PWMODEREG;
 3f16794:	e1d330b0 	ldrh	r3, [r3]
	i = ((i >> 7) & 0x01) ;
	return ((i) ? 0 : get_PLLCLK(UPLL));
 3f16798:	e3a00000 	mov	r0, #0	; 0x0
 3f1679c:	e3130080 	tst	r3, #128	; 0x80
 3f167a0:	191ba800 	ldmnedb	r11, {r11, r13, r15}
 3f167a4:	e2800001 	add	r0, r0, #1	; 0x1
 3f167a8:	ebffffb3 	bl	3f1667c <get_PLLCLK>
}
 3f167ac:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f167b0:	c0000900 	andgt	r0, r0, r0, lsl #18

03f167b4 <get_ACLK>:
 3f167b4:	e1a0c00d 	mov	r12, r13
 3f167b8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f167bc:	e59f301c 	ldr	r3, [pc, #1c]	; 3f167e0 <get_ACLK+0x2c>
 3f167c0:	e24cb004 	sub	r11, r12, #4	; 0x4
ulong get_ACLK(void)
{
   	MMSP20_CLOCK_POWER * const clk_power = MMSP20_GetBase_CLOCK_POWER();
    	ulong i;
	
	i = clk_power->PWMODEREG;
 3f167c4:	e1d330b0 	ldrh	r3, [r3]
	i = (i >> 8) & 0x01;
	return ((i) ? 0 : get_PLLCLK(APLL));
 3f167c8:	e3a00000 	mov	r0, #0	; 0x0
 3f167cc:	e3130c01 	tst	r3, #256	; 0x100
 3f167d0:	191ba800 	ldmnedb	r11, {r11, r13, r15}
 3f167d4:	e2800002 	add	r0, r0, #2	; 0x2
 3f167d8:	ebffffa7 	bl	3f1667c <get_PLLCLK>
}
 3f167dc:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f167e0:	c0000900 	andgt	r0, r0, r0, lsl #18

03f167e4 <get_UART1_CLK>:
 3f167e4:	e1a0c00d 	mov	r12, r13
 3f167e8:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f167ec:	e59f2064 	ldr	r2, [pc, #64]	; 3f16858 <get_UART1_CLK+0x74>
ulong get_UART1_CLK(void)
{
	MMSP20_CLOCK_POWER * const clk_power = MMSP20_GetBase_CLOCK_POWER();
	
	unsigned int clk_source = (clk_power->URTCSETREG[0] >> 14) & 0x03;
 3f167f0:	e1d232b8 	ldrh	r3, [r2, #40]
 3f167f4:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f167f8:	e1a01723 	mov	r1, r3, lsr #14
	unsigned int divide = (clk_power->URTCSETREG[0] >> 8 ) & 0x03F;
 3f167fc:	e1d232b8 	ldrh	r3, [r2, #40]

	switch (clk_source){
 3f16800:	e3510002 	cmp	r1, #2	; 0x2
 3f16804:	e1a03423 	mov	r3, r3, lsr #8
 3f16808:	e203403f 	and	r4, r3, #63	; 0x3f
 3f1680c:	0a00000b 	beq	3f16840 <get_UART1_CLK+0x5c>
 3f16810:	8a000002 	bhi	3f16820 <get_UART1_CLK+0x3c>
 3f16814:	e3510001 	cmp	r1, #1	; 0x1
 3f16818:	0a000003 	beq	3f1682c <get_UART1_CLK+0x48>
 3f1681c:	ea00000b 	b	3f16850 <get_UART1_CLK+0x6c>
 3f16820:	e3510003 	cmp	r1, #3	; 0x3
 3f16824:	0a000007 	beq	3f16848 <get_UART1_CLK+0x64>
 3f16828:	ea000008 	b	3f16850 <get_UART1_CLK+0x6c>
	   case (1):	/* FPLL 01b */
		return (get_PLLCLK(FPLL)/divide);
 3f1682c:	e3a00000 	mov	r0, #0	; 0x0
 3f16830:	ebffff91 	bl	3f1667c <get_PLLCLK>
 3f16834:	e1a01004 	mov	r1, r4
 3f16838:	ebfff2e8 	bl	3f133e0 <__udivsi3>
 3f1683c:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
		break;
	   case (2):    /* UPLL 10b */
		return (get_PLLCLK(UPLL)/divide);
 3f16840:	e3a00001 	mov	r0, #1	; 0x1
 3f16844:	eafffff9 	b	3f16830 <get_UART1_CLK+0x4c>
		break;
	   case (3):    /* APLL 11b */
		return (get_PLLCLK(APLL)/divide);
 3f16848:	e3a00002 	mov	r0, #2	; 0x2
 3f1684c:	eafffff7 	b	3f16830 <get_UART1_CLK+0x4c>
		break;
	   default :
		return 0;
 3f16850:	e3a00000 	mov	r0, #0	; 0x0
		break;
	}
}
 3f16854:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f16858:	c0000900 	andgt	r0, r0, r0, lsl #18

03f1685c <show_MMSP2_CLK>:
 3f1685c:	e1a0c00d 	mov	r12, r13
 3f16860:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
	return (MMSP20_DUALCPU * const)MMSP20_DUALCPU_BASE;
}
static inline MMSP20_CLOCK_POWER * const MMSP20_GetBase_CLOCK_POWER(void)
{
	return (MMSP20_CLOCK_POWER * const)MMSP20_CLOCK_POWER_BASE;
 3f16864:	e59f3108 	ldr	r3, [pc, #108]	; 3f16974 <show_MMSP2_CLK+0x118>
 3f16868:	e24cb004 	sub	r11, r12, #4	; 0x4

void show_MMSP2_CLK(void)
{
	MMSP20_CLOCK_POWER * const clk_power = MMSP20_GetBase_CLOCK_POWER();
	unsigned int clk_source = (clk_power->URTCSETREG[0] >> 14) & 0x03;
 3f1686c:	e1d332b8 	ldrh	r3, [r3, #40]

        printf("MP2520F    FPLLCLK: %9lu Hz\n", get_PLLCLK(FPLL) );
 3f16870:	e3a00000 	mov	r0, #0	; 0x0
 3f16874:	e1a04723 	mov	r4, r3, lsr #14
 3f16878:	ebffff7f 	bl	3f1667c <get_PLLCLK>
 3f1687c:	e1a01000 	mov	r1, r0
 3f16880:	e59f00f0 	ldr	r0, [pc, #f0]	; 3f16978 <show_MMSP2_CLK+0x11c>
 3f16884:	ebffd7ee 	bl	3f0c844 <printf>
	printf("MP2520F    UPLLCLK: %9lu Hz\n", get_PLLCLK(UPLL) );
 3f16888:	e3a00001 	mov	r0, #1	; 0x1
 3f1688c:	ebffff7a 	bl	3f1667c <get_PLLCLK>
 3f16890:	e1a01000 	mov	r1, r0
 3f16894:	e59f00e0 	ldr	r0, [pc, #e0]	; 3f1697c <show_MMSP2_CLK+0x120>
 3f16898:	ebffd7e9 	bl	3f0c844 <printf>
	printf("MP2520F    APLLCLK: %9lu Hz\n", get_PLLCLK(APLL) );
 3f1689c:	e3a00002 	mov	r0, #2	; 0x2
 3f168a0:	ebffff75 	bl	3f1667c <get_PLLCLK>
 3f168a4:	e1a01000 	mov	r1, r0
 3f168a8:	e59f00d0 	ldr	r0, [pc, #d0]	; 3f16980 <show_MMSP2_CLK+0x124>
 3f168ac:	ebffd7e4 	bl	3f0c844 <printf>

        printf("MP2520F UART 1 CLK: %9lu Hz\n", get_UART1_CLK() );
 3f168b0:	ebffffcb 	bl	3f167e4 <get_UART1_CLK>
 3f168b4:	e1a01000 	mov	r1, r0
 3f168b8:	e59f00c4 	ldr	r0, [pc, #c4]	; 3f16984 <show_MMSP2_CLK+0x128>
 3f168bc:	ebffd7e0 	bl	3f0c844 <printf>

	switch (clk_source){
 3f168c0:	e3540002 	cmp	r4, #2	; 0x2
 3f168c4:	0a000009 	beq	3f168f0 <show_MMSP2_CLK+0x94>
 3f168c8:	8a000002 	bhi	3f168d8 <show_MMSP2_CLK+0x7c>
 3f168cc:	e3540001 	cmp	r4, #1	; 0x1
 3f168d0:	0a000003 	beq	3f168e4 <show_MMSP2_CLK+0x88>
 3f168d4:	ea00000b 	b	3f16908 <show_MMSP2_CLK+0xac>
 3f168d8:	e3540003 	cmp	r4, #3	; 0x3
 3f168dc:	0a000006 	beq	3f168fc <show_MMSP2_CLK+0xa0>
 3f168e0:	ea000008 	b	3f16908 <show_MMSP2_CLK+0xac>
	   case (1):	/* FPLL 01b */
        printf("     uart 1 clock src ==> FPLL\n");
 3f168e4:	e59f009c 	ldr	r0, [pc, #9c]	; 3f16988 <show_MMSP2_CLK+0x12c>
 3f168e8:	ebffd7d5 	bl	3f0c844 <printf>
		break;
 3f168ec:	ea000007 	b	3f16910 <show_MMSP2_CLK+0xb4>
	   case (2):    /* UPLL 10b */
        printf("     uart 1 clock src ==> UPLL\n");
 3f168f0:	e59f0094 	ldr	r0, [pc, #94]	; 3f1698c <show_MMSP2_CLK+0x130>
 3f168f4:	ebffd7d2 	bl	3f0c844 <printf>
		break;
 3f168f8:	ea000004 	b	3f16910 <show_MMSP2_CLK+0xb4>
	   case (3):    /* APLL 11b */
        printf("     uart 1 clock src ==> APLL\n");
 3f168fc:	e59f008c 	ldr	r0, [pc, #8c]	; 3f16990 <show_MMSP2_CLK+0x134>
 3f16900:	ebffd7cf 	bl	3f0c844 <printf>
		break;
 3f16904:	ea000001 	b	3f16910 <show_MMSP2_CLK+0xb4>
	   default :
        printf("     uart 1 clock src ==> ?(don't know)\n");
 3f16908:	e59f0084 	ldr	r0, [pc, #84]	; 3f16994 <show_MMSP2_CLK+0x138>
 3f1690c:	ebffd7cc 	bl	3f0c844 <printf>
		break;
	}

        printf("MP2520F       FCLK: %9lu Hz\n", get_FCLK() );
 3f16910:	ebffff74 	bl	3f166e8 <get_FCLK>
 3f16914:	e1a01000 	mov	r1, r0
 3f16918:	e59f0078 	ldr	r0, [pc, #78]	; 3f16998 <show_MMSP2_CLK+0x13c>
 3f1691c:	ebffd7c8 	bl	3f0c844 <printf>
        printf("MP2520F       UCLK: %9lu Hz\n", get_UCLK() );
 3f16920:	ebffff97 	bl	3f16784 <get_UCLK>
 3f16924:	e1a01000 	mov	r1, r0
 3f16928:	e59f006c 	ldr	r0, [pc, #6c]	; 3f1699c <show_MMSP2_CLK+0x140>
 3f1692c:	ebffd7c4 	bl	3f0c844 <printf>
        printf("MP2520F       ACLK: %9lu Hz\n", get_ACLK() );
 3f16930:	ebffff9f 	bl	3f167b4 <get_ACLK>
 3f16934:	e1a01000 	mov	r1, r0
 3f16938:	e59f0060 	ldr	r0, [pc, #60]	; 3f169a0 <show_MMSP2_CLK+0x144>
 3f1693c:	ebffd7c0 	bl	3f0c844 <printf>
        printf("MP2520F       DCLK: %9lu Hz = FCLK/n\n", get_DCLK() );
 3f16940:	ebffff75 	bl	3f1671c <get_DCLK>
 3f16944:	e1a01000 	mov	r1, r0
 3f16948:	e59f0054 	ldr	r0, [pc, #54]	; 3f169a4 <show_MMSP2_CLK+0x148>
 3f1694c:	ebffd7bc 	bl	3f0c844 <printf>
        printf("MP2520F       BCLK: %9lu Hz = DCLK/2\n", get_BCLK() );
 3f16950:	ebffff7f 	bl	3f16754 <get_BCLK>
 3f16954:	e1a01000 	mov	r1, r0
 3f16958:	e59f0048 	ldr	r0, [pc, #48]	; 3f169a8 <show_MMSP2_CLK+0x14c>
 3f1695c:	ebffd7b8 	bl	3f0c844 <printf>
        printf("MP2520F       PCLK: %9lu Hz = BCLK/2 = DCLK/4\n", get_PCLK() );
 3f16960:	ebffff81 	bl	3f1676c <get_PCLK>
 3f16964:	e1a01000 	mov	r1, r0
 3f16968:	e59f003c 	ldr	r0, [pc, #3c]	; 3f169ac <show_MMSP2_CLK+0x150>
 3f1696c:	ebffd7b4 	bl	3f0c844 <printf>
}
 3f16970:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f16974:	c0000900 	andgt	r0, r0, r0, lsl #18
 3f16978:	03f1fb24 	mvneqs	r15, #36864	; 0x9000
 3f1697c:	03f1fb44 	mvneqs	r15, #69632	; 0x11000
 3f16980:	03f1fb64 	mvneqs	r15, #102400	; 0x19000
 3f16984:	03f1fb84 	mvneqs	r15, #135168	; 0x21000
 3f16988:	03f1fba4 	mvneqs	r15, #167936	; 0x29000
 3f1698c:	03f1fbc4 	mvneqs	r15, #200704	; 0x31000
 3f16990:	03f1fbe4 	mvneqs	r15, #233472	; 0x39000
 3f16994:	03f1fc04 	mvneqs	r15, #1024	; 0x400
 3f16998:	03f1fc30 	mvneqs	r15, #12288	; 0x3000
 3f1699c:	03f1fc50 	mvneqs	r15, #20480	; 0x5000
 3f169a0:	03f1fc70 	mvneqs	r15, #28672	; 0x7000
 3f169a4:	03f1fc90 	mvneqs	r15, #36864	; 0x9000
 3f169a8:	03f1fcb8 	mvneqs	r15, #47104	; 0xb800
 3f169ac:	03f1fce0 	mvneqs	r15, #57344	; 0xe000

03f169b0 <usbd_recv>:
 3f169b0:	e1a0c00d 	mov	r12, r13
 3f169b4:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f169b8:	e24cb004 	sub	r11, r12, #4	; 0x4
extern void usbd_en(void);
extern void usbd_dis(void);

unsigned int usbd_recv(unsigned long offset, char *file_name)
{
 3f169bc:	e1a06000 	mov	r6, r0
 3f169c0:	e1a04001 	mov	r4, r1
	int cnt;
	int len;
	unsigned int down_size;
	
	cmd_offset = offset;
 3f169c4:	e59f30d8 	ldr	r3, [pc, #d8]	; 3f16aa4 <usbd_recv+0xf4>
	/* make string descriptor */
	if((len=strlen(file_name)) > (DESCSTR3_SIZE_MAX/2)) return 0;
 3f169c8:	e1a00004 	mov	r0, r4
 3f169cc:	e5836000 	str	r6, [r3]
 3f169d0:	ebffe23c 	bl	3f0f2c8 <strlen>
 3f169d4:	e3500040 	cmp	r0, #64	; 0x40
 3f169d8:	c3a00000 	movgt	r0, #0	; 0x0
 3f169dc:	c91ba870 	ldmgtdb	r11, {r4, r5, r6, r11, r13, r15}
	for(cnt=0;cnt<DESCSTR3_SIZE_MAX+2;cnt++) {
 3f169e0:	e3a02000 	mov	r2, #0	; 0x0
		descStr3[cnt] = 0;
 3f169e4:	e59fe0bc 	ldr	r14, [pc, #bc]	; 3f16aa8 <usbd_recv+0xf8>
 3f169e8:	e3a03000 	mov	r3, #0	; 0x0
 3f169ec:	e7ce3002 	strb	r3, [r14, r2]
 3f169f0:	e2822001 	add	r2, r2, #1	; 0x1
 3f169f4:	e3520081 	cmp	r2, #129	; 0x81
 3f169f8:	dafffff9 	ble	3f169e4 <usbd_recv+0x34>
	}
	descStr3[0] = len*2 + 2;
	descStr3[1] = STRING_TYPE;
	for(cnt=0; cnt<len; cnt++) {
 3f169fc:	e1a02003 	mov	r2, r3
 3f16a00:	e1520000 	cmp	r2, r0
 3f16a04:	e1a03080 	mov	r3, r0, lsl #1
 3f16a08:	e2833002 	add	r3, r3, #2	; 0x2
 3f16a0c:	e5ce3000 	strb	r3, [r14]
 3f16a10:	e3a03003 	mov	r3, #3	; 0x3
 3f16a14:	e5ce3001 	strb	r3, [r14, #1]
 3f16a18:	aa00000a 	bge	3f16a48 <usbd_recv+0x98>
 3f16a1c:	e1a0c003 	mov	r12, r3
 3f16a20:	e3a01002 	mov	r1, #2	; 0x2
		descStr3[cnt*2+2] = file_name[cnt];
 3f16a24:	e7d43002 	ldrb	r3, [r4, r2]
 3f16a28:	e2822001 	add	r2, r2, #1	; 0x1
 3f16a2c:	e1520000 	cmp	r2, r0
 3f16a30:	e7ce3001 	strb	r3, [r14, r1]
		descStr3[cnt*2+3] = 0;
 3f16a34:	e3a03000 	mov	r3, #0	; 0x0
 3f16a38:	e7ce300c 	strb	r3, [r14, r12]
 3f16a3c:	e28cc002 	add	r12, r12, #2	; 0x2
 3f16a40:	e2811002 	add	r1, r1, #2	; 0x2
 3f16a44:	bafffff6 	blt	3f16a24 <usbd_recv+0x74>
	}

	InitUsbd(); 
 3f16a48:	eb000101 	bl	3f16e54 <InitUsbd>
	udelay(0);  //calibrate udelay()
 3f16a4c:	e3a00000 	mov	r0, #0	; 0x0
 3f16a50:	ebffa770 	bl	3f00818 <udelay>

	pullup_dis();
	udelay(500000);
 3f16a54:	e59f5050 	ldr	r5, [pc, #50]	; 3f16aac <usbd_recv+0xfc>
 3f16a58:	ebfff3f4 	bl	3f13a30 <pullup_dis>
 3f16a5c:	e1a00005 	mov	r0, r5
 3f16a60:	ebffa76c 	bl	3f00818 <udelay>

	usbd_en();
 3f16a64:	ebfff401 	bl	3f13a70 <usbd_en>

	download_run = 1;
 3f16a68:	e59f2040 	ldr	r2, [pc, #40]	; 3f16ab0 <usbd_recv+0x100>
 3f16a6c:	e3a03001 	mov	r3, #1	; 0x1
 3f16a70:	e5823000 	str	r3, [r2]
	isUsbdSetConfiguration=0;

	down_size = WaitDownload(offset);
 3f16a74:	e1a00006 	mov	r0, r6
 3f16a78:	e59f2034 	ldr	r2, [pc, #34]	; 3f16ab4 <usbd_recv+0x104>
 3f16a7c:	e2433001 	sub	r3, r3, #1	; 0x1
 3f16a80:	e5823000 	str	r3, [r2]
 3f16a84:	eb00000b 	bl	3f16ab8 <WaitDownload>
 3f16a88:	e1a04000 	mov	r4, r0

	pullup_dis();
 3f16a8c:	ebfff3e7 	bl	3f13a30 <pullup_dis>
	usbd_dis();
 3f16a90:	ebfff405 	bl	3f13aac <usbd_dis>
	udelay(500000);
 3f16a94:	e1a00005 	mov	r0, r5
 3f16a98:	ebffa75e 	bl	3f00818 <udelay>

	return down_size;
 3f16a9c:	e1a00004 	mov	r0, r4
}
 3f16aa0:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f16aa4:	03f73040 	mvneqs	r3, #64	; 0x40
 3f16aa8:	03f6a120 	mvneqs	r10, #8	; 0x8
 3f16aac:	0007a120 	andeq	r10, r7, r0, lsr #2
 3f16ab0:	03f6a1a8 	mvneqs	r10, #42	; 0x2a
 3f16ab4:	03f7305c 	mvneqs	r3, #92	; 0x5c

03f16ab8 <WaitDownload>:
 3f16ab8:	e1a0c00d 	mov	r12, r13
 3f16abc:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}

unsigned int WaitDownload(unsigned long offset)
{
	U32 j;
	U16 dnCS;
	int first=1;
	U8 tempMem[16];
	int cnt;
	
	DbgPrintf("****[%s:%d]->%s():\n", __FILE__, __LINE__, __FUNCTION__);

	checkSum=0;
 3f16ac0:	e59f9198 	ldr	r9, [pc, #198]	; 3f16c60 <WaitDownload+0x1a8>
	downloadAddress=(U32)tempMem;  
 3f16ac4:	e59f6198 	ldr	r6, [pc, #198]	; 3f16c64 <WaitDownload+0x1ac>
	downPt=(unsigned char *)downloadAddress;
	//This address is used for receiving first 8 byte.
	downloadFileSize=0;
 3f16ac8:	e59f4198 	ldr	r4, [pc, #198]	; 3f16c68 <WaitDownload+0x1b0>
 3f16acc:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f16ad0:	e59fa194 	ldr	r10, [pc, #194]	; 3f16c6c <WaitDownload+0x1b4>
 3f16ad4:	e3a02000 	mov	r2, #0	; 0x0
 3f16ad8:	e1c920b0 	strh	r2, [r9]
 3f16adc:	e24b3034 	sub	r3, r11, #52	; 0x34
 3f16ae0:	e5863000 	str	r3, [r6]
 3f16ae4:	e5963000 	ldr	r3, [r6]
 3f16ae8:	e24dd010 	sub	r13, r13, #16	; 0x10
 3f16aec:	e5842000 	str	r2, [r4]
 3f16af0:	e1a07000 	mov	r7, r0
 3f16af4:	e58a3000 	str	r3, [r10]

	j=0;

	pullup_en();
 3f16af8:	ebfff3be 	bl	3f139f8 <pullup_en>

	while(downloadFileSize==0)
 3f16afc:	e5943000 	ldr	r3, [r4]
 3f16b00:	e3a05001 	mov	r5, #1	; 0x1
 3f16b04:	e3530000 	cmp	r3, #0	; 0x0
 3f16b08:	1a00000c 	bne	3f16b40 <WaitDownload+0x88>
	{
		IsrUsbd();
 3f16b0c:	eb0000db 	bl	3f16e80 <IsrUsbd>

		if(first==1 && isUsbdSetConfiguration!=0)
 3f16b10:	e3550001 	cmp	r5, #1	; 0x1
 3f16b14:	1a000006 	bne	3f16b34 <WaitDownload+0x7c>
 3f16b18:	e59f3150 	ldr	r3, [pc, #150]	; 3f16c70 <WaitDownload+0x1b8>
 3f16b1c:	e5933000 	ldr	r3, [r3]
 3f16b20:	e3530000 	cmp	r3, #0	; 0x0
 3f16b24:	0a000002 	beq	3f16b34 <WaitDownload+0x7c>
		{
			printf("USB host is connected. Waiting a download.\n");
 3f16b28:	e59f0144 	ldr	r0, [pc, #144]	; 3f16c74 <WaitDownload+0x1bc>
			first=0;
 3f16b2c:	e3a05000 	mov	r5, #0	; 0x0
 3f16b30:	ebffd743 	bl	3f0c844 <printf>
		}

	}
 3f16b34:	e5943000 	ldr	r3, [r4]
 3f16b38:	e3530000 	cmp	r3, #0	; 0x0
 3f16b3c:	0afffff2 	beq	3f16b0c <WaitDownload+0x54>

	printf("\nNow, Downloading [ADDRESS:%xh,TOTAL:%xh]\n",
 3f16b40:	e59f5120 	ldr	r5, [pc, #120]	; 3f16c68 <WaitDownload+0x1b0>
 3f16b44:	e5952000 	ldr	r2, [r5]
 3f16b48:	e1a01007 	mov	r1, r7
 3f16b4c:	e59f0124 	ldr	r0, [pc, #124]	; 3f16c78 <WaitDownload+0x1c0>
 3f16b50:	e242200a 	sub	r2, r2, #10	; 0xa
 3f16b54:	ebffd73a 	bl	3f0c844 <printf>
		(U32)offset,downloadFileSize - 10);
	printf("RECEIVED FILE SIZE: 0x%8x",0);
 3f16b58:	e59f011c 	ldr	r0, [pc, #11c]	; 3f16c7c <WaitDownload+0x1c4>
 3f16b5c:	e3a01000 	mov	r1, #0	; 0x0
 3f16b60:	ebffd737 	bl	3f0c844 <printf>

	j=0x10000;

	while(((U32)downPt-downloadAddress)<(downloadFileSize-8))
 3f16b64:	e59a2000 	ldr	r2, [r10]
 3f16b68:	e5961000 	ldr	r1, [r6]
 3f16b6c:	e3a04801 	mov	r4, #65536	; 0x10000
 3f16b70:	e5953000 	ldr	r3, [r5]
 3f16b74:	e0612002 	rsb	r2, r1, r2
 3f16b78:	e2433008 	sub	r3, r3, #8	; 0x8
 3f16b7c:	e1520003 	cmp	r2, r3
 3f16b80:	2a000010 	bcs	3f16bc8 <WaitDownload+0x110>
	{
		IsrUsbd();
 3f16b84:	eb0000bd 	bl	3f16e80 <IsrUsbd>

		if( ((U32)downPt-downloadAddress)>=j)
 3f16b88:	e59a3000 	ldr	r3, [r10]
 3f16b8c:	e5962000 	ldr	r2, [r6]
 3f16b90:	e0623003 	rsb	r3, r2, r3
 3f16b94:	e1530004 	cmp	r3, r4
 3f16b98:	3a000003 	bcc	3f16bac <WaitDownload+0xf4>
		{
			printf("\b\b\b\b\b\b\b\b%08x",j);
 3f16b9c:	e1a01004 	mov	r1, r4
 3f16ba0:	e59f00d8 	ldr	r0, [pc, #d8]	; 3f16c80 <WaitDownload+0x1c8>
			j+=0x1000;
 3f16ba4:	e2844a01 	add	r4, r4, #4096	; 0x1000
 3f16ba8:	ebffd725 	bl	3f0c844 <printf>
		}
	}
 3f16bac:	e59a3000 	ldr	r3, [r10]
 3f16bb0:	e5961000 	ldr	r1, [r6]
 3f16bb4:	e5952000 	ldr	r2, [r5]
 3f16bb8:	e0613003 	rsb	r3, r1, r3
 3f16bbc:	e2422008 	sub	r2, r2, #8	; 0x8
 3f16bc0:	e1530002 	cmp	r3, r2
 3f16bc4:	3affffee 	bcc	3f16b84 <WaitDownload+0xcc>
	printf("\b\b\b\b\b\b\b\b%08x\n",downloadFileSize - 10);
 3f16bc8:	e59f5098 	ldr	r5, [pc, #98]	; 3f16c68 <WaitDownload+0x1b0>
 3f16bcc:	e5951000 	ldr	r1, [r5]
 3f16bd0:	e59f00ac 	ldr	r0, [pc, #ac]	; 3f16c84 <WaitDownload+0x1cc>
 3f16bd4:	e241100a 	sub	r1, r1, #10	; 0xa
 3f16bd8:	ebffd719 	bl	3f0c844 <printf>

	//checkSum was calculated including dnCS. So, dnCS should be subtracted.
	checkSum=checkSum - *((unsigned char *)(downloadAddress+downloadFileSize-8-2))
 3f16bdc:	e59fc080 	ldr	r12, [pc, #80]	; 3f16c64 <WaitDownload+0x1ac>
 3f16be0:	e59c1000 	ldr	r1, [r12]
 3f16be4:	e5950000 	ldr	r0, [r5]
 3f16be8:	e1d920b0 	ldrh	r2, [r9]
 3f16bec:	e3e04009 	mvn	r4, #9	; 0x9
 3f16bf0:	e59c3000 	ldr	r3, [r12]
 3f16bf4:	e0811000 	add	r1, r1, r0
 3f16bf8:	e5950000 	ldr	r0, [r5]
 3f16bfc:	e3e0e008 	mvn	r14, #8	; 0x8
 3f16c00:	e7d11004 	ldrb	r1, [r1, r4]
 3f16c04:	e0833000 	add	r3, r3, r0
 3f16c08:	e7d3300e 	ldrb	r3, [r3, r14]
 3f16c0c:	e0612002 	rsb	r2, r1, r2
 3f16c10:	e0632002 	rsb	r2, r3, r2
 3f16c14:	e1c920b0 	strh	r2, [r9]
		- *( (unsigned char *)(downloadAddress+downloadFileSize-8-1) );

	dnCS=*((unsigned char *)(downloadAddress+downloadFileSize-8-2))+
 3f16c18:	e59c3000 	ldr	r3, [r12]
 3f16c1c:	e5951000 	ldr	r1, [r5]
 3f16c20:	e59c2000 	ldr	r2, [r12]
 3f16c24:	e5950000 	ldr	r0, [r5]
 3f16c28:	e0833001 	add	r3, r3, r1
 3f16c2c:	e7d31004 	ldrb	r1, [r3, r4]
 3f16c30:	e0822000 	add	r2, r2, r0
 3f16c34:	e7d2300e 	ldrb	r3, [r2, r14]
	(*( (unsigned char *)(downloadAddress+downloadFileSize-8-1) )<<8);

	if(checkSum!=dnCS)
 3f16c38:	e1d920b0 	ldrh	r2, [r9]
 3f16c3c:	e1813403 	orr	r3, r1, r3, lsl #8
 3f16c40:	e1520003 	cmp	r2, r3
 3f16c44:	0a000010 	beq	3f16c8c <WaitDownload+0x1d4>
	{
		printf("Checksum Error!!! (MEM:%xh DN:%xh)\n",checkSum,dnCS);
 3f16c48:	e1d910b0 	ldrh	r1, [r9]
 3f16c4c:	e59f0034 	ldr	r0, [pc, #34]	; 3f16c88 <WaitDownload+0x1d0>
 3f16c50:	e1a02003 	mov	r2, r3
 3f16c54:	ebffd6fa 	bl	3f0c844 <printf>
		return 0;
 3f16c58:	e3a00000 	mov	r0, #0	; 0x0
 3f16c5c:	ea000018 	b	3f16cc4 <WaitDownload+0x20c>
 3f16c60:	03f73054 	mvneqs	r3, #84	; 0x54
 3f16c64:	03f73048 	mvneqs	r3, #72	; 0x48
 3f16c68:	03f73050 	mvneqs	r3, #80	; 0x50
 3f16c6c:	03f7304c 	mvneqs	r3, #76	; 0x4c
 3f16c70:	03f7305c 	mvneqs	r3, #92	; 0x5c
 3f16c74:	03f1fd58 	mvneqs	r15, #5632	; 0x1600
 3f16c78:	03f1fd84 	mvneqs	r15, #8448	; 0x2100
 3f16c7c:	03f1fdb0 	mvneqs	r15, #11264	; 0x2c00
 3f16c80:	03f1fdcc 	mvneqs	r15, #13056	; 0x3300
 3f16c84:	03f1fddc 	mvneqs	r15, #14080	; 0x3700
 3f16c88:	03f1fdec 	mvneqs	r15, #15104	; 0x3b00
	}

	printf("Checksum O.K. (MEM:%xh DN:%xh)\n",checkSum,dnCS);
 3f16c8c:	e1d910b0 	ldrh	r1, [r9]
 3f16c90:	e59f0030 	ldr	r0, [pc, #30]	; 3f16cc8 <WaitDownload+0x210>
 3f16c94:	ebffd6ea 	bl	3f0c844 <printf>
	printf("Download O.K.\n\n");
 3f16c98:	e59f002c 	ldr	r0, [pc, #2c]	; 3f16ccc <WaitDownload+0x214>
 3f16c9c:	ebffd6e8 	bl	3f0c844 <printf>

	for(cnt=0;cnt<64;cnt++) {
 3f16ca0:	e3a01000 	mov	r1, #0	; 0x0
		descStr3[cnt] = 0;
 3f16ca4:	e59f2024 	ldr	r2, [pc, #24]	; 3f16cd0 <WaitDownload+0x218>
 3f16ca8:	e3a03000 	mov	r3, #0	; 0x0
 3f16cac:	e7c23001 	strb	r3, [r2, r1]
 3f16cb0:	e2811001 	add	r1, r1, #1	; 0x1
 3f16cb4:	e351003f 	cmp	r1, #63	; 0x3f
 3f16cb8:	dafffff9 	ble	3f16ca4 <WaitDownload+0x1ec>
	}

	return downloadFileSize - 10;
 3f16cbc:	e5950000 	ldr	r0, [r5]
 3f16cc0:	e240000a 	sub	r0, r0, #10	; 0xa
 3f16cc4:	ea000002 	b	3f16cd4 <WaitDownload+0x21c>
 3f16cc8:	03f1fe10 	mvneqs	r15, #256	; 0x100
 3f16ccc:	03f1fe30 	mvneqs	r15, #768	; 0x300
 3f16cd0:	03f6a120 	mvneqs	r10, #8	; 0x8
}
 3f16cd4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f16cd8 <init_usb_regs>:
 3f16cd8:	e1a0c00d 	mov	r12, r13
 3f16cdc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

void init_usb_regs(void)
{
	rFUNC_ADDR_REG = 0x00;
 3f16ce0:	e59f215c 	ldr	r2, [pc, #15c]	; 3f16e44 <init_usb_regs+0x16c>
	rPWR_REG = 0x00; 
	rEP_INT_REG = 0x00; 
	rUSB_INT_REG = 0x00;  
	rEP_INT_EN_REG = 0xff;   
 3f16ce4:	e59f115c 	ldr	r1, [pc, #15c]	; 3f16e48 <init_usb_regs+0x170>
 3f16ce8:	e3a03000 	mov	r3, #0	; 0x0
 3f16cec:	e1c230b0 	strh	r3, [r2]
 3f16cf0:	e2822002 	add	r2, r2, #2	; 0x2
 3f16cf4:	e1c230b0 	strh	r3, [r2]
 3f16cf8:	e2822002 	add	r2, r2, #2	; 0x2
 3f16cfc:	e1c230b0 	strh	r3, [r2]
 3f16d00:	e2822008 	add	r2, r2, #8	; 0x8
 3f16d04:	e1c230b0 	strh	r3, [r2]
 3f16d08:	e3a020ff 	mov	r2, #255	; 0xff
 3f16d0c:	e1c120b0 	strh	r2, [r1]
	rUSB_INT_EN_REG = 0x04;   
 3f16d10:	e2811008 	add	r1, r1, #8	; 0x8
 3f16d14:	e24220fb 	sub	r2, r2, #251	; 0xfb
 3f16d18:	e1c120b0 	strh	r2, [r1]
	rFRAME_NUM1_REG = 0x00;   
 3f16d1c:	e59f2128 	ldr	r2, [pc, #128]	; 3f16e4c <init_usb_regs+0x174>
	rFRAME_NUM2_REG = 0x00;   
	rINDEX_REG = 0x00;   
	rMAXP_REG = 0x01;   
 3f16d20:	e281100a 	add	r1, r1, #10	; 0xa
 3f16d24:	e1c230b0 	strh	r3, [r2]
 3f16d28:	e2822002 	add	r2, r2, #2	; 0x2
 3f16d2c:	e1c230b0 	strh	r3, [r2]
 3f16d30:	e2822002 	add	r2, r2, #2	; 0x2
 3f16d34:	e1c230b0 	strh	r3, [r2]
 3f16d38:	e3a02001 	mov	r2, #1	; 0x1
 3f16d3c:	e1c120b0 	strh	r2, [r1]
	rEP0_CSR = 0x00; 
 3f16d40:	e59f2108 	ldr	r2, [pc, #108]	; 3f16e50 <init_usb_regs+0x178>
 3f16d44:	e1c230b0 	strh	r3, [r2]
 3f16d48:	e24cb004 	sub	r11, r12, #4	; 0x4
	rIN_CSR1_REG = 0x00;
 3f16d4c:	e1c230b0 	strh	r3, [r2]
	rIN_CSR2_REG = 0x00; 
 3f16d50:	e2822002 	add	r2, r2, #2	; 0x2
 3f16d54:	e1c230b0 	strh	r3, [r2]
	rOUT_CSR1_REG = 0x00;
 3f16d58:	e2822004 	add	r2, r2, #4	; 0x4
 3f16d5c:	e1c230b0 	strh	r3, [r2]
	rOUT_CSR2_REG = 0x00; 
 3f16d60:	e2822002 	add	r2, r2, #2	; 0x2
 3f16d64:	e1c230b0 	strh	r3, [r2]
	rOUT_FIFO_CNT1_REG = 0x00;
 3f16d68:	e2822002 	add	r2, r2, #2	; 0x2
 3f16d6c:	e1c230b0 	strh	r3, [r2]
	rOUT_FIFO_CNT2_REG = 0x00;
 3f16d70:	e2822002 	add	r2, r2, #2	; 0x2
 3f16d74:	e1c230b0 	strh	r3, [r2]
	rEP0_FIFO = 0x00; 
 3f16d78:	e2822012 	add	r2, r2, #18	; 0x12
 3f16d7c:	e1c230b0 	strh	r3, [r2]
	rEP1_FIFO = 0x00; 
 3f16d80:	e2822002 	add	r2, r2, #2	; 0x2
 3f16d84:	e1c230b0 	strh	r3, [r2]
	rEP2_FIFO = 0x00;
 3f16d88:	e2822002 	add	r2, r2, #2	; 0x2
 3f16d8c:	e1c230b0 	strh	r3, [r2]
	rEP3_FIFO = 0x00;   
 3f16d90:	e2822002 	add	r2, r2, #2	; 0x2
 3f16d94:	e1c230b0 	strh	r3, [r2]
	rEP4_FIFO = 0x00;  
 3f16d98:	e2822002 	add	r2, r2, #2	; 0x2
 3f16d9c:	e1c230b0 	strh	r3, [r2]
	rEP1_DMA_CON = 0x00;
 3f16da0:	e2822018 	add	r2, r2, #24	; 0x18
 3f16da4:	e1c230b0 	strh	r3, [r2]
#if defined(CONFIG_S3C2410)
	rEP1_DMA_UNIT = 0x00;  
#endif
	rEP1_DMA_FIFO = 0x00;  
 3f16da8:	e2822004 	add	r2, r2, #4	; 0x4
 3f16dac:	e1c230b0 	strh	r3, [r2]
	rEP1_DMA_TTC_L = 0x00;   
 3f16db0:	e2822002 	add	r2, r2, #2	; 0x2
 3f16db4:	e1c230b0 	strh	r3, [r2]
	rEP1_DMA_TTC_M = 0x00;  
 3f16db8:	e2822002 	add	r2, r2, #2	; 0x2
 3f16dbc:	e1c230b0 	strh	r3, [r2]
	rEP1_DMA_TTC_H = 0x00; 
 3f16dc0:	e2822002 	add	r2, r2, #2	; 0x2
 3f16dc4:	e1c230b0 	strh	r3, [r2]
	rEP2_DMA_CON = 0x00;  
 3f16dc8:	e2822002 	add	r2, r2, #2	; 0x2
 3f16dcc:	e1c230b0 	strh	r3, [r2]
#if defined(CONFIG_S3C2410)
	rEP2_DMA_UNIT = 0x00;
#endif
	rEP2_DMA_FIFO = 0x00;
 3f16dd0:	e2822004 	add	r2, r2, #4	; 0x4
 3f16dd4:	e1c230b0 	strh	r3, [r2]
	rEP2_DMA_TTC_L = 0x00;  
 3f16dd8:	e2822002 	add	r2, r2, #2	; 0x2
 3f16ddc:	e1c230b0 	strh	r3, [r2]
	rEP2_DMA_TTC_M = 0x00; 
 3f16de0:	e2822002 	add	r2, r2, #2	; 0x2
 3f16de4:	e1c230b0 	strh	r3, [r2]
	rEP2_DMA_TTC_H = 0x00;
 3f16de8:	e2822002 	add	r2, r2, #2	; 0x2
 3f16dec:	e1c230b0 	strh	r3, [r2]
	rEP3_DMA_CON = 0x00;  
 3f16df0:	e282200a 	add	r2, r2, #10	; 0xa
 3f16df4:	e1c230b0 	strh	r3, [r2]
#if defined(CONFIG_S3C2410)
	rEP3_DMA_UNIT = 0x00;
#endif
	rEP3_DMA_FIFO = 0x00;   
 3f16df8:	e2822004 	add	r2, r2, #4	; 0x4
 3f16dfc:	e1c230b0 	strh	r3, [r2]
	rEP3_DMA_TTC_L = 0x00; 
 3f16e00:	e2822002 	add	r2, r2, #2	; 0x2
 3f16e04:	e1c230b0 	strh	r3, [r2]
	rEP3_DMA_TTC_M = 0x00;
 3f16e08:	e2822002 	add	r2, r2, #2	; 0x2
 3f16e0c:	e1c230b0 	strh	r3, [r2]
	rEP3_DMA_TTC_H = 0x00;
 3f16e10:	e2822002 	add	r2, r2, #2	; 0x2
 3f16e14:	e1c230b0 	strh	r3, [r2]
	rEP4_DMA_CON = 0x00; 
 3f16e18:	e2822002 	add	r2, r2, #2	; 0x2
 3f16e1c:	e1c230b0 	strh	r3, [r2]
#if defined(CONFIG_S3C2410)
	rEP4_DMA_UNIT = 0x00;   
#endif
	rEP4_DMA_FIFO = 0x00;
 3f16e20:	e2822004 	add	r2, r2, #4	; 0x4
 3f16e24:	e1c230b0 	strh	r3, [r2]
	rEP4_DMA_TTC_L = 0x00;  
 3f16e28:	e2822002 	add	r2, r2, #2	; 0x2
 3f16e2c:	e1c230b0 	strh	r3, [r2]
	rEP4_DMA_TTC_M = 0x00;  
 3f16e30:	e2822002 	add	r2, r2, #2	; 0x2
 3f16e34:	e1c230b0 	strh	r3, [r2]
	rEP4_DMA_TTC_H = 0x00;  
 3f16e38:	e2822002 	add	r2, r2, #2	; 0x2
 3f16e3c:	e1c230b0 	strh	r3, [r2]
 3f16e40:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f16e44:	c0001400 	andgt	r1, r0, r0, lsl #8
 3f16e48:	c000140e 	andgt	r1, r0, r14, lsl #8
 3f16e4c:	c0001418 	andgt	r1, r0, r8, lsl r4
 3f16e50:	c0001422 	andgt	r1, r0, r2, lsr #8

03f16e54 <InitUsbd>:
 3f16e54:	e1a0c00d 	mov	r12, r13
 3f16e58:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f16e5c:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void InitUsbd(void)
{
	DbgPrintf("****[%s:%d]->%s():\n", __FILE__, __LINE__, __FUNCTION__);

	ChangeUPllValue(40,1,2);  //UCLK=48Mhz
 3f16e60:	e3a00028 	mov	r0, #40	; 0x28
 3f16e64:	e3a01001 	mov	r1, #1	; 0x1
 3f16e68:	e3a02002 	mov	r2, #2	; 0x2
 3f16e6c:	ebfff2cc 	bl	3f139a4 <ChangeUPllValue>
	InitDescriptorTable();
 3f16e70:	eb000355 	bl	3f17bcc <InitDescriptorTable>
	//ResetUsbd();
	
	ConfigUsbd(); 
 3f16e74:	eb0003a8 	bl	3f17d1c <ConfigUsbd>

	//DetectVbus(); //not used in S3C2400X

	PrepareEp1Fifo(); 
 3f16e78:	eb0000a9 	bl	3f17124 <PrepareEp1Fifo>
 3f16e7c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f16e80 <IsrUsbd>:
 3f16e80:	e1a0c00d 	mov	r12, r13
 3f16e84:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
}

void IsrUsbd(void)
{
	U8 usbdIntpnd,epIntpnd;
	U8 saveIndexReg = rINDEX_REG;
 3f16e88:	e59fa0ac 	ldr	r10, [pc, #ac]	; 3f16f3c <IsrUsbd+0xbc>

	usbdIntpnd = rUSB_INT_REG;
 3f16e8c:	e59f50ac 	ldr	r5, [pc, #ac]	; 3f16f40 <IsrUsbd+0xc0>
 3f16e90:	e1da30b0 	ldrh	r3, [r10]
 3f16e94:	e1d520b0 	ldrh	r2, [r5]
 3f16e98:	e24cb004 	sub	r11, r12, #4	; 0x4
	epIntpnd = rEP_INT_REG;
 3f16e9c:	e59f60a0 	ldr	r6, [pc, #a0]	; 3f16f44 <IsrUsbd+0xc4>
 3f16ea0:	e1a01002 	mov	r1, r2
	//DbgPrintf( "[INT:EP_I=%x,USBI=%x]",epIntpnd,usbIntpnd );

	if(usbdIntpnd&SUSPEND_INT) {
 3f16ea4:	e3110001 	tst	r1, #1	; 0x1
 3f16ea8:	e1d620b0 	ldrh	r2, [r6]
 3f16eac:	e20370ff 	and	r7, r3, #255	; 0xff
 3f16eb0:	e1a04002 	mov	r4, r2
		rUSB_INT_REG = SUSPEND_INT;
 3f16eb4:	13a03001 	movne	r3, #1	; 0x1
 3f16eb8:	11c530b0 	strneh	r3, [r5]
		DbgPrintf( "<SUS]");
	}
	
	if(usbdIntpnd&RESUME_INT) {
 3f16ebc:	e3110002 	tst	r1, #2	; 0x2
		rUSB_INT_REG = RESUME_INT;
 3f16ec0:	13a03002 	movne	r3, #2	; 0x2
 3f16ec4:	11c530b0 	strneh	r3, [r5]
		DbgPrintf("<RSM]");
	}

	if(usbdIntpnd&RESET_INT) {
 3f16ec8:	e3110004 	tst	r1, #4	; 0x4
 3f16ecc:	0a000003 	beq	3f16ee0 <IsrUsbd+0x60>
		DbgPrintf( "<RST]");  
		//ResetUsbd();
		ReconfigUsbd();
 3f16ed0:	eb000396 	bl	3f17d30 <ReconfigUsbd>
		rUSB_INT_REG = RESET_INT;  //RESET_INT should be cleared after ResetUsbd().   
 3f16ed4:	e3a03004 	mov	r3, #4	; 0x4
 3f16ed8:	e1c530b0 	strh	r3, [r5]
		PrepareEp1Fifo(); 
 3f16edc:	eb000090 	bl	3f17124 <PrepareEp1Fifo>
	}

	if(epIntpnd&EP0_INT) {
 3f16ee0:	e3140001 	tst	r4, #1	; 0x1
 3f16ee4:	0a000002 	beq	3f16ef4 <IsrUsbd+0x74>
		rEP_INT_REG = EP0_INT;  
 3f16ee8:	e3a03001 	mov	r3, #1	; 0x1
 3f16eec:	e1c630b0 	strh	r3, [r6]
		Ep0Handler();
 3f16ef0:	eb0000c9 	bl	3f1721c <Ep0Handler>
	}
	if(epIntpnd&EP1_INT) {
 3f16ef4:	e3140002 	tst	r4, #2	; 0x2
 3f16ef8:	0a000002 	beq	3f16f08 <IsrUsbd+0x88>
		rEP_INT_REG = EP1_INT;  
 3f16efc:	e3a03002 	mov	r3, #2	; 0x2
 3f16f00:	e1c630b0 	strh	r3, [r6]
		Ep1Handler();
 3f16f04:	eb0000a3 	bl	3f17198 <Ep1Handler>
	}

	if(epIntpnd&EP2_INT) {
 3f16f08:	e3140004 	tst	r4, #4	; 0x4
		rEP_INT_REG = EP2_INT;  
 3f16f0c:	13a03004 	movne	r3, #4	; 0x4
 3f16f10:	11c630b0 	strneh	r3, [r6]
		DbgPrintf("<2:TBD]");   //not implemented yet
		//Ep2Handler();
	}

	if(epIntpnd&EP3_INT) {
 3f16f14:	e3140008 	tst	r4, #8	; 0x8
 3f16f18:	0a000002 	beq	3f16f28 <IsrUsbd+0xa8>
		rEP_INT_REG = EP3_INT;
 3f16f1c:	e3a03008 	mov	r3, #8	; 0x8
 3f16f20:	e1c630b0 	strh	r3, [r6]
		Ep3Handler();
 3f16f24:	eb000007 	bl	3f16f48 <Ep3Handler>
	}

	if(epIntpnd&EP4_INT) {
 3f16f28:	e3140010 	tst	r4, #16	; 0x10
		rEP_INT_REG = EP4_INT;
 3f16f2c:	13a03010 	movne	r3, #16	; 0x10
 3f16f30:	11c630b0 	strneh	r3, [r6]
		DbgPrintf("<4:TBD]");   //not implemented yet
		//Ep4Handler();
	}

	rINDEX_REG = saveIndexReg;
 3f16f34:	e1ca70b0 	strh	r7, [r10]
}
 3f16f38:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}
 3f16f3c:	c000141c 	andgt	r1, r0, r12, lsl r4
 3f16f40:	c000140c 	andgt	r1, r0, r12, lsl #8
 3f16f44:	c0001404 	andgt	r1, r0, r4, lsl #8

03f16f48 <Ep3Handler>:
 3f16f48:	e1a0c00d 	mov	r12, r13
 3f16f4c:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}

void Ep3Handler(void)
{
	U8 out_csr3;
	int fifoCnt;
	rINDEX_REG=3;
 3f16f50:	e59f3100 	ldr	r3, [pc, #100]	; 3f17058 <Ep3Handler+0x110>
 3f16f54:	e3a02003 	mov	r2, #3	; 0x3
 3f16f58:	e1c320b0 	strh	r2, [r3]

	out_csr3=rOUT_CSR1_REG;
 3f16f5c:	e59f20f8 	ldr	r2, [pc, #f8]	; 3f1705c <Ep3Handler+0x114>
 3f16f60:	e1d230b0 	ldrh	r3, [r2]
 3f16f64:	e24cb004 	sub	r11, r12, #4	; 0x4
	
	DbgPrintf("<3:%x]",out_csr3);

	if(out_csr3 & EPO_OUT_PKT_READY)
 3f16f68:	e3130001 	tst	r3, #1	; 0x1
 3f16f6c:	e20370ff 	and	r7, r3, #255	; 0xff
 3f16f70:	0a000034 	beq	3f17048 <Ep3Handler+0x100>
	{   
		fifoCnt=rOUT_FIFO_CNT1_REG; 
 3f16f74:	e59f30e4 	ldr	r3, [pc, #e4]	; 3f17060 <Ep3Handler+0x118>
#if 0
	RdPktEp3(ep3Buf,fifoCnt);
	PrintEpoPkt(ep3Buf,fifoCnt);
#else

		if(downloadFileSize==0)
 3f16f78:	e59f40e4 	ldr	r4, [pc, #e4]	; 3f17064 <Ep3Handler+0x11c>
 3f16f7c:	e1d320b0 	ldrh	r2, [r3]
 3f16f80:	e5943000 	ldr	r3, [r4]
 3f16f84:	e3530000 	cmp	r3, #0	; 0x0
 3f16f88:	e1a05002 	mov	r5, r2
 3f16f8c:	1a000022 	bne	3f1701c <Ep3Handler+0xd4>
		{
			RdPktEp3((U8 *)downPt,8); 
 3f16f90:	e59f60d0 	ldr	r6, [pc, #d0]	; 3f17068 <Ep3Handler+0x120>
 3f16f94:	e5960000 	ldr	r0, [r6]
 3f16f98:	e3a01008 	mov	r1, #8	; 0x8
 3f16f9c:	eb0003ee 	bl	3f17f5c <RdPktEp3>
		
			if(download_run==0)
 3f16fa0:	e59f30c4 	ldr	r3, [pc, #c4]	; 3f1706c <Ep3Handler+0x124>
 3f16fa4:	e5933000 	ldr	r3, [r3]
 3f16fa8:	e3530000 	cmp	r3, #0	; 0x0
			{
				downloadAddress=tempDownloadAddress;
			}
			else
			{
#if 0			
				downloadAddress=
					*((U8 *)(downPt+0))+
					(*((U8 *)(downPt+1))<<8)+
					(*((U8 *)(downPt+2))<<16)+
					(*((U8 *)(downPt+3))<<24);
#else
				downloadAddress=cmd_offset;
 3f16fac:	e59f30bc 	ldr	r3, [pc, #bc]	; 3f17070 <Ep3Handler+0x128>
 3f16fb0:	059f30bc 	ldreq	r3, [pc, #bc]	; 3f17074 <Ep3Handler+0x12c>
 3f16fb4:	e59f20bc 	ldr	r2, [pc, #bc]	; 3f17078 <Ep3Handler+0x130>
 3f16fb8:	e5933000 	ldr	r3, [r3]
 3f16fbc:	e5823000 	str	r3, [r2]
#endif		
			}
			downloadFileSize=
 3f16fc0:	e5962000 	ldr	r2, [r6]
 3f16fc4:	e5d23004 	ldrb	r3, [r2, #4]
 3f16fc8:	e5d21005 	ldrb	r1, [r2, #5]
 3f16fcc:	e5d20006 	ldrb	r0, [r2, #6]
 3f16fd0:	e5d22007 	ldrb	r2, [r2, #7]
 3f16fd4:	e1833401 	orr	r3, r3, r1, lsl #8
 3f16fd8:	e1833800 	orr	r3, r3, r0, lsl #16
 3f16fdc:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f16fe0:	e5843000 	str	r3, [r4]
				*((U8 *)(downPt+4))+
				(*((U8 *)(downPt+5))<<8)+
				(*((U8 *)(downPt+6))<<16)+
				(*((U8 *)(downPt+7))<<24);
			checkSum=0;
 3f16fe4:	e59f2090 	ldr	r2, [pc, #90]	; 3f1707c <Ep3Handler+0x134>
 3f16fe8:	e3a03000 	mov	r3, #0	; 0x0
 3f16fec:	e1c230b0 	strh	r3, [r2]
			downPt=(U8 *)downloadAddress;
 3f16ff0:	e59f3080 	ldr	r3, [pc, #80]	; 3f17078 <Ep3Handler+0x130>

			RdPktEp3_CheckSum((U8 *)downPt,fifoCnt-8); //The first 8-bytes are deleted.
 3f16ff4:	e2454008 	sub	r4, r5, #8	; 0x8
 3f16ff8:	e5933000 	ldr	r3, [r3]
 3f16ffc:	e1a01004 	mov	r1, r4
 3f17000:	e1a00003 	mov	r0, r3
 3f17004:	e5863000 	str	r3, [r6]
 3f17008:	eb000024 	bl	3f170a0 <RdPktEp3_CheckSum>
			downPt+=fifoCnt-8;  
 3f1700c:	e5963000 	ldr	r3, [r6]
 3f17010:	e0833004 	add	r3, r3, r4
 3f17014:	e5863000 	str	r3, [r6]
		}
 3f17018:	ea000006 	b	3f17038 <Ep3Handler+0xf0>
		else
		{
			RdPktEp3_CheckSum((U8 *)downPt,fifoCnt); 
 3f1701c:	e59f4044 	ldr	r4, [pc, #44]	; 3f17068 <Ep3Handler+0x120>
 3f17020:	e5940000 	ldr	r0, [r4]
 3f17024:	e1a01005 	mov	r1, r5
 3f17028:	eb00001c 	bl	3f170a0 <RdPktEp3_CheckSum>
			downPt+=fifoCnt;  //fifoCnt=64
 3f1702c:	e5943000 	ldr	r3, [r4]
 3f17030:	e0833005 	add	r3, r3, r5
 3f17034:	e5843000 	str	r3, [r4]
		}
#endif
	CLR_EP3_OUT_PKT_READY();
 3f17038:	e59f201c 	ldr	r2, [pc, #1c]	; 3f1705c <Ep3Handler+0x114>
 3f1703c:	e207304e 	and	r3, r7, #78	; 0x4e
 3f17040:	e1c230b0 	strh	r3, [r2]
	return;
 3f17044:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
	}

	
	//I think that EPO_SENT_STALL will not be set to 1.
	if(out_csr3 & EPO_SENT_STALL)
 3f17048:	e3130040 	tst	r3, #64	; 0x40
	{
		DbgPrintf("[STALL]");
		CLR_EP3_SENT_STALL();
 3f1704c:	1203300f 	andne	r3, r3, #15	; 0xf
 3f17050:	11c230b0 	strneh	r3, [r2]
		return;
	}
}
 3f17054:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f17058:	c000141c 	andgt	r1, r0, r12, lsl r4
 3f1705c:	c0001428 	andgt	r1, r0, r8, lsr #8
 3f17060:	c000142c 	andgt	r1, r0, r12, lsr #8
 3f17064:	03f73050 	mvneqs	r3, #80	; 0x50
 3f17068:	03f7304c 	mvneqs	r3, #76	; 0x4c
 3f1706c:	03f6a1a8 	mvneqs	r10, #42	; 0x2a
 3f17070:	03f73040 	mvneqs	r3, #64	; 0x40
 3f17074:	03f72fb4 	mvneqs	r2, #720	; 0x2d0
 3f17078:	03f73048 	mvneqs	r3, #72	; 0x48
 3f1707c:	03f73054 	mvneqs	r3, #84	; 0x54

03f17080 <PrintEpoPkt>:
 3f17080:	e1a0c00d 	mov	r12, r13
 3f17084:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17088:	e24cb004 	sub	r11, r12, #4	; 0x4

void PrintEpoPkt(U8 *pt,int cnt)
{
	int i;
	DbgPrintf("[BOUT:%d:",cnt);
	for(i=0;i<cnt;i++)
 3f1708c:	e3510000 	cmp	r1, #0	; 0x0
 3f17090:	d91ba800 	ldmledb	r11, {r11, r13, r15}
 3f17094:	e2511001 	subs	r1, r1, #1	; 0x1
 3f17098:	1afffffd 	bne	3f17094 <PrintEpoPkt+0x14>
		DbgPrintf("%x,",pt[i]);
	DbgPrintf("]");
}
 3f1709c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f170a0 <RdPktEp3_CheckSum>:
 3f170a0:	e1a0c00d 	mov	r12, r13
 3f170a4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f170a8:	e24cb004 	sub	r11, r12, #4	; 0x4

void RdPktEp3_CheckSum(U8 *buf,int num)
{
	int i;
		
	for(i=0;i<num;i++)
 3f170ac:	e3a0c000 	mov	r12, #0	; 0x0
 3f170b0:	e1a0e001 	mov	r14, r1
 3f170b4:	e15c000e 	cmp	r12, r14
 3f170b8:	a91ba800 	ldmgedb	r11, {r11, r13, r15}
	{
		buf[i]=(U8)rEP3_FIFO;
 3f170bc:	e59f3028 	ldr	r3, [pc, #28]	; 3f170ec <RdPktEp3_CheckSum+0x4c>
		checkSum+=buf[i];
 3f170c0:	e59f2028 	ldr	r2, [pc, #28]	; 3f170f0 <RdPktEp3_CheckSum+0x50>
 3f170c4:	e1d330b0 	ldrh	r3, [r3]
 3f170c8:	e7c0300c 	strb	r3, [r0, r12]
 3f170cc:	e7d0100c 	ldrb	r1, [r0, r12]
 3f170d0:	e28cc001 	add	r12, r12, #1	; 0x1
 3f170d4:	e1d230b0 	ldrh	r3, [r2]
 3f170d8:	e15c000e 	cmp	r12, r14
 3f170dc:	e0833001 	add	r3, r3, r1
 3f170e0:	e1c230b0 	strh	r3, [r2]
 3f170e4:	bafffff4 	blt	3f170bc <RdPktEp3_CheckSum+0x1c>
	}
}
 3f170e8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f170ec:	c0001446 	andgt	r1, r0, r6, asr #8
 3f170f0:	03f73054 	mvneqs	r3, #84	; 0x54

03f170f4 <ClearEp3OutPktReady>:
 3f170f4:	e1a0c00d 	mov	r12, r13
 3f170f8:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}


void ClearEp3OutPktReady(void)
{
	U8 out_csr3;
	rINDEX_REG=3;
 3f170fc:	e59f201c 	ldr	r2, [pc, #1c]	; 3f17120 <ClearEp3OutPktReady+0x2c>
 3f17100:	e3a03003 	mov	r3, #3	; 0x3
 3f17104:	e1c230b0 	strh	r3, [r2]
	out_csr3=rOUT_CSR1_REG;
 3f17108:	e282200c 	add	r2, r2, #12	; 0xc
 3f1710c:	e1d230b0 	ldrh	r3, [r2]
 3f17110:	e24cb004 	sub	r11, r12, #4	; 0x4
	CLR_EP3_OUT_PKT_READY();
 3f17114:	e203304e 	and	r3, r3, #78	; 0x4e
 3f17118:	e1c230b0 	strh	r3, [r2]
}
 3f1711c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f17120:	c000141c 	andgt	r1, r0, r12, lsl r4

03f17124 <PrepareEp1Fifo>:
 3f17124:	e1a0c00d 	mov	r12, r13
 3f17128:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}

void PrepareEp1Fifo(void) 
{
	int i;
	U8 in_csr1;
	rINDEX_REG=1;
 3f1712c:	e59f2054 	ldr	r2, [pc, #54]	; 3f17188 <PrepareEp1Fifo+0x64>
 3f17130:	e3a03001 	mov	r3, #1	; 0x1
 3f17134:	e1c230b0 	strh	r3, [r2]
	in_csr1=rIN_CSR1_REG;
 3f17138:	e59f304c 	ldr	r3, [pc, #4c]	; 3f1718c <PrepareEp1Fifo+0x68>
 3f1713c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f17140:	e1d330b0 	ldrh	r3, [r3]
	
	for(i=0;i<EP1_PKT_SIZE;i++) ep1Buf[i]=(U8)(transferIndex+i);
 3f17144:	e3a02000 	mov	r2, #0	; 0x0
 3f17148:	e20340ff 	and	r4, r3, #255	; 0xff
 3f1714c:	e59f303c 	ldr	r3, [pc, #3c]	; 3f17190 <PrepareEp1Fifo+0x6c>
 3f17150:	e5d33000 	ldrb	r3, [r3]
 3f17154:	e59f0038 	ldr	r0, [pc, #38]	; 3f17194 <PrepareEp1Fifo+0x70>
 3f17158:	e0833002 	add	r3, r3, r2
 3f1715c:	e7c03002 	strb	r3, [r0, r2]
 3f17160:	e2822001 	add	r2, r2, #1	; 0x1
 3f17164:	e352003f 	cmp	r2, #63	; 0x3f
 3f17168:	dafffff7 	ble	3f1714c <PrepareEp1Fifo+0x28>
	WrPktEp1(ep1Buf,EP1_PKT_SIZE);
 3f1716c:	e3a01040 	mov	r1, #64	; 0x40
 3f17170:	eb00035d 	bl	3f17eec <WrPktEp1>
	SET_EP1_IN_PKT_READY(); 
 3f17174:	e20430b6 	and	r3, r4, #182	; 0xb6
 3f17178:	e59f200c 	ldr	r2, [pc, #c]	; 3f1718c <PrepareEp1Fifo+0x68>
 3f1717c:	e3833001 	orr	r3, r3, #1	; 0x1
 3f17180:	e1c230b0 	strh	r3, [r2]
}
 3f17184:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f17188:	c000141c 	andgt	r1, r0, r12, lsl r4
 3f1718c:	c0001422 	andgt	r1, r0, r2, lsr #8
 3f17190:	03f6a1a4 	mvneqs	r10, #41	; 0x29
 3f17194:	03f72ff8 	mvneqs	r2, #992	; 0x3e0

03f17198 <Ep1Handler>:
 3f17198:	e1a0c00d 	mov	r12, r13
 3f1719c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

void Ep1Handler(void)
{
	U8 in_csr1;
	rINDEX_REG=1;
 3f171a0:	e59f3044 	ldr	r3, [pc, #44]	; 3f171ec <Ep1Handler+0x54>
 3f171a4:	e3a02001 	mov	r2, #1	; 0x1
 3f171a8:	e1c320b0 	strh	r2, [r3]
	in_csr1=rIN_CSR1_REG;
 3f171ac:	e59f203c 	ldr	r2, [pc, #3c]	; 3f171f0 <Ep1Handler+0x58>
 3f171b0:	e1d230b0 	ldrh	r3, [r2]
 3f171b4:	e24cb004 	sub	r11, r12, #4	; 0x4
	
	DbgPrintf("<1:%x]",in_csr1);

	//I think that EPI_SENT_STALL will not be set to 1.
	if(in_csr1 & EPI_SENT_STALL)
 3f171b8:	e3130020 	tst	r3, #32	; 0x20
	{
		DbgPrintf("[STALL]");
		CLR_EP1_SENT_STALL();
 3f171bc:	12033096 	andne	r3, r3, #150	; 0x96
 3f171c0:	11c230b0 	strneh	r3, [r2]
		return;
 3f171c4:	191ba800 	ldmnedb	r11, {r11, r13, r15}
	}

	//IN_PKT_READY is cleared
	
	//The data transfered was ep1Buf[] which was already configured 

	PrintEpiPkt(ep1Buf,EP1_PKT_SIZE); 
 3f171c8:	e59f0024 	ldr	r0, [pc, #24]	; 3f171f4 <Ep1Handler+0x5c>
 3f171cc:	e3a01040 	mov	r1, #64	; 0x40
 3f171d0:	eb000009 	bl	3f171fc <PrintEpiPkt>
	
	transferIndex++;
 3f171d4:	e59f201c 	ldr	r2, [pc, #1c]	; 3f171f8 <Ep1Handler+0x60>
 3f171d8:	e5923000 	ldr	r3, [r2]
 3f171dc:	e2833001 	add	r3, r3, #1	; 0x1
 3f171e0:	e5823000 	str	r3, [r2]

	PrepareEp1Fifo(); 
 3f171e4:	ebffffce 	bl	3f17124 <PrepareEp1Fifo>
	//IN_PKT_READY is set   
	//This packit will be used for next IN packit.

	return;
}
 3f171e8:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f171ec:	c000141c 	andgt	r1, r0, r12, lsl r4
 3f171f0:	c0001422 	andgt	r1, r0, r2, lsr #8
 3f171f4:	03f72ff8 	mvneqs	r2, #992	; 0x3e0
 3f171f8:	03f6a1a4 	mvneqs	r10, #41	; 0x29

03f171fc <PrintEpiPkt>:
 3f171fc:	e1a0c00d 	mov	r12, r13
 3f17200:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17204:	e24cb004 	sub	r11, r12, #4	; 0x4

void PrintEpiPkt(U8 *pt,int cnt)
{
	int i;
	DbgPrintf("[B_IN:%d:",cnt);
	for(i=0;i<cnt;i++)
 3f17208:	e3510000 	cmp	r1, #0	; 0x0
 3f1720c:	d91ba800 	ldmledb	r11, {r11, r13, r15}
 3f17210:	e2511001 	subs	r1, r1, #1	; 0x1
 3f17214:	1afffffd 	bne	3f17210 <PrintEpiPkt+0x14>
		DbgPrintf("%x,",pt[i]);
	DbgPrintf("]");
}
 3f17218:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1721c <Ep0Handler>:
 3f1721c:	e1a0c00d 	mov	r12, r13
 3f17220:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}

void Ep0Handler(void)
{
	static int ep0SubState;
	U8 ep0_csr;

	rINDEX_REG=0;
 3f17224:	e59f33bc 	ldr	r3, [pc, #3bc]	; 3f175e8 <Ep0Handler+0x3cc>
	ep0_csr=rEP0_CSR;
 3f17228:	e59f13bc 	ldr	r1, [pc, #3bc]	; 3f175ec <Ep0Handler+0x3d0>
 3f1722c:	e3a02000 	mov	r2, #0	; 0x0
 3f17230:	e1c320b0 	strh	r2, [r3]
 3f17234:	e1d130b0 	ldrh	r3, [r1]
 3f17238:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f1723c:	e1a02003 	mov	r2, r3
 3f17240:	e20250ff 	and	r5, r2, #255	; 0xff
	
	DbgPrintf("<0:%x]",ep0_csr);

	//DATAEND interrupt(ep0_csr==0x0) will be ignored 
	//because ep0State==EP0_STATE_INIT when the DATAEND interrupt is issued.

	
	DbgPrintf2("****[%s:%d]->%s():\n", __FILE__, __LINE__, __FUNCTION__);
	if(ep0_csr & EP0_SETUP_END) {   
 3f17244:	e2120010 	ands	r0, r2, #16	; 0x10
 3f17248:	0a000013 	beq	3f1729c <Ep0Handler+0x80>
		// Host may end GET_DESCRIPTOR operation without completing the IN data stage.
		// If host does that, SETUP_END bit will be set.
		// OUT_PKT_RDY has to be also cleared because status stage sets OUT_PKT_RDY to 1.
		DbgPrintf("[SETUPEND]");
		CLR_EP0_SETUP_END();

		if(ep0_csr & EP0_OUT_PKT_READY) {
 3f1724c:	e3120001 	tst	r2, #1	; 0x1
 3f17250:	e202303f 	and	r3, r2, #63	; 0x3f
 3f17254:	e3833080 	orr	r3, r3, #128	; 0x80
 3f17258:	e1c130b0 	strh	r3, [r1]
 3f1725c:	0a00000a 	beq	3f1728c <Ep0Handler+0x70>
			FLUSH_EP0_FIFO(); //(???)
 3f17260:	e59f2388 	ldr	r2, [pc, #388]	; 3f175f0 <Ep0Handler+0x3d4>
 3f17264:	ea000001 	b	3f17270 <Ep0Handler+0x54>
 3f17268:	e59f3384 	ldr	r3, [pc, #384]	; 3f175f4 <Ep0Handler+0x3d8>
 3f1726c:	e1d330b0 	ldrh	r3, [r3]
 3f17270:	e1d230b0 	ldrh	r3, [r2]
 3f17274:	e3530000 	cmp	r3, #0	; 0x0
 3f17278:	1afffffa 	bne	3f17268 <Ep0Handler+0x4c>
			//I think this isn't needed because EP0 flush is done automatically.   
			CLR_EP0_OUT_PKT_RDY();
 3f1727c:	e205303f 	and	r3, r5, #63	; 0x3f
 3f17280:	e59f2364 	ldr	r2, [pc, #364]	; 3f175ec <Ep0Handler+0x3d0>
 3f17284:	e3833040 	orr	r3, r3, #64	; 0x40
 3f17288:	e1c230b0 	strh	r3, [r2]
		}
	
		ep0State=EP0_STATE_INIT;
 3f1728c:	e59f2364 	ldr	r2, [pc, #364]	; 3f175f8 <Ep0Handler+0x3dc>
 3f17290:	e3a03000 	mov	r3, #0	; 0x0
 3f17294:	e5823000 	str	r3, [r2]
		return;
 3f17298:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
	}

	//I think that EP0_SENT_STALL will not be set to 1.
	if(ep0_csr & EP0_SENT_STALL) {   
 3f1729c:	e3120004 	tst	r2, #4	; 0x4
 3f172a0:	0a000008 	beq	3f172c8 <Ep0Handler+0xac>
		DbgPrintf("[STALL]");
		CLR_EP0_SENT_STALL();
		if(ep0_csr & EP0_OUT_PKT_READY) {
 3f172a4:	e3120001 	tst	r2, #1	; 0x1
 3f172a8:	e202303b 	and	r3, r2, #59	; 0x3b
 3f172ac:	e1c130b0 	strh	r3, [r1]
			CLR_EP0_OUT_PKT_RDY();
 3f172b0:	1202303f 	andne	r3, r2, #63	; 0x3f
 3f172b4:	13833040 	orrne	r3, r3, #64	; 0x40
 3f172b8:	11c130b0 	strneh	r3, [r1]
		}

		ep0State=EP0_STATE_INIT;
 3f172bc:	e59f3334 	ldr	r3, [pc, #334]	; 3f175f8 <Ep0Handler+0x3dc>
 3f172c0:	e5830000 	str	r0, [r3]
		return;
 3f172c4:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
	}

	if((ep0_csr & EP0_OUT_PKT_READY) && (ep0State==EP0_STATE_INIT)) {
 3f172c8:	e3120001 	tst	r2, #1	; 0x1
 3f172cc:	0a000116 	beq	3f1772c <Ep0Handler+0x510>
 3f172d0:	e59f6320 	ldr	r6, [pc, #320]	; 3f175f8 <Ep0Handler+0x3dc>
 3f172d4:	e5963000 	ldr	r3, [r6]
 3f172d8:	e3530000 	cmp	r3, #0	; 0x0
 3f172dc:	1a000112 	bne	3f1772c <Ep0Handler+0x510>
		RdPktEp0((U8 *)&descSetup,EP0_PKT_SIZE);
 3f172e0:	e59f4314 	ldr	r4, [pc, #314]	; 3f175fc <Ep0Handler+0x3e0>
 3f172e4:	e3a01008 	mov	r1, #8	; 0x8
 3f172e8:	e1a00004 	mov	r0, r4
 3f172ec:	eb0002da 	bl	3f17e5c <RdPktEp0>

		PrintEp0Pkt((U8 *)(&descSetup)); //DEBUG
 3f172f0:	e1a00004 	mov	r0, r4
 3f172f4:	eb00022d 	bl	3f17bb0 <PrintEp0Pkt>

		switch(descSetup.bRequest) {
 3f172f8:	e5d43001 	ldrb	r3, [r4, #1]
 3f172fc:	e353000c 	cmp	r3, #12	; 0xc
 3f17300:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f17304:	ea000102 	b	3f17714 <Ep0Handler+0x4f8>
 3f17308:	03f17560 	mvneqs	r7, #402653184	; 0x18000000
 3f1730c:	03f174bc 	mvneqs	r7, #-1140850688	; 0xbc000000
 3f17310:	03f17714 	mvneqs	r7, #5242880	; 0x500000
 3f17314:	03f17670 	mvneqs	r7, #117440512	; 0x7000000
 3f17318:	03f17714 	mvneqs	r7, #5242880	; 0x500000
 3f1731c:	03f1746c 	mvneqs	r7, #1811939328	; 0x6c000000
 3f17320:	03f1733c 	mvneqs	r7, #-268435456	; 0xf0000000
 3f17324:	03f17714 	mvneqs	r7, #5242880	; 0x500000
 3f17328:	03f17530 	mvneqs	r7, #201326592	; 0xc000000
 3f1732c:	03f17488 	mvneqs	r7, #-2013265920	; 0x88000000
 3f17330:	03f17548 	mvneqs	r7, #301989888	; 0x12000000
 3f17334:	03f176f0 	mvneqs	r7, #251658240	; 0xf000000
 3f17338:	03f17708 	mvneqs	r7, #2097152	; 0x200000
			DbgPrintf2("****[%s:%d]->%s(): descSetup.bRequest(0x%x)\n", __FILE__, __LINE__, __FUNCTION__, descSetup.bRequest);
		case GET_DESCRIPTOR:
			DbgPrintf2("****[%s:%d]->%s(): descSetup.bValueH(0x%x)\n", __FILE__, __LINE__, __FUNCTION__, descSetup.bValueH);
			switch(descSetup.bValueH) {
 3f1733c:	e5d43003 	ldrb	r3, [r4, #3]
 3f17340:	e2433001 	sub	r3, r3, #1	; 0x1
 3f17344:	e3530004 	cmp	r3, #4	; 0x4
 3f17348:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f1734c:	ea000045 	b	3f17468 <Ep0Handler+0x24c>
 3f17350:	03f17364 	mvneqs	r7, #-1879048191	; 0x90000001
 3f17354:	03f1737c 	mvneqs	r7, #-268435455	; 0xf0000001
 3f17358:	03f173b4 	mvneqs	r7, #-805306366	; 0xd0000002
 3f1735c:	03f17414 	mvneqs	r7, #335544320	; 0x14000000
 3f17360:	03f1742c 	mvneqs	r7, #738197504	; 0x2c000000
			case DEVICE_TYPE:
				DbgPrintf("[GDD]");
				CLR_EP0_OUT_PKT_RDY();
				ep0State=EP0_STATE_GD_DEV_0;
 3f17364:	e3a0300a 	mov	r3, #10	; 0xa
 3f17368:	e5863000 	str	r3, [r6]
 3f1736c:	e205303f 	and	r3, r5, #63	; 0x3f
 3f17370:	e59f2274 	ldr	r2, [pc, #274]	; 3f175ec <Ep0Handler+0x3d0>
 3f17374:	e3833040 	orr	r3, r3, #64	; 0x40
				break;
 3f17378:	ea0000ea 	b	3f17728 <Ep0Handler+0x50c>
			case CONFIGURATION_TYPE:
				DbgPrintf("[GDC]");
				CLR_EP0_OUT_PKT_RDY();
				if((descSetup.bLengthL+(descSetup.bLengthH<<8))>0x9)
 3f1737c:	e5d43006 	ldrb	r3, [r4, #6]
 3f17380:	e5d42007 	ldrb	r2, [r4, #7]
 3f17384:	e1833402 	orr	r3, r3, r2, lsl #8
 3f17388:	e3530009 	cmp	r3, #9	; 0x9
 3f1738c:	e205303f 	and	r3, r5, #63	; 0x3f
 3f17390:	e59f2254 	ldr	r2, [pc, #254]	; 3f175ec <Ep0Handler+0x3d0>
 3f17394:	e3833040 	orr	r3, r3, #64	; 0x40
 3f17398:	e1c230b0 	strh	r3, [r2]
					//bLengthH should be used for bLength=0x209 at WIN2K.
					ep0State=EP0_STATE_GD_CFG_0; //for WIN98,WIN2K
 3f1739c:	c3a03014 	movgt	r3, #20	; 0x14
 3f173a0:	c5863000 	strgt	r3, [r6]
 3f173a4:	ca0000e0 	bgt	3f1772c <Ep0Handler+0x510>
				else
					ep0State=EP0_STATE_GD_CFG_ONLY_0; //for WIN2K
 3f173a8:	e3a03028 	mov	r3, #40	; 0x28
 3f173ac:	e5863000 	str	r3, [r6]
				break;
 3f173b0:	ea0000dd 	b	3f1772c <Ep0Handler+0x510>
			case STRING_TYPE:
				DbgPrintf("[GDS]");
				CLR_EP0_OUT_PKT_RDY();
 3f173b4:	e205303f 	and	r3, r5, #63	; 0x3f
 3f173b8:	e59f222c 	ldr	r2, [pc, #22c]	; 3f175ec <Ep0Handler+0x3d0>
 3f173bc:	e3833040 	orr	r3, r3, #64	; 0x40
 3f173c0:	e1c230b0 	strh	r3, [r2]
				switch(descSetup.bValueL) {
 3f173c4:	e5d43002 	ldrb	r3, [r4, #2]
 3f173c8:	e3530003 	cmp	r3, #3	; 0x3
 3f173cc:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f173d0:	ea00000b 	b	3f17404 <Ep0Handler+0x1e8>
 3f173d4:	03f173e4 	mvneqs	r7, #-1879048189	; 0x90000003
 3f173d8:	03f173ec 	mvneqs	r7, #-1342177277	; 0xb0000003
 3f173dc:	03f173f4 	mvneqs	r7, #-805306365	; 0xd0000003
 3f173e0:	03f173fc 	mvneqs	r7, #-268435453	; 0xf0000003
				case 0:
					ep0State=EP0_STATE_GD_STR_I0;
 3f173e4:	e3a0301e 	mov	r3, #30	; 0x1e
					break;
 3f173e8:	ea000004 	b	3f17400 <Ep0Handler+0x1e4>
				case 1:
					ep0State=EP0_STATE_GD_STR_I1;
 3f173ec:	e3a0301f 	mov	r3, #31	; 0x1f
					break;
 3f173f0:	ea000002 	b	3f17400 <Ep0Handler+0x1e4>
				case 2:
					ep0State=EP0_STATE_GD_STR_I2;
 3f173f4:	e3a03020 	mov	r3, #32	; 0x20
					break;
 3f173f8:	ea000000 	b	3f17400 <Ep0Handler+0x1e4>
				case 3:
					ep0State=EP0_STATE_GD_STR_I3;
 3f173fc:	e3a03046 	mov	r3, #70	; 0x46
 3f17400:	e5863000 	str	r3, [r6]
					break;
				default:
					DbgPrintf("[UE:STRI?]");
					break;
				}
				ep0SubState=0;
 3f17404:	e59f21f4 	ldr	r2, [pc, #1f4]	; 3f17600 <Ep0Handler+0x3e4>
 3f17408:	e3a03000 	mov	r3, #0	; 0x0
 3f1740c:	e5823000 	str	r3, [r2]
				break;
 3f17410:	ea0000c5 	b	3f1772c <Ep0Handler+0x510>
			case INTERFACE_TYPE:
				DbgPrintf("[GDI]");
				CLR_EP0_OUT_PKT_RDY();
				ep0State=EP0_STATE_GD_IF_ONLY_0; //for WIN98
 3f17414:	e3a0302a 	mov	r3, #42	; 0x2a
 3f17418:	e5863000 	str	r3, [r6]
 3f1741c:	e205303f 	and	r3, r5, #63	; 0x3f
 3f17420:	e59f21c4 	ldr	r2, [pc, #1c4]	; 3f175ec <Ep0Handler+0x3d0>
 3f17424:	e3833040 	orr	r3, r3, #64	; 0x40
				break;
 3f17428:	ea0000be 	b	3f17728 <Ep0Handler+0x50c>
			case ENDPOINT_TYPE:
				DbgPrintf("[GDE]");
				CLR_EP0_OUT_PKT_RDY();
 3f1742c:	e205203f 	and	r2, r5, #63	; 0x3f
				switch(descSetup.bValueL&0xf) {
 3f17430:	e5d41002 	ldrb	r1, [r4, #2]
 3f17434:	e3822040 	orr	r2, r2, #64	; 0x40
 3f17438:	e59f31ac 	ldr	r3, [pc, #1ac]	; 3f175ec <Ep0Handler+0x3d0>
 3f1743c:	e211100f 	ands	r1, r1, #15	; 0xf
 3f17440:	e1c320b0 	strh	r2, [r3]
 3f17444:	0a000002 	beq	3f17454 <Ep0Handler+0x238>
 3f17448:	e3510001 	cmp	r1, #1	; 0x1
 3f1744c:	0a000003 	beq	3f17460 <Ep0Handler+0x244>
 3f17450:	ea0000b5 	b	3f1772c <Ep0Handler+0x510>
				case 0:
					ep0State=EP0_STATE_GD_EP0_ONLY_0;
 3f17454:	e3a0302c 	mov	r3, #44	; 0x2c
 3f17458:	e5863000 	str	r3, [r6]
					break;
 3f1745c:	ea0000b2 	b	3f1772c <Ep0Handler+0x510>
				case 1:
					ep0State=EP0_STATE_GD_EP1_ONLY_0;
 3f17460:	e3a0302d 	mov	r3, #45	; 0x2d
 3f17464:	e5863000 	str	r3, [r6]
					break;
				default:
					DbgPrintf("[UE:GDE?]");
					break;
				}
				break;
			default:
				DbgPrintf("[UE:GD?]");
				break;
			}
			break;
 3f17468:	ea0000af 	b	3f1772c <Ep0Handler+0x510>

		case SET_ADDRESS:
			DbgPrintf("[SA:%d]",descSetup.bValueL);
			rFUNC_ADDR_REG=descSetup.bValueL | 0x80;
			CLR_EP0_OUTPKTRDY_DATAEND(); //Because of no data control transfers.
			ep0State=EP0_STATE_INIT;
 3f1746c:	e3a03000 	mov	r3, #0	; 0x0
 3f17470:	e5863000 	str	r3, [r6]
 3f17474:	e5d43002 	ldrb	r3, [r4, #2]
 3f17478:	e59f2184 	ldr	r2, [pc, #184]	; 3f17604 <Ep0Handler+0x3e8>
 3f1747c:	e3833080 	orr	r3, r3, #128	; 0x80
 3f17480:	e1c230b0 	strh	r3, [r2]
			break;
 3f17484:	ea0000a4 	b	3f1771c <Ep0Handler+0x500>

		case SET_CONFIGURATION:
			DbgPrintf("[SC]");
			ConfigSet.ConfigurationValue=descSetup.bValueL;
			CLR_EP0_OUTPKTRDY_DATAEND(); //Because of no data control transfers.
			ep0State=EP0_STATE_INIT;
 3f17488:	e3a03000 	mov	r3, #0	; 0x0
 3f1748c:	e5863000 	str	r3, [r6]
 3f17490:	e59f2170 	ldr	r2, [pc, #170]	; 3f17608 <Ep0Handler+0x3ec>
 3f17494:	e5d43002 	ldrb	r3, [r4, #2]
 3f17498:	e5c23000 	strb	r3, [r2]
 3f1749c:	e205303f 	and	r3, r5, #63	; 0x3f
 3f174a0:	e59f2144 	ldr	r2, [pc, #144]	; 3f175ec <Ep0Handler+0x3d0>
 3f174a4:	e3833048 	orr	r3, r3, #72	; 0x48
 3f174a8:	e1c230b0 	strh	r3, [r2]

			isUsbdSetConfiguration=1; 
 3f174ac:	e59f2158 	ldr	r2, [pc, #158]	; 3f1760c <Ep0Handler+0x3f0>
 3f174b0:	e3a03001 	mov	r3, #1	; 0x1
 3f174b4:	e5823000 	str	r3, [r2]
			break;
 3f174b8:	ea00009b 	b	3f1772c <Ep0Handler+0x510>

	//////////////////////// For chapter 9 test ////////////////////
		case CLEAR_FEATURE:
			switch (descSetup.bmRequestType) {
 3f174bc:	e5d42000 	ldrb	r2, [r4]
 3f174c0:	e3520000 	cmp	r2, #0	; 0x0
 3f174c4:	0a000002 	beq	3f174d4 <Ep0Handler+0x2b8>
 3f174c8:	e3520002 	cmp	r2, #2	; 0x2
 3f174cc:	0a000005 	beq	3f174e8 <Ep0Handler+0x2cc>
 3f174d0:	ea00008f 	b	3f17714 <Ep0Handler+0x4f8>
			case DEVICE_RECIPIENT:
				if (descSetup.bValueL == 1)
 3f174d4:	e5d43002 	ldrb	r3, [r4, #2]
 3f174d8:	e3530001 	cmp	r3, #1	; 0x1
					Rwuen = FALSE;
 3f174dc:	059f312c 	ldreq	r3, [pc, #12c]	; 3f17610 <Ep0Handler+0x3f4>
 3f174e0:	05c32000 	streqb	r2, [r3]
					break;
 3f174e4:	ea00008a 	b	3f17714 <Ep0Handler+0x4f8>

			case ENDPOINT_RECIPIENT:
				if (descSetup.bValueL == 0) {
 3f174e8:	e5d42002 	ldrb	r2, [r4, #2]
 3f174ec:	e3520000 	cmp	r2, #0	; 0x0
 3f174f0:	1a000087 	bne	3f17714 <Ep0Handler+0x4f8>
					if((descSetup.bIndexL & 0x7f) == 0x00) {
 3f174f4:	e5d43004 	ldrb	r3, [r4, #4]
 3f174f8:	e313007f 	tst	r3, #127	; 0x7f
						StatusGet.Endpoint0= 0;
 3f174fc:	059f3110 	ldreq	r3, [pc, #110]	; 3f17614 <Ep0Handler+0x3f8>
 3f17500:	05c32002 	streqb	r2, [r3, #2]
					}
					if((descSetup.bIndexL & 0x8f) == 0x81) {           // IN  Endpoint 1
 3f17504:	e5d43004 	ldrb	r3, [r4, #4]
 3f17508:	e203308f 	and	r3, r3, #143	; 0x8f
 3f1750c:	e3530081 	cmp	r3, #129	; 0x81
						StatusGet.Endpoint1= 0;
 3f17510:	059f30fc 	ldreq	r3, [pc, #fc]	; 3f17614 <Ep0Handler+0x3f8>
 3f17514:	05c32003 	streqb	r2, [r3, #3]
					}
					if((descSetup.bIndexL & 0x8f) == 0x03){          // OUT Endpoint 3
 3f17518:	e5d43004 	ldrb	r3, [r4, #4]
 3f1751c:	e203308f 	and	r3, r3, #143	; 0x8f
 3f17520:	e3530003 	cmp	r3, #3	; 0x3
						StatusGet.Endpoint3= 0;  
 3f17524:	059f30e8 	ldreq	r3, [pc, #e8]	; 3f17614 <Ep0Handler+0x3f8>
 3f17528:	05c32004 	streqb	r2, [r3, #4]
					}
				}
				break;

			default:
				break;
			}
			CLR_EP0_OUTPKTRDY_DATAEND();
			ep0State=EP0_STATE_INIT;
			break;
 3f1752c:	ea000078 	b	3f17714 <Ep0Handler+0x4f8>

		case GET_CONFIGURATION:
			CLR_EP0_OUT_PKT_RDY();
			ep0State=EP0_CONFIG_SET;
 3f17530:	e3a03021 	mov	r3, #33	; 0x21
 3f17534:	e5863000 	str	r3, [r6]
 3f17538:	e205303f 	and	r3, r5, #63	; 0x3f
 3f1753c:	e59f20a8 	ldr	r2, [pc, #a8]	; 3f175ec <Ep0Handler+0x3d0>
 3f17540:	e3833040 	orr	r3, r3, #64	; 0x40
			break;
 3f17544:	ea000077 	b	3f17728 <Ep0Handler+0x50c>

		case GET_INTERFACE:
			CLR_EP0_OUT_PKT_RDY();
			ep0State=EP0_INTERFACE_GET;
 3f17548:	e3a0302e 	mov	r3, #46	; 0x2e
 3f1754c:	e5863000 	str	r3, [r6]
 3f17550:	e205303f 	and	r3, r5, #63	; 0x3f
 3f17554:	e59f2090 	ldr	r2, [pc, #90]	; 3f175ec <Ep0Handler+0x3d0>
 3f17558:	e3833040 	orr	r3, r3, #64	; 0x40
			break;
 3f1755c:	ea000071 	b	3f17728 <Ep0Handler+0x50c>

		case GET_STATUS:
			switch(descSetup.bmRequestType) {
 3f17560:	e5d43000 	ldrb	r3, [r4]
 3f17564:	e3530081 	cmp	r3, #129	; 0x81
 3f17568:	0a000014 	beq	3f175c0 <Ep0Handler+0x3a4>
 3f1756c:	ca000002 	bgt	3f1757c <Ep0Handler+0x360>
 3f17570:	e3530080 	cmp	r3, #128	; 0x80
 3f17574:	0a000003 	beq	3f17588 <Ep0Handler+0x36c>
 3f17578:	ea00006b 	b	3f1772c <Ep0Handler+0x510>
 3f1757c:	e3530082 	cmp	r3, #130	; 0x82
 3f17580:	0a000025 	beq	3f1761c <Ep0Handler+0x400>
 3f17584:	ea000068 	b	3f1772c <Ep0Handler+0x510>
			case  (0x80):
				CLR_EP0_OUT_PKT_RDY();
				StatusGet.Device=((U8)Rwuen<<1)|(U8)Selfpwr;
				ep0State=EP0_GET_STATUS0;
 3f17588:	e3a03023 	mov	r3, #35	; 0x23
 3f1758c:	e5863000 	str	r3, [r6]
 3f17590:	e205303f 	and	r3, r5, #63	; 0x3f
 3f17594:	e59f2050 	ldr	r2, [pc, #50]	; 3f175ec <Ep0Handler+0x3d0>
 3f17598:	e3833040 	orr	r3, r3, #64	; 0x40
 3f1759c:	e1c230b0 	strh	r3, [r2]
 3f175a0:	e59f3068 	ldr	r3, [pc, #68]	; 3f17610 <Ep0Handler+0x3f4>
 3f175a4:	e59f206c 	ldr	r2, [pc, #6c]	; 3f17618 <Ep0Handler+0x3fc>
 3f175a8:	e5d31000 	ldrb	r1, [r3]
 3f175ac:	e5d23000 	ldrb	r3, [r2]
 3f175b0:	e59f205c 	ldr	r2, [pc, #5c]	; 3f17614 <Ep0Handler+0x3f8>
 3f175b4:	e1833081 	orr	r3, r3, r1, lsl #1
 3f175b8:	e5c23000 	strb	r3, [r2]
				break;
 3f175bc:	ea00005a 	b	3f1772c <Ep0Handler+0x510>

			case  (0x81):
				CLR_EP0_OUT_PKT_RDY();
				StatusGet.Interface=0;
				ep0State=EP0_GET_STATUS1;
 3f175c0:	e3a03024 	mov	r3, #36	; 0x24
 3f175c4:	e5863000 	str	r3, [r6]
 3f175c8:	e205303f 	and	r3, r5, #63	; 0x3f
 3f175cc:	e59f2018 	ldr	r2, [pc, #18]	; 3f175ec <Ep0Handler+0x3d0>
 3f175d0:	e3833040 	orr	r3, r3, #64	; 0x40
 3f175d4:	e1c230b0 	strh	r3, [r2]
 3f175d8:	e59f2034 	ldr	r2, [pc, #34]	; 3f17614 <Ep0Handler+0x3f8>
 3f175dc:	e3a03000 	mov	r3, #0	; 0x0
 3f175e0:	e5c23001 	strb	r3, [r2, #1]
				break;
 3f175e4:	ea000050 	b	3f1772c <Ep0Handler+0x510>
 3f175e8:	c000141c 	andgt	r1, r0, r12, lsl r4
 3f175ec:	c0001422 	andgt	r1, r0, r2, lsr #8
 3f175f0:	c000142c 	andgt	r1, r0, r12, lsr #8
 3f175f4:	c0001440 	andgt	r1, r0, r0, asr #8
 3f175f8:	03f73038 	mvneqs	r3, #56	; 0x38
 3f175fc:	03f73078 	mvneqs	r3, #120	; 0x78
 3f17600:	03f72fb0 	mvneqs	r2, #704	; 0x2c0
 3f17604:	c0001400 	andgt	r1, r0, r0, lsl #8
 3f17608:	03f730bc 	mvneqs	r3, #188	; 0xbc
 3f1760c:	03f7305c 	mvneqs	r3, #92	; 0x5c
 3f17610:	03f73044 	mvneqs	r3, #68	; 0x44
 3f17614:	03f730c4 	mvneqs	r3, #196	; 0xc4
 3f17618:	03f6a1b1 	mvneqs	r10, #1073741868	; 0x4000002c

			case  (0x82):
				CLR_EP0_OUT_PKT_RDY();
				if((descSetup.bIndexL & 0x7f) == 0x00) {
 3f1761c:	e5d43004 	ldrb	r3, [r4, #4]
 3f17620:	e59f23a0 	ldr	r2, [pc, #3a0]	; 3f179c8 <Ep0Handler+0x7ac>
 3f17624:	e313007f 	tst	r3, #127	; 0x7f
 3f17628:	e205303f 	and	r3, r5, #63	; 0x3f
 3f1762c:	e3833040 	orr	r3, r3, #64	; 0x40
 3f17630:	e1c230b0 	strh	r3, [r2]
					ep0State=EP0_GET_STATUS2;
 3f17634:	03a03025 	moveq	r3, #37	; 0x25
 3f17638:	05863000 	streq	r3, [r6]
				}

				if((descSetup.bIndexL & 0x8f) == 0x81){
 3f1763c:	e5d43004 	ldrb	r3, [r4, #4]
 3f17640:	e203308f 	and	r3, r3, #143	; 0x8f
 3f17644:	e3530081 	cmp	r3, #129	; 0x81
					ep0State=EP0_GET_STATUS3;
 3f17648:	059f237c 	ldreq	r2, [pc, #37c]	; 3f179cc <Ep0Handler+0x7b0>
 3f1764c:	03a03026 	moveq	r3, #38	; 0x26
 3f17650:	05823000 	streq	r3, [r2]
				}
  
				if((descSetup.bIndexL & 0x8f) == 0x03){
 3f17654:	e5d43004 	ldrb	r3, [r4, #4]
 3f17658:	e203308f 	and	r3, r3, #143	; 0x8f
 3f1765c:	e3530003 	cmp	r3, #3	; 0x3
					ep0State=EP0_GET_STATUS4;
 3f17660:	059f2364 	ldreq	r2, [pc, #364]	; 3f179cc <Ep0Handler+0x7b0>
 3f17664:	03a03027 	moveq	r3, #39	; 0x27
 3f17668:	05823000 	streq	r3, [r2]
				}
				break;

			default:
				break;
			}
			break;
 3f1766c:	ea00002e 	b	3f1772c <Ep0Handler+0x510>

		case SET_DESCRIPTOR:
			CLR_EP0_OUTPKTRDY_DATAEND();
			ep0State=EP0_STATE_INIT;
			break;

		case SET_FEATURE:
			switch (descSetup.bmRequestType) {
 3f17670:	e5d43000 	ldrb	r3, [r4]
 3f17674:	e3530000 	cmp	r3, #0	; 0x0
 3f17678:	0a000002 	beq	3f17688 <Ep0Handler+0x46c>
 3f1767c:	e3530002 	cmp	r3, #2	; 0x2
 3f17680:	0a000005 	beq	3f1769c <Ep0Handler+0x480>
 3f17684:	ea000022 	b	3f17714 <Ep0Handler+0x4f8>
			case DEVICE_RECIPIENT:
				if (descSetup.bValueL == 1)
 3f17688:	e5d40002 	ldrb	r0, [r4, #2]
 3f1768c:	e3500001 	cmp	r0, #1	; 0x1
					Rwuen = TRUE;
 3f17690:	059f3338 	ldreq	r3, [pc, #338]	; 3f179d0 <Ep0Handler+0x7b4>
 3f17694:	05c30000 	streqb	r0, [r3]
				break;
 3f17698:	ea00001d 	b	3f17714 <Ep0Handler+0x4f8>

			case ENDPOINT_RECIPIENT:
				if (descSetup.bValueL == 0) {
 3f1769c:	e5d43002 	ldrb	r3, [r4, #2]
 3f176a0:	e3530000 	cmp	r3, #0	; 0x0
 3f176a4:	1a00001a 	bne	3f17714 <Ep0Handler+0x4f8>
					if((descSetup.bIndexL & 0x7f) == 0x00) {
 3f176a8:	e5d43004 	ldrb	r3, [r4, #4]
 3f176ac:	e313007f 	tst	r3, #127	; 0x7f
						StatusGet.Endpoint0= 1;
 3f176b0:	059f231c 	ldreq	r2, [pc, #31c]	; 3f179d4 <Ep0Handler+0x7b8>
 3f176b4:	03a03001 	moveq	r3, #1	; 0x1
 3f176b8:	05c23002 	streqb	r3, [r2, #2]
					}
					if((descSetup.bIndexL & 0x8f) == 0x81) {
 3f176bc:	e5d43004 	ldrb	r3, [r4, #4]
 3f176c0:	e203308f 	and	r3, r3, #143	; 0x8f
 3f176c4:	e3530081 	cmp	r3, #129	; 0x81
						StatusGet.Endpoint1= 1;
 3f176c8:	059f2304 	ldreq	r2, [pc, #304]	; 3f179d4 <Ep0Handler+0x7b8>
 3f176cc:	03a03001 	moveq	r3, #1	; 0x1
 3f176d0:	05c23003 	streqb	r3, [r2, #3]
					}
					if((descSetup.bIndexL & 0x8f) == 0x03) {
 3f176d4:	e5d43004 	ldrb	r3, [r4, #4]
 3f176d8:	e203308f 	and	r3, r3, #143	; 0x8f
 3f176dc:	e3530003 	cmp	r3, #3	; 0x3
						StatusGet.Endpoint3= 1;
 3f176e0:	059f22ec 	ldreq	r2, [pc, #2ec]	; 3f179d4 <Ep0Handler+0x7b8>
 3f176e4:	03a03001 	moveq	r3, #1	; 0x1
 3f176e8:	05c23004 	streqb	r3, [r2, #4]
					}
				}
				break;

			default:
				break;
			}
			CLR_EP0_OUTPKTRDY_DATAEND();
			ep0State=EP0_STATE_INIT;
			break;
 3f176ec:	ea000008 	b	3f17714 <Ep0Handler+0x4f8>

		case SET_INTERFACE:
			InterfaceGet.AlternateSetting= descSetup.bValueL;
			CLR_EP0_OUTPKTRDY_DATAEND(); 
			ep0State=EP0_STATE_INIT;
 3f176f0:	e3a03000 	mov	r3, #0	; 0x0
 3f176f4:	e5863000 	str	r3, [r6]
 3f176f8:	e59f22d8 	ldr	r2, [pc, #2d8]	; 3f179d8 <Ep0Handler+0x7bc>
 3f176fc:	e5d43002 	ldrb	r3, [r4, #2]
 3f17700:	e5c23000 	strb	r3, [r2]
			break;
 3f17704:	ea000004 	b	3f1771c <Ep0Handler+0x500>

		case SYNCH_FRAME:
			ep0State=EP0_STATE_INIT;
 3f17708:	e3a03000 	mov	r3, #0	; 0x0
 3f1770c:	e5863000 	str	r3, [r6]
			break;
 3f17710:	ea000005 	b	3f1772c <Ep0Handler+0x510>

		default:
			DbgPrintf("[UE:SETUP=%x]",descSetup.bRequest);
			CLR_EP0_OUTPKTRDY_DATAEND(); //Because of no data control transfers.
			ep0State=EP0_STATE_INIT;
 3f17714:	e3a03000 	mov	r3, #0	; 0x0
 3f17718:	e5863000 	str	r3, [r6]
 3f1771c:	e205303f 	and	r3, r5, #63	; 0x3f
 3f17720:	e59f22a0 	ldr	r2, [pc, #2a0]	; 3f179c8 <Ep0Handler+0x7ac>
 3f17724:	e3833048 	orr	r3, r3, #72	; 0x48
 3f17728:	e1c230b0 	strh	r3, [r2]
			break;
		}
	}
	
	DbgPrintf2("****[%s:%d]->%s(): ep0State(%d)\n", __FILE__, __LINE__, __FUNCTION__, ep0State);
	switch(ep0State) {
 3f1772c:	e59f4298 	ldr	r4, [pc, #298]	; 3f179cc <Ep0Handler+0x7b0>
 3f17730:	e5943000 	ldr	r3, [r4]
 3f17734:	e3530046 	cmp	r3, #70	; 0x46
 3f17738:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f1773c:	ea00010f 	b	3f17b80 <Ep0Handler+0x964>
 3f17740:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17744:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17748:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f1774c:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17750:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17754:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17758:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f1775c:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17760:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17764:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17768:	03f1785c 	mvneqs	r7, #6029312	; 0x5c0000
 3f1776c:	03f17884 	mvneqs	r7, #8650752	; 0x840000
 3f17770:	03f17898 	mvneqs	r7, #9961472	; 0x980000
 3f17774:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17778:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f1777c:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17780:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17784:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17788:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f1778c:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17790:	03f178c0 	mvneqs	r7, #12582912	; 0xc00000
 3f17794:	03f178d4 	mvneqs	r7, #13893632	; 0xd40000
 3f17798:	03f178f4 	mvneqs	r7, #15990784	; 0xf40000
 3f1779c:	03f17914 	mvneqs	r7, #327680	; 0x50000
 3f177a0:	03f178a4 	mvneqs	r7, #10747904	; 0xa40000
 3f177a4:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f177a8:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f177ac:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f177b0:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f177b4:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f177b8:	03f17998 	mvneqs	r7, #2490368	; 0x260000
 3f177bc:	03f17a10 	mvneqs	r7, #65536	; 0x10000
 3f177c0:	03f17a80 	mvneqs	r7, #524288	; 0x80000
 3f177c4:	03f17b20 	mvneqs	r7, #32768	; 0x8000
 3f177c8:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f177cc:	03f17b2c 	mvneqs	r7, #45056	; 0xb000
 3f177d0:	03f17b38 	mvneqs	r7, #57344	; 0xe000
 3f177d4:	03f17b44 	mvneqs	r7, #69632	; 0x11000
 3f177d8:	03f17b50 	mvneqs	r7, #81920	; 0x14000
 3f177dc:	03f17b5c 	mvneqs	r7, #94208	; 0x17000
 3f177e0:	03f17934 	mvneqs	r7, #851968	; 0xd0000
 3f177e4:	03f17948 	mvneqs	r7, #1179648	; 0x120000
 3f177e8:	03f17954 	mvneqs	r7, #1376256	; 0x150000
 3f177ec:	03f17968 	mvneqs	r7, #1703936	; 0x1a0000
 3f177f0:	03f17974 	mvneqs	r7, #1900544	; 0x1d0000
 3f177f4:	03f17980 	mvneqs	r7, #2097152	; 0x200000
 3f177f8:	03f1798c 	mvneqs	r7, #2293760	; 0x230000
 3f177fc:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17800:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17804:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17808:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f1780c:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17810:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17814:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17818:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f1781c:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17820:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17824:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17828:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f1782c:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17830:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17834:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17838:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f1783c:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17840:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17844:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17848:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f1784c:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17850:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17854:	03f17b80 	mvneqs	r7, #131072	; 0x20000
 3f17858:	03f17ad0 	mvneqs	r7, #851968	; 0xd0000
	case EP0_STATE_INIT:
		break; 

	//=== GET_DESCRIPTOR:DEVICE ===

	case EP0_STATE_GD_DEV_0:
		DbgPrintf("[GDD0]");
		WrPktEp0((U8 *)&descDev+0,8); //EP0_PKT_SIZE
 3f1785c:	e59f0178 	ldr	r0, [pc, #178]	; 3f179dc <Ep0Handler+0x7c0>
 3f17860:	e3a01008 	mov	r1, #8	; 0x8
 3f17864:	eb00018a 	bl	3f17e94 <WrPktEp0>
		SET_EP0_IN_PKT_RDY();
		ep0State=EP0_STATE_GD_DEV_1;
 3f17868:	e3a0300b 	mov	r3, #11	; 0xb
 3f1786c:	e5843000 	str	r3, [r4]
 3f17870:	e205303f 	and	r3, r5, #63	; 0x3f
 3f17874:	e59f214c 	ldr	r2, [pc, #14c]	; 3f179c8 <Ep0Handler+0x7ac>
 3f17878:	e3833002 	orr	r3, r3, #2	; 0x2
 3f1787c:	e1c230b0 	strh	r3, [r2]
		break;
 3f17880:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

	case EP0_STATE_GD_DEV_1:
		DbgPrintf("[GDD1]");
		WrPktEp0((U8 *)&descDev+0x8,8); 
 3f17884:	e59f0154 	ldr	r0, [pc, #154]	; 3f179e0 <Ep0Handler+0x7c4>
 3f17888:	e3a01008 	mov	r1, #8	; 0x8
 3f1788c:	eb000180 	bl	3f17e94 <WrPktEp0>
		SET_EP0_IN_PKT_RDY();

		ep0State=EP0_STATE_GD_DEV_2;
 3f17890:	e3a0300c 	mov	r3, #12	; 0xc
		break;
 3f17894:	eafffff4 	b	3f1786c <Ep0Handler+0x650>

	case EP0_STATE_GD_DEV_2:
		DbgPrintf("[GDD2]");
		WrPktEp0((U8 *)&descDev+0x10,2);   //8+8+2=0x12
 3f17898:	e59f0144 	ldr	r0, [pc, #144]	; 3f179e4 <Ep0Handler+0x7c8>
 3f1789c:	e3a01002 	mov	r1, #2	; 0x2
 3f178a0:	eb00017b 	bl	3f17e94 <WrPktEp0>
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;
 3f178a4:	e3a03000 	mov	r3, #0	; 0x0
 3f178a8:	e5843000 	str	r3, [r4]
 3f178ac:	e205303f 	and	r3, r5, #63	; 0x3f
 3f178b0:	e59f2110 	ldr	r2, [pc, #110]	; 3f179c8 <Ep0Handler+0x7ac>
 3f178b4:	e383300a 	orr	r3, r3, #10	; 0xa
 3f178b8:	e1c230b0 	strh	r3, [r2]
		break;
 3f178bc:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

	//=== GET_DESCRIPTOR:CONFIGURATION+INTERFACE+ENDPOINT0+ENDPOINT1 ===
	//Windows98 gets these 4 descriptors all together by issuing only a request.
	//Windows2000 gets each descriptor seperately.
	case EP0_STATE_GD_CFG_0:
		DbgPrintf("[GDC0]");
		WrPktEp0((U8 *)&descConf+0,8); //EP0_PKT_SIZE
 3f178c0:	e59f0120 	ldr	r0, [pc, #120]	; 3f179e8 <Ep0Handler+0x7cc>
 3f178c4:	e3a01008 	mov	r1, #8	; 0x8
 3f178c8:	eb000171 	bl	3f17e94 <WrPktEp0>
		SET_EP0_IN_PKT_RDY();
		ep0State=EP0_STATE_GD_CFG_1;
 3f178cc:	e3a03015 	mov	r3, #21	; 0x15
		break;
 3f178d0:	eaffffe5 	b	3f1786c <Ep0Handler+0x650>

	case EP0_STATE_GD_CFG_1:
		DbgPrintf("[GDC1]");
		WrPktEp0((U8 *)&descConf+8,1); 
 3f178d4:	e59f0110 	ldr	r0, [pc, #110]	; 3f179ec <Ep0Handler+0x7d0>
 3f178d8:	e3a01001 	mov	r1, #1	; 0x1
 3f178dc:	eb00016c 	bl	3f17e94 <WrPktEp0>
		WrPktEp0((U8 *)&descIf+0,7); 
 3f178e0:	e59f0108 	ldr	r0, [pc, #108]	; 3f179f0 <Ep0Handler+0x7d4>
 3f178e4:	e3a01007 	mov	r1, #7	; 0x7
 3f178e8:	eb000169 	bl	3f17e94 <WrPktEp0>
		SET_EP0_IN_PKT_RDY();
		ep0State=EP0_STATE_GD_CFG_2;
 3f178ec:	e3a03016 	mov	r3, #22	; 0x16
		break;
 3f178f0:	eaffffdd 	b	3f1786c <Ep0Handler+0x650>

	case EP0_STATE_GD_CFG_2:
		DbgPrintf("[GDC2]");
		WrPktEp0((U8 *)&descIf+7,2); 
 3f178f4:	e59f00f8 	ldr	r0, [pc, #f8]	; 3f179f4 <Ep0Handler+0x7d8>
 3f178f8:	e3a01002 	mov	r1, #2	; 0x2
 3f178fc:	eb000164 	bl	3f17e94 <WrPktEp0>
		WrPktEp0((U8 *)&descEndpt0+0,6); 
 3f17900:	e59f00f0 	ldr	r0, [pc, #f0]	; 3f179f8 <Ep0Handler+0x7dc>
 3f17904:	e3a01006 	mov	r1, #6	; 0x6
 3f17908:	eb000161 	bl	3f17e94 <WrPktEp0>
		SET_EP0_IN_PKT_RDY();
		ep0State=EP0_STATE_GD_CFG_3;
 3f1790c:	e3a03017 	mov	r3, #23	; 0x17
		break;
 3f17910:	eaffffd5 	b	3f1786c <Ep0Handler+0x650>

	case EP0_STATE_GD_CFG_3:
		DbgPrintf("[GDC3]");
		WrPktEp0((U8 *)&descEndpt0+6,1); 
 3f17914:	e59f00e0 	ldr	r0, [pc, #e0]	; 3f179fc <Ep0Handler+0x7e0>
 3f17918:	e3a01001 	mov	r1, #1	; 0x1
 3f1791c:	eb00015c 	bl	3f17e94 <WrPktEp0>
		WrPktEp0((U8 *)&descEndpt1+0,7); 
 3f17920:	e59f00d8 	ldr	r0, [pc, #d8]	; 3f17a00 <Ep0Handler+0x7e4>
 3f17924:	e3a01007 	mov	r1, #7	; 0x7
 3f17928:	eb000159 	bl	3f17e94 <WrPktEp0>
		SET_EP0_IN_PKT_RDY();
		ep0State=EP0_STATE_GD_CFG_4;
 3f1792c:	e3a03018 	mov	r3, #24	; 0x18
		break;
 3f17930:	eaffffcd 	b	3f1786c <Ep0Handler+0x650>

	case EP0_STATE_GD_CFG_4:
		DbgPrintf("[GDC4]");
		//zero length data packit 
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;
		break;

	//=== GET_DESCRIPTOR:CONFIGURATION ONLY===
	case EP0_STATE_GD_CFG_ONLY_0:
		DbgPrintf("[GDCO0]");
		WrPktEp0((U8 *)&descConf+0,8); //EP0_PKT_SIZE
 3f17934:	e59f00ac 	ldr	r0, [pc, #ac]	; 3f179e8 <Ep0Handler+0x7cc>
 3f17938:	e3a01008 	mov	r1, #8	; 0x8
 3f1793c:	eb000154 	bl	3f17e94 <WrPktEp0>
		SET_EP0_IN_PKT_RDY();
		ep0State=EP0_STATE_GD_CFG_ONLY_1;
 3f17940:	e3a03029 	mov	r3, #41	; 0x29
		break;
 3f17944:	eaffffc8 	b	3f1786c <Ep0Handler+0x650>

	case EP0_STATE_GD_CFG_ONLY_1:
		DbgPrintf("[GDCO1]");
		WrPktEp0((U8 *)&descConf+8,1); 
 3f17948:	e59f009c 	ldr	r0, [pc, #9c]	; 3f179ec <Ep0Handler+0x7d0>
 3f1794c:	e3a01001 	mov	r1, #1	; 0x1
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;
		break;
 3f17950:	eaffffd2 	b	3f178a0 <Ep0Handler+0x684>

	//=== GET_DESCRIPTOR:INTERFACE ONLY===
	case EP0_STATE_GD_IF_ONLY_0:
		DbgPrintf("[GDI0]");
		WrPktEp0((U8 *)&descIf+0,8); 
 3f17954:	e59f0094 	ldr	r0, [pc, #94]	; 3f179f0 <Ep0Handler+0x7d4>
 3f17958:	e3a01008 	mov	r1, #8	; 0x8
 3f1795c:	eb00014c 	bl	3f17e94 <WrPktEp0>
		SET_EP0_IN_PKT_RDY();
		ep0State=EP0_STATE_GD_IF_ONLY_1;
 3f17960:	e3a0302b 	mov	r3, #43	; 0x2b
		break;
 3f17964:	eaffffc0 	b	3f1786c <Ep0Handler+0x650>
	case EP0_STATE_GD_IF_ONLY_1:
		DbgPrintf("[GDI1]");
		WrPktEp0((U8 *)&descIf+8,1); 
 3f17968:	e59f0094 	ldr	r0, [pc, #94]	; 3f17a04 <Ep0Handler+0x7e8>
 3f1796c:	e3a01001 	mov	r1, #1	; 0x1
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;
		break;
 3f17970:	eaffffca 	b	3f178a0 <Ep0Handler+0x684>

	//=== GET_DESCRIPTOR:ENDPOINT 0 ONLY===
	case EP0_STATE_GD_EP0_ONLY_0:
		DbgPrintf("[GDE00]");
		WrPktEp0((U8 *)&descEndpt0+0,7); 
 3f17974:	e59f007c 	ldr	r0, [pc, #7c]	; 3f179f8 <Ep0Handler+0x7dc>
 3f17978:	e3a01007 	mov	r1, #7	; 0x7
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;
		break;
 3f1797c:	eaffffc7 	b	3f178a0 <Ep0Handler+0x684>

	//=== GET_DESCRIPTOR:ENDPOINT 1 ONLY===
	case EP0_STATE_GD_EP1_ONLY_0:
		DbgPrintf("[GDE10]");
		WrPktEp0((U8 *)&descEndpt1+0,7); 
 3f17980:	e59f0078 	ldr	r0, [pc, #78]	; 3f17a00 <Ep0Handler+0x7e4>
 3f17984:	e3a01007 	mov	r1, #7	; 0x7
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;
		break;
 3f17988:	eaffffc4 	b	3f178a0 <Ep0Handler+0x684>

////////////////////////////////////////////

	 case EP0_INTERFACE_GET:
		WrPktEp0((U8 *)&InterfaceGet+0,1);
 3f1798c:	e59f0044 	ldr	r0, [pc, #44]	; 3f179d8 <Ep0Handler+0x7bc>
 3f17990:	e3a01001 	mov	r1, #1	; 0x1
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;  
		break;
 3f17994:	eaffffc1 	b	3f178a0 <Ep0Handler+0x684>


	//=== GET_DESCRIPTOR:STRING ===
	case EP0_STATE_GD_STR_I0:
		DbgPrintf("[GDS0_0]");
		WrPktEp0((U8 *)descStr0, 4 );  
 3f17998:	e59f0068 	ldr	r0, [pc, #68]	; 3f17a08 <Ep0Handler+0x7ec>
 3f1799c:	e3a01004 	mov	r1, #4	; 0x4
 3f179a0:	eb00013b 	bl	3f17e94 <WrPktEp0>
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT; 
 3f179a4:	e3a01000 	mov	r1, #0	; 0x0
 3f179a8:	e5841000 	str	r1, [r4]
 3f179ac:	e205303f 	and	r3, r5, #63	; 0x3f
 3f179b0:	e59f2010 	ldr	r2, [pc, #10]	; 3f179c8 <Ep0Handler+0x7ac>
 3f179b4:	e383300a 	orr	r3, r3, #10	; 0xa
 3f179b8:	e1c230b0 	strh	r3, [r2]
		ep0SubState=0;
 3f179bc:	e59f3048 	ldr	r3, [pc, #48]	; 3f17a0c <Ep0Handler+0x7f0>
 3f179c0:	e5831000 	str	r1, [r3]
		break;
 3f179c4:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f179c8:	c0001422 	andgt	r1, r0, r2, lsr #8
 3f179cc:	03f73038 	mvneqs	r3, #56	; 0x38
 3f179d0:	03f73044 	mvneqs	r3, #68	; 0x44
 3f179d4:	03f730c4 	mvneqs	r3, #196	; 0xc4
 3f179d8:	03f730c0 	mvneqs	r3, #192	; 0xc0
 3f179dc:	03f73080 	mvneqs	r3, #128	; 0x80
 3f179e0:	03f73088 	mvneqs	r3, #136	; 0x88
 3f179e4:	03f73090 	mvneqs	r3, #144	; 0x90
 3f179e8:	03f73094 	mvneqs	r3, #148	; 0x94
 3f179ec:	03f7309c 	mvneqs	r3, #156	; 0x9c
 3f179f0:	03f730a0 	mvneqs	r3, #160	; 0xa0
 3f179f4:	03f730a7 	mvneqs	r3, #167	; 0xa7
 3f179f8:	03f730ac 	mvneqs	r3, #172	; 0xac
 3f179fc:	03f730b2 	mvneqs	r3, #178	; 0xb2
 3f17a00:	03f730b4 	mvneqs	r3, #180	; 0xb4
 3f17a04:	03f730a8 	mvneqs	r3, #168	; 0xa8
 3f17a08:	03f1fd10 	mvneqs	r15, #1024	; 0x400
 3f17a0c:	03f72fb0 	mvneqs	r2, #704	; 0x2c0

	case EP0_STATE_GD_STR_I1:
		DbgPrintf("[GDS1_%d]",ep0SubState);
		if( (ep0SubState*EP0_PKT_SIZE+EP0_PKT_SIZE)<sizeof(descStr1) ) {
 3f17a10:	e59f616c 	ldr	r6, [pc, #16c]	; 3f17b84 <Ep0Handler+0x968>
 3f17a14:	e5963000 	ldr	r3, [r6]
 3f17a18:	e1a02183 	mov	r2, r3, lsl #3
 3f17a1c:	e2823008 	add	r3, r2, #8	; 0x8
 3f17a20:	e3530015 	cmp	r3, #21	; 0x15
 3f17a24:	8a00000d 	bhi	3f17a60 <Ep0Handler+0x844>
			WrPktEp0((U8 *)descStr1+(ep0SubState*EP0_PKT_SIZE),EP0_PKT_SIZE); 
 3f17a28:	e59f0158 	ldr	r0, [pc, #158]	; 3f17b88 <Ep0Handler+0x96c>
 3f17a2c:	e3a01008 	mov	r1, #8	; 0x8
 3f17a30:	e0820000 	add	r0, r2, r0
 3f17a34:	eb000116 	bl	3f17e94 <WrPktEp0>
			SET_EP0_IN_PKT_RDY();
			ep0State=EP0_STATE_GD_STR_I1;
 3f17a38:	e3a0301f 	mov	r3, #31	; 0x1f
 3f17a3c:	e5843000 	str	r3, [r4]
 3f17a40:	e59f1144 	ldr	r1, [pc, #144]	; 3f17b8c <Ep0Handler+0x970>
 3f17a44:	e205303f 	and	r3, r5, #63	; 0x3f
			ep0SubState++;
 3f17a48:	e5962000 	ldr	r2, [r6]
 3f17a4c:	e3833002 	orr	r3, r3, #2	; 0x2
 3f17a50:	e1c130b0 	strh	r3, [r1]
 3f17a54:	e2822001 	add	r2, r2, #1	; 0x1
 3f17a58:	e5862000 	str	r2, [r6]
		} else {
 3f17a5c:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
			WrPktEp0((U8 *)descStr1+(ep0SubState*EP0_PKT_SIZE),
 3f17a60:	e59f0120 	ldr	r0, [pc, #120]	; 3f17b88 <Ep0Handler+0x96c>
 3f17a64:	e2621016 	rsb	r1, r2, #22	; 0x16
 3f17a68:	e0820000 	add	r0, r2, r0
 3f17a6c:	eb000108 	bl	3f17e94 <WrPktEp0>
			sizeof(descStr1)-(ep0SubState*EP0_PKT_SIZE)); 
			SET_EP0_INPKTRDY_DATAEND();
			ep0State=EP0_STATE_INIT; 
 3f17a70:	e3a03000 	mov	r3, #0	; 0x0
 3f17a74:	e5843000 	str	r3, [r4]
			ep0SubState=0;
 3f17a78:	e5863000 	str	r3, [r6]
		}
		break;
 3f17a7c:	eaffff8a 	b	3f178ac <Ep0Handler+0x690>

	case EP0_STATE_GD_STR_I2:
		DbgPrintf("[GDS2_%d]",ep0SubState);
		if( (ep0SubState*EP0_PKT_SIZE+EP0_PKT_SIZE)<sizeof(descStr2) ) {
 3f17a80:	e59f60fc 	ldr	r6, [pc, #fc]	; 3f17b84 <Ep0Handler+0x968>
 3f17a84:	e5963000 	ldr	r3, [r6]
 3f17a88:	e1a02183 	mov	r2, r3, lsl #3
 3f17a8c:	e2823008 	add	r3, r2, #8	; 0x8
 3f17a90:	e353002b 	cmp	r3, #43	; 0x2b
 3f17a94:	8a000005 	bhi	3f17ab0 <Ep0Handler+0x894>
			WrPktEp0((U8 *)descStr2+(ep0SubState*EP0_PKT_SIZE),EP0_PKT_SIZE); 
 3f17a98:	e59f00f0 	ldr	r0, [pc, #f0]	; 3f17b90 <Ep0Handler+0x974>
 3f17a9c:	e3a01008 	mov	r1, #8	; 0x8
 3f17aa0:	e0820000 	add	r0, r2, r0
 3f17aa4:	eb0000fa 	bl	3f17e94 <WrPktEp0>
			SET_EP0_IN_PKT_RDY();
			ep0State=EP0_STATE_GD_STR_I2;
 3f17aa8:	e3a03020 	mov	r3, #32	; 0x20
			ep0SubState++;
		} else {
 3f17aac:	eaffffe2 	b	3f17a3c <Ep0Handler+0x820>
			DbgPrintf("[E]");
			WrPktEp0((U8 *)descStr2+(ep0SubState*EP0_PKT_SIZE),
 3f17ab0:	e59f00d8 	ldr	r0, [pc, #d8]	; 3f17b90 <Ep0Handler+0x974>
 3f17ab4:	e262102c 	rsb	r1, r2, #44	; 0x2c
 3f17ab8:	e0820000 	add	r0, r2, r0
 3f17abc:	eb0000f4 	bl	3f17e94 <WrPktEp0>
			sizeof(descStr2)-(ep0SubState*EP0_PKT_SIZE)); 
			SET_EP0_INPKTRDY_DATAEND();
			ep0State=EP0_STATE_INIT; 
 3f17ac0:	e3a03000 	mov	r3, #0	; 0x0
 3f17ac4:	e5843000 	str	r3, [r4]
			ep0SubState=0;
 3f17ac8:	e5863000 	str	r3, [r6]
		}
		break;
 3f17acc:	eaffff76 	b	3f178ac <Ep0Handler+0x690>

	case EP0_STATE_GD_STR_I3:
		DbgPrintf("[GDS2_%d]",ep0SubState);
		if( (ep0SubState*EP0_PKT_SIZE+EP0_PKT_SIZE)<sizeof(descStr3) ) {
 3f17ad0:	e59f60ac 	ldr	r6, [pc, #ac]	; 3f17b84 <Ep0Handler+0x968>
 3f17ad4:	e5963000 	ldr	r3, [r6]
 3f17ad8:	e1a02183 	mov	r2, r3, lsl #3
 3f17adc:	e2823008 	add	r3, r2, #8	; 0x8
 3f17ae0:	e3530081 	cmp	r3, #129	; 0x81
 3f17ae4:	8a000005 	bhi	3f17b00 <Ep0Handler+0x8e4>
			WrPktEp0((U8 *)descStr3+(ep0SubState*EP0_PKT_SIZE),EP0_PKT_SIZE); 
 3f17ae8:	e59f00a4 	ldr	r0, [pc, #a4]	; 3f17b94 <Ep0Handler+0x978>
 3f17aec:	e3a01008 	mov	r1, #8	; 0x8
 3f17af0:	e0820000 	add	r0, r2, r0
 3f17af4:	eb0000e6 	bl	3f17e94 <WrPktEp0>
			SET_EP0_IN_PKT_RDY();
			ep0State=EP0_STATE_GD_STR_I3;
 3f17af8:	e3a03046 	mov	r3, #70	; 0x46
			ep0SubState++;
		} else {
 3f17afc:	eaffffce 	b	3f17a3c <Ep0Handler+0x820>
			DbgPrintf("[E]");
			WrPktEp0((U8 *)descStr3+(ep0SubState*EP0_PKT_SIZE),
 3f17b00:	e59f008c 	ldr	r0, [pc, #8c]	; 3f17b94 <Ep0Handler+0x978>
 3f17b04:	e2621082 	rsb	r1, r2, #130	; 0x82
 3f17b08:	e0820000 	add	r0, r2, r0
 3f17b0c:	eb0000e0 	bl	3f17e94 <WrPktEp0>
			sizeof(descStr3)-(ep0SubState*EP0_PKT_SIZE)); 
			SET_EP0_INPKTRDY_DATAEND();
			ep0State=EP0_STATE_INIT; 
 3f17b10:	e3a03000 	mov	r3, #0	; 0x0
 3f17b14:	e5843000 	str	r3, [r4]
			ep0SubState=0;
 3f17b18:	e5863000 	str	r3, [r6]
		}
		break;
 3f17b1c:	eaffff62 	b	3f178ac <Ep0Handler+0x690>
	case EP0_CONFIG_SET:
		WrPktEp0((U8 *)&ConfigSet+0,1); 
 3f17b20:	e59f0070 	ldr	r0, [pc, #70]	; 3f17b98 <Ep0Handler+0x97c>
 3f17b24:	e3a01001 	mov	r1, #1	; 0x1
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;  
		break;
 3f17b28:	eaffff5c 	b	3f178a0 <Ep0Handler+0x684>

	case EP0_GET_STATUS0:
		WrPktEp0((U8 *)&StatusGet+0,1);
 3f17b2c:	e59f0068 	ldr	r0, [pc, #68]	; 3f17b9c <Ep0Handler+0x980>
 3f17b30:	e3a01001 	mov	r1, #1	; 0x1
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;  
		break;
 3f17b34:	eaffff59 	b	3f178a0 <Ep0Handler+0x684>

	case EP0_GET_STATUS1:
		WrPktEp0((U8 *)&StatusGet+1,1);
 3f17b38:	e59f0060 	ldr	r0, [pc, #60]	; 3f17ba0 <Ep0Handler+0x984>
 3f17b3c:	e3a01001 	mov	r1, #1	; 0x1
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;  
		break;
 3f17b40:	eaffff56 	b	3f178a0 <Ep0Handler+0x684>

	case EP0_GET_STATUS2:
		WrPktEp0((U8 *)&StatusGet+2,1);
 3f17b44:	e59f0058 	ldr	r0, [pc, #58]	; 3f17ba4 <Ep0Handler+0x988>
 3f17b48:	e3a01001 	mov	r1, #1	; 0x1
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;  
		break;
 3f17b4c:	eaffff53 	b	3f178a0 <Ep0Handler+0x684>

	case EP0_GET_STATUS3:
		WrPktEp0((U8 *)&StatusGet+3,1);
 3f17b50:	e59f0050 	ldr	r0, [pc, #50]	; 3f17ba8 <Ep0Handler+0x98c>
 3f17b54:	e3a01001 	mov	r1, #1	; 0x1
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;  
		break;
 3f17b58:	eaffff50 	b	3f178a0 <Ep0Handler+0x684>

	case EP0_GET_STATUS4:
		WrPktEp0((U8 *)&StatusGet+4,1);
 3f17b5c:	e59f0048 	ldr	r0, [pc, #48]	; 3f17bac <Ep0Handler+0x990>
 3f17b60:	e3a01001 	mov	r1, #1	; 0x1
 3f17b64:	eb0000ca 	bl	3f17e94 <WrPktEp0>
		SET_EP0_INPKTRDY_DATAEND();
		ep0State=EP0_STATE_INIT;  
 3f17b68:	e3a03000 	mov	r3, #0	; 0x0
 3f17b6c:	e5843000 	str	r3, [r4]
 3f17b70:	e205303f 	and	r3, r5, #63	; 0x3f
 3f17b74:	e59f2010 	ldr	r2, [pc, #10]	; 3f17b8c <Ep0Handler+0x970>
 3f17b78:	e383300a 	orr	r3, r3, #10	; 0xa
 3f17b7c:	e1c230b0 	strh	r3, [r2]
		break;

	default:
		DbgPrintf("UE:G?D");
		break;
	}
}
 3f17b80:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f17b84:	03f72fb0 	mvneqs	r2, #704	; 0x2c0
 3f17b88:	03f1fd14 	mvneqs	r15, #1280	; 0x500
 3f17b8c:	c0001422 	andgt	r1, r0, r2, lsr #8
 3f17b90:	03f1fd2a 	mvneqs	r15, #2688	; 0xa80
 3f17b94:	03f6a120 	mvneqs	r10, #8	; 0x8
 3f17b98:	03f730bc 	mvneqs	r3, #188	; 0xbc
 3f17b9c:	03f730c4 	mvneqs	r3, #196	; 0xc4
 3f17ba0:	03f730c5 	mvneqs	r3, #197	; 0xc5
 3f17ba4:	03f730c6 	mvneqs	r3, #198	; 0xc6
 3f17ba8:	03f730c7 	mvneqs	r3, #199	; 0xc7
 3f17bac:	03f730c8 	mvneqs	r3, #200	; 0xc8

03f17bb0 <PrintEp0Pkt>:
 3f17bb0:	e1a0c00d 	mov	r12, r13
 3f17bb4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17bb8:	e24cb004 	sub	r11, r12, #4	; 0x4

void PrintEp0Pkt(U8 *pt)
{
	int i;
	DbgPrintf("[RCV:");
	for(i=0;i<EP0_PKT_SIZE;i++)
 3f17bbc:	e3a03007 	mov	r3, #7	; 0x7
 3f17bc0:	e2533001 	subs	r3, r3, #1	; 0x1
 3f17bc4:	5afffffd 	bpl	3f17bc0 <PrintEp0Pkt+0x10>
		DbgPrintf("%x,",pt[i]);
	DbgPrintf("]");
}
 3f17bc8:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f17bcc <InitDescriptorTable>:
 3f17bcc:	e1a0c00d 	mov	r12, r13
 3f17bd0:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f17bd4:	e24cb004 	sub	r11, r12, #4	; 0x4

void InitDescriptorTable(void)
{	
	//Standard device descriptor
	descDev.bLength=0x12;	//EP0_DEV_DESC_SIZE=0x12 bytes
 3f17bd8:	e59f3128 	ldr	r3, [pc, #128]	; 3f17d08 <InitDescriptorTable+0x13c>
 3f17bdc:	e3a0c012 	mov	r12, #18	; 0x12
 3f17be0:	e5c3c000 	strb	r12, [r3]
	descDev.bDescriptorType=DEVICE_TYPE;
 3f17be4:	e3a00001 	mov	r0, #1	; 0x1
 3f17be8:	e5c30001 	strb	r0, [r3, #1]
	descDev.bcdUSBL=0x10;
 3f17bec:	e3a02010 	mov	r2, #16	; 0x10
 3f17bf0:	e5c32002 	strb	r2, [r3, #2]
	descDev.bcdUSBH=0x01; 	//Ver 1.10
 3f17bf4:	e5c30003 	strb	r0, [r3, #3]
	descDev.bDeviceClass=0xFF; //0x0
 3f17bf8:	e3a040ff 	mov	r4, #255	; 0xff
 3f17bfc:	e5c34004 	strb	r4, [r3, #4]
	descDev.bDeviceSubClass=0x0;
 3f17c00:	e3a01000 	mov	r1, #0	; 0x0
 3f17c04:	e5c31005 	strb	r1, [r3, #5]
	descDev.bDeviceProtocol=0x0;
 3f17c08:	e5c31006 	strb	r1, [r3, #6]
	descDev.bMaxPacketSize0=0x8;
 3f17c0c:	e2422008 	sub	r2, r2, #8	; 0x8
 3f17c10:	e5c32007 	strb	r2, [r3, #7]
	descDev.idVendorL=0x78;
 3f17c14:	e2822070 	add	r2, r2, #112	; 0x70
 3f17c18:	e5c32008 	strb	r2, [r3, #8]
	descDev.idVendorH=0x56;
 3f17c1c:	e2422022 	sub	r2, r2, #34	; 0x22
 3f17c20:	e5c32009 	strb	r2, [r3, #9]
	descDev.idProductL=0x34;
 3f17c24:	e2422022 	sub	r2, r2, #34	; 0x22
 3f17c28:	e5c3200a 	strb	r2, [r3, #10]
	descDev.idProductH=0x12;
 3f17c2c:	e5c3c00b 	strb	r12, [r3, #11]
	descDev.bcdDeviceL=0x00;
 3f17c30:	e5c3100c 	strb	r1, [r3, #12]
	descDev.bcdDeviceH=0x01;
 3f17c34:	e5c3000d 	strb	r0, [r3, #13]
	descDev.iManufacturer=0x1;  //index of string descriptor
 3f17c38:	e5c3000e 	strb	r0, [r3, #14]
	descDev.iProduct=0x2;	//index of string descriptor 
 3f17c3c:	e3a0e002 	mov	r14, #2	; 0x2
 3f17c40:	e5c3e00f 	strb	r14, [r3, #15]
	descDev.iSerialNumber=0x0;
 3f17c44:	e5c31010 	strb	r1, [r3, #16]
	descDev.bNumConfigurations=0x1;
 3f17c48:	e5c30011 	strb	r0, [r3, #17]

	//Standard configuration descriptor
	descConf.bLength=0x9;
 3f17c4c:	e59f30b8 	ldr	r3, [pc, #b8]	; 3f17d0c <InitDescriptorTable+0x140>
 3f17c50:	e24cc009 	sub	r12, r12, #9	; 0x9
 3f17c54:	e5c3c000 	strb	r12, [r3]
	descConf.bDescriptorType=CONFIGURATION_TYPE;
 3f17c58:	e5c3e001 	strb	r14, [r3, #1]
	descConf.wTotalLengthL=0x20; //<cfg desc>+<if desc>+<endp0 desc>+<endp1 desc>
 3f17c5c:	e2422014 	sub	r2, r2, #20	; 0x14
 3f17c60:	e5c32002 	strb	r2, [r3, #2]
	descConf.wTotalLengthH=0;
 3f17c64:	e5c31003 	strb	r1, [r3, #3]
	descConf.bNumInterfaces=1;
 3f17c68:	e5c30004 	strb	r0, [r3, #4]
	//dbg descConf.bConfigurationValue=2;  //why 2? There's no reason.
	descConf.bConfigurationValue=1;  
 3f17c6c:	e5c30005 	strb	r0, [r3, #5]
	descConf.iConfiguration=0;
 3f17c70:	e5c31006 	strb	r1, [r3, #6]
	descConf.bmAttributes=CONF_ATTR_DEFAULT|CONF_ATTR_SELFPOWERED;  //bus powered only.
 3f17c74:	e28220a0 	add	r2, r2, #160	; 0xa0
 3f17c78:	e5c32007 	strb	r2, [r3, #7]
	descConf.maxPower=25; //draws 50mA current from the USB bus.
 3f17c7c:	e24220a7 	sub	r2, r2, #167	; 0xa7
 3f17c80:	e5c32008 	strb	r2, [r3, #8]

	//Standard interface descriptor
	descIf.bLength=0x9;
 3f17c84:	e59f3084 	ldr	r3, [pc, #84]	; 3f17d10 <InitDescriptorTable+0x144>
 3f17c88:	e5c3c000 	strb	r12, [r3]
	descIf.bDescriptorType=INTERFACE_TYPE;
 3f17c8c:	e2422015 	sub	r2, r2, #21	; 0x15
 3f17c90:	e5c32001 	strb	r2, [r3, #1]
	descIf.bInterfaceNumber=0x0;
 3f17c94:	e5c31002 	strb	r1, [r3, #2]
	descIf.bAlternateSetting=0x0; //?
 3f17c98:	e5c31003 	strb	r1, [r3, #3]
	descIf.bNumEndpoints=2;	//# of endpoints except EP0
 3f17c9c:	e5c3e004 	strb	r14, [r3, #4]
	descIf.bInterfaceClass=0xff; //0x0 ?
 3f17ca0:	e5c34005 	strb	r4, [r3, #5]
	descIf.bInterfaceSubClass=0x0;  
 3f17ca4:	e5c31006 	strb	r1, [r3, #6]
	descIf.bInterfaceProtocol=0x0;
 3f17ca8:	e5c31007 	strb	r1, [r3, #7]
	descIf.iInterface=0x0;
 3f17cac:	e5c31008 	strb	r1, [r3, #8]

	//Standard endpoint0 descriptor
	descEndpt0.bLength=0x7;
 3f17cb0:	e59f305c 	ldr	r3, [pc, #5c]	; 3f17d14 <InitDescriptorTable+0x148>
 3f17cb4:	e24440f8 	sub	r4, r4, #248	; 0xf8
 3f17cb8:	e5c34000 	strb	r4, [r3]
	descEndpt0.bDescriptorType=ENDPOINT_TYPE;
 3f17cbc:	e24cc004 	sub	r12, r12, #4	; 0x4
 3f17cc0:	e5c3c001 	strb	r12, [r3, #1]
	descEndpt0.bEndpointAddress=1|EP_ADDR_IN;   // 2400Xendpoint 1 is IN endpoint.
 3f17cc4:	e282207d 	add	r2, r2, #125	; 0x7d
 3f17cc8:	e5c32002 	strb	r2, [r3, #2]
	descEndpt0.bmAttributes=EP_ATTR_BULK;
 3f17ccc:	e5c3e003 	strb	r14, [r3, #3]
	descEndpt0.wMaxPacketSizeL=EP1_PKT_SIZE; //64
 3f17cd0:	e280003f 	add	r0, r0, #63	; 0x3f
 3f17cd4:	e5c30004 	strb	r0, [r3, #4]
	descEndpt0.wMaxPacketSizeH=0x0;
 3f17cd8:	e5c31005 	strb	r1, [r3, #5]
	descEndpt0.bInterval=0x0; //not used
 3f17cdc:	e5c31006 	strb	r1, [r3, #6]

	//Standard endpoint1 descriptor
	descEndpt1.bLength=0x7;
 3f17ce0:	e59f3030 	ldr	r3, [pc, #30]	; 3f17d18 <InitDescriptorTable+0x14c>
 3f17ce4:	e5c34000 	strb	r4, [r3]
	descEndpt1.bDescriptorType=ENDPOINT_TYPE;
 3f17ce8:	e5c3c001 	strb	r12, [r3, #1]
	descEndpt1.bEndpointAddress=3|EP_ADDR_OUT;   // 2400X endpoint 3 is OUT endpoint.
 3f17cec:	e242207e 	sub	r2, r2, #126	; 0x7e
 3f17cf0:	e5c32002 	strb	r2, [r3, #2]
	descEndpt1.bmAttributes=EP_ATTR_BULK;
 3f17cf4:	e5c3e003 	strb	r14, [r3, #3]
	descEndpt1.wMaxPacketSizeL=EP3_PKT_SIZE; //64
 3f17cf8:	e5c30004 	strb	r0, [r3, #4]
	descEndpt1.wMaxPacketSizeH=0x0;
 3f17cfc:	e5c31005 	strb	r1, [r3, #5]
	descEndpt1.bInterval=0x0; //not used 
 3f17d00:	e5c31006 	strb	r1, [r3, #6]
 3f17d04:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f17d08:	03f73080 	mvneqs	r3, #128	; 0x80
 3f17d0c:	03f73094 	mvneqs	r3, #148	; 0x94
 3f17d10:	03f730a0 	mvneqs	r3, #160	; 0xa0
 3f17d14:	03f730ac 	mvneqs	r3, #172	; 0xac
 3f17d18:	03f730b4 	mvneqs	r3, #180	; 0xb4

03f17d1c <ConfigUsbd>:
 3f17d1c:	e1a0c00d 	mov	r12, r13
 3f17d20:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17d24:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void ConfigUsbd(void)
{

	ReconfigUsbd();
 3f17d28:	eb000000 	bl	3f17d30 <ReconfigUsbd>
 3f17d2c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f17d30 <ReconfigUsbd>:
 3f17d30:	e1a0c00d 	mov	r12, r13
 3f17d34:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
}


void ReconfigUsbd(void)
{
// *** End point information ***
//   EP0: control
//   EP1: bulk in end point
//   EP2: not used
//   EP3: bulk out end point
//   EP4: not used
	
	rPWR_REG=PWR_REG_DEFAULT_VALUE;	//disable suspend mode
 3f17d38:	e59f30f4 	ldr	r3, [pc, #f4]	; 3f17e34 <ReconfigUsbd+0x104>

	rINDEX_REG=0;
 3f17d3c:	e59fa0f4 	ldr	r10, [pc, #f4]	; 3f17e38 <ReconfigUsbd+0x108>
	rMAXP_REG=FIFO_SIZE_8;   	//EP0 max packit size = 8 
 3f17d40:	e59f70f4 	ldr	r7, [pc, #f4]	; 3f17e3c <ReconfigUsbd+0x10c>
	rEP0_CSR=EP0_SERVICED_OUT_PKT_RDY|EP0_SERVICED_SETUP_END;
 3f17d44:	e59f50f4 	ldr	r5, [pc, #f4]	; 3f17e40 <ReconfigUsbd+0x110>
				//EP0:clear OUT_PKT_RDY & SETUP_END
	/* Endpoint1 Initialize */
	rINDEX_REG=1;
	#if (EP1_PKT_SIZE==32)
		rMAXP_REG=FIFO_SIZE_32;	//EP1:max packit size = 32
	#else
		rMAXP_REG=FIFO_SIZE_64;	//EP1:max packit size = 64
	#endif
	rIN_CSR1_REG=EPI_FIFO_FLUSH|EPI_CDT;
	rIN_CSR2_REG=EPI_MODE_IN|EPI_IN_DMA_INT_MASK|EPI_BULK; //IN mode, IN_DMA_INT=masked
 3f17d48:	e59fe0f4 	ldr	r14, [pc, #f4]	; 3f17e44 <ReconfigUsbd+0x114>
 3f17d4c:	e24cb004 	sub	r11, r12, #4	; 0x4
	rOUT_CSR1_REG=EPO_CDT;
 3f17d50:	e59fc0f0 	ldr	r12, [pc, #f0]	; 3f17e48 <ReconfigUsbd+0x118>
	rOUT_CSR2_REG=EPO_BULK|EPO_OUT_DMA_INT_MASK;
 3f17d54:	e59f10f0 	ldr	r1, [pc, #f0]	; 3f17e4c <ReconfigUsbd+0x11c>
 3f17d58:	e3a02000 	mov	r2, #0	; 0x0
 3f17d5c:	e1c320b0 	strh	r2, [r3]
 3f17d60:	e1ca20b0 	strh	r2, [r10]
 3f17d64:	e3a02001 	mov	r2, #1	; 0x1
 3f17d68:	e1c720b0 	strh	r2, [r7]
 3f17d6c:	e3a030c0 	mov	r3, #192	; 0xc0
 3f17d70:	e1c530b0 	strh	r3, [r5]
 3f17d74:	e1ca20b0 	strh	r2, [r10]
 3f17d78:	e3a06008 	mov	r6, #8	; 0x8
 3f17d7c:	e1c760b0 	strh	r6, [r7]
 3f17d80:	e3a04048 	mov	r4, #72	; 0x48
 3f17d84:	e1c540b0 	strh	r4, [r5]
 3f17d88:	e3a09030 	mov	r9, #48	; 0x30
 3f17d8c:	e1ce90b0 	strh	r9, [r14]
 3f17d90:	e3a00080 	mov	r0, #128	; 0x80
 3f17d94:	e1cc00b0 	strh	r0, [r12]
 3f17d98:	e282201f 	add	r2, r2, #31	; 0x1f
 3f17d9c:	e1c120b0 	strh	r2, [r1]

	/* Endpoint2 Initialize */
	rINDEX_REG=2;
 3f17da0:	e24330be 	sub	r3, r3, #190	; 0xbe
 3f17da4:	e1ca30b0 	strh	r3, [r10]
	rMAXP_REG=FIFO_SIZE_64;	//EP2:max packit size = 64
 3f17da8:	e1c760b0 	strh	r6, [r7]
	rIN_CSR1_REG=EPI_FIFO_FLUSH|EPI_CDT|EPI_BULK;
 3f17dac:	e1c540b0 	strh	r4, [r5]
	rIN_CSR2_REG=EPI_MODE_IN|EPI_IN_DMA_INT_MASK; //IN mode, IN_DMA_INT=masked
 3f17db0:	e1ce90b0 	strh	r9, [r14]
	rOUT_CSR1_REG=EPO_CDT;
 3f17db4:	e1cc00b0 	strh	r0, [r12]
	rOUT_CSR2_REG=EPO_BULK|EPO_OUT_DMA_INT_MASK;
 3f17db8:	e1c120b0 	strh	r2, [r1]

	/* Endpoint3 Initialize */
	rINDEX_REG=3;
 3f17dbc:	e2833001 	add	r3, r3, #1	; 0x1
 3f17dc0:	e1ca30b0 	strh	r3, [r10]
	#if (EP3_PKT_SIZE==32)
		rMAXP_REG=FIFO_SIZE_32;	//EP3:max packit size = 32
	#else
		rMAXP_REG=FIFO_SIZE_64;	//EP3:max packit size = 64
 3f17dc4:	e1c760b0 	strh	r6, [r7]
	#endif
	rIN_CSR1_REG=EPI_FIFO_FLUSH|EPI_CDT|EPI_BULK;
 3f17dc8:	e1c540b0 	strh	r4, [r5]
	rIN_CSR2_REG=EPI_MODE_OUT|EPI_IN_DMA_INT_MASK; //OUT mode, IN_DMA_INT=masked
 3f17dcc:	e283300d 	add	r3, r3, #13	; 0xd
 3f17dd0:	e1ce30b0 	strh	r3, [r14]
	rOUT_CSR1_REG=EPO_CDT;
 3f17dd4:	e1cc00b0 	strh	r0, [r12]
	//clear OUT_PKT_RDY, data_toggle_bit.
	//The data toggle bit should be cleared when initialization.
	rOUT_CSR2_REG=EPO_BULK|EPO_OUT_DMA_INT_MASK;
 3f17dd8:	e1c120b0 	strh	r2, [r1]

	/* Endpoint4 Initialize */
	rINDEX_REG=4;
 3f17ddc:	e249902c 	sub	r9, r9, #44	; 0x2c
 3f17de0:	e1ca90b0 	strh	r9, [r10]
	rMAXP_REG=FIFO_SIZE_64;	//EP4:max packit size = 64
 3f17de4:	e1c760b0 	strh	r6, [r7]
	rIN_CSR1_REG=EPI_FIFO_FLUSH|EPI_CDT|EPI_BULK;
 3f17de8:	e1c540b0 	strh	r4, [r5]
	rIN_CSR2_REG=EPI_MODE_OUT|EPI_IN_DMA_INT_MASK; //OUT mode, IN_DMA_INT=masked
 3f17dec:	e1ce30b0 	strh	r3, [r14]
	rOUT_CSR1_REG=EPO_CDT;
 3f17df0:	e1cc00b0 	strh	r0, [r12]
	//clear OUT_PKT_RDY, data_toggle_bit.
	//The data toggle bit should be cleared when initialization.
	rOUT_CSR2_REG=EPO_BULK|EPO_OUT_DMA_INT_MASK;
 3f17df4:	e1c120b0 	strh	r2, [r1]
	
	rEP_INT_REG=EP0_INT|EP1_INT|EP2_INT|EP3_INT|EP4_INT;
 3f17df8:	e59f2050 	ldr	r2, [pc, #50]	; 3f17e50 <ReconfigUsbd+0x120>
 3f17dfc:	e283300f 	add	r3, r3, #15	; 0xf
 3f17e00:	e1c230b0 	strh	r3, [r2]
	rUSB_INT_REG=RESET_INT|SUSPEND_INT|RESUME_INT; 
 3f17e04:	e0822006 	add	r2, r2, r6
 3f17e08:	e2433018 	sub	r3, r3, #24	; 0x18
 3f17e0c:	e1c230b0 	strh	r3, [r2]
	//Clear all usbd pending bits

	//EP0,1,3 & reset interrupt are enabled
	rEP_INT_EN_REG=EP0_INT|EP1_INT|EP3_INT;
 3f17e10:	e2822002 	add	r2, r2, #2	; 0x2
 3f17e14:	e2833004 	add	r3, r3, #4	; 0x4
 3f17e18:	e1c230b0 	strh	r3, [r2]
	rUSB_INT_EN_REG=RESET_INT;
 3f17e1c:	e59f3030 	ldr	r3, [pc, #30]	; 3f17e54 <ReconfigUsbd+0x124>
 3f17e20:	e1c390b0 	strh	r9, [r3]
	ep0State=EP0_STATE_INIT;
 3f17e24:	e59f302c 	ldr	r3, [pc, #2c]	; 3f17e58 <ReconfigUsbd+0x128>
 3f17e28:	e3a02000 	mov	r2, #0	; 0x0
 3f17e2c:	e5832000 	str	r2, [r3]
 3f17e30:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}
 3f17e34:	c0001402 	andgt	r1, r0, r2, lsl #8
 3f17e38:	c000141c 	andgt	r1, r0, r12, lsl r4
 3f17e3c:	c0001420 	andgt	r1, r0, r0, lsr #8
 3f17e40:	c0001422 	andgt	r1, r0, r2, lsr #8
 3f17e44:	c0001424 	andgt	r1, r0, r4, lsr #8
 3f17e48:	c0001428 	andgt	r1, r0, r8, lsr #8
 3f17e4c:	c000142a 	andgt	r1, r0, r10, lsr #8
 3f17e50:	c0001404 	andgt	r1, r0, r4, lsl #8
 3f17e54:	c0001416 	andgt	r1, r0, r6, lsl r4
 3f17e58:	03f73038 	mvneqs	r3, #56	; 0x38

03f17e5c <RdPktEp0>:
 3f17e5c:	e1a0c00d 	mov	r12, r13
 3f17e60:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17e64:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void RdPktEp0(U8 *buf,int num)
{
	int i;

	for(i=0;i<num;i++)
 3f17e68:	e3a02000 	mov	r2, #0	; 0x0
 3f17e6c:	e1520001 	cmp	r2, r1
 3f17e70:	a91ba800 	ldmgedb	r11, {r11, r13, r15}
	{
		buf[i]=(U8)rEP0_FIFO;
 3f17e74:	e59f3014 	ldr	r3, [pc, #14]	; 3f17e90 <RdPktEp0+0x34>
 3f17e78:	e1d330b0 	ldrh	r3, [r3]
 3f17e7c:	e7c03002 	strb	r3, [r0, r2]
 3f17e80:	e2822001 	add	r2, r2, #1	; 0x1
 3f17e84:	e1520001 	cmp	r2, r1
 3f17e88:	bafffff9 	blt	3f17e74 <RdPktEp0+0x18>
	}
}
 3f17e8c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f17e90:	c0001440 	andgt	r1, r0, r0, asr #8

03f17e94 <WrPktEp0>:
 3f17e94:	e1a0c00d 	mov	r12, r13
 3f17e98:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17e9c:	e24cb004 	sub	r11, r12, #4	; 0x4

void WrPktEp0(U8 *buf,int num)
{
	int i;
		
	for(i=0;i<num;i++)
 3f17ea0:	e3a0c000 	mov	r12, #0	; 0x0
 3f17ea4:	e15c0001 	cmp	r12, r1
 3f17ea8:	a91ba800 	ldmgedb	r11, {r11, r13, r15}
	{
		rEP0_FIFO=buf[i];
 3f17eac:	e7d0200c 	ldrb	r2, [r0, r12]
 3f17eb0:	e28cc001 	add	r12, r12, #1	; 0x1
 3f17eb4:	e59f300c 	ldr	r3, [pc, #c]	; 3f17ec8 <WrPktEp0+0x34>
 3f17eb8:	e15c0001 	cmp	r12, r1
 3f17ebc:	e1c320b0 	strh	r2, [r3]
 3f17ec0:	bafffff9 	blt	3f17eac <WrPktEp0+0x18>
	}
}
 3f17ec4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f17ec8:	c0001440 	andgt	r1, r0, r0, asr #8

03f17ecc <WrByteEp0>:
 3f17ecc:	e1a0c00d 	mov	r12, r13
 3f17ed0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17ed4:	e24cb004 	sub	r11, r12, #4	; 0x4

void WrByteEp0(U8 value)
{
	rEP0_FIFO= value;
 3f17ed8:	e59f3008 	ldr	r3, [pc, #8]	; 3f17ee8 <WrByteEp0+0x1c>
 3f17edc:	e20000ff 	and	r0, r0, #255	; 0xff
 3f17ee0:	e1c300b0 	strh	r0, [r3]
 3f17ee4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f17ee8:	c0001440 	andgt	r1, r0, r0, asr #8

03f17eec <WrPktEp1>:
 3f17eec:	e1a0c00d 	mov	r12, r13
 3f17ef0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17ef4:	e24cb004 	sub	r11, r12, #4	; 0x4
}

void WrPktEp1(U8 *buf,int num)
{
	int i;

	for(i=0;i<num;i++) rEP1_FIFO=buf[i];
 3f17ef8:	e3a0c000 	mov	r12, #0	; 0x0
 3f17efc:	e15c0001 	cmp	r12, r1
 3f17f00:	a91ba800 	ldmgedb	r11, {r11, r13, r15}
 3f17f04:	e7d0200c 	ldrb	r2, [r0, r12]
 3f17f08:	e28cc001 	add	r12, r12, #1	; 0x1
 3f17f0c:	e59f300c 	ldr	r3, [pc, #c]	; 3f17f20 <WrPktEp1+0x34>
 3f17f10:	e15c0001 	cmp	r12, r1
 3f17f14:	e1c320b0 	strh	r2, [r3]
 3f17f18:	bafffff9 	blt	3f17f04 <WrPktEp1+0x18>
}
 3f17f1c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f17f20:	c0001442 	andgt	r1, r0, r2, asr #8

03f17f24 <WrPktEp2>:
 3f17f24:	e1a0c00d 	mov	r12, r13
 3f17f28:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17f2c:	e24cb004 	sub	r11, r12, #4	; 0x4

void WrPktEp2(U8 *buf,int num)
{
	int i;

	for(i=0;i<num;i++) rEP2_FIFO=buf[i];
 3f17f30:	e3a0c000 	mov	r12, #0	; 0x0
 3f17f34:	e15c0001 	cmp	r12, r1
 3f17f38:	a91ba800 	ldmgedb	r11, {r11, r13, r15}
 3f17f3c:	e7d0200c 	ldrb	r2, [r0, r12]
 3f17f40:	e28cc001 	add	r12, r12, #1	; 0x1
 3f17f44:	e59f300c 	ldr	r3, [pc, #c]	; 3f17f58 <WrPktEp2+0x34>
 3f17f48:	e15c0001 	cmp	r12, r1
 3f17f4c:	e1c320b0 	strh	r2, [r3]
 3f17f50:	bafffff9 	blt	3f17f3c <WrPktEp2+0x18>
}
 3f17f54:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f17f58:	c0001444 	andgt	r1, r0, r4, asr #8

03f17f5c <RdPktEp3>:
 3f17f5c:	e1a0c00d 	mov	r12, r13
 3f17f60:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17f64:	e24cb004 	sub	r11, r12, #4	; 0x4

void RdPktEp3(U8 *buf,int num)
{
	int i;

	for(i=0;i<num;i++) buf[i]=(U8)rEP3_FIFO;
 3f17f68:	e3a02000 	mov	r2, #0	; 0x0
 3f17f6c:	e1520001 	cmp	r2, r1
 3f17f70:	a91ba800 	ldmgedb	r11, {r11, r13, r15}
 3f17f74:	e59f3014 	ldr	r3, [pc, #14]	; 3f17f90 <RdPktEp3+0x34>
 3f17f78:	e1d330b0 	ldrh	r3, [r3]
 3f17f7c:	e7c03002 	strb	r3, [r0, r2]
 3f17f80:	e2822001 	add	r2, r2, #1	; 0x1
 3f17f84:	e1520001 	cmp	r2, r1
 3f17f88:	bafffff9 	blt	3f17f74 <RdPktEp3+0x18>
}
 3f17f8c:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f17f90:	c0001446 	andgt	r1, r0, r6, asr #8

03f17f94 <RdPktEp4>:
 3f17f94:	e1a0c00d 	mov	r12, r13
 3f17f98:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f17f9c:	e24cb004 	sub	r11, r12, #4	; 0x4

void RdPktEp4(U8 *buf,int num)
{
	int i;

	for(i=0;i<num;i++) buf[i]=(U8)rEP4_FIFO;
 3f17fa0:	e3a02000 	mov	r2, #0	; 0x0
 3f17fa4:	e1520001 	cmp	r2, r1
 3f17fa8:	a91ba800 	ldmgedb	r11, {r11, r13, r15}
 3f17fac:	e59f3014 	ldr	r3, [pc, #14]	; 3f17fc8 <RdPktEp4+0x34>
 3f17fb0:	e1d330b0 	ldrh	r3, [r3]
 3f17fb4:	e7c03002 	strb	r3, [r0, r2]
 3f17fb8:	e2822001 	add	r2, r2, #1	; 0x1
 3f17fbc:	e1520001 	cmp	r2, r1
 3f17fc0:	bafffff9 	blt	3f17fac <RdPktEp4+0x18>
}
 3f17fc4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f17fc8:	c0001448 	andgt	r1, r0, r8, asr #8

03f17fcc <do_bootm_linux>:
 3f17fcc:	e1a0c00d 	mov	r12, r13
 3f17fd0:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f17fd4:	e24cb004 	sub	r11, r12, #4	; 0x4
    ulong len = 0, checksum;
    ulong initrd_start, initrd_end;
    ulong data;
    void (*theKernel)(int zero, int arch);
    image_header_t *hdr = &header;
 3f17fd8:	e59f724c 	ldr	r7, [pc, #24c]	; 3f1822c <do_bootm_linux+0x260>
 3f17fdc:	e24dd010 	sub	r13, r13, #16	; 0x10
 3f17fe0:	e50b0028 	str	r0, [r11, -#40]
 3f17fe4:	e50b102c 	str	r1, [r11, -#44]
 3f17fe8:	e1a09002 	mov	r9, r2
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f17fec:	e5972014 	ldr	r2, [r7, #20]
 3f17ff0:	e1a0a003 	mov	r10, r3
 3f17ff4:	e59b0008 	ldr	r0, [r11, #8]
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f17ff8:	e2023cff 	and	r3, r2, #65280	; 0xff00
 3f17ffc:	e1a03403 	mov	r3, r3, lsl #8
 3f18000:	e1833c02 	orr	r3, r3, r2, lsl #24
 3f18004:	e20218ff 	and	r1, r2, #16711680	; 0xff0000
 3f18008:	e1833421 	orr	r3, r3, r1, lsr #8
 3f1800c:	e1832c22 	orr	r2, r3, r2, lsr #24
 3f18010:	e50b2030 	str	r2, [r11, -#48]
 3f18014:	e3a04000 	mov	r4, #0	; 0x0
    bd_t *bd = gd->bd;
 3f18018:	e5983000 	ldr	r3, [r8]
#ifdef CONFIG_CMDLINE_TAG
    char *commandline = getenv("bootargs");
#endif

    theKernel = (void (*)(int, int))ntohl(hdr->ih_ep);

    /*
     * Check if there is an initrd image
     */
    if (argc >= 3) {
 3f1801c:	e3590002 	cmp	r9, #2	; 0x2
 3f18020:	e50b3034 	str	r3, [r11, -#52]
 3f18024:	da000065 	ble	3f181c0 <do_bootm_linux+0x1f4>
	SHOW_BOOT_PROGRESS (9);

	addr = simple_strtoul(argv[2], NULL, 16);
 3f18028:	e1a01004 	mov	r1, r4
 3f1802c:	e59a0008 	ldr	r0, [r10, #8]
 3f18030:	e3a02010 	mov	r2, #16	; 0x10
 3f18034:	ebffddc2 	bl	3f0f744 <simple_strtoul>
 3f18038:	e1a06000 	mov	r6, r0

	printf ("## Loading Ramdisk Image at %08lx ...\n", addr);
 3f1803c:	e59f01ec 	ldr	r0, [pc, #1ec]	; 3f18230 <do_bootm_linux+0x264>
 3f18040:	e1a01006 	mov	r1, r6
 3f18044:	ebffd1fe 	bl	3f0c844 <printf>

	/* Copy header so we can blank CRC field for re-calculation */
#ifdef CONFIG_HAS_DATAFLASH
	if (addr_dataflash(addr)){
		read_dataflash(addr, sizeof(image_header_t), (char *)&header);
	} else
#endif
	memcpy (&header, (char *)addr, sizeof(image_header_t));
 3f18048:	e1a00007 	mov	r0, r7
 3f1804c:	e1a01006 	mov	r1, r6
 3f18050:	e3a02040 	mov	r2, #64	; 0x40
 3f18054:	ebffdd4b 	bl	3f0f588 <memcpy>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f18058:	e5971000 	ldr	r1, [r7]
	return __arch__swab32(x);
 3f1805c:	e2013cff 	and	r3, r1, #65280	; 0xff00
 3f18060:	e1a03403 	mov	r3, r3, lsl #8
 3f18064:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f18068:	e20128ff 	and	r2, r1, #16711680	; 0xff0000
 3f1806c:	e1833422 	orr	r3, r3, r2, lsr #8

	if (ntohl(hdr->ih_magic) != IH_MAGIC) {
 3f18070:	e59f21bc 	ldr	r2, [pc, #1bc]	; 3f18234 <do_bootm_linux+0x268>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f18074:	e1833c21 	orr	r3, r3, r1, lsr #24
 3f18078:	e1530002 	cmp	r3, r2
 3f1807c:	0a000006 	beq	3f1809c <do_bootm_linux+0xd0>
	    printf ("Bad Magic Number\n");
 3f18080:	e59f01b0 	ldr	r0, [pc, #1b0]	; 3f18238 <do_bootm_linux+0x26c>
 3f18084:	ebffd1ee 	bl	3f0c844 <printf>
	    SHOW_BOOT_PROGRESS (-10);
	    do_reset (cmdtp, flag, argc, argv);
 3f18088:	e51b0028 	ldr	r0, [r11, -#40]
 3f1808c:	e1a02009 	mov	r2, r9
 3f18090:	e51b102c 	ldr	r1, [r11, -#44]
 3f18094:	e1a0300a 	mov	r3, r10
 3f18098:	ebfff93d 	bl	3f16594 <do_reset>
	}

	data = (ulong)&header;
 3f1809c:	e1a05007 	mov	r5, r7
	len  = sizeof(image_header_t);

	checksum = ntohl(hdr->ih_hcrc);
	hdr->ih_hcrc = 0;
 3f180a0:	e3a03000 	mov	r3, #0	; 0x0

	if (crc32 (0, (char *)data, len) != checksum) {
 3f180a4:	e1a00003 	mov	r0, r3
 3f180a8:	e1a01005 	mov	r1, r5
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f180ac:	e595c004 	ldr	r12, [r5, #4]
 3f180b0:	e3a02040 	mov	r2, #64	; 0x40
 3f180b4:	e5853004 	str	r3, [r5, #4]
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f180b8:	e20c4cff 	and	r4, r12, #65280	; 0xff00
 3f180bc:	e1a04404 	mov	r4, r4, lsl #8
 3f180c0:	e1844c0c 	orr	r4, r4, r12, lsl #24
 3f180c4:	e20c38ff 	and	r3, r12, #16711680	; 0xff0000
 3f180c8:	e1844423 	orr	r4, r4, r3, lsr #8
 3f180cc:	e1844c2c 	orr	r4, r4, r12, lsr #24
 3f180d0:	ebffdb66 	bl	3f0ee70 <crc32>
 3f180d4:	e1500004 	cmp	r0, r4
 3f180d8:	0a000006 	beq	3f180f8 <do_bootm_linux+0x12c>
	    printf ("Bad Header Checksum\n");
 3f180dc:	e59f0158 	ldr	r0, [pc, #158]	; 3f1823c <do_bootm_linux+0x270>
 3f180e0:	ebffd1d7 	bl	3f0c844 <printf>
	    SHOW_BOOT_PROGRESS (-11);
	    do_reset (cmdtp, flag, argc, argv);
 3f180e4:	e51b0028 	ldr	r0, [r11, -#40]
 3f180e8:	e1a02009 	mov	r2, r9
 3f180ec:	e51b102c 	ldr	r1, [r11, -#44]
 3f180f0:	e1a0300a 	mov	r3, r10
 3f180f4:	ebfff926 	bl	3f16594 <do_reset>
	}

	SHOW_BOOT_PROGRESS (10);

	print_image_hdr (hdr);
 3f180f8:	e1a00005 	mov	r0, r5
 3f180fc:	ebffb31f 	bl	3f04d80 <print_image_hdr>

	data = addr + sizeof(image_header_t);
	len  = ntohl(hdr->ih_size);

#ifdef CONFIG_HAS_DATAFLASH
	if (addr_dataflash(addr)){
		read_dataflash(data, len, (char *)CFG_LOAD_ADDR);
		data = CFG_LOAD_ADDR;
	}
#endif

	if (verify) {
 3f18100:	e59b300c 	ldr	r3, [r11, #12]
 3f18104:	e2865040 	add	r5, r6, #64	; 0x40
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f18108:	e597100c 	ldr	r1, [r7, #12]
 3f1810c:	e3530000 	cmp	r3, #0	; 0x0
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f18110:	e2013cff 	and	r3, r1, #65280	; 0xff00
 3f18114:	e1a03403 	mov	r3, r3, lsl #8
 3f18118:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f1811c:	e20128ff 	and	r2, r1, #16711680	; 0xff0000
 3f18120:	e1833422 	orr	r3, r3, r2, lsr #8
 3f18124:	e1834c21 	orr	r4, r3, r1, lsr #24
 3f18128:	0a000017 	beq	3f1818c <do_bootm_linux+0x1c0>
	    ulong csum = 0;

	    printf ("   Verifying Checksum ... ");
 3f1812c:	e59f010c 	ldr	r0, [pc, #10c]	; 3f18240 <do_bootm_linux+0x274>
 3f18130:	ebffd1c3 	bl	3f0c844 <printf>
	    csum = crc32 (0, (char *)data, len);
 3f18134:	e3a00000 	mov	r0, #0	; 0x0
 3f18138:	e1a01005 	mov	r1, r5
 3f1813c:	e1a02004 	mov	r2, r4
 3f18140:	ebffdb4a 	bl	3f0ee70 <crc32>
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f18144:	e5973018 	ldr	r3, [r7, #24]
	return __arch__swab32(x);
 3f18148:	e2032cff 	and	r2, r3, #65280	; 0xff00
 3f1814c:	e1a02402 	mov	r2, r2, lsl #8
 3f18150:	e1822c03 	orr	r2, r2, r3, lsl #24
 3f18154:	e20318ff 	and	r1, r3, #16711680	; 0xff0000
 3f18158:	e1822421 	orr	r2, r2, r1, lsr #8
 3f1815c:	e1822c23 	orr	r2, r2, r3, lsr #24
	    if (csum != ntohl(hdr->ih_dcrc)) {
 3f18160:	e1500002 	cmp	r0, r2
 3f18164:	0a000006 	beq	3f18184 <do_bootm_linux+0x1b8>
		printf ("Bad Data CRC\n");
 3f18168:	e59f00d4 	ldr	r0, [pc, #d4]	; 3f18244 <do_bootm_linux+0x278>
 3f1816c:	ebffd1b4 	bl	3f0c844 <printf>
		SHOW_BOOT_PROGRESS (-12);
		do_reset (cmdtp, flag, argc, argv);
 3f18170:	e51b0028 	ldr	r0, [r11, -#40]
 3f18174:	e1a02009 	mov	r2, r9
 3f18178:	e51b102c 	ldr	r1, [r11, -#44]
 3f1817c:	e1a0300a 	mov	r3, r10
 3f18180:	ebfff903 	bl	3f16594 <do_reset>
	    }
	    printf ("OK\n");
 3f18184:	e59f00bc 	ldr	r0, [pc, #bc]	; 3f18248 <do_bootm_linux+0x27c>
 3f18188:	ebffd1ad 	bl	3f0c844 <printf>
	}

	SHOW_BOOT_PROGRESS (11);

	if ((hdr->ih_os   != IH_OS_LINUX)	||
 3f1818c:	e597301c 	ldr	r3, [r7, #28]
 3f18190:	e59f20b4 	ldr	r2, [pc, #b4]	; 3f1824c <do_bootm_linux+0x280>
 3f18194:	e3c334ff 	bic	r3, r3, #-16777216	; 0xff000000
 3f18198:	e1530002 	cmp	r3, r2
 3f1819c:	0a00002d 	beq	3f18258 <do_bootm_linux+0x28c>
	    (hdr->ih_arch != IH_CPU_ARM)	||
	    (hdr->ih_type != IH_TYPE_RAMDISK)	) {
	    printf ("No Linux ARM Ramdisk Image\n");
 3f181a0:	e59f00a8 	ldr	r0, [pc, #a8]	; 3f18250 <do_bootm_linux+0x284>
 3f181a4:	ebffd1a6 	bl	3f0c844 <printf>
	    SHOW_BOOT_PROGRESS (-13);
	    do_reset (cmdtp, flag, argc, argv);
 3f181a8:	e51b0028 	ldr	r0, [r11, -#40]
 3f181ac:	e1a02009 	mov	r2, r9
 3f181b0:	e51b102c 	ldr	r1, [r11, -#44]
 3f181b4:	e1a0300a 	mov	r3, r10
 3f181b8:	ebfff8f5 	bl	3f16594 <do_reset>
	}

	/*
	 * Now check if we have a multifile image
	 */
    } else if ((hdr->ih_type==IH_TYPE_MULTI) && (len_ptr[1])) {
 3f181bc:	ea000025 	b	3f18258 <do_bootm_linux+0x28c>
 3f181c0:	e5d7301e 	ldrb	r3, [r7, #30]
 3f181c4:	e3530004 	cmp	r3, #4	; 0x4
 3f181c8:	1a000021 	bne	3f18254 <do_bootm_linux+0x288>
 3f181cc:	e5903004 	ldr	r3, [r0, #4]
 3f181d0:	e3530000 	cmp	r3, #0	; 0x0
 3f181d4:	0a00001e 	beq	3f18254 <do_bootm_linux+0x288>
	ulong tail    = ntohl(len_ptr[0]) % 4;
	int i;

	SHOW_BOOT_PROGRESS (13);

	/* skip kernel length and terminator */
	data = (ulong)(&len_ptr[2]);
 3f181d8:	e2805008 	add	r5, r0, #8	; 0x8
	__arch__swab16s(addr);
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
 3f181dc:	e5901000 	ldr	r1, [r0]
	/* skip any additional image length fields */
	for (i=1; len_ptr[i]; ++i)
 3f181e0:	e3a02001 	mov	r2, #1	; 0x1
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f181e4:	e1a03c21 	mov	r3, r1, lsr #24
 3f181e8:	e203c003 	and	r12, r3, #3	; 0x3
 3f181ec:	e2822001 	add	r2, r2, #1	; 0x1
 3f181f0:	e7903102 	ldr	r3, [r0, r2, lsl #2]
	  data += 4;
 3f181f4:	e2855004 	add	r5, r5, #4	; 0x4
 3f181f8:	e3530000 	cmp	r3, #0	; 0x0
 3f181fc:	1afffffa 	bne	3f181ec <do_bootm_linux+0x220>
}

extern __inline__ __const__ __u32 __fswab32(__u32 x)
{
	return __arch__swab32(x);
 3f18200:	e2013cff 	and	r3, r1, #65280	; 0xff00
 3f18204:	e1a03403 	mov	r3, r3, lsl #8
 3f18208:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f1820c:	e20128ff 	and	r2, r1, #16711680	; 0xff0000
 3f18210:	e1833422 	orr	r3, r3, r2, lsr #8
 3f18214:	e1833c21 	orr	r3, r3, r1, lsr #24
	/* add kernel length, and align */
	data += ntohl(len_ptr[0]);
 3f18218:	e0855003 	add	r5, r5, r3
	if (tail) {
	    data += 4 - tail;
 3f1821c:	e2853004 	add	r3, r5, #4	; 0x4
 3f18220:	e35c0000 	cmp	r12, #0	; 0x0
 3f18224:	1043500c 	subne	r5, r3, r12
	}

	len   = ntohl(len_ptr[1]);

    } else {
 3f18228:	ea00000a 	b	3f18258 <do_bootm_linux+0x28c>
 3f1822c:	03f6cd04 	mvneqs	r12, #256	; 0x100
 3f18230:	03f1fe40 	mvneqs	r15, #1024	; 0x400
 3f18234:	27051956 	undefined
 3f18238:	03f1fe68 	mvneqs	r15, #1664	; 0x680
 3f1823c:	03f1fe7c 	mvneqs	r15, #1984	; 0x7c0
 3f18240:	03f1fe94 	mvneqs	r15, #2368	; 0x940
 3f18244:	03f1feb0 	mvneqs	r15, #2816	; 0xb00
 3f18248:	03f1fec0 	mvneqs	r15, #3072	; 0xc00
 3f1824c:	00030205 	andeq	r0, r3, r5, lsl #4
 3f18250:	03f1fec4 	mvneqs	r15, #3136	; 0xc40
	/*
	 * no initrd image
	 */
	SHOW_BOOT_PROGRESS (14);

	data = 0;
 3f18254:	e3a05000 	mov	r5, #0	; 0x0
    }

#ifdef	DEBUG
    if (!data) {
	printf ("No initrd\n");
    }
#endif

    if (data) {
 3f18258:	e3550000 	cmp	r5, #0	; 0x0
	initrd_start = data;
	initrd_end   = initrd_start + len;
    } else {
	initrd_start = 0;
	initrd_end = 0;
    }

    SHOW_BOOT_PROGRESS (15);

#ifdef DEBUG
    printf ("## Transferring control to Linux (at address %08lx) ...\n",
	    (ulong)theKernel);
#endif

#if defined (CONFIG_SETUP_MEMORY_TAGS) || \
    defined (CONFIG_CMDLINE_TAG) || \
    defined (CONFIG_INITRD_TAG) || \
    defined (CONFIG_VFD)
    setup_start_tag(bd);
#ifdef CONFIG_SETUP_MEMORY_TAGS
    setup_memory_tags(bd);
#endif
#ifdef CONFIG_CMDLINE_TAG
    setup_commandline_tag(bd, commandline);
#endif
#ifdef CONFIG_INITRD_TAG
    setup_initrd_tag(bd, initrd_start, initrd_end);
#endif
#if 0
    setup_ramdisk_tag(bd);
#endif
#if defined (CONFIG_VFD)
    setup_videolfb_tag((gd_t *)gd);
#endif
    setup_end_tag(bd);
#endif

    /* we assume that the kernel is in place */
    printf("\nStarting kernel ...\n\n");
 3f1825c:	e59f0020 	ldr	r0, [pc, #20]	; 3f18284 <do_bootm_linux+0x2b8>
 3f18260:	ebffd177 	bl	3f0c844 <printf>

    cleanup_before_linux();
 3f18264:	ebfff8be 	bl	3f16564 <cleanup_before_linux>

    theKernel(0, bd->bi_arch_number);
 3f18268:	e51b3034 	ldr	r3, [r11, -#52]
 3f1826c:	e5931014 	ldr	r1, [r3, #20]
 3f18270:	e51b3030 	ldr	r3, [r11, -#48]
 3f18274:	e3a00000 	mov	r0, #0	; 0x0
 3f18278:	e1a0e00f 	mov	r14, r15
 3f1827c:	e1a0f003 	mov	r15, r3
 3f18280:	ea000000 	b	3f18288 <do_bootm_linux+0x2bc>
 3f18284:	03f1fee0 	mvneqs	r15, #3584	; 0xe00
}
 3f18288:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f1828c <flush_cache>:
 3f1828c:	e1a0c00d 	mov	r12, r13
 3f18290:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f18294:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f18298:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1829c <downcase>:
 3f1829c:	e1a0c00d 	mov	r12, r13
 3f182a0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 * Convert a string to lowercase.
 */
static void downcase(char *str)
{
	while (*str != '\0') 
 3f182a4:	e5d02000 	ldrb	r2, [r0]
 3f182a8:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f182ac:	e3520000 	cmp	r2, #0	; 0x0
 3f182b0:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
	{
		TOLOWER(*str);
 3f182b4:	e2423041 	sub	r3, r2, #65	; 0x41
 3f182b8:	e3530019 	cmp	r3, #25	; 0x19
 3f182bc:	92823020 	addls	r3, r2, #32	; 0x20
 3f182c0:	95c03000 	strlsb	r3, [r0]
		str++;
	}
 3f182c4:	e5f02001 	ldrb	r2, [r0, #1]!
 3f182c8:	e3520000 	cmp	r2, #0	; 0x0
 3f182cc:	1afffff8 	bne	3f182b4 <downcase+0x18>
 3f182d0:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f182d4 <disk_read>:
 3f182d4:	e1a0c00d 	mov	r12, r13
 3f182d8:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
}
//[*]----------------------------------------------------------------------------------------------------[*]
static  block_dev_desc_t *cur_dev = NULL;
static unsigned long part_offset = 0;
static int cur_part = 1;
//[*]----------------------------------------------------------------------------------------------------[*]
#define DOS_PART_TBL_OFFSET		0x1be
#define DOS_PART_MAGIC_OFFSET	0x1fe
#define DOS_FS_TYPE_OFFSET		0x36
#if 1 /* shkim patch */
#define DOS_FS_TYPE_OFFSET_FAT32	0x52
#endif
//[*]----------------------------------------------------------------------------------------------------[*]
int disk_read (__u32 startblock, __u32 getsize, __u8 * bufptr)
{
	startblock += part_offset;
	if (cur_dev == NULL)
 3f182dc:	e59f304c 	ldr	r3, [pc, #4c]	; 3f18330 <disk_read+0x5c>
 3f182e0:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f182e4:	e593c000 	ldr	r12, [r3]
 3f182e8:	e1a05001 	mov	r5, r1
 3f182ec:	e59f3040 	ldr	r3, [pc, #40]	; 3f18334 <disk_read+0x60>
 3f182f0:	e1a0e002 	mov	r14, r2
 3f182f4:	e5933000 	ldr	r3, [r3]
 3f182f8:	e35c0000 	cmp	r12, #0	; 0x0
 3f182fc:	e0801003 	add	r1, r0, r3
 3f18300:	1a000001 	bne	3f1830c <disk_read+0x38>
		return -1;
 3f18304:	e3e00000 	mvn	r0, #0	; 0x0
 3f18308:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
	if (cur_dev->block_read) {
 3f1830c:	e59c405c 	ldr	r4, [r12, #92]
 3f18310:	e3540000 	cmp	r4, #0	; 0x0
 3f18314:	0afffffa 	beq	3f18304 <disk_read+0x30>
		return cur_dev->block_read (cur_dev->dev, startblock, getsize, (unsigned long *)bufptr);
 3f18318:	e1a02005 	mov	r2, r5
 3f1831c:	e59c0004 	ldr	r0, [r12, #4]
 3f18320:	e1a0300e 	mov	r3, r14
 3f18324:	e1a0e00f 	mov	r14, r15
 3f18328:	e1a0f004 	mov	r15, r4
 3f1832c:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f18330:	03f6a1b4 	mvneqs	r10, #45	; 0x2d
 3f18334:	03f6a1b8 	mvneqs	r10, #46	; 0x2e

03f18338 <fat_register_device>:
 3f18338:	e1a0c00d 	mov	r12, r13
 3f1833c:	e92ddcf0 	stmdb	r13!, {r4, r5, r6, r7, r10, r11, r12, r14, r15}
 3f18340:	e24cb004 	sub	r11, r12, #4	; 0x4
	}
	return -1;
}
//[*]----------------------------------------------------------------------------------------------------[*]
int fat_register_device(block_dev_desc_t *dev_desc, int part_no)
{
 3f18344:	e1a05000 	mov	r5, r0
 3f18348:	e24ddf93 	sub	r13, r13, #588	; 0x24c
	unsigned char buffer[SECTOR_SIZE];

	if (!dev_desc->block_read)
 3f1834c:	e595c05c 	ldr	r12, [r5, #92]
 3f18350:	e1a0a001 	mov	r10, r1
 3f18354:	e35c0000 	cmp	r12, #0	; 0x0
 3f18358:	0a00000e 	beq	3f18398 <fat_register_device+0x60>
		return -1;
	cur_dev=dev_desc;
	/* check if we have a MBR (on floppies we have only a PBR) */
	if(dev_desc->block_read (dev_desc->dev, 0, 1, (ulong *) buffer) != 1) 
 3f1835c:	e3a01000 	mov	r1, #0	; 0x0
 3f18360:	e59f30c4 	ldr	r3, [pc, #c4]	; 3f1842c <fat_register_device+0xf4>
 3f18364:	e3a02001 	mov	r2, #1	; 0x1
 3f18368:	e5835000 	str	r5, [r3]
 3f1836c:	e24b4e22 	sub	r4, r11, #544	; 0x220
 3f18370:	e5950004 	ldr	r0, [r5, #4]
 3f18374:	e1a03004 	mov	r3, r4
 3f18378:	e1a0e00f 	mov	r14, r15
 3f1837c:	e1a0f00c 	mov	r15, r12
 3f18380:	e1a06000 	mov	r6, r0
 3f18384:	e3560001 	cmp	r6, #1	; 0x1
 3f18388:	0a000004 	beq	3f183a0 <fat_register_device+0x68>
	{
		printf ("** Can't read from device %d **\n", dev_desc->dev);
 3f1838c:	e59f009c 	ldr	r0, [pc, #9c]	; 3f18430 <fat_register_device+0xf8>
 3f18390:	e5951004 	ldr	r1, [r5, #4]
 3f18394:	ebffd12a 	bl	3f0c844 <printf>
		return -1;
 3f18398:	e3e00000 	mvn	r0, #0	; 0x0
 3f1839c:	ea00002e 	b	3f1845c <fat_register_device+0x124>
	}
	
	if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 || buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) 
 3f183a0:	e55b3022 	ldrb	r3, [r11, -#34]
 3f183a4:	e3530055 	cmp	r3, #85	; 0x55
 3f183a8:	1afffffa 	bne	3f18398 <fat_register_device+0x60>
 3f183ac:	e55b3021 	ldrb	r3, [r11, -#33]
 3f183b0:	e35300aa 	cmp	r3, #170	; 0xaa
 3f183b4:	1afffff7 	bne	3f18398 <fat_register_device+0x60>
	{
		/* no signature found */
		return -1;
	}
	if(!strncmp(&buffer[DOS_FS_TYPE_OFFSET],"FAT",3)) 
 3f183b8:	e2840036 	add	r0, r4, #54	; 0x36
 3f183bc:	e59f7070 	ldr	r7, [pc, #70]	; 3f18434 <fat_register_device+0xfc>
 3f183c0:	e3a02003 	mov	r2, #3	; 0x3
 3f183c4:	e1a01007 	mov	r1, r7
 3f183c8:	ebffdb89 	bl	3f0f1f4 <strncmp>
 3f183cc:	e3500000 	cmp	r0, #0	; 0x0
 3f183d0:	0a000005 	beq	3f183ec <fat_register_device+0xb4>
	{
		/* ok, we assume we are on a PBR only */
		cur_part = 1;
		part_offset=0;
	}
#if 1 /* shkim patch */
	else if(!strncmp(&buffer[DOS_FS_TYPE_OFFSET_FAT32],"FAT",3)) 
 3f183d4:	e2840052 	add	r0, r4, #82	; 0x52
 3f183d8:	e1a01007 	mov	r1, r7
 3f183dc:	e3a02003 	mov	r2, #3	; 0x3
 3f183e0:	ebffdb83 	bl	3f0f1f4 <strncmp>
 3f183e4:	e3500000 	cmp	r0, #0	; 0x0
 3f183e8:	1a000004 	bne	3f18400 <fat_register_device+0xc8>
	{
		/* ok, we assume we are on a PBR only */
		cur_part = 1;
 3f183ec:	e59f3044 	ldr	r3, [pc, #44]	; 3f18438 <fat_register_device+0x100>
 3f183f0:	e5836000 	str	r6, [r3]
		part_offset=0;
 3f183f4:	e59f3040 	ldr	r3, [pc, #40]	; 3f1843c <fat_register_device+0x104>
 3f183f8:	e5830000 	str	r0, [r3]
	}
 3f183fc:	ea000015 	b	3f18458 <fat_register_device+0x120>
#endif
	else 
	{
#if (CONFIG_COMMANDS & CFG_CMD_IDE) || (CONFIG_COMMANDS & CFG_CMD_SCSI) || (CONFIG_COMMANDS & CFG_CMD_MMC)
		disk_partition_t info;
		if(!get_partition_info(dev_desc, part_no, &info)) 
 3f18400:	e1a00005 	mov	r0, r5
 3f18404:	e1a0100a 	mov	r1, r10
 3f18408:	e24b2f9b 	sub	r2, r11, #620	; 0x26c
 3f1840c:	eb0005d5 	bl	3f19b68 <get_partition_info>
 3f18410:	e3500000 	cmp	r0, #0	; 0x0
 3f18414:	0a00000a 	beq	3f18444 <fat_register_device+0x10c>
		{
			part_offset = info.start;
			cur_part = part_no;
		}
		else 
		{
			printf ("** Partition %d not valid on device %d **\n",part_no,dev_desc->dev);
 3f18418:	e59f0020 	ldr	r0, [pc, #20]	; 3f18440 <fat_register_device+0x108>
 3f1841c:	e5952004 	ldr	r2, [r5, #4]
 3f18420:	e1a0100a 	mov	r1, r10
 3f18424:	ebffd106 	bl	3f0c844 <printf>
			return -1;
 3f18428:	eaffffda 	b	3f18398 <fat_register_device+0x60>
 3f1842c:	03f6a1b4 	mvneqs	r10, #45	; 0x2d
 3f18430:	03f1fef8 	mvneqs	r15, #3968	; 0xf80
 3f18434:	03f1ff1c 	mvneqs	r15, #112	; 0x70
 3f18438:	03f6a1bc 	mvneqs	r10, #47	; 0x2f
 3f1843c:	03f6a1b8 	mvneqs	r10, #46	; 0x2e
 3f18440:	03f1ff20 	mvneqs	r15, #128	; 0x80
 3f18444:	e59f3014 	ldr	r3, [pc, #14]	; 3f18460 <fat_register_device+0x128>
 3f18448:	e51b226c 	ldr	r2, [r11, -#620]
 3f1844c:	e5832000 	str	r2, [r3]
 3f18450:	e59f300c 	ldr	r3, [pc, #c]	; 3f18464 <fat_register_device+0x12c>
 3f18454:	e583a000 	str	r10, [r3]
		}
#else
		/* FIXME we need to determine the start block of the
		 * partition where the DOS FS resides. This can be done
		 * by using the get_partition_info routine. For this
		 * purpose the libpart must be included.
		 */
		part_offset=32;
		cur_part = 1;
#endif
	}
	return 0;
 3f18458:	e3a00000 	mov	r0, #0	; 0x0
 3f1845c:	ea000001 	b	3f18468 <fat_register_device+0x130>
 3f18460:	03f6a1b8 	mvneqs	r10, #46	; 0x2e
 3f18464:	03f6a1bc 	mvneqs	r10, #47	; 0x2f
}
 3f18468:	e91bacf0 	ldmdb	r11, {r4, r5, r6, r7, r10, r11, r13, r15}

03f1846c <dirdelim>:
 3f1846c:	e1a0c00d 	mov	r12, r13
 3f18470:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f18474:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * Get the first occurence of a directory delimiter ('/' or '\') in a string.
 * Return index into string if found, -1 otherwise.
 */
static int dirdelim(char *str)
{
	char *start = str;

	while (*str != '\0') {
 3f18478:	e5d03000 	ldrb	r3, [r0]
 3f1847c:	e1a02000 	mov	r2, r0
 3f18480:	e3530000 	cmp	r3, #0	; 0x0
 3f18484:	0a000007 	beq	3f184a8 <dirdelim+0x3c>
		if (ISDIRDELIM(*str)) return str - start;
 3f18488:	e5d03000 	ldrb	r3, [r0]
 3f1848c:	e353005c 	cmp	r3, #92	; 0x5c
 3f18490:	1353002f 	cmpne	r3, #47	; 0x2f
 3f18494:	00620000 	rsbeq	r0, r2, r0
 3f18498:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
		str++;
	}
 3f1849c:	e5f03001 	ldrb	r3, [r0, #1]!
 3f184a0:	e3530000 	cmp	r3, #0	; 0x0
 3f184a4:	1afffff7 	bne	3f18488 <dirdelim+0x1c>
	return -1;
 3f184a8:	e3e00000 	mvn	r0, #0	; 0x0
}
 3f184ac:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f184b0 <compare_sign>:
 3f184b0:	e1a0c00d 	mov	r12, r13
 3f184b4:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f184b8:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * Match volume_info fs_type strings.
 * Return 0 on match, -1 otherwise.
 */
static int compare_sign(char *str1, char *str2)
{
	char *end = str1+SIGNLEN;
 3f184bc:	e280c008 	add	r12, r0, #8	; 0x8

	while (str1 != end) {
 3f184c0:	e150000c 	cmp	r0, r12
 3f184c4:	0a000008 	beq	3f184ec <compare_sign+0x3c>
		if (*str1 != *str2) {
 3f184c8:	e5d02000 	ldrb	r2, [r0]
 3f184cc:	e5d13000 	ldrb	r3, [r1]
 3f184d0:	e1520003 	cmp	r2, r3
			return -1;
 3f184d4:	13e00000 	mvnne	r0, #0	; 0x0
 3f184d8:	191ba800 	ldmnedb	r11, {r11, r13, r15}
		}
		str1++;
 3f184dc:	e2800001 	add	r0, r0, #1	; 0x1
		str2++;
 3f184e0:	e2811001 	add	r1, r1, #1	; 0x1
	}
 3f184e4:	e150000c 	cmp	r0, r12
 3f184e8:	1afffff6 	bne	3f184c8 <compare_sign+0x18>

	return 0;
 3f184ec:	e3a00000 	mov	r0, #0	; 0x0
}
 3f184f0:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f184f4 <get_name>:
 3f184f4:	e1a0c00d 	mov	r12, r13
 3f184f8:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f184fc:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * Extract zero terminated short name from a directory entry.
 */
static void get_name (dir_entry *dirent, char *s_name)
{
 3f18500:	e1a06000 	mov	r6, r0
 3f18504:	e1a05001 	mov	r5, r1
	char *ptr;

	memcpy (s_name, dirent->name, 8);
 3f18508:	e1a00005 	mov	r0, r5
 3f1850c:	e1a01006 	mov	r1, r6
 3f18510:	e3a02008 	mov	r2, #8	; 0x8
 3f18514:	ebffdc1b 	bl	3f0f588 <memcpy>
	s_name[8] = '\0';
	ptr = s_name;
 3f18518:	e1a04005 	mov	r4, r5
	while (*ptr && *ptr != ' ')
 3f1851c:	e5d52000 	ldrb	r2, [r5]
 3f18520:	e3a03000 	mov	r3, #0	; 0x0
 3f18524:	e5c53008 	strb	r3, [r5, #8]
 3f18528:	e1520003 	cmp	r2, r3
 3f1852c:	13520020 	cmpne	r2, #32	; 0x20
 3f18530:	0a000003 	beq	3f18544 <get_name+0x50>
		ptr++;
 3f18534:	e5f43001 	ldrb	r3, [r4, #1]!
 3f18538:	e3530000 	cmp	r3, #0	; 0x0
 3f1853c:	13530020 	cmpne	r3, #32	; 0x20
 3f18540:	1afffffb 	bne	3f18534 <get_name+0x40>
	if (dirent->ext[0] && dirent->ext[0] != ' ') {
 3f18544:	e5d63008 	ldrb	r3, [r6, #8]
 3f18548:	e3530000 	cmp	r3, #0	; 0x0
 3f1854c:	13530020 	cmpne	r3, #32	; 0x20
 3f18550:	0a00000f 	beq	3f18594 <get_name+0xa0>
		*ptr = '.';
		ptr++;
		memcpy (ptr, dirent->ext, 3);
 3f18554:	e2861008 	add	r1, r6, #8	; 0x8
 3f18558:	e3a0302e 	mov	r3, #46	; 0x2e
 3f1855c:	e4c43001 	strb	r3, [r4], #1
 3f18560:	e3a02003 	mov	r2, #3	; 0x3
 3f18564:	e1a00004 	mov	r0, r4
 3f18568:	ebffdc06 	bl	3f0f588 <memcpy>
		ptr[3] = '\0';
		while (*ptr && *ptr != ' ')
 3f1856c:	e5d42000 	ldrb	r2, [r4]
 3f18570:	e3a03000 	mov	r3, #0	; 0x0
 3f18574:	e5c43003 	strb	r3, [r4, #3]
 3f18578:	e1520003 	cmp	r2, r3
 3f1857c:	13520020 	cmpne	r2, #32	; 0x20
 3f18580:	0a000003 	beq	3f18594 <get_name+0xa0>
			ptr++;
 3f18584:	e5f43001 	ldrb	r3, [r4, #1]!
 3f18588:	e3530000 	cmp	r3, #0	; 0x0
 3f1858c:	13530020 	cmpne	r3, #32	; 0x20
 3f18590:	1afffffb 	bne	3f18584 <get_name+0x90>
	}
	*ptr = '\0';
 3f18594:	e3a02000 	mov	r2, #0	; 0x0
 3f18598:	e5c42000 	strb	r2, [r4]
	if (*s_name == DELETED_FLAG)
 3f1859c:	e5d53000 	ldrb	r3, [r5]
 3f185a0:	e35300e5 	cmp	r3, #229	; 0xe5
		*s_name = '\0';
 3f185a4:	05c52000 	streqb	r2, [r5]
 3f185a8:	0a000002 	beq	3f185b8 <get_name+0xc4>
	else if (*s_name == aRING)
 3f185ac:	e3530005 	cmp	r3, #5	; 0x5
		*s_name = '';
 3f185b0:	03a030e5 	moveq	r3, #229	; 0xe5
 3f185b4:	05c53000 	streqb	r3, [r5]
	downcase (s_name);
 3f185b8:	e1a00005 	mov	r0, r5
 3f185bc:	ebffff36 	bl	3f1829c <downcase>
}
 3f185c0:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f185c4 <get_fatent>:
 3f185c4:	e1a0c00d 	mov	r12, r13
 3f185c8:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f185cc:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * Get the entry at index 'entry' in a FAT (12/16/32) table.
 * On failure 0x00 is returned.
 */
static __u32 get_fatent(fsdata *mydata, __u32 entry)
{
 3f185d0:	e1a06000 	mov	r6, r0
	__u32 bufnum;
	__u32 offset;
	__u32 ret = 0x00;
	
	switch (mydata->fatsize) 
 3f185d4:	e5963000 	ldr	r3, [r6]
 3f185d8:	e3a07000 	mov	r7, #0	; 0x0
 3f185dc:	e3530010 	cmp	r3, #16	; 0x10
 3f185e0:	0a00000b 	beq	3f18614 <get_fatent+0x50>
 3f185e4:	ca000002 	bgt	3f185f4 <get_fatent+0x30>
 3f185e8:	e353000c 	cmp	r3, #12	; 0xc
 3f185ec:	0a00000d 	beq	3f18628 <get_fatent+0x64>
 3f185f0:	ea00001f 	b	3f18674 <get_fatent+0xb0>
 3f185f4:	e3530020 	cmp	r3, #32	; 0x20
 3f185f8:	1a00001d 	bne	3f18674 <get_fatent+0xb0>
	{
		case 32:
			bufnum = entry / FAT32BUFSIZE;
 3f185fc:	e59f3178 	ldr	r3, [pc, #178]	; 3f1877c <get_fatent+0x1b8>
 3f18600:	e0832391 	umull	r2, r3, r1, r3
 3f18604:	e1a044a3 	mov	r4, r3, lsr #9
			offset = entry - bufnum * FAT32BUFSIZE;
 3f18608:	e0843084 	add	r3, r4, r4, lsl #1
 3f1860c:	e0415403 	sub	r5, r1, r3, lsl #8
			break;
 3f18610:	ea000009 	b	3f1863c <get_fatent+0x78>
		case 16:
			bufnum = entry / FAT16BUFSIZE;
 3f18614:	e59f3160 	ldr	r3, [pc, #160]	; 3f1877c <get_fatent+0x1b8>
 3f18618:	e0832391 	umull	r2, r3, r1, r3
 3f1861c:	e1a04523 	mov	r4, r3, lsr #10
			offset = entry - bufnum * FAT16BUFSIZE;
 3f18620:	e0843084 	add	r3, r4, r4, lsl #1
			break;
 3f18624:	ea000003 	b	3f18638 <get_fatent+0x74>
		case 12:
			bufnum = entry / FAT12BUFSIZE;
 3f18628:	e59f3150 	ldr	r3, [pc, #150]	; 3f18780 <get_fatent+0x1bc>
 3f1862c:	e0832391 	umull	r2, r3, r1, r3
 3f18630:	e1a04523 	mov	r4, r3, lsr #10
			offset = entry - bufnum * FAT12BUFSIZE;
 3f18634:	e0843184 	add	r3, r4, r4, lsl #3
 3f18638:	e0415483 	sub	r5, r1, r3, lsl #9
			break;
	
		default:
			/* Unsupported FAT size */
			return ret;
	}

	/* Read a new block of FAT entries into the cache. */
	if(bufnum != mydata->fatbufnum) 
 3f1863c:	e5963c10 	ldr	r3, [r6, #3088]
 3f18640:	e1540003 	cmp	r4, r3
 3f18644:	0a00000d 	beq	3f18680 <get_fatent+0xbc>
	{
		int getsize = FATBUFSIZE/FS_BLOCK_SIZE;
		__u8 *bufptr = mydata->fatbuf;
		__u32 fatlength = mydata->fatlength;
		__u32 startblock = bufnum * FATBUFBLOCKS;
 3f18648:	e0840084 	add	r0, r4, r4, lsl #1

		fatlength *= SECTOR_SIZE;	/* We want it in bytes now */
		startblock += mydata->fat_sect;	/* Offset from start of disk */
 3f1864c:	e1d630b6 	ldrh	r3, [r6, #6]

		if (getsize > fatlength) getsize = fatlength;
		if (disk_read(startblock, getsize, bufptr) < 0) 
 3f18650:	e286200e 	add	r2, r6, #14	; 0xe
 3f18654:	e1d610b4 	ldrh	r1, [r6, #4]
 3f18658:	e0830080 	add	r0, r3, r0, lsl #1
 3f1865c:	e1a01481 	mov	r1, r1, lsl #9
 3f18660:	e3510005 	cmp	r1, #5	; 0x5
 3f18664:	83a01006 	movhi	r1, #6	; 0x6
 3f18668:	ebffff19 	bl	3f182d4 <disk_read>
 3f1866c:	e3500000 	cmp	r0, #0	; 0x0
 3f18670:	aa000001 	bge	3f1867c <get_fatent+0xb8>
		{
			FAT_DPRINT("Error reading FAT blocks\n");
			return ret;
 3f18674:	e3a00000 	mov	r0, #0	; 0x0
 3f18678:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
		}
		mydata->fatbufnum = bufnum;
 3f1867c:	e5864c10 	str	r4, [r6, #3088]
	}

	/* Get the actual entry from the table */
	switch (mydata->fatsize) 
 3f18680:	e5963000 	ldr	r3, [r6]
 3f18684:	e3530010 	cmp	r3, #16	; 0x10
 3f18688:	0a000013 	beq	3f186dc <get_fatent+0x118>
 3f1868c:	ca000002 	bgt	3f1869c <get_fatent+0xd8>
 3f18690:	e353000c 	cmp	r3, #12	; 0xc
 3f18694:	0a000017 	beq	3f186f8 <get_fatent+0x134>
 3f18698:	ea000035 	b	3f18774 <get_fatent+0x1b0>
 3f1869c:	e3530020 	cmp	r3, #32	; 0x20
 3f186a0:	1a000033 	bne	3f18774 <get_fatent+0x1b0>
	{
		case 32:
		/*
			printf("###HERE\n");
			if(!mydata)	printf("mydata == NULL\n");
			if(!mydata->fatbuf)	printf("mydata->fatbuf == NULL\n");
			
			{
				int i=0;
				printf("\n%04X ", i);
				for(i=0; i<FATBUFSIZE;) 
				{
					printf("%02x ", (mydata->fatbuf)[i++]);
					if(i%16 == 0)
					{
						printf("\n%04X ", i);
					}
				}
			}
			printf("FATBUFSIZE %x\n", FATBUFSIZE);
			//printf("((__u32*)mydata->fatbuf)[offset] %x\n", ((__u32*)mydata->fatbuf)[offset]);

/*
			printf("!!!!!!offset %x %x, %x, %x, %x\n", 
				offset,
				mydata->fatbuf[(offset*4)+0],
				mydata->fatbuf[(offset*4)+1],
				mydata->fatbuf[(offset*4)+2],
				mydata->fatbuf[(offset*4)+3]);
*/
//			ret = FAT2CPU32(((__u32*)mydata->fatbuf)[offset]);

			ret = FAT2CPU32(
 3f186a4:	e1a00105 	mov	r0, r5, lsl #2
 3f186a8:	e286100e 	add	r1, r6, #14	; 0xe
 3f186ac:	e2803002 	add	r3, r0, #2	; 0x2
 3f186b0:	e7d13003 	ldrb	r3, [r1, r3]
 3f186b4:	e2802003 	add	r2, r0, #3	; 0x3
 3f186b8:	e7d1c002 	ldrb	r12, [r1, r2]
 3f186bc:	e2802001 	add	r2, r0, #1	; 0x1
 3f186c0:	e7d1e002 	ldrb	r14, [r1, r2]
 3f186c4:	e7d12000 	ldrb	r2, [r1, r0]
 3f186c8:	e1a03803 	mov	r3, r3, lsl #16
 3f186cc:	e1833c0c 	orr	r3, r3, r12, lsl #24
 3f186d0:	e183340e 	orr	r3, r3, r14, lsl #8
 3f186d4:	e1837002 	orr	r7, r3, r2
				(((__u32)(mydata->fatbuf[(offset*4)+3]) << 24) & 0xFF000000) |
				(((__u32)(mydata->fatbuf[(offset*4)+2]) << 16) & 0x00FF0000) |
				(((__u32)(mydata->fatbuf[(offset*4)+1]) <<  8) & 0x0000FF00) |
				(((__u32)(mydata->fatbuf[(offset*4)+0]) <<  0) & 0x000000FF) );
			break;
 3f186d8:	ea000025 	b	3f18774 <get_fatent+0x1b0>
		case 16:
			//ret = FAT2CPU16(((__u16*)mydata->fatbuf)[offset]);
			ret = FAT2CPU32(
 3f186dc:	e1a01105 	mov	r1, r5, lsl #2
 3f186e0:	e2812001 	add	r2, r1, #1	; 0x1
 3f186e4:	e286300e 	add	r3, r6, #14	; 0xe
 3f186e8:	e7d32002 	ldrb	r2, [r3, r2]
 3f186ec:	e7d33001 	ldrb	r3, [r3, r1]
 3f186f0:	e1837402 	orr	r7, r3, r2, lsl #8
				(((__u16)(mydata->fatbuf[(offset*4)+1]) <<  8) & 0xFF00) |
				(((__u16)(mydata->fatbuf[(offset*4)+0]) <<  0) & 0x00FF) );
			break;
 3f186f4:	ea00001e 	b	3f18774 <get_fatent+0x1b0>
		case 12: 
		{
			__u32 off16 = (offset*3)/4;
 3f186f8:	e0853085 	add	r3, r5, r5, lsl #1
 3f186fc:	e1a02123 	mov	r2, r3, lsr #2
			__u16 val1, val2;
	
			switch (offset & 0x3) 
 3f18700:	e2053003 	and	r3, r5, #3	; 0x3
 3f18704:	e3530003 	cmp	r3, #3	; 0x3
 3f18708:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f1870c:	ea000018 	b	3f18774 <get_fatent+0x1b0>
 3f18710:	03f18720 	mvneqs	r8, #8388608	; 0x800000
 3f18714:	03f18734 	mvneqs	r8, #13631488	; 0xd00000
 3f18718:	03f1874c 	mvneqs	r8, #19922944	; 0x1300000
 3f1871c:	03f18768 	mvneqs	r8, #27262976	; 0x1a00000
			{
				case 0:
					ret = FAT2CPU16(((__u16*)mydata->fatbuf)[off16]);
 3f18720:	e0863082 	add	r3, r6, r2, lsl #1
 3f18724:	e1d370be 	ldrh	r7, [r3, #14]
					ret &= 0xfff;
 3f18728:	e1a07a07 	mov	r7, r7, lsl #20
 3f1872c:	e1a07a27 	mov	r7, r7, lsr #20
					break;
 3f18730:	ea00000f 	b	3f18774 <get_fatent+0x1b0>
				case 1:
					val1 = FAT2CPU16(((__u16*)mydata->fatbuf)[off16]);
 3f18734:	e0863082 	add	r3, r6, r2, lsl #1
 3f18738:	e1d310be 	ldrh	r1, [r3, #14]
					val1 &= 0xf000;
					val2 = FAT2CPU16(((__u16*)mydata->fatbuf)[off16+1]);
					val2 &= 0x00ff;
 3f1873c:	e5d30010 	ldrb	r0, [r3, #16]
					ret = (val2 << 4) | (val1 >> 12);
 3f18740:	e1a03621 	mov	r3, r1, lsr #12
 3f18744:	e1837200 	orr	r7, r3, r0, lsl #4
					break;
 3f18748:	ea000009 	b	3f18774 <get_fatent+0x1b0>
				case 2:
					val1 = FAT2CPU16(((__u16*)mydata->fatbuf)[off16]);
 3f1874c:	e0863082 	add	r3, r6, r2, lsl #1
					val1 &= 0xff00;
					val2 = FAT2CPU16(((__u16*)mydata->fatbuf)[off16+1]);
 3f18750:	e1d301b0 	ldrh	r0, [r3, #16]
 3f18754:	e1d310be 	ldrh	r1, [r3, #14]
					val2 &= 0x000f;
 3f18758:	e200000f 	and	r0, r0, #15	; 0xf
					ret = (val2 << 8) | (val1 >> 8);
 3f1875c:	e1a03421 	mov	r3, r1, lsr #8
 3f18760:	e1837400 	orr	r7, r3, r0, lsl #8
					break;
 3f18764:	ea000002 	b	3f18774 <get_fatent+0x1b0>
				case 3:
					ret = FAT2CPU16(((__u16*)mydata->fatbuf)[off16]);;
 3f18768:	e0863082 	add	r3, r6, r2, lsl #1
 3f1876c:	e1d370be 	ldrh	r7, [r3, #14]
					ret = (ret & 0xfff0) >> 4;
 3f18770:	e1a07227 	mov	r7, r7, lsr #4
					break;
				default:
					break;
			}
		}
		break;
	}
	FAT_DPRINT("ret: %d, offset: %d\n", ret, offset);

	return ret;
 3f18774:	e1a00007 	mov	r0, r7
}
 3f18778:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}
 3f1877c:	aaaaaaab 	bge	29c3230 <*ABS*+0x29c3230>
 3f18780:	38e38e39 	stmccia	r3!, {r0, r3, r4, r5, r9, r10, r11, r15}^

03f18784 <get_cluster>:
 3f18784:	e1a0c00d 	mov	r12, r13
 3f18788:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f1878c:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * Read at most 'size' bytes from the specified cluster into 'buffer'.
 * Return 0 on success, -1 otherwise.
 */
static int get_cluster(fsdata *mydata, __u32 clustnum, __u8 *buffer, unsigned long size)
{
 3f18790:	e1a07002 	mov	r7, r2
 3f18794:	e1a04003 	mov	r4, r3
	int idx = 0;
	__u32 startsect;

	if(clustnum > 0) 
 3f18798:	e3510000 	cmp	r1, #0	; 0x0
 3f1879c:	e24ddc02 	sub	r13, r13, #512	; 0x200
	{
		startsect = mydata->data_begin + clustnum * mydata->clust_size;
 3f187a0:	11d020bc 	ldrneh	r2, [r0, #12]
 3f187a4:	11d030ba 	ldrneh	r3, [r0, #10]
 3f187a8:	10252193 	mlane	r5, r3, r1, r2
	} 
	else 
	{
		startsect = mydata->rootdir_sect;
 3f187ac:	01d050b8 	ldreqh	r5, [r0, #8]
	}

	
	FAT_DPRINT("gc - clustnum: %d, startsect: %d\n", clustnum, startsect);
	if(disk_read(startsect, size/FS_BLOCK_SIZE , buffer) < 0)
 3f187b0:	e1a00005 	mov	r0, r5
 3f187b4:	e1a064a4 	mov	r6, r4, lsr #9
 3f187b8:	e1a01006 	mov	r1, r6
 3f187bc:	e1a02007 	mov	r2, r7
 3f187c0:	ebfffec3 	bl	3f182d4 <disk_read>
 3f187c4:	e3500000 	cmp	r0, #0	; 0x0
 3f187c8:	ba00000a 	blt	3f187f8 <get_cluster+0x74>
	{
		//FAT_DPRINT
		printf("Error reading data\n");
		return -1;
	}
	
	if(size % FS_BLOCK_SIZE) 
 3f187cc:	e1a04b84 	mov	r4, r4, lsl #23
 3f187d0:	e1a04ba4 	mov	r4, r4, lsr #23
 3f187d4:	e3540000 	cmp	r4, #0	; 0x0
 3f187d8:	0a00000f 	beq	3f1881c <get_cluster+0x98>
	{
		__u8 tmpbuf[FS_BLOCK_SIZE];
		idx = size/FS_BLOCK_SIZE;
		if(disk_read(startsect + idx, 1, tmpbuf) < 0) 
 3f187dc:	e0850006 	add	r0, r5, r6
 3f187e0:	e3a01001 	mov	r1, #1	; 0x1
 3f187e4:	e24b5f87 	sub	r5, r11, #540	; 0x21c
 3f187e8:	e1a02005 	mov	r2, r5
 3f187ec:	ebfffeb8 	bl	3f182d4 <disk_read>
 3f187f0:	e3500000 	cmp	r0, #0	; 0x0
 3f187f4:	aa000004 	bge	3f1880c <get_cluster+0x88>
		{
			//FAT_DPRINT
			printf("Error reading data\n");
 3f187f8:	e59f0008 	ldr	r0, [pc, #8]	; 3f18808 <get_cluster+0x84>
 3f187fc:	ebffd010 	bl	3f0c844 <printf>
			return -1;
 3f18800:	e3e00000 	mvn	r0, #0	; 0x0
 3f18804:	ea000005 	b	3f18820 <get_cluster+0x9c>
 3f18808:	03f1ff4c 	mvneqs	r15, #304	; 0x130
		}
		buffer += idx*FS_BLOCK_SIZE;

		memcpy(buffer, tmpbuf, size % FS_BLOCK_SIZE);
 3f1880c:	e0870486 	add	r0, r7, r6, lsl #9
 3f18810:	e1a01005 	mov	r1, r5
 3f18814:	e1a02004 	mov	r2, r4
 3f18818:	ebffdb5a 	bl	3f0f588 <memcpy>
		return 0;
	}

	return 0;
 3f1881c:	e3a00000 	mov	r0, #0	; 0x0
}
 3f18820:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}

03f18824 <get_contents>:
 3f18824:	e1a0c00d 	mov	r12, r13
 3f18828:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f1882c:	e24dd00c 	sub	r13, r13, #12	; 0xc
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * Read at most 'maxsize' bytes from the file associated with 'dentptr'
 * into 'buffer'.
 * Return the number of bytes read or -1 on fatal errors.
 */
 /*
 static long get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer, unsigned long maxsize)
{
	unsigned long filesize = FAT2CPU32(dentptr->size), gotsize = 0;
	unsigned int bytesperclust = mydata->clust_size * SECTOR_SIZE;
	__u32 curclust = START(dentptr);
	__u32 endclust, newclust;
	unsigned long actsize;

	printf("READ START\n");

	FAT_DPRINT("Filesize: %ld bytes\n", filesize);

	if (maxsize > 0 && filesize > maxsize) filesize = maxsize;

	FAT_DPRINT("Reading: %ld bytes\n", filesize);

	actsize=bytesperclust;
	//FAT_DPRINT("bytesperclust = %d\n",bytesperclust);
	endclust=curclust;
	do 
	{
		// search for consecutive clusters 
		while(actsize < filesize) 
		{
			newclust = get_fatent(mydata, endclust);
			if((newclust -1)!=endclust)
				goto getit;
			if (newclust <= 0x0001 || newclust >= 0xfff0) 
			{
				FAT_DPRINT("curclust: 0x%x\n", newclust);
				FAT_DPRINT("Invalid FAT entry\n");
				return gotsize;
			}
			endclust=newclust;
			actsize+= bytesperclust;
		}
		// actsize >= file size 
		actsize -= bytesperclust;
		// get remaining clusters 
		if(actsize)
		{
		if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
			FAT_ERROR("Error reading cluster\n");
			return -1;
		}
		}
		// get remaining bytes 
		gotsize += (int)actsize;
		filesize -= actsize;
		buffer += actsize;
		actsize= filesize;
		if (get_cluster(mydata, endclust, buffer, (int)actsize) != 0) {
			FAT_ERROR("Error reading cluster\n");
			return -1;
		}
		gotsize+=actsize;
		return gotsize;
getit:
		if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) {
			FAT_ERROR("Error reading cluster\n");
			return -1;
		}
		gotsize += (int)actsize;
		filesize -= actsize;
		buffer += actsize;
		curclust = get_fatent(mydata, endclust);
		if (curclust <= 0x0001 || curclust >= 0xfff0) {
			FAT_DPRINT("curclust: 0x%x\n", curclust);
			FAT_ERROR("Invalid FAT entry\n");
			return gotsize;
		}
		actsize=bytesperclust;
		endclust=curclust;
	} while (1);

	printf("READ END\n");
}
*/
extern ulong g_filesize;

static long get_contents(fsdata *mydata, dir_entry *dentptr, __u8 *buffer, unsigned long maxsize)
{
	unsigned long 	filesize = FAT2CPU32(dentptr->size), gotsize = 0;
 3f18830:	e591701c 	ldr	r7, [r1, #28]
 3f18834:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f18838:	e50b0028 	str	r0, [r11, -#40]
 3f1883c:	e1a09002 	mov	r9, r2
	unsigned int 	bytesperclust = mydata->clust_size * SECTOR_SIZE;
	__u32 			curclust = START(dentptr);
 3f18840:	e5902000 	ldr	r2, [r0]
 3f18844:	e3a00000 	mov	r0, #0	; 0x0
 3f18848:	e50b002c 	str	r0, [r11, -#44]
 3f1884c:	e51b0028 	ldr	r0, [r11, -#40]
 3f18850:	e3520020 	cmp	r2, #32	; 0x20
 3f18854:	e1d020ba 	ldrh	r2, [r0, #10]
 3f18858:	e1a06003 	mov	r6, r3
 3f1885c:	e1d151ba 	ldrh	r5, [r1, #26]
 3f18860:	e1a02482 	mov	r2, r2, lsl #9
 3f18864:	e50b2030 	str	r2, [r11, -#48]
 3f18868:	01d131b4 	ldreqh	r3, [r1, #20]
 3f1886c:	01855803 	orreq	r5, r5, r3, lsl #16
	__u32 			endclust; 
	__u32 			newclust;
	unsigned long 	actsize;

	printf("READ START %d\n", filesize);
 3f18870:	e1a01007 	mov	r1, r7
 3f18874:	e59f01b4 	ldr	r0, [pc, #1b4]	; 3f18a30 <get_contents+0x20c>
	g_filesize = filesize;
	
	if (maxsize > 0 && filesize > maxsize) filesize = maxsize;

	actsize  = bytesperclust;
	endclust = curclust;
 3f18878:	e1a0a005 	mov	r10, r5
 3f1887c:	e51b4030 	ldr	r4, [r11, -#48]
 3f18880:	ebffcfef 	bl	3f0c844 <printf>
 3f18884:	e59f31a8 	ldr	r3, [pc, #1a8]	; 3f18a34 <get_contents+0x210>
 3f18888:	e3560000 	cmp	r6, #0	; 0x0
 3f1888c:	11570006 	cmpne	r7, r6
 3f18890:	e5837000 	str	r7, [r3]
 3f18894:	81a07006 	movhi	r7, r6
	
	// 켱 ε ´.
	//   ϸ 0xFFFFFFFF(-1) ų 10000(128) ´.
	// ֳ ϸ ѹ SD  ü ִ ͷ 20000 ְ ̱⶧ 
	// ϰ 10000  ´.
	do
	{
		// ⼭  ũ ̳ ü  뷮 10000     üũ
		while(actsize<filesize && actsize<0x100000) 
 3f18898:	e51b2030 	ldr	r2, [r11, -#48]
 3f1889c:	e1520007 	cmp	r2, r7
 3f188a0:	33520601 	cmpcc	r2, #1048576	; 0x100000
 3f188a4:	2a00000f 	bcs	3f188e8 <get_contents+0xc4>
		{
			newclust = get_fatent(mydata, endclust);
 3f188a8:	e51b0028 	ldr	r0, [r11, -#40]
 3f188ac:	e1a0100a 	mov	r1, r10
 3f188b0:	ebffff43 	bl	3f185c4 <get_fatent>
 3f188b4:	e1a01000 	mov	r1, r0
			if((newclust -1) != endclust)
 3f188b8:	e2413001 	sub	r3, r1, #1	; 0x1
 3f188bc:	e153000a 	cmp	r3, r10
 3f188c0:	1a00003a 	bne	3f189b0 <get_contents+0x18c>
				goto getit;
			if (newclust <= 0x0001 || newclust >= 0xfffffff0) 
 3f188c4:	e2413002 	sub	r3, r1, #2	; 0x2
 3f188c8:	e3730013 	cmn	r3, #19	; 0x13
 3f188cc:	8a000053 	bhi	3f18a20 <get_contents+0x1fc>
			{
				//FAT_DPRINT
				printf("curclust: 0x%x\n", newclust);
				//FAT_DPRINT
				printf("### Invalid FAT entry\n");
				return gotsize;
			}
			endclust = newclust;
			actsize += bytesperclust;
 3f188d0:	e51b3030 	ldr	r3, [r11, -#48]
 3f188d4:	e1a0a001 	mov	r10, r1
 3f188d8:	e0844003 	add	r4, r4, r3
		}
 3f188dc:	e1540007 	cmp	r4, r7
 3f188e0:	33540601 	cmpcc	r4, #1048576	; 0x100000
 3f188e4:	3affffef 	bcc	3f188a8 <get_contents+0x84>
		
		//   0x10000 Ŭ ̹Ƿ  о .
		//printf("actsize %x\n", actsize);
		if(actsize >= 0x100000)
 3f188e8:	e3540601 	cmp	r4, #1048576	; 0x100000
 3f188ec:	3a000017 	bcc	3f18950 <get_contents+0x12c>
		{
			if(get_cluster(mydata, curclust, buffer, (int)actsize) != 0) 
 3f188f0:	e1a01005 	mov	r1, r5
 3f188f4:	e1a02009 	mov	r2, r9
 3f188f8:	e51b0028 	ldr	r0, [r11, -#40]
 3f188fc:	e1a03004 	mov	r3, r4
 3f18900:	ebffff9f 	bl	3f18784 <get_cluster>
 3f18904:	e3500000 	cmp	r0, #0	; 0x0
 3f18908:	1a000031 	bne	3f189d4 <get_contents+0x1b0>
			{
				//FAT_ERROR
				printf("Error reading cluster\n");
				return -1;
			}

			gotsize  += (int)actsize;
 3f1890c:	e51b002c 	ldr	r0, [r11, -#44]
			filesize -= actsize;
 3f18910:	e0647007 	rsb	r7, r4, r7
 3f18914:	e0800004 	add	r0, r0, r4
 3f18918:	e50b002c 	str	r0, [r11, -#44]
			buffer   += actsize;
 3f1891c:	e0899004 	add	r9, r9, r4
			// ׸  ִ ŬƮ ̵Ѵ.
			curclust = get_fatent(mydata, endclust);
 3f18920:	e51b0028 	ldr	r0, [r11, -#40]
 3f18924:	e1a0100a 	mov	r1, r10
 3f18928:	ebffff25 	bl	3f185c4 <get_fatent>
 3f1892c:	e1a05000 	mov	r5, r0
			if(curclust <= 0x0001 || curclust >= 0xfffffff0) 
 3f18930:	e2453002 	sub	r3, r5, #2	; 0x2
 3f18934:	e3730013 	cmn	r3, #19	; 0x13
 3f18938:	9a000035 	bls	3f18a14 <get_contents+0x1f0>
			{
				//FAT_DPRINT
				printf("curclust: 0x%x\n", curclust);
 3f1893c:	e59f00f4 	ldr	r0, [pc, #f4]	; 3f18a38 <get_contents+0x214>
 3f18940:	e1a01005 	mov	r1, r5
 3f18944:	ebffcfbe 	bl	3f0c844 <printf>
				//FAT_ERROR
				printf("!!! Invalid FAT entry\n");
 3f18948:	e59f00ec 	ldr	r0, [pc, #ec]	; 3f18a3c <get_contents+0x218>
				return gotsize;
 3f1894c:	ea000042 	b	3f18a5c <get_contents+0x238>
			}

			actsize  = bytesperclust;
			endclust = curclust;
			
			continue;
		}
		else
		{
			// actsize >= file size
			actsize -= bytesperclust;
 3f18950:	e51b2030 	ldr	r2, [r11, -#48]
			// get remaining clusters
			if(get_cluster(mydata, curclust, buffer, (int)actsize) != 0)
 3f18954:	e1a01005 	mov	r1, r5
 3f18958:	e51b0028 	ldr	r0, [r11, -#40]
 3f1895c:	e0624004 	rsb	r4, r2, r4
 3f18960:	e1a02009 	mov	r2, r9
 3f18964:	e1a03004 	mov	r3, r4
 3f18968:	ebffff85 	bl	3f18784 <get_cluster>
 3f1896c:	e3500000 	cmp	r0, #0	; 0x0
 3f18970:	1a000017 	bne	3f189d4 <get_contents+0x1b0>
			{
				//FAT_ERROR
				printf("Error reading cluster\n");
				return -1;
			}
			// get remaining bytes 
			gotsize  += (int)actsize;
			filesize -= actsize;
			buffer 	 += actsize;
 3f18974:	e0899004 	add	r9, r9, r4
			actsize  = filesize;
	
			if(get_cluster(mydata, endclust, buffer, (int)actsize) != 0) 
 3f18978:	e1a0100a 	mov	r1, r10
 3f1897c:	e51b302c 	ldr	r3, [r11, -#44]
 3f18980:	e1a02009 	mov	r2, r9
 3f18984:	e51b0028 	ldr	r0, [r11, -#40]
 3f18988:	e0833004 	add	r3, r3, r4
 3f1898c:	e0644007 	rsb	r4, r4, r7
 3f18990:	e50b302c 	str	r3, [r11, -#44]
 3f18994:	e1a03004 	mov	r3, r4
 3f18998:	ebffff79 	bl	3f18784 <get_cluster>
 3f1899c:	e3500000 	cmp	r0, #0	; 0x0
 3f189a0:	1a00000b 	bne	3f189d4 <get_contents+0x1b0>
			{
				//FAT_ERROR
				printf("Error reading cluster\n");
				return -1;
			}
			gotsize += actsize;
			
			//printf("!!! gotsize: %d , filesize: %d, actsize %d \n", gotsize, filesize, actsize);
			//printf("gotsize %x\n", gotsize);
			
			return gotsize;
 3f189a4:	e51b202c 	ldr	r2, [r11, -#44]
 3f189a8:	e0820004 	add	r0, r2, r4
 3f189ac:	ea00002c 	b	3f18a64 <get_contents+0x240>
		}
		
		// ࿡ ŬƮ   Ʒ ƾ ź.
getit:
	 	//    о .
		printf("getit:\n");
 3f189b0:	e59f0088 	ldr	r0, [pc, #88]	; 3f18a40 <get_contents+0x21c>
 3f189b4:	ebffcfa2 	bl	3f0c844 <printf>
		if (get_cluster(mydata, curclust, buffer, (int)actsize) != 0) 
 3f189b8:	e1a01005 	mov	r1, r5
 3f189bc:	e1a02009 	mov	r2, r9
 3f189c0:	e51b0028 	ldr	r0, [r11, -#40]
 3f189c4:	e1a03004 	mov	r3, r4
 3f189c8:	ebffff6d 	bl	3f18784 <get_cluster>
 3f189cc:	e3500000 	cmp	r0, #0	; 0x0
 3f189d0:	0a000003 	beq	3f189e4 <get_contents+0x1c0>
		{
			//FAT_ERROR
			printf("Error reading cluster\n");
 3f189d4:	e59f0068 	ldr	r0, [pc, #68]	; 3f18a44 <get_contents+0x220>
 3f189d8:	ebffcf99 	bl	3f0c844 <printf>
			return -1;
 3f189dc:	e3e00000 	mvn	r0, #0	; 0x0
 3f189e0:	ea00001f 	b	3f18a64 <get_contents+0x240>
		}
		gotsize += (int)actsize;
		filesize -= actsize;
 3f189e4:	e0647007 	rsb	r7, r4, r7
		buffer += actsize;
 3f189e8:	e0899004 	add	r9, r9, r4
 3f189ec:	e51b302c 	ldr	r3, [r11, -#44]
		// ׸  ִ ŬƮ ̵Ѵ.
		curclust = get_fatent(mydata, endclust);
 3f189f0:	e1a0100a 	mov	r1, r10
 3f189f4:	e51b0028 	ldr	r0, [r11, -#40]
 3f189f8:	e0833004 	add	r3, r3, r4
 3f189fc:	e50b302c 	str	r3, [r11, -#44]
 3f18a00:	ebfffeef 	bl	3f185c4 <get_fatent>
 3f18a04:	e1a05000 	mov	r5, r0
///		if(curclust <= 0x0001 || curclust >= 0xfff0) 
		if(curclust <= 0x0001 || curclust >= 0xfffffff0) 
 3f18a08:	e2453002 	sub	r3, r5, #2	; 0x2
 3f18a0c:	e3730013 	cmn	r3, #19	; 0x13
 3f18a10:	8a00000d 	bhi	3f18a4c <get_contents+0x228>
		{
			//FAT_DPRINT
			printf("curclust: 0x%x\n", curclust);
			//FAT_ERROR
			printf("^^^ Invalid FAT entry\n");
			return gotsize;
		}
		actsize  = bytesperclust;
		endclust = curclust;
 3f18a14:	e1a0a005 	mov	r10, r5
 3f18a18:	e51b4030 	ldr	r4, [r11, -#48]
	}while (1);
 3f18a1c:	eaffff9d 	b	3f18898 <get_contents+0x74>
 3f18a20:	e59f0010 	ldr	r0, [pc, #10]	; 3f18a38 <get_contents+0x214>
 3f18a24:	ebffcf86 	bl	3f0c844 <printf>
 3f18a28:	e59f0018 	ldr	r0, [pc, #18]	; 3f18a48 <get_contents+0x224>
 3f18a2c:	ea00000a 	b	3f18a5c <get_contents+0x238>
 3f18a30:	03f1ff60 	mvneqs	r15, #384	; 0x180
 3f18a34:	03f204d8 	mvneqs	r0, #-671088640	; 0xd8000000
 3f18a38:	03f1ff70 	mvneqs	r15, #448	; 0x1c0
 3f18a3c:	03f1ffb0 	mvneqs	r15, #704	; 0x2c0
 3f18a40:	03f1ffc8 	mvneqs	r15, #800	; 0x320
 3f18a44:	03f1ff98 	mvneqs	r15, #608	; 0x260
 3f18a48:	03f1ff80 	mvneqs	r15, #512	; 0x200
 3f18a4c:	e59f0014 	ldr	r0, [pc, #14]	; 3f18a68 <get_contents+0x244>
 3f18a50:	e1a01005 	mov	r1, r5
 3f18a54:	ebffcf7a 	bl	3f0c844 <printf>
 3f18a58:	e59f000c 	ldr	r0, [pc, #c]	; 3f18a6c <get_contents+0x248>
 3f18a5c:	ebffcf78 	bl	3f0c844 <printf>
 3f18a60:	e51b002c 	ldr	r0, [r11, -#44]
 3f18a64:	ea000001 	b	3f18a70 <get_contents+0x24c>
 3f18a68:	03f1ff70 	mvneqs	r15, #448	; 0x1c0
 3f18a6c:	03f1ffd0 	mvneqs	r15, #832	; 0x340
	
	printf("READ END\n");
}
 3f18a70:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f18a74 <slot2str>:
 3f18a74:	e1a0c00d 	mov	r12, r13
 3f18a78:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f18a7c:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
#ifdef CONFIG_SUPPORT_VFAT
/*
 * Extract the file name information from 'slotptr' into 'l_name',
 * starting at l_name[*idx].
 * Return 1 if terminator (zero byte) is found, 0 otherwise.
 */
static int slot2str(dir_slot *slotptr, char *l_name, int *idx)
{
 3f18a80:	e1a0c002 	mov	r12, r2
	int j;

	for (j = 0; j <= 8; j += 2) {
 3f18a84:	e3a0e000 	mov	r14, #0	; 0x0
		l_name[*idx] = slotptr->name0_4[j];
 3f18a88:	e59c2000 	ldr	r2, [r12]
 3f18a8c:	e2803001 	add	r3, r0, #1	; 0x1
 3f18a90:	e7d3300e 	ldrb	r3, [r3, r14]
 3f18a94:	e7c13002 	strb	r3, [r1, r2]
		if (l_name[*idx] == 0x00) return 1;
 3f18a98:	e59c2000 	ldr	r2, [r12]
 3f18a9c:	e7d13002 	ldrb	r3, [r1, r2]
 3f18aa0:	e3530000 	cmp	r3, #0	; 0x0
 3f18aa4:	1a000001 	bne	3f18ab0 <slot2str+0x3c>
 3f18aa8:	e3a00001 	mov	r0, #1	; 0x1
 3f18aac:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f18ab0:	e28ee002 	add	r14, r14, #2	; 0x2
 3f18ab4:	e35e0008 	cmp	r14, #8	; 0x8
		(*idx)++;
 3f18ab8:	e2823001 	add	r3, r2, #1	; 0x1
 3f18abc:	e58c3000 	str	r3, [r12]
 3f18ac0:	dafffff0 	ble	3f18a88 <slot2str+0x14>
	}
	for (j = 0; j <= 10; j += 2) {
 3f18ac4:	e3a0e000 	mov	r14, #0	; 0x0
		l_name[*idx] = slotptr->name5_10[j];
 3f18ac8:	e59c2000 	ldr	r2, [r12]
 3f18acc:	e280300e 	add	r3, r0, #14	; 0xe
 3f18ad0:	e7d3300e 	ldrb	r3, [r3, r14]
 3f18ad4:	e7c13002 	strb	r3, [r1, r2]
		if (l_name[*idx] == 0x00) return 1;
 3f18ad8:	e59c2000 	ldr	r2, [r12]
 3f18adc:	e7d13002 	ldrb	r3, [r1, r2]
 3f18ae0:	e3530000 	cmp	r3, #0	; 0x0
 3f18ae4:	0affffef 	beq	3f18aa8 <slot2str+0x34>
 3f18ae8:	e28ee002 	add	r14, r14, #2	; 0x2
 3f18aec:	e35e000a 	cmp	r14, #10	; 0xa
		(*idx)++;
 3f18af0:	e2823001 	add	r3, r2, #1	; 0x1
 3f18af4:	e58c3000 	str	r3, [r12]
 3f18af8:	dafffff2 	ble	3f18ac8 <slot2str+0x54>
	}
	for (j = 0; j <= 2; j += 2) {
 3f18afc:	e3a0e000 	mov	r14, #0	; 0x0
		l_name[*idx] = slotptr->name11_12[j];
 3f18b00:	e59c2000 	ldr	r2, [r12]
 3f18b04:	e280301c 	add	r3, r0, #28	; 0x1c
 3f18b08:	e7d3300e 	ldrb	r3, [r3, r14]
 3f18b0c:	e7c13002 	strb	r3, [r1, r2]
		if (l_name[*idx] == 0x00) return 1;
 3f18b10:	e59c2000 	ldr	r2, [r12]
 3f18b14:	e7d13002 	ldrb	r3, [r1, r2]
 3f18b18:	e3530000 	cmp	r3, #0	; 0x0
 3f18b1c:	0affffe1 	beq	3f18aa8 <slot2str+0x34>
 3f18b20:	e28ee002 	add	r14, r14, #2	; 0x2
 3f18b24:	e35e0002 	cmp	r14, #2	; 0x2
		(*idx)++;
 3f18b28:	e2823001 	add	r3, r2, #1	; 0x1
 3f18b2c:	e58c3000 	str	r3, [r12]
 3f18b30:	dafffff2 	ble	3f18b00 <slot2str+0x8c>
	}

	return 0;
 3f18b34:	e3a00000 	mov	r0, #0	; 0x0
}
 3f18b38:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f18b3c <get_vfatname>:
 3f18b3c:	e1a0c00d 	mov	r12, r13
 3f18b40:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f18b44:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * Extract the full long filename starting at 'retdent' (which is really
 * a slot) into 'l_name'. If successful also copy the real directory entry
 * into 'retdent'
 * Return 0 on success, -1 otherwise.
 */
__u8 get_vfatname_block[MAX_CLUSTSIZE];
static int get_vfatname(fsdata *mydata, int curclust, __u8 *cluster, dir_entry *retdent, char *l_name)
{
 3f18b48:	e1a0c001 	mov	r12, r1
	dir_entry 	*realdent;
	dir_slot  	*slotptr = (dir_slot*) retdent;
	__u8	  	*nextclust = cluster + mydata->clust_size * SECTOR_SIZE;
	__u8	   	counter = slotptr->id & 0xf;
	int 		idx = 0;
 3f18b4c:	e3a01000 	mov	r1, #0	; 0x0
 3f18b50:	e24dd004 	sub	r13, r13, #4	; 0x4
 3f18b54:	e50b1028 	str	r1, [r11, -#40]
 3f18b58:	e1a0a003 	mov	r10, r3
 3f18b5c:	e5da1000 	ldrb	r1, [r10]
 3f18b60:	e1a0500a 	mov	r5, r10
 3f18b64:	e59b7004 	ldr	r7, [r11, #4]
 3f18b68:	e1a04000 	mov	r4, r0
 3f18b6c:	e1d430ba 	ldrh	r3, [r4, #10]
 3f18b70:	e201100f 	and	r1, r1, #15	; 0xf
 3f18b74:	e0822483 	add	r2, r2, r3, lsl #9

	while ((__u8*)slotptr < nextclust) 
 3f18b78:	e15a0002 	cmp	r10, r2
	{
		if (counter == 0) break;
 3f18b7c:	ea000007 	b	3f18ba0 <get_vfatname+0x64>
		if ((slotptr->id & 0x0f) != counter) return -1;
 3f18b80:	e5d53000 	ldrb	r3, [r5]
 3f18b84:	e203300f 	and	r3, r3, #15	; 0xf
 3f18b88:	e1530001 	cmp	r3, r1
 3f18b8c:	1a000013 	bne	3f18be0 <get_vfatname+0xa4>
		slotptr++;
 3f18b90:	e2855020 	add	r5, r5, #32	; 0x20
		counter--;
 3f18b94:	e2413001 	sub	r3, r1, #1	; 0x1
 3f18b98:	e20310ff 	and	r1, r3, #255	; 0xff
	}
 3f18b9c:	e1550002 	cmp	r5, r2
 3f18ba0:	2a000001 	bcs	3f18bac <get_vfatname+0x70>
 3f18ba4:	e3510000 	cmp	r1, #0	; 0x0
 3f18ba8:	1afffff4 	bne	3f18b80 <get_vfatname+0x44>

	if ((__u8*)slotptr >= nextclust) 
 3f18bac:	e1550002 	cmp	r5, r2
 3f18bb0:	3a000027 	bcc	3f18c54 <get_vfatname+0x118>
	{
		dir_slot *slotptr2;

		slotptr--;
 3f18bb4:	e2455020 	sub	r5, r5, #32	; 0x20
		curclust = get_fatent(mydata, curclust);
 3f18bb8:	e1a00004 	mov	r0, r4
 3f18bbc:	e1a0100c 	mov	r1, r12
 3f18bc0:	ebfffe7f 	bl	3f185c4 <get_fatent>
 3f18bc4:	e1a0c000 	mov	r12, r0
		if (curclust <= 0x0001 || curclust >= 0xfff0) 
 3f18bc8:	e59f20d0 	ldr	r2, [pc, #d0]	; 3f18ca0 <get_vfatname+0x164>
 3f18bcc:	e24c3002 	sub	r3, r12, #2	; 0x2
 3f18bd0:	e1530002 	cmp	r3, r2
 3f18bd4:	9a000003 	bls	3f18be8 <get_vfatname+0xac>
		{
			FAT_DPRINT("curclust: 0x%x\n", curclust);
			FAT_ERROR("Invalid FAT entry\n");
 3f18bd8:	e59f00c4 	ldr	r0, [pc, #c4]	; 3f18ca4 <get_vfatname+0x168>
 3f18bdc:	ebffcf18 	bl	3f0c844 <printf>
			return -1;
 3f18be0:	e3e00000 	mvn	r0, #0	; 0x0
 3f18be4:	ea00003a 	b	3f18cd4 <get_vfatname+0x198>
		}
		if (get_cluster(mydata, curclust, get_vfatname_block,
 3f18be8:	e1a00004 	mov	r0, r4
 3f18bec:	e59f60b4 	ldr	r6, [pc, #b4]	; 3f18ca8 <get_vfatname+0x16c>
 3f18bf0:	e1a0100c 	mov	r1, r12
 3f18bf4:	e1d430ba 	ldrh	r3, [r4, #10]
 3f18bf8:	e1a02006 	mov	r2, r6
 3f18bfc:	e1a03483 	mov	r3, r3, lsl #9
 3f18c00:	ebfffedf 	bl	3f18784 <get_cluster>
 3f18c04:	e3500000 	cmp	r0, #0	; 0x0
 3f18c08:	1afffff4 	bne	3f18be0 <get_vfatname+0xa4>
				mydata->clust_size * SECTOR_SIZE) != 0) {
			FAT_DPRINT("Error: reading directory block\n");
			return -1;
		}
		slotptr2 = (dir_slot*) get_vfatname_block;
		while (slotptr2->id > 0x01) {
 3f18c0c:	e5d63000 	ldrb	r3, [r6]
 3f18c10:	e1a04006 	mov	r4, r6
 3f18c14:	e3530001 	cmp	r3, #1	; 0x1
 3f18c18:	9a000002 	bls	3f18c28 <get_vfatname+0xec>
			slotptr2++;
		}
 3f18c1c:	e5f43020 	ldrb	r3, [r4, #32]!
 3f18c20:	e3530001 	cmp	r3, #1	; 0x1
 3f18c24:	8afffffc 	bhi	3f18c1c <get_vfatname+0xe0>
		/* Save the real directory entry */
		realdent = (dir_entry*)slotptr2 + 1;
 3f18c28:	e2849020 	add	r9, r4, #32	; 0x20
		while ((__u8*)slotptr2 >= get_vfatname_block) {
 3f18c2c:	e1540006 	cmp	r4, r6
 3f18c30:	3a000008 	bcc	3f18c58 <get_vfatname+0x11c>
			slot2str(slotptr2, l_name, &idx);
 3f18c34:	e1a00004 	mov	r0, r4
 3f18c38:	e1a01007 	mov	r1, r7
 3f18c3c:	e24b2028 	sub	r2, r11, #40	; 0x28
 3f18c40:	ebffff8b 	bl	3f18a74 <slot2str>
			slotptr2--;
 3f18c44:	e2444020 	sub	r4, r4, #32	; 0x20
		}
 3f18c48:	e1540006 	cmp	r4, r6
 3f18c4c:	2afffff8 	bcs	3f18c34 <get_vfatname+0xf8>
	} else {
 3f18c50:	ea000000 	b	3f18c58 <get_vfatname+0x11c>
		/* Save the real directory entry */
		realdent = (dir_entry*)slotptr;
 3f18c54:	e1a09005 	mov	r9, r5
	}

	do {
		slotptr--;
 3f18c58:	e2455020 	sub	r5, r5, #32	; 0x20
		if (slot2str(slotptr, l_name, &idx)) break;
 3f18c5c:	e1a00005 	mov	r0, r5
 3f18c60:	e1a01007 	mov	r1, r7
 3f18c64:	e24b2028 	sub	r2, r11, #40	; 0x28
 3f18c68:	ebffff81 	bl	3f18a74 <slot2str>
 3f18c6c:	e3500000 	cmp	r0, #0	; 0x0
 3f18c70:	1a000002 	bne	3f18c80 <get_vfatname+0x144>
	} while (!(slotptr->id & 0x40));
 3f18c74:	e5d53000 	ldrb	r3, [r5]
 3f18c78:	e3130040 	tst	r3, #64	; 0x40
 3f18c7c:	0afffff5 	beq	3f18c58 <get_vfatname+0x11c>

	l_name[idx] = '\0';
 3f18c80:	e51b3028 	ldr	r3, [r11, -#40]
 3f18c84:	e3a02000 	mov	r2, #0	; 0x0
 3f18c88:	e7c72003 	strb	r2, [r7, r3]
	if (*l_name == DELETED_FLAG) *l_name = '\0';
 3f18c8c:	e5d73000 	ldrb	r3, [r7]
 3f18c90:	e35300e5 	cmp	r3, #229	; 0xe5
 3f18c94:	1a000004 	bne	3f18cac <get_vfatname+0x170>
 3f18c98:	e5c72000 	strb	r2, [r7]
 3f18c9c:	ea000005 	b	3f18cb8 <get_vfatname+0x17c>
 3f18ca0:	0000ffed 	andeq	r15, r0, r13, ror #31
 3f18ca4:	03f1fff4 	mvneqs	r15, #976	; 0x3d0
 3f18ca8:	03f730cc 	mvneqs	r3, #204	; 0xcc
	else if (*l_name == aRING) *l_name = '';
 3f18cac:	e3530005 	cmp	r3, #5	; 0x5
 3f18cb0:	03a030e5 	moveq	r3, #229	; 0xe5
 3f18cb4:	05c73000 	streqb	r3, [r7]
	downcase(l_name);
 3f18cb8:	e1a00007 	mov	r0, r7
 3f18cbc:	ebfffd76 	bl	3f1829c <downcase>

	/* Return the real directory entry */
	memcpy(retdent, realdent, sizeof(dir_entry));
 3f18cc0:	e1a0000a 	mov	r0, r10
 3f18cc4:	e1a01009 	mov	r1, r9
 3f18cc8:	e3a02020 	mov	r2, #32	; 0x20
 3f18ccc:	ebffda2d 	bl	3f0f588 <memcpy>

	return 0;
 3f18cd0:	e3a00000 	mov	r0, #0	; 0x0
}
 3f18cd4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f18cd8 <mkcksum>:
 3f18cd8:	e1a0c00d 	mov	r12, r13
 3f18cdc:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f18ce0:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
/* Calculate short name checksum */
static __u8 mkcksum(const char *str)
{
 3f18ce4:	e1a0e000 	mov	r14, r0
	int i;
	__u8 ret = 0;
 3f18ce8:	e3a00000 	mov	r0, #0	; 0x0

	for (i = 0; i < 11; i++) {
 3f18cec:	e1a0c000 	mov	r12, r0
		ret = (((ret&1)<<7)|((ret&0xfe)>>1)) + str[i];
 3f18cf0:	e7de300c 	ldrb	r3, [r14, r12]
 3f18cf4:	e28cc001 	add	r12, r12, #1	; 0x1
 3f18cf8:	e2001001 	and	r1, r0, #1	; 0x1
 3f18cfc:	e1a020a0 	mov	r2, r0, lsr #1
 3f18d00:	e1822381 	orr	r2, r2, r1, lsl #7
 3f18d04:	e35c000a 	cmp	r12, #10	; 0xa
 3f18d08:	e0833002 	add	r3, r3, r2
 3f18d0c:	e20300ff 	and	r0, r3, #255	; 0xff
 3f18d10:	dafffff6 	ble	3f18cf0 <mkcksum+0x18>
	}

	return ret;
}
 3f18d14:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f18d18 <get_dentfromdir>:
 3f18d18:	e1a0c00d 	mov	r12, r13
 3f18d1c:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f18d20:	e24cb004 	sub	r11, r12, #4	; 0x4
#endif
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * Get the directory entry associated with 'filename' from the directory
 * starting at 'startsect'
 */
__u8 get_dentfromdir_block[MAX_CLUSTSIZE];
static dir_entry *get_dentfromdir (fsdata * mydata, int startsect, char *filename, dir_entry * retdent, int dols)
{
    __u16 prevcksum = 0xffff;
 3f18d24:	e59f1270 	ldr	r1, [pc, #270]	; 3f18f9c <get_dentfromdir+0x284>
 3f18d28:	e24ddf4a 	sub	r13, r13, #296	; 0x128
 3f18d2c:	e50b113c 	str	r1, [r11, -#316]
 3f18d30:	e1a07000 	mov	r7, r0
    __u32 curclust = START (retdent);
 3f18d34:	e5971000 	ldr	r1, [r7]
 3f18d38:	e1a09003 	mov	r9, r3
 3f18d3c:	e1d961ba 	ldrh	r6, [r9, #26]
 3f18d40:	e3510020 	cmp	r1, #32	; 0x20
 3f18d44:	e50b2138 	str	r2, [r11, -#312]
 3f18d48:	01d931b4 	ldreqh	r3, [r9, #20]
 3f18d4c:	01866803 	orreq	r6, r6, r3, lsl #16
    int files = 0, dirs = 0;
 3f18d50:	e3a02000 	mov	r2, #0	; 0x0
 3f18d54:	e50b2140 	str	r2, [r11, -#320]
 3f18d58:	e50b2144 	str	r2, [r11, -#324]

    FAT_DPRINT ("get_dentfromdir: %s\n", filename);
    while (1) 
    {
		dir_entry *dentptr;
		int i;
	
		if (get_cluster (mydata, curclust, get_dentfromdir_block,
 3f18d5c:	e1a00007 	mov	r0, r7
 3f18d60:	e1d730ba 	ldrh	r3, [r7, #10]
 3f18d64:	e1a01006 	mov	r1, r6
 3f18d68:	e59f2230 	ldr	r2, [pc, #230]	; 3f18fa0 <get_dentfromdir+0x288>
 3f18d6c:	e1a03483 	mov	r3, r3, lsl #9
 3f18d70:	ebfffe83 	bl	3f18784 <get_cluster>
 3f18d74:	e3500000 	cmp	r0, #0	; 0x0
 3f18d78:	1a00009c 	bne	3f18ff0 <get_dentfromdir+0x2d8>
			 mydata->clust_size * SECTOR_SIZE) != 0) 
		{
		    	FAT_DPRINT ("Error: reading directory block\n");
		    	return NULL;
		}
		dentptr = (dir_entry *) get_dentfromdir_block;
		for (i = 0; i < DIRENTSPERCLUST; i++) 
 3f18d7c:	e1d730ba 	ldrh	r3, [r7, #10]
 3f18d80:	e50b0148 	str	r0, [r11, -#328]
 3f18d84:	e59f4214 	ldr	r4, [pc, #214]	; 3f18fa0 <get_dentfromdir+0x288>
 3f18d88:	e1500203 	cmp	r0, r3, lsl #4
 3f18d8c:	2a00008d 	bcs	3f18fc8 <get_dentfromdir+0x2b0>
		{
	    	char s_name[14], l_name[256];

	    	l_name[0] = '\0';
		    if ((dentptr->attr & ATTR_VOLUME)) 
 3f18d90:	e5d4300b 	ldrb	r3, [r4, #11]
 3f18d94:	e3a0a000 	mov	r10, #0	; 0x0
 3f18d98:	e54ba134 	strb	r10, [r11, -#308]
 3f18d9c:	e3130008 	tst	r3, #8	; 0x8
 3f18da0:	0a000030 	beq	3f18e68 <get_dentfromdir+0x150>
		    {
#ifdef CONFIG_SUPPORT_VFAT
				if ((dentptr->attr & ATTR_VFAT) && (dentptr->name[0] & 0x40)) 
 3f18da4:	e313000f 	tst	r3, #15	; 0xf
 3f18da8:	0a000073 	beq	3f18f7c <get_dentfromdir+0x264>
 3f18dac:	e5d43000 	ldrb	r3, [r4]
 3f18db0:	e3130040 	tst	r3, #64	; 0x40
 3f18db4:	0a000070 	beq	3f18f7c <get_dentfromdir+0x264>
				{
			    	prevcksum = ((dir_slot *) dentptr)->alias_checksum;
			    	get_vfatname (mydata, curclust, get_dentfromdir_block, dentptr, l_name);
 3f18db8:	e1a00007 	mov	r0, r7
 3f18dbc:	e59f21dc 	ldr	r2, [pc, #1dc]	; 3f18fa0 <get_dentfromdir+0x288>
 3f18dc0:	e1a01006 	mov	r1, r6
 3f18dc4:	e5d4c00d 	ldrb	r12, [r4, #13]
 3f18dc8:	e1a03004 	mov	r3, r4
 3f18dcc:	e50bc13c 	str	r12, [r11, -#316]
 3f18dd0:	e24b5f4d 	sub	r5, r11, #308	; 0x134
 3f18dd4:	e58d5000 	str	r5, [r13]
 3f18dd8:	ebffff57 	bl	3f18b3c <get_vfatname>
				    if (dols) 
 3f18ddc:	e59b1004 	ldr	r1, [r11, #4]
 3f18de0:	e151000a 	cmp	r1, r10
 3f18de4:	0a00001f 	beq	3f18e68 <get_dentfromdir+0x150>
				    {
						int isdir = (dentptr->attr & ATTR_DIR);
 3f18de8:	e5d4300b 	ldrb	r3, [r4, #11]
						char dirc;
						int doit = 0;
 3f18dec:	e1a0200a 	mov	r2, r10
			
						if (isdir) 
 3f18df0:	e3130010 	tst	r3, #16	; 0x10
 3f18df4:	0a000005 	beq	3f18e10 <get_dentfromdir+0xf8>
						{
						    dirs++;
 3f18df8:	e51b2144 	ldr	r2, [r11, -#324]
						    dirc = '/';
 3f18dfc:	e3a0c02f 	mov	r12, #47	; 0x2f
 3f18e00:	e2822001 	add	r2, r2, #1	; 0x1
 3f18e04:	e50b2144 	str	r2, [r11, -#324]
						    doit = 1;
 3f18e08:	e3a02001 	mov	r2, #1	; 0x1
						} 
 3f18e0c:	ea000006 	b	3f18e2c <get_dentfromdir+0x114>
						else 
						{
						    dirc = ' ';
						    if (l_name[0] != 0) 
 3f18e10:	e55b3134 	ldrb	r3, [r11, -#308]
 3f18e14:	e3a0c020 	mov	r12, #32	; 0x20
 3f18e18:	e3530000 	cmp	r3, #0	; 0x0
						    {
								files++;
 3f18e1c:	151b3140 	ldrne	r3, [r11, -#320]
								doit = 1;
 3f18e20:	13a02001 	movne	r2, #1	; 0x1
 3f18e24:	12833001 	addne	r3, r3, #1	; 0x1
 3f18e28:	150b3140 	strne	r3, [r11, -#320]
						    }
						}
						if (doit) 
 3f18e2c:	e3520000 	cmp	r2, #0	; 0x0
 3f18e30:	0a000051 	beq	3f18f7c <get_dentfromdir+0x264>
						{
						    if (dirc == ' ') 
 3f18e34:	e35c0020 	cmp	r12, #32	; 0x20
 3f18e38:	1a000005 	bne	3f18e54 <get_dentfromdir+0x13c>
						    {
								printf (" %8ld   %s%c\n", (long) FAT2CPU32 (dentptr->size), l_name, dirc);
 3f18e3c:	e59f0160 	ldr	r0, [pc, #160]	; 3f18fa4 <get_dentfromdir+0x28c>
 3f18e40:	e1a02005 	mov	r2, r5
 3f18e44:	e594101c 	ldr	r1, [r4, #28]
 3f18e48:	e1a0300c 	mov	r3, r12
 3f18e4c:	ebffce7c 	bl	3f0c844 <printf>
						    } 
 3f18e50:	ea000049 	b	3f18f7c <get_dentfromdir+0x264>
						    else 
						    {
								printf ("            %s%c\n", l_name, dirc);
 3f18e54:	e1a01005 	mov	r1, r5
 3f18e58:	e59f0148 	ldr	r0, [pc, #148]	; 3f18fa8 <get_dentfromdir+0x290>
 3f18e5c:	e1a0200c 	mov	r2, r12
 3f18e60:	ebffce77 	bl	3f0c844 <printf>
						    }
						}
						dentptr++;
						continue;
 3f18e64:	ea000044 	b	3f18f7c <get_dentfromdir+0x264>
				    }
				    FAT_DPRINT ("vfatname: |%s|\n", l_name);
				} 
				else
#endif
				{
				    /* Volume label or VFAT entry */
				    dentptr++;
				    continue;
				}
		    }
		    if (dentptr->name[0] == 0) 
 3f18e68:	e5d45000 	ldrb	r5, [r4]
 3f18e6c:	e3550000 	cmp	r5, #0	; 0x0
 3f18e70:	1a000007 	bne	3f18e94 <get_dentfromdir+0x17c>
		    {
				if (dols) 
 3f18e74:	e59bc004 	ldr	r12, [r11, #4]
 3f18e78:	e35c0000 	cmp	r12, #0	; 0x0
 3f18e7c:	0a00005b 	beq	3f18ff0 <get_dentfromdir+0x2d8>
				{
				    printf ("\n%d file(s), %d dir(s)\n\n", files, dirs);
 3f18e80:	e51b1140 	ldr	r1, [r11, -#320]
 3f18e84:	e59f0120 	ldr	r0, [pc, #120]	; 3f18fac <get_dentfromdir+0x294>
 3f18e88:	e51b2144 	ldr	r2, [r11, -#324]
 3f18e8c:	ebffce6c 	bl	3f0c844 <printf>
				}
				FAT_DPRINT ("Dentname == NULL - %d\n", i);
				return NULL;
 3f18e90:	ea000056 	b	3f18ff0 <get_dentfromdir+0x2d8>
		    }
#ifdef CONFIG_SUPPORT_VFAT
		    if (dols && mkcksum (dentptr->name) == prevcksum) 
 3f18e94:	e59b1004 	ldr	r1, [r11, #4]
 3f18e98:	e3510000 	cmp	r1, #0	; 0x0
 3f18e9c:	0a000005 	beq	3f18eb8 <get_dentfromdir+0x1a0>
 3f18ea0:	e1a00004 	mov	r0, r4
 3f18ea4:	ebffff8b 	bl	3f18cd8 <mkcksum>
 3f18ea8:	e51b213c 	ldr	r2, [r11, -#316]
 3f18eac:	e20000ff 	and	r0, r0, #255	; 0xff
 3f18eb0:	e1500002 	cmp	r0, r2
 3f18eb4:	0a000030 	beq	3f18f7c <get_dentfromdir+0x264>
		    {
				dentptr++;
				continue;
		    }
#endif
		    get_name (dentptr, s_name);
 3f18eb8:	e1a00004 	mov	r0, r4
 3f18ebc:	e24b5034 	sub	r5, r11, #52	; 0x34
 3f18ec0:	e1a01005 	mov	r1, r5
 3f18ec4:	ebfffd8a 	bl	3f184f4 <get_name>
		    if (dols) 
 3f18ec8:	e59b3004 	ldr	r3, [r11, #4]
 3f18ecc:	e3530000 	cmp	r3, #0	; 0x0
 3f18ed0:	0a00001f 	beq	3f18f54 <get_dentfromdir+0x23c>
		    {
				int isdir = (dentptr->attr & ATTR_DIR);
 3f18ed4:	e5d4300b 	ldrb	r3, [r4, #11]
				char dirc;
				int doit = 0;
 3f18ed8:	e3a02000 	mov	r2, #0	; 0x0
		
				if (isdir) 
 3f18edc:	e3130010 	tst	r3, #16	; 0x10
 3f18ee0:	0a000005 	beq	3f18efc <get_dentfromdir+0x1e4>
				{
				    dirs++;
 3f18ee4:	e51bc144 	ldr	r12, [r11, -#324]
				    dirc = '/';
				    doit = 1;
 3f18ee8:	e2822001 	add	r2, r2, #1	; 0x1
 3f18eec:	e28cc001 	add	r12, r12, #1	; 0x1
 3f18ef0:	e50bc144 	str	r12, [r11, -#324]
 3f18ef4:	e3a0c02f 	mov	r12, #47	; 0x2f
				} 
 3f18ef8:	ea000006 	b	3f18f18 <get_dentfromdir+0x200>
				else 
				{
				    dirc = ' ';
				    if (s_name[0] != 0) 
 3f18efc:	e55b3034 	ldrb	r3, [r11, -#52]
 3f18f00:	e3a0c020 	mov	r12, #32	; 0x20
 3f18f04:	e3530000 	cmp	r3, #0	; 0x0
				    {
						files++;
 3f18f08:	151b1140 	ldrne	r1, [r11, -#320]
						doit = 1;
 3f18f0c:	13a02001 	movne	r2, #1	; 0x1
 3f18f10:	12811001 	addne	r1, r1, #1	; 0x1
 3f18f14:	150b1140 	strne	r1, [r11, -#320]
				    }
				}
				if (doit) 
 3f18f18:	e3520000 	cmp	r2, #0	; 0x0
 3f18f1c:	0a000016 	beq	3f18f7c <get_dentfromdir+0x264>
				{
				    if (dirc == ' ') 
 3f18f20:	e35c0020 	cmp	r12, #32	; 0x20
 3f18f24:	1a000005 	bne	3f18f40 <get_dentfromdir+0x228>
				    {
						printf (" %8ld   %s%c\n", (long) FAT2CPU32 (dentptr->size), s_name, dirc);
 3f18f28:	e59f0074 	ldr	r0, [pc, #74]	; 3f18fa4 <get_dentfromdir+0x28c>
 3f18f2c:	e1a02005 	mov	r2, r5
 3f18f30:	e594101c 	ldr	r1, [r4, #28]
 3f18f34:	e1a0300c 	mov	r3, r12
 3f18f38:	ebffce41 	bl	3f0c844 <printf>
				    } 
 3f18f3c:	ea00000e 	b	3f18f7c <get_dentfromdir+0x264>
				    else 
				    {
						printf ("            %s%c\n", s_name, dirc);
 3f18f40:	e1a01005 	mov	r1, r5
 3f18f44:	e59f005c 	ldr	r0, [pc, #5c]	; 3f18fa8 <get_dentfromdir+0x290>
 3f18f48:	e1a0200c 	mov	r2, r12
 3f18f4c:	ebffce3c 	bl	3f0c844 <printf>
				    }
				}
				dentptr++;
				continue;
 3f18f50:	ea000009 	b	3f18f7c <get_dentfromdir+0x264>
		    }
		    if (strcmp (filename, s_name) && strcmp (filename, l_name)) 
 3f18f54:	e51b0138 	ldr	r0, [r11, -#312]
 3f18f58:	e1a01005 	mov	r1, r5
 3f18f5c:	ebffd895 	bl	3f0f1b8 <strcmp>
 3f18f60:	e3500000 	cmp	r0, #0	; 0x0
 3f18f64:	0a000006 	beq	3f18f84 <get_dentfromdir+0x26c>
 3f18f68:	e51b0138 	ldr	r0, [r11, -#312]
 3f18f6c:	e24b1f4d 	sub	r1, r11, #308	; 0x134
 3f18f70:	ebffd890 	bl	3f0f1b8 <strcmp>
 3f18f74:	e3500000 	cmp	r0, #0	; 0x0
 3f18f78:	0a000001 	beq	3f18f84 <get_dentfromdir+0x26c>
		    {
				FAT_DPRINT ("Mismatch: |%s|%s|\n", s_name, l_name);
				dentptr++;
 3f18f7c:	e2844020 	add	r4, r4, #32	; 0x20
				continue;
 3f18f80:	ea00000a 	b	3f18fb0 <get_dentfromdir+0x298>
		    }
		    memcpy (retdent, dentptr, sizeof (dir_entry));
 3f18f84:	e1a00009 	mov	r0, r9
 3f18f88:	e1a01004 	mov	r1, r4
 3f18f8c:	e3a02020 	mov	r2, #32	; 0x20
 3f18f90:	ebffd97c 	bl	3f0f588 <memcpy>
	
		    FAT_DPRINT ("DentName: %s", s_name);
		    FAT_DPRINT (", start: 0x%x", START (dentptr));
		    FAT_DPRINT (", size:  0x%x %s\n",
				FAT2CPU32 (dentptr->size),
				(dentptr->attr & ATTR_DIR) ? "(DIR)" : "");
	
		    return retdent;
 3f18f94:	e1a00009 	mov	r0, r9
 3f18f98:	ea000015 	b	3f18ff4 <get_dentfromdir+0x2dc>
 3f18f9c:	0000ffff 	streqd	r15, [r0], -r15
 3f18fa0:	03f830cc 	mvneqs	r3, #204	; 0xcc
 3f18fa4:	03f20008 	mvneqs	r0, #8	; 0x8
 3f18fa8:	03f20018 	mvneqs	r0, #24	; 0x18
 3f18fac:	03f2002c 	mvneqs	r0, #44	; 0x2c
 3f18fb0:	e51b2148 	ldr	r2, [r11, -#328]
 3f18fb4:	e1d730ba 	ldrh	r3, [r7, #10]
 3f18fb8:	e2822001 	add	r2, r2, #1	; 0x1
 3f18fbc:	e1520203 	cmp	r2, r3, lsl #4
 3f18fc0:	e50b2148 	str	r2, [r11, -#328]
 3f18fc4:	3affff71 	bcc	3f18d90 <get_dentfromdir+0x78>
		}
		curclust = get_fatent(mydata, curclust);
 3f18fc8:	e1a00007 	mov	r0, r7
 3f18fcc:	e1a01006 	mov	r1, r6
 3f18fd0:	ebfffd7b 	bl	3f185c4 <get_fatent>
 3f18fd4:	e1a06000 	mov	r6, r0
		if (curclust <= 0x0001 || curclust >= 0xfff0) 
 3f18fd8:	e59f2018 	ldr	r2, [pc, #18]	; 3f18ff8 <get_dentfromdir+0x2e0>
 3f18fdc:	e2463002 	sub	r3, r6, #2	; 0x2
 3f18fe0:	e1530002 	cmp	r3, r2
 3f18fe4:	9affff5c 	bls	3f18d5c <get_dentfromdir+0x44>
		{
		    FAT_DPRINT ("curclust: 0x%x\n", curclust);
		    FAT_ERROR ("Invalid FAT entry\n");
 3f18fe8:	e59f000c 	ldr	r0, [pc, #c]	; 3f18ffc <get_dentfromdir+0x2e4>
 3f18fec:	ebffce14 	bl	3f0c844 <printf>
		    return NULL;
 3f18ff0:	e3a00000 	mov	r0, #0	; 0x0
		}
    }
 3f18ff4:	ea000001 	b	3f19000 <get_dentfromdir+0x2e8>
 3f18ff8:	0000ffed 	andeq	r15, r0, r13, ror #31
 3f18ffc:	03f1fff4 	mvneqs	r15, #976	; 0x3d0

    return NULL;
}
 3f19000:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f19004 <read_bootsectandvi>:
 3f19004:	e1a0c00d 	mov	r12, r13
 3f19008:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f1900c:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
/*
 * Read boot sector and volume info from a FAT filesystem
 */
static int read_bootsectandvi(boot_sector *bs, volume_info *volinfo, int *fatsize)
{
 3f19010:	e1a04000 	mov	r4, r0
	__u8 block[FS_BLOCK_SIZE];
	volume_info *vistart;

	if (disk_read(0, 1, block) < 0) {
 3f19014:	e3a00000 	mov	r0, #0	; 0x0
 3f19018:	e1a07001 	mov	r7, r1
 3f1901c:	e3a01001 	mov	r1, #1	; 0x1
 3f19020:	e1a06002 	mov	r6, r2
 3f19024:	e24b5f87 	sub	r5, r11, #540	; 0x21c
 3f19028:	e1a02005 	mov	r2, r5
 3f1902c:	e24ddc02 	sub	r13, r13, #512	; 0x200
 3f19030:	ebfffca7 	bl	3f182d4 <disk_read>
 3f19034:	e3500000 	cmp	r0, #0	; 0x0
		FAT_DPRINT("Error: reading block\n");
		return -1;
 3f19038:	e3e00000 	mvn	r0, #0	; 0x0
 3f1903c:	ba00002e 	blt	3f190fc <read_bootsectandvi+0xf8>
	}

	memcpy(bs, block, sizeof(boot_sector));
 3f19040:	e1a00004 	mov	r0, r4
 3f19044:	e1a01005 	mov	r1, r5
 3f19048:	e3a02040 	mov	r2, #64	; 0x40
 3f1904c:	ebffd94d 	bl	3f0f588 <memcpy>
	bs->reserved	= FAT2CPU16(bs->reserved);
	bs->fat_length	= FAT2CPU16(bs->fat_length);
	bs->secs_track	= FAT2CPU16(bs->secs_track);
	bs->heads	= FAT2CPU16(bs->heads);
#if 0 /* UNUSED */
	bs->hidden	= FAT2CPU32(bs->hidden);
#endif
	bs->total_sect	= FAT2CPU32(bs->total_sect);

	/* FAT32 entries */
	if (bs->fat_length == 0) {
 3f19050:	e1d431b6 	ldrh	r3, [r4, #22]
 3f19054:	e3530000 	cmp	r3, #0	; 0x0
		/* Assume FAT32 */
		bs->fat32_length = FAT2CPU32(bs->fat32_length);
		bs->flags	 = FAT2CPU16(bs->flags);
		bs->root_cluster = FAT2CPU32(bs->root_cluster);
		bs->info_sector  = FAT2CPU16(bs->info_sector);
		bs->backup_boot  = FAT2CPU16(bs->backup_boot);
		vistart = (volume_info*) (block + sizeof(boot_sector));
 3f19058:	024b4f77 	subeq	r4, r11, #476	; 0x1dc
		*fatsize = 32;
 3f1905c:	03a03020 	moveq	r3, #32	; 0x20
	} else {
		vistart = (volume_info*) &(bs->fat32_length);
 3f19060:	12844024 	addne	r4, r4, #36	; 0x24
		*fatsize = 0;
 3f19064:	13a03000 	movne	r3, #0	; 0x0
 3f19068:	e5863000 	str	r3, [r6]
	}
	memcpy(volinfo, vistart, sizeof(volume_info));
 3f1906c:	e1a00007 	mov	r0, r7
 3f19070:	e1a01004 	mov	r1, r4
 3f19074:	e3a0201c 	mov	r2, #28	; 0x1c
 3f19078:	ebffd942 	bl	3f0f588 <memcpy>

	/* Terminate fs_type string. Writing past the end of vistart
	   is ok - it's just the buffer. */
	vistart->fs_type[8] = '\0';
 3f1907c:	e3a03000 	mov	r3, #0	; 0x0
 3f19080:	e5c4301a 	strb	r3, [r4, #26]

	if (*fatsize == 32) {
 3f19084:	e5963000 	ldr	r3, [r6]
 3f19088:	e3530020 	cmp	r3, #32	; 0x20
 3f1908c:	1a000005 	bne	3f190a8 <read_bootsectandvi+0xa4>
		if (compare_sign(FAT32_SIGN, vistart->fs_type) == 0) {
 3f19090:	e59f0054 	ldr	r0, [pc, #54]	; 3f190ec <read_bootsectandvi+0xe8>
 3f19094:	e2841012 	add	r1, r4, #18	; 0x12
 3f19098:	ebfffd04 	bl	3f184b0 <compare_sign>
 3f1909c:	e3500000 	cmp	r0, #0	; 0x0
 3f190a0:	1a000014 	bne	3f190f8 <read_bootsectandvi+0xf4>
			return 0;
 3f190a4:	ea000014 	b	3f190fc <read_bootsectandvi+0xf8>
		}
	} else {
		if (compare_sign(FAT12_SIGN, vistart->fs_type) == 0) {
 3f190a8:	e2844012 	add	r4, r4, #18	; 0x12
 3f190ac:	e59f003c 	ldr	r0, [pc, #3c]	; 3f190f0 <read_bootsectandvi+0xec>
 3f190b0:	e1a01004 	mov	r1, r4
 3f190b4:	ebfffcfd 	bl	3f184b0 <compare_sign>
 3f190b8:	e3500000 	cmp	r0, #0	; 0x0
 3f190bc:	1a000002 	bne	3f190cc <read_bootsectandvi+0xc8>
			*fatsize = 12;
 3f190c0:	e3a0300c 	mov	r3, #12	; 0xc
 3f190c4:	e5863000 	str	r3, [r6]
			return 0;
 3f190c8:	ea00000b 	b	3f190fc <read_bootsectandvi+0xf8>
		}
		if (compare_sign(FAT16_SIGN, vistart->fs_type) == 0) {
 3f190cc:	e59f0020 	ldr	r0, [pc, #20]	; 3f190f4 <read_bootsectandvi+0xf0>
 3f190d0:	e1a01004 	mov	r1, r4
 3f190d4:	ebfffcf5 	bl	3f184b0 <compare_sign>
 3f190d8:	e3500000 	cmp	r0, #0	; 0x0
 3f190dc:	1a000005 	bne	3f190f8 <read_bootsectandvi+0xf4>
			*fatsize = 16;
 3f190e0:	e3a03010 	mov	r3, #16	; 0x10
 3f190e4:	e5863000 	str	r3, [r6]
			return 0;
 3f190e8:	ea000003 	b	3f190fc <read_bootsectandvi+0xf8>
 3f190ec:	03f20048 	mvneqs	r0, #72	; 0x48
 3f190f0:	03f20054 	mvneqs	r0, #84	; 0x54
 3f190f4:	03f20060 	mvneqs	r0, #96	; 0x60
		}
	}

	FAT_DPRINT("Error: broken fs_type sign\n");
	return -1;
 3f190f8:	e3e00000 	mvn	r0, #0	; 0x0
}
 3f190fc:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}

03f19100 <do_fat_read>:
 3f19100:	e1a0c00d 	mov	r12, r13
 3f19104:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f19108:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
__u8 do_fat_read_block[MAX_CLUSTSIZE];  /* Block buffer */
static long do_fat_read(const char *filename, void *buffer, unsigned long maxsize, int dols)
{
 3f1910c:	e1a05000 	mov	r5, r0
 3f19110:	e1a09003 	mov	r9, r3
    char 			fnamecopy[2048];
    boot_sector 	bs;
    volume_info 	volinfo;
    fsdata 			datablock;
    fsdata 			*mydata = &datablock;
    dir_entry 		*dentptr;
    __u16 			prevcksum = 0xffff;
    char 			*subname = "";
    int 			rootdir_size, cursect;
    int 			idx, isdir = 0;
 3f19114:	e3a03000 	mov	r3, #0	; 0x0
 3f19118:	e24b0a01 	sub	r0, r11, #4096	; 0x1000
 3f1911c:	e59f4360 	ldr	r4, [pc, #360]	; 3f19484 <do_fat_read+0x384>
 3f19120:	e24ddd57 	sub	r13, r13, #5568	; 0x15c0
 3f19124:	e24dd00c 	sub	r13, r13, #12	; 0xc
 3f19128:	e50035dc 	str	r3, [r0, -#1500]
    int 			files = 0, dirs = 0;
 3f1912c:	e1a0c000 	mov	r12, r0
 3f19130:	e50c35e0 	str	r3, [r12, -#1504]
 3f19134:	e59fc34c 	ldr	r12, [pc, #34c]	; 3f19488 <do_fat_read+0x388>
 3f19138:	e1a0e000 	mov	r14, r0
 3f1913c:	e51e05dc 	ldr	r0, [r14, -#1500]
 3f19140:	e1a0300e 	mov	r3, r14
 3f19144:	e50e05e4 	str	r0, [r14, -#1508]
    long 			ret = 0;
    int 			firsttime;
    
    //printf("filename %s\n", filename);

    if(read_bootsectandvi(&bs, &volinfo, &mydata->fatsize)) 
 3f19148:	e24b0e86 	sub	r0, r11, #2144	; 0x860
 3f1914c:	e503c5d0 	str	r12, [r3, -#1488]
 3f19150:	e2400004 	sub	r0, r0, #4	; 0x4
 3f19154:	e50e15c8 	str	r1, [r14, -#1480]
 3f19158:	e24b1e87 	sub	r1, r11, #2160	; 0x870
 3f1915c:	e59fc328 	ldr	r12, [pc, #328]	; 3f1948c <do_fat_read+0x38c>
 3f19160:	e2411004 	sub	r1, r1, #4	; 0x4
 3f19164:	e503c5d4 	str	r12, [r3, -#1492]
 3f19168:	e241100c 	sub	r1, r1, #12	; 0xc
 3f1916c:	e50e25cc 	str	r2, [r14, -#1484]
 3f19170:	e08b2004 	add	r2, r11, r4
 3f19174:	e2426024 	sub	r6, r2, #36	; 0x24
 3f19178:	e1a02006 	mov	r2, r6
 3f1917c:	ebffffa0 	bl	3f19004 <read_bootsectandvi>
 3f19180:	e3500000 	cmp	r0, #0	; 0x0
 3f19184:	1a0000bc 	bne	3f1947c <do_fat_read+0x37c>
    {
		FAT_DPRINT ("Error: reading boot sector\n");
		return -1;
    }
    if (mydata->fatsize == 32) 
 3f19188:	e24bc024 	sub	r12, r11, #36	; 0x24
 3f1918c:	e79c3004 	ldr	r3, [r12, r4]
 3f19190:	e3530020 	cmp	r3, #32	; 0x20
    {
		mydata->fatlength = bs.fat32_length;
 3f19194:	059f32f4 	ldreq	r3, [pc, #2f4]	; 3f19490 <do_fat_read+0x390>
 3f19198:	01a0e00c 	moveq	r14, r12
 3f1919c:	019e30b3 	ldreqh	r3, [r14, r3]
    } 
    else 
    {
		mydata->fatlength = bs.fat_length;
 3f191a0:	159f32ec 	ldrne	r3, [pc, #2ec]	; 3f19494 <do_fat_read+0x394>
 3f191a4:	124b0024 	subne	r0, r11, #36	; 0x24
 3f191a8:	119030b3 	ldrneh	r3, [r0, r3]
 3f191ac:	e1c630b4 	strh	r3, [r6, #4]
    }
    mydata->fat_sect = bs.reserved;
 3f191b0:	e59f32e0 	ldr	r3, [pc, #2e0]	; 3f19498 <do_fat_read+0x398>
 3f191b4:	e24b2024 	sub	r2, r11, #36	; 0x24
 3f191b8:	e19210b3 	ldrh	r1, [r2, r3]
    cursect = mydata->rootdir_sect = mydata->fat_sect + mydata->fatlength * bs.fats;
 3f191bc:	e1d630b4 	ldrh	r3, [r6, #4]
 3f191c0:	e1c610b6 	strh	r1, [r6, #6]
 3f191c4:	e55b2854 	ldrb	r2, [r11, -#2132]
 3f191c8:	e0221293 	mla	r2, r3, r2, r1
    mydata->clust_size = bs.cluster_size;
    if (mydata->fatsize == 32) 
 3f191cc:	e5963000 	ldr	r3, [r6]
 3f191d0:	e24bca01 	sub	r12, r11, #4096	; 0x1000
 3f191d4:	e3530020 	cmp	r3, #32	; 0x20
 3f191d8:	e1a01002 	mov	r1, r2
 3f191dc:	e1c610b8 	strh	r1, [r6, #8]
 3f191e0:	e1a03801 	mov	r3, r1, lsl #16
 3f191e4:	e55b2857 	ldrb	r2, [r11, -#2135]
 3f191e8:	e1a03823 	mov	r3, r3, lsr #16
 3f191ec:	e50c35d8 	str	r3, [r12, -#1496]
 3f191f0:	e1c620ba 	strh	r2, [r6, #10]
    {
		rootdir_size = mydata->clust_size;
 3f191f4:	01d630ba 	ldreqh	r3, [r6, #10]
		mydata->data_begin = mydata->rootdir_sect   /* + rootdir_size */
 3f191f8:	00413083 	subeq	r3, r1, r3, lsl #1
 3f191fc:	01c630bc 	streqh	r3, [r6, #12]
			- (mydata->clust_size * 2);
    } 
 3f19200:	0a000006 	beq	3f19220 <do_fat_read+0x120>
    else 
    {
		rootdir_size = ((bs.dir_entries[1] * (int) 256 + bs.dir_entries[0]) * sizeof (dir_entry)) / SECTOR_SIZE;
 3f19204:	e55b3852 	ldrb	r3, [r11, -#2130]
 3f19208:	e55b2853 	ldrb	r2, [r11, -#2131]
 3f1920c:	e1822403 	orr	r2, r2, r3, lsl #8
		mydata->data_begin = mydata->rootdir_sect + rootdir_size - (mydata->clust_size * 2);
 3f19210:	e1d630ba 	ldrh	r3, [r6, #10]
 3f19214:	e0812222 	add	r2, r1, r2, lsr #4
 3f19218:	e0422083 	sub	r2, r2, r3, lsl #1
 3f1921c:	e1c620bc 	strh	r2, [r6, #12]
    }
    mydata->fatbufnum = -1;

    FAT_DPRINT ("FAT%d, fatlength: %d\n", mydata->fatsize, mydata->fatlength);
    FAT_DPRINT ("Rootdir begins at sector: %d, offset: %x, size: %d\n"
		"Data begins at: %d\n",
		mydata->rootdir_sect, mydata->rootdir_sect * SECTOR_SIZE,
		rootdir_size, mydata->data_begin);
    FAT_DPRINT ("Cluster size: %d\n", mydata->clust_size);

    /* "cwd" is always the root... */
    while (ISDIRDELIM (*filename))
 3f19220:	e5d52000 	ldrb	r2, [r5]
 3f19224:	e3e03000 	mvn	r3, #0	; 0x0
 3f19228:	e5863c10 	str	r3, [r6, #3088]
 3f1922c:	e352005c 	cmp	r2, #92	; 0x5c
 3f19230:	1352002f 	cmpne	r2, #47	; 0x2f
 3f19234:	1a000003 	bne	3f19248 <do_fat_read+0x148>
		filename++;
 3f19238:	e5f53001 	ldrb	r3, [r5, #1]!
 3f1923c:	e353005c 	cmp	r3, #92	; 0x5c
 3f19240:	1353002f 	cmpne	r3, #47	; 0x2f
 3f19244:	0afffffb 	beq	3f19238 <do_fat_read+0x138>
    /* Make a copy of the filename and convert it to lowercase */
    strcpy (fnamecopy, filename);
 3f19248:	e24bae82 	sub	r10, r11, #2080	; 0x820
 3f1924c:	e24aa004 	sub	r10, r10, #4	; 0x4
 3f19250:	e1a0000a 	mov	r0, r10
 3f19254:	e1a01005 	mov	r1, r5
 3f19258:	ebffd79a 	bl	3f0f0c8 <strcpy>
    downcase (fnamecopy);
 3f1925c:	e1a0000a 	mov	r0, r10
 3f19260:	ebfffc0d 	bl	3f1829c <downcase>
    if (*fnamecopy == '\0') 
 3f19264:	e55b3824 	ldrb	r3, [r11, -#2084]
 3f19268:	e3530000 	cmp	r3, #0	; 0x0
 3f1926c:	1a000003 	bne	3f19280 <do_fat_read+0x180>
    {
		if (!dols)
 3f19270:	e3590000 	cmp	r9, #0	; 0x0
 3f19274:	0a000080 	beq	3f1947c <do_fat_read+0x37c>
	    	return -1;
		dols = LS_ROOT;
 3f19278:	e3a09002 	mov	r9, #2	; 0x2
    } 
 3f1927c:	ea000030 	b	3f19344 <do_fat_read+0x244>
    else if ((idx = dirdelim (fnamecopy)) >= 0) 
 3f19280:	e1a0000a 	mov	r0, r10
 3f19284:	ebfffc78 	bl	3f1846c <dirdelim>
 3f19288:	e2504000 	subs	r4, r0, #0	; 0x0
 3f1928c:	ba000028 	blt	3f19334 <do_fat_read+0x234>
    {
		isdir = 1;
 3f19290:	e3a00001 	mov	r0, #1	; 0x1
 3f19294:	e24bea01 	sub	r14, r11, #4096	; 0x1000
 3f19298:	e50e05dc 	str	r0, [r14, -#1500]
		fnamecopy[idx] = '\0';
 3f1929c:	e3a03000 	mov	r3, #0	; 0x0
 3f192a0:	e7ca3004 	strb	r3, [r10, r4]
		subname = fnamecopy + idx + 1;
 3f192a4:	e08a3004 	add	r3, r10, r4
 3f192a8:	e1a0100e 	mov	r1, r14
		/* Handle multiple delimiters */
		while (ISDIRDELIM (*subname))
 3f192ac:	e5d32001 	ldrb	r2, [r3, #1]
 3f192b0:	e0833000 	add	r3, r3, r0
 3f192b4:	e50135d4 	str	r3, [r1, -#1492]
 3f192b8:	e352005c 	cmp	r2, #92	; 0x5c
 3f192bc:	1352002f 	cmpne	r2, #47	; 0x2f
 3f192c0:	1a00001f 	bne	3f19344 <do_fat_read+0x244>
		    subname++;
 3f192c4:	e24b2a01 	sub	r2, r11, #4096	; 0x1000
 3f192c8:	e51255d4 	ldr	r5, [r2, -#1492]
 3f192cc:	e2855001 	add	r5, r5, #1	; 0x1
 3f192d0:	e50255d4 	str	r5, [r2, -#1492]
 3f192d4:	e5d53000 	ldrb	r3, [r5]
 3f192d8:	e353005c 	cmp	r3, #92	; 0x5c
 3f192dc:	1353002f 	cmpne	r3, #47	; 0x2f
 3f192e0:	0afffff7 	beq	3f192c4 <do_fat_read+0x1c4>
    } 
 3f192e4:	ea000016 	b	3f19344 <do_fat_read+0x244>
    else if (dols) 
    {
		isdir = 1;
    }

    while (1) 
    {
		int i;

		if (disk_read (cursect, mydata->clust_size, do_fat_read_block) < 0) 
		{
	    	FAT_DPRINT ("Error: reading rootdir block\n");
	    	return -1;
		}
		dentptr = (dir_entry *) do_fat_read_block;
		for (i = 0; i < DIRENTSPERBLOCK; i++) 
		{
	    	char s_name[14], l_name[256];

	    	l_name[0] = '\0';
	    	if ((dentptr->attr & ATTR_VOLUME)) 
	    	{
#ifdef CONFIG_SUPPORT_VFAT
				if ((dentptr->attr & ATTR_VFAT) && (dentptr->name[0] & 0x40)) 
				{
		    		prevcksum = ((dir_slot *) dentptr)->alias_checksum;
		    		get_vfatname (mydata, 0, do_fat_read_block, dentptr, l_name);
		    		if (dols == LS_ROOT) 
		    		{
						int isdir = (dentptr->attr & ATTR_DIR);
						char dirc;
						int doit = 0;

						if (isdir) 
						{
			    			dirs++;
			    			dirc = '/';
			    			doit = 1;
						} 
						else 
						{
			    			dirc = ' ';
			    			if (l_name[0] != 0) 
			    			{
								files++;
								doit = 1;
			    			}
						}
						if (doit) 
						{
			    			if (dirc == ' ') 
			    			{
								printf (" %8ld   %s%c\n", (long) FAT2CPU32 (dentptr->size), l_name, dirc);
			    			} 
			    			else 
			    			{
								printf ("            %s%c\n", l_name, dirc);
			    			}
						}
						dentptr++;
						continue;
		    		}
		    		FAT_DPRINT ("Rootvfatname: |%s|\n", l_name);
				} 
				else
#endif
				{
		    		/* Volume label or VFAT entry */
		    		dentptr++;
		    		continue;
				}
	    	} 
	    	else if (dentptr->name[0] == 0) 
	    	{
				FAT_DPRINT ("RootDentname == NULL - %d\n", i);
				if (dols == LS_ROOT) 
				{
		    		printf ("\n%d file(s), %d dir(s)\n\n", files, dirs);
 3f192e8:	e24bca01 	sub	r12, r11, #4096	; 0x1000
 3f192ec:	e51c15e0 	ldr	r1, [r12, -#1504]
 3f192f0:	e59f01a4 	ldr	r0, [pc, #1a4]	; 3f1949c <do_fat_read+0x39c>
 3f192f4:	e1a0e00c 	mov	r14, r12
 3f192f8:	e51e25e4 	ldr	r2, [r14, -#1508]
 3f192fc:	ebffcd50 	bl	3f0c844 <printf>
		    		return 0;
 3f19300:	e1a00004 	mov	r0, r4
 3f19304:	ea000129 	b	3f197b0 <do_fat_read+0x6b0>
				}
				return -1;
	    	}
#ifdef CONFIG_SUPPORT_VFAT
	    	else if (dols == LS_ROOT && mkcksum (dentptr->name) == prevcksum) 
	    	{
				dentptr++;
				continue;
	    	}
#endif
	    	get_name (dentptr, s_name);
	    	if (dols == LS_ROOT) 
	    	{
				int isdir = (dentptr->attr & ATTR_DIR);
				char dirc;
				int doit = 0;

				if (isdir) 
				{
		    		dirc = '/';
		    		if (s_name[0] != 0) 
		    		{
						dirs++;
						doit = 1;
		    		}
				} 
				else 
				{
		    		dirc = ' ';
		    		if (s_name[0] != 0) 
		    		{
						files++;
						doit = 1;
		    		}
				}
				if (doit) 
				{
		    		if (dirc == ' ') 
		    		{
						printf (" %8ld   %s%c\n", (long) FAT2CPU32 (dentptr->size), s_name, dirc);
		    		} 
		    		else 
		    		{
						printf ("            %s%c\n", s_name, dirc);
		    		}
				}
				dentptr++;
				continue;
	    	}
	    	if (strcmp (fnamecopy, s_name) && strcmp (fnamecopy, l_name)) 
	    	{
				FAT_DPRINT ("RootMismatch: |%s|%s|\n", s_name, l_name);
				dentptr++;
				continue;
	    	}
	    	if (isdir && !(dentptr->attr & ATTR_DIR))
				return -1;

	    	FAT_DPRINT ("RootName: %s", s_name);
	    	FAT_DPRINT (", start: 0x%x", START (dentptr));
	    	FAT_DPRINT (", size:  0x%x %s\n",
			FAT2CPU32 (dentptr->size), isdir ? "(DIR)" : "");

		    goto rootdir_done;  /* We got a match */
		}
		cursect++;
    }
rootdir_done:

    firsttime = 1;
    while (isdir) 
    {
		int startsect = mydata->data_begin + START (dentptr) * mydata->clust_size;
		dir_entry dent;
		char *nextname = NULL;

		dent = *dentptr;
		dentptr = &dent;

		idx = dirdelim (subname);
		if (idx >= 0) 
		{
		    subname[idx] = '\0';
	    	nextname = subname + idx + 1;
	    	/* Handle multiple delimiters */
	    	while (ISDIRDELIM (*nextname))
				nextname++;
	    	if (dols && *nextname == '\0')
				firsttime = 0;
		} 
		else 
		{
		    if (dols && firsttime) 
		    {
				firsttime = 0;
		    } 
		    else 
		    {
				isdir = 0;
		    }
		}

		if (get_dentfromdir (mydata, startsect, subname, dentptr, isdir ? 0 : dols) == NULL) 
		{
		    if (dols && !isdir)
 3f19308:	e24b0a01 	sub	r0, r11, #4096	; 0x1000
 3f1930c:	e51005dc 	ldr	r0, [r0, -#1500]
 3f19310:	e3500000 	cmp	r0, #0	; 0x0
 3f19314:	13a03000 	movne	r3, #0	; 0x0
 3f19318:	03a03001 	moveq	r3, #1	; 0x1
 3f1931c:	e3590000 	cmp	r9, #0	; 0x0
 3f19320:	03a03000 	moveq	r3, #0	; 0x0
 3f19324:	e3530000 	cmp	r3, #0	; 0x0
 3f19328:	13a00000 	movne	r0, #0	; 0x0
 3f1932c:	03e00000 	mvneq	r0, #0	; 0x0
			return 0;
		    return -1;
 3f19330:	ea00011e 	b	3f197b0 <do_fat_read+0x6b0>
 3f19334:	e2592000 	subs	r2, r9, #0	; 0x0
 3f19338:	13a02001 	movne	r2, #1	; 0x1
 3f1933c:	e24b1a01 	sub	r1, r11, #4096	; 0x1000
 3f19340:	e50125dc 	str	r2, [r1, -#1500]
 3f19344:	e24b3a01 	sub	r3, r11, #4096	; 0x1000
 3f19348:	e51305d8 	ldr	r0, [r3, -#1496]
 3f1934c:	e1d610ba 	ldrh	r1, [r6, #10]
 3f19350:	e59f2148 	ldr	r2, [pc, #148]	; 3f194a0 <do_fat_read+0x3a0>
 3f19354:	ebfffbde 	bl	3f182d4 <disk_read>
 3f19358:	e3500000 	cmp	r0, #0	; 0x0
 3f1935c:	ba000046 	blt	3f1947c <do_fat_read+0x37c>
 3f19360:	e3a0e000 	mov	r14, #0	; 0x0
 3f19364:	e59f5134 	ldr	r5, [pc, #134]	; 3f194a0 <do_fat_read+0x3a0>
 3f19368:	e24bca01 	sub	r12, r11, #4096	; 0x1000
 3f1936c:	e50ce5e8 	str	r14, [r12, -#1512]
 3f19370:	e3a07000 	mov	r7, #0	; 0x0
 3f19374:	e24b0a01 	sub	r0, r11, #4096	; 0x1000
 3f19378:	e54075a4 	strb	r7, [r0, -#1444]
 3f1937c:	e5d5300b 	ldrb	r3, [r5, #11]
 3f19380:	e3130008 	tst	r3, #8	; 0x8
 3f19384:	0a000037 	beq	3f19468 <do_fat_read+0x368>
 3f19388:	e313000f 	tst	r3, #15	; 0xf
 3f1938c:	0a00008d 	beq	3f195c8 <do_fat_read+0x4c8>
 3f19390:	e5d53000 	ldrb	r3, [r5]
 3f19394:	e3130040 	tst	r3, #64	; 0x40
 3f19398:	0a00008a 	beq	3f195c8 <do_fat_read+0x4c8>
 3f1939c:	e1a00006 	mov	r0, r6
 3f193a0:	e1a01007 	mov	r1, r7
 3f193a4:	e1a03005 	mov	r3, r5
 3f193a8:	e59f20f0 	ldr	r2, [pc, #f0]	; 3f194a0 <do_fat_read+0x3a0>
 3f193ac:	e24bca01 	sub	r12, r11, #4096	; 0x1000
 3f193b0:	e5d5e00d 	ldrb	r14, [r5, #13]
 3f193b4:	e24b4d56 	sub	r4, r11, #5504	; 0x1580
 3f193b8:	e50ce5d0 	str	r14, [r12, -#1488]
 3f193bc:	e2444024 	sub	r4, r4, #36	; 0x24
 3f193c0:	e58d4000 	str	r4, [r13]
 3f193c4:	ebfffddc 	bl	3f18b3c <get_vfatname>
 3f193c8:	e3590002 	cmp	r9, #2	; 0x2
 3f193cc:	1a00003f 	bne	3f194d0 <do_fat_read+0x3d0>
 3f193d0:	e5d5300b 	ldrb	r3, [r5, #11]
 3f193d4:	e1a01007 	mov	r1, r7
 3f193d8:	e3130010 	tst	r3, #16	; 0x10
 3f193dc:	0a000007 	beq	3f19400 <do_fat_read+0x300>
 3f193e0:	e24b0a01 	sub	r0, r11, #4096	; 0x1000
 3f193e4:	e51005e4 	ldr	r0, [r0, -#1508]
 3f193e8:	e3a0c02f 	mov	r12, #47	; 0x2f
 3f193ec:	e2801001 	add	r1, r0, #1	; 0x1
 3f193f0:	e24b0a01 	sub	r0, r11, #4096	; 0x1000
 3f193f4:	e50015e4 	str	r1, [r0, -#1508]
 3f193f8:	e3a01001 	mov	r1, #1	; 0x1
 3f193fc:	ea00000a 	b	3f1942c <do_fat_read+0x32c>
 3f19400:	e24b2a01 	sub	r2, r11, #4096	; 0x1000
 3f19404:	e55235a4 	ldrb	r3, [r2, -#1444]
 3f19408:	e3a0c020 	mov	r12, #32	; 0x20
 3f1940c:	e3530000 	cmp	r3, #0	; 0x0
 3f19410:	0a000005 	beq	3f1942c <do_fat_read+0x32c>
 3f19414:	e1a03002 	mov	r3, r2
 3f19418:	e51335e0 	ldr	r3, [r3, -#1504]
 3f1941c:	e3a01001 	mov	r1, #1	; 0x1
 3f19420:	e283e001 	add	r14, r3, #1	; 0x1
 3f19424:	e1a03002 	mov	r3, r2
 3f19428:	e503e5e0 	str	r14, [r3, -#1504]
 3f1942c:	e3510000 	cmp	r1, #0	; 0x0
 3f19430:	0a000064 	beq	3f195c8 <do_fat_read+0x4c8>
 3f19434:	e35c0020 	cmp	r12, #32	; 0x20
 3f19438:	1a000005 	bne	3f19454 <do_fat_read+0x354>
 3f1943c:	e59f0060 	ldr	r0, [pc, #60]	; 3f194a4 <do_fat_read+0x3a4>
 3f19440:	e1a02004 	mov	r2, r4
 3f19444:	e595101c 	ldr	r1, [r5, #28]
 3f19448:	e1a0300c 	mov	r3, r12
 3f1944c:	ebffccfc 	bl	3f0c844 <printf>
 3f19450:	ea00005c 	b	3f195c8 <do_fat_read+0x4c8>
 3f19454:	e1a01004 	mov	r1, r4
 3f19458:	e59f0048 	ldr	r0, [pc, #48]	; 3f194a8 <do_fat_read+0x3a8>
 3f1945c:	e1a0200c 	mov	r2, r12
 3f19460:	ebffccf7 	bl	3f0c844 <printf>
 3f19464:	ea000057 	b	3f195c8 <do_fat_read+0x4c8>
 3f19468:	e5d54000 	ldrb	r4, [r5]
 3f1946c:	e3540000 	cmp	r4, #0	; 0x0
 3f19470:	1a00000d 	bne	3f194ac <do_fat_read+0x3ac>
 3f19474:	e3590002 	cmp	r9, #2	; 0x2
 3f19478:	0affff9a 	beq	3f192e8 <do_fat_read+0x1e8>
 3f1947c:	e3e00000 	mvn	r0, #0	; 0x0
 3f19480:	ea0000ca 	b	3f197b0 <do_fat_read+0x6b0>
 3f19484:	ffffeb90 	swinv	0x00ffeb90
 3f19488:	0000ffff 	streqd	r15, [r0], -r15
 3f1948c:	03f2006c 	mvneqs	r0, #108	; 0x6c
 3f19490:	fffff7e4 	swinv	0x00fff7e4
 3f19494:	fffff7d6 	swinv	0x00fff7d6
 3f19498:	fffff7ce 	swinv	0x00fff7ce
 3f1949c:	03f2002c 	mvneqs	r0, #44	; 0x2c
 3f194a0:	03f930cc 	mvneqs	r3, #204	; 0xcc
 3f194a4:	03f20008 	mvneqs	r0, #8	; 0x8
 3f194a8:	03f20018 	mvneqs	r0, #24	; 0x18
 3f194ac:	e3590002 	cmp	r9, #2	; 0x2
 3f194b0:	1a000006 	bne	3f194d0 <do_fat_read+0x3d0>
 3f194b4:	e1a00005 	mov	r0, r5
 3f194b8:	ebfffe06 	bl	3f18cd8 <mkcksum>
 3f194bc:	e24bca01 	sub	r12, r11, #4096	; 0x1000
 3f194c0:	e51cc5d0 	ldr	r12, [r12, -#1488]
 3f194c4:	e20000ff 	and	r0, r0, #255	; 0xff
 3f194c8:	e150000c 	cmp	r0, r12
 3f194cc:	0a00003d 	beq	3f195c8 <do_fat_read+0x4c8>
 3f194d0:	e1a00005 	mov	r0, r5
 3f194d4:	e24b4d52 	sub	r4, r11, #5248	; 0x1480
 3f194d8:	e2444024 	sub	r4, r4, #36	; 0x24
 3f194dc:	e1a01004 	mov	r1, r4
 3f194e0:	ebfffc03 	bl	3f184f4 <get_name>
 3f194e4:	e3590002 	cmp	r9, #2	; 0x2
 3f194e8:	1a00002b 	bne	3f1959c <do_fat_read+0x49c>
 3f194ec:	e5d5300b 	ldrb	r3, [r5, #11]
 3f194f0:	e3a02000 	mov	r2, #0	; 0x0
 3f194f4:	e3130010 	tst	r3, #16	; 0x10
 3f194f8:	0a00000c 	beq	3f19530 <do_fat_read+0x430>
 3f194fc:	e59f3210 	ldr	r3, [pc, #210]	; 3f19714 <do_fat_read+0x614>
 3f19500:	e24be024 	sub	r14, r11, #36	; 0x24
 3f19504:	e7de3003 	ldrb	r3, [r14, r3]
 3f19508:	e3a0c02f 	mov	r12, #47	; 0x2f
 3f1950c:	e1530002 	cmp	r3, r2
 3f19510:	0a000012 	beq	3f19560 <do_fat_read+0x460>
 3f19514:	e24b0a01 	sub	r0, r11, #4096	; 0x1000
 3f19518:	e51005e4 	ldr	r0, [r0, -#1508]
 3f1951c:	e2822001 	add	r2, r2, #1	; 0x1
 3f19520:	e2801001 	add	r1, r0, #1	; 0x1
 3f19524:	e24b0a01 	sub	r0, r11, #4096	; 0x1000
 3f19528:	e50015e4 	str	r1, [r0, -#1508]
 3f1952c:	ea00000b 	b	3f19560 <do_fat_read+0x460>
 3f19530:	e59f31dc 	ldr	r3, [pc, #1dc]	; 3f19714 <do_fat_read+0x614>
 3f19534:	e24b1024 	sub	r1, r11, #36	; 0x24
 3f19538:	e7d13003 	ldrb	r3, [r1, r3]
 3f1953c:	e3a0c020 	mov	r12, #32	; 0x20
 3f19540:	e3530000 	cmp	r3, #0	; 0x0
 3f19544:	0a000005 	beq	3f19560 <do_fat_read+0x460>
 3f19548:	e24b2a01 	sub	r2, r11, #4096	; 0x1000
 3f1954c:	e51225e0 	ldr	r2, [r2, -#1504]
 3f19550:	e2823001 	add	r3, r2, #1	; 0x1
 3f19554:	e24b2a01 	sub	r2, r11, #4096	; 0x1000
 3f19558:	e50235e0 	str	r3, [r2, -#1504]
 3f1955c:	e3a02001 	mov	r2, #1	; 0x1
 3f19560:	e3520000 	cmp	r2, #0	; 0x0
 3f19564:	0a000017 	beq	3f195c8 <do_fat_read+0x4c8>
 3f19568:	e35c0020 	cmp	r12, #32	; 0x20
 3f1956c:	1a000005 	bne	3f19588 <do_fat_read+0x488>
 3f19570:	e59f01a0 	ldr	r0, [pc, #1a0]	; 3f19718 <do_fat_read+0x618>
 3f19574:	e1a02004 	mov	r2, r4
 3f19578:	e595101c 	ldr	r1, [r5, #28]
 3f1957c:	e1a0300c 	mov	r3, r12
 3f19580:	ebffccaf 	bl	3f0c844 <printf>
 3f19584:	ea00000f 	b	3f195c8 <do_fat_read+0x4c8>
 3f19588:	e1a01004 	mov	r1, r4
 3f1958c:	e59f0188 	ldr	r0, [pc, #188]	; 3f1971c <do_fat_read+0x61c>
 3f19590:	e1a0200c 	mov	r2, r12
 3f19594:	ebffccaa 	bl	3f0c844 <printf>
 3f19598:	ea00000a 	b	3f195c8 <do_fat_read+0x4c8>
 3f1959c:	e1a0000a 	mov	r0, r10
 3f195a0:	e1a01004 	mov	r1, r4
 3f195a4:	ebffd703 	bl	3f0f1b8 <strcmp>
 3f195a8:	e3500000 	cmp	r0, #0	; 0x0
 3f195ac:	0a000007 	beq	3f195d0 <do_fat_read+0x4d0>
 3f195b0:	e1a0000a 	mov	r0, r10
 3f195b4:	e24b1d56 	sub	r1, r11, #5504	; 0x1580
 3f195b8:	e2411024 	sub	r1, r1, #36	; 0x24
 3f195bc:	ebffd6fd 	bl	3f0f1b8 <strcmp>
 3f195c0:	e3500000 	cmp	r0, #0	; 0x0
 3f195c4:	0a000001 	beq	3f195d0 <do_fat_read+0x4d0>
 3f195c8:	e2855020 	add	r5, r5, #32	; 0x20
 3f195cc:	ea000007 	b	3f195f0 <do_fat_read+0x4f0>
 3f195d0:	e24b3a01 	sub	r3, r11, #4096	; 0x1000
 3f195d4:	e51335dc 	ldr	r3, [r3, -#1500]
 3f195d8:	e3530000 	cmp	r3, #0	; 0x0
 3f195dc:	0a000010 	beq	3f19624 <do_fat_read+0x524>
 3f195e0:	e5d5300b 	ldrb	r3, [r5, #11]
 3f195e4:	e3130010 	tst	r3, #16	; 0x10
 3f195e8:	1a00000d 	bne	3f19624 <do_fat_read+0x524>
 3f195ec:	eaffffa2 	b	3f1947c <do_fat_read+0x37c>
 3f195f0:	e24bca01 	sub	r12, r11, #4096	; 0x1000
 3f195f4:	e51cc5e8 	ldr	r12, [r12, -#1512]
 3f195f8:	e28ce001 	add	r14, r12, #1	; 0x1
 3f195fc:	e24bca01 	sub	r12, r11, #4096	; 0x1000
 3f19600:	e35e000f 	cmp	r14, #15	; 0xf
 3f19604:	e50ce5e8 	str	r14, [r12, -#1512]
 3f19608:	9affff58 	bls	3f19370 <do_fat_read+0x270>
 3f1960c:	e1a0000c 	mov	r0, r12
 3f19610:	e51005d8 	ldr	r0, [r0, -#1496]
 3f19614:	e2801001 	add	r1, r0, #1	; 0x1
 3f19618:	e1a0000c 	mov	r0, r12
 3f1961c:	e50015d8 	str	r1, [r0, -#1496]
 3f19620:	eaffff47 	b	3f19344 <do_fat_read+0x244>
 3f19624:	e24b1a01 	sub	r1, r11, #4096	; 0x1000
 3f19628:	e51115dc 	ldr	r1, [r1, -#1500]
 3f1962c:	e3a0a001 	mov	r10, #1	; 0x1
 3f19630:	e3510000 	cmp	r1, #0	; 0x0
 3f19634:	0a000056 	beq	3f19794 <do_fat_read+0x694>
 3f19638:	e1d501ba 	ldrh	r0, [r5, #26]
 3f1963c:	e5963000 	ldr	r3, [r6]
 3f19640:	e1d620ba 	ldrh	r2, [r6, #10]
 3f19644:	e1d610bc 	ldrh	r1, [r6, #12]
 3f19648:	e3530020 	cmp	r3, #32	; 0x20
 3f1964c:	1a000005 	bne	3f19668 <do_fat_read+0x568>
 3f19650:	e1d531b4 	ldrh	r3, [r5, #20]
 3f19654:	e1803803 	orr	r3, r0, r3, lsl #16
 3f19658:	e0231392 	mla	r3, r2, r3, r1
 3f1965c:	e24bca01 	sub	r12, r11, #4096	; 0x1000
 3f19660:	e50c35ec 	str	r3, [r12, -#1516]
 3f19664:	ea000002 	b	3f19674 <do_fat_read+0x574>
 3f19668:	e0201092 	mla	r0, r2, r0, r1
 3f1966c:	e24bea01 	sub	r14, r11, #4096	; 0x1000
 3f19670:	e50e05ec 	str	r0, [r14, -#1516]
 3f19674:	e59fc0a4 	ldr	r12, [pc, #a4]	; 3f19720 <do_fat_read+0x620>
 3f19678:	e1a0e005 	mov	r14, r5
 3f1967c:	e8be000f 	ldmia	r14!, {r0, r1, r2, r3}
 3f19680:	e08b500c 	add	r5, r11, r12
 3f19684:	e2454024 	sub	r4, r5, #36	; 0x24
 3f19688:	e8a4000f 	stmia	r4!, {r0, r1, r2, r3}
 3f1968c:	e89e000f 	ldmia	r14, {r0, r1, r2, r3}
 3f19690:	e3a07000 	mov	r7, #0	; 0x0
 3f19694:	e884000f 	stmia	r4, {r0, r1, r2, r3}
 3f19698:	e08cc00b 	add	r12, r12, r11
 3f1969c:	e24c5024 	sub	r5, r12, #36	; 0x24
 3f196a0:	e24bca01 	sub	r12, r11, #4096	; 0x1000
 3f196a4:	e51c05d4 	ldr	r0, [r12, -#1492]
 3f196a8:	ebfffb6f 	bl	3f1846c <dirdelim>
 3f196ac:	e2504000 	subs	r4, r0, #0	; 0x0
 3f196b0:	ba000012 	blt	3f19700 <do_fat_read+0x600>
 3f196b4:	e24bea01 	sub	r14, r11, #4096	; 0x1000
 3f196b8:	e51ee5d4 	ldr	r14, [r14, -#1492]
 3f196bc:	e7ce7004 	strb	r7, [r14, r4]
 3f196c0:	e08e3004 	add	r3, r14, r4
 3f196c4:	e5f32001 	ldrb	r2, [r3, #1]!
 3f196c8:	e1a07003 	mov	r7, r3
 3f196cc:	e352005c 	cmp	r2, #92	; 0x5c
 3f196d0:	1352002f 	cmpne	r2, #47	; 0x2f
 3f196d4:	1a000003 	bne	3f196e8 <do_fat_read+0x5e8>
 3f196d8:	e5f73001 	ldrb	r3, [r7, #1]!
 3f196dc:	e353005c 	cmp	r3, #92	; 0x5c
 3f196e0:	1353002f 	cmpne	r3, #47	; 0x2f
 3f196e4:	0afffffb 	beq	3f196d8 <do_fat_read+0x5d8>
 3f196e8:	e3590000 	cmp	r9, #0	; 0x0
 3f196ec:	0a00000e 	beq	3f1972c <do_fat_read+0x62c>
 3f196f0:	e5d73000 	ldrb	r3, [r7]
 3f196f4:	e3530000 	cmp	r3, #0	; 0x0
 3f196f8:	03a0a000 	moveq	r10, #0	; 0x0
 3f196fc:	ea00000a 	b	3f1972c <do_fat_read+0x62c>
 3f19700:	e3590000 	cmp	r9, #0	; 0x0
 3f19704:	135a0000 	cmpne	r10, #0	; 0x0
 3f19708:	0a000005 	beq	3f19724 <do_fat_read+0x624>
 3f1970c:	e1a0a007 	mov	r10, r7
 3f19710:	ea000005 	b	3f1972c <do_fat_read+0x62c>
 3f19714:	ffffeb80 	swinv	0x00ffeb80
 3f19718:	03f20008 	mvneqs	r0, #8	; 0x8
 3f1971c:	03f20018 	mvneqs	r0, #24	; 0x18
 3f19720:	ffffea60 	swinv	0x00ffea60
 3f19724:	e24b1a01 	sub	r1, r11, #4096	; 0x1000
 3f19728:	e50175dc 	str	r7, [r1, -#1500]
 3f1972c:	e1a00006 	mov	r0, r6
 3f19730:	e24b2a01 	sub	r2, r11, #4096	; 0x1000
 3f19734:	e51215ec 	ldr	r1, [r2, -#1516]
 3f19738:	e1a03002 	mov	r3, r2
 3f1973c:	e51325d4 	ldr	r2, [r3, -#1492]
 3f19740:	e24bca01 	sub	r12, r11, #4096	; 0x1000
 3f19744:	e51cc5dc 	ldr	r12, [r12, -#1500]
 3f19748:	e1a03005 	mov	r3, r5
 3f1974c:	e35c0000 	cmp	r12, #0	; 0x0
 3f19750:	01a0c009 	moveq	r12, r9
 3f19754:	13a0c000 	movne	r12, #0	; 0x0
 3f19758:	e58dc000 	str	r12, [r13]
 3f1975c:	ebfffd6d 	bl	3f18d18 <get_dentfromdir>
 3f19760:	e3500000 	cmp	r0, #0	; 0x0
 3f19764:	0afffee7 	beq	3f19308 <do_fat_read+0x208>
		}
	
		if (idx >= 0) 
 3f19768:	e3540000 	cmp	r4, #0	; 0x0
 3f1976c:	ba000004 	blt	3f19784 <do_fat_read+0x684>
		{
		    if (!(dentptr->attr & ATTR_DIR))
 3f19770:	e5d5300b 	ldrb	r3, [r5, #11]
 3f19774:	e3130010 	tst	r3, #16	; 0x10
 3f19778:	0affff3f 	beq	3f1947c <do_fat_read+0x37c>
			return -1;
		    subname = nextname;
 3f1977c:	e24bea01 	sub	r14, r11, #4096	; 0x1000
 3f19780:	e50e75d4 	str	r7, [r14, -#1492]
		}
    }
 3f19784:	e24b0a01 	sub	r0, r11, #4096	; 0x1000
 3f19788:	e51005dc 	ldr	r0, [r0, -#1500]
 3f1978c:	e3500000 	cmp	r0, #0	; 0x0
 3f19790:	1affffa8 	bne	3f19638 <do_fat_read+0x538>
    ret = get_contents(mydata, dentptr, buffer, maxsize);
 3f19794:	e1a00006 	mov	r0, r6
 3f19798:	e1a01005 	mov	r1, r5
 3f1979c:	e24b3a01 	sub	r3, r11, #4096	; 0x1000
 3f197a0:	e51325c8 	ldr	r2, [r3, -#1480]
 3f197a4:	e1a05003 	mov	r5, r3
 3f197a8:	e51535cc 	ldr	r3, [r5, -#1484]
 3f197ac:	ebfffc1c 	bl	3f18824 <get_contents>
    FAT_DPRINT ("Size: %d, got: %ld\n", FAT2CPU32 (dentptr->size), ret);

    return ret;
}
 3f197b0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f197b4 <file_fat_detectfs>:
 3f197b4:	e1a0c00d 	mov	r12, r13
 3f197b8:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
//[*]----------------------------------------------------------------------------------------------------[*]
int file_fat_detectfs(void)
{
	boot_sector	bs;
	volume_info	volinfo;
	int		fatsize;
	char	vol_label[12];

	if(cur_dev==NULL) {
 3f197bc:	e59f4108 	ldr	r4, [pc, #108]	; 3f198cc <file_fat_detectfs+0x118>
 3f197c0:	e24dd06c 	sub	r13, r13, #108	; 0x6c
 3f197c4:	e5943000 	ldr	r3, [r4]
 3f197c8:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f197cc:	e3530000 	cmp	r3, #0	; 0x0
		printf("No current device\n");
 3f197d0:	e59f00f8 	ldr	r0, [pc, #f8]	; 3f198d0 <file_fat_detectfs+0x11c>
 3f197d4:	0a00004a 	beq	3f19904 <file_fat_detectfs+0x150>
		return 1;
	}
#if (CONFIG_COMMANDS & CFG_CMD_IDE) || (CONFIG_COMMANDS & CFG_CMD_SCSI) || (CONFIG_COMMANDS & CFG_CMD_MMC)
	printf("Interface:  ");
 3f197d8:	e59f00f4 	ldr	r0, [pc, #f4]	; 3f198d4 <file_fat_detectfs+0x120>
 3f197dc:	ebffcc18 	bl	3f0c844 <printf>
	switch(cur_dev->if_type) {
 3f197e0:	e5943000 	ldr	r3, [r4]
 3f197e4:	e5933000 	ldr	r3, [r3]
 3f197e8:	e2433001 	sub	r3, r3, #1	; 0x1
 3f197ec:	e3530005 	cmp	r3, #5	; 0x5
 3f197f0:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f197f4:	ea000017 	b	3f19858 <file_fat_detectfs+0xa4>
 3f197f8:	03f19810 	mvneqs	r9, #1048576	; 0x100000
 3f197fc:	03f1981c 	mvneqs	r9, #1835008	; 0x1c0000
 3f19800:	03f19828 	mvneqs	r9, #2621440	; 0x280000
 3f19804:	03f19834 	mvneqs	r9, #3407872	; 0x340000
 3f19808:	03f19840 	mvneqs	r9, #4194304	; 0x400000
 3f1980c:	03f1984c 	mvneqs	r9, #4980736	; 0x4c0000
		case IF_TYPE_IDE 	:	printf("IDE"	);	break;
 3f19810:	e59f00c0 	ldr	r0, [pc, #c0]	; 3f198d8 <file_fat_detectfs+0x124>
 3f19814:	ebffcc0a 	bl	3f0c844 <printf>
 3f19818:	ea000010 	b	3f19860 <file_fat_detectfs+0xac>
		case IF_TYPE_SCSI 	:	printf("SCSI"	); 	break;
 3f1981c:	e59f00b8 	ldr	r0, [pc, #b8]	; 3f198dc <file_fat_detectfs+0x128>
 3f19820:	ebffcc07 	bl	3f0c844 <printf>
 3f19824:	ea00000d 	b	3f19860 <file_fat_detectfs+0xac>
		case IF_TYPE_ATAPI 	:	printf("ATAPI"	); 	break;
 3f19828:	e59f00b0 	ldr	r0, [pc, #b0]	; 3f198e0 <file_fat_detectfs+0x12c>
 3f1982c:	ebffcc04 	bl	3f0c844 <printf>
 3f19830:	ea00000a 	b	3f19860 <file_fat_detectfs+0xac>
		case IF_TYPE_USB 	:	printf("USB"	);	break;
 3f19834:	e59f00a8 	ldr	r0, [pc, #a8]	; 3f198e4 <file_fat_detectfs+0x130>
 3f19838:	ebffcc01 	bl	3f0c844 <printf>
 3f1983c:	ea000007 	b	3f19860 <file_fat_detectfs+0xac>
		case IF_TYPE_DOC 	:	printf("DOC"	);	break;
 3f19840:	e59f00a0 	ldr	r0, [pc, #a0]	; 3f198e8 <file_fat_detectfs+0x134>
 3f19844:	ebffcbfe 	bl	3f0c844 <printf>
 3f19848:	ea000004 	b	3f19860 <file_fat_detectfs+0xac>
		case IF_TYPE_MMC 	:	printf("MMC"	);	break;
 3f1984c:	e59f0098 	ldr	r0, [pc, #98]	; 3f198ec <file_fat_detectfs+0x138>
 3f19850:	ebffcbfb 	bl	3f0c844 <printf>
 3f19854:	ea000001 	b	3f19860 <file_fat_detectfs+0xac>
		default :				printf("Unknown");
 3f19858:	e59f0090 	ldr	r0, [pc, #90]	; 3f198f0 <file_fat_detectfs+0x13c>
 3f1985c:	ebffcbf8 	bl	3f0c844 <printf>
	}
	printf("\n  Device %d: ",cur_dev->dev);
 3f19860:	e5943000 	ldr	r3, [r4]
 3f19864:	e59f0088 	ldr	r0, [pc, #88]	; 3f198f4 <file_fat_detectfs+0x140>
 3f19868:	e5931004 	ldr	r1, [r3, #4]
 3f1986c:	ebffcbf4 	bl	3f0c844 <printf>
	dev_print(cur_dev);
 3f19870:	e5940000 	ldr	r0, [r4]
 3f19874:	eb00003f 	bl	3f19978 <dev_print>
#endif
	if(read_bootsectandvi(&bs, &volinfo, &fatsize)) {
 3f19878:	e24b0054 	sub	r0, r11, #84	; 0x54
 3f1987c:	e24b1070 	sub	r1, r11, #112	; 0x70
 3f19880:	e24b2080 	sub	r2, r11, #128	; 0x80
 3f19884:	ebfffdde 	bl	3f19004 <read_bootsectandvi>
 3f19888:	e2505000 	subs	r5, r0, #0	; 0x0
 3f1988c:	1a00001b 	bne	3f19900 <file_fat_detectfs+0x14c>
		printf("\nNo valid FAT fs found\n");
		return 1;
	}
	memcpy (vol_label, volinfo.volume_label, 11);
 3f19890:	e24b407c 	sub	r4, r11, #124	; 0x7c
 3f19894:	e1a00004 	mov	r0, r4
 3f19898:	e24b1069 	sub	r1, r11, #105	; 0x69
 3f1989c:	e3a0200b 	mov	r2, #11	; 0xb
 3f198a0:	ebffd738 	bl	3f0f588 <memcpy>
	vol_label[11] = '\0';
 3f198a4:	e54b5071 	strb	r5, [r11, -#113]
	volinfo.fs_type[5]='\0';
 3f198a8:	e54b5059 	strb	r5, [r11, -#89]
	printf("Partition %d: Filesystem: %s \"%s\"\n",cur_part,volinfo.fs_type,vol_label);
 3f198ac:	e59f0044 	ldr	r0, [pc, #44]	; 3f198f8 <file_fat_detectfs+0x144>
 3f198b0:	e59f3044 	ldr	r3, [pc, #44]	; 3f198fc <file_fat_detectfs+0x148>
 3f198b4:	e24b205e 	sub	r2, r11, #94	; 0x5e
 3f198b8:	e5931000 	ldr	r1, [r3]
 3f198bc:	e1a03004 	mov	r3, r4
 3f198c0:	ebffcbdf 	bl	3f0c844 <printf>
	return 0;
 3f198c4:	e1a00005 	mov	r0, r5
 3f198c8:	ea00000f 	b	3f1990c <file_fat_detectfs+0x158>
 3f198cc:	03f6a1b4 	mvneqs	r10, #45	; 0x2d
 3f198d0:	03f20070 	mvneqs	r0, #112	; 0x70
 3f198d4:	03f20084 	mvneqs	r0, #132	; 0x84
 3f198d8:	03f20094 	mvneqs	r0, #148	; 0x94
 3f198dc:	03f20098 	mvneqs	r0, #152	; 0x98
 3f198e0:	03f200a0 	mvneqs	r0, #160	; 0xa0
 3f198e4:	03f200a8 	mvneqs	r0, #168	; 0xa8
 3f198e8:	03f200ac 	mvneqs	r0, #172	; 0xac
 3f198ec:	03f200b0 	mvneqs	r0, #176	; 0xb0
 3f198f0:	03f200b4 	mvneqs	r0, #180	; 0xb4
 3f198f4:	03f200bc 	mvneqs	r0, #188	; 0xbc
 3f198f8:	03f200e4 	mvneqs	r0, #228	; 0xe4
 3f198fc:	03f6a1bc 	mvneqs	r10, #47	; 0x2f
 3f19900:	e59f0008 	ldr	r0, [pc, #8]	; 3f19910 <file_fat_detectfs+0x15c>
 3f19904:	ebffcbce 	bl	3f0c844 <printf>
 3f19908:	e3a00001 	mov	r0, #1	; 0x1
 3f1990c:	ea000000 	b	3f19914 <file_fat_detectfs+0x160>
 3f19910:	03f200cc 	mvneqs	r0, #204	; 0xcc
}
 3f19914:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f19918 <file_fat_ls>:
 3f19918:	e1a0c00d 	mov	r12, r13
 3f1991c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f19920:	e24cb004 	sub	r11, r12, #4	; 0x4
//[*]----------------------------------------------------------------------------------------------------[*]
int file_fat_ls(const char *dir)
{
	return do_fat_read(dir, NULL, 0, LS_YES);
 3f19924:	e3a01000 	mov	r1, #0	; 0x0
 3f19928:	e1a02001 	mov	r2, r1
 3f1992c:	e3a03001 	mov	r3, #1	; 0x1
 3f19930:	ebfffdf2 	bl	3f19100 <do_fat_read>
 3f19934:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f19938 <file_fat_read>:
 3f19938:	e1a0c00d 	mov	r12, r13
 3f1993c:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f19940:	e24cb004 	sub	r11, r12, #4	; 0x4
}
//[*]----------------------------------------------------------------------------------------------------[*]
long file_fat_read(const char *filename, void *buffer, unsigned long maxsize)
{
 3f19944:	e1a04000 	mov	r4, r0
 3f19948:	e1a06001 	mov	r6, r1
	printf("reading %s\n",filename);
 3f1994c:	e1a01004 	mov	r1, r4
 3f19950:	e59f001c 	ldr	r0, [pc, #1c]	; 3f19974 <file_fat_read+0x3c>
 3f19954:	e1a05002 	mov	r5, r2
 3f19958:	ebffcbb9 	bl	3f0c844 <printf>
	return do_fat_read(filename, buffer, maxsize, LS_NO);
 3f1995c:	e1a00004 	mov	r0, r4
 3f19960:	e1a01006 	mov	r1, r6
 3f19964:	e1a02005 	mov	r2, r5
 3f19968:	e3a03000 	mov	r3, #0	; 0x0
 3f1996c:	ebfffde3 	bl	3f19100 <do_fat_read>
 3f19970:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f19974:	03f20108 	mvneqs	r0, #2	; 0x2

03f19978 <dev_print>:
 3f19978:	e1a0c00d 	mov	r12, r13
 3f1997c:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
/*
 * reports device info to the user
 */
void dev_print (block_dev_desc_t *dev_desc)
{
 3f19980:	e1a04000 	mov	r4, r0
 3f19984:	e24dd00c 	sub	r13, r13, #12	; 0xc
	ulong lba512; /* number of blocks if 512bytes block size */

	if (dev_desc->type==DEV_TYPE_UNKNOWN) {
 3f19988:	e5d4300b 	ldrb	r3, [r4, #11]
 3f1998c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f19990:	e35300ff 	cmp	r3, #255	; 0xff
 3f19994:	1a000002 	bne	3f199a4 <dev_print+0x2c>
		puts ("not available\n");
 3f19998:	e59f0158 	ldr	r0, [pc, #158]	; 3f19af8 <dev_print+0x180>
 3f1999c:	ebffcb9b 	bl	3f0c810 <puts>
		return;
 3f199a0:	ea000066 	b	3f19b40 <dev_print+0x1c8>
	}
	if (dev_desc->if_type==IF_TYPE_SCSI)  {
 3f199a4:	e5943000 	ldr	r3, [r4]
 3f199a8:	e3530002 	cmp	r3, #2	; 0x2
 3f199ac:	1a000003 	bne	3f199c0 <dev_print+0x48>
		printf ("(%d:%d) ", dev_desc->target,dev_desc->lun);
 3f199b0:	e59f0144 	ldr	r0, [pc, #144]	; 3f19afc <dev_print+0x184>
 3f199b4:	e5d41009 	ldrb	r1, [r4, #9]
 3f199b8:	e5d4200a 	ldrb	r2, [r4, #10]
 3f199bc:	ebffcba0 	bl	3f0c844 <printf>
	}
	if (dev_desc->if_type==IF_TYPE_IDE) {
 3f199c0:	e5943000 	ldr	r3, [r4]
 3f199c4:	e3530001 	cmp	r3, #1	; 0x1
 3f199c8:	1a000005 	bne	3f199e4 <dev_print+0x6c>
		printf ("Model: %s Firm: %s Ser#: %s\n",
 3f199cc:	e2841014 	add	r1, r4, #20	; 0x14
 3f199d0:	e2842050 	add	r2, r4, #80	; 0x50
 3f199d4:	e59f0124 	ldr	r0, [pc, #124]	; 3f19b00 <dev_print+0x188>
 3f199d8:	e284303c 	add	r3, r4, #60	; 0x3c
 3f199dc:	ebffcb98 	bl	3f0c844 <printf>
			dev_desc->vendor,
			dev_desc->revision,
			dev_desc->product);
	} else {
 3f199e0:	ea000004 	b	3f199f8 <dev_print+0x80>
		printf ("Vendor: %s Prod.: %s Rev: %s\n",
 3f199e4:	e2841014 	add	r1, r4, #20	; 0x14
 3f199e8:	e284203c 	add	r2, r4, #60	; 0x3c
 3f199ec:	e59f0110 	ldr	r0, [pc, #110]	; 3f19b04 <dev_print+0x18c>
 3f199f0:	e2843050 	add	r3, r4, #80	; 0x50
 3f199f4:	ebffcb92 	bl	3f0c844 <printf>
			dev_desc->vendor,
			dev_desc->product,
			dev_desc->revision);
	}
	puts ("            Type: ");
 3f199f8:	e59f0108 	ldr	r0, [pc, #108]	; 3f19b08 <dev_print+0x190>
 3f199fc:	ebffcb83 	bl	3f0c810 <puts>
	if (dev_desc->removable)
 3f19a00:	e5d43058 	ldrb	r3, [r4, #88]
 3f19a04:	e3530000 	cmp	r3, #0	; 0x0
 3f19a08:	0a000001 	beq	3f19a14 <dev_print+0x9c>
		puts ("Removable ");
 3f19a0c:	e59f00f8 	ldr	r0, [pc, #f8]	; 3f19b0c <dev_print+0x194>
 3f19a10:	ebffcb7e 	bl	3f0c810 <puts>
	switch (dev_desc->type & 0x1F) {
 3f19a14:	e5d4100b 	ldrb	r1, [r4, #11]
 3f19a18:	e201301f 	and	r3, r1, #31	; 0x1f
 3f19a1c:	e3530007 	cmp	r3, #7	; 0x7
 3f19a20:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f19a24:	ea000013 	b	3f19a78 <dev_print+0x100>
 3f19a28:	03f19a48 	mvneqs	r9, #294912	; 0x48000
 3f19a2c:	03f19a6c 	mvneqs	r9, #442368	; 0x6c000
 3f19a30:	03f19a78 	mvneqs	r9, #491520	; 0x78000
 3f19a34:	03f19a78 	mvneqs	r9, #491520	; 0x78000
 3f19a38:	03f19a78 	mvneqs	r9, #491520	; 0x78000
 3f19a3c:	03f19a54 	mvneqs	r9, #344064	; 0x54000
 3f19a40:	03f19a78 	mvneqs	r9, #491520	; 0x78000
 3f19a44:	03f19a60 	mvneqs	r9, #393216	; 0x60000
		case DEV_TYPE_HARDDISK: puts ("Hard Disk");
 3f19a48:	e59f00c0 	ldr	r0, [pc, #c0]	; 3f19b10 <dev_print+0x198>
 3f19a4c:	ebffcb6f 	bl	3f0c810 <puts>
					break;
 3f19a50:	ea00000b 	b	3f19a84 <dev_print+0x10c>
		case DEV_TYPE_CDROM: 	puts ("CD ROM");
 3f19a54:	e59f00b8 	ldr	r0, [pc, #b8]	; 3f19b14 <dev_print+0x19c>
 3f19a58:	ebffcb6c 	bl	3f0c810 <puts>
					break;
 3f19a5c:	ea000008 	b	3f19a84 <dev_print+0x10c>
		case DEV_TYPE_OPDISK: 	puts ("Optical Device");
 3f19a60:	e59f00b0 	ldr	r0, [pc, #b0]	; 3f19b18 <dev_print+0x1a0>
 3f19a64:	ebffcb69 	bl	3f0c810 <puts>
					break;
 3f19a68:	ea000005 	b	3f19a84 <dev_print+0x10c>
		case DEV_TYPE_TAPE: 	puts ("Tape");
 3f19a6c:	e59f00a8 	ldr	r0, [pc, #a8]	; 3f19b1c <dev_print+0x1a4>
 3f19a70:	ebffcb66 	bl	3f0c810 <puts>
					break;
 3f19a74:	ea000002 	b	3f19a84 <dev_print+0x10c>
		default:		printf ("# %02X #", dev_desc->type & 0x1F);
 3f19a78:	e59f00a0 	ldr	r0, [pc, #a0]	; 3f19b20 <dev_print+0x1a8>
 3f19a7c:	e201101f 	and	r1, r1, #31	; 0x1f
 3f19a80:	ebffcb6f 	bl	3f0c844 <printf>
					break;
	}
	puts ("\n");
 3f19a84:	e59f0098 	ldr	r0, [pc, #98]	; 3f19b24 <dev_print+0x1ac>
 3f19a88:	ebffcb60 	bl	3f0c810 <puts>
	if ((dev_desc->lba * dev_desc->blksz)>0L) {
 3f19a8c:	e594100c 	ldr	r1, [r4, #12]
 3f19a90:	e5940010 	ldr	r0, [r4, #16]
 3f19a94:	e0130190 	muls	r3, r0, r1
 3f19a98:	0a000024 	beq	3f19b30 <dev_print+0x1b8>
		ulong mb, mb_quot, mb_rem, gb, gb_quot, gb_rem;

		lba512 = (dev_desc->lba * (dev_desc->blksz/512));
 3f19a9c:	e1a034a0 	mov	r3, r0, lsr #9
 3f19aa0:	e00e0193 	mul	r14, r3, r1

		mb = (10 * lba512) / 2048;	/* 2048 = (1024 * 1024) / 512 MB */
		/* round to 1 digit */
		mb_quot	= mb / 10;
 3f19aa4:	e59f307c 	ldr	r3, [pc, #7c]	; 3f19b28 <dev_print+0x1b0>
 3f19aa8:	e08ee10e 	add	r14, r14, r14, lsl #2
 3f19aac:	e1a0e08e 	mov	r14, r14, lsl #1
 3f19ab0:	e1a045ae 	mov	r4, r14, lsr #11
 3f19ab4:	e0825493 	umull	r5, r2, r3, r4
		mb_rem	= mb - (10 * mb_quot);

		gb = mb / 1024;
 3f19ab8:	e1a0eaae 	mov	r14, r14, lsr #21
		gb_quot	= gb / 10;
 3f19abc:	e08c5e93 	umull	r5, r12, r3, r14
		gb_rem	= gb - (10 * gb_quot);

		printf ("            Capacity: %ld.%ld MB = %ld.%ld GB (%ld x %ld)\n",
 3f19ac0:	e58d1004 	str	r1, [r13, #4]
 3f19ac4:	e58d0008 	str	r0, [r13, #8]
 3f19ac8:	e59f005c 	ldr	r0, [pc, #5c]	; 3f19b2c <dev_print+0x1b4>
 3f19acc:	e1a021a2 	mov	r2, r2, lsr #3
 3f19ad0:	e1a01002 	mov	r1, r2
 3f19ad4:	e0822102 	add	r2, r2, r2, lsl #2
 3f19ad8:	e0442082 	sub	r2, r4, r2, lsl #1
 3f19adc:	e1a0c1ac 	mov	r12, r12, lsr #3
 3f19ae0:	e1a0300c 	mov	r3, r12
 3f19ae4:	e08cc10c 	add	r12, r12, r12, lsl #2
 3f19ae8:	e04ee08c 	sub	r14, r14, r12, lsl #1
 3f19aec:	e58de000 	str	r14, [r13]
 3f19af0:	ebffcb53 	bl	3f0c844 <printf>
			mb_quot, mb_rem,
			gb_quot, gb_rem,
			dev_desc->lba,
			dev_desc->blksz);
	} else {
 3f19af4:	ea000011 	b	3f19b40 <dev_print+0x1c8>
 3f19af8:	03f20114 	mvneqs	r0, #5	; 0x5
 3f19afc:	03f20124 	mvneqs	r0, #9	; 0x9
 3f19b00:	03f20130 	mvneqs	r0, #12	; 0xc
 3f19b04:	03f20150 	mvneqs	r0, #20	; 0x14
 3f19b08:	03f20170 	mvneqs	r0, #28	; 0x1c
 3f19b0c:	03f20184 	mvneqs	r0, #33	; 0x21
 3f19b10:	03f20190 	mvneqs	r0, #36	; 0x24
 3f19b14:	03f2019c 	mvneqs	r0, #39	; 0x27
 3f19b18:	03f201a4 	mvneqs	r0, #41	; 0x29
 3f19b1c:	03f201b4 	mvneqs	r0, #45	; 0x2d
 3f19b20:	03f201bc 	mvneqs	r0, #47	; 0x2f
 3f19b24:	03f201c8 	mvneqs	r0, #50	; 0x32
 3f19b28:	cccccccd 	stcgtl	12, cr12, [r12], #820
 3f19b2c:	03f201cc 	mvneqs	r0, #51	; 0x33
		puts ("            Capacity: not available\n");
 3f19b30:	e59f0004 	ldr	r0, [pc, #4]	; 3f19b3c <dev_print+0x1c4>
 3f19b34:	ebffcb35 	bl	3f0c810 <puts>
 3f19b38:	ea000000 	b	3f19b40 <dev_print+0x1c8>
 3f19b3c:	03f20208 	mvneqs	r0, #-2147483648	; 0x80000000
	}
}
 3f19b40:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}

03f19b44 <init_part>:
 3f19b44:	e1a0c00d 	mov	r12, r13
 3f19b48:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f19b4c:	e24cb004 	sub	r11, r12, #4	; 0x4


#if defined(CONFIG_MAC_PARTITION) || \
    defined(CONFIG_DOS_PARTITION) || \
    defined(CONFIG_ISO_PARTITION) || \
    defined(CONFIG_AMIGA_PARTITION)

void init_part (block_dev_desc_t * dev_desc)
{
 3f19b50:	e1a04000 	mov	r4, r0
#ifdef CONFIG_ISO_PARTITION
	if (test_part_iso(dev_desc) == 0) {
		dev_desc->part_type = PART_TYPE_ISO;
		return;
	}
#endif

#ifdef CONFIG_MAC_PARTITION
	if (test_part_mac(dev_desc) == 0) {
		dev_desc->part_type = PART_TYPE_MAC;
		return;
	}
#endif

#ifdef CONFIG_DOS_PARTITION
	if (test_part_dos(dev_desc) == 0) {
 3f19b54:	eb000094 	bl	3f19dac <test_part_dos>
 3f19b58:	e3500000 	cmp	r0, #0	; 0x0
		dev_desc->part_type = PART_TYPE_DOS;
 3f19b5c:	03a03002 	moveq	r3, #2	; 0x2
 3f19b60:	05c43008 	streqb	r3, [r4, #8]
		return;
	}
 3f19b64:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}

03f19b68 <get_partition_info>:
 3f19b68:	e1a0c00d 	mov	r12, r13
 3f19b6c:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
#endif

#ifdef CONFIG_AMIGA_PARTITION
	if (test_part_amiga(dev_desc) == 0) {
	    dev_desc->part_type = PART_TYPE_AMIGA;
	    return;
	}
#endif
}


int get_partition_info (block_dev_desc_t *dev_desc, int part, disk_partition_t *info)
{
		switch (dev_desc->part_type) {
 3f19b70:	e5d03008 	ldrb	r3, [r0, #8]
 3f19b74:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f19b78:	e3530002 	cmp	r3, #2	; 0x2
 3f19b7c:	1a000003 	bne	3f19b90 <get_partition_info+0x28>
#ifdef CONFIG_MAC_PARTITION
	case PART_TYPE_MAC:
		if (get_partition_info_mac(dev_desc,part,info) == 0) {
			PRINTF ("## Valid MAC partition found ##\n");
			return (0);
		}
		break;
#endif

#ifdef CONFIG_DOS_PARTITION
	case PART_TYPE_DOS:
		if (get_partition_info_dos(dev_desc,part,info) == 0) {
 3f19b80:	eb0001d5 	bl	3f1a2dc <get_partition_info_dos>
 3f19b84:	e3500000 	cmp	r0, #0	; 0x0
			PRINTF ("## Valid DOS partition found ##\n");
			return (0);
 3f19b88:	e3a00000 	mov	r0, #0	; 0x0
 3f19b8c:	091ba800 	ldmeqdb	r11, {r11, r13, r15}
		}
		break;
#endif

#ifdef CONFIG_ISO_PARTITION
	case PART_TYPE_ISO:
		if (get_partition_info_iso(dev_desc,part,info) == 0) {
			PRINTF ("## Valid ISO boot partition found ##\n");
			return (0);
		}
		break;
#endif

#ifdef CONFIG_AMIGA_PARTITION
	case PART_TYPE_AMIGA:
	    if (get_partition_info_amiga(dev_desc, part, info) == 0)
	    {
		PRINTF ("## Valid Amiga partition found ##\n");
		return (0);
	    }
	    break;
#endif
	default:
		break;
	}
	return (-1);
 3f19b90:	e3e00000 	mvn	r0, #0	; 0x0
 3f19b94:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f19b98 <print_part_header>:
 3f19b98:	e1a0c00d 	mov	r12, r13
 3f19b9c:	e92dd830 	stmdb	r13!, {r4, r5, r11, r12, r14, r15}
 3f19ba0:	e24cb004 	sub	r11, r12, #4	; 0x4
}

static void print_part_header (const char *type, block_dev_desc_t * dev_desc)
{
 3f19ba4:	e1a05000 	mov	r5, r0
	puts ("\nPartition Map for ");
 3f19ba8:	e59f0084 	ldr	r0, [pc, #84]	; 3f19c34 <print_part_header+0x9c>
 3f19bac:	e1a04001 	mov	r4, r1
 3f19bb0:	ebffcb16 	bl	3f0c810 <puts>
	switch (dev_desc->if_type) {
 3f19bb4:	e5943000 	ldr	r3, [r4]
 3f19bb8:	e2433001 	sub	r3, r3, #1	; 0x1
 3f19bbc:	e3530004 	cmp	r3, #4	; 0x4
 3f19bc0:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f19bc4:	ea000013 	b	3f19c18 <print_part_header+0x80>
 3f19bc8:	03f19bdc 	mvneqs	r9, #225280	; 0x37000
 3f19bcc:	03f19be8 	mvneqs	r9, #237568	; 0x3a000
 3f19bd0:	03f19bf4 	mvneqs	r9, #249856	; 0x3d000
 3f19bd4:	03f19c00 	mvneqs	r9, #0	; 0x0
 3f19bd8:	03f19c0c 	mvneqs	r9, #3072	; 0xc00
		case IF_TYPE_IDE:  	puts ("IDE");
 3f19bdc:	e59f0054 	ldr	r0, [pc, #54]	; 3f19c38 <print_part_header+0xa0>
 3f19be0:	ebffcb0a 	bl	3f0c810 <puts>
					break;
 3f19be4:	ea00000d 	b	3f19c20 <print_part_header+0x88>
		case IF_TYPE_SCSI: 	puts ("SCSI");
 3f19be8:	e59f004c 	ldr	r0, [pc, #4c]	; 3f19c3c <print_part_header+0xa4>
 3f19bec:	ebffcb07 	bl	3f0c810 <puts>
					break;
 3f19bf0:	ea00000a 	b	3f19c20 <print_part_header+0x88>
		case IF_TYPE_ATAPI:	puts ("ATAPI");
 3f19bf4:	e59f0044 	ldr	r0, [pc, #44]	; 3f19c40 <print_part_header+0xa8>
 3f19bf8:	ebffcb04 	bl	3f0c810 <puts>
					break;
 3f19bfc:	ea000007 	b	3f19c20 <print_part_header+0x88>
		case IF_TYPE_USB:	puts ("USB");
 3f19c00:	e59f003c 	ldr	r0, [pc, #3c]	; 3f19c44 <print_part_header+0xac>
 3f19c04:	ebffcb01 	bl	3f0c810 <puts>
					break;
 3f19c08:	ea000004 	b	3f19c20 <print_part_header+0x88>
		case IF_TYPE_DOC:	puts ("DOC");
 3f19c0c:	e59f0034 	ldr	r0, [pc, #34]	; 3f19c48 <print_part_header+0xb0>
 3f19c10:	ebffcafe 	bl	3f0c810 <puts>
					break;
 3f19c14:	ea000001 	b	3f19c20 <print_part_header+0x88>
		default: 		puts ("UNKNOWN");
 3f19c18:	e59f002c 	ldr	r0, [pc, #2c]	; 3f19c4c <print_part_header+0xb4>
 3f19c1c:	ebffcafb 	bl	3f0c810 <puts>
					break;
	}
	printf (" device %d  --   Partition Type: %s\n\n",
 3f19c20:	e59f0028 	ldr	r0, [pc, #28]	; 3f19c50 <print_part_header+0xb8>
 3f19c24:	e5941004 	ldr	r1, [r4, #4]
 3f19c28:	e1a02005 	mov	r2, r5
 3f19c2c:	ebffcb04 	bl	3f0c844 <printf>
 3f19c30:	e91ba830 	ldmdb	r11, {r4, r5, r11, r13, r15}
 3f19c34:	03f20230 	mvneqs	r0, #3	; 0x3
 3f19c38:	03f20244 	mvneqs	r0, #1073741828	; 0x40000004
 3f19c3c:	03f20248 	mvneqs	r0, #-2147483644	; 0x80000004
 3f19c40:	03f20250 	mvneqs	r0, #5	; 0x5
 3f19c44:	03f20258 	mvneqs	r0, #-2147483643	; 0x80000005
 3f19c48:	03f2025c 	mvneqs	r0, #-1073741819	; 0xc0000005
 3f19c4c:	03f20260 	mvneqs	r0, #6	; 0x6
 3f19c50:	03f20268 	mvneqs	r0, #-2147483642	; 0x80000006

03f19c54 <print_part>:
 3f19c54:	e1a0c00d 	mov	r12, r13
 3f19c58:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
			dev_desc->dev, type);
}

void print_part (block_dev_desc_t * dev_desc)
{
 3f19c5c:	e1a04000 	mov	r4, r0

		switch (dev_desc->part_type) {
 3f19c60:	e5d43008 	ldrb	r3, [r4, #8]
 3f19c64:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f19c68:	e3530002 	cmp	r3, #2	; 0x2
 3f19c6c:	1a000005 	bne	3f19c88 <print_part+0x34>
#ifdef CONFIG_MAC_PARTITION
	case PART_TYPE_MAC:
		PRINTF ("## Testing for valid MAC partition ##\n");
		print_part_header ("MAC", dev_desc);
		print_part_mac (dev_desc);
		return;
#endif
#ifdef CONFIG_DOS_PARTITION
	case PART_TYPE_DOS:
		PRINTF ("## Testing for valid DOS partition ##\n");
		print_part_header ("DOS", dev_desc);
 3f19c70:	e59f001c 	ldr	r0, [pc, #1c]	; 3f19c94 <print_part+0x40>
 3f19c74:	e1a01004 	mov	r1, r4
 3f19c78:	ebffffc6 	bl	3f19b98 <print_part_header>
		print_part_dos (dev_desc);
 3f19c7c:	e1a00004 	mov	r0, r4
 3f19c80:	eb000188 	bl	3f1a2a8 <print_part_dos>
		return;
 3f19c84:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
#endif

#ifdef CONFIG_ISO_PARTITION
	case PART_TYPE_ISO:
		PRINTF ("## Testing for valid ISO Boot partition ##\n");
		print_part_header ("ISO", dev_desc);
		print_part_iso (dev_desc);
		return;
#endif

#ifdef CONFIG_AMIGA_PARTITION
	case PART_TYPE_AMIGA:
	    PRINTF ("## Testing for a valid Amiga partition ##\n");
	    print_part_header ("AMIGA", dev_desc);
	    print_part_amiga (dev_desc);
	    return;
#endif
	}
	puts ("## Unknown partition table\n");
 3f19c88:	e59f0008 	ldr	r0, [pc, #8]	; 3f19c98 <print_part+0x44>
 3f19c8c:	ebffcadf 	bl	3f0c810 <puts>
}
 3f19c90:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f19c94:	03f20290 	mvneqs	r0, #9	; 0x9
 3f19c98:	03f20294 	mvneqs	r0, #1073741833	; 0x40000009

03f19c9c <print_one_part>:
 3f19c9c:	e1a0c00d 	mov	r12, r13
 3f19ca0:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f19ca4:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f19ca8:	e24dd008 	sub	r13, r13, #8	; 0x8
{
	int lba_start = ext_part_sector + le32_to_int (p->start4);
	int lba_size  = le32_to_int (p->size4);

	printf ("%5d\t\t%10d\t%10d\t%2x%s\n",
 3f19cac:	e5d04004 	ldrb	r4, [r0, #4]
 3f19cb0:	e2803008 	add	r3, r0, #8	; 0x8
 3f19cb4:	e5d3c002 	ldrb	r12, [r3, #2]
 3f19cb8:	e1a05002 	mov	r5, r2
 3f19cbc:	e5d32003 	ldrb	r2, [r3, #3]
 3f19cc0:	e5d3e001 	ldrb	r14, [r3, #1]
 3f19cc4:	e5d03008 	ldrb	r3, [r0, #8]
 3f19cc8:	e1a0c80c 	mov	r12, r12, lsl #16
 3f19ccc:	e18ccc02 	orr	r12, r12, r2, lsl #24
 3f19cd0:	e18cc40e 	orr	r12, r12, r14, lsl #8
 3f19cd4:	e08cc003 	add	r12, r12, r3
 3f19cd8:	e280200c 	add	r2, r0, #12	; 0xc
 3f19cdc:	e5d23002 	ldrb	r3, [r2, #2]
 3f19ce0:	e081e00c 	add	r14, r1, r12
 3f19ce4:	e5d21003 	ldrb	r1, [r2, #3]
 3f19ce8:	e3a06000 	mov	r6, #0	; 0x0
 3f19cec:	e5d2c001 	ldrb	r12, [r2, #1]
 3f19cf0:	e354000f 	cmp	r4, #15	; 0xf
 3f19cf4:	13540005 	cmpne	r4, #5	; 0x5
 3f19cf8:	e5d0200c 	ldrb	r2, [r0, #12]
 3f19cfc:	e1a03803 	mov	r3, r3, lsl #16
 3f19d00:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f19d04:	e183340c 	orr	r3, r3, r12, lsl #8
 3f19d08:	e083c002 	add	r12, r3, r2
 3f19d0c:	0a000001 	beq	3f19d18 <print_one_part+0x7c>
 3f19d10:	e3540085 	cmp	r4, #133	; 0x85
 3f19d14:	1a000000 	bne	3f19d1c <print_one_part+0x80>
 3f19d18:	e3a06001 	mov	r6, #1	; 0x1
		part_num, lba_start, lba_size, p->sys_ind,
		(is_extended (p->sys_ind) ? " Extd" : ""));
 3f19d1c:	e59f3028 	ldr	r3, [pc, #28]	; 3f19d4c <print_one_part+0xb0>
 3f19d20:	e59f2028 	ldr	r2, [pc, #28]	; 3f19d50 <print_one_part+0xb4>
 3f19d24:	e3560000 	cmp	r6, #0	; 0x0
 3f19d28:	e58d4000 	str	r4, [r13]
 3f19d2c:	e1a01005 	mov	r1, r5
 3f19d30:	e59f001c 	ldr	r0, [pc, #1c]	; 3f19d54 <print_one_part+0xb8>
 3f19d34:	11a03002 	movne	r3, r2
 3f19d38:	e1a0200e 	mov	r2, r14
 3f19d3c:	e58d3004 	str	r3, [r13, #4]
 3f19d40:	e1a0300c 	mov	r3, r12
 3f19d44:	ebffcabe 	bl	3f0c844 <printf>
 3f19d48:	ea000002 	b	3f19d58 <print_one_part+0xbc>
 3f19d4c:	03f202b8 	mvneqs	r0, #-2147483637	; 0x8000000b
 3f19d50:	03f202b0 	mvneqs	r0, #11	; 0xb
 3f19d54:	03f202bc 	mvneqs	r0, #-1073741813	; 0xc000000b
}
 3f19d58:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}

03f19d5c <test_block_type>:
 3f19d5c:	e1a0c00d 	mov	r12, r13
 3f19d60:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}

static int test_block_type(unsigned char *buffer)
{
	if((buffer[DOS_PART_MAGIC_OFFSET + 0] != 0x55) ||
 3f19d64:	e5d031fe 	ldrb	r3, [r0, #510]
 3f19d68:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f19d6c:	e3530055 	cmp	r3, #85	; 0x55
 3f19d70:	1a000002 	bne	3f19d80 <test_block_type+0x24>
 3f19d74:	e5d031ff 	ldrb	r3, [r0, #511]
 3f19d78:	e35300aa 	cmp	r3, #170	; 0xaa
 3f19d7c:	0a000001 	beq	3f19d88 <test_block_type+0x2c>
	    (buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) ) {
		return (-1);
 3f19d80:	e3e00000 	mvn	r0, #0	; 0x0
 3f19d84:	e91ba800 	ldmdb	r11, {r11, r13, r15}
	} /* no DOS Signature at all */
	if(strncmp(&buffer[DOS_PBR_FSTYPE_OFFSET],"FAT",3)==0)
 3f19d88:	e2800036 	add	r0, r0, #54	; 0x36
 3f19d8c:	e59f1014 	ldr	r1, [pc, #14]	; 3f19da8 <test_block_type+0x4c>
 3f19d90:	e3a02003 	mov	r2, #3	; 0x3
 3f19d94:	ebffd516 	bl	3f0f1f4 <strncmp>
 3f19d98:	e3500000 	cmp	r0, #0	; 0x0
 3f19d9c:	13a00000 	movne	r0, #0	; 0x0
 3f19da0:	03a00001 	moveq	r0, #1	; 0x1
		return DOS_PBR; /* is PBR */
	return DOS_MBR;	    /* Is MBR */
 3f19da4:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f19da8:	03f202d4 	mvneqs	r0, #1073741837	; 0x4000000d

03f19dac <test_part_dos>:
 3f19dac:	e1a0c00d 	mov	r12, r13
 3f19db0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f19db4:	e24cb004 	sub	r11, r12, #4	; 0x4
}


int test_part_dos (block_dev_desc_t *dev_desc)
{
 3f19db8:	e1a0c000 	mov	r12, r0
	unsigned char buffer[DEFAULT_SECTOR_SIZE];

	if ((dev_desc->block_read(dev_desc->dev, 0, 1, (ulong *) buffer) != 1) ||
 3f19dbc:	e3a01000 	mov	r1, #0	; 0x0
 3f19dc0:	e3a02001 	mov	r2, #1	; 0x1
 3f19dc4:	e24ddc02 	sub	r13, r13, #512	; 0x200
 3f19dc8:	e59c0004 	ldr	r0, [r12, #4]
 3f19dcc:	e24b3f83 	sub	r3, r11, #524	; 0x20c
 3f19dd0:	e1a0e00f 	mov	r14, r15
 3f19dd4:	e59cf05c 	ldr	r15, [r12, #92]
 3f19dd8:	e3500001 	cmp	r0, #1	; 0x1
 3f19ddc:	1a000005 	bne	3f19df8 <test_part_dos+0x4c>
 3f19de0:	e55b300e 	ldrb	r3, [r11, -#14]
 3f19de4:	e3530055 	cmp	r3, #85	; 0x55
 3f19de8:	1a000002 	bne	3f19df8 <test_part_dos+0x4c>
 3f19dec:	e55b300d 	ldrb	r3, [r11, -#13]
 3f19df0:	e35300aa 	cmp	r3, #170	; 0xaa
 3f19df4:	0a000001 	beq	3f19e00 <test_part_dos+0x54>
	    (buffer[DOS_PART_MAGIC_OFFSET + 0] != 0x55) ||
	    (buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) ) {
		return (-1);
 3f19df8:	e3e00000 	mvn	r0, #0	; 0x0
 3f19dfc:	ea000000 	b	3f19e04 <test_part_dos+0x58>
	}
	return (0);
 3f19e00:	e3a00000 	mov	r0, #0	; 0x0
}
 3f19e04:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f19e08 <print_partition_extended>:
 3f19e08:	e1a0c00d 	mov	r12, r13
 3f19e0c:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f19e10:	e24cb004 	sub	r11, r12, #4	; 0x4

/*  Print a partition that is relative to its Extended partition table
 */
static void print_partition_extended (block_dev_desc_t *dev_desc, int ext_part_sector, int relative,
							   int part_num)
{
 3f19e14:	e1a0a003 	mov	r10, r3
 3f19e18:	e1a06001 	mov	r6, r1
 3f19e1c:	e1a09002 	mov	r9, r2
	unsigned char buffer[DEFAULT_SECTOR_SIZE];
	dos_partition_t *pt;
	int i;

	if (dev_desc->block_read(dev_desc->dev, ext_part_sector, 1, (ulong *) buffer) != 1) {
 3f19e20:	e3a02001 	mov	r2, #1	; 0x1
 3f19e24:	e1a07000 	mov	r7, r0
 3f19e28:	e24b4f89 	sub	r4, r11, #548	; 0x224
 3f19e2c:	e24ddc02 	sub	r13, r13, #512	; 0x200
 3f19e30:	e5970004 	ldr	r0, [r7, #4]
 3f19e34:	e1a03004 	mov	r3, r4
 3f19e38:	e1a0e00f 	mov	r14, r15
 3f19e3c:	e597f05c 	ldr	r15, [r7, #92]
 3f19e40:	e3500001 	cmp	r0, #1	; 0x1
 3f19e44:	0a000004 	beq	3f19e5c <print_partition_extended+0x54>
		printf ("** Can't read partition table on %d:%d **\n",
 3f19e48:	e59f0050 	ldr	r0, [pc, #50]	; 3f19ea0 <print_partition_extended+0x98>
 3f19e4c:	e5971004 	ldr	r1, [r7, #4]
 3f19e50:	e1a02006 	mov	r2, r6
 3f19e54:	ebffca7a 	bl	3f0c844 <printf>
			dev_desc->dev, ext_part_sector);
		return;
 3f19e58:	ea000058 	b	3f19fc0 <print_partition_extended+0x1b8>
	}
	i=test_block_type(buffer);
 3f19e5c:	e1a00004 	mov	r0, r4
 3f19e60:	ebffffbd 	bl	3f19d5c <test_block_type>
 3f19e64:	e1a05000 	mov	r5, r0
	if(i==-1) {
 3f19e68:	e3750001 	cmn	r5, #1	; 0x1
 3f19e6c:	1a000004 	bne	3f19e84 <print_partition_extended+0x7c>
		printf ("bad MBR sector signature 0x%02x%02x\n",
 3f19e70:	e59f002c 	ldr	r0, [pc, #2c]	; 3f19ea4 <print_partition_extended+0x9c>
 3f19e74:	e55b1026 	ldrb	r1, [r11, -#38]
 3f19e78:	e55b2025 	ldrb	r2, [r11, -#37]
 3f19e7c:	ebffca70 	bl	3f0c844 <printf>
			buffer[DOS_PART_MAGIC_OFFSET],
			buffer[DOS_PART_MAGIC_OFFSET + 1]);
		return;
 3f19e80:	ea00004e 	b	3f19fc0 <print_partition_extended+0x1b8>
	}
	if(i==DOS_PBR) {
 3f19e84:	e3550001 	cmp	r5, #1	; 0x1
 3f19e88:	1a000007 	bne	3f19eac <print_partition_extended+0xa4>
		printf ("    1\t\t         0\t%10ld\t%2x\n",
 3f19e8c:	e59f0014 	ldr	r0, [pc, #14]	; 3f19ea8 <print_partition_extended+0xa0>
 3f19e90:	e597100c 	ldr	r1, [r7, #12]
 3f19e94:	e55b220f 	ldrb	r2, [r11, -#527]
 3f19e98:	ebffca69 	bl	3f0c844 <printf>
			dev_desc->lba, buffer[DOS_PBR_MEDIA_TYPE_OFFSET]);
		return;
 3f19e9c:	ea000047 	b	3f19fc0 <print_partition_extended+0x1b8>
 3f19ea0:	03f202d8 	mvneqs	r0, #-2147483635	; 0x8000000d
 3f19ea4:	03f20304 	mvneqs	r0, #268435456	; 0x10000000
 3f19ea8:	03f2032c 	mvneqs	r0, #-1342177280	; 0xb0000000
	}
	/* Print all primary/logical partitions */
	pt = (dos_partition_t *) (buffer + DOS_PART_TBL_OFFSET);
 3f19eac:	e24b4066 	sub	r4, r11, #102	; 0x66
	for (i = 0; i < 4; i++, pt++) {
 3f19eb0:	e3a05003 	mov	r5, #3	; 0x3
		/*
		 * fdisk does not show the extended partitions that
		 * are not in the MBR
		 */

		if ((pt->sys_ind != 0) &&
 3f19eb4:	e5d43004 	ldrb	r3, [r4, #4]
 3f19eb8:	e3530000 	cmp	r3, #0	; 0x0
 3f19ebc:	0a00000e 	beq	3f19efc <print_partition_extended+0xf4>
 3f19ec0:	e3560000 	cmp	r6, #0	; 0x0
 3f19ec4:	0a000008 	beq	3f19eec <print_partition_extended+0xe4>
 3f19ec8:	e3a02000 	mov	r2, #0	; 0x0
 3f19ecc:	e353000f 	cmp	r3, #15	; 0xf
 3f19ed0:	13530005 	cmpne	r3, #5	; 0x5
 3f19ed4:	0a000001 	beq	3f19ee0 <print_partition_extended+0xd8>
 3f19ed8:	e3530085 	cmp	r3, #133	; 0x85
 3f19edc:	1a000000 	bne	3f19ee4 <print_partition_extended+0xdc>
 3f19ee0:	e3a02001 	mov	r2, #1	; 0x1
		    (ext_part_sector == 0 || !is_extended (pt->sys_ind)) ) {
 3f19ee4:	e3520000 	cmp	r2, #0	; 0x0
 3f19ee8:	1a000003 	bne	3f19efc <print_partition_extended+0xf4>
			print_one_part (pt, ext_part_sector, part_num);
 3f19eec:	e1a00004 	mov	r0, r4
 3f19ef0:	e1a01006 	mov	r1, r6
 3f19ef4:	e1a0200a 	mov	r2, r10
 3f19ef8:	ebffff67 	bl	3f19c9c <print_one_part>
		}

		/* Reverse engr the fdisk part# assignment rule! */
		if ((ext_part_sector == 0) ||
 3f19efc:	e3560000 	cmp	r6, #0	; 0x0
 3f19f00:	0a00000b 	beq	3f19f34 <print_partition_extended+0x12c>
 3f19f04:	e5d43004 	ldrb	r3, [r4, #4]
 3f19f08:	e3530000 	cmp	r3, #0	; 0x0
 3f19f0c:	0a000009 	beq	3f19f38 <print_partition_extended+0x130>
 3f19f10:	e3a02000 	mov	r2, #0	; 0x0
 3f19f14:	e353000f 	cmp	r3, #15	; 0xf
 3f19f18:	13530005 	cmpne	r3, #5	; 0x5
 3f19f1c:	0a000001 	beq	3f19f28 <print_partition_extended+0x120>
 3f19f20:	e3530085 	cmp	r3, #133	; 0x85
 3f19f24:	1a000000 	bne	3f19f2c <print_partition_extended+0x124>
 3f19f28:	e3a02001 	mov	r2, #1	; 0x1
		    (pt->sys_ind != 0 && !is_extended (pt->sys_ind)) ) {
 3f19f2c:	e3520000 	cmp	r2, #0	; 0x0
 3f19f30:	1a000000 	bne	3f19f38 <print_partition_extended+0x130>
			part_num++;
 3f19f34:	e28aa001 	add	r10, r10, #1	; 0x1
 3f19f38:	e2844010 	add	r4, r4, #16	; 0x10
 3f19f3c:	e2555001 	subs	r5, r5, #1	; 0x1
 3f19f40:	5affffdb 	bpl	3f19eb4 <print_partition_extended+0xac>
		}
	}

	/* Follows the extended partitions */
	pt = (dos_partition_t *) (buffer + DOS_PART_TBL_OFFSET);
 3f19f44:	e24b4066 	sub	r4, r11, #102	; 0x66
	for (i = 0; i < 4; i++, pt++) {
 3f19f48:	e3a05003 	mov	r5, #3	; 0x3
		if (is_extended (pt->sys_ind)) {
 3f19f4c:	e5d43004 	ldrb	r3, [r4, #4]
 3f19f50:	e3a02000 	mov	r2, #0	; 0x0
 3f19f54:	e353000f 	cmp	r3, #15	; 0xf
 3f19f58:	13530005 	cmpne	r3, #5	; 0x5
 3f19f5c:	0a000001 	beq	3f19f68 <print_partition_extended+0x160>
 3f19f60:	e3530085 	cmp	r3, #133	; 0x85
 3f19f64:	1a000000 	bne	3f19f6c <print_partition_extended+0x164>
 3f19f68:	e3a02001 	mov	r2, #1	; 0x1
 3f19f6c:	e3520000 	cmp	r2, #0	; 0x0
 3f19f70:	0a00000f 	beq	3f19fb4 <print_partition_extended+0x1ac>
 3f19f74:	e2842008 	add	r2, r4, #8	; 0x8
 3f19f78:	e5d21002 	ldrb	r1, [r2, #2]
			int lba_start = le32_to_int (pt->start4) + relative;

			print_partition_extended (dev_desc, lba_start,
 3f19f7c:	e1a00007 	mov	r0, r7
 3f19f80:	e5d2c003 	ldrb	r12, [r2, #3]
 3f19f84:	e1a0300a 	mov	r3, r10
 3f19f88:	e5d2e001 	ldrb	r14, [r2, #1]
 3f19f8c:	e3560000 	cmp	r6, #0	; 0x0
 3f19f90:	e5d42008 	ldrb	r2, [r4, #8]
 3f19f94:	e1a01801 	mov	r1, r1, lsl #16
 3f19f98:	e1811c0c 	orr	r1, r1, r12, lsl #24
 3f19f9c:	e181140e 	orr	r1, r1, r14, lsl #8
 3f19fa0:	e0811002 	add	r1, r1, r2
 3f19fa4:	e0811009 	add	r1, r1, r9
 3f19fa8:	11a02009 	movne	r2, r9
 3f19fac:	01a02001 	moveq	r2, r1
 3f19fb0:	ebffff94 	bl	3f19e08 <print_partition_extended>
 3f19fb4:	e2844010 	add	r4, r4, #16	; 0x10
 3f19fb8:	e2555001 	subs	r5, r5, #1	; 0x1
 3f19fbc:	5affffe2 	bpl	3f19f4c <print_partition_extended+0x144>
						  ext_part_sector == 0  ? lba_start
									: relative,
						  part_num);
		}
	}

	return;
}
 3f19fc0:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f19fc4 <get_partition_info_extended>:
 3f19fc4:	e1a0c00d 	mov	r12, r13
 3f19fc8:	e92ddef0 	stmdb	r13!, {r4, r5, r6, r7, r9, r10, r11, r12, r14, r15}
 3f19fcc:	e24cb004 	sub	r11, r12, #4	; 0x4


/*  Print a partition that is relative to its Extended partition table
 */
static int get_partition_info_extended (block_dev_desc_t *dev_desc, int ext_part_sector,
				 int relative, int part_num,
				 int which_part, disk_partition_t *info)
{
 3f19fd0:	e1a06003 	mov	r6, r3
 3f19fd4:	e1a0a001 	mov	r10, r1
 3f19fd8:	e1a05000 	mov	r5, r0
 3f19fdc:	e1a09002 	mov	r9, r2
	unsigned char buffer[DEFAULT_SECTOR_SIZE];
	dos_partition_t *pt;
	int i;

	if (dev_desc->block_read (dev_desc->dev, ext_part_sector, 1, (ulong *) buffer) != 1) {
 3f19fe0:	e3a02001 	mov	r2, #1	; 0x1
 3f19fe4:	e24ddf82 	sub	r13, r13, #520	; 0x208
 3f19fe8:	e5950004 	ldr	r0, [r5, #4]
 3f19fec:	e24b3f89 	sub	r3, r11, #548	; 0x224
 3f19ff0:	e59b7008 	ldr	r7, [r11, #8]
 3f19ff4:	e1a0e00f 	mov	r14, r15
 3f19ff8:	e595f05c 	ldr	r15, [r5, #92]
 3f19ffc:	e3500001 	cmp	r0, #1	; 0x1
 3f1a000:	0a000004 	beq	3f1a018 <get_partition_info_extended+0x54>
		printf ("** Can't read partition table on %d:%d **\n",
 3f1a004:	e59f01e8 	ldr	r0, [pc, #1e8]	; 3f1a1f4 <get_partition_info_extended+0x230>
 3f1a008:	e5951004 	ldr	r1, [r5, #4]
 3f1a00c:	e1a0200a 	mov	r2, r10
 3f1a010:	ebffca0b 	bl	3f0c844 <printf>
			dev_desc->dev, ext_part_sector);
		return -1;
 3f1a014:	ea0000a1 	b	3f1a2a0 <get_partition_info_extended+0x2dc>
	}
	if (buffer[DOS_PART_MAGIC_OFFSET] != 0x55 ||
 3f1a018:	e55b3026 	ldrb	r3, [r11, -#38]
 3f1a01c:	e3530055 	cmp	r3, #85	; 0x55
 3f1a020:	1a000002 	bne	3f1a030 <get_partition_info_extended+0x6c>
 3f1a024:	e55b3025 	ldrb	r3, [r11, -#37]
 3f1a028:	e35300aa 	cmp	r3, #170	; 0xaa
 3f1a02c:	0a000018 	beq	3f1a094 <get_partition_info_extended+0xd0>
		buffer[DOS_PART_MAGIC_OFFSET + 1] != 0xaa) {
		printf ("bad MBR sector signature 0x%02x%02x\n",
 3f1a030:	e59f01c0 	ldr	r0, [pc, #1c0]	; 3f1a1f8 <get_partition_info_extended+0x234>
 3f1a034:	e55b1026 	ldrb	r1, [r11, -#38]
 3f1a038:	e55b2025 	ldrb	r2, [r11, -#37]
 3f1a03c:	ebffca00 	bl	3f0c844 <printf>
			buffer[DOS_PART_MAGIC_OFFSET],
			buffer[DOS_PART_MAGIC_OFFSET + 1]);
		return -1;
 3f1a040:	ea000096 	b	3f1a2a0 <get_partition_info_extended+0x2dc>
 3f1a044:	e2843008 	add	r3, r4, #8	; 0x8
 3f1a048:	e5d3e003 	ldrb	r14, [r3, #3]
 3f1a04c:	e5d31002 	ldrb	r1, [r3, #2]
 3f1a050:	e5d3c001 	ldrb	r12, [r3, #1]
 3f1a054:	e5d42008 	ldrb	r2, [r4, #8]
	}

	/* Print all primary/logical partitions */
	pt = (dos_partition_t *) (buffer + DOS_PART_TBL_OFFSET);
	for (i = 0; i < 4; i++, pt++) {
		/*
		 * fdisk does not show the extended partitions that
		 * are not in the MBR
		 */
		if ((pt->sys_ind != 0) &&
		    (part_num == which_part) &&
		    (is_extended(pt->sys_ind) == 0)) {
			info->blksz = 512;
			info->start = ext_part_sector + le32_to_int (pt->start4);
			info->size  = le32_to_int (pt->size4);
			switch(dev_desc->if_type) {
				case IF_TYPE_IDE:
				case IF_TYPE_ATAPI:
					sprintf (info->name, "hd%c%d\n", 'a' + dev_desc->dev, part_num);
					break;
				case IF_TYPE_SCSI:
					sprintf (info->name, "sd%c%d\n", 'a' + dev_desc->dev, part_num);
					break;
				case IF_TYPE_USB:
					sprintf (info->name, "usbd%c%d\n", 'a' + dev_desc->dev, part_num);
					break;
				case IF_TYPE_DOC:
					sprintf (info->name, "docd%c%d\n", 'a' + dev_desc->dev, part_num);
					break;
				default:
					sprintf (info->name, "xx%c%d\n", 'a' + dev_desc->dev, part_num);
					break;
			}
			/* sprintf(info->type, "%d, pt->sys_ind); */
			sprintf (info->type, "U-Boot");
			return 0;
		}

		/* Reverse engr the fdisk part# assignment rule! */
		if ((ext_part_sector == 0) ||
		    (pt->sys_ind != 0 && !is_extended (pt->sys_ind)) ) {
			part_num++;
		}
	}

	/* Follows the extended partitions */
	pt = (dos_partition_t *) (buffer + DOS_PART_TBL_OFFSET);
	for (i = 0; i < 4; i++, pt++) {
		if (is_extended (pt->sys_ind)) {
			int lba_start = le32_to_int (pt->start4) + relative;

			return get_partition_info_extended (dev_desc, lba_start,
 3f1a058:	e59b3004 	ldr	r3, [r11, #4]
 3f1a05c:	e1a00005 	mov	r0, r5
 3f1a060:	e58d7004 	str	r7, [r13, #4]
 3f1a064:	e35a0000 	cmp	r10, #0	; 0x0
 3f1a068:	e58d3000 	str	r3, [r13]
 3f1a06c:	e1a03006 	mov	r3, r6
 3f1a070:	e1a01801 	mov	r1, r1, lsl #16
 3f1a074:	e1811c0e 	orr	r1, r1, r14, lsl #24
 3f1a078:	e181140c 	orr	r1, r1, r12, lsl #8
 3f1a07c:	e0811002 	add	r1, r1, r2
 3f1a080:	e0811009 	add	r1, r1, r9
 3f1a084:	11a02009 	movne	r2, r9
 3f1a088:	01a02001 	moveq	r2, r1
 3f1a08c:	ebffffcc 	bl	3f19fc4 <get_partition_info_extended>
 3f1a090:	ea000083 	b	3f1a2a4 <get_partition_info_extended+0x2e0>
 3f1a094:	e24b4066 	sub	r4, r11, #102	; 0x66
 3f1a098:	e1a0c004 	mov	r12, r4
 3f1a09c:	e3a02000 	mov	r2, #0	; 0x0
 3f1a0a0:	e59b1004 	ldr	r1, [r11, #4]
 3f1a0a4:	e5d40004 	ldrb	r0, [r4, #4]
 3f1a0a8:	e1560001 	cmp	r6, r1
 3f1a0ac:	13a03000 	movne	r3, #0	; 0x0
 3f1a0b0:	03a03001 	moveq	r3, #1	; 0x1
 3f1a0b4:	e3500000 	cmp	r0, #0	; 0x0
 3f1a0b8:	03a03000 	moveq	r3, #0	; 0x0
 3f1a0bc:	e3530000 	cmp	r3, #0	; 0x0
 3f1a0c0:	0a000053 	beq	3f1a214 <get_partition_info_extended+0x250>
 3f1a0c4:	e5d43004 	ldrb	r3, [r4, #4]
 3f1a0c8:	e3a01000 	mov	r1, #0	; 0x0
 3f1a0cc:	e353000f 	cmp	r3, #15	; 0xf
 3f1a0d0:	13530005 	cmpne	r3, #5	; 0x5
 3f1a0d4:	0a000001 	beq	3f1a0e0 <get_partition_info_extended+0x11c>
 3f1a0d8:	e3530085 	cmp	r3, #133	; 0x85
 3f1a0dc:	1a000000 	bne	3f1a0e4 <get_partition_info_extended+0x120>
 3f1a0e0:	e3a01001 	mov	r1, #1	; 0x1
 3f1a0e4:	e3510000 	cmp	r1, #0	; 0x0
 3f1a0e8:	1a000049 	bne	3f1a214 <get_partition_info_extended+0x250>
 3f1a0ec:	e3a03c02 	mov	r3, #512	; 0x200
 3f1a0f0:	e5873008 	str	r3, [r7, #8]
 3f1a0f4:	e2842008 	add	r2, r4, #8	; 0x8
 3f1a0f8:	e5d23002 	ldrb	r3, [r2, #2]
 3f1a0fc:	e5d21003 	ldrb	r1, [r2, #3]
 3f1a100:	e5d20001 	ldrb	r0, [r2, #1]
 3f1a104:	e5d42008 	ldrb	r2, [r4, #8]
 3f1a108:	e1a03803 	mov	r3, r3, lsl #16
 3f1a10c:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f1a110:	e1833400 	orr	r3, r3, r0, lsl #8
 3f1a114:	e0833002 	add	r3, r3, r2
 3f1a118:	e08a3003 	add	r3, r10, r3
 3f1a11c:	e5873000 	str	r3, [r7]
 3f1a120:	e284200c 	add	r2, r4, #12	; 0xc
 3f1a124:	e5d23002 	ldrb	r3, [r2, #2]
 3f1a128:	e5d21003 	ldrb	r1, [r2, #3]
 3f1a12c:	e5d20001 	ldrb	r0, [r2, #1]
 3f1a130:	e5d4200c 	ldrb	r2, [r4, #12]
 3f1a134:	e1a03803 	mov	r3, r3, lsl #16
 3f1a138:	e1833c01 	orr	r3, r3, r1, lsl #24
 3f1a13c:	e1833400 	orr	r3, r3, r0, lsl #8
 3f1a140:	e0833002 	add	r3, r3, r2
 3f1a144:	e5873004 	str	r3, [r7, #4]
 3f1a148:	e5953000 	ldr	r3, [r5]
 3f1a14c:	e2433001 	sub	r3, r3, #1	; 0x1
 3f1a150:	e3530004 	cmp	r3, #4	; 0x4
 3f1a154:	979ff103 	ldrls	r15, [r15, r3, lsl #2]
 3f1a158:	ea00001a 	b	3f1a1c8 <get_partition_info_extended+0x204>
 3f1a15c:	03f1a170 	mvneqs	r10, #28	; 0x1c
 3f1a160:	03f1a184 	mvneqs	r10, #33	; 0x21
 3f1a164:	03f1a170 	mvneqs	r10, #28	; 0x1c
 3f1a168:	03f1a198 	mvneqs	r10, #38	; 0x26
 3f1a16c:	03f1a1ac 	mvneqs	r10, #43	; 0x2b
 3f1a170:	e287000c 	add	r0, r7, #12	; 0xc
 3f1a174:	e5952004 	ldr	r2, [r5, #4]
 3f1a178:	e1a03006 	mov	r3, r6
 3f1a17c:	e59f1078 	ldr	r1, [pc, #78]	; 3f1a1fc <get_partition_info_extended+0x238>
 3f1a180:	ea00000d 	b	3f1a1bc <get_partition_info_extended+0x1f8>
 3f1a184:	e287000c 	add	r0, r7, #12	; 0xc
 3f1a188:	e5952004 	ldr	r2, [r5, #4]
 3f1a18c:	e1a03006 	mov	r3, r6
 3f1a190:	e59f1068 	ldr	r1, [pc, #68]	; 3f1a200 <get_partition_info_extended+0x23c>
 3f1a194:	ea000008 	b	3f1a1bc <get_partition_info_extended+0x1f8>
 3f1a198:	e287000c 	add	r0, r7, #12	; 0xc
 3f1a19c:	e5952004 	ldr	r2, [r5, #4]
 3f1a1a0:	e1a03006 	mov	r3, r6
 3f1a1a4:	e59f1058 	ldr	r1, [pc, #58]	; 3f1a204 <get_partition_info_extended+0x240>
 3f1a1a8:	ea000003 	b	3f1a1bc <get_partition_info_extended+0x1f8>
 3f1a1ac:	e287000c 	add	r0, r7, #12	; 0xc
 3f1a1b0:	e5952004 	ldr	r2, [r5, #4]
 3f1a1b4:	e1a03006 	mov	r3, r6
 3f1a1b8:	e59f1048 	ldr	r1, [pc, #48]	; 3f1a208 <get_partition_info_extended+0x244>
 3f1a1bc:	e2822061 	add	r2, r2, #97	; 0x61
 3f1a1c0:	ebffd79d 	bl	3f1003c <sprintf>
 3f1a1c4:	ea000005 	b	3f1a1e0 <get_partition_info_extended+0x21c>
 3f1a1c8:	e287000c 	add	r0, r7, #12	; 0xc
 3f1a1cc:	e5952004 	ldr	r2, [r5, #4]
 3f1a1d0:	e1a03006 	mov	r3, r6
 3f1a1d4:	e59f1030 	ldr	r1, [pc, #30]	; 3f1a20c <get_partition_info_extended+0x248>
 3f1a1d8:	e2822061 	add	r2, r2, #97	; 0x61
 3f1a1dc:	ebffd796 	bl	3f1003c <sprintf>
 3f1a1e0:	e59f1028 	ldr	r1, [pc, #28]	; 3f1a210 <get_partition_info_extended+0x24c>
 3f1a1e4:	e287002c 	add	r0, r7, #44	; 0x2c
 3f1a1e8:	ebffd793 	bl	3f1003c <sprintf>
 3f1a1ec:	e3a00000 	mov	r0, #0	; 0x0
 3f1a1f0:	ea00002b 	b	3f1a2a4 <get_partition_info_extended+0x2e0>
 3f1a1f4:	03f202d8 	mvneqs	r0, #-2147483635	; 0x8000000d
 3f1a1f8:	03f20304 	mvneqs	r0, #268435456	; 0x10000000
 3f1a1fc:	03f2034c 	mvneqs	r0, #805306369	; 0x30000001
 3f1a200:	03f20354 	mvneqs	r0, #1342177281	; 0x50000001
 3f1a204:	03f2035c 	mvneqs	r0, #1879048193	; 0x70000001
 3f1a208:	03f20368 	mvneqs	r0, #-1610612735	; 0xa0000001
 3f1a20c:	03f20374 	mvneqs	r0, #-805306367	; 0xd0000001
 3f1a210:	03f2037c 	mvneqs	r0, #-268435455	; 0xf0000001
 3f1a214:	e35a0000 	cmp	r10, #0	; 0x0
 3f1a218:	0a00000b 	beq	3f1a24c <get_partition_info_extended+0x288>
 3f1a21c:	e31000ff 	tst	r0, #255	; 0xff
 3f1a220:	0a00000a 	beq	3f1a250 <get_partition_info_extended+0x28c>
 3f1a224:	e5d43004 	ldrb	r3, [r4, #4]
 3f1a228:	e3a01000 	mov	r1, #0	; 0x0
 3f1a22c:	e353000f 	cmp	r3, #15	; 0xf
 3f1a230:	13530005 	cmpne	r3, #5	; 0x5
 3f1a234:	0a000001 	beq	3f1a240 <get_partition_info_extended+0x27c>
 3f1a238:	e3530085 	cmp	r3, #133	; 0x85
 3f1a23c:	1a000000 	bne	3f1a244 <get_partition_info_extended+0x280>
 3f1a240:	e3a01001 	mov	r1, #1	; 0x1
 3f1a244:	e3510000 	cmp	r1, #0	; 0x0
 3f1a248:	1a000000 	bne	3f1a250 <get_partition_info_extended+0x28c>
 3f1a24c:	e2866001 	add	r6, r6, #1	; 0x1
 3f1a250:	e2822001 	add	r2, r2, #1	; 0x1
 3f1a254:	e2844010 	add	r4, r4, #16	; 0x10
 3f1a258:	e3520003 	cmp	r2, #3	; 0x3
 3f1a25c:	daffff8f 	ble	3f1a0a0 <get_partition_info_extended+0xdc>
 3f1a260:	e1a0400c 	mov	r4, r12
 3f1a264:	e3a02000 	mov	r2, #0	; 0x0
 3f1a268:	e5d43004 	ldrb	r3, [r4, #4]
 3f1a26c:	e3a01000 	mov	r1, #0	; 0x0
 3f1a270:	e353000f 	cmp	r3, #15	; 0xf
 3f1a274:	13530005 	cmpne	r3, #5	; 0x5
 3f1a278:	0a000001 	beq	3f1a284 <get_partition_info_extended+0x2c0>
 3f1a27c:	e3530085 	cmp	r3, #133	; 0x85
 3f1a280:	1a000000 	bne	3f1a288 <get_partition_info_extended+0x2c4>
 3f1a284:	e3a01001 	mov	r1, #1	; 0x1
 3f1a288:	e3510000 	cmp	r1, #0	; 0x0
 3f1a28c:	1affff6c 	bne	3f1a044 <get_partition_info_extended+0x80>
 3f1a290:	e2822001 	add	r2, r2, #1	; 0x1
 3f1a294:	e2844010 	add	r4, r4, #16	; 0x10
 3f1a298:	e3520003 	cmp	r2, #3	; 0x3
 3f1a29c:	dafffff1 	ble	3f1a268 <get_partition_info_extended+0x2a4>
				 ext_part_sector == 0 ? lba_start : relative,
				 part_num, which_part, info);
		}
	}
	return -1;
 3f1a2a0:	e3e00000 	mvn	r0, #0	; 0x0
}
 3f1a2a4:	e91baef0 	ldmdb	r11, {r4, r5, r6, r7, r9, r10, r11, r13, r15}

03f1a2a8 <print_part_dos>:
 3f1a2a8:	e1a0c00d 	mov	r12, r13
 3f1a2ac:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}

void print_part_dos (block_dev_desc_t *dev_desc)
{
 3f1a2b0:	e1a04000 	mov	r4, r0
	printf ("Partition     Start Sector     Num Sectors     Type\n");
 3f1a2b4:	e59f001c 	ldr	r0, [pc, #1c]	; 3f1a2d8 <print_part_dos+0x30>
 3f1a2b8:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f1a2bc:	ebffc960 	bl	3f0c844 <printf>
	print_partition_extended (dev_desc, 0, 0, 1);
 3f1a2c0:	e1a00004 	mov	r0, r4
 3f1a2c4:	e3a01000 	mov	r1, #0	; 0x0
 3f1a2c8:	e1a02001 	mov	r2, r1
 3f1a2cc:	e3a03001 	mov	r3, #1	; 0x1
 3f1a2d0:	ebfffecc 	bl	3f19e08 <print_partition_extended>
 3f1a2d4:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f1a2d8:	03f20384 	mvneqs	r0, #268435458	; 0x10000002

03f1a2dc <get_partition_info_dos>:
 3f1a2dc:	e1a0c00d 	mov	r12, r13
 3f1a2e0:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f1a2e4:	e24cb004 	sub	r11, r12, #4	; 0x4
}

int get_partition_info_dos (block_dev_desc_t *dev_desc, int part, disk_partition_t * info)
{
	return get_partition_info_extended (dev_desc, 0, 0, 1, part, info);
 3f1a2e8:	e3a03001 	mov	r3, #1	; 0x1
 3f1a2ec:	e24dd008 	sub	r13, r13, #8	; 0x8
 3f1a2f0:	e58d1000 	str	r1, [r13]
 3f1a2f4:	e3a01000 	mov	r1, #0	; 0x0
 3f1a2f8:	e58d2004 	str	r2, [r13, #4]
 3f1a2fc:	e1a02001 	mov	r2, r1
 3f1a300:	ebffff2f 	bl	3f19fc4 <get_partition_info_extended>
 3f1a304:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1a308 <GregorianDay>:
 3f1a308:	e1a0c00d 	mov	r12, r13
 3f1a30c:	e92dd8f0 	stmdb	r13!, {r4, r5, r6, r7, r11, r12, r14, r15}
 3f1a310:	e24cb004 	sub	r11, r12, #4	; 0x4
/*
 * This only works for the Gregorian calendar - i.e. after 1752 (in the UK)
 */
void GregorianDay(struct rtc_time * tm)
{
 3f1a314:	e1a04000 	mov	r4, r0
	int leapsToDate;
	int lastYear;
	int day;
	int MonthOffset[] = { 0,31,59,90,120,151,181,212,243,273,304,334 };
 3f1a318:	e24b704c 	sub	r7, r11, #76	; 0x4c
 3f1a31c:	e59fe0e8 	ldr	r14, [pc, #e8]	; 3f1a40c <GregorianDay+0x104>
 3f1a320:	e1a0c007 	mov	r12, r7
 3f1a324:	e8be000f 	ldmia	r14!, {r0, r1, r2, r3}
 3f1a328:	e24dd030 	sub	r13, r13, #48	; 0x30
 3f1a32c:	e8ac000f 	stmia	r12!, {r0, r1, r2, r3}
 3f1a330:	e8be000f 	ldmia	r14!, {r0, r1, r2, r3}
 3f1a334:	e8ac000f 	stmia	r12!, {r0, r1, r2, r3}
 3f1a338:	e89e000f 	ldmia	r14, {r0, r1, r2, r3}
 3f1a33c:	e88c000f 	stmia	r12, {r0, r1, r2, r3}

	lastYear=tm->tm_year-1;
 3f1a340:	e594e014 	ldr	r14, [r4, #20]

	/*
	 * Number of leap corrections to apply up to end of last year
	 */
	leapsToDate = lastYear/4 - lastYear/100 + lastYear/400;
 3f1a344:	e59f50c4 	ldr	r5, [pc, #c4]	; 3f1a410 <GregorianDay+0x108>
 3f1a348:	e24ec001 	sub	r12, r14, #1	; 0x1
 3f1a34c:	e0c13c95 	smull	r3, r1, r5, r12
 3f1a350:	e35c0000 	cmp	r12, #0	; 0x0
 3f1a354:	b28c0003 	addlt	r0, r12, #3	; 0x3
 3f1a358:	a1a0000c 	movge	r0, r12

	/*
	 * This year is a leap year if it is divisible by 4 except when it is
	 * divisible by 100 unless it is divisible by 400
	 *
	 * e.g. 1904 was a leap year, 1900 was not, 1996 is, and 2000 will be
	 */
	if((tm->tm_year%4==0) &&
 3f1a35c:	e31e0003 	tst	r14, #3	; 0x3
 3f1a360:	e1a02fcc 	mov	r2, r12, asr #31
 3f1a364:	e06232c1 	rsb	r3, r2, r1, asr #5
 3f1a368:	e0633140 	rsb	r3, r3, r0, asr #2
 3f1a36c:	e06223c1 	rsb	r2, r2, r1, asr #7
 3f1a370:	e0836002 	add	r6, r3, r2
 3f1a374:	1a00000f 	bne	3f1a3b8 <GregorianDay+0xb0>
 3f1a378:	e0c13e95 	smull	r3, r1, r5, r14
 3f1a37c:	e1a02fce 	mov	r2, r14, asr #31
 3f1a380:	e06232c1 	rsb	r3, r2, r1, asr #5
 3f1a384:	e0833103 	add	r3, r3, r3, lsl #2
 3f1a388:	e0833103 	add	r3, r3, r3, lsl #2
 3f1a38c:	e15e0103 	cmp	r14, r3, lsl #2
 3f1a390:	1a000004 	bne	3f1a3a8 <GregorianDay+0xa0>
 3f1a394:	e06233c1 	rsb	r3, r2, r1, asr #7
 3f1a398:	e0833103 	add	r3, r3, r3, lsl #2
 3f1a39c:	e0833103 	add	r3, r3, r3, lsl #2
 3f1a3a0:	e15e0203 	cmp	r14, r3, lsl #4
 3f1a3a4:	1a000003 	bne	3f1a3b8 <GregorianDay+0xb0>
 3f1a3a8:	e5943010 	ldr	r3, [r4, #16]
	   ((tm->tm_year%100!=0) || (tm->tm_year%400==0)) &&
	   (tm->tm_mon>2)) {
		/*
		 * We are past Feb. 29 in a leap year
		 */
		day=1;
 3f1a3ac:	e3a00001 	mov	r0, #1	; 0x1
 3f1a3b0:	e3530002 	cmp	r3, #2	; 0x2
 3f1a3b4:	ca000000 	bgt	3f1a3bc <GregorianDay+0xb4>
	} else {
		day=0;
 3f1a3b8:	e3a00000 	mov	r0, #0	; 0x0
	}

	day += lastYear*365 + leapsToDate + MonthOffset[tm->tm_mon-1] + tm->tm_mday;
 3f1a3bc:	e08c318c 	add	r3, r12, r12, lsl #3
 3f1a3c0:	e08c3183 	add	r3, r12, r3, lsl #3
 3f1a3c4:	e5942010 	ldr	r2, [r4, #16]
 3f1a3c8:	e0833103 	add	r3, r3, r3, lsl #2
 3f1a3cc:	e2422001 	sub	r2, r2, #1	; 0x1
 3f1a3d0:	e7971102 	ldr	r1, [r7, r2, lsl #2]
 3f1a3d4:	e0833006 	add	r3, r3, r6
 3f1a3d8:	e594200c 	ldr	r2, [r4, #12]
 3f1a3dc:	e0833001 	add	r3, r3, r1
 3f1a3e0:	e0833002 	add	r3, r3, r2

	tm->tm_wday=day%7;
 3f1a3e4:	e59f2028 	ldr	r2, [pc, #28]	; 3f1a414 <GregorianDay+0x10c>
 3f1a3e8:	e0800003 	add	r0, r0, r3
 3f1a3ec:	e0c23290 	smull	r3, r2, r0, r2
 3f1a3f0:	e1a03fc0 	mov	r3, r0, asr #31
 3f1a3f4:	e0822000 	add	r2, r2, r0
 3f1a3f8:	e0633142 	rsb	r3, r3, r2, asr #2
 3f1a3fc:	e0633183 	rsb	r3, r3, r3, lsl #3
 3f1a400:	e0633000 	rsb	r3, r3, r0
 3f1a404:	e5843018 	str	r3, [r4, #24]
 3f1a408:	ea000002 	b	3f1a418 <GregorianDay+0x110>
 3f1a40c:	03f203bc 	mvneqs	r0, #-268435454	; 0xf0000002
 3f1a410:	51eb851f 	mvnpl	r8, r15, lsl r5
 3f1a414:	92492493 	subls	r2, r9, #-1828716544	; 0x93000000
}
 3f1a418:	e91ba8f0 	ldmdb	r11, {r4, r5, r6, r7, r11, r13, r15}

03f1a41c <to_tm>:

void to_tm(int tim, struct rtc_time * tm)
{
	register int    i;
	register long   hms, day;

	day = tim / SECDAY;
 3f1a41c:	e59f3124 	ldr	r3, [pc, #124]	; 3f1a548 <to_tm+0x12c>
 3f1a420:	e0c32390 	smull	r2, r3, r0, r3
 3f1a424:	e1a0c00d 	mov	r12, r13
 3f1a428:	e92dd870 	stmdb	r13!, {r4, r5, r6, r11, r12, r14, r15}
 3f1a42c:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f1a430:	e1a02fc0 	mov	r2, r0, asr #31
 3f1a434:	e0833000 	add	r3, r3, r0
 3f1a438:	e062e843 	rsb	r14, r2, r3, asr #16
	hms = tim % SECDAY;
 3f1a43c:	e08e308e 	add	r3, r14, r14, lsl #1
 3f1a440:	e0633203 	rsb	r3, r3, r3, lsl #4
 3f1a444:	e0633203 	rsb	r3, r3, r3, lsl #4

	/* Hours, minutes, seconds are easy */
	tm->tm_hour = hms / 3600;
 3f1a448:	e59f20fc 	ldr	r2, [pc, #fc]	; 3f1a54c <to_tm+0x130>
 3f1a44c:	e0400383 	sub	r0, r0, r3, lsl #7
 3f1a450:	e0c3c092 	smull	r12, r3, r2, r0
 3f1a454:	e1a02fc0 	mov	r2, r0, asr #31
	tm->tm_min = (hms % 3600) / 60;
 3f1a458:	e59fc0f0 	ldr	r12, [pc, #f0]	; 3f1a550 <to_tm+0x134>
 3f1a45c:	e0833000 	add	r3, r3, r0
 3f1a460:	e06225c3 	rsb	r2, r2, r3, asr #11
 3f1a464:	e0623202 	rsb	r3, r2, r2, lsl #4
 3f1a468:	e0633203 	rsb	r3, r3, r3, lsl #4
 3f1a46c:	e0400203 	sub	r0, r0, r3, lsl #4
 3f1a470:	e0cc3c90 	smull	r3, r12, r0, r12
	tm->tm_sec = (hms % 3600) % 60;

	/* Number of years in days */
	for (i = STARTOFTIME; day >= days_in_year(i); i++) {
 3f1a474:	e59f40d8 	ldr	r4, [pc, #d8]	; 3f1a554 <to_tm+0x138>
 3f1a478:	e1a03fc0 	mov	r3, r0, asr #31
 3f1a47c:	e5812008 	str	r2, [r1, #8]
 3f1a480:	e08cc000 	add	r12, r12, r0
 3f1a484:	e06332cc 	rsb	r3, r3, r12, asr #5
 3f1a488:	e5813004 	str	r3, [r1, #4]
 3f1a48c:	e0633203 	rsb	r3, r3, r3, lsl #4
 3f1a490:	e0400103 	sub	r0, r0, r3, lsl #2
 3f1a494:	e5810000 	str	r0, [r1]
 3f1a498:	ea000005 	b	3f1a4b4 <to_tm+0x98>
		day -= days_in_year(i);
 3f1a49c:	e3520000 	cmp	r2, #0	; 0x0
 3f1a4a0:	024eef5b 	subeq	r14, r14, #364	; 0x16c
 3f1a4a4:	024ee002 	subeq	r14, r14, #2	; 0x2
 3f1a4a8:	124eef5b 	subne	r14, r14, #364	; 0x16c
 3f1a4ac:	124ee001 	subne	r14, r14, #1	; 0x1
 3f1a4b0:	e2844001 	add	r4, r4, #1	; 0x1
 3f1a4b4:	e2142003 	ands	r2, r4, #3	; 0x3
 3f1a4b8:	1a000002 	bne	3f1a4c8 <to_tm+0xac>
 3f1a4bc:	e59f3094 	ldr	r3, [pc, #94]	; 3f1a558 <to_tm+0x13c>
 3f1a4c0:	e15e0003 	cmp	r14, r3
 3f1a4c4:	ea000000 	b	3f1a4cc <to_tm+0xb0>
 3f1a4c8:	e35e0f5b 	cmp	r14, #364	; 0x16c
 3f1a4cc:	cafffff2 	bgt	3f1a49c <to_tm+0x80>
	}
	tm->tm_year = i;

	/* Number of months in days left */
	if (leapyear(tm->tm_year)) {
 3f1a4d0:	e3520000 	cmp	r2, #0	; 0x0
 3f1a4d4:	e5814014 	str	r4, [r1, #20]
		days_in_month(FEBRUARY) = 29;
 3f1a4d8:	059f207c 	ldreq	r2, [pc, #7c]	; 3f1a55c <to_tm+0x140>
 3f1a4dc:	03a0301d 	moveq	r3, #29	; 0x1d
 3f1a4e0:	05823004 	streq	r3, [r2, #4]
	}
	for (i = 1; day >= days_in_month(i); i++) {
 3f1a4e4:	e3a04001 	mov	r4, #1	; 0x1
 3f1a4e8:	e59f506c 	ldr	r5, [pc, #6c]	; 3f1a55c <to_tm+0x140>
 3f1a4ec:	e244c001 	sub	r12, r4, #1	; 0x1
 3f1a4f0:	e795300c 	ldr	r3, [r5, r12]
 3f1a4f4:	e1a06005 	mov	r6, r5
 3f1a4f8:	e15e0003 	cmp	r14, r3
 3f1a4fc:	ba000009 	blt	3f1a528 <to_tm+0x10c>
 3f1a500:	e1a0000c 	mov	r0, r12
 3f1a504:	e2800004 	add	r0, r0, #4	; 0x4
 3f1a508:	e2844001 	add	r4, r4, #1	; 0x1
		day -= days_in_month(i);
 3f1a50c:	e1a03006 	mov	r3, r6
 3f1a510:	e796210c 	ldr	r2, [r6, r12, lsl #2]
 3f1a514:	e244c001 	sub	r12, r4, #1	; 0x1
 3f1a518:	e7933000 	ldr	r3, [r3, r0]
 3f1a51c:	e062e00e 	rsb	r14, r2, r14
 3f1a520:	e15e0003 	cmp	r14, r3
 3f1a524:	aafffff6 	bge	3f1a504 <to_tm+0xe8>
	}
	days_in_month(FEBRUARY) = 28;
 3f1a528:	e3a0301c 	mov	r3, #28	; 0x1c
 3f1a52c:	e5853004 	str	r3, [r5, #4]
	tm->tm_mon = i;

	/* Days are what is left over (+1) from all that. */
	tm->tm_mday = day + 1;
 3f1a530:	e28e3001 	add	r3, r14, #1	; 0x1
 3f1a534:	e5814010 	str	r4, [r1, #16]

	/*
	 * Determine the day of week
	 */
	GregorianDay(tm);
 3f1a538:	e1a00001 	mov	r0, r1
 3f1a53c:	e581300c 	str	r3, [r1, #12]
 3f1a540:	ebffff70 	bl	3f1a308 <GregorianDay>
}
 3f1a544:	e91ba870 	ldmdb	r11, {r4, r5, r6, r11, r13, r15}
 3f1a548:	c22e4507 	eorgt	r4, r14, #29360128	; 0x1c00000
 3f1a54c:	91a2b3c5 	movls	r11, r5, asr #7
 3f1a550:	88888889 	stmhiia	r8, {r0, r3, r7, r11, r15}
 3f1a554:	000007b2 	streqh	r0, [r0], -r2
 3f1a558:	0000016d 	andeq	r0, r0, r13, ror #2
 3f1a55c:	03f6a1c0 	mvneqs	r10, #48	; 0x30

03f1a560 <mktime>:
 3f1a560:	e1a0c00d 	mov	r12, r13
 3f1a564:	e92dd810 	stmdb	r13!, {r4, r11, r12, r14, r15}
 3f1a568:	e24cb004 	sub	r11, r12, #4	; 0x4

/* Converts Gregorian date to seconds since 1970-01-01 00:00:00.
 * Assumes input in normal date format, i.e. 1980-12-31 23:59:59
 * => year=1980, mon=12, day=31, hour=23, min=59, sec=59.
 *
 * [For the Julian calendar (which was used in Russia before 1917,
 * Britain & colonies before 1752, anywhere else before 1582,
 * and is still in use by some communities) leave out the
 * -year/100+year/400 terms, and add 10.]
 *
 * This algorithm was first published by Gauss (I think).
 *
 * WARNING: this function will overflow on 2106-02-07 06:28:16 on
 * machines were long is 32-bit! (However, as time_t is signed, we
 * will already get problems at other places on 2038-01-19 03:14:08)
 */
unsigned long
mktime (unsigned int year, unsigned int mon,
	unsigned int day, unsigned int hour,
	unsigned int min, unsigned int sec)
{
 3f1a56c:	e1a0c000 	mov	r12, r0
	if (0 >= (int) (mon -= 2)) {	/* 1..12 -> 11,12,1..10 */
 3f1a570:	e2411002 	sub	r1, r1, #2	; 0x2
 3f1a574:	e1a0e002 	mov	r14, r2
 3f1a578:	e1a04003 	mov	r4, r3
 3f1a57c:	e3510000 	cmp	r1, #0	; 0x0
		mon += 12;		/* Puts Feb last since it has leap day */
 3f1a580:	d281100c 	addle	r1, r1, #12	; 0xc
		year -= 1;
 3f1a584:	d24cc001 	suble	r12, r12, #1	; 0x1
	}

	return (((
 3f1a588:	e59f3064 	ldr	r3, [pc, #64]	; 3f1a5f4 <mktime+0x94>
 3f1a58c:	e0802c93 	umull	r2, r0, r3, r12
 3f1a590:	e0813081 	add	r3, r1, r1, lsl #1
 3f1a594:	e0613183 	rsb	r3, r1, r3, lsl #3
 3f1a598:	e59f2058 	ldr	r2, [pc, #58]	; 3f1a5f8 <mktime+0x98>
 3f1a59c:	e0613203 	rsb	r3, r1, r3, lsl #4
 3f1a5a0:	e0831392 	umull	r1, r3, r2, r3
 3f1a5a4:	e59f1050 	ldr	r1, [pc, #50]	; 3f1a5fc <mktime+0x9c>
 3f1a5a8:	e1a022a0 	mov	r2, r0, lsr #5
 3f1a5ac:	e062212c 	rsb	r2, r2, r12, lsr #2
 3f1a5b0:	e08223a0 	add	r2, r2, r0, lsr #7
 3f1a5b4:	e59b0004 	ldr	r0, [r11, #4]
 3f1a5b8:	e08221a3 	add	r2, r2, r3, lsr #3
 3f1a5bc:	e082200e 	add	r2, r2, r14
 3f1a5c0:	e08c318c 	add	r3, r12, r12, lsl #3
 3f1a5c4:	e08c3183 	add	r3, r12, r3, lsl #3
 3f1a5c8:	e0833103 	add	r3, r3, r3, lsl #2
 3f1a5cc:	e0822003 	add	r2, r2, r3
 3f1a5d0:	e0821001 	add	r1, r2, r1
 3f1a5d4:	e0811081 	add	r1, r1, r1, lsl #1
 3f1a5d8:	e0841181 	add	r1, r4, r1, lsl #3
 3f1a5dc:	e0611201 	rsb	r1, r1, r1, lsl #4
 3f1a5e0:	e0800101 	add	r0, r0, r1, lsl #2
 3f1a5e4:	e59b3008 	ldr	r3, [r11, #8]
 3f1a5e8:	e0600200 	rsb	r0, r0, r0, lsl #4
 3f1a5ec:	e0830100 	add	r0, r3, r0, lsl #2
 3f1a5f0:	e91ba810 	ldmdb	r11, {r4, r11, r13, r15}
 3f1a5f4:	51eb851f 	mvnpl	r8, r15, lsl r5
 3f1a5f8:	aaaaaaab 	bge	29c50ac <*ABS*+0x29c50ac>
 3f1a5fc:	fff50575 	swinv	0x00f50575

03f1a600 <rtc_get>:
 3f1a600:	e1a0c00d 	mov	r12, r13
 3f1a604:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f1a608:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f1a60c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1a610 <rtc_set>:
 3f1a610:	e1a0c00d 	mov	r12, r13
 3f1a614:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f1a618:	e24cb004 	sub	r11, r12, #4	; 0x4
 3f1a61c:	e91ba800 	ldmdb	r11, {r11, r13, r15}

03f1a620 <rtc_reset>:
 3f1a620:	e1a0c00d 	mov	r12, r13
 3f1a624:	e92dd800 	stmdb	r13!, {r11, r12, r14, r15}
 3f1a628:	e24cb004 	sub	r11, r12, #4	; 0x4
	return (MMSP20_GPIO * const)MMSP20_GPIO_BASE;
}
static inline MMSP20_RTC * const MMSP20_GetBase_RTC(void)
{
	return (MMSP20_RTC * const)MMSP20_RTC_BASE;
 3f1a62c:	e59f2008 	ldr	r2, [pc, #8]	; 3f1a63c <rtc_reset+0x1c>
void rtc_reset (void)
{
	MMSP20_RTC * const rtc = MMSP20_GetBase_RTC();

	rtc->RTCTSETREG = 0x00000000;
 3f1a630:	e3a03000 	mov	r3, #0	; 0x0
 3f1a634:	e5823000 	str	r3, [r2]
}
 3f1a638:	e91ba800 	ldmdb	r11, {r11, r13, r15}
 3f1a63c:	c0000c00 	andgt	r0, r0, r0, lsl #24

03f1a640 <__divsi3>:
 3f1a640:	e020c001 	eor	r12, r0, r1
 3f1a644:	e3a03001 	mov	r3, #1	; 0x1
 3f1a648:	e3a02000 	mov	r2, #0	; 0x0
 3f1a64c:	e3510000 	cmp	r1, #0	; 0x0
 3f1a650:	42611000 	rsbmi	r1, r1, #0	; 0x0
 3f1a654:	0a000021 	beq	3f1a6e0 <Ldiv0>
 3f1a658:	e3500000 	cmp	r0, #0	; 0x0
 3f1a65c:	42600000 	rsbmi	r0, r0, #0	; 0x0
 3f1a660:	e1500001 	cmp	r0, r1
 3f1a664:	3a000019 	bcc	3f1a6d0 <Lgot_result>

03f1a668 <Loop1>:
 3f1a668:	e3510201 	cmp	r1, #268435456	; 0x10000000
 3f1a66c:	31510000 	cmpcc	r1, r0
 3f1a670:	31a01201 	movcc	r1, r1, lsl #4
 3f1a674:	31a03203 	movcc	r3, r3, lsl #4
 3f1a678:	3afffffa 	bcc	3f1a668 <Loop1>

03f1a67c <Lbignum>:
 3f1a67c:	e3510102 	cmp	r1, #-2147483648	; 0x80000000
 3f1a680:	31510000 	cmpcc	r1, r0
 3f1a684:	31a01081 	movcc	r1, r1, lsl #1
 3f1a688:	31a03083 	movcc	r3, r3, lsl #1
 3f1a68c:	3afffffa 	bcc	3f1a67c <Lbignum>

03f1a690 <Loop3>:
 3f1a690:	e1500001 	cmp	r0, r1
 3f1a694:	20400001 	subcs	r0, r0, r1
 3f1a698:	21822003 	orrcs	r2, r2, r3
 3f1a69c:	e15000a1 	cmp	r0, r1, lsr #1
 3f1a6a0:	204000a1 	subcs	r0, r0, r1, lsr #1
 3f1a6a4:	218220a3 	orrcs	r2, r2, r3, lsr #1
 3f1a6a8:	e1500121 	cmp	r0, r1, lsr #2
 3f1a6ac:	20400121 	subcs	r0, r0, r1, lsr #2
 3f1a6b0:	21822123 	orrcs	r2, r2, r3, lsr #2
 3f1a6b4:	e15001a1 	cmp	r0, r1, lsr #3
 3f1a6b8:	204001a1 	subcs	r0, r0, r1, lsr #3
 3f1a6bc:	218221a3 	orrcs	r2, r2, r3, lsr #3
 3f1a6c0:	e3500000 	cmp	r0, #0	; 0x0
 3f1a6c4:	11b03223 	movnes	r3, r3, lsr #4
 3f1a6c8:	11a01221 	movne	r1, r1, lsr #4
 3f1a6cc:	1affffef 	bne	3f1a690 <Loop3>

03f1a6d0 <Lgot_result>:
 3f1a6d0:	e1a00002 	mov	r0, r2
 3f1a6d4:	e35c0000 	cmp	r12, #0	; 0x0
 3f1a6d8:	42600000 	rsbmi	r0, r0, #0	; 0x0
 3f1a6dc:	e1a0f00e 	mov	r15, r14

03f1a6e0 <Ldiv0>:
 3f1a6e0:	e52de004 	str	r14, [r13, -#4]!
 3f1a6e4:	ebffe390 	bl	3f1352c <__div0>
 3f1a6e8:	e3a00000 	mov	r0, #0	; 0x0
 3f1a6ec:	e8bd8000 	ldmia	r13!, {r15}
Disassembly of section .glue_7:
Disassembly of section .glue_7t:
