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