1 /* 2 * (C) Copyright 2000 3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 /* #define DEBUG */ 9 10 #include <common.h> 11 #include <flash.h> 12 13 #include <mtd/cfi_flash.h> 14 15 extern flash_info_t flash_info[]; /* info for FLASH chips */ 16 17 /*----------------------------------------------------------------------- 18 * Functions 19 */ 20 21 /*----------------------------------------------------------------------- 22 * Set protection status for monitor sectors 23 * 24 * The monitor is always located in the _first_ Flash bank. 25 * If necessary you have to map the second bank at lower addresses. 26 */ 27 void 28 flash_protect (int flag, ulong from, ulong to, flash_info_t *info) 29 { 30 ulong b_end; 31 short s_end; 32 int i; 33 34 /* Do nothing if input data is bad. */ 35 if (!info || info->sector_count == 0 || info->size == 0 || to < from) { 36 return; 37 } 38 39 s_end = info->sector_count - 1; /* index of last sector */ 40 b_end = info->start[0] + info->size - 1; /* bank end address */ 41 42 debug ("flash_protect %s: from 0x%08lX to 0x%08lX\n", 43 (flag & FLAG_PROTECT_SET) ? "ON" : 44 (flag & FLAG_PROTECT_CLEAR) ? "OFF" : "???", 45 from, to); 46 47 /* There is nothing to do if we have no data about the flash 48 * or the protect range and flash range don't overlap. 49 */ 50 if (info->flash_id == FLASH_UNKNOWN || 51 to < info->start[0] || from > b_end) { 52 return; 53 } 54 55 for (i=0; i<info->sector_count; ++i) { 56 ulong end; /* last address in current sect */ 57 58 end = (i == s_end) ? b_end : info->start[i + 1] - 1; 59 60 /* Update protection if any part of the sector 61 * is in the specified range. 62 */ 63 if (from <= end && to >= info->start[i]) { 64 if (flag & FLAG_PROTECT_CLEAR) { 65 #if defined(CONFIG_SYS_FLASH_PROTECTION) 66 flash_real_protect(info, i, 0); 67 #else 68 info->protect[i] = 0; 69 #endif /* CONFIG_SYS_FLASH_PROTECTION */ 70 debug ("protect off %d\n", i); 71 } 72 else if (flag & FLAG_PROTECT_SET) { 73 #if defined(CONFIG_SYS_FLASH_PROTECTION) 74 flash_real_protect(info, i, 1); 75 #else 76 info->protect[i] = 1; 77 #endif /* CONFIG_SYS_FLASH_PROTECTION */ 78 debug ("protect on %d\n", i); 79 } 80 } 81 } 82 } 83 84 /*----------------------------------------------------------------------- 85 */ 86 87 flash_info_t * 88 addr2info (ulong addr) 89 { 90 flash_info_t *info; 91 int i; 92 93 for (i=0, info = &flash_info[0]; i<CONFIG_SYS_MAX_FLASH_BANKS; ++i, ++info) { 94 if (info->flash_id != FLASH_UNKNOWN && 95 addr >= info->start[0] && 96 /* WARNING - The '- 1' is needed if the flash 97 * is at the end of the address space, since 98 * info->start[0] + info->size wraps back to 0. 99 * Please don't change this unless you understand this. 100 */ 101 addr <= info->start[0] + info->size - 1) { 102 return (info); 103 } 104 } 105 106 return (NULL); 107 } 108 109 /*----------------------------------------------------------------------- 110 * Copy memory to flash. 111 * Make sure all target addresses are within Flash bounds, 112 * and no protected sectors are hit. 113 * Returns: 114 * ERR_OK 0 - OK 115 * ERR_TIMOUT 1 - write timeout 116 * ERR_NOT_ERASED 2 - Flash not erased 117 * ERR_PROTECTED 4 - target range includes protected sectors 118 * ERR_INVAL 8 - target address not in Flash memory 119 * ERR_ALIGN 16 - target address not aligned on boundary 120 * (only some targets require alignment) 121 */ 122 int 123 flash_write (char *src, ulong addr, ulong cnt) 124 { 125 int i; 126 ulong end = addr + cnt - 1; 127 flash_info_t *info_first = addr2info (addr); 128 flash_info_t *info_last = addr2info (end ); 129 flash_info_t *info; 130 __maybe_unused char *src_orig = src; 131 __maybe_unused char *addr_orig = (char *)addr; 132 __maybe_unused ulong cnt_orig = cnt; 133 134 if (cnt == 0) { 135 return (ERR_OK); 136 } 137 138 if (!info_first || !info_last) { 139 return (ERR_INVAL); 140 } 141 142 for (info = info_first; info <= info_last; ++info) { 143 ulong b_end = info->start[0] + info->size; /* bank end addr */ 144 short s_end = info->sector_count - 1; 145 for (i=0; i<info->sector_count; ++i) { 146 ulong e_addr = (i == s_end) ? b_end : info->start[i + 1]; 147 148 if ((end >= info->start[i]) && (addr < e_addr) && 149 (info->protect[i] != 0) ) { 150 return (ERR_PROTECTED); 151 } 152 } 153 } 154 155 /* finally write data to flash */ 156 for (info = info_first; info <= info_last && cnt>0; ++info) { 157 ulong len; 158 159 len = info->start[0] + info->size - addr; 160 if (len > cnt) 161 len = cnt; 162 if ((i = write_buff(info, (uchar *)src, addr, len)) != 0) { 163 return (i); 164 } 165 cnt -= len; 166 addr += len; 167 src += len; 168 } 169 170 #if defined(CONFIG_FLASH_VERIFY) 171 if (memcmp(src_orig, addr_orig, cnt_orig)) { 172 printf("\nVerify failed!\n"); 173 return ERR_PROG_ERROR; 174 } 175 #endif /* CONFIG_SYS_FLASH_VERIFY_AFTER_WRITE */ 176 177 return (ERR_OK); 178 } 179 180 /*----------------------------------------------------------------------- 181 */ 182 183 void flash_perror (int err) 184 { 185 switch (err) { 186 case ERR_OK: 187 break; 188 case ERR_TIMOUT: 189 puts ("Timeout writing to Flash\n"); 190 break; 191 case ERR_NOT_ERASED: 192 puts ("Flash not Erased\n"); 193 break; 194 case ERR_PROTECTED: 195 puts ("Can't write to protected Flash sectors\n"); 196 break; 197 case ERR_INVAL: 198 puts ("Outside available Flash\n"); 199 break; 200 case ERR_ALIGN: 201 puts ("Start and/or end address not on sector boundary\n"); 202 break; 203 case ERR_UNKNOWN_FLASH_VENDOR: 204 puts ("Unknown Vendor of Flash\n"); 205 break; 206 case ERR_UNKNOWN_FLASH_TYPE: 207 puts ("Unknown Type of Flash\n"); 208 break; 209 case ERR_PROG_ERROR: 210 puts ("General Flash Programming Error\n"); 211 break; 212 case ERR_ABORTED: 213 puts("Flash Programming Aborted\n"); 214 break; 215 default: 216 printf ("%s[%d] FIXME: rc=%d\n", __FILE__, __LINE__, err); 217 break; 218 } 219 } 220