CFI: fix eraseregions numblocks
[platform/kernel/u-boot.git] / drivers / mtd / cfi_mtd.c
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>
28 #include <malloc.h>
29
30 #include <asm/errno.h>
31 #include <linux/mtd/mtd.h>
32 #include <linux/mtd/concat.h>
33
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
41 extern flash_info_t flash_info[];
42
43 static struct mtd_info cfi_mtd_info[CFI_MAX_FLASH_BANKS];
44 static char cfi_mtd_names[CFI_MAX_FLASH_BANKS][16];
45 #ifdef CONFIG_MTD_CONCAT
46 static char c_mtd_name[16];
47 #endif
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
58         for (sect = 0; sect < fi->sector_count; sect++) {
59                 if (a_start == fi->start[sect])
60                         s_first = sect;
61
62                 if (sect < fi->sector_count - 1) {
63                         if (a_end == fi->start[sect + 1]) {
64                                 s_last = sect;
65                                 break;
66                         }
67                 } else {
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
133 static int cfi_mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
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
145 static int cfi_mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
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;
160         int sect_size_old = 0;
161         int sect;
162         int regions = 0;
163         int numblocks = 0;
164         ulong offset;
165         ulong base_addr;
166
167         /*
168          * First detect the number of eraseregions so that we can allocate
169          * the array of eraseregions correctly
170          */
171         for (sect = 0; sect < fi->sector_count; sect++) {
172                 if (sect_size_old != flash_sector_size(fi, sect))
173                         regions++;
174                 sect_size_old = flash_sector_size(fi, sect);
175         }
176
177         switch (regions) {
178         case 0:
179                 return 1;
180         case 1: /* flash has uniform erase size */
181                 mtd->numeraseregions = 0;
182                 mtd->erasesize = sect_size_old;
183                 return 0;
184         }
185
186         mtd->numeraseregions = regions;
187         mtd->eraseregions = malloc(sizeof(struct mtd_erase_region_info) * regions);
188
189         /*
190          * Now detect the largest sector and fill the eraseregions
191          */
192         regions = 0;
193         base_addr = offset = fi->start[0];
194         sect_size_old = flash_sector_size(fi, 0);
195         for (sect = 0; sect < fi->sector_count; sect++) {
196                 if (sect_size_old != flash_sector_size(fi, sect)) {
197                         mtd->eraseregions[regions].offset = offset - base_addr;
198                         mtd->eraseregions[regions].erasesize = sect_size_old;
199                         mtd->eraseregions[regions].numblocks = numblocks;
200                         /* Now start counting the next eraseregions */
201                         numblocks = 0;
202                         regions++;
203                         offset = fi->start[sect];
204                 }
205                 numblocks++;
206
207                 /*
208                  * Select the largest sector size as erasesize (e.g. for UBI)
209                  */
210                 if (flash_sector_size(fi, sect) > sect_size)
211                         sect_size = flash_sector_size(fi, sect);
212
213                 sect_size_old = flash_sector_size(fi, sect);
214         }
215
216         /*
217          * Set the last region
218          */
219         mtd->eraseregions[regions].offset = offset - base_addr;
220         mtd->eraseregions[regions].erasesize = sect_size_old;
221         mtd->eraseregions[regions].numblocks = numblocks;
222
223         mtd->erasesize = sect_size;
224
225         return 0;
226 }
227
228 int cfi_mtd_init(void)
229 {
230         struct mtd_info *mtd;
231         flash_info_t *fi;
232         int error, i;
233         int devices_found = 0;
234         struct mtd_info *mtd_list[CONFIG_SYS_MAX_FLASH_BANKS];
235
236         for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
237                 fi = &flash_info[i];
238                 mtd = &cfi_mtd_info[i];
239
240                 memset(mtd, 0, sizeof(struct mtd_info));
241
242                 error = cfi_mtd_set_erasesize(mtd, fi);
243                 if (error)
244                         continue;
245
246                 sprintf(cfi_mtd_names[i], "nor%d", i);
247                 mtd->name               = cfi_mtd_names[i];
248                 mtd->type               = MTD_NORFLASH;
249                 mtd->flags              = MTD_CAP_NORFLASH;
250                 mtd->size               = fi->size;
251                 mtd->writesize          = 1;
252
253                 mtd->erase              = cfi_mtd_erase;
254                 mtd->read               = cfi_mtd_read;
255                 mtd->write              = cfi_mtd_write;
256                 mtd->sync               = cfi_mtd_sync;
257                 mtd->lock               = cfi_mtd_lock;
258                 mtd->unlock             = cfi_mtd_unlock;
259                 mtd->priv               = fi;
260
261                 if (add_mtd_device(mtd))
262                         return -ENOMEM;
263
264                 mtd_list[devices_found++] = mtd;
265         }
266
267 #ifdef CONFIG_MTD_CONCAT
268         if (devices_found > 1) {
269                 /*
270                  * We detected multiple devices. Concatenate them together.
271                  */
272                 sprintf(c_mtd_name, "nor%d", devices_found);
273                 mtd = mtd_concat_create(mtd_list, devices_found, c_mtd_name);
274
275                 if (mtd == NULL)
276                         return -ENXIO;
277
278                 if (add_mtd_device(mtd))
279                         return -ENOMEM;
280         }
281 #endif /* CONFIG_MTD_CONCAT */
282
283         return 0;
284 }