CCS/am5728: RPMsg error

/*
 * Copyright (C) 2016 Texas Instruments Incorporated - http://www.ti.com/
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *	* Redistributions of source code must retain the above copyright
 *	  notice, this list of conditions and the following disclaimer.
 *
 *	* 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.
 *
 *	* Neither the name of Texas Instruments Incorporated 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.
 */

#include <stdint.h>
#include <stdio.h>
#include <pru_cfg.h>
#include <pru_intc.h>
#include <rsc_types.h>
#include <pru_rpmsg.h>
#include "resource_table_0.h"
#include "pru_uart_init.h"
#include <sys_mailbox.h>



/* Host-0 Interrupt sets bit 30 in register R31 */
#define HOST_INT			((uint32_t) 1 << 30)

/* The PRU-ICSS system events used for RPMsg are defined in the Linux device tree
 * PRU0 uses system event 16 (To ARM) and 17 (From ARM)
 * PRU1 uses system event 18 (To ARM) and 19 (From ARM)
 */
#define TO_ARM_HOST			16
#define FROM_ARM_HOST			17

#define TxSize 160
#define RxSize (uint8_t)64
#define Tx_data_size 140
#define IOSize 12
#define SizeOfOffset  24
#define route_data_size  240
#define new_array_size 360
#define PRU1
volatile register uint32_t __R30;
volatile register uint32_t __R31;
#define PRU1_PRU0_INTERRUPT (18)

/*
 * Using the name 'rpmsg-pru' will probe the rpmsg_pru driver found
 * at linux-x.y.z/drivers/rpmsg/rpmsg_pru.c
 */
#define CHAN_NAME			"rpmsg-pru"
#define CHAN_DESC			"Channel 30"
#define CHAN_PORT			30

/*
 * Used to make sure the Linux drivers are ready for RPMsg communication
 * Found at linux-x.y.z/include/uapi/linux/virtio_config.h
 */
#define VIRTIO_CONFIG_S_DRIVER_OK	4
uint8_t new_array[RPMSG_BUF_SIZE];
uint8_t payload[RPMSG_BUF_SIZE];
uint8_t tmp[RPMSG_BUF_SIZE];
uint8_t IOData[IOSize];
//uint8_t req_to_send[RxSize];


union char2short{
	uint16_t sint;  
	unsigned char c[2];
};

union ui2uc{
	unsigned int ui;
	unsigned char c[4];
};

void create_Tx_data(unsigned char *Txbuf, unsigned char ts, unsigned char ctlbyte, unsigned char *data, int no_of_char){
	int i;
	union char2short checksum;	//!< check sum variable

	Txbuf[0] = 0;	//!< head must be 0;
	Txbuf[1] = ts;	//!< current time stamp
	Txbuf[2] = ctlbyte;	//!< ctlbyte, 0

	if (no_of_char > 136)//20150630 xiaoxia add "+4" for get g_clock
	{
		//fprintf(stderr,"%cyour size of data is exceed the limit\n",getlocaltime());
	}
	memcpy(Txbuf+3, data, no_of_char); //!< convert float into unsigned char

	//! calculate checksum of the data
	checksum.sint = 0;
	for (i = 3; i < TxSize-3; ++i)
	{
		checksum.sint += Txbuf[i];
	}

	Txbuf[TxSize-3]=checksum.c[1];	//!MSB
	Txbuf[TxSize-2]=checksum.c[0];	//!LSB
	Txbuf[TxSize-1]=255; 	//!< end of Txbuf, must be 255

}

void uchar2uint(unsigned int *ibuf, const unsigned char *cbuf, int bufno){
	union ui2uc x;
	int i;
	for (i=0; i<bufno/4; i++){
		x.c[0] = cbuf[4*i];
    	x.c[1] = cbuf[4*i+1];
    	x.c[2] = cbuf[4*i+2];
    	x.c[3] = cbuf[4*i+3];
    	ibuf[i] = x.ui;
  	}
}

/*
 * main.c
 */
