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