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

##
## This file is part of the libsigrokdecode project.
##
## Copyright (C) 2018 Michalis Pappas <mpappas@fastmail.fm>
##
## 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

WORD_ADDR_RESET         = 0x00
WORD_ADDR_SLEEP         = 0x01
WORD_ADDR_IDLE          = 0x02
WORD_ADDR_COMMAND       = 0x03

WORD_ADDR = {0x00: 'RESET', 0x01: 'SLEEP', 0x02: 'IDLE', 0x03: 'COMMAND'}

OPCODE_DERIVE_KEY       = 0x1c
OPCODE_DEV_REV          = 0x30
OPCODE_GEN_DIG          = 0x15
OPCODE_HMAC             = 0x11
OPCODE_CHECK_MAC        = 0x28
OPCODE_LOCK             = 0x17
OPCODE_MAC              = 0x08
OPCODE_NONCE            = 0x16
OPCODE_PAUSE            = 0x01
OPCODE_RANDOM           = 0x1b
OPCODE_READ             = 0x02
OPCODE_SHA              = 0x47
OPCODE_UPDATE_EXTRA     = 0x20
OPCODE_WRITE            = 0x12

OPCODES = {
    0x01: 'Pause',
    0x02: 'Read',
    0x08: 'MAC',
    0x11: 'HMAC',
    0x12: 'Write',
    0x15: 'GenDig',
    0x16: 'Nonce',
    0x17: 'Lock',
    0x1b: 'Random',
    0x1c: 'DeriveKey',
    0x20: 'UpdateExtra',
    0x28: 'CheckMac',
    0x30: 'DevRev',
    0x47: 'SHA',
}

ZONE_CONFIG             = 0x00
ZONE_OTP                = 0x01
ZONE_DATA               = 0x02

ZONES = {0x00: 'CONFIG', 0x01: 'OTP', 0x02: 'DATA'}

STATUS_SUCCESS          = 0x00
STATUS_CHECKMAC_FAIL    = 0x01
STATUS_PARSE_ERROR      = 0x03
STATUS_EXECUTION_ERROR  = 0x0f
STATUS_READY            = 0x11
STATUS_CRC_COMM_ERROR   = 0xff

STATUS = {
    0x00: 'Command success',
    0x01: 'Checkmac failure',
    0x03: 'Parse error',
    0x0f: 'Execution error',
    0x11: 'Ready',
    0xff: 'CRC / communications error',
}

