sys/mips/broadcom/bcm_nvram_cfe.c

   1 /*-
   2  * Copyright (c) 2016 Landon Fuller <landonf@FreeBSD.org>
   3  * Copyright (c) 2017 The FreeBSD Foundation
   4  * All rights reserved.
   5  *
   6  * Portions of this software were developed by Landon Fuller
   7  * under sponsorship from the FreeBSD Foundation.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer,
  14  *    without modification.
  15  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  16  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  17  *    redistribution must be conditioned upon including a substantially
  18  *    similar Disclaimer requirement for further binary redistribution.
  19  *
  20  * NO WARRANTY
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  24  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  25  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  26  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  29  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  31  * THE POSSIBILITY OF SUCH DAMAGES.
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD$");
  36
  37 /*
  38  * BHND CFE NVRAM driver.
  39  *
  40  * Provides access to device NVRAM via CFE.
  41  */
  42
  43 #include <sys/param.h>
  44 #include <sys/kernel.h>
  45 #include <sys/bus.h>
  46 #include <sys/limits.h>
  47 #include <sys/malloc.h>
  48 #include <sys/module.h>
  49 #include <sys/systm.h>
  50
  51 #include <machine/bus.h>
  52 #include <sys/rman.h>
  53 #include <machine/resource.h>
  54
  55 #include <dev/bhnd/bhnd.h>
  56
  57 #include <dev/cfe/cfe_api.h>
  58 #include <dev/cfe/cfe_error.h>
  59 #include <dev/cfe/cfe_ioctl.h>
  60
  61 #include "bhnd_nvram_if.h"
  62
  63 #include "bcm_machdep.h"
  64 #include "bcm_nvram_cfevar.h"
  65
  66 BHND_NVRAM_IOPS_DEFN(iocfe)
  67
  68 #define IOCFE_LOG(_io, _fmt, ...)       \
  69         printf("%s/%s: " _fmt, __FUNCTION__, (_io)->dname, ##__VA_ARGS__)
  70
  71 static int      bcm_nvram_iocfe_init(struct bcm_nvram_iocfe *iocfe,
  72                     char *dname);
  73
  74 /** Known CFE NVRAM device names, in probe order. */
  75 static char *nvram_cfe_devs[] = {
  76         "nflash0.nvram",        /* NAND */
  77         "nflash1.nvram",
  78         "flash0.nvram",
  79         "flash1.nvram",
  80 };
  81
  82 /** Supported CFE NVRAM formats, in probe order. */
  83 static bhnd_nvram_data_class * const nvram_cfe_fmts[] = {
  84         &bhnd_nvram_bcm_class,
  85         &bhnd_nvram_tlv_class
  86 };
  87
  88 static int
  89 bhnd_nvram_cfe_probe(device_t dev)
  90 {
  91         struct bcm_platform *bp;
  92
  93         /* Fetch platform NVRAM I/O context */
  94         bp = bcm_get_platform();
  95         if (bp->nvram_io == NULL)
  96                 return (ENXIO);
  97
  98         KASSERT(bp->nvram_cls != NULL, ("missing NVRAM class"));
  99
 100         /* Set the device description */
 101         device_set_desc(dev, bhnd_nvram_data_class_desc(bp->nvram_cls));
 102
 103         /* Refuse wildcard attachments */
 104         return (BUS_PROBE_NOWILDCARD);
 105 }
 106
 107
 108 static int
 109 bhnd_nvram_cfe_attach(device_t dev)
 110 {
 111         struct bcm_platform             *bp;
 112         struct bhnd_nvram_cfe_softc     *sc;
 113         int                              error;
 114
 115         bp = bcm_get_platform();
 116         KASSERT(bp->nvram_io != NULL, ("missing NVRAM I/O context"));
 117         KASSERT(bp->nvram_cls != NULL, ("missing NVRAM class"));
 118
 119         sc = device_get_softc(dev);
 120         sc->dev = dev;
 121
 122         error = bhnd_nvram_store_parse_new(&sc->store, bp->nvram_io,
 123             bp->nvram_cls);
 124         if (error)
 125                 return (error);
 126
 127         error = bhnd_service_registry_add(&bp->services, dev,
 128             BHND_SERVICE_NVRAM, 0);
 129         if (error) {
 130                 bhnd_nvram_store_free(sc->store);
 131                 return (error);
 132         }
 133
 134         return (error);
 135 }
 136
 137 static int
 138 bhnd_nvram_cfe_resume(device_t dev)
 139 {
 140         return (0);
 141 }
 142
 143 static int
 144 bhnd_nvram_cfe_suspend(device_t dev)
 145 {
 146         return (0);
 147 }
 148
 149 static int
 150 bhnd_nvram_cfe_detach(device_t dev)
 151 {
 152         struct bcm_platform             *bp;
 153         struct bhnd_nvram_cfe_softc     *sc;
 154         int                              error;
 155
 156         bp = bcm_get_platform();
 157         sc = device_get_softc(dev);
 158
 159         error = bhnd_service_registry_remove(&bp->services, dev,
 160             BHND_SERVICE_ANY);
 161         if (error)
 162                 return (error);
 163
 164         bhnd_nvram_store_free(sc->store);
 165
 166         return (0);
 167 }
 168
 169 static int
 170 bhnd_nvram_cfe_getvar(device_t dev, const char *name, void *buf, size_t *len,
 171     bhnd_nvram_type type)
 172 {
 173         struct bhnd_nvram_cfe_softc *sc = device_get_softc(dev);
 174
 175         return (bhnd_nvram_store_getvar(sc->store, name, buf, len, type));
 176 }
 177
 178 static int
 179 bhnd_nvram_cfe_setvar(device_t dev, const char *name, const void *buf,
 180     size_t len, bhnd_nvram_type type)
 181 {
 182         struct bhnd_nvram_cfe_softc *sc = device_get_softc(dev);
 183
 184         return (bhnd_nvram_store_setvar(sc->store, name, buf, len, type));
 185 }
 186
 187 /**
 188  * Find, open, identify, and initialize an I/O context mapping the CFE NVRAM
 189  * device.
 190  *
 191  * @param[out]  iocfe           On success, an I/O context mapping the CFE NVRAM
 192  *                              device.
 193  * @param[out]  cls             On success, the identified NVRAM data format
 194  *                              class.
 195  *
 196  * @retval 0            success. the caller inherits ownership of @p iocfe.
 197  * @retval non-zero     if no usable CFE NVRAM device can be found, a standard
 198  *                      unix error will be returned.
 199  */
 200 int
 201 bcm_nvram_find_cfedev(struct bcm_nvram_iocfe *iocfe,
 202     bhnd_nvram_data_class **cls)
 203 {
 204         char    *dname;
 205         int      devinfo;
 206         int      error, result;
 207
 208         for (u_int i = 0; i < nitems(nvram_cfe_fmts); i++) {
 209                 *cls = nvram_cfe_fmts[i];
 210
 211                 for (u_int j = 0; j < nitems(nvram_cfe_devs); j++) {
 212                         dname = nvram_cfe_devs[j];
 213
 214                         /* Does the device exist? */
 215                         if ((devinfo = cfe_getdevinfo(dname)) < 0) {
 216                                 if (devinfo != CFE_ERR_DEVNOTFOUND) {
 217                                         BCM_ERR("cfe_getdevinfo(%s) failed: "
 218                                             "%d\n", dname, devinfo);
 219                                 }
 220
 221                                 continue;
 222                         }
 223
 224                         /* Open for reading */
 225                         if ((error = bcm_nvram_iocfe_init(iocfe, dname)))
 226                                 continue;
 227
 228                         /* Probe */
 229                         result = bhnd_nvram_data_probe(*cls, &iocfe->io);
 230                         if (result <= 0) {
 231                                 /* Found a supporting NVRAM data class */
 232                                 return (0);
 233                         }
 234
 235                         /* Keep searching */
 236                         bhnd_nvram_io_free(&iocfe->io);
 237                 }
 238         }
 239
 240         return (ENODEV);
 241 }
 242
 243
 244 /**
 245  * Initialize a new CFE device-backed I/O context.
 246  *
 247  * The caller is responsible for releasing all resources held by the returned
 248  * I/O context via bhnd_nvram_io_free().
 249  *
 250  * @param[out]  io      On success, will be initialized as an I/O context for
 251  *                      CFE device @p dname.
 252  * @param       dname   The name of the CFE device to be opened for reading.
 253  *
 254  * @retval 0            success.
 255  * @retval non-zero     if opening @p dname otherwise fails, a standard unix
 256  *                      error will be returned.
 257  */
 258 static int
 259 bcm_nvram_iocfe_init(struct bcm_nvram_iocfe *iocfe, char *dname)
 260 {
 261         nvram_info_t             nvram_info;
 262         int                      cerr, devinfo, dtype, rlen;
 263         int64_t                  nv_offset;
 264         u_int                    nv_size;
 265         bool                     req_blk_erase;
 266         int                      error;
 267
 268         iocfe->io.iops = &bhnd_nvram_iocfe_ops;
 269         iocfe->dname = dname;
 270
 271         /* Try to open the device */
 272         iocfe->fd = cfe_open(dname);
 273         if (iocfe->fd <= 0) {
 274                 IOCFE_LOG(iocfe, "cfe_open() failed: %d\n", iocfe->fd);
 275
 276                 return (ENXIO);
 277         }
 278
 279         /* Try to fetch device info */
 280         if ((devinfo = cfe_getdevinfo(iocfe->dname)) < 0) {
 281                 IOCFE_LOG(iocfe, "cfe_getdevinfo() failed: %d\n", devinfo);
 282                 error = ENXIO;
 283                 goto failed;
 284         }
 285
 286         /* Verify device type */
 287         dtype = devinfo & CFE_DEV_MASK;
 288         switch (dtype) {
 289         case CFE_DEV_FLASH:
 290         case CFE_DEV_NVRAM:
 291                 /* Valid device type */
 292                 break;
 293         default:
 294                 IOCFE_LOG(iocfe, "unknown device type: %d\n", dtype);
 295                 error = ENXIO;
 296                 goto failed;
 297         }
 298
 299         /* Try to fetch nvram info from CFE */
 300         cerr = cfe_ioctl(iocfe->fd, IOCTL_NVRAM_GETINFO,
 301             (unsigned char *)&nvram_info, sizeof(nvram_info), &rlen, 0);
 302         if (cerr == CFE_OK) {
 303                 /* Sanity check the result; must not be a negative integer */
 304                 if (nvram_info.nvram_size < 0 ||
 305                     nvram_info.nvram_offset < 0)
 306                 {
 307                         IOCFE_LOG(iocfe, "invalid NVRAM layout (%d/%d)\n",
 308                             nvram_info.nvram_size, nvram_info.nvram_offset);
 309                         error = ENXIO;
 310                         goto failed;
 311                 }
 312
 313                 nv_offset       = nvram_info.nvram_offset;
 314                 nv_size         = nvram_info.nvram_size;
 315                 req_blk_erase   = (nvram_info.nvram_eraseflg != 0);
 316         } else if (cerr != CFE_OK && cerr != CFE_ERR_INV_COMMAND) {
 317                 IOCFE_LOG(iocfe, "IOCTL_NVRAM_GETINFO failed: %d\n", cerr);
 318                 error = ENXIO;
 319                 goto failed;
 320         }
 321
 322         /* Fall back on flash info.
 323          *
 324          * This is known to be required on the Asus RT-N53 (CFE 5.70.55.33,
 325          * BBP 1.0.37, BCM5358UB0), where IOCTL_NVRAM_GETINFO returns
 326          * CFE_ERR_INV_COMMAND.
 327          */
 328         if (cerr == CFE_ERR_INV_COMMAND) {
 329                 flash_info_t fi;
 330
 331                 cerr = cfe_ioctl(iocfe->fd, IOCTL_FLASH_GETINFO,
 332                     (unsigned char *)&fi, sizeof(fi), &rlen, 0);
 333
 334                 if (cerr != CFE_OK) {
 335                         IOCFE_LOG(iocfe, "IOCTL_FLASH_GETINFO failed %d\n",
 336                             cerr);
 337                         error = ENXIO;
 338                         goto failed;
 339                 }
 340
 341                 nv_offset       = 0x0;
 342                 nv_size         = fi.flash_size;
 343                 req_blk_erase   = !(fi.flash_flags & FLASH_FLAG_NOERASE);
 344         }
 345
 346
 347         /* Verify that the full NVRAM layout can be represented via size_t */
 348         if (nv_size > SIZE_MAX || SIZE_MAX - nv_size < nv_offset) {
 349                 IOCFE_LOG(iocfe, "invalid NVRAM layout (%#x/%#jx)\n",
 350                     nv_size, (intmax_t)nv_offset);
 351                 error = ENXIO;
 352                 goto failed;
 353         }
 354
 355         iocfe->offset = nv_offset;
 356         iocfe->size = nv_size;
 357         iocfe->req_blk_erase = req_blk_erase;
 358
 359         return (CFE_OK);
 360
 361 failed:
 362         if (iocfe->fd >= 0)
 363                 cfe_close(iocfe->fd);
 364
 365         return (error);
 366 }
 367
 368 static void
 369 bhnd_nvram_iocfe_free(struct bhnd_nvram_io *io)
 370 {
 371         struct bcm_nvram_iocfe  *iocfe = (struct bcm_nvram_iocfe *)io;
 372
 373         /* CFE I/O instances are statically allocated; we do not need to free
 374          * the instance itself */
 375         cfe_close(iocfe->fd);
 376 }
 377
 378 static size_t
 379 bhnd_nvram_iocfe_getsize(struct bhnd_nvram_io *io)
 380 {
 381         struct bcm_nvram_iocfe  *iocfe = (struct bcm_nvram_iocfe *)io;
 382         return (iocfe->size);
 383 }
 384
 385 static int
 386 bhnd_nvram_iocfe_setsize(struct bhnd_nvram_io *io, size_t size)
 387 {
 388         /* unsupported */
 389         return (ENODEV);
 390 }
 391
 392 static int
 393 bhnd_nvram_iocfe_read_ptr(struct bhnd_nvram_io *io, size_t offset,
 394     const void **ptr, size_t nbytes, size_t *navail)
 395 {
 396         /* unsupported */
 397         return (ENODEV);
 398 }
 399
 400 static int
 401 bhnd_nvram_iocfe_write_ptr(struct bhnd_nvram_io *io, size_t offset,
 402     void **ptr, size_t nbytes, size_t *navail)
 403 {
 404         /* unsupported */
 405         return (ENODEV);
 406 }
 407
 408 static int
 409 bhnd_nvram_iocfe_write(struct bhnd_nvram_io *io, size_t offset, void *buffer,
 410     size_t nbytes)
 411 {
 412         /* unsupported */
 413         return (ENODEV);
 414 }
 415
 416 static int
 417 bhnd_nvram_iocfe_read(struct bhnd_nvram_io *io, size_t offset, void *buffer,
 418     size_t nbytes)
 419 {
 420         struct bcm_nvram_iocfe  *iocfe;
 421         size_t                   remain;
 422         int64_t                  cfe_offset;
 423         int                      nr, nreq;
 424
 425         iocfe = (struct bcm_nvram_iocfe *)io;
 426
 427         /* Determine (and validate) the base CFE offset */
 428 #if (SIZE_MAX > INT64_MAX)
 429         if (iocfe->offset > INT64_MAX || offset > INT64_MAX)
 430                 return (ENXIO);
 431 #endif
 432
 433         if (INT64_MAX - offset < iocfe->offset)
 434                 return (ENXIO);
 435
 436         cfe_offset = iocfe->offset + offset;
 437
 438         /* Verify that cfe_offset + nbytes is representable */
 439         if (INT64_MAX - cfe_offset < nbytes)
 440                 return (ENXIO);
 441
 442         /* Perform the read */
 443         for (remain = nbytes; remain > 0;) {
 444                 void    *p;
 445                 size_t   nread;
 446                 int64_t  cfe_noff;
 447
 448                 nread = (nbytes - remain);
 449                 cfe_noff = cfe_offset + nread;
 450                 p = ((uint8_t *)buffer + nread);
 451                 nreq = ummin(INT_MAX, remain);
 452
 453                 nr = cfe_readblk(iocfe->fd, cfe_noff, p, nreq);
 454                 if (nr < 0) {
 455                         IOCFE_LOG(iocfe, "cfe_readblk() failed: %d\n", nr);
 456                         return (ENXIO);
 457                 }
 458
 459                 /* Check for unexpected short read */
 460                 if (nr == 0 && remain > 0) {
 461                         /* If the request fits entirely within the CFE
 462                          * device range, we shouldn't hit EOF */
 463                         if (remain < iocfe->size &&
 464                             iocfe->size - remain > offset)
 465                         {
 466                                 IOCFE_LOG(iocfe, "cfe_readblk() returned "
 467                                     "unexpected short read (%d/%d)\n", nr,
 468                                     nreq);
 469                                 return (ENXIO);
 470                         }
 471                 }
 472
 473                 if (nr == 0)
 474                         break;
 475
 476                 remain -= nr;
 477         }
 478
 479         /* Check for short read */
 480         if (remain > 0)
 481                 return (ENXIO);
 482
 483         return (0);
 484 }
 485
 486 static device_method_t bhnd_nvram_cfe_methods[] = {
 487         /* Device interface */
 488         DEVMETHOD(device_probe,         bhnd_nvram_cfe_probe),
 489         DEVMETHOD(device_attach,        bhnd_nvram_cfe_attach),
 490         DEVMETHOD(device_resume,        bhnd_nvram_cfe_resume),
 491         DEVMETHOD(device_suspend,       bhnd_nvram_cfe_suspend),
 492         DEVMETHOD(device_detach,        bhnd_nvram_cfe_detach),
 493
 494         /* NVRAM interface */
 495         DEVMETHOD(bhnd_nvram_getvar,    bhnd_nvram_cfe_getvar),
 496         DEVMETHOD(bhnd_nvram_setvar,    bhnd_nvram_cfe_setvar),
 497
 498         DEVMETHOD_END
 499 };
 500
 501 DEFINE_CLASS_0(bhnd_nvram, bhnd_nvram_cfe, bhnd_nvram_cfe_methods,
 502     sizeof(struct bhnd_nvram_cfe_softc));
 503 EARLY_DRIVER_MODULE(bhnd_nvram_cfe, nexus, bhnd_nvram_cfe,
 504     bhnd_nvram_devclass, NULL, NULL, BUS_PASS_BUS + BUS_PASS_ORDER_EARLY);