blob: 709a48642d6056ef66feafa6bb6af84e2df49387 [file] [log] [blame]
Piotr Ziecik91809ed2008-11-17 15:57:58 +01001/*
2 * (C) Copyright 2008 Semihalf
3 *
4 * Written by: Piotr Ziecik <kosmo@semihalf.com>
5 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02006 * SPDX-License-Identifier: GPL-2.0+
Piotr Ziecik91809ed2008-11-17 15:57:58 +01007 */
8
9#include <common.h>
10#include <flash.h>
Stefan Roese0a572652009-05-12 14:29:39 +020011#include <malloc.h>
Piotr Ziecik91809ed2008-11-17 15:57:58 +010012
13#include <asm/errno.h>
14#include <linux/mtd/mtd.h>
Stefan Roese0a572652009-05-12 14:29:39 +020015#include <linux/mtd/concat.h>
Stefan Roese3c299752010-08-31 10:04:11 +020016#include <mtd/cfi_flash.h>
Piotr Ziecik91809ed2008-11-17 15:57:58 +010017
Kim Phillips95787182009-07-14 16:00:24 -050018static struct mtd_info cfi_mtd_info[CFI_MAX_FLASH_BANKS];
19static char cfi_mtd_names[CFI_MAX_FLASH_BANKS][16];
Stefan Roese0a572652009-05-12 14:29:39 +020020#ifdef CONFIG_MTD_CONCAT
21static char c_mtd_name[16];
22#endif
Piotr Ziecik91809ed2008-11-17 15:57:58 +010023
24static 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
Stefan Roesedba6fcf2009-05-11 15:54:13 +020033 for (sect = 0; sect < fi->sector_count; sect++) {
Piotr Ziecik91809ed2008-11-17 15:57:58 +010034 if (a_start == fi->start[sect])
35 s_first = sect;
36
Stefan Roesedba6fcf2009-05-11 15:54:13 +020037 if (sect < fi->sector_count - 1) {
38 if (a_end == fi->start[sect + 1]) {
39 s_last = sect;
40 break;
41 }
42 } else {
Piotr Ziecik91809ed2008-11-17 15:57:58 +010043 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
68static 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 memcpy(buf, f, len);
75 *retlen = len;
76
77 return 0;
78}
79
80static int cfi_mtd_write(struct mtd_info *mtd, loff_t to, size_t len,
81 size_t *retlen, const u_char *buf)
82{
83 flash_info_t *fi = mtd->priv;
84 u_long t = fi->start[0] + to;
85 int error;
86
87 flash_set_verbose(0);
88 error = write_buff(fi, (u_char*)buf, t, len);
89 flash_set_verbose(1);
90
91 if (!error) {
92 *retlen = len;
93 return 0;
94 }
95
96 return -EIO;
97}
98
99static void cfi_mtd_sync(struct mtd_info *mtd)
100{
101 /*
102 * This function should wait until all pending operations
103 * finish. However this driver is fully synchronous, so
104 * this function returns immediately
105 */
106}
107
Stefan Roese8d2effe2009-05-11 16:03:55 +0200108static int cfi_mtd_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100109{
110 flash_info_t *fi = mtd->priv;
111
112 flash_set_verbose(0);
113 flash_protect(FLAG_PROTECT_SET, fi->start[0] + ofs,
114 fi->start[0] + ofs + len - 1, fi);
115 flash_set_verbose(1);
116
117 return 0;
118}
119
Stefan Roese8d2effe2009-05-11 16:03:55 +0200120static int cfi_mtd_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100121{
122 flash_info_t *fi = mtd->priv;
123
124 flash_set_verbose(0);
125 flash_protect(FLAG_PROTECT_CLEAR, fi->start[0] + ofs,
126 fi->start[0] + ofs + len - 1, fi);
127 flash_set_verbose(1);
128
129 return 0;
130}
131
132static int cfi_mtd_set_erasesize(struct mtd_info *mtd, flash_info_t *fi)
133{
134 int sect_size = 0;
Stefan Roese0a572652009-05-12 14:29:39 +0200135 int sect_size_old = 0;
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100136 int sect;
Stefan Roese0a572652009-05-12 14:29:39 +0200137 int regions = 0;
138 int numblocks = 0;
Ladislav Michlf3dec792010-01-28 12:27:14 +0100139 ulong offset;
140 ulong base_addr;
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100141
Stefan Roesef8e2b312009-03-18 11:17:37 +0100142 /*
Stefan Roese0a572652009-05-12 14:29:39 +0200143 * First detect the number of eraseregions so that we can allocate
144 * the array of eraseregions correctly
Stefan Roesef8e2b312009-03-18 11:17:37 +0100145 */
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100146 for (sect = 0; sect < fi->sector_count; sect++) {
Stefan Roese0a572652009-05-12 14:29:39 +0200147 if (sect_size_old != flash_sector_size(fi, sect))
148 regions++;
149 sect_size_old = flash_sector_size(fi, sect);
150 }
151
Ladislav Michlf3dec792010-01-28 12:27:14 +0100152 switch (regions) {
153 case 0:
154 return 1;
155 case 1: /* flash has uniform erase size */
156 mtd->numeraseregions = 0;
157 mtd->erasesize = sect_size_old;
158 return 0;
159 }
160
161 mtd->numeraseregions = regions;
Stefan Roese0a572652009-05-12 14:29:39 +0200162 mtd->eraseregions = malloc(sizeof(struct mtd_erase_region_info) * regions);
163
164 /*
165 * Now detect the largest sector and fill the eraseregions
166 */
Stefan Roese0a572652009-05-12 14:29:39 +0200167 regions = 0;
Ladislav Michlf3dec792010-01-28 12:27:14 +0100168 base_addr = offset = fi->start[0];
169 sect_size_old = flash_sector_size(fi, 0);
Stefan Roese0a572652009-05-12 14:29:39 +0200170 for (sect = 0; sect < fi->sector_count; sect++) {
Ladislav Michlf3dec792010-01-28 12:27:14 +0100171 if (sect_size_old != flash_sector_size(fi, sect)) {
Stefan Roese0a572652009-05-12 14:29:39 +0200172 mtd->eraseregions[regions].offset = offset - base_addr;
173 mtd->eraseregions[regions].erasesize = sect_size_old;
174 mtd->eraseregions[regions].numblocks = numblocks;
Stefan Roese0a572652009-05-12 14:29:39 +0200175 /* Now start counting the next eraseregions */
176 numblocks = 0;
177 regions++;
Stefan Roese0a572652009-05-12 14:29:39 +0200178 offset = fi->start[sect];
Ladislav Michlf3dec792010-01-28 12:27:14 +0100179 }
180 numblocks++;
Stefan Roese0a572652009-05-12 14:29:39 +0200181
182 /*
183 * Select the largest sector size as erasesize (e.g. for UBI)
184 */
Stefan Roesef8e2b312009-03-18 11:17:37 +0100185 if (flash_sector_size(fi, sect) > sect_size)
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100186 sect_size = flash_sector_size(fi, sect);
Stefan Roese0a572652009-05-12 14:29:39 +0200187
188 sect_size_old = flash_sector_size(fi, sect);
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100189 }
190
Stefan Roese0a572652009-05-12 14:29:39 +0200191 /*
192 * Set the last region
193 */
194 mtd->eraseregions[regions].offset = offset - base_addr;
195 mtd->eraseregions[regions].erasesize = sect_size_old;
Ladislav Michlf3dec792010-01-28 12:27:14 +0100196 mtd->eraseregions[regions].numblocks = numblocks;
Stefan Roese0a572652009-05-12 14:29:39 +0200197
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100198 mtd->erasesize = sect_size;
199
200 return 0;
201}
202
203int cfi_mtd_init(void)
204{
205 struct mtd_info *mtd;
206 flash_info_t *fi;
207 int error, i;
Wolfgang Denk419a1fe2011-10-05 22:48:12 +0200208#ifdef CONFIG_MTD_CONCAT
Stefan Roese0a572652009-05-12 14:29:39 +0200209 int devices_found = 0;
210 struct mtd_info *mtd_list[CONFIG_SYS_MAX_FLASH_BANKS];
Wolfgang Denk419a1fe2011-10-05 22:48:12 +0200211#endif
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100212
213 for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
214 fi = &flash_info[i];
215 mtd = &cfi_mtd_info[i];
216
217 memset(mtd, 0, sizeof(struct mtd_info));
218
219 error = cfi_mtd_set_erasesize(mtd, fi);
220 if (error)
221 continue;
222
Andreas Huberc203ef52009-04-02 17:15:34 +0200223 sprintf(cfi_mtd_names[i], "nor%d", i);
224 mtd->name = cfi_mtd_names[i];
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100225 mtd->type = MTD_NORFLASH;
226 mtd->flags = MTD_CAP_NORFLASH;
227 mtd->size = fi->size;
228 mtd->writesize = 1;
Heiko Schocher65e5cb52014-10-31 11:29:45 +0100229 mtd->writebufsize = mtd->writesize;
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100230
Sergey Lapindfe64e22013-01-14 03:46:50 +0000231 mtd->_erase = cfi_mtd_erase;
232 mtd->_read = cfi_mtd_read;
233 mtd->_write = cfi_mtd_write;
234 mtd->_sync = cfi_mtd_sync;
235 mtd->_lock = cfi_mtd_lock;
236 mtd->_unlock = cfi_mtd_unlock;
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100237 mtd->priv = fi;
238
239 if (add_mtd_device(mtd))
240 return -ENOMEM;
Stefan Roese0a572652009-05-12 14:29:39 +0200241
Wolfgang Denk419a1fe2011-10-05 22:48:12 +0200242#ifdef CONFIG_MTD_CONCAT
Stefan Roese0a572652009-05-12 14:29:39 +0200243 mtd_list[devices_found++] = mtd;
Wolfgang Denk419a1fe2011-10-05 22:48:12 +0200244#endif
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100245 }
246
Stefan Roese0a572652009-05-12 14:29:39 +0200247#ifdef CONFIG_MTD_CONCAT
248 if (devices_found > 1) {
249 /*
250 * We detected multiple devices. Concatenate them together.
251 */
252 sprintf(c_mtd_name, "nor%d", devices_found);
253 mtd = mtd_concat_create(mtd_list, devices_found, c_mtd_name);
254
255 if (mtd == NULL)
256 return -ENXIO;
257
258 if (add_mtd_device(mtd))
259 return -ENOMEM;
260 }
261#endif /* CONFIG_MTD_CONCAT */
262
Piotr Ziecik91809ed2008-11-17 15:57:58 +0100263 return 0;
264}