SNB and SKL Idle States API code

gistfile1.txt

---
corefreq-cli.c
---

REASON_CODE SysInfoPerfMon(Window *win, CUINT width, CELL_FUNC OutFunc)
{
	REASON_INIT(reason);
	char *item;
  if ((item = calloc(1 + width, 1)) == NULL)
  {
	REASON_SET(reason, RC_MEM_ERR);
  }
  else
  {
	ATTRIBUTE *attrib[4] = {
		RSC(SYSINFO_PERFMON_COND0).ATTR(),
		RSC(SYSINFO_PERFMON_COND1).ATTR(),
		RSC(SYSINFO_PERFMON_COND2).ATTR(),
		RSC(SYSINFO_PERFMON_COND3).ATTR()
	};
	int bix;
	char str[8];
/* Section Mark */
	PUT(SCANKEY_NULL, attrib[0], width, 2,
		"%s%.*sPM       [%3d]", RSC(VERSION).CODE(),
		width - 17 - RSZ(VERSION), hSpace, Shm->Proc.PM_version);

	PUT(SCANKEY_NULL, attrib[0], width, 2,
		"%s:%.*s%s%.*s%s",
		RSC(COUNTERS).CODE(),10, hSpace, RSC(GENERAL_CTRS).CODE(),
		width - 61, hSpace, RSC(FIXED_CTRS).CODE());

    if (OutFunc == NULL) {
	PUT(SCANKEY_NULL, attrib[0], width, 1,
		"%.*s%3u x%3u bits%.*s%3u x%3u bits",
		19, hSpace,	Shm->Proc.Features.PerfMon.EAX.MonCtrs,
				Shm->Proc.Features.PerfMon.EAX.MonWidth,
		11, hSpace,	Shm->Proc.Features.PerfMon.EDX.FixCtrs,
				Shm->Proc.Features.PerfMon.EDX.FixWidth);
    } else {
	PUT(SCANKEY_NULL, attrib[0], width, 0,
		"%.*s%3u x%3u bits%.*s%3u x%3u bits",
		19, hSpace,	Shm->Proc.Features.PerfMon.EAX.MonCtrs,
				Shm->Proc.Features.PerfMon.EAX.MonWidth,
		5, hSpace,	Shm->Proc.Features.PerfMon.EDX.FixCtrs,
				Shm->Proc.Features.PerfMon.EDX.FixWidth);
    }
	bix = Shm->Proc.Technology.C1E == 1;
	GridCall(PUT(BOXKEY_C1E, attrib[bix], width, 2,
			"%s%.*sC1E       <%3s>", RSC(PERF_MON_C1E).CODE(),
			width - 18 - RSZ(PERF_MON_C1E), hSpace, enabled(bix)),
		C1E_Update);

    if (Shm->Proc.Features.Info.Vendor.CRC == CRC_INTEL)
    {
	bix = Shm->Proc.Technology.C1A == 1;
	GridCall(PUT(BOXKEY_C1A, attrib[bix], width, 2,
			"%s%.*sC1A       <%3s>", RSC(PERF_MON_C1A).CODE(),
			width - 18 - RSZ(PERF_MON_C1A), hSpace, enabled(bix)),
		C1A_Update);

	bix = Shm->Proc.Technology.C3A == 1;
	GridCall(PUT(BOXKEY_C3A, attrib[bix], width, 2,
			"%s%.*sC3A       <%3s>", RSC(PERF_MON_C3A).CODE(),
			width - 18 - RSZ(PERF_MON_C3A), hSpace, enabled(bix)),
		C3A_Update);

	bix = Shm->Proc.Technology.C1U == 1;
	GridCall(PUT(BOXKEY_C1U, attrib[bix], width, 2,
			"%s%.*sC1U       <%3s>", RSC(PERF_MON_C1U).CODE(),
			width - 18 - RSZ(PERF_MON_C1U), hSpace, enabled(bix)),
		C1U_Update);

	bix = Shm->Proc.Technology.C3U == 1;
	GridCall(PUT(BOXKEY_C3U, attrib[bix], width, 2,
			"%s%.*sC3U       <%3s>", RSC(PERF_MON_C3U).CODE(),
			width - 18 - RSZ(PERF_MON_C3U), hSpace, enabled(bix)),
		C3U_Update);
    }
    if (Shm->Proc.Features.Info.Vendor.CRC == CRC_AMD)
    {
	bix = Shm->Proc.Technology.CC6 == 1;
	GridCall(PUT(BOXKEY_CC6, attrib[bix], width, 2,
			"%s%.*sCC6       <%3s>", RSC(PERF_MON_CC6).CODE(),
			width - 18 - RSZ(PERF_MON_CC6), hSpace, enabled(bix)),
		CC6_Update);

	bix = Shm->Proc.Technology.PC6 == 1;
	GridCall(PUT(BOXKEY_PC6, attrib[bix], width, 2,
			"%s%.*sPC6       <%3s>", RSC(PERF_MON_PC6).CODE(),
			width - 18 - RSZ(PERF_MON_PC6), hSpace, enabled(bix)),
		PC6_Update);
    }
	bix = (Shm->Proc.Features.AdvPower.EDX.FID == 1)
	   || (Shm->Proc.Features.AdvPower.EDX.HwPstate == 1);
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*sFID       [%3s]", RSC(PERF_MON_FID).CODE(),
		width - 18 - RSZ(PERF_MON_FID), hSpace, enabled(bix));

	bix = (Shm->Proc.Features.AdvPower.EDX.VID == 1)
	   || (Shm->Proc.Features.AdvPower.EDX.HwPstate == 1);
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*sVID       [%3s]", RSC(PERF_MON_VID).CODE(),
		width - 18 - RSZ(PERF_MON_VID), hSpace, enabled(bix));

	bix = (Shm->Proc.Features.Power.ECX.HCF_Cap == 1)
	   || ((Shm->Proc.Features.Info.Vendor.CRC == CRC_AMD)
		&& (Shm->Proc.Features.AdvPower.EDX.EffFrqRO == 1));
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*sMPERF/APERF       [%3s]", RSC(PERF_MON_HWCF).CODE(),
		width - 26 - RSZ(PERF_MON_HWCF), hSpace, enabled(bix));

	bix = (Shm->Proc.Features.Power.EAX.HWP_Reg == 1)
	   || (Shm->Proc.Features.AdvPower.EDX.HwPstate == 1);
    if (bix)
    {
	CPU_STRUCT *SProc = &Shm->Cpu[Shm->Proc.Service.Core];
	struct FLIP_FLOP *CFlop = &SProc->FlipFlop[
				!Shm->Cpu[Shm->Proc.Service.Core].Toggle
	];
	ATTRIBUTE *HWP_Cap_Attr[2] = {
		RSC(SYSINFO_PERFMON_HWP_CAP_COND0).ATTR(),
		RSC(SYSINFO_PERFMON_HWP_CAP_COND1).ATTR()
	};
	bix = Shm->Proc.Features.HWP_Enable == 1;

	GridCall(PUT(BOXKEY_HWP, attrib[bix], width, 2,
			"%s%.*sHWP       <%3s>", RSC(PERF_MON_HWP).CODE(),
			width - 18 - RSZ(PERF_MON_HWP), hSpace, enabled(bix)),
		HWP_Update);

	PUT(SCANKEY_NULL, RSC(SYSINFO_PROC_COND0).ATTR(), width, 3,
		"%s""%.*s(MHz)%.*s""%s", RSC(CAPABILITIES).CODE(),
		21 - 3*(OutFunc == NULL) - RSZ(CAPABILITIES), hSpace,
		22, hSpace,
		RSC(RATIO).CODE());

	GridCall(PrintRatioFreq(win, CFlop,
			1, (char*) RSC(LOWEST).CODE(),
			&SProc->PowerThermal.HWP.Capabilities.Lowest,
			0, SCANKEY_NULL, width, OutFunc,
			HWP_Cap_Attr[bix]),
		Refresh_HWP_Cap_Freq,
			&SProc->PowerThermal.HWP.Capabilities.Lowest);

	GridCall(PrintRatioFreq(win, CFlop,
			1, (char*) RSC(EFFICIENT).CODE(),
			&SProc->PowerThermal.HWP.Capabilities.Most_Efficient,
			0, SCANKEY_NULL, width, OutFunc,
			HWP_Cap_Attr[bix]),
		Refresh_HWP_Cap_Freq,
			&SProc->PowerThermal.HWP.Capabilities.Most_Efficient);

	GridCall(PrintRatioFreq(win, CFlop,
			1, (char*) RSC(GUARANTEED).CODE(),
			&SProc->PowerThermal.HWP.Capabilities.Guaranteed,
			0, SCANKEY_NULL, width, OutFunc,
			HWP_Cap_Attr[bix]),
		Refresh_HWP_Cap_Freq,
			&SProc->PowerThermal.HWP.Capabilities.Guaranteed);

	GridCall(PrintRatioFreq(win, CFlop,
			1, (char*) RSC(HIGHEST).CODE(),
			&SProc->PowerThermal.HWP.Capabilities.Highest,
			0, SCANKEY_NULL, width, OutFunc,
			HWP_Cap_Attr[bix]),
		Refresh_HWP_Cap_Freq,
			&SProc->PowerThermal.HWP.Capabilities.Highest);
    } else {
	bix = Shm->Proc.Features.HWP_Enable == 1;
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*sHWP       [%3s]", RSC(PERF_MON_HWP).CODE(),
		width - 18 - RSZ(PERF_MON_HWP), hSpace, enabled(bix));
    }

	bix = Shm->Proc.Features.HDC_Enable == 1;
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*sHDC       [%3s]", RSC(PERF_MON_HDC).CODE(),
		width - 18 - RSZ(PERF_MON_HDC), hSpace, enabled(bix));

	PUT(SCANKEY_NULL, attrib[0], width, 2,
		"%s", RSC(PERF_MON_PKG_CSTATE).CODE());

	bix = Shm->Cpu[Shm->Proc.Service.Core].Query.CfgLock == 0 ? 3 : 0;
	PUT(SCANKEY_NULL, attrib[bix], width, 3,
		"%s%.*sCONFIG   [%7s]", RSC(PERF_MON_CFG_CTRL).CODE(),
		width - (OutFunc == NULL ? 24 : 22)
		- RSZ(PERF_MON_CFG_CTRL), hSpace,
		!Shm->Cpu[Shm->Proc.Service.Core].Query.CfgLock ?
			RSC(UNLOCK).CODE() : RSC(LOCK).CODE());

	if (!Shm->Cpu[Shm->Proc.Service.Core].Query.CfgLock) {
	    GridCall(PUT(BOXKEY_PKGCST, attrib[0], width, 3,
			"%s%.*sLIMIT   <%7d>", RSC(PERF_MON_LOW_CSTATE).CODE(),
			width - (OutFunc == NULL ? 23 : 21)
			- RSZ(PERF_MON_LOW_CSTATE), hSpace,
			Shm->Cpu[Shm->Proc.Service.Core].Query.CStateLimit),
		CStateLimit_Update);

		bix = Shm->Cpu[Shm->Proc.Service.Core].Query.IORedir == 1 ? 3:2;
	    GridCall(PUT(BOXKEY_IOMWAIT, attrib[bix], width, 3,
			"%s%.*sIOMWAIT   <%7s>", RSC(PERF_MON_IOMWAIT).CODE(),
			width - (OutFunc == NULL ? 25 : 23)
			- RSZ(PERF_MON_IOMWAIT), hSpace,
			Shm->Cpu[Shm->Proc.Service.Core].Query.IORedir ?
				RSC(ENABLE).CODE() : RSC(DISABLE).CODE()),
		IOMWAIT_Update);

	    GridCall(PUT(BOXKEY_IORCST, attrib[0], width, 3,
			"%s%.*sRANGE   <%7d>", RSC(PERF_MON_MAX_CSTATE).CODE(),
			width - (OutFunc == NULL ? 23 : 21)
			- RSZ(PERF_MON_MAX_CSTATE), hSpace,
			Shm->Cpu[Shm->Proc.Service.Core].Query.CStateInclude),
		CStateRange_Update);
	} else {
		PUT(SCANKEY_NULL, attrib[0], width, 3,
			"%s%.*sLIMIT   [%7d]", RSC(PERF_MON_LOW_CSTATE).CODE(),
			width - (OutFunc == NULL ? 23 : 21)
			- RSZ(PERF_MON_LOW_CSTATE), hSpace,
			Shm->Cpu[Shm->Proc.Service.Core].Query.CStateLimit);

		PUT(SCANKEY_NULL, attrib[0], width, 3,
			"%s%.*sIOMWAIT   [%7s]", RSC(PERF_MON_IOMWAIT).CODE(),
			width - (OutFunc == NULL ? 25 : 23)
			- RSZ(PERF_MON_IOMWAIT), hSpace,
			Shm->Cpu[Shm->Proc.Service.Core].Query.IORedir ?
				RSC(ENABLE).CODE() : RSC(DISABLE).CODE());

		PUT(SCANKEY_NULL, attrib[0], width, 3,
			"%s%.*sRANGE   [%7d]", RSC(PERF_MON_MAX_CSTATE).CODE(),
			width - (OutFunc == NULL ? 23 : 21)
			- RSZ(PERF_MON_MAX_CSTATE), hSpace,
			Shm->Cpu[Shm->Proc.Service.Core].Query.CStateInclude);
	}
    for (bix = 1; bix < Shm->SysGate.IdleDriver.stateCount; bix++)
    {
	sprintf(str, "%-6.*s", 6, Shm->SysGate.IdleDriver.State[bix].Name);
	strcat(item, str);
    }
	PUT(SCANKEY_NULL, attrib[0], width, 2,
		"%s:%.*s%s",
		RSC(PERF_MON_MWAIT_CTRS).CODE(), 04, hSpace, item);

	PUT(SCANKEY_NULL, attrib[0], width, (OutFunc == NULL) ? 1 : 0,
		"%.*s%2d    %2d    %2d    %2d    %2d    %2d    %2d    %2d",
		19, hSpace,
		Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT0,
		Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT1,
		Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT2,
		Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT3,
		Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT4,
		Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT5,
		Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT6,
		Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT7);

	bix = Shm->Proc.Features.PerfMon.EBX.CoreCycles == 0 ? 2 : 0;
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*s[%7s]", RSC(PERF_MON_CORE_CYCLE).CODE(),
		width - 12 - RSZ(PERF_MON_CORE_CYCLE), hSpace, powered(bix));

	bix = Shm->Proc.Features.PerfMon.EBX.InstrRetired == 0 ? 2 : 0;
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*s[%7s]", RSC(PERF_MON_INST_RET).CODE(),
		width - 12 - RSZ(PERF_MON_INST_RET), hSpace, powered(bix));

	bix = Shm->Proc.Features.PerfMon.EBX.RefCycles == 0 ? 2 : 0;
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*s[%7s]", RSC(PERF_MON_REF_CYCLE).CODE(),
		width - 12 - RSZ(PERF_MON_REF_CYCLE), hSpace, powered(bix));

	bix = Shm->Proc.Features.PerfMon.EBX.LLC_Ref == 0 ? 2 : 0;
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*s[%7s]", RSC(PERF_MON_REF_LLC).CODE(),
		width - 12 - RSZ(PERF_MON_REF_LLC), hSpace, powered(bix));

	bix = Shm->Proc.Features.PerfMon.EBX.LLC_Misses == 0 ? 2 : 0;
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*s[%7s]", RSC(PERF_MON_MISS_LLC).CODE(),
		width - 12 - RSZ(PERF_MON_MISS_LLC), hSpace, powered(bix));

	bix = Shm->Proc.Features.PerfMon.EBX.BranchRetired == 0 ? 2 : 0;
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*s[%7s]", RSC(PERF_MON_BRANCH_RET).CODE(),
		width - 12 - RSZ(PERF_MON_BRANCH_RET), hSpace, powered(bix));

	bix = Shm->Proc.Features.PerfMon.EBX.BranchMispred == 0 ? 2 : 0;
	PUT(SCANKEY_NULL, attrib[bix], width, 2,
		"%s%.*s[%7s]", RSC(PERF_MON_BRANCH_MIS).CODE(),
		width - 12 - RSZ(PERF_MON_BRANCH_MIS), hSpace, powered(bix));

	free(item);
  }
	return(reason);
}


