1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * (C) Copyright 2008 Semihalf
4 *
5 * Written by: Piotr Ziecik <kosmo@semihalf.com>
6 */
7
8 #include <common.h>
9 #include <dma.h>
10 #include <flash.h>
11 #include <malloc.h>
12
13 #include <linux/errno.h>
14 #include <linux/mtd/mtd.h>
15 #include <linux/mtd/concat.h>
16 #include <mtd/cfi_flash.h>
17
18 static struct mtd_info cfi_mtd_info[CFI_MAX_FLASH_BANKS];
19 static char cfi_mtd_names[CFI_MAX_FLASH_BANKS][16];
20 #ifdef CONFIG_MTD_CONCAT
21 static char c_mtd_name[16];
22 #endif
23
cfi_mtd_erase(struct mtd_info * mtd,struct erase_info * instr)24 static int cfi_mtd_erase(struct mtd_info *mtd, struct erase_info *instr)
25 {
26 flash_info_t *fi = mtd->priv;
27 size_t a_start = fi->start[0] + instr->addr;
28 size_t a_end = a_start + instr->len;
29 int s_first = -1;
30 int s_last = -1;
31 int error, sect;
32
33 for (sect = 0; sect < fi->sector_count; sect++) {
34 if (a_start == fi->start[sect])
35 s_first = sect;
36
37 if (sect < fi->sector_count - 1) {
38 if (a_end == fi->start[sect + 1]) {
39 s_last = sect;
40 break;
41 }
42 } else {
43 s_last = sect;
44 break;
45 }
46 }
47
48 if (s_first >= 0 && s_first <= s_last) {
49 instr->state = MTD_ERASING;
50
51 flash_set_verbose(0);
52 error = flash_erase(fi, s_first, s_last);
53 flash_set_verbose(1);
54
55 if (error) {
56 instr->state = MTD_ERASE_FAILED;
57 return -EIO;
58 }
59
60 instr->state = MTD_ERASE_DONE;
61 mtd_erase_callback(instr);
62 return 0;
63 }
64
65 return -EINVAL;
66 }
67
cfi_mtd_read(struct mtd_info * mtd,loff_t from,size_t len,size_t * retlen,u_char * buf)68 static int cfi_mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
69 size_t *retlen, u_char *buf)
70 {
71 flash_info_t *fi = mtd->priv;
72 u_char *f = (u_char*)(fi->start[0]) + from;
73
74 if (dma_memcpy(buf, f, len) < 0)
75 memcpy(buf, f, len);
76 *retlen = len;
77
78 return 0;
79 }
80
cfi_mtd_write(struct mtd_info * mtd,loff_t to,size_t len,size_t * retlen,const u_char * buf)81 static int cfi_mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
82 size_t *retlen, const u_char *buf)
83 {
84 flash_info_t *fi = mtd->priv;
85 u_long t = fi->start[0] + to;
86 int error;
87
88 flash_set_verbose(0);
89 error = write_buff(fi, (u_char*)buf, t, len);
90 flash_set_verbose(1);
91
92 if (!error) {
93 *retlen = len;
94 return 0;
95 }
96
97 return -EIO;
98 }
99
cfi_mtd_sync(struct mtd_info * mtd)100 static void cfi_mtd_sync(struct mtd_info *mtd)
101 {
102 /*
103 * This function should wait until all pending operations
104 * finish. However this driver is fully synchronous, so
105 * this function returns immediately
106 */
107 }
108
cfi_mtd_lock(struct mtd_info * mtd,loff_t ofs,uint64_t len)109 static int cfi_mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
110 {
111 flash_info_t *fi = mtd->priv;
112
113 flash_set_verbose(0);
114 flash_protect(FLAG_PROTECT_SET, fi->start[0] + ofs,
115 fi->start[0] + ofs + len - 1, fi);
116 flash_set_verbose(1);
117
118 return 0;
119 }
120
cfi_mtd_unlock(struct mtd_info * mtd,loff_t ofs,uint64_t len)121 static int cfi_mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
122 {
123 flash_info_t *fi = mtd->priv;
124
125 flash_set_verbose(0);
126 flash_protect(FLAG_PROTECT_CLEAR, fi->start[0] + ofs,
127 fi->start[0] + ofs + len - 1, fi);
128 flash_set_verbose(1);
129
130 return 0;
131 }
132
cfi_mtd_set_erasesize(struct mtd_info * mtd,flash_info_t * fi)133 static int cfi_mtd_set_erasesize(struct mtd_info *mtd, flash_info_t *fi)
134 {
135 int sect_size = 0;
136 int sect_size_old = 0;
137 int sect;
138 int regions = 0;
139 int numblocks = 0;
140 ulong offset;
141 ulong base_addr;
142
143 /*
144 * First detect the number of eraseregions so that we can allocate
145 * the array of eraseregions correctly
146 */
147 for (sect = 0; sect < fi->sector_count; sect++) {
148 if (sect_size_old != flash_sector_size(fi, sect))
149 regions++;
150 sect_size_old = flash_sector_size(fi, sect);
151 }
152
153 switch (regions) {
154 case 0:
155 return 1;
156 case 1: /* flash has uniform erase size */
157 mtd->numeraseregions = 0;
158 mtd->erasesize = sect_size_old;
159 return 0;
160 }
161
162 mtd->numeraseregions = regions;
163 mtd->eraseregions = malloc(sizeof(struct mtd_erase_region_info) * regions);
164
165 /*
166 * Now detect the largest sector and fill the eraseregions
167 */
168 regions = 0;
169 base_addr = offset = fi->start[0];
170 sect_size_old = flash_sector_size(fi, 0);
171 for (sect = 0; sect < fi->sector_count; sect++) {
172 if (sect_size_old != flash_sector_size(fi, sect)) {
173 mtd->eraseregions[regions].offset = offset - base_addr;
174 mtd->eraseregions[regions].erasesize = sect_size_old;
175 mtd->eraseregions[regions].numblocks = numblocks;
176 /* Now start counting the next eraseregions */
177 numblocks = 0;
178 regions++;
179 offset = fi->start[sect];
180 }
181 numblocks++;
182
183 /*
184 * Select the largest sector size as erasesize (e.g. for UBI)
185 */
186 if (flash_sector_size(fi, sect) > sect_size)
187 sect_size = flash_sector_size(fi, sect);
188
189 sect_size_old = flash_sector_size(fi, sect);
190 }
191
192 /*
193 * Set the last region
194 */
195 mtd->eraseregions[regions].offset = offset - base_addr;
196 mtd->eraseregions[regions].erasesize = sect_size_old;
197 mtd->eraseregions[regions].numblocks = numblocks;
198
199 mtd->erasesize = sect_size;
200
201 return 0;
202 }
203
cfi_mtd_init(void)204 int cfi_mtd_init(void)
205 {
206 struct mtd_info *mtd;
207 flash_info_t *fi;
208 int error, i;
209 #ifdef CONFIG_MTD_CONCAT
210 int devices_found = 0;
211 struct mtd_info *mtd_list[CONFIG_SYS_MAX_FLASH_BANKS];
212 #endif
213
214 for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
215 fi = &flash_info[i];
216 mtd = &cfi_mtd_info[i];
217
218 memset(mtd, 0, sizeof(struct mtd_info));
219
220 error = cfi_mtd_set_erasesize(mtd, fi);
221 if (error)
222 continue;
223
224 sprintf(cfi_mtd_names[i], "nor%d", i);
225 mtd->name = cfi_mtd_names[i];
226 mtd->type = MTD_NORFLASH;
227 mtd->flags = MTD_CAP_NORFLASH;
228 mtd->size = fi->size;
229 mtd->writesize = 1;
230 mtd->writebufsize = mtd->writesize;
231
232 mtd->_erase = cfi_mtd_erase;
233 mtd->_read = cfi_mtd_read;
234 mtd->_write = cfi_mtd_write;
235 mtd->_sync = cfi_mtd_sync;
236 mtd->_lock = cfi_mtd_lock;
237 mtd->_unlock = cfi_mtd_unlock;
238 mtd->priv = fi;
239
240 if (add_mtd_device(mtd))
241 return -ENOMEM;
242
243 #ifdef CONFIG_MTD_CONCAT
244 mtd_list[devices_found++] = mtd;
245 #endif
246 }
247
248 #ifdef CONFIG_MTD_CONCAT
249 if (devices_found > 1) {
250 /*
251 * We detected multiple devices. Concatenate them together.
252 */
253 sprintf(c_mtd_name, "nor%d", devices_found);
254 mtd = mtd_concat_create(mtd_list, devices_found, c_mtd_name);
255
256 if (mtd == NULL)
257 return -ENXIO;
258
259 if (add_mtd_device(mtd))
260 return -ENOMEM;
261 }
262 #endif /* CONFIG_MTD_CONCAT */
263
264 return 0;
265 }
266