[libsigrokdecode.git] / decoders / ds2432 / pd.py

##
## This file is part of the libsigrokdecode project.
##
## Copyright (C) 2017 Kevin Redon <kingkevin@cuvoodoo.info>
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, see <http://www.gnu.org/licenses/>.
##

import sigrokdecode as srd

# Dictionary of FUNCTION commands and their names.
commands = {
    0x0f: 'Write scratchpad',
    0xaa: 'Read scratchpad',
    0x55: 'Copy scratchpad',
    0xf0: 'Read memory',
    0x5a: 'Load first secret',
    0x33: 'Compute next secret',
    0xa5: 'Read authenticated page',
}

# Maxim DS2432 family code, present at the end of the ROM code.
family_code = 0x33

# Calculate the CRC-16 checksum.
# Initial value: 0x0000, xor-in: 0x0000, polynom 0x8005, xor-out: 0xffff.
def crc16(byte_array):
    reverse = 0xa001 # Use the reverse polynom to make algo simpler.
    crc = 0x0000 # Initial value.
    # Reverse CRC calculation.
    for byte in byte_array:
        for bit in range(8):
            if (byte ^ crc) & 1:
                crc = (crc >> 1) ^ reverse
            else:
                crc >>= 1
            byte >>= 1
    crc ^= 0xffff # Invert CRC.
    return crc

