// 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_function_token(RTAS_FN_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_function_token(RTAS_FN_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_function_token(RTAS_FN_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_function_token(RTAS_FN_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", 

Lines 1–500 of 769. Load more