]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * (C) Copyright 2000 | |
3 | * Wolfgang Denk, DENX Software Engineering, wd@denx.de. | |
4 | * | |
5 | * SPDX-License-Identifier: GPL-2.0+ | |
6 | */ | |
7 | ||
8 | /* #define DEBUG */ | |
9 | ||
10 | #include <common.h> | |
11 | #include <flash.h> | |
12 | ||
13 | #include <mtd/cfi_flash.h> | |
14 | ||
15 | extern flash_info_t flash_info[]; /* info for FLASH chips */ | |
16 | ||
17 | /*----------------------------------------------------------------------- | |
18 | * Functions | |
19 | */ | |
20 | ||
21 | /*----------------------------------------------------------------------- | |
22 | * Set protection status for monitor sectors | |
23 | * | |
24 | * The monitor is always located in the _first_ Flash bank. | |
25 | * If necessary you have to map the second bank at lower addresses. | |
26 | */ | |
27 | void | |
28 | flash_protect (int flag, ulong from, ulong to, flash_info_t *info) | |
29 | { | |
30 | ulong b_end; | |
31 | short s_end; | |
32 | int i; | |
33 | ||
34 | /* Do nothing if input data is bad. */ | |
35 | if (!info || info->sector_count == 0 || info->size == 0 || to < from) { | |
36 | return; | |
37 | } | |
38 | ||
39 | s_end = info->sector_count - 1; /* index of last sector */ | |
40 | b_end = info->start[0] + info->size - 1; /* bank end address */ | |
41 | ||
42 | debug ("flash_protect %s: from 0x%08lX to 0x%08lX\n", | |
43 | (flag & FLAG_PROTECT_SET) ? "ON" : | |
44 | (flag & FLAG_PROTECT_CLEAR) ? "OFF" : "???", | |
45 | from, to); | |
46 | ||
47 | /* There is nothing to do if we have no data about the flash | |
48 | * or the protect range and flash range don't overlap. | |
49 | */ | |
50 | if (info->flash_id == FLASH_UNKNOWN || | |
51 | to < info->start[0] || from > b_end) { | |
52 | return; | |
53 | } | |
54 | ||
55 | for (i=0; i<info->sector_count; ++i) { | |
56 | ulong end; /* last address in current sect */ | |
57 | ||
58 | end = (i == s_end) ? b_end : info->start[i + 1] - 1; | |
59 | ||
60 | /* Update protection if any part of the sector | |
61 | * is in the specified range. | |
62 | */ | |
63 | if (from <= end && to >= info->start[i]) { | |
64 | if (flag & FLAG_PROTECT_CLEAR) { | |
65 | #if defined(CONFIG_SYS_FLASH_PROTECTION) | |
66 | flash_real_protect(info, i, 0); | |
67 | #else | |
68 | info->protect[i] = 0; | |
69 | #endif /* CONFIG_SYS_FLASH_PROTECTION */ | |
70 | debug ("protect off %d\n", i); | |
71 | } | |
72 | else if (flag & FLAG_PROTECT_SET) { | |
73 | #if defined(CONFIG_SYS_FLASH_PROTECTION) | |
74 | flash_real_protect(info, i, 1); | |
75 | #else | |
76 | info->protect[i] = 1; | |
77 | #endif /* CONFIG_SYS_FLASH_PROTECTION */ | |
78 | debug ("protect on %d\n", i); | |
79 | } | |
80 | } | |
81 | } | |
82 | } | |
83 | ||
84 | /*----------------------------------------------------------------------- | |
85 | */ | |
86 | ||
87 | flash_info_t * | |
88 | addr2info (ulong addr) | |
89 | { | |
90 | flash_info_t *info; | |
91 | int i; | |
92 | ||
93 | for (i=0, info = &flash_info[0]; i<CONFIG_SYS_MAX_FLASH_BANKS; ++i, ++info) { | |
94 | if (info->flash_id != FLASH_UNKNOWN && | |
95 | addr >= info->start[0] && | |
96 | /* WARNING - The '- 1' is needed if the flash | |
97 | * is at the end of the address space, since | |
98 | * info->start[0] + info->size wraps back to 0. | |
99 | * Please don't change this unless you understand this. | |
100 | */ | |
101 | addr <= info->start[0] + info->size - 1) { | |
102 | return (info); | |
103 | } | |
104 | } | |
105 | ||
106 | return (NULL); | |
107 | } | |
108 | ||
109 | /*----------------------------------------------------------------------- | |
110 | * Copy memory to flash. | |
111 | * Make sure all target addresses are within Flash bounds, | |
112 | * and no protected sectors are hit. | |
113 | * Returns: | |
114 | * ERR_OK 0 - OK | |
115 | * ERR_TIMEOUT 1 - write timeout | |
116 | * ERR_NOT_ERASED 2 - Flash not erased | |
117 | * ERR_PROTECTED 4 - target range includes protected sectors | |
118 | * ERR_INVAL 8 - target address not in Flash memory | |
119 | * ERR_ALIGN 16 - target address not aligned on boundary | |
120 | * (only some targets require alignment) | |
121 | */ | |
122 | int | |
123 | flash_write (char *src, ulong addr, ulong cnt) | |
124 | { | |
125 | int i; | |
126 | ulong end = addr + cnt - 1; | |
127 | flash_info_t *info_first = addr2info (addr); | |
128 | flash_info_t *info_last = addr2info (end ); | |
129 | flash_info_t *info; | |
130 | __maybe_unused char *src_orig = src; | |
131 | __maybe_unused char *addr_orig = (char *)addr; | |
132 | __maybe_unused ulong cnt_orig = cnt; | |
133 | ||
134 | if (cnt == 0) { | |
135 | return (ERR_OK); | |
136 | } | |
137 | ||
138 | if (!info_first || !info_last) { | |
139 | return (ERR_INVAL); | |
140 | } | |
141 | ||
142 | for (info = info_first; info <= info_last; ++info) { | |
143 | ulong b_end = info->start[0] + info->size; /* bank end addr */ | |
144 | short s_end = info->sector_count - 1; | |
145 | for (i=0; i<info->sector_count; ++i) { | |
146 | ulong e_addr = (i == s_end) ? b_end : info->start[i + 1]; | |
147 | ||
148 | if ((end >= info->start[i]) && (addr < e_addr) && | |
149 | (info->protect[i] != 0) ) { | |
150 | return (ERR_PROTECTED); | |
151 | } | |
152 | } | |
153 | } | |
154 | ||
155 | /* finally write data to flash */ | |
156 | for (info = info_first; info <= info_last && cnt>0; ++info) { | |
157 | ulong len; | |
158 | ||
159 | len = info->start[0] + info->size - addr; | |
160 | if (len > cnt) | |
161 | len = cnt; | |
162 | if ((i = write_buff(info, (uchar *)src, addr, len)) != 0) { | |
163 | return (i); | |
164 | } | |
165 | cnt -= len; | |
166 | addr += len; | |
167 | src += len; | |
168 | } | |
169 | ||
170 | #if defined(CONFIG_FLASH_VERIFY) | |
171 | if (memcmp(src_orig, addr_orig, cnt_orig)) { | |
172 | printf("\nVerify failed!\n"); | |
173 | return ERR_PROG_ERROR; | |
174 | } | |
175 | #endif /* CONFIG_SYS_FLASH_VERIFY_AFTER_WRITE */ | |
176 | ||
177 | return (ERR_OK); | |
178 | } | |
179 | ||
180 | /*----------------------------------------------------------------------- | |
181 | */ | |
182 | ||
183 | void flash_perror (int err) | |
184 | { | |
185 | switch (err) { | |
186 | case ERR_OK: | |
187 | break; | |
188 | case ERR_TIMEOUT: | |
189 | puts ("Timeout writing to Flash\n"); | |
190 | break; | |
191 | case ERR_NOT_ERASED: | |
192 | puts ("Flash not Erased\n"); | |
193 | break; | |
194 | case ERR_PROTECTED: | |
195 | puts ("Can't write to protected Flash sectors\n"); | |
196 | break; | |
197 | case ERR_INVAL: | |
198 | puts ("Outside available Flash\n"); | |
199 | break; | |
200 | case ERR_ALIGN: | |
201 | puts ("Start and/or end address not on sector boundary\n"); | |
202 | break; | |
203 | case ERR_UNKNOWN_FLASH_VENDOR: | |
204 | puts ("Unknown Vendor of Flash\n"); | |
205 | break; | |
206 | case ERR_UNKNOWN_FLASH_TYPE: | |
207 | puts ("Unknown Type of Flash\n"); | |
208 | break; | |
209 | case ERR_PROG_ERROR: | |
210 | puts ("General Flash Programming Error\n"); | |
211 | break; | |
212 | case ERR_ABORTED: | |
213 | puts("Flash Programming Aborted\n"); | |
214 | break; | |
215 | default: | |
216 | printf ("%s[%d] FIXME: rc=%d\n", __FILE__, __LINE__, err); | |
217 | break; | |
218 | } | |
219 | } |