rename chan to chan_out in libchan

lowobservable · lowobservable · commit 8a53dad2026b · 2025-07-04T11:09:34.000-05:00
diff --git a/cxip/cxip.c b/cxip/cxip.c
@@ -24,11 +24,11 @@
 uint8_t xxx_buf[MSG_BUF_SIZE];
 size_t xxx_buf_len = 0;
 
-bool serve(int listen_sock, struct chan *chan);
-void handle_client(int sock, struct chan *chan);
-void handle_message(int sock, struct chan *chan, uint8_t *msg, size_t msg_len);
-void test_and_send_status(int sock, struct chan *chan, uint8_t addr);
-void purge_status(struct chan *chan, uint8_t addr);
+bool serve(int listen_sock, struct chan_out *chan);
+void handle_client(int sock, struct chan_out *chan);
+void handle_message(int sock, struct chan_out *chan, uint8_t *msg, size_t msg_len);
+void test_and_send_status(int sock, struct chan_out *chan, uint8_t addr);
+void purge_status(struct chan_out *chan, uint8_t addr);
 
 int main(int argc, char **argv)
 {
@@ -74,9 +74,9 @@ int main(int argc, char **argv)
         printf("WARN: External interface not enabled, acting as loopback\n");
     }
 
-    struct chan chan;
+    struct chan_out chan;
 
-    if (chan_open(&chan, 0x40000000, mem_fd, "udmabuf0", frontend_enable) < 0) {
+    if (chan_out_open(&chan, 0x40000000, mem_fd, "udmabuf0", frontend_enable) < 0) {
         perror("chan_open");
         return EXIT_FAILURE;
     }
@@ -95,15 +95,15 @@ int main(int argc, char **argv)
     }
 
     mock_cu_close(&mock_cu);
-    chan_close(&chan, true);
+    chan_out_close(&chan, true);
 
     close(listen_sock);
     close(mem_fd);
 
     return EXIT_SUCCESS;
 }
 
-bool serve(int listen_sock, struct chan *chan)
+bool serve(int listen_sock, struct chan_out *chan)
 {
     int epfd;
 
@@ -183,7 +183,7 @@ purge_status(chan, ADDR);
 
         // Check for request in.
         if (client_sock != -1) {
-            if (chan_request_in(chan)) {
+            if (chan_out_request_in(chan)) {
                 printf("REQUEST IN...\n");
 
                 test_and_send_status(client_sock, chan, ADDR /* TODO */);
@@ -194,7 +194,7 @@ purge_status(chan, ADDR);
     return true;
 }
 
-void handle_client(int sock, struct chan *chan)
+void handle_client(int sock, struct chan_out *chan)
 {
     // First, read as much as we can into the buffer.
     uint8_t *buf_p = xxx_buf + xxx_buf_len;
@@ -251,7 +251,7 @@ void handle_client(int sock, struct chan *chan)
     }
 }
 
-void handle_message(int sock, struct chan *chan, uint8_t *msg, size_t msg_len)
+void handle_message(int sock, struct chan_out *chan, uint8_t *msg, size_t msg_len)
 {
     uint8_t buf[MSG_BUF_SIZE];
 
@@ -296,9 +296,9 @@ void handle_message(int sock, struct chan *chan, uint8_t *msg, size_t msg_len)
 
         printf("\taddr = %.2x, cmd = %.2x, flags = %.2x, count = %zu\n", addr, cmd, flags, count);
 
-        ssize_t result = chan_exec(chan, ADDR /* TODO */, cmd, data, count);
+        ssize_t result = chan_out_exec(chan, ADDR /* TODO */, cmd, data, count);
 
-        uint8_t device_status = chan_device_status(chan);
+        uint8_t device_status = chan_out_device_status(chan);
 
         /*
         ssize_t result;
@@ -339,18 +339,18 @@ void handle_message(int sock, struct chan *chan, uint8_t *msg, size_t msg_len)
             // wait for it via request in...
             printf("\tgot CE without DE, waiting for DE via request in...\n");
 
-            while (!chan_request_in(chan)) {
+            while (!chan_out_request_in(chan)) {
                 usleep(100000); // 100ms
             }
 
-            int test_result = chan_test(chan, ADDR /* TODO */);
+            int test_result = chan_out_test(chan, ADDR /* TODO */);
 
             if (test_result < 0) {
                 printf("\ttest result = %d\n", test_result);
                 return;
             }
 
-            device_status |= chan_device_status(chan);
+            device_status |= chan_out_device_status(chan);
 
             printf("\tupdated status = %.2x\n", device_status);
 
@@ -388,18 +388,18 @@ void handle_message(int sock, struct chan *chan, uint8_t *msg, size_t msg_len)
     }
 }
 
