]>
Commit | Line | Data |
---|---|---|
c4d52210 UH |
1 | ## |
2 | ## This file is part of the libsigrokdecode project. | |
3 | ## | |
4 | ## Copyright (C) 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 | |
4539e9ca | 17 | ## along with this program; if not, see <http://www.gnu.org/licenses/>. |
c4d52210 UH |
18 | ## |
19 | ||
20 | import sigrokdecode as srd | |
21 | from .lists import * | |
22 | ||
23 | class Decoder(srd.Decoder): | |
b197383c | 24 | api_version = 3 |
c4d52210 UH |
25 | id = 'eeprom24xx' |
26 | name = '24xx EEPROM' | |
27 | longname = '24xx I²C EEPROM' | |
28 | desc = '24xx series I²C EEPROM protocol.' | |
29 | license = 'gplv2+' | |
30 | inputs = ['i2c'] | |
6cbba91f | 31 | outputs = [] |
d6d8a8a4 | 32 | tags = ['IC', 'Memory'] |
c4d52210 UH |
33 | options = ( |
34 | {'id': 'chip', 'desc': 'Chip', 'default': 'generic', | |
35 | 'values': tuple(chips.keys())}, | |
36 | {'id': 'addr_counter', 'desc': 'Initial address counter value', | |
37 | 'default': 0}, | |
38 | ) | |
39 | annotations = ( | |
40 | # Warnings | |
41 | ('warnings', 'Warnings'), | |
42 | # Bits/bytes | |
43 | ('control-code', 'Control code'), | |
44 | ('address-pin', 'Address pin (A0/A1/A2)'), | |
45 | ('rw-bit', 'Read/write bit'), | |
46 | ('word-addr-byte', 'Word address byte'), | |
47 | ('data-byte', 'Data byte'), | |
48 | # Fields | |
49 | ('control-word', 'Control word'), | |
50 | ('word-addr', 'Word address'), | |
51 | ('data', 'Data'), | |
52 | # Operations | |
53 | ('byte-write', 'Byte write'), | |
54 | ('page-write', 'Page write'), | |
55 | ('cur-addr-read', 'Current address read'), | |
56 | ('random-read', 'Random read'), | |
57 | ('seq-random-read', 'Sequential random read'), | |
58 | ('seq-cur-addr-read', 'Sequential current address read'), | |
59 | ('ack-polling', 'Acknowledge polling'), | |
60 | ('set-bank-addr', 'Set bank address'), # SBA. Only 34AA04. | |
61 | ('read-bank-addr', 'Read bank address'), # RBA. Only 34AA04. | |
62 | ('set-wp', 'Set write protection'), # SWP | |
63 | ('clear-all-wp', 'Clear all write protection'), # CWP | |
64 | ('read-wp', 'Read write protection status'), # RPS | |
65 | ) | |
66 | annotation_rows = ( | |
67 | ('bits-bytes', 'Bits/bytes', (1, 2, 3, 4, 5)), | |
68 | ('fields', 'Fields', (6, 7, 8)), | |
69 | ('ops', 'Operations', tuple(range(9, 21))), | |
70 | ('warnings', 'Warnings', (0,)), | |
71 | ) | |
72 | binary = ( | |
73 | ('binary', 'Binary'), | |
74 | ) | |
75 | ||
92b7b49f | 76 | def __init__(self): |
10aeb8ea GS |
77 | self.reset() |
78 | ||
79 | def reset(self): | |
0f4d8807 | 80 | self.reset_variables() |
c4d52210 UH |
81 | |
82 | def start(self): | |
83 | self.out_ann = self.register(srd.OUTPUT_ANN) | |
2f370328 | 84 | self.out_binary = self.register(srd.OUTPUT_BINARY) |
c4d52210 UH |
85 | self.chip = chips[self.options['chip']] |
86 | self.addr_counter = self.options['addr_counter'] | |
87 | ||
88 | def putb(self, data): | |
89 | self.put(self.ss_block, self.es_block, self.out_ann, data) | |
90 | ||
91 | def putbin(self, data): | |
2f370328 | 92 | self.put(self.ss_block, self.es_block, self.out_binary, data) |
c4d52210 UH |
93 | |
94 | def putbits(self, bit1, bit2, bits, data): | |
95 | self.put(bits[bit1][1], bits[bit2][2], self.out_ann, data) | |
96 | ||
0f4d8807 | 97 | def reset_variables(self): |
c4d52210 UH |
98 | self.state = 'WAIT FOR START' |
99 | self.packets = [] | |
100 | self.bytebuf = [] | |
101 | self.is_cur_addr_read = False | |
102 | self.is_random_access_read = False | |
103 | self.is_seq_random_read = False | |
104 | self.is_byte_write = False | |
105 | self.is_page_write = False | |
106 | ||
107 | def packet_append(self): | |
108 | self.packets.append([self.ss, self.es, self.cmd, self.databyte, self.bits]) | |
109 | if self.cmd in ('DATA READ', 'DATA WRITE'): | |
110 | self.bytebuf.append(self.databyte) | |
111 | ||
112 | def hexbytes(self, idx): | |
113 | return ' '.join(['%02X' % b for b in self.bytebuf[idx:]]) | |
114 | ||
115 | def put_control_word(self, bits): | |
116 | s = ''.join(['%d' % b[0] for b in reversed(bits[4:])]) | |
117 | self.putbits(7, 4, bits, [1, ['Control code bits: ' + s, | |
118 | 'Control code: ' + s, 'Ctrl code: ' + s, 'Ctrl code', 'Ctrl', 'C']]) | |
119 | for i in reversed(range(self.chip['addr_pins'])): | |
120 | self.putbits(i + 1, i + 1, bits, | |
121 | [2, ['Address bit %d: %d' % (i, bits[i + 1][0]), | |
122 | 'Addr bit %d' % i, 'A%d' % i, 'A']]) | |
123 | s1 = 'read' if bits[0][0] == 1 else 'write' | |
124 | s2 = 'R' if bits[0][0] == 1 else 'W' | |
125 | self.putbits(0, 0, bits, [3, ['R/W bit: ' + s1, 'R/W', 'RW', s2]]) | |
126 | self.putbits(7, 0, bits, [6, ['Control word', 'Control', 'CW', 'C']]) | |
127 | ||
128 | def put_word_addr(self, p): | |
129 | if self.chip['addr_bytes'] == 1: | |
130 | a = p[1][3] | |
131 | self.put(p[1][0], p[1][1], self.out_ann, | |
132 | [4, ['Word address byte: %02X' % a, 'Word addr byte: %02X' % a, | |
133 | 'Addr: %02X' % a, 'A: %02X' % a, '%02X' % a]]) | |
134 | self.put(p[1][0], p[1][1], self.out_ann, [7, ['Word address', | |
135 | 'Word addr', 'Addr', 'A']]) | |
136 | self.addr_counter = a | |
137 | else: | |
138 | a = p[1][3] | |
139 | self.put(p[1][0], p[1][1], self.out_ann, | |
140 | [4, ['Word address high byte: %02X' % a, | |
141 | 'Word addr high byte: %02X' % a, | |
142 | 'Addr high: %02X' % a, 'AH: %02X' % a, '%02X' % a]]) | |
143 | a = p[2][3] | |
144 | self.put(p[2][0], p[2][1], self.out_ann, | |
145 | [4, ['Word address low byte: %02X' % a, | |
146 | 'Word addr low byte: %02X' % a, | |
147 | 'Addr low: %02X' % a, 'AL: %02X' % a, '%02X' % a]]) | |
148 | self.put(p[1][0], p[2][1], self.out_ann, [7, ['Word address', | |
149 | 'Word addr', 'Addr', 'A']]) | |
150 | self.addr_counter = (p[1][3] << 8) | p[2][3] | |
151 | ||
152 | def put_data_byte(self, p): | |
153 | if self.chip['addr_bytes'] == 1: | |
154 | s = '%02X' % self.addr_counter | |
155 | else: | |
156 | s = '%04X' % self.addr_counter | |
157 | self.put(p[0], p[1], self.out_ann, [5, ['Data byte %s: %02X' % \ | |
158 | (s, p[3]), 'Data byte: %02X' % p[3], \ | |
159 | 'Byte: %02X' % p[3], 'DB: %02X' % p[3], '%02X' % p[3]]]) | |
160 | ||
161 | def put_data_bytes(self, idx, cls, s): | |
162 | for p in self.packets[idx:]: | |
163 | self.put_data_byte(p) | |
164 | self.addr_counter += 1 | |
165 | self.put(self.packets[idx][0], self.packets[-1][1], self.out_ann, | |
166 | [8, ['Data', 'D']]) | |
167 | a = ''.join(['%s' % c[0] for c in s.split()]).upper() | |
168 | self.putb([cls, ['%s (%s): %s' % (s, self.addr_and_len(), \ | |
169 | self.hexbytes(self.chip['addr_bytes'])), | |
170 | '%s (%s)' % (s, self.addr_and_len()), s, a, s[0]]]) | |
2824e811 | 171 | self.putbin([0, bytes(self.bytebuf[self.chip['addr_bytes']:])]) |
c4d52210 UH |
172 | |
173 | def addr_and_len(self): | |
174 | if self.chip['addr_bytes'] == 1: | |
175 | a = '%02X' % self.bytebuf[0] | |
176 | else: | |
177 | a = '%02X%02X' % tuple(self.bytebuf[:2]) | |
178 | num_data_bytes = len(self.bytebuf) - self.chip['addr_bytes'] | |
179 | d = '%d bytes' % num_data_bytes | |
180 | if num_data_bytes <= 1: | |
181 | d = d[:-1] | |
182 | return 'addr=%s, %s' % (a, d) | |
183 | ||
184 | def decide_on_seq_or_rnd_read(self): | |
185 | if len(self.bytebuf) < 2: | |
0f4d8807 | 186 | self.reset_variables() |
c4d52210 UH |
187 | return |
188 | if len(self.bytebuf) == 2: | |
189 | self.is_random_access_read = True | |
190 | else: | |
191 | self.is_seq_random_read = True | |
192 | ||
193 | def put_operation(self): | |
194 | idx = 1 + self.chip['addr_bytes'] | |
195 | if self.is_byte_write: | |
196 | # Byte write: word address, one data byte. | |
197 | self.put_word_addr(self.packets) | |
198 | self.put_data_bytes(idx, 9, 'Byte write') | |
199 | elif self.is_page_write: | |
200 | # Page write: word address, two or more data bytes. | |
201 | self.put_word_addr(self.packets) | |
202 | intitial_addr = self.addr_counter | |
203 | self.put_data_bytes(idx, 10, 'Page write') | |
204 | num_bytes_to_write = len(self.packets[idx:]) | |
205 | if num_bytes_to_write > self.chip['page_size']: | |
206 | self.putb([0, ['Warning: Wrote %d bytes but page size is ' | |
207 | 'only %d bytes!' % (num_bytes_to_write, | |
208 | self.chip['page_size'])]]) | |
209 | page1 = int(intitial_addr / self.chip['page_size']) | |
210 | page2 = int((self.addr_counter - 1) / self.chip['page_size']) | |
211 | if page1 != page2: | |
212 | self.putb([0, ['Warning: Page write crossed page boundary ' | |
213 | 'from page %d to %d!' % (page1, page2)]]) | |
214 | elif self.is_cur_addr_read: | |
215 | # Current address read: no word address, one data byte. | |
216 | self.put_data_byte(self.packets[1]) | |
217 | self.put(self.packets[1][0], self.packets[-1][1], self.out_ann, | |
218 | [8, ['Data', 'D']]) | |
219 | self.putb([11, ['Current address read: %02X' % self.bytebuf[0], | |
220 | 'Current address read', 'Cur addr read', 'CAR', 'C']]) | |
2824e811 | 221 | self.putbin([0, bytes([self.bytebuf[0]])]) |
c4d52210 UH |
222 | self.addr_counter += 1 |
223 | elif self.is_random_access_read: | |
224 | # Random access read: word address, one data byte. | |
225 | self.put_control_word(self.packets[idx][4]) | |
226 | self.put_word_addr(self.packets) | |
227 | self.put_data_bytes(idx + 1, 12, 'Random access read') | |
228 | elif self.is_seq_random_read: | |
229 | # Sequential random read: word address, two or more data bytes. | |
230 | self.put_control_word(self.packets[idx][4]) | |
231 | self.put_word_addr(self.packets) | |
232 | self.put_data_bytes(idx + 1, 13, 'Sequential random read') | |
233 | ||
234 | def handle_wait_for_start(self): | |
235 | # Wait for an I²C START condition. | |
236 | if self.cmd not in ('START', 'START REPEAT'): | |
237 | return | |
238 | self.ss_block = self.ss | |
239 | self.state = 'GET CONTROL WORD' | |
240 | ||
241 | def handle_get_control_word(self): | |
242 | # The packet after START must be an ADDRESS READ or ADDRESS WRITE. | |
243 | if self.cmd not in ('ADDRESS READ', 'ADDRESS WRITE'): | |
0f4d8807 | 244 | self.reset_variables() |
c4d52210 UH |
245 | return |
246 | self.packet_append() | |
247 | self.put_control_word(self.bits) | |
248 | self.state = '%s GET ACK NACK AFTER CONTROL WORD' % self.cmd[8] | |
249 | ||
250 | def handle_r_get_ack_nack_after_control_word(self): | |
251 | if self.cmd == 'ACK': | |
252 | self.state = 'R GET WORD ADDR OR BYTE' | |
253 | elif self.cmd == 'NACK': | |
254 | self.es_block = self.es | |
255 | self.putb([0, ['Warning: No reply from slave!']]) | |
0f4d8807 | 256 | self.reset_variables() |
c4d52210 | 257 | else: |
0f4d8807 | 258 | self.reset_variables() |
c4d52210 UH |
259 | |
260 | def handle_r_get_word_addr_or_byte(self): | |
261 | if self.cmd == 'STOP': | |
262 | self.es_block = self.es | |
263 | self.putb([0, ['Warning: Slave replied, but master aborted!']]) | |
0f4d8807 | 264 | self.reset_variables() |
c4d52210 UH |
265 | return |
266 | elif self.cmd != 'DATA READ': | |
0f4d8807 | 267 | self.reset_variables() |
c4d52210 UH |
268 | return |
269 | self.packet_append() | |
270 | self.state = 'R GET ACK NACK AFTER WORD ADDR OR BYTE' | |
271 | ||
272 | def handle_r_get_ack_nack_after_word_addr_or_byte(self): | |
273 | if self.cmd == 'ACK': | |
274 | self.state = 'R GET RESTART' | |
275 | elif self.cmd == 'NACK': | |
276 | self.is_cur_addr_read = True | |
277 | self.state = 'GET STOP AFTER LAST BYTE' | |
278 | else: | |
0f4d8807 | 279 | self.reset_variables() |
c4d52210 UH |
280 | |
281 | def handle_r_get_restart(self): | |
282 | if self.cmd == 'RESTART': | |
283 | self.state = 'R READ BYTE' | |
284 | else: | |
0f4d8807 | 285 | self.reset_variables() |
c4d52210 UH |
286 | |
287 | def handle_r_read_byte(self): | |
288 | if self.cmd == 'DATA READ': | |
289 | self.packet_append() | |
290 | self.state = 'R GET ACK NACK AFTER BYTE WAS READ' | |
291 | else: | |
0f4d8807 | 292 | self.reset_variables() |
c4d52210 UH |
293 | |
294 | def handle_r_get_ack_nack_after_byte_was_read(self): | |
295 | if self.cmd == 'ACK': | |
296 | self.state = 'R READ BYTE' | |
297 | elif self.cmd == 'NACK': | |
298 | # It's either a RANDOM READ or a SEQUENTIAL READ. | |
299 | self.state = 'GET STOP AFTER LAST BYTE' | |
300 | else: | |
0f4d8807 | 301 | self.reset_variables() |
c4d52210 UH |
302 | |
303 | def handle_w_get_ack_nack_after_control_word(self): | |
304 | if self.cmd == 'ACK': | |
305 | self.state = 'W GET WORD ADDR' | |
306 | elif self.cmd == 'NACK': | |
307 | self.es_block = self.es | |
308 | self.putb([0, ['Warning: No reply from slave!']]) | |
0f4d8807 | 309 | self.reset_variables() |
c4d52210 | 310 | else: |
0f4d8807 | 311 | self.reset_variables() |
c4d52210 UH |
312 | |
313 | def handle_w_get_word_addr(self): | |
314 | if self.cmd == 'STOP': | |
315 | self.es_block = self.es | |
316 | self.putb([0, ['Warning: Slave replied, but master aborted!']]) | |
0f4d8807 | 317 | self.reset_variables() |
c4d52210 UH |
318 | return |
319 | elif self.cmd != 'DATA WRITE': | |
0f4d8807 | 320 | self.reset_variables() |
c4d52210 UH |
321 | return |
322 | self.packet_append() | |
323 | self.state = 'W GET ACK AFTER WORD ADDR' | |
324 | ||
325 | def handle_w_get_ack_after_word_addr(self): | |
326 | if self.cmd == 'ACK': | |
327 | self.state = 'W DETERMINE EEPROM READ OR WRITE' | |
328 | else: | |
0f4d8807 | 329 | self.reset_variables() |
c4d52210 UH |
330 | |
331 | def handle_w_determine_eeprom_read_or_write(self): | |
332 | if self.cmd == 'START REPEAT': | |
333 | # It's either a RANDOM ACCESS READ or SEQUENTIAL RANDOM READ. | |
334 | self.state = 'R2 GET CONTROL WORD' | |
335 | elif self.cmd == 'DATA WRITE': | |
336 | self.packet_append() | |
337 | self.state = 'W GET ACK NACK AFTER BYTE WAS WRITTEN' | |
338 | else: | |
0f4d8807 | 339 | self.reset_variables() |
c4d52210 UH |
340 | |
341 | def handle_w_write_byte(self): | |
342 | if self.cmd == 'DATA WRITE': | |
343 | self.packet_append() | |
344 | self.state = 'W GET ACK NACK AFTER BYTE WAS WRITTEN' | |
345 | elif self.cmd == 'STOP': | |
346 | if len(self.bytebuf) < 2: | |
0f4d8807 | 347 | self.reset_variables() |
c4d52210 UH |
348 | return |
349 | self.es_block = self.es | |
350 | if len(self.bytebuf) == 2: | |
351 | self.is_byte_write = True | |
352 | else: | |
353 | self.is_page_write = True | |
354 | self.put_operation() | |
0f4d8807 | 355 | self.reset_variables() |
c4d52210 UH |
356 | elif self.cmd == 'START REPEAT': |
357 | # It's either a RANDOM ACCESS READ or SEQUENTIAL RANDOM READ. | |
358 | self.state = 'R2 GET CONTROL WORD' | |
359 | else: | |
0f4d8807 | 360 | self.reset_variables() |
c4d52210 UH |
361 | |
362 | def handle_w_get_ack_nack_after_byte_was_written(self): | |
363 | if self.cmd == 'ACK': | |
364 | self.state = 'W WRITE BYTE' | |
365 | else: | |
0f4d8807 | 366 | self.reset_variables() |
c4d52210 UH |
367 | |
368 | def handle_r2_get_control_word(self): | |
369 | if self.cmd == 'ADDRESS READ': | |
370 | self.packet_append() | |
371 | self.state = 'R2 GET ACK AFTER ADDR READ' | |
372 | else: | |
0f4d8807 | 373 | self.reset_variables() |
c4d52210 UH |
374 | |
375 | def handle_r2_get_ack_after_addr_read(self): | |
376 | if self.cmd == 'ACK': | |
377 | self.state = 'R2 READ BYTE' | |
378 | else: | |
0f4d8807 | 379 | self.reset_variables() |
c4d52210 UH |
380 | |
381 | def handle_r2_read_byte(self): | |
382 | if self.cmd == 'DATA READ': | |
383 | self.packet_append() | |
384 | self.state = 'R2 GET ACK NACK AFTER BYTE WAS READ' | |
385 | elif self.cmd == 'STOP': | |
386 | self.decide_on_seq_or_rnd_read() | |
387 | self.es_block = self.es | |
388 | self.putb([0, ['Warning: STOP expected after a NACK (not ACK)']]) | |
389 | self.put_operation() | |
0f4d8807 | 390 | self.reset_variables() |
c4d52210 | 391 | else: |
0f4d8807 | 392 | self.reset_variables() |
c4d52210 UH |
393 | |
394 | def handle_r2_get_ack_nack_after_byte_was_read(self): | |
395 | if self.cmd == 'ACK': | |
396 | self.state = 'R2 READ BYTE' | |
397 | elif self.cmd == 'NACK': | |
398 | self.decide_on_seq_or_rnd_read() | |
399 | self.state = 'GET STOP AFTER LAST BYTE' | |
400 | else: | |
0f4d8807 | 401 | self.reset_variables() |
c4d52210 UH |
402 | |
403 | def handle_get_stop_after_last_byte(self): | |
404 | if self.cmd == 'STOP': | |
405 | self.es_block = self.es | |
406 | self.put_operation() | |
0f4d8807 | 407 | self.reset_variables() |
c4d52210 UH |
408 | elif self.cmd == 'START REPEAT': |
409 | self.es_block = self.es | |
410 | self.putb([0, ['Warning: STOP expected (not RESTART)']]) | |
411 | self.put_operation() | |
0f4d8807 | 412 | self.reset_variables() |
c4d52210 UH |
413 | self.ss_block = self.ss |
414 | self.state = 'GET CONTROL WORD' | |
415 | else: | |
0f4d8807 | 416 | self.reset_variables() |
c4d52210 UH |
417 | |
418 | def decode(self, ss, es, data): | |
419 | self.cmd, self.databyte = data | |
420 | ||
421 | # Collect the 'BITS' packet, then return. The next packet is | |
422 | # guaranteed to belong to these bits we just stored. | |
423 | if self.cmd == 'BITS': | |
424 | self.bits = self.databyte | |
425 | return | |
426 | ||
427 | # Store the start/end samples of this I²C packet. | |
428 | self.ss, self.es = ss, es | |
429 | ||
430 | # State machine. | |
431 | s = 'handle_%s' % self.state.lower().replace(' ', '_') | |
432 | handle_state = getattr(self, s) | |
433 | handle_state() |