Move USB host stuff to separate crate.

6 files changed, 1357 insertions, 0 deletions

diff --git a/usbh/src/pipe/addr.rs b/usbh/src/pipe/addr.rs
new file mode 100644
index 0000000..8b92177
--- /dev/null
+++ b/usbh/src/pipe/addr.rs
@@ -0,0 +1,87 @@
+/// § 32.8.7.2
+/// Address of the Data Buffer.
+///
+/// Offset: 0x00 & 0x10
+/// Reset: 0xxxxxxxxx
+/// Property: NA
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+pub(crate) struct Addr(u32);
+
+pub(crate) struct R {
+    bits: u32,
+}
+
+pub(crate) struct W {
+    bits: u32,
+}
+
+impl Addr {
+    pub fn read(&self) -> R {
+        R { bits: self.0 }
+    }
+
+    pub fn write<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut W) -> &mut W,
+    {
+        let mut w = W { bits: self.0 };
+        f(&mut w);
+        // Address must be 32-bit aligned.
+        assert!((w.bits & 0x3) == 0);
+        self.0 = w.bits;
+    }
+}
+
+impl From<u32> for Addr {
+    fn from(v: u32) -> Self {
+        Self(v)
+    }
+}
+
+impl R {
+    /// Value in raw bits.
+    pub fn bits(&self) -> u32 {
+        self.bits
+    }
+
+    pub fn addr(&self) -> AddrR {
+        AddrR(self.bits)
+    }
+}
+
+/// Data Pointer Address Value
+///
+/// These bits define the data pointer address as an absolute double
+/// word address in RAM. The two least significant bits must be zero
+/// to ensure the descriptor is 32-bit aligned.
+pub(crate) struct AddrR(u32);
+impl AddrR {
+    pub fn bits(&self) -> u32 {
+        self.0
+    }
+}
+
+impl W {
+    /// Write raw bits.
+    pub unsafe fn bits(&mut self, v: u32) -> &mut Self {
+        self.bits = v;
+        self
+    }
+
+    pub fn addr(&mut self) -> AddrW {
+        AddrW { w: self }
+    }
+}
+
+pub(crate) struct AddrW<'a> {
+    w: &'a mut W,
+}
+impl<'a> AddrW<'a> {
+    pub unsafe fn bits(self, v: u32) -> &'a mut W {
+        self.w.bits = v;
+        self.w
+    }
+
+    // TODO: "safe" method take a pointer instead of raw u32
+}
diff --git a/usbh/src/pipe/ctrl_pipe.rs b/usbh/src/pipe/ctrl_pipe.rs
new file mode 100644
index 0000000..63390df
--- /dev/null
+++ b/usbh/src/pipe/ctrl_pipe.rs
@@ -0,0 +1,177 @@
+/// Host Control Pipe.
+///
+/// Offset: 0x0c
+/// Reset: 0xXXXX
+/// Property: PAC Write-Protection, Write-Synchronized, Read-Synchronized
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+pub(crate) struct CtrlPipe(u16);
+
+pub(crate) struct R {
+    bits: u16,
+}
+
+pub(crate) struct W {
+    bits: u16,
+}
+
+impl CtrlPipe {
+    pub fn read(&self) -> R {
+        R { bits: self.0 }
+    }
+
+    pub fn write<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut W) -> &mut W,
+    {
+        let mut w = W { bits: self.0 };
+        f(&mut w);
+        self.0 = w.bits;
+    }
+}
+
+impl From<u16> for CtrlPipe {
+    fn from(v: u16) -> Self {
+        Self(v)
+    }
+}
+
+impl R {
+    /// Value in raw bits.
+    pub fn bits(&self) -> u16 {
+        self.bits
+    }
+
+    pub fn permax(&self) -> PErMaxR {
+        let bits = {
+            const POS: u8 = 12;
+            const MASK: u16 = 0xf;
+            ((self.bits >> POS) & MASK) as u8
+        };
+
+        PErMaxR(bits)
+    }
+
+    pub fn pepnum(&self) -> PEpNumR {
+        let bits = {
+            const POS: u8 = 8;
+            const MASK: u16 = 0xf;
+            ((self.bits >> POS) & MASK) as u8
+        };
+
+        PEpNumR(bits)
+    }
+
+    pub fn pdaddr(&self) -> PDAddrR {
+        let bits = {
+            const POS: u8 = 0;
+            const MASK: u16 = 0x3f;
+            ((self.bits >> POS) & MASK) as u8
+        };
+
+        PDAddrR(bits)
+    }
+}
+
+/// Pipe Error Max Number
+///
+/// These bits define the maximum number of error for this Pipe before
+/// freezing the pipe automatically.
+pub(crate) struct PErMaxR(u8);
+impl PErMaxR {
+    pub fn max(&self) -> u8 {
+        self.0
+    }
+}
+
+/// Pipe EndPoint Number
+///
+/// These bits define the number of endpoint for this Pipe.
+pub(crate) struct PEpNumR(u8);
+impl PEpNumR {
+    pub fn epnum(&self) -> u8 {
+        self.0
+    }
+}
+
+/// Pipe Device Address
+///
+/// These bits define the Device Address for this pipe.
+pub(crate) struct PDAddrR(u8);
+impl PDAddrR {
+    pub fn addr(&self) -> u8 {
+        self.0
+    }
+}
+
+impl W {
+    /// Write raw bits.
+
+    pub unsafe fn bits(&mut self, v: u16) -> &mut Self {
+        self.bits = v;
+        self
+    }
+
+    pub fn permax(&mut self) -> PErMaxW {
+        PErMaxW { w: self }
+    }
+
+    pub fn pepnum(&mut self) -> PEpNumW {
+        PEpNumW { w: self }
+    }
+
+    pub fn pdaddr(&mut self) -> PDAddrW {
+        PDAddrW { w: self }
+    }
+}
+
+pub(crate) struct PErMaxW<'a> {
+    w: &'a mut W,
+}
+impl<'a> PErMaxW<'a> {
+    pub unsafe fn bits(self, v: u8) -> &'a mut W {
+        const POS: u8 = 12;
+        const MASK: u8 = 0xf;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+
+    pub fn set_max(self, v: u8) -> &'a mut W {
+        unsafe { self.bits(v) }
+    }
+}
+
+pub(crate) struct PEpNumW<'a> {
+    w: &'a mut W,
+}
+impl<'a> PEpNumW<'a> {
+    pub unsafe fn bits(self, v: u8) -> &'a mut W {
+        const POS: u8 = 8;
+        const MASK: u8 = 0xf;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+
+    pub fn set_epnum(self, v: u8) -> &'a mut W {
+        unsafe { self.bits(v) }
+    }
+}
+
+pub(crate) struct PDAddrW<'a> {
+    w: &'a mut W,
+}
+impl<'a> PDAddrW<'a> {
+    pub unsafe fn bits(self, v: u8) -> &'a mut W {
+        const POS: u8 = 0;
+        const MASK: u8 = 0x3f;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+
+    pub fn set_addr(self, v: u8) -> &'a mut W {
+        unsafe { self.bits(v) }
+    }
+}
diff --git a/usbh/src/pipe/ext_reg.rs b/usbh/src/pipe/ext_reg.rs
new file mode 100644
index 0000000..023ce9f
--- /dev/null
+++ b/usbh/src/pipe/ext_reg.rs
@@ -0,0 +1,156 @@
+/// §32.8.7.4
+/// Extended Register.
+///
+/// Offset: 0x08
+/// Reset: 0xxxxxxxx
+/// Property: NA
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+pub(crate) struct ExtReg(u16);
+
+pub(crate) struct R {
+    bits: u16,
+}
+
+pub(crate) struct W {
+    bits: u16,
+}
+
+impl ExtReg {
+    pub fn read(&self) -> R {
+        R { bits: self.0 }
+    }
+
+    pub fn write<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut W) -> &mut W,
+    {
+        let mut w = W { bits: self.0 };
+        f(&mut w);
+        self.0 = w.bits;
+    }
+}
+
+impl From<u16> for ExtReg {
+    fn from(v: u16) -> Self {
+        Self(v)
+    }
+}
+
+impl R {
+    /// Value in raw bits.
+    pub fn bits(&self) -> u16 {
+        self.bits
+    }
+
+    pub fn variable(&self) -> VariableR {
+        let bits = {
+            const POS: u8 = 4;
+            const MASK: u16 = 0x7ff;
+            (self.bits >> POS) & MASK
+        };
+
+        VariableR(bits)
+    }
+
+    pub fn subpid(&self) -> SubPIDR {
+        let bits = {
+            const POS: u8 = 0;
+            const MASK: u16 = 0xf;
+            ((self.bits >> POS) & MASK) as u8
+        };
+
+        SubPIDR(bits)
+    }
+}
+
+/// Variable field send with extended token
+///
+/// These bits define the VARIABLE field sent with extended token. See
+/// “Section 2.1.1 Protocol Extension Token in the reference document
+/// ENGINEERING CHANGE NOTICE, USB 2.0 Link Power Management
+/// Addendum.”
+///
+/// To support the USB2.0 Link Power Management addition the VARIABLE
+/// field should be set as described below.
+///
+/// | VARIABLE       | Description           |
+/// +----------------+-----------------------+
+/// | VARIABLE[3:0]  | bLinkState[1]         |
+/// | VARIABLE[7:4]  | BESL (See LPM ECN)[2] |
+/// | VARIABLE[8]    | bRemoteWake[1]        |
+/// | VARIABLE[10:9] | Reserved              |
+///
+/// [1] for a definition of LPM Token bRemoteWake and bLinkState
+/// fields, refer to "Table 2-3 in the reference document ENGINEERING
+/// CHANGE NOTICE, USB 2.0 Link Power Management Addendum"
+///
+/// [2] for a definition of LPM Token BESL field, refer to "Table 2-3
+/// in the reference document ENGINEERING CHANGE NOTICE, USB 2.0 Link
+/// Power Management Addendum" and "Table X-X1 in Errata for ECN USB
+/// 2.0 Link Power Management.
+pub(crate) struct VariableR(u16);
+impl VariableR {
+    pub fn bits(&self) -> u16 {
+        self.0
+    }
+}
+
+/// SUBPID field with extended token
+///
+/// These bits define the SUBPID field sent with extended token. See
+/// “Section 2.1.1 Protocol Extension Token in the reference document
+/// ENGINEERING CHANGE NOTICE, USB 2.0 Link Power Management
+/// Addendum”.
+///
+/// To support the USB2.0 Link Power Management addition the SUBPID
+/// field should be set as described in “Table 2.2 SubPID Types in the
+/// reference document ENGINEERING CHANGE NOTICE, USB 2.0 Link Power
+/// Management Addendum”.
+pub(crate) struct SubPIDR(u8);
+impl SubPIDR {
+    pub fn bits(&self) -> u8 {
+        self.0
+    }
+}
+
+impl W {
+    /// Write raw bits.
+    pub unsafe fn bits(&mut self, v: u16) -> &mut Self {
+        self.bits = v;
+        self
+    }
+
+    pub fn variable(&mut self) -> VariableW {
+        VariableW { w: self }
+    }
+    pub fn subpid(&mut self) -> SubPIDW {
+        SubPIDW { w: self }
+    }
+}
+
+pub(crate) struct VariableW<'a> {
+    w: &'a mut W,
+}
+impl<'a> VariableW<'a> {
+    pub unsafe fn bits(self, v: u16) -> &'a mut W {
+        const POS: u8 = 4;
+        const MASK: u16 = 0x7ff;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+}
+
+pub(crate) struct SubPIDW<'a> {
+    w: &'a mut W,
+}
+impl<'a> SubPIDW<'a> {
+    pub unsafe fn bits(self, v: u16) -> &'a mut W {
+        const POS: u8 = 0;
+        const MASK: u16 = 0xf;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+}
diff --git a/usbh/src/pipe/pck_size.rs b/usbh/src/pipe/pck_size.rs
new file mode 100644
index 0000000..5133005
--- /dev/null
+++ b/usbh/src/pipe/pck_size.rs
@@ -0,0 +1,360 @@
+/// § 32.8.7.3
+/// Packet Size.
+///
+/// Offset: 0x04 & 0x14
+/// Reset: 0xxxxxxxxx
+/// Property: NA
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+pub(crate) struct PckSize(u32);
+
+pub(crate) struct R {
+    bits: u32,
+}
+
+pub(crate) struct W {
+    bits: u32,
+}
+
+impl PckSize {
+    pub fn read(&self) -> R {
+        R { bits: self.0 }
+    }
+
+    pub fn write<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut W) -> &mut W,
+    {
+        let mut w = W { bits: self.0 };
+        f(&mut w);
+        self.0 = w.bits;
+    }
+}
+
+impl From<u32> for PckSize {
+    fn from(v: u32) -> Self {
+        Self(v)
+    }
+}
+
+impl R {
+    /// Value in raw bits.
+    pub fn bits(&self) -> u32 {
+        self.bits
+    }
+
+    pub fn auto_zlp(&self) -> AutoZLPR {
+        let bits = {
+            const POS: u8 = 31;
+            const MASK: u32 = 1;
+            ((self.bits >> POS) & MASK) == 1
+        };
+
+        AutoZLPR(bits)
+    }
+
+    pub fn size(&self) -> SizeR {
+        let bits = {
+            const POS: u8 = 28;
+            const MASK: u32 = 0x7;
+            ((self.bits >> POS) & MASK) as u8
+        };
+
+        SizeR::from(bits)
+    }
+
+    pub fn multi_packet_size(&self) -> MultiPacketSizeR {
+        let bits = {
+            const POS: u8 = 14;
+            const MASK: u32 = 0x3fff;
+            ((self.bits >> POS) & MASK) as u16
+        };
+
+        MultiPacketSizeR(bits)
+    }
+
+    pub fn byte_count(&self) -> ByteCountR {
+        let bits = {
+            const POS: u8 = 8;
+            const MASK: u32 = 0x3f;
+            ((self.bits >> POS) & MASK) as u8
+        };
+
+        ByteCountR(bits)
+    }
+}
+
+/// Automatic Zero Length Packet
+///
+/// This bit defines the automatic Zero Length Packet mode of the
+/// pipe.
+///
+/// When enabled, the USB module will manage the ZLP handshake by
+/// hardware. This bit is for OUT pipes only. When disabled the
+/// handshake should be managed by firmware.
+pub(crate) struct AutoZLPR(bool);
+impl AutoZLPR {
+    pub fn bit(&self) -> bool {
+        self.0
+    }
+
+    pub fn bit_is_set(&self) -> bool {
+        self.bit()
+    }
+
+    pub fn bit_is_clear(&self) -> bool {
+        !self.bit()
+    }
+}
+
+/// Pipe size
+///
+/// These bits contains the size of the pipe.
+///
+/// These bits are cleared upon sending a USB reset.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum SizeR {
+    Bytes8,
+    Bytes16,
+    Bytes32,
+    Bytes64,
+    Bytes128,
+    Bytes256,
+    Bytes512,
+    Bytes1024,
+}
+
+impl SizeR {
+    pub fn bits(&self) -> u8 {
+        match *self {
+            Self::Bytes8 => 0x0,
+            Self::Bytes16 => 0x1,
+            Self::Bytes32 => 0x2,
+            Self::Bytes64 => 0x3,
+            Self::Bytes128 => 0x4,
+            Self::Bytes256 => 0x5,
+            Self::Bytes512 => 0x6,
+            Self::Bytes1024 => 0x7,
+        }
+    }
+
+    fn is_bytes8(&self) -> bool {
+        *self == Self::Bytes8
+    }
+    fn is_bytes16(&self) -> bool {
+        *self == Self::Bytes16
+    }
+    fn is_bytes32(&self) -> bool {
+        *self == Self::Bytes32
+    }
+    fn is_bytes64(&self) -> bool {
+        *self == Self::Bytes64
+    }
+    fn is_bytes128(&self) -> bool {
+        *self == Self::Bytes128
+    }
+    fn is_bytes256(&self) -> bool {
+        *self == Self::Bytes256
+    }
+    fn is_bytes512(&self) -> bool {
+        *self == Self::Bytes512
+    }
+    fn is_bytes1024(&self) -> bool {
+        *self == Self::Bytes1024
+    }
+}
+
+impl From<u8> for SizeR {
+    fn from(v: u8) -> Self {
+        match v {
+            0x0 => Self::Bytes8,
+            0x1 => Self::Bytes16,
+            0x2 => Self::Bytes32,
+            0x3 => Self::Bytes64,
+            0x4 => Self::Bytes128,
+            0x5 => Self::Bytes256,
+            0x6 => Self::Bytes512,
+            0x7 => Self::Bytes1024,
+            _ => panic!("pcksize between 0 and 7 only"),
+        }
+    }
+}
+
+/// Multi Packet IN or OUT size
+///
+/// These bits define the 14-bit value that is used for multi-packet
+/// transfers.
+///
+/// For IN pipes, MULTI_PACKET_SIZE holds the total number of bytes
+/// sent. MULTI_PACKET_SIZE should be written to zero when setting up
+/// a new transfer.
+///
+/// For OUT pipes, MULTI_PACKET_SIZE holds the total data size for the
+/// complete transfer. This value must be a multiple of the maximum
+/// packet size.
+pub(crate) struct MultiPacketSizeR(u16);
+impl MultiPacketSizeR {
+    pub fn bits(&self) -> u16 {
+        self.0
+    }
+}
+
+/// Byte Count
+///
+/// These bits define the 14-bit value that contains number of bytes
+/// sent in the last OUT or SETUP transaction for an OUT pipe, or of
+/// the number of bytes to be received in the next IN transaction for
+/// an input pipe.
+pub(crate) struct ByteCountR(u8);
+impl ByteCountR {
+    pub fn bits(&self) -> u8 {
+        self.0
+    }
+}
+
+impl W {
+    /// Write raw bits.
+    pub unsafe fn bits(&mut self, v: u32) -> &mut Self {
+        self.bits = v;
+        self
+    }
+
+    pub fn auto_zlp(&mut self) -> AutoZLPW {
+        AutoZLPW { w: self }
+    }
+
+    pub fn size(&mut self) -> _SizeW {
+        _SizeW { w: self }
+    }
+
+    pub fn multi_packet_size(&mut self) -> MultiPacketSizeW {
+        MultiPacketSizeW { w: self }
+    }
+
+    pub fn byte_count(&mut self) -> ByteCountW {
+        ByteCountW { w: self }
+    }
+}
+
+pub(crate) struct AutoZLPW<'a> {
+    w: &'a mut W,
+}
+impl<'a> AutoZLPW<'a> {
+    pub fn bit(self, v: bool) -> &'a mut W {
+        const POS: u8 = 31;
+        const MASK: bool = true;
+        self.w.bits &= !((MASK as u32) << POS);
+        self.w.bits |= ((v & MASK) as u32) << POS;
+        self.w
+    }
+
+    pub fn set_bit(self) -> &'a mut W {
+        self.bit(true)
+    }
+
+    pub fn clear_bit(self) -> &'a mut W {
+        self.bit(false)
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub(crate) enum SizeW {
+    Bytes8,
+    Bytes16,
+    Bytes32,
+    Bytes64,
+    Bytes128,
+    Bytes256,
+    Bytes512,
+    Bytes1024,
+}
+impl SizeW {
+    pub fn bits(&self) -> u8 {
+        match *self {
+            Self::Bytes8 => 0,
+            Self::Bytes16 => 1,
+            Self::Bytes32 => 2,
+            Self::Bytes64 => 3,
+            Self::Bytes128 => 4,
+            Self::Bytes256 => 5,
+            Self::Bytes512 => 6,
+            Self::Bytes1024 => 7,
+        }
+    }
+}
+
+/// Proxy for `SizeW`
+pub(crate) struct _SizeW<'a> {
+    w: &'a mut W,
+}
+impl<'a> _SizeW<'a> {
+    pub unsafe fn bits(self, v: u8) -> &'a mut W {
+        const POS: u8 = 28;
+        const MASK: u8 = 0x7;
+        self.w.bits &= !((MASK as u32) << POS);
+        self.w.bits |= ((v & MASK) as u32) << POS;
+        self.w
+    }
+
+    pub fn variant(self, v: SizeW) -> &'a mut W {
+        unsafe { self.bits(v.bits()) }
+    }
+
+    pub fn bytes8(self) -> &'a mut W {
+        self.variant(SizeW::Bytes8)
+    }
+
+    pub fn bytes16(self) -> &'a mut W {
+        self.variant(SizeW::Bytes16)
+    }
+
+    pub fn bytes32(self) -> &'a mut W {
+        self.variant(SizeW::Bytes32)
+    }
+
+    pub fn bytes64(self) -> &'a mut W {
+        self.variant(SizeW::Bytes64)
+    }
+
+    pub fn bytes128(self) -> &'a mut W {
+        self.variant(SizeW::Bytes128)
+    }
+
+    pub fn bytes256(self) -> &'a mut W {
+        self.variant(SizeW::Bytes256)
+    }
+
+    pub fn bytes512(self) -> &'a mut W {
+        self.variant(SizeW::Bytes512)
+    }
+
+    pub fn bytes1024(self) -> &'a mut W {
+        self.variant(SizeW::Bytes1024)
+    }
+}
+
+pub(crate) struct MultiPacketSizeW<'a> {
+    w: &'a mut W,
+}
+impl<'a> MultiPacketSizeW<'a> {
+    pub unsafe fn bits(self, v: u16) -> &'a mut W {
+        const POS: u8 = 14;
+        const MASK: u16 = 0x3fff;
+        self.w.bits &= !((MASK as u32) << POS);
+        self.w.bits |= ((v & MASK) as u32) << POS;
+        self.w
+    }
+}
+
+pub(crate) struct ByteCountW<'a> {
+    w: &'a mut W,
+}
+impl<'a> ByteCountW<'a> {
+    pub unsafe fn bits(self, v: u8) -> &'a mut W {
+        const POS: u8 = 8;
+        const MASK: u8 = 0x3f;
+        self.w.bits &= !((MASK as u32) << POS);
+        self.w.bits |= ((v & MASK) as u32) << POS;
+        self.w
+    }
+}
diff --git a/usbh/src/pipe/status_bk.rs b/usbh/src/pipe/status_bk.rs
new file mode 100644
index 0000000..4ddb420
--- /dev/null
+++ b/usbh/src/pipe/status_bk.rs
@@ -0,0 +1,170 @@
+/// §32.8.7.5
+/// Host Status Bank.
+///
+/// Offset: 0x0a & 0x1a
+/// Reset: 0xxxxxxx
+/// Property: NA
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+pub(crate) struct StatusBk(u8);
+
+pub(crate) struct R {
+    bits: u8,
+}
+
+pub(crate) struct W {
+    bits: u8,
+}
+
+impl StatusBk {
+    pub fn read(&self) -> R {
+        R { bits: self.0 }
+    }
+
+    pub fn write<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut W) -> &mut W,
+    {
+        let mut w = W { bits: self.0 };
+        f(&mut w);
+        self.0 = w.bits;
+    }
+}
+
+impl From<u8> for StatusBk {
+    fn from(v: u8) -> Self {
+        Self(v)
+    }
+}
+
+impl R {
+    /// Value in raw bits.
+    pub fn bits(&self) -> u8 {
+        self.bits
+    }
+
+    pub fn errorflow(&self) -> ErrorFlowR {
+        let bits = {
+            const POS: u8 = 1;
+            const MASK: u8 = 1;
+            ((self.bits >> POS) & MASK) == 1
+        };
+
+        ErrorFlowR(bits)
+    }
+
+    pub fn crcerr(&self) -> CRCErrR {
+        let bits = {
+            const POS: u8 = 0;
+            const MASK: u8 = 1;
+            ((self.bits >> POS) & MASK) == 1
+        };
+
+        CRCErrR(bits)
+    }
+}
+
+/// Error Flow Status
+///
+/// This bit defines the Error Flow Status.
+///
+/// This bit is set when a Error Flow has been detected during
+/// transfer from/towards this bank.
+///
+/// For IN transfer, a NAK handshake has been received. For OUT
+/// transfer, a NAK handshake has been received. For Isochronous IN
+/// transfer, an overrun condition has occurred. For Isochronous OUT
+/// transfer, an underflow condition has occurred.
+pub(crate) struct ErrorFlowR(bool);
+impl ErrorFlowR {
+    pub fn bit(&self) -> bool {
+        self.0
+    }
+
+    pub fn bit_is_set(&self) -> bool {
+        self.bit()
+    }
+
+    pub fn bit_is_clear(&self) -> bool {
+        !self.bit_is_set()
+    }
+}
+
+/// CRC Error
+///
+/// This bit defines the CRC Error Status.
+///
+/// This bit is set when a CRC error has been detected in an
+/// isochronous IN endpoint bank.
+pub(crate) struct CRCErrR(bool);
+impl CRCErrR {
+    pub fn bit(&self) -> bool {
+        self.0
+    }
+
+    pub fn bit_is_set(&self) -> bool {
+        self.bit()
+    }
+
+    pub fn bit_is_clear(&self) -> bool {
+        !self.bit_is_set()
+    }
+}
+
+impl W {
+    /// Write raw bits.
+    pub unsafe fn bits(&mut self, v: u8) -> &mut Self {
+        self.bits = v;
+        self
+    }
+
+    pub fn errorflow(&mut self) -> ErrorFlowW {
+        ErrorFlowW { w: self }
+    }
+
+    pub fn crcerr(&mut self) -> CRCErrW {
+        CRCErrW { w: self }
+    }
+}
+
+pub(crate) struct ErrorFlowW<'a> {
+    w: &'a mut W,
+}
+impl<'a> ErrorFlowW<'a> {
+    pub fn bit(self, v: bool) -> &'a mut W {
+        const POS: u8 = 1;
+        const MASK: bool = true;
+        self.w.bits &= !((MASK as u8) << POS);
+        self.w.bits |= ((v & MASK) as u8) << POS;
+        self.w
+    }
+
+    pub fn set_bit(self) -> &'a mut W {
+        self.bit(true)
+    }
+
+    pub fn clear_bit(self) -> &'a mut W {
+        self.bit(false)
+    }
+}
+
+pub(crate) struct CRCErrW<'a> {
+    w: &'a mut W,
+}
+impl<'a> CRCErrW<'a> {
+    pub fn bit(self, v: bool) -> &'a mut W {
+        const POS: u8 = 0;
+        const MASK: bool = true;
+        self.w.bits &= !((MASK as u8) << POS);
+        self.w.bits |= ((v & MASK) as u8) << POS;
+        self.w
+    }
+
+    pub fn set_bit(self) -> &'a mut W {
+        self.bit(true)
+    }
+
+    pub fn clear_bit(self) -> &'a mut W {
+        self.bit(false)
+    }
+}
diff --git a/usbh/src/pipe/status_pipe.rs b/usbh/src/pipe/status_pipe.rs
new file mode 100644
index 0000000..4f8eb41
--- /dev/null
+++ b/usbh/src/pipe/status_pipe.rs
@@ -0,0 +1,407 @@
+/// Host Status Pipe.
+///
+/// Offset: 0x0e & 0x1e
+/// Reset: 0xxxxxx
+/// Property: PAC Write-Protection, Write-Synchronized, Read-Synchronized
+#[derive(Clone, Copy, Debug)]
+#[repr(C)]
+pub(crate) struct StatusPipe(u16);
+
+pub(crate) struct R {
+    bits: u16,
+}
+pub(crate) struct W {
+    bits: u16,
+}
+
+impl StatusPipe {
+    pub fn read(&self) -> R {
+        R { bits: self.0 }
+    }
+
+    pub fn write<F>(&mut self, f: F)
+    where
+        F: FnOnce(&mut W) -> &mut W,
+    {
+        let mut w = W { bits: self.0 };
+        f(&mut w);
+        self.0 = w.bits;
+    }
+}
+
+impl From<u16> for StatusPipe {
+    fn from(v: u16) -> Self {
+        Self(v)
+    }
+}
+
+impl R {
+    /// Value in raw bits.
+    pub fn bits(&self) -> u16 {
+        self.bits
+    }
+
+    pub fn ercnt(&self) -> ErCntR {
+        let bits = {
+            const POS: u8 = 5;
+            const MASK: u16 = 0x7;
+            ((self.bits >> POS) & MASK) as u8
+        };
+
+        ErCntR(bits)
+    }
+
+    pub fn crc16er(&self) -> CRC16ErR {
+        let bits = {
+            const POS: u8 = 4;
+            const MASK: u16 = 1;
+            ((self.bits >> POS) & MASK) == 1
+        };
+
+        CRC16ErR(bits)
+    }
+
+    pub fn touter(&self) -> TOutErrR {
+        let bits = {
+            const POS: u8 = 3;
+            const MASK: u16 = 1;
+
+            ((self.bits >> POS) & MASK) == 1
+        };
+
+        TOutErrR(bits)
+    }
+
+    pub fn pider(&self) -> PIDErR {
+        let bits = {
+            const POS: u8 = 2;
+            const MASK: u16 = 1;
+
+            ((self.bits >> POS) & MASK) == 1
+        };
+
+        PIDErR(bits)
+    }
+
+    pub fn dapider(&self) -> DaPIDErR {
+        let bits = {
+            const POS: u8 = 1;
+            const MASK: u16 = 1;
+
+            ((self.bits >> POS) & MASK) == 1
+        };
+
+        DaPIDErR(bits)
+    }
+
+    pub fn dtgler(&self) -> DTglErR {
+        let bits = {
+            const POS: u8 = 0;
+            const MASK: u16 = 1;
+
+            ((self.bits >> POS) & MASK) == 1
+        };
+
+        DTglErR(bits)
+    }
+}
+
+/// Pipe Error Counter
+///
+/// The number of errors detected on the pipe.
+pub(crate) struct ErCntR(u8);
+impl ErCntR {
+    pub fn bits(&self) -> u8 {
+        self.0
+    }
+}
+
+/// CRC16 ERROR
+///
+/// This bit defines the CRC16 Error Status.
+///
+/// This bit is set when a CRC 16 error has been detected during a IN
+/// transactions.
+pub(crate) struct CRC16ErR(bool);
+impl CRC16ErR {
+    pub fn bit(&self) -> bool {
+        self.0
+    }
+
+    pub fn bit_is_set(&self) -> bool {
+        self.bit()
+    }
+
+    pub fn bit_is_clear(&self) -> bool {
+        !self.bit_is_set()
+    }
+}
+
+/// TIME OUT ERROR
+///
+/// This bit defines the Time Out Error Status.
+///
+/// This bit is set when a Time Out error has been detected during a
+/// USB transaction.
+pub(crate) struct TOutErrR(bool);
+impl TOutErrR {
+    pub fn bit(&self) -> bool {
+        self.0
+    }
+
+    pub fn bit_is_set(&self) -> bool {
+        self.bit()
+    }
+
+    pub fn bit_is_clear(&self) -> bool {
+        !self.bit_is_set()
+    }
+}
+
+/// PID ERROR
+///
+/// This bit defines the PID Error Status.
+///
+/// This bit is set when a PID error has been detected during a USB
+/// transaction.
+pub(crate) struct PIDErR(bool);
+impl PIDErR {
+    pub fn bit(&self) -> bool {
+        self.0
+    }
+
+    pub fn bit_is_set(&self) -> bool {
+        self.bit()
+    }
+
+    pub fn bit_is_clear(&self) -> bool {
+        !self.bit_is_set()
+    }
+}
+
+/// Data PID ERROR
+///
+/// This bit defines the PID Error Status.
+///
+/// This bit is set when a Data PID error has been detected during a
+/// USB transaction.
+pub(crate) struct DaPIDErR(bool);
+impl DaPIDErR {
+    pub fn bit(&self) -> bool {
+        self.0
+    }
+
+    pub fn bit_is_set(&self) -> bool {
+        self.bit()
+    }
+
+    pub fn bit_is_clear(&self) -> bool {
+        !self.bit_is_set()
+    }
+}
+
+/// Data Toggle Error
+///
+/// This bit defines the Data Toggle Error Status.
+///
+/// This bit is set when a Data Toggle Error has been detected.
+pub(crate) struct DTglErR(bool);
+impl DTglErR {
+    pub fn bit(&self) -> bool {
+        self.0
+    }
+
+    pub fn bit_is_set(&self) -> bool {
+        self.bit()
+    }
+
+    pub fn bit_is_clear(&self) -> bool {
+        !self.bit_is_set()
+    }
+}
+
+impl W {
+    /// Write raw bits.
+    pub unsafe fn bits(&mut self, v: u16) -> &mut Self {
+        self.bits = v;
+        self
+    }
+
+    pub fn ercnt(&mut self) -> ErCntW {
+        ErCntW { w: self }
+    }
+
+    pub fn crc16er(&mut self) -> CRC16ErW {
+        CRC16ErW { w: self }
+    }
+
+    pub fn touter(&mut self) -> TOutErW {
+        TOutErW { w: self }
+    }
+
+    pub fn pider(&mut self) -> PIDErW {
+        PIDErW { w: self }
+    }
+
+    pub fn dapider(&mut self) -> DaPIDErW {
+        DaPIDErW { w: self }
+    }
+
+    pub fn dtgler(&mut self) -> DTglErW {
+        DTglErW { w: self }
+    }
+}
+
+/// Pipe Error Counter
+///
+/// The number of errors detected on the pipe.
+pub(crate) struct ErCntW<'a> {
+    w: &'a mut W,
+}
+impl<'a> ErCntW<'a> {
+    pub unsafe fn bits(self, v: u8) -> &'a mut W {
+        const POS: u8 = 5;
+        const MASK: u8 = 0x7;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+
+    pub fn set_count(self, v: u8) -> &'a mut W {
+        unsafe { self.bits(v) }
+    }
+}
+
+/// CRC16 ERROR
+///
+/// This bit defines the CRC16 Error Status.
+///
+/// This bit is set when a CRC 16 error has been detected during a IN
+/// transactions.
+pub(crate) struct CRC16ErW<'a> {
+    w: &'a mut W,
+}
+impl<'a> CRC16ErW<'a> {
+    pub fn bit(self, v: bool) -> &'a mut W {
+        const POS: u8 = 4;
+        const MASK: bool = true;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+
+    pub fn set_bit(self) -> &'a mut W {
+        self.bit(true)
+    }
+
+    pub fn clear_bit(self) -> &'a mut W {
+        self.bit(false)
+    }
+}
+
+/// TIME OUT ERROR
+///
+/// This bit defines the Time Out Error Status.
+///
+/// This bit is set when a Time Out error has been detected during a
+/// USB transaction.
+pub(crate) struct TOutErW<'a> {
+    w: &'a mut W,
+}
+impl<'a> TOutErW<'a> {
+    pub fn bit(self, v: bool) -> &'a mut W {
+        const POS: u8 = 3;
+        const MASK: bool = true;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+
+    pub fn set_bit(self) -> &'a mut W {
+        self.bit(true)
+    }
+
+    pub fn clear_bit(self) -> &'a mut W {
+        self.bit(false)
+    }
+}
+
+/// PID ERROR
+///
+/// This bit defines the PID Error Status.
+///
+/// This bit is set when a PID error has been detected during a USB
+/// transaction.
+pub(crate) struct PIDErW<'a> {
+    w: &'a mut W,
+}
+impl<'a> PIDErW<'a> {
+    pub fn bit(self, v: bool) -> &'a mut W {
+        const POS: u8 = 2;
+        const MASK: bool = true;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+
+    pub fn set_bit(self) -> &'a mut W {
+        self.bit(true)
+    }
+
+    pub fn clear_bit(self) -> &'a mut W {
+        self.bit(false)
+    }
+}
+
+/// Data PID ERROR
+///
+/// This bit defines the PID Error Status.
+///
+/// This bit is set when a Data PID error has been detected during a
+/// USB transaction.
+pub(crate) struct DaPIDErW<'a> {
+    w: &'a mut W,
+}
+impl<'a> DaPIDErW<'a> {
+    pub fn bit(self, v: bool) -> &'a mut W {
+        const POS: u8 = 1;
+        const MASK: bool = true;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+
+    pub fn set_bit(self) -> &'a mut W {
+        self.bit(true)
+    }
+
+    pub fn clear_bit(self) -> &'a mut W {
+        self.bit(false)
+    }
+}
+
+/// Data Toggle Error
+///
+/// This bit defines the Data Toggle Error Status.
+///
+/// This bit is set when a Data Toggle Error has been detected.
+pub(crate) struct DTglErW<'a> {
+    w: &'a mut W,
+}
+impl<'a> DTglErW<'a> {
+    pub fn bit(self, v: bool) -> &'a mut W {
+        const POS: u8 = 0;
+        const MASK: bool = true;
+        self.w.bits &= !((MASK as u16) << POS);
+        self.w.bits |= ((v & MASK) as u16) << POS;
+        self.w
+    }
+
+    pub fn set_bit(self) -> &'a mut W {
+        self.bit(true)
+    }
+
+    pub fn clear_bit(self) -> &'a mut W {
+        self.bit(false)
+    }
+}