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

##
## This file is part of the libsigrokdecode project.
##
## Copyright (C) 2012-2014 Uwe Hermann <uwe@hermann-uwe.de>
##
## 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, write to the Free Software
## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
##

import sigrokdecode as srd
from .parts import *

VENDOR_CODE_ATMEL = 0x1e

class Decoder(srd.Decoder):
    api_version = 1
    id = 'avr_isp'
    name = 'AVR ISP'
    longname = 'AVR In-System Programming'
    desc = 'Protocol for in-system programming Atmel AVR MCUs.'
    license = 'gplv2+'
    inputs = ['spi']
    outputs = ['avr_isp']
    annotations = (
        ('pe', 'Programming enable'),
        ('rsb0', 'Read signature byte 0'),
        ('rsb1', 'Read signature byte 1'),
        ('rsb2', 'Read signature byte 2'),
        ('ce', 'Chip erase'),
        ('rfb', 'Read fuse bits'),
        ('rhfb', 'Read high fuse bits'),
        ('refb', 'Read extended fuse bits'),
        ('warnings', 'Warnings'),
        ('dev', 'Device'),
    )
    annotation_rows = (
        ('bits', 'Bits', ()),
        ('commands', 'Commands', tuple(range(7 + 1))),
        ('warnings', 'Warnings', (8,)),
        ('dev', 'Device', (9,)),
    )

    def __init__(self, **kwargs):
        self.state = 'IDLE'
        self.mosi_bytes, self.miso_bytes = [], []
        self.cmd_ss, self.cmd_es = 0, 0
        self.xx, self.yy, self.zz, self.mm = 0, 0, 0, 0
        self.device_ss = None

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

    def putx(self, data):
        self.put(self.cmd_ss, self.cmd_es, self.out_ann, data)

    def handle_cmd_programming_enable(self, cmd, ret):
        # Programming enable.
        # Note: The chip doesn't send any ACK for 'Programming enable'.
        self.putx([0, ['Programming enable']])

        # Sanity check on reply.
        if ret[1:4] != [0xac, 0x53, cmd[2]]:
            self.putx([8, ['Warning: Unexpected bytes in reply!']])

    def handle_cmd_read_signature_byte_0x00(self, cmd, ret):
        # Signature byte 0x00: vendor code.
        self.vendor_code = ret[3]
        v = vendor_code[self.vendor_code]
        self.putx([1, ['Vendor code: 0x%02x (%s)' % (ret[3], v)]])

        # Store for later.
        self.xx = cmd[1] # Same as ret[2].
        self.yy = cmd[3]
        self.zz = ret[0]

        # Sanity check on reply.
        if ret[1] != 0x30 or ret[2] != cmd[1]:
            self.putx([8, ['Warning: Unexpected bytes in reply!']])

        # Sanity check for the vendor code.
        if self.vendor_code != VENDOR_CODE_ATMEL:
            self.putx([8, ['Warning: Vendor code was not 0x1e (Atmel)!']])

    def handle_cmd_read_signature_byte_0x01(self, cmd, ret):
        # Signature byte 0x01: part family and memory size.
        self.part_fam_flash_size = ret[3]
        self.putx([2, ['Part family / memory size: 0x%02x' % ret[3]]])

        # Store for later.
        self.mm = cmd[3]
        self.device_ss = self.cmd_ss

        # Sanity check on reply.
        if ret[1] != 0x30 or ret[2] != cmd[1] or ret[0] != self.yy:
            self.putx([8, ['Warning: Unexpected bytes in reply!']])

    def handle_cmd_read_signature_byte_0x02(self, cmd, ret):
        # Signature byte 0x02: part number.
        self.part_number = ret[3]
        self.putx([3, ['Part number: 0x%02x' % ret[3]]])

        p = part[(self.part_fam_flash_size, self.part_number)]
        data = [9, ['Device: Atmel %s' % p]]
        self.put(self.device_ss, self.cmd_es, self.out_ann, data)

        # Sanity check on reply.
        if ret[1] != 0x30 or ret[2] != self.xx or ret[0] != self.mm:
            self.putx([8, ['Warning: Unexpected bytes in reply!']])

        self.xx, self.yy, self.zz, self.mm = 0, 0, 0, 0

    def handle_cmd_chip_erase(self, cmd, ret):
        # Chip erase (erases both flash an EEPROM).
        # Upon successful chip erase, the lock bits will also be erased.
        # The only way to end a Chip Erase cycle is to release RESET#.
        self.putx([4, ['Chip erase']])

        # TODO: Check/handle RESET#.

        # Sanity check on reply.
        bit = (ret[2] & (1 << 7)) >> 7
        if ret[1] != 0xac or bit != 1 or ret[3] != cmd[2]:
            self.putx([8, ['Warning: Unexpected bytes in reply!']])

    def handle_cmd_read_fuse_bits(self, cmd, ret):
        # Read fuse bits.
        self.putx([5, ['Read fuse bits: 0x%02x' % ret[3]]])

        # TODO: Decode fuse bits.
        # TODO: Sanity check on reply.

    def handle_cmd_read_fuse_high_bits(self, cmd, ret):
        # Read fuse high bits.
        self.putx([6, ['Read fuse high bits: 0x%02x' % ret[3]]])

        # TODO: Decode fuse bits.
        # TODO: Sanity check on reply.

    def handle_cmd_read_extended_fuse_bits(self, cmd, ret):
        # Read extended fuse bits.
        self.putx([7, ['Read extended fuse bits: 0x%02x' % ret[3]]])

        # TODO: Decode fuse bits.
        # TODO: Sanity check on reply.

    def handle_command(self, cmd, ret):
        if cmd[:2] == [0xac, 0x53]:
            self.handle_cmd_programming_enable(cmd, ret)
        elif cmd[0] == 0xac and (cmd[1] & (1 << 7)) == (1 << 7):
            self.handle_cmd_chip_erase(cmd, ret)
        elif cmd[:3] == [0x50, 0x00, 0x00]:
            self.handle_cmd_read_fuse_bits(cmd, ret)
        elif cmd[:3] == [0x58, 0x08, 0x00]:
            self.handle_cmd_read_fuse_high_bits(cmd, ret)
        elif cmd[:3] == [0x50, 0x08, 0x00]:
            self.handle_cmd_read_extended_fuse_bits(cmd, ret)
        elif cmd[0] == 0x30 and cmd[2] == 0x00:
            self.handle_cmd_read_signature_byte_0x00(cmd, ret)
        elif cmd[0] == 0x30 and cmd[2] == 0x01:
            self.handle_cmd_read_signature_byte_0x01(cmd, ret)
        elif cmd[0] == 0x30 and cmd[2] == 0x02:
            self.handle_cmd_read_signature_byte_0x02(cmd, ret)
        else:
            c = '%02x %02x %02x %02x' % tuple(cmd)
            r = '%02x %02x %02x %02x' % tuple(ret)
            self.putx([0, ['Unknown command: %s (reply: %s)!' % (c, r)]])

    def decode(self, ss, es, data):
        ptype, mosi, miso = data

        # For now, only use DATA and BITS packets.
        if ptype not in ('DATA', 'BITS'):
            return

        # Store the individual bit values and ss/es numbers. The next packet
        # is guaranteed to be a 'DATA' packet belonging to this 'BITS' one.
        if ptype == 'BITS':
            self.miso_bits, self.mosi_bits = miso, mosi
            return

        self.ss, self.es = ss, es

        if len(self.mosi_bytes) == 0:
            self.cmd_ss = ss

        # Append new bytes.
        self.mosi_bytes.append(mosi)
        self.miso_bytes.append(miso)

        # All commands consist of 4 bytes.
        if len(self.mosi_bytes) < 4:
            return

        self.cmd_es = es

        self.handle_command(self.mosi_bytes, self.miso_bytes)

        self.mosi_bytes = []
        self.miso_bytes = []
