root/dev/flash.c

DEFINITIONS

1. flashattach
2. flashdetach
3. flashactivate
4. flash_reg8_read
5. flash_reg8_read_page
6. flash_reg8_write
7. flash_reg8_write_page
8. flash_wait_ready
9. flash_wait_complete
10. flash_chip_enable
11. flash_chip_disable
12. flash_chip_reset
13. flash_chip_identify
14. flash_chip_erase_block
15. flash_chip_read_block
16. flash_chip_read_page
17. flash_chip_read_oob
18. flash_chip_write_block
19. flash_chip_write_page
20. flash_chip_verify_block
21. flash_chip_verify_page
22. flashopen
23. flashclose
24. flashstrategy
25. flashioctl
26. flashdump
27. flashsize
28. flashstart
29. _flashstart
30. flashdone
31. flashgetdefaultlabel
32. flashgetdisklabel
33. flashminphys
34. flashread
35. flashwrite
36. flashsafestrategy
37. dumppage

    1 /*      $OpenBSD: flash.c,v 1.8 2007/06/20 18:15:46 deraadt Exp $       */
    3 /*
    4  * Copyright (c) 2005 Uwe Stuehler <uwe@openbsd.org>
    5  *
    6  * Permission to use, copy, modify, and distribute this software for any
    7  * purpose with or without fee is hereby granted, provided that the above
    8  * copyright notice and this permission notice appear in all copies.
    9  *
   10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   17  */
   19 #include <sys/param.h>
   20 #include <sys/buf.h>
   21 #include <sys/conf.h>
   22 #include <sys/device.h>
   23 #include <sys/disk.h>
   24 #include <sys/disklabel.h>
   25 #include <sys/dkio.h>
   26 #include <sys/kernel.h>
   27 #include <sys/stat.h>
   28 #include <sys/systm.h>
   30 #include <dev/flashvar.h>
   32 #include <ufs/ffs/fs.h>         /* XXX */
   34 /* Samsung command set */
   35 #define SAMSUNG_CMD_PTRLO       0x00
   36 #define SAMSUNG_CMD_PTRHI       0x01
   37 #define SAMSUNG_CMD_PTROOB      0x50
   38 #define SAMSUNG_CMD_READ        0x30
   39 #define SAMSUNG_CMD_SEQIN       0x80
   40 #define SAMSUNG_CMD_WRITE       0x10
   41 #define SAMSUNG_CMD_ERASE0      0x60
   42 #define SAMSUNG_CMD_ERASE1      0xd0
   43 #define SAMSUNG_CMD_STATUS      0x70
   44 #define  STATUS_FAIL            (1<<0)
   45 #define  STATUS_READY           (1<<6)
   46 #define  STATUS_NWP             (1<<7)
   47 #define SAMSUNG_CMD_READID      0x90
   48 #define SAMSUNG_CMD_RESET       0xff
   50 int      flash_wait_ready(struct flash_softc *);
   51 int      flash_wait_complete(struct flash_softc *);
   53 /* XXX: these should go elsewhere */
cdev_decl(flash);
bdev_decl(flash);
   57 #define flashlock(sc) disk_lock(&(sc)->sc_dk)
   58 #define flashunlock(sc) disk_unlock(&(sc)->sc_dk)
   59 #define flashlookup(unit) \
   60         (struct flash_softc *)device_lookup(&flash_cd, (unit))
   62 void    flashminphys(struct buf *);
   63 void    flashstart(struct flash_softc *);
   64 void    _flashstart(struct flash_softc *, struct buf *);
   65 void    flashdone(void *);
   67 int     flashsafestrategy(struct flash_softc *, struct buf *);
   68 void    flashgetdefaultlabel(dev_t, struct flash_softc *,
   69     struct disklabel *);
   70 void    flashgetdisklabel(dev_t, struct flash_softc *, struct disklabel *, int);
   72 /*
   73  * Driver attachment glue
   74  */
   76 struct flashvendor {
u_int8_t         vendor;
   78         const char      *name;
   79 };
   81 static const struct flashvendor flashvendors[] = {
   82         { FLASH_VENDOR_SAMSUNG, "Samsung" }
   83 };
   84 #define FLASH_NVENDORS (sizeof(flashvendors) / sizeof(flashvendors[0]))
   86 static const struct flashdev flashdevs[] = {
   87         { FLASH_DEVICE_SAMSUNG_K9F2808U0C, "K9F2808U0C 16Mx8 3.3V",
   88            512, 16, 32, 32768 },
   89         { FLASH_DEVICE_SAMSUNG_K9F1G08U0A, "K9F1G08U0A 128Mx8 3.3V",
   90           2048, 64, 64, 65536 },
   91 };
   92 #define FLASH_NDEVS (sizeof(flashdevs) / sizeof(flashdevs[0]))
   94 struct cfdriver flash_cd = {
NULL, "flash", DV_DISK
   96 };
   98 struct dkdriver flashdkdriver = { flashstrategy };
  100 void
