Важное замечание: установка на Windows проходит аналогично, однако необходим тулчейн для компиляции кода C++ от Microsoft (Visual Studio Build Tools C++). Если тучейн не установлен, то rustup-init.exe предупредит вас об этом. Тулчейн устанавливается автоматически после установки Visual Studio, его можно скачать его с сайта Microsoft [4]. Выберите бесплатный вариант установки Community.

Если Build Tools C++ уже установлен, то выполните следующие шаги:

1. Установка Rust. По ссылке [3] выберите закачку одного из вариантов установщиков, в зависимости от разрядности вашей Windows: "DOWNLOAD RUSTUP-INIT.EXE (32-BIT)" или "DOWNLOAD RUSTUP-INIT.EXE (64-BIT)". Закачается rustup-init.exe.

2. Запустите rustup-init.exe, откроется окно CMD со следующим диалогом выбора варианта установки.

Welcome to Rust!

This will download and install the official compiler for the Rust
programming language, and its package manager, Cargo.

Rustup metadata and toolchains will be installed into the Rustup
home directory, located at:

  C:\Users\admin\.rustup

This can be modified with the RUSTUP_HOME environment variable.

The Cargo home directory is located at:
  C:\Users\admin\.cargo

This can be modified with the CARGO_HOME environment variable.

The cargo, rustc, rustup and other commands will be added to
Cargo's bin directory, located at:
  C:\Users\admin\.cargo\bin

This path will then be added to your PATH environment variable by
modifying the HKEY_CURRENT_USER/Environment/PATH registry key.
You can uninstall at any time with rustup self uninstall and
these changes will be reverted.

Current installation options:
   default host triple: x86_64-pc-windows-msvc
     default toolchain: stable (default)
               profile: default
  modify PATH variable: yes
1) Proceed with standard installation (default - just press enter)
2) Customize installation
3) Cancel installation

Выберите вариант 1 (просто нажмите Enter), начнется установка. По завершению установки нажмите Enter, окно консоли закроется.

3. Закачка репозитория blflash. Снова запустите cmd.exe, командой cd перейдите в любую папку, где должна будет находиться папка репозитория blflash. Для закачки репозитория выполните команду клонирования репозитория:

m:\asm>git clone https://github.com/spacemeowx2/blflash.git
Cloning into 'blflash'...
remote: Enumerating objects: 582, done.
remote: Counting objects: 100% (98/98), done.
remote: Compressing objects: 100% (71/71), done.
remote: Total 582 (delta 45), reused 67 (delta 26), pack-reused 484
Receiving objects:  95% (553/582)
Receiving objects: 100% (582/582), 155.12 KiB | 2.22 MiB/s, done.
Resolving deltas: 100% (304/304), done.

4. Компиляция blflash. Зайдите в папку blflash, выполните команду установки cargo build, начнется загрузка и компиляция пакетов:

m:\asm>cd blflash

m:\asm\blflash>cargo build
    Updating crates.io index
  Downloaded atty v0.2.14
  Downloaded autocfg v1.1.0
  Downloaded main_error v0.1.2
  Downloaded darling_macro v0.14.2
  Downloaded parse_int v0.6.0
  ...
  Downloaded bitflags v1.3.2
  Downloaded 82 crates (8.4 MB) in 3.49s (largest was `windows-sys` at 3.0 MB)
   Compiling proc-macro2 v1.0.49
   Compiling quote v1.0.23
   Compiling unicode-ident v1.0.6
   Compiling syn v1.0.107
   Compiling version_check v0.9.4
   ...
   Compiling deku v0.15.1
   Compiling blflash v0.3.5 (M:\asm\blflash\blflash)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 52.61s

После завершения процесса в папке blflash\target\debug\ появится исполняемый файл blflash.exe.

m:\asm\blflash>cd target\debug

m:\asm\blflash\target\debug>blflash.exe
blflash 0.3.5

USAGE:
    blflash.exe < SUBCOMMAND>

FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information

SUBCOMMANDS:
    check    Check if the device's flash matches the image
    dump     Dump the whole flash to a file
    flash    Flash image to serial
    help     Prints this message or the help of the given subcommand(s)

Это расшифровка дампа протокола команды blflash.exe dump dump_firmware.bin --port COM4, снятого под Windows 10 с помощью утилиты Device Monitoring Studio [7]. Далее рассмотрим процесс чтения по шагам. Передаваемые данные от утилиты blflash показаны синим шрифтом, а ответы от BL602 красным шрифтом.