REASON_CODE SysInfoKernel(Window *win, CUINT width, CELL_FUNC OutFunc)
{
	REASON_INIT(reason);
	size_t	len = KMAX(1 + width,
			1 + 16 + (8 * Shm->SysGate.IdleDriver.stateCount));
	char	*item = NULL, *str = NULL;
	int	idx = 0;

  if ((item = malloc(len)) == NULL) {
	REASON_SET(reason, RC_MEM_ERR);
  } else if ((str = malloc(len)) == NULL) {
	REASON_SET(reason, RC_MEM_ERR);
	free(item);
  } else
  {
/* Section Mark */
	PUT(SCANKEY_NULL, RSC(SYSINFO_KERNEL).ATTR(), width, 0,
		"%s:", Shm->SysGate.sysname);

	PUT(SCANKEY_NULL, RSC(KERNEL_RELEASE).ATTR(), width, 2,
		"%s%.*s[%s]", RSC(KERNEL_RELEASE).CODE(),
		width - 5 - RSZ(KERNEL_RELEASE)- strlen(Shm->SysGate.release),
		hSpace, Shm->SysGate.release);

	PUT(SCANKEY_NULL, RSC(KERNEL_VERSION).ATTR(), width, 2,
		"%s%.*s[%s]", RSC(KERNEL_VERSION).CODE(),
		width - 5 - RSZ(KERNEL_VERSION) - strlen(Shm->SysGate.version),
		hSpace, Shm->SysGate.version);

	PUT(SCANKEY_NULL, RSC(KERNEL_MACHINE).ATTR(), width, 2,
		"%s%.*s[%s]", RSC(KERNEL_MACHINE).CODE(),
		width - 5 - RSZ(KERNEL_MACHINE) - strlen(Shm->SysGate.machine),
		hSpace, Shm->SysGate.machine);
/* Section Mark */
	PUT(SCANKEY_NULL, RSC(KERNEL_MEMORY).ATTR(), width, 0,
		"%s:%.*s", RSC(KERNEL_MEMORY).CODE(),
		width - 1 - RSZ(KERNEL_MEMORY), hSpace);

	len = sprintf(str, "%lu", Shm->SysGate.memInfo.totalram);
	PUT(SCANKEY_NULL, RSC(KERNEL_TOTAL_RAM).ATTR(), width, 2,
		"%s%.*s" "%s KB", RSC(KERNEL_TOTAL_RAM).CODE(),
		width - 6 - RSZ(KERNEL_TOTAL_RAM) - len, hSpace, str);

	len = sprintf(str, "%lu", Shm->SysGate.memInfo.sharedram);
	GridCall(PUT(SCANKEY_NULL, RSC(KERNEL_SHARED_RAM).ATTR(), width, 2,
			"%s%.*s" "%s KB", RSC(KERNEL_SHARED_RAM).CODE(),
			width - 6 - RSZ(KERNEL_SHARED_RAM) - len, hSpace, str),
		KernelUpdate, &Shm->SysGate.memInfo.sharedram);

	len = sprintf(str, "%lu", Shm->SysGate.memInfo.freeram);
	GridCall(PUT(SCANKEY_NULL, RSC(KERNEL_FREE_RAM).ATTR(), width, 2,
			"%s%.*s" "%s KB", RSC(KERNEL_FREE_RAM).CODE(),
			width - 6 - RSZ(KERNEL_FREE_RAM) - len, hSpace, str),
		KernelUpdate, &Shm->SysGate.memInfo.freeram);

	len = sprintf(str, "%lu", Shm->SysGate.memInfo.bufferram);
	GridCall(PUT(SCANKEY_NULL, RSC(KERNEL_BUFFER_RAM).ATTR(), width, 2,
			"%s%.*s" "%s KB", RSC(KERNEL_BUFFER_RAM).CODE(),
			width - 6 - RSZ(KERNEL_BUFFER_RAM) - len, hSpace, str),
		KernelUpdate, &Shm->SysGate.memInfo.bufferram);

	len = sprintf(str, "%lu", Shm->SysGate.memInfo.totalhigh);
	GridCall(PUT(SCANKEY_NULL, RSC(KERNEL_TOTAL_HIGH).ATTR(), width, 2,
			"%s%.*s" "%s KB", RSC(KERNEL_TOTAL_HIGH).CODE(),
			width - 6 - RSZ(KERNEL_TOTAL_HIGH) - len, hSpace, str),
		KernelUpdate, &Shm->SysGate.memInfo.totalhigh);

	len = sprintf(str, "%lu", Shm->SysGate.memInfo.freehigh);
	GridCall(PUT(SCANKEY_NULL, RSC(KERNEL_FREE_HIGH).ATTR(), width, 2,
			"%s%.*s" "%s KB", RSC(KERNEL_FREE_HIGH).CODE(),
			width - 6 - RSZ(KERNEL_FREE_HIGH) - len, hSpace, str),
		KernelUpdate, &Shm->SysGate.memInfo.freehigh);
/* Section Mark */
    if ((len = strlen(Shm->SysGate.IdleDriver.Name)
		+ strlen(Shm->SysGate.IdleDriver.Governor)) > 0)
    {
	PUT(SCANKEY_NULL, RSC(KERNEL_IDLE_DRIVER).ATTR(), width, 0,
		"%s%.*s[%s@%s]", RSC(KERNEL_IDLE_DRIVER).CODE(),
		width - 3 - RSZ(KERNEL_IDLE_DRIVER) - len, hSpace,
		Shm->SysGate.IdleDriver.Governor, Shm->SysGate.IdleDriver.Name);
/* Row Mark */
	sprintf(item, "%s:%.*s", RSC(KERNEL_STATE).CODE(),
			15 - (int) RSZ(KERNEL_STATE), hSpace);
      for (idx = 0; idx < Shm->SysGate.IdleDriver.stateCount; idx++)
      {
	sprintf(str, "%-8.*s", 8,
		Shm->SysGate.IdleDriver.State[idx].Name);
	strcat(item, str);
      }
	PUT(SCANKEY_NULL, RSC(KERNEL_STATE).ATTR(), width, 3,
		 "%.*s", width - (OutFunc == NULL ? 6 : 3), item);
/* Row Mark */
	sprintf(item, "%.*s", 16, hSpace);
      for (idx = 0; idx < Shm->SysGate.IdleDriver.stateCount; idx++)
      {
	sprintf(str, "%-8.*s", 8,
		Shm->SysGate.IdleDriver.State[idx].Desc);
	strcat(item, str);
      }
	PUT(SCANKEY_NULL, RSC(KERNEL_STATE).ATTR(), width, 3,
		"%.*s", width - (OutFunc == NULL ? 6 : 3), item);
/* Row Mark */
	sprintf(item, "%s:%.*s", RSC(KERNEL_POWER).CODE(),
			15 - (int) RSZ(KERNEL_POWER), hSpace);
      for (idx = 0; idx < Shm->SysGate.IdleDriver.stateCount;idx++ )
      {
	sprintf(str, "%-8d",
		Shm->SysGate.IdleDriver.State[idx].powerUsage);
	strcat(item, str);
      }
	PUT(SCANKEY_NULL, RSC(KERNEL_POWER).ATTR(), width, 3,
		"%.*s", width - (OutFunc == NULL ? 6 : 3), item);
/* Row Mark */
	sprintf(item, "%s:%.*s", RSC(KERNEL_LATENCY).CODE(),
			15 - (int) RSZ(KERNEL_LATENCY), hSpace);
      for (idx = 0; idx < Shm->SysGate.IdleDriver.stateCount; idx++)
      {
	sprintf(str, "%-8u",
		Shm->SysGate.IdleDriver.State[idx].exitLatency);
	strcat(item, str);
      }
	PUT(SCANKEY_NULL, RSC(KERNEL_LATENCY).ATTR(), width, 3,
		"%.*s", width - (OutFunc == NULL ? 6 : 3), item);
/* Row Mark */
	sprintf(item, "%s:%.*s", RSC(KERNEL_RESIDENCY).CODE(),
			15 - (int) RSZ(KERNEL_RESIDENCY), hSpace);
      for (idx = 0; idx < Shm->SysGate.IdleDriver.stateCount; idx++)
      {
	sprintf(str, "%-8u",
		Shm->SysGate.IdleDriver.State[idx].targetResidency);
	strcat(item, str);
      }
	PUT(SCANKEY_NULL, RSC(KERNEL_RESIDENCY).ATTR(), width, 3,
		"%.*s", width - (OutFunc == NULL ? 6 : 3), item);
    }
	free(item);
	free(str);
  }
	return(reason);
}

