tpa2016d2/
regmap.rs

1pub trait RegisterMapRegister {
2    fn as_byte(&self) -> u8;
3    fn update(&mut self, val: u8);
4}
5
6#[allow(non_snake_case)]
7pub struct Register1 {
8    pub SPK_EN_R: bool,
9    pub SPK_EN_L: bool,
10    pub SWS: bool,
11    pub FAULT_R: bool,
12    pub FAULT_L: bool,
13    pub Thermal: bool,
14    pub NG_EN: bool,
15}
16
17impl Default for Register1 {
18    fn default() -> Self {
19        Self {
20            SPK_EN_R: true,
21            SPK_EN_L: true,
22            SWS: false,
23            FAULT_R: false,
24            FAULT_L: false,
25            Thermal: false,
26            NG_EN: true,
27        }
28    }
29}
30
31impl RegisterMapRegister for Register1 {
32    fn as_byte(&self) -> u8 {
33        let mut r = 0;
34
35        if self.SPK_EN_R {
36            r |= 1 << 7;
37        }
38        if self.SPK_EN_L {
39            r |= 1 << 6;
40        }
41        if self.SWS {
42            r |= 1 << 5;
43        }
44        if self.FAULT_R {
45            r |= 1 << 4;
46        }
47        if self.FAULT_L {
48            r |= 1 << 3;
49        }
50        if self.Thermal {
51            r |= 1 << 2;
52        }
53        // Bit 1 should always be 1
54        r |= 1 << 1;
55        if self.NG_EN {
56            r |= 1;
57        }
58
59        r
60    }
61
62    fn update(&mut self, new: u8) {
63        self.SPK_EN_R = new & 1 << 7 != 0;
64        self.SPK_EN_L = new & 1 << 6 != 0;
65        self.SWS = new & 1 << 5 != 0;
66        self.FAULT_R = new & 1 << 4 != 0;
67        self.FAULT_L = new & 1 << 3 != 0;
68        self.Thermal = new & 1 << 2 != 0;
69        // Reserved
70        self.NG_EN = new & 1 != 0;
71    }
72}
73
74pub struct U6Register(u8);
75
76impl U6Register {
77    pub fn set(&mut self, value: u8) {
78        self.0 = value & 0x3F;
79    }
80}
81
82impl RegisterMapRegister for U6Register {
83    fn as_byte(&self) -> u8 {
84        self.0 & 0x3F
85    }
86
87    fn update(&mut self, val: u8) {
88        self.0 = val & 0x3F;
89    }
90}
91
92pub struct Register6 {
93    pub output_limiter_disable: bool,
94    pub noise_gate_threshold: u8,
95    pub output_limiter_level: u8,
96}
97
98impl Default for Register6 {
99    fn default() -> Self {
100        Self {
101            output_limiter_disable: false,
102            noise_gate_threshold: 0b01,
103            output_limiter_level: 0b11010,
104        }
105    }
106}
107
108impl RegisterMapRegister for Register6 {
109    fn as_byte(&self) -> u8 {
110        let mut r = 0;
111
112        if self.output_limiter_disable {
113            r |= 1 << 7
114        }
115
116        r |= (self.noise_gate_threshold & 0b11) << 5;
117        r |= self.output_limiter_level & 0b11111;
118        r
119    }
120
121    fn update(&mut self, val: u8) {
122        self.output_limiter_disable = val & 1 << 7 != 0;
123        self.noise_gate_threshold = (val >> 5) & 0b11;
124        self.output_limiter_level = val & 0b11111;
125    }
126}
127
128pub struct Register7 {
129    pub max_gain: u8,
130    pub compression_ratio: u8,
131}
132
133impl Default for Register7 {
134    fn default() -> Self {
135        Self {
136            max_gain: 0b1100,
137            compression_ratio: 0b10,
138        }
139    }
140}
141
142impl RegisterMapRegister for Register7 {
143    fn as_byte(&self) -> u8 {
144        // Gain
145        (self.max_gain & 0b1111) << 4 |
146        // Compression radio
147        (self.compression_ratio & 0b11)
148    }
149
150    fn update(&mut self, val: u8) {
151        self.max_gain = val >> 4;
152        self.compression_ratio = val & 0b11;
153    }
154}
155
156#[allow(non_snake_case)]
157pub struct RegisterMap {
158    pub reg1: Register1,
159    pub atk_time: U6Register,  // reg2
160    pub rel_time: U6Register,  // reg3
161    pub hold_time: U6Register, // reg4
162    pub fixedGain: U6Register, // reg5
163    pub reg6: Register6,
164    pub reg7: Register7,
165}
166
167impl Default for RegisterMap {
168    fn default() -> Self {
169        Self {
170            reg1: Register1::default(),
171            atk_time: U6Register(0x05),
172            rel_time: U6Register(0x0B),
173            hold_time: U6Register(0x00),
174            fixedGain: U6Register(0x06),
175            reg6: Register6::default(),
176            reg7: Register7::default(),
177        }
178    }
179}
180
181impl RegisterMap {
182    pub fn reg_as_byte(&self, idx: u8) -> u8 {
183        match idx {
184            1 => self.reg1.as_byte(),
185            2 => self.atk_time.as_byte(),
186            3 => self.rel_time.as_byte(),
187            4 => self.hold_time.as_byte(),
188            5 => self.fixedGain.as_byte(),
189            6 => self.reg6.as_byte(),
190            7 => self.reg7.as_byte(),
191            _ => 0,
192        }
193    }
194
195    pub fn update_map(&mut self, idx: u8, val: u8) {
196        match idx {
197            1 => self.reg1.update(val),
198            2 => self.atk_time.update(val),
199            3 => self.rel_time.update(val),
200            4 => self.hold_time.update(val),
201            5 => self.fixedGain.update(val),
202            6 => self.reg6.update(val),
203            7 => self.reg7.update(val),
204            _ => (),
205        }
206    }
207}
tpa2016d2/regmap.rs

tpa2016d2/
regmap.rs
