IT8613E,Super I/O,逻辑设备，温度，电压寄存器数据更改，风扇，看门狗

已于 2022-09-30 10:52:22 修改
阅读量2.4k 收藏 7
点赞数 1
分类专栏： UEFI BIOS 文章标签： 其他
于 2022-09-28 17:54:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44686698/article/details/127094067
版权

IT8613E,温度，电压，风扇，逻辑设备号，寄存器数据更改看门狗代码备份。
命令行输入分以下几种情况：
①mySIO.efi输出当前的温度，电压，风扇转速
②mySIO.efi Xd "X"表示逻辑设备号，输出LDN=X时的寄存器列表
③mySIO.efi W X,这里执行看门狗功能，X表示秒数，代码设定1-9秒
④mySIO.efi Xd offset value,执行LDN=x时，地址offset寄存器的值设置为value
⑤mySIO.efi G X，风扇调速，X表示档位，有0,1,2三个档位，0表示停止，有个bug，执行完毕会输出一个风扇转速值，这个值是更改前的值。
⑥mySIO.efi GP10 I/O N/Y H/L，其中GP10表示GPIO10，可更改，第二个表示输入模式还是输出模式，Ｎ／Ｙ选择不反转/反转，H/L表示高/低电平.

mySIO.c。

#include <Uefi.h>
#include <stdio.h>
#include <Library/UefiLib.h>
#include <Library/UefiBootServicesTableLib.h>
#include <Library/IoLib.h>
#include <Library/ShellLib.h>
#include <Library/ShellCEntryLib.h>
#include <Library/BaseLib/BaseLibInternals.h>