---
coretypes.h
---

typedef struct	/* MONITOR & MWAIT Leaf.				*/
{		/* Common x86						*/
	struct
	{
		unsigned int
		SmallestSize	: 16-0,
		ReservedBits	: 32-16;
	} EAX;
	struct
	{
		unsigned int
		LargestSize	: 16-0,
		ReservedBits	: 32-16;
	} EBX;
	struct
	{
		unsigned int
		EMX_MWAIT	:  1-0,
		IBE_MWAIT	:  2-1,
		ReservedBits	: 32-2;
	} ECX;
	struct
	{	/* Intel reseved.					*/
		unsigned int
		SubCstate_MWAIT0:  4-0,
		SubCstate_MWAIT1:  8-4,
		SubCstate_MWAIT2: 12-8,
		SubCstate_MWAIT3: 16-12,
		SubCstate_MWAIT4: 20-16,
		SubCstate_MWAIT5: 24-20,
		SubCstate_MWAIT6: 28-24,
		SubCstate_MWAIT7: 32-28;
	} EDX;
}  CPUID_0x00000005;

typedef struct {
	int			stateCount;
	struct {
		unsigned int	exitLatency;		/* in US	*/
			int	powerUsage;		/* in mW	*/
		unsigned int	targetResidency;	/* in US	*/
			char	Name[CPUIDLE_NAME_LEN],
				Desc[CPUIDLE_NAME_LEN];
	} State[CPUIDLE_STATE_MAX];
	char			Name[CPUIDLE_NAME_LEN],
				Governor[CPUIDLE_NAME_LEN];
} IDLEDRIVER;

