Andrey/templates
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Сохранить текущие изменения NAND и LED перед объединением веток

Browse Source
This commit is contained in:
Andrey Kruchinkin
2026-09-15 15:57:06 +03:00
parent 20dbc2c721
commit 698632ebf3
35 changed files with 1841 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
c/parallel-nand/README.md
View File

@@ -1,13 +1,16 @@
# parallel-nand
Переносимый C99-драйвер асинхронной parallel NAND x8 и окно управления через
общее адресное пространство GAS. Первый профиль — Micron `MT29F1G08ABADA`:
2048+64 байта, 64 страницы в блоке, 1024 блока.
общее адресное пространство GAS. Есть профили Micron `MT29F1G08ABADA` и
Hynix `HY27UF084G2M` (512 MiB, 2048+64 байта, 64 страницы в блоке,
4096 блоков, ID `AD DC 80 95`).
Подготовлены аппаратные порты:
- `TMS320F2812` — XINTF Zone 6;
- `STM32F407VET6` — аппаратный FSMC NAND Bank 2;
- `STM32F103RCT6` — GPIO bit-bang, так как в LQFP64 FSMC недоступен;
- `STM32F103ZET6` — аппаратный FSMC NAND Bank 3;
- `STM32G474CEU6` — GPIO bit-bang для корпуса UFQFPN-48.
Ядро не зависит от HAL и транспорта GUI. STM32 HAL используется только в
@@ -55,6 +58,12 @@ void memory_init(void)
}
```
Для Hynix на STM32F103ZET6 используйте
`parallel_nand_port_stm32f103ze()` и
`parallel_nand_hy27uf084g2m_geometry`; распиновка и ограничения приведены в
[`ports/stm32f103ze/README.md`](ports/stm32f103ze/README.md). Порт RCT6
с GPIO bit-bang сохранён как отдельный вариант для корпуса LQFP64.
Диспетчер общего адресного пространства вызывает
`parallel_nand_gas_read()`/`parallel_nand_gas_write()` для адресов
`0xE000..0xE51F`. Для STM32 с `c/set-protocol/pcan_gas` дополнительно включить
@@ -67,10 +76,28 @@ void memory_init(void)
[docs/MEMORY_GAS.md](docs/MEMORY_GAS.md). Электрические соединения — в README
соответствующего порта и [docs/EMPTY_BOARD_PINOUT.md](docs/EMPTY_BOARD_PINOUT.md).
## PROGRAM и ERASE
- `parallel_nand_program_page()` записывает полную main-область и, при
необходимости, полную OOB-область страницы.
- `parallel_nand_erase_block()` стирает один физический блок.
- Перед изменением ядро проверяет заводской bad-block marker, на время операции
снимает `WP#`, ждёт `R/B#`, проверяет fail-бит статуса и снова включает
защиту при любом результате.
- Порт обязан объявить `write_supported = 1`; иначе возвращается
`PNAND_ERROR_WRITE_PROTECTED`. Это защищает платы, где `WP#` постоянно
соединён с GND.
- Через GAS разрушительные команды требуют записи `0xA55A` в `CONFIRM`
непосредственно перед `PROGRAM_PAGE` или `ERASE_BLOCK`.
NAND можно программировать только из `1` в `0`; для повторной записи сначала
стирается весь блок. Не стирайте заводские bad-блоки и не используйте raw-запись
как файловую систему без ECC, wear leveling и защиты загрузочных блоков.
## Текущие границы
- Реализовано безопасное чтение, RESET, READ ID, STATUS и bad-block marker.
- PROGRAM/ERASE намеренно отсутствуют; ядро включает аппаратную защиту `WP#`.
- Реализованы чтение, программирование страницы, стирание блока, RESET,
READ ID, STATUS и проверка bad-block marker.
- ECC пока не исправляет данные. GUI получает физические main/OOB и должен
помечать дамп как raw.
- В полном дампе bad-блоки не пропускаются: сохраняется физический порядок.
@@ -86,3 +113,5 @@ void memory_init(void)
5. Записать номер страницы в `0xE005/0xE006`, затем `3` в `0xE004`.
6. Дождаться `READY | PAGE_VALID` в `0xE002`.
7. Прочитать main из `0xE100..0xE4FF`, OOB из `0xE500..0xE51F`.
8. PROGRAM/ERASE проверять только на заведомо расходном блоке после сохранения
полного raw-дампа.

6
c/parallel-nand/docs/EMPTY_BOARD_PINOUT.md
View File

@@ -30,7 +30,7 @@ TSOP-48 (суффикс `WP`). На второй фотографии NAND —
| `CLE` | 16 | фиксация команды |
| `ALE` | 17 | фиксация адреса |
| `WE#` | 18 | строб команды/адреса от МК |
| `WP#` | 19 | для read-only 10 кОм на GND; для записи — GPIO и pull-down |
| `WP#` | 19 | GPIO МК и pull-down 10 кОм; только для чтения допустим GND через 10 кОм |
| `I/O0` | 29 | двунаправленная шина, бит 0 |
| `I/O1` | 30 | двунаправленная шина, бит 1 |
| `I/O2` | 31 | двунаправленная шина, бит 2 |
@@ -69,10 +69,12 @@ TSOP-48 (суффикс `WP`). На второй фотографии NAND —
## Первый запуск
1. Не устанавливать NAND и проверить 3,3 В, отсутствие КЗ и уровни `CE#/WE#/RE#`.
2. Установить NAND, оставить `WP#` в нуле и выполнить RESET `FFh`.
2. Установить NAND, проверить pull-down и уровень `WP# = 0`, выполнить RESET `FFh`.
3. Прочитать ID `90h`: ожидаемые первые байты для профиля — `2C F1`.
4. Считать одну страницу два раза и сравнить main/OOB побайтно.
5. Только после устойчивого чтения запускать полный дамп через GAS.
6. PROGRAM/ERASE проверять на расходном блоке после сохранения raw-дампа;
убедиться осциллографом, что `WP#` поднимается только на время операции.
## Источники для проверки footprint

42
c/parallel-nand/docs/MEMORY_GAS.md
View File