class Decoder(srd.Decoder):
    api_version = 3
    id = 'atsha204a'
    name = 'ATSHA204A'
    longname = 'Microchip ATSHA204A'
    desc = 'Microchip ATSHA204A CryptoAuthentication device.'
    license = 'gplv2+'
    inputs = ['i2c']
    outputs = ['atsha204a']
    tags = ['Security/crypto', 'IC', 'Memory']
    annotations = (
        ('waddr', 'Word address'),
        ('count', 'Count'),
        ('opcode', 'Opcode'),
        ('param1', 'Param1'),
        ('param2', 'Param2'),
        ('data', 'Data'),
        ('crc', 'CRC'),
        ('status', 'Status'),
        ('warning', 'Warning'),
    )
    annotation_rows = (
        ('frame', 'Frame', (0, 1, 2, 3, 4, 5, 6)),
        ('status', 'Status', (7,)),
        ('warnings', 'Warnings', (8,)),
    )

    def __init__(self):
        self.reset()

    def reset(self):
        self.state = 'IDLE'
        self.waddr = self.opcode = -1
        self.ss_block = self.es_block = 0
        self.bytes = []

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

    def output_tx_bytes(self):
        b = self.bytes
        if len(b) < 1: # Ignore wakeup.
            return
        self.waddr = b[0][2]
        self.put_waddr(b[0])
        if self.waddr == WORD_ADDR_COMMAND:
            count = b[1][2]
            self.put_count(b[1])
            if len(b) - 1 != count:
                self.put_warning(b[0][0], b[-1][1],
                    'Invalid frame length: Got {}, expecting {} '.format(
                    len(b) - 1, count))
                return
            self.opcode = b[2][2]
            self.put_opcode(b[2])
            self.put_param1(b[3])
            self.put_param2([b[4], b[5]])
            self.put_data(b[6:-2])
            self.put_crc([b[-2], b[-1]])

    def output_rx_bytes(self):
        b = self.bytes
        count = b[0][2]
        self.put_count(b[0])
        if self.waddr == WORD_ADDR_RESET:
            self.put_data([b[1]])
            self.put_crc([b[2], b[3]])
            self.put_status(b[0][0], b[-1][1], b[1][2])
        elif self.waddr == WORD_ADDR_COMMAND:
            if count == 4: # Status / Error.
                self.put_data([b[1]])
                self.put_crc([b[2], b[3]])
                self.put_status(b[0][0], b[-1][1], b[1][2])
            else:
                self.put_data(b[1:-2])
                self.put_crc([b[-2], b[-1]])

    def putx(self, s, data):
        self.put(s[0], s[1], self.out_ann, data)

    def puty(self, s, data):
        self.put(s[0][0], s[1][1], self.out_ann, data)

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

    def put_waddr(self, s):
        self.putx(s, [0, ['Word addr: %s' % WORD_ADDR[s[2]]]])

    def put_count(self, s):
        self.putx(s, [1, ['Count: %s' % s[2]]])

    def put_opcode(self, s):
        self.putx(s, [2, ['Opcode: %s' % OPCODES[s[2]]]])

    def put_param1(self, s):
        op = self.opcode
        if op in (OPCODE_CHECK_MAC, OPCODE_DEV_REV, OPCODE_HMAC, \
                OPCODE_MAC, OPCODE_NONCE, OPCODE_RANDOM, OPCODE_SHA):
            self.putx(s, [3, ['Mode: %02X' % s[2]]])
        elif op == OPCODE_DERIVE_KEY:
            self.putx(s, [3, ['Random: %s' % s[2]]])
        elif op == OPCODE_GEN_DIG:
            self.putx(s, [3, ['Zone: %s' % ZONES[s[2]]]])
        elif op == OPCODE_LOCK:
            self.putx(s, [3, ['Zone: {}, Summary: {}'.format(
                'DATA/OTP' if s[2] else 'CONFIG',
                'Ignored' if s[2] & 0x80 else 'Used')]])
        elif op == OPCODE_PAUSE:
            self.putx(s, [3, ['Selector: %02X' % s[2]]])
        elif op == OPCODE_READ:
            self.putx(s, [3, ['Zone: {}, Length: {}'.format(ZONES[s[2] & 0x03],
                '32 bytes' if s[2] & 0x90 else '4 bytes')]])
        elif op == OPCODE_WRITE:
            self.putx(s, [3, ['Zone: {}, Encrypted: {}, Length: {}'.format(ZONES[s[2] & 0x03],
                'Yes' if s[2] & 0x40 else 'No', '32 bytes' if s[2] & 0x90 else '4 bytes')]])
        else:
            self.putx(s, [3, ['Param1: %02X' % s[2]]])

    def put_param2(self, s):
        op = self.opcode
        if op == OPCODE_DERIVE_KEY:
            self.puty(s, [4, ['TargetKey: {:02x} {:02x}'.format(s[1][2], s[0][2])]])
        elif op in (OPCODE_NONCE, OPCODE_PAUSE, OPCODE_RANDOM):
            self.puty(s, [4, ['Zero: {:02x} {:02x}'.format(s[1][2], s[0][2])]])
        elif op in (OPCODE_HMAC, OPCODE_MAC, OPCODE_CHECK_MAC, OPCODE_GEN_DIG):
            self.puty(s, [4, ['SlotID: {:02x} {:02x}'.format(s[1][2], s[0][2])]])
        elif op == OPCODE_LOCK:
            self.puty(s, [4, ['Summary: {:02x} {:02x}'.format(s[1][2], s[0][2])]])
        elif op in (OPCODE_READ, OPCODE_WRITE):
            self.puty(s, [4, ['Address: {:02x} {:02x}'.format(s[1][2], s[0][2])]])
        elif op == OPCODE_UPDATE_EXTRA:
            self.puty(s, [4, ['NewValue: {:02x}'.format(s[0][2])]])
        else:
            self.puty(s, [4, ['-']])

    def put_data(self, s):
        if len(s) == 0:
            return
        op = self.opcode
        if op == OPCODE_CHECK_MAC:
            self.putz(s[0][0], s[31][1], [5, ['ClientChal: %s' % ' '.join(format(i[2], '02x') for i in s[0:31])]])
            self.putz(s[32][0], s[63][1], [5, ['ClientResp: %s' % ' '.join(format(i[2], '02x') for i in s[32:63])]])
            self.putz(s[64][0], s[76][1], [5, ['OtherData: %s' % ' '.join(format(i[2], '02x') for i in s[64:76])]])
        elif op == OPCODE_DERIVE_KEY:
            self.putz(s[0][0], s[31][1], [5, ['MAC: %s' % ' '.join(format(i[2], '02x') for i in s)]])
        elif op == OPCODE_GEN_DIG:
            self.putz(s[0][0], s[3][1], [5, ['OtherData: %s' % ' '.join(format(i[2], '02x') for i in s)]])
        elif op == OPCODE_MAC:
            self.putz(s[0][0], s[31][1], [5, ['Challenge: %s' % ' '.join(format(i[2], '02x') for i in s)]])
        elif op == OPCODE_WRITE:
            if len(s) > 32: # Value + MAC.
                self.putz(s[0][0], s[-31][1], [5, ['Value: %s' % ' '.join(format(i[2], '02x') for i in s)]])
                self.putz(s[-32][0], s[-1][1], [5, ['MAC: %s' % ' '.join(format(i[2], '02x') for i in s)]])
            else: # Just value.
                self.putz(s[0][0], s[-1][1], [5, ['Value: %s' % ' '.join(format(i[2], '02x') for i in s)]])
        else:
            self.putz(s[0][0], s[-1][1], [5, ['Data: %s' % ' '.join(format(i[2], '02x') for i in s)]])

    def put_crc(self, s):
        self.puty(s, [6, ['CRC: {:02X} {:02X}'.format(s[0][2], s[1][2])]])

    def put_status(self, ss, es, status):
        self.putz(ss, es, [7, ['Status: %s' % STATUS[status]]])

    def put_warning(self, ss, es, msg):
        self.putz(ss, es, [8, ['Warning: %s' % msg]])

    def decode(self, ss, es, data):
        cmd, databyte = data

        # State machine.
        if self.state == 'IDLE':
            # Wait for an I²C START condition.
            if cmd != 'START':
                return
            self.state = 'GET SLAVE ADDR'
            self.ss_block = ss
        elif self.state == 'GET SLAVE ADDR':
            # Wait for an address read/write operation.
            if cmd == 'ADDRESS READ':
                self.state = 'READ REGS'
            elif cmd == 'ADDRESS WRITE':
                self.state = 'WRITE REGS'
        elif self.state == 'READ REGS':
            if cmd == 'DATA READ':
                self.bytes.append([ss, es, databyte])
            elif cmd == 'STOP':
                self.es_block = es
                # Reset the opcode before received data, as this causes
                # responses to be displayed incorrectly.
                self.opcode = -1
                self.output_rx_bytes()
                self.waddr = -1
                self.bytes = []
                self.state = 'IDLE'
        elif self.state == 'WRITE REGS':
            if cmd == 'DATA WRITE':
                self.bytes.append([ss, es, databyte])
            elif cmd == 'STOP':
                self.es_block = es
                self.output_tx_bytes()
                self.bytes = []
                self.state = 'IDLE'
