starnix_modules_android_usb/
lib.rs

1// Copyright 2026 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#![recursion_limit = "256"]
6
7use fidl_fuchsia_hardware_usb_policy::DeviceState;
8use starnix_core::task::dynamic_thread_spawner::SpawnRequestBuilder;
9use starnix_core::task::{CurrentTask, Kernel};
10use starnix_logging::log_error;
11
12use starnix_uapi::errors::Errno;
13
14use fidl_fuchsia_usb_policy::PolicyProviderMarker;
15use fuchsia_component::client::connect_to_protocol;
16use starnix_core::device::kobject::{Device, UEventAction};
17use starnix_core::device::mem::DevNull;
18use starnix_core::device::simple_device_ops;
19use starnix_core::fs::sysfs::build_device_directory;
20use starnix_core::vfs::pseudo::simple_file::{BytesFile, BytesFileOps};
21use starnix_core::vfs::{FsStr, FsString};
22use starnix_uapi::file_mode::mode;
23use std::borrow::Cow;
24
25use std::future::Future;
26use std::sync::Arc;
27use std::sync::atomic::{AtomicU8, Ordering};
28
29#[repr(u8)]
30#[derive(Copy, Clone, Debug, PartialEq, Eq)]
31pub enum UsbGadgetState {
32    Disconnected = 0,
33    Configured = 1,
34    Connected = 2,
35    Unknown = 3,
36}
37
38impl From<u8> for UsbGadgetState {
39    fn from(val: u8) -> Self {
40        match val {
41            0 => UsbGadgetState::Disconnected,
42            1 => UsbGadgetState::Configured,
43            2 => UsbGadgetState::Connected,
44            _ => UsbGadgetState::Unknown,
45        }
46    }
47}
48
49impl UsbGadgetState {
50    pub fn to_fs_str(&self) -> &'static FsStr {
51        match self {
52            UsbGadgetState::Disconnected => b"DISCONNECTED".into(),
53            UsbGadgetState::Configured => b"CONFIGURED".into(),
54            UsbGadgetState::Connected => b"CONNECTED".into(),
55            UsbGadgetState::Unknown => b"UNKNOWN".into(),
56        }
57    }
58
59    pub fn map_from_device_state(state: DeviceState, previous: Option<Self>) -> Option<Self> {
60        match state {
61            DeviceState::NotAttached => Some(UsbGadgetState::Disconnected),
62            DeviceState::Attached => Some(UsbGadgetState::Connected),
63            DeviceState::Powered => Some(UsbGadgetState::Connected),
64            DeviceState::Default => Some(UsbGadgetState::Connected),
65            DeviceState::Address => Some(UsbGadgetState::Connected),
66            DeviceState::Configured => Some(UsbGadgetState::Configured),
67            DeviceState::Suspended => previous, // No change when suspended
68            _ => {
69                log_error!("Unexpected DeviceState: {:?}", state);
70                previous
71            }
72        }
73    }
74}
75
76#[derive(Clone)]
77struct UsbStateSysfsFile {
78    state: Arc<AtomicU8>,
79}
80
81impl BytesFileOps for UsbStateSysfsFile {
82    fn read(&self, _current_task: &CurrentTask) -> Result<Cow<'_, [u8]>, Errno> {
83        let state_val = self.state.load(Ordering::Relaxed);
84        let state = UsbGadgetState::from(state_val);
85        let mut content = state.to_fs_str().to_vec();
86        content.push(b'\n'); // standard sysfs newline
87        Ok(Cow::Owned(content))
88    }
89}
90
91pub fn usb_device_init(kernel: &Arc<Kernel>) -> Result<Device, Errno> {
92    let registry = &kernel.device_registry;
93
94    let android_usb_class =
95        registry.objects.get_or_create_class("android_usb".into(), registry.objects.virtual_bus());
96
97    let shared_state = Arc::new(AtomicU8::new(UsbGadgetState::Disconnected as u8));
98    let state_clone = shared_state.clone();
99
100    let device = registry.register_dyn_device_with_dir(
101        kernel,
102        "android0".into(),
103        android_usb_class,
104        |device, dir| {
105            build_device_directory(device, dir);
106            dir.entry(
107                "state",
108                BytesFile::new_node(UsbStateSysfsFile { state: state_clone }),
109                mode!(IFREG, 0o444),
110            );
111        },
112        simple_device_ops::<DevNull>,
113    )?;
114
115    let kernel_clone = Arc::clone(kernel);
116    let device_clone = device.clone();
117    kernel.kthreads.spawn_future(
118        move || async move {
119            monitor_usb_device_state(kernel_clone, device_clone, shared_state).await;
120        },
121        "usb_device_state_monitor",
122    );
123
124    Ok(device)
125}
126
127// Prepare a request to broadcast a USB state change and dispatch it on a kernel thread.
128fn dispatch_usb_state_change(
129    kernel: &Arc<Kernel>,
130    device: &Device,
131    usb_state: FsString,
132) -> impl Future<Output = Result<(), Errno>> {
133    let spawner = kernel.kthreads.spawner();
134    let device_clone = device.clone();
135    let closure = move |current_task: &CurrentTask| {
136        if let Some(metadata) = &device_clone.metadata {
137            metadata.properties.insert("USB_STATE".into(), usb_state);
138        }
139
140        current_task.kernel.device_registry.dispatch_uevent(UEventAction::Change, device_clone);
141    };
142    let (result, request) =
143        SpawnRequestBuilder::new().with_sync_closure(closure).build_with_async_result();
144    spawner.spawn_from_request(request);
145    result
146}
147
148/// Monitor the USB state via FIDL messages from the PolicyProvider and dispatch uevents when the
149/// state changes.
150async fn monitor_usb_device_state(
151    kernel: Arc<Kernel>,
152    device: Device,
153    shared_state: Arc<AtomicU8>,
154) {
155    let provider = connect_to_protocol::<PolicyProviderMarker>()
156        .expect("USB Failed to connect to PolicyProvider");
157    let mut previous_mapped_state: Option<UsbGadgetState> = None;
158    loop {
159        match provider.watch_device_state().await {
160            Ok(Ok(update)) => {
161                let state = update.state.unwrap_or_else(DeviceState::unknown);
162
163                // Map the incoming device state onto the new UsbGadgetState.
164                let mapped = UsbGadgetState::map_from_device_state(state, previous_mapped_state);
165
166                if previous_mapped_state != mapped {
167                    if let Some(val) = mapped {
168                        previous_mapped_state = Some(val);
169                        shared_state.store(val as u8, Ordering::Relaxed);
170                        if let Err(e) =
171                            dispatch_usb_state_change(&kernel, &device, val.to_fs_str().to_owned())
172                                .await
173                        {
174                            log_error!("Failed to dispatch USB state change: {:?}", e);
175                        }
176                    }
177                }
178            }
179            Ok(Err(err)) => {
180                log_error!("USB PolicyProvider returned error: {:?}", err);
181                break;
182            }
183            Err(e) => {
184                log_error!("USB PolicyProvider watch failed: {:?}", e);
185                break;
186            }
187        }
188    }
189}
190
191#[cfg(test)]
192mod tests {
193    use super::*;
194    use starnix_core::testing::spawn_kernel_and_run;
195    use starnix_rcu::RcuReadScope;
196
197    #[::fuchsia::test]
198    async fn test_usb_gadget_state_map_from_device_state() {
199        assert_eq!(
200            UsbGadgetState::map_from_device_state(DeviceState::NotAttached, None),
201            Some(UsbGadgetState::Disconnected)
202        );
203        assert_eq!(
204            UsbGadgetState::map_from_device_state(DeviceState::Configured, None),
205            Some(UsbGadgetState::Configured)
206        );
207        assert_eq!(
208            UsbGadgetState::map_from_device_state(DeviceState::Attached, None),
209            Some(UsbGadgetState::Connected)
210        );
211        assert_eq!(
212            UsbGadgetState::map_from_device_state(DeviceState::Powered, None),
213            Some(UsbGadgetState::Connected)
214        );
215        assert_eq!(
216            UsbGadgetState::map_from_device_state(DeviceState::Default, None),
217            Some(UsbGadgetState::Connected)
218        );
219        assert_eq!(
220            UsbGadgetState::map_from_device_state(DeviceState::Address, None),
221            Some(UsbGadgetState::Connected)
222        );
223        assert_eq!(
224            UsbGadgetState::map_from_device_state(
225                DeviceState::Suspended,
226                Some(UsbGadgetState::Configured)
227            ),
228            Some(UsbGadgetState::Configured)
229        );
230        assert_eq!(UsbGadgetState::map_from_device_state(DeviceState::Suspended, None), None);
231        assert_eq!(UsbGadgetState::map_from_device_state(DeviceState::unknown(), None), None);
232        assert_eq!(
233            UsbGadgetState::map_from_device_state(
234                DeviceState::unknown(),
235                Some(UsbGadgetState::Configured)
236            ),
237            Some(UsbGadgetState::Configured)
238        );
239    }
240
241    #[::fuchsia::test]
242    async fn test_usb_sysfs_state_reads() {
243        spawn_kernel_and_run(async |current_task| {
244            let shared_state = Arc::new(AtomicU8::new(UsbGadgetState::Disconnected as u8));
245
246            shared_state.store(UsbGadgetState::Configured as u8, Ordering::Relaxed);
247
248            let sysfs_file = UsbStateSysfsFile { state: shared_state };
249            let content = sysfs_file.read(current_task).expect("read failed");
250            assert_eq!(content.as_ref(), b"CONFIGURED\n");
251        })
252        .await;
253    }
254
255    #[::fuchsia::test]
256    async fn test_usb_device_state_to_fs_str() {
257        assert_eq!(UsbGadgetState::Disconnected.to_fs_str(), b"DISCONNECTED");
258        assert_eq!(UsbGadgetState::Configured.to_fs_str(), b"CONFIGURED");
259        assert_eq!(UsbGadgetState::Connected.to_fs_str(), b"CONNECTED");
260        assert_eq!(UsbGadgetState::Unknown.to_fs_str(), b"UNKNOWN");
261    }
262
263    #[::fuchsia::test]
264    async fn test_usb_device_state_from_u8() {
265        assert_eq!(UsbGadgetState::from(0), UsbGadgetState::Disconnected);
266        assert_eq!(UsbGadgetState::from(1), UsbGadgetState::Configured);
267        assert_eq!(UsbGadgetState::from(2), UsbGadgetState::Connected);
268        assert_eq!(UsbGadgetState::from(255), UsbGadgetState::Unknown);
269    }
270
271    #[::fuchsia::test]
272    async fn test_usb_device_init_sysfs() {
273        spawn_kernel_and_run(async |current_task| {
274            let device = usb_device_init(current_task.kernel()).expect("usb_device_init failed");
275
276            assert_eq!(device.name.as_slice(), b"android0");
277            let metadata = device.metadata.as_ref().expect("metadata not found");
278            assert_eq!(metadata.devname.as_slice(), b"android0");
279        })
280        .await;
281    }
282
283    #[::fuchsia::test]
284    async fn test_usb_device_metadata_property_injection() {
285        spawn_kernel_and_run(async |current_task| {
286            let device = usb_device_init(current_task.kernel()).expect("usb_device_init failed");
287
288            let kernel = current_task.kernel();
289
290            // Send the state change and wait for the background task to execute.
291            dispatch_usb_state_change(
292                kernel,
293                &device,
294                UsbGadgetState::Connected.to_fs_str().to_owned(),
295            )
296            .await
297            .unwrap();
298
299            let metadata = device.metadata.as_ref().expect("metadata not found");
300            let scope = RcuReadScope::new();
301            let value = metadata
302                .properties
303                .get(&scope, FsStr::new(b"USB_STATE"))
304                .expect("property not found");
305            assert_eq!(value.as_slice(), b"CONNECTED");
306        })
307        .await;
308    }
309}
starnix_modules_android_usb/lib.rs

starnix_modules_android_usb/
lib.rs
