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

已于 2022-09-30 10:52:22 修改
阅读量3k 收藏 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
unraid 硬件监控芯片不显示问题 IT87
07-20 1021
ITE IT8613E Super IO Sensors 芯片。查看什么监控芯片 ，一路 YES。在看监控数据 ,温度、风扇转速已经显示。
linux主机风扇速度控制 解决记录 it8613E z490 GTN ubuntu 20.04
sss的博客
12-10 6260
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
AML8613芯片完整资料
12-30
AML8613芯片完整资料，支持RMVB、MP4、JPEG、PNG等硬解的码芯片。
UEFI开发历程2—基于SuperIO芯片的寄存器读写
qq_40945626的博客
11-21 5739
一、SuperIO介绍 目前市面上的主流SuperIO芯片有NCT、ITE等厂商的生产的芯片，本文主要针对IT8613E这款芯片的逻辑设备寄存器的读写进行介绍。 IT8613E主要用来连接外部低速设备，如键鼠、串口、Floppy等外设，可以监控PC硬件中的几个关键参数，包括电源电压、风扇速度和温度等。
UEFI开发历程4—串口调试功能的探索
qq_40945626的博客
12-17 3041
前言 现如今，由于BIOS代码在生成bin文件烧录进板子后，我们无法看见程序变量的变化，故而导致调试困难。我们都知道，大部分语言程序都有几种方法：日志打印、单步调试等方法。然而BIOS是一个开机过程中的用于初始化的系统，它不是一个软件，因此没有实体界面可以观察变量的改变。但由于主板上存在着串口，因此，串口调试对于BIOS来说是一种非常重要的调试手段。 串口调试实现方法 串口调试功能的打开有三种方式：IO配置寄存器并通过寄存器发送/接收数据的方式、Protocol配置寄存器并通过Protocol提供的读
ITE 8516 DataSheet
03-13
ITE 8516 DataSheet,EC embeded control spec
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 功能，可用于监控受监控对象
Linux内核编译选项-5
ELF Project
01-06 9426
Device Drivers  ---> 驱动程序 Generic Driver Options  --->驱动程序通用选项 (/sbin/hotplug) path to uevent helper [*] Maintain a devtmpfs filesystem to mount at /dev [*]   Automount devtmpfs at /dev, after
Linux-4.4-x86_64 内核配置选项简介
ye1223的博客
11-08 4567
Linux-4.4-x86_64 内核配置选项简介 作者：金步国 版权声明 本文作者是一位开源理念的坚定支持者，所以本文虽然不是软件，但是遵照开源的精神发布。 无担保：本文作者不保证作品内容准确无误，亦不承担任何由于使用此文档所导致的损失。 自由使用：任何人都可以自由的阅读/链接/打印此文档，无需任何附加条件。 名誉权：任何人都可以自由的转载/引用/再创作此文档，但必须保留作者署名并注...
IT8892E.pdf
06-16
PCI转接芯片IT8892E规格书，欢迎下载。
超级输入输出SuperIO
07-29
DOS下操作NCT5538D，用地址端口 0x2E,数据端口 0x2F，配置super IO，最后控制GPIO27。
SFF-8613.PDF
05-17
This specification was developed by the SFF Committee prior to it becoming the SFF TA (Technology Affiliate) TWG (Technical Working Group) of SNIA (Storage Networking Industry Association).
sio_wdt.rar_qnx_qnx 看门狗_qnx中的看门狗
09-14
在QNX下，与SuperIO的看门狗通信涉及识别正确的硬件地址，然后通过I/O端口进行读写操作。这个过程通常需要查阅芯片的数据手册以获取正确的寄存器映射和操作方法。 在提供的压缩包文件“sio_wdt”中，可能包含了一个...
IT8783 superio datesheet
10-25
IT8783E/F是一款由ITE（Integrated Tech Express）公司生产的环境控制低引脚数输入/输出（EC-LPCI/O）芯片，它主要应用于计算机主板上，用于提供对风扇速度、温度传感器、电源管理等硬件监控功能的支持。该芯片的...
计算机组成原理学习笔记（7.I/O系统）
super_song的博客
07-11 1013
7.I/O系统
万字深剖 Linux I/O 原理
热门推荐
qq_61500888的博客
11-03 1万+
带你一命通关 Linux IO 原理 十分钟手撕底层内涵
多路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、付费专栏及课程。

余额充值