---
corefreqk.c
---

long Sys_IdleDriver_Query(SYSGATE *SysGate)
{
    if (SysGate != NULL) {
	struct cpuidle_driver *idleDriver;
#ifdef CONFIG_CPU_FREQ
	struct cpufreq_policy freqPolicy;
#endif
	unsigned int cpu;
	int rc;

	if ((idleDriver = cpuidle_get_driver()) != NULL) {
		int i;
		memcpy( SysGate->IdleDriver.Name,
			idleDriver->name,
			CPUIDLE_NAME_LEN);
		SysGate->IdleDriver.Name[CPUIDLE_NAME_LEN - 1] = 0;

		if (idleDriver->state_count < CPUIDLE_STATE_MAX)
			SysGate->IdleDriver.stateCount=idleDriver->state_count;
		else	/* Don't allow an overflow. */
			SysGate->IdleDriver.stateCount=CPUIDLE_STATE_MAX;

	    for (i = 0; i < SysGate->IdleDriver.stateCount; i++) {
		memcpy( SysGate->IdleDriver.State[i].Name,
			idleDriver->states[i].name,
			CPUIDLE_NAME_LEN);
		SysGate->IdleDriver.State[i].Name[CPUIDLE_NAME_LEN - 1] = 0;

		memcpy( SysGate->IdleDriver.State[i].Desc,
			idleDriver->states[i].desc,
			CPUIDLE_NAME_LEN);
		SysGate->IdleDriver.State[i].Desc[CPUIDLE_NAME_LEN - 1] = 0;

		SysGate->IdleDriver.State[i].exitLatency =
				idleDriver->states[i].exit_latency;
		SysGate->IdleDriver.State[i].powerUsage =
				idleDriver->states[i].power_usage;
		SysGate->IdleDriver.State[i].targetResidency =
				idleDriver->states[i].target_residency;
	    }
	}
	else
		memset(&SysGate->IdleDriver, 0, sizeof(IDLEDRIVER));
#ifdef CONFIG_CPU_FREQ
	memset(&freqPolicy, 0, sizeof(freqPolicy));
	cpu = get_cpu();
	rc = cpufreq_get_policy(&freqPolicy, cpu);
	put_cpu();
	if (rc == 0) {
		struct cpufreq_governor *pGovernor = freqPolicy.governor;
		if (pGovernor != NULL) {
			memcpy( SysGate->IdleDriver.Governor,
				pGovernor->name,
				CPUIDLE_NAME_LEN);
			SysGate->IdleDriver.Governor[CPUIDLE_NAME_LEN - 1] = 0;
		}
	}
#else
	memset(SysGate->IdleDriver.Governor, 0, CPUIDLE_NAME_LEN);
#endif
	return(0);
    }
    else
	return(-1);
}

