doc/README.rockchip

   1 # SPDX-License-Identifier: GPL-2.0+
   2 #
   3 # Copyright (C) 2015 Google. Inc
   4 # Written by Simon Glass <sjg@chromium.org>
   5
   6 U-Boot on Rockchip
   7 ==================
   8
   9 A wide range of Rockchip SoCs are supported in mainline U-Boot
  10
  11
  12 Prerequisites
  13 =============
  14
  15 You will need:
  16
  17    - Firefly RK3288 board or something else with a supported RockChip SoC
  18    - Power connection to 5V using the supplied micro-USB power cable
  19    - Separate USB serial cable attached to your computer and the Firefly
  20         (connect to the micro-USB connector below the logo)
  21    - rkflashtool [3]
  22    - openssl (sudo apt-get install openssl)
  23    - Serial UART connection [4]
  24    - Suitable ARM cross compiler, e.g.:
  25         sudo apt-get install gcc-4.7-arm-linux-gnueabi
  26
  27
  28 Building
  29 ========
  30
  31 At present 11 RK3288 boards are supported:
  32
  33    - EVB RK3288 - use evb-rk3288 configuration
  34    - Firefly RK3288 - use firefly-rk3288 configuration
  35    - Hisense Chromebook - use chromebook_jerry configuration
  36    - Asus C100P Chromebook - use chromebook_minnie configuration
  37    - Asus Chromebit - use chromebook_mickey configuration
  38    - MiQi RK3288 - use miqi-rk3288 configuration
  39    - phyCORE-RK3288 RDK - use phycore-rk3288 configuration
  40    - PopMetal RK3288 - use popmetal-rk3288 configuration
  41    - Radxa Rock 2 - use rock2 configuration
  42    - Tinker RK3288 - use tinker-rk3288 configuration
  43    - Vyasa RK3288 - use vyasa-rk3288 configuration
  44
  45 Two RK3036 boards are supported:
  46
  47    - EVB RK3036 - use evb-rk3036 configuration
  48    - Kylin - use kylin_rk3036 configuration
  49
  50 Two RK3328 board are supported:
  51
  52    - EVB RK3328 - use evb-rk3328_defconfig
  53    - Pine64 Rock64 board - use rock64-rk3328_defconfig
  54
  55 Size RK3399 boards are supported (aarch64):
  56
  57    - EBV RK3399 - use evb_rk3399 configuration
  58    - Firefly RK3399 - use the firefly_rk3399 configuration
  59    - Puma - use puma_rk3399 configuration
  60    - Ficus - use ficus-rk3399 configuration
  61    - Rock960 (Vamrs) - use rock960-rk3399 configuration
  62    - Bob - use chromebook_bob configuration
  63
  64 Four RK3368 boards are supported:
  65
  66    - Sheep - use sheep-rk3368 configuration
  67    - Lion - use lion-rk3368 configuration
  68    - Geekbox - use geekbox configuration
  69    - EVB PX5 - use evb-px5  configuration
  70
  71 One RK3128 board is supported:
  72
  73    - EVB RK3128 - use evb-rk3128 configuration
  74
  75 One RK3229 board is supported:
  76
  77    - EVB RK3229 - use evb-rk3229 configuration
  78
  79 Two RV1108 boards are supported:
  80
  81    - EVB RV1108 - use evb-rv1108 configuration
  82    - Elgin R1 - use elgin-rv1108 configuration
  83
  84 One RV3188 baord is supported:
  85
  86    - Raxda Rock - use rock configuration
  87
  88
  89 For example:
  90
  91 1. To build RK3288 board:
  92
  93    CROSS_COMPILE=arm-linux-gnueabi- make O=firefly firefly-rk3288_defconfig all
  94
  95     (or you can use another cross compiler if you prefer)
  96
  97 2. To build RK3399 board:
  98
  99    Option 1: Package the image with Rockchip miniloader:
 100
 101    - Compile U-Boot
 102
 103      => cd /path/to/u-boot
 104      => make nanopi-neo4-rk3399_defconfig
 105      => make
 106
 107    - Get the rkbin
 108
 109      => git clone https://github.com/rockchip-linux/rkbin.git
 110
 111    - Create trust.img
 112
 113      => cd /path/to/rkbin
 114      => ./tools/trust_merger RKTRUST/RK3399TRUST.ini
 115
 116    - Create uboot.img
 117
 118      => cd /path/to/rkbin
 119      => ./tools/loaderimage --pack --uboot /path/to/u-boot/u-boot-dtb.bin uboot.img
 120
 121      (Get trust.img and uboot.img)
 122
 123    Option 2: Package the image with SPL:
 124
 125    - Export cross compiler path for aarch64
 126
 127    - Compile ATF
 128
 129      For Puma board.
 130
 131         => git clone git://git.theobroma-systems.com/arm-trusted-firmware.git
 132         => cd arm-trusted-firmware
 133         => make CROSS_COMPILE=aarch64-linux-gnu- PLAT=rk3399 bl31
 134
 135         (export bl31.bin)
 136         => export BL31=/path/to/arm-trusted-firmware/build/rk3399/release/bl31/bl31.bin
 137
 138      For rest of rk3399 boards.
 139
 140         => git clone https://github.com/ARM-software/arm-trusted-firmware.git
 141         => cd arm-trusted-firmware
 142
 143         (export cross compiler path for Cortex-M0 MCU likely arm-none-eabi-)
 144         => make realclean
 145         => make CROSS_COMPILE=aarch64-linux-gnu- PLAT=rk3399
 146
 147         (export bl31.elf)
 148         => export BL31=/path/to/arm-trusted-firmware/build/rk3399/release/bl31/bl31.elf
 149
 150    - Compile PMU M0 firmware
 151
 152      This is optional for most of the rk3399 boards and required only for Puma board.
 153
 154      => git clone git://git.theobroma-systems.com/rk3399-cortex-m0.git
 155      => cd rk3399-cortex-m0
 156
 157      (export cross compiler path for Cortex-M0 PMU)
 158      => make CROSS_COMPILE=arm-cortex_m0-eabi-
 159
 160      (export rk3399m0.bin)
 161      => export PMUM0=/path/to/rk3399-cortex-m0/rk3399m0.bin
 162
 163    - Compile U-Boot
 164
 165      => cd /path/to/u-boot
 166      => make orangepi-rk3399_defconfig
 167      => make
 168
 169      (Get spl/u-boot-spl-dtb.bin, u-boot.itb images and some boards would get
 170       spl/u-boot-spl.bin since it doesn't enable CONFIG_SPL_OF_CONTROL
 171
 172       If TPL enabled on the target, get tpl/u-boot-tpl-dtb.bin or tpl/u-boot-tpl.bin
 173       if CONFIG_TPL_OF_CONTROL not enabled)
 174
 175 Writing to the board with USB
 176 =============================
 177
 178 For USB to work you must get your board into ROM boot mode, either by erasing
 179 your MMC or (perhaps) holding the recovery button when you boot the board.
 180 To erase your MMC, you can boot into Linux and type (as root)
 181
 182    dd if=/dev/zero of=/dev/mmcblk0 bs=1M
 183
 184 Connect your board's OTG port to your computer.
 185
 186 To create a suitable image and write it to the board:
 187
 188    ./firefly-rk3288/tools/mkimage -n rk3288 -T rkimage -d \
 189         ./firefly-rk3288/spl/u-boot-spl-dtb.bin out && \
 190    cat out | openssl rc4 -K 7c4e0304550509072d2c7b38170d1711 | rkflashtool l
 191
 192 If all goes well you should something like:
 193
 194    U-Boot SPL 2015.07-rc1-00383-ge345740-dirty (Jun 03 2015 - 10:06:49)
 195    Card did not respond to voltage select!
 196    spl: mmc init failed with error: -17
 197    ### ERROR ### Please RESET the board ###
 198
 199 You will need to reset the board before each time you try. Yes, that's all
 200 it does so far. If support for the Rockchip USB protocol or DFU were added
 201 in SPL then we could in principle load U-Boot and boot to a prompt from USB
 202 as several other platforms do. However it does not seem to be possible to
 203 use the existing boot ROM code from SPL.
 204
 205
 206 Booting from an SD card
 207 =======================
 208
 209 To write an image that boots from an SD card (assumed to be /dev/sdc):
 210
 211    ./firefly-rk3288/tools/mkimage -n rk3288 -T rksd -d \
 212         firefly-rk3288/spl/u-boot-spl-dtb.bin out && \
 213    sudo dd if=out of=/dev/sdc seek=64 && \
 214    sudo dd if=firefly-rk3288/u-boot-dtb.img of=/dev/sdc seek=16384
 215
 216 This puts the Rockchip header and SPL image first and then places the U-Boot
 217 image at block 16384 (i.e. 8MB from the start of the SD card). This
 218 corresponds with this setting in U-Boot:
 219
 220    #define CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR      0x4000
 221
 222 Put this SD (or micro-SD) card into your board and reset it. You should see
 223 something like:
 224
 225    U-Boot 2016.01-rc2-00309-ge5bad3b-dirty (Jan 02 2016 - 23:41:59 -0700)
 226
 227    Model: Radxa Rock 2 Square
 228    DRAM:  2 GiB
 229    MMC:   dwmmc@ff0f0000: 0, dwmmc@ff0c0000: 1
 230    *** Warning - bad CRC, using default environment
 231
 232    In:    serial
 233    Out:   vop@ff940000.vidconsole
 234    Err:   serial
 235    Net:   Net Initialization Skipped
 236    No ethernet found.
 237    Hit any key to stop autoboot:  0
 238    =>
 239
 240 The rockchip bootrom can load and boot an initial spl, then continue to
 241 load a second-stage bootloader (ie. U-Boot) as soon as the control is returned
 242 to the bootrom. Both the RK3288 and the RK3036 use this special boot sequence.
 243 The configuration option enabling this is:
 244
 245         CONFIG_SPL_ROCKCHIP_BACK_TO_BROM=y
 246
 247 You can create the image via the following operations:
 248
 249    ./firefly-rk3288/tools/mkimage -n rk3288 -T rksd -d \
 250         firefly-rk3288/spl/u-boot-spl-dtb.bin out && \
 251    cat firefly-rk3288/u-boot-dtb.bin >> out && \
 252    sudo dd if=out of=/dev/sdc seek=64
 253
 254 If you have an HDMI cable attached you should see a video console.
 255
 256 For evb_rk3036 board:
 257         ./evb-rk3036/tools/mkimage -n rk3036 -T rksd  -d evb-rk3036/spl/u-boot-spl.bin out && \
 258         cat evb-rk3036/u-boot-dtb.bin >> out && \
 259         sudo dd if=out of=/dev/sdc seek=64
 260
 261 Note: rk3036 SDMMC and debug uart use the same iomux, so if you boot from SD, the
 262       debug uart must be disabled
 263
 264
 265 Booting from an SD card on RK3288 with TPL
 266 ==========================================
 267
 268 Since the size of SPL can't be exceeded 0x8000 bytes in RK3288, it is not possible add
 269 new SPL features like Falcon mode or etc.
 270
 271 So introduce TPL so-that adding new features to SPL is possible because now TPL should
 272 run minimal with code like DDR, clock etc and rest of new features in SPL.
 273
 274 As of now TPL is added on Vyasa-RK3288 board.
 275
 276 To write an image that boots from an SD card (assumed to be /dev/mmcblk0):
 277
 278    ./tools/mkimage -n rk3288 -T rksd -d ./tpl/u-boot-tpl.bin out &&
 279     cat ./spl/u-boot-spl-dtb.bin >> out &&
 280     sudo dd if=out of=/dev/mmcblk0 seek=64 &&
 281     sudo dd if=u-boot-dtb.img of=/dev/mmcblk0 seek=16384
 282
 283 Booting from an SD card on RK3188
 284 =================================
 285
 286 For rk3188 boards the general storage onto the card stays the same as
 287 described above, but the image creation needs a bit more care.
 288
 289 The bootrom of rk3188 expects to find a small 1kb loader which returns
 290 control to the bootrom, after which it will load the real loader, which
 291 can then be up to 29kb in size and does the regular ddr init.  This is
 292 handled by a single image (built as the SPL stage) that tests whether
 293 it is handled for the first or second time via code executed from the
 294 boot0-hook.
 295
 296 Additionally the rk3188 requires everything the bootrom loads to be
 297 rc4-encrypted. Except for the very first stage the bootrom always reads
 298 and decodes 2kb pages, so files should be sized accordingly.
 299
 300 # copy tpl, pad to 1020 bytes and append spl
 301 tools/mkimage -n rk3188 -T rksd -d spl/u-boot-spl.bin out
 302
 303 # truncate, encode and append u-boot.bin
 304 truncate -s %2048 u-boot.bin
 305 cat u-boot.bin | split -b 512 --filter='openssl rc4 -K 7C4E0304550509072D2C7B38170D1711' >> out
 306
 307 Booting from an SD card on Pine64 Rock64 (RK3328)
 308 =================================================
 309
 310 For Rock64 rk3328 board the following three parts are required:
 311 TPL, SPL, and the u-boot image tree blob.
 312
 313   - Create TPL/SPL image
 314
 315     => tools/mkimage -n rk3328 -T rksd -d tpl/u-boot-tpl.bin idbloader.img
 316     => cat spl/u-boot-spl.bin >> idbloader.img
 317
 318   - Write TPL/SPL image at 64 sector
 319
 320     => sudo dd if=idbloader.img of=/dev/mmcblk0 seek=64
 321
 322   - Write u-boot image tree blob at 16384 sector
 323
 324     => sudo dd if=u-boot.itb of=/dev/mmcblk0 seek=16384
 325
 326 Booting from an SD card on RK3399
 327 =================================
 328
 329 To write an image that boots from an SD card (assumed to be /dev/sdc):
 330
 331 Option 1: Package the image with Rockchip miniloader:
 332
 333   - Create idbloader.img
 334
 335     => cd /path/to/u-boot
 336     => ./tools/mkimage  -n rk3399 -T rksd -d /path/to/rkbin/bin/rk33/rk3399_ddr_800MHz_v1.20.bin idbloader.img
 337     => cat /path/to/rkbin/bin/rk33/rk3399_miniloader_v1.19.bin >> idbloader.img
 338
 339   - Write idbloader.img at 64 sector
 340
 341     => sudo dd if=idbloader.img of=/dev/sdc seek=64
 342
 343   - Write trust.img at 24576
 344
 345     => sudo dd if=trust.img of=/dev/sdc seek=24576
 346
 347   - Write uboot.img at 16384 sector
 348
 349     => sudo dd if=uboot.img of=/dev/sdc seek=16384
 350     => sync
 351
 352 Put this SD (or micro-SD) card into your board and reset it. You should see
 353 something like:
 354
 355 DDR Version 1.20 20190314
 356 In
 357 Channel 0: DDR3, 933MHz
 358 Bus Width=32 Col=10 Bank=8 Row=15 CS=1 Die Bus-Width=16 Size=1024MB
 359 no stride
 360 ch 0 ddrconfig = 0x101, ddrsize = 0x20
 361 pmugrf_os_reg[2] = 0x10006281, stride = 0x17
 362 OUT
 363 Boot1: 2019-03-14, version: 1.19
 364 CPUId = 0x0
 365 ChipType = 0x10, 239
 366 mmc: ERROR: SDHCI ERR:cmd:0x102,stat:0x18000
 367 mmc: ERROR: Card did not respond to voltage select!
 368 emmc reinit
 369 mmc: ERROR: SDHCI ERR:cmd:0x102,stat:0x18000
 370 mmc: ERROR: Card did not respond to voltage select!
 371 emmc reinit
 372 mmc: ERROR: SDHCI ERR:cmd:0x102,stat:0x18000
 373 mmc: ERROR: Card did not respond to voltage select!
 374 SdmmcInit=2 1
 375 mmc0:cmd5,20
 376 SdmmcInit=0 0
 377 BootCapSize=0
 378 UserCapSize=60543MB
 379 FwPartOffset=2000 , 0
 380 StorageInit ok = 45266
 381 SecureMode = 0
 382 SecureInit read PBA: 0x4
 383 SecureInit read PBA: 0x404
 384 SecureInit read PBA: 0x804
 385 SecureInit read PBA: 0xc04
 386 SecureInit read PBA: 0x1004
 387 SecureInit read PBA: 0x1404
 388 SecureInit read PBA: 0x1804
 389 SecureInit read PBA: 0x1c04
 390 SecureInit ret = 0, SecureMode = 0
 391 atags_set_bootdev: ret:(0)
 392 GPT 0x3380ec0 signature is wrong
 393 recovery gpt...
 394 GPT 0x3380ec0 signature is wrong
 395 recovery gpt fail!
 396 LoadTrust Addr:0x4000
 397 No find bl30.bin
 398 Load uboot, ReadLba = 2000
 399 hdr 0000000003380880 + 0x0:0x88,0x41,0x3e,0x97,0xe6,0x61,0x54,0x23,0xe9,0x5a,0xd1,0x2b,0xdc,0x2f,0xf9,0x35,
 400
 401 Load OK, addr=0x200000, size=0x9c9c0
 402 RunBL31 0x10000
 403 NOTICE:  BL31: v1.3(debug):370ab80
 404 NOTICE:  BL31: Built : 09:23:41, Mar  4 2019
 405 NOTICE:  BL31: Rockchip release version: v1.1
 406 INFO:    GICv3 with legacy support detected. ARM GICV3 driver initialized in EL3
 407 INFO:    Using opteed sec cpu_context!
 408 INFO:    boot cpu mask: 0
 409 INFO:    plat_rockchip_pmu_init(1181): pd status 3e
 410 INFO:    BL31: Initializing runtime services
 411 INFO:    BL31: Initializing BL32
 412 INF [0x0] TEE-CORE:init_primary_helper:337: Initializing (1.1.0-195-g8f090d20 #6 Fri Dec  7 06:11:20 UTC 2018 aarch64)
 413
 414 INF [0x0] TEE-CORE:init_primary_helper:338: Release version: 1.2
 415
 416 INF [0x0] TEE-CORE:init_teecore:83: teecore inits done
 417 INFO:    BL31: Preparing for EL3 exit to normal world
 418 INFO:    Entry point address = 0x200000
 419 INFO:    SPSR = 0x3c9
 420
 421
 422 U-Boot 2019.04-rc4-00136-gfd121f9641-dirty (Apr 16 2019 - 14:02:47 +0530)
 423
 424 Model: FriendlyARM NanoPi NEO4
 425 DRAM:  1022 MiB
 426 MMC:   dwmmc@fe310000: 2, dwmmc@fe320000: 1, sdhci@fe330000: 0
 427 Loading Environment from MMC... *** Warning - bad CRC, using default environment
 428
 429 In:    serial@ff1a0000
 430 Out:   serial@ff1a0000
 431 Err:   serial@ff1a0000
 432 Model: FriendlyARM NanoPi NEO4
 433 Net:   eth0: ethernet@fe300000
 434 Hit any key to stop autoboot:  0
 435 =>
 436
 437 Option 2: Package the image with SPL:
 438
 439   - Prefix rk3399 header to SPL image
 440
 441     => cd /path/to/u-boot
 442     => ./tools/mkimage -n rk3399 -T rksd -d spl/u-boot-spl-dtb.bin out
 443
 444   - Write prefixed SPL at 64th sector
 445
 446     => sudo dd if=out of=/dev/sdc seek=64
 447
 448   - Write U-Boot proper at 16384 sector
 449
 450     => sudo dd if=u-boot.itb of=/dev/sdc seek=16384
 451     => sync
 452
 453 Put this SD (or micro-SD) card into your board and reset it. You should see
 454 something like:
 455
 456 U-Boot SPL board init
 457 Trying to boot from MMC1
 458
 459
 460 U-Boot 2019.01-00004-g14db5ee998 (Mar 11 2019 - 13:18:41 +0530)
 461
 462 Model: Orange Pi RK3399 Board
 463 DRAM:  2 GiB
 464 MMC:   dwmmc@fe310000: 2, dwmmc@fe320000: 1, sdhci@fe330000: 0
 465 Loading Environment from MMC... OK
 466 In:    serial@ff1a0000
 467 Out:   serial@ff1a0000
 468 Err:   serial@ff1a0000
 469 Model: Orange Pi RK3399 Board
 470 Net:   eth0: ethernet@fe300000
 471 Hit any key to stop autoboot:  0
 472 =>
 473
 474 Option 3: Package the image with TPL:
 475
 476   - Prefix rk3399 header to TPL image
 477
 478     => cd /path/to/u-boot
 479     => ./tools/mkimage -n rk3399 -T rksd -d tpl/u-boot-tpl-dtb.bin out
 480
 481   - Concatinate tpl with spl
 482
 483     => cd /path/to/u-boot
 484     => cat ./spl/u-boot-spl-dtb.bin >> out
 485
 486   - Write tpl+spl at 64th sector
 487
 488     => sudo dd if=out of=/dev/sdc seek=64
 489
 490   - Write U-Boot proper at 16384 sector
 491
 492     => sudo dd if=u-boot.itb of=/dev/sdc seek=16384
 493     => sync
 494
 495 Put this SD (or micro-SD) card into your board and reset it. You should see
 496 something like:
 497
 498 U-Boot TPL board init
 499 Trying to boot from BOOTROM
 500 Returning to boot ROM...
 501
 502 U-Boot SPL board init
 503 Trying to boot from MMC1
 504
 505
 506 U-Boot 2019.07-rc1-00241-g5b3244767a (May 08 2019 - 10:51:06 +0530)
 507
 508 Model: Orange Pi RK3399 Board
 509 DRAM:  2 GiB
 510 MMC:   dwmmc@fe310000: 2, dwmmc@fe320000: 1, sdhci@fe330000: 0
 511 Loading Environment from MMC... OK
 512 In:    serial@ff1a0000
 513 Out:   serial@ff1a0000
 514 Err:   serial@ff1a0000
 515 Model: Orange Pi RK3399 Board
 516 Net:   eth0: ethernet@fe300000
 517 Hit any key to stop autoboot:  0
 518 =>
 519
 520 Using fastboot on rk3288
 521 ========================
 522 - Write GPT partition layout to mmc device which fastboot want to use it to
 523 store the image
 524
 525         => gpt write mmc 1 $partitions
 526
 527 - Invoke fastboot command to prepare
 528
 529         => fastboot 1
 530
 531 - Start fastboot request on PC
 532
 533         fastboot -i 0x2207 flash loader evb-rk3288/spl/u-boot-spl-dtb.bin
 534
 535 You should see something like:
 536
 537         => fastboot 1
 538         WARNING: unknown variable: partition-type:loader
 539         Starting download of 357796 bytes
 540         ..
 541         downloading of 357796 bytes finished
 542         Flashing Raw Image
 543         ........ wrote 357888 bytes to 'loader'
 544
 545 Booting from SPI
 546 ================
 547
 548 To write an image that boots from SPI flash (e.g. for the Haier Chromebook or
 549 Bob):
 550
 551    ./chromebook_jerry/tools/mkimage -n rk3288 -T rkspi \
 552         -d chromebook_jerry/spl/u-boot-spl-dtb.bin spl.bin && \
 553    dd if=spl.bin of=spl-out.bin bs=128K conv=sync && \
 554    cat spl-out.bin chromebook_jerry/u-boot-dtb.img >out.bin && \
 555    dd if=out.bin of=out.bin.pad bs=4M conv=sync
 556
 557 This converts the SPL image to the required SPI format by adding the Rockchip
 558 header and skipping every second 2KB block. Then the U-Boot image is written at
 559 offset 128KB and the whole image is padded to 4MB which is the SPI flash size.
 560 The position of U-Boot is controlled with this setting in U-Boot:
 561
 562    #define CONFIG_SYS_SPI_U_BOOT_OFFS   (128 << 10)
 563
 564 If you have a Dediprog em100pro connected then you can write the image with:
 565
 566       sudo em100 -s -c GD25LQ32 -d out.bin.pad -r
 567
 568 When booting you should see something like:
 569
 570    U-Boot SPL 2015.07-rc2-00215-g9a58220-dirty (Jun 23 2015 - 12:11:32)
 571
 572
 573    U-Boot 2015.07-rc2-00215-g9a58220-dirty (Jun 23 2015 - 12:11:32 -0600)
 574
 575    Model: Google Jerry
 576    DRAM:  2 GiB
 577    MMC:
 578    Using default environment
 579
 580    In:    serial@ff690000
 581    Out:   serial@ff690000
 582    Err:   serial@ff690000
 583    =>
 584
 585 Future work
 586 ===========
 587
 588 Immediate priorities are:
 589
 590 - USB host
 591 - USB device
 592 - Run CPU at full speed (code exists but we only see ~60 DMIPS maximum)
 593 - NAND flash
 594 - Boot U-Boot proper over USB OTG (at present only SPL works)
 595
 596
 597 Development Notes
 598 =================
 599
 600 There are plenty of patches in the links below to help with this work.
 601
 602 [1] https://github.com/rkchrome/uboot.git
 603 [2] https://github.com/linux-rockchip/u-boot-rockchip.git branch u-boot-rk3288
 604 [3] https://github.com/linux-rockchip/rkflashtool.git
 605 [4] http://wiki.t-firefly.com/index.php/Firefly-RK3288/Serial_debug/en
 606
 607 rkimage
 608 -------
 609
 610 rkimage.c produces an SPL image suitable for sending directly to the boot ROM
 611 over USB OTG. This is a very simple format - just the string RK32 (as 4 bytes)
 612 followed by u-boot-spl-dtb.bin.
 613
 614 The boot ROM loads image to 0xff704000 which is in the internal SRAM. The SRAM
 615 starts at 0xff700000 and extends to 0xff718000 where we put the stack.
 616
 617 rksd
 618 ----
 619
 620 rksd.c produces an image consisting of 32KB of empty space, a header and
 621 u-boot-spl-dtb.bin. The header is defined by 'struct header0_info' although
 622 most of the fields are unused by U-Boot. We just need to specify the
 623 signature, a flag and the block offset and size of the SPL image.
 624
 625 The header occupies a single block but we pad it out to 4 blocks. The header
 626 is encoding using RC4 with the key 7c4e0304550509072d2c7b38170d1711. The SPL
 627 image can be encoded too but we don't do that.
 628
 629 The maximum size of u-boot-spl-dtb.bin which the boot ROM will read is 32KB,
 630 or 0x40 blocks. This is a severe and annoying limitation. There may be a way
 631 around this limitation, since there is plenty of SRAM, but at present the
 632 board refuses to boot if this limit is exceeded.
 633
 634 The image produced is padded up to a block boundary (512 bytes). It should be
 635 written to the start of an SD card using dd.
 636
 637 Since this image is set to load U-Boot from the SD card at block offset,
 638 CONFIG_SYS_MMCSD_RAW_MODE_U_BOOT_SECTOR, dd should be used to write
 639 u-boot-dtb.img to the SD card at that offset. See above for instructions.
 640
 641 rkspi
 642 -----
 643
 644 rkspi.c produces an image consisting of a header and u-boot-spl-dtb.bin. The
 645 resulting image is then spread out so that only the first 2KB of each 4KB
 646 sector is used. The header is the same as with rksd and the maximum size is
 647 also 32KB (before spreading). The image should be written to the start of
 648 SPI flash.
 649
 650 See above for instructions on how to write a SPI image.
 651
 652 rkmux.py
 653 --------
 654
 655 You can use this script to create #defines for SoC register access. See the
 656 script for usage.
 657
 658
 659 Device tree and driver model
 660 ----------------------------
 661
 662 Where possible driver model is used to provide a structure to the
 663 functionality. Device tree is used for configuration. However these have an
 664 overhead and in SPL with a 32KB size limit some shortcuts have been taken.
 665 In general all Rockchip drivers should use these features, with SPL-specific
 666 modifications where required.
 667
 668 GPT partition layout
 669 ----------------------------
 670
 671 Rockchip use a unified GPT partition layout  in open source support.
 672 With this GPT partition layout, uboot can be compatilbe with other components,
 673 like miniloader, trusted-os, arm-trust-firmware.
 674
 675 There are some documents about partitions in the links below.
 676 http://rockchip.wikidot.com/partitions
 677
 678 --
 679 Jagan Teki <jagan@amarulasolutions.com>
 680 27 Mar 2019
 681 Simon Glass <sjg@chromium.org>
 682 24 June 2015