usb-descriptor-decoder 0.1.0

A no-std extensible USB Descriptor Decoder, support organize Descriptors as tree structure
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

use alloc::vec;
use alloc::vec::Vec;

use super::{
    desc_configuration::Configuration,
    desc_device::Device,
    desc_endpoint::Endpoint,
    desc_interface::{Interface, InterfaceAssociation},
    desc_uvc::uvc_endpoints::UVCVideoControlInterruptEndpoint,
    parser::ParserMetaData,
    USBDescriptor,
};

#[derive(Clone, Debug)]
pub struct TopologicalUSBDescriptorDevice {
    pub data: Device,
    pub child: Vec<TopologicalUSBDescriptorConfiguration>,
}

#[derive(Clone, Debug)]
pub struct TopologicalUSBDescriptorConfiguration {
    pub data: Configuration,
    pub child: Vec<TopologicalUSBDescriptorFunction>,
}

#[derive(Clone, Debug)]
pub enum TopologicalUSBDescriptorFunction {
    InterfaceAssociation((InterfaceAssociation, Vec<TopologicalUSBDescriptorFunction>)), //maybe we would have multi layer compose device in future? for now just treat it as a trick!
    Interface(
        Vec<(
            Interface,
            Vec<USBDescriptor>,
            Vec<TopologicalUSBDescriptorEndpoint>,
        )>,
    ),
}
#[derive(Clone, Debug)]
pub struct TopologicalUSBDescriptorRoot {
    pub device: TopologicalUSBDescriptorDevice,
    pub others: Vec<USBDescriptor>,
    pub metadata: ParserMetaData,
}

#[derive(Clone, Debug)]
pub enum TopologicalUSBDescriptorEndpoint {
    Standard(Endpoint),
    UNVVideoControlInterruptEndpoint(UVCVideoControlInterruptEndpoint),
}

pub enum USBFunctionExpressions<'a> {
    Interface(&'a Interface),
    InterfaceAssociation(&'a InterfaceAssociation),
    Device(&'a Device),
}

impl TopologicalUSBDescriptorRoot {
    pub fn interfaces<'a>(&'a self) -> Vec<USBFunctionExpressions<'a>> {
        if self.device.data.is_refer_interface() {
            self.device
                .child
                .first()
                .expect("atleast 1 cfg, this device got some issue!")
                .child
                .iter()
                .map(|int| match int {
                    TopologicalUSBDescriptorFunction::InterfaceAssociation((ia, _)) => {
                        USBFunctionExpressions::InterfaceAssociation(ia)
                    }
                    TopologicalUSBDescriptorFunction::Interface(vec) => {
                        USBFunctionExpressions::Interface(
                            &vec.first()
                                .expect(
                                    "atleast 1 interface exist, this device must had some issue!",
                                )
                                .0,
                        )
                    }
                })
                .collect()
        } else {
            vec![USBFunctionExpressions::Device(&self.device.data)]
        }
    }

    pub fn configs(&self) -> Vec<&Configuration> {
        self.device.child.iter().map(|cfg| &cfg.data).collect()
    }
}

impl<'a> USBFunctionExpressions<'a> {
    pub fn class_subclass_protocol(&self) -> (u8, u8, u8) {
        match self {
            USBFunctionExpressions::Interface(interface) => (
                interface.interface_class,
                interface.interface_subclass,
                interface.interface_protocol,
            ),
            USBFunctionExpressions::InterfaceAssociation(interface_association) => (
                interface_association.function_class,
                interface_association.function_subclass,
                interface_association.function_protocol,
            ),
            USBFunctionExpressions::Device(device) => {
                (device.class, device.subclass, device.protocol)
            }
        }
    }
}