aic8800 0.2.9

OS-independent AIC8800 Wi-Fi driver core
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

use alloc::{collections::VecDeque, vec::Vec};

use super::{
    AicError, AicEvent, AicState, ControlState, IoPurpose, MailboxState, MonotonicTime, PendingIo,
    SdioRequestKind, StartupState, TxToken,
};
use crate::{
    common::ChipVariant, firmware::images, registers::RegisterMap, rx::RxState, tx::TxState,
};

pub(super) struct ActiveTx {
    pub token: TxToken,
    pub wire_frame: Vec<u8>,
}

pub(super) struct LifecycleState {
    pub state: AicState,
    pub startup: Option<StartupState>,
    pub mailbox: Option<MailboxState>,
    pub control: Option<ControlState>,
    pub last_time: MonotonicTime,
    pub retry_at: Option<MonotonicTime>,
    pub cancel_pending: bool,
}

pub(super) struct IoState {
    pub pending: Option<PendingIo>,
    pub next: Option<(IoPurpose, SdioRequestKind)>,
    pub next_request_id: u64,
    pub irq_pending: bool,
    pub last_irq_sequence: u64,
}

pub(super) struct DataPlaneState {
    pub events: VecDeque<AicEvent>,
    pub rx: RxState,
    pub tx: TxState,
    pub active_tx: Option<ActiveTx>,
    pub mac_address: [u8; 6],
    pub interface_index: u8,
    pub station_index: u8,
}

/// Sole owner of all AIC protocol and data-plane state.
pub struct AicDevice {
    pub(super) chip: ChipVariant,
    pub(super) registers: RegisterMap,
    pub(super) lifecycle: LifecycleState,
    pub(super) io: IoState,
    pub(super) data: DataPlaneState,
}

impl AicDevice {
    /// Creates a stopped device owner for one supported chip.
    ///
    /// # Errors
    ///
    /// Returns [`AicError::UnsupportedChip`] when no firmware image and startup
    /// sequence exist for `chip`.
    pub fn new(chip: ChipVariant) -> Result<Self, AicError> {
        images(chip).ok_or(AicError::UnsupportedChip)?;
        Ok(Self {
            chip,
            registers: RegisterMap::for_chip(chip),
            lifecycle: LifecycleState {
                state: AicState::Stopped,
                startup: None,
                mailbox: None,
                control: None,
                last_time: MonotonicTime::default(),
                retry_at: None,
                cancel_pending: false,
            },
            io: IoState {
                pending: None,
                next: None,
                next_request_id: 1,
                irq_pending: false,
                last_irq_sequence: 0,
            },
            data: DataPlaneState {
                events: VecDeque::new(),
                rx: RxState::new(),
                tx: TxState::new(),
                active_tx: None,
                mac_address: [0; 6],
                interface_index: 0xff,
                station_index: 0xff,
            },
        })
    }

    /// Returns the externally visible lifecycle state.
    pub const fn state(&self) -> AicState {
        self.lifecycle.state
    }

    /// Returns the selected chip variant.
    pub const fn chip(&self) -> ChipVariant {
        self.chip
    }

    /// Returns the MAC address learned during startup.
    pub const fn mac_address(&self) -> [u8; 6] {
        self.data.mac_address
    }
}