static int CoreFreqK_IdleHandler(struct cpuidle_device *pIdleDevice,
				struct cpuidle_driver *pIdleDriver, int index)
{
	unsigned long MWAIT=(CoreFreqK.IdleDriver.states[index].flags>>24)&0xff;
	mwait_idle_with_hints(MWAIT, Proc->Features.MWait.ECX.IBE_MWAIT);
	return index;
}

static void CoreFreqK_S2IdleHandler(struct cpuidle_device *pIdleDevice,
				struct cpuidle_driver *pIdleDriver, int index)
{
	unsigned long MWAIT=(CoreFreqK.IdleDriver.states[index].flags>>24)&0xff;
	mwait_idle_with_hints(MWAIT, Proc->Features.MWait.ECX.IBE_MWAIT);
}

static int CoreFreqK_IdleDriver_Init(void)
{
	IDLE_STATE *pIdleState = Arch[Proc->ArchID].IdleState;
	int rc = -EPERM;
  if (Proc->Features.Std.ECX.MONITOR && (pIdleState != NULL))
  {
	/* Performance State						*/
	cpuidle_poll_state_init(&CoreFreqK.IdleDriver);
	CoreFreqK.IdleDriver.state_count = 1;
	/* Idle States							*/
    while (pIdleState->Name != NULL)
    {
	strcpy(CoreFreqK.IdleDriver.states[
			CoreFreqK.IdleDriver.state_count
		].name, pIdleState->Name);

	strcpy(CoreFreqK.IdleDriver.states[
			CoreFreqK.IdleDriver.state_count
		].desc, pIdleState->Desc);

	CoreFreqK.IdleDriver.states[
		CoreFreqK.IdleDriver.state_count
	].flags = pIdleState->flags;

	CoreFreqK.IdleDriver.states[
		CoreFreqK.IdleDriver.state_count
	].exit_latency = pIdleState->Latency;

	CoreFreqK.IdleDriver.states[
		CoreFreqK.IdleDriver.state_count
	].target_residency = pIdleState->Residency;

	CoreFreqK.IdleDriver.states[
		CoreFreqK.IdleDriver.state_count
	].enter = CoreFreqK_IdleHandler;

	CoreFreqK.IdleDriver.states[
		CoreFreqK.IdleDriver.state_count
	].enter_s2idle = CoreFreqK_S2IdleHandler;

	CoreFreqK.IdleDriver.state_count++;
	pIdleState++;
    }
    if ((rc = cpuidle_register_driver(&CoreFreqK.IdleDriver)) == 0) {
	struct cpuidle_device *device;
	unsigned int cpu;
	for (cpu = 0; cpu < Proc->CPU.Count; cpu++) {
	    if (!BITVAL(KPublic->Core[cpu]->OffLine, HW)) {
		device = &per_cpu(IdleDevice, cpu);
		device->cpu = cpu;
		if ((rc = cpuidle_register_device(device)) == 0)
			continue;

		cpuidle_unregister_driver(&CoreFreqK.IdleDriver);
		break;
	    }
	}
    }
  }
	return(rc);
}

