hwmodiag.c

hwmodiag for mcp55 chipset

			}
			printf("%-15s :  %d C Degree\n", tests[i].name, tests[i].get_val.ival);
		}
	}
	return 0;
}


void usage(void)
{
	gotoxy(1,6);
	printf("Usage:\n");
	printf("hwmodiag c [config file name]  --------  view config file\n");
	printf("hwmodiag t [config file name]  --------  start test\n");
	printf("hwmodiag -?                    --------  print this usage\n");

	return;
}

int main (int argc, char **argv)
{
	int i = 0, ret = 1, ch = 0;
	char *file = NULL;
//	char str;
	FILE *fp;
	char buf[80];
	char *vs;

	clrscr();

	gotoxy(8,1);
		printf("*********************************************************************\n");
	gotoxy(8,2);
		printf("*             Munich Hardware Monitor Testing Program               *\n");
	gotoxy(8,3);
		printf("*    Ver: 0.6    Date: 2006/07/17    By: MiTAC Shanghai ESBU/SW     *\n");
	gotoxy(8,4);
		printf("*********************************************************************\n");

	if((argc == 1) || !(strncmp(argv[1], "-?", 2)) || !(strncmp(argv[1], "-h", 2)) || !(strncmp(argv[1], "-H", 2)))
	{
	    usage();
	    return 0;
	}

	if (argc == 2)
	{
	    printf("Command error: Please inb_put your config file name!\n\n");
	    usage();
	    return 1;
	}
	else if (argc == 3)
	{
	    file = argv[2];
	    fp = fopen(file, "r");
	    if (fp)
	    {
	    	while (fgets(buf, sizeof(buf), fp))
	        {
		    for (i = 0; i<12; i++)
		    {
			if (strstr(buf, tests[i].name))
		    	{
			    vs = strstr(buf, "= ");
			    memset(tests[i].start, 0, 5);
			    sscanf(vs, "= %s %d, %d", tests[i].start, &tests[i].min, &tests[i].max);
			    tests[i].start[strlen(tests[i].start) - 1] = '\0';
//			    printf("%-25s= %-5s, %-9d, %d\n", tests[i].name, tests[i].start, tests[i].min, tests[i].max);
			}
		    }
	    	}
	    	fclose(fp);
	    }
	    else
	    {
	    	printf("%s: file open error!\n\n", file);
	    	return 1;
	    }
	}
	else
	{
	    printf("Command error\n\n");
	    usage();
            return 1;
	}

	ch = *argv[1];
	gotoxy(1,6);
	switch(ch)
	{
	    case 'c':
	    case 'C':
		printf("# Munich MB H/W Monitor Test Items\n");
		printf("# NO. Name        = Start, Value Min, Value Max\n");
		for (i = 0; i<12; i++)
		{
		    printf("%-3d%-15s= %-5s, %-9d, %d\n", i, tests[i].name, tests[i].start, tests[i].min, tests[i].max);
/*		    if (i == 15)
		    {
			printf("Please inb_put <Y> to continue: ");
			scanf("%s", &str);
		    }*/
		}
		break;
	    case 't':
	    case 'T':
		printf("Begin Test ......\n\n");
//		iopl(3);
		get_smbus_addr();
		ret = read_chip_id();
		if (ret)
		{
		    printf("\nHardware Monitor Chip error: wrong chip or bad chip\n");
		    printf("Hardware Monitor Chip ID: CompanyID = 0x%x,  DeviceID = 0x%x\n", chip_id.company_id, chip_id.device_id);
		    printf("1. Please check whether it is ADT7463\n");
		    printf("2. Please check whether it is broken\n");
//		    iopl(5);
		    return(ret);
		}
		hwmtest_start();
		ret = test_vol();
		if (ret)
		{
	            printf("..........Voltage test FAIL\n");
		    printf("\nMunich Hardware Monitor test FAIL\n");
//		    iopl(5);
		    return ret;
		}

		ret = test_fan();
	        if (ret)
		{
		    printf("..........CPU fan test FAIL\n");
		    printf("\nMunich Hardware Monitor test FAIL\n");
//		    iopl(5);
		    return ret;
		}
			
		ret = test_tem();
	        if (ret)
		{
		    printf("..........CPU temperature test FAIL\n");
		    printf("\nMunich Hardware Monitor test FAIL\n");
//		    iopl(5);
		    return ret;
		}

		if (ret == 0)
		    printf("\nMunich Hardware Monitor test PASS\n");
//		iopl(5);
		return ret;
	    
		default:
			usage();
			break;
	}
	return 0;
}

