// SPDX-License-Identifier: GPL-2.0-only
/*
* ACPI AML interfacing userspace utility
*
* Copyright (C) 2015, Intel Corporation
* Authors: Lv Zheng <[email protected]>
*/
#include <acpi/acpi.h>
/* Headers not included by include/acpi/platform/aclinux.h */
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#include <stdbool.h>
#include <fcntl.h>
#include <assert.h>
#include <sys/select.h>
#include "../../../../../include/linux/circ_buf.h"
#define ACPI_AML_FILE "/sys/kernel/debug/acpi/acpidbg"
#define ACPI_AML_SEC_TICK 1
#define ACPI_AML_USEC_PEEK 200
#define ACPI_AML_BUF_SIZE 4096
#define ACPI_AML_BATCH_WRITE_CMD 0x00 /* Write command to kernel */
#define ACPI_AML_BATCH_READ_LOG 0x01 /* Read log from kernel */
#define ACPI_AML_BATCH_WRITE_LOG 0x02 /* Write log to console */
#define ACPI_AML_LOG_START 0x00
#define ACPI_AML_PROMPT_START 0x01
#define ACPI_AML_PROMPT_STOP 0x02
#define ACPI_AML_LOG_STOP 0x03
#define ACPI_AML_PROMPT_ROLL 0x04
#define ACPI_AML_INTERACTIVE 0x00
#define ACPI_AML_BATCH 0x01
#define circ_count(circ) \
(CIRC_CNT((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
#define circ_count_to_end(circ) \
(CIRC_CNT_TO_END((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
#define circ_space(circ) \
(CIRC_SPACE((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
#define circ_space_to_end(circ) \
(CIRC_SPACE_TO_END((circ)->head, (circ)->tail, ACPI_AML_BUF_SIZE))
#define acpi_aml_cmd_count() circ_count(&acpi_aml_cmd_crc)
#define acpi_aml_log_count() circ_count(&acpi_aml_log_crc)
#define acpi_aml_cmd_space() circ_space(&acpi_aml_cmd_crc)
#define acpi_aml_log_space() circ_space(&acpi_aml_log_crc)
#define ACPI_AML_DO(_fd, _op, _buf, _ret) \
do { \
_ret = acpi_aml_##_op(_fd, &acpi_aml_##_buf##_crc); \
if (_ret == 0) { \
fprintf(stderr, \
"%s %s pipe closed.\n", #_buf, #_op); \
return; \
} \
} while (0)
#define ACPI_AML_BATCH_DO(_fd, _op, _buf, _ret) \
do { \
_ret = acpi_aml_##_op##_batch_##_buf(_fd, \
&acpi_aml_##_buf##_crc); \
if (_ret == 0) \
return; \
} while (0)
static char acpi_aml_cmd_buf[ACPI_AML_BUF_SIZE];
static char acpi_aml_log_buf[ACPI_AML_BUF_SIZE];
static struct circ_buf acpi_aml_cmd_crc = {
.buf = acpi_aml_cmd_buf,
.head = 0,
.tail = 0,
};
static struct circ_buf acpi_aml_log_crc = {
.buf = acpi_aml_log_buf,
.head = 0,
.tail = 0,
};
static const char *acpi_aml_file_path = ACPI_AML_FILE;
static unsigned long acpi_aml_mode = ACPI_AML_INTERACTIVE;
static bool acpi_aml_exit;
static bool acpi_aml_batch_drain;
static unsigned long acpi_aml_batch_state;
static char acpi_aml_batch_prompt;
static char acpi_aml_batch_roll;
static unsigned long acpi_aml_log_state;
static char *acpi_aml_batch_cmd = NULL;
static char *acpi_aml_batch_pos = NULL;
static int acpi_aml_set_fl(int fd, int flags)
{
int ret;
ret = fcntl(fd, F_GETFL, 0);
if (ret < 0) {
perror("fcntl(F_GETFL)");
return ret;
}
flags |= ret;
ret = fcntl(fd, F_SETFL, flags);
if (ret < 0) {
perror("fcntl(F_SETFL)");
return ret;
}
return ret;
}
static int acpi_aml_set_fd(int fd, int maxfd, fd_set *set)
{
if (fd > maxfd)
maxfd = fd;
FD_SET(fd, set);
return maxfd;
}
static int acpi_aml_read(int fd, struct circ_buf *crc)
{
char *p;
int len;
p = &crc->buf[crc->head];
len = circ_space_to_end(crc);
len = read(fd, p, len);
if (len < 0)
perror("read");
else if (len > 0)
crc->head = (crc->head + len) & (ACPI_AML_BUF_SIZE - 1);
return len;
}
static int acpi_aml_read_batch_cmd(int unused, struct circ_buf *crc)
{
char *p;
int len;
int remained = strlen(acpi_aml_batch_pos);
p = &crc->buf[crc->head];
len = circ_space_to_end(crc);
if (len > remained) {
memcpy(p, acpi_aml_batch_pos, remained);
acpi_aml_batch_pos += remained;
len = remained;
} else {
memcpy(p, acpi_aml_batch_pos, len);
acpi_aml_batch_pos += len;
}
if (len > 0)
crc->head = (crc->head + len) & (ACPI_AML_BUF_SIZE - 1);
return len;
}
static int acpi_aml_read_batch_log(int fd, struct circ_buf *crc)
{
char *p;
int len;
int ret = 0;
p = &crc->buf[crc->head];
len = circ_space_to_end(crc);
while (ret < len && acpi_aml_log_state != ACPI_AML_LOG_STOP) {
if (acpi_aml_log_state == ACPI_AML_PROMPT_ROLL) {
*p = acpi_aml_batch_roll;
len = 1;
crc->head = (crc->head + 1) & (ACPI_AML_BUF_SIZE - 1);
ret += 1;
acpi_aml_log_state = ACPI_AML_LOG_START;
} else {
len = read(fd, p, 1);
if (len <= 0) {
if (len < 0)
perror("read");
ret = len;
break;
}
}
switch (acpi_aml_log_state) {
case ACPI_AML_LOG_START:
if (*p == '\n')
acpi_aml_log_state = ACPI_AML_PROMPT_START;
crc->head = (crc->head + 1) & (ACPI_AML_BUF_SIZE - 1);
ret += 1;
break;
case ACPI_AML_PROMPT_START:
if (*p == ACPI_DEBUGGER_COMMAND_PROMPT ||
*p == ACPI_DEBUGGER_EXECUTE_PROMPT) {
acpi_aml_batch_prompt = *p;
acpi_aml_log_state = ACPI_AML_PROMPT_STOP;
} else {
if (*p != '\n')
acpi_aml_log_state = ACPI_AML_LOG_START;
crc->head = (crc->head + 1) & (ACPI_AML_BUF_SIZE - 1);
ret += 1;
}
break;
case ACPI_AML_PROMPT_STOP:
if (*p == ' ') {
acpi_aml_log_state = ACPI_AML_LOG_STOP;
acpi_aml_exit = true;
} else {
/* Roll back */
acpi_aml_log_state = ACPI_AML_PROMPT_ROLL;
acpi_aml_batch_roll = *p;
*p = acpi_aml_batch_prompt;
crc->head = (crc->head + 1) & (ACPI_AML_BUF_SIZE - 1);
ret += 1;
}
break;
default:
assert(0);
break;
}
}
return ret;
}
static int acpi_aml_write(int fd, struct circ_buf *crc)
{
char *p;
int len;
p = &crc->buf[crc->tail];
len = circ_count_to_end(crc);
len = write(fd, p, len);
if (len < 0)
perror("write");
else if (len > 0)
crc->tail = (crc->tail + len) & (ACPI_AML_BUF_SIZE - 1);
return len;
}
static int acpi_aml_write_batch_log(int fd, struct circ_buf *crc)
{
char *p;
int len;
p = &crc->buf[crc->tail];
len = circ_count_to_end(crc);
if (!acpi_aml_batch_drain) {
len = write(fd, p, len);
if (len < 0)
perror("write");
}
if (len > 0)
crc->tail = (crc->tail + len) & (ACPI_AML_BUF_SIZE - 1);
return len;
}
static int acpi_aml_write_batch_cmd(int fd, struct circ_buf *crc)
{
int len;
len = acpi_aml_write(fd, crc);
if (circ_count_to_end(crc) == 0)
acpi_aml_batch_state = ACPI_AML_BATCH_READ_LOG;
return len;
}
static void acpi_aml_loop(int fd)
{
fd_set rfds;
fd_set wfds;
struct timeval tv;
int ret;
int maxfd = 0;
if (acpi_aml_mode == ACPI_AML_BATCH) {
acpi_aml_log_state = ACPI_AML_LOG_START;
acpi_aml_batch_pos = acpi_aml_batch_cmd;
if (acpi_aml_batch_drain)
acpi_aml_batch_state = ACPI_AML_BATCH_READ_LOG;
else
acpi_aml_batch_state = ACPI_AML_BATCH_WRITE_CMD;
}
acpi_aml_exit = false;
while (!acpi_aml_exit) {
tv.tv_sec = ACPI_AML_SEC_TICK;
tv.tv_usec = 0;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
if (acpi_aml_cmd_space()) {
if (acpi_aml_mode == ACPI_AML_INTERACTIVE)
maxfd = acpi_aml_set_fd(STDIN_FILENO, maxfd, &rfds);
else if (strlen(acpi_aml_batch_pos) &&
acpi_aml_batch_state == ACPI_AML_BATCH_WRITE_CMD)
ACPI_AML_BATCH_DO(STDIN_FILENO, read, cmd, ret);
}
if (acpi_aml_cmd_count() &&
(acpi_aml_mode == ACPI_AML_INTERACTIVE ||
acpi_aml_batch_state == ACPI_AML_BATCH_WRITE_CMD))
maxfd = acpi_aml_set_fd(fd, maxfd, &wfds);
if (acpi_aml_log_space() &&
(acpi_aml_mode == ACPI_AML_INTERACTIVE ||
acpi_aml_batch_state == ACPI_AML_BATCH_READ_LOG))
maxfd = acpi_aml_set_fd(fd, maxfd, &rfds);
if (acpi_aml_log_count())
maxfd = acpi_aml_set_fd(STDOUT_FILENO, maxfd, &wfds);
ret = select(maxfd+1, &rfds, &wfds, NULL, &tv);
if (ret < 0) {
perror("select");
break;
}
if (ret > 0) {
if (FD_ISSET(STDIN_FILENO, &rfds))
ACPI_AML_DO(STDIN_FILENO, read, cmd, ret);
if (FD_ISSET(fd, &wfds)) {
if (acpi_aml_mode == ACPI_AML_BATCH)
ACPI_AML_BATCH_DO(fd, write, cmd, ret);
else
ACPI_AML_DO(fd, write, cmd, ret);
}
if (FD_ISSET(fd, &rfds)) {
if (acpi_aml_mode == ACPI_AML_BATCH)
ACPI_AML_BATCH_DO(fd, read, log, ret);
else
ACPI_AML_DO(fd, read, log, ret);
}
if (FD_ISSET(STDOUT_FILENO, &wfds)) {
if (acpi_aml_mode == ACPI_AML_BATCH)
ACPI_AML_BATCH_DO(STDOUT_FILENO, write, log, ret);
else
ACPI_AML_DO(STDOUT_FILENO, write, log, ret);
}
}
}
}
static bool acpi_aml_readable(int fd)
{
fd_set rfds;
struct timeval tv;
int ret;
int maxfd = 0;
tv.tv_sec = 0;
tv.tv_usec = ACPI_AML_USEC_PEEK;
FD_ZERO(&rfds);
maxfd = acpi_aml_set_fd(fd, maxfd, &rfds);
ret = select(maxfd+1, &rfds, NULL, NULL, &tv);
if (ret < 0)
perror("select");
if (ret > 0 && FD_ISSET(fd, &rfds))
return true;
return false;
}
/*
* This is a userspace IO flush implementation, replying on the prompt
* characters and can be turned into a flush() call after kernel implements
* .flush() filesystem operation.
*/
static void acpi_aml_flush(int fd)
{
while (acpi_aml_readable(fd)) {
acpi_aml_batch_drain = true;
acpi_aml_loop(fd);
acpi_aml_batch_drain = false;
}
}
void usage(FILE *file, char *progname)
{
fprintf(file, "usage: %s [-b cmd] [-f file] [-h]\n", progname);
fprintf(file, "\nOptions:\n");
fprintf(file, " -b Specify command to be executed in batch mode\n");
fprintf(file, " -f Specify interface file other than");
fprintf(file, " /sys/kernel/debug/acpi/acpidbg\n");
fprintf(file, " -h Print this help message\n");
}
int main(int argc, char **argv)
{
int fd = -1;
int ch;
int len;
int ret = EXIT_SUCCESS;
while ((ch = getopt(argc, argv, "b:f:h")) != -1) {
switch (ch) {
case 'b':
if (acpi_aml_batch_cmd) {
fprintf(stderr, "Already specify %s\n",
acpi_aml_batch_cmd);
ret = EXIT_FAILURE;
goto exit;
}
len = strlen(optarg);
acpi_aml_batch_cmd = calloc(len + 2, 1);
if (!acpi_aml_batch_cmd) {
perror("calloc");
ret = EXIT_FAILURE;
goto exit;
}
memcpy(acpi_aml_batch_cmd, optarg, len);
acpi_aml_batch_cmd[len] = '\n';
acpi_aml_mode = ACPI_AML_BATCH;
break;
case 'f':
acpi_aml_file_path = optarg;
break;
case 'h':
usage(stdout, argv[0]);
goto exit;
break;
case '?':
default:
usage(stderr, argv[0]);
ret = EXIT_FAILURE;
goto exit;
break;
}
}
fd = open(acpi_aml_file_path, O_RDWR | O_NONBLOCK);
if (fd < 0) {
perror("open");
ret = EXIT_FAILURE;
goto exit;
}
acpi_aml_set_fl(STDIN_FILENO, O_NONBLOCK);
acpi_aml_set_fl(STDOUT_FILENO, O_NONBLOCK);
if (acpi_aml_mode == ACPI_AML_BATCH)
acpi_aml_flush(fd);
acpi_aml_loop(fd);
exit:
if (fd >= 0)
close(fd);
if (acpi_aml_batch_cmd)
free(acpi_aml_batch_cmd);
return ret;
}