flashattach(struct flash_softc *sc, struct flash_ctl_tag *tag,
  102     void *cookie)
  103 {
u_int8_t vendor, device;
u_int16_t id;
  106         int i;
sc->sc_tag = tag;
sc->sc_cookie = cookie;
  111         if (sc->sc_maxwaitready <= 0)
sc->sc_maxwaitready = 1000;      /* 1ms */
  113         if (sc->sc_maxwaitcomplete <= 0)
sc->sc_maxwaitcomplete = 200000; /* 200ms */
flash_chip_enable(sc);
  118         /* Identify the flash device. */
  119         if (flash_chip_identify(sc, &vendor, &device) != 0) {
printf(": identification failed\n");
flash_chip_disable(sc);
  122                 return;
  123         }
id = (vendor << 8) | device;
  126         /* Look up device characteristics, abort if not recognized. */
  127         for (i = 0; i < FLASH_NVENDORS; i++) {
  128                 if (flashvendors[i].vendor == vendor) {
printf(": %s", flashvendors[i].name);
  130                         break;
  131                 }
  132         }
  133         if (i == FLASH_NVENDORS)
printf(": vendor 0x%02x", vendor);
  135         for (i = 0; i < FLASH_NDEVS; i++) {
  136                 if (flashdevs[i].id == id) {
printf(" %s\n", flashdevs[i].longname);
  138                         break;
  139                 }
  140         }
  141         if (i == FLASH_NDEVS) {
  142                 /* Need to add this device to flashdevs first. */
printf(" device 0x%02x\n", device);
flash_chip_disable(sc);
  145                 return;
  146         }
sc->sc_flashdev = &flashdevs[i];
  149         /* Check if the device really works or fail early. */
  150         if (flash_chip_reset(sc) != 0) {
printf("%s: reset failed\n", sc->sc_dev.dv_xname);
flash_chip_disable(sc);
  153                 return;
  154         }
flash_chip_disable(sc);
  158         /*
  159          * Initialize and attach the disk structure.
  160          */
sc->sc_dk.dk_driver = &flashdkdriver;
sc->sc_dk.dk_name = sc->sc_dev.dv_xname;
disk_attach(&sc->sc_dk);
  165         /* XXX establish shutdown hook to finish any commands. */
  166 }
  168 int
flashdetach(struct device *self, int flags)
  170 {
  171         struct flash_softc *sc = (struct flash_softc *)self;
  173         /* Detach disk. */
disk_detach(&sc->sc_dk);
  176         /* XXX more resources need to be freed here. */
  177         return 0;
  178 }
  180 int
flashactivate(struct device *self, enum devact act)
  182 {
  183         /* XXX anything to be done here? */
  184         return 0;
  185 }
  187 /*
  188  * Flash controller and chip functions
  189  */
u_int8_t
flash_reg8_read(struct flash_softc *sc, int reg)
  193 {
  194         return sc->sc_tag->reg8_read(sc->sc_cookie, reg);
  195 }
  197 void
flash_reg8_read_page(struct flash_softc *sc, caddr_t data, caddr_t oob)
  199 {
  200         int i;
  202         for (i = 0; i < sc->sc_flashdev->pagesize; i++)
data[i] = flash_reg8_read(sc, FLASH_REG_DATA);
  205         if (oob != NULL)
  206                 for (i = 0; i < sc->sc_flashdev->oobsize; i++)
oob[i] = flash_reg8_read(sc, FLASH_REG_DATA);
  208 }
  210 void
flash_reg8_write(struct flash_softc *sc, int reg, u_int8_t value)
  212 {
sc->sc_tag->reg8_write(sc->sc_cookie, reg, value);
  214 }
  216 void
