Attachment 145376 Details for Bug 222328 – hacked915resolution.c

hacked915resolution.c

hacked915resolution.c (text/x-csrc), 27.76 KB, created by Reiner Wilhelms on 2007-01-11 18:26:42 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Reiner Wilhelms

Created: 2007-01-11 18:26:42 UTC

Size: 27.76 KB

patch

obsolete

>/* 915 resolution by steve tomljenovic
> *
> * This was tested only on Sony VGN-FS550.  Use at your own risk
> *
> * This code is based on the techniques used in :
> *
> *   - 855patch.  Many thanks to Christian Zietz (czietz gmx net)
> *     for demonstrating how to shadow the VBIOS into system RAM
> *     and then modify it.
> *
> *   - 1280patch by Andrew Tipton (andrewtipton null li).
> *
> *   - 855resolution by Alain Poirier
> *     
> *   - hacked by Reiner Wilhelms to fix a problem with i810 for 
> *     the Intel  865G graphics controller - the screen was 
> *     shifted too far because of wrong synchronization timing. 
> *     added option -m to directly specify a modeline.
> * 
> *
> * This source code is in the public domain. GPL I suppose
> */
>
>#include <stdio.h>
>#include <stdlib.h>
>#include <unistd.h>
>#define __USE_GNU
>#include <string.h>
>#include <sys/mman.h>
>#include <fcntl.h>
>#include <sys/io.h>
>#include <unistd.h>
>#include <assert.h>
>
>
>
>#define NEW(a) ((a *)(calloc(1, sizeof(a))))
>#define FREE(a) (free(a))
>
>#define VBIOS_START         0xc0000
>#define VBIOS_SIZE          0x10000
>
>#define VBIOS_FILE    "/dev/mem"
>
>#define FALSE 0
>#define TRUE 1
>
>#define MODE_TABLE_OFFSET_845G 617
>
>#define VERSION "0.5.2 Extra "
>
>#define ATI_SIGNATURE1 "ATI MOBILITY RADEON"
>#define ATI_SIGNATURE2 "ATI Technologies Inc"
>#define NVIDIA_SIGNATURE "NVIDIA Corp"
>#define INTEL_SIGNATURE "Intel Corp"
>
>typedef unsigned char * address;
>typedef unsigned char byte;
>typedef unsigned short word;
>typedef unsigned char boolean;
>typedef unsigned int cardinal;
>
>typedef enum {
>    CT_UNKWN, CT_845G, CT_855GM, CT_865G, CT_915G, CT_915GM, CT_945G, CT_945GM 
>} chipset_type;
>
>char * chipset_type_names[] = {"UNKNOWN", "845G", "855GM", "865G", "915G", "915GM", "945G", "945GM"};
>
>typedef enum {
>    BT_UNKWN, BT_1, BT_2, BT_3
>} bios_type;
>
>char * bios_type_names[] = {"UNKNOWN", "TYPE 1", "TYPE 2", "TYPE 3"};
>
>int freqs[] = { 60, 75, 85 };
>
>typedef struct {
>    byte mode;
>    byte bits_per_pixel;
>    word resolution;
>    byte unknown;
>} __attribute__((packed)) vbios_mode;
>
>typedef struct {
>    byte unknow1[2];
>    byte x1;
>    byte x_total;
>    byte x2;
>    byte y1;
>    byte y_total;
>    byte y2;
>} __attribute__((packed)) vbios_resolution_type1;
>
>typedef struct {
>    unsigned long clock;
>
>    word x1;
>    word htotal;
>    word x2;
>    word hblank;
>    word hsyncstart;
>    word hsyncend;
>
>    word y1;
>    word vtotal;
>    word y2;
>    word vblank;
>    word vsyncstart;
>    word vsyncend;
>} __attribute__((packed)) vbios_modeline_type2;
>
>typedef struct {
>    byte unknown[6];
>
>    vbios_modeline_type2 modelines[];
>} __attribute__((packed)) vbios_resolution_type2;
>
>typedef struct {
>    unsigned long clock;
>
>    word x1;
>    word htotal;
>    word x2;
>    word hblank;
>    word hsyncstart;
>    word hsyncend;
>
>    word y1;
>    word vtotal;
>    word y2;
>    word vblank;
>    word vsyncstart;
>    word vsyncend;
>
>    word timing_h;
>    word timing_v;
>
>    byte unknown[6];
>} __attribute__((packed)) vbios_modeline_type3;
>
>typedef struct {
>    unsigned char unknown[6];
>
>    vbios_modeline_type3 modelines[];
>} __attribute__((packed)) vbios_resolution_type3;
>
>
>typedef struct {
>    boolean file;
>
>    cardinal chipset_id;
>    chipset_type chipset;
>    bios_type bios;
>    
>    int bios_fd;
>    address bios_ptr;
>
>    vbios_mode * mode_table;
>    cardinal mode_table_size;
>
>    byte b1, b2;
>
>    boolean unlocked;
>} vbios_map;
>
>
>void initialize_system(char * filename) {
>
>    if (!filename) {
>        if (iopl(3) < 0) {
>            perror("Unable to obtain the proper IO permissions");
>            exit(2);
>        }
>    }
>}
>
>cardinal get_chipset_id(void) {
>    outl(0x80000000, 0xcf8);
>    return inl(0xcfc);
>}
>
>chipset_type get_chipset(cardinal id) {
>    chipset_type type;
>    
>    switch (id) {
>    case 0x25608086:
>        type = CT_845G;
>        break;
>        
>    case 0x35808086:
>        type = CT_855GM;
>        break;
>        
>    case 0x25708086:
>        type = CT_865G;
>        break;
>
>    case 0x25808086:
>	type = CT_915G;
>	break;
>
>    case 0x25908086:
>        type = CT_915GM;
>        break;
>
>    case 0x27708086:
>        type = CT_945G;
>        break;
>
>    case 0x27a08086:
>        type = CT_945GM;
>        break;
>
>    default:
>        type = CT_UNKWN;
>        break;
>    }
>
>    return type;
>}
>
>
>vbios_resolution_type1 * map_type1_resolution(vbios_map * map, word res) {
>    vbios_resolution_type1 * ptr = ((vbios_resolution_type1*)(map->bios_ptr + res)); 
>    return ptr;
>}
>
>vbios_resolution_type2 * map_type2_resolution(vbios_map * map, word res) {
>    vbios_resolution_type2 * ptr = ((vbios_resolution_type2*)(map->bios_ptr + res)); 
>    return ptr;
>}
>
>vbios_resolution_type3 * map_type3_resolution(vbios_map * map, word res) {
>    vbios_resolution_type3 * ptr = ((vbios_resolution_type3*)(map->bios_ptr + res)); 
>    return ptr;
>}
>
>
>boolean detect_bios_type(vbios_map * map, boolean modeline, int entry_size) {
>    int i;
>    short int r1, r2;
>    float f;
>    
>    r1 = r2 = 32000;
>
>    for (i=0; i < map->mode_table_size; i++) {
>        if (map->mode_table[i].resolution <= r1) {
>            r1 = map->mode_table[i].resolution;
>    	}
>        else {
>            if (map->mode_table[i].resolution <= r2) {
>            	r2 = map->mode_table[i].resolution;
>            }
>    	}
>
>        /*printf("r1 = %d  r2 = %d\n", r1, r2);*/
>    }
>
>    
>    f = ((float) (r2-r1-6)) / entry_size;
>
>    return f == (int) f;
>}
>
>
>void close_vbios(vbios_map * map);
>
>
>vbios_map * open_vbios(char * filename, chipset_type forced_chipset) {
>    vbios_map * map = NEW(vbios_map);
>
>    /*
>     * Determine chipset
>     */
>
>    if (!filename && forced_chipset == CT_UNKWN) {
>        map->chipset_id = get_chipset_id();
>
>        map->chipset = get_chipset(map->chipset_id);
>    }
>    else if (forced_chipset != CT_UNKWN) {
>        map->chipset = forced_chipset;
>    }
>    else {
>        map->chipset = CT_915GM;
>    }
>    
>    /*
>     *  Map the video bios to memory
>     */
>
>    if (!filename) {
>        map->bios_fd = open(VBIOS_FILE, O_RDWR);
>        if(map->bios_fd < 0) {
>            if (map->chipset == CT_UNKWN) {
>                fprintf(stderr, "Invalid chipset detected: %x\n", map->chipset_id);
>            }
>            perror("Unable to open the BIOS file");
>            exit(2);
>        }
>        
>        map->bios_ptr = mmap(0, VBIOS_SIZE,
>                             PROT_READ | PROT_WRITE, MAP_SHARED,
>                             map->bios_fd, VBIOS_START);
>        
>        if (map->bios_ptr == MAP_FAILED) {
>            if (map->chipset == CT_UNKWN) {
>                fprintf(stderr, "Invalid chipset detected: %x\n", map->chipset_id);
>            }
>            perror("Cannot mmap() the video BIOS\n");
>            close(map->bios_fd);
>            exit(2);
>        }
>    }
>    else {
>        map->bios_fd = open(filename, O_RDWR);
>        if(map->bios_fd < 0) {
>            if (map->chipset == CT_UNKWN) {
>                fprintf(stderr, "Invalid chipset detected: %x\n", map->chipset_id);
>            }
>            perror("Unable to open the BIOS file");
>            exit(2);
>        }
>        
>        map->bios_ptr = mmap(0, VBIOS_SIZE,
>                             PROT_READ | PROT_WRITE, MAP_SHARED,
>                             map->bios_fd, 0);
>        
>        if (map->bios_ptr == MAP_FAILED) {
>            if (map->chipset == CT_UNKWN) {
>                fprintf(stderr, "Invalid chipset detected: %x\n", map->chipset_id);
>            }
>            perror("Cannot mmap() the BIOS file\n");
>            close(map->bios_fd);
>            exit(2);
>        }
>    }
>
>    /*
>     * check if we have ATI Radeon
>     */
>    
>    if (memmem(map->bios_ptr, VBIOS_SIZE, ATI_SIGNATURE1, strlen(ATI_SIGNATURE1)) ||
>        memmem(map->bios_ptr, VBIOS_SIZE, ATI_SIGNATURE2, strlen(ATI_SIGNATURE2)) ) {
>        fprintf(stderr, "ATI chipset detected.  915resolution only works with Intel 800/900 series graphic chipsets.\n");
>        close(map->bios_fd);
>        exit(2);
>    }
>
>    /*
>     * check if we have NVIDIA
>     */
>    
>    if (memmem(map->bios_ptr, VBIOS_SIZE, NVIDIA_SIGNATURE, strlen(NVIDIA_SIGNATURE))) {
>        fprintf(stderr, "NVIDIA chipset detected.  915resolution only works with Intel 800/900 series graphic chipsets.\n");
>        close(map->bios_fd);
>        exit(2);
>    }
>
>    /*
>     * check if we have Intel
>     */
>    
>    if (map->chipset == CT_UNKWN && memmem(map->bios_ptr, VBIOS_SIZE, INTEL_SIGNATURE, strlen(INTEL_SIGNATURE))) {
>        fprintf(stderr, "Intel chipset detected.  However, 915resolution was unable to determine the chipset type.\n");
>
>        fprintf(stderr, "Chipset Id: %x\n", map->chipset_id);
>
>        fprintf(stderr, "Please report this problem to stomljen@yahoo.com\n");
>        
>        close_vbios(map);
>        exit(2);
>    }
>
>    /*
>     * check for others
>     */
>
>    if (map->chipset == CT_UNKWN) {
>        fprintf(stderr, "Unknown chipset type and unrecognized bios.\n");
>        fprintf(stderr, "915resolution only works with Intel 800/900 series graphic chipsets.\n");
>
>        fprintf(stderr, "Chipset Id: %x\n", map->chipset_id);
>        close_vbios(map);
>        exit(2);
>    }
>
>    /*
>     * Figure out where the mode table is 
>     */
>    
>    {
>        address p = map->bios_ptr + 16;
>        address limit = map->bios_ptr + VBIOS_SIZE - (3 * sizeof(vbios_mode));
>        
>        while (p < limit && map->mode_table == 0) {
>            vbios_mode * mode_ptr = (vbios_mode *) p;
>            
>            if (((mode_ptr[0].mode & 0xf0) == 0x30) && ((mode_ptr[1].mode & 0xf0) == 0x30) &&
>                ((mode_ptr[2].mode & 0xf0) == 0x30) && ((mode_ptr[3].mode & 0xf0) == 0x30)) {
>
>                map->mode_table = mode_ptr;
>            }
>            
>            p++;
>        }
>
>        if (map->mode_table == 0) {
>            fprintf(stderr, "Unable to locate the mode table.\n");
>            fprintf(stderr, "Please run the program 'dump_bios' as root and\n");
>            fprintf(stderr, "email the file 'vbios.dmp' to stomljen@yahoo.com.\n");
>            
>            fprintf(stderr, "Chipset: %s\n", chipset_type_names[map->chipset]);
>            close_vbios(map);
>            exit(2);
>        }
>    }
>
>    /*
>     * Determine size of mode table
>     */
>    
>    {
>        vbios_mode * mode_ptr = map->mode_table;
>        
>        while (mode_ptr->mode != 0xff) {
>            map->mode_table_size++;
>            mode_ptr++;
>        }
>    }
>
>    /*
>     * Figure out what type of bios we have
>     *  order of detection is important
>     */
>
>    if (detect_bios_type(map, TRUE, sizeof(vbios_modeline_type3))) {
>        map->bios = BT_3;
>    }
>    else if (detect_bios_type(map, TRUE, sizeof(vbios_modeline_type2))) {
>        map->bios = BT_2;
>    }
>    else if (detect_bios_type(map, FALSE, sizeof(vbios_resolution_type1))) {
>        map->bios = BT_1;
>    }
>    else {
>        fprintf(stderr, "Unable to determine bios type.\n");
>        fprintf(stderr, "Please run the program 'dump_bios' as root and\n");
>        fprintf(stderr, "email the file 'vbios.dmp' to stomljen@yahoo.com.\n");
>
>        fprintf(stderr, "Chipset: %s\n", chipset_type_names[map->chipset]);
>        fprintf(stderr, "Mode Table Offset: $C0000 + $%x\n", ((cardinal)map->mode_table) - ((cardinal)map->bios_ptr));
>        fprintf(stderr, "Mode Table Entries: %u\n", map->mode_table_size);
>        exit(2);
>    }
>
>    return map;
>}
>
>void close_vbios(vbios_map * map) {
>    assert(!map->unlocked);
>
>    if(map->bios_ptr == MAP_FAILED) {
>        fprintf(stderr, "BIOS should be open already!\n");
>        exit(2);
>    }
>
>    munmap(map->bios_ptr, VBIOS_SIZE);
>    close(map->bios_fd);
>
>    FREE(map);
>}
>
>void unlock_vbios(vbios_map * map) {
>
>    if (!map->file) {
>        assert(!map->unlocked);
>        
>        map->unlocked = TRUE;
>        
>        switch (map->chipset) {
>        case CT_UNKWN:
>            break;
>        case CT_855GM:
>            outl(0x8000005a, 0xcf8);
>            map->b1 = inb(0xcfe);
>            
>            outl(0x8000005a, 0xcf8);
>            outb(0x33, 0xcfe);
>            break;
>        case CT_845G:
>        case CT_865G:
>	case CT_915G:
>        case CT_915GM:
>        case CT_945G:
>        case CT_945GM:
>            outl(0x80000090, 0xcf8);
>            map->b1 = inb(0xcfd);
>            map->b2 = inb(0xcfe);
>            
>            outl(0x80000090, 0xcf8);
>            outb(0x33, 0xcfd);
>            outb(0x33, 0xcfe);
>            break;
>        }
>    }
>
>#if DEBUG
>    {
>        cardinal t = inl(0xcfc);
>        printf("unlock PAM: (0x%08x)\n", t);
>    }
>#endif
>    
>
>#if DEBUG
>    {
>        cardinal t = inl(0xcfc);
>        printf("unlock PAM: (0x%08x)\n", t);
>    }
>#endif
>
>}
>
>void relock_vbios(vbios_map * map) {
>
>    if (!map->file) {
>        assert(map->unlocked);
>        map->unlocked = FALSE;
>        
>        switch (map->chipset) {
>        case CT_UNKWN:
>            break;
>        case CT_855GM:
>            outl(0x8000005a, 0xcf8);
>            outb(map->b1, 0xcfe);
>            break;
>        case CT_845G:
>        case CT_865G:
>	case CT_915G:
>        case CT_915GM:
>        case CT_945G:
>        case CT_945GM:
>            outl(0x80000090, 0xcf8);
>            outb(map->b1, 0xcfd);
>            outb(map->b2, 0xcfe);
>            break;
>        }
>    }
>
>#if DEBUG
>    {
>        cardinal t = inl(0xcfc);
>        printf("relock PAM: (0x%08x)\n", t);
>    }
>#endif
>
>#if DEBUG
>    {
>        cardinal t = inl(0xcfc);
>        printf("relock PAM: (0x%08x)\n", t);
>    }
>#endif
>}
>
>
>void list_modes(vbios_map *map, cardinal raw) {
>    cardinal i, x, y;
>
>    for (i=0; i < map->mode_table_size; i++) {
>        switch(map->bios) {
>        case BT_1:
>            {
>                vbios_resolution_type1 * res = map_type1_resolution(map, map->mode_table[i].resolution);
>                
>                x = ((((cardinal) res->x2) & 0xf0) << 4) | res->x1;
>                y = ((((cardinal) res->y2) & 0xf0) << 4) | res->y1;
>                
>                if (x != 0 && y != 0) {
>                    printf("Mode %02x : %dx%d, %d bits/pixel\n", map->mode_table[i].mode, x, y, map->mode_table[i].bits_per_pixel);
>                }
>
>		if (raw)
>		{
>                    printf("Mode %02x (raw) :\n\t%02x %02x\n\t%02x\n\t%02x\n\t%02x\n\t%02x\n\t%02x\n\t%02x\n", map->mode_table[i].mode, res->unknow1[0],res->unknow1[1], res->x1,res->x_total,res->x2,res->y1,res->y_total,res->y2);
>		}
>
>            }
>            break;
>        case BT_2:
>            {
>                vbios_resolution_type2 * res = map_type2_resolution(map, map->mode_table[i].resolution);
>                
>                x = res->modelines[0].x1+1;
>                y = res->modelines[0].y1+1;
>
>                if (x != 0 && y != 0) {
>                    printf("Mode %02x : %dx%d, %d bits/pixel\n", map->mode_table[i].mode, x, y, map->mode_table[i].bits_per_pixel);
>                }
>            }
>            break;
>        case BT_3:
>            {
>                vbios_resolution_type3 * res = map_type3_resolution(map, map->mode_table[i].resolution);
>                
>                x = res->modelines[0].x1+1;
>                y = res->modelines[0].y1+1;
>                
>                if (x != 0 && y != 0) {
>                    printf("Mode %02x : %dx%d, %d bits/pixel\n", map->mode_table[i].mode, x, y, map->mode_table[i].bits_per_pixel);
>                }
>            }
>            break;
>        case BT_UNKWN:
>            break;
>        }
>    }
>}
>
>void set_mode(vbios_map * map, cardinal mode, 
>	      cardinal x, cardinal y, cardinal bp, cardinal htotal, cardinal vtotal,
>	      cardinal hstart, cardinal hend, cardinal vstart, cardinal vend) {
>    cardinal i, j;
>
>    for (i=0; i < map->mode_table_size; i++) {
>        if (map->mode_table[i].mode == mode) {
>            switch(map->bios) {
>            case BT_1:
>                {
>                    vbios_resolution_type1 * res = map_type1_resolution(map, map->mode_table[i].resolution);
>                    
>                    if (bp) {
>                        map->mode_table[i].bits_per_pixel = bp;
>                    }
>                    
>                    res->x2 = (htotal?(((htotal-x) >> 8) & 0x0f) : (res->x2 & 0x0f)) | ((x >> 4) & 0xf0);
>                    res->x1 = (x & 0xff);
>                    
>                    res->y2 = (vtotal?(((vtotal-y) >> 8) & 0x0f) : (res->y2 & 0x0f)) | ((y >> 4) & 0xf0);
>                    res->y1 = (y & 0xff);
>		    if (htotal)
>			res->x_total = ((htotal-x) & 0xff);
>
>		    if (vtotal)
>			res->y_total = ((vtotal-y) & 0xff);
>                }
>                break;
>            case BT_2:
>                {
>                    vbios_resolution_type2 * res = map_type2_resolution(map, map->mode_table[i].resolution);
>
>                    for(j=0; j < 3; j++) {
>                        vbios_modeline_type2 * modeline = &res->modelines[j];
>                        
>                        if (modeline->x1 == res->modelines[0].x1) {
>                            modeline->x1 = modeline->x2 = x-1;
>                            modeline->y1 = modeline->y2 = y-1;
>			    if (htotal)
>                        	modeline->htotal = htotal;
>
>			    if (vtotal)
>                        	modeline->vtotal = vtotal;
>                            
>                            /* WARNING: I don't know at all what are the formulas
>                               to calculate these values !
>                               The following lines are only an example.
>
>			       Modified: Fixed values 
>                            */
>			    /* 106.47  1440 1528 1672 1904  900 901 904 932 -hsync +vsync */
>
>                            modeline->clock = freqs[j] * x;    
>			    if (hstart == 0 || hend ==0 )
>			      {
>				hstart = x + (htotal-x)/4;
>				hend   = hstart + (htotal-x)/4;
>				fprintf(stderr,"915resolution warning: Imprecisely calculated horizontal sync start and end \n");
>			      }
>			    if (vstart == 0 || vend==0)
>			      {
>				vstart = y+2;
>				vend =   y+4;
>				fprintf(stderr,"915resulution warning: Imprecisely calculated vertical sync start and end\n");
>			      }
>                            
>                            modeline->hsyncstart = hstart;
>                            modeline->hsyncend   = hend;
>                            
>                            modeline->vsyncstart = vstart;
>                            modeline->vsyncend   = vend;
>			    
>			    fprintf(stderr," Modeline j= %5i Freq=%4i Hz \n Set clock to %9li\n",
>				    j, freqs[j], modeline->clock);
>			    fprintf(stderr," x = %i  Htotal = %8i Vtotal = %8i\n",
>				    x, modeline->htotal, modeline->vtotal);
>			    fprintf(stderr," HsyncStart= %8i\n HsyncEnd  = %8i\n VsyncStart= %8i \n VsyncEnd  = %8i\n",
>				    modeline->hsyncstart,
>				    modeline->hsyncend,
>                                    modeline->vsyncstart,
>                                    modeline->vsyncend
>				    );
>                        }
>                    }
>                }
>                break;
>            case BT_3:
>                {
>                    vbios_resolution_type3 * res = map_type3_resolution(map, map->mode_table[i].resolution);
>                    
>                    for (j=0; j < 3; j++) {
>                        vbios_modeline_type3 * modeline = &res->modelines[j];
>                        
>                        if (modeline->x1 == res->modelines[0].x1) {
>                            modeline->x1 = modeline->x2 = x-1;
>                            modeline->y1 = modeline->y2 = y-1;
>                            
>			    if (htotal)
>                        	modeline->htotal = htotal;
>
>			    if (vtotal)
>                        	modeline->vtotal = vtotal;
>
>                            /* WARNING: I don't know at all what are the formulas
>                               to calculate these values !
>                               The following lines are only an example
>			       Replaced warning: What would really be needed is 
>			       a call to gtf or cvt to compute the proper values
>			       for h/v syncstart and end.  
>                            */
>
>			    modeline->clock = freqs[j] * x;
>
>			    if (hstart == 0 || hend ==0 )
>			      {
>				hstart = x + (htotal-x)/4;
>				hend   = hstart + (htotal-x)/4;
>				fprintf(stderr,"915resolution warning: Imprecisely calculated horizontal sync start and end \n");
>			      }
>			    if (vstart == 0 || vend==0)
>			      {
>				vstart = y+2;
>				vend =   y+4;
>				fprintf(stderr,"915resulution warning: Imprecisely calculated vertical sync start and end\n");
>			      }
>                            
>                            modeline->hsyncstart = hstart;
>                            modeline->hsyncend   = hend;
>                            
>                            modeline->vsyncstart = vstart;
>                            modeline->vsyncend   = vend;
>			    
>			    fprintf(stderr," Modeline j= %5i Freq=%4i Hz \n Set clock to %9li\n",
>				    j, freqs[j], modeline->clock);
>			    fprintf(stderr," x = %i  Htotal = %8i Vtotal = %8i\n",
>				    x, modeline->htotal, modeline->vtotal);
>			    fprintf(stderr," HsyncStart= %8i\n HsyncEnd  = %8i\n VsyncStart= %8i \n VsyncEnd  = %8i\n",
>				    modeline->hsyncstart,
>				    modeline->hsyncend,
>                                    modeline->vsyncstart,
>                                    modeline->vsyncend
>				    );
>                            modeline->timing_h   = 0x2ff;
>                            modeline->timing_v   = 0x4ff;
>
>                        }
>                    }
>                }
>                break;
>            case BT_UNKWN:
>                break;
>            }
>        }
>    }
>}   
>
>void display_map_info(vbios_map * map) {
>    printf("Chipset: %s\n", chipset_type_names[map->chipset]);
>    printf("BIOS: %s\n", bios_type_names[map->bios]);
>
>    printf("Mode Table Offset: $C0000 + $%x\n", ((cardinal)map->mode_table) - ((cardinal)map->bios_ptr));
>    printf("Mode Table Entries: %u\n", map->mode_table_size);
>}
>
>
>/* Modified: Reiner Wilhelms
>
> A new option -m followed by the timing information of a mode line (xorg.conf)
>
> Instead of specifying only the x and y screen resolution, 
> I want to specify an entire mode line, as follows:
>
>/usr/sbin/915resolution  -m mode bitperpix  xres HsyncStart HsyncEnd Htotal   yres VsyncStart VsyncEnd Vtotal 
>
>so for a Modeline found in xorg.conf:
>
>Modeline "1440x900" 106.50  1440 1528 1672 1904  900 903 909 934 -hsync +vsync
>
>one would have 
>
>/usr/sbin/915resolution  -m 38  8 1440 1528 1672 1904  900 903 909 934
>/usr/sbin/915resolution  -m 49 16 1440 1528 1672 1904  900 903 909 934
>/usr/sbin/915resolution  -m 58 32 1440 1528 1672 1904  900 903 909 934
>
>Note that only one modeline per mode can be set, and that the user has
>to make sure that the modelines specified correspond to a mode line in
>xorg.conf
>
>*/
>
>int parse_args(int argc, char *argv[], char ** filename, chipset_type *forced_chipset, cardinal *list, 
>	       cardinal *mode, cardinal *x, cardinal *y, cardinal *bp, cardinal *raw, cardinal *htotal, cardinal *vtotal,
>	       cardinal *hstart, cardinal *hend, cardinal *vstart, cardinal *vend) {
>    cardinal index = 1;
>
>    cardinal directsetmode=0;
>
>    *list = *mode = *x = *y = *raw = *htotal = *vtotal = 0;
>    *hstart = *hend = *vstart = *vend = 0;
>
>    *forced_chipset = CT_UNKWN;
>    
>    *filename = NULL;
>
>    if ((argc > index) && !strcmp(argv[index], "-f")) {
>        index++;
>
>        if(argc<=index) {
>            return 0;
>        }
>        
>        *filename = argv[index];
>        
>        index++;
>        
>        if(argc<=index) {
>            return 0;
>        }
>    }
>    
>    if ((argc > index) && !strcmp(argv[index], "-c")) {
>        index++;
>
>        if(argc<=index) {
>            return 0;
>        }
>        
>        if (!strcmp(argv[index], "845")) {
>            *forced_chipset = CT_845G;
>        }
>        else if (!strcmp(argv[index], "855")) {
>            *forced_chipset = CT_855GM;
>        }
>        else if (!strcmp(argv[index], "865")) {
>            *forced_chipset = CT_865G;
>        }
>        else if (!strcmp(argv[index], "915G")) {
>            *forced_chipset = CT_915G;
>        }
>        else if (!strcmp(argv[index], "915GM")) {
>            *forced_chipset = CT_915GM;
>        }
>        else if (!strcmp(argv[index], "945G")) {
>            *forced_chipset = CT_945G;
>        }
>        else if (!strcmp(argv[index], "945GM")) {
>            *forced_chipset = CT_945GM;
>        }
>        else {
>            *forced_chipset = CT_UNKWN;
>        }
>        
>        index++;
>        
>        if (argc<=index) {
>            return 0;
>        }
>    }
>
>    if ((argc > index) && !strcmp(argv[index], "-l")) {
>        *list = 1;
>        index++;
>
>        if(argc<=index) {
>            return 0;
>        }
>    }
>    
>    if ((argc > index) && !strcmp(argv[index], "-r")) {
>        *raw = 1;
>        index++;
>
>        if(argc<=index) {
>            return 0;
>        }
>    }
>
>    if ((argc > index) && !strcmp(argv[index], "-m")) {
>        directsetmode = 1;
>        index++;
>	fprintf(stderr," direct set mode index: %i\n",index);
>
>        if(argc<=index) {
>            return 0;
>        }
>    }
>    
>
>    if (directsetmode)   /* is set if option -m was used */
>      {
>	/* sequence of numbers altered. Example:
>	   /usr/sbin/915resolution  -m 38  8 1440 1528 1672 1904  900 903 909 934
>	*/
>	if (argc-index < 10) {
>	  fprintf(stderr," 915resolution: wrong number of arguments for setting direct modeline \n");
>	  return -1;
>	}	
>	*mode = (cardinal) strtol(argv[index], NULL, 16);
>	*bp = (cardinal)atoi(argv[index+1]);     
>	*x  = (cardinal)atoi(argv[index+2]);     
>	*hstart = (cardinal)atoi(argv[index+3]); 
>	*hend = (cardinal)atoi(argv[index+4]);   
>	*htotal = (cardinal)atoi(argv[index+5]); 
>	*y  = (cardinal)atoi(argv[index+6]);     
>	*vstart = (cardinal)atoi(argv[index+7]); 
>	*vend = (cardinal)atoi(argv[index+8]);   
>	*vtotal = (cardinal)atoi(argv[index+9]); 
>	/*	fprintf(stderr,"vtotal %i \n",*vtotal); */
>      }
>    else
>      {
>	if (argc-index < 3 || (!directsetmode && (argc-index) > 6 ) || (directsetmode && (argc-index) < 10)) {
>	  fprintf(stderr," 915resolutino: wrong number of arguments \n");
>	  return -1;
>	}
>	
>	*mode = (cardinal) strtol(argv[index], NULL, 16);
>	*x = (cardinal)atoi(argv[index+1]);
>	*y = (cardinal)atoi(argv[index+2]);
>	
>	/* previously used method */
>	if (argc-index > 3) {
>	  *bp = (cardinal)atoi(argv[index+3]);
>	}
>	else {
>	  *bp = 0;
>	}
>	
>	if (argc-index > 4) {
>	  *htotal = (cardinal)atoi(argv[index+4]);
>	}
>	else {
>	  *htotal = 0;
>	}
>	
>	if (argc-index > 5) {
>	  *vtotal = (cardinal)atoi(argv[index+5]);
>	}
>	else {
>	  *vtotal = 0;
>	}
>      } 
>    
>    return 0;
>}
>
>void usage(char *name) {
>    printf("Usage: %s [-f file] [-c chipset] [-l] [mode X Y] [bits/pixel] [htotal] [vtotal]\n", name);
>    printf("  Set the resolution to XxY for a video mode\n");
>    printf("  Bits per pixel are optional.  htotal/vtotal settings are additionally optional.\n");
>    printf("  Options:\n");
>    printf("    -f use an alternate file (THIS IS USED FOR DEBUG PURPOSES)\n");
>    printf("    -c force chipset type (THIS IS USED FOR DEBUG PURPOSES)\n");
>    printf("    -l display the modes found in the video BIOS\n");
>    printf("    -r display the modes found in the video BIOS in raw mode (THIS IS USED FOR DEBUG PURPOSES)\n");
>    printf("    -m specify modes directly:  \n");
>    printf("       915resolution -m mode bitperpix  xres HsyncStart HsyncEnd Htotal   yres VsyncStart VsyncEnd Vtotal\n");
>}
>
> int main (int argc, char *argv[]) {
>    vbios_map * map;
>    cardinal list, mode, x, y, bp, raw, htotal, vtotal, hstart,hend,vstart,vend;
>    char * filename;
>    chipset_type forced_chipset;
>    
>    printf("Intel 800/900 Series VBIOS Hack : version %s\n\n", VERSION);
>
>    if (parse_args(argc, argv, &filename, &forced_chipset, &list, &mode, &x, &y, &bp, &raw, &htotal, &vtotal,&hstart,&hend,&vstart,&vend) == -1) {
>        usage(argv[0]);
>        return 2;
>    }
>
>    initialize_system(filename);
>    
>    map = open_vbios(filename, forced_chipset);
>    display_map_info(map);
>
>    printf("\n");
>
>    if (list) {
>        list_modes(map, raw);
>    }
>
>    if (mode!=0 && x!=0 && y!=0) {
>        unlock_vbios(map);
>        set_mode(map, mode, x, y, bp, htotal, vtotal, hstart,hend,vstart,vend);
>        relock_vbios(map);
>        
>        printf("Patch mode %02x to resolution %dx%d complete\n", mode, x, y);
>        
>        if (list) {
>            list_modes(map, raw);
>        }
>    }
>
>    close_vbios(map);
>    
>    return 0;
>}
>

Actions: View

Attachments on bug 222328: 145376 | 145720