-void test_and_send_status(int sock, struct chan *chan, uint8_t addr)
+void test_and_send_status(int sock, struct chan_out *chan, uint8_t addr)
 {
     uint8_t buf[MSG_BUF_SIZE];
 
-    int result = chan_test(chan, addr);
+    int result = chan_out_test(chan, addr);
 
     if (result < 0) {
         printf("\tresult = %d\n", result);
         return;
     }
 
-    uint8_t device_status = chan_device_status(chan);
+    uint8_t device_status = chan_out_device_status(chan);
 
     printf("\tstatus = %.2x\n", device_status);
 
@@ -414,20 +414,20 @@ void test_and_send_status(int sock, struct chan *chan, uint8_t addr)
     }
 }
 
-void purge_status(struct chan *chan, uint8_t addr)
+void purge_status(struct chan_out *chan, uint8_t addr)
 {
     // Very hacky... this is no way to do error recovery!
     while (true) {
         printf("TEST...\n");
 
-        int result = chan_test(chan, addr);
+        int result = chan_out_test(chan, addr);
 
         if (result < 0) {
             printf("\tresult = %d\n", result);
             return;
         }
 
-        uint8_t status = chan_device_status(chan);
+        uint8_t status = chan_out_device_status(chan);
 
         printf("\tstatus = 0x%.2x\n", status);
 
diff --git a/libchan/Makefile b/libchan/Makefile
@@ -2,7 +2,7 @@ CFLAGS = -Wall -I../libhack
 
 all: libchan.a test_3174 test_mock test_wrap
 
-libchan.a: chan.o mock_cu.o
+libchan.a: chan_out.o mock_cu.o
 	$(AR) rcs $@ $^
 
 test_3174: test_3174.c libchan.a ../libhack/libhack.a
diff --git a/libchan/chan.h b/libchan/chan.h
@@ -16,23 +16,23 @@
 #define CHAN_STATUS_UC      0x02    // Unit Check
 #define CHAN_STATUS_UX      0x01    // Unit Exception
 
-struct chan {
+struct chan_out {
     uintptr_t addr;
     void *base;
     volatile uint32_t *regs;
     struct udmabuf udmabuf;
 };
 
-int chan_open(struct chan *chan, uintptr_t addr, int mem_fd, char *udmabuf_path, bool frontend_enable);
+int chan_out_open(struct chan_out *chan, uintptr_t addr, int mem_fd, char *udmabuf_path, bool frontend_enable);
 
-int chan_close(struct chan *chan, bool disable);
+int chan_out_close(struct chan_out *chan, bool disable);
 
-int chan_test(struct chan *chan, uint8_t addr);
+int chan_out_test(struct chan_out *chan, uint8_t addr);
 
-ssize_t chan_exec(struct chan *chan, uint8_t addr, uint8_t cmd, uint8_t *buf, size_t count);
+ssize_t chan_out_exec(struct chan_out *chan, uint8_t addr, uint8_t cmd, uint8_t *buf, size_t count);
 
-uint8_t chan_device_status(struct chan *chan);
+uint8_t chan_out_device_status(struct chan_out *chan);
 
-bool chan_request_in(struct chan *chan);
+bool chan_out_request_in(struct chan_out *chan);
 
 #endif
diff --git a/libchan/chan_out.c b/libchan/chan_out.c
@@ -18,11 +18,11 @@
 #define REG_CCW_1 4
 #define REG_CCW_2 5
 
-void config(struct chan *chan, bool enable, bool frontend_enable);
+void config(struct chan_out *chan, bool enable, bool frontend_enable);
 static inline bool is_read_cmd(uint8_t cmd);
 static inline bool is_write_cmd(uint8_t cmd);
 
-int chan_open(struct chan *chan, uintptr_t addr, int mem_fd, char *udmabuf_path, bool frontend_enable)
+int chan_out_open(struct chan_out *chan, uintptr_t addr, int mem_fd, char *udmabuf_path, bool frontend_enable)
 {
     chan->addr = addr;
 
@@ -43,7 +43,7 @@ int chan_open(struct chan *chan, uintptr_t addr, int mem_fd, char *udmabuf_path,
     return 0;
 }
 
-int chan_close(struct chan *chan, bool disable)
+int chan_out_close(struct chan_out *chan, bool disable)
 {
     if (chan == NULL) {
         return 0;
@@ -66,7 +66,7 @@ int chan_close(struct chan *chan, bool disable)
     return result;
 }
 
-int chan_test(struct chan *chan, uint8_t addr)
+int chan_out_test(struct chan_out *chan, uint8_t addr)
 {
     // Channel is active...
     if (chan->regs[REG_STATUS_1] & 0x01) {
@@ -91,7 +91,7 @@ int chan_test(struct chan *chan, uint8_t addr)
     return 0;
 }
 
-ssize_t chan_exec(struct chan *chan, uint8_t addr, uint8_t cmd, uint8_t *buf, size_t count)
+ssize_t chan_out_exec(struct chan_out *chan, uint8_t addr, uint8_t cmd, uint8_t *buf, size_t count)
 {
     if (count > 0 && buf == NULL) {
         return -1;
@@ -129,7 +129,7 @@ ssize_t chan_exec(struct chan *chan, uint8_t addr, uint8_t cmd, uint8_t *buf, si
         return -3;
     }
 
-    uint8_t device_status = chan_device_status(chan);
+    uint8_t device_status = chan_out_device_status(chan);
 
     if (device_status & CHAN_STATUS_BUSY) {
         return -4;
@@ -155,17 +155,17 @@ ssize_t chan_exec(struct chan *chan, uint8_t addr, uint8_t cmd, uint8_t *buf, si
     return actual_count;
 }
 
-uint8_t chan_device_status(struct chan *chan)
+uint8_t chan_out_device_status(struct chan_out *chan)
 {
     return (uint8_t) (chan->regs[REG_STATUS_2] >> 24);
 }
 
-bool chan_request_in(struct chan *chan)
+bool chan_out_request_in(struct chan_out *chan)
 {
     return chan->regs[REG_STATUS_1] & 0x02;
 }
 
-void config(struct chan *chan, bool enable, bool frontend_enable)
+void config(struct chan_out *chan, bool enable, bool frontend_enable)
 {
     chan->regs[REG_CONTROL_1] = (frontend_enable << 31) | (enable << 1);
 }
diff --git a/libchan/test_3174.c b/libchan/test_3174.c
diff --git a/libchan/test_mock.c b/libchan/test_mock.c

Original file line number	Diff line number	Diff line change
`@@ -24,11 +24,11 @@`
`24`	`24`	`uint8_t xxx_buf[MSG_BUF_SIZE];`
`25`	`25`	`size_t xxx_buf_len = 0;`
`26`	`26`
`27`		`-bool serve(int listen_sock, struct chan *chan);`
`28`		`-void handle_client(int sock, struct chan *chan);`
`29`		`-void handle_message(int sock, struct chan chan, uint8_t msg, size_t msg_len);`
`30`		`-void test_and_send_status(int sock, struct chan *chan, uint8_t addr);`
`31`		`-void purge_status(struct chan *chan, uint8_t addr);`
	`27`	`+bool serve(int listen_sock, struct chan_out *chan);`
	`28`	`+void handle_client(int sock, struct chan_out *chan);`
	`29`	`+void handle_message(int sock, struct chan_out chan, uint8_t msg, size_t msg_len);`
	`30`	`+void test_and_send_status(int sock, struct chan_out *chan, uint8_t addr);`
	`31`	`+void purge_status(struct chan_out *chan, uint8_t addr);`
`32`	`32`
`33`	`33`	`int main(int argc, char **argv)`
`34`	`34`	`{`
`@@ -74,9 +74,9 @@ int main(int argc, char **argv)`
`74`	`74`	`printf("WARN: External interface not enabled, acting as loopback\n");`
`75`	`75`	`}`
`76`	`76`
`77`		`- struct chan chan;`
	`77`	`+ struct chan_out chan;`
`78`	`78`
`79`		`- if (chan_open(&chan, 0x40000000, mem_fd, "udmabuf0", frontend_enable) < 0) {`
	`79`	`+ if (chan_out_open(&chan, 0x40000000, mem_fd, "udmabuf0", frontend_enable) < 0) {`
`80`	`80`	`perror("chan_open");`
`81`	`81`	`return EXIT_FAILURE;`
`82`	`82`	`}`
`@@ -95,15 +95,15 @@ int main(int argc, char **argv)`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`mock_cu_close(&mock_cu);`
`98`		`- chan_close(&chan, true);`
	`98`	`+ chan_out_close(&chan, true);`
`99`	`99`
`100`	`100`	`close(listen_sock);`
`101`	`101`	`close(mem_fd);`
`102`	`102`
`103`	`103`	`return EXIT_SUCCESS;`
`104`	`104`	`}`
`105`	`105`
`106`		`-bool serve(int listen_sock, struct chan *chan)`
	`106`	`+bool serve(int listen_sock, struct chan_out *chan)`
`107`	`107`	`{`
`108`	`108`	`int epfd;`
`109`	`109`
`@@ -183,7 +183,7 @@ purge_status(chan, ADDR);`
`183`	`183`
`184`	`184`	`// Check for request in.`
`185`	`185`	`if (client_sock != -1) {`
`186`		`- if (chan_request_in(chan)) {`
	`186`	`+ if (chan_out_request_in(chan)) {`
`187`	`187`	`printf("REQUEST IN...\n");`
`188`	`188`
`189`	`189`	`test_and_send_status(client_sock, chan, ADDR /* TODO */);`
`@@ -194,7 +194,7 @@ purge_status(chan, ADDR);`
`194`	`194`	`return true;`
`195`	`195`	`}`
`196`	`196`
`197`		`-void handle_client(int sock, struct chan *chan)`
	`197`	`+void handle_client(int sock, struct chan_out *chan)`
`198`	`198`	`{`
`199`	`199`	`// First, read as much as we can into the buffer.`
`200`	`200`	`uint8_t *buf_p = xxx_buf + xxx_buf_len;`
`@@ -251,7 +251,7 @@ void handle_client(int sock, struct chan *chan)`
`251`	`251`	`}`
`252`	`252`	`}`
`253`	`253`
`254`		`-void handle_message(int sock, struct chan chan, uint8_t msg, size_t msg_len)`
	`254`	`+void handle_message(int sock, struct chan_out chan, uint8_t msg, size_t msg_len)`
`255`	`255`	`{`
`256`	`256`	`uint8_t buf[MSG_BUF_SIZE];`
`257`	`257`
`@@ -296,9 +296,9 @@ void handle_message(int sock, struct chan chan, uint8_t msg, size_t msg_len)`
`296`	`296`
`297`	`297`	`printf("\taddr = %.2x, cmd = %.2x, flags = %.2x, count = %zu\n", addr, cmd, flags, count);`
`298`	`298`
`299`		`- ssize_t result = chan_exec(chan, ADDR /* TODO */, cmd, data, count);`
	`299`	`+ ssize_t result = chan_out_exec(chan, ADDR /* TODO */, cmd, data, count);`
`300`	`300`
`301`		`- uint8_t device_status = chan_device_status(chan);`
	`301`	`+ uint8_t device_status = chan_out_device_status(chan);`
`302`	`302`
`303`	`303`	`/*`
`304`	`304`	`ssize_t result;`
`@@ -339,18 +339,18 @@ void handle_message(int sock, struct chan chan, uint8_t msg, size_t msg_len)`
`339`	`339`	`// wait for it via request in...`
`340`	`340`	`printf("\tgot CE without DE, waiting for DE via request in...\n");`
`341`	`341`
`342`		`- while (!chan_request_in(chan)) {`
	`342`	`+ while (!chan_out_request_in(chan)) {`
`343`	`343`	`usleep(100000); // 100ms`
`344`	`344`	`}`
`345`	`345`
`346`		`- int test_result = chan_test(chan, ADDR /* TODO */);`
	`346`	`+ int test_result = chan_out_test(chan, ADDR /* TODO */);`
`347`	`347`
`348`	`348`	`if (test_result < 0) {`
`349`	`349`	`printf("\ttest result = %d\n", test_result);`
`350`	`350`	`return;`
`351`	`351`	`}`
`352`	`352`
`353`		`- device_status \|= chan_device_status(chan);`
	`353`	`+ device_status \|= chan_out_device_status(chan);`
`354`	`354`
`355`	`355`	`printf("\tupdated status = %.2x\n", device_status);`
`356`	`356`
`@@ -388,18 +388,18 @@ void handle_message(int sock, struct chan chan, uint8_t msg, size_t msg_len)`
`388`	`388`	`}`
`389`	`389`	`}`
`390`	`390`
`391`		`-void test_and_send_status(int sock, struct chan *chan, uint8_t addr)`
	`391`	`+void test_and_send_status(int sock, struct chan_out *chan, uint8_t addr)`
`392`	`392`	`{`
`393`	`393`	`uint8_t buf[MSG_BUF_SIZE];`
`394`	`394`
`395`		`- int result = chan_test(chan, addr);`
	`395`	`+ int result = chan_out_test(chan, addr);`
`396`	`396`
`397`	`397`	`if (result < 0) {`
`398`	`398`	`printf("\tresult = %d\n", result);`
`399`	`399`	`return;`
`400`	`400`	`}`
`401`	`401`
`402`		`- uint8_t device_status = chan_device_status(chan);`
	`402`	`+ uint8_t device_status = chan_out_device_status(chan);`
`403`	`403`
`404`	`404`	`printf("\tstatus = %.2x\n", device_status);`
`405`	`405`
`@@ -414,20 +414,20 @@ void test_and_send_status(int sock, struct chan *chan, uint8_t addr)`
`414`	`414`	`}`
`415`	`415`	`}`
`416`	`416`
`417`		`-void purge_status(struct chan *chan, uint8_t addr)`
	`417`	`+void purge_status(struct chan_out *chan, uint8_t addr)`
`418`	`418`	`{`
`419`	`419`	`// Very hacky... this is no way to do error recovery!`
`420`	`420`	`while (true) {`
`421`	`421`	`printf("TEST...\n");`
`422`	`422`
`423`		`- int result = chan_test(chan, addr);`
	`423`	`+ int result = chan_out_test(chan, addr);`
`424`	`424`
`425`	`425`	`if (result < 0) {`
`426`	`426`	`printf("\tresult = %d\n", result);`
`427`	`427`	`return;`
`428`	`428`	`}`
`429`	`429`
`430`		`- uint8_t status = chan_device_status(chan);`
	`430`	`+ uint8_t status = chan_out_device_status(chan);`
`431`	`431`
`432`	`432`	`printf("\tstatus = 0x%.2x\n", status);`
`433`	`433`
Original file line number	Diff line number	Diff line change
`@@ -18,11 +18,11 @@`
`18`	`18`	`#define REG_CCW_1 4`
`19`	`19`	`#define REG_CCW_2 5`
`20`	`20`
`21`		`-void config(struct chan *chan, bool enable, bool frontend_enable);`
	`21`	`+void config(struct chan_out *chan, bool enable, bool frontend_enable);`
`22`	`22`	`static inline bool is_read_cmd(uint8_t cmd);`
`23`	`23`	`static inline bool is_write_cmd(uint8_t cmd);`
`24`	`24`
`25`		`-int chan_open(struct chan chan, uintptr_t addr, int mem_fd, char udmabuf_path, bool frontend_enable)`
	`25`	`+int chan_out_open(struct chan_out chan, uintptr_t addr, int mem_fd, char udmabuf_path, bool frontend_enable)`
`26`	`26`	`{`
`27`	`27`	`chan->addr = addr;`
`28`	`28`
`@@ -43,7 +43,7 @@ int chan_open(struct chan chan, uintptr_t addr, int mem_fd, char udmabuf_path,`
`43`	`43`	`return 0;`
`44`	`44`	`}`
`45`	`45`
`46`		`-int chan_close(struct chan *chan, bool disable)`
	`46`	`+int chan_out_close(struct chan_out *chan, bool disable)`
`47`	`47`	`{`
`48`	`48`	`if (chan == NULL) {`
`49`	`49`	`return 0;`
`@@ -66,7 +66,7 @@ int chan_close(struct chan *chan, bool disable)`
`66`	`66`	`return result;`
`67`	`67`	`}`
`68`	`68`
`69`		`-int chan_test(struct chan *chan, uint8_t addr)`
	`69`	`+int chan_out_test(struct chan_out *chan, uint8_t addr)`
`70`	`70`	`{`
`71`	`71`	`// Channel is active...`
`72`	`72`	`if (chan->regs[REG_STATUS_1] & 0x01) {`
`@@ -91,7 +91,7 @@ int chan_test(struct chan *chan, uint8_t addr)`
`91`	`91`	`return 0;`
`92`	`92`	`}`
`93`	`93`
`94`		`-ssize_t chan_exec(struct chan chan, uint8_t addr, uint8_t cmd, uint8_t buf, size_t count)`
	`94`	`+ssize_t chan_out_exec(struct chan_out chan, uint8_t addr, uint8_t cmd, uint8_t buf, size_t count)`
`95`	`95`	`{`
`96`	`96`	`if (count > 0 && buf == NULL) {`
`97`	`97`	`return -1;`
`@@ -129,7 +129,7 @@ ssize_t chan_exec(struct chan chan, uint8_t addr, uint8_t cmd, uint8_t buf, si`
`129`	`129`	`return -3;`
`130`	`130`	`}`
`131`	`131`
`132`		`- uint8_t device_status = chan_device_status(chan);`
	`132`	`+ uint8_t device_status = chan_out_device_status(chan);`
`133`	`133`
`134`	`134`	`if (device_status & CHAN_STATUS_BUSY) {`
`135`	`135`	`return -4;`
`@@ -155,17 +155,17 @@ ssize_t chan_exec(struct chan chan, uint8_t addr, uint8_t cmd, uint8_t buf, si`
`155`	`155`	`return actual_count;`
`156`	`156`	`}`
`157`	`157`
`158`		`-uint8_t chan_device_status(struct chan *chan)`
	`158`	`+uint8_t chan_out_device_status(struct chan_out *chan)`
`159`	`159`	`{`
`160`	`160`	`return (uint8_t) (chan->regs[REG_STATUS_2] >> 24);`
`161`	`161`	`}`
`162`	`162`
`163`		`-bool chan_request_in(struct chan *chan)`
	`163`	`+bool chan_out_request_in(struct chan_out *chan)`
`164`	`164`	`{`
`165`	`165`	`return chan->regs[REG_STATUS_1] & 0x02;`
`166`	`166`	`}`
`167`	`167`
`168`		`-void config(struct chan *chan, bool enable, bool frontend_enable)`
	`168`	`+void config(struct chan_out *chan, bool enable, bool frontend_enable)`
`169`	`169`	`{`
`170`	`170`	`chan->regs[REG_CONTROL_1] = (frontend_enable << 31) \| (enable << 1);`
`171`	`171`	`}`