class Decoder(srd.Decoder):
    api_version = 3
    id = 'ds2432'
    name = 'DS2432'
    longname = 'Maxim DS2432 1-Wire 1k-Bit Protected EEPROM with SHA-1 Engine'
    desc = '1-Wire 1k-Bit Protected EEPROM with SHA-1 Engine.'
    license = 'gplv2+'
    inputs = ['onewire_network']
    outputs = ['ds2432']
    annotations = (
        ('text', 'Human-readable text'),
    )

    def __init__(self):
        # Bytes for function command.
        self.bytes = []

    def start(self):
        self.out_ann = self.register(srd.OUTPUT_ANN)

    def putx(self, data):
        self.put(self.ss, self.es, self.out_ann, data)

    def decode(self, ss, es, data):
        code, val = data

        if code == 'RESET/PRESENCE':
            self.ss, self.es = ss, es
            self.putx([0, ['Reset/presence: %s'
                           % ('true' if val else 'false')]])
            self.bytes = []
        elif code == 'ROM':
            self.ss, self.es = ss, es
            self.putx([0, ['ROM: 0x%016x (family code %s to 0x%02x)'
                           % (val, 'matches' if family_code == (val & 0xff)
                               else 'does not match', family_code),
                           'ROM: 0x%016x (family code %s)'
                           % (val, 'match' if family_code == (val & 0xff)
                               else 'mismatch')]])
            self.bytes = []
        elif code == 'DATA':
            self.bytes.append(val)
            if 1 == len(self.bytes):
                self.ss, self.es = ss, es
                if val not in commands:
                    self.putx([0, ['Unrecognized command: 0x%02x' % val]])
                else:
                    self.putx([0, ['Function command: %s (0x%02x)'
                                   % (commands[val], val)]])
            elif 0x0f == self.bytes[0]: # Write scratchpad
                if 2 == len(self.bytes):
                    self.ss = ss
                elif 3 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['Target address: 0x%04x'
                                   % ((self.bytes[2] << 8) + self.bytes[1])]])
                elif 4 == len(self.bytes):
                    self.ss = ss
                elif 11 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['Data: ' + (','.join(format(n, '#04x')
                                       for n in self.bytes[3:11]))]])
                elif 12 == len(self.bytes):
                    self.ss = ss
                elif 13 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['CRC: '
                        + ('ok' if crc16(self.bytes[0:11]) == (self.bytes[11]
                        + (self.bytes[12] << 8)) else 'error')]])
            elif 0xaa == self.bytes[0]: # Read scratchpad
                if 2 == len(self.bytes):
                    self.ss = ss
                elif 3 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['Target address: 0x%04x'
                                   % ((self.bytes[2] << 8) + self.bytes[1])]])
                elif 4 == len(self.bytes):
                    self.ss, self.es = ss, es
                    self.putx([0, ['Data status (E/S): 0x%02x'
                                   % (self.bytes[3])]])
                elif 5 == len(self.bytes):
                    self.ss = ss
                elif 12 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['Data: ' + (','.join(format(n, '#04x')
                                       for n in self.bytes[4:12]))]])
                elif 13 == len(self.bytes):
                    self.ss = ss
                elif 14 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['CRC: '
                        + ('ok' if crc16(self.bytes[0:12]) == (self.bytes[12]
                        + (self.bytes[13] << 8)) else 'error')]])
            elif 0x5a == self.bytes[0]: # Load first secret
                if 2 == len(self.bytes):
                    self.ss = ss
                elif 4 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['Authorization pattern (TA1, TA2, E/S): '
                        + (','.join(format(n, '#04x')
                            for n in self.bytes[1:4]))]])
                elif 4 < len(self.bytes):
                    self.ss, self.es = ss, es
                    if (0xaa == self.bytes[-1] or 0x55 == self.bytes[-1]):
                        self.putx([0, ['End of operation']])
            elif 0x33 == self.bytes[0]: # Compute next secret
                if 2 == len(self.bytes):
                    self.ss = ss
                elif 3 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['Target address: 0x%04x'
                                   % ((self.bytes[2] << 8) + self.bytes[1])]])
                elif 3 < len(self.bytes):
                    self.ss, self.es = ss, es
                    if (0xaa == self.bytes[-1] or 0x55 == self.bytes[-1]):
                        self.putx([0, ['End of operation']])
            elif 0x55 == self.bytes[0]: # Copy scratchpad
                if 2 == len(self.bytes):
                    self.ss = ss
                elif 4 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['Authorization pattern (TA1, TA2, E/S): '
                        + (','.join(format(n, '#04x')
                            for n in self.bytes[1:4]))]])
                elif 5 == len(self.bytes):
                    self.ss = ss
                elif 24 == len(self.bytes):
                    self.es = es
                    mac = ','.join(format(n, '#04x') for n in self.bytes[4:24])
                    self.putx([0, ['Message authentication code: ' + mac,
                                   'MAC: ' + mac]])
                elif 24 < len(self.bytes):
                    self.ss, self.es = ss, es
                    if (0xaa == self.bytes[-1] or 0x55 == self.bytes[-1]):
                        self.putx([0, ['Operation succeeded']])
                    elif (0 == self.bytes[-1]):
                        self.putx([0, ['Operation failed']])
            elif 0xa5 == self.bytes[0]: # Read authenticated page
                if 2 == len(self.bytes):
                    self.ss = ss
                elif 3 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['Target address: 0x%04x'
                                   % ((self.bytes[2] << 8) + self.bytes[1])]])
                elif 4 == len(self.bytes):
                    self.ss = ss
                elif 35 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['Data: ' + (','.join(format(n, '#04x')
                                       for n in self.bytes[3:35]))]])
                elif 36 == len(self.bytes):
                    self.ss, self.es = ss, es
                    self.putx([0, ['Padding: '
                        + ('ok' if 0xff == self.bytes[-1] else 'error')]])
                elif 37 == len(self.bytes):
                    self.ss = ss
                elif 38 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['CRC: '
                        + ('ok' if crc16(self.bytes[0:36]) == (self.bytes[36]
                        + (self.bytes[37] << 8)) else 'error')]])
                elif 39 == len(self.bytes):
                    self.ss = ss
                elif 58 == len(self.bytes):
                    self.es = es
                    mac = ','.join(format(n, '#04x') for n in self.bytes[38:58])
                    self.putx([0, ['Message authentication code: ' + mac,
                                   'MAC: ' + mac]])
                elif 59 == len(self.bytes):
                    self.ss = ss
                elif 60 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['MAC CRC: '
                        + ('ok' if crc16(self.bytes[38:58]) == (self.bytes[58]
                        + (self.bytes[59] << 8)) else 'error')]])
                elif 60 < len(self.bytes):
                    self.ss, self.es = ss, es
                    if (0xaa == self.bytes[-1] or 0x55 == self.bytes[-1]):
                        self.putx([0, ['Operation completed']])
            elif 0xf0 == self.bytes[0]: # Read memory
                if 2 == len(self.bytes):
                    self.ss = ss
                elif 3 == len(self.bytes):
                    self.es = es
                    self.putx([0, ['Target address: 0x%04x'
                                   % ((self.bytes[2] << 8) + self.bytes[1])]])
                elif 3 < len(self.bytes):
                    self.ss, self.es = ss, es
                    self.putx([0, ['Data: 0x%02x' % (self.bytes[-1])]])
