Skip to content

W
White Rabbit Trigger Distribution
Commit 99b52bcf authored by Tristan Gingold's avatar Tristan Gingold
Browse files
Options

Remove wrtd_core, rework logging to add cpu number.

parent 1e8a68e6
Hide whitespace changes
Inline Side-by-side
Showing with 72 additions and 90 deletions
software/include/wrtd-common.h
View file @ 99b52bcf
......@@ -195,6 +195,9 @@ enum wrtd_log_level {
missed by the output */
WRTD_LOG_ALL = 0xff, /**< all events will be logged */
WRTD_LOG_LEVEL_MASK = 0xff, /**< mask for level */
WRTD_LOG_CPU_MASK = 0xf00, /**< mask for the source */
WRTD_LOG_CPU_SHIFT = 8
};
......@@ -257,7 +260,7 @@ struct wrtd_trigger_entry {
* Log event descriptor
*/
struct wrtd_log_entry {
uint32_t type; /**< type of logging */
uint32_t type; /**< type of logging. With cpu for user API. */
uint32_t seq; /**< log sequence number */
int channel; /**< channel that generate the logging message */
struct wrtd_trig_id id; /**< trigger id associated with the log event */
......
software/lib/libwrtd-internal.c
View file @ 99b52bcf
......@@ -73,11 +73,11 @@ int wrtd_trig_id_cmp(struct wrtd_trig_id *id1, struct wrtd_trig_id *id2)
*/
int wrtd_send_and_receive_sync(struct wrtd_desc *wrtd,
struct trtl_msg *msg,
enum wrtd_core core)
int cpu)
{
int err;
err = trtl_msg_sync(wrtd->trtl, core, 0,
err = trtl_msg_sync(wrtd->trtl, cpu, 0,
msg, msg, WRTD_DEFAULT_TIMEOUT);
return err < 0 ? err : 0; /* ignore timeout */
......@@ -89,12 +89,12 @@ int wrtd_send_and_receive_sync(struct wrtd_desc *wrtd,
*/
int wrtd_trivial_request(struct wrtd_node *dev,
struct trtl_msg *request_msg,
enum wrtd_core core)
int cpu)
{
struct wrtd_desc *wrtd = (struct wrtd_desc *)dev;
int err;
err = wrtd_send_and_receive_sync(wrtd, request_msg, core);
err = wrtd_send_and_receive_sync(wrtd, request_msg, cpu);
if (err)
return err;
......
software/lib/libwrtd-internal.h
View file @ 99b52bcf
......@@ -42,9 +42,9 @@ int wrtd_validate_acknowledge(struct trtl_msg *msg);
int wrtd_trig_id_cmp(struct wrtd_trig_id *id1, struct wrtd_trig_id *id2);
extern int wrtd_trivial_request(struct wrtd_node *dev,
struct trtl_msg *request_msg,
enum wrtd_core core);
int cpu);
extern int wrtd_send_and_receive_sync(struct wrtd_desc *wrtd,
struct trtl_msg *msg,
enum wrtd_core core);
int cpu);
#endif
software/lib/libwrtd-logging.c
View file @ 99b52bcf
......@@ -31,7 +31,7 @@
*/
const char *wrtd_strlogging(enum wrtd_log_level lvl)
{
switch (lvl) {
switch (lvl & WRTD_LOG_LEVEL_MASK) {
case WRTD_LOG_NOTHING:
return "off";
case WRTD_LOG_RAW:
......@@ -153,7 +153,7 @@ int wrtd_log_read(struct wrtd_node *dev,
if (ret <= 0)
break;
memcpy(cur, msg.data, sizeof(struct wrtd_log_entry));
cur->type |= (p[i].idx_cpu << WRTD_LOG_CPU_SHIFT);
remaining--;
n_read++;
cur++;
......@@ -172,7 +172,7 @@ int wrtd_log_read(struct wrtd_node *dev,
* @return 0 on success, -1 on error and errno is set appropriately
*/
static int wrtd_log_level_set(struct wrtd_node *dev, unsigned int channel,
uint32_t log_level, enum wrtd_core core)
uint32_t log_level, int core)
{
struct wrtd_desc *wrtd = (struct wrtd_desc *)dev;
struct trtl_tlv tlv;
......@@ -180,7 +180,8 @@ static int wrtd_log_level_set(struct wrtd_node *dev, unsigned int channel,
struct wrtd_in_channel ichan;
int err;
if (core) {
switch (core) {
case WRTD_CPU_FD:
if (channel >= FD_NUM_CHANNELS) {
errno = EWRTD_INVALID_CHANNEL;
return -1;
......@@ -189,7 +190,8 @@ static int wrtd_log_level_set(struct wrtd_node *dev, unsigned int channel,
tlv.type = OUT_STRUCT_CHAN_0 + channel;
tlv.size = WRTD_OUT_CHANNEL_PUBLIC_SIZE;
tlv.buf = &ochan;
} else {
break;
case WRTD_CPU_TDC:
if (channel >= TDC_NUM_CHANNELS) {
errno = EWRTD_INVALID_CHANNEL;
return -1;
......@@ -197,16 +199,25 @@ static int wrtd_log_level_set(struct wrtd_node *dev, unsigned int channel,
tlv.type = IN_STRUCT_CHAN_0 + channel;
tlv.size = sizeof(struct wrtd_in_channel);
tlv.buf = &ichan;
break;
default:
abort();
}
err = trtl_fw_buffer_get(wrtd->trtl, core, 0, &tlv, 1);
if (err)
return err;
if (core)
switch(core) {
case WRTD_CPU_FD:
ochan.config.log_level = log_level;
else
break;
case WRTD_CPU_TDC:
ichan.config.log_level = log_level;
break;
default:
abort();
}
return trtl_fw_buffer_set(wrtd->trtl, core, 0, &tlv, 1);
}
......@@ -222,8 +233,7 @@ static int wrtd_log_level_set(struct wrtd_node *dev, unsigned int channel,
int wrtd_out_log_level_set(struct wrtd_node *dev, unsigned int output,
uint32_t log_level)
{
return wrtd_log_level_set(dev, output, log_level,
WRTD_CORE_OUT);
return wrtd_log_level_set(dev, output, log_level, WRTD_CPU_FD);
}
......@@ -260,7 +270,7 @@ int wrtd_out_log_level_get(struct wrtd_node *dev, unsigned int input,
int wrtd_in_log_level_set(struct wrtd_node *dev, unsigned int input,
uint32_t log_level)
{
return wrtd_log_level_set(dev, input, log_level, WRTD_CORE_IN);
return wrtd_log_level_set(dev, input, log_level, WRTD_CPU_TDC);
}
......
software/lib/libwrtd.h
View file @ 99b52bcf
......@@ -50,15 +50,6 @@ enum wrtd_error_list {
__EWRTD_MAX_ERROR_NUMBER,
};
/**
* @enum wrtd_core
* Core indexes according to their main purpose
*/
enum wrtd_core {
WRTD_CORE_IN = 0, /**< Input core that manages incoming pulses */
WRTD_CORE_OUT = 1, /**< Output core that manages pulses generation */
};
/**
* Trigger token
......
software/tools/wrtd-logging.c
View file @ 99b52bcf
......@@ -25,18 +25,8 @@
#include <poll.h>
#include <inttypes.h>
#include <libgen.h>
#include <pthread.h>
#include <libwrtd.h>
static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
struct wrtd_log_th {
struct wrtd_node *wrtd;
enum wrtd_core core;
int n_read;
};
static void help()
{
fprintf(stderr, "wrtd-logging -D 0x<hex-number>\n");
......@@ -48,41 +38,37 @@ static void help()
}
static void *logging_thread(void *arg)
static void print_logging (struct wrtd_node *wrtd, int n_read)
{
struct wrtd_log_th *th_data = arg;
struct wrtd_log_entry log;
int i, count, valid;
switch (th_data->core) {
case WRTD_CORE_IN:
valid = wrtd_in_is_valid(th_data->wrtd);
break;
case WRTD_CORE_OUT:
valid = wrtd_out_is_valid(th_data->wrtd);
break;
default:
valid = 0;
break;
int i, count, valid, cpu;
valid = wrtd_in_is_valid(wrtd);
if (!valid) {
fprintf(stderr,
"Cannot run logging, invalid input firmware: %s\n",
wrtd_strerror(errno));
return;
}
valid = wrtd_out_is_valid(wrtd);
if (!valid) {
fprintf(stderr, "Cannot run logging, invalid %s firmware: %s\n",
th_data->core == WRTD_CORE_IN ? "input" : "output",
fprintf(stderr,
"Cannot run logging, invalid output firmware: %s\n",
wrtd_strerror(errno));
return NULL;
return;
}
while (i < th_data->n_read || th_data->n_read == 0) {
count = wrtd_log_read(th_data->wrtd, &log, 1, -1);
for(i = 0; i < n_read || n_read == 0; i++) {
count = wrtd_log_read(wrtd, &log, 1, -1);
if (count <= 0) {
fprintf(stderr, "Cannot read message: %s\n",
wrtd_strerror(errno));
break;
}
cpu = (log.type & WRTD_LOG_CPU_MASK) >> WRTD_LOG_CPU_SHIFT;
fprintf(stdout, "Device %s\n",
th_data->core == WRTD_CORE_IN ? "input" : "output");
cpu == WRTD_CPU_TDC ? "tdc" : "fd");
fprintf(stdout, "Event Type %s\n", wrtd_strlogging(log.type));
if (log.type == WRTD_LOG_PROMISC || log.channel < 0)
fprintf(stdout, "Channel --\n");
......@@ -99,23 +85,20 @@ static void *logging_thread(void *arg)
log.ts.seconds, log.ts.ticks, log.ts.frac);
fprintf(stdout, "----\n");
pthread_mutex_lock(&mtx);
i++;
pthread_mutex_unlock(&mtx);
}
return NULL;
}
static void show_logging_level(struct wrtd_node *dev, enum wrtd_core core)
static void show_logging_level(struct wrtd_node *dev, int cpu)
{
uint32_t log_level;
char log_level_str[128];
int i, err, max = core ? FD_NUM_CHANNELS : TDC_NUM_CHANNELS;
int i, err, max = cpu == WRTD_CPU_FD ? FD_NUM_CHANNELS : TDC_NUM_CHANNELS;
fprintf(stdout, "%s log levels\n", core ? "Output" : "Input");
fprintf(stdout, "%s log levels\n",
cpu == WRTD_CPU_FD ? "Output (FD)" : "Input (TDC)");
for (i = 0; i < max; i++) {
if (core)
if (cpu == WRTD_CPU_FD)
err = wrtd_out_log_level_get(dev, i, &log_level);
else
err = wrtd_in_log_level_get(dev, i, &log_level);
......@@ -132,9 +115,10 @@ static void show_logging_level(struct wrtd_node *dev, enum wrtd_core core)
#define N_LOG 2
int main(int argc, char *argv[])
{
struct wrtd_log_th th_data[N_LOG];
pthread_t tid[N_LOG];
int i = 0, err, show_log = 0;
struct wrtd_node *wrtd;
int n_read = 0;
char *endptr;
int err, show_log = 0;
uint32_t dev_id = 0;
char c;
......@@ -144,11 +128,18 @@ int main(int argc, char *argv[])
help();
break;
case 'D':
sscanf(optarg, "0x%x", &dev_id);
dev_id = strtoul(optarg, &endptr, 0);
if (*endptr != 0) {
fprintf(stderr, "bad value for -D");
exit (1);
}
break;
case 'n':
sscanf(optarg, "0x%x", &th_data[0].n_read);
th_data[1].n_read = th_data[0].n_read;
n_read = strtoul(optarg, &endptr, 0);
if (*endptr != 0) {
fprintf(stderr, "bad value for -n");
exit (1);
}
break;
case 's':
show_log = 1;
......@@ -167,33 +158,20 @@ int main(int argc, char *argv[])
exit(1);
}
th_data[0].wrtd = wrtd_open(dev_id);
if (!th_data[0].wrtd) {
wrtd = wrtd_open(dev_id);
if (!wrtd) {
fprintf(stderr, "Cannot open WRNC: %s\n", wrtd_strerror(errno));
exit(1);
}
th_data[1].wrtd = th_data[0].wrtd;
if (show_log) {
show_logging_level(th_data[WRTD_CORE_IN].wrtd, WRTD_CORE_IN);
show_logging_level(th_data[WRTD_CORE_OUT].wrtd, WRTD_CORE_OUT);
show_logging_level(wrtd, WRTD_CPU_TDC);
show_logging_level(wrtd, WRTD_CPU_FD);
exit(0);
}
for (i = 0; i < N_LOG; i++) {
th_data[i].core = i;
err = pthread_create(&tid[i], NULL, logging_thread, (void *)&th_data[i]);
if (err)
fprintf(stderr,
"Cannot create 'logging_thread' instance %d: %s\n",
i, strerror(errno));
}
/* Wait for the threads to finish */
for (i = 0; i < N_LOG; i++)
pthread_join(tid[i], NULL);
print_logging (wrtd, n_read);
wrtd_close(th_data[0].wrtd);
wrtd_close(wrtd);
exit(0);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment