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

163 lines
4.0 KiB
C

#include "lab.h"
#include <string.h>
typedef struct {
unsigned channel;
unsigned bit;
mailbox_t message;
} delivery_t;
static unsigned enabled_snapshot(const driver_t *driver)
{
unsigned pending = reg_pending(driver->registers);
unsigned enabled = reg_enabled(driver->registers);
return pending & enabled;
}
static unsigned channel_selected(unsigned snapshot, unsigned channel)
{
unsigned bit = channel_bit(channel);
return (snapshot & bit) != 0u;
}
static delivery_t prepare_delivery(driver_t *driver, unsigned channel)
{
delivery_t delivery;
delivery.channel = channel;
delivery.bit = channel_bit(channel);
delivery.message = reg_read(driver->registers, channel);
return delivery;
}
static void acknowledge_delivery(driver_t *driver, const delivery_t *delivery)
{
reg_clear(driver->registers, delivery->bit);
}
static void remember_delivery(driver_t *driver, const delivery_t *delivery)
{
driver->delivered[delivery->channel] = delivery->message.sequence;
driver->callbacks += 1u;
}
static void notify_delivery(driver_t *driver, const delivery_t *delivery)
{
reg_callback(driver->registers,
delivery->channel,
delivery->message.value);
}
static void dispatch_channel(driver_t *driver, unsigned channel)
{
delivery_t delivery = prepare_delivery(driver, channel);
acknowledge_delivery(driver, &delivery);
remember_delivery(driver, &delivery);
notify_delivery(driver, &delivery);
}
static unsigned dispatch_budget(driver_t *driver,
unsigned snapshot,
unsigned budget)
{
unsigned delivered = 0u;
while (snapshot != 0u && delivered < budget) {
unsigned channel = 0u;
while (!channel_selected(snapshot, channel)) {
channel += 1u;
}
dispatch_channel(driver, channel);
snapshot &= ~channel_bit(channel);
delivered += 1u;
}
return delivered;
}
static void reset_statistics(driver_t *driver)
{
unsigned channel;
for (channel = 0u; channel < CHANNELS; ++channel) {
driver->delivered[channel] = 0u;
}
driver->callbacks = 0u;
driver->interrupts = 0u;
driver->ignored = 0u;
}
static void copy_delivered(const driver_t *driver, snapshot_t *snapshot)
{
unsigned channel;
for (channel = 0u; channel < CHANNELS; ++channel) {
snapshot->delivered[channel] = driver->delivered[channel];
}
}
static void copy_statistics(const driver_t *driver, snapshot_t *snapshot)
{
snapshot->callbacks = driver_callback_count(driver);
snapshot->interrupts = driver_interrupt_count(driver);
snapshot->ignored = driver_ignored_count(driver);
}
void driver_init(driver_t *driver, registers_t *registers)
{
memset(driver, 0, sizeof(*driver));
driver->registers = registers;
reset_statistics(driver);
reg_init(registers);
}
void driver_enable(driver_t *driver, unsigned mask)
{
reg_enable(driver->registers, mask);
}
void driver_service(driver_t *driver, unsigned budget)
{
unsigned snapshot = enabled_snapshot(driver);
unsigned delivered;
driver->interrupts += 1u;
if (snapshot == 0u || budget == 0u) {
driver->ignored += 1u;
return;
}
if (budget > CHANNELS) {
budget = CHANNELS;
}
delivered = dispatch_budget(driver, snapshot, budget);
(void)delivered;
}
void driver_irq(driver_t *driver)
{
driver_service(driver, CHANNELS);
}
void driver_snapshot(const driver_t *driver, snapshot_t *snapshot)
{
copy_delivered(driver, snapshot);
copy_statistics(driver, snapshot);
}
unsigned driver_delivered(const driver_t *driver, unsigned channel)
{
if (!channel_valid(channel)) {
return 0u;
}
return driver->delivered[channel];
}
unsigned driver_callback_count(const driver_t *driver)
{
return driver->callbacks;
}
unsigned driver_interrupt_count(const driver_t *driver)
{
return driver->interrupts;
}
unsigned driver_ignored_count(const driver_t *driver)
{
return driver->ignored;
}