-
Notifications
You must be signed in to change notification settings - Fork 0
/
command_DY_VY_LY.asm
214 lines (208 loc) · 5.87 KB
/
command_DY_VY_LY.asm
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
; This file is part of Programator.
;
; Programator is free software: you can redistribute it and/or
; modify it under the terms of the GNU General Public License as
; published by the Free Software Foundation, either version 3 of the
; License, or (at your option) any later version.
;
; Programator is distributed in the hope that it will be useful,
; but WITHOUT ANY WARRANTY; without even the implied warranty of
; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
; General Public License for more details.
;
; You should have received a copy of the GNU General Public License
; along with Programator. If not, see <https://www.gnu.org/licenses/>.
;
; Copyright (c) 2022, 2024 Aleksander Mazur
;
; Procedura obsługi poleceń:
; - DY [begin-address [end-address]]
; - VY
; - LY
; Czyli odczyt, weryfikacja i zapis pamięci EEPROM na SPI (np. 93C46N)
;-----------------------------------------------------------
; DY [begin-address [end-address]]
if USE_HELP_DESC
dw s_help_DY
endif
command_dump_spi_eeprom:
bcall spi_eeprom_autodetect
; domyślny zakres adekwatny do liczby bitów adresu
clr A
mov R2, A
mov R3, A
mov R4, A
mov R5, #1
mov A, spi_address_bits
orl A, #1 ; parzysta liczba oznacza tryb 16-bitowy, w którym adresowanych _bajtów_ jest 2x więcej
mov R6, A
command_dump_spi_eeprom_shl:
mov A, R5
clr C
rlc A
mov R5, A
mov A, R4
rlc A
mov R4, A
djnz R6, command_dump_spi_eeprom_shl
; 6, 7 bitów -> 2^7=128 bajtów
; 8, 9 bitów -> 2^9=512 bajtów
; 10, 11 bitów -> 2^11=2048 bajtów
dec R5
cjne R5, #-1, command_dump_spi_no_carry
dec R4
command_dump_spi_no_carry:
bcall get_address_range
; mamy zakres zrzutu: R2:R3 bajtów poczynając od R4:R5
mov DPTR, #cb_dump_spi_eeprom
bjmp dump_hex_file
cb_dump_spi_eeprom:
; na wejściu i na wyjściu CS=CLK=0
bcall spi_eeprom_check_address
jnc cb_dump_spi_eeprom_addr_ok
mov DPTR, #s_error_odd_address
bjmp print_error_then_prompt
cb_dump_spi_eeprom_addr_ok:
setb RS0
mov R4, AR4
mov R5, AR5
mov R7, AR7
mov R0, #input
cb_dump_spi_eeprom_loop:
; rozpoczynamy odczyt
bcall spi_eeprom_start_reading
jc cb_dump_spi_eeprom_error
bcall cb_dump_spi_eeprom_byte
djnz R7, cb_dump_spi_eeprom_loop2
sjmp cb_dump_spi_eeprom_end
cb_dump_spi_eeprom_loop2:
jb spi_address_bits.0, cb_dump_spi_eeprom_loop3
; drugi bajt w trybie 16-bitowym
bcall cb_dump_spi_eeprom_byte
djnz R7, cb_dump_spi_eeprom_loop3
cb_dump_spi_eeprom_end:
clr C
cb_dump_spi_eeprom_ret:
anl P1, #11000111b ; CS=CLK=GND=0
clr RS0
mov R0, #input
ret
cb_dump_spi_eeprom_loop3:
; kończymy odczyt bajtu/słowa
anl P1, #11000111b ; CS=CLK=GND=0
sjmp cb_dump_spi_eeprom_loop
cb_dump_spi_eeprom_error:
mov DPTR, #s_error_spierr
setb C
sjmp cb_dump_spi_eeprom_ret
;-----------------------------------------------------------
; VY
if USE_HELP_DESC
dw s_help_VY
endif
command_verify_spi_eeprom:
bcall ensure_no_args
bcall spi_eeprom_autodetect
mov DPTR, #cb_verify_spi_eeprom
bjmp load_hex_file
cb_verify_spi_eeprom:
; na wejściu i na wyjściu CS=CLK=0
bcall spi_eeprom_check_address
jnc cb_verify_spi_eeprom_loop
cb_spi_eeprom_code_A:
mov A, #'A'
sjmp cb_spi_eeprom_ret
cb_verify_spi_eeprom_loop:
; rozpoczynamy odczyt
bcall spi_eeprom_start_reading
jc cb_spi_eeprom_code_F
bcall cb_verify_spi_eeprom_byte
cjne A, AR2, cb_spi_eeprom_code_V
djnz R7, cb_verify_spi_eeprom_loop2
sjmp cb_spi_eeprom_code_G
cb_verify_spi_eeprom_loop2:
jb spi_address_bits.0, cb_verify_spi_eeprom_loop3
; drugi bajt w trybie 16-bitowym
bcall cb_verify_spi_eeprom_byte
cjne A, AR2, cb_spi_eeprom_code_V
djnz R7, cb_verify_spi_eeprom_loop3
; wszystko się zgadzało
cb_spi_eeprom_code_G:
mov A, #'G'
cb_spi_eeprom_ret:
anl P1, #11000111b ; CS=CLK=GND=0
ret
cb_verify_spi_eeprom_loop3:
; kończymy odczyt bajtu/słowa
anl P1, #11000111b ; CS=CLK=GND=0
sjmp cb_verify_spi_eeprom_loop
cb_spi_eeprom_code_F:
mov A, #'F'
sjmp cb_spi_eeprom_ret
cb_spi_eeprom_code_V:
mov A, #'V'
sjmp cb_spi_eeprom_ret
;-----------------------------------------------------------
; LY
if USE_HELP_DESC
dw s_help_LY
endif
command_load_spi_eeprom:
bcall ensure_no_args
bcall spi_eeprom_autodetect
; musimy włączyć możliwość zapisu
orl P1, #00010110b ; CS=DI=DO=1
mov A, spi_address_bits
add A, #3
mov R6, A
mov A, #10011000b ; EWEN (Erase/Write ENable): 1,0,0,1,1,x,x,x,... 3 bity + niby-adres
; to nic, że R6 może być > 8, bo i tak wartości po piątym wysłanym bicie są bez znaczenia
bcall spi_transfer_bits
anl P1, #11000111b ; CS=CLK=GND=0
mov DPTR, #cb_load_spi_eeprom
bjmp load_hex_file
cb_load_spi_eeprom:
; na wejściu i na wyjściu CS=CLK=0
bcall spi_eeprom_check_address
jc cb_spi_eeprom_code_A
jb spi_address_bits.0, cb_load_spi_eeprom_loop
; czy długość jest parzysta w trybie 16-bitowym?
mov A, R7
clr C
rrc A
jnc cb_load_spi_eeprom_16bit
cb_spi_eeprom_code_L:
mov A, #'L'
sjmp cb_spi_eeprom_ret
cb_load_spi_eeprom_16bit:
mov R7, A ; R7 /= 2 - jedno djnz na słowo
cb_load_spi_eeprom_loop:
; rozpoczynamy zapis
bcall spi_eeprom_start_writing
jc cb_spi_eeprom_code_F
bcall cb_load_spi_eeprom_byte
jb spi_address_bits.0, cb_load_spi_eeprom_one_byte
; drugi bajt w trybie 16-bitowym
bcall cb_load_spi_eeprom_byte
cb_load_spi_eeprom_one_byte:
; opuszczamy CS na minimum T_CSL = 250 ns
clr SPI_CS ; CS=0
orl P1, #00010010b ; CS=DO=1
; DO = READY/nBUSY po max. T_SV = 500 ns
; czekamy, dopóki DO=0 (BUSY) - max. T_WC = 15 ms
; ((100+(6-1)*256)*(24+24)+6*24)/11059200 = 6 ms
; ((121+(14-1)*256)*(24+24)+14*24)/11059200 = 15 ms
mov R6, #121
mov R1, #14
cb_load_spi_eeprom_busy_loop:
jb SPI_DO, cb_load_spi_eeprom_ready ; 24 cykle
djnz R6, cb_load_spi_eeprom_busy_loop ; 24 cykle
djnz R1, cb_load_spi_eeprom_busy_loop ; 24 cykle
; coś jest nie tak - za długo DO=0
sjmp cb_spi_eeprom_code_F
cb_load_spi_eeprom_ready:
; kończymy zapis bajtu/słowa
anl P1, #11000111b ; CS=CLK=GND=0
djnz R7, cb_load_spi_eeprom_loop
; wszystko się zgadzało
sjmp cb_spi_eeprom_code_G