nand.h revision 1.18
1 /* $NetBSD: nand.h,v 1.18 2017/11/13 17:36:39 jmcneill Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 Department of Software Engineering, 5 * University of Szeged, Hungary 6 * Copyright (c) 2010 Adam Hoka <ahoka (at) NetBSD.org> 7 * All rights reserved. 8 * 9 * This code is derived from software contributed to The NetBSD Foundation 10 * by the Department of Software Engineering, University of Szeged, Hungary 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted provided that the following conditions 14 * are met: 15 * 1. Redistributions of source code must retain the above copyright 16 * notice, this list of conditions and the following disclaimer. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 22 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 23 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 24 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 25 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 */ 33 34 #ifndef _NAND_H_ 35 #define _NAND_H_ 36 37 #include <sys/param.h> 38 #include <sys/cdefs.h> 39 40 #include <sys/bufq.h> 41 #include <sys/buf.h> 42 #include <sys/time.h> 43 44 #include <dev/nand/onfi.h> 45 #include <dev/flash/flash.h> 46 #include <dev/flash/flash_io.h> 47 48 #ifdef NAND_DEBUG 49 #define DPRINTF(x) printf x 50 #else 51 #define DPRINTF(x) 52 #endif 53 54 /* same as in linux for compatibility */ 55 enum { 56 NAND_BAD_MARKER_OFFSET = 0, 57 NAND_BAD_MARKER_OFFSET_SMALL = 5 58 }; 59 60 /* feature flags use in nc_flags */ 61 enum { 62 NC_BUSWIDTH_16 = (1<<0), 63 NC_SOURCE_SYNC = (1<<2), 64 NC_INTERLEAVED_PE = (1<<1), 65 NC_INTERLEAVED_R = (1<<3), 66 NC_EXTENDED_PARAM = (1<<4) 67 }; 68 69 /* various quirks used in nc_quirks */ 70 enum { 71 NC_QUIRK_NO_READ_START = (1<<0) 72 }; 73 74 enum { 75 NAND_ECC_READ, 76 NAND_ECC_WRITE 77 }; 78 79 enum { 80 NAND_ECC_OK, 81 NAND_ECC_CORRECTED, 82 NAND_ECC_INVALID, 83 NAND_ECC_TWOBIT 84 }; 85 86 enum { 87 NAND_ECC_TYPE_HW, 88 NAND_ECC_TYPE_SW 89 }; 90 91 struct nand_bbt { 92 uint8_t *nbbt_bitmap; 93 size_t nbbt_size; 94 }; 95 96 struct nand_ecc { 97 size_t necc_offset; /* offset of ecc data in oob */ 98 size_t necc_size; /* size of ecc data in oob */ 99 size_t necc_block_size; /* block size used in ecc calc */ 100 size_t necc_code_size; /* reduntant bytes per block */ 101 int necc_steps; /* pagesize / code size */ 102 int necc_type; /* type of the ecc engine */ 103 }; 104 105 /** 106 * nand_chip: structure containing the required information 107 * about the NAND chip. 108 */ 109 struct nand_chip { 110 struct nand_ecc *nc_ecc; /* ecc information */ 111 uint8_t *nc_oob_cache; /* buffer for oob cache */ 112 uint8_t *nc_page_cache; /* buffer for page cache */ 113 uint8_t *nc_ecc_cache; /* buffer for ecc */ 114 uint64_t nc_size; /* storage size in bytes */ 115 uint32_t nc_page_size; /* page size in bytes */ 116 uint32_t nc_block_size; /* block size in bytes */ 117 uint32_t nc_lun_blocks; /* LUN size in blocks */ 118 uint32_t nc_flags; /* bitfield flags */ 119 uint32_t nc_quirks; /* bitfield quirks */ 120 uint32_t nc_page_shift; /* page shift for page alignment */ 121 uint32_t nc_page_mask; /* page mask for page alignment */ 122 uint32_t nc_block_shift; /* write shift */ 123 uint32_t nc_block_mask; /* write mask */ 124 uint16_t nc_spare_size; /* spare (oob) size in bytes */ 125 uint8_t nc_num_luns; /* number of LUNs */ 126 uint8_t nc_manf_id; /* manufacturer id */ 127 uint8_t nc_dev_id; /* device id */ 128 uint8_t nc_addr_cycles_row; /* row cycles for addressing */ 129 uint8_t nc_addr_cycles_column; /* column cycles for addressing */ 130 uint8_t nc_badmarker_offs; /* offset for marking bad blocks */ 131 bool nc_isonfi; /* if the device is onfi compliant */ 132 }; 133 134 struct nand_write_cache { 135 struct bintime nwc_creation; 136 struct bintime nwc_last_write; 137 struct bufq_state *nwc_bufq; 138 uint8_t *nwc_data; 139 daddr_t nwc_block; 140 kmutex_t nwc_lock; 141 bool nwc_write_pending; 142 struct lwp *nwc_thread; 143 kcondvar_t nwc_cv; 144 bool nwc_exiting; 145 }; 146 147 /* driver softc for nand */ 148 struct nand_softc { 149 device_t sc_dev; 150 device_t controller_dev; 151 struct nand_interface *nand_if; 152 void *nand_softc; 153 struct nand_chip sc_chip; 154 struct nand_bbt sc_bbt; 155 size_t sc_part_offset; 156 size_t sc_part_size; 157 kmutex_t sc_device_lock; /* serialize access to chip */ 158 struct flash_io sc_flash_io; 159 }; 160 161 /* structure holding the nand api */ 162 struct nand_interface { 163 /* basic nand controller commands */ 164 void (*select) (device_t, bool); /* optional */ 165 void (*command) (device_t, uint8_t); 166 void (*address) (device_t, uint8_t); 167 void (*read_buf_1) (device_t, void *, size_t); 168 void (*read_buf_2) (device_t, void *, size_t); 169 void (*read_1) (device_t, uint8_t *); 170 void (*read_2) (device_t, uint16_t *); 171 void (*write_buf_1) (device_t, const void *, size_t); 172 void (*write_buf_2) (device_t, const void *, size_t); 173 void (*write_1) (device_t, uint8_t); 174 void (*write_2) (device_t, uint16_t); 175 void (*busy) (device_t); 176 177 /* "smart" controllers may override read/program functions */ 178 int (*read_page) (device_t, size_t, uint8_t *); /* optional */ 179 int (*program_page) (device_t, size_t, const uint8_t *); /* optional */ 180 181 /* functions specific to ecc computation */ 182 int (*ecc_prepare)(device_t, int); /* optional */ 183 int (*ecc_compute)(device_t, const uint8_t *, uint8_t *); 184 int (*ecc_correct)(device_t, uint8_t *, const uint8_t *, 185 const uint8_t *); 186 187 /* information for the ecc engine */ 188 struct nand_ecc ecc; 189 190 /* flash partition information */ 191 const struct flash_partition *part_info; 192 int part_num; 193 }; 194 195 /* attach args */ 196 struct nand_attach_args { 197 struct nand_interface *naa_nand_if; 198 }; 199 200 static inline void 201 nand_busy(device_t device) 202 { 203 struct nand_softc * const sc = device_private(device); 204 205 KASSERT(sc->nand_if->select != NULL); 206 KASSERT(sc->controller_dev != NULL); 207 208 sc->nand_if->select(sc->controller_dev, true); 209 210 if (sc->nand_if->busy != NULL) { 211 sc->nand_if->busy(sc->controller_dev); 212 } 213 214 sc->nand_if->select(sc->controller_dev, false); 215 } 216 217 static inline void 218 nand_select(device_t self, bool enable) 219 { 220 struct nand_softc * const sc = device_private(self); 221 222 KASSERT(sc->nand_if->select != NULL); 223 KASSERT(sc->controller_dev != NULL); 224 225 sc->nand_if->select(sc->controller_dev, enable); 226 } 227 228 static inline void 229 nand_address(device_t self, uint32_t address) 230 { 231 struct nand_softc * const sc = device_private(self); 232 233 KASSERT(sc->nand_if->address != NULL); 234 KASSERT(sc->controller_dev != NULL); 235 236 sc->nand_if->address(sc->controller_dev, address); 237 } 238 239 static inline void 240 nand_command(device_t self, uint8_t command) 241 { 242 struct nand_softc * const sc = device_private(self); 243 244 KASSERT(sc->nand_if->command != NULL); 245 KASSERT(sc->controller_dev != NULL); 246 247 sc->nand_if->command(sc->controller_dev, command); 248 } 249 250 static inline void 251 nand_read_1(device_t self, uint8_t *data) 252 { 253 struct nand_softc * const sc = device_private(self); 254 255 KASSERT(sc->nand_if->read_1 != NULL); 256 KASSERT(sc->controller_dev != NULL); 257 258 sc->nand_if->read_1(sc->controller_dev, data); 259 } 260 261 static inline void 262 nand_write_1(device_t self, uint8_t data) 263 { 264 struct nand_softc * const sc = device_private(self); 265 266 KASSERT(sc->nand_if->write_1 != NULL); 267 KASSERT(sc->controller_dev != NULL); 268 269 sc->nand_if->write_1(sc->controller_dev, data); 270 } 271 272 static inline void 273 nand_read_2(device_t self, uint16_t *data) 274 { 275 struct nand_softc * const sc = device_private(self); 276 277 KASSERT(sc->nand_if->read_2 != NULL); 278 KASSERT(sc->controller_dev != NULL); 279 280 sc->nand_if->read_2(sc->controller_dev, data); 281 } 282 283 static inline void 284 nand_write_2(device_t self, uint16_t data) 285 { 286 struct nand_softc * const sc = device_private(self); 287 288 KASSERT(sc->nand_if->write_2 != NULL); 289 KASSERT(sc->controller_dev != NULL); 290 291 sc->nand_if->write_2(sc->controller_dev, data); 292 } 293 294 static inline void 295 nand_read_buf_1(device_t self, void *buf, size_t size) 296 { 297 struct nand_softc * const sc = device_private(self); 298 299 KASSERT(sc->nand_if->read_buf_1 != NULL); 300 KASSERT(sc->controller_dev != NULL); 301 302 sc->nand_if->read_buf_1(sc->controller_dev, buf, size); 303 } 304 305 static inline void 306 nand_read_buf_2(device_t self, void *buf, size_t size) 307 { 308 struct nand_softc * const sc = device_private(self); 309 310 KASSERT(sc->nand_if->read_buf_2 != NULL); 311 KASSERT(sc->controller_dev != NULL); 312 313 sc->nand_if->read_buf_2(sc->controller_dev, buf, size); 314 } 315 316 static inline void 317 nand_write_buf_1(device_t self, const void *buf, size_t size) 318 { 319 struct nand_softc * const sc = device_private(self); 320 321 KASSERT(sc->nand_if->write_buf_1 != NULL); 322 KASSERT(sc->controller_dev != NULL); 323 324 sc->nand_if->write_buf_1(sc->controller_dev, buf, size); 325 } 326 327 static inline void 328 nand_write_buf_2(device_t self, const void *buf, size_t size) 329 { 330 struct nand_softc * const sc = device_private(self); 331 332 KASSERT(sc->nand_if->write_buf_2 != NULL); 333 KASSERT(sc->controller_dev != NULL); 334 335 sc->nand_if->write_buf_2(sc->controller_dev, buf, size); 336 } 337 338 static inline int 339 nand_ecc_correct(device_t self, uint8_t *data, const uint8_t *oldcode, 340 const uint8_t *newcode) 341 { 342 struct nand_softc * const sc = device_private(self); 343 344 KASSERT(sc->nand_if->ecc_correct != NULL); 345 KASSERT(sc->controller_dev != NULL); 346 347 return sc->nand_if->ecc_correct(sc->controller_dev, data, oldcode, newcode); 348 } 349 350 static inline void 351 nand_ecc_compute(device_t self, const uint8_t *data, uint8_t *code) 352 { 353 struct nand_softc * const sc = device_private(self); 354 355 KASSERT(sc->nand_if->ecc_compute != NULL); 356 KASSERT(sc->controller_dev != NULL); 357 358 sc->nand_if->ecc_compute(sc->controller_dev, data, code); 359 } 360 361 static inline void 362 nand_ecc_prepare(device_t self, int mode) 363 { 364 struct nand_softc * const sc = device_private(self); 365 366 KASSERT(sc->controller_dev != NULL); 367 368 if (sc->nand_if->ecc_prepare != NULL) 369 sc->nand_if->ecc_prepare(sc->controller_dev, mode); 370 } 371 372 static inline int 373 nand_program_page(device_t self, size_t offset, const uint8_t *data) 374 { 375 struct nand_softc * const sc = device_private(self); 376 377 KASSERT(sc->nand_if->program_page != NULL); 378 379 return sc->nand_if->program_page(self, offset, data); 380 } 381 382 static inline int 383 nand_read_page(device_t self, size_t offset, uint8_t *data) 384 { 385 struct nand_softc * const sc = device_private(self); 386 387 KASSERT(sc->nand_if->read_page != NULL); 388 389 return sc->nand_if->read_page(self, offset, data); 390 } 391 392 #if 0 393 static inline bool 394 nand_block_isbad(device_t self, flash_off_t block) 395 { 396 struct nand_softc * const sc = device_private(self); 397 398 KASSERT(sc->nand_if->block_isbad != NULL); 399 KASSERT(sc->controller_dev != NULL); 400 401 return sc->nand_if->block_isbad(sc->controller_dev, block); 402 } 403 #endif 404 405 /* Manufacturer IDs defined by JEDEC */ 406 enum { 407 NAND_MFR_UNKNOWN = 0x00, 408 NAND_MFR_AMD = 0x01, 409 NAND_MFR_FUJITSU = 0x04, 410 NAND_MFR_RENESAS = 0x07, 411 NAND_MFR_STMICRO = 0x20, 412 NAND_MFR_MICRON = 0x2c, 413 NAND_MFR_NATIONAL = 0x8f, 414 NAND_MFR_TOSHIBA = 0x98, 415 NAND_MFR_HYNIX = 0xad, 416 NAND_MFR_SAMSUNG = 0xec 417 }; 418 419 struct nand_manufacturer { 420 int id; 421 const char *name; 422 }; 423 424 extern const struct nand_manufacturer nand_mfrs[]; 425 426 /* 427 * Manufacturer specific parameter functions 428 */ 429 int nand_read_parameters_micron(device_t, struct nand_chip *); 430 int nand_read_parameters_samsung(device_t, struct nand_chip *); 431 int nand_read_parameters_toshiba(device_t, struct nand_chip *); 432 433 /* debug inlines */ 434 435 static inline void 436 nand_dump_data(const char *name, void *data, size_t len) 437 { 438 uint8_t *dump = data; 439 int i; 440 441 printf("dumping %s\n--------------\n", name); 442 for (i = 0; i < len; i++) { 443 printf("0x%.2hhx ", *dump); 444 dump++; 445 } 446 printf("\n--------------\n"); 447 } 448 449 /* flash interface implementation */ 450 int nand_flash_isbad(device_t, flash_off_t, bool *); 451 int nand_flash_markbad(device_t, flash_off_t); 452 int nand_flash_write(device_t, flash_off_t, size_t, size_t *, const u_char *); 453 int nand_flash_read(device_t, flash_off_t, size_t, size_t *, uint8_t *); 454 int nand_flash_erase(device_t, struct flash_erase_instruction *); 455 int nand_flash_submit(device_t, struct buf *); 456 457 /* nand specific functions */ 458 int nand_erase_block(device_t, size_t); 459 460 bool nand_isfactorybad(device_t, flash_off_t); 461 bool nand_iswornoutbad(device_t, flash_off_t); 462 bool nand_isbad(device_t, flash_off_t); 463 void nand_markbad(device_t, size_t); 464 465 //int nand_read_page(device_t, size_t, uint8_t *); 466 int nand_read_oob(device_t, size_t, uint8_t *); 467 //int nand_program_page(device_t, size_t, const uint8_t *); 468 469 device_t nand_attach_mi(struct nand_interface *, device_t); 470 void nand_init_interface(struct nand_interface *); 471 void nand_attach_mtdparts(device_t, const char *, const char *); 472 473 /* controller drivers may use these functions to get info about the chip */ 474 void nand_read_id(device_t, uint8_t *, uint8_t *); 475 int nand_read_parameter_page(device_t, struct onfi_parameter_page *); 476 477 /* 478 * default functions for driver development 479 */ 480 void nand_default_select(device_t, bool); 481 int nand_default_ecc_compute(device_t, const uint8_t *, uint8_t *); 482 int nand_default_ecc_correct(device_t, uint8_t *, const uint8_t *, 483 const uint8_t *); 484 int nand_default_read_page(device_t, size_t, uint8_t *); 485 int nand_default_program_page(device_t, size_t, const uint8_t *); 486 487 static inline void nand_busy(device_t); 488 static inline void nand_select(device_t, bool); 489 static inline void nand_command(device_t, uint8_t); 490 static inline void nand_address(device_t, uint32_t); 491 static inline void nand_read_buf_1(device_t, void *, size_t); 492 static inline void nand_read_buf_2(device_t, void *, size_t); 493 static inline void nand_read_1(device_t, uint8_t *); 494 static inline void nand_write_buf_1(device_t, const void *, size_t); 495 static inline void nand_write_buf_2(device_t, const void *, size_t); 496 //static inline bool nand_block_isbad(device_t, off_t); 497 //static inline void nand_block_markbad(device_t, off_t); 498 //static inline bool nand_isbusy(device_t); 499 500 #endif /* _NAND_H_ */ 501
Indexes created Wed Oct 01 19:09:53 GMT 2025