BLAHAJ
/
libsigrok
10
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

ipdbg-la: Adjust to sigrok indentation style

This commit is contained in:
Soeren Apel 2018-08-20 23:16:14 +02:00 committed by Uwe Hermann
parent 7f4c9a0444
commit 9d2e5483dc
3 changed files with 594 additions and 565 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

436
src/hardware/ipdbg-logic-analyser/api.c
View File

@ -21,329 +21,341 @@
#include "protocol.h"
static const uint32_t ipdbg_org_la_drvopts[] = {
SR_CONF_LOGIC_ANALYZER,
SR_CONF_LOGIC_ANALYZER,
};
static const uint32_t ipdbg_org_la_scanopts[] = {
SR_CONF_CONN,
SR_CONF_SERIALCOMM,
SR_CONF_CONN,
SR_CONF_SERIALCOMM,
};
static const uint32_t ipdbg_org_la_devopts[] = {
SR_CONF_TRIGGER_MATCH | SR_CONF_LIST| SR_CONF_SET,
SR_CONF_CAPTURE_RATIO | SR_CONF_GET | SR_CONF_SET,
SR_CONF_LIMIT_SAMPLES | SR_CONF_GET
SR_CONF_TRIGGER_MATCH | SR_CONF_LIST | SR_CONF_SET,
SR_CONF_CAPTURE_RATIO | SR_CONF_GET | SR_CONF_SET,
SR_CONF_LIMIT_SAMPLES | SR_CONF_GET
};
static const int32_t ipdbg_org_la_trigger_matches[] = {
SR_TRIGGER_ZERO,
SR_TRIGGER_ONE,
SR_TRIGGER_RISING,
SR_TRIGGER_FALLING,
SR_TRIGGER_EDGE,
SR_TRIGGER_ZERO,
SR_TRIGGER_ONE,
SR_TRIGGER_RISING,
SR_TRIGGER_FALLING,
SR_TRIGGER_EDGE,
};
SR_PRIV struct sr_dev_driver ipdbg_la_driver_info;
static void ipdbg_org_la_split_addr_port(const char *conn, char **addr, char **port)
static void ipdbg_org_la_split_addr_port(const char *conn, char **addr,
char **port)
{
char **strs = g_strsplit(conn, "/", 3);
char **strs = g_strsplit(conn, "/", 3);
*addr = g_strdup(strs[1]);
*port = g_strdup(strs[2]);
*addr = g_strdup(strs[1]);
*port = g_strdup(strs[2]);
g_strfreev(strs);
g_strfreev(strs);
}
static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
struct drv_context *drvc;
GSList *devices;
struct drv_context *drvc;
GSList *devices;
devices = NULL;
drvc = di->context;
drvc->instances = NULL;
const char *conn;
struct sr_config *src;
GSList *l;
devices = NULL;
drvc = di->context;
drvc->instances = NULL;
const char *conn;
struct sr_config *src;
GSList *l;
conn = NULL;
for (l = options; l; l = l->next) {
src = l->data;
switch (src->key) {
case SR_CONF_CONN:
conn = g_variant_get_string(src->data, NULL);
break;
}
}
conn = NULL;
for (l = options; l; l = l->next) {
src = l->data;
switch (src->key) {
case SR_CONF_CONN:
conn = g_variant_get_string(src->data, NULL);
break;
}
}
if (!conn)
return NULL;
if (!conn)
return NULL;
struct ipdbg_org_la_tcp *tcp = ipdbg_org_la_tcp_new();
struct ipdbg_org_la_tcp *tcp = ipdbg_org_la_tcp_new();
ipdbg_org_la_split_addr_port(conn, &tcp->address, &tcp->port);
ipdbg_org_la_split_addr_port(conn, &tcp->address, &tcp->port);
if (!tcp->address)
return NULL;
if (!tcp->address)
return NULL;
if (ipdbg_org_la_tcp_open(tcp) != SR_OK)
return NULL;
if(ipdbg_org_la_tcp_open(tcp) != SR_OK)
return NULL;
ipdbg_org_la_send_reset(tcp);
ipdbg_org_la_send_reset(tcp);
ipdbg_org_la_request_id(tcp);
ipdbg_org_la_send_reset(tcp);
ipdbg_org_la_send_reset(tcp);
ipdbg_org_la_request_id(tcp);
struct sr_dev_inst *sdi = g_malloc0(sizeof(struct sr_dev_inst));
if (!sdi) {
sr_err("no possible to allocate sr_dev_inst");
return NULL;
}
struct sr_dev_inst *sdi = g_malloc0(sizeof(struct sr_dev_inst));
if (!sdi){
sr_err("no possible to allocate sr_dev_inst");
return NULL;
}
sdi->status = SR_ST_INACTIVE;
sdi->vendor = g_strdup("ipdbg.org");
sdi->model = g_strdup("Logic Analyzer");
sdi->version = g_strdup("v1.0");
sdi->driver = di;
sdi->status = SR_ST_INACTIVE;
sdi->vendor = g_strdup("ipdbg.org");
sdi->model = g_strdup("Logic Analyzer");
sdi->version = g_strdup("v1.0");
sdi->driver = di;
struct ipdbg_org_la_dev_context *devc = ipdbg_org_la_dev_new();
sdi->priv = devc;
struct ipdbg_org_la_dev_context *devc = ipdbg_org_la_dev_new();
sdi->priv = devc;
ipdbg_org_la_get_addrwidth_and_datawidth(tcp, devc);
ipdbg_org_la_get_addrwidth_and_datawidth(tcp, devc);
sr_dbg("addr_width = %d, data_width = %d\n", devc->ADDR_WIDTH,
devc->DATA_WIDTH);
sr_dbg("limit samples = %" PRIu64 "\n", devc->limit_samples_max);
sr_dbg("addr_width = %d, data_width = %d\n", devc->ADDR_WIDTH, devc->DATA_WIDTH);
sr_dbg("limit samples = %" PRIu64 "\n", devc->limit_samples_max);
for (uint32_t i = 0; i < devc->DATA_WIDTH; i++) {
const uint8_t buf_size = 16;
char buf[buf_size];
snprintf(buf, buf_size, "ch%d", i);
sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, buf);
}
for (uint32_t i = 0; i < devc->DATA_WIDTH; i++) {
const uint8_t buf_size = 16;
char buf[buf_size];
snprintf(buf, buf_size, "ch%d", i);
sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, buf);
}
sdi->inst_type = SR_INST_USER;
sdi->conn = tcp;
sdi->inst_type = SR_INST_USER;
sdi->conn = tcp;
ipdbg_org_la_tcp_close(tcp);
ipdbg_org_la_tcp_close(tcp);
devices = g_slist_append(devices, sdi);
devices = g_slist_append(devices, sdi);
return std_scan_complete(di, devices);
return std_scan_complete(di, devices);
}
static int dev_clear(const struct sr_dev_driver *di)
{
struct drv_context *drvc = di->context;
struct sr_dev_inst *sdi;
GSList *l;
struct drv_context *drvc = di->context;
struct sr_dev_inst *sdi;
GSList *l;
if (drvc) {
for (l = drvc->instances; l; l = l->next) {
sdi = l->data;
struct ipdbg_org_la_tcp *tcp = sdi->conn;
if (tcp) {
ipdbg_org_la_tcp_close(tcp);
ipdbg_org_la_tcp_free(tcp);
g_free(tcp);
}
sdi->conn = NULL;
}
}
if (drvc) {
for (l = drvc->instances; l; l = l->next) {
sdi = l->data;
struct ipdbg_org_la_tcp *tcp = sdi->conn;
if (tcp) {
ipdbg_org_la_tcp_close(tcp);
ipdbg_org_la_tcp_free(tcp);
g_free(tcp);
}
sdi->conn = NULL;
}
}
return std_dev_clear(di);
return std_dev_clear(di);
}
static int dev_open(struct sr_dev_inst *sdi)
{
sdi->status = SR_ST_INACTIVE;
sdi->status = SR_ST_INACTIVE;
struct ipdbg_org_la_tcp *tcp = sdi->conn;
struct ipdbg_org_la_tcp *tcp = sdi->conn;
if (!tcp)
return SR_ERR;
if (!tcp)
return SR_ERR;
if (ipdbg_org_la_tcp_open(tcp) != SR_OK)
return SR_ERR;
if (ipdbg_org_la_tcp_open(tcp) != SR_OK)
return SR_ERR;
sdi->status = SR_ST_ACTIVE;
sdi->status = SR_ST_ACTIVE;
return SR_OK;
return SR_OK;
}
static int dev_close(struct sr_dev_inst *sdi)
{
// Should be called before a new call to scan()
struct ipdbg_org_la_tcp *tcp = sdi->conn;
// Should be called before a new call to scan()
struct ipdbg_org_la_tcp *tcp = sdi->conn;
if (tcp)
ipdbg_org_la_tcp_close(tcp);
if (tcp)
ipdbg_org_la_tcp_close(tcp);
sdi->conn = NULL;
sdi->status = SR_ST_INACTIVE;
sdi->conn = NULL;
sdi->status = SR_ST_INACTIVE;
return SR_OK;
return SR_OK;
}
static int config_get(uint32_t key, GVariant **data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
int ret = SR_OK;
int ret = SR_OK;
(void)cg;
(void)cg;
struct ipdbg_org_la_dev_context *devc = sdi->priv;
struct ipdbg_org_la_dev_context *devc = sdi->priv;
switch (key) {
case SR_CONF_CAPTURE_RATIO:
*data = g_variant_new_uint64(devc->capture_ratio);
break;
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
default:
ret = SR_ERR_NA;
}
switch (key) {
case SR_CONF_CAPTURE_RATIO:
*data = g_variant_new_uint64(devc->capture_ratio);
break;
case SR_CONF_LIMIT_SAMPLES:
*data = g_variant_new_uint64(devc->limit_samples);
break;
default:
ret = SR_ERR_NA;
}
return ret;
return ret;
}
static int config_set(uint32_t key, GVariant *data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
int ret = SR_OK;
uint64_t value;
int ret = SR_OK;
uint64_t value;
(void)cg;
(void)cg;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
struct ipdbg_org_la_dev_context *devc = sdi->priv;
struct ipdbg_org_la_dev_context *devc = sdi->priv;
switch (key) {
case SR_CONF_CAPTURE_RATIO:
value = g_variant_get_uint64(data);
if (value <= 100)
devc->capture_ratio = value;
else
ret = SR_ERR;
break;
case SR_CONF_LIMIT_SAMPLES:
value = g_variant_get_uint64(data);
if (value <= devc->limit_samples_max)
devc->limit_samples = value;
else
ret = SR_ERR;
break;
default:
ret = SR_ERR_NA;
}
switch (key) {
case SR_CONF_CAPTURE_RATIO:
value = g_variant_get_uint64(data);
if (value <= 100)
devc->capture_ratio = value;
else
ret = SR_ERR;
break;
case SR_CONF_LIMIT_SAMPLES:
value = g_variant_get_uint64(data);
if (value <= devc->limit_samples_max)
devc->limit_samples = value;
else
ret = SR_ERR;
break;
default:
ret = SR_ERR_NA;
}
return ret;
return ret;
}
static int config_list(uint32_t key, GVariant **data,
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
(void)cg;
(void)cg;
switch (key) {
case SR_CONF_SCAN_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
ipdbg_org_la_scanopts, ARRAY_SIZE(ipdbg_org_la_scanopts), sizeof(uint32_t));
break;
case SR_CONF_DEVICE_OPTIONS:
if (!sdi)
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
ipdbg_org_la_drvopts, ARRAY_SIZE(ipdbg_org_la_drvopts), sizeof(uint32_t));
else
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
ipdbg_org_la_devopts, ARRAY_SIZE(ipdbg_org_la_devopts), sizeof(uint32_t));
break;
case SR_CONF_TRIGGER_MATCH:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
ipdbg_org_la_trigger_matches, ARRAY_SIZE(ipdbg_org_la_trigger_matches), sizeof(int32_t));
break;
default:
return SR_ERR_NA;
}
switch (key) {
case SR_CONF_SCAN_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
ipdbg_org_la_scanopts,
ARRAY_SIZE
(ipdbg_org_la_scanopts),
sizeof(uint32_t));
break;
case SR_CONF_DEVICE_OPTIONS:
if (!sdi)
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
ipdbg_org_la_drvopts,
ARRAY_SIZE
(ipdbg_org_la_drvopts),
sizeof(uint32_t));
else
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
ipdbg_org_la_devopts,
ARRAY_SIZE
(ipdbg_org_la_devopts),
sizeof(uint32_t));
break;
case SR_CONF_TRIGGER_MATCH:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
ipdbg_org_la_trigger_matches,
ARRAY_SIZE
(ipdbg_org_la_trigger_matches),
sizeof(int32_t));
break;
default:
return SR_ERR_NA;
}
return SR_OK;
return SR_OK;
}
static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
{
return std_init(di, sr_ctx);
return std_init(di, sr_ctx);
}
static GSList *dev_list(const struct sr_dev_driver *di)
{
return ((struct drv_context*)(di->context))->instances;
return ((struct drv_context *)(di->context))->instances;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
struct ipdbg_org_la_tcp *tcp = sdi->conn;
struct ipdbg_org_la_dev_context *devc = sdi->priv;
struct ipdbg_org_la_tcp *tcp = sdi->conn;
struct ipdbg_org_la_dev_context *devc = sdi->priv;
ipdbg_org_la_convert_trigger(sdi);
ipdbg_org_la_send_trigger(devc, tcp);
ipdbg_org_la_send_delay(devc, tcp);;
ipdbg_org_la_convert_trigger(sdi);
ipdbg_org_la_send_trigger(devc, tcp);
ipdbg_org_la_send_delay(devc, tcp);
/* If the device stops sending for longer than it takes to send a byte,
* that means it's finished. But wait at least 100 ms to be safe.
*/
sr_session_source_add(sdi->session, tcp->socket, G_IO_IN, 100,
ipdbg_org_la_receive_data, (struct sr_dev_inst *)sdi);
/* If the device stops sending for longer than it takes to send a byte,
* that means it's finished. But wait at least 100 ms to be safe.
*/
sr_session_source_add(sdi->session, tcp->socket, G_IO_IN, 100,
ipdbg_org_la_receive_data, (struct sr_dev_inst *)sdi);
ipdbg_org_la_send_start(tcp);
ipdbg_org_la_send_start(tcp);
return SR_OK;
return SR_OK;
}
static int dev_acquisition_stop(struct sr_dev_inst *sdi)
{
struct ipdbg_org_la_tcp *tcp = sdi->conn;
struct ipdbg_org_la_dev_context *devc = sdi->priv;
struct ipdbg_org_la_tcp *tcp = sdi->conn;
struct ipdbg_org_la_dev_context *devc = sdi->priv;
uint8_t byte;
uint8_t byte;
if (devc->num_transfers > 0) {
while (devc->num_transfers < (devc->limit_samples_max * devc->DATA_WIDTH_BYTES)) {
ipdbg_org_la_tcp_receive(tcp, &byte);
devc->num_transfers++;
}
}
if (devc->num_transfers > 0) {
while (devc->num_transfers <
(devc->limit_samples_max * devc->DATA_WIDTH_BYTES)) {
ipdbg_org_la_tcp_receive(tcp, &byte);
devc->num_transfers++;
}
}
ipdbg_org_la_send_reset(tcp);
ipdbg_org_la_abort_acquisition(sdi);
ipdbg_org_la_send_reset(tcp);
ipdbg_org_la_abort_acquisition(sdi);
return SR_OK;
return SR_OK;
}
SR_PRIV struct sr_dev_driver ipdbg_la_driver_info = {
.name = "ipdbg-org-la",
.longname = "ipdbg.org logic analyzer",
.api_version = 1,
.init = init,
.cleanup = std_cleanup,
.scan = scan,
.dev_list = dev_list,
.dev_clear = dev_clear,
.config_get = config_get,
.config_set = config_set,
.config_list = config_list,
.dev_open = dev_open,
.dev_close = dev_close,
.dev_acquisition_start = dev_acquisition_start,
.dev_acquisition_stop = dev_acquisition_stop,
.context = NULL,
.name = "ipdbg-org-la",
.longname = "ipdbg.org logic analyzer",
.api_version = 1,
.init = init,
.cleanup = std_cleanup,
.scan = scan,
.dev_list = dev_list,
.dev_clear = dev_clear,
.config_get = config_get,
.config_set = config_set,
.config_list = config_list,
.dev_open = dev_open,
.dev_close = dev_close,
.dev_acquisition_start = dev_acquisition_start,
.dev_acquisition_stop = dev_acquisition_stop,
.context = NULL,
};
SR_REGISTER_DEV_DRIVER(ipdbg_la_driver_info);

