printf()

Implement printf() to send output via poll_dma.

The printed output must fit into a single 512 byte sized buffer.  It is
appended to the current buffer whenit fits, else, the buffer is
submitted and the message goes into a new one. With `poll_dma_nonblock`,
every print goes into a new data block, zero filled.

message.c

@@ -5,6 +5,7 @@
 #include <stdarg.h>
 #include <string.h>
 #include "isr.h"
+#include "stream.h"
 
 int vsniprintf (char *str, size_t size, const char *fmt, va_list ap);
 
@@ -108,3 +109,44 @@ int snprintf(char *s, unsigned int n, const char *f, ...)
 	va_end (a);
 	return r;
 }
+
+int printf(const char *fmt, ...)
+ {
+	if (!poll_dma_ready())
+		return -1;
+	size_t size = 512 - poll_dma_buffer_size;
+	if (!size) {
+		poll_dma_submit(0,0);
+		size = 512 - poll_dma_buffer_size;
+		if (!size)
+			return 0;
+	}
+	va_list ap;
+	va_start (ap, fmt);
+	unsigned int iflags =  disable_irq(INT_DISABLE);
+	int n = vsniprintf(poll_dma_buffer+poll_dma_buffer_size, size, fmt, ap);
+	enable_irq(iflags);
+	va_end (ap);
+	if (n < size)
+		goto submit;
+	if (n >= 512)
+		return -1;
+	unsigned int flags = poll_dma_flags;
+	poll_dma_flags |= poll_dma_nonblock;
+	poll_dma_submit(0,0);
+	poll_dma_flags = flags;
+	if (!poll_dma_ready())
+		return -1;
+	size = 512 - poll_dma_buffer_size;
+	va_start (ap, fmt);
+	iflags =  disable_irq(INT_DISABLE);
+	n = vsniprintf(poll_dma_buffer+poll_dma_buffer_size, size, fmt, ap);
+	enable_irq(iflags);
+	va_end (ap);
+	if (n >= size)
+		return -1;
+submit:
+	poll_dma_buffer_size += n;
+		poll_dma_submit(0,0);
+		return n;
+}

message.h

@@ -33,3 +33,4 @@ int message_count(int);
 int message_to_buffer(unsigned int n, char *buf);
 void message_spurios_irq(const char *t, unsigned int bits);
 int snprintf(char *s, unsigned int n, const char *f, ...) __attribute__ ((format (printf, 3, 4)));
+int printf(const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));

stream.c

@@ -105,12 +105,14 @@ unsigned int poll_dma_submit(const char *buffer, unsigned int buffer_size)
 {
 	unsigned int n = 0;
 	if (buffer_size + poll_dma_buffer_size >= 512) {
+		if (buffer_size)
 			memcpy(poll_dma_buffer+poll_dma_buffer_size, buffer, 512-poll_dma_buffer_size);
 		int nn = buffer_size + poll_dma_buffer_size - 512;
 		unsigned char *new_buffer = dma_poll(poll_dma_buffer);
 		if (new_buffer) {
 			poll_dma_buffer = new_buffer;
-			memcpy(poll_dma_buffer, buffer+512-poll_dma_buffer_size, n);
+			if (nn)
+				memcpy(poll_dma_buffer, buffer+512-poll_dma_buffer_size, nn);
 			poll_dma_buffer_size = nn;
 			poll_dma_flags &=~ poll_dma_stuck;
 		}
@@ -120,7 +122,7 @@ unsigned int poll_dma_submit(const char *buffer, unsigned int buffer_size)
 			poll_dma_flags |= poll_dma_stuck;
 		}
 	}
-	else {
+	else if (buffer_size) {
 		memcpy(poll_dma_buffer+poll_dma_buffer_size, buffer, buffer_size);
 		poll_dma_buffer_size += buffer_size;
 	}