Add register debug and sense ID commands to channel tool

Author: lowobservable

cxip/cxip.c

@@ -56,6 +56,7 @@ struct state {
     struct client clients[CLIENTS_MAX];
 };
 
+static void usage(char *cmd);
 static bool serve(int listen_sock, struct chan *chan, struct dev *dev);
 
 static bool handle_connect(int sock, struct client **client, struct state *state);
@@ -69,7 +70,7 @@ static struct dev *find_dev(struct state *state, int num);
 static struct client *find_client(struct state *state, int sock);
 static bool close_client(struct client *client, struct state *state);
 
-static void usage(char *cmd);
+static bool parse_dev_num(char *str, uint16_t *num);
 static bool parse_dev_config(char *config, uint16_t *num, uint8_t *addr);
 
 int main(int argc, char **argv)
@@ -112,7 +113,7 @@ int main(int argc, char **argv)
     uint8_t dev_addr;
 
     if (!parse_dev_config(dev_config, &dev_num, &dev_addr)) {
-        printf("Device config invalid: %s\n", argv[optind]);
+        printf("Invalid device config: %s\n", argv[optind]);
         return EXIT_FAILURE;
     }
 
@@ -160,13 +161,13 @@ int main(int argc, char **argv)
 
     struct chan chan;
 
-    int result = chan_out_open(&chan.out, mem_fd, "udmabuf0", frontend_enable);
+    int result = chan_out_open(&chan.out, mem_fd, "udmabuf0", false);
 
     if (result == -1) {
         perror("chan_open");
         return EXIT_FAILURE;
     } else if (result < -1) {
-        printf("chan_open error: %d\n", result);
+        printf("chan_out_open error: %d\n", result);
         return EXIT_FAILURE;
     }
 
@@ -184,7 +185,7 @@ int main(int argc, char **argv)
 
     printf("Device number %.4X configured for address %.2X\n", dev.num, dev.addr);
 
-    chan_out_enable(&chan.out);
+    chan_out_config(&chan.out, true, frontend_enable);
 
     struct mock_cu mock_cu;
 
@@ -208,7 +209,7 @@ int main(int argc, char **argv)
         mock_cu_close(&mock_cu);
     }
 
-    chan_out_close(&chan.out);
+    chan_out_close(&chan.out, true);
 
     free(chan.recv_buf);
 
@@ -218,6 +219,11 @@ int main(int argc, char **argv)
     return (success ? EXIT_SUCCESS : EXIT_FAILURE);
 }
 
+void usage(char *cmd)
+{
+    printf("Usage: %s [-lm] nnnn[:aa]\n", cmd);
+}
+
 volatile bool stop = false;
 
 static void signal_handler(int signum)
@@ -481,7 +487,7 @@ bool handle_msg(struct client *client, uint8_t *msg, size_t msg_len, struct stat
             return cxip_send_error(client->sock, 0, "Device already open");
         }
 
-        chan_out_config(&dev->chan->out, dev->addr, true);
+        chan_out_dev_config(&dev->chan->out, dev->addr, true);
 
         printf("%.4X | %.2X | Open   |\n", dev->num, dev->addr);
 
@@ -501,7 +507,7 @@ bool handle_msg(struct client *client, uint8_t *msg, size_t msg_len, struct stat
             return cxip_send_error(client->sock, 0, "Device not open");
         }
 
-        chan_out_config(&dev->chan->out, dev->addr, false);
+        chan_out_dev_config(&dev->chan->out, dev->addr, false);
 
         printf("%.4X | %.2X | Close  |\n", dev->num, dev->addr);
 
@@ -654,7 +660,7 @@ bool close_client(struct client *client, struct state *state)
     if (state->dev != NULL && state->dev->client == client) {
         struct dev *dev = state->dev;
 
-        chan_out_config(&dev->chan->out, dev->addr, false);
+        chan_out_dev_config(&dev->chan->out, dev->addr, false);
 
         dev->client = NULL;
     }
