sys/dev/flash/n25q.c

   1 /*-
   2  * Copyright (c) 2009 Oleksandr Tymoshenko.  All rights reserved.
   3  * Copyright (c) 2017 Ruslan Bukin <br@bsdpad.com>
   4  * Copyright (c) 2018 Ian Lepore.  All rights reserved.
   5  * Copyright (c) 2006 M. Warner Losh <imp@FreeBSD.org>
   6  *
   7  * This software was developed by SRI International and the University of
   8  * Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-10-C-0237
   9  * ("CTSRD"), as part of the DARPA CRASH research programme.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  */
  32
  33 /* n25q Quad SPI Flash driver. */
  34
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 #include "opt_platform.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/bio.h>
  43 #include <sys/bus.h>
  44 #include <sys/conf.h>
  45 #include <sys/kernel.h>
  46 #include <sys/kthread.h>
  47 #include <sys/lock.h>
  48 #include <sys/mbuf.h>
  49 #include <sys/malloc.h>
  50 #include <sys/module.h>
  51 #include <sys/mutex.h>
  52 #include <geom/geom_disk.h>
  53
  54 #include <machine/bus.h>
  55
  56 #include <dev/fdt/fdt_common.h>
  57 #include <dev/ofw/ofw_bus_subr.h>
  58 #include <dev/ofw/openfirm.h>
  59
  60 #include <dev/flash/mx25lreg.h>
  61
  62 #include "qspi_if.h"
  63
  64 #define N25Q_DEBUG
  65 #undef N25Q_DEBUG
  66
  67 #ifdef N25Q_DEBUG
  68 #define dprintf(fmt, ...)  printf(fmt, ##__VA_ARGS__)
  69 #else
  70 #define dprintf(fmt, ...)
  71 #endif
  72
  73 #define FL_NONE                 0x00
  74 #define FL_ERASE_4K             0x01
  75 #define FL_ERASE_32K            0x02
  76 #define FL_ENABLE_4B_ADDR       0x04
  77 #define FL_DISABLE_4B_ADDR      0x08
  78
  79 /*
  80  * Define the sectorsize to be a smaller size rather than the flash
  81  * sector size. Trying to run FFS off of a 64k flash sector size
  82  * results in a completely un-usable system.
  83  */
  84 #define FLASH_SECTORSIZE        512
  85
  86 struct n25q_flash_ident {
  87         const char      *name;
  88         uint8_t         manufacturer_id;
  89         uint16_t        device_id;
  90         unsigned int    sectorsize;
  91         unsigned int    sectorcount;
  92         unsigned int    flags;
  93 };
  94
  95 struct n25q_softc {
  96         device_t                dev;
  97         bus_space_tag_t         bst;
  98         bus_space_handle_t      bsh;
  99         void                    *ih;
 100         struct resource         *res[3];
 101
 102         uint8_t                 sc_manufacturer_id;
 103         uint16_t                device_id;
 104         unsigned int            sc_sectorsize;
 105         struct mtx              sc_mtx;
 106         struct disk             *sc_disk;
 107         struct proc             *sc_p;
 108         struct bio_queue_head   sc_bio_queue;
 109         unsigned int            sc_flags;
 110         unsigned int            sc_taskstate;
 111 };
 112
 113 #define TSTATE_STOPPED  0
 114 #define TSTATE_STOPPING 1
 115 #define TSTATE_RUNNING  2
 116
 117 #define N25Q_LOCK(_sc)          mtx_lock(&(_sc)->sc_mtx)
 118 #define N25Q_UNLOCK(_sc)        mtx_unlock(&(_sc)->sc_mtx)
 119 #define N25Q_LOCK_INIT(_sc)                                     \
 120         mtx_init(&_sc->sc_mtx, device_get_nameunit(_sc->dev),   \
 121             "n25q", MTX_DEF)
 122 #define N25Q_LOCK_DESTROY(_sc)  mtx_destroy(&_sc->sc_mtx);
 123 #define N25Q_ASSERT_LOCKED(_sc)                         \
 124         mtx_assert(&_sc->sc_mtx, MA_OWNED);
 125 #define N25Q_ASSERT_UNLOCKED(_sc)                               \
 126         mtx_assert(&_sc->sc_mtx, MA_NOTOWNED);
 127
 128 static struct ofw_compat_data compat_data[] = {
 129         { "n25q00aa",           1 },
 130         { NULL,                 0 },
 131 };
 132
 133 /* disk routines */
 134 static int n25q_open(struct disk *dp);
 135 static int n25q_close(struct disk *dp);
 136 static int n25q_ioctl(struct disk *, u_long, void *, int, struct thread *);
 137 static void n25q_strategy(struct bio *bp);
 138 static int n25q_getattr(struct bio *bp);
 139 static void n25q_task(void *arg);
 140
 141 static struct n25q_flash_ident flash_devices[] = {
 142         { "n25q00", 0x20, 0xbb21, (64 * 1024), 2048, FL_ENABLE_4B_ADDR},
 143 };
 144
 145 static int
 146 n25q_wait_for_device_ready(device_t dev)
 147 {
 148         device_t pdev;
 149         uint8_t status;
 150         int err;
 151
 152         pdev = device_get_parent(dev);
 153
 154         do {
 155                 err = QSPI_READ_REG(pdev, dev, CMD_READ_STATUS, &status, 1);
 156         } while (err == 0 && (status & STATUS_WIP));
 157
 158         return (err);
 159 }
 160
 161 static struct n25q_flash_ident*
 162 n25q_get_device_ident(struct n25q_softc *sc)
 163 {
 164         uint8_t manufacturer_id;
 165         uint16_t dev_id;
 166         device_t pdev;
 167         uint8_t data[4];
 168         int i;
 169
 170         pdev = device_get_parent(sc->dev);
 171
 172         QSPI_READ_REG(pdev, sc->dev, CMD_READ_IDENT, (uint8_t *)&data[0], 4);
 173
 174         manufacturer_id = data[0];
 175         dev_id = (data[1] << 8) | (data[2]);
 176
 177         for (i = 0; i < nitems(flash_devices); i++) {
 178                 if ((flash_devices[i].manufacturer_id == manufacturer_id) &&
 179                     (flash_devices[i].device_id == dev_id))
 180                         return &flash_devices[i];
 181         }
 182
 183         printf("Unknown SPI flash device. Vendor: %02x, device id: %04x\n",
 184             manufacturer_id, dev_id);
 185
 186         return (NULL);
 187 }
 188
 189 static int
 190 n25q_write(device_t dev, struct bio *bp, off_t offset, caddr_t data, off_t count)
 191 {
 192         struct n25q_softc *sc;
 193         device_t pdev;
 194         int err;
 195
 196         pdev = device_get_parent(dev);
 197         sc = device_get_softc(dev);
 198
 199         dprintf("%s: offset 0x%llx count %lld bytes\n", __func__, offset, count);
 200
 201         err = QSPI_ERASE(pdev, dev, offset);
 202         if (err != 0) {
 203                 return (err);
 204         }
 205
 206         err = QSPI_WRITE(pdev, dev, bp, offset, data, count);
 207
 208         return (err);
 209 }
 210
 211 static int
 212 n25q_read(device_t dev, struct bio *bp, off_t offset, caddr_t data, off_t count)
 213 {
 214         struct n25q_softc *sc;
 215         device_t pdev;
 216         int err;
 217
 218         pdev = device_get_parent(dev);
 219         sc = device_get_softc(dev);
 220
 221         dprintf("%s: offset 0x%llx count %lld bytes\n", __func__, offset, count);
 222
 223         /*
 224          * Enforce the disk read sectorsize not the erase sectorsize.
 225          * In this way, smaller read IO is possible,dramatically
 226          * speeding up filesystem/geom_compress access.
 227          */
 228         if (count % sc->sc_disk->d_sectorsize != 0
 229             || offset % sc->sc_disk->d_sectorsize != 0) {
 230                 printf("EIO\n");
 231                 return (EIO);
 232         }
 233
 234         err = QSPI_READ(pdev, dev, bp, offset, data, count);
 235
 236         return (err);
 237 }
 238
 239 static int
 240 n25q_set_4b_mode(device_t dev, uint8_t command)
 241 {
 242         struct n25q_softc *sc;
 243         device_t pdev;
 244         int err;
 245
 246         pdev = device_get_parent(dev);
 247         sc = device_get_softc(dev);
 248
 249         err = QSPI_WRITE_REG(pdev, dev, command, 0, 0);
 250
 251         return (err);
 252 }
 253
 254 static int
 255 n25q_probe(device_t dev)
 256 {
 257         int i;
 258
 259         if (!ofw_bus_status_okay(dev))
 260                 return (ENXIO);
 261
 262         /* First try to match the compatible property to the compat_data */
 263         if (ofw_bus_search_compatible(dev, compat_data)->ocd_data == 1)
 264                 goto found;
 265
 266         /*
 267          * Next, try to find a compatible device using the names in the
 268          * flash_devices structure
 269          */
 270         for (i = 0; i < nitems(flash_devices); i++)
 271                 if (ofw_bus_is_compatible(dev, flash_devices[i].name))
 272                         goto found;
 273
 274         return (ENXIO);
 275 found:
 276         device_set_desc(dev, "Micron n25q");
 277
 278         return (0);
 279 }
 280
 281 static int
 282 n25q_attach(device_t dev)
 283 {
 284         struct n25q_flash_ident *ident;
 285         struct n25q_softc *sc;
 286
 287         sc = device_get_softc(dev);
 288         sc->dev = dev;
 289
 290         N25Q_LOCK_INIT(sc);
 291
 292         ident = n25q_get_device_ident(sc);
 293         if (ident == NULL) {
 294                 return (ENXIO);
 295         }
 296
 297         n25q_wait_for_device_ready(sc->dev);
 298
 299         sc->sc_disk = disk_alloc();
 300         sc->sc_disk->d_open = n25q_open;
 301         sc->sc_disk->d_close = n25q_close;
 302         sc->sc_disk->d_strategy = n25q_strategy;
 303         sc->sc_disk->d_getattr = n25q_getattr;
 304         sc->sc_disk->d_ioctl = n25q_ioctl;
 305         sc->sc_disk->d_name = "flash/qspi";
 306         sc->sc_disk->d_drv1 = sc;
 307         sc->sc_disk->d_maxsize = DFLTPHYS;
 308         sc->sc_disk->d_sectorsize = FLASH_SECTORSIZE;
 309         sc->sc_disk->d_mediasize = (ident->sectorsize * ident->sectorcount);
 310         sc->sc_disk->d_unit = device_get_unit(sc->dev);
 311         sc->sc_disk->d_dump = NULL;
 312         /* Sectorsize for erase operations */
 313         sc->sc_sectorsize =  ident->sectorsize;
 314         sc->sc_flags = ident->flags;
 315
 316         if (sc->sc_flags & FL_ENABLE_4B_ADDR)
 317                 n25q_set_4b_mode(dev, CMD_ENTER_4B_MODE);
 318
 319         if (sc->sc_flags & FL_DISABLE_4B_ADDR)
 320                 n25q_set_4b_mode(dev, CMD_EXIT_4B_MODE);
 321
 322         /* NB: use stripesize to hold the erase/region size for RedBoot */
 323         sc->sc_disk->d_stripesize = ident->sectorsize;
 324
 325         disk_create(sc->sc_disk, DISK_VERSION);
 326         bioq_init(&sc->sc_bio_queue);
 327
 328         kproc_create(&n25q_task, sc, &sc->sc_p, 0, 0, "task: n25q flash");
 329         sc->sc_taskstate = TSTATE_RUNNING;
 330
 331         device_printf(sc->dev, "%s, sector %d bytes, %d sectors\n",
 332             ident->name, ident->sectorsize, ident->sectorcount);
 333
 334         return (0);
 335 }
 336
 337 static int
 338 n25q_detach(device_t dev)
 339 {
 340         struct n25q_softc *sc;
 341         int err;
 342
 343         sc = device_get_softc(dev);
 344         err = 0;
 345
 346         N25Q_LOCK(sc);
 347         if (sc->sc_taskstate == TSTATE_RUNNING) {
 348                 sc->sc_taskstate = TSTATE_STOPPING;
 349                 wakeup(sc);
 350                 while (err == 0 && sc->sc_taskstate != TSTATE_STOPPED) {
 351                         err = msleep(sc, &sc->sc_mtx, 0, "n25q", hz * 3);
 352                         if (err != 0) {
 353                                 sc->sc_taskstate = TSTATE_RUNNING;
 354                                 device_printf(sc->dev,
 355                                     "Failed to stop queue task\n");
 356                         }
 357                 }
 358         }
 359         N25Q_UNLOCK(sc);
 360
 361         if (err == 0 && sc->sc_taskstate == TSTATE_STOPPED) {
 362                 disk_destroy(sc->sc_disk);
 363                 bioq_flush(&sc->sc_bio_queue, NULL, ENXIO);
 364                 N25Q_LOCK_DESTROY(sc);
 365         }
 366         return (err);
 367 }
 368
 369 static int
 370 n25q_open(struct disk *dp)
 371 {
 372
 373         return (0);
 374 }
 375
 376 static int
 377 n25q_close(struct disk *dp)
 378 {
 379
 380         return (0);
 381 }
 382
 383 static int
 384 n25q_ioctl(struct disk *dp, u_long cmd, void *data,
 385     int fflag, struct thread *td)
 386 {
 387
 388         return (EINVAL);
 389 }
 390
 391 static void
 392 n25q_strategy(struct bio *bp)
 393 {
 394         struct n25q_softc *sc;
 395
 396         sc = (struct n25q_softc *)bp->bio_disk->d_drv1;
 397
 398         N25Q_LOCK(sc);
 399         bioq_disksort(&sc->sc_bio_queue, bp);
 400         wakeup(sc);
 401         N25Q_UNLOCK(sc);
 402 }
 403
 404 static int
 405 n25q_getattr(struct bio *bp)
 406 {
 407         struct n25q_softc *sc;
 408         device_t dev;
 409
 410         if (bp->bio_disk == NULL || bp->bio_disk->d_drv1 == NULL) {
 411                 return (ENXIO);
 412         }
 413
 414         sc = bp->bio_disk->d_drv1;
 415         dev = sc->dev;
 416
 417         if (strcmp(bp->bio_attribute, "SPI::device") == 0) {
 418                 if (bp->bio_length != sizeof(dev)) {
 419                         return (EFAULT);
 420                 }
 421                 bcopy(&dev, bp->bio_data, sizeof(dev));
 422                 return (0);
 423         }
 424
 425         return (-1);
 426 }
 427
 428 static void
 429 n25q_task(void *arg)
 430 {
 431         struct n25q_softc *sc;
 432         struct bio *bp;
 433         device_t dev;
 434
 435         sc = (struct n25q_softc *)arg;
 436
 437         dev = sc->dev;
 438
 439         for (;;) {
 440                 N25Q_LOCK(sc);
 441                 do {
 442                         if (sc->sc_taskstate == TSTATE_STOPPING) {
 443                                 sc->sc_taskstate = TSTATE_STOPPED;
 444                                 N25Q_UNLOCK(sc);
 445                                 wakeup(sc);
 446                                 kproc_exit(0);
 447                         }
 448                         bp = bioq_first(&sc->sc_bio_queue);
 449                         if (bp == NULL)
 450                                 msleep(sc, &sc->sc_mtx, PRIBIO, "jobqueue", hz);
 451                 } while (bp == NULL);
 452                 bioq_remove(&sc->sc_bio_queue, bp);
 453                 N25Q_UNLOCK(sc);
 454
 455                 switch (bp->bio_cmd) {
 456                 case BIO_READ:
 457                         bp->bio_error = n25q_read(dev, bp, bp->bio_offset,
 458                             bp->bio_data, bp->bio_bcount);
 459                         break;
 460                 case BIO_WRITE:
 461                         bp->bio_error = n25q_write(dev, bp, bp->bio_offset,
 462                             bp->bio_data, bp->bio_bcount);
 463                         break;
 464                 default:
 465                         bp->bio_error = EOPNOTSUPP;
 466                 }
 467
 468                 biodone(bp);
 469         }
 470 }
 471
 472 static devclass_t n25q_devclass;
 473
 474 static device_method_t n25q_methods[] = {
 475         /* Device interface */
 476         DEVMETHOD(device_probe,         n25q_probe),
 477         DEVMETHOD(device_attach,        n25q_attach),
 478         DEVMETHOD(device_detach,        n25q_detach),
 479
 480         { 0, 0 }
 481 };
 482
 483 static driver_t n25q_driver = {
 484         "n25q",
 485         n25q_methods,
 486         sizeof(struct n25q_softc),
 487 };
 488
 489 DRIVER_MODULE(n25q, simplebus, n25q_driver, n25q_devclass, 0, 0);