X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fhardware%2Fipdbg-logic-analyser%2Fapi.c;h=e2b061d05482662ba66d49d5dad5aaff435b3377;hb=38e7493dd1ec6d1121246f74f1cedfd3291fd5da;hp=05469606644f37dcae4754c5ebdbf0e37e902ceb;hpb=8f6b0eb12aeab55ae10190e20765425fd91837fc;p=libsigrok.git

diff --git a/src/hardware/ipdbg-logic-analyser/api.c b/src/hardware/ipdbg-logic-analyser/api.c
index 05469606..e2b061d0 100644
--- a/src/hardware/ipdbg-logic-analyser/api.c
+++ b/src/hardware/ipdbg-logic-analyser/api.c
@@ -40,7 +40,7 @@ static const int32_t ipdbg_org_la_trigger_matches[] = {
     SR_TRIGGER_ONE,
     SR_TRIGGER_RISING,
     SR_TRIGGER_FALLING,
-    //SR_TRIGGER_EDGE,
+    SR_TRIGGER_EDGE,
 };
 
 SR_PRIV struct sr_dev_driver ipdbg_la_driver_info;
@@ -59,12 +59,9 @@ static void ipdbg_org_la_split_addr_port(const char *conn, char **addr, char **p
 
 static GSList *scan(struct sr_dev_driver *di, GSList *options)
 {
-    sr_err("scan\n");
     struct drv_context *drvc;
     GSList *devices;
 
-    (void)options;
-
     devices = NULL;
     drvc = di->context;
     drvc->instances = NULL;
@@ -96,8 +93,6 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options)
     if(ipdbg_org_la_tcp_open(tcp) != SR_OK)
         return NULL;
 
-    sr_err("set Reset\n");
-//////////////////////////////////////////////////////////////////////////////////////////
     ipdbg_org_la_sendReset(tcp);
     ipdbg_org_la_sendReset(tcp);
 
@@ -113,21 +108,19 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options)
     sdi->model = g_strdup("Logic Analyzer");
     sdi->version = g_strdup("v1.0");
     sdi->driver = di;
-    const size_t bufSize = 16;
-    char buff[bufSize];
-
 
     struct ipdbg_org_la_dev_context *devc = ipdbg_org_la_dev_new();
     sdi->priv = devc;
 
     ipdbg_org_la_get_addrwidth_and_datawidth(tcp, devc);
 
-    sr_err("addr_width = %d, data_width = %d\n", devc->ADDR_WIDTH, devc->DATA_WIDTH);
-    sr_err("limit samples = %d\n", devc->limit_samples_max);
-    /////////////////////////////////////////////////////////////////////////////////////////////////////////
+    sr_dbg("addr_width = %d, data_width = %d\n", devc->ADDR_WIDTH, devc->DATA_WIDTH);
+    sr_dbg("limit samples = %d\n", devc->limit_samples_max);
 
-    for (int i = 0; i < devc->DATA_WIDTH; i++)
+    for (unsigned int i = 0; i < devc->DATA_WIDTH; i++)
     {
+        const size_t bufSize = 16;
+        char buff[bufSize];
         snprintf(buff, bufSize, "ch%d", i);
         sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, buff);
     }
