src/southbridge/nvidia/ck804/ck804.c

   1 /*
   2  * Copyright 2004 Tyan Computer
   3  *  by yhlu@tyan.com
   4  */
   5
   6 #include <console/console.h>
   7
   8 #include <arch/io.h>
   9
  10 #include <device/device.h>
  11 #include <device/pci.h>
  12 #include <device/pci_ids.h>
  13 #include <device/pci_ops.h>
  14 #include "ck804.h"
  15
  16 static uint32_t final_reg;
  17
  18 static device_t find_lpc_dev( device_t dev,  unsigned devfn)
  19 {
  20
  21         device_t lpc_dev;
  22
  23         lpc_dev = dev_find_slot(dev->bus->secondary, devfn);
  24
  25         if ( !lpc_dev ) return lpc_dev;
  26
  27         if ((lpc_dev->vendor != PCI_VENDOR_ID_NVIDIA) || (
  28                 (lpc_dev->device != PCI_DEVICE_ID_NVIDIA_CK804_LPC) &&
  29                 (lpc_dev->device != PCI_DEVICE_ID_NVIDIA_CK804_PRO) &&
  30                 (lpc_dev->device != PCI_DEVICE_ID_NVIDIA_CK804_SLAVE)) ) {
  31                         uint32_t id;
  32                         id = pci_read_config32(lpc_dev, PCI_VENDOR_ID);
  33                         if ( (id != (PCI_VENDOR_ID_NVIDIA | (PCI_DEVICE_ID_NVIDIA_CK804_LPC << 16))) &&
  34                                 (id != (PCI_VENDOR_ID_NVIDIA | (PCI_DEVICE_ID_NVIDIA_CK804_PRO << 16))) &&
  35                                 (id != (PCI_VENDOR_ID_NVIDIA | (PCI_DEVICE_ID_NVIDIA_CK804_SLAVE << 16)))
  36                                 ) {
  37                                lpc_dev = 0;
  38                         }
  39         }
  40
  41         return lpc_dev;
  42 }
  43
  44 void ck804_enable(device_t dev)
  45 {
  46         device_t lpc_dev;
  47         unsigned index = 0;
  48         unsigned index2 = 0;
  49         uint32_t reg_old, reg;
  50         uint8_t byte;
  51         unsigned deviceid;
  52         unsigned vendorid;
  53
  54         struct southbridge_nvidia_ck804_config *conf;
  55         conf = dev->chip_info;
  56
  57         unsigned devfn;
  58
  59         if(dev->device==0x0000) {
  60                 vendorid = pci_read_config32(dev, PCI_VENDOR_ID);
  61                 deviceid = (vendorid>>16) & 0xffff;
  62 //              vendorid &= 0xffff;
  63         } else {
  64 //              vendorid = dev->vendor;
  65                 deviceid = dev->device;
  66         }
  67
  68         devfn = (dev->path.u.pci.devfn) & ~7;
  69         switch(deviceid) {
  70                 case PCI_DEVICE_ID_NVIDIA_CK804_SM:
  71                         index = 16;
  72                         break;
  73                 case PCI_DEVICE_ID_NVIDIA_CK804_USB:
  74                         devfn -= (1<<3);
  75                         index = 8;
  76                         break;
  77                 case PCI_DEVICE_ID_NVIDIA_CK804_USB2:
  78                         devfn -= (1<<3);
  79                         index = 20;
  80                         break;
  81                 case PCI_DEVICE_ID_NVIDIA_CK804_NIC:
  82                         devfn -= (9<<3);
  83                         index = 10;
  84                         dev->rom_address = conf->nic_rom_address;
  85                         break;
  86                 case PCI_DEVICE_ID_NVIDIA_CK804_NIC_BRIDGE:
  87                         devfn -= (9<<3);
  88                         index = 10;
  89                         dev->rom_address = conf->nic_rom_address;
  90                         break;
  91                 case PCI_DEVICE_ID_NVIDIA_CK804_ACI:
  92                         devfn -= (3<<3);
  93                         index = 12;
  94                         break;
  95                 case PCI_DEVICE_ID_NVIDIA_CK804_MCI:
  96                         devfn -= (3<<3);
  97                         index = 13;
  98                         break;
  99                 case PCI_DEVICE_ID_NVIDIA_CK804_IDE:
 100                         devfn -= (5<<3);
 101                         index = 14;
 102                         dev->rom_address = conf->raid_rom_address;
 103                         break;
 104                 case PCI_DEVICE_ID_NVIDIA_CK804_SATA0:
 105                         devfn -= (6<<3);
 106                         index = 22;
 107                         break;
 108                 case PCI_DEVICE_ID_NVIDIA_CK804_SATA1:
 109                         devfn -= (7<<3);
 110                         index = 18;
 111                         break;
 112                 case PCI_DEVICE_ID_NVIDIA_CK804_PCI:
 113                         devfn -= (8<<3);
 114                         index = 15;
 115                         break;
 116                 case PCI_DEVICE_ID_NVIDIA_CK804_PCI_E:
 117                         devfn -= (0xa<<3);
 118                         index2 = 19;
 119                         break;
 120                 default:
 121                         index = 0;
 122         }
 123
 124         if(index2!=0) {
 125                 int i;
 126                 for(i=0;i<4;i++) {
 127                         lpc_dev = find_lpc_dev(dev, devfn - (i<<3));
 128                         if(!lpc_dev) continue;
 129                         index2 -= i;
 130                         break;
 131                 }
 132
 133                 if ( lpc_dev ) {
 134                         reg_old = reg =  pci_read_config32(lpc_dev, 0xe4);
 135
 136                         if (!dev->enabled) {
 137                                 reg |= (1<<index2);
 138                         }
 139
 140                         if (reg != reg_old) {
 141                                 pci_write_config32(lpc_dev, 0xe4, reg);
 142                         }
 143                 }
 144
 145                 index2 = 0;
 146                 return;
 147         }
 148
 149
 150         lpc_dev = find_lpc_dev(dev, devfn);
 151
 152         if ( !lpc_dev ) return;
 153
 154         if ( index == 0) {
 155
 156                 final_reg = pci_read_config32(lpc_dev, 0xe8);
 157                 final_reg &= ~((1<<16)|(1<<8)|(1<<20)|(1<<10)|(1<<12)|(1<<13)|(1<<14)|(1<<22)|(1<<18)|(1<<15));
 158                 pci_write_config32(lpc_dev, 0xe8, final_reg);
 159
 160                 reg_old = reg = pci_read_config32(lpc_dev, 0xe4);
 161                 reg |= (1<<20);
 162                 if (reg != reg_old) {
 163                         pci_write_config32(lpc_dev, 0xe4, reg);
 164                 }
 165
 166                 byte = pci_read_config8(lpc_dev, 0x74);
 167                 byte |= ((1<<1));
 168                 pci_write_config8(dev, 0x74, byte);
 169
 170                 byte = pci_read_config8(lpc_dev, 0xdd);
 171                 byte |= ((1<<0)|(1<<3));
 172                 pci_write_config8(dev, 0xdd, byte);
 173
 174                 return;
 175
 176         }
 177
 178         if (!dev->enabled) {
 179                 final_reg |= (1 << index);
 180         }
 181
 182         if(index == 10 ) {
 183                 reg_old = pci_read_config32(lpc_dev, 0xe8);
 184                 if (final_reg != reg_old) {
 185                         pci_write_config32(lpc_dev, 0xe8, final_reg);
 186                 }
 187
 188         }
 189
 190 }
 191
 192 struct chip_operations southbridge_nvidia_ck804_ops = {
 193         CHIP_NAME("NVIDIA CK804 Southbridge")
 194         .enable_dev = ck804_enable,
 195 };