void main(void)
{
	  int count=0;//static
	unsigned int ts_cur,ts_lcur=0;
	const unsigned int Tx_raw_size=120;
	int  i=0,OutputDataSize = 4, PLCConveyorDataSize = 4,CurrentPos,CurrentPos1;
	unsigned char Txbuf[TxSize],Txbuf1[TxSize];
	uint8_t   Rxbuf[RxSize+1];  
	for(i=0;i < TxSize;i++)
		Txbuf[i] = i+1;
	for(i=RxSize;i >0;i--)
		Rxbuf[i] = i;

	int time_counter;


	struct pru_rpmsg_transport transport;
	uint16_t src, dst, len=0,iodata_len;
	volatile uint8_t *status;




	/* Allow OCP master port access by the PRU so the PRU can read external memories */
	CT_CFG.SYSCFG_bit.STANDBY_INIT = 0;

	/* Clear the status of the PRU-ICSS system event that the ARM will use to 'kick' us */
	CT_INTC.SICR_bit.STATUS_CLR_INDEX = FROM_ARM_HOST;

	/* Make sure the Linux drivers are ready for RPMsg communication */
	status = &resourceTable.rpmsg_vdev.status;

	while (!(*status & VIRTIO_CONFIG_S_DRIVER_OK));

	/* Initialize the RPMsg transport structure */
	pru_rpmsg_init(&transport, &resourceTable.rpmsg_vring0, &resourceTable.rpmsg_vring1, TO_ARM_HOST, FROM_ARM_HOST);

	/* Create the RPMsg channel between the PRU and ARM user space using the transport structure. */
	while (pru_rpmsg_channel(RPMSG_NS_CREATE, &transport, CHAN_NAME, CHAN_DESC, CHAN_PORT) != PRU_RPMSG_SUCCESS);
	pru_uart_initialize();

	while(1)
				{


						if (__R31 & HOST_INT) {
							//pru_uart_write(Txbuf,TxSize);
							CT_INTC.SICR_bit.STATUS_CLR_INDEX = FROM_ARM_HOST;


								while (pru_rpmsg_receive(&transport, &src, &dst, tmp, &len) != PRU_RPMSG_SUCCESS);





							}
			
						if(count==0)
							memcpy(payload,tmp,len);
						else
							
							memcpy(new_array,tmp,len);
					}

					if(count==0){


										for(CurrentPos=0;CurrentPos<=route_data_size-Tx_raw_size;CurrentPos+=SizeOfOffset)
													{
														pru_uart_read(Rxbuf,RxSize);

												
*/


//														uchar2uint(&ts_cur,Rxbuf+57,4);
//														ts_lcur = (ts_cur/20)%256 ;
														pru_rpmsg_send(&transport, dst, src, Rxbuf,RxSize+1);
														//problem here
														memcpy(Txbuf1,payload+CurrentPos,Tx_raw_size);//1 .&payload[CurrentPos],2.payload+CurrentPos,dont use 1

														//memcpy(&Txbuf1[120], IOData, OutputDataSize) ;
														//memcpy(&Txbuf1[136], &payload[244], PLCConveyorDataSize);
//														create_Tx_data(Txbuf, ts_lcur, 0, Txbuf1, Tx_data_size);
														pru_uart_write(Txbuf1,Tx_raw_size);
														


													}
							}
					else {


						for(time_counter=4;time_counter>0;time_counter--)
						{
							//i=4;
								CurrentPos=route_data_size-time_counter*SizeOfOffset;
									{
											memcpy(Txbuf1,payload+CurrentPos,time_counter*SizeOfOffset);

											memcpy(Txbuf1+time_counter*SizeOfOffset,new_array,Tx_raw_size-(time_counter*SizeOfOffset));
											pru_uart_read(Rxbuf,RxSize);
		//									uchar2uint(&ts_cur,Rxbuf+57,4);
		//									ts_lcur = (ts_cur/20)%256 ;
											pru_rpmsg_send(&transport,dst,src,Rxbuf,RxSize+1);
											//memcpy(&Txbuf1[120], IOData, OutputDataSize) ;
											//memcpy(&Txbuf1[136], &payload[244], PLCConveyorDataSize);
		//									create_Tx_data(Txbuf, ts_lcur, 0, Txbuf1, Tx_data_size);
											pru_uart_write(Txbuf1,Tx_raw_size);
											}
						}
						
						
					len=0;
					i=0;
					count=!count;


/*							//加一个pru_rpmsg_send 反馈?
							//pru_uart_read(Rxbuf,RxSize);
							//pru_rpmsg_send(&transport, dst, src, Rxbuf,RxSize);
							//pru_uart_write(Txbuf,TxSize);

								//while((CurrentPos+=SizeOfOffset*i)<Tx_raw_size)
	//						IOData=&payload[240];
	//						pru_rpmsg_send(&transport, dst, src, payload,len);
	//						pru_rpmsg_send(&transport, dst, src, IOData,iodata_len);

							//get the timestampe to fsignal->ts_cur
						pru_uart_write(Txbuf,TxSize*10);
							uchar2uint(&ts_cur,Rxbuf+57,4);
							ts_lcur = (ts_cur/20)%256 ;
							//while(len-(CurrentPos+=SizeOfOffset*i)>Tx_raw_size-2)
							for(CurrentPos=0;CurrentPos<=len-Tx_raw_size;CurrentPos+=SizeOfOffset*i)
								{

									if (__R31 & HOST_INT) {
										//pru_uart_write(Txbuf,TxSize);
										 Clear the event status
										CT_INTC.SICR_bit.STATUS_CLR_INDEX = FROM_ARM_HOST;
										while(pru_rpmsg_receive(&transport, &src, &dst, IOData, &iodata_len) == PRU_RPMSG_SUCCESS);//
										}
									if(CurrentPos==len-Tx_raw_size)
										//only 5*24 Bytes data left, call A15 to send route
										{

										memcpy(&Rxbuf[RxSize],"1",1);
										pru_rpmsg_send(&transport, dst, src, Rxbuf,RxSize+1);
										}
									if(payload[CurrentPos]!=i)
										pritnf("A15 to dsp data error !");
//									memcpy(Txbuf1,&payload[CurrentPos],Tx_raw_size);
//									memcpy(&Txbuf1[120], &payload[240], OutputDataSize) ;
//									memcpy(&Txbuf1[136], &payload[244], PLCConveyorDataSize);
//									create_Tx_data(Txbuf, ts_lcur, 0, Txbuf1, Tx_data_size);//i=0;i=1;i=2
//									pru_uart_write(Txbuf,TxSize);
									pru_uart_read(Rxbuf,RxSize);



									//pru_rpmsg_send(&transport, dst, src, Rxbuf,RxSize);
									i++;

								}
								i=0;*/



				}



}

