ports.c

См. документацию.

 
#include <stdarg.h>
#include <io/ports.h>
#include <lib/sprintf.h>
#include "io/serial_port.h"
#include "sys/scheduler.h"
#include "mem/vmm.h"
 
void (*default_qemu_printf)(const char *text, ...) = qemu_printf;
 
void switch_qemu_logging() {
    default_qemu_printf = new_qemu_printf;
}
 
void insl(uint16_t port, uint32_t *buffer, int32_t times) {
    for (uint32_t index = 0; index < times; index++) {
        buffer[index] = inl(port);
    }
}
 
 
void outsl(uint16_t port, uint32_t *buffer, int32_t times) {
    for (int32_t index = 0; index < times; index++) {
        outl(port, buffer[index]);
    }
}
 
void insw(uint16_t __port, void *__buf, unsigned long __n) {
    __asm__ volatile("cld; rep; insw"
            : "+D"(__buf), "+c"(__n)
            : "d"(__port));
}
 
void outsw(uint16_t __port, const void *__buf, unsigned long __n) {
    __asm__ volatile("cld; rep; outsw"
            : "+S"(__buf), "+c"(__n)
            : "d"(__port));
}
 
int32_t is_transmit_empty(uint16_t port) {
    return inb(port + 5) & 0x20;
}
 
// Read 1 byte (char) from port.
uint8_t serial_readchar(uint16_t port) {
   //size_t to = 0;
    while (is_signal_received(port) == 0){
       //to++;
       //qemu_warn("TIMEOUT: %d",to);
   }
   return inb(port);
}
 
 
// Read 1 byte (char) from port.
int8_t serial_readchar_timeout(uint16_t port,size_t timeout, bool Alert) {
    size_t to = 0;
    while (is_signal_received(port) == 0){
        to++;
        //qemu_warn("TIMEOUT: %d",to);
        if (to >= timeout){
            if (Alert) qemu_warn("TIMEOUT: %d",to);
            return -1;
        }
    }
    return inb(port);
}
 
void io_wait(void) {
    outb(0x80, 0);
}
 
int isprint(char c) {
    return ((c >= ' ' && c <= '~') ? 1 : 0);
}
 
 
int is_com_port(int port) {
    switch (port) {
        case PORT_COM1:
            return 1;
        case PORT_COM2:
            return 2;
        case PORT_COM3:
            return 3;
        case PORT_COM4:
            return 4;
        case PORT_COM5:
            return 5;
        case PORT_COM6:
            return 6;
        case PORT_COM7:
            return 7;
        case PORT_COM8:
            return 8;
        default:
            return 0;
    }
}
 
void qemu_printf(const char *text, ...) {
    va_list args;
    va_start(args, text);
 
    if (__com_getInit(1)) {
        scheduler_mode(false);  // Stop scheduler
 
        __com_pre_formatString(PORT_COM1, text, args);
 
        scheduler_mode(true);  // Start scheduler
    }
    
    va_end(args);
}
 
void new_qemu_printf(const char *format, ...) {
    if (!__com_getInit(1))
        return;
 
    va_list args;
    va_start(args, format);
 
    char* container;
 
    vasprintf(&container, format, args);
 
    va_end(args);
 
    scheduler_mode(false);  // Stop scheduler
    __com_writeString(PORT_COM1, container);
    scheduler_mode(true);  // Start scheduler
 
    kfree(container);
}