fix: clippy warnings (#130)

Author: toku-sa-n

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 ### Fixed
 - Outdated code example in `README.md` is fixed.
+- Removed all the use of deprecated code.
 
 ## 0.8.2 - 2021-05-13
 ### Removed

src/context/mod.rs

@@ -233,7 +233,7 @@ pub trait InputControlHandler: AsRef<[u32]> + AsMut<[u32]> {
         assert!(
             i <= 31,
             "The index of Add Context flag must be less than 32."
-        )
+        );
     }
 }
 

src/extended_capabilities/debug.rs

@@ -1,8 +1,8 @@
 //! Debug Capability.
 
 use super::ExtendedCapability;
+use accessor::single;
 use accessor::Mapper;
-use accessor::Single;
 use bit_field::BitField;
 use core::convert::TryInto;
 
@@ -13,27 +13,27 @@ where
     M: Mapper + Clone,
 {
     /// Capability ID.
-    pub dcid: Single<Id, M>,
+    pub dcid: single::ReadWrite<Id, M>,
     /// Doorbell.
-    pub dcdb: Single<Doorbell, M>,
+    pub dcdb: single::ReadWrite<Doorbell, M>,
     /// Event Ring Segment Table Size.
-    pub dcerstsz: Single<EventRingSegmentTableSize, M>,
+    pub dcerstsz: single::ReadWrite<EventRingSegmentTableSize, M>,
     /// Event Ring Segment Table Base Address.
-    pub dcerstba: Single<EventRingSegmentTableBaseAddress, M>,
+    pub dcerstba: single::ReadWrite<EventRingSegmentTableBaseAddress, M>,
     /// Event Ring Dequeue Pointer.
-    pub dcerdp: Single<EventRingDequeuePointer, M>,
+    pub dcerdp: single::ReadWrite<EventRingDequeuePointer, M>,
     /// Control.
-    pub dcctrl: Single<Control, M>,
+    pub dcctrl: single::ReadWrite<Control, M>,
     /// Status.
-    pub dcst: Single<Status, M>,
+    pub dcst: single::ReadWrite<Status, M>,
     /// Port Status and Control.
-    pub dcportsc: Single<PortStatusAndControl, M>,
+    pub dcportsc: single::ReadWrite<PortStatusAndControl, M>,
     /// Debug Capability Context Pointer.
-    pub dccp: Single<ContextPointer, M>,
+    pub dccp: single::ReadWrite<ContextPointer, M>,
     /// Device Descriptor Info Register 1.
-    pub dcddi1: Single<DeviceDescriptorInfo1, M>,
+    pub dcddi1: single::ReadWrite<DeviceDescriptorInfo1, M>,
     /// Device Descriptor Info Register 2.
-    pub dcddi2: Single<DeviceDescriptorInfo2, M>,
+    pub dcddi2: single::ReadWrite<DeviceDescriptorInfo2, M>,
 }
 impl<M> Debug<M>
 where