/*
 * Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com/
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *	* Redistributions of source code must retain the above copyright
 *	  notice, this list of conditions and the following disclaimer.
 *
 *	* 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.
 *
 *	* Neither the name of Texas Instruments Incorporated 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.
 */

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/poll.h>
#include "realtime.h"
#include "timer.h"

// char readBuf[MAX_BUFFER_SIZE];


#define DEVICE_NAME		"/dev/rpmsg_pru30"

#define MY_PRIORITY 99 /*! we use 49 as the PRREMPT_RT use 50
                            as the priority of kernel tasklets
                            and interrupt handler by default */
#define TxSize 120*2	//!< transmission data frame size is 160 bytes

#define RxSize 64+1	//!< recieved data frame size is 64 bytes      
int main(void)
{
	static struct timespec t1,t2,ton,toff;
	float tdiff;
	struct pollfd pollfds[1];
	int i=0,j;
	int result = 0,result1 = 0,result2 = 0;

	unsigned char Txbuf[TxSize];	// 160!< define Tx data buffer, CHECK! what Ready_buf does
	unsigned char Rxbuf[RxSize];	// 64!< define Rx data buffer, CHECK! what Rxbuf does
	ton=tic();
	for(i=0;i<TxSize;i++)
		Txbuf[i]=i;
	make_realtime(getpid(), MY_PRIORITY);
	/* Open the rpmsg_pru character device file */
	pollfds[0].fd = open(DEVICE_NAME, O_RDWR);//| O_NDELAY | O_NOCTTY|O_NONBLOCK );

	/*
	 * If the RPMsg channel doesn't exist yet the character device
	 * won't either.
	 * Make sure the PRU firmware is loaded and that the rpmsg_pru
	 * module is inserted.
	 */
	if (pollfds[0].fd < 0) {
		printf("Failed to open %s\n", DEVICE_NAME);
		return -1;
	}

	/* The RPMsg channel exists and the character device is opened */
	printf("Opened %s\n", DEVICE_NAME);

	 while(1){
				result = write(pollfds[0].fd, Txbuf, TxSize);
				if(result>0)
					//printf("write Txbuf\n");
				
			//	for(i=0;i<8;i++)
					{					
					result2 = read(pollfds[0].fd, Rxbuf,RxSize);//block
					
					if (result2 > 0)
						{
						//printf("cost_time is %f\n",tdiff);
						for (i=0;i<RxSize;i++)
							printf("--%d",Rxbuf[i]);
						printf("\n");
						}
					}
			
	}

	toc(ton,&tdiff);
	printf("whole_process_cost %f\n",tdiff);
	/* Received all the messages the example is complete */
	printf("closing %s\n",DEVICE_NAME);

	/* Close the rpmsg_pru character device file */
	close(pollfds[0].fd);
	
	return 0;
}