CHAR16 ListHeader[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
UINT8 hex_List[]={0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};
UINT8 Multiple_function[] = {0x25,0x26,0x27,0x28,0x29};
UINT8 I_O_Registers[6] = {0xC8,0xC9,0xCA,0xCB,0xCC,0xCD};
UINT8 Polarity_Registers[6] = {0xB0,0xB1,0xB2,0xB3,0xB4,0x00};
UINT8 Pull_UP_Registers[6] = {0xB8,0x00,0xBA,0xBB,0xBC,0xBD};
UINT8 Simple_Enable_Register[6] = {0xC0,0xC1,0xC2,0xC3,0xC4,0x00};
UINT8 setone[8] = {0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};


//enter PNP mode
void EnterPnpMode(void)
{
	IoWrite8(0x2E,0x87);
	IoWrite8(0x2E,0x01);
	IoWrite8(0x2E,0x55);
	IoWrite8(0x2E,0x55);
}

void SelectLDN(UINT8 LDNnumber)
{
	IoWrite8(0x2E,0x07);
	IoWrite8(0x2F,LDNnumber);
}

void ExitPnpMode(void)
{
	IoWrite8(0x2E,0x02);
	IoWrite8(0x2F,0x02);
}

void ReadLdnRegister(void)
{
	unsigned int row,col;
	UINT8 addr = 0;
	unsigned int value[16][16];
	Print(L"-------------------------------------------------------\n");
	for(row = 0;row < 16;row++)
	{
		Print(L"%x0 ",row);
//		ShellPrintEx(0,row,L"%V%x0",row);
		for(col = 0;col < 16;col++)
		{
			IoWrite8(0x2E,addr);
			value[row][col] = IoRead8(0x2F);

			if(value[row][col] < 16)
			{
				Print(L" 0%x",value[row][col]);
			}
			else
			{
				Print(L" %x",value[row][col]);
			}
			addr++;
		}
		Print(L"\n");
	}
}

void WriteLdnRegister(UINT8 Offset,UINT8 Value)
{
	IoWrite8(0x2E,Offset);
	IoWrite8(0x2F,Value);
}

void PrintListHeader(void)
{
	UINT8 Index = 0;
	for(UINT8 Cow = 4;Cow < 48+4;Cow += 3)
	{
		ShellPrintEx(Cow,4,L"%V0");
		ShellPrintEx(Cow+1,4,L"%V%c",ListHeader[Index]);
		Index += 1;
	}
	Print(L"\n");
}

VOID SetGPIO(IN UINT8 GPIONumbr,IN UINT8 I_O_Mode,IN UINT8 InvertOrNot, IN UINT8 *H_L_Level)
{
	UINT16 BaseAddress;
	UINT16 addrMSB,addrLSB;
	//UINT8 ReadLevel;

	//multiple function
	IoWrite8(0x2E,Multiple_function[GPIONumbr/10-1]);
	IoWrite8(0x2F,IoRead8(0x2F) | setone[GPIONumbr%10]);//对应位置1

	// IN  OR OUT   输出时是否有反转
	if (I_O_Mode == 0)//out
	{
		IoWrite8(0x2E,Polarity_Registers[GPIONumbr/10-1]);
		if (InvertOrNot == 1)//fan zhuan
		{
			IoWrite8(0x2F,IoRead8(0x2F) | setone[GPIONumbr%10]);//对应位置1
		}
		else
		{
			IoWrite8(0x2F,IoRead8(0x2F) | hex_List[0]);//对应位置0
		}
	}


	//排除G2X,G53上拉
	if(GPIONumbr/10 != 2 || (GPIONumbr/10 != 5 && GPIONumbr%10 != 3))
	{
		IoWrite8(0x2E,Pull_UP_Registers[GPIONumbr/10-1]);
		IoWrite8(0x2F,IoRead8(0x2F) | setone[GPIONumbr%10]);//对应位置1
	}
	//GP6X
	if(GPIONumbr/10 != 6)
	{
		IoWrite8(0x2E,Simple_Enable_Register[GPIONumbr/10 -1]);
		IoWrite8(0x2F,IoRead8(0x2F) | setone[GPIONumbr%10]);
	}
	
	IoWrite8(0X2E,0x62);
	addrMSB = IoRead8(0x2F);

	IoWrite8(0x2E,0x63);
	addrLSB = IoRead8(0x2F);

	BaseAddress = (addrMSB << 8) | addrLSB;


	if (I_O_Mode == 0)
	{
		IoWrite8(0x2E,I_O_Registers[GPIONumbr/10-1]);
		IoWrite8(0x2F,IoRead8(0x2F)|setone[GPIONumbr%10]);

		if (*H_L_Level == 1)
		{
			//IoWrite16(0x2E,BaseAddress + (GPIONumbr/10 - 1));
			IoWrite8(BaseAddress + (GPIONumbr/10 - 1),IoRead8(BaseAddress + (GPIONumbr/10 - 1)) | setone[GPIONumbr%10]);
		}
		else if(*H_L_Level == 0)
		{
			//IoWrite16(0x2E,BaseAddress + (GPIONumbr/10 - 1));
			IoWrite8(BaseAddress + (GPIONumbr/10 - 1),IoRead8(BaseAddress + (GPIONumbr/10 - 1))&(0xff - setone[GPIONumbr%10]));
		}
	}
	else if(I_O_Mode == 1)
	{
		//IoWrite8(0x2E,I_O_Registers[GPIONumbr/10-1]);
		IoWrite8(0x2F,IoRead8(I_O_Registers[GPIONumbr/10-1]) & (0xff - setone[GPIONumbr%10]));
	}

}

unsigned int GetEcBasedAddress()//temp
{
	unsigned int addrMSB,addrLSB;
	unsigned int baseaddr;

	SelectLDN(hex_List[4]);

	IoWrite8(0x2E,0x30);
	IoWrite8(0x2F,0x01);

	IoWrite8(0x2E,0x60);
	addrMSB = IoRead8(0x2F);

	IoWrite8(0x2E,0x61);
	addrLSB = IoRead8(0x2F);	



	baseaddr = (addrMSB << 8 & 0xff00) | addrLSB;

	return baseaddr;
}

unsigned int ReadEcSpace(UINT8 index)
{
	unsigned int data,addr;
	unsigned int Index_Port,Data_Port;

	addr = GetEcBasedAddress();
	//Print(L"GetEcBasedAddress  Temp:%x\n",addr); 
	Index_Port = addr + 5;
	Data_Port = addr + 6;

	//bank0
	IoWrite8(0x2E,0x06);
	IoWrite8(0x2F,0x80);
	

	IoWrite8(Index_Port,index);
	data = IoRead8(Data_Port);

	return data;
}

void ReadTemp()
{
	unsigned int temp0,temp1;

	

	temp0 = ReadEcSpace(0x29);
	temp1 = ReadEcSpace(0x2A);

	Print(L"temp0 CPU: %d\n",temp0);
	Print(L"temp1: %d\n",temp1);

}

void ReadFan()
{
	unsigned  int fan;
	unsigned int fanMSB,fanLSB;
	
	fanMSB = ReadEcSpace(0x19);
	fanLSB = ReadEcSpace(0x0E);

	fan = (fanMSB << 8 & 0xff00)|fanLSB;
	Print(L"fanMSB:  %x or  %d \n",fanMSB,fanMSB);
	Print(L"fanLSB:   %x  or  %d\n",fanLSB,fanLSB);
	Print(L"fan:%x\n",fan);
	Print(L"fan: %d\n",(135*10000)/(fan*2));
}

void FanGear( UINT8 gear)
{
	unsigned int addr;

	//Print(L"enter fan gear\n");

	addr = GetEcBasedAddress();

	//enable
	IoWrite8(addr+0x05,0x13);
	IoWrite8(addr+0x06,0x01 << 5);

	//Print(L"enter fan gear enable\n");

	//select software Operation
	IoWrite8(addr+0x05,0x16);
	IoWrite8(addr+0x06,0x00);

	//Print(L"enter fan gear software\n");

	//polarity
	IoWrite8(addr+0x05,0x14);
	IoWrite8(addr+0x06,0x01 << 7);

	//Print(L"enter fan gear polarity\n");

	//Print(L"%x\n",gear);

	//gear PWM 0-255
	if (gear == hex_List[0])
	{
		IoWrite8(addr+0x05,0x6B);
		IoWrite8(addr+0x06,0x00);
		Print(L"enter fan gear PWM 0\n");
	}
	else if(gear == hex_List[1])
	{
		IoWrite8(addr+0x05,0x6B);
		IoWrite8(addr+0x06,0x80);
		Print(L"enter fan gear PWM 128\n");
	}
	else if(gear == hex_List[2])
	{
		IoWrite8(addr+0x05,0x6B);
		IoWrite8(addr+0x06,0xFF);
		Print(L"enter fan gear PWM 255\n");
	}

}

void ReadVoltage()
{
	unsigned int voltage0,voltage1,voltage2;
	unsigned int voltage01,voltage02;
	unsigned int voltage11,voltage12;
	unsigned int voltage21,voltage22;

	voltage0 = ReadEcSpace(0x20);
	voltage1 = ReadEcSpace(0x21);
	voltage2 =ReadEcSpace(0x22);

	voltage01 = voltage0*109/10000;
	voltage02 = voltage0*109%10000;

	voltage11 = voltage1*109/10000;
	voltage12 = voltage1*109%10000;

	voltage21 = voltage2*109/10000;
	voltage22 = voltage2*109%10000;

	Print(L"voltage0:%d.%d V\n",voltage01,voltage02);
	Print(L"voltage1:%d.%d V\n",voltage11,voltage12);
	Print(L"voltage2:%d.%d V\n",voltage21,voltage22);


}

void WatchDog(UINT8 sec)
{
	EnterPnpMode();
	Print(L"0x07");
	SelectLDN(0x07);
	//enable wdt IRQ
	//IoWrite8(0x2E,0xF1);
	//IoWrite8(0x2F,IoRead8(0x2F)|(0x01<<2));

	//select clock
	//IoWrite8(0x2E,0x23);
//	IoWrite8(0x2F,IoRead8(0x2F)|(0x01<<4));
//	Print(L"clock\n");
	

	IoWrite8(0x2E,0x72);
	//IoWrite8(0x2F,0x90);PWRGD
	IoWrite8(0x2F,0xD0);//KST
	//Print(L"configuration\n");

	//Timer control
	IoWrite8(0x2E,0x71);
	IoWrite8(0x2F,0x08);//5s
	//Print(L"Timer control\n");

	//73  LSB
	IoWrite8(0x2E,0x73);
	IoWrite8(0x2F,hex_List[sec]);
	//Print(L"LSB\n");

	ExitPnpMode();
}

INTN ShellAppMain(IN UINTN Argc,IN CHAR16 **Argv)
{
	UINT8 LDNnumber;
	UINT8 Offset;
 	UINT8 Value;
 	UINT8 GPIONumbr;
 	UINT8 I_O_Mode;//1为in,0为out
 	UINT8 InvertOrNot;
 	UINT8 H_L_Level;
 	UINT8 gear;//fan
 	UINT8 sec;

	switch(Argc)
	{
		case 1 :		
			//gST->ConOut->ClearScreen(gST->ConOut);
			EnterPnpMode();
			ReadTemp();
			ReadVoltage();
			ReadFan();
			ExitPnpMode();
			break;
		case 2 :
			if(*(Argv[1]+1) == 'D' || *(Argv[1]+1) == 'd')
			{
				LDNnumber = hex_List[InternalHexCharToUintn(*Argv[1])];
				EnterPnpMode();
				SelectLDN(LDNnumber);
				gST->ConOut->ClearScreen(gST->ConOut);
				PrintListHeader();
				ReadLdnRegister();
				ExitPnpMode();
			}
			else
			{
				Print(L"Please enter the correct parameter format！\n");
			}
			
			break;
		case 3:	
			if (*(Argv[1]) == 'g' || *(Argv[1]) == 'G')
			{
				EnterPnpMode();
				ReadTemp();//select LDN ,EC
				gear = (UINT8)InternalHexCharToUintn(*Argv[2]);
				//Print(L"main %x\n",gear);	
				FanGear(gear);
				ReadVoltage();
				ReadFan();
				ExitPnpMode();
			}
			else if(*(Argv[1]) == 'W' || *(Argv[1]) == 'w')
			{
				Print(L"wdt\n");
				sec = (UINT8)InternalHexCharToUintn(*Argv[2]);
				WatchDog(sec);
			}
			
			break;

		case 4 :
			if(*(Argv[1]+1) == 'D' || *(Argv[1]+1) == 'd')
			{
				LDNnumber = hex_List[InternalHexCharToUintn(*Argv[1])];
				Offset = hex_List[InternalHexCharToUintn(*Argv[2])]*16 + hex_List[InternalHexCharToUintn(*((Argv[2])+1))];
   				//The value to be written in
    			Value = hex_List[InternalHexCharToUintn(*Argv[3])]*16 + hex_List[InternalHexCharToUintn(*((Argv[3])+1))];
				EnterPnpMode();
				SelectLDN(LDNnumber);
				WriteLdnRegister(Offset,Value);
				gST->ConOut->ClearScreen(gST->ConOut);
				PrintListHeader();
				ReadLdnRegister();
				ExitPnpMode();
			}
			else
			{
				Print(L"Please enter the correct parameter format！\n");
			}
			break;

		case 5 :
			if(*Argv[1] == 'G' || *Argv[1] == 'g')
			{
				GPIONumbr = hex_List[InternalHexCharToUintn(*(Argv[1]+2))*10  + InternalHexCharToUintn(*(Argv[1]+3))];

				if (*Argv[2] == 'I' || *Argv[2] == 'i')
				{
					I_O_Mode = 1;
				}
				else if(*Argv[2] == 'O' || *Argv[2] == 'o')
				{
					I_O_Mode = 0;
				}

				if (*Argv[3] == 'Y' || *Argv[3] == 'y')
				{
					InvertOrNot = 1;
				}
				else if(*Argv[3] == 'N' || *Argv[3] == 'n')
				{
					InvertOrNot = 0;
				}

				if (*Argv[4] == 'H' || *Argv[4] == 'h')
				{
					H_L_Level = 1;
				}
				else if(*Argv[4] == 'L' || *Argv[4] == 'l')
				{
					H_L_Level = 0;
				}

				EnterPnpMode();
				SelectLDN(0x07);
				SetGPIO(GPIONumbr,I_O_Mode,InvertOrNot,&H_L_Level);
				gST->ConOut->ClearScreen(gST->ConOut);
				PrintListHeader();
				ReadLdnRegister();
				ExitPnpMode();

			}
			else
			{
				Print(L"Please enter the correct parameter format！\n");
			}
			
			break;
	}

	return 0;

}

mySIO.inf。

// An highlighted block
[Defines]
	INF_VERSION   = 0x00010005
	BASE_NAME     = mySIO
	FILE_GUID     = ED123456-1345-7890-AAAA-123321ABCABC
	MODULE_TYPE   = UEFI_APPLICATION
	VERSION_STRING = 1.0
	ENTRY_POINT    = ShellCEntryLib

[Sources]
	mySIO.c

[Packages]
	MdePkg/MdePkg.dec
	ShellPkg/ShellPkg.dec
	StdLib/StdLib.dec

[LibraryClasses]
	ShellCEntryLib
	UefiBootServicesTableLib
	UefiLib
	IoLib
	ShellLib
疯狂麦子君
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
SuperIO芯片IT8786E数据手册及上电指导下载
09-07
SuperIO芯片IT8786E数据手册及上电指导下载 IT8786E-Environment Control- Low Pin Count Input / Output(EC - LPC I/O) Preliminary Specification V0.7.2 IT8786E/HX BIOS initial guide IoWrite8(0x2E, 0x87) IoWrite8(0x2E, 0x01) IoWrite8(0x2E, 0x55) IoWrite8(0x2E, 0x55) 相关博文：https://blog.csdn.net/kingpower2018/article/details/132738950
IT8892E.pdf
06-16
PCI转接芯片IT8892E规格书，欢迎下载。
unraid 硬件监控芯片不显示问题 IT87
最新发布
07-20 650
ITE IT8613E Super IO Sensors 芯片。查看什么监控芯片 ，一路 YES。在看监控数据 ,温度、风扇转速已经显示。
AML8613芯片完整资料
12-30
AML8613芯片完整资料，支持RMVB、MP4、JPEG、PNG等硬解的码芯片。
linux主机风扇速度控制 解决记录 it8613E z490 GTN ubuntu 20.04
sss的博客
12-10 5672
OS: ubuntu 20.04、主板：biostar z490 GTN、风扇IO芯片：it8613E lmsensors 可以获取 温度传感器 与 风扇的转速，也可以自定义调整风扇速度。 1、运行sensors-detect显示it8613E无驱动（如图） it8613E不是一个新的芯片，所以没有驱动linux很奇怪。 github上找到了https://github.com/a1wong/it87 2、按照readme安装it87报错 Device or resource busy dm
UEFI开发历程2—基于SuperIO芯片的寄存器读写
qq_40945626的博客
11-21 4950
一、SuperIO介绍 目前市面上的主流SuperIO芯片有NCT、ITE等厂商的生产的芯片，本文主要针对IT8613E这款芯片的逻辑设备寄存器的读写进行介绍。 IT8613E主要用来连接外部低速设备，如键鼠、串口、Floppy等外设，可以监控PC硬件中的几个关键参数，包括电源电压、风扇速度和温度等。
UEFI开发历程4—串口调试功能的探索
qq_40945626的博客
12-17 2534
前言 现如今，由于BIOS代码在生成bin文件烧录进板子后，我们无法看见程序变量的变化，故而导致调试困难。我们都知道，大部分语言程序都有几种方法：日志打印、单步调试等方法。然而BIOS是一个开机过程中的用于初始化的系统，它不是一个软件，因此没有实体界面可以观察变量的改变。但由于主板上存在着串口，因此，串口调试对于BIOS来说是一种非常重要的调试手段。 串口调试实现方法 串口调试功能的打开有三种方式：IO配置寄存器并通过寄存器发送/接收数据的方式、Protocol配置寄存器并通过Protocol提供的读
IT8512E_datasheet
10-23
ITE8512E芯片手册，ITE的芯片在笔记本主板上经常出现，但是芯片资料不多，希望能给主板维修人员带来一定的参考价值。
UEFI学习（四）-SuperIo的访问
weixin_42951246的博客
11-12 1万+
UEFI学习（四）-SuperIo的访问一、什么是Super I/O？二、我们要用SuperIo实现什么三、NCT5581D的访问机制 一、什么是Super I/O？ Super I/O 芯片也叫 I/O 芯片。在 486 以上档次的主板上都有 I/O控制电路。因为在南桥这样的高速设备和串行、并行接口、软盘驱动器及键盘鼠标等大量低速设备之间必定存在资源的不匹配，而需要经过转换和管理。而 Super I/O 芯片则完成了该功能。 通常在硬件监控芯片硬件监控芯片中会整合超级 I/O 功能，可用于监控受监控对象
ITE 8516 DataSheet
03-13
ITE 8516 DataSheet,EC embeded control spec
超级输入输出SuperIO
07-29
DOS下操作NCT5538D，用地址端口 0x2E,数据端口 0x2F，配置super IO，最后控制GPIO27。
NCT6102D / NCT6106D Nuvoton LPC I/O
11-23
The NCT6102D / NCT6106D is a member of Nuvoton‟s Super I/O product line. The NCT6102D / NCT6106D monitors several critical parameters in PC hardware, including power supply voltages, fan speeds, and ...
工业电子中的SMSC工业级超级I/O控制芯片
12-09
科汇盈丰 (Memec Insight) 分部今天推介SMSC公司一系列引脚兼容的系统控制中心芯片(controller hub chip) SCH3112、SCH3114 和 SCH3116，这些输出/输出(I/O)控制器不仅加强了设计的灵活性，还能让系统设计工程师在...
FanCpuInfo.rar_FanCpuInfo _HDD temperature_SuperIO_VC superio it
07-14
SuperIO对应CPU和系统温度的主板风扇转速读写控制程序。
Linux内核配置选项简介
热门推荐
whatday的专栏
03-12 1万+
目录 General setup常规设置 Enable loadable module support可加载模块支持 Enable the block layer块设备支持 Processor type and features中央处理器(CPU)类型及特性 Power management and ACPI options电源管理和ACPI选项 Bus options (PCI et...
Linux-4.4-x86_64 内核配置选项简介
轮子工厂
10-15 4842
Linux-4.4-x86_64 内核配置选项简介 作者：金步国 64-bit kernel CONFIG_64BIT 编译64位内核.本文仅讲述x86_64(AMD64)平台的内核编译,所以这个是必选项. General setup 常规设置 Cross-compiler tool prefix CONFIG_CROSS_COMPILE 交叉编译工具前缀(比如"arm-linux...
看门狗测试软件
03-06
2.为了让SUPERIO 必须在这个周期内对这个计时器进行清零处理，让看门狗定时器重新计数，防止看门狗产生复 位，测试软件有个自动重置按扭，勾选上了代表不间断的发出喂狗信号，程序或系统运行正常时，SUPERIO 不会 ...
多路I/O复用技术是什么
06-08
多路I/O复用技术是一种高效的I/O处理方式，它可以同时监听多个I/O事件，并且在有事件发生时及时通知应用程序。常见的多路I/O复用技术包括select、poll和epoll等。 在使用多路I/O复用技术时，应用程序只需要调用一次select、poll或epoll等函数来监听多个I/O事件，而不需要为每个I/O操作创建一个线程或进程来处理。当有事件发生时，这些函数会返回一个可读、可写或异常事件的文件描述符集合，应用程序只需要遍历描述符集合，根据每个文件描述符的状态进行相应的I/O操作即可。这种方式可以大大减少系统调用次数，提高程序的并发性能。 多路I/O复用技术不仅可以用于网络编程中的socket通信，还可以用于文件I/O、管道、信号等各种I/O操作。不同的多路I/O复用技术在实现方式和性能上有所差异，开发人员可以根据具体的应用场景选择合适的技术。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值