@@ -674,9 +680,41 @@ bool close_client(struct client *client, struct state *state)
     return true;
 }
 
-void usage(char *cmd)
+bool parse_dev_num(char *str, uint16_t *num)
 {
-    printf("Usage: %s [-lm] nnnn[:aa]\n", cmd);
+    if (str == NULL) {
+        return false;
+    }
+
+    size_t digits = 0;
+
+    for (size_t index = 0; index < strlen(str); index++) {
+        if (isblank(str[index])) {
+            continue;
+        }
+
+        if (!isxdigit(str[index])) {
+            return false;
+        }
+
+        if (++digits > 4) {
+            return false;
+        }
+    }
+
+    char *end;
+
+    errno = 0;
+
+    unsigned long value = strtol(str, &end, 16);
+
+    if (errno != 0 || *end != '\0') {
+        return false;
+    }
+
+    *num = (uint16_t) value;
+
+    return true;
 }
 
 bool parse_dev_config(char *config, uint16_t *num, uint8_t *addr)
@@ -692,38 +730,16 @@ bool parse_dev_config(char *config, uint16_t *num, uint8_t *addr)
         return false;
     }
 
-    for (int element = 0; element < 2; element++) {
-        for (size_t index = 0; index < strlen(token); index++) {
-            if (!(isxdigit(token[index]) || isblank(token[index]))) {
-                return false;
-            }
-        }
-
-        char *end;
-
-        errno = 0;
-
-        unsigned long value = strtol(token, &end, 16);
-
-        if (errno != 0 || *end != '\0') {
-            return false;
-        }
-
-        if (element == 0 && value <= 0xffff) {
-            *num = (uint16_t) value;
-            *addr = (uint8_t) (value & 0xff);
-        } else if (element == 1 && value <= 0xff) {
-            *addr = (uint8_t) (value & 0xff);
-        } else {
-            return false;
-        }
-
-        if (strlen(rest) == 0) {
-            break;
-        }
+    if (!parse_dev_num(token, num)) {
+        return false;
+    }
 
-        token = rest;
+    if (strlen(rest) == 0) {
+        *addr = (uint8_t) (*num & 0xff);
+        return true;
     }
 
-    return true;
+    token = rest;
+
+    return chan_parse_dev_addr(token, addr);
 }

libchan/chan.c

@@ -1,8 +1,12 @@
 #include <stdio.h>
 #include <stdint.h>
+#include <string.h>
 #include <stddef.h>
+#include <stdlib.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
 
 #include "chan.h"
 
@@ -47,6 +51,10 @@ ssize_t chan_exec(struct chan_out *out, uint8_t addr, uint8_t cmd, uint8_t flags
         *status = cumulative_status;
     }
 
+    if (cumulative_status != (CHAN_STATUS_CE | CHAN_STATUS_DE)) {
+        return CHAN_ERR_EXEC_STATUS;
+    }
+
     return chan_out_complete(out, cmd, buf, count);
 }
 
@@ -60,7 +68,17 @@ ssize_t chan_exec_basic_sense(struct chan_out *out, uint8_t addr, void *buf, siz
         return CHAN_ERR_ARGS;
     }
 
-    return chan_exec(out, addr, CHAN_CMD_BASIC_SENSE, 0, buf, count, status);
+    ssize_t result = chan_exec(out, addr, CHAN_CMD_BASIC_SENSE, 0, buf, count, status);
+
+    if (result < 0) {
+        return result;
+    }
+
+    if (result < 1) {
+        return CHAN_ERR_EXEC_COUNT;
+    }
+
+    return result;
 }
 
 ssize_t chan_exec_sense_id(struct chan_out *out, uint8_t addr, void *buf, size_t count, uint8_t *status)
