/****************************************************************************
* apps/examples/mtdrwb/mtdrwb_main.c
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership. The
* ASF licenses this file to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
/****************************************************************************
* Included Files
****************************************************************************/
#include <nuttx/config.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <debug.h>
#include <nuttx/mtd/mtd.h>
#include <nuttx/drivers/drivers.h>
#include <nuttx/fs/ioctl.h>
#ifdef CONFIG_EXAMPLES_MTDRWB
/****************************************************************************
* Pre-processor Definitions
****************************************************************************/
/* Configuration ************************************************************/
#if !defined(CONFIG_MTD_WRBUFFER) && !defined(CONFIG_MTD_READAHEAD)
# error CONFIG_MTD_WRBUFFER or CONFIG_MTD_READAHEAD must be selected
#endif
/* The default is to use the RAM MTD device at drivers/mtd/rammtd.c. But
* an architecture-specific MTD driver can be used instead by defining
* CONFIG_EXAMPLES_MTDRWB_ARCHINIT. In this case, the initialization logic
* will call mtdrwb_archinitialize() to obtain the MTD driver instance.
*/
#ifndef CONFIG_EXAMPLES_MTDRWB_ARCHINIT
/* Make sure that the RAM MTD driver is enabled */
# ifndef CONFIG_RAMMTD
# error "CONFIG_RAMMTD is required without CONFIG_EXAMPLES_MTDRWB_ARCHINIT"
# endif
/* This must exactly match the default configuration in
* drivers/mtd/rammtd.c
*/
# ifndef CONFIG_RAMMTD_ERASESIZE
# define CONFIG_RAMMTD_ERASESIZE 4096
# endif
/* Given the ERASESIZE, CONFIG_EXAMPLES_MTDRWB_NEBLOCKS will determine the
* size of the RAM allocation needed.
*/
# ifndef CONFIG_EXAMPLES_MTDRWB_NEBLOCKS
# define CONFIG_EXAMPLES_MTDRWB_NEBLOCKS (32)
# endif
# undef MTDRWB_BUFSIZE
# define MTDRWB_BUFSIZE \
(CONFIG_RAMMTD_ERASESIZE * CONFIG_EXAMPLES_MTDRWB_NEBLOCKS)
#endif
/****************************************************************************
* Private Types
****************************************************************************/
struct mtdweb_filedesc_s
{
FAR char *name;
bool deleted;
size_t len;
uint32_t crc;
};
/****************************************************************************
* Private Data
****************************************************************************/
/* Pre-allocated simulated flash */
#ifndef CONFIG_EXAMPLES_MTDRWB_ARCHINIT
static uint8_t g_simflash[MTDRWB_BUFSIZE];
#endif
/****************************************************************************
* External Functions
****************************************************************************/
#ifdef CONFIG_EXAMPLES_MTDRWB_ARCHINIT
extern FAR struct mtd_dev_s *mtdrwb_archinitialize(void);
#endif
/****************************************************************************
* Public Functions
****************************************************************************/
/****************************************************************************
* Name: mtdrwb_main
****************************************************************************/
int main(int argc, FAR char *argv[])
{
FAR struct mtd_dev_s *mtdraw;
FAR struct mtd_dev_s *mtdrwb;
FAR struct mtd_geometry_s geo;
FAR uint32_t *buffer;
ssize_t nbytes;
off_t nblocks;
off_t offset;
off_t seekpos;
unsigned int blkpererase;
int fd;
int i;
int j;
int k;
int ret;
/* Create and initialize a RAM MTD FLASH driver instance */
#ifdef CONFIG_EXAMPLES_MTDRWB_ARCHINIT
mtdraw = mtdrwb_archinitialize();
#else
mtdraw = rammtd_initialize(g_simflash, MTDRWB_BUFSIZE);
#endif
if (!mtdraw)
{
printf("ERROR: Failed to create RAM MTD instance\n");
fflush(stdout);
exit(1);
}
/* Perform the IOCTL to erase the entire FLASH part */
ret = mtdraw->ioctl(mtdraw, MTDIOC_BULKERASE, 0);
if (ret < 0)
{
printf("ERROR: MTDIOC_BULKERASE ioctl failed: %d\n", ret);
}
/* Initialize to support buffering on the MTD device */
mtdrwb = mtd_rwb_initialize(mtdraw);
if (!mtdrwb)
{
printf("ERROR: Failed to create RAM MTD R/W buffering\n");
fflush(stdout);
exit(2);
}
/* Initialize to provide an FTL block driver on the MTD FLASH interface.
*
* NOTE: We could just skip all of this FTL and BCH stuff. We could
* instead just use the MTD drivers bwrite and bread to perform this
* test. Creating the character drivers, however, makes this test more
* interesting.
*/
ret = ftl_initialize(0, mtdrwb);
if (ret < 0)
{
printf("ERROR: ftl_initialize /dev/mtdblock0 failed: %d\n", ret);
fflush(stdout);
exit(3);
}
/* Now create a character device on the block device */
ret = bchdev_register("/dev/mtdblock0", "/dev/mtd0", false);
if (ret < 0)
{
printf("ERROR: bchdev_register /dev/mtd0 failed: %d\n", ret);
fflush(stdout);
exit(4);
}
/* Get the geometry of the FLASH device */
ret = mtdrwb->ioctl(mtdrwb, MTDIOC_GEOMETRY,
(unsigned long)((uintptr_t)&geo));
if (ret < 0)
{
ferr("ERROR: mtdrwb->ioctl failed: %d\n", ret);
exit(5);
}
printf("Flash Geometry:\n");
printf(" blocksize: %lu\n", (unsigned long)geo.blocksize);
printf(" erasesize: %lu\n", (unsigned long)geo.erasesize);
printf(" neraseblocks: %lu\n", (unsigned long)geo.neraseblocks);
blkpererase = geo.erasesize / geo.blocksize;
printf(" blkpererase: %u\n", blkpererase);
nblocks = geo.neraseblocks * blkpererase;
printf(" nblocks: %lu\n", (unsigned long)nblocks);
/* Allocate a buffer */
buffer = (FAR uint32_t *)malloc(geo.blocksize);
if (!buffer)
{
printf("ERROR: failed to allocate a sector buffer\n");
fflush(stdout);
exit(6);
}
/* Open the MTD FLASH character driver for writing */
fd = open("/dev/mtd0", O_WRONLY);
if (fd < 0)
{
printf("ERROR: open /dev/mtd0 failed: %d\n", errno);
fflush(stdout);
exit(7);
}
/* Now write the offset into every block */
printf("Initializing media:\n");
offset = 0;
for (i = 0; i < geo.neraseblocks; i++)
{
for (j = 0; j < blkpererase; j++)
{
/* Fill the block with the offset */
for (k = 0; k < geo.blocksize / sizeof(uint32_t); k++)
{
buffer[k] = offset;
offset += sizeof(uint32_t);
}
/* And write it using the character driver */
nbytes = write(fd, buffer, geo.blocksize);
if (nbytes < 0)
{
printf("ERROR: write to /dev/mtd0 failed: %d\n", errno);
fflush(stdout);
exit(8);
}
}
}
close(fd);
/* Open the MTD character driver for reading */
fd = open("/dev/mtd0", O_RDONLY);
if (fd < 0)
{
printf("ERROR: open /dev/mtd0 failed: %d\n", errno);
fflush(stdout);
exit(9);
}
/* Now verify the offset in every block */
offset = 0;
for (j = 0; j < nblocks; j++)
{
/* Seek to the next read position */
seekpos = lseek(fd, offset, SEEK_SET);
if (seekpos != offset)
{
printf("ERROR: lseek to offset %ld failed: %d\n",
(unsigned long)offset, errno);
fflush(stdout);
exit(10);
}
/* Read the next block into memory */
nbytes = read(fd, buffer, geo.blocksize);
if (nbytes < 0)
{
printf("ERROR: read from /dev/mtd0 failed: %d\n", errno);
fflush(stdout);
exit(11);
}
else if (nbytes == 0)
{
printf("ERROR: Unexpected end-of file in /dev/mtd0\n");
fflush(stdout);
exit(12);
}
else if (nbytes != geo.blocksize)
{
printf("ERROR: Unexpected read size from /dev/mtd0 : %ld\n",
(unsigned long)nbytes);
fflush(stdout);
exit(13);
}
/* Since we forced the size of the partition to be an even number
* of erase blocks, we do not expect to encounter the end of file
* indication.
*/
else if (nbytes == 0)
{
printf("ERROR: Unexpected end of file on /dev/mtd0\n");
fflush(stdout);
exit(14);
}
/* This is not expected at all */
else if (nbytes != geo.blocksize)
{
printf("ERROR: Short read from /dev/mtd0 failed: %lu\n",
(unsigned long)nbytes);
fflush(stdout);
exit(15);
}
/* Verify the offsets in the block */
for (k = 0; k < geo.blocksize / sizeof(uint32_t); k++)
{
if (buffer[k] != offset)
{
printf("ERROR: Bad offset %lu, expected %lu\n",
(long)buffer[k], (long)offset);
fflush(stdout);
exit(16);
}
offset += sizeof(uint32_t);
}
}
/* Try reading one more time. We should get the end of file */
nbytes = read(fd, buffer, geo.blocksize);
if (nbytes != 0)
{
printf("ERROR: Expected end-of-file from /dev/mtd0 failed: %zd %d\n",
nbytes, errno);
fflush(stdout);
exit(20);
}
close(fd);
/* And exit without bothering to clean up */
printf("PASS: Everything looks good\n");
fflush(stdout);
return 0;
}
#endif /* CONFIG_EXAMPLES_MTDRWB */