io.cpp

Vai alla documentazione di questo file.

#include <costanti.h>
#include <libce.h>
#include <sys.h>
#include <sysio.h>
#include <io.h>


natl ioheap_mutex;

void* operator new(size_t s)
{
        void* p;
 
        sem_wait(ioheap_mutex);
        p = alloc(s);
        sem_signal(ioheap_mutex);
 
        return p;
}

void* operator new(size_t s, std::align_val_t a)
{
        void* p;
 
        if (static_cast<natq>(a) > DIM_PAGINA)
                return phys_alloc(s, a);
 
        sem_wait(ioheap_mutex);
        p = alloc_aligned(s, a);
        sem_signal(ioheap_mutex);
        return p;
}

void operator delete(void* p)
{
        sem_wait(ioheap_mutex);
        dealloc(p);
        sem_signal(ioheap_mutex);
}

void operator delete(void *p, std::align_val_t a)
{
        if (static_cast<natq>(a) > DIM_PAGINA)
                return phys_dealloc(p);
 
        sem_wait(ioheap_mutex);
        dealloc(p);
        sem_signal(ioheap_mutex);
}



struct des_console {
        natl mutex;
        natl sincr;
        char* punt;
        natq cont;
        natq dim;
};

des_console console;


extern "C" void c_writeconsole(const char* buff, natq quanti)
{
        des_console* p_des = &console;
 
        if (!access(buff, quanti, false, false)) {
                flog(LOG_WARN, "writeconsole: parametri non validi: %p, %lu:", buff, quanti);
                abort_p();
        }
 
        sem_wait(p_des->mutex);
#ifndef AUTOCORR
        for (natq i = 0; i < quanti; i++)
                vid::char_write(buff[i]);
#else /* AUTOCORR */
        if (quanti > 0 && buff[quanti - 1] == '\n')
                quanti--;
        if (quanti > 0)
                flog(LOG_USR, "%.*s", static_cast<int>(quanti), buff);
#endif /* AUTOCORR */
        sem_signal(p_des->mutex);
}


void startkbd_in(des_console* d, char* buff, natq dim)
{
        d->punt = buff;
        d->cont = dim;
        d->dim  = dim;
        kbd::enable_intr();
}


extern "C" natq c_readconsole(char* buff, natq quanti)
{
        des_console* d = &console;
        natq rv;
 
        if (!access(buff, quanti, true)) {
                flog(LOG_WARN, "readconsole: parametri non validi: %p, %lu:", buff, quanti);
                abort_p();
        }
 
#ifdef AUTOCORR
        return 0;
#endif
 
        if (!quanti)
                return 0;
 
        sem_wait(d->mutex);
        startkbd_in(d, buff, quanti);
        sem_wait(d->sincr);
        rv = d->dim - d->cont;
        sem_signal(d->mutex);
        return rv;
}


void estern_kbd(natq)
{
        des_console* d = &console;
        char a;
        bool fine;
 
        for(;;) {
                kbd::disable_intr();
 
                a = kbd::char_read_intr();
 
                fine = false;
                switch (a) {
                case 0:
                        break;
                case '\b':
                        if (d->cont < d->dim) {
                                d->punt--;
                                d->cont++;
                                vid::str_write("\b \b");
                        }
                        break;
                case '\r':
                case '\n':
                        fine = true;
                        *d->punt = '\0';
                        vid::str_write("\r\n");
                        break;
                default:
                        *d->punt = a;
                        d->punt++;
                        d->cont--;
                        vid::char_write(a);
                        if (d->cont == 0) {
                                fine = true;
                        }
                        break;
                }
                if (fine)
                        sem_signal(d->sincr);
                else
                        kbd::enable_intr();
                wfi();
        }
}


extern "C" void c_iniconsole(natb cc)
{
        vid::clear(cc);
}


const int KBD_IRQ = 1;

bool kbd_init()
{
        // blocchiamo subito le interruzioni generabili dalla tastiera
        kbd::disable_intr();
 
        // svuotiamo il buffer interno della tastiera
        kbd::drain();
 
        if (activate_pe(estern_kbd, 0, MIN_EXT_PRIO + INTR_TIPO_KBD, LIV_SISTEMA, KBD_IRQ) == 0xFFFFFFFF) {
                flog(LOG_ERR, "kbd: impossibile creare estern_kbd");
                return false;
        }
        flog(LOG_INFO, "kbd: tastiera inizializzata");
        return true;
}

bool vid_init()
{
        vid::clear(0x07);
        flog(LOG_INFO, "vid: video inizializzato");
        return true;
}

