scottk/OpenNetworkLinux
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenNetworkLinux.git synced 2025-12-24 16:57:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

1. Add tmp401 and gpio_pca953x module config.

Browse Source 
2. Remove tmp401 driver in local path.
3. Read fantray present by gpio attribute instead of i2c access.
This commit is contained in:
Jeff Chen
2018-12-07 17:20:22 +08:00
parent 61f44e2207
commit 316de4d518
8 changed files with 122 additions and 872 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
packages/base/any/kernels/4.9-lts/configs/x86_64-all/x86_64-all.config
View File

@@ -1,6 +1,6 @@
#
# Automatically generated file; DO NOT EDIT.
# Linux/x86_64 4.9.75 Kernel Configuration
# Linux/x86 4.9.75 Kernel Configuration
#
CONFIG_64BIT=y
CONFIG_X86_64=y
@@ -2273,7 +2273,7 @@ CONFIG_PTP_1588_CLOCK=y
CONFIG_GPIOLIB=y
CONFIG_GPIO_ACPI=y
# CONFIG_DEBUG_GPIO is not set
# CONFIG_GPIO_SYSFS is not set
CONFIG_GPIO_SYSFS=y
#
# Memory mapped GPIO drivers
@@ -2301,7 +2301,7 @@ CONFIG_GPIO_ACPI=y
# CONFIG_GPIO_ADP5588 is not set
# CONFIG_GPIO_MAX7300 is not set
# CONFIG_GPIO_MAX732X is not set
# CONFIG_GPIO_PCA953X is not set
CONFIG_GPIO_PCA953X=m
# CONFIG_GPIO_PCF857X is not set
# CONFIG_GPIO_SX150X is not set
# CONFIG_GPIO_TPIC2810 is not set
@@ -2504,7 +2504,7 @@ CONFIG_SENSORS_UCD9200=y
# CONFIG_SENSORS_THMC50 is not set
CONFIG_SENSORS_TMP102=y
# CONFIG_SENSORS_TMP103 is not set
# CONFIG_SENSORS_TMP401 is not set
CONFIG_SENSORS_TMP401=m
# CONFIG_SENSORS_TMP421 is not set
# CONFIG_SENSORS_VIA_CPUTEMP is not set
# CONFIG_SENSORS_VIA686A is not set
@@ -3879,7 +3879,7 @@ CONFIG_RAS=y
#
# CONFIG_ANDROID is not set
# CONFIG_LIBNVDIMM is not set
CONFIG_NVMEM=m
CONFIG_NVMEM=y
# CONFIG_STM is not set
# CONFIG_INTEL_TH is not set

6
packages/platforms/delta/x86-64/x86-64-delta-agc7648sv1/modules/builds/delta_agc7648sv1_platform.c
View File

