CTCaer/RetroArch
1
0
Fork 0
mirror of https://github.com/CTCaer/RetroArch.git synced 2024-12-15 06:50:32 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
225187dbd0
RetroArch/frontend/drivers/platform_linux.c
twinaphex a2c8f89137 Create frontend->parse_drive_list
2015-06-15 22:45:02 +02:00

489 lines
13 KiB
C
Raw Blame History

/* RetroArch - A frontend for libretro.
* Copyright (C) 2010-2014 - Hans-Kristian Arntzen
* Copyright (C) 2011-2015 - Daniel De Matteis
* Copyright (C) 2012-2015 - Jason Fetters
*
* RetroArch is free software: you can redistribute it and/or modify it under the terms
* of the GNU General Public License as published by the Free Software Found-
* ation, either version 3 of the License, or (at your option) any later version.
*
* RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU General Public License for more details.
* * You should have received a copy of the GNU General Public License along with RetroArch.
* If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdint.h>
#include <boolean.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/utsname.h>
#include <compat/strl.h>
#include <rhash.h>
#include "../frontend_driver.h"
static const char *proc_apm_path = "/proc/apm";
static const char *proc_acpi_battery_path = "/proc/acpi/battery";
static const char *proc_acpi_ac_adapter_path = "/proc/acpi/ac_adapter";
static int open_acpi_file(const char *base, const char *node, const char *key)
{
const size_t pathlen = strlen(base) + strlen(node) + strlen(key) + 3;
char *path = (char *)alloca(pathlen);
if (!path)
return -1;
snprintf(path, pathlen, "%s/%s/%s", base, node, key);
return open(path, O_RDONLY);
}
static bool load_acpi_file(const char *base, const char *node, const char *key,
char *buf, size_t buflen)
{
ssize_t br = 0;
const int fd = open_acpi_file(base, node, key);
if (fd == -1)
return false;
br = read(fd, buf, buflen-1);
close(fd);
if (br < 0)
return false;
buf[br] = '\0'; /* null-terminate the string. */
return true;
}
static bool make_proc_acpi_key_val(char **_ptr, char **_key, char **_val)
{
char *ptr = *_ptr;
while (*ptr == ' ')
ptr++; /* skip whitespace. */
if (*ptr == '\0')
return false; /* EOF. */
*_key = ptr;
while ((*ptr != ':') && (*ptr != '\0'))
ptr++;
if (*ptr == '\0')
return false; /* (unexpected) EOF. */
*(ptr++) = '\0'; /* terminate the key. */
while ((*ptr == ' ') && (*ptr != '\0'))
ptr++; /* skip whitespace. */
if (*ptr == '\0')
return false; /* (unexpected) EOF. */
*_val = ptr;
while ((*ptr != '\n') && (*ptr != '\0'))
ptr++;
if (*ptr != '\0')
*(ptr++) = '\0'; /* terminate the value. */
*_ptr = ptr; /* store for next time. */
return true;
}
#define ACPI_KEY_STATE 0x10614a06U
#define ACPI_KEY_PRESENT 0xc28ac046U
#define ACPI_KEY_CHARGING_STATE 0x5ba13e29U
#define ACPI_KEY_REMAINING_CAPACITY 0xf36952edU
#define ACPI_KEY_DESIGN_CAPACITY 0x05e6488dU
#define ACPI_VAL_CHARGING_DISCHARGING 0xf268327aU
#define ACPI_VAL_CHARGING 0x095ee228U
#define ACPI_VAL_YES 0x0b88c316U
#define ACPI_VAL_ONLINE 0x6842bf17U
static void
check_proc_acpi_battery(const char * node, bool * have_battery,
bool * charging, int *seconds, int *percent)
{
const char *base = proc_acpi_battery_path;
char info[1024] = {0};
char state[1024] = {0};
char *ptr = NULL;
char *key = NULL;
char *val = NULL;
bool charge = false;
bool choose = false;
int maximum = -1;
int remaining = -1;
int secs = -1;
int pct = -1;
if (!load_acpi_file(base, node, "state", state, sizeof (state)))
return;
else if (!load_acpi_file(base, node, "info", info, sizeof (info)))
return;
ptr = &state[0];
while (make_proc_acpi_key_val(&ptr, &key, &val))
{
uint32_t key_hash = djb2_calculate(key);
uint32_t val_hash = djb2_calculate(val);
switch (key_hash)
{
case ACPI_KEY_PRESENT:
if (val_hash == ACPI_VAL_YES)
*have_battery = true;
break;
case ACPI_KEY_CHARGING_STATE:
switch (val_hash)
{
case ACPI_VAL_CHARGING_DISCHARGING:
case ACPI_VAL_CHARGING:
charge = true;
break;
}
break;
case ACPI_KEY_REMAINING_CAPACITY:
{
char *endptr = NULL;
const int cvt = (int) strtol(val, &endptr, 10);
if (*endptr == ' ')
remaining = cvt;
}
break;
}
}
ptr = &info[0];
while (make_proc_acpi_key_val(&ptr, &key, &val))
{
uint32_t key_hash = djb2_calculate(key);
switch (key_hash)
{
case ACPI_KEY_DESIGN_CAPACITY:
{
char *endptr = NULL;
const int cvt = (int) strtol(val, &endptr, 10);
if (*endptr == ' ')
maximum = cvt;
}
break;
}
}
if ((maximum >= 0) && (remaining >= 0))
{
pct = (int) ((((float) remaining) / ((float) maximum)) * 100.0f);
if (pct < 0)
pct = 0;
else if (pct > 100)
pct = 100;
}
/* !!! FIXME: calculate (secs). */
/*
* We pick the battery that claims to have the most minutes left.
* (failing a report of minutes, we'll take the highest percent.)
*/
if ((secs < 0) && (*seconds < 0))
{
if ((pct < 0) && (*percent < 0))
choose = true; /* at least we know there's a battery. */
if (pct > *percent)
choose = true;
}
else if (secs > *seconds)
choose = true;
if (choose)
{
*seconds = secs;
*percent = pct;
*charging = charge;
}
}
static void
check_proc_acpi_ac_adapter(const char * node, bool *have_ac)
{
const char *base = proc_acpi_ac_adapter_path;
char state[256] = {0};
char *ptr = NULL;
char *key = NULL;
char *val = NULL;
if (!load_acpi_file(base, node, "state", state, sizeof (state)))
return;
ptr = &state[0];
while (make_proc_acpi_key_val(&ptr, &key, &val))
{
uint32_t key_hash = djb2_calculate(key);
uint32_t val_hash = djb2_calculate(val);
if (key_hash == ACPI_KEY_STATE &&
val_hash == ACPI_VAL_ONLINE)
*have_ac = true;
}
}
static bool next_string(char **_ptr, char **_str)
{
char *ptr = *_ptr;
char *str = *_str;
while (*ptr == ' ') /* skip any spaces... */
ptr++;
if (*ptr == '\0')
return false;
str = ptr;
while ((*ptr != ' ') && (*ptr != '\n') && (*ptr != '\0'))
ptr++;
if (*ptr != '\0')
*(ptr++) = '\0';
*_str = str;
*_ptr = ptr;
return true;
}
static bool int_string(char *str, int *val)
{
char *endptr = NULL;
*val = (int) strtol(str, &endptr, 0);
return ((*str != '\0') && (*endptr == '\0'));
}
bool frontend_linux_powerstate_check_apm(enum frontend_powerstate *state,
int *seconds, int *percent)
{
ssize_t br;
int ac_status = 0;
int battery_status = 0;
int battery_flag = 0;
int battery_percent = 0;
int battery_time = 0;
const int fd = open(proc_apm_path, O_RDONLY);
char buf[128] = {0};
char *ptr = &buf[0];
char *str = NULL;
if (fd == -1)
return false; /* can't use this interface. */
br = read(fd, buf, sizeof (buf) - 1);
close(fd);
if (br < 0)
return false;
buf[br] = '\0'; /* null-terminate the string. */
if (!next_string(&ptr, &str)) /* driver version */
return false;
if (!next_string(&ptr, &str)) /* BIOS version */
return false;
if (!next_string(&ptr, &str)) /* APM flags */
return false;
if (!next_string(&ptr, &str)) /* AC line status */
return false;
else if (!int_string(str, &ac_status))
return false;
if (!next_string(&ptr, &str)) /* battery status */
return false;
else if (!int_string(str, &battery_status))
return false;
if (!next_string(&ptr, &str)) /* battery flag */
return false;
else if (!int_string(str, &battery_flag))
return false;
if (!next_string(&ptr, &str)) /* remaining battery life percent */
return false;
if (str[strlen(str) - 1] == '%')
str[strlen(str) - 1] = '\0';
if (!int_string(str, &battery_percent))
return false;
if (!next_string(&ptr, &str)) /* remaining battery life time */
return false;
else if (!int_string(str, &battery_time))
return false;
if (!next_string(&ptr, &str)) /* remaining battery life time units */
return false;
else if (!strcmp(str, "min"))
battery_time *= 60;
if (battery_flag == 0xFF) /* unknown state */
*state = FRONTEND_POWERSTATE_NONE;
else if (battery_flag & (1 << 7)) /* no battery */
*state = FRONTEND_POWERSTATE_NO_SOURCE;
else if (battery_flag & (1 << 3)) /* charging */
*state = FRONTEND_POWERSTATE_CHARGING;
else if (ac_status == 1)
*state = FRONTEND_POWERSTATE_CHARGED; /* on AC, not charging. */
else
*state = FRONTEND_POWERSTATE_ON_POWER_SOURCE;
const int pct = battery_percent;
const int secs = battery_time;
if (pct >= 0) /* -1 == unknown */
*percent = (pct > 100) ? 100 : pct; /* clamp between 0%, 100% */
if (secs >= 0) /* -1 == unknown */
*seconds = secs;
return true;
}
bool frontend_linux_powerstate_check_acpi(enum frontend_powerstate *state,
int *seconds, int *percent)
{
struct dirent *dent = NULL;
DIR *dirp = NULL;
bool have_battery = false;
bool have_ac = false;
bool charging = false;
*state = FRONTEND_POWERSTATE_NONE;
dirp = opendir(proc_acpi_battery_path);
if (dirp == NULL)
return false; /* can't use this interface. */
while ((dent = readdir(dirp)) != NULL)
{
const char *node = dent->d_name;
check_proc_acpi_battery(node, &have_battery, &charging,
seconds, percent);
}
closedir(dirp);
dirp = opendir(proc_acpi_ac_adapter_path);
if (dirp == NULL)
return false; /* can't use this interface. */
while ((dent = readdir(dirp)) != NULL)
{
const char *node = dent->d_name;
check_proc_acpi_ac_adapter(node, &have_ac);
}
closedir(dirp);
if (!have_battery)
*state = FRONTEND_POWERSTATE_NO_SOURCE;
else if (charging)
*state = FRONTEND_POWERSTATE_CHARGING;
else if (have_ac)
*state = FRONTEND_POWERSTATE_CHARGED;
else
*state = FRONTEND_POWERSTATE_ON_POWER_SOURCE;
return true; /* definitive answer. */
}
static enum frontend_powerstate
frontend_linux_get_powerstate(int *seconds, int *percent)
{
enum frontend_powerstate ret = FRONTEND_POWERSTATE_NONE;
if (frontend_linux_powerstate_check_apm(&ret, seconds, percent))
return ret;
if (frontend_linux_powerstate_check_acpi(&ret, seconds, percent))
return ret;
return FRONTEND_POWERSTATE_NONE;
}
#define LINUX_ARCH_X86_64 0x23dea434U
#define LINUX_ARCH_X86 0x0b88b8cbU
#define LINUX_ARCH_ARM 0x0b885ea5U
#define LINUX_ARCH_PPC64 0x1028cf52U
#define LINUX_ARCH_MIPS 0x7c9aa25eU
#define LINUX_ARCH_TILE 0x7c9e7873U
enum frontend_architecture frontend_linux_get_architecture(void)
{
uint32_t buffer_hash;
struct utsname buffer;
if (uname(&buffer) != 0)
return FRONTEND_ARCH_NONE;
buffer_hash = djb2_calculate(buffer.machine);
switch (buffer_hash)
{
case LINUX_ARCH_X86_64:
return FRONTEND_ARCH_X86_64;
case LINUX_ARCH_X86:
return FRONTEND_ARCH_X86;
case LINUX_ARCH_ARM:
return FRONTEND_ARCH_ARM;
case LINUX_ARCH_PPC64:
return FRONTEND_ARCH_PPC;
case LINUX_ARCH_MIPS:
return FRONTEND_ARCH_MIPS;
case LINUX_ARCH_TILE:
return FRONTEND_ARCH_TILE;
}
return FRONTEND_ARCH_NONE;
}
static void frontend_linux_get_os(char *s, size_t len, int *major, int *minor)
{
unsigned krel;
struct utsname buffer;
if (uname(&buffer) != 0)
return;
sscanf(buffer.release, "%u.%u.%u", major, minor, &krel);
strlcpy(s, "Linux", len);
}
const frontend_ctx_driver_t frontend_ctx_linux = {
NULL, /* environment_get */
NULL, /* init */
NULL, /* deinit */
NULL, /* exitspawn */
NULL, /* process_args */
NULL, /* exec */
NULL, /* set_fork */
NULL, /* shutdown */
NULL, /* get_name */
frontend_linux_get_os,
NULL, /* get_rating */
NULL, /* load_content */
frontend_linux_get_architecture,
frontend_linux_get_powerstate,
NULL, /* parse_drive_list */
"linux",
};
Reference in New Issue View Git Blame Copy Permalink