/* Physical GPIO number <N> may be accessed through /sys/class/gpio/gpio<M>/,
* but <N> and <M> may differ by some offset <O>. To determine that constant,
* we look for a directory named /sys/class/gpio/gpiochip<O>/ and check for
* a 'label' file inside of it to find the expected the controller name.
*/
static int FindGpioChipOffsetByLabel(unsigned *gpio_num, unsigned *offset,
const char *name) {
DIR *dir;
struct dirent *ent;
char filename[128];
char chiplabel[128];
int match = 0;
dir = opendir(GPIO_BASE_PATH);
if (!dir) {
return 0;
}
while(0 != (ent = readdir(dir))) {
if (1 == sscanf(ent->d_name, "gpiochip%u", offset)) {
/*
* Read the file at gpiochip<O>/label to get the identifier
* for this bank of GPIOs.
*/
snprintf(filename, sizeof(filename), "%s/gpiochip%u/label",
GPIO_BASE_PATH, *offset);
if (ReadFileString(chiplabel, sizeof(chiplabel), filename)) {
if (!strncasecmp(chiplabel, name, strlen(name)))
match++;
}
}
}
closedir(dir);
return (1 == match);
}
const char* VbGetArchPropertyString(const char* name, char* dest,
size_t size) {
unsigned value;
if (!strcasecmp(name,"arch")) {
return StrCopy(dest, "x86", size);
} else if (!strcasecmp(name,"hwid")) {
return ReadFileString(dest, size, ACPI_BASE_PATH "/HWID");
} else if (!strcasecmp(name,"fwid")) {
return ReadFileString(dest, size, ACPI_BASE_PATH "/FWID");
} else if (!strcasecmp(name,"ro_fwid")) {
return ReadFileString(dest, size, ACPI_BASE_PATH "/FRID");
} else if (!strcasecmp(name,"mainfw_act")) {
if (ReadFileInt(ACPI_BINF_PATH ".1", &value) < 0)
return NULL;
switch(value) {
case 0:
return StrCopy(dest, "recovery", size);
case 1:
return StrCopy(dest, "A", size);
case 2:
return StrCopy(dest, "B", size);
default:
return NULL;
}
} else if (!strcasecmp(name,"mainfw_type")) {
return VbReadMainFwType(dest, size);
} else if (!strcasecmp(name,"ecfw_act")) {
if (ReadFileInt(ACPI_BINF_PATH ".2", &value) < 0)
return NULL;
switch(value) {
case 0:
return StrCopy(dest, "RO", size);
case 1:
return StrCopy(dest, "RW", size);
default:
return NULL;
}
} else if (!strcasecmp(name,"platform_family")) {
return ReadPlatformFamilyString(dest, size);
}
return NULL;
}
int ReadFileInt(const char* filename) {
char buf[64];
int value;
char* e = NULL;
if (!ReadFileString(buf, sizeof(buf), filename))
return -1;
/* Convert to integer. Allow characters after the int ("123 blah"). */
value = strtol(buf, &e, 0);
if (e == buf)
return -1; /* No characters consumed, so conversion failed */
return value;
}
// see https://msdn.microsoft.com/en-us/library/windows/desktop/dd607324(v=vs.85).aspx
bool D3D12Shader::CompileSource(const ShaderDescriptor& shaderDesc)
{
/* Get source code */
std::string fileContent;
const char* sourceCode = nullptr;
SIZE_T sourceLength = 0;
if (shaderDesc.sourceType == ShaderSourceType::CodeFile)
{
fileContent = ReadFileString(shaderDesc.source);
sourceCode = fileContent.c_str();
sourceLength = fileContent.size();
}
else
{
sourceCode = shaderDesc.source;
sourceLength = shaderDesc.sourceSize;
}
/* Get parameter from union */
const char* entry = shaderDesc.entryPoint;
const char* target = (shaderDesc.profile != nullptr ? shaderDesc.profile : "");
auto flags = shaderDesc.flags;
/* Compile shader code */
ComPtr<ID3DBlob> code;
auto hr = D3DCompile(
sourceCode,
sourceLength,
nullptr, // LPCSTR pSourceName
nullptr, // D3D_SHADER_MACRO* pDefines
nullptr, // ID3DInclude* pInclude
entry, // LPCSTR pEntrypoint
target, // LPCSTR pTarget
DXGetCompilerFlags(flags), // UINT Flags1
0, // UINT Flags2 (recommended to always be 0)
code.ReleaseAndGetAddressOf(), // ID3DBlob** ppCode
errors_.ReleaseAndGetAddressOf() // ID3DBlob** ppErrorMsgs
);
/* Get byte code from blob */
if (code)
byteCode_ = DXGetBlobData(code.Get());
/* Store if compilation was successful */
return !FAILED(hr);
}
/* Read a GPIO of the specified signal type (see ACPI GPIO SignalType).
*
* Returns 1 if the signal is asserted, 0 if not asserted, or -1 if error. */
static int ReadGpio(unsigned signal_type) {
char name[128];
int index = 0;
unsigned gpio_type;
unsigned active_high;
unsigned controller_num;
unsigned controller_offset = 0;
char controller_name[128];
unsigned value;
const struct GpioChipset *chipset;
/* Scan GPIO.* to find a matching signal type */
for (index = 0; ; index++) {
snprintf(name, sizeof(name), "%s.%d/GPIO.0", ACPI_GPIO_PATH, index);
if (ReadFileInt(name, &gpio_type) < 0)
return -1; /* Ran out of GPIOs before finding a match */
if (gpio_type == signal_type)
break;
}
/* Read attributes and controller info for the GPIO */
snprintf(name, sizeof(name), "%s.%d/GPIO.1", ACPI_GPIO_PATH, index);
if (ReadFileInt(name, &active_high) < 0)
return -1;
snprintf(name, sizeof(name), "%s.%d/GPIO.2", ACPI_GPIO_PATH, index);
if (ReadFileInt(name, &controller_num) < 0)
return -1;
/* Do not attempt to read GPIO that is set to -1 in ACPI */
if (controller_num == 0xFFFFFFFF)
return -1;
/* Check for chipsets we recognize. */
snprintf(name, sizeof(name), "%s.%d/GPIO.3", ACPI_GPIO_PATH, index);
if (!ReadFileString(controller_name, sizeof(controller_name), name))
return -1;
chipset = FindChipset(controller_name);
if (chipset == NULL)
return -1;
/* Modify GPIO number by driver's offset */
if (!chipset->ChipOffsetAndGpioNumber(&controller_num, &controller_offset,
chipset->name))
return -1;
controller_offset += controller_num;
/* Try reading the GPIO value */
snprintf(name, sizeof(name), "%s/gpio%d/value",
GPIO_BASE_PATH, controller_offset);
if (ReadFileInt(name, &value) < 0) {
/* Try exporting the GPIO */
FILE* f = fopen(GPIO_EXPORT_PATH, "wt");
if (!f)
return -1;
fprintf(f, "%u", controller_offset);
fclose(f);
/* Try re-reading the GPIO value */
if (ReadFileInt(name, &value) < 0)
return -1;
}
/* Normalize the value read from the kernel in case it is not always 1. */
value = value ? 1 : 0;
/* Compare the GPIO value with the active value and return 1 if match. */
return (value == active_high ? 1 : 0);
}
