Subversion Repositories s80186

// Copyright Jamie Iles, 2017

//

// This file is part of s80x86.

//

// s80x86 is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// s80x86 is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with s80x86.  If not, see <http://www.gnu.org/licenses/>.

#pragma once

static inline void outw(unsigned short port, unsigned short v)

{

    asm volatile("outw %1, %0" : : "d"(port), "a"(v));

}

static inline void outb(unsigned short port, unsigned char v)

{

    asm volatile(

        "mov %0, %%al\n"

        "outb %%al, %w1"

        :

        : "a"(v), "Nd"(port)

        : "%al");

}

static inline unsigned short inw(unsigned short port)

{

    unsigned short v;

    asm volatile("inw %1, %0" : "=a"(v) : "d"(port));

    return v;

}

static inline unsigned char inb(unsigned short port)

{

    unsigned char v;

    asm volatile(

        "inb %w1, %%al\n"

        "mov %%al, %0"

        : "=a"(v)

        : "Nd"(port)

        : "%al");

    return v;

}

static inline void writeb(unsigned short segment,

                          unsigned short address,

                          unsigned char val)

{

    asm volatile(

        "push %%ds\n"

        "mov %P[segment], %%ds\n"

        "mov %P[address], %%bx\n"

        "movb %P[val], (%%bx)\n"

        "pop %%ds"

        :

        : [segment] "r"(segment), [address] "m"(address), [val] "r"(val)

        : "%bx", "memory");

}

static inline void writew(unsigned short segment,

                          unsigned short address,

                          unsigned short val)

{

    asm volatile(

        "push %%ds\n"

        "mov %P[segment], %%ds\n"

        "mov %P[address], %%bx\n"

        "movw %P[val], (%%bx)\n"

        "pop %%ds"

        :

        : [segment] "r"(segment), [address] "m"(address), [val] "r"(val)

        : "%bx", "memory");

}

static inline void memcpy_seg(unsigned short dseg,

                              void *dst,

                              unsigned short sseg,

                              const void *src,

                              unsigned short len)

{

    asm volatile(

        "push %%ds\n"

        "push %%es\n"

        "push %%cx\n"

        "push %%si\n"

        "push %%di\n"

        "cld\n"

        "mov %P[dseg], %%es\n"

        "mov %P[sseg], %%ds\n"

        "mov %P[len], %%cx\n"

        "rep movsb\n"

        "pop %%di\n"

        "pop %%si\n"

        "pop %%cx\n"

        "pop %%es\n"

        "pop %%ds\n"

        :

        : [dseg] "r"(dseg), [sseg] "r"(sseg), "S"(src), "D"(dst), [len] "r"(len)

        : "memory", "cc");

}

static inline unsigned char readb(unsigned short segment,

                                  unsigned short address)

{

    unsigned char v;

    asm volatile(

        "push %%ds\n"

        "mov %P[segment], %%ds\n"

        "mov %P[address], %%bx\n"

        "movb (%%bx), %P[val]\n"

        "pop %%ds"

        : [val] "=r"(v)

        : [segment] "r"(segment), [address] "m"(address)

        : "%bx", "memory");

    return v;

}

static inline unsigned short readw(unsigned short segment,

                                   unsigned short address)

{

    unsigned short v;

    asm volatile(

        "push %%ds\n"

        "mov %P[segment], %%ds\n"

        "mov %P[address], %%bx\n"

        "movw (%%bx), %P[val]\n"

        "pop %%ds"

        : [val] "=r"(v)

        : [segment] "r"(segment), [address] "m"(address)

        : "%bx", "memory");

    return v;

}

static inline unsigned short get_cs(void)

{

    unsigned short cs;

    asm volatile("mov %%cs, %0" : "=r"(cs));

    return cs;

}

static inline unsigned short get_es(void)

{

    unsigned short es;

    asm volatile("mov %%es, %0" : "=r"(es));

    return es;

}

static inline void set_es(unsigned short es)

{

    asm volatile("mov %0, %%es" ::"r"(es));

}