flash_reg8_write_page(struct flash_softc *sc, caddr_t data, caddr_t oob)
  218 {
  219         int i;
  221         for (i = 0; i < sc->sc_flashdev->pagesize; i++)
flash_reg8_write(sc, FLASH_REG_DATA, data[i]);
  224         if (oob != NULL)
  225                 for (i = 0; i < sc->sc_flashdev->oobsize; i++)
flash_reg8_write(sc, FLASH_REG_DATA, oob[i]);
  227 }
  229 /*
  230  * Wait for the "Ready/Busy" signal to go high, indicating that the
  231  * device is ready to accept another command.
  232  */
  233 int
flash_wait_ready(struct flash_softc *sc)
  235 {
  236         int timo = sc->sc_maxwaitready;
u_int8_t ready;
ready = flash_reg8_read(sc, FLASH_REG_READY);
  240         while (ready == 0 && timo-- > 0) {
delay(1);
ready = flash_reg8_read(sc, FLASH_REG_READY);
  243         }
  244         return (ready == 0 ? EIO : 0);
  245 }
  247 /*
  248  * Similar to flash_wait_ready() but looks at IO 6 and IO 0 signals
  249  * besides R/B to decide whether the last operation was successful.
  250  */
  251 int
flash_wait_complete(struct flash_softc *sc)
  253 {
  254         int timo = sc->sc_maxwaitcomplete;
u_int8_t status;
  257         (void)flash_wait_ready(sc);
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_STATUS);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
status = flash_reg8_read(sc, FLASH_REG_DATA);
  264         while ((status & STATUS_READY) == 0 && timo-- > 0) {
  265                 if (flash_reg8_read(sc, FLASH_REG_READY))
  266                         break;
delay(1);
status = flash_reg8_read(sc, FLASH_REG_DATA);
  269         }
status = flash_reg8_read(sc, FLASH_REG_DATA);
  272         return ((status & STATUS_FAIL) != 0 ? EIO : 0);
  273 }
  275 void
flash_chip_enable(struct flash_softc *sc)
  277 {
  278         /* XXX aquire the lock. */
flash_reg8_write(sc, FLASH_REG_CE, 1);
  280 }
  282 void
flash_chip_disable(struct flash_softc *sc)
  284 {
flash_reg8_write(sc, FLASH_REG_CE, 0);
  286         /* XXX release the lock. */
  287 }
  289 int
flash_chip_reset(struct flash_softc *sc)
  291 {
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_RESET);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  296         return flash_wait_ready(sc);
  297 }
  299 int
flash_chip_identify(struct flash_softc *sc, u_int8_t *vendor,
u_int8_t *device)
  302 {
  303         int error;
  305         (void)flash_wait_ready(sc);
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_READID);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
error = flash_wait_ready(sc);
  312         if (error == 0) {
  313                 *vendor = flash_reg8_read(sc, FLASH_REG_DATA);
  314                 *device = flash_reg8_read(sc, FLASH_REG_DATA);
  315         }
  316         return error;
  317 }
  319 int
flash_chip_erase_block(struct flash_softc *sc, long blkno)
  321 {
  322         long pageno = blkno * sc->sc_flashdev->blkpages;
  323         int error;
  325         (void)flash_wait_ready(sc);
  327         /* Disable write-protection. */
flash_reg8_write(sc, FLASH_REG_WP, 0);
  330         switch (sc->sc_flashdev->id) {
  331         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
  332         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_ERASE0);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  336                 break;
  337         }
  339         switch (sc->sc_flashdev->id) {
  340         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
  341         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_ALE, 1);
flash_reg8_write(sc, FLASH_REG_ROW, pageno);
flash_reg8_write(sc, FLASH_REG_ROW, pageno >> 8);
flash_reg8_write(sc, FLASH_REG_ALE, 0);
  346                 break;
  347         }
  349         switch (sc->sc_flashdev->id) {
  350         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
  351         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_ERASE1);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  355                 break;
  356         }
error = flash_wait_complete(sc);
  360         /* Re-enable write-protection. */
flash_reg8_write(sc, FLASH_REG_WP, 1);
  363         return error;
  364 }
  366 int