657
src/hardware/ipdbg-logic-analyser/protocol.c
View File

@ -40,7 +40,6 @@
#include <sys/ioctl.h>
#define BUFFER_SIZE 4
/* Top-level command opcodes */
@ -69,485 +68,497 @@
/* LA subfunction command opcodes */
#define CMD_LA_DELAY 0x1F
SR_PRIV int data_available(struct ipdbg_org_la_tcp *tcp)
{
#ifdef __WIN32__
ioctlsocket(tcp->socket, FIONREAD, &bytes_available);
ioctlsocket(tcp->socket, FIONREAD, &bytes_available);
#else
int status;
int status;
if (ioctl(tcp->socket, FIONREAD, &status) < 0) { // TIOCMGET
sr_err("FIONREAD failed: %s\n", strerror(errno));
return 0;
}
if (ioctl(tcp->socket, FIONREAD, &status) < 0) { // TIOCMGET
sr_err("FIONREAD failed: %s\n", strerror(errno));
return 0;
}
return (status < 1) ? 0 : 1;
return (status < 1) ? 0 : 1;
#endif // __WIN32__
}
SR_PRIV struct ipdbg_org_la_tcp *ipdbg_org_la_tcp_new(void)
{
struct ipdbg_org_la_tcp *tcp;
struct ipdbg_org_la_tcp *tcp;
tcp = g_malloc0(sizeof(struct ipdbg_org_la_tcp));
tcp = g_malloc0(sizeof(struct ipdbg_org_la_tcp));
tcp->address = NULL;
tcp->port = NULL;
tcp->socket = -1;
tcp->address = NULL;
tcp->port = NULL;
tcp->socket = -1;
return tcp;
return tcp;
}
SR_PRIV void ipdbg_org_la_tcp_free(struct ipdbg_org_la_tcp *tcp)
{
g_free(tcp->address);
g_free(tcp->port);
g_free(tcp->address);
g_free(tcp->port);
}
SR_PRIV int ipdbg_org_la_tcp_open(struct ipdbg_org_la_tcp *tcp)
{
struct addrinfo hints;
struct addrinfo *results, *res;
int err;
struct addrinfo hints;
struct addrinfo *results, *res;
int err;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
err = getaddrinfo(tcp->address, tcp->port, &hints, &results);
err = getaddrinfo(tcp->address, tcp->port, &hints, &results);
if (err) {
sr_err("Address lookup failed: %s:%s: %s", tcp->address, tcp->port,
gai_strerror(err));
return SR_ERR;
}
if (err) {
sr_err("Address lookup failed: %s:%s: %s", tcp->address,
tcp->port, gai_strerror(err));
return SR_ERR;
}
for (res = results; res; res = res->ai_next) {
if ((tcp->socket = socket(res->ai_family, res->ai_socktype,
res->ai_protocol)) < 0)
continue;
if (connect(tcp->socket, res->ai_addr, res->ai_addrlen) != 0) {
close(tcp->socket);
tcp->socket = -1;
continue;
}
break;
}
for (res = results; res; res = res->ai_next) {
if ((tcp->socket = socket(res->ai_family, res->ai_socktype,
res->ai_protocol)) < 0)
continue;
if (connect(tcp->socket, res->ai_addr, res->ai_addrlen) != 0) {
close(tcp->socket);
tcp->socket = -1;
continue;
}
break;
}
freeaddrinfo(results);
freeaddrinfo(results);
if (tcp->socket < 0) {
sr_err("Failed to connect to %s:%s: %s", tcp->address, tcp->port,
g_strerror(errno));
return SR_ERR;
}
if (tcp->socket < 0) {
sr_err("Failed to connect to %s:%s: %s", tcp->address, tcp->port,
g_strerror(errno));
return SR_ERR;
}
return SR_OK;
return SR_OK;
}
SR_PRIV int ipdbg_org_la_tcp_close(struct ipdbg_org_la_tcp *tcp)
{
int ret = SR_OK;
int ret = SR_OK;
if (close(tcp->socket) < 0)
ret = SR_ERR;
if (close(tcp->socket) < 0)
ret = SR_ERR;
tcp->socket = -1;
tcp->socket = -1;
return ret;
return ret;
}
SR_PRIV int ipdbg_org_la_tcp_send(struct ipdbg_org_la_tcp *tcp,
const uint8_t *buf, size_t len)
{
int out;
out = send(tcp->socket, (char*)buf, len, 0);
int out;
out = send(tcp->socket, (char*)buf, len, 0);
if (out < 0) {
sr_err("Send error: %s", g_strerror(errno));
return SR_ERR;
}
if (out < 0) {
sr_err("Send error: %s", g_strerror(errno));
return SR_ERR;
}
if (out < (int)len)
sr_dbg("Only sent %d/%d bytes of data.", out, (int)len);
if (out < (int)len)
sr_dbg("Only sent %d/%d bytes of data.", out, (int)len);
return SR_OK;
return SR_OK;
}
SR_PRIV int ipdbg_org_la_tcp_receive_blocking(struct ipdbg_org_la_tcp *tcp,
uint8_t *buf, int bufsize)
{
int received = 0;
int received = 0;
while (received < bufsize) {
if (ipdbg_org_la_tcp_receive(tcp, buf) > 0) {
buf++;
received++;
}
}
while (received < bufsize) {
if (ipdbg_org_la_tcp_receive(tcp, buf) > 0) {
buf++;
received++;
}
}
return received;
return received;
}
SR_PRIV int ipdbg_org_la_tcp_receive(struct ipdbg_org_la_tcp *tcp, uint8_t *buf)
SR_PRIV int ipdbg_org_la_tcp_receive(struct ipdbg_org_la_tcp *tcp,
uint8_t *buf)
{
int received = 0;
int received = 0;
if (data_available(tcp)) {
while (received < 1) {
int len = recv(tcp->socket, buf, 1, 0);
if (data_available(tcp)) {
while (received < 1) {
int len = recv(tcp->socket, buf, 1, 0);
if (len < 0) {
sr_err("Receive error: %s", g_strerror(errno));
return SR_ERR;
} else
received += len;
}
if (len < 0) {
sr_err("Receive error: %s", g_strerror(errno));
return SR_ERR;
} else
received += len;
}
return received;
}
else
return -1;
return received;
} else
return -1;
}
SR_PRIV int ipdbg_org_la_convert_trigger(const struct sr_dev_inst *sdi)
{
struct ipdbg_org_la_dev_context *devc;
struct sr_trigger *trigger;
struct sr_trigger_stage *stage;
struct sr_trigger_match *match;
const GSList *l, *m;
struct ipdbg_org_la_dev_context *devc;
struct sr_trigger *trigger;
struct sr_trigger_stage *stage;
struct sr_trigger_match *match;
const GSList *l, *m;
devc = sdi->priv;
devc = sdi->priv;
devc->num_stages = 0;
devc->num_transfers = 0;
devc->raw_sample_buf = NULL;
devc->num_stages = 0;
devc->num_transfers = 0;
devc->raw_sample_buf = NULL;
for (uint64_t i = 0; i < devc->DATA_WIDTH_BYTES; i++) {
devc->trigger_mask[i] = 0;
devc->trigger_value[i] = 0;
devc->trigger_mask_last[i] = 0;
devc->trigger_value_last[i] = 0;
devc->trigger_edge_mask[i] = 0;
}
for (uint64_t i = 0; i < devc->DATA_WIDTH_BYTES; i++) {
devc->trigger_mask[i] = 0;
devc->trigger_value[i] = 0;
devc->trigger_mask_last[i] = 0;
devc->trigger_value_last[i] = 0;
devc->trigger_edge_mask[i] = 0;
}
if (!(trigger = sr_session_trigger_get(sdi->session)))
return SR_OK;
if (!(trigger = sr_session_trigger_get(sdi->session)))
return SR_OK;
for (l = trigger->stages; l; l = l->next) {
stage = l->data;
for (m = stage->matches; m; m = m->next) {
match = m->data;
int byte_idx = match->channel->index / 8;
uint8_t match_bit = 1 << (match->channel->index % 8);
for (l = trigger->stages; l; l = l->next) {
stage = l->data;
for (m = stage->matches; m; m = m->next) {
match = m->data;
int byte_idx = match->channel->index / 8;
uint8_t match_bit = 1 << (match->channel->index % 8);
if (!match->channel->enabled)
/* Ignore disabled channels with a trigger. */
continue;
if (!match->channel->enabled)
/* Ignore disabled channels with a trigger. */
continue;
if (match->match == SR_TRIGGER_ONE) {
devc->trigger_value[byte_idx] |= match_bit;
devc->trigger_mask[byte_idx] |= match_bit;
devc->trigger_mask_last[byte_idx] &= ~match_bit;
devc->trigger_edge_mask[byte_idx] &= ~match_bit;
} else if (match->match == SR_TRIGGER_ZERO) {
devc->trigger_value[byte_idx] &= ~match_bit;
devc->trigger_mask[byte_idx] |= match_bit;
devc->trigger_mask_last[byte_idx] &= ~match_bit;
devc->trigger_edge_mask[byte_idx] &= ~match_bit;
} else if ( match->match == SR_TRIGGER_RISING) {
devc->trigger_value[byte_idx] |= match_bit;
devc->trigger_value_last[byte_idx] &= ~match_bit;
devc->trigger_mask[byte_idx] |= match_bit;
devc->trigger_mask_last[byte_idx] |= match_bit;
devc->trigger_edge_mask[byte_idx] &= ~match_bit;
} else if (match->match == SR_TRIGGER_FALLING) {
devc->trigger_value[byte_idx] &= ~match_bit;
devc->trigger_value_last[byte_idx] |= match_bit;
devc->trigger_mask[byte_idx] |= match_bit;
devc->trigger_mask_last[byte_idx] |= match_bit;
devc->trigger_edge_mask[byte_idx] &= ~match_bit;
} else if (match->match == SR_TRIGGER_EDGE) {
devc->trigger_mask[byte_idx] &= ~match_bit;
devc->trigger_mask_last[byte_idx] &= ~match_bit;
devc->trigger_edge_mask[byte_idx] |= match_bit;
}
}
}
if (match->match == SR_TRIGGER_ONE) {
devc->trigger_value[byte_idx] |= match_bit;
devc->trigger_mask[byte_idx] |= match_bit;
devc->trigger_mask_last[byte_idx] &= ~match_bit;
devc->trigger_edge_mask[byte_idx] &= ~match_bit;
} else if (match->match == SR_TRIGGER_ZERO) {
devc->trigger_value[byte_idx] &= ~match_bit;
devc->trigger_mask[byte_idx] |= match_bit;
devc->trigger_mask_last[byte_idx] &= ~match_bit;
devc->trigger_edge_mask[byte_idx] &= ~match_bit;
} else if (match->match == SR_TRIGGER_RISING) {
devc->trigger_value[byte_idx] |= match_bit;
devc->trigger_value_last[byte_idx] &=
~match_bit;
devc->trigger_mask[byte_idx] |= match_bit;
devc->trigger_mask_last[byte_idx] |= match_bit;
devc->trigger_edge_mask[byte_idx] &= ~match_bit;
} else if (match->match == SR_TRIGGER_FALLING) {
devc->trigger_value[byte_idx] &= ~match_bit;
devc->trigger_value_last[byte_idx] |= match_bit;
devc->trigger_mask[byte_idx] |= match_bit;
devc->trigger_mask_last[byte_idx] |= match_bit;
devc->trigger_edge_mask[byte_idx] &= ~match_bit;
} else if (match->match == SR_TRIGGER_EDGE) {
devc->trigger_mask[byte_idx] &= ~match_bit;
devc->trigger_mask_last[byte_idx] &= ~match_bit;
devc->trigger_edge_mask[byte_idx] |= match_bit;
}
}
}
return SR_OK;
return SR_OK;
}
SR_PRIV int ipdbg_org_la_receive_data(int fd, int revents, void *cb_data)
{
const struct sr_dev_inst *sdi;
struct ipdbg_org_la_dev_context *devc;
const struct sr_dev_inst *sdi;
struct ipdbg_org_la_dev_context *devc;
(void)fd;
(void)revents;
(void)fd;
(void)revents;
sdi = (const struct sr_dev_inst*)cb_data;
if (!sdi)
return FALSE;
sdi = (const struct sr_dev_inst *)cb_data;
if (!sdi)
return FALSE;
if (!(devc = sdi->priv))
return FALSE;
if (!(devc = sdi->priv))
return FALSE;
struct ipdbg_org_la_tcp *tcp = sdi->conn;
struct sr_datafeed_packet packet;
struct sr_datafeed_logic logic;
struct ipdbg_org_la_tcp *tcp = sdi->conn;
struct sr_datafeed_packet packet;
struct sr_datafeed_logic logic;
if (!devc->raw_sample_buf) {
devc->raw_sample_buf =
g_try_malloc(devc->limit_samples * devc->DATA_WIDTH_BYTES);
if (!devc->raw_sample_buf) {
sr_warn("Sample buffer malloc failed.");
return FALSE;
}
}
if (!devc->raw_sample_buf) {
devc->raw_sample_buf =
g_try_malloc(devc->limit_samples * devc->DATA_WIDTH_BYTES);
if (!devc->raw_sample_buf) {
sr_warn("Sample buffer malloc failed.");
return FALSE;
}
}
if (devc->num_transfers < (devc->limit_samples_max * devc->DATA_WIDTH_BYTES)) {
uint8_t byte;
if (devc->num_transfers <
(devc->limit_samples_max * devc->DATA_WIDTH_BYTES)) {
uint8_t byte;
if (ipdbg_org_la_tcp_receive(tcp, &byte) == 1) {
if (devc->num_transfers < (devc->limit_samples * devc->DATA_WIDTH_BYTES))
devc->raw_sample_buf[devc->num_transfers] = byte;
if (ipdbg_org_la_tcp_receive(tcp, &byte) == 1) {
if (devc->num_transfers <
(devc->limit_samples * devc->DATA_WIDTH_BYTES))
devc->raw_sample_buf[devc->num_transfers] = byte;
devc->num_transfers++;
}
} else {
if (devc->delay_value > 0) {
/* There are pre-trigger samples, send those first. */
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.length = devc->delay_value * devc->DATA_WIDTH_BYTES;
logic.unitsize = devc->DATA_WIDTH_BYTES;
logic.data = devc->raw_sample_buf;
sr_session_send(cb_data, &packet);
}
devc->num_transfers++;
}
} else {
if (devc->delay_value > 0) {
/* There are pre-trigger samples, send those first. */
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.length = devc->delay_value * devc->DATA_WIDTH_BYTES;
logic.unitsize = devc->DATA_WIDTH_BYTES;
logic.data = devc->raw_sample_buf;
sr_session_send(cb_data, &packet);
}
/* Send the trigger. */
packet.type = SR_DF_TRIGGER;
sr_session_send(cb_data, &packet);
/* Send the trigger. */
packet.type = SR_DF_TRIGGER;
sr_session_send(cb_data, &packet);
/* Send post-trigger samples. */
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.length = (devc->limit_samples - devc->delay_value) * devc->DATA_WIDTH_BYTES;
logic.unitsize = devc->DATA_WIDTH_BYTES;
logic.data = devc->raw_sample_buf + (devc->delay_value * devc->DATA_WIDTH_BYTES);
sr_session_send(cb_data, &packet);
/* Send post-trigger samples. */
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.length = (devc->limit_samples - devc->delay_value) *
devc->DATA_WIDTH_BYTES;
logic.unitsize = devc->DATA_WIDTH_BYTES;
logic.data = devc->raw_sample_buf +
(devc->delay_value * devc->DATA_WIDTH_BYTES);
sr_session_send(cb_data, &packet);
g_free(devc->raw_sample_buf);
devc->raw_sample_buf = NULL;
g_free(devc->raw_sample_buf);
devc->raw_sample_buf = NULL;
ipdbg_org_la_abort_acquisition(sdi);
}
ipdbg_org_la_abort_acquisition(sdi);
}
return TRUE;
return TRUE;
}
SR_PRIV int ipdbg_org_la_send_delay(struct ipdbg_org_la_dev_context *devc,
struct ipdbg_org_la_tcp *tcp)
{
devc->delay_value = (devc->limit_samples / 100.0) * devc->capture_ratio;
devc->delay_value = (devc->limit_samples / 100.0) * devc->capture_ratio;
uint8_t buf;
buf = CMD_CFG_LA;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_LA_DELAY;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
uint8_t buf;
buf = CMD_CFG_LA;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_LA_DELAY;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
uint8_t delay_buf[4] = { devc->delay_value & 0x000000ff,
(devc->delay_value >> 8) & 0x000000ff,
(devc->delay_value >> 16) & 0x000000ff,
(devc->delay_value >> 24) & 0x000000ff};
uint8_t delay_buf[4] = { devc->delay_value & 0x000000ff,
(devc->delay_value >> 8) & 0x000000ff,
(devc->delay_value >> 16) & 0x000000ff,
(devc->delay_value >> 24) & 0x000000ff
};
for (uint64_t i = 0; i < devc->ADDR_WIDTH_BYTES; i++)
send_escaping(tcp, &(delay_buf[devc->ADDR_WIDTH_BYTES-1-i]), 1);
for (uint64_t i = 0; i < devc->ADDR_WIDTH_BYTES; i++)
send_escaping(tcp, &(delay_buf[devc->ADDR_WIDTH_BYTES - 1 - i]), 1);
return SR_OK;
return SR_OK;
}
SR_PRIV int ipdbg_org_la_send_trigger(struct ipdbg_org_la_dev_context *devc,
struct ipdbg_org_la_tcp *tcp)
{
uint8_t buf;
uint8_t buf;
/* Mask */
buf = CMD_CFG_TRIGGER;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASKS;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASK;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
/* Mask */
buf = CMD_CFG_TRIGGER;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASKS;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASK;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
for (size_t i = 0; i < devc->DATA_WIDTH_BYTES; i++)
send_escaping(tcp, devc->trigger_mask + devc->DATA_WIDTH_BYTES - 1 - i, 1);
for (size_t i = 0; i < devc->DATA_WIDTH_BYTES; i++)
send_escaping(tcp,
devc->trigger_mask + devc->DATA_WIDTH_BYTES - 1 - i, 1);
/* Value */
buf = CMD_CFG_TRIGGER;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASKS;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_VALUE;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
/* Value */
buf = CMD_CFG_TRIGGER;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASKS;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_VALUE;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
for (size_t i = 0; i < devc->DATA_WIDTH_BYTES; i++)
send_escaping(tcp, devc->trigger_value + devc->DATA_WIDTH_BYTES - 1 - i, 1);
for (size_t i = 0; i < devc->DATA_WIDTH_BYTES; i++)
send_escaping(tcp,
devc->trigger_value + devc->DATA_WIDTH_BYTES - 1 - i, 1);
/* Mask_last */
buf = CMD_CFG_TRIGGER;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASKS_LAST;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASK_LAST;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
/* Mask_last */
buf = CMD_CFG_TRIGGER;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASKS_LAST;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASK_LAST;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
for (size_t i = 0; i < devc->DATA_WIDTH_BYTES; i++)
send_escaping(tcp, devc->trigger_mask_last + devc->DATA_WIDTH_BYTES - 1 - i, 1);
for (size_t i = 0; i < devc->DATA_WIDTH_BYTES; i++)
send_escaping(tcp,
devc->trigger_mask_last + devc->DATA_WIDTH_BYTES - 1 - i, 1);
/* Value_last */
buf = CMD_CFG_TRIGGER;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASKS_LAST;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_VALUE_LAST;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
/* Value_last */
buf = CMD_CFG_TRIGGER;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_MASKS_LAST;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_VALUE_LAST;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
for (size_t i = 0; i < devc->DATA_WIDTH_BYTES; i++)
send_escaping(tcp, devc->trigger_value_last + devc->DATA_WIDTH_BYTES - 1 - i, 1);
for (size_t i = 0; i < devc->DATA_WIDTH_BYTES; i++)
send_escaping(tcp,
devc->trigger_value_last + devc->DATA_WIDTH_BYTES - 1 - i, 1);
/* Edge_mask */
buf = CMD_CFG_TRIGGER;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_SELECT_EDGE_MASK;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_SET_EDGE_MASK;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
/* Edge_mask */
buf = CMD_CFG_TRIGGER;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_SELECT_EDGE_MASK;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
buf = CMD_TRIG_SET_EDGE_MASK;
ipdbg_org_la_tcp_send(tcp, &buf, 1);
for (size_t i = 0; i < devc->DATA_WIDTH_BYTES; i++)
send_escaping(tcp, devc->trigger_edge_mask + devc->DATA_WIDTH_BYTES - 1 - i, 1);
for (size_t i = 0; i < devc->DATA_WIDTH_BYTES; i++)
send_escaping(tcp,
devc->trigger_edge_mask + devc->DATA_WIDTH_BYTES - 1 - i, 1);
return SR_OK;
return SR_OK;
}
SR_PRIV int send_escaping(struct ipdbg_org_la_tcp *tcp, uint8_t *dataToSend, uint32_t length)
SR_PRIV int send_escaping(struct ipdbg_org_la_tcp *tcp, uint8_t *dataToSend,
uint32_t length)
{
uint8_t escape = CMD_ESCAPE;
uint8_t escape = CMD_ESCAPE;
while (length--) {
uint8_t payload = *dataToSend++;
while (length--) {
uint8_t payload = *dataToSend++;
if (payload == (uint8_t)CMD_RESET)
if (ipdbg_org_la_tcp_send(tcp, &escape, 1) != SR_OK)
sr_warn("Couldn't send escape");
if (payload == (uint8_t) CMD_RESET)
if (ipdbg_org_la_tcp_send(tcp, &escape, 1) != SR_OK)
sr_warn("Couldn't send escape");
if (payload == (uint8_t)CMD_ESCAPE)
if (ipdbg_org_la_tcp_send(tcp, &escape, 1) != SR_OK)
sr_warn("Couldn't send escape");
if (payload == (uint8_t) CMD_ESCAPE)
if (ipdbg_org_la_tcp_send(tcp, &escape, 1) != SR_OK)
sr_warn("Couldn't send escape");
if (ipdbg_org_la_tcp_send(tcp, &payload, 1) != SR_OK)
sr_warn("Couldn't send data");
}
if (ipdbg_org_la_tcp_send(tcp, &payload, 1) != SR_OK)
sr_warn("Couldn't send data");
}
return SR_OK;
return SR_OK;
}
SR_PRIV void ipdbg_org_la_get_addrwidth_and_datawidth(struct ipdbg_org_la_tcp *tcp,
struct ipdbg_org_la_dev_context *devc)
SR_PRIV void ipdbg_org_la_get_addrwidth_and_datawidth(
struct ipdbg_org_la_tcp *tcp, struct ipdbg_org_la_dev_context *devc)
{
uint8_t buf[8];
uint8_t read_cmd = CMD_GET_BUS_WIDTHS;
uint8_t buf[8];
uint8_t read_cmd = CMD_GET_BUS_WIDTHS;
if (ipdbg_org_la_tcp_send(tcp, &read_cmd, 1) != SR_OK)
sr_warn("Can't send read command");
if (ipdbg_org_la_tcp_send(tcp, &read_cmd, 1) != SR_OK)
sr_warn("Can't send read command");
if (ipdbg_org_la_tcp_receive_blocking(tcp, buf, 8) != 8)
sr_warn("Can't get address and data width from device");
if (ipdbg_org_la_tcp_receive_blocking(tcp, buf, 8) != 8)
sr_warn("Can't get address and data width from device");
devc->DATA_WIDTH = buf[0] & 0x000000FF;
devc->DATA_WIDTH |= (buf[1] << 8) & 0x0000FF00;
devc->DATA_WIDTH |= (buf[2] << 16) & 0x00FF0000;
devc->DATA_WIDTH |= (buf[3] << 24) & 0xFF000000;
devc->DATA_WIDTH = buf[0] & 0x000000FF;
devc->DATA_WIDTH |= (buf[1] << 8) & 0x0000FF00;
devc->DATA_WIDTH |= (buf[2] << 16) & 0x00FF0000;
devc->DATA_WIDTH |= (buf[3] << 24) & 0xFF000000;
devc->ADDR_WIDTH = buf[4] & 0x000000FF;
devc->ADDR_WIDTH |= (buf[5] << 8) & 0x0000FF00;
devc->ADDR_WIDTH |= (buf[6] << 16) & 0x00FF0000;
devc->ADDR_WIDTH |= (buf[7] << 24) & 0xFF000000;
devc->ADDR_WIDTH = buf[4] & 0x000000FF;
devc->ADDR_WIDTH |= (buf[5] << 8) & 0x0000FF00;
devc->ADDR_WIDTH |= (buf[6] << 16) & 0x00FF0000;
devc->ADDR_WIDTH |= (buf[7] << 24) & 0xFF000000;
uint8_t HOST_WORD_SIZE = 8;
uint8_t HOST_WORD_SIZE = 8;
devc->DATA_WIDTH_BYTES = (devc->DATA_WIDTH + HOST_WORD_SIZE - 1) / HOST_WORD_SIZE;
devc->ADDR_WIDTH_BYTES = (devc->ADDR_WIDTH + HOST_WORD_SIZE - 1) / HOST_WORD_SIZE;
devc->limit_samples_max = (0x01 << devc->ADDR_WIDTH);
devc->limit_samples = devc->limit_samples_max;
devc->DATA_WIDTH_BYTES =
(devc->DATA_WIDTH + HOST_WORD_SIZE - 1) / HOST_WORD_SIZE;
devc->ADDR_WIDTH_BYTES =
(devc->ADDR_WIDTH + HOST_WORD_SIZE - 1) / HOST_WORD_SIZE;
devc->trigger_mask = g_malloc0(devc->DATA_WIDTH_BYTES);
devc->trigger_value = g_malloc0(devc->DATA_WIDTH_BYTES);
devc->trigger_mask_last = g_malloc0(devc->DATA_WIDTH_BYTES);
devc->trigger_value_last = g_malloc0(devc->DATA_WIDTH_BYTES);
devc->trigger_edge_mask = g_malloc0(devc->DATA_WIDTH_BYTES);
devc->limit_samples_max = (0x01 << devc->ADDR_WIDTH);
devc->limit_samples = devc->limit_samples_max;
devc->trigger_mask = g_malloc0(devc->DATA_WIDTH_BYTES);
devc->trigger_value = g_malloc0(devc->DATA_WIDTH_BYTES);
devc->trigger_mask_last = g_malloc0(devc->DATA_WIDTH_BYTES);
devc->trigger_value_last = g_malloc0(devc->DATA_WIDTH_BYTES);
devc->trigger_edge_mask = g_malloc0(devc->DATA_WIDTH_BYTES);
}
SR_PRIV struct ipdbg_org_la_dev_context *ipdbg_org_la_dev_new(void)
{
struct ipdbg_org_la_dev_context *devc;
struct ipdbg_org_la_dev_context *devc;
devc = g_malloc0(sizeof(struct ipdbg_org_la_dev_context));
devc->capture_ratio = 50;
devc = g_malloc0(sizeof(struct ipdbg_org_la_dev_context));
devc->capture_ratio = 50;
return devc;
return devc;
}
SR_PRIV int ipdbg_org_la_send_reset(struct ipdbg_org_la_tcp *tcp)
{
uint8_t buf = CMD_RESET;
if (ipdbg_org_la_tcp_send(tcp, &buf, 1) != SR_OK)
sr_warn("Couldn't send reset");
uint8_t buf = CMD_RESET;
if (ipdbg_org_la_tcp_send(tcp, &buf, 1) != SR_OK)
sr_warn("Couldn't send reset");
return SR_OK;
return SR_OK;
}
SR_PRIV int ipdbg_org_la_request_id(struct ipdbg_org_la_tcp *tcp)
{
uint8_t buf = CMD_GET_LA_ID;
if (ipdbg_org_la_tcp_send(tcp, &buf, 1) != SR_OK)
sr_warn("Couldn't send ID request");
uint8_t buf = CMD_GET_LA_ID;
if (ipdbg_org_la_tcp_send(tcp, &buf, 1) != SR_OK)
sr_warn("Couldn't send ID request");
char id[4];
if (ipdbg_org_la_tcp_receive_blocking(tcp, (uint8_t*)id, 4) != 4)
sr_warn("Couldn't read device ID");
char id[4];
if (ipdbg_org_la_tcp_receive_blocking(tcp, (uint8_t *) id, 4) != 4)
sr_warn("Couldn't read device ID");
if (strncmp(id, "IDBG", 4)) {
sr_err("Invalid device ID: expected 'IDBG', got '%c%c%c%c'.",
id[0], id[1], id[2], id[3]);
return SR_ERR;
}
if (strncmp(id, "IDBG", 4)) {
sr_err("Invalid device ID: expected 'IDBG', got '%c%c%c%c'.",
id[0], id[1], id[2], id[3]);
return SR_ERR;
}
return SR_OK;
return SR_OK;
}
SR_PRIV void ipdbg_org_la_abort_acquisition(const struct sr_dev_inst *sdi)
{
struct ipdbg_org_la_tcp *tcp = sdi->conn;
struct ipdbg_org_la_tcp *tcp = sdi->conn;
sr_session_source_remove(sdi->session, tcp->socket);
sr_session_source_remove(sdi->session, tcp->socket);
std_session_send_df_end(sdi);
std_session_send_df_end(sdi);
}
SR_PRIV int ipdbg_org_la_send_start(struct ipdbg_org_la_tcp *tcp)
{
uint8_t buf = CMD_START;
uint8_t buf = CMD_START;
if (ipdbg_org_la_tcp_send(tcp, &buf, 1) != SR_OK)
sr_warn("Couldn't send start");
if (ipdbg_org_la_tcp_send(tcp, &buf, 1) != SR_OK)
sr_warn("Couldn't send start");
return SR_OK;
return SR_OK;
}