@@ -145,8 +138,6 @@ static GSList *scan(struct sr_dev_driver *di, GSList *options)
 
 static int dev_clear(const struct sr_dev_driver *di)
 {
-    //sr_err("dev_clear\n");
-
     struct drv_context *drvc = di->context;
     struct sr_dev_inst *sdi;
     GSList *l;
@@ -170,20 +161,14 @@ static int dev_clear(const struct sr_dev_driver *di)
 
 static int dev_open(struct sr_dev_inst *sdi)
 {
-    //sr_err("dev_open\n");
-    (void)sdi;
-
-    /* TODO: get handle from sdi->conn and open it. */
     sdi->status = SR_ST_INACTIVE;
 
     struct ipdbg_org_la_tcp *tcp = sdi->conn;
 
     if (!tcp)
-    {
         return SR_ERR;
-    }
 
-    if(ipdbg_org_la_tcp_open(tcp) != SR_OK)
+    if (ipdbg_org_la_tcp_open(tcp) != SR_OK)
         return SR_ERR;
 
     sdi->status = SR_ST_ACTIVE;
@@ -193,17 +178,13 @@ static int dev_open(struct sr_dev_inst *sdi)
 
 static int dev_close(struct sr_dev_inst *sdi)
 {
-    (void)sdi;
-
-    /* TODO: get handle from sdi->conn and close it. */
-    //sr_err("dev_close\n");
-    /// should be called before a new call to scan()
+    // Should be called before a new call to scan()
     struct ipdbg_org_la_tcp *tcp = sdi->conn;
-    if(tcp)
+
+    if (tcp)
         ipdbg_org_la_tcp_close(tcp);
 
     sdi->conn = NULL;
-
     sdi->status = SR_ST_INACTIVE;
 
     return SR_OK;
@@ -212,15 +193,12 @@ static int dev_close(struct sr_dev_inst *sdi)
 static int config_get(uint32_t key, GVariant **data,
     const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 {
-    int ret;
+    int ret = SR_OK;
 
-    (void)sdi;
-    (void)data;
     (void)cg;
 
     struct ipdbg_org_la_dev_context *devc = sdi->priv;
 
-    ret = SR_OK;
     switch (key) {
     case SR_CONF_CAPTURE_RATIO:
         *data = g_variant_new_uint64(devc->capture_ratio);
@@ -229,7 +207,7 @@ static int config_get(uint32_t key, GVariant **data,
         *data = g_variant_new_uint64(devc->limit_samples);
         break;
     default:
-        return SR_ERR_NA;
+        ret = SR_ERR_NA;
     }
 
     return ret;
@@ -238,38 +216,30 @@ static int config_get(uint32_t key, GVariant **data,
 static int config_set(uint32_t key, GVariant *data,
     const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
 {
-    int ret;
+    int ret = SR_OK;
+    uint64_t value;
 
-    (void)data;
     (void)cg;
 
     if (sdi->status != SR_ST_ACTIVE)
         return SR_ERR_DEV_CLOSED;
 
-    //sr_err("config_set\n");
     struct ipdbg_org_la_dev_context *devc = sdi->priv;
 
-    ret = SR_OK;
     switch (key) {
     case SR_CONF_CAPTURE_RATIO:
-        devc->capture_ratio = g_variant_get_uint64(data);
-        if (devc->capture_ratio < 0 || devc->capture_ratio > 100)
-        {
-            devc->capture_ratio = 50;
-            ret = SR_ERR;
-        }
+    	value = g_variant_get_uint64(data);
+        if (value <= 100)
+            devc->capture_ratio = value;
         else
-            ret = SR_OK;
+        	ret = SR_ERR;
         break;
     case SR_CONF_LIMIT_SAMPLES:
-        devc->limit_samples = g_variant_get_uint64(data);
-        if(devc->limit_samples > devc->limit_samples_max)
-        {
-            devc->limit_samples = devc->limit_samples_max;
-            ret = SR_ERR;
-        }
+    	value = g_variant_get_uint64(data);
+        if (value <= devc->limit_samples_max)
+        	devc->limit_samples = value;
         else
-            ret = SR_OK;
+            ret = SR_ERR;
         break;
     default:
         ret = SR_ERR_NA;
@@ -285,16 +255,20 @@ static int config_list(uint32_t key, GVariant **data,
 
     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));
+        *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));
+            *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));
+            *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));
+        *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;
@@ -303,7 +277,6 @@ static int config_list(uint32_t key, GVariant **data,
     return SR_OK;
 }
 
-
 static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
 {
     return std_init(di, sr_ctx);
@@ -311,12 +284,11 @@ static int init(struct sr_dev_driver *di, struct sr_context *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;
     struct ipdbg_org_la_tcp *tcp = sdi->conn;
@@ -324,45 +296,44 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi)
     struct ipdbg_org_la_dev_context *devc = sdi->priv;
 
     ipdbg_org_la_convert_trigger(sdi);
-    //sr_err("dev_acquisition_start\n");
 
     /* Send Triggerkonviguration */
     ipdbg_org_la_sendTrigger(devc, tcp);
-    //sr_err("dev_acquisition_start1\n");
 
     /* Send Delay */
-    ipdbg_org_la_sendDelay(devc, tcp);
-    //sr_err("dev_acquisition_start2\n");
+    ipdbg_org_la_sendDelay(devc, tcp);;
 
-    //std_session_send_df_header(sdi, LOG_PREFIX);
-    std_session_send_df_header(sdi);
-    //sr_err("dev_acquisition_start3\n");
     /* 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, -1, G_IO_IN, 100, ipdbg_receive_data, (struct sr_dev_inst *)sdi);
-    //sr_session_source_add(sdi->session, -1, G_IO_IN, 100, ipdbg_org_la_receive_data, NULL);
     sr_session_source_add(sdi->session, tcp->socket, G_IO_IN, 100, ipdbg_org_la_receive_data, (struct sr_dev_inst *)sdi);
-    //sr_err("dev_acquisition_start4\n");
 
     ipdbg_org_la_sendStart(tcp);
-    //sr_err("dev_acquisition_start5\n");
-    /* TODO: configure hardware, reset acquisition state, set up
-     * callbacks and send header packet. */
 
     return SR_OK;
 }
 
 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
 {
+    struct ipdbg_org_la_dev_context *devc = sdi->priv;
+    struct ipdbg_org_la_tcp *tcp = sdi->conn;
 
-    sr_err("dev_acquisition_stop\n");
+    unsigned char byte;
 
-    if (sdi->status != SR_ST_ACTIVE)
-        return SR_ERR_DEV_CLOSED;
+    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_sendReset(tcp);
     ipdbg_org_la_abort_acquisition(sdi);
 
+
+
     return SR_OK;
 }