flash_chip_read_block(struct flash_softc *sc, long blkno, caddr_t data)
  368 {
  369         long pageno;
  370         long blkend;
  371         int error;
pageno = blkno * sc->sc_flashdev->blkpages;
blkend = pageno + sc->sc_flashdev->blkpages;
  376         while (pageno < blkend) {
error = flash_chip_read_page(sc, pageno, data, NULL);
  378                 if (error != 0)
  379                         return error;
data += sc->sc_flashdev->pagesize;
pageno++;
  382         }
  383         return 0;
  384 }
  386 int
flash_chip_read_page(struct flash_softc *sc, long pageno, caddr_t data,
caddr_t oob)
  389 {
  390         int error;
  392         (void)flash_wait_ready(sc);
  394         switch (sc->sc_flashdev->id) {
  395         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
  396         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_PTRLO);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  400                 break;
  401         }
  403         switch (sc->sc_flashdev->id) {
  404         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
flash_reg8_write(sc, FLASH_REG_ALE, 1);
flash_reg8_write(sc, FLASH_REG_COL, 0x00);
flash_reg8_write(sc, FLASH_REG_ALE, 0);
  408                 break;
  409         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_ALE, 1);
flash_reg8_write(sc, FLASH_REG_COL, 0x00);
flash_reg8_write(sc, FLASH_REG_COL, 0x00);
flash_reg8_write(sc, FLASH_REG_ALE, 0);
  414                 break;
  415         }
  417         switch (sc->sc_flashdev->id) {
  418         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
  419         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_ALE, 1);
flash_reg8_write(sc, FLASH_REG_ROW, pageno);
flash_reg8_write(sc, FLASH_REG_ROW, pageno >> 8);
flash_reg8_write(sc, FLASH_REG_ALE, 0);
  424                 break;
  425         }
  427         switch (sc->sc_flashdev->id) {
  428         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_READ);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  432                 break;
  433         }
  435         if ((error = flash_wait_ready(sc)) != 0)
  436                 return error;
  438         /* Support hardware ECC calculation. */
  439         if (sc->sc_tag->regx_read_page) {
error = sc->sc_tag->regx_read_page(sc->sc_cookie, data,
oob);
  442                 if (error != 0)
  443                         return error;
  444         } else
flash_reg8_read_page(sc, data, oob);
  447         return 0;
  448 }
  450 int
flash_chip_read_oob(struct flash_softc *sc, long pageno, caddr_t oob)
  452 {
u_int8_t *p = (u_int8_t *)oob;
  454         int error;
  455         int i;
  457         (void)flash_wait_ready(sc);
  459         switch (sc->sc_flashdev->id) {
  460         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_PTROOB);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  464                 break;
  465         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_PTRLO);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  469                 break;
  470         }
  472         switch (sc->sc_flashdev->id) {
  473         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
flash_reg8_write(sc, FLASH_REG_ALE, 1);
flash_reg8_write(sc, FLASH_REG_COL, 0x00);
flash_reg8_write(sc, FLASH_REG_ALE, 0);
  477                 break;
  478         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_ALE, 1);
flash_reg8_write(sc, FLASH_REG_COL, 0x00);
flash_reg8_write(sc, FLASH_REG_COL, 0x08);
flash_reg8_write(sc, FLASH_REG_ALE, 0);
  483                 break;
  484         }
  486         switch (sc->sc_flashdev->id) {
  487         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
  488         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_ALE, 1);
flash_reg8_write(sc, FLASH_REG_ROW, pageno);
flash_reg8_write(sc, FLASH_REG_ROW, pageno >> 8);
flash_reg8_write(sc, FLASH_REG_ALE, 0);
  493                 break;
  494         }
  496         switch (sc->sc_flashdev->id) {
  497         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_READ);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  501                 break;
  502         }
  504         if ((error = flash_wait_ready(sc)) != 0)
  505                 return error;
  507         for (i = 0; i < sc->sc_flashdev->oobsize; i++)
p[i] = flash_reg8_read(sc, FLASH_REG_DATA);
  510         return 0;
  511 }
  513 int
flash_chip_write_block(struct flash_softc *sc, long blkno, caddr_t data,
caddr_t oob)
  516 {
  517         long pageno;
  518         long blkend;
caddr_t p;
  520         int error;
pageno = blkno * sc->sc_flashdev->blkpages;
blkend = pageno + sc->sc_flashdev->blkpages;
p = data;
  526         while (pageno < blkend) {
error = flash_chip_write_page(sc, pageno, p, oob);
  528                 if (error != 0)
  529                         return error;
p += sc->sc_flashdev->pagesize;
pageno++;
  532         }
  534         /* Verify the newly written block. */
  535         return flash_chip_verify_block(sc, blkno, data, oob);
  536 }
  538 int
