blob: 8cd98890302786d3e01b5ffe2336990a290000d9 [file]
// Copyright 2026 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#![recursion_limit = "256"]
use fidl_fuchsia_hardware_usb_policy::DeviceState;
use starnix_core::task::dynamic_thread_spawner::SpawnRequestBuilder;
use starnix_core::task::{CurrentTask, Kernel};
use starnix_logging::log_error;
use starnix_uapi::errors::Errno;
use starnix_uapi::{errno, error};
use fidl_fuchsia_usb_policy::{
ConfigurationMarker, ConfigurationSynchronousProxy, PolicyProviderMarker,
};
use fuchsia_component::client::{connect_to_protocol, connect_to_protocol_sync};
use starnix_core::device::kobject::{Device, UEventAction};
use starnix_core::device::mem::DevNull;
use starnix_core::device::simple_device_ops;
use starnix_core::fs::sysfs::build_device_directory;
use starnix_core::vfs::pseudo::simple_file::{BytesFile, BytesFileOps};
use starnix_core::vfs::{FsStr, FsString};
use starnix_sync::{AndroidUsbCcToggleEnableLock, LockDepMutex};
use starnix_uapi::file_mode::mode;
use std::borrow::Cow;
use std::future::Future;
use std::sync::Arc;
use std::sync::atomic::{AtomicU8, Ordering};
#[repr(u8)]
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum UsbGadgetState {
Disconnected = 0,
Configured = 1,
Connected = 2,
Unknown = 3,
}
impl From<u8> for UsbGadgetState {
fn from(val: u8) -> Self {
match val {
0 => UsbGadgetState::Disconnected,
1 => UsbGadgetState::Configured,
2 => UsbGadgetState::Connected,
_ => UsbGadgetState::Unknown,
}
}
}
impl UsbGadgetState {
pub fn to_fs_str(&self) -> &'static FsStr {
match self {
UsbGadgetState::Disconnected => b"DISCONNECTED".into(),
UsbGadgetState::Configured => b"CONFIGURED".into(),
UsbGadgetState::Connected => b"CONNECTED".into(),
UsbGadgetState::Unknown => b"UNKNOWN".into(),
}
}
pub fn map_from_device_state(state: DeviceState, previous: Option<Self>) -> Option<Self> {
match state {
DeviceState::NotAttached | DeviceState::Attached | DeviceState::Powered => {
Some(UsbGadgetState::Disconnected)
}
DeviceState::Default | DeviceState::Address => Some(UsbGadgetState::Connected),
DeviceState::Configured => Some(UsbGadgetState::Configured),
DeviceState::Suspended => previous, // No change when suspended
_ => {
log_error!("Unexpected DeviceState: {:?}", state);
previous
}
}
}
}
#[derive(Clone)]
struct UsbStateSysfsFile {
state: Arc<AtomicU8>,
}
impl BytesFileOps for UsbStateSysfsFile {
fn read(&self, _current_task: &CurrentTask) -> Result<Cow<'_, [u8]>, Errno> {
let state_val = self.state.load(Ordering::Relaxed);
let state = UsbGadgetState::from(state_val);
let mut content = state.to_fs_str().to_vec();
content.push(b'\n'); // standard sysfs newline
Ok(Cow::Owned(content))
}
}
struct CcToggleEnableState {
/// Last value successfully applied via `fuchsia.usb.policy.Configuration`.
enabled: bool,
/// Lazily connected `fuchsia.usb.policy.Configuration` proxy, reused across writes so all
/// requests are serialized on a single channel.
config_proxy: Option<ConfigurationSynchronousProxy>,
}
struct CcToggleEnableSysfsFile {
/// Guards both the FIDL call and the `enabled` update so concurrent writers can't apply
/// `DisconnectCable`/`ConnectCable` in one order and record `enabled` in another.
state: LockDepMutex<CcToggleEnableState, AndroidUsbCcToggleEnableLock>,
}
impl CcToggleEnableSysfsFile {
fn new() -> Self {
Self { state: CcToggleEnableState { enabled: true, config_proxy: None }.into() }
}
#[cfg(test)]
fn new_with_proxy(config_proxy: ConfigurationSynchronousProxy) -> Self {
Self {
state: CcToggleEnableState { enabled: true, config_proxy: Some(config_proxy) }.into(),
}
}
}
impl BytesFileOps for CcToggleEnableSysfsFile {
fn read(&self, _current_task: &CurrentTask) -> Result<Cow<'_, [u8]>, Errno> {
let content: &[u8] = if self.state.lock().enabled { b"1\n" } else { b"0\n" };
Ok(Cow::Borrowed(content))
}
fn write(&self, _current_task: &CurrentTask, data: Vec<u8>) -> Result<(), Errno> {
let input = std::str::from_utf8(&data).map_err(|_| errno!(EINVAL))?;
let enable = match input.trim_matches(|c: char| c.is_whitespace() || c == '\0') {
"0" => false,
"1" => true,
_ => return error!(EINVAL),
};
let mut state = self.state.lock();
if state.config_proxy.is_none() {
state.config_proxy =
Some(connect_to_protocol_sync::<ConfigurationMarker>().map_err(|e| {
log_error!("Failed to connect to fuchsia.usb.policy.Configuration: {:?}", e);
errno!(EIO)
})?);
}
let Some(proxy) = state.config_proxy.as_ref() else {
return error!(EIO);
};
let (method, result) = if enable {
("ConnectCable", proxy.connect_cable(zx::MonotonicInstant::INFINITE))
} else {
("DisconnectCable", proxy.disconnect_cable(0, zx::MonotonicInstant::INFINITE))
};
match result {
Ok(Ok(())) => {}
Ok(Err(status)) => {
log_error!("{method} returned error: {:?}", zx::Status::err_from_raw(status));
return error!(EIO);
}
Err(e) => {
log_error!("{method} FIDL error: {:?}", e);
// Drop the proxy so the next write reconnects (e.g. if usb-policy restarted).
state.config_proxy = None;
return error!(EIO);
}
}
state.enabled = enable;
Ok(())
}
}
pub fn usb_device_init(kernel: &Arc<Kernel>) -> Result<Device, Errno> {
let registry = &kernel.device_registry;
// TODO(https://fxbug.dev/452096300): Populate or remove stub udc class.
registry.objects.get_or_create_class("udc".into());
let android_usb_class = registry.objects.get_or_create_class("android_usb".into());
let shared_state = Arc::new(AtomicU8::new(UsbGadgetState::Disconnected as u8));
let state_clone = shared_state.clone();
let device = registry.add_dyn_device_with_dir(
kernel,
"android0".into(),
android_usb_class,
|device, dir| {
build_device_directory(device, dir);
dir.entry(
"state",
BytesFile::new_node(UsbStateSysfsFile { state: state_clone }),
mode!(IFREG, 0o444),
);
},
simple_device_ops::<DevNull>,
)?;
// Register `/sys/devices/platform/10d50000.hsi2c/i2c-6/i2c-max77759tcpc/cc_toggle_enable` so
// Android's `cable_breaker` tool can simulate Type-C cable disconnects and reconnects via
// `fuchsia.usb.policy.Configuration`.
// TODO(https://fxbug.dev/452096300): Drive the hardcoded `10d50000.hsi2c/i2c-6/i2c-max77759tcpc`
// topology from board configuration rather than registering it for all `android_usb`
// containers.
let platform_bus = registry.objects.platform_bus();
let i2c_bus = registry.objects.get_or_create_bus("i2c".into());
let hsi2c = registry.add_bus_device(
"10d50000.hsi2c".into(),
Some(registry.objects.platform_device()),
platform_bus,
build_device_directory,
);
let i2c_6 = registry.add_bus_device(
"i2c-6".into(),
Some(hsi2c),
i2c_bus.clone(),
build_device_directory,
);
registry.add_bus_device("i2c-max77759tcpc".into(), Some(i2c_6), i2c_bus, |device, dir| {
build_device_directory(device, dir);
dir.entry(
"cc_toggle_enable",
BytesFile::new_node(CcToggleEnableSysfsFile::new()),
mode!(IFREG, 0o644),
);
});
let kernel_clone = Arc::clone(kernel);
let device_clone = device.clone();
kernel.kthreads.spawn_future(
move || async move {
monitor_usb_device_state(kernel_clone, device_clone, shared_state).await;
},
"usb_device_state_monitor",
);
Ok(device)
}
// Prepare a request to broadcast a USB state change and dispatch it on a kernel thread.
fn dispatch_usb_state_change(
kernel: &Arc<Kernel>,
device: &Device,
usb_state: FsString,
) -> impl Future<Output = Result<(), Errno>> {
let spawner = kernel.kthreads.spawner();
let device_clone = device.clone();
let closure = move |current_task: &CurrentTask| {
if let Some(metadata) = device_clone.metadata() {
metadata.properties.insert("USB_STATE".into(), usb_state);
}
current_task.kernel.device_registry.dispatch_uevent(UEventAction::Change, device_clone);
};
let (result, request) =
SpawnRequestBuilder::new().with_sync_closure(closure).build_with_async_result();
spawner.spawn_from_request(request);
result
}
/// Monitor the USB state via FIDL messages from the PolicyProvider and dispatch uevents when the
/// state changes.
async fn monitor_usb_device_state(
kernel: Arc<Kernel>,
device: Device,
shared_state: Arc<AtomicU8>,
) {
let provider = connect_to_protocol::<PolicyProviderMarker>()
.expect("USB Failed to connect to PolicyProvider");
let mut previous_mapped_state: Option<UsbGadgetState> = None;
loop {
match provider.watch_device_state().await {
Ok(Ok(update)) => {
let state = update.state.unwrap_or_else(DeviceState::unknown);
// Map the incoming device state onto the new UsbGadgetState.
let mapped = UsbGadgetState::map_from_device_state(state, previous_mapped_state);
if previous_mapped_state != mapped {
if let Some(val) = mapped {
previous_mapped_state = Some(val);
shared_state.store(val as u8, Ordering::Relaxed);
if let Err(e) =
dispatch_usb_state_change(&kernel, &device, val.to_fs_str().to_owned())
.await
{
log_error!("Failed to dispatch USB state change: {:?}", e);
}
}
}
}
Ok(Err(err)) => {
log_error!("USB PolicyProvider returned error: {:?}", err);
break;
}
Err(e) => {
log_error!("USB PolicyProvider watch failed: {:?}", e);
break;
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use fidl_fuchsia_usb_policy::ConfigurationRequest;
use futures::StreamExt;
use starnix_core::testing::spawn_kernel_and_run;
use starnix_rcu::RcuReadScope;
#[::fuchsia::test]
async fn test_usb_gadget_state_map_from_device_state() {
assert_eq!(
UsbGadgetState::map_from_device_state(DeviceState::NotAttached, None),
Some(UsbGadgetState::Disconnected)
);
assert_eq!(
UsbGadgetState::map_from_device_state(DeviceState::Configured, None),
Some(UsbGadgetState::Configured)
);
assert_eq!(
UsbGadgetState::map_from_device_state(DeviceState::Attached, None),
Some(UsbGadgetState::Disconnected)
);
assert_eq!(
UsbGadgetState::map_from_device_state(DeviceState::Powered, None),
Some(UsbGadgetState::Disconnected)
);
assert_eq!(
UsbGadgetState::map_from_device_state(DeviceState::Default, None),
Some(UsbGadgetState::Connected)
);
assert_eq!(
UsbGadgetState::map_from_device_state(DeviceState::Address, None),
Some(UsbGadgetState::Connected)
);
assert_eq!(
UsbGadgetState::map_from_device_state(
DeviceState::Suspended,
Some(UsbGadgetState::Configured)
),
Some(UsbGadgetState::Configured)
);
assert_eq!(UsbGadgetState::map_from_device_state(DeviceState::Suspended, None), None);
assert_eq!(UsbGadgetState::map_from_device_state(DeviceState::unknown(), None), None);
assert_eq!(
UsbGadgetState::map_from_device_state(
DeviceState::unknown(),
Some(UsbGadgetState::Configured)
),
Some(UsbGadgetState::Configured)
);
}
#[::fuchsia::test]
async fn test_usb_sysfs_state_reads() {
spawn_kernel_and_run(async |current_task| {
let shared_state = Arc::new(AtomicU8::new(UsbGadgetState::Disconnected as u8));
shared_state.store(UsbGadgetState::Configured as u8, Ordering::Relaxed);
let sysfs_file = UsbStateSysfsFile { state: shared_state };
let content = sysfs_file.read(current_task).expect("read failed");
assert_eq!(content.as_ref(), b"CONFIGURED\n");
})
.await;
}
#[::fuchsia::test]
async fn test_usb_device_state_to_fs_str() {
assert_eq!(UsbGadgetState::Disconnected.to_fs_str(), b"DISCONNECTED");
assert_eq!(UsbGadgetState::Configured.to_fs_str(), b"CONFIGURED");
assert_eq!(UsbGadgetState::Connected.to_fs_str(), b"CONNECTED");
assert_eq!(UsbGadgetState::Unknown.to_fs_str(), b"UNKNOWN");
}
#[::fuchsia::test]
async fn test_usb_device_state_from_u8() {
assert_eq!(UsbGadgetState::from(0), UsbGadgetState::Disconnected);
assert_eq!(UsbGadgetState::from(1), UsbGadgetState::Configured);
assert_eq!(UsbGadgetState::from(2), UsbGadgetState::Connected);
assert_eq!(UsbGadgetState::from(255), UsbGadgetState::Unknown);
}
#[::fuchsia::test]
async fn test_usb_device_init_sysfs() {
spawn_kernel_and_run(async |current_task| {
let device = usb_device_init(current_task.kernel()).expect("usb_device_init failed");
assert_eq!(device.name(), "android0");
let metadata = device.metadata().expect("metadata not found");
assert_eq!(metadata.devname.as_slice(), b"android0");
let root = &current_task.kernel().device_registry.objects.root;
assert!(root.lookup("class/udc".into()).is_some());
assert!(
root.lookup(
"devices/platform/10d50000.hsi2c/i2c-6/i2c-max77759tcpc/cc_toggle_enable"
.into()
)
.is_some()
);
})
.await;
}
#[::fuchsia::test]
async fn test_usb_device_metadata_property_injection() {
spawn_kernel_and_run(async |current_task| {
let device = usb_device_init(current_task.kernel()).expect("usb_device_init failed");
let kernel = current_task.kernel();
// Send the state change and wait for the background task to execute.
dispatch_usb_state_change(
kernel,
&device,
UsbGadgetState::Connected.to_fs_str().to_owned(),
)
.await
.unwrap();
let metadata = device.metadata().expect("metadata not found");
let scope = RcuReadScope::new();
let value = metadata
.properties
.get(&scope, FsStr::new(b"USB_STATE"))
.expect("property not found");
assert_eq!(value.as_slice(), b"CONNECTED");
})
.await;
}
#[::fuchsia::test]
async fn test_cc_toggle_enable_sysfs_read_and_write() {
let (config_proxy, mut config_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<ConfigurationMarker>();
let server_task = fuchsia_async::Task::spawn(async move {
let mut requests = Vec::new();
while let Some(Ok(req)) = config_stream.next().await {
match req {
ConfigurationRequest::DisconnectCable { duration, responder } => {
requests.push((false, duration));
let _ = responder.send(Ok(()));
}
ConfigurationRequest::ConnectCable { responder } => {
requests.push((true, 0));
let _ = responder.send(Ok(()));
}
_ => panic!("unexpected request: {:?}", req),
}
if requests.len() == 4 {
break;
}
}
requests
});
spawn_kernel_and_run(async move |current_task| {
let sysfs_file = CcToggleEnableSysfsFile::new_with_proxy(config_proxy);
assert_eq!(sysfs_file.read(current_task).expect("read failed").as_ref(), b"1\n");
sysfs_file.write(current_task, b"0\n".to_vec()).expect("write 0 failed");
assert_eq!(sysfs_file.read(current_task).expect("read failed").as_ref(), b"0\n");
sysfs_file.write(current_task, b"1".to_vec()).expect("write 1 failed");
assert_eq!(sysfs_file.read(current_task).expect("read failed").as_ref(), b"1\n");
sysfs_file.write(current_task, b"0\0".to_vec()).expect("write 0\\0 failed");
assert_eq!(sysfs_file.read(current_task).expect("read failed").as_ref(), b"0\n");
sysfs_file.write(current_task, b"1\n\0".to_vec()).expect("write 1\\n\\0 failed");
assert_eq!(sysfs_file.read(current_task).expect("read failed").as_ref(), b"1\n");
assert_eq!(sysfs_file.write(current_task, b"invalid".to_vec()), error!(EINVAL));
})
.await;
assert_eq!(server_task.await, vec![(false, 0), (true, 0), (false, 0), (true, 0)]);
}
#[::fuchsia::test]
async fn test_cc_toggle_enable_sysfs_write_error_keeps_state() {
let (config_proxy, mut config_stream) =
fidl::endpoints::create_sync_proxy_and_stream::<ConfigurationMarker>();
let server_task = fuchsia_async::Task::spawn(async move {
let mut num_requests = 0;
while let Some(Ok(req)) = config_stream.next().await {
match req {
ConfigurationRequest::DisconnectCable { responder, .. } => {
let _ = responder.send(Err(zx::Status::UNAVAILABLE.into_raw()));
}
ConfigurationRequest::ConnectCable { responder } => {
let _ = responder.send(Err(zx::Status::INTERNAL.into_raw()));
}
_ => panic!("unexpected request: {:?}", req),
}
num_requests += 1;
if num_requests == 2 {
break;
}
}
num_requests
});
spawn_kernel_and_run(async move |current_task| {
let sysfs_file = CcToggleEnableSysfsFile::new_with_proxy(config_proxy);
// A failed DisconnectCable must return EIO and leave `enabled` set.
assert_eq!(sysfs_file.write(current_task, b"0".to_vec()), error!(EIO));
assert_eq!(sysfs_file.read(current_task).expect("read failed").as_ref(), b"1\n");
// Force `enabled` to false, then verify a failed ConnectCable leaves it unset.
sysfs_file.state.lock().enabled = false;
assert_eq!(sysfs_file.write(current_task, b"1".to_vec()), error!(EIO));
assert_eq!(sysfs_file.read(current_task).expect("read failed").as_ref(), b"0\n");
})
.await;
assert_eq!(server_task.await, 2);
}
}