Commit	Line	Data
	1	##
	2	## This file is part of the libsigrokdecode project.
	3	##
	4	## Copyright (C) 2018 Michalis Pappas <mpappas@fastmail.fm>
	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	WORD_ADDR_RESET = 0x00
	23	WORD_ADDR_SLEEP = 0x01
	24	WORD_ADDR_IDLE = 0x02
	25	WORD_ADDR_COMMAND = 0x03
	26
	27	WORD_ADDR = {0x00: 'RESET', 0x01: 'SLEEP', 0x02: 'IDLE', 0x03: 'COMMAND'}
	28
	29	OPCODE_DERIVE_KEY = 0x1c
	30	OPCODE_DEV_REV = 0x30
	31	OPCODE_GEN_DIG = 0x15
	32	OPCODE_HMAC = 0x11
	33	OPCODE_CHECK_MAC = 0x28
	34	OPCODE_LOCK = 0x17
	35	OPCODE_MAC = 0x08
	36	OPCODE_NONCE = 0x16
	37	OPCODE_PAUSE = 0x01
	38	OPCODE_RANDOM = 0x1b
	39	OPCODE_READ = 0x02
	40	OPCODE_SHA = 0x47
	41	OPCODE_UPDATE_EXTRA = 0x20
	42	OPCODE_WRITE = 0x12
	43
	44	OPCODES = {
	45	0x01: 'Pause',
	46	0x02: 'Read',
	47	0x08: 'MAC',
	48	0x11: 'HMAC',
	49	0x12: 'Write',
	50	0x15: 'GenDig',
	51	0x16: 'Nonce',
	52	0x17: 'Lock',
	53	0x1b: 'Random',
	54	0x1c: 'DeriveKey',
	55	0x20: 'UpdateExtra',
	56	0x28: 'CheckMac',
	57	0x30: 'DevRev',
	58	0x47: 'SHA',
	59	}
	60
	61	ZONE_CONFIG = 0x00
	62	ZONE_OTP = 0x01
	63	ZONE_DATA = 0x02
	64
	65	ZONES = {0x00: 'CONFIG', 0x01: 'OTP', 0x02: 'DATA'}
	66
	67	STATUS_SUCCESS = 0x00
	68	STATUS_CHECKMAC_FAIL = 0x01
	69	STATUS_PARSE_ERROR = 0x03
	70	STATUS_EXECUTION_ERROR = 0x0f
	71	STATUS_READY = 0x11
	72	STATUS_CRC_COMM_ERROR = 0xff
	73
	74	STATUS = {
	75	0x00: 'Command success',
	76	0x01: 'Checkmac failure',
	77	0x03: 'Parse error',
	78	0x0f: 'Execution error',
	79	0x11: 'Ready',
	80	0xff: 'CRC / communications error',
	81	}
	82
	83	class Decoder(srd.Decoder):
	84	api_version = 3
	85	id = 'atsha204a'
	86	name = 'ATSHA204A'
	87	longname = 'Microchip ATSHA204A'
	88	desc = 'Microchip ATSHA204A CryptoAuthentication device.'
	89	license = 'gplv2+'
	90	inputs = ['i2c']
	91	outputs = ['atsha204a']
	92	tags = ['Security/crypto', 'IC', 'Memory']
	93	annotations = (
	94	('waddr', 'Word address'),
	95	('count', 'Count'),
	96	('opcode', 'Opcode'),
	97	('param1', 'Param1'),
	98	('param2', 'Param2'),
	99	('data', 'Data'),
	100	('crc', 'CRC'),
	101	('status', 'Status'),
	102	('warning', 'Warning'),
	103	)
	104	annotation_rows = (
	105	('frame', 'Frame', (0, 1, 2, 3, 4, 5, 6)),
	106	('status', 'Status', (7,)),
	107	('warnings', 'Warnings', (8,)),
	108	)
	109
	110	def __init__(self):
	111	self.reset()
	112
	113	def reset(self):
	114	self.state = 'IDLE'
	115	self.waddr = self.opcode = -1
	116	self.ss_block = self.es_block = 0
	117	self.bytes = []
	118
	119	def start(self):
	120	self.out_ann = self.register(srd.OUTPUT_ANN)
	121
	122	def output_tx_bytes(self):
	123	b = self.bytes
	124	if len(b) < 1: # Ignore wakeup.
	125	return
	126	self.waddr = b[0][2]
	127	self.put_waddr(b[0])
	128	if self.waddr == WORD_ADDR_COMMAND:
	129	count = b[1][2]
	130	self.put_count(b[1])
	131	if len(b) - 1 != count:
	132	self.put_warning(b[0][0], b[-1][1],
	133	'Invalid frame length: Got {}, expecting {} '.format(
	134	len(b) - 1, count))
	135	return
	136	self.opcode = b[2][2]
	137	self.put_opcode(b[2])
	138	self.put_param1(b[3])
	139	self.put_param2([b[4], b[5]])
	140	self.put_data(b[6:-2])
	141	self.put_crc([b[-2], b[-1]])
	142
	143	def output_rx_bytes(self):
	144	b = self.bytes
	145	count = b[0][2]
	146	self.put_count(b[0])
	147	if self.waddr == WORD_ADDR_RESET:
	148	self.put_data([b[1]])
	149	self.put_crc([b[2], b[3]])
	150	self.put_status(b[0][0], b[-1][1], b[1][2])
	151	elif self.waddr == WORD_ADDR_COMMAND:
	152	if count == 4: # Status / Error.
	153	self.put_data([b[1]])
	154	self.put_crc([b[2], b[3]])
	155	self.put_status(b[0][0], b[-1][1], b[1][2])
	156	else:
	157	self.put_data(b[1:-2])
	158	self.put_crc([b[-2], b[-1]])
	159
	160	def putx(self, s, data):
	161	self.put(s[0], s[1], self.out_ann, data)
	162
	163	def puty(self, s, data):
	164	self.put(s[0][0], s[1][1], self.out_ann, data)
	165
	166	def putz(self, ss, es, data):
	167	self.put(ss, es, self.out_ann, data)
	168
	169	def put_waddr(self, s):
	170	self.putx(s, [0, ['Word addr: %s' % WORD_ADDR[s[2]]]])
	171
	172	def put_count(self, s):
	173	self.putx(s, [1, ['Count: %s' % s[2]]])
	174
	175	def put_opcode(self, s):
	176	self.putx(s, [2, ['Opcode: %s' % OPCODES[s[2]]]])
	177
	178	def put_param1(self, s):
	179	op = self.opcode
	180	if op in (OPCODE_CHECK_MAC, OPCODE_DEV_REV, OPCODE_HMAC, \
	181	OPCODE_MAC, OPCODE_NONCE, OPCODE_RANDOM, OPCODE_SHA):
	182	self.putx(s, [3, ['Mode: %02X' % s[2]]])
	183	elif op == OPCODE_DERIVE_KEY:
	184	self.putx(s, [3, ['Random: %s' % s[2]]])
	185	elif op == OPCODE_GEN_DIG:
	186	self.putx(s, [3, ['Zone: %s' % ZONES[s[2]]]])
	187	elif op == OPCODE_LOCK:
	188	self.putx(s, [3, ['Zone: {}, Summary: {}'.format(
	189	'DATA/OTP' if s[2] else 'CONFIG',
	190	'Ignored' if s[2] & 0x80 else 'Used')]])
	191	elif op == OPCODE_PAUSE:
	192	self.putx(s, [3, ['Selector: %02X' % s[2]]])
	193	elif op == OPCODE_READ:
	194	self.putx(s, [3, ['Zone: {}, Length: {}'.format(ZONES[s[2] & 0x03],
	195	'32 bytes' if s[2] & 0x90 else '4 bytes')]])
	196	elif op == OPCODE_WRITE:
	197	self.putx(s, [3, ['Zone: {}, Encrypted: {}, Length: {}'.format(ZONES[s[2] & 0x03],
	198	'Yes' if s[2] & 0x40 else 'No', '32 bytes' if s[2] & 0x90 else '4 bytes')]])
	199	else:
	200	self.putx(s, [3, ['Param1: %02X' % s[2]]])
	201
	202	def put_param2(self, s):
	203	op = self.opcode
	204	if op == OPCODE_DERIVE_KEY:
	205	self.puty(s, [4, ['TargetKey: {:02x} {:02x}'.format(s[1][2], s[0][2])]])
	206	elif op in (OPCODE_NONCE, OPCODE_PAUSE, OPCODE_RANDOM):
	207	self.puty(s, [4, ['Zero: {:02x} {:02x}'.format(s[1][2], s[0][2])]])
	208	elif op in (OPCODE_HMAC, OPCODE_MAC, OPCODE_CHECK_MAC, OPCODE_GEN_DIG):
	209	self.puty(s, [4, ['SlotID: {:02x} {:02x}'.format(s[1][2], s[0][2])]])
	210	elif op == OPCODE_LOCK:
	211	self.puty(s, [4, ['Summary: {:02x} {:02x}'.format(s[1][2], s[0][2])]])
	212	elif op in (OPCODE_READ, OPCODE_WRITE):
	213	self.puty(s, [4, ['Address: {:02x} {:02x}'.format(s[1][2], s[0][2])]])
	214	elif op == OPCODE_UPDATE_EXTRA:
	215	self.puty(s, [4, ['NewValue: {:02x}'.format(s[0][2])]])
	216	else:
	217	self.puty(s, [4, ['-']])
	218
	219	def put_data(self, s):
	220	if len(s) == 0:
	221	return
	222	op = self.opcode
	223	if op == OPCODE_CHECK_MAC:
	224	self.putz(s[0][0], s[31][1], [5, ['ClientChal: %s' % ' '.join(format(i[2], '02x') for i in s[0:31])]])
	225	self.putz(s[32][0], s[63][1], [5, ['ClientResp: %s' % ' '.join(format(i[2], '02x') for i in s[32:63])]])
	226	self.putz(s[64][0], s[76][1], [5, ['OtherData: %s' % ' '.join(format(i[2], '02x') for i in s[64:76])]])
	227	elif op == OPCODE_DERIVE_KEY:
	228	self.putz(s[0][0], s[31][1], [5, ['MAC: %s' % ' '.join(format(i[2], '02x') for i in s)]])
	229	elif op == OPCODE_GEN_DIG:
	230	self.putz(s[0][0], s[3][1], [5, ['OtherData: %s' % ' '.join(format(i[2], '02x') for i in s)]])
	231	elif op == OPCODE_MAC:
	232	self.putz(s[0][0], s[31][1], [5, ['Challenge: %s' % ' '.join(format(i[2], '02x') for i in s)]])
	233	elif op == OPCODE_WRITE:
	234	if len(s) > 32: # Value + MAC.
	235	self.putz(s[0][0], s[-31][1], [5, ['Value: %s' % ' '.join(format(i[2], '02x') for i in s)]])
	236	self.putz(s[-32][0], s[-1][1], [5, ['MAC: %s' % ' '.join(format(i[2], '02x') for i in s)]])
	237	else: # Just value.
	238	self.putz(s[0][0], s[-1][1], [5, ['Value: %s' % ' '.join(format(i[2], '02x') for i in s)]])
	239	else:
	240	self.putz(s[0][0], s[-1][1], [5, ['Data: %s' % ' '.join(format(i[2], '02x') for i in s)]])
	241
	242	def put_crc(self, s):
	243	self.puty(s, [6, ['CRC: {:02X} {:02X}'.format(s[0][2], s[1][2])]])
	244
	245	def put_status(self, ss, es, status):
	246	self.putz(ss, es, [7, ['Status: %s' % STATUS[status]]])
	247
	248	def put_warning(self, ss, es, msg):
	249	self.putz(ss, es, [8, ['Warning: %s' % msg]])
	250
	251	def decode(self, ss, es, data):
	252	cmd, databyte = data
	253
	254	# State machine.
	255	if self.state == 'IDLE':
	256	# Wait for an I²C START condition.
	257	if cmd != 'START':
	258	return
	259	self.state = 'GET SLAVE ADDR'
	260	self.ss_block = ss
	261	elif self.state == 'GET SLAVE ADDR':
	262	# Wait for an address read/write operation.
	263	if cmd == 'ADDRESS READ':
	264	self.state = 'READ REGS'
	265	elif cmd == 'ADDRESS WRITE':
	266	self.state = 'WRITE REGS'
	267	elif self.state == 'READ REGS':
	268	if cmd == 'DATA READ':
	269	self.bytes.append([ss, es, databyte])
	270	elif cmd == 'STOP':
	271	self.es_block = es
	272	# Reset the opcode before received data, as this causes
	273	# responses to be displayed incorrectly.
	274	self.opcode = -1
	275	self.output_rx_bytes()
	276	self.waddr = -1
	277	self.bytes = []
	278	self.state = 'IDLE'
	279	elif self.state == 'WRITE REGS':
	280	if cmd == 'DATA WRITE':
	281	self.bytes.append([ss, es, databyte])
	282	elif cmd == 'STOP':
	283	self.es_block = es
	284	self.output_tx_bytes()
	285	self.bytes = []
	286	self.state = 'IDLE'
	287