flash_chip_write_page(struct flash_softc *sc, long pageno, caddr_t data,
caddr_t oob)
  541 {
  542         int error;
  544         (void)flash_wait_ready(sc);
  546         /* Disable write-protection. */
flash_reg8_write(sc, FLASH_REG_WP, 0);
  549         switch (sc->sc_flashdev->id) {
  550         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
  551         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_PTRLO);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  555                 break;
  556         }
  558         switch (sc->sc_flashdev->id) {
  559         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
  560         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_SEQIN);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  564                 break;
  565         }
  567         switch (sc->sc_flashdev->id) {
  568         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
flash_reg8_write(sc, FLASH_REG_ALE, 1);
flash_reg8_write(sc, FLASH_REG_COL, 0x00);
flash_reg8_write(sc, FLASH_REG_ALE, 0);
  572                 break;
  573         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_ALE, 1);
flash_reg8_write(sc, FLASH_REG_COL, 0x00);
flash_reg8_write(sc, FLASH_REG_COL, 0x00);
flash_reg8_write(sc, FLASH_REG_ALE, 0);
  578                 break;
  579         }
  581         switch (sc->sc_flashdev->id) {
  582         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
  583         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_ALE, 1);
flash_reg8_write(sc, FLASH_REG_ROW, pageno);
flash_reg8_write(sc, FLASH_REG_ROW, pageno >> 8);
flash_reg8_write(sc, FLASH_REG_ALE, 0);
  588                 break;
  589         }
  591         /* Support hardware ECC calculation. */
  592         if (sc->sc_tag->regx_write_page) {
error = sc->sc_tag->regx_write_page(sc->sc_cookie, data,
oob);
  595                 if (error != 0)
  596                         return error;
  597         } else
flash_reg8_write_page(sc, data, oob);
  600         switch (sc->sc_flashdev->id) {
  601         case FLASH_DEVICE_SAMSUNG_K9F2808U0C:
  602         case FLASH_DEVICE_SAMSUNG_K9F1G08U0A:
flash_reg8_write(sc, FLASH_REG_CLE, 1);
flash_reg8_write(sc, FLASH_REG_CMD, SAMSUNG_CMD_WRITE);
flash_reg8_write(sc, FLASH_REG_CLE, 0);
  606                 break;
  607         }
  609         /*
  610          * Wait for the write operation to complete although this can
  611          * take up to 700 us for the K9F1G08U0A flash type.
  612          */
error = flash_wait_complete(sc);
  615         /* Re-enable write-protection. */
flash_reg8_write(sc, FLASH_REG_WP, 1);
  618         return error;
  619 }
  621 int
flash_chip_verify_block(struct flash_softc *sc, long blkno, caddr_t data,
caddr_t oob)
  624 {
  625         long pageno;
  626         long blkend;
  627         int error;
pageno = blkno * sc->sc_flashdev->blkpages;
blkend = pageno + sc->sc_flashdev->blkpages;
  632         while (pageno < blkend) {
error = flash_chip_verify_page(sc, pageno, data, oob);
  634                 if (error != 0) {
printf("block %d page %d verify failed\n",
blkno, pageno);
  637                         return error;
  638                 }
data += sc->sc_flashdev->pagesize;
pageno++;
  641         }
  642         return 0;
  643 }
  645 int
