1058 lines
35 KiB
C
1058 lines
35 KiB
C
/*
|
|
* logic_analyser_backend.c
|
|
* Implements the logic analyser backend to intereact with the GUI.
|
|
*
|
|
* Copyright (C) 2019, STMicroelectronics - All Rights Reserved
|
|
* Author: Michel Catrouillet michel.catrouillet@st.com for STMicroelectronics.
|
|
*
|
|
* License type: GPLv2
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 as published by
|
|
* the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
|
|
* or FITNESS FOR A PARTICULAR PURPOSE.
|
|
* See the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along with
|
|
* this program. If not, see
|
|
* http://www.gnu.org/licenses/.
|
|
* https://github.com/STMicroelectronics/meta-st-stm32mpu-app-logicanalyser/blob/kirkstone/recipes-graphics/st-software/logic-analyser-backend/backend.c
|
|
*/
|
|
|
|
#define _GNU_SOURCE /* To get DN_* constants from <fcntl.h> */
|
|
#include <signal.h>
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <termios.h>
|
|
#include <fcntl.h>
|
|
#include <inttypes.h>
|
|
#include <time.h>
|
|
#include <pthread.h>
|
|
#include <unistd.h> // for usleep
|
|
#include <math.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/time.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <sys/eventfd.h>
|
|
#include <sys/poll.h>
|
|
#include <regex.h>
|
|
#include <sched.h>
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <error.h>
|
|
#include <gtk/gtk.h>
|
|
|
|
#define SAMP_SRAM_PACKET_SIZE (256*2)
|
|
#define SAMP_DDR_BUFFER_SIZE (1024*1024)
|
|
|
|
#define TTY_CTRL_OPTS (CS8 | CLOCAL | CREAD)
|
|
#define TTY_INPUT_OPTS IGNPAR
|
|
#define TTY_OUTPUT_OPTS 0
|
|
#define TTY_LOCAL_OPTS 0
|
|
|
|
#define DATA_BUF_POOL_SIZE 1024*1024 /* 1MB */
|
|
#define MAX_BUF 80
|
|
|
|
#define PORT 8888
|
|
#define GET 0
|
|
#define POST 1
|
|
#define POSTBUFFERSIZE 512
|
|
|
|
#define DMA_DDR_BUFF 1
|
|
#define PHYS_RESERVED_REGION_ADDR 0xdb000000
|
|
#define PHYS_RESERVED_REGION_SIZE 0x1000000
|
|
|
|
#define RPMSG_SDB_IOCTL_SET_EFD _IOW('R', 0x00, struct rpmsg_sdb_ioctl_set_efd *)
|
|
#define RPMSG_SDB_IOCTL_GET_DATA_SIZE _IOWR('R', 0x01, struct rpmsg_sdb_ioctl_get_data_size *)
|
|
|
|
#define TIMEOUT 60
|
|
#define NB_BUF 10
|
|
|
|
typedef struct
|
|
{
|
|
int bufferId, eventfd;
|
|
} rpmsg_sdb_ioctl_set_efd;
|
|
|
|
typedef struct
|
|
{
|
|
int bufferId;
|
|
uint32_t size;
|
|
} rpmsg_sdb_ioctl_get_data_size;
|
|
|
|
struct connection_info_struct
|
|
{
|
|
int connectiontype;
|
|
char *answerstring;
|
|
struct MHD_PostProcessor *postprocessor;
|
|
};
|
|
|
|
struct MHD_Daemon *mHttpDaemon;
|
|
|
|
char FIRM_NAME[50];
|
|
struct timeval tval_before, tval_after, tval_result;
|
|
|
|
typedef enum {
|
|
STATE_READY = 0,
|
|
STATE_SAMPLING_LOW,
|
|
STATE_SAMPLING_HIGH,
|
|
} machine_state_t;
|
|
|
|
static char machine_state_str[5][13] = {"READY", "SAMPLING_LOW", "SAMPLING_HIGH"};
|
|
static char SELECTED[10] = {" selected"};
|
|
static char NOT_SELECTED[10] = {""};
|
|
static char freq_unit_str[3][4] = {"MHz", "kHz", "Hz"};
|
|
static char FREQU[3] = {'M', 'k', 'H'};
|
|
|
|
/* The file descriptor used to manage our TTY over RPMSG */
|
|
static int mFdRpmsg[2] = {-1, -1};
|
|
|
|
/* The file descriptor used to manage our SDB over RPMSG */
|
|
static int mFdSdbRpmsg = -1;
|
|
|
|
static int virtual_tty_send_command(int len, char* commandStr);
|
|
|
|
static char mByteBuffer[512];
|
|
static char mByteBuffCpy[512];
|
|
static int mNbReadTty = 0;
|
|
|
|
static char mRxTraceBuffer[512];
|
|
|
|
static char mSamplingStr[15];
|
|
static int32_t mSampFreq_Hz = 4;
|
|
static machine_state_t mMachineState;
|
|
static int32_t mSampParmCount;
|
|
static uint8_t mExitRequested = 0, mErrorDetected = 0;
|
|
static uint32_t mNbUncompData=0, mNbWrittenInFileData;
|
|
static uint32_t mNbUncompMB=0, mNbPrevUncompMB=0, mNbTty0Frame=0;
|
|
static uint8_t mDdrBuffAwaited;
|
|
static uint8_t mThreadCancel = 0;
|
|
|
|
void* mmappedData[NB_BUF];
|
|
static int fMappedData = 0;
|
|
FILE *pOutFile = NULL;
|
|
static char mFileNameStr[150];
|
|
static pthread_t threadTTY, threadSDB, threadUI;
|
|
|
|
static int efd[NB_BUF];
|
|
static struct pollfd fds[NB_BUF];
|
|
|
|
static GtkWidget *window;
|
|
static GtkWidget *f_scale;
|
|
static GtkAdjustment *fadjustment;
|
|
|
|
static GtkWidget *controlTitle_label;
|
|
static GtkWidget *fTitle_label;
|
|
static GtkWidget *fValue_label;
|
|
static GtkWidget *measurTitle_label;
|
|
static GtkWidget *state_label;
|
|
static GtkWidget *state_value;
|
|
static GtkWidget *nbCompData_label;
|
|
static GtkWidget *nbCompData_value;
|
|
static GtkWidget *nbRealData_label;
|
|
static GtkWidget *nbRealData_value;
|
|
static GtkWidget *nbRpmsgFrame_label ;
|
|
static GtkWidget *nbRpmsgFrame_value;
|
|
static GtkWidget *data_label;
|
|
static GtkWidget *data_value;
|
|
static GtkWidget *butSingle;
|
|
static GtkWidget *notchSetdata;
|
|
|
|
/********************************************************************************
|
|
Copro functions allowing to manage a virtual TTY over RPMSG
|
|
*********************************************************************************/
|
|
int copro_isFwRunning(void)
|
|
{
|
|
int fd;
|
|
size_t byte_read;
|
|
int result = 0;
|
|
unsigned char bufRead[MAX_BUF];
|
|
char *user = getenv("USER");
|
|
if (user && strncmp(user, "root", 4)) {
|
|
system("XTERM=xterm su root -c 'cat /sys/class/remoteproc/remoteproc0/state' > /tmp/remoteproc0_state");
|
|
fd = open("/tmp/remoteproc0_state", O_RDONLY);
|
|
} else {
|
|
fd = open("/sys/class/remoteproc/remoteproc0/state", O_RDONLY);
|
|
}
|
|
if (fd < 0) {
|
|
printf("CA7 : Error opening remoteproc0/state, err=-%d\n", errno);
|
|
return (errno * -1);
|
|
}
|
|
byte_read = (size_t) read (fd, bufRead, MAX_BUF);
|
|
if (byte_read >= strlen("running")) {
|
|
char* pos = strstr((char*)bufRead, "running");
|
|
if(pos) {
|
|
result = 1;
|
|
}
|
|
}
|
|
close(fd);
|
|
return result;
|
|
}
|
|
|
|
int copro_stopFw(void)
|
|
{
|
|
int fd;
|
|
char *user = getenv("USER");
|
|
if (user && strncmp(user, "root",4)) {
|
|
system("su root -c 'echo stop > /sys/class/remoteproc/remoteproc0/state'");
|
|
return 0;
|
|
}
|
|
fd = open("/sys/class/remoteproc/remoteproc0/state", O_RDWR);
|
|
if (fd < 0) {
|
|
printf("CA7 : Error opening remoteproc0/state, err=-%d\n", errno);
|
|
return (errno * -1);
|
|
}
|
|
write(fd, "stop", strlen("stop"));
|
|
close(fd);
|
|
return 0;
|
|
}
|
|
|
|
int copro_startFw(void)
|
|
{
|
|
int fd;
|
|
char *user = getenv("USER");
|
|
if (user && strncmp(user, "root",4)) {
|
|
system("su root -c 'echo start > /sys/class/remoteproc/remoteproc0/state'");
|
|
return 0;
|
|
}
|
|
fd = open("/sys/class/remoteproc/remoteproc0/state", O_RDWR);
|
|
if (fd < 0) {
|
|
printf("CA7 : Error opening remoteproc0/state, err=-%d\n", errno);
|
|
return (errno * -1);
|
|
}
|
|
write(fd, "start", strlen("start"));
|
|
close(fd);
|
|
return 0;
|
|
}
|
|
|
|
int copro_getFwPath(char* pathStr)
|
|
{
|
|
int fd;
|
|
int byte_read;
|
|
char *user = getenv("USER");
|
|
if (user && strncmp(user, "root",4)) {
|
|
system("XTERM=xterm su root -c 'cat /sys/module/firmware_class/parameters/path' > /tmp/parameters_path");
|
|
fd = open("/tmp/parameters_path", O_RDONLY);
|
|
} else {
|
|
fd = open("/sys/module/firmware_class/parameters/path", O_RDONLY);
|
|
}
|
|
if (fd < 0) {
|
|
printf("CA7 : Error opening firmware_class/parameters/path, err=-%d\n", errno);
|
|
return (errno * -1);
|
|
}
|
|
byte_read = read (fd, pathStr, MAX_BUF);
|
|
close(fd);
|
|
return byte_read;
|
|
}
|
|
|
|
int copro_setFwPath(char* pathStr)
|
|
{
|
|
int fd;
|
|
int result = 0;
|
|
char *user = getenv("USER");
|
|
if (user && strncmp(user, "root",4)) {
|
|
char cmd[1024];
|
|
snprintf(cmd, 1024, "su root -c 'echo %s > /sys/module/firmware_class/parameters/path'", pathStr);
|
|
system(cmd);
|
|
return strlen(pathStr);
|
|
}
|
|
fd = open("/sys/module/firmware_class/parameters/path", O_RDWR);
|
|
if (fd < 0) {
|
|
printf("CA7 : Error opening firmware_class/parameters/path, err=-%d\n", errno);
|
|
return (errno * -1);
|
|
}
|
|
result = write(fd, pathStr, strlen(pathStr));
|
|
close(fd);
|
|
return result;
|
|
}
|
|
|
|
int copro_getFwName(char* pathStr)
|
|
{
|
|
int fd;
|
|
int byte_read;
|
|
char *user = getenv("USER");
|
|
if (user && strncmp(user, "root",4)) {
|
|
system("XTERM=xterm su root -c 'cat /sys/class/remoteproc/remoteproc0/firmware' > /tmp/remoteproc0_firmware");
|
|
fd = open("/tmp/remoteproc0_firmware", O_RDONLY);
|
|
} else {
|
|
fd = open("/sys/class/remoteproc/remoteproc0/firmware", O_RDWR);
|
|
}
|
|
if (fd < 0) {
|
|
printf("CA7 : Error opening remoteproc0/firmware, err=-%d\n", errno);
|
|
return (errno * -1);
|
|
}
|
|
byte_read = read (fd, pathStr, MAX_BUF);
|
|
close(fd);
|
|
return byte_read;
|
|
}
|
|
|
|
int copro_setFwName(char* nameStr)
|
|
{
|
|
int fd;
|
|
int result = 0;
|
|
char *user = getenv("USER");
|
|
if (user && strncmp(user, "root",4)) {
|
|
char cmd[1024];
|
|
snprintf(cmd, 1024, "su root -c 'echo %s > /sys/class/remoteproc/remoteproc0/firmware'", nameStr);
|
|
system(cmd);
|
|
return strlen(nameStr);
|
|
}
|
|
fd = open("/sys/class/remoteproc/remoteproc0/firmware", O_RDWR);
|
|
if (fd < 0) {
|
|
printf("CA7 : Error opening remoteproc0/firmware, err=-%d\n", errno);
|
|
return (errno * -1);
|
|
}
|
|
result = write(fd, nameStr, strlen(nameStr));
|
|
close(fd);
|
|
return result;
|
|
}
|
|
|
|
int copro_openTtyRpmsg(int ttyNb, int modeRaw)
|
|
{
|
|
struct termios tiorpmsg;
|
|
char devName[50];
|
|
sprintf(devName, "/dev/ttyRPMSG%d", ttyNb%2);
|
|
mFdRpmsg[ttyNb%2] = open(devName, O_RDWR | O_NOCTTY | O_NONBLOCK);
|
|
if (mFdRpmsg[ttyNb%2] < 0) {
|
|
printf("CA7 : Error opening ttyRPMSG%d, err=-%d\n", ttyNb%2, errno);
|
|
return (errno * -1);
|
|
}
|
|
#if 1
|
|
/* get current port settings */
|
|
tcgetattr(mFdRpmsg[ttyNb%2],&tiorpmsg);
|
|
if (modeRaw) {
|
|
#if 0
|
|
tiorpmsg.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP
|
|
| INLCR | IGNCR | ICRNL | IXON);
|
|
tiorpmsg.c_oflag &= ~OPOST;
|
|
tiorpmsg.c_lflag &= ~(ECHO | ECHONL | ICANON | ISIG | IEXTEN);
|
|
tiorpmsg.c_cflag &= ~(CSIZE | PARENB);
|
|
tiorpmsg.c_cflag |= CS8;
|
|
#else
|
|
memset(&tiorpmsg, 0, sizeof(tiorpmsg));
|
|
tiorpmsg.c_cflag = TTY_CTRL_OPTS;
|
|
tiorpmsg.c_iflag = TTY_INPUT_OPTS;
|
|
tiorpmsg.c_oflag = TTY_OUTPUT_OPTS;
|
|
tiorpmsg.c_lflag = TTY_LOCAL_OPTS;
|
|
tiorpmsg.c_cc[VTIME] = 0;
|
|
tiorpmsg.c_cc[VMIN] = 1;
|
|
cfmakeraw(&tiorpmsg);
|
|
#endif
|
|
} else {
|
|
/* ECHO off, other bits unchanged */
|
|
tiorpmsg.c_lflag &= ~ECHO;
|
|
/*do not convert LF to CR LF */
|
|
tiorpmsg.c_oflag &= ~ONLCR;
|
|
}
|
|
if (tcsetattr(mFdRpmsg[ttyNb%2], TCSANOW, &tiorpmsg) < 0) {
|
|
printf("Error %d in copro_openTtyRpmsg(%d) tcsetattr", errno, ttyNb);
|
|
return (errno * -1);
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
int copro_closeTtyRpmsg(int ttyNb)
|
|
{
|
|
close(mFdRpmsg[ttyNb%2]);
|
|
mFdRpmsg[ttyNb%2] = -1;
|
|
return 0;
|
|
}
|
|
|
|
int copro_writeTtyRpmsg(int ttyNb, int len, char* pData)
|
|
{
|
|
int result = 0;
|
|
if (mFdRpmsg[ttyNb%2] < 0) {
|
|
printf("CA7 : Error writing ttyRPMSG%d, fileDescriptor is not set\n", ttyNb%2);
|
|
return mFdRpmsg[ttyNb%2];
|
|
}
|
|
|
|
result = write(mFdRpmsg[ttyNb%2], pData, len);
|
|
return result;
|
|
}
|
|
|
|
int copro_readTtyRpmsg(int ttyNb, int len, char* pData)
|
|
{
|
|
int byte_rd, byte_avail;
|
|
int result = 0;
|
|
if (mFdRpmsg[ttyNb%2] < 0) {
|
|
printf("CA7 : Error reading ttyRPMSG%d, fileDescriptor is not set\n", ttyNb%2);
|
|
return mFdRpmsg[ttyNb%2];
|
|
}
|
|
ioctl(mFdRpmsg[ttyNb%2], FIONREAD, &byte_avail);
|
|
if (byte_avail > 0) {
|
|
if (byte_avail >= len) {
|
|
byte_rd = read (mFdRpmsg[ttyNb%2], pData, len);
|
|
} else {
|
|
byte_rd = read (mFdRpmsg[ttyNb%2], pData, byte_avail);
|
|
}
|
|
//printf("CA7 : read successfully %d bytes to %p, [0]=0x%x\n", byte_rd, pData, pData[0]);
|
|
result = byte_rd;
|
|
} else {
|
|
result = 0;
|
|
}
|
|
return result;
|
|
}
|
|
/********************************************************************************
|
|
End of Copro functions
|
|
*********************************************************************************/
|
|
|
|
void
|
|
print_time() {
|
|
struct timespec ts;
|
|
clock_gettime(1, &ts);
|
|
printf("Time: %lld\n", (ts.tv_sec * 1000LL) + (ts.tv_nsec / 1000000LL));
|
|
}
|
|
|
|
/********************************************************************************
|
|
GTK UI functions
|
|
*********************************************************************************/
|
|
static void
|
|
open_raw_file(void) {
|
|
time_t t = time(NULL);
|
|
struct tm tm = *localtime(&t);
|
|
sprintf(mFileNameStr, "/usr/local/demo/la/%04d%02d%02d-%02d%02d%02d.dat",
|
|
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
|
|
pOutFile = fopen(mFileNameStr,"wb");
|
|
}
|
|
|
|
static int32_t
|
|
write_raw_file(unsigned char* pData, unsigned int size) {
|
|
// perform the write by packets of 4kB
|
|
int rest2write = size;
|
|
int index = 0;
|
|
int size2write = 4096;
|
|
int writtenSize = 0;
|
|
do {
|
|
if (rest2write < 4096) {
|
|
size2write = rest2write;
|
|
}
|
|
writtenSize += fwrite(pData+index, 1, size2write, pOutFile);
|
|
rest2write -= size2write;
|
|
index += size2write;
|
|
} while (rest2write > 0);
|
|
return writtenSize;
|
|
}
|
|
|
|
static void
|
|
close_raw_file(void) {
|
|
if (pOutFile != NULL) {
|
|
fclose(pOutFile);
|
|
pOutFile = NULL;
|
|
}
|
|
}
|
|
|
|
static gboolean refreshUI_CB (gpointer data)
|
|
{
|
|
char tmpStr[200];
|
|
|
|
if (mMachineState >= STATE_SAMPLING_LOW) {
|
|
gtk_button_set_label (GTK_BUTTON (butSingle), "Stop");
|
|
} else {
|
|
gtk_button_set_label (GTK_BUTTON (butSingle), "Start");
|
|
}
|
|
gtk_label_set_text (GTK_LABEL (state_value), machine_state_str[mMachineState]);
|
|
sprintf(tmpStr, "%uMB : %u", mNbUncompMB, mNbUncompData);
|
|
gtk_label_set_text (GTK_LABEL (nbRealData_value), tmpStr);
|
|
sprintf(tmpStr, "%u", mNbTty0Frame);
|
|
gtk_label_set_text (GTK_LABEL (nbRpmsgFrame_value), tmpStr);
|
|
//gtk_label_set_text (GTK_LABEL (fileName_value), mFileNameStr);
|
|
sprintf(tmpStr, "%x", mByteBuffCpy[0]);
|
|
gtk_label_set_text (GTK_LABEL (data_value), tmpStr);
|
|
|
|
gtk_widget_show_all(window);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static void single_clicked (GtkWidget *widget, gpointer data)
|
|
{
|
|
char setData = 'n';
|
|
if (mMachineState == STATE_READY) {
|
|
if (mSampFreq_Hz > 5) {
|
|
mMachineState = STATE_SAMPLING_HIGH;
|
|
} else {
|
|
mMachineState = STATE_SAMPLING_LOW;
|
|
}
|
|
mNbUncompData=0;
|
|
mNbPrevUncompMB = 0;
|
|
mNbUncompMB = 0;
|
|
mNbWrittenInFileData=0;
|
|
mDdrBuffAwaited=0;
|
|
mNbTty0Frame=0;
|
|
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (notchSetdata))) {
|
|
setData = 'y';
|
|
}
|
|
// build sampling string
|
|
sprintf(mSamplingStr, "S%03dMs%c", mSampFreq_Hz, setData);
|
|
printf("CA7 : Start sampling at %dMHz\n", mSampFreq_Hz);
|
|
virtual_tty_send_command(strlen(mSamplingStr), mSamplingStr);
|
|
gdk_threads_add_idle (refreshUI_CB, window);
|
|
} else if (mMachineState >= STATE_SAMPLING_LOW) {
|
|
mMachineState = STATE_READY;
|
|
printf("CA7 : Stop sampling\n");
|
|
virtual_tty_send_command(strlen("Exit"), "Exit");
|
|
gdk_threads_add_idle (refreshUI_CB, window);
|
|
} else {
|
|
printf("CA7 : Start sampling param error: mMachineState=%d mSampFreq_Hz=%d \n",
|
|
mMachineState, mSampFreq_Hz);
|
|
}
|
|
}
|
|
|
|
static void f_scale_moved (GtkRange *range, gpointer user_data)
|
|
{
|
|
GtkWidget *label = user_data;
|
|
|
|
gdouble pos = gtk_range_get_value (range);
|
|
gdouble val = 1 + 11 * pos / 100;
|
|
gchar *str = g_strdup_printf ("%.0f", val);
|
|
mSampFreq_Hz = atoi(str);
|
|
gtk_label_set_text (GTK_LABEL (label), str);
|
|
printf("CA7 : fscale = %d\n", mSampFreq_Hz);
|
|
|
|
g_free(str);
|
|
}
|
|
|
|
void *ui_thread(void *arg)
|
|
{
|
|
|
|
GtkWidget *mainGrid;
|
|
char tmpStr[100];
|
|
|
|
time_t t = time(NULL);
|
|
struct tm tm = *localtime(&t);
|
|
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
|
gtk_window_set_title (GTK_WINDOW (window), "STHowToM4ToA7LargeDataExchange");
|
|
g_signal_connect (window, "destroy",
|
|
G_CALLBACK (gtk_main_quit), NULL);
|
|
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
|
|
gtk_window_fullscreen(GTK_WINDOW (window));
|
|
|
|
GtkCssProvider *provider = gtk_css_provider_new ();
|
|
gtk_css_provider_load_from_path (provider, "/usr/local/demo/la/bin/la.css", NULL);
|
|
|
|
GdkDisplay* Display = gdk_display_get_default();
|
|
GdkScreen* Screen = gdk_display_get_default_screen(Display);
|
|
gtk_style_context_add_provider_for_screen(Screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_USER);
|
|
|
|
controlTitle_label = gtk_label_new ("Control");
|
|
gtk_widget_set_name(controlTitle_label, "title1");
|
|
|
|
fTitle_label = gtk_label_new ("Sampling freq. (MHz) :");
|
|
gtk_label_set_xalign (GTK_LABEL (fTitle_label), 0);
|
|
gtk_widget_set_name(fTitle_label, "header");
|
|
|
|
fValue_label = gtk_label_new ("4");
|
|
gtk_label_set_xalign (GTK_LABEL (fValue_label), 0);
|
|
gtk_widget_set_name(fValue_label, "value");
|
|
|
|
fadjustment = gtk_adjustment_new (16, 0, 100, 5, 10, 0);
|
|
f_scale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, fadjustment);
|
|
gtk_scale_set_draw_value (GTK_SCALE (f_scale), FALSE);
|
|
g_object_set (GTK_SCALE (f_scale), "expand", TRUE, NULL);
|
|
|
|
g_signal_connect (f_scale,
|
|
"value-changed",
|
|
G_CALLBACK (f_scale_moved),
|
|
fValue_label);
|
|
|
|
measurTitle_label = gtk_label_new ("Measurements");
|
|
gtk_widget_set_name(measurTitle_label, "title1");
|
|
|
|
state_label = gtk_label_new ("Machine state :");
|
|
gtk_label_set_xalign (GTK_LABEL (state_label), 0);
|
|
gtk_widget_set_name(state_label, "header");
|
|
state_value = gtk_label_new ("");
|
|
gtk_label_set_xalign (GTK_LABEL (state_value), 0);
|
|
gtk_widget_set_name(state_value, "value");
|
|
|
|
nbRealData_label = gtk_label_new ("Nb of received data :");
|
|
gtk_label_set_xalign (GTK_LABEL (nbRealData_label), 0);
|
|
gtk_widget_set_name(nbRealData_label, "header");
|
|
nbRealData_value = gtk_label_new ("");
|
|
gtk_label_set_xalign (GTK_LABEL (nbRealData_value), 0);
|
|
gtk_widget_set_name(nbRealData_value, "value");
|
|
|
|
nbRpmsgFrame_label = gtk_label_new ("Nb of RPMSG data frame :");
|
|
gtk_label_set_xalign (GTK_LABEL (nbRpmsgFrame_label ), 0);
|
|
gtk_widget_set_name(nbRpmsgFrame_label, "header");
|
|
|
|
nbRpmsgFrame_value = gtk_label_new ("");
|
|
gtk_label_set_xalign (GTK_LABEL (nbRpmsgFrame_value), 0);
|
|
gtk_widget_set_name(nbRpmsgFrame_value, "value");
|
|
|
|
data_label = gtk_label_new ("Data :");
|
|
gtk_label_set_xalign (GTK_LABEL (data_label), 0);
|
|
gtk_widget_set_name(data_label, "header");
|
|
|
|
data_value = gtk_label_new ("");
|
|
gtk_label_set_xalign (GTK_LABEL (data_value), 0);
|
|
gtk_widget_set_name(data_value, "value");
|
|
|
|
gtk_label_set_text (GTK_LABEL (state_value), machine_state_str[mMachineState]);
|
|
sprintf(tmpStr, "%u", mNbUncompData);
|
|
gtk_label_set_text (GTK_LABEL (nbCompData_value), tmpStr);
|
|
sprintf(tmpStr, "%u", mNbUncompData);
|
|
gtk_label_set_text (GTK_LABEL (nbRealData_value), tmpStr);
|
|
sprintf(tmpStr, "%u", mNbWrittenInFileData);
|
|
gtk_label_set_text (GTK_LABEL (nbRpmsgFrame_value), tmpStr);
|
|
|
|
butSingle = gtk_button_new_with_label("Start");
|
|
g_signal_connect(butSingle,
|
|
"clicked",
|
|
G_CALLBACK (single_clicked),
|
|
NULL);
|
|
gtk_style_context_add_class(
|
|
gtk_widget_get_style_context(GTK_WIDGET(butSingle)), "circular");
|
|
gtk_widget_set_name(butSingle, "mybutt");
|
|
|
|
notchSetdata = gtk_check_button_new_with_label("Set DATA");
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(notchSetdata), FALSE);
|
|
|
|
|
|
mainGrid = gtk_grid_new ();
|
|
gtk_grid_set_row_spacing (GTK_GRID (mainGrid), 5);
|
|
gtk_grid_set_column_spacing (GTK_GRID (mainGrid), 20);
|
|
// Control title in (0,0) is 3 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), controlTitle_label, 0, 0, 3, 1);
|
|
// Freq. title in (0,1) is 1 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), fTitle_label, 0, 1, 1, 1);
|
|
// Freq. value in (1,1) is 1 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), fValue_label, 1, 1, 1, 1);
|
|
// Freq. scale in (2,1) is 1 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), f_scale, 2, 1, 1, 1);
|
|
|
|
// Start button in (0,2) is 2 column large & 2 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), butSingle, 0, 2, 2, 2);
|
|
|
|
// SetDATA notch in (3,2) is 2 column large & 2 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), notchSetdata, 2, 2, 2, 1);
|
|
|
|
// Measurement title in (0,4) is 3 columns large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), measurTitle_label, 0, 4, 3, 1);
|
|
// State label in (0,5) is 2 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), state_label, 0, 5, 2, 1);
|
|
// State value in (2,5) is 2 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), state_value, 2, 5, 2, 1);
|
|
|
|
// Real data label in (0,7) is 2 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), nbRealData_label, 0, 6, 2, 1);
|
|
// Real data value in (2,7) is 2 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), nbRealData_value, 2, 6, 2, 1);
|
|
|
|
// Nb of RPMSG frame label in (0,8) is 2 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), nbRpmsgFrame_label, 0, 7, 2, 1);
|
|
// Nb of RPMSG frame value in (2,8) is 2 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), nbRpmsgFrame_value, 2, 7, 2, 1);
|
|
|
|
|
|
// Data label in (0,9) is 2 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), data_label, 0, 8, 2, 1);
|
|
// File name value in (2,9) is 2 column large & 1 row high
|
|
gtk_grid_attach (GTK_GRID (mainGrid), data_value, 2, 8, 2, 1);
|
|
|
|
gtk_grid_set_row_homogeneous (GTK_GRID (mainGrid), TRUE);
|
|
|
|
gtk_container_add (GTK_CONTAINER (window), mainGrid);
|
|
|
|
gtk_widget_show_all(window);
|
|
|
|
|
|
gtk_main ();
|
|
return 0;
|
|
}
|
|
|
|
/*************************************************************************************
|
|
End of GTK UI functions
|
|
*************************************************************************************/
|
|
|
|
static void sleep_ms(int milliseconds)
|
|
{
|
|
usleep(milliseconds * 1000);
|
|
}
|
|
|
|
static int virtual_tty_send_command(int len, char* commandStr) {
|
|
|
|
struct timespec ts;
|
|
clock_gettime(1, &ts);
|
|
printf("CA7 [%lld] : virtual_tty_send_command len=%d => %s\n",
|
|
(ts.tv_sec * 1000LL) + (ts.tv_nsec / 1000000LL), len, commandStr);
|
|
return copro_writeTtyRpmsg(0, len, commandStr);
|
|
}
|
|
|
|
size_t getFilesize(const char* filename) {
|
|
struct stat st;
|
|
stat(filename, &st);
|
|
return st.st_size;
|
|
}
|
|
|
|
void incatchr(int signum){
|
|
printf("%s!\n",__func__);
|
|
}
|
|
|
|
void exit_fct(int signum)
|
|
{
|
|
gtk_main_quit();
|
|
mThreadCancel = 1;
|
|
sleep_ms(100);
|
|
if (fMappedData) {
|
|
for (int i=0;i<NB_BUF;i++){
|
|
int rc = munmap(mmappedData[i], DATA_BUF_POOL_SIZE);
|
|
assert(rc == 0);
|
|
}
|
|
fMappedData = 0;
|
|
printf("CA7 : Buffers successfully unmapped\n");
|
|
}
|
|
|
|
if (copro_isFwRunning()) {
|
|
mExitRequested = 1;
|
|
//while (mExitRequested);
|
|
close(mFdSdbRpmsg);
|
|
mFdSdbRpmsg = -1;
|
|
copro_closeTtyRpmsg(0);
|
|
copro_closeTtyRpmsg(1);
|
|
copro_stopFw();
|
|
printf("CA7 : stop the firmware before exit\n");
|
|
}
|
|
#if 0
|
|
if (pOutFile != NULL) {
|
|
printf("CA7 : closing file before exit\n");
|
|
close_raw_file();
|
|
}
|
|
#endif
|
|
exit(signum);
|
|
}
|
|
|
|
void *virtual_tty_thread(void *arg)
|
|
{
|
|
int read0, read1;
|
|
int32_t wsize;
|
|
int nb2copy = 0;
|
|
char cmdmsg[20];
|
|
|
|
// open tty0
|
|
if (copro_openTtyRpmsg(0, 1)) {
|
|
printf("CA7 : fails to open the ttyRPMSG0\n");
|
|
return (errno * -1);
|
|
}
|
|
//system("stty -F /dev/ttyRPMGS0 -isig");
|
|
|
|
// needed to allow M4 to send any data over virtualTTY
|
|
copro_writeTtyRpmsg(0, 1, "r");
|
|
|
|
// open tty1
|
|
if (copro_openTtyRpmsg(1, 1)) {
|
|
printf("CA7 : fails to open the ttyRPMSG0\n");
|
|
return (errno * -1);
|
|
}
|
|
// needed to allow M4 to send any data over virtualTTY
|
|
copro_writeTtyRpmsg(1, 1, "r");
|
|
|
|
usleep(500000);
|
|
sprintf(cmdmsg, "B%02d", NB_BUF);
|
|
copro_writeTtyRpmsg(0, strlen(cmdmsg), cmdmsg);
|
|
|
|
while (1) {
|
|
if (mThreadCancel) break; // kill thread requested
|
|
|
|
// tty0 is used for low rate compressed data transfer (less or equal to 5MHz sampling)
|
|
read0 = copro_readTtyRpmsg(0, SAMP_SRAM_PACKET_SIZE, mByteBuffer);
|
|
if (read0 > 0) {
|
|
mNbTty0Frame++;
|
|
mNbUncompData += read0;
|
|
|
|
mNbUncompMB = mNbUncompData / 1024 / 1024;
|
|
if (mNbUncompMB != mNbPrevUncompMB) {
|
|
// a new MB has been received, update display
|
|
mNbPrevUncompMB = mNbUncompMB;
|
|
mByteBuffCpy[0] = mByteBuffer[0];
|
|
gdk_threads_add_idle (refreshUI_CB, window);
|
|
}
|
|
}
|
|
|
|
// tty1 is dedicated to trace of M4
|
|
read1 = copro_readTtyRpmsg(1, 512, mRxTraceBuffer);
|
|
mRxTraceBuffer[read1] = 0; // to be sure to get a end of string
|
|
if (read1 > 0) {
|
|
if (strcmp(mRxTraceBuffer, "CM4 : DMA TransferError") == 0) {
|
|
// sampling is aborted, refresh the UI
|
|
mErrorDetected = 1;
|
|
//mMachineState = STATE_READY;
|
|
//gdk_threads_add_idle (refreshUI_CB, window);
|
|
}
|
|
gettimeofday(&tval_after, NULL);
|
|
timersub(&tval_after, &tval_before, &tval_result);
|
|
if (mRxTraceBuffer[0] == 'C') {
|
|
printf("[%ld.%06ld] : %s\n",
|
|
(long int)tval_result.tv_sec, (long int)tval_result.tv_usec,
|
|
mRxTraceBuffer);
|
|
} else {
|
|
printf("[%ld.%06ld] : CA7 : tty1 got %d [%x] bytes\n",
|
|
(long int)tval_result.tv_sec, (long int)tval_result.tv_usec,
|
|
read1, mRxTraceBuffer[0]);
|
|
}
|
|
}
|
|
//usleep(500);
|
|
|
|
//sleep_ms(1); // give time to UI
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void *sdb_thread(void *arg)
|
|
{
|
|
int ret, rc, i, n;
|
|
int buffIdx = 0;
|
|
char buf[16];
|
|
char dbgmsg[80];
|
|
rpmsg_sdb_ioctl_get_data_size q_get_data_size;
|
|
char *filename = "/dev/rpmsg-sdb";
|
|
rpmsg_sdb_ioctl_set_efd q_set_efd;
|
|
|
|
mFdSdbRpmsg = open(filename, O_RDWR);
|
|
assert(mFdSdbRpmsg != -1);
|
|
for (i=0;i<NB_BUF;i++){
|
|
// Create the evenfd, and sent it to kernel driver, for notification of buffer full
|
|
efd[i] = eventfd(0, 0);
|
|
if (efd[i] == -1)
|
|
error(EXIT_FAILURE, errno,
|
|
"failed to get eventfd");
|
|
printf("\nCA7 : Forward efd info for buf%d with mFdSdbRpmsg:%d and efd:%d\n",i,mFdSdbRpmsg,efd[i]);
|
|
q_set_efd.bufferId = i;
|
|
q_set_efd.eventfd = efd[i];
|
|
if(ioctl(mFdSdbRpmsg, RPMSG_SDB_IOCTL_SET_EFD, &q_set_efd) < 0)
|
|
error(EXIT_FAILURE, errno,
|
|
"failed to set efd");
|
|
// watch eventfd for input
|
|
fds[i].fd = efd[i];
|
|
fds[i].events = POLLIN;
|
|
mmappedData[i] = mmap(NULL,
|
|
DATA_BUF_POOL_SIZE,
|
|
PROT_READ | PROT_WRITE,
|
|
MAP_PRIVATE,
|
|
mFdSdbRpmsg,
|
|
0);
|
|
printf("\nCA7 : DBG mmappedData[%d]:%p\n", i, mmappedData[i]);
|
|
assert(mmappedData[i] != MAP_FAILED);
|
|
fMappedData = 1;
|
|
sleep_ms(50);
|
|
}
|
|
|
|
while (1) {
|
|
if (mMachineState == STATE_SAMPLING_HIGH) {
|
|
// wait till at least one buffer becomes available
|
|
ret = poll(fds, NB_BUF, TIMEOUT * 1000);
|
|
if (ret == -1)
|
|
perror("poll()");
|
|
else if (ret == 0){
|
|
printf("CA7 : No buffer data within %d seconds.\n", TIMEOUT);
|
|
}
|
|
if (fds[mDdrBuffAwaited].revents & POLLIN) {
|
|
rc = read(efd[mDdrBuffAwaited], buf, 16);
|
|
if (!rc) {
|
|
printf("CA7 : stdin closed\n");
|
|
return 0;
|
|
}
|
|
/* Get buffer data size*/
|
|
q_get_data_size.bufferId = mDdrBuffAwaited;
|
|
|
|
if(ioctl(mFdSdbRpmsg, RPMSG_SDB_IOCTL_GET_DATA_SIZE, &q_get_data_size) < 0) {
|
|
error(EXIT_FAILURE, errno, "Failed to get data size");
|
|
}
|
|
|
|
if (q_get_data_size.size) {
|
|
mNbUncompMB++;
|
|
mNbUncompData += q_get_data_size.size;
|
|
unsigned char* pData = (unsigned char*)mmappedData[mDdrBuffAwaited];
|
|
// save a copy of 1st data
|
|
mByteBuffCpy[0] = *pData;
|
|
gettimeofday(&tval_after, NULL);
|
|
timersub(&tval_after, &tval_before, &tval_result);
|
|
printf("[%ld.%06ld] sdb_thread data EVENT mDdrBuffAwaited=%d mNbUncompData=%u \n",
|
|
(long int)tval_result.tv_sec, (long int)tval_result.tv_usec, mDdrBuffAwaited,
|
|
mNbUncompData);
|
|
gdk_threads_add_idle (refreshUI_CB, window);
|
|
}
|
|
else {
|
|
printf("CA7 : sdb_thread => buf[%d] is empty\n", mDdrBuffAwaited);
|
|
}
|
|
mDdrBuffAwaited++;
|
|
if (mDdrBuffAwaited >= NB_BUF) {
|
|
mDdrBuffAwaited = 0;
|
|
}
|
|
} else {
|
|
// we face message lost due to SDB driver not managing RPMSG DATA containing several messages
|
|
// in this case, just treat several message
|
|
mDdrBuffAwaited++;
|
|
if (mDdrBuffAwaited >= NB_BUF) {
|
|
mDdrBuffAwaited = 0;
|
|
}
|
|
if (fds[mDdrBuffAwaited].revents & POLLIN) {
|
|
rc = read(efd[mDdrBuffAwaited], buf, 16);
|
|
if (!rc) {
|
|
printf("CA7 : stdin closed\n");
|
|
return 0;
|
|
}
|
|
/* Get buffer data size*/
|
|
q_get_data_size.bufferId = mDdrBuffAwaited;
|
|
|
|
if(ioctl(mFdSdbRpmsg, RPMSG_SDB_IOCTL_GET_DATA_SIZE, &q_get_data_size) < 0) {
|
|
error(EXIT_FAILURE, errno, "Failed to get data size");
|
|
}
|
|
|
|
if (q_get_data_size.size) {
|
|
mNbUncompMB += 2;
|
|
mNbUncompData += q_get_data_size.size;
|
|
mNbUncompData += q_get_data_size.size; // need twice as we missed one
|
|
unsigned char* pData = (unsigned char*)mmappedData[mDdrBuffAwaited];
|
|
// save a copy of 1st data
|
|
mByteBuffCpy[0] = *pData;
|
|
gettimeofday(&tval_after, NULL);
|
|
timersub(&tval_after, &tval_before, &tval_result);
|
|
printf("[%ld.%06ld] sdb_thread data EVENT mDdrBuffAwaited=%d mNbUncompData=%u \n",
|
|
(long int)tval_result.tv_sec, (long int)tval_result.tv_usec, mDdrBuffAwaited,
|
|
mNbUncompData);
|
|
gdk_threads_add_idle (refreshUI_CB, window);
|
|
}
|
|
else {
|
|
printf("CA7 : sdb_thread => buf[%d] is empty\n", mDdrBuffAwaited);
|
|
}
|
|
mDdrBuffAwaited++;
|
|
if (mDdrBuffAwaited >= NB_BUF) {
|
|
mDdrBuffAwaited = 0;
|
|
}
|
|
} else {
|
|
// we may have started the timeout, but have stopped and started sampling in RPMSG
|
|
if (mMachineState == STATE_SAMPLING_HIGH) {
|
|
n = 0;
|
|
for (i=0; i<NB_BUF; i++) {
|
|
n += sprintf(dbgmsg+n, "[%d] ", (fds[i].revents & POLLIN));
|
|
}
|
|
printf("CA7 : sdb_thread wrong buffer index ERROR, waiting idx=%d buff status=%s\n",
|
|
mDdrBuffAwaited, dbgmsg);
|
|
mErrorDetected = 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
sleep_ms(5); // give time to UI
|
|
|
|
}
|
|
return 0;
|
|
}
|
|
int main(int argc, char **argv)
|
|
{
|
|
int ret = 0, i, cmd;
|
|
char FwName[30];
|
|
strcpy(FIRM_NAME, "how2eldb04140.elf");
|
|
/* check if copro is already running */
|
|
ret = copro_isFwRunning();
|
|
if (ret) {
|
|
// check FW name
|
|
int nameLn = copro_getFwName(FwName);
|
|
if (FwName[nameLn-1] == 0x0a) {
|
|
FwName[nameLn-1] = 0x00; // replace \n by \0
|
|
}
|
|
if (strcmp(FwName, FIRM_NAME) == 0) {
|
|
printf("CA7 : %s is already running.\n", FIRM_NAME);
|
|
goto fwrunning;
|
|
}else {
|
|
printf("CA7 : wrong FW running. Try to stop it... \n");
|
|
if (copro_stopFw()) {
|
|
printf("CA7 : fails to stop firmware\n");
|
|
goto end;
|
|
}
|
|
}
|
|
}
|
|
|
|
setname:
|
|
/* set the firmware name to load */
|
|
ret = copro_setFwName(FIRM_NAME);
|
|
if (ret <= 0) {
|
|
printf("CA7 : fails to change the firmware name\n");
|
|
goto end;
|
|
}
|
|
|
|
/* start the firmware */
|
|
if (copro_startFw()) {
|
|
printf("CA7 : fails to start firmware\n");
|
|
goto end;
|
|
}
|
|
/* wait for 1 seconds the creation of the virtual ttyRPMSGx */
|
|
sleep_ms(1000);
|
|
|
|
fwrunning:
|
|
signal(SIGINT, exit_fct); /* Ctrl-C signal */
|
|
signal(SIGTERM, exit_fct); /* kill command */
|
|
gettimeofday(&tval_before, NULL); // get current time
|
|
|
|
if (pthread_create( &threadTTY, NULL, virtual_tty_thread, NULL) != 0) {
|
|
printf("CA7 : virtual_tty_thread creation fails\n");
|
|
goto end;
|
|
}
|
|
|
|
sleep_ms(500); // let tty send the DDR buffer command
|
|
if (pthread_create( &threadSDB, NULL, sdb_thread, NULL) != 0) {
|
|
printf("CA7 : sdb_thread creation fails\n");
|
|
goto end;
|
|
}
|
|
|
|
/****** new production way => use rpmsg-sdb driver to perform CMA buff allocation ******/
|
|
|
|
mMachineState = STATE_READY;
|
|
mSampFreq_Hz = 4;
|
|
mSampParmCount = 0;
|
|
|
|
gtk_init (&argc, &argv);
|
|
|
|
if (pthread_create( &threadUI, NULL, ui_thread, NULL) != 0) {
|
|
printf("CA7 : ui_thread creation fails\n");
|
|
goto end;
|
|
}
|
|
|
|
printf("CA7 : Entering in Main loop\n");
|
|
|
|
while (1) {
|
|
if (mExitRequested) break;
|
|
if (mErrorDetected) {
|
|
if (mMachineState >= STATE_SAMPLING_LOW) {
|
|
virtual_tty_send_command(strlen("Exit"), "Exit");
|
|
if (mErrorDetected == 2) printf("CA7 : ERROR in DDR Buffer order => Stop sampling!!!\n");
|
|
//else if (mErrorDetected == 2) printf("CA7 : File System full => Stop sampling!!!\n");
|
|
else if (mErrorDetected == 1) printf("CA7 : M4 reported DMA error !!!\n");
|
|
mErrorDetected = 0;
|
|
mMachineState = STATE_READY;
|
|
gdk_threads_add_idle (refreshUI_CB, window);
|
|
#if 0
|
|
close_raw_file();
|
|
#endif
|
|
}
|
|
}
|
|
sleep_ms(1); // give time to UI
|
|
}
|
|
for (i=0;i<NB_BUF;i++){
|
|
int rc = munmap(mmappedData[i], DATA_BUF_POOL_SIZE);
|
|
assert(rc == 0);
|
|
}
|
|
fMappedData = 0;
|
|
printf("CA7 : Buffers successfully unmapped\n");
|
|
|
|
end:
|
|
mThreadCancel = 1;
|
|
sleep_ms(100);
|
|
/* check if copro is already running */
|
|
if (copro_isFwRunning()) {
|
|
printf("CA7 : stop the firmware before exit\n");
|
|
copro_closeTtyRpmsg(0);
|
|
copro_closeTtyRpmsg(1);
|
|
copro_stopFw();
|
|
}
|
|
return ret;
|
|
}
|