274 lines
6.8 KiB
C
274 lines
6.8 KiB
C
/*
|
|
* sysfs_class.c
|
|
*
|
|
* Generic class utility functions for libsysfs
|
|
*
|
|
* Copyright (C) 2003 International Business Machines, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
#include "libsysfs.h"
|
|
#include "sysfs.h"
|
|
|
|
/**
|
|
* sysfs_close_class_device: closes a single class device.
|
|
* @dev: class device to close.
|
|
*/
|
|
void sysfs_close_class_device(struct sysfs_class_device *dev)
|
|
{
|
|
if (dev != NULL) {
|
|
if (dev->directory != NULL)
|
|
sysfs_close_directory(dev->directory);
|
|
if (dev->sysdevice != NULL)
|
|
sysfs_close_device(dev->sysdevice);
|
|
if (dev->driver != NULL)
|
|
sysfs_close_driver(dev->driver);
|
|
free(dev);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* sysfs_close_class: close single class
|
|
* @class: class structure
|
|
*/
|
|
void sysfs_close_class(struct sysfs_class *cls)
|
|
{
|
|
struct sysfs_class_device *cur = NULL, *next = NULL;
|
|
|
|
if (cls != NULL) {
|
|
if (cls->directory != NULL)
|
|
sysfs_close_directory(cls->directory);
|
|
for (cur = cls->devices; cur != NULL; cur = next) {
|
|
next = cur->next;
|
|
sysfs_close_class_device(cur);
|
|
}
|
|
free(cls);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* alloc_class_device: mallocs and initializes new class device struct.
|
|
* returns sysfs_class_device or NULL.
|
|
*/
|
|
static struct sysfs_class_device *alloc_class_device(void)
|
|
{
|
|
return (struct sysfs_class_device *)
|
|
calloc(1, sizeof(struct sysfs_class_device));
|
|
}
|
|
|
|
/**
|
|
* alloc_class: mallocs new class structure
|
|
* returns sysfs_class struct or NULL
|
|
*/
|
|
static struct sysfs_class *alloc_class(void)
|
|
{
|
|
return (struct sysfs_class *)calloc(1, sizeof(struct sysfs_class));
|
|
}
|
|
|
|
/**
|
|
* open_class_dir: opens up sysfs class directory
|
|
* returns sysfs_directory struct with success and NULL with error
|
|
*/
|
|
static struct sysfs_directory *open_class_dir(const char *name)
|
|
{
|
|
struct sysfs_directory *classdir = NULL;
|
|
char classpath[SYSFS_PATH_MAX];
|
|
|
|
if (name == NULL) {
|
|
errno = EINVAL;
|
|
return NULL;
|
|
}
|
|
|
|
memset(classpath, 0, SYSFS_PATH_MAX);
|
|
if ((sysfs_get_mnt_path(classpath, SYSFS_PATH_MAX)) != 0) {
|
|
dprintf(stderr, "Sysfs not supported on this system\n");
|
|
return NULL;
|
|
}
|
|
|
|
strcat(classpath, SYSFS_CLASS_DIR);
|
|
strcat(classpath, "/");
|
|
strcat(classpath, name);
|
|
classdir = sysfs_open_directory(classpath);
|
|
if (classdir == NULL) {
|
|
errno = EINVAL;
|
|
dprintf(stderr,"Class %s not supported on this system\n",
|
|
name);
|
|
return NULL;
|
|
}
|
|
if ((sysfs_read_directory(classdir)) != 0) {
|
|
dprintf(stderr, "Error reading %s class dir %s\n", name,
|
|
classpath);
|
|
sysfs_close_directory(classdir);
|
|
return NULL;
|
|
}
|
|
|
|
return classdir;
|
|
}
|
|
|
|
/**
|
|
* sysfs_open_class_device: Opens and populates class device
|
|
* @path: path to class device.
|
|
* returns struct sysfs_class_device with success and NULL with error.
|
|
*/
|
|
struct sysfs_class_device *sysfs_open_class_device(const char *path)
|
|
{
|
|
struct sysfs_class_device *cdev = NULL;
|
|
struct sysfs_directory *dir = NULL, *cur = NULL;
|
|
struct sysfs_dlink *curl = NULL;
|
|
struct sysfs_device *sdev = NULL;
|
|
struct sysfs_driver *drv = NULL;
|
|
char temp[SYSFS_NAME_LEN];
|
|
|
|
if (path == NULL) {
|
|
errno = EINVAL;
|
|
return NULL;
|
|
}
|
|
cdev = alloc_class_device();
|
|
if (cdev == NULL) {
|
|
perror("malloc");
|
|
return NULL;
|
|
}
|
|
memset(temp, 0, SYSFS_NAME_LEN);
|
|
if ((sysfs_get_name_from_path(path, temp, SYSFS_NAME_LEN)) != 0) {
|
|
errno = EINVAL;
|
|
dprintf(stderr, "Invalid class device path %s\n", path);
|
|
sysfs_close_class_device(cdev);
|
|
return NULL;
|
|
}
|
|
strcpy(cdev->name, temp);
|
|
|
|
dir = sysfs_open_directory(path);
|
|
if (dir == NULL) {
|
|
dprintf(stderr, "Error opening class device at %s\n", path);
|
|
sysfs_close_class_device(cdev);
|
|
return NULL;
|
|
}
|
|
if ((sysfs_read_directory(dir)) != 0) {
|
|
dprintf(stderr, "Error reading class device at %s\n", path);
|
|
sysfs_close_directory(dir);
|
|
sysfs_close_class_device(cdev);
|
|
return NULL;
|
|
}
|
|
cdev->directory = dir;
|
|
|
|
cur = cdev->directory->subdirs;
|
|
while(cur != NULL) {
|
|
sysfs_read_directory(cur);
|
|
cur = cur->next;
|
|
}
|
|
/* get driver and device, if implemented */
|
|
curl = cdev->directory->links;
|
|
while (curl != NULL) {
|
|
if (strncmp(curl->name, SYSFS_DEVICES_NAME, 6) == 0) {
|
|
sdev = sysfs_open_device(curl->target->path);
|
|
if (sdev != NULL) {
|
|
cdev->sysdevice = sdev;
|
|
if (cdev->driver != NULL)
|
|
sdev->driver = cdev->driver;
|
|
}
|
|
} else if (strncmp(curl->name, SYSFS_DRIVERS_NAME, 6) == 0) {
|
|
drv = sysfs_open_driver(curl->target->path);
|
|
if (drv != NULL) {
|
|
cdev->driver = drv;
|
|
if (cdev->sysdevice != NULL)
|
|
drv->device = cdev->sysdevice;
|
|
}
|
|
}
|
|
curl = curl->next;
|
|
}
|
|
return cdev;
|
|
}
|
|
|
|
/**
|
|
* add_dev_to_class: adds a class device to class list
|
|
* @class: class to add the device
|
|
* @dev: device to add
|
|
*/
|
|
static void add_dev_to_class(struct sysfs_class *cls,
|
|
struct sysfs_class_device *dev)
|
|
{
|
|
if (cls != NULL && dev != NULL) {
|
|
dev->next = cls->devices;
|
|
cls->devices = dev;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* get_all_class_devices: gets all devices for class
|
|
* @class: class to get devices for
|
|
* returns 0 with success and -1 with failure
|
|
*/
|
|
static int get_all_class_devices(struct sysfs_class *cls)
|
|
{
|
|
struct sysfs_class_device *dev = NULL;
|
|
struct sysfs_directory *cur = NULL, *next = NULL;
|
|
|
|
if (cls == NULL || cls->directory == NULL) {
|
|
errno = EINVAL;
|
|
return -1;
|
|
}
|
|
for (cur = cls->directory->subdirs; cur != NULL; cur = next) {
|
|
next = cur->next;
|
|
dev = sysfs_open_class_device(cur->path);
|
|
if (dev == NULL) {
|
|
dprintf(stderr, "Error opening device at %s\n",
|
|
cur->path);
|
|
continue;
|
|
}
|
|
add_dev_to_class(cls, dev);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* sysfs_open_class: opens specific class and all its devices on system
|
|
* returns sysfs_class structure with success or NULL with error.
|
|
*/
|
|
struct sysfs_class *sysfs_open_class(const char *name)
|
|
{
|
|
struct sysfs_class *cls = NULL;
|
|
struct sysfs_directory *classdir = NULL;
|
|
|
|
if (name == NULL) {
|
|
errno = EINVAL;
|
|
return NULL;
|
|
}
|
|
|
|
cls = alloc_class();
|
|
if (cls == NULL) {
|
|
perror("malloc");
|
|
return NULL;
|
|
}
|
|
strcpy(cls->name, name);
|
|
classdir = open_class_dir(name);
|
|
if (classdir == NULL) {
|
|
dprintf(stderr,
|
|
"Invalid class, %s not supported on this system\n",
|
|
name);
|
|
sysfs_close_class(cls);
|
|
return NULL;
|
|
}
|
|
cls->directory = classdir;
|
|
if ((get_all_class_devices(cls)) != 0) {
|
|
dprintf(stderr, "Error reading %s class devices\n", name);
|
|
sysfs_close_class(cls);
|
|
return NULL;
|
|
}
|
|
|
|
return cls;
|
|
}
|