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/esc600-128q/modules/phy_cpld640.c

1103 lines
42 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 ESC600-128Q i2c Module */
#pragma GCC diagnostic ignored "-Wformat-zero-length"
#include <linux/module.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>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/string.h>
#define ESC_600_INT_WANTED
//#define PREVIOUS_CHECK_TYPE
#define DEBUG_MSG
#ifdef DEBUG_MSG
#define debug_print(s) printk s
#else
#define debug_print(s)
#endif
#define TURN_OFF 0
#define TURN_ON 1
enum model_type{
MODEL_TYPE_100G = 0,
MODEL_TYPE_400G = 1,
MODEL_TYPE_UNKNOWN = 2
};
/* Addresses scanned */
static const unsigned short normal_i2c[] = { 0x32, I2C_CLIENT_END };
/*0x32 PHY CPLD*/
static ssize_t portnum_get(struct device *dev, struct device_attribute *da, char *buf);
static ssize_t model_get(struct device *dev, struct device_attribute *da, char *buf);
static ssize_t phy_reset_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count);
#ifdef ESC_600_INT_WANTED
static ssize_t QSFP_int_get(struct device *dev, struct device_attribute *da, char *buf);
#endif
static ssize_t QSFP_status_all_get(struct device *dev, struct device_attribute *da, char *buf);
static ssize_t low_power_all_get(struct device *dev, struct device_attribute *da, char *buf);
static ssize_t low_power_all_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count);
static ssize_t low_power_get(struct device *dev, struct device_attribute *da, char *buf);
static ssize_t low_power_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count);
static ssize_t qsfp_reset_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count);
static ssize_t qsfp_status_get(struct device *dev, struct device_attribute *da, char *buf);
/* struct i2c_data */
struct Cameo_i2c_data
{
struct device *hwmon_dev;
struct mutex update_lock;
char valid; /* !=0 if registers are valid */
unsigned long last_updated; /* In jiffies */
#ifdef PREVIOUS_CHECK_TYPE
u8 model_type;
#endif
};
/* struct i2c_sysfs_attributes */
enum Cameo_i2c_sysfs_attributes
{
/*0x32 PHY CPLD*/
SLOT_PORTNUM,
SLOT_MODEL,
QSFP_LOW_POWER_ALL,
QSFP_RESET,
QSFP_PRESENT,
QSFP_INT
};
/* end of struct i2c_sysfs_attributes */
/* sysfs attributes for SENSOR_DEVICE_ATTR */
/*phy_cpld640_QSFP_attributes*/
#ifdef ESC_600_INT_WANTED
static SENSOR_DEVICE_ATTR(QSFP_int , S_IRUGO , QSFP_int_get , NULL , QSFP_INT);
#endif
static SENSOR_DEVICE_ATTR(phy_reset , S_IRUGO | S_IWUSR , NULL , phy_reset_set , 0);
static SENSOR_DEVICE_ATTR(portnum , S_IRUGO , portnum_get , NULL , SLOT_PORTNUM);
static SENSOR_DEVICE_ATTR(model , S_IRUGO , model_get , NULL , SLOT_MODEL);
static SENSOR_DEVICE_ATTR(QSFP_reset_1 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 1);
static SENSOR_DEVICE_ATTR(QSFP_reset_2 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 2);
static SENSOR_DEVICE_ATTR(QSFP_reset_3 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 3);
static SENSOR_DEVICE_ATTR(QSFP_reset_4 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 4);
static SENSOR_DEVICE_ATTR(QSFP_reset_5 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 5);
static SENSOR_DEVICE_ATTR(QSFP_reset_6 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 6);
static SENSOR_DEVICE_ATTR(QSFP_reset_7 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 7);
static SENSOR_DEVICE_ATTR(QSFP_reset_8 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 8);
static SENSOR_DEVICE_ATTR(QSFP_reset_9 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 9);
static SENSOR_DEVICE_ATTR(QSFP_reset_10 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 10);
static SENSOR_DEVICE_ATTR(QSFP_reset_11 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 11);
static SENSOR_DEVICE_ATTR(QSFP_reset_12 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 12);
static SENSOR_DEVICE_ATTR(QSFP_reset_13 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 13);
static SENSOR_DEVICE_ATTR(QSFP_reset_14 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 14);
static SENSOR_DEVICE_ATTR(QSFP_reset_15 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 15);
static SENSOR_DEVICE_ATTR(QSFP_reset_16 , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , 16);
static SENSOR_DEVICE_ATTR(QSFP_low_power_1 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 1);
static SENSOR_DEVICE_ATTR(QSFP_low_power_2 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 2);
static SENSOR_DEVICE_ATTR(QSFP_low_power_3 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 3);
static SENSOR_DEVICE_ATTR(QSFP_low_power_4 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 4);
static SENSOR_DEVICE_ATTR(QSFP_low_power_5 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 5);
static SENSOR_DEVICE_ATTR(QSFP_low_power_6 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 6);
static SENSOR_DEVICE_ATTR(QSFP_low_power_7 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 7);
static SENSOR_DEVICE_ATTR(QSFP_low_power_8 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 8);
static SENSOR_DEVICE_ATTR(QSFP_low_power_9 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 9);
static SENSOR_DEVICE_ATTR(QSFP_low_power_10 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 10);
static SENSOR_DEVICE_ATTR(QSFP_low_power_11 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 11);
static SENSOR_DEVICE_ATTR(QSFP_low_power_12 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 12);
static SENSOR_DEVICE_ATTR(QSFP_low_power_13 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 13);
static SENSOR_DEVICE_ATTR(QSFP_low_power_14 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 14);
static SENSOR_DEVICE_ATTR(QSFP_low_power_15 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 15);
static SENSOR_DEVICE_ATTR(QSFP_low_power_16 , S_IRUGO | S_IWUSR , low_power_get , low_power_set , 16);
static SENSOR_DEVICE_ATTR(QSFP_low_power_all , S_IRUGO | S_IWUSR , low_power_all_get , low_power_all_set , QSFP_LOW_POWER_ALL);
//static SENSOR_DEVICE_ATTR(QSFP_reset , S_IRUGO | S_IWUSR , NULL , qsfp_reset_set , QSFP_RESET);
static SENSOR_DEVICE_ATTR(QSFP_present_all , S_IRUGO , QSFP_status_all_get , NULL , QSFP_PRESENT);
static SENSOR_DEVICE_ATTR(QSFP_present_1 , S_IRUGO , qsfp_status_get , NULL , 1);
static SENSOR_DEVICE_ATTR(QSFP_present_2 , S_IRUGO , qsfp_status_get , NULL , 2);
static SENSOR_DEVICE_ATTR(QSFP_present_3 , S_IRUGO , qsfp_status_get , NULL , 3);
static SENSOR_DEVICE_ATTR(QSFP_present_4 , S_IRUGO , qsfp_status_get , NULL , 4);
static SENSOR_DEVICE_ATTR(QSFP_present_5 , S_IRUGO , qsfp_status_get , NULL , 5);
static SENSOR_DEVICE_ATTR(QSFP_present_6 , S_IRUGO , qsfp_status_get , NULL , 6);
static SENSOR_DEVICE_ATTR(QSFP_present_7 , S_IRUGO , qsfp_status_get , NULL , 7);
static SENSOR_DEVICE_ATTR(QSFP_present_8 , S_IRUGO , qsfp_status_get , NULL , 8);
static SENSOR_DEVICE_ATTR(QSFP_present_9 , S_IRUGO , qsfp_status_get , NULL , 9);
static SENSOR_DEVICE_ATTR(QSFP_present_10 , S_IRUGO , qsfp_status_get , NULL , 10);
static SENSOR_DEVICE_ATTR(QSFP_present_11 , S_IRUGO , qsfp_status_get , NULL , 11);
static SENSOR_DEVICE_ATTR(QSFP_present_12 , S_IRUGO , qsfp_status_get , NULL , 12);
static SENSOR_DEVICE_ATTR(QSFP_present_13 , S_IRUGO , qsfp_status_get , NULL , 13);
static SENSOR_DEVICE_ATTR(QSFP_present_14 , S_IRUGO , qsfp_status_get , NULL , 14);
static SENSOR_DEVICE_ATTR(QSFP_present_15 , S_IRUGO , qsfp_status_get , NULL , 15);
static SENSOR_DEVICE_ATTR(QSFP_present_16 , S_IRUGO , qsfp_status_get , NULL , 16);
/* end of sysfs attributes for SENSOR_DEVICE_ATTR */
/* sysfs attributes for hwmon */
static struct attribute *phy_cpld640_QSFP_attributes[] =
{
#ifdef ESC_600_INT_WANTED
&sensor_dev_attr_QSFP_int.dev_attr.attr,
#endif
&sensor_dev_attr_portnum.dev_attr.attr,
&sensor_dev_attr_model.dev_attr.attr,
&sensor_dev_attr_phy_reset.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_1.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_2.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_3.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_4.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_5.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_6.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_7.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_8.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_9.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_10.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_11.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_12.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_13.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_14.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_15.dev_attr.attr,
&sensor_dev_attr_QSFP_reset_16.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_all.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_1.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_2.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_3.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_4.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_5.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_6.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_7.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_8.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_9.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_10.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_11.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_12.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_13.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_14.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_15.dev_attr.attr,
&sensor_dev_attr_QSFP_low_power_16.dev_attr.attr,
// &sensor_dev_attr_QSFP_reset.dev_attr.attr,
&sensor_dev_attr_QSFP_present_all.dev_attr.attr,
&sensor_dev_attr_QSFP_present_1.dev_attr.attr,
&sensor_dev_attr_QSFP_present_2.dev_attr.attr,
&sensor_dev_attr_QSFP_present_3.dev_attr.attr,
&sensor_dev_attr_QSFP_present_4.dev_attr.attr,
&sensor_dev_attr_QSFP_present_5.dev_attr.attr,
&sensor_dev_attr_QSFP_present_6.dev_attr.attr,
&sensor_dev_attr_QSFP_present_7.dev_attr.attr,
&sensor_dev_attr_QSFP_present_8.dev_attr.attr,
&sensor_dev_attr_QSFP_present_9.dev_attr.attr,
&sensor_dev_attr_QSFP_present_10.dev_attr.attr,
&sensor_dev_attr_QSFP_present_11.dev_attr.attr,
&sensor_dev_attr_QSFP_present_12.dev_attr.attr,
&sensor_dev_attr_QSFP_present_13.dev_attr.attr,
&sensor_dev_attr_QSFP_present_14.dev_attr.attr,
&sensor_dev_attr_QSFP_present_15.dev_attr.attr,
&sensor_dev_attr_QSFP_present_16.dev_attr.attr,
NULL
};
/* end of sysfs attributes for hwmon */
#ifdef PREVIOUS_CHECK_TYPE
static umode_t phy_cpld640_is_attribute_visible(struct kobject *kobj,
struct attribute *attr, int n)
{
struct device *dev = kobj_to_dev(kobj);
struct Cameo_i2c_data *data = dev_get_drvdata(dev);
umode_t mode = attr->mode;
if (attr == &sensor_dev_attr_QSFP_reset_5.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_6.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_7.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_8.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_9.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_10.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_11.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_12.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_13.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_14.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_15.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_reset_16.dev_attr.attr){
if (data->model_type == MODEL_TYPE_400G)
mode = 0;
}
if (attr == &sensor_dev_attr_QSFP_low_power_5.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_6.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_7.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_8.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_9.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_10.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_11.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_12.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_13.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_14.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_15.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_low_power_16.dev_attr.attr){
if (data->model_type == MODEL_TYPE_400G)
mode = 0;
}
if (attr == &sensor_dev_attr_QSFP_present_5.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_6.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_7.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_8.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_9.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_10.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_11.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_12.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_13.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_14.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_15.dev_attr.attr ||
attr == &sensor_dev_attr_QSFP_present_16.dev_attr.attr){
if (data->model_type == MODEL_TYPE_400G)
mode = 0;
}
return mode;
}
#else
static u8 get_model_type(struct i2c_client *client, struct Cameo_i2c_data *data)
{
u8 card_model = -EPERM;
mutex_lock(&data->update_lock);
card_model = i2c_smbus_read_byte_data(client, 0xb0);
mutex_unlock(&data->update_lock);
switch (card_model)
{
case 0x00:
case 0x10:
return MODEL_TYPE_100G;
case 0x01:
case 0x11:
return MODEL_TYPE_400G;
default:
return MODEL_TYPE_UNKNOWN;
}
}
#endif //PREVIOUS_CHECK_TYPE
static const struct attribute_group phy_cpld640_QSFP_group =
{
#ifdef PREVIOUS_CHECK_TYPE
.is_visible = phy_cpld640_is_attribute_visible,
#endif
.attrs = phy_cpld640_QSFP_attributes,
};
/*function */
static ssize_t portnum_get(struct device *dev, struct device_attribute *da, char *buf)
{
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
u8 res = 0;
sprintf(buf, "\n");
if (attr->index == SLOT_PORTNUM)
{
#ifdef PREVIOUS_CHECK_TYPE
if (data->model_type == MODEL_TYPE_100G)
res = 16;
else if (data->model_type == MODEL_TYPE_400G)
res = 4;
#else
if (get_model_type(client, data) == MODEL_TYPE_100G)
res = 16;
else if (get_model_type(client, data) == MODEL_TYPE_400G)
res = 4;
#endif
else
res = 0;
}
return sprintf(buf, "%s%d\n", buf, res);
}
/********************************************************************************/
/* Function Name : model_get */
/* Description : This is the function to get module id 100G/400G */
/* */
/* Input(s) : None. */
/* Output(s) : None. */
/* Returns : String. */
/********************************************************************************/
static ssize_t model_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 card_model = -EPERM;
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
if (attr->index == SLOT_MODEL)
{
mutex_lock(&data->update_lock);
card_model = i2c_smbus_read_byte_data(client, 0xb0);
mutex_unlock(&data->update_lock);
if (card_model < 0)
{
return sprintf(buf, "%serr(%d)\n", buf, card_model);
}
if (card_model == 0x00) //Inphi 100G 16 Port
{
sprintf(buf, "%sInphi 100G", buf);
}
else if(card_model == 0x01) //Inphi 400G 4 Port
{
sprintf(buf, "%sInphi 400G", buf);
}
else if(card_model == 0x10) //Credo 100G 16 Port
{
sprintf(buf, "%sCredo 100G", buf);
}
else if(card_model == 0x11) //Credo 400G 4 Port
{
sprintf(buf, "%sCredo 400G", buf);
}
else
{
sprintf(buf, "%sUnknown", buf);
}
}
return sprintf(buf, "%s\n", buf);
}
/********************************************************************************/
/* Function Name : slot_phy_reset_set */
/* Description : This is the function to reset PHY module */
/* */
/* Input(s) : PHY module number. */
/* Output(s) : None. */
/* Returns : None. */
/********************************************************************************/
static ssize_t phy_reset_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 status = -EPERM;
u8 value = -EPERM;
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
int input = 0;
input = simple_strtol(buf, NULL, 10);
if (input == 0 || input == 1)
{
if(input == 0)
{
value = 0x00; //turn off
}
else if (input == 1)
{
value = 0xff; //turn on
}
printk(KERN_ALERT "phy_reset_set value = %x\n", value);
mutex_lock(&data->update_lock);
status = i2c_smbus_write_byte_data(client, 0xa0, value); //to reset phy
mutex_unlock(&data->update_lock);
if(status < 0)
{
printk(KERN_ALERT "ERROR: phy_reset_set FAILED\n");
return count;
}
printk(KERN_ALERT "phy_reset_set set value Done\n");
}
else
{
printk(KERN_ALERT "phy_reset_set wrong value\n");
return count;
}
return count;
}
#ifdef ESC_600_INT_WANTED
/********************************************************************************/
/* Function Name : qsfp_int_get */
/* Description : This is the function to get qsfp interrupt status */
/* 0x33 0xd0 */
/* Input(s) : None. */
/* Output(s) : None. */
/* Returns : String. */
/********************************************************************************/
static ssize_t QSFP_int_get(struct device *dev, struct device_attribute *da, char *buf)
{
u32 qsfp_stat = 0;
u8 res = 0;
u8 max_port_num = 4;
int l;
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
u8 model_type = MODEL_TYPE_UNKNOWN;
if (attr->index == QSFP_INT)
{
#ifdef PREVIOUS_CHECK_TYPE
model_type = data->model_type;
#else
model_type = get_model_type(client, data);
#endif
if (model_type == MODEL_TYPE_UNKNOWN)
return sprintf(buf, "%sTYPEERR\n", buf);
res = i2c_smbus_read_byte_data(client, 0x90); //to get register 0x32 0x90
qsfp_stat = res;
if (model_type == MODEL_TYPE_100G)
{
max_port_num = 16;
qsfp_stat = i2c_smbus_read_byte_data(client, 0x91); //to get register 0x32 0x91
qsfp_stat = (qsfp_stat<<8) | res;
}
debug_print((KERN_DEBUG "DEBUG : QSFP_int_get status = %x\n", qsfp_stat));
for (l = 1; l <= max_port_num; l++)
{
if (qsfp_stat & 0x01)
{
sprintf(buf, "%sQSFP %03d is abnormal\n", buf, l);
}
else
{
sprintf(buf, "%sQSFP %03d is OK\n", buf, l);
}
qsfp_stat = qsfp_stat >> 1;
}
}
return sprintf(buf, "%s\n", buf);
}
#endif
/*0x32 PHY CPLD*/
/********************************************************************************/
/* Function Name : low_power_all_get */
/* Description : This is the function to get all QSFP low power mode */
/* 0x32 0x60 0x61 */
/* Input(s) : None. */
/* Output(s) : None. */
/* Returns : String. */
/********************************************************************************/
static ssize_t low_power_all_get(struct device *dev, struct device_attribute *da, char *buf)
{
u32 qsfp_stat = 0;
u8 res = 0;
u8 max_port_num = 4;
u8 model_type = MODEL_TYPE_UNKNOWN;
int l;
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
if (attr->index == QSFP_LOW_POWER_ALL)
{
#ifdef PREVIOUS_CHECK_TYPE
model_type = data->model_type;
#else
model_type = get_model_type(client, data);
#endif
if (model_type == MODEL_TYPE_UNKNOWN)
return sprintf(buf, "%sTYPEERR\n", buf);
res = i2c_smbus_read_byte_data(client, 0x60); //to get register 0x32 0x60
qsfp_stat = res;
if (model_type == MODEL_TYPE_100G)
{
max_port_num = 16;
qsfp_stat = i2c_smbus_read_byte_data(client, 0x61); //to get register 0x32 0x61
qsfp_stat = (qsfp_stat<<8) | res;
}
debug_print((KERN_DEBUG "DEBUG : low_power_all_get status = %x\n",qsfp_stat));
for (l = 1; l <= max_port_num; l++)
{
if (qsfp_stat & 0x01)
{
sprintf(buf, "%sQSFP %02d low power mode: ON\n", buf, l);
}
else
{
sprintf(buf, "%sQSFP %02d low power mode: OFF\n", buf, l);
}
qsfp_stat = qsfp_stat >>1;
}
}
return sprintf(buf, "%s\n", buf);
}
/********************************************************************************/
/* Function Name : low_power_all_set */
/* Description : This is the function to set all QSFP low power mode */
/* 0x32 0x60 0x61 */
/* Input(s) : 1 or 0. */
/* Output(s) : None. */
/* Returns : None. */
/********************************************************************************/
static ssize_t low_power_all_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 value = 0x0;
u8 result = 0;
u8 enable = 0;
u8 model_type = MODEL_TYPE_UNKNOWN;
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
if (attr->index == QSFP_LOW_POWER_ALL)
{
enable = simple_strtol(buf, NULL, 10);
if (enable == TURN_ON)
{
value = 0xff;
}
else if(enable == TURN_OFF)
{
value = 0x0;
}
else
{
printk(KERN_ALERT "QSFP_LOW_POWER_ALL set wrong value\n");
}
#ifdef PREVIOUS_CHECK_TYPE
model_type = data->model_type;
#else
model_type = get_model_type(client, data);
#endif
if (model_type == MODEL_TYPE_UNKNOWN)
{
printk(KERN_ALERT "ERROR: QSFP_LOW_POWER_ALL type ERR\n");
return count;
}
mutex_lock(&data->update_lock);
result = i2c_smbus_write_byte_data(client, 0x60, value); //to set register 0x32 0x60
mutex_unlock(&data->update_lock);
if (model_type == MODEL_TYPE_100G)
{
mutex_lock(&data->update_lock);
result = i2c_smbus_write_byte_data(client, 0x61, value); //to set register 0x32 0x61
mutex_unlock(&data->update_lock);
}
if (result < 0)
{
printk(KERN_ALERT "ERROR: QSFP_LOW_POWER_ALL set FAILED!\n");
}
else
{
debug_print((KERN_DEBUG "QSFP_LOW_POWER_ALL set %d\n", enable));
}
}
return count;
}
/********************************************************************************/
/* Function Name : low_power_get */
/* Description : This is the function to get QSFP low power mode */
/* 0x32 0x60 0x61 */
/* Input(s) : None. */
/* Output(s) : None. */
/* Returns : String. */
/********************************************************************************/
static ssize_t low_power_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 ret = -EPERM;
u8 reg = 0;
u8 offset = 0;
u8 model_type = MODEL_TYPE_UNKNOWN;
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
#ifdef PREVIOUS_CHECK_TYPE
model_type = data->model_type;
#else
model_type = get_model_type(client, data);
#endif
if (model_type == MODEL_TYPE_UNKNOWN)
return sprintf(buf, "TYPEERR\n");
#ifndef PREVIOUS_CHECK_TYPE
if (model_type == MODEL_TYPE_400G)
{
if (attr->index > 4)
return sprintf(buf, "out of range\n");
}
#endif
if (attr->index <= 8)
{
reg = 0x60;
offset = attr->index-1;
}
else
{
reg = 0x61;
offset = attr->index-9;
}
ret = i2c_smbus_read_byte_data(client, reg);
if (ret < 0)
{
return sprintf(buf, "%serr(%d)\n", buf, ret);
}
ret = (ret>>offset) & 0x1;
return sprintf(buf, "%s%d\n", buf, ret);
}
/********************************************************************************/
/* Function Name : low_power_set */
/* Description : This is the function to set QSFP low power mode */
/* 0x32 0x60 0x61 */
/* Input(s) : None. */
/* Output(s) : None. */
/* Returns : None. */
/********************************************************************************/
static ssize_t low_power_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 ret = -EPERM;
u8 value = 0;
u8 reg = 0;
u8 offset = 0;
u8 input;
u8 model_type = MODEL_TYPE_UNKNOWN;
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
#ifdef PREVIOUS_CHECK_TYPE
model_type = data->model_type;
#else
model_type = get_model_type(client, data);
#endif
if (model_type == MODEL_TYPE_UNKNOWN)
{
printk(KERN_ALERT "low_power_set type ERR\n");
return count;
}
#ifndef PREVIOUS_CHECK_TYPE
if (model_type == MODEL_TYPE_400G)
{
if (attr->index > 4)
{
printk(KERN_ALERT "low_power_set out of range\n");
return count;
}
}
#endif
input = simple_strtol(buf, NULL, 10);
if(input == 0 || input == 1)
{
if (attr->index <= 8)
{
reg = 0x60;
offset = attr->index-1;
}
else {
reg = 0x61;
offset = attr->index-9;
}
if (model_type == MODEL_TYPE_400G && reg == 0x61)
{
printk(KERN_ALERT "low_power_set out of range\n");
return count;
}
// read current setting
ret = i2c_smbus_read_byte_data(client, reg);
if (ret < 0)
{
printk(KERN_ALERT "low_power_set read err(%d)\n", ret);
return count;
}
// set new setting
if (input == 0)
value = ret & ( ~(1<<offset) );
else if (input == 1)
value = ret | (1<<offset);
mutex_lock(&data->update_lock);
ret = i2c_smbus_write_byte_data(client, reg, value); //to set register 0x32 0x60
mutex_unlock(&data->update_lock);
if (ret < 0)
{
printk(KERN_ALERT "low_power_set write err(%d)\n", ret);
}
}
else
{
printk(KERN_ALERT "low_power_set wrong value\n");
return count;
}
return count;
}
/********************************************************************************/
/* Function Name : qsfp_reset_set */
/* Description : This is the function to reset QSFP module */
/* 0x32 0x70 0x71 */
/* Input(s) : None. */
/* Output(s) : None. */
/* Returns : None. */
/********************************************************************************/
static ssize_t qsfp_reset_set(struct device *dev, struct device_attribute *da, const char *buf, size_t count)
{
u8 ret = -EPERM;
u8 value = 0;
u8 offset = 0;
u8 reg = 0;
u8 model_type = MODEL_TYPE_UNKNOWN;
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
#ifdef PREVIOUS_CHECK_TYPE
model_type = data->model_type;
#else
model_type = get_model_type(client, data);
#endif
if (model_type == MODEL_TYPE_UNKNOWN)
{
printk(KERN_ALERT "qsfp_reset_set type ERR\n");
return count;
}
#ifndef PREVIOUS_CHECK_TYPE
if (model_type == MODEL_TYPE_400G)
{
if (attr->index > 4)
{
printk(KERN_ALERT "qsfp_reset_set out of range\n");
return count;
}
}
#endif
if (attr->index == QSFP_RESET)
{
if (attr->index <= 8)
{
reg = 0x70;
offset = attr->index-1;
}
else
{
reg = 0x71;
offset = attr->index-9;
}
debug_print((KERN_DEBUG "DEBUG : qsfp_reset_set port %03d\n", attr->index));
value = ret & ( ~( 1<<offset ));
mutex_lock(&data->update_lock);
i2c_smbus_write_byte_data(client, reg, value); //to set register 0x32 0x70
mutex_unlock(&data->update_lock);
debug_print((KERN_DEBUG "DEBUG : qsfp_reset_set_%03d set = %x\n", attr->index, value));
if (ret < 0)
{
printk(KERN_ALERT "qsfp_reset_set write err(%d)\n", ret);
}
}
return count;
}
/********************************************************************************/
/* Function Name : QSFP_status_all_get */
/* Description : This is the function to get all QSFP insert status */
/* 0x32 0x80 0x81 */
/* Input(s) : None. */
/* Output(s) : None. */
/* Returns : String. */
/********************************************************************************/
static ssize_t QSFP_status_all_get(struct device *dev, struct device_attribute *da, char *buf)
{
u32 qsfp_stat = 0;
u8 res = 0;
u8 max_port_num = 4;
u8 model_type = MODEL_TYPE_UNKNOWN;
int port_num;
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
if (attr->index == QSFP_PRESENT)
{
res = i2c_smbus_read_byte_data(client, 0x80); //to get register 0x32 0x80
qsfp_stat = res;
#ifdef PREVIOUS_CHECK_TYPE
model_type = data->model_type;
#else
model_type = get_model_type(client, data);
#endif
if (model_type == MODEL_TYPE_UNKNOWN)
return sprintf(buf, "TYPEERR\n");
if (model_type == MODEL_TYPE_100G)
{
max_port_num = 16;
qsfp_stat = i2c_smbus_read_byte_data(client, 0x81); //to get register 0x32 0x81
qsfp_stat = (qsfp_stat<<8) | res;
}
debug_print((KERN_DEBUG "DEBUG : QSFP_status_all_get status = %x\n",qsfp_stat));
for (port_num = 1; port_num <= max_port_num; port_num++)
{
if (qsfp_stat & 0x01)
{
sprintf(buf, "%sQSFP %02d is not present\n", buf, port_num);
}
else
{
sprintf(buf, "%sQSFP %02d is present\n", buf, port_num);
}
qsfp_stat = qsfp_stat >> 1;
}
}
return sprintf(buf, "%s\n", buf);
}
/********************************************************************************/
/* Function Name : qsfp_status_get */
/* Description : This is the function to get QSFP insert status */
/* 0x32 0x80 0x81 */
/* Input(s) : attr->index. */
/* Output(s) : None. */
/* Returns : String. */
/********************************************************************************/
static ssize_t qsfp_status_get(struct device *dev, struct device_attribute *da, char *buf)
{
u8 ret = -EPERM;
u8 reg = 0;
u8 offset = 0;
u8 model_type = MODEL_TYPE_UNKNOWN;
struct i2c_client *client = to_i2c_client(dev);
struct Cameo_i2c_data *data = i2c_get_clientdata(client);
struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
#ifdef PREVIOUS_CHECK_TYPE
model_type = data->model_type;
#else
model_type = get_model_type(client, data);
#endif
if (model_type == MODEL_TYPE_UNKNOWN)
return sprintf(buf, "TYPEERR\n");
#ifndef PREVIOUS_CHECK_TYPE
if (model_type == MODEL_TYPE_400G)
{
if (attr->index > 4)
return sprintf(buf, "out of range\n");
}
#endif
if (attr->index <= 8)
{
reg = 0x80;
offset = attr->index-1;
}
else
{
reg = 0x81;
offset = attr->index-9;
}
ret = i2c_smbus_read_byte_data(client, reg);
if (ret < 0)
{
return sprintf(buf, "%serr(%d)\n", buf, ret);
}
ret = (ret>>offset) & 0x1;
return sprintf(buf, "%s%d\n", buf, ((ret)?0:1));
}
/* end of function */
/********************************************************************************/
/* Function Name : Cameo_i2c_probe */
/* Description : To probe i2c device */
/* */
/* Input(s) : None. */
/* Output(s) : None. */
/* Returns : None. */
/********************************************************************************/
static int phy_cpld640_probe(struct i2c_client *client, const struct i2c_device_id *dev_id)
{
struct Cameo_i2c_data *data;
#ifdef PREVIOUS_CHECK_TYPE
u8 card_model;
#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 "Cameo_PHY_CPLD_data kzalloc fail\n");
status = -ENOMEM;
goto exit;
}
i2c_set_clientdata(client, data);
mutex_init(&data->update_lock);
data->valid = 0;
dev_info(&client->dev, "chip found\n");
#ifdef PREVIOUS_CHECK_TYPE
/* check model type */
mutex_lock(&data->update_lock);
card_model = i2c_smbus_read_byte_data(client, 0xb0);
mutex_unlock(&data->update_lock);
if (card_model < 0)
{
status = -EPERM;
goto exit_free;
}
switch (card_model)
{
case 0x00:
case 0x10:
data->model_type = MODEL_TYPE_100G;
break;
case 0x01:
case 0x11:
data->model_type = MODEL_TYPE_400G;
break;
default:
return -EPERM;
}
#endif
/* Register sysfs hooks */
status = sysfs_create_group(&client->dev.kobj, &phy_cpld640_QSFP_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, &phy_cpld640_QSFP_group);
exit_free:
kfree(data);
exit:
return status;
}
static int phy_cpld640_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, &phy_cpld640_QSFP_group);
kfree(data);
return 0;
}
static const struct i2c_device_id phy_cpld640_id[] =
{
{ "phy_cpld640", 0 },
{},
};
MODULE_DEVICE_TABLE(i2c, phy_cpld640_id);
static struct i2c_driver phy_cpld640_driver =
{
.class = I2C_CLASS_HWMON,
.driver =
{
.name = "phy_cpld640",
},
.probe = phy_cpld640_probe,
.remove = phy_cpld640_remove,
.id_table = phy_cpld640_id,
.address_list = normal_i2c,
};
module_i2c_driver(phy_cpld640_driver)
MODULE_AUTHOR("Cameo Inc.");
MODULE_DESCRIPTION("Cameo phy_cpld640 i2c driver");
MODULE_LICENSE("GPL");
Reference in New Issue Copy Permalink