---
corefreqd.c
---

void SysGate_IdleDriver(REF *Ref)
{
    SHM_STRUCT *Shm = Ref->Shm;
    SYSGATE *SysGate = Ref->SysGate;

    if (strlen(SysGate->IdleDriver.Name) > 0) {
	int idx;

	memcpy(Shm->SysGate.IdleDriver.Name,
		SysGate->IdleDriver.Name, CPUIDLE_NAME_LEN - 1);
	Shm->SysGate.IdleDriver.Name[CPUIDLE_NAME_LEN - 1] = '\0';

	Shm->SysGate.IdleDriver.stateCount = SysGate->IdleDriver.stateCount;
	for (idx = 0; idx < Shm->SysGate.IdleDriver.stateCount; idx++)
	{
	size_t len=KMIN(strlen(SysGate->IdleDriver.State[idx].Name),
			CPUIDLE_NAME_LEN - 1);
		memcpy( Shm->SysGate.IdleDriver.State[idx].Name,
			SysGate->IdleDriver.State[idx].Name, len);
		Shm->SysGate.IdleDriver.State[idx].Name[len] = '\0';

		len=KMIN(strlen(SysGate->IdleDriver.State[idx].Desc),
			CPUIDLE_NAME_LEN - 1);
		memcpy( Shm->SysGate.IdleDriver.State[idx].Desc,
			SysGate->IdleDriver.State[idx].Desc, len);
		Shm->SysGate.IdleDriver.State[idx].Desc[len] = '\0';

		Shm->SysGate.IdleDriver.State[idx].exitLatency =
			SysGate->IdleDriver.State[idx].exitLatency;

		Shm->SysGate.IdleDriver.State[idx].powerUsage =
			SysGate->IdleDriver.State[idx].powerUsage;

		Shm->SysGate.IdleDriver.State[idx].targetResidency =
			SysGate->IdleDriver.State[idx].targetResidency;
	}
    }
    if (strlen(SysGate->IdleDriver.Governor) > 0) {
	size_t len=KMIN(strlen(SysGate->IdleDriver.Governor),
			CPUIDLE_NAME_LEN - 1);
	memcpy(Shm->SysGate.IdleDriver.Governor,
		SysGate->IdleDriver.Governor, len);
	Shm->SysGate.IdleDriver.Governor[len] = '\0';
    }
}