bool console_init()
{
        des_console* d = &console;
 
        if ( (d->mutex = sem_ini(1)) == 0xFFFFFFFF) {
                flog(LOG_ERR, "console: impossibile creare mutex");
                return false;
        }
        if ( (d->sincr = sem_ini(0)) == 0xFFFFFFFF) {
                flog(LOG_ERR, "console: impossibile creare sincr");
                return false;
        }
        return kbd_init() && vid_init();
}



struct des_ata {
        natb comando;
        natl mutex;
        natl sincr;
        natb cont;
        natb* punt;
        natl* prd;
};

des_ata hard_disk;

const natb HD_IRQ = 14;

bool prepare_prd(des_ata *d, natb* vett, natb quanti)
{
        natq n = quanti * DIM_BLOCK;
        int i = 0;
 
        while (n && i < MAX_PRD) {
                paddr p = trasforma(vett);
                natq  r = DIM_PAGINA - (p % DIM_PAGINA);
                if (r > n)
                        r = n;
                d->prd[i] = p;
                d->prd[i + 1] = r;
 
                n -= r;
                vett += r;
                i += 2;
        }
        if (n)
                return false;
        d->prd[i - 1] |= 0x80000000;
        return true;
}

void starthd_in(des_ata* d, natb vetti[], natl primo, natb quanti)
{
        d->cont = quanti;
        d->punt = vetti;
        d->comando = hd::READ_SECT;
        hd::start_cmd(primo, quanti, hd::READ_SECT);
}


extern "C" void c_readhd_n(natb vetti[], natl primo, natb quanti)
{
        des_ata* d = &hard_disk;
 
        if (!access(vetti, quanti * DIM_BLOCK, true)) {
                flog(LOG_WARN, "readhd_n: parametri non validi: %p, %d", vetti, quanti);
                abort_p();
        }
 
        if (!quanti)
                return;
 
        sem_wait(d->mutex);
        starthd_in(d, vetti, primo, quanti);
        sem_wait(d->sincr);
        sem_signal(d->mutex);
}


void starthd_out(des_ata* d, natb vetto[], natl primo, natb quanti)
{
        d->cont = quanti;
        d->punt = vetto + DIM_BLOCK;
        d->comando = hd::WRITE_SECT;
        hd::start_cmd(primo, quanti, hd::WRITE_SECT);
        hd::output_sect(vetto);
}


extern "C" void c_writehd_n(natb vetto[], natl primo, natb quanti)
{
        des_ata* d = &hard_disk;
 
        if (!access(vetto, quanti * DIM_BLOCK, false)) {
                flog(LOG_WARN, "writehd_n: parametri non validi: %p, %d", vetto, quanti);
                abort_p();
        }
 
        if (!quanti)
                return;
 
        sem_wait(d->mutex);
        starthd_out(d, vetto, primo, quanti);
        sem_wait(d->sincr);
        sem_signal(d->mutex);
}


void dmastarthd_in(des_ata* d, natb vetti[], natl primo, natb quanti)
{
        if (!prepare_prd(d, vetti, quanti)) {
                flog(LOG_ERR, "dmastarthd_in: numero di PRD insufficiente");
                sem_signal(d->sincr);
                return;
        }
 
        d->comando = hd::READ_DMA;
        d->cont = 1;
        paddr prd = trasforma(d->prd);
        bm::prepare(prd, false);
        hd::start_cmd(primo, quanti, hd::READ_DMA);
        bm::start();
}


extern "C" void c_dmareadhd_n(natb vetti[], natl primo, natb quanti)
{
        des_ata* d = &hard_disk;
 
        if (quanti * DIM_BLOCK > MAX_PRD * DIM_PAGINA) {
                flog(LOG_WARN, "readhd_n: quanti %d troppo grande", quanti);
                abort_p();
        }
 
        if (!access(vetti, quanti * DIM_BLOCK, true)) {
                flog(LOG_WARN, "dmareadhd_n: parametri non validi: %p, %d", vetti, quanti);
                abort_p();
        }
 
        if (!quanti)
                return;
 
        sem_wait(d->mutex);
        dmastarthd_in(d, vetti, primo, quanti);
        sem_wait(d->sincr);
        sem_signal(d->mutex);
}


