lm-sensors/lib/proc.c

/*
    proc.c - Part of libsensors, a Linux library for reading sensor data.
    Copyright (c) 1998, 1999  Frodo Looijaard <frodol@dds.nl>

    This program 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 Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program 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 this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <sys/sysctl.h>
#include "kernel/include/sensors.h"
#include "data.h"
#include "error.h"
#include "access.h"
#include "general.h"
#include <limits.h>
#include <dirent.h>

/* OK, this proves one thing: if there are too many chips detected, we get in
   trouble. The limit is around 4096/sizeof(struct sensors_chip_data), which
   works out to about 100 entries right now. That seems sensible enough,
   but if we ever get at the point where more chips can be detected, we must
   enlarge buf, and check that sysctl can handle larger buffers. */

#define BUF_LEN 4096

static char buf[BUF_LEN];

sensors_proc_chips_entry *sensors_proc_chips;
int sensors_proc_chips_count, sensors_proc_chips_max;
int sensors_sys_chips_count, sensors_sys_chips_max;

sensors_bus *sensors_sys_bus;
int sensors_sys_bus_count, sensors_sys_bus_max;
sensors_bus *sensors_proc_bus;
int sensors_proc_bus_count, sensors_proc_bus_max;

static int sensors_get_chip_id(sensors_chip_name name);

int foundsysfs=0;
char sysfsmount[NAME_MAX];

#define add_proc_chips(el) sensors_add_array_el(el,\
                                       (void **) &sensors_proc_chips,\
                                       &sensors_proc_chips_count,\
                                       &sensors_proc_chips_max,\
                                       sizeof(struct sensors_proc_chips_entry))

#define add_proc_bus(el) sensors_add_array_el(el,\
                                       (void **) &sensors_proc_bus,\
                                       &sensors_proc_bus_count,\
                                       &sensors_proc_bus_max,\
                                       sizeof(struct sensors_bus))

/* This reads /proc/sys/dev/sensors/chips into memory */
int sensors_read_proc_chips(void)
{
	struct dirent *de;
	DIR *dir;
	FILE *f;
	char dev[NAME_MAX], fstype[NAME_MAX], sysfs[NAME_MAX], n[NAME_MAX];
	char dirname[NAME_MAX];
	int res;

	int name[3] = { CTL_DEV, DEV_SENSORS, SENSORS_CHIPS };
	int buflen = BUF_LEN;
	char *bufptr = buf;
	sensors_proc_chips_entry entry;
	int lineno;

	/* First figure out where sysfs was mounted */
	if ((f = fopen("/proc/mounts", "r")) == NULL)
		goto proc;
	while (fgets(n, NAME_MAX, f)) {
		sscanf(n, "%[^ ] %[^ ] %[^ ] %*s\n", dev, sysfs, fstype);
		if (strcasecmp(fstype, "sysfs") == 0) {
			foundsysfs++;
			break;
		}
	}
	fclose(f);
	if (! foundsysfs)
		goto proc;
	strcpy(sysfsmount, sysfs);
	strcat(sysfs, "/bus/i2c/devices");

	/* Then read from it */
	dir = opendir(sysfs);
	if (! dir)
		goto proc;

	while ((de = readdir(dir)) != NULL) {
		if (!strcmp(de->d_name, "."))
			continue;
		if (!strcmp(de->d_name, ".."))
			continue;
/*
		if (de->d_type != DT_DIR && de->d_type != DT_LNK)
			continue;
*/

		strcpy(n, sysfs);
		strcat(n, "/");
		strcat(n, de->d_name);
		strcpy(dirname, n);
		strcat(n, "/name");

		if ((f = fopen(n, "r")) != NULL) {
			char	x[120];
			fscanf(f, "%[a-zA-z0-9_]", x);
			/* HACK */ strcat(x, "-*");
			if ((res = sensors_parse_chip_name(x, &entry.name))) {
				char	em[NAME_MAX + 20];
				strcpy(em, "Parsing ");
				strcat(em, n);
				sensors_parse_error(em, 0);
				return res;
			}
			entry.name.busname = strdup(dirname);
			sscanf(de->d_name, "%x-%x", &entry.name.bus, &entry.name.addr);
			add_proc_chips(&entry);
			fclose(f);
		}
	}
	closedir(dir);
	return 0;

proc:

  if (sysctl(name, 3, bufptr, &buflen, NULL, 0))
    return -SENSORS_ERR_PROC;

  lineno = 1;
  while (buflen >= sizeof(struct i2c_chips_data)) {
    if ((res = 
          sensors_parse_chip_name(((struct i2c_chips_data *) bufptr)->name, 
                                   &entry.name))) {
      sensors_parse_error("Parsing /proc/sys/dev/sensors/chips",lineno);
      return res;
    }
    entry.sysctl = ((struct i2c_chips_data *) bufptr)->sysctl_id;
    add_proc_chips(&entry);
    bufptr += sizeof(struct i2c_chips_data);
    buflen -= sizeof(struct i2c_chips_data);
    lineno++;
  }
  return 0;
}

