T536_DTU/app_public/fuxi_public/fuxi_bsp/source/shm.c

/******************************************************************************
版权所有：	文件名称：	shm.c
文件名称：	shm.c
文件版本：	01.01
创建作者：	sunxi
创建日期：	2022-04-21
功能说明：	共享内存驱动
其它说明：
修改记录：
*/
#include "bspconfig.h"
#include "bsp.h"
#include "shm.h"

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <pthread.h>
#include <stdbool.h>


uint8_t *SHM_BASE_R = NULL; //共享内存---读(从裸核读取数据)---开始地址
uint8_t *SHM_BASE_W = NULL; //共享内存---写(向裸核写入数据)---开始地址



struct  test_data_s
{
	uint16_t A;//标志A，写buf和crc前，A++
	uint8_t  buf[1000];
	uint16_t crc;// buf的crc
	uint16_t B;//标志B，写buf和crc后，B++，且A=B

};

struct dev_co {
    char                    *name;
    pthread_t               thread_id;
    //int                     fd_co; //mailbox 暂时去掉
   	int                     fd_shm_w;
    int                     fd_shm_r;

    uint8_t                 *shm_w;
    uint8_t                 *shm_r;

    //struct co_io            coio; //mailbox 暂时去掉
};

struct dev_co *pco0;


static inline void dmsg_u8(uint8_t *data, int length, char *str)
{
	int i, j;
	int tmp;

	printf("%s:\n", str);
	for (i = 0; i < (length / 16); i++)
	{
		for (j = 0; j < 16; j++)
			printf("%02x ", data[i * 16 + j]);
		printf("\n");
	}
	tmp = (length / 16) * 16;
	for (i = 0; i < (length % 16); i++)
		printf("%02x ", data[tmp + i]);
	if (length % 16)
		printf("\n");
}


/******************************************************************************
函数名称：	shm_read
函数版本：	01.01
创建作者：	sunxi
创建日期：	2022-04-21
函数说明：	读取共享内存的数据.
参数说明：	
addr：所以读取共享内存的地址
len：需要读取数据的长度
out_data：输出buf
out_data_size:输出buf的长度

返回值：	成功返回读取数据的长度, 失败返回-1
修改记录：	
*/
int shm_read(uint32_t addr, uint32_t len, uint8_t *out_data, uint32_t out_data_size)
{
	uint32_t i=0;
	
	if(SHM_BASE_R == NULL)
		return -1;

	if(out_data == NULL)
		return -1;
	if((len == 0) || (out_data_size == 0))
		return -1;

	for(i=0;i < len; i++)
	{
		if((addr+i) >= SHM_MAX_SIZE)
			return -1;

		if(i >= out_data_size)
			return -1;

		out_data[i] = SHM_BASE_R[addr+i];
	}

	return i;
}

/******************************************************************************
函数名称：	shm_write
函数版本：	01.01
创建作者：	sunxi
创建日期：	2022-04-21
函数说明：	向共享内存写入数据.
参数说明：	
addr：共享内存的地址
data：写入数据
len:写入数据长度

返回值：	成功返回写入数据的长度, 失败返回-1
修改记录：	
*/
int shm_write(uint32_t addr, uint8_t *data, uint32_t len)
{
	uint32_t i=0;

	if(SHM_BASE_W == NULL)
		return -1;

	if(data == NULL)
		return -1;
	if(len == 0 )
		return -1;

	for(i=0;i < len; i++)
	{
		if((addr+i) >= SHM_MAX_SIZE)
			return -1;

		SHM_BASE_W[addr+i] = data[i];
	}

	return i;
}




