| |
| /* 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 |
