1 /* $NetBSD: nor.c,v 1.7 2021/08/07 16:19:13 thorpej Exp $ */ 2 3 /*- 4 * Copyright (c) 2011 Department of Software Engineering, 5 * University of Szeged, Hungary 6 * Copyright (c) 2011 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 /* Common driver for NOR chips implementing the ONFI CFI specification */ 35 36 #include <sys/cdefs.h> 37 __KERNEL_RCSID(0, "$NetBSD: nor.c,v 1.7 2021/08/07 16:19:13 thorpej Exp $"); 38 39 #include "locators.h" 40 #include "opt_nor.h" 41 42 #include <sys/param.h> 43 #include <sys/types.h> 44 #include <sys/device.h> 45 #include <sys/kmem.h> 46 #include <sys/sysctl.h> 47 #include <sys/atomic.h> 48 49 #include <dev/flash/flash.h> 50 #include <dev/flash/flash_io.h> 51 #include <dev/nor/nor.h> 52 53 54 static int nor_match(device_t, cfdata_t, void *); 55 static void nor_attach(device_t, device_t, void *); 56 static int nor_detach(device_t, int); 57 static bool nor_shutdown(device_t, int); 58 static int nor_print(void *, const char *); 59 static int nor_search(device_t, cfdata_t, const int *, void *); 60 61 /* flash interface implementation */ 62 static int nor_flash_isbad(device_t, flash_off_t, bool *); 63 static int nor_flash_markbad(device_t, flash_off_t); 64 static int nor_flash_write(device_t, flash_off_t, size_t, size_t *, 65 const u_char *); 66 static int nor_flash_read(device_t, flash_off_t, size_t, size_t *, uint8_t *); 67 static int nor_flash_erase_all(device_t); 68 static int nor_flash_erase(device_t, struct flash_erase_instruction *); 69 static int nor_flash_submit(device_t, buf_t *); 70 71 /* default functions for driver development */ 72 static void nor_default_select(device_t, bool); 73 static int nor_default_read_page(device_t, flash_off_t, uint8_t *); 74 static int nor_default_program_page(device_t, flash_off_t, const uint8_t *); 75 76 static int nor_scan_media(device_t, struct nor_chip *); 77 78 CFATTACH_DECL_NEW(nor, sizeof(struct nor_softc), 79 nor_match, nor_attach, nor_detach, NULL); 80 81 #ifdef NOR_DEBUG 82 int nordebug = NOR_DEBUG; 83 #endif 84 85 int nor_cachesync_timeout = 1; 86 int nor_cachesync_nodenum; 87 88 struct flash_interface nor_flash_if = { 89 .type = FLASH_TYPE_NOR, 90 91 .read = nor_flash_read, 92 .write = nor_flash_write, 93 .erase = nor_flash_erase, 94 .block_isbad = nor_flash_isbad, 95 .block_markbad = nor_flash_markbad, 96 97 .submit = nor_flash_submit 98 }; 99 100 #ifdef NOR_VERBOSE 101 const struct nor_manufacturer nor_mfrs[] = { 102 { NOR_MFR_AMD, "AMD" }, 103 { NOR_MFR_FUJITSU, "Fujitsu" }, 104 { NOR_MFR_RENESAS, "Renesas" }, 105 { NOR_MFR_STMICRO, "ST Micro" }, 106 { NOR_MFR_MICRON, "Micron" }, 107 { NOR_MFR_NATIONAL, "National" }, 108 { NOR_MFR_TOSHIBA, "Toshiba" }, 109 { NOR_MFR_HYNIX, "Hynix" }, 110 { NOR_MFGR_MACRONIX, "Macronix" }, 111 { NOR_MFR_SAMSUNG, "Samsung" }, 112 { NOR_MFR_UNKNOWN, "Unknown" } 113 }; 114 115 static const char * 116 nor_midtoname(int id) 117 { 118 int i; 119 120 for (i = 0; nor_mfrs[i].id != 0; i++) { 121 if (nor_mfrs[i].id == id) 122 return nor_mfrs[i].name; 123 } 124 125 KASSERT(nor_mfrs[i].id == 0); 126 127 return nor_mfrs[i].name; 128 } 129 #endif 130 131 /* ARGSUSED */ 132 static int 133 nor_match(device_t parent, cfdata_t match, void *aux) 134 { 135 /* pseudo device, always attaches */ 136 return 1; 137 } 138 139 static void 140 nor_attach(device_t parent, device_t self, void *aux) 141 { 142 struct nor_softc * const sc = device_private(self); 143 struct nor_attach_args * const naa = aux; 144 struct nor_chip * const chip = &sc->sc_chip; 145 146 sc->sc_dev = self; 147 sc->sc_controller_dev = parent; 148 sc->sc_nor_if = naa->naa_nor_if; 149 150 aprint_naive("\n"); 151 aprint_normal("\n"); 152 153 if (nor_scan_media(self, chip)) 154 return; 155 156 sc->sc_flash_if = nor_flash_if; 157 sc->sc_flash_if.erasesize = chip->nc_block_size; 158 sc->sc_flash_if.page_size = chip->nc_page_size; 159 sc->sc_flash_if.writesize = chip->nc_page_size; 160 161 /* allocate cache */ 162 #ifdef NOTYET 163 chip->nc_oob_cache = kmem_alloc(chip->nc_spare_size, KM_SLEEP); 164 #endif 165 chip->nc_page_cache = kmem_alloc(chip->nc_page_size, KM_SLEEP); 166 167 mutex_init(&sc->sc_device_lock, MUTEX_DEFAULT, IPL_NONE); 168 169 if (flash_sync_thread_init(&sc->sc_flash_io, self, &sc->sc_flash_if)) { 170 goto error; 171 } 172 173 if (!pmf_device_register1(sc->sc_dev, NULL, NULL, nor_shutdown)) 174 aprint_error_dev(sc->sc_dev, 175 "couldn't establish power handler\n"); 176 177 #ifdef NOR_BBT 178 nor_bbt_init(self); 179 nor_bbt_scan(self); 180 #endif 181 182 /* 183 * Attach all our devices 184 */ 185 config_search(self, NULL, 186 CFARGS(.search = nor_search)); 187 188 return; 189 190 error: 191 #ifdef NOTET 192 kmem_free(chip->nc_oob_cache, chip->nc_spare_size); 193 #endif 194 kmem_free(chip->nc_page_cache, chip->nc_page_size); 195 mutex_destroy(&sc->sc_device_lock); 196 } 197 198 static int 199 nor_search(device_t parent, cfdata_t cf, const int *ldesc, void *aux) 200 { 201 struct nor_softc * const sc = device_private(parent); 202 struct nor_chip * const chip = &sc->sc_chip; 203 struct flash_attach_args faa; 204 205 faa.partinfo.part_offset = cf->cf_loc[FLASHBUSCF_OFFSET]; 206 207 if (cf->cf_loc[FLASHBUSCF_SIZE] == 0) { 208 faa.partinfo.part_size = 209 chip->nc_size - faa.partinfo.part_offset; 210 } else { 211 faa.partinfo.part_size = cf->cf_loc[FLASHBUSCF_SIZE]; 212 } 213 214 if (cf->cf_loc[FLASHBUSCF_READONLY]) 215 faa.partinfo.part_flags = FLASH_PART_READONLY; 216 else 217 faa.partinfo.part_flags = 0; 218 219 faa.flash_if = &sc->sc_flash_if; 220 221 if (config_probe(parent, cf, &faa)) { 222 if (config_attach(parent, cf, &faa, nor_print, 223 CFARGS_NONE) != NULL) { 224 return 0; 225 } else { 226 return 1; 227 } 228 } 229 230 return 1; 231 } 232 233 static int 234 nor_detach(device_t self, int flags) 235 { 236 struct nor_softc * const sc = device_private(self); 237 struct nor_chip * const chip = &sc->sc_chip; 238 int error = 0; 239 240 error = config_detach_children(self, flags); 241 if (error) { 242 return error; 243 } 244 245 flash_sync_thread_destroy(&sc->sc_flash_io); 246 #ifdef NOR_BBT 247 nor_bbt_detach(self); 248 #endif 249 #ifdef NOTET 250 /* free oob cache */ 251 kmem_free(chip->nc_oob_cache, chip->nc_spare_size); 252 #endif 253 kmem_free(chip->nc_page_cache, chip->nc_page_size); 254 255 mutex_destroy(&sc->sc_device_lock); 256 257 pmf_device_deregister(sc->sc_dev); 258 259 return error; 260 } 261 262 static int 263 nor_print(void *aux, const char *pnp) 264 { 265 if (pnp != NULL) 266 aprint_normal("nor at %s\n", pnp); 267 268 return UNCONF; 269 } 270 271 /* ask for a nor driver to attach to the controller */ 272 device_t 273 nor_attach_mi(struct nor_interface * const nor_if, device_t parent) 274 { 275 struct nor_attach_args arg; 276 277 KASSERT(nor_if != NULL); 278 279 if (nor_if->select == NULL) 280 nor_if->select = &nor_default_select; 281 if (nor_if->read_page == NULL) 282 nor_if->read_page = &nor_default_read_page; 283 if (nor_if->program_page == NULL) 284 nor_if->program_page = &nor_default_program_page; 285 286 arg.naa_nor_if = nor_if; 287 288 device_t dev = config_found(parent, &arg, nor_print, 289 CFARGS(.iattr = "norbus")); 290 291 return dev; 292 } 293 294 static void 295 nor_default_select(device_t self, bool n) 296 { 297 /* do nothing */ 298 return; 299 } 300 301 static int 302 nor_flash_submit(device_t self, buf_t * const bp) 303 { 304 struct nor_softc * const sc = device_private(self); 305 306 return flash_io_submit(&sc->sc_flash_io, bp); 307 } 308 309 310 /* default everything to reasonable values, to ease future api changes */ 311 void 312 nor_init_interface(struct nor_interface * const nor_if) 313 { 314 nor_if->select = &nor_default_select; 315 nor_if->read_1 = NULL; 316 nor_if->read_2 = NULL; 317 nor_if->read_4 = NULL; 318 nor_if->read_buf_1 = NULL; 319 nor_if->read_buf_2 = NULL; 320 nor_if->read_buf_4 = NULL; 321 nor_if->write_1 = NULL; 322 nor_if->write_2 = NULL; 323 nor_if->write_4 = NULL; 324 nor_if->write_buf_1 = NULL; 325 nor_if->write_buf_2 = NULL; 326 nor_if->write_buf_4 = NULL; 327 nor_if->busy = NULL; 328 } 329 330 #ifdef NOTYET 331 /* handle quirks here */ 332 static void 333 nor_quirks(device_t self, struct nor_chip * const chip) 334 { 335 /* this is an example only! */ 336 switch (chip->nc_manf_id) { 337 case NOR_MFR_SAMSUNG: 338 if (chip->nc_dev_id == 0x00) { 339 /* do something only samsung chips need */ 340 /* or */ 341 /* chip->nc_quirks |= NC_QUIRK_NO_READ_START */ 342 } 343 } 344 345 return; 346 } 347 #endif 348 349 /** 350 * scan media to determine the chip's properties 351 * this function resets the device 352 */ 353 static int 354 nor_scan_media(device_t self, struct nor_chip * const chip) 355 { 356 struct nor_softc * const sc = device_private(self); 357 char pbuf[3][sizeof("XXXX MB")]; 358 359 KASSERT(sc->sc_nor_if != NULL); 360 KASSERT(sc->sc_nor_if->scan_media != NULL); 361 int error = sc->sc_nor_if->scan_media(self, chip); 362 if (error != 0) 363 return error; 364 365 #ifdef NOR_VERBOSE 366 aprint_normal_dev(self, 367 "manufacturer id: 0x%.4x (%s), device id: 0x%.4x\n", 368 chip->nc_manf_id, 369 nor_midtoname(chip->nc_manf_id), 370 chip->nc_dev_id); 371 #endif 372 373 format_bytes(pbuf[0], sizeof(pbuf[0]), chip->nc_page_size); 374 format_bytes(pbuf[1], sizeof(pbuf[1]), chip->nc_spare_size); 375 format_bytes(pbuf[2], sizeof(pbuf[2]), chip->nc_block_size); 376 aprint_normal_dev(self, 377 "page size: %s, spare size: %s, block size: %s\n", 378 pbuf[0], pbuf[1], pbuf[2]); 379 380 format_bytes(pbuf[0], sizeof(pbuf[0]), chip->nc_size); 381 aprint_normal_dev(self, 382 "LUN size: %" PRIu32 " blocks, LUNs: %" PRIu8 383 ", total storage size: %s\n", 384 chip->nc_lun_blocks, chip->nc_num_luns, pbuf[0]); 385 386 #ifdef NOTYET 387 /* XXX does this apply to nor? */ 388 /* 389 * calculate badblock marker offset in oob 390 * we try to be compatible with linux here 391 */ 392 if (chip->nc_page_size > 512) 393 chip->nc_badmarker_offs = 0; 394 else 395 chip->nc_badmarker_offs = 5; 396 #endif 397 398 /* Calculate page shift and mask */ 399 chip->nc_page_shift = ffs(chip->nc_page_size) - 1; 400 chip->nc_page_mask = ~(chip->nc_page_size - 1); 401 /* same for block */ 402 chip->nc_block_shift = ffs(chip->nc_block_size) - 1; 403 chip->nc_block_mask = ~(chip->nc_block_size - 1); 404 405 #ifdef NOTYET 406 /* look for quirks here if needed in future */ 407 nor_quirks(self, chip); 408 #endif 409 410 return 0; 411 } 412 413 /* ARGSUSED */ 414 static bool 415 nor_shutdown(device_t self, int howto) 416 { 417 return true; 418 } 419 420 /* implementation of the block device API */ 421 422 /* read a page, default implementation */ 423 static int 424 nor_default_read_page(device_t self, flash_off_t offset, uint8_t * const data) 425 { 426 struct nor_softc * const sc = device_private(self); 427 struct nor_chip * const chip = &sc->sc_chip; 428 429 /* 430 * access by specified access_width 431 * note: #bits == 1 << width 432 */ 433 switch(sc->sc_nor_if->access_width) { 434 case 0: 435 nor_read_buf_1(self, offset, data, chip->nc_page_size); 436 break; 437 case 1: 438 nor_read_buf_2(self, offset, data, chip->nc_page_size); 439 break; 440 case 2: 441 nor_read_buf_4(self, offset, data, chip->nc_page_size); 442 break; 443 #ifdef NOTYET 444 case 3: 445 nor_read_buf_8(self, offset, data, chip->nc_page_size); 446 break; 447 #endif 448 default: 449 panic("%s: bad width %d\n", __func__, sc->sc_nor_if->access_width); 450 } 451 452 #if 0 453 /* for debugging new drivers */ 454 nor_dump_data("page", data, chip->nc_page_size); 455 #endif 456 457 return 0; 458 } 459 460 /* write a page, default implementation */ 461 static int 462 nor_default_program_page(device_t self, flash_off_t offset, 463 const uint8_t * const data) 464 { 465 struct nor_softc * const sc = device_private(self); 466 struct nor_chip * const chip = &sc->sc_chip; 467 468 /* 469 * access by specified width 470 * #bits == 1 << access_width 471 */ 472 switch(sc->sc_nor_if->access_width) { 473 case 0: 474 nor_write_buf_1(self, offset, data, chip->nc_page_size); 475 break; 476 case 1: 477 nor_write_buf_2(self, offset, data, chip->nc_page_size); 478 break; 479 case 2: 480 nor_write_buf_4(self, offset, data, chip->nc_page_size); 481 break; 482 #ifdef NOTYET 483 case 3: 484 nor_write_buf_8(self, offset, data, chip->nc_page_size); 485 break; 486 #endif 487 default: 488 panic("%s: bad width %d\n", __func__, 489 sc->sc_nor_if->access_width); 490 } 491 492 #if 0 493 /* for debugging new drivers */ 494 nor_dump_data("page", data, chip->nc_page_size); 495 #endif 496 497 return 0; 498 } 499 500 /* 501 * nor_flash_erase_all - erase the entire chip 502 * 503 * XXX a good way to brick your system 504 */ 505 static int 506 nor_flash_erase_all(device_t self) 507 { 508 struct nor_softc * const sc = device_private(self); 509 int error; 510 511 mutex_enter(&sc->sc_device_lock); 512 error = nor_erase_all(self); 513 mutex_exit(&sc->sc_device_lock); 514 515 return error; 516 } 517 518 static int 519 nor_flash_erase(device_t self, struct flash_erase_instruction * const ei) 520 { 521 struct nor_softc * const sc = device_private(self); 522 struct nor_chip * const chip = &sc->sc_chip; 523 flash_off_t addr; 524 int error = 0; 525 526 if (ei->ei_addr < 0 || ei->ei_len < chip->nc_block_size) 527 return EINVAL; 528 529 if (ei->ei_addr + ei->ei_len > chip->nc_size) { 530 DPRINTF(("%s: erase address is past the end" 531 " of the device\n", __func__)); 532 return EINVAL; 533 } 534 535 if ((ei->ei_addr == 0) && (ei->ei_len == chip->nc_size) 536 && (sc->sc_nor_if->erase_all != NULL)) { 537 return nor_flash_erase_all(self); 538 } 539 540 if (ei->ei_addr % chip->nc_block_size != 0) { 541 aprint_error_dev(self, 542 "nor_flash_erase: ei_addr (%ju) is not" 543 " a multiple of block size (%ju)\n", 544 (uintmax_t)ei->ei_addr, 545 (uintmax_t)chip->nc_block_size); 546 return EINVAL; 547 } 548 549 if (ei->ei_len % chip->nc_block_size != 0) { 550 aprint_error_dev(self, 551 "nor_flash_erase: ei_len (%ju) is not" 552 " a multiple of block size (%ju)", 553 (uintmax_t)ei->ei_len, 554 (uintmax_t)chip->nc_block_size); 555 return EINVAL; 556 } 557 558 mutex_enter(&sc->sc_device_lock); 559 addr = ei->ei_addr; 560 while (addr < ei->ei_addr + ei->ei_len) { 561 #ifdef NOTYET 562 if (nor_isbad(self, addr)) { 563 aprint_error_dev(self, "bad block encountered\n"); 564 ei->ei_state = FLASH_ERASE_FAILED; 565 error = EIO; 566 goto out; 567 } 568 #endif 569 570 error = nor_erase_block(self, addr); 571 if (error) { 572 ei->ei_state = FLASH_ERASE_FAILED; 573 goto out; 574 } 575 576 addr += chip->nc_block_size; 577 } 578 mutex_exit(&sc->sc_device_lock); 579 580 ei->ei_state = FLASH_ERASE_DONE; 581 if (ei->ei_callback != NULL) { 582 ei->ei_callback(ei); 583 } 584 585 return 0; 586 out: 587 mutex_exit(&sc->sc_device_lock); 588 589 return error; 590 } 591 592 /* 593 * handle (page) unaligned write to nor 594 */ 595 static int 596 nor_flash_write_unaligned(device_t self, flash_off_t offset, size_t len, 597 size_t * const retlen, const uint8_t * const buf) 598 { 599 struct nor_softc * const sc = device_private(self); 600 struct nor_chip * const chip = &sc->sc_chip; 601 flash_off_t first, last, firstoff; 602 const uint8_t *bufp; 603 flash_off_t addr; 604 size_t left, count; 605 int error = 0, i; 606 607 first = offset & chip->nc_page_mask; 608 firstoff = offset & ~chip->nc_page_mask; 609 /* XXX check if this should be len - 1 */ 610 last = (offset + len) & chip->nc_page_mask; 611 count = last - first + 1; 612 613 addr = first; 614 *retlen = 0; 615 616 mutex_enter(&sc->sc_device_lock); 617 if (count == 1) { 618 #ifdef NOTYET 619 if (nor_isbad(self, addr)) { 620 aprint_error_dev(self, 621 "nor_flash_write_unaligned: " 622 "bad block encountered\n"); 623 error = EIO; 624 goto out; 625 } 626 #endif 627 628 error = nor_read_page(self, addr, chip->nc_page_cache); 629 if (error) { 630 goto out; 631 } 632 633 memcpy(chip->nc_page_cache + firstoff, buf, len); 634 635 error = nor_program_page(self, addr, chip->nc_page_cache); 636 if (error) { 637 goto out; 638 } 639 640 *retlen = len; 641 goto out; 642 } 643 644 bufp = buf; 645 left = len; 646 647 for (i = 0; i < count && left != 0; i++) { 648 #ifdef NOTYET 649 if (nor_isbad(self, addr)) { 650 aprint_error_dev(self, 651 "nor_flash_write_unaligned: " 652 "bad block encountered\n"); 653 error = EIO; 654 goto out; 655 } 656 #endif 657 658 if (i == 0) { 659 error = nor_read_page(self, addr, chip->nc_page_cache); 660 if (error) { 661 goto out; 662 } 663 664 memcpy(chip->nc_page_cache + firstoff, 665 bufp, chip->nc_page_size - firstoff); 666 667 printf("write page: %s: %d\n", __FILE__, __LINE__); 668 error = nor_program_page(self, addr, 669 chip->nc_page_cache); 670 if (error) { 671 goto out; 672 } 673 674 bufp += chip->nc_page_size - firstoff; 675 left -= chip->nc_page_size - firstoff; 676 *retlen += chip->nc_page_size - firstoff; 677 678 } else if (i == count - 1) { 679 error = nor_read_page(self, addr, chip->nc_page_cache); 680 if (error) { 681 goto out; 682 } 683 684 memcpy(chip->nc_page_cache, bufp, left); 685 686 error = nor_program_page(self, addr, 687 chip->nc_page_cache); 688 if (error) { 689 goto out; 690 } 691 692 *retlen += left; 693 KASSERT(left < chip->nc_page_size); 694 695 } else { 696 /* XXX debug */ 697 if (left > chip->nc_page_size) { 698 printf("left: %zu, i: %d, count: %zu\n", 699 (size_t )left, i, count); 700 } 701 KASSERT(left > chip->nc_page_size); 702 703 error = nor_program_page(self, addr, bufp); 704 if (error) { 705 goto out; 706 } 707 708 bufp += chip->nc_page_size; 709 left -= chip->nc_page_size; 710 *retlen += chip->nc_page_size; 711 } 712 713 addr += chip->nc_page_size; 714 } 715 716 KASSERT(*retlen == len); 717 out: 718 mutex_exit(&sc->sc_device_lock); 719 720 return error; 721 } 722 723 static int 724 nor_flash_write(device_t self, flash_off_t offset, size_t len, 725 size_t * const retlen, const uint8_t * const buf) 726 { 727 struct nor_softc * const sc = device_private(self); 728 struct nor_chip * const chip = &sc->sc_chip; 729 const uint8_t *bufp; 730 size_t pages, page; 731 daddr_t addr; 732 int error = 0; 733 734 if ((offset + len) > chip->nc_size) { 735 DPRINTF(("%s: write (off: 0x%jx, len: %ju)," 736 " exceeds device size (0x%jx)\n", __func__, 737 (uintmax_t)offset, (uintmax_t)len, 738 (uintmax_t)chip->nc_size)); 739 return EINVAL; 740 } 741 742 if (len % chip->nc_page_size != 0 || 743 offset % chip->nc_page_size != 0) { 744 return nor_flash_write_unaligned(self, 745 offset, len, retlen, buf); 746 } 747 748 pages = len / chip->nc_page_size; 749 KASSERT(pages != 0); 750 *retlen = 0; 751 752 addr = offset; 753 bufp = buf; 754 755 mutex_enter(&sc->sc_device_lock); 756 for (page = 0; page < pages; page++) { 757 #ifdef NOTYET 758 /* do we need this check here? */ 759 if (nor_isbad(self, addr)) { 760 aprint_error_dev(self, 761 "nor_flash_write: bad block encountered\n"); 762 763 error = EIO; 764 goto out; 765 } 766 #endif 767 768 error = nor_program_page(self, addr, bufp); 769 if (error) { 770 goto out; 771 } 772 773 addr += chip->nc_page_size; 774 bufp += chip->nc_page_size; 775 *retlen += chip->nc_page_size; 776 } 777 out: 778 mutex_exit(&sc->sc_device_lock); 779 DPRINTF(("%s: retlen: %zu, len: %zu\n", __func__, *retlen, len)); 780 781 return error; 782 } 783 784 /* 785 * handle (page) unaligned read from nor 786 */ 787 static int 788 nor_flash_read_unaligned(device_t self, flash_off_t offset, size_t len, 789 size_t * const retlen, uint8_t * const buf) 790 { 791 struct nor_softc * const sc = device_private(self); 792 struct nor_chip * const chip = &sc->sc_chip; 793 daddr_t first, last, count, firstoff; 794 uint8_t *bufp; 795 daddr_t addr; 796 size_t left; 797 int error = 0, i; 798 799 first = offset & chip->nc_page_mask; 800 firstoff = offset & ~chip->nc_page_mask; 801 last = (offset + len) & chip->nc_page_mask; 802 count = (last - first) / chip->nc_page_size + 1; 803 804 addr = first; 805 bufp = buf; 806 left = len; 807 *retlen = 0; 808 809 mutex_enter(&sc->sc_device_lock); 810 if (count == 1) { 811 error = nor_read_page(self, addr, chip->nc_page_cache); 812 if (error) { 813 goto out; 814 } 815 816 memcpy(bufp, chip->nc_page_cache + firstoff, len); 817 818 *retlen = len; 819 goto out; 820 } 821 822 for (i = 0; i < count && left != 0; i++) { 823 /* XXX Why use the page cache here ? */ 824 error = nor_read_page(self, addr, chip->nc_page_cache); 825 if (error) { 826 goto out; 827 } 828 829 if (i == 0) { 830 memcpy(bufp, chip->nc_page_cache + firstoff, 831 chip->nc_page_size - firstoff); 832 833 bufp += chip->nc_page_size - firstoff; 834 left -= chip->nc_page_size - firstoff; 835 *retlen += chip->nc_page_size - firstoff; 836 837 } else if (i == count - 1) { 838 memcpy(bufp, chip->nc_page_cache, left); 839 *retlen += left; 840 KASSERT(left < chip->nc_page_size); 841 842 } else { 843 memcpy(bufp, chip->nc_page_cache, chip->nc_page_size); 844 845 bufp += chip->nc_page_size; 846 left -= chip->nc_page_size; 847 *retlen += chip->nc_page_size; 848 } 849 850 addr += chip->nc_page_size; 851 } 852 KASSERT(*retlen == len); 853 out: 854 mutex_exit(&sc->sc_device_lock); 855 856 return error; 857 } 858 859 static int 860 nor_flash_read(device_t self, flash_off_t offset, size_t len, 861 size_t * const retlen, uint8_t * const buf) 862 { 863 struct nor_softc * const sc = device_private(self); 864 struct nor_chip * const chip = &sc->sc_chip; 865 uint8_t *bufp; 866 size_t addr; 867 size_t i, pages; 868 int error = 0; 869 870 *retlen = 0; 871 872 DPRINTF(("%s: off: 0x%jx, len: %zu\n", 873 __func__, (uintmax_t)offset, len)); 874 875 if (__predict_false((offset + len) > chip->nc_size)) { 876 DPRINTF(("%s: read (off: 0x%jx, len: %zu)," 877 " exceeds device size (%ju)\n", __func__, 878 (uintmax_t)offset, len, (uintmax_t)chip->nc_size)); 879 return EINVAL; 880 } 881 882 /* Handle unaligned access, shouldnt be needed when using the 883 * block device, as strategy handles it, so only low level 884 * accesses will use this path 885 */ 886 /* XXX^2 */ 887 #if 0 888 if (len < chip->nc_page_size) 889 panic("TODO page size is larger than read size"); 890 #endif 891 892 if (len % chip->nc_page_size != 0 || 893 offset % chip->nc_page_size != 0) { 894 return nor_flash_read_unaligned(self, 895 offset, len, retlen, buf); 896 } 897 898 bufp = buf; 899 addr = offset; 900 pages = len / chip->nc_page_size; 901 902 mutex_enter(&sc->sc_device_lock); 903 for (i = 0; i < pages; i++) { 904 #ifdef NOTYET 905 /* XXX do we need this check here? */ 906 if (nor_isbad(self, addr)) { 907 aprint_error_dev(self, "bad block encountered\n"); 908 error = EIO; 909 goto out; 910 } 911 #endif 912 error = nor_read_page(self, addr, bufp); 913 if (error) 914 goto out; 915 916 bufp += chip->nc_page_size; 917 addr += chip->nc_page_size; 918 *retlen += chip->nc_page_size; 919 } 920 out: 921 mutex_exit(&sc->sc_device_lock); 922 923 return error; 924 } 925 926 static int 927 nor_flash_isbad(device_t self, flash_off_t ofs, bool * const isbad) 928 { 929 struct nor_softc * const sc = device_private(self); 930 struct nor_chip * const chip = &sc->sc_chip; 931 #ifdef NOTYET 932 bool result; 933 #endif 934 935 if (ofs > chip->nc_size) { 936 DPRINTF(("%s: offset 0x%jx is larger than" 937 " device size (0x%jx)\n", __func__, 938 (uintmax_t)ofs, (uintmax_t)chip->nc_size)); 939 return EINVAL; 940 } 941 942 if (ofs % chip->nc_block_size != 0) { 943 DPRINTF(("offset (0x%jx) is not the multiple of block size " 944 "(%ju)", 945 (uintmax_t)ofs, (uintmax_t)chip->nc_block_size)); 946 return EINVAL; 947 } 948 949 #ifdef NOTYET 950 mutex_enter(&sc->sc_device_lock); 951 result = nor_isbad(self, ofs); 952 mutex_exit(&sc->sc_device_lock); 953 954 *isbad = result; 955 #else 956 *isbad = false; 957 #endif 958 959 return 0; 960 } 961 962 static int 963 nor_flash_markbad(device_t self, flash_off_t ofs) 964 { 965 struct nor_softc * const sc = device_private(self); 966 struct nor_chip * const chip = &sc->sc_chip; 967 968 if (ofs > chip->nc_size) { 969 DPRINTF(("%s: offset 0x%jx is larger than" 970 " device size (0x%jx)\n", __func__, 971 ofs, (uintmax_t)chip->nc_size)); 972 return EINVAL; 973 } 974 975 if (ofs % chip->nc_block_size != 0) { 976 panic("offset (%ju) is not the multiple of block size (%ju)", 977 (uintmax_t)ofs, (uintmax_t)chip->nc_block_size); 978 } 979 980 /* TODO: implement this */ 981 982 return 0; 983 } 984 985 static int 986 sysctl_nor_verify(SYSCTLFN_ARGS) 987 { 988 int error, t; 989 struct sysctlnode node; 990 991 node = *rnode; 992 t = *(int *)rnode->sysctl_data; 993 node.sysctl_data = &t; 994 error = sysctl_lookup(SYSCTLFN_CALL(&node)); 995 if (error || newp == NULL) 996 return error; 997 998 if (node.sysctl_num == nor_cachesync_nodenum) { 999 if (t <= 0 || t > 60) 1000 return EINVAL; 1001 } else { 1002 return EINVAL; 1003 } 1004 1005 *(int *)rnode->sysctl_data = t; 1006 1007 return 0; 1008 } 1009 1010 SYSCTL_SETUP(sysctl_nor, "sysctl nor subtree setup") 1011 { 1012 int rc, nor_root_num; 1013 const struct sysctlnode *node; 1014 1015 if ((rc = sysctl_createv(clog, 0, NULL, &node, 1016 CTLFLAG_PERMANENT, CTLTYPE_NODE, "nor", 1017 SYSCTL_DESCR("NOR driver controls"), 1018 NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL)) != 0) { 1019 goto error; 1020 } 1021 1022 nor_root_num = node->sysctl_num; 1023 1024 if ((rc = sysctl_createv(clog, 0, NULL, &node, 1025 CTLFLAG_PERMANENT|CTLFLAG_READWRITE, 1026 CTLTYPE_INT, "cache_sync_timeout", 1027 SYSCTL_DESCR("NOR write cache sync timeout in seconds"), 1028 sysctl_nor_verify, 0, &nor_cachesync_timeout, 1029 0, CTL_HW, nor_root_num, CTL_CREATE, 1030 CTL_EOL)) != 0) { 1031 goto error; 1032 } 1033 1034 nor_cachesync_nodenum = node->sysctl_num; 1035 1036 return; 1037 1038 error: 1039 aprint_error("%s: sysctl_createv failed (rc = %d)\n", __func__, rc); 1040 } 1041 1042 MODULE(MODULE_CLASS_DRIVER, nor, "flash"); 1043 1044 #ifdef _MODULE 1045 #include "ioconf.c" 1046 #endif 1047 1048 static int 1049 nor_modcmd(modcmd_t cmd, void *opaque) 1050 { 1051 switch (cmd) { 1052 case MODULE_CMD_INIT: 1053 #ifdef _MODULE 1054 return config_init_component(cfdriver_ioconf_nor, 1055 cfattach_ioconf_nor, cfdata_ioconf_nor); 1056 #else 1057 return 0; 1058 #endif 1059 case MODULE_CMD_FINI: 1060 #ifdef _MODULE 1061 return config_fini_component(cfdriver_ioconf_nor, 1062 cfattach_ioconf_nor, cfdata_ioconf_nor); 1063 #else 1064 return 0; 1065 #endif 1066 default: 1067 return ENOTTY; 1068 } 1069 } 1070
Indexes created Sun Sep 21 20:09:37 GMT 2025