@@ -796,6 +796,12 @@ static struct i2c_device_platform_data agc7648sv1_i2c_device_platform_data[] = {
.info = { I2C_BOARD_INFO("tmp75", 0x4f) },
.client = NULL,
},
{
// fan IO CTRL
.parent = 27,
.info = { I2C_BOARD_INFO("pca9555", 0x27) },
.client = NULL,
},
{
// PSU 1 eeprom
.parent = 31,

796
packages/platforms/delta/x86-64/x86-64-delta-agc7648sv1/modules/builds/tmp401.c
View File

@@ -1,796 +0,0 @@
/* tmp401.c
*
* Copyright (C) 2007,2008 Hans de Goede <hdegoede@redhat.com>
* Preliminary tmp411 support by:
* Gabriel Konat, Sander Leget, Wouter Willems
* Copyright (C) 2009 Andre Prendel <andre.prendel@gmx.de>
*
* Cleanup and support for TMP431 and TMP432 by Guenter Roeck
* Copyright (c) 2013 Guenter Roeck <linux@roeck-us.net>
*
* 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.
*/
/*
* Driver for the Texas Instruments TMP401 SMBUS temperature sensor IC.
*
* Note this IC is in some aspect similar to the LM90, but it has quite a
* few differences too, for example the local temp has a higher resolution
* and thus has 16 bits registers for its value and limit instead of 8 bits.
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/bitops.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/err.h>
#include <linux/mutex.h>
#include <linux/sysfs.h>
/* Addresses to scan */
static const unsigned short normal_i2c[] = { 0x48, 0x49, 0x4a, 0x4c, 0x4d,
0x4e, 0x4f, I2C_CLIENT_END };
enum chips { tmp401, tmp411, tmp431, tmp432, tmp435, tmp461 };
/*
* The TMP401 registers, note some registers have different addresses for
* reading and writing
*/
#define TMP401_STATUS 0x02
#define TMP401_CONFIG_READ 0x03
#define TMP401_CONFIG_WRITE 0x09
#define TMP401_CONVERSION_RATE_READ 0x04
#define TMP401_CONVERSION_RATE_WRITE 0x0A
#define TMP401_TEMP_CRIT_HYST 0x21
#define TMP401_MANUFACTURER_ID_REG 0xFE
#define TMP401_DEVICE_ID_REG 0xFF
static const u8 TMP401_TEMP_MSB_READ[7][2] = {
{ 0x00, 0x01 }, /* temp */
{ 0x06, 0x08 }, /* low limit */
{ 0x05, 0x07 }, /* high limit */
{ 0x20, 0x19 }, /* therm (crit) limit */
{ 0x30, 0x34 }, /* lowest */
{ 0x32, 0x36 }, /* highest */
{ 0, 0x11 }, /* offset */
};
static const u8 TMP401_TEMP_MSB_WRITE[7][2] = {
{ 0, 0 }, /* temp (unused) */
{ 0x0C, 0x0E }, /* low limit */
{ 0x0B, 0x0D }, /* high limit */
{ 0x20, 0x19 }, /* therm (crit) limit */
{ 0x30, 0x34 }, /* lowest */
{ 0x32, 0x36 }, /* highest */
{ 0, 0x11 }, /* offset */
};
static const u8 TMP401_TEMP_LSB[7][2] = {
{ 0x15, 0x10 }, /* temp */
{ 0x17, 0x14 }, /* low limit */
{ 0x16, 0x13 }, /* high limit */
{ 0, 0 }, /* therm (crit) limit (unused) */
{ 0x31, 0x35 }, /* lowest */
{ 0x33, 0x37 }, /* highest */
{ 0, 0x12 }, /* offset */
};
static const u8 TMP432_TEMP_MSB_READ[4][3] = {
{ 0x00, 0x01, 0x23 }, /* temp */
{ 0x06, 0x08, 0x16 }, /* low limit */
{ 0x05, 0x07, 0x15 }, /* high limit */
{ 0x20, 0x19, 0x1A }, /* therm (crit) limit */
};
static const u8 TMP432_TEMP_MSB_WRITE[4][3] = {
{ 0, 0, 0 }, /* temp - unused */
{ 0x0C, 0x0E, 0x16 }, /* low limit */
{ 0x0B, 0x0D, 0x15 }, /* high limit */
{ 0x20, 0x19, 0x1A }, /* therm (crit) limit */
};
static const u8 TMP432_TEMP_LSB[3][3] = {
{ 0x29, 0x10, 0x24 }, /* temp */
{ 0x3E, 0x14, 0x18 }, /* low limit */
{ 0x3D, 0x13, 0x17 }, /* high limit */
};
/* [0] = fault, [1] = low, [2] = high, [3] = therm/crit */
static const u8 TMP432_STATUS_REG[] = {
0x1b, 0x36, 0x35, 0x37 };
/* Flags */
#define TMP401_CONFIG_RANGE BIT(2)
#define TMP401_CONFIG_SHUTDOWN BIT(6)
#define TMP401_STATUS_LOCAL_CRIT BIT(0)
#define TMP401_STATUS_REMOTE_CRIT BIT(1)
#define TMP401_STATUS_REMOTE_OPEN BIT(2)
#define TMP401_STATUS_REMOTE_LOW BIT(3)
#define TMP401_STATUS_REMOTE_HIGH BIT(4)
#define TMP401_STATUS_LOCAL_LOW BIT(5)
#define TMP401_STATUS_LOCAL_HIGH BIT(6)
/* On TMP432, each status has its own register */
#define TMP432_STATUS_LOCAL BIT(0)
#define TMP432_STATUS_REMOTE1 BIT(1)
#define TMP432_STATUS_REMOTE2 BIT(2)
/* Manufacturer / Device ID's */
#define TMP401_MANUFACTURER_ID 0x55
#define TMP401_DEVICE_ID 0x11
#define TMP411A_DEVICE_ID 0x12
#define TMP411B_DEVICE_ID 0x13
#define TMP411C_DEVICE_ID 0x10
#define TMP431_DEVICE_ID 0x31
#define TMP432_DEVICE_ID 0x32
#define TMP435_DEVICE_ID 0x35
/*
* Driver data (common to all clients)
*/
static const struct i2c_device_id tmp401_id[] = {
{ "tmp401", tmp401 },
{ "tmp411", tmp411 },
{ "tmp431", tmp431 },
{ "tmp432", tmp432 },
{ "tmp435", tmp435 },
{ "tmp461", tmp461 },
{ }
};
MODULE_DEVICE_TABLE(i2c, tmp401_id);
/*
* Client data (each client gets its own)
*/
struct tmp401_data {
struct i2c_client *client;
const struct attribute_group *groups[3];
struct mutex update_lock;
char valid; /* zero until following fields are valid */
unsigned long last_updated; /* in jiffies */
enum chips kind;
unsigned int update_interval; /* in milliseconds */
/* register values */
u8 status[4];
u8 config;
u16 temp[7][3];
u8 temp_crit_hyst;
};
/*
* Sysfs attr show / store functions
*/
static int tmp401_register_to_temp(u16 reg, u8 config)
{
int temp = reg;
if (config & TMP401_CONFIG_RANGE)
temp -= 64 * 256;
return DIV_ROUND_CLOSEST(temp * 125, 32);
}
static u16 tmp401_temp_to_register(long temp, u8 config, int zbits)
{
if (config & TMP401_CONFIG_RANGE) {
temp = clamp_val(temp, -64000, 191000);
temp += 64000;
} else
temp = clamp_val(temp, 0, 127000);
return DIV_ROUND_CLOSEST(temp * (1 << (8 - zbits)), 1000) << zbits;
}
static int tmp401_update_device_reg16(struct i2c_client *client,
struct tmp401_data *data)
{
int i, j, val;
int num_regs = data->kind == tmp411 ? 6 : 4;
int num_sensors = data->kind == tmp432 ? 3 : 2;
for (i = 0; i < num_sensors; i++) { /* local / r1 / r2 */
for (j = 0; j < num_regs; j++) { /* temp / low / ... */
u8 regaddr;
/*
* High byte must be read first immediately followed
* by the low byte
*/
regaddr = data->kind == tmp432 ?
TMP432_TEMP_MSB_READ[j][i] :
TMP401_TEMP_MSB_READ[j][i];
val = i2c_smbus_read_byte_data(client, regaddr);
if (val < 0)
return val;
data->temp[j][i] = val << 8;
if (j == 3) /* crit is msb only */
continue;
regaddr = data->kind == tmp432 ? TMP432_TEMP_LSB[j][i]
: TMP401_TEMP_LSB[j][i];
val = i2c_smbus_read_byte_data(client, regaddr);
if (val < 0)
return val;
data->temp[j][i] |= val;
}
}
return 0;
}
static struct tmp401_data *tmp401_update_device(struct device *dev)
{
struct tmp401_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
struct tmp401_data *ret = data;
int i, val;
unsigned long next_update;
mutex_lock(&data->update_lock);
next_update = data->last_updated +
msecs_to_jiffies(data->update_interval);
if (time_after(jiffies, next_update) || !data->valid) {
if (data->kind != tmp432) {
/*
* The driver uses the TMP432 status format internally.
* Convert status to TMP432 format for other chips.
*/
val = i2c_smbus_read_byte_data(client, TMP401_STATUS);
if (val < 0) {
ret = ERR_PTR(val);
goto abort;
}
data->status[0] =
(val & TMP401_STATUS_REMOTE_OPEN) >> 1;
data->status[1] =
((val & TMP401_STATUS_REMOTE_LOW) >> 2) |
((val & TMP401_STATUS_LOCAL_LOW) >> 5);
data->status[2] =
((val & TMP401_STATUS_REMOTE_HIGH) >> 3) |
((val & TMP401_STATUS_LOCAL_HIGH) >> 6);
data->status[3] = val & (TMP401_STATUS_LOCAL_CRIT
| TMP401_STATUS_REMOTE_CRIT);
} else {
for (i = 0; i < ARRAY_SIZE(data->status); i++) {
val = i2c_smbus_read_byte_data(client,
TMP432_STATUS_REG[i]);
if (val < 0) {
ret = ERR_PTR(val);
goto abort;
}
data->status[i] = val;
}
}
val = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
if (val < 0) {
ret = ERR_PTR(val);
goto abort;
}
data->config = val;
val = tmp401_update_device_reg16(client, data);
if (val < 0) {
ret = ERR_PTR(val);
goto abort;
}
val = i2c_smbus_read_byte_data(client, TMP401_TEMP_CRIT_HYST);
if (val < 0) {
ret = ERR_PTR(val);
goto abort;
}
data->temp_crit_hyst = val;
data->last_updated = jiffies;
data->valid = 1;
}
abort:
mutex_unlock(&data->update_lock);
return ret;
}
static ssize_t show_temp(struct device *dev,
struct device_attribute *devattr, char *buf)
{
int nr = to_sensor_dev_attr_2(devattr)->nr;
int index = to_sensor_dev_attr_2(devattr)->index;
struct tmp401_data *data = tmp401_update_device(dev);
if (IS_ERR(data))
return PTR_ERR(data);
return sprintf(buf, "%d\n",
tmp401_register_to_temp(data->temp[nr][index], data->config));
}
static ssize_t show_temp_crit_hyst(struct device *dev,
struct device_attribute *devattr, char *buf)
{
int temp, index = to_sensor_dev_attr(devattr)->index;
struct tmp401_data *data = tmp401_update_device(dev);
if (IS_ERR(data))
return PTR_ERR(data);
mutex_lock(&data->update_lock);
temp = tmp401_register_to_temp(data->temp[3][index], data->config);
temp -= data->temp_crit_hyst * 1000;
mutex_unlock(&data->update_lock);
return sprintf(buf, "%d\n", temp);
}
static ssize_t show_status(struct device *dev,
struct device_attribute *devattr, char *buf)
{
int nr = to_sensor_dev_attr_2(devattr)->nr;
int mask = to_sensor_dev_attr_2(devattr)->index;
struct tmp401_data *data = tmp401_update_device(dev);
if (IS_ERR(data))
return PTR_ERR(data);
return sprintf(buf, "%d\n", !!(data->status[nr] & mask));
}
static ssize_t store_temp(struct device *dev, struct device_attribute *devattr,
const char *buf, size_t count)
{
int nr = to_sensor_dev_attr_2(devattr)->nr;
int index = to_sensor_dev_attr_2(devattr)->index;
struct tmp401_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
long val;
u16 reg;
u8 regaddr;
if (kstrtol(buf, 10, &val))
return -EINVAL;
reg = tmp401_temp_to_register(val, data->config, nr == 3 ? 8 : 4);
mutex_lock(&data->update_lock);
regaddr = data->kind == tmp432 ? TMP432_TEMP_MSB_WRITE[nr][index]
: TMP401_TEMP_MSB_WRITE[nr][index];
i2c_smbus_write_byte_data(client, regaddr, reg >> 8);
if (nr != 3) {
regaddr = data->kind == tmp432 ? TMP432_TEMP_LSB[nr][index]
: TMP401_TEMP_LSB[nr][index];
i2c_smbus_write_byte_data(client, regaddr, reg & 0xFF);
}
data->temp[nr][index] = reg;
mutex_unlock(&data->update_lock);
return count;
}
static ssize_t store_temp_crit_hyst(struct device *dev, struct device_attribute
*devattr, const char *buf, size_t count)
{
int temp, index = to_sensor_dev_attr(devattr)->index;
struct tmp401_data *data = tmp401_update_device(dev);
long val;
u8 reg;
if (IS_ERR(data))
return PTR_ERR(data);
if (kstrtol(buf, 10, &val))
return -EINVAL;
if (data->config & TMP401_CONFIG_RANGE)
val = clamp_val(val, -64000, 191000);
else
val = clamp_val(val, 0, 127000);
mutex_lock(&data->update_lock);
temp = tmp401_register_to_temp(data->temp[3][index], data->config);
val = clamp_val(val, temp - 255000, temp);
reg = ((temp - val) + 500) / 1000;
i2c_smbus_write_byte_data(data->client, TMP401_TEMP_CRIT_HYST,
reg);
data->temp_crit_hyst = reg;
mutex_unlock(&data->update_lock);
return count;
}
/*
* Resets the historical measurements of minimum and maximum temperatures.
* This is done by writing any value to any of the minimum/maximum registers
* (0x30-0x37).
*/
static ssize_t reset_temp_history(struct device *dev,
struct device_attribute *devattr, const char *buf, size_t count)
{
struct tmp401_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
long val;
if (kstrtol(buf, 10, &val))
return -EINVAL;
if (val != 1) {
dev_err(dev,
"temp_reset_history value %ld not supported. Use 1 to reset the history!\n",
val);
return -EINVAL;
}
mutex_lock(&data->update_lock);
i2c_smbus_write_byte_data(client, TMP401_TEMP_MSB_WRITE[5][0], val);
data->valid = 0;
mutex_unlock(&data->update_lock);
return count;
}
static ssize_t show_update_interval(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct tmp401_data *data = dev_get_drvdata(dev);
return sprintf(buf, "%u\n", data->update_interval);
}
static ssize_t set_update_interval(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
struct tmp401_data *data = dev_get_drvdata(dev);
struct i2c_client *client = data->client;
unsigned long val;
int err, rate;
err = kstrtoul(buf, 10, &val);
if (err)
return err;
/*
* For valid rates, interval can be calculated as
* interval = (1 << (7 - rate)) * 125;
* Rounded rate is therefore
* rate = 7 - __fls(interval * 4 / (125 * 3));
* Use clamp_val() to avoid overflows, and to ensure valid input
* for __fls.
*/
val = clamp_val(val, 125, 16000);
rate = 7 - __fls(val * 4 / (125 * 3));
mutex_lock(&data->update_lock);
i2c_smbus_write_byte_data(client, TMP401_CONVERSION_RATE_WRITE, rate);
data->update_interval = (1 << (7 - rate)) * 125;
mutex_unlock(&data->update_lock);
return count;
}
static SENSOR_DEVICE_ATTR_2(temp1_input, S_IRUGO, show_temp, NULL, 0, 0);
static SENSOR_DEVICE_ATTR_2(temp1_min, S_IWUSR | S_IRUGO, show_temp,
store_temp, 1, 0);
static SENSOR_DEVICE_ATTR_2(temp1_max, S_IWUSR | S_IRUGO, show_temp,
store_temp, 2, 0);
static SENSOR_DEVICE_ATTR_2(temp1_crit, S_IWUSR | S_IRUGO, show_temp,
store_temp, 3, 0);
static SENSOR_DEVICE_ATTR(temp1_crit_hyst, S_IWUSR | S_IRUGO,
show_temp_crit_hyst, store_temp_crit_hyst, 0);
static SENSOR_DEVICE_ATTR_2(temp1_min_alarm, S_IRUGO, show_status, NULL,
1, TMP432_STATUS_LOCAL);
static SENSOR_DEVICE_ATTR_2(temp1_max_alarm, S_IRUGO, show_status, NULL,
2, TMP432_STATUS_LOCAL);
static SENSOR_DEVICE_ATTR_2(temp1_crit_alarm, S_IRUGO, show_status, NULL,
3, TMP432_STATUS_LOCAL);
static SENSOR_DEVICE_ATTR_2(temp2_input, S_IRUGO, show_temp, NULL, 0, 1);
static SENSOR_DEVICE_ATTR_2(temp2_min, S_IWUSR | S_IRUGO, show_temp,
store_temp, 1, 1);
static SENSOR_DEVICE_ATTR_2(temp2_max, S_IWUSR | S_IRUGO, show_temp,
store_temp, 2, 1);
static SENSOR_DEVICE_ATTR_2(temp2_crit, S_IWUSR | S_IRUGO, show_temp,
store_temp, 3, 1);
static SENSOR_DEVICE_ATTR(temp2_crit_hyst, S_IRUGO, show_temp_crit_hyst,
NULL, 1);
static SENSOR_DEVICE_ATTR_2(temp2_fault, S_IRUGO, show_status, NULL,
0, TMP432_STATUS_REMOTE1);
static SENSOR_DEVICE_ATTR_2(temp2_min_alarm, S_IRUGO, show_status, NULL,
1, TMP432_STATUS_REMOTE1);
static SENSOR_DEVICE_ATTR_2(temp2_max_alarm, S_IRUGO, show_status, NULL,
2, TMP432_STATUS_REMOTE1);
static SENSOR_DEVICE_ATTR_2(temp2_crit_alarm, S_IRUGO, show_status, NULL,
3, TMP432_STATUS_REMOTE1);
static DEVICE_ATTR(update_interval, S_IRUGO | S_IWUSR, show_update_interval,
set_update_interval);
static struct attribute *tmp401_attributes[] = {
&sensor_dev_attr_temp1_input.dev_attr.attr,
&sensor_dev_attr_temp1_min.dev_attr.attr,
&sensor_dev_attr_temp1_max.dev_attr.attr,
&sensor_dev_attr_temp1_crit.dev_attr.attr,
&sensor_dev_attr_temp1_crit_hyst.dev_attr.attr,
&sensor_dev_attr_temp1_max_alarm.dev_attr.attr,
&sensor_dev_attr_temp1_min_alarm.dev_attr.attr,
&sensor_dev_attr_temp1_crit_alarm.dev_attr.attr,
&sensor_dev_attr_temp2_input.dev_attr.attr,
&sensor_dev_attr_temp2_min.dev_attr.attr,
&sensor_dev_attr_temp2_max.dev_attr.attr,
&sensor_dev_attr_temp2_crit.dev_attr.attr,
&sensor_dev_attr_temp2_crit_hyst.dev_attr.attr,
&sensor_dev_attr_temp2_fault.dev_attr.attr,
&sensor_dev_attr_temp2_max_alarm.dev_attr.attr,
&sensor_dev_attr_temp2_min_alarm.dev_attr.attr,
&sensor_dev_attr_temp2_crit_alarm.dev_attr.attr,
&dev_attr_update_interval.attr,
NULL
};
static const struct attribute_group tmp401_group = {
.attrs = tmp401_attributes,
};
/*
* Additional features of the TMP411 chip.
* The TMP411 stores the minimum and maximum
* temperature measured since power-on, chip-reset, or
* minimum and maximum register reset for both the local
* and remote channels.
*/
static SENSOR_DEVICE_ATTR_2(temp1_lowest, S_IRUGO, show_temp, NULL, 4, 0);
static SENSOR_DEVICE_ATTR_2(temp1_highest, S_IRUGO, show_temp, NULL, 5, 0);
static SENSOR_DEVICE_ATTR_2(temp2_lowest, S_IRUGO, show_temp, NULL, 4, 1);
static SENSOR_DEVICE_ATTR_2(temp2_highest, S_IRUGO, show_temp, NULL, 5, 1);
static SENSOR_DEVICE_ATTR(temp_reset_history, S_IWUSR, NULL, reset_temp_history,
0);
static struct attribute *tmp411_attributes[] = {
&sensor_dev_attr_temp1_highest.dev_attr.attr,
&sensor_dev_attr_temp1_lowest.dev_attr.attr,
&sensor_dev_attr_temp2_highest.dev_attr.attr,
&sensor_dev_attr_temp2_lowest.dev_attr.attr,
&sensor_dev_attr_temp_reset_history.dev_attr.attr,
NULL
};
static const struct attribute_group tmp411_group = {
.attrs = tmp411_attributes,
};
static SENSOR_DEVICE_ATTR_2(temp3_input, S_IRUGO, show_temp, NULL, 0, 2);
static SENSOR_DEVICE_ATTR_2(temp3_min, S_IWUSR | S_IRUGO, show_temp,
store_temp, 1, 2);
static SENSOR_DEVICE_ATTR_2(temp3_max, S_IWUSR | S_IRUGO, show_temp,
store_temp, 2, 2);
static SENSOR_DEVICE_ATTR_2(temp3_crit, S_IWUSR | S_IRUGO, show_temp,
store_temp, 3, 2);
static SENSOR_DEVICE_ATTR(temp3_crit_hyst, S_IRUGO, show_temp_crit_hyst,
NULL, 2);
static SENSOR_DEVICE_ATTR_2(temp3_fault, S_IRUGO, show_status, NULL,
0, TMP432_STATUS_REMOTE2);
static SENSOR_DEVICE_ATTR_2(temp3_min_alarm, S_IRUGO, show_status, NULL,
1, TMP432_STATUS_REMOTE2);
static SENSOR_DEVICE_ATTR_2(temp3_max_alarm, S_IRUGO, show_status, NULL,
2, TMP432_STATUS_REMOTE2);
static SENSOR_DEVICE_ATTR_2(temp3_crit_alarm, S_IRUGO, show_status, NULL,
3, TMP432_STATUS_REMOTE2);
static struct attribute *tmp432_attributes[] = {
&sensor_dev_attr_temp3_input.dev_attr.attr,
&sensor_dev_attr_temp3_min.dev_attr.attr,
&sensor_dev_attr_temp3_max.dev_attr.attr,
&sensor_dev_attr_temp3_crit.dev_attr.attr,
&sensor_dev_attr_temp3_crit_hyst.dev_attr.attr,
&sensor_dev_attr_temp3_fault.dev_attr.attr,
&sensor_dev_attr_temp3_max_alarm.dev_attr.attr,
&sensor_dev_attr_temp3_min_alarm.dev_attr.attr,
&sensor_dev_attr_temp3_crit_alarm.dev_attr.attr,
NULL
};
static const struct attribute_group tmp432_group = {
.attrs = tmp432_attributes,
};
/*
* Additional features of the TMP461 chip.
* The TMP461 temperature offset for the remote channel.
*/
static SENSOR_DEVICE_ATTR_2(temp2_offset, S_IWUSR | S_IRUGO, show_temp,
store_temp, 6, 1);
static struct attribute *tmp461_attributes[] = {
&sensor_dev_attr_temp2_offset.dev_attr.attr,
NULL
};
static const struct attribute_group tmp461_group = {
.attrs = tmp461_attributes,
};
/*
* Begin non sysfs callback code (aka Real code)
*/
static int tmp401_init_client(struct tmp401_data *data,
struct i2c_client *client)
{
int config, config_orig, status = 0;
/* Set the conversion rate to 2 Hz */
i2c_smbus_write_byte_data(client, TMP401_CONVERSION_RATE_WRITE, 5);
data->update_interval = 500;
/* Start conversions (disable shutdown if necessary) */
config = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
if (config < 0)
return config;
config_orig = config;
config &= ~TMP401_CONFIG_SHUTDOWN;
if (config != config_orig)
status = i2c_smbus_write_byte_data(client,
TMP401_CONFIG_WRITE,
config);
return status;
}
static int tmp401_detect(struct i2c_client *client,
struct i2c_board_info *info)
{
enum chips kind;
struct i2c_adapter *adapter = client->adapter;
u8 reg;
if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
return -ENODEV;
/* Detect and identify the chip */
reg = i2c_smbus_read_byte_data(client, TMP401_MANUFACTURER_ID_REG);
if (reg != TMP401_MANUFACTURER_ID)
return -ENODEV;
reg = i2c_smbus_read_byte_data(client, TMP401_DEVICE_ID_REG);
switch (reg) {
case TMP401_DEVICE_ID:
if (client->addr != 0x4c)
return -ENODEV;
kind = tmp401;
break;
case TMP411A_DEVICE_ID:
if (client->addr != 0x4c)
return -ENODEV;
kind = tmp411;
break;
case TMP411B_DEVICE_ID:
if (client->addr != 0x4d)
return -ENODEV;
kind = tmp411;
break;
case TMP411C_DEVICE_ID:
if (client->addr != 0x4e)
return -ENODEV;
kind = tmp411;
break;
case TMP431_DEVICE_ID:
if (client->addr != 0x4c && client->addr != 0x4d)
return -ENODEV;
kind = tmp431;
break;
case TMP432_DEVICE_ID:
if (client->addr != 0x4c && client->addr != 0x4d)
return -ENODEV;
kind = tmp432;
break;
case TMP435_DEVICE_ID:
kind = tmp435;
break;
default:
return -ENODEV;
}
reg = i2c_smbus_read_byte_data(client, TMP401_CONFIG_READ);
if (reg & 0x1b)
return -ENODEV;
reg = i2c_smbus_read_byte_data(client, TMP401_CONVERSION_RATE_READ);
/* Datasheet says: 0x1-0x6 */
if (reg > 15)
return -ENODEV;
strlcpy(info->type, tmp401_id[kind].name, I2C_NAME_SIZE);
return 0;
}
static int tmp401_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
static const char * const names[] = {
"TMP401", "TMP411", "TMP431", "TMP432", "TMP435", "TMP461"
};
struct device *dev = &client->dev;
struct device *hwmon_dev;
struct tmp401_data *data;
int groups = 0, status;
data = devm_kzalloc(dev, sizeof(struct tmp401_data), GFP_KERNEL);
if (!data)
return -ENOMEM;
data->client = client;
mutex_init(&data->update_lock);
data->kind = id->driver_data;
/* Initialize the TMP401 chip */
status = tmp401_init_client(data, client);
if (status < 0)
return status;
/* Register sysfs hooks */
data->groups[groups++] = &tmp401_group;
/* Register additional tmp411 sysfs hooks */
if (data->kind == tmp411)
data->groups[groups++] = &tmp411_group;
/* Register additional tmp432 sysfs hooks */
if (data->kind == tmp432)
data->groups[groups++] = &tmp432_group;
if (data->kind == tmp461)
data->groups[groups++] = &tmp461_group;
hwmon_dev = devm_hwmon_device_register_with_groups(dev, client->name,
data, data->groups);
if (IS_ERR(hwmon_dev))
return PTR_ERR(hwmon_dev);
dev_info(dev, "Detected TI %s chip\n", names[data->kind]);
return 0;
}
static struct i2c_driver tmp401_driver = {
.class = I2C_CLASS_HWMON,
.driver = {
.name = "tmp401",
},
.probe = tmp401_probe,
.id_table = tmp401_id,
.detect = tmp401_detect,
.address_list = normal_i2c,
};
module_i2c_driver(tmp401_driver);
MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
MODULE_DESCRIPTION("Texas Instruments TMP401 temperature sensor driver");
MODULE_LICENSE("GPL");

