root/morphix/trunk/ddcxinfo/vbe.c

#include <sys/types.h>
#include <sys/io.h>
#include <sys/mman.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>
#include <limits.h>
#include <ctype.h>
#include "lrmi.h"
#include "vesamode.h"
#include "vbe.h"
#ident "$Id: vbe.c 1815 2005-04-25 08:27:54Z alextreme $"

/* Return information about a particular video mode. */
struct vbe_mode_info *vbe_get_mode_info(u_int16_t mode)
{
        struct LRMI_regs regs;
        char *mem;
        struct vbe_mode_info *ret = NULL;

        /* Initialize LRMI. */
        if(LRMI_init() == 0) {
                return NULL;
        }

        /* Allocate a chunk of memory. */
        mem = LRMI_alloc_real(sizeof(struct vbe_mode_info));
        if(mem == NULL) {
                return NULL;
        }
        memset(mem, 0, sizeof(struct vbe_mode_info));

        memset(&regs, 0, sizeof(regs));
        regs.eax = 0x4f01;
        regs.ecx = mode;
        regs.es = ((u_int32_t)mem) >> 4;
        regs.edi = ((u_int32_t)mem) & 0x0f;

        /* Do it. */
        iopl(3);
        ioperm(0, 0x400, 1);

        if(LRMI_int(0x10, &regs) == 0) {
                LRMI_free_real(mem);
                return NULL;
        }

        /* Check for successful return. */
        if((regs.eax & 0xffff) != 0x004f) {
                LRMI_free_real(mem);
                return NULL;
        }

        /* Get memory for return. */
        ret = malloc(sizeof(struct vbe_mode_info));
        if(ret == NULL) {
                LRMI_free_real(mem);
                return NULL;
        }

        /* Copy the buffer for return. */
        memcpy(ret, mem, sizeof(struct vbe_mode_info));

        /* Clean up and return. */
        LRMI_free_real(mem);
        return ret;
}

/* Get VBE info. */
struct vbe_info *vbe_get_vbe_info()
{
        struct LRMI_regs regs;
        unsigned char *mem;
        struct vbe_info *ret = NULL;
        int i;

        /* Initialize LRMI. */
        if(LRMI_init() == 0) {
                return NULL;
        }

        /* Allocate a chunk of memory. */
        mem = LRMI_alloc_real(sizeof(struct vbe_mode_info));
        if(mem == NULL) {
                return NULL;
        }
        memset(mem, 0, sizeof(struct vbe_mode_info));

        /* Set up registers for the interrupt call. */
        memset(&regs, 0, sizeof(regs));
        regs.eax = 0x4f00;
        regs.es = ((u_int32_t)mem) >> 4;
        regs.edi = ((u_int32_t)mem) & 0x0f;
        memcpy(mem, "VBE2", 4);

        /* Do it. */
        iopl(3);
        ioperm(0, 0x400, 1);

        if(LRMI_int(0x10, &regs) == 0) {
                LRMI_free_real(mem);
                return NULL;
        }

        /* Check for successful return code. */
        if((regs.eax & 0xffff) != 0x004f) {
                LRMI_free_real(mem);
                return NULL;
        }

        /* Get memory to return the information. */
        ret = malloc(sizeof(struct vbe_info));
        if(ret == NULL) {
                LRMI_free_real(mem);
                return NULL;
        }
        memcpy(ret, mem, sizeof(struct vbe_info));

        /* Set up pointers to usable memory. */
        ret->mode_list.list = (u_int16_t*) ((ret->mode_list.addr.seg << 4) +
                                            (ret->mode_list.addr.ofs));
        ret->oem_name.string = (char*) ((ret->oem_name.addr.seg << 4) +
                                        (ret->oem_name.addr.ofs));

        /* Snip, snip. */
        mem = strdup(ret->oem_name.string); /* leak */
        while(((i = strlen(mem)) > 0) && isspace(mem[i - 1])) {
                mem[i - 1] = '\0';
        }
        ret->oem_name.string = mem;

        /* Set up pointers for VESA 2.0+ strings. */
        if(ret->version[1] >= 2) {

                /* Vendor name. */
                ret->vendor_name.string = (char*)
                         ((ret->vendor_name.addr.seg << 4)
                        + (ret->vendor_name.addr.ofs));

                mem = strdup(ret->vendor_name.string); /* leak */
                while(((i = strlen(mem)) > 0) && isspace(mem[i - 1])) {
                        mem[i - 1] = '\0';
                }
                ret->vendor_name.string = mem;

                /* Product name. */
                ret->product_name.string = (char*)
                         ((ret->product_name.addr.seg << 4)
                        + (ret->product_name.addr.ofs));

                mem = strdup(ret->product_name.string); /* leak */
                while(((i = strlen(mem)) > 0) && isspace(mem[i - 1])) {
                        mem[i - 1] = '\0';
                }
                ret->product_name.string = mem;

                /* Product revision. */
                ret->product_revision.string = (char*)
                         ((ret->product_revision.addr.seg << 4)
                        + (ret->product_revision.addr.ofs));

                mem = strdup(ret->product_revision.string); /* leak */
                while(((i = strlen(mem)) > 0) && isspace(mem[i - 1])) {
                        mem[i - 1] = '\0';
                }
                ret->product_revision.string = mem;
        }