void dmastarthd_out(des_ata* d, natb vetto[], natl primo, natb quanti)
{
        if (!prepare_prd(d, vetto, quanti)) {
                flog(LOG_ERR, "dmastarthd_out: numero di PRD insufficiente");
                sem_signal(d->sincr);
                return;
        }
 
        d->comando = hd::WRITE_DMA;
        d->cont = 1;                                // informazione per il driver
        paddr prd = trasforma(d->prd);
        bm::prepare(prd, true);
        hd::start_cmd(primo, quanti, hd::WRITE_DMA);
        bm::start();
}


extern "C" void c_dmawritehd_n(natb vetto[], natl primo, natb quanti)
{
        des_ata* d = &hard_disk;
 
        if (quanti * DIM_BLOCK > MAX_PRD * DIM_PAGINA) {
                flog(LOG_WARN, "readhd_n: quanti %d troppo grande", quanti);
                abort_p();
        }
 
        if (!access(vetto, quanti * DIM_BLOCK, false)) {
                flog(LOG_WARN, "dmawritehd_n: parametri non validi: %p, %d", vetto, quanti);
                abort_p();
        }
 
        if (!quanti)
                return;
 
        sem_wait(d->mutex);
        dmastarthd_out(d, vetto, primo, quanti);
        sem_wait(d->sincr);
        sem_signal(d->mutex);
}


void estern_hd(natq)
{
        des_ata* d = &hard_disk;
        for(;;) {
                d->cont--;
                hd::ack();
                switch (d->comando) {
                case hd::READ_SECT:
                        hd::input_sect(d->punt);
                        d->punt += DIM_BLOCK;
                        break;
                case hd::WRITE_SECT:
                        if (d->cont != 0) {
                                hd::output_sect(d->punt);
                                d->punt += DIM_BLOCK;
                        }
                        break;
                case hd::READ_DMA:
                case hd::WRITE_DMA:
                        bm::ack();
                        break;
                }
                if (d->cont == 0)
                        sem_signal(d->sincr);
                wfi();
        }
}

bool hd_init()
{
        natl id;
        natb bus = 0, dev = 0, fun = 0;
        des_ata* d;
 
        d = &hard_disk;
 
        if ( (d->mutex = sem_ini(1)) == 0xFFFFFFFF) {
                flog(LOG_ERR, "hd: impossibile creare mutex");
                return false;
        }
        if ( (d->sincr = sem_ini(0)) == 0xFFFFFFFF) {
                flog(LOG_ERR, "hd: impossibile creare sincr");
                return false;
        }
 
        if (!bm::find(bus, dev, fun)) {
                flog(LOG_WARN, "hd: bus master non trovato");
                return false;
        }
 
        if ( (d->prd = new (std::align_val_t{65536}) natl[2 * MAX_PRD]) == nullptr) {
                flog(LOG_WARN, "hd: impossibile allocare vettore di PRD");
                return false;
        }
 
        flog(LOG_INFO, "bm: %02x:%02x.%1d", bus, dev, fun);
        bm::init(bus, dev, fun);
 
        id = activate_pe(estern_hd, 0, MIN_EXT_PRIO + INTR_TIPO_HD, LIV_SISTEMA, HD_IRQ);
        if (id == 0xFFFFFFFF) {
                flog(LOG_ERR, "hd: impossibile creare proc. esterno");
                return false;
        }
 
        hd::enable_intr();
 
        return true;
}



extern "C" char _end[];

extern "C" bool fill_io_gates();

extern "C" void main_io(natq p)
{
        int *p_io_init_done = ptr_cast<int>(p);
 
        fill_io_gates();
        ioheap_mutex = sem_ini(1);
        if (ioheap_mutex == 0xFFFFFFFF) {
                flog(LOG_ERR, "impossible creare semaforo ioheap_mutex");
                abort_p();
        }
        char* end_ = allinea_ptr(_end, DIM_PAGINA);
        heap_init(end_, DIM_IO_HEAP);
        flog(LOG_INFO, "Heap del modulo I/O: %llxB [%p, %p)", DIM_IO_HEAP,
                        end_, end_ + DIM_IO_HEAP);
        flog(LOG_INFO, "Inizializzo la console (kbd + vid)");
        if (!console_init()) {
                flog(LOG_ERR, "inizializzazione console fallita");
                abort_p();
        }
        flog(LOG_INFO, "Inizializzo la gestione dell'hard disk");
        if (!hd_init()) {
                flog(LOG_ERR, "inizializzazione hard disk fallita");
                abort_p();
        }
        *p_io_init_done = 1;
        terminate_p();
}



extern "C" natq c_getiomeminfo()
{
        natq rv;
        sem_wait(ioheap_mutex);
        rv = disponibile();
        sem_signal(ioheap_mutex);
        return rv;
}