]>
Commit | Line | Data |
---|---|---|
1d4fe1c1 JH |
1 | ## |
2 | ## This file is part of the libsigrokdecode project. | |
3 | ## | |
4 | ## Copyright (C) 2017 Joel Holdsworth <joel@airwebreathe.org.uk> | |
5 | ## | |
6 | ## This program is free software; you can redistribute it and/or modify | |
7 | ## it under the terms of the GNU General Public License as published by | |
8 | ## the Free Software Foundation; either version 3 of the License, or | |
9 | ## (at your option) any later version. | |
10 | ## | |
11 | ## This program is distributed in the hope that it will be useful, | |
12 | ## but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 | ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
14 | ## GNU General Public License for more details. | |
15 | ## | |
16 | ## You should have received a copy of the GNU General Public License | |
17 | ## along with this program; if not, see <http://www.gnu.org/licenses/>. | |
18 | ## | |
19 | ||
20 | import sigrokdecode as srd | |
317eaa7f | 21 | from common.srdhelper import bitpack_lsb |
1d4fe1c1 JH |
22 | |
23 | def disabled_enabled(v): | |
24 | return ['Disabled', 'Enabled'][v] | |
25 | ||
26 | def output_power(v): | |
3851b0c0 | 27 | return '{:+d}dBm'.format([-4, -1, 2, 5][v]) |
1d4fe1c1 | 28 | |
4d86276d GS |
29 | # Notes on the implementation: |
30 | # - Bit fields' width in registers determines the range of indices in | |
31 | # table/tuple lookups. Keep the implementation as robust as possible | |
32 | # during future maintenance. Avoid Python runtime errors when adjusting | |
33 | # the decoder. | |
1d4fe1c1 JH |
34 | regs = { |
35 | # reg: name offset width parser | |
36 | 0: [ | |
37 | ('FRAC', 3, 12, None), | |
38 | ('INT', 15, 16, lambda v: 'Not Allowed' if v < 32 else v) | |
39 | ], | |
40 | 1: [ | |
41 | ('MOD', 3, 12, None), | |
42 | ('Phase', 15, 12, None), | |
43 | ('Prescalar', 27, 1, lambda v: ['4/5', '8/9'][v]), | |
44 | ('Phase Adjust', 28, 1, lambda v: ['Off', 'On'][v]), | |
45 | ], | |
46 | 2: [ | |
47 | ('Counter Reset', 3, 1, disabled_enabled), | |
48 | ('Charge Pump Three-State', 4, 1, disabled_enabled), | |
49 | ('Power-Down', 5, 1, disabled_enabled), | |
50 | ('PD Polarity', 6, 1, lambda v: ['Negative', 'Positive'][v]), | |
51 | ('LDP', 7, 1, lambda v: ['10ns', '6ns'][v]), | |
52 | ('LDF', 8, 1, lambda v: ['FRAC-N', 'INT-N'][v]), | |
4d86276d GS |
53 | ('Charge Pump Current Setting', 9, 4, lambda v: '{curr:0.2f}mA @ 5.1kΩ'.format( |
54 | curr = ( | |
55 | 0.31, 0.63, 0.94, 1.25, 1.56, 1.88, 2.19, 2.50, | |
56 | 2.81, 3.13, 3.44, 3.75, 4.06, 4.38, 4.69, 5.00, | |
57 | )[v])), | |
1d4fe1c1 JH |
58 | ('Double Buffer', 13, 1, disabled_enabled), |
59 | ('R Counter', 14, 10, None), | |
60 | ('RDIV2', 24, 1, disabled_enabled), | |
61 | ('Reference Doubler', 25, 1, disabled_enabled), | |
4d86276d GS |
62 | ('MUXOUT', 26, 3, lambda v: '{text}'.format( |
63 | text = ( | |
64 | 'Three-State Output', 'DVdd', 'DGND', | |
65 | 'R Counter Output', 'N Divider Output', | |
66 | 'Analog Lock Detect', 'Digital Lock Detect', | |
67 | 'Reserved' | |
68 | )[v])), | |
69 | ('Low Noise and Low Spur Modes', 29, 2, lambda v: '{text}'.format( | |
70 | text = ( | |
71 | 'Low Noise Mode', 'Reserved', 'Reserved', 'Low Spur Mode' | |
72 | )[v])), | |
1d4fe1c1 JH |
73 | ], |
74 | 3: [ | |
75 | ('Clock Divider', 3, 12, None), | |
4d86276d GS |
76 | ('Clock Divider Mode', 15, 2, lambda v: '{text}'.format( |
77 | text = ( | |
78 | 'Clock Divider Off', 'Fast Lock Enable', 'Resync Enable', 'Reserved' | |
79 | )[v])), | |
1d4fe1c1 JH |
80 | ('CSR Enable', 18, 1, disabled_enabled), |
81 | ('Charge Cancellation', 21, 1, disabled_enabled), | |
82 | ('ABP', 22, 1, lambda v: ['6ns (FRAC-N)', '3ns (INT-N)'][v]), | |
83 | ('Band Select Clock Mode', 23, 1, lambda v: ['Low', 'High'][v]) | |
84 | ], | |
85 | 4: [ | |
86 | ('Output Power', 3, 2, output_power), | |
87 | ('Output Enable', 5, 1, disabled_enabled), | |
88 | ('AUX Output Power', 6, 2, output_power), | |
89 | ('AUX Output Select', 8, 1, lambda v: ['Divided Output', 'Fundamental'][v]), | |
90 | ('AUX Output Enable', 9, 1, disabled_enabled), | |
91 | ('MTLD', 10, 1, disabled_enabled), | |
92 | ('VCO Power-Down', 11, 1, lambda v: | |
3851b0c0 | 93 | 'VCO Powered {updown}'.format(updown = 'Down' if v else 'Up')), |
1d4fe1c1 | 94 | ('Band Select Clock Divider', 12, 8, None), |
3851b0c0 | 95 | ('RF Divider Select', 20, 3, lambda v: '÷{:d}'.format(2 ** v)), |
1d4fe1c1 JH |
96 | ('Feedback Select', 23, 1, lambda v: ['Divided', 'Fundamental'][v]), |
97 | ], | |
98 | 5: [ | |
4d86276d GS |
99 | ('LD Pin Mode', 22, 2, lambda v: '{text}'.format( |
100 | text = ( | |
101 | 'Low', 'Digital Lock Detect', 'Low', 'High', | |
102 | )[v])), | |
1d4fe1c1 JH |
103 | ] |
104 | } | |
105 | ||
106 | ANN_REG = 0 | |
f534ce44 | 107 | ANN_WARN = 1 |
1d4fe1c1 JH |
108 | |
109 | class Decoder(srd.Decoder): | |
b197383c | 110 | api_version = 3 |
1d4fe1c1 JH |
111 | id = 'adf435x' |
112 | name = 'ADF435x' | |
113 | longname = 'Analog Devices ADF4350/1' | |
114 | desc = 'Wideband synthesizer with integrated VCO.' | |
115 | license = 'gplv3+' | |
116 | inputs = ['spi'] | |
6cbba91f | 117 | outputs = [] |
d6d8a8a4 | 118 | tags = ['Clock/timing', 'IC', 'Wireless/RF'] |
1d4fe1c1 JH |
119 | annotations = ( |
120 | # Sent from the host to the chip. | |
e144452b | 121 | ('write', 'Register write'), |
f534ce44 | 122 | ('warning', "Warnings"), |
1d4fe1c1 JH |
123 | ) |
124 | annotation_rows = ( | |
e144452b | 125 | ('writes', 'Register writes', (ANN_REG,)), |
f534ce44 | 126 | ('warnings', 'Warnings', (ANN_WARN,)), |
1d4fe1c1 JH |
127 | ) |
128 | ||
129 | def __init__(self): | |
10aeb8ea GS |
130 | self.reset() |
131 | ||
132 | def reset(self): | |
1d4fe1c1 JH |
133 | self.bits = [] |
134 | ||
135 | def start(self): | |
136 | self.out_ann = self.register(srd.OUTPUT_ANN) | |
137 | ||
e5027632 GS |
138 | def putg(self, ss, es, cls, data): |
139 | self.put(ss, es, self.out_ann, [ cls, data, ]) | |
140 | ||
1d4fe1c1 | 141 | def decode_bits(self, offset, width): |
c4aaef25 | 142 | '''Extract a bit field. Expects LSB input data.''' |
317eaa7f GS |
143 | bits = self.bits[offset:][:width] |
144 | ss, es = bits[-1][1], bits[0][2] | |
145 | value = bitpack_lsb(bits, 0) | |
146 | return ( value, ( ss, es, )) | |
1d4fe1c1 JH |
147 | |
148 | def decode_field(self, name, offset, width, parser): | |
c4aaef25 | 149 | '''Interpret a bit field. Emits an annotation.''' |
e5027632 | 150 | val, ( ss, es, ) = self.decode_bits(offset, width) |
3851b0c0 GS |
151 | val = parser(val) if parser else '{}'.format(val) |
152 | text = ['{name}: {val}'.format(name = name, val = val)] | |
e5027632 | 153 | self.putg(ss, es, ANN_REG, text) |
c4aaef25 GS |
154 | |
155 | def decode_word(self, ss, es, bits): | |
156 | '''Interpret a 32bit word after accumulation completes.''' | |
157 | # SPI transfer content must be exactly one 32bit word. | |
3851b0c0 GS |
158 | count = len(self.bits) |
159 | if count != 32: | |
c4aaef25 | 160 | text = [ |
3851b0c0 | 161 | 'Frame error: Bit count: want 32, got {}'.format(count), |
c4aaef25 GS |
162 | 'Frame error: Bit count', |
163 | 'Frame error', | |
164 | ] | |
165 | self.putg(ss, es, ANN_WARN, text) | |
166 | return | |
167 | # Holding bits in LSB order during interpretation simplifies | |
168 | # bit field extraction. And annotation emitting routines expect | |
169 | # this reverse order of bits' timestamps. | |
170 | self.bits.reverse() | |
171 | # Determine which register was accessed. | |
172 | reg_addr, ( reg_ss, reg_es, ) = self.decode_bits(0, 3) | |
173 | text = [ | |
3851b0c0 GS |
174 | 'Register: {addr}'.format(addr = reg_addr), |
175 | 'Reg: {addr}'.format(addr = reg_addr), | |
176 | '[{addr}]'.format(addr = reg_addr), | |
c4aaef25 GS |
177 | ] |
178 | self.putg(reg_ss, reg_es, ANN_REG, text) | |
179 | # Interpret the register's content (when parsers are available). | |
180 | field_descs = regs.get(reg_addr, None) | |
181 | if not field_descs: | |
182 | return | |
183 | for field_desc in field_descs: | |
184 | self.decode_field(*field_desc) | |
1d4fe1c1 JH |
185 | |
186 | def decode(self, ss, es, data): | |
53cbedf5 | 187 | ptype, _, _ = data |
1d4fe1c1 | 188 | |
adb8233a | 189 | if ptype == 'TRANSFER': |
c4aaef25 GS |
190 | # Process accumulated bits after completion of a transfer. |
191 | self.decode_word(ss, es, self.bits) | |
912f4e8a | 192 | self.bits.clear() |
f534ce44 | 193 | |
1d4fe1c1 | 194 | if ptype == 'BITS': |
53cbedf5 | 195 | _, mosi_bits, miso_bits = data |
c4aaef25 GS |
196 | # Accumulate bits in MSB order as they are seen in SPI frames. |
197 | msb_bits = mosi_bits.copy() | |
198 | msb_bits.reverse() | |
199 | self.bits.extend(msb_bits) |