cat25040 0.1.2

A `no_std`, async Rust driver for the **ON Semiconductor CAT25040** (4-Kbit SPI EEPROM), built on [`embedded-hal-async`](https://crates.io/crates/embedded-hal-async) traits.
Documentation 
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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Register interface implementation for CAT25040 SPI communication.
//!
//! This module bridges the device-driver crate's RegisterInterface traits
//! with the CAT25040's SPI protocol.

use crate::{Cat25040Error, Operation, Spi};
use device_driver::{AsyncCommandInterface, AsyncRegisterInterface, CommandInterface, RegisterInterface};

/// Wrapper that implements device-driver's RegisterInterface for our SPI trait.
pub struct SpiRegisterInterface<S: Spi> {
    spi: S,
}

impl<S: Spi> SpiRegisterInterface<S> {
    /// Create a new SPI register interface wrapper.
    pub fn new(spi: S) -> Self {
        Self { spi }
    }

    /// Unwrap and return the underlying SPI interface.
    pub fn into_inner(self) -> S {
        self.spi
    }

    /// Get a mutable reference to the underlying SPI interface.
    pub fn spi_mut(&mut self) -> &mut S {
        &mut self.spi
    }
}

impl<S: Spi> RegisterInterface for SpiRegisterInterface<S> {
    type AddressType = u8;
    type Error = Cat25040Error;

    fn read_register(
        &mut self,
        _address: Self::AddressType,
        _size_bits: u32,
        _data: &mut [u8],
    ) -> Result<(), Self::Error> {
        // For CAT25040, the address IS the opcode for register reads (e.g., 0x05 for status)
        // We need to use async in a sync context, which isn't directly possible
        // This is a limitation - we'll implement the async version primarily
        unimplemented!("Use AsyncRegisterInterface instead for async operations")
    }

    fn write_register(
        &mut self,
        _address: Self::AddressType,
        _size_bits: u32,
        _data: &[u8],
    ) -> Result<(), Self::Error> {
        unimplemented!("Use AsyncRegisterInterface instead for async operations")
    }
}

impl<S: Spi> AsyncRegisterInterface for SpiRegisterInterface<S> {
    type AddressType = u8;
    type Error = Cat25040Error;

    async fn read_register(
        &mut self,
        address: Self::AddressType,
        _size_bits: u32,
        data: &mut [u8],
    ) -> Result<(), Self::Error> {
        // For CAT25040, address is the opcode (e.g., 0x05 for Read Status)
        self.spi
            .transaction(&mut [Operation::Write(&[address]), Operation::Read(data)])
            .await
    }

    async fn write_register(
        &mut self,
        address: Self::AddressType,
        _size_bits: u32,
        data: &[u8],
    ) -> Result<(), Self::Error> {
        // For CAT25040, address is the opcode (e.g., 0x01 for Write Status)
        let mut buf = [0u8; 9]; // Max: 1 byte opcode + 8 bytes data
        buf[0] = address;
        let len = 1 + data.len();
        buf[1..len].copy_from_slice(data);

        self.spi
            .transaction(&mut [Operation::Write(&buf[..len])])
            .await
    }
}

impl<S: Spi> CommandInterface for SpiRegisterInterface<S> {
    type AddressType = u8;
    type Error = Cat25040Error;

    fn dispatch_command(
        &mut self,
        _address: Self::AddressType,
        _size_bits_in: u32,
        _input: &[u8],
        _size_bits_out: u32,
        _output: &mut [u8],
    ) -> Result<(), Self::Error> {
        unimplemented!("Use AsyncCommandInterface instead for async operations")
    }
}

impl<S: Spi> AsyncCommandInterface for SpiRegisterInterface<S> {
    type AddressType = u8;
    type Error = Cat25040Error;

    async fn dispatch_command(
        &mut self,
        address: Self::AddressType,
        _size_bits_in: u32,
        input: &[u8],
        _size_bits_out: u32,
        output: &mut [u8],
    ) -> Result<(), Self::Error> {
        // For CAT25040 commands:
        // - Commands like WREN/WRDI have no input/output (empty slices)
        // - Just send the opcode
        if input.is_empty() && output.is_empty() {
            // Simple command with no data
            self.spi
                .transaction(&mut [Operation::Write(&[address])])
                .await
        } else {
            // Commands with input/output would go here if needed
            unimplemented!("Commands with input/output not yet supported")
        }
    }
}