        /* Cleanup. */
        LRMI_free_real(mem);
        return ret;
}

/* Check if EDID queries are suorted. */
int vbe_get_edid_supported()
{
        struct LRMI_regs regs;
        int ret = 0;

        /* Initialize LRMI. */
        if(LRMI_init() == 0) {
                return 0;
        }

        memset(&regs, 0, sizeof(regs));
        regs.eax = 0x4f15;
        regs.ebx = 0x0000;
        regs.es = 0x3000;
        regs.edi = 0x3000;

        /* Do it. */
        iopl(3);
        ioperm(0, 0x400, 1);

        if(LRMI_int(0x10, &regs) == 0) {
                return 0;
        }

        /* Check for successful return. */
        if((regs.eax & 0xff) == 0x4f) {
                /* Supported. */
                ret = 1;
        } else {
                /* Not supported. */
                ret = 0;
        }

        /* Clean up and return. */
        return ret;
}

/* Get EDID info. */
struct vbe_edid1_info *vbe_get_edid_info()
{
        struct LRMI_regs regs;
        unsigned char *mem;
        struct vbe_edid1_info *ret = NULL;
        u_int16_t man;

        /* Initialize LRMI. */
        if(LRMI_init() == 0) {
                return NULL;
        }

        /* Allocate a chunk of memory. */
        mem = LRMI_alloc_real(sizeof(struct vbe_edid1_info));
        if(mem == NULL) {
                return NULL;
        }
        memset(mem, 0, sizeof(struct vbe_edid1_info));

        memset(&regs, 0, sizeof(regs));
        regs.eax = 0x4f15;
        regs.ebx = 0x0001;
        regs.es = ((u_int32_t)mem) >> 4;
        regs.edi = ((u_int32_t)mem) & 0x0f;

        /* Do it. */
        iopl(3);
        ioperm(0, 0x400, 1);

        if(LRMI_int(0x10, &regs) == 0) {
                LRMI_free_real(mem);
                return NULL;
        }

#if 0
        /* Check for successful return. */
        if((regs.eax & 0xffff) != 0x004f) {
                LRMI_free_real(mem);
                return NULL;
        }
#elseif
        /* Check for successful return. */
        if((regs.eax & 0xff) != 0x4f) {
                LRMI_free_real(mem);
                return NULL;
        }
#endif

        /* Get memory for return. */
        ret = malloc(sizeof(struct vbe_edid1_info));
        if(ret == NULL) {
                LRMI_free_real(mem);
                return NULL;
        }

        /* Copy the buffer for return. */
        memcpy(ret, mem, sizeof(struct vbe_edid1_info));

        memcpy(&man, &ret->manufacturer_name, 2);
        man = ntohs(man);
        memcpy(&ret->manufacturer_name, &man, 2);

        LRMI_free_real(mem);
        return ret;
}

/* Figure out what the current video mode is. */
int32_t vbe_get_mode()
{
        struct LRMI_regs regs;
        int32_t ret = -1;

        /* Initialize LRMI. */
        if(LRMI_init() == 0) {
                return -1;
        }

        memset(&regs, 0, sizeof(regs));
        regs.eax = 0x4f03;

        /* Do it. */
        iopl(3);
        ioperm(0, 0x400, 1);

        if(LRMI_int(0x10, &regs) == 0) {
                return -1;
        }

        /* Save the returned value. */
        if((regs.eax & 0xffff) == 0x004f) {
                ret = regs.ebx & 0xffff;
        } else {
                ret = -1;
        }

        /* Clean up and return. */
        return ret;
}

/* Set the video mode. */
void vbe_set_mode(u_int16_t mode)
{
        struct LRMI_regs regs;

        /* Initialize LRMI. */
        if(LRMI_init() == 0) {
                return;
        }

        memset(&regs, 0, sizeof(regs));
        regs.eax = 0x4f02;
        regs.ebx = mode;

        /* Do it. */
        iopl(3);
        ioperm(0, 0x400, 1);
        LRMI_int(0x10, &regs);

        /* Return. */
        return;
}

