768 lines
22 KiB
C
768 lines
22 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright (C) 2000 Tilmann Bitterberg
|
|
* (tilmann@bitterberg.de)
|
|
*
|
|
* RTAS (Runtime Abstraction Services) stuff
|
|
* Intention is to provide a clean user interface
|
|
* to use the RTAS.
|
|
*
|
|
* TODO:
|
|
* Split off a header file and maybe move it to a different
|
|
* location. Write Documentation on what the /proc/rtas/ entries
|
|
* actually do.
|
|
*/
|
|
|
|
#include <linux/errno.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/stat.h>
|
|
#include <linux/ctype.h>
|
|
#include <linux/time.h>
|
|
#include <linux/string.h>
|
|
#include <linux/init.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/rtc.h>
|
|
#include <linux/of.h>
|
|
|
|
#include <linux/uaccess.h>
|
|
#include <asm/processor.h>
|
|
#include <asm/io.h>
|
|
#include <asm/rtas.h>
|
|
#include <asm/machdep.h> /* for ppc_md */
|
|
#include <asm/time.h>
|
|
|
|
/* Token for Sensors */
|
|
#define KEY_SWITCH 0x0001
|
|
#define ENCLOSURE_SWITCH 0x0002
|
|
#define THERMAL_SENSOR 0x0003
|
|
#define LID_STATUS 0x0004
|
|
#define POWER_SOURCE 0x0005
|
|
#define BATTERY_VOLTAGE 0x0006
|
|
#define BATTERY_REMAINING 0x0007
|
|
#define BATTERY_PERCENTAGE 0x0008
|
|
#define EPOW_SENSOR 0x0009
|
|
#define BATTERY_CYCLESTATE 0x000a
|
|
#define BATTERY_CHARGING 0x000b
|
|
|
|
/* IBM specific sensors */
|
|
#define IBM_SURVEILLANCE 0x2328 /* 9000 */
|
|
#define IBM_FANRPM 0x2329 /* 9001 */
|
|
#define IBM_VOLTAGE 0x232a /* 9002 */
|
|
#define IBM_DRCONNECTOR 0x232b /* 9003 */
|
|
#define IBM_POWERSUPPLY 0x232c /* 9004 */
|
|
|
|
/* Status return values */
|
|
#define SENSOR_CRITICAL_HIGH 13
|
|
#define SENSOR_WARNING_HIGH 12
|
|
#define SENSOR_NORMAL 11
|
|
#define SENSOR_WARNING_LOW 10
|
|
#define SENSOR_CRITICAL_LOW 9
|
|
#define SENSOR_SUCCESS 0
|
|
#define SENSOR_HW_ERROR -1
|
|
#define SENSOR_BUSY -2
|
|
#define SENSOR_NOT_EXIST -3
|
|
#define SENSOR_DR_ENTITY -9000
|
|
|
|
/* Location Codes */
|
|
#define LOC_SCSI_DEV_ADDR 'A'
|
|
#define LOC_SCSI_DEV_LOC 'B'
|
|
#define LOC_CPU 'C'
|
|
#define LOC_DISKETTE 'D'
|
|
#define LOC_ETHERNET 'E'
|
|
#define LOC_FAN 'F'
|
|
#define LOC_GRAPHICS 'G'
|
|
/* reserved / not used 'H' */
|
|
#define LOC_IO_ADAPTER 'I'
|
|
/* reserved / not used 'J' */
|
|
#define LOC_KEYBOARD 'K'
|
|
#define LOC_LCD 'L'
|
|
#define LOC_MEMORY 'M'
|
|
#define LOC_NV_MEMORY 'N'
|
|
#define LOC_MOUSE 'O'
|
|
#define LOC_PLANAR 'P'
|
|
#define LOC_OTHER_IO 'Q'
|
|
#define LOC_PARALLEL 'R'
|
|
#define LOC_SERIAL 'S'
|
|
#define LOC_DEAD_RING 'T'
|
|
#define LOC_RACKMOUNTED 'U' /* for _u_nit is rack mounted */
|
|
#define LOC_VOLTAGE 'V'
|
|
#define LOC_SWITCH_ADAPTER 'W'
|
|
#define LOC_OTHER 'X'
|
|
#define LOC_FIRMWARE 'Y'
|
|
#define LOC_SCSI 'Z'
|
|
|
|
/* Tokens for indicators */
|
|
#define TONE_FREQUENCY 0x0001 /* 0 - 1000 (HZ)*/
|
|
#define TONE_VOLUME 0x0002 /* 0 - 100 (%) */
|
|
#define SYSTEM_POWER_STATE 0x0003
|
|
#define WARNING_LIGHT 0x0004
|
|
#define DISK_ACTIVITY_LIGHT 0x0005
|
|
#define HEX_DISPLAY_UNIT 0x0006
|
|
#define BATTERY_WARNING_TIME 0x0007
|
|
#define CONDITION_CYCLE_REQUEST 0x0008
|
|
#define SURVEILLANCE_INDICATOR 0x2328 /* 9000 */
|
|
#define DR_ACTION 0x2329 /* 9001 */
|
|
#define DR_INDICATOR 0x232a /* 9002 */
|
|
/* 9003 - 9004: Vendor specific */
|
|
/* 9006 - 9999: Vendor specific */
|
|
|
|
/* other */
|
|
#define MAX_SENSORS 17 /* I only know of 17 sensors */
|
|
#define MAX_LINELENGTH 256
|
|
#define SENSOR_PREFIX "ibm,sensor-"
|
|
#define cel_to_fahr(x) ((x*9/5)+32)
|
|
|
|
struct individual_sensor {
|
|
unsigned int token;
|
|
unsigned int quant;
|
|
};
|
|
|
|
struct rtas_sensors {
|
|
struct individual_sensor sensor[MAX_SENSORS];
|
|
unsigned int quant;
|
|
};
|
|
|
|
/* Globals */
|
|
static struct rtas_sensors sensors;
|
|
static struct device_node *rtas_node = NULL;
|
|
static unsigned long power_on_time = 0; /* Save the time the user set */
|
|
static char progress_led[MAX_LINELENGTH];
|
|
|
|
static unsigned long rtas_tone_frequency = 1000;
|
|
static unsigned long rtas_tone_volume = 0;
|
|
|
|
/* ****************************************************************** */
|
|
/* Declarations */
|
|
static int ppc_rtas_sensors_show(struct seq_file *m, void *v);
|
|
static int ppc_rtas_clock_show(struct seq_file *m, void *v);
|
|
static ssize_t ppc_rtas_clock_write(struct file *file,
|
|
const char __user *buf, size_t count, loff_t *ppos);
|
|
static int ppc_rtas_progress_show(struct seq_file *m, void *v);
|
|
static ssize_t ppc_rtas_progress_write(struct file *file,
|
|
const char __user *buf, size_t count, loff_t *ppos);
|
|
static int ppc_rtas_poweron_show(struct seq_file *m, void *v);
|
|
static ssize_t ppc_rtas_poweron_write(struct file *file,
|
|
const char __user *buf, size_t count, loff_t *ppos);
|
|
|
|
static ssize_t ppc_rtas_tone_freq_write(struct file *file,
|
|
const char __user *buf, size_t count, loff_t *ppos);
|
|
static int ppc_rtas_tone_freq_show(struct seq_file *m, void *v);
|
|
static ssize_t ppc_rtas_tone_volume_write(struct file *file,
|
|
const char __user *buf, size_t count, loff_t *ppos);
|
|
static int ppc_rtas_tone_volume_show(struct seq_file *m, void *v);
|
|
static int ppc_rtas_rmo_buf_show(struct seq_file *m, void *v);
|
|
|
|
static int poweron_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, ppc_rtas_poweron_show, NULL);
|
|
}
|
|
|
|
static const struct proc_ops ppc_rtas_poweron_proc_ops = {
|
|
.proc_open = poweron_open,
|
|
.proc_read = seq_read,
|
|
.proc_lseek = seq_lseek,
|
|
.proc_write = ppc_rtas_poweron_write,
|
|
.proc_release = single_release,
|
|
};
|
|
|
|
static int progress_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, ppc_rtas_progress_show, NULL);
|
|
}
|
|
|
|
static const struct proc_ops ppc_rtas_progress_proc_ops = {
|
|
.proc_open = progress_open,
|
|
.proc_read = seq_read,
|
|
.proc_lseek = seq_lseek,
|
|
.proc_write = ppc_rtas_progress_write,
|
|
.proc_release = single_release,
|
|
};
|
|
|
|
static int clock_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, ppc_rtas_clock_show, NULL);
|
|
}
|
|
|
|
static const struct proc_ops ppc_rtas_clock_proc_ops = {
|
|
.proc_open = clock_open,
|
|
.proc_read = seq_read,
|
|
.proc_lseek = seq_lseek,
|
|
.proc_write = ppc_rtas_clock_write,
|
|
.proc_release = single_release,
|
|
};
|
|
|
|
static int tone_freq_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, ppc_rtas_tone_freq_show, NULL);
|
|
}
|
|
|
|
static const struct proc_ops ppc_rtas_tone_freq_proc_ops = {
|
|
.proc_open = tone_freq_open,
|
|
.proc_read = seq_read,
|
|
.proc_lseek = seq_lseek,
|
|
.proc_write = ppc_rtas_tone_freq_write,
|
|
.proc_release = single_release,
|
|
};
|
|
|
|
static int tone_volume_open(struct inode *inode, struct file *file)
|
|
{
|
|
return single_open(file, ppc_rtas_tone_volume_show, NULL);
|
|
}
|
|
|
|
static const struct proc_ops ppc_rtas_tone_volume_proc_ops = {
|
|
.proc_open = tone_volume_open,
|
|
.proc_read = seq_read,
|
|
.proc_lseek = seq_lseek,
|
|
.proc_write = ppc_rtas_tone_volume_write,
|
|
.proc_release = single_release,
|
|
};
|
|
|
|
static int ppc_rtas_find_all_sensors(void);
|
|
static void ppc_rtas_process_sensor(struct seq_file *m,
|
|
struct individual_sensor *s, int state, int error, const char *loc);
|
|
static char *ppc_rtas_process_error(int error);
|
|
static void get_location_code(struct seq_file *m,
|
|
struct individual_sensor *s, const char *loc);
|
|
static void check_location_string(struct seq_file *m, const char *c);
|
|
static void check_location(struct seq_file *m, const char *c);
|
|
|
|
static int __init proc_rtas_init(void)
|
|
{
|
|
if (!machine_is(pseries))
|
|
return -ENODEV;
|
|
|
|
rtas_node = of_find_node_by_name(NULL, "rtas");
|
|
if (rtas_node == NULL)
|
|
return -ENODEV;
|
|
|
|
proc_create("powerpc/rtas/progress", 0644, NULL,
|
|
&ppc_rtas_progress_proc_ops);
|
|
proc_create("powerpc/rtas/clock", 0644, NULL,
|
|
&ppc_rtas_clock_proc_ops);
|
|
proc_create("powerpc/rtas/poweron", 0644, NULL,
|
|
&ppc_rtas_poweron_proc_ops);
|
|
proc_create_single("powerpc/rtas/sensors", 0444, NULL,
|
|
ppc_rtas_sensors_show);
|
|
proc_create("powerpc/rtas/frequency", 0644, NULL,
|
|
&ppc_rtas_tone_freq_proc_ops);
|
|
proc_create("powerpc/rtas/volume", 0644, NULL,
|
|
&ppc_rtas_tone_volume_proc_ops);
|
|
proc_create_single("powerpc/rtas/rmo_buffer", 0400, NULL,
|
|
ppc_rtas_rmo_buf_show);
|
|
return 0;
|
|
}
|
|
|
|
__initcall(proc_rtas_init);
|
|
|
|
static int parse_number(const char __user *p, size_t count, u64 *val)
|
|
{
|
|
char buf[40];
|
|
|
|
if (count > 39)
|
|
return -EINVAL;
|
|
|
|
if (copy_from_user(buf, p, count))
|
|
return -EFAULT;
|
|
|
|
buf[count] = 0;
|
|
|
|
return kstrtoull(buf, 10, val);
|
|
}
|
|
|
|
/* ****************************************************************** */
|
|
/* POWER-ON-TIME */
|
|
/* ****************************************************************** */
|
|
static ssize_t ppc_rtas_poweron_write(struct file *file,
|
|
const char __user *buf, size_t count, loff_t *ppos)
|
|
{
|
|
struct rtc_time tm;
|
|
time64_t nowtime;
|
|
int error = parse_number(buf, count, &nowtime);
|
|
if (error)
|
|
return error;
|
|
|
|
power_on_time = nowtime; /* save the time */
|
|
|
|
rtc_time64_to_tm(nowtime, &tm);
|
|
|
|
error = rtas_call(rtas_token("set-time-for-power-on"), 7, 1, NULL,
|
|
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec, 0 /* nano */);
|
|
if (error)
|
|
printk(KERN_WARNING "error: setting poweron time returned: %s\n",
|
|
ppc_rtas_process_error(error));
|
|
return count;
|
|
}
|
|
/* ****************************************************************** */
|
|
static int ppc_rtas_poweron_show(struct seq_file *m, void *v)
|
|
{
|
|
if (power_on_time == 0)
|
|
seq_printf(m, "Power on time not set\n");
|
|
else
|
|
seq_printf(m, "%lu\n",power_on_time);
|
|
return 0;
|
|
}
|
|
|
|
/* ****************************************************************** */
|
|
/* PROGRESS */
|
|
/* ****************************************************************** */
|
|
static ssize_t ppc_rtas_progress_write(struct file *file,
|
|
const char __user *buf, size_t count, loff_t *ppos)
|
|
{
|
|
unsigned long hex;
|
|
|
|
if (count >= MAX_LINELENGTH)
|
|
count = MAX_LINELENGTH -1;
|
|
if (copy_from_user(progress_led, buf, count)) { /* save the string */
|
|
return -EFAULT;
|
|
}
|
|
progress_led[count] = 0;
|
|
|
|
/* Lets see if the user passed hexdigits */
|
|
hex = simple_strtoul(progress_led, NULL, 10);
|
|
|
|
rtas_progress ((char *)progress_led, hex);
|
|
return count;
|
|
|
|
/* clear the line */
|
|
/* rtas_progress(" ", 0xffff);*/
|
|
}
|
|
/* ****************************************************************** */
|
|
static int ppc_rtas_progress_show(struct seq_file *m, void *v)
|
|
{
|
|
if (progress_led[0])
|
|
seq_printf(m, "%s\n", progress_led);
|
|
return 0;
|
|
}
|
|
|
|
/* ****************************************************************** */
|
|
/* CLOCK */
|
|
/* ****************************************************************** */
|
|
static ssize_t ppc_rtas_clock_write(struct file *file,
|
|
const char __user *buf, size_t count, loff_t *ppos)
|
|
{
|
|
struct rtc_time tm;
|
|
time64_t nowtime;
|
|
int error = parse_number(buf, count, &nowtime);
|
|
if (error)
|
|
return error;
|
|
|
|
rtc_time64_to_tm(nowtime, &tm);
|
|
error = rtas_call(rtas_token("set-time-of-day"), 7, 1, NULL,
|
|
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec, 0);
|
|
if (error)
|
|
printk(KERN_WARNING "error: setting the clock returned: %s\n",
|
|
ppc_rtas_process_error(error));
|
|
return count;
|
|
}
|
|
/* ****************************************************************** */
|
|
static int ppc_rtas_clock_show(struct seq_file *m, void *v)
|
|
{
|
|
int ret[8];
|
|
int error = rtas_call(rtas_token("get-time-of-day"), 0, 8, ret);
|
|
|
|
if (error) {
|
|
printk(KERN_WARNING "error: reading the clock returned: %s\n",
|
|
ppc_rtas_process_error(error));
|
|
seq_printf(m, "0");
|
|
} else {
|
|
unsigned int year, mon, day, hour, min, sec;
|
|
year = ret[0]; mon = ret[1]; day = ret[2];
|
|
hour = ret[3]; min = ret[4]; sec = ret[5];
|
|
seq_printf(m, "%lld\n",
|
|
mktime64(year, mon, day, hour, min, sec));
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* ****************************************************************** */
|
|
/* SENSOR STUFF */
|
|
/* ****************************************************************** */
|
|
static int ppc_rtas_sensors_show(struct seq_file *m, void *v)
|
|
{
|
|
int i,j;
|
|
int state, error;
|
|
int get_sensor_state = rtas_token("get-sensor-state");
|
|
|
|
seq_printf(m, "RTAS (RunTime Abstraction Services) Sensor Information\n");
|
|
seq_printf(m, "Sensor\t\tValue\t\tCondition\tLocation\n");
|
|
seq_printf(m, "********************************************************\n");
|
|
|
|
if (ppc_rtas_find_all_sensors() != 0) {
|
|
seq_printf(m, "\nNo sensors are available\n");
|
|
return 0;
|
|
}
|
|
|
|
for (i=0; i<sensors.quant; i++) {
|
|
struct individual_sensor *p = &sensors.sensor[i];
|
|
char rstr[64];
|
|
const char *loc;
|
|
int llen, offs;
|
|
|
|
sprintf (rstr, SENSOR_PREFIX"%04d", p->token);
|
|
loc = of_get_property(rtas_node, rstr, &llen);
|
|
|
|
/* A sensor may have multiple instances */
|
|
for (j = 0, offs = 0; j <= p->quant; j++) {
|
|
error = rtas_call(get_sensor_state, 2, 2, &state,
|
|
p->token, j);
|
|
|
|
ppc_rtas_process_sensor(m, p, state, error, loc);
|
|
seq_putc(m, '\n');
|
|
if (loc) {
|
|
offs += strlen(loc) + 1;
|
|
loc += strlen(loc) + 1;
|
|
if (offs >= llen)
|
|
loc = NULL;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* ****************************************************************** */
|
|
|
|
static int ppc_rtas_find_all_sensors(void)
|
|
{
|
|
const unsigned int *utmp;
|
|
int len, i;
|
|
|
|
utmp = of_get_property(rtas_node, "rtas-sensors", &len);
|
|
if (utmp == NULL) {
|
|
printk (KERN_ERR "error: could not get rtas-sensors\n");
|
|
return 1;
|
|
}
|
|
|
|
sensors.quant = len / 8; /* int + int */
|
|
|
|
for (i=0; i<sensors.quant; i++) {
|
|
sensors.sensor[i].token = *utmp++;
|
|
sensors.sensor[i].quant = *utmp++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* ****************************************************************** */
|
|
/*
|
|
* Builds a string of what rtas returned
|
|
*/
|
|
static char *ppc_rtas_process_error(int error)
|
|
{
|
|
switch (error) {
|
|
case SENSOR_CRITICAL_HIGH:
|
|
return "(critical high)";
|
|
case SENSOR_WARNING_HIGH:
|
|
return "(warning high)";
|
|
case SENSOR_NORMAL:
|
|
return "(normal)";
|
|
case SENSOR_WARNING_LOW:
|
|
return "(warning low)";
|
|
case SENSOR_CRITICAL_LOW:
|
|
return "(critical low)";
|
|
case SENSOR_SUCCESS:
|
|
return "(read ok)";
|
|
case SENSOR_HW_ERROR:
|
|
return "(hardware error)";
|
|
case SENSOR_BUSY:
|
|
return "(busy)";
|
|
case SENSOR_NOT_EXIST:
|
|
return "(non existent)";
|
|
case SENSOR_DR_ENTITY:
|
|
return "(dr entity removed)";
|
|
default:
|
|
return "(UNKNOWN)";
|
|
}
|
|
}
|
|
|
|
/* ****************************************************************** */
|
|
/*
|
|
* Builds a string out of what the sensor said
|
|
*/
|
|
|
|
static void ppc_rtas_process_sensor(struct seq_file *m,
|
|
struct individual_sensor *s, int state, int error, const char *loc)
|
|
{
|
|
/* Defined return vales */
|
|
const char * key_switch[] = { "Off\t", "Normal\t", "Secure\t",
|
|
"Maintenance" };
|
|
const char * enclosure_switch[] = { "Closed", "Open" };
|
|
const char * lid_status[] = { " ", "Open", "Closed" };
|
|
const char * power_source[] = { "AC\t", "Battery",
|
|
"AC & Battery" };
|
|
const char * battery_remaining[] = { "Very Low", "Low", "Mid", "High" };
|
|
const char * epow_sensor[] = {
|
|
"EPOW Reset", "Cooling warning", "Power warning",
|
|
"System shutdown", "System halt", "EPOW main enclosure",
|
|
"EPOW power off" };
|
|
const char * battery_cyclestate[] = { "None", "In progress",
|
|
"Requested" };
|
|
const char * battery_charging[] = { "Charging", "Discharging",
|
|
"No current flow" };
|
|
const char * ibm_drconnector[] = { "Empty", "Present", "Unusable",
|
|
"Exchange" };
|
|
|
|
int have_strings = 0;
|
|
int num_states = 0;
|
|
int temperature = 0;
|
|
int unknown = 0;
|
|
|
|
/* What kind of sensor do we have here? */
|
|
|
|
switch (s->token) {
|
|
case KEY_SWITCH:
|
|
seq_printf(m, "Key switch:\t");
|
|
num_states = sizeof(key_switch) / sizeof(char *);
|
|
if (state < num_states) {
|
|
seq_printf(m, "%s\t", key_switch[state]);
|
|
have_strings = 1;
|
|
}
|
|
break;
|
|
case ENCLOSURE_SWITCH:
|
|
seq_printf(m, "Enclosure switch:\t");
|
|
num_states = sizeof(enclosure_switch) / sizeof(char *);
|
|
if (state < num_states) {
|
|
seq_printf(m, "%s\t",
|
|
enclosure_switch[state]);
|
|
have_strings = 1;
|
|
}
|
|
break;
|
|
case THERMAL_SENSOR:
|
|
seq_printf(m, "Temp. (C/F):\t");
|
|
temperature = 1;
|
|
break;
|
|
case LID_STATUS:
|
|
seq_printf(m, "Lid status:\t");
|
|
num_states = sizeof(lid_status) / sizeof(char *);
|
|
if (state < num_states) {
|
|
seq_printf(m, "%s\t", lid_status[state]);
|
|
have_strings = 1;
|
|
}
|
|
break;
|
|
case POWER_SOURCE:
|
|
seq_printf(m, "Power source:\t");
|
|
num_states = sizeof(power_source) / sizeof(char *);
|
|
if (state < num_states) {
|
|
seq_printf(m, "%s\t",
|
|
power_source[state]);
|
|
have_strings = 1;
|
|
}
|
|
break;
|
|
case BATTERY_VOLTAGE:
|
|
seq_printf(m, "Battery voltage:\t");
|
|
break;
|
|
case BATTERY_REMAINING:
|
|
seq_printf(m, "Battery remaining:\t");
|
|
num_states = sizeof(battery_remaining) / sizeof(char *);
|
|
if (state < num_states)
|
|
{
|
|
seq_printf(m, "%s\t",
|
|
battery_remaining[state]);
|
|
have_strings = 1;
|
|
}
|
|
break;
|
|
case BATTERY_PERCENTAGE:
|
|
seq_printf(m, "Battery percentage:\t");
|
|
break;
|
|
case EPOW_SENSOR:
|
|
seq_printf(m, "EPOW Sensor:\t");
|
|
num_states = sizeof(epow_sensor) / sizeof(char *);
|
|
if (state < num_states) {
|
|
seq_printf(m, "%s\t", epow_sensor[state]);
|
|
have_strings = 1;
|
|
}
|
|
break;
|
|
case BATTERY_CYCLESTATE:
|
|
seq_printf(m, "Battery cyclestate:\t");
|
|
num_states = sizeof(battery_cyclestate) /
|
|
sizeof(char *);
|
|
if (state < num_states) {
|
|
seq_printf(m, "%s\t",
|
|
battery_cyclestate[state]);
|
|
have_strings = 1;
|
|
}
|
|
break;
|
|
case BATTERY_CHARGING:
|
|
seq_printf(m, "Battery Charging:\t");
|
|
num_states = sizeof(battery_charging) / sizeof(char *);
|
|
if (state < num_states) {
|
|
seq_printf(m, "%s\t",
|
|
battery_charging[state]);
|
|
have_strings = 1;
|
|
}
|
|
break;
|
|
case IBM_SURVEILLANCE:
|
|
seq_printf(m, "Surveillance:\t");
|
|
break;
|
|
case IBM_FANRPM:
|
|
seq_printf(m, "Fan (rpm):\t");
|
|
break;
|
|
case IBM_VOLTAGE:
|
|
seq_printf(m, "Voltage (mv):\t");
|
|
break;
|
|
case IBM_DRCONNECTOR:
|
|
seq_printf(m, "DR connector:\t");
|
|
num_states = sizeof(ibm_drconnector) / sizeof(char *);
|
|
if (state < num_states) {
|
|
seq_printf(m, "%s\t",
|
|
ibm_drconnector[state]);
|
|
have_strings = 1;
|
|
}
|
|
break;
|
|
case IBM_POWERSUPPLY:
|
|
seq_printf(m, "Powersupply:\t");
|
|
break;
|
|
default:
|
|
seq_printf(m, "Unknown sensor (type %d), ignoring it\n",
|
|
s->token);
|
|
unknown = 1;
|
|
have_strings = 1;
|
|
break;
|
|
}
|
|
if (have_strings == 0) {
|
|
if (temperature) {
|
|
seq_printf(m, "%4d /%4d\t", state, cel_to_fahr(state));
|
|
} else
|
|
seq_printf(m, "%10d\t", state);
|
|
}
|
|
if (unknown == 0) {
|
|
seq_printf(m, "%s\t", ppc_rtas_process_error(error));
|
|
get_location_code(m, s, loc);
|
|
}
|
|
}
|
|
|
|
/* ****************************************************************** */
|
|
|
|
static void check_location(struct seq_file *m, const char *c)
|
|
{
|
|
switch (c[0]) {
|
|
case LOC_PLANAR:
|
|
seq_printf(m, "Planar #%c", c[1]);
|
|
break;
|
|
case LOC_CPU:
|
|
seq_printf(m, "CPU #%c", c[1]);
|
|
break;
|
|
case LOC_FAN:
|
|
seq_printf(m, "Fan #%c", c[1]);
|
|
break;
|
|
case LOC_RACKMOUNTED:
|
|
seq_printf(m, "Rack #%c", c[1]);
|
|
break;
|
|
case LOC_VOLTAGE:
|
|
seq_printf(m, "Voltage #%c", c[1]);
|
|
break;
|
|
case LOC_LCD:
|
|
seq_printf(m, "LCD #%c", c[1]);
|
|
break;
|
|
case '.':
|
|
seq_printf(m, "- %c", c[1]);
|
|
break;
|
|
default:
|
|
seq_printf(m, "Unknown location");
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/* ****************************************************************** */
|
|
/*
|
|
* Format:
|
|
* ${LETTER}${NUMBER}[[-/]${LETTER}${NUMBER} [ ... ] ]
|
|
* the '.' may be an abbreviation
|
|
*/
|
|
static void check_location_string(struct seq_file *m, const char *c)
|
|
{
|
|
while (*c) {
|
|
if (isalpha(*c) || *c == '.')
|
|
check_location(m, c);
|
|
else if (*c == '/' || *c == '-')
|
|
seq_printf(m, " at ");
|
|
c++;
|
|
}
|
|
}
|
|
|
|
|
|
/* ****************************************************************** */
|
|
|
|
static void get_location_code(struct seq_file *m, struct individual_sensor *s,
|
|
const char *loc)
|
|
{
|
|
if (!loc || !*loc) {
|
|
seq_printf(m, "---");/* does not have a location */
|
|
} else {
|
|
check_location_string(m, loc);
|
|
}
|
|
seq_putc(m, ' ');
|
|
}
|
|
/* ****************************************************************** */
|
|
/* INDICATORS - Tone Frequency */
|
|
/* ****************************************************************** */
|
|
static ssize_t ppc_rtas_tone_freq_write(struct file *file,
|
|
const char __user *buf, size_t count, loff_t *ppos)
|
|
{
|
|
u64 freq;
|
|
int error = parse_number(buf, count, &freq);
|
|
if (error)
|
|
return error;
|
|
|
|
rtas_tone_frequency = freq; /* save it for later */
|
|
error = rtas_call(rtas_token("set-indicator"), 3, 1, NULL,
|
|
TONE_FREQUENCY, 0, freq);
|
|
if (error)
|
|
printk(KERN_WARNING "error: setting tone frequency returned: %s\n",
|
|
ppc_rtas_process_error(error));
|
|
return count;
|
|
}
|
|
/* ****************************************************************** */
|
|
static int ppc_rtas_tone_freq_show(struct seq_file *m, void *v)
|
|
{
|
|
seq_printf(m, "%lu\n", rtas_tone_frequency);
|
|
return 0;
|
|
}
|
|
/* ****************************************************************** */
|
|
/* INDICATORS - Tone Volume */
|
|
/* ****************************************************************** */
|
|
static ssize_t ppc_rtas_tone_volume_write(struct file *file,
|
|
const char __user *buf, size_t count, loff_t *ppos)
|
|
{
|
|
u64 volume;
|
|
int error = parse_number(buf, count, &volume);
|
|
if (error)
|
|
return error;
|
|
|
|
if (volume > 100)
|
|
volume = 100;
|
|
|
|
rtas_tone_volume = volume; /* save it for later */
|
|
error = rtas_call(rtas_token("set-indicator"), 3, 1, NULL,
|
|
TONE_VOLUME, 0, volume);
|
|
if (error)
|
|
printk(KERN_WARNING "error: setting tone volume returned: %s\n",
|
|
ppc_rtas_process_error(error));
|
|
return count;
|
|
}
|
|
/* ****************************************************************** */
|
|
static int ppc_rtas_tone_volume_show(struct seq_file *m, void *v)
|
|
{
|
|
seq_printf(m, "%lu\n", rtas_tone_volume);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ppc_rtas_rmo_buf_show() - Describe RTAS-addressable region for user space.
|
|
*
|
|
* Base + size description of a range of RTAS-addressable memory set
|
|
* aside for user space to use as work area(s) for certain RTAS
|
|
* functions. User space accesses this region via /dev/mem. Apart from
|
|
* security policies, the kernel does not arbitrate or serialize
|
|
* access to this region, and user space must ensure that concurrent
|
|
* users do not interfere with each other.
|
|
*/
|
|
static int ppc_rtas_rmo_buf_show(struct seq_file *m, void *v)
|
|
{
|
|
seq_printf(m, "%016lx %x\n", rtas_rmo_buf, RTAS_USER_REGION_SIZE);
|
|
return 0;
|
|
}
|