flash_chip_verify_page(struct flash_softc *sc, long pageno, caddr_t data,
caddr_t oob)
  648 {
  649         static u_char rbuf[FLASH_MAXPAGESIZE];
  650         static u_char roob[FLASH_MAXOOBSIZE];
  651         int error;
error = flash_chip_read_page(sc, pageno, rbuf,
oob == NULL ? NULL : roob);
  655         if (error != 0)
  656                 return error;
  658         if (memcmp((const void *)&rbuf[0], (const void *)data,
sc->sc_flashdev->pagesize) != 0)
  660                 return EIO;
  662         if (oob != NULL && memcmp((const void *)&roob[0],
  663             (const void *)oob, sc->sc_flashdev->oobsize) != 0)
  664                 return EIO;
  666         return 0;
  667 }
  669 /*
  670  * Block device functions
  671  */
  673 int
  674 flashopen(dev_t dev, int oflags, int devtype, struct proc *p)
  675 {
  676         struct flash_softc *sc;
  677         int error;
  678         int part;
sc = flashlookup(flashunit(dev));
  681         if (sc == NULL)
  682                 return ENXIO;
  684         if ((error = flashlock(sc)) != 0) {
device_unref(&sc->sc_dev);
  686                 return error;
  687         }
  689         /*
  690          * If no partition is open load the partition info if it is
  691          * not already valid.  If partitions are already open, allow
  692          * opens only for the same kind of device.
  693          */
  694         if (sc->sc_dk.dk_openmask == 0) {
  695                 if ((sc->sc_flags & FDK_LOADED) == 0 ||
  696                     ((sc->sc_flags & FDK_SAFE) == 0) !=
  697                     (flashsafe(dev) == 0)) {
sc->sc_flags &= ~FDK_SAFE;
sc->sc_flags |= FDK_LOADED;
  700                         if (flashsafe(dev))
sc->sc_flags |= FDK_SAFE;
flashgetdisklabel(dev, sc, sc->sc_dk.dk_label, 0);
  703                 }
  704         } else if (((sc->sc_flags & FDK_SAFE) == 0) !=
  705             (flashsafe(dev) == 0)) {
flashunlock(sc);
device_unref(&sc->sc_dev);
  708                 return EBUSY;
  709         }
  711         /* Check that the partition exists. */
part = flashpart(dev);
  713         if (part != RAW_PART &&
  714             (part >= sc->sc_dk.dk_label->d_npartitions ||
sc->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
flashunlock(sc);
device_unref(&sc->sc_dev);
  718                 return ENXIO;
  719         }
  721         /* Prevent our unit from being deconfigured while open. */
  722         switch (devtype) {
  723         case S_IFCHR:
sc->sc_dk.dk_copenmask |= (1 << part);
  725                 break;
  726         case S_IFBLK:
sc->sc_dk.dk_bopenmask |= (1 << part);
  728                 break;
  729         }
sc->sc_dk.dk_openmask =
sc->sc_dk.dk_copenmask | sc->sc_dk.dk_bopenmask;
flashunlock(sc);
device_unref(&sc->sc_dev);
  735         return 0;
  736 }
  738 int
  739 flashclose(dev_t dev, int fflag, int devtype, struct proc *p)
  740 {
  741         struct flash_softc *sc;
  742         int error;
  743         int part;
sc = flashlookup(flashunit(dev));
  746         if (sc == NULL)
  747                 return ENXIO;
  749         if ((error = flashlock(sc)) != 0) {
device_unref(&sc->sc_dev);
  751                 return error;
  752         }
  754         /* Close one open partition. */
part = flashpart(dev);
  756         switch (devtype) {
  757         case S_IFCHR:
sc->sc_dk.dk_copenmask &= ~(1 << part);
  759                 break;
  760         case S_IFBLK:
sc->sc_dk.dk_bopenmask &= ~(1 << part);
  762                 break;
  763         }
sc->sc_dk.dk_openmask =
sc->sc_dk.dk_copenmask | sc->sc_dk.dk_bopenmask;
  767         if (sc->sc_dk.dk_openmask == 0) {
  768                 /* XXX wait for I/O to complete? */
  769         }
flashunlock(sc);
device_unref(&sc->sc_dev);
  773         return 0;
  774 }
  776 /*
  777  * Queue the transfer of one or more flash pages.
  778  */
  779 void
flashstrategy(struct buf *bp)
  781 {
  782         struct flash_softc *sc;
  783         int s;
sc = flashlookup(flashunit(bp->b_dev));
  786         if (sc == NULL) {
bp->b_error = ENXIO;
  788                 goto bad;
  789         }
  791         /* Transfer only a multiple of the flash page size. */
  792         if ((bp->b_bcount % sc->sc_flashdev->pagesize) != 0) {
bp->b_error = EINVAL;
  794                 goto bad;
  795         }
  797         /* If the device has been invalidated, error out. */
  798         if ((sc->sc_flags & FDK_LOADED) == 0) {
bp->b_error = EIO;
  800                 goto bad;
  801         }
  803         /* Translate logical block numbers to physical. */
  804         if (flashsafe(bp->b_dev) && flashsafestrategy(sc, bp) <= 0)
  805                 goto done;
  807         /* Return immediately if it is a null transfer. */
  808         if (bp->b_bcount == 0)
  809                 goto done;
  811         /* Do bounds checking on partitions. */
  812         if (flashpart(bp->b_dev) != RAW_PART &&
bounds_check_with_label(bp, sc->sc_dk.dk_label, 0) <= 0)
  814                 goto done;
  816         /* Queue the transfer. */
s = splbio();
disksort(&sc->sc_q, bp);
flashstart(sc);
splx(s);
device_unref(&sc->sc_dev);
  822         return;
bad:
bp->b_flags |= B_ERROR;
done:
  827         if ((bp->b_flags & B_ERROR) != 0)
bp->b_resid = bp->b_bcount;
s = splbio();
biodone(bp);
splx(s);
  832         if (sc != NULL)
device_unref(&sc->sc_dev);
  834 }
  836 int
  837 flashioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct proc *p)
  838 {
  839         struct flash_softc *sc;
  840         int error = 0;
sc = flashlookup(flashunit(dev));
  843         if (sc == NULL)
  844                 return ENXIO;
  846         if ((sc->sc_flags & FDK_LOADED) == 0) {
device_unref(&sc->sc_dev);
  848                 return EIO;
  849         }
  851         switch (cmd) {
  852         case DIOCGDINFO:
  853                 *(struct disklabel *)data = *sc->sc_dk.dk_label;
  854                 break;
  855         default:
error = ENOTTY;
  857                 break;
  858         }
device_unref(&sc->sc_dev);
  861         return error;
  862 }
  864 int
  865 flashdump(dev_t dev, daddr64_t blkno, caddr_t va, size_t size)
  866 {
printf("flashdump\n");
  868         return ENODEV;
  869 }
