/* Radeontool   v1.4
 * by Frederick Dean <software@fdd.com>
 * Copyright 2002-2004 Frederick Dean
 * Use hereby granted under the zlib license.
 *
 * Warning: I do not have the Radeon documents, so this was engineered from 
 * the radeon_reg.h header file.  
 *
 * USE RADEONTOOL AT YOUR OWN RISK
 *
 * Thanks to Deepak Chawla, Erno Kuusela, Rolf Offermanns, and Soos Peter
 * for patches.
 *
 * Stripped down to bare bones by Pavel Machek <pavel@suse.cz> -- for use in s2ram.c
 * Rework of the map_radeon_cntl_mem function and various cleanups 
 *                                  by Stefan Seyfried <seife@suse.de>
 */

#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <pci/pci.h>

#define RADEON_LVDS_GEN_CNTL                0x02d0
#       define RADEON_LVDS_ON               (1   <<  0)
#       define RADEON_LVDS_DISPLAY_DIS      (1   <<  1)
#       define RADEON_LVDS_PANEL_TYPE       (1   <<  2)
#       define RADEON_LVDS_PANEL_FORMAT     (1   <<  3)
#       define RADEON_LVDS_EN               (1   <<  7)
#       define RADEON_LVDS_DIGON            (1   << 18)
#       define RADEON_LVDS_BLON             (1   << 19)
#       define RADEON_LVDS_SEL_CRTC2        (1   << 23)

/* *radeon_cntl_mem is mapped to the actual device's memory mapped control area. */
/* Not the address but what it points to is volatile. */
volatile unsigned char * radeon_cntl_mem;

static unsigned long radeon_get(unsigned long offset)
{
    unsigned long value;

    if(radeon_cntl_mem == NULL) {
        fprintf(stderr, "radeon_get: radeon_cntl_mem == NULL");
        return 0;
    }

    value = *(volatile unsigned long *)(radeon_cntl_mem+offset);
    return value;
}

static void radeon_set(unsigned long offset, unsigned long value)
{
    if(radeon_cntl_mem == NULL) {
        fprintf(stderr, "radeon_set: radeon_cntl_mem == NULL");
        return;
    }

    *(volatile unsigned long *)(radeon_cntl_mem+offset) = value;
}

/* Ohh, life would be good if we could simply address all memory addresses */
/* with /dev/mem, then I could write this whole program in perl, */
/* but sadly this is only the size of physical RAM.  If you */
/* want to be truely bad and poke into device memory you have to mmap() */
static volatile unsigned char * map_device_memory(unsigned int base,unsigned int length) 
{
    int mem_fd;
    volatile unsigned char *device_mem;

    /* open /dev/mem */
    if ((mem_fd = open("/dev/mem", O_RDWR) ) < 0) {
        perror("radeontool /dev/mem");
        return NULL;
    }

    /* mmap graphics memory */
    if ((device_mem = malloc(length + (getpagesize()-1))) == NULL) {
        perror("radeontool malloc");
        close(mem_fd);
        return NULL;
    }
    if ((unsigned long)device_mem % getpagesize())
        device_mem += getpagesize() - ((unsigned long)device_mem % getpagesize());
    device_mem = (volatile unsigned char *)mmap(
        (caddr_t)device_mem, 
        length,
        PROT_READ|PROT_WRITE,
        MAP_SHARED|MAP_FIXED,
        mem_fd, 
        base
    );
    if (device_mem == (volatile unsigned char *)-1) {
        perror("radeontool mmap");
        return NULL;
    }
    return device_mem;
}

void radeon_cmd_light(int param)
{
    unsigned long lvds_gen_cntl;

    lvds_gen_cntl = radeon_get(RADEON_LVDS_GEN_CNTL);

    if (param)
        lvds_gen_cntl |= RADEON_LVDS_ON;
    else
        lvds_gen_cntl &= ~ RADEON_LVDS_ON;

    radeon_set(RADEON_LVDS_GEN_CNTL, lvds_gen_cntl);
}

/* I have not got much feedback on my radeontool rework, hence i leave the old
 * code #if 0-ed in for reference.
 * Once some time passes without complaints about the new code, i will remove it.
 * Sorry for the clutter - seife.
 */
