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