daddr64_t
  872 flashsize(dev_t dev)
  873 {
printf("flashsize\n");
  875         return ENODEV;
  876 }
  878 void
flashstart(struct flash_softc *sc)
  880 {
  881         struct buf *dp, *bp;
  883         while (1) {
  884                 /* Remove the next buffer from the queue or stop. */
dp = &sc->sc_q;
bp = dp->b_actf;
  887                 if (bp == NULL)
  888                         return;
dp->b_actf = bp->b_actf;
  891                 /* Transfer this buffer now. */
_flashstart(sc, bp);
  893         }
  894 }
  896 void
_flashstart(struct flash_softc *sc, struct buf *bp)
  898 {
  899         int part;
daddr64_t offset;
  901         long pgno;
part = flashpart(bp->b_dev);
offset = DL_GETPOFFSET(&sc->sc_dk.dk_label->d_partitions[part]) +
bp->b_blkno;
pgno = offset / (sc->sc_flashdev->pagesize / DEV_BSIZE);
  908         /*
  909          * If the requested page is exactly at the end of flash and it
  910          * is an "unsafe" device, return EOF, else error out.
  911          */
  912         if (!flashsafe(bp->b_dev) && pgno == sc->sc_flashdev->capacity) {
bp->b_resid = bp->b_bcount;
biodone(bp);
  915                 return;
  916         } else if (pgno >= sc->sc_flashdev->capacity) {
bp->b_error = EINVAL;
bp->b_flags |= B_ERROR;
biodone(bp);
  920                 return;
  921         }
sc->sc_bp = bp;
  925         /* Instrumentation. */
disk_busy(&sc->sc_dk);
  928         /* XXX this should be done asynchronously. */
flash_chip_enable(sc);
  930         if ((bp->b_flags & B_READ) != 0)
bp->b_error = flash_chip_read_page(sc, pgno, bp->b_data,
NULL);
  933         else
bp->b_error = flash_chip_write_page(sc, pgno, bp->b_data,
NULL);
  936         if (bp->b_error == 0)
bp->b_resid = bp->b_bcount - sc->sc_flashdev->pagesize;
flash_chip_disable(sc);
flashdone(sc);
  940 }
  942 void
flashdone(void *v)
  944 {
  945         struct flash_softc *sc = v;
  946         struct buf *bp = sc->sc_bp;
  948         /* Instrumentation. */
disk_unbusy(&sc->sc_dk, bp->b_bcount - bp->b_resid,
  950             (bp->b_flags & B_READ) != 0);
  952         if (bp->b_error != 0)
bp->b_flags |= B_ERROR;
biodone(bp);
flashstart(sc);
  957 }
  959 void
