nuttx/configs/ea3131/src/up_fillpage.c

/****************************************************************************
 * configs/ea3131/src/up_fillpage.c
 * arch/arm/src/board/up_fillpage.c
 *
 *   Copyright (C) 2010 Gregory Nutt. All rights reserved.
 *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name NuttX nor the names of its contributors may be
 *    used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 ****************************************************************************/

/****************************************************************************
 * Included Files
 ****************************************************************************/

#include <nuttx/config.h>

#include <errno.h>
#include <debug.h>

#include <nuttx/sched.h>
#include <nuttx/page.h>

#ifdef CONFIG_PAGING
#ifdef CONFIG_PAGING_BINPATH
#  include <sys/stat.h>
#  include <sys/types.h>
#  include <stdbool.h>
#  include <unistd.h>
#  include <fcntl.h>
#  ifdef CONFIG_PAGING_SDSLOT
#    include <stdio.h>
#    include <sys/mount.h>
#    include <nuttx/sdio.h>
#    include <nuttx/mmcsd.h>
#    include "lpc313x_internal.h"
#  endif
#endif

#ifdef CONFIG_PAGING_M25PX
#  include <sys/ioctl.h>
#  include <nuttx/ioctl.h>
#  include <nuttx/spi.h>
#  include <nuttx/mtd.h>
#endif

/****************************************************************************
 * Definitions
 ****************************************************************************/

/* Configuration ************************************************************/

/* SD SLOT number might depend on the board configuration */

#ifdef CONFIG_ARCH_BOARD_EA3131
#  define HAVE_SD     1
#  define HAVE_SPINOR 1
#  if defined(CONFIG_PAGING_SDSLOT) && CONFIG_PAGING_SDSLOT != 0
#    error "Only one SD slot"
#    undef CONFIG_PAGING_SDSLOT
#  endif
#else
   /* Add configuration for new LPC313X boards here */
#  error "Unrecognized LPC313X board"
#  undef CONFIG_PAGING_SDSLOT
#  undef HAVE_SD
#  undef HAVE_SPINOR
#endif

/* Sanity check:  We can only perform paging using a single source device */

#if defined(CONFIG_PAGING_BINPATH) && defined(CONFIG_PAGING_M25PX)
#  error "Both CONFIG_PAGING_BINPATH and CONFIG_PAGING_M25PX are defined"
#  undef CONFIG_PAGING_BINPATH 
#endif

/* Are we accessing the page source data through a file path? */

#ifdef CONFIG_PAGING_BINPATH

   /* Can't support SD if the board does not support SD (duh) */

#  if defined(CONFIG_PAGING_SDSLOT) && !defined(HAVE_SD)
#    error "This board does not support SD"
#    undef CONFIG_PAGING_SDSLOT
#  endif

   /* Can't support SD if mountpoints are disabled or if SDIO support
    * is not enabled.
    */

#  if defined(CONFIG_DISABLE_MOUNTPOINT) || !defined(CONFIG_LPC313X_MCI)
#    ifdef CONFIG_PAGING_SDSLOT
#      error "Mountpoints and/or MCI disabled"
#    endif
#    undef CONFIG_PAGING_SDSLOT
#    undef HAVE_SD
#  endif

   /* A mountpoint for the FAT file system must be provided */

#  if !defined(CONFIG_PAGING_MOUNTPT) && defined(CONFIG_PAGING_SDSLOT)
#    error "No CONFIG_PAGING_MOUNTPT provided"
#    undef CONFIG_PAGING_SDSLOT
#    undef HAVE_SD
#  endif

   /* If no minor number is provided, default to zero */

#  ifndef CONFIG_PAGING_MINOR
#    define CONFIG_PAGING_MINOR 0
#  endif

#endif /* CONFIG_PAGING_BINPATH */

/* Are we accessing the page source data through the M25P* MTD device? */

#ifdef CONFIG_PAGING_M25PX

   /* Verify that SPI support is enabld */

#ifndef CONFIG_LPC313X_SPI
#  error "SPI support is not enabled"
#endif

   /* Make sure that some value is defined for the offset into the FLASH
    * of the NuttX binary image.
    */

#  ifndef CONFIG_PAGING_M25PX_BINOFFSET
#    define CONFIG_PAGING_M25PX_BINOFFSET 0
#  endif

   /* Make sure that some value is defined for the SPI port number */

#  ifndef CONFIG_PAGING_M25PX_SPIPORT
#    define CONFIG_PAGING_M25PX_SPIPORT 0
#  endif
#endif