1. Рукопожатие (handshaking). Утилита blflash.exe периодически отправляет пакеты рукопожатия (байты 0x55) и команду Get boot info (0x10), пока BL602 не ответит 0x4F 0x4B (OK):

55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55
55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55
55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55
55 55 55 55 55 55 55

10 00 00 00

В ответ BL602 посылает подтверждение 'OK':

4F 4B

И далее BL602 посылает информацию о себе:

4F 4B 14 00 01 00 00 00 00 00 00 00 03 00 03 00
DD 88 47 94 94 24 1C 00

В этом пакете передается следующее:

4F 4B OK

14 00 Младший (0x14) и старший (0x00) байты длины пакета данных, который идет далее (т. е. далее идут 0x14 == 20 байт данных).

01 00 00 00 Версия Boot ROM (4 байта).

00 00 00 00 03 00 03 00 DD 88 47 94 94 24 1C 00 Это информация OTP info (16 байт). По ней хост получает информацию, относящуюся к BL602. Хост должен решить, требуется ли для BL602 подписанный образ, ориентируясь на значение sign_type. В соответствии с encrypted, хост также определяет, требует ли BL602 зашифрованный образ. Если известно, что чип не запускается с шифрованием и подписью, то анализ этой информации может быть пропущен.

Структура данных OTP info:

typedef struct
{
   uint16_t len;             // длина данных, начиная с bootrom_version
   uint32_t bootrom_version; // версия ROM-загрузчика
   uint8_t otp_info[16];     // информация OTP info
}TBootInfo;

Содержимое блока OTP info:

00 00 00 00 03 00 03 00 ???
DD 88 47 94 94 24 Идентификатор чипа (chipid, серийный номер?) 0x2494944788DD.
1C 00 ???

2. Передача RAM-загрузчика. Теперь утилита blflash должна передать содержимое файла загрузчика eflash_loader_40m.bin. Это программа RAM-загрузчика, которая обладает расширенным функционалом по сравнению с ROM-загрузчиком. Для этого blflash.exe посылает команду Load boot header (0x11):

11 00 B0 00 42 46 4E 50 01 00 00 00 46 43 46 47
14 01 00 0F 66 99 FF 03 9F 00 9F 00 04 EF 00 01
C7 20 52 D8 06 02 32 00 0B 01 0B 01 3B 01 BB 00
6B 01 EB 02 EB 02 02 50 00 01 00 01 01 00 02 01
02 01 AB 01 05 35 00 00 01 01 00 00 38 FF A0 F0
77 03 02 40 77 03 02 F0 2C 01 B0 04 B0 04 32 00
20 4E 05 00 A2 AF F2 41 00 00 00 00 04 04 00 01
03 00 00 00 DE 73 F2 3A 00 02 00 00 01 00 00 00
00 00 00 00 00 00 01 22 BA CA E9 6E 53 D0 64 D7
31 5E 20 22 27 E2 3A CA AA 3D EC F3 1D 96 05 95
17 20 F8 D7 30 FC C3 02 00 00 00 00 00 00 00 00
EA E2 30 06

Здесь передаются первые 0xB0 (176) байт из файла eflash_loader_40m.bin, т. е. следующие данные:

11 00 Команда 0x11 и зарезервированный байт 0x00

B0 00 Младший (0xB0) и старший (0x00) байты количества передаваемых далее байт. Т. е. далее идут 0x00B0 == 176 байт структуры заголовка загрузчика bootheader_t.

            42 46 4E 50 01 00 00 00 46 43 46 47
14 01 00 0F 66 99 FF 03 9F 00 9F 00 04 EF 00 01
C7 20 52 D8 06 02 32 00 0B 01 0B 01 3B 01 BB 00
6B 01 EB 02 EB 02 02 50 00 01 00 01 01 00 02 01
02 01 AB 01 05 35 00 00 01 01 00 00 38 FF A0 F0
77 03 02 40 77 03 02 F0 2C 01 B0 04 B0 04 32 00
20 4E 05 00 A2 AF F2 41 00 00 00 00 04 04 00 01
03 00 00 00 DE 73 F2 3A 00 02 00 00 01 00 00 00
00 00 00 00 00 00 01 22 BA CA E9 6E 53 D0 64 D7
31 5E 20 22 27 E2 3A CA AA 3D EC F3 1D 96 05 95
17 20 F8 D7 30 FC C3 02 00 00 00 00 00 00 00 00
EA E2 30 06

