src/drivers/generic/debug/debug_dev.c

   1 #include <console/console.h>
   2 #include <device/device.h>
   3 #include <device/smbus.h>
   4 #include <device/pci.h>
   5 #include <device/pci_ids.h>
   6 #include <device/pci_ops.h>
   7 #include <cpu/x86/msr.h>
   8 #include "chip.h"
   9
  10 static void print_pci_regs(struct device *dev)
  11 {
  12       uint8_t byte;
  13       int i;
  14
  15       for(i=0;i<256;i++) {
  16               byte = pci_read_config8(dev, i);
  17
  18               if((i & 0xf)==0) printk_debug("\n%02x:",i);
  19               printk_debug(" %02x",byte);
  20       }
  21       printk_debug("\n");
  22 }
  23
  24 static void print_mem(void)
  25 {
  26         unsigned int i;
  27         unsigned int start = 0xfffff000;
  28         for(i=start;i<0xffffffff;i++) {
  29              if((i & 0xf)==0) printk_debug("\n %08x:",i);
  30              printk_debug(" %02x",(unsigned char)*((unsigned char *)i));
  31              }
  32         printk_debug(" %02x\n",(unsigned char)*((unsigned char *)i));
  33
  34  }
  35 static void print_pci_regs_all(void)
  36 {
  37         struct device *dev;
  38         unsigned char bus, device, function;
  39
  40         for(bus=0; bus<=256; bus++) {
  41                 for(device=0; device<=0x1f; device++) {
  42                         for (function=0; function<=7; function++){
  43                                 unsigned devfn;
  44                                 devfn = PCI_DEVFN(device, function);
  45                                 dev = dev_find_slot(bus, devfn);
  46                                 if(!dev) {
  47                                         continue;
  48                                 }
  49                                 if(!dev->enabled) {
  50                                         continue;
  51                                 }
  52                                 printk_debug("\n%02x:%02x:%02x aka %s",
  53                                         bus, device, function, dev_path(dev));
  54                                 print_pci_regs(dev);
  55                         }
  56                 }
  57         }
  58 }
  59
  60 static void print_cpuid()
  61 {
  62         msr_t msr;
  63         unsigned index;
  64         unsigned eax, ebx, ecx, edx;
  65         index = 0x80000007;
  66         printk_debug("calling cpuid 0x%08x\n", index);
  67         asm volatile(
  68                 "cpuid"
  69                 : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
  70                 : "a" (index)
  71                 );
  72         printk_debug("cpuid[%08x]: %08x %08x %08x %08x\n",
  73                 index, eax, ebx, ecx, edx);
  74         if (edx & (3 << 1)) {
  75                 index = 0xC0010042;
  76                 printk_debug("Reading msr: 0x%08x\n", index);
  77                 msr = rdmsr(index);
  78                 printk_debug("msr[0x%08x]: 0x%08x%08x\n",
  79                         index, msr.hi, msr.hi);
  80         }
  81
  82 }
  83 static void print_smbus_regs(struct device *dev)
  84 {
  85         int j;
  86         printk_debug("smbus:  %s[%d]->",  dev_path(dev->bus->dev), dev->bus->link );
  87         printk_debug("%s",  dev_path(dev));
  88         for(j = 0; j < 256; j++) {
  89                 int status;
  90                 unsigned char byte;
  91                 if ((j & 0xf) == 0) {
  92                         printk_debug("\r\n%02x: ", j);
  93                 }
  94                 status = smbus_read_byte(dev, j);
  95                 if (status < 0) {
  96                         printk_debug("bad device status= %08x\r\n", status);
  97                         break;
  98                 }
  99                 byte = status & 0xff;
 100                 printk_debug("%02x ", byte);
 101         }
 102         printk_debug("\r\n");
 103 }
 104
 105 static void print_smbus_regs_all(struct device *dev)
 106 {
 107         struct device *child;
 108         int i;
 109         if (dev->enabled && dev->path.type == DEVICE_PATH_I2C)
 110         {
 111                 // Here don't need to call smbus_set_link, because we scan it from top to down
 112                 if( dev->bus->dev->path.type == DEVICE_PATH_I2C) { // it's under i2c MUX so set mux at first
 113                         if(ops_smbus_bus(get_pbus_smbus(dev->bus->dev))) {
 114                                 if(dev->bus->dev->ops && dev->bus->dev->ops->set_link)
 115                                         dev->bus->dev->ops->set_link(dev->bus->dev, dev->bus->link);
 116                         }
 117                 }
 118
 119                 if(ops_smbus_bus(get_pbus_smbus(dev))) print_smbus_regs(dev);
 120         }
 121
 122         for(i=0; i< dev->links; i++) {
 123                 for (child = dev->link[i].children; child; child = child->sibling) {
 124                         print_smbus_regs_all(child);
 125                 }
 126         }
 127 }
 128 static void debug_init(device_t dev)
 129 {
 130         device_t parent;
 131         if (!dev->enabled)
 132                 return;
 133         switch(dev->path.u.pnp.device) {
 134 #if CONFIG_CHIP_NAME
 135         case 0:
 136                 parent = dev->bus->dev;
 137                 printk_debug("DEBUG: %s", dev_path(parent));
 138                 if(parent->chip_ops && parent->chip_ops->name) {
 139                         printk_debug(": %s\n", parent->chip_ops->name);
 140                 } else {
 141                         printk_debug("\n");
 142                 }
 143                 break;
 144 #endif
 145
 146         case 1:
 147                 print_pci_regs_all();
 148                 break;
 149         case 2:
 150                 print_mem();
 151                 break;
 152         case 3:
 153                 print_cpuid();
 154                 break;
 155         case 4:
 156                 print_smbus_regs_all(&dev_root);
 157                 break;
 158         }
 159 }
 160
 161 static void debug_noop(device_t dummy)
 162 {
 163 }
 164
 165 static struct device_operations debug_operations = {
 166         .read_resources   = debug_noop,
 167         .set_resources    = debug_noop,
 168         .enable_resources = debug_noop,
 169         .init             = debug_init,
 170 };
 171
 172 static void enable_dev(struct device *dev)
 173 {
 174         dev->ops = &debug_operations;
 175 }
 176
 177 struct chip_operations drivers_generic_debug_ops = {
 178         CHIP_NAME("Debug device")
 179         .enable_dev = enable_dev,
 180 };