Commit	Line	Data
	1	##
	2	## This file is part of the libsigrokdecode project.
	3	##
	4	## Copyright (C) 2012-2014 Uwe Hermann <uwe@hermann-uwe.de>
	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, write to the Free Software
	18	## Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	19	##
	20
	21	import sigrokdecode as srd
	22	from .parts import *
	23
	24	VENDOR_CODE_ATMEL = 0x1e
	25
	26	class Decoder(srd.Decoder):
	27	api_version = 1
	28	id = 'avr_isp'
	29	name = 'AVR ISP'
	30	longname = 'AVR In-System Programming'
	31	desc = 'Protocol for in-system programming Atmel AVR MCUs.'
	32	license = 'gplv2+'
	33	inputs = ['spi']
	34	outputs = ['avr_isp']
	35	annotations = (
	36	('pe', 'Programming enable'),
	37	('rsb0', 'Read signature byte 0'),
	38	('rsb1', 'Read signature byte 1'),
	39	('rsb2', 'Read signature byte 2'),
	40	('ce', 'Chip erase'),
	41	('rfb', 'Read fuse bits'),
	42	('rhfb', 'Read high fuse bits'),
	43	('refb', 'Read extended fuse bits'),
	44	('warnings', 'Warnings'),
	45	('dev', 'Device'),
	46	)
	47	annotation_rows = (
	48	('bits', 'Bits', ()),
	49	('commands', 'Commands', tuple(range(7 + 1))),
	50	('warnings', 'Warnings', (8,)),
	51	('dev', 'Device', (9,)),
	52	)
	53
	54	def __init__(self, **kwargs):
	55	self.state = 'IDLE'
	56	self.mosi_bytes, self.miso_bytes = [], []
	57	self.cmd_ss, self.cmd_es = 0, 0
	58	self.xx, self.yy, self.zz, self.mm = 0, 0, 0, 0
	59	self.device_ss = None
	60
	61	def start(self):
	62	# self.out_python = self.register(srd.OUTPUT_PYTHON)
	63	self.out_ann = self.register(srd.OUTPUT_ANN)
	64
	65	def putx(self, data):
	66	self.put(self.cmd_ss, self.cmd_es, self.out_ann, data)
	67
	68	def handle_cmd_programming_enable(self, cmd, ret):
	69	# Programming enable.
	70	# Note: The chip doesn't send any ACK for 'Programming enable'.
	71	self.putx([0, ['Programming enable']])
	72
	73	# Sanity check on reply.
	74	if ret[1:4] != [0xac, 0x53, cmd[2]]:
	75	self.putx([8, ['Warning: Unexpected bytes in reply!']])
	76
	77	def handle_cmd_read_signature_byte_0x00(self, cmd, ret):
	78	# Signature byte 0x00: vendor code.
	79	self.vendor_code = ret[3]
	80	v = vendor_code[self.vendor_code]
	81	self.putx([1, ['Vendor code: 0x%02x (%s)' % (ret[3], v)]])
	82
	83	# Store for later.
	84	self.xx = cmd[1] # Same as ret[2].
	85	self.yy = cmd[3]
	86	self.zz = ret[0]
	87
	88	# Sanity check on reply.
	89	if ret[1] != 0x30 or ret[2] != cmd[1]:
	90	self.putx([8, ['Warning: Unexpected bytes in reply!']])
	91
	92	# Sanity check for the vendor code.
	93	if self.vendor_code != VENDOR_CODE_ATMEL:
	94	self.putx([8, ['Warning: Vendor code was not 0x1e (Atmel)!']])
	95
	96	def handle_cmd_read_signature_byte_0x01(self, cmd, ret):
	97	# Signature byte 0x01: part family and memory size.
	98	self.part_fam_flash_size = ret[3]
	99	self.putx([2, ['Part family / memory size: 0x%02x' % ret[3]]])
	100
	101	# Store for later.
	102	self.mm = cmd[3]
	103	self.device_ss = self.cmd_ss
	104
	105	# Sanity check on reply.
	106	if ret[1] != 0x30 or ret[2] != cmd[1] or ret[0] != self.yy:
	107	self.putx([8, ['Warning: Unexpected bytes in reply!']])
	108
	109	def handle_cmd_read_signature_byte_0x02(self, cmd, ret):
	110	# Signature byte 0x02: part number.
	111	self.part_number = ret[3]
	112	self.putx([3, ['Part number: 0x%02x' % ret[3]]])
	113
	114	p = part[(self.part_fam_flash_size, self.part_number)]
	115	data = [9, ['Device: Atmel %s' % p]]
	116	self.put(self.device_ss, self.cmd_es, self.out_ann, data)
	117
	118	# Sanity check on reply.
	119	if ret[1] != 0x30 or ret[2] != self.xx or ret[0] != self.mm:
	120	self.putx([8, ['Warning: Unexpected bytes in reply!']])
	121
	122	self.xx, self.yy, self.zz, self.mm = 0, 0, 0, 0
	123
	124	def handle_cmd_chip_erase(self, cmd, ret):
	125	# Chip erase (erases both flash an EEPROM).
	126	# Upon successful chip erase, the lock bits will also be erased.
	127	# The only way to end a Chip Erase cycle is to release RESET#.
	128	self.putx([4, ['Chip erase']])
	129
	130	# TODO: Check/handle RESET#.
	131
	132	# Sanity check on reply.
	133	bit = (ret[2] & (1 << 7)) >> 7
	134	if ret[1] != 0xac or bit != 1 or ret[3] != cmd[2]:
	135	self.putx([8, ['Warning: Unexpected bytes in reply!']])
	136
	137	def handle_cmd_read_fuse_bits(self, cmd, ret):
	138	# Read fuse bits.
	139	self.putx([5, ['Read fuse bits: 0x%02x' % ret[3]]])
	140
	141	# TODO: Decode fuse bits.
	142	# TODO: Sanity check on reply.
	143
	144	def handle_cmd_read_fuse_high_bits(self, cmd, ret):
	145	# Read fuse high bits.
	146	self.putx([6, ['Read fuse high bits: 0x%02x' % ret[3]]])
	147
	148	# TODO: Decode fuse bits.
	149	# TODO: Sanity check on reply.
	150
	151	def handle_cmd_read_extended_fuse_bits(self, cmd, ret):
	152	# Read extended fuse bits.
	153	self.putx([7, ['Read extended fuse bits: 0x%02x' % ret[3]]])
	154
	155	# TODO: Decode fuse bits.
	156	# TODO: Sanity check on reply.
	157
	158	def handle_command(self, cmd, ret):
	159	if cmd[:2] == [0xac, 0x53]:
	160	self.handle_cmd_programming_enable(cmd, ret)
	161	elif cmd[0] == 0xac and (cmd[1] & (1 << 7)) == (1 << 7):
	162	self.handle_cmd_chip_erase(cmd, ret)
	163	elif cmd[:3] == [0x50, 0x00, 0x00]:
	164	self.handle_cmd_read_fuse_bits(cmd, ret)
	165	elif cmd[:3] == [0x58, 0x08, 0x00]:
	166	self.handle_cmd_read_fuse_high_bits(cmd, ret)
	167	elif cmd[:3] == [0x50, 0x08, 0x00]:
	168	self.handle_cmd_read_extended_fuse_bits(cmd, ret)
	169	elif cmd[0] == 0x30 and cmd[2] == 0x00:
	170	self.handle_cmd_read_signature_byte_0x00(cmd, ret)
	171	elif cmd[0] == 0x30 and cmd[2] == 0x01:
	172	self.handle_cmd_read_signature_byte_0x01(cmd, ret)
	173	elif cmd[0] == 0x30 and cmd[2] == 0x02:
	174	self.handle_cmd_read_signature_byte_0x02(cmd, ret)
	175	else:
	176	c = '%02x %02x %02x %02x' % tuple(cmd)
	177	r = '%02x %02x %02x %02x' % tuple(ret)
	178	self.putx([0, ['Unknown command: %s (reply: %s)!' % (c, r)]])
	179
	180	def decode(self, ss, es, data):
	181	ptype, mosi, miso = data
	182
	183	# For now, only use DATA and BITS packets.
	184	if ptype not in ('DATA', 'BITS'):
	185	return
	186
	187	# Store the individual bit values and ss/es numbers. The next packet
	188	# is guaranteed to be a 'DATA' packet belonging to this 'BITS' one.
	189	if ptype == 'BITS':
	190	self.miso_bits, self.mosi_bits = miso, mosi
	191	return
	192
	193	self.ss, self.es = ss, es
	194
	195	if len(self.mosi_bytes) == 0:
	196	self.cmd_ss = ss
	197
	198	# Append new bytes.
	199	self.mosi_bytes.append(mosi)
	200	self.miso_bytes.append(miso)
	201
	202	# All commands consist of 4 bytes.
	203	if len(self.mosi_bytes) < 4:
	204	return
	205
	206	self.cmd_es = es
	207
	208	self.handle_command(self.mosi_bytes, self.miso_bytes)
	209
	210	self.mosi_bytes = []
	211	self.miso_bytes = []
	212