hisiflash 0.3.0

Library for flashing HiSilicon chips
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
133
134
135
136
137
138
139
140
141
142

//! Error types for hisiflash.

use {std::io, thiserror::Error};

/// Result type for hisiflash operations.
pub type Result<T> = std::result::Result<T, Error>;

/// Error type for hisiflash operations.
#[derive(Debug, Error)]
pub enum Error {
    /// I/O error (serial port, file operations).
    #[error("I/O error: {0}")]
    Io(#[from] io::Error),

    /// Serial port error.
    #[error("Serial port error: {0}")]
    Serial(#[from] serialport::Error),

    /// Invalid firmware package format.
    #[error("Invalid FWPKG: {0}")]
    InvalidFwpkg(String),

    /// CRC checksum mismatch.
    #[error("CRC mismatch: expected {expected:#06x}, got {actual:#06x}")]
    CrcMismatch {
        /// Expected CRC value.
        expected: u16,
        /// Actual CRC value.
        actual: u16,
    },

    /// Communication timeout.
    #[error("Timeout: {0}")]
    Timeout(String),

    /// Device not responding or not in boot mode.
    #[error("Device not found or not in boot mode")]
    DeviceNotFound,

    /// Handshake failed.
    #[error("Handshake failed: {0}")]
    HandshakeFailed(String),

    /// Protocol error.
    #[error("Protocol error: {0}")]
    Protocol(String),

    /// YMODEM transfer error.
    #[error("YMODEM error: {0}")]
    Ymodem(String),

    /// Unsupported chip or operation.
    #[error("Unsupported: {0}")]
    Unsupported(String),

    /// Configuration error.
    #[error("Configuration error: {0}")]
    Config(String),
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_error_display_messages() {
        let err = Error::InvalidFwpkg("bad magic".into());
        assert!(
            err.to_string()
                .contains("bad magic")
        );

        let err = Error::CrcMismatch {
            expected: 0x1234,
            actual: 0x5678,
        };
        let msg = err.to_string();
        assert!(msg.contains("1234"));
        assert!(msg.contains("5678"));

        let err = Error::Timeout("read timed out".into());
        assert!(
            err.to_string()
                .contains("read timed out")
        );

        let err = Error::DeviceNotFound;
        assert!(
            !err.to_string()
                .is_empty()
        );

        let err = Error::HandshakeFailed("no ack".into());
        assert!(
            err.to_string()
                .contains("no ack")
        );

        let err = Error::Protocol("invalid frame".into());
        assert!(
            err.to_string()
                .contains("invalid frame")
        );

        let err = Error::Ymodem("transfer aborted".into());
        assert!(
            err.to_string()
                .contains("transfer aborted")
        );

        let err = Error::Unsupported("bs2x".into());
        assert!(
            err.to_string()
                .contains("bs2x")
        );

        let err = Error::Config("missing field".into());
        assert!(
            err.to_string()
                .contains("missing field")
        );
    }

    #[test]
    fn test_error_from_io() {
        let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "file not found");
        let err: Error = io_err.into();
        assert!(matches!(err, Error::Io(_)));
        assert!(
            err.to_string()
                .contains("file not found")
        );
    }

    #[test]
    fn test_error_is_send_sync() {
        fn assert_send<T: Send>() {}
        fn assert_sync<T: Sync>() {}
        assert_send::<Error>();
        assert_sync::<Error>();
    }
}