psvcobj.c revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 1999-2003 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* This file consists of routines to manage objects in the
* "Platform Environment Services Framework". The classes
* and subclasses are defined by attributes and methods.
* The objects, and their initial, static, attribute values are
* specified in a configuration file, "psvcobj.conf".
* psvc_init() reads the configuration file and creates a repository
* of environmental objects in memory. A client application may manipulate
* these objects by invoking the psvc_get_attr(), and psvc_set_attr()
* routines with the object's string ID specified as an argument.
*/
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <unistd.h>
#include <stropts.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <syslog.h>
#include <stdarg.h>
#include <pthread.h>
#include <sys/systeminfo.h>
#define LIBRARY_BUILD 1
#include <psvc_objects.h>
#include <psvc_objects_class.h>
/* Mutex used for Daktari Fan speed reading */
/*LINTLIBRARY*/
#define BUFSZ 512
#define CLASS_MAX 12
#define SUBCLASS_MAX 10
void *attrp);
/*
* Method lookup tables
* Update when adding classes or subclasses.
*/
/* Lookup method by class, subclass, used when calling method */
char *, EObj_t **) = {
{i_psvc_constructor_0_0, i_psvc_constructor_0_1, 0, 0, 0, 0, 0, 0, 0, 0},
{i_psvc_constructor_1_0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
0, 0, 0, 0, 0, 0, 0},
{i_psvc_constructor_3_0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{i_psvc_constructor_4_0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{i_psvc_constructor_5_0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{i_psvc_constructor_6_0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{i_psvc_constructor_7_0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{i_psvc_constructor_8_0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{i_psvc_constructor_9_0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{i_psvc_constructor_10_0, i_psvc_constructor_10_1, 0, 0, 0, 0, 0, 0, 0, 0},
};
static struct bits {
char *label;
} feature_bits[] = {
{PSVC_DEV_PERM, "PERM="},
{PSVC_DEV_HOTPLUG, "HOTPLUG="},
{PSVC_DEV_OPTION, "OPTION="},
{PSVC_DEV_PRIMARY, "PRIMARY="},
{PSVC_DEV_SECONDARY, "SECONDARY="},
{PSVC_DEV_RDONLY, "RDONLY="},
{PSVC_DEV_RDWR, "RDWR="},
{PSVC_DEV_FRU, "FRU="},
{PSVC_LOW_WARN, "LO_WARN_MASK="},
{PSVC_LOW_SHUT, "LO_SHUT_MASK="},
{PSVC_HIGH_WARN, "HI_WARN_MASK="},
{PSVC_HIGH_SHUT, "HI_SHUT_MASK="},
{PSVC_CONVERSION_TABLE, "CONV_TABLE="},
{PSVC_OPT_TEMP, "OPT_TEMP_MASK="},
{PSVC_HW_LOW_SHUT, "HW_LO_MASK="},
{PSVC_HW_HIGH_SHUT, "HW_HI_MASK="},
{PSVC_FAN_DRIVE_PR, "FAN_DRIVE_PR="},
{PSVC_TEMP_DRIVEN, "TEMP_DRIVEN="},
{PSVC_SPEED_CTRL_PR, "SPEED_CTRL_PR="},
{PSVC_FAN_ON_OFF, "FAN_ON_OFF="},
{PSVC_CLOSED_LOOP_CTRL, "CLOSED_LOOP_CTRL="},
{PSVC_FAN_DRIVE_TABLE_PR, "FAN_DRIVE_TABLE_PR="},
{PSVC_DIE_TEMP, "DIE_TEMP="},
{PSVC_AMB_TEMP, "AMB_TEMP="},
{PSVC_DIGI_SENSOR, "DIGI_SENSOR="},
{PSVC_BI_STATE, "BI_STATE="},
{PSVC_TRI_STATE, "TRI_STATE="},
{PSVC_GREEN, "GREEN="},
{PSVC_AMBER, "AMBER="},
{PSVC_OUTPUT, "OUTPUT="},
{PSVC_INPUT, "INPUT="},
{PSVC_BIDIR, "BIDIR="},
{PSVC_BIT_POS, "BIT_POS="},
{PSVC_VAL_POS, "VAL_POS="},
{PSVC_NORMAL_POS_AV, "NORMAL_POS_AV="},
{PSVC_DIAG_POS_AV, "DIAG_POS_AV="},
{PSVC_LOCK_POS_AV, "LOCK_POS_AV="},
{PSVC_OFF_POS_AV, "OFF_POS_AV="},
{PSVC_GPIO_PORT, "GPIO_PORT="},
{PSVC_GPIO_REG, "GPIO_REG="}
};
#define ASSOC_STR_TAB_SIZE 33
static char *assoc_str_tab[] = {
"PSVC_PRESENCE_SENSOR", /* 0 */
"PSVC_FAN_ONOFF_SENSOR", /* 1 */
"PSVC_FAN_SPEED_TACHOMETER", /* 2 */
"PSVC_FAN_PRIM_SEC_SELECTOR", /* 3 */
"PSVC_DEV_TEMP_SENSOR", /* 4 */
"PSVC_FAN_DRIVE_CONTROL", /* 5 */
"PSVC_KS_NORMAL_POS_SENSOR", /* 6 */
"PSVC_KS_DIAG_POS_SENSOR", /* 7 */
"PSVC_KS_LOCK_POS_SENSOR", /* 8 */
"PSVC_KS_OFF_POS_SENSOR", /* 9 */
"PSVC_SLOT_FAULT_LED", /* 10 */
"PSVC_SLOT_REMOVE_LED", /* 11 */
"PSVC_TS_OVERTEMP_LED", /* 12 */
"PSVC_PS_I_SENSOR", /* 13 */
"PSVC_DEV_FAULT_SENSOR", /* 14 */
"PSVC_DEV_FAULT_LED", /* 15 */
"PSVC_TABLE", /* 16 */
"PSVC_PARENT", /* 17 */
"PSVC_CPU", /* 18 */
"PSVC_ALTERNATE", /* 19 */
"PSVC_HOTPLUG_ENABLE_SWITCH", /* 20 */
"PSVC_PS", /* 21 */
"PSVC_FAN", /* 22 */
"PSVC_TS", /* 23 */
"PSVC_DISK", /* 24 */
"PSVC_LED", /* 25 */
"PSVC_FSP_LED", /* 26 */
"PSVC_KEYSWITCH", /* 27 */
"PSVC_PCI_CARD", /* 28 */
"PSVC_PHYSICAL_DEVICE", /* 29 */
"PSVC_DEV_TYPE_SENSOR", /* 30 */
"PSVC_FAN_TRAY_FANS", /* 31 */
"PSVC_FRU" /* 32 */
};
static struct bitfield {
char *label;
char *format;
} addr_fields[] =
{
};
/*
* record format is:
* pathname label1=val1,label2=val2,label3=val3
* Must be a space after the pathname and a comma between variables.
*/
static char *
{
char *start;
return (start);
do {
++start;
return (start);
return (NULL);
}
static int32_t
{
char *val;
int32_t i;
char label[64];
int val_size;
int label_size;
switch (attr_id) {
case PSVC_CLASS_ATTR:
case PSVC_SUBCLASS_ATTR:
case PSVC_INSTANCE_ATTR:
case PSVC_LO_WARN_ATTR:
case PSVC_LO_SHUT_ATTR:
case PSVC_HI_WARN_ATTR:
case PSVC_HI_SHUT_ATTR:
case PSVC_HW_HI_SHUT_ATTR:
case PSVC_HW_LO_SHUT_ATTR:
case PSVC_OPTIMAL_TEMP_ATTR:
return (PSVC_FAILURE);
}
if (found == 0)
break;
case PSVC_SETPOINT_ATTR:
case PSVC_HYSTERESIS_ATTR:
case PSVC_LOOPGAIN_ATTR:
case PSVC_LOOPBIAS_ATTR:
return (PSVC_FAILURE);
}
if (found == 0)
break;
case PSVC_LED_COLOR_ATTR:
case PSVC_LED_IS_LOCATOR_ATTR:
return (PSVC_FAILURE);
}
i - label_size);
} else
if (found == 0)
break;
case PSVC_FEATURES_ATTR:
result = 0;
for (i = 0; i < FEATURE_BITS; ++i) {
continue;
"%d", &temp32);
if (found != 0) {
if (temp32 == 1)
}
}
break;
case PSVC_ADDR_SPEC_ATTR:
result = 0;
for (i = 0; i < ADDR_BITFIELDS; ++i) {
continue;
if (found != 0) {
}
}
break;
default:
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
}
/* determine number of records in file section */
static int32_t
{
long first_record;
char *ret;
break;
++count;
}
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
}
/* determine number of records in file section */
static int32_t
{
long first_record;
char *ret;
++count;
}
#ifdef lint
#endif
return (PSVC_SUCCESS);
}
/* determine number of records in a table */
static int32_t
{
long first_record;
int ret;
break;
++count;
}
if (ret != 1) {
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
}
/*
* Find number of matches to an antecedent_id of a certain
* association type.
*/
static int32_t
{
int i;
*matches = 0;
return (PSVC_FAILURE);
}
== 0)
++*matches;
}
}
return (PSVC_SUCCESS);
}
/*
* Find 1st m matches to an antecedent_id of a certain
* association type.
* Returns zero for success, -1 for failure.
*/
static int32_t
{
int i;
int found = 0;
return (-1);
}
== 0) {
return (0);
}
++found;
}
}
}
return (-1);
}
static int32_t
void *value)
{
int32_t i;
table_id) == 0)
break;
}
}
return (PSVC_FAILURE);
return (PSVC_FAILURE);
return (PSVC_FAILURE);
case 0:
break;
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
case 7:
break;
default:
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
}
{
if (attr_valuep == NULL) {
return (PSVC_FAILURE);
}
switch (attr_id) {
case PSVC_TABLE_VALUE_ATTR:
break;
case PSVC_ASSOC_MATCHES_ATTR:
break;
case PSVC_ASSOC_ID_ATTR:
break;
default:
if (status != PSVC_SUCCESS) {
return (status);
}
}
if (status != PSVC_SUCCESS) {
return (status);
}
return (status);
}
{
if (status != PSVC_SUCCESS) {
return (status);
}
if (attr_valuep == NULL) {
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS) {
return (status);
}
return (status);
}
static int32_t
{
char *mid;
char *parent_id;
*pr = PSVC_PRESENT;
return (PSVC_SUCCESS);
}
&parent_id);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
return (status);
}
}
if (matches != 0) {
PSVC_PRESENCE_SENSOR, 0, &mid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
if (active_low)
if (value == 0)
*pr = PSVC_PRESENT;
else
*pr = PSVC_ABSENT;
else
if (value == 0)
*pr = PSVC_ABSENT;
else
*pr = PSVC_PRESENT;
if (status != PSVC_SUCCESS)
return (status);
else
if (active_low)
if (value_8bit_inv == 0)
*pr = PSVC_PRESENT;
else
*pr = PSVC_ABSENT;
else
if (value_8bit_inv == 0)
*pr = PSVC_ABSENT;
else
*pr = PSVC_PRESENT;
} else {
return (PSVC_FAILURE);
}
} else {
*pr = PSVC_PRESENT;
}
return (status);
}
static int32_t
{
char *tid;
char *physid;
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS) {
return (status);
}
if (status != PSVC_SUCCESS) {
return (status);
}
if (status != PSVC_SUCCESS) {
return (status);
}
PSVC_TABLE, &m);
return (status);
}
&tid);
}
return (status);
}
static int32_t
{
char *tid;
char *physid;
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS) {
return (status);
}
if (status != PSVC_SUCCESS) {
return (status);
}
if (status != PSVC_SUCCESS) {
return (status);
}
PSVC_TABLE, &m);
return (status);
}
&tid);
}
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
value);
if (status != PSVC_SUCCESS)
return (status);
int32_t m;
char *tid;
PSVC_TABLE, &m);
return (status);
}
&tid);
}
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
*value);
if (status != PSVC_SUCCESS)
return (status);
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
value);
if (status != PSVC_SUCCESS)
return (status);
int32_t m;
char *tid;
PSVC_TABLE, &m);
return (status);
}
&tid);
}
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
&bit_value);
if (status != PSVC_SUCCESS)
return (status);
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
return (status);
}
static int32_t
{
char *fan_tach;
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
int32_t m;
char *tid;
PSVC_TABLE, &m);
return (status);
}
&tid);
}
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
&bit_value);
if (status != PSVC_SUCCESS)
return (status);
if (active_low)
if (bit_value == 0)
else
else
if (bit_value == 0)
else
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
/*
* For Locator LEDs we ignore lit_count. RSC may have
* altered the LED state underneath us, So we should
* always just do what the user asked instead of trying
* to be smart.
*/
return (PSVC_SUCCESS);
/* Fall through case is when lit_count is 0 */
}
}
/*
* Flip the bit if necessary (for active_low devices,
* O ==> ON; 1 ==> OFF.
*/
bit_value ^= active_low;
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
&value);
if (status != PSVC_SUCCESS)
return (status);
switch (value) {
case 0:
break;
case 1:
break;
case 2:
break;
case 3:
break;
}
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
/* Fall through case is when lit_count is 0 */
}
value = 0;
value = 1;
value = 2;
value = 3;
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
value);
return (status);
}
static int32_t
{
char *sensorid;
char state[32];
return (PSVC_FAILURE);
}
if (matches == 1) {
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
return (PSVC_SUCCESS);
}
}
}
if (matches == 1) {
PSVC_KS_DIAG_POS_SENSOR, 0, &sensorid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
return (PSVC_SUCCESS);
}
}
}
if (matches == 1) {
PSVC_KS_LOCK_POS_SENSOR, 0, &sensorid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
return (PSVC_SUCCESS);
}
}
}
if (matches == 1) {
PSVC_KS_OFF_POS_SENSOR, 0, &sensorid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
return (PSVC_SUCCESS);
}
}
}
/* If we have fallen through till here, something's wrong */
return (PSVC_FAILURE);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
value);
if (status != PSVC_SUCCESS)
return (status);
int32_t m;
char *tid;
PSVC_TABLE, &m);
return (status);
}
PSVC_TABLE, 0, &tid);
}
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
value);
if (status != PSVC_SUCCESS)
return (status);
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
*value);
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
*value);
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
&bit_value);
if (status != PSVC_SUCCESS)
return (status);
if (active_low)
if (bit_value == 0)
else
else
if (bit_value == 0)
else
return (status);
}
static int32_t
{
char *physid;
return (PSVC_FAILURE);
}
if (active_low)
bit_value = 0;
else
bit_value = 1;
else
bit_value = 1;
else
bit_value = 0;
0, &physid);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
return (status);
}
/* LM75 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (status == -1) {
return (PSVC_FAILURE);
}
return (status);
}
/* MAX1617 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (status == -1) {
return (PSVC_FAILURE);
}
return (status);
}
/* PCF8591 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (status == -1) {
return (-1);
}
return (status);
}
/* SSC050 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* PCF8591 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* LTC1427 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (PSVC_FAILURE);
}
return (status);
}
/* PCF8591 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (PSVC_FAILURE);
}
return (status);
}
/* TDA8444 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (PSVC_FAILURE);
}
return (status);
}
/* LTC1427 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (PSVC_FAILURE);
}
return (status);
}
/* PCF8591 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (PSVC_FAILURE);
}
return (status);
}
/* TDA8444 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (PSVC_FAILURE);
}
return (status);
}
/* HPC3130 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* SSC050 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* HPC3130 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (bytemask != 0xFF) {
if (ret == -1) {
return (-1);
}
} else
tval = 0;
if (ret == -1) {
return (-1);
}
return (status);
}
/* SSC050 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (bytemask != 0xFF) {
if (ret == -1) {
return (-1);
}
} else
tval = 0;
if (ret == -1) {
return (-1);
}
return (status);
}
/* PCF8574 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* PCF8574 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* SSC050 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* PCF8574 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* PCF8574 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* SSC050 */
static int32_t
{
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* AT24 */
static int32_t
{
char path[1024];
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS) {
return (status);
}
if (fp == -1) {
return (PSVC_FAILURE);
}
if (ret == -1) {
return (-1);
}
return (status);
}
/* HPC3130 */
static int32_t
{
char path[1024];
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* LM75 */
static int32_t
{
char path[1024];
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS) {
return (status);
}
if (fp == -1) {
return (PSVC_FAILURE);
}
if (ret == -1) {
return (-1);
}
return (status);
}
/* LTC1427 */
static int32_t
{
char path[1024];
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS) {
return (status);
}
if (fp == -1) {
return (PSVC_FAILURE);
}
if (ret == -1) {
return (-1);
}
if (ret == -1) {
return (-1);
}
return (status);
}
/* MAX1617 */
static int32_t
{
char path[1024];
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS) {
return (status);
}
if (fp == -1) {
return (PSVC_FAILURE);
}
if (ret == -1) {
return (-1);
}
return (status);
}
/* PCF8574 */
static int32_t
{
char path[1024];
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS) {
return (status);
}
if (fp == -1) {
return (PSVC_FAILURE);
}
if (ret == -1) {
return (-1);
}
return (status);
}
/* PCF8591 */
static int32_t
{
char path[1024];
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* SSC050 */
static int32_t
{
char path[1024];
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* TDA8444 */
static int32_t
{
char path[1024];
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1)
return (PSVC_FAILURE);
if (ret == -1) {
return (-1);
}
return (status);
}
/* SSC100 */
static int32_t
{
char path[1024];
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS) {
return (status);
}
if (fp == -1) {
return (PSVC_FAILURE);
}
/*
* There are only a few register numbers that are valid numbers to
* read from. 0x10 is one of these registers. Any non-valid registers
* cause unknown behavior to the ssc100 device.
*/
if (ret == -1) {
return (-1);
}
return (status);
}
/*
* Find start of a section within the config file,
* Returns number of records in the section.
* FILE *fd is set to first data record within section.
*/
static int32_t
{
char *ret;
char name[32];
int found;
break;
}
return (-1);
}
if (found != 1) {
return (-1);
} else {
return (0);
}
}
/* compare routine for qsort of str_tbl */
static int32_t
{
}
/* compare routine for bsearch of str_tbl */
static int32_t
{
}
/*
* Determine the initial state of a device.
*/
static int32_t
{
char state[32];
state);
if (status != PSVC_SUCCESS)
return (status);
else
}
char state[32];
state);
if (status != PSVC_SUCCESS)
return (status);
}
return (status);
}
/*
* Return the object pointer for the object name passed in.
* Creates the object if this is the first access,
* Returns 0 if successful, -1 if not.
*/
static int32_t
{
char *start;
return (-1);
return (0);
}
}
}
return (-1);
}
return (PSVC_FAILURE);
}
if (found != 1) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS)
return (PSVC_FAILURE);
!= PSVC_SUCCESS)
return (PSVC_FAILURE);
if (ret != PSVC_SUCCESS) {
return (-1);
}
&presence);
return (ret);
}
}
return (-1);
}
/*
* Gets the device path associated with an object id.
* Returns 0 if successful, -1 if not.
*/
static int32_t
{
int i;
return (PSVC_SUCCESS);
}
}
return (PSVC_FAILURE);
}
/* Load the association table */
static int32_t
{
int found;
int i, j;
/*
* ignore count in the file, correct count is highest
* association id + 1, now figured when loading ASSOC_STR
* section.
*/
return (-1);
== NULL) {
return (-1);
}
for (i = 0; i < hp->assoc_count; ++i) {
break;
if (found != 2) {
return (-1);
}
(int (*)(const void *, const void *))
return (-1);
}
if (status != PSVC_SUCCESS)
return (status);
return (-1);
for (j = 0; j < count; ++j) {
ap->dependent_id);
if (found != 2) {
return (-1);
}
}
return (-1);
}
}
return (0);
}
/* Load the table of tables */
static int32_t
{
int i, j;
int found;
int ret;
return (PSVC_SUCCESS); /* no tables */
"TABLE_END");
return (status);
for (i = 0; i < table_count; ++i) {
int slot;
return (-1);
}
return (PSVC_FAILURE);
} else {
}
return (PSVC_FAILURE);
if (status != PSVC_SUCCESS)
return (status);
if (found != 2) {
return (-1);
}
/* allocate and load table */
return (-1);
}
switch (cell_type) {
case 0:
break;
case 1:
break;
case 2:
break;
case 3:
break;
case 4:
break;
case 5:
break;
case 6:
break;
case 7:
break;
default:
return (-1);
}
if (ret != 1) {
return (-1);
}
}
return (-1);
}
}
return (0);
}
static int32_t
{
name) == 0) {
return (PSVC_SUCCESS);
}
}
}
return (PSVC_SUCCESS);
}
static int32_t
void * attrp)
{
char *parent_id;
switch (attr_id) {
case PSVC_ADDR_SPEC_ATTR:
break;
case PSVC_CLASS_ATTR:
break;
case PSVC_SUBCLASS_ATTR:
break;
case PSVC_PRESENCE_ATTR:
break;
case PSVC_PREV_PRESENCE_ATTR:
break;
case PSVC_STATE_ATTR:
break;
case PSVC_PREV_STATE_ATTR:
break;
case PSVC_ENABLE_ATTR:
break;
case PSVC_FAULTID_ATTR:
break;
case PSVC_FEATURES_ATTR:
break;
case PSVC_LABEL_ATTR:
break;
case PSVC_FRUID_ATTR:
PSVC_PARENT, 0, &parent_id);
if (status != PSVC_SUCCESS)
return (status);
if (status != PSVC_SUCCESS)
return (status);
}
break;
case PSVC_INSTANCE_ATTR:
break;
default:
return (PSVC_FAILURE);
}
return (status);
}
static int32_t
void * attrp)
{
switch (attr_id) {
case PSVC_PREV_PRESENCE_ATTR:
break;
case PSVC_STATE_ATTR:
break;
case PSVC_ENABLE_ATTR:
break;
case PSVC_FAULTID_ATTR:
break;
default:
return (PSVC_FAILURE);
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_SENSOR_VALUE_ATTR:
case PSVC_LO_WARN_ATTR:
return (status);
case PSVC_LO_SHUT_ATTR:
return (status);
case PSVC_HI_WARN_ATTR:
return (status);
case PSVC_HI_SHUT_ATTR:
return (status);
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_SENSOR_VALUE_ATTR:
case PSVC_LO_WARN_ATTR:
return (status);
case PSVC_LO_SHUT_ATTR:
return (status);
case PSVC_HI_WARN_ATTR:
return (status);
case PSVC_HI_SHUT_ATTR:
return (status);
case PSVC_OPTIMAL_TEMP_ATTR:
return (status);
case PSVC_HW_HI_SHUT_ATTR:
return (status);
case PSVC_HW_LO_SHUT_ATTR:
return (status);
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_LO_WARN_ATTR:
return (status);
case PSVC_LO_SHUT_ATTR:
return (status);
case PSVC_HI_WARN_ATTR:
return (status);
case PSVC_HI_SHUT_ATTR:
return (status);
case PSVC_OPTIMAL_TEMP_ATTR:
return (status);
case PSVC_HW_HI_SHUT_ATTR:
return (status);
case PSVC_HW_LO_SHUT_ATTR:
return (status);
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_SENSOR_VALUE_ATTR:
case PSVC_SETPOINT_ATTR:
return (status);
case PSVC_HYSTERESIS_ATTR:
return (status);
case PSVC_LOOPGAIN_ATTR:
return (status);
case PSVC_LOOPBIAS_ATTR:
return (status);
return (status);
return (status);
}
return (status);
}
static int32_t
{
switch (attr_id) {
return (status);
return (status);
case PSVC_SETPOINT_ATTR:
return (status);
}
return (PSVC_SUCCESS);
}
static int32_t
{
switch (attr_id) {
case PSVC_LED_STATE_ATTR:
case PSVC_STATE_ATTR:
case PSVC_LED_COLOR_ATTR:
return (status);
case PSVC_LIT_COUNT_ATTR:
return (status);
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_LED_STATE_ATTR:
case PSVC_STATE_ATTR:
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_LED_STATE_ATTR:
case PSVC_STATE_ATTR:
case PSVC_LED_COLOR_ATTR:
return (status);
case PSVC_LIT_COUNT_ATTR:
return (status);
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_LED_STATE_ATTR:
case PSVC_STATE_ATTR:
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_LED_STATE_ATTR:
case PSVC_STATE_ATTR:
case PSVC_LED_COLOR_ATTR:
return (status);
case PSVC_LIT_COUNT_ATTR:
return (status);
case PSVC_LED_IS_LOCATOR_ATTR:
return (status);
return (status);
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_SENSOR_VALUE_ATTR:
case PSVC_LO_WARN_ATTR:
return (status);
case PSVC_LO_SHUT_ATTR:
return (status);
case PSVC_HI_WARN_ATTR:
return (status);
case PSVC_HI_SHUT_ATTR:
return (status);
}
return (PSVC_SUCCESS);
}
static int32_t
{
if (attr_id == PSVC_CONTROL_VALUE_ATTR) {
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_CONTROL_VALUE_ATTR) {
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_GPIO_VALUE_ATTR:
case PSVC_GPIO_BITS:
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_GPIO_VALUE_ATTR) {
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_SENSOR_VALUE_ATTR:
case PSVC_LO_WARN_ATTR:
return (status);
case PSVC_LO_SHUT_ATTR:
return (status);
case PSVC_HI_WARN_ATTR:
return (status);
case PSVC_HI_SHUT_ATTR:
return (status);
}
return (PSVC_SUCCESS);
}
static int32_t
{
switch (attr_id) {
case PSVC_SWITCH_STATE_ATTR:
case PSVC_STATE_ATTR:
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_SWITCH_STATE_ATTR:
case PSVC_STATE_ATTR:
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_SWITCH_STATE_ATTR:
case PSVC_STATE_ATTR:
return (PSVC_SUCCESS);
} else {
return (status);
}
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_GPIO_VALUE_ATTR:
case PSVC_GPIO_BITS:
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_GPIO_VALUE_ATTR) {
}
return (status);
}
static int32_t
{
switch (attr_id) {
case PSVC_GPIO_VALUE_ATTR:
case PSVC_GPIO_BITS:
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_GPIO_VALUE_ATTR) {
}
return (status);
}
/* AT24 */
static int32_t
{
switch (attr_id) {
case PSVC_PROBE_RESULT_ATTR:
if (probe_status == PSVC_SUCCESS)
else
return (status);
case PSVC_FRU_INFO_ATTR:
return (status);
}
return (status);
}
static int32_t
{
return (PSVC_FAILURE);
}
if (status != PSVC_SUCCESS)
return (status);
if (fp == -1) {
return (PSVC_FAILURE);
}
temp_errno = errno;
errno = temp_errno;
return (PSVC_FAILURE);
}
if (ret == -1) {
return (-1);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_PROBE_RESULT_ATTR) {
if (probe_status == PSVC_SUCCESS)
else
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_PROBE_RESULT_ATTR) {
if (probe_status == PSVC_SUCCESS)
else
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_PROBE_RESULT_ATTR) {
if (probe_status == PSVC_SUCCESS)
else
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_PROBE_RESULT_ATTR) {
if (probe_status == PSVC_SUCCESS)
else
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_PROBE_RESULT_ATTR) {
if (probe_status == PSVC_SUCCESS)
else
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_PROBE_RESULT_ATTR) {
if (probe_status == PSVC_SUCCESS)
else
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_PROBE_RESULT_ATTR) {
if (probe_status == PSVC_SUCCESS)
else
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_PROBE_RESULT_ATTR) {
if (probe_status == PSVC_SUCCESS)
else
return (status);
}
return (status);
}
static int32_t
{
if (attr_id == PSVC_PROBE_RESULT_ATTR) {
if (probe_status == PSVC_SUCCESS)
else
return (status);
}
return (status);
}
static int32_t
char *name,
char *buf,
{
char *start;
char cur_device[NAMELEN];
int slot;
return (PSVC_FAILURE);
} else {
}
return (PSVC_FAILURE);
return (PSVC_FAILURE);
}
if (found != 1) {
return (PSVC_FAILURE);
}
break;
}
return (PSVC_FAILURE);
return (PSVC_FAILURE);
}
PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
else
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
}
static int32_t
{
return (PSVC_FAILURE);
}
/* Temperature sensor */
/* Class 0 Subclass 0 are temperature sensors that cannot be updated */
static int32_t
char *id,
{
sizeof (ETempSensor_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
return (0);
}
/* Class 0 Subclass 1 are temperature sensors that can be updated */
static int32_t
char *id,
{
sizeof (ETempSensor_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
}
return (0);
}
/* Fan */
static int32_t
char *id,
{
sizeof (EFan_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
}
/* LED */
static int32_t
char *id,
{
sizeof (ELed_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
}
static int32_t
char *id,
{
sizeof (ELed_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
}
static int32_t
char *id,
{
sizeof (ELed_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
return (PSVC_FAILURE);
}
} else {
}
return (PSVC_SUCCESS);
}
/* System Device */
static int32_t
char *id,
{
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* Digital Sensor */
static int32_t
char *id,
{
sizeof (EDigiSensor_t));
if (status != PSVC_SUCCESS) {
return (status);
}
/* Load class specific info */
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
}
/* Digital Control */
static int32_t
char *id,
{
sizeof (EDigiControl_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* Boolean GPIO */
static int32_t
char *id,
{
sizeof (EBoolSensor_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* Fan Tachometer */
static int32_t
char *id,
{
EFanTach_t *dp;
sizeof (EFanTach_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
!= PSVC_SUCCESS) {
return (PSVC_FAILURE);
}
return (PSVC_SUCCESS);
}
/* On Off Switch */
static int32_t
char *id,
{
sizeof (ESwitch_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* Key Switch */
static int32_t
char *id,
{
sizeof (EKeySwitch_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* 8 Bit GPIO , devices with registers, calls get_reg()/set_reg() */
static int32_t
char *id,
{
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* 8 Bit GPIO , devices with ports, calls get_port()/set_port() */
static int32_t
char *id,
{
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* AT24 */
static int32_t
char *id,
{
EPhysDev_t *dp;
sizeof (EPhysDev_t));
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* HPC3130 */
static int32_t
char *id,
{
EPhysDev_t *dp;
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* LM75 */
static int32_t
char *id,
{
EPhysDev_t *dp;
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* LTC1427 */
static int32_t
char *id,
{
EPhysDev_t *dp;
char path[1024];
if (status != PSVC_SUCCESS)
return (status);
/*
* The following code upto and including the open() call is so the
* device driver for the ltc1427 does not get unloaded by the OS at
* any time. This is important as the device driver is a write only
* physical device but DOES keep readable states in the device unitp
* structure (I2C_GET_OUTPUT) as a result this device should not
* be unload while PSVC is up and running
*/
if (status != PSVC_SUCCESS) {
return (status);
}
if (fp == -1) {
return (PSVC_FAILURE);
}
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* MAX1617 */
static int32_t
char *id,
{
EPhysDev_t *dp;
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* PCF8574 */
static int32_t
char *id,
{
EPhysDev_t *dp;
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* PCF8591 */
static int32_t
char *id,
{
EPhysDev_t *dp;
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* SSC050 */
static int32_t
char *id,
{
EPhysDev_t *dp;
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* TDA8444 */
static int32_t
char *id,
{
EPhysDev_t *dp;
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
/* SSC100 */
static int32_t
char *id,
{
EPhysDev_t *dp;
if (status != PSVC_SUCCESS)
return (status);
/* Load class specific info */
return (PSVC_SUCCESS);
}
{
int i;
char platform[32];
char filename[256];
int found;
int forward_slash = 47;
int new_line = 10;
char *nl_char;
return (-1);
/* Initialize the lock */
if (status != 0) {
return (-1);
}
if (status != 0) {
return (-1);
}
return (-1);
}
return (-1);
}
/* Build the association ID lookup table */
return (-1);
}
for (i = 0; i < hdlp->othr_count; ++i) {
}
(int (*)(const void *, const void *))i_psvc_name_compare_qsort);
/* determine total number of objects + tables */
return (-1);
}
return (-1);
}
&table_count, "TABLE_END");
if (status == PSVC_FAILURE) {
return (status);
}
}
/* Allocate object name to object pointer translation table */
for (i = 0; i < PSVC_MAX_TABLE_ARRAYS; i++) {
(ENamePtr_t *)malloc(
return (-1);
}
}
/* Build the association table */
return (-1);
/* Build the table of device paths */
return (-1);
return (-1);
return (-1);
}
if (found != 4) {
return (-1);
}
/*
* Replace new line character with NUL character
*/
*nl_char = 0;
}
/* Build the table of tables */
return (-1);
return (0);
}
{
int32_t i, j;
if (hdlp == 0)
return (PSVC_SUCCESS);
for (j = 0; j < PSVC_MAX_TABLE_ARRAYS; j++) {
/* Skip non-existent object */
continue;
}
}
}
}
}
}
for (i = 0; i < hdlp->assoc_count; ++i) {
}
}
return (PSVC_SUCCESS);
}
{
/*
* Becuase the i2c bus is a multimaster bus we need to protect
* ourselves from bus masters that are not being good bus citizens.
* A retry number of 10 should be sufficient to handle any bad bus
* citizens. After that we will simply say that there is something
* wrong with the ioctl transaction and let it bubble back up.
*/
do {
tries ++;
return (ret);
}
static int32_t
psvc_get_str_key(char *object)
{
int i, length;
for (i = 0; i < length; i++) {
} else {
}
}
return (key);
}