Вот так этот блок выглядит при просмотре содержимого файла eflash_loader_40m.bin (выделено желтым цветом):

Это блок данных накладывается на следующую структуру bootheader_t:

typedef struct
{
   uint32_t magiccode;                                  // 4
   uint32_t revison;                                    // +4 = 8
   boot_flash_cfg_t flashCfg;                           // +2 = 10
   boot_clk_cfg_t clkCfg;                               // +16 = 26
   ISP_protocol_BL602 bootcfg;                          // +4 = 30
   uint32_t segment_cnt;                                // +4 = 34
   uint32_t bootentry;   /* точка входа образа */       // +4 = 38
   uint32_t flashoffset;                                // +4 = 42
   uint8_t hash[BFLB_BOOTROM_HASH_SIZE];                // +122 = 164  /* хэш образа */
   uint32_t rsv1;                                       // +4 = 168
   uint32_t rsv2;                                       // +4 = 172
   uint32_t crc32;                                      // +4 = 176
} __attribute__((packed)) bootheader_t;

42 46 4E 50 magiccode 'BFNP'

01 00 00 00 ревизия

46 43 flashCfg

46 47 14 01 00 0F 66 99 FF 03 9F 00 9F 00 04 EF clkCfg

00 01 C7 20 bootcfg

52 D8 06 02 segment_cnt

32 00 0B 01 bootentry

0B 01 3B 01 flashoffset

                                          BB 00
6B 01 EB 02 EB 02 02 50 00 01 00 01 01 00 02 01
02 01 AB 01 05 35 00 00 01 01 00 00 38 FF A0 F0
77 03 02 40 77 03 02 F0 2C 01 B0 04 B0 04 32 00
20 4E 05 00 A2 AF F2 41 00 00 00 00 04 04 00 01
03 00 00 00 DE 73 F2 3A 00 02 00 00 01 00 00 00
00 00 00 00 00 00 01 22 BA CA E9 6E 53 D0 64 D7
31 5E 20 22 27 E2 3A CA AA 3D EC F3 1D 96 05 95
17 20 F8 D7 30 FC C3 02 hash

00 00 00 00 rsv1

00 00 00 00 rsv2

EA E2 30 06 crc32

Примечание: описание структур boot_flash_cfg_t, boot_clk_cfg_t, ISP_protocol_BL602 см. в статье [2].

В ответ BL602 посылает подтверждение 'OK':

4F 4B

3. Далее blflash.exe посылает команду загрузки заголовка сегмента Load Segment Header (0x17):

17 00 10 00 00 00 01 22 90 71 00 00 35 7D C8 6E
93 8A 7A 6F

Здесь 17 00 это код команды и зарезервированный байт, 10 00 длина блока данных (16 байт). 16 байт это структура segment_header_t:

typedef struct
{
   uint32_t destaddr;
   uint32_t len;
   uint32_t rsvd;
   uint32_t crc32;
} __attribute__((packed)) segment_header_t;

00 00 01 22 destaddr

90 71 00 00 len

35 7D C8 6E rsvd

93 8A 7A 6F crc32

Данные segment_header_t это следующие 16 байт из того же файла eflash_loader_40m.bin. Вот так этот блок выглядит при просмотре содержимого файла eflash_loader_40m.bin (выделено желтым цветом):

В ответ BL602 в качестве подтверждения выдает 'OK' и зеркально эти же данные:

4F 4B 10 00 00 00 01 22 90 71 00 00 35 7D C8 6E
93 8A 7A 6F

4. blflash.exe начинает передавать данные из файла eflash_loader_40m.bin, пропустив 0xC0 байт от начала этого файла (от начала идет заголовок bootheader_t, который был передан на шаге 2, потом segment_header_t, переданный на шаге 3). Данные передаются блоками по 0x0FA0 = 4000 байт. Пример передачи одного такого блока:

18 00 A0 0F 97 11 01 20 .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. EF 50 10 0B B7 57
02 42 83 A7

Здесь закодированы следующие данные: 

18 00 Команда Load Segment Data (0x18) и зарезервированный байт (0x00).

A0 0F Младший (0xA0) и старший (0x0F) длины передаваемого блока данных, т. е. 0x0FA0 == 4000 байт.

