fixing components

Author: frihetselsker

boards/components/src/adc.rs

@@ -6,7 +6,9 @@
 
 use capsules_core::adc::AdcDedicated;
 use capsules_core::adc::AdcVirtualized;
+use capsules_core::virtualizers::selection_policy::SelectionPolicy;
 use capsules_core::virtualizers::virtual_adc::{AdcDevice, MuxAdc};
+use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 use kernel::capabilities;
 use kernel::component::Component;
@@ -57,19 +59,32 @@ macro_rules! adc_dedicated_component_static {
     };};
 }
 
-pub struct AdcMuxComponent<A: 'static + adc::Adc<'static>> {
+pub struct AdcMuxComponent<
+    A: 'static + adc::Adc<'static>,
+    P: 'static + SelectionPolicy<&'static AdcDevice<'static, A, P>>,
+> {
     adc: &'static A,
+    phantom: PhantomData<P>,
 }
 
-impl<A: 'static + adc::Adc<'static>> AdcMuxComponent<A> {
+impl<
+        A: 'static + adc::Adc<'static>,
+        P: 'static + SelectionPolicy<&'static AdcDevice<'static, A, P>>,
+    > AdcMuxComponent<A, P>
+{
     pub fn new(adc: &'static A) -> Self {
-        AdcMuxComponent { adc }
+        AdcMuxComponent {
+            adc,
+            phantom: PhantomData,
+        }
     }
 }
 
-impl<A: 'static + adc::Adc<'static>> Component for AdcMuxComponent<A> {
-    type StaticInput = &'static mut MaybeUninit<MuxAdc<'static, A>>;
-    type Output = &'static MuxAdc<'static, A>;
+impl<A: 'static + adc::Adc<'static>, P: SelectionPolicy<&'static AdcDevice<'static, A, P>>>
+    Component for AdcMuxComponent<A, P>
+{
+    type StaticInput = &'static mut MaybeUninit<MuxAdc<'static, A, P>>;
+    type Output = &'static MuxAdc<'static, A, P>;
 
     fn finalize(self, static_buffer: Self::StaticInput) -> Self::Output {
         let adc_mux = static_buffer.write(MuxAdc::new(self.adc));
@@ -80,23 +95,32 @@ impl<A: 'static + adc::Adc<'static>> Component for AdcMuxComponent<A> {
     }
 }
 
-pub struct AdcComponent<A: 'static + adc::Adc<'static>> {
-    adc_mux: &'static MuxAdc<'static, A>,
+pub struct AdcComponent<
+    A: 'static + adc::Adc<'static>,
+    P: 'static + SelectionPolicy<&'static AdcDevice<'static, A, P>>,
+> {
+    adc_mux: &'static MuxAdc<'static, A, P>,
     channel: A::Channel,
 }
 
-impl<A: 'static + adc::Adc<'static>> AdcComponent<A> {
-    pub fn new(mux: &'static MuxAdc<'static, A>, channel: A::Channel) -> Self {
+impl<
+        A: 'static + adc::Adc<'static>,
+        P: 'static + SelectionPolicy<&'static AdcDevice<'static, A, P>>,
+    > AdcComponent<A, P>
+{
+    pub fn new(mux: &'static MuxAdc<'static, A, P>, channel: A::Channel) -> Self {
         AdcComponent {
             adc_mux: mux,
             channel,
         }
     }
 }
 
-impl<A: 'static + adc::Adc<'static>> Component for AdcComponent<A> {
-    type StaticInput = &'static mut MaybeUninit<AdcDevice<'static, A>>;
-    type Output = &'static AdcDevice<'static, A>;
+impl<A: 'static + adc::Adc<'static>, P: SelectionPolicy<&'static AdcDevice<'static, A, P>>>
+    Component for AdcComponent<A, P>
+{
+    type StaticInput = &'static mut MaybeUninit<AdcDevice<'static, A, P>>;
+    type Output = &'static AdcDevice<'static, A, P>;
 
     fn finalize(self, static_buffer: Self::StaticInput) -> Self::Output {
         let adc_device = static_buffer.write(AdcDevice::new(self.adc_mux, self.channel));

boards/components/src/bus.rs

@@ -24,6 +24,7 @@
 //! );
 //! ```
 
+use capsules_core::virtualizers::selection_policy::SelectionPolicy;
 use capsules_core::virtualizers::virtual_i2c::{I2CDevice, MuxI2C};
 use capsules_core::virtualizers::virtual_spi::MuxSpiMaster;
 use capsules_core::virtualizers::virtual_spi::VirtualSpiMasterDevice;
@@ -72,6 +73,18 @@ macro_rules! i2c_master_bus_component_static {
             >
         );
 
+        (bus, i2c_device, address_buffer)
+    };};
+    ($D:ty, $P:ty $(,)?) => {{
+        let address_buffer = kernel::static_buf!([u8; 1]);
+        let bus = kernel::static_buf!(capsules_extra::bus::I2CMasterBus<'static, $D, $P>);
+        let i2c_device = kernel::static_buf!(
+            capsules_core::virtualizers::virtual_i2c::I2CDevice<
+                'static,
+                capsules_extra::bus::I2CMasterBus<'static, $D, $P>,
+            >
+        );
+
         (bus, i2c_device, address_buffer)
     };};
 }
@@ -98,22 +111,29 @@ impl<B: 'static + bus8080::Bus8080<'static>> Component for Bus8080BusComponent<B
     }
 }
 
-pub struct SpiMasterBusComponent<S: 'static + spi::SpiMaster<'static>> {
-    spi_mux: &'static MuxSpiMaster<'static, S>,
+pub struct SpiMasterBusComponent<
+    S: 'static + spi::SpiMaster<'static>,
+    P: 'static + SelectionPolicy<&'static VirtualSpiMasterDevice<'static, S, P>>,
+> {
+    spi_mux: &'static MuxSpiMaster<'static, S, P>,
     chip_select: S::ChipSelect,
     baud_rate: u32,
     clock_phase: ClockPhase,
     clock_polarity: ClockPolarity,
 }
 
-impl<S: 'static + spi::SpiMaster<'static>> SpiMasterBusComponent<S> {
+impl<
+        S: 'static + spi::SpiMaster<'static>,
+        P: 'static + SelectionPolicy<&'static VirtualSpiMasterDevice<'static, S, P>>,
+    > SpiMasterBusComponent<S, P>
+{
     pub fn new(
-        spi_mux: &'static MuxSpiMaster<'static, S>,
+        spi_mux: &'static MuxSpiMaster<'static, S, P>,
         chip_select: S::ChipSelect,
         baud_rate: u32,
         clock_phase: ClockPhase,
         clock_polarity: ClockPolarity,
-    ) -> SpiMasterBusComponent<S> {
+    ) -> SpiMasterBusComponent<S, P> {
         SpiMasterBusComponent {
             spi_mux,
             chip_select,
@@ -124,13 +144,17 @@ impl<S: 'static + spi::SpiMaster<'static>> SpiMasterBusComponent<S> {
     }
 }
 
-impl<S: 'static + spi::SpiMaster<'static>> Component for SpiMasterBusComponent<S> {
+impl<
+        S: 'static + spi::SpiMaster<'static>,
+        P: 'static + SelectionPolicy<&'static VirtualSpiMasterDevice<'static, S, P>>,
+    > Component for SpiMasterBusComponent<S, P>
+{
     type StaticInput = (
-        &'static mut MaybeUninit<VirtualSpiMasterDevice<'static, S>>,
-        &'static mut MaybeUninit<SpiMasterBus<'static, VirtualSpiMasterDevice<'static, S>>>,
+        &'static mut MaybeUninit<VirtualSpiMasterDevice<'static, S, P>>,
+        &'static mut MaybeUninit<SpiMasterBus<'static, VirtualSpiMasterDevice<'static, S, P>>>,
         &'static mut MaybeUninit<[u8; core::mem::size_of::<usize>()]>,
     );
-    type Output = &'static SpiMasterBus<'static, VirtualSpiMasterDevice<'static, S>>;
+    type Output = &'static SpiMasterBus<'static, VirtualSpiMasterDevice<'static, S, P>>;
 
     fn finalize(self, static_buffer: Self::StaticInput) -> Self::Output {
         let spi_device = static_buffer

capsules/core/src/virtualizers/virtual_adc.rs

@@ -54,6 +54,15 @@ impl<'a, A: hil::adc::Adc<'a>, P: SelectionPolicy<&'a AdcDevice<'a, A, P>>> MuxA
         }
     }
 
+    pub fn new_with_policy(adc: &'a A, selection_policy: P) -> MuxAdc<'a, A, P> {
+        MuxAdc {
+            adc,
+            devices: List::new(),
+            inflight: OptionalCell::empty(),
+            selection_policy,
+        }
+    }
+
     fn do_next_op(&self) {
         if self.inflight.is_none() {
             let mnode = self

capsules/core/src/virtualizers/virtual_aes_ccm.rs

@@ -167,6 +167,18 @@ impl<
         }
     }
 
+    pub fn new_with_policy(aes: &'a A, selection_policy: P) -> MuxAES128CCM<'a, A, P> {
+        aes.enable(); // enable the hardware, in case it's forgotten elsewhere
+        MuxAES128CCM {
+            aes,
+            client: OptionalCell::empty(),
+            ccm_clients: List::new(),
+            inflight: OptionalCell::empty(),
+            deferred_call: DeferredCall::new(),
+            selection_policy,
+        }
+    }
+
     /// Asynchronously executes the next operation, if any. Used by calls
     /// to trigger do_next_op such that it will execute after the call
     /// returns.

capsules/core/src/virtualizers/virtual_flash.rs

@@ -101,6 +101,15 @@ impl<'a, F: hil::flash::Flash, P: SelectionPolicy<&'a FlashUser<'a, F, P>>> MuxF
         }
     }
 
+    pub fn new_with_policy(flash: &'a F, selection_policy: P) -> MuxFlash<'a, F, P> {
+        MuxFlash {
+            flash,
+            users: List::new(),
+            inflight: OptionalCell::empty(),
+            selection_policy,
+        }
+    }
+
     /// Scan the list of users and find the first user that has a pending
     /// request, then issue that request to the flash hardware.
     fn do_next_op(&self) {

capsules/core/src/virtualizers/virtual_i2c.rs

@@ -83,6 +83,26 @@ impl<
         }
     }
 
+    pub fn new_with_policy(
+        i2c: &'a I,
+        smbus: Option<&'a S>,
+        i2c_selection_policy: PI,
+        smbus_selection_policy: PS,
+    ) -> MuxI2C<'a, I, S, PI, PS> {
+        MuxI2C {
+            i2c,
+            smbus,
+            i2c_devices: List::new(),
+            smbus_devices: List::new(),
+            enabled: Cell::new(0),
+            i2c_inflight: OptionalCell::empty(),
+            smbus_inflight: OptionalCell::empty(),
+            deferred_call: DeferredCall::new(),
+            i2c_selection_policy,
+            smbus_selection_policy,
+        }
+    }
+
     fn enable(&self) {
         let enabled = self.enabled.get();
         self.enabled.set(enabled + 1);

capsules/core/src/virtualizers/virtual_pwm.rs

@@ -50,6 +50,15 @@ impl<'a, P: hil::pwm::Pwm, SP: SelectionPolicy<&'a PwmPinUser<'a, P, SP>>> MuxPw
         }
     }
 
+    pub fn new_with_policy(pwm: &'a P, selection_policy: SP) -> MuxPwm<'a, P, SP> {
+        MuxPwm {
+            pwm,
+            devices: List::new(),
+            inflight: OptionalCell::empty(),
+            selection_policy,
+        }
+    }
+
     /// If we are not currently doing anything, scan the list of devices for
     /// one with an outstanding operation and run that.
     fn do_next_op(&self) {

capsules/core/src/virtualizers/virtual_rng.rs

@@ -40,6 +40,15 @@ impl<'a, P: SelectionPolicy<&'a VirtualRngMasterDevice<'a, P>>> MuxRngMaster<'a,
         }
     }
 
+    pub fn new_with_policy(rng: &'a dyn Rng<'a>, selection_policy: P) -> MuxRngMaster<'a, P> {
+        MuxRngMaster {
+            rng,
+            devices: List::new(),
+            inflight: OptionalCell::empty(),
+            selection_policy,
+        }
+    }
+
     fn do_next_op(&self) -> Result<(), ErrorCode> {
         if self.inflight.is_none() {
             let mnode = self

capsules/core/src/virtualizers/virtual_spi.rs

@@ -68,6 +68,15 @@ impl<
             deferred_call: DeferredCall::new(),
         }
     }
+    pub fn new_with_policy(spi: &'a Spi, selection_policy: P) -> MuxSpiMaster<'a, Spi, P> {
+        MuxSpiMaster {
+            spi,
+            devices: List::new(),
+            inflight: OptionalCell::empty(),
+            selection_policy,
+            deferred_call: DeferredCall::new(),
+        }
+    }
 
     fn do_next_op(&self) {
         if self.inflight.is_none() {