/* Just read ranges from the EDID. */
void vbe_get_edid_ranges(unsigned char *hmin, unsigned char *hmax,
                         unsigned char *vmin, unsigned char *vmax)
{
        struct vbe_edid1_info *edid;
        struct vbe_edid_monitor_descriptor *monitor;
        int i;

        *hmin = *hmax = *vmin = *vmax = 0;

        if((edid = vbe_get_edid_info()) == NULL) {
                return;
        }

        for(i = 0; i < 4; i++) {
                monitor = &edid->monitor_details.monitor_descriptor[i];
                if(monitor->type == vbe_edid_monitor_descriptor_range) {
                        *hmin = monitor->data.range_data.horizontal_min;
                        *hmax = monitor->data.range_data.horizontal_max;
                        *vmin = monitor->data.range_data.vertical_min;
                        *vmax = monitor->data.range_data.vertical_max;
                }
        }
}

static int compare_vbe_modelines(const void *m1, const void *m2)
{
        const struct vbe_modeline *M1 = (const struct vbe_modeline*) m1;
        const struct vbe_modeline *M2 = (const struct vbe_modeline*) m2;
        if(M1->width < M2->width) return -1;
        if(M1->width > M2->width) return 1;
        return 0;
}

struct vbe_modeline *vbe_get_edid_modelines()
{
        struct vbe_edid1_info *edid;
        struct vbe_modeline *ret;
        char buf[LINE_MAX];
        int modeline_count = 0, i, j;

        if((edid = vbe_get_edid_info()) == NULL) {
                return NULL;
        }

        memcpy(buf, &edid->established_timings,
               sizeof(edid->established_timings));
        for(i = 0; i < (8 * sizeof(edid->established_timings)); i++) {
                if(buf[i / 8] & (1 << (i % 8))) {
                        modeline_count++;
                }
        }

        /* Count the number of standard timings. */
        for(i = 0; i < 8; i++) {
                int x, v;
                x = edid->standard_timing[i].xresolution;
                v = edid->standard_timing[i].vfreq;
                if(((edid->standard_timing[i].xresolution & 0x01) != x) &&
                   ((edid->standard_timing[i].vfreq & 0x01) != v)) {
                        modeline_count++;
                }
        }

        ret = malloc(sizeof(struct vbe_modeline) * (modeline_count + 1));
        if(ret == NULL) {
                return NULL;
        }
        memset(ret, 0, sizeof(struct vbe_modeline) * (modeline_count + 1));

        modeline_count = 0;

        /* Fill out established timings. */
        if(edid->established_timings.timing_720x400_70) {
                ret[modeline_count].width = 720;
                ret[modeline_count].height = 400;
                ret[modeline_count].refresh = 70;
                modeline_count++;
        }
        if(edid->established_timings.timing_720x400_88) {
                ret[modeline_count].width = 720;
                ret[modeline_count].height = 400;
                ret[modeline_count].refresh = 88;
                modeline_count++;
        }
        if(edid->established_timings.timing_640x480_60) {
                ret[modeline_count].width = 640;
                ret[modeline_count].height = 480;
                ret[modeline_count].refresh = 60;
                modeline_count++;
        }
        if(edid->established_timings.timing_640x480_67) {
                ret[modeline_count].width = 640;
                ret[modeline_count].height = 480;
                ret[modeline_count].refresh = 67;
                modeline_count++;
        }
        if(edid->established_timings.timing_640x480_72) {
                ret[modeline_count].width = 640;
                ret[modeline_count].height = 480;
                ret[modeline_count].refresh = 72;
                modeline_count++;
        }
        if(edid->established_timings.timing_640x480_75) {
                ret[modeline_count].width = 640;
                ret[modeline_count].height = 480;
                ret[modeline_count].refresh = 75;
                modeline_count++;
        }
        if(edid->established_timings.timing_800x600_56) {
                ret[modeline_count].width = 800;
                ret[modeline_count].height = 600;
                ret[modeline_count].refresh = 56;
                modeline_count++;
        }
        if(edid->established_timings.timing_800x600_60) {
                ret[modeline_count].width = 800;
                ret[modeline_count].height = 600;
                ret[modeline_count].refresh = 60;
                modeline_count++;
        }
        if(edid->established_timings.timing_800x600_72) {
                ret[modeline_count].width = 800;
                ret[modeline_count].height = 600;
                ret[modeline_count].refresh = 72;
                modeline_count++;
        }
        if(edid->established_timings.timing_800x600_75) {
                ret[modeline_count].width = 800;
                ret[modeline_count].height = 600;
                ret[modeline_count].refresh = 75;
                modeline_count++;
        }
        if(edid->established_timings.timing_832x624_75) {
                ret[modeline_count].width = 832;
                ret[modeline_count].height = 624;
                ret[modeline_count].refresh = 75;
                modeline_count++;
        }
        if(edid->established_timings.timing_1024x768_87i) {
                ret[modeline_count].width = 1024;
                ret[modeline_count].height = 768;
                ret[<