devices/usb/backend/host_backend/
host_device.rs

1// Copyright 2019 The ChromiumOS Authors
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use std::collections::HashMap;
6use std::mem;
7use std::sync::Arc;
8use std::sync::RwLock;
9
10use base::debug;
11use base::error;
12use base::AsRawDescriptor;
13use base::RawDescriptor;
14use sync::Mutex;
15use usb_util::ConfigDescriptorTree;
16use usb_util::DescriptorHeader;
17use usb_util::Device;
18use usb_util::DeviceDescriptorTree;
19use usb_util::DeviceSpeed;
20use usb_util::InterfaceDescriptor;
21use usb_util::Transfer;
22use usb_util::TransferBuffer;
23use usb_util::TransferHandle;
24use usb_util::TransferStatus;
25use usb_util::UsbRequestSetup;
26use zerocopy::IntoBytes;
27
28use crate::usb::backend::device::BackendDevice;
29use crate::usb::backend::device::DeviceState;
30use crate::usb::backend::endpoint::ControlEndpointState;
31use crate::usb::backend::endpoint::UsbEndpoint;
32use crate::usb::backend::error::Error;
33use crate::usb::backend::error::Result;
34use crate::usb::backend::transfer::BackendTransfer;
35use crate::usb::backend::transfer::BackendTransferHandle;
36use crate::usb::backend::transfer::BackendTransferType;
37use crate::usb::backend::transfer::ControlTransferState;
38use crate::usb::backend::transfer::GenericTransferHandle;
39use crate::usb::xhci::scatter_gather_buffer::ScatterGatherBuffer;
40use crate::usb::xhci::xhci_backend_device::BackendType;
41use crate::usb::xhci::xhci_backend_device::UsbDeviceAddress;
42use crate::usb::xhci::xhci_backend_device::XhciBackendDevice;
43use crate::utils::EventLoop;
44
45/// Host device is a device connected to host.
46pub struct HostDevice {
47    pub device: Arc<Mutex<Device>>,
48    alt_settings: HashMap<u8, u8>,
49    claimed_interfaces: Vec<u8>,
50    state: Arc<RwLock<DeviceState>>,
51    control_transfer_state: Arc<RwLock<ControlTransferState>>,
52}
53
54impl HostDevice {
55    /// Create a new host device.
56    pub fn new(device: Arc<Mutex<Device>>, state: DeviceState) -> Result<HostDevice> {
57        let control_transfer_state = ControlTransferState {
58            ctl_ep_state: ControlEndpointState::SetupStage,
59            control_request_setup: UsbRequestSetup::new(0, 0, 0, 0, 0),
60            data_stage_transfer: None,
61        };
62        let mut host_device = HostDevice {
63            device,
64            alt_settings: HashMap::new(),
65            claimed_interfaces: vec![],
66            state: Arc::new(RwLock::new(state)),
67            control_transfer_state: Arc::new(RwLock::new(control_transfer_state)),
68        };
69
70        let config_descriptor = host_device.get_active_config_descriptor()?;
71        host_device.claim_interfaces(&config_descriptor);
72
73        Ok(host_device)
74    }
75
76    // Execute a Get Descriptor control request with type Configuration.
77    // This function is used to return a filtered version of the host device's configuration
78    // descriptor that only includes the interfaces in `self.claimed_interfaces`.
79    pub fn get_config_descriptor_filtered(
80        &mut self,
81        buffer: &ScatterGatherBuffer,
82        descriptor_index: u8,
83    ) -> Result<(TransferStatus, u32)> {
84        let _trace = cros_tracing::trace_event!(
85            USB,
86            "host_device get_config_descriptor_filtered",
87            descriptor_index
88        );
89
90        let config_descriptor = self.get_config_descriptor_by_index(descriptor_index)?;
91
92        let device_descriptor = self.get_device_descriptor_tree()?;
93        let config_start = config_descriptor.offset();
94        let config_end = config_start + config_descriptor.wTotalLength as usize;
95        let mut descriptor_data = device_descriptor.raw()[config_start..config_end].to_vec();
96
97        if config_descriptor.bConfigurationValue == self.get_active_configuration()? {
98            for i in 0..config_descriptor.bNumInterfaces {
99                if !self.claimed_interfaces.contains(&i) {
100                    // Rewrite descriptors for unclaimed interfaces to vendor-specific class.
101                    // This prevents them from being recognized by the guest drivers.
102                    let alt_setting = self.alt_settings.get(&i).unwrap_or(&0);
103                    let interface = config_descriptor
104                        .get_interface_descriptor(i, *alt_setting)
105                        .ok_or(Error::GetInterfaceDescriptor(i, *alt_setting))?;
106                    let mut interface_data: InterfaceDescriptor = **interface;
107                    interface_data.bInterfaceClass = 0xFF;
108                    interface_data.bInterfaceSubClass = 0xFF;
109                    interface_data.bInterfaceProtocol = 0xFF;
110
111                    let interface_start =
112                        interface.offset() + mem::size_of::<DescriptorHeader>() - config_start;
113                    let interface_end = interface_start + mem::size_of::<InterfaceDescriptor>();
114                    descriptor_data[interface_start..interface_end]
115                        .copy_from_slice(interface_data.as_bytes());
116                }
117            }
118        }
119
120        let bytes_transferred = buffer.write(&descriptor_data).map_err(Error::WriteBuffer)?;
121        Ok((TransferStatus::Completed, bytes_transferred as u32))
122    }
123
124    pub fn set_interface(&mut self, interface: u8, alt_setting: u8) -> Result<TransferStatus> {
125        let _trace = cros_tracing::trace_event!(USB, "host_device set_interface");
126        // It's a standard, set_interface, interface request.
127        self.device
128            .lock()
129            .set_interface_alt_setting(interface, alt_setting)
130            .map_err(Error::SetInterfaceAltSetting)?;
131        self.alt_settings.insert(interface, alt_setting);
132        let config = self.get_active_configuration()?;
133        let config_descriptor = self.get_config_descriptor(config)?;
134        self.create_endpoints(&config_descriptor)?;
135        Ok(TransferStatus::Completed)
136    }
137
138    pub fn claim_interfaces(&mut self, config_descriptor: &ConfigDescriptorTree) {
139        for i in 0..config_descriptor.num_interfaces() {
140            match self.device.lock().claim_interface(i) {
141                Ok(()) => {
142                    debug!("usb: claimed interface {}", i);
143                    self.claimed_interfaces.push(i);
144                }
145                Err(e) => {
146                    error!("unable to claim interface {}: {:?}", i, e);
147                }
148            }
149        }
150    }
151
152    pub fn release_interfaces(&mut self) {
153        let device_locked = self.device.lock();
154        for i in &self.claimed_interfaces {
155            if let Err(e) = device_locked.release_interface(*i) {
156                error!("could not release interface: {:?}", e);
157            }
158        }
159        self.claimed_interfaces = Vec::new();
160    }
161}
162
163impl Drop for HostDevice {
164    fn drop(&mut self) {
165        self.release_interfaces();
166    }
167}
168
169impl AsRawDescriptor for HostDevice {
170    fn as_raw_descriptor(&self) -> RawDescriptor {
171        self.device.lock().as_raw_descriptor()
172    }
173}
174
175impl GenericTransferHandle for TransferHandle {
176    fn cancel(&self) -> Result<()> {
177        TransferHandle::cancel(self).map_err(Error::TransferHandle)
178    }
179}
180
181impl BackendDevice for HostDevice {
182    fn submit_backend_transfer(
183        &mut self,
184        transfer: BackendTransferType,
185    ) -> Result<BackendTransferHandle> {
186        match transfer {
187            BackendTransferType::HostDevice(transfer) => self
188                .device
189                .lock()
190                .submit_transfer(transfer)
191                .map_err(Error::CreateTransfer)
192                .map(BackendTransferHandle::new),
193            _ => Err(Error::MalformedBackendTransfer),
194        }
195    }
196
197    fn detach_event_handler(&self, event_loop: &Arc<EventLoop>) -> Result<()> {
198        event_loop
199            .remove_event_for_descriptor(self)
200            .map_err(Error::RemoveFromEventLoop)
201    }
202
203    fn request_transfer_buffer(&mut self, size: usize) -> TransferBuffer {
204        match self.device.lock().reserve_dma_buffer(size) {
205            Ok(dmabuf) => TransferBuffer::Dma(dmabuf),
206            Err(_) => TransferBuffer::Vector(vec![0u8; size]),
207        }
208    }
209
210    fn build_bulk_transfer(
211        &mut self,
212        ep_addr: u8,
213        transfer_buffer: TransferBuffer,
214        stream_id: Option<u16>,
215    ) -> Result<BackendTransferType> {
216        Ok(BackendTransferType::HostDevice(
217            Transfer::new_bulk(ep_addr, transfer_buffer, stream_id)
218                .map_err(Error::CreateTransfer)?,
219        ))
220    }
221
222    fn build_interrupt_transfer(
223        &mut self,
224        ep_addr: u8,
225        transfer_buffer: TransferBuffer,
226    ) -> Result<BackendTransferType> {
227        Ok(BackendTransferType::HostDevice(
228            Transfer::new_interrupt(ep_addr, transfer_buffer).map_err(Error::CreateTransfer)?,
229        ))
230    }
231
232    fn build_isochronous_transfer(
233        &mut self,
234        ep_addr: u8,
235        transfer_buffer: TransferBuffer,
236        packet_size: u32,
237    ) -> Result<BackendTransferType> {
238        Ok(BackendTransferType::HostDevice(
239            Transfer::new_isochronous(ep_addr, transfer_buffer, packet_size)
240                .map_err(Error::CreateTransfer)?,
241        ))
242    }
243
244    fn get_control_transfer_state(&mut self) -> Arc<RwLock<ControlTransferState>> {
245        self.control_transfer_state.clone()
246    }
247
248    fn get_device_state(&mut self) -> Arc<RwLock<DeviceState>> {
249        self.state.clone()
250    }
251
252    fn get_active_config_descriptor(&mut self) -> Result<ConfigDescriptorTree> {
253        let cur_config = self.get_active_configuration()?;
254        self.get_config_descriptor(cur_config)
255    }
256
257    fn get_config_descriptor(&mut self, config: u8) -> Result<ConfigDescriptorTree> {
258        self.device
259            .lock()
260            .get_config_descriptor(config)
261            .map_err(Error::GetActiveConfig)
262    }
263
264    fn get_config_descriptor_by_index(&mut self, config_index: u8) -> Result<ConfigDescriptorTree> {
265        self.device
266            .lock()
267            .get_config_descriptor_by_index(config_index)
268            .map_err(Error::GetConfigDescriptor)
269    }
270
271    fn get_device_descriptor_tree(&mut self) -> Result<DeviceDescriptorTree> {
272        Ok(self.device.lock().get_device_descriptor_tree().clone())
273    }
274
275    fn get_active_configuration(&mut self) -> Result<u8> {
276        self.device
277            .lock()
278            .get_active_configuration()
279            .map_err(Error::GetActiveConfig)
280    }
281
282    fn set_active_configuration(&mut self, config: u8) -> Result<()> {
283        self.device
284            .lock()
285            .set_active_configuration(config)
286            .map_err(Error::SetActiveConfig)
287    }
288
289    fn clear_feature(&mut self, value: u16, index: u16) -> Result<TransferStatus> {
290        // It's a standard, clear_feature, endpoint request.
291        const STD_FEATURE_ENDPOINT_HALT: u16 = 0;
292        if value == STD_FEATURE_ENDPOINT_HALT {
293            self.device
294                .lock()
295                .clear_halt(index as u8)
296                .map_err(Error::ClearHalt)?;
297        }
298        Ok(TransferStatus::Completed)
299    }
300
301    fn create_endpoints(&mut self, config_descriptor: &ConfigDescriptorTree) -> Result<()> {
302        let mut endpoints = Vec::new();
303        let device_state = self.get_device_state();
304        for i in &self.claimed_interfaces {
305            let alt_setting = self.alt_settings.get(i).unwrap_or(&0);
306            let interface = config_descriptor
307                .get_interface_descriptor(*i, *alt_setting)
308                .ok_or(Error::GetInterfaceDescriptor(*i, *alt_setting))?;
309            for ep_idx in 0..interface.bNumEndpoints {
310                let ep_dp = interface
311                    .get_endpoint_descriptor(ep_idx)
312                    .ok_or(Error::GetEndpointDescriptor(ep_idx))?;
313                let ep_num = ep_dp.get_endpoint_number();
314                if ep_num == 0 {
315                    continue;
316                }
317                let direction = ep_dp.get_direction();
318                let ty = ep_dp.get_endpoint_type().ok_or(Error::GetEndpointType)?;
319                endpoints.push(UsbEndpoint::new(
320                    device_state.read().unwrap().fail_handle.clone(),
321                    device_state.read().unwrap().job_queue.clone(),
322                    ep_num,
323                    direction,
324                    ty,
325                ));
326            }
327        }
328        device_state.write().unwrap().endpoints = endpoints;
329        Ok(())
330    }
331}
332
333impl XhciBackendDevice for HostDevice {
334    fn get_backend_type(&self) -> BackendType {
335        let d = match self.device.lock().get_device_descriptor() {
336            Ok(d) => d,
337            Err(_) => return BackendType::Usb2,
338        };
339
340        // See definition of bcdUsb.
341        const USB3_MASK: u16 = 0x0300;
342        match d.bcdUSB & USB3_MASK {
343            USB3_MASK => BackendType::Usb3,
344            _ => BackendType::Usb2,
345        }
346    }
347
348    fn get_vid(&self) -> u16 {
349        match self.device.lock().get_device_descriptor() {
350            Ok(d) => d.idVendor,
351            Err(e) => {
352                error!("cannot get device descriptor: {:?}", e);
353                0
354            }
355        }
356    }
357
358    fn get_pid(&self) -> u16 {
359        match self.device.lock().get_device_descriptor() {
360            Ok(d) => d.idProduct,
361            Err(e) => {
362                error!("cannot get device descriptor: {:?}", e);
363                0
364            }
365        }
366    }
367
368    fn set_address(&mut self, _address: UsbDeviceAddress) {
369        // It's a standard, set_address, device request. We do nothing here. As described in XHCI
370        // spec. See set address command ring trb.
371        debug!(
372            "usb set address control transfer is received with address: {}",
373            _address
374        );
375    }
376
377    fn reset(&mut self) -> Result<()> {
378        self.device.lock().reset().map_err(Error::Reset)
379    }
380
381    fn get_speed(&self) -> Option<DeviceSpeed> {
382        self.device.lock().get_speed().unwrap_or(None)
383    }
384
385    fn alloc_streams(&self, ep: u8, num_streams: u16) -> Result<()> {
386        self.device
387            .lock()
388            .alloc_streams(ep, num_streams)
389            .map_err(Error::AllocStreams)
390    }
391
392    fn free_streams(&self, ep: u8) -> Result<()> {
393        self.device
394            .lock()
395            .free_streams(ep)
396            .map_err(Error::FreeStreams)
397    }
398
399    fn stop(&mut self) {
400        // NOOP, nothing to do
401    }
402}
403
404impl BackendTransfer for Transfer {
405    fn status(&self) -> TransferStatus {
406        Transfer::status(self)
407    }
408
409    fn actual_length(&self) -> usize {
410        Transfer::actual_length(self)
411    }
412
413    fn buffer(&self) -> &TransferBuffer {
414        &self.buffer
415    }
416
417    fn set_callback<C: 'static + Fn(BackendTransferType) + Send + Sync>(&mut self, cb: C) {
418        Transfer::set_callback(self, move |t| cb(BackendTransferType::HostDevice(t)));
419    }
420}
devices/usb/backend/host_backend/host_device.rs

devices/usb/backend/host_backend/
host_device.rs