@@ -80,13 +98,13 @@ ssize_t chan_exec_sense_id(struct chan_out *out, uint8_t addr, void *buf, size_t
     }
 
     if (result < 4) {
-        return -1;
+        return CHAN_ERR_EXEC_COUNT;
     }
 
     uint8_t *p = buf;
 
     if (p[0] != 0xff) {
-        return -1;
+        return CHAN_ERR_EXEC_DATA;
     }
 
     return result;
@@ -101,12 +119,49 @@ int chan_exec_nop(struct chan_out *out, uint8_t addr, uint8_t *status)
     }
 
     if (result != 0) {
-        return -1;
+        return CHAN_ERR_EXEC_COUNT;
     }
 
     return 0;
 }
 
+bool chan_parse_dev_addr(char *str, uint8_t *addr)
+{
+    if (str == NULL) {
+        return false;
+    }
+
+    size_t digits = 0;
+
+    for (size_t index = 0; index < strlen(str); index++) {
+        if (isblank(str[index])) {
+            continue;
+        }
+
+        if (!isxdigit(str[index])) {
+            return false;
+        }
+
+        if (++digits > 2) {
+            return false;
+        }
+    }
+
+    char *end;
+
+    errno = 0;
+
+    unsigned long value = strtol(str, &end, 16);
+
+    if (errno != 0 || *end != '\0') {
+        return false;
+    }
+
+    *addr = (uint8_t) value;
+
+    return true;
+}
+
 char *chan_fmt_status(uint8_t status, char *buf, size_t size)
 {
     if (size < CHAN_FMT_STATUS_BUF_SIZE) {
@@ -223,7 +278,7 @@ char *chan_fmt_cmd(uint8_t cmd, char *buf, size_t size)
         p += sprintf(p, "*");
     }
 
-    p += sprintf(p, ">");
+    sprintf(p, ">");
 
     return buf;
 }

libchan/chan.h

@@ -36,6 +36,9 @@
 #define CHAN_ERR_STATUS_PENDING -8      // Status pending
 #define CHAN_ERR_CMD_RESERVED   -9      // Reserved command
 #define CHAN_ERR_DMA_SIZE       -10     // DMA buffer limit
+#define CHAN_ERR_EXEC_STATUS    -11     // Unexpected status
+#define CHAN_ERR_EXEC_COUNT     -12     // Unexpected count
+#define CHAN_ERR_EXEC_DATA      -13     // Unexpected data
 
 struct chan_out {
     uintptr_t base_addr;
@@ -44,15 +47,15 @@ struct chan_out {
     struct udmabuf udmabuf;
 };
 
-int chan_out_open(struct chan_out *out, int mem_fd, char *udmabuf_path, bool frontend_enable);
+int chan_out_open(struct chan_out *out, int mem_fd, char *udmabuf_path, bool ignore_state);
 
-int chan_out_close(struct chan_out *out);
+int chan_out_close(struct chan_out *out, bool reset);
 
-int chan_out_enable(struct chan_out *out);
+bool chan_out_is_enabled(struct chan_out *out);
 
-int chan_out_disable(struct chan_out *out);
+int chan_out_config(struct chan_out *out, bool enable, bool frontend_enable);
 
-int chan_out_config(struct chan_out *out, uint8_t addr, bool enable);
+int chan_out_dev_config(struct chan_out *out, uint8_t addr, bool enable);
 
 int chan_out_test(struct chan_out *out, uint8_t addr, uint8_t *status);
 
@@ -72,6 +75,8 @@ ssize_t chan_exec_sense_id(struct chan_out *out, uint8_t addr, void *buf, size_t
 
 int chan_exec_nop(struct chan_out *out, uint8_t addr, uint8_t *status);
 
+bool chan_parse_dev_addr(char *str, uint8_t *addr);
+
 char *chan_fmt_status(uint8_t status, char *buf, size_t size);
 
 char *chan_fmt_cmd(uint8_t cmd, char *buf, size_t size);