/****************************************************************************
 * Private Types
 ****************************************************************************/

/* State structure needed to support paging from a file */

#ifdef CONFIG_PAGING_BINPATH
struct pg_source_s
{
  bool initialized;  /* TRUE: we are initialized */
  int  fd;           /* File descriptor of the nuttx.bin file */
};
#endif

/* State structured needd to support paging through the M25P* MTD interface. */

#ifdef CONFIG_PAGING_M25PX
struct pg_source_s
{
  /* If interrupts or DMA are used, then we will have to defer initialization */

#if defined(CONFIG_LPC313x_SPI_INTERRUPTS) || defined(CONFIG_LPC313x_SPI_DMA)
  bool initialized;  /* TRUE: we are initialized */
#endif

  /* This is the M25P* device state structure */

  FAR struct mtd_dev_s *mtd;

  /* This the the device geometry */

#ifdef CONFIG_DEBUG
  FAR struct mtd_geometry_s geo;
#endif
};
#endif

/****************************************************************************
 * Private Data
 ****************************************************************************/

#if defined(CONFIG_PAGING_BINPATH) || defined(CONFIG_PAGING_M25PX)
static struct pg_source_s g_pgsrc;
#endif

/****************************************************************************
 * Private Functions
 ****************************************************************************/

/****************************************************************************
 * Name: lpc313x_initsrc()
 *
 * Description:
 *  Initialize the source device that will support paging.
 *  If BINPATH is defined, then it is the full path to a file on a mounted file
 *  system.  In this case initialization will be deferred until the first
 *  time that up_fillpage() is called.
 *
 ****************************************************************************/

#if defined(CONFIG_PAGING_BINPATH)
static inline void lpc313x_initsrc(void)
{
#ifdef CONFIG_PAGING_SDSLOT
  FAR struct sdio_dev_s *sdio;
  int ret;
#endif

  /* Are we already initialized? */

  if (!g_pgsrc.initialized)
    {
#ifdef CONFIG_PAGING_SDSLOT
      char devname[16];
#endif

      pgvdbg("Initializing %s\n", CONFIG_PAGING_BINPATH);

      /* No, do we need to mount an SD device? */

#ifdef CONFIG_PAGING_SDSLOT

      /* Yes.. First, get an instance of the SDIO interface */

      sdio = sdio_initialize(CONFIG_PAGING_SDSLOT);
      DEBUGASSERT(sdio != NULL);

      /* Then bind the SDIO interface to the SD driver */

      ret = mmcsd_slotinitialize(CONFIG_PAGING_MINOR, sdio);
      DEBUGASSERT(ret == OK);
  
      /* Then let's guess and say that there is a card in the slot.
       * (We are basically jodido anyway if there is no card in the slot).
       */

      sdio_mediachange(sdio, true);

      /* Now mount the file system */

      snprintf(devname, 16, "/dev/mmcsd%d", CONFIG_PAGING_MINOR);
      ret = mount(devname, CONFIG_PAGING_MOUNTPT, "vfat", MS_RDONLY, NULL);
      DEBUGASSERT(ret == OK);

#endif /* CONFIG_PAGING_SDSLOT */

      /* Open the selected path for read-only access */

      g_pgsrc.fd = open(CONFIG_PAGING_BINPATH, O_RDONLY);
      DEBUGASSERT(g_pgsrc.fd >= 0);
      g_pgsrc.initialized = true;
    }
}

#elif defined(CONFIG_PAGING_M25PX)
static inline void lpc313x_initsrc(void)
{
#ifdef CONFIG_DEBUG
  uint32_t capacity;
  int ret;
#endif

  /* Are we already initialized? */

#if defined(CONFIG_LPC313x_SPI_INTERRUPTS) || defined(CONFIG_LPC313x_SPI_DMA)
  if (!g_pgsrc.initialized)
#endif
    {
      pgvdbg("Initializing\n");

      /* First get an instance of the SPI device interface */

      FAR struct spi_dev_s *spi = up_spiinitialize(CONFIG_PAGING_M25PX_SPIPORT);
      DEBUGASSERT(spi != NULL);

      /* Then bind the SPI interface to the M25Px MTD driver */

      g_pgsrc.mtd = m25p_initialize(spi);
      DEBUGASSERT(g_pgsrc.mtd != NULL);

      /* Verify that we can use the device */

#ifdef CONFIG_DEBUG
      /* Get the device geometry. (casting to uintptr_t first eliminates
       * complaints on some architectures where the sizeof long is different
       * from the size of a pointer).
       */

      ret = MTD_IOCTL(g_pgsrc.mtd, MTDIOC_GEOMETRY, (unsigned long)&g_pgsrc.geo);
      DEBUGASSERT(ret >= 0);
      capacity = g_pgsrc.geo.erasesize*g_pgsrc.geo.neraseblocks;
      pgllvdbg("capacity: %d\n", capacity);
      DEBUGASSERT(capacity >= (CONFIG_PAGING_M25PX_BINOFFSET + PG_TEXT_VSIZE));
#endif

#if defined(CONFIG_LPC313x_SPI_INTERRUPTS) || defined(CONFIG_LPC313x_SPI_DMA)
      g_pgsrc.initialized = true;
#endif
    }
}

