sys/dev/nand/nand_geom.c

   1 /*-
   2  * Copyright (C) 2009-2012 Semihalf
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/systm.h>
  32 #include <sys/conf.h>
  33 #include <sys/bus.h>
  34 #include <sys/malloc.h>
  35 #include <sys/uio.h>
  36 #include <sys/bio.h>
  37 #include <geom/geom.h>
  38 #include <geom/geom_disk.h>
  39
  40 #include <dev/nand/nand.h>
  41 #include <dev/nand/nandbus.h>
  42 #include <dev/nand/nand_dev.h>
  43 #include "nand_if.h"
  44 #include "nandbus_if.h"
  45
  46 #define BIO_NAND_STD    ((void *)1)
  47 #define BIO_NAND_RAW    ((void *)2)
  48
  49 static disk_ioctl_t nand_ioctl;
  50 static disk_getattr_t nand_getattr;
  51 static disk_strategy_t nand_strategy;
  52 static disk_strategy_t nand_strategy_raw;
  53
  54 static int
  55 nand_read(struct nand_chip *chip, uint32_t offset, void *buf, uint32_t len)
  56 {
  57
  58         nand_debug(NDBG_GEOM, "Read from chip %d [%p] at %d", chip->num, chip,
  59             offset);
  60
  61         return (nand_read_pages(chip, offset, buf, len));
  62 }
  63
  64 static int
  65 nand_write(struct nand_chip *chip, uint32_t offset, void* buf, uint32_t len)
  66 {
  67
  68         nand_debug(NDBG_GEOM, "Write to chip %d [%p] at %d", chip->num, chip,
  69             offset);
  70
  71         return (nand_prog_pages(chip, offset, buf, len));
  72 }
  73
  74 static int
  75 nand_read_raw(struct nand_chip *chip, uint32_t offset, void *buf, uint32_t len)
  76 {
  77         nand_debug(NDBG_GEOM, "Raw read from chip %d [%p] at %d", chip->num,
  78             chip, offset);
  79
  80         return (nand_read_pages_raw(chip, offset, buf, len));
  81 }
  82
  83 static int
  84 nand_write_raw(struct nand_chip *chip, uint32_t offset, void *buf, uint32_t len)
  85 {
  86
  87         nand_debug(NDBG_GEOM, "Raw write to chip %d [%p] at %d", chip->num,
  88             chip, offset);
  89
  90         return (nand_prog_pages_raw(chip, offset, buf, len));
  91 }
  92
  93 static void
  94 nand_strategy(struct bio *bp)
  95 {
  96         struct nand_chip *chip;
  97
  98         chip = (struct nand_chip *)bp->bio_disk->d_drv1;
  99
 100         bp->bio_driver1 = BIO_NAND_STD;
 101
 102         nand_debug(NDBG_GEOM, "Strategy %s on chip %d [%p]",
 103             (bp->bio_cmd & BIO_READ) == BIO_READ ? "READ" :
 104             ((bp->bio_cmd & BIO_WRITE) == BIO_WRITE ? "WRITE" :
 105             ((bp->bio_cmd & BIO_DELETE) == BIO_DELETE ? "DELETE" : "UNKNOWN")),
 106             chip->num, chip);
 107
 108         mtx_lock(&chip->qlock);
 109         bioq_insert_tail(&chip->bioq, bp);
 110         mtx_unlock(&chip->qlock);
 111         taskqueue_enqueue(chip->tq, &chip->iotask);
 112 }
 113
 114 static void
 115 nand_strategy_raw(struct bio *bp)
 116 {
 117         struct nand_chip *chip;
 118
 119         chip = (struct nand_chip *)bp->bio_disk->d_drv1;
 120
 121         /* Inform taskqueue that it's a raw access */
 122         bp->bio_driver1 = BIO_NAND_RAW;
 123
 124         nand_debug(NDBG_GEOM, "Strategy %s on chip %d [%p]",
 125             (bp->bio_cmd & BIO_READ) == BIO_READ ? "READ" :
 126             ((bp->bio_cmd & BIO_WRITE) == BIO_WRITE ? "WRITE" :
 127             ((bp->bio_cmd & BIO_DELETE) == BIO_DELETE ? "DELETE" : "UNKNOWN")),
 128             chip->num, chip);
 129
 130         mtx_lock(&chip->qlock);
 131         bioq_insert_tail(&chip->bioq, bp);
 132         mtx_unlock(&chip->qlock);
 133         taskqueue_enqueue(chip->tq, &chip->iotask);
 134 }
 135
 136 static int
 137 nand_oob_access(struct nand_chip *chip, uint32_t page, uint32_t offset,
 138     uint32_t len, uint8_t *data, uint8_t write)
 139 {
 140         struct chip_geom *cg;
 141         int ret = 0;
 142
 143         cg = &chip->chip_geom;
 144
 145         if (!write)
 146                 ret = nand_read_oob(chip, page, data, cg->oob_size);
 147         else
 148                 ret = nand_prog_oob(chip, page, data, cg->oob_size);
 149
 150         return (ret);
 151 }
 152
 153 static int
 154 nand_getattr(struct bio *bp)
 155 {
 156         struct nand_chip *chip;
 157         struct chip_geom *cg;
 158         device_t dev;
 159         int val;
 160
 161         if (bp->bio_disk == NULL || bp->bio_disk->d_drv1 == NULL)
 162                 return (ENXIO);
 163
 164         chip = (struct nand_chip *)bp->bio_disk->d_drv1;
 165         cg = &(chip->chip_geom);
 166
 167         dev = device_get_parent(chip->dev);
 168         dev = device_get_parent(dev);
 169
 170         if (strcmp(bp->bio_attribute, "NAND::device") == 0) {
 171                 if (bp->bio_length != sizeof(dev))
 172                         return (EFAULT);
 173                 bcopy(&dev, bp->bio_data, sizeof(dev));
 174         } else {
 175                 if (strcmp(bp->bio_attribute, "NAND::oobsize") == 0)
 176                         val = cg->oob_size;
 177                 else if (strcmp(bp->bio_attribute, "NAND::pagesize") == 0)
 178                         val = cg->page_size;
 179                 else if (strcmp(bp->bio_attribute, "NAND::blocksize") == 0)
 180                         val = cg->block_size;
 181                 else
 182                         return (-1);
 183                 if (bp->bio_length != sizeof(val))
 184                         return (EFAULT);
 185                 bcopy(&val, bp->bio_data, sizeof(val));
 186         }
 187         bp->bio_completed = bp->bio_length;
 188         return (0);
 189 }
 190
 191 static int
 192 nand_ioctl(struct disk *ndisk, u_long cmd, void *data, int fflag,
 193     struct thread *td)
 194 {
 195         struct nand_chip *chip;
 196         struct nand_oob_rw *oob_rw = NULL;
 197         struct nand_raw_rw *raw_rw = NULL;
 198         device_t nandbus;
 199         uint8_t *buf = NULL;
 200         int ret = 0;
 201         uint8_t status;
 202
 203         chip = (struct nand_chip *)ndisk->d_drv1;
 204         nandbus = device_get_parent(chip->dev);
 205
 206         if ((cmd == NAND_IO_RAW_READ) || (cmd == NAND_IO_RAW_PROG)) {
 207                 raw_rw = (struct nand_raw_rw *)data;
 208                 buf = malloc(raw_rw->len, M_NAND, M_WAITOK);
 209         }
 210         switch (cmd) {
 211         case NAND_IO_ERASE:
 212                 ret = nand_erase_blocks(chip, ((off_t *)data)[0],
 213                     ((off_t *)data)[1]);
 214                 break;
 215
 216         case NAND_IO_OOB_READ:
 217                 oob_rw = (struct nand_oob_rw *)data;
 218                 ret = nand_oob_access(chip, oob_rw->page, 0,
 219                     oob_rw->len, oob_rw->data, 0);
 220                 break;
 221
 222         case NAND_IO_OOB_PROG:
 223                 oob_rw = (struct nand_oob_rw *)data;
 224                 ret = nand_oob_access(chip, oob_rw->page, 0,
 225                     oob_rw->len, oob_rw->data, 1);
 226                 break;
 227
 228         case NAND_IO_GET_STATUS:
 229                 NANDBUS_LOCK(nandbus);
 230                 ret = NANDBUS_GET_STATUS(nandbus, &status);
 231                 if (ret == 0)
 232                         *(uint8_t *)data = status;
 233                 NANDBUS_UNLOCK(nandbus);
 234                 break;
 235
 236         case NAND_IO_RAW_PROG:
 237                 copyin(raw_rw->data, buf, raw_rw->len);
 238                 ret = nand_prog_pages_raw(chip, raw_rw->off, buf,
 239                     raw_rw->len);
 240                 break;
 241
 242         case NAND_IO_RAW_READ:
 243                 ret = nand_read_pages_raw(chip, raw_rw->off, buf,
 244                     raw_rw->len);
 245                 copyout(buf, raw_rw->data, raw_rw->len);
 246                 break;
 247
 248         case NAND_IO_GET_CHIP_PARAM:
 249                 nand_get_chip_param(chip, (struct chip_param_io *)data);
 250                 break;
 251
 252         default:
 253                 printf("Unknown nand_ioctl request \n");
 254                 ret = EIO;
 255         }
 256
 257         if (buf)
 258                 free(buf, M_NAND);
 259
 260         return (ret);
 261 }
 262
 263 static void
 264 nand_io_proc(void *arg, int pending)
 265 {
 266         struct nand_chip *chip = arg;
 267         struct bio *bp;
 268         int err = 0;
 269
 270         for (;;) {
 271                 mtx_lock(&chip->qlock);
 272                 bp = bioq_takefirst(&chip->bioq);
 273                 mtx_unlock(&chip->qlock);
 274                 if (bp == NULL)
 275                         break;
 276
 277                 if (bp->bio_driver1 == BIO_NAND_STD) {
 278                         if ((bp->bio_cmd & BIO_READ) == BIO_READ) {
 279                                 err = nand_read(chip,
 280                                     bp->bio_offset & 0xffffffff,
 281                                     bp->bio_data, bp->bio_bcount);
 282                         } else if ((bp->bio_cmd & BIO_WRITE) == BIO_WRITE) {
 283                                 err = nand_write(chip,
 284                                     bp->bio_offset & 0xffffffff,
 285                                     bp->bio_data, bp->bio_bcount);
 286                         }
 287                 } else if (bp->bio_driver1 == BIO_NAND_RAW) {
 288                         if ((bp->bio_cmd & BIO_READ) == BIO_READ) {
 289                                 err = nand_read_raw(chip,
 290                                     bp->bio_offset & 0xffffffff,
 291                                     bp->bio_data, bp->bio_bcount);
 292                         } else if ((bp->bio_cmd & BIO_WRITE) == BIO_WRITE) {
 293                                 err = nand_write_raw(chip,
 294                                     bp->bio_offset & 0xffffffff,
 295                                     bp->bio_data, bp->bio_bcount);
 296                         }
 297                 } else
 298                         panic("Unknown access type in bio->bio_driver1\n");
 299
 300                 if ((bp->bio_cmd & BIO_DELETE) == BIO_DELETE) {
 301                         nand_debug(NDBG_GEOM, "Delete on chip%d offset %lld "
 302                             "length %ld\n", chip->num, bp->bio_offset,
 303                             bp->bio_bcount);
 304                         err = nand_erase_blocks(chip,
 305                             bp->bio_offset & 0xffffffff,
 306                             bp->bio_bcount);
 307                 }
 308
 309                 if (err == 0 || err == ECC_CORRECTABLE)
 310                         bp->bio_resid = 0;
 311                 else {
 312                         nand_debug(NDBG_GEOM,"nand_[read|write|erase_blocks] "
 313                             "error: %d\n", err);
 314
 315                         bp->bio_error = EIO;
 316                         bp->bio_flags |= BIO_ERROR;
 317                         bp->bio_resid = bp->bio_bcount;
 318                 }
 319                 biodone(bp);
 320         }
 321 }
 322
 323 int
 324 create_geom_disk(struct nand_chip *chip)
 325 {
 326         struct disk *ndisk, *rdisk;
 327
 328         /* Create the disk device */
 329         ndisk = disk_alloc();
 330         ndisk->d_strategy = nand_strategy;
 331         ndisk->d_ioctl = nand_ioctl;
 332         ndisk->d_getattr = nand_getattr;
 333         ndisk->d_name = "gnand";
 334         ndisk->d_drv1 = chip;
 335         ndisk->d_maxsize = chip->chip_geom.block_size;
 336         ndisk->d_sectorsize = chip->chip_geom.page_size;
 337         ndisk->d_mediasize = chip->chip_geom.chip_size;
 338         ndisk->d_unit = chip->num +
 339             10 * device_get_unit(device_get_parent(chip->dev));
 340
 341         /*
 342          * When using BBT, make two last blocks of device unavailable
 343          * to user (because those are used to store BBT table).
 344          */
 345         if (chip->bbt != NULL)
 346                 ndisk->d_mediasize -= (2 * chip->chip_geom.block_size);
 347
 348         ndisk->d_flags = DISKFLAG_CANDELETE;
 349
 350         snprintf(ndisk->d_ident, sizeof(ndisk->d_ident),
 351             "nand: Man:0x%02x Dev:0x%02x", chip->id.man_id, chip->id.dev_id);
 352
 353         disk_create(ndisk, DISK_VERSION);
 354
 355         /* Create the RAW disk device */
 356         rdisk = disk_alloc();
 357         rdisk->d_strategy = nand_strategy_raw;
 358         rdisk->d_ioctl = nand_ioctl;
 359         rdisk->d_getattr = nand_getattr;
 360         rdisk->d_name = "gnand.raw";
 361         rdisk->d_drv1 = chip;
 362         rdisk->d_maxsize = chip->chip_geom.block_size;
 363         rdisk->d_sectorsize = chip->chip_geom.page_size;
 364         rdisk->d_mediasize = chip->chip_geom.chip_size;
 365         rdisk->d_unit = chip->num +
 366             10 * device_get_unit(device_get_parent(chip->dev));
 367
 368         rdisk->d_flags = DISKFLAG_CANDELETE;
 369
 370         snprintf(rdisk->d_ident, sizeof(rdisk->d_ident),
 371             "nand_raw: Man:0x%02x Dev:0x%02x", chip->id.man_id,
 372             chip->id.dev_id);
 373
 374         disk_create(rdisk, DISK_VERSION);
 375
 376         chip->ndisk = ndisk;
 377         chip->rdisk = rdisk;
 378
 379         mtx_init(&chip->qlock, "NAND I/O lock", NULL, MTX_DEF);
 380         bioq_init(&chip->bioq);
 381
 382         TASK_INIT(&chip->iotask, 0, nand_io_proc, chip);
 383         chip->tq = taskqueue_create("nand_taskq", M_WAITOK,
 384             taskqueue_thread_enqueue, &chip->tq);
 385         taskqueue_start_threads(&chip->tq, 1, PI_DISK, "nand taskq");
 386
 387         if (bootverbose)
 388                 device_printf(chip->dev, "Created gnand%d for chip [0x%0x, "
 389                     "0x%0x]\n", ndisk->d_unit, chip->id.man_id,
 390                     chip->id.dev_id);
 391
 392         return (0);
 393 }
 394
 395 void
 396 destroy_geom_disk(struct nand_chip *chip)
 397 {
 398         struct bio *bp;
 399
 400         taskqueue_free(chip->tq);
 401         disk_destroy(chip->ndisk);
 402         disk_destroy(chip->rdisk);
 403
 404         mtx_lock(&chip->qlock);
 405         for (;;) {
 406                 bp = bioq_takefirst(&chip->bioq);
 407                 if (bp == NULL)
 408                         break;
 409                 bp->bio_error = EIO;
 410                 bp->bio_flags |= BIO_ERROR;
 411                 bp->bio_resid = bp->bio_bcount;
 412
 413                 biodone(bp);
 414         }
 415         mtx_unlock(&chip->qlock);
 416
 417         mtx_destroy(&chip->qlock);
 418 }