int sensors_read_proc_bus(void)
{
	struct dirent *de;
	DIR *dir;
	FILE *f;
	char line[255];
	char *border;
	sensors_bus entry;
	int lineno;
	char sysfs[NAME_MAX], n[NAME_MAX];
	char dirname[NAME_MAX];

	if(foundsysfs) {
		strcpy(sysfs, sysfsmount);
		strcat(sysfs, "/class/i2c-adapter");
		/* Then read from it */
		dir = opendir(sysfs);
		if (! dir)
			goto proc;

		while ((de = readdir(dir)) != NULL) {
			if (!strcmp(de->d_name, "."))
				continue;
			if (!strcmp(de->d_name, ".."))
				continue;

			strcpy(n, sysfs);
			strcat(n, "/");
			strcat(n, de->d_name);
			strcpy(dirname, n);
			strcat(n, "/device/name");

printf("opening %s\n", n);
			if ((f = fopen(n, "r")) != NULL) {
				char	x[120];
				fgets(x, 120, f);
				fclose(f);
				if((border = index(x, '\n')) != NULL)
					*border = 0;
				entry.adapter=strdup(x);
				if(!strncmp(x, "ISA ", 4)) {
					entry.number = SENSORS_CHIP_NAME_BUS_ISA;
					entry.algorithm = "ISA bus algorithm";
				} else if(!sscanf(de->d_name, "i2c-%x", &entry.number)) {
					entry.number = SENSORS_CHIP_NAME_BUS_DUMMY;
					entry.algorithm = "Dummy bus algorithm";
				} else
					entry.algorithm = "Unavailable from sysfs";
printf("adding bus adap %s algo %s number %d\n", entry.adapter, entry.algorithm, entry.number);
				add_proc_bus(&entry);
			}
		}
		closedir(dir);
		return 0;
	}

proc:

  f = fopen("/proc/bus/i2c","r");
  if (!f)
    return -SENSORS_ERR_PROC;
  lineno=1;
  while (fgets(line,255,f)) {
    if (strlen(line) > 0)
      line[strlen(line)-1] = '\0';
    if (! (border = rindex(line,'\t')))
      goto ERROR;
    if (! (entry.algorithm = strdup(border+1)))
      goto FAT_ERROR;
    *border='\0';
    if (! (border = rindex(line,'\t')))
      goto ERROR;
    if (! (entry.adapter = strdup(border + 1)))
      goto FAT_ERROR;
    *border='\0';
    if (! (border = rindex(line,'\t')))
      goto ERROR;
    *border='\0';
    if (strncmp(line,"i2c-",4))
      goto ERROR;
    if (sensors_parse_i2cbus_name(line,&entry.number))
      goto ERROR;
    sensors_strip_of_spaces(entry.algorithm);
    sensors_strip_of_spaces(entry.adapter);
    add_proc_bus(&entry);
    lineno++;
  }
  fclose(f);
  return 0;
FAT_ERROR:
  sensors_fatal_error("sensors_read_proc_bus","Allocating entry");
ERROR:
  sensors_parse_error("Parsing /proc/bus/i2c",lineno);
  fclose(f);
  return -SENSORS_ERR_PROC;
}
    