void outb_p(int value, int addr)
{
  asm{
	   mov	dx,addr
	   mov	al,value
	   out 	dx,al
     }
}

u16 inb_p(int addr)
{
   unsigned int value;
   asm{
           mov  dx, addr
           in   al, dx
           mov  value, al
      }
   return (value);
}


u32 pcibios_read_config_u32(u32 busnum, u32 devnum, u32 funnum, u32 regnum)
{
	unsigned long value=-1;
	unsigned long config;

//	iopl(3);
	config = (0x80000000|(busnum<<16)|(devnum<<11)|(funnum<<8)) + regnum;
	asm{
		.386
		mov  dx, 0cf8h
		mov  eax, config
		out  dx, eax
		mov  dx, 0cfch
		in   eax, dx
		mov  value, eax
		};

/*	outl(config, 0x0CF8);
	value = inl(0x0CFC);
        if(value == 0xFFFFFFFF)
		value = -1; */
	return value;
}

int probe_smbus (unsigned long pci_id)
{
	int i = 0, ret = 1;
 	while(smbus_controller_list[i].pci_id)
 	{ 
	    if ( smbus_controller_list[i].pci_id == pci_id)
	    {
		smbus_base_offset = smbus_controller_list[i].base_offset;
		smbus_value_bit = smbus_controller_list[i].value_bit;
		ret = 0;
		break;
	    }
	    i++;
 	}
 	return ret;
}

int get_smbus_addr (void)
{
	u32 pci_bus = 0, pci_dev = 0, pci_fn = 0, pci_id = 0;

	for(pci_bus=0; pci_bus<256; pci_bus++)
	    for(pci_dev=0; pci_dev<32; pci_dev++)
		for(pci_fn=0; pci_fn<8; pci_fn++)
		{
		    pci_id = pcibios_read_config_u32 (pci_bus, pci_dev, pci_fn, 0);
		    if (pci_id == 0xffffffff)
			continue;
		    if (probe_smbus(pci_id) != 0)
			continue;
		    else
		    {
//			printf("%x %x %x %x\n", pci_bus, pci_dev, pci_fn, smbus_base_offset);
	  		smbus_base_addr = pcibios_read_config_u32 (pci_bus, pci_dev, pci_fn, smbus_base_offset);
			smbus_base_addr &= 0xfffffffc;
//			printf("SMBus base address %8.8x\n", smbus_base_addr);
			return 0;
		    }
		}
	return 1;
}

int i2c_read_u8(int sa, u8 offset)
{
	outb_p(0, DATA0);
	outb_p(0, STS);

	outb_p(offset, CMD);
	outb_p(sa << 1, ADDR);
	outb_p(0x07, PRTCL);

	delay(500);

	return inb_p(DATA0);
}

void i2c_write_u8(int sa, u8 offset, u8 data)
{
	outb_p(0, DATA0);
	outb_p(0, STS);

	outb_p(offset, CMD);
	outb_p(sa << 1, ADDR);
	outb_p(data, DATA0);
	delay(100);
	outb_p(0x06, PRTCL);
	delay(100);
}

int read_chip_id (void)
{
	int result = 1;

	chip_id.device_id = i2c_read_u8(slaveadd, 0x3d);
	chip_id.company_id = i2c_read_u8(slaveadd, 0x3e);
//	printf("\ndevice_id = 0x%x,  company_id = 0x%x\n", chip_id.device_id, chip_id.company_id);

	if ((chip_id.device_id == 0x76) && (chip_id.company_id == 0x41))
	    result = 0;
	
	return (result);
}

void hwmtest_start(void)
{
	u8 value = i2c_read_u8(slaveadd, config_reg);
//	printf("0x40: 0x%x\n", value);
	i2c_write_u8(slaveadd, config_reg, (value | 0x1));
//	printf("0x40: 0x%x\n", i2c_read_u8(slaveadd, config_reg));
}

u32 ReadThermState(int cpunode)
{
    u32 busnum=0;
    u32 devnum=24;
    u32 funnum=3;
    u32 regnum=0xe4;
    u32 value=-1;

    devnum = devnum + cpunode;
    value = pcibios_read_config_u32(busnum, devnum, funnum, regnum);
    return value;
}