Skip to main content

mediatek_optical/
error_codes.rs

1//! Stable identifiers for host diagnostics and translation keys.
2
3/// A typed error with a stable, namespaced identifier.
4///
5/// Codes contain no runtime values. Match the error variant for parameters;
6/// `Display` is diagnostic prose and may change. Wrapper errors retain their
7/// own stage code; their typed causes describe the underlying failure.
8pub trait CodedError {
9    /// Stable identifier, such as `mediatek.receiver.changed`.
10    fn code(&self) -> &'static str;
11}
12
13impl CodedError for crate::UnknownChip {
14    fn code(&self) -> &'static str {
15        "mediatek.chip.unknown_label"
16    }
17}
18
19#[cfg(feature = "drive")]
20impl<E> CodedError for crate::drive::Error<E> {
21    fn code(&self) -> &'static str {
22        match self {
23            Self::Transport(_) => "mediatek.drive.transport",
24            Self::Short { .. } => "mediatek.drive.short",
25            Self::Oversize(_) => "mediatek.drive.oversize",
26        }
27    }
28}
29
30#[cfg(feature = "enc")]
31impl CodedError for crate::enc::LengthError {
32    fn code(&self) -> &'static str {
33        "mediatek.enc.length"
34    }
35}
36
37#[cfg(feature = "image")]
38impl CodedError for crate::image::ChipError {
39    fn code(&self) -> &'static str {
40        match self {
41            Self::Undetectable => "mediatek.image.undetectable_chip",
42        }
43    }
44}
45
46#[cfg(feature = "image")]
47impl CodedError for crate::image::cmac::CmacError {
48    fn code(&self) -> &'static str {
49        match self {
50            Self::ImageTooSmall { .. } => "mediatek.cmac.image_too_small",
51            Self::BadRange { .. } => "mediatek.cmac.bad_range",
52        }
53    }
54}
55
56#[cfg(feature = "image")]
57impl CodedError for crate::update::PrepareError {
58    fn code(&self) -> &'static str {
59        match self {
60            Self::ReceiverEntry => "mediatek.prepare.receiver_entry",
61            Self::ReceiverContract => "mediatek.prepare.receiver_contract",
62            Self::Size(_) => "mediatek.prepare.size",
63            Self::Integrity => "mediatek.prepare.integrity",
64            Self::DriveRead => "mediatek.prepare.drive_read",
65            Self::UnknownChip => "mediatek.prepare.unknown_chip",
66            Self::UnknownDriveChip => "mediatek.prepare.unknown_drive_chip",
67            Self::ChipMismatch { .. } => "mediatek.prepare.chip_mismatch",
68            Self::InstalledMismatch => "mediatek.prepare.installed_mismatch",
69            Self::UnknownInstalledFamily => "mediatek.prepare.unknown_installed_family",
70            Self::UnknownTargetFamily => "mediatek.prepare.unknown_target_family",
71            Self::FamilyMismatch { .. } => "mediatek.prepare.family_mismatch",
72        }
73    }
74}
75
76#[cfg(all(feature = "image", feature = "enc"))]
77impl CodedError for crate::envelope::Error {
78    fn code(&self) -> &'static str {
79        match self {
80            Self::Image(_) => "mediatek.envelope.image",
81            Self::UnknownFraming => "mediatek.envelope.unknown_framing",
82            Self::Ambiguous => "mediatek.envelope.ambiguous",
83        }
84    }
85}
86
87#[cfg(feature = "oem")]
88impl CodedError for crate::oem::RebuildError {
89    fn code(&self) -> &'static str {
90        match self {
91            Self::Size(_) => "mediatek.oem.size",
92            Self::Chip(_) => "mediatek.oem.chip",
93            Self::NoFactory(_) => "mediatek.oem.no_factory",
94            Self::UnknownBootPage(_) => "mediatek.oem.unknown_boot_page",
95            Self::Factory(_) => "mediatek.oem.factory",
96        }
97    }
98}
99
100#[cfg(feature = "drive")]
101impl<E> CodedError for crate::receiver::Error<E> {
102    fn code(&self) -> &'static str {
103        match self {
104            Self::Read(_) => "mediatek.receiver.read",
105            Self::InvalidIdentity => "mediatek.receiver.invalid_identity",
106            Self::Unknown => "mediatek.receiver.unknown",
107            Self::Conflict => "mediatek.receiver.conflict",
108            Self::Changed => "mediatek.receiver.changed",
109            Self::UnknownEntry => "mediatek.receiver.unknown_entry",
110        }
111    }
112}
113
114#[cfg(all(feature = "drive", feature = "image"))]
115impl<E> CodedError for crate::update::FlashError<E> {
116    fn code(&self) -> &'static str {
117        match self {
118            Self::Entry(_) => "mediatek.flash.entry",
119            Self::Transfer { .. } => "mediatek.flash.transfer",
120            Self::Fault { .. } => "mediatek.flash.fault",
121            Self::ReadyTimeout(_) => "mediatek.flash.ready_timeout",
122            Self::Startup(_) => "mediatek.flash.startup",
123            Self::Mismatch { .. } => "mediatek.flash.mismatch",
124            Self::Incomplete { .. } => "mediatek.flash.incomplete",
125        }
126    }
127}
128
129#[cfg(all(feature = "drive", feature = "image"))]
130impl<E> CodedError for crate::update::StartupError<E> {
131    fn code(&self) -> &'static str {
132        match self {
133            Self::Identity(_) => "mediatek.startup.identity",
134            Self::Read(_) => "mediatek.startup.read",
135            Self::TargetMismatch => "mediatek.startup.target_mismatch",
136        }
137    }
138}
139
140#[cfg(all(feature = "drive", feature = "image", feature = "enc"))]
141impl<E> CodedError for crate::receiver::ExecuteError<E> {
142    fn code(&self) -> &'static str {
143        match self {
144            Self::Receiver(_) => "mediatek.execute.receiver",
145            Self::Flash(_) => "mediatek.execute.flash",
146        }
147    }
148}
149
150#[cfg(all(feature = "drive", feature = "image", feature = "enc"))]
151impl<E> CodedError for crate::receiver::reference::Error<E> {
152    fn code(&self) -> &'static str {
153        match self {
154            Self::Analysis(_) => "mediatek.reference.analysis",
155            Self::Binding(_) => "mediatek.reference.binding",
156        }
157    }
158}
159
160#[cfg(all(feature = "drive", feature = "image", feature = "enc"))]
161impl CodedError for crate::receiver::layout::Error {
162    fn code(&self) -> &'static str {
163        match self {
164            Self::Alignment => "mediatek.layout.alignment",
165            Self::Range => "mediatek.layout.range",
166            Self::Conflict { .. } => "mediatek.layout.conflict",
167            Self::MultipleDecryptions { .. } => "mediatek.layout.multiple_decryptions",
168            Self::NoProgram => "mediatek.layout.no_program",
169            Self::ImageSize => "mediatek.layout.image_size",
170        }
171    }
172}
173
174#[cfg(all(feature = "drive", feature = "image", feature = "enc"))]
175impl<E> CodedError for crate::recovery::Error<E> {
176    fn code(&self) -> &'static str {
177        match self {
178            Self::Receiver(_) => "mediatek.recovery.receiver",
179            Self::Reference(_) => "mediatek.recovery.reference",
180            Self::Read(_) => "mediatek.recovery.read",
181            Self::Image(_) => "mediatek.recovery.image",
182            Self::Flash(_) => "mediatek.recovery.flash",
183            Self::Changed => "mediatek.recovery.changed",
184            Self::Startup => "mediatek.recovery.startup",
185        }
186    }
187}