5. Das U-Boot
5.9. U-Boot Command Line Interface
5.9.2. Memory Commands
5.9.2.1. base - print or set address offset
=> help basebase
- print address offset for memory commands base off
- set address offset for memory commands to 'off'
=>
You can use the base command (short: ba) to print or set a "base address" that is used as address offset for all memory commands; the default value of the base address is 0, so all addresses you enter are used
unmodified. However, when you repeatedly have to access a certain memory region (like the internal memory of some embedded Power Architecture® processors) it can be very convenient to set the base address to the start of this area and then use only the offsets:
=> base
Base Address: 0x00000000 => md 0 c
00000000: 5d557d47 efeaa2ee 779fdd75 bfa74abb ]U}G....w..u..J. 00000010: cd3d556d 7ee66b2b 95553135 c97ffbfb .=Um~.k+.U15.... 00000020: f79ff547 7a8fb6ff dcb7d75f bfbdba4b ...Gz..._...K => base 100000
Base Address: 0x00100000 => md 0 c
00100000: 27051956 56e38816 4327e555 0000009e '..VV...C'.U.... 00100010: 00000000 00000000 f54c21db 05070600 ...L!... 00100020: 6175746f 73637220 6578616d 706c6520 autoscr example =>
5.9.2.2. crc32 - checksum calculation
The crc32 command (short: crc) can be used to caculate a CRC32 checksum over a range of memory: => crc 100004 3FC
CRC32 for 00100004 ... 001003ff ==> e1e8cd20 =>
When used with 3 arguments, the command stores the calculated checksum at the given address: => crc 100004 3FC 100000
CRC32 for 00100004 ... 001003ff ==> e1e8cd20 => md 100000 4
00100000: e1e8cd20 56e38816 4327e555 0000009e ... V...C'.U.... =>
As you can see, the CRC32 checksum was not only printed, but also stored at address 0x100000.
5.9.2.3. cmp - memory compare
=> help cmp
cmp [.b, .w, .l] addr1 addr2 count - compare memory
=>
With the cmp command you can test of the contents of two memory areas is identical or not. The command will either test the whole area as specified by the 3rd (length) argument, or stop at the first difference. => cmp 100000 200000 400
word at 0x00100000 (0xe1e8cd20) != word at 0x00200000 (0x27051956) Total of 0 words were the same
=> md 100000 C
00100000: e1e8cd20 56e38816 4327e555 0000009e ... V...C'.U.... 00100010: 00000000 00000000 f54c21db 05070600 ...L!... 00100020: 6175746f 73637220 6578616d 706c6520 autoscr example => md 200000 C
00200000: 27051956 cbe03a2e 43291ff6 0011d870 '..V..:.C)...p 00200010: 00000000 00000000 5176f8b7 05070201 ...Qv... 00200020: 4c696e75 782d322e 362e3133 00000000 Linux-2.6.13.... =>
Like most memory commands the cmp can access the memory in different sizes: as 32 bit (long word), 16 bit (word) or 8 bit (byte) data. If invoked just as cmp the default size (32 bit or long words) is used; the same can be selected explicitely by typing cmp.l instead. If you want to access memory as 16 bit or word data, you can use the variant cmp.w instead; and to access memory as 8 bit or byte data please use cmp.b.
Please note that the count argument specifies the number of data items to process, i. e. the number of long words or words or bytes to compare.
=> cmp.l 100000 200000 400
word at 0x00100000 (0xe1e8cd20) != word at 0x00200000 (0x27051956) Total of 0 words were the same
=> cmp.w 100000 200000 800
halfword at 0x00100000 (0xe1e8) != halfword at 0x00200000 (0x2705) Total of 0 halfwords were the same
=> cmp.b 100000 200000 1000
byte at 0x00100000 (0xe1) != byte at 0x00200000 (0x27) Total of 0 bytes were the same
=>
5.9.2.4. cp - memory copy
=> help cpcp [.b, .w, .l] source target count - copy memory
=>
The cp is used to copy memory areas. => cp 200000 100000 10000
=>
The cp understands the type extensions .l, .w and .b : => cp.l 200000 100000 10000 => cp.w 200000 100000 20000 => cp.b 200000 100000 40000 =>
5.9.2.5. md - memory display
=> help md md [.b, .w, .l] address [# of objects] - memory display =>The md can be used to display memory contents both as hexadecimal and ASCII data. => md 100000
00100000: 27051956 cbe03a2e 43291ff6 0011d870 '..V..:.C)...p 00100010: 00000000 00000000 5176f8b7 05070201 ...Qv... 00100020: 4c696e75 782d322e 362e3133 00000000 Linux-2.6.13.... =>
00100030: 00000000 00000000 00000000 00000000 ... 00100040: 1f8b0800 f51f2943 0203d45a 7f501457 ...)C...Z.P.W 00100050: 9efff6cc 00c30fcf 5189e102 177b0422 ...Q....{." =>
00100060: 44623031 773d61d0 06c9a605 760fe270 Db01w=a...v..p 00100070: b289e69a 1b302a24 1937a4ae b3dbedf4 ...0*$.7...
00100080: 0c9842c1 bde18755 6a92dd41 618e4493 ..B....Uj..Aa.D. =>
This command, too, can be used with the type extensions .l, .w and .b : => md.w 100000 00100000: 2705 1956 cbe0 3a2e 4329 1ff6 0011 d870 '..V..:.C)...p 00100010: 0000 0000 0000 0000 ... => md.b 100000 00100000: 27 05 19 56 cb e0 3a 2e 43 29 1f f6 '..V..:.C).. =>
The last displayed memory address and the value of the count argument are remembered, so when you enter
md again without arguments it will automatically continue at the next address, and use the same count again. => md.b 100000 20 00100000: 27 05 19 56 cb e0 3a 2e 43 29 1f f6 00 11 d8 70 '..V..:.C)...p 00100010: 00 00 00 00 00 00 00 00 51 76 f8 b7 05 07 02 01 ...Qv... => md.w 100000 00100000: 2705 1956 cbe0 3a2e 4329 1ff6 0011 d870 '..V..:.C)...p 00100010: 0000 0000 0000 0000 5176 f8b7 0507 0201 ...Qv... 00100020: 4c69 6e75 782d 322e 362e 3133 0000 0000 Linux-2.6.13.... 00100030: 0000 0000 0000 0000 0000 0000 0000 0000 ... => md 100000
00100000: 27051956 cbe03a2e 43291ff6 0011d870 '..V..:.C)...p 00100010: 00000000 00000000 5176f8b7 05070201 ...Qv... 00100020: 4c696e75 782d322e 362e3133 00000000 Linux-2.6.13.... 00100030: 00000000 00000000 00000000 00000000 ... 00100040: 1f8b0800 f51f2943 0203d45a 7f501457 ...)C...Z.P.W 00100050: 9efff6cc 00c30fcf 5189e102 177b0422 ...Q....{." 00100060: 44623031 773d61d0 06c9a605 760fe270 Db01w=a...v..p 00100070: b289e69a 1b302a24 1937a4ae b3dbedf4 ...0*$.7... =>
5.9.2.6. mm - memory modify (auto-incrementing)
=> help mmmm [.b, .w, .l] address
- memory modify, auto increment address
=>
The mm is a method to interactively modify memory contents. It will display the address and current contents and then prompt for user input. If you enter a legal hexadecimal number, this new value will be written to the address. Then the next address will be prompted. If you don't enter any value and just press ENTER, then the contents of this address will remain unchanged. The command stops as soon as you enter any data that is not a hex number (like .):
=> mm 100000 00100000: 27051956 ? 0 00100004: cbe03a2e ? aabbccdd 00100008: 43291ff6 ? 01234567 0010000c: 0011d870 ? . => md 100000 10 00100000: 00000000 aabbccdd 01234567 0011d870 ...#Eg...p 00100010: 00000000 00000000 5176f8b7 05070201 ...Qv... 00100020: 4c696e75 782d322e 362e3133 00000000 Linux-2.6.13.... 00100030: 00000000 00000000 00000000 00000000 ... =>
Again this command can be used with the type extensions .l, .w and .b :
=> mm.w 100000 00100000: 0000 ? 0101 00100002: 0000 ? 0202 00100004: aabb ? 4321 00100006: ccdd ? 8765 00100008: 0123 ? . => md 100000 10 00100000: 01010202 43218765 01234567 0011d870 ....C!.e.#Eg...p 00100010: 00000000 00000000 5176f8b7 05070201 ...Qv... 00100020: 4c696e75 782d322e 362e3133 00000000 Linux-2.6.13.... 00100030: 00000000 00000000 00000000 00000000 ... => => mm.b 100000 00100000: 01 ? 48 00100001: 01 ? 65 00100002: 02 ? 6c 00100003: 02 ? 6c 00100004: 43 ? 6f 00100005: 21 ? 20 00100006: 87 ? 20 00100007: 65 ? 20 00100008: 01 ? . => md 100000 10 00100000: 48656c6c 6f202020 01234567 0011d870 Hello .#Eg...p 00100010: 00000000 00000000 5176f8b7 05070201 ...Qv... 00100020: 4c696e75 782d322e 362e3133 00000000 Linux-2.6.13.... 00100030: 00000000 00000000 00000000 00000000 ... =>
5.9.2.7. mtest - simple RAM test
=> help mtestmtest [start [end [pattern]]] - simple RAM read/write test
=>
The mtest provides a simple memory test. => mtest 100000 200000
Pattern 00000000 Writing... Reading... =>
This tests writes to memory, thus modifying the memory contents. It will fail when applied to ROM or flash memory.
This command may crash the system when the tested memory range includes areas that are needed for the operation of the U-Boot firnware (like exception vector code, or U-Boot's internal program code, stack or heap memory areas).
5.9.2.8. mw - memory write (fill)
=> help mwmw [.b, .w, .l] address value [count] - write memory
=>
The mw is a way to initialize (fill) memory with some value. When called without a count argument, the value will be written only to the specified address. When used with a count, then a whole memory areas will be
initialized with this value: => md 100000 10 00100000: 0000000f 00000010 00000011 00000012 ... 00100010: 00000013 00000014 00000015 00000016 ... 00100020: 00000017 00000018 00000019 0000001a ... 00100030: 0000001b 0000001c 0000001d 0000001e ... => mw 100000 aabbccdd => md 100000 10 00100000: aabbccdd 00000010 00000011 00000012 ... 00100010: 00000013 00000014 00000015 00000016 ... 00100020: 00000017 00000018 00000019 0000001a ... 00100030: 0000001b 0000001c 0000001d 0000001e ... => mw 100000 0 6 => md 100000 10 00100000: 00000000 00000000 00000000 00000000 ... 00100010: 00000000 00000000 00000015 00000016 ... 00100020: 00000017 00000018 00000019 0000001a ... 00100030: 0000001b 0000001c 0000001d 0000001e ... =>
This is another command that accepts the type extensions .l, .w and .b : => mw.w 100004 1155 6 => md 100000 10 00100000: 00000000 11551155 11551155 11551155 ...U.U.U.U.U.U 00100010: 00000000 00000000 00000015 00000016 ... 00100020: 00000017 00000018 00000019 0000001a ... 00100030: 0000001b 0000001c 0000001d 0000001e ... => mw.b 100007 ff 7 => md 100000 10 00100000: 00000000 115511ff ffffffff ffff1155 ...U...U 00100010: 00000000 00000000 00000015 00000016 ... 00100020: 00000017 00000018 00000019 0000001a ... 00100030: 0000001b 0000001c 0000001d 0000001e ... =>
5.9.2.9. nm - memory modify (constant address)
=> help nmnm [.b, .w, .l] address
- memory modify, read and keep address
=>
The nm command (non-incrementing memory modify) can be used to interactively write different data several times to the same address. This can be useful for instance to access and modify device registers:
=> nm.b 100000 00100000: 00 ? 48 00100000: 48 ? 65 00100000: 65 ? 6c 00100000: 6c ? 6c 00100000: 6c ? 6f 00100000: 6f ? . => md 100000 8 00100000: 6f000000 115511ff ffffffff ffff1155 o....U...U 00100010: 00000000 00000000 00000015 00000016 ... =>
The nm command too accepts the type extensions .l, .w and .b.
5.9.2.10. loop - infinite loop on address range
=> help looploop [.b, .w, .l] address number_of_objects - loop on a set of addresses
=>
The loop command reads in a tight loop from a range of memory. This is intended as a special form of a memory test, since this command tries to read the memory as fast as possible.
This command will never terminate. There is no way to stop it but to reset the board! => loop 100000 8