]>
Commit | Line | Data |
---|---|---|
91809ed5 PZ |
1 | /* |
2 | * (C) Copyright 2008 Semihalf | |
3 | * | |
4 | * Written by: Piotr Ziecik <kosmo@semihalf.com> | |
5 | * | |
6 | * See file CREDITS for list of people who contributed to this | |
7 | * project. | |
8 | * | |
9 | * This program is free software; you can redistribute it and/or | |
10 | * modify it under the terms of the GNU General Public License as | |
11 | * published by the Free Software Foundation; either version 2 of | |
12 | * the License, or (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, | |
22 | * MA 02111-1307 USA | |
23 | * | |
24 | */ | |
25 | ||
26 | #include <common.h> | |
27 | #include <flash.h> | |
0a572655 | 28 | #include <malloc.h> |
91809ed5 PZ |
29 | |
30 | #include <asm/errno.h> | |
31 | #include <linux/mtd/mtd.h> | |
0a572655 | 32 | #include <linux/mtd/concat.h> |
91809ed5 | 33 | |
9578718c KP |
34 | /* use CONFIG_SYS_MAX_FLASH_BANKS_DETECT if defined */ |
35 | #ifdef CONFIG_SYS_MAX_FLASH_BANKS_DETECT | |
36 | # define CFI_MAX_FLASH_BANKS CONFIG_SYS_MAX_FLASH_BANKS_DETECT | |
37 | #else | |
38 | # define CFI_MAX_FLASH_BANKS CONFIG_SYS_MAX_FLASH_BANKS | |
39 | #endif | |
40 | ||
91809ed5 PZ |
41 | extern flash_info_t flash_info[]; |
42 | ||
9578718c KP |
43 | static struct mtd_info cfi_mtd_info[CFI_MAX_FLASH_BANKS]; |
44 | static char cfi_mtd_names[CFI_MAX_FLASH_BANKS][16]; | |
0a572655 SR |
45 | #ifdef CONFIG_MTD_CONCAT |
46 | static char c_mtd_name[16]; | |
47 | #endif | |
91809ed5 PZ |
48 | |
49 | static int cfi_mtd_erase(struct mtd_info *mtd, struct erase_info *instr) | |
50 | { | |
51 | flash_info_t *fi = mtd->priv; | |
52 | size_t a_start = fi->start[0] + instr->addr; | |
53 | size_t a_end = a_start + instr->len; | |
54 | int s_first = -1; | |
55 | int s_last = -1; | |
56 | int error, sect; | |
57 | ||
dba6fcf6 | 58 | for (sect = 0; sect < fi->sector_count; sect++) { |
91809ed5 PZ |
59 | if (a_start == fi->start[sect]) |
60 | s_first = sect; | |
61 | ||
dba6fcf6 SR |
62 | if (sect < fi->sector_count - 1) { |
63 | if (a_end == fi->start[sect + 1]) { | |
64 | s_last = sect; | |
65 | break; | |
66 | } | |
67 | } else { | |
91809ed5 PZ |
68 | s_last = sect; |
69 | break; | |
70 | } | |
71 | } | |
72 | ||
73 | if (s_first >= 0 && s_first <= s_last) { | |
74 | instr->state = MTD_ERASING; | |
75 | ||
76 | flash_set_verbose(0); | |
77 | error = flash_erase(fi, s_first, s_last); | |
78 | flash_set_verbose(1); | |
79 | ||
80 | if (error) { | |
81 | instr->state = MTD_ERASE_FAILED; | |
82 | return -EIO; | |
83 | } | |
84 | ||
85 | instr->state = MTD_ERASE_DONE; | |
86 | mtd_erase_callback(instr); | |
87 | return 0; | |
88 | } | |
89 | ||
90 | return -EINVAL; | |
91 | } | |
92 | ||
93 | static int cfi_mtd_read(struct mtd_info *mtd, loff_t from, size_t len, | |
94 | size_t *retlen, u_char *buf) | |
95 | { | |
96 | flash_info_t *fi = mtd->priv; | |
97 | u_char *f = (u_char*)(fi->start[0]) + from; | |
98 | ||
99 | memcpy(buf, f, len); | |
100 | *retlen = len; | |
101 | ||
102 | return 0; | |
103 | } | |
104 | ||
105 | static int cfi_mtd_write(struct mtd_info *mtd, loff_t to, size_t len, | |
106 | size_t *retlen, const u_char *buf) | |
107 | { | |
108 | flash_info_t *fi = mtd->priv; | |
109 | u_long t = fi->start[0] + to; | |
110 | int error; | |
111 | ||
112 | flash_set_verbose(0); | |
113 | error = write_buff(fi, (u_char*)buf, t, len); | |
114 | flash_set_verbose(1); | |
115 | ||
116 | if (!error) { | |
117 | *retlen = len; | |
118 | return 0; | |
119 | } | |
120 | ||
121 | return -EIO; | |
122 | } | |
123 | ||
124 | static void cfi_mtd_sync(struct mtd_info *mtd) | |
125 | { | |
126 | /* | |
127 | * This function should wait until all pending operations | |
128 | * finish. However this driver is fully synchronous, so | |
129 | * this function returns immediately | |
130 | */ | |
131 | } | |
132 | ||
8d2effea | 133 | static int cfi_mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len) |
91809ed5 PZ |
134 | { |
135 | flash_info_t *fi = mtd->priv; | |
136 | ||
137 | flash_set_verbose(0); | |
138 | flash_protect(FLAG_PROTECT_SET, fi->start[0] + ofs, | |
139 | fi->start[0] + ofs + len - 1, fi); | |
140 | flash_set_verbose(1); | |
141 | ||
142 | return 0; | |
143 | } | |
144 | ||
8d2effea | 145 | static int cfi_mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len) |
91809ed5 PZ |
146 | { |
147 | flash_info_t *fi = mtd->priv; | |
148 | ||
149 | flash_set_verbose(0); | |
150 | flash_protect(FLAG_PROTECT_CLEAR, fi->start[0] + ofs, | |
151 | fi->start[0] + ofs + len - 1, fi); | |
152 | flash_set_verbose(1); | |
153 | ||
154 | return 0; | |
155 | } | |
156 | ||
157 | static int cfi_mtd_set_erasesize(struct mtd_info *mtd, flash_info_t *fi) | |
158 | { | |
159 | int sect_size = 0; | |
0a572655 | 160 | int sect_size_old = 0; |
91809ed5 | 161 | int sect; |
0a572655 SR |
162 | int regions = 0; |
163 | int numblocks = 0; | |
164 | ulong offset = 0; | |
165 | ulong base_addr = fi->start[0]; | |
91809ed5 | 166 | |
f8e2b310 | 167 | /* |
0a572655 SR |
168 | * First detect the number of eraseregions so that we can allocate |
169 | * the array of eraseregions correctly | |
f8e2b310 | 170 | */ |
91809ed5 | 171 | for (sect = 0; sect < fi->sector_count; sect++) { |
0a572655 SR |
172 | if (sect_size_old != flash_sector_size(fi, sect)) |
173 | regions++; | |
174 | sect_size_old = flash_sector_size(fi, sect); | |
175 | } | |
176 | ||
177 | mtd->eraseregions = malloc(sizeof(struct mtd_erase_region_info) * regions); | |
178 | ||
179 | /* | |
180 | * Now detect the largest sector and fill the eraseregions | |
181 | */ | |
182 | sect_size_old = 0; | |
183 | regions = 0; | |
184 | for (sect = 0; sect < fi->sector_count; sect++) { | |
185 | if ((sect_size_old != flash_sector_size(fi, sect)) && | |
186 | (sect_size_old != 0)) { | |
187 | mtd->eraseregions[regions].offset = offset - base_addr; | |
188 | mtd->eraseregions[regions].erasesize = sect_size_old; | |
189 | mtd->eraseregions[regions].numblocks = numblocks; | |
190 | ||
191 | /* Now start counting the next eraseregions */ | |
192 | numblocks = 0; | |
193 | regions++; | |
194 | } else { | |
195 | numblocks++; | |
196 | } | |
197 | ||
198 | if (sect_size_old != flash_sector_size(fi, sect)) | |
199 | offset = fi->start[sect]; | |
200 | ||
201 | /* | |
202 | * Select the largest sector size as erasesize (e.g. for UBI) | |
203 | */ | |
f8e2b310 | 204 | if (flash_sector_size(fi, sect) > sect_size) |
91809ed5 | 205 | sect_size = flash_sector_size(fi, sect); |
0a572655 SR |
206 | |
207 | sect_size_old = flash_sector_size(fi, sect); | |
91809ed5 PZ |
208 | } |
209 | ||
0a572655 SR |
210 | /* |
211 | * Set the last region | |
212 | */ | |
213 | mtd->eraseregions[regions].offset = offset - base_addr; | |
214 | mtd->eraseregions[regions].erasesize = sect_size_old; | |
215 | mtd->eraseregions[regions].numblocks = numblocks + 1; | |
216 | ||
217 | if (regions) | |
218 | mtd->numeraseregions = regions + 1; | |
219 | else | |
220 | mtd->numeraseregions = 0; | |
221 | ||
91809ed5 PZ |
222 | mtd->erasesize = sect_size; |
223 | ||
224 | return 0; | |
225 | } | |
226 | ||
227 | int cfi_mtd_init(void) | |
228 | { | |
229 | struct mtd_info *mtd; | |
230 | flash_info_t *fi; | |
231 | int error, i; | |
0a572655 SR |
232 | int devices_found = 0; |
233 | struct mtd_info *mtd_list[CONFIG_SYS_MAX_FLASH_BANKS]; | |
91809ed5 PZ |
234 | |
235 | for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) { | |
236 | fi = &flash_info[i]; | |
237 | mtd = &cfi_mtd_info[i]; | |
238 | ||
239 | memset(mtd, 0, sizeof(struct mtd_info)); | |
240 | ||
241 | error = cfi_mtd_set_erasesize(mtd, fi); | |
242 | if (error) | |
243 | continue; | |
244 | ||
c203ef5d AH |
245 | sprintf(cfi_mtd_names[i], "nor%d", i); |
246 | mtd->name = cfi_mtd_names[i]; | |
91809ed5 PZ |
247 | mtd->type = MTD_NORFLASH; |
248 | mtd->flags = MTD_CAP_NORFLASH; | |
249 | mtd->size = fi->size; | |
250 | mtd->writesize = 1; | |
251 | ||
252 | mtd->erase = cfi_mtd_erase; | |
253 | mtd->read = cfi_mtd_read; | |
254 | mtd->write = cfi_mtd_write; | |
255 | mtd->sync = cfi_mtd_sync; | |
256 | mtd->lock = cfi_mtd_lock; | |
257 | mtd->unlock = cfi_mtd_unlock; | |
258 | mtd->priv = fi; | |
259 | ||
260 | if (add_mtd_device(mtd)) | |
261 | return -ENOMEM; | |
0a572655 SR |
262 | |
263 | mtd_list[devices_found++] = mtd; | |
264 | } | |
265 | ||
266 | #ifdef CONFIG_MTD_CONCAT | |
267 | if (devices_found > 1) { | |
268 | /* | |
269 | * We detected multiple devices. Concatenate them together. | |
270 | */ | |
271 | sprintf(c_mtd_name, "nor%d", devices_found); | |
272 | mtd = mtd_concat_create(mtd_list, devices_found, c_mtd_name); | |
273 | ||
274 | if (mtd == NULL) | |
275 | return -ENXIO; | |
276 | ||
277 | if (add_mtd_device(mtd)) | |
278 | return -ENOMEM; | |
91809ed5 | 279 | } |
0a572655 | 280 | #endif /* CONFIG_MTD_CONCAT */ |
91809ed5 PZ |
281 | |
282 | return 0; | |
283 | } |