1 /* 2 * This file is part of the Serial Flash Universal Driver Library. 3 * 4 * Copyright (c) 2016, Armink, <[email protected]> 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining 7 * a copy of this software and associated documentation files (the 8 * 'Software'), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sublicense, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be 15 * included in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, 18 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 20 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 21 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 * 25 * Function: Analyze the SFDP (Serial Flash Discoverable Parameters) which from JESD216/A/B (V1.X) standard. 26 * JESD216 (V1.0) document: http://www.jedec.org/sites/default/files/docs/JESD216.pdf 27 * JESD216A (V1.5) document: http://www.jedec.org/sites/default/files/docs/JESD216A.pdf 28 * JESD216B (V1.6) document: http://www.jedec.org/sites/default/files/docs/JESD216B.pdf 29 * 30 * Created on: 2016-05-26 31 */ 32 33 #include "../inc/sfud.h" 34 35 /** 36 * JEDEC Standard JESD216 Terms and definitions: 37 * 38 * DWORD: Four consecutive 8-bit bytes used as the basic 32-bit building block for headers and parameter tables. 39 * 40 * Sector: The minimum granularity - size and alignment - of an area that can be erased in the data array 41 * of a flash memory device. Different areas within the address range of the data array may have a different 42 * minimum erase granularity (sector size). 43 */ 44 45 #ifdef SFUD_USING_SFDP 46 47 /* support maximum SFDP major revision by driver */ 48 #define SUPPORT_MAX_SFDP_MAJOR_REV 1 49 /* the JEDEC basic flash parameter table length is 9 DWORDs (288-bit) on JESD216 (V1.0) initial release standard */ 50 #define BASIC_TABLE_LEN 9 51 /* the smallest eraser in SFDP eraser table */ 52 #define SMALLEST_ERASER_INDEX 0 53 /** 54 * SFDP parameter header structure 55 */ 56 typedef struct { 57 uint8_t id; /**< Parameter ID LSB */ 58 uint8_t minor_rev; /**< Parameter minor revision */ 59 uint8_t major_rev; /**< Parameter major revision */ 60 uint8_t len; /**< Parameter table length(in double words) */ 61 uint32_t ptp; /**< Parameter table 24bit pointer (byte address) */ 62 } sfdp_para_header; 63 64 static sfud_err read_sfdp_data(const sfud_flash *flash, uint32_t addr, uint8_t *read_buf, size_t size); 65 static bool read_sfdp_header(sfud_flash *flash); 66 static bool read_basic_header(const sfud_flash *flash, sfdp_para_header *basic_header); 67 static bool read_basic_table(sfud_flash *flash, sfdp_para_header *basic_header); 68 69 /* ../port/sfup_port.c */ 70 extern void sfud_log_debug(const char *file, const long line, const char *format, ...); 71 extern void sfud_log_info(const char *format, ...); 72 73 /** 74 * Read SFDP parameter information 75 * 76 * @param flash flash device 77 * 78 * @return true: read OK 79 */ 80 bool sfud_read_sfdp(sfud_flash *flash) { 81 SFUD_ASSERT(flash); 82 83 /* JEDEC basic flash parameter header */ 84 sfdp_para_header basic_header; 85 if (read_sfdp_header(flash) && read_basic_header(flash, &basic_header)) { 86 return read_basic_table(flash, &basic_header); 87 } else { 88 SFUD_INFO("Warning: Read SFDP parameter header information failed. The %s is not support JEDEC SFDP.", flash->name); 89 return false; 90 } 91 } 92 93 /** 94 * Read SFDP parameter header 95 * 96 * @param flash flash device 97 * 98 * @return true: read OK 99 */ 100 static bool read_sfdp_header(sfud_flash *flash) { 101 sfud_sfdp *sfdp = &flash->sfdp; 102 /* The SFDP header is located at address 000000h of the SFDP data structure. 103 * It identifies the SFDP Signature, the number of parameter headers, and the SFDP revision numbers. */ 104 /* sfdp parameter header address */ 105 uint32_t header_addr = 0; 106 /* each parameter header being 2 DWORDs (64-bit) */ 107 uint8_t header[2 * 4] = { 0 }; 108 109 SFUD_ASSERT(flash); 110 111 sfdp->available = false; 112 /* read SFDP header */ 113 if (read_sfdp_data(flash, header_addr, header, sizeof(header)) != SFUD_SUCCESS) { 114 SFUD_INFO("Error: Can't read SFDP header."); 115 return false; 116 } 117 /* check SFDP header */ 118 if (!(header[0] == 'S' && 119 header[1] == 'F' && 120 header[2] == 'D' && 121 header[3] == 'P')) { 122 SFUD_DEBUG("Error: Check SFDP signature error. It's must be 50444653h('S' 'F' 'D' 'P')."); 123 return false; 124 } 125 sfdp->minor_rev = header[4]; 126 sfdp->major_rev = header[5]; 127 if (sfdp->major_rev > SUPPORT_MAX_SFDP_MAJOR_REV) { 128 SFUD_INFO("Error: This reversion(V%d.%d) SFDP is not supported.", sfdp->major_rev, sfdp->minor_rev); 129 return false; 130 } 131 SFUD_DEBUG("Check SFDP header is OK. The reversion is V%d.%d, NPN is %d.", sfdp->major_rev, sfdp->minor_rev, 132 header[6]); 133 134 return true; 135 } 136 137 /** 138 * Read JEDEC basic parameter header 139 * 140 * @param flash flash device 141 * 142 * @return true: read OK 143 */ 144 static bool read_basic_header(const sfud_flash *flash, sfdp_para_header *basic_header) { 145 /* The basic parameter header is mandatory, is defined by this standard, and starts at byte offset 08h. */ 146 uint32_t header_addr = 8; 147 /* each parameter header being 2 DWORDs (64-bit) */ 148 uint8_t header[2 * 4] = { 0 }; 149 150 SFUD_ASSERT(flash); 151 SFUD_ASSERT(basic_header); 152 153 /* read JEDEC basic flash parameter header */ 154 if (read_sfdp_data(flash, header_addr, header, sizeof(header)) != SFUD_SUCCESS) { 155 SFUD_INFO("Error: Can't read JEDEC basic flash parameter header."); 156 return false; 157 } 158 basic_header->id = header[0]; 159 basic_header->minor_rev = header[1]; 160 basic_header->major_rev = header[2]; 161 basic_header->len = header[3]; 162 basic_header->ptp = (long)header[4] | (long)header[5] << 8 | (long)header[6] << 16; 163 /* check JEDEC basic flash parameter header */ 164 if (basic_header->major_rev > SUPPORT_MAX_SFDP_MAJOR_REV) { 165 SFUD_INFO("Error: This reversion(V%d.%d) JEDEC basic flash parameter header is not supported.", 166 basic_header->major_rev, basic_header->minor_rev); 167 return false; 168 } 169 if (basic_header->len < BASIC_TABLE_LEN) { 170 SFUD_INFO("Error: The JEDEC basic flash parameter table length (now is %d) error.", basic_header->len); 171 return false; 172 } 173 SFUD_DEBUG("Check JEDEC basic flash parameter header is OK. The table id is %d, reversion is V%d.%d," 174 " length is %d, parameter table pointer is 0x%06lX.", basic_header->id, basic_header->major_rev, 175 basic_header->minor_rev, basic_header->len, basic_header->ptp); 176 177 return true; 178 } 179 180 /** 181 * Read JEDEC basic parameter table 182 * 183 * @param flash flash device 184 * 185 * @return true: read OK 186 */ 187 static bool read_basic_table(sfud_flash *flash, sfdp_para_header *basic_header) { 188 sfud_sfdp *sfdp = &flash->sfdp; 189 /* parameter table address */ 190 uint32_t table_addr = basic_header->ptp; 191 /* parameter table */ 192 uint8_t table[BASIC_TABLE_LEN * 4] = { 0 }, i, j; 193 194 SFUD_ASSERT(flash); 195 SFUD_ASSERT(basic_header); 196 197 /* read JEDEC basic flash parameter table */ 198 if (read_sfdp_data(flash, table_addr, table, sizeof(table)) != SFUD_SUCCESS) { 199 SFUD_INFO("Warning: Can't read JEDEC basic flash parameter table."); 200 return false; 201 } 202 /* print JEDEC basic flash parameter table info */ 203 SFUD_DEBUG("JEDEC basic flash parameter table info:"); 204 SFUD_DEBUG("MSB-LSB 3 2 1 0"); 205 for (i = 0; i < BASIC_TABLE_LEN; i++) { 206 SFUD_DEBUG("[%04d] 0x%02X 0x%02X 0x%02X 0x%02X", i + 1, table[i * 4 + 3], table[i * 4 + 2], table[i * 4 + 1], 207 table[i * 4]); 208 } 209 210 /* get block/sector 4 KB erase supported and command */ 211 sfdp->erase_4k_cmd = table[1]; 212 switch (table[0] & 0x03) { 213 case 1: 214 sfdp->erase_4k = true; 215 SFUD_DEBUG("4 KB Erase is supported throughout the device. Command is 0x%02X.", sfdp->erase_4k_cmd); 216 break; 217 case 3: 218 sfdp->erase_4k = false; 219 SFUD_DEBUG("Uniform 4 KB erase is unavailable for this device."); 220 break; 221 default: 222 SFUD_INFO("Error: Uniform 4 KB erase supported information error."); 223 return false; 224 } 225 /* get write granularity */ 226 //TODO ĿǰΪ 1.0 ���ṩ�ķ�ʽ������֧�� V1.5 �����ϵķ�ʽ��ȡ page size 227 switch ((table[0] & (0x01 << 2)) >> 2) { 228 case 0: 229 sfdp->write_gran = 1; 230 SFUD_DEBUG("Write granularity is 1 byte."); 231 break; 232 case 1: 233 sfdp->write_gran = 256; 234 SFUD_DEBUG("Write granularity is 64 bytes or larger."); 235 break; 236 } 237 /* volatile status register block protect bits */ 238 switch ((table[0] & (0x01 << 3)) >> 3) { 239 case 0: 240 /* Block Protect bits in device's status register are solely non-volatile or may be 241 * programmed either as volatile using the 50h instruction for write enable or non-volatile 242 * using the 06h instruction for write enable. 243 */ 244 sfdp->sr_is_non_vola = true; 245 SFUD_DEBUG("Target flash status register is non-volatile."); 246 break; 247 case 1: 248 /* block protect bits in device's status register are solely volatile. */ 249 sfdp->sr_is_non_vola = false; 250 SFUD_DEBUG("Block Protect bits in device's status register are solely volatile."); 251 /* write enable instruction select for writing to volatile status register */ 252 switch ((table[0] & (0x01 << 4)) >> 4) { 253 case 0: 254 sfdp->vola_sr_we_cmd = SFUD_VOLATILE_SR_WRITE_ENABLE; 255 SFUD_DEBUG("Flash device requires instruction 50h as the write enable prior " 256 "to performing a volatile write to the status register."); 257 break; 258 case 1: 259 sfdp->vola_sr_we_cmd = SFUD_CMD_WRITE_ENABLE; 260 SFUD_DEBUG("Flash device requires instruction 06h as the write enable prior " 261 "to performing a volatile write to the status register."); 262 break; 263 } 264 break; 265 } 266 /* get address bytes, number of bytes used in addressing flash array read, write and erase. */ 267 switch ((table[2] & (0x03 << 1)) >> 1) { 268 case 0: 269 sfdp->addr_3_byte = true; 270 sfdp->addr_4_byte = false; 271 SFUD_DEBUG("3-Byte only addressing."); 272 break; 273 case 1: 274 sfdp->addr_3_byte = true; 275 sfdp->addr_4_byte = true; 276 SFUD_DEBUG("3- or 4-Byte addressing."); 277 break; 278 case 2: 279 sfdp->addr_3_byte = false; 280 sfdp->addr_4_byte = true; 281 SFUD_DEBUG("4-Byte only addressing."); 282 break; 283 default: 284 sfdp->addr_3_byte = false; 285 sfdp->addr_4_byte = false; 286 SFUD_INFO("Error: Read address bytes error!"); 287 return false; 288 } 289 /* get flash memory capacity */ 290 uint32_t table2_temp = ((long)table[7] << 24) | ((long)table[6] << 16) | ((long)table[5] << 8) | (long)table[4]; 291 switch ((table[7] & (0x01 << 7)) >> 7) { 292 case 0: 293 sfdp->capacity = 1 + (table2_temp >> 3); 294 break; 295 case 1: 296 table2_temp &= 0x7FFFFFFF; 297 if (table2_temp > sizeof(sfdp->capacity) * 8 + 3) { 298 sfdp->capacity = 0; 299 SFUD_INFO("Error: The flash capacity is grater than 32 Gb/ 4 GB! Not Supported."); 300 return false; 301 } 302 sfdp->capacity = 1L << (table2_temp - 3); 303 break; 304 } 305 SFUD_DEBUG("Capacity is %ld Bytes.", sfdp->capacity); 306 /* get erase size and erase command */ 307 for (i = 0, j = 0; i < SFUD_SFDP_ERASE_TYPE_MAX_NUM; i++) { 308 if (table[28 + 2 * i] != 0x00) { 309 sfdp->eraser[j].size = 1L << table[28 + 2 * i]; 310 sfdp->eraser[j].cmd = table[28 + 2 * i + 1]; 311 SFUD_DEBUG("Flash device supports %ldKB block erase. Command is 0x%02X.", sfdp->eraser[j].size / 1024, 312 sfdp->eraser[j].cmd); 313 j++; 314 } 315 } 316 /* sort the eraser size from small to large */ 317 for (i = 0, j = 0; i < SFUD_SFDP_ERASE_TYPE_MAX_NUM; i++) { 318 if (sfdp->eraser[i].size) { 319 for (j = i + 1; j < SFUD_SFDP_ERASE_TYPE_MAX_NUM; j++) { 320 if (sfdp->eraser[j].size != 0 && sfdp->eraser[i].size > sfdp->eraser[j].size) { 321 /* swap the small eraser */ 322 uint32_t temp_size = sfdp->eraser[i].size; 323 uint8_t temp_cmd = sfdp->eraser[i].cmd; 324 sfdp->eraser[i].size = sfdp->eraser[j].size; 325 sfdp->eraser[i].cmd = sfdp->eraser[j].cmd; 326 sfdp->eraser[j].size = temp_size; 327 sfdp->eraser[j].cmd = temp_cmd; 328 } 329 } 330 } 331 } 332 333 sfdp->available = true; 334 return true; 335 } 336 337 static sfud_err read_sfdp_data(const sfud_flash *flash, uint32_t addr, uint8_t *read_buf, size_t size) { 338 uint8_t cmd[] = { 339 SFUD_CMD_READ_SFDP_REGISTER, 340 (addr >> 16) & 0xFF, 341 (addr >> 8) & 0xFF, 342 (addr >> 0) & 0xFF, 343 SFUD_DUMMY_DATA, 344 }; 345 346 SFUD_ASSERT(flash); 347 SFUD_ASSERT(addr < 1L << 24); 348 SFUD_ASSERT(read_buf); 349 SFUD_ASSERT(flash->spi.wr); 350 351 return flash->spi.wr(&flash->spi, cmd, sizeof(cmd), read_buf, size); 352 } 353 354 /** 355 * get the most suitable eraser for erase process from SFDP parameter 356 * 357 * @param flash flash device 358 * @param addr start address 359 * @param erase_size will be erased size 360 * 361 * @return the eraser index of SFDP eraser table @see sfud_sfdp.eraser[] 362 */ 363 size_t sfud_sfdp_get_suitable_eraser(const sfud_flash *flash, uint32_t addr, size_t erase_size) { 364 size_t index = SMALLEST_ERASER_INDEX, i; 365 /* only used when flash supported SFDP */ 366 SFUD_ASSERT(flash->sfdp.available); 367 /* the address isn't align by smallest eraser's size, then use the smallest eraser */ 368 if (addr % flash->sfdp.eraser[SMALLEST_ERASER_INDEX].size) { 369 return SMALLEST_ERASER_INDEX; 370 } 371 /* Find the suitable eraser. 372 * The largest size eraser is at the end of eraser table. 373 * In order to decrease erase command counts, so the find process is from the end of eraser table. */ 374 for (i = SFUD_SFDP_ERASE_TYPE_MAX_NUM - 1;; i--) { 375 if ((flash->sfdp.eraser[i].size != 0) && (erase_size >= flash->sfdp.eraser[i].size) 376 && (addr % flash->sfdp.eraser[i].size == 0)) { 377 index = i; 378 break; 379 } 380 if (i == SMALLEST_ERASER_INDEX) { 381 break; 382 } 383 } 384 return index; 385 } 386 387 #endif /* SFUD_USING_SFDP */ 388