Codex 69521e54e0 Add 15 embedded repair tasks and correct grader-read controls
Complete batch 20261016-C-embedded-2: 45 verified GLM/Pi samples, independent regrades and archives; preserve difficulty misses and Salty blockage.
2026-10-16 14:23:48 +08:00

160 lines
3.7 KiB
C

#include "lab.h"
#include <string.h>
static unsigned request_valid(const request_t *request)
{
if (request->id == 0u) {
return 0u;
}
if (request->length == 0u) {
return 0u;
}
if (request->length > REQUEST_SIZE) {
return 0u;
}
return 1u;
}
static unsigned remaining_writes(const driver_t *driver)
{
if (driver->sent >= driver->active.length) {
return 0u;
}
return driver->active.length - driver->sent;
}
static unsigned transfer_finished(const driver_t *driver)
{
if (driver->received != driver->active.length) {
return 0u;
}
if (remaining_writes(driver) != 0u) {
return 0u;
}
return 1u;
}
static void receive_drain(driver_t *driver)
{
unsigned available = reg_rx_count(driver->registers);
unsigned pending = driver->active.length - driver->received;
unsigned count = available < pending ? available : pending;
while (count != 0u) {
unsigned position = driver->received;
(void)reg_read(driver->registers, position);
driver->received = position + 1u;
count -= 1u;
}
}
static void transmit_fill(driver_t *driver)
{
while (remaining_writes(driver) != 0u &&
reg_tx_space(driver->registers) != 0u) {
unsigned position = driver->sent;
reg_write(driver->registers, driver->active.data[position], position);
driver->sent += 1u;
}
}
static void complete_request(driver_t *driver)
{
unsigned identifier = driver->active.id;
reg_select(driver->registers, 0u);
driver->busy = 0u;
driver->completed += 1u;
reg_done(driver->registers, identifier, 0u);
}
static void service(driver_t *driver)
{
if (!driver->busy) {
return;
}
receive_drain(driver);
transmit_fill(driver);
if (transfer_finished(driver)) {
complete_request(driver);
}
}
static void start_request(driver_t *driver, const request_t *request)
{
driver->active = *request;
driver->sent = 0u;
driver->received = 0u;
driver->busy = 1u;
reg_select(driver->registers, 1u);
service(driver);
}
static void reject_request(driver_t *driver, const request_t *request)
{
driver->rejected += 1u;
reg_reject(driver->registers, request->id);
}
void driver_init(driver_t *driver, registers_t *registers)
{
memset(driver, 0, sizeof(*driver));
driver->registers = registers;
reg_init(registers);
}
void driver_submit(driver_t *driver, const request_t *request)
{
if (driver->busy) {
reject_request(driver, request);
return;
}
if (!request_valid(request)) {
reject_request(driver, request);
return;
}
start_request(driver, request);
}
void driver_irq(driver_t *driver)
{
service(driver);
}
void driver_cancel(driver_t *driver, unsigned id)
{
unsigned identifier;
if (!driver->busy) {
return;
}
if (driver->active.id != id) {
return;
}
identifier = driver->active.id;
reg_flush(driver->registers);
reg_select(driver->registers, 0u);
driver->busy = 0u;
driver->cancelled += 1u;
reg_done(driver->registers, identifier, 3u);
}
void driver_snapshot(const driver_t *driver, snapshot_t *snapshot)
{
snapshot->id = driver->busy ? driver->active.id : 0u;
snapshot->length = driver->busy ? driver->active.length : 0u;
snapshot->sent = driver->sent;
snapshot->received = driver->received;
snapshot->completed = driver->completed;
snapshot->cancelled = driver->cancelled;
snapshot->rejected = driver->rejected;
}
unsigned driver_remaining(const driver_t *driver)
{
if (!driver->busy) {
return 0u;
}
if (driver->received >= driver->active.length) {
return 0u;
}
return driver->active.length - driver->received;
}