Various PDs: Drop currently unsupported probes in stacked PDs.
[libsigrokdecode.git] / decoders / avr_isp / pd.py
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