#if 0
/* Here we fork() and exec() the lspci command to look for the Radeon hardware address. */
void map_radeon_cntl_mem(void)
{
    int pipefd[2];
    int forkrc;
    FILE *fp;
    char line[1000];
    int base;

    if(pipe(pipefd)) {
        fatal("pipe failure\n");
    }
    forkrc = fork();
    if(forkrc == -1) {
        fatal("fork failure\n");
    } else if(forkrc == 0) { /* if child */
        close(pipefd[0]);
        dup2(pipefd[1],1);  /* stdout */
        setenv("PATH","/sbin:/usr/sbin:/bin:/usr/bin",1);
        execlp("lspci","lspci","-v",NULL);
        fatal("exec lspci failure\n");
    }
    close(pipefd[1]);
    fp = fdopen(pipefd[0],"r");
    if(fp == NULL) {
        fatal("fdopen error\n");
    }
#if 0
  This is an example output of "lspci -v" ...

00:1f.6 Modem: Intel Corp. 82801CA/CAM AC 97 Modem (rev 01) (prog-if 00 [Generic])
	Subsystem: PCTel Inc: Unknown device 4c21
	Flags: bus master, medium devsel, latency 0, IRQ 11
	I/O ports at d400 [size=256]
	I/O ports at dc00 [size=128]

01:00.0 VGA compatible controller: ATI Technologies Inc Radeon Mobility M6 LY (prog-if 00 [VGA])
	Subsystem: Dell Computer Corporation: Unknown device 00e3
	Flags: bus master, VGA palette snoop, stepping, 66Mhz, medium devsel, latency 32, IRQ 11
	Memory at e0000000 (32-bit, prefetchable) [size=128M]
	I/O ports at c000 [size=256]
	Memory at fcff0000 (32-bit, non-prefetchable) [size=64K]
	Expansion ROM at <unassigned> [disabled] [size=128K]
	Capabilities: <available only to root>

02:00.0 Ethernet controller: 3Com Corporation 3c905C-TX/TX-M [Tornado] (rev 78)
	Subsystem: Dell Computer Corporation: Unknown device 00e3
	Flags: bus master, medium devsel, latency 32, IRQ 11
	I/O ports at ec80 [size=128]
	Memory at f8fffc00 (32-bit, non-prefetchable) [size=128]
	Expansion ROM at f9000000 [disabled] [size=128K]
	Capabilities: <available only to root>

We need to look through it to find the smaller region base address f8fffc00.

#endif
    while(1) { /* for every line up to the "Radeon" string */
       if(fgets(line,sizeof(line),fp) == NULL) {  /* if end of file */
          fatal("Radeon hardware not found in lspci output.\n");
       }
       if(strstr(line,"Radeon") || strstr(line,"ATI Tech")) {  /* if line contains a "radeon" string */
             break;
       }
    };
    if(debug) 
       printf("%s",line);
    while(1) { /* for every line up till memory statement */
       if(fgets(line,sizeof(line),fp) == NULL || line[0] != '\t') {  /* if end of file */
          fatal("Radeon control memory not found.\n");
       }
       if(debug) 
          printf("%s",line);
       if(strstr(line,"emory") && strstr(line,"K")) {  /* if line contains a "Memory" and "K" string */
          break;
       }
    };
    if(sscanf(line,"%*s%*s%x",&base) == 0) { /* third token as hex number */
       fatal("parse error of lspci output (control memory not found)\n");
    }
    if(debug)
        printf("Radeon found. Base control address is %x.\n",base);
    radeon_cntl_mem = map_device_memory(base,0x2000);
}
#else

static u32
get_conf_long(unsigned char *d, unsigned int pos)
{
    return d[pos] | (d[pos+1] << 8) | (d[pos+2] << 16) | (d[pos+3] << 24);
}

/* Find out where the radeon memory is. The idea is taken from radeontool-1.5,
 * but we no longer fork lspci and parse its output :-)
 * The logic seems to be: the memory range that is not I/O space and smaller
 * than 1 MB is the radeon chip control range. Let's hope that this is true.
 */
void map_radeon_cntl_mem(void)
{
    struct pci_access *pacc;
    struct pci_dev *dev;
    unsigned int class;
    int i;
    int base = -1;
    unsigned char *config;

    radeon_cntl_mem = NULL;

    config = malloc(64);
    if (!config) {
        perror("map_radeon_cntl_mem malloc(64)");
        return;
    }
    pacc = pci_alloc();		/* Get the pci_access structure */
    pci_init(pacc);		/* Initialize the PCI library */
    pci_scan_bus(pacc);		/* We want to get the list of devices */
    for (dev=pacc->devices; dev; dev=dev->next) {           /* Iterate over all devices */
        pci_fill_info(dev, PCI_FILL_IDENT | PCI_FILL_BASES);/* Fill in header info we need */
        class = pci_read_word(dev, PCI_CLASS_DEVICE);       /* Read config register directly */
        if (dev->vendor_id == 0x1002 && class == 0x300) {   /* ATI && Graphics card */
            pci_read_block(dev, 0, config, 64);
            for (i=0; i<6; i++){
                u32 flag = get_conf_long(config, PCI_BASE_ADDRESS_0 + 4*i);
                if (flag & PCI_BASE_ADDRESS_SPACE_IO)   /* I/O-Ports, not memory */
                    continue;
                /* the original code parsed lspci for "emory" and "K", so it
                 * has to be at least 1K and less than 1M
                 */
                if (dev->size[i] >=1024 && dev->size[i] < 1024*1024) {
                    base = dev->base_addr[i];
                    goto found;
                }
            }
        }
    }
 found:
    pci_cleanup(pacc);
    free(config);
    if (base == -1) {
        fprintf(stderr, "radeontool: Radeon not found.\n");
        return;
    }
    radeon_cntl_mem = map_device_memory(base,0x2000);
}
#endif

#ifndef S2RAM
int main(int argc,char *argv[]) 
{
    map_radeon_cntl_mem();
    if (radeon_cntl_mem == NULL) {
        fprintf(stderr, "Fatal error: radeon_cntl_mem == NULL.\n");
        return 1;
    }
    if (argc == 3) {
        if(strcmp(argv[1],"light") == 0) {
            radeon_cmd_light(strcmp(argv[2],"off"));
            return 0;
        }
    };
    return 1;
}
#endif