#else
#  define lpc313x_initsrc()
#endif

/****************************************************************************
 * Public Functions
 ****************************************************************************/

/****************************************************************************
 * Name: up_fillpage()
 *
 * Description:
 *  After a page is allocated and mapped by up_allocpage(), the actual
 *  filling of the page with data from the non-volatile, must be performed
 *  by a separate call to the architecture-specific function, up_fillpage().
 *  This function is non-blocking, it will start an asynchronous page fill.
 *  The common paging logic will provide a callback function, pg_callback,
 *  that will be called when the page fill is finished (or an error occurs).
 *  This callback is assumed to occur from an interrupt level when the
 *  device driver completes the fill operation.
 *
 *  NOTE 1: Allocating and filling a page is a two step process.  up_allocpage()
 *  allocates the page, and up_fillpage() fills it with data from some non-
 *  volatile storage device.  This distinction is made because up_allocpage()
 *  can probably be implemented in board-independent logic whereas up_fillpage()
 *  probably must be implemented as board-specific logic.
 *
 *  NOTE 2: The initial mapping of vpage will be read-able, write-able,
 *  but non-cacheable.  No special actions will be required of
 *  up_fillpage() in order to write into this allocated page.  If the
 *  virtual address maps to a text region, however, this function should
 *  remap the region so that is is read/execute only.  It should be made
 *  cache-able in any case.

 * Input Parameters:
 *   tcb - A reference to the task control block of the task that needs to
 *         have a page fill.  Architecture-specific logic can retrieve page
 *         fault information from the architecture-specific context
 *         information in this TCB to perform the fill.
 *   pg_callbck - The function to be called when the page fill is complete.
 *
 * Returned Value:
 *   This function will return zero (OK) if the page fill was successfully
 *   started (the result of the page fill is passed to the callback function
 *   as the result argument).  A negated errno value may be returned if an
 *   error occurs.  All errors, however, are fatal.
 *
 *   NOTE: -EBUSY has a special meaning. It is used internally to mean that
 *   the callback function has not executed.  Therefore, -EBUSY should
 *   never be provided in the result argument of pg_callback.
 *
 * Assumptions:
 *   - This function is called from the normal tasking context (but
 *     interrupts siabled).  The implementation must take whatever actions
 *     are necessary to assure that the operation is safe within this context.
 *   - Upon return, the caller will sleep waiting for the page fill callback
 *     to occur.  The callback function will perform the wakeup.
 *
 ****************************************************************************/

#ifdef CONFIG_PAGING_BLOCKINGFILL

/* Version 1:  Supports blocking fill operations */