flashgetdefaultlabel(dev_t dev, struct flash_softc *sc,
  961     struct disklabel *lp)
  962 {
size_t len;
bzero(lp, sizeof(struct disklabel));
lp->d_type = 0;
lp->d_subtype = 0;
strncpy(lp->d_typename, "NAND flash", sizeof(lp->d_typename));
  971         /* Use the product name up to the first space. */
strncpy(lp->d_packname, sc->sc_flashdev->longname,
  973             sizeof(lp->d_packname));
  974         for (len = 0; len < sizeof(lp->d_packname); len++)
  975                 if (lp->d_packname[len] == ' ') {
lp->d_packname[len] = '\0';
  977                         break;
  978                 }
  980         /* Fake the disk geometry. */
lp->d_ncylinders = 1;
lp->d_ntracks = 16;
lp->d_secsize = sc->sc_flashdev->pagesize;
lp->d_nsectors = sc->sc_flashdev->capacity / lp->d_ntracks
  985             / lp->d_ncylinders;
lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
DL_SETDSIZE(lp, (daddr64_t)lp->d_ncylinders * lp->d_secpercyl);
  989         /* Fake hardware characteristics. */
lp->d_rpm = 3600;
lp->d_interleave = 1;
lp->d_version = 1;
  994         /* XXX these values assume ffs. */
lp->d_bbsize = BBSIZE;
lp->d_sbsize = SBSIZE;
  998         /* Wrap it up. */
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
lp->d_checksum = dkcksum(lp);
 1002 }
 1004 void
flashgetdisklabel(dev_t dev, struct flash_softc *sc,
 1006     struct disklabel *lp, int spoofonly)
 1007 {
 1008         char *errstring;
dev_t labeldev;
flashgetdefaultlabel(dev, sc, lp);
 1013         if (sc->sc_tag->default_disklabel != NULL)
sc->sc_tag->default_disklabel(sc->sc_cookie, dev, lp);
 1016         /* Call the generic disklabel extraction routine. */
labeldev = flashlabeldev(dev);
errstring = readdisklabel(labeldev, flashstrategy, lp, spoofonly);
 1019         if (errstring != NULL) {
 1020                 /*printf("%s: %s\n", sc->sc_dev.dv_xname, errstring);*/
 1021         }
 1022 }
 1024 /*
 1025  * Character device functions
 1026  */
 1028 void
flashminphys(struct buf *bp)
 1030 {
 1031         struct flash_softc *sc;
sc = flashlookup(flashunit(bp->b_dev));
 1035         if (bp->b_bcount > sc->sc_flashdev->pagesize)
bp->b_bcount = sc->sc_flashdev->pagesize;
 1037 }
 1039 int
 1040 flashread(dev_t dev, struct uio *uio, int ioflag)
 1041 {
 1042         return physio(flashstrategy, NULL, dev, B_READ, flashminphys, uio);
 1043 }
 1045 int
 1046 flashwrite(dev_t dev, struct uio *uio, int ioflag)
 1047 {
 1048         return physio(flashstrategy, NULL, dev, B_WRITE, flashminphys, uio);
 1049 }
 1051 /*
 1052  * Physical access strategy "fixup" routines for transparent bad
 1053  * blocks management, wear-leveling, etc.
 1054  */
 1056 /*
 1057  * Call the machine-specific routine if there is any or use just a
 1058  * default strategy for bad blocks management.
 1059  */
 1060 int
flashsafestrategy(struct flash_softc *sc, struct buf *bp)
 1062 {
 1063         if (sc->sc_tag->safe_strategy) {
 1064                 return sc->sc_tag->safe_strategy(sc->sc_cookie, bp);
 1065         }
 1067         /* XXX no default bad blocks management strategy yet */
 1068         return 1;
 1069 }
 1071 void dumppage(u_char *);
 1072 void dumppage(u_char *buf)
 1073 {
 1074         int i;
 1075         for (i = 0; i < 512; i++) {
 1076                 if ((i % 16) == 0)
printf("%04x: ", i);
 1078                 if ((i % 16) == 8)
printf(" ");
printf(" %02x", buf[i]);
 1081                 if ((i % 16) == 15)
printf("\n");
 1083         }
 1084         if ((i % 16) != 0)
printf("\n");
 1086 }