66
src/hardware/ipdbg-logic-analyser/protocol.h
View File

@ -27,33 +27,31 @@
#define LOG_PREFIX "ipdbg-org-la"
struct ipdbg_org_la_tcp {
char *address;
char *port;
int socket;
char *address;
char *port;
int socket;
};
/** Private, per-device-instance driver context. */
struct ipdbg_org_la_dev_context
{
uint32_t DATA_WIDTH;
uint32_t DATA_WIDTH_BYTES;
uint32_t ADDR_WIDTH;
uint32_t ADDR_WIDTH_BYTES;
struct ipdbg_org_la_dev_context {
uint32_t DATA_WIDTH;
uint32_t DATA_WIDTH_BYTES;
uint32_t ADDR_WIDTH;
uint32_t ADDR_WIDTH_BYTES;
uint64_t limit_samples;
uint64_t limit_samples_max;
uint8_t capture_ratio;
uint8_t *trigger_mask;
uint8_t *trigger_value;
uint8_t *trigger_mask_last;
uint8_t *trigger_value_last;
uint8_t *trigger_edge_mask;
uint64_t delay_value;
int num_stages;
uint64_t num_transfers;
uint8_t *raw_sample_buf;
uint64_t limit_samples;
uint64_t limit_samples_max;
uint8_t capture_ratio;
uint8_t *trigger_mask;
uint8_t *trigger_value;
uint8_t *trigger_mask_last;
uint8_t *trigger_value_last;
uint8_t *trigger_edge_mask;
uint64_t delay_value;
int num_stages;
uint64_t num_transfers;
uint8_t *raw_sample_buf;
};
int data_available(struct ipdbg_org_la_tcp *tcp);
@ -62,22 +60,30 @@ SR_PRIV struct ipdbg_org_la_tcp *ipdbg_org_la_tcp_new(void);
SR_PRIV void ipdbg_org_la_tcp_free(struct ipdbg_org_la_tcp *tcp);
SR_PRIV int ipdbg_org_la_tcp_open(struct ipdbg_org_la_tcp *tcp);
SR_PRIV int ipdbg_org_la_tcp_close(struct ipdbg_org_la_tcp *tcp);
SR_PRIV int ipdbg_org_la_tcp_send(struct ipdbg_org_la_tcp *tcp, const uint8_t *buf, size_t len);
SR_PRIV int ipdbg_org_la_tcp_receive_blocking(struct ipdbg_org_la_tcp *tcp, uint8_t *buf, int bufsize);
SR_PRIV int ipdbg_org_la_tcp_receive(struct ipdbg_org_la_tcp *tcp, uint8_t *buf);
SR_PRIV int ipdbg_org_la_tcp_send(struct ipdbg_org_la_tcp *tcp,
const uint8_t *buf, size_t len);
SR_PRIV int ipdbg_org_la_tcp_receive_blocking(struct ipdbg_org_la_tcp *tcp,
uint8_t *buf, int bufsize);
SR_PRIV int ipdbg_org_la_tcp_receive(struct ipdbg_org_la_tcp *tcp,
uint8_t *buf);
SR_PRIV int ipdbg_org_la_convert_trigger(const struct sr_dev_inst *sdi);
SR_PRIV struct ipdbg_org_la_dev_context *ipdbg_org_la_dev_new(void);
SR_PRIV void ipdbg_org_la_get_addrwidth_and_datawidth(struct ipdbg_org_la_tcp *tcp, struct ipdbg_org_la_dev_context *devc);
SR_PRIV int send_escaping(struct ipdbg_org_la_tcp *tcp, uint8_t *dataToSend, uint32_t length);
SR_PRIV void ipdbg_org_la_get_addrwidth_and_datawidth(
struct ipdbg_org_la_tcp *tcp, struct ipdbg_org_la_dev_context *devc);
SR_PRIV int send_escaping(struct ipdbg_org_la_tcp *tcp, uint8_t *dataToSend,
uint32_t length);
SR_PRIV int ipdbg_org_la_send_reset(struct ipdbg_org_la_tcp *tcp);
SR_PRIV int ipdbg_org_la_request_id(struct ipdbg_org_la_tcp *tcp);
SR_PRIV int ipdbg_org_la_send_start(struct ipdbg_org_la_tcp *tcp);
SR_PRIV int ipdbg_org_la_send_trigger(struct ipdbg_org_la_dev_context *devc, struct ipdbg_org_la_tcp *tcp);
SR_PRIV int ipdbg_org_la_send_delay(struct ipdbg_org_la_dev_context *devc, struct ipdbg_org_la_tcp *tcp);
SR_PRIV int ipdbg_org_la_send_trigger(struct ipdbg_org_la_dev_context *devc,
struct ipdbg_org_la_tcp *tcp);
SR_PRIV int ipdbg_org_la_send_delay(struct ipdbg_org_la_dev_context *devc,
struct ipdbg_org_la_tcp *tcp);
SR_PRIV int ipdbg_org_la_receive_data(int fd, int revents, void *cb_data);
SR_PRIV void ipdbg_org_la_abort_acquisition(const struct sr_dev_inst *sdi);
SR_PRIV int ipdbg_org_la_tcp_receive_blocking(struct ipdbg_org_la_tcp *tcp, uint8_t *buf, int bufsize);
SR_PRIV int ipdbg_org_la_tcp_receive_blocking(struct ipdbg_org_la_tcp *tcp,
uint8_t * buf, int bufsize);
#endif