snark13/Sprinter-SDCC
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

libc: IM2 Phase 2b — звук CBL/COVOX через callback fill(), без кольца libc

Browse Source 
CBL уже имеет аппаратный буфер 256 Б (2×128, двойная буферизация на
стороне железа) — держать поверх него ещё одно кольцо в libc было бы
лишней копией. cbl_open(freq, fmt, pump_mode, underrun_mode, fill)
регистрирует callback, вызываемый из ISR за очередным блоком; он сам
пропихивает данные приложения (откуда угодно) через cbl_push_otir()/
cbl_push_accel() — без промежуточного буфера.

- два насоса: OTIR (порт 0x4F) и ACCEL (акселератор, спец-страница
  EMM 0xFD@0xC000); OTIR+16-бит запрещён (EINVAL) — по исходнику MAME
  порт данных физически не может собрать 16-бит сэмпл из пары байт;
- форматы CBL_FMT_MONO8/16/STEREO8/16, частоты 7.8..109к;
- CBL_UNDERRUN_APP (по умолчанию, недолив не наша забота) /
  CBL_UNDERRUN_SILENCE (буфер тишины malloc'ится только в этом режиме);
- tests/cbltest: матрица 64 комбинации (2 насоса × 8 форматов × 4
  частоты); tests/cblwav: banked-стрим речи с дискеты (физстраницы
  кэшированы заранее — mem_get_page нельзя звать из fill()/ISR);
  tests/cblstream: единственный случай с собственным кольцом уровня
  приложения (диск нельзя читать из fill()).

Verified в MAME 2026-07-07 — все три теста работают.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Alexander Petrov
2026-07-07 21:21:54 +03:00
parent 8a952b99eb
commit 5086c47f0f
28 changed files with 1208 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Makefile
+2 -1
View File
@@ -16,7 +16,7 @@
TESTS := hello hello2 simple banked bankedbg banktest strtest cat seek \
malloc mem_test argv errno rt_test openenv ls conio conio2 \
attrprob timedir mouse banklocl stdlib assrtest ptime stattest \
filetest fdmax fbench solidt irqtest dec_test gets stest2 winrest \
filetest fdmax fbench solidt irqtest cbltest cblwav dec_test gets stest2 winrest \
bios_text text_palette \
gfx_demo gfx_d16 gfx_text gfx_mous gfx_dbuf
@@ -34,6 +34,7 @@ ALL_EXES := $(TEST_EXES) $(APP_EXES)
DATA_FILES := \
tests/cat/test.txt \
tests/seek/big.txt \
tests/cblwav/speech.pcm \
examples/mdview/SAMPLE.MD
.PHONY: all tools lib tests examples check clean sdcc floppy \
docs/TODO.md
+16
View File
@@ -84,6 +84,22 @@ Quick wins:
dual-write тест → если работает, кэшировать Port_Y в putpixel
(~8× меньше OUT для Брезенхэма); если нет — вычистить из доков.
- [ ] fdmax: лимит манипуляторов и зависание 9-го OPEN — MAME vs железо.
- [ ] CBL: щелчок перед первым проигрыванием звука за сессию (tests/
cbltest, tests/cblwav) — воспроизводится ТОЛЬКО на первом запуске
программы за сессию MAME, не зависит от содержимого потока
(тон/тишина/речь одинаково). Похоже на разовый прогрев звуковой
подсистемы MAME при первой активации канала — на реальном железе
скорее всего отсутствует. Проверить и закрыть либо описать как
реальный аппаратный эффект.
- [ ] **CBL: помехи в звуке при движении мыши** (tests/cblstream,
2026-07-07) — при потоковом воспроизведении движение мыши даёт
слышимые артефакты. Гипотеза (НЕ подтверждена): мышь может
делить SIO-канал/детект-бит с клавиатурой (порт 0x19 бит 0,
см. _irq_tramp.c), и трамплин классифицирует байты мыши как
«клавиатура» → сразу chain на DSS (0x0038), пропуская проверку
CBL-хука для ЭТОГО прерывания — при движении мыши часть тиков,
которые должны были обслужить CBL-насос, уходят мимо, кольцо
недоливается. Нужно исследование (MAME-дамп/лог трамплина).
## Known quirks (зафиксированы, обходы в libc)
docs/im2_isr_design.md
+154 -6
View File
@@ -1,7 +1,13 @@
# IM2 Interrupt Handlers — Design Document
**Status: Phase 1 РЕАЛИЗОВАН 2026-07-06, ИСПРАВЛЕН после отладки**
(libc/irq: irq_install/irq_remove + трамплин; тест tests/irqtest).
**Status: Phase 1 (2026-07-06), Phase 2a CTC (2026-07-07), Phase 2b CBL
(2026-07-07, редизайн на callback без кольца — см. ниже) РЕАЛИЗОВАНЫ**
(libc/irq: irq_install/irq_remove + трамплин, irq_ctc_install/remove;
libc/cbl: cbl_open/close/push_otir/push_accel + fill-callback; тесты
tests/irqtest, tests/cbltest, tests/cblwav, tests/cblstream).
Callback-редизайн **verified в MAME 2026-07-07**: все три CBL-теста
(cbltest — матрица 64 комбинации; cblwav — banked-стрим, голос слышен;
cblstream — собственное кольцо приложения) работают.
## Результаты verification (2026-07-06, по docs/samples и исходникам MAME)
@@ -77,9 +83,151 @@ SIO_CTC_KEY.asm):
I/IM 1; atexit-уборка глушит CTC ОБЯЗАТЕЛЬНО (иначе после выхода
прерывания кГц-частоты душат шелл).
Phase 2b (CBL/COVOX handler — вернуть фильтр 0xFE.7 при активном CBL,
sample-буфер; фундамент Audio API), ISA-вектора, цепочки нескольких
хендлеров — не реализовано.
## Phase 2b — CBL/COVOX audio (РЕАЛИЗОВАН 2026-07-07, редизайн без кольца)
`libc/include/cbl.h`: `cbl_open(freq_code, fmt, pump_mode,
underrun_mode, fill)` / `cbl_close()` / `cbl_push_otir(src,n)` /
`cbl_push_accel(src,n)` / `cbl_requests()` / `cbl_underruns()`. По
`docs/samples/Пример для CBL.asm`, разделу «Звук через COVOX-Blaster»
в `docs/converted/Forum.txt`, официальной документации "5.3
COVOX-Blaster" (see below) и `docs/converted/accel_r.txt`:
**Архитектурный редизайн (2026-07-07)**: у CBL УЖЕ ЕСТЬ собственный
аппаратный буфер 256 Б, разбитый на ДВЕ половины по 128 Б (double
buffering целиком на стороне железа — см. официальную доку: "Блок ОЗУ
256 байт условно разбит на две банки по 128 байт, и бит 7 порта #FE
указывает какая из банок ОЗУ выводится в ЦАП... используется программой
вывода для определения, нужно ли подгружать следующие 128 байт").
Держать ЕЩЁ ОДНО кольцо в libc поверх этого — лишний второй буфер и
лишняя копия. Библиотека теперь НЕ хранит кольца: при cbl_open()
регистрируется callback `fill(n)`, который ISR вызывает НАПРЯМУЮ, а
callback сам пропихивает n байт ИЗ ДАННЫХ ПРИЛОЖЕНИЯ (статический
массив, банковая EMM-страница, файл — что угодно) прямо в CBL через
`cbl_push_otir()`/`cbl_push_accel()` — без промежуточной копии в libc.
Пример из офиц. документации делает ровно это: `OUTI` читает прямо из
HL, указывающего в банковую страницу с WAV-данными, без всякого
стейджинга.
`fill(n)` вызывается ИЗ ISR — ОБЯЗАН быть быстрым: никаких
ESTEX/BIOS/gfx-вызовов (тот же констрейнт, что у `irq_install()`-
хендлера). В частности, диск (read() — ESTEX) читать из fill() НЕЛЬЗЯ
— см. tests/cblstream ниже, где под это заведено собственное кольцо
уровня приложения. Возвращает ненулевое при успехе, 0 — недолив.
- **Control-порт 0x004E — 16-битный** (`ld bc,#0x004E` / `out (c),a`,
не 8-битный `out (n),a`). Биты: 7 = CBL on, 6 = stereo, 5 = 16-bit,
4 = interrupt enable, 3..0 = код частоты (8=7.8125 кГц…F=109.375 кГц,
0/1 — legacy-режим без сэмплирования). `cbl_open` шлёт
`0x90|fmt|freq` (on + int + формат + частота) под DI, `cbl_close`
шлёт `0`.
- **Формат — CBL_FMT_MONO8/MONO16/STEREO8/STEREO16** (2026-07-07):
биты 5(16-бит)/6(stereo) напрямую соответствуют константам, можно
OR'ить с freq. Блок запроса — 128 Б для 8-бит, 256 Б для 16-бит
(НЕ зависит от моно/стерео — см. Forum.txt: «для каждых 128 байт
(256 в режиме 16 бит)»); тишина — 0x80 (8-бит unsigned) или 0x0000
(16-бит signed). 8-бит сэмплы центр 0x80, 16-бит центр 0x0000,
stereo — чередование L/R. Runtime-размер блока — `_cbl_block`
(128 или 256), заполняется в `cbl_open` по fmt.
- **Два насоса, выбор — CBL_PUMP_OTIR/CBL_PUMP_ACCEL** (2026-07-07):
- **OTIR** (`_cbl_pump_otir`) — блок в порт 0x4F через `otir`; B=младший
байт `_cbl_block` (128 остаётся 128, 256 идёт как 0 — Z80 OTIR:
B=0 значит 256 итераций). Проверено в MAME (звук слышен, 0
underrun).
- **ACCEL** (`_cbl_pump_accel`) — запись через акселератор в
спец-страницу EMM 0xFD, замапленную в окно W3 на 0xC000 (Forum.txt:
«запись данных в COVOX-Blaster... 128/256 байт с адреса 0xC000»).
Последовательность (по accel_r.txt + рабочему прецеденту
libc/gfx/_gfx_hfill256.c): `LD D,D` (режим размера блока) →
immediate `LD A,n` (SMC-патч, 0 значит 256 — тот же трюк, что и в
OTIR) → `LD L,L` (режим "копирование блока") → `LD A,(HL)` /
`LD (DE),A` (блочное чтение источника → блочная запись в
0xC000@стр.0xFD) → `LD B,B` (выкл). Акселератор НЕ продвигает
HL/DE сам — advance после пересылки делается вручную (`add hl,
(block)`). W3 сохраняется/восстанавливается вокруг переключения
(как `bank_read`/`bank_write`); доп. DI/EI не нужны — весь насос
целиком уже внутри ISR (прерывания замаскированы до EI/RETI
трамплина). **Verified в MAME 2026-07-07** — tests/cbltest, все
32 accel-комбинации матрицы прошли без ошибок/underrun.
- Общий каприз с CBL-примером из docs/samples: там для установки
размера блока акселератора используется `LD C,128` СРАЗУ ЗА
`LD D,D` — это противоречит и accel_r.txt («далее следует команда
типа LD A,dat»), и нашему же подтверждённому на gfx констрейнту
(CLAUDE.md: «block-size ОБЯЗАН быть immediate операндом LD A,n»).
Мы взяли ВЕРИФИЦИРОВАННЫЙ вариант (LD A,n), а не пример — вероятно,
у автора размер уже был установлен раньше (заметка в accel_r.txt:
«если размер блока был установлен ранее, его можно не
устанавливать»), и `LD C,128` в примере готовит BC для последующего
`ADD HL,BC`, а не для акселератора.
- **Data-порт 0x4F** (для OTIR-насоса), блок 128/256 байт.
- **Признак запроса блока — бит 7 порта 0xFE — валиден ТОЛЬКО когда
CBL реально активен.** При выключенном CBL MAME (`kbd_fe_r`)
подтягивает этот бит к 1 всегда (`data |= 0xE0`) — поэтому трамплин
проверяет бит 0xFE.7 не напрямую, а через индирекцию
`_irq_cbl_hook`: пока `cbl_open` не установил хук, кадровые
прерывания даже не читают порт 0xFE (см. Phase 1 — по этой же
причине первая версия фильтра была убрана). Официальная документация
описывает тот же бит как "старший бит счётчика" адреса аппаратного
буфера — по нему же программа определяет, какую половину доливать.
- **Насос (`_cbl_pump_otir`/`_cbl_pump_accel`) теперь тривиален**:
`_cbl_reqs++; ok = _cbl_fill ? _cbl_fill(_cbl_block) : 0; if (!ok) {
_cbl_undr++; ...}`. Обычные (не `__naked`) Си-функции — можно, т.к.
трамплин уже сохраняет ВЕСЬ контекст (оба регистровых набора + IX/IY)
вокруг вызова хука, что бы функция ни наделала с регистрами.
- **Поведение при недоливе — CBL_UNDERRUN_APP/SILENCE** (4-й параметр
cbl_open, 2026-07-07): по умолчанию (`APP`, 0) недолив — не забота
библиотеки, буфер тишины НЕ аллоцируется вовсе, в CBL доигрывает то,
что уже лежало в его аппаратном буфере. `SILENCE` (1) — насос сам
пропихивает тишину (`_cbl_silence`, malloc'ится В cbl_open() ТОЛЬКО
в этом режиме, размером `_cbl_block`, залит 0x80/0x0000 по формату) —
тот же приём, что раньше был жёстко вшит в насос, теперь опционален.
`cbl_underruns()` считает недоливы в ОБОИХ режимах — это только
диагностика.
- **CBL-путь НЕ чейнится к DSS** — личное прерывание CBL, полный сейв
контекста (основной набор + теневой AF/BC/DE/HL + IX/IY, т.к. `fill()`
может клобберить что угодно) → `EI`/`RETI` напрямую, без 0x0038.
- `cbl_open` держит те же анти-повторные гарантии, что и irq/ctc:
занятый хук → EBUSY, `atexit(cbl_close)` регистрируется один раз,
`_irq_table_ref()`/`_irq_table_unref()` для общей IM2-таблицы.
- **tests/cbltest**: полная матрица (2 насоса × 8 форматов × 4 частоты
= 64 комбинации) пилообразного тона, ~1 с каждая; `fill_tone()`
всегда возвращает 1 (period-64 тон никогда не "кончается") —
CBL_UNDERRUN_APP без буфера тишины достаточно. Main не поллит
ничего — просто ждёт halt()'ом. OTIR+16-бит (16/64) пропускаются
заранее (cbl_open вернул бы EINVAL).
- **tests/cblwav**: потоковая речь (78 КБ) с ДИСКЕТЫ через banked EMM
(диск слишком медленный для realtime — клип предзагружается в RAM
ДО cbl_open). `fill_speech()` делает `bank_read()` из уже загруженной
страницы в стейджинг и `cbl_push_otir()` — физические номера страниц
кэшированы в массиве ЗАРАНЕЕ (на этапе загрузки, в main-контексте):
`mem_get_page()` — BIOS-вызов, сам управляет EI/DI, и звать его ИЗ
fill() (то есть из ISR) нельзя — его `ei` при возврате может
преждевременно снять маску прерываний, пока мы ещё внутри ISR.
- **tests/cblstream**: без banked-предзагрузки — чтение с диска
ОДНОВРЕМЕННО с воспроизведением; рассчитан на быстрый носитель (HDD).
Единственный из трёх тестов, где приложению НУЖНО собственное кольцо:
`read()` — ESTEX-вызов, а `fill()` зовётся из ISR, где ESTEX/BIOS под
запретом — поэтому диск читается ТОЛЬКО в main (в кольцо уровня
приложения), а `fill_stream()` лишь копирует уже готовые байты и
пропихивает `cbl_push_otir()`. НЕ входит в общую сборку (`make`/
`make floppy`) — только `cd tests/cblstream && make run`, свой образ
диска.
ISA-вектора, цепочки нескольких хендлеров на одном векторе — не
реализовано (см. «Phase 2 (когда понадобится)» ниже).
**Щелчок перед первым звуком за сессию (2026-07-07, A/B/C-стенд)**:
на РЕАЛЬНОМ файле (tests/cblwav, потоковая речь) перед началом
воспроизведения был слышен щелчок/призвук. Диагностика через
tests/cblwav (banked-стрим с пилой, затем с чистой тишиной вместо
речи, в одном запуске) показала: щелчок слышен ТОЛЬКО на первом
запуске программы после старта MAME и НЕ зависит от содержимого потока
(тон / тишина / речь — одинаково). Проверенное на macOS (`afplay`)
воспроизведение исходного speech.pcm — чистое, артефактов в самом
файле нет. Разбивка `cbl_open()` на две записи в порт 0x004E (сначала
код частоты, потом enable, с паузой) не повлияла — отменена. Вывод:
это одноразовый прогрев звуковой подсистемы MAME при первой активации
канала CBL за сессию эмулятора, не баг протокола/драйвера; на реальном
железе, скорее всего, отсутствует (см. docs/TODO.md).
Этот документ собирает всё, что мы знаем о прерываниях Sprinter и план реализации user-задаваемых ISR через Z80 IM 2 mode. Когда возьмёмся за реализацию — читать этот файл, чтобы не повторять research.
@@ -247,7 +395,7 @@ User's ISR НЕ должен:
## Phase 2 (когда понадобится)
- CBL/COVOX prerequisite handler (для audio playback)
- ~~CBL/COVOX prerequisite handler~~ — реализован, см. «Phase 2b» выше
- ISA interrupt handler (для ZX-Bus карт)
- Multiple user handler chain (e.g. tick + sound)
docs/libc-reference.md
+56
View File
@@ -168,6 +168,62 @@ font[row*256+char]).
Handler'у нельзя: ESTEX/BIOS-вызовы, gfx_*/своп окон, акселератор,
banked-функции; только volatile-глобалы и быстрая работа (<1 мс).
## <cbl.h> — потоковый звук CBL/COVOX (вектор 0xFF, свой ISR)
Без собственного кольца (2026-07-07): у CBL уже есть аппаратный буфер
256 Б (2×128, двойная буферизация на стороне железа — см. официальную
доку "5.3 COVOX-Blaster"); библиотека просто зовёт `fill()` приложения
ИЗ ISR, а оно само пропихивает данные (откуда угодно) через
`cbl_push_otir/accel` — без промежуточной копии.
| Сигнатура | Описание |
|---|---|
| `int cbl_open(freq_code, fmt, pump_mode, underrun_mode, fill)` | включить CBL (`0x90\|fmt\|freq`), зарегистрировать callback; 0 / -1+errno (EBUSY повтор, EINVAL — freq/fmt/pump_mode/underrun_mode плохие или OTIR+16-бит, ENOMEM — буфер тишины) |
| `void cbl_close(void)` | выключить CBL, снять хук, освободить буфер тишины (если был); висит на atexit |
| `void cbl_push_otir(const void *src, uint16_t n)` | пропихнуть n байт через `otir` в порт 0x4F; звать ИЗ fill() |
| `void cbl_push_accel(const void *src, uint16_t n)` | то же акселератором (страница EMM 0xFD@0xC000); единственный путь для 16-бит |
| `uint16_t cbl_requests(void)` | счётчик запросов блока ISR (~fs/(сэмплов в блоке) в секунду) |
| `uint16_t cbl_underruns(void)` | счётчик недоливов (`fill` вернул 0 или не задан) |
| `CBL_FREQ_7K8 .. CBL_FREQ_109K` | коды частоты (биты 3..0 control-порта) |
| `CBL_FMT_MONO8/MONO16/STEREO8/STEREO16` | формат (биты 5/6 control-порта); блок 128 Б (8-бит) или 256 Б (16-бит), не зависит от моно/стерео; тишина 0x80 (8-бит) / 0x0000 (16-бит, знаковый) |
| `CBL_PUMP_OTIR / CBL_PUMP_ACCEL` | способ выдачи — см. ниже |
| `CBL_UNDERRUN_APP / CBL_UNDERRUN_SILENCE` | поведение при недоливе — см. ниже |
`typedef int (*cbl_fill_fn)(uint16_t n);` — callback, зовётся ИЗ ISR за
очередным блоком (n = `_cbl_block`, 128/256). **Обязан быть быстрым**
— никаких ESTEX/BIOS/gfx-вызовов (тот же констрейнт, что у
`irq_install()`-хендлера); вернуть ненулевое, если реально пропихнул n
байт. Диск (read()) читать из fill() НЕЛЬЗЯ — см. tests/cblstream,
где под это заведено кольцо уровня приложения.
Два насоса (3-й параметр `cbl_open`):
- **OTIR** (`_cbl_pump_otir`) — `cbl_push_otir()` в порт 0x4F; базовый.
**НЕ умеет 16-бит** — `cbl_open(..., MONO16/STEREO16, CBL_PUMP_OTIR,
...)` вернёт EINVAL: по исходнику MAME (sprinter.cpp) порт данных
ВСЕГДА кладёт байт как есть в один слот, не собирая пару байт в
16-бит значение и не сверяясь с 16-бит флагом вообще.
- **ACCEL** (`_cbl_pump_accel`) — `cbl_push_accel()` через акселератор
в спец-страницу EMM 0xFD, замапленную в окно W3 на 0xC000 (см.
docs/converted/accel_r.txt, Forum.txt); размер блока патчится SMC
(`LD D,D` + immediate `LD A,n` + `LD L,L` — тот же паттерн, что и в
libc/gfx/_gfx_hfill256.c); единственный путь для 16-бит.
**Verified в MAME 2026-07-07** (tests/cbltest, вся accel-половина
матрицы прошла без ошибок/underrun).
Поведение при недоливе (4-й параметр `cbl_open`):
- **CBL_UNDERRUN_APP** (по умолчанию, 0) — не забота библиотеки, буфер
тишины НЕ аллоцируется, в CBL доигрывает то, что уже лежало в его
аппаратном буфере.
- **CBL_UNDERRUN_SILENCE** (1) — насос сам пропихивает тишину; буфер
(128/256 Б по формату) аллоцируется malloc'ом ВНУТРИ `cbl_open()`
только в этом режиме.
`cbl_underruns()` считает недоливы в обоих режимах — диагностика,
поведение не меняет.
Приватное прерывание, к DSS не чейнится; бит 7 порта 0xFE (запрос
блока) читается только пока `cbl_open` не закрыт (при выключенном CBL
бит всегда 1 — MAME-квирк).
## <palette.h> — низкий уровень (BIOS $A4/$A6)
`pal_load pal_get pal_set_color pal_get_color` (страница 0..7,
docs/size_baseline.tsv
+4 -1
View File
@@ -8,6 +8,9 @@ banklocl 4832
banktest 3767
bios_text 4470
cat 915
cblstream 6234
cbltest 6374
cblwav 6443
conio 4634
conio2 3946
dec_test 860
@@ -23,7 +26,7 @@ gfx_mous 5542
gfx_text 2560
hello 4176
hello2 4251
irqtest 5834
irqtest 5881
ls 4919
malloc 4462
mdview 19122
1 # Эталон размеров _CODE (байт); обновление: python3 toolchain/size_check.py --update
8 banktest
9 bios_text
10 cat
11 cblstream
12 cbltest
13 cblwav
14 conio
15 conio2
16 dec_test
26 gfx_text
27 hello
28 hello2
29 irqtest
30 ls
31 malloc
32 mdview
libc/cbl/_cbl.h
+52
View File
@@ -0,0 +1,52 @@
/*
* _cbl.h — внутренности CBL-модуля (НЕ публичный заголовок).
*
* Механика (форум Sprinter Team + официальная документация "5.3
* COVOX-Blaster" + docs/converted/accel_r.txt):
* - порт управления 0x004E — 16-битный (только ld bc,#0x004E /
* out (c),a): bit7 = CBL on, bit6 = stereo, bit5 = 16-бит,
* bit4 = int enable, bits3..0 = частота; выключение — запись 0;
* - буфер 256 Б аппаратно разбит на две половины по 128 Б; бит 7
* порта 0xFE отражает, какая половина ИГРАЕТ сейчас — флип этого
* бита поднимает прерывание (вектор 0xFF), пора долить неактивную
* половину;
* - размер блока — 128 Б для 8-бит формата, 256 Б для 16-бит (не
* зависит от моно/стерео) — см. _cbl_block;
* - выдача блока — ДВА способа (cbl_push_otir.c/cbl_push_accel.c):
* OTIR в порт 0x4F, либо акселератором в спец-страницу EMM 0xFD
* (маппится в W3 на 0xC000); библиотека сама НИЧЕГО не пропихивает
* — это делает fill()-callback приложения;
* - насос вызывается из кадрового трамплина через хук _irq_cbl_hook
* (см. _irq.h) — прямой ссылки irq→cbl нет, DCE сохраняется.
*
* Никакого собственного кольца НЕТ — второй буфер поверх аппаратного
* был бы избыточен. _cbl_fill — callback приложения; _cbl_silence —
* буфер тишины, malloc'ится в cbl_open() ТОЛЬКО при
* CBL_UNDERRUN_SILENCE (иначе NULL).
*/
#ifndef _CBL_INTERNAL_H
#define _CBL_INTERNAL_H
#include <stdint.h>
#include <cbl.h>
#define _CBL_CTRL_PORT 0x004E
#define _CBL_DATA_PORT 0x4F
#define _CBL_ACCEL_PAGE 0xFD /* спец-страница EMM: запись на W3@0xC000 идёт в CBL */
extern uint16_t _cbl_block; /* размер блока: 128 или 256 (по формату) */
extern uint16_t _cbl_reqs; /* блоков-запросов обслужено */
extern uint16_t _cbl_undr; /* из них недолив (fill вернул 0/не задан) */
extern cbl_fill_fn _cbl_fill; /* callback приложения, может быть NULL */
extern uint8_t _cbl_underrun_mode; /* CBL_UNDERRUN_* */
extern uint8_t *_cbl_silence; /* буфер тишины или NULL */
/* Запись в 16-битный порт управления 0x004E. */
void _cbl_ctrl(uint8_t v);
/* ISR-насосы: вызвать fill(), при недоливе — тишина по режиму (один
* регистрируется в _irq_cbl_hook при cbl_open — по выбору CBL_PUMP_*). */
void _cbl_pump_otir(void);
void _cbl_pump_accel(void);
#endif
libc/cbl/_cbl_ctrl.c
+17
View File
@@ -0,0 +1,17 @@
/*
* _cbl_ctrl — запись в порт управления CBL 0x004E. Порт 16-битный:
* только `ld bc,#0x004E / out (c),a` (B = старший байт адреса порта).
*/
#include "_cbl.h"
void _cbl_ctrl(uint8_t v) __naked
{
(void)v;
__asm
;; __sdcccall(1): uint8_t-аргумент уже в A.
ld bc, #0x004E
out (c), a
ret
__endasm;
}
libc/cbl/_cbl_pump_accel.c
+21
View File
@@ -0,0 +1,21 @@
/*
* _cbl_pump_accel — ISR-насос CBL (путь ACCEL): зовёт fill() приложения
* за очередным блоком; при недоливе — тишина через cbl_push_accel(),
* если включён CBL_UNDERRUN_SILENCE. См. _cbl_pump_otir.c — та же
* логика, отличается только способ выдачи (важно для 16-бит формата,
* который OTIR собрать не может).
*/
#include "_cbl.h"
void _cbl_pump_accel(void)
{
_cbl_reqs++;
int ok = _cbl_fill ? _cbl_fill(_cbl_block) : 0;
if (!ok) {
_cbl_undr++;
if (_cbl_underrun_mode == CBL_UNDERRUN_SILENCE && _cbl_silence) {
cbl_push_accel(_cbl_silence, _cbl_block);
}
}
}
libc/cbl/_cbl_pump_otir.c
+24
View File
@@ -0,0 +1,24 @@
/*
* _cbl_pump_otir — ISR-насос CBL (путь OTIR): зовёт fill() приложения
* за очередным блоком; при недоливе (fill вернул 0 или не задан) —
* тишина через cbl_push_otir(), если включён CBL_UNDERRUN_SILENCE.
*
* Обычная (не __naked) Си-функция: вызывается из _irq_tramp.c через
* указатель, а трамплин уже сохранил ВЕСЬ контекст (оба регистровых
* набора + IX/IY) вокруг вызова — что бы эта функция ни наделала с
* регистрами, трамплин восстановит всё сам после возврата.
*/
#include "_cbl.h"
void _cbl_pump_otir(void)
{
_cbl_reqs++;
int ok = _cbl_fill ? _cbl_fill(_cbl_block) : 0;
if (!ok) {
_cbl_undr++;
if (_cbl_underrun_mode == CBL_UNDERRUN_SILENCE && _cbl_silence) {
cbl_push_otir(_cbl_silence, _cbl_block);
}
}
}
libc/cbl/_cbl_state.c
+14
View File
@@ -0,0 +1,14 @@
/*
* _cbl_state — данные CBL-модуля: размер блока, счётчики, callback
* приложения, режим недолива, буфер тишины (если аллоцирован).
* Только данные.
*/
#include "_cbl.h"
uint16_t _cbl_block;
uint16_t _cbl_reqs;
uint16_t _cbl_undr;
cbl_fill_fn _cbl_fill;
uint8_t _cbl_underrun_mode;
uint8_t *_cbl_silence;
libc/cbl/cbl_close.c
+22
View File
@@ -0,0 +1,22 @@
/*
* cbl_close — выключить CBL (запись 0 в порт управления, как в
* сэмпле), снять хук насоса, освободить буфер тишины (если был
* аллоцирован под CBL_UNDERRUN_SILENCE) и отпустить IM2-таблицу.
* Идемпотентно; вызывается и из atexit.
*/
#include <stdlib.h>
#include "_cbl.h"
#include "../irq/_irq.h"
void cbl_close(void)
{
if (!_irq_cbl_hook) return;
IRQ_DISABLE();
_cbl_ctrl(0);
_irq_cbl_hook = 0;
IRQ_ENABLE();
free(_cbl_silence);
_cbl_silence = 0;
_irq_table_unref();
}
libc/cbl/cbl_open.c
+83
View File
@@ -0,0 +1,83 @@
/*
* cbl_open — включить CBL, зарегистрировать fill()-callback и один
* из ISR-насосов.
*
* Управляющее слово: bit7 (CBL on) + bit4 (int enable) + fmt (bit6
* stereo, bit5 16-бит) + freq_code. Размер блока/буфер тишины
* зависят от fmt и underrun_mode (см. cbl.h). cbl_close вешается на
* atexit.
*
* ЗАПРЕТ CBL_PUMP_OTIR + 16-бит (подтверждено чтением исходника MAME
* sprinter.cpp): порт данных 0x4F ВСЕГДА кладёт байт как есть в один
* слот, не собирая пару байт в 16-бит значение и не сверяясь с
* cbl_mode16() вообще — это умеет только акселераторный путь (спец-
* страница 0xFD, do_accel_block). Комбинация принципиально не может
* звучать правильно, поэтому запрещена (EINVAL). Для 16-бит —
* CBL_PUMP_ACCEL.
*/
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sprinter_exit.h>
#include "_cbl.h"
#include "../irq/_irq.h"
int cbl_open(uint8_t freq_code, uint8_t fmt, uint8_t pump_mode,
uint8_t underrun_mode, cbl_fill_fn fill)
{
if (_irq_cbl_hook) { errno = EBUSY; return -1; }
if (freq_code < CBL_FREQ_7K8 || freq_code > CBL_FREQ_109K) {
errno = EINVAL;
return -1;
}
if (fmt & (uint8_t)~(CBL_FMT_MONO16 | CBL_FMT_STEREO8)) {
errno = EINVAL; /* биты вне 5/6 — неизвестный формат */
return -1;
}
if (pump_mode != CBL_PUMP_OTIR && pump_mode != CBL_PUMP_ACCEL) {
errno = EINVAL;
return -1;
}
if (pump_mode == CBL_PUMP_OTIR && (fmt & CBL_FMT_MONO16)) {
errno = EINVAL; /* OTIR не может собрать 16-бит сэмпл — только ACCEL */
return -1;
}
if (underrun_mode != CBL_UNDERRUN_APP && underrun_mode != CBL_UNDERRUN_SILENCE) {
errno = EINVAL;
return -1;
}
uint16_t block = (fmt & CBL_FMT_MONO16) ? 256u : 128u;
uint8_t *silence = 0;
if (underrun_mode == CBL_UNDERRUN_SILENCE) {
silence = malloc(block);
if (!silence) { errno = ENOMEM; return -1; }
memset(silence, (fmt & CBL_FMT_MONO16) ? 0x00 : 0x80, block);
}
if (_irq_table_ref() != 0) {
free(silence);
return -1;
}
_cbl_block = block;
_cbl_reqs = 0;
_cbl_undr = 0;
_cbl_fill = fill;
_cbl_underrun_mode = underrun_mode;
_cbl_silence = silence;
static uint8_t atexit_armed;
if (!atexit_armed) {
atexit_armed = 1;
atexit(cbl_close); /* CBL обязан умолкнуть до шелла */
}
IRQ_DISABLE();
_irq_cbl_hook = (pump_mode == CBL_PUMP_ACCEL) ? _cbl_pump_accel : _cbl_pump_otir;
_cbl_ctrl((uint8_t)(0x90 | fmt | freq_code)); /* on + int + формат + частота */
IRQ_ENABLE();
return 0;
}
libc/cbl/cbl_push_accel.c
+49
View File
@@ -0,0 +1,49 @@
/*
* cbl_push_accel — пропихнуть n байт из src в CBL акселератором,
* записью на спец-страницу EMM 0xFD (маппится в W3 на 0xC000; см.
* официальную доку "5.3 COVOX-Blaster" и docs/converted/accel_r.txt).
* Звать ИЗ fill()-callback'а — единственный способ получить настоящий
* 16-бит сэмпл (порт 0x4F/OTIR этого не умеет).
*
* Последовательность акселератора (см. libc/gfx/_gfx_hfill256.c —
* тот же рабочий паттерн SMC для immediate-размера): LD D,D (режим
* размера блока) → immediate LD A,n (патчится SMC — 0 значит 256,
* тот же трюк, что и в OTIR) → LD L,L (режим "копирование блока") →
* LD A,(HL) / LD (DE),A (блочное чтение источника → блочная запись
* в 0xC000@стр.0xFD) → LD B,B (выкл). Акселератор НЕ продвигает
* HL/DE сам — нам это и не нужно, вызов одноразовый.
*
* W3 сохраняется/восстанавливается вокруг свопа (как bank_read/
* bank_write). Доп. DI/EI не нужны — функция вызывается ИЗ ISR
* (прерывания уже замаскированы трамплином до его EI/RETI).
*/
#include "_cbl.h"
void cbl_push_accel(const void *src, uint16_t n) __naked
{
(void)src; (void)n;
__asm
;; HL = src (1-й арг), DE = n (2-й арг) — __sdcccall(1)
ld a, e
ld (_cblpa_push_size), a ; SMC: 128 остаётся 128, 256 -> 0
in a, (#0xE2) ; сохранить текущий W3
push af
ld a, #0xFD ; замапить W3 на спец-страницу CBL
out (#0xE2), a
ld de, #0xC000
ld d, d ; 0x52 — режим размера блока
ld a, #0 ; immediate — патчится SMC выше
_cblpa_push_size = . - 1
ld l, l ; 0x6D — режим "копирование блока"
ld a, (hl) ; блочное чтение источника
ld (de), a ; блочная запись в CBL-порт
ld b, b ; 0x40 — выключить акселератор
pop af
out (#0xE2), a ; вернуть W3
ret
__endasm;
}
libc/cbl/cbl_push_otir.c
+27
View File
@@ -0,0 +1,27 @@
/*
* cbl_push_otir — пропихнуть n байт из src в CBL через OTIR (порт
* 0x4F). Звать ИЗ fill()-callback'а (см. cbl.h) — приложение само
* решает, откуда брать данные, никакой промежуточной копии в libc.
*
* n — 128 или 256 (см. _cbl_block); низкий байт n (E) даёт готовое
* значение для регистра B: 128 остаётся 128, 256 идёт как 0 (Z80
* OTIR: B=0 значит 256 итераций).
*
* НЕ умеет 16-бит: порт 0x4F всегда кладёт байт как есть в один слот
* (см. cbl.h, cbl_open.c) — для 16-бит нужен cbl_push_accel().
*/
#include "_cbl.h"
void cbl_push_otir(const void *src, uint16_t n) __naked
{
(void)src; (void)n;
__asm
;; HL = src (1-й арг), DE = n (2-й арг) — __sdcccall(1)
ld a, e
ld b, a
ld c, #0x4F
otir
ret
__endasm;
}
libc/cbl/cbl_requests.c
+15
View File
@@ -0,0 +1,15 @@
/*
* cbl_requests — сколько блоков-запросов обслужено с cbl_open
* (диагностика: при fs=21.9 кГц ожидается ~171/с).
*/
#include "_cbl.h"
#include "../irq/_irq.h"
uint16_t cbl_requests(void)
{
IRQ_DISABLE();
uint16_t v = _cbl_reqs;
IRQ_ENABLE();
return v;
}
libc/cbl/cbl_underruns.c
+15
View File
@@ -0,0 +1,15 @@
/*
* cbl_underruns — сколько блоков сыграно тишиной из-за пустого
* кольца (включая период до первой записи после cbl_open).
*/
#include "_cbl.h"
#include "../irq/_irq.h"
uint16_t cbl_underruns(void)
{
IRQ_DISABLE();
uint16_t v = _cbl_undr;
IRQ_ENABLE();
return v;
}
libc/include/cbl.h
+123
View File
@@ -0,0 +1,123 @@
/*
* cbl.h — COVOX-Blaster: потоковый вывод звука через прерывания.
*
* CBL — COVOX с буферным ОЗУ (256 Б, аппаратно разбито на ДВЕ половины
* по 128 Б — двойная буферизация целиком на стороне железа, см.
* официальную документацию "5.3 COVOX-Blaster"): бит 7 порта 0xFE
* отражает, какая половина СЕЙЧАС играет; когда она флипает, вектор
* 0xFF поднимает прерывание — пора долить НЕАКТИВНУЮ половину.
*
* Библиотека НЕ держит собственного кольца — оно было бы лишним
* вторым буфером поверх аппаратного. Вместо этого при cbl_open()
* регистрируется callback fill(): ISR вызывает его напрямую, а
* callback САМ пропихивает n байт из данных приложения (откуда бы они
* ни жили — статический массив, банковая EMM-страница, файл) прямо в
* CBL через cbl_push_otir()/cbl_push_accel() — без промежуточной
* копии в libc.
*
* fill(n) ОБЯЗАН быть быстрым (то же ограничение, что у irq_install()
* — никаких ESTEX/BIOS/gfx-вызовов, только память и один push) и
* вернуть ненулевое значение, если реально пропихнул n байт; 0 — если
* данных сейчас нет (недолив/underrun).
*
* Формат данных (bits 6/5 порта 0x4E; см. Forum.txt "Звук через
* COVOX-Blaster"):
* 8-бит: unsigned, центр 0x80 (моно — один байт/сэмпл;
* стерео — чередование L/R байт)
* 16-бит: signed, центр 0x0000, little-endian (моно — int16/сэмпл;
* стерео — чередование L/R int16)
* Блок запроса — 128 байт для 8-бит, 256 байт для 16-бит (не зависит
* от моно/стерео — это ПОЛНЫЙ байтовый блок, раскладка каналов внутри
* него на размер не влияет); n, приходящий в fill(), равен этому блоку.
*
* Способ выдачи блока — CBL_PUMP_* (см. cbl_open):
* OTIR — cbl_push_otir(), блочный вывод в порт 0x4F; НЕ умеет
* 16-бит (см. ниже) — cbl_open(..., 16-бит формат,
* CBL_PUMP_OTIR, ...) вернёт EINVAL.
* ACCEL — cbl_push_accel(), запись в спец-страницу EMM 0xFD
* (маппится в W3 на 0xC000) через акселератор (см.
* docs/converted/accel_r.txt); единственный способ получить
* настоящий 16-бит сэмпл.
*
* OTIR + 16-бит запрещён не просто "хуже", а физически не работает:
* по исходнику эмулятора (MAME sprinter.cpp) порт данных 0x4F ВСЕГДА
* кладёт байт как есть в один слот, не собирая пару байт в 16-бит
* значение — это умеет только акселераторный путь (страница 0xFD).
*
* Поведение при недоливе — CBL_UNDERRUN_* (4-й параметр cbl_open):
* CBL_UNDERRUN_APP (по умолчанию, 0) — недолив не наша забота;
* в CBL доигрывает то, что уже лежит в его буфере (никакого
* буфера тишины не аллоцируется).
* CBL_UNDERRUN_SILENCE (1) — насос сам пропихивает тишину при
* недоливе; буфер тишины (128/256 Б по формату) аллоцируется
* malloc'ом ВНУТРИ cbl_open(), только в этом режиме.
* cbl_underruns() считает недоливы в ОБОИХ режимах — это диагностика,
* поведение не меняет.
*
* cbl_close() обязателен (atexit подстрахует) — иначе CBL продолжит
* прерывать шелл после выхода; заодно освобождает буфер тишины, если
* он был аллоцирован.
*
* Требования как у <irq.h>: код/данные в W2 (tiny/big).
*/
#ifndef CBL_H
#define CBL_H
#include <stdint.h>
/* Коды частоты дискретизации (bits 3..0 порта 0x4E; из форума
* Sprinter Team; коды 0/1 — legacy, не использовать). */
#define CBL_FREQ_7K8 0x8 /* 7.8125 кГц */
#define CBL_FREQ_10K9 0x9 /* 10.9375 кГц */
#define CBL_FREQ_15K6 0xA /* 15.625 кГц */
#define CBL_FREQ_21K9 0xB /* 21.875 кГц */
#define CBL_FREQ_31K3 0xC /* 31.25 кГц */
#define CBL_FREQ_43K8 0xD /* 43.75 кГц */
#define CBL_FREQ_54K7 0xE /* 54.6875 кГц */
#define CBL_FREQ_109K 0xF /* 109.375 кГц */
/* Формат: биты 5(16-бит)/6(stereo) порта 0x4E — значения готовы для
* прямого OR с freq_code внутри cbl_open(). */
#define CBL_FMT_MONO8 0x00 /* 8-бит, моно — блок 128 Б */
#define CBL_FMT_MONO16 0x20 /* 16-бит, моно — блок 256 Б */
#define CBL_FMT_STEREO8 0x40 /* 8-бит, стерео — блок 128 Б */
#define CBL_FMT_STEREO16 0x60 /* 16-бит, стерео — блок 256 Б */
/* Способ выдачи блока. */
#define CBL_PUMP_OTIR 0 /* cbl_push_otir() — базовый, не умеет 16-бит */
#define CBL_PUMP_ACCEL 1 /* cbl_push_accel() — единственный путь для 16-бит */
/* Поведение при недоливе (fill() вернул 0 или не задан). */
#define CBL_UNDERRUN_APP 0 /* по умолчанию: не наша забота, буфер тишины не аллоцируется */
#define CBL_UNDERRUN_SILENCE 1 /* насос сам шлёт тишину; буфер аллоцируется в cbl_open() */
/* fill(n): пропихнуть n байт (через cbl_push_otir/accel) прямо из
* данных приложения. Вызывается ИЗ ISR — обязан быть быстрым (без
* ESTEX/BIOS/gfx/malloc). Вернуть ненулевое при успехе, 0 — нет
* данных сейчас (недолив). */
typedef int (*cbl_fill_fn)(uint16_t n);
/* Включить CBL с частотой CBL_FREQ_*, форматом CBL_FMT_*, способом
* выдачи CBL_PUMP_* и поведением при недоливе CBL_UNDERRUN_*; fill —
* callback, зовущийся из ISR за новым блоком (может быть NULL, тогда
* недолив — на каждом запросе). 0 или -1 + errno (EBUSY — уже
* открыт; EINVAL — плохой код частоты/формат/pump/underrun_mode, или
* не-W2 режим; ENOMEM — не хватило памяти под буфер тишины). */
int cbl_open(uint8_t freq_code, uint8_t fmt, uint8_t pump_mode,
uint8_t underrun_mode, cbl_fill_fn fill);
/* Выключить CBL, отпустить IM2-таблицу, освободить буфер тишины (если
* был). Идемпотентно. */
void cbl_close(void);
/* Пропихнуть n байт из src прямо в CBL (звать ИЗ fill()). */
void cbl_push_otir (const void *src, uint16_t n);
void cbl_push_accel(const void *src, uint16_t n);
/* Счётчики диагностики: блоки-запросы и недоливы (fill() вернул 0
* или не задан). */
uint16_t cbl_requests(void);
uint16_t cbl_underruns(void);
#endif
libc/irq/_irq.h
+6
View File
@@ -35,6 +35,12 @@ extern isr_t _irq_ctc_user; /* CTC-handler; NULL = нет */
extern uint8_t _irq_old_i; /* I до захвата таблицы */
extern uint8_t _irq_refs; /* счётчик пользователей таблицы */
/* Хук CBL-насоса (libc/cbl регистрирует _cbl_pump). Косвенность
* сознательная: прямая ссылка трамплина на cbl-модуль притянула бы
* его (и 2 КБ кольца) в каждую irq-программу. NULL = CBL выключен,
* трамплин НЕ проверяет бит 7 порта 0xFE (он подтянут к 1). */
extern isr_t _irq_cbl_hook;
/* Порты встроенной периферии Z84C015 (docs/samples/SIO_CTC_KEY.asm). */
#define _IRQ_CTC_CH0 0x10
#define _IRQ_CTC_CH2 0x12
libc/irq/_irq_state.c
+1
View File
@@ -9,5 +9,6 @@
uint8_t _irq_vec_buf[_IRQ_VEC_BUF_SIZE];
isr_t _irq_user;
isr_t _irq_ctc_user;
isr_t _irq_cbl_hook;
uint8_t _irq_old_i;
uint8_t _irq_refs;
libc/irq/_irq_tramp.c
+55 -14
View File
@@ -1,21 +1,23 @@
/*
* _irq_tramp — вход IM2-прерывания (вектор 0xFF, все источники).
* _irq_tramp — вход IM2-прерывания (вектор 0xFF: кадр/клавиатура/CBL).
*
* До выяснения источника трогаем только AF: клавиатура (бит 0 порта
* 0x19 = SIO-A RR0 «Rx Character Available») уходит напрямую в DSS.
* Кадровое прерывание: полный сейв обоих наборов + IX/IY, вызов
* user-handler'а, симметричный restore. В конце ВСЕГДА jp на
* обработчик DSS 0x0038 (DSS работает в IM 1; jp с interrupted-PC на
* стеке имитирует RST 38) — он делает свой save/restore и завершает
* EI/RETI: клавиатурный FIFO, SYSTIME и курсор мыши живут.
* До выяснения источника трогаем только AF:
* - клавиатура (бит 0 порта 0x19 = SIO-A RR0 «Rx Character
* Available») уходит напрямую в DSS;
* - CBL (бит 7 порта 0xFE) проверяется ТОЛЬКО при зарегистрированном
* хуке _irq_cbl_hook: при выключенном CBL бит подтянут к 1 (MAME
* kbd_fe_r: data |= 0xE0) и проверка ложно срабатывала бы на
* каждом кадре. CBL-путь: полный сейв → насос → restore →
* EI/RETI, к DSS НЕ чейнится (личное прерывание);
* - кадровое: полный сейв → user-handler → restore → чейн.
*
* CBL-фильтр по биту 7 порта 0xFE УБРАН: при выключенном CBL бит
* подтянут к 1 (MAME kbd_fe_r: data |= 0xE0), и каждое кадровое
* прерывание ложно уходило бы в чейн — user-handler не вызывался бы
* никогда. Вернуть вместе с поддержкой CBL в Phase 2.
* Чейн — ВСЕГДА jp на обработчик DSS 0x0038 (DSS работает в IM 1;
* jp с interrupted-PC на стеке имитирует RST 38) — он делает свой
* save/restore и завершает EI/RETI: клавиатурный FIFO, SYSTIME и
* курсор мыши живут.
*
* Операнд финального jp (_irq_dss_target) — SMC, патчится из
* irq_install; модуль в _CODE (RAM на Sprinter, W2 в tiny/big).
* _irq_table_ref; модуль в _CODE (RAM на Sprinter, W2 в tiny/big).
*/
#include "_irq.h"
@@ -28,6 +30,45 @@ void _irq_tramp(void) __naked
rrca ; бит 0 — клавиатурный байт принят?
jr C, _irq_chain
;; --- CBL? --- старший байт хука ненулевой у любого
;; W2-адреса — для проверки «хук есть» хватает одного байта.
ld a, (__irq_cbl_hook + 1)
or a, a
jr Z, _irq_frame
in a, (#0xFE)
rlca ; бит 7 — запрос блока CBL?
jr NC, _irq_frame
;; --- CBL: сейв, насос, restore, EI/RETI (без DSS) ---
push bc
push de
push hl
.db 0x08 ; ex af,af (теневой AF)
push af
exx
push bc
push de
push hl
push ix
push iy
ld hl, (__irq_cbl_hook)
call _irq_call_hl
pop iy
pop ix
pop hl
pop de
pop bc
exx
pop af
.db 0x08 ; ex af,af (теневой AF)
pop hl
pop de
pop bc
pop af
ei
reti
_irq_frame:
;; --- кадровое прерывание ---
push bc
push de
@@ -67,7 +108,7 @@ void _irq_tramp(void) __naked
;; Всегда к DSS (IM 1, обработчик 0x0038) — EI/RETI за ним.
.db 0xC3 ; jp nn
__irq_dss_target::
.dw 0x0038 ; SMC: подтверждается в irq_install
.dw 0x0038 ; SMC: подтверждается в _irq_table_ref
_irq_call_hl:
jp (hl)
tests/cblstream/Makefile
+6
View File
@@ -0,0 +1,6 @@
# Build cblstream.exe — потоковое чтение с диска + CBL одновременно.
PROJ_ROOT := $(abspath $(CURDIR)/../..)
EXAMPLE := cblstream
EXTRA_DATA := speech30.pcm
include $(PROJ_ROOT)/app.mk
tests/cblstream/cblstream.c
+140
View File
@@ -0,0 +1,140 @@
/*
* cblstream — потоковое чтение с диска ОДНОВРЕМЕННО с воспроизведением
* через CBL. Расчитан на быстрый носитель (HDD) — на floppy
* захлёбывается (см. tests/cblwav, где поэтому весь клип грузится в
* RAM заранее). speech30.pcm — ~39.6 c речи, моно 8-бит unsigned,
* 21.875 кГц.
*
* ЕДИНСТВЕННЫЙ случай из трёх cbl-тестов, где приложению НУЖНО своё
* кольцо (2026-07-07): read() — ESTEX-вызов, а fill()-callback CBL
* зовётся ИЗ ISR, где ESTEX/BIOS под запретом (см. cbl.h). Поэтому
* диск читается ТОЛЬКО в main (в собственное кольцо ring[]), а
* fill_stream() лишь копирует уже готовые байты из ring в стейджинг и
* пропихивает cbl_push_otir() — сам с диском не работает.
*/
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <cbl.h>
#include <irq.h>
#define RING_SIZE 2048u
#define READ_CHUNK 1024u
static uint8_t ring[RING_SIZE];
static uint16_t r_rd, r_wr, r_count; /* r_count: main под IRQ_DISABLE, fill() уже в ISR */
static uint8_t staging[128]; /* блок 8-бит моно */
static uint16_t ring_in = 0;
static uint16_t ring_border = 0;
static uint16_t ring_free(void)
{
IRQ_DISABLE();
uint16_t c = r_count;
IRQ_ENABLE();
return (uint16_t)(RING_SIZE - c);
}
/* Вызывать ТОЛЬКО из main. */
static void ring_push(const void *src, uint16_t n)
{
const uint8_t *s = src;
while (n) {
uint16_t tail = (uint16_t)(RING_SIZE - r_wr);
uint16_t chunk = n < tail ? n : tail;
memcpy(ring + r_wr, s, chunk);
r_wr = (uint16_t)((r_wr + chunk) % RING_SIZE);
IRQ_DISABLE();
r_count += chunk;
IRQ_ENABLE();
s += chunk;
n = (uint16_t)(n - chunk);
}
}
/* Зовётся ИЗ ISR — только копия из уже готового ring, никакого ESTEX. */
static int fill_stream(uint16_t n)
{
if (r_count < n) return 0;
uint16_t tail = (uint16_t)(RING_SIZE - r_rd);
if (tail >= n) {
// memcpy(staging, ring + r_rd, n);
cbl_push_otir(ring + r_rd, n);
ring_in++;
} else {
memcpy(staging, ring + r_rd, tail);
memcpy(staging + tail, ring, (uint16_t)(n - tail));
cbl_push_otir(staging, n);
ring_border++;
}
r_rd = (uint16_t)((r_rd + n) % RING_SIZE);
r_count = (uint16_t)(r_count - n); /* уже внутри ISR — IRQ и так замаскированы */
return 1;
}
int main(void)
{
int fd = open("speech30.pcm", O_RDONLY);
if (fd < 0) {
printf("open(speech30.pcm) failed: errno=%d\n", errno);
return 1;
}
static uint8_t readbuf[READ_CHUNK];
uint32_t played = 0;
uint8_t eof = 0;
/* прогреть кольцо реальными данными ДО cbl_open()/puts() — иначе
* пауза тишины на старте (тот же приём, что в cbltest.c/cblwav.c) */
while (!eof && ring_free() >= sizeof(readbuf)) {
int got = read(fd, readbuf, sizeof(readbuf));
if (got <= 0) { eof = 1; break; }
ring_push(readbuf, (uint16_t)got);
played += (uint32_t)got;
}
if (cbl_open(CBL_FREQ_21K9, CBL_FMT_MONO8, CBL_PUMP_OTIR,
CBL_UNDERRUN_APP, fill_stream) != 0) {
printf("cbl_open failed: errno=%d\n", errno);
close(fd);
return 1;
}
puts("streaming speech30.pcm from disk (21.875 kHz, mono 8-bit)...");
while (!eof) {
if (ring_free() >= sizeof(readbuf)) {
int got = read(fd, readbuf, sizeof(readbuf));
if (got <= 0) { eof = 1; break; }
ring_push(readbuf, (uint16_t)got);
played += (uint32_t)got;
} else {
__asm__("halt"); /* ждём, пока ISR подъест кольцо */
}
}
close(fd);
printf("streamed %lu bytes from disk\n", played);
/* Ждём "почти полного" опустошения, а не точного RING_SIZE: если
* общая длина потока не кратна 128, необслуженный хвост (<128 Б,
* тот же квирк, что и в старом кольце libc — см. cbl.h) навечно
* оставит r_count>0, и точное ожидание никогда бы не завершилось. */
while (ring_free() < RING_SIZE - 127u) __asm__("halt");
printf("requests: %u, underruns: %u (expect 0 during play)\n",
cbl_requests(), cbl_underruns());
printf("ring: in: %u, border: %u\n",
ring_in, ring_border);
cbl_close();
puts("press any key (keyboard must work)...");
getch();
puts("cblstream done.");
return 0;
}
tests/cblstream/speech30.pcm
+1
View File
File diff suppressed because one or more lines are too long
tests/cbltest/Makefile
+5
View File
@@ -0,0 +1,5 @@
# Build cbltest.exe — smoke CBL-звука (пила через кольцевой буфер).
PROJ_ROOT := $(abspath $(CURDIR)/../..)
EXAMPLE := cbltest
include $(PROJ_ROOT)/app.mk
tests/cbltest/cbltest.c
+159
View File
@@ -0,0 +1,159 @@
/*
* cbltest — полный перебор CBL-звука (Phase 2b, docs/im2_isr_design.md).
*
* Матрица: 2 насоса (OTIR/ACCEL) × 8 форматов (mono/stereo-L/stereo-R/
* stereo-LR, каждый в 8- и 16-бит) × 4 частоты (7.8/10.9/15.6/21.9 кГц)
* = 64 комбинации, каждая ~1 с пилообразного тона (период 64 сэмпла/
* кадра). Для каждой печатается requests/underruns — 0 недоливов
* ожидается всегда. В MAME на слух должно быть отчётливо слышно:
* смену тембра насоса (не должно быть разницы OTIR/ACCEL), канал
* (левый/правый/оба) и высоту тона (растёт с частотой).
*
* OTIR+16-бит (16 из 64 комбинаций) ПРОПУСКАЮТСЯ — cbl_open() отдаёт
* EINVAL: OTIR-порт данных не умеет собирать 16-бит сэмпл из пары
* байт (только акселератор это делает; см. cbl_open.c, сверено с
* исходником MAME sprinter.cpp).
*
* Новая модель без кольца libc (2026-07-07): fill_tone() зовётся ИЗ
* ISR, сама пропихивает n байт из уже готового периодического чанка
* через cbl_push_otir/accel (по current_pump) — данные никогда не
* кончаются, так что CBL_UNDERRUN_APP (без буфера тишины) достаточно.
* Main-цикл ничего не поллит — просто ждёт ~1 с через halt().
*/
#include <stdio.h>
#include <time.h>
#include <conio.h>
#include <errno.h>
#include <cbl.h>
static uint8_t chunk[256];
static uint8_t current_pump; /* CBL_PUMP_OTIR/ACCEL для активной комбинации */
/* Заполнить chunk одним периодом (64 сэмпла/кадра) пилы — раскладка
* зависит от bits (8/16) и stereo (моно / чередование L,R). */
static void gen_chunk(uint8_t bits, uint8_t stereo, uint8_t want_l, uint8_t want_r)
{
if (!stereo) {
if (bits == 8) {
for (uint16_t i = 0; i < sizeof(chunk); i++) {
chunk[i] = (uint8_t)(i * 4); /* период 64 (обёртка uint8_t) */
}
} else {
int16_t *p = (int16_t *)chunk;
for (uint16_t i = 0; i < sizeof(chunk) / 2; i++) {
uint16_t idx = i & 63;
p[i] = (int16_t)(uint16_t)(idx * 1024u);
}
}
} else if (bits == 8) {
for (uint16_t k = 0; k < sizeof(chunk) / 2; k++) {
uint8_t frame = (uint8_t)(k & 63);
uint8_t tone = (uint8_t)(frame * 4);
chunk[2 * k] = want_l ? tone : 0x80;
chunk[2 * k + 1] = want_r ? tone : 0x80;
}
} else {
int16_t *p = (int16_t *)chunk;
for (uint16_t k = 0; k < sizeof(chunk) / 4; k++) {
uint16_t frame = k & 63;
int16_t tone = (int16_t)(uint16_t)(frame * 1024u);
p[2 * k] = want_l ? tone : 0;
p[2 * k + 1] = want_r ? tone : 0;
}
}
}
/* Зовётся ИЗ ISR (см. cbl.h: обязано быть быстрым). chunk — готовый
* period-64 тон, никогда не "кончается", поэтому всегда успех. */
static int fill_tone(uint16_t n)
{
if (current_pump == CBL_PUMP_ACCEL) cbl_push_accel(chunk, n);
else cbl_push_otir(chunk, n);
return 1;
}
static void play_combo(uint16_t idx, uint16_t total,
const char *pump_name, uint8_t pump_mode,
const char *fmt_name, uint8_t fmt, uint8_t bits,
uint8_t stereo, uint8_t want_l, uint8_t want_r,
const char *freq_name, uint8_t freq_code)
{
gen_chunk(bits, stereo, want_l, want_r);
current_pump = pump_mode;
if (cbl_open(freq_code, fmt, pump_mode, CBL_UNDERRUN_APP, fill_tone) != 0) {
printf("[%2u/%u] %s %s %s: cbl_open failed errno=%d\n",
idx, total, pump_name, fmt_name, freq_name, errno);
return;
}
printf("[%2u/%u] %s %s %s ...\n", idx, total, pump_name, fmt_name, freq_name);
datetime_t t, t2;
getdatetime(&t);
getdatetime(&t2);
while (t.second == t2.second) {
__asm__("halt"); /* ISR сам кормит CBL — просто ждём */
getdatetime(&t2);
}
uint16_t reqs = cbl_requests();
uint16_t undr = cbl_underruns();
cbl_close();
if (undr) printf(" !! underruns=%u (reqs=%u)\n", undr, reqs);
}
int main(void)
{
static const uint8_t pumps[2] = { CBL_PUMP_OTIR, CBL_PUMP_ACCEL };
static const char *const pump_names[2] = { "otir ", "accel" };
static const uint8_t freq_codes[4] = {
CBL_FREQ_7K8, CBL_FREQ_10K9, CBL_FREQ_15K6, CBL_FREQ_21K9
};
static const char *const freq_names[4] = { "7.8k ", "10.9k", "15.6k", "21.9k" };
/* формат: биты, fmt-код, stereo?, L?, R?, имя */
static const uint8_t fmt_bits[8] = { 8, 8, 8, 8, 16, 16, 16, 16 };
static const uint8_t fmt_code[8] = {
CBL_FMT_MONO8, CBL_FMT_STEREO8, CBL_FMT_STEREO8, CBL_FMT_STEREO8,
CBL_FMT_MONO16, CBL_FMT_STEREO16, CBL_FMT_STEREO16, CBL_FMT_STEREO16
};
static const uint8_t fmt_stereo[8] = { 0, 1, 1, 1, 0, 1, 1, 1 };
static const uint8_t fmt_l[8] = { 1, 1, 0, 1, 1, 1, 0, 1 };
static const uint8_t fmt_r[8] = { 1, 0, 1, 1, 1, 0, 1, 1 };
static const char *const fmt_names[8] = {
"mono8 ", "st8-L ", "st8-R ", "st8-LR ",
"mono16 ", "st16-L ", "st16-R ", "st16-LR "
};
uint16_t total = 2u * 8u * 4u;
uint16_t idx = 0;
for (uint8_t p = 0; p < 2; p++) {
for (uint8_t f = 0; f < 8; f++) {
for (uint8_t q = 0; q < 4; q++) {
idx++;
/* OTIR принципиально не может собрать 16-бит сэмпл
* (см. cbl_open.c) — cbl_open вернёт EINVAL; не тратим
* время на заведомо запрещённую комбинацию. */
if (pumps[p] == CBL_PUMP_OTIR && fmt_bits[f] == 16) {
printf("[%2u/%u] %s %s %s : skip (OTIR can't do 16-bit)\n",
idx, total, pump_names[p], fmt_names[f], freq_names[q]);
continue;
}
play_combo(idx, total,
pump_names[p], pumps[p],
fmt_names[f], fmt_code[f], fmt_bits[f],
fmt_stereo[f], fmt_l[f], fmt_r[f],
freq_names[q], freq_codes[q]);
}
}
}
puts("press any key (keyboard must work)...");
getch();
puts("cbltest done.");
return 0;
}
tests/cblwav/Makefile
+6
View File
@@ -0,0 +1,6 @@
# Build cblwav.exe — проигрывание speech.pcm через CBL (Phase 2b смоук).
PROJ_ROOT := $(abspath $(CURDIR)/../..)
EXAMPLE := cblwav
EXTRA_DATA := speech.pcm
include $(PROJ_ROOT)/app.mk
tests/cblwav/cblwav.c
+134
View File
@@ -0,0 +1,134 @@
/*
* cblwav — проигрывание РЕАЛЬНОГО звука через CBL (Phase 2b смоук).
*
* speech.pcm: моно 8-бит unsigned (центр 0x80), 21.875 кГц — сгенерирован
* macOS `say` + `afconvert -d UI8@21875` (см. docs/im2_isr_design.md).
*
* speech.pcm лежит на ДИСКЕТЕ (mc.img на -flop1) — этот привод слишком
* медленный для потокового чтения в реальном времени. Поэтому клип
* целиком грузится в банковую EMM-память ЗАРАНЕЕ (без таймингов),
* крупными блоками через сырой read(), а во время проигрывания диск
* больше не участвует.
*
* Новая модель без кольца libc (2026-07-07): fill_speech() зовётся
* ИЗ ISR за очередным блоком; она делает bank_read() из УЖЕ ЗАГРУЖЕННОЙ
* страницы прямо в маленький стейджинг-буфер и пропихивает его через
* cbl_push_otir() — без промежуточного кольца.
*
* ВАЖНО: fill() не должен звать mem_get_page() (BIOS rst 8) — BIOS сам
* управляет EI/DI вокруг rst 8, а его `ei` при возврате может
* преждевременно снять маску прерываний, пока мы ещё внутри ISR (см.
* cbl.h: "fill() ОБЯЗАН быть быстрым... никаких ESTEX/BIOS-вызовов").
* Поэтому номера физических страниц считаются ОДИН РАЗ на этапе
* загрузки (в main-контексте) и кэшируются в phys_pages[] — fill()
* только индексирует массив. bank_read() — чистый порт-ввод/вывод,
* без BIOS/ESTEX, вызывать из ISR безопасно.
*
* Хвост не кратный размеру блока (78 КБ % 128 = 43) — fill()
* докладывает остаток тишиной (0x80) прямо в стейджинге на последнем
* неполном блоке, никакого отдельного паддинг-прохода не нужно.
*/
#include <stdio.h>
#include <string.h>
#include <conio.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <cbl.h>
#include <sprinter_mem.h>
#define PAGE_SIZE 16384u /* размер страницы EMM */
#define LOAD_CHUNK 4096u /* блок разовой загрузки с диска; делит PAGE_SIZE нацело */
#define SPEECH_SIZE 77995ul /* точный размер tests/cblwav/speech.pcm */
#define MAX_PAGES 8
static uint8_t loadbuf[LOAD_CHUNK];
static uint8_t staging[256]; /* под самый большой блок (16-бит = 256) */
static uint8_t phys_pages[MAX_PAGES]; /* кэш физ. страниц — БЕЗ BIOS-вызовов из fill() */
static uint8_t page_idx;
static uint16_t page_off;
static uint32_t played;
static uint32_t loaded;
static volatile uint8_t done;
static int fill_speech(uint16_t n)
{
if (played >= loaded) { done = 1; return 0; }
uint16_t want = n;
if (want > loaded - played) want = (uint16_t)(loaded - played);
bank_read(phys_pages[page_idx], page_off, staging, want);
if (want < n) memset(staging + want, 0x80, n - want); /* хвост короче блока */
cbl_push_otir(staging, n);
page_off += want;
played += want;
if (page_off >= PAGE_SIZE) {
page_off -= PAGE_SIZE;
page_idx++;
}
return 1;
}
int main(void)
{
int fd = open("speech.pcm", O_RDONLY);
if (fd < 0) {
printf("open(speech.pcm) failed: errno=%d\n", errno);
return 1;
}
uint8_t npages = (uint8_t)((SPEECH_SIZE + PAGE_SIZE - 1) / PAGE_SIZE);
uint8_t blk = mem_alloc_pages(npages);
if (!blk) {
printf("mem_alloc_pages(%u) failed: errno=%d\n", npages, errno);
close(fd);
return 1;
}
puts("loading speech.pcm into RAM (slow: floppy)...");
page_idx = 0;
page_off = 0;
phys_pages[0] = mem_get_page(blk, 0);
while (loaded < SPEECH_SIZE) {
int got = read(fd, loadbuf, sizeof(loadbuf));
if (got <= 0) break;
bank_write(phys_pages[page_idx], page_off, loadbuf, (uint16_t)got);
page_off += (uint16_t)got;
loaded += (uint32_t)got;
if (page_off >= PAGE_SIZE) {
page_off -= PAGE_SIZE;
page_idx++;
phys_pages[page_idx] = mem_get_page(blk, page_idx); /* редко: смена страницы */
}
}
close(fd);
printf("loaded %lu bytes into %u page(s)\n", loaded, npages);
page_idx = 0;
page_off = 0;
played = 0;
done = 0;
if (cbl_open(CBL_FREQ_21K9, CBL_FMT_MONO8, CBL_PUMP_OTIR,
CBL_UNDERRUN_APP, fill_speech) != 0) {
printf("cbl_open failed: errno=%d\n", errno);
mem_free_block(blk);
return 1;
}
puts("playing speech.pcm (21.875 kHz, mono 8-bit)...");
while (!done) __asm__("halt"); /* ISR сам кормит CBL — просто ждём */
printf("requests: %u, underruns: %u (expect ~1: tail block)\n",
cbl_requests(), cbl_underruns());
cbl_close();
mem_free_block(blk);
puts("press any key (keyboard must work)...");
getch();
puts("cblwav done.");
return 0;
}
tests/cblwav/speech.pcm
+1
View File
File diff suppressed because one or more lines are too long