|
128
|
1 import time
|
|
256
|
2 import logging
|
|
128
|
3 from devices import Device, registerDevice, STLinkException, Interface
|
|
138
|
4 import stlink
|
|
128
|
5
|
|
|
6 # F4 specifics:
|
|
|
7 STM32_FLASH_BASE = 0x08000000
|
|
|
8 STM32_SRAM_BASE = 0x20000000
|
|
|
9
|
|
|
10 # flash registers:
|
|
|
11 FLASH_F4_REGS_ADDR = 0x40023c00
|
|
|
12 FLASH_F4_KEYR = FLASH_F4_REGS_ADDR + 0x04
|
|
|
13 FLASH_F4_SR = FLASH_F4_REGS_ADDR + 0x0c
|
|
|
14 FLASH_F4_CR = FLASH_F4_REGS_ADDR + 0x10
|
|
|
15
|
|
|
16 FLASH_F4_CR_START = 16
|
|
|
17 FLASH_F4_CR_LOCK = 31
|
|
|
18 FLASH_CR_PG = 0
|
|
|
19 FLASH_F4_CR_SER = 1
|
|
|
20 FLASH_CR_MER = 2
|
|
|
21 FLASH_F4_CR_SNB = 3
|
|
|
22 FLASH_F4_CR_SNB_MASK = 0x38
|
|
|
23 FLASH_F4_SR_BSY = 16
|
|
|
24
|
|
|
25 class Stm32F4(Device):
|
|
130
|
26 """
|
|
|
27 Implementation of the specifics of the STM32F4xx device series.
|
|
|
28 """
|
|
128
|
29 def __init__(self, iface):
|
|
129
|
30 super().__init__(iface)
|
|
255
|
31 self.logger = logging.getLogger('stm32')
|
|
246
|
32
|
|
129
|
33 def __str__(self):
|
|
130
|
34 return 'STM32F4 device size=0x{1:X} id=0x{0:X}'.format(\
|
|
|
35 self.UID, self.FlashSize)
|
|
246
|
36
|
|
130
|
37 def calculate_F4_sector(self, address):
|
|
|
38 sectorstarts = []
|
|
|
39 a = STM32_FLASH_BASE
|
|
|
40 for sectorsize in self.sectorsizes:
|
|
|
41 sectorstarts.append(a)
|
|
|
42 a += sectorsize
|
|
|
43 # linear search:
|
|
|
44 sec = 0
|
|
|
45 while sec < len(self.sectorsizes) and address >= sectorstarts[sec]:
|
|
|
46 sec += 1
|
|
|
47 sec -= 1 # one back.
|
|
|
48 return sec, self.sectorsizes[sec]
|
|
|
49
|
|
|
50 def calcSectors(self, address, size):
|
|
|
51 off = 0
|
|
|
52 sectors = []
|
|
|
53 while off < size:
|
|
|
54 sectornum, sectorsize = self.calculate_F4_sector(address + off)
|
|
|
55 sectors.append((sectornum, sectorsize))
|
|
|
56 off += sectorsize
|
|
|
57 return sectors
|
|
|
58 # Device registers:
|
|
|
59 @property
|
|
|
60 def UID(self):
|
|
|
61 uid_base = 0x1FFF7A10
|
|
|
62 uid1 = self.iface.read_debug32(uid_base)
|
|
|
63 uid2 = self.iface.read_debug32(uid_base + 0x4)
|
|
|
64 uid3 = self.iface.read_debug32(uid_base + 0x8)
|
|
|
65 return (uid3 << 64) | (uid2 << 32) | uid1
|
|
246
|
66
|
|
130
|
67 @property
|
|
|
68 def FlashSize(self):
|
|
|
69 f_id = self.iface.read_debug32(0x1FFF7A22)
|
|
|
70 f_id = f_id >> 16
|
|
|
71 return f_id * 1024
|
|
246
|
72
|
|
138
|
73 @property
|
|
|
74 def Running(self):
|
|
|
75 return self.iface.Status == stlink.CORE_RUNNING
|
|
246
|
76
|
|
128
|
77 # flashing commands:
|
|
|
78 def writeFlash(self, address, content):
|
|
130
|
79 flashsize = self.FlashSize
|
|
|
80 pagesize = min(self.sectorsizes)
|
|
128
|
81
|
|
|
82 # Check address range:
|
|
|
83 if address < STM32_FLASH_BASE:
|
|
|
84 raise STLinkException('Flashing below flash start')
|
|
|
85 if address + len(content) > STM32_FLASH_BASE + flashsize:
|
|
|
86 raise STLinkException('Flashing above flash size')
|
|
|
87 if address & 1 == 1:
|
|
|
88 raise STLinkException('Unaligned flash')
|
|
|
89 if len(content) & 1 == 1:
|
|
255
|
90 self.logger.warning('unaligned length, padding with zero')
|
|
128
|
91 content += bytes([0])
|
|
|
92 if address & (pagesize - 1) != 0:
|
|
|
93 raise STLinkException('Address not aligned with pagesize')
|
|
|
94 # erase required space
|
|
130
|
95 sectors = self.calcSectors(address, len(content))
|
|
255
|
96 self.logger.info('erasing {0} sectors'.format(len(sectors)))
|
|
128
|
97 for sector, secsize in sectors:
|
|
255
|
98 self.logger.info('erasing sector {0} of {1} bytes'.format(sector, secsize))
|
|
128
|
99 self.eraseFlashSector(sector)
|
|
|
100 # program pages:
|
|
|
101 self.unlockFlashIf()
|
|
|
102 self.writeFlashCrPsiz(2) # writes are 32 bits aligned
|
|
|
103 self.setFlashCrPg()
|
|
256
|
104 self.logger.info('writing {0} bytes'.format(len(content)))
|
|
128
|
105 offset = 0
|
|
|
106 t1 = time.time()
|
|
|
107 while offset < len(content):
|
|
|
108 size = len(content) - offset
|
|
|
109 if size > 0x8000:
|
|
|
110 size = 0x8000
|
|
|
111 chunk = content[offset:offset + size]
|
|
|
112 while len(chunk) % 4 != 0:
|
|
|
113 chunk = chunk + bytes([0])
|
|
|
114 # Use simple mem32 writes:
|
|
|
115 self.iface.write_mem32(address + offset, chunk)
|
|
|
116 offset += size
|
|
256
|
117 self.logger.info('.')
|
|
128
|
118 t2 = time.time()
|
|
256
|
119 self.logger.info('Done!')
|
|
|
120 self.logger.info('Speed: {0} bytes/second'.format(len(content)/(t2-t1)))
|
|
128
|
121 self.lockFlash()
|
|
|
122 # verfify program:
|
|
|
123 self.verifyFlash(address, content)
|
|
|
124 def eraseFlashSector(self, sector):
|
|
|
125 self.waitFlashBusy()
|
|
|
126 self.unlockFlashIf()
|
|
|
127 self.writeFlashCrSnb(sector)
|
|
|
128 self.setFlashCrStart()
|
|
|
129 self.waitFlashBusy()
|
|
|
130 self.lockFlash()
|
|
|
131 def eraseFlash(self):
|
|
|
132 self.waitFlashBusy()
|
|
|
133 self.unlockFlashIf()
|
|
|
134 self.setFlashCrMer()
|
|
|
135 self.setFlashCrStart()
|
|
|
136 self.waitFlashBusy()
|
|
|
137 self.clearFlashCrMer()
|
|
|
138 self.lockFlash()
|
|
256
|
139
|
|
128
|
140 def verifyFlash(self, address, content):
|
|
|
141 device_content = self.readFlash(address, len(content))
|
|
|
142 ok = content == device_content
|
|
256
|
143 self.logger.info('Verify: {}'.format(ok))
|
|
|
144
|
|
128
|
145 def readFlash(self, address, size):
|
|
256
|
146 self.logger.info('Reading {1} bytes from 0x{0:X}'.format(address, size))
|
|
128
|
147 offset = 0
|
|
|
148 tmp_size = 0x1800
|
|
|
149 t1 = time.time()
|
|
|
150 image = bytes()
|
|
|
151 while offset < size:
|
|
|
152 # Correct for last page:
|
|
|
153 if offset + tmp_size > size:
|
|
|
154 tmp_size = size - offset
|
|
|
155
|
|
|
156 # align size to 4 bytes:
|
|
|
157 aligned_size = tmp_size
|
|
|
158 while aligned_size % 4 != 0:
|
|
|
159 aligned_size += 1
|
|
|
160
|
|
|
161 mem = self.iface.read_mem32(address + offset, aligned_size)
|
|
|
162 image += mem[:tmp_size]
|
|
|
163
|
|
|
164 # indicate progress:
|
|
256
|
165 self.logger.info('.')
|
|
128
|
166
|
|
|
167 # increase for next piece:
|
|
|
168 offset += tmp_size
|
|
|
169 t2 = time.time()
|
|
|
170 assert size == len(image)
|
|
256
|
171 self.logger.info('Done!')
|
|
|
172 self.logger.info('Speed: {0} bytes/second'.format(size/(t2-t1)))
|
|
128
|
173 return image
|
|
|
174
|
|
|
175 def waitFlashBusy(self):
|
|
246
|
176 """ block until flash operation completes. """
|
|
|
177 while self.isFlashBusy():
|
|
|
178 time.sleep(0.01)
|
|
128
|
179 def isFlashLocked(self):
|
|
|
180 cr = self.readFlashCr()
|
|
|
181 mask = 1 << FLASH_F4_CR_LOCK
|
|
|
182 return cr & mask == mask
|
|
|
183 def unlockFlashIf(self):
|
|
130
|
184 FLASH_KEY1, FLASH_KEY2 = 0x45670123, 0xcdef89ab
|
|
128
|
185 if self.isFlashLocked():
|
|
|
186 self.iface.write_debug32(FLASH_F4_KEYR, FLASH_KEY1)
|
|
|
187 self.iface.write_debug32(FLASH_F4_KEYR, FLASH_KEY2)
|
|
|
188 if self.isFlashLocked():
|
|
|
189 raise STLinkException('Failed to unlock')
|
|
|
190 def lockFlash(self):
|
|
|
191 x = self.readFlashCr() | (1 << FLASH_F4_CR_LOCK)
|
|
|
192 self.writeFlashCr(x)
|
|
|
193 def readFlashSr(self):
|
|
|
194 return self.iface.read_debug32(FLASH_F4_SR)
|
|
|
195 def readFlashCr(self):
|
|
|
196 return self.iface.read_debug32(FLASH_F4_CR)
|
|
|
197 def writeFlashCr(self, x):
|
|
|
198 self.iface.write_debug32(FLASH_F4_CR, x)
|
|
|
199 def writeFlashCrSnb(self, sector):
|
|
|
200 x = self.readFlashCr()
|
|
|
201 x &= ~FLASH_F4_CR_SNB_MASK
|
|
|
202 x |= sector << FLASH_F4_CR_SNB
|
|
|
203 x |= 1 << FLASH_F4_CR_SER
|
|
|
204 self.writeFlashCr(x)
|
|
|
205 def setFlashCrMer(self):
|
|
|
206 x = self.readFlashCr()
|
|
|
207 x |= 1 << FLASH_CR_MER
|
|
|
208 self.writeFlashCr(x)
|
|
|
209 def setFlashCrPg(self):
|
|
|
210 x = self.readFlashCr()
|
|
|
211 x |= 1 << FLASH_CR_PG
|
|
|
212 self.writeFlashCr(x)
|
|
|
213 def writeFlashCrPsiz(self, n):
|
|
|
214 x = self.readFlashCr()
|
|
|
215 x &= (0x3 << 8)
|
|
|
216 x |= n << 8
|
|
|
217 self.writeFlashCr(x)
|
|
|
218 def clearFlashCrMer(self):
|
|
|
219 x = self.readFlashCr()
|
|
|
220 x &= ~(1 << FLASH_CR_MER)
|
|
|
221 self.writeFlashCr(x)
|
|
|
222 def setFlashCrStart(self):
|
|
|
223 x = self.readFlashCr()
|
|
|
224 x |= 1 << FLASH_F4_CR_START
|
|
|
225 self.writeFlashCr(x)
|
|
|
226 def isFlashBusy(self):
|
|
|
227 mask = 1 << FLASH_F4_SR_BSY
|
|
|
228 sr = self.readFlashSr()
|
|
|
229 # Check for error bits:
|
|
|
230 errorbits = {}
|
|
|
231 errorbits[7] = 'Programming sequence error'
|
|
|
232 errorbits[6] = 'Programming parallelism error'
|
|
|
233 errorbits[5] = 'Programming alignment error'
|
|
|
234 errorbits[4] = 'Write protection error'
|
|
|
235 errorbits[1] = 'Operation error'
|
|
|
236 #errorbits[0] = 'End of operation'
|
|
|
237 for bit, msg in errorbits.items():
|
|
|
238 if sr & (1 << bit) == (1 << bit):
|
|
|
239 raise STLinkException(msg)
|
|
|
240 return sr & mask == mask
|
|
|
241
|
|
131
|
242 @registerDevice(0x10016413)
|
|
|
243 class Stm32F40x(Stm32F4):
|
|
|
244 """ STM32F40x and STM32F41x device series """
|
|
|
245 def __init__(self, iface):
|
|
|
246 super().__init__(iface)
|
|
|
247 # Assert the proper size for this device:
|
|
|
248 assert self.FlashSize == 0x100000
|
|
|
249 """
|
|
|
250 from 0x8000000 to 0x80FFFFF
|
|
|
251 4 sectors of 0x4000 (16 kB)
|
|
|
252 1 sector of 0x10000 (64 kB)
|
|
|
253 7 of 0x20000 (128 kB)
|
|
|
254 """
|
|
|
255 self.sectorsizes = [0x4000] * 4 + [0x10000] + [0x20000] * 7
|
|
|
256
|
