X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=decoders%2Fadf435x%2Fpd.py;h=ca61fbc02e8c41f9cf89047efdf17b390db5e428;hb=HEAD;hp=d234a815f4f2e7fb299130cf5809e2351b91d09b;hpb=e50276324056e37149b5456070a097170d49725b;p=libsigrokdecode.git diff --git a/decoders/adf435x/pd.py b/decoders/adf435x/pd.py index d234a81..ca61fbc 100644 --- a/decoders/adf435x/pd.py +++ b/decoders/adf435x/pd.py @@ -24,70 +24,96 @@ def disabled_enabled(v): return ['Disabled', 'Enabled'][v] def output_power(v): - return '%+ddBm' % [-4, -1, 2, 5][v] + return '{:+d}dBm'.format([-4, -1, 2, 5][v]) +# Notes on the implementation: +# - A register's description is an iterable of tuples which contain: +# The starting bit position, the bit count, the name of a field, and +# an optional parser which interprets the field's content. Parser are +# expected to yield a single text string when they exist. Other types +# of output are passed to Python's .format() routine as is. +# - Bit fields' width in registers determines the range of indices in +# table/tuple lookups. Keep the implementation as robust as possible +# during future maintenance. Avoid Python runtime errors when adjusting +# the decoder. regs = { -# reg: name offset width parser - 0: [ - ('FRAC', 3, 12, None), - ('INT', 15, 16, lambda v: 'Not Allowed' if v < 32 else v) - ], - 1: [ - ('MOD', 3, 12, None), - ('Phase', 15, 12, None), - ('Prescalar', 27, 1, lambda v: ['4/5', '8/9'][v]), - ('Phase Adjust', 28, 1, lambda v: ['Off', 'On'][v]), - ], - 2: [ - ('Counter Reset', 3, 1, disabled_enabled), - ('Charge Pump Three-State', 4, 1, disabled_enabled), - ('Power-Down', 5, 1, disabled_enabled), - ('PD Polarity', 6, 1, lambda v: ['Negative', 'Positive'][v]), - ('LDP', 7, 1, lambda v: ['10ns', '6ns'][v]), - ('LDF', 8, 1, lambda v: ['FRAC-N', 'INT-N'][v]), - ('Charge Pump Current Setting', 9, 4, lambda v: '%0.2fmA @ 5.1kΩ' % - [0.31, 0.63, 0.94, 1.25, 1.56, 1.88, 2.19, 2.50, - 2.81, 3.13, 3.44, 3.75, 4.06, 4.38, 4.69, 5.00][v]), - ('Double Buffer', 13, 1, disabled_enabled), - ('R Counter', 14, 10, None), - ('RDIV2', 24, 1, disabled_enabled), - ('Reference Doubler', 25, 1, disabled_enabled), - ('MUXOUT', 26, 3, lambda v: - ['Three-State Output', 'DVdd', 'DGND', 'R Counter Output', 'N Divider Output', - 'Analog Lock Detect', 'Digital Lock Detect', 'Reserved'][v]), - ('Low Noise and Low Spur Modes', 29, 2, lambda v: - ['Low Noise Mode', 'Reserved', 'Reserved', 'Low Spur Mode'][v]) - ], - 3: [ - ('Clock Divider', 3, 12, None), - ('Clock Divider Mode', 15, 2, lambda v: - ['Clock Divider Off', 'Fast Lock Enable', 'Resync Enable', 'Reserved'][v]), - ('CSR Enable', 18, 1, disabled_enabled), - ('Charge Cancellation', 21, 1, disabled_enabled), - ('ABP', 22, 1, lambda v: ['6ns (FRAC-N)', '3ns (INT-N)'][v]), - ('Band Select Clock Mode', 23, 1, lambda v: ['Low', 'High'][v]) - ], - 4: [ - ('Output Power', 3, 2, output_power), - ('Output Enable', 5, 1, disabled_enabled), - ('AUX Output Power', 6, 2, output_power), - ('AUX Output Select', 8, 1, lambda v: ['Divided Output', 'Fundamental'][v]), - ('AUX Output Enable', 9, 1, disabled_enabled), - ('MTLD', 10, 1, disabled_enabled), - ('VCO Power-Down', 11, 1, lambda v: - 'VCO Powered ' + ('Down' if v == 1 else 'Up')), - ('Band Select Clock Divider', 12, 8, None), - ('RF Divider Select', 20, 3, lambda v: '÷' + str(2**v)), - ('Feedback Select', 23, 1, lambda v: ['Divided', 'Fundamental'][v]), - ], - 5: [ - ('LD Pin Mode', 22, 2, lambda v: - ['Low', 'Digital Lock Detect', 'Low', 'High'][v]) - ] + # Register description fields: + # offset, width, name, parser. + 0: ( + ( 3, 12, 'FRAC'), + (15, 16, 'INT', + None, lambda v: 'Not Allowed' if v < 23 else None, + ), + ), + 1: ( + ( 3, 12, 'MOD'), + (15, 12, 'Phase'), + (27, 1, 'Prescalar', lambda v: ('4/5', '8/9',)[v]), + (28, 1, 'Phase Adjust', lambda v: ('Off', 'On',)[v]), + ), + 2: ( + ( 3, 1, 'Counter Reset', disabled_enabled), + ( 4, 1, 'Charge Pump Three-State', disabled_enabled), + ( 5, 1, 'Power-Down', disabled_enabled), + ( 6, 1, 'PD Polarity', lambda v: ('Negative', 'Positive',)[v]), + ( 7, 1, 'LDP', lambda v: ('10ns', '6ns',)[v]), + ( 8, 1, 'LDF', lambda v: ('FRAC-N', 'INT-N',)[v]), + ( 9, 4, 'Charge Pump Current Setting', + lambda v: '{curr:0.2f}mA @ 5.1kΩ'.format(curr = ( + 0.31, 0.63, 0.94, 1.25, 1.56, 1.88, 2.19, 2.50, + 2.81, 3.13, 3.44, 3.75, 4.06, 4.38, 4.69, 5.00, + )[v])), + (13, 1, 'Double Buffer', disabled_enabled), + (14, 10, 'R Counter'), + (24, 1, 'RDIV2', disabled_enabled), + (25, 1, 'Reference Doubler', disabled_enabled), + (26, 3, 'MUXOUT', + lambda v: '{text}'.format(text = ( + 'Three-State Output', 'DVdd', 'DGND', + 'R Counter Output', 'N Divider Output', + 'Analog Lock Detect', 'Digital Lock Detect', + 'Reserved', + )[v])), + (29, 2, 'Low Noise and Low Spur Modes', + lambda v: '{text}'.format(text = ( + 'Low Noise Mode', 'Reserved', 'Reserved', 'Low Spur Mode', + )[v])), + ), + 3: ( + ( 3, 12, 'Clock Divider'), + (15, 2, 'Clock Divider Mode', + lambda v: '{text}'.format(text = ( + 'Clock Divider Off', 'Fast Lock Enable', + 'Resync Enable', 'Reserved', + )[v])), + (18, 1, 'CSR Enable', disabled_enabled), + (21, 1, 'Charge Cancellation', disabled_enabled), + (22, 1, 'ABP', lambda v: ('6ns (FRAC-N)', '3ns (INT-N)',)[v]), + (23, 1, 'Band Select Clock Mode', lambda v: ('Low', 'High',)[v]), + ), + 4: ( + ( 3, 2, 'Output Power', output_power), + ( 5, 1, 'Output Enable', disabled_enabled), + ( 6, 2, 'AUX Output Power', output_power), + ( 8, 1, 'AUX Output Select', + lambda v: ('Divided Output', 'Fundamental',)[v]), + ( 9, 1, 'AUX Output Enable', disabled_enabled), + (10, 1, 'MTLD', disabled_enabled), + (11, 1, 'VCO Power-Down', + lambda v: 'VCO Powered {ud}'.format(ud = 'Down' if v else 'Up')), + (12, 8, 'Band Select Clock Divider'), + (20, 3, 'RF Divider Select', lambda v: '÷{:d}'.format(2 ** v)), + (23, 1, 'Feedback Select', lambda v: ('Divided', 'Fundamental',)[v]), + ), + 5: ( + (22, 2, 'LD Pin Mode', + lambda v: '{text}'.format(text = ( + 'Low', 'Digital Lock Detect', 'Low', 'High', + )[v])), + ), } -ANN_REG = 0 -ANN_WARN = 1 +( ANN_REG, ANN_WARN, ) = range(2) class Decoder(srd.Decoder): api_version = 3 @@ -122,50 +148,83 @@ class Decoder(srd.Decoder): self.put(ss, es, self.out_ann, [ cls, data, ]) def decode_bits(self, offset, width): + '''Extract a bit field. Expects LSB input data.''' bits = self.bits[offset:][:width] ss, es = bits[-1][1], bits[0][2] value = bitpack_lsb(bits, 0) return ( value, ( ss, es, )) - def decode_field(self, name, offset, width, parser): + def decode_field(self, name, offset, width, parser = None, checker = None): + '''Interpret a bit field. Emits an annotation.''' + # Get the register field's content and position. val, ( ss, es, ) = self.decode_bits(offset, width) - val = parser(val) if parser else str(val) - text = ['%s: %s' % (name, val)] - self.putg(ss, es, ANN_REG, text) - return val + # Have the field's content formatted, emit an annotation. + formatted = parser(val) if parser else '{}'.format(val) + if formatted is not None: + text = ['{name}: {val}'.format(name = name, val = formatted)] + else: + text = ['{name}'.format(name = name)] + if text: + self.putg(ss, es, ANN_REG, text) + # Have the field's content checked, emit an optional warning. + warn = checker(val) if checker else None + if warn: + text = ['{}'.format(warn)] + self.putg(ss, es, ANN_WARN, text) + + def decode_word(self, ss, es, bits): + '''Interpret a 32bit word after accumulation completes.''' + # SPI transfer content must be exactly one 32bit word. + count = len(self.bits) + if count != 32: + text = [ + 'Frame error: Bit count: want 32, got {}'.format(count), + 'Frame error: Bit count', + 'Frame error', + ] + self.putg(ss, es, ANN_WARN, text) + return + # Holding bits in LSB order during interpretation simplifies + # bit field extraction. And annotation emitting routines expect + # this reverse order of bits' timestamps. + self.bits.reverse() + # Determine which register was accessed. + reg_addr, ( reg_ss, reg_es, ) = self.decode_bits(0, 3) + text = [ + 'Register: {addr}'.format(addr = reg_addr), + 'Reg: {addr}'.format(addr = reg_addr), + '[{addr}]'.format(addr = reg_addr), + ] + self.putg(reg_ss, reg_es, ANN_REG, text) + # Interpret the register's content (when parsers are available). + field_descs = regs.get(reg_addr, None) + if not field_descs: + return + for field_desc in field_descs: + parser = None + checker = None + if len(field_desc) == 3: + start, count, name, = field_desc + elif len(field_desc) == 4: + start, count, name, parser = field_desc + elif len(field_desc) == 5: + start, count, name, parser, checker = field_desc + else: + # Unsupported regs{} syntax, programmer's error. + return + self.decode_field(name, start, count, parser, checker) def decode(self, ss, es, data): ptype, _, _ = data if ptype == 'TRANSFER': - if len(self.bits) == 32: - self.bits.reverse() - reg_value, ( reg_ss, reg_es, ) = self.decode_bits(0, 3) - text = [ - 'Register: %d' % reg_value, - 'Reg: %d' % reg_value, - '[%d]' % reg_value, - ] - self.putg(reg_ss, reg_es, ANN_REG, text) - if reg_value < len(regs): - field_descs = regs[reg_value] - for field_desc in field_descs: - field = self.decode_field(*field_desc) - else: - text = [ - 'Frame error: Bit count: want 32, got %d' % len(self.bits), - 'Frame error: Bit count', - 'Frame error', - ] - self.putg(ss, es, ANN_WARN, text) + # Process accumulated bits after completion of a transfer. + self.decode_word(ss, es, self.bits) self.bits.clear() if ptype == 'BITS': _, mosi_bits, miso_bits = data - # Cope with the lower layer SPI decoder's output convention: - # Regardless of wire transfer's frame format, .decode() input - # provides BITS in the LE order. Accumulate in MSB order here, - # and reverse before data processing when 'TRANSFER' is seen. - mosi_bits = mosi_bits.copy() - mosi_bits.reverse() - self.bits.extend(mosi_bits) + # Accumulate bits in MSB order as they are seen in SPI frames. + msb_bits = mosi_bits.copy() + msb_bits.reverse() + self.bits.extend(msb_bits)