int up_fillpage(FAR _TCB *tcb, FAR void *vpage)
{
#if defined(CONFIG_PAGING_BINPATH)
  ssize_t nbytes;
  off_t   offset;
  off_t   pos;
#elif defined(CONFIG_PAGING_M25PX)
  ssize_t nbytes;
  off_t   offset;
#endif

  pgdbg("TCB: %p vpage: %p far: %08x\n", tcb, vpage, tcb->xcp.far);
  DEBUGASSERT(tcb->xcp.far >= PG_PAGED_VBASE && tcb->xcp.far < PG_PAGED_VEND);

  /* If BINPATH is defined, then it is the full path to a file on a mounted file
   * system.  In this case initialization will be deferred until the first
   * time that up_fillpage() is called.  Are we initialized?
   */

#if defined(CONFIG_PAGING_BINPATH)

  /* Perform initialization of the paging source device (if necessary and
   * appropriate)
   */

  lpc313x_initsrc();

  /* Create an offset into the binary image that corresponds to the 
   * virtual address.   File offset 0 corresponds to PG_LOCKED_VBASE.
   */

  offset = (off_t)tcb->xcp.far - PG_LOCKED_VBASE;

  /* Seek to that position */

  pos = lseek(g_pgsrc.fd, offset, SEEK_SET);
  DEBUGASSERT(pos != (off_t)-1);
  
  /* And read the page data from that offset */

  nbytes = read(g_pgsrc.fd, vpage, PAGESIZE);
  DEBUGASSERT(nbytes == PAGESIZE);
  return OK;

#elif defined(CONFIG_PAGING_M25PX) /* !CONFIG_PAGING_BINPATH */

  /* If CONFIG_PAGING_M25PX is defined, use the m25px.c FLASH driver.  If this
   * is selected, then the MTD interface to the M25Px device will be used to
   * support paging.
   *
   * If the driver is configured to use interrupts or DMA, then it must be
   * initialized in this context.
   */

#if defined(CONFIG_LPC313x_SPI_INTERRUPTS) || defined(CONFIG_LPC313x_SPI_DMA)
  lpc313x_initsrc();
#endif

  /* Create an offset into the binary image that corresponds to the 
   * virtual address.   File offset 0 corresponds to PG_LOCKED_VBASE.
   */

  offset = (off_t)tcb->xcp.far - PG_LOCKED_VBASE + CONFIG_PAGING_M25PX_BINOFFSET;

  /* Read the page at the correct offset into the SPI FLASH device */

  nbytes = MTD_READ(g_pgsrc.mtd, offset, PAGESIZE, (FAR uint8_t *)vpage);
  DEBUGASSERT(nbytes == PAGESIZE);
  return OK;

#else /* !CONFIG_PAGING_BINPATH && !CONFIG_PAGING_M25PX */

# warning "Not implemented"
  return -ENOSYS;

#endif /* !CONFIG_PAGING_BINPATH && !CONFIG_PAGING_M25PX */
}

#else /* CONFIG_PAGING_BLOCKINGFILL */

/* Version 2:  Supports non-blocking, asynchronous fill operations */

int up_fillpage(FAR _TCB *tcb, FAR void *vpage, up_pgcallback_t pg_callback)
{
  pgdbg("TCB: %p vpage: %d far: %08x\n", tcb, vpage, tcb->xcp.far);
  DEBUGASSERT(tcb->xcp.far >= PG_PAGED_VBASE && tcb->xcp.far < PG_PAGED_VEND);

#if defined(CONFIG_PAGING_BINPATH)
#  error "File system-based paging must always be implemented with blocking calls"
#elif defined(CONFIG_PAGING_M25PX)
#  error "SPI FLASH paging must always be implemented with blocking calls"
#else
#  warning "Not implemented"
#endif

  return -ENOSYS;
}

#endif /* CONFIG_PAGING_BLOCKINGFILL */

/************************************************************************************
 * Name: lpc313x_pginitialize
 *
 * Description:
 *   Set up mass storage device to support on demand paging.
 *
 ************************************************************************************/

void weak_function lpc313x_pginitialize(void)
{
  /* This initialization does nothing in this example setup.  But this function is
   * where you might, for example:
   *
   * - Initialize and configure a mass storage device to support on-demand paging.
   *   This might be, perhaps an SD card or NAND memory.  An SPI FLASH would probably
   *   already have been configured by lpc313x_spiinitialize(void);
   * - Set up resources to support up_fillpage() operation.  For example, perhaps the
   *   the text image is stored in a named binary file.  In this case, the virtual
   *   text addresses might map to offsets into that file.
   * - Do whatever else is necessary to make up_fillpage() ready for the first time
   *   that it is called.
   */

#if defined(CONFIG_PAGING_BINPATH)

  /* If BINPATH is defined, then it is the full path to a file on a mounted file
   * system.  However, in this case, initialization will involve some higher level
   * file system operations.  Since this function is called from a low level (before
   * os_start() is even called), it may not be possible to perform file system
   * operations yet.  Therefore, initialization will be deferred until the first
   * time that up_fillpage() is called.
   */

#elif defined(CONFIG_PAGING_M25PX)

  /* If CONFIG_PAGING_M25PX is defined, use the m25px.c FLASH driver.  If this
   * is selected, then the MTD interface to the M25Px device will be used to
   * support paging.
   *
   * If the driver is not configured to use interrupts or DMA, then it is
   * probably safe to initialize it in this context.
   */

#if !defined(CONFIG_LPC313x_SPI_INTERRUPTS) && !defined(CONFIG_LPC313x_SPI_DMA)

  lpc313x_initsrc();

#endif
#endif
}

#endif /* CONFIG_PAGING */