musb 0.2.0

musb(Mentor USB) regs and `embassy-usb-driver`, `usb-device` impl
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use std::env;

#[allow(dead_code)]
pub struct Features {
    pub builtin: String,
    pub endpoints_num: Option<u8>,
}

impl Features {
    fn get_one_feature(name: &str) -> Option<String> {
        let name_upper = name.to_ascii_uppercase();

        match env::vars()
            .map(|(a, _)| a)
            .filter(|x| x.starts_with(format!("CARGO_FEATURE_{}", &name_upper).as_str()))
            .get_one()
        {
            Ok(x) => Some({
                x.strip_prefix(&format!("CARGO_FEATURE_{}_", &name_upper))
                .unwrap()
                .to_ascii_lowercase()
            }),
            Err(GetOneError::None) => None,
            Err(GetOneError::Multiple) => panic!("Multiple {}-xxx Cargo features enabled", name),
        }
    }


    pub fn get() -> Self {
        let builtin = Self::get_one_feature("builtin").expect("No builtin-xxx Cargo features enabled");

        let endpoints_num = Self::get_one_feature("endpoints_num")
            .map(|x| x.parse::<u8>().unwrap());

        Self {
            builtin,
            endpoints_num,
        }

    }
}

pub struct FeatureGenerator(pub Vec<String>);

impl FeatureGenerator {
    pub fn gen(&self) {
        for feature in self.0.iter() {
            println!("cargo:rustc-cfg=feature=\"{}\"", feature);
        }
    }

    #[cfg(not(feature = "prebuild"))]
    pub fn get_from_profile(profile: &crate::Profile) -> Self {
        use crate::FifoConfig;

        let mut features = Vec::new();
        match &profile.fifo {
            FifoConfig::Fixed(fifo) => {
                features.push("_fixed-fifo-size".to_string());
                if fifo.equal_size {
                    features.push("_equal-fifo-size".to_string());
                }
                if fifo.shared {
                    features.push("_ep-shared-fifo".to_string());
                }
            },
            FifoConfig::Dynamic(_) => (),
        }

        if let Some(_) = profile.base_address {
            features.push("_gen-usb-instance".to_string());
        }
        Self(features)
    }
    
    #[cfg(feature = "prebuild")]
    pub fn get_from_prebuild(features: &Features) -> Self {
        use std::path::Path;
        use std::fs::File;
        use std::io::BufReader;
        use std::io::BufRead;
    
        let file_path = format!("src/prebuilds/{}/features.txt", features.builtin);
        let path = Path::new(&file_path);
        
        // Open the file in read-only mode.
        let file = File::open(path).unwrap();
        let reader = BufReader::new(file);
    
        // Read lines, filter out empty ones, and collect into a Vec<String>.
        let features: Vec<String> = reader
            .lines()
            .filter_map(|line| line.ok()) // Handle potential errors for individual lines
            .map(|line| line.trim().to_string()) // Trim whitespace
            .filter(|line| !line.is_empty()) // Remove empty lines
            .collect();
    
        Self(features)
    }

    #[cfg(not(feature = "prebuild"))]
    pub fn gen_file(&self) {
        use std::path::Path;
        use std::fs;
        use std::env;

        let out_dir = env::var("OUT_DIR").unwrap();
        let file_path = Path::new(&out_dir).join("features.txt");
    
        let mut content = String::new();
        for feature in self.0.iter() {
            content.push_str(&format!("{}\n", feature));
        }
    
        fs::write(&file_path, content).unwrap();
    }
}



enum GetOneError {
    None,
    Multiple,
}

trait IteratorExt: Iterator {
    fn get_one(self) -> Result<Self::Item, GetOneError>;
}

impl<T: Iterator> IteratorExt for T {
    fn get_one(mut self) -> Result<Self::Item, GetOneError> {
        match self.next() {
            None => Err(GetOneError::None),
            Some(res) => match self.next() {
                Some(_) => Err(GetOneError::Multiple),
                None => Ok(res),
            },
        }
    }
}