---
corefreqk.h
---

static IDLE_STATE SNB_IdleState[] = {
	{
	.Name		= "C1",
	.Desc		= "SNB-C1",
	.flags		= 0x00 << 24,
	.Latency	= 2,
	.Residency	= 2
	},
	{
	.Name		= "C1E",
	.Desc		= "SNB-C1E",
	.flags		= 0x01 << 24,
	.Latency	= 10,
	.Residency	= 20
	},
	{
	.Name		= "C3",
	.Desc		= "SNB-C3",
	.flags		= (0x10 << 24) | 0x10000,
	.Latency	= 80,
	.Residency	= 211
	},
	{
	.Name		= "C6",
	.Desc		= "SNB-C6",
	.flags		= (0x20 << 24) | 0x10000,
	.Latency	= 104,
	.Residency	= 345
	},
	{
	.Name		= "C7",
	.Desc		= "SNB-C7",
	.flags		= (0x30 << 24) | 0x10000,
	.Latency	= 109,
	.Residency	= 345
	},
	{NULL}
};

static IDLE_STATE SKL_IdleState[] = {
	{
	.Name		= "C1",
	.Desc		= "SKL-C1",
	.flags		= 0x00 << 24,
	.Latency	= 2,
	.Residency	= 2
	},
	{
	.Name		= "C1E",
	.Desc		= "SKL-C1E",
	.flags		= 0x01 << 24,
	.Latency	= 10,
	.Residency	= 20
	},
	{
	.Name		= "C3",
	.Desc		= "SKL-C3",
	.flags		= (0x10 << 24) | 0x10000,
	.Latency	= 70,
	.Residency	= 100
	},
	{
	.Name		= "C6",
	.Desc		= "SKL-C6",
	.flags		= (0x20 << 24) | 0x10000,
	.Latency	= 85,
	.Residency	= 200
	},
	{
	.Name		= "C7",
	.Desc		= "SKL-C7",
	.flags		= (0x33 << 24) | 0x10000,
	.Latency	= 124,
	.Residency	= 800
	},
	{
	.Name		= "C8",
	.Desc		= "SKL-C8",
	.flags		= (0x40 << 24) | 0x10000,
	.Latency	= 200,
	.Residency	= 800
	},
	{
	.Name		= "C9",
	.Desc		= "SKL-C9",
	.flags		= (0x50 << 24) | 0x10000,
	.Latency	= 480,
	.Residency	= 5000
	},
	{
	.Name		= "C10",
	.Desc		= "SKL-C10",
	.flags		= (0x60 << 24) | 0x10000,
	.Latency	= 890,
	.Residency	= 5000
	},
	{NULL}
};

