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 } 285