97 11 01 20 .. .. 02 42 83 A7 4000 байт из файла eflash_loader_40m.bin без всякой контрольной суммы.

В последнем блоке передается оставшееся количество байт (0x0430 = 1072 байта):

18 00 30 04 06 59 65 61 .. ..
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
.. .. .. .. .. .. .. .. .. .. 14 00 10 10 00 00
00 00 00 00

В ответ на каждый переданный блок BL602 отвечает 'OK':

4F 4B

5. blflash.exe посылает команду Check image (0x19):

19 00 00 00

BL602 проверяет образ, и посылает в ответ 'OK':

4F 4B

6. blflash.exe посылает команду Run image (0x1A):

1A 00 00 00

BL602 посылает в ответ 'OK':

4F 4B

После этой команды активизируется RAM-загрузчик, который может работать на повышенной скорости UART, до 2 мегабит.

7. blflash.exe посылает рукопожатие на повышенной скорости, 660 байт 0x55:

55 55 55 55 55 55 55 55 55 55 55 55 55 55 55 55
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
55 55 55 55

BL602 посылает в ответ 'OK':

4F 4B

8. blflash.exe посылает команды flash_read (0x32), вычитывая блоки один за другим по 4 килобайта:

32 00 08 00 00 00 00 00 00 10 00 00

Здесь посылаются следующие данные:

32 00 Команда flash_read (0x32) и зарезервированный байт (0x00).

08 00 Младший (0x08) и старший байт (0x00) количества байт в пакете. Таким образом, дальше идут 0x0008 = 8 байт.

00 00 00 00 Начальный адрес, откуда читать данные (0x00000000).

00 10 00 00 Сколько байт прочитать (0x00001000 = 4096 байт).

В ответ BL602 передает 'OK' (4F 4B), запрошенное количество байт (0x1000 = 4096) и далее сами данные, без контрольной суммы:

4F 4B 00 10 42 46 4E 50 01 00 00 00 46 43 46 47
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
FF FF FF FF

Так передаются все блоки, и в каждой команде увеличивается запрашиваемый адрес:

32 00 08 00 00 10 00 00 00 10 00 00

32 00 08 00 00 20 00 00 00 10 00 00

32 00 08 00 00 30 00 00 00 10 00 00

.. .. .. .. .. .. .. .. .. .. .. ..

32 00 08 00 00 F0 0F 00 00 10 00 00

Здесь приведен дамп обмена команды прошивки flash BL602 (blflash.exe flash firmware.bin --port COM4), снятый с помощью снифера Device Monitoring Studio [7].

Шаги 1 .. 7 те же самые - рукопожатие, отправка eflash_loader_40m.bin, проверка образа, запуск образа, рукопожатие на повышенной скорости (см. предыдущую врезку "Расшифровка протокола чтения flash-памяти BL602").

Начиная с шага 8 процесс меняется.

8. blflash.exe посылает команду flash_readSha (0x3D):

3D 00 08 00 00 00 00 00 90 B9 00 00

В этом пакете:

3D 00 Код команды и зарезервированный байт.

08 00 Количество байт, которое идет далее (8 байт).

00 00 00 00 начальный адрес (0x00000000).

90 B9 00 00 конечный адрес, не включая. Таким образом, должно быть вычислена SHA256 от (0x0000B990 - 0x00000000) == 47504 байт, начиная с адреса 0.

BL602 в ответ посылает:

4F 4B 20 00 5E 5E FA 55 7A A8 31 C7 FC B8 A2 A4
FC 0F 52 B3 78 AF C6 77 53 0A DF 02 3E DF BD 74
DA 0B 72 EB

В этом пакете:

4F 4B 'OK'

20 00 Младший (0x20) и старший байт (0x00) количества байт хэша SHA256, которые идут далее (0x0020 == 32 байта).

            5E 5E FA 55 7A A8 31 C7 FC B8 A2 A4
FC 0F 52 B3 78 AF C6 77 53 0A DF 02 3E DF BD 74
DA 0B 72 EB Хэш SHA256 запрошенного блока.

9. blflash.exe проверяет соответствие хеша в своем образе файла для этого блока с хешем, который прислал BL602. В нашем примере хэш не совпал, поэтому blflash.exe посылает команду flash_erase (0x30):

30 00 08 00 00 00 00 00 90 B9 00 00

В этом пакете:

30 00 Код команды (0x30) и зарезервированный байт (0x00).

08 00 Количество байт, которое идет далее (8 байт).

00 00 00 00 начальный адрес 0x00000000.

90 B9 00 00 конечный адрес 0x0000B990.

BL602 посылает в ответ 'OK':

4F 4B

10. blflash.exe посылает команду flash_write (0x31):

31 00 A4 0F 00 00 00 00 42 46 4E 50 01 00 00 00
46 43 46 47 04 01 01 01 66 99 FF 03 9F 00 9F 00
04 EF 00 01 C7 20 52 D8 06 02 32 00 0B 01 0B 01
.. .. .. .. .. .. .. .. .. .. .. .. .. .. .. ..
FF FF FF FF FF FF FF FF

В этом пакете:

31 00 Код команды flash_write.

A4 0F Размер передаваемых данных (0x0FA4 = 4004 байта). В этот размер входит адрес назначения (4 байта) и сами данные (4000 байт).

00 00 00 00 Адрес назначения (0x00000000).

42 46 4E 50 .. FF FF FF Записываемые данные.

В ответ BL602 посылает 'OK':

4F 4B

Далее blflash посылает таким же образом следующие блоки данных, а BL602 отвечает на них 'OK':

31 00 A4 0F A0 0F 00 00 (0x0FA0 = 4000 байт, начиная с адреса 0x00000FA0)
31 00 A4 0F 40 1F 00 00 (0x0FA0 = 4000 байт, начиная с адреса 0x00001F40)
31 00 A4 0F E0 2E 00 00 (0x0FA0 = 4000 байт, начиная с адреса 0x00002EE0)
31 00 A4 0F 80 3E 00 00 (0x0FA0 = 4000 байт, начиная с адреса 0x00003E80)
31 00 A4 0F 20 4E 00 00 (0x0FA0 = 4000 байт, начиная с адреса 0x00004E20)
31 00 A4 0F C0 5D 00 00 (0x0FA0 = 4000 байт, начиная с адреса 0x00005DC0)
31 00 A4 0F 60 6D 00 00 (0x0FA0 = 4000 байт, начиная с адреса 0x00006D60)
31 00 A4 0F 00 7D 00 00 (0x0FA0 = 4000 байт, начиная с адреса 0x00007D00)
31 00 A4 0F A0 8C 00 00 (0x0FA0 = 4000 байт, начиная с адреса 0x00008CA0)
31 00 A4 0F 40 9C 00 00 (0x0FA0 = 4000 байт, начиная с адреса 0x00009C40)
31 00 B4 0D E0 AB 00 00 (0x0DB0 = 3504 байт, начиная с адреса 0x0000ABE0)

Таким образом, записываются данные в ранее стертом блоке, причем по возможности пропускаются чистые области (содержимое которых заполнено байтами 0xFF).

11. blflash проверяет только что записанный блок отправкой все той же команды flash_readSha (0x3D):

3D 00 08 00 00 00 00 00 90 B9 00 00

В ответ на эту команду BL602 присылает хэш SHA256 (см. шаг 8).

После этого процесс прошивки продолжается аналогичным образом, с повторением шагов 8, 9, 10, 11. Общий алгоритм следующий:

(A) Запрашивается SHA256 блока у BL602, сравнивается на соответствие с записываемым файлом (шаг 8).

(B) Было совпадение? Если да, то происходит увеличение адреса, и переход на (A), пока все данные файла не будут записаны. Если же SHA256 не совпало, то (C).

(C) Стирается не совпавший блок в BL602 (шаг 9), и записывается данными из файла порциями по 4000 байт (шаг 10), последняя порция может быть меньше. Качество записи проверяется по SHA256 (шаг 11). После этого происходит увеличение адреса, и если данные файла не закончились, то переход на (A).

(D) Прошивка завершена (шаг 12).

В моем случае стирались, и потом записывались следующие блоки:

30 00 08 00 00 00 00 00 90 B9 00 00  00000000 0000B990
30 00 08 00 00 E0 00 00 10 E1 00 00  0000E000 0000E110
30 00 08 00 00 F0 00 00 10 F1 00 00  0000F000 0000F110
30 00 08 00 00 00 01 00 00 10 11 00  00010000 00111000
30 00 08 00 00 80 1F 00 27 96 1F 00  001F8000 001F9627

12. Прошивка завершена. Передается команда сброса 0x21 (опциональный шаг).