2 ## This file is part of the libsigrokdecode project.
4 ## Copyright (C) 2012-2014 Uwe Hermann <uwe@hermann-uwe.de>
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.
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.
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
21 import sigrokdecode as srd
24 VENDOR_CODE_ATMEL = 0x1e
26 class Decoder(srd.Decoder):
30 longname = 'AVR In-System Programming'
31 desc = 'Protocol for in-system programming Atmel AVR MCUs.'
33 inputs = ['spi', 'logic']
36 {'id': 'reset', 'name': 'RESET#', 'desc': 'Target AVR MCU reset'},
39 ('pe', 'Programming enable'),
40 ('rsb0', 'Read signature byte 0'),
41 ('rsb1', 'Read signature byte 1'),
42 ('rsb2', 'Read signature byte 2'),
44 ('rfb', 'Read fuse bits'),
45 ('rhfb', 'Read high fuse bits'),
46 ('refb', 'Read extended fuse bits'),
47 ('warnings', 'Warnings'),
52 ('commands', 'Commands', tuple(range(7 + 1))),
53 ('warnings', 'Warnings', (8,)),
54 ('dev', 'Device', (9,)),
57 def __init__(self, **kwargs):
59 self.mosi_bytes, self.miso_bytes = [], []
60 self.cmd_ss, self.cmd_es = 0, 0
61 self.xx, self.yy, self.zz, self.mm = 0, 0, 0, 0
65 # self.out_python = self.register(srd.OUTPUT_PYTHON)
66 self.out_ann = self.register(srd.OUTPUT_ANN)
69 self.put(self.cmd_ss, self.cmd_es, self.out_ann, data)
71 def handle_cmd_programming_enable(self, cmd, ret):
73 # Note: The chip doesn't send any ACK for 'Programming enable'.
74 self.putx([0, ['Programming enable']])
76 # Sanity check on reply.
77 if ret[1:4] != [0xac, 0x53, cmd[2]]:
78 self.putx([8, ['Warning: Unexpected bytes in reply!']])
80 def handle_cmd_read_signature_byte_0x00(self, cmd, ret):
81 # Signature byte 0x00: vendor code.
82 self.vendor_code = ret[3]
83 v = vendor_code[self.vendor_code]
84 self.putx([1, ['Vendor code: 0x%02x (%s)' % (ret[3], v)]])
87 self.xx = cmd[1] # Same as ret[2].
91 # Sanity check on reply.
92 if ret[1] != 0x30 or ret[2] != cmd[1]:
93 self.putx([8, ['Warning: Unexpected bytes in reply!']])
95 # Sanity check for the vendor code.
96 if self.vendor_code != VENDOR_CODE_ATMEL:
97 self.putx([8, ['Warning: Vendor code was not 0x1e (Atmel)!']])
99 def handle_cmd_read_signature_byte_0x01(self, cmd, ret):
100 # Signature byte 0x01: part family and memory size.
101 self.part_fam_flash_size = ret[3]
102 self.putx([2, ['Part family / memory size: 0x%02x' % ret[3]]])
106 self.device_ss = self.cmd_ss
108 # Sanity check on reply.
109 if ret[1] != 0x30 or ret[2] != cmd[1] or ret[0] != self.yy:
110 self.putx([8, ['Warning: Unexpected bytes in reply!']])
112 def handle_cmd_read_signature_byte_0x02(self, cmd, ret):
113 # Signature byte 0x02: part number.
114 self.part_number = ret[3]
115 self.putx([3, ['Part number: 0x%02x' % ret[3]]])
117 p = part[(self.part_fam_flash_size, self.part_number)]
118 data = [9, ['Device: Atmel %s' % p]]
119 self.put(self.device_ss, self.cmd_es, self.out_ann, data)
121 # Sanity check on reply.
122 if ret[1] != 0x30 or ret[2] != self.xx or ret[0] != self.mm:
123 self.putx([8, ['Warning: Unexpected bytes in reply!']])
125 self.xx, self.yy, self.zz, self.mm = 0, 0, 0, 0
127 def handle_cmd_chip_erase(self, cmd, ret):
128 # Chip erase (erases both flash an EEPROM).
129 # Upon successful chip erase, the lock bits will also be erased.
130 # The only way to end a Chip Erase cycle is to release RESET#.
131 self.putx([4, ['Chip erase']])
133 # TODO: Check/handle RESET#.
135 # Sanity check on reply.
136 bit = (ret[2] & (1 << 7)) >> 7
137 if ret[1] != 0xac or bit != 1 or ret[3] != cmd[2]:
138 self.putx([8, ['Warning: Unexpected bytes in reply!']])
140 def handle_cmd_read_fuse_bits(self, cmd, ret):
142 self.putx([5, ['Read fuse bits: 0x%02x' % ret[3]]])
144 # TODO: Decode fuse bits.
145 # TODO: Sanity check on reply.
147 def handle_cmd_read_fuse_high_bits(self, cmd, ret):
148 # Read fuse high bits.
149 self.putx([6, ['Read fuse high bits: 0x%02x' % ret[3]]])
151 # TODO: Decode fuse bits.
152 # TODO: Sanity check on reply.
154 def handle_cmd_read_extended_fuse_bits(self, cmd, ret):
155 # Read extended fuse bits.
156 self.putx([7, ['Read extended fuse bits: 0x%02x' % ret[3]]])
158 # TODO: Decode fuse bits.
159 # TODO: Sanity check on reply.
161 def handle_command(self, cmd, ret):
162 if cmd[:2] == [0xac, 0x53]:
163 self.handle_cmd_programming_enable(cmd, ret)
164 elif cmd[0] == 0xac and (cmd[1] & (1 << 7)) == (1 << 7):
165 self.handle_cmd_chip_erase(cmd, ret)
166 elif cmd[:3] == [0x50, 0x00, 0x00]:
167 self.handle_cmd_read_fuse_bits(cmd, ret)
168 elif cmd[:3] == [0x58, 0x08, 0x00]:
169 self.handle_cmd_read_fuse_high_bits(cmd, ret)
170 elif cmd[:3] == [0x50, 0x08, 0x00]:
171 self.handle_cmd_read_extended_fuse_bits(cmd, ret)
172 elif cmd[0] == 0x30 and cmd[2] == 0x00:
173 self.handle_cmd_read_signature_byte_0x00(cmd, ret)
174 elif cmd[0] == 0x30 and cmd[2] == 0x01:
175 self.handle_cmd_read_signature_byte_0x01(cmd, ret)
176 elif cmd[0] == 0x30 and cmd[2] == 0x02:
177 self.handle_cmd_read_signature_byte_0x02(cmd, ret)
179 c = '%02x %02x %02x %02x' % tuple(cmd)
180 r = '%02x %02x %02x %02x' % tuple(ret)
181 self.putx([0, ['Unknown command: %s (reply: %s)!' % (c, r)]])
183 def decode(self, ss, es, data):
184 ptype, mosi, miso = data
186 # For now, only use DATA and BITS packets.
187 if ptype not in ('DATA', 'BITS'):
190 # Store the individual bit values and ss/es numbers. The next packet
191 # is guaranteed to be a 'DATA' packet belonging to this 'BITS' one.
193 self.miso_bits, self.mosi_bits = miso, mosi
196 self.ss, self.es = ss, es
198 if len(self.mosi_bytes) == 0:
202 self.mosi_bytes.append(mosi)
203 self.miso_bytes.append(miso)
205 # All commands consist of 4 bytes.
206 if len(self.mosi_bytes) < 4:
211 self.handle_command(self.mosi_bytes, self.miso_bytes)