* apps/testing/rpmsg/rpmsgmtd.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 <stdio.h>
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
#include <setjmp.h>
#include <sys/ioctl.h>
#include <sys/random.h>
#include <syslog.h>
#include <fcntl.h>
#include <cmocka.h>
#include <unistd.h>
#include <nuttx/fs/fs.h>
#include <nuttx/kmalloc.h>
#include <nuttx/mtd/mtd.h>
* Pre-processor Definitions
****************************************************************************/
#define MTD_BLOCKSIZE 512
#define MTD_ERASESIZE 4096
#define MTD_SIZE (1024 * 128)
#define MTD_ERASESTATE 0xff
#define MTD_NAMESIZE 32
* Private Types
****************************************************************************/
struct pre_build_s
{
char source[MTD_NAMESIZE];
struct mtd_geometry_s geo;
int fd;
FAR char *cpu;
bool server;
};
* Private Functions
****************************************************************************/
#ifdef CONFIG_RPMSGMTD_SERVER
* Name: mtddriver_register
*
* Description:
* Non-standard function to register rpmsgmtd device
*
* Input Parameters:
* minor: Selects suffix of device named /dev/ramN, N={1,2,3...}
*
* Returned Value:
* Zero on success; a negated errno value on failure.
*
****************************************************************************/
static int mtddriver_register(FAR const char *path)
{
struct rammtd_config_s config;
FAR struct mtd_dev_s *mtd;
FAR uint8_t *start;
int ret;
start = (FAR uint8_t *)malloc(MTD_SIZE);
assert_true(start != NULL);
config.blocksize = MTD_BLOCKSIZE;
config.erasesize = MTD_ERASESIZE;
config.erase_state = MTD_ERASESTATE;
config.size = MTD_SIZE;
config.start = start;
mtd = rammtd_initialize_with_config(&config);
if (mtd == NULL)
{
syslog(LOG_ERR, "Fail to initialize MTD device\n");
free(start);
return ERROR;
}
ret = register_mtddriver(path, mtd, 0, start);
if (ret < 0)
{
syslog(LOG_ERR, "register_mtddriver failed: %d\n", -ret);
rammtd_uninitialize(mtd);
free(start);
}
return ret;
}
#endif
#ifdef CONFIG_RPMSGMTD_SERVER
* Name: mtddriver_unregister
****************************************************************************/
static int mtddriver_unregister(FAR const char *path)
{
FAR struct inode *inode;
FAR void *mem;
int ret;
ret = find_mtddriver(path, &inode);
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: Failed to find mtddriver, ret=%d\n", ret);
return ret;
}
mem = inode->i_private;
ret = close_mtddriver(inode);
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: Failed to close mtddriver, ret=%d\n", ret);
return ret;
}
ret = unregister_mtddriver(path);
if (ret < 0)
{
syslog(LOG_ERR, "ERROR: unregister driver failed, ret=%d\n", ret);
return ret;
}
free(mem);
return ret;
}
#endif
* Name: show_usage
****************************************************************************/
static void show_usage(FAR const char *progname, int exitcode)
{
printf("Usage: %s [-c <remote cpu>] [-d <dev_name>] [-u <dev_name>] \
[-m <server>]\n", progname);
printf("Where:\n");
printf(" -c: <name> remote cpu which regists test driver\n"
" -d: <path> register rpmsgmtd device\n"
" -u: <path> unregister rpmsgmtd driver\n"
" -m: <server>: is server\n");
exit(exitcode);
}
* Name: parse_commandline
****************************************************************************/
static void parse_commandline(int argc, FAR char **argv,
FAR struct pre_build_s *pre)
{
int option;
int ret = 0;
pre->server = true;
while ((option = getopt(argc, argv, "c:d:u:m:")) != ERROR)
{
switch (option)
{
case 'c':
pre->cpu = optarg;
break;
case 'm':
pre->server = atoi(optarg);
break;
case 'd':
memcpy(pre->source, optarg, sizeof(pre->source));
if (pre->server)
{
#ifdef CONFIG_RPMSGMTD_SERVER
ret = mtddriver_register(pre->source);
#endif
}
else
{
#ifdef CONFIG_RPMSGMTD
ret = rpmsgmtd_register(pre->cpu, pre->source, NULL);
#endif
}
if (ret == 0)
{
syslog(LOG_INFO, "register rpmsgmtd device success.\n");
}
else
{
syslog(LOG_ERR, "register rpmsgmtd device failed.\n");
}
break;
case 'u':
memcpy(pre->source, optarg, sizeof(pre->source));
#ifdef CONFIG_RPMSGMTD_SERVER
if (mtddriver_unregister(pre->source) < 0)
{
syslog(LOG_INFO, "unregister mtd device fail.\n");
}
else
{
syslog(LOG_INFO, "unregister mtd device success.\n");
}
#else
syslog(LOG_ERR, "ERROR: Client unsupport ops: -u.\n");
#endif
break;
case '?':
printf("Unknown option: %c\n", optopt);
show_usage(argv[0], EXIT_FAILURE);
break;
}
}
}
#ifdef CONFIG_RPMSGMTD
* Name: testcase1
*
* Description:
* Test rpmsgmtd device open, ioctl command and close option.
*
* Returned Value:
* Zero on success; a negated errno value on failure.
*
****************************************************************************/
static void testcase1(FAR void** state)
{
FAR const char *source = (FAR const char *)(*state);
struct partition_info_s partinfo;
FAR uint8_t *start;
FAR uint8_t *data;
uint8_t result;
size_t index;
int fd;
int ret;
fd = open(source, O_RDWR | O_DIRECT);
assert_true(fd > 0);
ret = ioctl(fd, BIOC_XIPBASE, (unsigned long)((uintptr_t)&start));
assert_true(ret == 0);
ret = ioctl(fd, MTDIOC_BULKERASE, NULL);
assert_true(ret == 0);
data = malloc(MTD_SIZE);
assert_true(data != NULL);
ret = read(fd, data, MTD_SIZE);
assert_true(ret == MTD_SIZE);
for (index = 0; index < MTD_SIZE; index++)
{
assert_true(data[index] == MTD_ERASESTATE);
}
free(data);
ret = ioctl(fd, MTDIOC_ERASESTATE, (unsigned long)((uintptr_t)&result));
assert_true(ret == 0);
assert_true(result == MTD_ERASESTATE);
ret = ioctl(fd, BIOC_PARTINFO, (unsigned long)((uintptr_t)&partinfo));
assert_true(ret == 0);
assert_true(partinfo.numsectors == MTD_SIZE / MTD_BLOCKSIZE &&
partinfo.sectorsize == MTD_BLOCKSIZE &&
partinfo.startsector == 0);
syslog(LOG_INFO, "partinfo.numsectors = %d partinfo.sectorsize = %d\
partinfo.startsector = %lld partinfo.parent = %s\n",
partinfo.numsectors, partinfo.sectorsize,
partinfo.startsector, partinfo.parent);
close(fd);
}
* Name: testcase2_setup
****************************************************************************/
static int testcase2_setup(FAR void **state)
{
FAR struct pre_build_s *pre = (FAR struct pre_build_s *)(*state);
time_t t;
int ret;
pre->fd = open(pre->source, O_RDWR | O_DIRECT);
assert_true(pre->fd > 0);
ret = ioctl(pre->fd, MTDIOC_GEOMETRY,
(unsigned long)((uintptr_t)&pre->geo));
assert_true(ret == 0);
assert_true(pre->geo.blocksize == MTD_BLOCKSIZE &&
pre->geo.erasesize == MTD_ERASESIZE &&
pre->geo.neraseblocks == MTD_SIZE / MTD_ERASESIZE);
srand((unsigned)time(&t));
return ret;
}
* Name: testcase2
*
* Description:
* Test rpmsgmtd device read, write option.
*
* Returned Value:
* Zero on success; a negated errno value on failure.
*
****************************************************************************/
static void testcase2(FAR void ** state)
{
FAR struct pre_build_s *pre = (FAR struct pre_build_s *)(*state);
FAR char *output;
FAR char *input;
off_t offset;
int ret;
input = malloc(pre->geo.blocksize * 2);
assert_true(input != NULL);
output = input + pre->geo.blocksize;
for (offset = 0; offset < pre->geo.erasesize; offset += pre->geo.blocksize)
{
assert_true(lseek(pre->fd, offset, SEEK_SET) >= 0);
getrandom(input, pre->geo.blocksize, 0);
ret = write(pre->fd, input, pre->geo.blocksize);
assert_true(ret == pre->geo.blocksize);
* beginning
*/
assert_true(lseek(pre->fd, offset, SEEK_SET) >= 0);
ret = read(pre->fd, output, pre->geo.blocksize);
assert_true(ret == pre->geo.blocksize);
assert_true(memcmp(input, output, pre->geo.blocksize) == 0);
}
free(input);
close(pre->fd);
}
#endif
* Public Functions
****************************************************************************/
int main(int argc, char *argv[])
{
struct pre_build_s pre;
parse_commandline(argc, argv, &pre);
#ifdef CONFIG_RPMSGMTD
if (pre.server == false)
{
const struct CMUnitTest tests[] =
{
cmocka_unit_test_prestate_setup_teardown(testcase1, NULL,
NULL, &pre),
cmocka_unit_test_prestate_setup_teardown(testcase2,
testcase2_setup,
NULL, &pre),
};
cmocka_run_group_tests(tests, NULL, NULL);
rpmsgmtd_unregister(pre.source);
return 0;
}
#endif
return 0;
}