Enum opentitanlib::bootstrap::BootstrapProtocol

source ·

pub enum BootstrapProtocol {
    Primitive,
    Legacy,
    LegacyRescue,
    Eeprom,
    Emulator,
}

Expand description

BootstrapProtocol describes the supported types of bootstrap. The Primitive SPI protocol is used by OpenTitan during development. The Legacy SPI protocol is used by previous generations of Google Titan-class chips. The LegacyRescue UART protocol is used by previous generations of Google Titan-class chips. The Eeprom SPI protocol is planned to be implemented for OpenTitan. The ‘Emulator’ value indicates that this tool has a direct way of communicating with the OpenTitan emulator, to replace the contents of the emulated flash storage.

Variants§

§

Enum opentitanlib::bootstrap::BootstrapProtocol

Variants§

Primitive

Legacy

LegacyRescue

Eeprom

Emulator

Trait Implementations§

impl Clone for BootstrapProtocol

fn clone(&self) -> BootstrapProtocol

fn clone_from(&mut self, source: &Self)

impl Debug for BootstrapProtocol

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<'de> Deserialize<'de> for BootstrapProtocol

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

impl PartialEq<BootstrapProtocol> for BootstrapProtocol

fn eq(&self, other: &BootstrapProtocol) -> bool

fn ne(&self, other: &Rhs) -> bool

impl Serialize for BootstrapProtocol

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

impl ValueEnum for BootstrapProtocol

fn value_variants<'a>() -> &'a [Self]

fn to_possible_value<'a>(&self) -> Option<PossibleValue>

fn from_str(input: &str, ignore_case: bool) -> Result<Self, String>

impl Copy for BootstrapProtocol

impl Eq for BootstrapProtocol

impl StructuralEq for BootstrapProtocol

impl StructuralPartialEq for BootstrapProtocol

Auto Trait Implementations§

impl RefUnwindSafe for BootstrapProtocol

impl Send for BootstrapProtocol

impl Sync for BootstrapProtocol

impl Unpin for BootstrapProtocol

impl UnwindSafe for BootstrapProtocol

Blanket Implementations§

impl<T> Annotate for Twhere T: Serialize + ?Sized,

default fn format( &self, _variant: Option<&str>, _field: &MemberId<'_> ) -> Option<Format>

default fn comment( &self, _variant: Option<&str>, _field: &MemberId<'_> ) -> Option<String>

default fn as_annotate(&self) -> Option<&dyn Annotate>

default fn thunk_serialize( &self, serializer: &mut AnnotatedSerializer<'_> ) -> Result<Document, Error>

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T, U> ConsoleRecv<T> for Uwhere T: ConsoleDevice + ?Sized, U: DeserializeOwned,

fn recv(device: &T, timeout: Duration, quiet: bool) -> Result<U, Error>

impl<T, U> ConsoleSend<T> for Uwhere T: ConsoleDevice + ?Sized, U: Serialize,

fn send(&self, device: &T) -> Result<(), Error>

fn send_with_crc(&self, device: &T) -> Result<(), Error>

impl<T> Conv for T

fn conv<T>(self) -> Twhere Self: Into<T>,

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>where Self: Binary,

fn fmt_display(self) -> FmtDisplay<Self>where Self: Display,

fn fmt_lower_exp(self) -> FmtLowerExp<Self>where Self: LowerExp,

fn fmt_lower_hex(self) -> FmtLowerHex<Self>where Self: LowerHex,

fn fmt_octal(self) -> FmtOctal<Self>where Self: Octal,

fn fmt_pointer(self) -> FmtPointer<Self>where Self: Pointer,

fn fmt_upper_exp(self) -> FmtUpperExp<Self>where Self: UpperExp,

fn fmt_upper_hex(self) -> FmtUpperHex<Self>where Self: UpperHex,

fn fmt_list(self) -> FmtList<Self>where &'a Self: for<'a> IntoIterator,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> Pipe for Twhere T: ?Sized,

fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere Self: Sized,

fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere R: 'a,

fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere R: 'a,

fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere Self: Borrow<B>, B: 'a + ?Sized, R: 'a,

fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> Rwhere Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,

fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere Self: AsRef<U>, U: 'a + ?Sized, R: 'a,

fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere Self: AsMut<U>, U: 'a + ?Sized, R: 'a,

fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,

fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> Rwhere Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,

impl<T> Same<T> for T

type Output = T

impl<T> Serialize for Twhere T: Serialize + ?Sized,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where __D: Deserializer<'de>,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,