@@ -52,7 +52,7 @@ where
     pub unsafe fn new(base: usize, mapper: &M) -> Self {
         macro_rules! m {
             ($offset:expr) => {
-                Single::new(base + $offset, mapper.clone())
+                single::ReadWrite::new(base + $offset, mapper.clone())
             };
         }
 

src/extended_capabilities/hci_extended_power_management.rs

@@ -1,8 +1,7 @@
 //! HCI Extended Power Management Capability.
 
 use super::ExtendedCapability;
-use accessor::Mapper;
-use accessor::Single;
+use accessor::{single, Mapper};
 
 /// HCI Extended Power Management Capability.
 #[derive(Copy, Clone, Debug)]
@@ -19,11 +18,11 @@ pub struct HciExtendedPowerManagement {
     /// Data.
     pub data: Data,
 }
-impl<M> From<Single<HciExtendedPowerManagement, M>> for ExtendedCapability<M>
+impl<M> From<single::ReadWrite<HciExtendedPowerManagement, M>> for ExtendedCapability<M>
 where
     M: Mapper + Clone,
 {
-    fn from(h: Single<HciExtendedPowerManagement, M>) -> Self {
+    fn from(h: single::ReadWrite<HciExtendedPowerManagement, M>) -> Self {
         ExtendedCapability::HciExtendedPowerManagementCapability(h)
     }
 }

src/extended_capabilities/mod.rs

@@ -53,8 +53,8 @@
 //! ```
 
 use super::registers::capability::CapabilityParameters1;
+use accessor::single;
 use accessor::Mapper;
-use accessor::Single;
 use bit_field::BitField;
 use core::convert::TryInto;
 use debug::Debug;
@@ -185,7 +185,7 @@ where
         let current = self.current?;
 
         // SAFETY: `Iter::new` guarantees that `self.current` is the correct address.
-        let h: Header = unsafe { accessor::Single::new(current, self.m.clone()) }.read();
+        let h: Header = unsafe { single::ReadWrite::new(current, self.m.clone()) }.read_volatile();
 
         self.current = if h.next() == 0 {
             None
@@ -217,15 +217,15 @@ where
     /// xHCI Supported Protocol Capability.
     XhciSupportedProtocol(XhciSupportedProtocol<M>),
     /// HCI Extended Power Management Capability.
-    HciExtendedPowerManagementCapability(Single<HciExtendedPowerManagement, M>),
+    HciExtendedPowerManagementCapability(single::ReadWrite<HciExtendedPowerManagement, M>),
     /// xHCI Message Interrupt Capability.
     XhciMessageInterrupt(XhciMessageInterrupt<M>),
     /// xHCI Local Memory Capability.
     XhciLocalMemory(XhciLocalMemory<M>),
     /// Debug Capability.
     Debug(Debug<M>),
     /// xHCI Extended Message Interrupt.
-    XhciExtendedMessageInterrupt(Single<XhciExtendedMessageInterrupt, M>),
+    XhciExtendedMessageInterrupt(single::ReadWrite<XhciExtendedMessageInterrupt, M>),
 }
 impl<M> ExtendedCapability<M>
 where
@@ -242,13 +242,13 @@ where
             Ty::UsbLegacySupport => UsbLegacySupport::new(base, m).into(),
             Ty::SupportedProtocol => XhciSupportedProtocol::new(base, m).into(),
             Ty::ExtendedPowerManagement => {
-                Single::<HciExtendedPowerManagement, M>::new(base, m).into()
+                single::ReadWrite::<HciExtendedPowerManagement, M>::new(base, m).into()
             }
             Ty::MessageInterrupt => XhciMessageInterrupt::new(base, m).into(),
             Ty::LocalMemory => XhciLocalMemory::new(base, m)?.into(),
             Ty::UsbDebugCapability => Debug::new(base, &m).into(),
             Ty::ExtendedMessageInterrupt => {
-                Single::<XhciExtendedMessageInterrupt, M>::new(base, m).into()
+                single::ReadWrite::<XhciExtendedMessageInterrupt, M>::new(base, m).into()
             }
         };
 

src/extended_capabilities/usb_legacy_support_capability.rs

@@ -1,8 +1,7 @@
 //! USB Legacy Support Capability
 
 use super::ExtendedCapability;
-use accessor::Mapper;
-use accessor::Single;
+use accessor::{single, Mapper};
 
 /// USB Legacy Support Capability.
 #[derive(Debug)]
@@ -11,9 +10,9 @@ where
     M: Mapper + Clone,
 {
     /// The first 4 byte of USB Legacy Support Capability.
-    pub usblegsup: Single<LegSup, M>,
+    pub usblegsup: single::ReadWrite<LegSup, M>,
     /// USB Legacy Support Control/Status.
-    pub usblegctlsts: Single<UsbLegacySupportControlStatus, M>,
+    pub usblegctlsts: single::ReadWrite<UsbLegacySupportControlStatus, M>,
 }
 impl<M> UsbLegacySupport<M>
 where
@@ -31,8 +30,8 @@ where
     ///
     /// This method panics if `base` is not aligned correctly.
     pub unsafe fn new(base: usize, m: M) -> Self {
-        let usblegsup = Single::new(base, m.clone());
-        let usblegctlsts = Single::new(base, m);
+        let usblegsup = single::ReadWrite::new(base, m.clone());
+        let usblegctlsts = single::ReadWrite::new(base, m);
 
         Self {
             usblegsup,

src/extended_capabilities/xhci_extended_message_interrupt.rs

@@ -1,8 +1,8 @@
 //! xHCI Extended Message Interrupt Capability.
 
 use super::ExtendedCapability;
+use accessor::single;
 use accessor::Mapper;
-use accessor::Single;
 use bit_field::BitField;
 use core::convert::TryInto;
 
@@ -19,11 +19,11 @@ pub struct XhciExtendedMessageInterrupt {
     /// Table Offset and BIR.
     pub table_offset: TableOffset,
 }
-impl<M> From<Single<XhciExtendedMessageInterrupt, M>> for ExtendedCapability<M>
+impl<M> From<single::ReadWrite<XhciExtendedMessageInterrupt, M>> for ExtendedCapability<M>
 where
     M: Mapper + Clone,
 {
-    fn from(x: Single<XhciExtendedMessageInterrupt, M>) -> Self {
+    fn from(x: single::ReadWrite<XhciExtendedMessageInterrupt, M>) -> Self {
         ExtendedCapability::XhciExtendedMessageInterrupt(x)
     }
 }

src/extended_capabilities/xhci_local_memory.rs

@@ -1,9 +1,7 @@
 //! xHCI Local Memory Capability.
 
 use super::ExtendedCapability;
-use accessor::Array;
-use accessor::Mapper;
-use accessor::Single;
+use accessor::{array, single, Mapper};
 use bit_field::BitField;
 use core::convert::TryInto;
 
@@ -14,9 +12,9 @@ where
     M: Mapper + Clone,
 {
     /// The header of this Capability.
-    pub header: Single<Header, M>,
+    pub header: single::ReadWrite<Header, M>,
     /// The Local Memory.
-    pub memory: Array<u8, M>,
+    pub memory: array::ReadWrite<u8, M>,
 }
 impl<M> XhciLocalMemory<M>
 where
@@ -37,11 +35,11 @@ where
     ///
     /// This method panics if `base` is not aligned correctly.
     pub unsafe fn new(base: usize, mapper: M) -> Option<Self> {
-        let header: Single<Header, M> = Single::new(base, mapper.clone());
-        let size = header.read().size();
+        let header: single::ReadWrite<Header, M> = single::ReadWrite::new(base, mapper.clone());
+        let size = header.read_volatile().size();
 
         if size > 0 {
-            let memory = Array::new(base + 8, (size * 1024).try_into().unwrap(), mapper);
+            let memory = array::ReadWrite::new(base + 8, (size * 1024).try_into().unwrap(), mapper);
 
             Some(Self { header, memory })
         } else {

src/extended_capabilities/xhci_message_interrupt.rs

@@ -1,8 +1,8 @@
 //! xHCI Message Interrupt Capability.
 
 use super::ExtendedCapability;
+use accessor::single;
 use accessor::Mapper;
-use accessor::Single;
 use bit_field::BitField;
 use core::convert::TryFrom;
 use core::convert::TryInto;
@@ -14,9 +14,9 @@ where
     M: Mapper,
 {
     /// xHCI Message Interrupt Capability with the 32-bit Message Address.
-    Addr32(Single<Internal<u32>, M>),
+    Addr32(single::ReadWrite<Internal<u32>, M>),
     /// xHCI Message Interrupt Capability with the 64-bit Message Address.
-    Addr64(Single<Internal<u64>, M>),
+    Addr64(single::ReadWrite<Internal<u64>, M>),
 }
 impl<M> XhciMessageInterrupt<M>
 where
@@ -32,12 +32,13 @@ where
     ///
     /// This method panics if `base` is not aligned correctly.
     pub unsafe fn new(base: usize, mapper: M) -> Self {
-        let control: Single<MessageControl, M> = Single::new(base + 2, mapper.clone());
+        let control: single::ReadWrite<MessageControl, M> =
+            single::ReadWrite::new(base + 2, mapper.clone());
 
-        if control.read().bit64_address_capable() {
-            Self::Addr64(Single::new(base, mapper))
+        if control.read_volatile().bit64_address_capable() {
+            Self::Addr64(single::ReadWrite::new(base, mapper))
         } else {
-            Self::Addr32(Single::new(base, mapper))
+            Self::Addr32(single::ReadWrite::new(base, mapper))
         }
     }
 }

src/extended_capabilities/xhci_supported_protocol.rs

@@ -1,9 +1,7 @@
 //! xHCI Supported Protocol Capability
 
 use super::ExtendedCapability;
-use accessor::Array;
-use accessor::Mapper;
-use accessor::Single;
+use accessor::{array, single, Mapper};
 use bit_field::BitField;
 use core::convert::TryInto;
 use num_derive::FromPrimitive;
@@ -16,12 +14,12 @@ where
     M: Mapper + Clone,
 {
     /// The first 16 bytes of xHCI Supported Protocol Capability.
-    pub header: Single<Header, M>,
+    pub header: single::ReadWrite<Header, M>,
     /// Protocol Speed IDs.
     ///
     /// This field is `None` is `PSIC == 0`. Refer to 7.2.2.1.2 of the xHCI requirements
     /// specification for more information.
-    pub psis: Option<Array<ProtocolSpeedId, M>>,
+    pub psis: Option<array::ReadWrite<ProtocolSpeedId, M>>,
 }
 impl<M> XhciSupportedProtocol<M>
 where
@@ -37,10 +35,10 @@ where
     ///
     /// This method panics if `base` is not aligned correctly.
     pub unsafe fn new(base: usize, mapper: M) -> Self {
-        let header: Single<Header, M> = Single::new(base, mapper.clone());
-        let len = header.read().protocol_speed_id_count();
+        let header: single::ReadWrite<Header, M> = single::ReadWrite::new(base, mapper.clone());
+        let len = header.read_volatile().protocol_speed_id_count();
         let psis = if len > 0 {
-            Some(Array::new(base + 0x10, len.into(), mapper))
+            Some(array::ReadWrite::new(base + 0x10, len.into(), mapper))
         } else {
             None
         };