SquidgeOS/src/drivers/uart.c

#include <stdint.h>
#include <stddef.h>
#include <stdarg.h>
#include <syscon/syscon.h>
#include <drivers/uart.h>
#include <lib/string.h>

void uart_init()
{
	kprint("UART Drive Init...");
	volatile uint8_t *UART_IER = (uint8_t *)(UART_ADDRESS + 1);
	*UART_IER = 0x01; // Enable "Received Data Available" interrupt
	kputs("OK");
}

void uart_put(size_t base_addr, uint8_t data)
{
	*(volatile uint8_t *)base_addr = data;
}

char uart_getc()
{
	if (*UART_LSR & 0x01)
	{
		return (char)(*UART_RBR);
	}
	return '\0';
}

void uart_handle_interrupt()
{
	char c = uart_getc();
	switch (c)
	{
	case '\r': // enter key
		knewline();
		break;
	case '\0':
		// do nowt
		break;
	default:
		kputchar(c);
		break;
	}
}

int kputchar(int ch)
{
	uart_put(UART_ADDRESS, ch);
	return ch;
}

void kprint(const char *str)
{
	while (*str)
	{
		kputchar(*str++);
	}
}

void kprint_int(int num)
{
	char buffer[21];
	memset(buffer, 0, sizeof(buffer));
	int i = 0;
	if (num == 0)
	{
		kputchar('0');
		return;
	}
	if (num < 0)
	{
		kputchar('-');
		num = -num;
	}
	while (num > 0)
	{
		buffer[i++] = '0' + (num % 10);
		num /= 10;
	}
	while (i > 0)
	{
		kputchar(buffer[--i]);
	}
}

void kprint_float(float num)
{
	if (num < 0)
	{
		kputchar('-');
		num = -num;
	}
	int int_part = (int)num;
	float frac_part = num - int_part;
	kprint_int(int_part);
	kputchar('.');
	for (int i = 0; i < 6; i++)
	{
		frac_part *= 10.0f;
	}
	int fraction = (int)(frac_part + 0.5f);
	kprint_int(fraction);
}

void kprint_hex(uint64_t val)
{
	char *digits = "0123456789ABCDEF";
	char buffer[17]; //+1 for null terminator
	memset(buffer, 0, sizeof(buffer));
	buffer[16] = '\0';

	for (int i = 15; i >= 0; i--)
	{
		buffer[i] = digits[val & 0xF];
		val >>= 4;
	}
	kprint("0x");
	kprint(buffer);
}

void knewline(void)
{
	kputchar('\n');
}

void kputs(const char *str)
{
	kprint(str);
	knewline();
}

void kprintf_internal(const char *format, va_list args)
{
    for (const char *p = format; *p != '\0'; p++)
    {
        if (*p == '%')
        {
            p++;
            switch (*p)
            {
            case 'c':
            {
                char c = (char)va_arg(args, int);
                kputchar(c);
                break;
            }
            case 's':
            {
                char *s = va_arg(args, char *);
                kprint(s);
                break;
            }
            case 'd':
            {
                int d = va_arg(args, int);
                kprint_int(d);
                break;
            }
            case 'f':
            {
                double f = va_arg(args, double);
                kprint_float((float)f);
                break;
            }
            case 'x': // Hex
            case 'p': // Pointer
            {
                uint64_t x = va_arg(args, uint64_t);
                kprint_hex(x);
                break;
            }
            case '%':
                kputchar('%');
                break;
            default:
                kputchar('%');
                kputchar(*p);
            }
        }
        else
        {
            kputchar(*p);
        }
    }
    knewline();
}

void kprintf(const char *format, ...)
{
    va_list args;
    va_start(args, format);
    kprintf_internal(format, args);
    va_end(args);
}