@@ -18,6 +18,8 @@ parallel_nand_gas
▼
общее ядро parallel_nand
├─ TMS320F2812: XINTF
├─ STM32F103RC: GPIO
├─ STM32F103ZE: FSMC
├─ STM32F407VE: FSMC
└─ STM32G474CE: GPIO
```
@@ -77,7 +79,7 @@ ARM.
| Адрес | Доступ | Название | Значение |
|---:|:---:|---|---|
| `E000` | R | `SIGNATURE` | `0x4E44` (`ND`) |
| `E001` | R | `VERSION` | версия окна, сейчас 1 |
| `E001` | R | `VERSION` | версия окна, сейчас 2 |
| `E002` | R | `STATUS` | состояние операции |
| `E003` | R | `ERROR` | код `PNAND_*`, 0 = нет ошибки |
| `E004` | W | `COMMAND` | команда окна |
@@ -92,8 +94,9 @@ ARM.
| `E00D` | R | `BAD_BLOCK` | 1 для физически плохого блока |
| `E00E` | R | `GENERATION_LO` | счётчик загруженных страниц, low |
| `E00F` | R | `GENERATION_HI` | счётчик загруженных страниц, high |
| `E100..E4FF` | R | `PAGE_DATA` | 1024 регистра main, два байта LE |
| `E500..E51F` | R | `PAGE_OOB` | 32 регистра OOB, два байта LE |
| `E010` | W | `CONFIRM` | `0xA55A` непосредственно перед разрушительной командой |
| `E100..E4FF` | R/W | `PAGE_DATA` | 1024 регистра main, два байта LE |
| `E500..E51F` | R/W | `PAGE_OOB` | 32 регистра OOB, два байта LE |
Между управляющими регистрами и окнами данных есть зарезервированные адреса.
Чтение блока через них не выполняется: каждый запрос должен начинаться внутри
@@ -107,6 +110,8 @@ ARM.
| 1 | `0x0002` | `BUSY` |
| 2 | `0x0004` | `PAGE_VALID` |
| 3 | `0x0008` | `BAD_BLOCK` |
| 4 | `0x0010` | `WRITE_SUPPORTED`, порт способен управлять `WP#` |
| 5 | `0x0020` | `BUFFER_DIRTY`, буфер изменён после чтения/очистки |
| 15 | `0x8000` | `ERROR`, подробность в `E003` |
GUI читает окно данных только при `READY=1`, `PAGE_VALID=1`, `ERROR=0`.
@@ -118,6 +123,9 @@ GUI читает окно данных только при `READY=1`, `PAGE_VALI
| 1 | `RESET` | сброс NAND и ожидание Ready |
| 2 | `READ_ID` | обновляет `E00B/E00C` |
| 3 | `READ_PAGE` | загружает main/OOB выбранной страницы |
| 4 | `CLEAR_BUFFER` | заполняет main/OOB значением `0xFF` для подготовки записи |
| 5 | `PROGRAM_PAGE` | программирует выбранную страницу из буфера |
| 6 | `ERASE_BLOCK` | стирает блок, содержащий выбранную страницу |
Запись номера страницы и запуск — две отдельные операции. Сначала GUI пишет
`PAGE_LO/PAGE_HI`, затем записывает `READ_PAGE` в `COMMAND`. Нельзя отправлять
@@ -172,6 +180,28 @@ GUI хранит номер последней полностью записан
## PROGRAM/ERASE
Запись и стирание не включены намеренно. Они требуют отдельного разрешения,
проверки ECC, защиты загрузочных блоков и двухфазного подтверждения через GAS.
До добавления этих функций `WP#` удерживается активным аппаратным портом.
Разрушительные команды доступны только если установлен флаг
`WRITE_SUPPORTED`. Ядро проверяет bad-block marker и отказывается изменять
заводской плохой блок. `WP#` снимается только внутри операции и включается
обратно после проверки status fail-бита, тайм-аута или другой ошибки.
Для программирования очищенной страницы:
1. Записать `PAGE_LO/PAGE_HI`.
2. Выполнить `CLEAR_BUFFER`.
3. Записать необходимые main/OOB-регистры. Незаписанные байты останутся
`0xFF`; OOB лучше не менять без определённой ECC-разметки.
4. Записать `0xA55A` в `CONFIRM`.
5. Следующей записью без промежуточных операций отправить `PROGRAM_PAGE`.
6. Проверить `READY`, отсутствие `ERROR` и изменение `GENERATION`.
Для стирания записать любую страницу целевого блока в `PAGE_LO/PAGE_HI`, затем
`0xA55A` в `CONFIRM` и сразу `ERASE_BLOCK`. Изменение страницы, буфера или
другого управляющего регистра сбрасывает подтверждение. После успешного
стирания `PAGE_VALID` очищается.
Повторное программирование не может превратить `0` обратно в `1`: для этого
требуется стирание всего блока. Перед первым тестом сохраните полный raw-дамп,
исключите загрузочные блоки и используйте заведомо расходный исправный блок.
Библиотека не реализует ECC, wear leveling, журналирование и восстановление
после пропадания питания.

27
c/parallel-nand/include/parallel_nand.h
View File

@@ -16,13 +16,31 @@ extern "C" {
#define PNAND_MT29F1G08_PAGE_TOTAL \
(PNAND_MT29F1G08_PAGE_MAIN + PNAND_MT29F1G08_PAGE_OOB)
#define PNAND_HY27UF084G2M_PAGE_MAIN 2048UL
#define PNAND_HY27UF084G2M_PAGE_OOB 64UL
#define PNAND_HY27UF084G2M_PAGES_PER_BLOCK 64UL
#define PNAND_HY27UF084G2M_BLOCKS 4096UL
#define PNAND_HY27UF084G2M_COLUMN_CYCLES 2U
#define PNAND_HY27UF084G2M_ROW_CYCLES 3U
#define PNAND_HY27UF084G2M_MANUFACTURER_ID 0xADU
#define PNAND_HY27UF084G2M_DEVICE_ID 0xDCU
#define PNAND_HY27UF084G2M_ID3 0x80U
#define PNAND_HY27UF084G2M_ID4 0x95U
#define PNAND_HY27UF084G2M_PAGE_TOTAL \
(PNAND_HY27UF084G2M_PAGE_MAIN + PNAND_HY27UF084G2M_PAGE_OOB)
typedef enum {
PNAND_OK = 0,
PNAND_ERROR_ARGUMENT = -1,
PNAND_ERROR_PORT = -2,
PNAND_ERROR_TIMEOUT = -3,
PNAND_ERROR_RANGE = -4,
PNAND_ERROR_BUFFER = -5
PNAND_ERROR_BUFFER = -5,
PNAND_ERROR_WRITE_PROTECTED = -6,
PNAND_ERROR_PROGRAM_FAILED = -7,
PNAND_ERROR_ERASE_FAILED = -8,
PNAND_ERROR_BAD_BLOCK = -9,
PNAND_ERROR_CONFIRMATION = -10
} parallel_nand_result_t;
typedef struct {
@@ -41,6 +59,7 @@ typedef struct {
} parallel_nand_t;
extern const parallel_nand_geometry_t parallel_nand_mt29f1g08_geometry;
extern const parallel_nand_geometry_t parallel_nand_hy27uf084g2m_geometry;
int parallel_nand_init(parallel_nand_t *nand,
const parallel_nand_port_t *port,
@@ -57,6 +76,12 @@ int parallel_nand_read_page(parallel_nand_t *nand, unsigned long page,
int parallel_nand_read_page_slice(parallel_nand_t *nand, unsigned long page,
unsigned long column, pnand_octet_t *out,
unsigned long count);
int parallel_nand_program_page(parallel_nand_t *nand, unsigned long page,
const pnand_octet_t *main_data,
unsigned long main_count,
const pnand_octet_t *oob,
unsigned long oob_count);
int parallel_nand_erase_block(parallel_nand_t *nand, unsigned long block);
int parallel_nand_is_bad_block(parallel_nand_t *nand, unsigned long block,
int *is_bad);
unsigned long parallel_nand_page_count(const parallel_nand_t *nand);

13
c/parallel-nand/include/parallel_nand_gas.h
View File

@@ -30,20 +30,28 @@ enum {
PNAND_GAS_REG_DEVICE_ID = 0x000C,
PNAND_GAS_REG_BAD_BLOCK = 0x000D,
PNAND_GAS_REG_GENERATION_LO = 0x000E,
PNAND_GAS_REG_GENERATION_HI = 0x000F
PNAND_GAS_REG_GENERATION_HI = 0x000F,
PNAND_GAS_REG_CONFIRM = 0x0010
};
enum {
PNAND_GAS_CMD_NONE = 0,
PNAND_GAS_CMD_RESET = 1,
PNAND_GAS_CMD_READ_ID = 2,
PNAND_GAS_CMD_READ_PAGE = 3
PNAND_GAS_CMD_READ_PAGE = 3,
PNAND_GAS_CMD_CLEAR_BUFFER = 4,
PNAND_GAS_CMD_PROGRAM_PAGE = 5,
PNAND_GAS_CMD_ERASE_BLOCK = 6
};
#define PNAND_GAS_CONFIRM_MAGIC 0xA55AU
#define PNAND_GAS_STATUS_READY 0x0001U
#define PNAND_GAS_STATUS_BUSY 0x0002U
#define PNAND_GAS_STATUS_PAGE_VALID 0x0004U
#define PNAND_GAS_STATUS_BAD_BLOCK 0x0008U
#define PNAND_GAS_STATUS_WRITE_SUPPORTED 0x0010U
#define PNAND_GAS_STATUS_BUFFER_DIRTY 0x0020U
#define PNAND_GAS_STATUS_ERROR 0x8000U
typedef struct {
@@ -56,6 +64,7 @@ typedef struct {
unsigned long cached_block;
int cached_bad_block;
int block_cache_valid;
int destructive_armed;
pnand_octet_t id[8];
pnand_octet_t main_data[PNAND_MT29F1G08_PAGE_MAIN];
pnand_octet_t oob[PNAND_MT29F1G08_PAGE_OOB];

2
c/parallel-nand/include/parallel_nand_port.h
View File

@@ -19,6 +19,8 @@ typedef struct {
int (*is_ready)(void);
void (*set_write_protect)(int enabled);
void (*delay_us)(unsigned long us);
/* Nonzero only when set_write_protect(0) physically releases WP#. */
int write_supported;
} parallel_nand_port_t;
#ifdef __cplusplus

51
c/parallel-nand/ports/stm32f103rc/README.md Normal file
View File

@@ -0,0 +1,51 @@
# Порт STM32F103RCT6 для HY27UF084G2M
У `STM32F103RCT6` корпус LQFP64. Согласно datasheet STM32F103xC/D/E, функция
FSMC в этом корпусе недоступна, поэтому порт выполняет асинхронные NAND-циклы
через GPIO.
## Соединения
| HY27UF084G2M | STM32F103RCT6 | LQFP64 |
|---|---|---:|
| `I/O0..I/O7` | `PB0..PB7` | 26, 27, 28, 55, 56, 57, 58, 59 |
| `CLE` | `PC0` | 8 |
| `ALE` | `PC1` | 9 |
| `WE#` | `PC2` | 10 |
| `RE#` | `PC3` | 11 |
| `CE#` | `PC4` | 24 |
| `WP#` | `PC5` | 25 |
| `R/B#` | `PC6` | 37 |
Питание NAND — 3,3 В. На каждый вывод питания нужен 100 нФ, рядом с чипом —
1–4,7 мкФ. `R/B#` имеет открытый сток и требует внешней подтяжки 4,7–10 кОм
к 3,3 В. Не оставляйте `WP#` неподключённым.
`PB2` также является `BOOT1`: NAND держит I/O в высокоимпедансном состоянии
до командного цикла, но штатную конфигурацию загрузки платы всё равно нужно
обеспечить подтяжкой. `PB3/PB4` заняты JTAG; порт отключает JTAG и сохраняет
SWD на `PA13/PA14`.
## Подключение к проекту Cube/HAL
Добавьте `parallel_nand_port_stm32f103rc.c`, путь к его заголовку и включите
GPIO HAL. Инициализация:
```c
#include "parallel_nand.h"
#include "parallel_nand_port_stm32f103rc.h"
static parallel_nand_t nand;
int nand_init(void)
{
return parallel_nand_init(
&nand,
parallel_nand_port_stm32f103rc(),
&parallel_nand_hy27uf084g2m_geometry);
}
```
После успешной инициализации прочитайте четыре байта ID и ожидайте
`AD DC 80 95`. Порт поддерживает PROGRAM/ERASE: ядро держит `WP#` в активном
низком уровне между операциями и поднимает его только на время изменения NAND.

143
c/parallel-nand/ports/stm32f103rc/parallel_nand_port_stm32f103rc.c Normal file
View File

@@ -0,0 +1,143 @@
#include "parallel_nand_port_stm32f103rc.h"
#include "stm32f1xx_hal.h"
/* STM32F103RCT6 LQFP64: FSMC is unavailable, so use GPIO bit-bang. */
#define DATA_MASK 0x00FFU
#define CLE_PIN GPIO_PIN_0
#define ALE_PIN GPIO_PIN_1
#define WE_PIN GPIO_PIN_2
#define RE_PIN GPIO_PIN_3
#define CE_PIN GPIO_PIN_4
#define WP_PIN GPIO_PIN_5
#define RB_PIN GPIO_PIN_6
static int data_is_output;
static void data_input(void)
{
if (data_is_output) {
GPIOB->CRL = 0x44444444UL; /* PB0..PB7: floating input. */
data_is_output = 0;
}
}
static void data_output(void)
{
if (!data_is_output) {
GPIOB->CRL = 0x33333333UL; /* PB0..PB7: 50 MHz push-pull. */
data_is_output = 1;
}
}
static void short_delay(void)
{
__NOP(); __NOP(); __NOP(); __NOP();
}
static int f103rc_init(void)
{
GPIO_InitTypeDef io;
__HAL_RCC_AFIO_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();
/* Latch inactive control levels while pins are still inputs. */
GPIOC->BSRR = WE_PIN | RE_PIN | CE_PIN |
((uint32_t)(CLE_PIN | ALE_PIN | WP_PIN) << 16);
/* PB3/PB4 carry I/O3/I/O4. Keep SWD, release only the JTAG pins. */
__HAL_AFIO_REMAP_SWJ_NOJTAG();
GPIOB->BSRR = DATA_MASK;
GPIOB->CRL = 0x33333333UL;
data_is_output = 1;
data_input();
io.Pin = CLE_PIN | ALE_PIN | WE_PIN | RE_PIN | CE_PIN | WP_PIN;
io.Mode = GPIO_MODE_OUTPUT_PP;
io.Pull = GPIO_NOPULL;
io.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOC, &io);
io.Pin = RB_PIN;
io.Mode = GPIO_MODE_INPUT;
io.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOC, &io);
return 0;
}
static void f103rc_select(void) { GPIOC->BRR = CE_PIN; }
static void f103rc_deselect(void) { GPIOC->BSRR = CE_PIN; }
static void write_cycle(pnand_octet_t value)
{
data_output();
GPIOB->BRR = DATA_MASK;
GPIOB->BSRR = (uint32_t)value & DATA_MASK;
short_delay();
GPIOC->BRR = WE_PIN;
short_delay();
GPIOC->BSRR = WE_PIN;
short_delay();
}
static void f103rc_write_command(pnand_octet_t value)
{
GPIOC->BSRR = CLE_PIN;
GPIOC->BRR = ALE_PIN;
write_cycle(value);
GPIOC->BRR = CLE_PIN;
}
static void f103rc_write_address(pnand_octet_t value)
{
GPIOC->BSRR = ALE_PIN;
GPIOC->BRR = CLE_PIN;
write_cycle(value);
GPIOC->BRR = ALE_PIN;
}
static void f103rc_write_data(pnand_octet_t value)
{
GPIOC->BRR = CLE_PIN | ALE_PIN;
write_cycle(value);
}
static pnand_octet_t f103rc_read_data(void)
{
pnand_octet_t value;
data_input();
GPIOC->BRR = CLE_PIN | ALE_PIN | RE_PIN;
short_delay();
value = (pnand_octet_t)(GPIOB->IDR & DATA_MASK);
GPIOC->BSRR = RE_PIN;
short_delay();
return value;
}
static int f103rc_is_ready(void) { return (GPIOC->IDR & RB_PIN) != 0U; }
static void f103rc_set_wp(int enabled)
{
if (enabled) GPIOC->BRR = WP_PIN;
else GPIOC->BSRR = WP_PIN;
}
static void f103rc_delay_us(unsigned long us)
{
uint32_t cycles = (SystemCoreClock / 3000000UL) * (uint32_t)us;
while (cycles-- != 0U) __NOP();
}
static const parallel_nand_port_t f103rc_port = {
f103rc_init, f103rc_select, f103rc_deselect,
f103rc_write_command, f103rc_write_address, f103rc_write_data,
f103rc_read_data, f103rc_is_ready, f103rc_set_wp, f103rc_delay_us,
1
};
const parallel_nand_port_t *parallel_nand_port_stm32f103rc(void)
{
return &f103rc_port;
}

16
c/parallel-nand/ports/stm32f103rc/parallel_nand_port_stm32f103rc.h Normal file
View File

@@ -0,0 +1,16 @@
#ifndef PARALLEL_NAND_PORT_STM32F103RC_H
#define PARALLEL_NAND_PORT_STM32F103RC_H
#include "parallel_nand_port.h"
#ifdef __cplusplus
extern "C" {
#endif
const parallel_nand_port_t *parallel_nand_port_stm32f103rc(void);
#ifdef __cplusplus
}
#endif
#endif

62
c/parallel-nand/ports/stm32f103ze/README.md Normal file
View File

@@ -0,0 +1,62 @@
# Порт STM32F103ZET6 для HY27UF084G2M
Порт использует аппаратный контроллер `FSMC NAND Bank 3`, 8-битную шину и
окно памяти `0x70000000`. Сигналы `CE#`, `WE#`, `RE#`, `CLE` и `ALE`
формируются FSMC. Защита записи `WP#` управляется отдельным GPIO `PG8`.
## Соединения
| HY27UF084G2M | STM32F103ZET6 | LQFP144 | Функция FSMC |
|---|---|---:|---|
| `I/O0` | `PD14` | 85 | `D0` |
| `I/O1` | `PD15` | 86 | `D1` |
| `I/O2` | `PD0` | 114 | `D2` |
| `I/O3` | `PD1` | 115 | `D3` |
| `I/O4` | `PE7` | 58 | `D4` |
| `I/O5` | `PE8` | 59 | `D5` |
| `I/O6` | `PE9` | 60 | `D6` |
| `I/O7` | `PE10` | 63 | `D7` |
| `CLE` | `PD11` | 80 | `A16/CLE` |
| `ALE` | `PD12` | 81 | `A17/ALE` |
| `WE#` | `PD5` | 119 | `NWE` |
| `RE#` | `PD4` | 118 | `NOE` |
| `CE#` | `PD7` | 123 | `NCE2` |
| `R/B#` | `PD6` | 122 | вход GPIO (`NWAIT`) |
| `WP#` | `PG8` | 93 | выход GPIO |
`R/B#` имеет открытый сток и требует внешней подтяжки 4,7–10 кОм к 3,3 В.
Питание NAND — 3,3 В; возле каждой пары питания нужен 100 нФ, рядом с
микросхемой — 1–4,7 мкФ. Все номера выводов MCU указаны для вида сверху.
## Подключение к STM32Cube HAL
В `stm32f1xx_hal_conf.h` должны быть включены `HAL_NAND_MODULE_ENABLED` и
`HAL_GPIO_MODULE_ENABLED`. В проект добавляются:
- `parallel_nand_port_stm32f103ze.c`;
- `stm32f1xx_hal_nand.c`;
- `stm32f1xx_ll_fsmc.c`.
Инициализация переносимой библиотеки:
```c
#include "parallel_nand.h"
#include "parallel_nand_port_stm32f103ze.h"
static parallel_nand_t nand;
int nand_init(void)
{
return parallel_nand_init(
&nand,
parallel_nand_port_stm32f103ze(),
&parallel_nand_hy27uf084g2m_geometry);
}
```
Начальные тайминги намеренно консервативны. После запуска проверьте
осциллографом длительности `WE#`/`RE#` и время установки данных. Ожидаемый ID
HY27UF084G2M: `AD DC 80 95`.
Порт поддерживает PROGRAM/ERASE. `WP#` на `PG8` остаётся активным между
операциями и снимается ядром только на время программирования или стирания.

184
c/parallel-nand/ports/stm32f103ze/parallel_nand_port_stm32f103ze.c Normal file
View File

@@ -0,0 +1,184 @@
#include "parallel_nand_port_stm32f103ze.h"
#include "stm32f1xx_hal.h"
#include "stm32f1xx_hal_nand.h"
/* STM32F103 names this block FSMC NAND Bank 3. Its HAL memory window is
* NAND_DEVICE1; each access makes FSMC assert PD7/FSMC_NCE2 automatically. */
#define PNAND_F103ZE_DATA_ADDRESS 0x70000000UL
#define PNAND_F103ZE_COMMAND_AREA (1UL << 16U)
#define PNAND_F103ZE_ADDRESS_AREA (1UL << 17U)
/* WP# is not generated by FSMC, so it is controlled as an ordinary GPIO. */
#define PNAND_F103ZE_WP_PORT GPIOG
#define PNAND_F103ZE_WP_PIN GPIO_PIN_8
/* HAL owns the FSMC registers through this handle during initialization. */
static NAND_HandleTypeDef nand_handle;
/** Configure all FSMC signals that belong to GPIO port D. */
static void configure_fsmc_gpio_d(void)
{
GPIO_InitTypeDef pin = {0};
/* D0..D3, NOE, NWE, NCE2, CLE and ALE are driven by FSMC. On STM32F1
* alternate-function output mode is selected without an AF number. */
pin.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_4 | GPIO_PIN_5 |
GPIO_PIN_7 | GPIO_PIN_11 | GPIO_PIN_12 |
GPIO_PIN_14 | GPIO_PIN_15;
pin.Mode = GPIO_MODE_AF_PP;
pin.Pull = GPIO_NOPULL;
pin.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOD, &pin);
/* R/B# is read directly. Its open-drain output needs an external
* 4.7..10 kOhm pull-up to 3.3 V. */
pin.Pin = GPIO_PIN_6;
pin.Mode = GPIO_MODE_INPUT;
pin.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOD, &pin);
}
/** Configure FSMC data bits D4..D7 on GPIO port E. */
static void configure_fsmc_gpio_e(void)
{
GPIO_InitTypeDef pin = {0};
pin.Pin = GPIO_PIN_7 | GPIO_PIN_8 | GPIO_PIN_9 | GPIO_PIN_10;
pin.Mode = GPIO_MODE_AF_PP;
pin.Pull = GPIO_NOPULL;
pin.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOE, &pin);
}
/** Configure the explicit write-protect output and assert protection. */
static void configure_write_protect(void)
{
GPIO_InitTypeDef pin = {0};
/* Set the safe active-low level before changing the pad to an output. */
HAL_GPIO_WritePin(PNAND_F103ZE_WP_PORT, PNAND_F103ZE_WP_PIN,
GPIO_PIN_RESET);
pin.Pin = PNAND_F103ZE_WP_PIN;
pin.Mode = GPIO_MODE_OUTPUT_PP;
pin.Pull = GPIO_NOPULL;
pin.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(PNAND_F103ZE_WP_PORT, &pin);
}
/** Initialize the STM32F1 HAL NAND layer with conservative 72 MHz timings. */
static int f103ze_init(void)
{
FSMC_NAND_PCC_TimingTypeDef common_timing = {0};
FSMC_NAND_PCC_TimingTypeDef attribute_timing = {0};
__HAL_RCC_GPIOD_CLK_ENABLE();
__HAL_RCC_GPIOE_CLK_ENABLE();
__HAL_RCC_GPIOG_CLK_ENABLE();
__HAL_RCC_FSMC_CLK_ENABLE();
configure_fsmc_gpio_d();
configure_fsmc_gpio_e();
configure_write_protect();
nand_handle.Instance = FSMC_NAND_DEVICE;
nand_handle.Init.NandBank = FSMC_NAND_BANK3;
nand_handle.Init.Waitfeature = FSMC_NAND_PCC_WAIT_FEATURE_DISABLE;
nand_handle.Init.MemoryDataWidth = FSMC_NAND_PCC_MEM_BUS_WIDTH_8;
nand_handle.Init.EccComputation = FSMC_NAND_ECC_DISABLE;
nand_handle.Init.ECCPageSize = FSMC_NAND_ECC_PAGE_SIZE_2048BYTE;
nand_handle.Init.TCLRSetupTime = 2U;
nand_handle.Init.TARSetupTime = 2U;
/* One FSMC tick is about 13.9 ns at HCLK=72 MHz. These deliberately
* relaxed values are suitable for first bring-up and signal probing. */
common_timing.SetupTime = 2U;
common_timing.WaitSetupTime = 5U;
common_timing.HoldSetupTime = 3U;
common_timing.HiZSetupTime = 2U;
attribute_timing = common_timing;
return HAL_NAND_Init(&nand_handle, &common_timing, &attribute_timing) ==
HAL_OK
? 0
: -1;
}
static void f103ze_select(void)
{
/* A memory-window access asserts NCE2; no separate software GPIO exists. */
}
static void f103ze_deselect(void)
{
/* NCE2 is released automatically when the FSMC access finishes. */
}
static void f103ze_write_command(pnand_octet_t value)
{
*(__IO uint8_t *)(PNAND_F103ZE_DATA_ADDRESS |
PNAND_F103ZE_COMMAND_AREA) = (uint8_t)value;
__DSB(); /* Complete the external bus write before the next NAND cycle. */
}
static void f103ze_write_address(pnand_octet_t value)
{
*(__IO uint8_t *)(PNAND_F103ZE_DATA_ADDRESS |
PNAND_F103ZE_ADDRESS_AREA) = (uint8_t)value;
__DSB();
}
static void f103ze_write_data(pnand_octet_t value)
{
*(__IO uint8_t *)PNAND_F103ZE_DATA_ADDRESS = (uint8_t)value;
__DSB();
}
static pnand_octet_t f103ze_read_data(void)
{
uint8_t value = *(__IO uint8_t *)PNAND_F103ZE_DATA_ADDRESS;
__DSB();
return (pnand_octet_t)value;
}
static int f103ze_is_ready(void)
{
return HAL_GPIO_ReadPin(GPIOD, GPIO_PIN_6) == GPIO_PIN_SET;
}
static void f103ze_set_write_protect(int enabled)
{
/* NAND WP# is active low: RESET protects, SET permits program/erase. */
HAL_GPIO_WritePin(PNAND_F103ZE_WP_PORT, PNAND_F103ZE_WP_PIN,
enabled ? GPIO_PIN_RESET : GPIO_PIN_SET);
}
static void f103ze_delay_us(unsigned long us)
{
/* Approximate delay used only around reset/status polling. The factor
* accounts for loop instructions in addition to the NOP. */
uint32_t cycles = (SystemCoreClock / 3000000UL) * (uint32_t)us;
while (cycles-- != 0U) {
__NOP();
}
}
static const parallel_nand_port_t f103ze_port = {
f103ze_init,
f103ze_select,
f103ze_deselect,
f103ze_write_command,
f103ze_write_address,
f103ze_write_data,
f103ze_read_data,
f103ze_is_ready,
f103ze_set_write_protect,
f103ze_delay_us,
1
};
const parallel_nand_port_t *parallel_nand_port_stm32f103ze(void)
{
return &f103ze_port;
}

16
c/parallel-nand/ports/stm32f103ze/parallel_nand_port_stm32f103ze.h Normal file
View File

@@ -0,0 +1,16 @@
#ifndef PARALLEL_NAND_PORT_STM32F103ZE_H
#define PARALLEL_NAND_PORT_STM32F103ZE_H
#include "parallel_nand_port.h"
#ifdef __cplusplus
extern "C" {
#endif
const parallel_nand_port_t *parallel_nand_port_stm32f103ze(void);
#ifdef __cplusplus
}
#endif
#endif

5
c/parallel-nand/ports/stm32f407ve/README.md
View File

@@ -24,3 +24,8 @@
`stm32f4xx_ll_fsmc.c`, включить FSMC и не создавать второй
`NAND_HandleTypeDef` для Bank 2. Начальные тайминги
консервативны; финальные значения подтвердить осциллографом.
В базовой схеме `WP#` аппаратно зафиксирован в активном уровне, поэтому порт
объявляет `write_supported = 0`, а PROGRAM/ERASE возвращают
`PNAND_ERROR_WRITE_PROTECTED`. Для записи назначьте отдельный GPIO с внешним
pull-down, реализуйте управление `WP#` и включите признак поддержки порта.

3
c/parallel-nand/ports/stm32f407ve/parallel_nand_port_stm32f407ve.c
View File

@@ -84,7 +84,8 @@ static void f407_delay_us(unsigned long us)
static const parallel_nand_port_t f407_port = {
f407_init, f407_select, f407_deselect,
f407_write_command, f407_write_address, f407_write_data,
f407_read_data, f407_is_ready, f407_set_wp, f407_delay_us
f407_read_data, f407_is_ready, f407_set_wp, f407_delay_us,
0
};
const parallel_nand_port_t *parallel_nand_port_stm32f407ve(void)

3
c/parallel-nand/ports/stm32g474ce/README.md
View File

@@ -19,3 +19,6 @@ HAL только для инициализации, а циклы NAND выпо
Выбранные `PB3/PB4` нельзя одновременно использовать для trace/JTAG; SWD на
`PA13/PA14` остаётся доступен. Если эти пины нужны проекту, измените таблицу и
операции шины: текущая оптимизация рассчитана на непрерывные `PB0..PB7`.
Порт поддерживает PROGRAM/ERASE через управляемый `WP#` на `PA5`. Внешний
pull-down сохраняет защиту до инициализации GPIO и при сбросе МК.

3
c/parallel-nand/ports/stm32g474ce/parallel_nand_port_stm32g474ce.c
View File

@@ -125,7 +125,8 @@ static void g474_delay_us(unsigned long us)
static const parallel_nand_port_t g474_port = {
g474_init, g474_select, g474_deselect,
g474_write_command, g474_write_address, g474_write_data,
g474_read_data, g474_is_ready, g474_set_wp, g474_delay_us
g474_read_data, g474_is_ready, g474_set_wp, g474_delay_us,
1
};
const parallel_nand_port_t *parallel_nand_port_stm32g474ce(void)

7
c/parallel-nand/ports/tms320f2812/README.md
View File

@@ -13,9 +13,10 @@
Адреса C28x задаются в 16-битных словах: data `0x100000`, command
`0x100001`, address `0x100002`. Используется только младший байт XINTF.
`WP#` в базовом варианте аппаратный: для режима только чтения соединить с GND
через 10 кОм; если позже понадобится PROGRAM/ERASE, заменить на GPIO и реализовать
`tms_set_wp()`.
`WP#` в базовом варианте аппаратный и соединён с GND через 10 кОм. Поэтому
порт объявляет `write_supported = 0`, а PROGRAM/ERASE возвращают
`PNAND_ERROR_WRITE_PROTECTED`. Для записи нужно перенести `WP#` на GPIO,
реализовать `tms_set_wp()` и установить признак поддержки в структуре порта.
Задержка в порте приблизительная. После выбора частоты CPU проверить импульсы
осциллографом и при необходимости изменить `PNAND_TMS_CPU_MHZ`.

3
c/parallel-nand/ports/tms320f2812/parallel_nand_port_tms320f2812.c
View File

@@ -56,7 +56,8 @@ static void tms_set_wp(int enabled)
static const parallel_nand_port_t tms_port = {
tms_init, tms_select, tms_deselect,
tms_write_command, tms_write_address, tms_write_data,
tms_read_data, tms_is_ready, tms_set_wp, tms_delay_us
tms_read_data, tms_is_ready, tms_set_wp, tms_delay_us,
0
};
const parallel_nand_port_t *parallel_nand_port_tms320f2812(void)

117
c/parallel-nand/src/parallel_nand.c
View File

@@ -4,8 +4,15 @@
#define PNAND_CMD_READ_2 0x30U
#define PNAND_CMD_READ_ID 0x90U
#define PNAND_CMD_READ_STATUS 0x70U
#define PNAND_CMD_PROGRAM_1 0x80U
#define PNAND_CMD_PROGRAM_2 0x10U
#define PNAND_CMD_ERASE_1 0x60U
#define PNAND_CMD_ERASE_2 0xD0U
#define PNAND_CMD_RESET 0xFFU
#define PNAND_STATUS_FAIL 0x01U
#define PNAND_STATUS_WP 0x80U
const parallel_nand_geometry_t parallel_nand_mt29f1g08_geometry = {
PNAND_MT29F1G08_PAGE_MAIN,
PNAND_MT29F1G08_PAGE_OOB,
@@ -16,6 +23,16 @@ const parallel_nand_geometry_t parallel_nand_mt29f1g08_geometry = {
1000000UL
};
const parallel_nand_geometry_t parallel_nand_hy27uf084g2m_geometry = {
PNAND_HY27UF084G2M_PAGE_MAIN,
PNAND_HY27UF084G2M_PAGE_OOB,
PNAND_HY27UF084G2M_PAGES_PER_BLOCK,
PNAND_HY27UF084G2M_BLOCKS,
PNAND_HY27UF084G2M_COLUMN_CYCLES,
PNAND_HY27UF084G2M_ROW_CYCLES,
1000000UL
};
static int port_valid(const parallel_nand_port_t *port)
{
return port != 0 && port->init != 0 && port->select != 0 &&
@@ -57,6 +74,8 @@ int parallel_nand_reset(parallel_nand_t *nand)
nand->port->select();
nand->port->write_command(PNAND_CMD_RESET);
nand->port->deselect();
/* R/B# may not fall until tWB after the command cycle. */
nand->port->delay_us(1UL);
return wait_ready(nand);
}
@@ -70,7 +89,7 @@ int parallel_nand_init(parallel_nand_t *nand,
nand->geometry = *geometry;
if (port->init() != 0) return PNAND_ERROR_PORT;
port->deselect();
/* Ядро пока только читает: аппаратно запрещаем PROGRAM/ERASE. */
/* WP# stays asserted except for the shortest possible mutation window. */
port->set_write_protect(1);
return parallel_nand_reset(nand);
}
@@ -122,6 +141,7 @@ static int begin_page_read(parallel_nand_t *nand, unsigned long page,
}
nand->port->write_command(PNAND_CMD_READ_2);
nand->port->deselect();
nand->port->delay_us(1UL); /* Cover tWB before polling R/B#. */
return wait_ready(nand);
}
@@ -167,6 +187,101 @@ int parallel_nand_read_page(parallel_nand_t *nand, unsigned long page,
return PNAND_OK;
}
static void write_address_cycles(parallel_nand_t *nand,
unsigned long value,
unsigned int count)
{
unsigned int i;
for (i = 0U; i < count; i++) {
nand->port->write_address((pnand_octet_t)(value & 0xFFUL));
value >>= 8;
}
}
static int mutation_supported(const parallel_nand_t *nand)
{
return nand != 0 && port_valid(nand->port) &&
nand->port->write_data != 0 &&
nand->port->write_supported != 0;
}
static int finish_mutation(parallel_nand_t *nand, int failure_result)
{
pnand_octet_t status = 0U;
int result = wait_ready(nand);
if (result == PNAND_OK)
result = parallel_nand_read_status(nand, &status);
nand->port->set_write_protect(1);
if (result != PNAND_OK) return result;
if ((status & PNAND_STATUS_WP) == 0U)
return PNAND_ERROR_WRITE_PROTECTED;
return (status & PNAND_STATUS_FAIL) != 0U ? failure_result : PNAND_OK;
}
int parallel_nand_program_page(parallel_nand_t *nand, unsigned long page,
const pnand_octet_t *main_data,
unsigned long main_count,
const pnand_octet_t *oob,
unsigned long oob_count)
{
unsigned long i;
unsigned long block;
int bad = 0;
int result;
if (nand == 0 || main_data == 0) return PNAND_ERROR_ARGUMENT;
if (!mutation_supported(nand)) return PNAND_ERROR_WRITE_PROTECTED;
if (page >= parallel_nand_page_count(nand)) return PNAND_ERROR_RANGE;
if (main_count != nand->geometry.page_main_size)
return PNAND_ERROR_BUFFER;
if ((oob == 0 && oob_count != 0UL) ||
(oob != 0 && oob_count != nand->geometry.page_oob_size))
return PNAND_ERROR_BUFFER;
block = page / nand->geometry.pages_per_block;
result = parallel_nand_is_bad_block(nand, block, &bad);
if (result != PNAND_OK) return result;
if (bad) return PNAND_ERROR_BAD_BLOCK;
nand->port->set_write_protect(0);
nand->port->delay_us(1UL);
nand->port->select();
nand->port->write_command(PNAND_CMD_PROGRAM_1);
write_address_cycles(nand, 0UL, nand->geometry.column_cycles);
write_address_cycles(nand, page, nand->geometry.row_cycles);
for (i = 0UL; i < main_count; i++)
nand->port->write_data(main_data[i] & 0xFFU);
for (i = 0UL; i < oob_count; i++)
nand->port->write_data(oob[i] & 0xFFU);
nand->port->write_command(PNAND_CMD_PROGRAM_2);
nand->port->deselect();
nand->port->delay_us(1UL); /* Cover tWB before polling R/B#. */
return finish_mutation(nand, PNAND_ERROR_PROGRAM_FAILED);
}
int parallel_nand_erase_block(parallel_nand_t *nand, unsigned long block)
{
unsigned long first_page;
int bad = 0;
int result;
if (nand == 0) return PNAND_ERROR_ARGUMENT;
if (!mutation_supported(nand)) return PNAND_ERROR_WRITE_PROTECTED;
if (block >= nand->geometry.block_count) return PNAND_ERROR_RANGE;
result = parallel_nand_is_bad_block(nand, block, &bad);
if (result != PNAND_OK) return result;
if (bad) return PNAND_ERROR_BAD_BLOCK;
first_page = block * nand->geometry.pages_per_block;
nand->port->set_write_protect(0);
nand->port->delay_us(1UL);
nand->port->select();
nand->port->write_command(PNAND_CMD_ERASE_1);
write_address_cycles(nand, first_page, nand->geometry.row_cycles);
nand->port->write_command(PNAND_CMD_ERASE_2);
nand->port->deselect();
nand->port->delay_us(1UL); /* Cover tWB before polling R/B#. */
return finish_mutation(nand, PNAND_ERROR_ERASE_FAILED);
}
int parallel_nand_is_bad_block(parallel_nand_t *nand, unsigned long block,
int *is_bad)
{

124
c/parallel-nand/src/parallel_nand_gas.c
View File

@@ -6,6 +6,20 @@ static unsigned int pack_pair(const pnand_octet_t *data, unsigned int index)
((data[index * 2U + 1U] & 0xFFU) << 8));
}
static void unpack_pair(pnand_octet_t *data, unsigned int index,
unsigned int value)
{
data[index * 2U] = (pnand_octet_t)(value & 0xFFU);
data[index * 2U + 1U] = (pnand_octet_t)((value >> 8) & 0xFFU);
}
static unsigned int persistent_status(const parallel_nand_gas_t *gas)
{
return gas->nand->port->write_supported != 0
? PNAND_GAS_STATUS_WRITE_SUPPORTED
: 0U;
}
parallel_nand_gas_result_t parallel_nand_gas_read(
parallel_nand_gas_t *gas, unsigned int address, unsigned int *value)
{
@@ -13,11 +27,16 @@ parallel_nand_gas_result_t parallel_nand_gas_read(
const parallel_nand_geometry_t *g;
if (gas == 0 || value == 0 || address < gas->base)
return PNAND_GAS_REJECTED;
/* Confirmation authorizes exactly the immediately following write. */
gas->destructive_armed = 0;
g = &gas->nand->geometry;
offset = address - gas->base;
if (offset >= PNAND_GAS_REGION_REGS) return PNAND_GAS_NO_REG;
if (offset >= PNAND_GAS_DATA_OFFSET &&
offset < PNAND_GAS_DATA_OFFSET + PNAND_GAS_DATA_REGS) {
if ((unsigned long)(offset - PNAND_GAS_DATA_OFFSET) * 2UL >=
g->page_main_size)
return PNAND_GAS_NO_REG;
if ((gas->status & PNAND_GAS_STATUS_PAGE_VALID) == 0U)
return PNAND_GAS_REJECTED;
*value = pack_pair(gas->main_data,
@@ -26,6 +45,9 @@ parallel_nand_gas_result_t parallel_nand_gas_read(
}
if (offset >= PNAND_GAS_OOB_OFFSET &&
offset < PNAND_GAS_OOB_OFFSET + PNAND_GAS_OOB_REGS) {
if ((unsigned long)(offset - PNAND_GAS_OOB_OFFSET) * 2UL >=
g->page_oob_size)
return PNAND_GAS_NO_REG;
if ((gas->status & PNAND_GAS_STATUS_PAGE_VALID) == 0U)
return PNAND_GAS_REJECTED;
*value = pack_pair(gas->oob,
@@ -34,7 +56,7 @@ parallel_nand_gas_result_t parallel_nand_gas_read(
}
switch (offset) {
case PNAND_GAS_REG_SIGNATURE: *value = 0x4E44U; break; /* ND */
case PNAND_GAS_REG_VERSION: *value = 0x0001U; break;
case PNAND_GAS_REG_VERSION: *value = 0x0002U; break;
case PNAND_GAS_REG_STATUS: *value = gas->status; break;
case PNAND_GAS_REG_ERROR: *value = (unsigned int)gas->error & 0xFFFFU; break;
case PNAND_GAS_REG_COMMAND: *value = PNAND_GAS_CMD_NONE; break;
@@ -50,6 +72,7 @@ parallel_nand_gas_result_t parallel_nand_gas_read(
*value = (gas->status & PNAND_GAS_STATUS_BAD_BLOCK) != 0U; break;
case PNAND_GAS_REG_GENERATION_LO: *value = (unsigned int)gas->generation & 0xFFFFU; break;
case PNAND_GAS_REG_GENERATION_HI: *value = (unsigned int)(gas->generation >> 16) & 0xFFFFU; break;
case PNAND_GAS_REG_CONFIRM: *value = 0U; break;
default: return PNAND_GAS_NO_REG;
}
*value &= 0xFFFFU;
@@ -60,7 +83,7 @@ static void finish(parallel_nand_gas_t *gas, int result)
{
gas->error = result;
gas->status &= (0xFFFFU ^ PNAND_GAS_STATUS_BUSY);
gas->status |= PNAND_GAS_STATUS_READY;
gas->status |= PNAND_GAS_STATUS_READY | persistent_status(gas);
if (result != PNAND_OK) gas->status |= PNAND_GAS_STATUS_ERROR;
}
@@ -69,7 +92,11 @@ static parallel_nand_gas_result_t run_command(parallel_nand_gas_t *gas,
{
int result = PNAND_OK;
int bad = 0;
gas->status = PNAND_GAS_STATUS_BUSY;
int armed = gas->destructive_armed;
unsigned int i;
unsigned int previous_status = gas->status;
gas->destructive_armed = 0;
gas->status = PNAND_GAS_STATUS_BUSY | persistent_status(gas);
if (command == PNAND_GAS_CMD_RESET) {
result = parallel_nand_reset(gas->nand);
} else if (command == PNAND_GAS_CMD_READ_ID) {
@@ -101,8 +128,59 @@ static parallel_nand_gas_result_t run_command(parallel_nand_gas_t *gas,
if (result == PNAND_OK && bad)
gas->status |= PNAND_GAS_STATUS_BAD_BLOCK;
}
} else if (command == PNAND_GAS_CMD_CLEAR_BUFFER) {
for (i = 0U; i < PNAND_MT29F1G08_PAGE_MAIN; i++)
gas->main_data[i] = 0xFFU;
for (i = 0U; i < PNAND_MT29F1G08_PAGE_OOB; i++)
gas->oob[i] = 0xFFU;
gas->status |= PNAND_GAS_STATUS_PAGE_VALID |
PNAND_GAS_STATUS_BUFFER_DIRTY;
gas->generation++;
} else if (command == PNAND_GAS_CMD_PROGRAM_PAGE) {
if (!armed ||
(previous_status & PNAND_GAS_STATUS_PAGE_VALID) == 0U) {
gas->status |= previous_status &
(PNAND_GAS_STATUS_PAGE_VALID |
PNAND_GAS_STATUS_BUFFER_DIRTY |
PNAND_GAS_STATUS_BAD_BLOCK);
finish(gas, PNAND_ERROR_CONFIRMATION);
return PNAND_GAS_REJECTED;
}
result = parallel_nand_program_page(
gas->nand, gas->selected_page,
gas->main_data, gas->nand->geometry.page_main_size,
gas->oob, gas->nand->geometry.page_oob_size);
gas->status |= PNAND_GAS_STATUS_PAGE_VALID;
if (result == PNAND_OK) {
gas->generation++;
gas->block_cache_valid = 0;
} else {
gas->status |= PNAND_GAS_STATUS_BUFFER_DIRTY;
}
} else if (command == PNAND_GAS_CMD_ERASE_BLOCK) {
unsigned long block;
if (!armed ||
gas->selected_page >= parallel_nand_page_count(gas->nand)) {
finish(gas, !armed ? PNAND_ERROR_CONFIRMATION :
PNAND_ERROR_RANGE);
return PNAND_GAS_REJECTED;
}
block = gas->selected_page / gas->nand->geometry.pages_per_block;
result = parallel_nand_erase_block(gas->nand, block);
if (result == PNAND_OK) {
gas->status &= (0xFFFFU ^ (PNAND_GAS_STATUS_PAGE_VALID |
PNAND_GAS_STATUS_BUFFER_DIRTY |
PNAND_GAS_STATUS_BAD_BLOCK));
gas->generation++;
gas->block_cache_valid = 0;
} else {
gas->status |= previous_status &
(PNAND_GAS_STATUS_PAGE_VALID |
PNAND_GAS_STATUS_BUFFER_DIRTY |
PNAND_GAS_STATUS_BAD_BLOCK);
}
} else {
gas->status = PNAND_GAS_STATUS_READY;
gas->status = PNAND_GAS_STATUS_READY | persistent_status(gas);
return PNAND_GAS_REJECTED;
}
finish(gas, result);
@@ -119,18 +197,47 @@ parallel_nand_gas_result_t parallel_nand_gas_write(
if ((gas->status & PNAND_GAS_STATUS_BUSY) != 0U)
return PNAND_GAS_REJECTED;
value &= 0xFFFFU;
if (offset >= PNAND_GAS_DATA_OFFSET &&
offset < PNAND_GAS_DATA_OFFSET + PNAND_GAS_DATA_REGS) {
unsigned int index = offset - PNAND_GAS_DATA_OFFSET;
if ((gas->status & PNAND_GAS_STATUS_PAGE_VALID) == 0U ||
(unsigned long)index * 2UL >= gas->nand->geometry.page_main_size)
return PNAND_GAS_REJECTED;
gas->destructive_armed = 0;
unpack_pair(gas->main_data, index, value);
gas->status |= PNAND_GAS_STATUS_BUFFER_DIRTY;
return PNAND_GAS_OK;
}
if (offset >= PNAND_GAS_OOB_OFFSET &&
offset < PNAND_GAS_OOB_OFFSET + PNAND_GAS_OOB_REGS) {
unsigned int index = offset - PNAND_GAS_OOB_OFFSET;
if ((gas->status & PNAND_GAS_STATUS_PAGE_VALID) == 0U ||
(unsigned long)index * 2UL >= gas->nand->geometry.page_oob_size)
return PNAND_GAS_REJECTED;
gas->destructive_armed = 0;
unpack_pair(gas->oob, index, value);
gas->status |= PNAND_GAS_STATUS_BUFFER_DIRTY;
return PNAND_GAS_OK;
}
switch (offset) {
case PNAND_GAS_REG_COMMAND: return run_command(gas, value);
case PNAND_GAS_REG_CONFIRM:
gas->destructive_armed = value == PNAND_GAS_CONFIRM_MAGIC;
return gas->destructive_armed ? PNAND_GAS_OK : PNAND_GAS_REJECTED;
case PNAND_GAS_REG_PAGE_LO:
gas->destructive_armed = 0;
gas->selected_page = (gas->selected_page & 0xFFFF0000UL) | value;
gas->status &= (0xFFFFU ^ PNAND_GAS_STATUS_PAGE_VALID);
return PNAND_GAS_OK;
case PNAND_GAS_REG_PAGE_HI:
gas->destructive_armed = 0;
gas->selected_page = (gas->selected_page & 0x0000FFFFUL) |
((unsigned long)value << 16);
gas->status &= (0xFFFFU ^ PNAND_GAS_STATUS_PAGE_VALID);
return PNAND_GAS_OK;
default: return PNAND_GAS_READ_ONLY;
default:
gas->destructive_armed = 0;
return PNAND_GAS_READ_ONLY;
}
}
@@ -140,12 +247,17 @@ void parallel_nand_gas_init(parallel_nand_gas_t *gas,
unsigned int i;
gas->nand = nand;
gas->base = base;
gas->status = PNAND_GAS_STATUS_READY;
gas->status = PNAND_GAS_STATUS_READY | persistent_status(gas);
gas->error = PNAND_OK;
gas->selected_page = 0UL;
gas->generation = 0UL;
gas->cached_block = 0UL;
gas->cached_bad_block = 0;
gas->block_cache_valid = 0;
gas->destructive_armed = 0;
for (i = 0U; i < 8U; i++) gas->id[i] = 0U;
for (i = 0U; i < PNAND_MT29F1G08_PAGE_MAIN; i++)
gas->main_data[i] = 0xFFU;
for (i = 0U; i < PNAND_MT29F1G08_PAGE_OOB; i++)
gas->oob[i] = 0xFFU;
}

179
c/parallel-nand/tests/test_parallel_nand.c
View File

@@ -5,7 +5,7 @@
#include "parallel_nand_gas.h"
typedef struct { char kind; unsigned int value; } event_t;
static event_t events[64];
static event_t events[256];
static unsigned int event_count;
static pnand_octet_t input_data[32];
static unsigned int input_count;
@@ -33,17 +33,35 @@ static void fake_delay(unsigned long us) { (void)us; }
static const parallel_nand_port_t fake_port = {
fake_init, fake_select, fake_deselect, fake_cmd, fake_addr, fake_write,
fake_read, fake_ready, fake_wp, fake_delay
fake_read, fake_ready, fake_wp, fake_delay, 1
};
static void clear_events(void) { event_count = 0U; }
static unsigned int find_event(unsigned int start, char kind,
unsigned int value)
{
unsigned int i;
for (i = start; i < event_count; i++) {
if (events[i].kind == kind && events[i].value == value) return i;
}
return event_count;
}
int main(void)
{
parallel_nand_t nand;
pnand_octet_t id[2];
pnand_octet_t bytes[2];
pnand_octet_t main_data[2] = {0xAAU, 0x55U};
pnand_octet_t oob[2] = {0xFFU, 0xFEU};
parallel_nand_gas_t gas;
parallel_nand_geometry_t small_geometry = {
2UL, 2UL, 2UL, 4UL, 2U, 2U, 100UL
};
parallel_nand_port_t read_only_port;
parallel_nand_t read_only_nand;
unsigned int pos;
unsigned int reg;
assert(parallel_nand_init(&nand, &fake_port,
@@ -76,9 +94,116 @@ int main(void)
assert(events[5].kind == 'A' && events[5].value == 0x12U);
assert(events[6].kind == 'C' && events[6].value == 0x30U);
assert(parallel_nand_init(&nand, &fake_port,
&parallel_nand_hy27uf084g2m_geometry) == PNAND_OK);
assert(parallel_nand_page_count(&nand) == 262144UL);
assert(PNAND_HY27UF084G2M_MANUFACTURER_ID == 0xADU);
assert(PNAND_HY27UF084G2M_DEVICE_ID == 0xDCU);
clear_events();
input_data[0] = 0xABU;
input_count = 1U;
input_pos = 0U;
assert(parallel_nand_read_page_slice(&nand, 0x23456UL, 0x78UL,
bytes, 1UL) == PNAND_OK);
assert(bytes[0] == 0xABU);
assert(events[2].kind == 'A' && events[2].value == 0x78U);
assert(events[3].kind == 'A' && events[3].value == 0x00U);
assert(events[4].kind == 'A' && events[4].value == 0x56U);
assert(events[5].kind == 'A' && events[5].value == 0x34U);
assert(events[6].kind == 'A' && events[6].value == 0x02U);
assert(events[7].kind == 'C' && events[7].value == 0x30U);
assert(parallel_nand_init(&nand, &fake_port, &small_geometry) ==
PNAND_OK);
clear_events();
input_data[0] = 0xFFU;
input_data[1] = 0xFFU;
input_data[2] = 0x80U;
input_count = 3U;
input_pos = 0U;
assert(parallel_nand_program_page(&nand, 3UL, main_data, 2UL,
oob, 2UL) == PNAND_OK);
pos = find_event(0U, 'P', 0U);
assert(pos < event_count);
pos = find_event(pos + 1U, 'C', 0x80U);
assert(pos < event_count);
pos = find_event(pos + 1U, 'W', 0xAAU);
assert(pos < event_count);
pos = find_event(pos + 1U, 'W', 0x55U);
assert(pos < event_count);
pos = find_event(pos + 1U, 'W', 0xFFU);
assert(pos < event_count);
pos = find_event(pos + 1U, 'W', 0xFEU);
assert(pos < event_count);
pos = find_event(pos + 1U, 'C', 0x10U);
assert(pos < event_count);
pos = find_event(pos + 1U, 'C', 0x70U);
assert(pos < event_count);
assert(events[event_count - 1U].kind == 'P' &&
events[event_count - 1U].value == 1U);
clear_events();
input_data[0] = 0xFFU;
input_data[1] = 0xFFU;
input_data[2] = 0x80U;
input_count = 3U;
input_pos = 0U;
assert(parallel_nand_erase_block(&nand, 2UL) == PNAND_OK);
pos = find_event(0U, 'P', 0U);
pos = find_event(pos + 1U, 'C', 0x60U);
assert(pos < event_count);
pos = find_event(pos + 1U, 'A', 0x04U);
assert(pos < event_count);
pos = find_event(pos + 1U, 'C', 0xD0U);
assert(pos < event_count);
assert(events[event_count - 1U].kind == 'P' &&
events[event_count - 1U].value == 1U);
clear_events();
input_data[0] = 0xFFU;
input_data[1] = 0xFFU;
input_data[2] = 0x81U;
input_count = 3U;
input_pos = 0U;
assert(parallel_nand_program_page(&nand, 0UL, main_data, 2UL,
0, 0UL) ==
PNAND_ERROR_PROGRAM_FAILED);
assert(events[event_count - 1U].kind == 'P' &&
events[event_count - 1U].value == 1U);
clear_events();
input_data[0] = 0xFFU;
input_data[1] = 0xFFU;
input_data[2] = 0x00U;
input_count = 3U;
input_pos = 0U;
assert(parallel_nand_program_page(&nand, 0UL, main_data, 2UL,
0, 0UL) ==
PNAND_ERROR_WRITE_PROTECTED);
assert(events[event_count - 1U].kind == 'P' &&
events[event_count - 1U].value == 1U);
clear_events();
input_data[0] = 0x00U;
input_count = 1U;
input_pos = 0U;
assert(parallel_nand_erase_block(&nand, 0UL) ==
PNAND_ERROR_BAD_BLOCK);
assert(find_event(0U, 'P', 0U) == event_count);
read_only_port = fake_port;
read_only_port.write_supported = 0;
assert(parallel_nand_init(&read_only_nand, &read_only_port,
&small_geometry) == PNAND_OK);
assert(parallel_nand_erase_block(&read_only_nand, 0UL) ==
PNAND_ERROR_WRITE_PROTECTED);
parallel_nand_gas_init(&gas, &nand, PNAND_GAS_DEFAULT_BASE);
assert(parallel_nand_gas_read(&gas, 0xE000U, &reg) == PNAND_GAS_OK);
assert(reg == 0x4E44U);
assert(parallel_nand_gas_read(&gas, 0xE001U, &reg) == PNAND_GAS_OK);
assert(reg == 0x0002U);
assert(parallel_nand_gas_write(&gas, 0xE005U, 0x1234U) ==
PNAND_GAS_OK);
assert(parallel_nand_gas_write(&gas, 0xE006U, 0x0001U) ==
@@ -92,6 +217,56 @@ int main(void)
assert(parallel_nand_gas_write(&gas, 0xE000U, 0U) ==
PNAND_GAS_READ_ONLY);
assert((gas.status & PNAND_GAS_STATUS_WRITE_SUPPORTED) != 0U);
assert(parallel_nand_gas_write(&gas, 0xE005U, 0U) == PNAND_GAS_OK);
assert(parallel_nand_gas_write(&gas, 0xE006U, 0U) == PNAND_GAS_OK);
assert(parallel_nand_gas_write(&gas, 0xE004U,
PNAND_GAS_CMD_CLEAR_BUFFER) ==
PNAND_GAS_OK);
assert(parallel_nand_gas_write(&gas, 0xE100U, 0x1234U) ==
PNAND_GAS_OK);
assert(gas.main_data[0] == 0x34U && gas.main_data[1] == 0x12U);
assert(parallel_nand_gas_write(&gas, 0xE004U,
PNAND_GAS_CMD_PROGRAM_PAGE) ==
PNAND_GAS_REJECTED);
assert(gas.error == PNAND_ERROR_CONFIRMATION);
assert(parallel_nand_gas_write(&gas, 0xE010U,
PNAND_GAS_CONFIRM_MAGIC) ==
PNAND_GAS_OK);
assert(parallel_nand_gas_read(&gas, 0xE002U, &reg) == PNAND_GAS_OK);
assert(parallel_nand_gas_write(&gas, 0xE004U,
PNAND_GAS_CMD_PROGRAM_PAGE) ==
PNAND_GAS_REJECTED);
assert(gas.error == PNAND_ERROR_CONFIRMATION);
input_data[0] = 0xFFU;
input_data[1] = 0xFFU;
input_data[2] = 0x80U;
input_count = 3U;
input_pos = 0U;
assert(parallel_nand_gas_write(&gas, 0xE010U,
PNAND_GAS_CONFIRM_MAGIC) ==
PNAND_GAS_OK);
assert(parallel_nand_gas_write(&gas, 0xE004U,
PNAND_GAS_CMD_PROGRAM_PAGE) ==
PNAND_GAS_OK);
assert((gas.status & PNAND_GAS_STATUS_BUFFER_DIRTY) == 0U);
assert(parallel_nand_gas_write(&gas, 0xE005U, 2U) == PNAND_GAS_OK);
input_data[0] = 0xFFU;
input_data[1] = 0xFFU;
input_data[2] = 0x80U;
input_count = 3U;
input_pos = 0U;
assert(parallel_nand_gas_write(&gas, 0xE010U,
PNAND_GAS_CONFIRM_MAGIC) ==
PNAND_GAS_OK);
assert(parallel_nand_gas_write(&gas, 0xE004U,
PNAND_GAS_CMD_ERASE_BLOCK) ==
PNAND_GAS_OK);
assert((gas.status & PNAND_GAS_STATUS_PAGE_VALID) == 0U);
puts("parallel_nand: OK");
return 0;
}