static int co_open(struct dev_co *co, char *name, int blk)
{
    //int fd_co;
    int fd_shm0;
    int fd_shm1;
	uint8_t *shm0 = NULL;
	uint8_t *shm1 = NULL;

    printf("open co dev %s blk=%d\n", name, blk);

	if(0 == blk) {
		fd_shm0 = open("/dev/arv-shmem", O_RDWR);
		if (!fd_shm0) {
            printf("open arv-shmem error\n");
			return -1;
		}
		fd_shm1 = open("/dev/arv-shmem", O_RDWR);
		if (!fd_shm1) {
			printf("open arv-shmem error\n");
			return -1;
		}

		shm0 = mmap(NULL, SHM_MAX_SIZE,
			    PROT_READ | PROT_WRITE,
			    MAP_FILE | MAP_SHARED,
			    fd_shm0, 0);
		if (shm0 == MAP_FAILED) {
			printf("shm mmap error\n");
			return -1;		
		}
		shm1 = mmap(NULL, SHM_MAX_SIZE,
			   PROT_READ | PROT_WRITE,
			   MAP_FILE | MAP_SHARED,
			   fd_shm1, 0);
		if (shm1 == MAP_FAILED) {
			printf("shm mmap error\n");
			return -1;		
		}
		
	} else if(1 == blk) {
		fd_shm0 = open("/dev/sc-shm2", O_RDWR);
		if (!fd_shm0) {
			printf("open sc-shm2 error\n");
			return -1;
		}
		fd_shm1 = open("/dev/sc-shm3", O_RDWR);
		if (!fd_shm1) {
			printf("open sc-shm3 error\n");
			return -1;
		}

		shm0 = mmap(NULL, SHM_MAX_SIZE,
			    PROT_READ | PROT_WRITE,
			    MAP_FILE | MAP_SHARED,
			    fd_shm0, 0);
		if (shm0 == MAP_FAILED) {
			printf("shm mmap error\n");
			return -1;		
		}
		shm1 = mmap(NULL, SHM_MAX_SIZE,
			   PROT_READ | PROT_WRITE,
			   MAP_FILE | MAP_SHARED,
			   fd_shm1, 0);
		if (shm1 == MAP_FAILED) {
			printf("shm mmap error\n");
			return -1;		
		}
	} else {
		printf("donot support this shm blk\n");
		return -1;
	}

/*
    fd_co = open(name, O_RDWR);
    if (!fd_co) {
        printf("open co dev failed\n");
        return -1;	
    }
*/
    co->name  = name;
    //co->fd_co = fd_co;
    co->fd_shm_w = fd_shm0;
    co->fd_shm_r = fd_shm1;
	co->shm_w = shm0;
	co->shm_r = shm1;

	return 0;

}


