Complete batch 20261016-C-embedded-2: 45 verified GLM/Pi samples, independent regrades and archives; preserve difficulty misses and Salty blockage.
160 lines
3.7 KiB
C
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;
|
|
}
|