/* This returns the first detected chip which matches the name */
int sensors_get_chip_id(sensors_chip_name name)
{
  int i;
  for (i = 0; i < sensors_proc_chips_count; i++)
    if (sensors_match_chip(name, sensors_proc_chips[i].name))
      return sensors_proc_chips[i].sysctl;
  return -SENSORS_ERR_NO_ENTRY;
}
  
/* This reads a feature /proc file */
int sensors_read_proc(sensors_chip_name name, int feature, double *value)
{
	int				sysctl_name[4] = { CTL_DEV, DEV_SENSORS };
	const sensors_chip_feature	*the_feature;
	int				buflen = BUF_LEN;
	int				mag;
	char				n[NAME_MAX];
	FILE				*f;

	if(!foundsysfs)
		if ((sysctl_name[2] = sensors_get_chip_id(name)) < 0)
			return sysctl_name[2];
	if (! (the_feature = sensors_lookup_feature_nr(name.prefix,feature)))
		return -SENSORS_ERR_NO_ENTRY;
	if(foundsysfs) {
		strcpy(n, name.busname);
		strcat(n, "/");
		if(the_feature->sysname != NULL)
			strcat(n, the_feature->sysname);
		else
			strcat(n, the_feature->name);
		if ((f = fopen(n, "r")) != NULL) {
			fscanf(f, "%lf", value);
			fclose(f);
			if(the_feature->sysscaling)
				mag = the_feature->sysscaling;
			else
				mag = the_feature->scaling;
			for (; mag > 0; mag --)
				*value /= 10.0;
	//		fprintf(stderr, "Feature %s value %lf scale %d offset %d\n",
	//			the_feature->name, *value,
	//			the_feature->scaling, the_feature->offset);
			return 0;
		} else
			return -SENSORS_ERR_PROC;
	} else {
		sysctl_name[3] = the_feature->sysctl;
		if (sysctl(sysctl_name, 4, buf, &buflen, NULL, 0))
			return -SENSORS_ERR_PROC;
		*value = *((long *) (buf + the_feature->offset));
		for (mag = the_feature->scaling; mag > 0; mag --)
			*value /= 10.0;
		for (; mag < 0; mag ++)
			*value *= 10.0;
	}
	return 0;
}
  
int sensors_write_proc(sensors_chip_name name, int feature, double value)
{
  int sysctl_name[4] = { CTL_DEV, DEV_SENSORS };
  const sensors_chip_feature *the_feature;
  int buflen = BUF_LEN;
  int mag;
 
  if ((sysctl_name[2] = sensors_get_chip_id(name)) < 0)
    return sysctl_name[2];
  if (! (the_feature = sensors_lookup_feature_nr(name.prefix,feature)))
    return -SENSORS_ERR_NO_ENTRY;
  sysctl_name[3] = the_feature->sysctl;
  if (sysctl(sysctl_name, 4, buf, &buflen, NULL, 0))
    return -SENSORS_ERR_PROC;
  if (sysctl_name[0] != CTL_DEV) { sysctl_name[0] = CTL_DEV ; }
  for (mag = the_feature->scaling; mag > 0; mag --)
    value *= 10.0;
  for (; mag < 0; mag ++)
    value /= 10.0;
  * ((long *) (buf + the_feature->offset)) = (long) value;
  buflen = the_feature->offset + sizeof(long);
  if (sysctl(sysctl_name, 4, NULL, 0, buf, buflen))
    return -SENSORS_ERR_PROC;
  return 0;
}