1 /* $NetBSD: flash.c,v 1.19 2022/09/25 21:56:12 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 * Copyright (c) 2010 David Tengeri <dtengeri (at) inf.u-szeged.hu> 8 * All rights reserved. 9 * 10 * This code is derived from software contributed to The NetBSD Foundation 11 * by the Department of Software Engineering, University of Szeged, Hungary 12 * 13 * Redistribution and use in source and binary forms, with or without 14 * modification, are permitted provided that the following conditions 15 * are met: 16 * 1. Redistributions of source code must retain the above copyright 17 * notice, this list of conditions and the following disclaimer. 18 * 2. Redistributions in binary form must reproduce the above copyright 19 * notice, this list of conditions and the following disclaimer in the 20 * documentation and/or other materials provided with the distribution. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 /*- 36 * Framework for storage devices based on Flash technology 37 */ 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: flash.c,v 1.19 2022/09/25 21:56:12 thorpej Exp $"); 41 42 #include <sys/param.h> 43 #include <sys/types.h> 44 #include <sys/proc.h> 45 #include <sys/errno.h> 46 #include <sys/ioctl.h> 47 #include <sys/device.h> 48 #include <sys/conf.h> 49 #include <sys/kmem.h> 50 #include <sys/uio.h> 51 #include <sys/kernel.h> 52 53 #include <sys/atomic.h> 54 #include <sys/buf.h> 55 #include <sys/bufq.h> 56 #include <sys/disk.h> 57 #include <sys/disklabel.h> 58 #include <sys/reboot.h> 59 60 #include "ioconf.h" 61 62 #include <sys/flashio.h> 63 #include "flash.h" 64 65 #ifdef FLASH_DEBUG 66 int flashdebug = FLASH_DEBUG; 67 #endif 68 69 dev_type_open(flashopen); 70 dev_type_close(flashclose); 71 dev_type_read(flashread); 72 dev_type_write(flashwrite); 73 dev_type_ioctl(flashioctl); 74 dev_type_strategy(flashstrategy); 75 dev_type_dump(flashdump); 76 77 int flash_print(void *aux, const char *pnp); 78 79 bool flash_shutdown(device_t dev, int how); 80 int flash_nsectors(struct buf *bp); 81 int flash_sector(struct buf *bp); 82 83 int flash_match(device_t parent, cfdata_t match, void *aux); 84 void flash_attach(device_t parent, device_t self, void *aux); 85 int flash_detach(device_t device, int flags); 86 87 CFATTACH_DECL_NEW(flash, sizeof(struct flash_softc), 88 flash_match, flash_attach, flash_detach, NULL); 89 90 /** 91 * Block device's operation 92 */ 93 const struct bdevsw flash_bdevsw = { 94 .d_open = flashopen, 95 .d_close = flashclose, 96 .d_strategy = flashstrategy, 97 .d_ioctl = flashioctl, 98 .d_dump = flashdump, 99 .d_psize = nosize, 100 .d_discard = nodiscard, /* XXX this driver probably wants a discard */ 101 .d_flag = D_DISK | D_MPSAFE 102 }; 103 104 /** 105 * Character device's operations 106 */ 107 const struct cdevsw flash_cdevsw = { 108 .d_open = flashopen, 109 .d_close = flashclose, 110 .d_read = flashread, 111 .d_write = flashwrite, 112 .d_ioctl = flashioctl, 113 .d_stop = nostop, 114 .d_tty = notty, 115 .d_poll = nopoll, 116 .d_mmap = nommap, 117 .d_kqfilter = nokqfilter, 118 .d_discard = nodiscard, 119 .d_flag = D_DISK | D_MPSAFE 120 }; 121 122 /* ARGSUSED */ 123 int 124 flash_match(device_t parent, cfdata_t match, void *aux) 125 { 126 /* pseudo device, always attaches */ 127 return 1; 128 } 129 130 /* ARGSUSED */ 131 void 132 flash_attach(device_t parent, device_t self, void *aux) 133 { 134 struct flash_softc * const sc = device_private(self); 135 struct flash_attach_args * const faa = aux; 136 char pbuf[2][sizeof("9999 KB")]; 137 138 sc->sc_dev = self; 139 sc->sc_parent_dev = parent; 140 sc->flash_if = faa->flash_if; 141 sc->sc_partinfo = faa->partinfo; 142 sc->hw_softc = device_private(parent); 143 144 format_bytes(pbuf[0], sizeof(pbuf[0]), sc->sc_partinfo.part_size); 145 format_bytes(pbuf[1], sizeof(pbuf[1]), sc->flash_if->erasesize); 146 147 aprint_naive("\n"); 148 149 aprint_normal(": partition"); 150 if (sc->sc_partinfo.part_name != NULL) 151 aprint_normal(" \"%s\"", sc->sc_partinfo.part_name); 152 153 aprint_normal(", size %s, offset %#jx", 154 pbuf[0], (uintmax_t)sc->sc_partinfo.part_offset); 155 156 if (sc->sc_partinfo.part_flags & FLASH_PART_READONLY) { 157 sc->sc_readonly = true; 158 aprint_normal(", read only"); 159 } else { 160 sc->sc_readonly = false; 161 } 162 163 aprint_normal("\n"); 164 165 if (sc->sc_partinfo.part_size == 0) { 166 aprint_error_dev(self, 167 "partition size must be larger than 0\n"); 168 return; 169 } 170 171 switch (sc->flash_if->type) { 172 case FLASH_TYPE_NOR: 173 aprint_normal_dev(sc->sc_dev, 174 "erase size %s bytes, write size %d bytes\n", 175 pbuf[1], sc->flash_if->writesize); 176 break; 177 178 case FLASH_TYPE_NAND: 179 default: 180 aprint_normal_dev(sc->sc_dev, 181 "erase size %s, page size %d bytes, write size %d bytes\n", 182 pbuf[1], sc->flash_if->page_size, 183 sc->flash_if->writesize); 184 break; 185 } 186 187 if (!pmf_device_register1(sc->sc_dev, NULL, NULL, flash_shutdown)) 188 aprint_error_dev(sc->sc_dev, 189 "couldn't establish power handler\n"); 190 } 191 192 int 193 flash_detach(device_t device, int flags) 194 { 195 struct flash_softc * const sc = device_private(device); 196 197 pmf_device_deregister(sc->sc_dev); 198 199 /* freeing flash_if is our responsibility */ 200 kmem_free(sc->flash_if, sizeof(*sc->flash_if)); 201 202 return 0; 203 } 204 205 int 206 flash_print(void *aux, const char *pnp) 207 { 208 struct flash_attach_args *arg; 209 const char *type; 210 211 if (pnp != NULL) { 212 arg = aux; 213 switch (arg->flash_if->type) { 214 case FLASH_TYPE_NOR: 215 type = "NOR"; 216 break; 217 case FLASH_TYPE_NAND: 218 type = "NAND"; 219 break; 220 default: 221 panic("flash_print: unknown type %d", 222 arg->flash_if->type); 223 } 224 aprint_normal("%s flash at %s", type, pnp); 225 } 226 return UNCONF; 227 } 228 229 device_t 230 flash_attach_mi(struct flash_interface * const flash_if, device_t device) 231 { 232 struct flash_attach_args arg; 233 234 #ifdef DIAGNOSTIC 235 if (flash_if == NULL) { 236 aprint_error("flash_attach_mi: NULL\n"); 237 return 0; 238 } 239 #endif 240 arg.flash_if = flash_if; 241 242 return config_found(device, &arg, flash_print, 243 CFARGS(.iattr = "flashbus")); 244 } 245 246 /** 247 * flash_open - open the character device 248 * Checks if there is a driver registered to the minor number of the open 249 * request. 250 */ 251 int 252 flashopen(dev_t dev, int flags, int fmt, lwp_t *l) 253 { 254 int unit = minor(dev); 255 struct flash_softc *sc; 256 257 FLDPRINTFN(1, ("flash: opening device unit %d\n", unit)); 258 259 if ((sc = device_lookup_private(&flash_cd, unit)) == NULL) 260 return ENXIO; 261 262 /* TODO return eperm if want to open for writing a read only dev */ 263 264 /* reset buffer length */ 265 // sc->sc_cache->fc_len = 0; 266 267 return 0; 268 } 269 270 /** 271 * flash_close - close device 272 * We don't have to release any resources, so just return 0. 273 */ 274 int 275 flashclose(dev_t dev, int flags, int fmt, lwp_t *l) 276 { 277 int unit = minor(dev); 278 struct flash_softc *sc; 279 int err; 280 281 FLDPRINTFN(1, ("flash: closing flash device unit %d\n", unit)); 282 283 if ((sc = device_lookup_private(&flash_cd, unit)) == NULL) 284 return ENXIO; 285 286 if (!sc->sc_readonly) { 287 err = flash_sync(sc->sc_dev); 288 if (err) 289 return err; 290 } 291 292 return 0; 293 } 294 295 /** 296 * flash_read - read from character device 297 * This function uses the registered driver's read function to read the 298 * requested length to * a buffer and then moves this buffer to userspace. 299 */ 300 int 301 flashread(dev_t dev, struct uio * const uio, int flag) 302 { 303 return physio(flashstrategy, NULL, dev, B_READ, minphys, uio); 304 } 305 306 /** 307 * flash_write - write to character device 308 * This function moves the data into a buffer from userspace to kernel space, 309 * then uses the registered driver's write function to write out the data to 310 * the media. 311 */ 312 int 313 flashwrite(dev_t dev, struct uio * const uio, int flag) 314 { 315 return physio(flashstrategy, NULL, dev, B_WRITE, minphys, uio); 316 } 317 318 void 319 flashstrategy(struct buf * const bp) 320 { 321 struct flash_softc *sc; 322 const struct flash_interface *flash_if; 323 const struct flash_partition *part; 324 int unit, device_blks; 325 326 unit = minor(bp->b_dev); 327 sc = device_lookup_private(&flash_cd, unit); 328 if (sc == NULL) { 329 bp->b_error = ENXIO; 330 goto done; 331 } 332 333 flash_if = sc->flash_if; 334 part = &sc->sc_partinfo; 335 336 /* divider */ 337 KASSERT(flash_if->writesize != 0); 338 339 aprint_debug_dev(sc->sc_dev, "flash_strategy()\n"); 340 341 if (!(bp->b_flags & B_READ) && sc->sc_readonly) { 342 bp->b_error = EACCES; 343 goto done; 344 } 345 346 /* check if length is not negative */ 347 if (bp->b_blkno < 0) { 348 bp->b_error = EINVAL; 349 goto done; 350 } 351 352 /* zero length i/o */ 353 if (bp->b_bcount == 0) { 354 goto done; 355 } 356 357 device_blks = sc->sc_partinfo.part_size / DEV_BSIZE; 358 KASSERT(part->part_offset % DEV_BSIZE == 0); 359 bp->b_rawblkno = bp->b_blkno + (part->part_offset / DEV_BSIZE); 360 361 if (bounds_check_with_mediasize(bp, DEV_BSIZE, device_blks) <= 0) { 362 goto done; 363 } 364 365 bp->b_resid = bp->b_bcount; 366 flash_if->submit(sc->sc_parent_dev, bp); 367 368 return; 369 done: 370 bp->b_resid = bp->b_bcount; 371 biodone(bp); 372 } 373 374 /* 375 * Handle the ioctl for the device 376 */ 377 int 378 flashioctl(dev_t dev, u_long command, void * const data, int flags, lwp_t *l) 379 { 380 struct flash_erase_params *ep; 381 struct flash_info_params *ip; 382 struct flash_dump_params *dp; 383 struct flash_badblock_params *bbp; 384 struct flash_erase_instruction ei; 385 struct flash_softc *sc; 386 int unit, err; 387 size_t retlen; 388 flash_off_t offset; 389 bool bad; 390 391 unit = minor(dev); 392 if ((sc = device_lookup_private(&flash_cd, unit)) == NULL) 393 return ENXIO; 394 395 err = 0; 396 switch (command) { 397 case FLASH_ERASE_BLOCK: 398 /** 399 * Set up an erase instruction then call the registered 400 * driver's erase operation. 401 */ 402 ep = data; 403 404 if (sc->sc_readonly) { 405 return EACCES; 406 } 407 408 ei.ei_addr = ep->ep_addr; 409 ei.ei_len = ep->ep_len; 410 ei.ei_callback = NULL; 411 412 err = flash_erase(sc->sc_dev, &ei); 413 if (err) { 414 return err; 415 } 416 417 break; 418 case FLASH_BLOCK_ISBAD: 419 /** 420 * Set up an erase instruction then call the registered 421 * driver's erase operation. 422 */ 423 bbp = data; 424 425 err = flash_block_isbad(sc->sc_dev, bbp->bbp_addr, &bad); 426 if (err) { 427 return err; 428 } 429 bbp->bbp_isbad = bad; 430 431 break; 432 case FLASH_BLOCK_MARKBAD: 433 bbp = data; 434 435 err = flash_block_markbad(sc->sc_dev, bbp->bbp_addr); 436 437 break; 438 case FLASH_DUMP: 439 dp = data; 440 offset = dp->dp_block * sc->flash_if->erasesize; 441 FLDPRINTF(("Reading from block: %jd len: %jd\n", 442 (intmax_t )dp->dp_block, (intmax_t )dp->dp_len)); 443 err = flash_read(sc->sc_parent_dev, offset, dp->dp_len, 444 &retlen, dp->dp_buf); 445 if (err) 446 return err; 447 if (retlen != dp->dp_len) { 448 dp->dp_len = -1; 449 dp->dp_buf = NULL; 450 } 451 452 break; 453 case FLASH_GET_INFO: 454 ip = data; 455 456 ip->ip_page_size = sc->flash_if->page_size; 457 ip->ip_erase_size = sc->flash_if->erasesize; 458 ip->ip_flash_type = sc->flash_if->type; 459 ip->ip_flash_size = sc->sc_partinfo.part_size; 460 break; 461 default: 462 err = ENODEV; 463 } 464 465 return err; 466 } 467 468 int 469 flashdump(dev_t dev, daddr_t blkno, void *va, size_t size) 470 { 471 return EACCES; 472 } 473 474 bool 475 flash_shutdown(device_t self, int how) 476 { 477 struct flash_softc * const sc = device_private(self); 478 479 if ((how & RB_NOSYNC) == 0 && !sc->sc_readonly) 480 flash_sync(self); 481 482 return true; 483 } 484 485 const struct flash_interface * 486 flash_get_interface(dev_t dev) 487 { 488 struct flash_softc *sc; 489 int unit; 490 491 unit = minor(dev); 492 if ((sc = device_lookup_private(&flash_cd, unit)) == NULL) 493 return NULL; 494 495 return sc->flash_if; 496 } 497 498 const struct flash_softc * 499 flash_get_softc(dev_t dev) 500 { 501 struct flash_softc *sc; 502 int unit; 503 504 unit = minor(dev); 505 sc = device_lookup_private(&flash_cd, unit); 506 507 return sc; 508 } 509 510 device_t 511 flash_get_device(dev_t dev) 512 { 513 struct flash_softc *sc; 514 int unit; 515 516 unit = minor(dev); 517 sc = device_lookup_private(&flash_cd, unit); 518 519 return sc->sc_dev; 520 } 521 522 flash_size_t 523 flash_get_size(dev_t dev) 524 { 525 const struct flash_softc *sc; 526 527 sc = flash_get_softc(dev); 528 529 return sc->sc_partinfo.part_size; 530 } 531 532 int 533 flash_erase(device_t self, struct flash_erase_instruction * const ei) 534 { 535 struct flash_softc * const sc = device_private(self); 536 KASSERT(ei != NULL); 537 struct flash_erase_instruction e = *ei; 538 539 if (sc->sc_readonly) 540 return EACCES; 541 542 /* adjust for flash partition */ 543 e.ei_addr += sc->sc_partinfo.part_offset; 544 545 /* bounds check for flash partition */ 546 if (e.ei_addr + e.ei_len > sc->sc_partinfo.part_size + 547 sc->sc_partinfo.part_offset) 548 return EINVAL; 549 550 return sc->flash_if->erase(device_parent(self), &e); 551 } 552 553 int 554 flash_read(device_t self, flash_off_t offset, size_t len, size_t * const retlen, 555 uint8_t * const buf) 556 { 557 struct flash_softc * const sc = device_private(self); 558 559 offset += sc->sc_partinfo.part_offset; 560 561 if (offset + len > sc->sc_partinfo.part_size + 562 sc->sc_partinfo.part_offset) 563 return EINVAL; 564 565 return sc->flash_if->read(device_parent(self), 566 offset, len, retlen, buf); 567 } 568 569 int 570 flash_write(device_t self, flash_off_t offset, size_t len, 571 size_t * const retlen, const uint8_t * const buf) 572 { 573 struct flash_softc * const sc = device_private(self); 574 575 if (sc->sc_readonly) 576 return EACCES; 577 578 offset += sc->sc_partinfo.part_offset; 579 580 if (offset + len > sc->sc_partinfo.part_size + 581 sc->sc_partinfo.part_offset) 582 return EINVAL; 583 584 return sc->flash_if->write(device_parent(self), 585 offset, len, retlen, buf); 586 } 587 588 int 589 flash_block_markbad(device_t self, flash_off_t offset) 590 { 591 struct flash_softc * const sc = device_private(self); 592 593 if (sc->sc_readonly) 594 return EACCES; 595 596 offset += sc->sc_partinfo.part_offset; 597 598 if (offset + sc->flash_if->erasesize >= 599 sc->sc_partinfo.part_size + 600 sc->sc_partinfo.part_offset) 601 return EINVAL; 602 603 return sc->flash_if->block_markbad(device_parent(self), offset); 604 } 605 606 int 607 flash_block_isbad(device_t self, flash_off_t offset, bool * const bad) 608 { 609 struct flash_softc * const sc = device_private(self); 610 611 offset += sc->sc_partinfo.part_offset; 612 613 if (offset + sc->flash_if->erasesize > 614 sc->sc_partinfo.part_size + 615 sc->sc_partinfo.part_offset) 616 return EINVAL; 617 618 return sc->flash_if->block_isbad(device_parent(self), offset, bad); 619 } 620 621 int 622 flash_sync(device_t self) 623 { 624 struct flash_softc * const sc = device_private(self); 625 626 if (sc->sc_readonly) 627 return EACCES; 628 629 /* noop now TODO: implement */ 630 return 0; 631 } 632 633 MODULE(MODULE_CLASS_DRIVER, flash, NULL); 634 635 #ifdef _MODULE 636 #include "ioconf.c" 637 #endif 638 639 static int 640 flash_modcmd(modcmd_t cmd, void *opaque) 641 { 642 int error = 0; 643 #ifdef _MODULE 644 int bmaj = -1, cmaj = -1; 645 #endif 646 647 switch (cmd) { 648 case MODULE_CMD_INIT: 649 #ifdef _MODULE 650 error = devsw_attach("flash", &flash_bdevsw, &bmaj, 651 &flash_cdevsw, &cmaj); 652 if (error) 653 return error; 654 error = config_init_component(cfdriver_ioconf_flash, 655 cfattach_ioconf_flash, cfdata_ioconf_flash); 656 if (error) 657 devsw_detach(&flash_bdevsw, &flash_cdevsw); 658 #endif 659 return error; 660 case MODULE_CMD_FINI: 661 #ifdef _MODULE 662 error = config_fini_component(cfdriver_ioconf_flash, 663 cfattach_ioconf_flash, cfdata_ioconf_flash); 664 devsw_detach(&flash_bdevsw, &flash_cdevsw); 665 #endif 666 return error; 667 default: 668 return ENOTTY; 669 } 670 } 671
Indexes created Sun Sep 21 14:09:52 GMT 2025