matthew/sonic-buildimage
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
fbd4e452c7
sonic-buildimage/platform/innovium/sonic-platform-modules-cameo/esqc610-56sq/modules/x86-64-cameo-esqc610-56sq.c

2427 lines
74 KiB
C
Raw Normal View History

[201911] [Innovium] Add new platforms and config updates (#7545) Update Innovium configs + Add new platforms supporting Innovium chips
2021-05-17 14:30:20 -05:00
/* An hwmon driver for Cameo ESQC610-56SQ Innovium i2c Module */
#pragma GCC diagnostic ignored "-Wformat-zero-length"
#include "x86-64-cameo-esqc610-56sq.h"
/* Addresses scanned */
static const unsigned short normal_i2c[] = { 0x30, 0x31, 0x32, I2C_CLIENT_END };
#if (defined THEMAL_WANTED)|| (defined ASPEED_BMC_WANTED)
int read_8bit_temp(u8 sign,u8 value)
{
int result = 0;
if(sign)
{
//printf("read_8bit_temp UP %d\n", value & 0x80);
value = ~(value)+1;
result = value;
return result;
}
else
{
//printf("read_8bit_temp DOWN %d\n", value & 0x80);
result = value;
return result;
}
}
#endif
/* i2c-0 function */
static ssize_t psu_status_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 bmc_present = -EPERM;
u8 status = -EPERM;
u8 mask = 0x1;
u8 res = 0x1;
int i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
bmc_present = i2c_smbus_read_byte_data(ESQC_610_i2c_client, BMC_PRESENT_OFFSET);
if (bmc_present & mask)
{
status = i2c_smbus_read_byte_data(Cameo_BMC_client, 0xc0); //BMC 0x14 0xc0
}
else
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_5_client, 0xa0); //CPLD 0x35 0xa0
}
debug_print((KERN_DEBUG "DEBUG : PSU_PRESENT status = %x\n",status));
sprintf(buf, "");
switch (attr->index)
{
case PSU_PRESENT:
for (i = 1; i <= 2; i++)
{
if (status & res)
{
sprintf(buf, "%sPSU %d is present\n", buf, i);
}
else
{
sprintf(buf, "%sPSU %d is not present\n", buf, i);
}
res = res << 1;
}
break;
case PSU_STATUS:
res = 0x1;
res = res << 2;
if (status & res)
{
sprintf(buf, "%sPSU 1 is not power Good\n", buf);
}
else
{
sprintf(buf, "%sPSU 1 is power Good\n", buf);
}
res = 0x1;
res = res << 3;
if (status & res)
{
sprintf(buf, "%sPSU 2 is not power Good\n", buf);
}
else
{
sprintf(buf, "%sPSU 2 is power Good\n", buf);
}
break;
}
return sprintf(buf, "%s\n", buf);
}
#ifdef THEMAL_WANTED
static long read_reg_linear(s32 data)
{
s16 exponent;
s32 mantissa;
long val;
exponent = ((s16)data) >> 11;
mantissa = ((s16)((data & 0x7ff) << 5)) >> 5;
val = mantissa;
val = val * 1000L;
if (exponent >= 0)
val <<= exponent;
else
val >>= -exponent;
return val/1000;
}
static long read_reg_linear_1000(s32 data)
{
s16 exponent;
s32 mantissa;
long val;
exponent = ((s16)data) >> 11;
mantissa = ((s16)((data & 0x7ff) << 5)) >> 5;
val = mantissa;
val = val * 1000L;
if (exponent >= 0)
val <<= exponent;
else
val >>= -exponent;
return val;
}
static long read_reg_linear_auto(s8 mode, u16 data)
{
s16 exponent;
s32 mantissa;
long val;
exponent = ((s8)(mode << 3)) >> 3;
mantissa = ((u16)data);
val = mantissa;
/*printk(KERN_ALERT "exponent= %d, mantissa= %d, val= %d\n",exponent,mantissa,val);*/
if (exponent >= 0)
val <<= exponent;
else
val >>= -exponent;
return val*1000;
}
#endif
#ifdef PSU_DEBUG
static long read_reg_vid(s32 data)
{
long val;
val = (((data-1)*5)+250)*1000L;
return val/1000;
}
static long read_reg_vid_10mv(s32 data)
{
long val;
val = (((data-1)*10)+500)*1000L;
return val/1000;
}
static long read_reg_vid_13mv(s32 data)
{
long val;
val = ((((data-1)*1333)+65000)/100)*1000L;
return val/1000;
}
#endif
#ifdef PSU_STAT_WANTED
static int two_complement_to_int(u16 data, u8 valid_bit, int mask)
{
u16 valid_data = data & mask;
bool is_negative = valid_data >> (valid_bit - 1);
return is_negative ? (-(((~valid_data) & mask) + 1)) : valid_data;
}
static ssize_t psu_module_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 bmc_present = -EPERM;
u8 module_num = 0;
u8 psu_table [3][11] =
{
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
{0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a},
{0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a}
};
u32 psu_status [11] = {0};
u8 mask = 0x1;
u8 i = 0;
u16 u16_val = 0;
int exponent = 0, mantissa = 0;
int multiplier = 1000; // lm-sensor uint: mV, mA, mC
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
sprintf(buf, "\n");
bmc_present = i2c_smbus_read_byte_data(ESQC_610_i2c_client, BMC_PRESENT_OFFSET);
if (bmc_present & mask)
{
switch(attr->index)
{
case PSU_MODULE_1:
module_num = 1;
break;
case PSU_MODULE_2:
module_num = 2;
break;
}
for(i = 0; i < 10; i ++)
{
u16_val = i2c_smbus_read_word_data(Cameo_BMC_client, psu_table[module_num][i]);
/* word data with linear format */
if (i != 2 && i != 8) {
multiplier = 1000;
if (i == 6 || i == 7) /* pin, pout */
multiplier = 1000000; // lm-sensor unit: uW
if ( i == 5 ) /* fan_speed */
multiplier = 1;
exponent = two_complement_to_int(u16_val >> 11, 5, 0x1f);
mantissa = two_complement_to_int(u16_val & 0x7ff, 11, 0x7ff);
psu_status[i] = (exponent >= 0) ? ((mantissa << exponent)*multiplier) : \
(mantissa*multiplier / (1 << -exponent));
}
}
/* vout mode */
multiplier = 1000;
u16_val = i2c_smbus_read_byte_data(Cameo_BMC_client, psu_table[module_num][10]);
psu_status[10] = u16_val;
exponent = two_complement_to_int(u16_val & 0x1f, 5, 0x1f);
/* vout */
u16_val = i2c_smbus_read_word_data(Cameo_BMC_client, psu_table[module_num][2]);
psu_status[2] = (exponent >= 0) ? ((u16_val << exponent)*multiplier) : \
(u16_val*multiplier / (1 << -exponent));
sprintf(buf, "%sPSU %d VIN is %d\n", buf, module_num, psu_status[0]);
sprintf(buf, "%sPSU %d IIN is %d\n", buf, module_num, psu_status[1]);
sprintf(buf, "%sPSU %d VOUT is %d\n", buf, module_num, psu_status[2]);
sprintf(buf, "%sPSU %d IOUT is %d\n", buf, module_num, psu_status[3]);
sprintf(buf, "%sPSU %d TEMP_1 is %d\n", buf, module_num, psu_status[4]);
sprintf(buf, "%sPSU %d FAN_SPEED is %d\n", buf, module_num, psu_status[5]);
sprintf(buf, "%sPSU %d POUT is %d\n", buf, module_num, psu_status[6]);
sprintf(buf, "%sPSU %d PIN is %d\n", buf, module_num, psu_status[7]);
sprintf(buf, "%sPSU %d MFR_MODEL is %d\n", buf, module_num, psu_status[8]);
sprintf(buf, "%sPSU %d MFR_IOUT_MAX is %d\n", buf, module_num, psu_status[9]);
sprintf(buf, "%sPSU %d VMODE is %d\n", buf, module_num, psu_status[10]);
}
else
{
sprintf(buf, "%sBMC Module is not present\n", buf);
}
return sprintf(buf, "%s", buf);
}
static ssize_t dc_chip_switch_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 bmc_present = -EPERM;
u8 dc_table [12] = {0x90, 0x91, 0x92, 0x94, 0x95, 0x96, 0x98, 0x99, 0x9a, 0x9c, 0x9d, 0x9e};
u16 dc_status [12] = {0};
u8 mask = 0x1;
u8 i = 0;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
sprintf(buf, "\n");
if (attr->index == DC_CHIP_SWITCH)
{
bmc_present = i2c_smbus_read_byte_data(ESQC_610_i2c_client, BMC_PRESENT_OFFSET); //CPLD 0x30 0xa4
if (bmc_present & mask)
{
for(i = 0; i < 12; i ++)
{
dc_status[i] = i2c_smbus_read_word_data(Cameo_BMC_client, dc_table[i]);
}
sprintf(buf, "%sTPS53681 0x6e page 0 Vin 0x%x\n", buf, dc_status[0]);
sprintf(buf, "%sTPS53681 0x6e page 0 Iout 0x%x\n", buf, dc_status[1]);
sprintf(buf, "%sTPS53681 0x6e page 0 Pout 0x%x\n", buf, dc_status[2]);
sprintf(buf, "%sTPS53681 0x6e page 1 Vin 0x%x\n", buf, dc_status[3]);
sprintf(buf, "%sTPS53681 0x6e page 1 Iout 0x%x\n", buf, dc_status[4]);
sprintf(buf, "%sTPS53681 0x6e page 1 Pout 0x%x\n", buf, dc_status[5]);
sprintf(buf, "%sTPS53681 0x70 page 0 Vin 0x%x\n", buf, dc_status[6]);
sprintf(buf, "%sTPS53681 0x70 page 0 Iout 0x%x\n", buf, dc_status[7]);
sprintf(buf, "%sTPS53681 0x70 page 0 Pout 0x%x\n", buf, dc_status[8]);
sprintf(buf, "%sTPS53681 0x70 page 1 Vin 0x%x\n", buf, dc_status[9]);
sprintf(buf, "%sTPS53681 0x70 page 1 Iout 0x%x\n", buf, dc_status[10]);
sprintf(buf, "%sTPS53681 0x70 page 1 Pout 0x%x\n", buf, dc_status[11]);
}
else
{
sprintf(buf, "%sBMC Module is not present\n", buf);
}
}
return sprintf(buf, "%s\n", buf);
}
#endif
#ifdef USB_CTRL_WANTED
static ssize_t usb_power_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 res = 0x1;
int i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa0);
debug_print((KERN_DEBUG "DEBUG : USB_POWER status = %x\n",status));
sprintf(buf, "");
if (attr->index == USB_POWER)
{
for (i = 1; i <= 2; i++)
{
if (i == GET_USB)
{
if (status & res)
{
sprintf(buf, "%sUSB Power is ON\n", buf);
}
else
{
sprintf(buf, "%sUSB Power is OFF\n", buf);
}
}
res = res << 1;
}
}
return sprintf(buf, "%s\n", buf);
}
static ssize_t usb_power_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = -EPERM;
u8 value = -EPERM;
u8 result = -EPERM;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *data = i2c_get_clientdata(ESQC_610_i2c_client);
mutex_lock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_lock\n"));
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa0);
debug_print((KERN_DEBUG "DEBUG : USB_POWER status = %x\n",status));
if (attr->index == USB_POWER)
{
i = simple_strtol(buf, NULL, 10);
if (i == TURN_ON)
{
value = status | USB_ON;
debug_print((KERN_DEBUG "DEBUG : USB_POWER value = %x\n",value));
result = i2c_smbus_write_byte_data(ESQC_610_i2c_client, 0xa0, value);
debug_print((KERN_DEBUG "DEBUG : USB_POWER result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: usb_ctrl_set ON FAILED!\n");
}
else
{
debug_print((KERN_DEBUG "USB Power is ON\n"));
}
}
else if (i == TURN_OFF)
{
value = status & USB_OFF;
debug_print((KERN_DEBUG "DEBUG : USB_POWER value = %x\n",value));
result = i2c_smbus_write_byte_data(ESQC_610_i2c_client, 0xa0, value);
debug_print((KERN_DEBUG "DEBUG : USB_POWER result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: usb_power_set OFF FAILED!\n");
}
else
{
debug_print((KERN_DEBUG "USB Power is OFF\n"));
}
}
else
{
printk(KERN_ALERT "USB_POWER set wrong Value\n");
}
}
mutex_unlock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
return count;
}
#endif
#ifdef LED_CTRL_WANTED
static ssize_t led_ctrl_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 res = 0x1;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
if (attr->index == LED_CTRL)
{
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa0);
debug_print((KERN_DEBUG "DEBUG : LED_CTRL status = %x\n",status));
sprintf(buf, "");
if (status & res)
{
sprintf(buf, "%sFiber LED is set to ON\n", buf);
}
else
{
sprintf(buf, "%sFiber LED is set to OFF\n", buf);
}
}
return sprintf(buf, "%s\n", buf);
}
static ssize_t led_ctrl_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = 0;
u8 value = 0;
u8 result = 0;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *data = i2c_get_clientdata(ESQC_610_i2c_client);
mutex_lock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_lock\n"));
if (attr->index == LED_CTRL)
{
i = simple_strtol(buf, NULL, 10);
if (i == TURN_ON)
{
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa0);
debug_print((KERN_DEBUG "DEBUG : LED_CTRL status = %x\n",status));
value = status | LED_ON;
debug_print((KERN_DEBUG "DEBUG : LED_CTRL value = %x\n",value));
result = i2c_smbus_write_byte_data(ESQC_610_i2c_client, 0xa0, value);
debug_print((KERN_DEBUG "DEBUG : LED_CTRL result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: led_ctrl_set on FAILED!\n");
}
else
{
debug_print((KERN_DEBUG "DEBUG : Fiber LED is set to ON\n"));
}
}
else if (i == TURN_OFF)
{
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa0);
debug_print((KERN_DEBUG "DEBUG : LED_CTRL status = %x\n",status));
value = status & LED_OFF;
debug_print((KERN_DEBUG "DEBUG : LED_CTRL value = %x\n",value));
result = i2c_smbus_write_byte_data(ESQC_610_i2c_client, 0xa0, value);
debug_print((KERN_DEBUG "DEBUG : LED_CTRL result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: led_ctrl_set off FAILED!\n");
}
else
{
debug_print((KERN_DEBUG "DEBUG : Fiber LED is set to OFF\n"));
}
}
else
{
printk(KERN_ALERT "LED set wrong Value\n");
}
}
mutex_unlock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
return count;
}
#endif
static ssize_t sys_led_ctrl_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 res = 0x1;
int i;
int led_a_status = 0;
int led_g_status = 0;
int led_b_status = 0;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa2); //to get register 0x30 0xa2
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_get led status = %x\n",status));
sprintf(buf, "");
for (i = 1; i <= 4; i++)
{
if ( i == attr->index)
{
if (status & res)
{
led_a_status = TURN_ON;
}
else
{
led_a_status = TURN_OFF;
}
}
res = res << 1;
if( i == (attr->index + 1) )
{
if (status & res)
{
led_g_status = TURN_ON;
}
else
{
led_g_status = TURN_OFF;
}
}
res = res << 1;
}
res = 0x1;
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa3); //to get register 0x30 0xa3
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_get blk status = %x\n",status));
for (i = 1; i <= 4; i++)
{
if ( i == attr->index)
{
if (status & res)
{
led_b_status = TURN_ON;
}
else
{
led_b_status = TURN_OFF;
}
}
res = res << 1;
}
if(attr->index == 1)
{
sprintf(buf, "%sSYS LED is set to ", buf);
}
else if(attr->index == 2)
{
sprintf(buf, "%sFLOW LED is set to ", buf);
}
else if(attr->index == 3)
{
sprintf(buf, "%sSwitch LED 1 is set to ", buf);
}
else if(attr->index == 4)
{
sprintf(buf, "%sSwitch LED 2 is set to ", buf);
}
if(led_a_status == TURN_ON && led_b_status == TURN_ON)
{
sprintf(buf, "%samber and blink\n", buf);
}
else if(led_a_status == TURN_ON && led_b_status == TURN_OFF)
{
sprintf(buf, "%samber\n", buf);
}
else if(led_g_status == TURN_ON && led_b_status == TURN_ON)
{
sprintf(buf, "%sgreen and blink\n", buf);
}
else if(led_g_status == TURN_ON && led_b_status == TURN_OFF)
{
sprintf(buf, "%sgreen\n", buf);
}
else
{
sprintf(buf, "%sOFF\n", buf);
}
return sprintf(buf, "%s", buf);
}
static ssize_t sys_led_ctrl_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 led_value = -EPERM;
u8 blk_value = -EPERM;
u8 result = -EPERM;
u8 offset = 0;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *data = i2c_get_clientdata(ESQC_610_i2c_client);
mutex_lock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_set lock\n"));
led_value = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa2);
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_set led_value = %x\n",led_value));
blk_value = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa3);
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_set blk_value = %x\n",blk_value));
if (attr->index != 0)
{
i = simple_strtol(buf, NULL, 10);
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_set value = %d\n",i));
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_set led attr->index = %d\n",attr->index));
if(attr->index == 1)
{
offset = 0;
}
else
{
offset = 2*((attr->index)-1);
}
switch(i)
{
case SWITCH_LED_OFF: //i=0
led_value &= ~(0x03 << offset);
blk_value &= ~(1 << ((attr->index)-1));
break;
case SWITCH_LED_A_N: //i=1
led_value &= ~(0x03 << offset);
led_value |= (0x01 << offset);
blk_value &= ~(1 << ((attr->index)-1));
break;
case SWITCH_LED_A_B: //i=2
led_value &= ~(0x03 << offset);
led_value |= (0x01 << offset);
blk_value |= (1 << ((attr->index)-1));
break;
case SWITCH_LED_G_N: //i=3
led_value &= ~(0x03 << offset);
led_value |= (0x02 << offset);
blk_value &= ~(1 << ((attr->index)-1));
break;
case SWITCH_LED_G_B: //i=4
led_value &= ~(0x03 << offset);
led_value |= (0x02 << offset);
blk_value |= (1 << ((attr->index)-1));
break;
default:
printk(KERN_ALERT "Switch LED set wrong Value\n");
}
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_set led_value = %x\n",led_value));
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_set blk_value = %x\n",blk_value));
result = i2c_smbus_write_byte_data(ESQC_610_i2c_client, 0xa2, led_value);
result |= i2c_smbus_write_byte_data(ESQC_610_i2c_client, 0xa3, blk_value);
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_set result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: sys_led_ctrl_set SYS_LED_OFF FAILED!\n");
}
else
{
debug_print((KERN_DEBUG "Switch LED is set Success\n"));
}
}
mutex_unlock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : sys_led_ctrl_set unlock\n"));
return count;
}
static ssize_t reset_mac_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = 0;
u8 value = 0;
u8 result = 0;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *data = i2c_get_clientdata(ESQC_610_i2c_client);
mutex_lock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_lock\n"));
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa1);
debug_print((KERN_DEBUG "DEBUG : RESET_MAC status = %x\n",status));
if (attr->index == RESET_MAC)
{
i = simple_strtol(buf, NULL, 10);
if (i == 0)
{
value = 0x0;
debug_print((KERN_DEBUG "DEBUG : RESET_MAC value = %x\n",value));
result = i2c_smbus_write_byte_data(ESQC_610_i2c_client, 0xa1, value);
debug_print((KERN_DEBUG "DEBUG : RESET_MAC result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: RESET_MAC set FAILED!\n");
}
else
{
debug_print((KERN_DEBUG "Switch MAC chip is reset\n"));
}
}
else
{
printk(KERN_ALERT "RESET_MAC set wrong Value\n");
}
}
mutex_unlock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
return count;
}
static ssize_t shutdown_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = 0;
u8 value = 0;
u8 result = 0;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *data = i2c_get_clientdata(ESQC_610_i2c_client);
mutex_lock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_lock\n"));
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa1);
debug_print((KERN_DEBUG "DEBUG : shutdown_set status = %x\n",status));
if (attr->index == SHUTDOWN_DUT)
{
i = simple_strtol(buf, NULL, 10);
if (i == 1)
{
value = status & 0xef;
debug_print((KERN_DEBUG "DEBUG : shutdown_set value = %x\n",value));
result = i2c_smbus_write_byte_data(ESQC_610_i2c_client, 0xa1, value);
debug_print((KERN_DEBUG "DEBUG : shutdown_set result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: shutdown_set set FAILED!\n");
}
else
{
debug_print((KERN_DEBUG "Switch is shutdown\n"));
}
}
else
{
printk(KERN_ALERT "shutdown_set set wrong Value\n");
}
}
mutex_unlock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
return count;
}
static ssize_t themal_status_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 res = 0x1;
int i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xc0);
debug_print((KERN_DEBUG "DEBUG : SENSOR_STATUS status = %x\n",status));
sprintf(buf, "");
if (attr->index == SENSOR_STATUS)
{
for (i = 1; i <= 4; i++)
{
if (status & res)
{
sprintf(buf, "%sSensor %d is OK\n", buf, i);
}
else
{
sprintf(buf, "%sSensor %d is NG\n", buf, i);
}
res = res << 1;
}
}
return sprintf(buf, "%s\n", buf);
}
#ifdef THEMAL_WANTED
static ssize_t themal_temp_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 channel_status = -EPERM;
int i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *Switch_2_data = i2c_get_clientdata(Cameo_Switch_2_client);
struct Cameo_i2c_data *Sensor_data = i2c_get_clientdata(Cameo_Sensor_client);
i = attr->index;
debug_print((KERN_DEBUG "DEBUG : themal_temp_get %d\n", i));
mutex_lock(&Switch_2_data->update_lock);
mutex_lock(&Sensor_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : themal_temp_get mutex_lock\n"));
sprintf(buf, "");
if (attr->index == SENSOR_TEMP)
{
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x02);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: themal_temp_get set channel 2 FAILED\n");
}
status = i2c_smbus_read_byte_data(Cameo_Sensor_client, 0X0);
debug_print((KERN_DEBUG "DEBUG : Sensor 1 status = %x\n",status));
if(status & 0x80)
{
sprintf(buf, "%sSensor 1 temp is -%d degrees (C)\n", buf, read_8bit_temp((status & 0x80),status));
}
else
{
sprintf(buf, "%sSensor 1 temp is %d degrees (C)\n", buf, read_8bit_temp((status & 0x80),status));
}
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x04);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: themal_temp_get set channel 3 FAILED\n");
}
status = i2c_smbus_read_byte_data(Cameo_Sensor_client, 0X0);
debug_print((KERN_DEBUG "DEBUG : Sensor 2 status = %x\n",status));
if(status & 0x80)
{
sprintf(buf, "%sSensor 2 temp is -%d degrees (C)\n", buf, read_8bit_temp((status & 0x80),status));
}
else
{
sprintf(buf, "%sSensor 2 temp is %d degrees (C)\n", buf, read_8bit_temp((status & 0x80),status));
}
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x08);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: themal_temp_get set channel 4 FAILED\n");
}
status = i2c_smbus_read_byte_data(Cameo_Sensor_client, 0X0);
debug_print((KERN_DEBUG "DEBUG : Sensor 3 status = %x\n",status));
if(status & 0x80)
{
sprintf(buf, "%sSensor 3 temp is -%d degrees (C)\n", buf, read_8bit_temp((status & 0x80),status));
}
else
{
sprintf(buf, "%sSensor 3 temp is %d degrees (C)\n", buf, read_8bit_temp((status & 0x80),status));
}
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x01);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: themal_temp_get set channel 1 FAILED\n");
}
status = i2c_smbus_read_byte_data(Cameo_Sensor_fan_client, 0X1);
debug_print((KERN_DEBUG "DEBUG : Sensor 4 status = %x\n",status));
if(status & 0x80)
{
sprintf(buf, "%sSensor 4 temp is -%d degrees (C)\n", buf, read_8bit_temp((status & 0x80),status));
}
else
{
sprintf(buf, "%sSensor 4 temp is %d degrees (C)\n", buf, read_8bit_temp((status & 0x80),status));
}
}
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x0);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: themal_temp_get reset channel FAILED\n");
}
mutex_unlock(&Switch_2_data->update_lock);
mutex_unlock(&Sensor_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
return sprintf(buf, "%s\n", buf);
}
#endif
static ssize_t themal_mask_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 res = 0x1;
int i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xc1);
debug_print((KERN_DEBUG "DEBUG : SENSOR_INT_MASK status = %x\n",status));
sprintf(buf, "");
if (attr->index == SENSOR_INT_MASK)
{
for (i = 1; i <= 4; i++)
{
if (status & res)
{
sprintf(buf, "%sSensor %d interrupt is enabled\n", buf, i);
}
else
{
sprintf(buf, "%sSensor %d interrupt is disabled\n", buf, i);
}
res = res << 1;
}
}
return sprintf(buf, "%s\n", buf);
}
static ssize_t themal_mask_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = -EPERM;
u8 value = -EPERM;
u8 result = -EPERM;
u8 res = 0x1;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *data = i2c_get_clientdata(ESQC_610_i2c_client);
mutex_lock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : themal_mask_set mutex_lock\n"));
i = simple_strtol(buf, NULL, 10);
debug_print((KERN_DEBUG "DEBUG : themal_mask_set input %d\n", i));
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xc1);
debug_print((KERN_DEBUG "DEBUG : themal_mask_set status = %x\n",status));
if (attr->index == 1)
{
if (i == TURN_ON)
{
value = status | res;
}
else if (i == TURN_OFF)
{
value = status & (~res);
}
else
{
printk(KERN_ALERT "themal_mask_set set wrong value\n");
}
}
else if (attr->index == 2)
{
res = res << 1;
if (i == TURN_ON)
{
value = status | res;
}
else if (i == TURN_OFF)
{
value = status & (~res);
}
else
{
printk(KERN_ALERT "themal_mask_set set wrong value\n");
}
}
else if (attr->index == 3)
{
res = res << 2;
if (i == TURN_ON)
{
value = status | res;
}
else if (i == TURN_OFF)
{
value = status & (~res);
}
else
{
printk(KERN_ALERT "themal_mask_set set wrong value\n");
}
}
else if (attr->index == 4)
{
res = res << 3;
if (i == TURN_ON)
{
value = status | res;
}
else if (i == TURN_OFF)
{
value = status & (~res);
}
else
{
printk(KERN_ALERT "themal_mask_set set wrong value\n");
}
}
debug_print((KERN_DEBUG "DEBUG : themal_mask_set %d value = %x\n", attr->index, value));
result = i2c_smbus_write_byte_data(ESQC_610_i2c_client, 0xc1, value);
debug_print((KERN_DEBUG "DEBUG : themal_mask_set %d result = %x\n", attr->index,result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: themal_mask_set %d FAILED!\n", attr->index);
}
else
{
debug_print((KERN_DEBUG "themal_mask_set %d : %x\n", attr->index, value));
}
mutex_unlock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
return count;
}
static ssize_t int_status_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 res = 0x1;
int i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
res = 0x1;
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xd0);
debug_print((KERN_DEBUG "DEBUG : INT_STATUS status = %x\n",status));
sprintf(buf, "");
if (attr->index == INT_STATUS)
{
for (i = 1; i <= 7; i++)
{
if ( i == PCIE_INT)
{
if (!(status & res))
{
sprintf(buf, "%sInterrupt is triggered by PCIe\n", buf);
}
}
else if( i == QSFP_1_INT)
{
if (!(status & res))
{
sprintf(buf, "%sInterrupt is triggered by QSFP\n", buf);
}
}
else if( i == QSFP_2_INT)
{
if (!(status & res))
{
sprintf(buf, "%sInterrupt is triggered by QSFP\n", buf);
}
}
else if( i == FAN_INT)
{
if (!(status & res))
{
sprintf(buf, "%sInterrupt is triggered by FAN\n", buf);
}
}
else if( i == PSU_INT)
{
if (!(status & res))
{
sprintf(buf, "%sInterrupt is triggered by PSU\n", buf);
}
}
else if( i == SENSOR_INT)
{
if (!(status & res))
{
sprintf(buf, "%sInterrupt is triggered by Sensor\n", buf);
}
}
else if( i == USB_INT)
{
if (!(status & res))
{
sprintf(buf, "%sInterrupt is triggered by USB\n", buf);
}
}
res = res << 1;
}
if(status == 0xf)
{
sprintf(buf, "%sNo interrupt is triggered\n", buf);
}
}
return sprintf(buf, "%s\n", buf);
}
static ssize_t sfp_status_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 present_reg[7] = {0x00, 0x80, 0x81, 0x82, 0x83, 0x80, 0x81}; //CPLD present register
u8 rx_loss_reg[7] = {0x00, 0x90, 0x91, 0x92, 0x93, 0x90, 0x91}; //CPLD present register
u8 tx_ctrl_reg[7] = {0x00, 0x70, 0x71, 0x72, 0x73, 0x70, 0x71}; //CPLD present register
u8 mask = 0x1;
u8 port_num;
u8 i,j;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
if (attr->index == SFP_PRESENT)
{
sprintf(buf, "");
port_num = 1;
for (i = 1; i <= 6; i++)
{
if(i <= 4) //for 1~32 port read 0x31 CPLD
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_2_client, present_reg[i]);
}
else
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_3_client, present_reg[i]);
}
debug_print((KERN_DEBUG "DEBUG : SFP_PRESENT status = %x\n",status));
for (j = 1; j <= 8; j++)
{
if (status & mask)
{
sprintf(buf, "%sSFP %02d is not present\n", buf, port_num);
}
else
{
sprintf(buf, "%sSFP %02d is present\n", buf, port_num);
}
port_num++;
mask = mask << 1;
}
mask = 0x1;
}
}
else if (attr->index == SFP_RX_LOSS)
{
sprintf(buf, "");
port_num = 1;
for (i = 1; i <= 6; i++)
{
if(i <= 4) //for 1~32 port read 0x31 CPLD
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_2_client, rx_loss_reg[i]);
}
else
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_3_client, rx_loss_reg[i]);
}
debug_print((KERN_DEBUG "DEBUG : SFP_PRESENT status = %x\n",status));
for (j = 1; j <= 8; j++)
{
if (status & mask)
{
sprintf(buf, "%sSFP %02d loss of signal\n", buf, port_num);
}
else
{
sprintf(buf, "%sSFP %02d signal detected\n", buf, port_num);
}
port_num++;
mask = mask << 1;
}
mask = 0x1;
}
}
else if (attr->index == SFP_TX_STAT)
{
sprintf(buf, "");
port_num = 1;
for (i = 1; i <= 6; i++)
{
if(i <= 4) //for 1~32 port read 0x31 CPLD
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_2_client, tx_ctrl_reg[i]);
}
else
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_3_client, tx_ctrl_reg[i]);
}
debug_print((KERN_DEBUG "DEBUG : SFP_PRESENT status = %x\n",status));
for (j = 1; j <= 8; j++)
{
if (status & mask)
{
sprintf(buf, "%sSFP %02d Disable TX\n", buf, port_num);
}
else
{
sprintf(buf, "%sSFP %02d Enable TX\n", buf, port_num);
}
port_num++;
mask = mask << 1;
}
mask = 0x1;
}
}
return sprintf(buf, "%s\n", buf);
}
static ssize_t sfp_tx_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = -EPERM;
u8 result = -EPERM;
u8 input = 0;
u8 port_num = 0;
u8 offset = 0;
u8 reg = 0x0;
u8 tx_ctrl_reg[7] = {0x00, 0x70, 0x71, 0x72, 0x73, 0x70, 0x71}; //CPLD present register
struct i2c_client *target_client = NULL;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *CPLD_2_data = i2c_get_clientdata(Cameo_CPLD_2_client);
struct Cameo_i2c_data *CPLD_3_data = i2c_get_clientdata(Cameo_CPLD_3_client);
input = simple_strtol(buf, NULL, 10); //user input, 0 disable, 1 enable
port_num = attr->index;
if (port_num >= 1 && port_num <= 8)
{
target_client = Cameo_CPLD_2_client;
reg = tx_ctrl_reg[1];
offset = port_num;
}
else if(port_num >= 9 && port_num <= 16)
{
target_client = Cameo_CPLD_2_client;
reg = tx_ctrl_reg[2];
offset = port_num % 8;
}
else if(port_num >= 17 && port_num <= 24)
{
target_client = Cameo_CPLD_2_client;
reg = tx_ctrl_reg[3];
offset = port_num % 8;
}
else if(port_num >= 25 && port_num <= 32)
{
target_client = Cameo_CPLD_2_client;
reg = tx_ctrl_reg[4];
offset = port_num % 8;
}
else if(port_num >= 33 && port_num <= 40)
{
target_client = Cameo_CPLD_3_client;
reg = tx_ctrl_reg[5];
offset = port_num % 8;
}
else if(port_num >= 41 && port_num <= 48)
{
target_client = Cameo_CPLD_3_client;
reg = tx_ctrl_reg[6];
offset = port_num % 8;
}
else
{
printk(KERN_ALERT "sfp_tx_set wrong value\n");
return count;
}
status = i2c_smbus_read_byte_data(target_client, reg);
debug_print((KERN_DEBUG "DEBUG : sfp_tx_set status = %x\n",status));
if(input == TURN_ON)
{
status &= ~(1 << (offset-1));
}
else if(input == TURN_OFF)
{
status |= (1 << (offset-1));
}
else
{
printk(KERN_ALERT "sfp_tx_set set wrong value\n");
return count;
}
debug_print((KERN_DEBUG "DEBUG : sfp_tx_set value = %x\n",status));
mutex_lock(&CPLD_2_data->update_lock);
mutex_lock(&CPLD_3_data->update_lock);
result = i2c_smbus_write_byte_data(target_client, reg, status);
mutex_unlock(&CPLD_2_data->update_lock);
mutex_unlock(&CPLD_3_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : sfp_tx_set result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: sfp_tx_set sfp %d FAILED!\n", port_num);
}
else
{
debug_print((KERN_DEBUG "sfp_tx_set port %02d : %d\n", port_num, input));
}
return count;
}
static ssize_t low_power_all_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM; //Low power mode 01-08 port stat
u8 res = 0x1;
int i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
status = i2c_smbus_read_byte_data(Cameo_CPLD_3_client, 0x62); //CPLD 0x32 0x62
debug_print((KERN_DEBUG "DEBUG : low_power_all_get status = %x\n",status));
sprintf(buf, "");
if (attr->index == QSFP_LOW_POWER_ALL)
{
for (i = 1; i <= 8; i++)
{
if (status & res)
{
sprintf(buf, "%sQSFP %02d low power mode: ON\n", buf, i);
}
else
{
sprintf(buf, "%sQSFP %02d low power mode: OFF\n", buf, i);
}
res = res << 1;
}
res = 0x1;
}
return sprintf(buf, "%s\n", buf);
}
static ssize_t low_power_all_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 value = 0x0;
u8 status = -EPERM; //Low power mode 01-08 port stat
u8 result = -EPERM;
u8 j = 0;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *CPLD_3_data = i2c_get_clientdata(Cameo_CPLD_3_client);
if (attr->index == QSFP_LOW_POWER_ALL)
{
i = simple_strtol(buf, NULL, 10);
status = i2c_smbus_read_byte_data(Cameo_CPLD_3_client, 0x62);
debug_print((KERN_DEBUG "DEBUG : low_power_all_set status = %x\n",status));
mutex_lock(&CPLD_3_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : low_power_all_set mutex_lock\n"));
if (i == TURN_ON)
{
value = 0xf;
debug_print((KERN_DEBUG "DEBUG : QSFP_LOW_POWER_ALL value = %x\n",value));
result = i2c_smbus_write_byte_data(Cameo_CPLD_3_client, 0x62, value);
debug_print((KERN_DEBUG "DEBUG : QSFP_LOW_POWER_ALL result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: QSFP_LOW_POWER_ALL set ON FAILED!\n");
}
else
{
for(j=1; j<=8; j++)
{
debug_print((KERN_DEBUG "QSFP %02d low power mode: ON\n", j));
}
}
}
else if(i == TURN_OFF)
{
value = 0x0;
debug_print((KERN_DEBUG "DEBUG : QSFP_LOW_POWER_ALL value = %x\n",value));
result = i2c_smbus_write_byte_data(Cameo_CPLD_3_client, 0x62, value);
debug_print((KERN_DEBUG "DEBUG : QSFP_LOW_POWER_ALL result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: QSFP_LOW_POWER_ALL set OFF FAILED!\n");
}
else
{
for(j=1; j<=8; j++)
{
debug_print((KERN_DEBUG "QSFP %02d low power mode: OFF\n", j));
}
}
}
else
{
printk(KERN_ALERT "QSFP_LOW_POWER_ALL set wrong value\n");
}
mutex_unlock(&CPLD_3_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
}
return count;
}
static ssize_t low_power_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM; //Low power mode 01-08 port stat
u8 res = 0x1;
int i, j = 0;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
i = attr->index;
sprintf(buf, "");
debug_print((KERN_DEBUG "DEBUG : low_power_get port %d\n", i));
if (i >= 1 && i <= 8)
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_3_client, 0x62);
debug_print((KERN_DEBUG "DEBUG : low_power_get status = %x\n", status));
for (j = 1; j <= 8; j++)
{
if (j == i)
{
if (status & res)
{
sprintf(buf, "%sQSFP %02d low power mode: ON\n", buf, i);
}
else
{
sprintf(buf, "%sQSFP %02d low power mode: OFF\n", buf, i);
}
}
res = res << 1;
}
}
else
{
printk(KERN_ALERT "low_power_get get %02d wrong value\n", i);
}
return sprintf(buf, "%s\n", buf);
}
static ssize_t low_power_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = 0;
u8 result = 0;
int i = 0;
int j = 0;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *CPLD_3_data = i2c_get_clientdata(Cameo_CPLD_3_client);
i = attr->index;
j = simple_strtol(buf, NULL, 10);
debug_print((KERN_DEBUG "DEBUG : low_power_set port %d\n", i));
mutex_lock(&CPLD_3_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : low_power_set mutex_lock\n"));
if (i >= 1 && i <= 8)
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_3_client, 0x62);
debug_print((KERN_DEBUG "DEBUG : low_power_set status = %x\n",status));
if( j == TURN_ON)
{
status |= (1 << (i-1));
debug_print((KERN_DEBUG "DEBUG : low_power_set value = %x\n",status));
result = i2c_smbus_write_byte_data(Cameo_CPLD_3_client, 0x62, status);
debug_print((KERN_DEBUG "DEBUG : low_power_set result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: low_power_set qsfp %d ON FAILED!\n", i);
}
else
{
debug_print((KERN_DEBUG "QSFP %02d low power mode: ON\n", i));
}
}
else if( j == TURN_OFF)
{
status &= ~(1 << (i-1));
debug_print((KERN_DEBUG "DEBUG : low_power_set value = %x\n",status));
result = i2c_smbus_write_byte_data(Cameo_CPLD_3_client, 0x62, status);
debug_print((KERN_DEBUG "DEBUG : low_power_set result = %x\n",result));
if (result < 0)
{
printk(KERN_ALERT "ERROR: low_power_set qsfp %d OFF FAILED!\n", i);
}
else
{
debug_print((KERN_DEBUG "QSFP %02d low power mode: OFF\n", i));
}
}
else
{
printk(KERN_ALERT "QSFP_low_power_%d set wrong value\n", i);
}
}
else
{
printk(KERN_ALERT "low_power_set wrong value\n");
}
mutex_unlock(&CPLD_3_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
return count;
}
static ssize_t qsfp_reset_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = 0;
u8 value = 0;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *CPLD_3_data = i2c_get_clientdata(Cameo_CPLD_3_client);
mutex_lock(&CPLD_3_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : qsfp_reset_set mutex_lock\n"));
if (attr->index == QSFP_RESET)
{
i = simple_strtol(buf, NULL, 10);
if (i >= 1 && i <= 8)
{
value = 0;
value = i2c_smbus_read_byte_data(Cameo_CPLD_3_client, 0x72);
debug_print((KERN_DEBUG "DEBUG : qsfp_reset_set value = %x\n",value));
value ^= (1 << (i - 1));
debug_print((KERN_DEBUG "DEBUG : qsfp_reset_set set value = %x\n",value));
status = i2c_smbus_write_byte_data(Cameo_CPLD_3_client, 0x72, value);
if (status < 0)
{
printk(KERN_ALERT "ERROR: QSFP_RESET port %02d FAILED!\n", i);
}
else
{
debug_print((KERN_DEBUG "QSFP %02d reset success\n", i));
}
}
else
{
printk(KERN_ALERT "qsfp_reset_set wrong value\n");
}
}
mutex_unlock(&CPLD_3_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
return count;
}
static ssize_t qsfp_status_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM; //qsfp_status 01-08 port stat
u8 res = 0x1;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
if (attr->index == QSFP_PRESENT)
{
sprintf(buf, "");
status = i2c_smbus_read_byte_data(Cameo_CPLD_3_client, 0x82);
for (i = 1; i <= 8; i++)
{
if (status & res)
{
sprintf(buf, "%sQSFP %02d is not present\n", buf, i);
}
else
{
sprintf(buf, "%sQSFP %02d is present\n", buf, i);
}
res = res << 1;
}
res = 0x1;
}
if (attr->index == QSFP_INT)
{
sprintf(buf, "");
status = i2c_smbus_read_byte_data(Cameo_CPLD_3_client, 0x92);
debug_print((KERN_DEBUG "DEBUG : QSFP_INT_1 status = %x\n",status));
res = 0x1;
for (i = 1; i <= 8; i++)
{
if (status & res)
{
sprintf(buf, "%sQSFP %02d is OK\n", buf, i);
}
else
{
sprintf(buf, "%sQSFP %02d is abnormal\n", buf, i);
}
res = res << 1;
}
res = 0x1;
}
return sprintf(buf, "%s\n", buf);
}
static ssize_t fan_status_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 res=0x1;
u16 fan_speed;
int i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct i2c_client *target_client = NULL;
sprintf(buf, "");
if (attr->index == FAN_STATUS)
{
if(i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa4) == 0x1) //check BMC present
{
status = i2c_smbus_read_byte_data(Cameo_BMC_client, 0x80);
}
else
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_4_client, 0x0);
}
debug_print((KERN_DEBUG "DEBUG : FAN_STATUS status = %x\n",status));
for(i=1; i<=4; i++)
{
if(status & res)
{
sprintf(buf, "%sFan %d is Good\n", buf, i);
}
else
{
sprintf(buf, "%sFan %d is Fail\n", buf, i);
}
res=res<<1;
}
}
else if (attr->index == FAN_PRESENT)
{
if(i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa4) == 0x1) //check BMC present
{
status = i2c_smbus_read_byte_data(Cameo_BMC_client, 0x81);
}
else
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_4_client, 0x01);
}
debug_print((KERN_DEBUG "DEBUG : FAN_PRESENT status = %x\n",status));
for(i=1; i<=4; i++)
{
if(status & res)
{
sprintf(buf, "%sFan %d is present\n", buf, i);
}
else
{
sprintf(buf, "%sFan %d is not present\n", buf, i);
}
res=res<<1;
}
}
else if (attr->index == FAN_POWER)
{
if(i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa4) == 0x1) //check BMC present
{
status = i2c_smbus_read_byte_data(Cameo_BMC_client, 0x82);
}
else
{
status = i2c_smbus_read_byte_data(Cameo_CPLD_4_client, 0x02);
}
debug_print((KERN_DEBUG "DEBUG : FAN_POWER status = %x\n",status));
for(i=1; i<=4; i++)
{
if(status & res)
{
sprintf(buf, "%sFan %d is power Good\n", buf, i);
}
else
{
sprintf(buf, "%sFan %d is not power Good\n", buf, i);
}
res=res<<1;
}
}
else if (attr->index == FAN_SPEED_RPM)
{
res = -EPERM;
if(i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa4) == 0x1) //check BMC present
{
target_client = Cameo_BMC_client;
res = i2c_smbus_read_byte_data(Cameo_BMC_client, 0x81); //check Fan present
}
else
{
target_client = Cameo_CPLD_4_client;
res = i2c_smbus_read_byte_data(Cameo_CPLD_4_client, 0x01); //check Fan present
}
if(res < 0) {
sprintf(buf, "%sCheck fan present error\n", buf);
return sprintf(buf, "%s\n",buf);
}
// first fan of couple
for(i=0; i<SYSFAN_MAX_NUM; i++)
{
// skip the fan which is not present
if(!(res & (0x01<<i)))
{
sprintf(buf, "%sFanModule%i Front : N/A\n", buf, i+1);
sprintf(buf, "%sFanModule%i Rear : N/A\n", buf, i+1);
continue;
}
// front fan of couple
// read high byte
status = i2c_smbus_read_byte_data(target_client, 0xA0+(i*2)+1);
if(status < 0){
sprintf(buf, "%sFanModule%i Front : read error\n", buf, i+1);
continue;
}
fan_speed = status;
// read low byte
status = i2c_smbus_read_byte_data(target_client, 0xA0+(i*2));
if(status < 0){
sprintf(buf, "%sFanModule%i Front : read error\n", buf, i+1);
continue;
}
fan_speed = ((fan_speed<<8) + status)*30;
sprintf(buf, "%sFanModule%i Front : %d RPM\n", buf, i+1, fan_speed);
// rear fan of couple
// read high byte
status = i2c_smbus_read_byte_data(target_client, 0xB0+(i*2)+1);
if(status < 0){
sprintf(buf, "%sFanModule%i Rear : read error\n", buf, i+1);
continue;
}
fan_speed = status;
// read low byte
status = i2c_smbus_read_byte_data(target_client, 0xB0+(i*2));
if(status < 0){
sprintf(buf, "%sFanModule%i Rear : read error\n", buf, i+1);
continue;
}
fan_speed = ((fan_speed<<8) + status)*30;
sprintf(buf, "%sFanModule%i Rear : %d RPM\n", buf, i+1, fan_speed);
}
}
return sprintf(buf, "%s\n",buf);
}
#ifdef FAN_CTRL_WANTED
static ssize_t fan_mode_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 channel_status = -EPERM;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *Switch_2_data = i2c_get_clientdata(Cameo_Switch_2_client);
mutex_lock(&Switch_2_data->update_lock);
sprintf(buf, "");
if (attr->index == FAN_MODE)
{
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x01);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: fan_mode_get set channel 1 FAILED\n");
}
status = i2c_smbus_read_byte_data(Cameo_Sensor_fan_client, 0x64);
debug_print((KERN_DEBUG "DEBUG : FAN_MODE get status = %x\n",status));
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x00);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: fan_mode_get channel reset FAILED\n");
}
sprintf(buf, "%s0x%x\n", buf, status);
}
mutex_unlock(&Switch_2_data->update_lock);
return sprintf(buf, "%s\n",buf);
}
static ssize_t fan_mode_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = -EPERM;
u8 channel_status = -EPERM;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *Switch_2_data = i2c_get_clientdata(Cameo_Switch_2_client);
struct Cameo_i2c_data *Sensor_fan_data = i2c_get_clientdata(Cameo_Sensor_fan_client);
mutex_lock(&Switch_2_data->update_lock);
mutex_lock(&Sensor_fan_data->update_lock);
if (attr->index == FAN_MODE)
{
i = simple_strtol(buf, NULL, 16);
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x01);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: fan_mode_get set channel 1 FAILED\n");
}
status = i2c_smbus_write_byte_data(Cameo_Sensor_fan_client, 0x64, i);
debug_print((KERN_DEBUG "DEBUG : FAN_MODE set status = %x\n", status));
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x00);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: fan_mode_get channel reset FAILED\n");
}
}
mutex_unlock(&Switch_2_data->update_lock);
mutex_unlock(&Sensor_fan_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
return count;
}
static ssize_t fan_rpm_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 status = -EPERM;
u8 channel_status = -EPERM;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *Switch_2_data = i2c_get_clientdata(Cameo_Switch_2_client);
mutex_lock(&Switch_2_data->update_lock);
sprintf(buf, "");
if (attr->index == FAN_RPM)
{
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x01);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: fan_rpm_get set channel 1 FAILED\n");
}
status = i2c_smbus_read_byte_data(Cameo_Sensor_fan_client, 0x60);
debug_print((KERN_DEBUG "DEBUG : FAN_RPM status = %x\n",status));
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x00);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: fan_rpm_get channel reset FAILED\n");
}
sprintf(buf, "%s0x%x\n", buf, status);
}
mutex_unlock(&Switch_2_data->update_lock);
return sprintf(buf, "%s\n",buf);
}
static ssize_t fan_rpm_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = -EPERM;
u8 channel_status = -EPERM;
u16 i;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
struct Cameo_i2c_data *Switch_2_data = i2c_get_clientdata(Cameo_Switch_2_client);
struct Cameo_i2c_data *Sensor_fan_data = i2c_get_clientdata(Cameo_Sensor_fan_client);
mutex_lock(&Switch_2_data->update_lock);
mutex_lock(&Sensor_fan_data->update_lock);
if (attr->index == FAN_RPM)
{
i = simple_strtol(buf, NULL, 16);
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x01);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: fan_mode_get set channel 1 FAILED\n");
}
status = i2c_smbus_write_byte_data(Cameo_Sensor_fan_client, 0x60, i);
debug_print((KERN_DEBUG "DEBUG : FAN_RPM set status = %x\n", status));
channel_status = i2c_smbus_write_byte(Cameo_Switch_2_client, 0x00);
if(channel_status < 0)
{
printk(KERN_ALERT "ERROR: fan_mode_get channel reset FAILED\n");
}
}
mutex_unlock(&Switch_2_data->update_lock);
mutex_unlock(&Sensor_fan_data->update_lock);
debug_print((KERN_DEBUG "DEBUG : mutex_unlock\n"));
return count;
}
#endif
#ifdef ASPEED_BMC_WANTED
static ssize_t bmc_register_get(struct device *dev, struct device_attribute *da, char *buf)
{
u32 reg = -EPERM;
u32 status = -EPERM;
u8 len = -EPERM;
u8 idex =0;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
sprintf(buf, "");
switch (attr->index)
{
case BMC_SERSOR_1:
reg = 0x10;
len = 1;
idex = 1;
break;
case BMC_SERSOR_2:
reg = 0x20;
len = 1;
idex = 2;
break;
case BMC_SERSOR_3:
reg = 0x30;
len = 1;
idex = 3;
break;
case BMC_SERSOR_4:
reg = 0x40;
len = 1;
idex = 4;
break;
}
if(len == 1)
{
status = i2c_smbus_read_byte_data(Cameo_BMC_client, reg);
debug_print((KERN_DEBUG "DEBUG : BMC byte status = 0x%x\n", status));
}
else if (len == 2)
{
status = i2c_smbus_read_word_data(Cameo_BMC_client, reg);
debug_print((KERN_DEBUG "DEBUG : BMC word status = 0x%x\n", status));
}
if(status == 0xfffffffa || status == 0xff || status == 0xffff)
{
sprintf(buf, "%sAccess BMC module FAILED\n", buf);
}
else
{
if(len == 1)
sprintf(buf, "%sSensor %d temp is %s%d degrees (C)\n", buf, idex,(status & 0x80)!=0 ? "-":"",read_8bit_temp((status & 0x80),status));
else
sprintf(buf, "%s0x%x\n", buf, ((status&0xff)<<8)|((status&0xFF00)>>8));
}
return sprintf(buf, "%s\n", buf);
}
static ssize_t bmc_module_detect(struct device *dev, struct device_attribute *da, char *buf)
{
u32 status = -EPERM;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
sprintf(buf, "");
if(attr->index == BMC_DETECT)
{
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0xa4);
debug_print((KERN_DEBUG "DEBUG : BMC byte status = 0x%x\n", status));
}
if(status == 0x1)
{
sprintf(buf, "%sBMC module is present\n", buf);
}
else
{
sprintf(buf, "%sBMC module is not present\n", buf);
}
return sprintf(buf, "%s\n", buf);
}
#endif /*ASPEED_BMC_WANTED*/
#ifdef WDT_CTRL_WANTED
static ssize_t wdt_status_get(struct device *dev, struct device_attribute *da, char *buf)
{
sprintf(buf, "");
return sprintf(buf, "%s\n", buf);
}
static ssize_t wdt_status_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
return count;
}
#endif /*WDT_CTRL_WANTED*/
#ifdef EEPROM_WP_WANTED
static ssize_t eeprom_wp_status_get(struct device *dev, struct device_attribute *da, char *buf)
{
sprintf(buf, "");
return sprintf(buf, "%s\n", buf);
}
static ssize_t eeprom_wp_status_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
return count;
}
#endif /*EEPROM_WP_WANTED*/
static ssize_t hw_version_get(struct device *dev, struct device_attribute *da, char *buf)
{
u32 status = -EPERM;
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
sprintf(buf, "");
if(attr->index == HW_VER)
{
status = i2c_smbus_read_byte_data(ESQC_610_i2c_client, 0x20);
}
sprintf(buf, "%sHW version is 0x%x\n", buf, status);
return sprintf(buf, "%s\n", buf);
}
/* end of function */
static int Cameo_i2c_probe(struct i2c_client *client, const struct i2c_device_id *dev_id)
{
struct Cameo_i2c_data *data;
struct Cameo_i2c_data *CPLD_2_data;
struct Cameo_i2c_data *CPLD_3_data;
struct Cameo_i2c_data *CPLD_4_data;
struct Cameo_i2c_data *CPLD_5_data;
#ifdef I2C_SWITCH_WANTED
struct Cameo_i2c_data *Switch_1_data;
struct Cameo_i2c_data *Switch_2_data;
#endif
#ifdef THEMAL_WANTED
struct Cameo_i2c_data *Sensor_data;
struct Cameo_i2c_data *Sensor_fan_data;
#endif
#ifdef ASPEED_BMC_WANTED
struct Cameo_i2c_data *Cameo_BMC_data;
#endif
int status;
if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_WORD_DATA))
{
status = -EIO;
goto exit;
}
data = kzalloc(sizeof(struct Cameo_i2c_data), GFP_KERNEL);
if (!data)
{
printk(KERN_ALERT "kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
CPLD_2_data = kzalloc(sizeof(struct Cameo_i2c_data), GFP_KERNEL);
if (!CPLD_2_data)
{
printk(KERN_ALERT "kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
CPLD_3_data = kzalloc(sizeof(struct Cameo_i2c_data), GFP_KERNEL);
if (!CPLD_3_data)
{
printk(KERN_ALERT "kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
CPLD_4_data = kzalloc(sizeof(struct Cameo_i2c_data), GFP_KERNEL);
if (!CPLD_4_data)
{
printk(KERN_ALERT "kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
CPLD_5_data = kzalloc(sizeof(struct Cameo_i2c_data), GFP_KERNEL);
if (!CPLD_5_data)
{
printk(KERN_ALERT "kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
#ifdef I2C_SWITCH_WANTED
Switch_1_data = kzalloc(sizeof(struct Cameo_i2c_data), GFP_KERNEL);
if (!Switch_1_data)
{
printk(KERN_ALERT "kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
Switch_2_data = kzalloc(sizeof(struct Cameo_i2c_data), GFP_KERNEL);
if (!Switch_2_data)
{
printk(KERN_ALERT "kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
#endif
#ifdef THEMAL_WANTED
Sensor_data = kzalloc(sizeof(struct Cameo_i2c_data), GFP_KERNEL);
if (!Sensor_data)
{
printk(KERN_ALERT "kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
Sensor_fan_data = kzalloc(sizeof(struct Cameo_i2c_data), GFP_KERNEL);
if (!Sensor_fan_data)
{
printk(KERN_ALERT "kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
#endif
#ifdef ASPEED_BMC_WANTED
Cameo_BMC_data = kzalloc(sizeof(struct Cameo_i2c_data), GFP_KERNEL);
if (!Cameo_BMC_data)
{
printk(KERN_ALERT "kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
#endif
i2c_set_clientdata(client, data);
i2c_set_clientdata(Cameo_CPLD_2_client, CPLD_2_data);
i2c_set_clientdata(Cameo_CPLD_3_client, CPLD_3_data);
i2c_set_clientdata(Cameo_CPLD_4_client, CPLD_4_data);
i2c_set_clientdata(Cameo_CPLD_5_client, CPLD_5_data);
#ifdef I2C_SWITCH_WANTED
i2c_set_clientdata(Cameo_Switch_1_client, Switch_1_data);
i2c_set_clientdata(Cameo_Switch_2_client, Switch_2_data);
#endif
#ifdef THEMAL_WANTED
i2c_set_clientdata(Cameo_Sensor_client, Sensor_data);
i2c_set_clientdata(Cameo_Sensor_fan_client, Sensor_fan_data);
#endif
mutex_init(&CPLD_2_data->update_lock);
mutex_init(&CPLD_3_data->update_lock);
mutex_init(&CPLD_4_data->update_lock);
mutex_init(&CPLD_5_data->update_lock);
#ifdef I2C_SWITCH_WANTED
mutex_init(&Switch_1_data->update_lock);
mutex_init(&Switch_2_data->update_lock);
#endif
#ifdef THEMAL_WANTED
mutex_init(&Sensor_data->update_lock);
mutex_init(&Sensor_fan_data->update_lock);
#endif
#ifdef ASPEED_BMC_WANTED
mutex_init(&Cameo_BMC_data->update_lock);
#endif
data->valid = 0;
mutex_init(&data->update_lock);
dev_info(&client->dev, "chip found\n");
/* Register sysfs hooks */
status = sysfs_create_group(&client->dev.kobj, &ESQC610_PSU_group);
if (status)
{
goto exit_free;
}
#ifdef USB_CTRL_WANTED
status = sysfs_create_group(&client->dev.kobj, &ESQC610_USB_group);
if (status)
{
goto exit_free;
}
#endif
status = sysfs_create_group(&client->dev.kobj, &ESQC610_LED_group);
if (status)
{
goto exit_free;
}
status = sysfs_create_group(&client->dev.kobj, &ESQC610_Reset_group);
if (status)
{
goto exit_free;
}
status = sysfs_create_group(&client->dev.kobj, &ESQC610_Sensor_group);
if (status)
{
goto exit_free;
}
status = sysfs_create_group(&client->dev.kobj, &ESQC610_INT_group);
if (status)
{
goto exit_free;
}
status = sysfs_create_group(&client->dev.kobj, &ESQC610_SFP_group);
if (status)
{
goto exit_free;
}
status = sysfs_create_group(&client->dev.kobj, &ESQC610_QSFP_group);
if (status)
{
goto exit_free;
}
status = sysfs_create_group(&client->dev.kobj, &ESQC610_FAN_group);
if (status)
{
goto exit_free;
}
#ifdef ASPEED_BMC_WANTED
status = sysfs_create_group(&client->dev.kobj, &ESQC610_BMC_group);
if (status)
{
goto exit_free;
}
#endif
status = sysfs_create_group(&client->dev.kobj, &ESQC610_SYS_group);
if (status)
{
goto exit_free;
}
data->hwmon_dev = hwmon_device_register(&client->dev);
if (IS_ERR(data->hwmon_dev))
{
status = PTR_ERR(data->hwmon_dev);
goto exit_remove;
}
dev_info(&client->dev, "%s: '%s'\n", dev_name(data->hwmon_dev), client->name);
return 0;
exit_remove:
sysfs_remove_group(&client->dev.kobj, &ESQC610_PSU_group);
#ifdef USB_CTRL_WANTED
sysfs_remove_group(&client->dev.kobj, &ESQC610_USB_group);
#endif
sysfs_remove_group(&client->dev.kobj, &ESQC610_LED_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_Reset_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_Sensor_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_INT_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_SFP_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_QSFP_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_FAN_group);
#ifdef ASPEED_BMC_WANTED
sysfs_remove_group(&client->dev.kobj, &ESQC610_BMC_group);
#endif
sysfs_remove_group(&client->dev.kobj, &ESQC610_SYS_group);
exit_free:
kfree(data);
exit:
return status;
}
static int Cameo_i2c_remove(struct i2c_client *client)
{
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
hwmon_device_unregister(data->hwmon_dev);
sysfs_remove_group(&client->dev.kobj, &ESQC610_PSU_group);
#ifdef USB_CTRL_WANTED
sysfs_remove_group(&client->dev.kobj, &ESQC610_USB_group);
#endif
sysfs_remove_group(&client->dev.kobj, &ESQC610_LED_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_Reset_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_Sensor_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_INT_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_SFP_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_QSFP_group);
sysfs_remove_group(&client->dev.kobj, &ESQC610_FAN_group);
#ifdef ASPEED_BMC_WANTED
sysfs_remove_group(&client->dev.kobj, &ESQC610_BMC_group);
#endif
sysfs_remove_group(&client->dev.kobj, &ESQC610_SYS_group);
kfree(data);
return 0;
}
static const struct i2c_device_id Cameo_i2c_id[] =
{
{ "ESQC_610_i2c", 0 },
{},
};
MODULE_DEVICE_TABLE(i2c, Cameo_i2c_id);
static struct i2c_driver Cameo_i2c_driver =
{
.class = I2C_CLASS_HWMON,
.driver =
{
.name = "ESQC_610_i2c",
},
.probe = Cameo_i2c_probe,
.remove = Cameo_i2c_remove,
.id_table = Cameo_i2c_id,
.address_list = normal_i2c,
};
/*For main Switch board*/
static struct i2c_board_info ESQC_610_i2c_info[] __initdata =
{
{
I2C_BOARD_INFO("ESQC_610_i2c", 0x30),
.platform_data = NULL,
},
};
/*For QSFP Port 01 - 16*/
static struct i2c_board_info Cameo_CPLD_2_info[] __initdata =
{
{
I2C_BOARD_INFO("Cameo_CPLD_2", 0x31),
.platform_data = NULL,
},
};
/*For QSFP Port 17 - 32*/
static struct i2c_board_info Cameo_CPLD_3_info[] __initdata =
{
{
I2C_BOARD_INFO("Cameo_CPLD_3", 0x32),
.platform_data = NULL,
},
};
/*For Fan status*/
static struct i2c_board_info Cameo_CPLD_4_info[] __initdata =
{
{
I2C_BOARD_INFO("Cameo_CPLD_4", 0x23),
.platform_data = NULL,
},
};
/*For Power status*/
static struct i2c_board_info Cameo_CPLD_5_info[] __initdata =
{
{
I2C_BOARD_INFO("Cameo_CPLD_5", 0x35),
.platform_data = NULL,
},
};
#ifdef I2C_SWITCH_WANTED
/*0x73*/
static struct i2c_board_info Cameo_Switch_1_info[] __initdata =
{
{
I2C_BOARD_INFO("Cameo_Switch_1", 0x73),
.platform_data = NULL,
},
};
/*0x75*/
static struct i2c_board_info Cameo_Switch_2_info[] __initdata =
{
{
I2C_BOARD_INFO("Cameo_Switch_2", 0x75),
.platform_data = NULL,
},
};
#endif
#ifdef THEMAL_WANTED
/*0x4c*/
static struct i2c_board_info Cameo_Sensor_info[] __initdata =
{
{
I2C_BOARD_INFO("Cameo_Sensor", 0x4c),
.platform_data = NULL,
},
};
/*0x2e*/
static struct i2c_board_info Cameo_Sensor_fan_info[] __initdata =
{
{
I2C_BOARD_INFO("Cameo_Sensor_fan", 0x2e),
.platform_data = NULL,
},
};
#endif
#ifdef ASPEED_BMC_WANTED
static struct i2c_board_info Cameo_BMC_info[] __initdata =
{
{
I2C_BOARD_INFO("Cameo_BMC", 0x14),
.platform_data = NULL,
},
};
#endif
static int __init Cameo_i2c_init(void)
{
int ret;
int cmp;
char keyword[] = "SMBus I801";
char buf1[128];
struct i2c_adapter *i2c_adap;
struct file *fp;
mm_segment_t fs;
loff_t pos;
printk("Open file...\n");
fp = filp_open("/sys/class/i2c-dev/i2c-0/name", O_RDONLY , 0644);
if (IS_ERR(fp)) {
printk("Open file FAILED\n");
return -1;
}
fs = get_fs();
set_fs(KERNEL_DS);
pos = 0;
vfs_read(fp, buf1, sizeof(buf1), &pos);
printk("Detect %s\n", buf1);
cmp = strncmp(keyword, buf1, sizeof(keyword)-1);
set_fs(fs);
filp_close(fp, NULL);
if(cmp == 0)
{
i2c_adap = i2c_get_adapter(0);
printk("SMBus I801 is at bus 0\n");
}
else
{
i2c_adap = i2c_get_adapter(1);
printk("SMBus I801 is at bus 1\n");
}
debug_print((KERN_DEBUG "Cameo_i2c_init\n"));
if (i2c_adap == NULL)
{
printk("ERROR: i2c_get_adapter FAILED!\n");
return -1;
}
ESQC_610_i2c_client = i2c_new_device(i2c_adap, &ESQC_610_i2c_info[0]);
Cameo_CPLD_2_client = i2c_new_device(i2c_adap, &Cameo_CPLD_2_info[0]);
Cameo_CPLD_3_client = i2c_new_device(i2c_adap, &Cameo_CPLD_3_info[0]);
Cameo_CPLD_4_client = i2c_new_device(i2c_adap, &Cameo_CPLD_4_info[0]);
Cameo_CPLD_5_client = i2c_new_device(i2c_adap, &Cameo_CPLD_5_info[0]);
#ifdef I2C_SWITCH_WANTED
Cameo_Switch_1_client = i2c_new_device(i2c_adap, &Cameo_Switch_1_info[0]);
Cameo_Switch_2_client = i2c_new_device(i2c_adap, &Cameo_Switch_2_info[0]);
#endif
#ifdef THEMAL_WANTED
Cameo_Sensor_client = i2c_new_device(i2c_adap, &Cameo_Sensor_info[0]);
Cameo_Sensor_fan_client = i2c_new_device(i2c_adap, &Cameo_Sensor_fan_info[0]);
#endif
#ifdef ASPEED_BMC_WANTED
Cameo_BMC_client = i2c_new_device(i2c_adap, &Cameo_BMC_info[0]);
#endif
if (ESQC_610_i2c_client == NULL || Cameo_CPLD_2_client == NULL || Cameo_CPLD_3_client == NULL
|| Cameo_CPLD_4_client == NULL || Cameo_CPLD_5_client == NULL)
{
printk("ERROR: ESQC_610_i2c_client FAILED!\n");
return -1;
}
#ifdef I2C_SWITCH_WANTED
if (Cameo_Switch_1_client == NULL || Cameo_Switch_2_client == NULL )
{
printk("ERROR: Cameo_Switch_client FAILED!\n");
return -1;
}
#endif
#ifdef THEMAL_WANTED
if (Cameo_Sensor_client == NULL || Cameo_Sensor_fan_client == NULL )
{
printk("ERROR: Cameo_Sensor_client FAILED!\n");
return -1;
}
#endif
#ifdef ASPEED_BMC_WANTED
if (Cameo_BMC_client == NULL )
{
printk("ERROR: Cameo_BMC_client FAILED!\n");
return -1;
}
#endif
i2c_put_adapter(i2c_adap);
ret = i2c_add_driver(&Cameo_i2c_driver);
printk(KERN_ALERT "ESQC610-56SQ i2c Driver Version: %s\n", DRIVER_VERSION);
printk(KERN_ALERT "ESQC610-56SQ i2c Driver INSTALL SUCCESS\n");
return ret;
}
static void __exit Cameo_i2c_exit(void)
{
i2c_unregister_device(ESQC_610_i2c_client);
i2c_unregister_device(Cameo_CPLD_2_client);
i2c_unregister_device(Cameo_CPLD_3_client);
i2c_unregister_device(Cameo_CPLD_4_client);
i2c_unregister_device(Cameo_CPLD_5_client);
#ifdef I2C_SWITCH_WANTED
i2c_unregister_device(Cameo_Switch_1_client);
i2c_unregister_device(Cameo_Switch_2_client);
#endif
#ifdef THEMAL_WANTED
i2c_unregister_device(Cameo_Sensor_client);
i2c_unregister_device(Cameo_Sensor_fan_client);
#endif
#ifdef ASPEED_BMC_WANTED
i2c_unregister_device(Cameo_BMC_client);
#endif
i2c_del_driver(&Cameo_i2c_driver);
printk(KERN_ALERT "ESQC610-56SQ i2c Driver UNINSTALL SUCCESS\n");
}
MODULE_AUTHOR("Cameo Inc.");
MODULE_DESCRIPTION("Cameo ESQC610-56SQ i2c Driver");
MODULE_LICENSE("GPL");
module_init(Cameo_i2c_init);
module_exit(Cameo_i2c_exit);
Reference in New Issue Copy Permalink