static void *thread_co_test(void *arg)
{
//	struct dev_co *co = (struct dev_co *)arg;
//	uint8_t *shm0 = co->shm_w;
//	uint8_t *shm1 = co->shm_r;
    int i;
    int state = 0;
//	int ret;
//	uint16_t crc = 0;
//	int crc_err_cnt = 0;
//	int cnt_alive = 0;
//	int cnt_busy = 0;
//	int cnt_crcerr = 0;
//	int cnt_good = 0;

	uint8_t test_buf_r[2000];
//	uint8_t test_buf_r_record[2000];
	uint8_t test_buf_w[2000];
    int nr = 0;
//	uint8_t lastcode = 0;
//	int cnt = 0;
//	int last_A = 0;
//	int last_B = 0;
//	struct  test_data_s *p_rec_buf = (struct  test_data_s*)test_buf_r;
//	uint16_t temval = 0;
	

	memset(test_buf_r, 0, 2000);
	memset(test_buf_w, 0, 2000);

    state = 1;

    while (1) {

		sleep(5);

		nr++;

		//读 分两种接口
		dmsg_u8(SHM_BASE_R, 10, "read:");

		shm_read(10, 10, test_buf_r, 2000);
		dmsg_u8(test_buf_r, 10, "shm_read:");


		//写 分两种接口
		for(i = 0; i< 10; i++)
			SHM_BASE_W[i] = nr+i;

		for(i = 0; i< 10; i++)
			test_buf_w[i] = nr+i+10;

	  	shm_write(10, test_buf_w, 10);

		
		
#if 0
      if (state == 1) {

			last_A = shm1[0]+((uint16_t)shm1[1]<<8);
			last_B = shm1[sizeof(struct  test_data_s)-2]+((uint16_t)shm1[sizeof(struct  test_data_s)-1]<<8);
			if(last_A == last_B)
			{
				//idle
				memcpy(&test_buf_r,shm1,sizeof(struct  test_data_s));

				if((p_rec_buf->A == p_rec_buf->B) && (p_rec_buf->A == last_A) && (last_A == shm1[0]+((uint16_t)shm1[1]<<8)) 
					&& (last_B == shm1[sizeof(struct  test_data_s)-2]+((uint16_t)shm1[sizeof(struct  test_data_s)-1]<<8)))
				{
					//在拷贝过程中，数据没有被修改
					crc = CrcStr(p_rec_buf->buf,sizeof(p_rec_buf->buf));
					if(crc != p_rec_buf->crc)
					{
						#if 0
						printf("crc err!!! cal crc=%04X, read crc=%04X\n",  crc,p_rec_buf->crc);
						dmsg_u8(test_buf_r, sizeof(struct  test_data_s), "test_buf_r");
						dmsg_u8(shm1, sizeof(struct  test_data_s), "shm1");
						printf("p_rec_buf->A=%d, last_A=%d\n",  p_rec_buf->A,last_A);
						#endif
						
						cnt_crcerr++;
					}
					else
					{
						cnt_good++;
					}

				}
				else
				{
					//busy 裸核正在写数据
					cnt_busy++;

				}

			}
			else
			{
				//busy 裸核正在写数据
				cnt_busy++;
				
			}


			if(cnt_alive++ > 100000)
			{
				cnt_alive = 0;
				printf("cnt_busy=%d, cnt_crcerr=%d, cnt_good=%d\n",  cnt_busy,cnt_crcerr,cnt_good);
				printf("cal crc=%04X, read crc=%04X\n",  crc,p_rec_buf->crc);

			}

		 	usleep(10);

      }

#endif

	  
    }



	
    printf("thread co exit\r\n");    
    pthread_exit(NULL);
}

static int co_close(struct dev_co *co)
{
    //if(co->fd_co)
    //    close(co->fd_co);
    if(co->fd_shm_w)
        close(co->fd_shm_w);
    if(co->fd_shm_r)
        close(co->fd_shm_r);
    return 0;
}

//测试代码
void shm_test(void)
{
	int ret;
	
	if((ret = pthread_create(&pco0->thread_id, NULL, thread_co_test, pco0)) == 0)
		printf("thread co0 create success\r\n");
	else
		printf("thread co0 create fail ret=%d\r\n", ret);

}



/******************************************************************************
函数名称：	shm_init
函数版本：	01.01
创建作者：	sunxi
创建日期：	2022-04-21
函数说明：	shm初始化.
参数说明：	
					无					
返回值：	成功返回0, 失败返回-1
修改记录：	
*/
int shm_init(void)
{
//	int ret;

	int i;

	SHM_BASE_R = NULL;
	SHM_BASE_W = NULL;

	pco0 = malloc(sizeof(struct dev_co));

	memset(pco0, 0, sizeof(struct dev_co));


	if(co_open(pco0, "/dev/arv-shmem", 0)) {
		printf("open shm blk 0 error\r\n");
		return -1;
	}

	SHM_BASE_R = pco0->shm_r; //共享内存---读(从裸核读取数据)---开始地址
	SHM_BASE_W = pco0->shm_w; //共享内存---写(向裸核写入数据)---开始地址

	//初始化shm区
	//暂时初始化参数区
	for(i=0;i<SHM_ADDR_U_ADC_1;i++)
	{
		SHM_BASE_R[i] = 0;
		SHM_BASE_W[i] = i;
	}
	
	// shm_test();//sunxi for test

	return 0;	
}

/******************************************************************************
函数名称：	shm_exit
函数版本：	01.01
创建作者：	sunxi
创建日期：	2022-04-21
函数说明：	shm反初始化.
参数说明：	
					无					
返回值：	总是返回0.
修改记录：	
*/
int shm_exit(void)
{
	 //pthread_join(pco0->thread_id, NULL);

	 co_close(pco0);

	return 0;
}