/* sensor layout init for different board */
void sensor_layout_init(void)
{
unsigned int sensor_type;
sensor_type = get_sensor_type();
switch (sensor_type) {
case E_SENSOR_TYPE_PHONE:
gs_platform_data.negate_x = 1;
gs_platform_data.negate_y = 1;
mma8452_platform_data.config_mxc_mma_position = 1;
adxl34x_default_init.config_adxl34x_position = 0;
compass_platform_data.config_akm_position = 3;
#ifdef CONFIG_HUAWEI_FEATURE_SENSORS_AKM8963
compass_akm8963_platform_data.layout = 3;
#endif
l3g4200d_gyr_platform_data.negate_x = 1;
l3g4200d_gyr_platform_data.negate_y = 1;
break;
case E_SENSOR_TYPE_PLATFORM:
gs_platform_data.negate_x = 0;
gs_platform_data.negate_y = 0;
mma8452_platform_data.config_mxc_mma_position = 3;
adxl34x_default_init.config_adxl34x_position = 2;
compass_platform_data.config_akm_position = 1;
l3g4200d_gyr_platform_data.negate_x = 0;
l3g4200d_gyr_platform_data.negate_y = 0;
break;
default:
pr_err("sensor_type unsupported\n");
break;
}
}
void print_device_list(){
device *dev;
for(dev = list_head(device_table);
dev!= NULL;
dev = list_item_next(dev)){
printf("Device %d: %s\n", dev->deviceId, dev->deviceName);
printf("Icon: %s, Type: %d\n", dev->icon, dev->type);
printf("Unit: %s, Max: %s, Min: %s\n", get_unit_type(dev), dev->min, dev->max);
printf("Display: %s, Sensor: %s\n", get_interface_type(dev), get_sensor_type(dev));
printf("--------\t--------\t--------\n");
}
printf("End print \t ------------------------------\n");
}
/* sensor layout init for different board */
void sensor_layout_init(void)
{
unsigned int sensor_type;
sensor_type = get_sensor_type();
switch (sensor_type) {
case E_SENSOR_TYPE_PHONE:
gs_platform_data.negate_x = 1;
gs_platform_data.negate_y = 1;
mma8452_platform_data.config_mxc_mma_position = 1;
adxl34x_default_init.config_adxl34x_position = 0;
compass_platform_data.config_akm_position = 3;
l3g4200d_gyr_platform_data.negate_x = 1;
l3g4200d_gyr_platform_data.negate_y = 1;
break;
case E_SENSOR_TYPE_PLATFORM:
gs_platform_data.negate_x = 0;
gs_platform_data.negate_y = 0;
mma8452_platform_data.config_mxc_mma_position = 3;
adxl34x_default_init.config_adxl34x_position = 2;
compass_platform_data.config_akm_position = 1;
l3g4200d_gyr_platform_data.negate_x = 0;
l3g4200d_gyr_platform_data.negate_y = 0;
break;
case E_SENSOR_TYPE_PAD:
printk("wanglin test boardid sensor,boardid %d\n",get_boardid());
gs_platform_data.negate_x = 0;
gs_platform_data.negate_z = 1;
mma8452_platform_data.config_mxc_mma_position = 1;
adxl34x_default_init.config_adxl34x_position = 6;
compass_platform_data.config_akm_position = 7;
l3g4200d_gyr_platform_data.negate_x = 0;
l3g4200d_gyr_platform_data.negate_z = 1;
break;
case E_SENSOR_TYPE_LINK:
printk("test boardid sensor,boardid %d\n",get_boardid());
gs_platform_data.axis_map_x = 1;
gs_platform_data.axis_map_y = 0;
gs_platform_data.negate_y = 0;
mma8452_platform_data.config_mxc_mma_position = 1;
adxl34x_default_init.config_adxl34x_position = 3;
compass_platform_data.config_akm_position = 7;
l3g4200d_gyr_platform_data.negate_x = 0;
l3g4200d_gyr_platform_data.negate_z = 1;
default:
pr_err("sensor_type unsupported\n");
break;
}
}
void list_sel(SaHpiSessionIdT session_id, SaHpiResourceIdT resource_id)
{
char str[256];
printf("SEL Info:\n");
SaHpiSelInfoT info;
SaErrorT rv = saHpiEventLogInfoGet(session_id, resource_id, &info);
if (rv != SA_OK) {
printf( "Error=%d reading SEL info\n", rv);
return;
}
printf("\tEntries in SEL: %d\n", info.Entries);
printf("\tSize: %d\n", info.Size);
time2str(info.UpdateTimestamp, str);
printf("\tUpdateTimestamp: %s\n", str);
time2str(info.CurrentTime, str);
printf("\tCurrentTime : %s\n", str);
printf("\tEnabled: %s\n", info.Enabled ? "true" : "false");
printf("\tOverflowFlag: %s\n", info.OverflowFlag ? "true" : "false");
printf("\tOverflowAction: " );
switch(info.OverflowAction) {
case SAHPI_SEL_OVERFLOW_DROP:
printf("SAHPI_SEL_OVERFLOW_DROP\n");
break;
case SAHPI_SEL_OVERFLOW_WRAP:
printf("SAHPI_SEL_OVERFLOW_WRAP\n");
break;
case SAHPI_SEL_OVERFLOW_WRITELAST:
printf("SAHPI_SEL_OVERFLOW_WRITELAST\n");
break;
default:
printf("unknown(0x%x)\n", info.OverflowAction);
break;
}
printf("\tDeleteEntrySupported: %s\n", info.DeleteEntrySupported ? "true" : "false" );
if (info.Entries == 0)
return;
//else
// read sel records
SaHpiSelEntryIdT current = SAHPI_OLDEST_ENTRY;
do {
SaHpiSelEntryIdT prev;
SaHpiSelEntryIdT next;
SaHpiSelEntryT entry;
SaHpiRdrT rdr;
SaHpiRptEntryT res;
rv = saHpiEventLogEntryGet(session_id, resource_id, current, &prev, &next, &entry, &rdr, &res);
if (rv != SA_OK) {
printf( "Error=%d reading SEL entry %d\n", rv, current);
return;
}
printf("\t\tEntry %d, prev %d, next %d\n", entry.EntryId, prev, next);
time2str(entry.Timestamp, str);
printf("\t\t\tTimestamp: %s\n", str);
SaHpiRptEntryT rres;
rv = saHpiRptEntryGetByResourceId(session_id, entry.Event.Source, &rres );
if ( rv != SA_OK )
printf("\t\t\tSource: unknown\n" );
else {
entitypath2string( &rres.ResourceEntity, str, sizeof(str));
printf("\t\t\tSource: %s\n", str );
}
printf("\t\t\tEventType: %s\n", eventtype2str(entry.Event.EventType));
time2str(entry.Timestamp, str);
printf("\t\t\tEvent timestamp: %s\n", str);
printf("\t\t\tSeverity: %s\n", severity2str( entry.Event.Severity ) );
switch(entry.Event.EventType) {
case SAHPI_ET_SENSOR:
{
SaHpiSensorEventT *se = &entry.Event.EventDataUnion.SensorEvent;
printf("\t\t\tSensorNum: %d\n", se->SensorNum );
printf("\t\t\tSensorType: %s\n", get_sensor_type(se->SensorType ) );
printf("\t\t\tEventCategory: %s\n", get_sensor_category( se->EventCategory ) );
printf("\t\t\tAssertion: %s\n", se->Assertion ? "TRUE" : "FALSE" );
}
break;
case SAHPI_ET_HOTSWAP:
{
SaHpiHotSwapEventT *he = &entry.Event.EventDataUnion.HotSwapEvent;
printf("\t\t\tHotSwapState: %s\n",
hotswapstate2str( he->HotSwapState ) );
printf("\t\t\tPreviousHotSwapState: %s\n",
hotswapstate2str( he->PreviousHotSwapState ) );
}
break;
case SAHPI_ET_WATCHDOG:
break;
case SAHPI_ET_OEM:
break;
case SAHPI_ET_USER:
break;
}
current = next;
} while(current != SAHPI_NO_MORE_ENTRIES);
}
void list_rdr(SaHpiSessionIdT session_id, SaHpiResourceIdT resource_id)
{
SaErrorT err;
SaHpiEntryIdT current_rdr;
SaHpiEntryIdT next_rdr;
SaHpiRdrT rdr;
SaHpiSensorReadingT reading;
SaHpiSensorTypeT sensor_type;
SaHpiSensorNumT sensor_num;
SaHpiEventCategoryT category;
SaHpiSensorThresholdsT thres;
SaHpiCtrlNumT ctrl_num;
SaHpiCtrlStateT state;
SaHpiCtrlTypeT ctrl_type;
SaHpiEirIdT l_eirid;
SaHpiInventoryDataT* l_inventdata;
const SaHpiUint32T l_inventsize = 16384;
SaHpiUint32T l_actualsize;
printf("RDR Info:\n");
next_rdr = SAHPI_FIRST_ENTRY;
do {
char tmp_epath[128];
current_rdr = next_rdr;
err = saHpiRdrGet(session_id, resource_id, current_rdr,
&next_rdr, &rdr);
if (SA_OK != err) {
if (current_rdr == SAHPI_FIRST_ENTRY)
printf("Empty RDR table\n");
else
error("saHpiRdrGet", err);
return;
}
printf("\tRecordId: %x\n", rdr.RecordId);
printf("\tRdrType: %s\n", rdrtype2str(rdr.RdrType));
if (rdr.RdrType == SAHPI_SENSOR_RDR)
{
SaErrorT val;
sensor_num = rdr.RdrTypeUnion.SensorRec.Num;
val = saHpiSensorTypeGet(session_id, resource_id,
sensor_num, &sensor_type,
&category);
printf("\tSensor num: %i\n\tType: %s\n", sensor_num, get_sensor_type(sensor_type));
printf("\tCategory: %s\n", get_sensor_category(category));
memset(&reading, 0, sizeof(SaHpiSensorReadingT));
err = saHpiSensorReadingGet(session_id, resource_id, sensor_num, &reading);
if (err != SA_OK) {
printf("Error=%d reading sensor data {sensor, %d}\n", err, sensor_num);
continue;
}
if (reading.ValuesPresent & SAHPI_SRF_RAW) {
printf("\tValues Present: RAW\n");
printf("\t\tRaw value: %d\n", reading.Raw);
}
if (reading.ValuesPresent & SAHPI_SRF_INTERPRETED) {
printf("\tValues Present: Interpreted\n");
printf("\t\t");
interpreted2str(reading.Interpreted);
}
if (reading.ValuesPresent & SAHPI_SRF_EVENT_STATE) {
printf("\tValues Present: Event State\n");
}
if (rdr.RdrTypeUnion.SensorRec.ThresholdDefn.IsThreshold == SAHPI_TRUE) {
memset(&thres, 0, sizeof(SaHpiSensorThresholdsT));
err = saHpiSensorThresholdsGet(session_id, resource_id, sensor_num, &thres);
if (err != SA_OK) {
printf("Error=%d reading sensor thresholds {sensor, %d}\n", err, sensor_num);
continue;
}
if (thres.LowCritical.ValuesPresent) {
printf("\t\tThreshold: Low Critical Values\n");
printreading(thres.LowCritical);
}
if (thres.LowMajor.ValuesPresent) {
printf("\t\tThreshold: Low Major Values\n");
printreading(thres.LowMajor);
}
if (thres.LowMinor.ValuesPresent) {
printf("\t\tThreshold: Low Minor Values\n");
printreading(thres.LowMinor);
}
if (thres.UpCritical.ValuesPresent) {
printf("\t\tThreshold: Up Critical Values\n");
printreading(thres.UpCritical);
}
if (thres.UpMajor.ValuesPresent) {
printf("\t\tThreshold: Up Major Values\n");
printreading(thres.UpMajor);
}
if (thres.UpMinor.ValuesPresent) {
printf("\t\tThreshold: Up Minor Values\n");
printreading(thres.UpMinor);
}
if (thres.PosThdHysteresis.ValuesPresent) {
printf("\t\tThreshold: Pos Threshold Hysteresis Values\n");
printreading(thres.PosThdHysteresis);
}
if (thres.NegThdHysteresis.ValuesPresent) {
printf("\t\tThreshold: Neg Threshold Hysteresis Values\n");
printreading(thres.NegThdHysteresis);
}
}
}
if (rdr.RdrType == SAHPI_CTRL_RDR)
{
ctrl_num = rdr.RdrTypeUnion.CtrlRec.Num;
err = saHpiControlTypeGet(session_id, resource_id, ctrl_num, &ctrl_type);
if (err != SA_OK) {
printf("Error=%d reading control type {control, %d}\n", err, ctrl_num);
continue;
}
printf("\tControl num: %i\n\tType: %s\n", ctrl_num, get_control_type(ctrl_type));
err = saHpiControlStateGet(session_id, resource_id, ctrl_num, &state);
if (err != SA_OK) {
printf("Error=%d reading control state {control, %d}\n", err, ctrl_num);
continue;
}
if (ctrl_type != state.Type) {
printf("Control Type mismatch between saHpiControlTypeGet=%d and saHpiControlStateGet = %d\n",
ctrl_type, state.Type);
}
switch (state.Type) {
case SAHPI_CTRL_TYPE_DIGITAL:
printf("\t\tControl Digital State: %s\n",
ctrldigital2str(state.StateUnion.Digital));
break;
case SAHPI_CTRL_TYPE_DISCRETE:
printf("\t\tControl Discrete State: %x\n", state.StateUnion.Discrete);
break;
case SAHPI_CTRL_TYPE_ANALOG:
printf("\t\tControl Analog State: %x\n", state.StateUnion.Analog);
break;
case SAHPI_CTRL_TYPE_STREAM:
printf("\t\tControl Stream Repeat: %d\n", state.StateUnion.Stream.Repeat);
printf("\t\tControl Stream Data: ");
display_oembuffer(state.StateUnion.Stream.StreamLength, state.StateUnion.Stream.Stream);
break;
case SAHPI_CTRL_TYPE_TEXT:
printf("\t\tControl Text Line Num: %c\n", state.StateUnion.Text.Line);
display_textbuffer(state.StateUnion.Text.Text);
break;
case SAHPI_CTRL_TYPE_OEM:
printf("\t\tControl OEM Manufacturer: %d\n", state.StateUnion.Oem.MId);
printf("\t\tControl OEM Data: ");
display_oembuffer((SaHpiUint32T)state.StateUnion.Oem.BodyLength,
state.StateUnion.Oem.Body);
break;
default:
printf("\t\tInvalid control type (%d) from saHpiControlStateGet\n",
state.Type);
}
}
if (rdr.RdrType == SAHPI_INVENTORY_RDR)
{
l_eirid = rdr.RdrTypeUnion.InventoryRec.EirId;
l_inventdata = (SaHpiInventoryDataT *)g_malloc(l_inventsize);
err = saHpiEntityInventoryDataRead(session_id, resource_id,
l_eirid, l_inventsize,
l_inventdata, &l_actualsize);
if (err != SA_OK) {
printf("Error=%d reading inventory type {EirId, %d}\n", err, l_eirid);
continue;
} else if (l_inventdata->Validity == SAHPI_INVENT_DATA_VALID) {
printf("\tFound Inventory RDR with EirId: %x\n", l_eirid);
printf("\tRDR l_inventsize = %d, actualsize = %d\n", l_inventsize, l_actualsize);
switch (l_inventdata->DataRecords[0]->RecordType)
{
case SAHPI_INVENT_RECTYPE_INTERNAL_USE:
printf( "Internal Use\n");
break;
case SAHPI_INVENT_RECTYPE_PRODUCT_INFO:
printf( "Product Info\n");
break;
case SAHPI_INVENT_RECTYPE_CHASSIS_INFO:
printf( "Chassis Info\n");
break;
case SAHPI_INVENT_RECTYPE_BOARD_INFO:
printf( "Board Info\n");
break;
case SAHPI_INVENT_RECTYPE_OEM:
printf( "OEM Record\n");
break;
default:
printf(" Invalid Invent Rec Type =%x\n",
l_inventdata->DataRecords[0]->RecordType);
break;
}
}
g_free(l_inventdata);
}
printf("\tEntity: \n");
entitypath2string(&rdr.Entity, tmp_epath, sizeof(tmp_epath));
printf("\t\t%s\n", tmp_epath);
printf("\tIdString: ");
display_textbuffer(rdr.IdString);
printf("\n"); /* Produce blank line between rdrs. */
}while(next_rdr != SAHPI_LAST_ENTRY);
}
static void check_sensor_with_data(GList **sensors,
const char * const chip_name,
const sensors_chip_name *chip,
int *n1, int *n2,
const sensors_feature_data *data)
{
char *label;
double value;
SensorsAppletSensorInfo *sensor_info = NULL;
/* ... some of which are boring ... */
if ((label = get_sensor_interesting_label (*chip, data->number))) {
/* ... and some of which are actually sensors */
if ((data->mode & SENSORS_MODE_R) &&
(data->mapping == SENSORS_NO_MAPPING) &&
(sensors_get_feature(*chip, data->number, &value) == 0) // make sure we can actually get a value for it
) {
SensorType type;
gboolean visible;
IconType icon;
gdouble low_value, high_value;
gchar *url;
type = get_sensor_type (data->name);
visible = (type == TEMP_SENSOR ? TRUE : FALSE);
icon = get_sensor_icon(type);
// the 'path' contains all the information we need to
// identify this sensor later
url = g_strdup_printf ("sensor://%s/%d", chip_name, data->number);
// get low and high values
sensors_applet_plugin_default_sensor_limits(type,
&low_value,
&high_value);
data = get_sensor_min_max(chip, n1, n2, data->number,
&low_value, &high_value);
if (data != NULL) {
// try adding this one
// at this point we have called sensors_get_all_features() and stopped when we have a potential new sensor, so make sure we try this as well - do a recursive call
check_sensor_with_data(sensors, chip_name, chip, n1, n2, data);
}
g_hash_table_insert(hash_table, g_strdup(url), (void *)chip);
// the id identifies a particular sensor for the user;
// we default to the label returned by libsensors
sensors_applet_plugin_add_sensor_with_limits(sensors,
url,
label,
label,
type,
visible,
low_value,
high_value,
icon,
DEFAULT_GRAPH_COLOR);
g_free(url);
}
free (label);
}
}
