438 lines
9.8 KiB
C
438 lines
9.8 KiB
C
/****************************************************************************
|
|
* apps/testing/himem_test/himem_chardev_test.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 <stdint.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <pthread.h>
|
|
#include <nuttx/himem/himem.h>
|
|
#include <math.h>
|
|
|
|
#include <nuttx/config.h>
|
|
#include <fcntl.h>
|
|
#include <stdbool.h>
|
|
#include <assert.h>
|
|
#include <arch/esp32/esp32_himem_chardev.h>
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
#define HIMEM_DEV1 "/dev/chardev1"
|
|
#define HIMEM_DEV2 "/dev/chardev2"
|
|
#define DATA_OUTPUT 0
|
|
|
|
/****************************************************************************
|
|
* Private Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Data check function
|
|
****************************************************************************/
|
|
|
|
static void himem_data_check(uint8_t *data1, uint8_t *data2,
|
|
uint32_t len, uint32_t offset)
|
|
{
|
|
uint32_t ok = 0;
|
|
uint32_t ng = 0;
|
|
|
|
for (int i = 0; i < len; i++)
|
|
{
|
|
if (data1[i] == data2[i])
|
|
{
|
|
ok++;
|
|
}
|
|
else
|
|
{
|
|
ng++;
|
|
}
|
|
}
|
|
|
|
if (ng == 0)
|
|
{
|
|
printf("Data check OK=%d KB\n", ok / 1024);
|
|
}
|
|
else
|
|
{
|
|
printf("Data check NG=%d OK=%d\n", ng, ok);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Alternate access verification for multiple devices
|
|
****************************************************************************/
|
|
|
|
static void himem_multi_dev_check(uint32_t size, uint32_t offset)
|
|
{
|
|
int fd1;
|
|
int fd2;
|
|
uint8_t *work_buffer1 = NULL;
|
|
uint8_t *work_buffer2 = NULL;
|
|
uint8_t *work_buffer3 = NULL;
|
|
|
|
if (himem_chardev_register(HIMEM_DEV1, size + offset) != 0)
|
|
{
|
|
printf("HIMEM_DEV1 Create failed. \n");
|
|
goto common_exit3;
|
|
}
|
|
|
|
if (himem_chardev_register(HIMEM_DEV2, size + offset) != 0)
|
|
{
|
|
printf("HIMEM_DEV2 Create failed. \n");
|
|
goto common_exit3;
|
|
}
|
|
|
|
if ((fd1 = open(HIMEM_DEV1, O_RDWR)) < 0)
|
|
{
|
|
printf("HIMEM_DEV1 Open failed. \n");
|
|
goto common_exit2;
|
|
}
|
|
|
|
if ((fd2 = open(HIMEM_DEV2, O_RDWR)) < 0)
|
|
{
|
|
printf("HIMEM_DEV1 Open failed. \n");
|
|
goto common_exit1;
|
|
}
|
|
|
|
if ((work_buffer1 = malloc(size)) == NULL)
|
|
{
|
|
printf("Allocate failed1");
|
|
goto common_exit;
|
|
}
|
|
|
|
if ((work_buffer2 = malloc(size)) == NULL)
|
|
{
|
|
printf("Allocate failed2");
|
|
goto common_exit;
|
|
}
|
|
|
|
if ((work_buffer3 = malloc(size)) == NULL)
|
|
{
|
|
printf("Allocate failed2");
|
|
goto common_exit;
|
|
}
|
|
|
|
memset(work_buffer1, 0, size);
|
|
memset(work_buffer2, 0, size);
|
|
memset(work_buffer3, 0, size);
|
|
|
|
if (size + offset < 1048576)
|
|
{
|
|
printf("Memory Size: %d KB\nHimemSizeTest=%d\n",
|
|
(size + offset) / 1024, size + offset);
|
|
}
|
|
else
|
|
{
|
|
printf("Memory Size: %d MB\nHimemSizeTest=%d\n",
|
|
(size + offset) / (1024 * 1024), size + offset);
|
|
}
|
|
|
|
printf("write HIMEM_DEV1 data:");
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
work_buffer1[i] = i;
|
|
#if DATA_OUTPUT
|
|
if (i < 128)
|
|
printf("%d ", work_buffer1[i]);
|
|
#endif
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
if (lseek(fd1, offset, SEEK_SET) < 0)
|
|
{
|
|
printf("HiMem Seek failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
if (write(fd1, work_buffer1, size) != size)
|
|
{
|
|
printf("HiMem Write failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
printf("write HIMEM_DEV2 data:");
|
|
for (int i = 5; i < size; i++)
|
|
{
|
|
work_buffer3[i - 5] = i;
|
|
#if DATA_OUTPUT
|
|
if (i < 128)
|
|
printf("%d ", i);
|
|
#endif
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
if (lseek(fd2, offset, SEEK_SET) < 0)
|
|
{
|
|
printf("HiMem Seek failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
if (write(fd2, work_buffer3, size) != size)
|
|
{
|
|
printf("HiMem Write failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
/* read dev1 */
|
|
|
|
memset(work_buffer2, 0, size);
|
|
if (lseek(fd1, offset, SEEK_SET) < 0)
|
|
{
|
|
printf("HiMem Seek failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
if (read(fd1, work_buffer2, size) != size)
|
|
{
|
|
printf("HiMem Read failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
printf("read HIMEM_DEV1 data:");
|
|
#if DATA_OUTPUT
|
|
for (int j = 0; j < 128; j++)
|
|
{
|
|
printf("%d ", work_buffer2[j]);
|
|
}
|
|
#endif
|
|
|
|
printf("\n");
|
|
himem_data_check(work_buffer1, work_buffer2, size, offset);
|
|
|
|
/* read dev2 */
|
|
|
|
memset(work_buffer2, 0, size);
|
|
if (lseek(fd2, offset, SEEK_SET) < 0)
|
|
{
|
|
printf("HiMem Seek failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
if (read(fd2, work_buffer2, size) != size)
|
|
{
|
|
printf("HiMem Read failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
printf("read HIMEM_DEV2 data:");
|
|
#if DATA_OUTPUT
|
|
for (int j = 0; j < 128; j++)
|
|
{
|
|
printf("%d ", work_buffer2[j]);
|
|
}
|
|
#endif
|
|
|
|
printf("\n");
|
|
himem_data_check(work_buffer3, work_buffer2, size, offset);
|
|
|
|
common_exit:
|
|
if (work_buffer1 == NULL)
|
|
{
|
|
free(work_buffer1);
|
|
}
|
|
|
|
if (work_buffer2 == NULL)
|
|
{
|
|
free(work_buffer2);
|
|
}
|
|
|
|
if (work_buffer3 == NULL)
|
|
{
|
|
free(work_buffer3);
|
|
}
|
|
|
|
common_exit1:
|
|
close(fd2);
|
|
common_exit2:
|
|
close(fd1);
|
|
common_exit3:
|
|
|
|
himem_chardev_unregister(HIMEM_DEV1);
|
|
himem_chardev_unregister(HIMEM_DEV2);
|
|
|
|
free(work_buffer1);
|
|
free(work_buffer2);
|
|
free(work_buffer3);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Himem access function verification from 1MB to 4 MB
|
|
****************************************************************************/
|
|
|
|
static void himem_check(uint32_t size, uint32_t offset)
|
|
{
|
|
int fd;
|
|
uint8_t *work_buffer1 = NULL;
|
|
uint8_t *work_buffer2 = NULL;
|
|
|
|
if (himem_chardev_register(HIMEM_DEV1, size + offset + 1024) != 0)
|
|
{
|
|
printf("HIMEM_DEV Create failed. \n");
|
|
goto common_exit3;
|
|
}
|
|
|
|
if ((fd = open(HIMEM_DEV1, O_RDWR)) < 0)
|
|
{
|
|
printf("HiMemo Open failed. \n");
|
|
goto common_exit2;
|
|
}
|
|
|
|
if ((work_buffer1 = malloc(size)) == NULL)
|
|
{
|
|
printf("Allocate failed1");
|
|
goto common_exit;
|
|
}
|
|
|
|
if ((work_buffer2 = malloc(size)) == NULL)
|
|
{
|
|
printf("Allocate failed2");
|
|
goto common_exit;
|
|
}
|
|
|
|
memset(work_buffer1, 0, size);
|
|
memset(work_buffer2, 0, size);
|
|
|
|
printf("Memory Size: %d KB\nHimemSizeTest=%d\n",
|
|
size / 1024, size + offset);
|
|
|
|
for (int i = 0; i < size; i++)
|
|
{
|
|
work_buffer1[i] = i;
|
|
}
|
|
|
|
if (lseek(fd, offset, SEEK_SET) < 0)
|
|
{
|
|
printf("HiMem Seek failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
if (write(fd, work_buffer1, size) != size)
|
|
{
|
|
printf("HiMem Write failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
if (lseek(fd, offset, SEEK_SET) < 0)
|
|
{
|
|
printf("HiMem Seek failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
if (read(fd, work_buffer2, size) != size)
|
|
{
|
|
printf("HiMem Read failed. \n");
|
|
goto common_exit;
|
|
}
|
|
|
|
himem_data_check(work_buffer1, work_buffer2, size, offset);
|
|
|
|
common_exit:
|
|
if (work_buffer1 == NULL)
|
|
{
|
|
free(work_buffer1);
|
|
}
|
|
|
|
if (work_buffer2 == NULL)
|
|
{
|
|
free(work_buffer2);
|
|
}
|
|
|
|
common_exit2:
|
|
close(fd);
|
|
common_exit3:
|
|
himem_chardev_unregister(HIMEM_DEV1);
|
|
|
|
free(work_buffer1);
|
|
free(work_buffer2);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Himem Initialization processing section
|
|
****************************************************************************/
|
|
|
|
static int himem_chardev_test(void)
|
|
{
|
|
uint32_t result;
|
|
|
|
/* himem Cdev initialization */
|
|
|
|
result = himem_chardev_init();
|
|
if (result != 0)
|
|
{
|
|
printf("himem_chardev_init() err:%d", result);
|
|
}
|
|
|
|
/* 1M--->4M */
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
printf("\nHimem Cdev test: %d MB\n", (i + 1));
|
|
for (int j = 0; j < 11; j++)
|
|
{
|
|
/* 1K--->1M */
|
|
|
|
himem_check(1024 * pow(2, j), 1048576 * i);
|
|
}
|
|
}
|
|
|
|
printf("\n\nRead and write multiple device files!\n");
|
|
|
|
/* 16K and 1024K */
|
|
|
|
himem_multi_dev_check(16384, 0);
|
|
himem_multi_dev_check(1048576, 0);
|
|
|
|
result = himem_chardev_exit();
|
|
if (result != 0)
|
|
{
|
|
printf("himem_chardev_exit() err:%d", result);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* Public Functions
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* himem_cdev_main
|
|
****************************************************************************/
|
|
|
|
int main(int argc, char*argv[])
|
|
{
|
|
if (!himem_chardev_test())
|
|
{
|
|
printf("Himemchardev test success!\n");
|
|
}
|
|
else
|
|
{
|
|
printf("Himemchardev test failed!\n");
|
|
}
|
|
|
|
return 0;
|
|
}
|