Commit	Line	Data
444960cc KR	1	##
	2	## This file is part of the libsigrokdecode project.
	3	##
	4	## Copyright (C) 2017 Kevin Redon <kingkevin@cuvoodoo.info>
	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 2 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
	21
	22	# Dictionary of FUNCTION commands and their names.
	23	commands = {
	24	0x0f: 'Write scratchpad',
	25	0xaa: 'Read scratchpad',
	26	0x55: 'Copy scratchpad',
	27	0xf0: 'Read memory',
	28	0x5a: 'Load first secret',
	29	0x33: 'Compute next secret',
	30	0xa5: 'Read authenticated page',
	31	}
	32
	33	# Maxim DS2432 family code, present at the end of the ROM code.
	34	family_code = 0x33
	35
	36	# Calculate the CRC-16 checksum.
	37	# Initial value: 0x0000, xor-in: 0x0000, polynom 0x8005, xor-out: 0xffff.
	38	def crc16(byte_array):
	39	reverse = 0xa001 # Use the reverse polynom to make algo simpler.
	40	crc = 0x0000 # Initial value.
	41	# Reverse CRC calculation.
	42	for byte in byte_array:
	43	for bit in range(8):
	44	if (byte ^ crc) & 1:
	45	crc = (crc >> 1) ^ reverse
	46	else:
	47	crc >>= 1
	48	byte >>= 1
	49	crc ^= 0xffff # Invert CRC.
	50	return crc
	51
	52	class Decoder(srd.Decoder):
	53	api_version = 3
	54	id = 'ds2432'
	55	name = 'DS2432'
	56	longname = 'Maxim DS2432 1-Wire 1k-Bit Protected EEPROM with SHA-1 Engine'
	57	desc = '1-Wire 1k-Bit Protected EEPROM with SHA-1 Engine.'
	58	license = 'gplv2+'
	59	inputs = ['onewire_network']
	60	outputs = ['ds2432']
	61	annotations = (
	62	('text', 'Human-readable text'),
	63	)
	64
65	def __init__(self):
66	# Bytes for function command.
67	self.bytes = []
68
69	def start(self):
70	self.out_ann = self.register(srd.OUTPUT_ANN)
71
72	def putx(self, data):
73	self.put(self.ss, self.es, self.out_ann, data)
74
75	def decode(self, ss, es, data):
76	code, val = data
77
78	if code == 'RESET/PRESENCE':
79	self.ss, self.es = ss, es
80	self.putx([0, ['Reset/presence: %s'
81	% ('true' if val else 'false')]])
82	self.bytes = []
83	elif code == 'ROM':
84	self.ss, self.es = ss, es
85	self.putx([0, ['ROM: 0x%016x (family code %s to 0x%02x)'
86	% (val, 'matches' if family_code == (val & 0xff)
87	else 'does not match', family_code),
88	'ROM: 0x%016x (family code %s)'
89	% (val, 'match' if family_code == (val & 0xff)
90	else 'mismatch')]])
91	self.bytes = []
92	elif code == 'DATA':
93	self.bytes.append(val)
94	if 1 == len(self.bytes):
95	self.ss, self.es = ss, es
96	if val not in commands:
97	self.putx([0, ['Unrecognized command: 0x%02x' % val]])
98	else:
99	self.putx([0, ['Function command: %s (0x%02x)'
100	% (commands[val], val)]])
101	elif 0x0f == self.bytes[0]: # Write scratchpad
102	if 2 == len(self.bytes):
103	self.ss = ss
104	elif 3 == len(self.bytes):
105	self.es = es
106	self.putx([0, ['Target address: 0x%04x'
107	% ((self.bytes[2] << 8) + self.bytes[1])]])
108	elif 4 == len(self.bytes):
109	self.ss = ss
110	elif 11 == len(self.bytes):
111	self.es = es
112	self.putx([0, ['Data: ' + (','.join(format(n, '#04x')
113	for n in self.bytes[3:11]))]])
114	elif 12 == len(self.bytes):
115	self.ss = ss
116	elif 13 == len(self.bytes):
117	self.es = es
118	self.putx([0, ['CRC: '
119	+ ('ok' if crc16(self.bytes[0:11]) == (self.bytes[11]
120	+ (self.bytes[12] << 8)) else 'error')]])
121	elif 0xaa == self.bytes[0]: # Read scratchpad
122	if 2 == len(self.bytes):
123	self.ss = ss
124	elif 3 == len(self.bytes):
125	self.es = es
126	self.putx([0, ['Target address: 0x%04x'
127	% ((self.bytes[2] << 8) + self.bytes[1])]])
128	elif 4 == len(self.bytes):
129	self.ss, self.es = ss, es
130	self.putx([0, ['Data status (E/S): 0x%02x'
131	% (self.bytes[3])]])
132	elif 5 == len(self.bytes):
133	self.ss = ss
134	elif 12 == len(self.bytes):
135	self.es = es
136	self.putx([0, ['Data: ' + (','.join(format(n, '#04x')
137	for n in self.bytes[4:12]))]])
138	elif 13 == len(self.bytes):
139	self.ss = ss
140	elif 14 == len(self.bytes):
141	self.es = es
142	self.putx([0, ['CRC: '
143	+ ('ok' if crc16(self.bytes[0:12]) == (self.bytes[12]
144	+ (self.bytes[13] << 8)) else 'error')]])
145	elif 0x5a == self.bytes[0]: # Load first secret
146	if 2 == len(self.bytes):
147	self.ss = ss
148	elif 4 == len(self.bytes):
149	self.es = es
150	self.putx([0, ['Authorization pattern (TA1, TA2, E/S): '
151	+ (','.join(format(n, '#04x')
152	for n in self.bytes[1:4]))]])
153	elif 4 < len(self.bytes):
154	self.ss, self.es = ss, es
155	if (0xaa == self.bytes[-1] or 0x55 == self.bytes[-1]):
156	self.putx([0, ['End of operation']])
157	elif 0x33 == self.bytes[0]: # Compute next secret
158	if 2 == len(self.bytes):
159	self.ss = ss
160	elif 3 == len(self.bytes):
161	self.es = es
162	self.putx([0, ['Target address: 0x%04x'
163	% ((self.bytes[2] << 8) + self.bytes[1])]])
164	elif 3 < len(self.bytes):
165	self.ss, self.es = ss, es
166	if (0xaa == self.bytes[-1] or 0x55 == self.bytes[-1]):
167	self.putx([0, ['End of operation']])
168	elif 0x55 == self.bytes[0]: # Copy scratchpad
169	if 2 == len(self.bytes):
170	self.ss = ss
171	elif 4 == len(self.bytes):
172	self.es = es
173	self.putx([0, ['Authorization pattern (TA1, TA2, E/S): '
174	+ (','.join(format(n, '#04x')
175	for n in self.bytes[1:4]))]])
176	elif 5 == len(self.bytes):
177	self.ss = ss
178	elif 24 == len(self.bytes):
179	self.es = es
3a9f6abf UH	180	mac = ','.join(format(n, '#04x') for n in self.bytes[4:24])
	181	self.putx([0, ['Message authentication code: ' + mac,
	182	'MAC: ' + mac]])
