mtd: cfi - if defined, use MAX_FLASH_BANKS_DETECT for static declarations
[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 = 0;
165         ulong base_addr = fi->start[0];
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         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                  */
204                 if (flash_sector_size(fi, sect) > sect_size)
205                         sect_size = flash_sector_size(fi, sect);
206
207                 sect_size_old = flash_sector_size(fi, sect);
208         }
209
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
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;
232         int devices_found = 0;
233         struct mtd_info *mtd_list[CONFIG_SYS_MAX_FLASH_BANKS];
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
245                 sprintf(cfi_mtd_names[i], "nor%d", i);
246                 mtd->name               = cfi_mtd_names[i];
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;
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;
279         }
280 #endif /* CONFIG_MTD_CONCAT */
281
282         return 0;
283 }