[SandyBridge] = {							/* 26*/
	.Signature = _SandyBridge,
	.Query = Query_SandyBridge,
	.Update = PerCore_SandyBridge_Query,
	.Start = Start_SandyBridge,
	.Stop = Stop_SandyBridge,
	.Exit = NULL,
	.Timer = InitTimer_SandyBridge,
	.BaseClock = BaseClock_SandyBridge,
	.ClockMod = ClockMod_SandyBridge_PPC,
	.TurboClock = Intel_Turbo_Config8C,
	.thermalFormula = THERMAL_FORMULA_INTEL,
	.voltageFormula = VOLTAGE_FORMULA_INTEL_SNB,
	.powerFormula   = POWER_FORMULA_INTEL,
	.PCI_ids = PCI_SandyBridge_ids,
	.Uncore = {
		.Start = Start_Uncore_SandyBridge,
		.Stop = Stop_Uncore_SandyBridge,
		.ClockMod = NULL
		},
	.Specific = Void_Specific,
	.IdleState = SNB_IdleState,
	.Architecture = Arch_SandyBridge
	},

[Skylake_S]  = {							/* 39*/
	.Signature = _Skylake_S,
	.Query = Query_Broadwell,
	.Update = PerCore_Skylake_Query,
	.Start = Start_Skylake,
	.Stop = Stop_Skylake,
	.Exit = NULL,
	.Timer = InitTimer_Skylake,
	.BaseClock = BaseClock_Skylake,
	.ClockMod = ClockMod_Skylake_HWP,
	.TurboClock = Intel_Turbo_Config8C,
	.thermalFormula = THERMAL_FORMULA_INTEL,
	.voltageFormula = VOLTAGE_FORMULA_INTEL_SNB,
	.powerFormula   = POWER_FORMULA_INTEL,
	.PCI_ids = PCI_Skylake_ids,
	.Uncore = {
		.Start = Start_Uncore_Skylake,
		.Stop = Stop_Uncore_Skylake,
		.ClockMod = NULL
		},
	.Specific = Void_Specific,
	.IdleState = SKL_IdleState,
	.Architecture = Arch_Skylake_S
	},

---
corefreq-cli-json.c
---

			json_key(&s, "MWait");
			{
				json_start_object(&s);
				json_key(&s, "EAX");
				{
					json_start_object(&s);
					json_key(&s, "SmallestSize");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EAX.SmallestSize);
					json_key(&s, "ReservedBits");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EAX.ReservedBits);
					json_end_object(&s);
				}
				json_key(&s, "EBX");
				{
					json_start_object(&s);
					json_key(&s, "LargestSize");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EBX.LargestSize);
					json_key(&s, "ReservedBits");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EBX.ReservedBits);
					json_end_object(&s);
				}
				json_key(&s, "ECX");
				{
					json_start_object(&s);
					json_key(&s, "EMX_MWAIT");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.ECX.EMX_MWAIT);
					json_key(&s, "IBE_MWAIT");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.ECX.IBE_MWAIT);
					json_key(&s, "ReservedBits");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.ECX.ReservedBits);
					json_end_object(&s);
				}
				json_key(&s, "EDX");
				{
					json_start_object(&s);
					json_key(&s, "SubCstate_C0_MWAIT");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT0);
					json_key(&s, "SubCstate_C1_MWAIT");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT1);
					json_key(&s, "SubCstate_C2_MWAIT");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT2);
					json_key(&s, "SubCstate_C3_MWAIT");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT3);
					json_key(&s, "SubCstate_C4_MWAIT");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT4);
					json_key(&s, "SubCstate_C5_MWAIT");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT5);
					json_key(&s, "SubCstate_C6_MWAIT");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT6);
					json_key(&s, "SubCstate_C7_MWAIT");
					json_literal(&s, "%u", (unsigned) Shm->Proc.Features.MWait.EDX.SubCstate_MWAIT7);

					json_end_object(&s);
				}
				json_end_object(&s);
			}
			json_key(&s, "Power");
			{
		json_start_object(&s);