444960cc KR	183	elif 24 < len(self.bytes):
	184	self.ss, self.es = ss, es
	185	if (0xaa == self.bytes[-1] or 0x55 == self.bytes[-1]):
	186	self.putx([0, ['Operation succeeded']])
	187	elif (0 == self.bytes[-1]):
	188	self.putx([0, ['Operation failed']])
	189	elif 0xa5 == self.bytes[0]: # Read authenticated page
	190	if 2 == len(self.bytes):
	191	self.ss = ss
	192	elif 3 == len(self.bytes):
	193	self.es = es
	194	self.putx([0, ['Target address: 0x%04x'
	195	% ((self.bytes[2] << 8) + self.bytes[1])]])
	196	elif 4 == len(self.bytes):
	197	self.ss = ss
	198	elif 35 == len(self.bytes):
	199	self.es = es
	200	self.putx([0, ['Data: ' + (','.join(format(n, '#04x')
	201	for n in self.bytes[3:35]))]])
	202	elif 36 == len(self.bytes):
	203	self.ss, self.es = ss, es
	204	self.putx([0, ['Padding: '
	205	+ ('ok' if 0xff == self.bytes[-1] else 'error')]])
	206	elif 37 == len(self.bytes):
	207	self.ss = ss
	208	elif 38 == len(self.bytes):
	209	self.es = es
	210	self.putx([0, ['CRC: '
	211	+ ('ok' if crc16(self.bytes[0:36]) == (self.bytes[36]
	212	+ (self.bytes[37] << 8)) else 'error')]])
	213	elif 39 == len(self.bytes):
	214	self.ss = ss
	215	elif 58 == len(self.bytes):
	216	self.es = es
3a9f6abf UH	217	mac = ','.join(format(n, '#04x') for n in self.bytes[38:58])
	218	self.putx([0, ['Message authentication code: ' + mac,
	219	'MAC: ' + mac]])
444960cc KR	220	elif 59 == len(self.bytes):
	221	self.ss = ss
	222	elif 60 == len(self.bytes):
	223	self.es = es
	224	self.putx([0, ['MAC CRC: '
	225	+ ('ok' if crc16(self.bytes[38:58]) == (self.bytes[58]
	226	+ (self.bytes[59] << 8)) else 'error')]])
	227	elif 60 < len(self.bytes):
	228	self.ss, self.es = ss, es
	229	if (0xaa == self.bytes[-1] or 0x55 == self.bytes[-1]):
	230	self.putx([0, ['Operation completed']])
	231	elif 0xf0 == self.bytes[0]: # Read memory
	232	if 2 == len(self.bytes):
	233	self.ss = ss
	234	elif 3 == len(self.bytes):
	235	self.es = es
	236	self.putx([0, ['Target address: 0x%04x'
	237	% ((self.bytes[2] << 8) + self.bytes[1])]])
	238	elif 3 < len(self.bytes):
	239	self.ss, self.es = ss, es
	240	self.putx([0, ['Data: 0x%02x' % (self.bytes[-1])]])