105
packages/platforms/delta/x86-64/x86-64-delta-agc7648sv1/onlp/builds/src/module/src/fani.c
View File

@@ -100,7 +100,8 @@ static int dni_fani_info_get_fan(int local_id, onlp_fan_info_t* info, char *dev_
uint8_t present_bit = 0x00;
UINT4 multiplier = 1;
UINT4 u4Data = 0;
int fantray_present = -1;
if(dni_bmc_check() == BMC_ON)
{
if(dni_bmc_sensor_read(dev_name, &u4Data, multiplier) == ONLP_STATUS_OK)
@@ -114,15 +115,40 @@ static int dni_fani_info_get_fan(int local_id, onlp_fan_info_t* info, char *dev_
present_bit = bit_data;
else
rv = ONLP_STATUS_E_INVALID;
switch(local_id) {
case FAN_4_ON_FAN_BOARD:
case FAN_8_ON_FAN_BOARD:
if((present_bit & 1) == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
case FAN_3_ON_FAN_BOARD:
case FAN_7_ON_FAN_BOARD:
if((present_bit & (1 << 1)) == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
case FAN_2_ON_FAN_BOARD:
case FAN_6_ON_FAN_BOARD:
if((present_bit & (1 << 2)) == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
case FAN_1_ON_FAN_BOARD:
case FAN_5_ON_FAN_BOARD:
if((present_bit & (1 << 3)) == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
}
}
else
{
dev_info_t dev_info;
dev_info.bus = I2C_BUS_27;
dev_info.addr = FAN_IO_CTL;
dev_info.offset = 0x00;
dev_info.flags = DEFAULT_FLAG;
sprintf(fullpath, "%s%s", PREFIX_PATH, fan_path[local_id].speed);
rpm = dni_i2c_lock_read_attribute(NULL, fullpath);
info->rpm = rpm;
@@ -133,38 +159,41 @@ static int dni_fani_info_get_fan(int local_id, onlp_fan_info_t* info, char *dev_
/* get speed percentage from rpm */
info->percentage = (info->rpm * 100)/MAX_FRONT_FAN_SPEED;
present_bit = dni_i2c_lock_read(NULL, &dev_info);
}
switch(local_id) {
case FAN_4_ON_FAN_BOARD:
case FAN_8_ON_FAN_BOARD:
if((present_bit & 1) == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
case FAN_3_ON_FAN_BOARD:
case FAN_7_ON_FAN_BOARD:
if((present_bit & (1 << 1)) == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
case FAN_2_ON_FAN_BOARD:
case FAN_6_ON_FAN_BOARD:
if((present_bit & (1 << 2)) == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
case FAN_1_ON_FAN_BOARD:
case FAN_5_ON_FAN_BOARD:
if((present_bit & (1 << 3)) == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
switch(local_id) {
case FAN_4_ON_FAN_BOARD:
case FAN_8_ON_FAN_BOARD:
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN4_PRESENT_PATH);
if(fantray_present == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
case FAN_3_ON_FAN_BOARD:
case FAN_7_ON_FAN_BOARD:
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN3_PRESENT_PATH);
if(fantray_present == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
case FAN_2_ON_FAN_BOARD:
case FAN_6_ON_FAN_BOARD:
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN2_PRESENT_PATH);
if(fantray_present == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
case FAN_1_ON_FAN_BOARD:
case FAN_5_ON_FAN_BOARD:
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN1_PRESENT_PATH);
if(fantray_present == 0)
info->status |= ONLP_FAN_STATUS_PRESENT;
else
info->status |= ONLP_FAN_STATUS_FAILED;
break;
}
}
return rv;

22
packages/platforms/delta/x86-64/x86-64-delta-agc7648sv1/onlp/builds/src/module/src/platform_lib.c
View File

@@ -363,11 +363,10 @@ int dni_lock_cpld_write_attribute(char *cpld_path, int addr, int data)
int dni_fan_present(int id)
{
int rv;
dev_info_t dev_info;
int bit_data = 0;
int data = 0;
uint8_t present_bit = 0x00;
int fantray_present = 0;
int fantray_present = -1;
if(dni_bmc_check() == BMC_ON)
{
@@ -386,30 +385,23 @@ int dni_fan_present(int id)
}
else if(dni_bmc_check() == BMC_OFF)
{
dev_info.offset = 0x00;
dev_info.flags = DEFAULT_FLAG;
switch(id) {
case LED_REAR_FAN_TRAY_1:
dev_info.addr = FAN_TRAY_1;
dev_info.bus = I2C_BUS_21;
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN1_PRESENT_PATH);
break;
case LED_REAR_FAN_TRAY_2:
dev_info.addr = FAN_TRAY_2;
dev_info.bus = I2C_BUS_22;
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN2_PRESENT_PATH);
break;
case LED_REAR_FAN_TRAY_3:
dev_info.addr = FAN_TRAY_3;
dev_info.bus = I2C_BUS_23;
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN3_PRESENT_PATH);
break;
case LED_REAR_FAN_TRAY_4:
dev_info.addr = FAN_TRAY_4;
dev_info.bus = I2C_BUS_24;
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN4_PRESENT_PATH);
break;
}
fantray_present = dni_i2c_lock_read(NULL, &dev_info);
if(fantray_present >= 0)
if(fantray_present == 0)
rv = ONLP_STATUS_OK;
else
else if(fantray_present == 1)
rv = ONLP_STATUS_E_INVALID;
}
else

4
packages/platforms/delta/x86-64/x86-64-delta-agc7648sv1/onlp/builds/src/module/src/platform_lib.h
View File

@@ -83,6 +83,10 @@ typedef unsigned int UINT4;
#define PSU1_AC_PMBUS_PREFIX "/sys/bus/i2c/devices/31-0058/"
#define PSU2_AC_PMBUS_PREFIX "/sys/bus/i2c/devices/32-0058/"
#define PSU2_AC_PMBUS_NODE(node) PSU2_AC_PMBUS_PREFIX#node
#define FAN1_PRESENT_PATH "/sys/class/gpio/gpio499/value"
#define FAN2_PRESENT_PATH "/sys/class/gpio/gpio498/value"
#define FAN3_PRESENT_PATH "/sys/class/gpio/gpio497/value"
#define FAN4_PRESENT_PATH "/sys/class/gpio/gpio496/value"
/* REG define */
#define SWPLD_1_ADDR (0x6A)

29
packages/platforms/delta/x86-64/x86-64-delta-agc7648sv1/onlp/builds/src/module/src/sysi.c
View File

@@ -202,31 +202,31 @@ int onlp_sysi_platform_manage_fans(void)
int onlp_sysi_platform_manage_leds(void)
{
int rpm = 0, rpm1 = 0, count = 0;
uint8_t present_bit = 0x00;
int rv;
int fantray_count;
char fantray_count_str[2];
uint8_t psu_state;
int psu_pwr_status = 0;
int psu_pwr_int = 0;
dev_info_t dev_info;
int fantray_present = -1;
char fullpath[50] = {'\0'};
if(dni_bmc_check() == BMC_ON)
{
rv = ONLP_STATUS_OK;
}
else{
else {
dev_info.offset = 0x00;
dev_info.flags = DEFAULT_FLAG;
dev_info.addr = FAN_IO_CTL;
dev_info.bus = I2C_BUS_27;
dev_info.size = 1;
present_bit = dni_i2c_lock_read(NULL, &dev_info);
/* Fan tray 1 */
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN1_PRESENT_PATH);
rpm = dni_i2c_lock_read_attribute(NULL, FAN1_FRONT);
rpm1 = dni_i2c_lock_read_attribute(NULL, FAN1_REAR);
if((present_bit & (1 << 3)) == 0 && rpm != FAN_ZERO_RPM && rpm != 0 && rpm1 != FAN_ZERO_RPM && rpm1 != 0 )
if(fantray_present == 0 && rpm != FAN_ZERO_RPM && rpm != 0 && rpm1 != FAN_ZERO_RPM && rpm1 != 0 )
{
/* Green */
if(onlp_ledi_mode_set(ONLP_LED_ID_CREATE(LED_REAR_FAN_TRAY_1),ONLP_LED_MODE_GREEN) != ONLP_STATUS_OK)
@@ -240,10 +240,11 @@ int onlp_sysi_platform_manage_leds(void)
}
/* Fan tray 2 */
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN2_PRESENT_PATH);
rpm = dni_i2c_lock_read_attribute(NULL, FAN2_FRONT);
rpm1 = dni_i2c_lock_read_attribute(NULL, FAN2_REAR);
if((present_bit & (1 << 2)) == 0 && rpm != FAN_ZERO_RPM && rpm != 0 && rpm1 != FAN_ZERO_RPM && rpm1 != 0 )
if(fantray_present == 0 && rpm != FAN_ZERO_RPM && rpm != 0 && rpm1 != FAN_ZERO_RPM && rpm1 != 0 )
{
/* Green */
if(onlp_ledi_mode_set(ONLP_LED_ID_CREATE(LED_REAR_FAN_TRAY_2),ONLP_LED_MODE_GREEN) != ONLP_STATUS_OK)
@@ -257,10 +258,11 @@ int onlp_sysi_platform_manage_leds(void)
}
/* Fan tray 3 */
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN3_PRESENT_PATH);
rpm = dni_i2c_lock_read_attribute(NULL, FAN3_FRONT);
rpm1 = dni_i2c_lock_read_attribute(NULL, FAN3_REAR);
if((present_bit & (1 << 1)) == 0 && rpm != FAN_ZERO_RPM && rpm != 0 && rpm1 != FAN_ZERO_RPM && rpm1 != 0 )
if(fantray_present == 0 && rpm != FAN_ZERO_RPM && rpm != 0 && rpm1 != FAN_ZERO_RPM && rpm1 != 0 )
{
/* Green */
if(onlp_ledi_mode_set(ONLP_LED_ID_CREATE(LED_REAR_FAN_TRAY_3),ONLP_LED_MODE_GREEN) != ONLP_STATUS_OK)
@@ -274,10 +276,11 @@ int onlp_sysi_platform_manage_leds(void)
}
/* Fan tray 4 */
fantray_present = dni_i2c_lock_read_attribute(NULL, FAN4_PRESENT_PATH);
rpm = dni_i2c_lock_read_attribute(NULL, FAN4_FRONT);
rpm1 = dni_i2c_lock_read_attribute(NULL, FAN4_REAR);
if((present_bit & 1) == 0 && rpm != FAN_ZERO_RPM && rpm != 0 && rpm1 != FAN_ZERO_RPM && rpm1 != 0 )
if(fantray_present == 0 && rpm != FAN_ZERO_RPM && rpm != 0 && rpm1 != FAN_ZERO_RPM && rpm1 != 0 )
{
/* Green */
if(onlp_ledi_mode_set(ONLP_LED_ID_CREATE(LED_REAR_FAN_TRAY_4),ONLP_LED_MODE_GREEN) != ONLP_STATUS_OK)
@@ -291,10 +294,12 @@ int onlp_sysi_platform_manage_leds(void)
}
/* FRONT FAN & SYS LED */
for(fantray_count = 0; fantray_count < 4; fantray_count++)
for(fantray_count = 9; fantray_count > 5 ; fantray_count--)
{
present_bit = dni_i2c_lock_read(NULL, &dev_info);
if((present_bit & (1 << fantray_count)) == 0)
sprintf(fantray_count_str, "%d", fantray_count);
sprintf(fullpath, "/sys/class/gpio/gpio49%s/value", fantray_count_str);
fantray_present = dni_i2c_lock_read_attribute(NULL, fullpath);
if(fantray_present == 0)
count++;
}

22
packages/platforms/delta/x86-64/x86-64-delta-agc7648sv1/platform-config/r0/src/python/x86_64_delta_agc7648sv1_r0/__init__.py
View File

@@ -1,5 +1,6 @@
from onl.platform.base import *
from onl.platform.delta import *
import os.path
class OnlPlatform_x86_64_delta_agc7648sv1_r0(OnlPlatformDelta,
OnlPlatformPortConfig_32x100):
@@ -10,23 +11,32 @@ class OnlPlatform_x86_64_delta_agc7648sv1_r0(OnlPlatformDelta,
def baseconfig(self):
#Remove and rescan bus
os.system("echo 1 >/sys/bus/i2c/devices/i2c-0/firmware_node/physical_node/remove")
os.system("echo 1 > /sys/bus/i2c/devices/i2c-0/firmware_node/physical_node/remove")
os.system("echo 1 > /sys/bus/pci/rescan")
#insert tmp401(tmp431/tmp432) module
self.insmod('tmp401')
#Insert gpio_pca953x module
os.system('modprobe gpio_pca953x')
#insert platform module
#Insert tmp401(tmp431/tmp432) module
os.system('modprobe tmp401')
#Insert platform module
self.insmod('delta_agc7648sv1_platform')
#Insert psu module
self.insmod('dni_agc7648sv1_psu')
#insert fan module
#Insert fan module
self.insmod('dni_emc2305')
#insert qsfp mosule
#Insert qsfp mosule
self.insmod('optoe')
#Fantray present(fan1:499, fan2:498, fan3:497, fan4:496)
os.system("echo 496 > /sys/class/gpio/export")
os.system("echo 497 > /sys/class/gpio/export")
os.system("echo 498 > /sys/class/gpio/export")
os.system("echo 499 > /sys/class/gpio/export")
return True